diff --git a/mythtv/configure b/mythtv/configure
index ea14b046099..fc7fc9f5252 100755
--- a/mythtv/configure
+++ b/mythtv/configure
@@ -173,6 +173,7 @@ EOF
 <<EOF
 Help options:
   --help                   print this message
+  --quiet                  Suppress showing informative output
   --list-decoders          show all available decoders
   --list-encoders          show all available encoders
   --list-hwaccels          show all available hardware accelerators
@@ -186,10 +187,10 @@ Help options:
   --list-filters           show all available filters
 
 Standard options:
-  --logfile=FILE           log tests and output to FILE [config.log]
+  --logfile=FILE           log tests and output to FILE [ffbuild/config.log]
   --disable-logging        do not log configure debug information
   --fatal-warnings         fail if any configure warning is generated
-  --prefix=PREFIX          install in PREFIX [$prefix]
+  --prefix=PREFIX          install in PREFIX [$prefix_default]
   --bindir=DIR             install binaries in DIR [PREFIX/bin]
   --datadir=DIR            install data files in DIR [PREFIX/share/ffmpeg]
   --docdir=DIR             install documentation in DIR [PREFIX/share/doc/ffmpeg]
@@ -200,7 +201,7 @@ Standard options:
   --pkgconfigdir=DIR       install pkg-config files in DIR [LIBDIR/pkgconfig]
   --enable-rpath           use rpath to allow installing libraries in paths
                            not part of the dynamic linker search path
-                           use rpath when linking programs [USE WITH CARE]
+                           use rpath when linking programs (USE WITH CARE)
   --install-name-dir=DIR   Darwin directory name for installed targets
 
 Licensing options:
@@ -214,11 +215,11 @@ Configuration options:
   --disable-static         do not build static libraries [no]
   --enable-shared          build shared libraries [no]
   --enable-small           optimize for size instead of speed
-  --disable-runtime-cpudetect disable detecting cpu capabilities at runtime (smaller binary)
+  --disable-runtime-cpudetect disable detecting CPU capabilities at runtime (smaller binary)
   --enable-gray            enable full grayscale support (slower color)
   --disable-swscale-alpha  disable alpha channel support in swscale
   --disable-all            disable building components, libraries and programs
-  --enable-raise-major     increase major version numbers in sonames [no]
+  --disable-autodetect     disable automatically detected external libraries [no]
 
 Program options:
   --disable-programs       do not build command line programs
@@ -294,6 +295,7 @@ Individual component options:
   --enable-filter=NAME     enable filter NAME
   --disable-filter=NAME    disable filter NAME
   --disable-filters        disable all filters
+  --disable-v4l2_m2m       disable V4L2 mem2mem code [autodetect]
 
 External library support:
 
@@ -310,8 +312,12 @@ External library support:
   Also note that the following help text describes the purpose of the libraries
   themselves, not all their features will necessarily be usable by FFmpeg.
 
+  --disable-alsa           disable ALSA support [autodetect]
+  --disable-appkit         disable Apple AppKit framework [autodetect]
+  --disable-avfoundation   disable Apple AVFoundation framework [autodetect]
   --enable-avisynth        enable reading of AviSynth script files [no]
   --disable-bzlib          disable bzlib [autodetect]
+  --disable-coreimage      disable Apple CoreImage framework [autodetect]
   --enable-chromaprint     enable audio fingerprinting with chromaprint [no]
   --enable-frei0r          enable frei0r video filtering [no]
   --enable-gcrypt          enable gcrypt, needed for rtmp(t)e support
@@ -321,6 +327,7 @@ External library support:
   --enable-gnutls          enable gnutls, needed for https support
                            if openssl is not used [no]
   --disable-iconv          disable iconv [autodetect]
+  --disable-jack           disable libjack support [autodetect]
   --enable-jni             enable JNI support [no]
   --enable-ladspa          enable LADSPA audio filtering [no]
   --enable-libass          enable libass subtitles rendering,
@@ -332,8 +339,6 @@ External library support:
   --enable-libcdio         enable audio CD grabbing with libcdio [no]
   --enable-libdc1394       enable IIDC-1394 grabbing using libdc1394
                            and libraw1394 [no]
-  --enable-libebur128      enable libebur128 for EBU R128 measurement,
-                           needed for loudnorm filter [no]
   --enable-libfdk-aac      enable AAC de/encoding via libfdk-aac [no]
   --enable-libflite        enable flite (voice synthesis) support via libflite [no]
   --enable-libfontconfig   enable libfontconfig, useful for drawtext filter [no]
@@ -346,8 +351,6 @@ External library support:
   --enable-libkvazaar      enable HEVC encoding via libkvazaar [no]
   --enable-libmodplug      enable ModPlug via libmodplug [no]
   --enable-libmp3lame      enable MP3 encoding via libmp3lame [no]
-  --enable-libnut          enable NUT (de)muxing via libnut,
-                           native (de)muxer exists [no]
   --enable-libopencore-amrnb enable AMR-NB de/encoding via libopencore-amrnb [no]
   --enable-libopencore-amrwb enable AMR-WB decoding via libopencore-amrwb [no]
   --enable-libopencv       enable video filtering via libopencv [no]
@@ -356,9 +359,9 @@ External library support:
   --enable-libopenmpt      enable decoding tracked files via libopenmpt [no]
   --enable-libopus         enable Opus de/encoding via libopus [no]
   --enable-libpulse        enable Pulseaudio input via libpulse [no]
+  --enable-librsvg         enable SVG rasterization via librsvg [no]
   --enable-librubberband   enable rubberband needed for rubberband filter [no]
   --enable-librtmp         enable RTMP[E] support via librtmp [no]
-  --enable-libschroedinger enable Dirac de/encoding via libschroedinger [no]
   --enable-libshine        enable fixed-point MP3 encoding via libshine [no]
   --enable-libsmbclient    enable Samba protocol via libsmbclient [no]
   --enable-libsnappy       enable Snappy compression, needed for hap encoding [no]
@@ -370,6 +373,7 @@ External library support:
   --enable-libtwolame      enable MP2 encoding via libtwolame [no]
   --enable-libv4l2         enable libv4l2/v4l-utils [no]
   --enable-libvidstab      enable video stabilization using vid.stab [no]
+  --enable-libvmaf         enable vmaf filter via libvmaf [no]
   --enable-libvo-amrwbenc  enable AMR-WB encoding via libvo-amrwbenc [no]
   --enable-libvorbis       enable Vorbis en/decoding via libvorbis,
                            native implementation exists [no]
@@ -385,39 +389,44 @@ External library support:
   --enable-libxcb-shape    enable X11 grabbing shape rendering [autodetect]
   --enable-libxvid         enable Xvid encoding via xvidcore,
                            native MPEG-4/Xvid encoder exists [no]
+  --enable-libxml2         enable XML parsing using the C library libxml2 [no]
   --enable-libzimg         enable z.lib, needed for zscale filter [no]
   --enable-libzmq          enable message passing via libzmq [no]
   --enable-libzvbi         enable teletext support via libzvbi [no]
   --disable-lzma           disable lzma [autodetect]
   --enable-decklink        enable Blackmagic DeckLink I/O support [no]
+  --enable-libndi_newtek   enable Newteck NDI I/O support [no]
   --enable-mediacodec      enable Android MediaCodec support [no]
-  --enable-netcdf          enable NetCDF, needed for sofalizer filter [no]
+  --enable-libmysofa       enable libmysofa, needed for sofalizer filter [no]
   --enable-openal          enable OpenAL 1.1 capture support [no]
   --enable-opencl          enable OpenCL code
   --enable-opengl          enable OpenGL rendering [no]
   --enable-openssl         enable openssl, needed for https support
                            if gnutls is not used [no]
+  --disable-sndio          disable sndio support [autodetect]
   --disable-schannel       disable SChannel SSP, needed for TLS support on
                            Windows if openssl and gnutls are not used [autodetect]
   --disable-sdl2           disable sdl2 [autodetect]
   --disable-securetransport disable Secure Transport, needed for TLS support
                            on OSX if openssl and gnutls are not used [autodetect]
-  --enable-x11grab         enable X11 grabbing (legacy) [no]
   --disable-xlib           disable xlib [autodetect]
   --disable-zlib           disable zlib [autodetect]
 
   The following libraries provide various hardware acceleration features:
   --disable-audiotoolbox   disable Apple AudioToolbox code [autodetect]
-  --enable-cuda            enable dynamically linked Nvidia CUDA code [no]
-  --enable-cuvid           enable Nvidia CUVID support [autodetect]
+  --disable-cuda           disable dynamically linked Nvidia CUDA code [autodetect]
+  --enable-cuda-sdk        enable CUDA features that require the CUDA SDK [no]
+  --disable-cuvid          disable Nvidia CUVID support [autodetect]
   --disable-d3d11va        disable Microsoft Direct3D 11 video acceleration code [autodetect]
   --disable-dxva2          disable Microsoft DirectX 9 video acceleration code [autodetect]
+  --enable-libdrm          enable DRM code (Linux) [no]
   --enable-libmfx          enable Intel MediaSDK (AKA Quick Sync Video) code via libmfx [no]
   --enable-libnpp          enable Nvidia Performance Primitives-based code [no]
   --enable-mmal            enable Broadcom Multi-Media Abstraction Layer (Raspberry Pi) via MMAL [no]
   --disable-nvenc          disable Nvidia video encoding code [autodetect]
   --enable-omx             enable OpenMAX IL code [no]
   --enable-omx-rpi         enable OpenMAX IL code for Raspberry Pi [no]
+  --enable-rkmpp           enable Rockchip Media Process Platform code [no]
   --disable-vaapi          disable Video Acceleration API (mainly Unix/Intel) code [autodetect]
   --disable-vda            disable Apple Video Decode Acceleration code [autodetect]
   --disable-vdpau          disable Nvidia Video Decode and Presentation API for Unix code [autodetect]
@@ -444,11 +453,12 @@ Toolchain options:
   --ln_s=LN_S              use symbolic link tool LN_S [$ln_s_default]
   --strip=STRIP            use strip tool STRIP [$strip_default]
   --windres=WINDRES        use windows resource compiler WINDRES [$windres_default]
-  --yasmexe=EXE            use yasm-compatible assembler EXE [$yasmexe_default]
+  --x86asmexe=EXE          use nasm-compatible assembler EXE [$x86asmexe_default]
   --cc=CC                  use C compiler CC [$cc_default]
   --cxx=CXX                use C compiler CXX [$cxx_default]
   --objcc=OCC              use ObjC compiler OCC [$cc_default]
   --dep-cc=DEPCC           use dependency generator DEPCC [$cc_default]
+  --nvcc=NVCC              use Nvidia CUDA compiler NVCC [$nvcc_default]
   --ld=LD                  use linker LD [$ld_default]
   --pkg-config=PKGCONFIG   use pkg-config tool PKGCONFIG [$pkg_config_default]
   --pkg-config-flags=FLAGS pass additional flags to pkgconf []
@@ -470,6 +480,7 @@ Toolchain options:
   --extra-libs=ELIBS       add ELIBS [$ELIBS]
   --extra-version=STRING   version string suffix []
   --optflags=OPTFLAGS      override optimization-related compiler flags
+  --nvccflags=NVCCFLAGS    override nvcc flags [$nvccflags_default]
   --build-suffix=SUFFIX    library name suffix []
   --bdj-type=TYPE          Specify the type of BD-J implementation (j2se,
                            j2me) [$bdj_type]
@@ -486,7 +497,6 @@ Advanced options (experts only):
   --disable-safe-bitstream-reader
                            disable buffer boundary checking in bitreaders
                            (faster, but may crash)
-  --enable-memalign-hack   emulate memalign, interferes with memory debuggers
   --sws-max-filter-size=N  the max filter size swscale uses [$sws_max_filter_size_default]
 
 Optimization options (experts only):
@@ -516,7 +526,7 @@ Optimization options (experts only):
   --disable-vfp            disable VFP optimizations
   --disable-neon           disable NEON optimizations
   --disable-inline-asm     disable use of inline assembly
-  --disable-yasm           disable use of nasm/yasm assembly
+  --disable-x86asm         disable use of standalone x86 assembly
   --disable-mipsdsp        disable MIPS DSP ASE R1 optimizations
   --disable-mipsdspr2      disable MIPS DSP ASE R2 optimizations
   --disable-msa            disable MSA optimizations
@@ -553,6 +563,11 @@ Developer options (useful when working on FFmpeg itself):
   --random-seed=VALUE      seed value for --enable/disable-random
   --disable-valgrind-backtrace do not print a backtrace under Valgrind
                            (only applies to --disable-optimizations builds)
+  --enable-osfuzz          Enable building fuzzer tool
+  --libfuzzer=PATH         path to libfuzzer
+  --ignore-tests=TESTS     comma-separated list (without "fate-" prefix
+                           in the name) of tests whose result is ignored
+  --enable-linux-perf      enable Linux Performance Monitor API
 
 NOTE: Object files are built at the place where configure is launched.
 EOF
@@ -638,7 +653,7 @@ filter(){
     pat=$1
     shift
     for v; do
-        eval "case $v in $pat) echo $v ;; esac"
+        eval "case $v in $pat) printf '%s ' $v ;; esac"
     done
 }
 
@@ -646,7 +661,7 @@ filter_out(){
     pat=$1
     shift
     for v; do
-        eval "case $v in $pat) ;; *) echo $v ;; esac"
+        eval "case $v in $pat) ;; *) printf '%s ' $v ;; esac"
     done
 }
 
@@ -711,6 +726,13 @@ popvar(){
     done
 }
 
+request(){
+    for var in $*; do
+        eval ${var}_requested=yes
+        eval $var=
+    done
+}
+
 enable(){
     set_all yes $*
 }
@@ -767,6 +789,11 @@ enable_deep_weak(){
     done
 }
 
+requested(){
+    test "${1#!}" = "$1" && op='=' || op=!=
+    eval test "x\$${1#!}_requested" $op "xyes"
+}
+
 enabled(){
     test "${1#!}" = "$1" && op='=' || op=!=
     eval test "x\$${1#!}" $op "xyes"
@@ -819,7 +846,6 @@ is_in(){
 
 do_check_deps(){
     for cfg; do
-        cfg="${cfg#!}"
         enabled ${cfg}_checking && die "Circular dependency for $cfg."
         disabled ${cfg}_checking && continue
         enable ${cfg}_checking
@@ -827,20 +853,22 @@ do_check_deps(){
 
         eval dep_all="\$${cfg}_deps"
         eval dep_any="\$${cfg}_deps_any"
+        eval dep_con="\$${cfg}_conflict"
         eval dep_sel="\$${cfg}_select"
         eval dep_sgs="\$${cfg}_suggest"
         eval dep_ifa="\$${cfg}_if"
         eval dep_ifn="\$${cfg}_if_any"
 
-        pushvar cfg dep_all dep_any dep_sel dep_sgs dep_ifa dep_ifn
-        do_check_deps $dep_all $dep_any $dep_sel $dep_sgs $dep_ifa $dep_ifn
-        popvar cfg dep_all dep_any dep_sel dep_sgs dep_ifa dep_ifn
+        pushvar cfg dep_all dep_any dep_con dep_sel dep_sgs dep_ifa dep_ifn
+        do_check_deps $dep_all $dep_any $dep_con $dep_sel $dep_sgs $dep_ifa $dep_ifn
+        popvar cfg dep_all dep_any dep_con dep_sel dep_sgs dep_ifa dep_ifn
 
         [ -n "$dep_ifa" ] && { enabled_all $dep_ifa && enable_weak $cfg; }
         [ -n "$dep_ifn" ] && { enabled_any $dep_ifn && enable_weak $cfg; }
-        enabled_all  $dep_all || disable $cfg
-        enabled_any  $dep_any || disable $cfg
-        disabled_any $dep_sel && disable $cfg
+        enabled_all  $dep_all || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but not all dependencies are satisfied: $dep_all"; }
+        enabled_any  $dep_any || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but not any dependency is satisfied: $dep_any"; }
+        disabled_all $dep_con || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but some conflicting dependencies are unsatisfied: $dep_con"; }
+        disabled_any $dep_sel && { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but some selected dependency is unsatisfied: $dep_sel"; }
 
         if enabled $cfg; then
             enable_deep $dep_sel
@@ -931,6 +959,10 @@ add_cflags(){
     append CFLAGS $($cflags_filter "$@")
 }
 
+add_cflags_headers(){
+    append CFLAGS_HEADERS $($cflags_filter "$@")
+}
+
 add_cxxflags(){
     append ECXXFLAGS "$@"
 }
@@ -1081,12 +1113,12 @@ check_insn(){
     echo "$2" | check_as && enable ${1}_external || disable ${1}_external
 }
 
-check_yasm(){
-    log check_yasm "$@"
+check_x86asm(){
+    log check_x86asm "$@"
     echo "$1" > $TMPS
     log_file $TMPS
     shift 1
-    check_cmd $yasmexe $YASMFLAGS -Werror "$@" -o $TMPO $TMPS
+    check_cmd $x86asmexe $X86ASMFLAGS -Werror "$@" -o $TMPO $TMPS
 }
 
 ld_o(){
@@ -1128,8 +1160,8 @@ check_code(){
 
 check_cppflags(){
     log check_cppflags "$@"
-    check_cc "$@" <<EOF && append CPPFLAGS "$@"
-int x;
+    check_cpp "$@" <<EOF && append CPPFLAGS "$@"
+#include <stdlib.h>
 EOF
 }
 
@@ -1155,15 +1187,15 @@ EOF
 }
 
 test_objcflags(){
-    log test_cflags "$@"
-    set -- $($cflags_filter "$@")
+    log test_objcflags "$@"
+    set -- $($objcflags_filter "$@")
     check_objcc "$@" <<EOF
 int x;
 EOF
 }
 
 check_objcflags(){
-    log check_cflags "$@"
+    log check_objcflags "$@"
     test_objcflags "$@" && add_objcflags "$@"
 }
 
@@ -1213,7 +1245,16 @@ check_header_objcc(){
     {
        echo "#include <$header>"
        echo "int main(void) { return 0; }"
-    } | check_objcc && check_stat "$TMPO" && enable_safe $headers
+    } | check_objcc && check_stat "$TMPO" && enable_safe $header
+}
+
+check_apple_framework(){
+    log check_apple_framework "$@"
+    framework="$1"
+    name="$(tolower $framework)"
+    header="${framework}/${framework}.h"
+    disable $name
+    check_header_objcc $header && enable $name && add_extralibs "-framework $framework"
 }
 
 check_func(){
@@ -1265,10 +1306,16 @@ check_func_headers(){
         for hdr in $headers; do
             print_include $hdr
         done
+        echo "#include <stdint.h>"
         for func in $funcs; do
             echo "long check_$func(void) { return (long) $func; }"
         done
-        echo "int main(void) { return 0; }"
+        echo "int main(void) { int ret = 0;"
+        # LTO could optimize out the test functions without this
+        for func in $funcs; do
+            echo " ret |= ((intptr_t)check_$func) & 0xFFFF;"
+        done
+        echo "return ret; }"
     } | check_ld "cc" "$@" && enable $funcs && enable_safe $headers
 }
 
@@ -1304,20 +1351,30 @@ check_cpp_condition(){
 EOF
 }
 
-check_lib(){
-    log check_lib "$@"
-    header="$1"
-    func="$2"
-    shift 2
-    check_header $header && check_func $func "$@" && add_extralibs "$@"
+test_cflags_cc(){
+    log test_cflags_cc "$@"
+    flags=$1
+    header=$2
+    condition=$3
+    shift 3
+    set -- $($cflags_filter "$flags")
+    check_cc "$@" <<EOF
+#include <$header>
+#if !($condition)
+#error "unsatisfied condition: $condition"
+#endif
+EOF
 }
 
-check_lib2(){
-    log check_lib2 "$@"
-    headers="$1"
-    funcs="$2"
-    shift 2
-    check_func_headers "$headers" "$funcs" "$@" && add_extralibs "$@"
+check_lib(){
+    log check_lib "$@"
+    name="$1"
+    headers="$2"
+    funcs="$3"
+    shift 3
+    disable $name
+    check_func_headers "$headers" "$funcs" "$@" &&
+        enable $name && add_extralibs "$@"
 }
 
 check_lib_cpp(){
@@ -1330,17 +1387,20 @@ check_lib_cpp(){
 
 check_pkg_config(){
     log check_pkg_config "$@"
-    pkgandversion="$1"
-    pkg="${1%% *}"
-    headers="$2"
-    funcs="$3"
-    shift 3
-    check_cmd $pkg_config --exists --print-errors $pkgandversion || return
+    name="$1"
+    pkg_version="$2"
+    pkg="${2%% *}"
+    headers="$3"
+    funcs="$4"
+    shift 4
+    disable $name
+    check_cmd $pkg_config --exists --print-errors $pkg_version || return
     pkg_cflags=$($pkg_config --cflags $pkg_config_flags $pkg)
     pkg_libs=$($pkg_config --libs $pkg_config_flags $pkg)
     check_func_headers "$headers" "$funcs" $pkg_cflags $pkg_libs "$@" &&
-        set_safe "${pkg}_cflags" $pkg_cflags   &&
-        set_safe "${pkg}_libs"   $pkg_libs
+        enable $name &&
+        set_safe "${pkg}_cflags"    $pkg_cflags &&
+        set_safe "${pkg}_extralibs" $pkg_libs
 }
 
 check_exec(){
@@ -1348,6 +1408,7 @@ check_exec(){
 }
 
 check_exec_crash(){
+    log check_exec_crash "$@"
     code=$(cat)
 
     # exit() is not async signal safe.  _Exit (C99) and _exit (POSIX)
@@ -1418,19 +1479,13 @@ check_compile_assert(){
 }
 
 require(){
-    name="$1"
-    header="$2"
-    func="$3"
-    shift 3
-    check_lib $header $func "$@" || die "ERROR: $name not found"
-}
-
-require2(){
-    name="$1"
+    log require "$@"
+    name_version="$1"
+    name="${1%% *}"
     headers="$2"
     func="$3"
     shift 3
-    check_lib2 "$headers" $func "$@" || die "ERROR: $name not found"
+    check_lib $name "$headers" $func "$@" || die "ERROR: $name_version not found"
 }
 
 require_cpp(){
@@ -1441,35 +1496,33 @@ require_cpp(){
     check_lib_cpp "$headers" "$classes" "$@" || die "ERROR: $name not found"
 }
 
+require_header(){
+    log require "$@"
+    header="$1"
+    shift
+    check_header "$header" "$@" || die "ERROR: $header header not found"
+}
+
+require_cpp_condition(){
+    log require "$@"
+    header="$1"
+    condition="$2"
+    shift 2
+    check_cpp_condition "$header" "$condition" "$@" || die "ERROR: $condition not satisfied"
+}
+
 use_pkg_config(){
-    pkg="$1"
+    log use_pkg_config "$@"
+    pkg="${2%% *}"
     check_pkg_config "$@" || return 1
     add_cflags    $(get_safe "${pkg}_cflags")
-    add_extralibs $(get_safe "${pkg}_libs")
+    add_extralibs $(get_safe "${pkg}_extralibs")
 }
 
 require_pkg_config(){
-    use_pkg_config "$@" || die "ERROR: $pkg not found using pkg-config$pkg_config_fail_message"
-}
-
-require_libfreetype(){
-    log require_libfreetype "$@"
-    pkg="freetype2"
-    check_cmd $pkg_config --exists --print-errors $pkg \
-      || die "ERROR: $pkg not found"
-    pkg_cflags=$($pkg_config --cflags $pkg_config_flags $pkg)
-    pkg_libs=$($pkg_config --libs $pkg_config_flags $pkg)
-    {
-        echo "#include <ft2build.h>"
-        echo "#include FT_FREETYPE_H"
-        echo "long check_func(void) { return (long) FT_Init_FreeType; }"
-        echo "int main(void) { return 0; }"
-    } | check_ld "cc" $pkg_cflags $pkg_libs \
-      && set_safe "${pkg}_cflags" $pkg_cflags \
-      && set_safe "${pkg}_libs"   $pkg_libs \
-      || die "ERROR: $pkg not found"
-    add_cflags    $(get_safe "${pkg}_cflags")
-    add_extralibs $(get_safe "${pkg}_libs")
+    log require_pkg_config "$@"
+    pkg_version="$2"
+    use_pkg_config "$@" || die "ERROR: $pkg_version not found using pkg-config$pkg_config_fail_message"
 }
 
 hostcc_e(){
@@ -1496,8 +1549,8 @@ check_host_cpp(){
 
 check_host_cppflags(){
     log check_host_cppflags "$@"
-    check_host_cc "$@" <<EOF && append host_cppflags "$@"
-int x;
+    check_host_cpp "$@" <<EOF && append host_cppflags "$@"
+#include <stdlib.h>
 EOF
 }
 
@@ -1523,9 +1576,10 @@ EOF
 }
 
 cp_if_changed(){
-    cmp -s "$1" "$2" && echo "$2 is unchanged" && return
+    cmp -s "$1" "$2" && { test "$quiet" != "yes" && echo "$2 is unchanged"; } && return
     mkdir -p "$(dirname $2)"
-    $cp_f "$1" "$2"
+    cp -f "$1" "$2"
+    echo "Created $2"
 }
 
 # MythTV Custom Tests
@@ -1689,9 +1743,11 @@ AVDEVICE_COMPONENTS="
     indevs
     outdevs
 "
+
 AVFILTER_COMPONENTS="
     filters
 "
+
 AVFORMAT_COMPONENTS="
     demuxers
     muxers
@@ -1699,6 +1755,7 @@ AVFORMAT_COMPONENTS="
 "
 
 AVRESAMPLE_COMPONENTS=""
+
 AVUTIL_COMPONENTS=""
 
 COMPONENT_LIST="
@@ -1713,13 +1770,17 @@ COMPONENT_LIST="
 EXAMPLE_LIST="
     avio_dir_cmd_example
     avio_reading_example
-    decoding_encoding_example
+    decode_audio_example
+    decode_video_example
     demuxing_decoding_example
+    encode_audio_example
+    encode_video_example
     extract_mvs_example
     filter_audio_example
     filtering_audio_example
     filtering_video_example
     http_multiclient_example
+    hw_decode_example
     metadata_example
     muxing_example
     qsvdec_example
@@ -1730,28 +1791,76 @@ EXAMPLE_LIST="
     transcoding_example
 "
 
-EXTERNAL_LIBRARY_LIST="
-    avisynth
+EXTERNAL_AUTODETECT_LIBRARY_LIST="
+    alsa
+    appkit
+    avfoundation
     bzlib
-    chromaprint
-    crystalhd
-    decklink
+    coreimage
+    iconv
+    jack
+    libxcb
+    libxcb_shm
+    libxcb_shape
+    libxcb_xfixes
+    lzma
+    schannel
+    sdl2
+    securetransport
+    sndio
+    xlib
+    zlib
+"
+
+EXTERNAL_LIBRARY_GPL_LIST="
+    avisynth
     frei0r
-    gcrypt
+    libcdio
+    librubberband
+    libvidstab
+    libx264
+    libx265
+    libxavs
+    libxvid
+"
+
+EXTERNAL_LIBRARY_NONFREE_LIST="
+    decklink
+    libndi_newtek
+    libfdk_aac
+    openssl
+"
+
+EXTERNAL_LIBRARY_VERSION3_LIST="
     gmp
+    libopencore_amrnb
+    libopencore_amrwb
+    libvo_amrwbenc
+    rkmpp
+"
+
+EXTERNAL_LIBRARY_GPLV3_LIST="
+    libsmbclient
+"
+
+EXTERNAL_LIBRARY_LIST="
+    $EXTERNAL_AUTODETECT_LIBRARY_LIST
+    $EXTERNAL_LIBRARY_GPL_LIST
+    $EXTERNAL_LIBRARY_NONFREE_LIST
+    $EXTERNAL_LIBRARY_VERSION3_LIST
+    $EXTERNAL_LIBRARY_GPLV3_LIST
+    chromaprint
+    gcrypt
     gnutls
-    iconv
     jni
     ladspa
     libass
     libbluray
     libbs2b
     libcaca
-    libcdio
     libcelt
     libdc1394
-    libebur128
-    libfdk_aac
+    libdrm
     libflite
     libfontconfig
     libfreetype
@@ -1763,18 +1872,15 @@ EXTERNAL_LIBRARY_LIST="
     libkvazaar
     libmodplug
     libmp3lame
-    libnut
-    libopencore_amrnb
-    libopencore_amrwb
+    libmysofa
     libopencv
     libopenh264
     libopenjpeg
     libopenmpt
     libopus
     libpulse
+    librsvg
     librtmp
-    librubberband
-    libschroedinger
     libshine
     libsmbclient
     libsnappy
@@ -1785,58 +1891,50 @@ EXTERNAL_LIBRARY_LIST="
     libtheora
     libtwolame
     libv4l2
-    libvidstab
-    libvo_amrwbenc
+    libvmaf
     libvorbis
     libvpx
     libwavpack
     libwebp
-    libx264
-    libx265
-    libxavs
-    libxcb
-    libxcb_shm
-    libxcb_shape
-    libxcb_xfixes
-    libxvid
+    libxml2
     libzimg
     libzmq
     libzvbi
-    lzma
     mediacodec
-    netcdf
     openal
     opencl
     opengl
-    openssl
-    schannel
-    sdl
-    sdl2
-    securetransport
-    videotoolbox
-    x11grab
-    xlib
-    zlib
 "
 
-HWACCEL_LIBRARY_LIST="
+HWACCEL_AUTODETECT_LIBRARY_LIST="
     audiotoolbox
+    crystalhd
     cuda
     cuvid
     d3d11va
     dxva2
-    libmfx
-    libnpp
-    mmal
     nvenc
-    omx
     vaapi
     vda
     vdpau
-    videotoolbox_hwaccel
+    videotoolbox
+    v4l2_m2m
     xvmc
 "
 
+HWACCEL_LIBRARY_NONFREE_LIST="
+    cuda_sdk
+    libnpp
+"
+
+HWACCEL_LIBRARY_LIST="
+    $HWACCEL_AUTODETECT_LIBRARY_LIST
+    $HWACCEL_LIBRARY_NONFREE_LIST
+    libmfx
+    mmal
+    omx
+"
+
 DOCUMENT_LIST="
     doc
     htmlpages
@@ -1898,8 +1996,8 @@ SUBSYSTEM_LIST="
     rdft
 "
 
+# COMPONENT_LIST needs to come last to ensure correct dependency checking
 CONFIG_LIST="
-    $COMPONENT_LIST
     $DOCUMENT_LIST
     $EXAMPLE_LIST
     $EXTERNAL_LIBRARY_LIST
@@ -1909,16 +2007,17 @@ CONFIG_LIST="
     $LIBRARY_LIST
     $PROGRAM_LIST
     $SUBSYSTEM_LIST
+    autodetect
     fontconfig
-    memalign_hack
+    linux_perf
     memory_poisoning
     neon_clobber_test
+    ossfuzz
     pic
-    pod2man
-    raise_major
     thumb
     valgrind_backtrace
     xmm_clobber_test
+    $COMPONENT_LIST
 "
 
 THREADS_LIST="
@@ -1933,6 +2032,12 @@ ATOMICS_LIST="
     atomics_win32
 "
 
+AUTODETECT_LIBS="
+    $EXTERNAL_AUTODETECT_LIBRARY_LIST
+    $HWACCEL_AUTODETECT_LIBRARY_LIST
+    $THREADS_LIST
+"
+
 ARCH_LIST="
     aarch64
     alpha
@@ -2040,11 +2145,11 @@ ARCH_FEATURES="
     local_aligned_16
     local_aligned_32
     simd_align_16
+    simd_align_32
 "
 
 BUILTIN_LIST="
     atomic_cas_ptr
-    atomic_compare_exchange
     machine_rw_barrier
     MemoryBarrier
     mm_empty
@@ -2056,7 +2161,7 @@ BUILTIN_LIST="
 HAVE_LIST_CMDLINE="
     inline_asm
     symver
-    yasm
+    x86asm
 "
 
 HAVE_LIST_PUB="
@@ -2065,12 +2170,13 @@ HAVE_LIST_PUB="
 "
 
 HEADERS_LIST="
-    alsa_asoundlib_h
     altivec_h
     arpa_inet_h
     asm_types_h
     cdio_paranoia_h
     cdio_paranoia_paranoia_h
+    cuda_h
+    d3d11_h
     dispatch_dispatch_h
     dev_bktr_ioctl_bt848_h
     dev_bktr_ioctl_meteor_h
@@ -2080,7 +2186,7 @@ HEADERS_LIST="
     direct_h
     dirent_h
     dlfcn_h
-    d3d11_h
+    dxgidebug_h
     dxva_h
     ES2_gl_h
     EGL_egl_h
@@ -2093,13 +2199,15 @@ HEADERS_LIST="
     machine_ioctl_meteor_h
     malloc_h
     opencv2_core_core_c_h
+    openjpeg_2_3_openjpeg_h
+    openjpeg_2_2_openjpeg_h
     openjpeg_2_1_openjpeg_h
     openjpeg_2_0_openjpeg_h
     openjpeg_1_5_openjpeg_h
     OpenGL_gl3_h
     poll_h
-    sndio_h
     soundcard_h
+    stdatomic_h
     sys_mman_h
     sys_param_h
     sys_resource_h
@@ -2166,7 +2274,6 @@ SYSTEM_FUNCS="
     CommandLineToArgvW
     CoTaskMemFree
     CryptGenRandom
-    dlopen
     fcntl
     flt_lim
     fork
@@ -2218,11 +2325,13 @@ SYSTEM_FUNCS="
 
 TOOLCHAIN_FEATURES="
     as_dn_directive
+    as_fpu_directive
     as_func
     as_object_arch
     asm_mod_q
     attribute_may_alias
     attribute_packed
+    blocks_extension
     ebp_available
     ebx_available
     gnu_as
@@ -2242,6 +2351,7 @@ TOOLCHAIN_FEATURES="
 
 TYPES_LIST="
     CONDITION_VARIABLE_Ptr
+    kCMVideoCodecType_HEVC
     socklen_t
     struct_addrinfo
     struct_group_source_req
@@ -2277,25 +2387,20 @@ HAVE_LIST="
     $TYPES_LIST
     atomics_native
     dos_paths
-    dxva2_lib
-    dxva2api_cobj
     libc_msvcrt
-    libdc1394_1
-    libdc1394_2
     makeinfo
     makeinfo_html
     MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS
     perl
     pod2man
-    sdl2
     section_data_rel_ro
     texi2html
     threads
+    uwp
     vaapi_drm
     vaapi_x11
     vdpau_x11
     winrt
-    xlib
 "
 
 # options emitted with CONFIG_ prefix but not available on the command line
@@ -2322,15 +2427,17 @@ CONFIG_EXTRA="
     h263dsp
     h264chroma
     h264dsp
+    h264parse
     h264pred
     h264qpel
+    hevcparse
     hpeldsp
     huffman
     huffyuvdsp
     huffyuvencdsp
     idctdsp
     iirfilter
-    imdct15
+    mdct15
     intrax8
     iso_media
     ividsp
@@ -2339,12 +2446,14 @@ CONFIG_EXTRA="
     libx262
     llauddsp
     llviddsp
+    llvidencdsp
     lpc
     lzf
     me_cmp
     mpeg_er
     mpegaudio
     mpegaudiodsp
+    mpegaudioheader
     mpegvideo
     mpegvideoenc
     mss34dsp
@@ -2366,13 +2475,13 @@ CONFIG_EXTRA="
     texturedsp
     texturedspenc
     tpeldsp
+    vaapi_1
     vaapi_encode
     vc1dsp
     videodsp
     vp3dsp
     vp56dsp
     vp8dsp
-    vt_bt2020
     wma_freqs
     wmv2dsp
 "
@@ -2547,10 +2656,11 @@ CMDLINE_SET="
     gas
     host_cc
     host_cflags
+    host_extralibs
     host_ld
     host_ldflags
-    host_libs
     host_os
+    ignore_tests
     install
     ld
     ln_s
@@ -2558,6 +2668,7 @@ CMDLINE_SET="
     malloc_prefix
     nm
     optflags
+    nvccflags
     pkg_config
     pkg_config_flags
     progs_suffix
@@ -2575,7 +2686,7 @@ CMDLINE_SET="
     tempprefix
     toolchain
     valgrind
-    yasmexe
+    x86asmexe
     $MYTHTV_PATHS_LIST
     $MYTHTV_CMDLINE_SET
 "
@@ -2646,7 +2757,7 @@ fma3_deps="avx"
 fma4_deps="avx"
 avx2_deps="avx"
 
-mmx_external_deps="yasm"
+mmx_external_deps="x86asm"
 mmx_inline_deps="inline_asm"
 mmx_suggest="mmx_external mmx_inline"
 
@@ -2662,13 +2773,15 @@ fast_64bit_if_any="aarch64 alpha ia64 mips64 parisc64 ppc64 sparc64 x86_64"
 fast_clz_if_any="aarch64 alpha avr32 mips ppc x86"
 fast_unaligned_if_any="aarch64 ppc x86"
 simd_align_16_if_any="altivec neon sse"
+simd_align_32_if_any="avx"
 
 # system capabilities
 symver_if_any="symver_asm_label symver_gnu_asm"
-valgrind_backtrace_deps="!optimizations valgrind_valgrind_h"
+valgrind_backtrace_conflict="optimizations"
+valgrind_backtrace_deps="valgrind_valgrind_h"
 
 # threading support
-atomics_gcc_if_any="sync_val_compare_and_swap atomic_compare_exchange"
+atomics_gcc_if="sync_val_compare_and_swap"
 atomics_suncc_if="atomic_cas_ptr machine_rw_barrier"
 atomics_win32_if="MemoryBarrier"
 atomics_native_if_any="$ATOMICS_LIST"
@@ -2682,12 +2795,14 @@ error_resilience_select="me_cmp"
 faandct_deps="faan fdctdsp"
 faanidct_deps="faan idctdsp"
 h264dsp_select="startcode"
+hevcparse_select="golomb"
 frame_thread_encoder_deps="encoders threads"
 intrax8_select="blockdsp idctdsp"
 mdct_select="fft"
+mdct15_select="fft"
 me_cmp_select="fdctdsp idctdsp pixblockdsp"
 mpeg_er_select="error_resilience"
-mpegaudio_select="mpegaudiodsp"
+mpegaudio_select="mpegaudiodsp mpegaudioheader"
 mpegaudiodsp_select="dct"
 mpegvideo_select="blockdsp h264chroma hpeldsp idctdsp me_cmp mpeg_er videodsp"
 mpegvideoenc_select="me_cmp mpegvideo pixblockdsp qpeldsp"
@@ -2695,7 +2810,7 @@ vc1dsp_select="h264chroma qpeldsp startcode"
 rdft_select="fft"
 
 # decoders / encoders
-aac_decoder_select="imdct15 mdct sinewin"
+aac_decoder_select="mdct15 mdct sinewin"
 aac_fixed_decoder_select="mdct sinewin"
 aac_encoder_select="audio_frame_queue iirfilter lpc mdct sinewin"
 aac_latm_decoder_select="aac_decoder aac_latm_parser"
@@ -2714,7 +2829,7 @@ amv_decoder_select="sp5x_decoder exif"
 amv_encoder_select="aandcttables jpegtables mpegvideoenc"
 ape_decoder_select="bswapdsp llauddsp"
 apng_decoder_select="zlib"
-apng_encoder_select="huffyuvencdsp zlib"
+apng_encoder_select="llvidencdsp zlib"
 asv1_decoder_select="blockdsp bswapdsp idctdsp"
 asv1_encoder_select="bswapdsp fdctdsp pixblockdsp"
 asv2_decoder_select="blockdsp bswapdsp idctdsp"
@@ -2727,6 +2842,7 @@ bink_decoder_select="blockdsp hpeldsp"
 binkaudio_dct_decoder_select="mdct rdft dct sinewin wma_freqs"
 binkaudio_rdft_decoder_select="mdct rdft sinewin wma_freqs"
 cavs_decoder_select="blockdsp golomb h264chroma idctdsp qpeldsp videodsp"
+clearvideo_decoder_select="idctdsp"
 cllc_decoder_select="bswapdsp"
 comfortnoise_encoder_select="lpc"
 cook_decoder_select="audiodsp mdct sinewin"
@@ -2737,6 +2853,7 @@ dds_decoder_select="texturedsp"
 dirac_decoder_select="dirac_parse dwt golomb videodsp mpegvideoenc"
 dnxhd_decoder_select="blockdsp idctdsp"
 dnxhd_encoder_select="aandcttables blockdsp fdctdsp idctdsp mpegvideoenc pixblockdsp"
+dolby_e_decoder_select="mdct"
 dvvideo_decoder_select="dvprofile idctdsp"
 dvvideo_encoder_select="dvprofile fdctdsp me_cmp pixblockdsp"
 dxa_decoder_select="zlib"
@@ -2747,13 +2864,13 @@ eamad_decoder_select="aandcttables blockdsp bswapdsp idctdsp mpegvideo"
 eatgq_decoder_select="aandcttables"
 eatqi_decoder_select="aandcttables blockdsp bswapdsp idctdsp"
 exr_decoder_select="zlib"
-ffv1_decoder_select="golomb rangecoder"
+ffv1_decoder_select="rangecoder"
 ffv1_encoder_select="rangecoder"
 ffvhuff_decoder_select="huffyuv_decoder"
 ffvhuff_encoder_select="huffyuv_encoder"
 fic_decoder_select="golomb"
-flac_decoder_select="flacdsp golomb"
-flac_encoder_select="bswapdsp flacdsp golomb lpc"
+flac_decoder_select="flacdsp"
+flac_encoder_select="bswapdsp flacdsp lpc"
 flashsv2_decoder_select="zlib"
 flashsv2_encoder_select="zlib"
 flashsv_decoder_select="zlib"
@@ -2771,36 +2888,33 @@ h263_encoder_select="aandcttables h263dsp mpegvideoenc"
 h263i_decoder_select="h263_decoder"
 h263p_decoder_select="h263_decoder"
 h263p_encoder_select="h263_encoder"
-h264_decoder_select="cabac golomb h264chroma h264dsp h264pred h264qpel videodsp"
+h264_decoder_select="cabac golomb h264chroma h264dsp h264parse h264pred h264qpel videodsp"
 h264_decoder_suggest="error_resilience"
 hap_decoder_select="snappy texturedsp"
 hap_encoder_deps="libsnappy"
 hap_encoder_select="texturedspenc"
-hevc_decoder_select="bswapdsp cabac golomb videodsp"
+hevc_decoder_select="bswapdsp cabac golomb hevcparse videodsp"
 huffyuv_decoder_select="bswapdsp huffyuvdsp llviddsp"
-huffyuv_encoder_select="bswapdsp huffman huffyuvencdsp llviddsp"
+huffyuv_encoder_select="bswapdsp huffman huffyuvencdsp llvidencdsp"
 iac_decoder_select="imc_decoder"
 imc_decoder_select="bswapdsp fft mdct sinewin"
 indeo3_decoder_select="hpeldsp"
 indeo4_decoder_select="ividsp"
 indeo5_decoder_select="ividsp"
 interplay_video_decoder_select="hpeldsp"
-jpegls_decoder_select="golomb mjpeg_decoder"
-jpegls_encoder_select="golomb"
+jpegls_decoder_select="mjpeg_decoder"
 jv_decoder_select="blockdsp"
-lagarith_decoder_select="huffyuvdsp"
-ljpeg_encoder_select="aandcttables idctdsp jpegtables"
-loco_decoder_select="golomb"
-magicyuv_decoder_select="huffyuvdsp"
+lagarith_decoder_select="llviddsp"
+ljpeg_encoder_select="aandcttables idctdsp jpegtables mpegvideoenc"
+magicyuv_decoder_select="llviddsp"
 mdec_decoder_select="blockdsp idctdsp mpegvideo"
 metasound_decoder_select="lsp mdct sinewin"
 mimic_decoder_select="blockdsp bswapdsp hpeldsp idctdsp"
 mjpeg_decoder_select="blockdsp hpeldsp exif idctdsp jpegtables"
 mjpeg_encoder_select="aandcttables jpegtables mpegvideoenc"
 mjpegb_decoder_select="mjpeg_decoder"
-mjpeg_vaapi_encoder_deps="VAEncPictureParameterBufferJPEG"
-mjpeg_vaapi_encoder_select="vaapi_encode jpegtables"
 mlp_decoder_select="mlp_parser"
+mlp_encoder_select="lpc"
 motionpixels_decoder_select="bswapdsp"
 mp1_decoder_select="mpegaudio"
 mp1float_decoder_select="mpegaudio"
@@ -2824,12 +2938,13 @@ mpeg2video_encoder_select="aandcttables mpegvideoenc h263dsp"
 mpeg4_decoder_select="h263_decoder mpeg4video_parser"
 mpeg4_encoder_select="h263_encoder"
 msa1_decoder_select="mss34dsp"
+mscc_decoder_select="zlib"
 msmpeg4v1_decoder_select="h263_decoder"
 msmpeg4v2_decoder_select="h263_decoder"
 msmpeg4v2_encoder_select="h263_encoder"
 msmpeg4v3_decoder_select="h263_decoder"
 msmpeg4v3_encoder_select="h263_encoder"
-mss2_decoder_select="vc1_decoder mpegvideo"
+mss2_decoder_select="mpegvideo qpeldsp vc1_decoder"
 mts2_decoder_select="mss34dsp"
 mxpeg_decoder_select="mjpeg_decoder"
 nellymoser_decoder_select="mdct sinewin"
@@ -2837,9 +2952,10 @@ nellymoser_encoder_select="audio_frame_queue mdct sinewin"
 nuv_decoder_select="idctdsp lzo"
 on2avc_decoder_select="mdct"
 opus_decoder_deps="swresample"
-opus_decoder_select="imdct15"
+opus_decoder_select="mdct15"
+opus_encoder_select="audio_frame_queue mdct15"
 png_decoder_select="zlib"
-png_encoder_select="huffyuvencdsp zlib"
+png_encoder_select="llvidencdsp zlib"
 prores_decoder_select="blockdsp idctdsp"
 prores_encoder_select="fdctdsp"
 qcelp_decoder_select="lsp"
@@ -2857,7 +2973,7 @@ rv20_encoder_select="h263_encoder"
 rv30_decoder_select="golomb h264pred h264qpel mpegvideo rv34dsp"
 rv40_decoder_select="golomb h264pred h264qpel mpegvideo rv34dsp"
 screenpresso_decoder_select="zlib"
-shorten_decoder_select="golomb"
+shorten_decoder_select="bswapdsp"
 sipr_decoder_select="lsp"
 snow_decoder_select="dwt h264qpel hpeldsp me_cmp rangecoder videodsp"
 snow_encoder_select="aandcttables dwt h264qpel hpeldsp me_cmp mpegvideoenc rangecoder"
@@ -2865,9 +2981,10 @@ sonic_decoder_select="golomb rangecoder"
 sonic_encoder_select="golomb rangecoder"
 sonic_ls_encoder_select="golomb rangecoder"
 sp5x_decoder_select="mjpeg_decoder"
+srgc_decoder_select="zlib"
 svq1_decoder_select="hpeldsp"
 svq1_encoder_select="aandcttables hpeldsp me_cmp mpegvideoenc"
-svq3_decoder_select="golomb h264dsp h264pred hpeldsp tpeldsp videodsp"
+svq3_decoder_select="golomb h264dsp h264parse h264pred hpeldsp tpeldsp videodsp"
 svq3_decoder_suggest="zlib"
 tak_decoder_select="audiodsp"
 tdsc_decoder_select="zlib mjpeg_decoder"
@@ -2876,17 +2993,18 @@ thp_decoder_select="mjpeg_decoder"
 tiff_decoder_suggest="zlib lzma"
 tiff_encoder_suggest="zlib"
 truehd_decoder_select="mlp_parser"
+truehd_encoder_select="lpc"
 truemotion2_decoder_select="bswapdsp"
 truespeech_decoder_select="bswapdsp"
 tscc_decoder_select="zlib"
 twinvq_decoder_select="mdct lsp sinewin"
 txd_decoder_select="texturedsp"
-utvideo_decoder_select="bswapdsp"
-utvideo_encoder_select="bswapdsp huffman huffyuvencdsp"
-vble_decoder_select="huffyuvdsp"
+utvideo_decoder_select="bswapdsp llviddsp"
+utvideo_encoder_select="bswapdsp huffman llvidencdsp"
+vble_decoder_select="llviddsp"
 vc1_decoder_select="blockdsp h263_decoder h264qpel intrax8 mpegvideo vc1dsp"
 vc1_qsv_decoder_deps="libmfx"
-vc1_qsv_decoder_select="qsvdec vc1_qsv_hwaccel"
+vc1_qsv_decoder_select="qsvdec vc1_qsv_hwaccel vc1_parser"
 vc1image_decoder_select="vc1_decoder"
 vorbis_decoder_select="mdct"
 vorbis_encoder_select="mdct"
@@ -2920,64 +3038,53 @@ zlib_encoder_select="zlib"
 zmbv_decoder_select="zlib"
 zmbv_encoder_select="zlib"
 
-# platform codecs
-audiotoolbox_deps="AudioToolbox_AudioToolbox_h"
-audiotoolbox_extralibs="-framework CoreFoundation -framework AudioToolbox -framework CoreMedia"
-
 # hardware accelerators
 crystalhd_deps="libcrystalhd_libcrystalhd_if_h"
+cuda_deps_any="libdl LoadLibrary"
 cuvid_deps="cuda"
 d3d11va_deps="d3d11_h dxva_h ID3D11VideoDecoder ID3D11VideoContext"
-dxva2_deps="dxva2api_h DXVA2_ConfigPictureDecode"
-vaapi_deps="va_va_h"
-vda_framework_deps="VideoDecodeAcceleration_VDADecoder_h"
+dxva2_deps="dxva2api_h DXVA2_ConfigPictureDecode ole32"
+dxva2_extralibs="-luser32"
+vda_framework_deps="VideoDecodeAcceleration_VDADecoder_h blocks_extension"
 vda_framework_extralibs="-framework VideoDecodeAcceleration"
 vda_deps="vda_framework pthreads"
 vda_extralibs="-framework CoreFoundation -framework QuartzCore"
-vdpau_deps="vdpau_vdpau_h vdpau_vdpau_x11_h"
 videotoolbox_hwaccel_deps="videotoolbox pthreads"
 videotoolbox_hwaccel_extralibs="-framework QuartzCore"
 xvmc_deps="X11_extensions_XvMClib_h"
 
-h263_cuvid_hwaccel_deps="cuda cuvid"
 h263_vaapi_hwaccel_deps="vaapi"
 h263_vaapi_hwaccel_select="h263_decoder"
 h263_videotoolbox_hwaccel_deps="videotoolbox"
 h263_videotoolbox_hwaccel_select="h263_decoder"
-h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser"
 h264_cuvid_hwaccel_deps="cuda cuvid"
+h264_cuvid_hwaccel_select="h264_cuvid_decoder"
 h264_d3d11va_hwaccel_deps="d3d11va"
 h264_d3d11va_hwaccel_select="h264_decoder"
+h264_d3d11va2_hwaccel_deps="d3d11va"
+h264_d3d11va2_hwaccel_select="h264_decoder"
 h264_dxva2_hwaccel_deps="dxva2"
 h264_dxva2_hwaccel_select="h264_decoder"
-h264_mediacodec_decoder_deps="mediacodec"
 h264_mediacodec_hwaccel_deps="mediacodec"
-h264_mediacodec_decoder_select="h264_mp4toannexb_bsf h264_parser"
-h264_mmal_decoder_deps="mmal"
-h264_mmal_decoder_select="mmal"
 h264_mmal_hwaccel_deps="mmal"
-h264_omx_encoder_deps="omx"
 h264_qsv_hwaccel_deps="libmfx"
 h264_vaapi_hwaccel_deps="vaapi"
 h264_vaapi_hwaccel_select="h264_decoder"
-h264_vda_decoder_deps="vda"
-h264_vda_decoder_select="h264_decoder"
 h264_vda_hwaccel_deps="vda"
 h264_vda_hwaccel_select="h264_decoder"
 h264_vda_old_hwaccel_deps="vda"
 h264_vda_old_hwaccel_select="h264_decoder"
-h264_vdpau_decoder_deps="vdpau"
-h264_vdpau_decoder_select="h264_decoder"
 h264_vdpau_hwaccel_deps="vdpau"
 h264_vdpau_hwaccel_select="h264_decoder"
 h264_videotoolbox_hwaccel_deps="videotoolbox"
 h264_videotoolbox_hwaccel_select="h264_decoder"
 hevc_cuvid_hwaccel_deps="cuda cuvid"
+hevc_cuvid_hwaccel_select="hevc_cuvid_decoder"
 hevc_d3d11va_hwaccel_deps="d3d11va DXVA_PicParams_HEVC"
 hevc_d3d11va_hwaccel_select="hevc_decoder"
-hevc_mediacodec_decoder_deps="mediacodec"
 hevc_mediacodec_hwaccel_deps="mediacodec"
-hevc_mediacodec_decoder_select="hevc_mp4toannexb_bsf hevc_parser"
+hevc_d3d11va2_hwaccel_deps="d3d11va DXVA_PicParams_HEVC"
+hevc_d3d11va2_hwaccel_select="hevc_decoder"
 hevc_dxva2_hwaccel_deps="dxva2 DXVA_PicParams_HEVC"
 hevc_dxva2_hwaccel_select="hevc_decoder"
 hevc_qsv_hwaccel_deps="libmfx"
@@ -2985,28 +3092,29 @@ hevc_vaapi_hwaccel_deps="vaapi VAPictureParameterBufferHEVC"
 hevc_vaapi_hwaccel_select="hevc_decoder"
 hevc_vdpau_hwaccel_deps="vdpau VdpPictureInfoHEVC"
 hevc_vdpau_hwaccel_select="hevc_decoder"
+hevc_videotoolbox_hwaccel_deps="videotoolbox"
+hevc_videotoolbox_hwaccel_select="hevc_decoder"
 mjpeg_cuvid_hwaccel_deps="cuda cuvid"
-mpeg_vdpau_decoder_deps="vdpau"
-mpeg_vdpau_decoder_select="mpeg2video_decoder"
+mjpeg_cuvid_hwaccel_select="mjpeg_cuvid_decoder"
 mpeg_xvmc_hwaccel_deps="xvmc"
 mpeg_xvmc_hwaccel_select="mpeg2video_decoder"
 mpeg1_cuvid_hwaccel_deps="cuda cuvid"
-mpeg1_vdpau_decoder_deps="vdpau"
-mpeg1_vdpau_decoder_select="mpeg1video_decoder"
+mpeg1_cuvid_hwaccel_select="mpeg1_cuvid_decoder"
 mpeg1_vdpau_hwaccel_deps="vdpau"
 mpeg1_vdpau_hwaccel_select="mpeg1video_decoder"
 mpeg1_videotoolbox_hwaccel_deps="videotoolbox"
 mpeg1_videotoolbox_hwaccel_select="mpeg1video_decoder"
 mpeg1_xvmc_hwaccel_deps="xvmc"
 mpeg1_xvmc_hwaccel_select="mpeg1video_decoder"
-mpeg2_crystalhd_decoder_select="crystalhd"
 mpeg2_cuvid_hwaccel_deps="cuda cuvid"
+mpeg2_cuvid_hwaccel_select="mpeg2_cuvid_decoder"
 mpeg2_d3d11va_hwaccel_deps="d3d11va"
 mpeg2_d3d11va_hwaccel_select="mpeg2video_decoder"
+mpeg2_d3d11va2_hwaccel_deps="d3d11va"
+mpeg2_d3d11va2_hwaccel_select="mpeg2video_decoder"
 mpeg2_dxva2_hwaccel_deps="dxva2"
 mpeg2_dxva2_hwaccel_select="mpeg2video_decoder"
-mpeg2_mmal_decoder_deps="mmal"
-mpeg2_mmal_decoder_select="mmal"
+mpeg2_mediacodec_hwaccel_deps="mediacodec"
 mpeg2_mmal_hwaccel_deps="mmal"
 mpeg2_qsv_hwaccel_deps="libmfx"
 mpeg2_qsv_hwaccel_select="qsvdec_mpeg2"
@@ -3018,117 +3126,168 @@ mpeg2_videotoolbox_hwaccel_deps="videotoolbox"
 mpeg2_videotoolbox_hwaccel_select="mpeg2video_decoder"
 mpeg2_xvmc_hwaccel_deps="xvmc"
 mpeg2_xvmc_hwaccel_select="mpeg2video_decoder"
-mpeg4_crystalhd_decoder_select="crystalhd"
 mpeg4_cuvid_hwaccel_deps="cuda cuvid"
-mpeg4_mediacodec_decoder_deps="mediacodec"
+mpeg4_cuvid_hwaccel_select="mpeg4_cuvid_decoder"
 mpeg4_mediacodec_hwaccel_deps="mediacodec"
-mpeg4_mmal_decoder_deps="mmal"
-mpeg4_mmal_decoder_select="mmal"
 mpeg4_mmal_hwaccel_deps="mmal"
-mpeg4_omx_encoder_deps="omx"
 mpeg4_vaapi_hwaccel_deps="vaapi"
 mpeg4_vaapi_hwaccel_select="mpeg4_decoder"
-mpeg4_vdpau_decoder_deps="vdpau"
-mpeg4_vdpau_decoder_select="mpeg4_decoder"
 mpeg4_vdpau_hwaccel_deps="vdpau"
 mpeg4_vdpau_hwaccel_select="mpeg4_decoder"
 mpeg4_videotoolbox_hwaccel_deps="videotoolbox"
 mpeg4_videotoolbox_hwaccel_select="mpeg4_decoder"
-msmpeg4_crystalhd_decoder_select="crystalhd"
-vc1_crystalhd_decoder_select="crystalhd"
 vc1_cuvid_hwaccel_deps="cuda cuvid"
+vc1_cuvid_hwaccel_select="vc1_cuvid_decoder"
 vc1_d3d11va_hwaccel_deps="d3d11va"
 vc1_d3d11va_hwaccel_select="vc1_decoder"
+vc1_d3d11va2_hwaccel_deps="d3d11va"
+vc1_d3d11va2_hwaccel_select="vc1_decoder"
 vc1_dxva2_hwaccel_deps="dxva2"
 vc1_dxva2_hwaccel_select="vc1_decoder"
-vc1_mmal_decoder_deps="mmal"
-vc1_mmal_decoder_select="mmal"
 vc1_mmal_hwaccel_deps="mmal"
 vc1_qsv_hwaccel_deps="libmfx"
 vc1_qsv_hwaccel_select="qsvdec_vc1"
 vc1_vaapi_hwaccel_deps="vaapi"
 vc1_vaapi_hwaccel_select="vc1_decoder"
-vc1_vdpau_decoder_deps="vdpau"
-vc1_vdpau_decoder_select="vc1_decoder"
 vc1_vdpau_hwaccel_deps="vdpau"
 vc1_vdpau_hwaccel_select="vc1_decoder"
 vp8_cuvid_hwaccel_deps="cuda cuvid"
+vp8_cuvid_hwaccel_select="vp8_cuvid_decoder"
 vp9_cuvid_hwaccel_deps="cuda cuvid"
-vp8_mediacodec_decoder_deps="mediacodec"
+vp9_cuvid_hwaccel_select="vp9_cuvid_decoder"
 vp8_mediacodec_hwaccel_deps="mediacodec"
+vp8_qsv_hwaccel_deps="libmfx"
 vp9_d3d11va_hwaccel_deps="d3d11va DXVA_PicParams_VP9"
 vp9_d3d11va_hwaccel_select="vp9_decoder"
+vp9_d3d11va2_hwaccel_deps="d3d11va DXVA_PicParams_VP9"
+vp9_d3d11va2_hwaccel_select="vp9_decoder"
 vp9_dxva2_hwaccel_deps="dxva2 DXVA_PicParams_VP9"
 vp9_dxva2_hwaccel_select="vp9_decoder"
-vp9_mediacodec_decoder_deps="mediacodec"
 vp9_mediacodec_hwaccel_deps="mediacodec"
-vp9_vaapi_hwaccel_deps="vaapi VADecPictureParameterBufferVP9"
+vp9_vaapi_hwaccel_deps="vaapi VADecPictureParameterBufferVP9_bit_depth"
 vp9_vaapi_hwaccel_select="vp9_decoder"
-wmv3_crystalhd_decoder_select="crystalhd"
 wmv3_d3d11va_hwaccel_select="vc1_d3d11va_hwaccel"
+wmv3_d3d11va2_hwaccel_select="vc1_d3d11va2_hwaccel"
 wmv3_dxva2_hwaccel_select="vc1_dxva2_hwaccel"
 wmv3_vaapi_hwaccel_select="vc1_vaapi_hwaccel"
-wmv3_vdpau_decoder_select="vc1_vdpau_decoder"
 wmv3_vdpau_hwaccel_select="vc1_vdpau_hwaccel"
 
 # hardware-accelerated codecs
-omx_deps="dlopen pthreads"
-omx_extralibs='$ldl'
+omx_deps="libdl pthreads"
+omx_rpi_select="omx"
 qsvdec_select="qsv"
 qsvenc_select="qsv"
 vaapi_encode_deps="vaapi"
+v4l2_m2m_deps_any="linux_videodev2_h"
 
 hwupload_cuda_filter_deps="cuda"
 scale_npp_filter_deps="cuda libnpp"
+scale_cuda_filter_deps="cuda_sdk"
+thumbnail_cuda_filter_deps="cuda_sdk"
 
-nvenc_deps_any="dlopen LoadLibrary"
+nvenc_deps="cuda"
+nvenc_deps_any="libdl LoadLibrary"
 nvenc_encoder_deps="nvenc"
-h263_cuvid_decoder_deps="cuda cuvid"
-h263_cuvid_decoder_select="h263_cuvid_hwaccel"
+
+h263_v4l2m2m_decoder_deps="v4l2_m2m h263_v4l2_m2m"
+h263_v4l2m2m_encoder_deps="v4l2_m2m h263_v4l2_m2m"
+h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser"
 h264_cuvid_decoder_deps="cuda cuvid"
-h264_cuvid_decoder_select="h264_mp4toannexb_bsf h264_cuvid_hwaccel"
+h264_cuvid_decoder_select="h264_mp4toannexb_bsf"
+h264_mediacodec_decoder_deps="mediacodec"
+h264_mediacodec_decoder_select="h264_mp4toannexb_bsf h264_parser"
+h264_mmal_decoder_deps="mmal"
 h264_nvenc_encoder_deps="nvenc"
+h264_omx_encoder_deps="omx"
 h264_qsv_decoder_deps="libmfx"
 h264_qsv_decoder_select="h264_mp4toannexb_bsf h264_parser qsvdec h264_qsv_hwaccel"
 h264_qsv_encoder_deps="libmfx"
 h264_qsv_encoder_select="qsvenc"
+h264_rkmpp_decoder_deps="rkmpp"
+h264_rkmpp_decoder_select="h264_mp4toannexb_bsf"
 h264_vaapi_encoder_deps="VAEncPictureParameterBufferH264"
 h264_vaapi_encoder_select="vaapi_encode golomb"
-
+h264_vda_decoder_deps="vda"
+h264_vda_decoder_select="h264_decoder"
+h264_vdpau_decoder_deps="vdpau"
+h264_vdpau_decoder_select="h264_decoder"
+h264_v4l2m2m_decoder_deps="v4l2_m2m h264_v4l2_m2m"
+h264_v4l2m2m_encoder_deps="v4l2_m2m h264_v4l2_m2m"
 hevc_cuvid_decoder_deps="cuda cuvid"
-hevc_cuvid_decoder_select="hevc_mp4toannexb_bsf hevc_cuvid_hwaccel"
+hevc_cuvid_decoder_select="hevc_mp4toannexb_bsf"
+hevc_mediacodec_decoder_deps="mediacodec"
+hevc_mediacodec_decoder_select="hevc_mp4toannexb_bsf hevc_parser"
 hevc_nvenc_encoder_deps="nvenc"
 hevc_qsv_decoder_deps="libmfx"
 hevc_qsv_decoder_select="hevc_mp4toannexb_bsf hevc_parser qsvdec hevc_qsv_hwaccel"
 hevc_qsv_encoder_deps="libmfx"
-hevc_qsv_encoder_select="qsvenc"
+hevc_qsv_encoder_select="hevcparse qsvenc"
+hevc_rkmpp_decoder_deps="rkmpp"
+hevc_rkmpp_decoder_select="hevc_mp4toannexb_bsf"
 hevc_vaapi_encoder_deps="VAEncPictureParameterBufferHEVC"
 hevc_vaapi_encoder_select="vaapi_encode golomb"
+hevc_v4l2m2m_decoder_deps="v4l2_m2m hevc_v4l2_m2m"
+hevc_v4l2m2m_encoder_deps="v4l2_m2m hevc_v4l2_m2m"
 mjpeg_cuvid_decoder_deps="cuda cuvid"
-mjpeg_cuvid_decoder_select="mjpeg_cuvid_hwaccel"
+mjpeg_vaapi_encoder_deps="VAEncPictureParameterBufferJPEG"
+mjpeg_vaapi_encoder_select="vaapi_encode jpegtables"
 mpeg1_cuvid_decoder_deps="cuda cuvid"
-mpeg1_cuvid_decoder_select="mpeg1_cuvid_hwaccel"
+mpeg1_vdpau_decoder_deps="vdpau"
+mpeg1_vdpau_decoder_select="mpeg1video_decoder"
+mpeg1_v4l2m2m_decoder_deps="v4l2_m2m mpeg1_v4l2_m2m"
+mpeg2_crystalhd_decoder_select="crystalhd"
 mpeg2_cuvid_decoder_deps="cuda cuvid"
-mpeg2_cuvid_decoder_select="mpeg2_cuvid_hwaccel"
+mpeg2_mmal_decoder_deps="mmal"
+mpeg2_mediacodec_decoder_deps="mediacodec"
 mpeg2_qsv_decoder_deps="libmfx"
 mpeg2_qsv_decoder_select="qsvdec mpeg2_qsv_hwaccel"
 mpeg2_qsv_encoder_deps="libmfx"
 mpeg2_qsv_encoder_select="qsvenc"
+mpeg2_vaapi_encoder_deps="VAEncPictureParameterBufferMPEG2"
+mpeg2_vaapi_encoder_select="vaapi_encode"
+mpeg2_v4l2m2m_decoder_deps="v4l2_m2m mpeg2_v4l2_m2m"
+mpeg4_crystalhd_decoder_select="crystalhd"
 mpeg4_cuvid_decoder_deps="cuda cuvid"
-mpeg4_cuvid_decoder_select="mpeg4_cuvid_hwaccel"
-nvenc_h264_encoder_deps="nvenc"
-nvenc_hevc_encoder_deps="nvenc"
-
+mpeg4_mediacodec_decoder_deps="mediacodec"
+mpeg4_mmal_decoder_deps="mmal"
+mpeg4_omx_encoder_deps="omx"
+mpeg4_vdpau_decoder_deps="vdpau"
+mpeg4_vdpau_decoder_select="mpeg4_decoder"
+mpeg4_v4l2m2m_decoder_deps="v4l2_m2m mpeg4_v4l2_m2m"
+mpeg4_v4l2m2m_encoder_deps="v4l2_m2m mpeg4_v4l2_m2m"
+mpeg_vdpau_decoder_deps="vdpau"
+mpeg_vdpau_decoder_select="mpeg2video_decoder"
+msmpeg4_crystalhd_decoder_select="crystalhd"
+nvenc_h264_encoder_select="h264_nvenc_encoder"
+nvenc_hevc_encoder_select="hevc_nvenc_encoder"
+vc1_crystalhd_decoder_select="crystalhd"
 vc1_cuvid_decoder_deps="cuda cuvid"
-vc1_cuvid_decoder_select="vc1_cuvid_hwaccel"
+vc1_mmal_decoder_deps="mmal"
+vc1_vdpau_decoder_deps="vdpau"
+vc1_vdpau_decoder_select="vc1_decoder"
+vc1_v4l2m2m_decoder_deps="v4l2_m2m vc1_v4l2_m2m"
 vp8_cuvid_decoder_deps="cuda cuvid"
-vp8_cuvid_decoder_select="vp8_cuvid_hwaccel"
+vp8_mediacodec_decoder_deps="mediacodec"
+vp8_qsv_decoder_deps="libmfx"
+vp8_qsv_decoder_select="qsvdec vp8_qsv_hwaccel vp8_parser"
+vp8_rkmpp_decoder_deps="rkmpp"
+vp8_vaapi_encoder_deps="VAEncPictureParameterBufferVP8"
+vp8_vaapi_encoder_select="vaapi_encode"
+vp8_v4l2m2m_decoder_deps="v4l2_m2m vp8_v4l2_m2m"
+vp8_v4l2m2m_encoder_deps="v4l2_m2m vp8_v4l2_m2m"
 vp9_cuvid_decoder_deps="cuda cuvid"
-vp9_cuvid_decoder_select="vp9_cuvid_hwaccel"
+vp9_mediacodec_decoder_deps="mediacodec"
+vp9_rkmpp_decoder_deps="rkmpp"
+vp9_vaapi_encoder_deps="VAEncPictureParameterBufferVP9"
+vp9_vaapi_encoder_select="vaapi_encode"
+vp9_v4l2m2m_decoder_deps="v4l2_m2m vp9_v4l2_m2m"
+wmv3_crystalhd_decoder_select="crystalhd"
+wmv3_vdpau_decoder_select="vc1_vdpau_decoder"
 
 # parsers
-h264_parser_select="golomb h264dsp"
-hevc_parser_select="golomb"
+h264_parser_select="golomb h264dsp h264parse"
+hevc_parser_select="hevcparse"
+mpegaudio_parser_select="mpegaudioheader"
 mpegvideo_parser_select="mpegvideo"
 mpeg4video_parser_select="h263dsp mpegvideo qpeldsp"
 vc1_parser_select="vc1dsp"
@@ -3138,11 +3297,15 @@ mjpeg2jpeg_bsf_select="jpegtables"
 
 # external libraries
 aac_at_decoder_deps="audiotoolbox"
+aac_at_decoder_select="aac_adtstoasc_bsf"
 ac3_at_decoder_deps="audiotoolbox"
 ac3_at_decoder_select="ac3_parser"
 adpcm_ima_qt_at_decoder_deps="audiotoolbox"
 alac_at_decoder_deps="audiotoolbox"
 amr_nb_at_decoder_deps="audiotoolbox"
+avisynth_deps_any="libdl LoadLibrary"
+avisynth_demuxer_deps="avisynth"
+avisynth_demuxer_select="riffdec"
 eac3_at_decoder_deps="audiotoolbox"
 eac3_at_decoder_select="ac3_parser"
 gsm_ms_at_decoder_deps="audiotoolbox"
@@ -3150,6 +3313,9 @@ ilbc_at_decoder_deps="audiotoolbox"
 mp1_at_decoder_deps="audiotoolbox"
 mp2_at_decoder_deps="audiotoolbox"
 mp3_at_decoder_deps="audiotoolbox"
+mp1_at_decoder_select="mpegaudioheader"
+mp2_at_decoder_select="mpegaudioheader"
+mp3_at_decoder_select="mpegaudioheader"
 pcm_alaw_at_decoder_deps="audiotoolbox"
 pcm_mulaw_at_decoder_deps="audiotoolbox"
 qdmc_at_decoder_deps="audiotoolbox"
@@ -3165,7 +3331,8 @@ pcm_alaw_at_encoder_select="audio_frame_queue"
 pcm_mulaw_at_encoder_deps="audiotoolbox"
 pcm_mulaw_at_encoder_select="audio_frame_queue"
 chromaprint_muxer_deps="chromaprint"
-h264_videotoolbox_encoder_deps="videotoolbox_encoder pthreads"
+h264_videotoolbox_encoder_deps="pthreads"
+h264_videotoolbox_encoder_select="videotoolbox_encoder"
 libcelt_decoder_deps="libcelt"
 libfdk_aac_decoder_deps="libfdk_aac"
 libfdk_aac_encoder_deps="libfdk_aac"
@@ -3180,7 +3347,7 @@ libilbc_encoder_deps="libilbc"
 libkvazaar_encoder_deps="libkvazaar"
 libmodplug_demuxer_deps="libmodplug"
 libmp3lame_encoder_deps="libmp3lame"
-libmp3lame_encoder_select="audio_frame_queue"
+libmp3lame_encoder_select="audio_frame_queue mpegaudioheader"
 libopencore_amrnb_decoder_deps="libopencore_amrnb"
 libopencore_amrnb_encoder_deps="libopencore_amrnb"
 libopencore_amrnb_encoder_select="audio_frame_queue"
@@ -3194,8 +3361,7 @@ libopenmpt_demuxer_deps="libopenmpt"
 libopus_decoder_deps="libopus"
 libopus_encoder_deps="libopus"
 libopus_encoder_select="audio_frame_queue"
-libschroedinger_decoder_deps="libschroedinger"
-libschroedinger_encoder_deps="libschroedinger"
+librsvg_decoder_deps="librsvg"
 libshine_encoder_deps="libshine"
 libshine_encoder_select="audio_frame_queue"
 libspeex_decoder_deps="libspeex"
@@ -3212,6 +3378,7 @@ libvpx_vp8_encoder_deps="libvpx"
 libvpx_vp9_decoder_deps="libvpx"
 libvpx_vp9_encoder_deps="libvpx"
 libwavpack_encoder_deps="libwavpack"
+libwavpack_encoder_select="audio_frame_queue"
 libwebp_encoder_deps="libwebp"
 libwebp_anim_encoder_deps="libwebp"
 libx262_encoder_deps="libx262"
@@ -3222,24 +3389,23 @@ libx265_encoder_deps="libx265"
 libxavs_encoder_deps="libxavs"
 libxvid_encoder_deps="libxvid"
 libzvbi_teletext_decoder_deps="libzvbi"
-videotoolbox_deps="VideoToolbox_VideoToolbox_h"
 videotoolbox_extralibs="-framework CoreFoundation -framework VideoToolbox -framework CoreMedia -framework CoreVideo"
 videotoolbox_encoder_deps="videotoolbox VTCompressionSessionPrepareToEncodeFrames"
-videotoolbox_encoder_suggest="vda_framework vt_bt2020"
-vt_bt2020_deps="kCVImageBufferColorPrimaries_ITU_R_2020"
+videotoolbox_encoder_suggest="vda_framework"
 
 # demuxers / muxers
 ac3_demuxer_select="ac3_parser"
+aiff_muxer_select="iso_media"
 asf_demuxer_select="riffdec"
 asf_o_demuxer_select="riffdec"
 asf_muxer_select="riffenc"
 asf_stream_muxer_select="asf_muxer"
 avi_demuxer_select="iso_media riffdec exif"
 avi_muxer_select="riffenc"
-avisynth_demuxer_deps="avisynth"
-avisynth_demuxer_select="riffdec"
 caf_demuxer_select="iso_media riffdec"
+caf_muxer_select="iso_media"
 dash_muxer_select="mp4_muxer"
+dash_demuxer_deps="libxml2"
 dirac_demuxer_select="dirac_parser"
 dts_demuxer_select="dca_parser"
 dtshd_demuxer_select="dca_parser"
@@ -3256,8 +3422,6 @@ image2_alias_pix_demuxer_select="image2_demuxer"
 image2_brender_pix_demuxer_select="image2_demuxer"
 ipod_muxer_select="mov_muxer"
 ismv_muxer_select="mov_muxer"
-libnut_demuxer_deps="libnut"
-libnut_muxer_deps="libnut"
 matroska_audio_muxer_select="matroska_muxer"
 matroska_demuxer_select="iso_media riffdec"
 matroska_demuxer_suggest="bzlib lzo zlib"
@@ -3267,6 +3431,7 @@ mov_demuxer_select="iso_media riffdec"
 mov_demuxer_suggest="zlib"
 mov_muxer_select="iso_media riffenc rtpenc_chain"
 mp3_demuxer_select="mpegaudio_parser"
+mp3_muxer_select="mpegaudioheader"
 mp4_muxer_select="mov_muxer"
 mpegts_demuxer_select="iso_media"
 mpegts_muxer_select="adts_muxer latm_muxer"
@@ -3281,6 +3446,7 @@ ogv_muxer_select="ogg_muxer"
 opus_muxer_select="ogg_muxer"
 psp_muxer_select="mov_muxer"
 rtp_demuxer_select="sdp_demuxer"
+rtp_muxer_select="golomb"
 rtpdec_select="asf_demuxer jpegtables mov_demuxer mpegts_demuxer rm_demuxer rtp_protocol srtp"
 rtsp_demuxer_select="http_protocol rtpdec"
 rtsp_muxer_select="rtp_muxer http_protocol rtp_protocol rtpenc_chain"
@@ -3310,28 +3476,32 @@ xwma_demuxer_select="riffdec"
 image_align=1
 
 # indevs / outdevs
-alsa_indev_deps="alsa_asoundlib_h snd_pcm_htimestamp"
-alsa_outdev_deps="alsa_asoundlib_h"
-avfoundation_indev_extralibs="-framework CoreVideo -framework Foundation -framework AVFoundation -framework CoreMedia"
-avfoundation_indev_select="avfoundation"
+alsa_indev_deps="alsa"
+alsa_outdev_deps="alsa"
+avfoundation_indev_deps="avfoundation pthreads"
+avfoundation_indev_extralibs="-framework Foundation -framework CoreVideo -framework CoreMedia"
 bktr_indev_deps_any="dev_bktr_ioctl_bt848_h machine_ioctl_bt848_h dev_video_bktr_ioctl_bt848_h dev_ic_bt8xx_h"
 caca_outdev_deps="libcaca"
-decklink_indev_deps="decklink pthreads"
+decklink_deps_any="libdl LoadLibrary"
+decklink_indev_deps="decklink threads"
 decklink_indev_extralibs="-lstdc++"
-decklink_outdev_deps="decklink pthreads"
+decklink_outdev_deps="decklink threads"
 decklink_outdev_extralibs="-lstdc++"
+libndi_newtek_indev_deps="libndi_newtek"
+libndi_newtek_indev_extralibs="-lndi"
+libndi_newtek_outdev_deps="libndi_newtek"
+libndi_newtek_outdev_extralibs="-lndi"
 dshow_indev_deps="IBaseFilter"
 dshow_indev_extralibs="-lpsapi -lole32 -lstrmiids -luuid -loleaut32 -lshlwapi"
-dv1394_indev_deps="dv1394"
-dv1394_indev_select="dv_demuxer"
 fbdev_indev_deps="linux_fb_h"
 fbdev_outdev_deps="linux_fb_h"
 gdigrab_indev_deps="CreateDIBSection"
 gdigrab_indev_extralibs="-lgdi32"
 gdigrab_indev_select="bmp_decoder"
 iec61883_indev_deps="libiec61883"
-jack_indev_deps="jack_jack_h"
+jack_indev_deps="jack"
 jack_indev_deps_any="sem_timedwait dispatch_dispatch_h"
+kmsgrab_indev_deps="libdrm"
 lavfi_indev_deps="avfilter"
 libcdio_indev_deps="libcdio"
 libdc1394_indev_deps="libdc1394"
@@ -3342,28 +3512,23 @@ oss_indev_deps_any="soundcard_h sys_soundcard_h"
 oss_outdev_deps_any="soundcard_h sys_soundcard_h"
 pulse_indev_deps="libpulse"
 pulse_outdev_deps="libpulse"
-qtkit_indev_extralibs="-framework QTKit -framework Foundation -framework QuartzCore"
-qtkit_indev_select="qtkit"
 sdl2_outdev_deps="sdl2"
-sndio_indev_deps="sndio_h"
-sndio_outdev_deps="sndio_h"
-v4l_indev_deps="linux_videodev_h"
+sndio_indev_deps="sndio"
+sndio_outdev_deps="sndio"
 v4l2_indev_deps_any="linux_videodev2_h sys_videoio_h"
 v4l2_outdev_deps_any="linux_videodev2_h sys_videoio_h"
-vfwcap_indev_deps="capCreateCaptureWindow vfwcap_defines"
-vfwcap_indev_extralibs="-lavicap32"
-x11grab_indev_deps="x11grab"
-x11grab_xcb_indev_deps="libxcb"
+vfwcap_indev_deps="vfw32 vfwcap_defines"
+xcbgrab_indev_deps="libxcb"
 xv_outdev_deps="X11_extensions_Xvlib_h XvGetPortAttribute"
 xv_outdev_extralibs="-lXv -lX11 -lXext"
 
 # protocols
 async_protocol_deps="threads"
 bluray_protocol_deps="libbluray"
-ffrtmpcrypt_protocol_deps="!librtmp_protocol"
+ffrtmpcrypt_protocol_conflict="librtmp_protocol"
 ffrtmpcrypt_protocol_deps_any="gcrypt gmp openssl"
 ffrtmpcrypt_protocol_select="tcp_protocol"
-ffrtmphttp_protocol_deps="!librtmp_protocol"
+ffrtmphttp_protocol_conflict="librtmp_protocol"
 ffrtmphttp_protocol_select="http_protocol"
 ftp_protocol_select="tcp_protocol"
 gopher_protocol_select="network"
@@ -3380,10 +3545,10 @@ libsmbclient_protocol_deps="libsmbclient gplv3"
 libssh_protocol_deps="libssh"
 mmsh_protocol_select="http_protocol"
 mmst_protocol_select="network"
-rtmp_protocol_deps="!librtmp_protocol"
+rtmp_protocol_conflict="librtmp_protocol"
 rtmp_protocol_select="tcp_protocol"
 rtmpe_protocol_select="ffrtmpcrypt_protocol"
-rtmps_protocol_deps="!librtmp_protocol"
+rtmps_protocol_conflict="librtmp_protocol"
 rtmps_protocol_select="tls_protocol"
 rtmpt_protocol_select="ffrtmphttp_protocol"
 rtmpte_protocol_select="ffrtmpcrypt_protocol ffrtmphttp_protocol"
@@ -3393,9 +3558,11 @@ sctp_protocol_deps="struct_sctp_event_subscribe struct_msghdr_msg_flags"
 sctp_protocol_select="network"
 srtp_protocol_select="rtp_protocol srtp"
 tcp_protocol_select="network"
-tls_gnutls_protocol_deps="gnutls !tls_schannel_protocol !tls_securetransport_protocol"
+tls_gnutls_protocol_conflict="tls_schannel_protocol tls_securetransport_protocol"
+tls_gnutls_protocol_deps="gnutls"
 tls_gnutls_protocol_select="tcp_protocol"
-tls_openssl_protocol_deps="openssl !tls_schannel_protocol !tls_securetransport_protocol !tls_gnutls_protocol"
+tls_openssl_protocol_conflict="tls_schannel_protocol tls_securetransport_protocol tls_gnutls_protocol"
+tls_openssl_protocol_deps="openssl"
 tls_openssl_protocol_select="tcp_protocol"
 tls_schannel_protocol_deps="schannel"
 tls_schannel_protocol_select="tcp_protocol"
@@ -3410,10 +3577,11 @@ unix_protocol_select="network"
 # filters
 afftfilt_filter_deps="avcodec"
 afftfilt_filter_select="fft"
+afir_filter_deps="avcodec"
+afir_filter_select="fft"
 amovie_filter_deps="avcodec avformat"
 aresample_filter_deps="swresample"
 ass_filter_deps="libass"
-asyncts_filter_deps="avresample"
 atempo_filter_deps="avcodec"
 atempo_filter_select="rdft"
 azmq_filter_deps="libzmq"
@@ -3421,12 +3589,18 @@ blackframe_filter_deps="gpl"
 boxblur_filter_deps="gpl"
 bs2b_filter_deps="libbs2b"
 colormatrix_filter_deps="gpl"
+coreimage_filter_deps="coreimage appkit"
+coreimage_filter_extralibs="-framework OpenGL"
+coreimagesrc_filter_deps="coreimage appkit"
+coreimagesrc_filter_extralibs="-framework OpenGL"
 cover_rect_filter_deps="avcodec avformat gpl"
 cropdetect_filter_deps="gpl"
+deinterlace_qsv_filter_deps="libmfx"
+deinterlace_vaapi_filter_deps="vaapi"
 delogo_filter_deps="gpl"
 deshake_filter_select="pixelutils"
 drawtext_filter_deps="libfreetype"
-ebur128_filter_deps="gpl"
+elbg_filter_deps="avcodec"
 eq_filter_deps="gpl"
 fftfilt_filter_deps="avcodec"
 fftfilt_filter_select="rdft"
@@ -3435,16 +3609,15 @@ firequalizer_filter_deps="avcodec"
 firequalizer_filter_select="rdft"
 flite_filter_deps="libflite"
 framerate_filter_select="pixelutils"
-frei0r_filter_deps="frei0r dlopen"
-frei0r_src_filter_deps="frei0r dlopen"
+frei0r_filter_deps="frei0r libdl"
+frei0r_src_filter_deps="frei0r libdl"
 fspp_filter_deps="gpl"
 geq_filter_deps="gpl"
 histeq_filter_deps="gpl"
 hqdn3d_filter_deps="gpl"
 interlace_filter_deps="gpl"
 kerndeint_filter_deps="gpl"
-ladspa_filter_deps="ladspa dlopen"
-loudnorm_filter_deps="libebur128"
+ladspa_filter_deps="ladspa libdl"
 mcdeint_filter_deps="avcodec gpl"
 movie_filter_deps="avcodec avformat"
 mpdecimate_filter_deps="gpl"
@@ -3468,6 +3641,7 @@ rubberband_filter_deps="librubberband"
 sab_filter_deps="gpl swscale"
 scale2ref_filter_deps="swscale"
 scale_filter_deps="swscale"
+scale_qsv_filter_deps="libmfx"
 select_filter_select="pixelutils"
 showcqt_filter_deps="avcodec avformat swscale"
 showcqt_filter_select="fft"
@@ -3477,8 +3651,9 @@ showspectrum_filter_deps="avcodec"
 showspectrum_filter_select="fft"
 showspectrumpic_filter_deps="avcodec"
 showspectrumpic_filter_select="fft"
+signature_filter_deps="gpl avcodec avformat"
 smartblur_filter_deps="gpl swscale"
-sofalizer_filter_deps="netcdf avcodec"
+sofalizer_filter_deps="libmysofa avcodec"
 sofalizer_filter_select="fft"
 spectrumsynth_filter_deps="avcodec"
 spectrumsynth_filter_select="fft"
@@ -3491,28 +3666,34 @@ pixfmts_super2xsai_test_deps="super2xsai_filter"
 tinterlace_filter_deps="gpl"
 tinterlace_merge_test_deps="tinterlace_filter"
 tinterlace_pad_test_deps="tinterlace_filter"
+tonemap_filter_deps="const_nan"
 uspp_filter_deps="gpl avcodec"
 vaguedenoiser_filter_deps="gpl"
 vidstabdetect_filter_deps="libvidstab"
 vidstabtransform_filter_deps="libvidstab"
+libvmaf_filter_deps="libvmaf"
 zmq_filter_deps="libzmq"
 zoompan_filter_deps="swscale"
-zscale_filter_deps="libzimg"
+zscale_filter_deps="libzimg const_nan"
 scale_vaapi_filter_deps="vaapi VAProcPipelineParameterBuffer"
 
 # examples
 avio_dir_cmd_deps="avformat avutil"
 avio_reading_deps="avformat avcodec avutil"
-decoding_encoding_example_deps="avcodec avformat avutil"
+decode_audio_example_deps="avcodec avutil"
+decode_video_example_deps="avcodec avutil"
 demuxing_decoding_example_deps="avcodec avformat avutil"
+encode_audio_example_deps="avcodec avutil"
+encode_video_example_deps="avcodec avutil"
 extract_mvs_example_deps="avcodec avformat avutil"
 filter_audio_example_deps="avfilter avutil"
 filtering_audio_example_deps="avfilter avcodec avformat avutil"
 filtering_video_example_deps="avfilter avcodec avformat avutil"
-http_multiclient_example_deps="avformat avutil"
+http_multiclient_example_deps="avformat avutil fork"
+hw_decode_example_deps="avcodec avformat avutil"
 metadata_example_deps="avformat avutil"
 muxing_example_deps="avcodec avformat avutil swscale"
-qsvdec_example_deps="avcodec avutil libmfx h264_qsv_decoder vaapi_x11"
+qsvdec_example_deps="avcodec avutil libmfx h264_qsv_decoder"
 remuxing_example_deps="avcodec avformat avutil"
 resampling_audio_example_deps="avutil swresample"
 scaling_video_example_deps="avutil swscale"
@@ -3521,9 +3702,11 @@ transcoding_example_deps="avfilter avcodec avformat avutil"
 
 # libraries, in linking order
 avcodec_deps="avutil"
+avcodec_select="null_bsf"
 avdevice_deps="avformat avcodec avutil"
 avfilter_deps="avutil"
 avformat_deps="avcodec avutil"
+avformat_suggest="network"
 avresample_deps="avutil"
 postproc_deps="avutil gpl"
 swresample_deps="avutil"
@@ -3533,9 +3716,9 @@ swscale_deps="avutil"
 ffmpeg_deps="avcodec avfilter avformat swresample"
 ffmpeg_select="aformat_filter anull_filter atrim_filter format_filter
                null_filter
-               setpts_filter trim_filter"
+               trim_filter"
 ffplay_deps="avcodec avformat swscale swresample sdl2"
-ffplay_libs='$sdl2_libs'
+ffplay_extralibs='$sdl2_extralibs'
 ffplay_select="rdft crop_filter transpose_filter hflip_filter vflip_filter rotate_filter"
 ffprobe_deps="avcodec avformat"
 ffserver_deps="avformat fork sarestart"
@@ -3594,18 +3777,19 @@ ar_default="ar"
 cc_default="gcc"
 cxx_default="g++"
 host_cc_default="gcc"
-cp_f="cp -f"
 doxygen_default="doxygen"
 install="install"
 ln_s_default="ln -s -f"
 nm_default="nm -g"
-objformat="elf"
 pkg_config_default=pkg-config
 ranlib_default="ranlib"
 strip_default="strip"
 version_script='--version-script'
-yasmexe_default="yasm"
+x86asmexe_default="nasm"
 windres_default="windres"
+nvcc_default="nvcc"
+nvccflags_default="-gencode arch=compute_30,code=sm_30 -O2"
+striptype="direct"
 
 # MythTV toolchain
 ccache="yes"
@@ -3687,14 +3871,6 @@ enable valgrind_backtrace
 sws_max_filter_size_default=256
 set_default sws_max_filter_size
 
-# Enable platform codecs by default.
-enable audiotoolbox
-
-# Enable hwaccels by default.
-enable d3d11va dxva2 vaapi vda vdpau videotoolbox_hwaccel xvmc
-enable xlib
-
-enable nvenc vda_framework videotoolbox videotoolbox_encoder
 # mythtv settings
 enable shared
 enable gpl
@@ -3756,7 +3932,6 @@ x11_path_default="${sysinclude:-$sysroot/usr/include}/X11"
 libcec_path_default="${sysinclude:-$sysroot/usr/include}"
 libxml2_path_default="${sysinclude:-$sysroot/usr/include}/libxml2"
 firewiresdk_path_default=""
-
 # build settings
 SHFLAGS='-shared -Wl,-soname,$$(@F)'
 LIBPREF="libmyth"
@@ -3788,6 +3963,7 @@ CXX_O='-o $@'
 OBJCC_C='-c'
 OBJCC_E='-E -o $@'
 OBJCC_O='-o $@'
+X86ASM_O='-o $@'
 LD_O='-o $@'
 LD_LIB='-l%'
 LD_MYTH_LIB='-lmyth%'
@@ -3795,8 +3971,10 @@ LD_PATH='-L'
 HOSTCC_C='-c'
 HOSTCC_O='-o $@'
 HOSTLD_O='-o $@'
+NVCC_C='-c'
+NVCC_O='-o $@'
 
-host_libs='-lm'
+host_extralibs='-lm'
 host_cflags_filter=echo
 host_ldflags_filter=echo
 
@@ -4043,6 +4221,9 @@ for opt do
             action=${opt%%-random=*}
             do_random ${action#--} $optval
         ;;
+        --enable-sdl)
+            enable sdl2
+        ;;
         --enable-*=*|--disable-*=*)
             eval $(echo "${opt%%=*}" | sed 's/--/action=/;s/-/ thing=/')
             is_in "${thing}s" $COMPONENT_LIST || die_unknown "$opt"
@@ -4052,6 +4233,16 @@ for opt do
             [ "$list" = "" ] && warn "Option $opt did not match anything"
             $action $list
         ;;
+        --enable-yasm|--disable-yasm)
+            warn "The ${opt} option is only provided for compatibility and will be\n"\
+                 "removed in the future. Use --enable-x86asm / --disable-x86asm instead."
+            test $opt = --enable-yasm && x86asm=yes || x86asm=no
+        ;;
+        --yasmexe=*)
+            warn "The --yasmexe option is only provided for compatibility and will be\n"\
+                 "removed in the future. Use --x86asmexe instead."
+            x86asmexe="$optval"
+        ;;
         --enable-?*|--disable-?*)
             eval $(echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g')
             if is_in $option $COMPONENT_LIST; then
@@ -4071,8 +4262,13 @@ for opt do
         ;;
         --help|-h) show_help
         ;;
+        --quiet|-q) quiet=yes
+        ;;
         --fatal-warnings) enable fatal_warnings
         ;;
+        --libfuzzer=*)
+            libfuzzer_path="$optval"
+        ;;
         *)
             optname="${opt%%=*}"
             optname="${optname#--}"
@@ -4113,8 +4309,41 @@ for e in $env; do
     eval "export $e"
 done
 
+if disabled autodetect; then
+
+    # Unless iconv is explicitely disabled by the user, we still want to probe
+    # for the iconv from the libc.
+    disabled iconv || enable libc_iconv
+
+    disable_weak $EXTERNAL_AUTODETECT_LIBRARY_LIST
+    disable_weak $HWACCEL_AUTODETECT_LIBRARY_LIST
+fi
+# Mark specifically enabled, but normally autodetected libraries as requested.
+for lib in $AUTODETECT_LIBS; do
+    enabled $lib && request $lib
+done
+#TODO: switch to $AUTODETECT_LIBS when $THREADS_LIST is supported the same way
+enable_weak $EXTERNAL_AUTODETECT_LIBRARY_LIST
+enable_weak $HWACCEL_AUTODETECT_LIBRARY_LIST
+
 disabled logging && logfile=/dev/null
 
+die_license_disabled() {
+    enabled $1 || { enabled $v && die "$v is $1 and --enable-$1 is not specified."; }
+}
+
+die_license_disabled_gpl() {
+    enabled $1 || { enabled $v && die "$v is incompatible with the gpl and --enable-$1 is not specified."; }
+}
+
+map "die_license_disabled gpl"      $EXTERNAL_LIBRARY_GPL_LIST $EXTERNAL_LIBRARY_GPLV3_LIST
+map "die_license_disabled version3" $EXTERNAL_LIBRARY_VERSION3_LIST $EXTERNAL_LIBRARY_GPLV3_LIST
+
+enabled gpl && map "die_license_disabled_gpl nonfree" $EXTERNAL_LIBRARY_NONFREE_LIST
+map "die_license_disabled nonfree" $HWACCEL_LIBRARY_NONFREE_LIST
+
+enabled version3 && { enabled gpl && enable gplv3 || enable lgplv3; }
+
 # Disable all the library-specific components if the library itself
 # is disabled, see AVCODEC_LIST and following _LIST variables.
 
@@ -4132,6 +4361,11 @@ set >> $logfile
 
 test -n "$valgrind" && toolchain="valgrind-memcheck"
 
+enabled ossfuzz && {
+    add_cflags  -fsanitize=address,undefined -fsanitize-coverage=trace-pc-guard,trace-cmp -fno-omit-frame-pointer
+    add_ldflags -fsanitize=address,undefined -fsanitize-coverage=trace-pc-guard,trace-cmp
+}
+
 case "$toolchain" in
     *-asan)
         cc_default="${toolchain%-asan}"
@@ -4145,7 +4379,7 @@ case "$toolchain" in
     ;;
     *-tsan)
         cc_default="${toolchain%-tsan}"
-        add_cflags  -fsanitize=thread -pie
+        add_cflags  -fsanitize=thread -fPIE
         add_ldflags -fsanitize=thread -pie
         case "$toolchain" in
             gcc-tsan)
@@ -4180,8 +4414,10 @@ case "$toolchain" in
         cl_major_ver=$(cl 2>&1 | sed -n 's/.*Version \([[:digit:]]\{1,\}\)\..*/\1/p')
         if [ -z "$cl_major_ver" ] || [ $cl_major_ver -ge 18 ]; then
             cc_default="cl"
+            cxx_default="cl"
         else
             cc_default="c99wrap cl"
+            cxx_default="c99wrap cl"
         fi
         ld_default="$source_path/compat/windows/mslink"
         nm_default="dumpbin -symbols"
@@ -4230,7 +4466,7 @@ test -n "$cross_prefix" && enable cross_compile
 
 if enabled cross_compile; then
     test -n "$arch" && test -n "$target_os" ||
-        die "Must specify target arch/cpu and OS when cross-compiling"
+        die "Must specify target arch (--arch) and OS (--target-os) when cross-compiling"
 fi
 
 ar_default="${cross_prefix}${ar_default}"
@@ -4249,7 +4485,7 @@ windres_default="${cross_prefix}${windres_default}"
 sysinclude_default="${sysroot}/usr/include"
 
 set_default arch cc cxx doxygen pkg_config ranlib strip sysinclude \
-    target_exec target_os yasmexe
+    target_exec target_os x86asmexe nvcc
 enabled cross_compile || host_cc_default=$cc
 set_default host_cc
 
@@ -4262,7 +4498,7 @@ elif is_in -static $cc $LDFLAGS && ! is_in --static $pkg_config $pkg_config_flag
 Note: When building a static binary, add --pkg-config-flags=\"--static\"."
 fi
 
-set_default qmake qmakespecs python yasmexe
+set_default qmake qmakespecs python x86asmexe
 
 if test $doxygen != $doxygen_default && \
   ! $doxygen --version >/dev/null 2>&1; then
@@ -4285,26 +4521,32 @@ HOSTEXESUF=$(exesuf $host_os)
 
 if [ -n "$tempprefix" ] ; then
     mktemp(){
-        echo $tempprefix.${HOSTNAME}.${UID}
+        tmpname="$tempprefix.${HOSTNAME}.${UID}"
+        echo "$tmpname"
+        mkdir "$tmpname"
     }
 elif ! check_cmd mktemp -u XXXXXX; then
     # simple replacement for missing mktemp
     # NOT SAFE FOR GENERAL USE
     mktemp(){
-        echo "${2%%XXX*}.${HOSTNAME}.${UID}.$$"
+        tmpname="${2%%XXX*}.${HOSTNAME}.${UID}.$$"
+        echo "$tmpname"
+        mkdir "$tmpname"
     }
 fi
 
+FFTMPDIR=$(mktemp -d "${TMPDIR}/ffconf.XXXXXXXX" 2> /dev/null) ||
+    die "Unable to create temporary directory in $TMPDIR."
+
 tmpfile(){
-    tmp=$(mktemp -u "${TMPDIR}/mythtv_conf.XXXXXXXX")$2 &&
-        (set -C; exec > $tmp) 2>/dev/null ||
-        die "Unable to create temporary file in $TMPDIR."
-    append TMPFILES $tmp
+    tmp="${FFTMPDIR}/test"$2
+    (set -C; exec > $tmp) 2> /dev/null ||
+        die "Unable to create temporary file in $FFTMPDIR."
     eval $1=$tmp
 }
 
-trap 'rm -f -- $TMPFILES' EXIT
-trap exit HUP INT TERM
+trap 'rm -rf -- "$FFTMPDIR"' EXIT
+trap 'exit 2' HUP INT TERM
 
 tmpfile TMPASM .asm
 tmpfile TMPC  .c
@@ -4384,6 +4626,7 @@ msvc_common_flags(){
             # specific filters, they must be specified here as well or else the
             # generic catch all at the bottom will print the original flag.
             -Wall)                ;;
+            -Wextra)              ;;
             -std=c99)             ;;
             # Common flags
             -fomit-frame-pointer) ;;
@@ -4395,9 +4638,8 @@ msvc_common_flags(){
             -mthumb)              ;;
             -march=*)             ;;
             -lz)                  echo zlib.lib ;;
-            -lavifil32)           echo vfw32.lib ;;
-            -lavicap32)           echo vfw32.lib user32.lib ;;
             -lx264)               echo libx264.lib ;;
+            -lstdc++)             ;;
             -l*)                  echo ${flag#-l}.lib ;;
             -LARGEADDRESSAWARE)   echo $flag ;;
             -L*)                  echo -libpath:${flag#-L} ;;
@@ -4410,11 +4652,13 @@ msvc_flags(){
     msvc_common_flags "$@"
     for flag; do
         case $flag in
-            -Wall)                echo -W4 -wd4244 -wd4127 -wd4018 -wd4389     \
+            -Wall)                echo -W3 -wd4018 -wd4146 -wd4244 -wd4305     \
+                                       -wd4554 ;;
+            -Wextra)              echo -W4 -wd4244 -wd4127 -wd4018 -wd4389     \
                                        -wd4146 -wd4057 -wd4204 -wd4706 -wd4305 \
                                        -wd4152 -wd4324 -we4013 -wd4100 -wd4214 \
                                        -wd4307 \
-                                       -wd4273 -wd4554 -wd4701 ;;
+                                       -wd4273 -wd4554 -wd4701 -wd4703 ;;
         esac
     done
 }
@@ -4615,7 +4859,7 @@ probe_cc(){
         _ident=$($_cc --version 2>/dev/null | head -n1)
         _depflags='-MMD -MF $(@:.o=.d) -MT $@'
         _cflags_speed='-O3'
-        _cflags_size='-Os'
+        _cflags_size='-Oz'
     elif $_cc -V 2>&1 | grep -q Sun; then
         _type=suncc
         _ident=$($_cc -V 2>&1 | head -n1 | cut -d' ' -f 2-)
@@ -4675,8 +4919,20 @@ probe_cc(){
         _flags='-nologo -Qdiag-error:4044,10157'
         # -Qvec- -Qsimd- to prevent miscompilation, -GS, fp:precise for consistency
         # with MSVC which enables it by default.
-        _cflags='-D_USE_MATH_DEFINES -Qms0 -Qvec- -Qsimd- -GS -fp:precise'
+        _cflags='-Qms0 -Qvec- -Qsimd- -GS -fp:precise'
         disable stripping
+    elif $_cc -? 2>/dev/null | grep -q 'LLVM.*Linker'; then
+        # lld can emulate multiple different linkers; in ms link.exe mode,
+        # the -? parameter gives the help output which contains an identifyable
+        # string, while it gives an error in other modes.
+        _type=lld-link
+        # The link.exe mode doesn't have a switch for getting the version,
+        # but we can force it back to gnu mode and get the version from there.
+        _ident=$($_cc -flavor gnu --version 2>/dev/null)
+        _ld_o='-out:$@'
+        _flags_filter=msvc_flags
+        _ld_lib='lib%.a'
+        _ld_path='-libpath:'
     elif $_cc -nologo- 2>&1 | grep -q Microsoft; then
         _type=msvc
         _ident=$($_cc 2>&1 | head -n1)
@@ -4684,6 +4940,7 @@ probe_cc(){
         _DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -showIncludes -Zs'
         _cflags_speed="-O2"
         _cflags_size="-O1"
+        _cflags_noopt="-O1"
         if $_cc -nologo- 2>&1 | grep -q Linker; then
             _ld_o='-out:$@'
         else
@@ -4695,7 +4952,6 @@ probe_cc(){
         _ld_lib='lib%.a'
         _ld_path='-libpath:'
         _flags='-nologo'
-        _cflags='-D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS'
         disable stripping
     elif $_cc --version 2>/dev/null | grep -q ^cparser; then
         _type=cparser
@@ -4732,9 +4988,11 @@ cflags_noopt=$_cflags_noopt
 add_cflags $_flags $_cflags
 cc_ldflags=$_ldflags
 set_ccvars CC
+set_ccvars CXX
 
 probe_cc hostcc "$host_cc"
 host_cflags_filter=$_flags_filter
+host_cflags_speed=$_cflags_speed
 add_host_cflags  $_flags $_cflags
 set_ccvars HOSTCC
 
@@ -5453,6 +5711,13 @@ fi
 
 add_cppflags -D_ISOC99_SOURCE -D_POSIX_C_SOURCE=200112
 #add_cxxflags -D__STDC_CONSTANT_MACROS
+check_cxxflags -std=c++11 || check_cxxflags -std=c++0x
+
+# some compilers silently accept -std=c11, so we also need to check that the
+# version macro is defined properly
+test_cflags_cc -std=c11 ctype.h "__STDC_VERSION__ >= 201112L" &&
+    add_cflags -std=c11 ||
+    check_cflags -std=c99
 
 # C++ compiler sanity check
 check_exec_cxx <<EOF
@@ -5468,13 +5733,9 @@ if test "$?" != 0; then
     die "C++ compiler test failed."
 fi
 
-check_cflags -std=c99
-check_cc -D_FILE_OFFSET_BITS=64 <<EOF && add_cppflags -D_FILE_OFFSET_BITS=64
-#include <stdlib.h>
-EOF
-check_cc -D_LARGEFILE_SOURCE <<EOF && add_cppflags -D_LARGEFILE_SOURCE
-#include <stdlib.h>
-EOF
+
+check_cppflags -D_FILE_OFFSET_BITS=64
+check_cppflags -D_LARGEFILE_SOURCE
 check_cxx -D_FILE_OFFSET_BITS=64 <<EOF && add_cxxppflags -D_FILE_OFFSET_BITS=64
 #include <stdlib.h>
 EOF
@@ -5485,7 +5746,7 @@ EOF
 add_host_cppflags -D_ISOC99_SOURCE
 check_host_cflags -std=c99
 check_host_cflags -Wall
-check_host_cflags -O3
+check_host_cflags $host_cflags_speed
 
 check_64bit(){
     arch32=$1
@@ -5538,6 +5799,8 @@ esac
 enable $subarch
 enabled spic && enable_weak pic
 
+enabled x86_64 && objformat=elf64 || objformat="elf32"
+
 # OS specific
 case $target_os in
     aix)
@@ -5558,7 +5821,7 @@ case $target_os in
     haiku)
         prefix_default="/boot/common"
         network_extralibs="-lnetwork"
-        host_libs=
+        host_extralibs=
         ;;
     sunos)
         SHFLAGS='-shared -Wl,-h,$$(@F)'
@@ -5636,7 +5899,7 @@ case $target_os in
         SLIBNAME_WITH_VERSION='$(SLIBPREF)$(FULLNAME).$(LIBVERSION)$(SLIBSUF)'
         SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME).$(LIBMAJOR)$(SLIBSUF)'
         objformat="macho"
-        enabled x86_64 && objformat="macho64"
+        enabled x86_64 && objformat="macho64" || objformat="macho32"
         enabled_any pic shared x86_64 ||
             { check_cflags -mdynamic-no-pic && add_asflags -mdynamic-no-pic; }
         check_header dispatch/dispatch.h &&
@@ -5676,8 +5939,6 @@ case $target_os in
         else
             target_os=mingw32
         fi
-        decklink_outdev_extralibs="$decklink_outdev_extralibs -lole32 -loleaut32"
-        decklink_indev_extralibs="$decklink_indev_extralibs -lole32 -loleaut32"
         LIBTARGET=i386
         if enabled x86_64; then
             LIBTARGET="i386:x86-64"
@@ -5693,7 +5954,7 @@ case $target_os in
         SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(NAME)-$(LIBMAJOR)$(SLIBSUF)'
         dlltool="${cross_prefix}dlltool"
         if check_cmd lib.exe -list ; then
-            SLIB_EXTRA_CMD='-lib.exe /machine:$(LIBTARGET) /def:$$(@:$(SLIBSUF)=.def) /out:$(SUBDIR)$(SLIBNAME_WITH_MAJOR:$(SLIBSUF)=.lib)'
+            SLIB_EXTRA_CMD=-'sed -e "s/ @[^ ]*//" $$(@:$(SLIBSUF)=.orig.def) > $$(@:$(SLIBSUF)=.def); lib.exe -nologo -machine:$(LIBTARGET) -def:$$(@:$(SLIBSUF)=.def) -out:$(SUBDIR)$(SLIBNAME:$(SLIBSUF)=.lib)'
         else
             SLIB_EXTRA_CMD=-'sed -e "s/ @[^ ]*//" $$(@:$(SLIBSUF)=.orig.def) > $$(@:$(SLIBSUF)=.def); $(DLLTOOL) -m $(LIBTARGET) -d $$(@:$(SLIBSUF)=.def) -l $(SUBDIR)$(SLIBNAME:$(SLIBSUF)=.lib) -D $(SLIBNAME_WITH_MAJOR)'
         fi
@@ -5703,7 +5964,6 @@ case $target_os in
             install -m 644 $(SUBDIR)lib$(SLIBNAME:$(SLIBSUF)=.dll.a) "$(LIBDIR)/lib$(SLIBNAME:$(SLIBSUF)=.dll.a)"'
         SLIB_UNINSTALL_EXTRA_CMD='rm -f "$(SHLIBDIR)/$(SLIBNAME:$(SLIBSUF)=.lib)"'
         SHFLAGS='-shared -Wl,--output-def,$$(@:$(SLIBSUF)=.orig.def) -Wl,--out-implib,$(SUBDIR)lib$(SLIBNAME:$(SLIBSUF)=.dll.a) -Wl,--enable-runtime-pseudo-reloc -Wl,--enable-auto-image-base'
-        objformat="win32"
         ranlib=:
         enable dos_paths
         check_ldflags -Wl,--nxcompat,--dynamicbase
@@ -5746,7 +6006,7 @@ case $target_os in
         SLIB_INSTALL_EXTRA_SHLIB='$(SLIBNAME:$(SLIBSUF)=.lib)'
         SLIB_INSTALL_EXTRA_LIB='$(SLIBNAME_WITH_MAJOR:$(SLIBSUF)=.def)'
         SHFLAGS='-dll -def:$$(@:$(SLIBSUF)=.def) -implib:$(SUBDIR)$(SLIBNAME:$(SLIBSUF)=.lib)'
-        objformat="win32"
+        enabled x86_64 && objformat="win64" || objformat="win32"
         ranlib=:
         enable dos_paths
         ;;
@@ -5763,7 +6023,7 @@ case $target_os in
         SLIB_INSTALL_LINKS=
         SLIB_INSTALL_EXTRA_LIB='lib$(FULLNAME).dll.a'
         SHFLAGS='-shared -Wl,--out-implib,$(SUBDIR)lib$(FULLNAME).dll.a'
-        objformat="win32"
+        enabled x86_64 && objformat="win64" || objformat="win32"
         enable dos_paths
         enabled shared && ! enabled small && check_cmd $windres --version && enable gnu_windres
         add_cppflags -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600
@@ -5777,8 +6037,8 @@ case $target_os in
         add_cppflags -U__STRICT_ANSI__
         ;;
     linux)
-        enable dv1394
         enable section_data_rel_ro
+        enabled_any arm aarch64 && enable_weak linux_perf
         append CCONFIG "linux"
         enable backend
         ! disabled joystick_menu && enable joystick_menu
@@ -5792,9 +6052,10 @@ case $target_os in
         ;;
     os/2*)
         strip="lxlite -CS"
+        striptype=""
         objformat="aout"
         add_cppflags -D_GNU_SOURCE
-        add_ldflags -Zomf -Zbin-files -Zargs-wild -Zmap
+        add_ldflags -Zomf -Zbin-files -Zargs-wild -Zhigh-mem -Zmap
         SHFLAGS='$(SUBDIR)$(NAME).def -Zdll -Zomf'
         LIBSUF="_s.a"
         SLIBPREF="myth"
@@ -5840,18 +6101,6 @@ case $target_os in
         ;;
     minix)
         ;;
-    plan9)
-        add_cppflags -D_C99_SNPRINTF_EXTENSION  \
-                     -D_REENTRANT_SOURCE        \
-                     -D_RESEARCH_SOURCE         \
-                     -DFD_SETSIZE=96            \
-                     -DHAVE_SOCK_OPTS
-        add_compat strtod.o strtod=avpriv_strtod
-        network_extralibs='-lbsd'
-        exeobjs=compat/plan9/main.o
-        disable ffserver
-        cp_f='cp'
-        ;;
     none)
         ;;
     *)
@@ -5894,7 +6143,7 @@ probe_libc(){
     # MinGW headers can be installed on Cygwin, so check for newlib first.
     elif check_${pfx}cpp_condition newlib.h "defined _NEWLIB_VERSION"; then
         eval ${pfx}libc_type=newlib
-        add_${pfx}cppflags -U__STRICT_ANSI__
+        add_${pfx}cppflags -U__STRICT_ANSI__ -D_XOPEN_SOURCE=600
     # MinGW64 is backwards compatible with MinGW32, so check for it first.
     elif check_${pfx}cpp_condition _mingw.h "defined __MINGW64_VERSION_MAJOR"; then
         eval ${pfx}libc_type=mingw64
@@ -5914,6 +6163,8 @@ probe_libc(){
         add_${pfx}cppflags -U__STRICT_ANSI__ -D__USE_MINGW_ANSI_STDIO=1
         check_${pfx}cpp_condition _mingw.h "defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0502" ||
             add_${pfx}cppflags -D_WIN32_WINNT=0x0502
+        check_${pfx}cpp_condition _mingw.h "__MSVCRT_VERSION__ < 0x0700" &&
+            add_${pfx}cppflags -D__MSVCRT_VERSION__=0x0700
         eval test \$${pfx_no_}cc_type = "gcc" &&
             add_${pfx}cppflags -D__printf__=__gnu_printf__
     elif check_${pfx}cpp_condition crtversion.h "defined _VC_CRT_MAJOR_VERSION"; then
@@ -5928,6 +6179,7 @@ probe_libc(){
                                              vsnprintf=avpriv_vsnprintf
             fi
         fi
+        add_${pfx}cppflags -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS
         # The MSVC 2010 headers (Win 7.0 SDK) set _WIN32_WINNT to
         # 0x601 by default unless something else is set by the user.
         # This can easily lead to us detecting functions only present
@@ -5947,6 +6199,10 @@ probe_libc(){
 #endif
 #endif
 EOF
+        if [ "$pfx" = "" ]; then
+            check_func strtoll || add_cflags -Dstrtoll=_strtoi64
+            check_func strtoull || add_cflags -Dstrtoull=_strtoui64
+        fi
     elif check_${pfx}cpp_condition stddef.h "defined __KLIBC__"; then
         eval ${pfx}libc_type=klibc
     elif check_${pfx}cpp_condition sys/cdefs.h "defined __BIONIC__"; then
@@ -5971,28 +6227,27 @@ test -n "$libc_type" && enable libc_$libc_type
 probe_libc host_
 test -n "$host_libc_type" && enable host_libc_$host_libc_type
 
+# hacks for compiler/libc/os combinations
+
 case $libc_type in
     bionic)
         if test $target_os != android ; then
             add_compat strtod.o strtod=avpriv_strtod
         fi
         ;;
+    glibc)
+        if enabled tms470; then
+            CPPFLAGS="-I${source_path}/compat/tms470 ${CPPFLAGS}"
+            add_cppflags -D__USER_LABEL_PREFIX__=
+            add_cppflags -D__builtin_memset=memset
+            add_cppflags -D__gnuc_va_list=va_list -D_VA_LIST_DEFINED
+            add_cflags   -pds=48    # incompatible redefinition of macro
+        elif enabled ccc; then
+            add_ldflags -Wl,-z,now  # calls to libots crash without this
+        fi
+        ;;
 esac
 
-# hacks for compiler/libc/os combinations
-
-if enabled_all tms470 libc_glibc; then
-    CPPFLAGS="-I${source_path}/compat/tms470 ${CPPFLAGS}"
-    add_cppflags -D__USER_LABEL_PREFIX__=
-    add_cppflags -D__builtin_memset=memset
-    add_cppflags -D__gnuc_va_list=va_list -D_VA_LIST_DEFINED
-    add_cflags   -pds=48    # incompatible redefinition of macro
-fi
-
-if enabled_all ccc libc_glibc; then
-    add_ldflags -Wl,-z,now  # calls to libots crash without this
-fi
-
 check_compile_assert flt_lim "float.h limits.h" "DBL_MAX == (double)DBL_MAX" ||
     add_cppflags '-I\$(SRC_PATH)/compat/float'
 
@@ -6000,7 +6255,7 @@ esc(){
     echo "$*" | sed 's/%/%25/g;s/:/%3a/g'
 }
 
-echo "config:$arch:$subarch:$cpu:$target_os:$(esc $cc_ident):$(esc $FFMPEG_CONFIGURATION)" >config.fate
+echo "config:$arch:$subarch:$cpu:$target_os:$(esc $cc_ident):$(esc $FFMPEG_CONFIGURATION)" > config.fate
 
 check_cpp_condition stdlib.h "defined(__PIC__) || defined(__pic__) || defined(PIC)" && enable_weak pic
 
@@ -6042,47 +6297,15 @@ EOF
     exit 1
 fi
 
+disabled optimizations || enabled ossfuzz || check_cflags -fomit-frame-pointer
 # backward compatibility layer for incompatible_libav/fork_abi
 enabled incompatible_fork_abi  && enable incompatible_libav_abi
 enabled incompatible_libav_abi && enable incompatible_fork_abi
 
 disabled static && LIBNAME=""
 
-die_license_disabled() {
-    enabled $1 || { enabled $2 && die "$2 is $1 and --enable-$1 is not specified."; }
-}
-
-die_license_disabled_gpl() {
-    enabled $1 || { enabled $2 && die "$2 is incompatible with the gpl and --enable-$1 is not specified."; }
-}
-
-die_license_disabled gpl frei0r
 #die_license_disabled gpl libcdio
 #die_license_disabled gpl libutvideo
-die_license_disabled gpl librubberband
-die_license_disabled gpl libsmbclient
-die_license_disabled gpl libvidstab
-die_license_disabled gpl libx264
-die_license_disabled gpl libx265
-die_license_disabled gpl libxavs
-die_license_disabled gpl libxvid
-die_license_disabled gpl x11grab
-
-die_license_disabled nonfree cuda
-die_license_disabled nonfree cuvid
-die_license_disabled nonfree libnpp
-enabled gpl && die_license_disabled_gpl nonfree libfdk_aac
-enabled gpl && die_license_disabled_gpl nonfree openssl
-
-die_license_disabled version3 gmp
-die_license_disabled version3 libopencore_amrnb
-die_license_disabled version3 libopencore_amrwb
-die_license_disabled version3 libsmbclient
-die_license_disabled version3 libvo_amrwbenc
-
-enabled version3 && { enabled gpl && enable gplv3 || enable lgplv3; }
-
-disabled optimizations || check_cflags -fomit-frame-pointer
 disabled optimizations || check_cxxflags -fomit-frame-pointer
 
 enable_weak_pic() {
@@ -6152,9 +6375,7 @@ EOF
 sym=$($nm $TMPO | awk '/ff_extern/{ print substr($0, match($0, /[^ \t]*ff_extern/)) }')
 extern_prefix=${sym%%ff_extern*}
 
-check_cc <<EOF && enable_weak inline_asm
-void foo(void) { __asm__ volatile ("" ::); }
-EOF
+check_inline_asm inline_asm '"" ::'
 
 _restrict=
 for restrict_keyword in restrict __restrict__ __restrict; do
@@ -6180,6 +6401,11 @@ unsigned int endian = 'B' << 24 | 'I' << 16 | 'G' << 8 | 'E';
 EOF
 od -t x1 $TMPO | grep -q '42 *49 *47 *45' && enable bigendian
 
+check_cc <<EOF && enable const_nan
+#include <math.h>
+void foo(void) { struct { double d; } static const bar[] = { { NAN } }; }
+EOF
+
 if ! enabled ppc64 || enabled bigendian; then
     disable vsx
 fi
@@ -6289,10 +6515,14 @@ EOF
     check_as <<EOF && enable as_dn_directive
 ra .dn d0.i16
 .unreq ra
+EOF
+    check_as <<EOF && enable as_fpu_directive
+.fpu neon
 EOF
 
     # llvm's integrated assembler supports .object_arch from llvm 3.5
-    [ "$objformat" = elf ] && check_as <<EOF && enable as_object_arch
+    [ "$objformat" = elf32 ] || [ "$objformat" = elf64 ] &&
+        check_as <<EOF && enable as_object_arch
 .object_arch armv4
 EOF
 
@@ -6322,6 +6552,10 @@ elif enabled mips; then
     enabled mipsdsp && check_inline_asm_flags mipsdsp '"addu.qb $t0, $t1, $t2"' '-mdsp'
     enabled mipsdspr2 && check_inline_asm_flags mipsdspr2 '"absq_s.qb $t0, $t1"' '-mdspr2'
 
+    if enabled bigendian && enabled msa; then
+        disable msa
+    fi
+
 elif enabled parisc; then
 
     if enabled gcc; then
@@ -6402,34 +6636,39 @@ EOF
     enabled ssse3  && check_inline_asm ssse3_inline  '"pabsw %xmm0, %xmm0"'
     enabled mmxext && check_inline_asm mmxext_inline '"pmaxub %mm0, %mm1"'
 
-    if ! disabled_any asm mmx yasm; then
-        if check_cmd $yasmexe --version; then
-            enabled x86_64 && yasm_extra="-m amd64"
-            yasm_debug="-g dwarf2"
-        elif check_cmd nasm -v; then
-            yasmexe=nasm
-            yasm_debug="-g -F dwarf"
-            if enabled x86_64; then
-                case "$objformat" in
-                    elf)   objformat=elf64 ;;
-                    win32) objformat=win64 ;;
-                esac
-            fi
+    probe_x86asm(){
+        x86asmexe_probe=$1
+        if check_cmd $x86asmexe_probe -v; then
+            x86asmexe=$x86asmexe_probe
+            x86asm_type=nasm
+            x86asm_debug="-g -F dwarf"
+        elif check_cmd $x86asmexe_probe --version; then
+            x86asmexe=$x86asmexe_probe
+            x86asm_type=yasm
+            x86asm_debug="-g dwarf2"
         fi
+        check_x86asm "movbe ecx, [5]" && enable x86asm
+    }
 
-        YASMFLAGS="-f $objformat $yasm_extra"
-        enabled pic               && append YASMFLAGS "-DPIC"
-        test -n "$extern_prefix"  && append YASMFLAGS "-DPREFIX"
+    if ! disabled_any asm mmx x86asm; then
+        disable x86asm
+        for program in $x86asmexe nasm yasm; do
+            probe_x86asm $program && break
+        done
+        disabled x86asm && die "nasm/yasm not found or too old. Use --disable-x86asm for a crippled build."
+        test $x86asm_type = 'nasm' && X86ASM_DEPFLAGS='-MD $(@:.o=.d)'
+        test $x86asm_type = 'yasm' && X86ASMDEP='$(DEPX86ASM) $(X86ASMFLAGS) -M $(X86ASM_O) $< > $(@:.o=.d)'
+        X86ASMFLAGS="-f $objformat"
+        enabled pic               && append X86ASMFLAGS "-DPIC"
+        test -n "$extern_prefix"  && append X86ASMFLAGS "-DPREFIX"
         case "$objformat" in
-            elf*) enabled debug && append YASMFLAGS $yasm_debug ;;
+            elf*) enabled debug && append X86ASMFLAGS $x86asm_debug ;;
         esac
 
-        check_yasm "movbe ecx, [5]" && enable yasm ||
-            die "yasm/nasm not found or too old. Use --disable-yasm for a crippled build."
-        check_yasm "vextracti128 xmm0, ymm0, 0"      || disable avx2_external
-        check_yasm "vpmacsdd xmm0, xmm1, xmm2, xmm3" || disable xop_external
-        check_yasm "vfmaddps ymm0, ymm1, ymm2, ymm3" || disable fma4_external
-        check_yasm "CPU amdnop" || disable cpunop
+        check_x86asm "vextracti128 xmm0, ymm0, 0"      || disable avx2_external
+        check_x86asm "vpmacsdd xmm0, xmm1, xmm2, xmm3" || disable xop_external
+        check_x86asm "vfmaddps ymm0, ymm1, ymm2, ymm3" || disable fma4_external
+        check_x86asm "CPU amdnop" || disable cpunop
     fi
 
     case "$cpu" in
@@ -6445,21 +6684,6 @@ check_code cc arm_neon.h "int16x8_t test = vdupq_n_s16(0)" && enable intrinsics_
 check_ldflags -Wl,--as-needed
 check_ldflags -Wl,-z,noexecstack
 
-if check_func dlopen && check_func dlsym; then
-    ldl=
-elif check_func dlopen -ldl && check_func dlsym -ldl; then
-    ldl=-ldl
-fi
-
-decklink_outdev_extralibs="$decklink_outdev_extralibs $ldl"
-decklink_indev_extralibs="$decklink_indev_extralibs $ldl"
-frei0r_filter_extralibs='$ldl'
-frei0r_src_filter_extralibs='$ldl'
-ladspa_filter_extralibs='$ldl'
-nvenc_extralibs='$ldl'
-coreimage_filter_extralibs="-framework QuartzCore -framework AppKit -framework OpenGL"
-coreimagesrc_filter_extralibs="-framework QuartzCore -framework AppKit -framework OpenGL"
-
 if ! disabled network; then
     check_func getaddrinfo $network_extralibs
     check_func inet_aton $network_extralibs
@@ -6595,7 +6819,6 @@ else
 fi
 
 check_builtin atomic_cas_ptr atomic.h "void **ptr; void *oldval, *newval; atomic_cas_ptr(ptr, oldval, newval)"
-check_builtin atomic_compare_exchange "" "int *ptr, *oldval; int newval; __atomic_compare_exchange_n(ptr, oldval, newval, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)"
 check_builtin machine_rw_barrier mbarrier.h "__machine_rw_barrier()"
 check_builtin MemoryBarrier windows.h "MemoryBarrier()"
 check_builtin sarestart signal.h "SA_RESTART"
@@ -6611,7 +6834,7 @@ case "$custom_allocator" in
         require libjemalloc jemalloc/jemalloc.h malloc -ljemalloc
     ;;
     tcmalloc)
-        require_pkg_config libtcmalloc gperftools/tcmalloc.h tc_malloc
+        require_pkg_config libtcmalloc libtcmalloc gperftools/tcmalloc.h tc_malloc
         malloc_prefix=tc_
     ;;
 esac
@@ -6622,7 +6845,8 @@ check_func  ${malloc_prefix}posix_memalign      && enable posix_memalign
 
 check_func  access
 check_func_headers stdlib.h arc4random
-check_func_headers time.h clock_gettime || { check_func_headers time.h clock_gettime -lrt && add_extralibs -lrt && LIBRT="-lrt"; }
+check_func_headers time.h clock_gettime ||
+    { check_lib clock_gettime time.h clock_gettime -lrt && LIBRT="-lrt"; }
 check_func  fcntl
 check_func  fork
 check_func  gethrtime
@@ -6635,7 +6859,8 @@ check_func  mkstemp
 check_func  mmap
 check_func  mprotect
 # Solaris has nanosleep in -lrt, OpenSolaris no longer needs that
-check_func_headers time.h nanosleep || { check_func_headers time.h nanosleep -lrt && add_extralibs -lrt && LIBRT="-lrt"; }
+check_func_headers time.h nanosleep ||
+    { check_lib nanosleep time.h nanosleep -lrt && LIBRT="-lrt"; }
 check_func  sched_getaffinity
 check_func  setrlimit
 check_struct "sys/stat.h" "struct stat" st_mtim.tv_nsec -D_BSD_SOURCE
@@ -6650,7 +6875,6 @@ check_func_headers lzo/lzo1x.h lzo1x_999_compress
 check_func_headers stdlib.h getenv
 check_func_headers sys/stat.h lstat
 
-check_func_headers windows.h CoTaskMemFree -lole32
 check_func_headers windows.h GetProcessAffinityMask
 check_func_headers windows.h GetProcessTimes
 check_func_headers windows.h GetSystemTimeAsFileTime
@@ -6666,11 +6890,11 @@ check_func_headers glob.h glob
 enabled xlib &&
     check_func_headers "X11/Xlib.h X11/extensions/Xvlib.h" XvGetPortAttribute -lXv -lX11 -lXext
 
-check_header AudioToolbox/AudioToolbox.h
+check_header d3d11.h
 check_header direct.h
 check_header dirent.h
 check_header dlfcn.h
-check_header d3d11.h
+check_header dxgidebug.h
 check_header dxva.h
 check_header dxva2api.h -D_WIN32_WINNT=0x0600
 check_header fcntl.h
@@ -6689,16 +6913,26 @@ check_header sys/un.h
 check_header termios.h
 check_header unistd.h
 check_header valgrind/valgrind.h
-check_header vdpau/vdpau.h
-check_header vdpau/vdpau_x11.h
 check_header VideoDecodeAcceleration/VDADecoder.h
-check_header VideoToolbox/VideoToolbox.h
 check_func_headers VideoToolbox/VTCompressionSession.h VTCompressionSessionPrepareToEncodeFrames -framework VideoToolbox
-enabled videotoolbox && check_func_headers CoreVideo/CVImageBuffer.h kCVImageBufferColorPrimaries_ITU_R_2020 -framework CoreVideo
 check_header windows.h
 #check_header X11/extensions/XvMClib.h
 check_header asm/types.h
 
+# it seems there are versions of clang in some distros that try to use the
+# gcc headers, which explodes for stdatomic
+# so we also check that atomics actually work here
+check_builtin stdatomic_h stdatomic.h "atomic_int foo, bar = ATOMIC_VAR_INIT(-1); atomic_store(&foo, 0)"
+
+check_lib ole32    "windows.h"            CoTaskMemFree        -lole32
+check_lib shell32  "windows.h shellapi.h" CommandLineToArgvW   -lshell32
+check_lib wincrypt "windows.h wincrypt.h" CryptGenRandom       -ladvapi32
+check_lib psapi    "windows.h psapi.h"    GetProcessMemoryInfo -lpsapi
+
+enabled appkit       && check_apple_framework AppKit
+enabled audiotoolbox && check_apple_framework AudioToolbox
+enabled avfoundation && check_apple_framework AVFoundation
+
 #Myth check for MYTHTV_HAVE_LIST
 check_header byteswap.h
 check_header sys/endian.h
@@ -6712,10 +6946,17 @@ check_func_headers "sys/types.h sys/socket.h ifaddrs.h" getifaddrs
 check_func_headers sys/time.h gettimeofday
 #End MythTV check
 
-check_lib2 "windows.h shellapi.h" CommandLineToArgvW -lshell32
-check_lib2 "windows.h wincrypt.h" CryptGenRandom -ladvapi32
-check_lib2 "windows.h psapi.h" GetProcessMemoryInfo -lpsapi
-check_lib "CoreServices/CoreServices.h" UTGetOSTypeFromString "-framework CoreServices"
+enabled coreimage    && check_apple_framework CoreImage
+enabled videotoolbox && check_apple_framework VideoToolbox
+
+enabled avfoundation && {
+    check_lib avfoundation CoreGraphics/CoreGraphics.h               CGGetActiveDisplayList "-framework CoreGraphics" ||
+    check_lib avfoundation ApplicationServices/ApplicationServices.h CGGetActiveDisplayList "-framework ApplicationServices"; }
+
+enabled videotoolbox && {
+    check_lib coreservices CoreServices/CoreServices.h UTGetOSTypeFromString "-framework CoreServices"
+    check_func_headers CoreMedia/CMFormatDescription.h kCMVideoCodecType_HEVC "-framework CoreMedia"
+}
 
 check_struct "sys/time.h sys/resource.h" "struct rusage" ru_maxrss
 
@@ -6725,12 +6966,15 @@ check_type "windows.h d3d11.h" "ID3D11VideoDecoder"
 check_type "windows.h d3d11.h" "ID3D11VideoContext"
 check_type "d3d9.h dxva2api.h" DXVA2_ConfigPictureDecode -D_WIN32_WINNT=0x0602
 
-check_type "va/va.h" "VAPictureParameterBufferHEVC"
-check_type "va/va.h" "VADecPictureParameterBufferVP9"
+check_type "va/va.h va/va_dec_hevc.h" "VAPictureParameterBufferHEVC"
+check_struct "va/va.h" "VADecPictureParameterBufferVP9" bit_depth
 check_type "va/va.h va/va_vpp.h" "VAProcPipelineParameterBuffer"
 check_type "va/va.h va/va_enc_h264.h" "VAEncPictureParameterBufferH264"
 check_type "va/va.h va/va_enc_hevc.h" "VAEncPictureParameterBufferHEVC"
 check_type "va/va.h va/va_enc_jpeg.h" "VAEncPictureParameterBufferJPEG"
+check_type "va/va.h va/va_enc_mpeg2.h" "VAEncPictureParameterBufferMPEG2"
+check_type "va/va.h va/va_enc_vp8.h"  "VAEncPictureParameterBufferVP8"
+check_type "va/va.h va/va_enc_vp9.h"  "VAEncPictureParameterBufferVP9"
 
 check_type "vdpau/vdpau.h" "VdpPictureInfoHEVC"
 
@@ -6771,24 +7015,25 @@ fi
 # check for some common methods of building with pthread support
 # do this before the optional library checks as some of them require pthreads
 if ! disabled pthreads && ! enabled w32threads && ! enabled os2threads; then
-    enable pthreads
-    if check_func pthread_join -pthread && check_func pthread_create -pthread; then
+    if check_lib pthreads pthread.h pthread_join   -pthread &&
+       check_lib pthreads pthread.h pthread_create -pthread; then
         add_cflags -pthread
         add_cxxflags -pthread
-        add_extralibs -pthread
-    elif check_func pthread_join -pthreads && check_func pthread_create -pthreads; then
+    elif check_lib pthreads pthread.h pthread_join   -pthreads &&
+         check_lib pthreads pthread.h pthread_create -pthreads; then
         add_cflags -pthreads
         add_cxxflags -pthread
-        add_extralibs -pthreads
-    elif check_func pthread_join -ldl -pthread && check_func pthread_create -ldl -pthread; then
+    elif check_lib pthreads pthread.h pthread_join   -ldl -pthread &&
+         check_lib pthreads pthread.h pthread_create -ldl -pthread; then
         add_cflags -ldl -pthread
-        add_extralibs -ldl -pthread
-    elif check_func pthread_join -lpthreadGC2 && check_func pthread_create -lpthreadGC2; then
-        add_extralibs -lpthreadGC2
-    elif check_lib pthread.h pthread_join -lpthread && check_lib pthread.h pthread_create -lpthread; then
+    elif check_lib pthreads pthread.h pthread_join   -lpthreadGC2 &&
+         check_lib pthreads pthread.h pthread_create -lpthreadGC2; then
         :
-    elif ! check_func pthread_join && ! check_func pthread_create; then
-        disable pthreads
+    elif check_lib pthreads pthread.h pthread_join   -lpthread &&
+         check_lib pthreads pthread.h pthread_create -lpthread; then
+        :
+    elif check_func pthread_join && check_func pthread_create; then
+        enable pthreads
     fi
     check_code cc "pthread.h" "static pthread_mutex_t atomic_lock = PTHREAD_MUTEX_INITIALIZER" || disable pthreads
 fi
@@ -6836,7 +7081,7 @@ if enabled taglib; then
 fi
 
 # Attempt to use libudev for mediamonitor
-enabled libudev && check_lib2 libudev.h udev_new -ludev || disable libudev
+enabled libudev && check_lib udev libudev.h udev_new  || disable libudev
 
 # libmythbluray
 antbin=""
@@ -6861,12 +7106,14 @@ fi
 enabled pthreads &&
     check_builtin sem_timedwait semaphore.h "sem_t *s; sem_init(s,0,0); sem_timedwait(s,0); sem_destroy(s)"
 
-disabled  zlib || check_lib   zlib.h      zlibVersion -lz   || disable  zlib
-disabled bzlib || check_lib2 bzlib.h BZ2_bzlibVersion -lbz2 || disable bzlib
-disabled  lzma || check_lib2  lzma.h lzma_version_number -llzma || disable lzma
+enabled  zlib && check_lib zlib   zlib.h      zlibVersion    -lz
+enabled bzlib && check_lib bzlib bzlib.h BZ2_bzlibVersion    -lbz2
+enabled  lzma && check_lib lzma   lzma.h lzma_version_number -llzma
+
+# On some systems dynamic loading requires no extra linker flags
+check_lib libdl dlfcn.h "dlopen dlsym" || check_lib libdl dlfcn.h "dlopen dlsym" -ldl
 
-check_lib math.h sin -lm && LIBM="-lm"
-disabled crystalhd || check_lib libcrystalhd/libcrystalhd_if.h DtsCrystalHDVersion -lcrystalhd || disable crystalhd
+check_lib libm math.h sin -lm && LIBM="-lm"
 
 atan2f_args=2
 copysign_args=2
@@ -6875,128 +7122,133 @@ ldexpf_args=2
 powf_args=2
 
 for func in $MATH_FUNCS; do
-    eval check_mathfunc $func \${${func}_args:-1}
+    eval check_mathfunc $func \${${func}_args:-1} $LIBM
 done
 
 for func in $COMPLEX_FUNCS; do
     eval check_complexfunc $func \${${func}_args:-1}
 done
 
-# Enable CUVID by default if CUDA is enabled
-if enabled cuda && ! disabled cuvid; then
-    enable cuvid
-fi
-
 # these are off by default, so fail if requested and not available
-enabled avfoundation_indev && { check_header_objcc AVFoundation/AVFoundation.h || disable avfoundation_indev; }
-enabled avfoundation_indev && { check_lib2 CoreGraphics/CoreGraphics.h CGGetActiveDisplayList -framework CoreGraphics ||
-                                check_lib2 ApplicationServices/ApplicationServices.h CGGetActiveDisplayList -framework ApplicationServices; }
-enabled avisynth          && { { check_lib2 "windows.h" LoadLibrary; } ||
-                               { check_lib2 "dlfcn.h" dlopen -ldl; } ||
-                               die "ERROR: LoadLibrary/dlopen not found for avisynth"; }
-enabled cuda              && { check_lib cuda.h cuInit -lcuda ||
-                               die "ERROR: CUDA not found"; }
-enabled cuvid             && { add_cflags -I$source_path;
-                               check_lib "compat/cuda/cuviddec.h" cuvidCreateDecoder -lnvcuvid ||
-                               die "ERROR: CUVID not found"; } &&
-                             { enabled cuda ||
+enabled cuda_sdk          && require cuda_sdk cuda.h cuCtxCreate -lcuda
+enabled cuvid             && { enabled cuda ||
                                die "ERROR: CUVID requires CUDA"; }
 enabled chromaprint       && require chromaprint chromaprint.h chromaprint_get_version -lchromaprint
-enabled coreimage_filter  && { check_header_objcc QuartzCore/CoreImage.h || disable coreimage_filter; }
-enabled coreimagesrc_filter && { check_header_objcc QuartzCore/CoreImage.h || disable coreimagesrc_filter; }
-enabled decklink          && { { check_header DeckLinkAPI.h || die "ERROR: DeckLinkAPI.h header not found"; } &&
+enabled decklink          && { require_header DeckLinkAPI.h &&
                                { check_cpp_condition DeckLinkAPIVersion.h "BLACKMAGIC_DECKLINK_API_VERSION >= 0x0a060100" || die "ERROR: Decklink API version must be >= 10.6.1."; } }
-enabled frei0r            && { check_header frei0r.h || die "ERROR: frei0r.h header not found"; }
-enabled gmp               && require2 gmp gmp.h mpz_export -lgmp
-enabled gnutls            && require_pkg_config gnutls gnutls/gnutls.h gnutls_global_init
-enabled jni               && { [ $target_os = "android" ] && check_header jni.h && enabled pthreads &&
-                               check_lib2 "dlfcn.h" dlopen -ldl; }
-enabled ladspa            && { check_header ladspa.h || die "ERROR: ladspa.h header not found"; }
+enabled libndi_newtek     && require_header Processing.NDI.Lib.h
+enabled frei0r            && require_header frei0r.h
+enabled gmp               && require gmp gmp.h mpz_export -lgmp
+enabled gnutls            && require_pkg_config gnutls gnutls gnutls/gnutls.h gnutls_global_init
+enabled jni               && { [ $target_os = "android" ] && check_header jni.h && enabled pthreads || die "ERROR: jni not found"; }
+enabled ladspa            && require_header ladspa.h
 enabled libiec61883       && require libiec61883 libiec61883/iec61883.h iec61883_cmp_connect -lraw1394 -lavc1394 -lrom1394 -liec61883
-#enabled libass            && require_pkg_config libass ass/ass.h ass_library_init
-enabled libbluray         && require libbluray libbluray/bluray.h bd_open -lbluray
-enabled libbs2b           && require_pkg_config libbs2b bs2b.h bs2b_open
+enabled libass            && require_pkg_config libass libass ass/ass.h ass_library_init
+enabled libbluray         && require_pkg_config libbluray libbluray libbluray/bluray.h bd_open -lbluray
+enabled libbs2b           && require_pkg_config libbs2b libbs2b bs2b.h bs2b_open
 enabled libcelt           && require libcelt celt/celt.h celt_decode -lcelt0 &&
-                             { check_lib celt/celt.h celt_decoder_create_custom -lcelt0 ||
+                             { check_lib libcelt celt/celt.h celt_decoder_create_custom -lcelt0 ||
                                die "ERROR: libcelt must be installed and version must be >= 0.11.0."; }
-enabled libcaca           && require_pkg_config caca caca.h caca_create_canvas
-enabled libebur128        && require ebur128 ebur128.h ebur128_relative_threshold -lebur128
-enabled libfdk_aac        && { use_pkg_config fdk-aac "fdk-aac/aacenc_lib.h" aacEncOpen ||
+enabled libcaca           && require_pkg_config libcaca caca caca.h caca_create_canvas
+enabled libdc1394         && require_pkg_config libdc1394 libdc1394-2 dc1394/dc1394.h dc1394_new
+enabled libdrm            && require_pkg_config libdrm libdrm xf86drm.h drmGetVersion
+enabled libfdk_aac        && { use_pkg_config libfdk_aac fdk-aac "fdk-aac/aacenc_lib.h" aacEncOpen ||
                                { require libfdk_aac fdk-aac/aacenc_lib.h aacEncOpen -lfdk-aac &&
                                  warn "using libfdk without pkg-config"; } }
-flite_libs="-lflite_cmu_time_awb -lflite_cmu_us_awb -lflite_cmu_us_kal -lflite_cmu_us_kal16 -lflite_cmu_us_rms -lflite_cmu_us_slt -lflite_usenglish -lflite_cmulex -lflite"
-enabled libflite          && require2 libflite "flite/flite.h" flite_init $flite_libs
+flite_extralibs="-lflite_cmu_time_awb -lflite_cmu_us_awb -lflite_cmu_us_kal -lflite_cmu_us_kal16 -lflite_cmu_us_rms -lflite_cmu_us_slt -lflite_usenglish -lflite_cmulex -lflite"
+enabled libflite          && require libflite "flite/flite.h" flite_init $flite_extralibs
 enabled fontconfig        && enable libfontconfig
-enabled libfontconfig     && require_pkg_config fontconfig "fontconfig/fontconfig.h" FcInit
-enabled libfreetype       && require_libfreetype
-enabled libfribidi        && require_pkg_config fribidi fribidi.h fribidi_version_info
-enabled libgme            && require  libgme gme/gme.h gme_new_emu -lgme -lstdc++
+enabled libfontconfig     && require_pkg_config libfontconfig fontconfig "fontconfig/fontconfig.h" FcInit
+enabled libfreetype       && require_pkg_config libfreetype2 freetype2 "ft2build.h FT_FREETYPE_H" FT_Init_FreeType
+enabled libfribidi        && require_pkg_config libfribidi fribidi fribidi.h fribidi_version_info
+enabled libgme            && { use_pkg_config libgme libgme gme/gme.h gme_new_emu ||
+                               require libgme gme/gme.h gme_new_emu -lgme -lstdc++; }
 enabled libgsm            && { for gsm_hdr in "gsm.h" "gsm/gsm.h"; do
-                                   check_lib "${gsm_hdr}" gsm_create -lgsm && break;
+                                   check_lib libgsm "${gsm_hdr}" gsm_create -lgsm && break;
                                done || die "ERROR: libgsm not found"; }
 enabled libilbc           && require libilbc ilbc.h WebRtcIlbcfix_InitDecode -lilbc
-enabled libkvazaar        && require_pkg_config "kvazaar >= 0.8.1" kvazaar.h kvz_api_get
-enabled libmfx            && require_pkg_config libmfx "mfx/mfxvideo.h" MFXInit
-enabled libmodplug        && require_pkg_config libmodplug libmodplug/modplug.h ModPlug_Load
+enabled libkvazaar        && require_pkg_config libkvazaar "kvazaar >= 0.8.1" kvazaar.h kvz_api_get
+# While it may appear that require is being used as a pkg-config
+# fallback for libmfx, it is actually being used to detect a different
+# installation route altogether.  If libmfx is installed via the Intel
+# Media SDK or Intel Media Server Studio, these don't come with
+# pkg-config support.  Instead, users should make sure that the build
+# can find the libraries and headers through other means.
+enabled libmfx            && { use_pkg_config libmfx libmfx "mfx/mfxvideo.h" MFXInit ||
+                               { require libmfx "mfx/mfxvideo.h" MFXInit -llibmfx && warn "using libmfx without pkg-config"; } }
+enabled libmodplug        && require_pkg_config libmodplug libmodplug libmodplug/modplug.h ModPlug_Load
 enabled libmp3lame        && require "libmp3lame >= 3.98.3" lame/lame.h lame_set_VBR_quality -lmp3lame
-enabled libnut            && require libnut libnut.h nut_demuxer_init -lnut
-enabled libnpp            && require libnpp npp.h nppGetLibVersion -lnppi -lnppc
+enabled libmysofa         && require libmysofa "mysofa.h" mysofa_load -lmysofa
+enabled libnpp            && { check_lib libnpp npp.h nppGetLibVersion -lnppig -lnppicc -lnppc ||
+                               check_lib libnpp npp.h nppGetLibVersion -lnppi -lnppc ||
+                               die "ERROR: libnpp not found"; }
 enabled libopencore_amrnb && require libopencore_amrnb opencore-amrnb/interf_dec.h Decoder_Interface_init -lopencore-amrnb
 enabled libopencore_amrwb && require libopencore_amrwb opencore-amrwb/dec_if.h D_IF_init -lopencore-amrwb
 enabled libopencv         && { check_header opencv2/core/core_c.h &&
-                               { use_pkg_config opencv opencv2/core/core_c.h cvCreateImageHeader ||
+                               { use_pkg_config libopencv opencv opencv2/core/core_c.h cvCreateImageHeader ||
                                  require opencv opencv2/core/core_c.h cvCreateImageHeader -lopencv_core -lopencv_imgproc; } ||
-                               require_pkg_config opencv opencv/cxcore.h cvCreateImageHeader; }
-enabled libopenh264       && require_pkg_config openh264 wels/codec_api.h WelsGetCodecVersion
-enabled libopenjpeg       && { { check_lib2 openjpeg-2.1/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
-                               check_lib2 openjpeg-2.1/openjpeg.h opj_version -lopenjp2 ||
-                               { check_lib2 openjpeg-2.0/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
-                               { check_lib2 openjpeg-1.5/openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
-                               { check_lib2 openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               require_pkg_config libopencv opencv opencv/cxcore.h cvCreateImageHeader; }
+enabled libopenh264       && require_pkg_config libopenh264 openh264 wels/codec_api.h WelsGetCodecVersion
+enabled libopenjpeg       && { { check_lib libopenjpeg openjpeg-2.3/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               check_lib libopenjpeg openjpeg-2.3/openjpeg.h opj_version -lopenjp2 ||
+                               { check_lib libopenjpeg openjpeg-2.2/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               check_lib libopenjpeg openjpeg-2.2/openjpeg.h opj_version -lopenjp2 ||
+                               { check_lib libopenjpeg openjpeg-2.1/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               check_lib libopenjpeg openjpeg-2.1/openjpeg.h opj_version -lopenjp2 ||
+                               { check_lib libopenjpeg openjpeg-2.0/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               { check_lib libopenjpeg openjpeg-1.5/openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               { check_lib libopenjpeg openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
                                die "ERROR: libopenjpeg not found"; }
-enabled libopenmpt        && require_pkg_config "libopenmpt >= 0.2.6557" libopenmpt/libopenmpt.h openmpt_module_create
-enabled libopus           && require_pkg_config opus opus_multistream.h opus_multistream_decoder_create
-enabled libpulse          && require_pkg_config libpulse pulse/pulseaudio.h pa_context_new
-enabled librtmp           && require_pkg_config librtmp librtmp/rtmp.h RTMP_Socket
-enabled librubberband     && require_pkg_config "rubberband >= 1.8.1" rubberband/rubberband-c.h rubberband_new
-enabled libschroedinger   && require_pkg_config schroedinger-1.0 schroedinger/schro.h schro_init
-enabled libshine          && require_pkg_config shine shine/layer3.h shine_encode_buffer
-enabled libsmbclient      && { use_pkg_config smbclient libsmbclient.h smbc_init ||
+enabled libopenmpt        && require_pkg_config libopenmpt "libopenmpt >= 0.2.6557" libopenmpt/libopenmpt.h openmpt_module_create
+enabled libopus           && {
+    enabled libopus_decoder && {
+        require_pkg_config libopus opus opus_multistream.h opus_multistream_decoder_create
+    }
+    enabled libopus_encoder && {
+        require_pkg_config libopus opus opus_multistream.h opus_multistream_surround_encoder_create
+    }
+}
+enabled libpulse          && require_pkg_config libpulse libpulse pulse/pulseaudio.h pa_context_new
+enabled librsvg           && require_pkg_config librsvg librsvg-2.0 librsvg-2.0/librsvg/rsvg.h rsvg_handle_render_cairo
+enabled librtmp           && require_pkg_config librtmp librtmp librtmp/rtmp.h RTMP_Socket
+enabled librubberband     && require_pkg_config librubberband "rubberband >= 1.8.1" rubberband/rubberband-c.h rubberband_new
+enabled libshine          && require_pkg_config libshine shine shine/layer3.h shine_encode_buffer
+enabled libsmbclient      && { use_pkg_config libsmbclient smbclient libsmbclient.h smbc_init ||
                                require smbclient libsmbclient.h smbc_init -lsmbclient; }
-enabled libsnappy         && require snappy snappy-c.h snappy_compress -lsnappy
+enabled libsnappy         && require libsnappy snappy-c.h snappy_compress -lsnappy
 enabled libsoxr           && require libsoxr soxr.h soxr_create -lsoxr && LIBSOXR="-lsoxr"
-enabled libssh            && require_pkg_config libssh libssh/sftp.h sftp_init
-enabled libspeex          && require_pkg_config speex speex/speex.h speex_decoder_init -lspeex
-enabled libtesseract      && require_pkg_config tesseract tesseract/capi.h TessBaseAPICreate
+enabled libssh            && require_pkg_config libssh libssh libssh/sftp.h sftp_init
+enabled libspeex          && require_pkg_config libspeex speex speex/speex.h speex_decoder_init -lspeex
+enabled libtesseract      && require_pkg_config libtesseract tesseract tesseract/capi.h TessBaseAPICreate
 enabled libtheora         && require libtheora theora/theoraenc.h th_info_init -ltheoraenc -ltheoradec -logg
 enabled libtwolame        && require libtwolame twolame.h twolame_init -ltwolame &&
-                             { check_lib twolame.h twolame_encode_buffer_float32_interleaved -ltwolame ||
+                             { check_lib libtwolame twolame.h twolame_encode_buffer_float32_interleaved -ltwolame ||
                                die "ERROR: libtwolame must be installed and version must be >= 0.3.10"; }
-enabled libv4l2           && require_pkg_config libv4l2 libv4l2.h v4l2_ioctl
-enabled libvidstab        && require_pkg_config "vidstab >= 0.98" vid.stab/libvidstab.h vsMotionDetectInit
+enabled libv4l2           && require_pkg_config libv4l2 libv4l2 libv4l2.h v4l2_ioctl
+enabled libvidstab        && require_pkg_config libvidstab "vidstab >= 0.98" vid.stab/libvidstab.h vsMotionDetectInit
+enabled libvmaf           && require_pkg_config libvmaf libvmaf libvmaf.h compute_vmaf
 enabled libvo_amrwbenc    && require libvo_amrwbenc vo-amrwbenc/enc_if.h E_IF_init -lvo-amrwbenc
-enabled libvorbis         && require libvorbis vorbis/vorbisenc.h vorbis_info_init -lvorbisenc -lvorbis -logg
+enabled libvorbis         && require_pkg_config libvorbis vorbis vorbis/codec.h vorbis_info_init &&
+                             require_pkg_config libvorbisenc vorbisenc vorbis/vorbisenc.h vorbis_encode_init
 
 enabled libvpx            && {
     enabled libvpx_vp8_decoder && {
-        use_pkg_config "vpx >= 0.9.1" "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_vp8_dx ||
-            check_lib2 "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_dec_init_ver -lvpx ||
+        use_pkg_config libvpx_vp8_decoder "vpx >= 0.9.1" "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_vp8_dx ||
+            check_lib libvpx_vp8_decoder "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_dec_init_ver -lvpx ||
                 die "ERROR: libvpx decoder version must be >=0.9.1";
     }
     enabled libvpx_vp8_encoder && {
-        use_pkg_config "vpx >= 0.9.7" "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_vp8_cx ||
-            check_lib2 "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_enc_init_ver VP8E_SET_MAX_INTRA_BITRATE_PCT" -lvpx ||
+        use_pkg_config libvpx_vp8_encoder "vpx >= 0.9.7" "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_vp8_cx ||
+            check_lib libvpx_vp8_encoder "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_enc_init_ver VP8E_SET_MAX_INTRA_BITRATE_PCT" -lvpx ||
                 die "ERROR: libvpx encoder version must be >=0.9.7";
     }
     enabled libvpx_vp9_decoder && {
-        use_pkg_config "vpx >= 1.3.0" "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_vp9_dx ||
-            check_lib2 "vpx/vpx_decoder.h vpx/vp8dx.h" "vpx_codec_vp9_dx" -lvpx ||
-                disable libvpx_vp9_decoder;
+        use_pkg_config libvpx_vp9_decoder "vpx >= 1.3.0" "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_vp9_dx ||
+            check_lib libvpx_vp9_decoder "vpx/vpx_decoder.h vpx/vp8dx.h" "vpx_codec_vp9_dx" -lvpx
     }
     enabled libvpx_vp9_encoder && {
-        use_pkg_config "vpx >= 1.3.0" "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_vp9_cx ||
-            check_lib2 "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_vp9_cx VP9E_SET_AQ_MODE" -lvpx ||
-                disable libvpx_vp9_encoder;
+        use_pkg_config libvpx_vp9_encoder "vpx >= 1.3.0" "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_vp9_cx ||
+            check_lib libvpx_vp9_encoder "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_vp9_cx VP9E_SET_AQ_MODE" -lvpx
     }
     if disabled_all libvpx_vp8_decoder libvpx_vp9_decoder libvpx_vp8_encoder libvpx_vp9_encoder; then
         die "libvpx enabled but no supported decoders found"
@@ -7005,71 +7257,70 @@ enabled libvpx            && {
 
 enabled libwavpack        && require libwavpack wavpack/wavpack.h WavpackOpenFileOutput  -lwavpack
 enabled libwebp           && {
-    enabled libwebp_encoder      && require_pkg_config "libwebp >= 0.2.0" webp/encode.h WebPGetEncoderVersion
-    enabled libwebp_anim_encoder && { use_pkg_config "libwebpmux >= 0.4.0" webp/mux.h WebPAnimEncoderOptionsInit || disable libwebp_anim_encoder; } }
-enabled libx264           && { use_pkg_config x264 "stdint.h x264.h" x264_encoder_encode ||
-                               { require libx264 x264.h x264_encoder_encode -lx264 &&
+    enabled libwebp_encoder      && require_pkg_config libwebp "libwebp >= 0.2.0" webp/encode.h WebPGetEncoderVersion
+    enabled libwebp_anim_encoder && use_pkg_config libwebp_anim_encoder "libwebpmux >= 0.4.0" webp/mux.h WebPAnimEncoderOptionsInit; }
+enabled libx264           && { use_pkg_config libx264 x264 "stdint.h x264.h" x264_encoder_encode ||
+                               { require libx264 "stdint.h x264.h" x264_encoder_encode -lx264 &&
                                  warn "using libx264 without pkg-config"; } } &&
-                             { check_cpp_condition x264.h "X264_BUILD >= 118" ||
-                               die "ERROR: libx264 must be installed and version must be >= 0.118."; } &&
+                             require_cpp_condition x264.h "X264_BUILD >= 118" &&
                              { check_cpp_condition x264.h "X264_MPEG2" &&
                                enable libx262; }
-enabled libx265           && require_pkg_config x265 x265.h x265_api_get &&
-                             { check_cpp_condition x265.h "X265_BUILD >= 68" ||
-                               die "ERROR: libx265 version must be >= 68."; }
-enabled libxavs           && require libxavs xavs.h xavs_encoder_encode -lxavs
+enabled libx265           && require_pkg_config libx265 x265 x265.h x265_api_get &&
+                             require_cpp_condition x265.h "X265_BUILD >= 68"
+enabled libxavs           && require libxavs "stdint.h xavs.h" xavs_encoder_encode -lxavs
 enabled libxvid           && require libxvid xvid.h xvid_global -lxvidcore
-enabled libzimg           && require_pkg_config zimg zimg.h zimg_get_api_version
-enabled libzmq            && require_pkg_config libzmq zmq.h zmq_ctx_new
+enabled libzimg           && require_pkg_config libzimg "zimg >= 2.3.0" zimg.h zimg_get_api_version
+enabled libzmq            && require_pkg_config libzmq libzmq zmq.h zmq_ctx_new
 enabled libzvbi           && require libzvbi libzvbi.h vbi_decoder_new -lzvbi &&
                              { check_cpp_condition libzvbi.h "VBI_VERSION_MAJOR > 0 || VBI_VERSION_MINOR > 2 || VBI_VERSION_MINOR == 2 && VBI_VERSION_MICRO >= 28" ||
                                enabled gpl || die "ERROR: libzvbi requires version 0.2.28 or --enable-gpl."; }
+enabled libxml2           && require_pkg_config libxml2 libxml-2.0 libxml2/libxml/xmlversion.h xmlCheckVersion
 enabled mediacodec        && { enabled jni || die "ERROR: mediacodec requires --enable-jni"; }
-enabled mmal              && { check_lib interface/mmal/mmal.h mmal_port_connect -lmmal_core -lmmal_util -lmmal_vc_client -lbcm_host ||
-                                { ! enabled cross_compile && {
-                                    add_cflags -isystem/opt/vc/include/ -isystem/opt/vc/include/interface/vmcs_host/linux -isystem/opt/vc/include/interface/vcos/pthreads -fgnu89-inline ;
-                                    add_extralibs -L/opt/vc/lib/ -lmmal_core -lmmal_util -lmmal_vc_client -lbcm_host ;
-                                    check_lib interface/mmal/mmal.h mmal_port_connect ; }
-                                check_lib interface/mmal/mmal.h mmal_port_connect ; } ||
-                               die "ERROR: mmal not found"; }
-enabled mmal && check_func_headers interface/mmal/mmal.h "MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS"
-
-enabled netcdf            && require_pkg_config netcdf netcdf.h nc_inq_libvers
-enabled openal            && { { for al_libs in "${OPENAL_LIBS}" "-lopenal" "-lOpenAL32"; do
-                               check_lib 'AL/al.h' alGetError "${al_libs}" && break; done } ||
+enabled mmal              && { check_lib mmal interface/mmal/mmal.h mmal_port_connect -lmmal_core -lmmal_util -lmmal_vc_client -lbcm_host ||
+                               { ! enabled cross_compile &&
+                                 add_cflags -isystem/opt/vc/include/ -isystem/opt/vc/include/interface/vmcs_host/linux -isystem/opt/vc/include/interface/vcos/pthreads -fgnu89-inline &&
+                                 add_ldflags -L/opt/vc/lib/ &&
+                                 check_lib mmal interface/mmal/mmal.h mmal_port_connect -lmmal_core -lmmal_util -lmmal_vc_client -lbcm_host; } ||
+                               die "ERROR: mmal not found" &&
+                               check_func_headers interface/mmal/mmal.h "MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS"; }
+enabled openal            && { { for al_extralibs in "${OPENAL_LIBS}" "-lopenal" "-lOpenAL32"; do
+                               check_lib openal 'AL/al.h' alGetError "${al_extralibs}" && break; done } ||
                                die "ERROR: openal not found"; } &&
                              { check_cpp_condition "AL/al.h" "defined(AL_VERSION_1_1)" ||
                                die "ERROR: openal must be installed and version must be 1.1 or compatible"; }
-enabled opencl            && { check_lib2 OpenCL/cl.h clEnqueueNDRangeKernel -Wl,-framework,OpenCL ||
-                               check_lib2 CL/cl.h clEnqueueNDRangeKernel -lOpenCL ||
+enabled opencl            && { check_lib opencl OpenCL/cl.h clEnqueueNDRangeKernel -Wl,-framework,OpenCL ||
+                               check_lib opencl CL/cl.h clEnqueueNDRangeKernel -lOpenCL ||
                                die "ERROR: opencl not found"; } &&
                              { check_cpp_condition "OpenCL/cl.h" "defined(CL_VERSION_1_2)" ||
                                check_cpp_condition "CL/cl.h" "defined(CL_VERSION_1_2)" ||
                                die "ERROR: opencl must be installed and version must be 1.2 or compatible"; }
-enabled opengl            && { check_lib GL/glx.h glXGetProcAddress "-lGL" ||
-                               check_lib2 windows.h wglGetProcAddress "-lopengl32 -lgdi32" ||
-                               check_lib2 OpenGL/gl3.h glGetError "-Wl,-framework,OpenGL" ||
-                               check_lib2 ES2/gl.h glGetError "-isysroot=${sysroot} -Wl,-framework,OpenGLES" ||
-                               check_lib2 GLES/gl.h glGetError "-Wl,-framework,OpenGLES" ||
-                               { check_lib2 GLES2/gl2.h glGetError "-lGLESv2" &&
-                                 check_lib2 EGL/egl.h eglGetProcAddress "-lEGL"
+enabled opengl            && { check_lib opengl GL/glx.h glXGetProcAddress "-lGL" ||
+                               check_lib opengl windows.h wglGetProcAddress "-lopengl32 -lgdi32" ||
+                               check_lib opengl OpenGL/gl3.h glGetError "-Wl,-framework,OpenGL" ||
+                               check_lib opengl ES2/gl.h glGetError "-isysroot=${sysroot} -Wl,-framework,OpenGLES" ||
+                               check_lib GLES/gl.h glGetError "-Wl,-framework,OpenGLES" ||
+                               { check_lib GLESv2 GLES2/gl2.h glGetError  &&
+                                 check_lib EGL EGL/egl.h eglGetProcAddress
                                } ||
                                die "ERROR: opengl not found."
                              }
-enabled omx_rpi && enable omx
-enabled omx               && { check_header OMX_Core.h ||
-                                { ! enabled cross_compile && enabled omx_rpi && {
-                                    add_cflags -isystem/opt/vc/include/IL ; }
-                                check_header OMX_Core.h ; } ||
+enabled omx_rpi           && { check_header OMX_Core.h ||
+                               { ! enabled cross_compile && add_cflags -isystem/opt/vc/include/IL && check_header OMX_Core.h ; } ||
                                die "ERROR: OpenMAX IL headers not found"; }
-enabled openssl           && { use_pkg_config openssl openssl/ssl.h OPENSSL_init_ssl ||
-                               use_pkg_config openssl openssl/ssl.h SSL_library_init ||
-                               check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto ||
-                               check_lib openssl/ssl.h SSL_library_init -lssl32 -leay32 ||
-                               check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto -lws2_32 -lgdi32 ||
+enabled omx               && require_header OMX_Core.h
+enabled openssl           && { use_pkg_config openssl openssl openssl/ssl.h OPENSSL_init_ssl ||
+                               use_pkg_config openssl openssl openssl/ssl.h SSL_library_init ||
+                               check_lib openssl openssl/ssl.h SSL_library_init -lssl -lcrypto ||
+                               check_lib openssl openssl/ssl.h SSL_library_init -lssl32 -leay32 ||
+                               check_lib openssl openssl/ssl.h SSL_library_init -lssl -lcrypto -lws2_32 -lgdi32 ||
                                die "ERROR: openssl not found"; }
-enabled qtkit_indev      && { check_header_objcc QTKit/QTKit.h || disable qtkit_indev; }
-
+enabled rkmpp             && { { require_pkg_config rockchip_mpp rockchip_mpp rockchip/rk_mpi.h mpp_create ||
+                                 die "ERROR : Rockchip MPP was not found."; } &&
+                               { check_func_headers rockchip/rk_mpi_cmd.h "MPP_DEC_GET_FREE_PACKET_SLOT_COUNT" ||
+                                 die "ERROR: Rockchip MPP is outdated, please get a more recent one."; } &&
+                               { enabled libdrm ||
+                                 die "ERROR: rkmpp requires --enable-libdrm"; }
+                             }
 if enabled libmpeg2external; then
     check_lib mpeg2dec/mpeg2.h mpeg2_init -lmpeg2 || disable libmpeg2external
     if disabled libmpeg2external; then
@@ -7078,25 +7329,17 @@ if enabled libmpeg2external; then
     disable mythtranscode
 fi
 
-# libdc1394 check
-if enabled libdc1394; then
-    { require_pkg_config libdc1394-2 dc1394/dc1394.h dc1394_new &&
-        enable libdc1394_2; } ||
-    { check_lib libdc1394/dc1394_control.h dc1394_create_handle -ldc1394_control -lraw1394 &&
-        enable libdc1394_1; } ||
-    die "ERROR: No version of libdc1394 found "
-fi
 
 if enabled gcrypt; then
     GCRYPT_CONFIG="${cross_prefix}libgcrypt-config"
     if "${GCRYPT_CONFIG}" --version > /dev/null 2>&1; then
         gcrypt_cflags=$("${GCRYPT_CONFIG}" --cflags)
-        gcrypt_libs=$("${GCRYPT_CONFIG}" --libs)
-        check_func_headers gcrypt.h gcry_mpi_new $gcrypt_cflags $gcrypt_libs ||
+        gcrypt_extralibs=$("${GCRYPT_CONFIG}" --libs)
+        check_func_headers gcrypt.h gcry_mpi_new $gcrypt_cflags $gcrypt_extralibs ||
             die "ERROR: gcrypt not found"
-        add_cflags $gcrypt_cflags && add_extralibs $gcrypt_libs
+        add_cflags $gcrypt_cflags && add_extralibs $gcrypt_extralibs
     else
-        require2 gcrypt gcrypt.h gcry_mpi_new -lgcrypt
+        require gcrypt gcrypt.h gcry_mpi_new -lgcrypt
     fi
 fi
 
@@ -7141,41 +7384,56 @@ void foo(){switch (0) case 0: case (sizeof(long) == $sizeof):;}
 EOF
 done
 
-check_foo_config freetype2 freetype ft2build.h FT_Init_FreeType
+# check_foo_config freetype2 freetype ft2build.h FT_Init_FreeType
+if require_pkg_config libfreetype2 freetype2 "ft2build.h FT_FREETYPE_H" FT_Init_FreeType ; then
+    enable freetype2
+else
+    disable freetype2
+fi
 
 enabled freetype2 ||
     die "ERROR! You must have FreeType installed to compile MythTV."
 
 
 ##########################################
-disabled sdl && disable sdl2
-if ! disabled sdl2; then
+if enabled sdl2; then
     SDL2_CONFIG="${cross_prefix}sdl2-config"
-    if check_pkg_config sdl2 SDL_events.h SDL_PollEvent; then
-        check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) >= 0x020001" $sdl2_cflags &&
-        check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) < 0x020100" $sdl2_cflags &&
-        check_func SDL_Init $sdl2_libs $sdl2_cflags && enable sdl2
-    else
-      if "${SDL2_CONFIG}" --version > /dev/null 2>&1; then
+    if check_pkg_config sdl2 "sdl2 >= 2.0.1 sdl2 < 2.1.0" SDL_events.h SDL_PollEvent; then
+        check_func SDL_Init $sdl2_extralibs $sdl2_cflags ||
+            disable sdl2
+    elif "${SDL2_CONFIG}" --version > /dev/null 2>&1; then
         sdl2_cflags=$("${SDL2_CONFIG}" --cflags)
-        sdl2_libs=$("${SDL2_CONFIG}" --libs)
+        sdl2_extralibs=$("${SDL2_CONFIG}" --libs)
         check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) >= 0x020001" $sdl2_cflags &&
         check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) < 0x020100" $sdl2_cflags &&
-        check_func SDL_Init $sdl2_libs $sdl2_cflags && enable sdl2
-      fi
+        check_func SDL_Init $sdl2_extralibs $sdl2_cflags &&
+            enable sdl2
     fi
     if test $target_os = "mingw32"; then
-        sdl2_libs="$sdl2_libs -mconsole"
+        sdl2_extralibs=$(filter_out '-mwindows' $sdl2_extralibs)
     fi
 fi
-enabled sdl2 && add_cflags $sdl2_cflags && add_extralibs $sdl2_libs
+enabled sdl2 && add_cflags $(filter_out '-Dmain=SDL_main' $sdl2_cflags) && add_extralibs $sdl2_extralibs
+
+if enabled decklink; then
+    case $target_os in
+        mingw32*|mingw64*|win32|win64)
+            decklink_outdev_extralibs="$decklink_outdev_extralibs -lole32 -loleaut32"
+            decklink_indev_extralibs="$decklink_indev_extralibs -lole32 -loleaut32"
+            ;;
+    esac
+fi
 
-disabled securetransport || { check_func SecIdentityCreate "-Wl,-framework,CoreFoundation -Wl,-framework,Security" &&
-    check_lib2 "Security/SecureTransport.h Security/Security.h" "SSLCreateContext SecItemImport" "-Wl,-framework,CoreFoundation -Wl,-framework,Security" &&
-    enable securetransport; }
+enabled securetransport &&
+    check_func SecIdentityCreate "-Wl,-framework,CoreFoundation -Wl,-framework,Security" &&
+    check_lib securetransport "Security/SecureTransport.h Security/Security.h" "SSLCreateContext SecItemImport" "-Wl,-framework,CoreFoundation -Wl,-framework,Security" ||
+        disable securetransport
 
-disabled schannel || { check_func_headers "windows.h security.h" InitializeSecurityContext -DSECURITY_WIN32 -lsecur32 &&
-                       check_cpp_condition winerror.h "defined(SEC_I_CONTEXT_EXPIRED)" && enable schannel && add_extralibs -lsecur32; }
+enabled schannel &&
+    check_func_headers "windows.h security.h" InitializeSecurityContext -DSECURITY_WIN32 -lsecur32 &&
+    check_cpp_condition winerror.h "defined(SEC_I_CONTEXT_EXPIRED)" &&
+    add_extralibs -lsecur32 ||
+        disable schannel
 
 makeinfo --version > /dev/null 2>&1 && enable makeinfo  || disable makeinfo
 enabled makeinfo \
@@ -7186,15 +7444,26 @@ perl -v            > /dev/null 2>&1 && enable perl      || disable perl
 pod2man --help     > /dev/null 2>&1 && enable pod2man   || disable pod2man
 rsync --help 2> /dev/null | grep -q 'contimeout' && enable rsync_contimeout || disable rsync_contimeout
 
+# check V4L2 codecs available in the API
 check_header linux/fb.h
-check_header linux/videodev.h
 check_header linux/videodev2.h
 check_code cc linux/videodev2.h "struct v4l2_frmsizeenum vfse; vfse.discrete.width = 0;" && enable_safe struct_v4l2_frmivalenum_discrete
+check_code cc linux/videodev2.h "int i = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_VIDEO_M2M | V4L2_BUF_FLAG_LAST;" || disable v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_VC1_ANNEX_G;" && enable vc1_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_MPEG1;" && enable mpeg1_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_MPEG2;" && enable mpeg2_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_MPEG4;" && enable mpeg4_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_HEVC;" && enable hevc_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_H263;" && enable h263_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_H264;" && enable h264_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_VP8;" && enable vp8_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_VP9;" && enable vp9_v4l2_m2m
 
 check_header sys/videoio.h
 check_code cc sys/videoio.h "struct v4l2_frmsizeenum vfse; vfse.discrete.width = 0;" && enable_safe struct_v4l2_frmivalenum_discrete
 
-check_func_headers "windows.h vfw.h" capCreateCaptureWindow "$vfwcap_indev_extralibs"
+check_lib user32 "windows.h winuser.h" GetShellWindow -luser32
+check_lib vfw32 "windows.h vfw.h" capCreateCaptureWindow -lvfw32
 # check that WM_CAP_DRIVER_CONNECT is defined to the proper value
 # w32api 3.12 had it defined wrong
 check_cpp_condition vfw.h "WM_CAP_DRIVER_CONNECT > WM_USER" && enable vfwcap_defines
@@ -7210,7 +7479,6 @@ check_type "dshow.h" IBaseFilter
   check_header dev/video/bktr/ioctl_bt848.h; } ||
 check_header dev/ic/bt8xx.h
 
-check_header sndio.h
 if check_struct sys/soundcard.h audio_buf_info bytes; then
     enable_safe sys/soundcard.h
 else
@@ -7221,17 +7489,16 @@ EOF
 fi
 check_header soundcard.h
 
-enabled_any alsa_indev alsa_outdev &&
-    check_lib2 alsa/asoundlib.h snd_pcm_htimestamp -lasound
+enabled alsa && check_lib alsa alsa/asoundlib.h snd_pcm_htimestamp -lasound
 
-enabled jack_indev && check_lib2 jack/jack.h jack_client_open -ljack &&
+enabled jack && check_lib jack jack/jack.h jack_client_open -ljack &&
     check_func jack_port_get_latency_range -ljack
 
-enabled_any sndio_indev sndio_outdev && check_lib2 sndio.h sio_open -lsndio
+enabled sndio && check_lib sndio sndio.h sio_open -lsndio
 
 # PulseAudio probe
 ! disabled audio_pulse &&
-    check_lib pulse/version.h pa_get_library_version -lpulse &&
+    check_lib pulse pulse/version.h pa_get_library_version  &&
     $(pkg-config --atleast-version=0.9.7 libpulse) &&
     enable  audio_pulse ||
     disable audio_pulse
@@ -7245,101 +7512,84 @@ fi
 
 # ALSA probe
 ! disabled audio_alsa &&
-    check_lib alsa/asoundlib.h snd_asoundlib_version -lasound &&
+    check_lib asound alsa/asoundlib.h snd_asoundlib_version  &&
     check_cpp_condition alsa/asoundlib.h "(defined(SND_PCM_NO_AUTO_RESAMPLE))" &&
     enable  audio_alsa ||
     { { ! enabled audio_alsa || die "ERROR: Alsa >= 1.0.16 required"; } &&
     disable audio_alsa; }
 
 if enabled libcdio; then
-    check_lib2 "cdio/cdda.h cdio/paranoia.h" cdio_cddap_open -lcdio_paranoia -lcdio_cdda -lcdio ||
-    check_lib2 "cdio/paranoia/cdda.h cdio/paranoia/paranoia.h" cdio_cddap_open -lcdio_paranoia -lcdio_cdda -lcdio ||
+    check_lib libcdio "cdio/cdda.h cdio/paranoia.h" cdio_cddap_open -lcdio_paranoia -lcdio_cdda -lcdio ||
+    check_lib libcdio "cdio/paranoia/cdda.h cdio/paranoia/paranoia.h" cdio_cddap_open -lcdio_paranoia -lcdio_cdda -lcdio ||
     die "ERROR: No usable libcdio/cdparanoia found"
 fi
 
-enabled xlib &&
-    check_lib X11/Xlib.h XOpenDisplay -lX11 || disable xlib
-
-if ! disabled libxcb; then
-    check_pkg_config "xcb >= 1.4" xcb/xcb.h xcb_connect || {
-        enabled libxcb && die "ERROR: libxcb >= 1.4 not found";
-    } && disable x11grab && enable libxcb
+enabled libxcb && check_pkg_config libxcb "xcb >= 1.4" xcb/xcb.h xcb_connect ||
+    disable libxcb_shm libxcb_shape libxcb_xfixes
 
 if enabled libxcb; then
-    disabled libxcb_shm || {
-        check_pkg_config xcb-shm xcb/shm.h xcb_shm_attach || {
-            enabled libxcb_shm && die "ERROR: libxcb_shm not found";
-        } && check_header sys/shm.h && enable libxcb_shm; }
-
-    disabled libxcb_xfixes || {
-        check_pkg_config xcb-xfixes xcb/xfixes.h xcb_xfixes_get_cursor_image || {
-            enabled libxcb_xfixes && die "ERROR: libxcb_xfixes not found";
-        } && enable libxcb_xfixes; }
-
-    disabled libxcb_shape || {
-        check_pkg_config xcb-shape xcb/shape.h xcb_shape_get_rectangles || {
-            enabled libxcb_shape && die "ERROR: libxcb_shape not found";
-        } && enable libxcb_shape; }
+    enabled libxcb_shm    && check_pkg_config libxcb_shm    xcb-shm    xcb/shm.h    xcb_shm_attach
+    enabled libxcb_shape  && check_pkg_config libxcb_shape  xcb-shape  xcb/shape.h  xcb_shape_get_rectangles
+    enabled libxcb_xfixes && check_pkg_config libxcb_xfixes xcb-xfixes xcb/xfixes.h xcb_xfixes_get_cursor_image
 
     add_cflags $xcb_cflags $xcb_shm_cflags $xcb_xfixes_cflags $xcb_shape_cflags
-    add_extralibs $xcb_libs $xcb_shm_libs $xcb_xfixes_libs $xcb_shape_libs
-fi
-fi
-
-if enabled x11grab; then
-    enabled xlib || die "ERROR: Xlib not found"
-    require Xext X11/extensions/XShm.h XShmCreateImage -lXext
-    require Xfixes X11/extensions/Xfixes.h XFixesGetCursorImage -lXfixes
+    add_extralibs $xcb_extralibs $xcb_shm_extralibs $xcb_xfixes_extralibs $xcb_shape_extralibs
 fi
 
 check_func_headers "windows.h" CreateDIBSection "$gdigrab_indev_extralibs"
 
-enabled dxva2api_h &&
-    check_cc <<EOF && enable dxva2api_cobj
-#define _WIN32_WINNT 0x0600
-#define COBJMACROS
-#include <windows.h>
-#include <d3d9.h>
-#include <dxva2api.h>
-int main(void) { IDirectXVideoDecoder *o = NULL; IDirectXVideoDecoder_Release(o); return 0; }
+# d3d11va requires linking directly to dxgi and d3d11 if not building for
+# the desktop api partition
+check_cpp <<EOF && enable uwp && d3d11va_extralibs="-ldxgi -ld3d11"
+#ifdef WINAPI_FAMILY
+#include <winapifamily.h>
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#error desktop, not uwp
+#else
+// WINAPI_FAMILY_APP, WINAPI_FAMILY_PHONE_APP => UWP
+#endif
+#else
+#error no family set
+#endif
 EOF
 
 enabled vaapi && enabled opengl &&
     check_header GL/glx.h &&
-    check_lib va/va.h vaInitialize -lva ||
-    disable vaapi
+    check_lib vaapi va/va.h vaInitialize -lva
 
 enabled vaapi &&
     check_code cc "va/va.h" "vaCreateSurfaces(0, 0, 0, 0, 0, 0, 0, 0)" ||
     disable vaapi
 
-if enabled vaapi ; then
-    enabled xlib &&
-    check_lib2 "va/va.h va/va_x11.h" vaGetDisplay -lva -lva-x11 &&
-    enable vaapi_x11
+enabled vaapi &&
+    check_lib vaapi_drm "va/va.h va/va_drm.h" vaGetDisplayDRM -lva -lva-drm
 
-    check_lib2 "va/va.h va/va_drm.h" vaGetDisplayDRM -lva -lva-drm &&
-    enable vaapi_drm
-fi
+enabled vaapi &&
+    check_lib vaapi_x11 "va/va.h va/va_x11.h" vaGetDisplay -lva -lva-x11 -lX11
+
+enabled vaapi &&
+    check_cpp_condition "va/va.h" "VA_CHECK_VERSION(1, 0, 0)" &&
+    enable vaapi_1
 
 enabled vdpau &&
     check_cpp_condition vdpau/vdpau.h "defined VDP_DECODER_PROFILE_MPEG4_PART2_ASP" ||
     disable vdpau
 
-enabled vdpau && enabled xlib &&
-    check_lib2 "vdpau/vdpau.h vdpau/vdpau_x11.h" vdp_device_create_x11 -lvdpau &&
-    enable vdpau_x11
+enabled vdpau &&
+    check_lib vdpau_x11 "vdpau/vdpau.h vdpau/vdpau_x11.h" vdp_device_create_x11 -lvdpau -lX11
+
+enabled crystalhd && check_lib crystalhd "stdint.h libcrystalhd/libcrystalhd_if.h" DtsCrystalHDVersion -lcrystalhd
 
 if enabled x86; then
     case $target_os in
         mingw32*|mingw64*|win32|win64|linux|cygwin*)
             ;;
         *)
-            disable nvenc
+            disable cuda cuvid nvenc
             ;;
     esac
 else
-    disable nvenc
+    disable cuda cuvid nvenc
 fi
 
 enabled nvenc &&
@@ -7351,7 +7601,11 @@ int main(void) { return 0; }
 EOF
 
 # Funny iconv installations are not unusual, so check it after all flags have been set
-disabled iconv || check_func_headers iconv.h iconv || check_lib2 iconv.h iconv -liconv || disable iconv
+if enabled libc_iconv; then
+    check_func_headers iconv.h iconv
+elif enabled iconv; then
+    check_func_headers iconv.h iconv || check_lib iconv iconv.h iconv -liconv
+fi
 
 enabled debug && add_cflags -g"$debuglevel" && add_asflags -g"$debuglevel"
 enabled debug && add_cxxflags -g"$debuglevel"
@@ -7371,19 +7625,41 @@ if [ "$target_os" != "darwin" ]; then
 fi
 check_cflags -Wno-pointer-to-int-cast
 check_cflags -Wstrict-prototypes
-enabled extra_warnings && check_cflags -Winline
-enabled extra_warnings && check_cflags -Wcast-qual
+
+if enabled extra_warnings; then
+    check_cflags -Wcast-qual
+    check_cflags -Wextra
+    check_cflags -Wpedantic
+fi
 
 check_disable_warning(){
     warning_flag=-W${1#-Wno-}
-    test_cflags $warning_flag && add_cflags $1
+    test_cflags $unknown_warning_flags $warning_flag && add_cflags $1
 }
 
+test_cflags -Werror=unused-command-line-argument &&
+    append unknown_warning_flags "-Werror=unused-command-line-argument"
+test_cflags -Werror=unknown-warning-option &&
+    append unknown_warning_flags "-Werror=unknown-warning-option"
+
 check_disable_warning -Wno-parentheses
 disabled icc && check_disable_warning -Wno-switch
 check_disable_warning -Wno-format-zero-length
 check_disable_warning -Wno-pointer-sign
 check_disable_warning -Wno-unused-const-variable
+check_disable_warning -Wno-bool-operation
+
+check_disable_warning_headers(){
+    warning_flag=-W${1#-Wno-}
+    test_cflags $warning_flag && add_cflags_headers $1
+}
+
+check_disable_warning_headers -Wno-deprecated-declarations
+check_disable_warning_headers -Wno-unused-variable
+
+check_cc <<EOF && enable blocks_extension
+void (^block)(void);
+EOF
 
 # C++ Flags
 check_cxxflags -Wall
@@ -7401,8 +7677,7 @@ enabled rpath && add_ldlibflags -Wl,-rpath,$libdir
 test_ldflags -Wl,-Bsymbolic && append SHFLAGS -Wl,-Bsymbolic
 
 # add some strip flags
-# -wN '..@*' is more selective than -x, but not available everywhere.
-check_stripflags -wN \'..@*\' || check_stripflags -x
+check_stripflags -x
 
 enabled neon_clobber_test &&
     check_ldflags -Wl,--wrap,avcodec_open2              \
@@ -7411,11 +7686,11 @@ enabled neon_clobber_test &&
                   -Wl,--wrap,avcodec_decode_subtitle2   \
                   -Wl,--wrap,avcodec_encode_audio2      \
                   -Wl,--wrap,avcodec_encode_video2      \
+                  -Wl,--wrap,avcodec_encode_subtitle    \
                   -Wl,--wrap,avcodec_send_packet        \
-                  -Wl,--wrap,avcodec_receive_frame      \
-                  -Wl,--wrap,avcodec_send_frame         \
                   -Wl,--wrap,avcodec_receive_packet     \
-                  -Wl,--wrap,avcodec_encode_subtitle    \
+                  -Wl,--wrap,avcodec_send_frame         \
+                  -Wl,--wrap,avcodec_receive_frame      \
                   -Wl,--wrap,swr_convert                \
                   -Wl,--wrap,avresample_convert ||
     disable neon_clobber_test
@@ -7429,9 +7704,9 @@ enabled xmm_clobber_test &&
                   -Wl,--wrap,avcodec_encode_video2      \
                   -Wl,--wrap,avcodec_encode_subtitle    \
                   -Wl,--wrap,avcodec_send_packet        \
-                  -Wl,--wrap,avcodec_receive_frame      \
-                  -Wl,--wrap,avcodec_send_frame         \
                   -Wl,--wrap,avcodec_receive_packet     \
+                  -Wl,--wrap,avcodec_send_frame         \
+                  -Wl,--wrap,avcodec_receive_frame      \
                   -Wl,--wrap,swr_convert                \
                   -Wl,--wrap,avresample_convert         \
                   -Wl,--wrap,sws_scale ||
@@ -7468,11 +7743,24 @@ if [ -z "$optflags" ]; then
     fi
 fi
 
+if [ -z "$nvccflags" ]; then
+    nvccflags=$nvccflags_default
+fi
+
+if enabled x86_64 || enabled ppc64 || enabled aarch64; then
+    nvccflags="$nvccflags -m64"
+else
+    nvccflags="$nvccflags -m32"
+fi
+
 check_optflags(){
     check_cflags "$@"
     enabled lto && check_ldflags "$@"
 }
 
+check_optflags $optflags
+check_optflags -fno-math-errno
+check_optflags -fno-signed-zeros
 
 if enabled lto; then
     test "$cc_type" != "$ld_type" && die "LTO requires same compiler and linker"
@@ -7481,10 +7769,6 @@ if enabled lto; then
     disable inline_asm_direct_symbol_refs
 fi
 
-check_optflags $optflags
-check_optflags -fno-math-errno
-check_optflags -fno-signed-zeros
-
 enabled ftrapv && check_cflags -ftrapv
 
 if enabled dvb; then
@@ -7531,18 +7815,18 @@ int main(void) { return 1; }
 EOF
 
 if enabled systemd_notify ; then
-    if check_pkg_config libsystemd-daemon systemd/sd-daemon.h sd_notify ; then
-        require_pkg_config libsystemd-daemon systemd/sd-daemon.h sd_notify
-    elif check_pkg_config libsystemd systemd/sd-daemon.h sd_notify ; then
-        require_pkg_config libsystemd systemd/sd-daemon.h sd_notify
+    if check_pkg_config systemd_notify libsystemd-daemon systemd/sd-daemon.h sd_notify ; then
+        require_pkg_config systemd_notify libsystemd-daemon systemd/sd-daemon.h sd_notify
+    elif check_pkg_config systemd_notify libsystemd systemd/sd-daemon.h sd_notify ; then
+        require_pkg_config systemd_notify libsystemd systemd/sd-daemon.h sd_notify
     else
         disable systemd_notify
     fi
 fi
 
 if enabled systemd_journal ; then
-   if check_pkg_config libsystemd systemd/sd-journal.h sd_journal_send ; then
-        require_pkg_config libsystemd systemd/sd-journal.h sd_journal_send
+   if check_pkg_config systemd_journal libsystemd systemd/sd-journal.h sd_journal_send ; then
+        require_pkg_config systemd_journal libsystemd systemd/sd-journal.h sd_journal_send
    else
         disable systemd_journal
    fi
@@ -7637,11 +7921,11 @@ if enabled firewire; then
     fi
 fi
 
-enabled libfftw3 && check_lib2 fftw3.h fftw_init_threads -lfftw3_threads -lfftw3f -lfftw3 ||
+enabled libfftw3 && check_lib fftw3_threads fftw3.h fftw_init_threads  -lfftw3f -lfftw3 ||
     disable libfftw3
 
 # ass_flush_events was added in 0.9.10
-enabled libass && check_lib2 ass/ass.h ass_flush_events -lass || disable libass
+enabled libass && check_lib ass ass/ass.h ass_flush_events  || disable libass
 
 if enabled libcec ; then
     if pkg-config --exists libcec; then
@@ -7664,10 +7948,10 @@ EOF
     fi
 fi
 
-enabled libcrypto && check_lib openssl/rsa.h RSA_new -lcrypto || disable libcrypto
+enabled libcrypto && check_lib crypto openssl/rsa.h RSA_new -lcrypto || disable libcrypto
 
 if test $target_os != darwin ; then
-    enabled libdns_sd && check_lib dns_sd.h DNSServiceRegister -ldns_sd || disable libdns_sd
+    enabled libdns_sd && check_lib dns_sd dns_sd.h DNSServiceRegister -ldns_sd || disable libdns_sd
 fi
 
 if enabled libxml2 ; then
@@ -7692,14 +7976,14 @@ if enabled taglib; then
     taglib_libs=`taglib-config --libs`
 fi
 
-enabled x11 && check_lib X11/Xlib.h XQueryExtension -lX11 || disable x11
-enabled xrandr && check_lib X11/extensions/Xrandr.h XRRSelectInput -lXrandr || disable xrandr
-enabled xv && check_lib X11/extensions/Xv.h XvPutStill -lXv || disable xv
+enabled x11 && check_lib X11 "X11/Xdefs.h X11/Xlib.h" XQueryExtension  || disable x11
+enabled xrandr && check_lib Xrandr "X11/Xdefs.h X11/Xlib.h X11/extensions/Xrandr.h" XRRSelectInput -lXrandr || disable xrandr
+enabled xv && check_lib Xv "X11/Xdefs.h X11/Xlib.h X11/extensions/Xvlib.h" XvPutStill -lXv || disable xv
 
 if enabled x11; then
-    require libXxf86vm X11/extensions/xf86vmode.h XF86VidModeSetClientVersion -lXxf86vm
+    require libXxf86vm "X11/Xdefs.h X11/Xlib.h X11/extensions/xf86vmode.h" XF86VidModeSetClientVersion -lXxf86vm
     require libXinerama X11/extensions/Xinerama.h XineramaQueryExtension -lXinerama
-    require libXext X11/extensions/Xext.h XMissingExtension -lXext
+    require libXext "X11/Xdefs.h X11/Xlib.h X11/extensions/Xext.h" XMissingExtension -lXext
 fi
 
 if enabled x11; then
@@ -7869,17 +8153,19 @@ elif enabled_any msvc icl; then
 __declspec($_restrict) void* foo(int);
 EOF
     fi
-    check_func strtoll || add_cflags -Dstrtoll=_strtoi64
     # the new SSA optimzer in VS2015 U3 is mis-optimizing some parts of the code
-    # this flag should be re-checked on newer compiler releases and put under a
-    # version check once its fixed
-    check_cflags -d2SSAOptimizer-
+    # Issue has been fixed in MSVC v19.00.24218.
+    check_cpp_condition windows.h "_MSC_FULL_VER >= 190024218" ||
+        check_cflags -d2SSAOptimizer-
+    # enable utf-8 source processing on VS2015 U2 and newer
+    check_cpp_condition windows.h "_MSC_FULL_VER >= 190023918" &&
+        add_cflags -utf-8
 fi
 
 for pfx in "" host_; do
     varname=${pfx%_}cc_type
     eval "type=\$$varname"
-    if [ $type = "msvc" ]; then
+    if [ "$type" = "msvc" ]; then
         check_${pfx}cc <<EOF || add_${pfx}cflags -Dinline=__inline
 static inline int foo(int a) { return a; }
 EOF
@@ -7975,9 +8261,6 @@ case $target_os in
     osf1)
         enabled ccc && add_ldflags '-Wl,-expect_unresolved,*'
     ;;
-    plan9)
-        add_cppflags -Dmain=plan9_main
-    ;;
 esac
 
 enable frame_thread_encoder
@@ -8001,13 +8284,6 @@ if test $target_os = "haiku"; then
     disable posix_memalign
 fi
 
-enabled_all dxva2 dxva2api_cobj CoTaskMemFree &&
-    prepend ffmpeg_libs $($ldflags_filter "-lole32" "-luser32") &&
-    enable dxva2_lib
-
-! enabled_any memalign posix_memalign aligned_malloc &&
-    enabled simd_align_16 && enable memalign_hack
-
 # add_dep lib dep
 # -> enable ${lib}_deps_${dep}
 # -> add $dep to ${lib}_deps only once
@@ -8045,19 +8321,41 @@ for thread in $THREADS_LIST; do
     fi
 done
 
+if disabled stdatomic_h; then
+    if enabled atomics_gcc; then
+        add_cppflags '-I\$(SRC_PATH)/compat/atomics/gcc'
+    elif enabled atomics_win32; then
+        add_cppflags '-I\$(SRC_PATH)/compat/atomics/win32'
+    elif enabled atomics_suncc; then
+        add_cppflags '-I\$(SRC_PATH)/compat/atomics/suncc'
+    elif enabled pthreads; then
+        add_compat atomics/pthread/stdatomic.o
+        add_cppflags '-I\$(SRC_PATH)/compat/atomics/pthread'
+    else
+        enabled threads && die "Threading is enabled, but no atomics are available"
+        add_cppflags '-I\$(SRC_PATH)/compat/atomics/dummy'
+    fi
+fi
+
+# Check if requested libraries were found.
+for lib in $AUTODETECT_LIBS; do
+    requested $lib && ! enabled $lib && die "ERROR: $lib requested but not found";
+done
+
 enabled zlib && add_cppflags -DZLIB_CONST
 
 # conditional library dependencies, in linking order
 enabled afftfilt_filter     && prepend avfilter_deps "avcodec"
+enabled afir_filter         && prepend avfilter_deps "avcodec"
 enabled amovie_filter       && prepend avfilter_deps "avformat avcodec"
 enabled aresample_filter    && prepend avfilter_deps "swresample"
-enabled asyncts_filter      && prepend avfilter_deps "avresample"
 enabled atempo_filter       && prepend avfilter_deps "avcodec"
 enabled cover_rect_filter   && prepend avfilter_deps "avformat avcodec"
 enabled ebur128_filter && enabled swresample && prepend avfilter_deps "swresample"
 enabled elbg_filter         && prepend avfilter_deps "avcodec"
 enabled fftfilt_filter      && prepend avfilter_deps "avcodec"
 enabled find_rect_filter    && prepend avfilter_deps "avformat avcodec"
+enabled firequalizer_filter && prepend avfilter_deps "avcodec"
 enabled mcdeint_filter      && prepend avfilter_deps "avcodec"
 enabled movie_filter    && prepend avfilter_deps "avformat avcodec"
 enabled pan_filter          && prepend avfilter_deps "swresample"
@@ -8071,10 +8369,13 @@ enabled sofalizer_filter    && prepend avfilter_deps "avcodec"
 enabled showcqt_filter      && prepend avfilter_deps "avformat avcodec swscale"
 enabled showfreqs_filter    && prepend avfilter_deps "avcodec"
 enabled showspectrum_filter && prepend avfilter_deps "avcodec"
+enabled signature_filter    && prepend avfilter_deps "avcodec avformat"
 enabled smartblur_filter    && prepend avfilter_deps "swscale"
 enabled spectrumsynth_filter && prepend avfilter_deps "avcodec"
+enabled spp_filter          && prepend avfilter_deps "avcodec"
 enabled subtitles_filter    && prepend avfilter_deps "avformat avcodec"
 enabled uspp_filter         && prepend avfilter_deps "avcodec"
+enabled zoompan_filter      && prepend avfilter_deps "swscale"
 
 enabled lavfi_indev         && prepend avdevice_deps "avfilter"
 
@@ -8098,6 +8399,19 @@ fi
 
 enabled asm || { arch=c; disable $ARCH_LIST $ARCH_EXT_LIST; }
 
+license="LGPL version 2.1 or later"
+if enabled nonfree; then
+    license="nonfree and unredistributable"
+elif enabled gplv3; then
+    license="GPL version 3 or later"
+elif enabled lgplv3; then
+    license="LGPL version 3 or later"
+elif enabled gpl; then
+    license="GPL version 2 or later"
+fi
+
+if test "$quiet" != "yes"; then
+
 echo "# Basic Settings"
 echo "Qt minimum version        $QT_MIN_VERSION_STR"
 echo "Qt installed version      `$qmake -query QT_VERSION`"
@@ -8138,7 +8452,8 @@ echo "big-endian                ${bigendian-no}"
 echo "runtime cpu detection     ${runtime_cpudetect-no}"
 BLOCK_QUOTE
 if enabled x86; then
-    echo "${yasmexe}                      ${yasm-no}"
+    echo "standalone assembly       ${x86asm-no}"
+    echo "x86 assembler             ${x86asmexe}"
     echo "MMX enabled               ${mmx-no}"
     echo "MMXEXT enabled            ${mmxext-no}"
     echo "3DNow! enabled            ${amd3dnow-no}"
@@ -8147,6 +8462,7 @@ if enabled x86; then
     echo "SSSE3 enabled             ${ssse3-no}"
     echo "AESNI enabled             ${aesni-no}"
     echo "AVX enabled               ${avx-no}"
+    echo "AVX2 enabled              ${avx2-no}"
     echo "XOP enabled               ${xop-no}"
     echo "FMA3 enabled              ${fma3-no}"
     echo "FMA4 enabled              ${fma4-no}"
@@ -8192,13 +8508,9 @@ echo "optimizations             ${optimizations-no}"
 echo "static                    ${static-no}"
 echo "shared                    ${shared-no}"
 echo "postprocessing support    ${postproc-no}"
-echo "new filter support        ${avfilter-no}"
 echo "network support           ${network-no}"
 echo "threading support         ${thread_type-no}"
 echo "safe bitstream reader     ${safe_bitstream_reader-no}"
-echo "SDL2 support              ${sdl2-no}"
-echo "opencl enabled            ${opencl-no}"
-echo "JNI support               ${jni-no}"
 echo "texi2html enabled         ${texi2html-no}"
 echo "perl enabled              ${perl-no}"
 echo "pod2man enabled           ${pod2man-no}"
@@ -8208,10 +8520,6 @@ test -n "$random_seed" &&
     echo "random seed               ${random_seed}"
 echo
 
-echo "Enabled programs:"
-print_enabled '' $PROGRAM_LIST | print_in_columns
-echo
-
 echo "External libraries:"
 print_enabled '' $EXTERNAL_LIBRARY_LIST | print_in_columns
 echo
@@ -8224,6 +8532,10 @@ echo "Libraries:"
 print_enabled '' $LIBRARY_LIST | print_in_columns
 echo
 
+echo "Programs:"
+print_enabled '' $PROGRAM_LIST | print_in_columns
+echo
+
 for type in decoder encoder hwaccel parser demuxer muxer protocol filter bsf indev outdev; do
     echo "Enabled ${type}s:"
     eval list=\$$(toupper $type)_LIST
@@ -8231,20 +8543,20 @@ for type in decoder encoder hwaccel parser demuxer muxer protocol filter bsf ind
     echo
 done
 
-license="LGPL version 2.1 or later"
-if enabled nonfree; then
-    license="nonfree and unredistributable"
-elif enabled gplv3; then
-    license="GPL version 3 or later"
-elif enabled lgplv3; then
-    license="LGPL version 3 or later"
-elif enabled gpl; then
-    license="GPL version 2 or later"
+if test -n "$ignore_tests"; then
+    ignore_tests=$(echo $ignore_tests | tr ',' ' ')
+    echo "Ignored FATE tests:"
+    echo $ignore_tests | print_in_columns
+    echo
 fi
 
 echo "License: $license"
 BLOCK_QUOTE
 
+echo "Creating configuration files ..."
+
+fi # test "$quiet" != "yes"
+
 echo
 if enabled frontend; then
   echo "# Input Support"
@@ -8313,8 +8625,9 @@ if enabled source_path_used; then
 fi
 
 enabled stripping || strip="echo skipping strip"
+enabled stripping || striptype=""
 
-config_files="$TMPH $TMPMAK"
+config_files="$TMPH $TMPMAK doc/config.texi"
 
 if enabled backend; then
   echo "Video4Linux support       ${v4l2-no}"
@@ -8460,13 +8773,16 @@ DEPCC=$dep_cc
 DEPCCFLAGS=$DEPCCFLAGS \$(CPPFLAGS)
 DEPAS=$as
 DEPASFLAGS=$DEPASFLAGS \$(CPPFLAGS)
-YASM=$yasmexe
-DEPYASM=$yasmexe
+X86ASM=$x86asmexe
+DEPX86ASM=$x86asmexe
+DEPX86ASMFLAGS=\$(X86ASMFLAGS)
 AR=$ar
 ARFLAGS=$arflags
 AR_O=$ar_o
 RANLIB=$ranlib
 STRIP=$strip
+STRIPTYPE=$striptype
+NVCC=$nvcc
 CP=cp -p
 LN_S=$ln_s
 CPPFLAGS=$CPPFLAGS
@@ -8474,6 +8790,7 @@ CFLAGS=$CFLAGS
 CXXFLAGS=$CXXFLAGS
 OBJCFLAGS=$OBJCFLAGS
 ASFLAGS=$ASFLAGS
+NVCCFLAGS=$nvccflags
 AS_C=$AS_C
 AS_O=$AS_O
 OBJCC_C=$OBJCC_C
@@ -8484,7 +8801,10 @@ CC_E=$CC_E
 CC_O=$CC_O
 CXX_C=$CXX_C
 CXX_O=$CXX_O
+NVCC_C=$NVCC_C
+NVCC_O=$NVCC_O
 LD_O=$LD_O
+X86ASM_O=$X86ASM_O
 LD_LIB=$LD_LIB
 LD_MYTH_LIB=$LD_MYTH_LIB
 LD_PATH=$LD_PATH
@@ -8500,7 +8820,7 @@ LDEXEFLAGS=$LDEXEFLAGS
 LDLIBFLAGS=$LDLIBFLAGS
 #SHFLAGS=$(echo $($ldflags_filter $SHFLAGS))
 ASMSTRIPFLAGS=$ASMSTRIPFLAGS
-YASMFLAGS=$YASMFLAGS
+X86ASMFLAGS=$X86ASMFLAGS
 BUILDSUF=$build_suffix
 PROGSSUF=$progs_suffix
 FULLNAME=$FULLNAME
@@ -8516,15 +8836,18 @@ CXXDEP=$CXXDEP
 CCDEP_FLAGS=$CCDEP_FLAGS
 ASDEP=$ASDEP
 ASDEP_FLAGS=$ASDEP_FLAGS
+X86ASMDEP=$X86ASMDEP
+X86ASMDEP_FLAGS=$X86ASMDEP_FLAGS
 CC_DEPFLAGS=$CC_DEPFLAGS
 AS_DEPFLAGS=$AS_DEPFLAGS
+X86ASM_DEPFLAGS=$X86ASM_DEPFLAGS
 HOSTCC=$host_cc
 HOSTLD=$host_ld
 HOSTCFLAGS=$host_cflags
 HOSTCPPFLAGS=$host_cppflags
 HOSTEXESUF=$HOSTEXESUF
 HOSTLDFLAGS=$host_ldflags
-HOSTLIBS=$host_libs
+HOSTEXTRALIBS=$host_extralibs
 DEPHOSTCC=$host_cc
 DEPHOSTCCFLAGS=$DEPHOSTCCFLAGS \$(HOSTCCFLAGS)
 HOSTCCDEP=$HOSTCCDEP
@@ -8537,11 +8860,11 @@ TARGET_EXEC=$target_exec $target_exec_args
 TARGET_PATH=$target_path
 TARGET_SAMPLES=${target_samples:-\$(SAMPLES)}
 CFLAGS-ffplay=${sdl2_cflags}
+CFLAGS_HEADERS=$CFLAGS_HEADERS
 ZLIB=$($ldflags_filter -lz)
 #LIB_INSTALL_EXTRA_CMD=$_LIB_INSTALL_EXTRA_CMD
 EXTRALIBS=$extralibs $ldl
 COMPAT_OBJS=$compat_objs
-EXEOBJS=$exeobjs
 INSTALL=$install
 LIBTARGET=${LIBTARGET}
 SLIBNAME=${SLIBNAME}
@@ -8558,34 +8881,22 @@ SLIB_INSTALL_EXTRA_SHLIB=${SLIB_INSTALL_EXTRA_SHLIB}
 VERSION_SCRIPT_POSTPROCESS_CMD=${VERSION_SCRIPT_POSTPROCESS_CMD}
 SAMPLES=$samples
 NOREDZONE_FLAGS=$noredzone_flags
+LIBFUZZER_PATH=$libfuzzer_path
+IGNORE_TESTS=$ignore_tests
 ANTBIN=$antbin
 BDJ_TYPE=$bdj_type
 JDK_HOME=$JDK_HOME
 JAVA_ARCH=$java_arch
 EOF
 
-get_version(){
-    lcname=lib${1}
-    name=$(toupper $lcname)
-    file=$source_path/external/FFmpeg/$lcname/version.h
-    eval $(awk "/#define ${name}_VERSION_M/ { print \$2 \"=\" \$3 }" "$file")
-    enabled raise_major && eval ${name}_VERSION_MAJOR=$((${name}_VERSION_MAJOR+100))
-    eval ${name}_VERSION=\$${name}_VERSION_MAJOR.\$${name}_VERSION_MINOR.\$${name}_VERSION_MICRO
-    eval echo "${lcname}_VERSION=\$${name}_VERSION" >> $TMPMAK
-    eval echo "${lcname}_VERSION_MAJOR=\$${name}_VERSION_MAJOR" >> $TMPMAK
-    eval echo "${lcname}_VERSION_MINOR=\$${name}_VERSION_MINOR" >> $TMPMAK
-}
-
-map 'get_version $v' $LIBRARY_LIST
-
 map 'eval echo "${v}_FFLIBS=\$${v}_deps" >> $TMPMAK' $LIBRARY_LIST
 
-print_program_libs(){
-    eval "program_libs=\$${1}_libs"
-    eval echo "LIBS-${1}=${program_libs}" >> $TMPMAK
+print_program_extralibs(){
+    eval "program_extralibs=\$${1}_extralibs"
+    eval echo "EXTRALIBS-${1}=${program_extralibs}" >> $TMPMAK
 }
 
-map 'print_program_libs $v' $PROGRAM_LIST
+map 'print_program_extralibs $v' $PROGRAM_LIST
 
 echo "RUNPREFIX=$runprefix" >> $TMPMAK
 echo "SYSROOT=$sysroot" >> $TMPMAK
@@ -8620,7 +8931,7 @@ cat > $TMPH <<EOF
 #define QT_MIN_VERSION $QT_MIN_VERSION
 #define FFMPEG_CONFIGURATION "$(c_escape $FFMPEG_CONFIGURATION)"
 #define FFMPEG_LICENSE "$(c_escape $license)"
-#define CONFIG_THIS_YEAR 2016
+#define CONFIG_THIS_YEAR 2017
 #define FFMPEG_DATADIR "$(eval c_escape $datadir)"
 #define AVCONV_DATADIR "$(eval c_escape $datadir)"
 #define CC_IDENT "$(c_escape ${cc_ident:-Unknown compiler})"
@@ -8667,7 +8978,7 @@ if enabled cygwin ; then
   echo "#endif" >> $TMPH
 fi
 
-if enabled yasm; then
+if enabled x86asm; then
     append config_files $TMPASM
     printf '' >$TMPASM
 fi
@@ -8852,7 +9163,7 @@ fi
 
 
 # create config.mak for external/FFmpeg
-cat >  external/FFmpeg/config.mak <<EOF
+cat >  external/FFmpeg/ffbuild/config.mak <<EOF
 # Automatically generated by configure - do not modify!
 ifndef FFMPEG_CONFIG_MAK
 FFMPEG_CONFIG_MAK=1
@@ -8864,8 +9175,8 @@ SLIB_INSTALL_EXTRA_CMD=${SLIB_INSTALL_EXTRA_CMD}
 SLIB_UNINSTALL_EXTRA_CMD=${SLIB_UNINSTALL_EXTRA_CMD}
 EOF
 # Strip out the old dirs that we are about to put back in.
-sed -e '/^S?H?LIBDIR=.*$/d' -e '/^INCDIR=.*$/d' -e '/^BINDIR=.*$/d' -e '/^DATADIR=.*$/d' -e '/^MANDIR=.*$/d' $TMPMAK >> external/FFmpeg/config.mak
-cat >> external/FFmpeg/config.mak <<EOF
+sed -e '/^S?H?LIBDIR=.*$/d' -e '/^INCDIR=.*$/d' -e '/^BINDIR=.*$/d' -e '/^DATADIR=.*$/d' -e '/^MANDIR=.*$/d' $TMPMAK >> external/FFmpeg/ffbuild/config.mak
+cat >> external/FFmpeg/ffbuild/config.mak <<EOF
 LIBDIR=\$(INSTALL_ROOT)$libdir
 SHLIBDIR=\$(INSTALL_ROOT)$shlibdir
 INCDIR=\$(INSTALL_ROOT)$incdir
@@ -8877,11 +9188,11 @@ endif # FFMPEG_CONFIG_MAK
 EOF
 
 # link config.h into external/FFmpeg
-rm -f external/FFmpeg/config.h
+rm -f external/FFmpeg/ffbuild/config.h
 (cd external/FFmpeg/ && ${ln_s} ../../$MYTH_CONFIG_H config.h)
-touch external/FFmpeg/.config
+touch external/FFmpeg/ffbuild/.config
 
-enabled yasm && cp_if_changed $TMPASM external/FFmpeg/config.asm
+enabled x86asm && cp_if_changed $TMPASM external/FFmpeg/ffbuild/config.asm
 
 # delete old myth config files in old location
 if [ -e libs/libmyth/mythconfig.mak ] ; then
@@ -8969,7 +9280,7 @@ print_enabled_components(){
     struct_name=$2
     name=$3
     shift 3
-    echo "static const $struct_name *$name[] = {" > $TMPH
+    echo "static const $struct_name * const $name[] = {" > $TMPH
     for c in $*; do
         enabled $c && printf "    &ff_%s,\n" $c >> $TMPH
     done
@@ -8983,65 +9294,34 @@ print_enabled_components external/FFmpeg/libavformat/protocol_list.c URLProtocol
 test -n "$WARNINGS" && printf "\n$WARNINGS" || exit 0
 
 <<MYTHEOF
-# build pkg-config files
 
-lib_version(){
-    eval printf "\"lib${1}${build_suffix} >= \$LIB$(toupper ${1})_VERSION, \""
-}
+# Settings for pkg-config files
 
-pkgconfig_generate(){
-    name=$1
-    shortname=${name#lib}${build_suffix}
-    comment=$2
-    version=$3
-    libs=$4
-    requires=$(map 'lib_version $v' $(eval echo \$${name#lib}_deps))
-    requires=${requires%, }
-    enabled ${name#lib} || return 0
-    mkdir -p $name
-    cat <<EOF > $name/$name${build_suffix}.pc
+cat > ffbuild/config.sh <<EOF
+# Automatically generated by configure - do not modify!
+shared=$shared
+build_suffix=$build_suffix
 prefix=$prefix
-exec_prefix=\${prefix}
 libdir=$libdir
-includedir=$incdir
-
-Name: $name
-Description: $comment
-Version: $version
-Requires: $(enabled shared || echo $requires)
-Requires.private: $(enabled shared && echo $requires)
-Conflicts:
-Libs: -L\${libdir} $(enabled rpath && echo "-Wl,-rpath,\${libdir}") -l${shortname} $(enabled shared || echo $libs)
-Libs.private: $(enabled shared && echo $libs)
-Cflags: -I\${includedir}
-EOF
-
-mkdir -p doc/examples/pc-uninstalled
-includedir=${source_path}
-[ "$includedir" = . ] && includedir="\${pcfiledir}/../../.."
-    cat <<EOF > doc/examples/pc-uninstalled/$name.pc
-prefix=
-exec_prefix=
-libdir=\${pcfiledir}/../../../$name
-includedir=${includedir}
-
-Name: $name
-Description: $comment
-Version: $version
-Requires: $requires
-Conflicts:
-Libs: -L\${libdir} -Wl,-rpath,\${libdir} -l${shortname} $(enabled shared || echo $libs)
-Cflags: -I\${includedir}
+incdir=$incdir
+rpath=$(enabled rpath && echo "-Wl,-rpath,\${libdir}")
+source_path=${source_path}
+LIBPREF=${LIBPREF}
+LIBSUF=${LIBSUF}
+
+extralibs_avutil="$LIBRT $LIBM"
+extralibs_avcodec="$extralibs"
+extralibs_avformat="$extralibs"
+extralibs_avdevice="$extralibs"
+extralibs_avfilter="$extralibs"
+extralibs_avresample="$LIBM"
+extralibs_postproc=""
+extralibs_swscale="$LIBM"
+extralibs_swresample="$LIBM $LIBSOXR"
 EOF
-}
 
-pkgconfig_generate libavutil     "FFmpeg utility library"               "$LIBAVUTIL_VERSION"     "$LIBRT $LIBM"
-pkgconfig_generate libavcodec    "FFmpeg codec library"                 "$LIBAVCODEC_VERSION"    "$extralibs"
-pkgconfig_generate libavformat   "FFmpeg container format library"      "$LIBAVFORMAT_VERSION"   "$extralibs"
-pkgconfig_generate libavdevice   "FFmpeg device handling library"       "$LIBAVDEVICE_VERSION"   "$extralibs"
-pkgconfig_generate libavfilter   "FFmpeg audio/video filtering library" "$LIBAVFILTER_VERSION"   "$extralibs"
-pkgconfig_generate libpostproc   "FFmpeg postprocessing library"        "$LIBPOSTPROC_VERSION"   ""
-pkgconfig_generate libavresample "Libav audio resampling library"       "$LIBAVRESAMPLE_VERSION" "$LIBM"
-pkgconfig_generate libswscale    "FFmpeg image rescaling library"       "$LIBSWSCALE_VERSION"    "$LIBM"
-pkgconfig_generate libswresample "FFmpeg audio resampling library"      "$LIBSWRESAMPLE_VERSION" "$LIBM $LIBSOXR"
+for lib in $LIBRARY_LIST; do
+    lib_deps="$(eval echo \$${lib}_deps)"
+    echo ${lib}_deps=\"$lib_deps\" >> ffbuild/config.sh
+done
 MYTHEOF
diff --git a/mythtv/external/FFmpeg/.gitattributes b/mythtv/external/FFmpeg/.gitattributes
index a900528e474..5a19b963b66 100644
--- a/mythtv/external/FFmpeg/.gitattributes
+++ b/mythtv/external/FFmpeg/.gitattributes
@@ -1 +1,2 @@
 *.pnm -diff -text
+tests/ref/fate/sub-scc eol=crlf
diff --git a/mythtv/external/FFmpeg/.gitignore b/mythtv/external/FFmpeg/.gitignore
index 524fb73c165..dabb51762d3 100644
--- a/mythtv/external/FFmpeg/.gitignore
+++ b/mythtv/external/FFmpeg/.gitignore
@@ -18,6 +18,9 @@
 *.so.*
 *.swp
 *.ver
+*.version
+*.ptx
+*.ptx.c
 *_g
 \#*
 .\#*
@@ -27,7 +30,8 @@
 /ffplay
 /ffprobe
 /ffserver
-/config.*
+/config.asm
+/config.h
 /coverage.info
 /avversion.h
 /lcov/
diff --git a/mythtv/external/FFmpeg/.travis.yml b/mythtv/external/FFmpeg/.travis.yml
index e541ee16088..40f01f94c26 100644
--- a/mythtv/external/FFmpeg/.travis.yml
+++ b/mythtv/external/FFmpeg/.travis.yml
@@ -6,7 +6,7 @@ os:
 addons:
   apt:
     packages:
-      - yasm
+      - nasm
       - diffutils
 compiler:
   - clang
@@ -17,7 +17,7 @@ cache:
 before_install:
   - if [ "$TRAVIS_OS_NAME" == "osx" ]; then brew update --all; fi
 install:
-  - if [ "$TRAVIS_OS_NAME" == "osx" ]; then brew install yasm; fi
+  - if [ "$TRAVIS_OS_NAME" == "osx" ]; then brew install nasm; fi
 script:
   - mkdir -p ffmpeg-samples
   - ./configure --samples=ffmpeg-samples --cc=$CC
diff --git a/mythtv/external/FFmpeg/Changelog b/mythtv/external/FFmpeg/Changelog
index fd71ad379bf..d9f6b8a87ac 100644
--- a/mythtv/external/FFmpeg/Changelog
+++ b/mythtv/external/FFmpeg/Changelog
@@ -1,6 +1,173 @@
 Entries are sorted chronologically from oldest to youngest within each release,
 releases are sorted from youngest to oldest.
 
+version 3.4.1:
+- avcodec/vp9_superframe_split_bsf: Fix integer overflow in frame_size/total_size checks
+- avcodec/amrwbdec: Fix division by 0 in voice_factor()
+- avformat/utils: Fix warning: ISO C90 forbids mixed declarations and code
+- avcodec/decode: reset codec on receiving packet after EOF in compat_decode
+- avcodec/diracdsp: Fix integer overflow in PUT_SIGNED_RECT_CLAMPED()
+- avcodec/dirac_dwt: Fix integer overflows in COMPOSE_DAUB97*
+- avcodec/extract_extradata_bsf: Fix leak discovered via fuzzing
+- avcodec/vorbis: Fix another 1 << 31 > int32_t::max() with 1u.
+- avcodec/vorbis: 1 << 31 > int32_t::max(), so use 1u << 31 instead.
+- avformat/utils: Prevent undefined shift with wrap_bits > 64.
+- avcodec/j2kenc: Fix out of array access in encode_cblk()
+- avcodec/hevcdsp_template: Fix undefined shift in put_hevc_epel_bi_w_h()
+- lavf/mov: fix huge alloc in mov_read_ctts
+- avcodec/mlpdsp: Fix signed integer overflow, 2nd try
+- avcodec/h264idct_template: Fix integer overflow in ff_h264_idct8_add
+- avcodec/kgv1dec: Check that there is enough input for maximum RLE compression
+- avformat/aacdec: Fix leak in adts_aac_read_packet()
+- avcodec/dirac_dwt: Fix integer overflow in COMPOSE_FIDELITYi*
+- avcodec/sbrdsp_fixed: Fix integer overflow
+- avcodec/mpeg4videodec: Check also for negative versions in the validity check
+- Close ogg stream upon error when using AV_EF_EXPLODE.
+- Fix undefined shift on assumed 8-bit input.
+- Use ff_thread_once for fixed, float table init.
+- Fix leak of frame_duration_buffer in mov_fix_index().
+- avformat/mov: Propagate errors in mov_switch_root.
+- avcodec/hevcdsp_template: Fix invalid shift in put_hevc_epel_bi_w_v()
+- avcodec/mlpdsp: Fix undefined shift ff_mlp_pack_output()
+- avcodec/zmbv: Check that the buffer is large enough for mvec
+- avcodec/dirac_dwt: Fix integer overflow in COMPOSE_DD137iL0()
+- avcodec/wmv2dec: Check end of bitstream in parse_mb_skip() and ff_wmv2_decode_mb()
+- avcodec/snowdec: Check for remaining bitstream in decode_blocks()
+- avcodec/snowdec: Check intra block dc differences.
+- avformat/mov: Check size of STSC allocation
+- avcodec/vc2enc: Clear coef_buf on allocation
+- avcodec/h264dec: Fix potential array overread
+- avcodec/x86/mpegvideodsp: Fix signedness bug in need_emu
+- avcodec/aacpsdsp_template: Fix integer overflows in ps_decorrelate_c()
+- avcodec/aacdec_fixed: Fix undefined shift
+- avcodec/mdct_*: Fix integer overflow in addition in RESCALE()
+- avcodec/snowdec: Fix integer overflow in header parsing
+- avcodec/cngdec: Fix integer clipping
+- avcodec/sbrdsp_fixed: Fix integer overflow in shift in sbr_hf_g_filt_c()
+- avcodec/aacsbr_fixed: Fix division by zero in sbr_gain_calc()
+- avutil/softfloat: Add FLOAT_MIN
+- avcodec/h264idct_template: Fix integer overflows in ff_h264_idct8_add()
+- avcodec/xan: Check for bitstream end in xan_huffman_decode()
+- avcodec/exr: fix undefined shift in pxr24_uncompress()
+- avformat: Free the internal codec context at the end
+- avcodec/h264idct_template: Fix integer overflows in ff_h264_idct8_add()
+- avcodec/xan: Improve overlapping check
+- avcodec/aacdec_fixed: Fix integer overflow in apply_dependent_coupling_fixed()
+- avcodec/aacdec_fixed: Fix integer overflow in predict()
+- avcodec/jpeglsdec: Check for end of bitstream in ls_decode_line()
+- avcodec/jpeglsdec: Check ilv for being a supported value
+- tests/ffserver.regression.ref: update checksums to what ffserver currently produces
+- ffserver: Fix off by 1 error in path
+- avcodec/proresdec: align dequantization matrix buffers
+- avformat/matroskaenc: add missing allocation failure checks for stream durations
+- avformat/matroskaenc: actually enforce the stream limit
+- configure: Fix dependencies of aac_at decoder.
+- Don't manipulate duration when it's AV_NOPTS_VALUE.
+- lavfi/af_pan: fix sign handling in channel coefficient parser
+- avformat/hlsenc: write fmp4 init header after first AV frame
+- avformat/hlsenc: allocate space for terminating null
+- avformat/hlsenc: reindent hlsenc code
+- avformat/hlsenc: check hls segment mode for ignore the init filename
+- avformat/hlsenc: reindent hlsenc code
+- avformat/hlsenc: fix missing first segment bug in fmp4 mode
+- avformat/hlsenc: fix base_output_dirname is null when basename_size is 0 bug
+- ffplay: use SDL2 audio API
+- ffplay: only use hardware accelerated SDL texture formats
+- ffplay: create the window and the renderer before starting playback
+- ffmpeg: always init output stream before reaping filters
+- vc2enc_dwt: pad the temporary buffer by the slice size
+- lavu/arm: Check for have_vfp_vm instead of !have_vfpv3 for float_dsp_vfp
+
+version 3.4:
+- deflicker video filter
+- doubleweave video filter
+- lumakey video filter
+- pixscope video filter
+- oscilloscope video filter
+- config.log and other configuration files moved into ffbuild/ directory
+- update cuvid/nvenc headers to Video Codec SDK 8.0.14
+- afir audio filter
+- scale_cuda CUDA based video scale filter
+- librsvg support for svg rasterization
+- crossfeed audio filter
+- spec compliant VP9 muxing support in MP4
+- remove the libnut muxer/demuxer wrappers
+- remove the libschroedinger encoder/decoder wrappers
+- surround audio filter
+- sofalizer filter switched to libmysofa
+- Gremlin Digital Video demuxer and decoder
+- headphone audio filter
+- superequalizer audio filter
+- roberts video filter
+- The x86 assembler default switched from yasm to nasm, pass
+  --x86asmexe=yasm to configure to restore the old behavior.
+- additional frame format support for Interplay MVE movies
+- support for decoding through D3D11VA in ffmpeg
+- limiter video filter
+- libvmaf video filter
+- Dolby E decoder and SMPTE 337M demuxer
+- unpremultiply video filter
+- tlut2 video filter
+- floodfill video filter
+- pseudocolor video filter
+- raw G.726 muxer and demuxer, left- and right-justified
+- NewTek NDI input/output device
+- Some video filters with several inputs now use a common set of options:
+  blend, libvmaf, lut3d, overlay, psnr, ssim.
+  They must always be used by name.
+- FITS demuxer and decoder
+- FITS muxer and encoder
+- add --disable-autodetect build switch
+- drop deprecated qtkit input device (use avfoundation instead)
+- despill video filter
+- haas audio filter
+- SUP/PGS subtitle muxer
+- convolve video filter
+- VP9 tile threading support
+- KMS screen grabber
+- CUDA thumbnail filter
+- V4L2 mem2mem HW assisted codecs
+- Rockchip MPP hardware decoding
+- vmafmotion video filter
+- use MIME type "G726" for little-endian G.726, "AAL2-G726" for big-endian G.726
+
+
+version 3.3:
+- CrystalHD decoder moved to new decode API
+- add internal ebur128 library, remove external libebur128 dependency
+- Pro-MPEG CoP #3-R2 FEC protocol
+- premultiply video filter
+- Support for spherical videos
+- configure now fails if autodetect-libraries are requested but not found
+- PSD Decoder
+- 16.8 floating point pcm decoder
+- 24.0 floating point pcm decoder
+- Apple Pixlet decoder
+- QDMC audio decoder
+- NewTek SpeedHQ decoder
+- MIDI Sample Dump Standard demuxer
+- readeia608 filter
+- Sample Dump eXchange demuxer
+- abitscope multimedia filter
+- Scenarist Closed Captions demuxer and muxer
+- threshold filter
+- midequalizer filter
+- Optimal Huffman tables for (M)JPEG encoding
+- VAAPI-accelerated MPEG-2 and VP8 encoding
+- FM Screen Capture Codec decoder
+- native Opus encoder
+- ScreenPressor decoder
+- incomplete ClearVideo decoder
+- Intel QSV video scaling and deinterlacing filters
+- Support MOV with multiple sample description tables
+- XPM decoder
+- Removed the legacy X11 screen grabber, use XCB instead
+- MPEG-7 Video Signature filter
+- Removed asyncts filter (use af_aresample instead)
+- Intel QSV-accelerated VP8 video decoding
+- VAAPI-accelerated deinterlacing
+
+
 version 3.2:
 - libopenmpt demuxer
 - tee protocol
@@ -38,6 +205,7 @@ version 3.2:
 - Matroska muxer now writes CRC32 elements by default in all Level 1 elements
 - sidedata video and asidedata audio filter
 - Changed mapping of rtp MIME type G726 to codec g726le.
+- spec compliant VAAPI/DXVA2 VC-1 decoding of slices in frame-coded images
 
 
 version 3.1:
diff --git a/mythtv/external/FFmpeg/LICENSE.md b/mythtv/external/FFmpeg/LICENSE.md
index a384fa0bef1..ba65b059c5b 100644
--- a/mythtv/external/FFmpeg/LICENSE.md
+++ b/mythtv/external/FFmpeg/LICENSE.md
@@ -17,7 +17,6 @@ Specifically, the GPL parts of FFmpeg are:
     - `libavcodec/x86/flac_dsp_gpl.asm`
     - `libavcodec/x86/idct_mmx.c`
     - `libavfilter/x86/vf_removegrain.asm`
-- the X11 grabber in `libavdevice/x11grab.c`
 - the following building and testing tools
     - `compat/solaris/make_sunver.pl`
     - `doc/t2h.pm`
@@ -26,7 +25,6 @@ Specifically, the GPL parts of FFmpeg are:
     - `tests/checkasm/*`
     - `tests/tiny_ssim.c`
 - the following filters in libavfilter:
-    - `f_ebur128.c`
     - `vf_blackframe.c`
     - `vf_boxblur.c`
     - `vf_colormatrix.c`
diff --git a/mythtv/external/FFmpeg/MAINTAINERS b/mythtv/external/FFmpeg/MAINTAINERS
index d0457a6bc9b..9027ed5846e 100644
--- a/mythtv/external/FFmpeg/MAINTAINERS
+++ b/mythtv/external/FFmpeg/MAINTAINERS
@@ -47,6 +47,7 @@ project server                          Árpád Gereöffy, Michael Niedermayer,
 presets                                 Robert Swain
 metadata subsystem                      Aurelien Jacobs
 release management                      Michael Niedermayer
+API tests                               Ludmila Glinskih
 
 
 Communication
@@ -59,6 +60,7 @@ mailing lists                           Baptiste Coudurier, Lou Logan
 Google+                                 Paul B Mahol, Michael Niedermayer, Alexander Strasser
 Twitter                                 Lou Logan, Reynaldo H. Verdejo Pinochet
 Launchpad                               Timothy Gu
+ffmpeg-security                         Andreas Cadhalpun, Carl Eugen Hoyos, Clément Bœsch, Michael Niedermayer, Reimar Doeffinger, Rodger Combs, wm4
 
 
 libavutil
@@ -114,6 +116,8 @@ Generic Parts:
     lzw.*                               Michael Niedermayer
   floating point AAN DCT:
     faandct.c, faandct.h                Michael Niedermayer
+  Non-power-of-two MDCT:
+    mdct15.c, mdct15.h                  Rostislav Pehlivanov
   Golomb coding:
     golomb.c, golomb.h                  Michael Niedermayer
   motion estimation:
@@ -155,8 +159,10 @@ Codecs:
   crystalhd.c                           Philip Langdale
   cscd.c                                Reimar Doeffinger
   cuvid.c                               Timo Rothenpieler
+  dca*                                  foo86
   dirac*                                Rostislav Pehlivanov
   dnxhd*                                Baptiste Coudurier
+  dolby_e*                              foo86
   dpcm.c                                Mike Melanson
   dss_sp.c                              Oleksij Rempel
   dv.c                                  Roman Shaposhnik
@@ -175,7 +181,7 @@ Codecs:
   h263*                                 Michael Niedermayer
   h264*                                 Loren Merritt, Michael Niedermayer
   hap*                                  Tom Butterworth
-  huffyuv*                              Michael Niedermayer, Christophe Gisquet
+  huffyuv*                              Michael Niedermayer
   idcinvideo.c                          Mike Melanson
   interplayvideo.c                      Mike Melanson
   jni*, ffjni*                          Matthieu Bouron
@@ -188,7 +194,6 @@ Codecs:
   libkvazaar.c                          Arttu Ylä-Outinen
   libopenjpeg.c                         Jaikrishnan Menon
   libopenjpegenc.c                      Michael Bradshaw
-  libschroedinger*                      David Conrad
   libtheoraenc.c                        David Conrad
   libvorbis.c                           David Conrad
   libvpx*                               James Zern
@@ -208,13 +213,14 @@ Codecs:
   msvideo1.c                            Mike Melanson
   nuv.c                                 Reimar Doeffinger
   nvenc*                                Timo Rothenpieler
+  opus*                                 Rostislav Pehlivanov
   paf.*                                 Paul B Mahol
   pcx.c                                 Ivo van Poorten
   pgssubdec.c                           Reimar Doeffinger
   ptx.c                                 Ivo van Poorten
   qcelp*                                Reynaldo H. Verdejo Pinochet
   qdm2.c, qdm2data.h                    Roberto Togni
-  qsv*                                  Ivan Uskov
+  qsv*                                  Mark Thompson
   qtrle.c                               Mike Melanson
   ra144.c, ra144.h, ra288.c, ra288.h    Roberto Togni
   resample2.c                           Michael Niedermayer
@@ -222,12 +228,12 @@ Codecs:
   rpza.c                                Roberto Togni
   rtjpeg.c, rtjpeg.h                    Reimar Doeffinger
   rv10.c                                Michael Niedermayer
-  rv4*                                  Christophe Gisquet
   s3tc*                                 Ivo van Poorten
   smc.c                                 Mike Melanson
   smvjpegdec.c                          Ash Hughes
   snow*                                 Michael Niedermayer, Loren Merritt
   sonic.c                               Alex Beregszaszi
+  speedhq.c                             Steinar H. Gunderson
   srt*                                  Aurelien Jacobs
   sunrast.c                             Ivo van Poorten
   svq3.c                                Michael Niedermayer
@@ -236,7 +242,6 @@ Codecs:
   tta.c                                 Alex Beregszaszi, Jaikrishnan Menon
   ttaenc.c                              Paul B Mahol
   txd.c                                 Ivo van Poorten
-  vc1*                                  Christophe Gisquet
   vc2*                                  Rostislav Pehlivanov
   vcr1.c                                Michael Niedermayer
   vda_h264_dec.c                        Xidorn Quan
@@ -261,7 +266,8 @@ Codecs:
 
 Hardware acceleration:
   crystalhd.c                           Philip Langdale
-  dxva2*                                Hendrik Leppkes, Laurent Aimar
+  dxva2*                                Hendrik Leppkes, Laurent Aimar, Steve Lhomme
+  d3d11va*                              Steve Lhomme
   mediacodec*                           Matthieu Bouron
   vaapi*                                Gwenole Beauchesne
   vaapi_encode*                         Mark Thompson
@@ -276,7 +282,7 @@ libavdevice
 
 
   avfoundation.m                        Thilo Borgmann
-  decklink*                             Deti Fliegl
+  decklink*                             Marton Balint
   dshow.c                               Roger Pack (CC rogerdpack@gmail.com)
   fbdev_enc.c                           Lukasz Marek
   gdigrab.c                             Roger Pack (CC rogerdpack@gmail.com)
@@ -285,7 +291,6 @@ libavdevice
   libdc1394.c                           Roman Shaposhnik
   opengl_enc.c                          Lukasz Marek
   pulse_audio_enc.c                     Lukasz Marek
-  qtkit.m                               Thilo Borgmann
   sdl                                   Stefano Sabatini
   sdl2.c                                Josh de Kock
   v4l2.c                                Giorgio Vazzana
@@ -324,6 +329,7 @@ Filters:
   avf_avectorscope.c                    Paul B Mahol
   avf_showcqt.c                         Muhammad Faiz
   vf_blend.c                            Paul B Mahol
+  vf_bwdif                              Thomas Mundt (CC <thomas.mundt@hr.de>)
   vf_chromakey.c                        Timo Rothenpieler
   vf_colorchannelmixer.c                Paul B Mahol
   vf_colorbalance.c                     Paul B Mahol
@@ -339,6 +345,7 @@ Filters:
   vf_hqx.c                              Clément Bœsch
   vf_idet.c                             Pascal Massimino
   vf_il.c                               Paul B Mahol
+  vf_(t)interlace                       Thomas Mundt (CC <thomas.mundt@hr.de>)
   vf_lenscorrection.c                   Daniel Oberhoff
   vf_mergeplanes.c                      Paul B Mahol
   vf_mestimate.c                        Davinder Singh
@@ -384,23 +391,27 @@ Muxers/Demuxers:
   avisynth.c                            Stephen Hutchinson
   avr.c                                 Paul B Mahol
   bink.c                                Peter Ross
+  boadec.c                              Michael Niedermayer
   brstm.c                               Paul B Mahol
   caf*                                  Peter Ross
   cdxl.c                                Paul B Mahol
   crc.c                                 Michael Niedermayer
+  dashdec.c                             Steven Liu
   daud.c                                Reimar Doeffinger
   dss.c                                 Oleksij Rempel
+  dtsdec.c                              foo86
   dtshddec.c                            Paul B Mahol
   dv.c                                  Roman Shaposhnik
   electronicarts.c                      Peter Ross
   epafdec.c                             Paul B Mahol
   ffm*                                  Baptiste Coudurier
   flic.c                                Mike Melanson
-  flvdec.c, flvenc.c                    Michael Niedermayer
+  flvdec.c                              Michael Niedermayer
+  flvenc.c                              Michael Niedermayer, Steven Liu
   gxf.c                                 Reimar Doeffinger
   gxfenc.c                              Baptiste Coudurier
   hls.c                                 Anssi Hannula
-  hls encryption (hlsenc.c)             Christian Suloway, Steven Liu
+  hlsenc.c                              Christian Suloway, Steven Liu
   idcin.c                               Mike Melanson
   idroqdec.c                            Mike Melanson
   iff.c                                 Jaikrishnan Menon
@@ -410,7 +421,6 @@ Muxers/Demuxers:
   iss.c                                 Stefan Gehrer
   jvdec.c                               Peter Ross
   libmodplug.c                          Clément Bœsch
-  libnut.c                              Oded Shimon
   libopenmpt.c                          Josh de Kock
   lmlm4.c                               Ivo van Poorten
   lvfdec.c                              Paul B Mahol
@@ -433,7 +443,6 @@ Muxers/Demuxers:
   msnwc_tcp.c                           Ramiro Polla
   mtv.c                                 Reynaldo H. Verdejo Pinochet
   mxf*                                  Baptiste Coudurier
-  mxfdec.c                              Tomas Härdin
   nistspheredec.c                       Paul B Mahol
   nsvdec.c                              Francois Revol
   nut*                                  Michael Niedermayer
@@ -462,6 +471,7 @@ Muxers/Demuxers:
   rtpdec_vc2hq.*, rtpenc_vc2hq.*        Thomas Volkert
   rtpdec_vp9.c                          Thomas Volkert
   rtpenc_mpv.*, rtpenc_aac.*            Martin Storsjo
+  s337m.c                               foo86
   sbgdec.c                              Nicolas George
   sdp.c                                 Martin Storsjo
   segafilm.c                            Mike Melanson
@@ -511,7 +521,7 @@ Operating systems / CPU architectures
 =====================================
 
 Alpha                                   Falk Hueffner
-MIPS                                    Nedeljko Babic
+MIPS                                    Manojkumar Bhosale
 Mac OS X / PowerPC                      Romain Dolbeau, Guillaume Poirier
 Amiga / PowerPC                         Colin Ward
 Windows MinGW                           Alex Beregszaszi, Ramiro Polla
@@ -523,6 +533,33 @@ Sparc                                   Roman Shaposhnik
 OS/2                                    KO Myung-Hun
 
 
+Developers with git write access who are currently not maintaining any specific part
+====================================================================================
+Alex Converse
+Andreas Cadhalpun
+Anuradha Suraparaju
+Ben Littler
+Benjamin Larsson
+Bobby Bingham
+Daniel Verkamp
+Derek Buitenhuis
+Ganesh Ajjanagadde
+Henrik Gramner
+Ivan Uskov
+James Darnley
+Jan Ekström
+Joakim Plate
+Kieran Kunhya
+Kirill Gavrilov
+Martin Storsjö
+Panagiotis Issaris
+Pedro Arthur
+Sebastien Zwickert
+Vittorio Giovara
+wm4
+(this list is incomplete)
+
+
 Releases
 ========
 
@@ -565,6 +602,7 @@ Reynaldo H. Verdejo Pinochet  6E27 CD34 170C C78E 4D4F 5F40 C18E 077F 3114 452A
 Robert Swain                  EE7A 56EA 4A81 A7B5 2001 A521 67FA 362D A2FC 3E71
 Sascha Sommer                 38A0 F88B 868E 9D3A 97D4 D6A0 E823 706F 1E07 0D3C
 Stefano Sabatini              0D0B AD6B 5330 BBAD D3D6 6A0C 719C 2839 FC43 2D5F
+Steinar H. Gunderson          C2E9 004F F028 C18E 4EAD DB83 7F61 7561 7797 8F76
 Stephan Hilb                  4F38 0B3A 5F39 B99B F505 E562 8D5C 5554 4E17 8863
 Tiancheng "Timothy" Gu        9456 AFC0 814A 8139 E994 8351 7FE6 B095 B582 B0D4
 Tim Nicholson                 38CF DB09 3ED0 F607 8B67 6CED 0C0B FC44 8B0B FC83
diff --git a/mythtv/external/FFmpeg/Makefile b/mythtv/external/FFmpeg/Makefile
index 78636b43ffe..fc97b6b2ecd 100644
--- a/mythtv/external/FFmpeg/Makefile
+++ b/mythtv/external/FFmpeg/Makefile
@@ -1,52 +1,24 @@
-include config.mak
+include ffbuild/config.mak
 
 SRC_PATH = ${SRC_PATH_BARE}/external/FFmpeg
 SRC_DIR = $(SRC_PATH)
 
 vpath %.c    $(SRC_PATH)
 vpath %.cpp  $(SRC_PATH)
-vpath %.m    $(SRC_PATH)
 vpath %.h    $(SRC_PATH)
+vpath %.inc  $(SRC_PATH)
+vpath %.m    $(SRC_PATH)
 vpath %.S    $(SRC_PATH)
 vpath %.asm  $(SRC_PATH)
 vpath %.rc   $(SRC_PATH)
 vpath %.v    $(SRC_PATH)
 vpath %.texi $(SRC_PATH)
+vpath %.cu   $(SRC_PATH)
+vpath %.ptx  $(SRC_PATH)
 vpath %/fate_config.sh.template $(SRC_PATH)
 
-AVPROGS-$(CONFIG_FFMPEG)   += ffmpeg
-AVPROGS-$(CONFIG_FFPLAY)   += ffplay
-AVPROGS-$(CONFIG_FFPROBE)  += ffprobe
-AVPROGS-$(CONFIG_FFSERVER) += ffserver
-
-AVPROGS    := $(AVPROGS-yes:%=%$(PROGSSUF)$(EXESUF))
-INSTPROGS   = $(AVPROGS-yes:%=%$(PROGSSUF)$(EXESUF))
-PROGS      += $(AVPROGS)
-
-AVBASENAMES  = ffmpeg ffplay ffprobe ffserver
-ALLAVPROGS   = $(AVBASENAMES:%=%$(PROGSSUF)$(EXESUF))
-ALLAVPROGS_G = $(AVBASENAMES:%=%$(PROGSSUF)_g$(EXESUF))
-
-$(foreach prog,$(AVBASENAMES),$(eval OBJS-$(prog) += cmdutils.o))
-$(foreach prog,$(AVBASENAMES),$(eval OBJS-$(prog)-$(CONFIG_OPENCL) += cmdutils_opencl.o))
-
-OBJS-ffmpeg                   += ffmpeg_opt.o ffmpeg_filter.o
-OBJS-ffmpeg-$(CONFIG_VIDEOTOOLBOX) += ffmpeg_videotoolbox.o
-OBJS-ffmpeg-$(CONFIG_LIBMFX)  += ffmpeg_qsv.o
-OBJS-ffmpeg-$(CONFIG_VAAPI)   += ffmpeg_vaapi.o
-ifndef CONFIG_VIDEOTOOLBOX
-OBJS-ffmpeg-$(CONFIG_VDA)     += ffmpeg_videotoolbox.o
-endif
-OBJS-ffmpeg-$(CONFIG_CUVID)   += ffmpeg_cuvid.o
-OBJS-ffmpeg-$(HAVE_DXVA2_LIB) += ffmpeg_dxva2.o
-OBJS-ffmpeg-$(HAVE_VDPAU_X11) += ffmpeg_vdpau.o
-OBJS-ffserver                 += ffserver_config.o
-
 TESTTOOLS   = audiogen videogen rotozoom tiny_psnr tiny_ssim base64 audiomatch
 HOSTPROGS  := $(TESTTOOLS:%=tests/%) doc/print_options
-TOOLS       = qt-faststart trasher uncoded_frame
-TOOLS-$(CONFIG_ZLIB) += cws2fws
-MYTHPROGS   = $(addprefix myth, ${PROGS})
 
 # $(FFLIBS-yes) needs to be in linking order
 FFLIBS-$(CONFIG_AVDEVICE)   += avdevice
@@ -61,39 +33,46 @@ FFLIBS-$(CONFIG_SWSCALE)    += swscale
 FFLIBS := avutil
 
 DATA_FILES := $(wildcard $(SRC_PATH)/presets/*.ffpreset) $(SRC_PATH)/doc/ffprobe.xsd
-EXAMPLES_FILES := $(wildcard $(SRC_PATH)/doc/examples/*.c) $(SRC_PATH)/doc/examples/Makefile $(SRC_PATH)/doc/examples/README
 
-SKIPHEADERS = cmdutils_common_opts.h                                    \
-              compat/w32pthreads.h
+SKIPHEADERS = compat/w32pthreads.h
+
+# first so "all" becomes default target
+all: all-yes
 
-include $(SRC_PATH)/common.mak
+include $(SRC_PATH)/tools/Makefile
+include $(SRC_PATH)/ffbuild/common.mak
 
 FF_EXTRALIBS := $(FFEXTRALIBS)
 FF_DEP_LIBS  := $(DEP_LIBS)
 FF_STATIC_DEP_LIBS := $(STATIC_DEP_LIBS)
 
-all: $(AVPROGS)
-
-$(TOOLS): %$(EXESUF): %.o $(EXEOBJS)
+$(TOOLS): %$(EXESUF): %.o
 	$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $^ $(ELIBS)
 
+target_dec_%_fuzzer$(EXESUF): target_dec_%_fuzzer.o $(FF_DEP_LIBS)
+	$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $^ $(ELIBS) $(FF_EXTRALIBS) $(LIBFUZZER_PATH)
+
 tools/cws2fws$(EXESUF): ELIBS = $(ZLIB)
+tools/sofa2wavs$(EXESUF): ELIBS = $(FF_EXTRALIBS)
 tools/uncoded_frame$(EXESUF): $(FF_DEP_LIBS)
 tools/uncoded_frame$(EXESUF): ELIBS = $(FF_EXTRALIBS)
+tools/target_dec_%_fuzzer$(EXESUF): $(FF_DEP_LIBS)
 
-${MYTHPROGS}: myth%: %
-	$(CP) $< $@
+CONFIGURABLE_COMPONENTS =                                           \
+    $(wildcard $(FFLIBS:%=$(SRC_PATH)/lib%/all*.c))                 \
+    $(SRC_PATH)/libavcodec/bitstream_filters.c                      \
+    $(SRC_PATH)/libavformat/protocols.c                             \
 
-config.h: .config
-.config: $(wildcard $(FFLIBS:%=$(SRC_PATH)/lib%/all*.c))
+config.h: ffbuild/.config
+ffbuild/.config: $(CONFIGURABLE_COMPONENTS)
 	@-tput bold 2>/dev/null
-	@-printf '\nWARNING: $(?F) newer than config.h, rerun configure\n\n'
+	@-printf '\nWARNING: $(?) newer than config.h, rerun configure\n\n'
 	@-tput sgr0 2>/dev/null
 
-SUBDIR_VARS := CLEANFILES EXAMPLES FFLIBS HOSTPROGS TESTPROGS TOOLS      \
+SUBDIR_VARS := CLEANFILES FFLIBS HOSTPROGS TESTPROGS TOOLS               \
                HEADERS ARCH_HEADERS BUILT_HEADERS SKIPHEADERS            \
                ARMV5TE-OBJS ARMV6-OBJS ARMV8-OBJS VFP-OBJS NEON-OBJS     \
-               ALTIVEC-OBJS MMX-OBJS YASM-OBJS                           \
+               ALTIVEC-OBJS VSX-OBJS MMX-OBJS X86ASM-OBJS                \
                MIPSFPU-OBJS MIPSDSPR2-OBJS MIPSDSP-OBJS MSA-OBJS         \
                MMI-OBJS OBJS SLIBOBJS HOSTOBJS TESTOBJS
 
@@ -108,41 +87,33 @@ SUBDIR := $(1)/
 include $(SRC_PATH_BARE)/external/FFmpeg/$(1)/Makefile
 -include $(SRC_PATH_BARE)/external/FFmpeg/$(1)/$(ARCH)/Makefile
 -include $(SRC_PATH_BARE)/external/FFmpeg/$(1)/$(INTRINSICS)/Makefile
-include $(SRC_PATH_BARE)/external/FFmpeg/library.mak
+include $(SRC_PATH_BARE)/external/FFmpeg/ffbuild/library.mak
+
 endef
 
 $(foreach D,$(FFLIBS),$(eval $(call DOSUBDIR,lib$(D))))
 
+include $(SRC_PATH)/fftools/Makefile
 include $(SRC_PATH)/doc/Makefile
+include $(SRC_PATH)/doc/examples/Makefile
 
-define DOPROG
-OBJS-$(1) += $(1).o $(EXEOBJS) $(OBJS-$(1)-yes)
-$(1)$(PROGSSUF)_g$(EXESUF): $$(OBJS-$(1))
-$$(OBJS-$(1)): CFLAGS  += $(CFLAGS-$(1))
-$(1)$(PROGSSUF)_g$(EXESUF): LDFLAGS += $(LDFLAGS-$(1))
-$(1)$(PROGSSUF)_g$(EXESUF): FF_EXTRALIBS += $(LIBS-$(1))
--include $$(OBJS-$(1):.o=.d)
-endef
-
-$(foreach P,$(PROGS),$(eval $(call DOPROG,$(P:$(PROGSSUF)$(EXESUF)=))))
-
-ffprobe.o cmdutils.o libavcodec/utils.o libavformat/utils.o libavdevice/avdevice.o libavfilter/avfilter.o libavutil/utils.o libpostproc/postprocess.o libswresample/swresample.o libswscale/utils.o : libavutil/ffversion.h
+libavcodec/utils.o libavformat/utils.o libavdevice/avdevice.o libavfilter/avfilter.o libavutil/utils.o libpostproc/postprocess.o libswresample/swresample.o libswscale/utils.o : libavutil/ffversion.h
 
 $(PROGS): %$(PROGSSUF)$(EXESUF): %$(PROGSSUF)_g$(EXESUF)
+ifeq ($(STRIPTYPE),direct)
+	$(STRIP) -o $@ $<
+else
 	$(CP) $< $@
 	$(STRIP) $@
+endif
 
-%$(PROGSSUF)_g$(EXESUF): %.o $(FF_DEP_LIBS)
+%$(PROGSSUF)_g$(EXESUF): $(FF_DEP_LIBS)
 	$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $(OBJS-$*) $(FF_EXTRALIBS)
 
-OBJDIRS += tools
-
--include $(wildcard tools/*.d)
-
-VERSION_SH  = $(SRC_PATH_BARE)/external/FFmpeg/version.sh
+VERSION_SH  = $(SRC_PATH_BARE)/external/FFmpeg/ffbuild/version.sh
 GIT_LOG     = $(SRC_PATH_BARE)/.git/logs/HEAD
 
-.version: $(wildcard $(GIT_LOG)) $(VERSION_SH) config.mak
+.version: $(wildcard $(GIT_LOG)) $(VERSION_SH) ffbuild/config.mak
 .version: M=@
 
 libavutil/ffversion.h .version:
@@ -152,48 +123,33 @@ libavutil/ffversion.h .version:
 # force version.sh to run whenever version might have changed
 -include .version
 
-ifdef AVPROGS
-install: install-mythprogs
-endif
-
 install: install-libs install-headers
 
 install-libs: install-libs-yes
 
-install-progs-yes:
-install-progs-$(CONFIG_SHARED): install-libs
-
-install-progs: install-progs-yes $(AVPROGS)
-	$(Q)mkdir -p "$(BINDIR)"
-	$(INSTALL) -c -m 755 $(INSTPROGS) "$(BINDIR)"
-
-install-mythprogs: install-progs-yes $(MYTHPROGS)
-	$(Q)mkdir -p "$(BINDIR)"
-	$(INSTALL) -c -m 755 $(MYTHPROGS) "$(BINDIR)"
-
-install-data: $(DATA_FILES) $(EXAMPLES_FILES)
-	$(Q)mkdir -p "$(DATADIR)/examples"
+install-data: $(DATA_FILES)
+	$(Q)mkdir -p "$(DATADIR)"
 	$(INSTALL) -m 644 $(DATA_FILES) "$(DATADIR)"
-	$(INSTALL) -m 644 $(EXAMPLES_FILES) "$(DATADIR)/examples"
-
-uninstall: uninstall-libs uninstall-headers uninstall-progs uninstall-data
 
-uninstall-progs:
-	$(RM) $(addprefix "$(BINDIR)/", $(ALLAVPROGS))
+uninstall: uninstall-libs uninstall-headers uninstall-data
 
 uninstall-data:
 	$(RM) -r "$(DATADIR)"
 
 clean::
-	$(RM) $(ALLAVPROGS) $(ALLAVPROGS_G)
 	$(RM) $(CLEANSUFFIXES)
-	$(RM) $(CLEANSUFFIXES:%=tools/%)
+	$(RM) $(CLEANSUFFIXES:%=compat/msvcrt/%)
+	$(RM) $(CLEANSUFFIXES:%=compat/atomics/pthread/%)
+	$(RM) $(CLEANSUFFIXES:%=compat/%)
 	$(RM) -r coverage-html
 	$(RM) -rf coverage.info coverage.info.in lcov
 
 distclean::
 	$(RM) $(DISTCLEANSUFFIXES)
-	$(RM) config.* .config libavutil/avconfig.h .version mapfile avversion.h version.h libavutil/ffversion.h libavcodec/codec_names.h libavcodec/bsf_list.c libavformat/protocol_list.c
+	$(RM) .version avversion.h config.asm config.h mapfile  \
+		ffbuild/.config ffbuild/config.* libavutil/avconfig.h \
+		version.h libavutil/ffversion.h libavcodec/codec_names.h \
+		libavcodec/bsf_list.c libavformat/protocol_list.c
 ifeq ($(SRC_LINK),src)
 	$(RM) src
 endif
@@ -217,5 +173,4 @@ $(sort $(OBJDIRS)):
 # so this saves some time on slow systems.
 .SUFFIXES:
 
-.PHONY: all all-yes alltools check *clean config install*
-.PHONY: testprogs uninstall*
+.PHONY: all all-yes alltools check *clean config install* testprogs uninstall*
diff --git a/mythtv/external/FFmpeg/RELEASE b/mythtv/external/FFmpeg/RELEASE
index a3ec5a4bd3d..47b322c971c 100644
--- a/mythtv/external/FFmpeg/RELEASE
+++ b/mythtv/external/FFmpeg/RELEASE
@@ -1 +1 @@
-3.2
+3.4.1
diff --git a/mythtv/external/FFmpeg/RELEASE_NOTES b/mythtv/external/FFmpeg/RELEASE_NOTES
index c3ec010069e..d649c77bd52 100644
--- a/mythtv/external/FFmpeg/RELEASE_NOTES
+++ b/mythtv/external/FFmpeg/RELEASE_NOTES
@@ -1,10 +1,10 @@
 
-              ┌────────────────────────────────────────┐
-              │ RELEASE NOTES for FFmpeg 3.2 "Hypatia" │
-              └────────────────────────────────────────┘
+              ┌───────────────────────────────────────┐
+              │ RELEASE NOTES for FFmpeg 3.4 "Cantor" │
+              └───────────────────────────────────────┘
 
-   The FFmpeg Project proudly presents FFmpeg 3.2 "Hypatia", about 4
-   months after the release of FFmpeg 3.1.
+   The FFmpeg Project proudly presents FFmpeg 3.4 "Cantor", about 6
+   months after the release of FFmpeg 3.3.
 
    A complete Changelog is available at the root of the project, and the
    complete Git history on http://source.ffmpeg.org.
diff --git a/mythtv/external/FFmpeg/compat/atomics/dummy/stdatomic.h b/mythtv/external/FFmpeg/compat/atomics/dummy/stdatomic.h
new file mode 100644
index 00000000000..59d85f915d6
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/atomics/dummy/stdatomic.h
@@ -0,0 +1,176 @@
+/*
+ * 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
+ */
+
+/*
+ * based on vlc_atomic.h from VLC
+ * Copyright (C) 2010 Rémi Denis-Courmont
+ */
+
+#ifndef COMPAT_ATOMICS_DUMMY_STDATOMIC_H
+#define COMPAT_ATOMICS_DUMMY_STDATOMIC_H
+
+#include <stdint.h>
+
+#define ATOMIC_FLAG_INIT 0
+
+#define ATOMIC_VAR_INIT(value) (value)
+
+#define atomic_init(obj, value) \
+do {                            \
+    *(obj) = (value);           \
+} while(0)
+
+#define kill_dependency(y) ((void)0)
+
+#define atomic_thread_fence(order) \
+    ((void)0)
+
+#define atomic_signal_fence(order) \
+    ((void)0)
+
+#define atomic_is_lock_free(obj) 0
+
+typedef intptr_t atomic_flag;
+typedef intptr_t atomic_bool;
+typedef intptr_t atomic_char;
+typedef intptr_t atomic_schar;
+typedef intptr_t atomic_uchar;
+typedef intptr_t atomic_short;
+typedef intptr_t atomic_ushort;
+typedef intptr_t atomic_int;
+typedef intptr_t atomic_uint;
+typedef intptr_t atomic_long;
+typedef intptr_t atomic_ulong;
+typedef intptr_t atomic_llong;
+typedef intptr_t atomic_ullong;
+typedef intptr_t atomic_wchar_t;
+typedef intptr_t atomic_int_least8_t;
+typedef intptr_t atomic_uint_least8_t;
+typedef intptr_t atomic_int_least16_t;
+typedef intptr_t atomic_uint_least16_t;
+typedef intptr_t atomic_int_least32_t;
+typedef intptr_t atomic_uint_least32_t;
+typedef intptr_t atomic_int_least64_t;
+typedef intptr_t atomic_uint_least64_t;
+typedef intptr_t atomic_int_fast8_t;
+typedef intptr_t atomic_uint_fast8_t;
+typedef intptr_t atomic_int_fast16_t;
+typedef intptr_t atomic_uint_fast16_t;
+typedef intptr_t atomic_int_fast32_t;
+typedef intptr_t atomic_uint_fast32_t;
+typedef intptr_t atomic_int_fast64_t;
+typedef intptr_t atomic_uint_fast64_t;
+typedef intptr_t atomic_intptr_t;
+typedef intptr_t atomic_uintptr_t;
+typedef intptr_t atomic_size_t;
+typedef intptr_t atomic_ptrdiff_t;
+typedef intptr_t atomic_intmax_t;
+typedef intptr_t atomic_uintmax_t;
+
+#define atomic_store(object, desired)   \
+do {                                    \
+    *(object) = (desired);              \
+} while (0)
+
+#define atomic_store_explicit(object, desired, order) \
+    atomic_store(object, desired)
+
+#define atomic_load(object) \
+    (*(object))
+
+#define atomic_load_explicit(object, order) \
+    atomic_load(object)
+
+static inline intptr_t atomic_exchange(intptr_t *object, intptr_t desired)
+{
+    intptr_t ret = *object;
+    *object = desired;
+    return ret;
+}
+
+#define atomic_exchange_explicit(object, desired, order) \
+    atomic_exchange(object, desired)
+
+static inline int atomic_compare_exchange_strong(intptr_t *object, intptr_t *expected,
+                                                 intptr_t desired)
+{
+    int ret;
+    if (*object == *expected) {
+        *object = desired;
+        ret = 1;
+    } else {
+        *expected = *object;
+        ret = 0;
+    }
+    return ret;
+}
+
+#define atomic_compare_exchange_strong_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak(object, expected, desired) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_weak(object, expected, desired)
+
+#define FETCH_MODIFY(opname, op)                                            \
+static inline intptr_t atomic_fetch_ ## opname(intptr_t *object, intptr_t operand) \
+{                                                                    \
+    intptr_t ret;                                                    \
+    ret = *object;                                                   \
+    *object = *object op operand;                                    \
+    return ret;                                                      \
+}
+
+FETCH_MODIFY(add, +)
+FETCH_MODIFY(sub, -)
+FETCH_MODIFY(or,  |)
+FETCH_MODIFY(xor, ^)
+FETCH_MODIFY(and, &)
+
+#undef FETCH_MODIFY
+
+#define atomic_fetch_add_explicit(object, operand, order) \
+    atomic_fetch_add(object, operand)
+
+#define atomic_fetch_sub_explicit(object, operand, order) \
+    atomic_fetch_sub(object, operand)
+
+#define atomic_fetch_or_explicit(object, operand, order) \
+    atomic_fetch_or(object, operand)
+
+#define atomic_fetch_xor_explicit(object, operand, order) \
+    atomic_fetch_xor(object, operand)
+
+#define atomic_fetch_and_explicit(object, operand, order) \
+    atomic_fetch_and(object, operand)
+
+#define atomic_flag_test_and_set(object) \
+    atomic_exchange(object, 1)
+
+#define atomic_flag_test_and_set_explicit(object, order) \
+    atomic_flag_test_and_set(object)
+
+#define atomic_flag_clear(object) \
+    atomic_store(object, 0)
+
+#define atomic_flag_clear_explicit(object, order) \
+    atomic_flag_clear(object)
+
+#endif /* COMPAT_ATOMICS_DUMMY_STDATOMIC_H */
diff --git a/mythtv/external/FFmpeg/compat/atomics/gcc/stdatomic.h b/mythtv/external/FFmpeg/compat/atomics/gcc/stdatomic.h
new file mode 100644
index 00000000000..e13ed0e068b
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/atomics/gcc/stdatomic.h
@@ -0,0 +1,173 @@
+/*
+ * 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
+ */
+
+/*
+ * based on vlc_atomic.h from VLC
+ * Copyright (C) 2010 Rémi Denis-Courmont
+ */
+
+#ifndef COMPAT_ATOMICS_GCC_STDATOMIC_H
+#define COMPAT_ATOMICS_GCC_STDATOMIC_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define ATOMIC_FLAG_INIT 0
+
+#define ATOMIC_VAR_INIT(value) (value)
+
+#define atomic_init(obj, value) \
+do {                            \
+    *(obj) = (value);           \
+} while(0)
+
+#define kill_dependency(y) ((void)0)
+
+#define atomic_thread_fence(order) \
+    __sync_synchronize()
+
+#define atomic_signal_fence(order) \
+    ((void)0)
+
+#define atomic_is_lock_free(obj) 0
+
+typedef         _Bool      atomic_flag;
+typedef         _Bool      atomic_bool;
+typedef          char      atomic_char;
+typedef   signed char      atomic_schar;
+typedef unsigned char      atomic_uchar;
+typedef          short     atomic_short;
+typedef unsigned short     atomic_ushort;
+typedef          int       atomic_int;
+typedef unsigned int       atomic_uint;
+typedef          long      atomic_long;
+typedef unsigned long      atomic_ulong;
+typedef          long long atomic_llong;
+typedef unsigned long long atomic_ullong;
+typedef          wchar_t   atomic_wchar_t;
+typedef       int_least8_t atomic_int_least8_t;
+typedef      uint_least8_t atomic_uint_least8_t;
+typedef      int_least16_t atomic_int_least16_t;
+typedef     uint_least16_t atomic_uint_least16_t;
+typedef      int_least32_t atomic_int_least32_t;
+typedef     uint_least32_t atomic_uint_least32_t;
+typedef      int_least64_t atomic_int_least64_t;
+typedef     uint_least64_t atomic_uint_least64_t;
+typedef       int_fast8_t atomic_int_fast8_t;
+typedef      uint_fast8_t atomic_uint_fast8_t;
+typedef      int_fast16_t atomic_int_fast16_t;
+typedef     uint_fast16_t atomic_uint_fast16_t;
+typedef      int_fast32_t atomic_int_fast32_t;
+typedef     uint_fast32_t atomic_uint_fast32_t;
+typedef      int_fast64_t atomic_int_fast64_t;
+typedef     uint_fast64_t atomic_uint_fast64_t;
+typedef          intptr_t atomic_intptr_t;
+typedef         uintptr_t atomic_uintptr_t;
+typedef            size_t atomic_size_t;
+typedef         ptrdiff_t atomic_ptrdiff_t;
+typedef          intmax_t atomic_intmax_t;
+typedef         uintmax_t atomic_uintmax_t;
+
+#define atomic_store(object, desired)   \
+do {                                    \
+    *(object) = (desired);              \
+    __sync_synchronize();               \
+} while (0)
+
+#define atomic_store_explicit(object, desired, order) \
+    atomic_store(object, desired)
+
+#define atomic_load(object) \
+    (__sync_synchronize(), *(object))
+
+#define atomic_load_explicit(object, order) \
+    atomic_load(object)
+
+#define atomic_exchange(object, desired)                            \
+({                                                                  \
+    __typeof__(object) _obj = (object);                             \
+    __typeof__(*object) _old;                                       \
+    do                                                              \
+        _old = atomic_load(_obj);                                   \
+    while (!__sync_bool_compare_and_swap(_obj, _old, (desired)));   \
+    _old;                                                           \
+})
+
+#define atomic_exchange_explicit(object, desired, order) \
+    atomic_exchange(object, desired)
+
+#define atomic_compare_exchange_strong(object, expected, desired)   \
+({                                                                  \
+    __typeof__(object) _exp = (expected);                           \
+    __typeof__(*object) _old = *_exp;                               \
+    *_exp = __sync_val_compare_and_swap((object), _old, (desired)); \
+    *_exp == _old;                                                  \
+})
+
+#define atomic_compare_exchange_strong_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak(object, expected, desired) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_weak(object, expected, desired)
+
+#define atomic_fetch_add(object, operand) \
+    __sync_fetch_and_add(object, operand)
+
+#define atomic_fetch_add_explicit(object, operand, order) \
+    atomic_fetch_add(object, operand)
+
+#define atomic_fetch_sub(object, operand) \
+    __sync_fetch_and_sub(object, operand)
+
+#define atomic_fetch_sub_explicit(object, operand, order) \
+    atomic_fetch_sub(object, operand)
+
+#define atomic_fetch_or(object, operand) \
+    __sync_fetch_and_or(object, operand)
+
+#define atomic_fetch_or_explicit(object, operand, order) \
+    atomic_fetch_or(object, operand)
+
+#define atomic_fetch_xor(object, operand) \
+    __sync_fetch_and_xor(object, operand)
+
+#define atomic_fetch_xor_explicit(object, operand, order) \
+    atomic_fetch_xor(object, operand)
+
+#define atomic_fetch_and(object, operand) \
+    __sync_fetch_and_and(object, operand)
+
+#define atomic_fetch_and_explicit(object, operand, order) \
+    atomic_fetch_and(object, operand)
+
+#define atomic_flag_test_and_set(object) \
+    atomic_exchange(object, 1)
+
+#define atomic_flag_test_and_set_explicit(object, order) \
+    atomic_flag_test_and_set(object)
+
+#define atomic_flag_clear(object) \
+    atomic_store(object, 0)
+
+#define atomic_flag_clear_explicit(object, order) \
+    atomic_flag_clear(object)
+
+#endif /* COMPAT_ATOMICS_GCC_STDATOMIC_H */
diff --git a/mythtv/external/FFmpeg/compat/atomics/pthread/stdatomic.c b/mythtv/external/FFmpeg/compat/atomics/pthread/stdatomic.c
new file mode 100644
index 00000000000..9fca98980b9
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/atomics/pthread/stdatomic.c
@@ -0,0 +1,39 @@
+/*
+ * 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
+ */
+
+/*
+ * based on vlc_atomic.h from VLC
+ * Copyright (C) 2010 Rémi Denis-Courmont
+ */
+
+#include <pthread.h>
+#include <stdint.h>
+
+#include "stdatomic.h"
+
+static pthread_mutex_t atomic_lock = PTHREAD_MUTEX_INITIALIZER;
+
+void avpriv_atomic_lock(void)
+{
+    pthread_mutex_lock(&atomic_lock);
+}
+
+void avpriv_atomic_unlock(void)
+{
+    pthread_mutex_unlock(&atomic_lock);
+}
diff --git a/mythtv/external/FFmpeg/compat/atomics/pthread/stdatomic.h b/mythtv/external/FFmpeg/compat/atomics/pthread/stdatomic.h
new file mode 100644
index 00000000000..81a60f102bb
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/atomics/pthread/stdatomic.h
@@ -0,0 +1,197 @@
+/*
+ * 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
+ */
+
+/*
+ * based on vlc_atomic.h from VLC
+ * Copyright (C) 2010 Rémi Denis-Courmont
+ */
+
+#ifndef COMPAT_ATOMICS_PTHREAD_STDATOMIC_H
+#define COMPAT_ATOMICS_PTHREAD_STDATOMIC_H
+
+#include <stdint.h>
+
+#define ATOMIC_FLAG_INIT 0
+
+#define ATOMIC_VAR_INIT(value) (value)
+
+#define atomic_init(obj, value) \
+do {                            \
+    *(obj) = (value);           \
+} while(0)
+
+#define kill_dependency(y) ((void)0)
+
+#define atomic_signal_fence(order) \
+    ((void)0)
+
+#define atomic_is_lock_free(obj) 0
+
+typedef intptr_t atomic_flag;
+typedef intptr_t atomic_bool;
+typedef intptr_t atomic_char;
+typedef intptr_t atomic_schar;
+typedef intptr_t atomic_uchar;
+typedef intptr_t atomic_short;
+typedef intptr_t atomic_ushort;
+typedef intptr_t atomic_int;
+typedef intptr_t atomic_uint;
+typedef intptr_t atomic_long;
+typedef intptr_t atomic_ulong;
+typedef intptr_t atomic_llong;
+typedef intptr_t atomic_ullong;
+typedef intptr_t atomic_wchar_t;
+typedef intptr_t atomic_int_least8_t;
+typedef intptr_t atomic_uint_least8_t;
+typedef intptr_t atomic_int_least16_t;
+typedef intptr_t atomic_uint_least16_t;
+typedef intptr_t atomic_int_least32_t;
+typedef intptr_t atomic_uint_least32_t;
+typedef intptr_t atomic_int_least64_t;
+typedef intptr_t atomic_uint_least64_t;
+typedef intptr_t atomic_int_fast8_t;
+typedef intptr_t atomic_uint_fast8_t;
+typedef intptr_t atomic_int_fast16_t;
+typedef intptr_t atomic_uint_fast16_t;
+typedef intptr_t atomic_int_fast32_t;
+typedef intptr_t atomic_uint_fast32_t;
+typedef intptr_t atomic_int_fast64_t;
+typedef intptr_t atomic_uint_fast64_t;
+typedef intptr_t atomic_intptr_t;
+typedef intptr_t atomic_uintptr_t;
+typedef intptr_t atomic_size_t;
+typedef intptr_t atomic_ptrdiff_t;
+typedef intptr_t atomic_intmax_t;
+typedef intptr_t atomic_uintmax_t;
+
+void avpriv_atomic_lock(void);
+void avpriv_atomic_unlock(void);
+
+static inline void atomic_thread_fence(int order)
+{
+    avpriv_atomic_lock();
+    avpriv_atomic_unlock();
+}
+
+static inline void atomic_store(intptr_t *object, intptr_t desired)
+{
+    avpriv_atomic_lock();
+    *object = desired;
+    avpriv_atomic_unlock();
+}
+
+#define atomic_store_explicit(object, desired, order) \
+    atomic_store(object, desired)
+
+static inline intptr_t atomic_load(intptr_t *object)
+{
+    intptr_t ret;
+    avpriv_atomic_lock();
+    ret = *object;
+    avpriv_atomic_unlock();
+    return ret;
+}
+
+#define atomic_load_explicit(object, order) \
+    atomic_load(object)
+
+static inline intptr_t atomic_exchange(intptr_t *object, intptr_t desired)
+{
+    intptr_t ret;
+    avpriv_atomic_lock();
+    ret     = *object;
+    *object = desired;
+    avpriv_atomic_unlock();
+    return ret;
+}
+
+#define atomic_exchange_explicit(object, desired, order) \
+    atomic_exchange(object, desired)
+
+static inline int atomic_compare_exchange_strong(intptr_t *object, intptr_t *expected,
+                                                 intptr_t desired)
+{
+    int ret;
+    avpriv_atomic_lock();
+    if (*object == *expected) {
+        ret     = 1;
+        *object = desired;
+    } else {
+        ret = 0;
+        *expected = *object;
+    }
+    avpriv_atomic_unlock();
+    return ret;
+}
+
+#define atomic_compare_exchange_strong_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak(object, expected, desired) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_weak(object, expected, desired)
+
+#define FETCH_MODIFY(opname, op)                                                   \
+static inline intptr_t atomic_fetch_ ## opname(intptr_t *object, intptr_t operand) \
+{                                                                                  \
+    intptr_t ret;                                                                  \
+    avpriv_atomic_lock();                                                          \
+    ret = *object;                                                                 \
+    *object = *object op operand;                                                  \
+    avpriv_atomic_unlock();                                                        \
+    return ret;                                                                    \
+}
+
+FETCH_MODIFY(add, +)
+FETCH_MODIFY(sub, -)
+FETCH_MODIFY(or,  |)
+FETCH_MODIFY(xor, ^)
+FETCH_MODIFY(and, &)
+
+#undef FETCH_MODIFY
+
+#define atomic_fetch_add_explicit(object, operand, order) \
+    atomic_fetch_add(object, operand)
+
+#define atomic_fetch_sub_explicit(object, operand, order) \
+    atomic_fetch_sub(object, operand)
+
+#define atomic_fetch_or_explicit(object, operand, order) \
+    atomic_fetch_or(object, operand)
+
+#define atomic_fetch_xor_explicit(object, operand, order) \
+    atomic_fetch_xor(object, operand)
+
+#define atomic_fetch_and_explicit(object, operand, order) \
+    atomic_fetch_and(object, operand)
+
+#define atomic_flag_test_and_set(object) \
+    atomic_exchange(object, 1)
+
+#define atomic_flag_test_and_set_explicit(object, order) \
+    atomic_flag_test_and_set(object)
+
+#define atomic_flag_clear(object) \
+    atomic_store(object, 0)
+
+#define atomic_flag_clear_explicit(object, order) \
+    atomic_flag_clear(object)
+
+#endif /* COMPAT_ATOMICS_PTHREAD_STDATOMIC_H */
diff --git a/mythtv/external/FFmpeg/compat/atomics/suncc/stdatomic.h b/mythtv/external/FFmpeg/compat/atomics/suncc/stdatomic.h
new file mode 100644
index 00000000000..0cf89e0f78d
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/atomics/suncc/stdatomic.h
@@ -0,0 +1,186 @@
+/*
+ * 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 COMPAT_ATOMICS_SUNCC_STDATOMIC_H
+#define COMPAT_ATOMICS_SUNCC_STDATOMIC_H
+
+#include <atomic.h>
+#include <mbarrier.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#define ATOMIC_FLAG_INIT 0
+
+#define ATOMIC_VAR_INIT(value) (value)
+
+#define atomic_init(obj, value) \
+do {                            \
+    *(obj) = (value);           \
+} while(0)
+
+#define kill_dependency(y) ((void)0)
+
+#define atomic_thread_fence(order) \
+    __machine_rw_barrier();
+
+#define atomic_signal_fence(order) \
+    ((void)0)
+
+#define atomic_is_lock_free(obj) 0
+
+typedef intptr_t atomic_flag;
+typedef intptr_t atomic_bool;
+typedef intptr_t atomic_char;
+typedef intptr_t atomic_schar;
+typedef intptr_t atomic_uchar;
+typedef intptr_t atomic_short;
+typedef intptr_t atomic_ushort;
+typedef intptr_t atomic_int;
+typedef intptr_t atomic_uint;
+typedef intptr_t atomic_long;
+typedef intptr_t atomic_ulong;
+typedef intptr_t atomic_llong;
+typedef intptr_t atomic_ullong;
+typedef intptr_t atomic_wchar_t;
+typedef intptr_t atomic_int_least8_t;
+typedef intptr_t atomic_uint_least8_t;
+typedef intptr_t atomic_int_least16_t;
+typedef intptr_t atomic_uint_least16_t;
+typedef intptr_t atomic_int_least32_t;
+typedef intptr_t atomic_uint_least32_t;
+typedef intptr_t atomic_int_least64_t;
+typedef intptr_t atomic_uint_least64_t;
+typedef intptr_t atomic_int_fast8_t;
+typedef intptr_t atomic_uint_fast8_t;
+typedef intptr_t atomic_int_fast16_t;
+typedef intptr_t atomic_uint_fast16_t;
+typedef intptr_t atomic_int_fast32_t;
+typedef intptr_t atomic_uint_fast32_t;
+typedef intptr_t atomic_int_fast64_t;
+typedef intptr_t atomic_uint_fast64_t;
+typedef intptr_t atomic_intptr_t;
+typedef intptr_t atomic_uintptr_t;
+typedef intptr_t atomic_size_t;
+typedef intptr_t atomic_ptrdiff_t;
+typedef intptr_t atomic_intmax_t;
+typedef intptr_t atomic_uintmax_t;
+
+static inline void atomic_store(intptr_t *object, intptr_t desired)
+{
+    *object = desired;
+    __machine_rw_barrier();
+}
+
+#define atomic_store_explicit(object, desired, order) \
+    atomic_store(object, desired)
+
+static inline intptr_t atomic_load(intptr_t *object)
+{
+    __machine_rw_barrier();
+    return *object;
+}
+
+#define atomic_load_explicit(object, order) \
+    atomic_load(object)
+
+#define atomic_exchange(object, desired) \
+    atomic_swap_ptr(object, desired)
+
+#define atomic_exchange_explicit(object, desired, order) \
+    atomic_exchange(object, desired)
+
+static inline int atomic_compare_exchange_strong(intptr_t *object, intptr_t *expected,
+                                                 intptr_t desired)
+{
+    intptr_t  old = *expected;
+    *expected = (intptr_t)atomic_cas_ptr(object, (void *)old, (void *)desired);
+    return *expected == old;
+}
+
+#define atomic_compare_exchange_strong_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak(object, expected, desired) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_weak(object, expected, desired)
+
+static inline intptr_t atomic_fetch_add(intptr_t *object, intptr_t operand)
+{
+    return atomic_add_ptr_nv(object, operand) - operand;
+}
+
+#define atomic_fetch_sub(object, operand) \
+    atomic_fetch_add(object, -(operand))
+
+static inline intptr_t atomic_fetch_or(intptr_t *object, intptr_t operand)
+{
+    intptr_t old;
+    do {
+        old = atomic_load(object);
+    } while (!atomic_compare_exchange_strong(object, old, old | operand));
+    return old;
+}
+
+static inline intptr_t atomic_fetch_xor(intptr_t *object, intptr_t operand)
+{
+    intptr_t old;
+    do {
+        old = atomic_load(object);
+    } while (!atomic_compare_exchange_strong(object, old, old ^ operand));
+    return old;
+}
+
+static inline intptr_t atomic_fetch_and(intptr_t *object, intptr_t operand)
+{
+    intptr_t old;
+    do {
+        old = atomic_load(object);
+    } while (!atomic_compare_exchange_strong(object, old, old & operand));
+    return old;
+}
+
+#define atomic_fetch_add_explicit(object, operand, order) \
+    atomic_fetch_add(object, operand)
+
+#define atomic_fetch_sub_explicit(object, operand, order) \
+    atomic_fetch_sub(object, operand)
+
+#define atomic_fetch_or_explicit(object, operand, order) \
+    atomic_fetch_or(object, operand)
+
+#define atomic_fetch_xor_explicit(object, operand, order) \
+    atomic_fetch_xor(object, operand)
+
+#define atomic_fetch_and_explicit(object, operand, order) \
+    atomic_fetch_and(object, operand)
+
+#define atomic_flag_test_and_set(object) \
+    atomic_exchange(object, 1)
+
+#define atomic_flag_test_and_set_explicit(object, order) \
+    atomic_flag_test_and_set(object)
+
+#define atomic_flag_clear(object) \
+    atomic_store(object, 0)
+
+#define atomic_flag_clear_explicit(object, order) \
+    atomic_flag_clear(object)
+
+#endif /* COMPAT_ATOMICS_SUNCC_STDATOMIC_H */
diff --git a/mythtv/external/FFmpeg/compat/atomics/win32/stdatomic.h b/mythtv/external/FFmpeg/compat/atomics/win32/stdatomic.h
new file mode 100644
index 00000000000..bb8e6e7e15a
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/atomics/win32/stdatomic.h
@@ -0,0 +1,181 @@
+/*
+ * 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 COMPAT_ATOMICS_WIN32_STDATOMIC_H
+#define COMPAT_ATOMICS_WIN32_STDATOMIC_H
+
+#define WIN32_LEAN_AND_MEAN
+#include <stddef.h>
+#include <stdint.h>
+#include <windows.h>
+
+#define ATOMIC_FLAG_INIT 0
+
+#define ATOMIC_VAR_INIT(value) (value)
+
+#define atomic_init(obj, value) \
+do {                            \
+    *(obj) = (value);           \
+} while(0)
+
+#define kill_dependency(y) ((void)0)
+
+#define atomic_thread_fence(order) \
+    MemoryBarrier();
+
+#define atomic_signal_fence(order) \
+    ((void)0)
+
+#define atomic_is_lock_free(obj) 0
+
+typedef intptr_t atomic_flag;
+typedef intptr_t atomic_bool;
+typedef intptr_t atomic_char;
+typedef intptr_t atomic_schar;
+typedef intptr_t atomic_uchar;
+typedef intptr_t atomic_short;
+typedef intptr_t atomic_ushort;
+typedef intptr_t atomic_int;
+typedef intptr_t atomic_uint;
+typedef intptr_t atomic_long;
+typedef intptr_t atomic_ulong;
+typedef intptr_t atomic_llong;
+typedef intptr_t atomic_ullong;
+typedef intptr_t atomic_wchar_t;
+typedef intptr_t atomic_int_least8_t;
+typedef intptr_t atomic_uint_least8_t;
+typedef intptr_t atomic_int_least16_t;
+typedef intptr_t atomic_uint_least16_t;
+typedef intptr_t atomic_int_least32_t;
+typedef intptr_t atomic_uint_least32_t;
+typedef intptr_t atomic_int_least64_t;
+typedef intptr_t atomic_uint_least64_t;
+typedef intptr_t atomic_int_fast8_t;
+typedef intptr_t atomic_uint_fast8_t;
+typedef intptr_t atomic_int_fast16_t;
+typedef intptr_t atomic_uint_fast16_t;
+typedef intptr_t atomic_int_fast32_t;
+typedef intptr_t atomic_uint_fast32_t;
+typedef intptr_t atomic_int_fast64_t;
+typedef intptr_t atomic_uint_fast64_t;
+typedef intptr_t atomic_intptr_t;
+typedef intptr_t atomic_uintptr_t;
+typedef intptr_t atomic_size_t;
+typedef intptr_t atomic_ptrdiff_t;
+typedef intptr_t atomic_intmax_t;
+typedef intptr_t atomic_uintmax_t;
+
+#define atomic_store(object, desired)   \
+do {                                    \
+    *(object) = (desired);              \
+    MemoryBarrier();                    \
+} while (0)
+
+#define atomic_store_explicit(object, desired, order) \
+    atomic_store(object, desired)
+
+#define atomic_load(object) \
+    (MemoryBarrier(), *(object))
+
+#define atomic_load_explicit(object, order) \
+    atomic_load(object)
+
+#define atomic_exchange(object, desired) \
+    InterlockedExchangePointer(object, desired);
+
+#define atomic_exchange_explicit(object, desired, order) \
+    atomic_exchange(object, desired)
+
+static inline int atomic_compare_exchange_strong(intptr_t *object, intptr_t *expected,
+                                                 intptr_t desired)
+{
+    intptr_t old = *expected;
+    *expected = (intptr_t)InterlockedCompareExchangePointer(
+        (PVOID *)object, (PVOID)desired, (PVOID)old);
+    return *expected == old;
+}
+
+#define atomic_compare_exchange_strong_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak(object, expected, desired) \
+    atomic_compare_exchange_strong(object, expected, desired)
+
+#define atomic_compare_exchange_weak_explicit(object, expected, desired, success, failure) \
+    atomic_compare_exchange_weak(object, expected, desired)
+
+#ifdef _WIN64
+#define atomic_fetch_add(object, operand) \
+    InterlockedExchangeAdd64(object, operand)
+
+#define atomic_fetch_sub(object, operand) \
+    InterlockedExchangeAdd64(object, -(operand))
+
+#define atomic_fetch_or(object, operand) \
+    InterlockedOr64(object, operand)
+
+#define atomic_fetch_xor(object, operand) \
+    InterlockedXor64(object, operand)
+
+#define atomic_fetch_and(object, operand) \
+    InterlockedAnd64(object, operand)
+#else
+#define atomic_fetch_add(object, operand) \
+    InterlockedExchangeAdd(object, operand)
+
+#define atomic_fetch_sub(object, operand) \
+    InterlockedExchangeAdd(object, -(operand))
+
+#define atomic_fetch_or(object, operand) \
+    InterlockedOr(object, operand)
+
+#define atomic_fetch_xor(object, operand) \
+    InterlockedXor(object, operand)
+
+#define atomic_fetch_and(object, operand) \
+    InterlockedAnd(object, operand)
+#endif /* _WIN64 */
+
+#define atomic_fetch_add_explicit(object, operand, order) \
+    atomic_fetch_add(object, operand)
+
+#define atomic_fetch_sub_explicit(object, operand, order) \
+    atomic_fetch_sub(object, operand)
+
+#define atomic_fetch_or_explicit(object, operand, order) \
+    atomic_fetch_or(object, operand)
+
+#define atomic_fetch_xor_explicit(object, operand, order) \
+    atomic_fetch_xor(object, operand)
+
+#define atomic_fetch_and_explicit(object, operand, order) \
+    atomic_fetch_and(object, operand)
+
+#define atomic_flag_test_and_set(object) \
+    atomic_exchange(object, 1)
+
+#define atomic_flag_test_and_set_explicit(object, order) \
+    atomic_flag_test_and_set(object)
+
+#define atomic_flag_clear(object) \
+    atomic_store(object, 0)
+
+#define atomic_flag_clear_explicit(object, order) \
+    atomic_flag_clear(object)
+
+#endif /* COMPAT_ATOMICS_WIN32_STDATOMIC_H */
diff --git a/mythtv/external/FFmpeg/compat/cuda/cuviddec.h b/mythtv/external/FFmpeg/compat/cuda/cuviddec.h
deleted file mode 100644
index f9257ea5300..00000000000
--- a/mythtv/external/FFmpeg/compat/cuda/cuviddec.h
+++ /dev/null
@@ -1,827 +0,0 @@
-/*
- * This copyright notice applies to this header file only:
- *
- * Copyright (c) 2010-2016 NVIDIA Corporation
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the software, and to permit persons to whom the
- * software is furnished to do so, subject to the following
- * conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/**
- * \file cuviddec.h
- * NvCuvid API provides Video Decoding interface to NVIDIA GPU devices.
- * \date 2015-2016
- * This file contains constants, structure definitions and function prototypes used for decoding.
- */
-
-#if !defined(__CUDA_VIDEO_H__)
-#define __CUDA_VIDEO_H__
-
-#ifndef __cuda_cuda_h__
-#include <cuda.h>
-#endif // __cuda_cuda_h__
-
-#if defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
-#if (CUDA_VERSION >= 3020) && (!defined(CUDA_FORCE_API_VERSION) || (CUDA_FORCE_API_VERSION >= 3020))
-#define __CUVID_DEVPTR64
-#endif
-#endif
-
-#if defined(__cplusplus)
-extern "C" {
-#endif /* __cplusplus */
-
-typedef void *CUvideodecoder;
-typedef struct _CUcontextlock_st *CUvideoctxlock;
-
-/**
- * \addtogroup VIDEO_DECODER Video Decoder
- * @{
- */
-
-/*!
- * \enum cudaVideoCodec
- * Video Codec Enums
- */
-typedef enum cudaVideoCodec_enum {
-    cudaVideoCodec_MPEG1=0,                 /**<  MPEG1   */
-    cudaVideoCodec_MPEG2,                   /**<  MPEG2  */
-    cudaVideoCodec_MPEG4,                   /**<  MPEG4   */
-    cudaVideoCodec_VC1,                     /**<  VC1   */
-    cudaVideoCodec_H264,                    /**<  H264   */
-    cudaVideoCodec_JPEG,                    /**<  JPEG   */
-    cudaVideoCodec_H264_SVC,                /**<  H264-SVC   */
-    cudaVideoCodec_H264_MVC,                /**<  H264-MVC   */
-    cudaVideoCodec_HEVC,                    /**<  HEVC   */
-    cudaVideoCodec_VP8,                     /**<  VP8   */
-    cudaVideoCodec_VP9,                     /**<  VP9   */
-    cudaVideoCodec_NumCodecs,               /**<  Max COdecs   */
-    // Uncompressed YUV
-    cudaVideoCodec_YUV420 = (('I'<<24)|('Y'<<16)|('U'<<8)|('V')),   /**< Y,U,V (4:2:0)  */
-    cudaVideoCodec_YV12   = (('Y'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,V,U (4:2:0)  */
-    cudaVideoCodec_NV12   = (('N'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,UV  (4:2:0)  */
-    cudaVideoCodec_YUYV   = (('Y'<<24)|('U'<<16)|('Y'<<8)|('V')),   /**< YUYV/YUY2 (4:2:2)  */
-    cudaVideoCodec_UYVY   = (('U'<<24)|('Y'<<16)|('V'<<8)|('Y'))    /**< UYVY (4:2:2)  */
-} cudaVideoCodec;
-
-/*!
- * \enum cudaVideoSurfaceFormat
- * Video Surface Formats Enums
- */
-typedef enum cudaVideoSurfaceFormat_enum {
-    cudaVideoSurfaceFormat_NV12=0       /**< NV12 (currently the only supported output format)  */
-} cudaVideoSurfaceFormat;
-
-/*!
- * \enum cudaVideoDeinterlaceMode
- * Deinterlacing Modes Enums
- */
-typedef enum cudaVideoDeinterlaceMode_enum {
-    cudaVideoDeinterlaceMode_Weave=0,   /**< Weave both fields (no deinterlacing) */
-    cudaVideoDeinterlaceMode_Bob,       /**< Drop one field  */
-    cudaVideoDeinterlaceMode_Adaptive   /**< Adaptive deinterlacing  */
-} cudaVideoDeinterlaceMode;
-
-/*!
- * \enum cudaVideoChromaFormat
- * Chroma Formats Enums
- */
-typedef enum cudaVideoChromaFormat_enum {
-    cudaVideoChromaFormat_Monochrome=0,  /**< MonoChrome */
-    cudaVideoChromaFormat_420,           /**< 4:2:0 */
-    cudaVideoChromaFormat_422,           /**< 4:2:2 */
-    cudaVideoChromaFormat_444            /**< 4:4:4 */
-} cudaVideoChromaFormat;
-
-/*!
- * \enum cudaVideoCreateFlags
- * Decoder Flags Enums
- */
-typedef enum cudaVideoCreateFlags_enum {
-    cudaVideoCreate_Default = 0x00,     /**< Default operation mode: use dedicated video engines */
-    cudaVideoCreate_PreferCUDA = 0x01,  /**< Use a CUDA-based decoder if faster than dedicated engines (requires a valid vidLock object for multi-threading) */
-    cudaVideoCreate_PreferDXVA = 0x02,  /**< Go through DXVA internally if possible (requires D3D9 interop) */
-    cudaVideoCreate_PreferCUVID = 0x04  /**< Use dedicated video engines directly */
-} cudaVideoCreateFlags;
-
-/*!
- * \struct CUVIDDECODECREATEINFO
- * Struct used in create decoder
- */
-typedef struct _CUVIDDECODECREATEINFO
-{
-    unsigned long ulWidth;              /**< Coded Sequence Width */
-    unsigned long ulHeight;             /**< Coded Sequence Height */
-    unsigned long ulNumDecodeSurfaces;  /**< Maximum number of internal decode surfaces */
-    cudaVideoCodec CodecType;           /**< cudaVideoCodec_XXX */
-    cudaVideoChromaFormat ChromaFormat; /**< cudaVideoChromaFormat_XXX (only 4:2:0 is currently supported) */
-    unsigned long ulCreationFlags;      /**< Decoder creation flags (cudaVideoCreateFlags_XXX) */
-    unsigned long bitDepthMinus8;
-    unsigned long Reserved1[4];         /**< Reserved for future use - set to zero */
-    /**
-    * area of the frame that should be displayed
-    */
-    struct {
-        short left;
-        short top;
-        short right;
-        short bottom;
-    } display_area;
-
-    cudaVideoSurfaceFormat OutputFormat;       /**< cudaVideoSurfaceFormat_XXX */
-    cudaVideoDeinterlaceMode DeinterlaceMode;  /**< cudaVideoDeinterlaceMode_XXX */
-    unsigned long ulTargetWidth;               /**< Post-processed Output Width (Should be aligned to 2) */
-    unsigned long ulTargetHeight;              /**< Post-processed Output Height (Should be aligbed to 2) */
-    unsigned long ulNumOutputSurfaces;         /**< Maximum number of output surfaces simultaneously mapped */
-    CUvideoctxlock vidLock;                    /**< If non-NULL, context lock used for synchronizing ownership of the cuda context */
-    /**
-    * target rectangle in the output frame (for aspect ratio conversion)
-    * if a null rectangle is specified, {0,0,ulTargetWidth,ulTargetHeight} will be used
-    */
-    struct {
-        short left;
-        short top;
-        short right;
-        short bottom;
-    } target_rect;
-    unsigned long Reserved2[5];                /**< Reserved for future use - set to zero */
-} CUVIDDECODECREATEINFO;
-
-/*!
- * \struct CUVIDH264DPBENTRY
- * H.264 DPB Entry
- */
-typedef struct _CUVIDH264DPBENTRY
-{
-    int PicIdx;                 /**< picture index of reference frame */
-    int FrameIdx;               /**< frame_num(short-term) or LongTermFrameIdx(long-term) */
-    int is_long_term;           /**< 0=short term reference, 1=long term reference */
-    int not_existing;           /**< non-existing reference frame (corresponding PicIdx should be set to -1) */
-    int used_for_reference;     /**< 0=unused, 1=top_field, 2=bottom_field, 3=both_fields */
-    int FieldOrderCnt[2];       /**< field order count of top and bottom fields */
-} CUVIDH264DPBENTRY;
-
-/*!
- * \struct CUVIDH264MVCEXT
- * H.264 MVC Picture Parameters Ext
- */
-typedef struct _CUVIDH264MVCEXT
-{
-    int num_views_minus1;
-    int view_id;
-    unsigned char inter_view_flag;
-    unsigned char num_inter_view_refs_l0;
-    unsigned char num_inter_view_refs_l1;
-    unsigned char MVCReserved8Bits;
-    int InterViewRefsL0[16];
-    int InterViewRefsL1[16];
-} CUVIDH264MVCEXT;
-
-/*!
- * \struct CUVIDH264SVCEXT
- * H.264 SVC Picture Parameters Ext
- */
-typedef struct _CUVIDH264SVCEXT
-{
-    unsigned char profile_idc;
-    unsigned char level_idc;
-    unsigned char DQId;
-    unsigned char DQIdMax;
-    unsigned char disable_inter_layer_deblocking_filter_idc;
-    unsigned char ref_layer_chroma_phase_y_plus1;
-    signed char   inter_layer_slice_alpha_c0_offset_div2;
-    signed char   inter_layer_slice_beta_offset_div2;
-
-    unsigned short DPBEntryValidFlag;
-    unsigned char inter_layer_deblocking_filter_control_present_flag;
-    unsigned char extended_spatial_scalability_idc;
-    unsigned char adaptive_tcoeff_level_prediction_flag;
-    unsigned char slice_header_restriction_flag;
-    unsigned char chroma_phase_x_plus1_flag;
-    unsigned char chroma_phase_y_plus1;
-
-    unsigned char tcoeff_level_prediction_flag;
-    unsigned char constrained_intra_resampling_flag;
-    unsigned char ref_layer_chroma_phase_x_plus1_flag;
-    unsigned char store_ref_base_pic_flag;
-    unsigned char Reserved8BitsA;
-    unsigned char Reserved8BitsB;
-    // For the 4 scaled_ref_layer_XX fields below,
-    // if (extended_spatial_scalability_idc == 1), SPS field, G.7.3.2.1.4, add prefix "seq_"
-    // if (extended_spatial_scalability_idc == 2), SLH field, G.7.3.3.4,
-    short scaled_ref_layer_left_offset;
-    short scaled_ref_layer_top_offset;
-    short scaled_ref_layer_right_offset;
-    short scaled_ref_layer_bottom_offset;
-    unsigned short Reserved16Bits;
-    struct _CUVIDPICPARAMS *pNextLayer; /**< Points to the picparams for the next layer to be decoded. Linked list ends at the target layer. */
-    int bRefBaseLayer;                  /**< whether to store ref base pic */
-} CUVIDH264SVCEXT;
-
-/*!
- * \struct CUVIDH264PICPARAMS
- * H.264 Picture Parameters
- */
-typedef struct _CUVIDH264PICPARAMS
-{
-    // SPS
-    int log2_max_frame_num_minus4;
-    int pic_order_cnt_type;
-    int log2_max_pic_order_cnt_lsb_minus4;
-    int delta_pic_order_always_zero_flag;
-    int frame_mbs_only_flag;
-    int direct_8x8_inference_flag;
-    int num_ref_frames;             // NOTE: shall meet level 4.1 restrictions
-    unsigned char residual_colour_transform_flag;
-    unsigned char bit_depth_luma_minus8;    // Must be 0 (only 8-bit supported)
-    unsigned char bit_depth_chroma_minus8;  // Must be 0 (only 8-bit supported)
-    unsigned char qpprime_y_zero_transform_bypass_flag;
-    // PPS
-    int entropy_coding_mode_flag;
-    int pic_order_present_flag;
-    int num_ref_idx_l0_active_minus1;
-    int num_ref_idx_l1_active_minus1;
-    int weighted_pred_flag;
-    int weighted_bipred_idc;
-    int pic_init_qp_minus26;
-    int deblocking_filter_control_present_flag;
-    int redundant_pic_cnt_present_flag;
-    int transform_8x8_mode_flag;
-    int MbaffFrameFlag;
-    int constrained_intra_pred_flag;
-    int chroma_qp_index_offset;
-    int second_chroma_qp_index_offset;
-    int ref_pic_flag;
-    int frame_num;
-    int CurrFieldOrderCnt[2];
-    // DPB
-    CUVIDH264DPBENTRY dpb[16];          // List of reference frames within the DPB
-    // Quantization Matrices (raster-order)
-    unsigned char WeightScale4x4[6][16];
-    unsigned char WeightScale8x8[2][64];
-    // FMO/ASO
-    unsigned char fmo_aso_enable;
-    unsigned char num_slice_groups_minus1;
-    unsigned char slice_group_map_type;
-    signed char pic_init_qs_minus26;
-    unsigned int slice_group_change_rate_minus1;
-    union
-    {
-        unsigned long long slice_group_map_addr;
-        const unsigned char *pMb2SliceGroupMap;
-    } fmo;
-    unsigned int  Reserved[12];
-    // SVC/MVC
-    union
-    {
-        CUVIDH264MVCEXT mvcext;
-        CUVIDH264SVCEXT svcext;
-    };
-} CUVIDH264PICPARAMS;
-
-
-/*!
- * \struct CUVIDMPEG2PICPARAMS
- * MPEG-2 Picture Parameters
- */
-typedef struct _CUVIDMPEG2PICPARAMS
-{
-    int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)
-    int BackwardRefIdx;         // Picture index of backward reference (B-frames)
-    int picture_coding_type;
-    int full_pel_forward_vector;
-    int full_pel_backward_vector;
-    int f_code[2][2];
-    int intra_dc_precision;
-    int frame_pred_frame_dct;
-    int concealment_motion_vectors;
-    int q_scale_type;
-    int intra_vlc_format;
-    int alternate_scan;
-    int top_field_first;
-    // Quantization matrices (raster order)
-    unsigned char QuantMatrixIntra[64];
-    unsigned char QuantMatrixInter[64];
-} CUVIDMPEG2PICPARAMS;
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// MPEG-4 Picture Parameters
-//
-
-// MPEG-4 has VOP types instead of Picture types
-#define I_VOP 0
-#define P_VOP 1
-#define B_VOP 2
-#define S_VOP 3
-
-/*!
- * \struct CUVIDMPEG4PICPARAMS
- * MPEG-4 Picture Parameters
- */
-typedef struct _CUVIDMPEG4PICPARAMS
-{
-    int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)
-    int BackwardRefIdx;         // Picture index of backward reference (B-frames)
-    // VOL
-    int video_object_layer_width;
-    int video_object_layer_height;
-    int vop_time_increment_bitcount;
-    int top_field_first;
-    int resync_marker_disable;
-    int quant_type;
-    int quarter_sample;
-    int short_video_header;
-    int divx_flags;
-    // VOP
-    int vop_coding_type;
-    int vop_coded;
-    int vop_rounding_type;
-    int alternate_vertical_scan_flag;
-    int interlaced;
-    int vop_fcode_forward;
-    int vop_fcode_backward;
-    int trd[2];
-    int trb[2];
-    // Quantization matrices (raster order)
-    unsigned char QuantMatrixIntra[64];
-    unsigned char QuantMatrixInter[64];
-    int gmc_enabled;
-} CUVIDMPEG4PICPARAMS;
-
-/*!
- * \struct CUVIDVC1PICPARAMS
- * VC1 Picture Parameters
- */
-typedef struct _CUVIDVC1PICPARAMS
-{
-    int ForwardRefIdx;      /**< Picture index of forward reference (P/B-frames) */
-    int BackwardRefIdx;     /**< Picture index of backward reference (B-frames) */
-    int FrameWidth;         /**< Actual frame width */
-    int FrameHeight;        /**< Actual frame height */
-    // PICTURE
-    int intra_pic_flag;     /**< Set to 1 for I,BI frames */
-    int ref_pic_flag;       /**< Set to 1 for I,P frames */
-    int progressive_fcm;    /**< Progressive frame */
-    // SEQUENCE
-    int profile;
-    int postprocflag;
-    int pulldown;
-    int interlace;
-    int tfcntrflag;
-    int finterpflag;
-    int psf;
-    int multires;
-    int syncmarker;
-    int rangered;
-    int maxbframes;
-    // ENTRYPOINT
-    int panscan_flag;
-    int refdist_flag;
-    int extended_mv;
-    int dquant;
-    int vstransform;
-    int loopfilter;
-    int fastuvmc;
-    int overlap;
-    int quantizer;
-    int extended_dmv;
-    int range_mapy_flag;
-    int range_mapy;
-    int range_mapuv_flag;
-    int range_mapuv;
-    int rangeredfrm;    // range reduction state
-} CUVIDVC1PICPARAMS;
-
-/*!
- * \struct CUVIDJPEGPICPARAMS
- * JPEG Picture Parameters
- */
-typedef struct _CUVIDJPEGPICPARAMS
-{
-    int Reserved;
-} CUVIDJPEGPICPARAMS;
-
-
- /*!
- * \struct CUVIDHEVCPICPARAMS
- * HEVC Picture Parameters
- */
-typedef struct _CUVIDHEVCPICPARAMS
-{
-    // sps
-    int pic_width_in_luma_samples;
-    int pic_height_in_luma_samples;
-    unsigned char log2_min_luma_coding_block_size_minus3;
-    unsigned char log2_diff_max_min_luma_coding_block_size;
-    unsigned char log2_min_transform_block_size_minus2;
-    unsigned char log2_diff_max_min_transform_block_size;
-    unsigned char pcm_enabled_flag;
-    unsigned char log2_min_pcm_luma_coding_block_size_minus3;
-    unsigned char log2_diff_max_min_pcm_luma_coding_block_size;
-    unsigned char pcm_sample_bit_depth_luma_minus1;
-
-    unsigned char pcm_sample_bit_depth_chroma_minus1;
-    unsigned char pcm_loop_filter_disabled_flag;
-    unsigned char strong_intra_smoothing_enabled_flag;
-    unsigned char max_transform_hierarchy_depth_intra;
-    unsigned char max_transform_hierarchy_depth_inter;
-    unsigned char amp_enabled_flag;
-    unsigned char separate_colour_plane_flag;
-    unsigned char log2_max_pic_order_cnt_lsb_minus4;
-
-    unsigned char num_short_term_ref_pic_sets;
-    unsigned char long_term_ref_pics_present_flag;
-    unsigned char num_long_term_ref_pics_sps;
-    unsigned char sps_temporal_mvp_enabled_flag;
-    unsigned char sample_adaptive_offset_enabled_flag;
-    unsigned char scaling_list_enable_flag;
-    unsigned char IrapPicFlag;
-    unsigned char IdrPicFlag;
-
-    unsigned char bit_depth_luma_minus8;
-    unsigned char bit_depth_chroma_minus8;
-    unsigned char reserved1[14];
-
-    // pps
-    unsigned char dependent_slice_segments_enabled_flag;
-    unsigned char slice_segment_header_extension_present_flag;
-    unsigned char sign_data_hiding_enabled_flag;
-    unsigned char cu_qp_delta_enabled_flag;
-    unsigned char diff_cu_qp_delta_depth;
-    signed char init_qp_minus26;
-    signed char pps_cb_qp_offset;
-    signed char pps_cr_qp_offset;
-
-    unsigned char constrained_intra_pred_flag;
-    unsigned char weighted_pred_flag;
-    unsigned char weighted_bipred_flag;
-    unsigned char transform_skip_enabled_flag;
-    unsigned char transquant_bypass_enabled_flag;
-    unsigned char entropy_coding_sync_enabled_flag;
-    unsigned char log2_parallel_merge_level_minus2;
-    unsigned char num_extra_slice_header_bits;
-
-    unsigned char loop_filter_across_tiles_enabled_flag;
-    unsigned char loop_filter_across_slices_enabled_flag;
-    unsigned char output_flag_present_flag;
-    unsigned char num_ref_idx_l0_default_active_minus1;
-    unsigned char num_ref_idx_l1_default_active_minus1;
-    unsigned char lists_modification_present_flag;
-    unsigned char cabac_init_present_flag;
-    unsigned char pps_slice_chroma_qp_offsets_present_flag;
-
-    unsigned char deblocking_filter_override_enabled_flag;
-    unsigned char pps_deblocking_filter_disabled_flag;
-    signed char pps_beta_offset_div2;
-    signed char pps_tc_offset_div2;
-    unsigned char tiles_enabled_flag;
-    unsigned char uniform_spacing_flag;
-    unsigned char num_tile_columns_minus1;
-    unsigned char num_tile_rows_minus1;
-
-    unsigned short column_width_minus1[21];
-    unsigned short row_height_minus1[21];
-    unsigned int reserved3[15];
-
-    // RefPicSets
-    int NumBitsForShortTermRPSInSlice;
-    int NumDeltaPocsOfRefRpsIdx;
-    int NumPocTotalCurr;
-    int NumPocStCurrBefore;
-    int NumPocStCurrAfter;
-    int NumPocLtCurr;
-    int CurrPicOrderCntVal;
-    int RefPicIdx[16];                  // [refpic] Indices of valid reference pictures (-1 if unused for reference)
-    int PicOrderCntVal[16];             // [refpic]
-    unsigned char IsLongTerm[16];       // [refpic] 0=not a long-term reference, 1=long-term reference
-    unsigned char RefPicSetStCurrBefore[8]; // [0..NumPocStCurrBefore-1] -> refpic (0..15)
-    unsigned char RefPicSetStCurrAfter[8];  // [0..NumPocStCurrAfter-1] -> refpic (0..15)
-    unsigned char RefPicSetLtCurr[8];       // [0..NumPocLtCurr-1] -> refpic (0..15)
-    unsigned char RefPicSetInterLayer0[8];
-    unsigned char RefPicSetInterLayer1[8];
-    unsigned int reserved4[12];
-
-    // scaling lists (diag order)
-    unsigned char ScalingList4x4[6][16];       // [matrixId][i]
-    unsigned char ScalingList8x8[6][64];       // [matrixId][i]
-    unsigned char ScalingList16x16[6][64];     // [matrixId][i]
-    unsigned char ScalingList32x32[2][64];     // [matrixId][i]
-    unsigned char ScalingListDCCoeff16x16[6];  // [matrixId]
-    unsigned char ScalingListDCCoeff32x32[2];  // [matrixId]
-} CUVIDHEVCPICPARAMS;
-
-
-/*!
- * \struct CUVIDVP8PICPARAMS
- * VP8 Picture Parameters
- */
-typedef struct _CUVIDVP8PICPARAMS
-{
-    int width;
-    int height;
-    unsigned int first_partition_size;
-    //Frame Indexes
-    unsigned char LastRefIdx;
-    unsigned char GoldenRefIdx;
-    unsigned char AltRefIdx;
-    union {
-        struct {
-            unsigned char frame_type : 1;    /**< 0 = KEYFRAME, 1 = INTERFRAME  */
-            unsigned char version : 3;
-            unsigned char show_frame : 1;
-            unsigned char update_mb_segmentation_data : 1;    /**< Must be 0 if segmentation is not enabled */
-            unsigned char Reserved2Bits : 2;
-        };
-        unsigned char wFrameTagFlags;
-    };
-    unsigned char Reserved1[4];
-    unsigned int  Reserved2[3];
-} CUVIDVP8PICPARAMS;
-
-/*!
- * \struct CUVIDVP9PICPARAMS
- * VP9 Picture Parameters
- */
-typedef struct _CUVIDVP9PICPARAMS
-{
-    unsigned int width;
-    unsigned int height;
-
-    //Frame Indices
-    unsigned char LastRefIdx;
-    unsigned char GoldenRefIdx;
-    unsigned char AltRefIdx;
-    unsigned char colorSpace;
-
-    unsigned short profile : 3;
-    unsigned short frameContextIdx : 2;
-    unsigned short frameType : 1;
-    unsigned short showFrame : 1;
-    unsigned short errorResilient : 1;
-    unsigned short frameParallelDecoding : 1;
-    unsigned short subSamplingX : 1;
-    unsigned short subSamplingY : 1;
-    unsigned short intraOnly : 1;
-    unsigned short allow_high_precision_mv : 1;
-    unsigned short refreshEntropyProbs : 1;
-    unsigned short reserved2Bits : 2;
-
-    unsigned short reserved16Bits;
-
-    unsigned char  refFrameSignBias[4];
-
-    unsigned char bitDepthMinus8Luma;
-    unsigned char bitDepthMinus8Chroma;
-    unsigned char loopFilterLevel;
-    unsigned char loopFilterSharpness;
-
-    unsigned char modeRefLfEnabled;
-    unsigned char log2_tile_columns;
-    unsigned char log2_tile_rows;
-
-    unsigned char segmentEnabled : 1;
-    unsigned char segmentMapUpdate : 1;
-    unsigned char segmentMapTemporalUpdate : 1;
-    unsigned char segmentFeatureMode : 1;
-    unsigned char reserved4Bits : 4;
-
-
-    unsigned char segmentFeatureEnable[8][4];
-    short segmentFeatureData[8][4];
-    unsigned char mb_segment_tree_probs[7];
-    unsigned char segment_pred_probs[3];
-    unsigned char reservedSegment16Bits[2];
-
-    int qpYAc;
-    int qpYDc;
-    int qpChDc;
-    int qpChAc;
-
-    unsigned int activeRefIdx[3];
-    unsigned int resetFrameContext;
-    unsigned int mcomp_filter_type;
-    unsigned int mbRefLfDelta[4];
-    unsigned int mbModeLfDelta[2];
-    unsigned int frameTagSize;
-    unsigned int offsetToDctParts;
-    unsigned int reserved128Bits[4];
-
-} CUVIDVP9PICPARAMS;
-
-
-/*!
- * \struct CUVIDPICPARAMS
- * Picture Parameters for Decoding
- */
-typedef struct _CUVIDPICPARAMS
-{
-    int PicWidthInMbs;                    /**< Coded Frame Size */
-    int FrameHeightInMbs;                 /**< Coded Frame Height */
-    int CurrPicIdx;                       /**< Output index of the current picture */
-    int field_pic_flag;                   /**< 0=frame picture, 1=field picture */
-    int bottom_field_flag;                /**< 0=top field, 1=bottom field (ignored if field_pic_flag=0) */
-    int second_field;                     /**< Second field of a complementary field pair */
-    // Bitstream data
-    unsigned int nBitstreamDataLen;        /**< Number of bytes in bitstream data buffer */
-    const unsigned char *pBitstreamData;   /**< Ptr to bitstream data for this picture (slice-layer) */
-    unsigned int nNumSlices;               /**< Number of slices in this picture */
-    const unsigned int *pSliceDataOffsets; /**< nNumSlices entries, contains offset of each slice within the bitstream data buffer */
-    int ref_pic_flag;                      /**< This picture is a reference picture */
-    int intra_pic_flag;                    /**< This picture is entirely intra coded */
-    unsigned int Reserved[30];             /**< Reserved for future use */
-    // Codec-specific data
-    union {
-        CUVIDMPEG2PICPARAMS mpeg2;         /**< Also used for MPEG-1 */
-        CUVIDH264PICPARAMS h264;
-        CUVIDVC1PICPARAMS vc1;
-        CUVIDMPEG4PICPARAMS mpeg4;
-        CUVIDJPEGPICPARAMS jpeg;
-        CUVIDHEVCPICPARAMS hevc;
-        CUVIDVP8PICPARAMS vp8;
-        CUVIDVP9PICPARAMS vp9;
-        unsigned int CodecReserved[1024];
-    } CodecSpecific;
-} CUVIDPICPARAMS;
-
-
-/*!
- * \struct CUVIDPROCPARAMS
- * Picture Parameters for Postprocessing
- */
-typedef struct _CUVIDPROCPARAMS
-{
-    int progressive_frame;  /**< Input is progressive (deinterlace_mode will be ignored)  */
-    int second_field;       /**< Output the second field (ignored if deinterlace mode is Weave) */
-    int top_field_first;    /**< Input frame is top field first (1st field is top, 2nd field is bottom) */
-    int unpaired_field;     /**< Input only contains one field (2nd field is invalid) */
-    // The fields below are used for raw YUV input
-    unsigned int reserved_flags;        /**< Reserved for future use (set to zero) */
-    unsigned int reserved_zero;         /**< Reserved (set to zero) */
-    unsigned long long raw_input_dptr;  /**< Input CUdeviceptr for raw YUV extensions */
-    unsigned int raw_input_pitch;       /**< pitch in bytes of raw YUV input (should be aligned appropriately) */
-    unsigned int raw_input_format;      /**< Reserved for future use (set to zero) */
-    unsigned long long raw_output_dptr; /**< Reserved for future use (set to zero) */
-    unsigned int raw_output_pitch;      /**< Reserved for future use (set to zero) */
-    unsigned int Reserved[48];
-    void *Reserved3[3];
-} CUVIDPROCPARAMS;
-
-
-/**
- *
- * In order to minimize decode latencies, there should be always at least 2 pictures in the decode
- * queue at any time, in order to make sure that all decode engines are always busy.
- *
- * Overall data flow:
- *  - cuvidCreateDecoder(...)
- *  For each picture:
- *  - cuvidDecodePicture(N)
- *  - cuvidMapVideoFrame(N-4)
- *  - do some processing in cuda
- *  - cuvidUnmapVideoFrame(N-4)
- *  - cuvidDecodePicture(N+1)
- *  - cuvidMapVideoFrame(N-3)
- *    ...
- *  - cuvidDestroyDecoder(...)
- *
- * NOTE:
- * - When the cuda context is created from a D3D device, the D3D device must also be created
- *   with the D3DCREATE_MULTITHREADED flag.
- * - There is a limit to how many pictures can be mapped simultaneously (ulNumOutputSurfaces)
- * - cuVidDecodePicture may block the calling thread if there are too many pictures pending
- *   in the decode queue
- */
-
-/**
- * \fn CUresult CUDAAPI cuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci)
- * Create the decoder object
- */
-CUresult CUDAAPI cuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci);
-
-/**
- * \fn CUresult CUDAAPI cuvidDestroyDecoder(CUvideodecoder hDecoder)
- * Destroy the decoder object
- */
-CUresult CUDAAPI cuvidDestroyDecoder(CUvideodecoder hDecoder);
-
-/**
- * \fn CUresult CUDAAPI cuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams)
- * Decode a single picture (field or frame)
- */
-CUresult CUDAAPI cuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams);
-
-
-#if !defined(__CUVID_DEVPTR64) || defined(__CUVID_INTERNAL)
-/**
- * \fn CUresult CUDAAPI cuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx, unsigned int *pDevPtr, unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
- * Post-process and map a video frame for use in cuda
- */
-CUresult CUDAAPI cuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx,
-                                           unsigned int *pDevPtr, unsigned int *pPitch,
-                                           CUVIDPROCPARAMS *pVPP);
-
-/**
- * \fn CUresult CUDAAPI cuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr)
- * Unmap a previously mapped video frame
- */
-CUresult CUDAAPI cuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr);
-#endif
-
-#if defined(WIN64) || defined(_WIN64) || defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
-/**
- * \fn CUresult CUDAAPI cuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr, unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
- * map a video frame
- */
-CUresult CUDAAPI cuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr,
-                                             unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
-
-/**
- * \fn CUresult CUDAAPI cuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);
- * Unmap a previously mapped video frame
- */
-CUresult CUDAAPI cuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);
-
-#if defined(__CUVID_DEVPTR64) && !defined(__CUVID_INTERNAL)
-#define cuvidMapVideoFrame      cuvidMapVideoFrame64
-#define cuvidUnmapVideoFrame    cuvidUnmapVideoFrame64
-#endif
-#endif
-
-
-
-/**
- *
- * Context-locking: to facilitate multi-threaded implementations, the following 4 functions
- * provide a simple mutex-style host synchronization. If a non-NULL context is specified
- * in CUVIDDECODECREATEINFO, the codec library will acquire the mutex associated with the given
- * context before making any cuda calls.
- * A multi-threaded application could create a lock associated with a context handle so that
- * multiple threads can safely share the same cuda context:
- *  - use cuCtxPopCurrent immediately after context creation in order to create a 'floating' context
- *    that can be passed to cuvidCtxLockCreate.
- *  - When using a floating context, all cuda calls should only be made within a cuvidCtxLock/cuvidCtxUnlock section.
- *
- * NOTE: This is a safer alternative to cuCtxPushCurrent and cuCtxPopCurrent, and is not related to video
- * decoder in any way (implemented as a critical section associated with cuCtx{Push|Pop}Current calls).
-*/
-
-/**
- * \fn CUresult CUDAAPI cuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx)
- */
-CUresult CUDAAPI cuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx);
-
-/**
- * \fn CUresult CUDAAPI cuvidCtxLockDestroy(CUvideoctxlock lck)
- */
-CUresult CUDAAPI cuvidCtxLockDestroy(CUvideoctxlock lck);
-
-/**
- * \fn CUresult CUDAAPI cuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags)
- */
-CUresult CUDAAPI cuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags);
-
-/**
- * \fn CUresult CUDAAPI cuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags)
- */
-CUresult CUDAAPI cuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags);
-
-/** @} */  /* End VIDEO_DECODER */
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if defined(__cplusplus)
-
-// Auto-lock helper for C++ applications
-class CCtxAutoLock
-{
-private:
-    CUvideoctxlock m_ctx;
-public:
-    CCtxAutoLock(CUvideoctxlock ctx);
-    ~CCtxAutoLock();
-};
-
-}
-
-#endif /* __cplusplus */
-
-#endif // __CUDA_VIDEO_H__
-
diff --git a/mythtv/external/FFmpeg/compat/cuda/dynlink_cuda.h b/mythtv/external/FFmpeg/compat/cuda/dynlink_cuda.h
new file mode 100644
index 00000000000..3a13611ce64
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/cuda/dynlink_cuda.h
@@ -0,0 +1,98 @@
+/*
+ * This copyright notice applies to this header file only:
+ *
+ * Copyright (c) 2016
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the software, and to permit persons to whom the
+ * software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#if !defined(AV_COMPAT_DYNLINK_CUDA_H) && !defined(CUDA_VERSION)
+#define AV_COMPAT_DYNLINK_CUDA_H
+
+#include <stddef.h>
+
+#define CUDA_VERSION 7050
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define CUDAAPI __stdcall
+#else
+#define CUDAAPI
+#endif
+
+#define CU_CTX_SCHED_BLOCKING_SYNC 4
+
+typedef int CUdevice;
+typedef void* CUarray;
+typedef void* CUcontext;
+typedef void* CUstream;
+#if defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
+typedef unsigned long long CUdeviceptr;
+#else
+typedef unsigned int CUdeviceptr;
+#endif
+
+typedef enum cudaError_enum {
+    CUDA_SUCCESS = 0
+} CUresult;
+
+typedef enum CUmemorytype_enum {
+    CU_MEMORYTYPE_HOST = 1,
+    CU_MEMORYTYPE_DEVICE = 2
+} CUmemorytype;
+
+typedef struct CUDA_MEMCPY2D_st {
+    size_t srcXInBytes;
+    size_t srcY;
+    CUmemorytype srcMemoryType;
+    const void *srcHost;
+    CUdeviceptr srcDevice;
+    CUarray srcArray;
+    size_t srcPitch;
+
+    size_t dstXInBytes;
+    size_t dstY;
+    CUmemorytype dstMemoryType;
+    void *dstHost;
+    CUdeviceptr dstDevice;
+    CUarray dstArray;
+    size_t dstPitch;
+
+    size_t WidthInBytes;
+    size_t Height;
+} CUDA_MEMCPY2D;
+
+typedef CUresult CUDAAPI tcuInit(unsigned int Flags);
+typedef CUresult CUDAAPI tcuDeviceGetCount(int *count);
+typedef CUresult CUDAAPI tcuDeviceGet(CUdevice *device, int ordinal);
+typedef CUresult CUDAAPI tcuDeviceGetName(char *name, int len, CUdevice dev);
+typedef CUresult CUDAAPI tcuDeviceComputeCapability(int *major, int *minor, CUdevice dev);
+typedef CUresult CUDAAPI tcuCtxCreate_v2(CUcontext *pctx, unsigned int flags, CUdevice dev);
+typedef CUresult CUDAAPI tcuCtxPushCurrent_v2(CUcontext *pctx);
+typedef CUresult CUDAAPI tcuCtxPopCurrent_v2(CUcontext *pctx);
+typedef CUresult CUDAAPI tcuCtxDestroy_v2(CUcontext ctx);
+typedef CUresult CUDAAPI tcuMemAlloc_v2(CUdeviceptr *dptr, size_t bytesize);
+typedef CUresult CUDAAPI tcuMemFree_v2(CUdeviceptr dptr);
+typedef CUresult CUDAAPI tcuMemcpy2D_v2(const CUDA_MEMCPY2D *pcopy);
+typedef CUresult CUDAAPI tcuGetErrorName(CUresult error, const char** pstr);
+typedef CUresult CUDAAPI tcuGetErrorString(CUresult error, const char** pstr);
+
+#endif
diff --git a/mythtv/external/FFmpeg/compat/cuda/dynlink_cuviddec.h b/mythtv/external/FFmpeg/compat/cuda/dynlink_cuviddec.h
new file mode 100644
index 00000000000..4af78a186ba
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/cuda/dynlink_cuviddec.h
@@ -0,0 +1,886 @@
+/*
+ * This copyright notice applies to this header file only:
+ *
+ * Copyright (c) 2010-2017 NVIDIA Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the software, and to permit persons to whom the
+ * software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*****************************************************************************************************/
+//! \file cuviddec.h
+//! NVDECODE API provides video decoding interface to NVIDIA GPU devices.
+//! \date 2015-2017
+//! This file contains constants, structure definitions and function prototypes used for decoding.
+/*****************************************************************************************************/
+
+#if !defined(__CUDA_VIDEO_H__)
+#define __CUDA_VIDEO_H__
+
+#if defined(_WIN64) || defined(__LP64__) || defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
+#if (CUDA_VERSION >= 3020) && (!defined(CUDA_FORCE_API_VERSION) || (CUDA_FORCE_API_VERSION >= 3020))
+#define __CUVID_DEVPTR64
+#endif
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif /* __cplusplus */
+
+#if defined(__CYGWIN__)
+typedef unsigned int tcu_ulong;
+#else
+typedef unsigned long tcu_ulong;
+#endif
+
+typedef void *CUvideodecoder;
+typedef struct _CUcontextlock_st *CUvideoctxlock;
+
+/*********************************************************************************/
+//! \enum cudaVideoCodec
+//! Video codec enums
+//! These enums are used in CUVIDDECODECREATEINFO and CUVIDDECODECAPS structures
+/*********************************************************************************/
+typedef enum cudaVideoCodec_enum {
+    cudaVideoCodec_MPEG1=0,                                         /**<  MPEG1             */
+    cudaVideoCodec_MPEG2,                                           /**<  MPEG2             */
+    cudaVideoCodec_MPEG4,                                           /**<  MPEG4             */
+    cudaVideoCodec_VC1,                                             /**<  VC1               */
+    cudaVideoCodec_H264,                                            /**<  H264              */
+    cudaVideoCodec_JPEG,                                            /**<  JPEG              */
+    cudaVideoCodec_H264_SVC,                                        /**<  H264-SVC          */
+    cudaVideoCodec_H264_MVC,                                        /**<  H264-MVC          */
+    cudaVideoCodec_HEVC,                                            /**<  HEVC              */
+    cudaVideoCodec_VP8,                                             /**<  VP8               */
+    cudaVideoCodec_VP9,                                             /**<  VP9               */
+    cudaVideoCodec_NumCodecs,                                       /**<  Max codecs        */
+    // Uncompressed YUV
+    cudaVideoCodec_YUV420 = (('I'<<24)|('Y'<<16)|('U'<<8)|('V')),   /**< Y,U,V (4:2:0)      */
+    cudaVideoCodec_YV12   = (('Y'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,V,U (4:2:0)      */
+    cudaVideoCodec_NV12   = (('N'<<24)|('V'<<16)|('1'<<8)|('2')),   /**< Y,UV  (4:2:0)      */
+    cudaVideoCodec_YUYV   = (('Y'<<24)|('U'<<16)|('Y'<<8)|('V')),   /**< YUYV/YUY2 (4:2:2)  */
+    cudaVideoCodec_UYVY   = (('U'<<24)|('Y'<<16)|('V'<<8)|('Y'))    /**< UYVY (4:2:2)       */
+} cudaVideoCodec;
+
+/*********************************************************************************/
+//! \enum cudaVideoSurfaceFormat
+//! Video surface format enums used for output format of decoded output
+//! These enums are used in CUVIDDECODECREATEINFO structure
+/*********************************************************************************/
+typedef enum cudaVideoSurfaceFormat_enum {
+    cudaVideoSurfaceFormat_NV12=0,       /**< NV12 format          */
+    cudaVideoSurfaceFormat_P016=1        /**< 16 bit semiplaner format. Can be used for 10 bit(6LSB bits 0),
+                                              12 bit (4LSB bits 0) */
+} cudaVideoSurfaceFormat;
+
+/******************************************************************************************************************/
+//! \enum cudaVideoDeinterlaceMode
+//! Deinterlacing mode enums
+//! These enums are used in CUVIDDECODECREATEINFO structure
+//! Use cudaVideoDeinterlaceMode_Weave for progressive content and for content that doesn't need deinterlacing
+//! cudaVideoDeinterlaceMode_Adaptive needs more video memory than other DImodes
+/******************************************************************************************************************/
+typedef enum cudaVideoDeinterlaceMode_enum {
+    cudaVideoDeinterlaceMode_Weave=0,   /**< Weave both fields (no deinterlacing) */
+    cudaVideoDeinterlaceMode_Bob,       /**< Drop one field                       */
+    cudaVideoDeinterlaceMode_Adaptive   /**< Adaptive deinterlacing               */
+} cudaVideoDeinterlaceMode;
+
+/**************************************************************************************************************/
+//! \enum cudaVideoChromaFormat
+//! Chroma format enums
+//! These enums are used in CUVIDDECODECREATEINFO and CUVIDDECODECAPS structures
+//! JPEG supports Monochrome, YUV 4:2:0, YUV 4:2:2 and YUV 4:4:4 chroma formats.
+//! H264, HEVC, VP9, VP8, VC1, MPEG1, MPEG2 and MPEG4 support YUV 4:2:0 chroma format only.
+/**************************************************************************************************************/
+typedef enum cudaVideoChromaFormat_enum {
+    cudaVideoChromaFormat_Monochrome=0,  /**< MonoChrome */
+    cudaVideoChromaFormat_420,           /**< YUV 4:2:0  */
+    cudaVideoChromaFormat_422,           /**< YUV 4:2:2  */
+    cudaVideoChromaFormat_444            /**< YUV 4:4:4  */
+} cudaVideoChromaFormat;
+
+/*************************************************************************************************************/
+//! \enum cudaVideoCreateFlags
+//! Decoder flag enums to select preferred decode path
+//! cudaVideoCreate_Default and cudaVideoCreate_PreferCUVID are most optimized, use these whenever possible
+/*************************************************************************************************************/
+typedef enum cudaVideoCreateFlags_enum {
+    cudaVideoCreate_Default     = 0x00,     /**< Default operation mode: use dedicated video engines                        */
+    cudaVideoCreate_PreferCUDA  = 0x01,     /**< Use CUDA-based decoder (requires valid vidLock object for multi-threading) */
+    cudaVideoCreate_PreferDXVA  = 0x02,     /**< Go through DXVA internally if possible (requires D3D9 interop)             */
+    cudaVideoCreate_PreferCUVID = 0x04      /**< Use dedicated video engines directly                                       */
+} cudaVideoCreateFlags;
+
+
+/**************************************************************************************************************/
+//! \struct CUVIDDECODECAPS;
+//! This structure is used in cuvidGetDecoderCaps API
+/**************************************************************************************************************/
+typedef struct _CUVIDDECODECAPS
+{
+    cudaVideoCodec          eCodecType;                 /**< IN: cudaVideoCodec_XXX                                 */
+    cudaVideoChromaFormat   eChromaFormat;              /**< IN: cudaVideoChromaFormat_XXX                          */
+    unsigned int            nBitDepthMinus8;            /**< IN: The Value "BitDepth minus 8"                       */
+    unsigned int            reserved1[3];               /**< Reserved for future use - set to zero                  */
+
+    unsigned char           bIsSupported;               /**< OUT: 1 if codec supported, 0 if not supported          */
+    unsigned char           reserved2[3];               /**< Reserved for future use - set to zero                  */
+    unsigned int            nMaxWidth;                  /**< OUT: Max supported coded width in pixels               */
+    unsigned int            nMaxHeight;                 /**< OUT: Max supported coded height in pixels              */
+    unsigned int            nMaxMBCount;                /**< OUT: Max supported macroblock count
+                                                                  CodedWidth*CodedHeight/256 must be <= nMaxMBCount */
+    unsigned short          nMinWidth;                  /**< OUT: Min supported coded width in pixels               */
+    unsigned short          nMinHeight;                 /**< OUT: Min supported coded height in pixels              */
+    unsigned int            reserved3[11];              /**< Reserved for future use - set to zero                  */
+} CUVIDDECODECAPS;
+
+/**************************************************************************************************************/
+//! \struct CUVIDDECODECREATEINFO
+//! This structure is used in cuvidCreateDecoder API
+/**************************************************************************************************************/
+typedef struct _CUVIDDECODECREATEINFO
+{
+    tcu_ulong ulWidth;                  /**< IN: Coded sequence width in pixels                                             */
+    tcu_ulong ulHeight;                 /**< IN: Coded sequence height in pixels                                            */
+    tcu_ulong ulNumDecodeSurfaces;      /**< IN: Maximum number of internal decode surfaces                                 */
+    cudaVideoCodec CodecType;           /**< IN: cudaVideoCodec_XXX                                                         */
+    cudaVideoChromaFormat ChromaFormat; /**< IN: cudaVideoChromaFormat_XXX                                                  */
+    tcu_ulong ulCreationFlags;          /**< IN: Decoder creation flags (cudaVideoCreateFlags_XXX)                          */
+    tcu_ulong bitDepthMinus8;           /**< IN: The value "BitDepth minus 8"                                               */
+    tcu_ulong ulIntraDecodeOnly;        /**< IN: Set 1 only if video has all intra frames (default value is 0). This will
+                                             optimize video memory for Intra frames only decoding. The support is limited
+                                             to specific codecs(H264 rightnow), the flag will be ignored for codecs which
+                                             are not supported. However decoding might fail if the flag is enabled in case
+                                             of supported codecs for regular bit streams having P and/or B frames.          */
+    tcu_ulong Reserved1[3];             /**< Reserved for future use - set to zero                                          */
+    /**
+    * IN: area of the frame that should be displayed
+    */
+    struct {
+        short left;
+        short top;
+        short right;
+        short bottom;
+    } display_area;
+
+    cudaVideoSurfaceFormat OutputFormat;       /**< IN: cudaVideoSurfaceFormat_XXX                                     */
+    cudaVideoDeinterlaceMode DeinterlaceMode;  /**< IN: cudaVideoDeinterlaceMode_XXX                                   */
+    tcu_ulong ulTargetWidth;                   /**< IN: Post-processed output width (Should be aligned to 2)           */
+    tcu_ulong ulTargetHeight;                  /**< IN: Post-processed output height (Should be aligbed to 2)          */
+    tcu_ulong ulNumOutputSurfaces;             /**< IN: Maximum number of output surfaces simultaneously mapped        */
+    CUvideoctxlock vidLock;                    /**< IN: If non-NULL, context lock used for synchronizing ownership of
+                                                    the cuda context. Needed for cudaVideoCreate_PreferCUDA decode     */
+    /**
+    * IN: target rectangle in the output frame (for aspect ratio conversion)
+    * if a null rectangle is specified, {0,0,ulTargetWidth,ulTargetHeight} will be used
+    */
+    struct {
+        short left;
+        short top;
+        short right;
+        short bottom;
+    } target_rect;
+    tcu_ulong Reserved2[5];                    /**< Reserved for future use - set to zero */
+} CUVIDDECODECREATEINFO;
+
+/*********************************************************/
+//! \struct CUVIDH264DPBENTRY
+//! H.264 DPB entry
+//! This structure is used in CUVIDH264PICPARAMS structure
+/*********************************************************/
+typedef struct _CUVIDH264DPBENTRY
+{
+    int PicIdx;                 /**< picture index of reference frame                                        */
+    int FrameIdx;               /**< frame_num(short-term) or LongTermFrameIdx(long-term)                    */
+    int is_long_term;           /**< 0=short term reference, 1=long term reference                           */
+    int not_existing;           /**< non-existing reference frame (corresponding PicIdx should be set to -1) */
+    int used_for_reference;     /**< 0=unused, 1=top_field, 2=bottom_field, 3=both_fields                    */
+    int FieldOrderCnt[2];       /**< field order count of top and bottom fields                              */
+} CUVIDH264DPBENTRY;
+
+/************************************************************/
+//! \struct CUVIDH264MVCEXT
+//! H.264 MVC picture parameters ext
+//! This structure is used in CUVIDH264PICPARAMS structure
+/************************************************************/
+typedef struct _CUVIDH264MVCEXT
+{
+    int num_views_minus1;                  /**< Max number of coded views minus 1 in video : Range - 0 to 1023              */
+    int view_id;                           /**< view identifier                                                             */
+    unsigned char inter_view_flag;         /**< 1 if used for inter-view prediction, 0 if not                               */
+    unsigned char num_inter_view_refs_l0;  /**< number of inter-view ref pics in RefPicList0                                */
+    unsigned char num_inter_view_refs_l1;  /**< number of inter-view ref pics in RefPicList1                                */
+    unsigned char MVCReserved8Bits;        /**< Reserved bits                                                               */
+    int InterViewRefsL0[16];               /**< view id of the i-th view component for inter-view prediction in RefPicList0 */
+    int InterViewRefsL1[16];               /**< view id of the i-th view component for inter-view prediction in RefPicList1 */
+} CUVIDH264MVCEXT;
+
+/*********************************************************/
+//! \struct CUVIDH264SVCEXT
+//! H.264 SVC picture parameters ext
+//! This structure is used in CUVIDH264PICPARAMS structure
+/*********************************************************/
+typedef struct _CUVIDH264SVCEXT
+{
+    unsigned char profile_idc;
+    unsigned char level_idc;
+    unsigned char DQId;
+    unsigned char DQIdMax;
+    unsigned char disable_inter_layer_deblocking_filter_idc;
+    unsigned char ref_layer_chroma_phase_y_plus1;
+    signed char   inter_layer_slice_alpha_c0_offset_div2;
+    signed char   inter_layer_slice_beta_offset_div2;
+
+    unsigned short DPBEntryValidFlag;
+    unsigned char inter_layer_deblocking_filter_control_present_flag;
+    unsigned char extended_spatial_scalability_idc;
+    unsigned char adaptive_tcoeff_level_prediction_flag;
+    unsigned char slice_header_restriction_flag;
+    unsigned char chroma_phase_x_plus1_flag;
+    unsigned char chroma_phase_y_plus1;
+
+    unsigned char tcoeff_level_prediction_flag;
+    unsigned char constrained_intra_resampling_flag;
+    unsigned char ref_layer_chroma_phase_x_plus1_flag;
+    unsigned char store_ref_base_pic_flag;
+    unsigned char Reserved8BitsA;
+    unsigned char Reserved8BitsB;
+
+    short scaled_ref_layer_left_offset;
+    short scaled_ref_layer_top_offset;
+    short scaled_ref_layer_right_offset;
+    short scaled_ref_layer_bottom_offset;
+    unsigned short Reserved16Bits;
+    struct _CUVIDPICPARAMS *pNextLayer; /**< Points to the picparams for the next layer to be decoded.
+                                             Linked list ends at the target layer. */
+    int bRefBaseLayer;                  /**< whether to store ref base pic */
+} CUVIDH264SVCEXT;
+
+/******************************************************/
+//! \struct CUVIDH264PICPARAMS
+//! H.264 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/******************************************************/
+typedef struct _CUVIDH264PICPARAMS
+{
+    // SPS
+    int log2_max_frame_num_minus4;
+    int pic_order_cnt_type;
+    int log2_max_pic_order_cnt_lsb_minus4;
+    int delta_pic_order_always_zero_flag;
+    int frame_mbs_only_flag;
+    int direct_8x8_inference_flag;
+    int num_ref_frames;             // NOTE: shall meet level 4.1 restrictions
+    unsigned char residual_colour_transform_flag;
+    unsigned char bit_depth_luma_minus8;    // Must be 0 (only 8-bit supported)
+    unsigned char bit_depth_chroma_minus8;  // Must be 0 (only 8-bit supported)
+    unsigned char qpprime_y_zero_transform_bypass_flag;
+    // PPS
+    int entropy_coding_mode_flag;
+    int pic_order_present_flag;
+    int num_ref_idx_l0_active_minus1;
+    int num_ref_idx_l1_active_minus1;
+    int weighted_pred_flag;
+    int weighted_bipred_idc;
+    int pic_init_qp_minus26;
+    int deblocking_filter_control_present_flag;
+    int redundant_pic_cnt_present_flag;
+    int transform_8x8_mode_flag;
+    int MbaffFrameFlag;
+    int constrained_intra_pred_flag;
+    int chroma_qp_index_offset;
+    int second_chroma_qp_index_offset;
+    int ref_pic_flag;
+    int frame_num;
+    int CurrFieldOrderCnt[2];
+    // DPB
+    CUVIDH264DPBENTRY dpb[16];          // List of reference frames within the DPB
+    // Quantization Matrices (raster-order)
+    unsigned char WeightScale4x4[6][16];
+    unsigned char WeightScale8x8[2][64];
+    // FMO/ASO
+    unsigned char fmo_aso_enable;
+    unsigned char num_slice_groups_minus1;
+    unsigned char slice_group_map_type;
+    signed char pic_init_qs_minus26;
+    unsigned int slice_group_change_rate_minus1;
+    union
+    {
+        unsigned long long slice_group_map_addr;
+        const unsigned char *pMb2SliceGroupMap;
+    } fmo;
+    unsigned int Reserved[12];
+    // SVC/MVC
+    union
+    {
+        CUVIDH264MVCEXT mvcext;
+        CUVIDH264SVCEXT svcext;
+    };
+} CUVIDH264PICPARAMS;
+
+
+/********************************************************/
+//! \struct CUVIDMPEG2PICPARAMS
+//! MPEG-2 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/********************************************************/
+typedef struct _CUVIDMPEG2PICPARAMS
+{
+    int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)
+    int BackwardRefIdx;         // Picture index of backward reference (B-frames)
+    int picture_coding_type;
+    int full_pel_forward_vector;
+    int full_pel_backward_vector;
+    int f_code[2][2];
+    int intra_dc_precision;
+    int frame_pred_frame_dct;
+    int concealment_motion_vectors;
+    int q_scale_type;
+    int intra_vlc_format;
+    int alternate_scan;
+    int top_field_first;
+    // Quantization matrices (raster order)
+    unsigned char QuantMatrixIntra[64];
+    unsigned char QuantMatrixInter[64];
+} CUVIDMPEG2PICPARAMS;
+
+// MPEG-4 has VOP types instead of Picture types
+#define I_VOP 0
+#define P_VOP 1
+#define B_VOP 2
+#define S_VOP 3
+
+/*******************************************************/
+//! \struct CUVIDMPEG4PICPARAMS
+//! MPEG-4 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/*******************************************************/
+typedef struct _CUVIDMPEG4PICPARAMS
+{
+    int ForwardRefIdx;          // Picture index of forward reference (P/B-frames)
+    int BackwardRefIdx;         // Picture index of backward reference (B-frames)
+    // VOL
+    int video_object_layer_width;
+    int video_object_layer_height;
+    int vop_time_increment_bitcount;
+    int top_field_first;
+    int resync_marker_disable;
+    int quant_type;
+    int quarter_sample;
+    int short_video_header;
+    int divx_flags;
+    // VOP
+    int vop_coding_type;
+    int vop_coded;
+    int vop_rounding_type;
+    int alternate_vertical_scan_flag;
+    int interlaced;
+    int vop_fcode_forward;
+    int vop_fcode_backward;
+    int trd[2];
+    int trb[2];
+    // Quantization matrices (raster order)
+    unsigned char QuantMatrixIntra[64];
+    unsigned char QuantMatrixInter[64];
+    int gmc_enabled;
+} CUVIDMPEG4PICPARAMS;
+
+/********************************************************/
+//! \struct CUVIDVC1PICPARAMS
+//! VC1 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/********************************************************/
+typedef struct _CUVIDVC1PICPARAMS
+{
+    int ForwardRefIdx;      /**< Picture index of forward reference (P/B-frames) */
+    int BackwardRefIdx;     /**< Picture index of backward reference (B-frames)  */
+    int FrameWidth;         /**< Actual frame width                              */
+    int FrameHeight;        /**< Actual frame height                             */
+    // PICTURE
+    int intra_pic_flag;     /**< Set to 1 for I,BI frames */
+    int ref_pic_flag;       /**< Set to 1 for I,P frames  */
+    int progressive_fcm;    /**< Progressive frame        */
+    // SEQUENCE
+    int profile;
+    int postprocflag;
+    int pulldown;
+    int interlace;
+    int tfcntrflag;
+    int finterpflag;
+    int psf;
+    int multires;
+    int syncmarker;
+    int rangered;
+    int maxbframes;
+    // ENTRYPOINT
+    int panscan_flag;
+    int refdist_flag;
+    int extended_mv;
+    int dquant;
+    int vstransform;
+    int loopfilter;
+    int fastuvmc;
+    int overlap;
+    int quantizer;
+    int extended_dmv;
+    int range_mapy_flag;
+    int range_mapy;
+    int range_mapuv_flag;
+    int range_mapuv;
+    int rangeredfrm;    // range reduction state
+} CUVIDVC1PICPARAMS;
+
+/***********************************************************/
+//! \struct CUVIDJPEGPICPARAMS
+//! JPEG picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/***********************************************************/
+typedef struct _CUVIDJPEGPICPARAMS
+{
+    int Reserved;
+} CUVIDJPEGPICPARAMS;
+
+
+/*******************************************************/
+//! \struct CUVIDHEVCPICPARAMS
+//! HEVC picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/*******************************************************/
+typedef struct _CUVIDHEVCPICPARAMS
+{
+    // sps
+    int pic_width_in_luma_samples;
+    int pic_height_in_luma_samples;
+    unsigned char log2_min_luma_coding_block_size_minus3;
+    unsigned char log2_diff_max_min_luma_coding_block_size;
+    unsigned char log2_min_transform_block_size_minus2;
+    unsigned char log2_diff_max_min_transform_block_size;
+    unsigned char pcm_enabled_flag;
+    unsigned char log2_min_pcm_luma_coding_block_size_minus3;
+    unsigned char log2_diff_max_min_pcm_luma_coding_block_size;
+    unsigned char pcm_sample_bit_depth_luma_minus1;
+
+    unsigned char pcm_sample_bit_depth_chroma_minus1;
+    unsigned char pcm_loop_filter_disabled_flag;
+    unsigned char strong_intra_smoothing_enabled_flag;
+    unsigned char max_transform_hierarchy_depth_intra;
+    unsigned char max_transform_hierarchy_depth_inter;
+    unsigned char amp_enabled_flag;
+    unsigned char separate_colour_plane_flag;
+    unsigned char log2_max_pic_order_cnt_lsb_minus4;
+
+    unsigned char num_short_term_ref_pic_sets;
+    unsigned char long_term_ref_pics_present_flag;
+    unsigned char num_long_term_ref_pics_sps;
+    unsigned char sps_temporal_mvp_enabled_flag;
+    unsigned char sample_adaptive_offset_enabled_flag;
+    unsigned char scaling_list_enable_flag;
+    unsigned char IrapPicFlag;
+    unsigned char IdrPicFlag;
+
+    unsigned char bit_depth_luma_minus8;
+    unsigned char bit_depth_chroma_minus8;
+    unsigned char reserved1[14];
+
+    // pps
+    unsigned char dependent_slice_segments_enabled_flag;
+    unsigned char slice_segment_header_extension_present_flag;
+    unsigned char sign_data_hiding_enabled_flag;
+    unsigned char cu_qp_delta_enabled_flag;
+    unsigned char diff_cu_qp_delta_depth;
+    signed char init_qp_minus26;
+    signed char pps_cb_qp_offset;
+    signed char pps_cr_qp_offset;
+
+    unsigned char constrained_intra_pred_flag;
+    unsigned char weighted_pred_flag;
+    unsigned char weighted_bipred_flag;
+    unsigned char transform_skip_enabled_flag;
+    unsigned char transquant_bypass_enabled_flag;
+    unsigned char entropy_coding_sync_enabled_flag;
+    unsigned char log2_parallel_merge_level_minus2;
+    unsigned char num_extra_slice_header_bits;
+
+    unsigned char loop_filter_across_tiles_enabled_flag;
+    unsigned char loop_filter_across_slices_enabled_flag;
+    unsigned char output_flag_present_flag;
+    unsigned char num_ref_idx_l0_default_active_minus1;
+    unsigned char num_ref_idx_l1_default_active_minus1;
+    unsigned char lists_modification_present_flag;
+    unsigned char cabac_init_present_flag;
+    unsigned char pps_slice_chroma_qp_offsets_present_flag;
+
+    unsigned char deblocking_filter_override_enabled_flag;
+    unsigned char pps_deblocking_filter_disabled_flag;
+    signed char   pps_beta_offset_div2;
+    signed char   pps_tc_offset_div2;
+    unsigned char tiles_enabled_flag;
+    unsigned char uniform_spacing_flag;
+    unsigned char num_tile_columns_minus1;
+    unsigned char num_tile_rows_minus1;
+
+    unsigned short column_width_minus1[21];
+    unsigned short row_height_minus1[21];
+    unsigned int   reserved3[15];
+
+    // RefPicSets
+    int NumBitsForShortTermRPSInSlice;
+    int NumDeltaPocsOfRefRpsIdx;
+    int NumPocTotalCurr;
+    int NumPocStCurrBefore;
+    int NumPocStCurrAfter;
+    int NumPocLtCurr;
+    int CurrPicOrderCntVal;
+    int RefPicIdx[16];                      // [refpic] Indices of valid reference pictures (-1 if unused for reference)
+    int PicOrderCntVal[16];                 // [refpic]
+    unsigned char IsLongTerm[16];           // [refpic] 0=not a long-term reference, 1=long-term reference
+    unsigned char RefPicSetStCurrBefore[8]; // [0..NumPocStCurrBefore-1] -> refpic (0..15)
+    unsigned char RefPicSetStCurrAfter[8];  // [0..NumPocStCurrAfter-1] -> refpic (0..15)
+    unsigned char RefPicSetLtCurr[8];       // [0..NumPocLtCurr-1] -> refpic (0..15)
+    unsigned char RefPicSetInterLayer0[8];
+    unsigned char RefPicSetInterLayer1[8];
+    unsigned int  reserved4[12];
+
+    // scaling lists (diag order)
+    unsigned char ScalingList4x4[6][16];       // [matrixId][i]
+    unsigned char ScalingList8x8[6][64];       // [matrixId][i]
+    unsigned char ScalingList16x16[6][64];     // [matrixId][i]
+    unsigned char ScalingList32x32[2][64];     // [matrixId][i]
+    unsigned char ScalingListDCCoeff16x16[6];  // [matrixId]
+    unsigned char ScalingListDCCoeff32x32[2];  // [matrixId]
+} CUVIDHEVCPICPARAMS;
+
+
+/***********************************************************/
+//! \struct CUVIDVP8PICPARAMS
+//! VP8 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/***********************************************************/
+typedef struct _CUVIDVP8PICPARAMS
+{
+    int width;
+    int height;
+    unsigned int first_partition_size;
+    //Frame Indexes
+    unsigned char LastRefIdx;
+    unsigned char GoldenRefIdx;
+    unsigned char AltRefIdx;
+    union {
+        struct {
+            unsigned char frame_type : 1;    /**< 0 = KEYFRAME, 1 = INTERFRAME  */
+            unsigned char version : 3;
+            unsigned char show_frame : 1;
+            unsigned char update_mb_segmentation_data : 1;    /**< Must be 0 if segmentation is not enabled */
+            unsigned char Reserved2Bits : 2;
+        };
+        unsigned char wFrameTagFlags;
+    };
+    unsigned char Reserved1[4];
+    unsigned int  Reserved2[3];
+} CUVIDVP8PICPARAMS;
+
+/***********************************************************/
+//! \struct CUVIDVP9PICPARAMS
+//! VP9 picture parameters
+//! This structure is used in CUVIDPICPARAMS structure
+/***********************************************************/
+typedef struct _CUVIDVP9PICPARAMS
+{
+    unsigned int width;
+    unsigned int height;
+
+    //Frame Indices
+    unsigned char LastRefIdx;
+    unsigned char GoldenRefIdx;
+    unsigned char AltRefIdx;
+    unsigned char colorSpace;
+
+    unsigned short profile : 3;
+    unsigned short frameContextIdx : 2;
+    unsigned short frameType : 1;
+    unsigned short showFrame : 1;
+    unsigned short errorResilient : 1;
+    unsigned short frameParallelDecoding : 1;
+    unsigned short subSamplingX : 1;
+    unsigned short subSamplingY : 1;
+    unsigned short intraOnly : 1;
+    unsigned short allow_high_precision_mv : 1;
+    unsigned short refreshEntropyProbs : 1;
+    unsigned short reserved2Bits : 2;
+
+    unsigned short reserved16Bits;
+
+    unsigned char  refFrameSignBias[4];
+
+    unsigned char bitDepthMinus8Luma;
+    unsigned char bitDepthMinus8Chroma;
+    unsigned char loopFilterLevel;
+    unsigned char loopFilterSharpness;
+
+    unsigned char modeRefLfEnabled;
+    unsigned char log2_tile_columns;
+    unsigned char log2_tile_rows;
+
+    unsigned char segmentEnabled : 1;
+    unsigned char segmentMapUpdate : 1;
+    unsigned char segmentMapTemporalUpdate : 1;
+    unsigned char segmentFeatureMode : 1;
+    unsigned char reserved4Bits : 4;
+
+
+    unsigned char segmentFeatureEnable[8][4];
+    short         segmentFeatureData[8][4];
+    unsigned char mb_segment_tree_probs[7];
+    unsigned char segment_pred_probs[3];
+    unsigned char reservedSegment16Bits[2];
+
+    int qpYAc;
+    int qpYDc;
+    int qpChDc;
+    int qpChAc;
+
+    unsigned int activeRefIdx[3];
+    unsigned int resetFrameContext;
+    unsigned int mcomp_filter_type;
+    unsigned int mbRefLfDelta[4];
+    unsigned int mbModeLfDelta[2];
+    unsigned int frameTagSize;
+    unsigned int offsetToDctParts;
+    unsigned int reserved128Bits[4];
+
+} CUVIDVP9PICPARAMS;
+
+
+/******************************************************************************************/
+//! \struct CUVIDPICPARAMS
+//! Picture parameters for decoding
+//! This structure is used in cuvidDecodePicture API
+//! IN  for cuvidDecodePicture
+/******************************************************************************************/
+typedef struct _CUVIDPICPARAMS
+{
+    int PicWidthInMbs;                     /**< IN: Coded frame size in macroblocks                           */
+    int FrameHeightInMbs;                  /**< IN: Coded frame height in macroblocks                         */
+    int CurrPicIdx;                        /**< IN: Output index of the current picture                       */
+    int field_pic_flag;                    /**< IN: 0=frame picture, 1=field picture                          */
+    int bottom_field_flag;                 /**< IN: 0=top field, 1=bottom field (ignored if field_pic_flag=0) */
+    int second_field;                      /**< IN: Second field of a complementary field pair                */
+    // Bitstream data
+    unsigned int nBitstreamDataLen;        /**< IN: Number of bytes in bitstream data buffer                  */
+    const unsigned char *pBitstreamData;   /**< IN: Ptr to bitstream data for this picture (slice-layer)      */
+    unsigned int nNumSlices;               /**< IN: Number of slices in this picture                          */
+    const unsigned int *pSliceDataOffsets; /**< IN: nNumSlices entries, contains offset of each slice within
+                                                        the bitstream data buffer                             */
+    int ref_pic_flag;                      /**< IN: This picture is a reference picture                       */
+    int intra_pic_flag;                    /**< IN: This picture is entirely intra coded                      */
+    unsigned int Reserved[30];             /**< Reserved for future use                                       */
+    // IN: Codec-specific data
+    union {
+        CUVIDMPEG2PICPARAMS mpeg2;         /**< Also used for MPEG-1 */
+        CUVIDH264PICPARAMS  h264;
+        CUVIDVC1PICPARAMS   vc1;
+        CUVIDMPEG4PICPARAMS mpeg4;
+        CUVIDJPEGPICPARAMS  jpeg;
+        CUVIDHEVCPICPARAMS  hevc;
+        CUVIDVP8PICPARAMS   vp8;
+        CUVIDVP9PICPARAMS   vp9;
+        unsigned int CodecReserved[1024];
+    } CodecSpecific;
+} CUVIDPICPARAMS;
+
+
+/******************************************************/
+//! \struct CUVIDPROCPARAMS
+//! Picture parameters for postprocessing
+//! This structure is used in cuvidMapVideoFrame API
+/******************************************************/
+typedef struct _CUVIDPROCPARAMS
+{
+    int progressive_frame;              /**< IN: Input is progressive (deinterlace_mode will be ignored)                */
+    int second_field;                   /**< IN: Output the second field (ignored if deinterlace mode is Weave)         */
+    int top_field_first;                /**< IN: Input frame is top field first (1st field is top, 2nd field is bottom) */
+    int unpaired_field;                 /**< IN: Input only contains one field (2nd field is invalid)                   */
+    // The fields below are used for raw YUV input
+    unsigned int reserved_flags;        /**< Reserved for future use (set to zero)                                      */
+    unsigned int reserved_zero;         /**< Reserved (set to zero)                                                     */
+    unsigned long long raw_input_dptr;  /**< IN: Input CUdeviceptr for raw YUV extensions                               */
+    unsigned int raw_input_pitch;       /**< IN: pitch in bytes of raw YUV input (should be aligned appropriately)      */
+    unsigned int raw_input_format;      /**< IN: Input YUV format (cudaVideoCodec_enum)                                 */
+    unsigned long long raw_output_dptr; /**< IN: Output CUdeviceptr for raw YUV extensions                              */
+    unsigned int raw_output_pitch;      /**< IN: pitch in bytes of raw YUV output (should be aligned appropriately)     */
+    unsigned int Reserved1;             /**< Reserved for future use (set to zero)                                      */
+    CUstream output_stream;             /**< IN: stream object used by cuvidMapVideoFrame                               */
+    unsigned int Reserved[46];          /**< Reserved for future use (set to zero)                                      */
+    void *Reserved2[2];                 /**< Reserved for future use (set to zero)                                      */
+} CUVIDPROCPARAMS;
+
+
+/***********************************************************************************************************/
+//! VIDEO_DECODER
+//!
+//! In order to minimize decode latencies, there should be always at least 2 pictures in the decode
+//! queue at any time, in order to make sure that all decode engines are always busy.
+//!
+//! Overall data flow:
+//!  - cuvidGetDecoderCaps(...)
+//!  - cuvidCreateDecoder(...)
+//!  - For each picture:
+//!    + cuvidDecodePicture(N)
+//!    + cuvidMapVideoFrame(N-4)
+//!    + do some processing in cuda
+//!    + cuvidUnmapVideoFrame(N-4)
+//!    + cuvidDecodePicture(N+1)
+//!    + cuvidMapVideoFrame(N-3)
+//!    + ...
+//!  - cuvidDestroyDecoder(...)
+//!
+//! NOTE:
+//! - When the cuda context is created from a D3D device, the D3D device must also be created
+//!   with the D3DCREATE_MULTITHREADED flag.
+//! - There is a limit to how many pictures can be mapped simultaneously (ulNumOutputSurfaces)
+//! - cuvidDecodePicture may block the calling thread if there are too many pictures pending
+//!   in the decode queue
+/***********************************************************************************************************/
+
+
+/**********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidGetDecoderCaps(CUVIDDECODECAPS *pdc)
+//! Queries decode capabilities of NVDEC-HW based on CodecType, ChromaFormat and BitDepthMinus8 parameters.
+//! 1. Application fills IN parameters CodecType, ChromaFormat and BitDepthMinus8 of CUVIDDECODECAPS structure
+//! 2. On calling cuvidGetDecoderCaps, driver fills OUT parameters if the IN parameters are supported
+//!    If IN parameters passed to the driver are not supported by NVDEC-HW, then all OUT params are set to 0.
+//! E.g. on Geforce GTX 960:
+//!   App fills - eCodecType = cudaVideoCodec_H264; eChromaFormat = cudaVideoChromaFormat_420; nBitDepthMinus8 = 0;
+//!   Given IN parameters are supported, hence driver fills: bIsSupported = 1; nMinWidth   = 48; nMinHeight  = 16;
+//!   nMaxWidth = 4096; nMaxHeight = 4096; nMaxMBCount = 65536;
+//! CodedWidth*CodedHeight/256 must be less than or equal to nMaxMBCount
+/**********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidGetDecoderCaps(CUVIDDECODECAPS *pdc);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci)
+//! Create the decoder object based on pdci. A handle to the created decoder is returned
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCreateDecoder(CUvideodecoder *phDecoder, CUVIDDECODECREATEINFO *pdci);
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidDestroyDecoder(CUvideodecoder hDecoder)
+//! Destroy the decoder object.
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidDestroyDecoder(CUvideodecoder hDecoder);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams)
+//! Decode a single picture (field or frame)
+//! Kicks off HW decoding
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidDecodePicture(CUvideodecoder hDecoder, CUVIDPICPARAMS *pPicParams);
+
+
+#if !defined(__CUVID_DEVPTR64) || defined(__CUVID_INTERNAL)
+/************************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx, unsigned int *pDevPtr,
+//!                                         unsigned int  *pPitch, CUVIDPROCPARAMS *pVPP);
+//! Post-process and map video frame corresponding to nPicIdx for use in cuda. Returns cuda device pointer and associated
+//! pitch of the video frame
+/************************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidMapVideoFrame(CUvideodecoder hDecoder, int nPicIdx,
+                                           unsigned int *pDevPtr, unsigned int *pPitch,
+                                           CUVIDPROCPARAMS *pVPP);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr)
+//! Unmap a previously mapped video frame
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidUnmapVideoFrame(CUvideodecoder hDecoder, unsigned int DevPtr);
+#endif
+
+#if defined(_WIN64) || defined(__LP64__) || defined(__x86_64) || defined(AMD64) || defined(_M_AMD64)
+/************************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr,
+//!                                           unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
+//! Post-process and map video frame corresponding to nPicIdx for use in cuda. Returns cuda device pointer and associated
+//! pitch of the video frame
+/************************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidMapVideoFrame64(CUvideodecoder hDecoder, int nPicIdx, unsigned long long *pDevPtr,
+                                             unsigned int *pPitch, CUVIDPROCPARAMS *pVPP);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);
+//! Unmap a previously mapped video frame
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidUnmapVideoFrame64(CUvideodecoder hDecoder, unsigned long long DevPtr);
+
+#if defined(__CUVID_DEVPTR64) && !defined(__CUVID_INTERNAL)
+#define tcuvidMapVideoFrame      tcuvidMapVideoFrame64
+#define tcuvidUnmapVideoFrame    tcuvidUnmapVideoFrame64
+#endif
+#endif
+
+
+
+/********************************************************************************************************************/
+//!
+//! Context-locking: to facilitate multi-threaded implementations, the following 4 functions
+//! provide a simple mutex-style host synchronization. If a non-NULL context is specified
+//! in CUVIDDECODECREATEINFO, the codec library will acquire the mutex associated with the given
+//! context before making any cuda calls.
+//! A multi-threaded application could create a lock associated with a context handle so that
+//! multiple threads can safely share the same cuda context:
+//!  - use cuCtxPopCurrent immediately after context creation in order to create a 'floating' context
+//!    that can be passed to cuvidCtxLockCreate.
+//!  - When using a floating context, all cuda calls should only be made within a cuvidCtxLock/cuvidCtxUnlock section.
+//!
+//! NOTE: This is a safer alternative to cuCtxPushCurrent and cuCtxPopCurrent, and is not related to video
+//! decoder in any way (implemented as a critical section associated with cuCtx{Push|Pop}Current calls).
+/********************************************************************************************************************/
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx)
+//! This API is used to create CtxLock object
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCtxLockCreate(CUvideoctxlock *pLock, CUcontext ctx);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxLockDestroy(CUvideoctxlock lck)
+//! This API is used to free CtxLock object
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCtxLockDestroy(CUvideoctxlock lck);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags)
+//! This API is used to acquire ctxlock
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCtxLock(CUvideoctxlock lck, unsigned int reserved_flags);
+
+/********************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags)
+//! This API is used to release ctxlock
+/********************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCtxUnlock(CUvideoctxlock lck, unsigned int reserved_flags);
+
+/**********************************************************************************************/
+
+#if defined(__cplusplus)
+}
+#endif /* __cplusplus */
+
+#endif // __CUDA_VIDEO_H__
diff --git a/mythtv/external/FFmpeg/compat/cuda/dynlink_loader.h b/mythtv/external/FFmpeg/compat/cuda/dynlink_loader.h
new file mode 100644
index 00000000000..7d2c87449e1
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/cuda/dynlink_loader.h
@@ -0,0 +1,268 @@
+/*
+ * This copyright notice applies to this header file only:
+ *
+ * Copyright (c) 2016
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the software, and to permit persons to whom the
+ * software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef AV_COMPAT_CUDA_DYNLINK_LOADER_H
+#define AV_COMPAT_CUDA_DYNLINK_LOADER_H
+
+#include "compat/cuda/dynlink_cuda.h"
+#include "compat/cuda/dynlink_nvcuvid.h"
+#include "compat/nvenc/nvEncodeAPI.h"
+#include "compat/w32dlfcn.h"
+
+#include "libavutil/log.h"
+#include "libavutil/error.h"
+
+#if defined(_WIN32)
+# define LIB_HANDLE HMODULE
+#else
+# define LIB_HANDLE void*
+#endif
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+# define CUDA_LIBNAME "nvcuda.dll"
+# define NVCUVID_LIBNAME "nvcuvid.dll"
+# if ARCH_X86_64
+#  define NVENC_LIBNAME "nvEncodeAPI64.dll"
+# else
+#  define NVENC_LIBNAME "nvEncodeAPI.dll"
+# endif
+#else
+# define CUDA_LIBNAME "libcuda.so.1"
+# define NVCUVID_LIBNAME "libnvcuvid.so.1"
+# define NVENC_LIBNAME "libnvidia-encode.so.1"
+#endif
+
+#define LOAD_LIBRARY(l, path)                                     \
+    do {                                                          \
+        if (!((l) = dlopen(path, RTLD_LAZY))) {                   \
+            av_log(NULL, AV_LOG_ERROR, "Cannot load %s\n", path); \
+            ret = AVERROR_UNKNOWN;                                \
+            goto error;                                           \
+        }                                                         \
+        av_log(NULL, AV_LOG_TRACE, "Loaded lib: %s\n", path);     \
+    } while (0)
+
+#define LOAD_SYMBOL(fun, tp, symbol)                                \
+    do {                                                            \
+        if (!((f->fun) = (tp*)dlsym(f->lib, symbol))) {             \
+            av_log(NULL, AV_LOG_ERROR, "Cannot load %s\n", symbol); \
+            ret = AVERROR_UNKNOWN;                                  \
+            goto error;                                             \
+        }                                                           \
+        av_log(NULL, AV_LOG_TRACE, "Loaded sym: %s\n", symbol);     \
+    } while (0)
+
+#define LOAD_SYMBOL_OPT(fun, tp, symbol)                                     \
+    do {                                                                     \
+        if (!((f->fun) = (tp*)dlsym(f->lib, symbol))) {                      \
+            av_log(NULL, AV_LOG_DEBUG, "Cannot load optional %s\n", symbol); \
+        } else {                                                             \
+            av_log(NULL, AV_LOG_TRACE, "Loaded sym: %s\n", symbol);          \
+        }                                                                    \
+    } while (0)
+
+#define GENERIC_LOAD_FUNC_PREAMBLE(T, n, N)  \
+    T *f;                                    \
+    int ret;                                 \
+                                             \
+    n##_free_functions(functions);           \
+                                             \
+    f = *functions = av_mallocz(sizeof(*f)); \
+    if (!f)                                  \
+        return AVERROR(ENOMEM);              \
+                                             \
+    LOAD_LIBRARY(f->lib, N);
+
+#define GENERIC_LOAD_FUNC_FINALE(n) \
+    return 0;                       \
+error:                              \
+    n##_free_functions(functions);  \
+    return ret;
+
+#define GENERIC_FREE_FUNC()              \
+    if (!functions)                      \
+        return;                          \
+    if (*functions && (*functions)->lib) \
+        dlclose((*functions)->lib);      \
+    av_freep(functions);
+
+#ifdef AV_COMPAT_DYNLINK_CUDA_H
+typedef struct CudaFunctions {
+    tcuInit *cuInit;
+    tcuDeviceGetCount *cuDeviceGetCount;
+    tcuDeviceGet *cuDeviceGet;
+    tcuDeviceGetName *cuDeviceGetName;
+    tcuDeviceComputeCapability *cuDeviceComputeCapability;
+    tcuCtxCreate_v2 *cuCtxCreate;
+    tcuCtxPushCurrent_v2 *cuCtxPushCurrent;
+    tcuCtxPopCurrent_v2 *cuCtxPopCurrent;
+    tcuCtxDestroy_v2 *cuCtxDestroy;
+    tcuMemAlloc_v2 *cuMemAlloc;
+    tcuMemFree_v2 *cuMemFree;
+    tcuMemcpy2D_v2 *cuMemcpy2D;
+    tcuGetErrorName *cuGetErrorName;
+    tcuGetErrorString *cuGetErrorString;
+
+    LIB_HANDLE lib;
+} CudaFunctions;
+#else
+typedef struct CudaFunctions CudaFunctions;
+#endif
+
+typedef struct CuvidFunctions {
+    tcuvidGetDecoderCaps *cuvidGetDecoderCaps;
+    tcuvidCreateDecoder *cuvidCreateDecoder;
+    tcuvidDestroyDecoder *cuvidDestroyDecoder;
+    tcuvidDecodePicture *cuvidDecodePicture;
+    tcuvidMapVideoFrame *cuvidMapVideoFrame;
+    tcuvidUnmapVideoFrame *cuvidUnmapVideoFrame;
+    tcuvidCtxLockCreate *cuvidCtxLockCreate;
+    tcuvidCtxLockDestroy *cuvidCtxLockDestroy;
+    tcuvidCtxLock *cuvidCtxLock;
+    tcuvidCtxUnlock *cuvidCtxUnlock;
+
+    tcuvidCreateVideoSource *cuvidCreateVideoSource;
+    tcuvidCreateVideoSourceW *cuvidCreateVideoSourceW;
+    tcuvidDestroyVideoSource *cuvidDestroyVideoSource;
+    tcuvidSetVideoSourceState *cuvidSetVideoSourceState;
+    tcuvidGetVideoSourceState *cuvidGetVideoSourceState;
+    tcuvidGetSourceVideoFormat *cuvidGetSourceVideoFormat;
+    tcuvidGetSourceAudioFormat *cuvidGetSourceAudioFormat;
+    tcuvidCreateVideoParser *cuvidCreateVideoParser;
+    tcuvidParseVideoData *cuvidParseVideoData;
+    tcuvidDestroyVideoParser *cuvidDestroyVideoParser;
+
+    LIB_HANDLE lib;
+} CuvidFunctions;
+
+typedef NVENCSTATUS NVENCAPI tNvEncodeAPICreateInstance(NV_ENCODE_API_FUNCTION_LIST *functionList);
+typedef NVENCSTATUS NVENCAPI tNvEncodeAPIGetMaxSupportedVersion(uint32_t* version);
+
+typedef struct NvencFunctions {
+    tNvEncodeAPICreateInstance *NvEncodeAPICreateInstance;
+    tNvEncodeAPIGetMaxSupportedVersion *NvEncodeAPIGetMaxSupportedVersion;
+
+    LIB_HANDLE lib;
+} NvencFunctions;
+
+#ifdef AV_COMPAT_DYNLINK_CUDA_H
+static inline void cuda_free_functions(CudaFunctions **functions)
+{
+    GENERIC_FREE_FUNC();
+}
+#endif
+
+static inline void cuvid_free_functions(CuvidFunctions **functions)
+{
+    GENERIC_FREE_FUNC();
+}
+
+static inline void nvenc_free_functions(NvencFunctions **functions)
+{
+    GENERIC_FREE_FUNC();
+}
+
+#ifdef AV_COMPAT_DYNLINK_CUDA_H
+static inline int cuda_load_functions(CudaFunctions **functions)
+{
+    GENERIC_LOAD_FUNC_PREAMBLE(CudaFunctions, cuda, CUDA_LIBNAME);
+
+    LOAD_SYMBOL(cuInit, tcuInit, "cuInit");
+    LOAD_SYMBOL(cuDeviceGetCount, tcuDeviceGetCount, "cuDeviceGetCount");
+    LOAD_SYMBOL(cuDeviceGet, tcuDeviceGet, "cuDeviceGet");
+    LOAD_SYMBOL(cuDeviceGetName, tcuDeviceGetName, "cuDeviceGetName");
+    LOAD_SYMBOL(cuDeviceComputeCapability, tcuDeviceComputeCapability, "cuDeviceComputeCapability");
+    LOAD_SYMBOL(cuCtxCreate, tcuCtxCreate_v2, "cuCtxCreate_v2");
+    LOAD_SYMBOL(cuCtxPushCurrent, tcuCtxPushCurrent_v2, "cuCtxPushCurrent_v2");
+    LOAD_SYMBOL(cuCtxPopCurrent, tcuCtxPopCurrent_v2, "cuCtxPopCurrent_v2");
+    LOAD_SYMBOL(cuCtxDestroy, tcuCtxDestroy_v2, "cuCtxDestroy_v2");
+    LOAD_SYMBOL(cuMemAlloc, tcuMemAlloc_v2, "cuMemAlloc_v2");
+    LOAD_SYMBOL(cuMemFree, tcuMemFree_v2, "cuMemFree_v2");
+    LOAD_SYMBOL(cuMemcpy2D, tcuMemcpy2D_v2, "cuMemcpy2D_v2");
+    LOAD_SYMBOL(cuGetErrorName, tcuGetErrorName, "cuGetErrorName");
+    LOAD_SYMBOL(cuGetErrorString, tcuGetErrorString, "cuGetErrorString");
+
+    GENERIC_LOAD_FUNC_FINALE(cuda);
+}
+#endif
+
+static inline int cuvid_load_functions(CuvidFunctions **functions)
+{
+    GENERIC_LOAD_FUNC_PREAMBLE(CuvidFunctions, cuvid, NVCUVID_LIBNAME);
+
+    LOAD_SYMBOL_OPT(cuvidGetDecoderCaps, tcuvidGetDecoderCaps, "cuvidGetDecoderCaps");
+    LOAD_SYMBOL(cuvidCreateDecoder, tcuvidCreateDecoder, "cuvidCreateDecoder");
+    LOAD_SYMBOL(cuvidDestroyDecoder, tcuvidDestroyDecoder, "cuvidDestroyDecoder");
+    LOAD_SYMBOL(cuvidDecodePicture, tcuvidDecodePicture, "cuvidDecodePicture");
+#ifdef __CUVID_DEVPTR64
+    LOAD_SYMBOL(cuvidMapVideoFrame, tcuvidMapVideoFrame, "cuvidMapVideoFrame64");
+    LOAD_SYMBOL(cuvidUnmapVideoFrame, tcuvidUnmapVideoFrame, "cuvidUnmapVideoFrame64");
+#else
+    LOAD_SYMBOL(cuvidMapVideoFrame, tcuvidMapVideoFrame, "cuvidMapVideoFrame");
+    LOAD_SYMBOL(cuvidUnmapVideoFrame, tcuvidUnmapVideoFrame, "cuvidUnmapVideoFrame");
+#endif
+    LOAD_SYMBOL(cuvidCtxLockCreate, tcuvidCtxLockCreate, "cuvidCtxLockCreate");
+    LOAD_SYMBOL(cuvidCtxLockDestroy, tcuvidCtxLockDestroy, "cuvidCtxLockDestroy");
+    LOAD_SYMBOL(cuvidCtxLock, tcuvidCtxLock, "cuvidCtxLock");
+    LOAD_SYMBOL(cuvidCtxUnlock, tcuvidCtxUnlock, "cuvidCtxUnlock");
+
+    LOAD_SYMBOL(cuvidCreateVideoSource, tcuvidCreateVideoSource, "cuvidCreateVideoSource");
+    LOAD_SYMBOL(cuvidCreateVideoSourceW, tcuvidCreateVideoSourceW, "cuvidCreateVideoSourceW");
+    LOAD_SYMBOL(cuvidDestroyVideoSource, tcuvidDestroyVideoSource, "cuvidDestroyVideoSource");
+    LOAD_SYMBOL(cuvidSetVideoSourceState, tcuvidSetVideoSourceState, "cuvidSetVideoSourceState");
+    LOAD_SYMBOL(cuvidGetVideoSourceState, tcuvidGetVideoSourceState, "cuvidGetVideoSourceState");
+    LOAD_SYMBOL(cuvidGetSourceVideoFormat, tcuvidGetSourceVideoFormat, "cuvidGetSourceVideoFormat");
+    LOAD_SYMBOL(cuvidGetSourceAudioFormat, tcuvidGetSourceAudioFormat, "cuvidGetSourceAudioFormat");
+    LOAD_SYMBOL(cuvidCreateVideoParser, tcuvidCreateVideoParser, "cuvidCreateVideoParser");
+    LOAD_SYMBOL(cuvidParseVideoData, tcuvidParseVideoData, "cuvidParseVideoData");
+    LOAD_SYMBOL(cuvidDestroyVideoParser, tcuvidDestroyVideoParser, "cuvidDestroyVideoParser");
+
+    GENERIC_LOAD_FUNC_FINALE(cuvid);
+}
+
+static inline int nvenc_load_functions(NvencFunctions **functions)
+{
+    GENERIC_LOAD_FUNC_PREAMBLE(NvencFunctions, nvenc, NVENC_LIBNAME);
+
+    LOAD_SYMBOL(NvEncodeAPICreateInstance, tNvEncodeAPICreateInstance, "NvEncodeAPICreateInstance");
+    LOAD_SYMBOL(NvEncodeAPIGetMaxSupportedVersion, tNvEncodeAPIGetMaxSupportedVersion, "NvEncodeAPIGetMaxSupportedVersion");
+
+    GENERIC_LOAD_FUNC_FINALE(nvenc);
+}
+
+#undef GENERIC_LOAD_FUNC_PREAMBLE
+#undef LOAD_LIBRARY
+#undef LOAD_SYMBOL
+#undef GENERIC_LOAD_FUNC_FINALE
+#undef GENERIC_FREE_FUNC
+#undef CUDA_LIBNAME
+#undef NVCUVID_LIBNAME
+#undef NVENC_LIBNAME
+#undef LIB_HANDLE
+
+#endif
+
diff --git a/mythtv/external/FFmpeg/compat/cuda/dynlink_nvcuvid.h b/mythtv/external/FFmpeg/compat/cuda/dynlink_nvcuvid.h
new file mode 100644
index 00000000000..87294248e5a
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/cuda/dynlink_nvcuvid.h
@@ -0,0 +1,356 @@
+/*
+ * This copyright notice applies to this header file only:
+ *
+ * Copyright (c) 2010-2017 NVIDIA Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the software, and to permit persons to whom the
+ * software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/********************************************************************************************************************/
+//! \file nvcuvid.h
+//!   NVDECODE API provides video decoding interface to NVIDIA GPU devices.
+//! \date 2015-2017
+//!  This file contains the interface constants, structure definitions and function prototypes.
+/********************************************************************************************************************/
+
+#if !defined(__NVCUVID_H__)
+#define __NVCUVID_H__
+
+#include "compat/cuda/dynlink_cuviddec.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif /* __cplusplus */
+
+/*********************************
+** Initialization
+*********************************/
+CUresult  CUDAAPI cuvidInit(unsigned int Flags);
+
+/***********************************************/
+//!
+//! High-level helper APIs for video sources
+//!
+/***********************************************/
+
+typedef void *CUvideosource;
+typedef void *CUvideoparser;
+typedef long long CUvideotimestamp;
+
+
+/************************************************************************/
+//! \enum cudaVideoState
+//! Video source state enums
+//! Used in cuvidSetVideoSourceState and cuvidGetVideoSourceState APIs
+/************************************************************************/
+typedef enum {
+    cudaVideoState_Error   = -1,    /**< Error state (invalid source)                  */
+    cudaVideoState_Stopped = 0,     /**< Source is stopped (or reached end-of-stream)  */
+    cudaVideoState_Started = 1      /**< Source is running and delivering data         */
+} cudaVideoState;
+
+/************************************************************************/
+//! \enum cudaAudioCodec
+//! Audio compression enums
+//! Used in CUAUDIOFORMAT structure
+/************************************************************************/
+typedef enum {
+    cudaAudioCodec_MPEG1=0,         /**< MPEG-1 Audio               */
+    cudaAudioCodec_MPEG2,           /**< MPEG-2 Audio               */
+    cudaAudioCodec_MP3,             /**< MPEG-1 Layer III Audio     */
+    cudaAudioCodec_AC3,             /**< Dolby Digital (AC3) Audio  */
+    cudaAudioCodec_LPCM,            /**< PCM Audio                  */
+    cudaAudioCodec_AAC,             /**< AAC Audio                  */
+} cudaAudioCodec;
+
+/************************************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDEOFORMAT
+//! Video format
+//! Used in cuvidGetSourceVideoFormat API
+/************************************************************************************************/
+typedef struct
+{
+    cudaVideoCodec codec;                   /**< OUT: Compression format          */
+   /**
+    * OUT: frame rate = numerator / denominator (for example: 30000/1001)
+    */
+    struct {
+        /**< OUT: frame rate numerator   (0 = unspecified or variable frame rate) */
+        unsigned int numerator;
+        /**< OUT: frame rate denominator (0 = unspecified or variable frame rate) */
+        unsigned int denominator;
+    } frame_rate;
+    unsigned char progressive_sequence;     /**< OUT: 0=interlaced, 1=progressive                                      */
+    unsigned char bit_depth_luma_minus8;    /**< OUT: high bit depth luma. E.g, 2 for 10-bitdepth, 4 for 12-bitdepth   */
+    unsigned char bit_depth_chroma_minus8;  /**< OUT: high bit depth chroma. E.g, 2 for 10-bitdepth, 4 for 12-bitdepth */
+    unsigned char reserved1;                /**< Reserved for future use                                               */
+    unsigned int coded_width;               /**< OUT: coded frame width in pixels                                      */
+    unsigned int coded_height;              /**< OUT: coded frame height in pixels                                     */
+   /**
+    * area of the frame that should be displayed
+    * typical example:
+    * coded_width = 1920, coded_height = 1088
+    * display_area = { 0,0,1920,1080 }
+    */
+    struct {
+        int left;                           /**< OUT: left position of display rect    */
+        int top;                            /**< OUT: top position of display rect     */
+        int right;                          /**< OUT: right position of display rect   */
+        int bottom;                         /**< OUT: bottom position of display rect  */
+    } display_area;
+    cudaVideoChromaFormat chroma_format;    /**< OUT:  Chroma format                   */
+    unsigned int bitrate;                   /**< OUT: video bitrate (bps, 0=unknown)   */
+   /**
+    * OUT: Display Aspect Ratio = x:y (4:3, 16:9, etc)
+    */
+    struct {
+        int x;
+        int y;
+    } display_aspect_ratio;
+    /**
+    * Video Signal Description
+    * Refer section E.2.1 (VUI parameters semantics) of H264 spec file
+    */
+    struct {
+        unsigned char video_format          : 3; /**< OUT: 0-Component, 1-PAL, 2-NTSC, 3-SECAM, 4-MAC, 5-Unspecified     */
+        unsigned char video_full_range_flag : 1; /**< OUT: indicates the black level and luma and chroma range           */
+        unsigned char reserved_zero_bits    : 4; /**< Reserved bits                                                      */
+        unsigned char color_primaries;           /**< OUT: chromaticity coordinates of source primaries                  */
+        unsigned char transfer_characteristics;  /**< OUT: opto-electronic transfer characteristic of the source picture */
+        unsigned char matrix_coefficients;       /**< OUT: used in deriving luma and chroma signals from RGB primaries   */
+    } video_signal_description;
+    unsigned int seqhdr_data_length;             /**< OUT: Additional bytes following (CUVIDEOFORMATEX)                  */
+} CUVIDEOFORMAT;
+
+/****************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDEOFORMATEX
+//! Video format including raw sequence header information
+//! Used in cuvidGetSourceVideoFormat API
+/****************************************************************/
+typedef struct
+{
+    CUVIDEOFORMAT format;                 /**< OUT: CUVIDEOFORMAT structure */
+    unsigned char raw_seqhdr_data[1024];  /**< OUT: Sequence header data    */
+} CUVIDEOFORMATEX;
+
+/****************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUAUDIOFORMAT
+//! Audio formats
+//! Used in cuvidGetSourceAudioFormat API
+/****************************************************************/
+typedef struct
+{
+    cudaAudioCodec codec;       /**< OUT: Compression format                                              */
+    unsigned int channels;      /**< OUT: number of audio channels                                        */
+    unsigned int samplespersec; /**< OUT: sampling frequency                                              */
+    unsigned int bitrate;       /**< OUT: For uncompressed, can also be used to determine bits per sample */
+    unsigned int reserved1;     /**< Reserved for future use                                              */
+    unsigned int reserved2;     /**< Reserved for future use                                              */
+} CUAUDIOFORMAT;
+
+
+/***************************************************************/
+//! \enum CUvideopacketflags
+//! Data packet flags
+//! Used in CUVIDSOURCEDATAPACKET structure
+/***************************************************************/
+typedef enum {
+    CUVID_PKT_ENDOFSTREAM   = 0x01,   /**< Set when this is the last packet for this stream  */
+    CUVID_PKT_TIMESTAMP     = 0x02,   /**< Timestamp is valid                                */
+    CUVID_PKT_DISCONTINUITY = 0x04,   /**< Set when a discontinuity has to be signalled      */
+    CUVID_PKT_ENDOFPICTURE  = 0x08,   /**< Set when the packet contains exactly one frame    */
+} CUvideopacketflags;
+
+/*****************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDSOURCEDATAPACKET
+//! Data Packet
+//! Used in cuvidParseVideoData API
+//! IN for cuvidParseVideoData
+/*****************************************************************************/
+typedef struct _CUVIDSOURCEDATAPACKET
+{
+    tcu_ulong flags;                /**< IN: Combination of CUVID_PKT_XXX flags                              */
+    tcu_ulong payload_size;         /**< IN: number of bytes in the payload (may be zero if EOS flag is set) */
+    const unsigned char *payload;   /**< IN: Pointer to packet payload data (may be NULL if EOS flag is set) */
+    CUvideotimestamp timestamp;     /**< IN: Presentation time stamp (10MHz clock), only valid if
+                                             CUVID_PKT_TIMESTAMP flag is set                                 */
+} CUVIDSOURCEDATAPACKET;
+
+// Callback for packet delivery
+typedef int (CUDAAPI *PFNVIDSOURCECALLBACK)(void *, CUVIDSOURCEDATAPACKET *);
+
+/**************************************************************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDSOURCEPARAMS
+//! Describes parameters needed in cuvidCreateVideoSource API
+//! NVDECODE API is intended for HW accelerated video decoding so CUvideosource doesn't have audio demuxer for all supported
+//! containers. It's recommended to clients to use their own or third party demuxer if audio support is needed.
+/**************************************************************************************************************************/
+typedef struct _CUVIDSOURCEPARAMS
+{
+    unsigned int ulClockRate;                   /**< IN: Time stamp units in Hz (0=default=10000000Hz)      */
+    unsigned int uReserved1[7];                 /**< Reserved for future use - set to zero                  */
+    void *pUserData;                            /**< IN: User private data passed in to the data handlers   */
+    PFNVIDSOURCECALLBACK pfnVideoDataHandler;   /**< IN: Called to deliver video packets                    */
+    PFNVIDSOURCECALLBACK pfnAudioDataHandler;   /**< IN: Called to deliver audio packets.                   */
+    void *pvReserved2[8];                       /**< Reserved for future use - set to NULL                  */
+} CUVIDSOURCEPARAMS;
+
+
+/**********************************************/
+//! \ingroup ENUMS
+//! \enum CUvideosourceformat_flags
+//! CUvideosourceformat_flags
+//! Used in cuvidGetSourceVideoFormat API
+/**********************************************/
+typedef enum {
+    CUVID_FMT_EXTFORMATINFO = 0x100             /**< Return extended format structure (CUVIDEOFORMATEX) */
+} CUvideosourceformat_flags;
+
+#if !defined(__APPLE__)
+/**************************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams)
+//! Create CUvideosource object. CUvideosource spawns demultiplexer thread that provides two callbacks:
+//! pfnVideoDataHandler() and pfnAudioDataHandler()
+//! NVDECODE API is intended for HW accelerated video decoding so CUvideosource doesn't have audio demuxer for all supported
+//! containers. It's recommended to clients to use their own or third party demuxer if audio support is needed.
+/**************************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams);
+
+/****************************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams)
+//! Create video source object and initialize
+/****************************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams);
+
+/*********************************************************************/
+//! \fn CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj)
+//! Destroy video source
+/*********************************************************************/
+typedef CUresult CUDAAPI tcuvidDestroyVideoSource(CUvideosource obj);
+
+/******************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state)
+//! Set video source state
+/******************************************************************************************/
+typedef CUresult CUDAAPI tcuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state);
+
+/******************************************************************************************/
+//! \fn cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj)
+//! Get video source state
+/******************************************************************************************/
+typedef cudaVideoState CUDAAPI tcuvidGetVideoSourceState(CUvideosource obj);
+
+/****************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags)
+//! Gets details of video stream in pvidfmt
+/****************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags);
+
+/****************************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags)
+//! Get audio source format
+//! NVDECODE API is intended for HW accelarated video decoding so CUvideosource doesn't have audio demuxer for all suppported
+//! containers. It's recommended to clients to use their own or third party demuxer if audio support is needed.
+/****************************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags);
+
+#endif
+/**********************************************************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDPARSERDISPINFO
+//! Used in cuvidParseVideoData API with PFNVIDDISPLAYCALLBACK pfnDisplayPicture
+/**********************************************************************************/
+typedef struct _CUVIDPARSERDISPINFO
+{
+    int picture_index;          /**< OUT: Index of the current picture                                                         */
+    int progressive_frame;      /**< OUT: 1 if progressive frame; 0 otherwise                                                  */
+    int top_field_first;        /**< OUT: 1 if top field is displayed first; 0 otherwise                                       */
+    int repeat_first_field;     /**< OUT: Number of additional fields (1=ivtc, 2=frame doubling, 4=frame tripling,
+                                     -1=unpaired field)                                                                        */
+    CUvideotimestamp timestamp; /**< OUT: Presentation time stamp                                                              */
+} CUVIDPARSERDISPINFO;
+
+/***********************************************************************************************************************/
+//! Parser callbacks
+//! The parser will call these synchronously from within cuvidParseVideoData(), whenever a picture is ready to
+//! be decoded and/or displayed. First argument in functions is "void *pUserData" member of structure CUVIDSOURCEPARAMS
+/***********************************************************************************************************************/
+typedef int (CUDAAPI *PFNVIDSEQUENCECALLBACK)(void *, CUVIDEOFORMAT *);
+typedef int (CUDAAPI *PFNVIDDECODECALLBACK)(void *, CUVIDPICPARAMS *);
+typedef int (CUDAAPI *PFNVIDDISPLAYCALLBACK)(void *, CUVIDPARSERDISPINFO *);
+
+/**************************************/
+//! \ingroup STRUCTS
+//! \struct CUVIDPARSERPARAMS
+//! Used in cuvidCreateVideoParser API
+/**************************************/
+typedef struct _CUVIDPARSERPARAMS
+{
+    cudaVideoCodec CodecType;                   /**< IN: cudaVideoCodec_XXX                                                  */
+    unsigned int ulMaxNumDecodeSurfaces;        /**< IN: Max # of decode surfaces (parser will cycle through these)          */
+    unsigned int ulClockRate;                   /**< IN: Timestamp units in Hz (0=default=10000000Hz)                        */
+    unsigned int ulErrorThreshold;              /**< IN: % Error threshold (0-100) for calling pfnDecodePicture (100=always
+                                                     IN: call pfnDecodePicture even if picture bitstream is fully corrupted) */
+    unsigned int ulMaxDisplayDelay;             /**< IN: Max display queue delay (improves pipelining of decode with display)
+                                                         0=no delay (recommended values: 2..4)                               */
+    unsigned int uReserved1[5];                 /**< IN: Reserved for future use - set to 0                                  */
+    void *pUserData;                            /**< IN: User data for callbacks                                             */
+    PFNVIDSEQUENCECALLBACK pfnSequenceCallback; /**< IN: Called before decoding frames and/or whenever there is a fmt change */
+    PFNVIDDECODECALLBACK pfnDecodePicture;      /**< IN: Called when a picture is ready to be decoded (decode order)         */
+    PFNVIDDISPLAYCALLBACK pfnDisplayPicture;    /**< IN: Called whenever a picture is ready to be displayed (display order)  */
+    void *pvReserved2[7];                       /**< Reserved for future use - set to NULL                                   */
+    CUVIDEOFORMATEX *pExtVideoInfo;             /**< IN: [Optional] sequence header data from system layer                   */
+} CUVIDPARSERPARAMS;
+
+/************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams)
+//! Create video parser object and initialize
+/************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams);
+
+/************************************************************************************************/
+//! \fn CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket)
+//! Parse the video data from source data packet in pPacket
+//! Extracts parameter sets like SPS, PPS, bitstream etc. from pPacket and
+//! calls back pfnDecodePicture with CUVIDPICPARAMS data for kicking of HW decoding
+/************************************************************************************************/
+typedef CUresult CUDAAPI tcuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket);
+
+/*******************************************************************/
+//! \fn CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj)
+/*******************************************************************/
+typedef CUresult CUDAAPI tcuvidDestroyVideoParser(CUvideoparser obj);
+
+/**********************************************************************************************/
+
+#if defined(__cplusplus)
+}
+#endif /* __cplusplus */
+
+#endif // __NVCUVID_H__
+
+
diff --git a/mythtv/external/FFmpeg/compat/cuda/nvcuvid.h b/mythtv/external/FFmpeg/compat/cuda/nvcuvid.h
deleted file mode 100644
index 738d8e38d5b..00000000000
--- a/mythtv/external/FFmpeg/compat/cuda/nvcuvid.h
+++ /dev/null
@@ -1,321 +0,0 @@
-/*
- * This copyright notice applies to this header file only:
- *
- * Copyright (c) 2010-2016 NVIDIA Corporation
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the software, and to permit persons to whom the
- * software is furnished to do so, subject to the following
- * conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/**
- * \file nvcuvid.h
- *   NvCuvid API provides Video Decoding interface to NVIDIA GPU devices.
- * \date 2015-2015
- *  This file contains the interface constants, structure definitions and function prototypes.
- */
-
-#if !defined(__NVCUVID_H__)
-#define __NVCUVID_H__
-
-#include "compat/cuda/cuviddec.h"
-
-#if defined(__cplusplus)
-extern "C" {
-#endif /* __cplusplus */
-
-/*********************************
-** Initialization
-*********************************/
-CUresult  CUDAAPI cuvidInit(unsigned int Flags);
-
-////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// High-level helper APIs for video sources
-//
-
-typedef void *CUvideosource;
-typedef void *CUvideoparser;
-typedef long long CUvideotimestamp;
-
-/**
- * \addtogroup VIDEO_PARSER Video Parser
- * @{
- */
-
-/*!
- * \enum cudaVideoState
- * Video Source State
- */
-typedef enum {
-    cudaVideoState_Error   = -1,    /**< Error state (invalid source)  */
-    cudaVideoState_Stopped = 0,     /**< Source is stopped (or reached end-of-stream)  */
-    cudaVideoState_Started = 1      /**< Source is running and delivering data  */
-} cudaVideoState;
-
-/*!
- * \enum cudaAudioCodec
- * Audio compression
- */
-typedef enum {
-    cudaAudioCodec_MPEG1=0,         /**< MPEG-1 Audio  */
-    cudaAudioCodec_MPEG2,           /**< MPEG-2 Audio  */
-    cudaAudioCodec_MP3,             /**< MPEG-1 Layer III Audio  */
-    cudaAudioCodec_AC3,             /**< Dolby Digital (AC3) Audio  */
-    cudaAudioCodec_LPCM             /**< PCM Audio  */
-} cudaAudioCodec;
-
-/*!
- * \struct CUVIDEOFORMAT
- * Video format
- */
-typedef struct
-{
-    cudaVideoCodec codec;                   /**< Compression format  */
-   /**
-    * frame rate = numerator / denominator (for example: 30000/1001)
-    */
-    struct {
-        unsigned int numerator;             /**< frame rate numerator   (0 = unspecified or variable frame rate) */
-        unsigned int denominator;           /**< frame rate denominator (0 = unspecified or variable frame rate) */
-    } frame_rate;
-    unsigned char progressive_sequence;     /**< 0=interlaced, 1=progressive */
-    unsigned char bit_depth_luma_minus8;    /**< high bit depth Luma */
-    unsigned char bit_depth_chroma_minus8;  /**< high bit depth Chroma */
-    unsigned char reserved1;                /**< Reserved for future use */
-    unsigned int coded_width;               /**< coded frame width */
-    unsigned int coded_height;              /**< coded frame height  */
-   /**
-    *   area of the frame that should be displayed
-    * typical example:
-    *   coded_width = 1920, coded_height = 1088
-    *   display_area = { 0,0,1920,1080 }
-    */
-    struct {
-        int left;                           /**< left position of display rect  */
-        int top;                            /**< top position of display rect  */
-        int right;                          /**< right position of display rect  */
-        int bottom;                         /**< bottom position of display rect  */
-    } display_area;
-    cudaVideoChromaFormat chroma_format;    /**<  Chroma format */
-    unsigned int bitrate;                   /**< video bitrate (bps, 0=unknown) */
-   /**
-    * Display Aspect Ratio = x:y (4:3, 16:9, etc)
-    */
-    struct {
-        int x;
-        int y;
-    } display_aspect_ratio;
-    /**
-    * Video Signal Description
-    */
-    struct {
-        unsigned char video_format          : 3;
-        unsigned char video_full_range_flag : 1;
-        unsigned char reserved_zero_bits    : 4;
-        unsigned char color_primaries;
-        unsigned char transfer_characteristics;
-        unsigned char matrix_coefficients;
-    } video_signal_description;
-    unsigned int seqhdr_data_length;          /**< Additional bytes following (CUVIDEOFORMATEX)  */
-} CUVIDEOFORMAT;
-
-/*!
- * \struct CUVIDEOFORMATEX
- * Video format including raw sequence header information
- */
-typedef struct
-{
-    CUVIDEOFORMAT format;
-    unsigned char raw_seqhdr_data[1024];
-} CUVIDEOFORMATEX;
-
-/*!
- * \struct CUAUDIOFORMAT
- * Audio Formats
- */
-typedef struct
-{
-    cudaAudioCodec codec;       /**< Compression format  */
-    unsigned int channels;      /**< number of audio channels */
-    unsigned int samplespersec; /**< sampling frequency */
-    unsigned int bitrate;       /**< For uncompressed, can also be used to determine bits per sample */
-    unsigned int reserved1;     /**< Reserved for future use */
-    unsigned int reserved2;     /**< Reserved for future use */
-} CUAUDIOFORMAT;
-
-
-/*!
- * \enum CUvideopacketflags
- * Data packet flags
- */
-typedef enum {
-    CUVID_PKT_ENDOFSTREAM   = 0x01,   /**< Set when this is the last packet for this stream  */
-    CUVID_PKT_TIMESTAMP     = 0x02,   /**< Timestamp is valid  */
-    CUVID_PKT_DISCONTINUITY = 0x04    /**< Set when a discontinuity has to be signalled  */
-} CUvideopacketflags;
-
-/*!
- * \struct CUVIDSOURCEDATAPACKET
- * Data Packet
- */
-typedef struct _CUVIDSOURCEDATAPACKET
-{
-    unsigned long flags;            /**< Combination of CUVID_PKT_XXX flags */
-    unsigned long payload_size;     /**< number of bytes in the payload (may be zero if EOS flag is set) */
-    const unsigned char *payload;   /**< Pointer to packet payload data (may be NULL if EOS flag is set) */
-    CUvideotimestamp timestamp;     /**< Presentation timestamp (10MHz clock), only valid if CUVID_PKT_TIMESTAMP flag is set */
-} CUVIDSOURCEDATAPACKET;
-
-// Callback for packet delivery
-typedef int (CUDAAPI *PFNVIDSOURCECALLBACK)(void *, CUVIDSOURCEDATAPACKET *);
-
-/*!
- * \struct CUVIDSOURCEPARAMS
- * Source Params
- */
-typedef struct _CUVIDSOURCEPARAMS
-{
-    unsigned int ulClockRate;                   /**< Timestamp units in Hz (0=default=10000000Hz)  */
-    unsigned int uReserved1[7];                 /**< Reserved for future use - set to zero  */
-    void *pUserData;                            /**< Parameter passed in to the data handlers  */
-    PFNVIDSOURCECALLBACK pfnVideoDataHandler;   /**< Called to deliver audio packets  */
-    PFNVIDSOURCECALLBACK pfnAudioDataHandler;   /**< Called to deliver video packets  */
-    void *pvReserved2[8];                       /**< Reserved for future use - set to NULL */
-} CUVIDSOURCEPARAMS;
-
-/*!
- * \enum CUvideosourceformat_flags
- * CUvideosourceformat_flags
- */
-typedef enum {
-    CUVID_FMT_EXTFORMATINFO = 0x100             /**< Return extended format structure (CUVIDEOFORMATEX) */
-} CUvideosourceformat_flags;
-
-#if !defined(__APPLE__)
-/**
- * \fn CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams)
- * Create Video Source
- */
-CUresult CUDAAPI cuvidCreateVideoSource(CUvideosource *pObj, const char *pszFileName, CUVIDSOURCEPARAMS *pParams);
-
-/**
- * \fn CUresult CUDAAPI cuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams)
- * Create Video Source
- */
-CUresult CUDAAPI cuvidCreateVideoSourceW(CUvideosource *pObj, const wchar_t *pwszFileName, CUVIDSOURCEPARAMS *pParams);
-
-/**
- * \fn CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj)
- * Destroy Video Source
- */
-CUresult CUDAAPI cuvidDestroyVideoSource(CUvideosource obj);
-
-/**
- * \fn CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state)
- * Set Video Source state
- */
-CUresult CUDAAPI cuvidSetVideoSourceState(CUvideosource obj, cudaVideoState state);
-
-/**
- * \fn cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj)
- * Get Video Source state
- */
-cudaVideoState CUDAAPI cuvidGetVideoSourceState(CUvideosource obj);
-
-/**
- * \fn CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags)
- * Get Video Source Format
- */
-CUresult CUDAAPI cuvidGetSourceVideoFormat(CUvideosource obj, CUVIDEOFORMAT *pvidfmt, unsigned int flags);
-
-/**
- * \fn CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags)
- * Set Video Source state
- */
-CUresult CUDAAPI cuvidGetSourceAudioFormat(CUvideosource obj, CUAUDIOFORMAT *paudfmt, unsigned int flags);
-
-#endif
-
-/**
- * \struct CUVIDPARSERDISPINFO
- */
-typedef struct _CUVIDPARSERDISPINFO
-{
-    int picture_index;         /**<                 */
-    int progressive_frame;     /**<                 */
-    int top_field_first;       /**<                 */
-    int repeat_first_field;    /**< Number of additional fields (1=ivtc, 2=frame doubling, 4=frame tripling, -1=unpaired field)  */
-    CUvideotimestamp timestamp; /**<     */
-} CUVIDPARSERDISPINFO;
-
-//
-// Parser callbacks
-// The parser will call these synchronously from within cuvidParseVideoData(), whenever a picture is ready to
-// be decoded and/or displayed.
-//
-typedef int (CUDAAPI *PFNVIDSEQUENCECALLBACK)(void *, CUVIDEOFORMAT *);
-typedef int (CUDAAPI *PFNVIDDECODECALLBACK)(void *, CUVIDPICPARAMS *);
-typedef int (CUDAAPI *PFNVIDDISPLAYCALLBACK)(void *, CUVIDPARSERDISPINFO *);
-
-/**
- * \struct CUVIDPARSERPARAMS
- */
-typedef struct _CUVIDPARSERPARAMS
-{
-    cudaVideoCodec CodecType;               /**< cudaVideoCodec_XXX  */
-    unsigned int ulMaxNumDecodeSurfaces;    /**< Max # of decode surfaces (parser will cycle through these) */
-    unsigned int ulClockRate;               /**< Timestamp units in Hz (0=default=10000000Hz) */
-    unsigned int ulErrorThreshold;          /**< % Error threshold (0-100) for calling pfnDecodePicture (100=always call pfnDecodePicture even if picture bitstream is fully corrupted) */
-    unsigned int ulMaxDisplayDelay;         /**< Max display queue delay (improves pipelining of decode with display) - 0=no delay (recommended values: 2..4) */
-    unsigned int uReserved1[5];             /**< Reserved for future use - set to 0 */
-    void *pUserData;                        /**< User data for callbacks */
-    PFNVIDSEQUENCECALLBACK pfnSequenceCallback; /**< Called before decoding frames and/or whenever there is a format change */
-    PFNVIDDECODECALLBACK pfnDecodePicture;      /**< Called when a picture is ready to be decoded (decode order) */
-    PFNVIDDISPLAYCALLBACK pfnDisplayPicture;    /**< Called whenever a picture is ready to be displayed (display order)  */
-    void *pvReserved2[7];                       /**< Reserved for future use - set to NULL */
-    CUVIDEOFORMATEX *pExtVideoInfo;             /**< [Optional] sequence header data from system layer */
-} CUVIDPARSERPARAMS;
-
-/**
- * \fn CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams)
- */
-CUresult CUDAAPI cuvidCreateVideoParser(CUvideoparser *pObj, CUVIDPARSERPARAMS *pParams);
-
-/**
- * \fn CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket)
- */
-CUresult CUDAAPI cuvidParseVideoData(CUvideoparser obj, CUVIDSOURCEDATAPACKET *pPacket);
-
-/**
- * \fn CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj)
- */
-CUresult CUDAAPI cuvidDestroyVideoParser(CUvideoparser obj);
-
-/** @} */  /* END VIDEO_PARSER */
-////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if defined(__cplusplus)
-}
-#endif /* __cplusplus */
-
-#endif // __NVCUVID_H__
-
-
diff --git a/mythtv/external/FFmpeg/compat/cuda/ptx2c.sh b/mythtv/external/FFmpeg/compat/cuda/ptx2c.sh
new file mode 100755
index 00000000000..5ccabbf56f1
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/cuda/ptx2c.sh
@@ -0,0 +1,36 @@
+#!/bin/sh
+
+# Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+set -e
+
+OUT="$1"
+IN="$2"
+NAME="$(basename "$IN" | sed 's/\..*//')"
+
+printf "const char %s_ptx[] = \\" "$NAME" > "$OUT"
+while read LINE
+do
+    printf "\n\t\"%s\\\n\"" "$(printf "%s" "$LINE" | sed -e 's/\r//g' -e 's/["\\]/\\&/g')" >> "$OUT"
+done < "$IN"
+printf ";\n" >> "$OUT"
+
+exit 0
diff --git a/mythtv/external/FFmpeg/compat/nvenc/nvEncodeAPI.h b/mythtv/external/FFmpeg/compat/nvenc/nvEncodeAPI.h
index 18cf522d17f..c3a82942128 100644
--- a/mythtv/external/FFmpeg/compat/nvenc/nvEncodeAPI.h
+++ b/mythtv/external/FFmpeg/compat/nvenc/nvEncodeAPI.h
@@ -1,7 +1,7 @@
 /*
  * This copyright notice applies to this header file only:
  *
- * Copyright (c) 2010-2015 NVIDIA Corporation
+ * Copyright (c) 2010-2017 NVIDIA Corporation
  *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
@@ -27,8 +27,10 @@
 
 /**
  * \file nvEncodeAPI.h
- *   NvEncodeAPI provides a NVENC Video Encoding interface to NVIDIA GPU devices based on the Kepler architecture.
- * \date 2011-2016
+ *   NVIDIA GPUs - beginning with the Kepler generation - contain a hardware-based encoder
+ *   (referred to as NVENC) which provides fully-accelerated hardware-based video encoding.
+ *   NvEncodeAPI provides the interface for NVIDIA video encoder (NVENC).
+ * \date 2011-2017
  *  This file contains the interface constants, structure definitions and function prototypes.
  */
 
@@ -111,7 +113,7 @@ typedef void* NV_ENC_INPUT_PTR;             /**< NVENCODE API input buffer
 typedef void* NV_ENC_OUTPUT_PTR;            /**< NVENCODE API output buffer*/
 typedef void* NV_ENC_REGISTERED_PTR;        /**< A Resource that has been registered with NVENCODE API*/
 
-#define NVENCAPI_MAJOR_VERSION 7
+#define NVENCAPI_MAJOR_VERSION 8
 #define NVENCAPI_MINOR_VERSION 0
 
 #define NVENCAPI_VERSION (NVENCAPI_MAJOR_VERSION | (NVENCAPI_MINOR_VERSION << 24))
@@ -255,13 +257,16 @@ typedef enum _NV_ENC_PARAMS_RC_MODE
     NV_ENC_PARAMS_RC_CONSTQP                = 0x0,       /**< Constant QP mode */
     NV_ENC_PARAMS_RC_VBR                    = 0x1,       /**< Variable bitrate mode */
     NV_ENC_PARAMS_RC_CBR                    = 0x2,       /**< Constant bitrate mode */
-    NV_ENC_PARAMS_RC_VBR_MINQP              = 0x4,       /**< Variable bitrate mode with MinQP */
-    NV_ENC_PARAMS_RC_2_PASS_QUALITY         = 0x8,       /**< Multi pass encoding optimized for image quality and works only with low latency mode */
-    NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP   = 0x10,      /**< Multi pass encoding optimized for maintaining frame size and works only with low latency mode */
-    NV_ENC_PARAMS_RC_2_PASS_VBR             = 0x20       /**< Multi pass VBR */
+    NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ        = 0x8,       /**< low-delay CBR, high quality */
+    NV_ENC_PARAMS_RC_CBR_HQ                 = 0x10,      /**< CBR, high quality (slower) */
+    NV_ENC_PARAMS_RC_VBR_HQ                 = 0x20       /**< VBR, high quality (slower) */
 } NV_ENC_PARAMS_RC_MODE;
 
-#define NV_ENC_PARAMS_RC_CBR2   NV_ENC_PARAMS_RC_CBR    /**< Deprecated */
+#define NV_ENC_PARAMS_RC_VBR_MINQP              (NV_ENC_PARAMS_RC_MODE)0x4          /**< Deprecated */
+#define NV_ENC_PARAMS_RC_2_PASS_QUALITY         NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ    /**< Deprecated */
+#define NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP   NV_ENC_PARAMS_RC_CBR_HQ             /**< Deprecated */
+#define NV_ENC_PARAMS_RC_2_PASS_VBR             NV_ENC_PARAMS_RC_VBR_HQ             /**< Deprecated */
+#define NV_ENC_PARAMS_RC_CBR2                   NV_ENC_PARAMS_RC_CBR                /**< Deprecated */
 
 /**
  * Input picture structure
@@ -313,11 +318,26 @@ typedef enum _NV_ENC_BUFFER_FORMAT
     NV_ENC_BUFFER_FORMAT_YUV444                          = 0x00001000,  /**< Planar YUV [Y plane followed by U and V planes] */
     NV_ENC_BUFFER_FORMAT_YUV420_10BIT                    = 0x00010000,  /**< 10 bit Semi-Planar YUV [Y plane followed by interleaved UV plane]. Each pixel of size 2 bytes. Most Significant 10 bits contain pixel data. */
     NV_ENC_BUFFER_FORMAT_YUV444_10BIT                    = 0x00100000,  /**< 10 bit Planar YUV444 [Y plane followed by U and V planes]. Each pixel of size 2 bytes. Most Significant 10 bits contain pixel data.  */
-    NV_ENC_BUFFER_FORMAT_ARGB                            = 0x01000000,  /**< 8 bit Packed A8R8G8B8 */
-    NV_ENC_BUFFER_FORMAT_ARGB10                          = 0x02000000,  /**< 10 bit Packed A2R10G10B10. Each pixel of size 2 bytes. Most Significant 10 bits contain pixel data.  */
-    NV_ENC_BUFFER_FORMAT_AYUV                            = 0x04000000,  /**< 8 bit Packed A8Y8U8V8 */
-    NV_ENC_BUFFER_FORMAT_ABGR                            = 0x10000000,  /**< 8 bit Packed A8B8G8R8 */
-    NV_ENC_BUFFER_FORMAT_ABGR10                          = 0x20000000,  /**< 10 bit Packed A2B10G10R10. Each pixel of size 2 bytes. Most Significant 10 bits contain pixel data.  */
+    NV_ENC_BUFFER_FORMAT_ARGB                            = 0x01000000,  /**< 8 bit Packed A8R8G8B8. This is a word-ordered format
+                                                                             where a pixel is represented by a 32-bit word with B
+                                                                             in the lowest 8 bits, G in the next 8 bits, R in the
+                                                                             8 bits after that and A in the highest 8 bits. */
+    NV_ENC_BUFFER_FORMAT_ARGB10                          = 0x02000000,  /**< 10 bit Packed A2R10G10B10. This is a word-ordered format
+                                                                             where a pixel is represented by a 32-bit word with B
+                                                                             in the lowest 10 bits, G in the next 10 bits, R in the
+                                                                             10 bits after that and A in the highest 2 bits. */
+    NV_ENC_BUFFER_FORMAT_AYUV                            = 0x04000000,  /**< 8 bit Packed A8Y8U8V8. This is a word-ordered format
+                                                                             where a pixel is represented by a 32-bit word with V
+                                                                             in the lowest 8 bits, U in the next 8 bits, Y in the
+                                                                             8 bits after that and A in the highest 8 bits. */
+    NV_ENC_BUFFER_FORMAT_ABGR                            = 0x10000000,  /**< 8 bit Packed A8B8G8R8. This is a word-ordered format
+                                                                             where a pixel is represented by a 32-bit word with R
+                                                                             in the lowest 8 bits, G in the next 8 bits, B in the
+                                                                             8 bits after that and A in the highest 8 bits. */
+    NV_ENC_BUFFER_FORMAT_ABGR10                          = 0x20000000,  /**< 10 bit Packed A2B10G10R10. This is a word-ordered format
+                                                                             where a pixel is represented by a 32-bit word with R
+                                                                             in the lowest 10 bits, G in the next 10 bits, B in the
+                                                                             10 bits after that and A in the highest 2 bits. */
 } NV_ENC_BUFFER_FORMAT;
 
 #define NV_ENC_BUFFER_FORMAT_NV12_PL NV_ENC_BUFFER_FORMAT_NV12
@@ -629,6 +649,7 @@ typedef enum _NV_ENC_INPUT_RESOURCE_TYPE
     NV_ENC_INPUT_RESOURCE_TYPE_DIRECTX          = 0x0,   /**< input resource type is a directx9 surface*/
     NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR    = 0x1,   /**< input resource type is a cuda device pointer surface*/
     NV_ENC_INPUT_RESOURCE_TYPE_CUDAARRAY        = 0x2,   /**< input resource type is a cuda array surface */
+    NV_ENC_INPUT_RESOURCE_TYPE_OPENGL_TEX       = 0x3    /**< input resource type is an OpenGL texture */
 } NV_ENC_INPUT_RESOURCE_TYPE;
 
 /**
@@ -638,6 +659,8 @@ typedef enum _NV_ENC_DEVICE_TYPE
 {
     NV_ENC_DEVICE_TYPE_DIRECTX          = 0x0,   /**< encode device type is a directx9 device */
     NV_ENC_DEVICE_TYPE_CUDA             = 0x1,   /**< encode device type is a cuda device */
+    NV_ENC_DEVICE_TYPE_OPENGL           = 0x2    /**< encode device type is an OpenGL device.
+                                                      Use of this device type is supported only on Linux */
 } NV_ENC_DEVICE_TYPE;
 
 /**
@@ -896,7 +919,8 @@ typedef enum _NV_ENC_CAPS
     /**
      * Indicates HW support for MEOnly Mode.
      * \n 0 : MEOnly Mode not supported.
-     * \n 1 : MEOnly Mode supported.
+     * \n 1 : MEOnly Mode supported for I and P frames.
+     * \n 2 : MEOnly Mode supported for I, P and B frames.
      */
     NV_ENC_CAPS_SUPPORT_MEONLY_MODE,
 
@@ -919,6 +943,17 @@ typedef enum _NV_ENC_CAPS
      * \n 1 : 10 bit encoding supported.
      */
     NV_ENC_CAPS_SUPPORT_10BIT_ENCODE,
+    /**
+     * Maximum number of Long Term Reference frames supported
+     */
+    NV_ENC_CAPS_NUM_MAX_LTR_FRAMES,
+
+    /**
+     * Indicates HW support for Weighted Predicition.
+     * \n 0 : Weighted Predicition not supported.
+     * \n 1 : Weighted Predicition supported.
+     */
+    NV_ENC_CAPS_SUPPORT_WEIGHTED_PREDICTION,
 
     /**
      * Reserved - Not to be used by clients.
@@ -960,7 +995,7 @@ typedef struct _NV_ENC_CREATE_INPUT_BUFFER
     uint32_t                  version;                 /**< [in]: Struct version. Must be set to ::NV_ENC_CREATE_INPUT_BUFFER_VER */
     uint32_t                  width;                   /**< [in]: Input buffer width */
     uint32_t                  height;                  /**< [in]: Input buffer width */
-    NV_ENC_MEMORY_HEAP        memoryHeap;              /**< [in]: Deprecated. Will be removed in sdk 8.0 */
+    NV_ENC_MEMORY_HEAP        memoryHeap;              /**< [in]: Deprecated. Do not use */
     NV_ENC_BUFFER_FORMAT      bufferFmt;               /**< [in]: Input buffer format */
     uint32_t                  reserved;                /**< [in]: Reserved and must be set to 0 */
     NV_ENC_INPUT_PTR          inputBuffer;             /**< [out]: Pointer to input buffer */
@@ -978,8 +1013,8 @@ typedef struct _NV_ENC_CREATE_INPUT_BUFFER
 typedef struct _NV_ENC_CREATE_BITSTREAM_BUFFER
 {
     uint32_t              version;                     /**< [in]: Struct version. Must be set to ::NV_ENC_CREATE_BITSTREAM_BUFFER_VER */
-    uint32_t              size;                        /**< [in]: Size of the bitstream buffer to be created */
-    NV_ENC_MEMORY_HEAP    memoryHeap;                  /**< [in]: Deprecated. Will be removed in sdk 8.0 */
+    uint32_t              size;                        /**< [in]: Deprecated. Do not use */
+    NV_ENC_MEMORY_HEAP    memoryHeap;                  /**< [in]: Deprecated. Do not use */
     uint32_t              reserved;                    /**< [in]: Reserved and must be set to 0 */
     NV_ENC_OUTPUT_PTR     bitstreamBuffer;             /**< [out]: Pointer to the output bitstream buffer */
     void*                 bitstreamBufferPtr;          /**< [out]: Reserved and should not be used */
@@ -1073,14 +1108,15 @@ typedef struct _NV_ENC_QP
     uint32_t                        zeroReorderDelay     :1;                     /**< [in]: Set this to 1 to indicate zero latency operation (no reordering delay, num_reorder_frames=0) */
     uint32_t                        enableNonRefP        :1;                     /**< [in]: Set this to 1 to enable automatic insertion of non-reference P-frames (no effect if enablePTD=0) */
     uint32_t                        strictGOPTarget      :1;                     /**< [in]: Set this to 1 to minimize GOP-to-GOP rate fluctuations */
-    uint32_t                        aqStrength           :4;                     /**< [in]: When AQ (Spatial) is enabled (i.e. NV_ENC_RC_PARAMS::enableAQ is set), this field is used to specify AQ strength. AQ strength scale is from 1 (low) - 15 (aggressive). If not set, strength is autoselected by driver. Currently supported only with h264 */
+    uint32_t                        aqStrength           :4;                     /**< [in]: When AQ (Spatial) is enabled (i.e. NV_ENC_RC_PARAMS::enableAQ is set), this field is used to specify AQ strength. AQ strength scale is from 1 (low) - 15 (aggressive). If not set, strength is autoselected by driver. */
     uint32_t                        reservedBitFields    :16;                    /**< [in]: Reserved bitfields and must be set to 0 */
     NV_ENC_QP                       minQP;                                       /**< [in]: Specifies the minimum QP used for rate control. Client must set NV_ENC_CONFIG::enableMinQP to 1. */
     NV_ENC_QP                       maxQP;                                       /**< [in]: Specifies the maximum QP used for rate control. Client must set NV_ENC_CONFIG::enableMaxQP to 1. */
     NV_ENC_QP                       initialRCQP;                                 /**< [in]: Specifies the initial QP used for rate control. Client must set NV_ENC_CONFIG::enableInitialRCQP to 1. */
     uint32_t                        temporallayerIdxMask;                        /**< [in]: Specifies the temporal layers (as a bitmask) whose QPs have changed. Valid max bitmask is [2^NV_ENC_CAPS_NUM_MAX_TEMPORAL_LAYERS - 1] */
     uint8_t                         temporalLayerQP[8];                          /**< [in]: Specifies the temporal layer QPs used for rate control. Temporal layer index is used as as the array index */
-    uint16_t                        targetQuality;                               /**< [in]: Target CQ (Constant Quality) level for VBR mode (range 0-51 with 0-automatic)  */
+    uint8_t                         targetQuality;                               /**< [in]: Target CQ (Constant Quality) level for VBR mode (range 0-51 with 0-automatic)  */
+    uint8_t                         targetQualityLSB;                            /**< [in]: Fractional part of target quality (as 8.8 fixed point format) */
     uint16_t                        lookaheadDepth;                              /**< [in]: Maximum depth of lookahead with range 0-32 (only used if enableLookahead=1) */
     uint32_t                        reserved[9];
  } NV_ENC_RC_PARAMS;
@@ -1117,13 +1153,14 @@ typedef NV_ENC_CONFIG_H264_VUI_PARAMETERS NV_ENC_CONFIG_HEVC_VUI_PARAMETERS;
 /**
  * \struct _NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE
  * External motion vector hint counts per block type.
+ * H264 supports multiple hint while HEVC supports one hint for each valid candidate.
  */
 typedef struct _NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE
 {
-    uint32_t   numCandsPerBlk16x16                   : 4;   /**< [in]: Specifies the number of candidates per 16x16 block. */
-    uint32_t   numCandsPerBlk16x8                    : 4;   /**< [in]: Specifies the number of candidates per 16x8 block. */
-    uint32_t   numCandsPerBlk8x16                    : 4;   /**< [in]: Specifies the number of candidates per 8x16 block. */
-    uint32_t   numCandsPerBlk8x8                     : 4;   /**< [in]: Specifies the number of candidates per 8x8 block. */
+    uint32_t   numCandsPerBlk16x16                   : 4;   /**< [in]: Supported for H264,HEVC.It Specifies the number of candidates per 16x16 block. */
+    uint32_t   numCandsPerBlk16x8                    : 4;   /**< [in]: Supported for H264 only.Specifies the number of candidates per 16x8 block. */
+    uint32_t   numCandsPerBlk8x16                    : 4;   /**< [in]: Supported for H264 only.Specifies the number of candidates per 8x16 block. */
+    uint32_t   numCandsPerBlk8x8                     : 4;   /**< [in]: Supported for H264,HEVC.Specifies the number of candidates per 8x8 block. */
     uint32_t   reserved                              : 16;  /**< [in]: Reserved for padding. */
     uint32_t   reserved1[3];                                /**< [in]: Reserved for future use. */
 } NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE;
@@ -1156,7 +1193,8 @@ typedef struct _NV_ENC_CONFIG_H264
     uint32_t hierarchicalPFrames       :1;                          /**< [in]: Set to 1 to enable hierarchical PFrames */
     uint32_t hierarchicalBFrames       :1;                          /**< [in]: Set to 1 to enable hierarchical BFrames */
     uint32_t outputBufferingPeriodSEI  :1;                          /**< [in]: Set to 1 to write SEI buffering period syntax in the bitstream */
-    uint32_t outputPictureTimingSEI    :1;                          /**< [in]: Set to 1 to write SEI picture timing syntax in the bitstream */
+    uint32_t outputPictureTimingSEI    :1;                          /**< [in]: Set to 1 to write SEI picture timing syntax in the bitstream.  When set for following rateControlMode : NV_ENC_PARAMS_RC_CBR, NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ,
+                                                                               NV_ENC_PARAMS_RC_CBR_HQ, filler data is inserted if needed to achieve hrd bitrate */
     uint32_t outputAUD                 :1;                          /**< [in]: Set to 1 to write access unit delimiter syntax in bitstream */
     uint32_t disableSPSPPS             :1;                          /**< [in]: Set to 1 to disable writing of Sequence and Picture parameter info in bitstream */
     uint32_t outputFramePackingSEI     :1;                          /**< [in]: Set to 1 to enable writing of frame packing arrangement SEI messages to bitstream */
@@ -1166,7 +1204,13 @@ typedef struct _NV_ENC_CONFIG_H264
                                                                                Check support for constrained encoding using ::NV_ENC_CAPS_SUPPORT_CONSTRAINED_ENCODING caps. */
     uint32_t repeatSPSPPS              :1;                          /**< [in]: Set to 1 to enable writing of Sequence and Picture parameter for every IDR frame */
     uint32_t enableVFR                 :1;                          /**< [in]: Set to 1 to enable variable frame rate. */
-    uint32_t enableLTR                 :1;                          /**< [in]: Currently this feature is not available and must be set to 0. Set to 1 to enable LTR support and auto-mark the first */
+    uint32_t enableLTR                 :1;                          /**< [in]: Set to 1 to enable LTR (Long Term Reference) frame support. LTR can be used in two modes: "LTR Trust" mode and "LTR Per Picture" mode.
+                                                                               LTR Trust mode: In this mode, ltrNumFrames pictures after IDR are automatically marked as LTR. This mode is enabled by setting ltrTrustMode = 1.
+                                                                                               Use of LTR Trust mode is strongly discouraged as this mode may be deprecated in future.
+                                                                               LTR Per Picture mode: In this mode, client can control whether the current picture should be marked as LTR. Enable this mode by setting
+                                                                                                     ltrTrustMode = 0 and ltrMarkFrame = 1 for the picture to be marked as LTR. This is the preferred mode
+                                                                                                     for using LTR.
+                                                                               Note that LTRs are not supported if encoding session is configured with B-frames */
     uint32_t qpPrimeYZeroTransformBypassFlag :1;                    /**< [in]: To enable lossless encode set this to 1, set QP to 0 and RC_mode to NV_ENC_PARAMS_RC_CONSTQP and profile to HIGH_444_PREDICTIVE_PROFILE.
                                                                                Check support for lossless encoding using ::NV_ENC_CAPS_SUPPORT_LOSSLESS_ENCODE caps.  */
     uint32_t useConstrainedIntraPred   :1;                          /**< [in]: Set 1 to enable constrained intra prediction. */
@@ -1176,8 +1220,8 @@ typedef struct _NV_ENC_CONFIG_H264
     uint32_t separateColourPlaneFlag;                               /**< [in]: Set to 1 to enable 4:4:4 separate colour planes */
     uint32_t disableDeblockingFilterIDC;                            /**< [in]: Specifies the deblocking filter mode. Permissible value range: [0,2] */
     uint32_t numTemporalLayers;                                     /**< [in]: Specifies max temporal layers to be used for hierarchical coding. Valid value range is [1,::NV_ENC_CAPS_NUM_MAX_TEMPORAL_LAYERS] */
-    uint32_t spsId;                                                 /**< [in]: Specifies the SPS id of the sequence header. Currently reserved and must be set to 0. */
-    uint32_t ppsId;                                                 /**< [in]: Specifies the PPS id of the picture header. Currently reserved and must be set to 0. */
+    uint32_t spsId;                                                 /**< [in]: Specifies the SPS id of the sequence header */
+    uint32_t ppsId;                                                 /**< [in]: Specifies the PPS id of the picture header */
     NV_ENC_H264_ADAPTIVE_TRANSFORM_MODE adaptiveTransformMode;      /**< [in]: Specifies the AdaptiveTransform Mode. Check support for AdaptiveTransform mode using ::NV_ENC_CAPS_SUPPORT_ADAPTIVE_TRANSFORM caps. */
     NV_ENC_H264_FMO_MODE                fmoMode;                    /**< [in]: Specified the FMO Mode. Check support for FMO using ::NV_ENC_CAPS_SUPPORT_FMO caps. */
     NV_ENC_H264_BDIRECT_MODE            bdirectMode;                /**< [in]: Specifies the BDirect mode. Check support for BDirect mode using ::NV_ENC_CAPS_SUPPORT_BDIRECT_MODE caps.*/
@@ -1200,13 +1244,13 @@ typedef struct _NV_ENC_CONFIG_H264
                                                                                sliceMode = 2, sliceModeData specifies # of MB rows in each slice (except last slice)
                                                                                sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */
     NV_ENC_CONFIG_H264_VUI_PARAMETERS   h264VUIParameters;          /**< [in]: Specifies the H264 video usability info pamameters */
-    uint32_t                            ltrNumFrames;               /**< [in]: Specifies the number of LTR frames used.
-                                                                               If ltrTrustMode=1, encoder will mark first numLTRFrames base layer reference frames within each IDR interval as LTR.
-                                                                               If ltrMarkFrame=1, ltrNumFrames specifies maximum number of ltr frames in DPB.
-                                                                               If ltrNumFrames value is more that DPB size(maxNumRefFrames) encoder will take decision on its own. */
-    uint32_t                            ltrTrustMode;               /**< [in]: Specifies the LTR operating mode.
-                                                                               Set to 0 to disallow encoding using LTR frames until later specified.
-                                                                               Set to 1 to allow encoding using LTR frames unless later invalidated.*/
+    uint32_t                            ltrNumFrames;               /**< [in]: Specifies the number of LTR frames. This parameter has different meaning in two LTR modes.
+                                                                               In "LTR Trust" mode (ltrTrustMode = 1), encoder will mark the first ltrNumFrames base layer reference frames within each IDR interval as LTR.
+                                                                               In "LTR Per Picture" mode (ltrTrustMode = 0 and ltrMarkFrame = 1), ltrNumFrames specifies maximum number of LTR frames in DPB. */
+    uint32_t                            ltrTrustMode;               /**< [in]: Specifies the LTR operating mode. See comments near NV_ENC_CONFIG_H264::enableLTR for description of the two modes.
+                                                                               Set to 1 to use "LTR Trust" mode of LTR operation. Clients are discouraged to use "LTR Trust" mode as this mode may
+                                                                               be deprecated in future releases.
+                                                                               Set to 0 when using "LTR Per Picture" mode of LTR operation. */
     uint32_t                            chromaFormatIDC;            /**< [in]: Specifies the chroma format. Should be set to 1 for yuv420 input, 3 for yuv444 input.
                                                                                Check support for YUV444 encoding using ::NV_ENC_CAPS_SUPPORT_YUV444_ENCODE caps.*/
     uint32_t                            maxTemporalLayers;          /**< [in]: Specifies the max temporal layer used for hierarchical coding. */
@@ -1230,7 +1274,13 @@ typedef struct _NV_ENC_CONFIG_HEVC
     uint32_t outputBufferingPeriodSEI              :1;              /**< [in]: Set 1 to write SEI buffering period syntax in the bitstream */
     uint32_t outputPictureTimingSEI                :1;              /**< [in]: Set 1 to write SEI picture timing syntax in the bitstream */
     uint32_t outputAUD                             :1;              /**< [in]: Set 1 to write Access Unit Delimiter syntax. */
-    uint32_t enableLTR                             :1;              /**< [in]: Set 1 to enable use of long term reference pictures for inter prediction. */
+    uint32_t enableLTR                             :1;              /**< [in]: Set to 1 to enable LTR (Long Term Reference) frame support. LTR can be used in two modes: "LTR Trust" mode and "LTR Per Picture" mode.
+                                                                               LTR Trust mode: In this mode, ltrNumFrames pictures after IDR are automatically marked as LTR. This mode is enabled by setting ltrTrustMode = 1.
+                                                                                               Use of LTR Trust mode is strongly discouraged as this mode may be deprecated in future releases.
+                                                                               LTR Per Picture mode: In this mode, client can control whether the current picture should be marked as LTR. Enable this mode by setting
+                                                                                                     ltrTrustMode = 0 and ltrMarkFrame = 1 for the picture to be marked as LTR. This is the preferred mode
+                                                                                                     for using LTR.
+                                                                               Note that LTRs are not supported if encoding session is configured with B-frames */
     uint32_t disableSPSPPS                         :1;              /**< [in]: Set 1 to disable VPS,SPS and PPS signalling in the bitstream. */
     uint32_t repeatSPSPPS                          :1;              /**< [in]: Set 1 to output VPS,SPS and PPS for every IDR frame.*/
     uint32_t enableIntraRefresh                    :1;              /**< [in]: Set 1 to enable gradual decoder refresh or intra refresh. If the GOP structure uses B frames this will be ignored */
@@ -1242,13 +1292,12 @@ typedef struct _NV_ENC_CONFIG_HEVC
                                                                     Will be disabled if NV_ENC_CONFIG::gopLength is not set to NVENC_INFINITE_GOPLENGTH. */
     uint32_t intraRefreshCnt;                                       /**< [in]: Specifies the length of intra refresh in number of frames for periodic intra refresh. This value should be smaller than intraRefreshPeriod */
     uint32_t maxNumRefFramesInDPB;                                  /**< [in]: Specifies the maximum number of references frames in the DPB.*/
-    uint32_t ltrNumFrames;                                          /**< [in]: Specifies the number of LTR frames used.
-                                                                               If ltrTrustMode=1, encoder will mark first numLTRFrames base layer reference frames within each IDR interval as LTR.
-                                                                               If ltrMarkFrame=1, ltrNumFrames specifies maximum number of ltr frames in DPB.
-                                                                               If ltrNumFrames value is more that DPB size(maxNumRefFramesInDPB) encoder will take decision on its own. */
-    uint32_t vpsId;                                                 /**< [in]: Specifies the VPS id of the video parameter set. Currently reserved and must be set to 0. */
-    uint32_t spsId;                                                 /**< [in]: Specifies the SPS id of the sequence header. Currently reserved and must be set to 0. */
-    uint32_t ppsId;                                                 /**< [in]: Specifies the PPS id of the picture header. Currently reserved and must be set to 0. */
+    uint32_t ltrNumFrames;                                          /**< [in]: This parameter has different meaning in two LTR modes.
+                                                                               In "LTR Trust" mode (ltrTrustMode = 1), encoder will mark the first ltrNumFrames base layer reference frames within each IDR interval as LTR.
+                                                                               In "LTR Per Picture" mode (ltrTrustMode = 0 and ltrMarkFrame = 1), ltrNumFrames specifies maximum number of LTR frames in DPB. */
+    uint32_t vpsId;                                                 /**< [in]: Specifies the VPS id of the video parameter set */
+    uint32_t spsId;                                                 /**< [in]: Specifies the SPS id of the sequence header */
+    uint32_t ppsId;                                                 /**< [in]: Specifies the PPS id of the picture header */
     uint32_t sliceMode;                                             /**< [in]: This parameter in conjunction with sliceModeData specifies the way in which the picture is divided into slices
                                                                                 sliceMode = 0 CTU based slices, sliceMode = 1 Byte based slices, sliceMode = 2 CTU row based slices, sliceMode = 3, numSlices in Picture
                                                                                 When sliceMode == 0 and sliceModeData == 0 whole picture will be coded with one slice */
@@ -1259,22 +1308,55 @@ typedef struct _NV_ENC_CONFIG_HEVC
                                                                                 sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */
     uint32_t maxTemporalLayersMinus1;                               /**< [in]: Specifies the max temporal layer used for hierarchical coding. */
     NV_ENC_CONFIG_HEVC_VUI_PARAMETERS   hevcVUIParameters;          /**< [in]: Specifies the HEVC video usability info pamameters */
-    uint32_t ltrTrustMode;                                          /**< [in]: Specifies the LTR operating mode.
-                                                                               Set to 0 to disallow encoding using LTR frames until later specified.
-                                                                               Set to 1 to allow encoding using LTR frames unless later invalidated.*/
+    uint32_t ltrTrustMode;                                          /**< [in]: Specifies the LTR operating mode. See comments near NV_ENC_CONFIG_HEVC::enableLTR for description of the two modes.
+                                                                               Set to 1 to use "LTR Trust" mode of LTR operation. Clients are discouraged to use "LTR Trust" mode as this mode may
+                                                                               be deprecated in future releases.
+                                                                               Set to 0 when using "LTR Per Picture" mode of LTR operation. */
     uint32_t reserved1[217];                                        /**< [in]: Reserved and must be set to 0.*/
     void*    reserved2[64];                                         /**< [in]: Reserved and must be set to NULL */
 } NV_ENC_CONFIG_HEVC;
 
+/**
+ * \struct _NV_ENC_CONFIG_H264_MEONLY
+ * H264 encoder configuration parameters for ME only Mode
+ *
+ */
+typedef struct _NV_ENC_CONFIG_H264_MEONLY
+{
+    uint32_t disablePartition16x16 :1;                          /**< [in]: Disable MotionEstimation on 16x16 blocks*/
+    uint32_t disablePartition8x16  :1;                          /**< [in]: Disable MotionEstimation on 8x16 blocks*/
+    uint32_t disablePartition16x8  :1;                          /**< [in]: Disable MotionEstimation on 16x8 blocks*/
+    uint32_t disablePartition8x8   :1;                          /**< [in]: Disable MotionEstimation on 8x8 blocks*/
+    uint32_t disableIntraSearch    :1;                          /**< [in]: Disable Intra search during MotionEstimation*/
+    uint32_t bStereoEnable         :1;                          /**< [in]: Enable Stereo Mode for Motion Estimation where each view is independently executed*/
+    uint32_t reserved              :26;                         /**< [in]: Reserved and must be set to 0 */
+    uint32_t reserved1 [255];                                   /**< [in]: Reserved and must be set to 0 */
+    void*    reserved2[64];                                     /**< [in]: Reserved and must be set to NULL */
+} NV_ENC_CONFIG_H264_MEONLY;
+
+
+/**
+ * \struct _NV_ENC_CONFIG_HEVC_MEONLY
+ * HEVC encoder configuration parameters for ME only Mode
+ *
+ */
+typedef struct _NV_ENC_CONFIG_HEVC_MEONLY
+{
+    uint32_t reserved [256];                                   /**< [in]: Reserved and must be set to 0 */
+    void*    reserved1[64];                                     /**< [in]: Reserved and must be set to NULL */
+} NV_ENC_CONFIG_HEVC_MEONLY;
+
 /**
  * \struct _NV_ENC_CODEC_CONFIG
  * Codec-specific encoder configuration parameters to be set during initialization.
  */
 typedef union _NV_ENC_CODEC_CONFIG
 {
-    NV_ENC_CONFIG_H264      h264Config;                  /**< [in]: Specifies the H.264-specific encoder configuration. */
-    NV_ENC_CONFIG_HEVC      hevcConfig;                  /**< [in]: Specifies the HEVC-specific encoder configuration. */
-    uint32_t                reserved[256];               /**< [in]: Reserved and must be set to 0 */
+    NV_ENC_CONFIG_H264        h264Config;                /**< [in]: Specifies the H.264-specific encoder configuration. */
+    NV_ENC_CONFIG_HEVC        hevcConfig;                /**< [in]: Specifies the HEVC-specific encoder configuration. */
+    NV_ENC_CONFIG_H264_MEONLY h264MeOnlyConfig;          /**< [in]: Specifies the H.264-specific ME only encoder configuration. */
+    NV_ENC_CONFIG_HEVC_MEONLY hevcMeOnlyConfig;          /**< [in]: Specifies the HEVC-specific ME only encoder configuration. */
+    uint32_t                reserved[320];               /**< [in]: Reserved and must be set to 0 */
 } NV_ENC_CODEC_CONFIG;
 
 
@@ -1325,7 +1407,8 @@ typedef struct _NV_ENC_INITIALIZE_PARAMS
     uint32_t                                   enableExternalMEHints     :1;    /**< [in]: Set to 1 to enable external ME hints for the current frame. For NV_ENC_INITIALIZE_PARAMS::enablePTD=1 with B frames, programming L1 hints is optional for B frames since Client doesn't know internal GOP structure.
                                                                                            NV_ENC_PIC_PARAMS::meHintRefPicDist should preferably be set with enablePTD=1. */
     uint32_t                                   enableMEOnlyMode          :1;    /**< [in]: Set to 1 to enable ME Only Mode .*/
-    uint32_t                                   reservedBitFields         :28;   /**< [in]: Reserved bitfields and must be set to 0 */
+    uint32_t                                   enableWeightedPrediction  :1;    /**< [in]: Set this to 1 to enable weighted prediction. Not supported if encode session is configured for B-Frames( 'frameIntervalP' in NV_ENC_CONFIG is greater than 1).*/
+    uint32_t                                   reservedBitFields         :27;   /**< [in]: Reserved bitfields and must be set to 0 */
     uint32_t                                   privDataSize;                    /**< [in]: Reserved private data buffer size and must be set to 0 */
     void*                                      privData;                        /**< [in]: Reserved private data buffer and must be set to NULL */
     NV_ENC_CONFIG*                             encodeConfig;                    /**< [in]: Specifies the advanced codec specific structure. If client has sent a valid codec config structure, it will override parameters set by the NV_ENC_INITIALIZE_PARAMS::presetGUID parameter. If set to NULL the NvEncodeAPI interface will use the NV_ENC_INITIALIZE_PARAMS::presetGUID to set the codec specific parameters.
@@ -1428,8 +1511,8 @@ typedef struct _NV_ENC_PIC_PARAMS_H264
                                                                     sliceMode = 2, sliceModeData specifies # of MB rows in each slice (except last slice)
                                                                     sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */
     uint32_t ltrMarkFrameIdx;                            /**< [in]: Specifies the long term referenceframe index to use for marking this frame as LTR.*/
-    uint32_t ltrUseFrameBitmap;                          /**< [in]: Specifies the the associated bitmap of LTR frame indices when encoding this frame. */
-    uint32_t ltrUsageMode;                               /**< [in]: Specifies additional usage constraints for encoding using LTR frames from this point further. 0: no constraints, 1: no short term refs older than current, no previous LTR frames.*/
+    uint32_t ltrUseFrameBitmap;                          /**< [in]: Specifies the the associated bitmap of LTR frame indices to use when encoding this frame. */
+    uint32_t ltrUsageMode;                               /**< [in]: Not supported. Reserved for future use and must be set to 0. */
     uint32_t reserved [243];                             /**< [in]: Reserved and must be set to 0. */
     void*    reserved2[62];                              /**< [in]: Reserved and must be set to NULL. */
 } NV_ENC_PIC_PARAMS_H264;
@@ -1468,8 +1551,8 @@ typedef struct _NV_ENC_PIC_PARAMS_HEVC
                                                                     sliceMode = 2, sliceModeData specifies # of CTU rows in each slice (except last slice)
                                                                     sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */
     uint32_t ltrMarkFrameIdx;                            /**< [in]: Specifies the long term reference frame index to use for marking this frame as LTR.*/
-    uint32_t ltrUseFrameBitmap;                          /**< [in]: Specifies the associated bitmap of LTR frame indices when encoding this frame. */
-    uint32_t ltrUsageMode;                               /**< [in]: Specifies additional usage constraints for encoding using LTR frames from this point further. 0: no constraints, 1: no short term refs older than current, no previous LTR frames.*/
+    uint32_t ltrUseFrameBitmap;                          /**< [in]: Specifies the associated bitmap of LTR frame indices to use when encoding this frame. */
+    uint32_t ltrUsageMode;                               /**< [in]: Not supported. Reserved for future use and must be set to 0. */
     uint32_t seiPayloadArrayCnt;                         /**< [in]: Specifies the number of elements allocated in  seiPayloadArray array. */
     uint32_t reserved;                                   /**< [in]: Reserved and must be set to 0. */
     NV_ENC_SEI_PAYLOAD* seiPayloadArray;                 /**< [in]: Array of SEI payloads which will be inserted for this frame. */
@@ -1484,7 +1567,7 @@ typedef struct _NV_ENC_PIC_PARAMS_HEVC
 typedef union _NV_ENC_CODEC_PIC_PARAMS
 {
     NV_ENC_PIC_PARAMS_H264 h264PicParams;                /**< [in]: H264 encode picture params. */
-    NV_ENC_PIC_PARAMS_HEVC hevcPicParams;                /**< [in]: HEVC encode picture params. Currently unsupported and must not to be used.  */
+    NV_ENC_PIC_PARAMS_HEVC hevcPicParams;                /**< [in]: HEVC encode picture params. */
     uint32_t               reserved[256];                /**< [in]: Reserved and must be set to 0. */
 } NV_ENC_CODEC_PIC_PARAMS;
 
@@ -1511,7 +1594,7 @@ typedef struct _NV_ENC_PIC_PARAMS
     NV_ENC_CODEC_PIC_PARAMS                     codecPicParams;                 /**< [in]: Specifies the codec specific per-picture encoding parameters. */
     NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE meHintCountsPerBlock[2];        /**< [in]: Specifies the number of hint candidates per block per direction for the current frame. meHintCountsPerBlock[0] is for L0 predictors and meHintCountsPerBlock[1] is for L1 predictors.
                                                                                            The candidate count in NV_ENC_PIC_PARAMS::meHintCountsPerBlock[lx] must never exceed NV_ENC_INITIALIZE_PARAMS::maxMEHintCountsPerBlock[lx] provided during encoder intialization. */
-    NVENC_EXTERNAL_ME_HINT                     *meExternalHints;                /**< [in]: Specifies the pointer to ME external hints for the current frame. The size of ME hint buffer should be equal to number of macroblocks multiplied by the total number of candidates per macroblock.
+    NVENC_EXTERNAL_ME_HINT                     *meExternalHints;                /**< [in]: Specifies the pointer to ME external hints for the current frame. The size of ME hint buffer should be equal to number of macroblocks * the total number of candidates per macroblock.
                                                                                            The total number of candidates per MB per direction = 1*meHintCountsPerBlock[Lx].numCandsPerBlk16x16 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk16x8 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk8x8
                                                                                            + 4*meHintCountsPerBlock[Lx].numCandsPerBlk8x8. For frames using bidirectional ME , the total number of candidates for single macroblock is sum of total number of candidates per MB for each direction (L0 and L1) */
     uint32_t                                    reserved1[6];                    /**< [in]: Reserved and must be set to 0 */
@@ -1532,6 +1615,7 @@ typedef struct _NV_ENC_PIC_PARAMS
 /**
  * \struct _NV_ENC_MEONLY_PARAMS
  * MEOnly parameters that need to be sent on a per motion estimation basis.
+ * NV_ENC_MEONLY_PARAMS::meExternalHints is supported for H264 only.
  */
 typedef struct _NV_ENC_MEONLY_PARAMS
 {
@@ -1545,12 +1629,20 @@ typedef struct _NV_ENC_MEONLY_PARAMS
     void*                   completionEvent;                    /**< [in]: Specifies an event to be signalled on completion of motion estimation
                                                                            of this Frame [only if operating in Asynchronous mode].
                                                                            Each output buffer should be associated with a distinct event pointer. */
-    uint32_t                reserved1[252];                     /**< [in]: Reserved and must be set to 0 */
-    void*                   reserved2[60];                      /**< [in]: Reserved and must be set to NULL */
+    uint32_t                viewID;                             /**< [in]: Specifies left,right viewID if NV_ENC_CONFIG_H264_MEONLY::bStereoEnable is set.
+                                                                            viewID can be 0,1 if bStereoEnable is set, 0 otherwise. */
+    NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE
+                            meHintCountsPerBlock[2];            /**< [in]: Specifies the number of hint candidates per block for the current frame. meHintCountsPerBlock[0] is for L0 predictors.
+                                                                            The candidate count in NV_ENC_PIC_PARAMS::meHintCountsPerBlock[lx] must never exceed NV_ENC_INITIALIZE_PARAMS::maxMEHintCountsPerBlock[lx] provided during encoder intialization. */
+    NVENC_EXTERNAL_ME_HINT  *meExternalHints;                   /**< [in]: Specifies the pointer to ME external hints for the current frame. The size of ME hint buffer should be equal to number of macroblocks * the total number of candidates per macroblock.
+                                                                            The total number of candidates per MB per direction = 1*meHintCountsPerBlock[Lx].numCandsPerBlk16x16 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk16x8 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk8x8
+                                                                            + 4*meHintCountsPerBlock[Lx].numCandsPerBlk8x8. For frames using bidirectional ME , the total number of candidates for single macroblock is sum of total number of candidates per MB for each direction (L0 and L1) */
+    uint32_t                reserved1[243];                     /**< [in]: Reserved and must be set to 0 */
+    void*                   reserved2[59];                      /**< [in]: Reserved and must be set to NULL */
 } NV_ENC_MEONLY_PARAMS;
 
 /** NV_ENC_MEONLY_PARAMS struct version*/
-#define NV_ENC_MEONLY_PARAMS_VER NVENCAPI_STRUCT_VERSION(2)
+#define NV_ENC_MEONLY_PARAMS_VER NVENCAPI_STRUCT_VERSION(3)
 
 
 /**
@@ -1627,6 +1719,17 @@ typedef struct _NV_ENC_MAP_INPUT_RESOURCE
 /** Macro for constructing the version field of ::_NV_ENC_MAP_INPUT_RESOURCE */
 #define NV_ENC_MAP_INPUT_RESOURCE_VER NVENCAPI_STRUCT_VERSION(4)
 
+/**
+ * \struct _NV_ENC_INPUT_RESOURCE_OPENGL_TEX
+ * NV_ENC_REGISTER_RESOURCE::resourceToRegister must be a pointer to a variable of this type,
+ * when NV_ENC_REGISTER_RESOURCE::resourceType is NV_ENC_INPUT_RESOURCE_TYPE_OPENGL_TEX
+ */
+typedef struct _NV_ENC_INPUT_RESOURCE_OPENGL_TEX
+{
+    uint32_t texture;                                     /**< [in]: The name of the texture to be used. */
+    uint32_t target;                                      /**< [in]: Accepted values are GL_TEXTURE_RECTANGLE and GL_TEXTURE_2D. */
+} NV_ENC_INPUT_RESOURCE_OPENGL_TEX;
+
 /**
  * \struct _NV_ENC_REGISTER_RESOURCE
  * Register a resource for future use with the Nvidia Video Encoder Interface.
@@ -1634,7 +1737,11 @@ typedef struct _NV_ENC_MAP_INPUT_RESOURCE
 typedef struct _NV_ENC_REGISTER_RESOURCE
 {
     uint32_t                    version;                        /**< [in]: Struct version. Must be set to ::NV_ENC_REGISTER_RESOURCE_VER. */
-    NV_ENC_INPUT_RESOURCE_TYPE  resourceType;                   /**< [in]: Specifies the type of resource to be registered. Supported values are ::NV_ENC_INPUT_RESOURCE_TYPE_DIRECTX, ::NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR. */
+    NV_ENC_INPUT_RESOURCE_TYPE  resourceType;                   /**< [in]: Specifies the type of resource to be registered.
+                                                                           Supported values are
+                                                                           ::NV_ENC_INPUT_RESOURCE_TYPE_DIRECTX,
+                                                                           ::NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR,
+                                                                           ::NV_ENC_INPUT_RESOURCE_TYPE_OPENGL_TEX */
     uint32_t                    width;                          /**< [in]: Input buffer Width. */
     uint32_t                    height;                         /**< [in]: Input buffer Height. */
     uint32_t                    pitch;                          /**< [in]: Input buffer Pitch.  */
@@ -2734,7 +2841,7 @@ NVENCSTATUS NVENCAPI NvEncUnregisterAsyncEvent                  (void* encoder,
  * mapped resource is returned in the field NV_ENC_MAP_INPUT_RESOURCE::outputResourcePtr.
  * The NvEncodeAPI interface also returns the buffer format of the mapped resource
  * in the field NV_ENC_MAP_INPUT_RESOURCE::outbufferFmt.
- * This function provides synchronization guarantee that any direct3d or cuda
+ * This function provides synchronization guarantee that any graphics or compute
  * work submitted on the input buffer is completed before the buffer is used for encoding.
  * The client should not access any input buffer while they are mapped by the encoder.
  *
@@ -2865,7 +2972,9 @@ NVENCSTATUS NVENCAPI NvEncInvalidateRefFrames(void* encoder, uint64_t invalidRef
  * Opens an encoding session and returns a pointer to the encoder interface in
  * the \p **encoder parameter. The client should start encoding process by calling
  * this API first.
- * The client must pass a pointer to IDirect3DDevice9/CUDA interface in the \p *device parameter.
+ * The client must pass a pointer to IDirect3DDevice9 device or CUDA context in the \p *device parameter.
+ * For the OpenGL interface, \p device must be NULL. An OpenGL context must be current when
+ * calling all NvEncodeAPI functions.
  * If the creation of encoder session fails, the client must call ::NvEncDestroyEncoder API
  * before exiting.
  *
@@ -2892,8 +3001,6 @@ NVENCSTATUS NVENCAPI NvEncOpenEncodeSessionEx                   (NV_ENC_OPEN_ENC
  *
  * Registers a resource with the Nvidia Video Encoder Interface for book keeping.
  * The client is expected to pass the registered resource handle as well, while calling ::NvEncMapInputResource API.
- * This API is not implemented for the DirectX Interface.
- * DirectX based clients need not change their implementation.
  *
  * \param [in] encoder
  *   Pointer to the NVEncodeAPI interface.
@@ -2925,8 +3032,6 @@ NVENCSTATUS NVENCAPI NvEncRegisterResource                      (void* encoder,
  * Unregisters a resource previously registered with the Nvidia Video Encoder Interface.
  * The client is expected to unregister any resource that it has registered with the
  * Nvidia Video Encoder Interface before destroying the resource.
- * This API is not implemented for the DirectX Interface.
- * DirectX based clients need not change their implementation.
  *
  * \param [in] encoder
  *   Pointer to the NVEncodeAPI interface.
diff --git a/mythtv/external/FFmpeg/compat/plan9/head b/mythtv/external/FFmpeg/compat/plan9/head
deleted file mode 100755
index 2840b2d50f9..00000000000
--- a/mythtv/external/FFmpeg/compat/plan9/head
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/bin/sh
-
-n=10
-
-case "$1" in
-    -n)  n=$2;      shift 2 ;;
-    -n*) n=${1#-n}; shift   ;;
-esac
-
-exec sed ${n}q "$@"
diff --git a/mythtv/external/FFmpeg/compat/plan9/printf b/mythtv/external/FFmpeg/compat/plan9/printf
deleted file mode 100755
index 1a70a9e91a9..00000000000
--- a/mythtv/external/FFmpeg/compat/plan9/printf
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/sh
-exec awk "BEGIN { for (i = 2; i < ARGC; i++) printf \"$1\", ARGV[i] }" "$@"
diff --git a/mythtv/external/FFmpeg/compat/strtod.c b/mythtv/external/FFmpeg/compat/strtod.c
index 3a9452eac2b..8b4243b3132 100644
--- a/mythtv/external/FFmpeg/compat/strtod.c
+++ b/mythtv/external/FFmpeg/compat/strtod.c
@@ -25,9 +25,9 @@
 #include "libavutil/avstring.h"
 #include "libavutil/mathematics.h"
 
-static char *check_nan_suffix(char *s)
+static const char *check_nan_suffix(const char *s)
 {
-    char *start = s;
+    const char *start = s;
 
     if (*s++ != '(')
         return start;
@@ -44,7 +44,7 @@ double strtod(const char *, char **);
 
 double avpriv_strtod(const char *nptr, char **endptr)
 {
-    char *end;
+    const char *end;
     double res;
 
     /* Skip leading spaces */
@@ -81,13 +81,13 @@ double avpriv_strtod(const char *nptr, char **endptr)
                !av_strncasecmp(nptr, "+0x", 3)) {
         /* FIXME this doesn't handle exponents, non-integers (float/double)
          * and numbers too large for long long */
-        res = strtoll(nptr, &end, 16);
+        res = strtoll(nptr, (char **)&end, 16);
     } else {
-        res = strtod(nptr, &end);
+        res = strtod(nptr, (char **)&end);
     }
 
     if (endptr)
-        *endptr = end;
+        *endptr = (char *)end;
 
     return res;
 }
diff --git a/mythtv/external/FFmpeg/compat/w32dlfcn.h b/mythtv/external/FFmpeg/compat/w32dlfcn.h
new file mode 100644
index 00000000000..78cc8f4c96d
--- /dev/null
+++ b/mythtv/external/FFmpeg/compat/w32dlfcn.h
@@ -0,0 +1,93 @@
+/*
+ * 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 COMPAT_W32DLFCN_H
+#define COMPAT_W32DLFCN_H
+
+#ifdef _WIN32
+#include <windows.h>
+#if (_WIN32_WINNT < 0x0602) || HAVE_WINRT
+#include "libavutil/wchar_filename.h"
+#endif
+/**
+ * Safe function used to open dynamic libs. This attempts to improve program security
+ * by removing the current directory from the dll search path. Only dll's found in the
+ * executable or system directory are allowed to be loaded.
+ * @param name  The dynamic lib name.
+ * @return A handle to the opened lib.
+ */
+static inline HMODULE win32_dlopen(const char *name)
+{
+#if _WIN32_WINNT < 0x0602
+    // Need to check if KB2533623 is available
+    if (!GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "SetDefaultDllDirectories")) {
+        HMODULE module = NULL;
+        wchar_t *path = NULL, *name_w = NULL;
+        DWORD pathlen;
+        if (utf8towchar(name, &name_w))
+            goto exit;
+        path = (wchar_t *)av_mallocz_array(MAX_PATH, sizeof(wchar_t));
+        // Try local directory first
+        pathlen = GetModuleFileNameW(NULL, path, MAX_PATH);
+        pathlen = wcsrchr(path, '\\') - path;
+        if (pathlen == 0 || pathlen + wcslen(name_w) + 2 > MAX_PATH)
+            goto exit;
+        path[pathlen] = '\\';
+        wcscpy(path + pathlen + 1, name_w);
+        module = LoadLibraryExW(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+        if (module == NULL) {
+            // Next try System32 directory
+            pathlen = GetSystemDirectoryW(path, MAX_PATH);
+            if (pathlen == 0 || pathlen + wcslen(name_w) + 2 > MAX_PATH)
+                goto exit;
+            path[pathlen] = '\\';
+            wcscpy(path + pathlen + 1, name_w);
+            module = LoadLibraryExW(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+        }
+exit:
+        av_free(path);
+        av_free(name_w);
+        return module;
+    }
+#endif
+#ifndef LOAD_LIBRARY_SEARCH_APPLICATION_DIR
+#   define LOAD_LIBRARY_SEARCH_APPLICATION_DIR 0x00000200
+#endif
+#ifndef LOAD_LIBRARY_SEARCH_SYSTEM32
+#   define LOAD_LIBRARY_SEARCH_SYSTEM32        0x00000800
+#endif
+#if HAVE_WINRT
+    wchar_t *name_w = NULL;
+    int ret;
+    if (utf8towchar(name, &name_w))
+        return NULL;
+    ret = LoadPackagedLibrary(name_w, 0);
+    av_free(name_w);
+    return ret;
+#else
+    return LoadLibraryExA(name, NULL, LOAD_LIBRARY_SEARCH_APPLICATION_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32);
+#endif
+}
+#define dlopen(name, flags) win32_dlopen(name)
+#define dlclose FreeLibrary
+#define dlsym GetProcAddress
+#else
+#include <dlfcn.h>
+#endif
+
+#endif /* COMPAT_W32DLFCN_H */
diff --git a/mythtv/external/FFmpeg/compat/w32pthreads.h b/mythtv/external/FFmpeg/compat/w32pthreads.h
index 4ac2a995b84..eeead6051f2 100644
--- a/mythtv/external/FFmpeg/compat/w32pthreads.h
+++ b/mythtv/external/FFmpeg/compat/w32pthreads.h
@@ -77,7 +77,7 @@ typedef struct pthread_cond_t {
 
 static av_unused unsigned __stdcall attribute_align_arg win32thread_worker(void *arg)
 {
-    pthread_t *h = arg;
+    pthread_t *h = (pthread_t*)arg;
     h->ret = h->func(h->arg);
     return 0;
 }
@@ -270,7 +270,7 @@ static av_unused int pthread_cond_init(pthread_cond_t *cond, const void *unused_
     }
 
     /* non native condition variables */
-    win32_cond = av_mallocz(sizeof(win32_cond_t));
+    win32_cond = (win32_cond_t*)av_mallocz(sizeof(win32_cond_t));
     if (!win32_cond)
         return ENOMEM;
     cond->Ptr = win32_cond;
@@ -288,7 +288,7 @@ static av_unused int pthread_cond_init(pthread_cond_t *cond, const void *unused_
 
 static av_unused int pthread_cond_destroy(pthread_cond_t *cond)
 {
-    win32_cond_t *win32_cond = cond->Ptr;
+    win32_cond_t *win32_cond = (win32_cond_t*)cond->Ptr;
     /* native condition variables do not destroy */
     if (cond_init)
         return 0;
@@ -305,7 +305,7 @@ static av_unused int pthread_cond_destroy(pthread_cond_t *cond)
 
 static av_unused int pthread_cond_broadcast(pthread_cond_t *cond)
 {
-    win32_cond_t *win32_cond = cond->Ptr;
+    win32_cond_t *win32_cond = (win32_cond_t*)cond->Ptr;
     int have_waiter;
 
     if (cond_broadcast) {
@@ -337,7 +337,7 @@ static av_unused int pthread_cond_broadcast(pthread_cond_t *cond)
 
 static av_unused int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
 {
-    win32_cond_t *win32_cond = cond->Ptr;
+    win32_cond_t *win32_cond = (win32_cond_t*)cond->Ptr;
     int last_waiter;
     if (cond_wait) {
         cond_wait(cond, mutex, INFINITE);
@@ -369,7 +369,7 @@ static av_unused int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mu
 
 static av_unused int pthread_cond_signal(pthread_cond_t *cond)
 {
-    win32_cond_t *win32_cond = cond->Ptr;
+    win32_cond_t *win32_cond = (win32_cond_t*)cond->Ptr;
     int have_waiter;
     if (cond_signal) {
         cond_signal(cond);
@@ -397,20 +397,20 @@ static av_unused int pthread_cond_signal(pthread_cond_t *cond)
 static av_unused void w32thread_init(void)
 {
 #if _WIN32_WINNT < 0x0600
-    HANDLE kernel_dll = GetModuleHandle(TEXT("kernel32.dll"));
+    HMODULE kernel_dll = GetModuleHandle(TEXT("kernel32.dll"));
     /* if one is available, then they should all be available */
-    cond_init      =
-        (void*)GetProcAddress(kernel_dll, "InitializeConditionVariable");
-    cond_broadcast =
-        (void*)GetProcAddress(kernel_dll, "WakeAllConditionVariable");
-    cond_signal    =
-        (void*)GetProcAddress(kernel_dll, "WakeConditionVariable");
-    cond_wait      =
-        (void*)GetProcAddress(kernel_dll, "SleepConditionVariableCS");
-    initonce_begin =
-        (void*)GetProcAddress(kernel_dll, "InitOnceBeginInitialize");
-    initonce_complete =
-        (void*)GetProcAddress(kernel_dll, "InitOnceComplete");
+    cond_init      = (void (WINAPI*)(pthread_cond_t *))
+        GetProcAddress(kernel_dll, "InitializeConditionVariable");
+    cond_broadcast = (void (WINAPI*)(pthread_cond_t *))
+        GetProcAddress(kernel_dll, "WakeAllConditionVariable");
+    cond_signal    = (void (WINAPI*)(pthread_cond_t *))
+        GetProcAddress(kernel_dll, "WakeConditionVariable");
+    cond_wait      = (BOOL (WINAPI*)(pthread_cond_t *, pthread_mutex_t *, DWORD))
+        GetProcAddress(kernel_dll, "SleepConditionVariableCS");
+    initonce_begin = (BOOL (WINAPI*)(pthread_once_t *, DWORD, BOOL *, void **))
+        GetProcAddress(kernel_dll, "InitOnceBeginInitialize");
+    initonce_complete = (BOOL (WINAPI*)(pthread_once_t *, DWORD, void *))
+        GetProcAddress(kernel_dll, "InitOnceComplete");
 #endif
 
 }
diff --git a/mythtv/external/FFmpeg/configure b/mythtv/external/FFmpeg/configure
index 08707a93a42..1797c5dd4f8 100755
--- a/mythtv/external/FFmpeg/configure
+++ b/mythtv/external/FFmpeg/configure
@@ -63,6 +63,7 @@ Options: [defaults in brackets after descriptions]
 
 Help options:
   --help                   print this message
+  --quiet                  Suppress showing informative output
   --list-decoders          show all available decoders
   --list-encoders          show all available encoders
   --list-hwaccels          show all available hardware accelerators
@@ -76,10 +77,10 @@ Help options:
   --list-filters           show all available filters
 
 Standard options:
-  --logfile=FILE           log tests and output to FILE [config.log]
+  --logfile=FILE           log tests and output to FILE [ffbuild/config.log]
   --disable-logging        do not log configure debug information
   --fatal-warnings         fail if any configure warning is generated
-  --prefix=PREFIX          install in PREFIX [$prefix]
+  --prefix=PREFIX          install in PREFIX [$prefix_default]
   --bindir=DIR             install binaries in DIR [PREFIX/bin]
   --datadir=DIR            install data files in DIR [PREFIX/share/ffmpeg]
   --docdir=DIR             install documentation in DIR [PREFIX/share/doc/ffmpeg]
@@ -90,7 +91,7 @@ Standard options:
   --pkgconfigdir=DIR       install pkg-config files in DIR [LIBDIR/pkgconfig]
   --enable-rpath           use rpath to allow installing libraries in paths
                            not part of the dynamic linker search path
-                           use rpath when linking programs [USE WITH CARE]
+                           use rpath when linking programs (USE WITH CARE)
   --install-name-dir=DIR   Darwin directory name for installed targets
 
 Licensing options:
@@ -104,11 +105,11 @@ Configuration options:
   --disable-static         do not build static libraries [no]
   --enable-shared          build shared libraries [no]
   --enable-small           optimize for size instead of speed
-  --disable-runtime-cpudetect disable detecting cpu capabilities at runtime (smaller binary)
+  --disable-runtime-cpudetect disable detecting CPU capabilities at runtime (smaller binary)
   --enable-gray            enable full grayscale support (slower color)
   --disable-swscale-alpha  disable alpha channel support in swscale
   --disable-all            disable building components, libraries and programs
-  --enable-raise-major     increase major version numbers in sonames [no]
+  --disable-autodetect     disable automatically detected external libraries [no]
 
 Program options:
   --disable-programs       do not build command line programs
@@ -184,6 +185,7 @@ Individual component options:
   --enable-filter=NAME     enable filter NAME
   --disable-filter=NAME    disable filter NAME
   --disable-filters        disable all filters
+  --disable-v4l2_m2m       disable V4L2 mem2mem code [autodetect]
 
 External library support:
 
@@ -200,8 +202,12 @@ External library support:
   Also note that the following help text describes the purpose of the libraries
   themselves, not all their features will necessarily be usable by FFmpeg.
 
+  --disable-alsa           disable ALSA support [autodetect]
+  --disable-appkit         disable Apple AppKit framework [autodetect]
+  --disable-avfoundation   disable Apple AVFoundation framework [autodetect]
   --enable-avisynth        enable reading of AviSynth script files [no]
   --disable-bzlib          disable bzlib [autodetect]
+  --disable-coreimage      disable Apple CoreImage framework [autodetect]
   --enable-chromaprint     enable audio fingerprinting with chromaprint [no]
   --enable-frei0r          enable frei0r video filtering [no]
   --enable-gcrypt          enable gcrypt, needed for rtmp(t)e support
@@ -211,6 +217,7 @@ External library support:
   --enable-gnutls          enable gnutls, needed for https support
                            if openssl is not used [no]
   --disable-iconv          disable iconv [autodetect]
+  --disable-jack           disable libjack support [autodetect]
   --enable-jni             enable JNI support [no]
   --enable-ladspa          enable LADSPA audio filtering [no]
   --enable-libass          enable libass subtitles rendering,
@@ -222,8 +229,6 @@ External library support:
   --enable-libcdio         enable audio CD grabbing with libcdio [no]
   --enable-libdc1394       enable IIDC-1394 grabbing using libdc1394
                            and libraw1394 [no]
-  --enable-libebur128      enable libebur128 for EBU R128 measurement,
-                           needed for loudnorm filter [no]
   --enable-libfdk-aac      enable AAC de/encoding via libfdk-aac [no]
   --enable-libflite        enable flite (voice synthesis) support via libflite [no]
   --enable-libfontconfig   enable libfontconfig, useful for drawtext filter [no]
@@ -236,8 +241,6 @@ External library support:
   --enable-libkvazaar      enable HEVC encoding via libkvazaar [no]
   --enable-libmodplug      enable ModPlug via libmodplug [no]
   --enable-libmp3lame      enable MP3 encoding via libmp3lame [no]
-  --enable-libnut          enable NUT (de)muxing via libnut,
-                           native (de)muxer exists [no]
   --enable-libopencore-amrnb enable AMR-NB de/encoding via libopencore-amrnb [no]
   --enable-libopencore-amrwb enable AMR-WB decoding via libopencore-amrwb [no]
   --enable-libopencv       enable video filtering via libopencv [no]
@@ -246,9 +249,9 @@ External library support:
   --enable-libopenmpt      enable decoding tracked files via libopenmpt [no]
   --enable-libopus         enable Opus de/encoding via libopus [no]
   --enable-libpulse        enable Pulseaudio input via libpulse [no]
+  --enable-librsvg         enable SVG rasterization via librsvg [no]
   --enable-librubberband   enable rubberband needed for rubberband filter [no]
   --enable-librtmp         enable RTMP[E] support via librtmp [no]
-  --enable-libschroedinger enable Dirac de/encoding via libschroedinger [no]
   --enable-libshine        enable fixed-point MP3 encoding via libshine [no]
   --enable-libsmbclient    enable Samba protocol via libsmbclient [no]
   --enable-libsnappy       enable Snappy compression, needed for hap encoding [no]
@@ -260,6 +263,7 @@ External library support:
   --enable-libtwolame      enable MP2 encoding via libtwolame [no]
   --enable-libv4l2         enable libv4l2/v4l-utils [no]
   --enable-libvidstab      enable video stabilization using vid.stab [no]
+  --enable-libvmaf         enable vmaf filter via libvmaf [no]
   --enable-libvo-amrwbenc  enable AMR-WB encoding via libvo-amrwbenc [no]
   --enable-libvorbis       enable Vorbis en/decoding via libvorbis,
                            native implementation exists [no]
@@ -275,39 +279,44 @@ External library support:
   --enable-libxcb-shape    enable X11 grabbing shape rendering [autodetect]
   --enable-libxvid         enable Xvid encoding via xvidcore,
                            native MPEG-4/Xvid encoder exists [no]
+  --enable-libxml2         enable XML parsing using the C library libxml2 [no]
   --enable-libzimg         enable z.lib, needed for zscale filter [no]
   --enable-libzmq          enable message passing via libzmq [no]
   --enable-libzvbi         enable teletext support via libzvbi [no]
   --disable-lzma           disable lzma [autodetect]
   --enable-decklink        enable Blackmagic DeckLink I/O support [no]
+  --enable-libndi_newtek   enable Newteck NDI I/O support [no]
   --enable-mediacodec      enable Android MediaCodec support [no]
-  --enable-netcdf          enable NetCDF, needed for sofalizer filter [no]
+  --enable-libmysofa       enable libmysofa, needed for sofalizer filter [no]
   --enable-openal          enable OpenAL 1.1 capture support [no]
   --enable-opencl          enable OpenCL code
   --enable-opengl          enable OpenGL rendering [no]
   --enable-openssl         enable openssl, needed for https support
                            if gnutls is not used [no]
+  --disable-sndio          disable sndio support [autodetect]
   --disable-schannel       disable SChannel SSP, needed for TLS support on
                            Windows if openssl and gnutls are not used [autodetect]
   --disable-sdl2           disable sdl2 [autodetect]
   --disable-securetransport disable Secure Transport, needed for TLS support
                            on OSX if openssl and gnutls are not used [autodetect]
-  --enable-x11grab         enable X11 grabbing (legacy) [no]
   --disable-xlib           disable xlib [autodetect]
   --disable-zlib           disable zlib [autodetect]
 
   The following libraries provide various hardware acceleration features:
   --disable-audiotoolbox   disable Apple AudioToolbox code [autodetect]
-  --enable-cuda            enable dynamically linked Nvidia CUDA code [no]
-  --enable-cuvid           enable Nvidia CUVID support [autodetect]
+  --disable-cuda           disable dynamically linked Nvidia CUDA code [autodetect]
+  --enable-cuda-sdk        enable CUDA features that require the CUDA SDK [no]
+  --disable-cuvid          disable Nvidia CUVID support [autodetect]
   --disable-d3d11va        disable Microsoft Direct3D 11 video acceleration code [autodetect]
   --disable-dxva2          disable Microsoft DirectX 9 video acceleration code [autodetect]
+  --enable-libdrm          enable DRM code (Linux) [no]
   --enable-libmfx          enable Intel MediaSDK (AKA Quick Sync Video) code via libmfx [no]
   --enable-libnpp          enable Nvidia Performance Primitives-based code [no]
   --enable-mmal            enable Broadcom Multi-Media Abstraction Layer (Raspberry Pi) via MMAL [no]
   --disable-nvenc          disable Nvidia video encoding code [autodetect]
   --enable-omx             enable OpenMAX IL code [no]
   --enable-omx-rpi         enable OpenMAX IL code for Raspberry Pi [no]
+  --enable-rkmpp           enable Rockchip Media Process Platform code [no]
   --disable-vaapi          disable Video Acceleration API (mainly Unix/Intel) code [autodetect]
   --disable-vda            disable Apple Video Decode Acceleration code [autodetect]
   --disable-vdpau          disable Nvidia Video Decode and Presentation API for Unix code [autodetect]
@@ -334,11 +343,12 @@ Toolchain options:
   --ln_s=LN_S              use symbolic link tool LN_S [$ln_s_default]
   --strip=STRIP            use strip tool STRIP [$strip_default]
   --windres=WINDRES        use windows resource compiler WINDRES [$windres_default]
-  --yasmexe=EXE            use yasm-compatible assembler EXE [$yasmexe_default]
+  --x86asmexe=EXE          use nasm-compatible assembler EXE [$x86asmexe_default]
   --cc=CC                  use C compiler CC [$cc_default]
   --cxx=CXX                use C compiler CXX [$cxx_default]
   --objcc=OCC              use ObjC compiler OCC [$cc_default]
   --dep-cc=DEPCC           use dependency generator DEPCC [$cc_default]
+  --nvcc=NVCC              use Nvidia CUDA compiler NVCC [$nvcc_default]
   --ld=LD                  use linker LD [$ld_default]
   --pkg-config=PKGCONFIG   use pkg-config tool PKGCONFIG [$pkg_config_default]
   --pkg-config-flags=FLAGS pass additional flags to pkgconf []
@@ -360,6 +370,7 @@ Toolchain options:
   --extra-libs=ELIBS       add ELIBS [$ELIBS]
   --extra-version=STRING   version string suffix []
   --optflags=OPTFLAGS      override optimization-related compiler flags
+  --nvccflags=NVCCFLAGS    override nvcc flags [$nvccflags_default]
   --build-suffix=SUFFIX    library name suffix []
   --enable-pic             build position-independent code
   --enable-thumb           compile for Thumb instruction set
@@ -374,7 +385,6 @@ Advanced options (experts only):
   --disable-safe-bitstream-reader
                            disable buffer boundary checking in bitreaders
                            (faster, but may crash)
-  --enable-memalign-hack   emulate memalign, interferes with memory debuggers
   --sws-max-filter-size=N  the max filter size swscale uses [$sws_max_filter_size_default]
 
 Optimization options (experts only):
@@ -404,7 +414,7 @@ Optimization options (experts only):
   --disable-vfp            disable VFP optimizations
   --disable-neon           disable NEON optimizations
   --disable-inline-asm     disable use of inline assembly
-  --disable-yasm           disable use of nasm/yasm assembly
+  --disable-x86asm         disable use of standalone x86 assembly
   --disable-mipsdsp        disable MIPS DSP ASE R1 optimizations
   --disable-mipsdspr2      disable MIPS DSP ASE R2 optimizations
   --disable-msa            disable MSA optimizations
@@ -441,6 +451,11 @@ Developer options (useful when working on FFmpeg itself):
   --random-seed=VALUE      seed value for --enable/disable-random
   --disable-valgrind-backtrace do not print a backtrace under Valgrind
                            (only applies to --disable-optimizations builds)
+  --enable-osfuzz          Enable building fuzzer tool
+  --libfuzzer=PATH         path to libfuzzer
+  --ignore-tests=TESTS     comma-separated list (without "fate-" prefix
+                           in the name) of tests whose result is ignored
+  --enable-linux-perf      enable Linux Performance Monitor API
 
 NOTE: Object files are built at the place where configure is launched.
 EOF
@@ -526,7 +541,7 @@ filter(){
     pat=$1
     shift
     for v; do
-        eval "case $v in $pat) echo $v ;; esac"
+        eval "case $v in $pat) printf '%s ' $v ;; esac"
     done
 }
 
@@ -534,7 +549,7 @@ filter_out(){
     pat=$1
     shift
     for v; do
-        eval "case $v in $pat) ;; *) echo $v ;; esac"
+        eval "case $v in $pat) ;; *) printf '%s ' $v ;; esac"
     done
 }
 
@@ -599,6 +614,13 @@ popvar(){
     done
 }
 
+request(){
+    for var in $*; do
+        eval ${var}_requested=yes
+        eval $var=
+    done
+}
+
 enable(){
     set_all yes $*
 }
@@ -655,6 +677,11 @@ enable_deep_weak(){
     done
 }
 
+requested(){
+    test "${1#!}" = "$1" && op='=' || op=!=
+    eval test "x\$${1#!}_requested" $op "xyes"
+}
+
 enabled(){
     test "${1#!}" = "$1" && op='=' || op=!=
     eval test "x\$${1#!}" $op "xyes"
@@ -707,7 +734,6 @@ is_in(){
 
 do_check_deps(){
     for cfg; do
-        cfg="${cfg#!}"
         enabled ${cfg}_checking && die "Circular dependency for $cfg."
         disabled ${cfg}_checking && continue
         enable ${cfg}_checking
@@ -715,20 +741,22 @@ do_check_deps(){
 
         eval dep_all="\$${cfg}_deps"
         eval dep_any="\$${cfg}_deps_any"
+        eval dep_con="\$${cfg}_conflict"
         eval dep_sel="\$${cfg}_select"
         eval dep_sgs="\$${cfg}_suggest"
         eval dep_ifa="\$${cfg}_if"
         eval dep_ifn="\$${cfg}_if_any"
 
-        pushvar cfg dep_all dep_any dep_sel dep_sgs dep_ifa dep_ifn
-        do_check_deps $dep_all $dep_any $dep_sel $dep_sgs $dep_ifa $dep_ifn
-        popvar cfg dep_all dep_any dep_sel dep_sgs dep_ifa dep_ifn
+        pushvar cfg dep_all dep_any dep_con dep_sel dep_sgs dep_ifa dep_ifn
+        do_check_deps $dep_all $dep_any $dep_con $dep_sel $dep_sgs $dep_ifa $dep_ifn
+        popvar cfg dep_all dep_any dep_con dep_sel dep_sgs dep_ifa dep_ifn
 
         [ -n "$dep_ifa" ] && { enabled_all $dep_ifa && enable_weak $cfg; }
         [ -n "$dep_ifn" ] && { enabled_any $dep_ifn && enable_weak $cfg; }
-        enabled_all  $dep_all || disable $cfg
-        enabled_any  $dep_any || disable $cfg
-        disabled_any $dep_sel && disable $cfg
+        enabled_all  $dep_all || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but not all dependencies are satisfied: $dep_all"; }
+        enabled_any  $dep_any || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but not any dependency is satisfied: $dep_any"; }
+        disabled_all $dep_con || { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but some conflicting dependencies are unsatisfied: $dep_con"; }
+        disabled_any $dep_sel && { disable $cfg && requested $cfg && die "ERROR: $cfg requested, but some selected dependency is unsatisfied: $dep_sel"; }
 
         if enabled $cfg; then
             enable_deep $dep_sel
@@ -819,6 +847,10 @@ add_cflags(){
     append CFLAGS $($cflags_filter "$@")
 }
 
+add_cflags_headers(){
+    append CFLAGS_HEADERS $($cflags_filter "$@")
+}
+
 add_cxxflags(){
     append CXXFLAGS $($cflags_filter "$@")
 }
@@ -962,12 +994,12 @@ check_insn(){
     echo "$2" | check_as && enable ${1}_external || disable ${1}_external
 }
 
-check_yasm(){
-    log check_yasm "$@"
+check_x86asm(){
+    log check_x86asm "$@"
     echo "$1" > $TMPS
     log_file $TMPS
     shift 1
-    check_cmd $yasmexe $YASMFLAGS -Werror "$@" -o $TMPO $TMPS
+    check_cmd $x86asmexe $X86ASMFLAGS -Werror "$@" -o $TMPO $TMPS
 }
 
 ld_o(){
@@ -1009,8 +1041,8 @@ check_code(){
 
 check_cppflags(){
     log check_cppflags "$@"
-    check_cc "$@" <<EOF && append CPPFLAGS "$@"
-int x;
+    check_cpp "$@" <<EOF && append CPPFLAGS "$@"
+#include <stdlib.h>
 EOF
 }
 
@@ -1036,15 +1068,15 @@ EOF
 }
 
 test_objcflags(){
-    log test_cflags "$@"
-    set -- $($cflags_filter "$@")
+    log test_objcflags "$@"
+    set -- $($objcflags_filter "$@")
     check_objcc "$@" <<EOF
 int x;
 EOF
 }
 
 check_objcflags(){
-    log check_cflags "$@"
+    log check_objcflags "$@"
     test_objcflags "$@" && add_objcflags "$@"
 }
 
@@ -1094,7 +1126,16 @@ check_header_objcc(){
     {
        echo "#include <$header>"
        echo "int main(void) { return 0; }"
-    } | check_objcc && check_stat "$TMPO" && enable_safe $headers
+    } | check_objcc && check_stat "$TMPO" && enable_safe $header
+}
+
+check_apple_framework(){
+    log check_apple_framework "$@"
+    framework="$1"
+    name="$(tolower $framework)"
+    header="${framework}/${framework}.h"
+    disable $name
+    check_header_objcc $header && enable $name && add_extralibs "-framework $framework"
 }
 
 check_func(){
@@ -1146,10 +1187,16 @@ check_func_headers(){
         for hdr in $headers; do
             print_include $hdr
         done
+        echo "#include <stdint.h>"
         for func in $funcs; do
             echo "long check_$func(void) { return (long) $func; }"
         done
-        echo "int main(void) { return 0; }"
+        echo "int main(void) { int ret = 0;"
+        # LTO could optimize out the test functions without this
+        for func in $funcs; do
+            echo " ret |= ((intptr_t)check_$func) & 0xFFFF;"
+        done
+        echo "return ret; }"
     } | check_ld "cc" "$@" && enable $funcs && enable_safe $headers
 }
 
@@ -1185,20 +1232,30 @@ check_cpp_condition(){
 EOF
 }
 
-check_lib(){
-    log check_lib "$@"
-    header="$1"
-    func="$2"
-    shift 2
-    check_header $header && check_func $func "$@" && add_extralibs "$@"
+test_cflags_cc(){
+    log test_cflags_cc "$@"
+    flags=$1
+    header=$2
+    condition=$3
+    shift 3
+    set -- $($cflags_filter "$flags")
+    check_cc "$@" <<EOF
+#include <$header>
+#if !($condition)
+#error "unsatisfied condition: $condition"
+#endif
+EOF
 }
 
-check_lib2(){
-    log check_lib2 "$@"
-    headers="$1"
-    funcs="$2"
-    shift 2
-    check_func_headers "$headers" "$funcs" "$@" && add_extralibs "$@"
+check_lib(){
+    log check_lib "$@"
+    name="$1"
+    headers="$2"
+    funcs="$3"
+    shift 3
+    disable $name
+    check_func_headers "$headers" "$funcs" "$@" &&
+        enable $name && add_extralibs "$@"
 }
 
 check_lib_cpp(){
@@ -1211,17 +1268,20 @@ check_lib_cpp(){
 
 check_pkg_config(){
     log check_pkg_config "$@"
-    pkgandversion="$1"
-    pkg="${1%% *}"
-    headers="$2"
-    funcs="$3"
-    shift 3
-    check_cmd $pkg_config --exists --print-errors $pkgandversion || return
+    name="$1"
+    pkg_version="$2"
+    pkg="${2%% *}"
+    headers="$3"
+    funcs="$4"
+    shift 4
+    disable $name
+    check_cmd $pkg_config --exists --print-errors $pkg_version || return
     pkg_cflags=$($pkg_config --cflags $pkg_config_flags $pkg)
     pkg_libs=$($pkg_config --libs $pkg_config_flags $pkg)
     check_func_headers "$headers" "$funcs" $pkg_cflags $pkg_libs "$@" &&
-        set_safe "${pkg}_cflags" $pkg_cflags   &&
-        set_safe "${pkg}_libs"   $pkg_libs
+        enable $name &&
+        set_safe "${pkg}_cflags"    $pkg_cflags &&
+        set_safe "${pkg}_extralibs" $pkg_libs
 }
 
 check_exec(){
@@ -1229,6 +1289,7 @@ check_exec(){
 }
 
 check_exec_crash(){
+    log check_exec_crash "$@"
     code=$(cat)
 
     # exit() is not async signal safe.  _Exit (C99) and _exit (POSIX)
@@ -1299,19 +1360,13 @@ check_compile_assert(){
 }
 
 require(){
-    name="$1"
-    header="$2"
-    func="$3"
-    shift 3
-    check_lib $header $func "$@" || die "ERROR: $name not found"
-}
-
-require2(){
-    name="$1"
+    log require "$@"
+    name_version="$1"
+    name="${1%% *}"
     headers="$2"
     func="$3"
     shift 3
-    check_lib2 "$headers" $func "$@" || die "ERROR: $name not found"
+    check_lib $name "$headers" $func "$@" || die "ERROR: $name_version not found"
 }
 
 require_cpp(){
@@ -1322,35 +1377,33 @@ require_cpp(){
     check_lib_cpp "$headers" "$classes" "$@" || die "ERROR: $name not found"
 }
 
+require_header(){
+    log require "$@"
+    header="$1"
+    shift
+    check_header "$header" "$@" || die "ERROR: $header header not found"
+}
+
+require_cpp_condition(){
+    log require "$@"
+    header="$1"
+    condition="$2"
+    shift 2
+    check_cpp_condition "$header" "$condition" "$@" || die "ERROR: $condition not satisfied"
+}
+
 use_pkg_config(){
-    pkg="$1"
+    log use_pkg_config "$@"
+    pkg="${2%% *}"
     check_pkg_config "$@" || return 1
     add_cflags    $(get_safe "${pkg}_cflags")
-    add_extralibs $(get_safe "${pkg}_libs")
+    add_extralibs $(get_safe "${pkg}_extralibs")
 }
 
 require_pkg_config(){
-    use_pkg_config "$@" || die "ERROR: $pkg not found using pkg-config$pkg_config_fail_message"
-}
-
-require_libfreetype(){
-    log require_libfreetype "$@"
-    pkg="freetype2"
-    check_cmd $pkg_config --exists --print-errors $pkg \
-      || die "ERROR: $pkg not found"
-    pkg_cflags=$($pkg_config --cflags $pkg_config_flags $pkg)
-    pkg_libs=$($pkg_config --libs $pkg_config_flags $pkg)
-    {
-        echo "#include <ft2build.h>"
-        echo "#include FT_FREETYPE_H"
-        echo "long check_func(void) { return (long) FT_Init_FreeType; }"
-        echo "int main(void) { return 0; }"
-    } | check_ld "cc" $pkg_cflags $pkg_libs \
-      && set_safe "${pkg}_cflags" $pkg_cflags \
-      && set_safe "${pkg}_libs"   $pkg_libs \
-      || die "ERROR: $pkg not found"
-    add_cflags    $(get_safe "${pkg}_cflags")
-    add_extralibs $(get_safe "${pkg}_libs")
+    log require_pkg_config "$@"
+    pkg_version="$2"
+    use_pkg_config "$@" || die "ERROR: $pkg_version not found using pkg-config$pkg_config_fail_message"
 }
 
 hostcc_e(){
@@ -1377,8 +1430,8 @@ check_host_cpp(){
 
 check_host_cppflags(){
     log check_host_cppflags "$@"
-    check_host_cc "$@" <<EOF && append host_cppflags "$@"
-int x;
+    check_host_cpp "$@" <<EOF && append host_cppflags "$@"
+#include <stdlib.h>
 EOF
 }
 
@@ -1404,9 +1457,9 @@ EOF
 }
 
 cp_if_changed(){
-    cmp -s "$1" "$2" && echo "$2 is unchanged" && return
+    cmp -s "$1" "$2" && { test "$quiet" != "yes" && echo "$2 is unchanged"; } && return
     mkdir -p "$(dirname $2)"
-    $cp_f "$1" "$2"
+    cp -f "$1" "$2"
 }
 
 # CONFIG_LIST contains configurable options, while HAVE_LIST is for
@@ -1424,9 +1477,11 @@ AVDEVICE_COMPONENTS="
     indevs
     outdevs
 "
+
 AVFILTER_COMPONENTS="
     filters
 "
+
 AVFORMAT_COMPONENTS="
     demuxers
     muxers
@@ -1434,6 +1489,7 @@ AVFORMAT_COMPONENTS="
 "
 
 AVRESAMPLE_COMPONENTS=""
+
 AVUTIL_COMPONENTS=""
 
 COMPONENT_LIST="
@@ -1448,13 +1504,17 @@ COMPONENT_LIST="
 EXAMPLE_LIST="
     avio_dir_cmd_example
     avio_reading_example
-    decoding_encoding_example
+    decode_audio_example
+    decode_video_example
     demuxing_decoding_example
+    encode_audio_example
+    encode_video_example
     extract_mvs_example
     filter_audio_example
     filtering_audio_example
     filtering_video_example
     http_multiclient_example
+    hw_decode_example
     metadata_example
     muxing_example
     qsvdec_example
@@ -1465,28 +1525,76 @@ EXAMPLE_LIST="
     transcoding_example
 "
 
-EXTERNAL_LIBRARY_LIST="
-    avisynth
+EXTERNAL_AUTODETECT_LIBRARY_LIST="
+    alsa
+    appkit
+    avfoundation
     bzlib
-    chromaprint
-    crystalhd
-    decklink
+    coreimage
+    iconv
+    jack
+    libxcb
+    libxcb_shm
+    libxcb_shape
+    libxcb_xfixes
+    lzma
+    schannel
+    sdl2
+    securetransport
+    sndio
+    xlib
+    zlib
+"
+
+EXTERNAL_LIBRARY_GPL_LIST="
+    avisynth
     frei0r
-    gcrypt
+    libcdio
+    librubberband
+    libvidstab
+    libx264
+    libx265
+    libxavs
+    libxvid
+"
+
+EXTERNAL_LIBRARY_NONFREE_LIST="
+    decklink
+    libndi_newtek
+    libfdk_aac
+    openssl
+"
+
+EXTERNAL_LIBRARY_VERSION3_LIST="
     gmp
+    libopencore_amrnb
+    libopencore_amrwb
+    libvo_amrwbenc
+    rkmpp
+"
+
+EXTERNAL_LIBRARY_GPLV3_LIST="
+    libsmbclient
+"
+
+EXTERNAL_LIBRARY_LIST="
+    $EXTERNAL_AUTODETECT_LIBRARY_LIST
+    $EXTERNAL_LIBRARY_GPL_LIST
+    $EXTERNAL_LIBRARY_NONFREE_LIST
+    $EXTERNAL_LIBRARY_VERSION3_LIST
+    $EXTERNAL_LIBRARY_GPLV3_LIST
+    chromaprint
+    gcrypt
     gnutls
-    iconv
     jni
     ladspa
     libass
     libbluray
     libbs2b
     libcaca
-    libcdio
     libcelt
     libdc1394
-    libebur128
-    libfdk_aac
+    libdrm
     libflite
     libfontconfig
     libfreetype
@@ -1498,18 +1606,15 @@ EXTERNAL_LIBRARY_LIST="
     libkvazaar
     libmodplug
     libmp3lame
-    libnut
-    libopencore_amrnb
-    libopencore_amrwb
+    libmysofa
     libopencv
     libopenh264
     libopenjpeg
     libopenmpt
     libopus
     libpulse
+    librsvg
     librtmp
-    librubberband
-    libschroedinger
     libshine
     libsmbclient
     libsnappy
@@ -1520,58 +1625,50 @@ EXTERNAL_LIBRARY_LIST="
     libtheora
     libtwolame
     libv4l2
-    libvidstab
-    libvo_amrwbenc
+    libvmaf
     libvorbis
     libvpx
     libwavpack
     libwebp
-    libx264
-    libx265
-    libxavs
-    libxcb
-    libxcb_shm
-    libxcb_shape
-    libxcb_xfixes
-    libxvid
+    libxml2
     libzimg
     libzmq
     libzvbi
-    lzma
     mediacodec
-    netcdf
     openal
     opencl
     opengl
-    openssl
-    schannel
-    sdl
-    sdl2
-    securetransport
-    videotoolbox
-    x11grab
-    xlib
-    zlib
 "
 
-HWACCEL_LIBRARY_LIST="
+HWACCEL_AUTODETECT_LIBRARY_LIST="
     audiotoolbox
+    crystalhd
     cuda
     cuvid
     d3d11va
     dxva2
-    libmfx
-    libnpp
-    mmal
     nvenc
-    omx
     vaapi
     vda
     vdpau
-    videotoolbox_hwaccel
+    videotoolbox
+    v4l2_m2m
     xvmc
 "
 
+HWACCEL_LIBRARY_NONFREE_LIST="
+    cuda_sdk
+    libnpp
+"
+
+HWACCEL_LIBRARY_LIST="
+    $HWACCEL_AUTODETECT_LIBRARY_LIST
+    $HWACCEL_LIBRARY_NONFREE_LIST
+    libmfx
+    mmal
+    omx
+"
+
 DOCUMENT_LIST="
     doc
     htmlpages
@@ -1633,8 +1730,8 @@ SUBSYSTEM_LIST="
     rdft
 "
 
+# COMPONENT_LIST needs to come last to ensure correct dependency checking
 CONFIG_LIST="
-    $COMPONENT_LIST
     $DOCUMENT_LIST
     $EXAMPLE_LIST
     $EXTERNAL_LIBRARY_LIST
@@ -1644,16 +1741,17 @@ CONFIG_LIST="
     $LIBRARY_LIST
     $PROGRAM_LIST
     $SUBSYSTEM_LIST
+    autodetect
     fontconfig
-    memalign_hack
+    linux_perf
     memory_poisoning
     neon_clobber_test
+    ossfuzz
     pic
-    pod2man
-    raise_major
     thumb
     valgrind_backtrace
     xmm_clobber_test
+    $COMPONENT_LIST
 "
 
 THREADS_LIST="
@@ -1668,6 +1766,12 @@ ATOMICS_LIST="
     atomics_win32
 "
 
+AUTODETECT_LIBS="
+    $EXTERNAL_AUTODETECT_LIBRARY_LIST
+    $HWACCEL_AUTODETECT_LIBRARY_LIST
+    $THREADS_LIST
+"
+
 ARCH_LIST="
     aarch64
     alpha
@@ -1775,11 +1879,11 @@ ARCH_FEATURES="
     local_aligned_16
     local_aligned_32
     simd_align_16
+    simd_align_32
 "
 
 BUILTIN_LIST="
     atomic_cas_ptr
-    atomic_compare_exchange
     machine_rw_barrier
     MemoryBarrier
     mm_empty
@@ -1791,7 +1895,7 @@ BUILTIN_LIST="
 HAVE_LIST_CMDLINE="
     inline_asm
     symver
-    yasm
+    x86asm
 "
 
 HAVE_LIST_PUB="
@@ -1800,12 +1904,13 @@ HAVE_LIST_PUB="
 "
 
 HEADERS_LIST="
-    alsa_asoundlib_h
     altivec_h
     arpa_inet_h
     asm_types_h
     cdio_paranoia_h
     cdio_paranoia_paranoia_h
+    cuda_h
+    d3d11_h
     dispatch_dispatch_h
     dev_bktr_ioctl_bt848_h
     dev_bktr_ioctl_meteor_h
@@ -1815,7 +1920,7 @@ HEADERS_LIST="
     direct_h
     dirent_h
     dlfcn_h
-    d3d11_h
+    dxgidebug_h
     dxva_h
     ES2_gl_h
     gsm_h
@@ -1825,13 +1930,15 @@ HEADERS_LIST="
     machine_ioctl_meteor_h
     malloc_h
     opencv2_core_core_c_h
+    openjpeg_2_3_openjpeg_h
+    openjpeg_2_2_openjpeg_h
     openjpeg_2_1_openjpeg_h
     openjpeg_2_0_openjpeg_h
     openjpeg_1_5_openjpeg_h
     OpenGL_gl3_h
     poll_h
-    sndio_h
     soundcard_h
+    stdatomic_h
     sys_mman_h
     sys_param_h
     sys_resource_h
@@ -1898,7 +2005,6 @@ SYSTEM_FUNCS="
     CommandLineToArgvW
     CoTaskMemFree
     CryptGenRandom
-    dlopen
     fcntl
     flt_lim
     fork
@@ -1949,11 +2055,13 @@ SYSTEM_FUNCS="
 
 TOOLCHAIN_FEATURES="
     as_dn_directive
+    as_fpu_directive
     as_func
     as_object_arch
     asm_mod_q
     attribute_may_alias
     attribute_packed
+    blocks_extension
     ebp_available
     ebx_available
     gnu_as
@@ -1973,6 +2081,7 @@ TOOLCHAIN_FEATURES="
 
 TYPES_LIST="
     CONDITION_VARIABLE_Ptr
+    kCMVideoCodecType_HEVC
     socklen_t
     struct_addrinfo
     struct_group_source_req
@@ -2008,25 +2117,20 @@ HAVE_LIST="
     $TYPES_LIST
     atomics_native
     dos_paths
-    dxva2_lib
-    dxva2api_cobj
     libc_msvcrt
-    libdc1394_1
-    libdc1394_2
     makeinfo
     makeinfo_html
     MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS
     perl
     pod2man
-    sdl2
     section_data_rel_ro
     texi2html
     threads
+    uwp
     vaapi_drm
     vaapi_x11
     vdpau_x11
     winrt
-    xlib
 "
 
 # options emitted with CONFIG_ prefix but not available on the command line
@@ -2053,15 +2157,17 @@ CONFIG_EXTRA="
     h263dsp
     h264chroma
     h264dsp
+    h264parse
     h264pred
     h264qpel
+    hevcparse
     hpeldsp
     huffman
     huffyuvdsp
     huffyuvencdsp
     idctdsp
     iirfilter
-    imdct15
+    mdct15
     intrax8
     iso_media
     ividsp
@@ -2070,12 +2176,14 @@ CONFIG_EXTRA="
     libx262
     llauddsp
     llviddsp
+    llvidencdsp
     lpc
     lzf
     me_cmp
     mpeg_er
     mpegaudio
     mpegaudiodsp
+    mpegaudioheader
     mpegvideo
     mpegvideoenc
     mss34dsp
@@ -2097,13 +2205,13 @@ CONFIG_EXTRA="
     texturedsp
     texturedspenc
     tpeldsp
+    vaapi_1
     vaapi_encode
     vc1dsp
     videodsp
     vp3dsp
     vp56dsp
     vp8dsp
-    vt_bt2020
     wma_freqs
     wmv2dsp
 "
@@ -2157,10 +2265,11 @@ CMDLINE_SET="
     gas
     host_cc
     host_cflags
+    host_extralibs
     host_ld
     host_ldflags
-    host_libs
     host_os
+    ignore_tests
     install
     ld
     ln_s
@@ -2168,6 +2277,7 @@ CMDLINE_SET="
     malloc_prefix
     nm
     optflags
+    nvccflags
     pkg_config
     pkg_config_flags
     progs_suffix
@@ -2185,7 +2295,7 @@ CMDLINE_SET="
     tempprefix
     toolchain
     valgrind
-    yasmexe
+    x86asmexe
 "
 
 CMDLINE_APPEND="
@@ -2253,7 +2363,7 @@ fma3_deps="avx"
 fma4_deps="avx"
 avx2_deps="avx"
 
-mmx_external_deps="yasm"
+mmx_external_deps="x86asm"
 mmx_inline_deps="inline_asm"
 mmx_suggest="mmx_external mmx_inline"
 
@@ -2269,13 +2379,15 @@ fast_64bit_if_any="aarch64 alpha ia64 mips64 parisc64 ppc64 sparc64 x86_64"
 fast_clz_if_any="aarch64 alpha avr32 mips ppc x86"
 fast_unaligned_if_any="aarch64 ppc x86"
 simd_align_16_if_any="altivec neon sse"
+simd_align_32_if_any="avx"
 
 # system capabilities
 symver_if_any="symver_asm_label symver_gnu_asm"
-valgrind_backtrace_deps="!optimizations valgrind_valgrind_h"
+valgrind_backtrace_conflict="optimizations"
+valgrind_backtrace_deps="valgrind_valgrind_h"
 
 # threading support
-atomics_gcc_if_any="sync_val_compare_and_swap atomic_compare_exchange"
+atomics_gcc_if="sync_val_compare_and_swap"
 atomics_suncc_if="atomic_cas_ptr machine_rw_barrier"
 atomics_win32_if="MemoryBarrier"
 atomics_native_if_any="$ATOMICS_LIST"
@@ -2289,12 +2401,14 @@ error_resilience_select="me_cmp"
 faandct_deps="faan fdctdsp"
 faanidct_deps="faan idctdsp"
 h264dsp_select="startcode"
+hevcparse_select="golomb"
 frame_thread_encoder_deps="encoders threads"
 intrax8_select="blockdsp idctdsp"
 mdct_select="fft"
+mdct15_select="fft"
 me_cmp_select="fdctdsp idctdsp pixblockdsp"
 mpeg_er_select="error_resilience"
-mpegaudio_select="mpegaudiodsp"
+mpegaudio_select="mpegaudiodsp mpegaudioheader"
 mpegaudiodsp_select="dct"
 mpegvideo_select="blockdsp h264chroma hpeldsp idctdsp me_cmp mpeg_er videodsp"
 mpegvideoenc_select="me_cmp mpegvideo pixblockdsp qpeldsp"
@@ -2302,7 +2416,7 @@ vc1dsp_select="h264chroma qpeldsp startcode"
 rdft_select="fft"
 
 # decoders / encoders
-aac_decoder_select="imdct15 mdct sinewin"
+aac_decoder_select="mdct15 mdct sinewin"
 aac_fixed_decoder_select="mdct sinewin"
 aac_encoder_select="audio_frame_queue iirfilter lpc mdct sinewin"
 aac_latm_decoder_select="aac_decoder aac_latm_parser"
@@ -2321,7 +2435,7 @@ amv_decoder_select="sp5x_decoder exif"
 amv_encoder_select="aandcttables jpegtables mpegvideoenc"
 ape_decoder_select="bswapdsp llauddsp"
 apng_decoder_select="zlib"
-apng_encoder_select="huffyuvencdsp zlib"
+apng_encoder_select="llvidencdsp zlib"
 asv1_decoder_select="blockdsp bswapdsp idctdsp"
 asv1_encoder_select="bswapdsp fdctdsp pixblockdsp"
 asv2_decoder_select="blockdsp bswapdsp idctdsp"
@@ -2334,6 +2448,7 @@ bink_decoder_select="blockdsp hpeldsp"
 binkaudio_dct_decoder_select="mdct rdft dct sinewin wma_freqs"
 binkaudio_rdft_decoder_select="mdct rdft sinewin wma_freqs"
 cavs_decoder_select="blockdsp golomb h264chroma idctdsp qpeldsp videodsp"
+clearvideo_decoder_select="idctdsp"
 cllc_decoder_select="bswapdsp"
 comfortnoise_encoder_select="lpc"
 cook_decoder_select="audiodsp mdct sinewin"
@@ -2344,6 +2459,7 @@ dds_decoder_select="texturedsp"
 dirac_decoder_select="dirac_parse dwt golomb videodsp mpegvideoenc"
 dnxhd_decoder_select="blockdsp idctdsp"
 dnxhd_encoder_select="aandcttables blockdsp fdctdsp idctdsp mpegvideoenc pixblockdsp"
+dolby_e_decoder_select="mdct"
 dvvideo_decoder_select="dvprofile idctdsp"
 dvvideo_encoder_select="dvprofile fdctdsp me_cmp pixblockdsp"
 dxa_decoder_select="zlib"
@@ -2354,13 +2470,13 @@ eamad_decoder_select="aandcttables blockdsp bswapdsp idctdsp mpegvideo"
 eatgq_decoder_select="aandcttables"
 eatqi_decoder_select="aandcttables blockdsp bswapdsp idctdsp"
 exr_decoder_select="zlib"
-ffv1_decoder_select="golomb rangecoder"
+ffv1_decoder_select="rangecoder"
 ffv1_encoder_select="rangecoder"
 ffvhuff_decoder_select="huffyuv_decoder"
 ffvhuff_encoder_select="huffyuv_encoder"
 fic_decoder_select="golomb"
-flac_decoder_select="flacdsp golomb"
-flac_encoder_select="bswapdsp flacdsp golomb lpc"
+flac_decoder_select="flacdsp"
+flac_encoder_select="bswapdsp flacdsp lpc"
 flashsv2_decoder_select="zlib"
 flashsv2_encoder_select="zlib"
 flashsv_decoder_select="zlib"
@@ -2378,36 +2494,33 @@ h263_encoder_select="aandcttables h263dsp mpegvideoenc"
 h263i_decoder_select="h263_decoder"
 h263p_decoder_select="h263_decoder"
 h263p_encoder_select="h263_encoder"
-h264_decoder_select="cabac golomb h264chroma h264dsp h264pred h264qpel videodsp"
+h264_decoder_select="cabac golomb h264chroma h264dsp h264parse h264pred h264qpel videodsp"
 h264_decoder_suggest="error_resilience"
 hap_decoder_select="snappy texturedsp"
 hap_encoder_deps="libsnappy"
 hap_encoder_select="texturedspenc"
-hevc_decoder_select="bswapdsp cabac golomb videodsp"
+hevc_decoder_select="bswapdsp cabac golomb hevcparse videodsp"
 huffyuv_decoder_select="bswapdsp huffyuvdsp llviddsp"
-huffyuv_encoder_select="bswapdsp huffman huffyuvencdsp llviddsp"
+huffyuv_encoder_select="bswapdsp huffman huffyuvencdsp llvidencdsp"
 iac_decoder_select="imc_decoder"
 imc_decoder_select="bswapdsp fft mdct sinewin"
 indeo3_decoder_select="hpeldsp"
 indeo4_decoder_select="ividsp"
 indeo5_decoder_select="ividsp"
 interplay_video_decoder_select="hpeldsp"
-jpegls_decoder_select="golomb mjpeg_decoder"
-jpegls_encoder_select="golomb"
+jpegls_decoder_select="mjpeg_decoder"
 jv_decoder_select="blockdsp"
-lagarith_decoder_select="huffyuvdsp"
-ljpeg_encoder_select="aandcttables idctdsp jpegtables"
-loco_decoder_select="golomb"
-magicyuv_decoder_select="huffyuvdsp"
+lagarith_decoder_select="llviddsp"
+ljpeg_encoder_select="aandcttables idctdsp jpegtables mpegvideoenc"
+magicyuv_decoder_select="llviddsp"
 mdec_decoder_select="blockdsp idctdsp mpegvideo"
 metasound_decoder_select="lsp mdct sinewin"
 mimic_decoder_select="blockdsp bswapdsp hpeldsp idctdsp"
 mjpeg_decoder_select="blockdsp hpeldsp exif idctdsp jpegtables"
 mjpeg_encoder_select="aandcttables jpegtables mpegvideoenc"
 mjpegb_decoder_select="mjpeg_decoder"
-mjpeg_vaapi_encoder_deps="VAEncPictureParameterBufferJPEG"
-mjpeg_vaapi_encoder_select="vaapi_encode jpegtables"
 mlp_decoder_select="mlp_parser"
+mlp_encoder_select="lpc"
 motionpixels_decoder_select="bswapdsp"
 mp1_decoder_select="mpegaudio"
 mp1float_decoder_select="mpegaudio"
@@ -2421,8 +2534,8 @@ mp3on4_decoder_select="mpegaudio"
 mp3on4float_decoder_select="mpegaudio"
 mpc7_decoder_select="bswapdsp mpegaudiodsp"
 mpc8_decoder_select="mpegaudiodsp"
-#MYTH mpeg_xvmc_decoder_deps="X11_extensions_XvMClib_h"
-#MYTH mpeg_xvmc_decoder_select="mpeg2video_decoder"
+mpeg_xvmc_decoder_deps="X11_extensions_XvMClib_h"
+mpeg_xvmc_decoder_select="mpeg2video_decoder"
 mpegvideo_decoder_select="mpegvideo"
 mpeg1video_decoder_select="mpegvideo"
 mpeg1video_encoder_select="aandcttables mpegvideoenc h263dsp"
@@ -2431,12 +2544,13 @@ mpeg2video_encoder_select="aandcttables mpegvideoenc h263dsp"
 mpeg4_decoder_select="h263_decoder mpeg4video_parser"
 mpeg4_encoder_select="h263_encoder"
 msa1_decoder_select="mss34dsp"
+mscc_decoder_select="zlib"
 msmpeg4v1_decoder_select="h263_decoder"
 msmpeg4v2_decoder_select="h263_decoder"
 msmpeg4v2_encoder_select="h263_encoder"
 msmpeg4v3_decoder_select="h263_decoder"
 msmpeg4v3_encoder_select="h263_encoder"
-mss2_decoder_select="vc1_decoder mpegvideo"
+mss2_decoder_select="mpegvideo qpeldsp vc1_decoder"
 mts2_decoder_select="mss34dsp"
 mxpeg_decoder_select="mjpeg_decoder"
 nellymoser_decoder_select="mdct sinewin"
@@ -2444,9 +2558,10 @@ nellymoser_encoder_select="audio_frame_queue mdct sinewin"
 nuv_decoder_select="idctdsp lzo"
 on2avc_decoder_select="mdct"
 opus_decoder_deps="swresample"
-opus_decoder_select="imdct15"
+opus_decoder_select="mdct15"
+opus_encoder_select="audio_frame_queue mdct15"
 png_decoder_select="zlib"
-png_encoder_select="huffyuvencdsp zlib"
+png_encoder_select="llvidencdsp zlib"
 prores_decoder_select="blockdsp idctdsp"
 prores_encoder_select="fdctdsp"
 qcelp_decoder_select="lsp"
@@ -2464,7 +2579,7 @@ rv20_encoder_select="h263_encoder"
 rv30_decoder_select="golomb h264pred h264qpel mpegvideo rv34dsp"
 rv40_decoder_select="golomb h264pred h264qpel mpegvideo rv34dsp"
 screenpresso_decoder_select="zlib"
-shorten_decoder_select="golomb"
+shorten_decoder_select="bswapdsp"
 sipr_decoder_select="lsp"
 snow_decoder_select="dwt h264qpel hpeldsp me_cmp rangecoder videodsp"
 snow_encoder_select="aandcttables dwt h264qpel hpeldsp me_cmp mpegvideoenc rangecoder"
@@ -2472,9 +2587,10 @@ sonic_decoder_select="golomb rangecoder"
 sonic_encoder_select="golomb rangecoder"
 sonic_ls_encoder_select="golomb rangecoder"
 sp5x_decoder_select="mjpeg_decoder"
+srgc_decoder_select="zlib"
 svq1_decoder_select="hpeldsp"
 svq1_encoder_select="aandcttables hpeldsp me_cmp mpegvideoenc"
-svq3_decoder_select="golomb h264dsp h264pred hpeldsp tpeldsp videodsp"
+svq3_decoder_select="golomb h264dsp h264parse h264pred hpeldsp tpeldsp videodsp"
 svq3_decoder_suggest="zlib"
 tak_decoder_select="audiodsp"
 tdsc_decoder_select="zlib mjpeg_decoder"
@@ -2483,17 +2599,18 @@ thp_decoder_select="mjpeg_decoder"
 tiff_decoder_suggest="zlib lzma"
 tiff_encoder_suggest="zlib"
 truehd_decoder_select="mlp_parser"
+truehd_encoder_select="lpc"
 truemotion2_decoder_select="bswapdsp"
 truespeech_decoder_select="bswapdsp"
 tscc_decoder_select="zlib"
 twinvq_decoder_select="mdct lsp sinewin"
 txd_decoder_select="texturedsp"
-utvideo_decoder_select="bswapdsp"
-utvideo_encoder_select="bswapdsp huffman huffyuvencdsp"
-vble_decoder_select="huffyuvdsp"
+utvideo_decoder_select="bswapdsp llviddsp"
+utvideo_encoder_select="bswapdsp huffman llvidencdsp"
+vble_decoder_select="llviddsp"
 vc1_decoder_select="blockdsp h263_decoder h264qpel intrax8 mpegvideo vc1dsp"
 vc1_qsv_decoder_deps="libmfx"
-vc1_qsv_decoder_select="qsvdec vc1_qsv_hwaccel"
+vc1_qsv_decoder_select="qsvdec vc1_qsv_hwaccel vc1_parser"
 vc1image_decoder_select="vc1_decoder"
 vorbis_decoder_select="mdct"
 vorbis_encoder_select="mdct"
@@ -2527,64 +2644,53 @@ zlib_encoder_select="zlib"
 zmbv_decoder_select="zlib"
 zmbv_encoder_select="zlib"
 
-# platform codecs
-audiotoolbox_deps="AudioToolbox_AudioToolbox_h"
-audiotoolbox_extralibs="-framework CoreFoundation -framework AudioToolbox -framework CoreMedia"
-
 # hardware accelerators
 crystalhd_deps="libcrystalhd_libcrystalhd_if_h"
+cuda_deps_any="libdl LoadLibrary"
 cuvid_deps="cuda"
 d3d11va_deps="d3d11_h dxva_h ID3D11VideoDecoder ID3D11VideoContext"
-dxva2_deps="dxva2api_h DXVA2_ConfigPictureDecode"
-vaapi_deps="va_va_h"
-vda_framework_deps="VideoDecodeAcceleration_VDADecoder_h"
+dxva2_deps="dxva2api_h DXVA2_ConfigPictureDecode ole32"
+dxva2_extralibs="-luser32"
+vda_framework_deps="VideoDecodeAcceleration_VDADecoder_h blocks_extension"
 vda_framework_extralibs="-framework VideoDecodeAcceleration"
 vda_deps="vda_framework pthreads"
 vda_extralibs="-framework CoreFoundation -framework QuartzCore"
-vdpau_deps="vdpau_vdpau_h vdpau_vdpau_x11_h"
 videotoolbox_hwaccel_deps="videotoolbox pthreads"
 videotoolbox_hwaccel_extralibs="-framework QuartzCore"
 xvmc_deps="X11_extensions_XvMClib_h"
 
-h263_cuvid_hwaccel_deps="cuda cuvid"
 h263_vaapi_hwaccel_deps="vaapi"
 h263_vaapi_hwaccel_select="h263_decoder"
 h263_videotoolbox_hwaccel_deps="videotoolbox"
 h263_videotoolbox_hwaccel_select="h263_decoder"
-h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser"
 h264_cuvid_hwaccel_deps="cuda cuvid"
+h264_cuvid_hwaccel_select="h264_cuvid_decoder"
 h264_d3d11va_hwaccel_deps="d3d11va"
 h264_d3d11va_hwaccel_select="h264_decoder"
+h264_d3d11va2_hwaccel_deps="d3d11va"
+h264_d3d11va2_hwaccel_select="h264_decoder"
 h264_dxva2_hwaccel_deps="dxva2"
 h264_dxva2_hwaccel_select="h264_decoder"
-h264_mediacodec_decoder_deps="mediacodec"
 h264_mediacodec_hwaccel_deps="mediacodec"
-h264_mediacodec_decoder_select="h264_mp4toannexb_bsf h264_parser"
-h264_mmal_decoder_deps="mmal"
-h264_mmal_decoder_select="mmal"
 h264_mmal_hwaccel_deps="mmal"
-h264_omx_encoder_deps="omx"
 h264_qsv_hwaccel_deps="libmfx"
 h264_vaapi_hwaccel_deps="vaapi"
 h264_vaapi_hwaccel_select="h264_decoder"
-h264_vda_decoder_deps="vda"
-h264_vda_decoder_select="h264_decoder"
 h264_vda_hwaccel_deps="vda"
 h264_vda_hwaccel_select="h264_decoder"
 h264_vda_old_hwaccel_deps="vda"
 h264_vda_old_hwaccel_select="h264_decoder"
-h264_vdpau_decoder_deps="vdpau"
-h264_vdpau_decoder_select="h264_decoder"
 h264_vdpau_hwaccel_deps="vdpau"
 h264_vdpau_hwaccel_select="h264_decoder"
 h264_videotoolbox_hwaccel_deps="videotoolbox"
 h264_videotoolbox_hwaccel_select="h264_decoder"
 hevc_cuvid_hwaccel_deps="cuda cuvid"
+hevc_cuvid_hwaccel_select="hevc_cuvid_decoder"
 hevc_d3d11va_hwaccel_deps="d3d11va DXVA_PicParams_HEVC"
 hevc_d3d11va_hwaccel_select="hevc_decoder"
-hevc_mediacodec_decoder_deps="mediacodec"
 hevc_mediacodec_hwaccel_deps="mediacodec"
-hevc_mediacodec_decoder_select="hevc_mp4toannexb_bsf hevc_parser"
+hevc_d3d11va2_hwaccel_deps="d3d11va DXVA_PicParams_HEVC"
+hevc_d3d11va2_hwaccel_select="hevc_decoder"
 hevc_dxva2_hwaccel_deps="dxva2 DXVA_PicParams_HEVC"
 hevc_dxva2_hwaccel_select="hevc_decoder"
 hevc_qsv_hwaccel_deps="libmfx"
@@ -2592,28 +2698,29 @@ hevc_vaapi_hwaccel_deps="vaapi VAPictureParameterBufferHEVC"
 hevc_vaapi_hwaccel_select="hevc_decoder"
 hevc_vdpau_hwaccel_deps="vdpau VdpPictureInfoHEVC"
 hevc_vdpau_hwaccel_select="hevc_decoder"
+hevc_videotoolbox_hwaccel_deps="videotoolbox"
+hevc_videotoolbox_hwaccel_select="hevc_decoder"
 mjpeg_cuvid_hwaccel_deps="cuda cuvid"
-mpeg_vdpau_decoder_deps="vdpau"
-mpeg_vdpau_decoder_select="mpeg2video_decoder"
+mjpeg_cuvid_hwaccel_select="mjpeg_cuvid_decoder"
 mpeg_xvmc_hwaccel_deps="xvmc"
 mpeg_xvmc_hwaccel_select="mpeg2video_decoder"
 mpeg1_cuvid_hwaccel_deps="cuda cuvid"
-mpeg1_vdpau_decoder_deps="vdpau"
-mpeg1_vdpau_decoder_select="mpeg1video_decoder"
+mpeg1_cuvid_hwaccel_select="mpeg1_cuvid_decoder"
 mpeg1_vdpau_hwaccel_deps="vdpau"
 mpeg1_vdpau_hwaccel_select="mpeg1video_decoder"
 mpeg1_videotoolbox_hwaccel_deps="videotoolbox"
 mpeg1_videotoolbox_hwaccel_select="mpeg1video_decoder"
 mpeg1_xvmc_hwaccel_deps="xvmc"
 mpeg1_xvmc_hwaccel_select="mpeg1video_decoder"
-mpeg2_crystalhd_decoder_select="crystalhd"
 mpeg2_cuvid_hwaccel_deps="cuda cuvid"
+mpeg2_cuvid_hwaccel_select="mpeg2_cuvid_decoder"
 mpeg2_d3d11va_hwaccel_deps="d3d11va"
 mpeg2_d3d11va_hwaccel_select="mpeg2video_decoder"
+mpeg2_d3d11va2_hwaccel_deps="d3d11va"
+mpeg2_d3d11va2_hwaccel_select="mpeg2video_decoder"
 mpeg2_dxva2_hwaccel_deps="dxva2"
 mpeg2_dxva2_hwaccel_select="mpeg2video_decoder"
-mpeg2_mmal_decoder_deps="mmal"
-mpeg2_mmal_decoder_select="mmal"
+mpeg2_mediacodec_hwaccel_deps="mediacodec"
 mpeg2_mmal_hwaccel_deps="mmal"
 mpeg2_qsv_hwaccel_deps="libmfx"
 mpeg2_qsv_hwaccel_select="qsvdec_mpeg2"
@@ -2625,117 +2732,168 @@ mpeg2_videotoolbox_hwaccel_deps="videotoolbox"
 mpeg2_videotoolbox_hwaccel_select="mpeg2video_decoder"
 mpeg2_xvmc_hwaccel_deps="xvmc"
 mpeg2_xvmc_hwaccel_select="mpeg2video_decoder"
-mpeg4_crystalhd_decoder_select="crystalhd"
 mpeg4_cuvid_hwaccel_deps="cuda cuvid"
-mpeg4_mediacodec_decoder_deps="mediacodec"
+mpeg4_cuvid_hwaccel_select="mpeg4_cuvid_decoder"
 mpeg4_mediacodec_hwaccel_deps="mediacodec"
-mpeg4_mmal_decoder_deps="mmal"
-mpeg4_mmal_decoder_select="mmal"
 mpeg4_mmal_hwaccel_deps="mmal"
-mpeg4_omx_encoder_deps="omx"
 mpeg4_vaapi_hwaccel_deps="vaapi"
 mpeg4_vaapi_hwaccel_select="mpeg4_decoder"
-mpeg4_vdpau_decoder_deps="vdpau"
-mpeg4_vdpau_decoder_select="mpeg4_decoder"
 mpeg4_vdpau_hwaccel_deps="vdpau"
 mpeg4_vdpau_hwaccel_select="mpeg4_decoder"
 mpeg4_videotoolbox_hwaccel_deps="videotoolbox"
 mpeg4_videotoolbox_hwaccel_select="mpeg4_decoder"
-msmpeg4_crystalhd_decoder_select="crystalhd"
-vc1_crystalhd_decoder_select="crystalhd"
 vc1_cuvid_hwaccel_deps="cuda cuvid"
+vc1_cuvid_hwaccel_select="vc1_cuvid_decoder"
 vc1_d3d11va_hwaccel_deps="d3d11va"
 vc1_d3d11va_hwaccel_select="vc1_decoder"
+vc1_d3d11va2_hwaccel_deps="d3d11va"
+vc1_d3d11va2_hwaccel_select="vc1_decoder"
 vc1_dxva2_hwaccel_deps="dxva2"
 vc1_dxva2_hwaccel_select="vc1_decoder"
-vc1_mmal_decoder_deps="mmal"
-vc1_mmal_decoder_select="mmal"
 vc1_mmal_hwaccel_deps="mmal"
 vc1_qsv_hwaccel_deps="libmfx"
 vc1_qsv_hwaccel_select="qsvdec_vc1"
 vc1_vaapi_hwaccel_deps="vaapi"
 vc1_vaapi_hwaccel_select="vc1_decoder"
-vc1_vdpau_decoder_deps="vdpau"
-vc1_vdpau_decoder_select="vc1_decoder"
 vc1_vdpau_hwaccel_deps="vdpau"
 vc1_vdpau_hwaccel_select="vc1_decoder"
 vp8_cuvid_hwaccel_deps="cuda cuvid"
+vp8_cuvid_hwaccel_select="vp8_cuvid_decoder"
 vp9_cuvid_hwaccel_deps="cuda cuvid"
-vp8_mediacodec_decoder_deps="mediacodec"
+vp9_cuvid_hwaccel_select="vp9_cuvid_decoder"
 vp8_mediacodec_hwaccel_deps="mediacodec"
+vp8_qsv_hwaccel_deps="libmfx"
 vp9_d3d11va_hwaccel_deps="d3d11va DXVA_PicParams_VP9"
 vp9_d3d11va_hwaccel_select="vp9_decoder"
+vp9_d3d11va2_hwaccel_deps="d3d11va DXVA_PicParams_VP9"
+vp9_d3d11va2_hwaccel_select="vp9_decoder"
 vp9_dxva2_hwaccel_deps="dxva2 DXVA_PicParams_VP9"
 vp9_dxva2_hwaccel_select="vp9_decoder"
-vp9_mediacodec_decoder_deps="mediacodec"
 vp9_mediacodec_hwaccel_deps="mediacodec"
-vp9_vaapi_hwaccel_deps="vaapi VADecPictureParameterBufferVP9"
+vp9_vaapi_hwaccel_deps="vaapi VADecPictureParameterBufferVP9_bit_depth"
 vp9_vaapi_hwaccel_select="vp9_decoder"
-wmv3_crystalhd_decoder_select="crystalhd"
 wmv3_d3d11va_hwaccel_select="vc1_d3d11va_hwaccel"
+wmv3_d3d11va2_hwaccel_select="vc1_d3d11va2_hwaccel"
 wmv3_dxva2_hwaccel_select="vc1_dxva2_hwaccel"
 wmv3_vaapi_hwaccel_select="vc1_vaapi_hwaccel"
-wmv3_vdpau_decoder_select="vc1_vdpau_decoder"
 wmv3_vdpau_hwaccel_select="vc1_vdpau_hwaccel"
 
 # hardware-accelerated codecs
-omx_deps="dlopen pthreads"
-omx_extralibs='$ldl'
+omx_deps="libdl pthreads"
+omx_rpi_select="omx"
 qsvdec_select="qsv"
 qsvenc_select="qsv"
 vaapi_encode_deps="vaapi"
+v4l2_m2m_deps_any="linux_videodev2_h"
 
 hwupload_cuda_filter_deps="cuda"
 scale_npp_filter_deps="cuda libnpp"
+scale_cuda_filter_deps="cuda_sdk"
+thumbnail_cuda_filter_deps="cuda_sdk"
 
-nvenc_deps_any="dlopen LoadLibrary"
+nvenc_deps="cuda"
+nvenc_deps_any="libdl LoadLibrary"
 nvenc_encoder_deps="nvenc"
-h263_cuvid_decoder_deps="cuda cuvid"
-h263_cuvid_decoder_select="h263_cuvid_hwaccel"
+
+h263_v4l2m2m_decoder_deps="v4l2_m2m h263_v4l2_m2m"
+h263_v4l2m2m_encoder_deps="v4l2_m2m h263_v4l2_m2m"
+h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser"
 h264_cuvid_decoder_deps="cuda cuvid"
-h264_cuvid_decoder_select="h264_mp4toannexb_bsf h264_cuvid_hwaccel"
+h264_cuvid_decoder_select="h264_mp4toannexb_bsf"
+h264_mediacodec_decoder_deps="mediacodec"
+h264_mediacodec_decoder_select="h264_mp4toannexb_bsf h264_parser"
+h264_mmal_decoder_deps="mmal"
 h264_nvenc_encoder_deps="nvenc"
+h264_omx_encoder_deps="omx"
 h264_qsv_decoder_deps="libmfx"
 h264_qsv_decoder_select="h264_mp4toannexb_bsf h264_parser qsvdec h264_qsv_hwaccel"
 h264_qsv_encoder_deps="libmfx"
 h264_qsv_encoder_select="qsvenc"
+h264_rkmpp_decoder_deps="rkmpp"
+h264_rkmpp_decoder_select="h264_mp4toannexb_bsf"
 h264_vaapi_encoder_deps="VAEncPictureParameterBufferH264"
 h264_vaapi_encoder_select="vaapi_encode golomb"
-
+h264_vda_decoder_deps="vda"
+h264_vda_decoder_select="h264_decoder"
+h264_vdpau_decoder_deps="vdpau"
+h264_vdpau_decoder_select="h264_decoder"
+h264_v4l2m2m_decoder_deps="v4l2_m2m h264_v4l2_m2m"
+h264_v4l2m2m_encoder_deps="v4l2_m2m h264_v4l2_m2m"
 hevc_cuvid_decoder_deps="cuda cuvid"
-hevc_cuvid_decoder_select="hevc_mp4toannexb_bsf hevc_cuvid_hwaccel"
+hevc_cuvid_decoder_select="hevc_mp4toannexb_bsf"
+hevc_mediacodec_decoder_deps="mediacodec"
+hevc_mediacodec_decoder_select="hevc_mp4toannexb_bsf hevc_parser"
 hevc_nvenc_encoder_deps="nvenc"
 hevc_qsv_decoder_deps="libmfx"
 hevc_qsv_decoder_select="hevc_mp4toannexb_bsf hevc_parser qsvdec hevc_qsv_hwaccel"
 hevc_qsv_encoder_deps="libmfx"
-hevc_qsv_encoder_select="qsvenc"
+hevc_qsv_encoder_select="hevcparse qsvenc"
+hevc_rkmpp_decoder_deps="rkmpp"
+hevc_rkmpp_decoder_select="hevc_mp4toannexb_bsf"
 hevc_vaapi_encoder_deps="VAEncPictureParameterBufferHEVC"
 hevc_vaapi_encoder_select="vaapi_encode golomb"
+hevc_v4l2m2m_decoder_deps="v4l2_m2m hevc_v4l2_m2m"
+hevc_v4l2m2m_encoder_deps="v4l2_m2m hevc_v4l2_m2m"
 mjpeg_cuvid_decoder_deps="cuda cuvid"
-mjpeg_cuvid_decoder_select="mjpeg_cuvid_hwaccel"
+mjpeg_vaapi_encoder_deps="VAEncPictureParameterBufferJPEG"
+mjpeg_vaapi_encoder_select="vaapi_encode jpegtables"
 mpeg1_cuvid_decoder_deps="cuda cuvid"
-mpeg1_cuvid_decoder_select="mpeg1_cuvid_hwaccel"
+mpeg1_vdpau_decoder_deps="vdpau"
+mpeg1_vdpau_decoder_select="mpeg1video_decoder"
+mpeg1_v4l2m2m_decoder_deps="v4l2_m2m mpeg1_v4l2_m2m"
+mpeg2_crystalhd_decoder_select="crystalhd"
 mpeg2_cuvid_decoder_deps="cuda cuvid"
-mpeg2_cuvid_decoder_select="mpeg2_cuvid_hwaccel"
+mpeg2_mmal_decoder_deps="mmal"
+mpeg2_mediacodec_decoder_deps="mediacodec"
 mpeg2_qsv_decoder_deps="libmfx"
 mpeg2_qsv_decoder_select="qsvdec mpeg2_qsv_hwaccel"
 mpeg2_qsv_encoder_deps="libmfx"
 mpeg2_qsv_encoder_select="qsvenc"
+mpeg2_vaapi_encoder_deps="VAEncPictureParameterBufferMPEG2"
+mpeg2_vaapi_encoder_select="vaapi_encode"
+mpeg2_v4l2m2m_decoder_deps="v4l2_m2m mpeg2_v4l2_m2m"
+mpeg4_crystalhd_decoder_select="crystalhd"
 mpeg4_cuvid_decoder_deps="cuda cuvid"
-mpeg4_cuvid_decoder_select="mpeg4_cuvid_hwaccel"
-nvenc_h264_encoder_deps="nvenc"
-nvenc_hevc_encoder_deps="nvenc"
-
+mpeg4_mediacodec_decoder_deps="mediacodec"
+mpeg4_mmal_decoder_deps="mmal"
+mpeg4_omx_encoder_deps="omx"
+mpeg4_vdpau_decoder_deps="vdpau"
+mpeg4_vdpau_decoder_select="mpeg4_decoder"
+mpeg4_v4l2m2m_decoder_deps="v4l2_m2m mpeg4_v4l2_m2m"
+mpeg4_v4l2m2m_encoder_deps="v4l2_m2m mpeg4_v4l2_m2m"
+mpeg_vdpau_decoder_deps="vdpau"
+mpeg_vdpau_decoder_select="mpeg2video_decoder"
+msmpeg4_crystalhd_decoder_select="crystalhd"
+nvenc_h264_encoder_select="h264_nvenc_encoder"
+nvenc_hevc_encoder_select="hevc_nvenc_encoder"
+vc1_crystalhd_decoder_select="crystalhd"
 vc1_cuvid_decoder_deps="cuda cuvid"
-vc1_cuvid_decoder_select="vc1_cuvid_hwaccel"
+vc1_mmal_decoder_deps="mmal"
+vc1_vdpau_decoder_deps="vdpau"
+vc1_vdpau_decoder_select="vc1_decoder"
+vc1_v4l2m2m_decoder_deps="v4l2_m2m vc1_v4l2_m2m"
 vp8_cuvid_decoder_deps="cuda cuvid"
-vp8_cuvid_decoder_select="vp8_cuvid_hwaccel"
+vp8_mediacodec_decoder_deps="mediacodec"
+vp8_qsv_decoder_deps="libmfx"
+vp8_qsv_decoder_select="qsvdec vp8_qsv_hwaccel vp8_parser"
+vp8_rkmpp_decoder_deps="rkmpp"
+vp8_vaapi_encoder_deps="VAEncPictureParameterBufferVP8"
+vp8_vaapi_encoder_select="vaapi_encode"
+vp8_v4l2m2m_decoder_deps="v4l2_m2m vp8_v4l2_m2m"
+vp8_v4l2m2m_encoder_deps="v4l2_m2m vp8_v4l2_m2m"
 vp9_cuvid_decoder_deps="cuda cuvid"
-vp9_cuvid_decoder_select="vp9_cuvid_hwaccel"
+vp9_mediacodec_decoder_deps="mediacodec"
+vp9_rkmpp_decoder_deps="rkmpp"
+vp9_vaapi_encoder_deps="VAEncPictureParameterBufferVP9"
+vp9_vaapi_encoder_select="vaapi_encode"
+vp9_v4l2m2m_decoder_deps="v4l2_m2m vp9_v4l2_m2m"
+wmv3_crystalhd_decoder_select="crystalhd"
+wmv3_vdpau_decoder_select="vc1_vdpau_decoder"
 
 # parsers
-h264_parser_select="golomb h264dsp"
-hevc_parser_select="golomb"
+h264_parser_select="golomb h264dsp h264parse"
+hevc_parser_select="hevcparse"
+mpegaudio_parser_select="mpegaudioheader"
 mpegvideo_parser_select="mpegvideo"
 mpeg4video_parser_select="h263dsp mpegvideo qpeldsp"
 vc1_parser_select="vc1dsp"
@@ -2745,11 +2903,15 @@ mjpeg2jpeg_bsf_select="jpegtables"
 
 # external libraries
 aac_at_decoder_deps="audiotoolbox"
+aac_at_decoder_select="aac_adtstoasc_bsf"
 ac3_at_decoder_deps="audiotoolbox"
 ac3_at_decoder_select="ac3_parser"
 adpcm_ima_qt_at_decoder_deps="audiotoolbox"
 alac_at_decoder_deps="audiotoolbox"
 amr_nb_at_decoder_deps="audiotoolbox"
+avisynth_deps_any="libdl LoadLibrary"
+avisynth_demuxer_deps="avisynth"
+avisynth_demuxer_select="riffdec"
 eac3_at_decoder_deps="audiotoolbox"
 eac3_at_decoder_select="ac3_parser"
 gsm_ms_at_decoder_deps="audiotoolbox"
@@ -2757,6 +2919,9 @@ ilbc_at_decoder_deps="audiotoolbox"
 mp1_at_decoder_deps="audiotoolbox"
 mp2_at_decoder_deps="audiotoolbox"
 mp3_at_decoder_deps="audiotoolbox"
+mp1_at_decoder_select="mpegaudioheader"
+mp2_at_decoder_select="mpegaudioheader"
+mp3_at_decoder_select="mpegaudioheader"
 pcm_alaw_at_decoder_deps="audiotoolbox"
 pcm_mulaw_at_decoder_deps="audiotoolbox"
 qdmc_at_decoder_deps="audiotoolbox"
@@ -2772,7 +2937,8 @@ pcm_alaw_at_encoder_select="audio_frame_queue"
 pcm_mulaw_at_encoder_deps="audiotoolbox"
 pcm_mulaw_at_encoder_select="audio_frame_queue"
 chromaprint_muxer_deps="chromaprint"
-h264_videotoolbox_encoder_deps="videotoolbox_encoder pthreads"
+h264_videotoolbox_encoder_deps="pthreads"
+h264_videotoolbox_encoder_select="videotoolbox_encoder"
 libcelt_decoder_deps="libcelt"
 libfdk_aac_decoder_deps="libfdk_aac"
 libfdk_aac_encoder_deps="libfdk_aac"
@@ -2787,7 +2953,7 @@ libilbc_encoder_deps="libilbc"
 libkvazaar_encoder_deps="libkvazaar"
 libmodplug_demuxer_deps="libmodplug"
 libmp3lame_encoder_deps="libmp3lame"
-libmp3lame_encoder_select="audio_frame_queue"
+libmp3lame_encoder_select="audio_frame_queue mpegaudioheader"
 libopencore_amrnb_decoder_deps="libopencore_amrnb"
 libopencore_amrnb_encoder_deps="libopencore_amrnb"
 libopencore_amrnb_encoder_select="audio_frame_queue"
@@ -2801,8 +2967,7 @@ libopenmpt_demuxer_deps="libopenmpt"
 libopus_decoder_deps="libopus"
 libopus_encoder_deps="libopus"
 libopus_encoder_select="audio_frame_queue"
-libschroedinger_decoder_deps="libschroedinger"
-libschroedinger_encoder_deps="libschroedinger"
+librsvg_decoder_deps="librsvg"
 libshine_encoder_deps="libshine"
 libshine_encoder_select="audio_frame_queue"
 libspeex_decoder_deps="libspeex"
@@ -2819,6 +2984,7 @@ libvpx_vp8_encoder_deps="libvpx"
 libvpx_vp9_decoder_deps="libvpx"
 libvpx_vp9_encoder_deps="libvpx"
 libwavpack_encoder_deps="libwavpack"
+libwavpack_encoder_select="audio_frame_queue"
 libwebp_encoder_deps="libwebp"
 libwebp_anim_encoder_deps="libwebp"
 libx262_encoder_deps="libx262"
@@ -2829,24 +2995,23 @@ libx265_encoder_deps="libx265"
 libxavs_encoder_deps="libxavs"
 libxvid_encoder_deps="libxvid"
 libzvbi_teletext_decoder_deps="libzvbi"
-videotoolbox_deps="VideoToolbox_VideoToolbox_h"
 videotoolbox_extralibs="-framework CoreFoundation -framework VideoToolbox -framework CoreMedia -framework CoreVideo"
 videotoolbox_encoder_deps="videotoolbox VTCompressionSessionPrepareToEncodeFrames"
-videotoolbox_encoder_suggest="vda_framework vt_bt2020"
-vt_bt2020_deps="kCVImageBufferColorPrimaries_ITU_R_2020"
+videotoolbox_encoder_suggest="vda_framework"
 
 # demuxers / muxers
 ac3_demuxer_select="ac3_parser"
+aiff_muxer_select="iso_media"
 asf_demuxer_select="riffdec"
 asf_o_demuxer_select="riffdec"
 asf_muxer_select="riffenc"
 asf_stream_muxer_select="asf_muxer"
 avi_demuxer_select="iso_media riffdec exif"
 avi_muxer_select="riffenc"
-avisynth_demuxer_deps="avisynth"
-avisynth_demuxer_select="riffdec"
 caf_demuxer_select="iso_media riffdec"
+caf_muxer_select="iso_media"
 dash_muxer_select="mp4_muxer"
+dash_demuxer_deps="libxml2"
 dirac_demuxer_select="dirac_parser"
 dts_demuxer_select="dca_parser"
 dtshd_demuxer_select="dca_parser"
@@ -2863,8 +3028,6 @@ image2_alias_pix_demuxer_select="image2_demuxer"
 image2_brender_pix_demuxer_select="image2_demuxer"
 ipod_muxer_select="mov_muxer"
 ismv_muxer_select="mov_muxer"
-libnut_demuxer_deps="libnut"
-libnut_muxer_deps="libnut"
 matroska_audio_muxer_select="matroska_muxer"
 matroska_demuxer_select="iso_media riffdec"
 matroska_demuxer_suggest="bzlib lzo zlib"
@@ -2874,6 +3037,7 @@ mov_demuxer_select="iso_media riffdec"
 mov_demuxer_suggest="zlib"
 mov_muxer_select="iso_media riffenc rtpenc_chain"
 mp3_demuxer_select="mpegaudio_parser"
+mp3_muxer_select="mpegaudioheader"
 mp4_muxer_select="mov_muxer"
 mpegts_demuxer_select="iso_media"
 mpegts_muxer_select="adts_muxer latm_muxer"
@@ -2888,6 +3052,7 @@ ogv_muxer_select="ogg_muxer"
 opus_muxer_select="ogg_muxer"
 psp_muxer_select="mov_muxer"
 rtp_demuxer_select="sdp_demuxer"
+rtp_muxer_select="golomb"
 rtpdec_select="asf_demuxer jpegtables mov_demuxer mpegts_demuxer rm_demuxer rtp_protocol srtp"
 rtsp_demuxer_select="http_protocol rtpdec"
 rtsp_muxer_select="rtp_muxer http_protocol rtp_protocol rtpenc_chain"
@@ -2914,28 +3079,32 @@ xmv_demuxer_select="riffdec"
 xwma_demuxer_select="riffdec"
 
 # indevs / outdevs
-alsa_indev_deps="alsa_asoundlib_h snd_pcm_htimestamp"
-alsa_outdev_deps="alsa_asoundlib_h"
-avfoundation_indev_extralibs="-framework CoreVideo -framework Foundation -framework AVFoundation -framework CoreMedia"
-avfoundation_indev_select="avfoundation"
+alsa_indev_deps="alsa"
+alsa_outdev_deps="alsa"
+avfoundation_indev_deps="avfoundation pthreads"
+avfoundation_indev_extralibs="-framework Foundation -framework CoreVideo -framework CoreMedia"
 bktr_indev_deps_any="dev_bktr_ioctl_bt848_h machine_ioctl_bt848_h dev_video_bktr_ioctl_bt848_h dev_ic_bt8xx_h"
 caca_outdev_deps="libcaca"
-decklink_indev_deps="decklink pthreads"
+decklink_deps_any="libdl LoadLibrary"
+decklink_indev_deps="decklink threads"
 decklink_indev_extralibs="-lstdc++"
-decklink_outdev_deps="decklink pthreads"
+decklink_outdev_deps="decklink threads"
 decklink_outdev_extralibs="-lstdc++"
+libndi_newtek_indev_deps="libndi_newtek"
+libndi_newtek_indev_extralibs="-lndi"
+libndi_newtek_outdev_deps="libndi_newtek"
+libndi_newtek_outdev_extralibs="-lndi"
 dshow_indev_deps="IBaseFilter"
 dshow_indev_extralibs="-lpsapi -lole32 -lstrmiids -luuid -loleaut32 -lshlwapi"
-dv1394_indev_deps="dv1394"
-dv1394_indev_select="dv_demuxer"
 fbdev_indev_deps="linux_fb_h"
 fbdev_outdev_deps="linux_fb_h"
 gdigrab_indev_deps="CreateDIBSection"
 gdigrab_indev_extralibs="-lgdi32"
 gdigrab_indev_select="bmp_decoder"
 iec61883_indev_deps="libiec61883"
-jack_indev_deps="jack_jack_h"
+jack_indev_deps="jack"
 jack_indev_deps_any="sem_timedwait dispatch_dispatch_h"
+kmsgrab_indev_deps="libdrm"
 lavfi_indev_deps="avfilter"
 libcdio_indev_deps="libcdio"
 libdc1394_indev_deps="libdc1394"
@@ -2946,28 +3115,23 @@ oss_indev_deps_any="soundcard_h sys_soundcard_h"
 oss_outdev_deps_any="soundcard_h sys_soundcard_h"
 pulse_indev_deps="libpulse"
 pulse_outdev_deps="libpulse"
-qtkit_indev_extralibs="-framework QTKit -framework Foundation -framework QuartzCore"
-qtkit_indev_select="qtkit"
 sdl2_outdev_deps="sdl2"
-sndio_indev_deps="sndio_h"
-sndio_outdev_deps="sndio_h"
-v4l_indev_deps="linux_videodev_h"
+sndio_indev_deps="sndio"
+sndio_outdev_deps="sndio"
 v4l2_indev_deps_any="linux_videodev2_h sys_videoio_h"
 v4l2_outdev_deps_any="linux_videodev2_h sys_videoio_h"
-vfwcap_indev_deps="capCreateCaptureWindow vfwcap_defines"
-vfwcap_indev_extralibs="-lavicap32"
-x11grab_indev_deps="x11grab"
-x11grab_xcb_indev_deps="libxcb"
+vfwcap_indev_deps="vfw32 vfwcap_defines"
+xcbgrab_indev_deps="libxcb"
 xv_outdev_deps="X11_extensions_Xvlib_h XvGetPortAttribute"
 xv_outdev_extralibs="-lXv -lX11 -lXext"
 
 # protocols
 async_protocol_deps="threads"
 bluray_protocol_deps="libbluray"
-ffrtmpcrypt_protocol_deps="!librtmp_protocol"
+ffrtmpcrypt_protocol_conflict="librtmp_protocol"
 ffrtmpcrypt_protocol_deps_any="gcrypt gmp openssl"
 ffrtmpcrypt_protocol_select="tcp_protocol"
-ffrtmphttp_protocol_deps="!librtmp_protocol"
+ffrtmphttp_protocol_conflict="librtmp_protocol"
 ffrtmphttp_protocol_select="http_protocol"
 ftp_protocol_select="tcp_protocol"
 gopher_protocol_select="network"
@@ -2984,10 +3148,10 @@ libsmbclient_protocol_deps="libsmbclient gplv3"
 libssh_protocol_deps="libssh"
 mmsh_protocol_select="http_protocol"
 mmst_protocol_select="network"
-rtmp_protocol_deps="!librtmp_protocol"
+rtmp_protocol_conflict="librtmp_protocol"
 rtmp_protocol_select="tcp_protocol"
 rtmpe_protocol_select="ffrtmpcrypt_protocol"
-rtmps_protocol_deps="!librtmp_protocol"
+rtmps_protocol_conflict="librtmp_protocol"
 rtmps_protocol_select="tls_protocol"
 rtmpt_protocol_select="ffrtmphttp_protocol"
 rtmpte_protocol_select="ffrtmpcrypt_protocol ffrtmphttp_protocol"
@@ -2997,9 +3161,11 @@ sctp_protocol_deps="struct_sctp_event_subscribe struct_msghdr_msg_flags"
 sctp_protocol_select="network"
 srtp_protocol_select="rtp_protocol srtp"
 tcp_protocol_select="network"
-tls_gnutls_protocol_deps="gnutls !tls_schannel_protocol !tls_securetransport_protocol"
+tls_gnutls_protocol_conflict="tls_schannel_protocol tls_securetransport_protocol"
+tls_gnutls_protocol_deps="gnutls"
 tls_gnutls_protocol_select="tcp_protocol"
-tls_openssl_protocol_deps="openssl !tls_schannel_protocol !tls_securetransport_protocol !tls_gnutls_protocol"
+tls_openssl_protocol_conflict="tls_schannel_protocol tls_securetransport_protocol tls_gnutls_protocol"
+tls_openssl_protocol_deps="openssl"
 tls_openssl_protocol_select="tcp_protocol"
 tls_schannel_protocol_deps="schannel"
 tls_schannel_protocol_select="tcp_protocol"
@@ -3014,10 +3180,11 @@ unix_protocol_select="network"
 # filters
 afftfilt_filter_deps="avcodec"
 afftfilt_filter_select="fft"
+afir_filter_deps="avcodec"
+afir_filter_select="fft"
 amovie_filter_deps="avcodec avformat"
 aresample_filter_deps="swresample"
 ass_filter_deps="libass"
-asyncts_filter_deps="avresample"
 atempo_filter_deps="avcodec"
 atempo_filter_select="rdft"
 azmq_filter_deps="libzmq"
@@ -3025,12 +3192,18 @@ blackframe_filter_deps="gpl"
 boxblur_filter_deps="gpl"
 bs2b_filter_deps="libbs2b"
 colormatrix_filter_deps="gpl"
+coreimage_filter_deps="coreimage appkit"
+coreimage_filter_extralibs="-framework OpenGL"
+coreimagesrc_filter_deps="coreimage appkit"
+coreimagesrc_filter_extralibs="-framework OpenGL"
 cover_rect_filter_deps="avcodec avformat gpl"
 cropdetect_filter_deps="gpl"
+deinterlace_qsv_filter_deps="libmfx"
+deinterlace_vaapi_filter_deps="vaapi"
 delogo_filter_deps="gpl"
 deshake_filter_select="pixelutils"
 drawtext_filter_deps="libfreetype"
-ebur128_filter_deps="gpl"
+elbg_filter_deps="avcodec"
 eq_filter_deps="gpl"
 fftfilt_filter_deps="avcodec"
 fftfilt_filter_select="rdft"
@@ -3039,16 +3212,15 @@ firequalizer_filter_deps="avcodec"
 firequalizer_filter_select="rdft"
 flite_filter_deps="libflite"
 framerate_filter_select="pixelutils"
-frei0r_filter_deps="frei0r dlopen"
-frei0r_src_filter_deps="frei0r dlopen"
+frei0r_filter_deps="frei0r libdl"
+frei0r_src_filter_deps="frei0r libdl"
 fspp_filter_deps="gpl"
 geq_filter_deps="gpl"
 histeq_filter_deps="gpl"
 hqdn3d_filter_deps="gpl"
 interlace_filter_deps="gpl"
 kerndeint_filter_deps="gpl"
-ladspa_filter_deps="ladspa dlopen"
-loudnorm_filter_deps="libebur128"
+ladspa_filter_deps="ladspa libdl"
 mcdeint_filter_deps="avcodec gpl"
 movie_filter_deps="avcodec avformat"
 mpdecimate_filter_deps="gpl"
@@ -3072,6 +3244,7 @@ rubberband_filter_deps="librubberband"
 sab_filter_deps="gpl swscale"
 scale2ref_filter_deps="swscale"
 scale_filter_deps="swscale"
+scale_qsv_filter_deps="libmfx"
 select_filter_select="pixelutils"
 showcqt_filter_deps="avcodec avformat swscale"
 showcqt_filter_select="fft"
@@ -3081,8 +3254,9 @@ showspectrum_filter_deps="avcodec"
 showspectrum_filter_select="fft"
 showspectrumpic_filter_deps="avcodec"
 showspectrumpic_filter_select="fft"
+signature_filter_deps="gpl avcodec avformat"
 smartblur_filter_deps="gpl swscale"
-sofalizer_filter_deps="netcdf avcodec"
+sofalizer_filter_deps="libmysofa avcodec"
 sofalizer_filter_select="fft"
 spectrumsynth_filter_deps="avcodec"
 spectrumsynth_filter_select="fft"
@@ -3095,28 +3269,34 @@ pixfmts_super2xsai_test_deps="super2xsai_filter"
 tinterlace_filter_deps="gpl"
 tinterlace_merge_test_deps="tinterlace_filter"
 tinterlace_pad_test_deps="tinterlace_filter"
+tonemap_filter_deps="const_nan"
 uspp_filter_deps="gpl avcodec"
 vaguedenoiser_filter_deps="gpl"
 vidstabdetect_filter_deps="libvidstab"
 vidstabtransform_filter_deps="libvidstab"
+libvmaf_filter_deps="libvmaf"
 zmq_filter_deps="libzmq"
 zoompan_filter_deps="swscale"
-zscale_filter_deps="libzimg"
+zscale_filter_deps="libzimg const_nan"
 scale_vaapi_filter_deps="vaapi VAProcPipelineParameterBuffer"
 
 # examples
 avio_dir_cmd_deps="avformat avutil"
 avio_reading_deps="avformat avcodec avutil"
-decoding_encoding_example_deps="avcodec avformat avutil"
+decode_audio_example_deps="avcodec avutil"
+decode_video_example_deps="avcodec avutil"
 demuxing_decoding_example_deps="avcodec avformat avutil"
+encode_audio_example_deps="avcodec avutil"
+encode_video_example_deps="avcodec avutil"
 extract_mvs_example_deps="avcodec avformat avutil"
 filter_audio_example_deps="avfilter avutil"
 filtering_audio_example_deps="avfilter avcodec avformat avutil"
 filtering_video_example_deps="avfilter avcodec avformat avutil"
-http_multiclient_example_deps="avformat avutil"
+http_multiclient_example_deps="avformat avutil fork"
+hw_decode_example_deps="avcodec avformat avutil"
 metadata_example_deps="avformat avutil"
 muxing_example_deps="avcodec avformat avutil swscale"
-qsvdec_example_deps="avcodec avutil libmfx h264_qsv_decoder vaapi_x11"
+qsvdec_example_deps="avcodec avutil libmfx h264_qsv_decoder"
 remuxing_example_deps="avcodec avformat avutil"
 resampling_audio_example_deps="avutil swresample"
 scaling_video_example_deps="avutil swscale"
@@ -3125,9 +3305,11 @@ transcoding_example_deps="avfilter avcodec avformat avutil"
 
 # libraries, in linking order
 avcodec_deps="avutil"
+avcodec_select="null_bsf"
 avdevice_deps="avformat avcodec avutil"
 avfilter_deps="avutil"
 avformat_deps="avcodec avutil"
+avformat_suggest="network"
 avresample_deps="avutil"
 postproc_deps="avutil gpl"
 swresample_deps="avutil"
@@ -3137,9 +3319,9 @@ swscale_deps="avutil"
 ffmpeg_deps="avcodec avfilter avformat swresample"
 ffmpeg_select="aformat_filter anull_filter atrim_filter format_filter
                null_filter
-               setpts_filter trim_filter"
+               trim_filter"
 ffplay_deps="avcodec avformat swscale swresample sdl2"
-ffplay_libs='$sdl2_libs'
+ffplay_extralibs='$sdl2_extralibs'
 ffplay_select="rdft crop_filter transpose_filter hflip_filter vflip_filter rotate_filter"
 ffprobe_deps="avcodec avformat"
 ffserver_deps="avformat fork sarestart"
@@ -3155,7 +3337,7 @@ doc_deps_any="manpages htmlpages podpages txtpages"
 
 # default parameters
 
-logfile="config.log"
+logfile="ffbuild/config.log"
 
 # installation paths
 prefix_default="/usr/local"
@@ -3171,18 +3353,19 @@ ar_default="ar"
 cc_default="gcc"
 cxx_default="g++"
 host_cc_default="gcc"
-cp_f="cp -f"
 doxygen_default="doxygen"
 install="install"
 ln_s_default="ln -s -f"
 nm_default="nm -g"
-objformat="elf"
 pkg_config_default=pkg-config
 ranlib_default="ranlib"
 strip_default="strip"
 version_script='--version-script'
-yasmexe_default="yasm"
+x86asmexe_default="nasm"
 windres_default="windres"
+nvcc_default="nvcc"
+nvccflags_default="-gencode arch=compute_30,code=sm_30 -O2"
+striptype="direct"
 
 # OS
 target_os_default=$(tolower $(uname -s))
@@ -3219,15 +3402,6 @@ enable valgrind_backtrace
 sws_max_filter_size_default=256
 set_default sws_max_filter_size
 
-# Enable platform codecs by default.
-enable audiotoolbox
-
-# Enable hwaccels by default.
-enable d3d11va dxva2 vaapi vda vdpau videotoolbox_hwaccel xvmc
-enable xlib
-
-enable nvenc vda_framework videotoolbox videotoolbox_encoder
-
 # build settings
 SHFLAGS='-shared -Wl,-soname,$$(@F)'
 LIBPREF="lib"
@@ -3258,16 +3432,18 @@ CXX_O='-o $@'
 OBJCC_C='-c'
 OBJCC_E='-E -o $@'
 OBJCC_O='-o $@'
+X86ASM_O='-o $@'
 LD_O='-o $@'
 LD_LIB='-l%'
-LD_MYTH_LIB='-lmyth%'
 LD_PATH='-L'
 HOSTCC_C='-c'
 HOSTCC_E='-E -o $@'
 HOSTCC_O='-o $@'
 HOSTLD_O='-o $@'
+NVCC_C='-c'
+NVCC_O='-o $@'
 
-host_libs='-lm'
+host_extralibs='-lm'
 host_cflags_filter=echo
 host_ldflags_filter=echo
 
@@ -3278,6 +3454,8 @@ target_path='$(CURDIR)'
 DEPCMD='$(DEP$(1)) $(DEP$(1)FLAGS) $($(1)DEP_FLAGS) $< 2>/dev/null | sed -e "/^\#.*/d" -e "s,^[[:space:]]*$(@F),$(@D)/$(@F)," > $(@:.o=.d)'
 DEPFLAGS='-MM'
 
+mkdir -p ffbuild
+
 # find source path
 if test -f configure; then
     source_path=.
@@ -3425,6 +3603,9 @@ for opt do
             action=${opt%%-random=*}
             do_random ${action#--} $optval
         ;;
+        --enable-sdl)
+            enable sdl2
+        ;;
         --enable-*=*|--disable-*=*)
             eval $(echo "${opt%%=*}" | sed 's/--/action=/;s/-/ thing=/')
             is_in "${thing}s" $COMPONENT_LIST || die_unknown "$opt"
@@ -3434,6 +3615,16 @@ for opt do
             [ "$list" = "" ] && warn "Option $opt did not match anything"
             $action $list
         ;;
+        --enable-yasm|--disable-yasm)
+            warn "The ${opt} option is only provided for compatibility and will be\n"\
+                 "removed in the future. Use --enable-x86asm / --disable-x86asm instead."
+            test $opt = --enable-yasm && x86asm=yes || x86asm=no
+        ;;
+        --yasmexe=*)
+            warn "The --yasmexe option is only provided for compatibility and will be\n"\
+                 "removed in the future. Use --x86asmexe instead."
+            x86asmexe="$optval"
+        ;;
         --enable-?*|--disable-?*)
             eval $(echo "$opt" | sed 's/--/action=/;s/-/ option=/;s/-/_/g')
             if is_in $option $COMPONENT_LIST; then
@@ -3453,8 +3644,13 @@ for opt do
         ;;
         --help|-h) show_help
         ;;
+        --quiet|-q) quiet=yes
+        ;;
         --fatal-warnings) enable fatal_warnings
         ;;
+        --libfuzzer=*)
+            libfuzzer_path="$optval"
+        ;;
         *)
             optname="${opt%%=*}"
             optname="${optname#--}"
@@ -3474,8 +3670,41 @@ for e in $env; do
     eval "export $e"
 done
 
+if disabled autodetect; then
+
+    # Unless iconv is explicitely disabled by the user, we still want to probe
+    # for the iconv from the libc.
+    disabled iconv || enable libc_iconv
+
+    disable_weak $EXTERNAL_AUTODETECT_LIBRARY_LIST
+    disable_weak $HWACCEL_AUTODETECT_LIBRARY_LIST
+fi
+# Mark specifically enabled, but normally autodetected libraries as requested.
+for lib in $AUTODETECT_LIBS; do
+    enabled $lib && request $lib
+done
+#TODO: switch to $AUTODETECT_LIBS when $THREADS_LIST is supported the same way
+enable_weak $EXTERNAL_AUTODETECT_LIBRARY_LIST
+enable_weak $HWACCEL_AUTODETECT_LIBRARY_LIST
+
 disabled logging && logfile=/dev/null
 
+die_license_disabled() {
+    enabled $1 || { enabled $v && die "$v is $1 and --enable-$1 is not specified."; }
+}
+
+die_license_disabled_gpl() {
+    enabled $1 || { enabled $v && die "$v is incompatible with the gpl and --enable-$1 is not specified."; }
+}
+
+map "die_license_disabled gpl"      $EXTERNAL_LIBRARY_GPL_LIST $EXTERNAL_LIBRARY_GPLV3_LIST
+map "die_license_disabled version3" $EXTERNAL_LIBRARY_VERSION3_LIST $EXTERNAL_LIBRARY_GPLV3_LIST
+
+enabled gpl && map "die_license_disabled_gpl nonfree" $EXTERNAL_LIBRARY_NONFREE_LIST
+map "die_license_disabled nonfree" $HWACCEL_LIBRARY_NONFREE_LIST
+
+enabled version3 && { enabled gpl && enable gplv3 || enable lgplv3; }
+
 # Disable all the library-specific components if the library itself
 # is disabled, see AVCODEC_LIST and following _LIST variables.
 
@@ -3493,6 +3722,11 @@ set >> $logfile
 
 test -n "$valgrind" && toolchain="valgrind-memcheck"
 
+enabled ossfuzz && {
+    add_cflags  -fsanitize=address,undefined -fsanitize-coverage=trace-pc-guard,trace-cmp -fno-omit-frame-pointer
+    add_ldflags -fsanitize=address,undefined -fsanitize-coverage=trace-pc-guard,trace-cmp
+}
+
 case "$toolchain" in
     *-asan)
         cc_default="${toolchain%-asan}"
@@ -3506,7 +3740,7 @@ case "$toolchain" in
     ;;
     *-tsan)
         cc_default="${toolchain%-tsan}"
-        add_cflags  -fsanitize=thread -pie
+        add_cflags  -fsanitize=thread -fPIE
         add_ldflags -fsanitize=thread -pie
         case "$toolchain" in
             gcc-tsan)
@@ -3541,8 +3775,10 @@ case "$toolchain" in
         cl_major_ver=$(cl 2>&1 | sed -n 's/.*Version \([[:digit:]]\{1,\}\)\..*/\1/p')
         if [ -z "$cl_major_ver" ] || [ $cl_major_ver -ge 18 ]; then
             cc_default="cl"
+            cxx_default="cl"
         else
             cc_default="c99wrap cl"
+            cxx_default="c99wrap cl"
         fi
         ld_default="$source_path/compat/windows/mslink"
         nm_default="dumpbin -symbols"
@@ -3591,7 +3827,7 @@ test -n "$cross_prefix" && enable cross_compile
 
 if enabled cross_compile; then
     test -n "$arch" && test -n "$target_os" ||
-        die "Must specify target arch and OS when cross-compiling"
+        die "Must specify target arch (--arch) and OS (--target-os) when cross-compiling"
 fi
 
 ar_default="${cross_prefix}${ar_default}"
@@ -3610,7 +3846,7 @@ windres_default="${cross_prefix}${windres_default}"
 sysinclude_default="${sysroot}/usr/include"
 
 set_default arch cc cxx doxygen pkg_config ranlib strip sysinclude \
-    target_exec target_os yasmexe
+    target_exec target_os x86asmexe nvcc
 enabled cross_compile || host_cc_default=$cc
 set_default host_cc
 
@@ -3644,25 +3880,32 @@ HOSTEXESUF=$(exesuf $host_os)
 
 if [ -n "$tempprefix" ] ; then
     mktemp(){
-        echo $tempprefix.${HOSTNAME}.${UID}
+        tmpname="$tempprefix.${HOSTNAME}.${UID}"
+        echo "$tmpname"
+        mkdir "$tmpname"
     }
 elif ! check_cmd mktemp -u XXXXXX; then
     # simple replacement for missing mktemp
     # NOT SAFE FOR GENERAL USE
     mktemp(){
-        echo "${2%%XXX*}.${HOSTNAME}.${UID}.$$"
+        tmpname="${2%%XXX*}.${HOSTNAME}.${UID}.$$"
+        echo "$tmpname"
+        mkdir "$tmpname"
     }
 fi
 
+FFTMPDIR=$(mktemp -d "${TMPDIR}/ffconf.XXXXXXXX" 2> /dev/null) ||
+    die "Unable to create temporary directory in $TMPDIR."
+
 tmpfile(){
-    tmp=$(mktemp -u "${TMPDIR}/ffconf.XXXXXXXX")$2 &&
-        (set -C; exec > $tmp) 2>/dev/null ||
-        die "Unable to create temporary file in $TMPDIR."
-    append TMPFILES $tmp
+    tmp="${FFTMPDIR}/test"$2
+    (set -C; exec > $tmp) 2> /dev/null ||
+        die "Unable to create temporary file in $FFTMPDIR."
     eval $1=$tmp
 }
 
-trap 'rm -f -- $TMPFILES' EXIT
+trap 'rm -rf -- "$FFTMPDIR"' EXIT
+trap 'exit 2' INT
 
 tmpfile TMPASM .asm
 tmpfile TMPC   .c
@@ -3740,6 +3983,7 @@ msvc_common_flags(){
             # specific filters, they must be specified here as well or else the
             # generic catch all at the bottom will print the original flag.
             -Wall)                ;;
+            -Wextra)              ;;
             -std=c99)             ;;
             # Common flags
             -fomit-frame-pointer) ;;
@@ -3751,9 +3995,8 @@ msvc_common_flags(){
             -mthumb)              ;;
             -march=*)             ;;
             -lz)                  echo zlib.lib ;;
-            -lavifil32)           echo vfw32.lib ;;
-            -lavicap32)           echo vfw32.lib user32.lib ;;
             -lx264)               echo libx264.lib ;;
+            -lstdc++)             ;;
             -l*)                  echo ${flag#-l}.lib ;;
             -LARGEADDRESSAWARE)   echo $flag ;;
             -L*)                  echo -libpath:${flag#-L} ;;
@@ -3766,11 +4009,13 @@ msvc_flags(){
     msvc_common_flags "$@"
     for flag; do
         case $flag in
-            -Wall)                echo -W4 -wd4244 -wd4127 -wd4018 -wd4389     \
+            -Wall)                echo -W3 -wd4018 -wd4146 -wd4244 -wd4305     \
+                                       -wd4554 ;;
+            -Wextra)              echo -W4 -wd4244 -wd4127 -wd4018 -wd4389     \
                                        -wd4146 -wd4057 -wd4204 -wd4706 -wd4305 \
                                        -wd4152 -wd4324 -we4013 -wd4100 -wd4214 \
                                        -wd4307 \
-                                       -wd4273 -wd4554 -wd4701 ;;
+                                       -wd4273 -wd4554 -wd4701 -wd4703 ;;
         esac
     done
 }
@@ -3971,7 +4216,7 @@ probe_cc(){
         _ident=$($_cc --version 2>/dev/null | head -n1)
         _depflags='-MMD -MF $(@:.o=.d) -MT $@'
         _cflags_speed='-O3'
-        _cflags_size='-Os'
+        _cflags_size='-Oz'
     elif $_cc -V 2>&1 | grep -q Sun; then
         _type=suncc
         _ident=$($_cc -V 2>&1 | head -n1 | cut -d' ' -f 2-)
@@ -4031,8 +4276,20 @@ probe_cc(){
         _flags='-nologo -Qdiag-error:4044,10157'
         # -Qvec- -Qsimd- to prevent miscompilation, -GS, fp:precise for consistency
         # with MSVC which enables it by default.
-        _cflags='-D_USE_MATH_DEFINES -Qms0 -Qvec- -Qsimd- -GS -fp:precise'
+        _cflags='-Qms0 -Qvec- -Qsimd- -GS -fp:precise'
         disable stripping
+    elif $_cc -? 2>/dev/null | grep -q 'LLVM.*Linker'; then
+        # lld can emulate multiple different linkers; in ms link.exe mode,
+        # the -? parameter gives the help output which contains an identifyable
+        # string, while it gives an error in other modes.
+        _type=lld-link
+        # The link.exe mode doesn't have a switch for getting the version,
+        # but we can force it back to gnu mode and get the version from there.
+        _ident=$($_cc -flavor gnu --version 2>/dev/null)
+        _ld_o='-out:$@'
+        _flags_filter=msvc_flags
+        _ld_lib='lib%.a'
+        _ld_path='-libpath:'
     elif $_cc -nologo- 2>&1 | grep -q Microsoft; then
         _type=msvc
         _ident=$($_cc 2>&1 | head -n1)
@@ -4040,6 +4297,7 @@ probe_cc(){
         _DEPFLAGS='$(CPPFLAGS) $(CFLAGS) -showIncludes -Zs'
         _cflags_speed="-O2"
         _cflags_size="-O1"
+        _cflags_noopt="-O1"
         if $_cc -nologo- 2>&1 | grep -q Linker; then
             _ld_o='-out:$@'
         else
@@ -4051,7 +4309,6 @@ probe_cc(){
         _ld_lib='lib%.a'
         _ld_path='-libpath:'
         _flags='-nologo'
-        _cflags='-D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS'
         disable stripping
     elif $_cc --version 2>/dev/null | grep -q ^cparser; then
         _type=cparser
@@ -4088,9 +4345,11 @@ cflags_noopt=$_cflags_noopt
 add_cflags $_flags $_cflags
 cc_ldflags=$_ldflags
 set_ccvars CC
+set_ccvars CXX
 
 probe_cc hostcc "$host_cc"
 host_cflags_filter=$_flags_filter
+host_cflags_speed=$_cflags_speed
 add_host_cflags  $_flags $_cflags
 set_ccvars HOSTCC
 
@@ -4574,19 +4833,21 @@ fi
 
 add_cppflags -D_ISOC99_SOURCE
 add_cxxflags -D__STDC_CONSTANT_MACROS
-add_cxxflags -std=c++98
-check_cflags -std=c99
-check_cc -D_FILE_OFFSET_BITS=64 <<EOF && add_cppflags -D_FILE_OFFSET_BITS=64
-#include <stdlib.h>
-EOF
-check_cc -D_LARGEFILE_SOURCE <<EOF && add_cppflags -D_LARGEFILE_SOURCE
-#include <stdlib.h>
-EOF
+check_cxxflags -std=c++11 || check_cxxflags -std=c++0x
+
+# some compilers silently accept -std=c11, so we also need to check that the
+# version macro is defined properly
+test_cflags_cc -std=c11 ctype.h "__STDC_VERSION__ >= 201112L" &&
+    add_cflags -std=c11 ||
+    check_cflags -std=c99
+
+check_cppflags -D_FILE_OFFSET_BITS=64
+check_cppflags -D_LARGEFILE_SOURCE
 
 add_host_cppflags -D_ISOC99_SOURCE
 check_host_cflags -std=c99
 check_host_cflags -Wall
-check_host_cflags -O3
+check_host_cflags $host_cflags_speed
 
 check_64bit(){
     arch32=$1
@@ -4639,6 +4900,8 @@ esac
 enable $subarch
 enabled spic && enable_weak pic
 
+enabled x86_64 && objformat=elf64 || objformat="elf32"
+
 # OS specific
 case $target_os in
     aix)
@@ -4656,7 +4919,7 @@ case $target_os in
     haiku)
         prefix_default="/boot/common"
         network_extralibs="-lnetwork"
-        host_libs=
+        host_extralibs=
         ;;
     sunos)
         SHFLAGS='-shared -Wl,-h,$$(@F)'
@@ -4709,7 +4972,7 @@ case $target_os in
         SLIBNAME_WITH_VERSION='$(SLIBPREF)$(FULLNAME).$(LIBVERSION)$(SLIBSUF)'
         SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME).$(LIBMAJOR)$(SLIBSUF)'
         objformat="macho"
-        enabled x86_64 && objformat="macho64"
+        enabled x86_64 && objformat="macho64" || objformat="macho32"
         enabled_any pic shared x86_64 ||
             { check_cflags -mdynamic-no-pic && add_asflags -mdynamic-no-pic; }
         check_header dispatch/dispatch.h &&
@@ -4726,8 +4989,6 @@ case $target_os in
         else
             target_os=mingw32
         fi
-        decklink_outdev_extralibs="$decklink_outdev_extralibs -lole32 -loleaut32"
-        decklink_indev_extralibs="$decklink_indev_extralibs -lole32 -loleaut32"
         LIBTARGET=i386
         if enabled x86_64; then
             LIBTARGET="i386:x86-64"
@@ -4743,7 +5004,7 @@ case $target_os in
         SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME)-$(LIBMAJOR)$(SLIBSUF)'
         dlltool="${cross_prefix}dlltool"
         if check_cmd lib.exe -list; then
-            SLIB_EXTRA_CMD=-'sed -e "s/ @[^ ]*//" $$(@:$(SLIBSUF)=.orig.def) > $$(@:$(SLIBSUF)=.def); lib.exe /machine:$(LIBTARGET) /def:$$(@:$(SLIBSUF)=.def) /out:$(SUBDIR)$(SLIBNAME:$(SLIBSUF)=.lib)'
+            SLIB_EXTRA_CMD=-'sed -e "s/ @[^ ]*//" $$(@:$(SLIBSUF)=.orig.def) > $$(@:$(SLIBSUF)=.def); lib.exe -nologo -machine:$(LIBTARGET) -def:$$(@:$(SLIBSUF)=.def) -out:$(SUBDIR)$(SLIBNAME:$(SLIBSUF)=.lib)'
             if enabled x86_64; then
                 LIBTARGET=x64
             fi
@@ -4755,7 +5016,7 @@ case $target_os in
         SLIB_INSTALL_EXTRA_SHLIB='$(SLIBNAME:$(SLIBSUF)=.lib)'
         SLIB_INSTALL_EXTRA_LIB='lib$(SLIBNAME:$(SLIBSUF)=.dll.a) $(SLIBNAME_WITH_MAJOR:$(SLIBSUF)=.def)'
         SHFLAGS='-shared -Wl,--output-def,$$(@:$(SLIBSUF)=.orig.def) -Wl,--out-implib,$(SUBDIR)lib$(SLIBNAME:$(SLIBSUF)=.dll.a) -Wl,--enable-runtime-pseudo-reloc -Wl,--disable-auto-image-base'
-        objformat="win32"
+        enabled x86_64 && objformat="win64" || objformat="win32"
         ranlib=:
         enable dos_paths
         check_ldflags -Wl,--nxcompat,--dynamicbase
@@ -4779,15 +5040,13 @@ case $target_os in
         if enabled shared; then
             # Link to the import library instead of the normal static library
             # for shared libs.
-            LD_LIB='myth%.lib'
-            LD_MYTH_LIB='myth%.lib'
+            LD_LIB='%.lib'
             # Cannot build both shared and static libs with MSVC or icl.
             disable static
         fi
         enabled x86_32 && check_ldflags -LARGEADDRESSAWARE
         shlibdir_default="$bindir_default"
-        LIBPREF="myth"
-        SLIBPREF="myth"
+        SLIBPREF=""
         SLIBSUF=".dll"
         SLIBNAME_WITH_VERSION='$(SLIBPREF)$(FULLNAME)-$(LIBVERSION)$(SLIBSUF)'
         SLIBNAME_WITH_MAJOR='$(SLIBPREF)$(FULLNAME)-$(LIBMAJOR)$(SLIBSUF)'
@@ -4797,7 +5056,7 @@ case $target_os in
         SLIB_INSTALL_EXTRA_SHLIB='$(SLIBNAME:$(SLIBSUF)=.lib)'
         SLIB_INSTALL_EXTRA_LIB='$(SLIBNAME_WITH_MAJOR:$(SLIBSUF)=.def)'
         SHFLAGS='-dll -def:$$(@:$(SLIBSUF)=.def) -implib:$(SUBDIR)$(SLIBNAME:$(SLIBSUF)=.lib)'
-        objformat="win32"
+        enabled x86_64 && objformat="win64" || objformat="win32"
         ranlib=:
         enable dos_paths
         ;;
@@ -4812,7 +5071,7 @@ case $target_os in
         SLIB_INSTALL_LINKS=
         SLIB_INSTALL_EXTRA_LIB='lib$(FULLNAME).dll.a'
         SHFLAGS='-shared -Wl,--out-implib,$(SUBDIR)lib$(FULLNAME).dll.a'
-        objformat="win32"
+        enabled x86_64 && objformat="win64" || objformat="win32"
         enable dos_paths
         enabled shared && ! enabled small && check_cmd $windres --version && enable gnu_windres
         add_cppflags -D_POSIX_C_SOURCE=200112 -D_XOPEN_SOURCE=600
@@ -4824,8 +5083,8 @@ case $target_os in
         add_cppflags -U__STRICT_ANSI__
         ;;
     linux)
-        enable dv1394
         enable section_data_rel_ro
+        enabled_any arm aarch64 && enable_weak linux_perf
         ;;
     irix*)
         target_os=irix
@@ -4833,9 +5092,10 @@ case $target_os in
         ;;
     os/2*)
         strip="lxlite -CS"
+        striptype=""
         objformat="aout"
         add_cppflags -D_GNU_SOURCE
-        add_ldflags -Zomf -Zbin-files -Zargs-wild -Zmap
+        add_ldflags -Zomf -Zbin-files -Zargs-wild -Zhigh-mem -Zmap
         SHFLAGS='$(SUBDIR)$(NAME).def -Zdll -Zomf'
         LIBSUF="_s.a"
         SLIBPREF=""
@@ -4881,18 +5141,6 @@ case $target_os in
         ;;
     minix)
         ;;
-    plan9)
-        add_cppflags -D_C99_SNPRINTF_EXTENSION  \
-                     -D_REENTRANT_SOURCE        \
-                     -D_RESEARCH_SOURCE         \
-                     -DFD_SETSIZE=96            \
-                     -DHAVE_SOCK_OPTS
-        add_compat strtod.o strtod=avpriv_strtod
-        network_extralibs='-lbsd'
-        exeobjs=compat/plan9/main.o
-        disable ffserver
-        cp_f='cp'
-        ;;
     none)
         ;;
     *)
@@ -4935,7 +5183,7 @@ probe_libc(){
     # MinGW headers can be installed on Cygwin, so check for newlib first.
     elif check_${pfx}cpp_condition newlib.h "defined _NEWLIB_VERSION"; then
         eval ${pfx}libc_type=newlib
-        add_${pfx}cppflags -U__STRICT_ANSI__
+        add_${pfx}cppflags -U__STRICT_ANSI__ -D_XOPEN_SOURCE=600
     # MinGW64 is backwards compatible with MinGW32, so check for it first.
     elif check_${pfx}cpp_condition _mingw.h "defined __MINGW64_VERSION_MAJOR"; then
         eval ${pfx}libc_type=mingw64
@@ -4955,6 +5203,8 @@ probe_libc(){
         add_${pfx}cppflags -U__STRICT_ANSI__ -D__USE_MINGW_ANSI_STDIO=1
         check_${pfx}cpp_condition _mingw.h "defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0502" ||
             add_${pfx}cppflags -D_WIN32_WINNT=0x0502
+        check_${pfx}cpp_condition _mingw.h "__MSVCRT_VERSION__ < 0x0700" &&
+            add_${pfx}cppflags -D__MSVCRT_VERSION__=0x0700
         eval test \$${pfx_no_}cc_type = "gcc" &&
             add_${pfx}cppflags -D__printf__=__gnu_printf__
     elif check_${pfx}cpp_condition crtversion.h "defined _VC_CRT_MAJOR_VERSION"; then
@@ -4969,6 +5219,7 @@ probe_libc(){
                                              vsnprintf=avpriv_vsnprintf
             fi
         fi
+        add_${pfx}cppflags -D_USE_MATH_DEFINES -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS
         # The MSVC 2010 headers (Win 7.0 SDK) set _WIN32_WINNT to
         # 0x601 by default unless something else is set by the user.
         # This can easily lead to us detecting functions only present
@@ -4988,6 +5239,10 @@ probe_libc(){
 #endif
 #endif
 EOF
+        if [ "$pfx" = "" ]; then
+            check_func strtoll || add_cflags -Dstrtoll=_strtoi64
+            check_func strtoull || add_cflags -Dstrtoull=_strtoui64
+        fi
     elif check_${pfx}cpp_condition stddef.h "defined __KLIBC__"; then
         eval ${pfx}libc_type=klibc
     elif check_${pfx}cpp_condition sys/cdefs.h "defined __BIONIC__"; then
@@ -5012,26 +5267,25 @@ test -n "$libc_type" && enable libc_$libc_type
 probe_libc host_
 test -n "$host_libc_type" && enable host_libc_$host_libc_type
 
+# hacks for compiler/libc/os combinations
+
 case $libc_type in
     bionic)
         add_compat strtod.o strtod=avpriv_strtod
         ;;
+    glibc)
+        if enabled tms470; then
+            CPPFLAGS="-I${source_path}/compat/tms470 ${CPPFLAGS}"
+            add_cppflags -D__USER_LABEL_PREFIX__=
+            add_cppflags -D__builtin_memset=memset
+            add_cppflags -D__gnuc_va_list=va_list -D_VA_LIST_DEFINED
+            add_cflags   -pds=48    # incompatible redefinition of macro
+        elif enabled ccc; then
+            add_ldflags -Wl,-z,now  # calls to libots crash without this
+        fi
+        ;;
 esac
 
-# hacks for compiler/libc/os combinations
-
-if enabled_all tms470 libc_glibc; then
-    CPPFLAGS="-I${source_path}/compat/tms470 ${CPPFLAGS}"
-    add_cppflags -D__USER_LABEL_PREFIX__=
-    add_cppflags -D__builtin_memset=memset
-    add_cppflags -D__gnuc_va_list=va_list -D_VA_LIST_DEFINED
-    add_cflags   -pds=48    # incompatible redefinition of macro
-fi
-
-if enabled_all ccc libc_glibc; then
-    add_ldflags -Wl,-z,now  # calls to libots crash without this
-fi
-
 check_compile_assert flt_lim "float.h limits.h" "DBL_MAX == (double)DBL_MAX" ||
     add_cppflags '-I\$(SRC_PATH)/compat/float'
 
@@ -5039,7 +5293,7 @@ esc(){
     echo "$*" | sed 's/%/%25/g;s/:/%3a/g'
 }
 
-echo "config:$arch:$subarch:$cpu:$target_os:$(esc $cc_ident):$(esc $FFMPEG_CONFIGURATION)" >config.fate
+echo "config:$arch:$subarch:$cpu:$target_os:$(esc $cc_ident):$(esc $FFMPEG_CONFIGURATION)" > ffbuild/config.fate
 
 check_cpp_condition stdlib.h "defined(__PIC__) || defined(__pic__) || defined(PIC)" && enable_weak pic
 
@@ -5061,40 +5315,7 @@ EOF
     exit 1
 fi
 
-die_license_disabled() {
-    enabled $1 || { enabled $2 && die "$2 is $1 and --enable-$1 is not specified."; }
-}
-
-die_license_disabled_gpl() {
-    enabled $1 || { enabled $2 && die "$2 is incompatible with the gpl and --enable-$1 is not specified."; }
-}
-
-die_license_disabled gpl frei0r
-die_license_disabled gpl libcdio
-die_license_disabled gpl librubberband
-die_license_disabled gpl libsmbclient
-die_license_disabled gpl libvidstab
-die_license_disabled gpl libx264
-die_license_disabled gpl libx265
-die_license_disabled gpl libxavs
-die_license_disabled gpl libxvid
-die_license_disabled gpl x11grab
-
-die_license_disabled nonfree cuda
-die_license_disabled nonfree cuvid
-die_license_disabled nonfree libnpp
-enabled gpl && die_license_disabled_gpl nonfree libfdk_aac
-enabled gpl && die_license_disabled_gpl nonfree openssl
-
-die_license_disabled version3 gmp
-die_license_disabled version3 libopencore_amrnb
-die_license_disabled version3 libopencore_amrwb
-die_license_disabled version3 libsmbclient
-die_license_disabled version3 libvo_amrwbenc
-
-enabled version3 && { enabled gpl && enable gplv3 || enable lgplv3; }
-
-disabled optimizations || check_cflags -fomit-frame-pointer
+disabled optimizations || enabled ossfuzz || check_cflags -fomit-frame-pointer
 
 enable_weak_pic() {
     disabled pic && return
@@ -5118,9 +5339,7 @@ EOF
 sym=$($nm $TMPO | awk '/ff_extern/{ print substr($0, match($0, /[^ \t]*ff_extern/)) }')
 extern_prefix=${sym%%ff_extern*}
 
-check_cc <<EOF && enable_weak inline_asm
-void foo(void) { __asm__ volatile ("" ::); }
-EOF
+check_inline_asm inline_asm '"" ::'
 
 _restrict=
 for restrict_keyword in restrict __restrict__ __restrict; do
@@ -5146,6 +5365,11 @@ unsigned int endian = 'B' << 24 | 'I' << 16 | 'G' << 8 | 'E';
 EOF
 od -t x1 $TMPO | grep -q '42 *49 *47 *45' && enable bigendian
 
+check_cc <<EOF && enable const_nan
+#include <math.h>
+void foo(void) { struct { double d; } static const bar[] = { { NAN } }; }
+EOF
+
 if ! enabled ppc64 || enabled bigendian; then
     disable vsx
 fi
@@ -5255,10 +5479,14 @@ EOF
     check_as <<EOF && enable as_dn_directive
 ra .dn d0.i16
 .unreq ra
+EOF
+    check_as <<EOF && enable as_fpu_directive
+.fpu neon
 EOF
 
     # llvm's integrated assembler supports .object_arch from llvm 3.5
-    [ "$objformat" = elf ] && check_as <<EOF && enable as_object_arch
+    [ "$objformat" = elf32 ] || [ "$objformat" = elf64 ] &&
+        check_as <<EOF && enable as_object_arch
 .object_arch armv4
 EOF
 
@@ -5288,6 +5516,10 @@ elif enabled mips; then
     enabled mipsdsp && check_inline_asm_flags mipsdsp '"addu.qb $t0, $t1, $t2"' '-mdsp'
     enabled mipsdspr2 && check_inline_asm_flags mipsdspr2 '"absq_s.qb $t0, $t1"' '-mdspr2'
 
+    if enabled bigendian && enabled msa; then
+        disable msa
+    fi
+
 elif enabled parisc; then
 
     if enabled gcc; then
@@ -5365,34 +5597,39 @@ EOF
     enabled ssse3  && check_inline_asm ssse3_inline  '"pabsw %xmm0, %xmm0"'
     enabled mmxext && check_inline_asm mmxext_inline '"pmaxub %mm0, %mm1"'
 
-    if ! disabled_any asm mmx yasm; then
-        if check_cmd $yasmexe --version; then
-            enabled x86_64 && yasm_extra="-m amd64"
-            yasm_debug="-g dwarf2"
-        elif check_cmd nasm -v; then
-            yasmexe=nasm
-            yasm_debug="-g -F dwarf"
-            if enabled x86_64; then
-                case "$objformat" in
-                    elf)   objformat=elf64 ;;
-                    win32) objformat=win64 ;;
-                esac
-            fi
+    probe_x86asm(){
+        x86asmexe_probe=$1
+        if check_cmd $x86asmexe_probe -v; then
+            x86asmexe=$x86asmexe_probe
+            x86asm_type=nasm
+            x86asm_debug="-g -F dwarf"
+        elif check_cmd $x86asmexe_probe --version; then
+            x86asmexe=$x86asmexe_probe
+            x86asm_type=yasm
+            x86asm_debug="-g dwarf2"
         fi
+        check_x86asm "movbe ecx, [5]" && enable x86asm
+    }
 
-        YASMFLAGS="-f $objformat $yasm_extra"
-        enabled pic               && append YASMFLAGS "-DPIC"
-        test -n "$extern_prefix"  && append YASMFLAGS "-DPREFIX"
+    if ! disabled_any asm mmx x86asm; then
+        disable x86asm
+        for program in $x86asmexe nasm yasm; do
+            probe_x86asm $program && break
+        done
+        disabled x86asm && die "nasm/yasm not found or too old. Use --disable-x86asm for a crippled build."
+        test $x86asm_type = 'nasm' && X86ASM_DEPFLAGS='-MD $(@:.o=.d)'
+        test $x86asm_type = 'yasm' && X86ASMDEP='$(DEPX86ASM) $(X86ASMFLAGS) -M $(X86ASM_O) $< > $(@:.o=.d)'
+        X86ASMFLAGS="-f $objformat"
+        enabled pic               && append X86ASMFLAGS "-DPIC"
+        test -n "$extern_prefix"  && append X86ASMFLAGS "-DPREFIX"
         case "$objformat" in
-            elf*) enabled debug && append YASMFLAGS $yasm_debug ;;
+            elf*) enabled debug && append X86ASMFLAGS $x86asm_debug ;;
         esac
 
-        check_yasm "movbe ecx, [5]" && enable yasm ||
-            die "yasm/nasm not found or too old. Use --disable-yasm for a crippled build."
-        check_yasm "vextracti128 xmm0, ymm0, 0"      || disable avx2_external
-        check_yasm "vpmacsdd xmm0, xmm1, xmm2, xmm3" || disable xop_external
-        check_yasm "vfmaddps ymm0, ymm1, ymm2, ymm3" || disable fma4_external
-        check_yasm "CPU amdnop" || disable cpunop
+        check_x86asm "vextracti128 xmm0, ymm0, 0"      || disable avx2_external
+        check_x86asm "vpmacsdd xmm0, xmm1, xmm2, xmm3" || disable xop_external
+        check_x86asm "vfmaddps ymm0, ymm1, ymm2, ymm3" || disable fma4_external
+        check_x86asm "CPU amdnop" || disable cpunop
     fi
 
     case "$cpu" in
@@ -5408,21 +5645,6 @@ check_code cc arm_neon.h "int16x8_t test = vdupq_n_s16(0)" && enable intrinsics_
 check_ldflags -Wl,--as-needed
 check_ldflags -Wl,-z,noexecstack
 
-if check_func dlopen && check_func dlsym; then
-    ldl=
-elif check_func dlopen -ldl && check_func dlsym -ldl; then
-    ldl=-ldl
-fi
-
-decklink_outdev_extralibs="$decklink_outdev_extralibs $ldl"
-decklink_indev_extralibs="$decklink_indev_extralibs $ldl"
-frei0r_filter_extralibs='$ldl'
-frei0r_src_filter_extralibs='$ldl'
-ladspa_filter_extralibs='$ldl'
-nvenc_extralibs='$ldl'
-coreimage_filter_extralibs="-framework QuartzCore -framework AppKit -framework OpenGL"
-coreimagesrc_filter_extralibs="-framework QuartzCore -framework AppKit -framework OpenGL"
-
 if ! disabled network; then
     check_func getaddrinfo $network_extralibs
     check_func inet_aton $network_extralibs
@@ -5464,7 +5686,6 @@ if ! disabled network; then
 fi
 
 check_builtin atomic_cas_ptr atomic.h "void **ptr; void *oldval, *newval; atomic_cas_ptr(ptr, oldval, newval)"
-check_builtin atomic_compare_exchange "" "int *ptr, *oldval; int newval; __atomic_compare_exchange_n(ptr, oldval, newval, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)"
 check_builtin machine_rw_barrier mbarrier.h "__machine_rw_barrier()"
 check_builtin MemoryBarrier windows.h "MemoryBarrier()"
 check_builtin sarestart signal.h "SA_RESTART"
@@ -5480,7 +5701,7 @@ case "$custom_allocator" in
         require libjemalloc jemalloc/jemalloc.h malloc -ljemalloc
     ;;
     tcmalloc)
-        require_pkg_config libtcmalloc gperftools/tcmalloc.h tc_malloc
+        require_pkg_config libtcmalloc libtcmalloc gperftools/tcmalloc.h tc_malloc
         malloc_prefix=tc_
     ;;
 esac
@@ -5491,7 +5712,8 @@ check_func  ${malloc_prefix}posix_memalign      && enable posix_memalign
 
 check_func  access
 check_func_headers stdlib.h arc4random
-check_func_headers time.h clock_gettime || { check_func_headers time.h clock_gettime -lrt && add_extralibs -lrt && LIBRT="-lrt"; }
+check_func_headers time.h clock_gettime ||
+    { check_lib clock_gettime time.h clock_gettime -lrt && LIBRT="-lrt"; }
 check_func  fcntl
 check_func  fork
 check_func  gethrtime
@@ -5504,7 +5726,8 @@ check_func  mkstemp
 check_func  mmap
 check_func  mprotect
 # Solaris has nanosleep in -lrt, OpenSolaris no longer needs that
-check_func_headers time.h nanosleep || { check_func_headers time.h nanosleep -lrt && add_extralibs -lrt && LIBRT="-lrt"; }
+check_func_headers time.h nanosleep ||
+    { check_lib nanosleep time.h nanosleep -lrt && LIBRT="-lrt"; }
 check_func  sched_getaffinity
 check_func  setrlimit
 check_struct "sys/stat.h" "struct stat" st_mtim.tv_nsec -D_BSD_SOURCE
@@ -5519,7 +5742,6 @@ check_func_headers lzo/lzo1x.h lzo1x_999_compress
 check_func_headers stdlib.h getenv
 check_func_headers sys/stat.h lstat
 
-check_func_headers windows.h CoTaskMemFree -lole32
 check_func_headers windows.h GetProcessAffinityMask
 check_func_headers windows.h GetProcessTimes
 check_func_headers windows.h GetSystemTimeAsFileTime
@@ -5535,11 +5757,11 @@ check_func_headers glob.h glob
 enabled xlib &&
     check_func_headers "X11/Xlib.h X11/extensions/Xvlib.h" XvGetPortAttribute -lXv -lX11 -lXext
 
-check_header AudioToolbox/AudioToolbox.h
+check_header d3d11.h
 check_header direct.h
 check_header dirent.h
 check_header dlfcn.h
-check_header d3d11.h
+check_header dxgidebug.h
 check_header dxva.h
 check_header dxva2api.h -D_WIN32_WINNT=0x0600
 check_header io.h
@@ -5557,20 +5779,36 @@ check_header sys/un.h
 check_header termios.h
 check_header unistd.h
 check_header valgrind/valgrind.h
-check_header vdpau/vdpau.h
-check_header vdpau/vdpau_x11.h
 check_header VideoDecodeAcceleration/VDADecoder.h
-check_header VideoToolbox/VideoToolbox.h
 check_func_headers VideoToolbox/VTCompressionSession.h VTCompressionSessionPrepareToEncodeFrames -framework VideoToolbox
-enabled videotoolbox && check_func_headers CoreVideo/CVImageBuffer.h kCVImageBufferColorPrimaries_ITU_R_2020 -framework CoreVideo
 check_header windows.h
-#MYTH check_header X11/extensions/XvMClib.h
+check_header X11/extensions/XvMClib.h
 check_header asm/types.h
 
-check_lib2 "windows.h shellapi.h" CommandLineToArgvW -lshell32
-check_lib2 "windows.h wincrypt.h" CryptGenRandom -ladvapi32
-check_lib2 "windows.h psapi.h" GetProcessMemoryInfo -lpsapi
-check_lib "CoreServices/CoreServices.h" UTGetOSTypeFromString "-framework CoreServices"
+# it seems there are versions of clang in some distros that try to use the
+# gcc headers, which explodes for stdatomic
+# so we also check that atomics actually work here
+check_builtin stdatomic_h stdatomic.h "atomic_int foo, bar = ATOMIC_VAR_INIT(-1); atomic_store(&foo, 0)"
+
+check_lib ole32    "windows.h"            CoTaskMemFree        -lole32
+check_lib shell32  "windows.h shellapi.h" CommandLineToArgvW   -lshell32
+check_lib wincrypt "windows.h wincrypt.h" CryptGenRandom       -ladvapi32
+check_lib psapi    "windows.h psapi.h"    GetProcessMemoryInfo -lpsapi
+
+enabled appkit       && check_apple_framework AppKit
+enabled audiotoolbox && check_apple_framework AudioToolbox
+enabled avfoundation && check_apple_framework AVFoundation
+enabled coreimage    && check_apple_framework CoreImage
+enabled videotoolbox && check_apple_framework VideoToolbox
+
+enabled avfoundation && {
+    check_lib avfoundation CoreGraphics/CoreGraphics.h               CGGetActiveDisplayList "-framework CoreGraphics" ||
+    check_lib avfoundation ApplicationServices/ApplicationServices.h CGGetActiveDisplayList "-framework ApplicationServices"; }
+
+enabled videotoolbox && {
+    check_lib coreservices CoreServices/CoreServices.h UTGetOSTypeFromString "-framework CoreServices"
+    check_func_headers CoreMedia/CMFormatDescription.h kCMVideoCodecType_HEVC "-framework CoreMedia"
+}
 
 check_struct "sys/time.h sys/resource.h" "struct rusage" ru_maxrss
 
@@ -5580,12 +5818,15 @@ check_type "windows.h d3d11.h" "ID3D11VideoDecoder"
 check_type "windows.h d3d11.h" "ID3D11VideoContext"
 check_type "d3d9.h dxva2api.h" DXVA2_ConfigPictureDecode -D_WIN32_WINNT=0x0602
 
-check_type "va/va.h" "VAPictureParameterBufferHEVC"
-check_type "va/va.h" "VADecPictureParameterBufferVP9"
+check_type "va/va.h va/va_dec_hevc.h" "VAPictureParameterBufferHEVC"
+check_struct "va/va.h" "VADecPictureParameterBufferVP9" bit_depth
 check_type "va/va.h va/va_vpp.h" "VAProcPipelineParameterBuffer"
 check_type "va/va.h va/va_enc_h264.h" "VAEncPictureParameterBufferH264"
 check_type "va/va.h va/va_enc_hevc.h" "VAEncPictureParameterBufferHEVC"
 check_type "va/va.h va/va_enc_jpeg.h" "VAEncPictureParameterBufferJPEG"
+check_type "va/va.h va/va_enc_mpeg2.h" "VAEncPictureParameterBufferMPEG2"
+check_type "va/va.h va/va_enc_vp8.h"  "VAEncPictureParameterBufferVP8"
+check_type "va/va.h va/va_enc_vp9.h"  "VAEncPictureParameterBufferVP9"
 
 check_type "vdpau/vdpau.h" "VdpPictureInfoHEVC"
 
@@ -5603,22 +5844,23 @@ fi
 # check for some common methods of building with pthread support
 # do this before the optional library checks as some of them require pthreads
 if ! disabled pthreads && ! enabled w32threads && ! enabled os2threads; then
-    enable pthreads
-    if check_func pthread_join -pthread && check_func pthread_create -pthread; then
+    if check_lib pthreads pthread.h pthread_join   -pthread &&
+       check_lib pthreads pthread.h pthread_create -pthread; then
         add_cflags -pthread
-        add_extralibs -pthread
-    elif check_func pthread_join -pthreads && check_func pthread_create -pthreads; then
+    elif check_lib pthreads pthread.h pthread_join   -pthreads &&
+         check_lib pthreads pthread.h pthread_create -pthreads; then
         add_cflags -pthreads
-        add_extralibs -pthreads
-    elif check_func pthread_join -ldl -pthread && check_func pthread_create -ldl -pthread; then
+    elif check_lib pthreads pthread.h pthread_join   -ldl -pthread &&
+         check_lib pthreads pthread.h pthread_create -ldl -pthread; then
         add_cflags -ldl -pthread
-        add_extralibs -ldl -pthread
-    elif check_func pthread_join -lpthreadGC2 && check_func pthread_create -lpthreadGC2; then
-        add_extralibs -lpthreadGC2
-    elif check_lib pthread.h pthread_join -lpthread && check_lib pthread.h pthread_create -lpthread; then
+    elif check_lib pthreads pthread.h pthread_join   -lpthreadGC2 &&
+         check_lib pthreads pthread.h pthread_create -lpthreadGC2; then
         :
-    elif ! check_func pthread_join && ! check_func pthread_create; then
-        disable pthreads
+    elif check_lib pthreads pthread.h pthread_join   -lpthread &&
+         check_lib pthreads pthread.h pthread_create -lpthread; then
+        :
+    elif check_func pthread_join && check_func pthread_create; then
+        enable pthreads
     fi
     check_code cc "pthread.h" "static pthread_mutex_t atomic_lock = PTHREAD_MUTEX_INITIALIZER" || disable pthreads
 fi
@@ -5631,12 +5873,14 @@ fi
 enabled pthreads &&
     check_builtin sem_timedwait semaphore.h "sem_t *s; sem_init(s,0,0); sem_timedwait(s,0); sem_destroy(s)"
 
-disabled  zlib || check_lib   zlib.h      zlibVersion -lz   || disable  zlib
-disabled bzlib || check_lib2 bzlib.h BZ2_bzlibVersion -lbz2 || disable bzlib
-disabled  lzma || check_lib2  lzma.h lzma_version_number -llzma || disable lzma
+enabled  zlib && check_lib zlib   zlib.h      zlibVersion    -lz
+enabled bzlib && check_lib bzlib bzlib.h BZ2_bzlibVersion    -lbz2
+enabled  lzma && check_lib lzma   lzma.h lzma_version_number -llzma
+
+# On some systems dynamic loading requires no extra linker flags
+check_lib libdl dlfcn.h "dlopen dlsym" || check_lib libdl dlfcn.h "dlopen dlsym" -ldl
 
-check_lib math.h sin -lm && LIBM="-lm"
-disabled crystalhd || check_lib libcrystalhd/libcrystalhd_if.h DtsCrystalHDVersion -lcrystalhd || disable crystalhd
+check_lib libm math.h sin -lm && LIBM="-lm"
 
 atan2f_args=2
 copysign_args=2
@@ -5645,128 +5889,133 @@ ldexpf_args=2
 powf_args=2
 
 for func in $MATH_FUNCS; do
-    eval check_mathfunc $func \${${func}_args:-1}
+    eval check_mathfunc $func \${${func}_args:-1} $LIBM
 done
 
 for func in $COMPLEX_FUNCS; do
     eval check_complexfunc $func \${${func}_args:-1}
 done
 
-# Enable CUVID by default if CUDA is enabled
-if enabled cuda && ! disabled cuvid; then
-    enable cuvid
-fi
-
 # these are off by default, so fail if requested and not available
-enabled avfoundation_indev && { check_header_objcc AVFoundation/AVFoundation.h || disable avfoundation_indev; }
-enabled avfoundation_indev && { check_lib2 CoreGraphics/CoreGraphics.h CGGetActiveDisplayList -framework CoreGraphics ||
-                                check_lib2 ApplicationServices/ApplicationServices.h CGGetActiveDisplayList -framework ApplicationServices; }
-enabled avisynth          && { { check_lib2 "windows.h" LoadLibrary; } ||
-                               { check_lib2 "dlfcn.h" dlopen -ldl; } ||
-                               die "ERROR: LoadLibrary/dlopen not found for avisynth"; }
-enabled cuda              && { check_lib cuda.h cuInit -lcuda ||
-                               die "ERROR: CUDA not found"; }
-enabled cuvid             && { add_cflags -I$source_path;
-                               check_lib "compat/cuda/cuviddec.h" cuvidCreateDecoder -lnvcuvid ||
-                               die "ERROR: CUVID not found"; } &&
-                             { enabled cuda ||
+enabled cuda_sdk          && require cuda_sdk cuda.h cuCtxCreate -lcuda
+enabled cuvid             && { enabled cuda ||
                                die "ERROR: CUVID requires CUDA"; }
 enabled chromaprint       && require chromaprint chromaprint.h chromaprint_get_version -lchromaprint
-enabled coreimage_filter  && { check_header_objcc QuartzCore/CoreImage.h || disable coreimage_filter; }
-enabled coreimagesrc_filter && { check_header_objcc QuartzCore/CoreImage.h || disable coreimagesrc_filter; }
-enabled decklink          && { { check_header DeckLinkAPI.h || die "ERROR: DeckLinkAPI.h header not found"; } &&
+enabled decklink          && { require_header DeckLinkAPI.h &&
                                { check_cpp_condition DeckLinkAPIVersion.h "BLACKMAGIC_DECKLINK_API_VERSION >= 0x0a060100" || die "ERROR: Decklink API version must be >= 10.6.1."; } }
-enabled frei0r            && { check_header frei0r.h || die "ERROR: frei0r.h header not found"; }
-enabled gmp               && require2 gmp gmp.h mpz_export -lgmp
-enabled gnutls            && require_pkg_config gnutls gnutls/gnutls.h gnutls_global_init
-enabled jni               && { [ $target_os = "android" ] && check_header jni.h && enabled pthreads &&
-                               check_lib2 "dlfcn.h" dlopen -ldl; }
-enabled ladspa            && { check_header ladspa.h || die "ERROR: ladspa.h header not found"; }
+enabled libndi_newtek     && require_header Processing.NDI.Lib.h
+enabled frei0r            && require_header frei0r.h
+enabled gmp               && require gmp gmp.h mpz_export -lgmp
+enabled gnutls            && require_pkg_config gnutls gnutls gnutls/gnutls.h gnutls_global_init
+enabled jni               && { [ $target_os = "android" ] && check_header jni.h && enabled pthreads || die "ERROR: jni not found"; }
+enabled ladspa            && require_header ladspa.h
 enabled libiec61883       && require libiec61883 libiec61883/iec61883.h iec61883_cmp_connect -lraw1394 -lavc1394 -lrom1394 -liec61883
-enabled libass            && require_pkg_config libass ass/ass.h ass_library_init
-enabled libbluray         && require_pkg_config libbluray libbluray/bluray.h bd_open
-enabled libbs2b           && require_pkg_config libbs2b bs2b.h bs2b_open
+enabled libass            && require_pkg_config libass libass ass/ass.h ass_library_init
+enabled libbluray         && require_pkg_config libbluray libbluray libbluray/bluray.h bd_open
+enabled libbs2b           && require_pkg_config libbs2b libbs2b bs2b.h bs2b_open
 enabled libcelt           && require libcelt celt/celt.h celt_decode -lcelt0 &&
-                             { check_lib celt/celt.h celt_decoder_create_custom -lcelt0 ||
+                             { check_lib libcelt celt/celt.h celt_decoder_create_custom -lcelt0 ||
                                die "ERROR: libcelt must be installed and version must be >= 0.11.0."; }
-enabled libcaca           && require_pkg_config caca caca.h caca_create_canvas
-enabled libebur128        && require ebur128 ebur128.h ebur128_relative_threshold -lebur128
-enabled libfdk_aac        && { use_pkg_config fdk-aac "fdk-aac/aacenc_lib.h" aacEncOpen ||
+enabled libcaca           && require_pkg_config libcaca caca caca.h caca_create_canvas
+enabled libdc1394         && require_pkg_config libdc1394 libdc1394-2 dc1394/dc1394.h dc1394_new
+enabled libdrm            && require_pkg_config libdrm libdrm xf86drm.h drmGetVersion
+enabled libfdk_aac        && { use_pkg_config libfdk_aac fdk-aac "fdk-aac/aacenc_lib.h" aacEncOpen ||
                                { require libfdk_aac fdk-aac/aacenc_lib.h aacEncOpen -lfdk-aac &&
                                  warn "using libfdk without pkg-config"; } }
-flite_libs="-lflite_cmu_time_awb -lflite_cmu_us_awb -lflite_cmu_us_kal -lflite_cmu_us_kal16 -lflite_cmu_us_rms -lflite_cmu_us_slt -lflite_usenglish -lflite_cmulex -lflite"
-enabled libflite          && require2 libflite "flite/flite.h" flite_init $flite_libs
+flite_extralibs="-lflite_cmu_time_awb -lflite_cmu_us_awb -lflite_cmu_us_kal -lflite_cmu_us_kal16 -lflite_cmu_us_rms -lflite_cmu_us_slt -lflite_usenglish -lflite_cmulex -lflite"
+enabled libflite          && require libflite "flite/flite.h" flite_init $flite_extralibs
 enabled fontconfig        && enable libfontconfig
-enabled libfontconfig     && require_pkg_config fontconfig "fontconfig/fontconfig.h" FcInit
-enabled libfreetype       && require_libfreetype
-enabled libfribidi        && require_pkg_config fribidi fribidi.h fribidi_version_info
-enabled libgme            && require  libgme gme/gme.h gme_new_emu -lgme -lstdc++
+enabled libfontconfig     && require_pkg_config libfontconfig fontconfig "fontconfig/fontconfig.h" FcInit
+enabled libfreetype       && require_pkg_config libfreetype2 freetype2 "ft2build.h FT_FREETYPE_H" FT_Init_FreeType
+enabled libfribidi        && require_pkg_config libfribidi fribidi fribidi.h fribidi_version_info
+enabled libgme            && { use_pkg_config libgme libgme gme/gme.h gme_new_emu ||
+                               require libgme gme/gme.h gme_new_emu -lgme -lstdc++; }
 enabled libgsm            && { for gsm_hdr in "gsm.h" "gsm/gsm.h"; do
-                                   check_lib "${gsm_hdr}" gsm_create -lgsm && break;
+                                   check_lib libgsm "${gsm_hdr}" gsm_create -lgsm && break;
                                done || die "ERROR: libgsm not found"; }
 enabled libilbc           && require libilbc ilbc.h WebRtcIlbcfix_InitDecode -lilbc
-enabled libkvazaar        && require_pkg_config "kvazaar >= 0.8.1" kvazaar.h kvz_api_get
-enabled libmfx            && require_pkg_config libmfx "mfx/mfxvideo.h" MFXInit
-enabled libmodplug        && require_pkg_config libmodplug libmodplug/modplug.h ModPlug_Load
+enabled libkvazaar        && require_pkg_config libkvazaar "kvazaar >= 0.8.1" kvazaar.h kvz_api_get
+# While it may appear that require is being used as a pkg-config
+# fallback for libmfx, it is actually being used to detect a different
+# installation route altogether.  If libmfx is installed via the Intel
+# Media SDK or Intel Media Server Studio, these don't come with
+# pkg-config support.  Instead, users should make sure that the build
+# can find the libraries and headers through other means.
+enabled libmfx            && { use_pkg_config libmfx libmfx "mfx/mfxvideo.h" MFXInit ||
+                               { require libmfx "mfx/mfxvideo.h" MFXInit -llibmfx && warn "using libmfx without pkg-config"; } }
+enabled libmodplug        && require_pkg_config libmodplug libmodplug libmodplug/modplug.h ModPlug_Load
 enabled libmp3lame        && require "libmp3lame >= 3.98.3" lame/lame.h lame_set_VBR_quality -lmp3lame
-enabled libnut            && require libnut libnut.h nut_demuxer_init -lnut
-enabled libnpp            && require libnpp npp.h nppGetLibVersion -lnppi -lnppc
+enabled libmysofa         && require libmysofa "mysofa.h" mysofa_load -lmysofa
+enabled libnpp            && { check_lib libnpp npp.h nppGetLibVersion -lnppig -lnppicc -lnppc ||
+                               check_lib libnpp npp.h nppGetLibVersion -lnppi -lnppc ||
+                               die "ERROR: libnpp not found"; }
 enabled libopencore_amrnb && require libopencore_amrnb opencore-amrnb/interf_dec.h Decoder_Interface_init -lopencore-amrnb
 enabled libopencore_amrwb && require libopencore_amrwb opencore-amrwb/dec_if.h D_IF_init -lopencore-amrwb
 enabled libopencv         && { check_header opencv2/core/core_c.h &&
-                               { use_pkg_config opencv opencv2/core/core_c.h cvCreateImageHeader ||
+                               { use_pkg_config libopencv opencv opencv2/core/core_c.h cvCreateImageHeader ||
                                  require opencv opencv2/core/core_c.h cvCreateImageHeader -lopencv_core -lopencv_imgproc; } ||
-                               require_pkg_config opencv opencv/cxcore.h cvCreateImageHeader; }
-enabled libopenh264       && require_pkg_config openh264 wels/codec_api.h WelsGetCodecVersion
-enabled libopenjpeg       && { { check_lib2 openjpeg-2.1/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
-                               check_lib2 openjpeg-2.1/openjpeg.h opj_version -lopenjp2 ||
-                               { check_lib2 openjpeg-2.0/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
-                               { check_lib2 openjpeg-1.5/openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
-                               { check_lib2 openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               require_pkg_config libopencv opencv opencv/cxcore.h cvCreateImageHeader; }
+enabled libopenh264       && require_pkg_config libopenh264 openh264 wels/codec_api.h WelsGetCodecVersion
+enabled libopenjpeg       && { { check_lib libopenjpeg openjpeg-2.3/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               check_lib libopenjpeg openjpeg-2.3/openjpeg.h opj_version -lopenjp2 ||
+                               { check_lib libopenjpeg openjpeg-2.2/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               check_lib libopenjpeg openjpeg-2.2/openjpeg.h opj_version -lopenjp2 ||
+                               { check_lib libopenjpeg openjpeg-2.1/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               check_lib libopenjpeg openjpeg-2.1/openjpeg.h opj_version -lopenjp2 ||
+                               { check_lib libopenjpeg openjpeg-2.0/openjpeg.h opj_version -lopenjp2 -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               { check_lib libopenjpeg openjpeg-1.5/openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
+                               { check_lib libopenjpeg openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC && add_cppflags -DOPJ_STATIC; } ||
                                die "ERROR: libopenjpeg not found"; }
-enabled libopenmpt        && require_pkg_config "libopenmpt >= 0.2.6557" libopenmpt/libopenmpt.h openmpt_module_create
-enabled libopus           && require_pkg_config opus opus_multistream.h opus_multistream_decoder_create
-enabled libpulse          && require_pkg_config libpulse pulse/pulseaudio.h pa_context_new
-enabled librtmp           && require_pkg_config librtmp librtmp/rtmp.h RTMP_Socket
-enabled librubberband     && require_pkg_config "rubberband >= 1.8.1" rubberband/rubberband-c.h rubberband_new
-enabled libschroedinger   && require_pkg_config schroedinger-1.0 schroedinger/schro.h schro_init
-enabled libshine          && require_pkg_config shine shine/layer3.h shine_encode_buffer
-enabled libsmbclient      && { use_pkg_config smbclient libsmbclient.h smbc_init ||
+enabled libopenmpt        && require_pkg_config libopenmpt "libopenmpt >= 0.2.6557" libopenmpt/libopenmpt.h openmpt_module_create
+enabled libopus           && {
+    enabled libopus_decoder && {
+        require_pkg_config libopus opus opus_multistream.h opus_multistream_decoder_create
+    }
+    enabled libopus_encoder && {
+        require_pkg_config libopus opus opus_multistream.h opus_multistream_surround_encoder_create
+    }
+}
+enabled libpulse          && require_pkg_config libpulse libpulse pulse/pulseaudio.h pa_context_new
+enabled librsvg           && require_pkg_config librsvg librsvg-2.0 librsvg-2.0/librsvg/rsvg.h rsvg_handle_render_cairo
+enabled librtmp           && require_pkg_config librtmp librtmp librtmp/rtmp.h RTMP_Socket
+enabled librubberband     && require_pkg_config librubberband "rubberband >= 1.8.1" rubberband/rubberband-c.h rubberband_new
+enabled libshine          && require_pkg_config libshine shine shine/layer3.h shine_encode_buffer
+enabled libsmbclient      && { use_pkg_config libsmbclient smbclient libsmbclient.h smbc_init ||
                                require smbclient libsmbclient.h smbc_init -lsmbclient; }
-enabled libsnappy         && require snappy snappy-c.h snappy_compress -lsnappy
+enabled libsnappy         && require libsnappy snappy-c.h snappy_compress -lsnappy
 enabled libsoxr           && require libsoxr soxr.h soxr_create -lsoxr && LIBSOXR="-lsoxr"
-enabled libssh            && require_pkg_config libssh libssh/sftp.h sftp_init
-enabled libspeex          && require_pkg_config speex speex/speex.h speex_decoder_init -lspeex
-enabled libtesseract      && require_pkg_config tesseract tesseract/capi.h TessBaseAPICreate
+enabled libssh            && require_pkg_config libssh libssh libssh/sftp.h sftp_init
+enabled libspeex          && require_pkg_config libspeex speex speex/speex.h speex_decoder_init -lspeex
+enabled libtesseract      && require_pkg_config libtesseract tesseract tesseract/capi.h TessBaseAPICreate
 enabled libtheora         && require libtheora theora/theoraenc.h th_info_init -ltheoraenc -ltheoradec -logg
 enabled libtwolame        && require libtwolame twolame.h twolame_init -ltwolame &&
-                             { check_lib twolame.h twolame_encode_buffer_float32_interleaved -ltwolame ||
+                             { check_lib libtwolame twolame.h twolame_encode_buffer_float32_interleaved -ltwolame ||
                                die "ERROR: libtwolame must be installed and version must be >= 0.3.10"; }
-enabled libv4l2           && require_pkg_config libv4l2 libv4l2.h v4l2_ioctl
-enabled libvidstab        && require_pkg_config "vidstab >= 0.98" vid.stab/libvidstab.h vsMotionDetectInit
+enabled libv4l2           && require_pkg_config libv4l2 libv4l2 libv4l2.h v4l2_ioctl
+enabled libvidstab        && require_pkg_config libvidstab "vidstab >= 0.98" vid.stab/libvidstab.h vsMotionDetectInit
+enabled libvmaf           && require_pkg_config libvmaf libvmaf libvmaf.h compute_vmaf
 enabled libvo_amrwbenc    && require libvo_amrwbenc vo-amrwbenc/enc_if.h E_IF_init -lvo-amrwbenc
-enabled libvorbis         && require libvorbis vorbis/vorbisenc.h vorbis_info_init -lvorbisenc -lvorbis -logg
+enabled libvorbis         && require_pkg_config libvorbis vorbis vorbis/codec.h vorbis_info_init &&
+                             require_pkg_config libvorbisenc vorbisenc vorbis/vorbisenc.h vorbis_encode_init
 
 enabled libvpx            && {
     enabled libvpx_vp8_decoder && {
-        use_pkg_config "vpx >= 0.9.1" "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_vp8_dx ||
-            check_lib2 "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_dec_init_ver -lvpx ||
+        use_pkg_config libvpx_vp8_decoder "vpx >= 0.9.1" "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_vp8_dx ||
+            check_lib libvpx_vp8_decoder "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_dec_init_ver -lvpx ||
                 die "ERROR: libvpx decoder version must be >=0.9.1";
     }
     enabled libvpx_vp8_encoder && {
-        use_pkg_config "vpx >= 0.9.7" "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_vp8_cx ||
-            check_lib2 "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_enc_init_ver VP8E_SET_MAX_INTRA_BITRATE_PCT" -lvpx ||
+        use_pkg_config libvpx_vp8_encoder "vpx >= 0.9.7" "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_vp8_cx ||
+            check_lib libvpx_vp8_encoder "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_enc_init_ver VP8E_SET_MAX_INTRA_BITRATE_PCT" -lvpx ||
                 die "ERROR: libvpx encoder version must be >=0.9.7";
     }
     enabled libvpx_vp9_decoder && {
-        use_pkg_config "vpx >= 1.3.0" "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_vp9_dx ||
-            check_lib2 "vpx/vpx_decoder.h vpx/vp8dx.h" "vpx_codec_vp9_dx" -lvpx ||
-                disable libvpx_vp9_decoder;
+        use_pkg_config libvpx_vp9_decoder "vpx >= 1.3.0" "vpx/vpx_decoder.h vpx/vp8dx.h" vpx_codec_vp9_dx ||
+            check_lib libvpx_vp9_decoder "vpx/vpx_decoder.h vpx/vp8dx.h" "vpx_codec_vp9_dx" -lvpx
     }
     enabled libvpx_vp9_encoder && {
-        use_pkg_config "vpx >= 1.3.0" "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_vp9_cx ||
-            check_lib2 "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_vp9_cx VP9E_SET_AQ_MODE" -lvpx ||
-                disable libvpx_vp9_encoder;
+        use_pkg_config libvpx_vp9_encoder "vpx >= 1.3.0" "vpx/vpx_encoder.h vpx/vp8cx.h" vpx_codec_vp9_cx ||
+            check_lib libvpx_vp9_encoder "vpx/vpx_encoder.h vpx/vp8cx.h" "vpx_codec_vp9_cx VP9E_SET_AQ_MODE" -lvpx
     }
     if disabled_all libvpx_vp8_decoder libvpx_vp9_decoder libvpx_vp8_encoder libvpx_vp9_encoder; then
         die "libvpx enabled but no supported decoders found"
@@ -5775,118 +6024,118 @@ enabled libvpx            && {
 
 enabled libwavpack        && require libwavpack wavpack/wavpack.h WavpackOpenFileOutput  -lwavpack
 enabled libwebp           && {
-    enabled libwebp_encoder      && require_pkg_config "libwebp >= 0.2.0" webp/encode.h WebPGetEncoderVersion
-    enabled libwebp_anim_encoder && { use_pkg_config "libwebpmux >= 0.4.0" webp/mux.h WebPAnimEncoderOptionsInit || disable libwebp_anim_encoder; } }
-enabled libx264           && { use_pkg_config x264 "stdint.h x264.h" x264_encoder_encode ||
-                               { require libx264 x264.h x264_encoder_encode -lx264 &&
+    enabled libwebp_encoder      && require_pkg_config libwebp "libwebp >= 0.2.0" webp/encode.h WebPGetEncoderVersion
+    enabled libwebp_anim_encoder && use_pkg_config libwebp_anim_encoder "libwebpmux >= 0.4.0" webp/mux.h WebPAnimEncoderOptionsInit; }
+enabled libx264           && { use_pkg_config libx264 x264 "stdint.h x264.h" x264_encoder_encode ||
+                               { require libx264 "stdint.h x264.h" x264_encoder_encode -lx264 &&
                                  warn "using libx264 without pkg-config"; } } &&
-                             { check_cpp_condition x264.h "X264_BUILD >= 118" ||
-                               die "ERROR: libx264 must be installed and version must be >= 0.118."; } &&
+                             require_cpp_condition x264.h "X264_BUILD >= 118" &&
                              { check_cpp_condition x264.h "X264_MPEG2" &&
                                enable libx262; }
-enabled libx265           && require_pkg_config x265 x265.h x265_api_get &&
-                             { check_cpp_condition x265.h "X265_BUILD >= 68" ||
-                               die "ERROR: libx265 version must be >= 68."; }
-enabled libxavs           && require libxavs xavs.h xavs_encoder_encode -lxavs
+enabled libx265           && require_pkg_config libx265 x265 x265.h x265_api_get &&
+                             require_cpp_condition x265.h "X265_BUILD >= 68"
+enabled libxavs           && require libxavs "stdint.h xavs.h" xavs_encoder_encode -lxavs
 enabled libxvid           && require libxvid xvid.h xvid_global -lxvidcore
-enabled libzimg           && require_pkg_config zimg zimg.h zimg_get_api_version
-enabled libzmq            && require_pkg_config libzmq zmq.h zmq_ctx_new
+enabled libzimg           && require_pkg_config libzimg "zimg >= 2.3.0" zimg.h zimg_get_api_version
+enabled libzmq            && require_pkg_config libzmq libzmq zmq.h zmq_ctx_new
 enabled libzvbi           && require libzvbi libzvbi.h vbi_decoder_new -lzvbi &&
                              { check_cpp_condition libzvbi.h "VBI_VERSION_MAJOR > 0 || VBI_VERSION_MINOR > 2 || VBI_VERSION_MINOR == 2 && VBI_VERSION_MICRO >= 28" ||
                                enabled gpl || die "ERROR: libzvbi requires version 0.2.28 or --enable-gpl."; }
+enabled libxml2           && require_pkg_config libxml2 libxml-2.0 libxml2/libxml/xmlversion.h xmlCheckVersion
 enabled mediacodec        && { enabled jni || die "ERROR: mediacodec requires --enable-jni"; }
-enabled mmal              && { check_lib interface/mmal/mmal.h mmal_port_connect -lmmal_core -lmmal_util -lmmal_vc_client -lbcm_host ||
-                                { ! enabled cross_compile && {
-                                    add_cflags -isystem/opt/vc/include/ -isystem/opt/vc/include/interface/vmcs_host/linux -isystem/opt/vc/include/interface/vcos/pthreads -fgnu89-inline ;
-                                    add_extralibs -L/opt/vc/lib/ -lmmal_core -lmmal_util -lmmal_vc_client -lbcm_host ;
-                                    check_lib interface/mmal/mmal.h mmal_port_connect ; }
-                                check_lib interface/mmal/mmal.h mmal_port_connect ; } ||
-                               die "ERROR: mmal not found"; }
-enabled mmal && check_func_headers interface/mmal/mmal.h "MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS"
-
-enabled netcdf            && require_pkg_config netcdf netcdf.h nc_inq_libvers
-enabled openal            && { { for al_libs in "${OPENAL_LIBS}" "-lopenal" "-lOpenAL32"; do
-                               check_lib 'AL/al.h' alGetError "${al_libs}" && break; done } ||
+enabled mmal              && { check_lib mmal interface/mmal/mmal.h mmal_port_connect -lmmal_core -lmmal_util -lmmal_vc_client -lbcm_host ||
+                               { ! enabled cross_compile &&
+                                 add_cflags -isystem/opt/vc/include/ -isystem/opt/vc/include/interface/vmcs_host/linux -isystem/opt/vc/include/interface/vcos/pthreads -fgnu89-inline &&
+                                 add_ldflags -L/opt/vc/lib/ &&
+                                 check_lib mmal interface/mmal/mmal.h mmal_port_connect -lmmal_core -lmmal_util -lmmal_vc_client -lbcm_host; } ||
+                               die "ERROR: mmal not found" &&
+                               check_func_headers interface/mmal/mmal.h "MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS"; }
+enabled openal            && { { for al_extralibs in "${OPENAL_LIBS}" "-lopenal" "-lOpenAL32"; do
+                               check_lib openal 'AL/al.h' alGetError "${al_extralibs}" && break; done } ||
                                die "ERROR: openal not found"; } &&
                              { check_cpp_condition "AL/al.h" "defined(AL_VERSION_1_1)" ||
                                die "ERROR: openal must be installed and version must be 1.1 or compatible"; }
-enabled opencl            && { check_lib2 OpenCL/cl.h clEnqueueNDRangeKernel -Wl,-framework,OpenCL ||
-                               check_lib2 CL/cl.h clEnqueueNDRangeKernel -lOpenCL ||
+enabled opencl            && { check_lib opencl OpenCL/cl.h clEnqueueNDRangeKernel -Wl,-framework,OpenCL ||
+                               check_lib opencl CL/cl.h clEnqueueNDRangeKernel -lOpenCL ||
                                die "ERROR: opencl not found"; } &&
                              { check_cpp_condition "OpenCL/cl.h" "defined(CL_VERSION_1_2)" ||
                                check_cpp_condition "CL/cl.h" "defined(CL_VERSION_1_2)" ||
                                die "ERROR: opencl must be installed and version must be 1.2 or compatible"; }
-enabled opengl            && { check_lib GL/glx.h glXGetProcAddress "-lGL" ||
-                               check_lib2 windows.h wglGetProcAddress "-lopengl32 -lgdi32" ||
-                               check_lib2 OpenGL/gl3.h glGetError "-Wl,-framework,OpenGL" ||
-                               check_lib2 ES2/gl.h glGetError "-isysroot=${sysroot} -Wl,-framework,OpenGLES" ||
-                               check_lib2 GLES2/gl2.h glGetError "-lGLESv2" ||
+enabled opengl            && { check_lib opengl GL/glx.h glXGetProcAddress "-lGL" ||
+                               check_lib opengl windows.h wglGetProcAddress "-lopengl32 -lgdi32" ||
+                               check_lib opengl OpenGL/gl3.h glGetError "-Wl,-framework,OpenGL" ||
+                               check_lib opengl ES2/gl.h glGetError "-isysroot=${sysroot} -Wl,-framework,OpenGLES" ||
                                die "ERROR: opengl not found."
                              }
-enabled omx_rpi && enable omx
-enabled omx               && { check_header OMX_Core.h ||
-                                { ! enabled cross_compile && enabled omx_rpi && {
-                                    add_cflags -isystem/opt/vc/include/IL ; }
-                                check_header OMX_Core.h ; } ||
+enabled omx_rpi           && { check_header OMX_Core.h ||
+                               { ! enabled cross_compile && add_cflags -isystem/opt/vc/include/IL && check_header OMX_Core.h ; } ||
                                die "ERROR: OpenMAX IL headers not found"; }
-enabled openssl           && { use_pkg_config openssl openssl/ssl.h OPENSSL_init_ssl ||
-                               use_pkg_config openssl openssl/ssl.h SSL_library_init ||
-                               check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto ||
-                               check_lib openssl/ssl.h SSL_library_init -lssl32 -leay32 ||
-                               check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto -lws2_32 -lgdi32 ||
+enabled omx               && require_header OMX_Core.h
+enabled openssl           && { use_pkg_config openssl openssl openssl/ssl.h OPENSSL_init_ssl ||
+                               use_pkg_config openssl openssl openssl/ssl.h SSL_library_init ||
+                               check_lib openssl openssl/ssl.h SSL_library_init -lssl -lcrypto ||
+                               check_lib openssl openssl/ssl.h SSL_library_init -lssl32 -leay32 ||
+                               check_lib openssl openssl/ssl.h SSL_library_init -lssl -lcrypto -lws2_32 -lgdi32 ||
                                die "ERROR: openssl not found"; }
-enabled qtkit_indev      && { check_header_objcc QTKit/QTKit.h || disable qtkit_indev; }
-
-# libdc1394 check
-if enabled libdc1394; then
-    { require_pkg_config libdc1394-2 dc1394/dc1394.h dc1394_new &&
-        enable libdc1394_2; } ||
-    { check_lib libdc1394/dc1394_control.h dc1394_create_handle -ldc1394_control -lraw1394 &&
-        enable libdc1394_1; } ||
-    die "ERROR: No version of libdc1394 found "
-fi
+enabled rkmpp             && { { require_pkg_config rockchip_mpp rockchip_mpp rockchip/rk_mpi.h mpp_create ||
+                                 die "ERROR : Rockchip MPP was not found."; } &&
+                               { check_func_headers rockchip/rk_mpi_cmd.h "MPP_DEC_GET_FREE_PACKET_SLOT_COUNT" ||
+                                 die "ERROR: Rockchip MPP is outdated, please get a more recent one."; } &&
+                               { enabled libdrm ||
+                                 die "ERROR: rkmpp requires --enable-libdrm"; }
+                             }
 
 if enabled gcrypt; then
     GCRYPT_CONFIG="${cross_prefix}libgcrypt-config"
     if "${GCRYPT_CONFIG}" --version > /dev/null 2>&1; then
         gcrypt_cflags=$("${GCRYPT_CONFIG}" --cflags)
-        gcrypt_libs=$("${GCRYPT_CONFIG}" --libs)
-        check_func_headers gcrypt.h gcry_mpi_new $gcrypt_cflags $gcrypt_libs ||
+        gcrypt_extralibs=$("${GCRYPT_CONFIG}" --libs)
+        check_func_headers gcrypt.h gcry_mpi_new $gcrypt_cflags $gcrypt_extralibs ||
             die "ERROR: gcrypt not found"
-        add_cflags $gcrypt_cflags && add_extralibs $gcrypt_libs
+        add_cflags $gcrypt_cflags && add_extralibs $gcrypt_extralibs
     else
-        require2 gcrypt gcrypt.h gcry_mpi_new -lgcrypt
+        require gcrypt gcrypt.h gcry_mpi_new -lgcrypt
     fi
 fi
 
-disabled sdl && disable sdl2
-if ! disabled sdl2; then
+if enabled sdl2; then
     SDL2_CONFIG="${cross_prefix}sdl2-config"
-    if check_pkg_config sdl2 SDL_events.h SDL_PollEvent; then
-        check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) >= 0x020001" $sdl2_cflags &&
-        check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) < 0x020100" $sdl2_cflags &&
-        check_func SDL_Init $sdl2_libs $sdl2_cflags && enable sdl2
-    else
-      if "${SDL2_CONFIG}" --version > /dev/null 2>&1; then
+    if check_pkg_config sdl2 "sdl2 >= 2.0.1 sdl2 < 2.1.0" SDL_events.h SDL_PollEvent; then
+        check_func SDL_Init $sdl2_extralibs $sdl2_cflags ||
+            disable sdl2
+    elif "${SDL2_CONFIG}" --version > /dev/null 2>&1; then
         sdl2_cflags=$("${SDL2_CONFIG}" --cflags)
-        sdl2_libs=$("${SDL2_CONFIG}" --libs)
+        sdl2_extralibs=$("${SDL2_CONFIG}" --libs)
         check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) >= 0x020001" $sdl2_cflags &&
         check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) < 0x020100" $sdl2_cflags &&
-        check_func SDL_Init $sdl2_libs $sdl2_cflags && enable sdl2
-      fi
+        check_func SDL_Init $sdl2_extralibs $sdl2_cflags &&
+            enable sdl2
     fi
     if test $target_os = "mingw32"; then
-        sdl2_libs="$sdl2_libs -mconsole"
+        sdl2_extralibs=$(filter_out '-mwindows' $sdl2_extralibs)
     fi
 fi
-enabled sdl2 && add_cflags $sdl2_cflags && add_extralibs $sdl2_libs
+enabled sdl2 && add_cflags $(filter_out '-Dmain=SDL_main' $sdl2_cflags) && add_extralibs $sdl2_extralibs
 
-disabled securetransport || { check_func SecIdentityCreate "-Wl,-framework,CoreFoundation -Wl,-framework,Security" &&
-    check_lib2 "Security/SecureTransport.h Security/Security.h" "SSLCreateContext SecItemImport" "-Wl,-framework,CoreFoundation -Wl,-framework,Security" &&
-    enable securetransport; }
+if enabled decklink; then
+    case $target_os in
+        mingw32*|mingw64*|win32|win64)
+            decklink_outdev_extralibs="$decklink_outdev_extralibs -lole32 -loleaut32"
+            decklink_indev_extralibs="$decklink_indev_extralibs -lole32 -loleaut32"
+            ;;
+    esac
+fi
 
-disabled schannel || { check_func_headers "windows.h security.h" InitializeSecurityContext -DSECURITY_WIN32 -lsecur32 &&
-                       check_cpp_condition winerror.h "defined(SEC_I_CONTEXT_EXPIRED)" && enable schannel && add_extralibs -lsecur32; }
+enabled securetransport &&
+    check_func SecIdentityCreate "-Wl,-framework,CoreFoundation -Wl,-framework,Security" &&
+    check_lib securetransport "Security/SecureTransport.h Security/Security.h" "SSLCreateContext SecItemImport" "-Wl,-framework,CoreFoundation -Wl,-framework,Security" ||
+        disable securetransport
+
+enabled schannel &&
+    check_func_headers "windows.h security.h" InitializeSecurityContext -DSECURITY_WIN32 -lsecur32 &&
+    check_cpp_condition winerror.h "defined(SEC_I_CONTEXT_EXPIRED)" &&
+    add_extralibs -lsecur32 ||
+        disable schannel
 
 makeinfo --version > /dev/null 2>&1 && enable makeinfo  || disable makeinfo
 enabled makeinfo \
@@ -5897,15 +6146,26 @@ perl -v            > /dev/null 2>&1 && enable perl      || disable perl
 pod2man --help     > /dev/null 2>&1 && enable pod2man   || disable pod2man
 rsync --help 2> /dev/null | grep -q 'contimeout' && enable rsync_contimeout || disable rsync_contimeout
 
+# check V4L2 codecs available in the API
 check_header linux/fb.h
-check_header linux/videodev.h
 check_header linux/videodev2.h
 check_code cc linux/videodev2.h "struct v4l2_frmsizeenum vfse; vfse.discrete.width = 0;" && enable_safe struct_v4l2_frmivalenum_discrete
+check_code cc linux/videodev2.h "int i = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_VIDEO_M2M | V4L2_BUF_FLAG_LAST;" || disable v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_VC1_ANNEX_G;" && enable vc1_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_MPEG1;" && enable mpeg1_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_MPEG2;" && enable mpeg2_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_MPEG4;" && enable mpeg4_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_HEVC;" && enable hevc_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_H263;" && enable h263_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_H264;" && enable h264_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_VP8;" && enable vp8_v4l2_m2m
+check_code cc linux/videodev2.h "int i = V4L2_PIX_FMT_VP9;" && enable vp9_v4l2_m2m
 
 check_header sys/videoio.h
 check_code cc sys/videoio.h "struct v4l2_frmsizeenum vfse; vfse.discrete.width = 0;" && enable_safe struct_v4l2_frmivalenum_discrete
 
-check_func_headers "windows.h vfw.h" capCreateCaptureWindow "$vfwcap_indev_extralibs"
+check_lib user32 "windows.h winuser.h" GetShellWindow -luser32
+check_lib vfw32 "windows.h vfw.h" capCreateCaptureWindow -lvfw32
 # check that WM_CAP_DRIVER_CONNECT is defined to the proper value
 # w32api 3.12 had it defined wrong
 check_cpp_condition vfw.h "WM_CAP_DRIVER_CONNECT > WM_USER" && enable vfwcap_defines
@@ -5921,7 +6181,6 @@ check_type "dshow.h" IBaseFilter
   check_header dev/video/bktr/ioctl_bt848.h; } ||
 check_header dev/ic/bt8xx.h
 
-check_header sndio.h
 if check_struct sys/soundcard.h audio_buf_info bytes; then
     enable_safe sys/soundcard.h
 else
@@ -5932,102 +6191,84 @@ EOF
 fi
 check_header soundcard.h
 
-enabled_any alsa_indev alsa_outdev &&
-    check_lib2 alsa/asoundlib.h snd_pcm_htimestamp -lasound
+enabled alsa && check_lib alsa alsa/asoundlib.h snd_pcm_htimestamp -lasound
 
-enabled jack_indev && check_lib2 jack/jack.h jack_client_open -ljack &&
+enabled jack && check_lib jack jack/jack.h jack_client_open -ljack &&
     check_func jack_port_get_latency_range -ljack
 
-enabled_any sndio_indev sndio_outdev && check_lib2 sndio.h sio_open -lsndio
+enabled sndio && check_lib sndio sndio.h sio_open -lsndio
 
 if enabled libcdio; then
-    check_lib2 "cdio/cdda.h cdio/paranoia.h" cdio_cddap_open -lcdio_paranoia -lcdio_cdda -lcdio ||
-    check_lib2 "cdio/paranoia/cdda.h cdio/paranoia/paranoia.h" cdio_cddap_open -lcdio_paranoia -lcdio_cdda -lcdio ||
+    check_lib libcdio "cdio/cdda.h cdio/paranoia.h" cdio_cddap_open -lcdio_paranoia -lcdio_cdda -lcdio ||
+    check_lib libcdio "cdio/paranoia/cdda.h cdio/paranoia/paranoia.h" cdio_cddap_open -lcdio_paranoia -lcdio_cdda -lcdio ||
     die "ERROR: No usable libcdio/cdparanoia found"
 fi
 
-enabled xlib &&
-    check_lib X11/Xlib.h XOpenDisplay -lX11 || disable xlib
-
-if ! disabled libxcb; then
-    check_pkg_config "xcb >= 1.4" xcb/xcb.h xcb_connect || {
-        enabled libxcb && die "ERROR: libxcb >= 1.4 not found";
-    } && disable x11grab && enable libxcb
+enabled libxcb && check_pkg_config libxcb "xcb >= 1.4" xcb/xcb.h xcb_connect ||
+    disable libxcb_shm libxcb_shape libxcb_xfixes
 
 if enabled libxcb; then
-    disabled libxcb_shm || {
-        check_pkg_config xcb-shm xcb/shm.h xcb_shm_attach || {
-            enabled libxcb_shm && die "ERROR: libxcb_shm not found";
-        } && check_header sys/shm.h && enable libxcb_shm; }
-
-    disabled libxcb_xfixes || {
-        check_pkg_config xcb-xfixes xcb/xfixes.h xcb_xfixes_get_cursor_image || {
-            enabled libxcb_xfixes && die "ERROR: libxcb_xfixes not found";
-        } && enable libxcb_xfixes; }
-
-    disabled libxcb_shape || {
-        check_pkg_config xcb-shape xcb/shape.h xcb_shape_get_rectangles || {
-            enabled libxcb_shape && die "ERROR: libxcb_shape not found";
-        } && enable libxcb_shape; }
+    enabled libxcb_shm    && check_pkg_config libxcb_shm    xcb-shm    xcb/shm.h    xcb_shm_attach
+    enabled libxcb_shape  && check_pkg_config libxcb_shape  xcb-shape  xcb/shape.h  xcb_shape_get_rectangles
+    enabled libxcb_xfixes && check_pkg_config libxcb_xfixes xcb-xfixes xcb/xfixes.h xcb_xfixes_get_cursor_image
 
     add_cflags $xcb_cflags $xcb_shm_cflags $xcb_xfixes_cflags $xcb_shape_cflags
-    add_extralibs $xcb_libs $xcb_shm_libs $xcb_xfixes_libs $xcb_shape_libs
-fi
-fi
-
-if enabled x11grab; then
-    enabled xlib || die "ERROR: Xlib not found"
-    require Xext X11/extensions/XShm.h XShmCreateImage -lXext
-    require Xfixes X11/extensions/Xfixes.h XFixesGetCursorImage -lXfixes
+    add_extralibs $xcb_extralibs $xcb_shm_extralibs $xcb_xfixes_extralibs $xcb_shape_extralibs
 fi
 
 check_func_headers "windows.h" CreateDIBSection "$gdigrab_indev_extralibs"
 
-enabled dxva2api_h &&
-    check_cc <<EOF && enable dxva2api_cobj
-#define _WIN32_WINNT 0x0600
-#define COBJMACROS
-#include <windows.h>
-#include <d3d9.h>
-#include <dxva2api.h>
-int main(void) { IDirectXVideoDecoder *o = NULL; IDirectXVideoDecoder_Release(o); return 0; }
+# d3d11va requires linking directly to dxgi and d3d11 if not building for
+# the desktop api partition
+check_cpp <<EOF && enable uwp && d3d11va_extralibs="-ldxgi -ld3d11"
+#ifdef WINAPI_FAMILY
+#include <winapifamily.h>
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#error desktop, not uwp
+#else
+// WINAPI_FAMILY_APP, WINAPI_FAMILY_PHONE_APP => UWP
+#endif
+#else
+#error no family set
+#endif
 EOF
 
 enabled vaapi &&
-    check_lib va/va.h vaInitialize -lva ||
-    disable vaapi
+    check_lib vaapi va/va.h vaInitialize -lva
 
 enabled vaapi &&
     check_code cc "va/va.h" "vaCreateSurfaces(0, 0, 0, 0, 0, 0, 0, 0)" ||
     disable vaapi
 
-if enabled vaapi ; then
-    enabled xlib &&
-    check_lib2 "va/va.h va/va_x11.h" vaGetDisplay -lva -lva-x11 &&
-    enable vaapi_x11
+enabled vaapi &&
+    check_lib vaapi_drm "va/va.h va/va_drm.h" vaGetDisplayDRM -lva -lva-drm
 
-    check_lib2 "va/va.h va/va_drm.h" vaGetDisplayDRM -lva -lva-drm &&
-    enable vaapi_drm
-fi
+enabled vaapi &&
+    check_lib vaapi_x11 "va/va.h va/va_x11.h" vaGetDisplay -lva -lva-x11 -lX11
+
+enabled vaapi &&
+    check_cpp_condition "va/va.h" "VA_CHECK_VERSION(1, 0, 0)" &&
+    enable vaapi_1
 
 enabled vdpau &&
     check_cpp_condition vdpau/vdpau.h "defined VDP_DECODER_PROFILE_MPEG4_PART2_ASP" ||
     disable vdpau
 
-enabled vdpau && enabled xlib &&
-    check_lib2 "vdpau/vdpau.h vdpau/vdpau_x11.h" vdp_device_create_x11 -lvdpau &&
-    enable vdpau_x11
+enabled vdpau &&
+    check_lib vdpau_x11 "vdpau/vdpau.h vdpau/vdpau_x11.h" vdp_device_create_x11 -lvdpau -lX11
+
+enabled crystalhd && check_lib crystalhd "stdint.h libcrystalhd/libcrystalhd_if.h" DtsCrystalHDVersion -lcrystalhd
 
 if enabled x86; then
     case $target_os in
         mingw32*|mingw64*|win32|win64|linux|cygwin*)
             ;;
         *)
-            disable nvenc
+            disable cuda cuvid nvenc
             ;;
     esac
 else
-    disable nvenc
+    disable cuda cuvid nvenc
 fi
 
 enabled nvenc &&
@@ -6039,7 +6280,11 @@ int main(void) { return 0; }
 EOF
 
 # Funny iconv installations are not unusual, so check it after all flags have been set
-disabled iconv || check_func_headers iconv.h iconv || check_lib2 iconv.h iconv -liconv || disable iconv
+if enabled libc_iconv; then
+    check_func_headers iconv.h iconv
+elif enabled iconv; then
+    check_func_headers iconv.h iconv || check_lib iconv iconv.h iconv -liconv
+fi
 
 enabled debug && add_cflags -g"$debuglevel" && add_asflags -g"$debuglevel"
 
@@ -6056,19 +6301,41 @@ check_cflags -Wmissing-prototypes
 check_cflags -Wno-pointer-to-int-cast
 check_cflags -Wstrict-prototypes
 check_cflags -Wempty-body
-enabled extra_warnings && check_cflags -Winline
-enabled extra_warnings && check_cflags -Wcast-qual
+
+if enabled extra_warnings; then
+    check_cflags -Wcast-qual
+    check_cflags -Wextra
+    check_cflags -Wpedantic
+fi
 
 check_disable_warning(){
     warning_flag=-W${1#-Wno-}
-    test_cflags $warning_flag && add_cflags $1
+    test_cflags $unknown_warning_flags $warning_flag && add_cflags $1
 }
 
+test_cflags -Werror=unused-command-line-argument &&
+    append unknown_warning_flags "-Werror=unused-command-line-argument"
+test_cflags -Werror=unknown-warning-option &&
+    append unknown_warning_flags "-Werror=unknown-warning-option"
+
 check_disable_warning -Wno-parentheses
 check_disable_warning -Wno-switch
 check_disable_warning -Wno-format-zero-length
 check_disable_warning -Wno-pointer-sign
 check_disable_warning -Wno-unused-const-variable
+check_disable_warning -Wno-bool-operation
+
+check_disable_warning_headers(){
+    warning_flag=-W${1#-Wno-}
+    test_cflags $warning_flag && add_cflags_headers $1
+}
+
+check_disable_warning_headers -Wno-deprecated-declarations
+check_disable_warning_headers -Wno-unused-variable
+
+check_cc <<EOF && enable blocks_extension
+void (^block)(void);
+EOF
 
 # add some linker flags
 check_ldflags -Wl,--warn-common
@@ -6078,8 +6345,7 @@ enabled rpath && add_ldlibflags -Wl,-rpath,$libdir
 test_ldflags -Wl,-Bsymbolic && append SHFLAGS -Wl,-Bsymbolic
 
 # add some strip flags
-# -wN '..@*' is more selective than -x, but not available everywhere.
-check_stripflags -wN \'..@*\' || check_stripflags -x
+check_stripflags -x
 
 enabled neon_clobber_test &&
     check_ldflags -Wl,--wrap,avcodec_open2              \
@@ -6088,11 +6354,11 @@ enabled neon_clobber_test &&
                   -Wl,--wrap,avcodec_decode_subtitle2   \
                   -Wl,--wrap,avcodec_encode_audio2      \
                   -Wl,--wrap,avcodec_encode_video2      \
+                  -Wl,--wrap,avcodec_encode_subtitle    \
                   -Wl,--wrap,avcodec_send_packet        \
-                  -Wl,--wrap,avcodec_receive_frame      \
-                  -Wl,--wrap,avcodec_send_frame         \
                   -Wl,--wrap,avcodec_receive_packet     \
-                  -Wl,--wrap,avcodec_encode_subtitle    \
+                  -Wl,--wrap,avcodec_send_frame         \
+                  -Wl,--wrap,avcodec_receive_frame      \
                   -Wl,--wrap,swr_convert                \
                   -Wl,--wrap,avresample_convert ||
     disable neon_clobber_test
@@ -6106,9 +6372,9 @@ enabled xmm_clobber_test &&
                   -Wl,--wrap,avcodec_encode_video2      \
                   -Wl,--wrap,avcodec_encode_subtitle    \
                   -Wl,--wrap,avcodec_send_packet        \
-                  -Wl,--wrap,avcodec_receive_frame      \
-                  -Wl,--wrap,avcodec_send_frame         \
                   -Wl,--wrap,avcodec_receive_packet     \
+                  -Wl,--wrap,avcodec_send_frame         \
+                  -Wl,--wrap,avcodec_receive_frame      \
                   -Wl,--wrap,swr_convert                \
                   -Wl,--wrap,avresample_convert         \
                   -Wl,--wrap,sws_scale ||
@@ -6145,11 +6411,24 @@ if [ -z "$optflags" ]; then
     fi
 fi
 
+if [ -z "$nvccflags" ]; then
+    nvccflags=$nvccflags_default
+fi
+
+if enabled x86_64 || enabled ppc64 || enabled aarch64; then
+    nvccflags="$nvccflags -m64"
+else
+    nvccflags="$nvccflags -m32"
+fi
+
 check_optflags(){
     check_cflags "$@"
     enabled lto && check_ldflags "$@"
 }
 
+check_optflags $optflags
+check_optflags -fno-math-errno
+check_optflags -fno-signed-zeros
 
 if enabled lto; then
     test "$cc_type" != "$ld_type" && die "LTO requires same compiler and linker"
@@ -6158,10 +6437,6 @@ if enabled lto; then
     disable inline_asm_direct_symbol_refs
 fi
 
-check_optflags $optflags
-check_optflags -fno-math-errno
-check_optflags -fno-signed-zeros
-
 enabled ftrapv && check_cflags -ftrapv
 
 check_cc -mno-red-zone <<EOF && noredzone_flags="-mno-red-zone"
@@ -6268,17 +6543,19 @@ elif enabled_any msvc icl; then
 __declspec($_restrict) void* foo(int);
 EOF
     fi
-    check_func strtoll || add_cflags -Dstrtoll=_strtoi64
     # the new SSA optimzer in VS2015 U3 is mis-optimizing some parts of the code
-    # this flag should be re-checked on newer compiler releases and put under a
-    # version check once its fixed
-    check_cflags -d2SSAOptimizer-
+    # Issue has been fixed in MSVC v19.00.24218.
+    check_cpp_condition windows.h "_MSC_FULL_VER >= 190024218" ||
+        check_cflags -d2SSAOptimizer-
+    # enable utf-8 source processing on VS2015 U2 and newer
+    check_cpp_condition windows.h "_MSC_FULL_VER >= 190023918" &&
+        add_cflags -utf-8
 fi
 
 for pfx in "" host_; do
     varname=${pfx%_}cc_type
     eval "type=\$$varname"
-    if [ $type = "msvc" ]; then
+    if [ "$type" = "msvc" ]; then
         check_${pfx}cc <<EOF || add_${pfx}cflags -Dinline=__inline
 static inline int foo(int a) { return a; }
 EOF
@@ -6301,9 +6578,6 @@ case $target_os in
     osf1)
         enabled ccc && add_ldflags '-Wl,-expect_unresolved,*'
     ;;
-    plan9)
-        add_cppflags -Dmain=plan9_main
-    ;;
 esac
 
 enable frame_thread_encoder
@@ -6323,13 +6597,6 @@ if test $target_os = "haiku"; then
     disable posix_memalign
 fi
 
-enabled_all dxva2 dxva2api_cobj CoTaskMemFree &&
-    prepend ffmpeg_libs $($ldflags_filter "-lole32" "-luser32") &&
-    enable dxva2_lib
-
-! enabled_any memalign posix_memalign aligned_malloc &&
-    enabled simd_align_16 && enable memalign_hack
-
 # add_dep lib dep
 # -> enable ${lib}_deps_${dep}
 # -> add $dep to ${lib}_deps only once
@@ -6367,19 +6634,41 @@ for thread in $THREADS_LIST; do
     fi
 done
 
+if disabled stdatomic_h; then
+    if enabled atomics_gcc; then
+        add_cppflags '-I\$(SRC_PATH)/compat/atomics/gcc'
+    elif enabled atomics_win32; then
+        add_cppflags '-I\$(SRC_PATH)/compat/atomics/win32'
+    elif enabled atomics_suncc; then
+        add_cppflags '-I\$(SRC_PATH)/compat/atomics/suncc'
+    elif enabled pthreads; then
+        add_compat atomics/pthread/stdatomic.o
+        add_cppflags '-I\$(SRC_PATH)/compat/atomics/pthread'
+    else
+        enabled threads && die "Threading is enabled, but no atomics are available"
+        add_cppflags '-I\$(SRC_PATH)/compat/atomics/dummy'
+    fi
+fi
+
+# Check if requested libraries were found.
+for lib in $AUTODETECT_LIBS; do
+    requested $lib && ! enabled $lib && die "ERROR: $lib requested but not found";
+done
+
 enabled zlib && add_cppflags -DZLIB_CONST
 
 # conditional library dependencies, in linking order
 enabled afftfilt_filter     && prepend avfilter_deps "avcodec"
+enabled afir_filter         && prepend avfilter_deps "avcodec"
 enabled amovie_filter       && prepend avfilter_deps "avformat avcodec"
 enabled aresample_filter    && prepend avfilter_deps "swresample"
-enabled asyncts_filter      && prepend avfilter_deps "avresample"
 enabled atempo_filter       && prepend avfilter_deps "avcodec"
 enabled cover_rect_filter   && prepend avfilter_deps "avformat avcodec"
 enabled ebur128_filter && enabled swresample && prepend avfilter_deps "swresample"
 enabled elbg_filter         && prepend avfilter_deps "avcodec"
 enabled fftfilt_filter      && prepend avfilter_deps "avcodec"
 enabled find_rect_filter    && prepend avfilter_deps "avformat avcodec"
+enabled firequalizer_filter && prepend avfilter_deps "avcodec"
 enabled mcdeint_filter      && prepend avfilter_deps "avcodec"
 enabled movie_filter    && prepend avfilter_deps "avformat avcodec"
 enabled pan_filter          && prepend avfilter_deps "swresample"
@@ -6393,10 +6682,13 @@ enabled sofalizer_filter    && prepend avfilter_deps "avcodec"
 enabled showcqt_filter      && prepend avfilter_deps "avformat avcodec swscale"
 enabled showfreqs_filter    && prepend avfilter_deps "avcodec"
 enabled showspectrum_filter && prepend avfilter_deps "avcodec"
+enabled signature_filter    && prepend avfilter_deps "avcodec avformat"
 enabled smartblur_filter    && prepend avfilter_deps "swscale"
 enabled spectrumsynth_filter && prepend avfilter_deps "avcodec"
+enabled spp_filter          && prepend avfilter_deps "avcodec"
 enabled subtitles_filter    && prepend avfilter_deps "avformat avcodec"
 enabled uspp_filter         && prepend avfilter_deps "avcodec"
+enabled zoompan_filter      && prepend avfilter_deps "swscale"
 
 enabled lavfi_indev         && prepend avdevice_deps "avfilter"
 
@@ -6414,6 +6706,19 @@ postproc_deps="$(filter_out 'gpl' $postproc_deps)"
 
 map 'expand_deps $v' $LIBRARY_LIST
 
+license="LGPL version 2.1 or later"
+if enabled nonfree; then
+    license="nonfree and unredistributable"
+elif enabled gplv3; then
+    license="GPL version 3 or later"
+elif enabled lgplv3; then
+    license="LGPL version 3 or later"
+elif enabled gpl; then
+    license="GPL version 2 or later"
+fi
+
+if test "$quiet" != "yes"; then
+
 echo "install prefix            $prefix"
 echo "source path               $source_path"
 echo "C compiler                $cc"
@@ -6435,7 +6740,8 @@ fi
 echo "big-endian                ${bigendian-no}"
 echo "runtime cpu detection     ${runtime_cpudetect-no}"
 if enabled x86; then
-    echo "${yasmexe}                      ${yasm-no}"
+    echo "standalone assembly       ${x86asm-no}"
+    echo "x86 assembler             ${x86asmexe}"
     echo "MMX enabled               ${mmx-no}"
     echo "MMXEXT enabled            ${mmxext-no}"
     echo "3DNow! enabled            ${amd3dnow-no}"
@@ -6444,6 +6750,7 @@ if enabled x86; then
     echo "SSSE3 enabled             ${ssse3-no}"
     echo "AESNI enabled             ${aesni-no}"
     echo "AVX enabled               ${avx-no}"
+    echo "AVX2 enabled              ${avx2-no}"
     echo "XOP enabled               ${xop-no}"
     echo "FMA3 enabled              ${fma3-no}"
     echo "FMA4 enabled              ${fma4-no}"
@@ -6485,13 +6792,9 @@ echo "optimizations             ${optimizations-no}"
 echo "static                    ${static-no}"
 echo "shared                    ${shared-no}"
 echo "postprocessing support    ${postproc-no}"
-echo "new filter support        ${avfilter-no}"
 echo "network support           ${network-no}"
 echo "threading support         ${thread_type-no}"
 echo "safe bitstream reader     ${safe_bitstream_reader-no}"
-echo "SDL2 support              ${sdl2-no}"
-echo "opencl enabled            ${opencl-no}"
-echo "JNI support               ${jni-no}"
 echo "texi2html enabled         ${texi2html-no}"
 echo "perl enabled              ${perl-no}"
 echo "pod2man enabled           ${pod2man-no}"
@@ -6501,10 +6804,6 @@ test -n "$random_seed" &&
     echo "random seed               ${random_seed}"
 echo
 
-echo "Enabled programs:"
-print_enabled '' $PROGRAM_LIST | print_in_columns
-echo
-
 echo "External libraries:"
 print_enabled '' $EXTERNAL_LIBRARY_LIST | print_in_columns
 echo
@@ -6517,6 +6816,10 @@ echo "Libraries:"
 print_enabled '' $LIBRARY_LIST | print_in_columns
 echo
 
+echo "Programs:"
+print_enabled '' $PROGRAM_LIST | print_in_columns
+echo
+
 for type in decoder encoder hwaccel parser demuxer muxer protocol filter bsf indev outdev; do
     echo "Enabled ${type}s:"
     eval list=\$$(toupper $type)_LIST
@@ -6524,28 +6827,27 @@ for type in decoder encoder hwaccel parser demuxer muxer protocol filter bsf ind
     echo
 done
 
-license="LGPL version 2.1 or later"
-if enabled nonfree; then
-    license="nonfree and unredistributable"
-elif enabled gplv3; then
-    license="GPL version 3 or later"
-elif enabled lgplv3; then
-    license="LGPL version 3 or later"
-elif enabled gpl; then
-    license="GPL version 2 or later"
+if test -n "$ignore_tests"; then
+    ignore_tests=$(echo $ignore_tests | tr ',' ' ')
+    echo "Ignored FATE tests:"
+    echo $ignore_tests | print_in_columns
+    echo
 fi
 
 echo "License: $license"
 
-echo "Creating config.mak, config.h, and doc/config.texi..."
+echo "Creating configuration files ..."
+
+fi # test "$quiet" != "yes"
 
 test -e Makefile || echo "include $source_path/Makefile" > Makefile
 
 enabled stripping || strip="echo skipping strip"
+enabled stripping || striptype=""
 
-config_files="$TMPH config.mak doc/config.texi"
+config_files="$TMPH ffbuild/config.mak doc/config.texi"
 
-cat > config.mak <<EOF
+cat > ffbuild/config.mak <<EOF
 # Automatically generated by configure - do not modify!
 ifndef FFMPEG_CONFIG_MAK
 FFMPEG_CONFIG_MAK=1
@@ -6577,13 +6879,16 @@ DEPCC=$dep_cc
 DEPCCFLAGS=$DEPCCFLAGS \$(CPPFLAGS)
 DEPAS=$as
 DEPASFLAGS=$DEPASFLAGS \$(CPPFLAGS)
-YASM=$yasmexe
-DEPYASM=$yasmexe
+X86ASM=$x86asmexe
+DEPX86ASM=$x86asmexe
+DEPX86ASMFLAGS=\$(X86ASMFLAGS)
 AR=$ar
 ARFLAGS=$arflags
 AR_O=$ar_o
 RANLIB=$ranlib
 STRIP=$strip
+STRIPTYPE=$striptype
+NVCC=$nvcc
 CP=cp -p
 LN_S=$ln_s
 CPPFLAGS=$CPPFLAGS
@@ -6591,6 +6896,7 @@ CFLAGS=$CFLAGS
 CXXFLAGS=$CXXFLAGS
 OBJCFLAGS=$OBJCFLAGS
 ASFLAGS=$ASFLAGS
+NVCCFLAGS=$nvccflags
 AS_C=$AS_C
 AS_O=$AS_O
 OBJCC_C=$OBJCC_C
@@ -6601,9 +6907,11 @@ CC_E=$CC_E
 CC_O=$CC_O
 CXX_C=$CXX_C
 CXX_O=$CXX_O
+NVCC_C=$NVCC_C
+NVCC_O=$NVCC_O
 LD_O=$LD_O
+X86ASM_O=$X86ASM_O
 LD_LIB=$LD_LIB
-LD_MYTH_LIB=$LD_MYTH_LIB
 LD_PATH=$LD_PATH
 DLLTOOL=$dlltool
 WINDRES=$windres
@@ -6614,7 +6922,7 @@ LDEXEFLAGS=$LDEXEFLAGS
 LDLIBFLAGS=$LDLIBFLAGS
 SHFLAGS=$(echo $($ldflags_filter $SHFLAGS))
 ASMSTRIPFLAGS=$ASMSTRIPFLAGS
-YASMFLAGS=$YASMFLAGS
+X86ASMFLAGS=$X86ASMFLAGS
 BUILDSUF=$build_suffix
 PROGSSUF=$progs_suffix
 FULLNAME=$FULLNAME
@@ -6630,15 +6938,18 @@ CXXDEP=$CXXDEP
 CCDEP_FLAGS=$CCDEP_FLAGS
 ASDEP=$ASDEP
 ASDEP_FLAGS=$ASDEP_FLAGS
+X86ASMDEP=$X86ASMDEP
+X86ASMDEP_FLAGS=$X86ASMDEP_FLAGS
 CC_DEPFLAGS=$CC_DEPFLAGS
 AS_DEPFLAGS=$AS_DEPFLAGS
+X86ASM_DEPFLAGS=$X86ASM_DEPFLAGS
 HOSTCC=$host_cc
 HOSTLD=$host_ld
 HOSTCFLAGS=$host_cflags
 HOSTCPPFLAGS=$host_cppflags
 HOSTEXESUF=$HOSTEXESUF
 HOSTLDFLAGS=$host_ldflags
-HOSTLIBS=$host_libs
+HOSTEXTRALIBS=$host_extralibs
 DEPHOSTCC=$host_cc
 DEPHOSTCCFLAGS=$DEPHOSTCCFLAGS \$(HOSTCCFLAGS)
 HOSTCCDEP=$HOSTCCDEP
@@ -6651,11 +6962,11 @@ TARGET_EXEC=$target_exec $target_exec_args
 TARGET_PATH=$target_path
 TARGET_SAMPLES=${target_samples:-\$(SAMPLES)}
 CFLAGS-ffplay=${sdl2_cflags}
+CFLAGS_HEADERS=$CFLAGS_HEADERS
 ZLIB=$($ldflags_filter -lz)
 LIB_INSTALL_EXTRA_CMD=$LIB_INSTALL_EXTRA_CMD
 EXTRALIBS=$extralibs
 COMPAT_OBJS=$compat_objs
-EXEOBJS=$exeobjs
 INSTALL=$install
 LIBTARGET=${LIBTARGET}
 SLIBNAME=${SLIBNAME}
@@ -6670,30 +6981,18 @@ SLIB_INSTALL_EXTRA_SHLIB=${SLIB_INSTALL_EXTRA_SHLIB}
 VERSION_SCRIPT_POSTPROCESS_CMD=${VERSION_SCRIPT_POSTPROCESS_CMD}
 SAMPLES:=${samples:-\$(FATE_SAMPLES)}
 NOREDZONE_FLAGS=$noredzone_flags
+LIBFUZZER_PATH=$libfuzzer_path
+IGNORE_TESTS=$ignore_tests
 EOF
 
-get_version(){
-    lcname=lib${1}
-    name=$(toupper $lcname)
-    file=$source_path/$lcname/version.h
-    eval $(awk "/#define ${name}_VERSION_M/ { print \$2 \"=\" \$3 }" "$file")
-    enabled raise_major && eval ${name}_VERSION_MAJOR=$((${name}_VERSION_MAJOR+100))
-    eval ${name}_VERSION=\$${name}_VERSION_MAJOR.\$${name}_VERSION_MINOR.\$${name}_VERSION_MICRO
-    eval echo "${lcname}_VERSION=\$${name}_VERSION" >> config.mak
-    eval echo "${lcname}_VERSION_MAJOR=\$${name}_VERSION_MAJOR" >> config.mak
-    eval echo "${lcname}_VERSION_MINOR=\$${name}_VERSION_MINOR" >> config.mak
-}
-
-map 'get_version $v' $LIBRARY_LIST
-
-map 'eval echo "${v}_FFLIBS=\$${v}_deps" >> config.mak' $LIBRARY_LIST
+map 'eval echo "${v}_FFLIBS=\$${v}_deps" >> ffbuild/config.mak' $LIBRARY_LIST
 
-print_program_libs(){
-    eval "program_libs=\$${1}_libs"
-    eval echo "LIBS-${1}=${program_libs}" >> config.mak
+print_program_extralibs(){
+    eval "program_extralibs=\$${1}_extralibs"
+    eval echo "EXTRALIBS-${1}=${program_extralibs}" >> ffbuild/config.mak
 }
 
-map 'print_program_libs $v' $PROGRAM_LIST
+map 'print_program_extralibs $v' $PROGRAM_LIST
 
 cat > $TMPH <<EOF
 /* Automatically generated by configure - do not modify! */
@@ -6701,7 +7000,7 @@ cat > $TMPH <<EOF
 #define FFMPEG_CONFIG_H
 #define FFMPEG_CONFIGURATION "$(c_escape $FFMPEG_CONFIGURATION)"
 #define FFMPEG_LICENSE "$(c_escape $license)"
-#define CONFIG_THIS_YEAR 2016
+#define CONFIG_THIS_YEAR 2017
 #define FFMPEG_DATADIR "$(eval c_escape $datadir)"
 #define AVCONV_DATADIR "$(eval c_escape $datadir)"
 #define CC_IDENT "$(c_escape ${cc_ident:-Unknown compiler})"
@@ -6720,7 +7019,7 @@ test -n "$assert_level" &&
 test -n "$malloc_prefix" &&
     echo "#define MALLOC_PREFIX $malloc_prefix" >>$TMPH
 
-if enabled yasm; then
+if enabled x86asm; then
     append config_files $TMPASM
     printf '' >$TMPASM
 fi
@@ -6740,13 +7039,13 @@ print_config CONFIG_ "$config_files" $CONFIG_LIST       \
                                      $ALL_COMPONENTS    \
 
 echo "#endif /* FFMPEG_CONFIG_H */" >> $TMPH
-echo "endif # FFMPEG_CONFIG_MAK" >> config.mak
+echo "endif # FFMPEG_CONFIG_MAK" >> ffbuild/config.mak
 
 # Do not overwrite an unchanged config.h to avoid superfluous rebuilds.
 cp_if_changed $TMPH config.h
-touch .config
+touch ffbuild/.config
 
-enabled yasm && cp_if_changed $TMPASM config.asm
+enabled x86asm && cp_if_changed $TMPASM config.asm
 
 cat > $TMPH <<EOF
 /* Generated by ffconf */
@@ -6760,18 +7059,13 @@ echo "#endif /* AVUTIL_AVCONFIG_H */" >> $TMPH
 
 cp_if_changed $TMPH libavutil/avconfig.h
 
-if test -n "$WARNINGS"; then
-    printf "\n%s%s$WARNINGS%s" "$warn_color" "$bold_color" "$reset_color"
-    enabled fatal_warnings && exit 1
-fi
-
 # generate the lists of enabled components
 print_enabled_components(){
     file=$1
     struct_name=$2
     name=$3
     shift 3
-    echo "static const $struct_name *$name[] = {" > $TMPH
+    echo "static const $struct_name * const $name[] = {" > $TMPH
     for c in $*; do
         enabled $c && printf "    &ff_%s,\n" $c >> $TMPH
     done
@@ -6782,64 +7076,37 @@ print_enabled_components(){
 print_enabled_components libavcodec/bsf_list.c AVBitStreamFilter bitstream_filters $BSF_LIST
 print_enabled_components libavformat/protocol_list.c URLProtocol url_protocols $PROTOCOL_LIST
 
-# build pkg-config files
+if test -n "$WARNINGS"; then
+    printf "\n%s%s$WARNINGS%s" "$warn_color" "$bold_color" "$reset_color"
+    enabled fatal_warnings && exit 1
+fi
 
-lib_version(){
-    eval printf "\"lib${1}${build_suffix} >= \$LIB$(toupper ${1})_VERSION, \""
-}
+# Settings for pkg-config files
 
-pkgconfig_generate(){
-    name=$1
-    shortname=${name#lib}${build_suffix}
-    comment=$2
-    version=$3
-    libs=$4
-    requires=$(map 'lib_version $v' $(eval echo \$${name#lib}_deps))
-    requires=${requires%, }
-    enabled ${name#lib} || return 0
-    mkdir -p $name
-    cat <<EOF > $name/$name${build_suffix}.pc
+cat > ffbuild/config.sh <<EOF
+# Automatically generated by configure - do not modify!
+shared=$shared
+build_suffix=$build_suffix
 prefix=$prefix
-exec_prefix=\${prefix}
 libdir=$libdir
-includedir=$incdir
-
-Name: $name
-Description: $comment
-Version: $version
-Requires: $(enabled shared || echo $requires)
-Requires.private: $(enabled shared && echo $requires)
-Conflicts:
-Libs: -L\${libdir} $(enabled rpath && echo "-Wl,-rpath,\${libdir}") -l${shortname} $(enabled shared || echo $libs)
-Libs.private: $(enabled shared && echo $libs)
-Cflags: -I\${includedir}
-EOF
-
-mkdir -p doc/examples/pc-uninstalled
-includedir=${source_path}
-[ "$includedir" = . ] && includedir="\${pcfiledir}/../../.."
-    cat <<EOF > doc/examples/pc-uninstalled/$name.pc
-prefix=
-exec_prefix=
-libdir=\${pcfiledir}/../../../$name
-includedir=${includedir}
-
-Name: $name
-Description: $comment
-Version: $version
-Requires: $requires
-Conflicts:
-Libs: -L\${libdir} -Wl,-rpath,\${libdir} -l${shortname} $(enabled shared || echo $libs)
-Cflags: -I\${includedir}
+incdir=$incdir
+rpath=$(enabled rpath && echo "-Wl,-rpath,\${libdir}")
+source_path=${source_path}
+LIBPREF=${LIBPREF}
+LIBSUF=${LIBSUF}
+
+extralibs_avutil="$LIBRT $LIBM"
+extralibs_avcodec="$extralibs"
+extralibs_avformat="$extralibs"
+extralibs_avdevice="$extralibs"
+extralibs_avfilter="$extralibs"
+extralibs_avresample="$LIBM"
+extralibs_postproc=""
+extralibs_swscale="$LIBM"
+extralibs_swresample="$LIBM $LIBSOXR"
 EOF
-}
 
-pkgconfig_generate libavutil     "FFmpeg utility library"               "$LIBAVUTIL_VERSION"     "$LIBRT $LIBM"
-pkgconfig_generate libavcodec    "FFmpeg codec library"                 "$LIBAVCODEC_VERSION"    "$extralibs"
-pkgconfig_generate libavformat   "FFmpeg container format library"      "$LIBAVFORMAT_VERSION"   "$extralibs"
-pkgconfig_generate libavdevice   "FFmpeg device handling library"       "$LIBAVDEVICE_VERSION"   "$extralibs"
-pkgconfig_generate libavfilter   "FFmpeg audio/video filtering library" "$LIBAVFILTER_VERSION"   "$extralibs"
-pkgconfig_generate libpostproc   "FFmpeg postprocessing library"        "$LIBPOSTPROC_VERSION"   ""
-pkgconfig_generate libavresample "Libav audio resampling library"       "$LIBAVRESAMPLE_VERSION" "$LIBM"
-pkgconfig_generate libswscale    "FFmpeg image rescaling library"       "$LIBSWSCALE_VERSION"    "$LIBM"
-pkgconfig_generate libswresample "FFmpeg audio resampling library"      "$LIBSWRESAMPLE_VERSION" "$LIBM $LIBSOXR"
+for lib in $LIBRARY_LIST; do
+    lib_deps="$(eval echo \$${lib}_deps)"
+    echo ${lib}_deps=\"$lib_deps\" >> ffbuild/config.sh
+done
diff --git a/mythtv/external/FFmpeg/doc/APIchanges b/mythtv/external/FFmpeg/doc/APIchanges
index 33c549ab679..6803eaaea2d 100644
--- a/mythtv/external/FFmpeg/doc/APIchanges
+++ b/mythtv/external/FFmpeg/doc/APIchanges
@@ -15,6 +15,233 @@ libavutil:     2015-08-28
 
 API changes, most recent first:
 
+-------- 8< --------- FFmpeg 3.4 was cut here -------- 8< ---------
+
+2017-09-28 - b6cf66ae1c - lavc 57.106.104 - avcodec.h
+  Add AV_PKT_DATA_A53_CC packet side data, to export closed captions
+
+2017-09-27 - 7aa6b8a68f - lavu 55.77.101 / lavu 55.31.1 - frame.h
+  Allow passing the value of 0 (meaning "automatic") as the required alignment
+  to av_frame_get_buffer().
+
+2017-09-27 - 522f877086 - lavu 55.77.100 / lavu 55.31.0 - cpu.h
+  Add av_cpu_max_align() for querying maximum required data alignment.
+
+2017-09-26 - b1cf151c4d - lavc 57.106.102 - avcodec.h
+  Deprecate AVCodecContext.refcounted_frames. This was useful for deprecated
+  API only (avcodec_decode_video2/avcodec_decode_audio4). The new decode APIs
+  (avcodec_send_packet/avcodec_receive_frame) always work with reference
+  counted frames.
+
+2017-09-21 - 6f15f1cdc8 - lavu 55.76.100 / 56.6.0 - pixdesc.h
+  Add av_color_range_from_name(), av_color_primaries_from_name(),
+  av_color_transfer_from_name(), av_color_space_from_name(), and
+  av_chroma_location_from_name().
+
+2017-09-13 - 82342cead1 - lavc 57.106.100 - avcodec.h
+  Add AV_PKT_FLAG_TRUSTED.
+
+2017-09-13 - 9cb23cd9fe - lavu 55.75.100 - hwcontext.h hwcontext_drm.h
+  Add AV_HWDEVICE_TYPE_DRM and implementation.
+
+2017-09-08 - 5ba2aef6ec - lavfi 6.103.100 - buffersrc.h
+  Add av_buffersrc_close().
+
+2017-09-04 - 6cadbb16e9 - lavc 57.105.100 - avcodec.h
+  Add AV_HWACCEL_CODEC_CAP_EXPERIMENTAL, replacing the deprecated
+  HWACCEL_CODEC_CAP_EXPERIMENTAL flag.
+
+2017-09-01 - 5d76674756 - lavf 57.81.100 - avio.h
+  Add avio_read_partial().
+
+2017-09-01 - xxxxxxx - lavf 57.80.100 / 57.11.0 - avio.h
+  Add avio_context_free(). From now on it must be used for freeing AVIOContext.
+
+2017-08-08 - 1460408703 - lavu 55.74.100 - pixdesc.h
+  Add AV_PIX_FMT_FLAG_FLOAT pixel format flag.
+
+2017-08-08 - 463b81de2b - lavu 55.72.100 - imgutils.h
+  Add av_image_fill_black().
+
+2017-08-08 - caa12027ba - lavu 55.71.100 - frame.h
+  Add av_frame_apply_cropping().
+
+2017-07-25 - 24de4fddca - lavu 55.69.100 - frame.h
+  Add AV_FRAME_DATA_ICC_PROFILE side data type.
+
+2017-06-27 - 70143a3954 - lavc 57.100.100 - avcodec.h
+  DXVA2 and D3D11 hardware accelerated decoding now supports the new hwaccel API,
+  which can create the decoder context and allocate hardware frame automatically.
+  See AVCodecContext.hw_device_ctx and AVCodecContext.hw_frames_ctx. For D3D11,
+  the new AV_PIX_FMT_D3D11 pixfmt must be used with the new API.
+
+2017-06-27 - 3303511f33 - lavu 56.67.100 - hwcontext.h
+  Add AV_HWDEVICE_TYPE_D3D11VA and AV_PIX_FMT_D3D11.
+
+2017-06-24 - 09891c5391 - lavf 57.75.100 - avio.h
+  Add AVIO_DATA_MARKER_FLUSH_POINT to signal preferred flush points to aviobuf.
+
+2017-06-14 - d59c6a3aeb - lavu 55.66.100 - hwcontext.h
+  av_hwframe_ctx_create_derived() now takes some AV_HWFRAME_MAP_* combination
+  as its flags argument (which was previously unused).
+
+2017-06-14 - 49ae8a5e87 - lavc 57.99.100 - avcodec.h
+  Add AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH.
+
+2017-06-14 - 0b1794a43e - lavu 55.65.100 - hwcontext.h
+  Add AV_HWDEVICE_TYPE_NONE, av_hwdevice_find_type_by_name(),
+  av_hwdevice_get_type_name() and av_hwdevice_iterate_types().
+
+2017-06-14 - b22172f6f3 - lavu 55.64.100 - hwcontext.h
+  Add av_hwdevice_ctx_create_derived().
+
+2017-05-15 - 532b23f079 - lavc 57.96.100 - avcodec.h
+  VideoToolbox hardware-accelerated decoding now supports the new hwaccel API,
+  which can create the decoder context and allocate hardware frames automatically.
+  See AVCodecContext.hw_device_ctx and AVCodecContext.hw_frames_ctx.
+
+2017-05-15 - 532b23f079 - lavu 57.63.100 - hwcontext.h
+  Add AV_HWDEVICE_TYPE_VIDEOTOOLBOX and implementation.
+
+2017-05-08 - f089e02fa2 - lavc 57.95.100 / 57.31.0 - avcodec.h
+  Add AVCodecContext.apply_cropping to control whether cropping
+  is handled by libavcodec or the caller.
+
+2017-05-08 - a47bd5d77e - lavu 55.62.100 / 55.30.0 - frame.h
+  Add AVFrame.crop_left/right/top/bottom fields for attaching cropping
+  information to video frames.
+
+2017-xx-xx - xxxxxxxxxx
+  Change av_sha_update(), av_sha512_update() and av_md5_sum()/av_md5_update() length
+  parameter type to size_t at next major bump.
+
+2017-05-05 - c0f17a905f - lavc 57.94.100 - avcodec.h
+  The cuvid decoders now support AVCodecContext.hw_device_ctx, which removes
+  the requirement to set an incomplete AVCodecContext.hw_frames_ctx only to
+  set the Cuda device handle.
+
+2017-04-11 - 8378466507 - lavu 55.61.100 - avstring.h
+  Add av_strireplace().
+
+2016-04-06 - 157e57a181 - lavc 57.92.100 - avcodec.h
+  Add AV_PKT_DATA_CONTENT_LIGHT_LEVEL packet side data.
+
+2016-04-06 - b378f5bd64 - lavu 55.60.100 - mastering_display_metadata.h
+  Add AV_FRAME_DATA_CONTENT_LIGHT_LEVEL value, av_content_light_metadata_alloc()
+  and av_content_light_metadata_create_side_data() API, and AVContentLightMetadata
+  type to export content light level video properties.
+
+2017-03-31 - 9033e8723c - lavu 55.57.100 - spherical.h
+  Add av_spherical_projection_name().
+  Add av_spherical_from_name().
+
+2017-03-30 - 4cda23f1f1 - lavu 55.53.100 / 55.27.0 - hwcontext.h
+  Add av_hwframe_map() and associated AV_HWFRAME_MAP_* flags.
+  Add av_hwframe_ctx_create_derived().
+
+2017-03-29 - bfdcdd6d82 - lavu 55.52.100 - avutil.h
+  add av_fourcc_make_string() function and av_fourcc2str() macro to replace
+  av_get_codec_tag_string() from lavc.
+
+2017-03-27 - ddef3d902f - lavf 57.68.100 - avformat.h
+  Deprecate that demuxers export the stream rotation angle in AVStream.metadata
+  (via an entry named "rotate"). Use av_stream_get_side_data() with
+  AV_PKT_DATA_DISPLAYMATRIX instead, and read the rotation angle with
+  av_display_rotation_get(). The same is done for muxing. Instead of adding a
+  "rotate" entry to AVStream.metadata, AV_PKT_DATA_DISPLAYMATRIX side data has
+  to be added to the AVStream.
+
+2017-03-23 - 7e4ba776a2 - lavc 57.85.101 - avcodec.h
+  vdpau hardware accelerated decoding now supports the new hwaccel API, which
+  can create the decoder context and allocate hardware frame automatically.
+  See AVCodecContext.hw_device_ctx and AVCodecContext.hw_frames_ctx.
+
+2017-03-23 - 156bd8278f - lavc 57.85.100 - avcodec.h
+  Add AVCodecContext.hwaccel_flags field. This will control some hwaccels at
+  a later point.
+
+2017-03-21 - fc9f14c7de - lavf 57.67.100 / 57.08.0 - avio.h
+  Add AVIO_SEEKABLE_TIME flag.
+
+2017-03-21 - d682ae70b4 - lavf 57.66.105, lavc 57.83.101 - avformat.h, avcodec.h
+  Deprecate AVFMT_FLAG_KEEP_SIDE_DATA. It will be ignored after the next major
+  bump, and libavformat will behave as if it were always set.
+  Deprecate av_packet_merge_side_data() and av_packet_split_side_data().
+
+2016-03-20 - 8200b16a9c - lavu 55.50.100 / 55.21.0 - imgutils.h
+  Add av_image_copy_uc_from(), a version of av_image_copy() for copying
+  from GPU mapped memory.
+
+2017-03-20 - 9c2436e - lavu 55.49.100 - pixdesc.h
+  Add AV_PIX_FMT_FLAG_BAYER pixel format flag.
+
+2017-03-18 - 3796fb2692 - lavfi 6.77.100 - avfilter.h
+  Deprecate AVFilterGraph.resample_lavr_opts
+  It's never been used by avfilter nor passed to anything.
+
+2017-02-10 - 1b7ffddb3a - lavu 55.48.100 / 55.33.0 - spherical.h
+  Add AV_SPHERICAL_EQUIRECTANGULAR_TILE, av_spherical_tile_bounds(),
+  and projection-specific properties (bound_left, bound_top, bound_right,
+  bound_bottom, padding) to AVSphericalMapping.
+
+2017-03-02 - ade7c1a232 - lavc 57.81.104 - videotoolbox.h
+  AVVideotoolboxContext.cv_pix_fmt_type can now be set to 0 to output the
+  native decoder format. (The default value is not changed.)
+
+2017-03-02 - 554bc4eea8 - lavu 55.47.101, lavc 57.81.102, lavf 57.66.103
+  Remove requirement to use AVOption or accessors to access certain fields
+  in AVFrame, AVCodecContext, and AVFormatContext that were previously
+  documented as "no direct access" allowed.
+
+2017-02-13 - c1a5fca06f - lavc 57.80.100 - avcodec.h
+  Add AVCodecContext.hw_device_ctx.
+
+2017-02-11 - e3af49b14b - lavu 55.47.100 - frame.h
+  Add AVFrame.opaque_ref.
+
+2017-01-31 - 2eab48177d - lavu 55.46.100 / 55.20.0 - cpu.h
+  Add AV_CPU_FLAG_SSSE3SLOW.
+
+2017-01-24 - c4618f842a - lavu 55.45.100 - channel_layout.h
+  Add av_get_extended_channel_layout()
+
+2017-01-22 - 76c5a69e26 - lavu 55.44.100 - lfg.h
+  Add av_lfg_init_from_data().
+
+2017-01-17 - 2a4a8653b6 - lavc 57.74.100 - vaapi.h
+  Deprecate struct vaapi_context and the vaapi.h installed header.
+  Callers should set AVCodecContext.hw_frames_ctx instead.
+
+2017-01-12 - dbe9dbed31 - lavfi 6.69.100 - buffersink.h
+  Add av_buffersink_get_*() functions.
+
+2017-01-06 - 9488032e10 - lavf 57.62.100 - avio.h
+  Add avio_get_dyn_buf()
+
+2016-12-10 - f542b152aa - lavu 55.43.100 - imgutils.h
+  Add av_image_check_size2()
+
+2016-12-07 - e7a6f8c972 - lavc 57.67.100 / 57.29.0 - avcodec.h
+  Add AV_PKT_DATA_SPHERICAL packet side data to export AVSphericalMapping
+  information from containers.
+
+2016-12-07 - 8f58ecc344 - lavu 55.42.100 / 55.30.0 - spherical.h
+  Add AV_FRAME_DATA_SPHERICAL value, av_spherical_alloc() API and
+  AVSphericalMapping type to export and describe spherical video properties.
+
+2016-11-18 - 2ab50647ff - lavf 57.58.100 - avformat.h
+  Add av_stream_add_side_data().
+
+2016-11-13 - 775a8477b7 - lavu 55.39.100 - hwcontext_vaapi.h
+  Add AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE.
+
+2016-11-13 - a8d51bb424 - lavu 55.38.100 - hwcontext_vaapi.h
+  Add driver quirks field to VAAPI-specific hwdevice and enum with
+  members AV_VAAPI_DRIVER_QUIRK_* to represent its values.
+
+2016-11-10 - 638b216d4f - lavu 55.36.100 - pixfmt.h
+  Add AV_PIX_FMT_GRAY12(LE/BE).
+
 -------- 8< --------- FFmpeg 3.2 was cut here -------- 8< ---------
 
 2016-10-24 - 73ead47 - lavf 57.55.100 - avformat.h
diff --git a/mythtv/external/FFmpeg/doc/Doxyfile b/mythtv/external/FFmpeg/doc/Doxyfile
index 8f855f8ff57..ca68f1aad60 100644
--- a/mythtv/external/FFmpeg/doc/Doxyfile
+++ b/mythtv/external/FFmpeg/doc/Doxyfile
@@ -38,7 +38,7 @@ PROJECT_NAME           = FFmpeg
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 3.2
+PROJECT_NUMBER         = 3.4.1
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
diff --git a/mythtv/external/FFmpeg/doc/Makefile b/mythtv/external/FFmpeg/doc/Makefile
index a180fbed216..fa4996b5a30 100644
--- a/mythtv/external/FFmpeg/doc/Makefile
+++ b/mythtv/external/FFmpeg/doc/Makefile
@@ -24,6 +24,7 @@ HTMLPAGES   = $(AVPROGS-yes:%=doc/%.html) $(AVPROGS-yes:%=doc/%-all.html) $(COMP
               doc/fate.html                                             \
               doc/general.html                                          \
               doc/git-howto.html                                        \
+              doc/mailing-list-faq.html                                 \
               doc/nut.html                                              \
               doc/platform.html                                         \
 
@@ -36,30 +37,6 @@ DOCS-$(CONFIG_MANPAGES)  += $(MANPAGES)
 DOCS-$(CONFIG_TXTPAGES)  += $(TXTPAGES)
 DOCS = $(DOCS-yes)
 
-DOC_EXAMPLES-$(CONFIG_AVIO_DIR_CMD_EXAMPLE)      += avio_dir_cmd
-DOC_EXAMPLES-$(CONFIG_AVIO_READING_EXAMPLE)      += avio_reading
-DOC_EXAMPLES-$(CONFIG_DECODING_ENCODING_EXAMPLE) += decoding_encoding
-DOC_EXAMPLES-$(CONFIG_DEMUXING_DECODING_EXAMPLE) += demuxing_decoding
-DOC_EXAMPLES-$(CONFIG_EXTRACT_MVS_EXAMPLE)       += extract_mvs
-DOC_EXAMPLES-$(CONFIG_FILTER_AUDIO_EXAMPLE)      += filter_audio
-DOC_EXAMPLES-$(CONFIG_FILTERING_AUDIO_EXAMPLE)   += filtering_audio
-DOC_EXAMPLES-$(CONFIG_FILTERING_VIDEO_EXAMPLE)   += filtering_video
-DOC_EXAMPLES-$(CONFIG_HTTP_MULTICLIENT_EXAMPLE)  += http_multiclient
-DOC_EXAMPLES-$(CONFIG_METADATA_EXAMPLE)          += metadata
-DOC_EXAMPLES-$(CONFIG_MUXING_EXAMPLE)            += muxing
-DOC_EXAMPLES-$(CONFIG_QSVDEC_EXAMPLE)            += qsvdec
-DOC_EXAMPLES-$(CONFIG_REMUXING_EXAMPLE)          += remuxing
-DOC_EXAMPLES-$(CONFIG_RESAMPLING_AUDIO_EXAMPLE)  += resampling_audio
-DOC_EXAMPLES-$(CONFIG_SCALING_VIDEO_EXAMPLE)     += scaling_video
-DOC_EXAMPLES-$(CONFIG_TRANSCODE_AAC_EXAMPLE)     += transcode_aac
-DOC_EXAMPLES-$(CONFIG_TRANSCODING_EXAMPLE)       += transcoding
-ALL_DOC_EXAMPLES_LIST = $(DOC_EXAMPLES-) $(DOC_EXAMPLES-yes)
-
-DOC_EXAMPLES       := $(DOC_EXAMPLES-yes:%=doc/examples/%$(PROGSSUF)$(EXESUF))
-ALL_DOC_EXAMPLES   := $(ALL_DOC_EXAMPLES_LIST:%=doc/examples/%$(PROGSSUF)$(EXESUF))
-ALL_DOC_EXAMPLES_G := $(ALL_DOC_EXAMPLES_LIST:%=doc/examples/%$(PROGSSUF)_g$(EXESUF))
-PROGS              += $(DOC_EXAMPLES)
-
 all-$(CONFIG_DOC): doc
 
 doc: documentation
@@ -67,8 +44,6 @@ doc: documentation
 apidoc: doc/doxy/html
 documentation: $(DOCS)
 
-examples: $(DOC_EXAMPLES)
-
 TEXIDEP = perl $(SRC_PATH)/doc/texidep.pl $(SRC_PATH) $< $@ >$(@:%=%.d)
 
 doc/%.txt: TAG = TXT
@@ -121,11 +96,9 @@ doc/%.3: doc/%.pod $(GENTEXI)
 	$(M)pod2man --section=3 --center=" " --release=" " --date=" " $< > $@
 
 $(DOCS) doc/doxy/html: | doc/
-$(DOC_EXAMPLES:%$(EXESUF)=%.o): | doc/examples
-OBJDIRS += doc/examples
 
-DOXY_INPUT      = $(INSTHEADERS) $(DOC_EXAMPLES:%$(EXESUF)=%.c) $(LIB_EXAMPLES:%$(EXESUF)=%.c)
-DOXY_INPUT_DEPS = $(addprefix $(SRC_PATH)/, $(DOXY_INPUT)) config.mak
+DOXY_INPUT      = $(INSTHEADERS)
+DOXY_INPUT_DEPS = $(addprefix $(SRC_PATH)/, $(DOXY_INPUT)) ffbuild/config.mak
 
 doc/doxy/html: TAG = DOXY
 doc/doxy/html: $(SRC_PATH)/doc/Doxyfile $(SRC_PATH)/doc/doxy-wrapper.sh $(DOXY_INPUT_DEPS)
@@ -171,11 +144,7 @@ clean:: docclean
 distclean:: docclean
 	$(RM) doc/config.texi
 
-examplesclean:
-	$(RM) $(ALL_DOC_EXAMPLES) $(ALL_DOC_EXAMPLES_G)
-	$(RM) $(CLEANSUFFIXES:%=doc/examples/%)
-
-docclean: examplesclean
+docclean::
 	$(RM) $(CLEANSUFFIXES:%=doc/%)
 	$(RM) $(TXTPAGES) doc/*.html doc/*.pod doc/*.1 doc/*.3 doc/avoptions_*.texi
 	$(RM) -r doc/doxy/html
diff --git a/mythtv/external/FFmpeg/doc/bitstream_filters.texi b/mythtv/external/FFmpeg/doc/bitstream_filters.texi
index a85327ff5c3..2dffe021f92 100644
--- a/mythtv/external/FFmpeg/doc/bitstream_filters.texi
+++ b/mythtv/external/FFmpeg/doc/bitstream_filters.texi
@@ -26,19 +26,26 @@ with their parameters, if any.
 
 @section aac_adtstoasc
 
-Convert MPEG-2/4 AAC ADTS to MPEG-4 Audio Specific Configuration
-bitstream filter.
+Convert MPEG-2/4 AAC ADTS to an MPEG-4 Audio Specific Configuration
+bitstream.
 
 This filter creates an MPEG-4 AudioSpecificConfig from an MPEG-2/4
 ADTS header and removes the ADTS header.
 
-This is required for example when copying an AAC stream from a raw
-ADTS AAC container to a FLV or a MOV/MP4 file.
+This filter is required for example when copying an AAC stream from a
+raw ADTS AAC or an MPEG-TS container to MP4A-LATM, to an FLV file, or
+to MOV/MP4 files and related formats such as 3GP or M4A. Please note
+that it is auto-inserted for MP4A-LATM and MOV/MP4 and related formats.
 
 @section chomp
 
 Remove zero padding at the end of a packet.
 
+@section dca_core
+
+Extract the core from a DCA/DTS stream, dropping extensions such as
+DTS-HD.
+
 @section dump_extra
 
 Add extradata to the beginning of the filtered packets.
@@ -67,9 +74,23 @@ the header stored in extradata to the key packets:
 ffmpeg -i INPUT -map 0 -flags:v +global_header -c:v libx264 -bsf:v dump_extra out.ts
 @end example
 
-@section dca_core
+@section extract_extradata
+
+Extract the in-band extradata.
+
+Certain codecs allow the long-term headers (e.g. MPEG-2 sequence headers,
+or H.264/HEVC (VPS/)SPS/PPS) to be transmitted either "in-band" (i.e. as a part
+of the bitstream containing the coded frames) or "out of band" (e.g. on the
+container level). This latter form is called "extradata" in FFmpeg terminology.
 
-Extract DCA core from DTS-HD streams.
+This bitstream filter detects the in-band headers and makes them available as
+extradata.
+
+@table @option
+@item remove
+When this option is enabled, the long-term headers are removed from the
+bitstream after extraction.
+@end table
 
 @section h264_mp4toannexb
 
@@ -78,7 +99,7 @@ prefixed mode (as defined in the Annex B of the ITU-T H.264
 specification).
 
 This is required by some streaming formats, typically the MPEG-2
-transport stream format ("mpegts").
+transport stream format (muxer @code{mpegts}).
 
 For example to remux an MP4 file containing an H.264 stream to mpegts
 format with @command{ffmpeg}, you can use the command:
@@ -87,6 +108,29 @@ format with @command{ffmpeg}, you can use the command:
 ffmpeg -i INPUT.mp4 -codec copy -bsf:v h264_mp4toannexb OUTPUT.ts
 @end example
 
+Please note that this filter is auto-inserted for MPEG-TS (muxer
+@code{mpegts}) and raw H.264 (muxer @code{h264}) output formats.
+
+@section hevc_mp4toannexb
+
+Convert an HEVC/H.265 bitstream from length prefixed mode to start code
+prefixed mode (as defined in the Annex B of the ITU-T H.265
+specification).
+
+This is required by some streaming formats, typically the MPEG-2
+transport stream format (muxer @code{mpegts}).
+
+For example to remux an MP4 file containing an HEVC stream to mpegts
+format with @command{ffmpeg}, you can use the command:
+
+@example
+ffmpeg -i INPUT.mp4 -codec copy -bsf:v hevc_mp4toannexb OUTPUT.ts
+@end example
+
+Please note that this filter is auto-inserted for MPEG-TS (muxer
+@code{mpegts}) and raw HEVC/H.265 (muxer @code{h265} or
+@code{hevc}) output formats.
+
 @section imxdump
 
 Modifies the bitstream to fit in MOV and to be usable by the Final Cut
@@ -137,11 +181,22 @@ exiftran -i -9 frame*.jpg
 ffmpeg -i frame_%d.jpg -c:v copy rotated.avi
 @end example
 
-@section mjpega_dump_header
+@section mjpegadump
+
+Add an MJPEG A header to the bitstream, to enable decoding by
+Quicktime.
+
+@anchor{mov2textsub}
+@section mov2textsub
+
+Extract a representable text file from MOV subtitles, stripping the
+metadata header from each subtitle packet.
 
-@section movsub
+See also the @ref{text2movsub} filter.
 
-@section mp3_header_decompress
+@section mp3decomp
+
+Decompress non-standard compressed MP3 audio headers.
 
 @section mpeg4_unpack_bframes
 
@@ -165,20 +220,74 @@ ffmpeg -i INPUT.avi -codec copy -bsf:v mpeg4_unpack_bframes OUTPUT.avi
 
 @section noise
 
-Damages the contents of packets without damaging the container. Can be
-used for fuzzing or testing error resilience/concealment.
+Damages the contents of packets or simply drops them without damaging the
+container. Can be used for fuzzing or testing error resilience/concealment.
 
 Parameters:
+@table @option
+@item amount
 A numeral string, whose value is related to how often output bytes will
 be modified. Therefore, values below or equal to 0 are forbidden, and
 the lower the more frequent bytes will be modified, with 1 meaning
 every byte is modified.
+@item dropamount
+A numeral string, whose value is related to how often packets will be dropped.
+Therefore, values below or equal to 0 are forbidden, and the lower the more
+frequent packets will be dropped, with 1 meaning every packet is dropped.
+@end table
 
+The following example applies the modification to every byte but does not drop
+any packets.
 @example
 ffmpeg -i INPUT -c copy -bsf noise[=1] output.mkv
 @end example
-applies the modification to every byte.
+
+@section null
+This bitstream filter passes the packets through unchanged.
 
 @section remove_extra
 
+Remove extradata from packets.
+
+It accepts the following parameter:
+@table @option
+@item freq
+Set which frame types to remove extradata from.
+
+@table @samp
+@item k
+Remove extradata from non-keyframes only.
+
+@item keyframe
+Remove extradata from keyframes only.
+
+@item e, all
+Remove extradata from all frames.
+
+@end table
+@end table
+
+@anchor{text2movsub}
+@section text2movsub
+
+Convert text subtitles to MOV subtitles (as used by the @code{mov_text}
+codec) with metadata headers.
+
+See also the @ref{mov2textsub} filter.
+
+@section vp9_superframe
+
+Merge VP9 invisible (alt-ref) frames back into VP9 superframes. This
+fixes merging of split/segmented VP9 streams where the alt-ref frame
+was split from its visible counterpart.
+
+@section vp9_superframe_split
+
+Split VP9 superframes into single frames.
+
+@section vp9_raw_reorder
+
+Given a VP9 stream with correct timestamps but possibly out of order,
+insert additional show-existing-frame packets to correct the ordering.
+
 @c man end BITSTREAM FILTERS
diff --git a/mythtv/external/FFmpeg/doc/build_system.txt b/mythtv/external/FFmpeg/doc/build_system.txt
index 8c12e0e294d..325a9e83d01 100644
--- a/mythtv/external/FFmpeg/doc/build_system.txt
+++ b/mythtv/external/FFmpeg/doc/build_system.txt
@@ -45,6 +45,9 @@ libswscale/swscale-test
 config
     Reconfigure the project with the current configuration.
 
+tools/target_dec_<decoder>_fuzzer
+    Build fuzzer to fuzz the specified decoder.
+
 
 Useful standard make commands:
 make -t <target>
diff --git a/mythtv/external/FFmpeg/doc/codecs.texi b/mythtv/external/FFmpeg/doc/codecs.texi
index 9d0b980c121..40f64fe4c88 100644
--- a/mythtv/external/FFmpeg/doc/codecs.texi
+++ b/mythtv/external/FFmpeg/doc/codecs.texi
@@ -138,7 +138,8 @@ Set audio sampling rate (in Hz).
 Set number of audio channels.
 
 @item cutoff @var{integer} (@emph{encoding,audio})
-Set cutoff bandwidth.
+Set cutoff bandwidth. (Supported only by selected encoders, see
+their respective documentation sections.)
 
 @item frame_size @var{integer} (@emph{encoding,audio})
 Set audio frame size.
@@ -1067,12 +1068,15 @@ SMPTE 240 M
 Film
 @item bt2020
 BT.2020
+@item smpte428
 @item smpte428_1
 SMPTE ST 428-1
 @item smpte431
 SMPTE 431-2
 @item smpte432
 SMPTE 432-1
+@item jedec-p22
+JEDEC P22
 @end table
 
 @item color_trc @var{integer} (@emph{decoding/encoding,video})
@@ -1091,21 +1095,29 @@ SMPTE 240 M
 @item linear
 Linear
 @item log
+@item log100
 Log
 @item log_sqrt
+@item log316
 Log square root
 @item iec61966_2_4
+@item iec61966-2-4
 IEC 61966-2-4
 @item bt1361
+@item bt1361e
 BT.1361
 @item iec61966_2_1
+@item iec61966-2-1
 IEC 61966-2-1
+@item bt2020_10
 @item bt2020_10bit
 BT.2020 - 10 bit
+@item bt2020_12
 @item bt2020_12bit
 BT.2020 - 12 bit
 @item smpte2084
 SMPTE ST 2084
+@item smpte428
 @item smpte428_1
 SMPTE ST 428-1
 @item arib-std-b67
@@ -1129,8 +1141,10 @@ SMPTE 170 M
 SMPTE 240 M
 @item ycocg
 YCOCG
+@item bt2020nc
 @item bt2020_ncl
 BT.2020 NCL
+@item bt2020c
 @item bt2020_cl
 BT.2020 CL
 @item smpte2085
@@ -1140,8 +1154,32 @@ SMPTE 2085
 @item color_range @var{integer} (@emph{decoding/encoding,video})
 If used as input parameter, it serves as a hint to the decoder, which
 color_range the input has.
+Possible values:
+@table @samp
+@item tv
+@item mpeg
+MPEG (219*2^(n-8))
+@item pc
+@item jpeg
+JPEG (2^n-1)
+@end table
 
 @item chroma_sample_location @var{integer} (@emph{decoding/encoding,video})
+Possible values:
+@table @samp
+@item left
+
+@item center
+
+@item topleft
+
+@item top
+
+@item bottomleft
+
+@item bottom
+
+@end table
 
 @item log_level_offset @var{integer}
 Set the log level offset.
@@ -1220,7 +1258,7 @@ Interlaced video, top coded first, bottom displayed first
 Interlaced video, bottom coded first, top displayed first
 @end table
 
-@item skip_alpha @var{integer} (@emph{decoding,video})
+@item skip_alpha @var{bool} (@emph{decoding,video})
 Set to 1 to disable processing alpha (transparency). This works like the
 @samp{gray} flag in the @option{flags} option which skips chroma information
 instead of alpha. Default is 0.
@@ -1237,6 +1275,20 @@ ffprobe -dump_separator "
                           "  -i ~/videos/matrixbench_mpeg2.mpg
 @end example
 
+@item max_pixels @var{integer} (@emph{decoding/encoding,video})
+Maximum number of pixels per image. This value can be used to avoid out of
+memory failures due to large images.
+
+@item apply_cropping @var{bool} (@emph{decoding,video})
+Enable cropping if cropping parameters are multiples of the required
+alignment for the left and top parameters. If the alignment is not met the
+cropping will be partially applied to maintain alignment.
+Default is 1 (enabled).
+Note: The required alignment depends on if @code{AV_CODEC_FLAG_UNALIGNED} is set and the
+CPU. @code{AV_CODEC_FLAG_UNALIGNED} cannot be changed from the command line. Also hardware
+decoders will not apply left/top Cropping.
+
+
 @end table
 
 @c man end CODEC OPTIONS
diff --git a/mythtv/external/FFmpeg/doc/decoders.texi b/mythtv/external/FFmpeg/doc/decoders.texi
index babe1297672..d149d2bea51 100644
--- a/mythtv/external/FFmpeg/doc/decoders.texi
+++ b/mythtv/external/FFmpeg/doc/decoders.texi
@@ -109,7 +109,7 @@ correctly by using lavc's old buggy lpc logic for decoding.
 
 @section ffwavesynth
 
-Internal wave synthetizer.
+Internal wave synthesizer.
 
 This decoder generates wave patterns according to predefined sequences. Its
 use is purely internal and the format of the data it accepts is not publicly
@@ -275,7 +275,7 @@ Y offset of generated bitmaps, default is 0.
 Chops leading and trailing spaces and removes empty lines from the generated
 text. This option is useful for teletext based subtitles where empty spaces may
 be present at the start or at the end of the lines or empty lines may be
-present between the subtitle lines because of double-sized teletext charactes.
+present between the subtitle lines because of double-sized teletext characters.
 Default value is 1.
 @item txt_duration
 Sets the display duration of the decoded teletext pages or subtitles in
diff --git a/mythtv/external/FFmpeg/doc/demuxers.texi b/mythtv/external/FFmpeg/doc/demuxers.texi
index 2934a1cf7f4..73dc0feec19 100644
--- a/mythtv/external/FFmpeg/doc/demuxers.texi
+++ b/mythtv/external/FFmpeg/doc/demuxers.texi
@@ -13,8 +13,9 @@ You can disable all the demuxers using the configure option
 the option @code{--enable-demuxer=@var{DEMUXER}}, or disable it
 with the option @code{--disable-demuxer=@var{DEMUXER}}.
 
-The option @code{-formats} of the ff* tools will display the list of
-enabled demuxers.
+The option @code{-demuxers} of the ff* tools will display the list of
+enabled demuxers. Use @code{-formats} to view a combined list of
+enabled demuxers and muxers.
 
 The description of some of the currently available demuxers follows.
 
@@ -243,11 +244,17 @@ file subdir/file-2.wav
 @end example
 @end itemize
 
-@section flv
+@section flv, live_flv
 
 Adobe Flash Video Format demuxer.
 
-This demuxer is used to demux FLV files and RTMP network streams.
+This demuxer is used to demux FLV files and RTMP network streams. In case of live network streams, if you force format, you may use live_flv option instead of flv to survive timestamp discontinuities.
+
+@example
+ffmpeg -f flv -i myfile.flv ...
+ffmpeg -f live_flv -i rtmp://<any.server>/anything/key ....
+@end example
+
 
 @table @option
 @item -flv_metadata @var{bool}
@@ -293,6 +300,24 @@ used to end the output video at the length of the shortest input file,
 which in this case is @file{input.mp4} as the GIF in this example loops
 infinitely.
 
+@section hls
+
+HLS demuxer
+
+It accepts the following options:
+
+@table @option
+@item live_start_index
+segment index to start live streams at (negative values are from the end).
+
+@item allowed_extensions
+',' separated list of file extensions that hls is allowed to access.
+
+@item max_reload
+Maximum number of times a insufficient list is attempted to be reloaded.
+Default value is 1000.
+@end table
+
 @section image2
 
 Image file demuxer.
diff --git a/mythtv/external/FFmpeg/doc/developer.texi b/mythtv/external/FFmpeg/doc/developer.texi
index dbe1f5421f5..98540c8f992 100644
--- a/mythtv/external/FFmpeg/doc/developer.texi
+++ b/mythtv/external/FFmpeg/doc/developer.texi
@@ -131,6 +131,11 @@ designated struct initializers (@samp{struct s x = @{ .i = 17 @};});
 
 @item
 compound literals (@samp{x = (struct s) @{ 17, 23 @};}).
+
+@item
+Implementation defined behavior for signed integers is assumed to match the
+expected behavior for two's complement. Non representable values in integer
+casts are binary truncated. Shift right of signed values uses sign extension.
 @end itemize
 
 These features are supported by all compilers we care about, so we will not
diff --git a/mythtv/external/FFmpeg/doc/encoders.texi b/mythtv/external/FFmpeg/doc/encoders.texi
index 5a60e7ee5a5..431777c4578 100644
--- a/mythtv/external/FFmpeg/doc/encoders.texi
+++ b/mythtv/external/FFmpeg/doc/encoders.texi
@@ -92,12 +92,12 @@ using the value "enable", which is mainly useful for debugging or disabled using
 
 @item aac_is
 Sets intensity stereo coding tool usage. By default, it's enabled and will
-automatically toggle IS for similar pairs of stereo bands if it's benefitial.
+automatically toggle IS for similar pairs of stereo bands if it's beneficial.
 Can be disabled for debugging by setting the value to "disable".
 
 @item aac_pns
 Uses perceptual noise substitution to replace low entropy high frequency bands
-with imperceivable white noise during the decoding process. By default, it's
+with imperceptible white noise during the decoding process. By default, it's
 enabled, but can be disabled for debugging purposes by using "disable".
 
 @item aac_tns
@@ -488,6 +488,10 @@ is an optional AC-3 feature that increases quality by selectively encoding
 the left/right channels as mid/side. This option is enabled by default, and it
 is highly recommended that it be left as enabled except for testing purposes.
 
+@item cutoff @var{frequency}
+Set lowpass cutoff frequency. If unspecified, the encoder selects a default
+determined by various other encoding parameters.
+
 @end table
 
 @subsection Floating-Point-Only AC-3 Encoding Options
@@ -545,7 +549,8 @@ The following options are supported by FFmpeg's flac encoder.
 @table @option
 @item compression_level
 Sets the compression level, which chooses defaults for many other options
-if they are not set explicitly.
+if they are not set explicitly. Valid values are from 0 to 12, 5 is the
+default.
 
 @item frame_size
 Sets the size of the frames in samples per channel.
@@ -594,7 +599,7 @@ Channel mode
 @item auto
 The mode is chosen automatically for each frame
 @item indep
-Chanels are independently coded
+Channels are independently coded
 @item left_side
 @item right_side
 @item mid_side
@@ -612,6 +617,27 @@ and slightly improves compression.
 
 @end table
 
+@anchor{opusenc}
+@section opus
+
+Opus encoder.
+
+This is a native FFmpeg encoder for the Opus format. Currently its in development and
+only implements the CELT part of the codec. Its quality is usually worse and at best
+is equal to the libopus encoder.
+
+@subsection Options
+
+@table @option
+@item b
+Set bit rate in bits/s. If unspecified it uses the number of channels and the layout
+to make a good guess.
+
+@item opus_delay
+Sets the maximum delay in milliseconds. Lower delays than 20ms will very quickly
+decrease quality.
+@end table
+
 @anchor{libfdk-aac-enc}
 @section libfdk_aac
 
@@ -817,6 +843,10 @@ Set algorithm quality. Valid arguments are integers in the 0-9 range,
 with 0 meaning highest quality but slowest, and 9 meaning fastest
 while producing the worst quality.
 
+@item cutoff (@emph{--lowpass})
+Set lowpass cutoff frequency. If unspecified, the encoder dynamically
+adjusts the cutoff.
+
 @item reservoir
 Enable use of bit reservoir when set to 1. Default value is 1. LAME
 has this enabled by default, but can be overridden by use
@@ -870,6 +900,90 @@ default value is 0 (disabled).
 
 @end table
 
+@section libopus
+
+libopus Opus Interactive Audio Codec encoder wrapper.
+
+Requires the presence of the libopus headers and library during
+configuration. You need to explicitly configure the build with
+@code{--enable-libopus}.
+
+@subsection Option Mapping
+
+Most libopus options are modelled after the @command{opusenc} utility from
+opus-tools. The following is an option mapping chart describing options
+supported by the libopus wrapper, and their @command{opusenc}-equivalent
+in parentheses.
+
+@table @option
+
+@item b (@emph{bitrate})
+Set the bit rate in bits/s.  FFmpeg's @option{b} option is
+expressed in bits/s, while @command{opusenc}'s @option{bitrate} in
+kilobits/s.
+
+@item vbr (@emph{vbr}, @emph{hard-cbr}, and @emph{cvbr})
+Set VBR mode. The FFmpeg @option{vbr} option has the following
+valid arguments, with the @command{opusenc} equivalent options
+in parentheses:
+
+@table @samp
+@item off (@emph{hard-cbr})
+Use constant bit rate encoding.
+
+@item on (@emph{vbr})
+Use variable bit rate encoding (the default).
+
+@item constrained (@emph{cvbr})
+Use constrained variable bit rate encoding.
+@end table
+
+@item compression_level (@emph{comp})
+Set encoding algorithm complexity. Valid options are integers in
+the 0-10 range. 0 gives the fastest encodes but lower quality, while 10
+gives the highest quality but slowest encoding. The default is 10.
+
+@item frame_duration (@emph{framesize})
+Set maximum frame size, or duration of a frame in milliseconds. The
+argument must be exactly the following: 2.5, 5, 10, 20, 40, 60. Smaller
+frame sizes achieve lower latency but less quality at a given bitrate.
+Sizes greater than 20ms are only interesting at fairly low bitrates.
+The default is 20ms.
+
+@item packet_loss (@emph{expect-loss})
+Set expected packet loss percentage. The default is 0.
+
+@item application (N.A.)
+Set intended application type. Valid options are listed below:
+
+@table @samp
+@item voip
+Favor improved speech intelligibility.
+@item audio
+Favor faithfulness to the input (the default).
+@item lowdelay
+Restrict to only the lowest delay modes.
+@end table
+
+@item cutoff (N.A.)
+Set cutoff bandwidth in Hz. The argument must be exactly one of the
+following: 4000, 6000, 8000, 12000, or 20000, corresponding to
+narrowband, mediumband, wideband, super wideband, and fullband
+respectively. The default is 0 (cutoff disabled).
+
+@item mapping_family (@emph{mapping_family})
+Set channel mapping family to be used by the encoder. The default value of -1
+uses mapping family 0 for mono and stereo inputs, and mapping family 1
+otherwise. The default also disables the surround masking and LFE bandwidth
+optimzations in libopus, and requires that the input contains 8 channels or
+fewer.
+
+Other values include 0 for mono and stereo, 1 for surround sound with masking
+and LFE bandwidth optimizations, and 255 for independent streams with an
+unspecified channel layout.
+
+@end table
+
 @anchor{libshine}
 @section libshine
 
@@ -1009,90 +1123,6 @@ default value is 0 (disabled).
 
 @end table
 
-@section libopus
-
-libopus Opus Interactive Audio Codec encoder wrapper.
-
-Requires the presence of the libopus headers and library during
-configuration. You need to explicitly configure the build with
-@code{--enable-libopus}.
-
-@subsection Option Mapping
-
-Most libopus options are modelled after the @command{opusenc} utility from
-opus-tools. The following is an option mapping chart describing options
-supported by the libopus wrapper, and their @command{opusenc}-equivalent
-in parentheses.
-
-@table @option
-
-@item b (@emph{bitrate})
-Set the bit rate in bits/s.  FFmpeg's @option{b} option is
-expressed in bits/s, while @command{opusenc}'s @option{bitrate} in
-kilobits/s.
-
-@item vbr (@emph{vbr}, @emph{hard-cbr}, and @emph{cvbr})
-Set VBR mode. The FFmpeg @option{vbr} option has the following
-valid arguments, with the @command{opusenc} equivalent options
-in parentheses:
-
-@table @samp
-@item off (@emph{hard-cbr})
-Use constant bit rate encoding.
-
-@item on (@emph{vbr})
-Use variable bit rate encoding (the default).
-
-@item constrained (@emph{cvbr})
-Use constrained variable bit rate encoding.
-@end table
-
-@item compression_level (@emph{comp})
-Set encoding algorithm complexity. Valid options are integers in
-the 0-10 range. 0 gives the fastest encodes but lower quality, while 10
-gives the highest quality but slowest encoding. The default is 10.
-
-@item frame_duration (@emph{framesize})
-Set maximum frame size, or duration of a frame in milliseconds. The
-argument must be exactly the following: 2.5, 5, 10, 20, 40, 60. Smaller
-frame sizes achieve lower latency but less quality at a given bitrate.
-Sizes greater than 20ms are only interesting at fairly low bitrates.
-The default is 20ms.
-
-@item packet_loss (@emph{expect-loss})
-Set expected packet loss percentage. The default is 0.
-
-@item application (N.A.)
-Set intended application type. Valid options are listed below:
-
-@table @samp
-@item voip
-Favor improved speech intelligibility.
-@item audio
-Favor faithfulness to the input (the default).
-@item lowdelay
-Restrict to only the lowest delay modes.
-@end table
-
-@item cutoff (N.A.)
-Set cutoff bandwidth in Hz. The argument must be exactly one of the
-following: 4000, 6000, 8000, 12000, or 20000, corresponding to
-narrowband, mediumband, wideband, super wideband, and fullband
-respectively. The default is 0 (cutoff disabled).
-
-@item mapping_family (@emph{mapping_family})
-Set channel mapping family to be used by the encoder. The default value of -1
-uses mapping family 0 for mono and stereo inputs, and mapping family 1
-otherwise. The default also disables the surround masking and LFE bandwidth
-optimzations in libopus, and requires that the input contains 8 channels or
-fewer.
-
-Other values include 0 for mono and stereo, 1 for surround sound with masking
-and LFE bandwidth optimizations, and 255 for independent streams with an
-unspecified channel layout.
-
-@end table
-
 @section libvorbis
 
 libvorbis encoder wrapper.
@@ -1192,6 +1222,27 @@ Same as @samp{3}, but with extra processing enabled.
 @end table
 @end table
 
+@anchor{mjpegenc}
+@section mjpeg
+
+Motion JPEG encoder.
+
+@subsection Options
+
+@table @option
+@item huffman
+Set the huffman encoding strategy. Possible values:
+
+@table @samp
+@item default
+Use the default huffman tables. This is the default strategy.
+
+@item optimal
+Compute and use optimal huffman tables.
+
+@end table
+@end table
+
 @anchor{wavpackenc}
 @section wavpack
 
@@ -1261,6 +1312,81 @@ disabled
 A description of some of the currently available video encoders
 follows.
 
+@section Hap
+
+Vidvox Hap video encoder.
+
+@subsection Options
+
+@table @option
+@item format @var{integer}
+Specifies the Hap format to encode.
+
+@table @option
+@item hap
+@item hap_alpha
+@item hap_q
+@end table
+
+Default value is @option{hap}.
+
+@item chunks @var{integer}
+Specifies the number of chunks to split frames into, between 1 and 64. This
+permits multithreaded decoding of large frames, potentially at the cost of
+data-rate. The encoder may modify this value to divide frames evenly.
+
+Default value is @var{1}.
+
+@item compressor @var{integer}
+Specifies the second-stage compressor to use. If set to @option{none},
+@option{chunks} will be limited to 1, as chunked uncompressed frames offer no
+benefit.
+
+@table @option
+@item none
+@item snappy
+@end table
+
+Default value is @option{snappy}.
+
+@end table
+
+@section jpeg2000
+
+The native jpeg 2000 encoder is lossy by default, the @code{-q:v}
+option can be used to set the encoding quality. Lossless encoding
+can be selected with @code{-pred 1}.
+
+@subsection Options
+
+@table @option
+@item format
+Can be set to either @code{j2k} or @code{jp2} (the default) that
+makes it possible to store non-rgb pix_fmts.
+
+@end table
+
+@section libkvazaar
+
+Kvazaar H.265/HEVC encoder.
+
+Requires the presence of the libkvazaar headers and library during
+configuration. You need to explicitly configure the build with
+@option{--enable-libkvazaar}.
+
+@subsection Options
+
+@table @option
+
+@item b
+Set target video bitrate in bit/s and enable rate control.
+
+@item kvazaar-params
+Set kvazaar parameters as a list of @var{name}=@var{value} pairs separated
+by commas (,). See kvazaar documentation for a list of options.
+
+@end table
+
 @section libopenh264
 
 Cisco libopenh264 H.264/MPEG-4 AVC encoder wrapper.
@@ -1327,30 +1453,6 @@ Set maximum NAL size in bytes.
 Allow skipping frames to hit the target bitrate if set to 1.
 @end table
 
-@section jpeg2000
-
-The native jpeg 2000 encoder is lossy by default, the @code{-q:v}
-option can be used to set the encoding quality. Lossless encoding
-can be selected with @code{-pred 1}.
-
-@subsection Options
-
-@table @option
-@item format
-Can be set to either @code{j2k} or @code{jp2} (the default) that
-makes it possible to store non-rgb pix_fmts.
-
-@end table
-
-@section snow
-
-@subsection Options
-
-@table @option
-@item iterative_dia_size
-dia size for the iterative motion estimation
-@end table
-
 @section libtheora
 
 libtheora Theora encoder wrapper.
@@ -1564,7 +1666,7 @@ option to 2.
 Enable frame parallel decodability features.
 @item aq-mode
 Set adaptive quantization mode (0: off (default), 1: variance 2: complexity, 3:
-cyclic refresh).
+cyclic refresh, 4: equator360).
 @item colorspace @emph{color-space}
 Set input color space. The VP9 bitstream supports signaling the following
 colorspaces:
@@ -1577,6 +1679,8 @@ colorspaces:
 @item @samp{smpte240m} @emph{smpte240}
 @item @samp{bt2020_ncl} @emph{bt2020}
 @end table
+@item row-mt @var{boolean}
+Enable row based multi-threading.
 @end table
 
 @end table
@@ -1584,7 +1688,6 @@ colorspaces:
 For more information about libvpx see:
 @url{http://www.webmproject.org/}
 
-
 @section libwebp
 
 libwebp WebP Image encoder wrapper
@@ -1690,7 +1793,7 @@ the documentation of the undocumented generic options, see
 @ref{codec-options,,the Codec Options chapter}.
 
 To get a more accurate and extensive documentation of the libx264
-options, invoke the command @command{x264 --full-help} or consult
+options, invoke the command @command{x264 --fullhelp} or consult
 the libx264 documentation.
 
 @table @option
@@ -1751,6 +1854,10 @@ Exhaustive search.
 Hadamard exhaustive search (slowest).
 @end table
 
+@item forced-idr
+Normally, when forcing a I-frame type, the encoder can select any type
+of I-frame. This option forces it to choose an IDR-frame.
+
 @item subq (@emph{subme})
 Sub-pixel motion estimation method.
 
@@ -1999,7 +2106,7 @@ is kept undocumented for some reason.
 
 For example to specify libx264 encoding options with @command{ffmpeg}:
 @example
-ffmpeg -i foo.mpg -vcodec libx264 -x264opts keyint=123:min-keyint=20 -an out.mkv
+ffmpeg -i foo.mpg -c:v libx264 -x264opts keyint=123:min-keyint=20 -an out.mkv
 @end example
 
 @item a53cc @var{boolean}
@@ -2041,6 +2148,10 @@ Set the x265 preset.
 @item tune
 Set the x265 tune parameter.
 
+@item forced-idr
+Normally, when forcing a I-frame type, the encoder can select any type
+of I-frame. This option forces it to choose an IDR-frame.
+
 @item x265-params
 Set x265 options using a list of @var{key}=@var{value} couples separated
 by ":". See @command{x265 --help} for a list of options.
@@ -2270,6 +2381,7 @@ Select the ProRes profile to encode
 @item standard
 @item hq
 @item 4444
+@item 4444xq
 @end table
 
 @item quant_mat @var{integer}
@@ -2319,27 +2431,6 @@ Setting a higher @option{bits_per_mb} limit will improve the speed.
 For the fastest encoding speed set the @option{qscale} parameter (4 is the
 recommended value) and do not set a size constraint.
 
-@section libkvazaar
-
-Kvazaar H.265/HEVC encoder.
-
-Requires the presence of the libkvazaar headers and library during
-configuration. You need to explicitly configure the build with
-@option{--enable-libkvazaar}.
-
-@subsection Options
-
-@table @option
-
-@item b
-Set target video bitrate in bit/s and enable rate control.
-
-@item kvazaar-params
-Set kvazaar parameters as a list of @var{name}=@var{value} pairs separated
-by commas (,). See kvazaar documentation for a list of options.
-
-@end table
-
 @section QSV encoders
 
 The family of Intel QuickSync Video encoders (MPEG-2, H.264 and HEVC)
@@ -2428,6 +2519,126 @@ encoder use CAVLC instead of CABAC.
 
 @end itemize
 
+@section snow
+
+@subsection Options
+
+@table @option
+@item iterative_dia_size
+dia size for the iterative motion estimation
+@end table
+
+@section VAAPI encoders
+
+Wrappers for hardware encoders accessible via VAAPI.
+
+These encoders only accept input in VAAPI hardware surfaces.  If you have input
+in software frames, use the @option{hwupload} filter to upload them to the GPU.
+
+The following standard libavcodec options are used:
+@itemize
+@item
+@option{g} / @option{gop_size}
+@item
+@option{bf} / @option{max_b_frames}
+@item
+@option{profile}
+@item
+@option{level}
+@item
+@option{b} / @option{bit_rate}
+@item
+@option{maxrate} / @option{rc_max_rate}
+@item
+@option{bufsize} / @option{rc_buffer_size}
+@item
+@option{rc_init_occupancy} / @option{rc_initial_buffer_occupancy}
+@item
+@option{compression_level}
+
+Speed / quality tradeoff: higher values are faster / worse quality.
+@item
+@option{q} / @option{global_quality}
+
+Size / quality tradeoff: higher values are smaller / worse quality.
+@item
+@option{qmin}
+(only: @option{qmax} is not supported)
+@item
+@option{i_qfactor} / @option{i_quant_factor}
+@item
+@option{i_qoffset} / @option{i_quant_offset}
+@item
+@option{b_qfactor} / @option{b_quant_factor}
+@item
+@option{b_qoffset} / @option{b_quant_offset}
+@end itemize
+
+@table @option
+
+@item h264_vaapi
+@option{profile} sets the value of @emph{profile_idc} and the @emph{constraint_set*_flag}s.
+@option{level} sets the value of @emph{level_idc}.
+
+@table @option
+@item low_power
+Use low-power encoding mode.
+@item coder
+Set entropy encoder (default is @emph{cabac}).  Possible values:
+
+@table @samp
+@item ac
+@item cabac
+Use CABAC.
+
+@item vlc
+@item cavlc
+Use CAVLC.
+@end table
+@end table
+
+@item hevc_vaapi
+@option{profile} and @option{level} set the values of
+@emph{general_profile_idc} and @emph{general_level_idc} respectively.
+
+@item mjpeg_vaapi
+Always encodes using the standard quantisation and huffman tables -
+@option{global_quality} scales the standard quantisation table (range 1-100).
+
+@item mpeg2_vaapi
+@option{profile} and @option{level} set the value of @emph{profile_and_level_indication}.
+
+No rate control is supported.
+
+@item vp8_vaapi
+B-frames are not supported.
+
+@option{global_quality} sets the @emph{q_idx} used for non-key frames (range 0-127).
+
+@table @option
+@item loop_filter_level
+@item loop_filter_sharpness
+Manually set the loop filter parameters.
+@end table
+
+@item vp9_vaapi
+@option{global_quality} sets the @emph{q_idx} used for P-frames (range 0-255).
+
+@table @option
+@item loop_filter_level
+@item loop_filter_sharpness
+Manually set the loop filter parameters.
+@end table
+
+B-frames are supported, but the output stream is always in encode order rather than display
+order.  If B-frames are enabled, it may be necessary to use the @option{vp9_raw_reorder}
+bitstream filter to modify the output stream to display frames in the correct order.
+
+Only normal frames are produced - the @option{vp9_superframe} bitstream filter may be
+required to produce a stream usable with all decoders.
+
+@end table
+
 @section vc2
 
 SMPTE VC-2 (previously BBC Dirac Pro). This codec was primarily aimed at
diff --git a/mythtv/external/FFmpeg/doc/examples/.gitignore b/mythtv/external/FFmpeg/doc/examples/.gitignore
index 430d3bfbfc7..154c8415f6c 100644
--- a/mythtv/external/FFmpeg/doc/examples/.gitignore
+++ b/mythtv/external/FFmpeg/doc/examples/.gitignore
@@ -1,12 +1,16 @@
 /avio_dir_cmd
 /avio_reading
-/decoding_encoding
+/decode_audio
+/decode_video
 /demuxing_decoding
+/encode_audio
+/encode_video
 /extract_mvs
 /filter_audio
 /filtering_audio
 /filtering_video
 /http_multiclient
+/hw_decode
 /metadata
 /muxing
 /pc-uninstalled
diff --git a/mythtv/external/FFmpeg/doc/examples/Makefile b/mythtv/external/FFmpeg/doc/examples/Makefile
index af3815995a0..58afd71b85b 100644
--- a/mythtv/external/FFmpeg/doc/examples/Makefile
+++ b/mythtv/external/FFmpeg/doc/examples/Makefile
@@ -1,46 +1,62 @@
-# use pkg-config for getting CFLAGS and LDLIBS
-FFMPEG_LIBS=    libavdevice                        \
-                libavformat                        \
-                libavfilter                        \
-                libavcodec                         \
-                libswresample                      \
-                libswscale                         \
-                libavutil                          \
-
-CFLAGS += -Wall -g
-CFLAGS := $(shell pkg-config --cflags $(FFMPEG_LIBS)) $(CFLAGS)
-LDLIBS := $(shell pkg-config --libs $(FFMPEG_LIBS)) $(LDLIBS)
-
-EXAMPLES=       avio_dir_cmd                       \
-                avio_reading                       \
-                decoding_encoding                  \
-                demuxing_decoding                  \
-                extract_mvs                        \
-                filtering_video                    \
-                filtering_audio                    \
-                http_multiclient                   \
-                metadata                           \
-                muxing                             \
-                remuxing                           \
-                resampling_audio                   \
-                scaling_video                      \
-                transcode_aac                      \
-                transcoding                        \
-
-OBJS=$(addsuffix .o,$(EXAMPLES))
-
-# the following examples make explicit use of the math library
-avcodec:           LDLIBS += -lm
-decoding_encoding: LDLIBS += -lm
-muxing:            LDLIBS += -lm
-resampling_audio:  LDLIBS += -lm
-
-.phony: all clean-test clean
-
-all: $(OBJS) $(EXAMPLES)
-
-clean-test:
-	$(RM) test*.pgm test.h264 test.mp2 test.sw test.mpg
-
-clean: clean-test
-	$(RM) $(EXAMPLES) $(OBJS)
+EXAMPLES-$(CONFIG_AVIO_DIR_CMD_EXAMPLE)      += avio_dir_cmd
+EXAMPLES-$(CONFIG_AVIO_READING_EXAMPLE)      += avio_reading
+EXAMPLES-$(CONFIG_DECODE_AUDIO_EXAMPLE)      += decode_audio
+EXAMPLES-$(CONFIG_DECODE_VIDEO_EXAMPLE)      += decode_video
+EXAMPLES-$(CONFIG_DEMUXING_DECODING_EXAMPLE) += demuxing_decoding
+EXAMPLES-$(CONFIG_ENCODE_AUDIO_EXAMPLE)      += encode_audio
+EXAMPLES-$(CONFIG_ENCODE_VIDEO_EXAMPLE)      += encode_video
+EXAMPLES-$(CONFIG_EXTRACT_MVS_EXAMPLE)       += extract_mvs
+EXAMPLES-$(CONFIG_FILTER_AUDIO_EXAMPLE)      += filter_audio
+EXAMPLES-$(CONFIG_FILTERING_AUDIO_EXAMPLE)   += filtering_audio
+EXAMPLES-$(CONFIG_FILTERING_VIDEO_EXAMPLE)   += filtering_video
+EXAMPLES-$(CONFIG_HTTP_MULTICLIENT_EXAMPLE)  += http_multiclient
+EXAMPLES-$(CONFIG_HW_DECODE_EXAMPLE)         += hw_decode
+EXAMPLES-$(CONFIG_METADATA_EXAMPLE)          += metadata
+EXAMPLES-$(CONFIG_MUXING_EXAMPLE)            += muxing
+EXAMPLES-$(CONFIG_QSVDEC_EXAMPLE)            += qsvdec
+EXAMPLES-$(CONFIG_REMUXING_EXAMPLE)          += remuxing
+EXAMPLES-$(CONFIG_RESAMPLING_AUDIO_EXAMPLE)  += resampling_audio
+EXAMPLES-$(CONFIG_SCALING_VIDEO_EXAMPLE)     += scaling_video
+EXAMPLES-$(CONFIG_TRANSCODE_AAC_EXAMPLE)     += transcode_aac
+EXAMPLES-$(CONFIG_TRANSCODING_EXAMPLE)       += transcoding
+
+EXAMPLES       := $(EXAMPLES-yes:%=doc/examples/%$(PROGSSUF)$(EXESUF))
+EXAMPLES_G     := $(EXAMPLES-yes:%=doc/examples/%$(PROGSSUF)_g$(EXESUF))
+ALL_EXAMPLES   := $(EXAMPLES) $(EXAMPLES-:%=doc/examples/%$(PROGSSUF)$(EXESUF))
+ALL_EXAMPLES_G := $(EXAMPLES_G) $(EXAMPLES-:%=doc/examples/%$(PROGSSUF)_g$(EXESUF))
+PROGS          += $(EXAMPLES)
+
+EXAMPLE_MAKEFILE := $(SRC_PATH)/doc/examples/Makefile
+EXAMPLES_FILES := $(wildcard $(SRC_PATH)/doc/examples/*.c) $(SRC_PATH)/doc/examples/README $(EXAMPLE_MAKEFILE)
+
+$(foreach P,$(EXAMPLES),$(eval OBJS-$(P:%$(PROGSSUF)$(EXESUF)=%) = $(P:%$(PROGSSUF)$(EXESUF)=%).o))
+$(EXAMPLES_G): %$(PROGSSUF)_g$(EXESUF): %.o
+
+examples: $(EXAMPLES)
+
+$(EXAMPLES:%$(PROGSSUF)$(EXESUF)=%.o): | doc/examples
+OBJDIRS += doc/examples
+
+DOXY_INPUT += $(EXAMPLES:%$(PROGSSUF)$(EXESUF)=%.c)
+
+install: install-examples
+
+install-examples: $(EXAMPLES_FILES)
+	$(Q)mkdir -p "$(DATADIR)/examples"
+	$(INSTALL) -m 644 $(EXAMPLES_FILES) "$(DATADIR)/examples"
+	$(INSTALL) -m 644 $(EXAMPLE_MAKEFILE:%=%.example) "$(DATADIR)/examples/Makefile"
+
+uninstall: uninstall-examples
+
+uninstall-examples:
+	$(RM) -r "$(DATADIR)/examples"
+
+examplesclean:
+	$(RM) $(ALL_EXAMPLES) $(ALL_EXAMPLES_G)
+	$(RM) $(CLEANSUFFIXES:%=doc/examples/%)
+
+docclean:: examplesclean
+
+-include $(wildcard $(EXAMPLES:%$(PROGSSUF)$(EXESUF)=%.d))
+
+.PHONY: examples
diff --git a/mythtv/external/FFmpeg/doc/examples/Makefile.example b/mythtv/external/FFmpeg/doc/examples/Makefile.example
new file mode 100644
index 00000000000..6428154c51d
--- /dev/null
+++ b/mythtv/external/FFmpeg/doc/examples/Makefile.example
@@ -0,0 +1,50 @@
+# use pkg-config for getting CFLAGS and LDLIBS
+FFMPEG_LIBS=    libavdevice                        \
+                libavformat                        \
+                libavfilter                        \
+                libavcodec                         \
+                libswresample                      \
+                libswscale                         \
+                libavutil                          \
+
+CFLAGS += -Wall -g
+CFLAGS := $(shell pkg-config --cflags $(FFMPEG_LIBS)) $(CFLAGS)
+LDLIBS := $(shell pkg-config --libs $(FFMPEG_LIBS)) $(LDLIBS)
+
+EXAMPLES=       avio_dir_cmd                       \
+                avio_reading                       \
+                decode_audio                       \
+                decode_video                       \
+                demuxing_decoding                  \
+                encode_audio                       \
+                encode_video                       \
+                extract_mvs                        \
+                filtering_video                    \
+                filtering_audio                    \
+                http_multiclient                   \
+                hw_decode                          \
+                metadata                           \
+                muxing                             \
+                remuxing                           \
+                resampling_audio                   \
+                scaling_video                      \
+                transcode_aac                      \
+                transcoding                        \
+
+OBJS=$(addsuffix .o,$(EXAMPLES))
+
+# the following examples make explicit use of the math library
+avcodec:           LDLIBS += -lm
+encode_audio:      LDLIBS += -lm
+muxing:            LDLIBS += -lm
+resampling_audio:  LDLIBS += -lm
+
+.phony: all clean-test clean
+
+all: $(OBJS) $(EXAMPLES)
+
+clean-test:
+	$(RM) test*.pgm test.h264 test.mp2 test.sw test.mpg
+
+clean: clean-test
+	$(RM) $(EXAMPLES) $(OBJS)
diff --git a/mythtv/external/FFmpeg/doc/examples/decode_audio.c b/mythtv/external/FFmpeg/doc/examples/decode_audio.c
new file mode 100644
index 00000000000..fb9a9af2f60
--- /dev/null
+++ b/mythtv/external/FFmpeg/doc/examples/decode_audio.c
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2001 Fabrice Bellard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * @file
+ * audio decoding with libavcodec API example
+ *
+ * @example decode_audio.c
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libavutil/frame.h>
+#include <libavutil/mem.h>
+
+#include <libavcodec/avcodec.h>
+
+#define AUDIO_INBUF_SIZE 20480
+#define AUDIO_REFILL_THRESH 4096
+
+static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame,
+                   FILE *outfile)
+{
+    int i, ch;
+    int ret, data_size;
+
+    /* send the packet with the compressed data to the decoder */
+    ret = avcodec_send_packet(dec_ctx, pkt);
+    if (ret < 0) {
+        fprintf(stderr, "Error submitting the packet to the decoder\n");
+        exit(1);
+    }
+
+    /* read all the output frames (in general there may be any number of them */
+    while (ret >= 0) {
+        ret = avcodec_receive_frame(dec_ctx, frame);
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+            return;
+        else if (ret < 0) {
+            fprintf(stderr, "Error during decoding\n");
+            exit(1);
+        }
+        data_size = av_get_bytes_per_sample(dec_ctx->sample_fmt);
+        if (data_size < 0) {
+            /* This should not occur, checking just for paranoia */
+            fprintf(stderr, "Failed to calculate data size\n");
+            exit(1);
+        }
+        for (i = 0; i < frame->nb_samples; i++)
+            for (ch = 0; ch < dec_ctx->channels; ch++)
+                fwrite(frame->data[ch] + data_size*i, 1, data_size, outfile);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    const char *outfilename, *filename;
+    const AVCodec *codec;
+    AVCodecContext *c= NULL;
+    AVCodecParserContext *parser = NULL;
+    int len, ret;
+    FILE *f, *outfile;
+    uint8_t inbuf[AUDIO_INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
+    uint8_t *data;
+    size_t   data_size;
+    AVPacket *pkt;
+    AVFrame *decoded_frame = NULL;
+
+    if (argc <= 2) {
+        fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
+        exit(0);
+    }
+    filename    = argv[1];
+    outfilename = argv[2];
+
+    /* register all the codecs */
+    avcodec_register_all();
+
+    pkt = av_packet_alloc();
+
+    /* find the MPEG audio decoder */
+    codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
+    if (!codec) {
+        fprintf(stderr, "Codec not found\n");
+        exit(1);
+    }
+
+    parser = av_parser_init(codec->id);
+    if (!parser) {
+        fprintf(stderr, "Parser not found\n");
+        exit(1);
+    }
+
+    c = avcodec_alloc_context3(codec);
+    if (!c) {
+        fprintf(stderr, "Could not allocate audio codec context\n");
+        exit(1);
+    }
+
+    /* open it */
+    if (avcodec_open2(c, codec, NULL) < 0) {
+        fprintf(stderr, "Could not open codec\n");
+        exit(1);
+    }
+
+    f = fopen(filename, "rb");
+    if (!f) {
+        fprintf(stderr, "Could not open %s\n", filename);
+        exit(1);
+    }
+    outfile = fopen(outfilename, "wb");
+    if (!outfile) {
+        av_free(c);
+        exit(1);
+    }
+
+    /* decode until eof */
+    data      = inbuf;
+    data_size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
+
+    while (data_size > 0) {
+        if (!decoded_frame) {
+            if (!(decoded_frame = av_frame_alloc())) {
+                fprintf(stderr, "Could not allocate audio frame\n");
+                exit(1);
+            }
+        }
+
+        ret = av_parser_parse2(parser, c, &pkt->data, &pkt->size,
+                               data, data_size,
+                               AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);
+        if (ret < 0) {
+            fprintf(stderr, "Error while parsing\n");
+            exit(1);
+        }
+        data      += ret;
+        data_size -= ret;
+
+        if (pkt->size)
+            decode(c, pkt, decoded_frame, outfile);
+
+        if (data_size < AUDIO_REFILL_THRESH) {
+            memmove(inbuf, data, data_size);
+            data = inbuf;
+            len = fread(data + data_size, 1,
+                        AUDIO_INBUF_SIZE - data_size, f);
+            if (len > 0)
+                data_size += len;
+        }
+    }
+
+    /* flush the decoder */
+    pkt->data = NULL;
+    pkt->size = 0;
+    decode(c, pkt, decoded_frame, outfile);
+
+    fclose(outfile);
+    fclose(f);
+
+    avcodec_free_context(&c);
+    av_parser_close(parser);
+    av_frame_free(&decoded_frame);
+    av_packet_free(&pkt);
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/doc/examples/decode_video.c b/mythtv/external/FFmpeg/doc/examples/decode_video.c
new file mode 100644
index 00000000000..4377fd49e0d
--- /dev/null
+++ b/mythtv/external/FFmpeg/doc/examples/decode_video.c
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2001 Fabrice Bellard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * @file
+ * video decoding with libavcodec API example
+ *
+ * @example decode_video.c
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libavcodec/avcodec.h>
+
+#define INBUF_SIZE 4096
+
+static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
+                     char *filename)
+{
+    FILE *f;
+    int i;
+
+    f = fopen(filename,"w");
+    fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255);
+    for (i = 0; i < ysize; i++)
+        fwrite(buf + i * wrap, 1, xsize, f);
+    fclose(f);
+}
+
+static void decode(AVCodecContext *dec_ctx, AVFrame *frame, AVPacket *pkt,
+                   const char *filename)
+{
+    char buf[1024];
+    int ret;
+
+    ret = avcodec_send_packet(dec_ctx, pkt);
+    if (ret < 0) {
+        fprintf(stderr, "Error sending a packet for decoding\n");
+        exit(1);
+    }
+
+    while (ret >= 0) {
+        ret = avcodec_receive_frame(dec_ctx, frame);
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+            return;
+        else if (ret < 0) {
+            fprintf(stderr, "Error during decoding\n");
+            exit(1);
+        }
+
+        printf("saving frame %3d\n", dec_ctx->frame_number);
+        fflush(stdout);
+
+        /* the picture is allocated by the decoder. no need to
+           free it */
+        snprintf(buf, sizeof(buf), "%s-%d", filename, dec_ctx->frame_number);
+        pgm_save(frame->data[0], frame->linesize[0],
+                 frame->width, frame->height, buf);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    const char *filename, *outfilename;
+    const AVCodec *codec;
+    AVCodecParserContext *parser;
+    AVCodecContext *c= NULL;
+    FILE *f;
+    AVFrame *frame;
+    uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
+    uint8_t *data;
+    size_t   data_size;
+    int ret;
+    AVPacket *pkt;
+
+    if (argc <= 2) {
+        fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
+        exit(0);
+    }
+    filename    = argv[1];
+    outfilename = argv[2];
+
+    avcodec_register_all();
+
+    pkt = av_packet_alloc();
+    if (!pkt)
+        exit(1);
+
+    /* set end of buffer to 0 (this ensures that no overreading happens for damaged MPEG streams) */
+    memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+
+    /* find the MPEG-1 video decoder */
+    codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
+    if (!codec) {
+        fprintf(stderr, "Codec not found\n");
+        exit(1);
+    }
+
+    parser = av_parser_init(codec->id);
+    if (!parser) {
+        fprintf(stderr, "parser not found\n");
+        exit(1);
+    }
+
+    c = avcodec_alloc_context3(codec);
+    if (!c) {
+        fprintf(stderr, "Could not allocate video codec context\n");
+        exit(1);
+    }
+
+    /* For some codecs, such as msmpeg4 and mpeg4, width and height
+       MUST be initialized there because this information is not
+       available in the bitstream. */
+
+    /* open it */
+    if (avcodec_open2(c, codec, NULL) < 0) {
+        fprintf(stderr, "Could not open codec\n");
+        exit(1);
+    }
+
+    f = fopen(filename, "rb");
+    if (!f) {
+        fprintf(stderr, "Could not open %s\n", filename);
+        exit(1);
+    }
+
+    frame = av_frame_alloc();
+    if (!frame) {
+        fprintf(stderr, "Could not allocate video frame\n");
+        exit(1);
+    }
+
+    while (!feof(f)) {
+        /* read raw data from the input file */
+        data_size = fread(inbuf, 1, INBUF_SIZE, f);
+        if (!data_size)
+            break;
+
+        /* use the parser to split the data into frames */
+        data = inbuf;
+        while (data_size > 0) {
+            ret = av_parser_parse2(parser, c, &pkt->data, &pkt->size,
+                                   data, data_size, AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);
+            if (ret < 0) {
+                fprintf(stderr, "Error while parsing\n");
+                exit(1);
+            }
+            data      += ret;
+            data_size -= ret;
+
+            if (pkt->size)
+                decode(c, frame, pkt, outfilename);
+        }
+    }
+
+    /* flush the decoder */
+    decode(c, frame, NULL, outfilename);
+
+    fclose(f);
+
+    av_parser_close(parser);
+    avcodec_free_context(&c);
+    av_frame_free(&frame);
+    av_packet_free(&pkt);
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/doc/examples/decoding_encoding.c b/mythtv/external/FFmpeg/doc/examples/decoding_encoding.c
deleted file mode 100644
index 43a64c2d595..00000000000
--- a/mythtv/external/FFmpeg/doc/examples/decoding_encoding.c
+++ /dev/null
@@ -1,665 +0,0 @@
-/*
- * Copyright (c) 2001 Fabrice Bellard
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-/**
- * @file
- * libavcodec API use example.
- *
- * @example decoding_encoding.c
- * Note that libavcodec only handles codecs (MPEG, MPEG-4, etc...),
- * not file formats (AVI, VOB, MP4, MOV, MKV, MXF, FLV, MPEG-TS, MPEG-PS, etc...).
- * See library 'libavformat' for the format handling
- */
-
-#include <math.h>
-
-#include <libavutil/opt.h>
-#include <libavcodec/avcodec.h>
-#include <libavutil/channel_layout.h>
-#include <libavutil/common.h>
-#include <libavutil/imgutils.h>
-#include <libavutil/mathematics.h>
-#include <libavutil/samplefmt.h>
-
-#define INBUF_SIZE 4096
-#define AUDIO_INBUF_SIZE 20480
-#define AUDIO_REFILL_THRESH 4096
-
-/* check that a given sample format is supported by the encoder */
-static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
-{
-    const enum AVSampleFormat *p = codec->sample_fmts;
-
-    while (*p != AV_SAMPLE_FMT_NONE) {
-        if (*p == sample_fmt)
-            return 1;
-        p++;
-    }
-    return 0;
-}
-
-/* just pick the highest supported samplerate */
-static int select_sample_rate(AVCodec *codec)
-{
-    const int *p;
-    int best_samplerate = 0;
-
-    if (!codec->supported_samplerates)
-        return 44100;
-
-    p = codec->supported_samplerates;
-    while (*p) {
-        best_samplerate = FFMAX(*p, best_samplerate);
-        p++;
-    }
-    return best_samplerate;
-}
-
-/* select layout with the highest channel count */
-static int select_channel_layout(AVCodec *codec)
-{
-    const uint64_t *p;
-    uint64_t best_ch_layout = 0;
-    int best_nb_channels   = 0;
-
-    if (!codec->channel_layouts)
-        return AV_CH_LAYOUT_STEREO;
-
-    p = codec->channel_layouts;
-    while (*p) {
-        int nb_channels = av_get_channel_layout_nb_channels(*p);
-
-        if (nb_channels > best_nb_channels) {
-            best_ch_layout    = *p;
-            best_nb_channels = nb_channels;
-        }
-        p++;
-    }
-    return best_ch_layout;
-}
-
-/*
- * Audio encoding example
- */
-static void audio_encode_example(const char *filename)
-{
-    AVCodec *codec;
-    AVCodecContext *c= NULL;
-    AVFrame *frame;
-    AVPacket pkt;
-    int i, j, k, ret, got_output;
-    int buffer_size;
-    FILE *f;
-    uint16_t *samples;
-    float t, tincr;
-
-    printf("Encode audio file %s\n", filename);
-
-    /* find the MP2 encoder */
-    codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
-    if (!codec) {
-        fprintf(stderr, "Codec not found\n");
-        exit(1);
-    }
-
-    c = avcodec_alloc_context3(codec);
-    if (!c) {
-        fprintf(stderr, "Could not allocate audio codec context\n");
-        exit(1);
-    }
-
-    /* put sample parameters */
-    c->bit_rate = 64000;
-
-    /* check that the encoder supports s16 pcm input */
-    c->sample_fmt = AV_SAMPLE_FMT_S16;
-    if (!check_sample_fmt(codec, c->sample_fmt)) {
-        fprintf(stderr, "Encoder does not support sample format %s",
-                av_get_sample_fmt_name(c->sample_fmt));
-        exit(1);
-    }
-
-    /* select other audio parameters supported by the encoder */
-    c->sample_rate    = select_sample_rate(codec);
-    c->channel_layout = select_channel_layout(codec);
-    c->channels       = av_get_channel_layout_nb_channels(c->channel_layout);
-
-    /* open it */
-    if (avcodec_open2(c, codec, NULL) < 0) {
-        fprintf(stderr, "Could not open codec\n");
-        exit(1);
-    }
-
-    f = fopen(filename, "wb");
-    if (!f) {
-        fprintf(stderr, "Could not open %s\n", filename);
-        exit(1);
-    }
-
-    /* frame containing input raw audio */
-    frame = av_frame_alloc();
-    if (!frame) {
-        fprintf(stderr, "Could not allocate audio frame\n");
-        exit(1);
-    }
-
-    frame->nb_samples     = c->frame_size;
-    frame->format         = c->sample_fmt;
-    frame->channel_layout = c->channel_layout;
-
-    /* the codec gives us the frame size, in samples,
-     * we calculate the size of the samples buffer in bytes */
-    buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
-                                             c->sample_fmt, 0);
-    if (buffer_size < 0) {
-        fprintf(stderr, "Could not get sample buffer size\n");
-        exit(1);
-    }
-    samples = av_malloc(buffer_size);
-    if (!samples) {
-        fprintf(stderr, "Could not allocate %d bytes for samples buffer\n",
-                buffer_size);
-        exit(1);
-    }
-    /* setup the data pointers in the AVFrame */
-    ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
-                                   (const uint8_t*)samples, buffer_size, 0);
-    if (ret < 0) {
-        fprintf(stderr, "Could not setup audio frame\n");
-        exit(1);
-    }
-
-    /* encode a single tone sound */
-    t = 0;
-    tincr = 2 * M_PI * 440.0 / c->sample_rate;
-    for (i = 0; i < 200; i++) {
-        av_init_packet(&pkt);
-        pkt.data = NULL; // packet data will be allocated by the encoder
-        pkt.size = 0;
-
-        for (j = 0; j < c->frame_size; j++) {
-            samples[2*j] = (int)(sin(t) * 10000);
-
-            for (k = 1; k < c->channels; k++)
-                samples[2*j + k] = samples[2*j];
-            t += tincr;
-        }
-        /* encode the samples */
-        ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
-        if (ret < 0) {
-            fprintf(stderr, "Error encoding audio frame\n");
-            exit(1);
-        }
-        if (got_output) {
-            fwrite(pkt.data, 1, pkt.size, f);
-            av_packet_unref(&pkt);
-        }
-    }
-
-    /* get the delayed frames */
-    for (got_output = 1; got_output; i++) {
-        ret = avcodec_encode_audio2(c, &pkt, NULL, &got_output);
-        if (ret < 0) {
-            fprintf(stderr, "Error encoding frame\n");
-            exit(1);
-        }
-
-        if (got_output) {
-            fwrite(pkt.data, 1, pkt.size, f);
-            av_packet_unref(&pkt);
-        }
-    }
-    fclose(f);
-
-    av_freep(&samples);
-    av_frame_free(&frame);
-    avcodec_close(c);
-    av_free(c);
-}
-
-/*
- * Audio decoding.
- */
-static void audio_decode_example(const char *outfilename, const char *filename)
-{
-    AVCodec *codec;
-    AVCodecContext *c= NULL;
-    int len;
-    FILE *f, *outfile;
-    uint8_t inbuf[AUDIO_INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
-    AVPacket avpkt;
-    AVFrame *decoded_frame = NULL;
-
-    av_init_packet(&avpkt);
-
-    printf("Decode audio file %s to %s\n", filename, outfilename);
-
-    /* find the MPEG audio decoder */
-    codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
-    if (!codec) {
-        fprintf(stderr, "Codec not found\n");
-        exit(1);
-    }
-
-    c = avcodec_alloc_context3(codec);
-    if (!c) {
-        fprintf(stderr, "Could not allocate audio codec context\n");
-        exit(1);
-    }
-
-    /* open it */
-    if (avcodec_open2(c, codec, NULL) < 0) {
-        fprintf(stderr, "Could not open codec\n");
-        exit(1);
-    }
-
-    f = fopen(filename, "rb");
-    if (!f) {
-        fprintf(stderr, "Could not open %s\n", filename);
-        exit(1);
-    }
-    outfile = fopen(outfilename, "wb");
-    if (!outfile) {
-        av_free(c);
-        exit(1);
-    }
-
-    /* decode until eof */
-    avpkt.data = inbuf;
-    avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
-
-    while (avpkt.size > 0) {
-        int i, ch;
-        int got_frame = 0;
-
-        if (!decoded_frame) {
-            if (!(decoded_frame = av_frame_alloc())) {
-                fprintf(stderr, "Could not allocate audio frame\n");
-                exit(1);
-            }
-        }
-
-        len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
-        if (len < 0) {
-            fprintf(stderr, "Error while decoding\n");
-            exit(1);
-        }
-        if (got_frame) {
-            /* if a frame has been decoded, output it */
-            int data_size = av_get_bytes_per_sample(c->sample_fmt);
-            if (data_size < 0) {
-                /* This should not occur, checking just for paranoia */
-                fprintf(stderr, "Failed to calculate data size\n");
-                exit(1);
-            }
-            for (i=0; i<decoded_frame->nb_samples; i++)
-                for (ch=0; ch<c->channels; ch++)
-                    fwrite(decoded_frame->data[ch] + data_size*i, 1, data_size, outfile);
-        }
-        avpkt.size -= len;
-        avpkt.data += len;
-        avpkt.dts =
-        avpkt.pts = AV_NOPTS_VALUE;
-        if (avpkt.size < AUDIO_REFILL_THRESH) {
-            /* Refill the input buffer, to avoid trying to decode
-             * incomplete frames. Instead of this, one could also use
-             * a parser, or use a proper container format through
-             * libavformat. */
-            memmove(inbuf, avpkt.data, avpkt.size);
-            avpkt.data = inbuf;
-            len = fread(avpkt.data + avpkt.size, 1,
-                        AUDIO_INBUF_SIZE - avpkt.size, f);
-            if (len > 0)
-                avpkt.size += len;
-        }
-    }
-
-    fclose(outfile);
-    fclose(f);
-
-    avcodec_close(c);
-    av_free(c);
-    av_frame_free(&decoded_frame);
-}
-
-/*
- * Video encoding example
- */
-static void video_encode_example(const char *filename, int codec_id)
-{
-    AVCodec *codec;
-    AVCodecContext *c= NULL;
-    int i, ret, x, y, got_output;
-    FILE *f;
-    AVFrame *frame;
-    AVPacket pkt;
-    uint8_t endcode[] = { 0, 0, 1, 0xb7 };
-
-    printf("Encode video file %s\n", filename);
-
-    /* find the video encoder */
-    codec = avcodec_find_encoder(codec_id);
-    if (!codec) {
-        fprintf(stderr, "Codec not found\n");
-        exit(1);
-    }
-
-    c = avcodec_alloc_context3(codec);
-    if (!c) {
-        fprintf(stderr, "Could not allocate video codec context\n");
-        exit(1);
-    }
-
-    /* put sample parameters */
-    c->bit_rate = 400000;
-    /* resolution must be a multiple of two */
-    c->width = 352;
-    c->height = 288;
-    /* frames per second */
-    c->time_base = (AVRational){1,25};
-    /* emit one intra frame every ten frames
-     * check frame pict_type before passing frame
-     * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
-     * then gop_size is ignored and the output of encoder
-     * will always be I frame irrespective to gop_size
-     */
-    c->gop_size = 10;
-    c->max_b_frames = 1;
-    c->pix_fmt = AV_PIX_FMT_YUV420P;
-
-    if (codec_id == AV_CODEC_ID_H264)
-        av_opt_set(c->priv_data, "preset", "slow", 0);
-
-    /* open it */
-    if (avcodec_open2(c, codec, NULL) < 0) {
-        fprintf(stderr, "Could not open codec\n");
-        exit(1);
-    }
-
-    f = fopen(filename, "wb");
-    if (!f) {
-        fprintf(stderr, "Could not open %s\n", filename);
-        exit(1);
-    }
-
-    frame = av_frame_alloc();
-    if (!frame) {
-        fprintf(stderr, "Could not allocate video frame\n");
-        exit(1);
-    }
-    frame->format = c->pix_fmt;
-    frame->width  = c->width;
-    frame->height = c->height;
-
-    /* the image can be allocated by any means and av_image_alloc() is
-     * just the most convenient way if av_malloc() is to be used */
-    ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
-                         c->pix_fmt, 32);
-    if (ret < 0) {
-        fprintf(stderr, "Could not allocate raw picture buffer\n");
-        exit(1);
-    }
-
-    /* encode 1 second of video */
-    for (i = 0; i < 25; i++) {
-        av_init_packet(&pkt);
-        pkt.data = NULL;    // packet data will be allocated by the encoder
-        pkt.size = 0;
-
-        fflush(stdout);
-        /* prepare a dummy image */
-        /* Y */
-        for (y = 0; y < c->height; y++) {
-            for (x = 0; x < c->width; x++) {
-                frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
-            }
-        }
-
-        /* Cb and Cr */
-        for (y = 0; y < c->height/2; y++) {
-            for (x = 0; x < c->width/2; x++) {
-                frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
-                frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
-            }
-        }
-
-        frame->pts = i;
-
-        /* encode the image */
-        ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
-        if (ret < 0) {
-            fprintf(stderr, "Error encoding frame\n");
-            exit(1);
-        }
-
-        if (got_output) {
-            printf("Write frame %3d (size=%5d)\n", i, pkt.size);
-            fwrite(pkt.data, 1, pkt.size, f);
-            av_packet_unref(&pkt);
-        }
-    }
-
-    /* get the delayed frames */
-    for (got_output = 1; got_output; i++) {
-        fflush(stdout);
-
-        ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
-        if (ret < 0) {
-            fprintf(stderr, "Error encoding frame\n");
-            exit(1);
-        }
-
-        if (got_output) {
-            printf("Write frame %3d (size=%5d)\n", i, pkt.size);
-            fwrite(pkt.data, 1, pkt.size, f);
-            av_packet_unref(&pkt);
-        }
-    }
-
-    /* add sequence end code to have a real MPEG file */
-    fwrite(endcode, 1, sizeof(endcode), f);
-    fclose(f);
-
-    avcodec_close(c);
-    av_free(c);
-    av_freep(&frame->data[0]);
-    av_frame_free(&frame);
-    printf("\n");
-}
-
-/*
- * Video decoding example
- */
-
-static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
-                     char *filename)
-{
-    FILE *f;
-    int i;
-
-    f = fopen(filename,"w");
-    fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255);
-    for (i = 0; i < ysize; i++)
-        fwrite(buf + i * wrap, 1, xsize, f);
-    fclose(f);
-}
-
-static int decode_write_frame(const char *outfilename, AVCodecContext *avctx,
-                              AVFrame *frame, int *frame_count, AVPacket *pkt, int last)
-{
-    int len, got_frame;
-    char buf[1024];
-
-    len = avcodec_decode_video2(avctx, frame, &got_frame, pkt);
-    if (len < 0) {
-        fprintf(stderr, "Error while decoding frame %d\n", *frame_count);
-        return len;
-    }
-    if (got_frame) {
-        printf("Saving %sframe %3d\n", last ? "last " : "", *frame_count);
-        fflush(stdout);
-
-        /* the picture is allocated by the decoder, no need to free it */
-        snprintf(buf, sizeof(buf), outfilename, *frame_count);
-        pgm_save(frame->data[0], frame->linesize[0],
-                 frame->width, frame->height, buf);
-        (*frame_count)++;
-    }
-    if (pkt->data) {
-        pkt->size -= len;
-        pkt->data += len;
-    }
-    return 0;
-}
-
-static void video_decode_example(const char *outfilename, const char *filename)
-{
-    AVCodec *codec;
-    AVCodecContext *c= NULL;
-    int frame_count;
-    FILE *f;
-    AVFrame *frame;
-    uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
-    AVPacket avpkt;
-
-    av_init_packet(&avpkt);
-
-    /* set end of buffer to 0 (this ensures that no overreading happens for damaged MPEG streams) */
-    memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
-
-    printf("Decode video file %s to %s\n", filename, outfilename);
-
-    /* find the MPEG-1 video decoder */
-    codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
-    if (!codec) {
-        fprintf(stderr, "Codec not found\n");
-        exit(1);
-    }
-
-    c = avcodec_alloc_context3(codec);
-    if (!c) {
-        fprintf(stderr, "Could not allocate video codec context\n");
-        exit(1);
-    }
-
-    if (codec->capabilities & AV_CODEC_CAP_TRUNCATED)
-        c->flags |= AV_CODEC_FLAG_TRUNCATED; // we do not send complete frames
-
-    /* For some codecs, such as msmpeg4 and mpeg4, width and height
-       MUST be initialized there because this information is not
-       available in the bitstream. */
-
-    /* open it */
-    if (avcodec_open2(c, codec, NULL) < 0) {
-        fprintf(stderr, "Could not open codec\n");
-        exit(1);
-    }
-
-    f = fopen(filename, "rb");
-    if (!f) {
-        fprintf(stderr, "Could not open %s\n", filename);
-        exit(1);
-    }
-
-    frame = av_frame_alloc();
-    if (!frame) {
-        fprintf(stderr, "Could not allocate video frame\n");
-        exit(1);
-    }
-
-    frame_count = 0;
-    for (;;) {
-        avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
-        if (avpkt.size == 0)
-            break;
-
-        /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
-           and this is the only method to use them because you cannot
-           know the compressed data size before analysing it.
-
-           BUT some other codecs (msmpeg4, mpeg4) are inherently frame
-           based, so you must call them with all the data for one
-           frame exactly. You must also initialize 'width' and
-           'height' before initializing them. */
-
-        /* NOTE2: some codecs allow the raw parameters (frame size,
-           sample rate) to be changed at any frame. We handle this, so
-           you should also take care of it */
-
-        /* here, we use a stream based decoder (mpeg1video), so we
-           feed decoder and see if it could decode a frame */
-        avpkt.data = inbuf;
-        while (avpkt.size > 0)
-            if (decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 0) < 0)
-                exit(1);
-    }
-
-    /* Some codecs, such as MPEG, transmit the I- and P-frame with a
-       latency of one frame. You must do the following to have a
-       chance to get the last frame of the video. */
-    avpkt.data = NULL;
-    avpkt.size = 0;
-    decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 1);
-
-    fclose(f);
-
-    avcodec_close(c);
-    av_free(c);
-    av_frame_free(&frame);
-    printf("\n");
-}
-
-int main(int argc, char **argv)
-{
-    const char *output_type;
-
-    /* register all the codecs */
-    avcodec_register_all();
-
-    if (argc < 2) {
-        printf("usage: %s output_type\n"
-               "API example program to decode/encode a media stream with libavcodec.\n"
-               "This program generates a synthetic stream and encodes it to a file\n"
-               "named test.h264, test.mp2 or test.mpg depending on output_type.\n"
-               "The encoded stream is then decoded and written to a raw data output.\n"
-               "output_type must be chosen between 'h264', 'mp2', 'mpg'.\n",
-               argv[0]);
-        return 1;
-    }
-    output_type = argv[1];
-
-    if (!strcmp(output_type, "h264")) {
-        video_encode_example("test.h264", AV_CODEC_ID_H264);
-    } else if (!strcmp(output_type, "mp2")) {
-        audio_encode_example("test.mp2");
-        audio_decode_example("test.pcm", "test.mp2");
-    } else if (!strcmp(output_type, "mpg")) {
-        video_encode_example("test.mpg", AV_CODEC_ID_MPEG1VIDEO);
-        video_decode_example("test%02d.pgm", "test.mpg");
-    } else {
-        fprintf(stderr, "Invalid output type '%s', choose between 'h264', 'mp2', or 'mpg'\n",
-                output_type);
-        return 1;
-    }
-
-    return 0;
-}
diff --git a/mythtv/external/FFmpeg/doc/examples/encode_audio.c b/mythtv/external/FFmpeg/doc/examples/encode_audio.c
new file mode 100644
index 00000000000..d1ef105d9da
--- /dev/null
+++ b/mythtv/external/FFmpeg/doc/examples/encode_audio.c
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 2001 Fabrice Bellard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * @file
+ * audio encoding with libavcodec API example.
+ *
+ * @example encode_audio.c
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <libavcodec/avcodec.h>
+
+#include <libavutil/channel_layout.h>
+#include <libavutil/common.h>
+#include <libavutil/frame.h>
+#include <libavutil/samplefmt.h>
+
+/* check that a given sample format is supported by the encoder */
+static int check_sample_fmt(const AVCodec *codec, enum AVSampleFormat sample_fmt)
+{
+    const enum AVSampleFormat *p = codec->sample_fmts;
+
+    while (*p != AV_SAMPLE_FMT_NONE) {
+        if (*p == sample_fmt)
+            return 1;
+        p++;
+    }
+    return 0;
+}
+
+/* just pick the highest supported samplerate */
+static int select_sample_rate(const AVCodec *codec)
+{
+    const int *p;
+    int best_samplerate = 0;
+
+    if (!codec->supported_samplerates)
+        return 44100;
+
+    p = codec->supported_samplerates;
+    while (*p) {
+        if (!best_samplerate || abs(44100 - *p) < abs(44100 - best_samplerate))
+            best_samplerate = *p;
+        p++;
+    }
+    return best_samplerate;
+}
+
+/* select layout with the highest channel count */
+static int select_channel_layout(const AVCodec *codec)
+{
+    const uint64_t *p;
+    uint64_t best_ch_layout = 0;
+    int best_nb_channels   = 0;
+
+    if (!codec->channel_layouts)
+        return AV_CH_LAYOUT_STEREO;
+
+    p = codec->channel_layouts;
+    while (*p) {
+        int nb_channels = av_get_channel_layout_nb_channels(*p);
+
+        if (nb_channels > best_nb_channels) {
+            best_ch_layout    = *p;
+            best_nb_channels = nb_channels;
+        }
+        p++;
+    }
+    return best_ch_layout;
+}
+
+static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt,
+                   FILE *output)
+{
+    int ret;
+
+    /* send the frame for encoding */
+    ret = avcodec_send_frame(ctx, frame);
+    if (ret < 0) {
+        fprintf(stderr, "Error sending the frame to the encoder\n");
+        exit(1);
+    }
+
+    /* read all the available output packets (in general there may be any
+     * number of them */
+    while (ret >= 0) {
+        ret = avcodec_receive_packet(ctx, pkt);
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+            return;
+        else if (ret < 0) {
+            fprintf(stderr, "Error encoding audio frame\n");
+            exit(1);
+        }
+
+        fwrite(pkt->data, 1, pkt->size, output);
+        av_packet_unref(pkt);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    const char *filename;
+    const AVCodec *codec;
+    AVCodecContext *c= NULL;
+    AVFrame *frame;
+    AVPacket *pkt;
+    int i, j, k, ret;
+    FILE *f;
+    uint16_t *samples;
+    float t, tincr;
+
+    if (argc <= 1) {
+        fprintf(stderr, "Usage: %s <output file>\n", argv[0]);
+        return 0;
+    }
+    filename = argv[1];
+
+    /* register all the codecs */
+    avcodec_register_all();
+
+    /* find the MP2 encoder */
+    codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
+    if (!codec) {
+        fprintf(stderr, "Codec not found\n");
+        exit(1);
+    }
+
+    c = avcodec_alloc_context3(codec);
+    if (!c) {
+        fprintf(stderr, "Could not allocate audio codec context\n");
+        exit(1);
+    }
+
+    /* put sample parameters */
+    c->bit_rate = 64000;
+
+    /* check that the encoder supports s16 pcm input */
+    c->sample_fmt = AV_SAMPLE_FMT_S16;
+    if (!check_sample_fmt(codec, c->sample_fmt)) {
+        fprintf(stderr, "Encoder does not support sample format %s",
+                av_get_sample_fmt_name(c->sample_fmt));
+        exit(1);
+    }
+
+    /* select other audio parameters supported by the encoder */
+    c->sample_rate    = select_sample_rate(codec);
+    c->channel_layout = select_channel_layout(codec);
+    c->channels       = av_get_channel_layout_nb_channels(c->channel_layout);
+
+    /* open it */
+    if (avcodec_open2(c, codec, NULL) < 0) {
+        fprintf(stderr, "Could not open codec\n");
+        exit(1);
+    }
+
+    f = fopen(filename, "wb");
+    if (!f) {
+        fprintf(stderr, "Could not open %s\n", filename);
+        exit(1);
+    }
+
+    /* packet for holding encoded output */
+    pkt = av_packet_alloc();
+    if (!pkt) {
+        fprintf(stderr, "could not allocate the packet\n");
+        exit(1);
+    }
+
+    /* frame containing input raw audio */
+    frame = av_frame_alloc();
+    if (!frame) {
+        fprintf(stderr, "Could not allocate audio frame\n");
+        exit(1);
+    }
+
+    frame->nb_samples     = c->frame_size;
+    frame->format         = c->sample_fmt;
+    frame->channel_layout = c->channel_layout;
+
+    /* allocate the data buffers */
+    ret = av_frame_get_buffer(frame, 0);
+    if (ret < 0) {
+        fprintf(stderr, "Could not allocate audio data buffers\n");
+        exit(1);
+    }
+
+    /* encode a single tone sound */
+    t = 0;
+    tincr = 2 * M_PI * 440.0 / c->sample_rate;
+    for (i = 0; i < 200; i++) {
+        /* make sure the frame is writable -- makes a copy if the encoder
+         * kept a reference internally */
+        ret = av_frame_make_writable(frame);
+        if (ret < 0)
+            exit(1);
+        samples = (uint16_t*)frame->data[0];
+
+        for (j = 0; j < c->frame_size; j++) {
+            samples[2*j] = (int)(sin(t) * 10000);
+
+            for (k = 1; k < c->channels; k++)
+                samples[2*j + k] = samples[2*j];
+            t += tincr;
+        }
+        encode(c, frame, pkt, f);
+    }
+
+    /* flush the encoder */
+    encode(c, NULL, pkt, f);
+
+    fclose(f);
+
+    av_frame_free(&frame);
+    av_packet_free(&pkt);
+    avcodec_free_context(&c);
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/doc/examples/encode_video.c b/mythtv/external/FFmpeg/doc/examples/encode_video.c
new file mode 100644
index 00000000000..8cd13219bb5
--- /dev/null
+++ b/mythtv/external/FFmpeg/doc/examples/encode_video.c
@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2001 Fabrice Bellard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * @file
+ * video encoding with libavcodec API example
+ *
+ * @example encode_video.c
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libavcodec/avcodec.h>
+
+#include <libavutil/opt.h>
+#include <libavutil/imgutils.h>
+
+static void encode(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt,
+                   FILE *outfile)
+{
+    int ret;
+
+    /* send the frame to the encoder */
+    if (frame)
+        printf("Send frame %3"PRId64"\n", frame->pts);
+
+    ret = avcodec_send_frame(enc_ctx, frame);
+    if (ret < 0) {
+        fprintf(stderr, "Error sending a frame for encoding\n");
+        exit(1);
+    }
+
+    while (ret >= 0) {
+        ret = avcodec_receive_packet(enc_ctx, pkt);
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+            return;
+        else if (ret < 0) {
+            fprintf(stderr, "Error during encoding\n");
+            exit(1);
+        }
+
+        printf("Write packet %3"PRId64" (size=%5d)\n", pkt->pts, pkt->size);
+        fwrite(pkt->data, 1, pkt->size, outfile);
+        av_packet_unref(pkt);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    const char *filename, *codec_name;
+    const AVCodec *codec;
+    AVCodecContext *c= NULL;
+    int i, ret, x, y;
+    FILE *f;
+    AVFrame *frame;
+    AVPacket *pkt;
+    uint8_t endcode[] = { 0, 0, 1, 0xb7 };
+
+    if (argc <= 2) {
+        fprintf(stderr, "Usage: %s <output file> <codec name>\n", argv[0]);
+        exit(0);
+    }
+    filename = argv[1];
+    codec_name = argv[2];
+
+    avcodec_register_all();
+
+    /* find the mpeg1video encoder */
+    codec = avcodec_find_encoder_by_name(codec_name);
+    if (!codec) {
+        fprintf(stderr, "Codec '%s' not found\n", codec_name);
+        exit(1);
+    }
+
+    c = avcodec_alloc_context3(codec);
+    if (!c) {
+        fprintf(stderr, "Could not allocate video codec context\n");
+        exit(1);
+    }
+
+    pkt = av_packet_alloc();
+    if (!pkt)
+        exit(1);
+
+    /* put sample parameters */
+    c->bit_rate = 400000;
+    /* resolution must be a multiple of two */
+    c->width = 352;
+    c->height = 288;
+    /* frames per second */
+    c->time_base = (AVRational){1, 25};
+    c->framerate = (AVRational){25, 1};
+
+    /* emit one intra frame every ten frames
+     * check frame pict_type before passing frame
+     * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
+     * then gop_size is ignored and the output of encoder
+     * will always be I frame irrespective to gop_size
+     */
+    c->gop_size = 10;
+    c->max_b_frames = 1;
+    c->pix_fmt = AV_PIX_FMT_YUV420P;
+
+    if (codec->id == AV_CODEC_ID_H264)
+        av_opt_set(c->priv_data, "preset", "slow", 0);
+
+    /* open it */
+    ret = avcodec_open2(c, codec, NULL);
+    if (ret < 0) {
+        fprintf(stderr, "Could not open codec: %s\n", av_err2str(ret));
+        exit(1);
+    }
+
+    f = fopen(filename, "wb");
+    if (!f) {
+        fprintf(stderr, "Could not open %s\n", filename);
+        exit(1);
+    }
+
+    frame = av_frame_alloc();
+    if (!frame) {
+        fprintf(stderr, "Could not allocate video frame\n");
+        exit(1);
+    }
+    frame->format = c->pix_fmt;
+    frame->width  = c->width;
+    frame->height = c->height;
+
+    ret = av_frame_get_buffer(frame, 32);
+    if (ret < 0) {
+        fprintf(stderr, "Could not allocate the video frame data\n");
+        exit(1);
+    }
+
+    /* encode 1 second of video */
+    for (i = 0; i < 25; i++) {
+        fflush(stdout);
+
+        /* make sure the frame data is writable */
+        ret = av_frame_make_writable(frame);
+        if (ret < 0)
+            exit(1);
+
+        /* prepare a dummy image */
+        /* Y */
+        for (y = 0; y < c->height; y++) {
+            for (x = 0; x < c->width; x++) {
+                frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
+            }
+        }
+
+        /* Cb and Cr */
+        for (y = 0; y < c->height/2; y++) {
+            for (x = 0; x < c->width/2; x++) {
+                frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
+                frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
+            }
+        }
+
+        frame->pts = i;
+
+        /* encode the image */
+        encode(c, frame, pkt, f);
+    }
+
+    /* flush the encoder */
+    encode(c, NULL, pkt, f);
+
+    /* add sequence end code to have a real MPEG file */
+    fwrite(endcode, 1, sizeof(endcode), f);
+    fclose(f);
+
+    avcodec_free_context(&c);
+    av_frame_free(&frame);
+    av_packet_free(&pkt);
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/doc/examples/extract_mvs.c b/mythtv/external/FFmpeg/doc/examples/extract_mvs.c
index 975189c77d3..7ae934ead3d 100644
--- a/mythtv/external/FFmpeg/doc/examples/extract_mvs.c
+++ b/mythtv/external/FFmpeg/doc/examples/extract_mvs.c
@@ -31,23 +31,26 @@ static const char *src_filename = NULL;
 
 static int video_stream_idx = -1;
 static AVFrame *frame = NULL;
-static AVPacket pkt;
 static int video_frame_count = 0;
 
-static int decode_packet(int *got_frame, int cached)
+static int decode_packet(const AVPacket *pkt)
 {
-    int decoded = pkt.size;
-
-    *got_frame = 0;
+    int ret = avcodec_send_packet(video_dec_ctx, pkt);
+    if (ret < 0) {
+        fprintf(stderr, "Error while sending a packet to the decoder: %s\n", av_err2str(ret));
+        return ret;
+    }
 
-    if (pkt.stream_index == video_stream_idx) {
-        int ret = avcodec_decode_video2(video_dec_ctx, frame, got_frame, &pkt);
-        if (ret < 0) {
-            fprintf(stderr, "Error decoding video frame (%s)\n", av_err2str(ret));
+    while (ret >= 0)  {
+        ret = avcodec_receive_frame(video_dec_ctx, frame);
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
+            break;
+        } else if (ret < 0) {
+            fprintf(stderr, "Error while receiving a frame from the decoder: %s\n", av_err2str(ret));
             return ret;
         }
 
-        if (*got_frame) {
+        if (ret >= 0) {
             int i;
             AVFrameSideData *sd;
 
@@ -58,19 +61,19 @@ static int decode_packet(int *got_frame, int cached)
                 for (i = 0; i < sd->size / sizeof(*mvs); i++) {
                     const AVMotionVector *mv = &mvs[i];
                     printf("%d,%2d,%2d,%2d,%4d,%4d,%4d,%4d,0x%"PRIx64"\n",
-                           video_frame_count, mv->source,
-                           mv->w, mv->h, mv->src_x, mv->src_y,
-                           mv->dst_x, mv->dst_y, mv->flags);
+                        video_frame_count, mv->source,
+                        mv->w, mv->h, mv->src_x, mv->src_y,
+                        mv->dst_x, mv->dst_y, mv->flags);
                 }
             }
+            av_frame_unref(frame);
         }
     }
 
-    return decoded;
+    return 0;
 }
 
-static int open_codec_context(int *stream_idx,
-                              AVFormatContext *fmt_ctx, enum AVMediaType type)
+static int open_codec_context(AVFormatContext *fmt_ctx, enum AVMediaType type)
 {
     int ret;
     AVStream *st;
@@ -78,24 +81,27 @@ static int open_codec_context(int *stream_idx,
     AVCodec *dec = NULL;
     AVDictionary *opts = NULL;
 
-    ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
+    ret = av_find_best_stream(fmt_ctx, type, -1, -1, &dec, 0);
     if (ret < 0) {
         fprintf(stderr, "Could not find %s stream in input file '%s'\n",
                 av_get_media_type_string(type), src_filename);
         return ret;
     } else {
-        *stream_idx = ret;
-        st = fmt_ctx->streams[*stream_idx];
-
-        /* find decoder for the stream */
-        dec_ctx = st->codec;
-        dec = avcodec_find_decoder(dec_ctx->codec_id);
-        if (!dec) {
-            fprintf(stderr, "Failed to find %s codec\n",
-                    av_get_media_type_string(type));
+        int stream_idx = ret;
+        st = fmt_ctx->streams[stream_idx];
+
+        dec_ctx = avcodec_alloc_context3(dec);
+        if (!dec_ctx) {
+            fprintf(stderr, "Failed to allocate codec\n");
             return AVERROR(EINVAL);
         }
 
+        ret = avcodec_parameters_to_context(dec_ctx, st->codecpar);
+        if (ret < 0) {
+            fprintf(stderr, "Failed to copy codec parameters to codec context\n");
+            return ret;
+        }
+
         /* Init the video decoder */
         av_dict_set(&opts, "flags2", "+export_mvs", 0);
         if ((ret = avcodec_open2(dec_ctx, dec, &opts)) < 0) {
@@ -103,6 +109,10 @@ static int open_codec_context(int *stream_idx,
                     av_get_media_type_string(type));
             return ret;
         }
+
+        video_stream_idx = stream_idx;
+        video_stream = fmt_ctx->streams[video_stream_idx];
+        video_dec_ctx = dec_ctx;
     }
 
     return 0;
@@ -110,7 +120,8 @@ static int open_codec_context(int *stream_idx,
 
 int main(int argc, char **argv)
 {
-    int ret = 0, got_frame;
+    int ret = 0;
+    AVPacket pkt = { 0 };
 
     if (argc != 2) {
         fprintf(stderr, "Usage: %s <video>\n", argv[0]);
@@ -130,10 +141,7 @@ int main(int argc, char **argv)
         exit(1);
     }
 
-    if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
-        video_stream = fmt_ctx->streams[video_stream_idx];
-        video_dec_ctx = video_stream->codec;
-    }
+    open_codec_context(fmt_ctx, AVMEDIA_TYPE_VIDEO);
 
     av_dump_format(fmt_ctx, 0, src_filename, 0);
 
@@ -152,33 +160,20 @@ int main(int argc, char **argv)
 
     printf("framenum,source,blockw,blockh,srcx,srcy,dstx,dsty,flags\n");
 
-    /* initialize packet, set data to NULL, let the demuxer fill it */
-    av_init_packet(&pkt);
-    pkt.data = NULL;
-    pkt.size = 0;
-
     /* read frames from the file */
     while (av_read_frame(fmt_ctx, &pkt) >= 0) {
-        AVPacket orig_pkt = pkt;
-        do {
-            ret = decode_packet(&got_frame, 0);
-            if (ret < 0)
-                break;
-            pkt.data += ret;
-            pkt.size -= ret;
-        } while (pkt.size > 0);
-        av_packet_unref(&orig_pkt);
+        if (pkt.stream_index == video_stream_idx)
+            ret = decode_packet(&pkt);
+        av_packet_unref(&pkt);
+        if (ret < 0)
+            break;
     }
 
     /* flush cached frames */
-    pkt.data = NULL;
-    pkt.size = 0;
-    do {
-        decode_packet(&got_frame, 1);
-    } while (got_frame);
+    decode_packet(NULL);
 
 end:
-    avcodec_close(video_dec_ctx);
+    avcodec_free_context(&video_dec_ctx);
     avformat_close_input(&fmt_ctx);
     av_frame_free(&frame);
     return ret < 0;
diff --git a/mythtv/external/FFmpeg/doc/examples/filtering_audio.c b/mythtv/external/FFmpeg/doc/examples/filtering_audio.c
index 6bb24a431dc..9fc4f1cb7e3 100644
--- a/mythtv/external/FFmpeg/doc/examples/filtering_audio.c
+++ b/mythtv/external/FFmpeg/doc/examples/filtering_audio.c
@@ -69,7 +69,12 @@ static int open_input_file(const char *filename)
         return ret;
     }
     audio_stream_index = ret;
-    dec_ctx = fmt_ctx->streams[audio_stream_index]->codec;
+
+    /* create decoding context */
+    dec_ctx = avcodec_alloc_context3(dec);
+    if (!dec_ctx)
+        return AVERROR(ENOMEM);
+    avcodec_parameters_to_context(dec_ctx, fmt_ctx->streams[audio_stream_index]->codecpar);
     av_opt_set_int(dec_ctx, "refcounted_frames", 1, 0);
 
     /* init the audio decoder */
@@ -196,7 +201,7 @@ static int init_filters(const char *filters_descr)
 
 static void print_frame(const AVFrame *frame)
 {
-    const int n = frame->nb_samples * av_get_channel_layout_nb_channels(av_frame_get_channel_layout(frame));
+    const int n = frame->nb_samples * av_get_channel_layout_nb_channels(frame->channel_layout);
     const uint16_t *p     = (uint16_t*)frame->data[0];
     const uint16_t *p_end = p + n;
 
@@ -211,10 +216,9 @@ static void print_frame(const AVFrame *frame)
 int main(int argc, char **argv)
 {
     int ret;
-    AVPacket packet0, packet;
+    AVPacket packet;
     AVFrame *frame = av_frame_alloc();
     AVFrame *filt_frame = av_frame_alloc();
-    int got_frame;
 
     if (!frame || !filt_frame) {
         perror("Could not allocate frame");
@@ -234,54 +238,52 @@ int main(int argc, char **argv)
         goto end;
 
     /* read all packets */
-    packet0.data = NULL;
-    packet.data = NULL;
     while (1) {
-        if (!packet0.data) {
-            if ((ret = av_read_frame(fmt_ctx, &packet)) < 0)
-                break;
-            packet0 = packet;
-        }
+        if ((ret = av_read_frame(fmt_ctx, &packet)) < 0)
+            break;
 
         if (packet.stream_index == audio_stream_index) {
-            got_frame = 0;
-            ret = avcodec_decode_audio4(dec_ctx, frame, &got_frame, &packet);
+            ret = avcodec_send_packet(dec_ctx, &packet);
             if (ret < 0) {
-                av_log(NULL, AV_LOG_ERROR, "Error decoding audio\n");
-                continue;
+                av_log(NULL, AV_LOG_ERROR, "Error while sending a packet to the decoder\n");
+                break;
             }
-            packet.size -= ret;
-            packet.data += ret;
 
-            if (got_frame) {
-                /* push the audio data from decoded frame into the filtergraph */
-                if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, 0) < 0) {
-                    av_log(NULL, AV_LOG_ERROR, "Error while feeding the audio filtergraph\n");
+            while (ret >= 0) {
+                ret = avcodec_receive_frame(dec_ctx, frame);
+                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                     break;
+                } else if (ret < 0) {
+                    av_log(NULL, AV_LOG_ERROR, "Error while receiving a frame from the decoder\n");
+                    goto end;
                 }
 
-                /* pull filtered audio from the filtergraph */
-                while (1) {
-                    ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);
-                    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+                if (ret >= 0) {
+                    /* push the audio data from decoded frame into the filtergraph */
+                    if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) {
+                        av_log(NULL, AV_LOG_ERROR, "Error while feeding the audio filtergraph\n");
                         break;
-                    if (ret < 0)
-                        goto end;
-                    print_frame(filt_frame);
-                    av_frame_unref(filt_frame);
+                    }
+
+                    /* pull filtered audio from the filtergraph */
+                    while (1) {
+                        ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);
+                        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+                            break;
+                        if (ret < 0)
+                            goto end;
+                        print_frame(filt_frame);
+                        av_frame_unref(filt_frame);
+                    }
+                    av_frame_unref(frame);
                 }
             }
-
-            if (packet.size <= 0)
-                av_packet_unref(&packet0);
-        } else {
-            /* discard non-wanted packets */
-            av_packet_unref(&packet0);
         }
+        av_packet_unref(&packet);
     }
 end:
     avfilter_graph_free(&filter_graph);
-    avcodec_close(dec_ctx);
+    avcodec_free_context(&dec_ctx);
     avformat_close_input(&fmt_ctx);
     av_frame_free(&frame);
     av_frame_free(&filt_frame);
diff --git a/mythtv/external/FFmpeg/doc/examples/filtering_video.c b/mythtv/external/FFmpeg/doc/examples/filtering_video.c
index 3dabf13b100..4e09c6fba47 100644
--- a/mythtv/external/FFmpeg/doc/examples/filtering_video.c
+++ b/mythtv/external/FFmpeg/doc/examples/filtering_video.c
@@ -72,7 +72,12 @@ static int open_input_file(const char *filename)
         return ret;
     }
     video_stream_index = ret;
-    dec_ctx = fmt_ctx->streams[video_stream_index]->codec;
+
+    /* create decoding context */
+    dec_ctx = avcodec_alloc_context3(dec);
+    if (!dec_ctx)
+        return AVERROR(ENOMEM);
+    avcodec_parameters_to_context(dec_ctx, fmt_ctx->streams[video_stream_index]->codecpar);
     av_opt_set_int(dec_ctx, "refcounted_frames", 1, 0);
 
     /* init the video decoder */
@@ -208,7 +213,6 @@ int main(int argc, char **argv)
     AVPacket packet;
     AVFrame *frame = av_frame_alloc();
     AVFrame *filt_frame = av_frame_alloc();
-    int got_frame;
 
     if (!frame || !filt_frame) {
         perror("Could not allocate frame");
@@ -233,40 +237,49 @@ int main(int argc, char **argv)
             break;
 
         if (packet.stream_index == video_stream_index) {
-            got_frame = 0;
-            ret = avcodec_decode_video2(dec_ctx, frame, &got_frame, &packet);
+            ret = avcodec_send_packet(dec_ctx, &packet);
             if (ret < 0) {
-                av_log(NULL, AV_LOG_ERROR, "Error decoding video\n");
+                av_log(NULL, AV_LOG_ERROR, "Error while sending a packet to the decoder\n");
                 break;
             }
 
-            if (got_frame) {
-                frame->pts = av_frame_get_best_effort_timestamp(frame);
-
-                /* push the decoded frame into the filtergraph */
-                if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) {
-                    av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
+            while (ret >= 0) {
+                ret = avcodec_receive_frame(dec_ctx, frame);
+                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                     break;
+                } else if (ret < 0) {
+                    av_log(NULL, AV_LOG_ERROR, "Error while receiving a frame from the decoder\n");
+                    goto end;
                 }
 
-                /* pull filtered frames from the filtergraph */
-                while (1) {
-                    ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);
-                    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+                if (ret >= 0) {
+                    frame->pts = frame->best_effort_timestamp;
+
+                    /* push the decoded frame into the filtergraph */
+                    if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) {
+                        av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
                         break;
-                    if (ret < 0)
-                        goto end;
-                    display_frame(filt_frame, buffersink_ctx->inputs[0]->time_base);
-                    av_frame_unref(filt_frame);
+                    }
+
+                    /* pull filtered frames from the filtergraph */
+                    while (1) {
+                        ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);
+                        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+                            break;
+                        if (ret < 0)
+                            goto end;
+                        display_frame(filt_frame, buffersink_ctx->inputs[0]->time_base);
+                        av_frame_unref(filt_frame);
+                    }
+                    av_frame_unref(frame);
                 }
-                av_frame_unref(frame);
             }
         }
         av_packet_unref(&packet);
     }
 end:
     avfilter_graph_free(&filter_graph);
-    avcodec_close(dec_ctx);
+    avcodec_free_context(&dec_ctx);
     avformat_close_input(&fmt_ctx);
     av_frame_free(&frame);
     av_frame_free(&filt_frame);
diff --git a/mythtv/external/FFmpeg/doc/examples/http_multiclient.c b/mythtv/external/FFmpeg/doc/examples/http_multiclient.c
index 7173c4db326..e2c2201a08f 100644
--- a/mythtv/external/FFmpeg/doc/examples/http_multiclient.c
+++ b/mythtv/external/FFmpeg/doc/examples/http_multiclient.c
@@ -45,6 +45,7 @@ static void process_client(AVIOContext *client, const char *in_uri)
         // may return empty string.
         if (resource && strlen(resource))
             break;
+        av_freep(&resource);
     }
     if (ret < 0)
         goto end;
@@ -93,6 +94,7 @@ static void process_client(AVIOContext *client, const char *in_uri)
     avio_close(client);
     fprintf(stderr, "Closing input\n");
     avio_close(input);
+    av_freep(&resource);
 }
 
 int main(int argc, char **argv)
diff --git a/mythtv/external/FFmpeg/doc/examples/hw_decode.c b/mythtv/external/FFmpeg/doc/examples/hw_decode.c
new file mode 100644
index 00000000000..9c7adbf51a0
--- /dev/null
+++ b/mythtv/external/FFmpeg/doc/examples/hw_decode.c
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 2017 Jun Zhao
+ * Copyright (c) 2017 Kaixuan Liu
+ *
+ * HW Acceleration API (video decoding) decode sample
+ *
+ * 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
+ * HW-Accelerated decoding example.
+ *
+ * @example hw_decode.c
+ * This example shows how to do HW-accelerated decoding with output
+ * frames from the HW video surfaces.
+ */
+
+#include <stdio.h>
+
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/pixdesc.h>
+#include <libavutil/hwcontext.h>
+#include <libavutil/opt.h>
+#include <libavutil/avassert.h>
+#include <libavutil/imgutils.h>
+
+static AVBufferRef *hw_device_ctx = NULL;
+static enum AVPixelFormat hw_pix_fmt;
+static FILE *output_file = NULL;
+
+static enum AVPixelFormat find_fmt_by_hw_type(const enum AVHWDeviceType type)
+{
+    enum AVPixelFormat fmt;
+
+    switch (type) {
+    case AV_HWDEVICE_TYPE_VAAPI:
+        fmt = AV_PIX_FMT_VAAPI;
+        break;
+    case AV_HWDEVICE_TYPE_DXVA2:
+        fmt = AV_PIX_FMT_DXVA2_VLD;
+        break;
+    case AV_HWDEVICE_TYPE_D3D11VA:
+        fmt = AV_PIX_FMT_D3D11;
+        break;
+    case AV_HWDEVICE_TYPE_VDPAU:
+        fmt = AV_PIX_FMT_VDPAU;
+        break;
+    case AV_HWDEVICE_TYPE_VIDEOTOOLBOX:
+        fmt = AV_PIX_FMT_VIDEOTOOLBOX;
+        break;
+    default:
+        fmt = AV_PIX_FMT_NONE;
+        break;
+    }
+
+    return fmt;
+}
+
+static int hw_decoder_init(AVCodecContext *ctx, const enum AVHWDeviceType type)
+{
+    int err = 0;
+
+    if ((err = av_hwdevice_ctx_create(&hw_device_ctx, type,
+                                      NULL, NULL, 0)) < 0) {
+        fprintf(stderr, "Failed to create specified HW device.\n");
+        return err;
+    }
+    ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
+
+    return err;
+}
+
+static enum AVPixelFormat get_hw_format(AVCodecContext *ctx,
+                                        const enum AVPixelFormat *pix_fmts)
+{
+    const enum AVPixelFormat *p;
+
+    for (p = pix_fmts; *p != -1; p++) {
+        if (*p == hw_pix_fmt)
+            return *p;
+    }
+
+    fprintf(stderr, "Failed to get HW surface format.\n");
+    return AV_PIX_FMT_NONE;
+}
+
+static int decode_write(AVCodecContext *avctx, AVPacket *packet)
+{
+    AVFrame *frame = NULL, *sw_frame = NULL;
+    AVFrame *tmp_frame = NULL;
+    uint8_t *buffer = NULL;
+    int size;
+    int ret = 0;
+
+    ret = avcodec_send_packet(avctx, packet);
+    if (ret < 0) {
+        fprintf(stderr, "Error during decoding\n");
+        return ret;
+    }
+
+    while (ret >= 0) {
+        if (!(frame = av_frame_alloc()) || !(sw_frame = av_frame_alloc())) {
+            fprintf(stderr, "Can not alloc frame\n");
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+
+        ret = avcodec_receive_frame(avctx, frame);
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
+            av_frame_free(&frame);
+            av_frame_free(&sw_frame);
+            return 0;
+        } else if (ret < 0) {
+            fprintf(stderr, "Error while decoding\n");
+            goto fail;
+        }
+
+        if (frame->format == hw_pix_fmt) {
+            /* retrieve data from GPU to CPU */
+            if ((ret = av_hwframe_transfer_data(sw_frame, frame, 0)) < 0) {
+                fprintf(stderr, "Error transferring the data to system memory\n");
+                goto fail;
+            }
+            tmp_frame = sw_frame;
+        } else
+            tmp_frame = frame;
+
+        size = av_image_get_buffer_size(tmp_frame->format, tmp_frame->width,
+                                        tmp_frame->height, 1);
+        buffer = av_malloc(size);
+        if (!buffer) {
+            fprintf(stderr, "Can not alloc buffer\n");
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+        ret = av_image_copy_to_buffer(buffer, size,
+                                      (const uint8_t * const *)tmp_frame->data,
+                                      (const int *)tmp_frame->linesize, tmp_frame->format,
+                                      tmp_frame->width, tmp_frame->height, 1);
+        if (ret < 0) {
+            fprintf(stderr, "Can not copy image to buffer\n");
+            goto fail;
+        }
+
+        if ((ret = fwrite(buffer, 1, size, output_file)) < 0) {
+            fprintf(stderr, "Failed to dump raw data.\n");
+            goto fail;
+        }
+
+    fail:
+        av_frame_free(&frame);
+        av_frame_free(&sw_frame);
+        if (buffer)
+            av_freep(&buffer);
+        if (ret < 0)
+            return ret;
+    }
+
+    return 0;
+}
+
+int main(int argc, char *argv[])
+{
+    AVFormatContext *input_ctx = NULL;
+    int video_stream, ret;
+    AVStream *video = NULL;
+    AVCodecContext *decoder_ctx = NULL;
+    AVCodec *decoder = NULL;
+    AVPacket packet;
+    enum AVHWDeviceType type;
+
+    if (argc < 4) {
+        fprintf(stderr, "Usage: %s <vaapi|vdpau|dxva2|d3d11va> <input file> <output file>\n", argv[0]);
+        return -1;
+    }
+
+    av_register_all();
+
+    type = av_hwdevice_find_type_by_name(argv[1]);
+    hw_pix_fmt = find_fmt_by_hw_type(type);
+    if (hw_pix_fmt == -1) {
+        fprintf(stderr, "Cannot support '%s' in this example.\n", argv[1]);
+        return -1;
+    }
+
+    /* open the input file */
+    if (avformat_open_input(&input_ctx, argv[2], NULL, NULL) != 0) {
+        fprintf(stderr, "Cannot open input file '%s'\n", argv[2]);
+        return -1;
+    }
+
+    if (avformat_find_stream_info(input_ctx, NULL) < 0) {
+        fprintf(stderr, "Cannot find input stream information.\n");
+        return -1;
+    }
+
+    /* find the video stream information */
+    ret = av_find_best_stream(input_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
+    if (ret < 0) {
+        fprintf(stderr, "Cannot find a video stream in the input file\n");
+        return -1;
+    }
+    video_stream = ret;
+
+    if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
+        return AVERROR(ENOMEM);
+
+    video = input_ctx->streams[video_stream];
+    if (avcodec_parameters_to_context(decoder_ctx, video->codecpar) < 0)
+        return -1;
+
+    decoder_ctx->get_format  = get_hw_format;
+    av_opt_set_int(decoder_ctx, "refcounted_frames", 1, 0);
+
+    if (hw_decoder_init(decoder_ctx, type) < 0)
+        return -1;
+
+    if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0) {
+        fprintf(stderr, "Failed to open codec for stream #%u\n", video_stream);
+        return -1;
+    }
+
+    /* open the file to dump raw data */
+    output_file = fopen(argv[3], "w+");
+
+    /* actual decoding and dump the raw data */
+    while (ret >= 0) {
+        if ((ret = av_read_frame(input_ctx, &packet)) < 0)
+            break;
+
+        if (video_stream == packet.stream_index)
+            ret = decode_write(decoder_ctx, &packet);
+
+        av_packet_unref(&packet);
+    }
+
+    /* flush the decoder */
+    packet.data = NULL;
+    packet.size = 0;
+    ret = decode_write(decoder_ctx, &packet);
+    av_packet_unref(&packet);
+
+    if (output_file)
+        fclose(output_file);
+    avcodec_free_context(&decoder_ctx);
+    avformat_close_input(&input_ctx);
+    av_buffer_unref(&hw_device_ctx);
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/doc/examples/muxing.c b/mythtv/external/FFmpeg/doc/examples/muxing.c
index f1f5bb8239b..e1a4770eb12 100644
--- a/mythtv/external/FFmpeg/doc/examples/muxing.c
+++ b/mythtv/external/FFmpeg/doc/examples/muxing.c
@@ -335,15 +335,15 @@ static int write_audio_frame(AVFormatContext *oc, OutputStream *ost)
         if (ret < 0)
             exit(1);
 
-            /* convert to destination format */
-            ret = swr_convert(ost->swr_ctx,
-                              ost->frame->data, dst_nb_samples,
-                              (const uint8_t **)frame->data, frame->nb_samples);
-            if (ret < 0) {
-                fprintf(stderr, "Error while converting\n");
-                exit(1);
-            }
-            frame = ost->frame;
+        /* convert to destination format */
+        ret = swr_convert(ost->swr_ctx,
+                          ost->frame->data, dst_nb_samples,
+                          (const uint8_t **)frame->data, frame->nb_samples);
+        if (ret < 0) {
+            fprintf(stderr, "Error while converting\n");
+            exit(1);
+        }
+        frame = ost->frame;
 
         frame->pts = av_rescale_q(ost->samples_count, (AVRational){1, c->sample_rate}, c->time_base);
         ost->samples_count += dst_nb_samples;
@@ -440,15 +440,7 @@ static void open_video(AVFormatContext *oc, AVCodec *codec, OutputStream *ost, A
 static void fill_yuv_image(AVFrame *pict, int frame_index,
                            int width, int height)
 {
-    int x, y, i, ret;
-
-    /* when we pass a frame to the encoder, it may keep a reference to it
-     * internally;
-     * make sure we do not overwrite it here
-     */
-    ret = av_frame_make_writable(pict);
-    if (ret < 0)
-        exit(1);
+    int x, y, i;
 
     i = frame_index;
 
@@ -475,6 +467,11 @@ static AVFrame *get_video_frame(OutputStream *ost)
                       STREAM_DURATION, (AVRational){ 1, 1 }) >= 0)
         return NULL;
 
+    /* when we pass a frame to the encoder, it may keep a reference to it
+     * internally; make sure we do not overwrite it here */
+    if (av_frame_make_writable(ost->frame) < 0)
+        exit(1);
+
     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
         /* as we only generate a YUV420P picture, we must convert it
          * to the codec pixel format if needed */
diff --git a/mythtv/external/FFmpeg/doc/examples/qsvdec.c b/mythtv/external/FFmpeg/doc/examples/qsvdec.c
index aaecd81d4ca..46e6ddcb0dc 100644
--- a/mythtv/external/FFmpeg/doc/examples/qsvdec.c
+++ b/mythtv/external/FFmpeg/doc/examples/qsvdec.c
@@ -26,185 +26,55 @@
  *
  * @example qsvdec.c
  * This example shows how to do QSV-accelerated H.264 decoding with output
- * frames in the VA-API video surfaces.
+ * frames in the GPU video surfaces.
  */
 
 #include "config.h"
 
 #include <stdio.h>
 
-#include <mfx/mfxvideo.h>
-
-#include <va/va.h>
-#include <va/va_x11.h>
-#include <X11/Xlib.h>
-
 #include "libavformat/avformat.h"
 #include "libavformat/avio.h"
 
 #include "libavcodec/avcodec.h"
-#include "libavcodec/qsv.h"
 
+#include "libavutil/buffer.h"
 #include "libavutil/error.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_qsv.h"
 #include "libavutil/mem.h"
 
 typedef struct DecodeContext {
-    mfxSession mfx_session;
-    VADisplay va_dpy;
-
-    VASurfaceID *surfaces;
-    mfxMemId    *surface_ids;
-    int         *surface_used;
-    int       nb_surfaces;
-
-    mfxFrameInfo frame_info;
+    AVBufferRef *hw_device_ref;
 } DecodeContext;
 
-static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
-                             mfxFrameAllocResponse *resp)
-{
-    DecodeContext *decode = pthis;
-    int err, i;
-
-    if (decode->surfaces) {
-        fprintf(stderr, "Multiple allocation requests.\n");
-        return MFX_ERR_MEMORY_ALLOC;
-    }
-    if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET)) {
-        fprintf(stderr, "Unsupported surface type: %d\n", req->Type);
-        return MFX_ERR_UNSUPPORTED;
-    }
-    if (req->Info.BitDepthLuma != 8 || req->Info.BitDepthChroma != 8 ||
-        req->Info.Shift || req->Info.FourCC != MFX_FOURCC_NV12 ||
-        req->Info.ChromaFormat != MFX_CHROMAFORMAT_YUV420) {
-        fprintf(stderr, "Unsupported surface properties.\n");
-        return MFX_ERR_UNSUPPORTED;
-    }
-
-    decode->surfaces     = av_malloc_array (req->NumFrameSuggested, sizeof(*decode->surfaces));
-    decode->surface_ids  = av_malloc_array (req->NumFrameSuggested, sizeof(*decode->surface_ids));
-    decode->surface_used = av_mallocz_array(req->NumFrameSuggested, sizeof(*decode->surface_used));
-    if (!decode->surfaces || !decode->surface_ids || !decode->surface_used)
-        goto fail;
-
-    err = vaCreateSurfaces(decode->va_dpy, VA_RT_FORMAT_YUV420,
-                           req->Info.Width, req->Info.Height,
-                           decode->surfaces, req->NumFrameSuggested,
-                           NULL, 0);
-    if (err != VA_STATUS_SUCCESS) {
-        fprintf(stderr, "Error allocating VA surfaces\n");
-        goto fail;
-    }
-    decode->nb_surfaces = req->NumFrameSuggested;
-
-    for (i = 0; i < decode->nb_surfaces; i++)
-        decode->surface_ids[i] = &decode->surfaces[i];
-
-    resp->mids           = decode->surface_ids;
-    resp->NumFrameActual = decode->nb_surfaces;
-
-    decode->frame_info = req->Info;
-
-    return MFX_ERR_NONE;
-fail:
-    av_freep(&decode->surfaces);
-    av_freep(&decode->surface_ids);
-    av_freep(&decode->surface_used);
-
-    return MFX_ERR_MEMORY_ALLOC;
-}
-
-static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
-{
-    return MFX_ERR_NONE;
-}
-
-static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
-{
-    return MFX_ERR_UNSUPPORTED;
-}
-
-static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
-{
-    return MFX_ERR_UNSUPPORTED;
-}
-
-static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
-{
-    *hdl = mid;
-    return MFX_ERR_NONE;
-}
-
-static void free_surfaces(DecodeContext *decode)
-{
-    if (decode->surfaces)
-        vaDestroySurfaces(decode->va_dpy, decode->surfaces, decode->nb_surfaces);
-    av_freep(&decode->surfaces);
-    av_freep(&decode->surface_ids);
-    av_freep(&decode->surface_used);
-    decode->nb_surfaces = 0;
-}
-
-static void free_buffer(void *opaque, uint8_t *data)
-{
-    int *used = opaque;
-    *used = 0;
-    av_freep(&data);
-}
-
-static int get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
-{
-    DecodeContext *decode = avctx->opaque;
-
-    mfxFrameSurface1 *surf;
-    AVBufferRef *surf_buf;
-    int idx;
-
-    for (idx = 0; idx < decode->nb_surfaces; idx++) {
-        if (!decode->surface_used[idx])
-            break;
-    }
-    if (idx == decode->nb_surfaces) {
-        fprintf(stderr, "No free surfaces\n");
-        return AVERROR(ENOMEM);
-    }
-
-    surf = av_mallocz(sizeof(*surf));
-    if (!surf)
-        return AVERROR(ENOMEM);
-    surf_buf = av_buffer_create((uint8_t*)surf, sizeof(*surf), free_buffer,
-                                &decode->surface_used[idx], AV_BUFFER_FLAG_READONLY);
-    if (!surf_buf) {
-        av_freep(&surf);
-        return AVERROR(ENOMEM);
-    }
-
-    surf->Info       = decode->frame_info;
-    surf->Data.MemId = &decode->surfaces[idx];
-
-    frame->buf[0]  = surf_buf;
-    frame->data[3] = (uint8_t*)surf;
-
-    decode->surface_used[idx] = 1;
-
-    return 0;
-}
-
 static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
 {
     while (*pix_fmts != AV_PIX_FMT_NONE) {
         if (*pix_fmts == AV_PIX_FMT_QSV) {
-            if (!avctx->hwaccel_context) {
-                DecodeContext *decode = avctx->opaque;
-                AVQSVContext *qsv = av_qsv_alloc_context();
-                if (!qsv)
-                    return AV_PIX_FMT_NONE;
-
-                qsv->session   = decode->mfx_session;
-                qsv->iopattern = MFX_IOPATTERN_OUT_VIDEO_MEMORY;
-
-                avctx->hwaccel_context = qsv;
-            }
+            DecodeContext *decode = avctx->opaque;
+            AVHWFramesContext  *frames_ctx;
+            AVQSVFramesContext *frames_hwctx;
+            int ret;
+
+            /* create a pool of surfaces to be used by the decoder */
+            avctx->hw_frames_ctx = av_hwframe_ctx_alloc(decode->hw_device_ref);
+            if (!avctx->hw_frames_ctx)
+                return AV_PIX_FMT_NONE;
+            frames_ctx   = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+            frames_hwctx = frames_ctx->hwctx;
+
+            frames_ctx->format            = AV_PIX_FMT_QSV;
+            frames_ctx->sw_format         = avctx->sw_pix_fmt;
+            frames_ctx->width             = FFALIGN(avctx->coded_width,  32);
+            frames_ctx->height            = FFALIGN(avctx->coded_height, 32);
+            frames_ctx->initial_pool_size = 32;
+
+            frames_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
+
+            ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
+            if (ret < 0)
+                return AV_PIX_FMT_NONE;
 
             return AV_PIX_FMT_QSV;
         }
@@ -218,86 +88,47 @@ static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
 }
 
 static int decode_packet(DecodeContext *decode, AVCodecContext *decoder_ctx,
-                         AVFrame *frame, AVPacket *pkt,
-                         AVIOContext *output_ctx)
+                         AVFrame *frame, AVFrame *sw_frame,
+                         AVPacket *pkt, AVIOContext *output_ctx)
 {
     int ret = 0;
-    int got_frame = 1;
 
-    while (pkt->size > 0 || (!pkt->data && got_frame)) {
-        ret = avcodec_decode_video2(decoder_ctx, frame, &got_frame, pkt);
-        if (ret < 0) {
+    ret = avcodec_send_packet(decoder_ctx, pkt);
+    if (ret < 0) {
+        fprintf(stderr, "Error during decoding\n");
+        return ret;
+    }
+
+    while (ret >= 0) {
+        int i, j;
+
+        ret = avcodec_receive_frame(decoder_ctx, frame);
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+            break;
+        else if (ret < 0) {
             fprintf(stderr, "Error during decoding\n");
             return ret;
         }
 
-        pkt->data += ret;
-        pkt->size -= ret;
-
         /* A real program would do something useful with the decoded frame here.
          * We just retrieve the raw data and write it to a file, which is rather
          * useless but pedagogic. */
-        if (got_frame) {
-            mfxFrameSurface1 *surf = (mfxFrameSurface1*)frame->data[3];
-            VASurfaceID    surface = *(VASurfaceID*)surf->Data.MemId;
-
-            VAImageFormat img_fmt = {
-                .fourcc         = VA_FOURCC_NV12,
-                .byte_order     = VA_LSB_FIRST,
-                .bits_per_pixel = 8,
-                .depth          = 8,
-            };
-
-            VAImage img;
-
-            VAStatus err;
-            uint8_t *data;
-            int i, j;
-
-            img.buf      = VA_INVALID_ID;
-            img.image_id = VA_INVALID_ID;
-
-            err = vaCreateImage(decode->va_dpy, &img_fmt,
-                                frame->width, frame->height, &img);
-            if (err != VA_STATUS_SUCCESS) {
-                fprintf(stderr, "Error creating an image: %s\n",
-                        vaErrorStr(err));
-                ret = AVERROR_UNKNOWN;
-                goto fail;
-            }
-
-            err = vaGetImage(decode->va_dpy, surface, 0, 0,
-                             frame->width, frame->height,
-                             img.image_id);
-            if (err != VA_STATUS_SUCCESS) {
-                fprintf(stderr, "Error getting an image: %s\n",
-                        vaErrorStr(err));
-                ret = AVERROR_UNKNOWN;
-                goto fail;
-            }
-
-            err = vaMapBuffer(decode->va_dpy, img.buf, (void**)&data);
-            if (err != VA_STATUS_SUCCESS) {
-                fprintf(stderr, "Error mapping the image buffer: %s\n",
-                        vaErrorStr(err));
-                ret = AVERROR_UNKNOWN;
-                goto fail;
-            }
-
-            for (i = 0; i < img.num_planes; i++)
-                for (j = 0; j < (img.height >> (i > 0)); j++)
-                    avio_write(output_ctx, data + img.offsets[i] + j * img.pitches[i], img.width);
+        ret = av_hwframe_transfer_data(sw_frame, frame, 0);
+        if (ret < 0) {
+            fprintf(stderr, "Error transferring the data to system memory\n");
+            goto fail;
+        }
+
+        for (i = 0; i < FF_ARRAY_ELEMS(sw_frame->data) && sw_frame->data[i]; i++)
+            for (j = 0; j < (sw_frame->height >> (i > 0)); j++)
+                avio_write(output_ctx, sw_frame->data[i] + j * sw_frame->linesize[i], sw_frame->width);
 
 fail:
-            if (img.buf != VA_INVALID_ID)
-                vaUnmapBuffer(decode->va_dpy, img.buf);
-            if (img.image_id != VA_INVALID_ID)
-                vaDestroyImage(decode->va_dpy, img.image_id);
-            av_frame_unref(frame);
+        av_frame_unref(sw_frame);
+        av_frame_unref(frame);
 
-            if (ret < 0)
-                return ret;
-        }
+        if (ret < 0)
+            return ret;
     }
 
     return 0;
@@ -311,28 +142,13 @@ int main(int argc, char **argv)
     const AVCodec *decoder;
 
     AVPacket pkt = { 0 };
-    AVFrame *frame = NULL;
+    AVFrame *frame = NULL, *sw_frame = NULL;
 
     DecodeContext decode = { NULL };
 
-    Display *dpy = NULL;
-    int va_ver_major, va_ver_minor;
-
-    mfxIMPL mfx_impl = MFX_IMPL_AUTO_ANY;
-    mfxVersion mfx_ver = { { 1, 1 } };
-
-    mfxFrameAllocator frame_allocator = {
-        .pthis = &decode,
-        .Alloc = frame_alloc,
-        .Lock  = frame_lock,
-        .Unlock = frame_unlock,
-        .GetHDL = frame_get_hdl,
-        .Free   = frame_free,
-    };
-
     AVIOContext *output_ctx = NULL;
 
-    int ret, i, err;
+    int ret, i;
 
     av_register_all();
 
@@ -362,35 +178,14 @@ int main(int argc, char **argv)
         goto finish;
     }
 
-    /* initialize VA-API */
-    dpy = XOpenDisplay(NULL);
-    if (!dpy) {
-        fprintf(stderr, "Cannot open the X display\n");
-        goto finish;
-    }
-    decode.va_dpy = vaGetDisplay(dpy);
-    if (!decode.va_dpy) {
-        fprintf(stderr, "Cannot open the VA display\n");
-        goto finish;
-    }
-
-    err = vaInitialize(decode.va_dpy, &va_ver_major, &va_ver_minor);
-    if (err != VA_STATUS_SUCCESS) {
-        fprintf(stderr, "Cannot initialize VA: %s\n", vaErrorStr(err));
-        goto finish;
-    }
-    fprintf(stderr, "Initialized VA v%d.%d\n", va_ver_major, va_ver_minor);
-
-    /* initialize an MFX session */
-    err = MFXInit(mfx_impl, &mfx_ver, &decode.mfx_session);
-    if (err != MFX_ERR_NONE) {
-        fprintf(stderr, "Error initializing an MFX session\n");
+    /* open the hardware device */
+    ret = av_hwdevice_ctx_create(&decode.hw_device_ref, AV_HWDEVICE_TYPE_QSV,
+                                 "auto", NULL, 0);
+    if (ret < 0) {
+        fprintf(stderr, "Cannot open the hardware device\n");
         goto finish;
     }
 
-    MFXVideoCORE_SetHandle(decode.mfx_session, MFX_HANDLE_VA_DISPLAY, decode.va_dpy);
-    MFXVideoCORE_SetFrameAllocator(decode.mfx_session, &frame_allocator);
-
     /* initialize the decoder */
     decoder = avcodec_find_decoder_by_name("h264_qsv");
     if (!decoder) {
@@ -418,7 +213,6 @@ int main(int argc, char **argv)
     decoder_ctx->refcounted_frames = 1;
 
     decoder_ctx->opaque      = &decode;
-    decoder_ctx->get_buffer2 = get_buffer;
     decoder_ctx->get_format  = get_format;
 
     ret = avcodec_open2(decoder_ctx, NULL, NULL);
@@ -434,8 +228,9 @@ int main(int argc, char **argv)
         goto finish;
     }
 
-    frame = av_frame_alloc();
-    if (!frame) {
+    frame    = av_frame_alloc();
+    sw_frame = av_frame_alloc();
+    if (!frame || !sw_frame) {
         ret = AVERROR(ENOMEM);
         goto finish;
     }
@@ -447,7 +242,7 @@ int main(int argc, char **argv)
             break;
 
         if (pkt.stream_index == video_st->index)
-            ret = decode_packet(&decode, decoder_ctx, frame, &pkt, output_ctx);
+            ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
 
         av_packet_unref(&pkt);
     }
@@ -455,7 +250,7 @@ int main(int argc, char **argv)
     /* flush the decoder */
     pkt.data = NULL;
     pkt.size = 0;
-    ret = decode_packet(&decode, decoder_ctx, frame, &pkt, output_ctx);
+    ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
 
 finish:
     if (ret < 0) {
@@ -467,19 +262,11 @@ int main(int argc, char **argv)
     avformat_close_input(&input_ctx);
 
     av_frame_free(&frame);
+    av_frame_free(&sw_frame);
 
-    if (decoder_ctx)
-        av_freep(&decoder_ctx->hwaccel_context);
     avcodec_free_context(&decoder_ctx);
 
-    free_surfaces(&decode);
-
-    if (decode.mfx_session)
-        MFXClose(decode.mfx_session);
-    if (decode.va_dpy)
-        vaTerminate(decode.va_dpy);
-    if (dpy)
-        XCloseDisplay(dpy);
+    av_buffer_unref(&decode.hw_device_ref);
 
     avio_close(output_ctx);
 
diff --git a/mythtv/external/FFmpeg/doc/examples/remuxing.c b/mythtv/external/FFmpeg/doc/examples/remuxing.c
index 65437d9abd5..59594181a70 100644
--- a/mythtv/external/FFmpeg/doc/examples/remuxing.c
+++ b/mythtv/external/FFmpeg/doc/examples/remuxing.c
@@ -50,6 +50,9 @@ int main(int argc, char **argv)
     AVPacket pkt;
     const char *in_filename, *out_filename;
     int ret, i;
+    int stream_index = 0;
+    int *stream_mapping = NULL;
+    int stream_mapping_size = 0;
 
     if (argc < 3) {
         printf("usage: %s input output\n"
@@ -83,25 +86,42 @@ int main(int argc, char **argv)
         goto end;
     }
 
+    stream_mapping_size = ifmt_ctx->nb_streams;
+    stream_mapping = av_mallocz_array(stream_mapping_size, sizeof(*stream_mapping));
+    if (!stream_mapping) {
+        ret = AVERROR(ENOMEM);
+        goto end;
+    }
+
     ofmt = ofmt_ctx->oformat;
 
     for (i = 0; i < ifmt_ctx->nb_streams; i++) {
+        AVStream *out_stream;
         AVStream *in_stream = ifmt_ctx->streams[i];
-        AVStream *out_stream = avformat_new_stream(ofmt_ctx, in_stream->codec->codec);
+        AVCodecParameters *in_codecpar = in_stream->codecpar;
+
+        if (in_codecpar->codec_type != AVMEDIA_TYPE_AUDIO &&
+            in_codecpar->codec_type != AVMEDIA_TYPE_VIDEO &&
+            in_codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
+            stream_mapping[i] = -1;
+            continue;
+        }
+
+        stream_mapping[i] = stream_index++;
+
+        out_stream = avformat_new_stream(ofmt_ctx, NULL);
         if (!out_stream) {
             fprintf(stderr, "Failed allocating output stream\n");
             ret = AVERROR_UNKNOWN;
             goto end;
         }
 
-        ret = avcodec_copy_context(out_stream->codec, in_stream->codec);
+        ret = avcodec_parameters_copy(out_stream->codecpar, in_codecpar);
         if (ret < 0) {
-            fprintf(stderr, "Failed to copy context from input to output stream codec context\n");
+            fprintf(stderr, "Failed to copy codec parameters\n");
             goto end;
         }
-        out_stream->codec->codec_tag = 0;
-        if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
-            out_stream->codec->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
+        out_stream->codecpar->codec_tag = 0;
     }
     av_dump_format(ofmt_ctx, 0, out_filename, 1);
 
@@ -127,8 +147,14 @@ int main(int argc, char **argv)
             break;
 
         in_stream  = ifmt_ctx->streams[pkt.stream_index];
-        out_stream = ofmt_ctx->streams[pkt.stream_index];
+        if (pkt.stream_index >= stream_mapping_size ||
+            stream_mapping[pkt.stream_index] < 0) {
+            av_packet_unref(&pkt);
+            continue;
+        }
 
+        pkt.stream_index = stream_mapping[pkt.stream_index];
+        out_stream = ofmt_ctx->streams[pkt.stream_index];
         log_packet(ifmt_ctx, &pkt, "in");
 
         /* copy packet */
@@ -156,6 +182,8 @@ int main(int argc, char **argv)
         avio_closep(&ofmt_ctx->pb);
     avformat_free_context(ofmt_ctx);
 
+    av_freep(&stream_mapping);
+
     if (ret < 0 && ret != AVERROR_EOF) {
         fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));
         return 1;
diff --git a/mythtv/external/FFmpeg/doc/examples/transcode_aac.c b/mythtv/external/FFmpeg/doc/examples/transcode_aac.c
index 9b3ee676953..6c2f4fb4756 100644
--- a/mythtv/external/FFmpeg/doc/examples/transcode_aac.c
+++ b/mythtv/external/FFmpeg/doc/examples/transcode_aac.c
@@ -45,18 +45,6 @@
 /** The number of output channels */
 #define OUTPUT_CHANNELS 2
 
-/**
- * Convert an error code into a text message.
- * @param error Error code to be converted
- * @return Corresponding error text (not thread-safe)
- */
-static const char *get_error_text(const int error)
-{
-    static char error_buffer[255];
-    av_strerror(error, error_buffer, sizeof(error_buffer));
-    return error_buffer;
-}
-
 /** Open an input file and the required decoder. */
 static int open_input_file(const char *filename,
                            AVFormatContext **input_format_context,
@@ -70,7 +58,7 @@ static int open_input_file(const char *filename,
     if ((error = avformat_open_input(input_format_context, filename, NULL,
                                      NULL)) < 0) {
         fprintf(stderr, "Could not open input file '%s' (error '%s')\n",
-                filename, get_error_text(error));
+                filename, av_err2str(error));
         *input_format_context = NULL;
         return error;
     }
@@ -78,7 +66,7 @@ static int open_input_file(const char *filename,
     /** Get information on the input file (number of streams etc.). */
     if ((error = avformat_find_stream_info(*input_format_context, NULL)) < 0) {
         fprintf(stderr, "Could not open find stream info (error '%s')\n",
-                get_error_text(error));
+                av_err2str(error));
         avformat_close_input(input_format_context);
         return error;
     }
@@ -117,7 +105,7 @@ static int open_input_file(const char *filename,
     /** Open the decoder for the audio stream to use it later. */
     if ((error = avcodec_open2(avctx, input_codec, NULL)) < 0) {
         fprintf(stderr, "Could not open input codec (error '%s')\n",
-                get_error_text(error));
+                av_err2str(error));
         avcodec_free_context(&avctx);
         avformat_close_input(input_format_context);
         return error;
@@ -149,7 +137,7 @@ static int open_output_file(const char *filename,
     if ((error = avio_open(&output_io_context, filename,
                            AVIO_FLAG_WRITE)) < 0) {
         fprintf(stderr, "Could not open output file '%s' (error '%s')\n",
-                filename, get_error_text(error));
+                filename, av_err2str(error));
         return error;
     }
 
@@ -219,7 +207,7 @@ static int open_output_file(const char *filename,
     /** Open the encoder for the audio stream to use it later. */
     if ((error = avcodec_open2(avctx, output_codec, NULL)) < 0) {
         fprintf(stderr, "Could not open output codec (error '%s')\n",
-                get_error_text(error));
+                av_err2str(error));
         goto cleanup;
     }
 
@@ -325,7 +313,7 @@ static int write_output_file_header(AVFormatContext *output_format_context)
     int error;
     if ((error = avformat_write_header(output_format_context, NULL)) < 0) {
         fprintf(stderr, "Could not write output file header (error '%s')\n",
-                get_error_text(error));
+                av_err2str(error));
         return error;
     }
     return 0;
@@ -349,7 +337,7 @@ static int decode_audio_frame(AVFrame *frame,
             *finished = 1;
         else {
             fprintf(stderr, "Could not read frame (error '%s')\n",
-                    get_error_text(error));
+                    av_err2str(error));
             return error;
         }
     }
@@ -363,7 +351,7 @@ static int decode_audio_frame(AVFrame *frame,
     if ((error = avcodec_decode_audio4(input_codec_context, frame,
                                        data_present, &input_packet)) < 0) {
         fprintf(stderr, "Could not decode frame (error '%s')\n",
-                get_error_text(error));
+                av_err2str(error));
         av_packet_unref(&input_packet);
         return error;
     }
@@ -410,7 +398,7 @@ static int init_converted_samples(uint8_t ***converted_input_samples,
                                   output_codec_context->sample_fmt, 0)) < 0) {
         fprintf(stderr,
                 "Could not allocate converted input samples (error '%s')\n",
-                get_error_text(error));
+                av_err2str(error));
         av_freep(&(*converted_input_samples)[0]);
         free(*converted_input_samples);
         return error;
@@ -434,7 +422,7 @@ static int convert_samples(const uint8_t **input_data,
                              converted_data, frame_size,
                              input_data    , frame_size)) < 0) {
         fprintf(stderr, "Could not convert input samples (error '%s')\n",
-                get_error_text(error));
+                av_err2str(error));
         return error;
     }
 
@@ -566,8 +554,8 @@ static int init_output_frame(AVFrame **frame,
      * sure that the audio frame can hold as many samples as specified.
      */
     if ((error = av_frame_get_buffer(*frame, 0)) < 0) {
-        fprintf(stderr, "Could allocate output frame samples (error '%s')\n",
-                get_error_text(error));
+        fprintf(stderr, "Could not allocate output frame samples (error '%s')\n",
+                av_err2str(error));
         av_frame_free(frame);
         return error;
     }
@@ -602,7 +590,7 @@ static int encode_audio_frame(AVFrame *frame,
     if ((error = avcodec_encode_audio2(output_codec_context, &output_packet,
                                        frame, data_present)) < 0) {
         fprintf(stderr, "Could not encode frame (error '%s')\n",
-                get_error_text(error));
+                av_err2str(error));
         av_packet_unref(&output_packet);
         return error;
     }
@@ -611,7 +599,7 @@ static int encode_audio_frame(AVFrame *frame,
     if (*data_present) {
         if ((error = av_write_frame(output_format_context, &output_packet)) < 0) {
             fprintf(stderr, "Could not write frame (error '%s')\n",
-                    get_error_text(error));
+                    av_err2str(error));
             av_packet_unref(&output_packet);
             return error;
         }
@@ -671,7 +659,7 @@ static int write_output_file_trailer(AVFormatContext *output_format_context)
     int error;
     if ((error = av_write_trailer(output_format_context)) < 0) {
         fprintf(stderr, "Could not write output file trailer (error '%s')\n",
-                get_error_text(error));
+                av_err2str(error));
         return error;
     }
     return 0;
diff --git a/mythtv/external/FFmpeg/doc/examples/transcoding.c b/mythtv/external/FFmpeg/doc/examples/transcoding.c
index 8633362d46a..fb15a2148d6 100644
--- a/mythtv/external/FFmpeg/doc/examples/transcoding.c
+++ b/mythtv/external/FFmpeg/doc/examples/transcoding.c
@@ -45,6 +45,12 @@ typedef struct FilteringContext {
 } FilteringContext;
 static FilteringContext *filter_ctx;
 
+typedef struct StreamContext {
+    AVCodecContext *dec_ctx;
+    AVCodecContext *enc_ctx;
+} StreamContext;
+static StreamContext *stream_ctx;
+
 static int open_input_file(const char *filename)
 {
     int ret;
@@ -61,22 +67,42 @@ static int open_input_file(const char *filename)
         return ret;
     }
 
+    stream_ctx = av_mallocz_array(ifmt_ctx->nb_streams, sizeof(*stream_ctx));
+    if (!stream_ctx)
+        return AVERROR(ENOMEM);
+
     for (i = 0; i < ifmt_ctx->nb_streams; i++) {
-        AVStream *stream;
+        AVStream *stream = ifmt_ctx->streams[i];
+        AVCodec *dec = avcodec_find_decoder(stream->codecpar->codec_id);
         AVCodecContext *codec_ctx;
-        stream = ifmt_ctx->streams[i];
-        codec_ctx = stream->codec;
+        if (!dec) {
+            av_log(NULL, AV_LOG_ERROR, "Failed to find decoder for stream #%u\n", i);
+            return AVERROR_DECODER_NOT_FOUND;
+        }
+        codec_ctx = avcodec_alloc_context3(dec);
+        if (!codec_ctx) {
+            av_log(NULL, AV_LOG_ERROR, "Failed to allocate the decoder context for stream #%u\n", i);
+            return AVERROR(ENOMEM);
+        }
+        ret = avcodec_parameters_to_context(codec_ctx, stream->codecpar);
+        if (ret < 0) {
+            av_log(NULL, AV_LOG_ERROR, "Failed to copy decoder parameters to input decoder context "
+                   "for stream #%u\n", i);
+            return ret;
+        }
         /* Reencode video & audio and remux subtitles etc. */
         if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
                 || codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
+            if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
+                codec_ctx->framerate = av_guess_frame_rate(ifmt_ctx, stream, NULL);
             /* Open decoder */
-            ret = avcodec_open2(codec_ctx,
-                    avcodec_find_decoder(codec_ctx->codec_id), NULL);
+            ret = avcodec_open2(codec_ctx, dec, NULL);
             if (ret < 0) {
                 av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
                 return ret;
             }
         }
+        stream_ctx[i].dec_ctx = codec_ctx;
     }
 
     av_dump_format(ifmt_ctx, 0, filename, 0);
@@ -108,8 +134,7 @@ static int open_output_file(const char *filename)
         }
 
         in_stream = ifmt_ctx->streams[i];
-        dec_ctx = in_stream->codec;
-        enc_ctx = out_stream->codec;
+        dec_ctx = stream_ctx[i].dec_ctx;
 
         if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
                 || dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
@@ -119,6 +144,11 @@ static int open_output_file(const char *filename)
                 av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");
                 return AVERROR_INVALIDDATA;
             }
+            enc_ctx = avcodec_alloc_context3(encoder);
+            if (!enc_ctx) {
+                av_log(NULL, AV_LOG_FATAL, "Failed to allocate the encoder context\n");
+                return AVERROR(ENOMEM);
+            }
 
             /* In this example, we transcode to same properties (picture size,
              * sample rate etc.). These properties can be changed for output
@@ -133,7 +163,7 @@ static int open_output_file(const char *filename)
                 else
                     enc_ctx->pix_fmt = dec_ctx->pix_fmt;
                 /* video time_base can be set to whatever is handy and supported by encoder */
-                enc_ctx->time_base = dec_ctx->time_base;
+                enc_ctx->time_base = av_inv_q(dec_ctx->framerate);
             } else {
                 enc_ctx->sample_rate = dec_ctx->sample_rate;
                 enc_ctx->channel_layout = dec_ctx->channel_layout;
@@ -149,22 +179,29 @@ static int open_output_file(const char *filename)
                 av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);
                 return ret;
             }
+            ret = avcodec_parameters_from_context(out_stream->codecpar, enc_ctx);
+            if (ret < 0) {
+                av_log(NULL, AV_LOG_ERROR, "Failed to copy encoder parameters to output stream #%u\n", i);
+                return ret;
+            }
+            if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
+                enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
+
+            out_stream->time_base = enc_ctx->time_base;
+            stream_ctx[i].enc_ctx = enc_ctx;
         } else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) {
             av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);
             return AVERROR_INVALIDDATA;
         } else {
             /* if this stream must be remuxed */
-            ret = avcodec_copy_context(ofmt_ctx->streams[i]->codec,
-                    ifmt_ctx->streams[i]->codec);
+            ret = avcodec_parameters_copy(out_stream->codecpar, in_stream->codecpar);
             if (ret < 0) {
-                av_log(NULL, AV_LOG_ERROR, "Copying stream context failed\n");
+                av_log(NULL, AV_LOG_ERROR, "Copying parameters for stream #%u failed\n", i);
                 return ret;
             }
+            out_stream->time_base = in_stream->time_base;
         }
 
-        if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
-            enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
-
     }
     av_dump_format(ofmt_ctx, 0, filename, 1);
 
@@ -348,17 +385,17 @@ static int init_filters(void)
         filter_ctx[i].buffersrc_ctx  = NULL;
         filter_ctx[i].buffersink_ctx = NULL;
         filter_ctx[i].filter_graph   = NULL;
-        if (!(ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO
-                || ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))
+        if (!(ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO
+                || ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO))
             continue;
 
 
-        if (ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
+        if (ifmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
             filter_spec = "null"; /* passthrough (dummy) filter for video */
         else
             filter_spec = "anull"; /* passthrough (dummy) filter for audio */
-        ret = init_filter(&filter_ctx[i], ifmt_ctx->streams[i]->codec,
-                ofmt_ctx->streams[i]->codec, filter_spec);
+        ret = init_filter(&filter_ctx[i], stream_ctx[i].dec_ctx,
+                stream_ctx[i].enc_ctx, filter_spec);
         if (ret)
             return ret;
     }
@@ -370,7 +407,7 @@ static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, in
     int got_frame_local;
     AVPacket enc_pkt;
     int (*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) =
-        (ifmt_ctx->streams[stream_index]->codec->codec_type ==
+        (ifmt_ctx->streams[stream_index]->codecpar->codec_type ==
          AVMEDIA_TYPE_VIDEO) ? avcodec_encode_video2 : avcodec_encode_audio2;
 
     if (!got_frame)
@@ -381,7 +418,7 @@ static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, in
     enc_pkt.data = NULL;
     enc_pkt.size = 0;
     av_init_packet(&enc_pkt);
-    ret = enc_func(ofmt_ctx->streams[stream_index]->codec, &enc_pkt,
+    ret = enc_func(stream_ctx[stream_index].enc_ctx, &enc_pkt,
             filt_frame, got_frame);
     av_frame_free(&filt_frame);
     if (ret < 0)
@@ -392,7 +429,7 @@ static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, in
     /* prepare packet for muxing */
     enc_pkt.stream_index = stream_index;
     av_packet_rescale_ts(&enc_pkt,
-                         ofmt_ctx->streams[stream_index]->codec->time_base,
+                         stream_ctx[stream_index].enc_ctx->time_base,
                          ofmt_ctx->streams[stream_index]->time_base);
 
     av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");
@@ -450,7 +487,7 @@ static int flush_encoder(unsigned int stream_index)
     int ret;
     int got_frame;
 
-    if (!(ofmt_ctx->streams[stream_index]->codec->codec->capabilities &
+    if (!(stream_ctx[stream_index].enc_ctx->codec->capabilities &
                 AV_CODEC_CAP_DELAY))
         return 0;
 
@@ -496,7 +533,7 @@ int main(int argc, char **argv)
         if ((ret = av_read_frame(ifmt_ctx, &packet)) < 0)
             break;
         stream_index = packet.stream_index;
-        type = ifmt_ctx->streams[packet.stream_index]->codec->codec_type;
+        type = ifmt_ctx->streams[packet.stream_index]->codecpar->codec_type;
         av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",
                 stream_index);
 
@@ -509,10 +546,10 @@ int main(int argc, char **argv)
             }
             av_packet_rescale_ts(&packet,
                                  ifmt_ctx->streams[stream_index]->time_base,
-                                 ifmt_ctx->streams[stream_index]->codec->time_base);
+                                 stream_ctx[stream_index].dec_ctx->time_base);
             dec_func = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 :
                 avcodec_decode_audio4;
-            ret = dec_func(ifmt_ctx->streams[stream_index]->codec, frame,
+            ret = dec_func(stream_ctx[stream_index].dec_ctx, frame,
                     &got_frame, &packet);
             if (ret < 0) {
                 av_frame_free(&frame);
@@ -521,7 +558,7 @@ int main(int argc, char **argv)
             }
 
             if (got_frame) {
-                frame->pts = av_frame_get_best_effort_timestamp(frame);
+                frame->pts = frame->best_effort_timestamp;
                 ret = filter_encode_write_frame(frame, stream_index);
                 av_frame_free(&frame);
                 if (ret < 0)
@@ -566,13 +603,14 @@ int main(int argc, char **argv)
     av_packet_unref(&packet);
     av_frame_free(&frame);
     for (i = 0; i < ifmt_ctx->nb_streams; i++) {
-        avcodec_close(ifmt_ctx->streams[i]->codec);
-        if (ofmt_ctx && ofmt_ctx->nb_streams > i && ofmt_ctx->streams[i] && ofmt_ctx->streams[i]->codec)
-            avcodec_close(ofmt_ctx->streams[i]->codec);
+        avcodec_free_context(&stream_ctx[i].dec_ctx);
+        if (ofmt_ctx && ofmt_ctx->nb_streams > i && ofmt_ctx->streams[i] && stream_ctx[i].enc_ctx)
+            avcodec_free_context(&stream_ctx[i].enc_ctx);
         if (filter_ctx && filter_ctx[i].filter_graph)
             avfilter_graph_free(&filter_ctx[i].filter_graph);
     }
     av_free(filter_ctx);
+    av_free(stream_ctx);
     avformat_close_input(&ifmt_ctx);
     if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))
         avio_closep(&ofmt_ctx->pb);
diff --git a/mythtv/external/FFmpeg/doc/faq.texi b/mythtv/external/FFmpeg/doc/faq.texi
index ff35c898dc7..dcaf89c6d2c 100644
--- a/mythtv/external/FFmpeg/doc/faq.texi
+++ b/mythtv/external/FFmpeg/doc/faq.texi
@@ -385,7 +385,7 @@ mkfifo intermediate2.mpg
 ffmpeg -i input1.avi -qscale:v 1 -y intermediate1.mpg < /dev/null &
 ffmpeg -i input2.avi -qscale:v 1 -y intermediate2.mpg < /dev/null &
 cat intermediate1.mpg intermediate2.mpg |\
-ffmpeg -f mpeg -i - -c:v mpeg4 -acodec libmp3lame output.avi
+ffmpeg -f mpeg -i - -c:v mpeg4 -c:a libmp3lame output.avi
 @end example
 
 @subsection Concatenating using raw audio and video
@@ -407,13 +407,13 @@ mkfifo temp2.a
 mkfifo temp2.v
 mkfifo all.a
 mkfifo all.v
-ffmpeg -i input1.flv -vn -f u16le -acodec pcm_s16le -ac 2 -ar 44100 - > temp1.a < /dev/null &
-ffmpeg -i input2.flv -vn -f u16le -acodec pcm_s16le -ac 2 -ar 44100 - > temp2.a < /dev/null &
+ffmpeg -i input1.flv -vn -f u16le -c:a pcm_s16le -ac 2 -ar 44100 - > temp1.a < /dev/null &
+ffmpeg -i input2.flv -vn -f u16le -c:a pcm_s16le -ac 2 -ar 44100 - > temp2.a < /dev/null &
 ffmpeg -i input1.flv -an -f yuv4mpegpipe - > temp1.v < /dev/null &
 @{ ffmpeg -i input2.flv -an -f yuv4mpegpipe - < /dev/null | tail -n +2 > temp2.v ; @} &
 cat temp1.a temp2.a > all.a &
 cat temp1.v temp2.v > all.v &
-ffmpeg -f u16le -acodec pcm_s16le -ac 2 -ar 44100 -i all.a \
+ffmpeg -f u16le -c:a pcm_s16le -ac 2 -ar 44100 -i all.a \
        -f yuv4mpegpipe -i all.v \
        -y output.flv
 rm temp[12].[av] all.[av]
diff --git a/mythtv/external/FFmpeg/doc/fate.texi b/mythtv/external/FFmpeg/doc/fate.texi
index 353443a17b3..7a96c25c72a 100644
--- a/mythtv/external/FFmpeg/doc/fate.texi
+++ b/mythtv/external/FFmpeg/doc/fate.texi
@@ -197,6 +197,11 @@ through @command{ssh}.
 
 @item GEN
 Set to @samp{1} to generate the missing or mismatched references.
+
+@item HWACCEL
+Specify which hardware acceleration to use while running regression tests,
+by default @samp{none} is used.
+
 @end table
 
 @section Examples
diff --git a/mythtv/external/FFmpeg/doc/fate_config.sh.template b/mythtv/external/FFmpeg/doc/fate_config.sh.template
index 059a1f862f6..ab1bda45e4c 100644
--- a/mythtv/external/FFmpeg/doc/fate_config.sh.template
+++ b/mythtv/external/FFmpeg/doc/fate_config.sh.template
@@ -6,6 +6,7 @@ workdir=                                 # directory in which to do all the work
 #fate_recv="ssh -T fate@fate.ffmpeg.org" # command to submit report
 comment=                                 # optional description
 build_only=     # set to "yes" for a compile-only instance that skips tests
+ignore_tests=
 
 # the following are optional and map to configure options
 arch=
@@ -26,5 +27,7 @@ extra_conf=     # extra configure options not covered above
 
 #make=          # name of GNU make if not 'make'
 makeopts=       # extra options passed to 'make'
+#makeopts_fate= # extra options passed to 'make' when running tests,
+                # defaulting to makeopts above if this is not set
 #tar=           # command to create a tar archive from its arguments on stdout,
                 # defaults to 'tar c'
diff --git a/mythtv/external/FFmpeg/doc/ffmpeg.texi b/mythtv/external/FFmpeg/doc/ffmpeg.texi
index 47c8935fc6a..0405d009b96 100644
--- a/mythtv/external/FFmpeg/doc/ffmpeg.texi
+++ b/mythtv/external/FFmpeg/doc/ffmpeg.texi
@@ -12,7 +12,7 @@
 
 @chapter Synopsis
 
-ffmpeg [@var{global_options}] @{[@var{input_file_options}] -i @file{input_file}@} ... @{[@var{output_file_options}] @file{output_file}@} ...
+ffmpeg [@var{global_options}] @{[@var{input_file_options}] -i @file{input_url}@} ... @{[@var{output_file_options}] @file{output_url}@} ...
 
 @chapter Description
 @c man begin DESCRIPTION
@@ -24,10 +24,10 @@ rates and resize video on the fly with a high quality polyphase filter.
 @command{ffmpeg} reads from an arbitrary number of input "files" (which can be regular
 files, pipes, network streams, grabbing devices, etc.), specified by the
 @code{-i} option, and writes to an arbitrary number of output "files", which are
-specified by a plain output filename. Anything found on the command line which
-cannot be interpreted as an option is considered to be an output filename.
+specified by a plain output url. Anything found on the command line which
+cannot be interpreted as an option is considered to be an output url.
 
-Each input or output file can, in principle, contain any number of streams of
+Each input or output url can, in principle, contain any number of streams of
 different types (video/audio/subtitle/attachment/data). The allowed number and/or
 types of streams may be limited by the container format. Selecting which
 streams from which inputs will go into which output is either done automatically
@@ -243,8 +243,8 @@ Force input or output file format. The format is normally auto detected for inpu
 files and guessed from the file extension for output files, so this option is not
 needed in most cases.
 
-@item -i @var{filename} (@emph{input})
-input file name
+@item -i @var{url} (@emph{input})
+input file url
 
 @item -y (@emph{global})
 Overwrite output files without asking.
@@ -281,7 +281,7 @@ libx264, and the 138th audio, which will be encoded with libvorbis.
 When used as an input option (before @code{-i}), limit the @var{duration} of
 data read from the input file.
 
-When used as an output option (before an output filename), stop writing the
+When used as an output option (before an output url), stop writing the
 output after its duration reaches @var{duration}.
 
 @var{duration} must be a time duration specification,
@@ -310,7 +310,7 @@ extra segment between the seek point and @var{position} will be decoded and
 discarded. When doing stream copy or when @option{-noaccurate_seek} is used, it
 will be preserved.
 
-When used as an output option (before an output filename), decodes but discards
+When used as an output option (before an output url), decodes but discards
 input until the timestamps reach @var{position}.
 
 @var{position} must be a time duration specification,
@@ -357,6 +357,40 @@ To set the language of the first audio stream:
 ffmpeg -i INPUT -metadata:s:a:0 language=eng OUTPUT
 @end example
 
+@item -disposition[:stream_specifier] @var{value} (@emph{output,per-stream})
+Sets the disposition for a stream.
+
+This option overrides the disposition copied from the input stream. It is also
+possible to delete the disposition by setting it to 0.
+
+The following dispositions are recognized:
+@table @option
+@item default
+@item dub
+@item original
+@item comment
+@item lyrics
+@item karaoke
+@item forced
+@item hearing_impaired
+@item visual_impaired
+@item clean_effects
+@item captions
+@item descriptions
+@item metadata
+@end table
+
+For example, to make the second audio stream the default stream:
+@example
+ffmpeg -i in.mkv -disposition:a:1 default out.mkv
+@end example
+
+To make the second subtitle stream the default stream and remove the default
+disposition from the first subtitle stream:
+@example
+ffmpeg -i INPUT -disposition:s:0 0 -disposition:s:1 default OUTPUT
+@end example
+
 @item -program [title=@var{title}:][program_num=@var{program_num}:]st=@var{stream}[:st=@var{stream}...] (@emph{output})
 
 Creates a program with the specified @var{title}, @var{program_num} and adds the specified
@@ -380,7 +414,8 @@ ffmpeg -i myfile.avi -target vcd -bf 2 /tmp/vcd.mpg
 @end example
 
 @item -dframes @var{number} (@emph{output})
-Set the number of data frames to output. This is an alias for @code{-frames:d}.
+Set the number of data frames to output. This is an obsolete alias for
+@code{-frames:d}, which you should use instead.
 
 @item -frames[:@var{stream_specifier}] @var{framecount} (@emph{output,per-stream})
 Stop writing to the stream after @var{framecount} frames.
@@ -415,6 +450,11 @@ This option is similar to @option{-filter}, the only difference is that its
 argument is the name of the file from which a filtergraph description is to be
 read.
 
+@item -filter_threads @var{nb_threads} (@emph{global})
+Defines how many threads are used to process a filter pipeline. Each pipeline
+will produce a thread pool with this many threads available for parallel processing.
+The default is the number of available CPUs.
+
 @item -pre[:@var{stream_specifier}] @var{preset_name} (@emph{output,per-stream})
 Specify the preset for matching stream(s).
 
@@ -490,7 +530,8 @@ Disable automatically rotating video based on file metadata.
 
 @table @option
 @item -vframes @var{number} (@emph{output})
-Set the number of video frames to output. This is an alias for @code{-frames:v}.
+Set the number of video frames to output. This is an obsolete alias for
+@code{-frames:v}, which you should use instead.
 @item -r[:@var{stream_specifier}] @var{fps} (@emph{input/output,per-stream})
 Set frame rate (Hz value, fraction or abbreviation).
 
@@ -597,6 +638,16 @@ Calculate PSNR of compressed frames.
 Dump video coding statistics to @file{vstats_HHMMSS.log}.
 @item -vstats_file @var{file}
 Dump video coding statistics to @var{file}.
+@item -vstats_version @var{file}
+Specifies which version of the vstats format to use. Default is 2.
+
+version = 1 :
+
+@code{frame= %5d q= %2.1f PSNR= %6.2f f_size= %6d s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s}
+
+version > 1:
+
+@code{out= %2d st= %2d frame= %5d q= %2.1f PSNR= %6.2f f_size= %6d s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s}
 @item -top[:@var{stream_specifier}] @var{n} (@emph{output,per-stream})
 top=1/bottom=0/auto=-1 field first
 @item -dc @var{precision}
@@ -664,6 +715,67 @@ would be more efficient.
 When doing stream copy, copy also non-key frames found at the
 beginning.
 
+@item -init_hw_device @var{type}[=@var{name}][:@var{device}[,@var{key=value}...]]
+Initialise a new hardware device of type @var{type} called @var{name}, using the
+given device parameters.
+If no name is specified it will receive a default name of the form "@var{type}%d".
+
+The meaning of @var{device} and the following arguments depends on the
+device type:
+@table @option
+
+@item cuda
+@var{device} is the number of the CUDA device.
+
+@item dxva2
+@var{device} is the number of the Direct3D 9 display adapter.
+
+@item vaapi
+@var{device} is either an X11 display name or a DRM render node.
+If not specified, it will attempt to open the default X11 display (@emph{$DISPLAY})
+and then the first DRM render node (@emph{/dev/dri/renderD128}).
+
+@item vdpau
+@var{device} is an X11 display name.
+If not specified, it will attempt to open the default X11 display (@emph{$DISPLAY}).
+
+@item qsv
+@var{device} selects a value in @samp{MFX_IMPL_*}. Allowed values are:
+@table @option
+@item auto
+@item sw
+@item hw
+@item auto_any
+@item hw_any
+@item hw2
+@item hw3
+@item hw4
+@end table
+If not specified, @samp{auto_any} is used.
+(Note that it may be easier to achieve the desired result for QSV by creating the
+platform-appropriate subdevice (@samp{dxva2} or @samp{vaapi}) and then deriving a
+QSV device from that.)
+
+@end table
+
+@item -init_hw_device @var{type}[=@var{name}]@@@var{source}
+Initialise a new hardware device of type @var{type} called @var{name},
+deriving it from the existing device with the name @var{source}.
+
+@item -init_hw_device list
+List all hardware device types supported in this build of ffmpeg.
+
+@item -filter_hw_device @var{name}
+Pass the hardware device called @var{name} to all filters in any filter graph.
+This can be used to set the device to upload to with the @code{hwupload} filter,
+or the device to map to with the @code{hwmap} filter.  Other filters may also
+make use of this parameter when they require a hardware device.  Note that this
+is typically only required when the input is not already in hardware frames -
+when it is, filters will derive the device they require from the context of the
+frames they receive as input.
+
+This is a global setting, so all filters will receive the same device.
+
 @item -hwaccel[:@var{stream_specifier}] @var{hwaccel} (@emph{input,per-stream})
 Use hardware acceleration to decode the matching stream(s). The allowed values
 of @var{hwaccel} are:
@@ -683,6 +795,9 @@ Use VDPAU (Video Decode and Presentation API for Unix) hardware acceleration.
 @item dxva2
 Use DXVA2 (DirectX Video Acceleration) hardware acceleration.
 
+@item vaapi
+Use VAAPI (Video Acceleration API) hardware acceleration.
+
 @item qsv
 Use the Intel QuickSync Video acceleration for video transcoding.
 
@@ -706,33 +821,11 @@ useful for testing.
 @item -hwaccel_device[:@var{stream_specifier}] @var{hwaccel_device} (@emph{input,per-stream})
 Select a device to use for hardware acceleration.
 
-This option only makes sense when the @option{-hwaccel} option is also
-specified. Its exact meaning depends on the specific hardware acceleration
-method chosen.
-
-@table @option
-@item vdpau
-For VDPAU, this option specifies the X11 display/screen to use. If this option
-is not specified, the value of the @var{DISPLAY} environment variable is used
-
-@item dxva2
-For DXVA2, this option should contain the number of the display adapter to use.
-If this option is not specified, the default adapter is used.
-
-@item qsv
-For QSV, this option corresponds to the values of MFX_IMPL_* . Allowed values
-are:
-@table @option
-@item auto
-@item sw
-@item hw
-@item auto_any
-@item hw_any
-@item hw2
-@item hw3
-@item hw4
-@end table
-@end table
+This option only makes sense when the @option{-hwaccel} option is also specified.
+It can either refer to an existing device created with @option{-init_hw_device}
+by name, or it can create a new device as if
+@samp{-init_hw_device} @var{type}:@var{hwaccel_device}
+were called immediately before.
 
 @item -hwaccels
 List all hardware acceleration methods supported in this build of ffmpeg.
@@ -743,7 +836,8 @@ List all hardware acceleration methods supported in this build of ffmpeg.
 
 @table @option
 @item -aframes @var{number} (@emph{output})
-Set the number of audio frames to output. This is an alias for @code{-frames:a}.
+Set the number of audio frames to output. This is an obsolete alias for
+@code{-frames:a}, which you should use instead.
 @item -ar[:@var{stream_specifier}] @var{freq} (@emph{input/output,per-stream})
 Set the audio sampling frequency. For output streams it is set by
 default to the frequency of the corresponding input stream. For input
@@ -822,7 +916,7 @@ Set the size of the canvas used to render subtitles.
 @section Advanced options
 
 @table @option
-@item -map [-]@var{input_file_id}[:@var{stream_specifier}][,@var{sync_file_id}[:@var{stream_specifier}]] | @var{[linklabel]} (@emph{output})
+@item -map [-]@var{input_file_id}[:@var{stream_specifier}][?][,@var{sync_file_id}[:@var{stream_specifier}]] | @var{[linklabel]} (@emph{output})
 
 Designate one or more input streams as a source for the output file. Each input
 stream is identified by the input file index @var{input_file_id} and
@@ -838,6 +932,11 @@ the source for output stream 1, etc.
 A @code{-} character before the stream identifier creates a "negative" mapping.
 It disables matching streams from already created mappings.
 
+A trailing @code{?} after the stream index will allow the map to be
+optional: if the map matches no streams the map will be ignored instead
+of failing. Note the map will still fail if an invalid input file index
+is used; such as if the map refers to a non-existent input.
+
 An alternative @var{[linklabel]} form will map outputs from complex filter
 graphs (see the @option{-filter_complex} option) to the output file.
 @var{linklabel} must correspond to a defined output link label in the graph.
@@ -875,6 +974,13 @@ To map all the streams except the second audio, use negative mappings
 ffmpeg -i INPUT -map 0 -map -0:a:1 OUTPUT
 @end example
 
+To map the video and audio streams from the first input, and using the
+trailing @code{?}, ignore the audio mapping if no audio streams exist in
+the first input:
+@example
+ffmpeg -i INPUT -map 0:v -map 0:a? OUTPUT
+@end example
+
 To pick the English audio stream:
 @example
 ffmpeg -i INPUT -map 0:m:language:eng OUTPUT
@@ -890,7 +996,7 @@ such streams is attempted.
 Allow input streams with unknown type to be copied instead of failing if copying
 such streams is attempted.
 
-@item -map_channel [@var{input_file_id}.@var{stream_specifier}.@var{channel_id}|-1][:@var{output_file_id}.@var{stream_specifier}]
+@item -map_channel [@var{input_file_id}.@var{stream_specifier}.@var{channel_id}|-1][?][:@var{output_file_id}.@var{stream_specifier}]
 Map an audio channel from a given input to an output. If
 @var{output_file_id}.@var{stream_specifier} is not set, the audio channel will
 be mapped on all the audio streams.
@@ -899,6 +1005,10 @@ Using "-1" instead of
 @var{input_file_id}.@var{stream_specifier}.@var{channel_id} will map a muted
 channel.
 
+A trailing @code{?} will allow the map_channel to be
+optional: if the map_channel matches no channel the map_channel will be ignored instead
+of failing.
+
 For example, assuming @var{INPUT} is a stereo audio file, you can switch the
 two audio channels with the following command:
 @example
@@ -946,6 +1056,13 @@ video stream), you can use the following command:
 ffmpeg -i input.mkv -filter_complex "[0:1] [0:2] amerge" -c:a pcm_s16le -c:v copy output.mkv
 @end example
 
+To map the first two audio channels from the first input, and using the
+trailing @code{?}, ignore the audio channel mapping if the first input is
+mono instead of stereo:
+@example
+ffmpeg -i INPUT -map_channel 0.0.0 -map_channel 0.0.1? OUTPUT
+@end example
+
 @item -map_metadata[:@var{metadata_spec_out}] @var{infile}[:@var{metadata_spec_in}] (@emph{output,per-metadata})
 Set metadata information of the next output file from @var{infile}. Note that
 those are file indices (zero-based), not filenames.
@@ -1112,6 +1229,30 @@ Try to make the choice automatically, in order to generate a sane output.
 
 Default value is -1.
 
+@item -enc_time_base[:@var{stream_specifier}] @var{timebase} (@emph{output,per-stream})
+Set the encoder timebase. @var{timebase} is a floating point number,
+and can assume one of the following values:
+
+@table @option
+@item 0
+Assign a default value according to the media type.
+
+For video - use 1/framerate, for audio - use 1/samplerate.
+
+@item -1
+Use the input stream timebase when possible.
+
+If an input stream is not available, the default timebase will be used.
+
+@item >0
+Use the provided number as the timebase.
+
+This field can be provided as a ratio of two integers (e.g. 1:24, 1:48000)
+or as a floating point number (e.g. 0.04166, 2.0833e-5)
+@end table
+
+Default value is 0.
+
 @item -shortest (@emph{output})
 Finish encoding when the shortest input stream ends.
 @item -dts_delta_threshold
@@ -1129,7 +1270,7 @@ may be reassigned to a different value.
 For example, to set the stream 0 PID to 33 and the stream 1 PID to 36 for
 an output mpegts file:
 @example
-ffmpeg -i infile -streamid 0:33 -streamid 1:36 out.ts
+ffmpeg -i inurl -streamid 0:33 -streamid 1:36 out.ts
 @end example
 
 @item -bsf[:@var{stream_specifier}] @var{bitstream_filters} (@emph{output,per-stream})
@@ -1201,6 +1342,11 @@ To generate 5 seconds of pure red video using lavfi @code{color} source:
 ffmpeg -filter_complex 'color=c=red' -t 5 out.mkv
 @end example
 
+@item -filter_complex_threads @var{nb_threads} (@emph{global})
+Defines how many threads are used to process a filter_complex graph.
+Similar to filter_threads but used for @code{-filter_complex} graphs only.
+The default is the number of available CPUs.
+
 @item -lavfi @var{filtergraph} (@emph{global})
 Define a complex filtergraph, i.e. one with arbitrary number of inputs and/or
 outputs. Equivalent to @option{-filter_complex}.
@@ -1493,7 +1639,7 @@ to enable LAME support by passing @code{--enable-libmp3lame} to configure.
 The mapping is particularly useful for DVD transcoding
 to get the desired audio language.
 
-NOTE: To see the supported input formats, use @code{ffmpeg -formats}.
+NOTE: To see the supported input formats, use @code{ffmpeg -demuxers}.
 
 @item
 You can extract images from a video, or create a video from many images:
@@ -1508,8 +1654,8 @@ output them in files named @file{foo-001.jpeg}, @file{foo-002.jpeg},
 etc. Images will be rescaled to fit the new WxH values.
 
 If you want to extract just a limited number of frames, you can use the
-above command in combination with the -vframes or -t option, or in
-combination with -ss to start extracting from a certain point in time.
+above command in combination with the @code{-frames:v} or @code{-t} option,
+or in combination with -ss to start extracting from a certain point in time.
 
 For creating a video from many images:
 @example
diff --git a/mythtv/external/FFmpeg/doc/ffplay.texi b/mythtv/external/FFmpeg/doc/ffplay.texi
index 4bc3ced39a8..a76bed4663a 100644
--- a/mythtv/external/FFmpeg/doc/ffplay.texi
+++ b/mythtv/external/FFmpeg/doc/ffplay.texi
@@ -12,7 +12,7 @@
 
 @chapter Synopsis
 
-ffplay [@var{options}] [@file{input_file}]
+ffplay [@var{options}] [@file{input_url}]
 
 @chapter Description
 @c man begin DESCRIPTION
@@ -62,6 +62,12 @@ see @ref{time duration syntax,,the Time duration section in the ffmpeg-utils(1)
 Seek by bytes.
 @item -nodisp
 Disable graphical display.
+@item -noborder
+Borderless window.
+@item -volume
+Set the startup volume. 0 means silence, 100 means no volume reduction or
+amplification. Negative values are treated as 0, values above 100 are treated
+as 100.
 @item -f @var{fmt}
 Force format.
 @item -window_title @var{title}
@@ -106,8 +112,8 @@ the input audio.
 Use the option "-filters" to show all the available filters (including
 sources and sinks).
 
-@item -i @var{input_file}
-Read @var{input_file}.
+@item -i @var{input_url}
+Read @var{input_url}.
 @end table
 
 @section Advanced options
diff --git a/mythtv/external/FFmpeg/doc/ffprobe.texi b/mythtv/external/FFmpeg/doc/ffprobe.texi
index 1069ae32de5..e3c34babdc7 100644
--- a/mythtv/external/FFmpeg/doc/ffprobe.texi
+++ b/mythtv/external/FFmpeg/doc/ffprobe.texi
@@ -12,7 +12,7 @@
 
 @chapter Synopsis
 
-ffprobe [@var{options}] [@file{input_file}]
+ffprobe [@var{options}] [@file{input_url}]
 
 @chapter Description
 @c man begin DESCRIPTION
@@ -24,8 +24,8 @@ For example it can be used to check the format of the container used
 by a multimedia stream and the format and type of each media stream
 contained in it.
 
-If a filename is specified in input, ffprobe will try to open and
-probe the file content. If the file cannot be opened or recognized as
+If a url is specified in input, ffprobe will try to open and
+probe the url content. If the url cannot be opened or recognized as
 a multimedia file, a positive exit code is returned.
 
 ffprobe may be employed both as a standalone application or in
@@ -208,6 +208,13 @@ multimedia stream.
 The information for each single frame is printed within a dedicated
 section with name "FRAME" or "SUBTITLE".
 
+@item -show_log @var{loglevel}
+Show logging information from the decoder about each frame according to
+the value set in @var{loglevel}, (see @code{-loglevel}). This option requires @code{-show_frames}.
+
+The information for each log message is printed within a dedicated
+section with name "LOG".
+
 @item -show_streams
 Show information about each media stream contained in the input
 multimedia stream.
@@ -332,8 +339,8 @@ with name "PIXEL_FORMAT".
 Force bitexact output, useful to produce output which is not dependent
 on the specific build.
 
-@item -i @var{input_file}
-Read @var{input_file}.
+@item -i @var{input_url}
+Read @var{input_url}.
 
 @end table
 @c man end
@@ -464,7 +471,7 @@ Perform no escaping.
 @end table
 
 @item print_section, p
-Print the section name at the begin of each line if the value is
+Print the section name at the beginning of each line if the value is
 @code{1}, disable it with value set to @code{0}. Default value is
 @code{1}.
 
diff --git a/mythtv/external/FFmpeg/doc/ffprobe.xsd b/mythtv/external/FFmpeg/doc/ffprobe.xsd
index f64656adf15..3e58da0f46f 100644
--- a/mythtv/external/FFmpeg/doc/ffprobe.xsd
+++ b/mythtv/external/FFmpeg/doc/ffprobe.xsd
@@ -83,6 +83,7 @@
     <xsd:complexType name="frameType">
       <xsd:sequence>
             <xsd:element name="tag" type="ffprobe:tagType" minOccurs="0" maxOccurs="unbounded"/>
+            <xsd:element name="logs" type="ffprobe:logsType" minOccurs="0" maxOccurs="1"/>
             <xsd:element name="side_data_list" type="ffprobe:frameSideDataListType"   minOccurs="0" maxOccurs="1" />
       </xsd:sequence>
 
@@ -119,6 +120,25 @@
       <xsd:attribute name="interlaced_frame"       type="xsd:int"   />
       <xsd:attribute name="top_field_first"        type="xsd:int"   />
       <xsd:attribute name="repeat_pict"            type="xsd:int"   />
+      <xsd:attribute name="color_range"            type="xsd:string"/>
+      <xsd:attribute name="color_space"            type="xsd:string"/>
+      <xsd:attribute name="color_primaries"        type="xsd:string"/>
+      <xsd:attribute name="color_transfer"         type="xsd:string"/>
+      <xsd:attribute name="chroma_location"        type="xsd:string"/>
+    </xsd:complexType>
+
+    <xsd:complexType name="logsType">
+        <xsd:sequence>
+            <xsd:element name="log" type="ffprobe:logType" minOccurs="1" maxOccurs="unbounded"/>
+        </xsd:sequence>
+    </xsd:complexType>
+    <xsd:complexType name="logType">
+        <xsd:attribute name="context"                     type="xsd:string"/>
+        <xsd:attribute name="level"                       type="xsd:int"   />
+        <xsd:attribute name="category"                    type="xsd:int"   />
+        <xsd:attribute name="parent_context"              type="xsd:string"/>
+        <xsd:attribute name="parent_category"             type="xsd:int"   />
+        <xsd:attribute name="message"                     type="xsd:string"/>
     </xsd:complexType>
 
     <xsd:complexType name="frameSideDataListType">
diff --git a/mythtv/external/FFmpeg/doc/ffserver.texi b/mythtv/external/FFmpeg/doc/ffserver.texi
index ad48f47a8f0..b3e1f1d7ef9 100644
--- a/mythtv/external/FFmpeg/doc/ffserver.texi
+++ b/mythtv/external/FFmpeg/doc/ffserver.texi
@@ -327,7 +327,7 @@ Name of options and sections are case-insensitive.
 An ACL (Access Control List) specifies the address which are allowed
 to access a given stream, or to write a given feed.
 
-It accepts the folling forms
+It accepts the following forms
 @itemize
 @item
 Allow/deny access to @var{address}.
@@ -416,7 +416,7 @@ deprecated.
 @item NoDefaults
 Control whether default codec options are used for the all streams or not.
 Each stream may overwrite this setting for its own. Default is @var{UseDefaults}.
-The lastest occurrence overrides previous if multiple definitions.
+The last occurrence overrides the previous if multiple definitions exist.
 @end table
 
 @section Feed section
diff --git a/mythtv/external/FFmpeg/doc/fftools-common-opts.texi b/mythtv/external/FFmpeg/doc/fftools-common-opts.texi
index a8e485f43ab..2eff33a36f5 100644
--- a/mythtv/external/FFmpeg/doc/fftools-common-opts.texi
+++ b/mythtv/external/FFmpeg/doc/fftools-common-opts.texi
@@ -110,6 +110,12 @@ Show version.
 @item -formats
 Show available formats (including devices).
 
+@item -demuxers
+Show available demuxers.
+
+@item -muxers
+Show available muxers.
+
 @item -devices
 Show available devices.
 
@@ -147,7 +153,7 @@ Show channel names and standard channel layouts.
 Show recognized color names.
 
 @item -sources @var{device}[,@var{opt1}=@var{val1}[,@var{opt2}=@var{val2}]...]
-Show autodetected sources of the intput device.
+Show autodetected sources of the input device.
 Some devices may provide system-dependent source names that cannot be autodetected.
 The returned list cannot be assumed to be always complete.
 @example
diff --git a/mythtv/external/FFmpeg/doc/filter_design.txt b/mythtv/external/FFmpeg/doc/filter_design.txt
index e8a7c53ee91..885b19b6f65 100644
--- a/mythtv/external/FFmpeg/doc/filter_design.txt
+++ b/mythtv/external/FFmpeg/doc/filter_design.txt
@@ -5,7 +5,7 @@ This document explains guidelines that should be observed (or ignored with
 good reason) when writing filters for libavfilter.
 
 In this document, the word “frame” indicates either a video frame or a group
-of audio samples, as stored in an AVFilterBuffer structure.
+of audio samples, as stored in an AVFrame structure.
 
 
 Format negotiation
@@ -35,32 +35,31 @@ Format negotiation
   to set the formats supported on another.
 
 
-Buffer references ownership and permissions
-===========================================
+Frame references ownership and permissions
+==========================================
 
   Principle
   ---------
 
-    Audio and video data are voluminous; the buffer and buffer reference
+    Audio and video data are voluminous; the frame and frame reference
     mechanism is intended to avoid, as much as possible, expensive copies of
     that data while still allowing the filters to produce correct results.
 
-    The data is stored in buffers represented by AVFilterBuffer structures.
-    They must not be accessed directly, but through references stored in
-    AVFilterBufferRef structures. Several references can point to the
-    same buffer; the buffer is automatically deallocated once all
-    corresponding references have been destroyed.
+    The data is stored in buffers represented by AVFrame structures.
+    Several references can point to the same frame buffer; the buffer is
+    automatically deallocated once all corresponding references have been
+    destroyed.
 
     The characteristics of the data (resolution, sample rate, etc.) are
     stored in the reference; different references for the same buffer can
     show different characteristics. In particular, a video reference can
     point to only a part of a video buffer.
 
-    A reference is usually obtained as input to the start_frame or
-    filter_frame method or requested using the ff_get_video_buffer or
-    ff_get_audio_buffer functions. A new reference on an existing buffer can
-    be created with the avfilter_ref_buffer. A reference is destroyed using
-    the avfilter_unref_bufferp function.
+    A reference is usually obtained as input to the filter_frame method or
+    requested using the ff_get_video_buffer or ff_get_audio_buffer
+    functions. A new reference on an existing buffer can be created with
+    av_frame_ref(). A reference is destroyed using
+    the av_frame_free() function.
 
   Reference ownership
   -------------------
@@ -73,17 +72,13 @@ Buffer references ownership and permissions
 
     Here are the (fairly obvious) rules for reference ownership:
 
-    * A reference received by the filter_frame method (or its start_frame
-      deprecated version) belongs to the corresponding filter.
+    * A reference received by the filter_frame method belongs to the
+      corresponding filter.
 
-      Special exception: for video references: the reference may be used
-      internally for automatic copying and must not be destroyed before
-      end_frame; it can be given away to ff_start_frame.
+    * A reference passed to ff_filter_frame is given away and must no longer
+      be used.
 
-    * A reference passed to ff_filter_frame (or the deprecated
-      ff_start_frame) is given away and must no longer be used.
-
-    * A reference created with avfilter_ref_buffer belongs to the code that
+    * A reference created with av_frame_ref() belongs to the code that
       created it.
 
     * A reference obtained with ff_get_video_buffer or ff_get_audio_buffer
@@ -95,89 +90,32 @@ Buffer references ownership and permissions
   Link reference fields
   ---------------------
 
-    The AVFilterLink structure has a few AVFilterBufferRef fields. The
-    cur_buf and out_buf were used with the deprecated
-    start_frame/draw_slice/end_frame API and should no longer be used.
-    src_buf and partial_buf are used by libavfilter internally
-    and must not be accessed by filters.
-
-  Reference permissions
-  ---------------------
-
-    The AVFilterBufferRef structure has a perms field that describes what
-    the code that owns the reference is allowed to do to the buffer data.
-    Different references for the same buffer can have different permissions.
-
-    For video filters that implement the deprecated
-    start_frame/draw_slice/end_frame API, the permissions only apply to the
-    parts of the buffer that have already been covered by the draw_slice
-    method.
-
-    The value is a binary OR of the following constants:
-
-    * AV_PERM_READ: the owner can read the buffer data; this is essentially
-      always true and is there for self-documentation.
-
-    * AV_PERM_WRITE: the owner can modify the buffer data.
-
-    * AV_PERM_PRESERVE: the owner can rely on the fact that the buffer data
-      will not be modified by previous filters.
-
-    * AV_PERM_REUSE: the owner can output the buffer several times, without
-      modifying the data in between.
-
-    * AV_PERM_REUSE2: the owner can output the buffer several times and
-      modify the data in between (useless without the WRITE permissions).
-
-    * AV_PERM_ALIGN: the owner can access the data using fast operations
-      that require data alignment.
-
-    The READ, WRITE and PRESERVE permissions are about sharing the same
-    buffer between several filters to avoid expensive copies without them
-    doing conflicting changes on the data.
-
-    The REUSE and REUSE2 permissions are about special memory for direct
-    rendering. For example a buffer directly allocated in video memory must
-    not modified once it is displayed on screen, or it will cause tearing;
-    it will therefore not have the REUSE2 permission.
-
-    The ALIGN permission is about extracting part of the buffer, for
-    copy-less padding or cropping for example.
-
+    The AVFilterLink structure has a few AVFrame fields.
 
-    References received on input pads are guaranteed to have all the
-    permissions stated in the min_perms field and none of the permissions
-    stated in the rej_perms.
+    partial_buf is used by libavfilter internally and must not be accessed
+    by filters.
 
-    References obtained by ff_get_video_buffer and ff_get_audio_buffer are
-    guaranteed to have at least all the permissions requested as argument.
+    fifo contains frames queued in the filter's input. They belong to the
+    framework until they are taken by the filter.
 
-    References created by avfilter_ref_buffer have the same permissions as
-    the original reference minus the ones explicitly masked; the mask is
-    usually ~0 to keep the same permissions.
-
-    Filters should remove permissions on reference they give to output
-    whenever necessary. It can be automatically done by setting the
-    rej_perms field on the output pad.
-
-    Here are a few guidelines corresponding to common situations:
+  Reference permissions
+  ---------------------
 
-    * Filters that modify and forward their frame (like drawtext) need the
-      WRITE permission.
+    Since the same frame data can be shared by several frames, modifying may
+    have unintended consequences. A frame is considered writable if only one
+    reference to it exists. The code owning that reference it then allowed
+    to modify the data.
 
-    * Filters that read their input to produce a new frame on output (like
-      scale) need the READ permission on input and must request a buffer
-      with the WRITE permission.
+    A filter can check if a frame is writable by using the
+    av_frame_is_writable() function.
 
-    * Filters that intend to keep a reference after the filtering process
-      is finished (after filter_frame returns) must have the PRESERVE
-      permission on it and remove the WRITE permission if they create a new
-      reference to give it away.
+    A filter can ensure that a frame is writable at some point of the code
+    by using the ff_inlink_make_frame_writable() function. It will duplicate
+    the frame if needed.
 
-    * Filters that intend to modify a reference they have kept after the end
-      of the filtering process need the REUSE2 permission and must remove
-      the PRESERVE permission if they create a new reference to give it
-      away.
+    A filter can ensure that the frame passed to the filter_frame() callback
+    is writable by setting the needs_writable flag on the corresponding
+    input pad. It does not apply to the activate() callback.
 
 
 Frame scheduling
@@ -189,11 +127,100 @@ Frame scheduling
   Simple filters that output one frame for each input frame should not have
   to worry about it.
 
+  There are two design for filters: one using the filter_frame() and
+  request_frame() callbacks and the other using the activate() callback.
+
+  The design using filter_frame() and request_frame() is legacy, but it is
+  suitable for filters that have a single input and process one frame at a
+  time. New filters with several inputs, that treat several frames at a time
+  or that require a special treatment at EOF should probably use the design
+  using activate().
+
+  activate
+  --------
+
+    This method is called when something must be done in a filter; the
+    definition of that "something" depends on the semantic of the filter.
+
+    The callback must examine the status of the filter's links and proceed
+    accordingly.
+
+    The status of output links is stored in the frame_wanted_out, status_in
+    and status_out fields and tested by the ff_outlink_frame_wanted()
+    function. If this function returns true, then the processing requires a
+    frame on this link and the filter is expected to make efforts in that
+    direction.
+
+    The status of input links is stored by the status_in, fifo and
+    status_out fields; they must not be accessed directly. The fifo field
+    contains the frames that are queued in the input for processing by the
+    filter. The status_in and status_out fields contains the queued status
+    (EOF or error) of the link; status_in is a status change that must be
+    taken into account after all frames in fifo have been processed;
+    status_out is the status that have been taken into account, it is final
+    when it is not 0.
+
+    The typical task of an activate callback is to first check the backward
+    status of output links, and if relevant forward it to the corresponding
+    input. Then, if relevant, for each input link: test the availability of
+    frames in fifo and process them;  if no frame is available, test and
+    acknowledge a change of status using ff_inlink_acknowledge_status(); and
+    forward the result (frame or status change) to the corresponding input.
+    If nothing is possible, test the status of outputs and forward it to the
+    corresponding input(s). If still not possible, return FFERROR_NOT_READY.
+
+    If the filters stores internally one or a few frame for some input, it
+    can consider them to be part of the FIFO and delay acknowledging a
+    status change accordingly.
+
+    Example code:
+
+    ret = ff_outlink_get_status(outlink);
+    if (ret) {
+        ff_inlink_set_status(inlink, ret);
+        return 0;
+    }
+    if (priv->next_frame) {
+        /* use it */
+        return 0;
+    }
+    ret = ff_inlink_consume_frame(inlink, &frame);
+    if (ret < 0)
+        return ret;
+    if (ret) {
+        /* use it */
+        return 0;
+    }
+    ret = ff_inlink_acknowledge_status(inlink, &status, &pts);
+    if (ret) {
+        /* flush */
+        ff_outlink_set_status(outlink, status, pts);
+        return 0;
+    }
+    if (ff_outlink_frame_wanted(outlink)) {
+        ff_inlink_request_frame(inlink);
+        return 0;
+    }
+    return FFERROR_NOT_READY;
+
+    The exact code depends on how similar the /* use it */ blocks are and
+    how related they are to the /* flush */ block, and needs to apply these
+    operations to the correct inlink or outlink if there are several.
+
+    Macros are available to factor that when no extra processing is needed:
+
+    FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
+    FF_FILTER_FORWARD_STATUS_ALL(outlink, filter);
+    FF_FILTER_FORWARD_STATUS(inlink, outlink);
+    FF_FILTER_FORWARD_STATUS_ALL(inlink, filter);
+    FF_FILTER_FORWARD_WANTED(outlink, inlink);
+
   filter_frame
   ------------
 
-    This method is called when a frame is pushed to the filter's input. It
-    can be called at any time except in a reentrant way.
+    For filters that do not use the activate() callback, this method is
+    called when a frame is pushed to the filter's input. It can be called at
+    any time except in a reentrant way.
 
     If the input frame is enough to produce output, then the filter should
     push the output frames on the output link immediately.
@@ -222,9 +249,10 @@ Frame scheduling
   request_frame
   -------------
 
-    This method is called when a frame is wanted on an output.
+    For filters that do not use the activate() callback, this method is
+    called when a frame is wanted on an output.
 
-    For an input, it should directly call filter_frame on the corresponding
+    For a source, it should directly call filter_frame on the corresponding
     output.
 
     For a filter, if there are queued frames already ready, one of these
@@ -254,16 +282,7 @@ Frame scheduling
         }
         return 0;
 
-    Note that, except for filters that can have queued frames, request_frame
-    does not push frames: it requests them to its input, and as a reaction,
-    the filter_frame method possibly will be called and do the work.
-
-Legacy API
-==========
-
-  Until libavfilter 3.23, the filter_frame method was split:
-
-  - for video filters, it was made of start_frame, draw_slice (that could be
-    called several times on distinct parts of the frame) and end_frame;
-
-  - for audio filters, it was called filter_samples.
+    Note that, except for filters that can have queued frames and sources,
+    request_frame does not push frames: it requests them to its input, and
+    as a reaction, the filter_frame method possibly will be called and do
+    the work.
diff --git a/mythtv/external/FFmpeg/doc/filters.texi b/mythtv/external/FFmpeg/doc/filters.texi
index c37fa295cee..e26dde4b1a9 100644
--- a/mythtv/external/FFmpeg/doc/filters.texi
+++ b/mythtv/external/FFmpeg/doc/filters.texi
@@ -130,11 +130,11 @@ filterchains is represented by a list of ";"-separated filterchain
 descriptions.
 
 A filter is represented by a string of the form:
-[@var{in_link_1}]...[@var{in_link_N}]@var{filter_name}=@var{arguments}[@var{out_link_1}]...[@var{out_link_M}]
+[@var{in_link_1}]...[@var{in_link_N}]@var{filter_name}@@@var{id}=@var{arguments}[@var{out_link_1}]...[@var{out_link_M}]
 
 @var{filter_name} is the name of the filter class of which the
 described filter is an instance of, and has to be the name of one of
-the filter classes registered in the program.
+the filter classes registered in the program optionally followed by "@@@var{id}".
 The name of the filter class is optionally followed by a string
 "=@var{arguments}".
 
@@ -212,10 +212,11 @@ to the filtergraph description.
 Here is a BNF description of the filtergraph syntax:
 @example
 @var{NAME}             ::= sequence of alphanumeric characters and '_'
+@var{FILTER_NAME}      ::= @var{NAME}["@@"@var{NAME}]
 @var{LINKLABEL}        ::= "[" @var{NAME} "]"
 @var{LINKLABELS}       ::= @var{LINKLABEL} [@var{LINKLABELS}]
 @var{FILTER_ARGUMENTS} ::= sequence of chars (possibly quoted)
-@var{FILTER}           ::= [@var{LINKLABELS}] @var{NAME} ["=" @var{FILTER_ARGUMENTS}] [@var{LINKLABELS}]
+@var{FILTER}           ::= [@var{LINKLABELS}] @var{FILTER_NAME} ["=" @var{FILTER_ARGUMENTS}] [@var{LINKLABELS}]
 @var{FILTERCHAIN}      ::= @var{FILTER} [,@var{FILTERCHAIN}]
 @var{FILTERGRAPH}      ::= [sws_flags=@var{flags};] @var{FILTERCHAIN} [;@var{FILTERGRAPH}]
 @end example
@@ -306,8 +307,43 @@ smartblur = enable='between(t,10,3*60)',
 curves    = enable='gte(t,3)' : preset=cross_process
 @end example
 
+See @code{ffmpeg -filters} to view which filters have timeline support.
+
 @c man end FILTERGRAPH DESCRIPTION
 
+@anchor{framesync}
+@chapter Options for filters with several inputs (framesync)
+@c man begin OPTIONS FOR FILTERS WITH SEVERAL INPUTS
+
+Some filters with several inputs support a common set of options.
+These options can only be set by name, not with the short notation.
+
+@table @option
+@item eof_action
+The action to take when EOF is encountered on the secondary input; it accepts
+one of the following values:
+
+@table @option
+@item repeat
+Repeat the last frame (the default).
+@item endall
+End both streams.
+@item pass
+Pass the main input through.
+@end table
+
+@item shortest
+If set to 1, force the output to terminate when the shortest input
+terminates. Default value is 0.
+
+@item repeatlast
+If set to 1, force the filter to extend the last frame of secondary streams
+until the end of the primary stream. A value of 0 disables this behavior.
+Default value is 1.
+@end table
+
+@c man end OPTIONS FOR FILTERS WITH SEVERAL INPUTS
+
 @chapter Audio Filters
 @c man begin AUDIO FILTERS
 
@@ -354,8 +390,8 @@ The filter accepts the following options:
 Set input gain. Default is 1. Range is between 0.015625 and 64.
 
 @item threshold
-If a signal of second stream rises above this level it will affect the gain
-reduction of the first stream.
+If a signal of stream rises above this level it will affect the gain
+reduction.
 By default it is 0.125. Range is between 0.00097563 and 1.
 
 @item ratio
@@ -373,7 +409,7 @@ reduction is decreased again. Default is 250. Range is between 0.01 and 9000.
 
 @item makeup
 Set the amount by how much signal will be amplified after processing.
-Default is 2. Range is from 1 and 64.
+Default is 1. Range is from 1 to 64.
 
 @item knee
 Curve the sharp knee around the threshold to enter gain reduction more softly.
@@ -393,6 +429,11 @@ How much to use compressed signal in output. Default is 1.
 Range is between 0 and 1.
 @end table
 
+@section acopy
+
+Copy the input audio source unchanged to the output. This is mainly useful for
+testing purposes.
+
 @section acrossfade
 
 Apply cross fade from one input audio stream to another input audio stream.
@@ -510,7 +551,6 @@ The filter accepts the following option:
 @table @option
 @item delays
 Set list of delays in milliseconds for each channel separated by '|'.
-At least one delay greater than 0 should be provided.
 Unused delays will be silently ignored. If number of given delays is
 smaller than number of channels all remaining channels will not be delayed.
 If you want to delay exact number of samples, append 'S' to number.
@@ -561,7 +601,7 @@ separated by '|'. Allowed range for each @code{delay} is @code{(0 - 90000.0]}.
 Default is @code{1000}.
 
 @item decays
-Set list of loudnesses of reflected signals separated by '|'.
+Set list of loudness of reflected signals separated by '|'.
 Allowed range for each @code{decay} is @code{(0 - 1.0]}.
 Default is @code{0.5}.
 @end table
@@ -876,6 +916,49 @@ afftfilt="1-clip((b/nb)*b,0,1)"
 @end example
 @end itemize
 
+@section afir
+
+Apply an arbitrary Frequency Impulse Response filter.
+
+This filter is designed for applying long FIR filters,
+up to 30 seconds long.
+
+It can be used as component for digital crossover filters,
+room equalization, cross talk cancellation, wavefield synthesis,
+auralization, ambiophonics and ambisonics.
+
+This filter uses second stream as FIR coefficients.
+If second stream holds single channel, it will be used
+for all input channels in first stream, otherwise
+number of channels in second stream must be same as
+number of channels in first stream.
+
+It accepts the following parameters:
+
+@table @option
+@item dry
+Set dry gain. This sets input gain.
+
+@item wet
+Set wet gain. This sets final output gain.
+
+@item length
+Set Impulse Response filter length. Default is 1, which means whole IR is processed.
+
+@item again
+Enable applying gain measured from power of IR.
+@end table
+
+@subsection Examples
+
+@itemize
+@item
+Apply reverb to stream using mono IR file as second input, complete command using ffmpeg:
+@example
+ffmpeg -i input.wav -i middle_tunnel_1way_mono.wav -lavfi afir output.wav
+@end example
+@end itemize
+
 @anchor{aformat}
 @section aformat
 
@@ -1023,7 +1106,7 @@ The filter accepts the following options:
 @item frequency, f
 Set frequency in Hz.
 
-@item width_type
+@item width_type, t
 Set method to specify band-width of filter.
 @table @option
 @item h
@@ -1038,6 +1121,9 @@ slope
 
 @item width, w
 Specify the band-width of a filter in width_type units.
+
+@item channels, c
+Specify which channels to filter, by default all available are filtered.
 @end table
 
 @section aloop
@@ -1411,7 +1497,9 @@ The filter accepts the syntax
 [@var{sample_rate}:]@var{resampler_options}, where @var{sample_rate}
 expresses a sample rate and @var{resampler_options} is a list of
 @var{key}=@var{value} pairs, separated by ":". See the
-ffmpeg-resampler manual for the complete list of supported options.
+@ref{Resampler Options,,the "Resampler Options" section in the
+ffmpeg-resampler(1) manual,ffmpeg-resampler}
+for the complete list of supported options.
 
 @subsection Examples
 
@@ -1559,6 +1647,7 @@ Max_level
 Min_difference
 Max_difference
 Mean_difference
+RMS_difference
 Peak_level
 RMS_peak
 RMS_trough
@@ -1566,6 +1655,7 @@ Crest_factor
 Flat_factor
 Peak_count
 Bit_depth
+Dynamic_range
 
 and for Overall:
 DC_offset
@@ -1574,6 +1664,7 @@ Max_level
 Min_difference
 Max_difference
 Mean_difference
+RMS_difference
 Peak_level
 RMS_level
 RMS_peak
@@ -1615,6 +1706,9 @@ Maximal difference between two consecutive samples.
 Mean difference between two consecutive samples.
 The average of each difference between two consecutive samples.
 
+@item RMS difference
+Root Mean Square difference between two consecutive samples.
+
 @item Peak level dB
 @item RMS level dB
 Standard peak and RMS level measured in dBFS.
@@ -1636,39 +1730,9 @@ Number of occasions (not the number of samples) that the signal attained either
 
 @item Bit depth
 Overall bit depth of audio. Number of bits used for each sample.
-@end table
-
-@section asyncts
-
-Synchronize audio data with timestamps by squeezing/stretching it and/or
-dropping samples/adding silence when needed.
-
-This filter is not built by default, please use @ref{aresample} to do squeezing/stretching.
-
-It accepts the following parameters:
-@table @option
-
-@item compensate
-Enable stretching/squeezing the data to make it match the timestamps. Disabled
-by default. When disabled, time gaps are covered with silence.
-
-@item min_delta
-The minimum difference between timestamps and audio data (in seconds) to trigger
-adding/dropping samples. The default value is 0.1. If you get an imperfect
-sync with this filter, try setting this parameter to 0.
-
-@item max_comp
-The maximum compensation in samples per second. Only relevant with compensate=1.
-The default value is 500.
-
-@item first_pts
-Assume that the first PTS should be this value. The time base is 1 / sample
-rate. This allows for padding/trimming at the start of the stream. By default,
-no assumption is made about the first frame's expected PTS, so no padding or
-trimming is done. For example, this could be set to 0 to pad the beginning with
-silence if an audio stream starts after the video stream or to trim any samples
-with a negative PTS due to encoder delay.
 
+@item Dynamic range
+Measured dynamic range of audio in dB.
 @end table
 
 @section atempo
@@ -1781,7 +1845,7 @@ Set the filter's central frequency. Default is @code{3000}.
 @item csg
 Constant skirt gain if set to 1. Defaults to 0.
 
-@item width_type
+@item width_type, t
 Set method to specify band-width of filter.
 @table @option
 @item h
@@ -1796,6 +1860,9 @@ slope
 
 @item width, w
 Specify the band-width of a filter in width_type units.
+
+@item channels, c
+Specify which channels to filter, by default all available are filtered.
 @end table
 
 @section bandreject
@@ -1810,7 +1877,7 @@ The filter accepts the following options:
 @item frequency, f
 Set the filter's central frequency. Default is @code{3000}.
 
-@item width_type
+@item width_type, t
 Set method to specify band-width of filter.
 @table @option
 @item h
@@ -1825,6 +1892,9 @@ slope
 
 @item width, w
 Specify the band-width of a filter in width_type units.
+
+@item channels, c
+Specify which channels to filter, by default all available are filtered.
 @end table
 
 @section bass
@@ -1846,7 +1916,7 @@ Set the filter's central frequency and so can be used
 to extend or reduce the frequency range to be boosted or cut.
 The default value is @code{100} Hz.
 
-@item width_type
+@item width_type, t
 Set method to specify band-width of filter.
 @table @option
 @item h
@@ -1861,6 +1931,9 @@ slope
 
 @item width, w
 Determine how steep is the filter's shelf transition.
+
+@item channels, c
+Specify which channels to filter, by default all available are filtered.
 @end table
 
 @section biquad
@@ -1868,11 +1941,16 @@ Determine how steep is the filter's shelf transition.
 Apply a biquad IIR filter with the given coefficients.
 Where @var{b0}, @var{b1}, @var{b2} and @var{a0}, @var{a1}, @var{a2}
 are the numerator and denominator coefficients respectively.
+and @var{channels}, @var{c} specify which channels to filter, by default all
+available are filtered.
 
 @section bs2b
 Bauer stereo to binaural transformation, which improves headphone listening of
 stereo audio records.
 
+To enable compilation of this filter you need to configure FFmpeg with
+@code{--enable-libbs2b}.
+
 It accepts the following parameters:
 @table @option
 
@@ -1905,9 +1983,6 @@ Remap input channels to new locations.
 
 It accepts the following parameters:
 @table @option
-@item channel_layout
-The channel layout of the output stream.
-
 @item map
 Map channels from input to output. The argument is a '|'-separated list of
 mappings, each in the @code{@var{in_channel}-@var{out_channel}} or
@@ -1916,6 +1991,9 @@ channel (e.g. FL for front left) or its index in the input channel layout.
 @var{out_channel} is the name of the output channel or its index in the output
 channel layout. If @var{out_channel} is not given then it is implicitly an
 index, starting with zero and increasing by one for each mapping.
+
+@item channel_layout
+The channel layout of the output stream.
 @end table
 
 If no mapping is present, the filter will implicitly map input channels to
@@ -2042,7 +2120,7 @@ the following syntax: @code{x0/y0|x1/y1|x2/y2|....} or
 The input values must be in strictly increasing order but the transfer function
 does not have to be monotonically rising. The point @code{0/0} is assumed but
 may be overridden (by @code{0/out-dBn}). Typical values for the transfer
-function are @code{-70/-70|-60/-20}.
+function are @code{-70/-70|-60/-20|1/0}.
 
 @item soft-knee
 Set the curve radius in dB for all joints. It defaults to 0.01.
@@ -2210,6 +2288,35 @@ Set temperature degree in Celsius. This is the temperature of the environment.
 Default is 20.
 @end table
 
+@section crossfeed
+Apply headphone crossfeed filter.
+
+Crossfeed is the process of blending the left and right channels of stereo
+audio recording.
+It is mainly used to reduce extreme stereo separation of low frequencies.
+
+The intent is to produce more speaker like sound to the listener.
+
+The filter accepts the following options:
+
+@table @option
+@item strength
+Set strength of crossfeed. Default is 0.2. Allowed range is from 0 to 1.
+This sets gain of low shelf filter for side part of stereo image.
+Default is -6dB. Max allowed is -30db when strength is set to 1.
+
+@item range
+Set soundstage wideness. Default is 0.5. Allowed range is from 0 to 1.
+This sets cut off frequency of low shelf filter. Default is cut off near
+1550 Hz. With range set to 1 cut off frequency is set to 2100 Hz.
+
+@item level_in
+Set input gain. Default is 0.9.
+
+@item level_out
+Set output gain. Default is 1.
+@end table
+
 @section crystalizer
 Simple algorithm to expand audio dynamic range.
 
@@ -2427,7 +2534,7 @@ The filter accepts the following options:
 @item frequency, f
 Set the filter's central frequency in Hz.
 
-@item width_type
+@item width_type, t
 Set method to specify band-width of filter.
 @table @option
 @item h
@@ -2446,6 +2553,9 @@ Specify the band-width of a filter in width_type units.
 @item gain, g
 Set the required gain or attenuation in dB.
 Beware of clipping when using a positive gain.
+
+@item channels, c
+Specify which channels to filter, by default all available are filtered.
 @end table
 
 @subsection Examples
@@ -2453,13 +2563,13 @@ Beware of clipping when using a positive gain.
 @item
 Attenuate 10 dB at 1000 Hz, with a bandwidth of 200 Hz:
 @example
-equalizer=f=1000:width_type=h:width=200:g=-10
+equalizer=f=1000:t=h:width=200:g=-10
 @end example
 
 @item
 Apply 2 dB gain at 1000 Hz with Q 1 and attenuate 5 dB at 100 Hz with Q 2:
 @example
-equalizer=f=1000:width_type=q:width=1:g=2,equalizer=f=100:width_type=q:width=2:g=-5
+equalizer=f=1000:t=q:w=1:g=2,equalizer=f=100:t=q:w=2:g=-5
 @end example
 @end itemize
 
@@ -2585,6 +2695,13 @@ Set file for dumping, suitable for gnuplot.
 @item dumpscale
 Set scale for dumpfile. Acceptable values are same with scale option.
 Default is linlog.
+
+@item fft2
+Enable 2-channel convolution using complex FFT. This improves speed significantly.
+Default is disabled.
+
+@item min_phase
+Enable minimum phase impulse response. Default is disabled.
 @end table
 
 @subsection Examples
@@ -2627,7 +2744,7 @@ The filter accepts the following options:
 Set base delay in milliseconds. Range from 0 to 30. Default value is 0.
 
 @item depth
-Set added swep delay in milliseconds. Range from 0 to 10. Default value is 2.
+Set added sweep delay in milliseconds. Range from 0 to 10. Default value is 2.
 
 @item regen
 Set percentage regeneration (delayed signal feedback). Range from -95 to 95.
@@ -2653,6 +2770,70 @@ Set delay-line interpolation, @var{linear} or @var{quadratic}.
 Default is @var{linear}.
 @end table
 
+@section haas
+Apply Haas effect to audio.
+
+Note that this makes most sense to apply on mono signals.
+With this filter applied to mono signals it give some directionality and
+stretches its stereo image.
+
+The filter accepts the following options:
+
+@table @option
+@item level_in
+Set input level. By default is @var{1}, or 0dB
+
+@item level_out
+Set output level. By default is @var{1}, or 0dB.
+
+@item side_gain
+Set gain applied to side part of signal. By default is @var{1}.
+
+@item middle_source
+Set kind of middle source. Can be one of the following:
+
+@table @samp
+@item left
+Pick left channel.
+
+@item right
+Pick right channel.
+
+@item mid
+Pick middle part signal of stereo image.
+
+@item side
+Pick side part signal of stereo image.
+@end table
+
+@item middle_phase
+Change middle phase. By default is disabled.
+
+@item left_delay
+Set left channel delay. By default is @var{2.05} milliseconds.
+
+@item left_balance
+Set left channel balance. By default is @var{-1}.
+
+@item left_gain
+Set left channel gain. By default is @var{1}.
+
+@item left_phase
+Change left phase. By default is disabled.
+
+@item right_delay
+Set right channel delay. By defaults is @var{2.12} milliseconds.
+
+@item right_balance
+Set right channel balance. By default is @var{1}.
+
+@item right_gain
+Set right channel gain. By default is @var{1}.
+
+@item right_phase
+Change right phase. By default is enabled.
+@end table
+
 @section hdcd
 
 Decodes High Definition Compatible Digital (HDCD) data. A 16-bit PCM stream with
@@ -2670,7 +2851,7 @@ so the resulting 20-bit stream will be truncated back to 16-bit. Use something
 like @command{-acodec pcm_s24le} after the filter to get 24-bit PCM output.
 @example
 ffmpeg -i HDCD16.wav -af hdcd OUT16.wav
-ffmpeg -i HDCD16.wav -af hdcd -acodec pcm_s24le OUT24.wav
+ffmpeg -i HDCD16.wav -af hdcd -c:a pcm_s24le OUT24.wav
 @end example
 
 The filter accepts the following options:
@@ -2711,6 +2892,49 @@ Samples where the target gain does not match between channels
 @end table
 @end table
 
+@section headphone
+
+Apply head-related transfer functions (HRTFs) to create virtual
+loudspeakers around the user for binaural listening via headphones.
+The HRIRs are provided via additional streams, for each channel
+one stereo input stream is needed.
+
+The filter accepts the following options:
+
+@table @option
+@item map
+Set mapping of input streams for convolution.
+The argument is a '|'-separated list of channel names in order as they
+are given as additional stream inputs for filter.
+This also specify number of input streams. Number of input streams
+must be not less than number of channels in first stream plus one.
+
+@item gain
+Set gain applied to audio. Value is in dB. Default is 0.
+
+@item type
+Set processing type. Can be @var{time} or @var{freq}. @var{time} is
+processing audio in time domain which is slow.
+@var{freq} is processing audio in frequency domain which is fast.
+Default is @var{freq}.
+
+@item lfe
+Set custom gain for LFE channels. Value is in dB. Default is 0.
+@end table
+
+@subsection Examples
+
+@itemize
+@item
+Full example using wav files as coefficients with amovie filters for 7.1 downmix,
+each amovie filter use stereo file with IR coefficients as input.
+The files give coefficients for each position of virtual loudspeaker:
+@example
+ffmpeg -i input.wav -lavfi-complex "amovie=azi_270_ele_0_DFC.wav[sr],amovie=azi_90_ele_0_DFC.wav[sl],amovie=azi_225_ele_0_DFC.wav[br],amovie=azi_135_ele_0_DFC.wav[bl],amovie=azi_0_ele_0_DFC.wav,asplit[fc][lfe],amovie=azi_35_ele_0_DFC.wav[fl],amovie=azi_325_ele_0_DFC.wav[fr],[a:0][fl][fr][fc][lfe][bl][br][sl][sr]headphone=FL|FR|FC|LFE|BL|BR|SL|SR"
+output.wav
+@end example
+@end itemize
+
 @section highpass
 
 Apply a high-pass filter with 3dB point frequency.
@@ -2726,7 +2950,7 @@ Set frequency in Hz. Default is 3000.
 @item poles, p
 Set number of poles. Default is 2.
 
-@item width_type
+@item width_type, t
 Set method to specify band-width of filter.
 @table @option
 @item h
@@ -2743,6 +2967,9 @@ slope
 Specify the band-width of a filter in width_type units.
 Applies only to double-pole filter.
 The default is 0.707q and gives a Butterworth response.
+
+@item channels, c
+Specify which channels to filter, by default all available are filtered.
 @end table
 
 @section join
@@ -2899,6 +3126,31 @@ Attenuate low frequencies using Multiband EQ from Steve Harris
 @example
 ladspa=mbeq_1197:mbeq:-24|-24|-24|0|0|0|0|0|0|0|0|0|0|0|0
 @end example
+
+@item
+Reduce stereo image using @code{Narrower} from the @code{C* Audio Plugin Suite}
+(CAPS) library:
+@example
+ladspa=caps:Narrower
+@end example
+
+@item
+Another white noise, now using @code{C* Audio Plugin Suite} (CAPS) library:
+@example
+ladspa=caps:White:.2
+@end example
+
+@item
+Some fractal noise, using @code{C* Audio Plugin Suite} (CAPS) library:
+@example
+ladspa=caps:Fractal:c=c1=1
+@end example
+
+@item
+Dynamic volume normalization using @code{VLevel} plugin:
+@example
+ladspa=vlevel-ladspa:vlevel_mono
+@end example
 @end itemize
 
 @subsection Commands
@@ -2915,10 +3167,9 @@ If the specified value is not valid, it is ignored and prior one is kept.
 
 EBU R128 loudness normalization. Includes both dynamic and linear normalization modes.
 Support for both single pass (livestreams, files) and double pass (files) modes.
-This algorithm can target IL, LRA, and maximum true peak.
-
-To enable compilation of this filter you need to configure FFmpeg with
-@code{--enable-libebur128}.
+This algorithm can target IL, LRA, and maximum true peak. To accurately detect true peaks,
+the audio stream will be upsampled to 192 kHz unless the normalization mode is linear.
+Use the @code{-ar} option or @code{aresample} filter to explicitly set an output sample rate.
 
 The filter accepts the following options:
 
@@ -2988,7 +3239,7 @@ Set frequency in Hz. Default is 500.
 @item poles, p
 Set number of poles. Default is 2.
 
-@item width_type
+@item width_type, t
 Set method to specify band-width of filter.
 @table @option
 @item h
@@ -3005,8 +3256,20 @@ slope
 Specify the band-width of a filter in width_type units.
 Applies only to double-pole filter.
 The default is 0.707q and gives a Butterworth response.
+
+@item channels, c
+Specify which channels to filter, by default all available are filtered.
 @end table
 
+@subsection Examples
+@itemize
+@item
+Lowpass only LFE channel, it LFE is not present it does nothing:
+@example
+lowpass=c=LFE
+@end example
+@end itemize
+
 @anchor{pan}
 @section pan
 
@@ -3025,7 +3288,7 @@ output channel layout or number of channels
 
 @item outdef
 output channel specification, of the form:
-"@var{out_name}=[@var{gain}*]@var{in_name}[+[@var{gain}*]@var{in_name}...]"
+"@var{out_name}=[@var{gain}*]@var{in_name}[(+-)[@var{gain}*]@var{in_name}...]"
 
 @item out_name
 output channel to define, either a channel name (FL, FR, etc.) or a channel
@@ -3225,7 +3488,7 @@ reduction is decreased again. Default is 250. Range is between 0.01 and 9000.
 
 @item makeup
 Set the amount by how much signal will be amplified after processing.
-Default is 2. Range is from 1 and 64.
+Default is 1. Range is from 1 to 64.
 
 @item knee
 Curve the sharp knee around the threshold to enter gain reduction more softly.
@@ -3456,7 +3719,7 @@ SOFAlizer is developed at the Acoustics Research Institute (ARI) of the
 Austrian Academy of Sciences.
 
 To enable compilation of this filter you need to configure FFmpeg with
-@code{--enable-netcdf}.
+@code{--enable-libmysofa}.
 
 The filter accepts the following options:
 
@@ -3487,11 +3750,14 @@ Default is @var{freq}.
 Set custom positions of virtual loudspeakers. Syntax for this option is:
 <CH> <AZIM> <ELEV>[|<CH> <AZIM> <ELEV>|...].
 Each virtual loudspeaker is described with short channel name following with
-azimuth and elevation in degreees.
+azimuth and elevation in degrees.
 Each virtual loudspeaker description is separated by '|'.
 For example to override front left and front right channel positions use:
 'speakers=FL 45 15|FR 345 15'.
 Descriptions with unrecognised channel names are ignored.
+
+@item lfegain
+Set custom gain for LFE channels. Value is in dB. Default is 0.
 @end table
 
 @subsection Examples
@@ -3510,10 +3776,10 @@ sofalizer=sofa=/path/to/ClubFritz12.sofa:type=freq:radius=2:rotation=5
 @end example
 
 @item
-Similar as above but with custom speaker positions for front left, front right, rear left and rear right
+Similar as above but with custom speaker positions for front left, front right, back left and back right
 and also with custom gain:
 @example
-"sofalizer=sofa=/path/to/ClubFritz6.sofa:type=freq:radius=2:speakers=FL 45|FR 315|RL 135|RR 225:gain=28"
+"sofalizer=sofa=/path/to/ClubFritz6.sofa:type=freq:radius=2:speakers=FL 45|FR 315|BL 135|BR 225:gain=28"
 @end example
 @end itemize
 
@@ -3582,6 +3848,12 @@ Left/Right to Left + Right.
 
 @item lr>rl
 Left/Right to Right/Left.
+
+@item ms>ll
+Mid/Side to Left/Left.
+
+@item ms>rr
+Mid/Side to Right/Right.
 @end table
 
 @item slev
@@ -3612,6 +3884,23 @@ Set S/C level. Default is 1. Allowed range is from 1 to 100.
 
 @item phase
 Set the stereo phase in degrees. Default is 0. Allowed range is from 0 to 360.
+
+@item bmode_in, bmode_out
+Set balance mode for balance_in/balance_out option.
+
+Can be one of the following:
+
+@table @samp
+@item balance
+Classic balance mode. Attenuate one channel at time.
+Gain is raised up to 1.
+
+@item amplitude
+Similar as classic mode above but gain is raised up to 2.
+
+@item power
+Equal power distribution, from -6dB to +6dB range.
+@end table
 @end table
 
 @subsection Examples
@@ -3657,6 +3946,97 @@ channels. Default is 0.3.
 Set level of input signal of original channel. Default is 0.8.
 @end table
 
+@section superequalizer
+Apply 18 band equalizer.
+
+The filter accepts the following options:
+@table @option
+@item 1b
+Set 65Hz band gain.
+@item 2b
+Set 92Hz band gain.
+@item 3b
+Set 131Hz band gain.
+@item 4b
+Set 185Hz band gain.
+@item 5b
+Set 262Hz band gain.
+@item 6b
+Set 370Hz band gain.
+@item 7b
+Set 523Hz band gain.
+@item 8b
+Set 740Hz band gain.
+@item 9b
+Set 1047Hz band gain.
+@item 10b
+Set 1480Hz band gain.
+@item 11b
+Set 2093Hz band gain.
+@item 12b
+Set 2960Hz band gain.
+@item 13b
+Set 4186Hz band gain.
+@item 14b
+Set 5920Hz band gain.
+@item 15b
+Set 8372Hz band gain.
+@item 16b
+Set 11840Hz band gain.
+@item 17b
+Set 16744Hz band gain.
+@item 18b
+Set 20000Hz band gain.
+@end table
+
+@section surround
+Apply audio surround upmix filter.
+
+This filter allows to produce multichannel output from audio stream.
+
+The filter accepts the following options:
+
+@table @option
+@item chl_out
+Set output channel layout. By default, this is @var{5.1}.
+
+See @ref{channel layout syntax,,the Channel Layout section in the ffmpeg-utils(1) manual,ffmpeg-utils}
+for the required syntax.
+
+@item chl_in
+Set input channel layout. By default, this is @var{stereo}.
+
+See @ref{channel layout syntax,,the Channel Layout section in the ffmpeg-utils(1) manual,ffmpeg-utils}
+for the required syntax.
+
+@item level_in
+Set input volume level. By default, this is @var{1}.
+
+@item level_out
+Set output volume level. By default, this is @var{1}.
+
+@item lfe
+Enable LFE channel output if output channel layout has it. By default, this is enabled.
+
+@item lfe_low
+Set LFE low cut off frequency. By default, this is @var{128} Hz.
+
+@item lfe_high
+Set LFE high cut off frequency. By default, this is @var{256} Hz.
+
+@item fc_in
+Set front center input volume. By default, this is @var{1}.
+
+@item fc_out
+Set front center output volume. By default, this is @var{1}.
+
+@item lfe_in
+Set LFE input volume. By default, this is @var{1}.
+
+@item lfe_out
+Set LFE output volume. By default, this is @var{1}.
+@end table
+
 @section treble
 
 Boost or cut treble (upper) frequencies of the audio using a two-pole
@@ -3676,7 +4056,7 @@ Set the filter's central frequency and so can be used
 to extend or reduce the frequency range to be boosted or cut.
 The default value is @code{3000} Hz.
 
-@item width_type
+@item width_type, t
 Set method to specify band-width of filter.
 @table @option
 @item h
@@ -3691,6 +4071,9 @@ slope
 
 @item width, w
 Determine how steep is the filter's shelf transition.
+
+@item channels, c
+Specify which channels to filter, by default all available are filtered.
 @end table
 
 @section tremolo
@@ -4205,8 +4588,8 @@ Specify the duration of the generated audio stream. Not specifying this option
 results in noise with an infinite length.
 
 @item color, colour, c
-Specify the color of noise. Available noise colors are white, pink, and brown.
-Default color is white.
+Specify the color of noise. Available noise colors are white, pink, brown,
+blue and violet. Default color is white.
 
 @item seed, s
 Specify a value used to seed the PRNG.
@@ -4538,6 +4921,10 @@ the position in the file if known or -1 and the timestamp in seconds.
 In order to display the output lines, you need to set the loglevel at
 least to the AV_LOG_INFO value.
 
+This filter exports frame metadata @code{lavfi.blackframe.pblack}.
+The value represents the percentage of pixels in the picture that
+are below the threshold value.
+
 It accepts the following parameters:
 
 @table @option
@@ -4578,17 +4965,18 @@ of @var{all_mode}. Default value is @code{normal}.
 Available values for component modes are:
 @table @samp
 @item addition
-@item addition128
+@item grainmerge
 @item and
 @item average
 @item burn
 @item darken
 @item difference
-@item difference128
+@item grainextract
 @item divide
 @item dodge
 @item freeze
 @item exclusion
+@item extremity
 @item glow
 @item hardlight
 @item hardmix
@@ -4657,17 +5045,10 @@ Value of pixel component at current location for first video frame (top layer).
 @item BOTTOM, B
 Value of pixel component at current location for second video frame (bottom layer).
 @end table
-
-@item shortest
-Force termination when the shortest input terminates. Default is
-@code{0}. This option is only defined for the @code{blend} filter.
-
-@item repeatlast
-Continue applying the last bottom frame after the end of the stream. A value of
-@code{0} disable the filter after the last frame of the bottom layer is reached.
-Default is @code{1}. This option is only defined for the @code{blend} filter.
 @end table
 
+The @code{blend} filter also supports the @ref{framesync} options.
+
 @subsection Examples
 
 @itemize
@@ -4677,6 +5058,12 @@ Apply transition from bottom layer to top layer in first 10 seconds:
 blend=all_expr='A*(if(gte(T,10),1,T/10))+B*(1-(if(gte(T,10),1,T/10)))'
 @end example
 
+@item
+Apply linear horizontal transition from top layer to bottom layer:
+@example
+blend=all_expr='A*(X/W)+B*(1-X/W)'
+@end example
+
 @item
 Apply 1x1 checkerboard effect:
 @example
@@ -4704,13 +5091,13 @@ blend=all_expr='if(gte(T*SH*40+Y,H)*gte((T*40*SW+X)*W/H,W),A,B)'
 @item
 Split diagonally video and shows top and bottom layer on each side:
 @example
-blend=all_expr=if(gt(X,Y*(W/H)),A,B)
+blend=all_expr='if(gt(X,Y*(W/H)),A,B)'
 @end example
 
 @item
 Display differences between the current and the previous frame:
 @example
-tblend=all_mode=difference128
+tblend=all_mode=grainextract
 @end example
 @end itemize
 
@@ -4880,7 +5267,7 @@ the more similar the pixels color is to the key color.
 @item yuv
 Signals that the color passed is already in YUV instead of RGB.
 
-Litteral colors like "green" or "red" don't make sense with this enabled anymore.
+Literal colors like "green" or "red" don't make sense with this enabled anymore.
 This can be used to pass exact YUV values as hexadecimal numbers.
 @end table
 
@@ -5251,15 +5638,24 @@ The accepted values are:
 @item bt709
 BT.709
 
+@item fcc
+FCC
+
 @item bt601
 BT.601
 
+@item bt470
+BT.470
+
+@item bt470bg
+BT.470BG
+
+@item smpte170m
+SMPTE-170M
+
 @item smpte240m
 SMPTE-240M
 
-@item fcc
-FCC
-
 @item bt2020
 BT.2020
 @end table
@@ -5273,6 +5669,7 @@ colormatrix=bt601:smpte240m
 @section colorspace
 
 Convert colorspace, transfer characteristics or color primaries.
+Input video needs to have an even size.
 
 The filter accepts the following options:
 
@@ -5330,6 +5727,9 @@ SMPTE-170M or BT.601-6 525
 @item smpte240m
 SMPTE-240M
 
+@item ycgco
+YCgCo
+
 @item bt2020ncl
 BT.2020 with non-constant luminance
 
@@ -5344,6 +5744,12 @@ The accepted values are:
 @item bt709
 BT.709
 
+@item bt470m
+BT.470M
+
+@item bt470bg
+BT.470BG
+
 @item gamma22
 Constant gamma of 2.2
 
@@ -5356,6 +5762,18 @@ SMPTE-170M, BT.601-6 625 or BT.601-6 525
 @item smpte240m
 SMPTE-240M
 
+@item srgb
+SRGB
+
+@item iec61966-2-1
+iec61966-2-1
+
+@item iec61966-2-4
+iec61966-2-4
+
+@item xvycc
+xvycc
+
 @item bt2020-10
 BT.2020 for 10-bits content
 
@@ -5385,9 +5803,21 @@ SMPTE-170M or BT.601-6 525
 @item smpte240m
 SMPTE-240M
 
+@item film
+film
+
+@item smpte431
+SMPTE-431
+
+@item smpte432
+SMPTE-432
+
 @item bt2020
 BT.2020
 
+@item jedec-p22
+JEDEC P22 phosphors
+
 @end table
 
 @anchor{range}
@@ -5396,9 +5826,15 @@ Specify output color range.
 
 The accepted values are:
 @table @samp
+@item tv
+TV (restricted) range
+
 @item mpeg
 MPEG (restricted) range
 
+@item pc
+PC (full) range
+
 @item jpeg
 JPEG (full) range
 
@@ -5556,6 +5992,12 @@ Apply edge detect:
 convolution="0 1 0 1 -4 1 0 1 0:0 1 0 1 -4 1 0 1 0:0 1 0 1 -4 1 0 1 0:0 1 0 1 -4 1 0 1 0:5:5:5:1:0:128:128:128"
 @end example
 
+@item
+Apply laplacian edge detector which includes diagonals:
+@example
+convolution="1 1 1 1 -8 1 1 1 1:1 1 1 1 -8 1 1 1 1:1 1 1 1 -8 1 1 1 1:1 1 1 1 -8 1 1 1 1:5:5:5:1:0:128:128:0"
+@end example
+
 @item
 Apply emboss:
 @example
@@ -5563,9 +6005,27 @@ convolution="-2 -1 0 -1 1 1 0 1 2:-2 -1 0 -1 1 1 0 1 2:-2 -1 0 -1 1 1 0 1 2:-2 -
 @end example
 @end itemize
 
+@section convolve
+
+Apply 2D convolution of video stream in frequency domain using second stream
+as impulse.
+
+The filter accepts the following options:
+
+@table @option
+@item planes
+Set which planes to process.
+
+@item impulse
+Set which impulse video frames will be processed, can be @var{first}
+or @var{all}. Default is @var{all}.
+@end table
+
+The @code{convolve} filter also supports the @ref{framesync} options.
+
 @section copy
 
-Copy the input source unchanged to the output. This is mainly useful for
+Copy the input video source unchanged to the output. This is mainly useful for
 testing purposes.
 
 @anchor{coreimage}
@@ -6161,11 +6621,16 @@ absolute value will be picked. For example direction 0, -PI or -2*PI radians
 will pick only pixels on same row and -PI/2 will pick only pixels on same
 column.
 
-@item blur
+@item blur, b
 If enabled, current pixel is compared with average value of all four
 surrounding pixels. The default is enabled. If disabled current pixel is
 compared with all four surrounding pixels. The pixel is considered banded
 if only all four differences with surrounding pixels are less than threshold.
+
+@item coupling, c
+If enabled, current pixel is changed if and only if all pixel components are banded,
+e.g. banding detection threshold is triggered for all color components.
+The default is disabled.
 @end table
 
 @anchor{decimate}
@@ -6226,6 +6691,47 @@ Limit the maximum change for each plane, default is 65535.
 If 0, plane will remain unchanged.
 @end table
 
+@section deflicker
+
+Remove temporal frame luminance variations.
+
+It accepts the following options:
+
+@table @option
+@item size, s
+Set moving-average filter size in frames. Default is 5. Allowed range is 2 - 129.
+
+@item mode, m
+Set averaging mode to smooth temporal luminance variations.
+
+Available values are:
+@table @samp
+@item am
+Arithmetic mean
+
+@item gm
+Geometric mean
+
+@item hm
+Harmonic mean
+
+@item qm
+Quadratic mean
+
+@item cm
+Cubic mean
+
+@item pm
+Power mean
+
+@item median
+Median
+@end table
+
+@item bypass
+Do not actually modify frame. Useful when one only wants metadata.
+@end table
+
 @section dejudder
 
 Remove judder produced by partially interlaced telecined content.
@@ -6387,6 +6893,41 @@ FFmpeg was configured with @code{--enable-opencl}. Default value is 0.
 
 @end table
 
+@section despill
+
+Remove unwanted contamination of foreground colors, caused by reflected color of
+greenscreen or bluescreen.
+
+This filter accepts the following options:
+
+@table @option
+@item type
+Set what type of despill to use.
+
+@item mix
+Set how spillmap will be generated.
+
+@item expand
+Set how much to get rid of still remaining spill.
+
+@item red
+Controls amount of red in spill area.
+
+@item green
+Controls amount of green in spill area.
+Should be -1 for greenscreen.
+
+@item blue
+Controls amount of blue in spill area.
+Should be -1 for bluescreen.
+
+@item brightness
+Controls brightness of spill area, preserving colors.
+
+@item alpha
+Modify alpha from generated spillmap.
+@end table
+
 @section detelecine
 
 Apply an exact inverse of the telecine operation. It requires a predefined
@@ -6472,6 +7013,9 @@ Adjacent pixels will spread out to replace missing pixels.
 
 @item wrap
 Out of range pixels are wrapped so they point to pixels of other side.
+
+@item mirror
+Out of range pixels will be replaced with mirrored pixels.
 @end table
 Default is @samp{smear}.
 
@@ -6703,6 +7247,10 @@ option, check the "Color" section in the ffmpeg-utils manual.
 
 The default value of @var{boxcolor} is "white".
 
+@item line_spacing
+Set the line spacing in pixels of the border to be drawn around the box using @var{box}.
+The default value of @var{line_spacing} is 0.
+
 @item borderw
 Set the width of the border to be drawn around the text using @var{bordercolor}.
 The default value of @var{borderw} is 0.
@@ -6719,6 +7267,12 @@ Select how the @var{text} is expanded. Can be either @code{none},
 @code{normal} (default). See the @ref{drawtext_expansion, Text expansion} section
 below for details.
 
+@item basetime
+Set a start time for the count. Value is in microseconds. Only applied
+in the deprecated strftime expansion mode. To emulate in normal expansion
+mode use the @code{pts} function, supplying the start time (in seconds)
+as the second argument.
+
 @item fix_bounds
 If true, check and fix text coords to avoid clipping.
 
@@ -6740,9 +7294,6 @@ The font family to be used for drawing text. By default Sans.
 The font file to be used for drawing text. The path must be included.
 This parameter is mandatory if the fontconfig support is disabled.
 
-@item draw
-This option does not exist, please see the timeline system
-
 @item alpha
 Draw the text applying alpha blending. The value can
 be a number between 0.0 and 1.0.
@@ -6816,6 +7367,10 @@ option must be specified.
 @item timecode_rate, rate, r
 Set the timecode frame rate (timecode only).
 
+@item tc24hmax
+If set to 1, the output of the timecode option will wrap around at 24 hours.
+Default is 0 (disabled).
+
 @item text
 The text string to be drawn. The text must be a sequence of UTF-8
 encoded characters.
@@ -7093,6 +7648,14 @@ FOD=5 # fade out duration
 ffplay -f lavfi "color,drawtext=text=TEST:fontsize=50:fontfile=FreeSerif.ttf:fontcolor_expr=ff0000%@{eif\\\\: clip(255*(1*between(t\\, $DS + $FID\\, $DE - $FOD) + ((t - $DS)/$FID)*between(t\\, $DS\\, $DS + $FID) + (-(t - $DE)/$FOD)*between(t\\, $DE - $FOD\\, $DE) )\\, 0\\, 255) \\\\: x\\\\: 2 @}"
 @end example
 
+@item
+Horizontally align multiple separate texts. Note that @option{max_glyph_a}
+and the @option{fontsize} value are included in the @option{y} offset.
+@example
+drawtext=fontfile=FreeSans.ttf:text=DOG:fontsize=24:x=10:y=20+24-max_glyph_a,
+drawtext=fontfile=FreeSans.ttf:text=cow:fontsize=24:x=80:y=20+24-max_glyph_a
+@end example
+
 @end itemize
 
 For more information about libfreetype, check:
@@ -7480,6 +8043,20 @@ Set the frequency domain weight expression for the 1st chroma plane.
 @item weight_V
 Set the frequency domain weight expression for the 2nd chroma plane.
 
+@item eval
+Set when the expressions are evaluated.
+
+It accepts the following values:
+@table @samp
+@item init
+Only evaluate expressions once during the filter initialization.
+
+@item frame
+Evaluate expressions for each incoming frame.
+@end table
+
+Default value is @samp{init}.
+
 The filter accepts the following variables:
 @item X
 @item Y
@@ -7488,6 +8065,9 @@ The coordinates of the current sample.
 @item W
 @item H
 The width and height of the image.
+
+@item N
+The number of input frame, starting from 0.
 @end table
 
 @subsection Examples
@@ -8009,6 +8589,43 @@ ffmpeg -i file.ts -vf find_rect=newref.pgm,cover_rect=cover.jpg:mode=cover new.m
 @end example
 @end itemize
 
+@section floodfill
+
+Flood area with values of same pixel components with another values.
+
+It accepts the following options:
+@table @option
+@item x
+Set pixel x coordinate.
+
+@item y
+Set pixel y coordinate.
+
+@item s0
+Set source #0 component value.
+
+@item s1
+Set source #1 component value.
+
+@item s2
+Set source #2 component value.
+
+@item s3
+Set source #3 component value.
+
+@item d0
+Set destination #0 component value.
+
+@item d1
+Set destination #1 component value.
+
+@item d2
+Set destination #2 component value.
+
+@item d3
+Set destination #3 component value.
+@end table
+
 @anchor{format}
 @section format
 
@@ -8052,13 +8669,21 @@ It accepts the following parameters:
 @item fps
 The desired output frame rate. The default is @code{25}.
 
+@item start_time
+Assume the first PTS should be the given value, in seconds. This allows for
+padding/trimming at the start of stream. By default, no assumption is made
+about the first frame's expected PTS, so no padding or trimming is done.
+For example, this could be set to 0 to pad the beginning with duplicates of
+the first frame if a video stream starts after the audio stream or to trim any
+frames with a negative PTS.
+
 @item round
-Rounding method.
+Timestamp (PTS) rounding method.
 
 Possible values are:
 @table @option
 @item zero
-zero round towards 0
+round towards 0
 @item inf
 round away from 0
 @item down
@@ -8070,18 +8695,22 @@ round to nearest
 @end table
 The default is @code{near}.
 
-@item start_time
-Assume the first PTS should be the given value, in seconds. This allows for
-padding/trimming at the start of stream. By default, no assumption is made
-about the first frame's expected PTS, so no padding or trimming is done.
-For example, this could be set to 0 to pad the beginning with duplicates of
-the first frame if a video stream starts after the audio stream or to trim any
-frames with a negative PTS.
+@item eof_action
+Action performed when reading the last frame.
+
+Possible values are:
+@table @option
+@item round
+Use same timestamp rounding method as used for other frames.
+@item pass
+Pass through last frame if input duration has not been reached yet.
+@end table
+The default is @code{round}.
 
 @end table
 
 Alternatively, the options can be specified as a flat string:
-@var{fps}[:@var{round}].
+@var{fps}[:@var{start_time}[:@var{round}]].
 
 See also the @ref{setpts} filter.
 
@@ -8217,7 +8846,7 @@ It accepts the following parameters:
 @item filter_name
 The name of the frei0r effect to load. If the environment variable
 @env{FREI0R_PATH} is defined, the frei0r effect is searched for in each of the
-directories specified by the colon-separated list in @env{FREIOR_PATH}.
+directories specified by the colon-separated list in @env{FREI0R_PATH}.
 Otherwise, the standard frei0r paths are searched, in this order:
 @file{HOME/.frei0r-1/lib/}, @file{/usr/local/lib/frei0r-1/},
 @file{/usr/lib/frei0r-1/}.
@@ -8638,15 +9267,18 @@ Allowed range is [0, 40].
 Set display mode.
 It accepts the following values:
 @table @samp
-@item parade
+@item stack
 Per color component graphs are placed below each other.
 
+@item parade
+Per color component graphs are placed side by side.
+
 @item overlay
 Presents information identical to that in the @code{parade}, except
 that the graphs representing color components are superimposed directly
 over one another.
 @end table
-Default is @code{parade}.
+Default is @code{stack}.
 
 @item levels_mode
 Set mode. Can be either @code{linear}, or @code{logarithmic}.
@@ -8702,6 +9334,104 @@ A floating point number which specifies chroma temporal strength. It defaults to
 @var{luma_tmp}*@var{chroma_spatial}/@var{luma_spatial}.
 @end table
 
+@section hwdownload
+
+Download hardware frames to system memory.
+
+The input must be in hardware frames, and the output a non-hardware format.
+Not all formats will be supported on the output - it may be necessary to insert
+an additional @option{format} filter immediately following in the graph to get
+the output in a supported format.
+
+@section hwmap
+
+Map hardware frames to system memory or to another device.
+
+This filter has several different modes of operation; which one is used depends
+on the input and output formats:
+@itemize
+@item
+Hardware frame input, normal frame output
+
+Map the input frames to system memory and pass them to the output.  If the
+original hardware frame is later required (for example, after overlaying
+something else on part of it), the @option{hwmap} filter can be used again
+in the next mode to retrieve it.
+@item
+Normal frame input, hardware frame output
+
+If the input is actually a software-mapped hardware frame, then unmap it -
+that is, return the original hardware frame.
+
+Otherwise, a device must be provided.  Create new hardware surfaces on that
+device for the output, then map them back to the software format at the input
+and give those frames to the preceding filter.  This will then act like the
+@option{hwupload} filter, but may be able to avoid an additional copy when
+the input is already in a compatible format.
+@item
+Hardware frame input and output
+
+A device must be supplied for the output, either directly or with the
+@option{derive_device} option.  The input and output devices must be of
+different types and compatible - the exact meaning of this is
+system-dependent, but typically it means that they must refer to the same
+underlying hardware context (for example, refer to the same graphics card).
+
+If the input frames were originally created on the output device, then unmap
+to retrieve the original frames.
+
+Otherwise, map the frames to the output device - create new hardware frames
+on the output corresponding to the frames on the input.
+@end itemize
+
+The following additional parameters are accepted:
+
+@table @option
+@item mode
+Set the frame mapping mode.  Some combination of:
+@table @var
+@item read
+The mapped frame should be readable.
+@item write
+The mapped frame should be writeable.
+@item overwrite
+The mapping will always overwrite the entire frame.
+
+This may improve performance in some cases, as the original contents of the
+frame need not be loaded.
+@item direct
+The mapping must not involve any copying.
+
+Indirect mappings to copies of frames are created in some cases where either
+direct mapping is not possible or it would have unexpected properties.
+Setting this flag ensures that the mapping is direct and will fail if that is
+not possible.
+@end table
+Defaults to @var{read+write} if not specified.
+
+@item derive_device @var{type}
+Rather than using the device supplied at initialisation, instead derive a new
+device of type @var{type} from the device the input frames exist on.
+
+@item reverse
+In a hardware to hardware mapping, map in reverse - create frames in the sink
+and map them back to the source.  This may be necessary in some cases where
+a mapping in one direction is required but only the opposite direction is
+supported by the devices being used.
+
+This option is dangerous - it may break the preceding filter in undefined
+ways if there are any additional constraints on that filter's output.
+Do not use it without fully understanding the implications of its use.
+@end table
+
+@section hwupload
+
+Upload system memory frames to hardware surfaces.
+
+The device to upload to must be supplied when the filter is initialised.  If
+using ffmpeg, select the appropriate device with the @option{-filter_hw_device}
+option.
+
 @anchor{hwupload_cuda}
 @section hwupload_cuda
 
@@ -9039,8 +9769,21 @@ This determines whether the interlaced frame is taken from the even
 (tff - default) or odd (bff) lines of the progressive frame.
 
 @item lowpass
-Enable (default) or disable the vertical lowpass filter to avoid twitter
-interlacing and reduce moire patterns.
+Vertical lowpass filter to avoid twitter interlacing and
+reduce moire patterns.
+
+@table @samp
+@item 0, off
+Disable vertical lowpass filter
+
+@item 1, linear
+Enable linear filter (default)
+
+@item 2, complex
+Enable complex filter. This will slightly less reduce twitter and moire
+but better retain detail and subjective sharpness impression.
+
+@end table
 @end table
 
 @section kerndeint
@@ -9140,6 +9883,89 @@ The formula that generates the correction is:
 where @var{r_0} is halve of the image diagonal and @var{r_src} and @var{r_tgt} are the
 distances from the focal point in the source and target images, respectively.
 
+@section libvmaf
+
+Obtain the average VMAF (Video Multi-Method Assessment Fusion)
+score between two input videos.
+
+This filter takes two input videos.
+
+Both video inputs must have the same resolution and pixel format for
+this filter to work correctly. Also it assumes that both inputs
+have the same number of frames, which are compared one by one.
+
+The obtained average VMAF score is printed through the logging system.
+
+It requires Netflix's vmaf library (libvmaf) as a pre-requisite.
+After installing the library it can be enabled using:
+@code{./configure --enable-libvmaf}.
+If no model path is specified it uses the default model: @code{vmaf_v0.6.1.pkl}.
+
+On the below examples the input file @file{main.mpg} being processed is
+compared with the reference file @file{ref.mpg}.
+
+The filter has following options:
+
+@table @option
+@item model_path
+Set the model path which is to be used for SVM.
+Default value: @code{"vmaf_v0.6.1.pkl"}
+
+@item log_path
+Set the file path to be used to store logs.
+
+@item log_fmt
+Set the format of the log file (xml or json).
+
+@item enable_transform
+Enables transform for computing vmaf.
+
+@item phone_model
+Invokes the phone model which will generate VMAF scores higher than in the
+regular model, which is more suitable for laptop, TV, etc. viewing conditions.
+
+@item psnr
+Enables computing psnr along with vmaf.
+
+@item ssim
+Enables computing ssim along with vmaf.
+
+@item ms_ssim
+Enables computing ms_ssim along with vmaf.
+
+@item pool
+Set the pool method to be used for computing vmaf.
+@end table
+
+This filter also supports the @ref{framesync} options.
+
+For example:
+@example
+ffmpeg -i main.mpg -i ref.mpg -lavfi libvmaf -f null -
+@end example
+
+Example with options:
+@example
+ffmpeg -i main.mpg -i ref.mpg -lavfi libvmaf="psnr=1:enable-transform=1" -f null -
+@end example
+
+@section limiter
+
+Limits the pixel components values to the specified range [min, max].
+
+The filter accepts the following options:
+
+@table @option
+@item min
+Lower bound. Defaults to the lowest allowed value for the input.
+
+@item max
+Upper bound. Defaults to the highest allowed value for the input.
+
+@item planes
+Specify which planes will be processed. Defaults to all available.
+@end table
+
 @section loop
 
 Loop video frames.
@@ -9194,6 +10020,28 @@ Interpolate values using a tetrahedron.
 @end table
 @end table
 
+This filter also supports the @ref{framesync} options.
+
+@section lumakey
+
+Turn certain luma values into transparency.
+
+The filter accepts the following options:
+
+@table @option
+@item threshold
+Set the luma which will be used as base for transparency.
+Default value is @code{0}.
+
+@item tolerance
+Set the range of luma values to be keyed out.
+Default value is @code{0}.
+
+@item softness
+Set the range of softness. Default value is @code{0}.
+Use this to control gradual transition from zero to full transparency.
+@end table
+
 @section lut, lutrgb, lutyuv
 
 Compute a look-up table for binding each pixel component input value
@@ -9342,9 +10190,13 @@ lutyuv=u='(val-maxval/2)*2+maxval/2':v='(val-maxval/2)*2+maxval/2'
 @end example
 @end itemize
 
-@section lut2
+@section lut2, tlut2
 
-Compute and apply a lookup table from two video inputs.
+The @code{lut2} filter takes two input streams and outputs one
+stream.
+
+The @code{tlut2} (time lut2) filter takes two consecutive frames
+from one single stream.
 
 This filter accepts the following parameters:
 @table @option
@@ -9400,6 +10252,12 @@ Highlight differences between two YUV video streams:
 @example
 lut2='ifnot(x-y,0,pow(2,bdx)-1):ifnot(x-y,pow(2,bdx-1),pow(2,bdx)-1):ifnot(x-y,pow(2,bdx-1),pow(2,bdx)-1)'
 @end example
+
+@item
+Show max difference between two video streams:
+@example
+lut2='if(lt(x,y),0,if(gt(x,y),pow(2,bdx)-1,pow(2,bdx-1))):if(lt(x,y),0,if(gt(x,y),pow(2,bdx)-1,pow(2,bdx-1))):if(lt(x,y),0,if(gt(x,y),pow(2,bdx)-1,pow(2,bdx-1)))'
+@end example
 @end itemize
 
 @section maskedclamp
@@ -9584,6 +10442,25 @@ Macroblock size. Default @code{16}.
 Search parameter. Default @code{7}.
 @end table
 
+@section midequalizer
+
+Apply Midway Image Equalization effect using two video streams.
+
+Midway Image Equalization adjusts a pair of images to have the same
+histogram, while maintaining their dynamics as much as possible. It's
+useful for e.g. matching exposures from a pair of stereo cameras.
+
+This filter has two inputs and one output, which must be of same pixel format, but
+may be of different sizes. The output of filter is first input adjusted with
+midway histogram of both inputs.
+
+This filter accepts the following option:
+
+@table @option
+@item planes
+Set which planes to process. Default is @code{15}, which is all available planes.
+@end table
+
 @section minterpolate
 
 Convert the video to specified frame rate using motion interpolation.
@@ -9654,7 +10531,7 @@ Macroblock size. Default @code{16}.
 @item search_param
 Motion estimation search parameter. Default @code{32}.
 
-@item vsmbc
+@item vsbmc
 Enable variable-size block motion compensation. Motion estimation is applied with smaller block sizes at object boundaries in order to make the them less blur. Default is @code{0} (disabled).
 @end table
 @end table
@@ -9665,7 +10542,7 @@ Scene change detection method. Scene change leads motion vectors to be in random
 @item none
 Disable scene change detection.
 @item fdiff
-Frame difference. Corresponding pixel values are compared and if it statisfies @var{scd_threshold} scene change is detected.
+Frame difference. Corresponding pixel values are compared and if it satisfies @var{scd_threshold} scene change is detected.
 @end table
 Default method is @samp{fdiff}.
 
@@ -9688,7 +10565,7 @@ A description of the accepted options follows.
 @item max
 Set the maximum number of consecutive frames which can be dropped (if
 positive), or the minimum interval between dropped frames (if
-negative). If the value is 0, the frame is dropped unregarding the
+negative). If the value is 0, the frame is dropped disregarding the
 number of previous sequentially dropped frames.
 
 Default value is 0.
@@ -9810,7 +10687,7 @@ Can be one of the following:
 @end table
 
 @item nns
-Set the number of neurons in predicctor neural network.
+Set the number of neurons in predictor neural network.
 Can be one of the following:
 
 @table @samp
@@ -9873,7 +10750,7 @@ It accepts the following parameters:
 
 @item pix_fmts
 A '|'-separated list of pixel format names, such as
-apix_fmts=yuv420p|monow|rgb24".
+pix_fmts=yuv420p|monow|rgb24".
 
 @end table
 
@@ -10075,6 +10952,84 @@ other parameters is 0.
 These parameters correspond to the parameters assigned to the
 libopencv function @code{cvSmooth}.
 
+@section oscilloscope
+
+2D Video Oscilloscope.
+
+Useful to measure spatial impulse, step responses, chroma delays, etc.
+
+It accepts the following parameters:
+
+@table @option
+@item x
+Set scope center x position.
+
+@item y
+Set scope center y position.
+
+@item s
+Set scope size, relative to frame diagonal.
+
+@item t
+Set scope tilt/rotation.
+
+@item o
+Set trace opacity.
+
+@item tx
+Set trace center x position.
+
+@item ty
+Set trace center y position.
+
+@item tw
+Set trace width, relative to width of frame.
+
+@item th
+Set trace height, relative to height of frame.
+
+@item c
+Set which components to trace. By default it traces first three components.
+
+@item g
+Draw trace grid. By default is enabled.
+
+@item st
+Draw some statistics. By default is enabled.
+
+@item sc
+Draw scope. By default is enabled.
+@end table
+
+@subsection Examples
+
+@itemize
+@item
+Inspect full first row of video frame.
+@example
+oscilloscope=x=0.5:y=0:s=1
+@end example
+
+@item
+Inspect full last row of video frame.
+@example
+oscilloscope=x=0.5:y=1:s=1
+@end example
+
+@item
+Inspect full 5th line of video frame of height 1080.
+@example
+oscilloscope=x=0.5:y=5/1080:s=1
+@end example
+
+@item
+Inspect full last column of video frame.
+@example
+oscilloscope=x=1:y=0.5:s=1:t=1
+@end example
+
+@end itemize
+
 @anchor{overlay}
 @section overlay
 
@@ -10096,17 +11051,7 @@ the expression is invalid, it is set to a huge value (meaning that the
 overlay will not be displayed within the output visible area).
 
 @item eof_action
-The action to take when EOF is encountered on the secondary input; it accepts
-one of the following values:
-
-@table @option
-@item repeat
-Repeat the last frame (the default).
-@item endall
-End both streams.
-@item pass
-Pass the main input through.
-@end table
+See @ref{framesync}.
 
 @item eval
 Set when the expressions for @option{x}, and @option{y} are evaluated.
@@ -10124,8 +11069,7 @@ evaluate expressions for each incoming frame
 Default value is @samp{frame}.
 
 @item shortest
-If set to 1, force the output to terminate when the shortest input
-terminates. Default value is 0.
+See @ref{framesync}.
 
 @item format
 Set the format for the output video.
@@ -10142,20 +11086,19 @@ force YUV422 output
 force YUV444 output
 
 @item rgb
-force RGB output
+force packed RGB output
+
+@item gbrp
+force planar RGB output
+
+@item auto
+automatically pick format
 @end table
 
 Default value is @samp{yuv420}.
 
-@item rgb @emph{(deprecated)}
-If set to 1, force the filter to accept inputs in the RGB
-color space. Default value is 0. This option is deprecated, use
-@option{format} instead.
-
 @item repeatlast
-If set to 1, force the filter to draw the last overlay frame over the
-main input until the end of the stream. A value of 0 disables this
-behavior. Default value is 1.
+See @ref{framesync}.
 @end table
 
 The @option{x}, and @option{y} expressions can contain the following
@@ -10192,6 +11135,8 @@ The timestamp, expressed in seconds. It's NAN if the input timestamp is unknown.
 
 @end table
 
+This filter also supports the @ref{framesync} options.
+
 Note that the @var{n}, @var{pos}, @var{t} variables are available only
 when evaluation is done @emph{per frame}, and will evaluate to NAN
 when @option{eval} is set to @samp{init}.
@@ -10362,11 +11307,35 @@ expression, and vice versa.
 
 The default value of @var{x} and @var{y} is 0.
 
+If @var{x} or @var{y} evaluate to a negative number, they'll be changed
+so the input image is centered on the padded area.
+
 @item color
 Specify the color of the padded area. For the syntax of this option,
 check the "Color" section in the ffmpeg-utils manual.
 
 The default value of @var{color} is "black".
+
+@item eval
+Specify when to evaluate  @var{width}, @var{height}, @var{x} and @var{y} expression.
+
+It accepts the following values:
+
+@table @samp
+@item init
+Only evaluate expressions once during the filter initialization or when
+a command is processed.
+
+@item frame
+Evaluate expressions for each incoming frame.
+
+@end table
+
+Default value is @samp{init}.
+
+@item aspect
+Pad to aspect instead to a resolution.
+
 @end table
 
 The value for the @var{width}, @var{height}, @var{x}, and @var{y}
@@ -10740,6 +11709,36 @@ format=monow, pixdesctest
 
 can be used to test the monowhite pixel format descriptor definition.
 
+@section pixscope
+
+Display sample values of color channels. Mainly useful for checking color
+and levels. Minimum supported resolution is 640x480.
+
+The filters accept the following options:
+
+@table @option
+@item x
+Set scope X position, relative offset on X axis.
+
+@item y
+Set scope Y position, relative offset on Y axis.
+
+@item w
+Set scope width.
+
+@item h
+Set scope height.
+
+@item o
+Set window opacity. This window also holds statistics about pixel area.
+
+@item wx
+Set window X position, relative offset on X axis.
+
+@item wy
+Set window Y position, relative offset on Y axis.
+@end table
+
 @section pp
 
 Enable the specified chain of postprocessing subfilters using libpostproc. This
@@ -10941,6 +11940,23 @@ Set medium thresholding (good results, default).
 @end table
 @end table
 
+@section premultiply
+Apply alpha premultiply effect to input video stream using first plane
+of second stream as alpha.
+
+Both streams must have same dimensions and same pixel format.
+
+The filter accepts the following option:
+
+@table @option
+@item planes
+Set which planes will be processed, unprocessed planes will be copied.
+By default value 0xf, all planes will be processed.
+
+@item inplace
+Do not require 2nd input for processing, instead use alpha plane from input stream.
+@end table
+
 @section prewitt
 Apply prewitt operator to input video stream.
 
@@ -10958,6 +11974,61 @@ Set value which will be multiplied with filtered result.
 Set value which will be added to filtered result.
 @end table
 
+@section pseudocolor
+
+Alter frame colors in video with pseudocolors.
+
+This filter accept the following options:
+
+@table @option
+@item c0
+set pixel first component expression
+
+@item c1
+set pixel second component expression
+
+@item c2
+set pixel third component expression
+
+@item c3
+set pixel fourth component expression, corresponds to the alpha component
+
+@item i
+set component to use as base for altering colors
+@end table
+
+Each of them specifies the expression to use for computing the lookup table for
+the corresponding pixel component values.
+
+The expressions can contain the following constants and functions:
+
+@table @option
+@item w
+@item h
+The input width and height.
+
+@item val
+The input value for the pixel component.
+
+@item ymin, umin, vmin, amin
+The minimum allowed component value.
+
+@item ymax, umax, vmax, amax
+The maximum allowed component value.
+@end table
+
+All expressions default to "val".
+
+@subsection Examples
+
+@itemize
+@item
+Change too high luma values to gradient:
+@example
+pseudocolor="'if(between(val,ymax,amax),lerp(ymin,ymax,(val-ymax)/(amax-ymax)),-1):if(between(val,ymax,amax),lerp(umax,umin,(val-ymax)/(amax-ymax)),-1):if(between(val,ymax,amax),lerp(vmin,vmax,(val-ymax)/(amax-ymax)),-1):-1'"
+@end example
+@end itemize
+
 @section psnr
 
 Obtain the average, maximum and minimum PSNR (Peak Signal to Noise
@@ -11005,6 +12076,8 @@ Requires stats_version >= 2. If this is set and stats_version < 2,
 the filter will return an error.
 @end table
 
+This filter also supports the @ref{framesync} options.
+
 The file printed if @var{stats_file} is selected, contains a sequence of
 key/value pairs of the form @var{key}:@var{value} for each compared
 couple of frames.
@@ -11126,50 +12199,120 @@ Change video quantization parameters (QP).
 
 The filter accepts the following option:
 
-@table @option
-@item qp
-Set expression for quantization parameter.
-@end table
+@table @option
+@item qp
+Set expression for quantization parameter.
+@end table
+
+The expression is evaluated through the eval API and can contain, among others,
+the following constants:
+
+@table @var
+@item known
+1 if index is not 129, 0 otherwise.
+
+@item qp
+Sequential index starting from -129 to 128.
+@end table
+
+@subsection Examples
+
+@itemize
+@item
+Some equation like:
+@example
+qp=2+2*sin(PI*qp)
+@end example
+@end itemize
+
+@section random
+
+Flush video frames from internal cache of frames into a random order.
+No frame is discarded.
+Inspired by @ref{frei0r} nervous filter.
+
+@table @option
+@item frames
+Set size in number of frames of internal cache, in range from @code{2} to
+@code{512}. Default is @code{30}.
+
+@item seed
+Set seed for random number generator, must be an integer included between
+@code{0} and @code{UINT32_MAX}. If not specified, or if explicitly set to
+less than @code{0}, the filter will try to use a good random seed on a
+best effort basis.
+@end table
+
+@section readeia608
+
+Read closed captioning (EIA-608) information from the top lines of a video frame.
+
+This filter adds frame metadata for @code{lavfi.readeia608.X.cc} and
+@code{lavfi.readeia608.X.line}, where @code{X} is the number of the identified line
+with EIA-608 data (starting from 0). A description of each metadata value follows:
+
+@table @option
+@item lavfi.readeia608.X.cc
+The two bytes stored as EIA-608 data (printed in hexadecimal).
+
+@item lavfi.readeia608.X.line
+The number of the line on which the EIA-608 data was identified and read.
+@end table
+
+This filter accepts the following options:
+
+@table @option
+@item scan_min
+Set the line to start scanning for EIA-608 data. Default is @code{0}.
+
+@item scan_max
+Set the line to end scanning for EIA-608 data. Default is @code{29}.
+
+@item mac
+Set minimal acceptable amplitude change for sync codes detection.
+Default is @code{0.2}. Allowed range is @code{[0.001 - 1]}.
+
+@item spw
+Set the ratio of width reserved for sync code detection.
+Default is @code{0.27}. Allowed range is @code{[0.01 - 0.7]}.
+
+@item mhd
+Set the max peaks height difference for sync code detection.
+Default is @code{0.1}. Allowed range is @code{[0.0 - 0.5]}.
+
+@item mpd
+Set max peaks period difference for sync code detection.
+Default is @code{0.1}. Allowed range is @code{[0.0 - 0.5]}.
+
+@item msd
+Set the first two max start code bits differences.
+Default is @code{0.02}. Allowed range is @code{[0.0 - 0.5]}.
+
+@item bhd
+Set the minimum ratio of bits height compared to 3rd start code bit.
+Default is @code{0.75}. Allowed range is @code{[0.01 - 1]}.
 
-The expression is evaluated through the eval API and can contain, among others,
-the following constants:
+@item th_w
+Set the white color threshold. Default is @code{0.35}. Allowed range is @code{[0.1 - 1]}.
 
-@table @var
-@item known
-1 if index is not 129, 0 otherwise.
+@item th_b
+Set the black color threshold. Default is @code{0.15}. Allowed range is @code{[0.0 - 0.5]}.
 
-@item qp
-Sequentional index starting from -129 to 128.
+@item chp
+Enable checking the parity bit. In the event of a parity error, the filter will output
+@code{0x00} for that character. Default is false.
 @end table
 
 @subsection Examples
 
 @itemize
 @item
-Some equation like:
+Output a csv with presentation time and the first two lines of identified EIA-608 captioning data.
 @example
-qp=2+2*sin(PI*qp)
+ffprobe -f lavfi -i movie=captioned_video.mov,readeia608 -show_entries frame=pkt_pts_time:frame_tags=lavfi.readeia608.0.cc,lavfi.readeia608.1.cc -of csv
 @end example
 @end itemize
 
-@section random
-
-Flush video frames from internal cache of frames into a random order.
-No frame is discarded.
-Inspired by @ref{frei0r} nervous filter.
-
-@table @option
-@item frames
-Set size in number of frames of internal cache, in range from @code{2} to
-@code{512}. Default is @code{30}.
-
-@item seed
-Set seed for random number generator, must be an integer included between
-@code{0} and @code{UINT32_MAX}. If not specified, or if explicitly set to
-less than @code{0}, the filter will try to use a good random seed on a
-best effort basis.
-@end table
-
 @section readvitc
 
 Read vertical interval timecode (VITC) information from the top lines of a
@@ -11375,6 +12518,23 @@ trim=end=5,reverse
 @end example
 @end itemize
 
+@section roberts
+Apply roberts cross operator to input video stream.
+
+The filter accepts the following option:
+
+@table @option
+@item planes
+Set which planes will be processed, unprocessed planes will be copied.
+By default value 0xf, all planes will be processed.
+
+@item scale
+Set value which will be multiplied with filtered result.
+
+@item delta
+Set value which will be added to filtered result.
+@end table
+
 @section rotate
 
 Rotate video by an arbitrary angle expressed in radians.
@@ -11569,17 +12729,18 @@ the complete list of scaler options.
 Set the output video dimension expression. Default value is the input
 dimension.
 
-If the value is 0, the input width is used for the output.
+If the @var{width} or @var{w} value is 0, the input width is used for
+the output. If the @var{height} or @var{h} value is 0, the input height
+is used for the output.
 
-If one of the values is -1, the scale filter will use a value that
-maintains the aspect ratio of the input image, calculated from the
-other specified dimension. If both of them are -1, the input size is
-used
+If one and only one of the values is -n with n >= 1, the scale filter
+will use a value that maintains the aspect ratio of the input image,
+calculated from the other specified dimension. After that it will,
+however, make sure that the calculated dimension is divisible by n and
+adjust the value if necessary.
 
-If one of the values is -n with n > 1, the scale filter will also use a value
-that maintains the aspect ratio of the input image, calculated from the other
-specified dimension. After that it will, however, make sure that the calculated
-dimension is divisible by n and adjust the value if necessary.
+If both values are -n with n >= 1, the behavior will be identical to
+both values being set to 0 as previously detailed.
 
 See below for the list of accepted constants for use in the dimension
 expression.
@@ -11909,13 +13070,37 @@ Supersampling
 Scale (resize) the input video, based on a reference video.
 
 See the scale filter for available options, scale2ref supports the same but
-uses the reference video instead of the main input as basis.
+uses the reference video instead of the main input as basis. scale2ref also
+supports the following additional constants for the @option{w} and
+@option{h} options:
+
+@table @var
+@item main_w
+@item main_h
+The main input video's width and height
+
+@item main_a
+The same as @var{main_w} / @var{main_h}
+
+@item main_sar
+The main input video's sample aspect ratio
+
+@item main_dar, mdar
+The main input video's display aspect ratio. Calculated from
+@code{(main_w / main_h) * main_sar}.
+
+@item main_hsub
+@item main_vsub
+The main input video's horizontal and vertical chroma subsample values.
+For example for the pixel format "yuv422p" @var{hsub} is 2 and @var{vsub}
+is 1.
+@end table
 
 @subsection Examples
 
 @itemize
 @item
-Scale a subtitle stream to match the main video in size before overlaying
+Scale a subtitle stream (b) to match the main video (a) in size before overlaying
 @example
 'scale2ref[b][a];[a][b]overlay'
 @end example
@@ -12206,7 +13391,7 @@ Set the size of the box used to represent one palette color entry. Default is
 
 @section shuffleframes
 
-Reorder and/or duplicate video frames.
+Reorder and/or duplicate and/or drop video frames.
 
 It accepts the following parameters:
 
@@ -12215,6 +13400,7 @@ It accepts the following parameters:
 Set the destination indexes of input frames.
 This is space or '|' separated list of indexes that maps input frames to output
 frames. Number of indexes also sets maximal value that each index may have.
+'-1' index have special meaning and that is to drop frame.
 @end table
 
 The first frame has the index 0. The default is to keep the input unchanged.
@@ -12464,6 +13650,95 @@ saturation maximum: %@{metadata:lavfi.signalstats.SATMAX@}
 @end example
 @end itemize
 
+@anchor{signature}
+@section signature
+
+Calculates the MPEG-7 Video Signature. The filter can handle more than one
+input. In this case the matching between the inputs can be calculated additionally.
+The filter always passes through the first input. The signature of each stream can
+be written into a file.
+
+It accepts the following options:
+
+@table @option
+@item detectmode
+Enable or disable the matching process.
+
+Available values are:
+
+@table @samp
+@item off
+Disable the calculation of a matching (default).
+@item full
+Calculate the matching for the whole video and output whether the whole video
+matches or only parts.
+@item fast
+Calculate only until a matching is found or the video ends. Should be faster in
+some cases.
+@end table
+
+@item nb_inputs
+Set the number of inputs. The option value must be a non negative integer.
+Default value is 1.
+
+@item filename
+Set the path to which the output is written. If there is more than one input,
+the path must be a prototype, i.e. must contain %d or %0nd (where n is a positive
+integer), that will be replaced with the input number. If no filename is
+specified, no output will be written. This is the default.
+
+@item format
+Choose the output format.
+
+Available values are:
+
+@table @samp
+@item binary
+Use the specified binary representation (default).
+@item xml
+Use the specified xml representation.
+@end table
+
+@item th_d
+Set threshold to detect one word as similar. The option value must be an integer
+greater than zero. The default value is 9000.
+
+@item th_dc
+Set threshold to detect all words as similar. The option value must be an integer
+greater than zero. The default value is 60000.
+
+@item th_xh
+Set threshold to detect frames as similar. The option value must be an integer
+greater than zero. The default value is 116.
+
+@item th_di
+Set the minimum length of a sequence in frames to recognize it as matching
+sequence. The option value must be a non negative integer value.
+The default value is 0.
+
+@item th_it
+Set the minimum relation, that matching frames to all frames must have.
+The option value must be a double value between 0 and 1. The default value is 0.5.
+@end table
+
+@subsection Examples
+
+@itemize
+@item
+To calculate the signature of an input video and store it in signature.bin:
+@example
+ffmpeg -i input.mkv -vf signature=filename=signature.bin -map 0:v -f null -
+@end example
+
+@item
+To detect whether two videos match and store the signatures in XML format in
+signature0.xml and signature1.xml:
+@example
+ffmpeg -i input1.mkv -i input2.mkv -filter_complex "[0:v][1:v] signature=nb_inputs=2:detectmode=full:format=xml:filename=signature%d.xml" -map :v -f null -
+@end example
+
+@end itemize
+
 @anchor{smartblur}
 @section smartblur
 
@@ -12493,20 +13768,20 @@ in [-30,0] will filter edges. Default value is 0.
 @item chroma_radius, cr
 Set the chroma radius. The option value must be a float number in
 the range [0.1,5.0] that specifies the variance of the gaussian filter
-used to blur the image (slower if larger). Default value is 1.0.
+used to blur the image (slower if larger). Default value is @option{luma_radius}.
 
 @item chroma_strength, cs
 Set the chroma strength. The option value must be a float number
 in the range [-1.0,1.0] that configures the blurring. A value included
 in [0.0,1.0] will blur the image whereas a value included in
-[-1.0,0.0] will sharpen the image. Default value is 1.0.
+[-1.0,0.0] will sharpen the image. Default value is @option{luma_strength}.
 
 @item chroma_threshold, ct
 Set the chroma threshold used as a coefficient to determine
 whether a pixel should be blurred or not. The option value must be an
 integer in the range [-30,30]. A value of 0 will filter all the image,
 a value included in [0,30] will filter flat areas and a value included
-in [-30,0] will filter edges. Default value is 0.
+in [-30,0] will filter edges. Default value is @option{luma_threshold}.
 @end table
 
 If a chroma option is not explicitly set, the corresponding luma value
@@ -12556,6 +13831,8 @@ SSIM of the compared frames for the whole frame.
 Same as above but in dB representation.
 @end table
 
+This filter also supports the @ref{framesync} options.
+
 For example:
 @example
 movie=ref_movie.mpg, setpts=PTS-STARTPTS [main];
@@ -12893,6 +14170,9 @@ correctly scale the fonts if the aspect ratio has been changed.
 Set a directory path containing fonts that can be used by the filter.
 These fonts will be used in addition to whatever the font provider uses.
 
+@item alpha
+Process alpha channel, by default alpha channel is untouched.
+
 @item charenc
 Set subtitles input character encoding. @code{subtitles} filter only. Only
 useful if not UTF-8.
@@ -13038,6 +14318,63 @@ PAL output (25i):
 16p: 33333334
 @end example
 
+@section threshold
+
+Apply threshold effect to video stream.
+
+This filter needs four video streams to perform thresholding.
+First stream is stream we are filtering.
+Second stream is holding threshold values, third stream is holding min values,
+and last, fourth stream is holding max values.
+
+The filter accepts the following option:
+
+@table @option
+@item planes
+Set which planes will be processed, unprocessed planes will be copied.
+By default value 0xf, all planes will be processed.
+@end table
+
+For example if first stream pixel's component value is less then threshold value
+of pixel component from 2nd threshold stream, third stream value will picked,
+otherwise fourth stream pixel component value will be picked.
+
+Using color source filter one can perform various types of thresholding:
+
+@subsection Examples
+
+@itemize
+@item
+Binary threshold, using gray color as threshold:
+@example
+ffmpeg -i 320x240.avi -f lavfi -i color=gray -f lavfi -i color=black -f lavfi -i color=white -lavfi threshold output.avi
+@end example
+
+@item
+Inverted binary threshold, using gray color as threshold:
+@example
+ffmpeg -i 320x240.avi -f lavfi -i color=gray -f lavfi -i color=white -f lavfi -i color=black -lavfi threshold output.avi
+@end example
+
+@item
+Truncate binary threshold, using gray color as threshold:
+@example
+ffmpeg -i 320x240.avi -f lavfi -i color=gray -i 320x240.avi -f lavfi -i color=gray -lavfi threshold output.avi
+@end example
+
+@item
+Threshold to zero, using gray color as threshold:
+@example
+ffmpeg -i 320x240.avi -f lavfi -i color=gray -f lavfi -i color=white -i 320x240.avi -lavfi threshold output.avi
+@end example
+
+@item
+Inverted threshold to zero, using gray color as threshold:
+@example
+ffmpeg -i 320x240.avi -f lavfi -i color=gray -i 320x240.avi -f lavfi -i color=white -lavfi threshold output.avi
+@end example
+@end itemize
+
 @section thumbnail
 Select the most representative frame in a given sequence of consecutive frames.
 
@@ -13340,16 +14677,129 @@ Available value for @var{flags} is:
 
 @table @option
 @item low_pass_filter, vlfp
-Enable vertical low-pass filtering in the filter.
+Enable linear vertical low-pass filtering in the filter.
 Vertical low-pass filtering is required when creating an interlaced
 destination from a progressive source which contains high-frequency
 vertical detail. Filtering will reduce interlace 'twitter' and Moire
 patterning.
 
+@item complex_filter, cvlfp
+Enable complex vertical low-pass filtering.
+This will slightly less reduce interlace 'twitter' and Moire
+patterning but better retain detail and subjective sharpness impression.
+
+@end table
+
 Vertical low-pass filtering can only be enabled for @option{mode}
 @var{interleave_top} and @var{interleave_bottom}.
 
 @end table
+
+@section tonemap
+Tone map colors from different dynamic ranges.
+
+This filter expects data in single precision floating point, as it needs to
+operate on (and can output) out-of-range values. Another filter, such as
+@ref{zscale}, is needed to convert the resulting frame to a usable format.
+
+The tonemapping algorithms implemented only work on linear light, so input
+data should be linearized beforehand (and possibly correctly tagged).
+
+@example
+ffmpeg -i INPUT -vf zscale=transfer=linear,tonemap=clip,zscale=transfer=bt709,format=yuv420p OUTPUT
+@end example
+
+@subsection Options
+The filter accepts the following options.
+
+@table @option
+@item tonemap
+Set the tone map algorithm to use.
+
+Possible values are:
+@table @var
+@item none
+Do not apply any tone map, only desaturate overbright pixels.
+
+@item clip
+Hard-clip any out-of-range values. Use it for perfect color accuracy for
+in-range values, while distorting out-of-range values.
+
+@item linear
+Stretch the entire reference gamut to a linear multiple of the display.
+
+@item gamma
+Fit a logarithmic transfer between the tone curves.
+
+@item reinhard
+Preserve overall image brightness with a simple curve, using nonlinear
+contrast, which results in flattening details and degrading color accuracy.
+
+@item hable
+Preserve both dark and bright details better than @var{reinhard}, at the cost
+of slightly darkening everything. Use it when detail preservation is more
+important than color and brightness accuracy.
+
+@item mobius
+Smoothly map out-of-range values, while retaining contrast and colors for
+in-range material as much as possible. Use it when color accuracy is more
+important than detail preservation.
+@end table
+
+Default is none.
+
+@item param
+Tune the tone mapping algorithm.
+
+This affects the following algorithms:
+@table @var
+@item none
+Ignored.
+
+@item linear
+Specifies the scale factor to use while stretching.
+Default to 1.0.
+
+@item gamma
+Specifies the exponent of the function.
+Default to 1.8.
+
+@item clip
+Specify an extra linear coefficient to multiply into the signal before clipping.
+Default to 1.0.
+
+@item reinhard
+Specify the local contrast coefficient at the display peak.
+Default to 0.5, which means that in-gamut values will be about half as bright
+as when clipping.
+
+@item hable
+Ignored.
+
+@item mobius
+Specify the transition point from linear to mobius transform. Every value
+below this point is guaranteed to be mapped 1:1. The higher the value, the
+more accurate the result will be, at the cost of losing bright details.
+Default to 0.3, which due to the steep initial slope still preserves in-range
+colors fairly accurately.
+@end table
+
+@item desat
+Apply desaturation for highlights that exceed this level of brightness. The
+higher the parameter, the more color information will be preserved. This
+setting helps prevent unnaturally blown-out colors for super-highlights, by
+(smoothly) turning into white instead. This makes images feel more natural,
+at the cost of reducing information about out-of-range colors.
+
+The default of 2.0 is somewhat conservative and will mostly just apply to
+skies or directly sunlit surfaces. A setting of 0.0 disables this option.
+
+This option works only if the input frame has a supported color tag.
+
+@item peak
+Override signal/nominal/reference peak with this value. Useful when the
+embedded peak information in display metadata is not reliable or when tone
+mapping from a lower range to a higher range.
 @end table
 
 @section transpose
@@ -13498,6 +14948,28 @@ ffmpeg -i INPUT -vf trim=duration=1
 
 @end itemize
 
+@section unpremultiply
+Apply alpha unpremultiply effect to input video stream using first plane
+of second stream as alpha.
+
+Both streams must have same dimensions and same pixel format.
+
+The filter accepts the following option:
+
+@table @option
+@item planes
+Set which planes will be processed, unprocessed planes will be copied.
+By default value 0xf, all planes will be processed.
+
+If the format has 1 or 2 components, then luma is bit 0.
+If the format has 3 or 4 components:
+for RGB formats bit 0 is green, bit 1 is blue and bit 2 is red;
+for YUV formats bit 0 is luma, bit 1 is chroma-U and bit 2 is chroma-V.
+If present, the alpha channel is always the last bit.
+
+@item inplace
+Do not require 2nd input for processing, instead use alpha plane from input stream.
+@end table
 
 @anchor{unsharp}
 @section unsharp
@@ -13607,7 +15079,7 @@ This filter accepts the following options:
 @item threshold
 The filtering strength. The higher, the more filtered the video will be.
 Hard thresholding can use a higher threshold than soft thresholding
-before the video looks overfiltered.
+before the video looks overfiltered. Default value is 2.
 
 @item method
 The filtering method the filter will use.
@@ -13626,13 +15098,15 @@ Scales or nullifies coefficients - intermediary between (more) soft and
 (less) hard thresholding.
 @end table
 
+Default is garrote.
+
 @item nsteps
 Number of times, the wavelet will decompose the picture. Picture can't
 be decomposed beyond a particular point (typically, 8 for a 640x480
-frame - as 2^9 = 512 > 480)
+frame - as 2^9 = 512 > 480). Valid values are integers between 1 and 32. Default value is 6.
 
 @item percent
-Partial of full denoising (limited coefficients shrinking), from 0 to 100.
+Partial of full denoising (limited coefficients shrinking), from 0 to 100. Default value is 85.
 
 @item planes
 A list of the planes to process. By default all planes are processed.
@@ -14109,6 +15583,20 @@ vignette='PI/4+random(1)*PI/50':eval=frame
 
 @end itemize
 
+@section vmafmotion
+
+Obtain the average vmaf motion score of a video.
+It is one of the component filters of VMAF.
+
+The obtained average motion score is printed through the logging system.
+
+In the below example the input file @file{ref.mpg} is being processed and score
+is computed.
+
+@example
+ffmpeg -i ref.mpg -lavfi vmafmotion -f null -
+@end example
+
 @section vstack
 Stack input videos vertically.
 
@@ -14306,12 +15794,15 @@ Default is digital.
 Set background opacity.
 @end table
 
-@section weave
+@section weave, doubleweave
 
 The @code{weave} takes a field-based video input and join
 each two sequential fields into single frame, producing a new double
 height clip with half the frame rate and half the frame count.
 
+The @code{doubleweave} works same as @code{weave} but without
+halving frame rate and frame count.
+
 It accepts the following option:
 
 @table @option
@@ -14512,6 +16003,7 @@ zoompan=z='min(max(zoom,pzoom)+0.0015,1.5)':d=1:x='iw/2-(iw/zoom/2)':y='ih/2-(ih
 @end example
 @end itemize
 
+@anchor{zscale}
 @section zscale
 Scale (resize) the input video, using the z.lib library:
 https://github.com/sekrit-twc/zimg.
@@ -14532,18 +16024,18 @@ The filter accepts the following options.
 Set the output video dimension expression. Default value is the input
 dimension.
 
-If the @var{width} or @var{w} is 0, the input width is used for the output.
-If the @var{height} or @var{h} is 0, the input height is used for the output.
+If the @var{width} or @var{w} value is 0, the input width is used for
+the output. If the @var{height} or @var{h} value is 0, the input height
+is used for the output.
 
-If one of the values is -1, the zscale filter will use a value that
-maintains the aspect ratio of the input image, calculated from the
-other specified dimension. If both of them are -1, the input size is
-used
+If one and only one of the values is -n with n >= 1, the zscale filter
+will use a value that maintains the aspect ratio of the input image,
+calculated from the other specified dimension. After that it will,
+however, make sure that the calculated dimension is divisible by n and
+adjust the value if necessary.
 
-If one of the values is -n with n > 1, the zscale filter will also use a value
-that maintains the aspect ratio of the input image, calculated from the other
-specified dimension. After that it will, however, make sure that the calculated
-dimension is divisible by n and adjust the value if necessary.
+If both values are -n with n >= 1, the behavior will be identical to
+both values being set to 0 as previously detailed.
 
 See below for the list of accepted constants for use in the dimension
 expression.
@@ -14619,6 +16111,9 @@ Possible values are:
 @item linear
 @item 2020_10
 @item 2020_12
+@item smpte2084
+@item iec61966-2-1
+@item arib-std-b67
 @end table
 
 Default is same as input.
@@ -14723,6 +16218,9 @@ Possible values are:
 @item bottomleft
 @item bottom
 @end table
+
+@item npl
+Set the nominal peak luminance.
 @end table
 
 The values of the @option{w} and @option{h} options are expressions
@@ -15357,6 +16855,11 @@ The sources accept the following parameters:
 
 @table @option
 
+@item alpha
+Specify the alpha (opacity) of the background, only available in the
+@code{testsrc2} source. The value must be between 0 (fully transparent) and
+255 (fully opaque, the default).
+
 @item color, c
 Specify the color of the source, only available in the @code{color}
 source. For the syntax of this option, check the "Color" section in the
@@ -15467,6 +16970,28 @@ tools.
 
 Below is a description of the currently available multimedia filters.
 
+@section abitscope
+
+Convert input audio to a video output, displaying the audio bit scope.
+
+The filter accepts the following options:
+
+@table @option
+@item rate, r
+Set frame rate, expressed as number of frames per second. Default
+value is "25".
+
+@item size, s
+Specify the video size for the output. For the syntax of this option, check the
+@ref{video size syntax,,"Video size" section in the ffmpeg-utils manual,ffmpeg-utils}.
+Default value is @code{1024x256}.
+
+@item colors
+Specify list of colors separated by space or by '|' which will be used to
+draw channels. Unrecognized or missing colors will be replaced
+by white color.
+@end table
+
 @section ahistogram
 
 Convert input audio to a video output, displaying the volume histogram.
@@ -15570,6 +17095,9 @@ Allowed range is @code{[0, 255]}.
 @item mpc
 Set color which will be used for drawing median phase. If color is
 @code{none} which is default, no median phase value will be drawn.
+
+@item video
+Enable video output. Default is enabled.
 @end table
 
 The filter also exports the frame metadata @code{lavfi.aphasemeter.phase} which
@@ -15634,7 +17162,8 @@ Specify the red, green, blue and alpha fade. Default values are @code{15},
 Allowed range is @code{[0, 255]}.
 
 @item zoom
-Set the zoom factor. Default value is @code{1}. Allowed range is @code{[1, 10]}.
+Set the zoom factor. Default value is @code{1}. Allowed range is @code{[0, 10]}.
+Values lower than @var{1} will auto adjust zoom factor to maximal possible value.
 
 @item draw
 Set the vectorscope drawing mode.
@@ -16136,13 +17665,13 @@ Float representation of @code{value} from metadata key.
 
 @item VALUE2
 Float representation of @code{value} as supplied by user in @code{value} option.
+@end table
 
 @item file
 If specified in @code{print} mode, output is written to the named file. Instead of
 plain filename any writable url can be specified. Filename ``-'' is a shorthand
 for standard output. If @code{file} option is not set, output is written to the log
 with AV_LOG_INFO loglevel.
-@end table
 
 @end table
 
@@ -16208,7 +17737,7 @@ perms/aperms filter can avoid this problem.
 
 @section realtime, arealtime
 
-Slow down filtering to match real time approximatively.
+Slow down filtering to match real time approximately.
 
 These filters will pause the filtering for a variable amount of time to
 match the output rate with the input timestamps.
@@ -16540,6 +18069,12 @@ Specify audio tempo change at second 4:
 asendcmd=c='4.0 atempo tempo 1.5',atempo
 @end example
 
+@item
+Target a specific filter instance:
+@example
+asendcmd=c='4.0 atempo@@my tempo 1.5',atempo@@my
+@end example
+
 @item
 Specify a list of drawtext and hue commands in a file.
 @example
@@ -16835,12 +18370,21 @@ Acceptable range is @code{[1, 7]}.
 Specify the bargraph gamma. Default value is @code{1}. Acceptable range is
 @code{[1, 7]}.
 
+@item bar_t
+Specify the bargraph transparency level. Lower value makes the bargraph sharper.
+Default value is @code{1}. Acceptable range is @code{[0, 1]}.
+
 @item timeclamp, tc
 Specify the transform timeclamp. At low frequency, there is trade-off between
 accuracy in time domain and frequency domain. If timeclamp is lower,
 event in time domain is represented more accurately (such as fast bass drum),
 otherwise event in frequency domain is represented more accurately
-(such as bass guitar). Acceptable range is @code{[0.1, 1]}. Default value is @code{0.17}.
+(such as bass guitar). Acceptable range is @code{[0.002, 1]}. Default value is @code{0.17}.
+
+@item attack
+Set attack time in seconds. The default is @code{0} (disabled). Otherwise, it
+limits future samples by applying asymmetric windowing in time domain, useful
+when low latency is required. Accepted range is @code{[0, 1]}.
 
 @item basefreq
 Specify the transform base frequency. Default value is @code{20.01523126408007475},
@@ -17618,7 +19162,23 @@ Set if channels should be drawn separately or overlap. Default value is 0.
 Set colors separated by '|' which are going to be used for drawing of each channel.
 
 @item scale
-Set amplitude scale. Can be linear @code{lin} or logarithmic @code{log}.
+Set amplitude scale.
+
+Available values are:
+@table @samp
+@item lin
+Linear.
+
+@item log
+Logarithmic.
+
+@item sqrt
+Square root.
+
+@item cbrt
+Cubic root.
+@end table
+
 Default is linear.
 @end table
 
@@ -17885,7 +19445,7 @@ audio instead of video.
 
 @item loop
 Specifies how many times to read the stream in sequence.
-If the value is less than 1, the stream will be read again and again.
+If the value is 0, the stream will be looped infinitely.
 Default value is "1".
 
 Note that when the movie is looped the source timestamps are not
diff --git a/mythtv/external/FFmpeg/doc/formats.texi b/mythtv/external/FFmpeg/doc/formats.texi
index 5ef7fada0dc..ddd77435486 100644
--- a/mythtv/external/FFmpeg/doc/formats.texi
+++ b/mythtv/external/FFmpeg/doc/formats.texi
@@ -63,7 +63,7 @@ This ensures that file and data checksums are reproducible and match between
 platforms. Its primary use is for regression testing.
 @item shortest
 Stop muxing at the end of the shortest stream.
-It may be needed to increase max_interleave_delta to avoid flusing the longer
+It may be needed to increase max_interleave_delta to avoid flushing the longer
 streams before EOF.
 @end table
 
@@ -182,9 +182,10 @@ Default is 0.
 Correct single timestamp overflows if set to 1. Default is 1.
 
 @item flush_packets @var{integer} (@emph{output})
-Flush the underlying I/O stream after each packet. Default 1 enables it, and
-has the effect of reducing the latency; 0 disables it and may slightly
-increase performance in some cases.
+Flush the underlying I/O stream after each packet. Default is -1 (auto), which
+means that the underlying protocol will decide, 1 enables it, and has the
+effect of reducing the latency, 0 disables it and may increase IO throughput in
+some cases.
 
 @item output_ts_offset @var{offset} (@emph{output})
 Set the output time offset.
@@ -209,6 +210,10 @@ For example to separate the fields with newlines and indention:
 ffprobe -dump_separator "
                           "  -i ~/videos/matrixbench_mpeg2.mpg
 @end example
+
+@item max_streams @var{integer} (@emph{input})
+Specifies the maximum number of streams. This can be used to reject files that
+would require too many resources due to a large number of streams.
 @end table
 
 @c man end FORMAT OPTIONS
diff --git a/mythtv/external/FFmpeg/doc/general.texi b/mythtv/external/FFmpeg/doc/general.texi
index f08c3cd66cf..a40400612ea 100644
--- a/mythtv/external/FFmpeg/doc/general.texi
+++ b/mythtv/external/FFmpeg/doc/general.texi
@@ -101,6 +101,14 @@ Go to @url{http://www.wavpack.com/} and follow the instructions for
 installing the library. Then pass @code{--enable-libwavpack} to configure to
 enable it.
 
+@section libxavs
+
+FFmpeg can make use of the libxavs library for Xavs encoding.
+
+Go to @url{http://xavs.sf.net/} and follow the instructions for
+installing the library. Then pass @code{--enable-libxavs} to configure to
+enable it.
+
 @section OpenH264
 
 FFmpeg can make use of the OpenH264 library for H.264 encoding and decoding.
@@ -186,6 +194,19 @@ For Windows, supported AviSynth variants are
 For Linux and OS X, the supported AviSynth variant is
 @url{https://github.com/avxsynth/avxsynth, AvxSynth}.
 
+@float NOTE
+There is currently a regression in AviSynth+'s @code{capi.h} header as of
+October 2016, which interferes with the ability for builds of FFmpeg to use
+MSVC-built binaries of AviSynth. Until this is resolved, you can make sure
+a known good version is installed by checking out a version from before
+the regression occurred:
+
+@code{git clone -b MT git://github.com/AviSynth/AviSynthPlus.git @*
+cd AviSynthPlus @*
+git checkout -b oldheader b4f292b4dbfad149697fb65c6a037bb3810813f9 @*
+make install PREFIX=/install/prefix}
+@end float
+
 @float NOTE
 AviSynth and AvxSynth are loaded dynamically.  Distributors can build FFmpeg
 with @code{--enable-avisynth}, and the binaries will work regardless of the
@@ -320,6 +341,7 @@ library:
 @item FunCom ISS                @tab   @tab X
     @tab Audio format used in various games from FunCom like The Longest Journey.
 @item G.723.1                   @tab X @tab X
+@item G.726                     @tab   @tab X @tab Both left- and right-justified.
 @item G.729 BIT                 @tab X @tab X
 @item G.729 raw                 @tab   @tab X
 @item GENH                      @tab   @tab X
@@ -342,6 +364,7 @@ library:
 @item iLBC                      @tab X @tab X
 @item Interplay MVE             @tab   @tab X
     @tab Format used in various Interplay computer games.
+@item Iterated Systems ClearVideo @tab     @tab  X
 @item IV8                       @tab   @tab X
     @tab A format generated by IndigoVision 8000 video server.
 @item IVF (On2)                 @tab X @tab X
@@ -387,6 +410,7 @@ library:
     @tab Audio format used on the PS3.
 @item Mirillis FIC video        @tab   @tab X
     @tab No cursor rendering.
+@item MIDI Sample Dump Standard @tab   @tab X
 @item MIME multipart JPEG       @tab X @tab
 @item MSN TCP webcam            @tab   @tab X
     @tab Used by MSN Messenger webcam streams.
@@ -450,6 +474,8 @@ library:
 @item raw PCM signed 24 bit little-endian  @tab X @tab X
 @item raw PCM signed 32 bit big-endian  @tab X @tab X
 @item raw PCM signed 32 bit little-endian  @tab X @tab X
+@item raw PCM signed 64 bit big-endian  @tab X @tab X
+@item raw PCM signed 64 bit little-endian  @tab X @tab X
 @item raw PCM unsigned 8 bit    @tab X @tab X
 @item raw PCM unsigned 16 bit big-endian  @tab X @tab X
 @item raw PCM unsigned 16 bit little-endian  @tab X @tab X
@@ -457,6 +483,8 @@ library:
 @item raw PCM unsigned 24 bit little-endian  @tab X @tab X
 @item raw PCM unsigned 32 bit big-endian  @tab X @tab X
 @item raw PCM unsigned 32 bit little-endian  @tab X @tab X
+@item raw PCM 16.8 floating point little-endian @tab   @tab X
+@item raw PCM 24.0 floating point little-endian @tab   @tab X
 @item raw PCM floating-point 32 bit big-endian  @tab X @tab X
 @item raw PCM floating-point 32 bit little-endian  @tab X @tab X
 @item raw PCM floating-point 64 bit big-endian  @tab X @tab X
@@ -478,6 +506,7 @@ library:
     @tab Output is performed by publishing stream to RTMP server
 @item RTP                       @tab X @tab X
 @item RTSP                      @tab X @tab X
+@item Sample Dump eXchange      @tab   @tab X
 @item SAP                       @tab X @tab X
 @item SBG                       @tab   @tab X
 @item SDP                       @tab   @tab X
@@ -492,6 +521,7 @@ library:
     @tab Multimedia format used by many games.
 @item SMJPEG                    @tab X @tab X
     @tab Used in certain Loki game ports.
+@item SMPTE 337M encapsulation  @tab   @tab X
 @item Smush                     @tab   @tab X
     @tab Multimedia format used in some LucasArts games.
 @item Sony OpenMG (OMA)         @tab X @tab X
@@ -500,7 +530,7 @@ library:
 @item Sony Wave64 (W64)         @tab X @tab X
 @item SoX native format         @tab X @tab X
 @item SUN AU format             @tab X @tab X
-@item SUP raw PGS subtitles     @tab   @tab X
+@item SUP raw PGS subtitles     @tab X @tab X
 @item SVAG                      @tab   @tab X
     @tab Audio format used in Konami PS2 games.
 @item TDSC                      @tab   @tab X
@@ -563,6 +593,8 @@ following image formats are supported:
     @tab Digital Picture Exchange
 @item EXR          @tab   @tab X
     @tab OpenEXR
+@item FITS         @tab X @tab X
+    @tab Flexible Image Transport System
 @item JPEG         @tab X @tab X
     @tab Progressive JPEG is not supported.
 @item JPEG 2000    @tab X @tab X
@@ -584,6 +616,8 @@ following image formats are supported:
 @item PNG          @tab X @tab X
 @item PPM          @tab X @tab X
     @tab Portable PixelMap image
+@item PSD          @tab   @tab X
+    @tab Photoshop
 @item PTX          @tab   @tab X
     @tab V.Flash PTX format
 @item SGI          @tab X @tab X
@@ -600,6 +634,8 @@ following image formats are supported:
     @tab X BitMap image format
 @item XFace @tab X @tab X
     @tab X-Face image format
+@item XPM  @tab   @tab X
+    @tab X PixMap image format
 @item XWD  @tab X @tab X
     @tab X Window Dump image format
 @end multitable
@@ -625,6 +661,7 @@ following image formats are supported:
 @item ANSI/ASCII art         @tab     @tab  X
 @item Apple Intermediate Codec @tab     @tab  X
 @item Apple MJPEG-B          @tab     @tab  X
+@item Apple Pixlet           @tab     @tab  X
 @item Apple ProRes           @tab  X  @tab  X
 @item Apple QuickDraw        @tab     @tab  X
     @tab fourcc: qdrw
@@ -678,7 +715,7 @@ following image formats are supported:
 @item DFA                    @tab     @tab  X
     @tab Codec used in Chronomaster game.
 @item Dirac                  @tab  E  @tab  X
-    @tab supported through external library libschroedinger
+    @tab supported though the native vc2 (Dirac Pro) encoder
 @item Deluxe Paint Animation @tab     @tab  X
 @item DNxHD                  @tab   X @tab  X
     @tab aka SMPTE VC3
@@ -707,6 +744,7 @@ following image formats are supported:
 @item Flash Screen Video v2  @tab  X  @tab  X
 @item Flash Video (FLV)      @tab  X  @tab  X
     @tab Sorenson H.263 used in Flash
+@item FM Screen Capture Codec  @tab     @tab  X
 @item Forward Uncompressed   @tab     @tab  X
 @item Fraps                  @tab     @tab  X
 @item Go2Meeting             @tab     @tab  X
@@ -755,6 +793,7 @@ following image formats are supported:
     @tab Used in LucasArts games / SMUSH animations.
 @item lossless MJPEG         @tab  X  @tab  X
 @item MagicYUV Video         @tab     @tab  X
+@item Mandsoft Screen Capture Codec  @tab     @tab  X
 @item Microsoft ATC Screen   @tab     @tab  X
     @tab Also known as Microsoft Screen 3.
 @item Microsoft Expression Encoder Screen  @tab     @tab  X
@@ -779,6 +818,7 @@ following image formats are supported:
 @item MPEG-4 part 2 Microsoft variant version 1  @tab     @tab  X
 @item MPEG-4 part 2 Microsoft variant version 2  @tab  X  @tab  X
 @item MPEG-4 part 2 Microsoft variant version 3  @tab  X  @tab  X
+@item Newtek SpeedHQ               @tab     @tab  X
 @item Nintendo Gamecube THP video  @tab     @tab  X
 @item NuppelVideo/RTjpeg     @tab     @tab  X
     @tab Video encoding used in NuppelVideo files.
@@ -819,7 +859,9 @@ following image formats are supported:
     @tab Texture dictionaries used by the Renderware Engine.
 @item RL2 video              @tab     @tab  X
     @tab used in some games by Entertainment Software Partners
+@item ScreenPressor          @tab     @tab  X
 @item Screenpresso           @tab     @tab  X
+@item Screen Recorder Gold Codec  @tab     @tab  X
 @item Sierra VMD video       @tab     @tab  X
     @tab Used in Sierra VMD files.
 @item Silicon Graphics Motion Video Compressor 1 (MVC1)  @tab     @tab  X
@@ -963,6 +1005,7 @@ following image formats are supported:
     @tab All versions except 5.1 are supported.
 @item DCA (DTS Coherent Acoustics)  @tab  X  @tab  X
     @tab supported extensions: XCh, XXCH, X96, XBR, XLL, LBR (partially)
+@item Dolby E  @tab     @tab  X
 @item DPCM id RoQ            @tab  X  @tab  X
     @tab Used in Quake III, Jedi Knight 2 and other computer games.
 @item DPCM Interplay         @tab     @tab  X
@@ -1041,6 +1084,7 @@ following image formats are supported:
 @item PCM unsigned 32-bit little-endian  @tab  X  @tab  X
 @item PCM Zork               @tab     @tab  X
 @item QCELP / PureVoice      @tab     @tab  X
+@item QDesign Music Codec 1  @tab     @tab  X
 @item QDesign Music Codec 2  @tab     @tab  X
     @tab There are still some distortions.
 @item RealAudio 1.0 (14.4K)  @tab  X  @tab  X
@@ -1137,6 +1181,7 @@ performance on systems without hardware floating point support).
 @item MMSH         @tab X
 @item MMST         @tab X
 @item pipe         @tab X
+@item Pro-MPEG FEC @tab X
 @item RTMP         @tab X
 @item RTMPE        @tab X
 @item RTMPS        @tab X
diff --git a/mythtv/external/FFmpeg/doc/indevs.texi b/mythtv/external/FFmpeg/doc/indevs.texi
index 54f270b0dce..55a4084bb22 100644
--- a/mythtv/external/FFmpeg/doc/indevs.texi
+++ b/mythtv/external/FFmpeg/doc/indevs.texi
@@ -68,7 +68,6 @@ Set the number of channels. Default is 2.
 AVFoundation input device.
 
 AVFoundation is the currently recommended framework by Apple for streamgrabbing on OSX >= 10.7 as well as on iOS.
-The older QTKit framework has been marked deprecated since OSX version 10.7.
 
 The input filename has to be given in the following syntax:
 @example
@@ -215,8 +214,9 @@ need to configure with the appropriate @code{--extra-cflags}
 and @code{--extra-ldflags}.
 On Windows, you need to run the IDL files through @command{widl}.
 
-DeckLink is very picky about the formats it supports. Pixel format is
-uyvy422 or v210, framerate and video size must be determined for your device with
+DeckLink is very picky about the formats it supports. Pixel format of the
+input can be set with @option{raw_format}.
+Framerate and video size must be determined for your device with
 @command{-list_formats 1}. Audio sample rate is always 48 kHz and the number
 of channels can be 2, 8 or 16. Note that all audio channels are bundled in one single
 audio track.
@@ -233,19 +233,48 @@ Defaults to @option{false}.
 If set to @option{true}, print a list of supported formats and exit.
 Defaults to @option{false}.
 
+@item format_code <FourCC>
+This sets the input video format to the format given by the FourCC. To see
+the supported values of your device(s) use @option{list_formats}.
+Note that there is a FourCC @option{'pal '} that can also be used
+as @option{pal} (3 letters).
+
 @item bm_v210
+This is a deprecated option, you can use @option{raw_format} instead.
 If set to @samp{1}, video is captured in 10 bit v210 instead
 of uyvy422. Not all Blackmagic devices support this option.
 
+@item raw_format
+Set the pixel format of the captured video.
+Available values are:
+@table @samp
+@item uyvy422
+
+@item yuv422p10
+
+@item argb
+
+@item bgra
+
+@item rgb10
+
+@end table
+
 @item teletext_lines
 If set to nonzero, an additional teletext stream will be captured from the
-vertical ancillary data. This option is a bitmask of the VBI lines checked,
-specifically lines 6 to 22, and lines 318 to 335. Line 6 is the LSB in the mask.
-Selected lines which do not contain teletext information will be ignored. You
-can use the special @option{all} constant to select all possible lines, or
-@option{standard} to skip lines 6, 318 and 319, which are not compatible with all
-receivers. Capturing teletext only works for SD PAL sources in 8 bit mode.
-To use this option, ffmpeg needs to be compiled with @code{--enable-libzvbi}.
+vertical ancillary data. Both SD PAL (576i) and HD (1080i or 1080p)
+sources are supported. In case of HD sources, OP47 packets are decoded.
+
+This option is a bitmask of the SD PAL VBI lines captured, specifically lines 6
+to 22, and lines 318 to 335. Line 6 is the LSB in the mask. Selected lines
+which do not contain teletext information will be ignored. You can use the
+special @option{all} constant to select all possible lines, or
+@option{standard} to skip lines 6, 318 and 319, which are not compatible with
+all receivers.
+
+For SD sources, ffmpeg needs to be compiled with @code{--enable-libzvbi}. For
+HD sources, on older (pre-4K) DeckLink card models you have to capture in 10
+bit mode.
 
 @item channels
 Defines number of audio channels to capture. Must be @samp{2}, @samp{8} or @samp{16}.
@@ -277,6 +306,11 @@ Sets the audio packet timestamp source. Must be @samp{video}, @samp{audio},
 If set to @samp{true}, color bars are drawn in the event of a signal loss.
 Defaults to @samp{true}.
 
+@item queue_size
+Sets maximum input buffer size in bytes. If the buffering reaches this value,
+incoming frames will be dropped.
+Defaults to @samp{1073741824}.
+
 @end table
 
 @subsection Examples
@@ -296,21 +330,131 @@ ffmpeg -f decklink -list_formats 1 -i 'Intensity Pro'
 @end example
 
 @item
-Capture video clip at 1080i50 (format 11):
+Capture video clip at 1080i50:
 @example
-ffmpeg -f decklink -i 'Intensity Pro@@11' -acodec copy -vcodec copy output.avi
+ffmpeg -format_code Hi50 -f decklink -i 'Intensity Pro' -c:a copy -c:v copy output.avi
 @end example
 
 @item
 Capture video clip at 1080i50 10 bit:
 @example
-ffmpeg -bm_v210 1 -f decklink -i 'UltraStudio Mini Recorder@@11' -acodec copy -vcodec copy output.avi
+ffmpeg -bm_v210 1 -format_code Hi50 -f decklink -i 'UltraStudio Mini Recorder' -c:a copy -c:v copy output.avi
 @end example
 
 @item
 Capture video clip at 1080i50 with 16 audio channels:
 @example
-ffmpeg -channels 16 -f decklink -i 'UltraStudio Mini Recorder@@11' -acodec copy -vcodec copy output.avi
+ffmpeg -channels 16 -format_code Hi50 -f decklink -i 'UltraStudio Mini Recorder' -c:a copy -c:v copy output.avi
+@end example
+
+@end itemize
+
+@section kmsgrab
+
+KMS video input device.
+
+Captures the KMS scanout framebuffer associated with a specified CRTC or plane as a
+DRM object that can be passed to other hardware functions.
+
+Requires either DRM master or CAP_SYS_ADMIN to run.
+
+If you don't understand what all of that means, you probably don't want this.  Look at
+@option{x11grab} instead.
+
+@subsection Options
+
+@table @option
+
+@item device
+DRM device to capture on.  Defaults to @option{/dev/dri/card0}.
+
+@item format
+Pixel format of the framebuffer.  Defaults to @option{bgr0}.
+
+@item format_modifier
+Format modifier to signal on output frames.  This is necessary to import correctly into
+some APIs, but can't be autodetected.  See the libdrm documentation for possible values.
+
+@item crtc_id
+KMS CRTC ID to define the capture source.  The first active plane on the given CRTC
+will be used.
+
+@item plane_id
+KMS plane ID to define the capture source.  Defaults to the first active plane found if
+neither @option{crtc_id} nor @option{plane_id} are specified.
+
+@item framerate
+Framerate to capture at.  This is not synchronised to any page flipping or framebuffer
+changes - it just defines the interval at which the framebuffer is sampled.  Sampling
+faster than the framebuffer update rate will generate independent frames with the same
+content.  Defaults to @code{30}.
+
+@end table
+
+@subsection Examples
+
+@itemize
+
+@item
+Capture from the first active plane, download the result to normal frames and encode.
+This will only work if the framebuffer is both linear and mappable - if not, the result
+may be scrambled or fail to download.
+@example
+ffmpeg -f kmsgrab -i - -vf 'hwdownload,format=bgr0' output.mp4
+@end example
+
+@item
+Capture from CRTC ID 42 at 60fps, map the result to VAAPI, convert to NV12 and encode as H.264.
+@example
+ffmpeg -crtc_id 42 -framerate 60 -f kmsgrab -i - -vf 'hwmap=derive_device=vaapi,scale_vaapi=w=1920:h=1080:format=nv12' -c:v h264_vaapi output.mp4
+@end example
+
+@end itemize
+
+@section libndi_newtek
+
+The libndi_newtek input device provides capture capabilities for using NDI (Network
+Device Interface, standard created by NewTek).
+
+Input filename is a NDI source name that could be found by sending -find_sources 1
+to command line - it has no specific syntax but human-readable formatted.
+
+To enable this input device, you need the NDI SDK and you
+need to configure with the appropriate @code{--extra-cflags}
+and @code{--extra-ldflags}.
+
+@subsection Options
+
+@table @option
+
+@item find_sources
+If set to @option{true}, print a list of found/available NDI sources and exit.
+Defaults to @option{false}.
+
+@item wait_sources
+Override time to wait until the number of online sources have changed.
+Defaults to @option{0.5}.
+
+@item allow_video_fields
+When this flag is @option{false}, all video that you receive will be progressive.
+Defaults to @option{true}.
+
+@end table
+
+@subsection Examples
+
+@itemize
+
+@item
+List input devices:
+@example
+ffmpeg -f libndi_newtek -find_sources 1 -i dummy
+@end example
+
+@item
+Restream to NDI:
+@example
+ffmpeg -f libndi_newtek -i "DEV-5.INTERNAL.M1STEREO.TV (NDI_SOURCE_NAME_1)" -f libndi_newtek -y NDI_SOURCE_NAME_2
 @end example
 
 @end itemize
@@ -515,31 +659,6 @@ $ ffmpeg -f dshow -show_video_device_dialog true -crossbar_video_input_pin_numbe
 
 @end itemize
 
-@section dv1394
-
-Linux DV 1394 input device.
-
-@subsection Options
-
-@table @option
-
-@item framerate
-Set the frame rate. Default is 25.
-
-@item standard
-
-Available values are:
-@table @samp
-@item pal
-
-@item ntsc
-
-@end table
-
-Default value is @code{ntsc}.
-
-@end table
-
 @section fbdev
 
 Linux framebuffer input device.
@@ -1076,49 +1195,6 @@ Record a stream from default device:
 ffmpeg -f pulse -i default /tmp/pulse.wav
 @end example
 
-@section qtkit
-
-QTKit input device.
-
-The filename passed as input is parsed to contain either a device name or index.
-The device index can also be given by using -video_device_index.
-A given device index will override any given device name.
-If the desired device consists of numbers only, use -video_device_index to identify it.
-The default device will be chosen if an empty string  or the device name "default" is given.
-The available devices can be enumerated by using -list_devices.
-
-@example
-ffmpeg -f qtkit -i "0" out.mpg
-@end example
-
-@example
-ffmpeg -f qtkit -video_device_index 0 -i "" out.mpg
-@end example
-
-@example
-ffmpeg -f qtkit -i "default" out.mpg
-@end example
-
-@example
-ffmpeg -f qtkit -list_devices true -i ""
-@end example
-
-@subsection Options
-
-@table @option
-
-@item frame_rate
-Set frame rate. Default is 30.
-
-@item list_devices
-If set to @code{true}, print a list of devices and exit. Default is
-@code{false}.
-
-@item video_device_index
-Select the video device by index for devices with the same name (starts at 0).
-
-@end table
-
 @section sndio
 
 sndio input device.
@@ -1305,9 +1381,6 @@ To enable this input device during configuration you need libxcb
 installed on your system. It will be automatically detected during
 configuration.
 
-Alternatively, the configure option @option{--enable-x11grab} exists
-for legacy Xlib users.
-
 This device allows one to capture a region of an X11 display.
 
 The filename passed as input has the syntax:
@@ -1395,11 +1468,6 @@ ffmpeg -f x11grab -follow_mouse centered -show_region 1 -framerate 25 -video_siz
 @item video_size
 Set the video frame size. Default value is @code{vga}.
 
-@item use_shm
-Use the MIT-SHM extension for shared memory. Default value is @code{1}.
-It may be necessary to disable it for remote displays (legacy x11grab
-only).
-
 @item grab_x
 @item grab_y
 Set the grabbing region coordinates. They are expressed as offset from
diff --git a/mythtv/external/FFmpeg/doc/lexicon b/mythtv/external/FFmpeg/doc/lexicon
new file mode 100644
index 00000000000..e596ab1b4ca
--- /dev/null
+++ b/mythtv/external/FFmpeg/doc/lexicon
@@ -0,0 +1,27 @@
+Common abbreviations/shorthands we use that don't need a comment
+================================================================
+
+dsp: digital signal processing
+dst/adst: (asymmetric) discrete sine transform
+ec: entropy coding or error concealment
+er: error resilience
+fdct/idct: forward/inverse discrete cosine transform
+fft: fast Fourier transform
+gop: group of pictures
+hw/sw: hardware/software
+lp: lowpass
+lpf: loop filter
+lut: lookup table
+mb: macroblock
+mc: motion compensation
+me: motion estimation
+mv: motion vector
+nal: network abstraction layer
+pel/qpel/epel/hpel/fpel: pixel / quarter-pixel / eighth-pixel / half-pixel / full-pixel
+pp: post process
+qp: quantization parameter
+rc: rate control
+sei: supplemental enhancement information
+sl: slice
+vlc: variable length coding
+vq: vector quantization
diff --git a/mythtv/external/FFmpeg/doc/libav-merge.txt b/mythtv/external/FFmpeg/doc/libav-merge.txt
index 962a98b1f8a..4a46bfcf464 100644
--- a/mythtv/external/FFmpeg/doc/libav-merge.txt
+++ b/mythtv/external/FFmpeg/doc/libav-merge.txt
@@ -88,11 +88,29 @@ Stuff that didn't reach the codebase:
 -------------------------------------
 
 - HEVC DSP and x86 MC SIMD improvements from Libav (see https://ffmpeg.org/pipermail/ffmpeg-devel/2015-December/184777.html)
-- QSV HWContext integration (04b17ff and 130e1f1), QSV scaling filter (62c58c5)
+  - 1f821750f hevcdsp: split the qpel functions by width instead of by the subpixel fraction
+  - 818bfe7f0 hevcdsp: split the epel functions by width
+  - 688417399 hevcdsp: split the pred functions by width
+  - a853388d2 hevc: change the stride of the MC buffer to be in bytes instead of elements
+  - 0cef06df0 checkasm: add HEVC MC tests
+  - e7078e842 hevcdsp: add x86 SIMD for MC
+- VAAPI VP8 decode hwaccel (currently under review: http://ffmpeg.org/pipermail/ffmpeg-devel/2017-February/thread.html#207348)
+- Removal of the custom atomic API (5cc0057f49, see http://ffmpeg.org/pipermail/ffmpeg-devel/2017-March/209003.html)
+- new bitstream reader (see http://ffmpeg.org/pipermail/ffmpeg-devel/2017-April/209609.html)
+- use of the bsf instead of our parser for vp9 superframes (see fa1749dd34)
+- use av_cpu_max_align() instead of hardcoding alignment requirements (see https://ffmpeg.org/pipermail/ffmpeg-devel/2017-September/215834.html)
+  - f44ec22e0 lavc: use av_cpu_max_align() instead of hardcoding alignment requirements
+  - 4de220d2e frame: allow align=0 (meaning automatic) for av_frame_get_buffer()
 
 Collateral damage that needs work locally:
 ------------------------------------------
 
 - Merge proresdec2.c and proresdec_lgpl.c
 - Merge proresenc_anatoliy.c and proresenc_kostya.c
-- Remove ADVANCED_PARSER in libavcodec/hevc_parser.c
+- Fix MIPS AC3 downmix
+
+Extra changes needed to be aligned with Libav:
+----------------------------------------------
+
+- Switching our examples to the new encode/decode API (see 67d28f4a0f)
+- HEVC IDCT bit depth 12-bit support (Libav added 8 and 10 but doesn't have 12)
diff --git a/mythtv/external/FFmpeg/doc/mailing-list-faq.texi b/mythtv/external/FFmpeg/doc/mailing-list-faq.texi
new file mode 100644
index 00000000000..fe2171e42e8
--- /dev/null
+++ b/mythtv/external/FFmpeg/doc/mailing-list-faq.texi
@@ -0,0 +1,366 @@
+\input texinfo @c -*- texinfo -*-
+@documentencoding UTF-8
+
+@settitle FFmpeg Mailing List FAQ
+@titlepage
+@center @titlefont{FFmpeg Mailing List FAQ}
+@end titlepage
+
+@top
+
+@contents
+
+@chapter General Questions
+
+@section What is a mailing list?
+
+A mailing list is not much different than emailing someone, but the
+main difference is that your message is received by everyone who
+subscribes to the list. It is somewhat like a forum but in email form.
+
+See the @url{https://lists.ffmpeg.org/pipermail/ffmpeg-user/, ffmpeg-user archives}
+for examples.
+
+@section What type of questions can I ask?
+
+@itemize
+@item
+@url{https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-user/, ffmpeg-user}:
+For questions involving unscripted usage or compilation of the FFmpeg
+command-line tools (@command{ffmpeg}, @command{ffprobe}, @command{ffplay},
+@command{ffserver}).
+
+@item
+@url{https://lists.ffmpeg.org/mailman/listinfo/libav-user/, libav-user}:
+For questions involving the FFmpeg libav* libraries (libavcodec,
+libavformat, libavfilter, etc).
+
+@item
+@url{https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-devel/, ffmpeg-devel}:
+For discussions involving the development of FFmpeg and for submitting
+patches. User questions should be asked at ffmpeg-user or libav-user.
+@end itemize
+
+To report a bug see @url{https://ffmpeg.org/bugreports.html}.
+
+We cannot provide help for scripts and/or third-party tools.
+
+@anchor{How do I ask a question or send a message to a mailing list?}
+@section How do I ask a question or send a message to a mailing list?
+
+All you have to do is send an email:
+
+@itemize
+@item
+Email @email{ffmpeg-user@@ffmpeg.org} to send a message to the
+ffmpeg-user mailing list.
+
+@item
+Email @email{libav-user@@ffmpeg.org} to send a message to the
+libav-user mailing list.
+@end itemize
+
+If you are not subscribed to the mailing list then your question must be
+manually approved. Approval may take several days, but the wait is
+usually less. If you want the message to be sent with no delay then you
+must subscribe first. See @ref{How do I subscribe?}
+
+Please do not send a message, subscribe, and re-send the message: this
+results in duplicates, causes more work for the admins, and may lower
+your chance at getting an answer. However, you may do so if you first
+@ref{How do I delete my message in the moderation queue?, delete your original message from the moderation queue}.
+
+@chapter Subscribing / Unsubscribing
+
+@section What does subscribing do?
+
+Subscribing allows two things:
+
+@itemize
+@item
+Your messages will show up in the mailing list without waiting in the
+moderation queue and needing to be manually approved by a mailing list
+admin.
+
+@item
+You will receive all messages to the mailing list including replies to
+your messages. Non-subscribed users do not receive any messages.
+@end itemize
+
+@section Do I need to subscribe?
+
+No. You can still send a message to the mailing list without
+subscribing. See @ref{How do I ask a question or send a message to a mailing list?}
+
+However, your message will need to be manually approved by a mailing
+list admin, and you will not receive any mailing list messages or
+replies.
+
+You can ask to be CCd in your message, but replying users will
+sometimes forget to do so.
+
+You may also view and reply to messages via the @ref{Where are the archives?, archives}.
+
+@anchor{How do I subscribe?}
+@section How do I subscribe?
+
+Email @email{ffmpeg-user-request@@ffmpeg.org} with the subject
+@emph{subscribe}.
+
+Or visit the @url{https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-user/, ffmpeg-user mailing list info page}
+and refer to the @emph{Subscribing to ffmpeg-user} section.
+
+The process is the same for the other mailing lists.
+
+@section How do I unsubscribe?
+
+Email @email{ffmpeg-user-request@@ffmpeg.org} with subject @emph{unsubscribe}.
+
+Or visit the @url{https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-user/, ffmpeg-user mailing list info page},
+scroll to bottom of page, enter your email address in the box, and click
+the @emph{Unsubscribe or edit options} button.
+
+The process is the same for the other mailing lists.
+
+Please avoid asking a mailing list admin to unsubscribe you unless you
+are absolutely unable to do so by yourself. See @ref{Who do I contact if I have a problem with the mailing list?}
+
+@chapter Moderation Queue
+@anchor{Why is my message awaiting moderator approval?}
+@section Why is my message awaiting moderator approval?
+
+Some messages are automatically held in the @emph{moderation queue} and
+must be manually approved by a mailing list admin:
+
+These are:
+
+@itemize
+@item
+Messages from users who are @strong{not} subscribed.
+
+@item
+Messages that exceed the @ref{What is the message size limit?, message size limit}.
+
+@item
+Messages from users whose accounts have been set with the @emph{moderation flag}
+(very rarely occurs, but may if a user repeatedly ignores the rules
+or is abusive towards others).
+@end itemize
+
+@section How long does it take for my message in the moderation queue to be approved?
+
+The queue is usually checked once or twice a day, but on occasion
+several days may pass before someone checks the queue.
+
+@anchor{How do I delete my message in the moderation queue?}
+@section How do I delete my message in the moderation queue?
+
+You should have received an email with the subject @emph{Your message to ffmpeg-user awaits moderator approval}.
+A link is in the message that will allow you to delete your message
+unless a mailing list admin already approved or rejected it.
+
+@chapter Archives
+
+@anchor{Where are the archives?}
+@section Where are the archives?
+
+See the @emph{Archives} section on the @url{https://ffmpeg.org/contact.html, FFmpeg Contact}
+page for links to all FFmpeg mailing list archives.
+
+Note that the archives are split by month. Discussions that span
+several months will be split into separate months in the archives.
+
+@section How do I reply to a message in the archives?
+
+Click the email link at the top of the message just under the subject
+title. The link will provide the proper headers to keep the message
+within the thread.
+
+@section How do I search the archives?
+
+Perform a site search using your favorite search engine. Example:
+
+@t{site:lists.ffmpeg.org/pipermail/ffmpeg-user/ "search term"}
+
+@chapter Other
+
+@section Is there an alternative to the mailing list?
+
+You can ask for help in the official @t{#ffmpeg} IRC channel on Freenode.
+
+Some users prefer the third-party Nabble interface which presents the
+mailing lists in a typical forum layout.
+
+There are also numerous third-party help sites such as Super User and
+r/ffmpeg on reddit.
+
+@anchor{What is top-posting?}
+@section What is top-posting?
+
+See @url{https://en.wikipedia.org/wiki/Posting_style#Top-posting}.
+
+Instead, use trimmed interleaved/inline replies (@url{https://lists.ffmpeg.org/pipermail/ffmpeg-user/2017-April/035849.html, example}).
+
+@anchor{What is the message size limit?}
+@section What is the message size limit?
+
+The message size limit is 500 kilobytes for the user lists and 1000
+kilobytes for ffmpeg-devel. Please provide links to larger files instead
+of attaching them.
+
+@section Where can I upload sample files?
+
+Anywhere that is not too annoying for us to use.
+
+Google Drive and Dropbox are acceptable if you need a file host, and
+0x0.st is good for files under 256 MiB.
+
+Small, short samples are preferred if possible.
+
+@section Will I receive spam if I send and/or subscribe to a mailing list?
+
+Highly unlikely.
+
+@itemize
+@item
+The list of subscribed users is not public.
+
+@item
+Email addresses in the archives are obfuscated.
+
+@item
+Several unique test email accounts were utilized and none have yet
+received any spam.
+@end itemize
+
+However, you may see a spam in the mailing lists on rare occasions:
+
+@itemize
+@item
+Spam in the moderation queue may be accidentally approved due to human
+error.
+
+@item
+There have been a few messages from subscribed users who had their own
+email addresses hacked and spam messages from (or appearing to be from)
+the hacked account were sent to their contacts (a mailing list being a
+contact in these cases).
+
+@item
+If you are subscribed to the bug tracker mailing list (ffmpeg-trac) you
+may see the occasional spam as a false bug report, but we take measures
+to try to prevent this.
+@end itemize
+
+@section How do I filter mailing list messages?
+
+Use the @emph{List-Id}. For example, the ffmpeg-user mailing list is
+@t{ffmpeg-user.ffmpeg.org}. You can view the List-Id in the raw message
+or headers.
+
+You can then filter the mailing list messages to their own folder.
+
+@chapter Rules and Etiquette
+
+@section What are the rules and the proper etiquette?
+
+There may seem to be many things to remember, but we want to help and
+following these guidelines will allow you to get answers more quickly
+and help avoid getting ignored.
+
+@itemize
+@item
+Always show your actual, unscripted @command{ffmpeg} command and the
+complete, uncut console output from your command.
+
+@item
+Use the most simple and minimal command that still shows the issue you
+are encountering.
+
+@item
+Provide all necessary information so others can attempt to duplicate
+your issue. This includes the actual command, complete uncut console
+output, and any inputs that are required to duplicate the issue.
+
+@item
+Use the latest @command{ffmpeg} build you can get. See the @url{https://ffmpeg.org/download.html, FFmpeg Download}
+page for links to recent builds for Linux, macOS, and Windows. Or
+compile from the current git master branch.
+
+@item
+Avoid @url{https://en.wikipedia.org/wiki/Posting_style#Top-posting, top-posting}.
+Also see @ref{What is top-posting?}
+
+@item
+Avoid hijacking threads. Thread hijacking is replying to a message and
+changing the subject line to something unrelated to the original thread.
+Most email clients will still show the renamed message under the
+original thread. This can be confusing and these types of messages are
+often ignored.
+
+@item
+Do not send screenshots. Copy and paste console text instead of making
+screenshots of the text.
+
+@item
+Avoid sending email disclaimers and legalese if possible as this is a
+public list.
+
+@item
+Avoid using the @code{-loglevel debug}, @code{-loglevel quiet}, and
+@command{-hide_banner} options unless requested to do so.
+
+@item
+If you attach files avoid compressing small files. Uncompressed is
+preferred.
+
+@item
+Please do not send HTML-only messages. The mailing list will ignore the
+HTML component of your message. Most mail clients will automatically
+include a text component: this is what the mailing list will use.
+
+@item
+Configuring your mail client to break lines after 70 or so characters is
+recommended.
+
+@item
+Avoid sending the same message to multiple mailing lists.
+
+@item
+Please follow our @url{https://ffmpeg.org/developer.html#Code-of-conduct, Code of Conduct}.
+@end itemize
+
+@chapter Help
+
+@section Why am I not receiving any messages?
+
+Some email providers have blacklists or spam filters that block or mark
+the mailing list messages as false positives. Unfortunately, the user is
+often not aware of this and is often out of their control.
+
+When possible we attempt to notify the provider to be removed from the
+blacklists or filters.
+
+@section Why are my sent messages not showing up?
+
+Excluding @ref{Why is my message awaiting moderator approval?, messages that are held in the moderation queue}
+there are a few other reasons why your messages may fail to appear:
+
+@itemize
+@item
+HTML-only messages are ignored by the mailing lists. Most mail clients
+automatically include a text component alongside HTML email: this is what
+the mailing list will use. If it does not then consider your client to be
+broken, because sending a text component along with the HTML component to
+form a multi-part message is recommended by email standards.
+
+@item
+Check your spam folder.
+@end itemize
+
+@anchor{Who do I contact if I have a problem with the mailing list?}
+@section Who do I contact if I have a problem with the mailing list?
+
+Send a message to @email{ffmpeg-user-owner@@ffmpeg.org}.
+
+@bye
diff --git a/mythtv/external/FFmpeg/doc/muxers.texi b/mythtv/external/FFmpeg/doc/muxers.texi
index d817bfa049f..91bbe673c53 100644
--- a/mythtv/external/FFmpeg/doc/muxers.texi
+++ b/mythtv/external/FFmpeg/doc/muxers.texi
@@ -13,8 +13,9 @@ You can disable all the muxers with the configure option
 with the options @code{--enable-muxer=@var{MUXER}} /
 @code{--disable-muxer=@var{MUXER}}.
 
-The option @code{-formats} of the ff* tools will display the list of
-enabled muxers.
+The option @code{-muxers} of the ff* tools will display the list of
+enabled muxers. Use @code{-formats} to view a combined list of
+enabled demuxers and muxers.
 
 A description of some of the currently available muxers follows.
 
@@ -57,6 +58,39 @@ fragmentation or muxer overhead depending on your source. Default value is
 
 @end table
 
+@anchor{avi}
+@section avi
+
+Audio Video Interleaved muxer.
+
+@subsection Options
+
+It accepts the following options:
+
+@table @option
+@item reserve_index_space
+Reserve the specified amount of bytes for the OpenDML master index of each
+stream within the file header. By default additional master indexes are
+embedded within the data packets if there is no space left in the first master
+index and are linked together as a chain of indexes. This index structure can
+cause problems for some use cases, e.g. third-party software strictly relying
+on the OpenDML index specification or when file seeking is slow. Reserving
+enough index space in the file header avoids these problems.
+
+The required index space depends on the output file size and should be about 16
+bytes per gigabyte. When this option is omitted or set to zero the necessary
+index space is guessed.
+
+@item write_channel_mask
+Write the channel layout mask into the audio stream header.
+
+This option is enabled by default. Disabling the channel mask can be useful in
+specific scenarios, e.g. when merging multiple audio streams into one for
+compatibility with software that only supports a single audio stream in AVI
+(see @ref{amerge,,the "amerge" section in the ffmpeg-filters manual,ffmpeg-filters}).
+
+@end table
+
 @anchor{chromaprint}
 @section chromaprint
 
@@ -148,13 +182,80 @@ Place AAC sequence header based on audio stream data.
 @item no_sequence_end
 Disable sequence end tag.
 
+@item no_metadata
+Disable metadata tag.
+
 @item no_duration_filesize
 Disable duration and filesize in metadata when they are equal to zero
 at the end of stream. (Be used to non-seekable living stream).
 
+@item add_keyframe_index
+Used to facilitate seeking; particularly for HTTP pseudo streaming.
 @end table
 @end table
 
+@anchor{dash}
+@section dash
+
+Dynamic Adaptive Streaming over HTTP (DASH) muxer that creates segments
+and manifest files according to the MPEG-DASH standard ISO/IEC 23009-1:2014.
+
+For more information see:
+
+@itemize @bullet
+@item
+ISO DASH Specification: @url{http://standards.iso.org/ittf/PubliclyAvailableStandards/c065274_ISO_IEC_23009-1_2014.zip}
+@item
+WebM DASH Specification: @url{https://sites.google.com/a/webmproject.org/wiki/adaptive-streaming/webm-dash-specification}
+@end itemize
+
+It creates a MPD manifest file and segment files for each stream.
+
+The segment filename might contain pre-defined identifiers used with SegmentTemplate
+as defined in section 5.3.9.4.4 of the standard. Available identifiers are "$RepresentationID$",
+"$Number$", "$Bandwidth$" and "$Time$".
+
+@example
+ffmpeg -re -i <input> -map 0 -map 0 -c:a libfdk_aac -c:v libx264
+-b:v:0 800k -b:v:1 300k -s:v:1 320x170 -profile:v:1 baseline
+-profile:v:0 main -bf 1 -keyint_min 120 -g 120 -sc_threshold 0
+-b_strategy 0 -ar:a:1 22050 -use_timeline 1 -use_template 1
+-window_size 5 -adaptation_sets "id=0,streams=v id=1,streams=a"
+-f dash /path/to/out.mpd
+@end example
+
+@table @option
+@item -min_seg_duration @var{microseconds}
+Set the segment length in microseconds.
+@item -window_size @var{size}
+Set the maximum number of segments kept in the manifest.
+@item -extra_window_size @var{size}
+Set the maximum number of segments kept outside of the manifest before removing from disk.
+@item -remove_at_exit @var{remove}
+Enable (1) or disable (0) removal of all segments when finished.
+@item -use_template @var{template}
+Enable (1) or disable (0) use of SegmentTemplate instead of SegmentList.
+@item -use_timeline @var{timeline}
+Enable (1) or disable (0) use of SegmentTimeline in SegmentTemplate.
+@item -single_file @var{single_file}
+Enable (1) or disable (0) storing all segments in one file, accessed using byte ranges.
+@item -single_file_name @var{file_name}
+DASH-templated name to be used for baseURL. Implies @var{single_file} set to "1".
+@item -init_seg_name @var{init_name}
+DASH-templated name to used for the initialization segment. Default is "init-stream$RepresentationID$.m4s"
+@item -media_seg_name @var{segment_name}
+DASH-templated name to used for the media segments. Default is "chunk-stream$RepresentationID$-$Number%05d$.m4s"
+@item -utc_timing_url @var{utc_url}
+URL of the page that will return the UTC timestamp in ISO format. Example: "https://time.akamai.com/?iso"
+@item -adaptation_sets @var{adaptation_sets}
+Assign streams to AdaptationSets. Syntax is "id=x,streams=a,b,c id=y,streams=d,e" with x and y being the IDs
+of the adaptation sets and a,b,c,d and e are the indices of the mapped streams.
+
+To map all video (or audio) streams to an AdaptationSet, "v" (or "a") can be used as stream identifier instead of IDs.
+
+When no assignment is defined, this defaults to an AdaptationSet for each stream.
+@end table
+
 @anchor{framecrc}
 @section framecrc
 
@@ -403,17 +504,41 @@ parameters. Values containing @code{:} special characters must be
 escaped.
 
 @item hls_wrap @var{wrap}
-Set the number after which the segment filename number (the number
-specified in each segment file) wraps. If set to 0 the number will be
-never wrapped. Default value is 0.
+This is a deprecated option, you can use @code{hls_list_size}
+and @code{hls_flags delete_segments} instead it
 
 This option is useful to avoid to fill the disk with many segment
 files, and limits the maximum number of segment files written to disk
 to @var{wrap}.
 
+
+@item hls_start_number_source
+Start the playlist sequence number (@code{#EXT-X-MEDIA-SEQUENCE}) according to the specified source.
+Unless @code{hls_flags single_file} is set, it also specifies source of starting sequence numbers of
+segment and subtitle filenames. In any case, if @code{hls_flags append_list}
+is set and read playlist sequence number is greater than the specified start sequence number,
+then that value will be used as start value.
+
+It accepts the following values:
+
+@table @option
+
+@item generic (default)
+Set the starting sequence numbers according to @var{start_number} option value.
+
+@item epoch
+The start number will be the seconds since epoch (1970-01-01 00:00:00)
+
+@item datetime
+The start number will be based on the current date/time as YYYYmmddHHMMSS. e.g. 20161231235759.
+
+@end table
+
 @item start_number @var{number}
-Start the playlist sequence number from @var{number}. Default value is
-0.
+Start the playlist sequence number (@code{#EXT-X-MEDIA-SEQUENCE}) from the specified @var{number}
+when @var{hls_start_number_source} value is @var{generic}. (This is the default case.)
+Unless @code{hls_flags single_file} is set, it also specifies starting sequence numbers of segment and subtitle filenames.
+Default value is 0.
 
 @item hls_allow_cache @var{allowcache}
 Explicitly set whether the client MAY (1) or MUST NOT (0) cache media segments.
@@ -436,24 +561,46 @@ ffmpeg -i in.nut -hls_segment_filename 'file%03d.ts' out.m3u8
 This example will produce the playlist, @file{out.m3u8}, and segment files:
 @file{file000.ts}, @file{file001.ts}, @file{file002.ts}, etc.
 
+@var{filename} may contain full path or relative path specification,
+but only the file name part without any path info will be contained in the m3u8 segment list.
+Should a relative path be specified, the path of the created segment
+files will be relative to the current working directory.
+When use_localtime_mkdir is set, the whole expanded value of @var{filename} will be written into the m3u8 segment list.
+
+
 @item use_localtime
-Use strftime on @var{filename} to expand the segment filename with localtime.
-The segment number (%d) is not available in this mode.
+Use strftime() on @var{filename} to expand the segment filename with localtime.
+The segment number is also available in this mode, but to use it, you need to specify second_level_segment_index
+hls_flag and %%d will be the specifier.
 @example
 ffmpeg -i in.nut -use_localtime 1 -hls_segment_filename 'file-%Y%m%d-%s.ts' out.m3u8
 @end example
 This example will produce the playlist, @file{out.m3u8}, and segment files:
 @file{file-20160215-1455569023.ts}, @file{file-20160215-1455569024.ts}, etc.
+Note: On some systems/environments, the @code{%s} specifier is not available. See
+  @code{strftime()} documentation.
+@example
+ffmpeg -i in.nut -use_localtime 1 -hls_flags second_level_segment_index -hls_segment_filename 'file-%Y%m%d-%%04d.ts' out.m3u8
+@end example
+This example will produce the playlist, @file{out.m3u8}, and segment files:
+@file{file-20160215-0001.ts}, @file{file-20160215-0002.ts}, etc.
 
 @item use_localtime_mkdir
-Used together with -use_localtime, it will create up to one subdirectory which
+Used together with -use_localtime, it will create all subdirectories which
 is expanded in @var{filename}.
 @example
 ffmpeg -i in.nut -use_localtime 1 -use_localtime_mkdir 1 -hls_segment_filename '%Y%m%d/file-%Y%m%d-%s.ts' out.m3u8
 @end example
 This example will create a directory 201560215 (if it does not exist), and then
 produce the playlist, @file{out.m3u8}, and segment files:
-@file{201560215/file-20160215-1455569023.ts}, @file{201560215/file-20160215-1455569024.ts}, etc.
+@file{20160215/file-20160215-1455569023.ts}, @file{20160215/file-20160215-1455569024.ts}, etc.
+
+@example
+ffmpeg -i in.nut -use_localtime 1 -use_localtime_mkdir 1 -hls_segment_filename '%Y/%m/%d/file-%Y%m%d-%s.ts' out.m3u8
+@end example
+This example will create a directory hierarchy 2016/02/15 (if any of them do not exist), and then
+produce the playlist, @file{out.m3u8}, and segment files:
+@file{2016/02/15/file-20160215-1455569023.ts}, @file{2016/02/15/file-20160215-1455569024.ts}, etc.
 
 
 @item hls_key_info_file @var{key_info_file}
@@ -466,7 +613,7 @@ format. The optional third line specifies the initialization vector (IV) as a
 hexadecimal string to be used instead of the segment sequence number (default)
 for encryption. Changes to @var{key_info_file} will result in segment
 encryption with the new key/IV and an entry in the playlist for the new key
-URI/IV.
+URI/IV if @code{hls_flags periodic_rekey} is enabled.
 
 Key info file format:
 @example
@@ -512,7 +659,45 @@ ffmpeg -f lavfi -re -i testsrc -c:v h264 -hls_flags delete_segments \
   -hls_key_info_file file.keyinfo out.m3u8
 @end example
 
-@item hls_flags single_file
+@item -hls_enc @var{enc}
+Enable (1) or disable (0) the AES128 encryption.
+When enabled every segment generated is encrypted and the encryption key
+is saved as @var{playlist name}.key.
+
+@item -hls_enc_key @var{key}
+Hex-coded 16byte key to encrypt the segments, by default it
+is randomly generated.
+
+@item -hls_enc_key_url @var{keyurl}
+If set, @var{keyurl} is prepended instead of @var{baseurl} to the key filename
+in the playlist.
+
+@item -hls_enc_iv @var{iv}
+Hex-coded 16byte initialization vector for every segment instead
+of the autogenerated ones.
+
+@item hls_segment_type @var{flags}
+Possible values:
+
+@table @samp
+@item mpegts
+If this flag is set, the hls segment files will format to mpegts.
+the mpegts files is used in all hls versions.
+
+@item fmp4
+If this flag is set, the hls segment files will format to fragment mp4 looks like dash.
+the fmp4 files is used in hls after version 7.
+
+@end table
+
+@item hls_fmp4_init_filename @var{filename}
+set filename to the fragment files header file, default filename is @file{init.mp4}.
+
+@item hls_flags @var{flags}
+Possible values:
+
+@table @samp
+@item single_file
 If this flag is set, the muxer will store all segments in a single MPEG-TS
 file, and will use byte ranges in the playlist. HLS playlists generated with
 this way will have the version number 4.
@@ -523,34 +708,70 @@ ffmpeg -i in.nut -hls_flags single_file out.m3u8
 Will produce the playlist, @file{out.m3u8}, and a single segment file,
 @file{out.ts}.
 
-@item hls_flags delete_segments
+@item delete_segments
 Segment files removed from the playlist are deleted after a period of time
 equal to the duration of the segment plus the duration of the playlist.
 
-@item hls_flags append_list
+@item append_list
 Append new segments into the end of old segment list,
 and remove the @code{#EXT-X-ENDLIST} from the old segment list.
 
-@item hls_flags round_durations
+@item round_durations
 Round the duration info in the playlist file segment info to integer
 values, instead of using floating point.
 
-@item hls_flags discont_starts
+@item discont_start
 Add the @code{#EXT-X-DISCONTINUITY} tag to the playlist, before the
 first segment's information.
 
-@item hls_flags omit_endlist
+@item omit_endlist
 Do not append the @code{EXT-X-ENDLIST} tag at the end of the playlist.
 
-@item hls_flags split_by_time
+@item periodic_rekey
+The file specified by @code{hls_key_info_file} will be checked periodically and
+detect updates to the encryption info. Be sure to replace this file atomically,
+including the file containing the AES encryption key.
+
+@item split_by_time
 Allow segments to start on frames other than keyframes. This improves
 behavior on some players when the time between keyframes is inconsistent,
 but may make things worse on others, and can cause some oddities during
 seeking. This flag should be used with the @code{hls_time} option.
 
-@item hls_flags program_date_time
+@item program_date_time
 Generate @code{EXT-X-PROGRAM-DATE-TIME} tags.
 
+@item second_level_segment_index
+Makes it possible to use segment indexes as %%d in hls_segment_filename expression
+besides date/time values when use_localtime is on.
+To get fixed width numbers with trailing zeroes, %%0xd format is available where x is the required width.
+
+@item second_level_segment_size
+Makes it possible to use segment sizes (counted in bytes) as %%s in hls_segment_filename
+expression besides date/time values when use_localtime is on.
+To get fixed width numbers with trailing zeroes, %%0xs format is available where x is the required width.
+
+@item second_level_segment_duration
+Makes it possible to use segment duration (calculated  in microseconds) as %%t in hls_segment_filename
+expression besides date/time values when use_localtime is on.
+To get fixed width numbers with trailing zeroes, %%0xt format is available where x is the required width.
+
+@example
+ffmpeg -i sample.mpeg \
+   -f hls -hls_time 3 -hls_list_size 5 \
+   -hls_flags second_level_segment_index+second_level_segment_size+second_level_segment_duration \
+   -use_localtime 1 -use_localtime_mkdir 1 -hls_segment_filename "segment_%Y%m%d%H%M%S_%%04d_%%08s_%%013t.ts" stream.m3u8
+@end example
+This will produce segments like this:
+@file{segment_20170102194334_0003_00122200_0000003000000.ts}, @file{segment_20170102194334_0004_00120072_0000003000000.ts} etc.
+
+@item temp_file
+Write segment data to filename.tmp and rename to filename only once the segment is complete. A webserver
+serving up segments can be configured to reject requests to *.tmp to prevent access to in-progress segments
+before they have been added to the m3u8 playlist.
+
+@end table
+
 @item hls_playlist_type event
 Emit @code{#EXT-X-PLAYLIST-TYPE:EVENT} in the m3u8 header. Forces
 @option{hls_list_size} to 0; the playlist can only be appended to.
@@ -569,6 +790,10 @@ server using the HTTP PUT method, and update the m3u8 files every
 @code{refresh} times using the same method.
 Note that the HTTP server must support the given method for uploading
 files.
+
+@item http_user_agent
+Override User-Agent field in HTTP header. Applicable only for HTTP output.
+
 @end table
 
 @anchor{ico}
@@ -640,7 +865,7 @@ The following example shows how to use @command{ffmpeg} for creating a
 sequence of files @file{img-001.jpeg}, @file{img-002.jpeg}, ...,
 taking one image every second from the input video:
 @example
-ffmpeg -i in.avi -vsync 1 -r 1 -f image2 'img-%03d.jpeg'
+ffmpeg -i in.avi -vsync cfr -r 1 -f image2 'img-%03d.jpeg'
 @end example
 
 Note that with @command{ffmpeg}, if the format is not specified with the
@@ -648,12 +873,12 @@ Note that with @command{ffmpeg}, if the format is not specified with the
 format, the image2 muxer is automatically selected, so the previous
 command can be written as:
 @example
-ffmpeg -i in.avi -vsync 1 -r 1 'img-%03d.jpeg'
+ffmpeg -i in.avi -vsync cfr -r 1 'img-%03d.jpeg'
 @end example
 
 Note also that the pattern must not necessarily contain "%d" or
 "%0@var{N}d", for example to create a single image file
-@file{img.jpeg} from the input video you can employ the command:
+@file{img.jpeg} from the start of the input video you can employ the command:
 @example
 ffmpeg -i in.avi -f image2 -frames:v 1 img.jpeg
 @end example
@@ -673,7 +898,7 @@ ffmpeg -f v4l2 -r 1 -i /dev/video0 -f image2 -strftime 1 "%Y-%m-%d_%H-%M-%S.jpg"
 
 @table @option
 @item start_number
-Start the sequence from the specified number. Default value is 0.
+Start the sequence from the specified number. Default value is 1.
 
 @item update
 If set to 1, the filename will always be interpreted as just a
@@ -892,6 +1117,12 @@ on the implicit end of the previous track fragment).
 @item -write_tmcd
 Specify @code{on} to force writing a timecode track, @code{off} to disable it
 and @code{auto} to write a timecode track only for mov and mp4 output (default).
+@item -movflags negative_cts_offsets
+Enables utilization of version 1 of the CTTS box, in which the CTS offsets can
+be negative. This enables the initial sample to have DTS/CTS of zero, and
+reduces the need for edit lists for some cases such as video tracks with
+B-frames. Additionally, eases conformance with the DASH-IF interoperability
+guidelines.
 @end table
 
 @subsection Example
@@ -970,69 +1201,35 @@ This muxer implements ISO 13818-1 and part of ETSI EN 300 468.
 
 The recognized metadata settings in mpegts muxer are @code{service_provider}
 and @code{service_name}. If they are not set the default for
-@code{service_provider} is "FFmpeg" and the default for
-@code{service_name} is "Service01".
+@code{service_provider} is @samp{FFmpeg} and the default for
+@code{service_name} is @samp{Service01}.
 
 @subsection Options
 
 The muxer options are:
 
 @table @option
-@item mpegts_original_network_id @var{number}
-Set the original_network_id (default 0x0001). This is unique identifier
-of a network in DVB. Its main use is in the unique identification of a
-service through the path Original_Network_ID, Transport_Stream_ID.
-@item mpegts_transport_stream_id @var{number}
-Set the transport_stream_id (default 0x0001). This identifies a
-transponder in DVB.
-@item mpegts_service_id @var{number}
-Set the service_id (default 0x0001) also known as program in DVB.
-@item mpegts_service_type @var{number}
-Set the program service_type (default @var{digital_tv}), see below
-a list of pre defined values.
-@item mpegts_pmt_start_pid @var{number}
-Set the first PID for PMT (default 0x1000, max 0x1f00).
-@item mpegts_start_pid @var{number}
-Set the first PID for data packets (default 0x0100, max 0x0f00).
-@item mpegts_m2ts_mode @var{number}
-Enable m2ts mode if set to 1. Default value is -1 which disables m2ts mode.
-@item muxrate @var{number}
-Set a constant muxrate (default VBR).
-@item pcr_period @var{numer}
-Override the default PCR retransmission time (default 20ms), ignored
-if variable muxrate is selected.
-@item pat_period @var{number}
-Maximal time in seconds between PAT/PMT tables.
-@item sdt_period @var{number}
-Maximal time in seconds between SDT tables.
-@item pes_payload_size @var{number}
-Set minimum PES packet payload in bytes.
-@item mpegts_flags @var{flags}
-Set flags (see below).
-@item mpegts_copyts @var{number}
-Preserve original timestamps, if value is set to 1. Default value is -1, which
-results in shifting timestamps so that they start from 0.
-@item tables_version @var{number}
-Set PAT, PMT and SDT version (default 0, valid values are from 0 to 31, inclusively).
-This option allows updating stream structure so that standard consumer may
-detect the change. To do so, reopen output AVFormatContext (in case of API
-usage) or restart ffmpeg instance, cyclically changing tables_version value:
-@example
-ffmpeg -i source1.ts -codec copy -f mpegts -tables_version 0 udp://1.1.1.1:1111
-ffmpeg -i source2.ts -codec copy -f mpegts -tables_version 1 udp://1.1.1.1:1111
-...
-ffmpeg -i source3.ts -codec copy -f mpegts -tables_version 31 udp://1.1.1.1:1111
-ffmpeg -i source1.ts -codec copy -f mpegts -tables_version 0 udp://1.1.1.1:1111
-ffmpeg -i source2.ts -codec copy -f mpegts -tables_version 1 udp://1.1.1.1:1111
-...
-@end example
-@end table
-
-Option @option{mpegts_service_type} accepts the following values:
-
-@table @option
+@item mpegts_transport_stream_id @var{integer}
+Set the @samp{transport_stream_id}. This identifies a transponder in DVB.
+Default is @code{0x0001}.
+
+@item mpegts_original_network_id @var{integer}
+Set the @samp{original_network_id}. This is unique identifier of a
+network in DVB. Its main use is in the unique identification of a service
+through the path @samp{Original_Network_ID, Transport_Stream_ID}. Default
+is @code{0x0001}.
+
+@item mpegts_service_id @var{integer}
+Set the @samp{service_id}, also known as program in DVB. Default is
+@code{0x0001}.
+
+@item mpegts_service_type @var{integer}
+Set the program @samp{service_type}. Default is @code{digital_tv}.
+Accepts the following options:
+@table @samp
 @item hex_value
-Any hexdecimal value between 0x01 to 0xff as defined in ETSI 300 468.
+Any hexdecimal value between @code{0x01} to @code{0xff} as defined in
+ETSI 300 468.
 @item digital_tv
 Digital TV service.
 @item digital_radio
@@ -1049,9 +1246,26 @@ Advanced Codec Digital SDTV service.
 Advanced Codec Digital HDTV service.
 @end table
 
-Option @option{mpegts_flags} may take a set of such flags:
+@item mpegts_pmt_start_pid @var{integer}
+Set the first PID for PMT. Default is @code{0x1000}. Max is @code{0x1f00}.
 
-@table @option
+@item mpegts_start_pid @var{integer}
+Set the first PID for data packets. Default is @code{0x0100}. Max is
+@code{0x0f00}.
+
+@item mpegts_m2ts_mode @var{boolean}
+Enable m2ts mode if set to @code{1}. Default value is @code{-1} which
+disables m2ts mode.
+
+@item muxrate @var{integer}
+Set a constant muxrate. Default is VBR.
+
+@item pes_payload_size @var{integer}
+Set minimum PES packet payload in bytes. Default is @code{2930}.
+
+@item mpegts_flags @var{flags}
+Set mpegts flags. Accepts the following options:
+@table @samp
 @item resend_headers
 Reemit PAT/PMT before writing the next packet.
 @item latm
@@ -1060,6 +1274,47 @@ Use LATM packetization for AAC.
 Reemit PAT and PMT at each video frame.
 @item system_b
 Conform to System B (DVB) instead of System A (ATSC).
+@item initial_discontinuity
+Mark the initial packet of each stream as discontinuity.
+@end table
+
+@item resend_headers @var{integer}
+Reemit PAT/PMT before writing the next packet. This option is deprecated:
+use @option{mpegts_flags} instead.
+
+@item mpegts_copyts @var{boolean}
+Preserve original timestamps, if value is set to @code{1}. Default value
+is @code{-1}, which results in shifting timestamps so that they start from 0.
+
+@item omit_video_pes_length @var{boolean}
+Omit the PES packet length for video packets. Default is @code{1} (true).
+
+@item pcr_period @var{integer}
+Override the default PCR retransmission time in milliseconds. Ignored if
+variable muxrate is selected. Default is @code{20}.
+
+@item pat_period @var{double}
+Maximum time in seconds between PAT/PMT tables.
+
+@item sdt_period @var{double}
+Maximum time in seconds between SDT tables.
+
+@item tables_version @var{integer}
+Set PAT, PMT and SDT version (default @code{0}, valid values are from 0 to 31, inclusively).
+This option allows updating stream structure so that standard consumer may
+detect the change. To do so, reopen output @code{AVFormatContext} (in case of API
+usage) or restart @command{ffmpeg} instance, cyclically changing
+@option{tables_version} value:
+
+@example
+ffmpeg -i source1.ts -codec copy -f mpegts -tables_version 0 udp://1.1.1.1:1111
+ffmpeg -i source2.ts -codec copy -f mpegts -tables_version 1 udp://1.1.1.1:1111
+...
+ffmpeg -i source3.ts -codec copy -f mpegts -tables_version 31 udp://1.1.1.1:1111
+ffmpeg -i source1.ts -codec copy -f mpegts -tables_version 0 udp://1.1.1.1:1111
+ffmpeg -i source2.ts -codec copy -f mpegts -tables_version 1 udp://1.1.1.1:1111
+...
+@end example
 @end table
 
 @subsection Example
@@ -1073,7 +1328,7 @@ ffmpeg -i file.mpg -c copy \
      -mpegts_start_pid 0x150 \
      -metadata service_provider="Some provider" \
      -metadata service_name="Some Channel" \
-     -y out.ts
+     out.ts
 @end example
 
 @section mxf, mxf_d10
@@ -1322,9 +1577,6 @@ within the specified duration after the segmenting clock time. This way you
 can make the segmenter more resilient to backward local time jumps, such as
 leap seconds or transition to standard time from daylight savings time.
 
-Assuming that the delay between the packets of your source is less than 0.5
-second you can detect a leap second by specifying 0.5 as the duration.
-
 Default is the maximum possible duration which means starting a new segment
 regardless of the elapsed time since the last clock time.
 
@@ -1382,7 +1634,7 @@ inconsistent, but may make things worse on others, and can cause some oddities
 during seeking. Defaults to @code{0}.
 
 @item reset_timestamps @var{1|0}
-Reset timestamps at the begin of each segment, so that each segment
+Reset timestamps at the beginning of each segment, so that each segment
 will start with near-zero timestamps. It is meant to ease the playback
 of the generated segments. May not work with some combinations of
 muxers/codecs. It is set to @code{0} by default.
@@ -1478,6 +1730,7 @@ Specify whether to remove all fragments when finished. Default 0 (do not remove)
 
 @end table
 
+@anchor{fifo}
 @section fifo
 
 The fifo pseudo-muxer allows the separation of encoding and muxing by using
@@ -1585,6 +1838,18 @@ with the tee muxer; encoding can be a very expensive process. It is not
 useful when using the libavformat API directly because it is then possible
 to feed the same packets to several muxers directly.
 
+@table @option
+
+@item use_fifo @var{bool}
+If set to 1, slave outputs will be processed in separate thread using @ref{fifo}
+muxer. This allows to compensate for different speed/latency/reliability of
+outputs and setup transparent recovery. By default this feature is turned off.
+
+@item fifo_options
+Options to pass to fifo pseudo-muxer instances. See @ref{fifo}.
+
+@end table
+
 The slave outputs are specified in the file name given to the muxer,
 separated by '|'. If any of the slave name contains the '|' separator,
 leading or trailing spaces or any special character, it must be
@@ -1606,6 +1871,13 @@ output name suffix.
 Specify a list of bitstream filters to apply to the specified
 output.
 
+@item use_fifo @var{bool}
+This allows to override tee muxer use_fifo option for individual slave muxer.
+
+@item fifo_options
+This allows to override tee muxer fifo_options for individual slave muxer.
+See @ref{fifo}.
+
 It is possible to specify to which streams a given bitstream filter
 applies, by appending a stream specifier to the option separated by
 @code{/}. @var{spec} must be a stream specifier (see @ref{Format
@@ -1654,7 +1926,7 @@ keyframes packets, as requested by the MPEG-TS format. The select
 option is applied to @file{out.aac} in order to make it contain only
 audio packets.
 @example
-ffmpeg -i ... -map 0 -flags +global_header -c:v libx264 -c:a aac -strict experimental
+ffmpeg -i ... -map 0 -flags +global_header -c:v libx264 -c:a aac
        -f tee "[bsfs/v=dump_extra]out.ts|[movflags=+faststart]out.mp4|[select=a]out.aac"
 @end example
 
@@ -1663,7 +1935,7 @@ As below, but select only stream @code{a:1} for the audio output. Note
 that a second level escaping must be performed, as ":" is a special
 character used to separate options.
 @example
-ffmpeg -i ... -map 0 -flags +global_header -c:v libx264 -c:a aac -strict experimental
+ffmpeg -i ... -map 0 -flags +global_header -c:v libx264 -c:a aac
        -f tee "[bsfs/v=dump_extra]out.ts|[movflags=+faststart]out.mp4|[select=\'a:1\']out.aac"
 @end example
 @end itemize
diff --git a/mythtv/external/FFmpeg/doc/optimization.txt b/mythtv/external/FFmpeg/doc/optimization.txt
index b4b0a064c35..974e2f9af27 100644
--- a/mythtv/external/FFmpeg/doc/optimization.txt
+++ b/mythtv/external/FFmpeg/doc/optimization.txt
@@ -142,7 +142,7 @@ Alignment:
 Some instructions on some architectures have strict alignment restrictions,
 for example most SSE/SSE2 instructions on x86.
 The minimum guaranteed alignment is written in the .h files, for example:
-    void (*put_pixels_clamped)(const int16_t *block/*align 16*/, UINT8 *pixels/*align 8*/, int line_size);
+    void (*put_pixels_clamped)(const int16_t *block/*align 16*/, uint8_t *pixels/*align 8*/, ptrdiff_t stride);
 
 
 General Tips:
@@ -161,8 +161,8 @@ do{
 For x86, mark registers that are clobbered in your asm. This means both
 general x86 registers (e.g. eax) as well as XMM registers. This last one is
 particularly important on Win64, where xmm6-15 are callee-save, and not
-restoring their contents leads to undefined results. In external asm (e.g.
-yasm), you do this by using:
+restoring their contents leads to undefined results. In external asm,
+you do this by using:
 cglobal function_name, num_args, num_regs, num_xmm_regs
 In inline asm, you specify clobbered registers at the end of your asm:
 __asm__(".." ::: "%eax").
@@ -199,12 +199,12 @@ actual lines causing issues.
 Inline asm vs. external asm
 ---------------------------
 Both inline asm (__asm__("..") in a .c file, handled by a compiler such as gcc)
-and external asm (.s or .asm files, handled by an assembler such as yasm/nasm)
+and external asm (.s or .asm files, handled by an assembler such as nasm/yasm)
 are accepted in FFmpeg. Which one to use differs per specific case.
 
 - if your code is intended to be inlined in a C function, inline asm is always
    better, because external asm cannot be inlined
-- if your code calls external functions, yasm is always better
+- if your code calls external functions, external asm is always better
 - if your code takes huge and complex structs as function arguments (e.g.
    MpegEncContext; note that this is not ideal and is discouraged if there
    are alternatives), then inline asm is always better, because predicting
diff --git a/mythtv/external/FFmpeg/doc/outdevs.texi b/mythtv/external/FFmpeg/doc/outdevs.texi
index e68653fd7a8..daf7b1ae62c 100644
--- a/mythtv/external/FFmpeg/doc/outdevs.texi
+++ b/mythtv/external/FFmpeg/doc/outdevs.texi
@@ -104,7 +104,7 @@ The argument must be one of @code{algorithms}, @code{antialiases},
 The following command shows the @command{ffmpeg} output is an
 CACA window, forcing its size to 80x25:
 @example
-ffmpeg -i INPUT -vcodec rawvideo -pix_fmt rgb24 -window_size 80x25 -f caca -
+ffmpeg -i INPUT -c:v rawvideo -pix_fmt rgb24 -window_size 80x25 -f caca -
 @end example
 
 @item
@@ -131,8 +131,8 @@ and @code{--extra-ldflags}.
 On Windows, you need to run the IDL files through @command{widl}.
 
 DeckLink is very picky about the formats it supports. Pixel format is always
-uyvy422, framerate and video size must be determined for your device with
-@command{-list_formats 1}. Audio sample rate is always 48 kHz.
+uyvy422, framerate, field order and video size must be determined for your
+device with @command{-list_formats 1}. Audio sample rate is always 48 kHz.
 
 @subsection Options
 
@@ -182,6 +182,51 @@ ffmpeg -i test.avi -f decklink -pix_fmt uyvy422 -s 720x486 -r 24000/1001 'DeckLi
 
 @end itemize
 
+@section libndi_newtek
+
+The libndi_newtek output device provides playback capabilities for using NDI (Network
+Device Interface, standard created by NewTek).
+
+Output filename is a NDI name.
+
+To enable this output device, you need the NDI SDK and you
+need to configure with the appropriate @code{--extra-cflags}
+and @code{--extra-ldflags}.
+
+NDI uses uyvy422 pixel format natively, but also supports bgra, bgr0, rgba and
+rgb0.
+
+@subsection Options
+
+@table @option
+
+@item reference_level
+The audio reference level in dB. This specifies how many dB above the
+reference level (+4dBU) is the full range of 16 bit audio.
+Defaults to @option{0}.
+
+@item clock_video
+These specify whether video "clock" themselves.
+Defaults to @option{false}.
+
+@item clock_audio
+These specify whether audio "clock" themselves.
+Defaults to @option{false}.
+
+@end table
+
+@subsection Examples
+
+@itemize
+
+@item
+Play video clip:
+@example
+ffmpeg -i "udp://@@239.1.1.1:10480?fifo_size=1000000&overrun_nonfatal=1" -vf "scale=720:576,fps=fps=25,setdar=dar=16/9,format=pix_fmts=uyvy422" -f libndi_newtek NEW_NDI1
+@end example
+
+@end itemize
+
 @section fbdev
 
 Linux framebuffer output device.
@@ -206,7 +251,7 @@ Set x/y coordinate of top left corner. Default is 0.
 Play a file on framebuffer device @file{/dev/fb0}.
 Required pixel format depends on current framebuffer settings.
 @example
-ffmpeg -re -i INPUT -vcodec rawvideo -pix_fmt bgra -f fbdev /dev/fb0
+ffmpeg -re -i INPUT -c:v rawvideo -pix_fmt bgra -f fbdev /dev/fb0
 @end example
 
 See also @url{http://linux-fbdev.sourceforge.net/}, and fbset(1).
@@ -368,7 +413,7 @@ Quit the device immediately.
 The following command shows the @command{ffmpeg} output is an
 SDL window, forcing its size to the qcif format:
 @example
-ffmpeg -i INPUT -vcodec rawvideo -pix_fmt yuv420p -window_size qcif -f sdl "SDL output"
+ffmpeg -i INPUT -c:v rawvideo -pix_fmt yuv420p -window_size qcif -f sdl "SDL output"
 @end example
 
 @section sndio
diff --git a/mythtv/external/FFmpeg/doc/platform.texi b/mythtv/external/FFmpeg/doc/platform.texi
index 0cce4703936..bdfb6fd6a52 100644
--- a/mythtv/external/FFmpeg/doc/platform.texi
+++ b/mythtv/external/FFmpeg/doc/platform.texi
@@ -71,9 +71,9 @@ Mac OS X on PowerPC or ARM (iPhone) requires a preprocessor from
 assembly functions. Put the Perl script somewhere
 in your PATH, FFmpeg's configure will pick it up automatically.
 
-Mac OS X on amd64 and x86 requires @command{yasm} to build most of the
+Mac OS X on amd64 and x86 requires @command{nasm} to build most of the
 optimized assembly functions. @uref{http://www.finkproject.org/, Fink},
-@uref{http://www.gentoo.org/proj/en/gentoo-alt/prefix/bootstrap-macos.xml, Gentoo Prefix},
+@uref{https://wiki.gentoo.org/wiki/Project:Prefix, Gentoo Prefix},
 @uref{https://mxcl.github.com/homebrew/, Homebrew}
 or @uref{http://www.macports.org, MacPorts} can easily provide it.
 
@@ -141,7 +141,7 @@ them under @command{MinGW-w64 Win64 Shell} and @command{MinGW-w64 Win32 Shell}.
 pacman -S make pkgconf diffutils
 
 # mingw-w64 packages and toolchains
-pacman -S mingw-w64-x86_64-yasm mingw-w64-x86_64-gcc mingw-w64-x86_64-SDL
+pacman -S mingw-w64-x86_64-nasm mingw-w64-x86_64-gcc mingw-w64-x86_64-SDL2
 @end example
 
 To target 32 bits replace @code{x86_64} with @code{i686} in the command above.
@@ -159,7 +159,7 @@ You will need the following prerequisites:
 @item @uref{http://code.google.com/p/msinttypes/, msinttypes}
 (if using MSVC 2012 or earlier)
 @item @uref{http://msys2.github.io/, MSYS2}
-@item @uref{http://yasm.tortall.net/, YASM}
+@item @uref{http://www.nasm.us/, NASM}
 (Also available via MSYS2's package manager.)
 @end itemize
 
@@ -315,7 +315,7 @@ These library packages are only available from
 
 @example
 yasm, libSDL-devel, libgsm-devel, libmp3lame-devel,
-libschroedinger1.0-devel, speex-devel, libtheora-devel, libxvidcore-devel
+speex-devel, libtheora-devel, libxvidcore-devel
 @end example
 
 The recommendation for x264 is to build it from source, as it evolves too
@@ -343,67 +343,4 @@ and for a build with shared libraries
 ./configure --target-os=mingw32 --enable-shared --disable-static --extra-cflags=-mno-cygwin --extra-libs=-mno-cygwin
 @end example
 
-@chapter Plan 9
-
-The native @uref{http://plan9.bell-labs.com/plan9/, Plan 9} compiler
-does not implement all the C99 features needed by FFmpeg so the gcc
-port must be used.  Furthermore, a few items missing from the C
-library and shell environment need to be fixed.
-
-@itemize
-
-@item GNU awk, grep, make, and sed
-
-Working packages of these tools can be found at
-@uref{http://code.google.com/p/ports2plan9/downloads/list, ports2plan9}.
-They can be installed with @uref{http://9front.org/, 9front's} @code{pkg}
-utility by setting @code{pkgpath} to
-@code{http://ports2plan9.googlecode.com/files/}.
-
-@item Missing/broken @code{head} and @code{printf} commands
-
-Replacements adequate for building FFmpeg can be found in the
-@code{compat/plan9} directory.  Place these somewhere they will be
-found by the shell.  These are not full implementations of the
-commands and are @emph{not} suitable for general use.
-
-@item Missing C99 @code{stdint.h} and @code{inttypes.h}
-
-Replacement headers are available from
-@url{http://code.google.com/p/plan9front/issues/detail?id=152}.
-
-@item Missing or non-standard library functions
-
-Some functions in the C library are missing or incomplete.  The
-@code{@uref{http://ports2plan9.googlecode.com/files/gcc-apelibs-1207.tbz,
-gcc-apelibs-1207}} package from
-@uref{http://code.google.com/p/ports2plan9/downloads/list, ports2plan9}
-includes an updated C library, but installing the full package gives
-unusable executables.  Instead, keep the files from @code{gccbin.tgz}
-under @code{/386/lib/gnu}.  From the @code{libc.a} archive in the
-@code{gcc-apelibs-1207} package, extract the following object files and
-turn them into a library:
-
-@itemize
-@item @code{strerror.o}
-@item @code{strtoll.o}
-@item @code{snprintf.o}
-@item @code{vsnprintf.o}
-@item @code{vfprintf.o}
-@item @code{_IO_getc.o}
-@item @code{_IO_putc.o}
-@end itemize
-
-Use the @code{--extra-libs} option of @code{configure} to inform the
-build system of this library.
-
-@item FPU exceptions enabled by default
-
-Unlike most other systems, Plan 9 enables FPU exceptions by default.
-These must be disabled before calling any FFmpeg functions.  While the
-included tools will do this automatically, other users of the
-libraries must do it themselves.
-
-@end itemize
-
 @bye
diff --git a/mythtv/external/FFmpeg/doc/print_options.c b/mythtv/external/FFmpeg/doc/print_options.c
index 9fd66ca3809..fd1cf10dc19 100644
--- a/mythtv/external/FFmpeg/doc/print_options.c
+++ b/mythtv/external/FFmpeg/doc/print_options.c
@@ -23,6 +23,7 @@
  */
 
 #include <stddef.h>
+#include <stdio.h>
 #include <string.h>
 #include <float.h>
 
@@ -30,12 +31,17 @@
 // for the target. without this build breaks on mingw
 #define AVFORMAT_OS_SUPPORT_H
 
-#include "libavformat/avformat.h"
-#include "libavformat/options_table.h"
-#include "libavcodec/avcodec.h"
-#include "libavcodec/options_table.h"
+#include "libavutil/attributes.h"
 #include "libavutil/opt.h"
 
+/* Forcibly turn off deprecation warnings, which just add noise here. */
+#undef attribute_deprecated
+#define attribute_deprecated
+
+#include "libavcodec/options_table.h"
+
+#include "libavformat/options_table.h"
+
 static void print_usage(void)
 {
     fprintf(stderr, "Usage: enum_options type\n"
diff --git a/mythtv/external/FFmpeg/doc/protocols.texi b/mythtv/external/FFmpeg/doc/protocols.texi
index 00e182efdc5..a7968ff56e3 100644
--- a/mythtv/external/FFmpeg/doc/protocols.texi
+++ b/mythtv/external/FFmpeg/doc/protocols.texi
@@ -5,6 +5,11 @@ The libavformat library provides some generic global options, which
 can be set on all the protocols. In addition each protocol may support
 so-called private options, which are specific for that component.
 
+Options may be set by specifying -@var{option} @var{value} in the
+FFmpeg tools, or by setting the value explicitly in the
+@code{AVFormatContext} options or using the @file{libavutil/opt.h} API
+for programmatic use.
+
 The list of supported options follows:
 
 @table @option
@@ -515,6 +520,41 @@ time, which is valuable if data transmission is slow.
 Note that some formats (typically MOV), require the output protocol to
 be seekable, so they will fail with the pipe output protocol.
 
+@section prompeg
+
+Pro-MPEG Code of Practice #3 Release 2 FEC protocol.
+
+The Pro-MPEG CoP#3 FEC is a 2D parity-check forward error correction mechanism
+for MPEG-2 Transport Streams sent over RTP.
+
+This protocol must be used in conjunction with the @code{rtp_mpegts} muxer and
+the @code{rtp} protocol.
+
+The required syntax is:
+@example
+-f rtp_mpegts -fec prompeg=@var{option}=@var{val}... rtp://@var{hostname}:@var{port}
+@end example
+
+The destination UDP ports are @code{port + 2} for the column FEC stream
+and @code{port + 4} for the row FEC stream.
+
+This protocol accepts the following options:
+@table @option
+
+@item l=@var{n}
+The number of columns (4-20, LxD <= 100)
+
+@item d=@var{n}
+The number of rows (4-20, LxD <= 100)
+
+@end table
+
+Example usage:
+
+@example
+-f rtp_mpegts -fec prompeg=l=8:d=4 rtp://@var{hostname}:@var{port}
+@end example
+
 @section rtmp
 
 Real-Time Messaging Protocol.
diff --git a/mythtv/external/FFmpeg/doc/resampler.texi b/mythtv/external/FFmpeg/doc/resampler.texi
index d72677c9159..5ed3f4377a2 100644
--- a/mythtv/external/FFmpeg/doc/resampler.texi
+++ b/mythtv/external/FFmpeg/doc/resampler.texi
@@ -132,12 +132,13 @@ For swr only, set resampling phase shift, default value is 10, and must be in
 the interval [0,30].
 
 @item linear_interp
-Use linear interpolation if set to 1, default value is 0.
+Use linear interpolation when enabled (the default). Disable it if you want
+to preserve speed instead of quality when exact_rational fails.
 
 @item exact_rational
 For swr only, when enabled, try to use exact phase_count based on input and
 output sample rate. However, if it is larger than @code{1 << phase_shift},
-the phase_count will be @code{1 << phase_shift} as fallback. Default is disabled.
+the phase_count will be @code{1 << phase_shift} as fallback. Default is enabled.
 
 @item cutoff
 Set cutoff frequency (swr: 6dB point; soxr: 0dB point) ratio; must be a float
diff --git a/mythtv/external/FFmpeg/doc/scaler.texi b/mythtv/external/FFmpeg/doc/scaler.texi
index 3e115cdda5b..f73804adfef 100644
--- a/mythtv/external/FFmpeg/doc/scaler.texi
+++ b/mythtv/external/FFmpeg/doc/scaler.texi
@@ -13,7 +13,8 @@ FFmpeg tools. For programmatic use, they can be set explicitly in the
 @anchor{sws_flags}
 @item sws_flags
 Set the scaler flags. This is also used to set the scaling
-algorithm. Only a single algorithm should be selected.
+algorithm. Only a single algorithm should be selected. Default
+value is @samp{bicubic}.
 
 It accepts the following values:
 @table @samp
diff --git a/mythtv/external/FFmpeg/doc/texi2pod.pl b/mythtv/external/FFmpeg/doc/texi2pod.pl
old mode 100755
new mode 100644
diff --git a/mythtv/external/FFmpeg/doc/undefined.txt b/mythtv/external/FFmpeg/doc/undefined.txt
new file mode 100644
index 00000000000..e01299bef14
--- /dev/null
+++ b/mythtv/external/FFmpeg/doc/undefined.txt
@@ -0,0 +1,47 @@
+Undefined Behavior
+------------------
+In the C language, some operations are undefined, like signed integer overflow,
+dereferencing freed pointers, accessing outside allocated space, ...
+
+Undefined Behavior must not occur in a C program, it is not safe even if the
+output of undefined operations is unused. The unsafety may seem nit picking
+but Optimizing compilers have in fact optimized code on the assumption that
+no undefined Behavior occurs.
+Optimizing code based on wrong assumptions can and has in some cases lead to
+effects beyond the output of computations.
+
+
+The signed integer overflow problem in speed critical code
+----------------------------------------------------------
+Code which is highly optimized and works with signed integers sometimes has the
+problem that some (invalid) inputs can trigger overflows (undefined behavior).
+In these cases, often the output of the computation does not matter (as it is
+from invalid input).
+In some cases the input can be checked easily in others checking the input is
+computationally too intensive.
+In these remaining cases a unsigned type can be used instead of a signed type.
+unsigned overflows are defined in C.
+
+SUINT
+-----
+As we have above established there is a need to use "unsigned" sometimes in
+computations which work with signed integers (which overflow).
+Using "unsigned" for signed integers has the very significant potential to
+cause confusion
+as in
+unsigned a,b,c;
+...
+a+b*c;
+The reader does not expect b to be semantically -5 here and if the code is
+changed by maybe adding a cast, a division or other the signedness will almost
+certainly be mistaken.
+To avoid this confusion a new type was introduced, "SUINT" is the C "unsigned"
+type but it holds a signed "int".
+to use the same example
+SUINT a,b,c;
+...
+a+b*c;
+here the reader knows that a,b,c are meant to be signed integers but for C
+standard compliance / to avoid undefined behavior they are stored in unsigned
+ints.
+
diff --git a/mythtv/external/FFmpeg/doc/utils.texi b/mythtv/external/FFmpeg/doc/utils.texi
index 7aea4606098..e635118565f 100644
--- a/mythtv/external/FFmpeg/doc/utils.texi
+++ b/mythtv/external/FFmpeg/doc/utils.texi
@@ -719,19 +719,24 @@ the name of a standard channel layout (e.g. @samp{mono},
 the name of a single channel (e.g. @samp{FL}, @samp{FR}, @samp{FC}, @samp{LFE}, etc.)
 
 @item
-a number of channels, in decimal, optionally followed by 'c', yielding
-the default channel layout for that number of channels (see the
-function @code{av_get_default_channel_layout})
+a number of channels, in decimal, followed by 'c', yielding the default channel
+layout for that number of channels (see the function
+@code{av_get_default_channel_layout}). Note that not all channel counts have a
+default layout.
+
+@item
+a number of channels, in decimal, followed by 'C', yielding an unknown channel
+layout with the specified number of channels. Note that not all channel layout
+specification strings support unknown channel layouts.
 
 @item
 a channel layout mask, in hexadecimal starting with "0x" (see the
 @code{AV_CH_*} macros in @file{libavutil/channel_layout.h}.
 @end itemize
 
-Starting from libavutil version 53 the trailing character "c" to
-specify a number of channels will be required, while a channel layout
-mask could also be specified as a decimal number (if and only if not
-followed by "c").
+Before libavutil version 53 the trailing character "c" to specify a number of
+channels was optional, but now it is required, while a channel layout mask can
+also be specified as a decimal number (if and only if not followed by "c" or "C").
 
 See also the function @code{av_get_channel_layout} defined in
 @file{libavutil/channel_layout.h}.
@@ -771,6 +776,9 @@ Compute arcsine of @var{x}.
 @item atan(x)
 Compute arctangent of @var{x}.
 
+@item atan2(x, y)
+Compute principal value of the arc tangent of @var{y}/@var{x}.
+
 @item between(x, min, max)
 Return 1 if @var{x} is greater than or equal to @var{min} and lesser than or
 equal to @var{max}, 0 otherwise.
@@ -856,6 +864,9 @@ Load the value of the internal variable with number
 @var{var}, which was previously stored with st(@var{var}, @var{expr}).
 The function returns the loaded value.
 
+@item lerp(x, y, z)
+Return linear interpolation between @var{x} and @var{y} by amount of @var{z}.
+
 @item log(x)
 Compute natural logarithm of @var{x}.
 
@@ -906,6 +917,9 @@ various input values that the expression can access through
 @code{ld(0)}. When the expression evaluates to 0 then the
 corresponding input value will be returned.
 
+@item round(expr)
+Round the value of expression @var{expr} to the nearest integer. For example, "round(1.5)" is "2.0".
+
 @item sin(x)
 Compute sine of @var{x}.
 
diff --git a/mythtv/external/FFmpeg/doc/writing_filters.txt b/mythtv/external/FFmpeg/doc/writing_filters.txt
index 66ebb532433..5cd4ecd6a4b 100644
--- a/mythtv/external/FFmpeg/doc/writing_filters.txt
+++ b/mythtv/external/FFmpeg/doc/writing_filters.txt
@@ -38,14 +38,14 @@ the build system and the C:
 
     --- after running configure ---
 
-    $ grep FOOBAR config.mak
+    $ grep FOOBAR ffbuild/config.mak
     CONFIG_FOOBAR_FILTER=yes
     $ grep FOOBAR config.h
     #define CONFIG_FOOBAR_FILTER 1
 
-CONFIG_FOOBAR_FILTER=yes from the config.mak is later used to enable the filter in
-libavfilter/Makefile and CONFIG_FOOBAR_FILTER=1 from the config.h will be used
-for registering the filter in libavfilter/allfilters.c.
+CONFIG_FOOBAR_FILTER=yes from the ffbuild/config.mak is later used to enable
+the filter in libavfilter/Makefile and CONFIG_FOOBAR_FILTER=1 from the config.h
+will be used for registering the filter in libavfilter/allfilters.c.
 
 Filter code layout
 ==================
diff --git a/mythtv/external/FFmpeg/ffbuild/.gitignore b/mythtv/external/FFmpeg/ffbuild/.gitignore
new file mode 100644
index 00000000000..38ed170752c
--- /dev/null
+++ b/mythtv/external/FFmpeg/ffbuild/.gitignore
@@ -0,0 +1,5 @@
+/.config
+/config.fate
+/config.log
+/config.mak
+/config.sh
diff --git a/mythtv/external/FFmpeg/ffbuild/arch.mak b/mythtv/external/FFmpeg/ffbuild/arch.mak
index 08f78b4efc5..e09006efcad 100644
--- a/mythtv/external/FFmpeg/ffbuild/arch.mak
+++ b/mythtv/external/FFmpeg/ffbuild/arch.mak
@@ -14,4 +14,4 @@ OBJS-$(HAVE_ALTIVEC) += $(ALTIVEC-OBJS) $(ALTIVEC-OBJS-yes)
 OBJS-$(HAVE_VSX)     += $(VSX-OBJS) $(VSX-OBJS-yes)
 
 OBJS-$(HAVE_MMX)     += $(MMX-OBJS)     $(MMX-OBJS-yes)
-OBJS-$(HAVE_YASM)    += $(YASM-OBJS)    $(YASM-OBJS-yes)
+OBJS-$(HAVE_X86ASM)  += $(X86ASM-OBJS)  $(X86ASM-OBJS-yes)
diff --git a/mythtv/external/FFmpeg/ffbuild/common.mak b/mythtv/external/FFmpeg/ffbuild/common.mak
index 1322d0c1597..e168fb2cfdd 100644
--- a/mythtv/external/FFmpeg/ffbuild/common.mak
+++ b/mythtv/external/FFmpeg/ffbuild/common.mak
@@ -2,15 +2,12 @@
 # common bits used by all libraries
 #
 
-# first so "all" becomes default target
-all: all-yes
-
-DEFAULT_YASMD=.dbg
+DEFAULT_X86ASMD=.dbg
 
 ifeq ($(DBG),1)
-YASMD=$(DEFAULT_YASMD)
+X86ASMD=$(DEFAULT_X86ASMD)
 else
-YASMD=
+X86ASMD=
 endif
 
 ifndef SUBDIR
@@ -18,8 +15,8 @@ ifndef SUBDIR
 ifndef V
 Q      = @
 ECHO   = printf "$(1)\t%s\n" $(2)
-BRIEF  = CC CXX OBJCC HOSTCC HOSTLD AS YASM AR LD STRIP CP WINDRES
-SILENT = DEPCC DEPHOSTCC DEPAS DEPYASM RANLIB RM
+BRIEF  = CC CXX OBJCC HOSTCC HOSTLD AS X86ASM AR LD STRIP CP WINDRES NVCC
+SILENT = DEPCC DEPHOSTCC DEPAS DEPX86ASM RANLIB RM
 
 MSG    = $@
 M      = @$(call ECHO,$(TAG),$@);
@@ -40,7 +37,8 @@ OBJCFLAGS  += $(EOBJCFLAGS)
 OBJCCFLAGS  = $(CPPFLAGS) $(CFLAGS) $(OBJCFLAGS)
 ASFLAGS    := $(CPPFLAGS) $(ASFLAGS)
 CXXFLAGS   := $(CPPFLAGS) $(CFLAGS) $(CXXFLAGS)
-YASMFLAGS  += $(IFLAGS:%=%/) -Pconfig.asm
+X86ASMFLAGS += $(IFLAGS:%=%/) -I$(<D)/ -Pconfig.asm
+NVCCFLAGS  += -ptx
 
 HOSTCCFLAGS = $(IFLAGS) $(HOSTCPPFLAGS) $(HOSTCFLAGS)
 LDFLAGS    := $(ALLFFLIBS:%=$(LD_PATH)lib%) $(LDFLAGS)
@@ -54,7 +52,9 @@ COMPILE_C = $(call COMPILE,CC)
 COMPILE_CXX = $(call COMPILE,CXX)
 COMPILE_S = $(call COMPILE,AS)
 COMPILE_M = $(call COMPILE,OBJCC)
+COMPILE_X86ASM = $(call COMPILE,X86ASM)
 COMPILE_HOSTC = $(call COMPILE,HOSTCC)
+COMPILE_NVCC = $(call COMPILE,NVCC)
 
 %.o: %.c
 	$(COMPILE_C)
@@ -74,6 +74,14 @@ COMPILE_HOSTC = $(call COMPILE,HOSTCC)
 %_host.o: %.c
 	$(COMPILE_HOSTC)
 
+%$(DEFAULT_X86ASMD).asm: %.asm
+	$(DEPX86ASM) $(X86ASMFLAGS) -M -o $@ $< > $(@:.asm=.d)
+	$(X86ASM) $(X86ASMFLAGS) -e $< | sed '/^%/d;/^$$/d;' > $@
+
+%.o: %.asm
+	$(COMPILE_X86ASM)
+	-$(if $(ASMSTRIPFLAGS), $(STRIP) $(ASMSTRIPFLAGS) $@)
+
 %.o: %.rc
 	$(WINDRES) $(IFLAGS) --preprocessor "$(DEPWINDRES) -E -xc-header -DRC_INVOKED $(CC_DEPFLAGS)" -o $@ $<
 
@@ -83,7 +91,13 @@ COMPILE_HOSTC = $(call COMPILE,HOSTCC)
 %.h.c:
 	$(Q)echo '#include "$*.h"' >$@
 
-%.c %.h %.ver: TAG = GEN
+%.ptx: %.cu
+	$(COMPILE_NVCC)
+
+%.ptx.c: %.ptx
+	$(Q)sh $(SRC_PATH)/compat/cuda/ptx2c.sh $@ $(patsubst $(SRC_PATH)/%,$(SRC_LINK)/%,$<)
+
+%.c %.h %.pc %.ver %.version: TAG = GEN
 
 # Dummy rule to stop make trying to rebuild removed or renamed headers
 %.h:
@@ -97,7 +111,7 @@ COMPILE_HOSTC = $(call COMPILE,HOSTCC)
 $(OBJS):
 endif
 
-include $(SRC_PATH)/arch.mak
+include $(SRC_PATH)/ffbuild/arch.mak
 
 OBJS      += $(OBJS-yes)
 SLIBOBJS  += $(SLIBOBJS-yes)
@@ -105,7 +119,7 @@ FFLIBS    := $($(NAME)_FFLIBS) $(FFLIBS-yes) $(FFLIBS)
 TESTPROGS += $(TESTPROGS-yes)
 
 LDLIBS       = $(FFLIBS:%=%$(BUILDSUF))
-FFEXTRALIBS := $(LDLIBS:%=$(LD_MYTH_LIB)) $(EXTRALIBS)
+FFEXTRALIBS := $(LDLIBS:%=$(LD_LIB)) $(EXTRALIBS)
 
 OBJS      := $(sort $(OBJS:%=$(SUBDIR)%))
 SLIBOBJS  := $(sort $(SLIBOBJS:%=$(SUBDIR)%))
@@ -127,8 +141,10 @@ ALLHEADERS := $(subst $(SRC_DIR)/,$(SUBDIR),$(wildcard $(SRC_DIR)/*.h $(SRC_DIR)
 SKIPHEADERS += $(ARCH_HEADERS:%=$(ARCH)/%) $(SKIPHEADERS-)
 SKIPHEADERS := $(SKIPHEADERS:%=$(SUBDIR)%)
 HOBJS        = $(filter-out $(SKIPHEADERS:.h=.h.o),$(ALLHEADERS:.h=.h.o))
+PTXOBJS      = $(filter %.ptx.o,$(OBJS))
+$(HOBJS):     CCFLAGS += $(CFLAGS_HEADERS)
 checkheaders: $(HOBJS)
-.SECONDARY:   $(HOBJS:.o=.c)
+.SECONDARY:   $(HOBJS:.o=.c) $(PTXOBJS:.o=.c) $(PTXOBJS:.o=)
 
 alltools: $(TOOLS)
 
@@ -136,7 +152,7 @@ $(HOSTOBJS): %.o: %.c
 	$(COMPILE_HOSTC)
 
 $(HOSTPROGS): %$(HOSTEXESUF): %.o
-	$(HOSTLD) $(HOSTLDFLAGS) $(HOSTLD_O) $^ $(HOSTLIBS)
+	$(HOSTLD) $(HOSTLDFLAGS) $(HOSTLD_O) $^ $(HOSTEXTRALIBS)
 
 $(OBJS):     | $(sort $(dir $(OBJS)))
 $(HOBJS):    | $(sort $(dir $(HOBJS)))
@@ -147,7 +163,7 @@ $(TOOLOBJS): | tools
 
 OBJDIRS := $(OBJDIRS) $(dir $(OBJS) $(HOBJS) $(HOSTOBJS) $(SLIBOBJS) $(TESTOBJS))
 
-CLEANSUFFIXES     = *.d *.o *~ *.h.c *.gcda *.gcno *.map *.ver *.ho *$(DEFAULT_YASMD).asm
+CLEANSUFFIXES     = *.d *.o *~ *.h.c *.gcda *.gcno *.map *.ver *.version *.ho *$(DEFAULT_X86ASMD).asm *.ptx *.ptx.c
 DISTCLEANSUFFIXES = *.pc
 LIBSUFFIXES       = *.a *.lib *.so *.so.* *.dylib *.dll *.def *.dll.a
 
@@ -158,4 +174,4 @@ endef
 
 $(eval $(RULES))
 
--include $(wildcard $(OBJS:.o=.d) $(HOSTOBJS:.o=.d) $(TESTOBJS:.o=.d) $(HOBJS:.o=.d) $(SLIBOBJS:.o=.d)) $(OBJS:.o=$(DEFAULT_YASMD).d)
+-include $(wildcard $(OBJS:.o=.d) $(HOSTOBJS:.o=.d) $(TESTOBJS:.o=.d) $(HOBJS:.o=.d) $(SLIBOBJS:.o=.d)) $(OBJS:.o=$(DEFAULT_X86ASMD).d)
diff --git a/mythtv/external/FFmpeg/ffbuild/library.mak b/mythtv/external/FFmpeg/ffbuild/library.mak
index 507b5d2efc7..f94cf854c13 100644
--- a/mythtv/external/FFmpeg/ffbuild/library.mak
+++ b/mythtv/external/FFmpeg/ffbuild/library.mak
@@ -1,6 +1,10 @@
-SRC_DIR := $(SRC_PATH_BARE)/lib$(NAME)
+#DO WE NEED THIS PGB #SRC_DIR := $(SRC_PATH_BARE)/lib$(NAME)
 
-include $(SRC_PATH_BARE)/external/FFmpeg/common.mak
+include $(SRC_PATH_BARE)/external/FFmpeg/ffbuild/common.mak
+
+ifeq (,$(filter %clean,$(MAKECMDGOALS)))
+-include $(SUBDIR)lib$(NAME).version
+endif
 
 LIBVERSION := $(lib$(NAME)_VERSION)
 LIBMAJOR   := $(lib$(NAME)_VERSION_MAJOR)
@@ -9,21 +13,11 @@ INCINSTDIR := $(INCDIR)/lib$(NAME)
 
 INSTHEADERS := $(INSTHEADERS) $(HEADERS:%=$(SUBDIR)%)
 
-all-$(CONFIG_STATIC): $(SUBDIR)$(LIBNAME)
-all-$(CONFIG_SHARED): $(SUBDIR)$(SLIBNAME)
-
-$(SUBDIR)x86/%$(DEFAULT_YASMD).asm: $(SUBDIR)x86/%.asm
-	$(DEPYASM) $(YASMFLAGS) -I $(<D)/ -M -o $@ $< > $(@:.asm=.d)
-	$(YASM) $(YASMFLAGS) -I $(<D)/ -e $< | sed '/^%/d;/^$$/d;' > $@
-
-$(SUBDIR)x86/%.o: $(SUBDIR)x86/%$(YASMD).asm
-	$(DEPYASM) $(YASMFLAGS) -I $(<D)/ -M -o $@ $< > $(@:.o=.d)
-	$(YASM) $(YASMFLAGS) -I $(<D)/ -o $@ $(patsubst $(SRC_PATH)/%,$(SRC_LINK)/%,$<)
-	-$(if $(ASMSTRIPFLAGS), $(STRIP) $(ASMSTRIPFLAGS) $@)
+all-$(CONFIG_STATIC): $(SUBDIR)$(LIBNAME)  $(SUBDIR)lib$(FULLNAME).pc
+all-$(CONFIG_SHARED): $(SUBDIR)$(SLIBNAME) $(SUBDIR)lib$(FULLNAME).pc
 
 LIBOBJS := $(OBJS) $(SUBDIR)%.h.o $(TESTOBJS)
 $(LIBOBJS) $(LIBOBJS:.o=.s) $(LIBOBJS:.o=.i):   CPPFLAGS += -DHAVE_AV_CONFIG_H
-$(TESTOBJS) $(TESTOBJS:.o=.i): CFLAGS += -Umain
 
 $(SUBDIR)$(LIBNAME): $(OBJS)
 	$(RM) $@
@@ -40,9 +34,15 @@ define RULES
 $(TOOLS):     THISLIB = $(FULLNAME:%=$(LD_LIB))
 $(TESTPROGS): THISLIB = $(SUBDIR)$(LIBNAME)
 
-$(TESTPROGS) $(TOOLS): %$(EXESUF): %.o $(EXEOBJS)
+$(TESTPROGS) $(TOOLS): %$(EXESUF): %.o
 	$$(LD) $(LDFLAGS) $(LDEXEFLAGS) $$(LD_O) $$(filter %.o,$$^) $$(THISLIB) $(FFEXTRALIBS) $$(ELIBS)
 
+$(SUBDIR)lib$(NAME).version: $(SUBDIR)version.h | $(SUBDIR)
+	$$(M) $$(SRC_PATH)/ffbuild/libversion.sh $(NAME) $$< > $$@
+
+$(SUBDIR)lib$(FULLNAME).pc: $(SUBDIR)version.h | $(SUBDIR)
+	$$(M) $$(SRC_PATH)/ffbuild/pkgconfig_generate.sh $(NAME) "$(DESC)"
+
 $(SUBDIR)lib$(NAME).ver: $(SUBDIR)lib$(NAME).v $(OBJS)
 	$$(M)sed 's/MAJOR/$(lib$(NAME)_VERSION_MAJOR)/' $$< | $(VERSION_SCRIPT_POSTPROCESS_CMD) > $$@
 
@@ -61,7 +61,7 @@ endif
 clean::
 	$(RM) $(addprefix $(SUBDIR),$(CLEANFILES) $(CLEANSUFFIXES) $(LIBSUFFIXES)) \
 	    $(CLEANSUFFIXES:%=$(SUBDIR)$(ARCH)/%) $(CLEANSUFFIXES:%=$(SUBDIR)tests/%)
- 
+
 distclean:: clean
 	$(RM) $(DISTCLEANSUFFIXES:%=$(SUBDIR)%) $(DISTCLEANSUFFIXES:%=$(SUBDIR)$(ARCH)/%) \
             $(DISTCLEANSUFFIXES:%=$(SUBDIR)tests/%)
diff --git a/mythtv/external/FFmpeg/ffbuild/libversion.sh b/mythtv/external/FFmpeg/ffbuild/libversion.sh
new file mode 100755
index 00000000000..990ce9f640e
--- /dev/null
+++ b/mythtv/external/FFmpeg/ffbuild/libversion.sh
@@ -0,0 +1,13 @@
+toupper(){
+    echo "$@" | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ
+}
+
+name=lib$1
+ucname=$(toupper ${name})
+file=$2
+
+eval $(awk "/#define ${ucname}_VERSION_M/ { print \$2 \"=\" \$3 }" "$file")
+eval ${ucname}_VERSION=\$${ucname}_VERSION_MAJOR.\$${ucname}_VERSION_MINOR.\$${ucname}_VERSION_MICRO
+eval echo "${name}_VERSION=\$${ucname}_VERSION"
+eval echo "${name}_VERSION_MAJOR=\$${ucname}_VERSION_MAJOR"
+eval echo "${name}_VERSION_MINOR=\$${ucname}_VERSION_MINOR"
diff --git a/mythtv/external/FFmpeg/ffbuild/pkgconfig_generate.sh b/mythtv/external/FFmpeg/ffbuild/pkgconfig_generate.sh
new file mode 100755
index 00000000000..e5de6716d28
--- /dev/null
+++ b/mythtv/external/FFmpeg/ffbuild/pkgconfig_generate.sh
@@ -0,0 +1,62 @@
+#!/bin/sh
+
+. ffbuild/config.sh
+
+if test "$shared" = "yes"; then
+    shared=true
+else
+    shared=false
+fi
+
+shortname=$1
+name=lib${shortname}
+fullname=${name}${build_suffix}
+comment=$2
+libs=$(eval echo \$extralibs_${shortname})
+deps=$(eval echo \$${shortname}_deps)
+
+for dep in $deps; do
+    depname=lib${dep}
+    fulldepname=${depname}${build_suffix}
+    . ${depname}/${depname}.version
+    depversion=$(eval echo \$${depname}_VERSION)
+    requires="$requires ${fulldepname} >= ${depversion}, "
+done
+requires=${requires%, }
+
+version=$(grep ${name}_VERSION= $name/${name}.version | cut -d= -f2)
+
+cat <<EOF > $name/$fullname.pc
+prefix=$prefix
+exec_prefix=\${prefix}
+libdir=$libdir
+includedir=$incdir
+
+Name: $fullname
+Description: $comment
+Version: $version
+Requires: $($shared || echo $requires)
+Requires.private: $($shared && echo $requires)
+Conflicts:
+Libs: -L\${libdir} $rpath -l${fullname#lib} $($shared || echo $libs)
+Libs.private: $($shared && echo $libs)
+Cflags: -I\${includedir}
+EOF
+
+mkdir -p doc/examples/pc-uninstalled
+includedir=${source_path}
+[ "$includedir" = . ] && includedir="\${pcfiledir}/../../.."
+    cat <<EOF > doc/examples/pc-uninstalled/${name}-uninstalled.pc
+prefix=
+exec_prefix=
+libdir=\${pcfiledir}/../../../$name
+includedir=${source_path}
+
+Name: $fullname
+Description: $comment
+Version: $version
+Requires: $requires
+Conflicts:
+Libs: -L\${libdir} -Wl,-rpath,\${libdir} -l${fullname#lib} $($shared || echo $libs)
+Cflags: -I\${includedir}
+EOF
diff --git a/mythtv/external/FFmpeg/fftools/Makefile b/mythtv/external/FFmpeg/fftools/Makefile
new file mode 100644
index 00000000000..27931393757
--- /dev/null
+++ b/mythtv/external/FFmpeg/fftools/Makefile
@@ -0,0 +1,66 @@
+AVPROGS-$(CONFIG_FFMPEG)   += ffmpeg
+AVPROGS-$(CONFIG_FFPLAY)   += ffplay
+AVPROGS-$(CONFIG_FFPROBE)  += ffprobe
+AVPROGS-$(CONFIG_FFSERVER) += ffserver
+
+AVPROGS     := $(AVPROGS-yes:%=%$(PROGSSUF)$(EXESUF))
+PROGS       += $(AVPROGS)
+MYTHPROGS   = $(addprefix myth, ${PROGS})
+
+AVBASENAMES  = ffmpeg ffplay ffprobe ffserver
+ALLAVPROGS   = $(AVBASENAMES:%=%$(PROGSSUF)$(EXESUF))
+ALLAVPROGS_G = $(AVBASENAMES:%=%$(PROGSSUF)_g$(EXESUF))
+
+OBJS-ffmpeg                        += fftools/ffmpeg_opt.o fftools/ffmpeg_filter.o fftools/ffmpeg_hw.o
+OBJS-ffmpeg-$(CONFIG_CUVID)        += fftools/ffmpeg_cuvid.o
+OBJS-ffmpeg-$(CONFIG_LIBMFX)       += fftools/ffmpeg_qsv.o
+ifndef CONFIG_VIDEOTOOLBOX
+OBJS-ffmpeg-$(CONFIG_VDA)          += fftools/ffmpeg_videotoolbox.o
+endif
+OBJS-ffmpeg-$(CONFIG_VIDEOTOOLBOX) += fftools/ffmpeg_videotoolbox.o
+OBJS-ffserver                      += fftools/ffserver_config.o
+
+define DOFFTOOL
+OBJS-$(1) += fftools/cmdutils.o fftools/$(1).o $(OBJS-$(1)-yes)
+$(1)$(PROGSSUF)_g$(EXESUF): $$(OBJS-$(1))
+$$(OBJS-$(1)): | fftools
+$$(OBJS-$(1)): CFLAGS  += $(CFLAGS-$(1))
+$(1)$(PROGSSUF)_g$(EXESUF): LDFLAGS += $(LDFLAGS-$(1))
+$(1)$(PROGSSUF)_g$(EXESUF): FF_EXTRALIBS += $(EXTRALIBS-$(1))
+-include $$(OBJS-$(1):.o=.d)
+endef
+
+$(foreach P,$(AVPROGS-yes),$(eval OBJS-$(P)-$(CONFIG_OPENCL) += fftools/cmdutils_opencl.o))
+$(foreach P,$(AVPROGS-yes),$(eval $(call DOFFTOOL,$(P))))
+
+all: $(AVPROGS)
+
+fftools/ffprobe.o fftools/cmdutils.o: libavutil/ffversion.h | fftools
+OBJDIRS += fftools
+
+${MYTHPROGS}: myth%: %
+	$(CP) $< $@
+
+ifdef AVPROGS
+install: install-mythprogs
+
+endif
+
+install-progs-yes:
+install-progs-$(CONFIG_SHARED): install-libs
+
+install-progs: install-progs-yes $(AVPROGS)
+	$(Q)mkdir -p "$(BINDIR)"
+	$(INSTALL) -c -m 755 $(AVPROGS) "$(BINDIR)"
+
+install-mythprogs: install-progs-yes $(MYTHPROGS)
+	$(Q)mkdir -p "$(BINDIR)"
+	$(INSTALL) -c -m 755 $(MYTHPROGS) "$(BINDIR)"
+
+uninstall: uninstall-progs
+
+uninstall-progs:
+	$(RM) $(addprefix "$(BINDIR)/", $(ALLAVPROGS))
+
+clean::
+	$(RM) $(ALLAVPROGS) $(ALLAVPROGS_G) $(CLEANSUFFIXES:%=fftools/%)
diff --git a/mythtv/external/FFmpeg/fftools/cmdutils.c b/mythtv/external/FFmpeg/fftools/cmdutils.c
index 469c2d557c9..3d428f3eea8 100644
--- a/mythtv/external/FFmpeg/fftools/cmdutils.c
+++ b/mythtv/external/FFmpeg/fftools/cmdutils.c
@@ -75,6 +75,12 @@ static FILE *report_file;
 static int report_file_level = AV_LOG_DEBUG;
 int hide_banner = 0;
 
+enum show_muxdemuxers {
+    SHOW_DEFAULT,
+    SHOW_DEMUXERS,
+    SHOW_MUXERS,
+};
+
 void init_opts(void)
 {
     av_dict_set(&sws_dict, "flags", "bicubic", 0);
@@ -225,7 +231,6 @@ static const OptionDef *find_option(const OptionDef *po, const char *name)
  * by default. HAVE_COMMANDLINETOARGVW is true on cygwin, while
  * it doesn't provide the actual command line via GetCommandLineW(). */
 #if HAVE_COMMANDLINETOARGVW && defined(_WIN32)
-#include <windows.h>
 #include <shellapi.h>
 /* Will be leaked on exit */
 static char** win32_argv_utf8 = NULL;
@@ -1251,7 +1256,7 @@ static int is_device(const AVClass *avclass)
     return AV_IS_INPUT_DEVICE(avclass->category) || AV_IS_OUTPUT_DEVICE(avclass->category);
 }
 
-static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only)
+static int show_formats_devices(void *optctx, const char *opt, const char *arg, int device_only, int muxdemuxers)
 {
     AVInputFormat *ifmt  = NULL;
     AVOutputFormat *ofmt = NULL;
@@ -1269,29 +1274,33 @@ static int show_formats_devices(void *optctx, const char *opt, const char *arg,
         const char *name      = NULL;
         const char *long_name = NULL;
 
-        while ((ofmt = av_oformat_next(ofmt))) {
-            is_dev = is_device(ofmt->priv_class);
-            if (!is_dev && device_only)
-                continue;
-            if ((!name || strcmp(ofmt->name, name) < 0) &&
-                strcmp(ofmt->name, last_name) > 0) {
-                name      = ofmt->name;
-                long_name = ofmt->long_name;
-                encode    = 1;
+        if (muxdemuxers !=SHOW_DEMUXERS) {
+            while ((ofmt = av_oformat_next(ofmt))) {
+                is_dev = is_device(ofmt->priv_class);
+                if (!is_dev && device_only)
+                    continue;
+                if ((!name || strcmp(ofmt->name, name) < 0) &&
+                    strcmp(ofmt->name, last_name) > 0) {
+                    name      = ofmt->name;
+                    long_name = ofmt->long_name;
+                    encode    = 1;
+                }
             }
         }
-        while ((ifmt = av_iformat_next(ifmt))) {
-            is_dev = is_device(ifmt->priv_class);
-            if (!is_dev && device_only)
-                continue;
-            if ((!name || strcmp(ifmt->name, name) < 0) &&
-                strcmp(ifmt->name, last_name) > 0) {
-                name      = ifmt->name;
-                long_name = ifmt->long_name;
-                encode    = 0;
+        if (muxdemuxers != SHOW_MUXERS) {
+            while ((ifmt = av_iformat_next(ifmt))) {
+                is_dev = is_device(ifmt->priv_class);
+                if (!is_dev && device_only)
+                    continue;
+                if ((!name || strcmp(ifmt->name, name) < 0) &&
+                    strcmp(ifmt->name, last_name) > 0) {
+                    name      = ifmt->name;
+                    long_name = ifmt->long_name;
+                    encode    = 0;
+                }
+                if (name && strcmp(ifmt->name, name) == 0)
+                    decode = 1;
             }
-            if (name && strcmp(ifmt->name, name) == 0)
-                decode = 1;
         }
         if (!name)
             break;
@@ -1308,12 +1317,22 @@ static int show_formats_devices(void *optctx, const char *opt, const char *arg,
 
 int show_formats(void *optctx, const char *opt, const char *arg)
 {
-    return show_formats_devices(optctx, opt, arg, 0);
+    return show_formats_devices(optctx, opt, arg, 0, SHOW_DEFAULT);
+}
+
+int show_muxers(void *optctx, const char *opt, const char *arg)
+{
+    return show_formats_devices(optctx, opt, arg, 0, SHOW_MUXERS);
+}
+
+int show_demuxers(void *optctx, const char *opt, const char *arg)
+{
+    return show_formats_devices(optctx, opt, arg, 0, SHOW_DEMUXERS);
 }
 
 int show_devices(void *optctx, const char *opt, const char *arg)
 {
-    return show_formats_devices(optctx, opt, arg, 1);
+    return show_formats_devices(optctx, opt, arg, 1, SHOW_DEFAULT);
 }
 
 #define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
@@ -2078,18 +2097,10 @@ void *grow_array(void *array, int elem_size, int *size, int new_size)
 
 double get_rotation(AVStream *st)
 {
-    AVDictionaryEntry *rotate_tag = av_dict_get(st->metadata, "rotate", NULL, 0);
     uint8_t* displaymatrix = av_stream_get_side_data(st,
                                                      AV_PKT_DATA_DISPLAYMATRIX, NULL);
     double theta = 0;
-
-    if (rotate_tag && *rotate_tag->value && strcmp(rotate_tag->value, "0")) {
-        char *tail;
-        theta = av_strtod(rotate_tag->value, &tail);
-        if (*tail)
-            theta = 0;
-    }
-    if (displaymatrix && !theta)
+    if (displaymatrix)
         theta = -av_display_rotation_get((int32_t*) displaymatrix);
 
     theta -= 360*floor(theta/360 + 0.9/360);
diff --git a/mythtv/external/FFmpeg/fftools/cmdutils.h b/mythtv/external/FFmpeg/fftools/cmdutils.h
index 1b96aa48d11..2997ee37b5a 100644
--- a/mythtv/external/FFmpeg/fftools/cmdutils.h
+++ b/mythtv/external/FFmpeg/fftools/cmdutils.h
@@ -19,8 +19,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#ifndef CMDUTILS_H
-#define CMDUTILS_H
+#ifndef FFTOOLS_CMDUTILS_H
+#define FFTOOLS_CMDUTILS_H
 
 #include <stdint.h>
 
@@ -206,6 +206,59 @@ typedef struct OptionDef {
 void show_help_options(const OptionDef *options, const char *msg, int req_flags,
                        int rej_flags, int alt_flags);
 
+#if CONFIG_OPENCL
+#define CMDUTILS_COMMON_OPTIONS_OPENCL                                                                                  \
+    { "opencl_bench", OPT_EXIT, {.func_arg = opt_opencl_bench},                                                         \
+       "run benchmark on all OpenCL devices and show results" },                                                        \
+    { "opencl_options", HAS_ARG, {.func_arg = opt_opencl},                                                              \
+       "set OpenCL environment options" },                                                                              \
+
+#else
+#define CMDUTILS_COMMON_OPTIONS_OPENCL
+#endif
+
+#if CONFIG_AVDEVICE
+#define CMDUTILS_COMMON_OPTIONS_AVDEVICE                                                                                \
+    { "sources"    , OPT_EXIT | HAS_ARG, { .func_arg = show_sources },                                                  \
+      "list sources of the input device", "device" },                                                                   \
+    { "sinks"      , OPT_EXIT | HAS_ARG, { .func_arg = show_sinks },                                                    \
+      "list sinks of the output device", "device" },                                                                    \
+
+#else
+#define CMDUTILS_COMMON_OPTIONS_AVDEVICE
+#endif
+
+#define CMDUTILS_COMMON_OPTIONS                                                                                         \
+    { "L",           OPT_EXIT,             { .func_arg = show_license },     "show license" },                          \
+    { "h",           OPT_EXIT,             { .func_arg = show_help },        "show help", "topic" },                    \
+    { "?",           OPT_EXIT,             { .func_arg = show_help },        "show help", "topic" },                    \
+    { "help",        OPT_EXIT,             { .func_arg = show_help },        "show help", "topic" },                    \
+    { "-help",       OPT_EXIT,             { .func_arg = show_help },        "show help", "topic" },                    \
+    { "version",     OPT_EXIT,             { .func_arg = show_version },     "show version" },                          \
+    { "buildconf",   OPT_EXIT,             { .func_arg = show_buildconf },   "show build configuration" },              \
+    { "formats",     OPT_EXIT,             { .func_arg = show_formats },     "show available formats" },                \
+    { "muxers",      OPT_EXIT,             { .func_arg = show_muxers },      "show available muxers" },                 \
+    { "demuxers",    OPT_EXIT,             { .func_arg = show_demuxers },    "show available demuxers" },               \
+    { "devices",     OPT_EXIT,             { .func_arg = show_devices },     "show available devices" },                \
+    { "codecs",      OPT_EXIT,             { .func_arg = show_codecs },      "show available codecs" },                 \
+    { "decoders",    OPT_EXIT,             { .func_arg = show_decoders },    "show available decoders" },               \
+    { "encoders",    OPT_EXIT,             { .func_arg = show_encoders },    "show available encoders" },               \
+    { "bsfs",        OPT_EXIT,             { .func_arg = show_bsfs },        "show available bit stream filters" },     \
+    { "protocols",   OPT_EXIT,             { .func_arg = show_protocols },   "show available protocols" },              \
+    { "filters",     OPT_EXIT,             { .func_arg = show_filters },     "show available filters" },                \
+    { "pix_fmts",    OPT_EXIT,             { .func_arg = show_pix_fmts },    "show available pixel formats" },          \
+    { "layouts",     OPT_EXIT,             { .func_arg = show_layouts },     "show standard channel layouts" },         \
+    { "sample_fmts", OPT_EXIT,             { .func_arg = show_sample_fmts }, "show available audio sample formats" },   \
+    { "colors",      OPT_EXIT,             { .func_arg = show_colors },      "show available color names" },            \
+    { "loglevel",    HAS_ARG,              { .func_arg = opt_loglevel },     "set logging level", "loglevel" },         \
+    { "v",           HAS_ARG,              { .func_arg = opt_loglevel },     "set logging level", "loglevel" },         \
+    { "report",      0,                    { (void*)opt_report },            "generate a report" },                     \
+    { "max_alloc",   HAS_ARG,              { .func_arg = opt_max_alloc },    "set maximum size of a single allocated block", "bytes" }, \
+    { "cpuflags",    HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },     "force specific cpu flags", "flags" },     \
+    { "hide_banner", OPT_BOOL | OPT_EXPERT, {&hide_banner},     "do not show program banner", "hide_banner" },          \
+    CMDUTILS_COMMON_OPTIONS_OPENCL                                                                                      \
+    CMDUTILS_COMMON_OPTIONS_AVDEVICE                                                                                    \
+
 /**
  * Show help for all options with given flags in class and all its
  * children.
@@ -441,6 +494,20 @@ int show_license(void *optctx, const char *opt, const char *arg);
  */
 int show_formats(void *optctx, const char *opt, const char *arg);
 
+/**
+ * Print a listing containing all the muxers supported by the
+ * program (including devices).
+ * This option processing function does not utilize the arguments.
+ */
+int show_muxers(void *optctx, const char *opt, const char *arg);
+
+/**
+ * Print a listing containing all the demuxer supported by the
+ * program (including devices).
+ * This option processing function does not utilize the arguments.
+ */
+int show_demuxers(void *optctx, const char *opt, const char *arg);
+
 /**
  * Print a listing containing all the devices supported by the
  * program.
@@ -592,4 +659,4 @@ void *grow_array(void *array, int elem_size, int *size, int new_size);
 
 double get_rotation(AVStream *st);
 
-#endif /* CMDUTILS_H */
+#endif /* FFTOOLS_CMDUTILS_H */
diff --git a/mythtv/external/FFmpeg/fftools/cmdutils_common_opts.h b/mythtv/external/FFmpeg/fftools/cmdutils_common_opts.h
deleted file mode 100644
index 758dac194c6..00000000000
--- a/mythtv/external/FFmpeg/fftools/cmdutils_common_opts.h
+++ /dev/null
@@ -1,35 +0,0 @@
-    { "L"          , OPT_EXIT, {.func_arg = show_license},      "show license" },
-    { "h"          , OPT_EXIT, {.func_arg = show_help},         "show help", "topic" },
-    { "?"          , OPT_EXIT, {.func_arg = show_help},         "show help", "topic" },
-    { "help"       , OPT_EXIT, {.func_arg = show_help},         "show help", "topic" },
-    { "-help"      , OPT_EXIT, {.func_arg = show_help},         "show help", "topic" },
-    { "version"    , OPT_EXIT, {.func_arg = show_version},      "show version" },
-    { "buildconf"  , OPT_EXIT, {.func_arg = show_buildconf},    "show build configuration" },
-    { "formats"    , OPT_EXIT, {.func_arg = show_formats  },    "show available formats" },
-    { "devices"    , OPT_EXIT, {.func_arg = show_devices  },    "show available devices" },
-    { "codecs"     , OPT_EXIT, {.func_arg = show_codecs   },    "show available codecs" },
-    { "decoders"   , OPT_EXIT, {.func_arg = show_decoders },    "show available decoders" },
-    { "encoders"   , OPT_EXIT, {.func_arg = show_encoders },    "show available encoders" },
-    { "bsfs"       , OPT_EXIT, {.func_arg = show_bsfs     },    "show available bit stream filters" },
-    { "protocols"  , OPT_EXIT, {.func_arg = show_protocols},    "show available protocols" },
-    { "filters"    , OPT_EXIT, {.func_arg = show_filters  },    "show available filters" },
-    { "pix_fmts"   , OPT_EXIT, {.func_arg = show_pix_fmts },    "show available pixel formats" },
-    { "layouts"    , OPT_EXIT, {.func_arg = show_layouts  },    "show standard channel layouts" },
-    { "sample_fmts", OPT_EXIT, {.func_arg = show_sample_fmts }, "show available audio sample formats" },
-    { "colors"     , OPT_EXIT, {.func_arg = show_colors },      "show available color names" },
-    { "loglevel"   , HAS_ARG,  {.func_arg = opt_loglevel},      "set logging level", "loglevel" },
-    { "v",           HAS_ARG,  {.func_arg = opt_loglevel},      "set logging level", "loglevel" },
-    { "report"     , 0,        {(void*)opt_report}, "generate a report" },
-    { "max_alloc"  , HAS_ARG,  {.func_arg = opt_max_alloc},     "set maximum size of a single allocated block", "bytes" },
-    { "cpuflags"   , HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags }, "force specific cpu flags", "flags" },
-    { "hide_banner", OPT_BOOL | OPT_EXPERT, {&hide_banner},     "do not show program banner", "hide_banner" },
-#if CONFIG_OPENCL
-    { "opencl_bench", OPT_EXIT, {.func_arg = opt_opencl_bench}, "run benchmark on all OpenCL devices and show results" },
-    { "opencl_options", HAS_ARG, {.func_arg = opt_opencl},      "set OpenCL environment options" },
-#endif
-#if CONFIG_AVDEVICE
-    { "sources"    , OPT_EXIT | HAS_ARG, { .func_arg = show_sources },
-      "list sources of the input device", "device" },
-    { "sinks"      , OPT_EXIT | HAS_ARG, { .func_arg = show_sinks },
-      "list sinks of the output device", "device" },
-#endif
diff --git a/mythtv/external/FFmpeg/fftools/cmdutils_opencl.c b/mythtv/external/FFmpeg/fftools/cmdutils_opencl.c
index dd21344a056..906aef48363 100644
--- a/mythtv/external/FFmpeg/fftools/cmdutils_opencl.c
+++ b/mythtv/external/FFmpeg/fftools/cmdutils_opencl.c
@@ -129,11 +129,11 @@ static int64_t run_opencl_bench(AVOpenCLExternalEnv *ext_opencl_env)
     cl_int status;
     size_t kernel_len;
     char *inbuf;
-    int *mask;
+    int *mask = NULL;
     int buf_size = width * height * sizeof(char);
     int mask_size = sizeof(uint32_t) * 128;
 
-    cl_mem cl_mask, cl_inbuf, cl_outbuf;
+    cl_mem cl_mask = NULL, cl_inbuf = NULL, cl_outbuf = NULL;
     cl_kernel kernel = NULL;
     cl_program program = NULL;
     size_t local_work_size_2d[2] = {16, 16};
@@ -213,22 +213,27 @@ static int compare_ocl_device_desc(const void *a, const void *b)
 
 int opt_opencl_bench(void *optctx, const char *opt, const char *arg)
 {
-    int i, j, nb_devices = 0, count = 0;
+    int i, j, nb_devices = 0, count = 0, ret = 0;
     int64_t score = 0;
     AVOpenCLDeviceList *device_list;
     AVOpenCLDeviceNode *device_node = NULL;
     OpenCLDeviceBenchmark *devices = NULL;
     cl_platform_id platform;
 
-    av_opencl_get_device_list(&device_list);
+    ret = av_opencl_get_device_list(&device_list);
+    if (ret < 0) {
+        return ret;
+    }
     for (i = 0; i < device_list->platform_num; i++)
         nb_devices += device_list->platform_node[i]->device_num;
     if (!nb_devices) {
         av_log(NULL, AV_LOG_ERROR, "No OpenCL device detected!\n");
+        av_opencl_free_device_list(&device_list);
         return AVERROR(EINVAL);
     }
     if (!(devices = av_malloc_array(nb_devices, sizeof(OpenCLDeviceBenchmark)))) {
         av_log(NULL, AV_LOG_ERROR, "Could not allocate buffer\n");
+        av_opencl_free_device_list(&device_list);
         return AVERROR(ENOMEM);
     }
 
diff --git a/mythtv/external/FFmpeg/fftools/ffmpeg.c b/mythtv/external/FFmpeg/fftools/ffmpeg.c
index 3b9171090f2..d581b40bf2f 100644
--- a/mythtv/external/FFmpeg/fftools/ffmpeg.c
+++ b/mythtv/external/FFmpeg/fftools/ffmpeg.c
@@ -30,6 +30,7 @@
 #include <stdlib.h>
 #include <errno.h>
 #include <limits.h>
+#include <stdatomic.h>
 #include <stdint.h>
 
 #if HAVE_IO_H
@@ -47,9 +48,11 @@
 #include "libavutil/parseutils.h"
 #include "libavutil/samplefmt.h"
 #include "libavutil/fifo.h"
+#include "libavutil/hwcontext.h"
 #include "libavutil/internal.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/dict.h"
+#include "libavutil/display.h"
 #include "libavutil/mathematics.h"
 #include "libavutil/pixdesc.h"
 #include "libavutil/avstring.h"
@@ -123,9 +126,11 @@ const char *const forced_keyframes_const_names[] = {
 static void do_video_stats(OutputStream *ost, int frame_size);
 static int64_t getutime(void);
 static int64_t getmaxrss(void);
+static int ifilter_has_all_input_formats(FilterGraph *fg);
 
 static int run_as_daemon  = 0;
 static int nb_frames_dup = 0;
+static unsigned dup_warning = 1000;
 static int nb_frames_drop = 0;
 static int64_t decode_error_stat[2];
 
@@ -224,7 +229,7 @@ static void sub2video_push_ref(InputStream *ist, int64_t pts)
                                      AV_BUFFERSRC_FLAG_PUSH);
 }
 
-static void sub2video_update(InputStream *ist, AVSubtitle *sub)
+void sub2video_update(InputStream *ist, AVSubtitle *sub)
 {
     AVFrame *frame = ist->sub2video.frame;
     int8_t *dst;
@@ -315,7 +320,7 @@ void term_exit(void)
 
 static volatile int received_sigterm = 0;
 static volatile int received_nb_signals = 0;
-static volatile int transcode_init_done = 0;
+static atomic_int transcode_init_done = ATOMIC_VAR_INIT(0);
 static volatile int ffmpeg_exited = 0;
 static int main_return_code = 0;
 
@@ -453,7 +458,7 @@ static int read_key(void)
 
 static int decode_interrupt_cb(void *ctx)
 {
-    return received_nb_signals > transcode_init_done;
+    return received_nb_signals > atomic_load(&transcode_init_done);
 }
 
 const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
@@ -471,12 +476,32 @@ static void ffmpeg_cleanup(int ret)
         FilterGraph *fg = filtergraphs[i];
         avfilter_graph_free(&fg->graph);
         for (j = 0; j < fg->nb_inputs; j++) {
+            while (av_fifo_size(fg->inputs[j]->frame_queue)) {
+                AVFrame *frame;
+                av_fifo_generic_read(fg->inputs[j]->frame_queue, &frame,
+                                     sizeof(frame), NULL);
+                av_frame_free(&frame);
+            }
+            av_fifo_freep(&fg->inputs[j]->frame_queue);
+            if (fg->inputs[j]->ist->sub2video.sub_queue) {
+                while (av_fifo_size(fg->inputs[j]->ist->sub2video.sub_queue)) {
+                    AVSubtitle sub;
+                    av_fifo_generic_read(fg->inputs[j]->ist->sub2video.sub_queue,
+                                         &sub, sizeof(sub), NULL);
+                    avsubtitle_free(&sub);
+                }
+                av_fifo_freep(&fg->inputs[j]->ist->sub2video.sub_queue);
+            }
+            av_buffer_unref(&fg->inputs[j]->hw_frames_ctx);
             av_freep(&fg->inputs[j]->name);
             av_freep(&fg->inputs[j]);
         }
         av_freep(&fg->inputs);
         for (j = 0; j < fg->nb_outputs; j++) {
             av_freep(&fg->outputs[j]->name);
+            av_freep(&fg->outputs[j]->formats);
+            av_freep(&fg->outputs[j]->channel_layouts);
+            av_freep(&fg->outputs[j]->sample_rates);
             av_freep(&fg->outputs[j]);
         }
         av_freep(&fg->outputs);
@@ -511,7 +536,6 @@ static void ffmpeg_cleanup(int ret)
         for (j = 0; j < ost->nb_bitstream_filters; j++)
             av_bsf_free(&ost->bsf_ctx[j]);
         av_freep(&ost->bsf_ctx);
-        av_freep(&ost->bsf_extradata_updated);
 
         av_frame_free(&ost->filtered_frame);
         av_frame_free(&ost->last_frame);
@@ -533,12 +557,14 @@ static void ffmpeg_cleanup(int ret)
         avcodec_free_context(&ost->enc_ctx);
         avcodec_parameters_free(&ost->ref_par);
 
-        while (ost->muxing_queue && av_fifo_size(ost->muxing_queue)) {
-            AVPacket pkt;
-            av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
-            av_packet_unref(&pkt);
+        if (ost->muxing_queue) {
+            while (av_fifo_size(ost->muxing_queue)) {
+                AVPacket pkt;
+                av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
+                av_packet_unref(&pkt);
+            }
+            av_fifo_freep(&ost->muxing_queue);
         }
-        av_fifo_freep(&ost->muxing_queue);
 
         av_freep(&output_streams[i]);
     }
@@ -586,7 +612,7 @@ static void ffmpeg_cleanup(int ret)
     if (received_sigterm) {
         av_log(NULL, AV_LOG_INFO, "Exiting normally, received signal %d.\n",
                (int) received_sigterm);
-    } else if (ret && transcode_init_done) {
+    } else if (ret && atomic_load(&transcode_init_done)) {
         av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");
     }
     term_exit();
@@ -642,14 +668,30 @@ static void close_all_output_streams(OutputStream *ost, OSTFinished this_stream,
     }
 }
 
-static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
+static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
 {
     AVFormatContext *s = of->ctx;
     AVStream *st = ost->st;
     int ret;
 
+    /*
+     * Audio encoders may split the packets --  #frames in != #packets out.
+     * But there is no reordering, so we can limit the number of output packets
+     * by simply dropping them here.
+     * Counting encoded video frames needs to be done separately because of
+     * reordering, see do_video_out().
+     * Do not count the packet when unqueued because it has been counted when queued.
+     */
+    if (!(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && ost->encoding_needed) && !unqueue) {
+        if (ost->frame_number >= ost->max_frames) {
+            av_packet_unref(pkt);
+            return;
+        }
+        ost->frame_number++;
+    }
+
     if (!of->header_written) {
-        AVPacket tmp_pkt;
+        AVPacket tmp_pkt = {0};
         /* the muxer is not initialized yet, buffer the packet */
         if (!av_fifo_space(ost->muxing_queue)) {
             int new_size = FFMIN(2 * av_fifo_size(ost->muxing_queue),
@@ -664,8 +706,11 @@ static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
             if (ret < 0)
                 exit_program(1);
         }
-        av_packet_move_ref(&tmp_pkt, pkt);
+        ret = av_packet_ref(&tmp_pkt, pkt);
+        if (ret < 0)
+            exit_program(1);
         av_fifo_generic_write(ost->muxing_queue, &tmp_pkt, sizeof(tmp_pkt), NULL);
+        av_packet_unref(pkt);
         return;
     }
 
@@ -673,20 +718,6 @@ static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
         (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
 
-    /*
-     * Audio encoders may split the packets --  #frames in != #packets out.
-     * But there is no reordering, so we can limit the number of output packets
-     * by simply dropping them here.
-     * Counting encoded video frames needs to be done separately because of
-     * reordering, see do_video_out()
-     */
-    if (!(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && ost->encoding_needed)) {
-        if (ost->frame_number >= ost->max_frames) {
-            av_packet_unref(pkt);
-            return;
-        }
-        ost->frame_number++;
-    }
     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
         int i;
         uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
@@ -705,10 +736,12 @@ static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
             if (pkt->duration > 0)
                 av_log(NULL, AV_LOG_WARNING, "Overriding packet duration by frame rate, this should not happen\n");
             pkt->duration = av_rescale_q(1, av_inv_q(ost->frame_rate),
-                                         ost->st->time_base);
+                                         ost->mux_timebase);
         }
     }
 
+    av_packet_rescale_ts(pkt, ost->mux_timebase, ost->st->time_base);
+
     if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
         if (pkt->dts != AV_NOPTS_VALUE &&
             pkt->pts != AV_NOPTS_VALUE &&
@@ -781,7 +814,19 @@ static void close_output_stream(OutputStream *ost)
     }
 }
 
-static void output_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
+/*
+ * Send a single packet to the output, applying any bitstream filters
+ * associated with the output stream.  This may result in any number
+ * of packets actually being written, depending on what bitstream
+ * filters are applied.  The supplied packet is consumed and will be
+ * blank (as if newly-allocated) when this function returns.
+ *
+ * If eof is set, instead indicate EOF to all bitstream filters and
+ * therefore flush any delayed packets to the output.  A blank packet
+ * must be supplied in this case.
+ */
+static void output_packet(OutputFile *of, AVPacket *pkt,
+                          OutputStream *ost, int eof)
 {
     int ret = 0;
 
@@ -789,50 +834,38 @@ static void output_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
     if (ost->nb_bitstream_filters) {
         int idx;
 
-        ret = av_bsf_send_packet(ost->bsf_ctx[0], pkt);
+        ret = av_bsf_send_packet(ost->bsf_ctx[0], eof ? NULL : pkt);
         if (ret < 0)
             goto finish;
 
+        eof = 0;
         idx = 1;
         while (idx) {
             /* get a packet from the previous filter up the chain */
             ret = av_bsf_receive_packet(ost->bsf_ctx[idx - 1], pkt);
-            /* HACK! - aac_adtstoasc updates extradata after filtering the first frame when
-             * the api states this shouldn't happen after init(). Propagate it here to the
-             * muxer and to the next filters in the chain to workaround this.
-             * TODO/FIXME - Make aac_adtstoasc use new packet side data instead of changing
-             * par_out->extradata and adapt muxers accordingly to get rid of this. */
-            if (!(ost->bsf_extradata_updated[idx - 1] & 1)) {
-                ret = avcodec_parameters_copy(ost->st->codecpar, ost->bsf_ctx[idx - 1]->par_out);
-                if (ret < 0)
-                    goto finish;
-                ost->bsf_extradata_updated[idx - 1] |= 1;
-            }
             if (ret == AVERROR(EAGAIN)) {
                 ret = 0;
                 idx--;
                 continue;
+            } else if (ret == AVERROR_EOF) {
+                eof = 1;
             } else if (ret < 0)
                 goto finish;
 
             /* send it to the next filter down the chain or to the muxer */
             if (idx < ost->nb_bitstream_filters) {
-                /* HACK/FIXME! - See above */
-                if (!(ost->bsf_extradata_updated[idx] & 2)) {
-                    ret = avcodec_parameters_copy(ost->bsf_ctx[idx]->par_out, ost->bsf_ctx[idx - 1]->par_out);
-                    if (ret < 0)
-                        goto finish;
-                    ost->bsf_extradata_updated[idx] |= 2;
-                }
-                ret = av_bsf_send_packet(ost->bsf_ctx[idx], pkt);
+                ret = av_bsf_send_packet(ost->bsf_ctx[idx], eof ? NULL : pkt);
                 if (ret < 0)
                     goto finish;
                 idx++;
-            } else
-                write_packet(of, pkt, ost);
+                eof = 0;
+            } else if (eof)
+                goto finish;
+            else
+                write_packet(of, pkt, ost, 0);
         }
-    } else
-        write_packet(of, pkt, ost);
+    } else if (!eof)
+        write_packet(of, pkt, ost, 0);
 
 finish:
     if (ret < 0 && ret != AVERROR_EOF) {
@@ -898,16 +931,16 @@ static void do_audio_out(OutputFile *of, OutputStream *ost,
 
         update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
 
-        av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
+        av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
 
         if (debug_ts) {
             av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
                    "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
-                   av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
-                   av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
+                   av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
+                   av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
         }
 
-        output_packet(of, &pkt, ost);
+        output_packet(of, &pkt, ost, 0);
     }
 
     return;
@@ -984,18 +1017,18 @@ static void do_subtitle_out(OutputFile *of,
         av_init_packet(&pkt);
         pkt.data = subtitle_out;
         pkt.size = subtitle_out_size;
-        pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
-        pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
+        pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->mux_timebase);
+        pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
         if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
             /* XXX: the pts correction is handled here. Maybe handling
                it in the codec would be better */
             if (i == 0)
-                pkt.pts += 90 * sub->start_display_time;
+                pkt.pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
             else
-                pkt.pts += 90 * sub->end_display_time;
+                pkt.pts += av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
         }
         pkt.dts = pkt.pts;
-        output_packet(of, &pkt, ost);
+        output_packet(of, &pkt, ost, 0);
     }
 }
 
@@ -1008,6 +1041,7 @@ static void do_video_out(OutputFile *of,
     AVPacket pkt;
     AVCodecContext *enc = ost->enc_ctx;
     AVCodecParameters *mux_par = ost->st->codecpar;
+    AVRational frame_rate;
     int nb_frames, nb0_frames, i;
     double delta, delta0;
     double duration = 0;
@@ -1018,9 +1052,9 @@ static void do_video_out(OutputFile *of,
     if (ost->source_index >= 0)
         ist = input_streams[ost->source_index];
 
-    if (filter->inputs[0]->frame_rate.num > 0 &&
-        filter->inputs[0]->frame_rate.den > 0)
-        duration = 1/(av_q2d(filter->inputs[0]->frame_rate) * av_q2d(enc->time_base));
+    frame_rate = av_buffersink_get_frame_rate(filter);
+    if (frame_rate.num > 0 && frame_rate.den > 0)
+        duration = 1/(av_q2d(frame_rate) * av_q2d(enc->time_base));
 
     if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
         duration = FFMIN(duration, 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base)));
@@ -1029,8 +1063,8 @@ static void do_video_out(OutputFile *of,
         !ost->filters &&
         next_picture &&
         ist &&
-        lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
-        duration = lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));
+        lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
+        duration = lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));
     }
 
     if (!next_picture) {
@@ -1134,6 +1168,10 @@ static void do_video_out(OutputFile *of,
         }
         nb_frames_dup += nb_frames - (nb0_frames && ost->last_dropped) - (nb_frames > nb0_frames);
         av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
+        if (nb_frames_dup > dup_warning) {
+            av_log(NULL, AV_LOG_WARNING, "More than %d frames duplicated\n", dup_warning);
+            dup_warning *= 10;
+        }
     }
     ost->last_dropped = nb_frames == nb0_frames && next_picture;
 
@@ -1173,10 +1211,10 @@ static void do_video_out(OutputFile *of,
             mux_par->field_order = AV_FIELD_PROGRESSIVE;
         pkt.data   = (uint8_t *)in_picture;
         pkt.size   =  sizeof(AVPicture);
-        pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
+        pkt.pts    = av_rescale_q(in_picture->pts, enc->time_base, ost->mux_timebase);
         pkt.flags |= AV_PKT_FLAG_KEY;
 
-        output_packet(of, &pkt, ost);
+        output_packet(of, &pkt, ost, 0);
     } else
 #endif
     {
@@ -1269,17 +1307,17 @@ static void do_video_out(OutputFile *of,
             if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & AV_CODEC_CAP_DELAY))
                 pkt.pts = ost->sync_opts;
 
-            av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
+            av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
 
             if (debug_ts) {
                 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
                     "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
-                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
-                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
+                    av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->mux_timebase),
+                    av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->mux_timebase));
             }
 
             frame_size = pkt.size;
-            output_packet(of, &pkt, ost);
+            output_packet(of, &pkt, ost, 0);
 
             /* if two pass, output log */
             if (ost->logfile && enc->stats_out) {
@@ -1336,8 +1374,13 @@ static void do_video_stats(OutputStream *ost, int frame_size)
     enc = ost->enc_ctx;
     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
         frame_number = ost->st->nb_frames;
-        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
-                ost->quality / (float)FF_QP2LAMBDA);
+        if (vstats_version <= 1) {
+            fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
+                    ost->quality / (float)FF_QP2LAMBDA);
+        } else  {
+            fprintf(vstats_file, "out= %2d st= %2d frame= %5d q= %2.1f ", ost->file_index, ost->index, frame_number,
+                    ost->quality / (float)FF_QP2LAMBDA);
+        }
 
         if (ost->error[0]>=0 && (enc->flags & AV_CODEC_FLAG_PSNR))
             fprintf(vstats_file, "PSNR= %6.2f ", psnr(ost->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
@@ -1356,6 +1399,8 @@ static void do_video_stats(OutputStream *ost, int frame_size)
     }
 }
 
+static int init_output_stream(OutputStream *ost, char *error, int error_len);
+
 static void finish_output_stream(OutputStream *ost)
 {
     OutputFile *of = output_files[ost->file_index];
@@ -1388,10 +1433,20 @@ static int reap_filters(int flush)
         AVCodecContext *enc = ost->enc_ctx;
         int ret = 0;
 
-        if (!ost->filter)
+        if (!ost->filter || !ost->filter->graph->graph)
             continue;
         filter = ost->filter->filter;
 
+        if (!ost->initialized) {
+            char error[1024] = "";
+            ret = init_output_stream(ost, error, sizeof(error));
+            if (ret < 0) {
+                av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
+                       ost->file_index, ost->index, error);
+                exit_program(1);
+            }
+        }
+
         if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
             return AVERROR(ENOMEM);
         }
@@ -1406,7 +1461,7 @@ static int reap_filters(int flush)
                     av_log(NULL, AV_LOG_WARNING,
                            "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
                 } else if (flush && ret == AVERROR_EOF) {
-                    if (filter->inputs[0]->type == AVMEDIA_TYPE_VIDEO)
+                    if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO)
                         do_video_out(of, ost, NULL, AV_NOPTS_VALUE);
                 }
                 break;
@@ -1417,25 +1472,26 @@ static int reap_filters(int flush)
             }
             if (filtered_frame->pts != AV_NOPTS_VALUE) {
                 int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
+                AVRational filter_tb = av_buffersink_get_time_base(filter);
                 AVRational tb = enc->time_base;
                 int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
 
                 tb.den <<= extra_bits;
                 float_pts =
-                    av_rescale_q(filtered_frame->pts, filter->inputs[0]->time_base, tb) -
+                    av_rescale_q(filtered_frame->pts, filter_tb, tb) -
                     av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
                 float_pts /= 1 << extra_bits;
                 // avoid exact midoints to reduce the chance of rounding differences, this can be removed in case the fps code is changed to work with integers
                 float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
 
                 filtered_frame->pts =
-                    av_rescale_q(filtered_frame->pts, filter->inputs[0]->time_base, enc->time_base) -
+                    av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
                     av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
             }
             //if (ost->source_index >= 0)
             //    *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
 
-            switch (filter->inputs[0]->type) {
+            switch (av_buffersink_get_type(filter)) {
             case AVMEDIA_TYPE_VIDEO:
                 if (!ost->frame_aspect_ratio.num)
                     enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
@@ -1451,7 +1507,7 @@ static int reap_filters(int flush)
                 break;
             case AVMEDIA_TYPE_AUDIO:
                 if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
-                    enc->channels != av_frame_get_channels(filtered_frame)) {
+                    enc->channels != filtered_frame->channels) {
                     av_log(NULL, AV_LOG_ERROR,
                            "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
                     break;
@@ -1489,7 +1545,7 @@ static void print_final_stats(int64_t total_size)
         }
         extra_size += ost->enc_ctx->extradata_size;
         data_size  += ost->data_size;
-        if (   (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))
+        if (   (ost->enc_ctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2))
             != AV_CODEC_FLAG_PASS1)
             pass1_used = 0;
     }
@@ -1787,11 +1843,58 @@ static void flush_encoders(void)
         OutputStream   *ost = output_streams[i];
         AVCodecContext *enc = ost->enc_ctx;
         OutputFile      *of = output_files[ost->file_index];
-        int stop_encoding = 0;
 
         if (!ost->encoding_needed)
             continue;
 
+        // Try to enable encoding with no input frames.
+        // Maybe we should just let encoding fail instead.
+        if (!ost->initialized) {
+            FilterGraph *fg = ost->filter->graph;
+            char error[1024] = "";
+
+            av_log(NULL, AV_LOG_WARNING,
+                   "Finishing stream %d:%d without any data written to it.\n",
+                   ost->file_index, ost->st->index);
+
+            if (ost->filter && !fg->graph) {
+                int x;
+                for (x = 0; x < fg->nb_inputs; x++) {
+                    InputFilter *ifilter = fg->inputs[x];
+                    if (ifilter->format < 0) {
+                        AVCodecParameters *par = ifilter->ist->st->codecpar;
+                        // We never got any input. Set a fake format, which will
+                        // come from libavformat.
+                        ifilter->format                 = par->format;
+                        ifilter->sample_rate            = par->sample_rate;
+                        ifilter->channels               = par->channels;
+                        ifilter->channel_layout         = par->channel_layout;
+                        ifilter->width                  = par->width;
+                        ifilter->height                 = par->height;
+                        ifilter->sample_aspect_ratio    = par->sample_aspect_ratio;
+                    }
+                }
+
+                if (!ifilter_has_all_input_formats(fg))
+                    continue;
+
+                ret = configure_filtergraph(fg);
+                if (ret < 0) {
+                    av_log(NULL, AV_LOG_ERROR, "Error configuring filter graph\n");
+                    exit_program(1);
+                }
+
+                finish_output_stream(ost);
+            }
+
+            ret = init_output_stream(ost, error, sizeof(error));
+            if (ret < 0) {
+                av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
+                       ost->file_index, ost->index, error);
+                exit_program(1);
+            }
+        }
+
         if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
             continue;
 #if FF_API_LAVF_FMT_RAWPICTURE
@@ -1802,10 +1905,10 @@ static void flush_encoders(void)
         if (enc->codec_type != AVMEDIA_TYPE_VIDEO && enc->codec_type != AVMEDIA_TYPE_AUDIO)
             continue;
 
-        avcodec_send_frame(enc, NULL);
-
         for (;;) {
             const char *desc = NULL;
+            AVPacket pkt;
+            int pkt_size;
 
             switch (enc->codec_type) {
             case AVMEDIA_TYPE_AUDIO:
@@ -1818,15 +1921,22 @@ static void flush_encoders(void)
                 av_assert0(0);
             }
 
-            if (1) {
-                AVPacket pkt;
-                int pkt_size;
                 av_init_packet(&pkt);
                 pkt.data = NULL;
                 pkt.size = 0;
 
                 update_benchmark(NULL);
-                ret = avcodec_receive_packet(enc, &pkt);
+
+                while ((ret = avcodec_receive_packet(enc, &pkt)) == AVERROR(EAGAIN)) {
+                    ret = avcodec_send_frame(enc, NULL);
+                    if (ret < 0) {
+                        av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
+                               desc,
+                               av_err2str(ret));
+                        exit_program(1);
+                    }
+                }
+
                 update_benchmark("flush_%s %d.%d", desc, ost->file_index, ost->index);
                 if (ret < 0 && ret != AVERROR_EOF) {
                     av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
@@ -1838,23 +1948,19 @@ static void flush_encoders(void)
                     fprintf(ost->logfile, "%s", enc->stats_out);
                 }
                 if (ret == AVERROR_EOF) {
-                    stop_encoding = 1;
+                    output_packet(of, &pkt, ost, 1);
                     break;
                 }
                 if (ost->finished & MUXER_FINISHED) {
                     av_packet_unref(&pkt);
                     continue;
                 }
-                av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);
+                av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
                 pkt_size = pkt.size;
-                output_packet(of, &pkt, ost);
+                output_packet(of, &pkt, ost, 0);
                 if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO && vstats_filename) {
                     do_video_stats(ost, pkt_size);
                 }
-            }
-
-            if (stop_encoding)
-                break;
         }
     }
 }
@@ -1884,7 +1990,7 @@ static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *p
     OutputFile *of = output_files[ost->file_index];
     InputFile   *f = input_files [ist->file_index];
     int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
-    int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
+    int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->mux_timebase);
     AVPicture pict;
     AVPacket opkt;
 
@@ -1925,14 +2031,14 @@ static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *p
         ost->sync_opts++;
 
     if (pkt->pts != AV_NOPTS_VALUE)
-        opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
+        opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->mux_timebase) - ost_tb_start_time;
     else
         opkt.pts = AV_NOPTS_VALUE;
 
     if (pkt->dts == AV_NOPTS_VALUE)
-        opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
+        opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->mux_timebase);
     else
-        opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
+        opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->mux_timebase);
     opkt.dts -= ost_tb_start_time;
 
     if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
@@ -1941,10 +2047,11 @@ static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *p
             duration = ist->dec_ctx->frame_size;
         opkt.dts = opkt.pts = av_rescale_delta(ist->st->time_base, pkt->dts,
                                                (AVRational){1, ist->dec_ctx->sample_rate}, duration, &ist->filter_in_rescale_delta_last,
-                                               ost->st->time_base) - ost_tb_start_time;
+                                               ost->mux_timebase) - ost_tb_start_time;
     }
 
-    opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
+    opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->mux_timebase);
+
     opkt.flags    = pkt->flags;
     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
     if (  ost->st->codecpar->codec_id != AV_CODEC_ID_H264
@@ -1989,7 +2096,7 @@ static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *p
     }
 #endif
 
-    output_packet(of, &opkt, ost);
+    output_packet(of, &opkt, ost, 0);
 }
 
 int guess_input_channel_layout(InputStream *ist)
@@ -2021,17 +2128,133 @@ static void check_decode_result(InputStream *ist, int *got_output, int ret)
         exit_program(1);
 
     if (exit_on_error && *got_output && ist) {
-        if (av_frame_get_decode_error_flags(ist->decoded_frame) || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
+        if (ist->decoded_frame->decode_error_flags || (ist->decoded_frame->flags & AV_FRAME_FLAG_CORRUPT)) {
             av_log(NULL, AV_LOG_FATAL, "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->filename, ist->st->index);
             exit_program(1);
         }
     }
 }
 
+// Filters can be configured only if the formats of all inputs are known.
+static int ifilter_has_all_input_formats(FilterGraph *fg)
+{
+    int i;
+    for (i = 0; i < fg->nb_inputs; i++) {
+        if (fg->inputs[i]->format < 0 && (fg->inputs[i]->type == AVMEDIA_TYPE_AUDIO ||
+                                          fg->inputs[i]->type == AVMEDIA_TYPE_VIDEO))
+            return 0;
+    }
+    return 1;
+}
+
+static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
+{
+    FilterGraph *fg = ifilter->graph;
+    int need_reinit, ret, i;
+
+    /* determine if the parameters for this input changed */
+    need_reinit = ifilter->format != frame->format;
+    if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
+        (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
+        need_reinit = 1;
+
+    switch (ifilter->ist->st->codecpar->codec_type) {
+    case AVMEDIA_TYPE_AUDIO:
+        need_reinit |= ifilter->sample_rate    != frame->sample_rate ||
+                       ifilter->channels       != frame->channels ||
+                       ifilter->channel_layout != frame->channel_layout;
+        break;
+    case AVMEDIA_TYPE_VIDEO:
+        need_reinit |= ifilter->width  != frame->width ||
+                       ifilter->height != frame->height;
+        break;
+    }
+
+    if (need_reinit) {
+        ret = ifilter_parameters_from_frame(ifilter, frame);
+        if (ret < 0)
+            return ret;
+    }
+
+    /* (re)init the graph if possible, otherwise buffer the frame and return */
+    if (need_reinit || !fg->graph) {
+        for (i = 0; i < fg->nb_inputs; i++) {
+            if (!ifilter_has_all_input_formats(fg)) {
+                AVFrame *tmp = av_frame_clone(frame);
+                if (!tmp)
+                    return AVERROR(ENOMEM);
+                av_frame_unref(frame);
+
+                if (!av_fifo_space(ifilter->frame_queue)) {
+                    ret = av_fifo_realloc2(ifilter->frame_queue, 2 * av_fifo_size(ifilter->frame_queue));
+                    if (ret < 0) {
+                        av_frame_free(&tmp);
+                        return ret;
+                    }
+                }
+                av_fifo_generic_write(ifilter->frame_queue, &tmp, sizeof(tmp), NULL);
+                return 0;
+            }
+        }
+
+        ret = reap_filters(1);
+        if (ret < 0 && ret != AVERROR_EOF) {
+            char errbuf[128];
+            av_strerror(ret, errbuf, sizeof(errbuf));
+
+            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
+            return ret;
+        }
+
+        ret = configure_filtergraph(fg);
+        if (ret < 0) {
+            av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
+            return ret;
+        }
+    }
+
+    ret = av_buffersrc_add_frame_flags(ifilter->filter, frame, AV_BUFFERSRC_FLAG_PUSH);
+    if (ret < 0) {
+        if (ret != AVERROR_EOF)
+            av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
+        return ret;
+    }
+
+    return 0;
+}
+
+static int ifilter_send_eof(InputFilter *ifilter, int64_t pts)
+{
+    int i, j, ret;
+
+    ifilter->eof = 1;
+
+    if (ifilter->filter) {
+        ret = av_buffersrc_close(ifilter->filter, pts, AV_BUFFERSRC_FLAG_PUSH);
+        if (ret < 0)
+            return ret;
+    } else {
+        // the filtergraph was never configured
+        FilterGraph *fg = ifilter->graph;
+        for (i = 0; i < fg->nb_inputs; i++)
+            if (!fg->inputs[i]->eof)
+                break;
+        if (i == fg->nb_inputs) {
+            // All the input streams have finished without the filtergraph
+            // ever being configured.
+            // Mark the output streams as finished.
+            for (j = 0; j < fg->nb_outputs; j++)
+                finish_output_stream(fg->outputs[j]->ost);
+        }
+    }
+
+    return 0;
+}
+
 // This does not quite work like avcodec_decode_audio4/avcodec_decode_video2.
 // There is the following difference: if you got a frame, you must call
-// it again with pkt=NULL. pkt==NULL is treated differently from pkt.size==0
-// (pkt==NULL means get more output, pkt.size==0 is a flush/drain packet)
+// it again with pkt=NULL. pkt==NULL is treated differently from pkt->size==0
+// (pkt==NULL means get more output, pkt->size==0 is a flush/drain packet)
 static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
 {
     int ret;
@@ -2055,11 +2278,38 @@ static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacke
     return 0;
 }
 
-static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
+static int send_frame_to_filters(InputStream *ist, AVFrame *decoded_frame)
+{
+    int i, ret;
+    AVFrame *f;
+
+    av_assert1(ist->nb_filters > 0); /* ensure ret is initialized */
+    for (i = 0; i < ist->nb_filters; i++) {
+        if (i < ist->nb_filters - 1) {
+            f = ist->filter_frame;
+            ret = av_frame_ref(f, decoded_frame);
+            if (ret < 0)
+                break;
+        } else
+            f = decoded_frame;
+        ret = ifilter_send_frame(ist->filters[i], f);
+        if (ret == AVERROR_EOF)
+            ret = 0; /* ignore */
+        if (ret < 0) {
+            av_log(NULL, AV_LOG_ERROR,
+                   "Failed to inject frame into filter network: %s\n", av_err2str(ret));
+            break;
+        }
+    }
+    return ret;
+}
+
+static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output,
+                        int *decode_failed)
 {
-    AVFrame *decoded_frame, *f;
+    AVFrame *decoded_frame;
     AVCodecContext *avctx = ist->dec_ctx;
-    int i, ret, err = 0, resample_changed;
+    int ret, err = 0;
     AVRational decoded_frame_tb;
 
     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
@@ -2071,6 +2321,8 @@ static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
     update_benchmark(NULL);
     ret = decode(avctx, decoded_frame, got_output, pkt);
     update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
+    if (ret < 0)
+        *decode_failed = 1;
 
     if (ret >= 0 && avctx->sample_rate <= 0) {
         av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
@@ -2095,49 +2347,6 @@ static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
                      avctx->sample_rate;
 #endif
 
-    resample_changed = ist->resample_sample_fmt     != decoded_frame->format         ||
-                       ist->resample_channels       != avctx->channels               ||
-                       ist->resample_channel_layout != decoded_frame->channel_layout ||
-                       ist->resample_sample_rate    != decoded_frame->sample_rate;
-    if (resample_changed) {
-        char layout1[64], layout2[64];
-
-        if (!guess_input_channel_layout(ist)) {
-            av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
-                   "layout for Input Stream #%d.%d\n", ist->file_index,
-                   ist->st->index);
-            exit_program(1);
-        }
-        decoded_frame->channel_layout = avctx->channel_layout;
-
-        av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
-                                     ist->resample_channel_layout);
-        av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
-                                     decoded_frame->channel_layout);
-
-        av_log(NULL, AV_LOG_INFO,
-               "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n",
-               ist->file_index, ist->st->index,
-               ist->resample_sample_rate,  av_get_sample_fmt_name(ist->resample_sample_fmt),
-               ist->resample_channels, layout1,
-               decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
-               avctx->channels, layout2);
-
-        ist->resample_sample_fmt     = decoded_frame->format;
-        ist->resample_sample_rate    = decoded_frame->sample_rate;
-        ist->resample_channel_layout = decoded_frame->channel_layout;
-        ist->resample_channels       = avctx->channels;
-
-        for (i = 0; i < nb_filtergraphs; i++)
-            if (ist_in_filtergraph(filtergraphs[i], ist)) {
-                FilterGraph *fg = filtergraphs[i];
-                if (configure_filtergraph(fg) < 0) {
-                    av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
-                    exit_program(1);
-                }
-            }
-    }
-
     if (decoded_frame->pts != AV_NOPTS_VALUE) {
         decoded_frame_tb   = ist->st->time_base;
     } else if (pkt && pkt->pts != AV_NOPTS_VALUE) {
@@ -2152,35 +2361,20 @@ static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
                                               (AVRational){1, avctx->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
                                               (AVRational){1, avctx->sample_rate});
     ist->nb_samples = decoded_frame->nb_samples;
-    for (i = 0; i < ist->nb_filters; i++) {
-        if (i < ist->nb_filters - 1) {
-            f = ist->filter_frame;
-            err = av_frame_ref(f, decoded_frame);
-            if (err < 0)
-                break;
-        } else
-            f = decoded_frame;
-        err = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f,
-                                     AV_BUFFERSRC_FLAG_PUSH);
-        if (err == AVERROR_EOF)
-            err = 0; /* ignore */
-        if (err < 0)
-            break;
-    }
-    decoded_frame->pts = AV_NOPTS_VALUE;
+    err = send_frame_to_filters(ist, decoded_frame);
 
     av_frame_unref(ist->filter_frame);
     av_frame_unref(decoded_frame);
     return err < 0 ? err : ret;
 }
 
-static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int eof)
+static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *duration_pts, int eof,
+                        int *decode_failed)
 {
-    AVFrame *decoded_frame, *f;
-    int i, ret = 0, err = 0, resample_changed;
+    AVFrame *decoded_frame;
+    int i, ret = 0, err = 0;
     int64_t best_effort_timestamp;
     int64_t dts = AV_NOPTS_VALUE;
-    AVRational *frame_sample_aspect;
     AVPacket avpkt;
 
     // With fate-indeo3-2, we're getting 0-sized packets before EOF for some
@@ -2214,6 +2408,8 @@ static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int eo
     update_benchmark(NULL);
     ret = decode(ist->dec_ctx, decoded_frame, got_output, pkt ? &avpkt : NULL);
     update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
+    if (ret < 0)
+        *decode_failed = 1;
 
     // The following line may be required in some cases where there is no parser
     // or the parser does not has_b_frames correctly
@@ -2225,7 +2421,7 @@ static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int eo
                    "video_delay is larger in decoder than demuxer %d > %d.\n"
                    "If you want to help, upload a sample "
                    "of this file to ftp://upload.ffmpeg.org/incoming/ "
-                   "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)",
+                   "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n",
                    ist->dec_ctx->has_b_frames,
                    ist->st->codecpar->video_delay);
     }
@@ -2262,7 +2458,11 @@ static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int eo
     }
     ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
 
-    best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
+    best_effort_timestamp= decoded_frame->best_effort_timestamp;
+    *duration_pts = decoded_frame->pkt_duration;
+
+    if (ist->framerate.num)
+        best_effort_timestamp = ist->cfr_next_pts++;
 
     if (eof && best_effort_timestamp == AV_NOPTS_VALUE && ist->nb_dts_buffer > 0) {
         best_effort_timestamp = ist->dts_buffer[0];
@@ -2293,50 +2493,7 @@ static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int eo
     if (ist->st->sample_aspect_ratio.num)
         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
 
-    resample_changed = ist->resample_width   != decoded_frame->width  ||
-                       ist->resample_height  != decoded_frame->height ||
-                       ist->resample_pix_fmt != decoded_frame->format;
-    if (resample_changed) {
-        av_log(NULL, AV_LOG_INFO,
-               "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
-               ist->file_index, ist->st->index,
-               ist->resample_width,  ist->resample_height,  av_get_pix_fmt_name(ist->resample_pix_fmt),
-               decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
-
-        ist->resample_width   = decoded_frame->width;
-        ist->resample_height  = decoded_frame->height;
-        ist->resample_pix_fmt = decoded_frame->format;
-
-        for (i = 0; i < nb_filtergraphs; i++) {
-            if (ist_in_filtergraph(filtergraphs[i], ist) && ist->reinit_filters &&
-                configure_filtergraph(filtergraphs[i]) < 0) {
-                av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
-                exit_program(1);
-            }
-        }
-    }
-
-    frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
-    for (i = 0; i < ist->nb_filters; i++) {
-        if (!frame_sample_aspect->num)
-            *frame_sample_aspect = ist->st->sample_aspect_ratio;
-
-        if (i < ist->nb_filters - 1) {
-            f = ist->filter_frame;
-            err = av_frame_ref(f, decoded_frame);
-            if (err < 0)
-                break;
-        } else
-            f = decoded_frame;
-        err = av_buffersrc_add_frame_flags(ist->filters[i]->filter, f, AV_BUFFERSRC_FLAG_PUSH);
-        if (err == AVERROR_EOF) {
-            err = 0; /* ignore */
-        } else if (err < 0) {
-            av_log(NULL, AV_LOG_FATAL,
-                   "Failed to inject frame into filter network: %s\n", av_err2str(err));
-            exit_program(1);
-        }
-    }
+    err = send_frame_to_filters(ist, decoded_frame);
 
 fail:
     av_frame_unref(ist->filter_frame);
@@ -2344,15 +2501,18 @@ static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int eo
     return err < 0 ? err : ret;
 }
 
-static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
+static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output,
+                               int *decode_failed)
 {
     AVSubtitle subtitle;
+    int free_sub = 1;
     int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
                                           &subtitle, got_output, pkt);
 
     check_decode_result(NULL, got_output, ret);
 
     if (ret < 0 || !*got_output) {
+        *decode_failed = 1;
         if (!pkt->size)
             sub2video_flush(ist);
         return ret;
@@ -2365,7 +2525,7 @@ static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
                              1000, AV_TIME_BASE);
             if (end < ist->prev_sub.subtitle.end_display_time) {
                 av_log(ist->dec_ctx, AV_LOG_DEBUG,
-                       "Subtitle duration reduced from %d to %d%s\n",
+                       "Subtitle duration reduced from %"PRId32" to %d%s\n",
                        ist->prev_sub.subtitle.end_display_time, end,
                        end <= 0 ? ", dropping it" : "");
                 ist->prev_sub.subtitle.end_display_time = end;
@@ -2381,7 +2541,21 @@ static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
     if (!*got_output)
         return ret;
 
-    sub2video_update(ist, &subtitle);
+    if (ist->sub2video.frame) {
+        sub2video_update(ist, &subtitle);
+    } else if (ist->nb_filters) {
+        if (!ist->sub2video.sub_queue)
+            ist->sub2video.sub_queue = av_fifo_alloc(8 * sizeof(AVSubtitle));
+        if (!ist->sub2video.sub_queue)
+            exit_program(1);
+        if (!av_fifo_space(ist->sub2video.sub_queue)) {
+            ret = av_fifo_realloc2(ist->sub2video.sub_queue, 2 * av_fifo_size(ist->sub2video.sub_queue));
+            if (ret < 0)
+                exit_program(1);
+        }
+        av_fifo_generic_write(ist->sub2video.sub_queue, &subtitle, sizeof(subtitle), NULL);
+        free_sub = 0;
+    }
 
     if (!subtitle.num_rects)
         goto out;
@@ -2399,15 +2573,20 @@ static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
     }
 
 out:
-    avsubtitle_free(&subtitle);
+    if (free_sub)
+        avsubtitle_free(&subtitle);
     return ret;
 }
 
 static int send_filter_eof(InputStream *ist)
 {
     int i, ret;
+    /* TODO keep pts also in stream time base to avoid converting back */
+    int64_t pts = av_rescale_q_rnd(ist->pts, AV_TIME_BASE_Q, ist->st->time_base,
+                                   AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX);
+
     for (i = 0; i < ist->nb_filters; i++) {
-        ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
+        ret = ifilter_send_eof(ist->filters[i], pts);
         if (ret < 0)
             return ret;
     }
@@ -2454,41 +2633,50 @@ static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eo
 
     // while we have more to decode or while the decoder did output something on EOF
     while (ist->decoding_needed) {
-        int duration = 0;
+        int64_t duration_dts = 0;
+        int64_t duration_pts = 0;
         int got_output = 0;
+        int decode_failed = 0;
 
         ist->pts = ist->next_pts;
         ist->dts = ist->next_dts;
 
         switch (ist->dec_ctx->codec_type) {
         case AVMEDIA_TYPE_AUDIO:
-            ret = decode_audio    (ist, repeating ? NULL : &avpkt, &got_output);
+            ret = decode_audio    (ist, repeating ? NULL : &avpkt, &got_output,
+                                   &decode_failed);
             break;
         case AVMEDIA_TYPE_VIDEO:
-            ret = decode_video    (ist, repeating ? NULL : &avpkt, &got_output, !pkt);
+            ret = decode_video    (ist, repeating ? NULL : &avpkt, &got_output, &duration_pts, !pkt,
+                                   &decode_failed);
             if (!repeating || !pkt || got_output) {
                 if (pkt && pkt->duration) {
-                    duration = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
+                    duration_dts = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
                 } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
                     int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict+1 : ist->dec_ctx->ticks_per_frame;
-                    duration = ((int64_t)AV_TIME_BASE *
+                    duration_dts = ((int64_t)AV_TIME_BASE *
                                     ist->dec_ctx->framerate.den * ticks) /
                                     ist->dec_ctx->framerate.num / ist->dec_ctx->ticks_per_frame;
                 }
 
-                if(ist->dts != AV_NOPTS_VALUE && duration) {
-                    ist->next_dts += duration;
+                if(ist->dts != AV_NOPTS_VALUE && duration_dts) {
+                    ist->next_dts += duration_dts;
                 }else
                     ist->next_dts = AV_NOPTS_VALUE;
             }
 
-            if (got_output)
-                ist->next_pts += duration; //FIXME the duration is not correct in some cases
+            if (got_output) {
+                if (duration_pts > 0) {
+                    ist->next_pts += av_rescale_q(duration_pts, ist->st->time_base, AV_TIME_BASE_Q);
+                } else {
+                    ist->next_pts += duration_dts;
+                }
+            }
             break;
         case AVMEDIA_TYPE_SUBTITLE:
             if (repeating)
                 break;
-            ret = transcode_subtitles(ist, &avpkt, &got_output);
+            ret = transcode_subtitles(ist, &avpkt, &got_output, &decode_failed);
             if (!pkt && ret >= 0)
                 ret = AVERROR_EOF;
             break;
@@ -2502,19 +2690,21 @@ static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eo
         }
 
         if (ret < 0) {
-            av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
-                   ist->file_index, ist->st->index, av_err2str(ret));
-            if (exit_on_error)
+            if (decode_failed) {
+                av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
+                       ist->file_index, ist->st->index, av_err2str(ret));
+            } else {
+                av_log(NULL, AV_LOG_FATAL, "Error while processing the decoded "
+                       "data for stream #%d:%d\n", ist->file_index, ist->st->index);
+            }
+            if (!decode_failed || exit_on_error)
                 exit_program(1);
-            // Decoding might not terminate if we're draining the decoder, and
-            // the decoder keeps returning an error.
-            // This should probably be considered a libavcodec issue.
-            // Sample: fate-vsynth1-dnxhd-720p-hr-lb
-            if (!pkt)
-                eof_reached = 1;
             break;
         }
 
+        if (got_output)
+            ist->got_output = 1;
+
         if (!got_output)
             break;
 
@@ -2724,6 +2914,18 @@ static int init_input_stream(int ist_index, char *error, int error_len)
 
         if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
             av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
+        /* Attached pics are sparse, therefore we would not want to delay their decoding till EOF. */
+        if (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC)
+            av_dict_set(&ist->decoder_opts, "threads", "1", 0);
+
+        ret = hw_device_setup_for_decode(ist);
+        if (ret < 0) {
+            snprintf(error, error_len, "Device setup failed for "
+                     "decoder on input stream #%d:%d : %s",
+                     ist->file_index, ist->st->index, av_err2str(ret));
+            return ret;
+        }
+
         if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
             if (ret == AVERROR_EXPERIMENTAL)
                 abort_codec_experimental(codec, 0);
@@ -2772,7 +2974,7 @@ static int check_init_output_file(OutputFile *of, int file_index)
     if (ret < 0) {
         av_log(NULL, AV_LOG_ERROR,
                "Could not write header for output file #%d "
-               "(incorrect codec parameters ?): %s",
+               "(incorrect codec parameters ?): %s\n",
                file_index, av_err2str(ret));
         return ret;
     }
@@ -2788,10 +2990,14 @@ static int check_init_output_file(OutputFile *of, int file_index)
     for (i = 0; i < of->ctx->nb_streams; i++) {
         OutputStream *ost = output_streams[of->ost_index + i];
 
+        /* try to improve muxing time_base (only possible if nothing has been written yet) */
+        if (!av_fifo_size(ost->muxing_queue))
+            ost->mux_timebase = ost->st->time_base;
+
         while (av_fifo_size(ost->muxing_queue)) {
             AVPacket pkt;
             av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
-            write_packet(of, &pkt, ost);
+            write_packet(of, &pkt, ost, 1);
         }
     }
 
@@ -2842,12 +3048,13 @@ static int init_output_stream_streamcopy(OutputStream *ost)
     AVCodecParameters *par_src = ost->ref_par;
     AVRational sar;
     int i, ret;
-    uint64_t extra_size;
+    uint32_t codec_tag = par_dst->codec_tag;
 
     av_assert0(ist && !ost->filter);
 
-    avcodec_parameters_to_context(ost->enc_ctx, ist->st->codecpar);
-    ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
+    ret = avcodec_parameters_to_context(ost->enc_ctx, ist->st->codecpar);
+    if (ret >= 0)
+        ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
     if (ret < 0) {
         av_log(NULL, AV_LOG_FATAL,
                "Error setting up codec context options.\n");
@@ -2855,38 +3062,19 @@ static int init_output_stream_streamcopy(OutputStream *ost)
     }
     avcodec_parameters_from_context(par_src, ost->enc_ctx);
 
-    extra_size = (uint64_t)par_src->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE;
-
-    if (extra_size > INT_MAX) {
-        return AVERROR(EINVAL);
-    }
-
-    /* if stream_copy is selected, no need to decode or encode */
-    par_dst->codec_id   = par_src->codec_id;
-    par_dst->codec_type = par_src->codec_type;
-
-    if (!par_dst->codec_tag) {
-        unsigned int codec_tag;
+    if (!codec_tag) {
+        unsigned int codec_tag_tmp;
         if (!of->ctx->oformat->codec_tag ||
-            av_codec_get_id (of->ctx->oformat->codec_tag, par_src->codec_tag) == par_dst->codec_id ||
-            !av_codec_get_tag2(of->ctx->oformat->codec_tag, par_src->codec_id, &codec_tag))
-            par_dst->codec_tag = par_src->codec_tag;
+            av_codec_get_id (of->ctx->oformat->codec_tag, par_src->codec_tag) == par_src->codec_id ||
+            !av_codec_get_tag2(of->ctx->oformat->codec_tag, par_src->codec_id, &codec_tag_tmp))
+            codec_tag = par_src->codec_tag;
     }
 
-    par_dst->bit_rate        = par_src->bit_rate;
-    par_dst->field_order     = par_src->field_order;
-    par_dst->chroma_location = par_src->chroma_location;
+    ret = avcodec_parameters_copy(par_dst, par_src);
+    if (ret < 0)
+        return ret;
 
-    if (par_src->extradata_size) {
-        par_dst->extradata      = av_mallocz(extra_size);
-        if (!par_dst->extradata) {
-            return AVERROR(ENOMEM);
-        }
-        memcpy(par_dst->extradata, par_src->extradata, par_src->extradata_size);
-        par_dst->extradata_size = par_src->extradata_size;
-    }
-    par_dst->bits_per_coded_sample  = par_src->bits_per_coded_sample;
-    par_dst->bits_per_raw_sample    = par_src->bits_per_raw_sample;
+    par_dst->codec_tag = codec_tag;
 
     if (!ost->frame_rate.num)
         ost->frame_rate = ist->framerate;
@@ -2897,32 +3085,35 @@ static int init_output_stream_streamcopy(OutputStream *ost)
         return ret;
 
     // copy timebase while removing common factors
-    ost->st->time_base = av_add_q(av_stream_get_codec_timebase(ost->st), (AVRational){0, 1});
+    if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
+        ost->st->time_base = av_add_q(av_stream_get_codec_timebase(ost->st), (AVRational){0, 1});
 
-    if (ist->st->nb_side_data) {
-        ost->st->side_data = av_realloc_array(NULL, ist->st->nb_side_data,
-                                              sizeof(*ist->st->side_data));
-        if (!ost->st->side_data)
-            return AVERROR(ENOMEM);
+    // copy estimated duration as a hint to the muxer
+    if (ost->st->duration <= 0 && ist->st->duration > 0)
+        ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
+
+    // copy disposition
+    ost->st->disposition = ist->st->disposition;
 
-        ost->st->nb_side_data = 0;
+    if (ist->st->nb_side_data) {
         for (i = 0; i < ist->st->nb_side_data; i++) {
             const AVPacketSideData *sd_src = &ist->st->side_data[i];
-            AVPacketSideData *sd_dst = &ost->st->side_data[ost->st->nb_side_data];
-
-            if (ost->rotate_overridden && sd_src->type == AV_PKT_DATA_DISPLAYMATRIX)
-                continue;
+            uint8_t *dst_data;
 
-            sd_dst->data = av_malloc(sd_src->size);
-            if (!sd_dst->data)
+            dst_data = av_stream_new_side_data(ost->st, sd_src->type, sd_src->size);
+            if (!dst_data)
                 return AVERROR(ENOMEM);
-            memcpy(sd_dst->data, sd_src->data, sd_src->size);
-            sd_dst->size = sd_src->size;
-            sd_dst->type = sd_src->type;
-            ost->st->nb_side_data++;
+            memcpy(dst_data, sd_src->data, sd_src->size);
         }
     }
 
+    if (ost->rotate_overridden) {
+        uint8_t *sd = av_stream_new_side_data(ost->st, AV_PKT_DATA_DISPLAYMATRIX,
+                                              sizeof(int32_t) * 9);
+        if (sd)
+            av_display_rotation_set((int32_t *)sd, -ost->rotate_override_value);
+    }
+
     ost->parser = av_parser_init(par_dst->codec_id);
     ost->parser_avctx = avcodec_alloc_context3(NULL);
     if (!ost->parser_avctx)
@@ -2934,29 +3125,12 @@ static int init_output_stream_streamcopy(OutputStream *ost)
             av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
             exit_program(1);
         }
-        par_dst->channel_layout     = par_src->channel_layout;
-        par_dst->sample_rate        = par_src->sample_rate;
-        par_dst->channels           = par_src->channels;
-        par_dst->frame_size         = par_src->frame_size;
-        par_dst->block_align        = par_src->block_align;
-        par_dst->initial_padding    = par_src->initial_padding;
-        par_dst->trailing_padding   = par_src->trailing_padding;
-        par_dst->profile            = par_src->profile;
         if((par_dst->block_align == 1 || par_dst->block_align == 1152 || par_dst->block_align == 576) && par_dst->codec_id == AV_CODEC_ID_MP3)
             par_dst->block_align= 0;
         if(par_dst->codec_id == AV_CODEC_ID_AC3)
             par_dst->block_align= 0;
         break;
     case AVMEDIA_TYPE_VIDEO:
-        par_dst->format             = par_src->format;
-        par_dst->color_space        = par_src->color_space;
-        par_dst->color_range        = par_src->color_range;
-        par_dst->color_primaries    = par_src->color_primaries;
-        par_dst->color_trc          = par_src->color_trc;
-        par_dst->width              = par_src->width;
-        par_dst->height             = par_src->height;
-        par_dst->video_delay        = par_src->video_delay;
-        par_dst->profile            = par_src->profile;
         if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
             sar =
                 av_mul_q(ost->frame_aspect_ratio,
@@ -2972,30 +3146,306 @@ static int init_output_stream_streamcopy(OutputStream *ost)
         ost->st->avg_frame_rate = ist->st->avg_frame_rate;
         ost->st->r_frame_rate = ist->st->r_frame_rate;
         break;
-    case AVMEDIA_TYPE_SUBTITLE:
-        par_dst->width  = par_src->width;
-        par_dst->height = par_src->height;
-        break;
-    case AVMEDIA_TYPE_UNKNOWN:
-    case AVMEDIA_TYPE_DATA:
-    case AVMEDIA_TYPE_ATTACHMENT:
-        break;
-    default:
-        abort();
     }
 
+    ost->mux_timebase = ist->st->time_base;
+
     return 0;
 }
 
-static int init_output_stream(OutputStream *ost, char *error, int error_len)
+static void set_encoder_id(OutputFile *of, OutputStream *ost)
 {
-    int ret = 0;
+    AVDictionaryEntry *e;
 
-    if (ost->encoding_needed) {
-        AVCodec      *codec = ost->enc;
+    uint8_t *encoder_string;
+    int encoder_string_len;
+    int format_flags = 0;
+    int codec_flags = 0;
+
+    if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
+        return;
+
+    e = av_dict_get(of->opts, "fflags", NULL, 0);
+    if (e) {
+        const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
+        if (!o)
+            return;
+        av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
+    }
+    e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
+    if (e) {
+        const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
+        if (!o)
+            return;
+        av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
+    }
+
+    encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
+    encoder_string     = av_mallocz(encoder_string_len);
+    if (!encoder_string)
+        exit_program(1);
+
+    if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
+        av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
+    else
+        av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
+    av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
+    av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
+                AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
+}
+
+static void parse_forced_key_frames(char *kf, OutputStream *ost,
+                                    AVCodecContext *avctx)
+{
+    char *p;
+    int n = 1, i, size, index = 0;
+    int64_t t, *pts;
+
+    for (p = kf; *p; p++)
+        if (*p == ',')
+            n++;
+    size = n;
+    pts = av_malloc_array(size, sizeof(*pts));
+    if (!pts) {
+        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
+        exit_program(1);
+    }
+
+    p = kf;
+    for (i = 0; i < n; i++) {
+        char *next = strchr(p, ',');
+
+        if (next)
+            *next++ = 0;
+
+        if (!memcmp(p, "chapters", 8)) {
+
+            AVFormatContext *avf = output_files[ost->file_index]->ctx;
+            int j;
+
+            if (avf->nb_chapters > INT_MAX - size ||
+                !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
+                                     sizeof(*pts)))) {
+                av_log(NULL, AV_LOG_FATAL,
+                       "Could not allocate forced key frames array.\n");
+                exit_program(1);
+            }
+            t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
+            t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
+
+            for (j = 0; j < avf->nb_chapters; j++) {
+                AVChapter *c = avf->chapters[j];
+                av_assert1(index < size);
+                pts[index++] = av_rescale_q(c->start, c->time_base,
+                                            avctx->time_base) + t;
+            }
+
+        } else {
+
+            t = parse_time_or_die("force_key_frames", p, 1);
+            av_assert1(index < size);
+            pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
+
+        }
+
+        p = next;
+    }
+
+    av_assert0(index == size);
+    qsort(pts, size, sizeof(*pts), compare_int64);
+    ost->forced_kf_count = size;
+    ost->forced_kf_pts   = pts;
+}
+
+static void init_encoder_time_base(OutputStream *ost, AVRational default_time_base)
+{
+    InputStream *ist = get_input_stream(ost);
+    AVCodecContext *enc_ctx = ost->enc_ctx;
+    AVFormatContext *oc;
+
+    if (ost->enc_timebase.num > 0) {
+        enc_ctx->time_base = ost->enc_timebase;
+        return;
+    }
+
+    if (ost->enc_timebase.num < 0) {
+        if (ist) {
+            enc_ctx->time_base = ist->st->time_base;
+            return;
+        }
+
+        oc = output_files[ost->file_index]->ctx;
+        av_log(oc, AV_LOG_WARNING, "Input stream data not available, using default time base\n");
+    }
+
+    enc_ctx->time_base = default_time_base;
+}
+
+static int init_output_stream_encode(OutputStream *ost)
+{
+    InputStream *ist = get_input_stream(ost);
+    AVCodecContext *enc_ctx = ost->enc_ctx;
+    AVCodecContext *dec_ctx = NULL;
+    AVFormatContext *oc = output_files[ost->file_index]->ctx;
+    int j, ret;
+
+    set_encoder_id(output_files[ost->file_index], ost);
+
+    // Muxers use AV_PKT_DATA_DISPLAYMATRIX to signal rotation. On the other
+    // hand, the legacy API makes demuxers set "rotate" metadata entries,
+    // which have to be filtered out to prevent leaking them to output files.
+    av_dict_set(&ost->st->metadata, "rotate", NULL, 0);
+
+    if (ist) {
+        ost->st->disposition          = ist->st->disposition;
+
+        dec_ctx = ist->dec_ctx;
+
+        enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
+    } else {
+        for (j = 0; j < oc->nb_streams; j++) {
+            AVStream *st = oc->streams[j];
+            if (st != ost->st && st->codecpar->codec_type == ost->st->codecpar->codec_type)
+                break;
+        }
+        if (j == oc->nb_streams)
+            if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ||
+                ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
+                ost->st->disposition = AV_DISPOSITION_DEFAULT;
+    }
+
+    if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
+        if (!ost->frame_rate.num)
+            ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
+        if (ist && !ost->frame_rate.num)
+            ost->frame_rate = ist->framerate;
+        if (ist && !ost->frame_rate.num)
+            ost->frame_rate = ist->st->r_frame_rate;
+        if (ist && !ost->frame_rate.num) {
+            ost->frame_rate = (AVRational){25, 1};
+            av_log(NULL, AV_LOG_WARNING,
+                   "No information "
+                   "about the input framerate is available. Falling "
+                   "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
+                   "if you want a different framerate.\n",
+                   ost->file_index, ost->index);
+        }
+//      ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
+        if (ost->enc->supported_framerates && !ost->force_fps) {
+            int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
+            ost->frame_rate = ost->enc->supported_framerates[idx];
+        }
+        // reduce frame rate for mpeg4 to be within the spec limits
+        if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
+            av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
+                      ost->frame_rate.num, ost->frame_rate.den, 65535);
+        }
+    }
+
+    switch (enc_ctx->codec_type) {
+    case AVMEDIA_TYPE_AUDIO:
+        enc_ctx->sample_fmt     = av_buffersink_get_format(ost->filter->filter);
+        if (dec_ctx)
+            enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
+                                                 av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
+        enc_ctx->sample_rate    = av_buffersink_get_sample_rate(ost->filter->filter);
+        enc_ctx->channel_layout = av_buffersink_get_channel_layout(ost->filter->filter);
+        enc_ctx->channels       = av_buffersink_get_channels(ost->filter->filter);
+
+        init_encoder_time_base(ost, av_make_q(1, enc_ctx->sample_rate));
+        break;
+
+    case AVMEDIA_TYPE_VIDEO:
+        init_encoder_time_base(ost, av_inv_q(ost->frame_rate));
+
+        if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
+            enc_ctx->time_base = av_buffersink_get_time_base(ost->filter->filter);
+        if (   av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
+           && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
+            av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
+                                       "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
+        }
+        for (j = 0; j < ost->forced_kf_count; j++)
+            ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
+                                                 AV_TIME_BASE_Q,
+                                                 enc_ctx->time_base);
+
+        enc_ctx->width  = av_buffersink_get_w(ost->filter->filter);
+        enc_ctx->height = av_buffersink_get_h(ost->filter->filter);
+        enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
+            ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
+            av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
+            av_buffersink_get_sample_aspect_ratio(ost->filter->filter);
+
+        enc_ctx->pix_fmt = av_buffersink_get_format(ost->filter->filter);
+        if (dec_ctx)
+            enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
+                                                 av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
+
+        enc_ctx->framerate = ost->frame_rate;
+
+        ost->st->avg_frame_rate = ost->frame_rate;
+
+        if (!dec_ctx ||
+            enc_ctx->width   != dec_ctx->width  ||
+            enc_ctx->height  != dec_ctx->height ||
+            enc_ctx->pix_fmt != dec_ctx->pix_fmt) {
+            enc_ctx->bits_per_raw_sample = frame_bits_per_raw_sample;
+        }
+
+        if (ost->forced_keyframes) {
+            if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
+                ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
+                                    forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
+                if (ret < 0) {
+                    av_log(NULL, AV_LOG_ERROR,
+                           "Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
+                    return ret;
+                }
+                ost->forced_keyframes_expr_const_values[FKF_N] = 0;
+                ost->forced_keyframes_expr_const_values[FKF_N_FORCED] = 0;
+                ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] = NAN;
+                ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] = NAN;
+
+            // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
+            // parse it only for static kf timings
+            } else if(strncmp(ost->forced_keyframes, "source", 6)) {
+                parse_forced_key_frames(ost->forced_keyframes, ost, ost->enc_ctx);
+            }
+        }
+        break;
+    case AVMEDIA_TYPE_SUBTITLE:
+        enc_ctx->time_base = AV_TIME_BASE_Q;
+        if (!enc_ctx->width) {
+            enc_ctx->width     = input_streams[ost->source_index]->st->codecpar->width;
+            enc_ctx->height    = input_streams[ost->source_index]->st->codecpar->height;
+        }
+        break;
+    case AVMEDIA_TYPE_DATA:
+        break;
+    default:
+        abort();
+        break;
+    }
+
+    ost->mux_timebase = enc_ctx->time_base;
+
+    return 0;
+}
+
+static int init_output_stream(OutputStream *ost, char *error, int error_len)
+{
+    int ret = 0;
+
+    if (ost->encoding_needed) {
+        AVCodec      *codec = ost->enc;
         AVCodecContext *dec = NULL;
         InputStream *ist;
 
+        ret = init_output_stream_encode(ost);
+        if (ret < 0)
+            return ret;
+
         if ((ist = get_input_stream(ost)))
             dec = ist->dec_ctx;
         if (dec && dec->subtitle_header) {
@@ -3014,10 +3464,20 @@ static int init_output_stream(OutputStream *ost, char *error, int error_len)
             !av_dict_get(ost->encoder_opts, "ab", NULL, 0))
             av_dict_set(&ost->encoder_opts, "b", "128000", 0);
 
-        if (ost->filter && ost->filter->filter->inputs[0]->hw_frames_ctx) {
-            ost->enc_ctx->hw_frames_ctx = av_buffer_ref(ost->filter->filter->inputs[0]->hw_frames_ctx);
+        if (ost->filter && av_buffersink_get_hw_frames_ctx(ost->filter->filter) &&
+            ((AVHWFramesContext*)av_buffersink_get_hw_frames_ctx(ost->filter->filter)->data)->format ==
+            av_buffersink_get_format(ost->filter->filter)) {
+            ost->enc_ctx->hw_frames_ctx = av_buffer_ref(av_buffersink_get_hw_frames_ctx(ost->filter->filter));
             if (!ost->enc_ctx->hw_frames_ctx)
                 return AVERROR(ENOMEM);
+        } else {
+            ret = hw_device_setup_for_encode(ost);
+            if (ret < 0) {
+                snprintf(error, error_len, "Device setup failed for "
+                         "encoder on output stream #%d:%d : %s",
+                     ost->file_index, ost->index, av_err2str(ret));
+                return ret;
+            }
         }
 
         if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
@@ -3054,27 +3514,45 @@ static int init_output_stream(OutputStream *ost, char *error, int error_len)
         if (ost->enc_ctx->nb_coded_side_data) {
             int i;
 
-            ost->st->side_data = av_realloc_array(NULL, ost->enc_ctx->nb_coded_side_data,
-                                                  sizeof(*ost->st->side_data));
-            if (!ost->st->side_data)
-                return AVERROR(ENOMEM);
-
             for (i = 0; i < ost->enc_ctx->nb_coded_side_data; i++) {
                 const AVPacketSideData *sd_src = &ost->enc_ctx->coded_side_data[i];
-                AVPacketSideData *sd_dst = &ost->st->side_data[i];
+                uint8_t *dst_data;
+
+                dst_data = av_stream_new_side_data(ost->st, sd_src->type, sd_src->size);
+                if (!dst_data)
+                    return AVERROR(ENOMEM);
+                memcpy(dst_data, sd_src->data, sd_src->size);
+            }
+        }
 
-                sd_dst->data = av_malloc(sd_src->size);
-                if (!sd_dst->data)
+        /*
+         * Add global input side data. For now this is naive, and copies it
+         * from the input stream's global side data. All side data should
+         * really be funneled over AVFrame and libavfilter, then added back to
+         * packet side data, and then potentially using the first packet for
+         * global side data.
+         */
+        if (ist) {
+            int i;
+            for (i = 0; i < ist->st->nb_side_data; i++) {
+                AVPacketSideData *sd = &ist->st->side_data[i];
+                uint8_t *dst = av_stream_new_side_data(ost->st, sd->type, sd->size);
+                if (!dst)
                     return AVERROR(ENOMEM);
-                memcpy(sd_dst->data, sd_src->data, sd_src->size);
-                sd_dst->size = sd_src->size;
-                sd_dst->type = sd_src->type;
-                ost->st->nb_side_data++;
+                memcpy(dst, sd->data, sd->size);
+                if (ist->autorotate && sd->type == AV_PKT_DATA_DISPLAYMATRIX)
+                    av_display_rotation_set((uint32_t *)dst, 0);
             }
         }
 
         // copy timebase while removing common factors
-        ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
+        if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
+            ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
+
+        // copy estimated duration as a hint to the muxer
+        if (ost->st->duration <= 0 && ist && ist->st->duration > 0)
+            ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
+
         ost->st->codec->codec= ost->enc_ctx->codec;
     } else if (ost->stream_copy) {
         ret = init_output_stream_streamcopy(ost);
@@ -3090,6 +3568,38 @@ static int init_output_stream(OutputStream *ost, char *error, int error_len)
             return ret;
     }
 
+    // parse user provided disposition, and update stream values
+    if (ost->disposition) {
+        static const AVOption opts[] = {
+            { "disposition"         , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
+            { "default"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT           },    .unit = "flags" },
+            { "dub"                 , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB               },    .unit = "flags" },
+            { "original"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL          },    .unit = "flags" },
+            { "comment"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT           },    .unit = "flags" },
+            { "lyrics"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS            },    .unit = "flags" },
+            { "karaoke"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE           },    .unit = "flags" },
+            { "forced"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED            },    .unit = "flags" },
+            { "hearing_impaired"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED  },    .unit = "flags" },
+            { "visual_impaired"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED   },    .unit = "flags" },
+            { "clean_effects"       , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS     },    .unit = "flags" },
+            { "captions"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS          },    .unit = "flags" },
+            { "descriptions"        , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS      },    .unit = "flags" },
+            { "metadata"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA          },    .unit = "flags" },
+            { NULL },
+        };
+        static const AVClass class = {
+            .class_name = "",
+            .item_name  = av_default_item_name,
+            .option     = opts,
+            .version    = LIBAVUTIL_VERSION_INT,
+        };
+        const AVClass *pclass = &class;
+
+        ret = av_opt_eval_flags(&pclass, &opts[0], ost->disposition, &ost->st->disposition);
+        if (ret < 0)
+            return ret;
+    }
+
     /* initialize bitstream filters for the output stream
      * needs to be done here, because the codec id for streamcopy is not
      * known until now */
@@ -3106,69 +3616,6 @@ static int init_output_stream(OutputStream *ost, char *error, int error_len)
     return ret;
 }
 
-static void parse_forced_key_frames(char *kf, OutputStream *ost,
-                                    AVCodecContext *avctx)
-{
-    char *p;
-    int n = 1, i, size, index = 0;
-    int64_t t, *pts;
-
-    for (p = kf; *p; p++)
-        if (*p == ',')
-            n++;
-    size = n;
-    pts = av_malloc_array(size, sizeof(*pts));
-    if (!pts) {
-        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
-        exit_program(1);
-    }
-
-    p = kf;
-    for (i = 0; i < n; i++) {
-        char *next = strchr(p, ',');
-
-        if (next)
-            *next++ = 0;
-
-        if (!memcmp(p, "chapters", 8)) {
-
-            AVFormatContext *avf = output_files[ost->file_index]->ctx;
-            int j;
-
-            if (avf->nb_chapters > INT_MAX - size ||
-                !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
-                                     sizeof(*pts)))) {
-                av_log(NULL, AV_LOG_FATAL,
-                       "Could not allocate forced key frames array.\n");
-                exit_program(1);
-            }
-            t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
-            t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
-
-            for (j = 0; j < avf->nb_chapters; j++) {
-                AVChapter *c = avf->chapters[j];
-                av_assert1(index < size);
-                pts[index++] = av_rescale_q(c->start, c->time_base,
-                                            avctx->time_base) + t;
-            }
-
-        } else {
-
-            t = parse_time_or_die("force_key_frames", p, 1);
-            av_assert1(index < size);
-            pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
-
-        }
-
-        p = next;
-    }
-
-    av_assert0(index == size);
-    qsort(pts, size, sizeof(*pts), compare_int64);
-    ost->forced_kf_count = size;
-    ost->forced_kf_pts   = pts;
-}
-
 static void report_new_stream(int input_index, AVPacket *pkt)
 {
     InputFile *file = input_files[input_index];
@@ -3184,47 +3631,6 @@ static void report_new_stream(int input_index, AVPacket *pkt)
     file->nb_streams_warn = pkt->stream_index + 1;
 }
 
-static void set_encoder_id(OutputFile *of, OutputStream *ost)
-{
-    AVDictionaryEntry *e;
-
-    uint8_t *encoder_string;
-    int encoder_string_len;
-    int format_flags = 0;
-    int codec_flags = 0;
-
-    if (av_dict_get(ost->st->metadata, "encoder",  NULL, 0))
-        return;
-
-    e = av_dict_get(of->opts, "fflags", NULL, 0);
-    if (e) {
-        const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
-        if (!o)
-            return;
-        av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
-    }
-    e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
-    if (e) {
-        const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
-        if (!o)
-            return;
-        av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
-    }
-
-    encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
-    encoder_string     = av_mallocz(encoder_string_len);
-    if (!encoder_string)
-        exit_program(1);
-
-    if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
-        av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
-    else
-        av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
-    av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
-    av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
-                AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
-}
-
 static int transcode_init(void)
 {
     int ret = 0, i, j, k;
@@ -3256,216 +3662,6 @@ static int transcode_init(void)
                 input_streams[j + ifile->ist_index]->start = av_gettime_relative();
     }
 
-    /* for each output stream, we compute the right encoding parameters */
-    for (i = 0; i < nb_output_streams; i++) {
-        ost = output_streams[i];
-        oc  = output_files[ost->file_index]->ctx;
-        ist = get_input_stream(ost);
-
-        if (ost->attachment_filename)
-            continue;
-
-        if (ist) {
-            ost->st->disposition          = ist->st->disposition;
-        } else {
-            for (j=0; j<oc->nb_streams; j++) {
-                AVStream *st = oc->streams[j];
-                if (st != ost->st && st->codecpar->codec_type == ost->st->codecpar->codec_type)
-                    break;
-            }
-            if (j == oc->nb_streams)
-                if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ||
-                    ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
-                    ost->st->disposition = AV_DISPOSITION_DEFAULT;
-        }
-
-        if (!ost->stream_copy) {
-            AVCodecContext *enc_ctx = ost->enc_ctx;
-            AVCodecContext *dec_ctx = NULL;
-
-            set_encoder_id(output_files[ost->file_index], ost);
-
-            if (ist) {
-                dec_ctx = ist->dec_ctx;
-
-                enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
-            }
-
-#if CONFIG_LIBMFX
-            if (qsv_transcode_init(ost))
-                exit_program(1);
-#endif
-
-#if CONFIG_CUVID
-            if (cuvid_transcode_init(ost))
-                exit_program(1);
-#endif
-
-            if ((enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
-                 enc_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
-                 filtergraph_is_simple(ost->filter->graph)) {
-                    FilterGraph *fg = ost->filter->graph;
-                    if (configure_filtergraph(fg)) {
-                        av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
-                        exit_program(1);
-                    }
-            }
-
-            if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
-                if (!ost->frame_rate.num)
-                    ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
-                if (ist && !ost->frame_rate.num)
-                    ost->frame_rate = ist->framerate;
-                if (ist && !ost->frame_rate.num)
-                    ost->frame_rate = ist->st->r_frame_rate;
-                if (ist && !ost->frame_rate.num) {
-                    ost->frame_rate = (AVRational){25, 1};
-                    av_log(NULL, AV_LOG_WARNING,
-                           "No information "
-                           "about the input framerate is available. Falling "
-                           "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
-                           "if you want a different framerate.\n",
-                           ost->file_index, ost->index);
-                }
-//                    ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
-                if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
-                    int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
-                    ost->frame_rate = ost->enc->supported_framerates[idx];
-                }
-                // reduce frame rate for mpeg4 to be within the spec limits
-                if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
-                    av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
-                              ost->frame_rate.num, ost->frame_rate.den, 65535);
-                }
-            }
-
-            switch (enc_ctx->codec_type) {
-            case AVMEDIA_TYPE_AUDIO:
-                enc_ctx->sample_fmt     = ost->filter->filter->inputs[0]->format;
-                if (dec_ctx)
-                    enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
-                                                         av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
-                enc_ctx->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
-                enc_ctx->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
-                enc_ctx->channels       = avfilter_link_get_channels(ost->filter->filter->inputs[0]);
-                enc_ctx->time_base      = (AVRational){ 1, enc_ctx->sample_rate };
-                break;
-            case AVMEDIA_TYPE_VIDEO:
-                enc_ctx->time_base = av_inv_q(ost->frame_rate);
-                if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
-                    enc_ctx->time_base = ost->filter->filter->inputs[0]->time_base;
-                if (   av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
-                   && (video_sync_method == VSYNC_CFR || video_sync_method == VSYNC_VSCFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
-                    av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
-                                               "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
-                }
-                for (j = 0; j < ost->forced_kf_count; j++)
-                    ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
-                                                         AV_TIME_BASE_Q,
-                                                         enc_ctx->time_base);
-
-                enc_ctx->width  = ost->filter->filter->inputs[0]->w;
-                enc_ctx->height = ost->filter->filter->inputs[0]->h;
-                enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
-                    ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
-                    av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
-                    ost->filter->filter->inputs[0]->sample_aspect_ratio;
-                if (!strncmp(ost->enc->name, "libx264", 7) &&
-                    enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
-                    ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
-                    av_log(NULL, AV_LOG_WARNING,
-                           "No pixel format specified, %s for H.264 encoding chosen.\n"
-                           "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
-                           av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
-                if (!strncmp(ost->enc->name, "mpeg2video", 10) &&
-                    enc_ctx->pix_fmt == AV_PIX_FMT_NONE &&
-                    ost->filter->filter->inputs[0]->format != AV_PIX_FMT_YUV420P)
-                    av_log(NULL, AV_LOG_WARNING,
-                           "No pixel format specified, %s for MPEG-2 encoding chosen.\n"
-                           "Use -pix_fmt yuv420p for compatibility with outdated media players.\n",
-                           av_get_pix_fmt_name(ost->filter->filter->inputs[0]->format));
-                enc_ctx->pix_fmt = ost->filter->filter->inputs[0]->format;
-                if (dec_ctx)
-                    enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
-                                                         av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
-
-                ost->st->avg_frame_rate = ost->frame_rate;
-
-                if (!dec_ctx ||
-                    enc_ctx->width   != dec_ctx->width  ||
-                    enc_ctx->height  != dec_ctx->height ||
-                    enc_ctx->pix_fmt != dec_ctx->pix_fmt) {
-                    enc_ctx->bits_per_raw_sample = frame_bits_per_raw_sample;
-                }
-
-                if (ost->forced_keyframes) {
-                    if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
-                        ret = av_expr_parse(&ost->forced_keyframes_pexpr, ost->forced_keyframes+5,
-                                            forced_keyframes_const_names, NULL, NULL, NULL, NULL, 0, NULL);
-                        if (ret < 0) {
-                            av_log(NULL, AV_LOG_ERROR,
-                                   "Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
-                            return ret;
-                        }
-                        ost->forced_keyframes_expr_const_values[FKF_N] = 0;
-                        ost->forced_keyframes_expr_const_values[FKF_N_FORCED] = 0;
-                        ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_N] = NAN;
-                        ost->forced_keyframes_expr_const_values[FKF_PREV_FORCED_T] = NAN;
-
-                        // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
-                        // parse it only for static kf timings
-                    } else if(strncmp(ost->forced_keyframes, "source", 6)) {
-                        parse_forced_key_frames(ost->forced_keyframes, ost, ost->enc_ctx);
-                    }
-                }
-                break;
-            case AVMEDIA_TYPE_SUBTITLE:
-                enc_ctx->time_base = (AVRational){1, 1000};
-                if (!enc_ctx->width) {
-                    enc_ctx->width     = input_streams[ost->source_index]->st->codecpar->width;
-                    enc_ctx->height    = input_streams[ost->source_index]->st->codecpar->height;
-                }
-                break;
-            case AVMEDIA_TYPE_DATA:
-                break;
-            default:
-                abort();
-                break;
-            }
-        }
-
-        if (ost->disposition) {
-            static const AVOption opts[] = {
-                { "disposition"         , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
-                { "default"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT           },    .unit = "flags" },
-                { "dub"                 , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB               },    .unit = "flags" },
-                { "original"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL          },    .unit = "flags" },
-                { "comment"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT           },    .unit = "flags" },
-                { "lyrics"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS            },    .unit = "flags" },
-                { "karaoke"             , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE           },    .unit = "flags" },
-                { "forced"              , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED            },    .unit = "flags" },
-                { "hearing_impaired"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED  },    .unit = "flags" },
-                { "visual_impaired"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED   },    .unit = "flags" },
-                { "clean_effects"       , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS     },    .unit = "flags" },
-                { "captions"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS          },    .unit = "flags" },
-                { "descriptions"        , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS      },    .unit = "flags" },
-                { "metadata"            , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA          },    .unit = "flags" },
-                { NULL },
-            };
-            static const AVClass class = {
-                .class_name = "",
-                .item_name  = av_default_item_name,
-                .option     = opts,
-                .version    = LIBAVUTIL_VERSION_INT,
-            };
-            const AVClass *pclass = &class;
-
-            ret = av_opt_eval_flags(&pclass, &opts[0], ost->disposition, &ost->st->disposition);
-            if (ret < 0)
-                goto dump_format;
-        }
-    }
-
     /* init input streams */
     for (i = 0; i < nb_input_streams; i++)
         if ((ret = init_input_stream(i, error, sizeof(error))) < 0) {
@@ -3478,6 +3674,10 @@ static int transcode_init(void)
 
     /* open each encoder */
     for (i = 0; i < nb_output_streams; i++) {
+        // skip streams fed from filtergraphs until we have a frame for them
+        if (output_streams[i]->filter)
+            continue;
+
         ret = init_output_stream(output_streams[i], error, sizeof(error));
         if (ret < 0)
             goto dump_format;
@@ -3598,7 +3798,7 @@ static int transcode_init(void)
         return ret;
     }
 
-    transcode_init_done = 1;
+    atomic_store(&transcode_init_done, 1);
 
     return 0;
 }
@@ -3648,6 +3848,9 @@ static OutputStream *choose_output(void)
         if (ost->st->cur_dts == AV_NOPTS_VALUE)
             av_log(NULL, AV_LOG_DEBUG, "cur_dts is invalid (this is harmless if it occurs once at the start per stream)\n");
 
+        if (!ost->initialized && !ost->inputs_done)
+            return ost;
+
         if (!ost->finished && opts < opts_min) {
             opts_min = opts;
             ost_min  = ost->unavailable ? NULL : ost;
@@ -3739,7 +3942,11 @@ static int check_keyboard_interaction(int64_t cur_time)
         if(key == 'D') {
             debug = input_streams[0]->st->codec->debug<<1;
             if(!debug) debug = 1;
-            while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
+            while(debug & (FF_DEBUG_DCT_COEFF
+#if FF_API_DEBUG_MV
+                                             |FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE
+#endif
+                                                                                  )) //unsupported, would just crash
                 debug += debug;
         }else{
             char buf[32];
@@ -4134,15 +4341,14 @@ static int process_input(int file_index)
 
     /* add the stream-global side data to the first packet */
     if (ist->nb_packets == 1) {
-        if (ist->st->nb_side_data)
-            av_packet_split_side_data(&pkt);
         for (i = 0; i < ist->st->nb_side_data; i++) {
             AVPacketSideData *src_sd = &ist->st->side_data[i];
             uint8_t *dst_data;
 
-            if (av_packet_get_side_data(&pkt, src_sd->type, NULL))
+            if (src_sd->type == AV_PKT_DATA_DISPLAYMATRIX)
                 continue;
-            if (ist->autorotate && src_sd->type == AV_PKT_DATA_DISPLAYMATRIX)
+
+            if (av_packet_get_side_data(&pkt, src_sd->type, NULL))
                 continue;
 
             dst_data = av_packet_new_side_data(&pkt, src_sd->type, src_sd->size);
@@ -4305,7 +4511,7 @@ static int transcode_from_filter(FilterGraph *graph, InputStream **best_ist)
 static int transcode_step(void)
 {
     OutputStream *ost;
-    InputStream  *ist;
+    InputStream  *ist = NULL;
     int ret;
 
     ost = choose_output();
@@ -4319,11 +4525,43 @@ static int transcode_step(void)
         return AVERROR_EOF;
     }
 
-    if (ost->filter) {
+    if (ost->filter && !ost->filter->graph->graph) {
+        if (ifilter_has_all_input_formats(ost->filter->graph)) {
+            ret = configure_filtergraph(ost->filter->graph);
+            if (ret < 0) {
+                av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
+                return ret;
+            }
+        }
+    }
+
+    if (ost->filter && ost->filter->graph->graph) {
+        if (!ost->initialized) {
+            char error[1024] = {0};
+            ret = init_output_stream(ost, error, sizeof(error));
+            if (ret < 0) {
+                av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
+                       ost->file_index, ost->index, error);
+                exit_program(1);
+            }
+        }
         if ((ret = transcode_from_filter(ost->filter->graph, &ist)) < 0)
             return ret;
         if (!ist)
             return 0;
+    } else if (ost->filter) {
+        int i;
+        for (i = 0; i < ost->filter->graph->nb_inputs; i++) {
+            InputFilter *ifilter = ost->filter->graph->inputs[i];
+            if (!ifilter->ist->got_output && !input_files[ifilter->ist->file_index]->eof_reached) {
+                ist = ifilter->ist;
+                break;
+            }
+        }
+        if (!ist) {
+            ost->inputs_done = 1;
+            return 0;
+        }
     } else {
         av_assert0(ost->source_index >= 0);
         ist = input_streams[ost->source_index];
@@ -4421,7 +4659,7 @@ static int transcode(void)
             continue;
         }
         if ((ret = av_write_trailer(os)) < 0) {
-            av_log(NULL, AV_LOG_ERROR, "Error writing trailer of %s: %s", os->filename, av_err2str(ret));
+            av_log(NULL, AV_LOG_ERROR, "Error writing trailer of %s: %s\n", os->filename, av_err2str(ret));
             if (exit_on_error)
                 exit_program(1);
         }
@@ -4455,6 +4693,7 @@ static int transcode(void)
     }
 
     av_buffer_unref(&hw_device_ctx);
+    hw_device_free_all();
 
     /* finished ! */
     ret = 0;
diff --git a/mythtv/external/FFmpeg/fftools/ffmpeg.h b/mythtv/external/FFmpeg/fftools/ffmpeg.h
index e1d4593b279..f6c76bcc553 100644
--- a/mythtv/external/FFmpeg/fftools/ffmpeg.h
+++ b/mythtv/external/FFmpeg/fftools/ffmpeg.h
@@ -16,8 +16,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#ifndef FFMPEG_H
-#define FFMPEG_H
+#ifndef FFTOOLS_FFMPEG_H
+#define FFTOOLS_FFMPEG_H
 
 #include "config.h"
 
@@ -42,6 +42,7 @@
 #include "libavutil/dict.h"
 #include "libavutil/eval.h"
 #include "libavutil/fifo.h"
+#include "libavutil/hwcontext.h"
 #include "libavutil/pixfmt.h"
 #include "libavutil/rational.h"
 #include "libavutil/threadmessage.h"
@@ -67,6 +68,7 @@ enum HWAccelID {
     HWACCEL_QSV,
     HWACCEL_VAAPI,
     HWACCEL_CUVID,
+    HWACCEL_D3D11VA,
 };
 
 typedef struct HWAccel {
@@ -74,8 +76,15 @@ typedef struct HWAccel {
     int (*init)(AVCodecContext *s);
     enum HWAccelID id;
     enum AVPixelFormat pix_fmt;
+    enum AVHWDeviceType device_type;
 } HWAccel;
 
+typedef struct HWDevice {
+    char *name;
+    enum AVHWDeviceType type;
+    AVBufferRef *device_ref;
+} HWDevice;
+
 /* select an input stream for an output stream */
 typedef struct StreamMap {
     int disabled;           /* 1 is this mapping is disabled by a negative map */
@@ -224,6 +233,10 @@ typedef struct OptionsContext {
     int        nb_disposition;
     SpecifierOpt *program;
     int        nb_program;
+    SpecifierOpt *time_bases;
+    int        nb_time_bases;
+    SpecifierOpt *enc_time_bases;
+    int        nb_enc_time_bases;
 } OptionsContext;
 
 typedef struct InputFilter {
@@ -231,6 +244,23 @@ typedef struct InputFilter {
     struct InputStream *ist;
     struct FilterGraph *graph;
     uint8_t            *name;
+    enum AVMediaType    type;   // AVMEDIA_TYPE_SUBTITLE for sub2video
+
+    AVFifoBuffer *frame_queue;
+
+    // parameters configured for this input
+    int format;
+
+    int width, height;
+    AVRational sample_aspect_ratio;
+
+    int sample_rate;
+    int channels;
+    uint64_t channel_layout;
+
+    AVBufferRef *hw_frames_ctx;
+
+    int eof;
 } InputFilter;
 
 typedef struct OutputFilter {
@@ -242,6 +272,18 @@ typedef struct OutputFilter {
     /* temporary storage until stream maps are processed */
     AVFilterInOut       *out_tmp;
     enum AVMediaType     type;
+
+    /* desired output stream properties */
+    int width, height;
+    AVRational frame_rate;
+    int format;
+    int sample_rate;
+    uint64_t channel_layout;
+
+    // those are only set if no format is specified and the encoder gives us multiple options
+    int *formats;
+    uint64_t *channel_layouts;
+    int *sample_rates;
 } OutputFilter;
 
 typedef struct FilterGraph {
@@ -285,6 +327,11 @@ typedef struct InputStream {
 
     int64_t min_pts; /* pts with the smallest value in a current stream */
     int64_t max_pts; /* pts with the higher value in a current stream */
+
+    // when forcing constant input framerate through -r,
+    // this contains the pts that will be given to the next decoded frame
+    int64_t cfr_next_pts;
+
     int64_t nb_samples; /* number of samples in the last decoded audio frame before looping */
 
     double ts_scale;
@@ -295,14 +342,6 @@ typedef struct InputStream {
     int guess_layout_max;
 
     int autorotate;
-    int resample_height;
-    int resample_width;
-    int resample_pix_fmt;
-
-    int      resample_sample_fmt;
-    int      resample_sample_rate;
-    int      resample_channels;
-    uint64_t resample_channel_layout;
 
     int fix_sub_duration;
     struct { /* previous decoded subtitle and related variables */
@@ -314,6 +353,7 @@ typedef struct InputStream {
     struct sub2video {
         int64_t last_pts;
         int64_t end_pts;
+        AVFifoBuffer *sub_queue;    ///< queue of AVSubtitle* before filter init
         AVFrame *frame;
         int w, h;
     } sub2video;
@@ -353,6 +393,8 @@ typedef struct InputStream {
 
     int64_t *dts_buffer;
     int nb_dts_buffer;
+
+    int got_output;
 } InputStream;
 
 typedef struct InputFile {
@@ -420,9 +462,11 @@ typedef struct OutputStream {
     int64_t first_pts;
     /* dts of the last packet sent to the muxer */
     int64_t last_mux_dts;
+    // the timebase of the packets sent to the muxer
+    AVRational mux_timebase;
+    AVRational enc_timebase;
 
     int                    nb_bitstream_filters;
-    uint8_t                  *bsf_extradata_updated;
     AVBSFContext            **bsf_ctx;
 
     AVCodecContext *enc_ctx;
@@ -442,6 +486,7 @@ typedef struct OutputStream {
     int force_fps;
     int top_field_first;
     int rotate_overridden;
+    double rotate_override_value;
 
     AVRational frame_aspect_ratio;
 
@@ -479,6 +524,8 @@ typedef struct OutputStream {
     // parameters are set in the AVStream.
     int initialized;
 
+    int inputs_done;
+
     const char *attachment_filename;
     int copy_initial_nonkeyframes;
     int copy_prior_start;
@@ -569,12 +616,20 @@ extern AVIOContext *progress_avio;
 extern float max_error_rate;
 extern char *videotoolbox_pixfmt;
 
+extern int filter_nbthreads;
+extern int filter_complex_nbthreads;
+extern int vstats_version;
+
 extern const AVIOInterruptCB int_cb;
 
 extern const OptionDef options[];
 extern const HWAccel hwaccels[];
 extern int hwaccel_lax_profile_check;
 extern AVBufferRef *hw_device_ctx;
+#if CONFIG_QSV
+extern char *qsv_device;
+#endif
+extern HWDevice *filter_hw_device;
 
 
 void term_init(void);
@@ -595,22 +650,30 @@ void choose_sample_fmt(AVStream *st, AVCodec *codec);
 
 int configure_filtergraph(FilterGraph *fg);
 int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out);
+void check_filter_outputs(void);
 int ist_in_filtergraph(FilterGraph *fg, InputStream *ist);
 int filtergraph_is_simple(FilterGraph *fg);
 int init_simple_filtergraph(InputStream *ist, OutputStream *ost);
 int init_complex_filtergraph(FilterGraph *fg);
 
+void sub2video_update(InputStream *ist, AVSubtitle *sub);
+
+int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame);
+
 int ffmpeg_parse_options(int argc, char **argv);
 
-int vdpau_init(AVCodecContext *s);
-int dxva2_init(AVCodecContext *s);
 int vda_init(AVCodecContext *s);
 int videotoolbox_init(AVCodecContext *s);
 int qsv_init(AVCodecContext *s);
-int qsv_transcode_init(OutputStream *ost);
-int vaapi_decode_init(AVCodecContext *avctx);
-int vaapi_device_init(const char *device);
 int cuvid_init(AVCodecContext *s);
-int cuvid_transcode_init(OutputStream *ost);
 
-#endif /* FFMPEG_H */
+HWDevice *hw_device_get_by_name(const char *name);
+int hw_device_init_from_string(const char *arg, HWDevice **dev);
+void hw_device_free_all(void);
+
+int hw_device_setup_for_decode(InputStream *ist);
+int hw_device_setup_for_encode(OutputStream *ost);
+
+int hwaccel_decode_init(AVCodecContext *avctx);
+
+#endif /* FFTOOLS_FFMPEG_H */
diff --git a/mythtv/external/FFmpeg/fftools/ffmpeg_cuvid.c b/mythtv/external/FFmpeg/fftools/ffmpeg_cuvid.c
index 766878f58bc..3ff3b40f17d 100644
--- a/mythtv/external/FFmpeg/fftools/ffmpeg_cuvid.c
+++ b/mythtv/external/FFmpeg/fftools/ffmpeg_cuvid.c
@@ -17,139 +17,57 @@
  */
 
 #include "libavutil/hwcontext.h"
+#include "libavutil/pixdesc.h"
 
 #include "ffmpeg.h"
 
-typedef struct CUVIDContext {
-    AVBufferRef *hw_frames_ctx;
-} CUVIDContext;
-
 static void cuvid_uninit(AVCodecContext *avctx)
 {
-    InputStream  *ist = avctx->opaque;
-    CUVIDContext *ctx = ist->hwaccel_ctx;
-
-    if (ctx) {
-        av_buffer_unref(&ctx->hw_frames_ctx);
-        av_freep(&ctx);
-    }
-
+    InputStream *ist = avctx->opaque;
     av_buffer_unref(&ist->hw_frames_ctx);
-
-    ist->hwaccel_ctx = 0;
-    ist->hwaccel_uninit = 0;
 }
 
 int cuvid_init(AVCodecContext *avctx)
 {
-    InputStream  *ist = avctx->opaque;
-    CUVIDContext *ctx = ist->hwaccel_ctx;
-
-    av_log(NULL, AV_LOG_TRACE, "Initializing cuvid hwaccel\n");
-
-    if (!ctx) {
-        av_log(NULL, AV_LOG_ERROR, "CUVID transcoding is not initialized. "
-               "-hwaccel cuvid should only be used for one-to-one CUVID transcoding "
-               "with no (software) filters.\n");
-        return AVERROR(EINVAL);
-    }
-
-    return 0;
-}
-
-int cuvid_transcode_init(OutputStream *ost)
-{
-    InputStream *ist;
-    const enum AVPixelFormat *pix_fmt;
-    AVHWFramesContext *hwframe_ctx;
-    AVBufferRef *device_ref = NULL;
-    CUVIDContext *ctx = NULL;
-    int ret = 0;
-
-    av_log(NULL, AV_LOG_TRACE, "Initializing cuvid transcoding\n");
+    InputStream *ist = avctx->opaque;
+    AVHWFramesContext *frames_ctx;
+    int ret;
 
-    if (ost->source_index < 0)
-        return 0;
+    av_log(avctx, AV_LOG_VERBOSE, "Initializing cuvid hwaccel\n");
 
-    ist = input_streams[ost->source_index];
-
-    /* check if the encoder supports CUVID */
-    if (!ost->enc->pix_fmts)
-        goto cancel;
-    for (pix_fmt = ost->enc->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++)
-        if (*pix_fmt == AV_PIX_FMT_CUDA)
-            break;
-    if (*pix_fmt == AV_PIX_FMT_NONE)
-        goto cancel;
-
-    /* check if the decoder supports CUVID */
-    if (ist->hwaccel_id != HWACCEL_CUVID || !ist->dec || !ist->dec->pix_fmts)
-        goto cancel;
-    for (pix_fmt = ist->dec->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++)
-        if (*pix_fmt == AV_PIX_FMT_CUDA)
-            break;
-    if (*pix_fmt == AV_PIX_FMT_NONE)
-        goto cancel;
-
-    av_log(NULL, AV_LOG_VERBOSE, "Setting up CUVID transcoding\n");
-
-    if (ist->hwaccel_ctx) {
-        ctx = ist->hwaccel_ctx;
-    } else {
-        ctx = av_mallocz(sizeof(*ctx));
-        if (!ctx) {
-            ret = AVERROR(ENOMEM);
-            goto error;
+    if (!hw_device_ctx) {
+        ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_CUDA,
+                                     ist->hwaccel_device, NULL, 0);
+        if (ret < 0) {
+            av_log(avctx, AV_LOG_ERROR, "Error creating a CUDA device\n");
+            return ret;
         }
     }
 
-    if (!ctx->hw_frames_ctx) {
-        ret = av_hwdevice_ctx_create(&device_ref, AV_HWDEVICE_TYPE_CUDA,
-                                     ist->hwaccel_device, NULL, 0);
-        if (ret < 0)
-            goto error;
+    av_buffer_unref(&ist->hw_frames_ctx);
+    ist->hw_frames_ctx = av_hwframe_ctx_alloc(hw_device_ctx);
+    if (!ist->hw_frames_ctx) {
+        av_log(avctx, AV_LOG_ERROR, "Error creating a CUDA frames context\n");
+        return AVERROR(ENOMEM);
+    }
 
-        ctx->hw_frames_ctx = av_hwframe_ctx_alloc(device_ref);
-        if (!ctx->hw_frames_ctx) {
-            av_log(NULL, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
-            ret = AVERROR(ENOMEM);
-            goto error;
-        }
-        av_buffer_unref(&device_ref);
+    frames_ctx = (AVHWFramesContext*)ist->hw_frames_ctx->data;
 
-        ist->hw_frames_ctx = av_buffer_ref(ctx->hw_frames_ctx);
-        if (!ist->hw_frames_ctx) {
-            av_log(NULL, AV_LOG_ERROR, "av_buffer_ref failed\n");
-            ret = AVERROR(ENOMEM);
-            goto error;
-        }
+    frames_ctx->format = AV_PIX_FMT_CUDA;
+    frames_ctx->sw_format = avctx->sw_pix_fmt;
+    frames_ctx->width = avctx->width;
+    frames_ctx->height = avctx->height;
 
-        ist->hwaccel_ctx = ctx;
-        ist->resample_pix_fmt = AV_PIX_FMT_CUDA;
-        ist->hwaccel_uninit = cuvid_uninit;
+    av_log(avctx, AV_LOG_DEBUG, "Initializing CUDA frames context: sw_format = %s, width = %d, height = %d\n",
+           av_get_pix_fmt_name(frames_ctx->sw_format), frames_ctx->width, frames_ctx->height);
 
-        /* This is a bit hacky, av_hwframe_ctx_init is called by the cuvid decoder
-         * once it has probed the necessary format information. But as filters/nvenc
-         * need to know the format/sw_format, set them here so they are happy.
-         * This is fine as long as CUVID doesn't add another supported pix_fmt.
-         */
-        hwframe_ctx = (AVHWFramesContext*)ctx->hw_frames_ctx->data;
-        hwframe_ctx->format = AV_PIX_FMT_CUDA;
-        hwframe_ctx->sw_format = AV_PIX_FMT_NV12;
+    ret = av_hwframe_ctx_init(ist->hw_frames_ctx);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error initializing a CUDA frame pool\n");
+        return ret;
     }
 
-    return 0;
-
-error:
-    av_freep(&ctx);
-    av_buffer_unref(&device_ref);
-    return ret;
-
-cancel:
-    if (ist->hwaccel_id == HWACCEL_CUVID) {
-        av_log(NULL, AV_LOG_ERROR, "CUVID hwaccel requested, but impossible to achieve.\n");
-        return AVERROR(EINVAL);
-    }
+    ist->hwaccel_uninit = cuvid_uninit;
 
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/fftools/ffmpeg_dxva2.c b/mythtv/external/FFmpeg/fftools/ffmpeg_dxva2.c
deleted file mode 100644
index 1a391f82f3e..00000000000
--- a/mythtv/external/FFmpeg/fftools/ffmpeg_dxva2.c
+++ /dev/null
@@ -1,444 +0,0 @@
-/*
- * 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 <windows.h>
-
-#ifdef _WIN32_WINNT
-#undef _WIN32_WINNT
-#endif
-#define _WIN32_WINNT 0x0600
-#define DXVA2API_USE_BITFIELDS
-#define COBJMACROS
-
-#include <stdint.h>
-
-#include <d3d9.h>
-#include <dxva2api.h>
-
-#include "ffmpeg.h"
-
-#include "libavcodec/dxva2.h"
-
-#include "libavutil/avassert.h"
-#include "libavutil/buffer.h"
-#include "libavutil/frame.h"
-#include "libavutil/imgutils.h"
-#include "libavutil/pixfmt.h"
-
-#include "libavutil/hwcontext.h"
-#include "libavutil/hwcontext_dxva2.h"
-
-/* define all the GUIDs used directly here,
-   to avoid problems with inconsistent dxva2api.h versions in mingw-w64 and different MSVC version */
-#include <initguid.h>
-DEFINE_GUID(IID_IDirectXVideoDecoderService, 0xfc51a551,0xd5e7,0x11d9,0xaf,0x55,0x00,0x05,0x4e,0x43,0xff,0x02);
-
-DEFINE_GUID(DXVA2_ModeMPEG2_VLD,      0xee27417f, 0x5e28,0x4e65,0xbe,0xea,0x1d,0x26,0xb5,0x08,0xad,0xc9);
-DEFINE_GUID(DXVA2_ModeMPEG2and1_VLD,  0x86695f12, 0x340e,0x4f04,0x9f,0xd3,0x92,0x53,0xdd,0x32,0x74,0x60);
-DEFINE_GUID(DXVA2_ModeH264_E,         0x1b81be68, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
-DEFINE_GUID(DXVA2_ModeH264_F,         0x1b81be69, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
-DEFINE_GUID(DXVADDI_Intel_ModeH264_E, 0x604F8E68, 0x4951,0x4C54,0x88,0xFE,0xAB,0xD2,0x5C,0x15,0xB3,0xD6);
-DEFINE_GUID(DXVA2_ModeVC1_D,          0x1b81beA3, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
-DEFINE_GUID(DXVA2_ModeVC1_D2010,      0x1b81beA4, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
-DEFINE_GUID(DXVA2_ModeHEVC_VLD_Main,  0x5b11d51b, 0x2f4c,0x4452,0xbc,0xc3,0x09,0xf2,0xa1,0x16,0x0c,0xc0);
-DEFINE_GUID(DXVA2_ModeHEVC_VLD_Main10,0x107af0e0, 0xef1a,0x4d19,0xab,0xa8,0x67,0xa1,0x63,0x07,0x3d,0x13);
-DEFINE_GUID(DXVA2_ModeVP9_VLD_Profile0, 0x463707f8, 0xa1d0,0x4585,0x87,0x6d,0x83,0xaa,0x6d,0x60,0xb8,0x9e);
-DEFINE_GUID(DXVA2_NoEncrypt,          0x1b81beD0, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
-DEFINE_GUID(GUID_NULL,                0x00000000, 0x0000,0x0000,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00);
-
-typedef struct dxva2_mode {
-  const GUID     *guid;
-  enum AVCodecID codec;
-} dxva2_mode;
-
-static const dxva2_mode dxva2_modes[] = {
-    /* MPEG-2 */
-    { &DXVA2_ModeMPEG2_VLD,      AV_CODEC_ID_MPEG2VIDEO },
-    { &DXVA2_ModeMPEG2and1_VLD,  AV_CODEC_ID_MPEG2VIDEO },
-
-    /* H.264 */
-    { &DXVA2_ModeH264_F,         AV_CODEC_ID_H264 },
-    { &DXVA2_ModeH264_E,         AV_CODEC_ID_H264 },
-    /* Intel specific H.264 mode */
-    { &DXVADDI_Intel_ModeH264_E, AV_CODEC_ID_H264 },
-
-    /* VC-1 / WMV3 */
-    { &DXVA2_ModeVC1_D2010,      AV_CODEC_ID_VC1  },
-    { &DXVA2_ModeVC1_D2010,      AV_CODEC_ID_WMV3 },
-    { &DXVA2_ModeVC1_D,          AV_CODEC_ID_VC1  },
-    { &DXVA2_ModeVC1_D,          AV_CODEC_ID_WMV3 },
-
-    /* HEVC/H.265 */
-    { &DXVA2_ModeHEVC_VLD_Main,  AV_CODEC_ID_HEVC },
-    { &DXVA2_ModeHEVC_VLD_Main10,AV_CODEC_ID_HEVC },
-
-    /* VP8/9 */
-    { &DXVA2_ModeVP9_VLD_Profile0, AV_CODEC_ID_VP9 },
-
-    { NULL,                      0 },
-};
-
-typedef struct DXVA2Context {
-    IDirectXVideoDecoder        *decoder;
-
-    GUID                        decoder_guid;
-    DXVA2_ConfigPictureDecode   decoder_config;
-    IDirectXVideoDecoderService *decoder_service;
-
-    AVFrame                     *tmp_frame;
-
-    AVBufferRef                 *hw_device_ctx;
-    AVBufferRef                 *hw_frames_ctx;
-} DXVA2Context;
-
-static void dxva2_uninit(AVCodecContext *s)
-{
-    InputStream  *ist = s->opaque;
-    DXVA2Context *ctx = ist->hwaccel_ctx;
-
-    ist->hwaccel_uninit        = NULL;
-    ist->hwaccel_get_buffer    = NULL;
-    ist->hwaccel_retrieve_data = NULL;
-
-    if (ctx->decoder_service)
-        IDirectXVideoDecoderService_Release(ctx->decoder_service);
-
-    av_buffer_unref(&ctx->hw_frames_ctx);
-    av_buffer_unref(&ctx->hw_device_ctx);
-
-    av_frame_free(&ctx->tmp_frame);
-
-    av_freep(&ist->hwaccel_ctx);
-    av_freep(&s->hwaccel_context);
-}
-
-static int dxva2_get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
-{
-    InputStream  *ist = s->opaque;
-    DXVA2Context *ctx = ist->hwaccel_ctx;
-
-    return av_hwframe_get_buffer(ctx->hw_frames_ctx, frame, 0);
-}
-
-static int dxva2_retrieve_data(AVCodecContext *s, AVFrame *frame)
-{
-    InputStream        *ist = s->opaque;
-    DXVA2Context       *ctx = ist->hwaccel_ctx;
-    int                ret;
-
-    ret = av_hwframe_transfer_data(ctx->tmp_frame, frame, 0);
-    if (ret < 0)
-        return ret;
-
-    ret = av_frame_copy_props(ctx->tmp_frame, frame);
-    if (ret < 0) {
-        av_frame_unref(ctx->tmp_frame);
-        return ret;
-    }
-
-    av_frame_unref(frame);
-    av_frame_move_ref(frame, ctx->tmp_frame);
-
-    return 0;
-}
-
-static int dxva2_alloc(AVCodecContext *s)
-{
-    InputStream  *ist = s->opaque;
-    int loglevel = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR;
-    DXVA2Context *ctx;
-    HANDLE device_handle;
-    HRESULT hr;
-
-    AVHWDeviceContext    *device_ctx;
-    AVDXVA2DeviceContext *device_hwctx;
-    int ret;
-
-    ctx = av_mallocz(sizeof(*ctx));
-    if (!ctx)
-        return AVERROR(ENOMEM);
-
-    ist->hwaccel_ctx           = ctx;
-    ist->hwaccel_uninit        = dxva2_uninit;
-    ist->hwaccel_get_buffer    = dxva2_get_buffer;
-    ist->hwaccel_retrieve_data = dxva2_retrieve_data;
-
-    ret = av_hwdevice_ctx_create(&ctx->hw_device_ctx, AV_HWDEVICE_TYPE_DXVA2,
-                                 ist->hwaccel_device, NULL, 0);
-    if (ret < 0)
-        goto fail;
-    device_ctx   = (AVHWDeviceContext*)ctx->hw_device_ctx->data;
-    device_hwctx = device_ctx->hwctx;
-
-    hr = IDirect3DDeviceManager9_OpenDeviceHandle(device_hwctx->devmgr,
-                                                  &device_handle);
-    if (FAILED(hr)) {
-        av_log(NULL, loglevel, "Failed to open a device handle\n");
-        goto fail;
-    }
-
-    hr = IDirect3DDeviceManager9_GetVideoService(device_hwctx->devmgr, device_handle,
-                                                 &IID_IDirectXVideoDecoderService,
-                                                 (void **)&ctx->decoder_service);
-    IDirect3DDeviceManager9_CloseDeviceHandle(device_hwctx->devmgr, device_handle);
-    if (FAILED(hr)) {
-        av_log(NULL, loglevel, "Failed to create IDirectXVideoDecoderService\n");
-        goto fail;
-    }
-
-    ctx->tmp_frame = av_frame_alloc();
-    if (!ctx->tmp_frame)
-        goto fail;
-
-    s->hwaccel_context = av_mallocz(sizeof(struct dxva_context));
-    if (!s->hwaccel_context)
-        goto fail;
-
-    return 0;
-fail:
-    dxva2_uninit(s);
-    return AVERROR(EINVAL);
-}
-
-static int dxva2_get_decoder_configuration(AVCodecContext *s, const GUID *device_guid,
-                                           const DXVA2_VideoDesc *desc,
-                                           DXVA2_ConfigPictureDecode *config)
-{
-    InputStream  *ist = s->opaque;
-    int loglevel = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR;
-    DXVA2Context *ctx = ist->hwaccel_ctx;
-    unsigned cfg_count = 0, best_score = 0;
-    DXVA2_ConfigPictureDecode *cfg_list = NULL;
-    DXVA2_ConfigPictureDecode best_cfg = {{0}};
-    HRESULT hr;
-    int i;
-
-    hr = IDirectXVideoDecoderService_GetDecoderConfigurations(ctx->decoder_service, device_guid, desc, NULL, &cfg_count, &cfg_list);
-    if (FAILED(hr)) {
-        av_log(NULL, loglevel, "Unable to retrieve decoder configurations\n");
-        return AVERROR(EINVAL);
-    }
-
-    for (i = 0; i < cfg_count; i++) {
-        DXVA2_ConfigPictureDecode *cfg = &cfg_list[i];
-
-        unsigned score;
-        if (cfg->ConfigBitstreamRaw == 1)
-            score = 1;
-        else if (s->codec_id == AV_CODEC_ID_H264 && cfg->ConfigBitstreamRaw == 2)
-            score = 2;
-        else
-            continue;
-        if (IsEqualGUID(&cfg->guidConfigBitstreamEncryption, &DXVA2_NoEncrypt))
-            score += 16;
-        if (score > best_score) {
-            best_score = score;
-            best_cfg   = *cfg;
-        }
-    }
-    CoTaskMemFree(cfg_list);
-
-    if (!best_score) {
-        av_log(NULL, loglevel, "No valid decoder configuration available\n");
-        return AVERROR(EINVAL);
-    }
-
-    *config = best_cfg;
-    return 0;
-}
-
-static int dxva2_create_decoder(AVCodecContext *s)
-{
-    InputStream  *ist = s->opaque;
-    int loglevel = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR;
-    DXVA2Context *ctx = ist->hwaccel_ctx;
-    struct dxva_context *dxva_ctx = s->hwaccel_context;
-    GUID *guid_list = NULL;
-    unsigned guid_count = 0, i, j;
-    GUID device_guid = GUID_NULL;
-    const D3DFORMAT surface_format = (s->sw_pix_fmt == AV_PIX_FMT_YUV420P10) ? MKTAG('P','0','1','0') : MKTAG('N','V','1','2');
-    D3DFORMAT target_format = 0;
-    DXVA2_VideoDesc desc = { 0 };
-    DXVA2_ConfigPictureDecode config;
-    HRESULT hr;
-    int surface_alignment, num_surfaces;
-    int ret;
-
-    AVDXVA2FramesContext *frames_hwctx;
-    AVHWFramesContext *frames_ctx;
-
-    hr = IDirectXVideoDecoderService_GetDecoderDeviceGuids(ctx->decoder_service, &guid_count, &guid_list);
-    if (FAILED(hr)) {
-        av_log(NULL, loglevel, "Failed to retrieve decoder device GUIDs\n");
-        goto fail;
-    }
-
-    for (i = 0; dxva2_modes[i].guid; i++) {
-        D3DFORMAT *target_list = NULL;
-        unsigned target_count = 0;
-        const dxva2_mode *mode = &dxva2_modes[i];
-        if (mode->codec != s->codec_id)
-            continue;
-
-        for (j = 0; j < guid_count; j++) {
-            if (IsEqualGUID(mode->guid, &guid_list[j]))
-                break;
-        }
-        if (j == guid_count)
-            continue;
-
-        hr = IDirectXVideoDecoderService_GetDecoderRenderTargets(ctx->decoder_service, mode->guid, &target_count, &target_list);
-        if (FAILED(hr)) {
-            continue;
-        }
-        for (j = 0; j < target_count; j++) {
-            const D3DFORMAT format = target_list[j];
-            if (format == surface_format) {
-                target_format = format;
-                break;
-            }
-        }
-        CoTaskMemFree(target_list);
-        if (target_format) {
-            device_guid = *mode->guid;
-            break;
-        }
-    }
-    CoTaskMemFree(guid_list);
-
-    if (IsEqualGUID(&device_guid, &GUID_NULL)) {
-        av_log(NULL, loglevel, "No decoder device for codec found\n");
-        goto fail;
-    }
-
-    desc.SampleWidth  = s->coded_width;
-    desc.SampleHeight = s->coded_height;
-    desc.Format       = target_format;
-
-    ret = dxva2_get_decoder_configuration(s, &device_guid, &desc, &config);
-    if (ret < 0) {
-        goto fail;
-    }
-
-    /* decoding MPEG-2 requires additional alignment on some Intel GPUs,
-       but it causes issues for H.264 on certain AMD GPUs..... */
-    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO)
-        surface_alignment = 32;
-    /* the HEVC DXVA2 spec asks for 128 pixel aligned surfaces to ensure
-       all coding features have enough room to work with */
-    else if  (s->codec_id == AV_CODEC_ID_HEVC)
-        surface_alignment = 128;
-    else
-        surface_alignment = 16;
-
-    /* 4 base work surfaces */
-    num_surfaces = 4;
-
-    /* add surfaces based on number of possible refs */
-    if (s->codec_id == AV_CODEC_ID_H264 || s->codec_id == AV_CODEC_ID_HEVC)
-        num_surfaces += 16;
-    else if (s->codec_id == AV_CODEC_ID_VP9)
-        num_surfaces += 8;
-    else
-        num_surfaces += 2;
-
-    /* add extra surfaces for frame threading */
-    if (s->active_thread_type & FF_THREAD_FRAME)
-        num_surfaces += s->thread_count;
-
-    ctx->hw_frames_ctx = av_hwframe_ctx_alloc(ctx->hw_device_ctx);
-    if (!ctx->hw_frames_ctx)
-        goto fail;
-    frames_ctx   = (AVHWFramesContext*)ctx->hw_frames_ctx->data;
-    frames_hwctx = frames_ctx->hwctx;
-
-    frames_ctx->format            = AV_PIX_FMT_DXVA2_VLD;
-    frames_ctx->sw_format         = (target_format == MKTAG('P','0','1','0') ? AV_PIX_FMT_P010 : AV_PIX_FMT_NV12);
-    frames_ctx->width             = FFALIGN(s->coded_width, surface_alignment);
-    frames_ctx->height            = FFALIGN(s->coded_height, surface_alignment);
-    frames_ctx->initial_pool_size = num_surfaces;
-
-    frames_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;
-
-    ret = av_hwframe_ctx_init(ctx->hw_frames_ctx);
-    if (ret < 0) {
-        av_log(NULL, loglevel, "Failed to initialize the HW frames context\n");
-        goto fail;
-    }
-
-    hr = IDirectXVideoDecoderService_CreateVideoDecoder(ctx->decoder_service, &device_guid,
-                                                        &desc, &config, frames_hwctx->surfaces,
-                                                        frames_hwctx->nb_surfaces, &frames_hwctx->decoder_to_release);
-    if (FAILED(hr)) {
-        av_log(NULL, loglevel, "Failed to create DXVA2 video decoder\n");
-        goto fail;
-    }
-
-    ctx->decoder_guid   = device_guid;
-    ctx->decoder_config = config;
-
-    dxva_ctx->cfg           = &ctx->decoder_config;
-    dxva_ctx->decoder       = frames_hwctx->decoder_to_release;
-    dxva_ctx->surface       = frames_hwctx->surfaces;
-    dxva_ctx->surface_count = frames_hwctx->nb_surfaces;
-
-    if (IsEqualGUID(&ctx->decoder_guid, &DXVADDI_Intel_ModeH264_E))
-        dxva_ctx->workaround |= FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO;
-
-    return 0;
-fail:
-    av_buffer_unref(&ctx->hw_frames_ctx);
-    return AVERROR(EINVAL);
-}
-
-int dxva2_init(AVCodecContext *s)
-{
-    InputStream *ist = s->opaque;
-    int loglevel = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR;
-    DXVA2Context *ctx;
-    int ret;
-
-    if (!ist->hwaccel_ctx) {
-        ret = dxva2_alloc(s);
-        if (ret < 0)
-            return ret;
-    }
-    ctx = ist->hwaccel_ctx;
-
-    if (s->codec_id == AV_CODEC_ID_H264 &&
-        (s->profile & ~FF_PROFILE_H264_CONSTRAINED) > FF_PROFILE_H264_HIGH) {
-        av_log(NULL, loglevel, "Unsupported H.264 profile for DXVA2 HWAccel: %d\n", s->profile);
-        return AVERROR(EINVAL);
-    }
-
-    if (s->codec_id == AV_CODEC_ID_HEVC &&
-        s->profile != FF_PROFILE_HEVC_MAIN && s->profile != FF_PROFILE_HEVC_MAIN_10) {
-        av_log(NULL, loglevel, "Unsupported HEVC profile for DXVA2 HWAccel: %d\n", s->profile);
-        return AVERROR(EINVAL);
-    }
-
-    av_buffer_unref(&ctx->hw_frames_ctx);
-
-    ret = dxva2_create_decoder(s);
-    if (ret < 0) {
-        av_log(NULL, loglevel, "Error creating the DXVA2 decoder\n");
-        return ret;
-    }
-
-    return 0;
-}
diff --git a/mythtv/external/FFmpeg/fftools/ffmpeg_filter.c b/mythtv/external/FFmpeg/fftools/ffmpeg_filter.c
index 27aeca0822a..aacc185059e 100644
--- a/mythtv/external/FFmpeg/fftools/ffmpeg_filter.c
+++ b/mythtv/external/FFmpeg/fftools/ffmpeg_filter.c
@@ -111,16 +111,16 @@ void choose_sample_fmt(AVStream *st, AVCodec *codec)
     }
 }
 
-static char *choose_pix_fmts(OutputStream *ost)
+static char *choose_pix_fmts(OutputFilter *ofilter)
 {
+    OutputStream *ost = ofilter->ost;
     AVDictionaryEntry *strict_dict = av_dict_get(ost->encoder_opts, "strict", NULL, 0);
     if (strict_dict)
         // used by choose_pixel_fmt() and below
         av_opt_set(ost->enc_ctx, "strict", strict_dict->value, 0);
 
      if (ost->keep_pix_fmt) {
-        if (ost->filter)
-            avfilter_graph_set_auto_convert(ost->filter->graph->graph,
+        avfilter_graph_set_auto_convert(ofilter->graph->graph,
                                             AVFILTER_AUTO_CONVERT_NONE);
         if (ost->enc_ctx->pix_fmt == AV_PIX_FMT_NONE)
             return NULL;
@@ -155,13 +155,13 @@ static char *choose_pix_fmts(OutputStream *ost)
 
 /* Define a function for building a string containing a list of
  * allowed formats. */
-#define DEF_CHOOSE_FORMAT(type, var, supported_list, none, get_name)           \
-static char *choose_ ## var ## s(OutputStream *ost)                            \
+#define DEF_CHOOSE_FORMAT(suffix, type, var, supported_list, none, get_name)   \
+static char *choose_ ## suffix (OutputFilter *ofilter)                         \
 {                                                                              \
-    if (ost->enc_ctx->var != none) {                                           \
-        get_name(ost->enc_ctx->var);                                           \
+    if (ofilter->var != none) {                                                \
+        get_name(ofilter->var);                                                \
         return av_strdup(name);                                                \
-    } else if (ost->enc && ost->enc->supported_list) {                         \
+    } else if (ofilter->supported_list) {                                      \
         const type *p;                                                         \
         AVIOContext *s = NULL;                                                 \
         uint8_t *ret;                                                          \
@@ -170,7 +170,7 @@ static char *choose_ ## var ## s(OutputStream *ost)                            \
         if (avio_open_dyn_buf(&s) < 0)                                         \
             exit_program(1);                                                           \
                                                                                \
-        for (p = ost->enc->supported_list; *p != none; p++) {                  \
+        for (p = ofilter->supported_list; *p != none; p++) {                   \
             get_name(*p);                                                      \
             avio_printf(s, "%s|", name);                                       \
         }                                                                      \
@@ -181,16 +181,16 @@ static char *choose_ ## var ## s(OutputStream *ost)                            \
         return NULL;                                                           \
 }
 
-// DEF_CHOOSE_FORMAT(enum AVPixelFormat, pix_fmt, pix_fmts, AV_PIX_FMT_NONE,
-//                   GET_PIX_FMT_NAME)
+//DEF_CHOOSE_FORMAT(pix_fmts, enum AVPixelFormat, format, formats, AV_PIX_FMT_NONE,
+//                  GET_PIX_FMT_NAME)
 
-DEF_CHOOSE_FORMAT(enum AVSampleFormat, sample_fmt, sample_fmts,
+DEF_CHOOSE_FORMAT(sample_fmts, enum AVSampleFormat, format, formats,
                   AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME)
 
-DEF_CHOOSE_FORMAT(int, sample_rate, supported_samplerates, 0,
+DEF_CHOOSE_FORMAT(sample_rates, int, sample_rate, sample_rates, 0,
                   GET_SAMPLE_RATE_NAME)
 
-DEF_CHOOSE_FORMAT(uint64_t, channel_layout, channel_layouts, 0,
+DEF_CHOOSE_FORMAT(channel_layouts, uint64_t, channel_layout, channel_layouts, 0,
                   GET_CH_LAYOUT_NAME)
 
 int init_simple_filtergraph(InputStream *ist, OutputStream *ost)
@@ -206,6 +206,7 @@ int init_simple_filtergraph(InputStream *ist, OutputStream *ost)
         exit_program(1);
     fg->outputs[0]->ost   = ost;
     fg->outputs[0]->graph = fg;
+    fg->outputs[0]->format = -1;
 
     ost->filter = fg->outputs[0];
 
@@ -214,6 +215,11 @@ int init_simple_filtergraph(InputStream *ist, OutputStream *ost)
         exit_program(1);
     fg->inputs[0]->ist   = ist;
     fg->inputs[0]->graph = fg;
+    fg->inputs[0]->format = -1;
+
+    fg->inputs[0]->frame_queue = av_fifo_alloc(8 * sizeof(AVFrame*));
+    if (!fg->inputs[0]->frame_queue)
+        exit_program(1);
 
     GROW_ARRAY(ist->filters, ist->nb_filters);
     ist->filters[ist->nb_filters - 1] = fg->inputs[0];
@@ -224,6 +230,25 @@ int init_simple_filtergraph(InputStream *ist, OutputStream *ost)
     return 0;
 }
 
+static char *describe_filter_link(FilterGraph *fg, AVFilterInOut *inout, int in)
+{
+    AVFilterContext *ctx = inout->filter_ctx;
+    AVFilterPad *pads = in ? ctx->input_pads  : ctx->output_pads;
+    int       nb_pads = in ? ctx->nb_inputs   : ctx->nb_outputs;
+    AVIOContext *pb;
+    uint8_t *res = NULL;
+
+    if (avio_open_dyn_buf(&pb) < 0)
+        exit_program(1);
+
+    avio_printf(pb, "%s", ctx->filter->name);
+    if (nb_pads > 1)
+        avio_printf(pb, ":%s", avfilter_pad_get_name(pads, inout->pad_idx));
+    avio_w8(pb, 0);
+    avio_close_dyn_buf(pb, &res);
+    return res;
+}
+
 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
 {
     InputStream *ist = NULL;
@@ -292,6 +317,13 @@ static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
         exit_program(1);
     fg->inputs[fg->nb_inputs - 1]->ist   = ist;
     fg->inputs[fg->nb_inputs - 1]->graph = fg;
+    fg->inputs[fg->nb_inputs - 1]->format = -1;
+    fg->inputs[fg->nb_inputs - 1]->type = ist->st->codecpar->codec_type;
+    fg->inputs[fg->nb_inputs - 1]->name = describe_filter_link(fg, in, 1);
+
+    fg->inputs[fg->nb_inputs - 1]->frame_queue = av_fifo_alloc(8 * sizeof(AVFrame*));
+    if (!fg->inputs[fg->nb_inputs - 1]->frame_queue)
+        exit_program(1);
 
     GROW_ARRAY(ist->filters, ist->nb_filters);
     ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
@@ -326,6 +358,7 @@ int init_complex_filtergraph(FilterGraph *fg)
         fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
         fg->outputs[fg->nb_outputs - 1]->type    = avfilter_pad_get_type(cur->filter_ctx->output_pads,
                                                                          cur->pad_idx);
+        fg->outputs[fg->nb_outputs - 1]->name = describe_filter_link(fg, cur, 0);
         cur = cur->next;
         fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
     }
@@ -414,13 +447,12 @@ static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter,
     char *pix_fmts;
     OutputStream *ost = ofilter->ost;
     OutputFile    *of = output_files[ost->file_index];
-    AVCodecContext *codec = ost->enc_ctx;
     AVFilterContext *last_filter = out->filter_ctx;
     int pad_idx = out->pad_idx;
     int ret;
     char name[255];
 
-    snprintf(name, sizeof(name), "output stream %d:%d", ost->file_index, ost->index);
+    snprintf(name, sizeof(name), "out_%d_%d", ost->file_index, ost->index);
     ret = avfilter_graph_create_filter(&ofilter->filter,
                                        avfilter_get_by_name("buffersink"),
                                        name, NULL, NULL, fg->graph);
@@ -428,21 +460,20 @@ static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter,
     if (ret < 0)
         return ret;
 
-    if (!hw_device_ctx && (codec->width || codec->height)) {
+    if (ofilter->width || ofilter->height) {
         char args[255];
         AVFilterContext *filter;
         AVDictionaryEntry *e = NULL;
 
         snprintf(args, sizeof(args), "%d:%d",
-                 codec->width,
-                 codec->height);
+                 ofilter->width, ofilter->height);
 
         while ((e = av_dict_get(ost->sws_dict, "", e,
                                 AV_DICT_IGNORE_SUFFIX))) {
             av_strlcatf(args, sizeof(args), ":%s=%s", e->key, e->value);
         }
 
-        snprintf(name, sizeof(name), "scaler for output stream %d:%d",
+        snprintf(name, sizeof(name), "scaler_out_%d_%d",
                  ost->file_index, ost->index);
         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
                                                 name, args, NULL, fg->graph)) < 0)
@@ -454,9 +485,9 @@ static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter,
         pad_idx = 0;
     }
 
-    if ((pix_fmts = choose_pix_fmts(ost))) {
+    if ((pix_fmts = choose_pix_fmts(ofilter))) {
         AVFilterContext *filter;
-        snprintf(name, sizeof(name), "pixel format for output stream %d:%d",
+        snprintf(name, sizeof(name), "format_out_%d_%d",
                  ost->file_index, ost->index);
         ret = avfilter_graph_create_filter(&filter,
                                            avfilter_get_by_name("format"),
@@ -477,7 +508,7 @@ static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter,
 
         snprintf(args, sizeof(args), "fps=%d/%d", ost->frame_rate.num,
                  ost->frame_rate.den);
-        snprintf(name, sizeof(name), "fps for output stream %d:%d",
+        snprintf(name, sizeof(name), "fps_out_%d_%d",
                  ost->file_index, ost->index);
         ret = avfilter_graph_create_filter(&fps, avfilter_get_by_name("fps"),
                                            name, args, NULL, fg->graph);
@@ -491,7 +522,7 @@ static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter,
         pad_idx = 0;
     }
 
-    snprintf(name, sizeof(name), "trim for output stream %d:%d",
+    snprintf(name, sizeof(name), "trim_out_%d_%d",
              ost->file_index, ost->index);
     ret = insert_trim(of->start_time, of->recording_time,
                       &last_filter, &pad_idx, name);
@@ -516,7 +547,7 @@ static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter,
     char name[255];
     int ret;
 
-    snprintf(name, sizeof(name), "output stream %d:%d", ost->file_index, ost->index);
+    snprintf(name, sizeof(name), "out_%d_%d", ost->file_index, ost->index);
     ret = avfilter_graph_create_filter(&ofilter->filter,
                                        avfilter_get_by_name("abuffersink"),
                                        name, NULL, NULL, fg->graph);
@@ -561,9 +592,9 @@ static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter,
     if (codec->channels && !codec->channel_layout)
         codec->channel_layout = av_get_default_channel_layout(codec->channels);
 
-    sample_fmts     = choose_sample_fmts(ost);
-    sample_rates    = choose_sample_rates(ost);
-    channel_layouts = choose_channel_layouts(ost);
+    sample_fmts     = choose_sample_fmts(ofilter);
+    sample_rates    = choose_sample_rates(ofilter);
+    channel_layouts = choose_channel_layouts(ofilter);
     if (sample_fmts || sample_rates || channel_layouts) {
         AVFilterContext *format;
         char args[256];
@@ -583,7 +614,7 @@ static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter,
         av_freep(&sample_rates);
         av_freep(&channel_layouts);
 
-        snprintf(name, sizeof(name), "audio format for output stream %d:%d",
+        snprintf(name, sizeof(name), "format_out_%d_%d",
                  ost->file_index, ost->index);
         ret = avfilter_graph_create_filter(&format,
                                            avfilter_get_by_name("aformat"),
@@ -633,28 +664,8 @@ static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter,
     return 0;
 }
 
-#define DESCRIBE_FILTER_LINK(f, inout, in)                         \
-{                                                                  \
-    AVFilterContext *ctx = inout->filter_ctx;                      \
-    AVFilterPad *pads = in ? ctx->input_pads  : ctx->output_pads;  \
-    int       nb_pads = in ? ctx->nb_inputs   : ctx->nb_outputs;   \
-    AVIOContext *pb;                                               \
-                                                                   \
-    if (avio_open_dyn_buf(&pb) < 0)                                \
-        exit_program(1);                                           \
-                                                                   \
-    avio_printf(pb, "%s", ctx->filter->name);                      \
-    if (nb_pads > 1)                                               \
-        avio_printf(pb, ":%s", avfilter_pad_get_name(pads, inout->pad_idx));\
-    avio_w8(pb, 0);                                                \
-    avio_close_dyn_buf(pb, &f->name);                              \
-}
-
 int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
 {
-    av_freep(&ofilter->name);
-    DESCRIBE_FILTER_LINK(ofilter, out, 0);
-
     if (!ofilter->ost) {
         av_log(NULL, AV_LOG_FATAL, "Filter %s has an unconnected output\n", ofilter->name);
         exit_program(1);
@@ -667,7 +678,22 @@ int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOu
     }
 }
 
-static int sub2video_prepare(InputStream *ist)
+void check_filter_outputs(void)
+{
+    int i;
+    for (i = 0; i < nb_filtergraphs; i++) {
+        int n;
+        for (n = 0; n < filtergraphs[i]->nb_outputs; n++) {
+            OutputFilter *output = filtergraphs[i]->outputs[n];
+            if (!output->ost) {
+                av_log(NULL, AV_LOG_FATAL, "Filter %s has an unconnected output\n", output->name);
+                exit_program(1);
+            }
+        }
+    }
+}
+
+static int sub2video_prepare(InputStream *ist, InputFilter *ifilter)
 {
     AVFormatContext *avf = input_files[ist->file_index]->ctx;
     int i, w, h;
@@ -675,8 +701,8 @@ static int sub2video_prepare(InputStream *ist)
     /* Compute the size of the canvas for the subtitles stream.
        If the subtitles codecpar has set a size, use it. Otherwise use the
        maximum dimensions of the video streams in the same file. */
-    w = ist->dec_ctx->width;
-    h = ist->dec_ctx->height;
+    w = ifilter->width;
+    h = ifilter->height;
     if (!(w && h)) {
         for (i = 0; i < avf->nb_streams; i++) {
             if (avf->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
@@ -690,12 +716,15 @@ static int sub2video_prepare(InputStream *ist)
         }
         av_log(avf, AV_LOG_INFO, "sub2video: using %dx%d canvas\n", w, h);
     }
-    ist->sub2video.w = ist->resample_width  = w;
-    ist->sub2video.h = ist->resample_height = h;
+    ist->sub2video.w = ifilter->width  = w;
+    ist->sub2video.h = ifilter->height = h;
+
+    ifilter->width  = ist->dec_ctx->width  ? ist->dec_ctx->width  : ist->sub2video.w;
+    ifilter->height = ist->dec_ctx->height ? ist->dec_ctx->height : ist->sub2video.h;
 
     /* rectangles are AV_PIX_FMT_PAL8, but we have no guarantee that the
        palettes for all rectangles are identical or compatible */
-    ist->resample_pix_fmt = ist->dec_ctx->pix_fmt = AV_PIX_FMT_RGB32;
+    ifilter->format = AV_PIX_FMT_RGB32;
 
     ist->sub2video.frame = av_frame_alloc();
     if (!ist->sub2video.frame)
@@ -736,22 +765,19 @@ static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
         fr = av_guess_frame_rate(input_files[ist->file_index]->ctx, ist->st, NULL);
 
     if (ist->dec_ctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
-        ret = sub2video_prepare(ist);
+        ret = sub2video_prepare(ist, ifilter);
         if (ret < 0)
             goto fail;
     }
 
-    sar = ist->st->sample_aspect_ratio.num ?
-          ist->st->sample_aspect_ratio :
-          ist->dec_ctx->sample_aspect_ratio;
+    sar = ifilter->sample_aspect_ratio;
     if(!sar.den)
         sar = (AVRational){0,1};
     av_bprint_init(&args, 0, 1);
     av_bprintf(&args,
              "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:"
-             "pixel_aspect=%d/%d:sws_param=flags=%d", ist->resample_width,
-             ist->resample_height,
-             ist->hwaccel_retrieve_data ? ist->hwaccel_retrieved_pix_fmt : ist->resample_pix_fmt,
+             "pixel_aspect=%d/%d:sws_param=flags=%d",
+             ifilter->width, ifilter->height, ifilter->format,
              tb.num, tb.den, sar.num, sar.den,
              SWS_BILINEAR + ((ist->dec_ctx->flags&AV_CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
     if (fr.num && fr.den)
@@ -763,7 +789,7 @@ static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
     if ((ret = avfilter_graph_create_filter(&ifilter->filter, buffer_filt, name,
                                             args.str, NULL, fg->graph)) < 0)
         goto fail;
-    par->hw_frames_ctx = ist->hw_frames_ctx;
+    par->hw_frames_ctx = ifilter->hw_frames_ctx;
     ret = av_buffersrc_parameters_set(ifilter->filter, par);
     if (ret < 0)
         goto fail;
@@ -791,27 +817,10 @@ static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
             return ret;
     }
 
-    if (ist->framerate.num) {
-        AVFilterContext *setpts;
-
-        snprintf(name, sizeof(name), "force CFR for input from stream %d:%d",
-                 ist->file_index, ist->st->index);
-        if ((ret = avfilter_graph_create_filter(&setpts,
-                                                avfilter_get_by_name("setpts"),
-                                                name, "N", NULL,
-                                                fg->graph)) < 0)
-            return ret;
-
-        if ((ret = avfilter_link(last_filter, 0, setpts, 0)) < 0)
-            return ret;
-
-        last_filter = setpts;
-    }
-
     if (do_deinterlace) {
         AVFilterContext *yadif;
 
-        snprintf(name, sizeof(name), "deinterlace input from stream %d:%d",
+        snprintf(name, sizeof(name), "deinterlace_in_%d_%d",
                  ist->file_index, ist->st->index);
         if ((ret = avfilter_graph_create_filter(&yadif,
                                                 avfilter_get_by_name("yadif"),
@@ -825,7 +834,7 @@ static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
         last_filter = yadif;
     }
 
-    snprintf(name, sizeof(name), "trim for input stream %d:%d",
+    snprintf(name, sizeof(name), "trim_in_%d_%d",
              ist->file_index, ist->st->index);
     if (copy_ts) {
         tsoffset = f->start_time == AV_NOPTS_VALUE ? 0 : f->start_time;
@@ -866,15 +875,15 @@ static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter,
 
     av_bprint_init(&args, 0, AV_BPRINT_SIZE_AUTOMATIC);
     av_bprintf(&args, "time_base=%d/%d:sample_rate=%d:sample_fmt=%s",
-             1, ist->dec_ctx->sample_rate,
-             ist->dec_ctx->sample_rate,
-             av_get_sample_fmt_name(ist->dec_ctx->sample_fmt));
-    if (ist->dec_ctx->channel_layout)
+             1, ifilter->sample_rate,
+             ifilter->sample_rate,
+             av_get_sample_fmt_name(ifilter->format));
+    if (ifilter->channel_layout)
         av_bprintf(&args, ":channel_layout=0x%"PRIx64,
-                   ist->dec_ctx->channel_layout);
+                   ifilter->channel_layout);
     else
-        av_bprintf(&args, ":channels=%d", ist->dec_ctx->channels);
-    snprintf(name, sizeof(name), "graph %d input from stream %d:%d", fg->index,
+        av_bprintf(&args, ":channels=%d", ifilter->channels);
+    snprintf(name, sizeof(name), "graph_%d_in_%d_%d", fg->index,
              ist->file_index, ist->st->index);
 
     if ((ret = avfilter_graph_create_filter(&ifilter->filter, abuffer_filt,
@@ -889,7 +898,7 @@ static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter,
     av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi "            \
            "similarly to -af " filter_name "=%s.\n", arg);                  \
                                                                             \
-    snprintf(name, sizeof(name), "graph %d %s for input stream %d:%d",      \
+    snprintf(name, sizeof(name), "graph_%d_%s_in_%d_%d",      \
                 fg->index, filter_name, ist->file_index, ist->st->index);   \
     ret = avfilter_graph_create_filter(&filt_ctx,                           \
                                        avfilter_get_by_name(filter_name),   \
@@ -960,9 +969,6 @@ static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter,
 static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter,
                                   AVFilterInOut *in)
 {
-    av_freep(&ifilter->name);
-    DESCRIBE_FILTER_LINK(ifilter, in, 1);
-
     if (!ifilter->ist->dec) {
         av_log(NULL, AV_LOG_ERROR,
                "No decoder for stream #%d:%d, filtering impossible\n",
@@ -976,6 +982,16 @@ static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter,
     }
 }
 
+static void cleanup_filtergraph(FilterGraph *fg)
+{
+    int i;
+    for (i = 0; i < fg->nb_outputs; i++)
+        fg->outputs[i]->filter = (AVFilterContext *)NULL;
+    for (i = 0; i < fg->nb_inputs; i++)
+        fg->inputs[i]->filter = (AVFilterContext *)NULL;
+    avfilter_graph_free(&fg->graph);
+}
+
 int configure_filtergraph(FilterGraph *fg)
 {
     AVFilterInOut *inputs, *outputs, *cur;
@@ -983,7 +999,7 @@ int configure_filtergraph(FilterGraph *fg)
     const char *graph_desc = simple ? fg->outputs[0]->ost->avfilter :
                                       fg->graph_desc;
 
-    avfilter_graph_free(&fg->graph);
+    cleanup_filtergraph(fg);
     if (!(fg->graph = avfilter_graph_alloc()))
         return AVERROR(ENOMEM);
 
@@ -992,6 +1008,8 @@ int configure_filtergraph(FilterGraph *fg)
         char args[512];
         AVDictionaryEntry *e = NULL;
 
+        fg->graph->nb_threads = filter_nbthreads;
+
         args[0] = 0;
         while ((e = av_dict_get(ost->sws_dict, "", e,
                                 AV_DICT_IGNORE_SUFFIX))) {
@@ -1017,19 +1035,26 @@ int configure_filtergraph(FilterGraph *fg)
         }
         if (strlen(args))
             args[strlen(args) - 1] = '\0';
-        fg->graph->resample_lavr_opts = av_strdup(args);
 
         e = av_dict_get(ost->encoder_opts, "threads", NULL, 0);
         if (e)
             av_opt_set(fg->graph, "threads", e->value, 0);
+    } else {
+        fg->graph->nb_threads = filter_complex_nbthreads;
     }
 
     if ((ret = avfilter_graph_parse2(fg->graph, graph_desc, &inputs, &outputs)) < 0)
-        return ret;
+        goto fail;
 
-    if (hw_device_ctx) {
+    if (filter_hw_device || hw_device_ctx) {
+        AVBufferRef *device = filter_hw_device ? filter_hw_device->device_ref
+                                               : hw_device_ctx;
         for (i = 0; i < fg->graph->nb_filters; i++) {
-            fg->graph->filters[i]->hw_device_ctx = av_buffer_ref(hw_device_ctx);
+            fg->graph->filters[i]->hw_device_ctx = av_buffer_ref(device);
+            if (!fg->graph->filters[i]->hw_device_ctx) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
         }
     }
 
@@ -1055,14 +1080,15 @@ int configure_filtergraph(FilterGraph *fg)
                " However, it had %s input(s) and %s output(s)."
                " Please adjust, or use a complex filtergraph (-filter_complex) instead.\n",
                graph_desc, num_inputs, num_outputs);
-        return AVERROR(EINVAL);
+        ret = AVERROR(EINVAL);
+        goto fail;
     }
 
     for (cur = inputs, i = 0; cur; cur = cur->next, i++)
         if ((ret = configure_input_filter(fg, fg->inputs[i], cur)) < 0) {
             avfilter_inout_free(&inputs);
             avfilter_inout_free(&outputs);
-            return ret;
+            goto fail;
         }
     avfilter_inout_free(&inputs);
 
@@ -1071,7 +1097,22 @@ int configure_filtergraph(FilterGraph *fg)
     avfilter_inout_free(&outputs);
 
     if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
-        return ret;
+        goto fail;
+
+    /* limit the lists of allowed formats to the ones selected, to
+     * make sure they stay the same if the filtergraph is reconfigured later */
+    for (i = 0; i < fg->nb_outputs; i++) {
+        OutputFilter *ofilter = fg->outputs[i];
+        AVFilterContext *sink = ofilter->filter;
+
+        ofilter->format = av_buffersink_get_format(sink);
+
+        ofilter->width  = av_buffersink_get_w(sink);
+        ofilter->height = av_buffersink_get_h(sink);
+
+        ofilter->sample_rate    = av_buffersink_get_sample_rate(sink);
+        ofilter->channel_layout = av_buffersink_get_channel_layout(sink);
+    }
 
     fg->reconfiguration = 1;
 
@@ -1082,7 +1123,8 @@ int configure_filtergraph(FilterGraph *fg)
                complex filter graphs are initialized earlier */
             av_log(NULL, AV_LOG_ERROR, "Encoder (codec %s) not found for output stream #%d:%d\n",
                      avcodec_get_name(ost->st->codecpar->codec_id), ost->file_index, ost->index);
-            return AVERROR(EINVAL);
+            ret = AVERROR(EINVAL);
+            goto fail;
         }
         if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
             !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
@@ -1090,6 +1132,66 @@ int configure_filtergraph(FilterGraph *fg)
                                          ost->enc_ctx->frame_size);
     }
 
+    for (i = 0; i < fg->nb_inputs; i++) {
+        while (av_fifo_size(fg->inputs[i]->frame_queue)) {
+            AVFrame *tmp;
+            av_fifo_generic_read(fg->inputs[i]->frame_queue, &tmp, sizeof(tmp), NULL);
+            ret = av_buffersrc_add_frame(fg->inputs[i]->filter, tmp);
+            av_frame_free(&tmp);
+            if (ret < 0)
+                goto fail;
+        }
+    }
+
+    /* send the EOFs for the finished inputs */
+    for (i = 0; i < fg->nb_inputs; i++) {
+        if (fg->inputs[i]->eof) {
+            ret = av_buffersrc_add_frame(fg->inputs[i]->filter, NULL);
+            if (ret < 0)
+                goto fail;
+        }
+    }
+
+    /* process queued up subtitle packets */
+    for (i = 0; i < fg->nb_inputs; i++) {
+        InputStream *ist = fg->inputs[i]->ist;
+        if (ist->sub2video.sub_queue && ist->sub2video.frame) {
+            while (av_fifo_size(ist->sub2video.sub_queue)) {
+                AVSubtitle tmp;
+                av_fifo_generic_read(ist->sub2video.sub_queue, &tmp, sizeof(tmp), NULL);
+                sub2video_update(ist, &tmp);
+                avsubtitle_free(&tmp);
+            }
+        }
+    }
+
+    return 0;
+
+fail:
+    cleanup_filtergraph(fg);
+    return ret;
+}
+
+int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame)
+{
+    av_buffer_unref(&ifilter->hw_frames_ctx);
+
+    ifilter->format = frame->format;
+
+    ifilter->width               = frame->width;
+    ifilter->height              = frame->height;
+    ifilter->sample_aspect_ratio = frame->sample_aspect_ratio;
+
+    ifilter->sample_rate         = frame->sample_rate;
+    ifilter->channels            = frame->channels;
+    ifilter->channel_layout      = frame->channel_layout;
+
+    if (frame->hw_frames_ctx) {
+        ifilter->hw_frames_ctx = av_buffer_ref(frame->hw_frames_ctx);
+        if (!ifilter->hw_frames_ctx)
+            return AVERROR(ENOMEM);
+    }
+
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/fftools/ffmpeg_hw.c b/mythtv/external/FFmpeg/fftools/ffmpeg_hw.c
new file mode 100644
index 00000000000..a4d1cada591
--- /dev/null
+++ b/mythtv/external/FFmpeg/fftools/ffmpeg_hw.c
@@ -0,0 +1,385 @@
+/*
+ * 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 <string.h>
+
+#include "libavutil/avstring.h"
+
+#include "ffmpeg.h"
+
+static int nb_hw_devices;
+static HWDevice **hw_devices;
+
+static HWDevice *hw_device_get_by_type(enum AVHWDeviceType type)
+{
+    HWDevice *found = NULL;
+    int i;
+    for (i = 0; i < nb_hw_devices; i++) {
+        if (hw_devices[i]->type == type) {
+            if (found)
+                return NULL;
+            found = hw_devices[i];
+        }
+    }
+    return found;
+}
+
+HWDevice *hw_device_get_by_name(const char *name)
+{
+    int i;
+    for (i = 0; i < nb_hw_devices; i++) {
+        if (!strcmp(hw_devices[i]->name, name))
+            return hw_devices[i];
+    }
+    return NULL;
+}
+
+static HWDevice *hw_device_add(void)
+{
+    int err;
+    err = av_reallocp_array(&hw_devices, nb_hw_devices + 1,
+                            sizeof(*hw_devices));
+    if (err) {
+        nb_hw_devices = 0;
+        return NULL;
+    }
+    hw_devices[nb_hw_devices] = av_mallocz(sizeof(HWDevice));
+    if (!hw_devices[nb_hw_devices])
+        return NULL;
+    return hw_devices[nb_hw_devices++];
+}
+
+int hw_device_init_from_string(const char *arg, HWDevice **dev_out)
+{
+    // "type=name:device,key=value,key2=value2"
+    // "type:device,key=value,key2=value2"
+    // -> av_hwdevice_ctx_create()
+    // "type=name@name"
+    // "type@name"
+    // -> av_hwdevice_ctx_create_derived()
+
+    AVDictionary *options = NULL;
+    char *type_name = NULL, *name = NULL, *device = NULL;
+    enum AVHWDeviceType type;
+    HWDevice *dev, *src;
+    AVBufferRef *device_ref = NULL;
+    int err;
+    const char *errmsg, *p, *q;
+    size_t k;
+
+    k = strcspn(arg, ":=@");
+    p = arg + k;
+
+    type_name = av_strndup(arg, k);
+    if (!type_name) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+    type = av_hwdevice_find_type_by_name(type_name);
+    if (type == AV_HWDEVICE_TYPE_NONE) {
+        errmsg = "unknown device type";
+        goto invalid;
+    }
+
+    if (*p == '=') {
+        k = strcspn(p + 1, ":@");
+
+        name = av_strndup(p + 1, k);
+        if (!name) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+        if (hw_device_get_by_name(name)) {
+            errmsg = "named device already exists";
+            goto invalid;
+        }
+
+        p += 1 + k;
+    } else {
+        // Give the device an automatic name of the form "type%d".
+        // We arbitrarily limit at 1000 anonymous devices of the same
+        // type - there is probably something else very wrong if you
+        // get to this limit.
+        size_t index_pos;
+        int index, index_limit = 1000;
+        index_pos = strlen(type_name);
+        name = av_malloc(index_pos + 4);
+        if (!name) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+        for (index = 0; index < index_limit; index++) {
+            snprintf(name, index_pos + 4, "%s%d", type_name, index);
+            if (!hw_device_get_by_name(name))
+                break;
+        }
+        if (index >= index_limit) {
+            errmsg = "too many devices";
+            goto invalid;
+        }
+    }
+
+    if (!*p) {
+        // New device with no parameters.
+        err = av_hwdevice_ctx_create(&device_ref, type,
+                                     NULL, NULL, 0);
+        if (err < 0)
+            goto fail;
+
+    } else if (*p == ':') {
+        // New device with some parameters.
+        ++p;
+        q = strchr(p, ',');
+        if (q) {
+            device = av_strndup(p, q - p);
+            if (!device) {
+                err = AVERROR(ENOMEM);
+                goto fail;
+            }
+            err = av_dict_parse_string(&options, q + 1, "=", ",", 0);
+            if (err < 0) {
+                errmsg = "failed to parse options";
+                goto invalid;
+            }
+        }
+
+        err = av_hwdevice_ctx_create(&device_ref, type,
+                                     device ? device : p, options, 0);
+        if (err < 0)
+            goto fail;
+
+    } else if (*p == '@') {
+        // Derive from existing device.
+
+        src = hw_device_get_by_name(p + 1);
+        if (!src) {
+            errmsg = "invalid source device name";
+            goto invalid;
+        }
+
+        err = av_hwdevice_ctx_create_derived(&device_ref, type,
+                                             src->device_ref, 0);
+        if (err < 0)
+            goto fail;
+    } else {
+        errmsg = "parse error";
+        goto invalid;
+    }
+
+    dev = hw_device_add();
+    if (!dev) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    dev->name = name;
+    dev->type = type;
+    dev->device_ref = device_ref;
+
+    if (dev_out)
+        *dev_out = dev;
+
+    name = NULL;
+    err = 0;
+done:
+    av_freep(&type_name);
+    av_freep(&name);
+    av_freep(&device);
+    av_dict_free(&options);
+    return err;
+invalid:
+    av_log(NULL, AV_LOG_ERROR,
+           "Invalid device specification \"%s\": %s\n", arg, errmsg);
+    err = AVERROR(EINVAL);
+    goto done;
+fail:
+    av_log(NULL, AV_LOG_ERROR,
+           "Device creation failed: %d.\n", err);
+    av_buffer_unref(&device_ref);
+    goto done;
+}
+
+void hw_device_free_all(void)
+{
+    int i;
+    for (i = 0; i < nb_hw_devices; i++) {
+        av_freep(&hw_devices[i]->name);
+        av_buffer_unref(&hw_devices[i]->device_ref);
+        av_freep(&hw_devices[i]);
+    }
+    av_freep(&hw_devices);
+    nb_hw_devices = 0;
+}
+
+static enum AVHWDeviceType hw_device_match_type_by_hwaccel(enum HWAccelID hwaccel_id)
+{
+    int i;
+    if (hwaccel_id == HWACCEL_NONE)
+        return AV_HWDEVICE_TYPE_NONE;
+    for (i = 0; hwaccels[i].name; i++) {
+        if (hwaccels[i].id == hwaccel_id)
+            return hwaccels[i].device_type;
+    }
+    return AV_HWDEVICE_TYPE_NONE;
+}
+
+static enum AVHWDeviceType hw_device_match_type_in_name(const char *codec_name)
+{
+    const char *type_name;
+    enum AVHWDeviceType type;
+    for (type = av_hwdevice_iterate_types(AV_HWDEVICE_TYPE_NONE);
+         type != AV_HWDEVICE_TYPE_NONE;
+         type = av_hwdevice_iterate_types(type)) {
+        type_name = av_hwdevice_get_type_name(type);
+        if (strstr(codec_name, type_name))
+            return type;
+    }
+    return AV_HWDEVICE_TYPE_NONE;
+}
+
+int hw_device_setup_for_decode(InputStream *ist)
+{
+    enum AVHWDeviceType type;
+    HWDevice *dev;
+    int err;
+
+    if (ist->hwaccel_device) {
+        dev = hw_device_get_by_name(ist->hwaccel_device);
+        if (!dev) {
+            char *tmp;
+            type = hw_device_match_type_by_hwaccel(ist->hwaccel_id);
+            if (type == AV_HWDEVICE_TYPE_NONE) {
+                // No match - this isn't necessarily invalid, though,
+                // because an explicit device might not be needed or
+                // the hwaccel setup could be handled elsewhere.
+                return 0;
+            }
+            tmp = av_asprintf("%s:%s", av_hwdevice_get_type_name(type),
+                              ist->hwaccel_device);
+            if (!tmp)
+                return AVERROR(ENOMEM);
+            err = hw_device_init_from_string(tmp, &dev);
+            av_free(tmp);
+            if (err < 0)
+                return err;
+        }
+    } else {
+        if (ist->hwaccel_id != HWACCEL_NONE)
+            type = hw_device_match_type_by_hwaccel(ist->hwaccel_id);
+        else
+            type = hw_device_match_type_in_name(ist->dec->name);
+        if (type != AV_HWDEVICE_TYPE_NONE) {
+            dev = hw_device_get_by_type(type);
+            if (!dev) {
+                hw_device_init_from_string(av_hwdevice_get_type_name(type),
+                                           &dev);
+            }
+        } else {
+            // No device required.
+            return 0;
+        }
+    }
+
+    if (!dev) {
+        av_log(ist->dec_ctx, AV_LOG_WARNING, "No device available "
+               "for decoder (device type %s for codec %s).\n",
+               av_hwdevice_get_type_name(type), ist->dec->name);
+        return 0;
+    }
+
+    ist->dec_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
+    if (!ist->dec_ctx->hw_device_ctx)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+int hw_device_setup_for_encode(OutputStream *ost)
+{
+    enum AVHWDeviceType type;
+    HWDevice *dev;
+
+    type = hw_device_match_type_in_name(ost->enc->name);
+    if (type != AV_HWDEVICE_TYPE_NONE) {
+        dev = hw_device_get_by_type(type);
+        if (!dev) {
+            av_log(ost->enc_ctx, AV_LOG_WARNING, "No device available "
+                   "for encoder (device type %s for codec %s).\n",
+                   av_hwdevice_get_type_name(type), ost->enc->name);
+            return 0;
+        }
+        ost->enc_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
+        if (!ost->enc_ctx->hw_device_ctx)
+            return AVERROR(ENOMEM);
+        return 0;
+    } else {
+        // No device required.
+        return 0;
+    }
+}
+
+static int hwaccel_retrieve_data(AVCodecContext *avctx, AVFrame *input)
+{
+    InputStream *ist = avctx->opaque;
+    AVFrame *output = NULL;
+    enum AVPixelFormat output_format = ist->hwaccel_output_format;
+    int err;
+
+    if (input->format == output_format) {
+        // Nothing to do.
+        return 0;
+    }
+
+    output = av_frame_alloc();
+    if (!output)
+        return AVERROR(ENOMEM);
+
+    output->format = output_format;
+
+    err = av_hwframe_transfer_data(output, input, 0);
+    if (err < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to transfer data to "
+               "output frame: %d.\n", err);
+        goto fail;
+    }
+
+    err = av_frame_copy_props(output, input);
+    if (err < 0) {
+        av_frame_unref(output);
+        goto fail;
+    }
+
+    av_frame_unref(input);
+    av_frame_move_ref(input, output);
+    av_frame_free(&output);
+
+    return 0;
+
+fail:
+    av_frame_free(&output);
+    return err;
+}
+
+int hwaccel_decode_init(AVCodecContext *avctx)
+{
+    InputStream *ist = avctx->opaque;
+
+    ist->hwaccel_retrieve_data = &hwaccel_retrieve_data;
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/fftools/ffmpeg_opt.c b/mythtv/external/FFmpeg/fftools/ffmpeg_opt.c
index 4d25fff410f..100fa76e46f 100644
--- a/mythtv/external/FFmpeg/fftools/ffmpeg_opt.c
+++ b/mythtv/external/FFmpeg/fftools/ffmpeg_opt.c
@@ -67,30 +67,42 @@
 
 const HWAccel hwaccels[] = {
 #if HAVE_VDPAU_X11
-    { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
+    { "vdpau", hwaccel_decode_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU,
+      AV_HWDEVICE_TYPE_VDPAU },
 #endif
-#if HAVE_DXVA2_LIB
-    { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
+#if CONFIG_D3D11VA
+    { "d3d11va", hwaccel_decode_init, HWACCEL_D3D11VA, AV_PIX_FMT_D3D11,
+      AV_HWDEVICE_TYPE_D3D11VA },
+#endif
+#if CONFIG_DXVA2
+    { "dxva2", hwaccel_decode_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD,
+      AV_HWDEVICE_TYPE_DXVA2 },
 #endif
 #if CONFIG_VDA
-    { "vda",   videotoolbox_init,   HWACCEL_VDA,   AV_PIX_FMT_VDA },
+    { "vda",   videotoolbox_init,   HWACCEL_VDA,   AV_PIX_FMT_VDA,
+      AV_HWDEVICE_TYPE_NONE },
 #endif
 #if CONFIG_VIDEOTOOLBOX
-    { "videotoolbox",   videotoolbox_init,   HWACCEL_VIDEOTOOLBOX,   AV_PIX_FMT_VIDEOTOOLBOX },
+    { "videotoolbox",   videotoolbox_init,   HWACCEL_VIDEOTOOLBOX,   AV_PIX_FMT_VIDEOTOOLBOX,
+      AV_HWDEVICE_TYPE_NONE },
 #endif
 #if CONFIG_LIBMFX
-    { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV },
+    { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV,
+      AV_HWDEVICE_TYPE_NONE },
 #endif
 #if CONFIG_VAAPI
-    { "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
+    { "vaapi", hwaccel_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI,
+      AV_HWDEVICE_TYPE_VAAPI },
 #endif
 #if CONFIG_CUVID
-    { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
+    { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA,
+      AV_HWDEVICE_TYPE_NONE },
 #endif
     { 0 },
 };
 int hwaccel_lax_profile_check = 0;
 AVBufferRef *hw_device_ctx;
+HWDevice *filter_hw_device;
 
 char *vstats_filename;
 char *sdp_filename;
@@ -119,6 +131,9 @@ int qp_hist           = 0;
 int stdin_interaction = 1;
 int frame_bits_per_raw_sample = 0;
 float max_error_rate  = 2.0/3;
+int filter_nbthreads = 0;
+int filter_complex_nbthreads = 0;
+int vstats_version = 2;
 
 
 static int intra_only         = 0;
@@ -130,6 +145,7 @@ static int override_ffserver  = 0;
 static int input_stream_potentially_available = 0;
 static int ignore_unknown_streams = 0;
 static int copy_unknown_streams = 0;
+static int find_stream_info = 1;
 
 static void uninit_options(OptionsContext *o)
 {
@@ -182,7 +198,7 @@ static int show_hwaccels(void *optctx, const char *opt, const char *arg)
     int i;
 
     printf("Hardware acceleration methods:\n");
-    for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
+    for (i = 0; hwaccels[i].name; i++) {
         printf("%s\n", hwaccels[i].name);
     }
     printf("\n");
@@ -389,6 +405,11 @@ static int opt_map_channel(void *optctx, const char *opt, const char *arg)
     int n;
     AVStream *st;
     AudioChannelMap *m;
+    char *allow_unused;
+    char *mapchan;
+    mapchan = av_strdup(arg);
+    if (!mapchan)
+        return AVERROR(ENOMEM);
 
     GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
@@ -399,6 +420,7 @@ static int opt_map_channel(void *optctx, const char *opt, const char *arg)
         m->file_idx = m->stream_idx = -1;
         if (n == 1)
             m->ofile_idx = m->ostream_idx = -1;
+        av_free(mapchan);
         return 0;
     }
 
@@ -434,11 +456,22 @@ static int opt_map_channel(void *optctx, const char *opt, const char *arg)
                m->file_idx, m->stream_idx);
         exit_program(1);
     }
+    /* allow trailing ? to map_channel */
+    if (allow_unused = strchr(mapchan, '?'))
+        *allow_unused = 0;
     if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
-        av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
-               m->file_idx, m->stream_idx, m->channel_idx);
-        exit_program(1);
+        if (allow_unused) {
+            av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
+                    m->file_idx, m->stream_idx, m->channel_idx);
+        } else {
+            av_log(NULL, AV_LOG_FATAL,  "mapchan: invalid audio channel #%d.%d.%d\n"
+                    "To ignore this, add a trailing '?' to the map_channel.\n",
+                    m->file_idx, m->stream_idx, m->channel_idx);
+            exit_program(1);
+        }
+
     }
+    av_free(mapchan);
     return 0;
 }
 
@@ -452,14 +485,53 @@ static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
 #if CONFIG_VAAPI
 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
 {
+    HWDevice *dev;
+    const char *prefix = "vaapi:";
+    char *tmp;
     int err;
-    err = vaapi_device_init(arg);
+    tmp = av_asprintf("%s%s", prefix, arg);
+    if (!tmp)
+        return AVERROR(ENOMEM);
+    err = hw_device_init_from_string(tmp, &dev);
+    av_free(tmp);
     if (err < 0)
-        exit_program(1);
+        return err;
+    hw_device_ctx = av_buffer_ref(dev->device_ref);
+    if (!hw_device_ctx)
+        return AVERROR(ENOMEM);
     return 0;
 }
 #endif
 
+static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
+{
+    if (!strcmp(arg, "list")) {
+        enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
+        printf("Supported hardware device types:\n");
+        while ((type = av_hwdevice_iterate_types(type)) !=
+               AV_HWDEVICE_TYPE_NONE)
+            printf("%s\n", av_hwdevice_get_type_name(type));
+        printf("\n");
+        exit_program(0);
+    } else {
+        return hw_device_init_from_string(arg, NULL);
+    }
+}
+
+static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
+{
+    if (filter_hw_device) {
+        av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
+        return AVERROR(EINVAL);
+    }
+    filter_hw_device = hw_device_get_by_name(arg);
+    if (!filter_hw_device) {
+        av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
+        return AVERROR(EINVAL);
+    }
+    return 0;
+}
+
 /**
  * Parse a metadata specifier passed as 'arg' parameter.
  * @param arg  metadata string to parse
@@ -719,24 +791,22 @@ static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
         case AVMEDIA_TYPE_VIDEO:
             if(!ist->dec)
                 ist->dec = avcodec_find_decoder(par->codec_id);
-#if FF_API_EMU_EDGE
+#if FF_API_LOWRES
             if (av_codec_get_lowres(st->codec)) {
                 av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
                 ist->dec_ctx->width  = st->codec->width;
                 ist->dec_ctx->height = st->codec->height;
                 ist->dec_ctx->coded_width  = st->codec->coded_width;
                 ist->dec_ctx->coded_height = st->codec->coded_height;
+#if FF_API_EMU_EDGE
                 ist->dec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
+#endif
             }
 #endif
 
             // avformat_find_stream_info() doesn't set this for us anymore.
             ist->dec_ctx->framerate = st->avg_frame_rate;
 
-            ist->resample_height  = ist->dec_ctx->height;
-            ist->resample_width   = ist->dec_ctx->width;
-            ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
-
             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
             if (framerate && av_parse_video_rate(&ist->framerate,
                                                  framerate) < 0) {
@@ -801,12 +871,6 @@ static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
             ist->guess_layout_max = INT_MAX;
             MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
             guess_input_channel_layout(ist);
-
-            ist->resample_sample_fmt     = ist->dec_ctx->sample_fmt;
-            ist->resample_sample_rate    = ist->dec_ctx->sample_rate;
-            ist->resample_channels       = ist->dec_ctx->channels;
-            ist->resample_channel_layout = ist->dec_ctx->channel_layout;
-
             break;
         case AVMEDIA_TYPE_DATA:
         case AVMEDIA_TYPE_SUBTITLE: {
@@ -905,10 +969,8 @@ static int open_input_file(OptionsContext *o, const char *filename)
     AVInputFormat *file_iformat = NULL;
     int err, i, ret;
     int64_t timestamp;
-    AVDictionary **opts;
     AVDictionary *unused_opts = NULL;
     AVDictionaryEntry *e = NULL;
-    int orig_nb_streams;                     // number of streams before avformat_find_stream_info
     char *   video_codec_name = NULL;
     char *   audio_codec_name = NULL;
     char *subtitle_codec_name = NULL;
@@ -934,6 +996,7 @@ static int open_input_file(OptionsContext *o, const char *filename)
         print_error(filename, AVERROR(ENOMEM));
         exit_program(1);
     }
+    ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
     if (o->nb_audio_sample_rate) {
         av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
     }
@@ -1010,18 +1073,24 @@ static int open_input_file(OptionsContext *o, const char *filename)
     for (i = 0; i < ic->nb_streams; i++)
         choose_decoder(o, ic, ic->streams[i]);
 
-    /* Set AVCodecContext options for avformat_find_stream_info */
-    opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
-    orig_nb_streams = ic->nb_streams;
+    if (find_stream_info) {
+        AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
+        int orig_nb_streams = ic->nb_streams;
 
-    /* If not enough info to get the stream parameters, we decode the
-       first frames to get it. (used in mpeg case for example) */
-    ret = avformat_find_stream_info(ic, opts);
-    if (ret < 0) {
-        av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
-        if (ic->nb_streams == 0) {
-            avformat_close_input(&ic);
-            exit_program(1);
+        /* If not enough info to get the stream parameters, we decode the
+           first frames to get it. (used in mpeg case for example) */
+        ret = avformat_find_stream_info(ic, opts);
+
+        for (i = 0; i < orig_nb_streams; i++)
+            av_dict_free(&opts[i]);
+        av_freep(&opts);
+
+        if (ret < 0) {
+            av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
+            if (ic->nb_streams == 0) {
+                avformat_close_input(&ic);
+                exit_program(1);
+            }
         }
     }
 
@@ -1135,10 +1204,6 @@ static int open_input_file(OptionsContext *o, const char *filename)
         }
     }
 
-    for (i = 0; i < orig_nb_streams; i++)
-        av_dict_free(&opts[i]);
-    av_freep(&opts);
-
     input_stream_potentially_available = 1;
 
     return 0;
@@ -1229,7 +1294,7 @@ static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, e
     OutputStream *ost;
     AVStream *st = avformat_new_stream(oc, NULL);
     int idx      = oc->nb_streams - 1, ret = 0;
-    const char *bsfs = NULL;
+    const char *bsfs = NULL, *time_base = NULL;
     char *next, *codec_tag = NULL;
     double qscale = -1;
     int i;
@@ -1306,6 +1371,28 @@ static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, e
         ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
     }
 
+    MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
+    if (time_base) {
+        AVRational q;
+        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
+            q.num <= 0 || q.den <= 0) {
+            av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
+            exit_program(1);
+        }
+        st->time_base = q;
+    }
+
+    MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
+    if (time_base) {
+        AVRational q;
+        if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
+            q.den <= 0) {
+            av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
+            exit_program(1);
+        }
+        ost->enc_timebase = q;
+    }
+
     ost->max_frames = INT64_MAX;
     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
     for (i = 0; i<o->nb_max_frames; i++) {
@@ -1369,13 +1456,6 @@ static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, e
         if (*bsfs)
             bsfs++;
     }
-    if (ost->nb_bitstream_filters) {
-        ost->bsf_extradata_updated = av_mallocz_array(ost->nb_bitstream_filters, sizeof(*ost->bsf_extradata_updated));
-        if (!ost->bsf_extradata_updated) {
-            av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
-            exit_program(1);
-        }
-    }
 
     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
     if (codec_tag) {
@@ -1908,6 +1988,7 @@ static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const ch
     int i, err;
     AVFormatContext *ic = avformat_alloc_context();
 
+    ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
     ic->interrupt_callback = int_cb;
     err = avformat_open_input(&ic, filename, NULL, NULL);
     if (err < 0)
@@ -1971,6 +2052,7 @@ static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
     ost->filter       = ofilter;
 
     ofilter->ost      = ost;
+    ofilter->format   = -1;
 
     if (ost->stream_copy) {
         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
@@ -2006,17 +2088,6 @@ static int init_complex_filters(void)
     return 0;
 }
 
-static int configure_complex_filters(void)
-{
-    int i, ret = 0;
-
-    for (i = 0; i < nb_filtergraphs; i++)
-        if (!filtergraph_is_simple(filtergraphs[i]) &&
-            (ret = configure_filtergraph(filtergraphs[i])) < 0)
-            return ret;
-    return 0;
-}
-
 static int open_output_file(OptionsContext *o, const char *filename)
 {
     AVFormatContext *oc;
@@ -2027,7 +2098,7 @@ static int open_output_file(OptionsContext *o, const char *filename)
     InputStream  *ist;
     AVDictionary *unused_opts = NULL;
     AVDictionaryEntry *e = NULL;
-
+    int format_flags = 0;
 
     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
         o->stop_time = INT64_MAX;
@@ -2073,6 +2144,12 @@ static int open_output_file(OptionsContext *o, const char *filename)
     file_oformat= oc->oformat;
     oc->interrupt_callback = int_cb;
 
+    e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
+    if (e) {
+        const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
+        av_opt_eval_flags(oc, o, e->value, &format_flags);
+    }
+
     /* create streams for all unlabeled output pads */
     for (i = 0; i < nb_filtergraphs; i++) {
         FilterGraph *fg = filtergraphs[i];
@@ -2093,6 +2170,7 @@ static int open_output_file(OptionsContext *o, const char *filename)
 
     /* ffserver seeking with date=... needs a date reference */
     if (!strcmp(file_oformat->name, "ffm") &&
+        !(format_flags & AVFMT_FLAG_BITEXACT) &&
         av_strstart(filename, "http:", NULL)) {
         int err = parse_option(o, "metadata", "creation_time=now", options);
         if (err < 0) {
@@ -2399,6 +2477,67 @@ static int open_output_file(OptionsContext *o, const char *filename)
                 }
             }
         }
+
+        /* set the filter output constraints */
+        if (ost->filter) {
+            OutputFilter *f = ost->filter;
+            int count;
+            switch (ost->enc_ctx->codec_type) {
+            case AVMEDIA_TYPE_VIDEO:
+                f->frame_rate = ost->frame_rate;
+                f->width      = ost->enc_ctx->width;
+                f->height     = ost->enc_ctx->height;
+                if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
+                    f->format = ost->enc_ctx->pix_fmt;
+                } else if (ost->enc->pix_fmts) {
+                    count = 0;
+                    while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
+                        count++;
+                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
+                    if (!f->formats)
+                        exit_program(1);
+                    memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
+                }
+                break;
+            case AVMEDIA_TYPE_AUDIO:
+                if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
+                    f->format = ost->enc_ctx->sample_fmt;
+                } else if (ost->enc->sample_fmts) {
+                    count = 0;
+                    while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
+                        count++;
+                    f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
+                    if (!f->formats)
+                        exit_program(1);
+                    memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
+                }
+                if (ost->enc_ctx->sample_rate) {
+                    f->sample_rate = ost->enc_ctx->sample_rate;
+                } else if (ost->enc->supported_samplerates) {
+                    count = 0;
+                    while (ost->enc->supported_samplerates[count])
+                        count++;
+                    f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
+                    if (!f->sample_rates)
+                        exit_program(1);
+                    memcpy(f->sample_rates, ost->enc->supported_samplerates,
+                           (count + 1) * sizeof(*f->sample_rates));
+                }
+                if (ost->enc_ctx->channels) {
+                    f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
+                } else if (ost->enc->channel_layouts) {
+                    count = 0;
+                    while (ost->enc->channel_layouts[count])
+                        count++;
+                    f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
+                    if (!f->channel_layouts)
+                        exit_program(1);
+                    memcpy(f->channel_layouts, ost->enc->channel_layouts,
+                           (count + 1) * sizeof(*f->channel_layouts));
+                }
+                break;
+            }
+        }
     }
 
     /* check filename in case of an image number is expected */
@@ -2485,8 +2624,6 @@ static int open_output_file(OptionsContext *o, const char *filename)
             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
             if (!output_streams[i]->stream_copy) {
                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
-                if (ist->autorotate)
-                    av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
             }
         }
 
@@ -2576,9 +2713,15 @@ static int open_output_file(OptionsContext *o, const char *filename)
             for (j = 0; j < oc->nb_streams; j++) {
                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
-                    av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
-                        ost->rotate_overridden = 1;
+                        char *tail;
+                        double theta = av_strtod(val, &tail);
+                        if (!*tail) {
+                            ost->rotate_overridden = 1;
+                            ost->rotate_override_value = theta;
+                        }
+                    } else {
+                        av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
                     }
                 } else if (ret < 0)
                     exit_program(1);
@@ -2949,7 +3092,7 @@ static int opt_timecode(void *optctx, const char *opt, const char *arg)
     if (ret >= 0)
         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
     av_free(tcr);
-    return 0;
+    return ret;
 }
 
 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
@@ -3108,8 +3251,8 @@ enum OptGroup {
 };
 
 static const OptionGroupDef groups[] = {
-    [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
-    [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
+    [GROUP_OUTFILE] = { "output url",  NULL, OPT_OUTPUT },
+    [GROUP_INFILE]  = { "input url",   "i",  OPT_INPUT },
 };
 
 static int open_files(OptionGroupList *l, const char *inout,
@@ -3192,12 +3335,7 @@ int ffmpeg_parse_options(int argc, char **argv)
         goto fail;
     }
 
-    /* configure the complex filtergraphs */
-    ret = configure_complex_filters();
-    if (ret < 0) {
-        av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
-        goto fail;
-    }
+    check_filter_outputs();
 
 fail:
     uninit_parse_context(&octx);
@@ -3228,7 +3366,7 @@ static int opt_progress(void *optctx, const char *opt, const char *arg)
 #define OFFSET(x) offsetof(OptionsContext, x)
 const OptionDef options[] = {
     /* main options */
-#include "cmdutils_common_opts.h"
+    CMDUTILS_COMMON_OPTIONS
     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
         "force format", "fmt" },
@@ -3365,12 +3503,16 @@ const OptionDef options[] = {
         "set profile", "profile" },
     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
         "set stream filtergraph", "filter_graph" },
+    { "filter_threads",  HAS_ARG | OPT_INT,                          { &filter_nbthreads },
+        "number of non-complex filter threads" },
     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
         "read stream filtergraph description from a file", "filename" },
     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
         "reinit filtergraph on input parameter changes", "" },
     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
         "create a complex filtergraph", "graph_description" },
+    { "filter_complex_threads", HAS_ARG | OPT_INT,                   { &filter_complex_nbthreads },
+        "number of threads for -filter_complex" },
     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
         "create a complex filtergraph", "graph_description" },
     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
@@ -3398,6 +3540,8 @@ const OptionDef options[] = {
     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
                                                                      { .off = OFFSET(thread_queue_size) },
         "set the maximum number of queued packets from the demuxer" },
+    { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
+        "read and decode the streams to fill missing information with heuristics" },
 
     /* video options */
     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
@@ -3445,6 +3589,8 @@ const OptionDef options[] = {
         "dump video coding statistics to file" },
     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
         "dump video coding statistics to file", "file" },
+    { "vstats_version",  OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,            { &vstats_version },
+        "Version of the vstats format to use."},
     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
         "set video filters", "filter_graph" },
     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
@@ -3558,6 +3704,14 @@ const OptionDef options[] = {
     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
         "specify a file in which to print sdp information", "file" },
 
+    { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
+        "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
+    { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
+        "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
+        "two special values are defined - "
+        "0 = use frame rate (video) or sample rate (audio),"
+        "-1 = match source time base", "ratio" },
+
     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
         "A comma-separated list of bitstream filters", "bitstream_filters" },
     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
@@ -3588,5 +3742,15 @@ const OptionDef options[] = {
         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
 #endif
 
+#if CONFIG_QSV
+    { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
+        "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
+#endif
+
+    { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
+        "initialise hardware device", "args" },
+    { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
+        "set hardware device used when filtering", "device" },
+
     { NULL, },
 };
diff --git a/mythtv/external/FFmpeg/fftools/ffmpeg_qsv.c b/mythtv/external/FFmpeg/fftools/ffmpeg_qsv.c
index acc54dd27af..74427500291 100644
--- a/mythtv/external/FFmpeg/fftools/ffmpeg_qsv.c
+++ b/mythtv/external/FFmpeg/fftools/ffmpeg_qsv.c
@@ -20,248 +20,90 @@
 #include <stdlib.h>
 
 #include "libavutil/dict.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_qsv.h"
 #include "libavutil/mem.h"
 #include "libavutil/opt.h"
 #include "libavcodec/qsv.h"
 
 #include "ffmpeg.h"
 
-typedef struct QSVContext {
-    OutputStream *ost;
-
-    mfxSession session;
-
-    mfxExtOpaqueSurfaceAlloc opaque_alloc;
-    AVBufferRef             *opaque_surfaces_buf;
-
-    uint8_t           *surface_used;
-    mfxFrameSurface1 **surface_ptrs;
-    int nb_surfaces;
-
-    mfxExtBuffer *ext_buffers[1];
-} QSVContext;
-
-static void buffer_release(void *opaque, uint8_t *data)
-{
-    *(uint8_t*)opaque = 0;
-}
+char *qsv_device = NULL;
 
 static int qsv_get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
 {
     InputStream *ist = s->opaque;
-    QSVContext  *qsv = ist->hwaccel_ctx;
-    int i;
-
-    for (i = 0; i < qsv->nb_surfaces; i++) {
-        if (qsv->surface_used[i])
-            continue;
-
-        frame->buf[0] = av_buffer_create((uint8_t*)qsv->surface_ptrs[i], sizeof(*qsv->surface_ptrs[i]),
-                                         buffer_release, &qsv->surface_used[i], 0);
-        if (!frame->buf[0])
-            return AVERROR(ENOMEM);
-        frame->data[3]       = (uint8_t*)qsv->surface_ptrs[i];
-        qsv->surface_used[i] = 1;
-        return 0;
-    }
-
-    return AVERROR(ENOMEM);
-}
-
-static int init_opaque_surf(QSVContext *qsv)
-{
-    AVQSVContext *hwctx_enc = qsv->ost->enc_ctx->hwaccel_context;
-    mfxFrameSurface1 *surfaces;
-    int i;
-
-    qsv->nb_surfaces = hwctx_enc->nb_opaque_surfaces;
 
-    qsv->opaque_surfaces_buf = av_buffer_ref(hwctx_enc->opaque_surfaces);
-    qsv->surface_ptrs        = av_mallocz_array(qsv->nb_surfaces, sizeof(*qsv->surface_ptrs));
-    qsv->surface_used        = av_mallocz_array(qsv->nb_surfaces, sizeof(*qsv->surface_used));
-    if (!qsv->opaque_surfaces_buf || !qsv->surface_ptrs || !qsv->surface_used)
-        return AVERROR(ENOMEM);
-
-    surfaces = (mfxFrameSurface1*)qsv->opaque_surfaces_buf->data;
-    for (i = 0; i < qsv->nb_surfaces; i++)
-        qsv->surface_ptrs[i] = surfaces + i;
-
-    qsv->opaque_alloc.Out.Surfaces   = qsv->surface_ptrs;
-    qsv->opaque_alloc.Out.NumSurface = qsv->nb_surfaces;
-    qsv->opaque_alloc.Out.Type       = hwctx_enc->opaque_alloc_type;
-
-    qsv->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
-    qsv->opaque_alloc.Header.BufferSz = sizeof(qsv->opaque_alloc);
-    qsv->ext_buffers[0]               = (mfxExtBuffer*)&qsv->opaque_alloc;
-
-    return 0;
+    return av_hwframe_get_buffer(ist->hw_frames_ctx, frame, 0);
 }
 
 static void qsv_uninit(AVCodecContext *s)
 {
     InputStream *ist = s->opaque;
-    QSVContext  *qsv = ist->hwaccel_ctx;
-
-    av_freep(&qsv->ost->enc_ctx->hwaccel_context);
-    av_freep(&s->hwaccel_context);
-
-    av_buffer_unref(&qsv->opaque_surfaces_buf);
-    av_freep(&qsv->surface_used);
-    av_freep(&qsv->surface_ptrs);
-
-    av_freep(&qsv);
+    av_buffer_unref(&ist->hw_frames_ctx);
 }
 
-int qsv_init(AVCodecContext *s)
+static int qsv_device_init(InputStream *ist)
 {
-    InputStream *ist = s->opaque;
-    QSVContext  *qsv = ist->hwaccel_ctx;
-    AVQSVContext *hwctx_dec;
-    int ret;
+    int err;
+    AVDictionary *dict = NULL;
 
-    if (!qsv) {
-        av_log(NULL, AV_LOG_ERROR, "QSV transcoding is not initialized. "
-               "-hwaccel qsv should only be used for one-to-one QSV transcoding "
-               "with no filters.\n");
-        return AVERROR_BUG;
+    if (qsv_device) {
+        err = av_dict_set(&dict, "child_device", qsv_device, 0);
+        if (err < 0)
+            return err;
     }
 
-    ret = init_opaque_surf(qsv);
-    if (ret < 0)
-        return ret;
-
-    hwctx_dec = av_qsv_alloc_context();
-    if (!hwctx_dec)
-        return AVERROR(ENOMEM);
-
-    hwctx_dec->session        = qsv->session;
-    hwctx_dec->iopattern      = MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
-    hwctx_dec->ext_buffers    = qsv->ext_buffers;
-    hwctx_dec->nb_ext_buffers = FF_ARRAY_ELEMS(qsv->ext_buffers);
-
-    av_freep(&s->hwaccel_context);
-    s->hwaccel_context = hwctx_dec;
+    err = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_QSV,
+                                 ist->hwaccel_device, dict, 0);
+    if (err < 0) {
+        av_log(NULL, AV_LOG_ERROR, "Error creating a QSV device\n");
+        goto err_out;
+    }
 
-    ist->hwaccel_get_buffer = qsv_get_buffer;
-    ist->hwaccel_uninit     = qsv_uninit;
+err_out:
+    if (dict)
+        av_dict_free(&dict);
 
-    return 0;
+    return err;
 }
 
-static mfxIMPL choose_implementation(const InputStream *ist)
+int qsv_init(AVCodecContext *s)
 {
-    static const struct {
-        const char *name;
-        mfxIMPL     impl;
-    } impl_map[] = {
-        { "auto",     MFX_IMPL_AUTO         },
-        { "sw",       MFX_IMPL_SOFTWARE     },
-        { "hw",       MFX_IMPL_HARDWARE     },
-        { "auto_any", MFX_IMPL_AUTO_ANY     },
-        { "hw_any",   MFX_IMPL_HARDWARE_ANY },
-        { "hw2",      MFX_IMPL_HARDWARE2    },
-        { "hw3",      MFX_IMPL_HARDWARE3    },
-        { "hw4",      MFX_IMPL_HARDWARE4    },
-    };
-
-    mfxIMPL impl = MFX_IMPL_AUTO_ANY;
-    int i;
+    InputStream *ist = s->opaque;
+    AVHWFramesContext *frames_ctx;
+    AVQSVFramesContext *frames_hwctx;
+    int ret;
 
-    if (ist->hwaccel_device) {
-        for (i = 0; i < FF_ARRAY_ELEMS(impl_map); i++)
-            if (!strcmp(ist->hwaccel_device, impl_map[i].name)) {
-                impl = impl_map[i].impl;
-                break;
-            }
-        if (i == FF_ARRAY_ELEMS(impl_map))
-            impl = strtol(ist->hwaccel_device, NULL, 0);
+    if (!hw_device_ctx) {
+        ret = qsv_device_init(ist);
+        if (ret < 0)
+            return ret;
     }
 
-    return impl;
-}
-
-int qsv_transcode_init(OutputStream *ost)
-{
-    InputStream *ist;
-    const enum AVPixelFormat *pix_fmt;
-
-    AVDictionaryEntry *e;
-    const AVOption *opt;
-    int flags = 0;
-
-    int err, i;
-
-    QSVContext *qsv = NULL;
-    AVQSVContext *hwctx = NULL;
-    mfxIMPL impl;
-    mfxVersion ver = { { 3, 1 } };
-
-    /* check if the encoder supports QSV */
-    if (!ost->enc->pix_fmts)
-        return 0;
-    for (pix_fmt = ost->enc->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++)
-        if (*pix_fmt == AV_PIX_FMT_QSV)
-            break;
-    if (*pix_fmt == AV_PIX_FMT_NONE)
-        return 0;
-
-    if (strcmp(ost->avfilter, "null") || ost->source_index < 0)
-        return 0;
-
-    /* check if the decoder supports QSV and the output only goes to this stream */
-    ist = input_streams[ost->source_index];
-    if (ist->hwaccel_id != HWACCEL_QSV || !ist->dec || !ist->dec->pix_fmts)
-        return 0;
-    for (pix_fmt = ist->dec->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++)
-        if (*pix_fmt == AV_PIX_FMT_QSV)
-            break;
-    if (*pix_fmt == AV_PIX_FMT_NONE)
-        return 0;
-
-    for (i = 0; i < nb_output_streams; i++)
-        if (output_streams[i] != ost &&
-            output_streams[i]->source_index == ost->source_index)
-            return 0;
-
-    av_log(NULL, AV_LOG_VERBOSE, "Setting up QSV transcoding\n");
+    av_buffer_unref(&ist->hw_frames_ctx);
+    ist->hw_frames_ctx = av_hwframe_ctx_alloc(hw_device_ctx);
+    if (!ist->hw_frames_ctx)
+        return AVERROR(ENOMEM);
 
-    qsv   = av_mallocz(sizeof(*qsv));
-    hwctx = av_qsv_alloc_context();
-    if (!qsv || !hwctx)
-        goto fail;
+    frames_ctx   = (AVHWFramesContext*)ist->hw_frames_ctx->data;
+    frames_hwctx = frames_ctx->hwctx;
 
-    impl = choose_implementation(ist);
+    frames_ctx->width             = FFALIGN(s->coded_width,  32);
+    frames_ctx->height            = FFALIGN(s->coded_height, 32);
+    frames_ctx->format            = AV_PIX_FMT_QSV;
+    frames_ctx->sw_format         = s->sw_pix_fmt;
+    frames_ctx->initial_pool_size = 64;
+    frames_hwctx->frame_type      = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
 
-    err = MFXInit(impl, &ver, &qsv->session);
-    if (err != MFX_ERR_NONE) {
-        av_log(NULL, AV_LOG_ERROR, "Error initializing an MFX session: %d\n", err);
-        goto fail;
+    ret = av_hwframe_ctx_init(ist->hw_frames_ctx);
+    if (ret < 0) {
+        av_log(NULL, AV_LOG_ERROR, "Error initializing a QSV frame pool\n");
+        return ret;
     }
 
-    e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
-    opt = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
-    if (e && opt)
-        av_opt_eval_flags(ost->enc_ctx, opt, e->value, &flags);
-
-    qsv->ost = ost;
-
-    hwctx->session                = qsv->session;
-    hwctx->iopattern              = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
-    hwctx->opaque_alloc           = 1;
-    hwctx->nb_opaque_surfaces     = 16;
-
-    ost->hwaccel_ctx              = qsv;
-    ost->enc_ctx->hwaccel_context = hwctx;
-    ost->enc_ctx->pix_fmt         = AV_PIX_FMT_QSV;
-
-    ist->hwaccel_ctx              = qsv;
-    ist->dec_ctx->pix_fmt         = AV_PIX_FMT_QSV;
-    ist->resample_pix_fmt         = AV_PIX_FMT_QSV;
+    ist->hwaccel_get_buffer = qsv_get_buffer;
+    ist->hwaccel_uninit     = qsv_uninit;
 
     return 0;
-
-fail:
-    av_freep(&hwctx);
-    av_freep(&qsv);
-    return AVERROR_UNKNOWN;
 }
diff --git a/mythtv/external/FFmpeg/fftools/ffmpeg_vaapi.c b/mythtv/external/FFmpeg/fftools/ffmpeg_vaapi.c
deleted file mode 100644
index f1e7c76f389..00000000000
--- a/mythtv/external/FFmpeg/fftools/ffmpeg_vaapi.c
+++ /dev/null
@@ -1,538 +0,0 @@
-/*
- * 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 <fcntl.h>
-#include <unistd.h>
-
-#include <va/va.h>
-#if HAVE_VAAPI_X11
-#   include <va/va_x11.h>
-#endif
-#if HAVE_VAAPI_DRM
-#   include <va/va_drm.h>
-#endif
-
-#include "libavutil/avassert.h"
-#include "libavutil/avconfig.h"
-#include "libavutil/buffer.h"
-#include "libavutil/frame.h"
-#include "libavutil/hwcontext.h"
-#include "libavutil/hwcontext_vaapi.h"
-#include "libavutil/imgutils.h"
-#include "libavutil/opt.h"
-#include "libavutil/pixfmt.h"
-
-#include "libavcodec/vaapi.h"
-
-#include "ffmpeg.h"
-
-
-static AVClass vaapi_class = {
-    .class_name = "vaapi",
-    .item_name  = av_default_item_name,
-    .version    = LIBAVUTIL_VERSION_INT,
-};
-
-#define DEFAULT_SURFACES 20
-
-typedef struct VAAPIDecoderContext {
-    const AVClass *class;
-
-    AVBufferRef       *device_ref;
-    AVHWDeviceContext *device;
-    AVBufferRef       *frames_ref;
-    AVHWFramesContext *frames;
-
-    VAProfile    va_profile;
-    VAEntrypoint va_entrypoint;
-    VAConfigID   va_config;
-    VAContextID  va_context;
-
-    enum AVPixelFormat decode_format;
-    int decode_width;
-    int decode_height;
-    int decode_surfaces;
-
-    // The output need not have the same format, width and height as the
-    // decoded frames - the copy for non-direct-mapped access is actually
-    // a whole vpp instance which can do arbitrary scaling and format
-    // conversion.
-    enum AVPixelFormat output_format;
-
-    struct vaapi_context decoder_vaapi_context;
-} VAAPIDecoderContext;
-
-
-static int vaapi_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
-{
-    InputStream *ist = avctx->opaque;
-    VAAPIDecoderContext *ctx = ist->hwaccel_ctx;
-    int err;
-
-    err = av_hwframe_get_buffer(ctx->frames_ref, frame, 0);
-    if (err < 0) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to allocate decoder surface.\n");
-    } else {
-        av_log(ctx, AV_LOG_DEBUG, "Decoder given surface %#x.\n",
-               (unsigned int)(uintptr_t)frame->data[3]);
-    }
-    return err;
-}
-
-static int vaapi_retrieve_data(AVCodecContext *avctx, AVFrame *input)
-{
-    InputStream *ist = avctx->opaque;
-    VAAPIDecoderContext *ctx = ist->hwaccel_ctx;
-    AVFrame *output = 0;
-    int err;
-
-    av_assert0(input->format == AV_PIX_FMT_VAAPI);
-
-    if (ctx->output_format == AV_PIX_FMT_VAAPI) {
-        // Nothing to do.
-        return 0;
-    }
-
-    av_log(ctx, AV_LOG_DEBUG, "Retrieve data from surface %#x.\n",
-           (unsigned int)(uintptr_t)input->data[3]);
-
-    output = av_frame_alloc();
-    if (!output)
-        return AVERROR(ENOMEM);
-
-    output->format = ctx->output_format;
-
-    err = av_hwframe_transfer_data(output, input, 0);
-    if (err < 0) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to transfer data to "
-               "output frame: %d.\n", err);
-        goto fail;
-    }
-
-    err = av_frame_copy_props(output, input);
-    if (err < 0) {
-        av_frame_unref(output);
-        goto fail;
-    }
-
-    av_frame_unref(input);
-    av_frame_move_ref(input, output);
-    av_frame_free(&output);
-
-    return 0;
-
-fail:
-    if (output)
-        av_frame_free(&output);
-    return err;
-}
-
-
-static const struct {
-    enum AVCodecID codec_id;
-    int codec_profile;
-    VAProfile va_profile;
-} vaapi_profile_map[] = {
-#define MAP(c, p, v) { AV_CODEC_ID_ ## c, FF_PROFILE_ ## p, VAProfile ## v }
-    MAP(MPEG2VIDEO,  MPEG2_SIMPLE,    MPEG2Simple ),
-    MAP(MPEG2VIDEO,  MPEG2_MAIN,      MPEG2Main   ),
-    MAP(H263,        UNKNOWN,         H263Baseline),
-    MAP(MPEG4,       MPEG4_SIMPLE,    MPEG4Simple ),
-    MAP(MPEG4,       MPEG4_ADVANCED_SIMPLE,
-                               MPEG4AdvancedSimple),
-    MAP(MPEG4,       MPEG4_MAIN,      MPEG4Main   ),
-    MAP(H264,        H264_CONSTRAINED_BASELINE,
-                           H264ConstrainedBaseline),
-    MAP(H264,        H264_BASELINE,   H264Baseline),
-    MAP(H264,        H264_MAIN,       H264Main    ),
-    MAP(H264,        H264_HIGH,       H264High    ),
-#if VA_CHECK_VERSION(0, 37, 0)
-    MAP(HEVC,        HEVC_MAIN,       HEVCMain    ),
-#endif
-    MAP(WMV3,        VC1_SIMPLE,      VC1Simple   ),
-    MAP(WMV3,        VC1_MAIN,        VC1Main     ),
-    MAP(WMV3,        VC1_COMPLEX,     VC1Advanced ),
-    MAP(WMV3,        VC1_ADVANCED,    VC1Advanced ),
-    MAP(VC1,         VC1_SIMPLE,      VC1Simple   ),
-    MAP(VC1,         VC1_MAIN,        VC1Main     ),
-    MAP(VC1,         VC1_COMPLEX,     VC1Advanced ),
-    MAP(VC1,         VC1_ADVANCED,    VC1Advanced ),
-#if VA_CHECK_VERSION(0, 35, 0)
-    MAP(VP8,         UNKNOWN,       VP8Version0_3 ),
-#endif
-#if VA_CHECK_VERSION(0, 37, 1)
-    MAP(VP9,         VP9_0,           VP9Profile0 ),
-#endif
-#undef MAP
-};
-
-static int vaapi_build_decoder_config(VAAPIDecoderContext *ctx,
-                                      AVCodecContext *avctx,
-                                      int fallback_allowed)
-{
-    AVVAAPIDeviceContext *hwctx = ctx->device->hwctx;
-    AVVAAPIHWConfig *hwconfig = NULL;
-    AVHWFramesConstraints *constraints = NULL;
-    VAStatus vas;
-    int err, i, j;
-    int loglevel = fallback_allowed ? AV_LOG_VERBOSE : AV_LOG_ERROR;
-    const AVCodecDescriptor *codec_desc;
-    const AVPixFmtDescriptor *pix_desc;
-    enum AVPixelFormat pix_fmt;
-    VAProfile profile, *profile_list = NULL;
-    int profile_count, exact_match, alt_profile;
-
-    codec_desc = avcodec_descriptor_get(avctx->codec_id);
-    if (!codec_desc) {
-        err = AVERROR(EINVAL);
-        goto fail;
-    }
-
-    profile_count = vaMaxNumProfiles(hwctx->display);
-    profile_list = av_malloc(profile_count * sizeof(VAProfile));
-    if (!profile_list) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-
-    vas = vaQueryConfigProfiles(hwctx->display,
-                                profile_list, &profile_count);
-    if (vas != VA_STATUS_SUCCESS) {
-        av_log(ctx, loglevel, "Failed to query profiles: %d (%s).\n",
-               vas, vaErrorStr(vas));
-        err = AVERROR(EIO);
-        goto fail;
-    }
-
-    profile = VAProfileNone;
-    exact_match = 0;
-
-    for (i = 0; i < FF_ARRAY_ELEMS(vaapi_profile_map); i++) {
-        int profile_match = 0;
-        if (avctx->codec_id != vaapi_profile_map[i].codec_id)
-            continue;
-        if (avctx->profile == vaapi_profile_map[i].codec_profile)
-            profile_match = 1;
-        profile = vaapi_profile_map[i].va_profile;
-        for (j = 0; j < profile_count; j++) {
-            if (profile == profile_list[j]) {
-                exact_match = profile_match;
-                break;
-            }
-        }
-        if (j < profile_count) {
-            if (exact_match)
-                break;
-            alt_profile = vaapi_profile_map[i].codec_profile;
-        }
-    }
-    av_freep(&profile_list);
-
-    if (profile == VAProfileNone) {
-        av_log(ctx, loglevel, "No VAAPI support for codec %s.\n",
-               codec_desc->name);
-        err = AVERROR(ENOSYS);
-        goto fail;
-    }
-    if (!exact_match) {
-        if (fallback_allowed || !hwaccel_lax_profile_check) {
-            av_log(ctx, loglevel, "No VAAPI support for codec %s "
-                   "profile %d.\n", codec_desc->name, avctx->profile);
-            if (!fallback_allowed) {
-                av_log(ctx, AV_LOG_WARNING, "If you want attempt decoding "
-                       "anyway with a possibly-incompatible profile, add "
-                       "the option -hwaccel_lax_profile_check.\n");
-            }
-            err = AVERROR(EINVAL);
-            goto fail;
-        } else {
-            av_log(ctx, AV_LOG_WARNING, "No VAAPI support for codec %s "
-                   "profile %d: trying instead with profile %d.\n",
-                   codec_desc->name, avctx->profile, alt_profile);
-            av_log(ctx, AV_LOG_WARNING, "This may fail or give "
-                   "incorrect results, depending on your hardware.\n");
-        }
-    }
-
-    ctx->va_profile = profile;
-    ctx->va_entrypoint = VAEntrypointVLD;
-
-    vas = vaCreateConfig(hwctx->display, ctx->va_profile,
-                         ctx->va_entrypoint, 0, 0, &ctx->va_config);
-    if (vas != VA_STATUS_SUCCESS) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to create decode pipeline "
-               "configuration: %d (%s).\n", vas, vaErrorStr(vas));
-        err = AVERROR(EIO);
-        goto fail;
-    }
-
-    hwconfig = av_hwdevice_hwconfig_alloc(ctx->device_ref);
-    if (!hwconfig) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-    hwconfig->config_id = ctx->va_config;
-
-    constraints = av_hwdevice_get_hwframe_constraints(ctx->device_ref,
-                                                      hwconfig);
-    if (!constraints)
-        goto fail;
-
-    // Decide on the decoder target format.
-    // If the user specified something with -hwaccel_output_format then
-    // try to use that to minimise conversions later.
-    ctx->decode_format = AV_PIX_FMT_NONE;
-    if (ctx->output_format != AV_PIX_FMT_NONE &&
-        ctx->output_format != AV_PIX_FMT_VAAPI) {
-        for (i = 0; constraints->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {
-            if (constraints->valid_sw_formats[i] == ctx->output_format) {
-                ctx->decode_format = ctx->output_format;
-                av_log(ctx, AV_LOG_DEBUG, "Using decode format %s (output "
-                       "format).\n", av_get_pix_fmt_name(ctx->decode_format));
-                break;
-            }
-        }
-    }
-    // Otherwise, we would like to try to choose something which matches the
-    // decoder output, but there isn't enough information available here to
-    // do so.  Assume for now that we are always dealing with YUV 4:2:0, so
-    // pick a format which does that.
-    if (ctx->decode_format == AV_PIX_FMT_NONE) {
-        for (i = 0; constraints->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {
-            pix_fmt  = constraints->valid_sw_formats[i];
-            pix_desc = av_pix_fmt_desc_get(pix_fmt);
-            if (pix_desc->nb_components == 3 &&
-                pix_desc->log2_chroma_w == 1 &&
-                pix_desc->log2_chroma_h == 1) {
-                ctx->decode_format = pix_fmt;
-                av_log(ctx, AV_LOG_DEBUG, "Using decode format %s (format "
-                       "matched).\n", av_get_pix_fmt_name(ctx->decode_format));
-                break;
-            }
-        }
-    }
-    // Otherwise pick the first in the list and hope for the best.
-    if (ctx->decode_format == AV_PIX_FMT_NONE) {
-        ctx->decode_format = constraints->valid_sw_formats[0];
-        av_log(ctx, AV_LOG_DEBUG, "Using decode format %s (first in list).\n",
-               av_get_pix_fmt_name(ctx->decode_format));
-        if (i > 1) {
-            // There was a choice, and we picked randomly.  Warn the user
-            // that they might want to choose intelligently instead.
-            av_log(ctx, AV_LOG_WARNING, "Using randomly chosen decode "
-                   "format %s.\n", av_get_pix_fmt_name(ctx->decode_format));
-        }
-    }
-
-    // Ensure the picture size is supported by the hardware.
-    ctx->decode_width  = avctx->coded_width;
-    ctx->decode_height = avctx->coded_height;
-    if (ctx->decode_width  < constraints->min_width  ||
-        ctx->decode_height < constraints->min_height ||
-        ctx->decode_width  > constraints->max_width  ||
-        ctx->decode_height >constraints->max_height) {
-        av_log(ctx, AV_LOG_ERROR, "VAAPI hardware does not support image "
-               "size %dx%d (constraints: width %d-%d height %d-%d).\n",
-               ctx->decode_width, ctx->decode_height,
-               constraints->min_width,  constraints->max_width,
-               constraints->min_height, constraints->max_height);
-        err = AVERROR(EINVAL);
-        goto fail;
-    }
-
-    av_hwframe_constraints_free(&constraints);
-    av_freep(&hwconfig);
-
-    // Decide how many reference frames we need.  This might be doable more
-    // nicely based on the codec and input stream?
-    ctx->decode_surfaces = DEFAULT_SURFACES;
-    // For frame-threaded decoding, one additional surfaces is needed for
-    // each thread.
-    if (avctx->active_thread_type & FF_THREAD_FRAME)
-        ctx->decode_surfaces += avctx->thread_count;
-
-    return 0;
-
-fail:
-    av_hwframe_constraints_free(&constraints);
-    av_freep(&hwconfig);
-    vaDestroyConfig(hwctx->display, ctx->va_config);
-    av_freep(&profile_list);
-    return err;
-}
-
-static void vaapi_decode_uninit(AVCodecContext *avctx)
-{
-    InputStream *ist = avctx->opaque;
-    VAAPIDecoderContext *ctx = ist->hwaccel_ctx;
-
-    if (ctx) {
-        AVVAAPIDeviceContext *hwctx = ctx->device->hwctx;
-
-        if (ctx->va_context != VA_INVALID_ID) {
-            vaDestroyContext(hwctx->display, ctx->va_context);
-            ctx->va_context = VA_INVALID_ID;
-        }
-        if (ctx->va_config != VA_INVALID_ID) {
-            vaDestroyConfig(hwctx->display, ctx->va_config);
-            ctx->va_config = VA_INVALID_ID;
-        }
-
-        av_buffer_unref(&ctx->frames_ref);
-        av_buffer_unref(&ctx->device_ref);
-        av_free(ctx);
-    }
-
-    av_buffer_unref(&ist->hw_frames_ctx);
-
-    ist->hwaccel_ctx           = 0;
-    ist->hwaccel_uninit        = 0;
-    ist->hwaccel_get_buffer    = 0;
-    ist->hwaccel_retrieve_data = 0;
-}
-
-int vaapi_decode_init(AVCodecContext *avctx)
-{
-    InputStream *ist = avctx->opaque;
-    AVVAAPIDeviceContext *hwctx;
-    AVVAAPIFramesContext *avfc;
-    VAAPIDecoderContext *ctx;
-    VAStatus vas;
-    int err;
-    int loglevel = (ist->hwaccel_id != HWACCEL_VAAPI ? AV_LOG_VERBOSE
-                                                     : AV_LOG_ERROR);
-
-    if (ist->hwaccel_ctx)
-        vaapi_decode_uninit(avctx);
-
-    // We have -hwaccel without -vaapi_device, so just initialise here with
-    // the device passed as -hwaccel_device (if -vaapi_device was passed, it
-    // will always have been called before now).
-    if (!hw_device_ctx) {
-        err = vaapi_device_init(ist->hwaccel_device);
-        if (err < 0)
-            return err;
-    }
-
-    ctx = av_mallocz(sizeof(*ctx));
-    if (!ctx)
-        return AVERROR(ENOMEM);
-    ctx->class = &vaapi_class;
-
-    ctx->device_ref = av_buffer_ref(hw_device_ctx);
-    ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
-
-    ctx->va_config  = VA_INVALID_ID;
-    ctx->va_context = VA_INVALID_ID;
-
-    hwctx = ctx->device->hwctx;
-
-    ctx->output_format = ist->hwaccel_output_format;
-
-    err = vaapi_build_decoder_config(ctx, avctx,
-                                     ist->hwaccel_id != HWACCEL_VAAPI);
-    if (err < 0) {
-        av_log(ctx, loglevel, "No supported configuration for this codec.");
-        goto fail;
-    }
-
-    avctx->pix_fmt = ctx->output_format;
-
-    ctx->frames_ref = av_hwframe_ctx_alloc(ctx->device_ref);
-    if (!ctx->frames_ref) {
-        av_log(ctx, loglevel, "Failed to create VAAPI frame context.\n");
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-
-    ctx->frames = (AVHWFramesContext*)ctx->frames_ref->data;
-
-    ctx->frames->format    = AV_PIX_FMT_VAAPI;
-    ctx->frames->sw_format = ctx->decode_format;
-    ctx->frames->width     = ctx->decode_width;
-    ctx->frames->height    = ctx->decode_height;
-    ctx->frames->initial_pool_size = ctx->decode_surfaces;
-
-    err = av_hwframe_ctx_init(ctx->frames_ref);
-    if (err < 0) {
-        av_log(ctx, loglevel, "Failed to initialise VAAPI frame "
-               "context: %d\n", err);
-        goto fail;
-    }
-
-    avfc = ctx->frames->hwctx;
-
-    vas = vaCreateContext(hwctx->display, ctx->va_config,
-                          ctx->decode_width, ctx->decode_height,
-                          VA_PROGRESSIVE,
-                          avfc->surface_ids, avfc->nb_surfaces,
-                          &ctx->va_context);
-    if (vas != VA_STATUS_SUCCESS) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to create decode pipeline "
-               "context: %d (%s).\n", vas, vaErrorStr(vas));
-        err = AVERROR(EINVAL);
-        goto fail;
-    }
-
-    av_log(ctx, AV_LOG_DEBUG, "VAAPI decoder (re)init complete.\n");
-
-    // We would like to set this on the AVCodecContext for use by whoever gets
-    // the frames from the decoder, but unfortunately the AVCodecContext we
-    // have here need not be the "real" one (H.264 makes many copies for
-    // threading purposes).  To avoid the problem, we instead store it in the
-    // InputStream and propagate it from there.
-    ist->hw_frames_ctx = av_buffer_ref(ctx->frames_ref);
-    if (!ist->hw_frames_ctx) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-
-    ist->hwaccel_ctx           = ctx;
-    ist->hwaccel_uninit        = vaapi_decode_uninit;
-    ist->hwaccel_get_buffer    = vaapi_get_buffer;
-    ist->hwaccel_retrieve_data = vaapi_retrieve_data;
-
-    ctx->decoder_vaapi_context.display    = hwctx->display;
-    ctx->decoder_vaapi_context.config_id  = ctx->va_config;
-    ctx->decoder_vaapi_context.context_id = ctx->va_context;
-    avctx->hwaccel_context = &ctx->decoder_vaapi_context;
-
-    return 0;
-
-fail:
-    vaapi_decode_uninit(avctx);
-    return err;
-}
-
-static AVClass *vaapi_log = &vaapi_class;
-
-av_cold int vaapi_device_init(const char *device)
-{
-    int err;
-
-    err = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI,
-                                 device, NULL, 0);
-    if (err < 0) {
-        av_log(&vaapi_log, AV_LOG_ERROR, "Failed to create a VAAPI device\n");
-        return err;
-    }
-
-    return 0;
-}
diff --git a/mythtv/external/FFmpeg/fftools/ffmpeg_vdpau.c b/mythtv/external/FFmpeg/fftools/ffmpeg_vdpau.c
deleted file mode 100644
index 7d4fbf8a379..00000000000
--- a/mythtv/external/FFmpeg/fftools/ffmpeg_vdpau.c
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * 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 <stdint.h>
-
-#include "ffmpeg.h"
-
-#include "libavcodec/vdpau.h"
-
-#include "libavutil/buffer.h"
-#include "libavutil/frame.h"
-#include "libavutil/hwcontext.h"
-#include "libavutil/hwcontext_vdpau.h"
-#include "libavutil/pixfmt.h"
-
-typedef struct VDPAUContext {
-    AVBufferRef *hw_frames_ctx;
-    AVFrame *tmp_frame;
-} VDPAUContext;
-
-static void vdpau_uninit(AVCodecContext *s)
-{
-    InputStream  *ist = s->opaque;
-    VDPAUContext *ctx = ist->hwaccel_ctx;
-
-    ist->hwaccel_uninit        = NULL;
-    ist->hwaccel_get_buffer    = NULL;
-    ist->hwaccel_retrieve_data = NULL;
-
-    av_buffer_unref(&ctx->hw_frames_ctx);
-    av_frame_free(&ctx->tmp_frame);
-
-    av_freep(&ist->hwaccel_ctx);
-    av_freep(&s->hwaccel_context);
-}
-
-static int vdpau_get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
-{
-    InputStream         *ist = s->opaque;
-    VDPAUContext        *ctx = ist->hwaccel_ctx;
-
-    return av_hwframe_get_buffer(ctx->hw_frames_ctx, frame, 0);
-}
-
-static int vdpau_retrieve_data(AVCodecContext *s, AVFrame *frame)
-{
-    InputStream        *ist = s->opaque;
-    VDPAUContext       *ctx = ist->hwaccel_ctx;
-    int ret;
-
-    ret = av_hwframe_transfer_data(ctx->tmp_frame, frame, 0);
-    if (ret < 0)
-        return ret;
-
-    ret = av_frame_copy_props(ctx->tmp_frame, frame);
-    if (ret < 0) {
-        av_frame_unref(ctx->tmp_frame);
-        return ret;
-    }
-
-    av_frame_unref(frame);
-    av_frame_move_ref(frame, ctx->tmp_frame);
-
-    return 0;
-}
-
-static int vdpau_alloc(AVCodecContext *s)
-{
-    InputStream  *ist = s->opaque;
-    int loglevel = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR;
-    VDPAUContext *ctx;
-    int ret;
-
-    AVBufferRef          *device_ref = NULL;
-    AVHWDeviceContext    *device_ctx;
-    AVVDPAUDeviceContext *device_hwctx;
-    AVHWFramesContext    *frames_ctx;
-
-    ctx = av_mallocz(sizeof(*ctx));
-    if (!ctx)
-        return AVERROR(ENOMEM);
-
-    ist->hwaccel_ctx           = ctx;
-    ist->hwaccel_uninit        = vdpau_uninit;
-    ist->hwaccel_get_buffer    = vdpau_get_buffer;
-    ist->hwaccel_retrieve_data = vdpau_retrieve_data;
-
-    ctx->tmp_frame = av_frame_alloc();
-    if (!ctx->tmp_frame)
-        goto fail;
-
-    ret = av_hwdevice_ctx_create(&device_ref, AV_HWDEVICE_TYPE_VDPAU,
-                                 ist->hwaccel_device, NULL, 0);
-    if (ret < 0)
-        goto fail;
-    device_ctx   = (AVHWDeviceContext*)device_ref->data;
-    device_hwctx = device_ctx->hwctx;
-
-    ctx->hw_frames_ctx = av_hwframe_ctx_alloc(device_ref);
-    if (!ctx->hw_frames_ctx)
-        goto fail;
-    av_buffer_unref(&device_ref);
-
-    frames_ctx            = (AVHWFramesContext*)ctx->hw_frames_ctx->data;
-    frames_ctx->format    = AV_PIX_FMT_VDPAU;
-    frames_ctx->sw_format = s->sw_pix_fmt;
-    frames_ctx->width     = s->coded_width;
-    frames_ctx->height    = s->coded_height;
-
-    ret = av_hwframe_ctx_init(ctx->hw_frames_ctx);
-    if (ret < 0)
-        goto fail;
-
-    if (av_vdpau_bind_context(s, device_hwctx->device, device_hwctx->get_proc_address, 0))
-        goto fail;
-
-    av_log(NULL, AV_LOG_VERBOSE, "Using VDPAU to decode input stream #%d:%d.\n",
-           ist->file_index, ist->st->index);
-
-    return 0;
-
-fail:
-    av_log(NULL, loglevel, "VDPAU init failed for stream #%d:%d.\n",
-           ist->file_index, ist->st->index);
-    av_buffer_unref(&device_ref);
-    vdpau_uninit(s);
-    return AVERROR(EINVAL);
-}
-
-int vdpau_init(AVCodecContext *s)
-{
-    InputStream *ist = s->opaque;
-
-    if (!ist->hwaccel_ctx) {
-        int ret = vdpau_alloc(s);
-        if (ret < 0)
-            return ret;
-    }
-
-    ist->hwaccel_get_buffer    = vdpau_get_buffer;
-    ist->hwaccel_retrieve_data = vdpau_retrieve_data;
-
-    return 0;
-}
diff --git a/mythtv/external/FFmpeg/fftools/ffmpeg_videotoolbox.c b/mythtv/external/FFmpeg/fftools/ffmpeg_videotoolbox.c
index 744a2a00093..e9039654b93 100644
--- a/mythtv/external/FFmpeg/fftools/ffmpeg_videotoolbox.c
+++ b/mythtv/external/FFmpeg/fftools/ffmpeg_videotoolbox.c
@@ -48,7 +48,6 @@ static int videotoolbox_retrieve_data(AVCodecContext *s, AVFrame *frame)
     uint8_t *data[4] = { 0 };
     int linesize[4] = { 0 };
     int planes, ret, i;
-    char codec_str[32];
 
     av_frame_unref(vt->tmp_frame);
 
@@ -60,9 +59,9 @@ static int videotoolbox_retrieve_data(AVCodecContext *s, AVFrame *frame)
     case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange: vt->tmp_frame->format = AV_PIX_FMT_NV12; break;
 #endif
     default:
-        av_get_codec_tag_string(codec_str, sizeof(codec_str), s->codec_tag);
         av_log(NULL, AV_LOG_ERROR,
-               "%s: Unsupported pixel format: %s\n", codec_str, videotoolbox_pixfmt);
+               "%s: Unsupported pixel format: %s\n",
+               av_fourcc2str(s->codec_tag), videotoolbox_pixfmt);
         return AVERROR(ENOSYS);
     }
 
diff --git a/mythtv/external/FFmpeg/fftools/ffplay.c b/mythtv/external/FFmpeg/fftools/ffplay.c
index 79dc76889e0..571dce31d21 100644
--- a/mythtv/external/FFmpeg/fftools/ffplay.c
+++ b/mythtv/external/FFmpeg/fftools/ffplay.c
@@ -73,8 +73,8 @@ const int program_birth_year = 2003;
 /* Calculate actual buffer size keeping in mind not cause too frequent audio callbacks */
 #define SDL_AUDIO_MAX_CALLBACKS_PER_SEC 30
 
-/* Step size for volume control */
-#define SDL_VOLUME_STEP (SDL_MIX_MAXVOLUME / 50)
+/* Step size for volume control in dB */
+#define SDL_VOLUME_STEP (0.75)
 
 /* no AV sync correction is done if below the minimum AV sync threshold */
 #define AV_SYNC_THRESHOLD_MIN 0.04
@@ -158,13 +158,12 @@ typedef struct Frame {
     double pts;           /* presentation timestamp for the frame */
     double duration;      /* estimated duration of the frame */
     int64_t pos;          /* byte position of the frame in the input file */
-    SDL_Texture *bmp;
-    int allocated;
     int width;
     int height;
     int format;
     AVRational sar;
     int uploaded;
+    int flip_v;
 } Frame;
 
 typedef struct FrameQueue {
@@ -188,7 +187,6 @@ enum {
 
 typedef struct Decoder {
     AVPacket pkt;
-    AVPacket pkt_temp;
     PacketQueue *queue;
     AVCodecContext *avctx;
     int pkt_serial;
@@ -273,6 +271,7 @@ typedef struct VideoState {
     double last_vis_time;
     SDL_Texture *vis_texture;
     SDL_Texture *sub_texture;
+    SDL_Texture *vid_texture;
 
     int subtitle_stream;
     AVStream *subtitle_st;
@@ -321,6 +320,8 @@ static int subtitle_disable;
 static const char* wanted_stream_spec[AVMEDIA_TYPE_NB] = {0};
 static int seek_by_bytes = -1;
 static int display_disable;
+static int borderless;
+static int startup_volume = 100;
 static int show_status = 1;
 static int av_sync_type = AV_SYNC_AUDIO_MASTER;
 static int64_t start_time = AV_NOPTS_VALUE;
@@ -348,6 +349,7 @@ static int nb_vfilters = 0;
 static char *afilters = NULL;
 #endif
 static int autorotate = 1;
+static int find_stream_info = 1;
 
 /* current context */
 static int is_full_screen;
@@ -355,11 +357,38 @@ static int64_t audio_callback_time;
 
 static AVPacket flush_pkt;
 
-#define FF_ALLOC_EVENT   (SDL_USEREVENT)
 #define FF_QUIT_EVENT    (SDL_USEREVENT + 2)
 
 static SDL_Window *window;
 static SDL_Renderer *renderer;
+static SDL_RendererInfo renderer_info = {0};
+static SDL_AudioDeviceID audio_dev;
+
+static const struct TextureFormatEntry {
+    enum AVPixelFormat format;
+    int texture_fmt;
+} sdl_texture_format_map[] = {
+    { AV_PIX_FMT_RGB8,           SDL_PIXELFORMAT_RGB332 },
+    { AV_PIX_FMT_RGB444,         SDL_PIXELFORMAT_RGB444 },
+    { AV_PIX_FMT_RGB555,         SDL_PIXELFORMAT_RGB555 },
+    { AV_PIX_FMT_BGR555,         SDL_PIXELFORMAT_BGR555 },
+    { AV_PIX_FMT_RGB565,         SDL_PIXELFORMAT_RGB565 },
+    { AV_PIX_FMT_BGR565,         SDL_PIXELFORMAT_BGR565 },
+    { AV_PIX_FMT_RGB24,          SDL_PIXELFORMAT_RGB24 },
+    { AV_PIX_FMT_BGR24,          SDL_PIXELFORMAT_BGR24 },
+    { AV_PIX_FMT_0RGB32,         SDL_PIXELFORMAT_RGB888 },
+    { AV_PIX_FMT_0BGR32,         SDL_PIXELFORMAT_BGR888 },
+    { AV_PIX_FMT_NE(RGB0, 0BGR), SDL_PIXELFORMAT_RGBX8888 },
+    { AV_PIX_FMT_NE(BGR0, 0RGB), SDL_PIXELFORMAT_BGRX8888 },
+    { AV_PIX_FMT_RGB32,          SDL_PIXELFORMAT_ARGB8888 },
+    { AV_PIX_FMT_RGB32_1,        SDL_PIXELFORMAT_RGBA8888 },
+    { AV_PIX_FMT_BGR32,          SDL_PIXELFORMAT_ABGR8888 },
+    { AV_PIX_FMT_BGR32_1,        SDL_PIXELFORMAT_BGRA8888 },
+    { AV_PIX_FMT_YUV420P,        SDL_PIXELFORMAT_IYUV },
+    { AV_PIX_FMT_YUYV422,        SDL_PIXELFORMAT_YUY2 },
+    { AV_PIX_FMT_UYVY422,        SDL_PIXELFORMAT_UYVY },
+    { AV_PIX_FMT_NONE,           SDL_PIXELFORMAT_UNKNOWN },
+};
 
 #if CONFIG_AVFILTER
 static int opt_add_vfilter(void *optctx, const char *opt, const char *arg)
@@ -390,8 +419,6 @@ int64_t get_valid_channel_layout(int64_t channel_layout, int channels)
         return 0;
 }
 
-static void free_picture(Frame *vp);
-
 static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
 {
     MyAVPacketList *pkt1;
@@ -552,88 +579,96 @@ static void decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue,
     d->queue = queue;
     d->empty_queue_cond = empty_queue_cond;
     d->start_pts = AV_NOPTS_VALUE;
+    d->pkt_serial = -1;
 }
 
 static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
-    int got_frame = 0;
-
-    do {
-        int ret = -1;
+    int ret = AVERROR(EAGAIN);
 
-        if (d->queue->abort_request)
-            return -1;
+    for (;;) {
+        AVPacket pkt;
 
-        if (!d->packet_pending || d->queue->serial != d->pkt_serial) {
-            AVPacket pkt;
+        if (d->queue->serial == d->pkt_serial) {
             do {
-                if (d->queue->nb_packets == 0)
-                    SDL_CondSignal(d->empty_queue_cond);
-                if (packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial) < 0)
+                if (d->queue->abort_request)
                     return -1;
-                if (pkt.data == flush_pkt.data) {
-                    avcodec_flush_buffers(d->avctx);
-                    d->finished = 0;
-                    d->next_pts = d->start_pts;
-                    d->next_pts_tb = d->start_pts_tb;
-                }
-            } while (pkt.data == flush_pkt.data || d->queue->serial != d->pkt_serial);
-            av_packet_unref(&d->pkt);
-            d->pkt_temp = d->pkt = pkt;
-            d->packet_pending = 1;
-        }
 
-        switch (d->avctx->codec_type) {
-            case AVMEDIA_TYPE_VIDEO:
-                ret = avcodec_decode_video2(d->avctx, frame, &got_frame, &d->pkt_temp);
-                if (got_frame) {
-                    if (decoder_reorder_pts == -1) {
-                        frame->pts = av_frame_get_best_effort_timestamp(frame);
-                    } else if (!decoder_reorder_pts) {
-                        frame->pts = frame->pkt_dts;
-                    }
+                switch (d->avctx->codec_type) {
+                    case AVMEDIA_TYPE_VIDEO:
+                        ret = avcodec_receive_frame(d->avctx, frame);
+                        if (ret >= 0) {
+                            if (decoder_reorder_pts == -1) {
+                                frame->pts = frame->best_effort_timestamp;
+                            } else if (!decoder_reorder_pts) {
+                                frame->pts = frame->pkt_dts;
+                            }
+                        }
+                        break;
+                    case AVMEDIA_TYPE_AUDIO:
+                        ret = avcodec_receive_frame(d->avctx, frame);
+                        if (ret >= 0) {
+                            AVRational tb = (AVRational){1, frame->sample_rate};
+                            if (frame->pts != AV_NOPTS_VALUE)
+                                frame->pts = av_rescale_q(frame->pts, av_codec_get_pkt_timebase(d->avctx), tb);
+                            else if (d->next_pts != AV_NOPTS_VALUE)
+                                frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
+                            if (frame->pts != AV_NOPTS_VALUE) {
+                                d->next_pts = frame->pts + frame->nb_samples;
+                                d->next_pts_tb = tb;
+                            }
+                        }
+                        break;
                 }
-                break;
-            case AVMEDIA_TYPE_AUDIO:
-                ret = avcodec_decode_audio4(d->avctx, frame, &got_frame, &d->pkt_temp);
-                if (got_frame) {
-                    AVRational tb = (AVRational){1, frame->sample_rate};
-                    if (frame->pts != AV_NOPTS_VALUE)
-                        frame->pts = av_rescale_q(frame->pts, av_codec_get_pkt_timebase(d->avctx), tb);
-                    else if (d->next_pts != AV_NOPTS_VALUE)
-                        frame->pts = av_rescale_q(d->next_pts, d->next_pts_tb, tb);
-                    if (frame->pts != AV_NOPTS_VALUE) {
-                        d->next_pts = frame->pts + frame->nb_samples;
-                        d->next_pts_tb = tb;
-                    }
+                if (ret == AVERROR_EOF) {
+                    d->finished = d->pkt_serial;
+                    avcodec_flush_buffers(d->avctx);
+                    return 0;
                 }
-                break;
-            case AVMEDIA_TYPE_SUBTITLE:
-                ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, &d->pkt_temp);
-                break;
+                if (ret >= 0)
+                    return 1;
+            } while (ret != AVERROR(EAGAIN));
         }
 
-        if (ret < 0) {
-            d->packet_pending = 0;
+        do {
+            if (d->queue->nb_packets == 0)
+                SDL_CondSignal(d->empty_queue_cond);
+            if (d->packet_pending) {
+                av_packet_move_ref(&pkt, &d->pkt);
+                d->packet_pending = 0;
+            } else {
+                if (packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial) < 0)
+                    return -1;
+            }
+        } while (d->queue->serial != d->pkt_serial);
+
+        if (pkt.data == flush_pkt.data) {
+            avcodec_flush_buffers(d->avctx);
+            d->finished = 0;
+            d->next_pts = d->start_pts;
+            d->next_pts_tb = d->start_pts_tb;
         } else {
-            d->pkt_temp.dts =
-            d->pkt_temp.pts = AV_NOPTS_VALUE;
-            if (d->pkt_temp.data) {
-                if (d->avctx->codec_type != AVMEDIA_TYPE_AUDIO)
-                    ret = d->pkt_temp.size;
-                d->pkt_temp.data += ret;
-                d->pkt_temp.size -= ret;
-                if (d->pkt_temp.size <= 0)
-                    d->packet_pending = 0;
+            if (d->avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
+                int got_frame = 0;
+                ret = avcodec_decode_subtitle2(d->avctx, sub, &got_frame, &pkt);
+                if (ret < 0) {
+                    ret = AVERROR(EAGAIN);
+                } else {
+                    if (got_frame && !pkt.data) {
+                       d->packet_pending = 1;
+                       av_packet_move_ref(&d->pkt, &pkt);
+                    }
+                    ret = got_frame ? 0 : (pkt.data ? AVERROR(EAGAIN) : AVERROR_EOF);
+                }
             } else {
-                if (!got_frame) {
-                    d->packet_pending = 0;
-                    d->finished = d->pkt_serial;
+                if (avcodec_send_packet(d->avctx, &pkt) == AVERROR(EAGAIN)) {
+                    av_log(d->avctx, AV_LOG_ERROR, "Receive_frame and send_packet both returned EAGAIN, which is an API violation.\n");
+                    d->packet_pending = 1;
+                    av_packet_move_ref(&d->pkt, &pkt);
                 }
             }
+            av_packet_unref(&pkt);
         }
-    } while (!got_frame && !d->finished);
-
-    return got_frame;
+    }
 }
 
 static void decoder_destroy(Decoder *d) {
@@ -675,7 +710,6 @@ static void frame_queue_destory(FrameQueue *f)
         Frame *vp = &f->queue[i];
         frame_queue_unref_item(vp);
         av_frame_free(&vp->frame);
-        free_picture(vp);
     }
     SDL_DestroyMutex(f->mutex);
     SDL_DestroyCond(f->cond);
@@ -796,14 +830,6 @@ static inline void fill_rectangle(int x, int y, int w, int h)
         SDL_RenderFillRect(renderer, &rect);
 }
 
-static void free_picture(Frame *vp)
-{
-     if (vp->bmp) {
-         SDL_DestroyTexture(vp->bmp);
-         vp->bmp = NULL;
-     }
-}
-
 static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_width, int new_height, SDL_BlendMode blendmode, int init_texture)
 {
     Uint32 format;
@@ -822,6 +848,7 @@ static int realloc_texture(SDL_Texture **texture, Uint32 new_format, int new_wid
             memset(pixels, 0, pitch * new_height);
             SDL_UnlockTexture(*texture);
         }
+        av_log(NULL, AV_LOG_VERBOSE, "Created %dx%d texture with %s.\n", new_width, new_height, SDL_GetPixelFormatName(new_format));
     }
     return 0;
 }
@@ -857,35 +884,71 @@ static void calculate_display_rect(SDL_Rect *rect,
     rect->h = FFMAX(height, 1);
 }
 
-static int upload_texture(SDL_Texture *tex, AVFrame *frame, struct SwsContext **img_convert_ctx) {
+static void get_sdl_pix_fmt_and_blendmode(int format, Uint32 *sdl_pix_fmt, SDL_BlendMode *sdl_blendmode)
+{
+    int i;
+    *sdl_blendmode = SDL_BLENDMODE_NONE;
+    *sdl_pix_fmt = SDL_PIXELFORMAT_UNKNOWN;
+    if (format == AV_PIX_FMT_RGB32   ||
+        format == AV_PIX_FMT_RGB32_1 ||
+        format == AV_PIX_FMT_BGR32   ||
+        format == AV_PIX_FMT_BGR32_1)
+        *sdl_blendmode = SDL_BLENDMODE_BLEND;
+    for (i = 0; i < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; i++) {
+        if (format == sdl_texture_format_map[i].format) {
+            *sdl_pix_fmt = sdl_texture_format_map[i].texture_fmt;
+            return;
+        }
+    }
+}
+
+static int upload_texture(SDL_Texture **tex, AVFrame *frame, struct SwsContext **img_convert_ctx) {
     int ret = 0;
-    switch (frame->format) {
-        case AV_PIX_FMT_YUV420P:
-            ret = SDL_UpdateYUVTexture(tex, NULL, frame->data[0], frame->linesize[0],
-                                                  frame->data[1], frame->linesize[1],
-                                                  frame->data[2], frame->linesize[2]);
-            break;
-        case AV_PIX_FMT_BGRA:
-            ret = SDL_UpdateTexture(tex, NULL, frame->data[0], frame->linesize[0]);
-            break;
-        default:
+    Uint32 sdl_pix_fmt;
+    SDL_BlendMode sdl_blendmode;
+    get_sdl_pix_fmt_and_blendmode(frame->format, &sdl_pix_fmt, &sdl_blendmode);
+    if (realloc_texture(tex, sdl_pix_fmt == SDL_PIXELFORMAT_UNKNOWN ? SDL_PIXELFORMAT_ARGB8888 : sdl_pix_fmt, frame->width, frame->height, sdl_blendmode, 0) < 0)
+        return -1;
+    switch (sdl_pix_fmt) {
+        case SDL_PIXELFORMAT_UNKNOWN:
             /* This should only happen if we are not using avfilter... */
             *img_convert_ctx = sws_getCachedContext(*img_convert_ctx,
                 frame->width, frame->height, frame->format, frame->width, frame->height,
                 AV_PIX_FMT_BGRA, sws_flags, NULL, NULL, NULL);
             if (*img_convert_ctx != NULL) {
-                uint8_t *pixels;
-                int pitch;
-                if (!SDL_LockTexture(tex, NULL, (void **)&pixels, &pitch)) {
+                uint8_t *pixels[4];
+                int pitch[4];
+                if (!SDL_LockTexture(*tex, NULL, (void **)pixels, pitch)) {
                     sws_scale(*img_convert_ctx, (const uint8_t * const *)frame->data, frame->linesize,
-                              0, frame->height, &pixels, &pitch);
-                    SDL_UnlockTexture(tex);
+                              0, frame->height, pixels, pitch);
+                    SDL_UnlockTexture(*tex);
                 }
             } else {
                 av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
                 ret = -1;
             }
             break;
+        case SDL_PIXELFORMAT_IYUV:
+            if (frame->linesize[0] > 0 && frame->linesize[1] > 0 && frame->linesize[2] > 0) {
+                ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0], frame->linesize[0],
+                                                       frame->data[1], frame->linesize[1],
+                                                       frame->data[2], frame->linesize[2]);
+            } else if (frame->linesize[0] < 0 && frame->linesize[1] < 0 && frame->linesize[2] < 0) {
+                ret = SDL_UpdateYUVTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height                    - 1), -frame->linesize[0],
+                                                       frame->data[1] + frame->linesize[1] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[1],
+                                                       frame->data[2] + frame->linesize[2] * (AV_CEIL_RSHIFT(frame->height, 1) - 1), -frame->linesize[2]);
+            } else {
+                av_log(NULL, AV_LOG_ERROR, "Mixed negative and positive linesizes are not supported.\n");
+                return -1;
+            }
+            break;
+        default:
+            if (frame->linesize[0] < 0) {
+                ret = SDL_UpdateTexture(*tex, NULL, frame->data[0] + frame->linesize[0] * (frame->height - 1), -frame->linesize[0]);
+            } else {
+                ret = SDL_UpdateTexture(*tex, NULL, frame->data[0], frame->linesize[0]);
+            }
+            break;
     }
     return ret;
 }
@@ -897,78 +960,77 @@ static void video_image_display(VideoState *is)
     SDL_Rect rect;
 
     vp = frame_queue_peek_last(&is->pictq);
-    if (vp->bmp) {
-        if (is->subtitle_st) {
-            if (frame_queue_nb_remaining(&is->subpq) > 0) {
-                sp = frame_queue_peek(&is->subpq);
-
-                if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
-                    if (!sp->uploaded) {
-                        uint8_t *pixels;
-                        int pitch;
-                        int i;
-                        if (!sp->width || !sp->height) {
-                            sp->width = vp->width;
-                            sp->height = vp->height;
-                        }
-                        if (realloc_texture(&is->sub_texture, SDL_PIXELFORMAT_ARGB8888, sp->width, sp->height, SDL_BLENDMODE_BLEND, 1) < 0)
+    if (is->subtitle_st) {
+        if (frame_queue_nb_remaining(&is->subpq) > 0) {
+            sp = frame_queue_peek(&is->subpq);
+
+            if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000)) {
+                if (!sp->uploaded) {
+                    uint8_t* pixels[4];
+                    int pitch[4];
+                    int i;
+                    if (!sp->width || !sp->height) {
+                        sp->width = vp->width;
+                        sp->height = vp->height;
+                    }
+                    if (realloc_texture(&is->sub_texture, SDL_PIXELFORMAT_ARGB8888, sp->width, sp->height, SDL_BLENDMODE_BLEND, 1) < 0)
+                        return;
+
+                    for (i = 0; i < sp->sub.num_rects; i++) {
+                        AVSubtitleRect *sub_rect = sp->sub.rects[i];
+
+                        sub_rect->x = av_clip(sub_rect->x, 0, sp->width );
+                        sub_rect->y = av_clip(sub_rect->y, 0, sp->height);
+                        sub_rect->w = av_clip(sub_rect->w, 0, sp->width  - sub_rect->x);
+                        sub_rect->h = av_clip(sub_rect->h, 0, sp->height - sub_rect->y);
+
+                        is->sub_convert_ctx = sws_getCachedContext(is->sub_convert_ctx,
+                            sub_rect->w, sub_rect->h, AV_PIX_FMT_PAL8,
+                            sub_rect->w, sub_rect->h, AV_PIX_FMT_BGRA,
+                            0, NULL, NULL, NULL);
+                        if (!is->sub_convert_ctx) {
+                            av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
                             return;
-
-                        for (i = 0; i < sp->sub.num_rects; i++) {
-                            AVSubtitleRect *sub_rect = sp->sub.rects[i];
-
-                            sub_rect->x = av_clip(sub_rect->x, 0, sp->width );
-                            sub_rect->y = av_clip(sub_rect->y, 0, sp->height);
-                            sub_rect->w = av_clip(sub_rect->w, 0, sp->width  - sub_rect->x);
-                            sub_rect->h = av_clip(sub_rect->h, 0, sp->height - sub_rect->y);
-
-                            is->sub_convert_ctx = sws_getCachedContext(is->sub_convert_ctx,
-                                sub_rect->w, sub_rect->h, AV_PIX_FMT_PAL8,
-                                sub_rect->w, sub_rect->h, AV_PIX_FMT_BGRA,
-                                0, NULL, NULL, NULL);
-                            if (!is->sub_convert_ctx) {
-                                av_log(NULL, AV_LOG_FATAL, "Cannot initialize the conversion context\n");
-                                return;
-                            }
-                            if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)&pixels, &pitch)) {
-                                sws_scale(is->sub_convert_ctx, (const uint8_t * const *)sub_rect->data, sub_rect->linesize,
-                                          0, sub_rect->h, &pixels, &pitch);
-                                SDL_UnlockTexture(is->sub_texture);
-                            }
                         }
-                        sp->uploaded = 1;
+                        if (!SDL_LockTexture(is->sub_texture, (SDL_Rect *)sub_rect, (void **)pixels, pitch)) {
+                            sws_scale(is->sub_convert_ctx, (const uint8_t * const *)sub_rect->data, sub_rect->linesize,
+                                      0, sub_rect->h, pixels, pitch);
+                            SDL_UnlockTexture(is->sub_texture);
+                        }
                     }
-                } else
-                    sp = NULL;
-            }
+                    sp->uploaded = 1;
+                }
+            } else
+                sp = NULL;
         }
+    }
 
-        calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar);
+    calculate_display_rect(&rect, is->xleft, is->ytop, is->width, is->height, vp->width, vp->height, vp->sar);
 
-        if (!vp->uploaded) {
-            if (upload_texture(vp->bmp, vp->frame, &is->img_convert_ctx) < 0)
-                return;
-            vp->uploaded = 1;
-        }
+    if (!vp->uploaded) {
+        if (upload_texture(&is->vid_texture, vp->frame, &is->img_convert_ctx) < 0)
+            return;
+        vp->uploaded = 1;
+        vp->flip_v = vp->frame->linesize[0] < 0;
+    }
 
-        SDL_RenderCopy(renderer, vp->bmp, NULL, &rect);
-        if (sp) {
+    SDL_RenderCopyEx(renderer, is->vid_texture, NULL, &rect, 0, NULL, vp->flip_v ? SDL_FLIP_VERTICAL : 0);
+    if (sp) {
 #if USE_ONEPASS_SUBTITLE_RENDER
-            SDL_RenderCopy(renderer, is->sub_texture, NULL, &rect);
+        SDL_RenderCopy(renderer, is->sub_texture, NULL, &rect);
 #else
-            int i;
-            double xratio = (double)rect.w / (double)sp->width;
-            double yratio = (double)rect.h / (double)sp->height;
-            for (i = 0; i < sp->sub.num_rects; i++) {
-                SDL_Rect *sub_rect = (SDL_Rect*)sp->sub.rects[i];
-                SDL_Rect target = {.x = rect.x + sub_rect->x * xratio,
-                                   .y = rect.y + sub_rect->y * yratio,
-                                   .w = sub_rect->w * xratio,
-                                   .h = sub_rect->h * yratio};
-                SDL_RenderCopy(renderer, is->sub_texture, sub_rect, &target);
-            }
-#endif
+        int i;
+        double xratio = (double)rect.w / (double)sp->width;
+        double yratio = (double)rect.h / (double)sp->height;
+        for (i = 0; i < sp->sub.num_rects; i++) {
+            SDL_Rect *sub_rect = (SDL_Rect*)sp->sub.rects[i];
+            SDL_Rect target = {.x = rect.x + sub_rect->x * xratio,
+                               .y = rect.y + sub_rect->y * yratio,
+                               .w = sub_rect->w * xratio,
+                               .h = sub_rect->h * yratio};
+            SDL_RenderCopy(renderer, is->sub_texture, sub_rect, &target);
         }
+#endif
     }
 }
 
@@ -1131,7 +1193,7 @@ static void stream_component_close(VideoState *is, int stream_index)
     switch (codecpar->codec_type) {
     case AVMEDIA_TYPE_AUDIO:
         decoder_abort(&is->auddec, &is->sampq);
-        SDL_CloseAudio();
+        SDL_CloseAudioDevice(audio_dev);
         decoder_destroy(&is->auddec);
         swr_free(&is->swr_ctx);
         av_freep(&is->audio_buf1);
@@ -1206,6 +1268,8 @@ static void stream_close(VideoState *is)
     av_free(is->filename);
     if (is->vis_texture)
         SDL_DestroyTexture(is->vis_texture);
+    if (is->vid_texture)
+        SDL_DestroyTexture(is->vid_texture);
     if (is->sub_texture)
         SDL_DestroyTexture(is->sub_texture);
     av_free(is);
@@ -1246,13 +1310,10 @@ static void set_default_window_size(int width, int height, AVRational sar)
     default_height = rect.h;
 }
 
-static int video_open(VideoState *is, Frame *vp)
+static int video_open(VideoState *is)
 {
     int w,h;
 
-    if (vp && vp->width)
-        set_default_window_size(vp->width, vp->height, vp->sar);
-
     if (screen_width) {
         w = screen_width;
         h = screen_height;
@@ -1261,30 +1322,15 @@ static int video_open(VideoState *is, Frame *vp)
         h = default_height;
     }
 
-    if (!window) {
-        int flags = SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE;
-        if (!window_title)
-            window_title = input_filename;
-        if (is_full_screen)
-            flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
-        window = SDL_CreateWindow(window_title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, w, h, flags);
-        SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
-        if (window) {
-            SDL_RendererInfo info;
-            renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
-            if (renderer) {
-                if (!SDL_GetRendererInfo(renderer, &info))
-                    av_log(NULL, AV_LOG_VERBOSE, "Initialized %s renderer.\n", info.name);
-            }
-        }
-    } else {
-        SDL_SetWindowSize(window, w, h);
-    }
+    if (!window_title)
+        window_title = input_filename;
+    SDL_SetWindowTitle(window, window_title);
 
-    if (!window || !renderer) {
-        av_log(NULL, AV_LOG_FATAL, "SDL: could not set video mode - exiting\n");
-        do_exit(is);
-    }
+    SDL_SetWindowSize(window, w, h);
+    SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+    if (is_full_screen)
+        SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
+    SDL_ShowWindow(window);
 
     is->width  = w;
     is->height = h;
@@ -1295,8 +1341,8 @@ static int video_open(VideoState *is, Frame *vp)
 /* display the current picture, if any */
 static void video_display(VideoState *is)
 {
-    if (!window)
-        video_open(is, NULL);
+    if (!is->width)
+        video_open(is);
 
     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
     SDL_RenderClear(renderer);
@@ -1443,9 +1489,11 @@ static void toggle_mute(VideoState *is)
     is->muted = !is->muted;
 }
 
-static void update_volume(VideoState *is, int sign, int step)
+static void update_volume(VideoState *is, int sign, double step)
 {
-    is->audio_volume = av_clip(is->audio_volume + sign * step, 0, SDL_MIX_MAXVOLUME);
+    double volume_level = is->audio_volume ? (20 * log(is->audio_volume / (double)SDL_MIX_MAXVOLUME) / log(10)) : -1000.0;
+    int new_volume = lrint(SDL_MIX_MAXVOLUME * pow(10.0, (volume_level + sign * step) / 20.0));
+    is->audio_volume = av_clip(is->audio_volume == new_volume ? (is->audio_volume + sign) : new_volume, 0, SDL_MIX_MAXVOLUME);
 }
 
 static void step_to_next_frame(VideoState *is)
@@ -1663,38 +1711,6 @@ static void video_refresh(void *opaque, double *remaining_time)
     }
 }
 
-/* allocate a picture (needs to do that in main thread to avoid
-   potential locking problems */
-static void alloc_picture(VideoState *is)
-{
-    Frame *vp;
-    int sdl_format;
-
-    vp = &is->pictq.queue[is->pictq.windex];
-
-    video_open(is, vp);
-
-    if (vp->format == AV_PIX_FMT_YUV420P)
-        sdl_format = SDL_PIXELFORMAT_YV12;
-    else
-        sdl_format = SDL_PIXELFORMAT_ARGB8888;
-
-    if (realloc_texture(&vp->bmp, sdl_format, vp->width, vp->height, SDL_BLENDMODE_NONE, 0) < 0) {
-        /* SDL allocates a buffer smaller than requested if the video
-         * overlay hardware is unable to support the requested size. */
-        av_log(NULL, AV_LOG_FATAL,
-               "Error: the video system does not support an image\n"
-                        "size of %dx%d pixels. Try using -lowres or -vf \"scale=w:h\"\n"
-                        "to reduce the image size.\n", vp->width, vp->height );
-        do_exit(is);
-    }
-
-    SDL_LockMutex(is->pictq.mutex);
-    vp->allocated = 1;
-    SDL_CondSignal(is->pictq.cond);
-    SDL_UnlockMutex(is->pictq.mutex);
-}
-
 static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double duration, int64_t pos, int serial)
 {
     Frame *vp;
@@ -1710,51 +1726,19 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts, double
     vp->sar = src_frame->sample_aspect_ratio;
     vp->uploaded = 0;
 
-    /* alloc or resize hardware picture buffer */
-    if (!vp->bmp || !vp->allocated ||
-        vp->width  != src_frame->width ||
-        vp->height != src_frame->height ||
-        vp->format != src_frame->format) {
-        SDL_Event event;
-
-        vp->allocated = 0;
-        vp->width = src_frame->width;
-        vp->height = src_frame->height;
-        vp->format = src_frame->format;
+    vp->width = src_frame->width;
+    vp->height = src_frame->height;
+    vp->format = src_frame->format;
 
-        /* the allocation must be done in the main thread to avoid
-           locking problems. */
-        event.type = FF_ALLOC_EVENT;
-        event.user.data1 = is;
-        SDL_PushEvent(&event);
-
-        /* wait until the picture is allocated */
-        SDL_LockMutex(is->pictq.mutex);
-        while (!vp->allocated && !is->videoq.abort_request) {
-            SDL_CondWait(is->pictq.cond, is->pictq.mutex);
-        }
-        /* if the queue is aborted, we have to pop the pending ALLOC event or wait for the allocation to complete */
-        if (is->videoq.abort_request && SDL_PeepEvents(&event, 1, SDL_GETEVENT, FF_ALLOC_EVENT, FF_ALLOC_EVENT) != 1) {
-            while (!vp->allocated && !is->abort_request) {
-                SDL_CondWait(is->pictq.cond, is->pictq.mutex);
-            }
-        }
-        SDL_UnlockMutex(is->pictq.mutex);
-
-        if (is->videoq.abort_request)
-            return -1;
-    }
+    vp->pts = pts;
+    vp->duration = duration;
+    vp->pos = pos;
+    vp->serial = serial;
 
-    /* if the frame is not skipped, then display it */
-    if (vp->bmp) {
-        vp->pts = pts;
-        vp->duration = duration;
-        vp->pos = pos;
-        vp->serial = serial;
+    set_default_window_size(vp->width, vp->height, vp->sar);
 
-        av_frame_move_ref(vp->frame, src_frame);
-        frame_queue_push(&is->pictq);
-    }
+    av_frame_move_ref(vp->frame, src_frame);
+    frame_queue_push(&is->pictq);
     return 0;
 }
 
@@ -1837,7 +1821,7 @@ static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
 
 static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters, AVFrame *frame)
 {
-    static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_BGRA, AV_PIX_FMT_NONE };
+    enum AVPixelFormat pix_fmts[FF_ARRAY_ELEMS(sdl_texture_format_map)];
     char sws_flags_str[512] = "";
     char buffersrc_args[256];
     int ret;
@@ -1845,6 +1829,18 @@ static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const c
     AVCodecParameters *codecpar = is->video_st->codecpar;
     AVRational fr = av_guess_frame_rate(is->ic, is->video_st, NULL);
     AVDictionaryEntry *e = NULL;
+    int nb_pix_fmts = 0;
+    int i, j;
+
+    for (i = 0; i < renderer_info.num_texture_formats; i++) {
+        for (j = 0; j < FF_ARRAY_ELEMS(sdl_texture_format_map) - 1; j++) {
+            if (renderer_info.texture_formats[i] == sdl_texture_format_map[j].texture_fmt) {
+                pix_fmts[nb_pix_fmts++] = sdl_texture_format_map[j].format;
+                break;
+            }
+        }
+    }
+    pix_fmts[nb_pix_fmts] = AV_PIX_FMT_NONE;
 
     while ((e = av_dict_get(sws_dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
         if (!strcmp(e->key, "sws_flags")) {
@@ -2029,11 +2025,11 @@ static int audio_thread(void *arg)
                 tb = (AVRational){1, frame->sample_rate};
 
 #if CONFIG_AVFILTER
-                dec_channel_layout = get_valid_channel_layout(frame->channel_layout, av_frame_get_channels(frame));
+                dec_channel_layout = get_valid_channel_layout(frame->channel_layout, frame->channels);
 
                 reconfigure =
                     cmp_audio_fmts(is->audio_filter_src.fmt, is->audio_filter_src.channels,
-                                   frame->format, av_frame_get_channels(frame))    ||
+                                   frame->format, frame->channels)    ||
                     is->audio_filter_src.channel_layout != dec_channel_layout ||
                     is->audio_filter_src.freq           != frame->sample_rate ||
                     is->auddec.pkt_serial               != last_serial;
@@ -2045,10 +2041,10 @@ static int audio_thread(void *arg)
                     av_log(NULL, AV_LOG_DEBUG,
                            "Audio frame changed from rate:%d ch:%d fmt:%s layout:%s serial:%d to rate:%d ch:%d fmt:%s layout:%s serial:%d\n",
                            is->audio_filter_src.freq, is->audio_filter_src.channels, av_get_sample_fmt_name(is->audio_filter_src.fmt), buf1, last_serial,
-                           frame->sample_rate, av_frame_get_channels(frame), av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
+                           frame->sample_rate, frame->channels, av_get_sample_fmt_name(frame->format), buf2, is->auddec.pkt_serial);
 
                     is->audio_filter_src.fmt            = frame->format;
-                    is->audio_filter_src.channels       = av_frame_get_channels(frame);
+                    is->audio_filter_src.channels       = frame->channels;
                     is->audio_filter_src.channel_layout = dec_channel_layout;
                     is->audio_filter_src.freq           = frame->sample_rate;
                     last_serial                         = is->auddec.pkt_serial;
@@ -2061,13 +2057,13 @@ static int audio_thread(void *arg)
                 goto the_end;
 
             while ((ret = av_buffersink_get_frame_flags(is->out_audio_filter, frame, 0)) >= 0) {
-                tb = is->out_audio_filter->inputs[0]->time_base;
+                tb = av_buffersink_get_time_base(is->out_audio_filter);
 #endif
                 if (!(af = frame_queue_peek_writable(&is->sampq)))
                     goto the_end;
 
                 af->pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
-                af->pos = av_frame_get_pkt_pos(frame);
+                af->pos = frame->pkt_pos;
                 af->serial = is->auddec.pkt_serial;
                 af->duration = av_q2d((AVRational){frame->nb_samples, frame->sample_rate});
 
@@ -2169,7 +2165,7 @@ static int video_thread(void *arg)
             last_format = frame->format;
             last_serial = is->viddec.pkt_serial;
             last_vfilter_idx = is->vfilter_idx;
-            frame_rate = filt_out->inputs[0]->frame_rate;
+            frame_rate = av_buffersink_get_frame_rate(filt_out);
         }
 
         ret = av_buffersrc_add_frame(filt_in, frame);
@@ -2190,11 +2186,11 @@ static int video_thread(void *arg)
             is->frame_last_filter_delay = av_gettime_relative() / 1000000.0 - is->frame_last_returned_time;
             if (fabs(is->frame_last_filter_delay) > AV_NOSYNC_THRESHOLD / 10.0)
                 is->frame_last_filter_delay = 0;
-            tb = filt_out->inputs[0]->time_base;
+            tb = av_buffersink_get_time_base(filt_out);
 #endif
             duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
             pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
-            ret = queue_picture(is, frame, pts, duration, av_frame_get_pkt_pos(frame), is->viddec.pkt_serial);
+            ret = queue_picture(is, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial);
             av_frame_unref(frame);
 #if CONFIG_AVFILTER
         }
@@ -2338,13 +2334,13 @@ static int audio_decode_frame(VideoState *is)
         frame_queue_next(&is->sampq);
     } while (af->serial != is->audioq.serial);
 
-    data_size = av_samples_get_buffer_size(NULL, av_frame_get_channels(af->frame),
+    data_size = av_samples_get_buffer_size(NULL, af->frame->channels,
                                            af->frame->nb_samples,
                                            af->frame->format, 1);
 
     dec_channel_layout =
-        (af->frame->channel_layout && av_frame_get_channels(af->frame) == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
-        af->frame->channel_layout : av_get_default_channel_layout(av_frame_get_channels(af->frame));
+        (af->frame->channel_layout && af->frame->channels == av_get_channel_layout_nb_channels(af->frame->channel_layout)) ?
+        af->frame->channel_layout : av_get_default_channel_layout(af->frame->channels);
     wanted_nb_samples = synchronize_audio(is, af->frame->nb_samples);
 
     if (af->frame->format        != is->audio_src.fmt            ||
@@ -2359,13 +2355,13 @@ static int audio_decode_frame(VideoState *is)
         if (!is->swr_ctx || swr_init(is->swr_ctx) < 0) {
             av_log(NULL, AV_LOG_ERROR,
                    "Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
-                    af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), av_frame_get_channels(af->frame),
+                    af->frame->sample_rate, av_get_sample_fmt_name(af->frame->format), af->frame->channels,
                     is->audio_tgt.freq, av_get_sample_fmt_name(is->audio_tgt.fmt), is->audio_tgt.channels);
             swr_free(&is->swr_ctx);
             return -1;
         }
         is->audio_src.channel_layout = dec_channel_layout;
-        is->audio_src.channels       = av_frame_get_channels(af->frame);
+        is->audio_src.channels       = af->frame->channels;
         is->audio_src.freq = af->frame->sample_rate;
         is->audio_src.fmt = af->frame->format;
     }
@@ -2456,7 +2452,7 @@ static void sdl_audio_callback(void *opaque, Uint8 *stream, int len)
         else {
             memset(stream, 0, len1);
             if (!is->muted && is->audio_buf)
-                SDL_MixAudio(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, len1, is->audio_volume);
+                SDL_MixAudioFormat(stream, (uint8_t *)is->audio_buf + is->audio_buf_index, AUDIO_S16SYS, len1, is->audio_volume);
         }
         len -= len1;
         stream += len1;
@@ -2501,7 +2497,7 @@ static int audio_open(void *opaque, int64_t wanted_channel_layout, int wanted_nb
     wanted_spec.samples = FFMAX(SDL_AUDIO_MIN_BUFFER_SIZE, 2 << av_log2(wanted_spec.freq / SDL_AUDIO_MAX_CALLBACKS_PER_SEC));
     wanted_spec.callback = sdl_audio_callback;
     wanted_spec.userdata = opaque;
-    while (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
+    while (!(audio_dev = SDL_OpenAudioDevice(NULL, 0, &wanted_spec, &spec, SDL_AUDIO_ALLOW_FREQUENCY_CHANGE | SDL_AUDIO_ALLOW_CHANNELS_CHANGE))) {
         av_log(NULL, AV_LOG_WARNING, "SDL_OpenAudio (%d channels, %d Hz): %s\n",
                wanted_spec.channels, wanted_spec.freq, SDL_GetError());
         wanted_spec.channels = next_nb_channels[FFMIN(7, wanted_spec.channels)];
@@ -2627,7 +2623,7 @@ static int stream_component_open(VideoState *is, int stream_index)
     case AVMEDIA_TYPE_AUDIO:
 #if CONFIG_AVFILTER
         {
-            AVFilterLink *link;
+            AVFilterContext *sink;
 
             is->audio_filter_src.freq           = avctx->sample_rate;
             is->audio_filter_src.channels       = avctx->channels;
@@ -2635,10 +2631,10 @@ static int stream_component_open(VideoState *is, int stream_index)
             is->audio_filter_src.fmt            = avctx->sample_fmt;
             if ((ret = configure_audio_filters(is, afilters, 0)) < 0)
                 goto fail;
-            link = is->out_audio_filter->inputs[0];
-            sample_rate    = link->sample_rate;
-            nb_channels    = avfilter_link_get_channels(link);
-            channel_layout = link->channel_layout;
+            sink = is->out_audio_filter;
+            sample_rate    = av_buffersink_get_sample_rate(sink);
+            nb_channels    = av_buffersink_get_channels(sink);
+            channel_layout = av_buffersink_get_channel_layout(sink);
         }
 #else
         sample_rate    = avctx->sample_rate;
@@ -2671,7 +2667,7 @@ static int stream_component_open(VideoState *is, int stream_index)
         }
         if ((ret = decoder_start(&is->auddec, audio_thread, is)) < 0)
             goto out;
-        SDL_PauseAudio(0);
+        SDL_PauseAudioDevice(audio_dev, 0);
         break;
     case AVMEDIA_TYPE_VIDEO:
         is->video_stream = stream_index;
@@ -2743,8 +2739,6 @@ static int read_thread(void *arg)
     int64_t stream_start_time;
     int pkt_in_play_range = 0;
     AVDictionaryEntry *t;
-    AVDictionary **opts;
-    int orig_nb_streams;
     SDL_mutex *wait_mutex = SDL_CreateMutex();
     int scan_all_pmts_set = 0;
     int64_t pkt_ts;
@@ -2794,20 +2788,22 @@ static int read_thread(void *arg)
 
     av_format_inject_global_side_data(ic);
 
-    opts = setup_find_stream_info_opts(ic, codec_opts);
-    orig_nb_streams = ic->nb_streams;
+    if (find_stream_info) {
+        AVDictionary **opts = setup_find_stream_info_opts(ic, codec_opts);
+        int orig_nb_streams = ic->nb_streams;
 
-    err = avformat_find_stream_info(ic, opts);
+        err = avformat_find_stream_info(ic, opts);
 
-    for (i = 0; i < orig_nb_streams; i++)
-        av_dict_free(&opts[i]);
-    av_freep(&opts);
+        for (i = 0; i < orig_nb_streams; i++)
+            av_dict_free(&opts[i]);
+        av_freep(&opts);
 
-    if (err < 0) {
-        av_log(NULL, AV_LOG_WARNING,
-               "%s: could not find codec parameters\n", is->filename);
-        ret = -1;
-        goto fail;
+        if (err < 0) {
+            av_log(NULL, AV_LOG_WARNING,
+                   "%s: could not find codec parameters\n", is->filename);
+            ret = -1;
+            goto fail;
+        }
     }
 
     if (ic->pb)
@@ -2968,8 +2964,8 @@ static int read_thread(void *arg)
         }
         if (is->queue_attachments_req) {
             if (is->video_st && is->video_st->disposition & AV_DISPOSITION_ATTACHED_PIC) {
-                AVPacket copy;
-                if ((ret = av_copy_packet(&copy, &is->video_st->attached_pic)) < 0)
+                AVPacket copy = { 0 };
+                if ((ret = av_packet_ref(&copy, &is->video_st->attached_pic)) < 0)
                     goto fail;
                 packet_queue_put(&is->videoq, &copy);
                 packet_queue_put_nullpacket(&is->videoq, is->video_stream);
@@ -3091,7 +3087,13 @@ static VideoState *stream_open(const char *filename, AVInputFormat *iformat)
     init_clock(&is->audclk, &is->audioq.serial);
     init_clock(&is->extclk, &is->extclk.serial);
     is->audio_clock_serial = -1;
-    is->audio_volume = SDL_MIX_MAXVOLUME;
+    if (startup_volume < 0)
+        av_log(NULL, AV_LOG_WARNING, "-volume=%d < 0, setting to 0\n", startup_volume);
+    if (startup_volume > 100)
+        av_log(NULL, AV_LOG_WARNING, "-volume=%d > 100, setting to 100\n", startup_volume);
+    startup_volume = av_clip(startup_volume, 0, 100);
+    startup_volume = av_clip(SDL_MIX_MAXVOLUME * startup_volume / 100, 0, SDL_MIX_MAXVOLUME);
+    is->audio_volume = startup_volume;
     is->muted = 0;
     is->av_sync_type = av_sync_type;
     is->read_tid     = SDL_CreateThread(read_thread, "read_thread", is);
@@ -3440,9 +3442,6 @@ static void event_loop(VideoState *cur_stream)
         case FF_QUIT_EVENT:
             do_exit(cur_stream);
             break;
-        case FF_ALLOC_EVENT:
-            alloc_picture(event.user.data1);
-            break;
         default:
             break;
         }
@@ -3557,7 +3556,7 @@ static int opt_codec(void *optctx, const char *opt, const char *arg)
 static int dummy;
 
 static const OptionDef options[] = {
-#include "cmdutils_common_opts.h"
+    CMDUTILS_COMMON_OPTIONS
     { "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
     { "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
     { "s", HAS_ARG | OPT_VIDEO, { .func_arg = opt_frame_size }, "set frame size (WxH or abbreviation)", "size" },
@@ -3572,6 +3571,8 @@ static const OptionDef options[] = {
     { "t", HAS_ARG, { .func_arg = opt_duration }, "play  \"duration\" seconds of audio/video", "duration" },
     { "bytes", OPT_INT | HAS_ARG, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
     { "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" },
+    { "noborder", OPT_BOOL, { &borderless }, "borderless window" },
+    { "volume", OPT_INT | HAS_ARG, { &startup_volume}, "set startup volume 0=min 100=max", "volume" },
     { "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_frame_pix_fmt }, "set pixel format", "format" },
     { "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" },
@@ -3600,6 +3601,8 @@ static const OptionDef options[] = {
     { "scodec", HAS_ARG | OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
     { "vcodec", HAS_ARG | OPT_STRING | OPT_EXPERT, {    &video_codec_name }, "force video decoder",    "decoder_name" },
     { "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" },
+    { "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
+        "read and decode the streams to fill missing information with heuristics" },
     { NULL, },
 };
 
@@ -3735,6 +3738,31 @@ int main(int argc, char **argv)
     av_init_packet(&flush_pkt);
     flush_pkt.data = (uint8_t *)&flush_pkt;
 
+    if (!display_disable) {
+        int flags = SDL_WINDOW_HIDDEN;
+        if (borderless)
+            flags |= SDL_WINDOW_BORDERLESS;
+        else
+            flags |= SDL_WINDOW_RESIZABLE;
+        window = SDL_CreateWindow(program_name, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, default_width, default_height, flags);
+        SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
+        if (window) {
+            renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
+            if (!renderer) {
+                av_log(NULL, AV_LOG_WARNING, "Failed to initialize a hardware accelerated renderer: %s\n", SDL_GetError());
+                renderer = SDL_CreateRenderer(window, -1, 0);
+            }
+            if (renderer) {
+                if (!SDL_GetRendererInfo(renderer, &renderer_info))
+                    av_log(NULL, AV_LOG_VERBOSE, "Initialized %s renderer.\n", renderer_info.name);
+            }
+        }
+        if (!window || !renderer || !renderer_info.num_texture_formats) {
+            av_log(NULL, AV_LOG_FATAL, "Failed to create window or renderer: %s", SDL_GetError());
+            do_exit(NULL);
+        }
+    }
+
     is = stream_open(input_filename, file_iformat);
     if (!is) {
         av_log(NULL, AV_LOG_FATAL, "Failed to initialize VideoState!\n");
diff --git a/mythtv/external/FFmpeg/fftools/ffprobe.c b/mythtv/external/FFmpeg/fftools/ffprobe.c
index a2980b338c4..b2e8949d9f9 100644
--- a/mythtv/external/FFmpeg/fftools/ffprobe.c
+++ b/mythtv/external/FFmpeg/fftools/ffprobe.c
@@ -35,8 +35,10 @@
 #include "libavutil/bprint.h"
 #include "libavutil/display.h"
 #include "libavutil/hash.h"
+#include "libavutil/mastering_display_metadata.h"
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
+#include "libavutil/spherical.h"
 #include "libavutil/stereo3d.h"
 #include "libavutil/dict.h"
 #include "libavutil/intreadwrite.h"
@@ -50,6 +52,19 @@
 #include "libpostproc/postprocess.h"
 #include "cmdutils.h"
 
+#include "libavutil/thread.h"
+
+#if !HAVE_THREADS
+#  ifdef pthread_mutex_lock
+#    undef pthread_mutex_lock
+#  endif
+#  define pthread_mutex_lock(a) do{}while(0)
+#  ifdef pthread_mutex_unlock
+#    undef pthread_mutex_unlock
+#  endif
+#  define pthread_mutex_unlock(a) do{}while(0)
+#endif
+
 typedef struct InputStream {
     AVStream *st;
 
@@ -85,6 +100,7 @@ static int do_show_library_versions = 0;
 static int do_show_pixel_formats = 0;
 static int do_show_pixel_format_flags = 0;
 static int do_show_pixel_format_components = 0;
+static int do_show_log = 0;
 
 static int do_show_chapter_tags = 0;
 static int do_show_format_tags = 0;
@@ -114,6 +130,8 @@ typedef struct ReadInterval {
 static ReadInterval *read_intervals;
 static int read_intervals_nb = 0;
 
+static int find_stream_info  = 1;
+
 /* section structure definition */
 
 #define SECTION_MAX_NB_CHILDREN 10
@@ -147,6 +165,8 @@ typedef enum {
     SECTION_ID_FRAME_TAGS,
     SECTION_ID_FRAME_SIDE_DATA_LIST,
     SECTION_ID_FRAME_SIDE_DATA,
+    SECTION_ID_FRAME_LOG,
+    SECTION_ID_FRAME_LOGS,
     SECTION_ID_LIBRARY_VERSION,
     SECTION_ID_LIBRARY_VERSIONS,
     SECTION_ID_PACKET,
@@ -186,17 +206,19 @@ static struct section sections[] = {
     [SECTION_ID_FORMAT] =             { SECTION_ID_FORMAT, "format", 0, { SECTION_ID_FORMAT_TAGS, -1 } },
     [SECTION_ID_FORMAT_TAGS] =        { SECTION_ID_FORMAT_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "format_tags" },
     [SECTION_ID_FRAMES] =             { SECTION_ID_FRAMES, "frames", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME, SECTION_ID_SUBTITLE, -1 } },
-    [SECTION_ID_FRAME] =              { SECTION_ID_FRAME, "frame", 0, { SECTION_ID_FRAME_TAGS, SECTION_ID_FRAME_SIDE_DATA_LIST, -1 } },
+    [SECTION_ID_FRAME] =              { SECTION_ID_FRAME, "frame", 0, { SECTION_ID_FRAME_TAGS, SECTION_ID_FRAME_SIDE_DATA_LIST, SECTION_ID_FRAME_LOGS, -1 } },
     [SECTION_ID_FRAME_TAGS] =         { SECTION_ID_FRAME_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "frame_tags" },
-    [SECTION_ID_FRAME_SIDE_DATA_LIST] ={ SECTION_ID_FRAME_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA, -1 } },
+    [SECTION_ID_FRAME_SIDE_DATA_LIST] ={ SECTION_ID_FRAME_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "frame_side_data_list" },
     [SECTION_ID_FRAME_SIDE_DATA] =     { SECTION_ID_FRAME_SIDE_DATA, "side_data", 0, { -1 } },
+    [SECTION_ID_FRAME_LOGS] =         { SECTION_ID_FRAME_LOGS, "logs", SECTION_FLAG_IS_ARRAY, { SECTION_ID_FRAME_LOG, -1 } },
+    [SECTION_ID_FRAME_LOG] =          { SECTION_ID_FRAME_LOG, "log", 0, { -1 },  },
     [SECTION_ID_LIBRARY_VERSIONS] =   { SECTION_ID_LIBRARY_VERSIONS, "library_versions", SECTION_FLAG_IS_ARRAY, { SECTION_ID_LIBRARY_VERSION, -1 } },
     [SECTION_ID_LIBRARY_VERSION] =    { SECTION_ID_LIBRARY_VERSION, "library_version", 0, { -1 } },
     [SECTION_ID_PACKETS] =            { SECTION_ID_PACKETS, "packets", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} },
     [SECTION_ID_PACKETS_AND_FRAMES] = { SECTION_ID_PACKETS_AND_FRAMES, "packets_and_frames", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET, -1} },
     [SECTION_ID_PACKET] =             { SECTION_ID_PACKET, "packet", 0, { SECTION_ID_PACKET_TAGS, SECTION_ID_PACKET_SIDE_DATA_LIST, -1 } },
     [SECTION_ID_PACKET_TAGS] =        { SECTION_ID_PACKET_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "packet_tags" },
-    [SECTION_ID_PACKET_SIDE_DATA_LIST] ={ SECTION_ID_PACKET_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET_SIDE_DATA, -1 } },
+    [SECTION_ID_PACKET_SIDE_DATA_LIST] ={ SECTION_ID_PACKET_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PACKET_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "packet_side_data_list" },
     [SECTION_ID_PACKET_SIDE_DATA] =     { SECTION_ID_PACKET_SIDE_DATA, "side_data", 0, { -1 } },
     [SECTION_ID_PIXEL_FORMATS] =      { SECTION_ID_PIXEL_FORMATS, "pixel_formats", SECTION_FLAG_IS_ARRAY, { SECTION_ID_PIXEL_FORMAT, -1 } },
     [SECTION_ID_PIXEL_FORMAT] =       { SECTION_ID_PIXEL_FORMAT, "pixel_format", 0, { SECTION_ID_PIXEL_FORMAT_FLAGS, SECTION_ID_PIXEL_FORMAT_COMPONENTS, -1 } },
@@ -219,7 +241,7 @@ static struct section sections[] = {
     [SECTION_ID_STREAM] =             { SECTION_ID_STREAM, "stream", 0, { SECTION_ID_STREAM_DISPOSITION, SECTION_ID_STREAM_TAGS, SECTION_ID_STREAM_SIDE_DATA_LIST, -1 } },
     [SECTION_ID_STREAM_DISPOSITION] = { SECTION_ID_STREAM_DISPOSITION, "disposition", 0, { -1 }, .unique_name = "stream_disposition" },
     [SECTION_ID_STREAM_TAGS] =        { SECTION_ID_STREAM_TAGS, "tags", SECTION_FLAG_HAS_VARIABLE_FIELDS, { -1 }, .element_name = "tag", .unique_name = "stream_tags" },
-    [SECTION_ID_STREAM_SIDE_DATA_LIST] ={ SECTION_ID_STREAM_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_SIDE_DATA, -1 } },
+    [SECTION_ID_STREAM_SIDE_DATA_LIST] ={ SECTION_ID_STREAM_SIDE_DATA_LIST, "side_data_list", SECTION_FLAG_IS_ARRAY, { SECTION_ID_STREAM_SIDE_DATA, -1 }, .element_name = "side_data", .unique_name = "stream_side_data_list" },
     [SECTION_ID_STREAM_SIDE_DATA] =     { SECTION_ID_STREAM_SIDE_DATA, "side_data", 0, { -1 } },
     [SECTION_ID_SUBTITLE] =           { SECTION_ID_SUBTITLE, "subtitle", 0, { -1 } },
 };
@@ -256,11 +278,79 @@ static uint64_t *nb_streams_packets;
 static uint64_t *nb_streams_frames;
 static int *selected_streams;
 
+#if HAVE_THREADS
+pthread_mutex_t log_mutex;
+#endif
+typedef struct LogBuffer {
+    char *context_name;
+    int log_level;
+    char *log_message;
+    AVClassCategory category;
+    char *parent_name;
+    AVClassCategory parent_category;
+}LogBuffer;
+
+static LogBuffer *log_buffer;
+static int log_buffer_size;
+
+static void log_callback(void *ptr, int level, const char *fmt, va_list vl)
+{
+    AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
+    va_list vl2;
+    char line[1024];
+    static int print_prefix = 1;
+    void *new_log_buffer;
+
+    va_copy(vl2, vl);
+    av_log_default_callback(ptr, level, fmt, vl);
+    av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
+    va_end(vl2);
+
+#if HAVE_THREADS
+    pthread_mutex_lock(&log_mutex);
+
+    new_log_buffer = av_realloc_array(log_buffer, log_buffer_size + 1, sizeof(*log_buffer));
+    if (new_log_buffer) {
+        char *msg;
+        int i;
+
+        log_buffer = new_log_buffer;
+        memset(&log_buffer[log_buffer_size], 0, sizeof(log_buffer[log_buffer_size]));
+        log_buffer[log_buffer_size].context_name= avc ? av_strdup(avc->item_name(ptr)) : NULL;
+        if (avc) {
+            if (avc->get_category) log_buffer[log_buffer_size].category = avc->get_category(ptr);
+            else                   log_buffer[log_buffer_size].category = avc->category;
+        }
+        log_buffer[log_buffer_size].log_level   = level;
+        msg = log_buffer[log_buffer_size].log_message = av_strdup(line);
+        for (i=strlen(msg) - 1; i>=0 && msg[i] == '\n'; i--) {
+            msg[i] = 0;
+        }
+        if (avc && avc->parent_log_context_offset) {
+            AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) +
+                                   avc->parent_log_context_offset);
+            if (parent && *parent) {
+                log_buffer[log_buffer_size].parent_name = av_strdup((*parent)->item_name(parent));
+                log_buffer[log_buffer_size].parent_category =
+                    (*parent)->get_category ? (*parent)->get_category(parent) :(*parent)->category;
+            }
+        }
+        log_buffer_size ++;
+    }
+
+    pthread_mutex_unlock(&log_mutex);
+#endif
+}
+
 static void ffprobe_cleanup(int ret)
 {
     int i;
     for (i = 0; i < FF_ARRAY_ELEMS(sections); i++)
         av_dict_free(&(sections[i].entries_to_show));
+
+#if HAVE_THREADS
+    pthread_mutex_destroy(&log_mutex);
+#endif
 }
 
 struct unit_value {
@@ -1761,6 +1851,7 @@ static inline int show_tags(WriterContext *w, AVDictionary *tags, int section_id
 }
 
 static void print_pkt_side_data(WriterContext *w,
+                                AVCodecParameters *par,
                                 const AVPacketSideData *side_data,
                                 int nb_side_data,
                                 SectionID id_data_list,
@@ -1768,14 +1859,13 @@ static void print_pkt_side_data(WriterContext *w,
 {
     int i;
 
-    writer_print_section_header(w, SECTION_ID_STREAM_SIDE_DATA_LIST);
+    writer_print_section_header(w, id_data_list);
     for (i = 0; i < nb_side_data; i++) {
         const AVPacketSideData *sd = &side_data[i];
         const char *name = av_packet_side_data_name(sd->type);
 
-        writer_print_section_header(w, SECTION_ID_STREAM_SIDE_DATA);
+        writer_print_section_header(w, id_data);
         print_str("side_data_type", name ? name : "unknown");
-        print_int("side_data_size", sd->size);
         if (sd->type == AV_PKT_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
             writer_print_integers(w, "displaymatrix", sd->data, 9, " %11d", 3, 4, 1);
             print_int("rotation", av_display_rotation_get((int32_t *)sd->data));
@@ -1783,12 +1873,160 @@ static void print_pkt_side_data(WriterContext *w,
             const AVStereo3D *stereo = (AVStereo3D *)sd->data;
             print_str("type", av_stereo3d_type_name(stereo->type));
             print_int("inverted", !!(stereo->flags & AV_STEREO3D_FLAG_INVERT));
+        } else if (sd->type == AV_PKT_DATA_SPHERICAL) {
+            const AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
+            print_str("projection", av_spherical_projection_name(spherical->projection));
+            if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
+                print_int("padding", spherical->padding);
+            } else if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
+                size_t l, t, r, b;
+                av_spherical_tile_bounds(spherical, par->width, par->height,
+                                         &l, &t, &r, &b);
+                print_int("bound_left", l);
+                print_int("bound_top", t);
+                print_int("bound_right", r);
+                print_int("bound_bottom", b);
+            }
+
+            print_int("yaw", (double) spherical->yaw / (1 << 16));
+            print_int("pitch", (double) spherical->pitch / (1 << 16));
+            print_int("roll", (double) spherical->roll / (1 << 16));
+        } else if (sd->type == AV_PKT_DATA_SKIP_SAMPLES && sd->size == 10) {
+            print_int("skip_samples",    AV_RL32(sd->data));
+            print_int("discard_padding", AV_RL32(sd->data + 4));
+            print_int("skip_reason",     AV_RL8(sd->data + 8));
+            print_int("discard_reason",  AV_RL8(sd->data + 9));
+        } else if (sd->type == AV_PKT_DATA_MASTERING_DISPLAY_METADATA) {
+            AVMasteringDisplayMetadata *metadata = (AVMasteringDisplayMetadata *)sd->data;
+
+            if (metadata->has_primaries) {
+                print_q("red_x", metadata->display_primaries[0][0], '/');
+                print_q("red_y", metadata->display_primaries[0][1], '/');
+                print_q("green_x", metadata->display_primaries[1][0], '/');
+                print_q("green_y", metadata->display_primaries[1][1], '/');
+                print_q("blue_x", metadata->display_primaries[2][0], '/');
+                print_q("blue_y", metadata->display_primaries[2][1], '/');
+
+                print_q("white_point_x", metadata->white_point[0], '/');
+                print_q("white_point_y", metadata->white_point[1], '/');
+            }
+
+            if (metadata->has_luminance) {
+                print_q("min_luminance", metadata->min_luminance, '/');
+                print_q("max_luminance", metadata->max_luminance, '/');
+            }
+        } else if (sd->type == AV_PKT_DATA_CONTENT_LIGHT_LEVEL) {
+            AVContentLightMetadata *metadata = (AVContentLightMetadata *)sd->data;
+            print_int("max_content", metadata->MaxCLL);
+            print_int("max_average", metadata->MaxFALL);
         }
         writer_print_section_footer(w);
     }
     writer_print_section_footer(w);
 }
 
+static void print_color_range(WriterContext *w, enum AVColorRange color_range)
+{
+    const char *val = av_color_range_name(color_range);
+    if (!val || color_range == AVCOL_RANGE_UNSPECIFIED) {
+        print_str_opt("color_range", "unknown");
+    } else {
+        print_str("color_range", val);
+    }
+}
+
+static void print_color_space(WriterContext *w, enum AVColorSpace color_space)
+{
+    const char *val = av_color_space_name(color_space);
+    if (!val || color_space == AVCOL_SPC_UNSPECIFIED) {
+        print_str_opt("color_space", "unknown");
+    } else {
+        print_str("color_space", val);
+    }
+}
+
+static void print_primaries(WriterContext *w, enum AVColorPrimaries color_primaries)
+{
+    const char *val = av_color_primaries_name(color_primaries);
+    if (!val || color_primaries == AVCOL_PRI_UNSPECIFIED) {
+        print_str_opt("color_primaries", "unknown");
+    } else {
+        print_str("color_primaries", val);
+    }
+}
+
+static void print_color_trc(WriterContext *w, enum AVColorTransferCharacteristic color_trc)
+{
+    const char *val = av_color_transfer_name(color_trc);
+    if (!val || color_trc == AVCOL_TRC_UNSPECIFIED) {
+        print_str_opt("color_transfer", "unknown");
+    } else {
+        print_str("color_transfer", val);
+    }
+}
+
+static void print_chroma_location(WriterContext *w, enum AVChromaLocation chroma_location)
+{
+    const char *val = av_chroma_location_name(chroma_location);
+    if (!val || chroma_location == AVCHROMA_LOC_UNSPECIFIED) {
+        print_str_opt("chroma_location", "unspecified");
+    } else {
+        print_str("chroma_location", val);
+    }
+}
+
+
+static void clear_log(int need_lock)
+{
+    int i;
+
+    if (need_lock)
+        pthread_mutex_lock(&log_mutex);
+    for (i=0; i<log_buffer_size; i++) {
+        av_freep(&log_buffer[i].context_name);
+        av_freep(&log_buffer[i].parent_name);
+        av_freep(&log_buffer[i].log_message);
+    }
+    log_buffer_size = 0;
+    if(need_lock)
+        pthread_mutex_unlock(&log_mutex);
+}
+
+static int show_log(WriterContext *w, int section_ids, int section_id, int log_level)
+{
+    int i;
+    pthread_mutex_lock(&log_mutex);
+    if (!log_buffer_size) {
+        pthread_mutex_unlock(&log_mutex);
+        return 0;
+    }
+    writer_print_section_header(w, section_ids);
+
+    for (i=0; i<log_buffer_size; i++) {
+        if (log_buffer[i].log_level <= log_level) {
+            writer_print_section_header(w, section_id);
+            print_str("context", log_buffer[i].context_name);
+            print_int("level", log_buffer[i].log_level);
+            print_int("category", log_buffer[i].category);
+            if (log_buffer[i].parent_name) {
+                print_str("parent_context", log_buffer[i].parent_name);
+                print_int("parent_category", log_buffer[i].parent_category);
+            } else {
+                print_str_opt("parent_context", "N/A");
+                print_str_opt("parent_category", "N/A");
+            }
+            print_str("message", log_buffer[i].log_message);
+            writer_print_section_footer(w);
+        }
+    }
+    clear_log(0);
+    pthread_mutex_unlock(&log_mutex);
+
+    writer_print_section_footer(w);
+
+    return 0;
+}
+
 static void show_packet(WriterContext *w, InputFile *ifile, AVPacket *pkt, int packet_idx)
 {
     char val_str[128];
@@ -1830,7 +2068,7 @@ static void show_packet(WriterContext *w, InputFile *ifile, AVPacket *pkt, int p
             av_dict_free(&dict);
         }
 
-        print_pkt_side_data(w, pkt->side_data, pkt->side_data_elems,
+        print_pkt_side_data(w, st->codecpar, pkt->side_data, pkt->side_data_elems,
                             SECTION_ID_PACKET_SIDE_DATA_LIST,
                             SECTION_ID_PACKET_SIDE_DATA);
     }
@@ -1888,13 +2126,13 @@ static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
     print_time("pkt_pts_time",          frame->pts, &stream->time_base);
     print_ts  ("pkt_dts",               frame->pkt_dts);
     print_time("pkt_dts_time",          frame->pkt_dts, &stream->time_base);
-    print_ts  ("best_effort_timestamp", av_frame_get_best_effort_timestamp(frame));
-    print_time("best_effort_timestamp_time", av_frame_get_best_effort_timestamp(frame), &stream->time_base);
-    print_duration_ts  ("pkt_duration",      av_frame_get_pkt_duration(frame));
-    print_duration_time("pkt_duration_time", av_frame_get_pkt_duration(frame), &stream->time_base);
-    if (av_frame_get_pkt_pos (frame) != -1) print_fmt    ("pkt_pos", "%"PRId64, av_frame_get_pkt_pos(frame));
+    print_ts  ("best_effort_timestamp", frame->best_effort_timestamp);
+    print_time("best_effort_timestamp_time", frame->best_effort_timestamp, &stream->time_base);
+    print_duration_ts  ("pkt_duration",      frame->pkt_duration);
+    print_duration_time("pkt_duration_time", frame->pkt_duration, &stream->time_base);
+    if (frame->pkt_pos != -1) print_fmt    ("pkt_pos", "%"PRId64, frame->pkt_pos);
     else                      print_str_opt("pkt_pos", "N/A");
-    if (av_frame_get_pkt_size(frame) != -1) print_val    ("pkt_size", av_frame_get_pkt_size(frame), unit_byte_str);
+    if (frame->pkt_size != -1) print_val    ("pkt_size", frame->pkt_size, unit_byte_str);
     else                       print_str_opt("pkt_size", "N/A");
 
     switch (stream->codecpar->codec_type) {
@@ -1918,6 +2156,12 @@ static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
         print_int("interlaced_frame",       frame->interlaced_frame);
         print_int("top_field_first",        frame->top_field_first);
         print_int("repeat_pict",            frame->repeat_pict);
+
+        print_color_range(w, frame->color_range);
+        print_color_space(w, frame->colorspace);
+        print_primaries(w, frame->color_primaries);
+        print_color_trc(w, frame->color_trc);
+        print_chroma_location(w, frame->chroma_location);
         break;
 
     case AVMEDIA_TYPE_AUDIO:
@@ -1925,18 +2169,20 @@ static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
         if (s) print_str    ("sample_fmt", s);
         else   print_str_opt("sample_fmt", "unknown");
         print_int("nb_samples",         frame->nb_samples);
-        print_int("channels", av_frame_get_channels(frame));
-        if (av_frame_get_channel_layout(frame)) {
+        print_int("channels", frame->channels);
+        if (frame->channel_layout) {
             av_bprint_clear(&pbuf);
-            av_bprint_channel_layout(&pbuf, av_frame_get_channels(frame),
-                                     av_frame_get_channel_layout(frame));
+            av_bprint_channel_layout(&pbuf, frame->channels,
+                                     frame->channel_layout);
             print_str    ("channel_layout", pbuf.str);
         } else
             print_str_opt("channel_layout", "unknown");
         break;
     }
     if (do_show_frame_tags)
-        show_tags(w, av_frame_get_metadata(frame), SECTION_ID_FRAME_TAGS);
+        show_tags(w, frame->metadata, SECTION_ID_FRAME_TAGS);
+    if (do_show_log)
+        show_log(w, SECTION_ID_FRAME_LOGS, SECTION_ID_FRAME_LOG, do_show_log);
     if (frame->nb_side_data) {
         writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA_LIST);
         for (i = 0; i < frame->nb_side_data; i++) {
@@ -1946,7 +2192,6 @@ static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
             writer_print_section_header(w, SECTION_ID_FRAME_SIDE_DATA);
             name = av_frame_side_data_name(sd->type);
             print_str("side_data_type", name ? name : "unknown");
-            print_int("side_data_size", sd->size);
             if (sd->type == AV_FRAME_DATA_DISPLAYMATRIX && sd->size >= 9*4) {
                 writer_print_integers(w, "displaymatrix", sd->data, 9, " %11d", 3, 4, 1);
                 print_int("rotation", av_display_rotation_get((int32_t *)sd->data));
@@ -1954,6 +2199,34 @@ static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
                 char tcbuf[AV_TIMECODE_STR_SIZE];
                 av_timecode_make_mpeg_tc_string(tcbuf, *(int64_t *)(sd->data));
                 print_str("timecode", tcbuf);
+            } else if (sd->type == AV_FRAME_DATA_MASTERING_DISPLAY_METADATA) {
+                AVMasteringDisplayMetadata *metadata = (AVMasteringDisplayMetadata *)sd->data;
+
+                if (metadata->has_primaries) {
+                    print_q("red_x", metadata->display_primaries[0][0], '/');
+                    print_q("red_y", metadata->display_primaries[0][1], '/');
+                    print_q("green_x", metadata->display_primaries[1][0], '/');
+                    print_q("green_y", metadata->display_primaries[1][1], '/');
+                    print_q("blue_x", metadata->display_primaries[2][0], '/');
+                    print_q("blue_y", metadata->display_primaries[2][1], '/');
+
+                    print_q("white_point_x", metadata->white_point[0], '/');
+                    print_q("white_point_y", metadata->white_point[1], '/');
+                }
+
+                if (metadata->has_luminance) {
+                    print_q("min_luminance", metadata->min_luminance, '/');
+                    print_q("max_luminance", metadata->max_luminance, '/');
+                }
+            } else if (sd->type == AV_FRAME_DATA_CONTENT_LIGHT_LEVEL) {
+                AVContentLightMetadata *metadata = (AVContentLightMetadata *)sd->data;
+                print_int("max_content", metadata->MaxCLL);
+                print_int("max_average", metadata->MaxFALL);
+            } else if (sd->type == AV_FRAME_DATA_ICC_PROFILE) {
+                AVDictionaryEntry *tag = av_dict_get(sd->metadata, "name", NULL, AV_DICT_MATCH_CASE);
+                if (tag)
+                    print_str(tag->key, tag->value);
+                print_int("size", sd->size);
             }
             writer_print_section_footer(w);
         }
@@ -1968,7 +2241,8 @@ static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
 
 static av_always_inline int process_frame(WriterContext *w,
                                           InputFile *ifile,
-                                          AVFrame *frame, AVPacket *pkt)
+                                          AVFrame *frame, AVPacket *pkt,
+                                          int *packet_new)
 {
     AVFormatContext *fmt_ctx = ifile->fmt_ctx;
     AVCodecContext *dec_ctx = ifile->streams[pkt->stream_index].dec_ctx;
@@ -1976,27 +2250,43 @@ static av_always_inline int process_frame(WriterContext *w,
     AVSubtitle sub;
     int ret = 0, got_frame = 0;
 
+    clear_log(1);
     if (dec_ctx && dec_ctx->codec) {
         switch (par->codec_type) {
         case AVMEDIA_TYPE_VIDEO:
-            ret = avcodec_decode_video2(dec_ctx, frame, &got_frame, pkt);
-            break;
-
         case AVMEDIA_TYPE_AUDIO:
-            ret = avcodec_decode_audio4(dec_ctx, frame, &got_frame, pkt);
+            if (*packet_new) {
+                ret = avcodec_send_packet(dec_ctx, pkt);
+                if (ret == AVERROR(EAGAIN)) {
+                    ret = 0;
+                } else if (ret >= 0 || ret == AVERROR_EOF) {
+                    ret = 0;
+                    *packet_new = 0;
+                }
+            }
+            if (ret >= 0) {
+                ret = avcodec_receive_frame(dec_ctx, frame);
+                if (ret >= 0) {
+                    got_frame = 1;
+                } else if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
+                    ret = 0;
+                }
+            }
             break;
 
         case AVMEDIA_TYPE_SUBTITLE:
             ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_frame, pkt);
+            *packet_new = 0;
             break;
+        default:
+            *packet_new = 0;
         }
+    } else {
+        *packet_new = 0;
     }
 
     if (ret < 0)
         return ret;
-    ret = FFMIN(ret, pkt->size); /* guard against bogus return values */
-    pkt->data += ret;
-    pkt->size -= ret;
     if (got_frame) {
         int is_sub = (par->codec_type == AVMEDIA_TYPE_SUBTITLE);
         nb_streams_frames[pkt->stream_index]++;
@@ -2008,7 +2298,7 @@ static av_always_inline int process_frame(WriterContext *w,
         if (is_sub)
             avsubtitle_free(&sub);
     }
-    return got_frame;
+    return got_frame || *packet_new;
 }
 
 static void log_read_interval(const ReadInterval *interval, void *log_ctx, int log_level)
@@ -2039,7 +2329,7 @@ static int read_interval_packets(WriterContext *w, InputFile *ifile,
                                  const ReadInterval *interval, int64_t *cur_ts)
 {
     AVFormatContext *fmt_ctx = ifile->fmt_ctx;
-    AVPacket pkt, pkt1;
+    AVPacket pkt;
     AVFrame *frame = NULL;
     int ret = 0, i = 0, frame_count = 0;
     int64_t start = -INT64_MAX, end = interval->end;
@@ -2116,8 +2406,8 @@ static int read_interval_packets(WriterContext *w, InputFile *ifile,
                 nb_streams_packets[pkt.stream_index]++;
             }
             if (do_read_frames) {
-                pkt1 = pkt;
-                while (pkt1.size && process_frame(w, ifile, frame, &pkt1) > 0);
+                int packet_new = 1;
+                while (process_frame(w, ifile, frame, &pkt, &packet_new) > 0);
             }
         }
         av_packet_unref(&pkt);
@@ -2129,7 +2419,7 @@ static int read_interval_packets(WriterContext *w, InputFile *ifile,
     for (i = 0; i < fmt_ctx->nb_streams; i++) {
         pkt.stream_index = i;
         if (do_read_frames)
-            while (process_frame(w, ifile, frame, &pkt) > 0);
+            while (process_frame(w, ifile, frame, &pkt, &(int){1}) > 0);
     }
 
 end:
@@ -2215,9 +2505,8 @@ static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_id
 #endif
 
     /* print AVI/FourCC tag */
-    av_get_codec_tag_string(val_str, sizeof(val_str), par->codec_tag);
-    print_str("codec_tag_string",    val_str);
-    print_fmt("codec_tag", "0x%04x", par->codec_tag);
+    print_str("codec_tag_string",    av_fourcc2str(par->codec_tag));
+    print_fmt("codec_tag", "0x%04"PRIx32, par->codec_tag);
 
     switch (par->codec_type) {
     case AVMEDIA_TYPE_VIDEO:
@@ -2244,29 +2533,12 @@ static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_id
         if (s) print_str    ("pix_fmt", s);
         else   print_str_opt("pix_fmt", "unknown");
         print_int("level",   par->level);
-        if (par->color_range != AVCOL_RANGE_UNSPECIFIED)
-            print_str    ("color_range", av_color_range_name(par->color_range));
-        else
-            print_str_opt("color_range", "N/A");
 
-        s = av_get_colorspace_name(par->color_space);
-        if (s) print_str    ("color_space", s);
-        else   print_str_opt("color_space", "unknown");
-
-        if (par->color_trc != AVCOL_TRC_UNSPECIFIED)
-            print_str("color_transfer", av_color_transfer_name(par->color_trc));
-        else
-            print_str_opt("color_transfer", av_color_transfer_name(par->color_trc));
-
-        if (par->color_primaries != AVCOL_PRI_UNSPECIFIED)
-            print_str("color_primaries", av_color_primaries_name(par->color_primaries));
-        else
-            print_str_opt("color_primaries", av_color_primaries_name(par->color_primaries));
-
-        if (par->chroma_location != AVCHROMA_LOC_UNSPECIFIED)
-            print_str("chroma_location", av_chroma_location_name(par->chroma_location));
-        else
-            print_str_opt("chroma_location", av_chroma_location_name(par->chroma_location));
+        print_color_range(w, par->color_range);
+        print_color_space(w, par->color_space);
+        print_color_trc(w, par->color_trc);
+        print_primaries(w, par->color_primaries);
+        print_chroma_location(w, par->chroma_location);
 
         if (par->field_order == AV_FIELD_PROGRESSIVE)
             print_str("field_order", "progressive");
@@ -2391,7 +2663,7 @@ static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_id
         ret = show_tags(w, stream->metadata, in_program ? SECTION_ID_PROGRAM_STREAM_TAGS : SECTION_ID_STREAM_TAGS);
 
     if (stream->nb_side_data) {
-        print_pkt_side_data(w, stream->side_data, stream->nb_side_data,
+        print_pkt_side_data(w, stream->codecpar, stream->side_data, stream->nb_side_data,
                             SECTION_ID_STREAM_SIDE_DATA_LIST,
                             SECTION_ID_STREAM_SIDE_DATA);
     }
@@ -2545,12 +2817,19 @@ static void show_error(WriterContext *w, int err)
 
 static int open_input_file(InputFile *ifile, const char *filename)
 {
-    int err, i, orig_nb_streams;
+    int err, i;
     AVFormatContext *fmt_ctx = NULL;
     AVDictionaryEntry *t;
-    AVDictionary **opts;
     int scan_all_pmts_set = 0;
 
+    fmt_ctx = avformat_alloc_context();
+    if (!fmt_ctx) {
+        print_error(filename, AVERROR(ENOMEM));
+        exit_program(1);
+    }
+
+    fmt_ctx->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
+
     if (!av_dict_get(format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
         av_dict_set(&format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
         scan_all_pmts_set = 1;
@@ -2568,19 +2847,20 @@ static int open_input_file(InputFile *ifile, const char *filename)
         return AVERROR_OPTION_NOT_FOUND;
     }
 
-    /* fill the streams in the format context */
-    opts = setup_find_stream_info_opts(fmt_ctx, codec_opts);
-    orig_nb_streams = fmt_ctx->nb_streams;
+    if (find_stream_info) {
+        AVDictionary **opts = setup_find_stream_info_opts(fmt_ctx, codec_opts);
+        int orig_nb_streams = fmt_ctx->nb_streams;
 
-    err = avformat_find_stream_info(fmt_ctx, opts);
+        err = avformat_find_stream_info(fmt_ctx, opts);
 
-    for (i = 0; i < orig_nb_streams; i++)
-        av_dict_free(&opts[i]);
-    av_freep(&opts);
+        for (i = 0; i < orig_nb_streams; i++)
+            av_dict_free(&opts[i]);
+        av_freep(&opts);
 
-    if (err < 0) {
-        print_error(filename, err);
-        return err;
+        if (err < 0) {
+            print_error(filename, err);
+            return err;
+        }
     }
 
     av_dump_format(fmt_ctx, 0, filename, 0);
@@ -2625,6 +2905,13 @@ static int open_input_file(InputFile *ifile, const char *filename)
             if (err < 0)
                 exit(1);
 
+            if (do_show_log) {
+                // For loging it is needed to disable at least frame threads as otherwise
+                // the log information would need to be reordered and matches up to contexts and frames
+                // That is in fact possible but not trivial
+                av_dict_set(&codec_opts, "threads", "1", 0);
+            }
+
             av_codec_set_pkt_timebase(ist->dec_ctx, stream->time_base);
             ist->dec_ctx->framerate = stream->avg_frame_rate;
 
@@ -2693,6 +2980,8 @@ static int probe_file(WriterContext *wctx, const char *filename)
         } else {
             selected_streams[i] = 1;
         }
+        if (!selected_streams[i])
+            ifile.fmt_ctx->streams[i]->discard = AVDISCARD_ALL;
     }
 
     if (do_read_frames || do_read_packets) {
@@ -2980,6 +3269,7 @@ void show_help_default(const char *opt, const char *arg)
     printf("\n");
 
     show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
+    show_help_children(avcodec_get_class(), AV_OPT_FLAG_DECODING_PARAM);
 }
 
 /**
@@ -3052,6 +3342,7 @@ static int parse_read_interval(const char *interval_spec,
             }
             interval->end = lli;
         } else {
+            interval->duration_frames = 0;
             ret = av_parse_time(&us, p, 1);
             if (ret < 0) {
                 av_log(NULL, AV_LOG_ERROR, "Invalid interval end/duration specification '%s'\n", p);
@@ -3185,7 +3476,7 @@ DEFINE_OPT_SHOW_SECTION(streams,          STREAMS)
 DEFINE_OPT_SHOW_SECTION(programs,         PROGRAMS)
 
 static const OptionDef real_options[] = {
-#include "cmdutils_common_opts.h"
+    CMDUTILS_COMMON_OPTIONS
     { "f", HAS_ARG, {.func_arg = opt_format}, "force format", "format" },
     { "unit", OPT_BOOL, {&show_value_unit}, "show unit of the displayed values" },
     { "prefix", OPT_BOOL, {&use_value_prefix}, "use SI prefixes for the displayed values" },
@@ -3209,6 +3500,9 @@ static const OptionDef real_options[] = {
       "show a particular entry from the format/container info", "entry" },
     { "show_entries", HAS_ARG, {.func_arg = opt_show_entries},
       "show a set of specified entries", "entry_list" },
+#if HAVE_THREADS
+    { "show_log", OPT_INT|HAS_ARG, {(void*)&do_show_log}, "show log" },
+#endif
     { "show_packets", 0, {(void*)&opt_show_packets}, "show packets info" },
     { "show_programs", 0, {(void*)&opt_show_programs}, "show programs info" },
     { "show_streams", 0, {(void*)&opt_show_streams}, "show streams info" },
@@ -3225,6 +3519,8 @@ static const OptionDef real_options[] = {
     { "read_intervals", HAS_ARG, {.func_arg = opt_read_intervals}, "set read intervals", "read_intervals" },
     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {.func_arg = opt_default}, "generic catch all option", "" },
     { "i", HAS_ARG, {.func_arg = opt_input_file_i}, "read specified file", "input_file"},
+    { "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
+        "read and decode the streams to fill missing information with heuristics" },
     { NULL, },
 };
 
@@ -3255,6 +3551,12 @@ int main(int argc, char **argv)
 
     init_dynload();
 
+#if HAVE_THREADS
+    ret = pthread_mutex_init(&log_mutex, NULL);
+    if (ret != 0) {
+        goto end;
+    }
+#endif
     av_log_set_flags(AV_LOG_SKIP_REPEATED);
     register_exit(ffprobe_cleanup);
 
@@ -3270,6 +3572,9 @@ int main(int argc, char **argv)
     show_banner(argc, argv, options);
     parse_options(NULL, argc, argv, options, opt_input_file);
 
+    if (do_show_log)
+        av_log_set_callback(log_callback);
+
     /* mark things to show, based on -show_entries */
     SET_DO_SHOW(CHAPTERS, chapters);
     SET_DO_SHOW(ERROR, error);
@@ -3311,6 +3616,12 @@ int main(int argc, char **argv)
         goto end;
     }
     w_name = av_strtok(print_format, "=", &buf);
+    if (!w_name) {
+        av_log(NULL, AV_LOG_ERROR,
+               "No name specified for the output format\n");
+        ret = AVERROR(EINVAL);
+        goto end;
+    }
     w_args = buf;
 
     if (show_data_hash) {
diff --git a/mythtv/external/FFmpeg/fftools/ffserver.c b/mythtv/external/FFmpeg/fftools/ffserver.c
index 453d790e6cd..7f8b2387bd0 100644
--- a/mythtv/external/FFmpeg/fftools/ffserver.c
+++ b/mythtv/external/FFmpeg/fftools/ffserver.c
@@ -32,16 +32,10 @@
 #include <stdio.h>
 #include "libavformat/avformat.h"
 /* FIXME: those are internal headers, ffserver _really_ shouldn't use them */
-#include "libavformat/ffm.h"
-#include "libavformat/network.h"
-#include "libavformat/os_support.h"
-#include "libavformat/rtpdec.h"
 #include "libavformat/rtpproto.h"
 #include "libavformat/rtsp.h"
-#include "libavformat/rtspcodes.h"
 #include "libavformat/avio_internal.h"
 #include "libavformat/internal.h"
-#include "libavformat/url.h"
 
 #include "libavutil/avassert.h"
 #include "libavutil/avstring.h"
@@ -50,6 +44,7 @@
 #include "libavutil/intreadwrite.h"
 #include "libavutil/mathematics.h"
 #include "libavutil/random_seed.h"
+#include "libavutil/rational.h"
 #include "libavutil/parseutils.h"
 #include "libavutil/opt.h"
 #include "libavutil/time.h"
@@ -161,7 +156,7 @@ typedef struct HTTPContext {
     int feed_streams[FFSERVER_MAX_STREAMS]; /* index of streams in the feed */
     int switch_feed_streams[FFSERVER_MAX_STREAMS]; /* index of streams in the feed */
     int switch_pending;
-    AVFormatContext fmt_ctx; /* instance of FFServerStream for one user */
+    AVFormatContext *pfmt_ctx; /* instance of FFServerStream for one user */
     int last_packet_sent; /* true if last data packet was sent */
     int suppress_log;
     DataRateData datarate;
@@ -169,6 +164,7 @@ typedef struct HTTPContext {
     char protocol[16];
     char method[16];
     char url[128];
+    char clean_url[128*7];
     int buffer_size;
     uint8_t *buffer;
     int is_packetized; /* if true, the stream is packetized */
@@ -192,11 +188,6 @@ typedef struct HTTPContext {
     uint8_t *packet_buffer, *packet_buffer_ptr, *packet_buffer_end;
 } HTTPContext;
 
-typedef struct FeedData {
-    long long data_count;
-    float avg_frame_size;   /* frame size averaged over last frames with exponential mean */
-} FeedData;
-
 static HTTPContext *first_http_ctx;
 
 static FFServerConfig config = {
@@ -245,8 +236,7 @@ static int rtp_new_av_stream(HTTPContext *c,
 /* utils */
 static size_t htmlencode (const char *src, char **dest);
 static inline void cp_html_entity (char *buffer, const char *entity);
-static inline int check_codec_match(AVCodecContext *ccf, AVCodecContext *ccs,
-                                    int stream);
+static inline int check_codec_match(LayeredAVStream *ccf, AVStream *ccs, int stream);
 
 static const char *my_program_name;
 
@@ -265,6 +255,21 @@ static AVLFG random_state;
 
 static FILE *logfile = NULL;
 
+static void unlayer_stream(AVStream *st, LayeredAVStream *lst)
+{
+    avcodec_free_context(&st->codec);
+    avcodec_parameters_free(&st->codecpar);
+#define COPY(a) st->a = lst->a;
+    COPY(index)
+    COPY(id)
+    COPY(codec)
+    COPY(codecpar)
+    COPY(time_base)
+    COPY(pts_wrap_bits)
+    COPY(sample_aspect_ratio)
+    COPY(recommended_encoder_configuration)
+}
+
 static inline void cp_html_entity (char *buffer, const char *entity) {
     if (!buffer || !entity)
         return;
@@ -471,7 +476,7 @@ static int compute_datarate(DataRateData *drd, int64_t count)
 static void start_children(FFServerStream *feed)
 {
     char *pathname;
-    char *slash;
+    char *dirname, *prog;
     int i;
     size_t cmd_length;
 
@@ -490,20 +495,18 @@ static void start_children(FFServerStream *feed)
         return;
     }
 
-    pathname = av_strdup (my_program_name);
-    if (!pathname) {
+   /* use "ffmpeg" in the path of current program. Ignore user provided path */
+    prog = av_strdup(my_program_name);
+    if (prog) {
+        dirname = av_dirname(prog);
+        pathname = *dirname ? av_asprintf("%s/%s", dirname, "ffmpeg")
+                            : av_asprintf("ffmpeg");
+        av_free(prog);
+    }
+    if (!prog || !pathname) {
         http_log("Could not allocate memory for children cmd line\n");
         return;
     }
-   /* replace "ffserver" with "ffmpeg" in the path of current
-    * program. Ignore user provided path */
-
-    slash = strrchr(pathname, '/');
-    if (!slash)
-        slash = pathname;
-    else
-        slash++;
-    strcpy(slash, "ffmpeg");
 
     for (; feed; feed = feed->next) {
 
@@ -936,21 +939,22 @@ static void close_connection(HTTPContext *c)
         ffurl_close(c->rtp_handles[i]);
     }
 
-    ctx = &c->fmt_ctx;
+    ctx = c->pfmt_ctx;
 
-    if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
-        /* prepare header */
-        if (ctx->oformat && avio_open_dyn_buf(&ctx->pb) >= 0) {
-            av_write_trailer(ctx);
-            av_freep(&c->pb_buffer);
-            avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
+    if (ctx) {
+        if (!c->last_packet_sent && c->state == HTTPSTATE_SEND_DATA_TRAILER) {
+            /* prepare header */
+            if (ctx->oformat && avio_open_dyn_buf(&ctx->pb) >= 0) {
+                av_write_trailer(ctx);
+                av_freep(&c->pb_buffer);
+                avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
+            }
+        }
+        for(i=0; i<ctx->nb_streams; i++)
+            av_freep(&ctx->streams[i]);
+        av_freep(&ctx->streams);
+        av_freep(&ctx->priv_data);
         }
-    }
-
-    for(i=0; i<ctx->nb_streams; i++)
-        av_freep(&ctx->streams[i]);
-    av_freep(&ctx->streams);
-    av_freep(&ctx->priv_data);
 
     if (c->stream && !c->post && c->stream->stream_type == STREAM_TYPE_LIVE)
         current_bandwidth -= c->stream->bandwidth;
@@ -1196,7 +1200,7 @@ static int extract_rates(char *rates, int ratelen, const char *request)
     return 0;
 }
 
-static int find_stream_in_feed(FFServerStream *feed, AVCodecContext *codec,
+static int find_stream_in_feed(FFServerStream *feed, AVCodecParameters *codec,
                                int bit_rate)
 {
     int i;
@@ -1204,7 +1208,7 @@ static int find_stream_in_feed(FFServerStream *feed, AVCodecContext *codec,
     int best = -1;
 
     for (i = 0; i < feed->nb_streams; i++) {
-        AVCodecContext *feed_codec = feed->streams[i]->codec;
+        AVCodecParameters *feed_codec = feed->streams[i]->codecpar;
 
         if (feed_codec->codec_id != codec->codec_id ||
             feed_codec->sample_rate != codec->sample_rate ||
@@ -1245,7 +1249,7 @@ static int modify_current_stream(HTTPContext *c, char *rates)
         return 0;
 
     for (i = 0; i < req->nb_streams; i++) {
-        AVCodecContext *codec = req->streams[i]->codec;
+        AVCodecParameters *codec = req->streams[i]->codecpar;
 
         switch(rates[i]) {
             case 0:
@@ -1279,6 +1283,8 @@ static void get_word(char *buf, int buf_size, const char **pp)
     const char *p;
     char *q;
 
+#define SPACE_CHARS " \t\r\n"
+
     p = *pp;
     p += strspn(p, SPACE_CHARS);
     q = buf;
@@ -1692,7 +1698,7 @@ static int http_parse_request(HTTPContext *c)
                                 memcpy(q, sdp_data, sdp_data_size);
                                 q += sdp_data_size;
                                 *q = '\0';
-                                av_free(sdp_data);
+                                av_freep(&sdp_data);
                             }
                         }
                         break;
@@ -1872,47 +1878,75 @@ static inline void print_stream_params(AVIOContext *pb, FFServerStream *stream)
     int i, stream_no;
     const char *type = "unknown";
     char parameters[64];
-    AVStream *st;
+    LayeredAVStream *st;
     AVCodec *codec;
 
     stream_no = stream->nb_streams;
 
-    avio_printf(pb, "<table cellspacing=0 cellpadding=4><tr><th>Stream<th>"
-                    "type<th>kbit/s<th align=left>codec<th align=left>"
+    avio_printf(pb, "<table><tr><th>Stream<th>"
+                    "type<th>kbit/s<th>codec<th>"
                     "Parameters\n");
 
     for (i = 0; i < stream_no; i++) {
         st = stream->streams[i];
-        codec = avcodec_find_encoder(st->codec->codec_id);
+        codec = avcodec_find_encoder(st->codecpar->codec_id);
 
         parameters[0] = 0;
 
-        switch(st->codec->codec_type) {
+        switch(st->codecpar->codec_type) {
         case AVMEDIA_TYPE_AUDIO:
             type = "audio";
             snprintf(parameters, sizeof(parameters), "%d channel(s), %d Hz",
-                     st->codec->channels, st->codec->sample_rate);
+                     st->codecpar->channels, st->codecpar->sample_rate);
             break;
         case AVMEDIA_TYPE_VIDEO:
             type = "video";
             snprintf(parameters, sizeof(parameters),
-                     "%dx%d, q=%d-%d, fps=%d", st->codec->width,
-                     st->codec->height, st->codec->qmin, st->codec->qmax,
-                     st->codec->time_base.den / st->codec->time_base.num);
+                     "%dx%d, q=%d-%d, fps=%d", st->codecpar->width,
+                     st->codecpar->height, st->codec->qmin, st->codec->qmax,
+                     st->time_base.den / st->time_base.num);
             break;
         default:
             abort();
         }
 
-        avio_printf(pb, "<tr><td align=right>%d<td>%s<td align=right>%"PRId64
+        avio_printf(pb, "<tr><td>%d<td>%s<td>%"PRId64
                         "<td>%s<td>%s\n",
-                    i, type, (int64_t)st->codec->bit_rate/1000,
+                    i, type, st->codecpar->bit_rate/1000,
                     codec ? codec->name : "", parameters);
      }
 
      avio_printf(pb, "</table>\n");
 }
 
+static void clean_html(char *clean, int clean_len, char *dirty)
+{
+    int i, o;
+
+    for (o = i = 0; o+10 < clean_len && dirty[i];) {
+        int len = strspn(dirty+i, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$-_.+!*(),?/ :;%");
+        if (len) {
+            if (o + len >= clean_len)
+                break;
+            memcpy(clean + o, dirty + i, len);
+            i += len;
+            o += len;
+        } else {
+            int c = dirty[i++];
+            switch (c) {
+            case  '&': av_strlcat(clean+o, "&amp;"  , clean_len - o); break;
+            case  '<': av_strlcat(clean+o, "&lt;"   , clean_len - o); break;
+            case  '>': av_strlcat(clean+o, "&gt;"   , clean_len - o); break;
+            case '\'': av_strlcat(clean+o, "&apos;" , clean_len - o); break;
+            case '\"': av_strlcat(clean+o, "&quot;" , clean_len - o); break;
+            default:   av_strlcat(clean+o, "&#9785;", clean_len - o); break;
+            }
+            o += strlen(clean+o);
+        }
+    }
+    clean[o] = 0;
+}
+
 static void compute_status(HTTPContext *c)
 {
     HTTPContext *c1;
@@ -1943,8 +1977,8 @@ static void compute_status(HTTPContext *c)
     avio_printf(pb, "<h1>%s Status</h1>\n", program_name);
     /* format status */
     avio_printf(pb, "<h2>Available Streams</h2>\n");
-    avio_printf(pb, "<table cellspacing=0 cellpadding=4>\n");
-    avio_printf(pb, "<tr><th valign=top>Path<th align=left>Served<br>Conns<th><br>bytes<th valign=top>Format<th>Bit rate<br>kbit/s<th align=left>Video<br>kbit/s<th><br>Codec<th align=left>Audio<br>kbit/s<th><br>Codec<th align=left valign=top>Feed\n");
+    avio_printf(pb, "<table>\n");
+    avio_printf(pb, "<tr><th>Path<th>Served<br>Conns<th><br>bytes<th>Format<th>Bit rate<br>kbit/s<th>Video<br>kbit/s<th><br>Codec<th>Audio<br>kbit/s<th><br>Codec<th>Feed\n");
     stream = config.first_stream;
     while (stream) {
         char sfilename[1024];
@@ -1978,9 +2012,11 @@ static void compute_status(HTTPContext *c)
 
         avio_printf(pb, "<tr><td><a href=\"/%s\">%s</a> ",
                     sfilename, stream->filename);
-        avio_printf(pb, "<td align=right> %d <td align=right> ",
+        avio_printf(pb, "<td> %d <td> ",
                     stream->conns_served);
-        fmt_bytecount(pb, stream->bytes_served);
+        // TODO: Investigate if we can make http bitexact so it always produces the same count of bytes
+        if (!config.bitexact)
+            fmt_bytecount(pb, stream->bytes_served);
 
         switch(stream->stream_type) {
         case STREAM_TYPE_LIVE: {
@@ -1992,12 +2028,12 @@ static void compute_status(HTTPContext *c)
             const char *video_codec_name_extra = "";
 
             for(i=0;i<stream->nb_streams;i++) {
-                AVStream *st = stream->streams[i];
-                AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
+                LayeredAVStream *st = stream->streams[i];
+                AVCodec *codec = avcodec_find_encoder(st->codecpar->codec_id);
 
-                switch(st->codec->codec_type) {
+                switch(st->codecpar->codec_type) {
                 case AVMEDIA_TYPE_AUDIO:
-                    audio_bit_rate += st->codec->bit_rate;
+                    audio_bit_rate += st->codecpar->bit_rate;
                     if (codec) {
                         if (*audio_codec_name)
                             audio_codec_name_extra = "...";
@@ -2005,7 +2041,7 @@ static void compute_status(HTTPContext *c)
                     }
                     break;
                 case AVMEDIA_TYPE_VIDEO:
-                    video_bit_rate += st->codec->bit_rate;
+                    video_bit_rate += st->codecpar->bit_rate;
                     if (codec) {
                         if (*video_codec_name)
                             video_codec_name_extra = "...";
@@ -2013,15 +2049,14 @@ static void compute_status(HTTPContext *c)
                     }
                     break;
                 case AVMEDIA_TYPE_DATA:
-                    video_bit_rate += st->codec->bit_rate;
+                    video_bit_rate += st->codecpar->bit_rate;
                     break;
                 default:
                     abort();
                 }
             }
 
-            avio_printf(pb, "<td align=center> %s <td align=right> %d "
-                            "<td align=right> %d <td> %s %s <td align=right> "
+            avio_printf(pb, "<td> %s <td> %d <td> %d <td> %s %s <td> "
                             "%d <td> %s %s",
                         stream->fmt->name, stream->bandwidth,
                         video_bit_rate / 1000, video_codec_name,
@@ -2036,8 +2071,8 @@ static void compute_status(HTTPContext *c)
         }
             break;
         default:
-            avio_printf(pb, "<td align=center> - <td align=right> - "
-                            "<td align=right> - <td><td align=right> - <td>\n");
+            avio_printf(pb, "<td> - <td> - "
+                            "<td> - <td><td> - <td>\n");
             break;
         }
         stream = stream->next;
@@ -2098,7 +2133,7 @@ static void compute_status(HTTPContext *c)
                 current_bandwidth, config.max_bandwidth);
 
     avio_printf(pb, "<table>\n");
-    avio_printf(pb, "<tr><th>#<th>File<th>IP<th>Proto<th>State<th>Target "
+    avio_printf(pb, "<tr><th>#<th>File<th>IP<th>URL<th>Proto<th>State<th>Target "
                     "bit/s<th>Actual bit/s<th>Bytes transferred\n");
     c1 = first_http_ctx;
     i = 0;
@@ -2110,33 +2145,38 @@ static void compute_status(HTTPContext *c)
         if (c1->stream) {
             for (j = 0; j < c1->stream->nb_streams; j++) {
                 if (!c1->stream->feed)
-                    bitrate += c1->stream->streams[j]->codec->bit_rate;
+                    bitrate += c1->stream->streams[j]->codecpar->bit_rate;
                 else if (c1->feed_streams[j] >= 0)
-                    bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
+                    bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codecpar->bit_rate;
             }
         }
 
         i++;
         p = inet_ntoa(c1->from_addr.sin_addr);
-        avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s"
-                        "<td align=right>",
+        clean_html(c1->clean_url, sizeof(c1->clean_url), c1->url);
+        avio_printf(pb, "<tr><td><b>%d</b><td>%s%s<td>%s<td>%s<td>%s<td>%s"
+                        "<td>",
                     i, c1->stream ? c1->stream->filename : "",
-                    c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "", p,
+                    c1->state == HTTPSTATE_RECEIVE_DATA ? "(input)" : "",
+                    p,
+                    c1->clean_url,
                     c1->protocol, http_state[c1->state]);
         fmt_bytecount(pb, bitrate);
-        avio_printf(pb, "<td align=right>");
+        avio_printf(pb, "<td>");
         fmt_bytecount(pb, compute_datarate(&c1->datarate, c1->data_count) * 8);
-        avio_printf(pb, "<td align=right>");
+        avio_printf(pb, "<td>");
         fmt_bytecount(pb, c1->data_count);
         avio_printf(pb, "\n");
         c1 = c1->next;
     }
     avio_printf(pb, "</table>\n");
 
-    /* date */
-    ti = time(NULL);
-    p = ctime(&ti);
-    avio_printf(pb, "<hr size=1 noshade>Generated at %s", p);
+    if (!config.bitexact) {
+        /* date */
+        ti = time(NULL);
+        p = ctime(&ti);
+        avio_printf(pb, "<hr>Generated at %s", p);
+    }
     avio_printf(pb, "</body>\n</html>\n");
 
     len = avio_close_dyn_buf(pb, &c->pb_buffer);
@@ -2262,17 +2302,14 @@ static int http_prepare_data(HTTPContext *c)
         ctx = avformat_alloc_context();
         if (!ctx)
             return AVERROR(ENOMEM);
-        c->fmt_ctx = *ctx;
-        av_freep(&ctx);
-        av_dict_copy(&(c->fmt_ctx.metadata), c->stream->metadata, 0);
-        c->fmt_ctx.streams = av_mallocz_array(c->stream->nb_streams,
-                                              sizeof(AVStream *));
-        if (!c->fmt_ctx.streams)
-            return AVERROR(ENOMEM);
+        c->pfmt_ctx = ctx;
+        av_dict_copy(&(c->pfmt_ctx->metadata), c->stream->metadata, 0);
 
         for(i=0;i<c->stream->nb_streams;i++) {
-            AVStream *src;
-            c->fmt_ctx.streams[i] = av_mallocz(sizeof(AVStream));
+            LayeredAVStream *src;
+            AVStream *st = avformat_new_stream(c->pfmt_ctx, NULL);
+            if (!st)
+                return AVERROR(ENOMEM);
 
             /* if file or feed, then just take streams from FFServerStream
              * struct */
@@ -2282,39 +2319,40 @@ static int http_prepare_data(HTTPContext *c)
             else
                 src = c->stream->feed->streams[c->stream->feed_streams[i]];
 
-            *(c->fmt_ctx.streams[i]) = *src;
-            c->fmt_ctx.streams[i]->priv_data = 0;
-            /* XXX: should be done in AVStream, not in codec */
-            c->fmt_ctx.streams[i]->codec->frame_number = 0;
+            unlayer_stream(c->pfmt_ctx->streams[i], src); //TODO we no longer copy st->internal, does this matter?
+            av_assert0(!c->pfmt_ctx->streams[i]->priv_data);
+
+            if (src->codec->flags & AV_CODEC_FLAG_BITEXACT)
+                c->pfmt_ctx->flags |= AVFMT_FLAG_BITEXACT;
         }
         /* set output format parameters */
-        c->fmt_ctx.oformat = c->stream->fmt;
-        c->fmt_ctx.nb_streams = c->stream->nb_streams;
+        c->pfmt_ctx->oformat = c->stream->fmt;
+        av_assert0(c->pfmt_ctx->nb_streams == c->stream->nb_streams);
 
         c->got_key_frame = 0;
 
         /* prepare header and save header data in a stream */
-        if (avio_open_dyn_buf(&c->fmt_ctx.pb) < 0) {
+        if (avio_open_dyn_buf(&c->pfmt_ctx->pb) < 0) {
             /* XXX: potential leak */
             return -1;
         }
-        c->fmt_ctx.pb->seekable = 0;
+        c->pfmt_ctx->pb->seekable = 0;
 
         /*
          * HACK to avoid MPEG-PS muxer to spit many underflow errors
          * Default value from FFmpeg
          * Try to set it using configuration option
          */
-        c->fmt_ctx.max_delay = (int)(0.7*AV_TIME_BASE);
+        c->pfmt_ctx->max_delay = (int)(0.7*AV_TIME_BASE);
 
-        if ((ret = avformat_write_header(&c->fmt_ctx, NULL)) < 0) {
+        if ((ret = avformat_write_header(c->pfmt_ctx, NULL)) < 0) {
             http_log("Error writing output header for stream '%s': %s\n",
                      c->stream->filename, av_err2str(ret));
             return ret;
         }
-        av_dict_free(&c->fmt_ctx.metadata);
+        av_dict_free(&c->pfmt_ctx->metadata);
 
-        len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
+        len = avio_close_dyn_buf(c->pfmt_ctx->pb, &c->pb_buffer);
         c->buffer_ptr = c->pb_buffer;
         c->buffer_end = c->pb_buffer + len;
 
@@ -2383,7 +2421,7 @@ static int http_prepare_data(HTTPContext *c)
                             AVStream *st = c->fmt_in->streams[source_index];
                             pkt.stream_index = i;
                             if (pkt.flags & AV_PKT_FLAG_KEY &&
-                                (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
+                                (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
                                  c->stream->nb_streams == 1))
                                 c->got_key_frame = 1;
                             if (!c->stream->send_on_key || c->got_key_frame)
@@ -2391,7 +2429,6 @@ static int http_prepare_data(HTTPContext *c)
                         }
                     }
                 } else {
-                    AVCodecContext *codec;
                     AVStream *ist, *ost;
                 send_it:
                     ist = c->fmt_in->streams[source_index];
@@ -2412,13 +2449,11 @@ static int http_prepare_data(HTTPContext *c)
                             av_packet_unref(&pkt);
                             break;
                         }
-                        codec = ctx->streams[0]->codec;
                         /* only one stream per RTP connection */
                         pkt.stream_index = 0;
                     } else {
-                        ctx = &c->fmt_ctx;
+                        ctx = c->pfmt_ctx;
                         /* Fudge here */
-                        codec = ctx->streams[pkt.stream_index]->codec;
                     }
 
                     if (c->is_packetized) {
@@ -2460,7 +2495,6 @@ static int http_prepare_data(HTTPContext *c)
                     c->buffer_ptr = c->pb_buffer;
                     c->buffer_end = c->pb_buffer + len;
 
-                    codec->frame_number++;
                     if (len == 0) {
                         av_packet_unref(&pkt);
                         goto redo;
@@ -2475,13 +2509,13 @@ static int http_prepare_data(HTTPContext *c)
         /* last packet test ? */
         if (c->last_packet_sent || c->is_packetized)
             return -1;
-        ctx = &c->fmt_ctx;
+        ctx = c->pfmt_ctx;
         /* prepare header */
         if (avio_open_dyn_buf(&ctx->pb) < 0) {
             /* XXX: potential leak */
             return -1;
         }
-        c->fmt_ctx.pb->seekable = 0;
+        c->pfmt_ctx->pb->seekable = 0;
         av_write_trailer(ctx);
         len = avio_close_dyn_buf(ctx->pb, &c->pb_buffer);
         c->buffer_ptr = c->pb_buffer;
@@ -2702,8 +2736,10 @@ static int http_receive_data(HTTPContext *c)
         } else if (c->buffer_ptr - c->buffer >= 2 &&
                    !memcmp(c->buffer_ptr - 1, "\r\n", 2)) {
             c->chunk_size = strtol(c->buffer, 0, 16);
-            if (c->chunk_size == 0) // end of stream
+            if (c->chunk_size <= 0) { // end of stream or invalid chunk size
+                c->chunk_size = 0;
                 goto fail;
+            }
             c->buffer_ptr = c->buffer;
             break;
         } else if (++loop_run > 10)
@@ -2725,6 +2761,7 @@ static int http_receive_data(HTTPContext *c)
             /* end of connection : close it */
             goto fail;
         else {
+            av_assert0(len <= c->chunk_size);
             c->chunk_size -= len;
             c->buffer_ptr += len;
             c->data_count += len;
@@ -2816,9 +2853,10 @@ static int http_receive_data(HTTPContext *c)
             }
 
             for (i = 0; i < s->nb_streams; i++) {
-                AVStream *fst = feed->streams[i];
+                LayeredAVStream *fst = feed->streams[i];
                 AVStream *st = s->streams[i];
-                avcodec_copy_context(fst->codec, st->codec);
+                avcodec_parameters_to_context(fst->codec, st->codecpar);
+                avcodec_parameters_from_context(fst->codecpar, fst->codec);
             }
 
             avformat_close_input(&s);
@@ -2963,7 +3001,6 @@ static int prepare_sdp_description(FFServerStream *stream, uint8_t **pbuffer,
                                    struct in_addr my_ip)
 {
     AVFormatContext *avc;
-    AVStream *avs = NULL;
     AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
     AVDictionaryEntry *entry = av_dict_get(stream->metadata, "title", NULL, 0);
     int i;
@@ -2977,7 +3014,6 @@ static int prepare_sdp_description(FFServerStream *stream, uint8_t **pbuffer,
     avc->oformat = rtp_format;
     av_dict_set(&avc->metadata, "title",
                 entry ? entry->value : "No Title", 0);
-    avc->nb_streams = stream->nb_streams;
     if (stream->is_multicast) {
         snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
                  inet_ntoa(stream->multicast_ip),
@@ -2985,30 +3021,23 @@ static int prepare_sdp_description(FFServerStream *stream, uint8_t **pbuffer,
     } else
         snprintf(avc->filename, 1024, "rtp://0.0.0.0");
 
-    avc->streams = av_malloc_array(avc->nb_streams, sizeof(*avc->streams));
-    if (!avc->streams)
-        goto sdp_done;
-
-    avs = av_malloc_array(avc->nb_streams, sizeof(*avs));
-    if (!avs)
-        goto sdp_done;
-
     for(i = 0; i < stream->nb_streams; i++) {
-        avc->streams[i] = &avs[i];
-        avc->streams[i]->codec = stream->streams[i]->codec;
+        AVStream *st = avformat_new_stream(avc, NULL);
+        if (!st)
+            goto sdp_done;
         avcodec_parameters_from_context(stream->streams[i]->codecpar, stream->streams[i]->codec);
-        avc->streams[i]->codecpar = stream->streams[i]->codecpar;
+        unlayer_stream(st, stream->streams[i]);
     }
-    *pbuffer = av_mallocz(2048);
+#define PBUFFER_SIZE 2048
+    *pbuffer = av_mallocz(PBUFFER_SIZE);
     if (!*pbuffer)
         goto sdp_done;
-    av_sdp_create(&avc, 1, *pbuffer, 2048);
+    av_sdp_create(&avc, 1, *pbuffer, PBUFFER_SIZE);
 
  sdp_done:
     av_freep(&avc->streams);
     av_dict_free(&avc->metadata);
     av_free(avc);
-    av_free(avs);
 
     return *pbuffer ? strlen(*pbuffer) : AVERROR(ENOMEM);
 }
@@ -3432,19 +3461,16 @@ static int rtp_new_av_stream(HTTPContext *c,
     if (!st)
         goto fail;
 
-    av_freep(&st->codec);
-    av_freep(&st->info);
     st_internal = st->internal;
 
     if (!c->stream->feed ||
         c->stream->feed == c->stream)
-        memcpy(st, c->stream->streams[stream_index], sizeof(AVStream));
+        unlayer_stream(st, c->stream->streams[stream_index]);
     else
-        memcpy(st,
-               c->stream->feed->streams[c->stream->feed_streams[stream_index]],
-               sizeof(AVStream));
-    st->priv_data = NULL;
-    st->internal = st_internal;
+        unlayer_stream(st,
+               c->stream->feed->streams[c->stream->feed_streams[stream_index]]);
+    av_assert0(st->priv_data == NULL);
+    av_assert0(st->internal == st_internal);
 
     /* build destination RTP address */
     ipaddr = inet_ntoa(dest_addr->sin_addr);
@@ -3512,15 +3538,15 @@ static int rtp_new_av_stream(HTTPContext *c,
 /* ffserver initialization */
 
 /* FIXME: This code should use avformat_new_stream() */
-static AVStream *add_av_stream1(FFServerStream *stream,
+static LayeredAVStream *add_av_stream1(FFServerStream *stream,
                                 AVCodecContext *codec, int copy)
 {
-    AVStream *fst;
+    LayeredAVStream *fst;
 
     if(stream->nb_streams >= FF_ARRAY_ELEMS(stream->streams))
         return NULL;
 
-    fst = av_mallocz(sizeof(AVStream));
+    fst = av_mallocz(sizeof(*fst));
     if (!fst)
         return NULL;
     if (copy) {
@@ -3536,21 +3562,20 @@ static AVStream *add_av_stream1(FFServerStream *stream,
          */
         fst->codec = codec;
 
-    fst->priv_data = av_mallocz(sizeof(FeedData));
-    fst->internal = av_mallocz(sizeof(*fst->internal));
-    fst->internal->avctx = avcodec_alloc_context3(NULL);
+    //NOTE we previously allocated internal & internal->avctx, these seemed uneeded though
     fst->codecpar = avcodec_parameters_alloc();
     fst->index = stream->nb_streams;
-    avpriv_set_pts_info(fst, 33, 1, 90000);
+    fst->time_base = codec->time_base;
+    fst->pts_wrap_bits = 33;
     fst->sample_aspect_ratio = codec->sample_aspect_ratio;
     stream->streams[stream->nb_streams++] = fst;
     return fst;
 }
 
 /* return the stream number in the feed */
-static int add_av_stream(FFServerStream *feed, AVStream *st)
+static int add_av_stream(FFServerStream *feed, LayeredAVStream *st)
 {
-    AVStream *fst;
+    LayeredAVStream *fst;
     AVCodecContext *av, *av1;
     int i;
 
@@ -3584,9 +3609,9 @@ static int add_av_stream(FFServerStream *feed, AVStream *st)
     fst = add_av_stream1(feed, av, 0);
     if (!fst)
         return -1;
-    if (av_stream_get_recommended_encoder_configuration(st))
-        av_stream_set_recommended_encoder_configuration(fst,
-            av_strdup(av_stream_get_recommended_encoder_configuration(st)));
+    if (st->recommended_encoder_configuration)
+        fst->recommended_encoder_configuration =
+            av_strdup(st->recommended_encoder_configuration);
     return feed->nb_streams - 1;
 }
 
@@ -3602,57 +3627,6 @@ static void remove_stream(FFServerStream *stream)
     }
 }
 
-/* specific MPEG4 handling : we extract the raw parameters */
-static void extract_mpeg4_header(AVFormatContext *infile)
-{
-    int mpeg4_count, i, size;
-    AVPacket pkt;
-    AVStream *st;
-    const uint8_t *p;
-
-    infile->flags |= AVFMT_FLAG_NOFILLIN | AVFMT_FLAG_NOPARSE;
-
-    mpeg4_count = 0;
-    for(i=0;i<infile->nb_streams;i++) {
-        st = infile->streams[i];
-        if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
-            st->codec->extradata_size == 0) {
-            mpeg4_count++;
-        }
-    }
-    if (!mpeg4_count)
-        return;
-
-    printf("MPEG4 without extra data: trying to find header in %s\n",
-           infile->filename);
-    while (mpeg4_count > 0) {
-        if (av_read_frame(infile, &pkt) < 0)
-            break;
-        st = infile->streams[pkt.stream_index];
-        if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
-            st->codec->extradata_size == 0) {
-            av_freep(&st->codec->extradata);
-            /* fill extradata with the header */
-            /* XXX: we make hard suppositions here ! */
-            p = pkt.data;
-            while (p < pkt.data + pkt.size - 4) {
-                /* stop when vop header is found */
-                if (p[0] == 0x00 && p[1] == 0x00 &&
-                    p[2] == 0x01 && p[3] == 0xb6) {
-                    size = p - pkt.data;
-                    st->codec->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
-                    st->codec->extradata_size = size;
-                    memcpy(st->codec->extradata, pkt.data, size);
-                    break;
-                }
-                p++;
-            }
-            mpeg4_count--;
-        }
-        av_packet_unref(&pkt);
-    }
-}
-
 /* compute the needed AVStream for each file */
 static void build_file_streams(void)
 {
@@ -3703,7 +3677,6 @@ static void build_file_streams(void)
                 avformat_close_input(&infile);
                 goto fail;
             }
-            extract_mpeg4_header(infile);
 
             for(i=0;i<infile->nb_streams;i++)
                 add_av_stream1(stream, infile->streams[i]->codec, 1);
@@ -3714,26 +3687,25 @@ static void build_file_streams(void)
 }
 
 static inline
-int check_codec_match(AVCodecContext *ccf, AVCodecContext *ccs, int stream)
+int check_codec_match(LayeredAVStream *ccf, AVStream *ccs, int stream)
 {
     int matches = 1;
 
-#define CHECK_CODEC(x)  (ccf->x != ccs->x)
+/* FIXME: Missed check on AVCodecContext.flags */
+#define CHECK_CODEC(x)  (ccf->codecpar->x != ccs->codecpar->x)
     if (CHECK_CODEC(codec_id) || CHECK_CODEC(codec_type)) {
         http_log("Codecs do not match for stream %d\n", stream);
         matches = 0;
-    } else if (CHECK_CODEC(bit_rate) || CHECK_CODEC(flags)) {
+    } else if (CHECK_CODEC(bit_rate)) {
         http_log("Codec bitrates do not match for stream %d\n", stream);
         matches = 0;
-    } else if (ccf->codec_type == AVMEDIA_TYPE_VIDEO) {
-        if (CHECK_CODEC(time_base.den) ||
-            CHECK_CODEC(time_base.num) ||
-            CHECK_CODEC(width) ||
-            CHECK_CODEC(height)) {
+    } else if (ccf->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
+        if (av_cmp_q(ccf->time_base, ccs->time_base) ||
+            CHECK_CODEC(width) || CHECK_CODEC(height)) {
             http_log("Codec width, height or framerate do not match for stream %d\n", stream);
             matches = 0;
         }
-    } else if (ccf->codec_type == AVMEDIA_TYPE_AUDIO) {
+    } else if (ccf->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
         if (CHECK_CODEC(sample_rate) ||
             CHECK_CODEC(channels) ||
             CHECK_CODEC(frame_size)) {
@@ -3803,7 +3775,8 @@ static int build_feed_streams(void)
 
             matches = 1;
             for(i=0;i<s->nb_streams;i++) {
-                AVStream *sf, *ss;
+                AVStream *ss;
+                LayeredAVStream *sf;
 
                 sf = feed->streams[i];
                 ss = s->streams[i];
@@ -3815,7 +3788,7 @@ static int build_feed_streams(void)
                     break;
                 }
 
-                matches = check_codec_match (sf->codec, ss->codec, i);
+                matches = check_codec_match (sf, ss, i);
                 if (!matches)
                     break;
             }
@@ -3858,8 +3831,14 @@ static int build_feed_streams(void)
                 goto bail;
             }
             s->oformat = feed->fmt;
-            s->nb_streams = feed->nb_streams;
-            s->streams = feed->streams;
+            for (i = 0; i<feed->nb_streams; i++) {
+                AVStream *st = avformat_new_stream(s, NULL); // FIXME free this
+                if (!st) {
+                    http_log("Failed to allocate stream\n");
+                    goto bail;
+                }
+                unlayer_stream(st, feed->streams[i]);
+            }
             if (avformat_write_header(s, NULL) < 0) {
                 http_log("Container doesn't support the required parameters\n");
                 avio_closep(&s->pb);
@@ -3909,7 +3888,7 @@ static void compute_bandwidth(void)
     for(stream = config.first_stream; stream; stream = stream->next) {
         bandwidth = 0;
         for(i=0;i<stream->nb_streams;i++) {
-            AVStream *st = stream->streams[i];
+            LayeredAVStream *st = stream->streams[i];
             switch(st->codec->codec_type) {
             case AVMEDIA_TYPE_AUDIO:
             case AVMEDIA_TYPE_VIDEO:
@@ -3967,7 +3946,7 @@ void show_help_default(const char *opt, const char *arg)
 }
 
 static const OptionDef options[] = {
-#include "cmdutils_common_opts.h"
+    CMDUTILS_COMMON_OPTIONS
     { "n", OPT_BOOL, {(void *)&no_launch }, "enable no-launch mode" },
     { "d", 0, {(void*)opt_debug}, "enable debug mode" },
     { "f", HAS_ARG | OPT_STRING, {(void*)&config.filename }, "use configfile instead of /etc/ffserver.conf", "configfile" },
diff --git a/mythtv/external/FFmpeg/fftools/ffserver_config.c b/mythtv/external/FFmpeg/fftools/ffserver_config.c
index 0ec93b5fda2..54135be989c 100644
--- a/mythtv/external/FFmpeg/fftools/ffserver_config.c
+++ b/mythtv/external/FFmpeg/fftools/ffserver_config.c
@@ -25,9 +25,6 @@
 #include "libavutil/pixdesc.h"
 #include "libavutil/avassert.h"
 
-// FIXME those are internal headers, ffserver _really_ shouldn't use them
-#include "libavformat/ffm.h"
-
 #include "cmdutils.h"
 #include "ffserver_config.h"
 
@@ -153,6 +150,11 @@ void ffserver_parse_acl_row(FFServerStream *stream, FFServerStream* feed,
     }
 
     nacl = av_mallocz(sizeof(*nacl));
+    if (!nacl) {
+        fprintf(stderr, "Failed to allocate FFServerIPAddressACL\n");
+        goto bail;
+    }
+
     naclp = 0;
 
     acl.next = 0;
@@ -185,7 +187,7 @@ void ffserver_parse_acl_row(FFServerStream *stream, FFServerStream* feed,
 static void add_codec(FFServerStream *stream, AVCodecContext *av,
                       FFServerConfig *config)
 {
-    AVStream *st;
+    LayeredAVStream *st;
     AVDictionary **opts, *recommended = NULL;
     char *enc_config;
 
@@ -316,13 +318,15 @@ static void add_codec(FFServerStream *stream, AVCodecContext *av,
     }
 
 done:
-    st = av_mallocz(sizeof(AVStream));
+    st = av_mallocz(sizeof(*st));
     if (!st)
         return;
     av_dict_get_string(recommended, &enc_config, '=', ',');
     av_dict_free(&recommended);
-    av_stream_set_recommended_encoder_configuration(st, enc_config);
+    st->recommended_encoder_configuration = enc_config;
     st->codec = av;
+    st->codecpar = avcodec_parameters_alloc();
+    avcodec_parameters_from_context(st->codecpar, av);
     stream->streams[stream->nb_streams++] = st;
 }
 
@@ -1049,6 +1053,7 @@ static int ffserver_parse_config_stream(FFServerConfig *config, const char *cmd,
                                        AV_OPT_FLAG_VIDEO_PARAM, config) < 0)
             goto nomem;
     } else if (!av_strcasecmp(cmd, "BitExact")) {
+        config->bitexact = 1;
         if (ffserver_save_avoption("flags", "+bitexact", AV_OPT_FLAG_VIDEO_PARAM, config) < 0)
             goto nomem;
     } else if (!av_strcasecmp(cmd, "DctFastint")) {
diff --git a/mythtv/external/FFmpeg/fftools/ffserver_config.h b/mythtv/external/FFmpeg/fftools/ffserver_config.h
index 1b121946c1e..089b8484da3 100644
--- a/mythtv/external/FFmpeg/fftools/ffserver_config.h
+++ b/mythtv/external/FFmpeg/fftools/ffserver_config.h
@@ -18,8 +18,10 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#ifndef FFSERVER_CONFIG_H
-#define FFSERVER_CONFIG_H
+#ifndef FFTOOLS_FFSERVER_CONFIG_H
+#define FFTOOLS_FFSERVER_CONFIG_H
+
+#define FFM_PACKET_SIZE 4096
 
 #include "libavutil/dict.h"
 #include "libavformat/avformat.h"
@@ -47,6 +49,24 @@ typedef struct FFServerIPAddressACL {
     struct in_addr last;
 } FFServerIPAddressACL;
 
+/**
+ * This holds the stream parameters for an AVStream, it cannot be a AVStream
+ * because AVStreams cannot be instanciated without a AVFormatContext, especially
+ * not outside libavformat.
+ *
+ * The fields of this struct have the same semantics as the fields of an AVStream.
+ */
+typedef struct LayeredAVStream {
+    int index;
+    int id;
+    AVCodecParameters *codecpar;
+    AVCodecContext *codec;
+    AVRational time_base;
+    int pts_wrap_bits;
+    AVRational sample_aspect_ratio;
+    char *recommended_encoder_configuration;
+} LayeredAVStream;
+
 /* description of each stream of the ffserver.conf file */
 typedef struct FFServerStream {
     enum FFServerStreamType stream_type;
@@ -62,7 +82,7 @@ typedef struct FFServerStream {
     int prebuffer;                /* Number of milliseconds early to start */
     int64_t max_time;             /* Number of milliseconds to run */
     int send_on_key;
-    AVStream *streams[FFSERVER_MAX_STREAMS];
+    LayeredAVStream *streams[FFSERVER_MAX_STREAMS];
     int feed_streams[FFSERVER_MAX_STREAMS]; /* index of streams in the feed */
     char feed_filename[1024];     /* file name of the feed storage, or
                                      input file name for a stream */
@@ -102,6 +122,7 @@ typedef struct FFServerConfig {
     unsigned int nb_max_connections;
     uint64_t max_bandwidth;
     int debug;
+    int bitexact;
     char logfilename[1024];
     struct sockaddr_in http_addr;
     struct sockaddr_in rtsp_addr;
@@ -131,4 +152,4 @@ int ffserver_parse_ffconfig(const char *filename, FFServerConfig *config);
 
 void ffserver_free_child_args(void *argsp);
 
-#endif /* FFSERVER_CONFIG_H */
+#endif /* FFTOOLS_FFSERVER_CONFIG_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/4xm.c b/mythtv/external/FFmpeg/libavcodec/4xm.c
index a7a757a0784..5547dfd87f2 100644
--- a/mythtv/external/FFmpeg/libavcodec/4xm.c
+++ b/mythtv/external/FFmpeg/libavcodec/4xm.c
@@ -532,7 +532,7 @@ static int decode_i_block(FourXContext *f, int16_t *block)
             }
             i    += code >> 4;
             if (i >= 64) {
-                av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
+                av_log(f->avctx, AV_LOG_ERROR, "run %d overflow\n", i);
                 return 0;
             }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/8bps.c b/mythtv/external/FFmpeg/libavcodec/8bps.c
index 49fd4454948..aa2318fa2d8 100644
--- a/mythtv/external/FFmpeg/libavcodec/8bps.c
+++ b/mythtv/external/FFmpeg/libavcodec/8bps.c
@@ -122,12 +122,15 @@ static int decode_frame(AVCodecContext *avctx, void *data,
     }
 
     if (avctx->bits_per_coded_sample <= 8) {
+        int size;
         const uint8_t *pal = av_packet_get_side_data(avpkt,
                                                      AV_PKT_DATA_PALETTE,
-                                                     NULL);
-        if (pal) {
+                                                     &size);
+        if (pal && size == AVPALETTE_SIZE) {
             frame->palette_has_changed = 1;
             memcpy(c->pal, pal, AVPALETTE_SIZE);
+        } else if (pal) {
+            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
         }
 
         memcpy (frame->data[1], c->pal, AVPALETTE_SIZE);
diff --git a/mythtv/external/FFmpeg/libavcodec/Makefile b/mythtv/external/FFmpeg/libavcodec/Makefile
index c6b3140e5d5..f2e413642ec 100644
--- a/mythtv/external/FFmpeg/libavcodec/Makefile
+++ b/mythtv/external/FFmpeg/libavcodec/Makefile
@@ -1,6 +1,5 @@
-include $(SUBDIR)../config.mak
-
 NAME = avcodec
+DESC = FFmpeg codec library
 
 HEADERS = avcodec.h                                                     \
           avdct.h                                                       \
@@ -31,13 +30,17 @@ OBJS = allcodecs.o                                                      \
        bsf.o                                                            \
        codec_desc.o                                                     \
        d3d11va.o                                                        \
+       decode.o                                                         \
        dirac.o                                                          \
        dv_profile.o                                                     \
+       encode.o                                                         \
        imgconvert.o                                                     \
        jni.o                                                            \
        mathtables.o                                                     \
        mediacodec.o                                                     \
+       mpeg12framerate.o                                                \
        options.o                                                        \
+       mjpegenc_huffman.o                                               \
        parser.o                                                         \
        profiles.o                                                       \
        qsv_api.o                                                        \
@@ -51,7 +54,7 @@ OBJS = allcodecs.o                                                      \
 
 # subsystems
 OBJS-$(CONFIG_AANDCTTABLES)            += aandcttab.o
-OBJS-$(CONFIG_AC3DSP)                  += ac3dsp.o
+OBJS-$(CONFIG_AC3DSP)                  += ac3dsp.o ac3.o ac3tab.o
 OBJS-$(CONFIG_AUDIO_FRAME_QUEUE)       += audio_frame_queue.o
 OBJS-$(CONFIG_AUDIODSP)                += audiodsp.o
 OBJS-$(CONFIG_BLOCKDSP)                += blockdsp.o
@@ -74,22 +77,25 @@ OBJS-$(CONFIG_GOLOMB)                  += golomb.o
 OBJS-$(CONFIG_H263DSP)                 += h263dsp.o
 OBJS-$(CONFIG_H264CHROMA)              += h264chroma.o
 OBJS-$(CONFIG_H264DSP)                 += h264dsp.o h264idct.o
+OBJS-$(CONFIG_H264PARSE)               += h264_parse.o h2645_parse.o h264_ps.o
 OBJS-$(CONFIG_H264PRED)                += h264pred.o
 OBJS-$(CONFIG_H264QPEL)                += h264qpel.o
+OBJS-$(CONFIG_HEVCPARSE)               += hevc_parse.o h2645_parse.o hevc_ps.o hevc_sei.o hevc_data.o
 OBJS-$(CONFIG_HPELDSP)                 += hpeldsp.o
 OBJS-$(CONFIG_HUFFMAN)                 += huffman.o
 OBJS-$(CONFIG_HUFFYUVDSP)              += huffyuvdsp.o
 OBJS-$(CONFIG_HUFFYUVENCDSP)           += huffyuvencdsp.o
 OBJS-$(CONFIG_IDCTDSP)                 += idctdsp.o simple_idct.o jrevdct.o
 OBJS-$(CONFIG_IIRFILTER)               += iirfilter.o
-OBJS-$(CONFIG_IMDCT15)                 += imdct15.o
-OBJS-$(CONFIG_INTRAX8)                 += intrax8.o intrax8dsp.o
+OBJS-$(CONFIG_MDCT15)                  += mdct15.o
+OBJS-$(CONFIG_INTRAX8)                 += intrax8.o intrax8dsp.o msmpeg4data.o
 OBJS-$(CONFIG_IVIDSP)                  += ivi_dsp.o
 OBJS-$(CONFIG_JNI)                     += ffjni.o jni.o
 OBJS-$(CONFIG_JPEGTABLES)              += jpegtables.o
 OBJS-$(CONFIG_LIBXVID)                 += libxvid_rc.o
 OBJS-$(CONFIG_LLAUDDSP)                += lossless_audiodsp.o
 OBJS-$(CONFIG_LLVIDDSP)                += lossless_videodsp.o
+OBJS-$(CONFIG_LLVIDENCDSP)             += lossless_videoencdsp.o
 OBJS-$(CONFIG_LPC)                     += lpc.o
 OBJS-$(CONFIG_LSP)                     += lsp.o
 OBJS-$(CONFIG_LZF)                     += lzf.o
@@ -97,12 +103,12 @@ OBJS-$(CONFIG_MDCT)                    += mdct_fixed.o mdct_float.o mdct_fixed_3
 OBJS-$(CONFIG_ME_CMP)                  += me_cmp.o
 OBJS-$(CONFIG_MEDIACODEC)              += mediacodecdec_common.o mediacodec_surface.o mediacodec_wrapper.o mediacodec_sw_buffer.o
 OBJS-$(CONFIG_MPEG_ER)                 += mpeg_er.o
-OBJS-$(CONFIG_MPEGAUDIO)               += mpegaudio.o mpegaudiodata.o   \
-                                          mpegaudiodecheader.o
+OBJS-$(CONFIG_MPEGAUDIO)               += mpegaudio.o
 OBJS-$(CONFIG_MPEGAUDIODSP)            += mpegaudiodsp.o                \
                                           mpegaudiodsp_data.o           \
                                           mpegaudiodsp_fixed.o          \
                                           mpegaudiodsp_float.o
+OBJS-$(CONFIG_MPEGAUDIOHEADER)         += mpegaudiodecheader.o mpegaudiodata.o
 OBJS-$(CONFIG_MPEGVIDEO)               += mpegvideo.o mpegvideodsp.o rl.o \
                                           mpegvideo_motion.o mpegutils.o \
                                           mpegvideodata.o mpegpicture.o
@@ -117,8 +123,7 @@ OBJS-$(CONFIG_QSV)                     += qsv.o
 OBJS-$(CONFIG_QSVDEC)                  += qsvdec.o
 OBJS-$(CONFIG_QSVENC)                  += qsvenc.o
 OBJS-$(CONFIG_RANGECODER)              += rangecoder.o
-RDFT-OBJS-$(CONFIG_HARDCODED_TABLES)   += sin_tables.o
-OBJS-$(CONFIG_RDFT)                    += rdft.o $(RDFT-OBJS-yes)
+OBJS-$(CONFIG_RDFT)                    += rdft.o
 OBJS-$(CONFIG_RV34DSP)                 += rv34dsp.o
 OBJS-$(CONFIG_SHARED)                  += log2_tab.o reverse.o
 OBJS-$(CONFIG_SINEWIN)                 += sinewin.o sinewin_fixed.o
@@ -133,6 +138,7 @@ OBJS-$(CONFIG_VIDEODSP)                += videodsp.o
 OBJS-$(CONFIG_VP3DSP)                  += vp3dsp.o
 OBJS-$(CONFIG_VP56DSP)                 += vp56dsp.o
 OBJS-$(CONFIG_VP8DSP)                  += vp8dsp.o
+OBJS-$(CONFIG_V4L2_M2M)                += v4l2_m2m.o v4l2_context.o v4l2_buffers.o v4l2_fmt.o
 OBJS-$(CONFIG_WMA_FREQS)               += wma_freqs.o
 OBJS-$(CONFIG_WMV2DSP)                 += wmv2dsp.o
 
@@ -154,8 +160,8 @@ OBJS-$(CONFIG_AAC_ENCODER)             += aacenc.o aaccoder.o aacenctab.o    \
                                           aacenc_pred.o \
                                           psymodel.o mpeg4audio.o kbdwin.o cbrt_data.o
 OBJS-$(CONFIG_AASC_DECODER)            += aasc.o msrledec.o
-OBJS-$(CONFIG_AC3_DECODER)             += ac3dec_float.o ac3dec_data.o ac3.o kbdwin.o
-OBJS-$(CONFIG_AC3_FIXED_DECODER)       += ac3dec_fixed.o ac3dec_data.o ac3.o kbdwin.o
+OBJS-$(CONFIG_AC3_DECODER)             += ac3dec_float.o ac3dec_data.o ac3.o kbdwin.o ac3tab.o
+OBJS-$(CONFIG_AC3_FIXED_DECODER)       += ac3dec_fixed.o ac3dec_data.o ac3.o kbdwin.o ac3tab.o
 OBJS-$(CONFIG_AC3_ENCODER)             += ac3enc_float.o ac3enc.o ac3tab.o \
                                           ac3.o kbdwin.o
 OBJS-$(CONFIG_AC3_FIXED_ENCODER)       += ac3enc_fixed.o ac3enc.o ac3tab.o ac3.o
@@ -174,9 +180,7 @@ OBJS-$(CONFIG_AMRWB_DECODER)           += amrwbdec.o celp_filters.o   \
                                           acelp_vectors.o             \
                                           acelp_pitch_delay.o
 OBJS-$(CONFIG_AMV_ENCODER)             += mjpegenc.o mjpegenc_common.o \
-                                          mpegvideo_enc.o motion_est.o \
-                                          ratecontrol.o mpeg12data.o   \
-                                          mpegvideo.o
+                                          mjpegenc_huffman.o
 OBJS-$(CONFIG_ANM_DECODER)             += anm.o
 OBJS-$(CONFIG_ANSI_DECODER)            += ansi.o cga_data.o
 OBJS-$(CONFIG_APE_DECODER)             += apedec.o
@@ -192,8 +196,11 @@ OBJS-$(CONFIG_ASV2_DECODER)            += asvdec.o asv.o mpeg12data.o
 OBJS-$(CONFIG_ASV2_ENCODER)            += asvenc.o asv.o mpeg12data.o
 OBJS-$(CONFIG_ATRAC1_DECODER)          += atrac1.o atrac.o
 OBJS-$(CONFIG_ATRAC3_DECODER)          += atrac3.o atrac.o
+OBJS-$(CONFIG_ATRAC3AL_DECODER)        += atrac3.o atrac.o
 OBJS-$(CONFIG_ATRAC3P_DECODER)         += atrac3plusdec.o atrac3plus.o \
                                           atrac3plusdsp.o atrac.o
+OBJS-$(CONFIG_ATRAC3PAL_DECODER)       += atrac3plusdec.o atrac3plus.o \
+                                          atrac3plusdsp.o atrac.o
 OBJS-$(CONFIG_AURA_DECODER)            += cyuv.o
 OBJS-$(CONFIG_AURA2_DECODER)           += aura.o
 OBJS-$(CONFIG_AVRN_DECODER)            += avrndec.o mjpegdec.o
@@ -210,6 +217,7 @@ OBJS-$(CONFIG_BINK_DECODER)            += bink.o binkdsp.o
 OBJS-$(CONFIG_BINKAUDIO_DCT_DECODER)   += binkaudio.o
 OBJS-$(CONFIG_BINKAUDIO_RDFT_DECODER)  += binkaudio.o
 OBJS-$(CONFIG_BINTEXT_DECODER)         += bintext.o cga_data.o
+OBJS-$(CONFIG_BITPACKED_DECODER)       += bitpacked.o
 OBJS-$(CONFIG_BMP_DECODER)             += bmp.o msrledec.o
 OBJS-$(CONFIG_BMP_ENCODER)             += bmpenc.o
 OBJS-$(CONFIG_BMV_AUDIO_DECODER)       += bmvaudio.o
@@ -217,13 +225,14 @@ OBJS-$(CONFIG_BMV_VIDEO_DECODER)       += bmvvideo.o
 OBJS-$(CONFIG_BRENDER_PIX_DECODER)     += brenderpix.o
 OBJS-$(CONFIG_C93_DECODER)             += c93.o
 OBJS-$(CONFIG_CAVS_DECODER)            += cavs.o cavsdec.o cavsdsp.o \
-                                          cavsdata.o mpeg12data.o
+                                          cavsdata.o
 OBJS-$(CONFIG_CCAPTION_DECODER)        += ccaption_dec.o
 OBJS-$(CONFIG_CDGRAPHICS_DECODER)      += cdgraphics.o
 OBJS-$(CONFIG_CDXL_DECODER)            += cdxl.o
 OBJS-$(CONFIG_CFHD_DECODER)            += cfhd.o cfhddata.o
 OBJS-$(CONFIG_CINEPAK_DECODER)         += cinepak.o
 OBJS-$(CONFIG_CINEPAK_ENCODER)         += cinepakenc.o elbg.o
+OBJS-$(CONFIG_CLEARVIDEO_DECODER)      += clearvideo.o
 OBJS-$(CONFIG_CLJR_DECODER)            += cljrdec.o
 OBJS-$(CONFIG_CLJR_ENCODER)            += cljrenc.o
 OBJS-$(CONFIG_CLLC_DECODER)            += cllc.o canopus.o
@@ -236,14 +245,15 @@ OBJS-$(CONFIG_CYUV_DECODER)            += cyuv.o
 OBJS-$(CONFIG_DCA_DECODER)             += dcadec.o dca.o dcadata.o dcahuff.o \
                                           dca_core.o dca_exss.o dca_xll.o dca_lbr.o \
                                           dcadsp.o dcadct.o synth_filter.o
-OBJS-$(CONFIG_DCA_ENCODER)             += dcaenc.o dca.o dcadata.o
+OBJS-$(CONFIG_DCA_ENCODER)             += dcaenc.o dca.o dcadata.o dcahuff.o \
+                                          dcaadpcm.o
 OBJS-$(CONFIG_DDS_DECODER)             += dds.o
 OBJS-$(CONFIG_DIRAC_DECODER)           += diracdec.o dirac.o diracdsp.o diractab.o \
-                                          dirac_arith.o mpeg12data.o dirac_dwt.o \
-                                          dirac_vlc.o
+                                          dirac_arith.o dirac_dwt.o dirac_vlc.o
 OBJS-$(CONFIG_DFA_DECODER)             += dfa.o
 OBJS-$(CONFIG_DNXHD_DECODER)           += dnxhddec.o dnxhddata.o
 OBJS-$(CONFIG_DNXHD_ENCODER)           += dnxhdenc.o dnxhddata.o
+OBJS-$(CONFIG_DOLBY_E_DECODER)         += dolby_e.o kbdwin.o
 OBJS-$(CONFIG_DPX_DECODER)             += dpx.o
 OBJS-$(CONFIG_DPX_ENCODER)             += dpxenc.o
 OBJS-$(CONFIG_DSD_LSBF_DECODER)        += dsddec.o dsd.o
@@ -278,11 +288,13 @@ OBJS-$(CONFIG_EIGHTSVX_FIB_DECODER)    += 8svx.o
 OBJS-$(CONFIG_ESCAPE124_DECODER)       += escape124.o
 OBJS-$(CONFIG_ESCAPE130_DECODER)       += escape130.o
 OBJS-$(CONFIG_EVRC_DECODER)            += evrcdec.o acelp_vectors.o lsp.o
-OBJS-$(CONFIG_EXR_DECODER)             += exr.o
+OBJS-$(CONFIG_EXR_DECODER)             += exr.o exrdsp.o
 OBJS-$(CONFIG_FFV1_DECODER)            += ffv1dec.o ffv1.o
 OBJS-$(CONFIG_FFV1_ENCODER)            += ffv1enc.o ffv1.o
 OBJS-$(CONFIG_FFWAVESYNTH_DECODER)     += ffwavesynth.o
 OBJS-$(CONFIG_FIC_DECODER)             += fic.o
+OBJS-$(CONFIG_FITS_DECODER)            += fitsdec.o fits.o
+OBJS-$(CONFIG_FITS_ENCODER)            += fitsenc.o
 OBJS-$(CONFIG_FLAC_DECODER)            += flacdec.o flacdata.o flac.o
 OBJS-$(CONFIG_FLAC_ENCODER)            += flacenc.o flacdata.o flac.o vorbis_data.o
 OBJS-$(CONFIG_FLASHSV_DECODER)         += flashsv.o
@@ -290,6 +302,7 @@ OBJS-$(CONFIG_FLASHSV_ENCODER)         += flashsvenc.o
 OBJS-$(CONFIG_FLASHSV2_ENCODER)        += flashsv2enc.o
 OBJS-$(CONFIG_FLASHSV2_DECODER)        += flashsv.o
 OBJS-$(CONFIG_FLIC_DECODER)            += flicvideo.o
+OBJS-$(CONFIG_FMVC_DECODER)            += fmvc.o
 OBJS-$(CONFIG_FOURXM_DECODER)          += 4xm.o
 OBJS-$(CONFIG_FRAPS_DECODER)           += fraps.o
 OBJS-$(CONFIG_FRWU_DECODER)            += frwu.o
@@ -299,8 +312,10 @@ OBJS-$(CONFIG_G723_1_DECODER)          += g723_1dec.o g723_1.o \
 OBJS-$(CONFIG_G723_1_ENCODER)          += g723_1enc.o g723_1.o \
                                           acelp_vectors.o celp_filters.o celp_math.o
 OBJS-$(CONFIG_G729_DECODER)            += g729dec.o lsp.o celp_math.o celp_filters.o acelp_filters.o acelp_pitch_delay.o acelp_vectors.o g729postfilter.o
+OBJS-$(CONFIG_GDV_DECODER)             += gdv.o
 OBJS-$(CONFIG_GIF_DECODER)             += gifdec.o lzw.o
 OBJS-$(CONFIG_GIF_ENCODER)             += gif.o lzwenc.o
+OBJS-$(CONFIG_GREMLIN_DPCM_DECODER)    += dpcm.o
 OBJS-$(CONFIG_GSM_DECODER)             += gsmdec.o gsmdec_data.o msgsmdec.o
 OBJS-$(CONFIG_GSM_MS_DECODER)          += gsmdec.o gsmdec_data.o msgsmdec.o
 OBJS-$(CONFIG_H261_DECODER)            += h261dec.o h261data.o h261.o
@@ -310,12 +325,13 @@ OBJS-$(CONFIG_H263_DECODER)            += h263dec.o h263.o ituh263dec.o        \
                                           intelh263dec.o h263data.o
 OBJS-$(CONFIG_H263_ENCODER)            += mpeg4videoenc.o mpeg4video.o  \
                                           h263.o ituh263enc.o flvenc.o h263data.o
+OBJS-$(CONFIG_H263_V4L2M2M_DECODER)    += v4l2_m2m_dec.o
+OBJS-$(CONFIG_H263_V4L2M2M_ENCODER)    += v4l2_m2m_enc.o
 OBJS-$(CONFIG_H264_DECODER)            += h264dec.o h264_cabac.o h264_cavlc.o \
                                           h264_direct.o h264_loopfilter.o  \
-                                          h264_mb.o h264_picture.o h264_ps.o \
+                                          h264_mb.o h264_picture.o \
                                           h264_refs.o h264_sei.o \
-                                          h264_slice.o h264data.o h264_parse.o \
-                                          h2645_parse.o
+                                          h264_slice.o h264data.o
 OBJS-$(CONFIG_H264_CUVID_DECODER)      += cuvid.o
 OBJS-$(CONFIG_H264_MEDIACODEC_DECODER) += mediacodecdec.o
 OBJS-$(CONFIG_H264_MMAL_DECODER)       += mmaldec.o
@@ -326,20 +342,27 @@ OBJS-$(CONFIG_H264_VDA_DECODER)        += vda_h264_dec.o
 OBJS-$(CONFIG_H264_OMX_ENCODER)        += omx.o
 OBJS-$(CONFIG_H264_QSV_DECODER)        += qsvdec_h2645.o
 OBJS-$(CONFIG_H264_QSV_ENCODER)        += qsvenc_h264.o
+OBJS-$(CONFIG_H264_RKMPP_DECODER)      += rkmppdec.o
 OBJS-$(CONFIG_H264_VAAPI_ENCODER)      += vaapi_encode_h264.o vaapi_encode_h26x.o
 OBJS-$(CONFIG_H264_VIDEOTOOLBOX_ENCODER) += videotoolboxenc.o
+OBJS-$(CONFIG_H264_V4L2M2M_DECODER)    += v4l2_m2m_dec.o
+OBJS-$(CONFIG_H264_V4L2M2M_ENCODER)    += v4l2_m2m_enc.o
 OBJS-$(CONFIG_HAP_DECODER)             += hapdec.o hap.o
 OBJS-$(CONFIG_HAP_ENCODER)             += hapenc.o hap.o
-OBJS-$(CONFIG_HEVC_DECODER)            += hevc.o hevc_mvs.o hevc_ps.o hevc_sei.o \
+OBJS-$(CONFIG_HEVC_DECODER)            += hevcdec.o hevc_mvs.o \
                                           hevc_cabac.o hevc_refs.o hevcpred.o    \
-                                          hevcdsp.o hevc_filter.o h2645_parse.o hevc_data.o
+                                          hevcdsp.o hevc_filter.o hevc_data.o
 OBJS-$(CONFIG_HEVC_CUVID_DECODER)      += cuvid.o
-OBJS-$(CONFIG_HEVC_MEDIACODEC_DECODER) += mediacodecdec.o hevc_parse.o
+OBJS-$(CONFIG_HEVC_MEDIACODEC_DECODER) += mediacodecdec.o
 OBJS-$(CONFIG_HEVC_NVENC_ENCODER)      += nvenc_hevc.o
 OBJS-$(CONFIG_NVENC_HEVC_ENCODER)      += nvenc_hevc.o
 OBJS-$(CONFIG_HEVC_QSV_DECODER)        += qsvdec_h2645.o
-OBJS-$(CONFIG_HEVC_QSV_ENCODER)        += qsvenc_hevc.o hevc_ps_enc.o h2645_parse.o
+OBJS-$(CONFIG_HEVC_QSV_ENCODER)        += qsvenc_hevc.o hevc_ps_enc.o       \
+                                          hevc_data.o
+OBJS-$(CONFIG_HEVC_RKMPP_DECODER)      += rkmppdec.o
 OBJS-$(CONFIG_HEVC_VAAPI_ENCODER)      += vaapi_encode_h265.o vaapi_encode_h26x.o
+OBJS-$(CONFIG_HEVC_V4L2M2M_DECODER)    += v4l2_m2m_dec.o
+OBJS-$(CONFIG_HEVC_V4L2M2M_ENCODER)    += v4l2_m2m_enc.o
 OBJS-$(CONFIG_HNM4_VIDEO_DECODER)      += hnm4video.o
 OBJS-$(CONFIG_HQ_HQA_DECODER)          += hq_hqa.o hq_hqadata.o hq_hqadsp.o \
                                           canopus.o
@@ -380,7 +403,8 @@ OBJS-$(CONFIG_METASOUND_DECODER)       += metasound.o metasound_data.o \
 OBJS-$(CONFIG_MICRODVD_DECODER)        += microdvddec.o ass.o
 OBJS-$(CONFIG_MIMIC_DECODER)           += mimic.o
 OBJS-$(CONFIG_MJPEG_DECODER)           += mjpegdec.o
-OBJS-$(CONFIG_MJPEG_ENCODER)           += mjpegenc.o mjpegenc_common.o
+OBJS-$(CONFIG_MJPEG_ENCODER)           += mjpegenc.o mjpegenc_common.o \
+                                          mjpegenc_huffman.o
 OBJS-$(CONFIG_MJPEGB_DECODER)          += mjpegbdec.o
 OBJS-$(CONFIG_MJPEG_VAAPI_ENCODER)     += vaapi_encode_mjpeg.o
 OBJS-$(CONFIG_MLP_DECODER)             += mlpdec.o mlpdsp.o
@@ -408,16 +432,23 @@ OBJS-$(CONFIG_MPC8_DECODER)            += mpc8.o mpc.o
 OBJS-$(CONFIG_MPEGVIDEO_DECODER)       += mpeg12dec.o mpeg12.o mpeg12data.o
 OBJS-$(CONFIG_MPEG1VIDEO_DECODER)      += mpeg12dec.o mpeg12.o mpeg12data.o
 OBJS-$(CONFIG_MPEG1VIDEO_ENCODER)      += mpeg12enc.o mpeg12.o
+OBJS-$(CONFIG_MPEG1_V4L2M2M_DECODER)   += v4l2_m2m_dec.o
 OBJS-$(CONFIG_MPEG2_MMAL_DECODER)      += mmaldec.o
-OBJS-$(CONFIG_MPEG2_QSV_DECODER)       += qsvdec_mpeg2.o
+OBJS-$(CONFIG_MPEG2_QSV_DECODER)       += qsvdec_other.o
 OBJS-$(CONFIG_MPEG2_QSV_ENCODER)       += qsvenc_mpeg2.o
 OBJS-$(CONFIG_MPEG2VIDEO_DECODER)      += mpeg12dec.o mpeg12.o mpeg12data.o
 OBJS-$(CONFIG_MPEG2VIDEO_ENCODER)      += mpeg12enc.o mpeg12.o
+OBJS-$(CONFIG_MPEG2_MEDIACODEC_DECODER) += mediacodecdec.o
+OBJS-$(CONFIG_MPEG2_VAAPI_ENCODER)     += vaapi_encode_mpeg2.o
+OBJS-$(CONFIG_MPEG2_V4L2M2M_DECODER)   += v4l2_m2m_dec.o
 OBJS-$(CONFIG_MPEG4_DECODER)           += xvididct.o
 OBJS-$(CONFIG_MPEG4_MEDIACODEC_DECODER) += mediacodecdec.o
 OBJS-$(CONFIG_MPEG4_OMX_ENCODER)       += omx.o
+OBJS-$(CONFIG_MPEG4_V4L2M2M_DECODER)   += v4l2_m2m_dec.o
+OBJS-$(CONFIG_MPEG4_V4L2M2M_ENCODER)   += v4l2_m2m_enc.o
 OBJS-$(CONFIG_MPL2_DECODER)            += mpl2dec.o ass.o
 OBJS-$(CONFIG_MSA1_DECODER)            += mss3.o
+OBJS-$(CONFIG_MSCC_DECODER)            += mscc.o
 OBJS-$(CONFIG_MSMPEG4V1_DECODER)       += msmpeg4dec.o msmpeg4.o msmpeg4data.o
 OBJS-$(CONFIG_MSMPEG4V2_DECODER)       += msmpeg4dec.o msmpeg4.o msmpeg4data.o
 OBJS-$(CONFIG_MSMPEG4V2_ENCODER)       += msmpeg4enc.o msmpeg4.o msmpeg4data.o
@@ -437,8 +468,10 @@ OBJS-$(CONFIG_NELLYMOSER_DECODER)      += nellymoserdec.o nellymoser.o
 OBJS-$(CONFIG_NELLYMOSER_ENCODER)      += nellymoserenc.o nellymoser.o
 OBJS-$(CONFIG_NUV_DECODER)             += nuv.o rtjpeg.o
 OBJS-$(CONFIG_ON2AVC_DECODER)          += on2avc.o on2avcdata.o
-OBJS-$(CONFIG_OPUS_DECODER)            += opusdec.o opus.o opus_celt.o \
-                                          opus_silk.o vorbis_data.o
+OBJS-$(CONFIG_OPUS_DECODER)            += opusdec.o opus.o opus_celt.o opus_rc.o \
+                                          opus_pvq.o opus_silk.o opustab.o vorbis_data.o
+OBJS-$(CONFIG_OPUS_ENCODER)            += opusenc.o opus_rc.o opustab.o opus_pvq.o \
+                                          opusenc_psy.o
 OBJS-$(CONFIG_PAF_AUDIO_DECODER)       += pafaudio.o
 OBJS-$(CONFIG_PAF_VIDEO_DECODER)       += pafvideo.o
 OBJS-$(CONFIG_PAM_DECODER)             += pnmdec.o pnm.o
@@ -453,6 +486,7 @@ OBJS-$(CONFIG_PGMYUV_DECODER)          += pnmdec.o pnm.o
 OBJS-$(CONFIG_PGMYUV_ENCODER)          += pnmenc.o
 OBJS-$(CONFIG_PGSSUB_DECODER)          += pgssubdec.o
 OBJS-$(CONFIG_PICTOR_DECODER)          += pictordec.o cga_data.o
+OBJS-$(CONFIG_PIXLET_DECODER)          += pixlet.o
 OBJS-$(CONFIG_PJS_DECODER)             += textdec.o ass.o
 OBJS-$(CONFIG_PNG_DECODER)             += png.o pngdec.o pngdsp.o
 OBJS-$(CONFIG_PNG_ENCODER)             += png.o pngenc.o
@@ -463,11 +497,13 @@ OBJS-$(CONFIG_PRORES_LGPL_DECODER)     += proresdec_lgpl.o proresdsp.o proresdat
 OBJS-$(CONFIG_PRORES_ENCODER)          += proresenc_anatoliy.o
 OBJS-$(CONFIG_PRORES_AW_ENCODER)       += proresenc_anatoliy.o
 OBJS-$(CONFIG_PRORES_KS_ENCODER)       += proresenc_kostya.o proresdata.o
+OBJS-$(CONFIG_PSD_DECODER)             += psd.o
 OBJS-$(CONFIG_PTX_DECODER)             += ptx.o
 OBJS-$(CONFIG_QCELP_DECODER)           += qcelpdec.o                     \
                                           celp_filters.o acelp_vectors.o \
                                           acelp_filters.o
 OBJS-$(CONFIG_QDM2_DECODER)            += qdm2.o
+OBJS-$(CONFIG_QDMC_DECODER)            += qdmc.o
 OBJS-$(CONFIG_QDRAW_DECODER)           += qdrw.o
 OBJS-$(CONFIG_QPEG_DECODER)            += qpeg.o
 OBJS-$(CONFIG_QTRLE_DECODER)           += qtrle.o
@@ -500,6 +536,7 @@ OBJS-$(CONFIG_SAMI_DECODER)            += samidec.o ass.o htmlsubtitles.o
 OBJS-$(CONFIG_S302M_DECODER)           += s302m.o
 OBJS-$(CONFIG_S302M_ENCODER)           += s302menc.o
 OBJS-$(CONFIG_SANM_DECODER)            += sanm.o
+OBJS-$(CONFIG_SCPR_DECODER)            += scpr.o
 OBJS-$(CONFIG_SCREENPRESSO_DECODER)    += screenpresso.o
 OBJS-$(CONFIG_SDX2_DPCM_DECODER)       += dpcm.o
 OBJS-$(CONFIG_SGI_DECODER)             += sgidec.o
@@ -522,7 +559,9 @@ OBJS-$(CONFIG_SOL_DPCM_DECODER)        += dpcm.o
 OBJS-$(CONFIG_SONIC_DECODER)           += sonic.o
 OBJS-$(CONFIG_SONIC_ENCODER)           += sonic.o
 OBJS-$(CONFIG_SONIC_LS_ENCODER)        += sonic.o
+OBJS-$(CONFIG_SPEEDHQ_DECODER)         += speedhq.o simple_idct.o
 OBJS-$(CONFIG_SP5X_DECODER)            += sp5xdec.o
+OBJS-$(CONFIG_SRGC_DECODER)            += mscc.o
 OBJS-$(CONFIG_SRT_DECODER)             += srtdec.o ass.o htmlsubtitles.o
 OBJS-$(CONFIG_SRT_ENCODER)             += srtenc.o ass_split.o
 OBJS-$(CONFIG_STL_DECODER)             += textdec.o ass.o
@@ -532,11 +571,11 @@ OBJS-$(CONFIG_SUBVIEWER1_DECODER)      += textdec.o ass.o
 OBJS-$(CONFIG_SUBVIEWER_DECODER)       += subviewerdec.o ass.o
 OBJS-$(CONFIG_SUNRAST_DECODER)         += sunrast.o
 OBJS-$(CONFIG_SUNRAST_ENCODER)         += sunrastenc.o
+OBJS-$(CONFIG_LIBRSVG_DECODER)         += librsvgdec.o
 OBJS-$(CONFIG_SVQ1_DECODER)            += svq1dec.o svq1.o svq13.o h263data.o
 OBJS-$(CONFIG_SVQ1_ENCODER)            += svq1enc.o svq1.o  h263data.o  \
                                           h263.o ituh263enc.o
-OBJS-$(CONFIG_SVQ3_DECODER)            += svq3.o svq13.o mpegutils.o \
-                                          h264_parse.o h264data.o h264_ps.o h2645_parse.o
+OBJS-$(CONFIG_SVQ3_DECODER)            += svq3.o svq13.o mpegutils.o h264data.o
 OBJS-$(CONFIG_TEXT_DECODER)            += textdec.o ass.o
 OBJS-$(CONFIG_TEXT_ENCODER)            += srtenc.o ass_split.o
 OBJS-$(CONFIG_TAK_DECODER)             += takdec.o tak.o takdsp.o
@@ -549,7 +588,7 @@ OBJS-$(CONFIG_TIFF_DECODER)            += tiff.o lzw.o faxcompr.o tiff_data.o ti
 OBJS-$(CONFIG_TIFF_ENCODER)            += tiffenc.o rle.o lzwenc.o tiff_data.o
 OBJS-$(CONFIG_TMV_DECODER)             += tmv.o cga_data.o
 OBJS-$(CONFIG_TRUEHD_DECODER)          += mlpdec.o mlpdsp.o
-OBJS-$(CONFIG_TRUEHD_ENCODER)          += mlpenc.o
+OBJS-$(CONFIG_TRUEHD_ENCODER)          += mlpenc.o mlp.o
 OBJS-$(CONFIG_TRUEMOTION1_DECODER)     += truemotion1.o
 OBJS-$(CONFIG_TRUEMOTION2_DECODER)     += truemotion2.o
 OBJS-$(CONFIG_TRUEMOTION2RT_DECODER)   += truemotion2rt.o
@@ -561,7 +600,7 @@ OBJS-$(CONFIG_TTA_ENCODER)             += ttaenc.o ttaencdsp.o ttadata.o
 OBJS-$(CONFIG_TWINVQ_DECODER)          += twinvqdec.o twinvq.o
 OBJS-$(CONFIG_TXD_DECODER)             += txd.o
 OBJS-$(CONFIG_ULTI_DECODER)            += ulti.o
-OBJS-$(CONFIG_UTVIDEO_DECODER)         += utvideodec.o utvideo.o
+OBJS-$(CONFIG_UTVIDEO_DECODER)         += utvideodec.o utvideo.o utvideodsp.o
 OBJS-$(CONFIG_UTVIDEO_ENCODER)         += utvideoenc.o utvideo.o
 OBJS-$(CONFIG_V210_DECODER)            += v210dec.o
 OBJS-$(CONFIG_V210_ENCODER)            += v210enc.o
@@ -580,7 +619,8 @@ OBJS-$(CONFIG_VC1_DECODER)             += vc1dec.o vc1_block.o vc1_loopfilter.o
                                           wmv2dsp.o wmv2data.o
 OBJS-$(CONFIG_VC1_CUVID_DECODER)       += cuvid.o
 OBJS-$(CONFIG_VC1_MMAL_DECODER)        += mmaldec.o
-OBJS-$(CONFIG_VC1_QSV_DECODER)         += qsvdec_vc1.o
+OBJS-$(CONFIG_VC1_QSV_DECODER)         += qsvdec_other.o
+OBJS-$(CONFIG_VC1_V4L2M2M_DECODER)     += v4l2_m2m_dec.o
 OBJS-$(CONFIG_VC2_ENCODER)             += vc2enc.o vc2enc_dwt.o diractab.o
 OBJS-$(CONFIG_VCR1_DECODER)            += vcr1.o
 OBJS-$(CONFIG_VMDAUDIO_DECODER)        += vmdaudio.o
@@ -598,11 +638,20 @@ OBJS-$(CONFIG_VP7_DECODER)             += vp8.o vp56rac.o
 OBJS-$(CONFIG_VP8_DECODER)             += vp8.o vp56rac.o
 OBJS-$(CONFIG_VP8_CUVID_DECODER)       += cuvid.o
 OBJS-$(CONFIG_VP8_MEDIACODEC_DECODER)  += mediacodecdec.o
-OBJS-$(CONFIG_VP9_DECODER)             += vp9.o vp9dsp.o vp56rac.o vp9dsp_8bpp.o \
-                                          vp9dsp_10bpp.o vp9dsp_12bpp.o
+OBJS-$(CONFIG_VP8_QSV_DECODER)         += qsvdec_other.o
+OBJS-$(CONFIG_VP8_RKMPP_DECODER)       += rkmppdec.o
+OBJS-$(CONFIG_VP8_VAAPI_ENCODER)       += vaapi_encode_vp8.o
+OBJS-$(CONFIG_VP8_V4L2M2M_DECODER)     += v4l2_m2m_dec.o
+OBJS-$(CONFIG_VP8_V4L2M2M_ENCODER)     += v4l2_m2m_enc.o
+OBJS-$(CONFIG_VP9_DECODER)             += vp9.o vp9data.o vp9dsp.o vp9lpf.o vp9recon.o \
+                                          vp9block.o vp9prob.o vp9mvs.o vp56rac.o \
+                                          vp9dsp_8bpp.o vp9dsp_10bpp.o vp9dsp_12bpp.o
 OBJS-$(CONFIG_VP9_CUVID_DECODER)       += cuvid.o
 OBJS-$(CONFIG_VP9_MEDIACODEC_DECODER)  += mediacodecdec.o
+OBJS-$(CONFIG_VP9_RKMPP_DECODER)       += rkmppdec.o
+OBJS-$(CONFIG_VP9_VAAPI_ENCODER)       += vaapi_encode_vp9.o
 OBJS-$(CONFIG_VPLAYER_DECODER)         += textdec.o ass.o
+OBJS-$(CONFIG_VP9_V4L2M2M_DECODER)     += v4l2_m2m_dec.o
 OBJS-$(CONFIG_VQA_DECODER)             += vqavideo.o
 OBJS-$(CONFIG_WAVPACK_DECODER)         += wavpack.o
 OBJS-$(CONFIG_WAVPACK_ENCODER)         += wavpackenc.o
@@ -625,6 +674,7 @@ OBJS-$(CONFIG_WMV2_DECODER)            += wmv2dec.o wmv2.o wmv2data.o \
 OBJS-$(CONFIG_WMV2_ENCODER)            += wmv2enc.o wmv2.o wmv2data.o \
                                           msmpeg4.o msmpeg4enc.o msmpeg4data.o
 OBJS-$(CONFIG_WNV1_DECODER)            += wnv1.o
+OBJS-$(CONFIG_WRAPPED_AVFRAME_DECODER) += wrapped_avframe.o
 OBJS-$(CONFIG_WRAPPED_AVFRAME_ENCODER) += wrapped_avframe.o
 OBJS-$(CONFIG_WS_SND1_DECODER)         += ws-snd1.o
 OBJS-$(CONFIG_XAN_DPCM_DECODER)        += dpcm.o
@@ -638,6 +688,7 @@ OBJS-$(CONFIG_XFACE_ENCODER)           += xfaceenc.o xface.o
 OBJS-$(CONFIG_XL_DECODER)              += xl.o
 OBJS-$(CONFIG_XMA1_DECODER)            += wmaprodec.o wma.o wma_common.o
 OBJS-$(CONFIG_XMA2_DECODER)            += wmaprodec.o wma.o wma_common.o
+OBJS-$(CONFIG_XPM_DECODER)             += xpmdec.o
 OBJS-$(CONFIG_XSUB_DECODER)            += xsubdec.o
 OBJS-$(CONFIG_XSUB_ENCODER)            += xsubenc.o
 OBJS-$(CONFIG_XWD_DECODER)             += xwddec.o
@@ -659,6 +710,8 @@ OBJS-$(CONFIG_PCM_ALAW_DECODER)           += pcm.o
 OBJS-$(CONFIG_PCM_ALAW_ENCODER)           += pcm.o
 OBJS-$(CONFIG_PCM_BLURAY_DECODER)         += pcm-bluray.o
 OBJS-$(CONFIG_PCM_DVD_DECODER)            += pcm-dvd.o
+OBJS-$(CONFIG_PCM_F16LE_DECODER)          += pcm.o
+OBJS-$(CONFIG_PCM_F24LE_DECODER)          += pcm.o
 OBJS-$(CONFIG_PCM_F32BE_DECODER)          += pcm.o
 OBJS-$(CONFIG_PCM_F32BE_ENCODER)          += pcm.o
 OBJS-$(CONFIG_PCM_F32LE_DECODER)          += pcm.o
@@ -734,6 +787,7 @@ OBJS-$(CONFIG_ADPCM_G722_ENCODER)         += g722.o g722dsp.o g722enc.o
 OBJS-$(CONFIG_ADPCM_G726_DECODER)         += g726.o
 OBJS-$(CONFIG_ADPCM_G726_ENCODER)         += g726.o
 OBJS-$(CONFIG_ADPCM_G726LE_DECODER)       += g726.o
+OBJS-$(CONFIG_ADPCM_G726LE_ENCODER)       += g726.o
 OBJS-$(CONFIG_ADPCM_IMA_AMV_DECODER)      += adpcm.o adpcm_data.o
 OBJS-$(CONFIG_ADPCM_IMA_APC_DECODER)      += adpcm.o adpcm_data.o
 OBJS-$(CONFIG_ADPCM_IMA_DAT4_DECODER)     += adpcm.o adpcm_data.o
@@ -769,7 +823,7 @@ OBJS-$(CONFIG_ADPCM_YAMAHA_ENCODER)       += adpcmenc.o adpcm_data.o
 # hardware accelerators
 OBJS-$(CONFIG_D3D11VA)                    += dxva2.o
 OBJS-$(CONFIG_DXVA2)                      += dxva2.o
-OBJS-$(CONFIG_VAAPI)                      += vaapi.o
+OBJS-$(CONFIG_VAAPI)                      += vaapi_decode.o
 OBJS-$(CONFIG_VDA)                        += vda.o videotoolbox.o
 OBJS-$(CONFIG_VIDEOTOOLBOX)               += videotoolbox.o
 OBJS-$(CONFIG_VDPAU)                      += vdpau.o
@@ -778,12 +832,14 @@ OBJS-$(CONFIG_H263_VAAPI_HWACCEL)         += vaapi_mpeg4.o
 OBJS-$(CONFIG_H263_VIDEOTOOLBOX_HWACCEL)  += videotoolbox.o
 OBJS-$(CONFIG_H264_D3D11VA_HWACCEL)       += dxva2_h264.o
 OBJS-$(CONFIG_H264_DXVA2_HWACCEL)         += dxva2_h264.o
+OBJS-$(CONFIG_H264_QSV_HWACCEL)           += qsvdec_h2645.o
 OBJS-$(CONFIG_H264_VAAPI_HWACCEL)         += vaapi_h264.o
 OBJS-$(CONFIG_H264_VDA_HWACCEL)           += vda_h264.o
 OBJS-$(CONFIG_H264_VDPAU_HWACCEL)         += vdpau_h264.o
 OBJS-$(CONFIG_H264_VIDEOTOOLBOX_HWACCEL)  += videotoolbox.o
 OBJS-$(CONFIG_HEVC_D3D11VA_HWACCEL)       += dxva2_hevc.o
 OBJS-$(CONFIG_HEVC_DXVA2_HWACCEL)         += dxva2_hevc.o
+OBJS-$(CONFIG_HEVC_QSV_HWACCEL)           += qsvdec_h2645.o
 OBJS-$(CONFIG_HEVC_VAAPI_HWACCEL)         += vaapi_hevc.o
 OBJS-$(CONFIG_HEVC_VDPAU_HWACCEL)         += vdpau_hevc.o
 OBJS-$(CONFIG_MPEG1_VDPAU_HWACCEL)        += vdpau_mpeg12.o
@@ -791,6 +847,7 @@ OBJS-$(CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL) += videotoolbox.o
 OBJS-$(CONFIG_MPEG1_XVMC_HWACCEL)         += mpegvideo_xvmc.o
 OBJS-$(CONFIG_MPEG2_D3D11VA_HWACCEL)      += dxva2_mpeg2.o
 OBJS-$(CONFIG_MPEG2_DXVA2_HWACCEL)        += dxva2_mpeg2.o
+OBJS-$(CONFIG_MPEG2_QSV_HWACCEL)          += qsvdec_other.o
 OBJS-$(CONFIG_MPEG2_VAAPI_HWACCEL)        += vaapi_mpeg2.o
 OBJS-$(CONFIG_MPEG2_VDPAU_HWACCEL)        += vdpau_mpeg12.o
 OBJS-$(CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL) += videotoolbox.o
@@ -800,11 +857,13 @@ OBJS-$(CONFIG_MPEG4_VDPAU_HWACCEL)        += vdpau_mpeg4.o
 OBJS-$(CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL) += videotoolbox.o
 OBJS-$(CONFIG_VC1_D3D11VA_HWACCEL)        += dxva2_vc1.o
 OBJS-$(CONFIG_VC1_DXVA2_HWACCEL)          += dxva2_vc1.o
+OBJS-$(CONFIG_VC1_QSV_HWACCEL)            += qsvdec_other.o
 OBJS-$(CONFIG_VC1_VAAPI_HWACCEL)          += vaapi_vc1.o
 OBJS-$(CONFIG_VC1_VDPAU_HWACCEL)          += vdpau_vc1.o
 OBJS-$(CONFIG_VP9_D3D11VA_HWACCEL)        += dxva2_vp9.o
 OBJS-$(CONFIG_VP9_DXVA2_HWACCEL)          += dxva2_vp9.o
 OBJS-$(CONFIG_VP9_VAAPI_HWACCEL)          += vaapi_vp9.o
+OBJS-$(CONFIG_VP8_QSV_HWACCEL)            += qsvdec_other.o
 
 # libavformat dependencies
 OBJS-$(CONFIG_ISO_MEDIA)               += mpeg4audio.o mpegaudiodata.o
@@ -812,34 +871,20 @@ OBJS-$(CONFIG_ISO_MEDIA)               += mpeg4audio.o mpegaudiodata.o
 OBJS-$(CONFIG_ADTS_MUXER)              += mpeg4audio.o
 OBJS-$(CONFIG_CAF_DEMUXER)             += ac3tab.o
 OBJS-$(CONFIG_DNXHD_DEMUXER)           += dnxhddata.o
-OBJS-$(CONFIG_FLAC_DEMUXER)            += flac.o flacdata.o vorbis_data.o
-OBJS-$(CONFIG_FLAC_MUXER)              += flac.o flacdata.o vorbis_data.o
+OBJS-$(CONFIG_FITS_DEMUXER)            += fits.o
 OBJS-$(CONFIG_FLV_DEMUXER)             += mpeg4audio.o
-OBJS-$(CONFIG_GXF_DEMUXER)             += mpeg12data.o
-OBJS-$(CONFIG_IFF_DEMUXER)             += iff.o
 OBJS-$(CONFIG_LATM_MUXER)              += mpeg4audio.o
-OBJS-$(CONFIG_MATROSKA_AUDIO_MUXER)    += mpeg4audio.o vorbis_data.o    \
-                                          flac.o flacdata.o
-OBJS-$(CONFIG_MATROSKA_MUXER)          += flac.o flacdata.o vorbis_data.o
+OBJS-$(CONFIG_MATROSKA_AUDIO_MUXER)    += mpeg4audio.o
+OBJS-$(CONFIG_MATROSKA_MUXER)          += mpeg4audio.o
 OBJS-$(CONFIG_MOV_DEMUXER)             += ac3tab.o
-OBJS-$(CONFIG_MP2_MUXER)               += mpegaudiodata.o mpegaudiodecheader.o
-OBJS-$(CONFIG_MP3_MUXER)               += mpegaudiodata.o mpegaudiodecheader.o
-OBJS-$(CONFIG_MPEGTS_MUXER)            += mpeg4audio.o
 OBJS-$(CONFIG_MXF_MUXER)               += dnxhddata.o
 OBJS-$(CONFIG_NUT_MUXER)               += mpegaudiodata.o
 OBJS-$(CONFIG_NUT_DEMUXER)             += mpegaudiodata.o mpeg4audio.o
-OBJS-$(CONFIG_OGA_MUXER)               += flac.o flacdata.o
-OBJS-$(CONFIG_OGG_DEMUXER)             += mpeg12data.o \
-                                          dirac.o vorbis_data.o
-OBJS-$(CONFIG_OGG_MUXER)               += flac.o flacdata.o \
-                                          vorbis_data.o
 OBJS-$(CONFIG_RTP_MUXER)               += mpeg4audio.o
 OBJS-$(CONFIG_SPDIF_DEMUXER)           += aacadtsdec.o mpeg4audio.o
 OBJS-$(CONFIG_SPDIF_MUXER)             += dca.o
 OBJS-$(CONFIG_TAK_DEMUXER)             += tak.o
-OBJS-$(CONFIG_WEBM_MUXER)              += mpeg4audio.o mpegaudiodata.o  \
-                                          flac.o flacdata.o \
-                                          vorbis_data.o
+OBJS-$(CONFIG_WEBM_MUXER)              += mpeg4audio.o
 
 # libavfilter dependencies
 OBJS-$(CONFIG_ELBG_FILTER)             += elbg.o
@@ -853,9 +898,9 @@ OBJS-$(CONFIG_AMR_NB_AT_DECODER)          += audiotoolboxdec.o
 OBJS-$(CONFIG_EAC3_AT_DECODER)            += audiotoolboxdec.o
 OBJS-$(CONFIG_GSM_MS_AT_DECODER)          += audiotoolboxdec.o
 OBJS-$(CONFIG_ILBC_AT_DECODER)            += audiotoolboxdec.o
-OBJS-$(CONFIG_MP1_AT_DECODER)             += audiotoolboxdec.o mpegaudiodata.o mpegaudiodecheader.o
-OBJS-$(CONFIG_MP2_AT_DECODER)             += audiotoolboxdec.o mpegaudiodata.o mpegaudiodecheader.o
-OBJS-$(CONFIG_MP3_AT_DECODER)             += audiotoolboxdec.o mpegaudiodata.o mpegaudiodecheader.o
+OBJS-$(CONFIG_MP1_AT_DECODER)             += audiotoolboxdec.o
+OBJS-$(CONFIG_MP2_AT_DECODER)             += audiotoolboxdec.o
+OBJS-$(CONFIG_MP3_AT_DECODER)             += audiotoolboxdec.o
 OBJS-$(CONFIG_PCM_MULAW_AT_DECODER)       += audiotoolboxdec.o
 OBJS-$(CONFIG_PCM_ALAW_AT_DECODER)        += audiotoolboxdec.o
 OBJS-$(CONFIG_QDMC_AT_DECODER)            += audiotoolboxdec.o
@@ -875,7 +920,7 @@ OBJS-$(CONFIG_LIBGSM_MS_ENCODER)          += libgsmenc.o
 OBJS-$(CONFIG_LIBILBC_DECODER)            += libilbc.o
 OBJS-$(CONFIG_LIBILBC_ENCODER)            += libilbc.o
 OBJS-$(CONFIG_LIBKVAZAAR_ENCODER)         += libkvazaar.o
-OBJS-$(CONFIG_LIBMP3LAME_ENCODER)         += libmp3lame.o mpegaudiodata.o mpegaudiodecheader.o
+OBJS-$(CONFIG_LIBMP3LAME_ENCODER)         += libmp3lame.o
 OBJS-$(CONFIG_LIBOPENCORE_AMRNB_DECODER)  += libopencore-amr.o
 OBJS-$(CONFIG_LIBOPENCORE_AMRNB_ENCODER)  += libopencore-amr.o
 OBJS-$(CONFIG_LIBOPENCORE_AMRWB_DECODER)  += libopencore-amr.o
@@ -887,10 +932,6 @@ OBJS-$(CONFIG_LIBOPUS_DECODER)            += libopusdec.o libopus.o     \
                                              vorbis_data.o
 OBJS-$(CONFIG_LIBOPUS_ENCODER)            += libopusenc.o libopus.o     \
                                              vorbis_data.o
-OBJS-$(CONFIG_LIBSCHROEDINGER_DECODER)    += libschroedingerdec.o \
-                                             libschroedinger.o
-OBJS-$(CONFIG_LIBSCHROEDINGER_ENCODER)    += libschroedingerenc.o \
-                                             libschroedinger.o
 OBJS-$(CONFIG_LIBSHINE_ENCODER)           += libshine.o
 OBJS-$(CONFIG_LIBSPEEX_DECODER)           += libspeexdec.o
 OBJS-$(CONFIG_LIBSPEEX_ENCODER)           += libspeexenc.o
@@ -926,7 +967,7 @@ OBJS-$(CONFIG_CAVSVIDEO_PARSER)        += cavs_parser.o
 OBJS-$(CONFIG_COOK_PARSER)             += cook_parser.o
 OBJS-$(CONFIG_DCA_PARSER)              += dca_parser.o dca_exss.o dca.o
 OBJS-$(CONFIG_DIRAC_PARSER)            += dirac_parser.o
-OBJS-$(CONFIG_DNXHD_PARSER)            += dnxhd_parser.o
+OBJS-$(CONFIG_DNXHD_PARSER)            += dnxhd_parser.o dnxhddata.o
 OBJS-$(CONFIG_DPX_PARSER)              += dpx_parser.o
 OBJS-$(CONFIG_DVAUDIO_PARSER)          += dvaudio_parser.o
 OBJS-$(CONFIG_DVBSUB_PARSER)           += dvbsub_parser.o
@@ -938,17 +979,15 @@ OBJS-$(CONFIG_G729_PARSER)             += g729_parser.o
 OBJS-$(CONFIG_GSM_PARSER)              += gsm_parser.o
 OBJS-$(CONFIG_H261_PARSER)             += h261_parser.o
 OBJS-$(CONFIG_H263_PARSER)             += h263_parser.o
-OBJS-$(CONFIG_H264_PARSER)             += h264_parser.o h264_parse.o h2645_parse.o \
-                                          h264_ps.o h264_sei.o h264data.o
-OBJS-$(CONFIG_HEVC_PARSER)             += hevc_parser.o h2645_parse.o hevc_ps.o hevc_data.o
+OBJS-$(CONFIG_H264_PARSER)             += h264_parser.o h264_sei.o h264data.o
+OBJS-$(CONFIG_HEVC_PARSER)             += hevc_parser.o hevc_data.o
 OBJS-$(CONFIG_MJPEG_PARSER)            += mjpeg_parser.o
 OBJS-$(CONFIG_MLP_PARSER)              += mlp_parser.o mlp.o
 OBJS-$(CONFIG_MPEG4VIDEO_PARSER)       += mpeg4video_parser.o h263.o \
                                           mpeg4videodec.o mpeg4video.o \
                                           ituh263dec.o h263dec.o h263data.o
 OBJS-$(CONFIG_PNG_PARSER)              += png_parser.o
-OBJS-$(CONFIG_MPEGAUDIO_PARSER)        += mpegaudio_parser.o \
-                                          mpegaudiodecheader.o mpegaudiodata.o
+OBJS-$(CONFIG_MPEGAUDIO_PARSER)        += mpegaudio_parser.o
 OBJS-$(CONFIG_MPEGVIDEO_PARSER)        += mpegvideo_parser.o    \
                                           mpeg12.o mpeg12data.o
 OBJS-$(CONFIG_OPUS_PARSER)             += opus_parser.o opus.o vorbis_data.o
@@ -956,12 +995,14 @@ OBJS-$(CONFIG_PNG_PARSER)              += png_parser.o
 OBJS-$(CONFIG_PNM_PARSER)              += pnm_parser.o pnm.o
 OBJS-$(CONFIG_RV30_PARSER)             += rv34_parser.o
 OBJS-$(CONFIG_RV40_PARSER)             += rv34_parser.o
+OBJS-$(CONFIG_SIPR_PARSER)             += sipr_parser.o
 OBJS-$(CONFIG_TAK_PARSER)              += tak_parser.o tak.o
 OBJS-$(CONFIG_VC1_PARSER)              += vc1_parser.o vc1.o vc1data.o  \
                                           simple_idct.o wmv2data.o
 OBJS-$(CONFIG_VP3_PARSER)              += vp3_parser.o
 OBJS-$(CONFIG_VP8_PARSER)              += vp8_parser.o
 OBJS-$(CONFIG_VP9_PARSER)              += vp9_parser.o
+OBJS-$(CONFIG_XMA_PARSER)              += xma_parser.o
 
 # bitstream filters
 OBJS-$(CONFIG_AAC_ADTSTOASC_BSF)          += aac_adtstoasc_bsf.o aacadtsdec.o \
@@ -969,6 +1010,8 @@ OBJS-$(CONFIG_AAC_ADTSTOASC_BSF)          += aac_adtstoasc_bsf.o aacadtsdec.o \
 OBJS-$(CONFIG_CHOMP_BSF)                  += chomp_bsf.o
 OBJS-$(CONFIG_DUMP_EXTRADATA_BSF)         += dump_extradata_bsf.o
 OBJS-$(CONFIG_DCA_CORE_BSF)               += dca_core_bsf.o
+OBJS-$(CONFIG_EXTRACT_EXTRADATA_BSF)      += extract_extradata_bsf.o    \
+                                             h2645_parse.o
 OBJS-$(CONFIG_H264_MP4TOANNEXB_BSF)       += h264_mp4toannexb_bsf.o
 OBJS-$(CONFIG_HEVC_MP4TOANNEXB_BSF)       += hevc_mp4toannexb_bsf.o
 OBJS-$(CONFIG_IMX_DUMP_HEADER_BSF)        += imx_dump_header_bsf.o
@@ -979,9 +1022,12 @@ OBJS-$(CONFIG_MOV2TEXTSUB_BSF)            += movsub_bsf.o
 OBJS-$(CONFIG_MP3_HEADER_DECOMPRESS_BSF)  += mp3_header_decompress_bsf.o \
                                              mpegaudiodata.o
 OBJS-$(CONFIG_NOISE_BSF)                  += noise_bsf.o
+OBJS-$(CONFIG_NULL_BSF)                   += null_bsf.o
 OBJS-$(CONFIG_REMOVE_EXTRADATA_BSF)       += remove_extradata_bsf.o
 OBJS-$(CONFIG_TEXT2MOVSUB_BSF)            += movsub_bsf.o
+OBJS-$(CONFIG_VP9_RAW_REORDER_BSF)        += vp9_raw_reorder_bsf.o
 OBJS-$(CONFIG_VP9_SUPERFRAME_BSF)         += vp9_superframe_bsf.o
+OBJS-$(CONFIG_VP9_SUPERFRAME_SPLIT_BSF)   += vp9_superframe_split_bsf.o
 
 # thread libraries
 OBJS-$(HAVE_LIBC_MSVCRT)               += file_open.o
@@ -1006,7 +1052,6 @@ SKIPHEADERS                            += %_tablegen.h                  \
 SKIPHEADERS-$(CONFIG_D3D11VA)          += d3d11va.h dxva2_internal.h
 SKIPHEADERS-$(CONFIG_DXVA2)            += dxva2.h dxva2_internal.h
 SKIPHEADERS-$(CONFIG_JNI)              += ffjni.h
-SKIPHEADERS-$(CONFIG_LIBSCHROEDINGER)  += libschroedinger.h
 SKIPHEADERS-$(CONFIG_LIBVPX)           += libvpx.h
 SKIPHEADERS-$(CONFIG_LIBWEBP_ENCODER)  += libwebpenc_common.h
 SKIPHEADERS-$(CONFIG_MEDIACODEC)       += mediacodecdec_common.h mediacodec_surface.h mediacodec_wrapper.h mediacodec_sw_buffer.h
@@ -1015,15 +1060,20 @@ SKIPHEADERS-$(CONFIG_QSV)              += qsv.h qsv_internal.h
 SKIPHEADERS-$(CONFIG_QSVDEC)           += qsvdec.h
 SKIPHEADERS-$(CONFIG_QSVENC)           += qsvenc.h
 SKIPHEADERS-$(CONFIG_XVMC)             += xvmc.h
-SKIPHEADERS-$(CONFIG_VAAPI)            += vaapi_encode.h vaapi_internal.h
+SKIPHEADERS-$(CONFIG_VAAPI)            += vaapi_decode.h vaapi_encode.h
 SKIPHEADERS-$(CONFIG_VDA)              += vda.h vda_vt_internal.h
 SKIPHEADERS-$(CONFIG_VDPAU)            += vdpau.h vdpau_internal.h
 SKIPHEADERS-$(CONFIG_VIDEOTOOLBOX)     += videotoolbox.h vda_vt_internal.h
+SKIPHEADERS-$(CONFIG_V4L2_M2M)         += v4l2_buffers.h v4l2_context.h v4l2_m2m.h
 
-TESTPROGS = imgconvert                                                  \
+TESTPROGS = avpacket                                                    \
+            celp_math                                                   \
+            htmlsubtitles                                               \
+            imgconvert                                                  \
             jpeg2000dwt                                                 \
             mathops                                                    \
             options                                                     \
+            mjpegenc_huffman                                            \
             utils                                                       \
 
 TESTPROGS-$(CONFIG_CABAC)                 += cabac
diff --git a/mythtv/external/FFmpeg/libavcodec/aac.h b/mythtv/external/FFmpeg/libavcodec/aac.h
index b1f4aa74f01..4910c661d61 100644
--- a/mythtv/external/FFmpeg/libavcodec/aac.h
+++ b/mythtv/external/FFmpeg/libavcodec/aac.h
@@ -36,7 +36,7 @@
 #include "libavutil/fixed_dsp.h"
 #include "avcodec.h"
 #if !USE_FIXED
-#include "imdct15.h"
+#include "mdct15.h"
 #endif
 #include "fft.h"
 #include "mpeg4audio.h"
@@ -327,7 +327,9 @@ struct AACContext {
 #if USE_FIXED
     AVFixedDSPContext *fdsp;
 #else
-    IMDCT15Context *mdct480;
+    MDCT15Context *mdct120;
+    MDCT15Context *mdct480;
+    MDCT15Context *mdct960;
     AVFloatDSPContext *fdsp;
 #endif /* USE_FIXED */
     int random_state;
@@ -353,6 +355,7 @@ struct AACContext {
 
     OutputConfiguration oc[2];
     int warned_num_aac_frames;
+    int warned_960_sbr;
 
     /* aacdec functions pointers */
     void (*imdct_and_windowing)(AACContext *ac, SingleChannelElement *sce);
diff --git a/mythtv/external/FFmpeg/libavcodec/aac_adtstoasc_bsf.c b/mythtv/external/FFmpeg/libavcodec/aac_adtstoasc_bsf.c
index 48889fc48ef..4bcf55b193a 100644
--- a/mythtv/external/FFmpeg/libavcodec/aac_adtstoasc_bsf.c
+++ b/mythtv/external/FFmpeg/libavcodec/aac_adtstoasc_bsf.c
@@ -49,14 +49,14 @@ static int aac_adtstoasc_filter(AVBSFContext *bsfc, AVPacket *out)
     if (ret < 0)
         return ret;
 
+    if (bsfc->par_in->extradata && in->size >= 2 && (AV_RB16(in->data) >> 4) != 0xfff)
+        goto finish;
+
     if (in->size < AAC_ADTS_HEADER_SIZE)
         goto packet_too_small;
 
     init_get_bits(&gb, in->data, AAC_ADTS_HEADER_SIZE * 8);
 
-    if (bsfc->par_in->extradata && show_bits(&gb, 12) != 0xfff)
-        goto finish;
-
     if (avpriv_aac_parse_header(&gb, &hdr) < 0) {
         av_log(bsfc, AV_LOG_ERROR, "Error parsing ADTS frame header!\n");
         ret = AVERROR_INVALIDDATA;
@@ -97,7 +97,8 @@ static int aac_adtstoasc_filter(AVBSFContext *bsfc, AVPacket *out)
             in->data += get_bits_count(&gb)/8;
         }
 
-        extradata = av_mallocz(2 + pce_size + AV_INPUT_BUFFER_PADDING_SIZE);
+        extradata = av_packet_new_side_data(in, AV_PKT_DATA_NEW_EXTRADATA,
+                                            2 + pce_size);
         if (!extradata) {
             ret = AVERROR(ENOMEM);
             goto fail;
@@ -115,8 +116,6 @@ static int aac_adtstoasc_filter(AVBSFContext *bsfc, AVPacket *out)
             memcpy(extradata + 2, pce_data, pce_size);
         }
 
-        bsfc->par_out->extradata = extradata;
-        bsfc->par_out->extradata_size = 2 + pce_size;
         ctx->first_frame_done = 1;
     }
 
@@ -136,8 +135,16 @@ static int aac_adtstoasc_filter(AVBSFContext *bsfc, AVPacket *out)
 
 static int aac_adtstoasc_init(AVBSFContext *ctx)
 {
-    av_freep(&ctx->par_out->extradata);
-    ctx->par_out->extradata_size = 0;
+    /* Validate the extradata if the stream is already MPEG-4 AudioSpecificConfig */
+    if (ctx->par_in->extradata) {
+        MPEG4AudioConfig mp4ac;
+        int ret = avpriv_mpeg4audio_get_config(&mp4ac, ctx->par_in->extradata,
+                                               ctx->par_in->extradata_size * 8, 1);
+        if (ret < 0) {
+            av_log(ctx, AV_LOG_ERROR, "Error parsing AudioSpecificConfig extradata!\n");
+            return ret;
+        }
+    }
 
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/aac_defines.h b/mythtv/external/FFmpeg/libavcodec/aac_defines.h
index c12dc2fab78..438d78a7aa7 100644
--- a/mythtv/external/FFmpeg/libavcodec/aac_defines.h
+++ b/mythtv/external/FFmpeg/libavcodec/aac_defines.h
@@ -35,6 +35,7 @@
 #define AAC_RENAME(x)       x ## _fixed
 #define AAC_RENAME_32(x)    x ## _fixed_32
 typedef int                 INTFLOAT;
+typedef unsigned            UINTFLOAT;  ///< Equivalent to INTFLOAT, Used as temporal cast to avoid undefined sign overflow operations.
 typedef int64_t             INT64FLOAT;
 typedef int16_t             SHORTFLOAT;
 typedef SoftFloat           AAC_FLOAT;
@@ -45,7 +46,7 @@ typedef int                 AAC_SIGNE;
 #define Q30(x)              (int)((x)*1073741824.0 + 0.5)
 #define Q31(x)              (int)((x)*2147483648.0 + 0.5)
 #define RANGE15(x)          x
-#define GET_GAIN(x, y)      (-(y) << (x)) + 1024
+#define GET_GAIN(x, y)      (-(y) * (1 << (x))) + 1024
 #define AAC_MUL16(x, y)     (int)(((int64_t)(x) * (y) + 0x8000) >> 16)
 #define AAC_MUL26(x, y)     (int)(((int64_t)(x) * (y) + 0x2000000) >> 26)
 #define AAC_MUL30(x, y)     (int)(((int64_t)(x) * (y) + 0x20000000) >> 30)
@@ -72,7 +73,7 @@ typedef int                 AAC_SIGNE;
 #define AAC_MSUB31_V3(x, y, z)    (int)((((int64_t)(x) * (z)) - \
                                       ((int64_t)(y) * (z)) + \
                                         0x40000000) >> 31)
-#define AAC_HALF_SUM(x, y)  (x) >> 1 + (y) >> 1
+#define AAC_HALF_SUM(x, y)  (((x) >> 1) + ((y) >> 1))
 #define AAC_SRA_R(x, y)     (int)(((x) + (1 << ((y) - 1))) >> (y))
 
 #else
@@ -83,6 +84,7 @@ typedef int                 AAC_SIGNE;
 #define AAC_RENAME(x)       x
 #define AAC_RENAME_32(x)    x
 typedef float               INTFLOAT;
+typedef float               UINTFLOAT;
 typedef float               INT64FLOAT;
 typedef float               SHORTFLOAT;
 typedef float               AAC_FLOAT;
diff --git a/mythtv/external/FFmpeg/libavcodec/aaccoder.c b/mythtv/external/FFmpeg/libavcodec/aaccoder.c
index 9f3b4ed3895..baa82489b19 100644
--- a/mythtv/external/FFmpeg/libavcodec/aaccoder.c
+++ b/mythtv/external/FFmpeg/libavcodec/aaccoder.c
@@ -557,13 +557,13 @@ static void search_for_pns(AACEncContext *s, AVCodecContext *avctx, SingleChanne
     const float pns_transient_energy_r = FFMIN(0.7f, lambda / 140.f);
 
     int refbits = avctx->bit_rate * 1024.0 / avctx->sample_rate
-        / ((avctx->flags & CODEC_FLAG_QSCALE) ? 2.0f : avctx->channels)
+        / ((avctx->flags & AV_CODEC_FLAG_QSCALE) ? 2.0f : avctx->channels)
         * (lambda / 120.f);
 
     /** Keep this in sync with twoloop's cutoff selection */
     float rate_bandwidth_multiplier = 1.5f;
     int prev = -1000, prev_sf = -1;
-    int frame_bit_rate = (avctx->flags & CODEC_FLAG_QSCALE)
+    int frame_bit_rate = (avctx->flags & AV_CODEC_FLAG_QSCALE)
         ? (refbits * rate_bandwidth_multiplier * avctx->sample_rate / 1024)
         : (avctx->bit_rate / avctx->channels);
 
@@ -694,12 +694,12 @@ static void mark_pns(AACEncContext *s, AVCodecContext *avctx, SingleChannelEleme
     const float pns_transient_energy_r = FFMIN(0.7f, lambda / 140.f);
 
     int refbits = avctx->bit_rate * 1024.0 / avctx->sample_rate
-        / ((avctx->flags & CODEC_FLAG_QSCALE) ? 2.0f : avctx->channels)
+        / ((avctx->flags & AV_CODEC_FLAG_QSCALE) ? 2.0f : avctx->channels)
         * (lambda / 120.f);
 
     /** Keep this in sync with twoloop's cutoff selection */
     float rate_bandwidth_multiplier = 1.5f;
-    int frame_bit_rate = (avctx->flags & CODEC_FLAG_QSCALE)
+    int frame_bit_rate = (avctx->flags & AV_CODEC_FLAG_QSCALE)
         ? (refbits * rate_bandwidth_multiplier * avctx->sample_rate / 1024)
         : (avctx->bit_rate / avctx->channels);
 
@@ -894,7 +894,7 @@ static void search_for_ms(AACEncContext *s, ChannelElement *cpe)
     }
 }
 
-AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB] = {
+const AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB] = {
     [AAC_CODER_ANMR] = {
         search_for_quantizers_anmr,
         encode_window_bands_info,
diff --git a/mythtv/external/FFmpeg/libavcodec/aaccoder_twoloop.h b/mythtv/external/FFmpeg/libavcodec/aaccoder_twoloop.h
index f175c5f8b88..8e1bc88a853 100644
--- a/mythtv/external/FFmpeg/libavcodec/aaccoder_twoloop.h
+++ b/mythtv/external/FFmpeg/libavcodec/aaccoder_twoloop.h
@@ -71,7 +71,7 @@ static void search_for_quantizers_twoloop(AVCodecContext *avctx,
 {
     int start = 0, i, w, w2, g, recomprd;
     int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate
-        / ((avctx->flags & CODEC_FLAG_QSCALE) ? 2.0f : avctx->channels)
+        / ((avctx->flags & AV_CODEC_FLAG_QSCALE) ? 2.0f : avctx->channels)
         * (lambda / 120.f);
     int refbits = destbits;
     int toomanybits, toofewbits;
@@ -136,7 +136,7 @@ static void search_for_quantizers_twoloop(AVCodecContext *avctx,
             * (lambda / (avctx->global_quality ? avctx->global_quality : 120));
     }
 
-    if (avctx->flags & CODEC_FLAG_QSCALE) {
+    if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
         /**
          * Constant Q-scale doesn't compensate MS coding on its own
          * No need to be overly precise, this only controls RD
@@ -184,7 +184,7 @@ static void search_for_quantizers_twoloop(AVCodecContext *avctx,
          * AAC_CUTOFF_FROM_BITRATE is calibrated for effective bitrate.
          */
         float rate_bandwidth_multiplier = 1.5f;
-        int frame_bit_rate = (avctx->flags & CODEC_FLAG_QSCALE)
+        int frame_bit_rate = (avctx->flags & AV_CODEC_FLAG_QSCALE)
             ? (refbits * rate_bandwidth_multiplier * avctx->sample_rate / 1024)
             : (avctx->bit_rate / avctx->channels);
 
@@ -332,7 +332,7 @@ static void search_for_quantizers_twoloop(AVCodecContext *avctx,
                     sce->coeffs + start,
                     nzslope * cleanup_factor);
                 energy2uplim *= de_psy_factor;
-                if (!(avctx->flags & CODEC_FLAG_QSCALE)) {
+                if (!(avctx->flags & AV_CODEC_FLAG_QSCALE)) {
                     /** In ABR, we need to priorize less and let rate control do its thing */
                     energy2uplim = sqrtf(energy2uplim);
                 }
@@ -346,7 +346,7 @@ static void search_for_quantizers_twoloop(AVCodecContext *avctx,
                     sce->coeffs + start,
                     2.0f);
                 energy2uplim *= de_psy_factor;
-                if (!(avctx->flags & CODEC_FLAG_QSCALE)) {
+                if (!(avctx->flags & AV_CODEC_FLAG_QSCALE)) {
                     /** In ABR, we need to priorize less and let rate control do its thing */
                     energy2uplim = sqrtf(energy2uplim);
                 }
diff --git a/mythtv/external/FFmpeg/libavcodec/aacdec.c b/mythtv/external/FFmpeg/libavcodec/aacdec.c
index ee9b4eb45f4..fe508714768 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/aacdec.c
@@ -42,7 +42,7 @@
 #include "internal.h"
 #include "get_bits.h"
 #include "fft.h"
-#include "imdct15.h"
+#include "mdct15.h"
 #include "lpc.h"
 #include "kbdwin.h"
 #include "sinewin.h"
@@ -284,29 +284,35 @@ static int latm_decode_audio_specific_config(struct LATMContext *latmctx,
     AACContext *ac        = &latmctx->aac_ctx;
     AVCodecContext *avctx = ac->avctx;
     MPEG4AudioConfig m4ac = { 0 };
+    GetBitContext gbc;
     int config_start_bit  = get_bits_count(gb);
     int sync_extension    = 0;
-    int bits_consumed, esize;
+    int bits_consumed, esize, i;
 
-    if (asclen) {
+    if (asclen > 0) {
         sync_extension = 1;
         asclen         = FFMIN(asclen, get_bits_left(gb));
-    } else
-        asclen         = get_bits_left(gb);
-
-    if (config_start_bit % 8) {
-        avpriv_request_sample(latmctx->aac_ctx.avctx,
-                              "Non-byte-aligned audio-specific config");
-        return AVERROR_PATCHWELCOME;
+        init_get_bits(&gbc, gb->buffer, config_start_bit + asclen);
+        skip_bits_long(&gbc, config_start_bit);
+    } else if (asclen == 0) {
+        gbc = *gb;
+    } else {
+        return AVERROR_INVALIDDATA;
     }
-    if (asclen <= 0)
+
+    if (get_bits_left(gb) <= 0)
         return AVERROR_INVALIDDATA;
-    bits_consumed = decode_audio_specific_config(NULL, avctx, &m4ac,
-                                         gb->buffer + (config_start_bit / 8),
-                                         asclen, sync_extension);
 
-    if (bits_consumed < 0)
+    bits_consumed = decode_audio_specific_config_gb(NULL, avctx, &m4ac,
+                                                    &gbc, config_start_bit,
+                                                    sync_extension);
+
+    if (bits_consumed < config_start_bit)
         return AVERROR_INVALIDDATA;
+    bits_consumed -= config_start_bit;
+
+    if (asclen == 0)
+      asclen = bits_consumed;
 
     if (!latmctx->initialized ||
         ac->oc[1].m4ac.sample_rate != m4ac.sample_rate ||
@@ -319,7 +325,7 @@ static int latm_decode_audio_specific_config(struct LATMContext *latmctx,
         }
         latmctx->initialized = 0;
 
-        esize = (bits_consumed+7) / 8;
+        esize = (asclen + 7) / 8;
 
         if (avctx->extradata_size < esize) {
             av_free(avctx->extradata);
@@ -329,12 +335,15 @@ static int latm_decode_audio_specific_config(struct LATMContext *latmctx,
         }
 
         avctx->extradata_size = esize;
-        memcpy(avctx->extradata, gb->buffer + (config_start_bit/8), esize);
+        gbc = *gb;
+        for (i = 0; i < esize; i++) {
+          avctx->extradata[i] = get_bits(&gbc, 8);
+        }
         memset(avctx->extradata+esize, 0, AV_INPUT_BUFFER_PADDING_SIZE);
     }
-    skip_bits_long(gb, bits_consumed);
+    skip_bits_long(gb, asclen);
 
-    return bits_consumed;
+    return 0;
 }
 
 static int read_stream_mux_config(struct LATMContext *latmctx,
@@ -375,8 +384,6 @@ static int read_stream_mux_config(struct LATMContext *latmctx,
             int ascLen = latm_get_value(gb);
             if ((ret = latm_decode_audio_specific_config(latmctx, gb, ascLen)) < 0)
                 return ret;
-            ascLen -= ret;
-            skip_bits_long(gb, ascLen);
         }
 
         latmctx->frame_length_type = get_bits(gb, 3);
@@ -424,6 +431,8 @@ static int read_payload_length_info(struct LATMContext *ctx, GetBitContext *gb)
     if (ctx->frame_length_type == 0) {
         int mux_slot_length = 0;
         do {
+            if (get_bits_left(gb) < 8)
+                return AVERROR_INVALIDDATA;
             tmp = get_bits(gb, 8);
             mux_slot_length += tmp;
         } while (tmp == 255);
@@ -449,11 +458,11 @@ static int read_audio_mux_element(struct LATMContext *latmctx,
     } else if (!latmctx->aac_ctx.avctx->extradata) {
         av_log(latmctx->aac_ctx.avctx, AV_LOG_DEBUG,
                "no decoder config found\n");
-        return AVERROR(EAGAIN);
+        return 1;
     }
     if (latmctx->audio_mux_version_A == 0) {
         int mux_slot_length_bytes = read_payload_length_info(latmctx, gb);
-        if (mux_slot_length_bytes * 8 > get_bits_left(gb)) {
+        if (mux_slot_length_bytes < 0 || mux_slot_length_bytes * 8LL > get_bits_left(gb)) {
             av_log(latmctx->aac_ctx.avctx, AV_LOG_ERROR, "incomplete frame\n");
             return AVERROR_INVALIDDATA;
         } else if (mux_slot_length_bytes * 8 + 256 < get_bits_left(gb)) {
@@ -486,8 +495,8 @@ static int latm_decode_frame(AVCodecContext *avctx, void *out,
     if (muxlength > avpkt->size)
         return AVERROR_INVALIDDATA;
 
-    if ((err = read_audio_mux_element(latmctx, &gb)) < 0)
-        return err;
+    if ((err = read_audio_mux_element(latmctx, &gb)))
+        return (err < 0) ? err : avpkt->size;
 
     if (!latmctx->initialized) {
         if (!avctx->extradata) {
diff --git a/mythtv/external/FFmpeg/libavcodec/aacdec_fixed.c b/mythtv/external/FFmpeg/libavcodec/aacdec_fixed.c
index acb8178337d..32bd1454bd7 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacdec_fixed.c
+++ b/mythtv/external/FFmpeg/libavcodec/aacdec_fixed.c
@@ -125,7 +125,7 @@ static inline int *DEC_SQUAD(int *dst, unsigned idx)
 static inline int *DEC_UPAIR(int *dst, unsigned idx, unsigned sign)
 {
     dst[0] = (idx & 15) * (1 - (sign & 0xFFFFFFFE));
-    dst[1] = (idx >> 4 & 15) * (1 - ((sign & 1) << 1));
+    dst[1] = (idx >> 4 & 15) * (1 - ((sign & 1) * 2));
 
     return dst + 2;
 }
@@ -134,16 +134,16 @@ static inline int *DEC_UQUAD(int *dst, unsigned idx, unsigned sign)
 {
     unsigned nz = idx >> 12;
 
-    dst[0] = (idx & 3) * (1 + (((int)sign >> 31) << 1));
+    dst[0] = (idx & 3) * (1 + (((int)sign >> 31) * 2));
     sign <<= nz & 1;
     nz >>= 1;
-    dst[1] = (idx >> 2 & 3) * (1 + (((int)sign >> 31) << 1));
+    dst[1] = (idx >> 2 & 3) * (1 + (((int)sign >> 31) * 2));
     sign <<= nz & 1;
     nz >>= 1;
-    dst[2] = (idx >> 4 & 3) * (1 + (((int)sign >> 31) << 1));
+    dst[2] = (idx >> 4 & 3) * (1 + (((int)sign >> 31) * 2));
     sign <<= nz & 1;
     nz >>= 1;
-    dst[3] = (idx >> 6 & 3) * (1 + (((int)sign >> 31) << 1));
+    dst[3] = (idx >> 6 & 3) * (1 + (((int)sign >> 31) * 2));
 
     return dst + 4;
 }
@@ -171,20 +171,25 @@ static void subband_scale(int *dst, int *src, int scale, int offset, int len)
 
     s = offset - (s >> 2);
 
-    if (s > 0) {
+    if (s > 31) {
+        for (i=0; i<len; i++) {
+            dst[i] = 0;
+        }
+    } else if (s > 0) {
         round = 1 << (s-1);
         for (i=0; i<len; i++) {
             out = (int)(((int64_t)src[i] * c) >> 32);
             dst[i] = ((int)(out+round) >> s) * ssign;
         }
-    }
-    else {
+    } else if (s > -32) {
         s = s + 32;
-        round = 1 << (s-1);
+        round = 1U << (s-1);
         for (i=0; i<len; i++) {
             out = (int)((int64_t)((int64_t)src[i] * c + round) >> s);
-            dst[i] = out * ssign;
+            dst[i] = out * (unsigned)ssign;
         }
+    } else {
+        av_log(NULL, AV_LOG_ERROR, "Overflow in subband_scale()\n");
     }
 }
 
@@ -203,8 +208,12 @@ static void noise_scale(int *coefs, int scale, int band_energy, int len)
     c /= band_energy;
     s = 21 + nlz - (s >> 2);
 
-    if (s > 0) {
-        round = 1 << (s-1);
+    if (s > 31) {
+        for (i=0; i<len; i++) {
+            coefs[i] = 0;
+        }
+    } else if (s >= 0) {
+        round = s ? 1 << (s-1) : 0;
         for (i=0; i<len; i++) {
             out = (int)(((int64_t)coefs[i] * c) >> 32);
             coefs[i] = ((int)(out+round) >> s) * ssign;
@@ -296,8 +305,12 @@ static av_always_inline void predict(PredictorState *ps, int *coef,
     if (output_enable) {
         int shift = 28 - pv.exp;
 
-        if (shift < 31)
-            *coef += (pv.mant + (1 << (shift - 1))) >> shift;
+        if (shift < 31) {
+            if (shift > 0) {
+                *coef += (unsigned)((pv.mant + (1 << (shift - 1))) >> shift);
+            } else
+                *coef += (unsigned)pv.mant << -shift;
+        }
     }
 
     e0 = av_int2sf(*coef, 2);
@@ -362,7 +375,9 @@ static void apply_dependent_coupling_fixed(AACContext *ac,
                     shift = (gain-1024) >> 3;
                 }
 
-                if (shift < 0) {
+                if (shift < -31) {
+                    // Nothing to do
+                } else if (shift < 0) {
                     shift = -shift;
                     round = 1 << (shift - 1);
 
@@ -379,7 +394,7 @@ static void apply_dependent_coupling_fixed(AACContext *ac,
                         for (k = offsets[i]; k < offsets[i + 1]; k++) {
                             tmp = (int)(((int64_t)src[group * 128 + k] * c + \
                                         (int64_t)0x1000000000) >> 37);
-                            dest[group * 128 + k] += tmp << shift;
+                            dest[group * 128 + k] += tmp * (1U << shift);
                         }
                     }
                 }
@@ -407,7 +422,9 @@ static void apply_independent_coupling_fixed(AACContext *ac,
 
     c = cce_scale_fixed[gain & 7];
     shift = (gain-1024) >> 3;
-    if (shift < 0) {
+    if (shift < -31) {
+        return;
+    } else if (shift < 0) {
         shift = -shift;
         round = 1 << (shift - 1);
 
@@ -419,7 +436,7 @@ static void apply_independent_coupling_fixed(AACContext *ac,
     else {
       for (i = 0; i < len; i++) {
           tmp = (int)(((int64_t)src[i] * c + (int64_t)0x1000000000) >> 37);
-          dest[i] += tmp << shift;
+          dest[i] += tmp * (1 << shift);
       }
     }
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/aacdec_template.c b/mythtv/external/FFmpeg/libavcodec/aacdec_template.c
index 883ed527f7a..082cc908d2b 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacdec_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/aacdec_template.c
@@ -134,7 +134,7 @@ static av_cold int che_configure(AACContext *ac,
         if (!ac->che[type][id]) {
             if (!(ac->che[type][id] = av_mallocz(sizeof(ChannelElement))))
                 return AVERROR(ENOMEM);
-            AAC_RENAME(ff_aac_sbr_ctx_init)(ac, &ac->che[type][id]->sbr);
+            AAC_RENAME(ff_aac_sbr_ctx_init)(ac, &ac->che[type][id]->sbr, type);
         }
         if (type != TYPE_CCE) {
             if (*channels >= MAX_CHANNELS - (type == TYPE_CPE || (type == TYPE_SCE && ac->oc[1].m4ac.ps == 1))) {
@@ -406,11 +406,15 @@ static uint64_t sniff_channel_order(uint8_t (*layout_map)[3], int tags)
 /**
  * Save current output configuration if and only if it has been locked.
  */
-static void push_output_configuration(AACContext *ac) {
+static int push_output_configuration(AACContext *ac) {
+    int pushed = 0;
+
     if (ac->oc[1].status == OC_LOCKED || ac->oc[0].status == OC_NONE) {
         ac->oc[0] = ac->oc[1];
+        pushed = 1;
     }
     ac->oc[1].status = OC_NONE;
+    return pushed;
 }
 
 /**
@@ -452,7 +456,7 @@ static int output_configure(AACContext *ac,
         int id =           layout_map[i][1];
         id_map[type][id] = type_counts[type]++;
         if (id_map[type][id] >= MAX_ELEM_ID) {
-            avpriv_request_sample(ac->avctx, "Remapped id too large\n");
+            avpriv_request_sample(ac->avctx, "Too large remapped id");
             return AVERROR_PATCHWELCOME;
         }
     }
@@ -715,6 +719,13 @@ static void decode_channel_map(uint8_t layout_map[][3],
     }
 }
 
+static inline void relative_align_get_bits(GetBitContext *gb,
+                                           int reference_position) {
+    int n = (reference_position - get_bits_count(gb) & 7);
+    if (n)
+        skip_bits(gb, n);
+}
+
 /**
  * Decode program configuration element; reference: table 4.2.
  *
@@ -722,7 +733,7 @@ static void decode_channel_map(uint8_t layout_map[][3],
  */
 static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
                       uint8_t (*layout_map)[3],
-                      GetBitContext *gb)
+                      GetBitContext *gb, int byte_align_ref)
 {
     int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc;
     int sampling_index;
@@ -752,7 +763,7 @@ static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
     if (get_bits1(gb))
         skip_bits(gb, 3); // mixdown_coeff_index and pseudo_surround
 
-    if (get_bits_left(gb) < 4 * (num_front + num_side + num_back + num_lfe + num_assoc_data + num_cc)) {
+    if (get_bits_left(gb) < 5 * (num_front + num_side + num_back + num_cc) + 4 *(num_lfe + num_assoc_data + num_cc)) {
         av_log(avctx, AV_LOG_ERROR, "decode_pce: " overread_err);
         return -1;
     }
@@ -770,7 +781,7 @@ static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
     decode_channel_map(layout_map + tags, AAC_CHANNEL_CC,    gb, num_cc);
     tags += num_cc;
 
-    align_get_bits(gb);
+    relative_align_get_bits(gb, byte_align_ref);
 
     /* comment field, first byte is length */
     comment_len = get_bits(gb, 8) * 8;
@@ -792,6 +803,7 @@ static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
  */
 static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,
                                      GetBitContext *gb,
+                                     int get_bit_alignment,
                                      MPEG4AudioConfig *m4ac,
                                      int channel_config)
 {
@@ -799,11 +811,21 @@ static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,
     uint8_t layout_map[MAX_ELEM_ID*4][3];
     int tags = 0;
 
+#if USE_FIXED
     if (get_bits1(gb)) { // frameLengthFlag
-        avpriv_request_sample(avctx, "960/120 MDCT window");
+        avpriv_report_missing_feature(avctx, "Fixed point 960/120 MDCT window");
         return AVERROR_PATCHWELCOME;
     }
     m4ac->frame_length_short = 0;
+#else
+    m4ac->frame_length_short = get_bits1(gb);
+    if (m4ac->frame_length_short && m4ac->sbr == 1) {
+      avpriv_report_missing_feature(avctx, "SBR with 960 frame length");
+      if (ac) ac->warned_960_sbr = 1;
+      m4ac->sbr = 0;
+      m4ac->ps = 0;
+    }
+#endif
 
     if (get_bits1(gb))       // dependsOnCoreCoder
         skip_bits(gb, 14);   // coreCoderDelay
@@ -815,7 +837,7 @@ static int decode_ga_specific_config(AACContext *ac, AVCodecContext *avctx,
 
     if (channel_config == 0) {
         skip_bits(gb, 4);  // element_instance_tag
-        tags = decode_pce(avctx, m4ac, layout_map, gb);
+        tags = decode_pce(avctx, m4ac, layout_map, gb, get_bit_alignment);
         if (tags < 0)
             return tags;
     } else {
@@ -937,37 +959,25 @@ static int decode_eld_specific_config(AACContext *ac, AVCodecContext *avctx,
  * @param   ac          pointer to AACContext, may be null
  * @param   avctx       pointer to AVCCodecContext, used for logging
  * @param   m4ac        pointer to MPEG4AudioConfig, used for parsing
- * @param   data        pointer to buffer holding an audio specific config
- * @param   bit_size    size of audio specific config or data in bits
+ * @param   gb          buffer holding an audio specific config
+ * @param   get_bit_alignment relative alignment for byte align operations
  * @param   sync_extension look for an appended sync extension
  *
  * @return  Returns error status or number of consumed bits. <0 - error
  */
-static int decode_audio_specific_config(AACContext *ac,
-                                        AVCodecContext *avctx,
-                                        MPEG4AudioConfig *m4ac,
-                                        const uint8_t *data, int64_t bit_size,
-                                        int sync_extension)
+static int decode_audio_specific_config_gb(AACContext *ac,
+                                           AVCodecContext *avctx,
+                                           MPEG4AudioConfig *m4ac,
+                                           GetBitContext *gb,
+                                           int get_bit_alignment,
+                                           int sync_extension)
 {
-    GetBitContext gb;
     int i, ret;
+    GetBitContext gbc = *gb;
 
-    if (bit_size < 0 || bit_size > INT_MAX) {
-        av_log(avctx, AV_LOG_ERROR, "Audio specific config size is invalid\n");
+    if ((i = ff_mpeg4audio_get_config_gb(m4ac, &gbc, sync_extension)) < 0)
         return AVERROR_INVALIDDATA;
-    }
 
-    ff_dlog(avctx, "audio specific config size %d\n", (int)bit_size >> 3);
-    for (i = 0; i < bit_size >> 3; i++)
-        ff_dlog(avctx, "%02x ", data[i]);
-    ff_dlog(avctx, "\n");
-
-    if ((ret = init_get_bits(&gb, data, bit_size)) < 0)
-        return ret;
-
-    if ((i = avpriv_mpeg4audio_get_config(m4ac, data, bit_size,
-                                          sync_extension)) < 0)
-        return AVERROR_INVALIDDATA;
     if (m4ac->sampling_index > 12) {
         av_log(avctx, AV_LOG_ERROR,
                "invalid sampling rate index %d\n",
@@ -982,7 +992,7 @@ static int decode_audio_specific_config(AACContext *ac,
         return AVERROR_INVALIDDATA;
     }
 
-    skip_bits_long(&gb, i);
+    skip_bits_long(gb, i);
 
     switch (m4ac->object_type) {
     case AOT_AAC_MAIN:
@@ -990,12 +1000,12 @@ static int decode_audio_specific_config(AACContext *ac,
     case AOT_AAC_LTP:
     case AOT_ER_AAC_LC:
     case AOT_ER_AAC_LD:
-        if ((ret = decode_ga_specific_config(ac, avctx, &gb,
+        if ((ret = decode_ga_specific_config(ac, avctx, gb, get_bit_alignment,
                                             m4ac, m4ac->chan_config)) < 0)
             return ret;
         break;
     case AOT_ER_AAC_ELD:
-        if ((ret = decode_eld_specific_config(ac, avctx, &gb,
+        if ((ret = decode_eld_specific_config(ac, avctx, gb,
                                               m4ac, m4ac->chan_config)) < 0)
             return ret;
         break;
@@ -1013,7 +1023,33 @@ static int decode_audio_specific_config(AACContext *ac,
             m4ac->sample_rate, m4ac->sbr,
             m4ac->ps);
 
-    return get_bits_count(&gb);
+    return get_bits_count(gb);
+}
+
+static int decode_audio_specific_config(AACContext *ac,
+                                        AVCodecContext *avctx,
+                                        MPEG4AudioConfig *m4ac,
+                                        const uint8_t *data, int64_t bit_size,
+                                        int sync_extension)
+{
+    int i, ret;
+    GetBitContext gb;
+
+    if (bit_size < 0 || bit_size > INT_MAX) {
+        av_log(avctx, AV_LOG_ERROR, "Audio specific config size is invalid\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    ff_dlog(avctx, "audio specific config size %d\n", (int)bit_size >> 3);
+    for (i = 0; i < bit_size >> 3; i++)
+        ff_dlog(avctx, "%02x ", data[i]);
+    ff_dlog(avctx, "\n");
+
+    if ((ret = init_get_bits(&gb, data, bit_size)) < 0)
+        return ret;
+
+    return decode_audio_specific_config_gb(ac, avctx, m4ac, &gb, 0,
+                                           sync_extension);
 }
 
 /**
@@ -1100,6 +1136,12 @@ static av_cold void aac_static_table_init(void)
     // window initialization
     AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_long_1024), 4.0, 1024);
     AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_short_128), 6.0, 128);
+#if !USE_FIXED
+    AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_long_960), 4.0, 960);
+    AAC_RENAME(ff_kbd_window_init)(AAC_RENAME(ff_aac_kbd_short_120), 6.0, 120);
+    AAC_RENAME(ff_sine_window_init)(AAC_RENAME(ff_sine_960), 960);
+    AAC_RENAME(ff_sine_window_init)(AAC_RENAME(ff_sine_120), 120);
+#endif
     AAC_RENAME(ff_init_ff_sine_windows)(10);
     AAC_RENAME(ff_init_ff_sine_windows)( 9);
     AAC_RENAME(ff_init_ff_sine_windows)( 7);
@@ -1185,7 +1227,13 @@ static av_cold int aac_decode_init(AVCodecContext *avctx)
     AAC_RENAME_32(ff_mdct_init)(&ac->mdct_small,  8, 1, 1.0 / RANGE15(128.0));
     AAC_RENAME_32(ff_mdct_init)(&ac->mdct_ltp,   11, 0, RANGE15(-2.0));
 #if !USE_FIXED
-    ret = ff_imdct15_init(&ac->mdct480, 5);
+    ret = ff_mdct15_init(&ac->mdct120, 1, 3, 1.0f/(16*1024*120*2));
+    if (ret < 0)
+        return ret;
+    ret = ff_mdct15_init(&ac->mdct480, 1, 5, 1.0f/(16*1024*960));
+    if (ret < 0)
+        return ret;
+    ret = ff_mdct15_init(&ac->mdct960, 1, 6, 1.0f/(16*1024*960*2));
     if (ret < 0)
         return ret;
 #endif
@@ -1255,6 +1303,8 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
     const MPEG4AudioConfig *const m4ac = &ac->oc[1].m4ac;
     const int aot = m4ac->object_type;
     const int sampling_index = m4ac->sampling_index;
+    int ret_fail = AVERROR_INVALIDDATA;
+
     if (aot != AOT_ER_AAC_ELD) {
         if (get_bits1(gb)) {
             av_log(ac->avctx, AV_LOG_ERROR, "Reserved bit set.\n");
@@ -1288,8 +1338,13 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
             }
         }
         ics->num_windows       = 8;
-        ics->swb_offset        =    ff_swb_offset_128[sampling_index];
-        ics->num_swb           =   ff_aac_num_swb_128[sampling_index];
+        if (m4ac->frame_length_short) {
+            ics->swb_offset    =  ff_swb_offset_120[sampling_index];
+            ics->num_swb       = ff_aac_num_swb_120[sampling_index];
+        } else {
+            ics->swb_offset    =  ff_swb_offset_128[sampling_index];
+            ics->num_swb       = ff_aac_num_swb_128[sampling_index];
+        }
         ics->tns_max_bands     = ff_tns_max_bands_128[sampling_index];
         ics->predictor_present = 0;
     } else {
@@ -1305,11 +1360,18 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
                 ics->num_swb       =    ff_aac_num_swb_512[sampling_index];
                 ics->tns_max_bands =  ff_tns_max_bands_512[sampling_index];
             }
-            if (!ics->num_swb || !ics->swb_offset)
-                return AVERROR_BUG;
+            if (!ics->num_swb || !ics->swb_offset) {
+                ret_fail = AVERROR_BUG;
+                goto fail;
+            }
         } else {
-            ics->swb_offset    =    ff_swb_offset_1024[sampling_index];
-            ics->num_swb       =   ff_aac_num_swb_1024[sampling_index];
+            if (m4ac->frame_length_short) {
+                ics->num_swb    = ff_aac_num_swb_960[sampling_index];
+                ics->swb_offset = ff_swb_offset_960[sampling_index];
+            } else {
+                ics->num_swb    = ff_aac_num_swb_1024[sampling_index];
+                ics->swb_offset = ff_swb_offset_1024[sampling_index];
+            }
             ics->tns_max_bands = ff_tns_max_bands_1024[sampling_index];
         }
         if (aot != AOT_ER_AAC_ELD) {
@@ -1330,7 +1392,8 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
                 if (aot == AOT_ER_AAC_LD) {
                     av_log(ac->avctx, AV_LOG_ERROR,
                            "LTP in ER AAC LD not yet implemented.\n");
-                    return AVERROR_PATCHWELCOME;
+                    ret_fail = AVERROR_PATCHWELCOME;
+                    goto fail;
                 }
                 if ((ics->ltp.present = get_bits(gb, 1)))
                     decode_ltp(&ics->ltp, gb, ics->max_sfb);
@@ -1349,7 +1412,7 @@ static int decode_ics_info(AACContext *ac, IndividualChannelStream *ics,
     return 0;
 fail:
     ics->max_sfb = 0;
-    return AVERROR_INVALIDDATA;
+    return ret_fail;
 }
 
 /**
@@ -1936,16 +1999,17 @@ static int decode_ics(AACContext *ac, SingleChannelElement *sce,
     global_gain = get_bits(gb, 8);
 
     if (!common_window && !scale_flag) {
-        if (decode_ics_info(ac, ics, gb) < 0)
-            return AVERROR_INVALIDDATA;
+        ret = decode_ics_info(ac, ics, gb);
+        if (ret < 0)
+            goto fail;
     }
 
     if ((ret = decode_band_types(ac, sce->band_type,
                                  sce->band_type_run_end, gb, ics)) < 0)
-        return ret;
+        goto fail;
     if ((ret = decode_scalefactors(ac, sce->sf, gb, global_gain, ics,
                                   sce->band_type, sce->band_type_run_end)) < 0)
-        return ret;
+        goto fail;
 
     pulse_present = 0;
     if (!scale_flag) {
@@ -1953,37 +2017,48 @@ static int decode_ics(AACContext *ac, SingleChannelElement *sce,
             if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
                 av_log(ac->avctx, AV_LOG_ERROR,
                        "Pulse tool not allowed in eight short sequence.\n");
-                return AVERROR_INVALIDDATA;
+                ret = AVERROR_INVALIDDATA;
+                goto fail;
             }
             if (decode_pulses(&pulse, gb, ics->swb_offset, ics->num_swb)) {
                 av_log(ac->avctx, AV_LOG_ERROR,
                        "Pulse data corrupt or invalid.\n");
-                return AVERROR_INVALIDDATA;
+                ret = AVERROR_INVALIDDATA;
+                goto fail;
             }
         }
         tns->present = get_bits1(gb);
-        if (tns->present && !er_syntax)
-            if (decode_tns(ac, tns, gb, ics) < 0)
-                return AVERROR_INVALIDDATA;
+        if (tns->present && !er_syntax) {
+            ret = decode_tns(ac, tns, gb, ics);
+            if (ret < 0)
+                goto fail;
+        }
         if (!eld_syntax && get_bits1(gb)) {
             avpriv_request_sample(ac->avctx, "SSR");
-            return AVERROR_PATCHWELCOME;
+            ret = AVERROR_PATCHWELCOME;
+            goto fail;
         }
         // I see no textual basis in the spec for this occurring after SSR gain
         // control, but this is what both reference and real implmentations do
-        if (tns->present && er_syntax)
-            if (decode_tns(ac, tns, gb, ics) < 0)
-                return AVERROR_INVALIDDATA;
+        if (tns->present && er_syntax) {
+            ret = decode_tns(ac, tns, gb, ics);
+            if (ret < 0)
+                goto fail;
+        }
     }
 
-    if (decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present,
-                                    &pulse, ics, sce->band_type) < 0)
-        return AVERROR_INVALIDDATA;
+    ret = decode_spectrum_and_dequant(ac, out, gb, sce->sf, pulse_present,
+                                    &pulse, ics, sce->band_type);
+    if (ret < 0)
+        goto fail;
 
     if (ac->oc[1].m4ac.object_type == AOT_AAC_MAIN && !common_window)
         apply_prediction(ac, sce);
 
     return 0;
+fail:
+    tns->present = 0;
+    return ret;
 }
 
 /**
@@ -2155,7 +2230,11 @@ static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
     coup->coupling_point += get_bits1(gb) || (coup->coupling_point >> 1);
 
     sign  = get_bits(gb, 1);
-    scale = AAC_RENAME(cce_scale)[get_bits(gb, 2)];
+#if USE_FIXED
+    scale = get_bits(gb, 2);
+#else
+    scale = cce_scale[get_bits(gb, 2)];
+#endif
 
     if ((ret = decode_ics(ac, sce, gb, 0, 0)))
         return ret;
@@ -2169,6 +2248,10 @@ static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
             cge = coup->coupling_point == AFTER_IMDCT ? 1 : get_bits1(gb);
             gain = cge ? get_vlc2(gb, vlc_scalefactors.table, 7, 3) - 60: 0;
             gain_cache = GET_GAIN(scale, gain);
+#if USE_FIXED
+            if ((abs(gain_cache)-1024) >> 3 > 30)
+                return AVERROR(ERANGE);
+#endif
         }
         if (coup->coupling_point == AFTER_IMDCT) {
             coup->gain[c][0] = gain_cache;
@@ -2186,6 +2269,10 @@ static int decode_cce(AACContext *ac, GetBitContext *gb, ChannelElement *che)
                                     t >>= 1;
                                 }
                                 gain_cache = GET_GAIN(scale, t) * s;
+#if USE_FIXED
+                                if ((abs(gain_cache)-1024) >> 3 > 30)
+                                    return AVERROR(ERANGE);
+#endif
                             }
                         }
                         coup->gain[c][idx] = gain_cache;
@@ -2318,6 +2405,13 @@ static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
         if (!che) {
             av_log(ac->avctx, AV_LOG_ERROR, "SBR was found before the first channel element.\n");
             return res;
+        } else if (ac->oc[1].m4ac.frame_length_short) {
+            if (!ac->warned_960_sbr)
+              avpriv_report_missing_feature(ac->avctx,
+                                            "SBR with 960 frame length");
+            ac->warned_960_sbr = 1;
+            skip_bits_long(gb, 8 * cnt - 4);
+            return res;
         } else if (!ac->oc[1].m4ac.sbr) {
             av_log(ac->avctx, AV_LOG_ERROR, "SBR signaled to be not-present but was found in the bitstream.\n");
             skip_bits_long(gb, 8 * cnt - 4);
@@ -2359,7 +2453,7 @@ static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
  * @param   decode  1 if tool is used normally, 0 if tool is used in LTP.
  * @param   coef    spectral coefficients
  */
-static void apply_tns(INTFLOAT coef[1024], TemporalNoiseShaping *tns,
+static void apply_tns(INTFLOAT coef_param[1024], TemporalNoiseShaping *tns,
                       IndividualChannelStream *ics, int decode)
 {
     const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb);
@@ -2367,6 +2461,7 @@ static void apply_tns(INTFLOAT coef[1024], TemporalNoiseShaping *tns,
     int bottom, top, order, start, end, size, inc;
     INTFLOAT lpc[TNS_MAX_ORDER];
     INTFLOAT tmp[TNS_MAX_ORDER+1];
+    UINTFLOAT *coef = coef_param;
 
     for (w = 0; w < ics->num_windows; w++) {
         bottom = ics->num_swb;
@@ -2396,7 +2491,7 @@ static void apply_tns(INTFLOAT coef[1024], TemporalNoiseShaping *tns,
                 // ar filter
                 for (m = 0; m < size; m++, start += inc)
                     for (i = 1; i <= FFMIN(m, order); i++)
-                        coef[start] -= AAC_MUL26(coef[start - i * inc], lpc[i - 1]);
+                        coef[start] -= AAC_MUL26((INTFLOAT)coef[start - i * inc], lpc[i - 1]);
             } else {
                 // ma filter
                 for (m = 0; m < size; m++, start += inc) {
@@ -2576,6 +2671,72 @@ static void imdct_and_windowing(AACContext *ac, SingleChannelElement *sce)
     }
 }
 
+/**
+ * Conduct IMDCT and windowing.
+ */
+static void imdct_and_windowing_960(AACContext *ac, SingleChannelElement *sce)
+{
+#if !USE_FIXED
+    IndividualChannelStream *ics = &sce->ics;
+    INTFLOAT *in    = sce->coeffs;
+    INTFLOAT *out   = sce->ret;
+    INTFLOAT *saved = sce->saved;
+    const INTFLOAT *swindow      = ics->use_kb_window[0] ? AAC_RENAME(ff_aac_kbd_short_120) : AAC_RENAME(ff_sine_120);
+    const INTFLOAT *lwindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_long_960) : AAC_RENAME(ff_sine_960);
+    const INTFLOAT *swindow_prev = ics->use_kb_window[1] ? AAC_RENAME(ff_aac_kbd_short_120) : AAC_RENAME(ff_sine_120);
+    INTFLOAT *buf  = ac->buf_mdct;
+    INTFLOAT *temp = ac->temp;
+    int i;
+
+    // imdct
+    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
+        for (i = 0; i < 8; i++)
+            ac->mdct120->imdct_half(ac->mdct120, buf + i * 120, in + i * 128, 1);
+    } else {
+        ac->mdct960->imdct_half(ac->mdct960, buf, in, 1);
+    }
+
+    /* window overlapping
+     * NOTE: To simplify the overlapping code, all 'meaningless' short to long
+     * and long to short transitions are considered to be short to short
+     * transitions. This leaves just two cases (long to long and short to short)
+     * with a little special sauce for EIGHT_SHORT_SEQUENCE.
+     */
+
+    if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
+        (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
+        ac->fdsp->vector_fmul_window(    out,               saved,            buf,         lwindow_prev, 480);
+    } else {
+        memcpy(                          out,               saved,            420 * sizeof(*out));
+
+        if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
+            ac->fdsp->vector_fmul_window(out + 420 + 0*120, saved + 420,      buf + 0*120, swindow_prev, 60);
+            ac->fdsp->vector_fmul_window(out + 420 + 1*120, buf + 0*120 + 60, buf + 1*120, swindow,      60);
+            ac->fdsp->vector_fmul_window(out + 420 + 2*120, buf + 1*120 + 60, buf + 2*120, swindow,      60);
+            ac->fdsp->vector_fmul_window(out + 420 + 3*120, buf + 2*120 + 60, buf + 3*120, swindow,      60);
+            ac->fdsp->vector_fmul_window(temp,              buf + 3*120 + 60, buf + 4*120, swindow,      60);
+            memcpy(                      out + 420 + 4*120, temp, 60 * sizeof(*out));
+        } else {
+            ac->fdsp->vector_fmul_window(out + 420,         saved + 420,      buf,         swindow_prev, 60);
+            memcpy(                      out + 540,         buf + 60,         420 * sizeof(*out));
+        }
+    }
+
+    // buffer update
+    if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
+        memcpy(                      saved,       temp + 60,         60 * sizeof(*saved));
+        ac->fdsp->vector_fmul_window(saved + 60,  buf + 4*120 + 60, buf + 5*120, swindow, 60);
+        ac->fdsp->vector_fmul_window(saved + 180, buf + 5*120 + 60, buf + 6*120, swindow, 60);
+        ac->fdsp->vector_fmul_window(saved + 300, buf + 6*120 + 60, buf + 7*120, swindow, 60);
+        memcpy(                      saved + 420, buf + 7*120 + 60,  60 * sizeof(*saved));
+    } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
+        memcpy(                      saved,       buf + 480,        420 * sizeof(*saved));
+        memcpy(                      saved + 420, buf + 7*120 + 60,  60 * sizeof(*saved));
+    } else { // LONG_STOP or ONLY_LONG
+        memcpy(                      saved,       buf + 480,        480 * sizeof(*saved));
+    }
+#endif
+}
 static void imdct_and_windowing_ld(AACContext *ac, SingleChannelElement *sce)
 {
     IndividualChannelStream *ics = &sce->ics;
@@ -2634,7 +2795,7 @@ static void imdct_and_windowing_eld(AACContext *ac, SingleChannelElement *sce)
     }
 #if !USE_FIXED
     if (n == 480)
-        ac->mdct480->imdct_half(ac->mdct480, buf, in, 1, -1.f/(16*1024*960));
+        ac->mdct480->imdct_half(ac->mdct480, buf, in, 1);
     else
 #endif
         ac->mdct.imdct_half(&ac->mdct_ld, buf, in);
@@ -2727,7 +2888,10 @@ static void spectral_to_sample(AACContext *ac, int samples)
         imdct_and_window = imdct_and_windowing_eld;
         break;
     default:
-        imdct_and_window = ac->imdct_and_windowing;
+        if (ac->oc[1].m4ac.frame_length_short)
+            imdct_and_window = imdct_and_windowing_960;
+        else
+            imdct_and_window = ac->imdct_and_windowing;
     }
     for (type = 3; type >= 0; type--) {
         for (i = 0; i < MAX_ELEM_ID; i++) {
@@ -2770,9 +2934,9 @@ static void spectral_to_sample(AACContext *ac, int samples)
                     int j;
                     /* preparation for resampler */
                     for(j = 0; j<samples; j++){
-                        che->ch[0].ret[j] = (int32_t)av_clipl_int32((int64_t)che->ch[0].ret[j]<<7)+0x8000;
+                        che->ch[0].ret[j] = (int32_t)av_clip64((int64_t)che->ch[0].ret[j]*128, INT32_MIN, INT32_MAX-0x8000)+0x8000;
                         if(type == TYPE_CPE)
-                            che->ch[1].ret[j] = (int32_t)av_clipl_int32((int64_t)che->ch[1].ret[j]<<7)+0x8000;
+                            che->ch[1].ret[j] = (int32_t)av_clip64((int64_t)che->ch[1].ret[j]*128, INT32_MIN, INT32_MAX-0x8000)+0x8000;
                     }
                 }
 #endif /* USE_FIXED */
@@ -2923,10 +3087,11 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
 {
     AACContext *ac = avctx->priv_data;
     ChannelElement *che = NULL, *che_prev = NULL;
-    enum RawDataBlockType elem_type, elem_type_prev = TYPE_END;
+    enum RawDataBlockType elem_type, che_prev_type = TYPE_END;
     int err, elem_id;
     int samples = 0, multiplier, audio_found = 0, pce_found = 0;
     int is_dmono, sce_count = 0;
+    int payload_alignment;
 
     ac->frame = data;
 
@@ -2949,6 +3114,7 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
     // This may lead to an undefined profile being signaled
     ac->avctx->profile = ac->oc[1].m4ac.object_type - 1;
 
+    payload_alignment = get_bits_count(gb);
     ac->tags_mapped = 0;
     // parse
     while ((elem_type = get_bits(gb, 3)) != TYPE_END) {
@@ -2969,7 +3135,7 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
                 err = AVERROR_INVALIDDATA;
                 goto fail;
             }
-            samples = 1024;
+            samples = ac->oc[1].m4ac.frame_length_short ? 960 : 1024;
             che->present = 1;
         }
 
@@ -3002,8 +3168,15 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
         case TYPE_PCE: {
             uint8_t layout_map[MAX_ELEM_ID*4][3];
             int tags;
-            push_output_configuration(ac);
-            tags = decode_pce(avctx, &ac->oc[1].m4ac, layout_map, gb);
+
+            int pushed = push_output_configuration(ac);
+            if (pce_found && !pushed) {
+                err = AVERROR_INVALIDDATA;
+                goto fail;
+            }
+
+            tags = decode_pce(avctx, &ac->oc[1].m4ac, layout_map, gb,
+                              payload_alignment);
             if (tags < 0) {
                 err = tags;
                 break;
@@ -3011,6 +3184,7 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
             if (pce_found) {
                 av_log(avctx, AV_LOG_ERROR,
                        "Not evaluating a further program_config_element as this construct is dubious at best.\n");
+                pop_output_configuration(ac);
             } else {
                 err = output_configure(ac, layout_map, tags, OC_TRIAL_PCE, 1);
                 if (!err)
@@ -3029,7 +3203,7 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
                     goto fail;
             }
             while (elem_id > 0)
-                elem_id -= decode_extension_payload(ac, gb, elem_id, che_prev, elem_type_prev);
+                elem_id -= decode_extension_payload(ac, gb, elem_id, che_prev, che_prev_type);
             err = 0; /* FIXME */
             break;
 
@@ -3038,8 +3212,10 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
             break;
         }
 
-        che_prev       = che;
-        elem_type_prev = elem_type;
+        if (elem_type < TYPE_DSE) {
+            che_prev      = che;
+            che_prev_type = elem_type;
+        }
 
         if (err)
             goto fail;
@@ -3067,12 +3243,8 @@ static int aac_decode_frame_int(AVCodecContext *avctx, void *data,
         ac->oc[1].status = OC_LOCKED;
     }
 
-    if (multiplier) {
-        int side_size;
-        const uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, &side_size);
-        if (side && side_size>=4)
-            AV_WL32(side, 2*AV_RL32(side));
-    }
+    if (multiplier)
+        avctx->internal->skip_samples_multiplier = 2;
 
     if (!ac->frame->data[0] && samples) {
         av_log(avctx, AV_LOG_ERROR, "no frame data found\n");
@@ -3190,7 +3362,9 @@ static av_cold int aac_decode_close(AVCodecContext *avctx)
     ff_mdct_end(&ac->mdct_ld);
     ff_mdct_end(&ac->mdct_ltp);
 #if !USE_FIXED
-    ff_imdct15_uninit(&ac->mdct480);
+    ff_mdct15_uninit(&ac->mdct120);
+    ff_mdct15_uninit(&ac->mdct480);
+    ff_mdct15_uninit(&ac->mdct960);
 #endif
     av_freep(&ac->fdsp);
     return 0;
diff --git a/mythtv/external/FFmpeg/libavcodec/aacenc.c b/mythtv/external/FFmpeg/libavcodec/aacenc.c
index 363ed0537b3..11da260742b 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/aacenc.c
@@ -520,13 +520,13 @@ static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     int chan_el_counter[4];
     FFPsyWindowInfo windows[AAC_MAX_CHANNELS];
 
-    if (s->last_frame == 2)
-        return 0;
-
     /* add current frame to queue */
     if (frame) {
         if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
             return ret;
+    } else {
+        if (!s->afq.remaining_samples || (!s->afq.frame_alloc && !s->afq.frame_count))
+            return 0;
     }
 
     copy_input_samples(s, frame);
@@ -769,7 +769,7 @@ static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
             start_ch += chans;
         }
 
-        if (avctx->flags & CODEC_FLAG_QSCALE) {
+        if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
             /* When using a constant Q-scale, don't mess with lambda */
             break;
         }
@@ -841,9 +841,6 @@ static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     s->lambda_sum += s->lambda;
     s->lambda_count++;
 
-    if (!frame)
-        s->last_frame++;
-
     ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
                        &avpkt->duration);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/aacenc.h b/mythtv/external/FFmpeg/libavcodec/aacenc.h
index 38a97349945..ea2d3b9628c 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacenc.h
+++ b/mythtv/external/FFmpeg/libavcodec/aacenc.h
@@ -78,7 +78,7 @@ typedef struct AACCoefficientsEncoder {
     void (*search_for_pred)(struct AACEncContext *s, SingleChannelElement *sce);
 } AACCoefficientsEncoder;
 
-extern AACCoefficientsEncoder ff_aac_coders[];
+extern const AACCoefficientsEncoder ff_aac_coders[];
 
 typedef struct AACQuantizeBandCostCacheEntry {
     float rd;
@@ -110,9 +110,8 @@ typedef struct AACEncContext {
     ChannelElement *cpe;                         ///< channel elements
     FFPsyContext psy;
     struct FFPsyPreprocessContext* psypp;
-    AACCoefficientsEncoder *coder;
+    const AACCoefficientsEncoder *coder;
     int cur_channel;                             ///< current channel for coder context
-    int last_frame;
     int random_state;
     float lambda;
     int last_frame_pb_count;                     ///< number of bits for the previous frame
diff --git a/mythtv/external/FFmpeg/libavcodec/aacenc_ltp.c b/mythtv/external/FFmpeg/libavcodec/aacenc_ltp.c
index 1bec85b9e39..674a2a06807 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacenc_ltp.c
+++ b/mythtv/external/FFmpeg/libavcodec/aacenc_ltp.c
@@ -74,8 +74,8 @@ void ff_aac_ltp_insert_new_frame(AACEncContext *s)
 
 static void get_lag(float *buf, const float *new, LongTermPrediction *ltp)
 {
-    int i, j, lag, max_corr = 0;
-    float max_ratio;
+    int i, j, lag = 0, max_corr = 0;
+    float max_ratio = 0.0f;
     for (i = 0; i < 2048; i++) {
         float corr, s0 = 0.0f, s1 = 0.0f;
         const int start = FFMAX(0, i - 1024);
diff --git a/mythtv/external/FFmpeg/libavcodec/aacps.c b/mythtv/external/FFmpeg/libavcodec/aacps.c
index ccc79ffc1dd..b16c3393d10 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacps.c
+++ b/mythtv/external/FFmpeg/libavcodec/aacps.c
@@ -196,8 +196,13 @@ int AAC_RENAME(ff_ps_read_data)(AVCodecContext *avctx, GetBitContext *gb_host, P
 
     ps->border_position[0] = -1;
     if (ps->frame_class) {
-        for (e = 1; e <= ps->num_env; e++)
+        for (e = 1; e <= ps->num_env; e++) {
             ps->border_position[e] = get_bits(gb, 5);
+            if (ps->border_position[e] < ps->border_position[e-1]) {
+                av_log(avctx, AV_LOG_ERROR, "border_position non monotone.\n");
+                goto err;
+            }
+        }
     } else
         for (e = 1; e <= ps->num_env; e++)
             ps->border_position[e] = (e * numQMFSlots >> ff_log2_tab[ps->num_env]) - 1;
@@ -499,13 +504,13 @@ static void map_idx_34_to_20(int8_t *par_mapped, const int8_t *par, int full)
 static void map_val_34_to_20(INTFLOAT par[PS_MAX_NR_IIDICC])
 {
 #if USE_FIXED
-    par[ 0] = (int)(((int64_t)(par[ 0] + (par[ 1]>>1)) * 1431655765 + \
+    par[ 0] = (int)(((int64_t)(par[ 0] + (unsigned)(par[ 1]>>1)) * 1431655765 + \
                       0x40000000) >> 31);
-    par[ 1] = (int)(((int64_t)((par[ 1]>>1) + par[ 2]) * 1431655765 + \
+    par[ 1] = (int)(((int64_t)((par[ 1]>>1) + (unsigned)par[ 2]) * 1431655765 + \
                       0x40000000) >> 31);
-    par[ 2] = (int)(((int64_t)(par[ 3] + (par[ 4]>>1)) * 1431655765 + \
+    par[ 2] = (int)(((int64_t)(par[ 3] + (unsigned)(par[ 4]>>1)) * 1431655765 + \
                       0x40000000) >> 31);
-    par[ 3] = (int)(((int64_t)((par[ 4]>>1) + par[ 5]) * 1431655765 + \
+    par[ 3] = (int)(((int64_t)((par[ 4]>>1) + (unsigned)par[ 5]) * 1431655765 + \
                       0x40000000) >> 31);
 #else
     par[ 0] = (2*par[ 0] +   par[ 1]) * 0.33333333f;
@@ -692,26 +697,17 @@ static void decorrelation(PSContext *ps, INTFLOAT (*out)[32][2], const INTFLOAT
     for (i = 0; i < NR_PAR_BANDS[is34]; i++) {
         for (n = n0; n < nL; n++) {
             int decayed_peak;
-            int denom;
-
             decayed_peak = (int)(((int64_t)peak_decay_factor * \
                                            peak_decay_nrg[i] + 0x40000000) >> 31);
             peak_decay_nrg[i] = FFMAX(decayed_peak, power[i][n]);
-            power_smooth[i] += (power[i][n] - power_smooth[i] + 2) >> 2;
-            peak_decay_diff_smooth[i] += (peak_decay_nrg[i] - power[i][n] - \
-                                          peak_decay_diff_smooth[i] + 2) >> 2;
-            denom = peak_decay_diff_smooth[i] + (peak_decay_diff_smooth[i] >> 1);
-            if (denom > power_smooth[i]) {
-              int p = power_smooth[i];
-              while (denom < 0x40000000) {
-                denom <<= 1;
-                p <<= 1;
-              }
-              transient_gain[i][n] = p / (denom >> 16);
-            }
-            else {
-              transient_gain[i][n] = 1 << 16;
-            }
+            power_smooth[i] += (power[i][n] + 2LL - power_smooth[i]) >> 2;
+            peak_decay_diff_smooth[i] += (peak_decay_nrg[i] + 2LL - power[i][n] - \
+                                          peak_decay_diff_smooth[i]) >> 2;
+
+            if (peak_decay_diff_smooth[i]) {
+                transient_gain[i][n] = FFMIN(power_smooth[i]*43691LL / peak_decay_diff_smooth[i], 1<<16);
+            } else
+                transient_gain[i][n] = 1 << 16;
         }
     }
 #else
@@ -942,7 +938,7 @@ static void stereo_processing(PSContext *ps, INTFLOAT (*l)[32][2], INTFLOAT (*r)
             int stop  = ps->border_position[e+1];
             INTFLOAT width = Q30(1.f) / ((stop - start) ? (stop - start) : 1);
 #if USE_FIXED
-            width <<= 1;
+            width = FFMIN(2U*width, INT_MAX);
 #endif
             b = k_to_i[k];
             h[0][0] = H11[0][e][b];
@@ -974,9 +970,10 @@ static void stereo_processing(PSContext *ps, INTFLOAT (*l)[32][2], INTFLOAT (*r)
                 h_step[1][2] = AAC_MSUB31_V3(H21[1][e+1][b], h[1][2], width);
                 h_step[1][3] = AAC_MSUB31_V3(H22[1][e+1][b], h[1][3], width);
             }
-            ps->dsp.stereo_interpolate[!PS_BASELINE && ps->enable_ipdopd](
-                l[k] + start + 1, r[k] + start + 1,
-                h, h_step, stop - start);
+            if (stop - start)
+                ps->dsp.stereo_interpolate[!PS_BASELINE && ps->enable_ipdopd](
+                    l[k] + 1 + start, r[k] + 1 + start,
+                    h, h_step, stop - start);
         }
     }
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/aacpsdsp.h b/mythtv/external/FFmpeg/libavcodec/aacpsdsp.h
index ad9bbb81bdb..917ac5303f5 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacpsdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/aacpsdsp.h
@@ -21,6 +21,8 @@
 #ifndef AVCODEC_AACPSDSP_H
 #define AVCODEC_AACPSDSP_H
 
+#include <stddef.h>
+
 #include "aac_defines.h"
 
 #define PS_QMF_TIME_SLOTS 32
@@ -33,7 +35,7 @@ typedef struct PSDSPContext {
                             int n);
     void (*hybrid_analysis)(INTFLOAT (*out)[2], INTFLOAT (*in)[2],
                             const INTFLOAT (*filter)[8][2],
-                            int stride, int n);
+                            ptrdiff_t stride, int n);
     void (*hybrid_analysis_ileave)(INTFLOAT (*out)[32][2], INTFLOAT L[2][38][64],
                                    int i, int len);
     void (*hybrid_synthesis_deint)(INTFLOAT out[2][38][64], INTFLOAT (*in)[32][2],
@@ -51,6 +53,7 @@ typedef struct PSDSPContext {
 
 void AAC_RENAME(ff_psdsp_init)(PSDSPContext *s);
 void ff_psdsp_init_arm(PSDSPContext *s);
+void ff_psdsp_init_aarch64(PSDSPContext *s);
 void ff_psdsp_init_mips(PSDSPContext *s);
 void ff_psdsp_init_x86(PSDSPContext *s);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/aacpsdsp_template.c b/mythtv/external/FFmpeg/libavcodec/aacpsdsp_template.c
index 3049ce8b79e..19be2006536 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacpsdsp_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/aacpsdsp_template.c
@@ -30,7 +30,7 @@ static void ps_add_squares_c(INTFLOAT *dst, const INTFLOAT (*src)[2], int n)
 {
     int i;
     for (i = 0; i < n; i++)
-        dst[i] += AAC_MADD28(src[i][0], src[i][0], src[i][1], src[i][1]);
+        dst[i] += (UINTFLOAT)AAC_MADD28(src[i][0], src[i][0], src[i][1], src[i][1]);
 }
 
 static void ps_mul_pair_single_c(INTFLOAT (*dst)[2], INTFLOAT (*src0)[2], INTFLOAT *src1,
@@ -45,7 +45,7 @@ static void ps_mul_pair_single_c(INTFLOAT (*dst)[2], INTFLOAT (*src0)[2], INTFLO
 
 static void ps_hybrid_analysis_c(INTFLOAT (*out)[2], INTFLOAT (*in)[2],
                                  const INTFLOAT (*filter)[8][2],
-                                 int stride, int n)
+                                 ptrdiff_t stride, int n)
 {
     int i, j;
 
@@ -72,6 +72,7 @@ static void ps_hybrid_analysis_c(INTFLOAT (*out)[2], INTFLOAT (*in)[2],
 #endif /* USE_FIXED */
     }
 }
+
 static void ps_hybrid_analysis_ileave_c(INTFLOAT (*out)[32][2], INTFLOAT L[2][38][64],
                                       int i, int len)
 {
@@ -129,12 +130,12 @@ static void ps_decorrelate_c(INTFLOAT (*out)[2], INTFLOAT (*delay)[2],
             INTFLOAT apd_im = in_im;
             in_re = AAC_MSUB30(link_delay_re, fractional_delay_re,
                     link_delay_im, fractional_delay_im);
-            in_re -= a_re;
+            in_re -= (UINTFLOAT)a_re;
             in_im = AAC_MADD30(link_delay_re, fractional_delay_im,
                     link_delay_im, fractional_delay_re);
-            in_im -= a_im;
-            ap_delay[m][n+5][0] = apd_re + AAC_MUL31(ag[m], in_re);
-            ap_delay[m][n+5][1] = apd_im + AAC_MUL31(ag[m], in_im);
+            in_im -= (UINTFLOAT)a_im;
+            ap_delay[m][n+5][0] = apd_re + (UINTFLOAT)AAC_MUL31(ag[m], in_re);
+            ap_delay[m][n+5][1] = apd_im + (UINTFLOAT)AAC_MUL31(ag[m], in_im);
         }
         out[n][0] = AAC_MUL16(transient_gain[n], in_re);
         out[n][1] = AAC_MUL16(transient_gain[n], in_im);
@@ -165,10 +166,10 @@ static void ps_stereo_interpolate_c(INTFLOAT (*l)[2], INTFLOAT (*r)[2],
         h1 += hs1;
         h2 += hs2;
         h3 += hs3;
-        l[n][0] = AAC_MADD30(h0,  l_re,  h2, r_re);
-        l[n][1] = AAC_MADD30(h0,  l_im,  h2,  r_im);
-        r[n][0] = AAC_MADD30(h1,  l_re,  h3,  r_re);
-        r[n][1] = AAC_MADD30(h1,  l_im,  h3,  r_im);
+        l[n][0] = AAC_MADD30(h0, l_re, h2, r_re);
+        l[n][1] = AAC_MADD30(h0, l_im, h2, r_im);
+        r[n][0] = AAC_MADD30(h1, l_re, h3, r_re);
+        r[n][1] = AAC_MADD30(h1, l_im, h3, r_im);
     }
 }
 
@@ -222,6 +223,8 @@ av_cold void AAC_RENAME(ff_psdsp_init)(PSDSPContext *s)
 #if !USE_FIXED
     if (ARCH_ARM)
         ff_psdsp_init_arm(s);
+    if (ARCH_AARCH64)
+        ff_psdsp_init_aarch64(s);
     if (ARCH_MIPS)
         ff_psdsp_init_mips(s);
     if (ARCH_X86)
diff --git a/mythtv/external/FFmpeg/libavcodec/aacpsy.c b/mythtv/external/FFmpeg/libavcodec/aacpsy.c
index a5fec7374ee..fca692cb153 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacpsy.c
+++ b/mythtv/external/FFmpeg/libavcodec/aacpsy.c
@@ -303,7 +303,7 @@ static av_cold int psy_3gpp_init(FFPsyContext *ctx) {
     float bark;
     int i, j, g, start;
     float prev, minscale, minath, minsnr, pe_min;
-    int chan_bitrate = ctx->avctx->bit_rate / ((ctx->avctx->flags & CODEC_FLAG_QSCALE) ? 2.0f : ctx->avctx->channels);
+    int chan_bitrate = ctx->avctx->bit_rate / ((ctx->avctx->flags & AV_CODEC_FLAG_QSCALE) ? 2.0f : ctx->avctx->channels);
 
     const int bandwidth    = ctx->cutoff ? ctx->cutoff : AAC_CUTOFF(ctx->avctx);
     const float num_bark   = calc_bark((float)bandwidth);
@@ -311,10 +311,10 @@ static av_cold int psy_3gpp_init(FFPsyContext *ctx) {
     ctx->model_priv_data = av_mallocz(sizeof(AacPsyContext));
     if (!ctx->model_priv_data)
         return AVERROR(ENOMEM);
-    pctx = (AacPsyContext*) ctx->model_priv_data;
+    pctx = ctx->model_priv_data;
     pctx->global_quality = (ctx->avctx->global_quality ? ctx->avctx->global_quality : 120) * 0.01f;
 
-    if (ctx->avctx->flags & CODEC_FLAG_QSCALE) {
+    if (ctx->avctx->flags & AV_CODEC_FLAG_QSCALE) {
         /* Use the target average bitrate to compute spread parameters */
         chan_bitrate = (int)(chan_bitrate / 120.0 * (ctx->avctx->global_quality ? ctx->avctx->global_quality : 120));
     }
@@ -704,7 +704,7 @@ static void psy_3gpp_analyze_channel(FFPsyContext *ctx, int channel,
 
     /* 5.6.1.3.2 "Calculation of the desired perceptual entropy" */
     ctx->ch[channel].entropy = pe;
-    if (ctx->avctx->flags & CODEC_FLAG_QSCALE) {
+    if (ctx->avctx->flags & AV_CODEC_FLAG_QSCALE) {
         /* (2.5 * 120) achieves almost transparent rate, and we want to give
          * ample room downwards, so we make that equivalent to QSCALE=2.4
          */
diff --git a/mythtv/external/FFmpeg/libavcodec/aacsbr.c b/mythtv/external/FFmpeg/libavcodec/aacsbr.c
index 15956e3f052..1d2a8d472d8 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacsbr.c
+++ b/mythtv/external/FFmpeg/libavcodec/aacsbr.c
@@ -241,6 +241,7 @@ static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
                                             ((1.0f + sbr->e_curr[e][m]) *
                                              (1.0f + sbr->q_mapped[e][m])));
                 }
+                sbr->gain[e][m] += FLT_MIN;
             }
             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
                 sum[0] += sbr->e_origmapped[e][m];
diff --git a/mythtv/external/FFmpeg/libavcodec/aacsbr.h b/mythtv/external/FFmpeg/libavcodec/aacsbr.h
index 88c4d8a916d..dd8b66c7bbc 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacsbr.h
+++ b/mythtv/external/FFmpeg/libavcodec/aacsbr.h
@@ -81,7 +81,7 @@ static const int8_t vlc_sbr_lav[10] =
 /** Initialize SBR. */
 void AAC_RENAME(ff_aac_sbr_init)(void);
 /** Initialize one SBR context. */
-void AAC_RENAME(ff_aac_sbr_ctx_init)(AACContext *ac, SpectralBandReplication *sbr);
+void AAC_RENAME(ff_aac_sbr_ctx_init)(AACContext *ac, SpectralBandReplication *sbr, int id_aac);
 /** Close one SBR context. */
 void AAC_RENAME(ff_aac_sbr_ctx_close)(SpectralBandReplication *sbr);
 /** Decode one SBR element. */
diff --git a/mythtv/external/FFmpeg/libavcodec/aacsbr_fixed.c b/mythtv/external/FFmpeg/libavcodec/aacsbr_fixed.c
index b26314a7eb5..3d5875a4690 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacsbr_fixed.c
+++ b/mythtv/external/FFmpeg/libavcodec/aacsbr_fixed.c
@@ -288,11 +288,12 @@ static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
         shift = a00.exp;
         if (shift >= 3)
             alpha0[k][0] = 0x7fffffff;
+        else if (shift <= -30)
+            alpha0[k][0] = 0;
         else {
-            a00.mant <<= 1;
-            shift = 2-shift;
-            if (shift == 0)
-                alpha0[k][0] = a00.mant;
+            shift = 1-shift;
+            if (shift <= 0)
+                alpha0[k][0] = a00.mant * (1<<-shift);
             else {
                 round = 1 << (shift-1);
                 alpha0[k][0] = (a00.mant + round) >> shift;
@@ -302,11 +303,12 @@ static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
         shift = a01.exp;
         if (shift >= 3)
             alpha0[k][1] = 0x7fffffff;
+        else if (shift <= -30)
+            alpha0[k][1] = 0;
         else {
-            a01.mant <<= 1;
-            shift = 2-shift;
-            if (shift == 0)
-                alpha0[k][1] = a01.mant;
+            shift = 1-shift;
+            if (shift <= 0)
+                alpha0[k][1] = a01.mant * (1<<-shift);
             else {
                 round = 1 << (shift-1);
                 alpha0[k][1] = (a01.mant + round) >> shift;
@@ -315,11 +317,12 @@ static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
         shift = a10.exp;
         if (shift >= 3)
             alpha1[k][0] = 0x7fffffff;
+        else if (shift <= -30)
+            alpha1[k][0] = 0;
         else {
-            a10.mant <<= 1;
-            shift = 2-shift;
-            if (shift == 0)
-                alpha1[k][0] = a10.mant;
+            shift = 1-shift;
+            if (shift <= 0)
+                alpha1[k][0] = a10.mant * (1<<-shift);
             else {
                 round = 1 << (shift-1);
                 alpha1[k][0] = (a10.mant + round) >> shift;
@@ -329,11 +332,12 @@ static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
         shift = a11.exp;
         if (shift >= 3)
             alpha1[k][1] = 0x7fffffff;
+        else if (shift <= -30)
+            alpha1[k][1] = 0;
         else {
-            a11.mant <<= 1;
-            shift = 2-shift;
-            if (shift == 0)
-                alpha1[k][1] = a11.mant;
+            shift = 1-shift;
+            if (shift <= 0)
+                alpha1[k][1] = a11.mant * (1<<-shift);
             else {
                 round = 1 << (shift-1);
                 alpha1[k][1] = (a11.mant + round) >> shift;
@@ -429,6 +433,7 @@ static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
                                                 av_add_sf(FLOAT_1, sbr->e_curr[e][m]),
                                                 av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));
                 }
+                sbr->gain[e][m] = av_add_sf(sbr->gain[e][m], FLOAT_MIN);
             }
             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
                 sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);
@@ -567,20 +572,33 @@ static void sbr_hf_assemble(int Y1[38][64][2],
 
                 SoftFloat *in  = sbr->s_m[e];
                 for (m = 0; m+1 < m_max; m+=2) {
-                  shift = 22 - in[m  ].exp;
-                  round = 1 << (shift-1);
-                  out[2*m  ] += (in[m  ].mant * A + round) >> shift;
+                    int shift2;
+                    shift = 22 - in[m  ].exp;
+                    shift2= 22 - in[m+1].exp;
+                    if (shift < 1 || shift2 < 1) {
+                        av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d,%d\n", shift, shift2);
+                        return;
+                    }
+                    if (shift < 32) {
+                        round = 1 << (shift-1);
+                        out[2*m  ] += (in[m  ].mant * A + round) >> shift;
+                    }
 
-                  shift = 22 - in[m+1].exp;
-                  round = 1 << (shift-1);
-                  out[2*m+2] += (in[m+1].mant * B + round) >> shift;
+                    if (shift2 < 32) {
+                        round = 1 << (shift2-1);
+                        out[2*m+2] += (in[m+1].mant * B + round) >> shift2;
+                    }
                 }
                 if(m_max&1)
                 {
-                  shift = 22 - in[m  ].exp;
-                  round = 1 << (shift-1);
-
-                  out[2*m  ] += (in[m  ].mant * A + round) >> shift;
+                    shift = 22 - in[m  ].exp;
+                    if (shift < 1) {
+                        av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d\n", shift);
+                        return;
+                    } else if (shift < 32) {
+                        round = 1 << (shift-1);
+                        out[2*m  ] += (in[m  ].mant * A + round) >> shift;
+                    }
                 }
             }
             indexnoise = (indexnoise + m_max) & 0x1ff;
diff --git a/mythtv/external/FFmpeg/libavcodec/aacsbr_template.c b/mythtv/external/FFmpeg/libavcodec/aacsbr_template.c
index 511054276a7..3fe78d5b622 100644
--- a/mythtv/external/FFmpeg/libavcodec/aacsbr_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/aacsbr_template.c
@@ -81,11 +81,12 @@ static void sbr_turnoff(SpectralBandReplication *sbr) {
     memset(&sbr->spectrum_params, -1, sizeof(SpectrumParameters));
 }
 
-av_cold void AAC_RENAME(ff_aac_sbr_ctx_init)(AACContext *ac, SpectralBandReplication *sbr)
+av_cold void AAC_RENAME(ff_aac_sbr_ctx_init)(AACContext *ac, SpectralBandReplication *sbr, int id_aac)
 {
     if(sbr->mdct.mdct_bits)
         return;
     sbr->kx[0] = sbr->kx[1];
+    sbr->id_aac = id_aac;
     sbr_turnoff(sbr);
     sbr->data[0].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
     sbr->data[1].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
@@ -260,13 +261,6 @@ static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
     const int8_t *sbr_offset_ptr;
     int16_t stop_dk[13];
 
-    if (sbr->sample_rate < 32000) {
-        temp = 3000;
-    } else if (sbr->sample_rate < 64000) {
-        temp = 4000;
-    } else
-        temp = 5000;
-
     switch (sbr->sample_rate) {
     case 16000:
         sbr_offset_ptr = sbr_offset[0];
@@ -292,6 +286,13 @@ static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
         return -1;
     }
 
+    if (sbr->sample_rate < 32000) {
+        temp = 3000;
+    } else if (sbr->sample_rate < 64000) {
+        temp = 4000;
+    } else
+        temp = 5000;
+
     start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
     stop_min  = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
 
@@ -623,24 +624,26 @@ static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
     int abs_bord_trail = 16;
     int num_rel_lead, num_rel_trail;
     unsigned bs_num_env_old = ch_data->bs_num_env;
+    int bs_frame_class, bs_num_env;
 
     ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env];
     ch_data->bs_amp_res = sbr->bs_amp_res_header;
     ch_data->t_env_num_env_old = ch_data->t_env[bs_num_env_old];
 
-    switch (ch_data->bs_frame_class = get_bits(gb, 2)) {
+    switch (bs_frame_class = get_bits(gb, 2)) {
     case FIXFIX:
-        ch_data->bs_num_env                 = 1 << get_bits(gb, 2);
-        num_rel_lead                        = ch_data->bs_num_env - 1;
-        if (ch_data->bs_num_env == 1)
-            ch_data->bs_amp_res = 0;
-
-        if (ch_data->bs_num_env > 4) {
+        bs_num_env = 1 << get_bits(gb, 2);
+        if (bs_num_env > 4) {
             av_log(ac->avctx, AV_LOG_ERROR,
                    "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
-                   ch_data->bs_num_env);
+                   bs_num_env);
             return -1;
         }
+        ch_data->bs_num_env = bs_num_env;
+        num_rel_lead                        = ch_data->bs_num_env - 1;
+        if (ch_data->bs_num_env == 1)
+            ch_data->bs_amp_res = 0;
+
 
         ch_data->t_env[0]                   = 0;
         ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
@@ -688,14 +691,15 @@ static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
         abs_bord_trail                     += get_bits(gb, 2);
         num_rel_lead                        = get_bits(gb, 2);
         num_rel_trail                       = get_bits(gb, 2);
-        ch_data->bs_num_env                 = num_rel_lead + num_rel_trail + 1;
+        bs_num_env                          = num_rel_lead + num_rel_trail + 1;
 
-        if (ch_data->bs_num_env > 5) {
+        if (bs_num_env > 5) {
             av_log(ac->avctx, AV_LOG_ERROR,
                    "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
-                   ch_data->bs_num_env);
+                   bs_num_env);
             return -1;
         }
+        ch_data->bs_num_env = bs_num_env;
 
         ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
 
@@ -710,6 +714,7 @@ static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
         get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
         break;
     }
+    ch_data->bs_frame_class = bs_frame_class;
 
     av_assert0(bs_pointer >= 0);
     if (bs_pointer > ch_data->bs_num_env + 1) {
@@ -940,14 +945,8 @@ static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
             skip_bits_long(gb, *num_bits_left); // bs_fill_bits
             *num_bits_left = 0;
         } else {
-#if 1
             *num_bits_left -= AAC_RENAME(ff_ps_read_data)(ac->avctx, gb, &sbr->ps, *num_bits_left);
             ac->avctx->profile = FF_PROFILE_AAC_HE_V2;
-#else
-            avpriv_report_missing_feature(ac->avctx, "Parametric Stereo");
-            skip_bits_long(gb, *num_bits_left); // bs_fill_bits
-            *num_bits_left = 0;
-#endif
         }
         break;
     default:
@@ -1142,6 +1141,7 @@ int AAC_RENAME(ff_decode_sbr_extension)(AACContext *ac, SpectralBandReplication
     if (bytes_read > cnt) {
         av_log(ac->avctx, AV_LOG_ERROR,
                "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
+        sbr_turnoff(sbr);
     }
     return cnt;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/aactab.c b/mythtv/external/FFmpeg/libavcodec/aactab.c
index 77d8732c47d..df551b058f5 100644
--- a/mythtv/external/FFmpeg/libavcodec/aactab.c
+++ b/mythtv/external/FFmpeg/libavcodec/aactab.c
@@ -37,6 +37,8 @@ float ff_aac_pow34sf_tab[428];
 
 DECLARE_ALIGNED(32, float,  ff_aac_kbd_long_1024)[1024];
 DECLARE_ALIGNED(32, float,  ff_aac_kbd_short_128)[128];
+DECLARE_ALIGNED(32, float,  ff_aac_kbd_long_960)[960];
+DECLARE_ALIGNED(32, float,  ff_aac_kbd_short_120)[120];
 DECLARE_ALIGNED(32, int,    ff_aac_kbd_long_1024_fixed)[1024];
 DECLARE_ALIGNED(32, int,    ff_aac_kbd_short_128_fixed)[128];
 
@@ -44,6 +46,10 @@ const uint8_t ff_aac_num_swb_1024[] = {
     41, 41, 47, 49, 49, 51, 47, 47, 43, 43, 43, 40, 40
 };
 
+const uint8_t ff_aac_num_swb_960[] = {
+    40, 40, 46, 49, 49, 49, 46, 46, 42, 42, 42, 40, 40
+};
+
 const uint8_t ff_aac_num_swb_512[] = {
      0,  0,  0, 36, 36, 37, 31, 31,  0,  0,  0,  0,  0
 };
@@ -56,6 +62,10 @@ const uint8_t ff_aac_num_swb_128[] = {
     12, 12, 12, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15
 };
 
+const uint8_t ff_aac_num_swb_120[] = {
+    12, 12, 12, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15
+};
+
 const uint8_t ff_aac_pred_sfb_max[] = {
     33, 33, 38, 40, 40, 40, 41, 41, 37, 37, 37, 34, 34
 };
@@ -1229,6 +1239,100 @@ static const uint16_t swb_offset_128_8[] = {
     36,  44,  52,  60,  72,  88, 108, 128
 };
 
+static const uint16_t swb_offset_960_96[] =
+{
+    0,   4,   8,   12,  16,  20,  24,  28,  32,  36,
+    40,  44,  48,  52,  56,  64,  72,  80,  88,  96,
+    108, 120, 132, 144, 156, 172, 188, 212, 240, 276,
+    320, 384, 448, 512, 576, 640, 704, 768, 832, 896,
+    960
+};
+
+static const uint16_t swb_offset_960_64[] =
+{
+    0,   4,   8,   12,  16,  20,  24,  28,  32,  36,
+    40,  44,  48,  52,  56,  64,  72,  80,  88,  100,
+    112, 124, 140, 156, 172, 192, 216, 240, 268, 304,
+    344, 384, 424, 464, 504, 544, 584, 624, 664, 704,
+    744, 784, 824, 864, 904, 944, 960
+};
+
+static const uint16_t swb_offset_960_48[] =
+{
+    0,   4,   8,   12,  16,  20,  24,  28,  32,  36,
+    40,  48,  56,  64,  72,  80,  88,  96,  108, 120,
+    132, 144, 160, 176, 196, 216, 240, 264, 292, 320,
+    352, 384, 416, 448, 480, 512, 544, 576, 608, 640,
+    672, 704, 736, 768, 800, 832, 864, 896, 928, 960
+};
+
+static const uint16_t swb_offset_960_32[] =
+{
+    0,   4,   8,   12,  16,  20,  24,  28,  32,  36,
+    40,  48,  56,  64,  72,  80,  88,  96,  108, 120,
+    132, 144, 160, 176, 196, 216, 240, 264, 292, 320,
+    352, 384, 416, 448, 480, 512, 544, 576, 608, 640,
+    672, 704, 736, 768, 800, 832, 864, 896, 928, 960
+};
+
+static const uint16_t swb_offset_960_24[] =
+{
+    0,   4,   8,   12,  16,  20,  24,  28,  32,  36,
+    40,  44,  52,  60,  68,  76,  84,  92,  100, 108,
+    116, 124, 136, 148, 160, 172, 188, 204, 220, 240,
+    260, 284, 308, 336, 364, 396, 432, 468, 508, 552,
+    600, 652, 704, 768, 832, 896, 960
+};
+
+static const uint16_t swb_offset_960_16[] =
+{
+    0,   8,   16,  24,  32,  40,  48,  56,  64,  72,
+    80,  88,  100, 112, 124, 136, 148, 160, 172, 184,
+    196, 212, 228, 244, 260, 280, 300, 320, 344, 368,
+    396, 424, 456, 492, 532, 572, 616, 664, 716, 772,
+    832, 896, 960
+};
+
+static const uint16_t swb_offset_960_8[] =
+{
+    0,   12,  24,  36,  48,  60,  72,  84,  96,  108,
+    120, 132, 144, 156, 172, 188, 204, 220, 236, 252,
+    268, 288, 308, 328, 348, 372, 396, 420, 448, 476,
+    508, 544, 580, 620, 664, 712, 764, 820, 880, 944,
+    960
+};
+
+
+static const uint16_t swb_offset_120_96[] =
+{
+    0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 120
+};
+
+static const uint16_t swb_offset_120_64[] =
+{
+    0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 120
+};
+
+static const uint16_t swb_offset_120_48[] =
+{
+    0,  4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 120
+};
+
+static const uint16_t swb_offset_120_24[] =
+{
+    0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 120
+};
+
+static const uint16_t swb_offset_120_16[] =
+{
+    0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 120
+};
+
+static const uint16_t swb_offset_120_8[] =
+{
+    0, 4, 8, 12, 16,  20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 120
+};
+
 const uint16_t * const ff_swb_offset_1024[] = {
     swb_offset_1024_96, swb_offset_1024_96, swb_offset_1024_64,
     swb_offset_1024_48, swb_offset_1024_48, swb_offset_1024_32,
@@ -1237,6 +1341,14 @@ const uint16_t * const ff_swb_offset_1024[] = {
     swb_offset_1024_8
 };
 
+const uint16_t * const ff_swb_offset_960[] = {
+    swb_offset_960_96, swb_offset_960_96, swb_offset_960_64,
+    swb_offset_960_48, swb_offset_960_48, swb_offset_960_32,
+    swb_offset_960_24, swb_offset_960_24, swb_offset_960_16,
+    swb_offset_960_16, swb_offset_960_16, swb_offset_960_8,
+    swb_offset_960_8
+};
+
 const uint16_t * const ff_swb_offset_512[] = {
     NULL,               NULL,               NULL,
     swb_offset_512_48,  swb_offset_512_48,  swb_offset_512_32,
@@ -1263,6 +1375,14 @@ const uint16_t * const ff_swb_offset_128[] = {
     swb_offset_128_8
 };
 
+const uint16_t * const ff_swb_offset_120[] = {
+    swb_offset_120_96, swb_offset_120_96, swb_offset_120_96,
+    swb_offset_120_48, swb_offset_120_48, swb_offset_120_48,
+    swb_offset_120_24, swb_offset_120_24, swb_offset_120_16,
+    swb_offset_120_16, swb_offset_120_16, swb_offset_120_8,
+    swb_offset_120_8
+};
+
 // @}
 
 /* @name ff_tns_max_bands
diff --git a/mythtv/external/FFmpeg/libavcodec/aactab.h b/mythtv/external/FFmpeg/libavcodec/aactab.h
index a0d44a2dadd..7cd81282317 100644
--- a/mythtv/external/FFmpeg/libavcodec/aactab.h
+++ b/mythtv/external/FFmpeg/libavcodec/aactab.h
@@ -136,22 +136,26 @@ static const INTFLOAT * const tns_tmp2_map[4] = {
  */
 DECLARE_ALIGNED(32, extern float,  ff_aac_kbd_long_1024)[1024];
 DECLARE_ALIGNED(32, extern float,  ff_aac_kbd_short_128)[128];
+DECLARE_ALIGNED(32, extern float,  ff_aac_kbd_long_960)[960];
+DECLARE_ALIGNED(32, extern float,  ff_aac_kbd_short_120)[120];
 DECLARE_ALIGNED(32, extern int,    ff_aac_kbd_long_1024_fixed)[1024];
 DECLARE_ALIGNED(32, extern int,    ff_aac_kbd_long_512_fixed)[512];
 DECLARE_ALIGNED(32, extern int,    ff_aac_kbd_short_128_fixed)[128];
-const DECLARE_ALIGNED(32, extern float, ff_aac_eld_window_512)[1920];
-const DECLARE_ALIGNED(32, extern int,   ff_aac_eld_window_512_fixed)[1920];
-const DECLARE_ALIGNED(32, extern float, ff_aac_eld_window_480)[1800];
-const DECLARE_ALIGNED(32, extern int,   ff_aac_eld_window_480_fixed)[1800];
+DECLARE_ALIGNED(32, extern const float, ff_aac_eld_window_512)[1920];
+DECLARE_ALIGNED(32, extern const int,   ff_aac_eld_window_512_fixed)[1920];
+DECLARE_ALIGNED(32, extern const float, ff_aac_eld_window_480)[1800];
+DECLARE_ALIGNED(32, extern const int,   ff_aac_eld_window_480_fixed)[1800];
 // @}
 
 /* @name number of scalefactor window bands for long and short transform windows respectively
  * @{
  */
 extern const uint8_t ff_aac_num_swb_1024[];
+extern const uint8_t ff_aac_num_swb_960 [];
 extern const uint8_t ff_aac_num_swb_512 [];
 extern const uint8_t ff_aac_num_swb_480 [];
 extern const uint8_t ff_aac_num_swb_128 [];
+extern const uint8_t ff_aac_num_swb_120 [];
 // @}
 
 extern const uint8_t ff_aac_pred_sfb_max [];
@@ -168,9 +172,11 @@ extern const float *ff_aac_codebook_vector_vals[];
 extern const uint16_t *ff_aac_codebook_vector_idx[];
 
 extern const uint16_t * const ff_swb_offset_1024[13];
+extern const uint16_t * const ff_swb_offset_960 [13];
 extern const uint16_t * const ff_swb_offset_512 [13];
 extern const uint16_t * const ff_swb_offset_480 [13];
 extern const uint16_t * const ff_swb_offset_128 [13];
+extern const uint16_t * const ff_swb_offset_120 [13];
 
 extern const uint8_t ff_tns_max_bands_1024[13];
 extern const uint8_t ff_tns_max_bands_512 [13];
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/Makefile b/mythtv/external/FFmpeg/libavcodec/aarch64/Makefile
index c3df8871082..72080c2dbb1 100644
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/Makefile
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/Makefile
@@ -6,16 +6,20 @@ OBJS-$(CONFIG_H264DSP)                  += aarch64/h264dsp_init_aarch64.o
 OBJS-$(CONFIG_H264PRED)                 += aarch64/h264pred_init.o
 OBJS-$(CONFIG_H264QPEL)                 += aarch64/h264qpel_init_aarch64.o
 OBJS-$(CONFIG_HPELDSP)                  += aarch64/hpeldsp_init_aarch64.o
-OBJS-$(CONFIG_IMDCT15)                  += aarch64/imdct15_init.o
 OBJS-$(CONFIG_MPEGAUDIODSP)             += aarch64/mpegaudiodsp_init.o
 OBJS-$(CONFIG_NEON_CLOBBER_TEST)        += aarch64/neontest.o
 OBJS-$(CONFIG_VIDEODSP)                 += aarch64/videodsp_init.o
 
 # decoders/encoders
+OBJS-$(CONFIG_AAC_DECODER)              += aarch64/aacpsdsp_init_aarch64.o \
+                                           aarch64/sbrdsp_init_aarch64.o
 OBJS-$(CONFIG_DCA_DECODER)              += aarch64/synth_filter_init.o
 OBJS-$(CONFIG_RV40_DECODER)             += aarch64/rv40dsp_init_aarch64.o
 OBJS-$(CONFIG_VC1DSP)                   += aarch64/vc1dsp_init_aarch64.o
 OBJS-$(CONFIG_VORBIS_DECODER)           += aarch64/vorbisdsp_init.o
+OBJS-$(CONFIG_VP9_DECODER)              += aarch64/vp9dsp_init_10bpp_aarch64.o \
+                                           aarch64/vp9dsp_init_12bpp_aarch64.o \
+                                           aarch64/vp9dsp_init_aarch64.o
 
 # ARMv8 optimizations
 
@@ -25,6 +29,7 @@ ARMV8-OBJS-$(CONFIG_VIDEODSP)           += aarch64/videodsp.o
 # NEON optimizations
 
 # subsystems
+NEON-OBJS-$(CONFIG_AAC_DECODER)         += aarch64/sbrdsp_neon.o
 NEON-OBJS-$(CONFIG_FFT)                 += aarch64/fft_neon.o
 NEON-OBJS-$(CONFIG_FMTCONVERT)          += aarch64/fmtconvert_neon.o
 NEON-OBJS-$(CONFIG_H264CHROMA)          += aarch64/h264cmc_neon.o
@@ -34,10 +39,18 @@ NEON-OBJS-$(CONFIG_H264PRED)            += aarch64/h264pred_neon.o
 NEON-OBJS-$(CONFIG_H264QPEL)            += aarch64/h264qpel_neon.o             \
                                            aarch64/hpeldsp_neon.o
 NEON-OBJS-$(CONFIG_HPELDSP)             += aarch64/hpeldsp_neon.o
-NEON-OBJS-$(CONFIG_IMDCT15)             += aarch64/imdct15_neon.o
+NEON-OBJS-$(CONFIG_IDCTDSP)             += aarch64/idctdsp_init_aarch64.o      \
+                                           aarch64/simple_idct_neon.o
 NEON-OBJS-$(CONFIG_MDCT)                += aarch64/mdct_neon.o
 NEON-OBJS-$(CONFIG_MPEGAUDIODSP)        += aarch64/mpegaudiodsp_neon.o
 
 # decoders/encoders
+NEON-OBJS-$(CONFIG_AAC_DECODER)         += aarch64/aacpsdsp_neon.o
 NEON-OBJS-$(CONFIG_DCA_DECODER)         += aarch64/synth_filter_neon.o
 NEON-OBJS-$(CONFIG_VORBIS_DECODER)      += aarch64/vorbisdsp_neon.o
+NEON-OBJS-$(CONFIG_VP9_DECODER)         += aarch64/vp9itxfm_16bpp_neon.o       \
+                                           aarch64/vp9itxfm_neon.o             \
+                                           aarch64/vp9lpf_16bpp_neon.o         \
+                                           aarch64/vp9lpf_neon.o               \
+                                           aarch64/vp9mc_16bpp_neon.o          \
+                                           aarch64/vp9mc_neon.o
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/aacpsdsp_init_aarch64.c b/mythtv/external/FFmpeg/libavcodec/aarch64/aacpsdsp_init_aarch64.c
new file mode 100644
index 00000000000..5e7e19bba47
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/aacpsdsp_init_aarch64.c
@@ -0,0 +1,48 @@
+/*
+ * 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/aarch64/cpu.h"
+#include "libavcodec/aacpsdsp.h"
+
+void ff_ps_add_squares_neon(float *dst, const float (*src)[2], int n);
+void ff_ps_mul_pair_single_neon(float (*dst)[2], float (*src0)[2],
+                                float *src1, int n);
+void ff_ps_hybrid_analysis_neon(float (*out)[2], float (*in)[2],
+                                const float (*filter)[8][2],
+                                ptrdiff_t stride, int n);
+void ff_ps_stereo_interpolate_neon(float (*l)[2], float (*r)[2],
+                                   float h[2][4], float h_step[2][4],
+                                   int len);
+void ff_ps_stereo_interpolate_ipdopd_neon(float (*l)[2], float (*r)[2],
+                                          float h[2][4], float h_step[2][4],
+                                          int len);
+
+av_cold void ff_psdsp_init_aarch64(PSDSPContext *s)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+        s->add_squares           = ff_ps_add_squares_neon;
+        s->mul_pair_single       = ff_ps_mul_pair_single_neon;
+        s->hybrid_analysis       = ff_ps_hybrid_analysis_neon;
+        s->stereo_interpolate[0] = ff_ps_stereo_interpolate_neon;
+        s->stereo_interpolate[1] = ff_ps_stereo_interpolate_ipdopd_neon;
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/aacpsdsp_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/aacpsdsp_neon.S
new file mode 100644
index 00000000000..ff4e6e244a4
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/aacpsdsp_neon.S
@@ -0,0 +1,148 @@
+/*
+ * 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/aarch64/asm.S"
+
+function ff_ps_add_squares_neon, export=1
+1:      ld1         {v0.4S,v1.4S}, [x1], #32
+        fmul        v0.4S, v0.4S, v0.4S
+        fmul        v1.4S, v1.4S, v1.4S
+        faddp       v2.4S, v0.4S, v1.4S
+        ld1         {v3.4S}, [x0]
+        fadd        v3.4S, v3.4S, v2.4S
+        st1         {v3.4S}, [x0], #16
+        subs        w2, w2, #4
+        b.gt        1b
+        ret
+endfunc
+
+function ff_ps_mul_pair_single_neon, export=1
+1:      ld1         {v0.4S,v1.4S}, [x1], #32
+        ld1         {v2.4S},       [x2], #16
+        zip1        v3.4S, v2.4S, v2.4S
+        zip2        v4.4S, v2.4S, v2.4S
+        fmul        v0.4S, v0.4S, v3.4S
+        fmul        v1.4S, v1.4S, v4.4S
+        st1         {v0.4S,v1.4S}, [x0], #32
+        subs        w3, w3, #4
+        b.gt        1b
+        ret
+endfunc
+
+function ff_ps_stereo_interpolate_neon, export=1
+        ld1         {v0.4S}, [x2]
+        ld1         {v1.4S}, [x3]
+        zip1        v4.4S, v0.4S, v0.4S
+        zip2        v5.4S, v0.4S, v0.4S
+        zip1        v6.4S, v1.4S, v1.4S
+        zip2        v7.4S, v1.4S, v1.4S
+1:      ld1         {v2.2S}, [x0]
+        ld1         {v3.2S}, [x1]
+        fadd        v4.4S, v4.4S, v6.4S
+        fadd        v5.4S, v5.4S, v7.4S
+        mov         v2.D[1], v2.D[0]
+        mov         v3.D[1], v3.D[0]
+        fmul        v2.4S, v2.4S, v4.4S
+        fmla        v2.4S, v3.4S, v5.4S
+        st1         {v2.D}[0], [x0], #8
+        st1         {v2.D}[1], [x1], #8
+        subs        w4, w4, #1
+        b.gt        1b
+        ret
+endfunc
+
+function ff_ps_stereo_interpolate_ipdopd_neon, export=1
+        ld1         {v0.4S,v1.4S}, [x2]
+        ld1         {v6.4S,v7.4S}, [x3]
+        fneg        v2.4S, v1.4S
+        fneg        v3.4S, v7.4S
+        zip1        v16.4S, v0.4S, v0.4S
+        zip2        v17.4S, v0.4S, v0.4S
+        zip1        v18.4S, v2.4S, v1.4S
+        zip2        v19.4S, v2.4S, v1.4S
+        zip1        v20.4S, v6.4S, v6.4S
+        zip2        v21.4S, v6.4S, v6.4S
+        zip1        v22.4S, v3.4S, v7.4S
+        zip2        v23.4S, v3.4S, v7.4S
+1:      ld1         {v2.2S}, [x0]
+        ld1         {v3.2S}, [x1]
+        fadd        v16.4S, v16.4S, v20.4S
+        fadd        v17.4S, v17.4S, v21.4S
+        mov         v2.D[1], v2.D[0]
+        mov         v3.D[1], v3.D[0]
+        fmul        v4.4S, v2.4S, v16.4S
+        fmla        v4.4S, v3.4S, v17.4S
+        fadd        v18.4S, v18.4S, v22.4S
+        fadd        v19.4S, v19.4S, v23.4S
+        ext         v2.16B, v2.16B, v2.16B, #4
+        ext         v3.16B, v3.16B, v3.16B, #4
+        fmla        v4.4S, v2.4S, v18.4S
+        fmla        v4.4S, v3.4S, v19.4S
+        st1         {v4.D}[0], [x0], #8
+        st1         {v4.D}[1], [x1], #8
+        subs        w4, w4, #1
+        b.gt        1b
+        ret
+endfunc
+
+function ff_ps_hybrid_analysis_neon, export=1
+        lsl         x3, x3, #3
+        ld2         {v0.4S,v1.4S}, [x1], #32
+        ld2         {v2.2S,v3.2S}, [x1], #16
+        ld1         {v24.2S},      [x1], #8
+        ld2         {v4.2S,v5.2S}, [x1], #16
+        ld2         {v6.4S,v7.4S}, [x1]
+        rev64       v6.4S, v6.4S
+        rev64       v7.4S, v7.4S
+        ext         v6.16B, v6.16B, v6.16B, #8
+        ext         v7.16B, v7.16B, v7.16B, #8
+        rev64       v4.2S, v4.2S
+        rev64       v5.2S, v5.2S
+        mov         v2.D[1], v3.D[0]
+        mov         v4.D[1], v5.D[0]
+        mov         v5.D[1], v2.D[0]
+        mov         v3.D[1], v4.D[0]
+        fadd        v16.4S, v0.4S, v6.4S
+        fadd        v17.4S, v1.4S, v7.4S
+        fsub        v18.4S, v1.4S, v7.4S
+        fsub        v19.4S, v0.4S, v6.4S
+        fadd        v22.4S, v2.4S, v4.4S
+        fsub        v23.4S, v5.4S, v3.4S
+        trn1        v20.2D, v22.2D, v23.2D      // {re4+re8, re5+re7, im8-im4, im7-im5}
+        trn2        v21.2D, v22.2D, v23.2D      // {im4+im8, im5+im7, re4-re8, re5-re7}
+1:      ld2         {v2.4S,v3.4S}, [x2], #32
+        ld2         {v4.2S,v5.2S}, [x2], #16
+        ld1         {v6.2S},       [x2], #8
+        add         x2, x2, #8
+        mov         v4.D[1], v5.D[0]
+        mov         v6.S[1], v6.S[0]
+        fmul        v6.2S, v6.2S, v24.2S
+        fmul        v0.4S, v2.4S, v16.4S
+        fmul        v1.4S, v2.4S, v17.4S
+        fmls        v0.4S, v3.4S, v18.4S
+        fmla        v1.4S, v3.4S, v19.4S
+        fmla        v0.4S, v4.4S, v20.4S
+        fmla        v1.4S, v4.4S, v21.4S
+        faddp       v0.4S, v0.4S, v1.4S
+        faddp       v0.4S, v0.4S, v0.4S
+        fadd        v0.2S, v0.2S, v6.2S
+        st1         {v0.2S}, [x0], x3
+        subs        w4, w4, #1
+        b.gt        1b
+        ret
+endfunc
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/h264chroma_init_aarch64.c b/mythtv/external/FFmpeg/libavcodec/aarch64/h264chroma_init_aarch64.c
index 2af62becf7c..fa6e0eaf15e 100644
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/h264chroma_init_aarch64.c
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/h264chroma_init_aarch64.c
@@ -28,18 +28,18 @@
 
 #include "config.h"
 
-void ff_put_h264_chroma_mc8_neon(uint8_t *dst, uint8_t *src, int stride,
+void ff_put_h264_chroma_mc8_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                  int h, int x, int y);
-void ff_put_h264_chroma_mc4_neon(uint8_t *dst, uint8_t *src, int stride,
+void ff_put_h264_chroma_mc4_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                  int h, int x, int y);
-void ff_put_h264_chroma_mc2_neon(uint8_t *dst, uint8_t *src, int stride,
+void ff_put_h264_chroma_mc2_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                  int h, int x, int y);
 
-void ff_avg_h264_chroma_mc8_neon(uint8_t *dst, uint8_t *src, int stride,
+void ff_avg_h264_chroma_mc8_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                  int h, int x, int y);
-void ff_avg_h264_chroma_mc4_neon(uint8_t *dst, uint8_t *src, int stride,
+void ff_avg_h264_chroma_mc4_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                  int h, int x, int y);
-void ff_avg_h264_chroma_mc2_neon(uint8_t *dst, uint8_t *src, int stride,
+void ff_avg_h264_chroma_mc2_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                  int h, int x, int y);
 
 av_cold void ff_h264chroma_init_aarch64(H264ChromaContext *c, int bit_depth)
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/h264cmc_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/h264cmc_neon.S
index ff97a29df13..8be75780011 100644
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/h264cmc_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/h264cmc_neon.S
@@ -21,10 +21,9 @@
 
 #include "libavutil/aarch64/asm.S"
 
-/* chroma_mc8(uint8_t *dst, uint8_t *src, int stride, int h, int x, int y) */
+/* chroma_mc8(uint8_t *dst, uint8_t *src, ptrdiff_t stride, int h, int x, int y) */
 .macro  h264_chroma_mc8 type, codec=h264
 function ff_\type\()_\codec\()_chroma_mc8_neon, export=1
-        sxtw            x2,  w2
   .ifc \type,avg
         mov             x8,  x0
   .endif
@@ -192,10 +191,9 @@ function ff_\type\()_\codec\()_chroma_mc8_neon, export=1
 endfunc
 .endm
 
-/* chroma_mc4(uint8_t *dst, uint8_t *src, int stride, int h, int x, int y) */
+/* chroma_mc4(uint8_t *dst, uint8_t *src, ptrdiff_t stride, int h, int x, int y) */
 .macro  h264_chroma_mc4 type, codec=h264
 function ff_\type\()_\codec\()_chroma_mc4_neon, export=1
-        sxtw            x2,  w2
   .ifc \type,avg
         mov             x8,  x0
   .endif
@@ -359,7 +357,6 @@ endfunc
 
 .macro  h264_chroma_mc2 type
 function ff_\type\()_h264_chroma_mc2_neon, export=1
-        sxtw            x2,  w2
         prfm            pldl1strm, [x1]
         prfm            pldl1strm, [x1, x2]
         orr             w7,  w4,  w5
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/h264idct_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/h264idct_neon.S
index fa414f73b2a..825ec49f8c6 100644
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/h264idct_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/h264idct_neon.S
@@ -162,7 +162,7 @@ function ff_h264_idct_add8_neon, export=1
         mov             w19, w3                 // stride
         movrel          x13, X(ff_h264_idct_dc_add_neon)
         movrel          x14, X(ff_h264_idct_add_neon)
-        movrel          x7,  scan8+16
+        movrel          x7,  scan8, 16
         mov             x10, #0
         mov             x11, #16
 1:      mov             w2,  w19
@@ -264,6 +264,7 @@ endfunc
 
 function ff_h264_idct8_add_neon, export=1
         movi            v19.8H,   #0
+        sxtw            x2,       w2
         ld1             {v24.8H, v25.8H}, [x1]
         st1             {v19.8H},  [x1],   #16
         st1             {v19.8H},  [x1],   #16
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/idct.h b/mythtv/external/FFmpeg/libavcodec/aarch64/idct.h
new file mode 100644
index 00000000000..5c49046148b
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/idct.h
@@ -0,0 +1,28 @@
+/*
+ * 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_AARCH64_IDCT_H
+#define AVCODEC_AARCH64_IDCT_H
+
+#include <stdint.h>
+
+void ff_simple_idct_neon(int16_t *data);
+void ff_simple_idct_put_neon(uint8_t *dest, ptrdiff_t line_size, int16_t *data);
+void ff_simple_idct_add_neon(uint8_t *dest, ptrdiff_t line_size, int16_t *data);
+
+#endif /* AVCODEC_AARCH64_IDCT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/idctdsp_init_aarch64.c b/mythtv/external/FFmpeg/libavcodec/aarch64/idctdsp_init_aarch64.c
new file mode 100644
index 00000000000..0406e608304
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/idctdsp_init_aarch64.c
@@ -0,0 +1,41 @@
+/*
+ * ARM-NEON-optimized IDCT functions
+ * Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
+ * Copyright (c) 2017 Matthieu Bouron <matthieu.bouron@gmail.com>
+ *
+ * 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/avcodec.h"
+#include "libavcodec/idctdsp.h"
+#include "idct.h"
+
+av_cold void ff_idctdsp_init_aarch64(IDCTDSPContext *c, AVCodecContext *avctx,
+                                     unsigned high_bit_depth)
+{
+    if (!avctx->lowres && !high_bit_depth) {
+        if (avctx->idct_algo == FF_IDCT_AUTO ||
+            avctx->idct_algo == FF_IDCT_SIMPLEAUTO ||
+            avctx->idct_algo == FF_IDCT_SIMPLENEON) {
+            c->idct_put  = ff_simple_idct_put_neon;
+            c->idct_add  = ff_simple_idct_add_neon;
+            c->idct      = ff_simple_idct_neon;
+            c->perm_type = FF_IDCT_PERM_PARTTRANS;
+        }
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/imdct15_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/imdct15_neon.S
deleted file mode 100644
index 97e1442ccc2..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/imdct15_neon.S
+++ /dev/null
@@ -1,647 +0,0 @@
-/*
- * Copyright (c) 2014 Janne Grunau <janne-libav@jannau.net>
- *
- * 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/aarch64/asm.S"
-
-#include "asm-offsets.h"
-
-.macro shuffle a, b, c, d
-const shuffle_\a\b\c\d, align=4
-        .byte (\a * 4), (\a * 4 + 1), (\a * 4 + 2), (\a * 4 + 3)
-        .byte (\b * 4), (\b * 4 + 1), (\b * 4 + 2), (\b * 4 + 3)
-        .byte (\c * 4), (\c * 4 + 1), (\c * 4 + 2), (\c * 4 + 3)
-        .byte (\d * 4), (\d * 4 + 1), (\d * 4 + 2), (\d * 4 + 3)
-endconst
-.endm
-
-shuffle 0, 2, 1, 3
-shuffle 1, 0, 3, 2
-shuffle 2, 3, 0, 1
-shuffle 3, 1, 2, 0
-
-
-function fft5_neon
-        lsl             x2,  x2,  #3
-        ld1             {v24.2s},         [x1],  x2
-        ld2             {v25.s,v26.s}[0], [x1],  x2
-        ld2             {v25.s,v26.s}[1], [x1],  x2
-        ld2             {v25.s,v26.s}[2], [x1],  x2
-        ld2             {v25.s,v26.s}[3], [x1]
-        dup             v6.4s,  v24.s[0]
-        dup             v7.4s,  v24.s[1]
-
-        faddp           v0.4s,  v25.4s, v26.4s
-        // z[][0], z[][3]
-        fmul            v16.4s, v25.4s, v15.s[0] // rr
-        fmul            v17.4s, v25.4s, v15.s[1] // ri
-        fmul            v18.4s, v26.4s, v15.s[0] // ir
-        fmul            v19.4s, v26.4s, v15.s[1] // ii
-        faddp           v0.4s,  v0.4s,  v0.4s
-        // z[][1], z[][2]
-        fmul            v20.4s, v25.4s, v15.s[2] // rr
-        fmul            v21.4s, v25.4s, v15.s[3] // ri
-        fmul            v22.4s, v26.4s, v15.s[2] // ir
-        fmul            v23.4s, v26.4s, v15.s[3] // ii
-        fadd            v0.2s,  v24.2s, v0.2s   // out[0]
-
-        // z[0123][0], z[0123][3]
-        fsub            v24.4s, v16.4s, v19.4s  //    (c).re =  rr - ii;
-        fadd            v27.4s, v16.4s, v19.4s  //    (d).re =  rr + ii;
-        ld1             {v16.16b},  [x11]
-        ld1             {v19.16b},  [x14]
-        fadd            v28.4s, v17.4s, v18.4s  //    (c).im =  ri + ir;
-        fsub            v31.4s, v18.4s, v17.4s  //    (d).im = -ri + ir;
-        ld1             {v17.16b},  [x12]
-        // z[0123][1], z[0123][2]
-        fsub            v25.4s, v20.4s, v23.4s  //    (c).re =  rr - ii;
-        fadd            v26.4s, v20.4s, v23.4s  //    (d).re =  rr + ii;
-        ld1             {v18.16b},  [x13]
-        fadd            v29.4s, v21.4s, v22.4s  //    (c).im =  ri + ir;
-        fsub            v30.4s, v22.4s, v21.4s  //    (d).im = -ri + ir;
-
-        //real
-        tbl             v20.16b, {v24.16b}, v16.16b
-        tbl             v21.16b, {v25.16b}, v17.16b
-        tbl             v22.16b, {v26.16b}, v18.16b
-        tbl             v23.16b, {v27.16b}, v19.16b
-        //imag
-        tbl             v16.16b, {v28.16b}, v16.16b
-        tbl             v17.16b, {v29.16b}, v17.16b
-        tbl             v18.16b, {v30.16b}, v18.16b
-        tbl             v19.16b, {v31.16b}, v19.16b
-
-        fadd            v6.4s,  v6.4s,  v20.4s
-        fadd            v22.4s, v22.4s, v23.4s
-        fadd            v7.4s,  v7.4s,  v16.4s
-        fadd            v18.4s, v18.4s, v19.4s
-
-        fadd            v21.4s, v21.4s, v22.4s
-        fadd            v17.4s, v17.4s, v18.4s
-        fadd            v6.4s,  v6.4s,  v21.4s
-        fadd            v7.4s,  v7.4s,  v17.4s
-
-        ret
-endfunc
-
-function fft15_neon
-        mov             x8,  x1
-        mov             x9,  x30
-        add             x2,  x3,  x3,  lsl #1   // 3 * stride
-
-        add             x1,  x8,  x3,  lsl #3   // in + 1 * stride
-        bl              fft5_neon
-        mov             v1.8b,   v0.8b
-        mov             v2.16b,  v6.16b
-        mov             v3.16b,  v7.16b
-
-        add             x1,  x8,  x3,  lsl #4   // in + 2 * stride
-        add             x2,  x3,  x3,  lsl #1   // 3 * stride
-        bl              fft5_neon
-        zip1            v1.4s,   v1.4s,  v0.4s
-        mov             v4.16b,  v6.16b
-        mov             v5.16b,  v7.16b
-
-        mov             x1,  x8                 // in + 0 * stride
-        add             x2,  x3,  x3,  lsl #1   // 3 * stride
-        bl              fft5_neon
-
-        faddp           v20.4s, v1.4s,  v1.4s
-
-        ext             v18.16b, v8.16b,  v8.16b,  #4
-        ext             v19.16b, v9.16b,  v9.16b,  #4
-        mov             v16.16b, v6.16b
-        mov             v17.16b, v7.16b
-        fadd            v20.2s, v20.2s, v0.2s
-
-        uzp1            v18.4s, v18.4s, v10.4s  // exp[2,4,6,8].re
-        uzp1            v19.4s, v19.4s, v11.4s  // exp[2,4,6,8].im
-
-        st1             {v20.2s},  [x0], #8     // out[0]
-
-        fmla            v16.4s, v2.4s,  v8.4s
-        fmls            v16.4s, v3.4s,  v9.4s
-
-        fmla            v17.4s, v2.4s,  v9.4s
-        fmla            v17.4s, v3.4s,  v8.4s
-
-        fmla            v16.4s, v4.4s,  v18.4s
-        fmls            v16.4s, v5.4s,  v19.4s
-
-        fmla            v17.4s, v4.4s,  v19.4s
-        fmla            v17.4s, v5.4s,  v18.4s
-
-        zip1            v18.4s, v16.4s, v17.4s
-        zip2            v19.4s, v16.4s, v17.4s
-
-        rev64           v31.4s, v14.4s
-        trn1            v28.2d, v1.2d,  v1.2d
-        trn2            v29.2d, v1.2d,  v1.2d
-        zip1            v30.2d, v14.2d, v31.2d
-        zip2            v31.2d, v14.2d, v31.2d
-
-        st1             {v18.4s,v19.4s},  [x0], #32 // out[1-4]
-
-        fmul            v16.4s, v28.4s, v30.4s
-        fmul            v17.4s, v29.4s, v30.4s
-        fmls            v16.4s, v29.4s, v31.4s
-        fmla            v17.4s, v28.4s, v31.4s
-        faddp           v16.4s, v16.4s, v16.4s
-        faddp           v17.4s, v17.4s, v17.4s
-        zip1            v18.2s, v16.2s, v17.2s
-        zip2            v19.2s, v16.2s, v17.2s
-
-        fadd            v18.2s, v18.2s, v0.2s
-        fadd            v0.2s,  v19.2s, v0.2s
-
-        ext             v30.16b, v12.16b, v12.16b, #4
-        ext             v31.16b, v13.16b, v13.16b, #4
-        mov             v16.16b, v6.16b
-        mov             v17.16b, v7.16b
-
-        uzp1            v30.4s, v30.4s, v8.4s
-        uzp1            v31.4s, v31.4s, v9.4s
-
-        st1             {v18.2s},  [x0], #8     // out[5]
-
-        fmla            v16.4s, v2.4s,  v10.4s
-        fmls            v16.4s, v3.4s,  v11.4s
-
-        fmla            v17.4s, v2.4s,  v11.4s
-        fmla            v17.4s, v3.4s,  v10.4s
-
-        fmla            v16.4s, v4.4s,  v30.4s
-        fmls            v16.4s, v5.4s,  v31.4s
-
-        fmla            v17.4s, v4.4s,  v31.4s
-        fmla            v17.4s, v5.4s,  v30.4s
-
-        zip1            v18.4s, v16.4s, v17.4s
-        zip2            v19.4s, v16.4s, v17.4s
-
-        ext             v30.16b, v10.16b, v10.16b, #4
-        ext             v31.16b, v11.16b, v11.16b, #4
-
-        fmla            v6.4s,  v2.4s,  v12.4s
-        fmls            v6.4s,  v3.4s,  v13.4s
-
-        st1             {v18.4s,v19.4s},  [x0], #32 // out[6-9]
-
-        uzp1            v30.4s, v30.4s, v12.4s
-        uzp1            v31.4s, v31.4s, v13.4s
-
-        fmla            v7.4s,  v2.4s,  v13.4s
-        fmla            v7.4s,  v3.4s,  v12.4s
-
-        st1             {v0.2s},  [x0], #8     // out[10]
-
-        fmla            v6.4s,  v4.4s,  v30.4s
-        fmls            v6.4s,  v5.4s,  v31.4s
-
-        fmla            v7.4s,  v4.4s,  v31.4s
-        fmla            v7.4s,  v5.4s,  v30.4s
-
-        zip1            v18.4s, v6.4s,  v7.4s
-        zip2            v19.4s, v6.4s,  v7.4s
-
-        st1             {v18.4s,v19.4s},  [x0], #32 // out[11-14]
-
-        ret             x9
-endfunc
-
-// x0: out, x1: out+len2, x2: exptab, x3: len2
-function fft15_pass
-        ands            x6,  x3,  #3
-        mov             x4,  x0
-        mov             x5,  x1
-        b.eq            9f
-        ld1             {v0.2s},  [x0], #8
-        ld1             {v1.2s},  [x1], #8
-        sub             x3,  x3,  x6
-        subs            x6,  x6,  #1
-        fadd            v2.2s,  v0.2s,  v1.2s
-        fsub            v3.2s,  v0.2s,  v1.2s
-        add             x2,  x2,  #8
-        st1             {v2.2s},  [x4], #8
-        st1             {v3.2s},  [x5], #8
-        b.eq            9f
-1:
-        subs            x6,  x6,  #1
-        ldp             s4,  s5,  [x2], #8
-        ldp             s2,  s3,  [x1], #8
-        ldp             s0,  s1,  [x0], #8
-
-        fmul            s6,  s2,  s4
-        fmul            s7,  s2,  s5
-        fmls            s6,  s3,  v5.s[0]
-        fmla            s7,  s3,  v4.s[0]
-
-        fsub            s2,  s0,  s6
-        fsub            s3,  s1,  s7
-        fadd            s0,  s0,  s6
-        fadd            s1,  s1,  s7
-
-        stp             s2,  s3,  [x5], #8
-        stp             s0,  s1,  [x4], #8
-        b.gt            1b
-9:
-        ld1             {v4.4s,v5.4s}, [x2],  #32
-        ld2             {v2.4s,v3.4s}, [x1],  #32
-        uzp1            v6.4s,  v4.4s,  v5.4s
-        uzp2            v7.4s,  v4.4s,  v5.4s
-        ld2             {v0.4s,v1.4s}, [x0],  #32
-8:
-        subs            x3,  x3,  #8
-
-        fmul            v4.4s,  v2.4s,  v6.4s
-        fmul            v5.4s,  v2.4s,  v7.4s
-        b.lt            4f
-
-        ld1             {v18.4s,v19.4s}, [x2],  #32
-
-        fmls            v4.4s,  v3.4s,  v7.4s
-        fmla            v5.4s,  v3.4s,  v6.4s
-
-        ld2             {v22.4s,v23.4s}, [x1],  #32
-
-        fsub            v2.4s,  v0.4s,  v4.4s
-        fadd            v0.4s,  v0.4s,  v4.4s
-        fsub            v3.4s,  v1.4s,  v5.4s
-        fadd            v1.4s,  v1.4s,  v5.4s
-
-        uzp1            v16.4s, v18.4s, v19.4s
-        uzp2            v17.4s, v18.4s, v19.4s
-
-        st2             {v2.4s,v3.4s}, [x5],  #32
-        st2             {v0.4s,v1.4s}, [x4],  #32
-        ld2             {v20.4s,v21.4s}, [x0],  #32
-
-        fmul            v18.4s, v22.4s, v16.4s
-        fmul            v19.4s, v22.4s, v17.4s
-        b.eq            0f
-
-        ld1             {v4.4s,v5.4s}, [x2],  #32
-
-        fmls            v18.4s, v23.4s, v17.4s
-        fmla            v19.4s, v23.4s, v16.4s
-
-        ld2             {v2.4s,v3.4s}, [x1],  #32
-
-        fsub            v22.4s, v20.4s, v18.4s
-        fadd            v20.4s, v20.4s, v18.4s
-        fsub            v23.4s, v21.4s, v19.4s
-        fadd            v21.4s, v21.4s, v19.4s
-
-        uzp1            v6.4s,  v4.4s,  v5.4s
-        uzp2            v7.4s,  v4.4s,  v5.4s
-
-        st2             {v22.4s,v23.4s}, [x5],  #32
-        st2             {v20.4s,v21.4s}, [x4],  #32
-        ld2             {v0.4s,v1.4s}, [x0],  #32
-
-        b               8b
-4:
-        fmls            v4.4s,  v3.4s,  v7.4s
-        fmla            v5.4s,  v3.4s,  v6.4s
-
-        fsub            v2.4s,  v0.4s,  v4.4s
-        fadd            v0.4s,  v0.4s,  v4.4s
-        fsub            v3.4s,  v1.4s,  v5.4s
-        fadd            v1.4s,  v1.4s,  v5.4s
-
-        st2             {v2.4s,v3.4s}, [x5],  #32
-        st2             {v0.4s,v1.4s}, [x4],  #32
-
-        ret
-0:
-        fmls            v18.4s, v23.4s, v17.4s
-        fmla            v19.4s, v23.4s, v16.4s
-
-        fsub            v22.4s, v20.4s, v18.4s
-        fadd            v20.4s, v20.4s, v18.4s
-        fsub            v23.4s, v21.4s, v19.4s
-        fadd            v21.4s, v21.4s, v19.4s
-
-        st2             {v22.4s,v23.4s}, [x5],  #32
-        st2             {v20.4s,v21.4s}, [x4],  #32
-
-        ret
-endfunc
-
-function fft30_neon, align=6
-        sub             sp,  sp,  #0x20
-        stp             x20, x21, [sp]
-        stp             x22, x30, [sp, #0x10]
-        mov             x21, x1
-        mov             x22, x2
-        mov             x20, x4
-        mov             x0,  x21
-        mov             x1,  x22
-        lsl             x3,  x20, #1
-        bl              fft15_neon
-
-        add             x0,  x21, #15*8
-        add             x1,  x22, x20,  lsl #3
-        lsl             x3,  x20, #1
-        bl              fft15_neon
-
-        ldr             x2,  [x10, #(CELT_EXPTAB + 8)]  // s->exptab[1]
-        add             x0,  x21, #0
-        add             x1,  x21, #15*8
-        mov             x3,  #15
-        ldp             x20, x21, [sp]
-        ldp             x22, x30, [sp, #0x10]
-        add             sp,  sp,  #0x20
-        b               fft15_pass
-endfunc
-
-.macro  def_fft n, n2
-function fft\n\()_neon, align=6
-        sub             sp,  sp,  #0x30
-        stp             x20, x21, [sp]
-        stp             x22, x30, [sp, #0x10]
-        stp             x23, x24, [sp, #0x20]
-        mov             x21, x1
-        mov             x22, x2
-        mov             x23, x3
-        mov             x20, x4
-        sub             x3,  x3,  #1
-        lsl             x4,  x4,  #1
-        bl              fft\n2\()_neon
-
-        add             x1,  x21, #(\n2 * 8)
-        add             x2,  x22, x20, lsl #3
-        sub             x3,  x23, #1
-        lsl             x4,  x20, #1
-        bl              fft\n2\()_neon
-
-        add             x5,  x10, #CELT_EXPTAB
-        mov             x0,  x21
-        ldr             x2,  [x5,  x23, lsl #3] // s->exptab[N]
-        add             x1,  x21, #(\n2 * 8)
-        mov             x3,  #\n2
-        ldp             x20, x21, [sp]
-        ldp             x22, x30, [sp, #0x10]
-        ldp             x23, x24, [sp, #0x20]
-        add             sp,  sp,  #0x30
-        b               fft15_pass
-endfunc
-.endm
-
-        def_fft    60,  30
-        def_fft   120,  60
-        def_fft   240, 120
-        def_fft   480, 240
-        def_fft   960, 480
-
-function fft_b15_calc_neon
-        sub             sp,  sp,  #0x50
-        ldr             x8,  [x0,  #CELT_EXPTAB]    // s->exptab[0]
-        movrel          x6,  fact5
-        movrel          x11, shuffle_0213
-        movrel          x12, shuffle_1032
-        movrel          x13, shuffle_2301
-        movrel          x14, shuffle_3120
-        add             x8,  x8,  #8
-        movrel          x5,  fft_tab_neon
-        stp             x20, x30, [sp]
-        stp             d8,  d9,  [sp, #0x10]
-        stp             d10, d11, [sp, #0x20]
-        stp             d12, d13, [sp, #0x30]
-        stp             d14, d15, [sp, #0x40]
-        ld1             {v15.4s}, [x6]
-        ld1             {v0.4s,v1.4s},   [x8],  #32
-        ld1             {v6.2s},  [x8],  #8
-        ld1             {v2.4s,v3.4s},   [x8],  #32
-        ld1             {v7.2s},  [x8],  #8
-        ld1             {v4.4s,v5.4s},   [x8],  #32
-        uzp1            v8.4s,  v0.4s,  v1.4s   // exp[ 1 -  4].re
-        uzp2            v9.4s,  v0.4s,  v1.4s   // exp[ 1 -  4].im
-        uzp1            v10.4s, v2.4s,  v3.4s   // exp[ 6 -  9].re
-        uzp2            v11.4s, v2.4s,  v3.4s   // exp[ 6 -  9].im
-        uzp1            v12.4s, v4.4s,  v5.4s   // exp[11 - 14].re
-        uzp2            v13.4s, v4.4s,  v5.4s   // exp[11 - 14].im
-        zip1            v14.4s, v6.4s,  v7.4s   // exp[5,10].re/exp[5,10].im
-        add             x5,  x5,  x3,  lsl #3
-        ldr             x5,  [x5]
-        mov             x10, x0
-        blr             x5
-        ldp             x20, x30, [sp]
-        ldp             d8,  d9,  [sp, #0x10]
-        ldp             d10, d11, [sp, #0x20]
-        ldp             d12, d13, [sp, #0x30]
-        ldp             d14, d15, [sp, #0x40]
-        add             sp,  sp,  #0x50
-        ret
-endfunc
-
-const   fft_tab_neon, relocate=1
-        .quad fft15_neon
-        .quad fft30_neon
-        .quad fft60_neon
-        .quad fft120_neon
-        .quad fft240_neon
-        .quad fft480_neon
-        .quad fft960_neon
-endconst
-
-function ff_celt_imdct_half_neon, export=1
-        sub             sp,  sp,  #0x20
-        stp             x21, x30, [sp]
-        str             s0, [sp, #0x10]
-
-        ldp             w5,  w6,  [x0,  #CELT_LEN2] // CELT_LEN4
-        mov             x10, x0
-        mov             x21, x1
-        sub             w5,  w5,  #1
-        lsl             x7,  x3,  #3            //  2 * stride * sizeof(float)
-        sub             x8,  xzr, x3,  lsl #3   // -2 * stride * sizeof(float)
-        mul             x5,  x5,  x3
-        ldp             x9,  x10, [x0,  #CELT_TMP]  // CELT_TWIDDLE
-        ldr             w3,  [x0, #CELT_FFT_N]
-        add             x5,  x2,  x5,  lsl #2
-        mov             x11, x9
-
-        sub             w6,  w6,  #4
-        ld1             {v0.s}[0],  [x5], x8
-        ld1             {v1.s}[0],  [x2], x7
-        ld1             {v4.4s,v5.4s}, [x10], #32
-        ld1             {v0.s}[1],  [x5], x8
-        ld1             {v1.s}[1],  [x2], x7
-        uzp1            v2.4s,  v4.4s,  v5.4s
-        ld1             {v0.s}[2],  [x5], x8
-        ld1             {v1.s}[2],  [x2], x7
-        uzp2            v3.4s,  v4.4s,  v5.4s
-        ld1             {v0.s}[3],  [x5], x8
-        ld1             {v1.s}[3],  [x2], x7
-1:
-        subs            w6,  w6,  #4
-
-        ld1             {v20.s}[0], [x5], x8
-        ld1             {v21.s}[0], [x2], x7
-        ld1             {v4.4s,v5.4s}, [x10], #32
-
-        fmul            v6.4s,  v0.4s,  v2.4s
-        fmul            v7.4s,  v0.4s,  v3.4s
-
-        ld1             {v20.s}[1], [x5], x8
-        ld1             {v21.s}[1], [x2], x7
-
-        fmls            v6.4s,  v1.4s,  v3.4s
-        fmla            v7.4s,  v1.4s,  v2.4s
-
-        ld1             {v20.s}[2], [x5], x8
-        ld1             {v21.s}[2], [x2], x7
-
-        uzp1            v2.4s,  v4.4s,  v5.4s
-        uzp2            v3.4s,  v4.4s,  v5.4s
-        ld1             {v20.s}[3], [x5], x8
-        ld1             {v21.s}[3], [x2], x7
-
-        zip1            v4.4s,  v6.4s,  v7.4s
-        zip2            v5.4s,  v6.4s,  v7.4s
-
-        fmul            v6.4s,  v20.4s, v2.4s
-        fmul            v7.4s,  v20.4s, v3.4s
-
-        st1             {v4.4s,v5.4s}, [x9], #32
-
-        fmls            v6.4s,  v21.4s, v3.4s
-        fmla            v7.4s,  v21.4s, v2.4s
-
-        b.eq            3f
-
-        subs            w6,  w6,  #4
-        ld1             {v4.4s,v5.4s}, [x10], #32
-        ld1             {v0.s}[0],  [x5], x8
-        ld1             {v1.s}[0],  [x2], x7
-        uzp1            v2.4s,  v4.4s,  v5.4s
-        ld1             {v0.s}[1],  [x5], x8
-        ld1             {v1.s}[1],  [x2], x7
-        uzp2            v3.4s,  v4.4s,  v5.4s
-        ld1             {v0.s}[2],  [x5], x8
-        ld1             {v1.s}[2],  [x2], x7
-        zip1            v4.4s,  v6.4s,  v7.4s
-        zip2            v5.4s,  v6.4s,  v7.4s
-        ld1             {v0.s}[3],  [x5], x8
-        ld1             {v1.s}[3],  [x2], x7
-
-        st1             {v4.4s,v5.4s}, [x9], #32
-
-        b.gt            1b
-
-        fmul            v6.4s,  v0.4s,  v2.4s
-        fmul            v7.4s,  v0.4s,  v3.4s
-        fmls            v6.4s,  v1.4s,  v3.4s
-        fmla            v7.4s,  v1.4s,  v2.4s
-3:
-        zip1            v4.4s,  v6.4s,  v7.4s
-        zip2            v5.4s,  v6.4s,  v7.4s
-        st1             {v4.4s,v5.4s}, [x9], #32
-
-        mov             x2,  x11
-        mov             x4,  #1
-
-        bl              fft_b15_calc_neon
-
-        ldr             w5,  [x10, #CELT_LEN4]
-        ldr             x6,  [x10, #CELT_TWIDDLE]
-        ldr             s31, [sp, #0x10]
-
-        add             x1,  x21, x5,  lsl #2
-        add             x3,  x6,  x5,  lsl #2
-        sub             x0,  x1,  #16
-        sub             x2,  x3,  #16
-        mov             x8,  #-16
-        mov             x7,  #16
-        mov             x10, x0
-        mov             x11, x1
-
-        sub             w5,  w5,  #4
-
-        ld1             {v0.4s},  [x0], x8
-        ld1             {v1.4s},  [x1], x7
-        ld1             {v2.4s},  [x2], x8
-        ld1             {v3.4s},  [x3], x7
-
-        uzp1            v4.4s,  v0.4s,  v1.4s   // z[-i-2, -i-1, +i, i+1].re
-        uzp2            v6.4s,  v0.4s,  v1.4s   // z[-i-2, -i-1, +i, i+1].im
-
-        uzp1            v5.4s,  v2.4s,  v3.4s   // twidlle_exptab[-i-2, -i-1, +i, i+1].re
-        uzp2            v7.4s,  v2.4s,  v3.4s   // twidlle_exptab[-i-2, -i-1, +i, i+1].im
-
-        fmul            v1.4s,  v6.4s,  v5.4s
-        fmul            v0.4s,  v6.4s,  v7.4s
-2:
-        subs            w5,  w5,  #4
-
-        ld1             {v20.4s}, [x0], x8
-
-        fmla            v1.4s,  v4.4s,  v7.4s
-        fmls            v0.4s,  v4.4s,  v5.4s
-
-        ld1             {v21.4s}, [x1], x7
-
-        ext             v1.16b, v1.16b, v1.16b, #8
-        fmul            v0.4s,  v0.4s,  v31.s[0]
-
-        ld1             {v2.4s},  [x2], x8
-
-        rev64           v1.4s,  v1.4s
-        fmul            v1.4s,  v1.4s,  v31.s[0]
-
-        ld1             {v3.4s},  [x3], x7
-
-        zip1            v5.4s,  v0.4s,  v1.4s
-        zip2            v7.4s,  v0.4s,  v1.4s
-
-        uzp1            v4.4s,  v20.4s, v21.4s  // z[-i-2, -i-1, +i, i+1].re
-        uzp2            v6.4s,  v20.4s, v21.4s  // z[-i-2, -i-1, +i, i+1].im
-
-        st1             {v5.4s},  [x10], x8
-        st1             {v7.4s},  [x11], x7
-
-        uzp1            v5.4s,  v2.4s,  v3.4s   // twidlle_exptab[-i-2, -i-1, +i, i+1].re
-        uzp2            v7.4s,  v2.4s,  v3.4s   // twidlle_exptab[-i-2, -i-1, +i, i+1].im
-
-        fmul            v1.4s,  v6.4s,  v5.4s
-        fmul            v0.4s,  v6.4s,  v7.4s
-        b.gt            2b
-
-        fmla            v1.4s,  v4.4s,  v7.4s
-        fmls            v0.4s,  v4.4s,  v5.4s
-        ext             v1.16b, v1.16b, v1.16b, #8
-        fmul            v0.4s,  v0.4s,  v31.s[0]
-        rev64           v1.4s,  v1.4s
-        fmul            v1.4s,  v1.4s,  v31.s[0]
-        zip1            v5.4s,  v0.4s,  v1.4s
-        zip2            v7.4s,  v0.4s,  v1.4s
-        st1             {v5.4s},  [x10], x8
-        st1             {v7.4s},  [x11], x7
-
-        ldp             x21, x30, [sp]
-        add             sp,  sp,  #0x20
-        ret
-endfunc
-
-// [0] = exp(2 * i * pi / 5), [1] = exp(2 * i * pi * 2 / 5)
-const   fact5,          align=4
-        .float           0.30901699437494745, 0.95105651629515353
-        .float          -0.80901699437494734, 0.58778525229247325
-endconst
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/mpegaudiodsp_init.c b/mythtv/external/FFmpeg/libavcodec/aarch64/mpegaudiodsp_init.c
index b94514645fb..5d966af5f4b 100644
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/mpegaudiodsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/mpegaudiodsp_init.c
@@ -16,6 +16,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "libavutil/attributes.h"
@@ -24,9 +25,9 @@
 #include "config.h"
 
 void ff_mpadsp_apply_window_fixed_neon(int32_t *synth_buf, int32_t *window,
-                                       int *dither, int16_t *samples, int incr);
+                                       int *dither, int16_t *samples, ptrdiff_t incr);
 void ff_mpadsp_apply_window_float_neon(float *synth_buf, float *window,
-                                       int *dither, float *samples, int incr);
+                                       int *dither, float *samples, ptrdiff_t incr);
 
 av_cold void ff_mpadsp_init_aarch64(MPADSPContext *s)
 {
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/mpegaudiodsp_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/mpegaudiodsp_neon.S
index 97d2e1f0889..cc7d9b321c4 100644
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/mpegaudiodsp_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/mpegaudiodsp_neon.S
@@ -34,7 +34,6 @@ endconst
 .macro   apply_window   type, st
 function ff_mpadsp_apply_window_\type\()_neon, export=1
         mov             x7,  x0
-        sxtw            x4,  w4  // incr
         add             x8,  x0,  #512<<2
         ld1             {v0.4s,v1.4s,v2.4s,v3.4s},  [x7],  #64
         ld1             {v4.4s,v5.4s,v6.4s,v7.4s},  [x7],  #64
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/neontest.c b/mythtv/external/FFmpeg/libavcodec/aarch64/neontest.c
index 1e9ef167e32..a24c22dd306 100644
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/neontest.c
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/neontest.c
@@ -83,9 +83,9 @@ wrap(avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt))
     testneonclobbers(avcodec_send_packet, avctx, avpkt);
 }
 
-wrap(avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame))
+wrap(avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt))
 {
-    testneonclobbers(avcodec_receive_frame, avctx, frame);
+    testneonclobbers(avcodec_receive_packet, avctx, avpkt);
 }
 
 wrap(avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame))
@@ -93,7 +93,7 @@ wrap(avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame))
     testneonclobbers(avcodec_send_frame, avctx, frame);
 }
 
-wrap(avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt))
+wrap(avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame))
 {
-    testneonclobbers(avcodec_receive_packet, avctx, avpkt);
+    testneonclobbers(avcodec_receive_frame, avctx, frame);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/rv40dsp_init_aarch64.c b/mythtv/external/FFmpeg/libavcodec/aarch64/rv40dsp_init_aarch64.c
index 764bc1ef391..142705db980 100644
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/rv40dsp_init_aarch64.c
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/rv40dsp_init_aarch64.c
@@ -25,15 +25,15 @@
 
 #include "config.h"
 
-void ff_put_rv40_chroma_mc8_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                 int x, int y);
-void ff_put_rv40_chroma_mc4_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                 int x, int y);
+void ff_put_rv40_chroma_mc8_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                 int h, int x, int y);
+void ff_put_rv40_chroma_mc4_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                 int h, int x, int y);
 
-void ff_avg_rv40_chroma_mc8_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                 int x, int y);
-void ff_avg_rv40_chroma_mc4_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                 int x, int y);
+void ff_avg_rv40_chroma_mc8_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                 int h, int x, int y);
+void ff_avg_rv40_chroma_mc4_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                 int h, int x, int y);
 
 av_cold void ff_rv40dsp_init_aarch64(RV34DSPContext *c)
 {
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/sbrdsp_init_aarch64.c b/mythtv/external/FFmpeg/libavcodec/aarch64/sbrdsp_init_aarch64.c
new file mode 100644
index 00000000000..9c967990dfc
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/sbrdsp_init_aarch64.c
@@ -0,0 +1,70 @@
+/*
+ * 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/aarch64/cpu.h"
+#include "libavutil/attributes.h"
+#include "libavcodec/sbrdsp.h"
+
+void ff_sbr_sum64x5_neon(float *z);
+float ff_sbr_sum_square_neon(float (*x)[2], int n);
+void ff_sbr_neg_odd_64_neon(float *x);
+void ff_sbr_qmf_pre_shuffle_neon(float *z);
+void ff_sbr_qmf_post_shuffle_neon(float W[32][2], const float *z);
+void ff_sbr_qmf_deint_neg_neon(float *v, const float *src);
+void ff_sbr_qmf_deint_bfly_neon(float *v, const float *src0, const float *src1);
+void ff_sbr_hf_g_filt_neon(float (*Y)[2], const float (*X_high)[40][2],
+                           const float *g_filt, int m_max, intptr_t ixh);
+void ff_sbr_hf_gen_neon(float (*X_high)[2], const float (*X_low)[2],
+                        const float alpha0[2], const float alpha1[2],
+                        float bw, int start, int end);
+void ff_sbr_autocorrelate_neon(const float x[40][2], float phi[3][2][2]);
+void ff_sbr_hf_apply_noise_0_neon(float Y[64][2], const float *s_m,
+                                  const float *q_filt, int noise,
+                                  int kx, int m_max);
+void ff_sbr_hf_apply_noise_1_neon(float Y[64][2], const float *s_m,
+                                  const float *q_filt, int noise,
+                                  int kx, int m_max);
+void ff_sbr_hf_apply_noise_2_neon(float Y[64][2], const float *s_m,
+                                  const float *q_filt, int noise,
+                                  int kx, int m_max);
+void ff_sbr_hf_apply_noise_3_neon(float Y[64][2], const float *s_m,
+                                  const float *q_filt, int noise,
+                                  int kx, int m_max);
+
+av_cold void ff_sbrdsp_init_aarch64(SBRDSPContext *s)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+        s->sum64x5 = ff_sbr_sum64x5_neon;
+        s->sum_square = ff_sbr_sum_square_neon;
+        s->neg_odd_64 = ff_sbr_neg_odd_64_neon;
+        s->qmf_pre_shuffle = ff_sbr_qmf_pre_shuffle_neon;
+        s->qmf_post_shuffle = ff_sbr_qmf_post_shuffle_neon;
+        s->qmf_deint_neg = ff_sbr_qmf_deint_neg_neon;
+        s->qmf_deint_bfly = ff_sbr_qmf_deint_bfly_neon;
+        s->hf_g_filt = ff_sbr_hf_g_filt_neon;
+        s->hf_gen = ff_sbr_hf_gen_neon;
+        s->autocorrelate = ff_sbr_autocorrelate_neon;
+        s->hf_apply_noise[0] = ff_sbr_hf_apply_noise_0_neon;
+        s->hf_apply_noise[1] = ff_sbr_hf_apply_noise_1_neon;
+        s->hf_apply_noise[2] = ff_sbr_hf_apply_noise_2_neon;
+        s->hf_apply_noise[3] = ff_sbr_hf_apply_noise_3_neon;
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/sbrdsp_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/sbrdsp_neon.S
new file mode 100644
index 00000000000..d1d79b749c2
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/sbrdsp_neon.S
@@ -0,0 +1,327 @@
+/*
+ * 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/aarch64/asm.S"
+
+const factors, align=4
+        .float 1.0, -1.0, 1.0, -1.0
+endconst
+
+const phi_noise_0, align=4
+        .float 1.0, 0.0, 1.0, 0.0
+endconst
+
+const phi_noise_1, align=4
+        .float 0.0,  1.0,  0.0, -1.0
+        .float 0.0, -1.0,  0.0,  1.0
+endconst
+
+const phi_noise_2, align=4
+        .float -1.0, 0.0, -1.0, 0.0
+endconst
+
+const phi_noise_3, align=4
+        .float 0.0, -1.0,  0.0,  1.0
+        .float 0.0,  1.0,  0.0, -1.0
+endconst
+
+function ff_sbr_sum64x5_neon, export=1
+        add             x1, x0, #64*4
+        add             x2, x0, #128*4
+        add             x3, x0, #192*4
+        add             x4, x0, #256*4
+        mov             x5, #64
+1:      ld1             {v0.4S}, [x0]
+        ld1             {v1.4S}, [x1], #16
+        fadd            v0.4S, v0.4S, v1.4S
+        ld1             {v2.4S}, [x2], #16
+        fadd            v0.4S, v0.4S, v2.4S
+        ld1             {v3.4S}, [x3], #16
+        fadd            v0.4S, v0.4S, v3.4S
+        ld1             {v4.4S}, [x4], #16
+        fadd            v0.4S, v0.4S, v4.4S
+        st1             {v0.4S}, [x0], #16
+        subs            x5, x5, #4
+        b.gt            1b
+        ret
+endfunc
+
+function ff_sbr_sum_square_neon, export=1
+        movi            v0.4S, #0
+1:      ld1             {v1.4S}, [x0], #16
+        fmla            v0.4S, v1.4S, v1.4S
+        subs            w1, w1, #2
+        b.gt            1b
+        faddp           v0.4S, v0.4S, v0.4S
+        faddp           v0.4S, v0.4S, v0.4S
+        ret
+endfunc
+
+function ff_sbr_neg_odd_64_neon, export=1
+        mov             x1, x0
+        movi            v5.4S, #1<<7, lsl #24
+        ld2             {v0.4S, v1.4S}, [x0], #32
+        eor             v1.16B, v1.16B, v5.16B
+        ld2             {v2.4S, v3.4S}, [x0], #32
+.rept 3
+        st2             {v0.4S, v1.4S}, [x1], #32
+        eor             v3.16B, v3.16B, v5.16B
+        ld2             {v0.4S, v1.4S}, [x0], #32
+        st2             {v2.4S, v3.4S}, [x1], #32
+        eor             v1.16B, v1.16B, v5.16B
+        ld2             {v2.4S, v3.4S}, [x0], #32
+.endr
+        eor             v3.16B, v3.16B, v5.16B
+        st2             {v0.4S, v1.4S}, [x1], #32
+        st2             {v2.4S, v3.4S}, [x1], #32
+        ret
+endfunc
+
+function ff_sbr_qmf_pre_shuffle_neon, export=1
+        add             x1, x0, #60*4
+        add             x2, x0, #64*4
+        mov             x3, #-16
+        mov             x4, #-4
+        movi            v6.4S, #1<<7, lsl #24
+        ld1             {v0.2S}, [x0], #8
+        st1             {v0.2S}, [x2], #8
+.rept 7
+        ld1             {v1.4S}, [x1], x3
+        ld1             {v2.4S}, [x0], #16
+        eor             v1.16B, v1.16B, v6.16B
+        rev64           v1.4S, v1.4S
+        ext             v1.16B, v1.16B, v1.16B, #8
+        st2             {v1.4S, v2.4S}, [x2], #32
+.endr
+        add             x1, x1, #8
+        ld1             {v1.2S}, [x1], x4
+        ld1             {v2.2S}, [x0], #8
+        ld1             {v1.S}[3], [x1]
+        ld1             {v2.S}[2], [x0]
+        eor             v1.16B, v1.16B, v6.16B
+        rev64           v1.4S, v1.4S
+        st2             {v1.2S, v2.2S}, [x2], #16
+        st2             {v1.S, v2.S}[2], [x2]
+        ret
+endfunc
+
+function ff_sbr_qmf_post_shuffle_neon, export=1
+        add             x2, x1, #60*4
+        mov             x3, #-16
+        mov             x4, #32
+        movi            v6.4S, #1<<7, lsl #24
+1:      ld1             {v0.4S}, [x2], x3
+        ld1             {v1.4S}, [x1], #16
+        eor             v0.16B, v0.16B, v6.16B
+        rev64           v0.4S, v0.4S
+        ext             v0.16B, v0.16B, v0.16B, #8
+        st2             {v0.4S, v1.4S}, [x0], #32
+        subs            x4, x4, #4
+        b.gt            1b
+        ret
+endfunc
+
+function ff_sbr_qmf_deint_neg_neon, export=1
+        add             x1, x1, #56*4
+        add             x2, x0, #60*4
+        mov             x3, #-32
+        mov             x4, #32
+        movi            v2.4S, #1<<7, lsl #24
+1:      ld2             {v0.4S, v1.4S}, [x1], x3
+        eor             v0.16B, v0.16B, v2.16B
+        rev64           v1.4S, v1.4S
+        ext             v1.16B, v1.16B, v1.16B, #8
+        st1             {v0.4S}, [x2]
+        st1             {v1.4S}, [x0], #16
+        sub             x2, x2, #16
+        subs            x4, x4, #4
+        b.gt            1b
+        ret
+endfunc
+
+function ff_sbr_qmf_deint_bfly_neon, export=1
+        add             x2, x2, #60*4
+        add             x3, x0, #124*4
+        mov             x4, #64
+        mov             x5, #-16
+1:      ld1             {v0.4S}, [x1], #16
+        ld1             {v1.4S}, [x2], x5
+        rev64           v2.4S, v0.4S
+        ext             v2.16B, v2.16B, v2.16B, #8
+        rev64           v3.4S, v1.4S
+        ext             v3.16B, v3.16B, v3.16B, #8
+        fadd            v1.4S, v1.4S, v2.4S
+        fsub            v0.4S, v0.4S, v3.4S
+        st1             {v0.4S}, [x0], #16
+        st1             {v1.4S}, [x3], x5
+        subs            x4, x4, #4
+        b.gt            1b
+        ret
+endfunc
+
+function ff_sbr_hf_gen_neon, export=1
+        sxtw            x4, w4
+        sxtw            x5, w5
+        movrel          x6, factors
+        ld1             {v7.4S}, [x6]
+        dup             v1.4S, v0.S[0]
+        mov             v2.8B, v1.8B
+        mov             v2.S[2], v7.S[0]
+        mov             v2.S[3], v7.S[0]
+        fmul            v1.4S, v1.4S, v2.4S
+        ld1             {v0.D}[0], [x3]
+        ld1             {v0.D}[1], [x2]
+        fmul            v0.4S, v0.4S, v1.4S
+        fmul            v1.4S, v0.4S, v7.4S
+        rev64           v0.4S, v0.4S
+        sub             x7, x5, x4
+        add             x0, x0, x4, lsl #3
+        add             x1, x1, x4, lsl #3
+        sub             x1, x1, #16
+1:      ld1             {v2.4S}, [x1], #16
+        ld1             {v3.2S}, [x1]
+        fmul            v4.4S, v2.4S, v1.4S
+        fmul            v5.4S, v2.4S, v0.4S
+        faddp           v4.4S, v4.4S, v4.4S
+        faddp           v5.4S, v5.4S, v5.4S
+        faddp           v4.4S, v4.4S, v4.4S
+        faddp           v5.4S, v5.4S, v5.4S
+        mov             v4.S[1], v5.S[0]
+        fadd            v4.2S, v4.2S, v3.2S
+        st1             {v4.2S}, [x0], #8
+        sub             x1, x1, #8
+        subs            x7, x7, #1
+        b.gt            1b
+        ret
+endfunc
+
+function ff_sbr_hf_g_filt_neon, export=1
+        sxtw            x3, w3
+        sxtw            x4, w4
+        mov             x5, #40*2*4
+        add             x1, x1, x4, lsl #3
+1:      ld1             {v0.2S}, [x1], x5
+        ld1             {v1.S}[0], [x2], #4
+        fmul            v2.4S, v0.4S, v1.S[0]
+        st1             {v2.2S}, [x0], #8
+        subs            x3, x3, #1
+        b.gt            1b
+        ret
+endfunc
+
+function ff_sbr_autocorrelate_neon, export=1
+        mov             x2, #38
+        movrel          x3, factors
+        ld1             {v0.4S}, [x3]
+        movi            v1.4S, #0
+        movi            v2.4S, #0
+        movi            v3.4S, #0
+        ld1             {v4.2S}, [x0], #8
+        ld1             {v5.2S}, [x0], #8
+        fmul            v16.2S, v4.2S, v4.2S
+        fmul            v17.2S, v5.2S, v4.S[0]
+        fmul            v18.2S, v5.2S, v4.S[1]
+1:      ld1             {v5.D}[1], [x0], #8
+        fmla            v1.2S, v4.2S, v4.2S
+        fmla            v2.4S, v5.4S, v4.S[0]
+        fmla            v3.4S, v5.4S, v4.S[1]
+        mov             v4.D[0], v5.D[0]
+        mov             v5.D[0], v5.D[1]
+        subs            x2, x2, #1
+        b.gt            1b
+        fmul            v19.2S, v4.2S, v4.2S
+        fmul            v20.2S, v5.2S, v4.S[0]
+        fmul            v21.2S, v5.2S, v4.S[1]
+        fadd            v22.4S, v2.4S, v20.4S
+        fsub            v22.4S, v22.4S, v17.4S
+        fadd            v23.4S, v3.4S, v21.4S
+        fsub            v23.4S, v23.4S, v18.4S
+        rev64           v23.4S, v23.4S
+        fmul            v23.4S, v23.4S, v0.4S
+        fadd            v22.4S, v22.4S, v23.4S
+        st1             {v22.4S}, [x1], #16
+        fadd            v23.2S, v1.2S, v19.2S
+        fsub            v23.2S, v23.2S, v16.2S
+        faddp           v23.2S, v23.2S, v23.2S
+        st1             {v23.S}[0], [x1]
+        add             x1, x1, #8
+        rev64           v3.2S, v3.2S
+        fmul            v3.2S, v3.2S, v0.2S
+        fadd            v2.2S, v2.2S, v3.2S
+        st1             {v2.2S}, [x1]
+        add             x1, x1, #16
+        faddp           v1.2S, v1.2S, v1.2S
+        st1             {v1.S}[0], [x1]
+        ret
+endfunc
+
+.macro apply_noise_common
+        sxtw            x3, w3
+        sxtw            x5, w5
+        movrel          x7, X(ff_sbr_noise_table)
+        add             x3, x3, #1
+1:      and             x3, x3, #0x1ff
+        add             x8, x7, x3, lsl #3
+        add             x3, x3, #2
+        ld1             {v2.4S}, [x0]
+        ld1             {v3.2S}, [x1], #8
+        ld1             {v4.2S}, [x2], #8
+        ld1             {v5.4S}, [x8]
+        mov             v6.16B, v2.16B
+        zip1            v3.4S, v3.4S, v3.4S
+        zip1            v4.4S, v4.4S, v4.4S
+        fmla            v6.4S, v1.4S, v3.4S
+        fmla            v2.4S, v5.4S, v4.4S
+        fcmeq           v7.4S, v3.4S, #0.0
+        bif             v2.16B, v6.16B, v7.16B
+        st1             {v2.4S}, [x0], #16
+        subs            x5, x5, #2
+        b.gt            1b
+.endm
+
+function ff_sbr_hf_apply_noise_0_neon, export=1
+        movrel          x9, phi_noise_0
+        ld1             {v1.4S}, [x9]
+        apply_noise_common
+        ret
+endfunc
+
+function ff_sbr_hf_apply_noise_1_neon, export=1
+        movrel          x9, phi_noise_1
+        and             x4, x4, #1
+        add             x9, x9, x4, lsl #4
+        ld1             {v1.4S}, [x9]
+        apply_noise_common
+        ret
+endfunc
+
+function ff_sbr_hf_apply_noise_2_neon, export=1
+        movrel          x9, phi_noise_2
+        ld1             {v1.4S}, [x9]
+        apply_noise_common
+        ret
+endfunc
+
+function ff_sbr_hf_apply_noise_3_neon, export=1
+        movrel          x9, phi_noise_3
+        and             x4, x4, #1
+        add             x9, x9, x4, lsl #4
+        ld1             {v1.4S}, [x9]
+        apply_noise_common
+        ret
+endfunc
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/simple_idct_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/simple_idct_neon.S
new file mode 100644
index 00000000000..5e4d021a976
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/simple_idct_neon.S
@@ -0,0 +1,362 @@
+/*
+ * ARM NEON IDCT
+ *
+ * Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
+ * Copyright (c) 2017 Matthieu Bouron <matthieu.bouron@gmail.com>
+ *
+ * Based on Simple IDCT
+ * Copyright (c) 2001 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * 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/aarch64/asm.S"
+
+#define Z1  22725  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+#define Z2  21407  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+#define Z3  19266  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+#define Z4  16383  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+#define Z5  12873  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+#define Z6  8867   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+#define Z7  4520   //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+#define Z4c ((1<<(COL_SHIFT-1))/Z4)
+#define ROW_SHIFT 11
+#define COL_SHIFT 20
+
+#define z1 v0.H[0]
+#define z2 v0.H[1]
+#define z3 v0.H[2]
+#define z4 v0.H[3]
+#define z5 v0.H[4]
+#define z6 v0.H[5]
+#define z7 v0.H[6]
+#define z4c v0.H[7]
+
+const   idct_coeff_neon, align=4
+        .short Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z4c
+endconst
+
+.macro idct_start data
+        prfm            pldl1keep, [\data]
+        mov             x10, x30
+        movrel          x3, idct_coeff_neon
+        ld1             {v0.2D}, [x3]
+.endm
+
+.macro idct_end
+        br              x10
+.endm
+
+.macro smull1 a, b, c
+        smull           \a, \b, \c
+.endm
+
+.macro smlal1 a, b, c
+        smlal           \a, \b, \c
+.endm
+
+.macro smlsl1 a, b, c
+        smlsl           \a, \b, \c
+.endm
+
+.macro idct_col4_top y1, y2, y3, y4, i, l
+        smull\i         v7.4S,  \y3\l, z2
+        smull\i         v16.4S, \y3\l, z6
+        smull\i         v17.4S, \y2\l, z1
+        add             v19.4S, v23.4S, v7.4S
+        smull\i         v18.4S, \y2\l, z3
+        add             v20.4S, v23.4S, v16.4S
+        smull\i         v5.4S,  \y2\l, z5
+        sub             v21.4S, v23.4S, v16.4S
+        smull\i         v6.4S,  \y2\l, z7
+        sub             v22.4S, v23.4S, v7.4S
+
+        smlal\i         v17.4S, \y4\l, z3
+        smlsl\i         v18.4S, \y4\l, z7
+        smlsl\i         v5.4S,  \y4\l, z1
+        smlsl\i         v6.4S,  \y4\l, z5
+.endm
+
+.macro idct_row4_neon y1, y2, y3, y4, pass
+        ld1             {\y1\().2D,\y2\().2D}, [x2], #32
+        movi            v23.4S, #1<<2, lsl #8
+        orr             v5.16B, \y1\().16B, \y2\().16B
+        ld1             {\y3\().2D,\y4\().2D}, [x2], #32
+        orr             v6.16B, \y3\().16B, \y4\().16B
+        orr             v5.16B, v5.16B, v6.16B
+        mov             x3, v5.D[1]
+        smlal           v23.4S, \y1\().4H, z4
+
+        idct_col4_top   \y1, \y2, \y3, \y4, 1, .4H
+
+        cmp             x3, #0
+        b.eq            \pass\()f
+
+        smull2          v7.4S, \y1\().8H, z4
+        smlal2          v17.4S, \y2\().8H, z5
+        smlsl2          v18.4S, \y2\().8H, z1
+        smull2          v16.4S, \y3\().8H, z2
+        smlal2          v5.4S, \y2\().8H, z7
+        add             v19.4S, v19.4S, v7.4S
+        sub             v20.4S, v20.4S, v7.4S
+        sub             v21.4S, v21.4S, v7.4S
+        add             v22.4S, v22.4S, v7.4S
+        smlal2          v6.4S, \y2\().8H, z3
+        smull2          v7.4S, \y3\().8H, z6
+        smlal2          v17.4S, \y4\().8H, z7
+        smlsl2          v18.4S, \y4\().8H, z5
+        smlal2          v5.4S, \y4\().8H, z3
+        smlsl2          v6.4S, \y4\().8H, z1
+        add             v19.4S, v19.4S, v7.4S
+        sub             v20.4S, v20.4S, v16.4S
+        add             v21.4S, v21.4S, v16.4S
+        sub             v22.4S, v22.4S, v7.4S
+
+\pass:  add             \y3\().4S, v19.4S, v17.4S
+        add             \y4\().4S, v20.4S, v18.4S
+        shrn            \y1\().4H, \y3\().4S, #ROW_SHIFT
+        shrn            \y2\().4H, \y4\().4S, #ROW_SHIFT
+        add             v7.4S, v21.4S, v5.4S
+        add             v16.4S, v22.4S, v6.4S
+        shrn            \y3\().4H, v7.4S, #ROW_SHIFT
+        shrn            \y4\().4H, v16.4S, #ROW_SHIFT
+        sub             v22.4S, v22.4S, v6.4S
+        sub             v19.4S, v19.4S, v17.4S
+        sub             v21.4S, v21.4S, v5.4S
+        shrn2           \y1\().8H, v22.4S, #ROW_SHIFT
+        sub             v20.4S, v20.4S, v18.4S
+        shrn2           \y2\().8H, v21.4S, #ROW_SHIFT
+        shrn2           \y3\().8H, v20.4S, #ROW_SHIFT
+        shrn2           \y4\().8H, v19.4S, #ROW_SHIFT
+
+        trn1            v16.8H, \y1\().8H, \y2\().8H
+        trn2            v17.8H, \y1\().8H, \y2\().8H
+        trn1            v18.8H, \y3\().8H, \y4\().8H
+        trn2            v19.8H, \y3\().8H, \y4\().8H
+        trn1            \y1\().4S, v16.4S, v18.4S
+        trn1            \y2\().4S, v17.4S, v19.4S
+        trn2            \y3\().4S, v16.4S, v18.4S
+        trn2            \y4\().4S, v17.4S, v19.4S
+.endm
+
+.macro declare_idct_col4_neon i, l
+function idct_col4_neon\i
+        dup             v23.4H, z4c
+.if \i == 1
+        add             v23.4H, v23.4H, v24.4H
+.else
+        mov             v5.D[0], v24.D[1]
+        add             v23.4H, v23.4H, v5.4H
+.endif
+        smull           v23.4S, v23.4H, z4
+
+        idct_col4_top   v24, v25, v26, v27, \i, \l
+
+        mov             x4, v28.D[\i - 1]
+        mov             x5, v29.D[\i - 1]
+        cmp             x4, #0
+        b.eq            1f
+
+        smull\i         v7.4S,  v28\l,  z4
+        add             v19.4S, v19.4S, v7.4S
+        sub             v20.4S, v20.4S, v7.4S
+        sub             v21.4S, v21.4S, v7.4S
+        add             v22.4S, v22.4S, v7.4S
+
+1:      mov             x4, v30.D[\i - 1]
+        cmp             x5, #0
+        b.eq            2f
+
+        smlal\i         v17.4S, v29\l, z5
+        smlsl\i         v18.4S, v29\l, z1
+        smlal\i         v5.4S,  v29\l, z7
+        smlal\i         v6.4S,  v29\l, z3
+
+2:      mov             x5, v31.D[\i - 1]
+        cmp             x4, #0
+        b.eq            3f
+
+        smull\i         v7.4S,  v30\l, z6
+        smull\i         v16.4S, v30\l, z2
+        add             v19.4S, v19.4S, v7.4S
+        sub             v22.4S, v22.4S, v7.4S
+        sub             v20.4S, v20.4S, v16.4S
+        add             v21.4S, v21.4S, v16.4S
+
+3:      cmp             x5, #0
+        b.eq            4f
+
+        smlal\i         v17.4S, v31\l, z7
+        smlsl\i         v18.4S, v31\l, z5
+        smlal\i         v5.4S,  v31\l, z3
+        smlsl\i         v6.4S,  v31\l, z1
+
+4:      addhn           v7.4H, v19.4S, v17.4S
+        addhn2          v7.8H, v20.4S, v18.4S
+        subhn           v18.4H, v20.4S, v18.4S
+        subhn2          v18.8H, v19.4S, v17.4S
+
+        addhn           v16.4H, v21.4S, v5.4S
+        addhn2          v16.8H, v22.4S, v6.4S
+        subhn           v17.4H, v22.4S, v6.4S
+        subhn2          v17.8H, v21.4S, v5.4S
+
+        ret
+endfunc
+.endm
+
+declare_idct_col4_neon 1, .4H
+declare_idct_col4_neon 2, .8H
+
+function ff_simple_idct_put_neon, export=1
+        idct_start      x2
+
+        idct_row4_neon  v24, v25, v26, v27, 1
+        idct_row4_neon  v28, v29, v30, v31, 2
+        bl              idct_col4_neon1
+
+        sqshrun         v1.8B,  v7.8H, #COL_SHIFT-16
+        sqshrun2        v1.16B, v16.8H, #COL_SHIFT-16
+        sqshrun         v3.8B,  v17.8H, #COL_SHIFT-16
+        sqshrun2        v3.16B, v18.8H, #COL_SHIFT-16
+
+        bl              idct_col4_neon2
+
+        sqshrun         v2.8B,  v7.8H, #COL_SHIFT-16
+        sqshrun2        v2.16B, v16.8H, #COL_SHIFT-16
+        sqshrun         v4.8B,  v17.8H, #COL_SHIFT-16
+        sqshrun2        v4.16B, v18.8H, #COL_SHIFT-16
+
+        zip1            v16.4S, v1.4S, v2.4S
+        zip2            v17.4S, v1.4S, v2.4S
+
+        st1             {v16.D}[0], [x0], x1
+        st1             {v16.D}[1], [x0], x1
+
+        zip1            v18.4S, v3.4S, v4.4S
+        zip2            v19.4S, v3.4S, v4.4S
+
+        st1             {v17.D}[0], [x0], x1
+        st1             {v17.D}[1], [x0], x1
+        st1             {v18.D}[0], [x0], x1
+        st1             {v18.D}[1], [x0], x1
+        st1             {v19.D}[0], [x0], x1
+        st1             {v19.D}[1], [x0], x1
+
+        idct_end
+endfunc
+
+function ff_simple_idct_add_neon, export=1
+        idct_start      x2
+
+        idct_row4_neon  v24, v25, v26, v27, 1
+        idct_row4_neon  v28, v29, v30, v31, 2
+        bl              idct_col4_neon1
+
+        sshr            v1.8H, v7.8H, #COL_SHIFT-16
+        sshr            v2.8H, v16.8H, #COL_SHIFT-16
+        sshr            v3.8H, v17.8H, #COL_SHIFT-16
+        sshr            v4.8H, v18.8H, #COL_SHIFT-16
+
+        bl              idct_col4_neon2
+
+        sshr            v7.8H, v7.8H, #COL_SHIFT-16
+        sshr            v16.8H, v16.8H, #COL_SHIFT-16
+        sshr            v17.8H, v17.8H, #COL_SHIFT-16
+        sshr            v18.8H, v18.8H, #COL_SHIFT-16
+
+        mov             x9,  x0
+        ld1             {v19.D}[0], [x0], x1
+        zip1            v23.2D, v1.2D, v7.2D
+        zip2            v24.2D, v1.2D, v7.2D
+        ld1             {v19.D}[1], [x0], x1
+        zip1            v25.2D, v2.2D, v16.2D
+        zip2            v26.2D, v2.2D, v16.2D
+        ld1             {v20.D}[0], [x0], x1
+        zip1            v27.2D, v3.2D, v17.2D
+        zip2            v28.2D, v3.2D, v17.2D
+        ld1             {v20.D}[1], [x0], x1
+        zip1            v29.2D, v4.2D, v18.2D
+        zip2            v30.2D, v4.2D, v18.2D
+        ld1             {v21.D}[0], [x0], x1
+        uaddw           v23.8H, v23.8H, v19.8B
+        uaddw2          v24.8H, v24.8H, v19.16B
+        ld1             {v21.D}[1], [x0], x1
+        sqxtun          v23.8B, v23.8H
+        sqxtun2         v23.16B, v24.8H
+        ld1             {v22.D}[0], [x0], x1
+        uaddw           v24.8H, v25.8H, v20.8B
+        uaddw2          v25.8H, v26.8H, v20.16B
+        ld1             {v22.D}[1], [x0], x1
+        sqxtun          v24.8B, v24.8H
+        sqxtun2         v24.16B, v25.8H
+        st1             {v23.D}[0], [x9], x1
+        uaddw           v25.8H, v27.8H, v21.8B
+        uaddw2          v26.8H, v28.8H, v21.16B
+        st1             {v23.D}[1], [x9], x1
+        sqxtun          v25.8B, v25.8H
+        sqxtun2         v25.16B, v26.8H
+        st1             {v24.D}[0], [x9], x1
+        uaddw           v26.8H, v29.8H, v22.8B
+        uaddw2          v27.8H, v30.8H, v22.16B
+        st1             {v24.D}[1], [x9], x1
+        sqxtun          v26.8B, v26.8H
+        sqxtun2         v26.16B, v27.8H
+        st1             {v25.D}[0], [x9], x1
+        st1             {v25.D}[1], [x9], x1
+        st1             {v26.D}[0], [x9], x1
+        st1             {v26.D}[1], [x9], x1
+
+        idct_end
+endfunc
+
+function ff_simple_idct_neon, export=1
+        idct_start      x0
+
+        mov             x2,  x0
+        idct_row4_neon  v24, v25, v26, v27, 1
+        idct_row4_neon  v28, v29, v30, v31, 2
+        sub             x2, x2, #128
+        bl              idct_col4_neon1
+
+        sshr            v1.8H, v7.8H, #COL_SHIFT-16
+        sshr            v2.8H, v16.8H, #COL_SHIFT-16
+        sshr            v3.8H, v17.8H, #COL_SHIFT-16
+        sshr            v4.8H, v18.8H, #COL_SHIFT-16
+
+        bl              idct_col4_neon2
+
+        sshr            v7.8H, v7.8H, #COL_SHIFT-16
+        sshr            v16.8H, v16.8H, #COL_SHIFT-16
+        sshr            v17.8H, v17.8H, #COL_SHIFT-16
+        sshr            v18.8H, v18.8H, #COL_SHIFT-16
+
+        zip1            v23.2D, v1.2D, v7.2D
+        zip2            v24.2D, v1.2D, v7.2D
+        st1             {v23.2D,v24.2D}, [x2], #32
+        zip1            v25.2D, v2.2D, v16.2D
+        zip2            v26.2D, v2.2D, v16.2D
+        st1             {v25.2D,v26.2D}, [x2], #32
+        zip1            v27.2D, v3.2D, v17.2D
+        zip2            v28.2D, v3.2D, v17.2D
+        st1             {v27.2D,v28.2D}, [x2], #32
+        zip1            v29.2D, v4.2D, v18.2D
+        zip2            v30.2D, v4.2D, v18.2D
+        st1             {v29.2D,v30.2D}, [x2], #32
+
+        idct_end
+endfunc
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/synth_filter_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/synth_filter_neon.S
index 65551cbff75..8fcd71f2525 100644
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/synth_filter_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/synth_filter_neon.S
@@ -50,7 +50,7 @@ function ff_synth_filter_float_neon, export=1
         add             x1,  x1,  x7,  lsl #2   // synth_buf
         sub             w8,  w7,  #32
         stp             x5,  x1,  [sp, #16]
-        bic             x7,  x7,  #63
+        and             x7,  x7,  #~63
         and             w8,  w8,  #511
         stp             x7,  x30, [sp, #32]
         str             w8,  [x2]
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/vc1dsp_init_aarch64.c b/mythtv/external/FFmpeg/libavcodec/aarch64/vc1dsp_init_aarch64.c
index e59e55ec886..13dfd74940a 100644
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/vc1dsp_init_aarch64.c
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vc1dsp_init_aarch64.c
@@ -25,14 +25,14 @@
 
 #include "config.h"
 
-void ff_put_vc1_chroma_mc8_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                int x, int y);
-void ff_avg_vc1_chroma_mc8_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                int x, int y);
-void ff_put_vc1_chroma_mc4_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                int x, int y);
-void ff_avg_vc1_chroma_mc4_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                int x, int y);
+void ff_put_vc1_chroma_mc8_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                int h, int x, int y);
+void ff_avg_vc1_chroma_mc8_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                int h, int x, int y);
+void ff_put_vc1_chroma_mc4_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                int h, int x, int y);
+void ff_avg_vc1_chroma_mc4_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                int h, int x, int y);
 
 av_cold void ff_vc1dsp_init_aarch64(VC1DSPContext *dsp)
 {
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init.h b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init.h
new file mode 100644
index 00000000000..9df1752c627
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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_AARCH64_VP9DSP_INIT_H
+#define AVCODEC_AARCH64_VP9DSP_INIT_H
+
+#include "libavcodec/vp9dsp.h"
+
+void ff_vp9dsp_init_10bpp_aarch64(VP9DSPContext *dsp);
+void ff_vp9dsp_init_12bpp_aarch64(VP9DSPContext *dsp);
+
+#endif /* AVCODEC_AARCH64_VP9DSP_INIT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/imdct15.h b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_10bpp_aarch64.c
similarity index 54%
rename from mythtv/external/FFmpeg/libavcodec/imdct15.h
rename to mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_10bpp_aarch64.c
index 1979aa76af0..0fa0d7f8c27 100644
--- a/mythtv/external/FFmpeg/libavcodec/imdct15.h
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_10bpp_aarch64.c
@@ -1,4 +1,6 @@
 /*
+ * Copyright (c) 2017 Google Inc.
+ *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
@@ -16,42 +18,6 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#ifndef AVCODEC_IMDCT15_H
-#define AVCODEC_IMDCT15_H
-
-#include <stddef.h>
-
-#include "avfft.h"
-
-typedef struct IMDCT15Context {
-    int fft_n;
-    int len2;
-    int len4;
-
-    FFTComplex *tmp;
-
-    FFTComplex *twiddle_exptab;
-
-    FFTComplex *exptab[6];
-
-    /**
-     * Calculate the middle half of the iMDCT
-     */
-    void (*imdct_half)(struct IMDCT15Context *s, float *dst, const float *src,
-                       ptrdiff_t src_stride, float scale);
-} IMDCT15Context;
-
-/**
- * Init an iMDCT of the length 2 * 15 * (2^N)
- */
-int ff_imdct15_init(IMDCT15Context **s, int N);
-
-/**
- * Free an iMDCT.
- */
-void ff_imdct15_uninit(IMDCT15Context **s);
-
-
-void ff_imdct15_init_aarch64(IMDCT15Context *s);
-
-#endif /* AVCODEC_IMDCT15_H */
+#define BPP 10
+#define INIT_FUNC ff_vp9dsp_init_10bpp_aarch64
+#include "vp9dsp_init_16bpp_aarch64_template.c"
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_12bpp_aarch64.c b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_12bpp_aarch64.c
new file mode 100644
index 00000000000..dae22324039
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_12bpp_aarch64.c
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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
+ */
+
+#define BPP 12
+#define INIT_FUNC ff_vp9dsp_init_12bpp_aarch64
+#include "vp9dsp_init_16bpp_aarch64_template.c"
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_16bpp_aarch64_template.c b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_16bpp_aarch64_template.c
new file mode 100644
index 00000000000..8dcfdeaaf7c
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_16bpp_aarch64_template.c
@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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 <stdint.h>
+
+#include "libavutil/attributes.h"
+#include "libavutil/internal.h"
+#include "libavutil/aarch64/cpu.h"
+#include "vp9dsp_init.h"
+
+#define declare_fpel(type, sz, suffix)                                          \
+void ff_vp9_##type##sz##suffix##_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                                      const uint8_t *src, ptrdiff_t src_stride, \
+                                      int h, int mx, int my)
+
+#define decl_mc_func(op, filter, dir, sz, bpp)                                                   \
+void ff_vp9_##op##_##filter##sz##_##dir##_##bpp##_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                                                       const uint8_t *src, ptrdiff_t src_stride, \
+                                                       int h, int mx, int my)
+
+#define define_8tap_2d_fn(op, filter, sz, bpp)                                      \
+static void op##_##filter##sz##_hv_##bpp##_neon(uint8_t *dst, ptrdiff_t dst_stride, \
+                                                const uint8_t *src,                 \
+                                                ptrdiff_t src_stride,               \
+                                                int h, int mx, int my)              \
+{                                                                                   \
+    LOCAL_ALIGNED_16(uint8_t, temp, [((1 + (sz < 64)) * sz + 8) * sz * 2]);         \
+    /* We only need h + 7 lines, but the horizontal filter assumes an               \
+     * even number of rows, so filter h + 8 lines here. */                          \
+    ff_vp9_put_##filter##sz##_h_##bpp##_neon(temp, 2 * sz,                          \
+                                             src - 3 * src_stride, src_stride,      \
+                                             h + 8, mx, 0);                         \
+    ff_vp9_##op##_##filter##sz##_v_##bpp##_neon(dst, dst_stride,                    \
+                                                temp + 3 * 2 * sz, 2 * sz,          \
+                                                h, 0, my);                          \
+}
+
+#define decl_filter_funcs(op, dir, sz, bpp)  \
+    decl_mc_func(op, regular, dir, sz, bpp); \
+    decl_mc_func(op, sharp,   dir, sz, bpp); \
+    decl_mc_func(op, smooth,  dir, sz, bpp)
+
+#define decl_mc_funcs(sz, bpp)           \
+    decl_filter_funcs(put, h,  sz, bpp); \
+    decl_filter_funcs(avg, h,  sz, bpp); \
+    decl_filter_funcs(put, v,  sz, bpp); \
+    decl_filter_funcs(avg, v,  sz, bpp); \
+    decl_filter_funcs(put, hv, sz, bpp); \
+    decl_filter_funcs(avg, hv, sz, bpp)
+
+#define ff_vp9_copy32_neon  ff_vp9_copy32_aarch64
+#define ff_vp9_copy64_neon  ff_vp9_copy64_aarch64
+#define ff_vp9_copy128_neon ff_vp9_copy128_aarch64
+
+declare_fpel(copy, 128, );
+declare_fpel(copy, 64,  );
+declare_fpel(copy, 32,  );
+declare_fpel(copy, 16,  );
+declare_fpel(copy, 8,   );
+declare_fpel(avg, 64, _16);
+declare_fpel(avg, 32, _16);
+declare_fpel(avg, 16, _16);
+declare_fpel(avg, 8,  _16);
+declare_fpel(avg, 4,  _16);
+
+decl_mc_funcs(64, BPP);
+decl_mc_funcs(32, BPP);
+decl_mc_funcs(16, BPP);
+decl_mc_funcs(8, BPP);
+decl_mc_funcs(4, BPP);
+
+#define define_8tap_2d_funcs(sz, bpp)        \
+    define_8tap_2d_fn(put, regular, sz, bpp) \
+    define_8tap_2d_fn(put, sharp,   sz, bpp) \
+    define_8tap_2d_fn(put, smooth,  sz, bpp) \
+    define_8tap_2d_fn(avg, regular, sz, bpp) \
+    define_8tap_2d_fn(avg, sharp,   sz, bpp) \
+    define_8tap_2d_fn(avg, smooth,  sz, bpp)
+
+define_8tap_2d_funcs(64, BPP)
+define_8tap_2d_funcs(32, BPP)
+define_8tap_2d_funcs(16, BPP)
+define_8tap_2d_funcs(8,  BPP)
+define_8tap_2d_funcs(4,  BPP)
+
+static av_cold void vp9dsp_mc_init_aarch64(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+#define init_fpel(idx1, idx2, sz, type, suffix)      \
+    dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_8TAP_SHARP  ][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_BILINEAR    ][idx2][0][0] = ff_vp9_##type##sz##suffix
+
+#define init_copy(idx, sz, suffix) \
+    init_fpel(idx, 0, sz, copy, suffix)
+
+#define init_avg(idx, sz, suffix) \
+    init_fpel(idx, 1, sz, avg,  suffix)
+
+#define init_copy_avg(idx, sz1, sz2) \
+    init_copy(idx, sz2, _neon);      \
+    init_avg (idx, sz1, _16_neon)
+
+    if (have_armv8(cpu_flags)) {
+        init_copy(0, 128, _aarch64);
+        init_copy(1, 64,  _aarch64);
+        init_copy(2, 32,  _aarch64);
+    }
+
+    if (have_neon(cpu_flags)) {
+#define init_mc_func(idx1, idx2, op, filter, fname, dir, mx, my, sz, pfx, bpp) \
+    dsp->mc[idx1][filter][idx2][mx][my] = pfx##op##_##fname##sz##_##dir##_##bpp##_neon
+
+#define init_mc_funcs(idx, dir, mx, my, sz, pfx, bpp)                                   \
+    init_mc_func(idx, 0, put, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx, bpp); \
+    init_mc_func(idx, 0, put, FILTER_8TAP_SHARP,   sharp,   dir, mx, my, sz, pfx, bpp); \
+    init_mc_func(idx, 0, put, FILTER_8TAP_SMOOTH,  smooth,  dir, mx, my, sz, pfx, bpp); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx, bpp); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_SHARP,   sharp,   dir, mx, my, sz, pfx, bpp); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_SMOOTH,  smooth,  dir, mx, my, sz, pfx, bpp)
+
+#define init_mc_funcs_dirs(idx, sz, bpp)            \
+    init_mc_funcs(idx, v,  0, 1, sz, ff_vp9_, bpp); \
+    init_mc_funcs(idx, h,  1, 0, sz, ff_vp9_, bpp); \
+    init_mc_funcs(idx, hv, 1, 1, sz,        , bpp)
+
+
+        init_avg(0, 64, _16_neon);
+        init_avg(1, 32, _16_neon);
+        init_avg(2, 16, _16_neon);
+        init_copy_avg(3, 8, 16);
+        init_copy_avg(4, 4, 8);
+
+        init_mc_funcs_dirs(0, 64, BPP);
+        init_mc_funcs_dirs(1, 32, BPP);
+        init_mc_funcs_dirs(2, 16, BPP);
+        init_mc_funcs_dirs(3, 8,  BPP);
+        init_mc_funcs_dirs(4, 4,  BPP);
+    }
+}
+
+#define define_itxfm2(type_a, type_b, sz, bpp)                                     \
+void ff_vp9_##type_a##_##type_b##_##sz##x##sz##_add_##bpp##_neon(uint8_t *_dst,    \
+                                                                 ptrdiff_t stride, \
+                                                                 int16_t *_block, int eob)
+#define define_itxfm(type_a, type_b, sz, bpp) define_itxfm2(type_a, type_b, sz, bpp)
+
+#define define_itxfm_funcs(sz, bpp)      \
+    define_itxfm(idct,  idct,  sz, bpp); \
+    define_itxfm(iadst, idct,  sz, bpp); \
+    define_itxfm(idct,  iadst, sz, bpp); \
+    define_itxfm(iadst, iadst, sz, bpp)
+
+define_itxfm_funcs(4,  BPP);
+define_itxfm_funcs(8,  BPP);
+define_itxfm_funcs(16, BPP);
+define_itxfm(idct, idct, 32, BPP);
+define_itxfm(iwht, iwht, 4,  BPP);
+
+
+static av_cold void vp9dsp_itxfm_init_aarch64(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+#define init_itxfm2(tx, sz, bpp)                                               \
+    dsp->itxfm_add[tx][DCT_DCT]   = ff_vp9_idct_idct_##sz##_add_##bpp##_neon;  \
+    dsp->itxfm_add[tx][DCT_ADST]  = ff_vp9_iadst_idct_##sz##_add_##bpp##_neon; \
+    dsp->itxfm_add[tx][ADST_DCT]  = ff_vp9_idct_iadst_##sz##_add_##bpp##_neon; \
+    dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_iadst_iadst_##sz##_add_##bpp##_neon
+#define init_itxfm(tx, sz, bpp) init_itxfm2(tx, sz, bpp)
+
+#define init_idct2(tx, nm, bpp)     \
+    dsp->itxfm_add[tx][DCT_DCT]   = \
+    dsp->itxfm_add[tx][ADST_DCT]  = \
+    dsp->itxfm_add[tx][DCT_ADST]  = \
+    dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_##nm##_add_##bpp##_neon
+#define init_idct(tx, nm, bpp) init_idct2(tx, nm, bpp)
+
+        init_itxfm(TX_4X4,   4x4,   BPP);
+        init_itxfm(TX_8X8,   8x8,   BPP);
+        init_itxfm(TX_16X16, 16x16, BPP);
+        init_idct(TX_32X32, idct_idct_32x32, BPP);
+        init_idct(4,        iwht_iwht_4x4,   BPP);
+    }
+}
+
+#define define_loop_filter(dir, wd, size, bpp) \
+void ff_vp9_loop_filter_##dir##_##wd##_##size##_##bpp##_neon(uint8_t *dst, ptrdiff_t stride, int E, int I, int H)
+
+#define define_loop_filters(wd, size, bpp) \
+    define_loop_filter(h, wd, size, bpp);  \
+    define_loop_filter(v, wd, size, bpp)
+
+define_loop_filters(4,  8,  BPP);
+define_loop_filters(8,  8,  BPP);
+define_loop_filters(16, 8,  BPP);
+
+define_loop_filters(16, 16, BPP);
+
+define_loop_filters(44, 16, BPP);
+define_loop_filters(48, 16, BPP);
+define_loop_filters(84, 16, BPP);
+define_loop_filters(88, 16, BPP);
+
+static av_cold void vp9dsp_loopfilter_init_aarch64(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+#define init_lpf_func_8(idx1, idx2, dir, wd, bpp) \
+    dsp->loop_filter_8[idx1][idx2] = ff_vp9_loop_filter_##dir##_##wd##_8_##bpp##_neon
+
+#define init_lpf_func_16(idx, dir, bpp) \
+    dsp->loop_filter_16[idx] = ff_vp9_loop_filter_##dir##_16_16_##bpp##_neon
+
+#define init_lpf_func_mix2(idx1, idx2, idx3, dir, wd, bpp) \
+    dsp->loop_filter_mix2[idx1][idx2][idx3] = ff_vp9_loop_filter_##dir##_##wd##_16_##bpp##_neon
+
+#define init_lpf_funcs_8_wd(idx, wd, bpp) \
+    init_lpf_func_8(idx, 0, h, wd, bpp);  \
+    init_lpf_func_8(idx, 1, v, wd, bpp)
+
+#define init_lpf_funcs_16(bpp)   \
+    init_lpf_func_16(0, h, bpp); \
+    init_lpf_func_16(1, v, bpp)
+
+#define init_lpf_funcs_mix2_wd(idx1, idx2, wd, bpp) \
+    init_lpf_func_mix2(idx1, idx2, 0, h, wd, bpp);  \
+    init_lpf_func_mix2(idx1, idx2, 1, v, wd, bpp)
+
+#define init_lpf_funcs_8(bpp)        \
+    init_lpf_funcs_8_wd(0, 4,  bpp); \
+    init_lpf_funcs_8_wd(1, 8,  bpp); \
+    init_lpf_funcs_8_wd(2, 16, bpp)
+
+#define init_lpf_funcs_mix2(bpp)           \
+    init_lpf_funcs_mix2_wd(0, 0, 44, bpp); \
+    init_lpf_funcs_mix2_wd(0, 1, 48, bpp); \
+    init_lpf_funcs_mix2_wd(1, 0, 84, bpp); \
+    init_lpf_funcs_mix2_wd(1, 1, 88, bpp)
+
+        init_lpf_funcs_8(BPP);
+        init_lpf_funcs_16(BPP);
+        init_lpf_funcs_mix2(BPP);
+    }
+}
+
+av_cold void INIT_FUNC(VP9DSPContext *dsp)
+{
+    vp9dsp_mc_init_aarch64(dsp);
+    vp9dsp_loopfilter_init_aarch64(dsp);
+    vp9dsp_itxfm_init_aarch64(dsp);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_aarch64.c b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_aarch64.c
new file mode 100644
index 00000000000..4c699759fe8
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9dsp_init_aarch64.c
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2016 Google Inc.
+ *
+ * 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 <stdint.h>
+
+#include "libavutil/attributes.h"
+#include "libavutil/internal.h"
+#include "libavutil/aarch64/cpu.h"
+#include "libavcodec/vp9dsp.h"
+#include "vp9dsp_init.h"
+
+#define declare_fpel(type, sz)                                          \
+void ff_vp9_##type##sz##_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                              const uint8_t *src, ptrdiff_t src_stride, \
+                              int h, int mx, int my)
+
+#define declare_copy_avg(sz) \
+    declare_fpel(copy, sz);  \
+    declare_fpel(avg , sz)
+
+#define decl_mc_func(op, filter, dir, sz)                                                \
+void ff_vp9_##op##_##filter##sz##_##dir##_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                                               const uint8_t *src, ptrdiff_t src_stride, \
+                                               int h, int mx, int my)
+
+#define define_8tap_2d_fn(op, filter, sz)                                         \
+static void op##_##filter##sz##_hv_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                                        const uint8_t *src, ptrdiff_t src_stride, \
+                                        int h, int mx, int my)                    \
+{                                                                                 \
+    LOCAL_ALIGNED_16(uint8_t, temp, [((1 + (sz < 64)) * sz + 8) * sz]);           \
+    /* We only need h + 7 lines, but the horizontal filter assumes an             \
+     * even number of rows, so filter h + 8 lines here. */                        \
+    ff_vp9_put_##filter##sz##_h_neon(temp, sz,                                    \
+                                     src - 3 * src_stride, src_stride,            \
+                                     h + 8, mx, 0);                               \
+    ff_vp9_##op##_##filter##sz##_v_neon(dst, dst_stride,                          \
+                                        temp + 3 * sz, sz,                        \
+                                        h, 0, my);                                \
+}
+
+#define decl_filter_funcs(op, dir, sz)  \
+    decl_mc_func(op, regular, dir, sz); \
+    decl_mc_func(op, sharp,   dir, sz); \
+    decl_mc_func(op, smooth,  dir, sz)
+
+#define decl_mc_funcs(sz)           \
+    decl_filter_funcs(put, h,  sz); \
+    decl_filter_funcs(avg, h,  sz); \
+    decl_filter_funcs(put, v,  sz); \
+    decl_filter_funcs(avg, v,  sz); \
+    decl_filter_funcs(put, hv, sz); \
+    decl_filter_funcs(avg, hv, sz)
+
+#define ff_vp9_copy32_neon ff_vp9_copy32_aarch64
+#define ff_vp9_copy64_neon ff_vp9_copy64_aarch64
+
+declare_copy_avg(64);
+declare_copy_avg(32);
+declare_copy_avg(16);
+declare_copy_avg(8);
+declare_copy_avg(4);
+
+decl_mc_funcs(64);
+decl_mc_funcs(32);
+decl_mc_funcs(16);
+decl_mc_funcs(8);
+decl_mc_funcs(4);
+
+#define define_8tap_2d_funcs(sz)        \
+    define_8tap_2d_fn(put, regular, sz) \
+    define_8tap_2d_fn(put, sharp,   sz) \
+    define_8tap_2d_fn(put, smooth,  sz) \
+    define_8tap_2d_fn(avg, regular, sz) \
+    define_8tap_2d_fn(avg, sharp,   sz) \
+    define_8tap_2d_fn(avg, smooth,  sz)
+
+define_8tap_2d_funcs(64)
+define_8tap_2d_funcs(32)
+define_8tap_2d_funcs(16)
+define_8tap_2d_funcs(8)
+define_8tap_2d_funcs(4)
+
+static av_cold void vp9dsp_mc_init_aarch64(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+#define init_fpel(idx1, idx2, sz, type, suffix)      \
+    dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_8TAP_SHARP  ][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_BILINEAR    ][idx2][0][0] = ff_vp9_##type##sz##suffix
+
+#define init_copy(idx, sz, suffix) \
+    init_fpel(idx, 0, sz, copy, suffix)
+
+#define init_avg(idx, sz, suffix) \
+    init_fpel(idx, 1, sz, avg,  suffix)
+
+#define init_copy_avg(idx, sz) \
+    init_copy(idx, sz, _neon); \
+    init_avg (idx, sz, _neon)
+
+    if (have_armv8(cpu_flags)) {
+        init_copy(0, 64, _aarch64);
+        init_copy(1, 32, _aarch64);
+    }
+
+    if (have_neon(cpu_flags)) {
+#define init_mc_func(idx1, idx2, op, filter, fname, dir, mx, my, sz, pfx) \
+    dsp->mc[idx1][filter][idx2][mx][my] = pfx##op##_##fname##sz##_##dir##_neon
+
+#define init_mc_funcs(idx, dir, mx, my, sz, pfx)                                   \
+    init_mc_func(idx, 0, put, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 0, put, FILTER_8TAP_SHARP,   sharp,   dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 0, put, FILTER_8TAP_SMOOTH,  smooth,  dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_SHARP,   sharp,   dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_SMOOTH,  smooth,  dir, mx, my, sz, pfx)
+
+#define init_mc_funcs_dirs(idx, sz)            \
+    init_mc_funcs(idx, h,  1, 0, sz, ff_vp9_); \
+    init_mc_funcs(idx, v,  0, 1, sz, ff_vp9_); \
+    init_mc_funcs(idx, hv, 1, 1, sz,)
+
+        init_avg(0, 64, _neon);
+        init_avg(1, 32, _neon);
+        init_copy_avg(2, 16);
+        init_copy_avg(3, 8);
+        init_copy_avg(4, 4);
+
+        init_mc_funcs_dirs(0, 64);
+        init_mc_funcs_dirs(1, 32);
+        init_mc_funcs_dirs(2, 16);
+        init_mc_funcs_dirs(3, 8);
+        init_mc_funcs_dirs(4, 4);
+    }
+}
+
+#define define_itxfm(type_a, type_b, sz)                                   \
+void ff_vp9_##type_a##_##type_b##_##sz##x##sz##_add_neon(uint8_t *_dst,    \
+                                                         ptrdiff_t stride, \
+                                                         int16_t *_block, int eob)
+
+#define define_itxfm_funcs(sz)      \
+    define_itxfm(idct,  idct,  sz); \
+    define_itxfm(iadst, idct,  sz); \
+    define_itxfm(idct,  iadst, sz); \
+    define_itxfm(iadst, iadst, sz)
+
+define_itxfm_funcs(4);
+define_itxfm_funcs(8);
+define_itxfm_funcs(16);
+define_itxfm(idct, idct, 32);
+define_itxfm(iwht, iwht, 4);
+
+
+static av_cold void vp9dsp_itxfm_init_aarch64(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+#define init_itxfm(tx, sz)                                             \
+    dsp->itxfm_add[tx][DCT_DCT]   = ff_vp9_idct_idct_##sz##_add_neon;  \
+    dsp->itxfm_add[tx][DCT_ADST]  = ff_vp9_iadst_idct_##sz##_add_neon; \
+    dsp->itxfm_add[tx][ADST_DCT]  = ff_vp9_idct_iadst_##sz##_add_neon; \
+    dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_iadst_iadst_##sz##_add_neon
+
+#define init_idct(tx, nm)           \
+    dsp->itxfm_add[tx][DCT_DCT]   = \
+    dsp->itxfm_add[tx][ADST_DCT]  = \
+    dsp->itxfm_add[tx][DCT_ADST]  = \
+    dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_##nm##_add_neon
+
+        init_itxfm(TX_4X4, 4x4);
+        init_itxfm(TX_8X8, 8x8);
+        init_itxfm(TX_16X16, 16x16);
+        init_idct(TX_32X32, idct_idct_32x32);
+        init_idct(4, iwht_iwht_4x4);
+    }
+}
+
+#define define_loop_filter(dir, wd, len) \
+void ff_vp9_loop_filter_##dir##_##wd##_##len##_neon(uint8_t *dst, ptrdiff_t stride, int E, int I, int H)
+
+#define define_loop_filters(wd, len) \
+    define_loop_filter(h, wd, len);  \
+    define_loop_filter(v, wd, len)
+
+define_loop_filters(4, 8);
+define_loop_filters(8, 8);
+define_loop_filters(16, 8);
+
+define_loop_filters(16, 16);
+
+define_loop_filters(44, 16);
+define_loop_filters(48, 16);
+define_loop_filters(84, 16);
+define_loop_filters(88, 16);
+
+static av_cold void vp9dsp_loopfilter_init_aarch64(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+        dsp->loop_filter_8[0][1] = ff_vp9_loop_filter_v_4_8_neon;
+        dsp->loop_filter_8[0][0] = ff_vp9_loop_filter_h_4_8_neon;
+        dsp->loop_filter_8[1][1] = ff_vp9_loop_filter_v_8_8_neon;
+        dsp->loop_filter_8[1][0] = ff_vp9_loop_filter_h_8_8_neon;
+        dsp->loop_filter_8[2][1] = ff_vp9_loop_filter_v_16_8_neon;
+        dsp->loop_filter_8[2][0] = ff_vp9_loop_filter_h_16_8_neon;
+
+        dsp->loop_filter_16[0] = ff_vp9_loop_filter_h_16_16_neon;
+        dsp->loop_filter_16[1] = ff_vp9_loop_filter_v_16_16_neon;
+
+        dsp->loop_filter_mix2[0][0][0] = ff_vp9_loop_filter_h_44_16_neon;
+        dsp->loop_filter_mix2[0][0][1] = ff_vp9_loop_filter_v_44_16_neon;
+        dsp->loop_filter_mix2[0][1][0] = ff_vp9_loop_filter_h_48_16_neon;
+        dsp->loop_filter_mix2[0][1][1] = ff_vp9_loop_filter_v_48_16_neon;
+        dsp->loop_filter_mix2[1][0][0] = ff_vp9_loop_filter_h_84_16_neon;
+        dsp->loop_filter_mix2[1][0][1] = ff_vp9_loop_filter_v_84_16_neon;
+        dsp->loop_filter_mix2[1][1][0] = ff_vp9_loop_filter_h_88_16_neon;
+        dsp->loop_filter_mix2[1][1][1] = ff_vp9_loop_filter_v_88_16_neon;
+    }
+}
+
+av_cold void ff_vp9dsp_init_aarch64(VP9DSPContext *dsp, int bpp)
+{
+    if (bpp == 10) {
+        ff_vp9dsp_init_10bpp_aarch64(dsp);
+        return;
+    } else if (bpp == 12) {
+        ff_vp9dsp_init_12bpp_aarch64(dsp);
+        return;
+    } else if (bpp != 8)
+        return;
+
+    vp9dsp_mc_init_aarch64(dsp);
+    vp9dsp_loopfilter_init_aarch64(dsp);
+    vp9dsp_itxfm_init_aarch64(dsp);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/vp9itxfm_16bpp_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9itxfm_16bpp_neon.S
new file mode 100644
index 00000000000..68296d9c40c
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9itxfm_16bpp_neon.S
@@ -0,0 +1,2017 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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/aarch64/asm.S"
+#include "neon.S"
+
+const itxfm4_coeffs, align=4
+        .short  11585, 0, 6270, 15137
+iadst4_coeffs:
+        .short  5283, 15212, 9929, 13377
+endconst
+
+const iadst8_coeffs, align=4
+        .short  16305, 1606, 14449, 7723, 10394, 12665, 4756, 15679
+idct_coeffs:
+        .short  11585, 0, 6270, 15137, 3196, 16069, 13623, 9102
+        .short  1606, 16305, 12665, 10394, 7723, 14449, 15679, 4756
+        .short  804, 16364, 12140, 11003, 7005, 14811, 15426, 5520
+        .short  3981, 15893, 14053, 8423, 9760, 13160, 16207, 2404
+endconst
+
+const iadst16_coeffs, align=4
+        .short  16364, 804, 15893, 3981, 11003, 12140, 8423, 14053
+        .short  14811, 7005, 13160, 9760, 5520, 15426, 2404, 16207
+endconst
+
+.macro transpose_4x4s r0, r1, r2, r3, r4, r5, r6, r7
+        trn1            \r4\().4s,  \r0\().4s,  \r1\().4s
+        trn2            \r5\().4s,  \r0\().4s,  \r1\().4s
+        trn1            \r6\().4s,  \r2\().4s,  \r3\().4s
+        trn2            \r7\().4s,  \r2\().4s,  \r3\().4s
+        trn1            \r0\().2d,  \r4\().2d,  \r6\().2d
+        trn2            \r2\().2d,  \r4\().2d,  \r6\().2d
+        trn1            \r1\().2d,  \r5\().2d,  \r7\().2d
+        trn2            \r3\().2d,  \r5\().2d,  \r7\().2d
+.endm
+
+// Transpose a 8x8 matrix of 32 bit elements, where each row is spread out
+// over two registers.
+.macro transpose_8x8s r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, t0, t1, t2, t3
+        transpose_4x4s  \r0,  \r2,  \r4,  \r6,  \t0, \t1, \t2, \t3
+        transpose_4x4s  \r9,  \r11, \r13, \r15, \t0, \t1, \t2, \t3
+
+        // Do 4x4 transposes of r1,r3,r5,r7 and r8,r10,r12,r14
+        // while swapping the two 4x4 matrices between each other
+
+        // First step of the 4x4 transpose of r1-r7, into t0-t3
+        trn1            \t0\().4s,  \r1\().4s,  \r3\().4s
+        trn2            \t1\().4s,  \r1\().4s,  \r3\().4s
+        trn1            \t2\().4s,  \r5\().4s,  \r7\().4s
+        trn2            \t3\().4s,  \r5\().4s,  \r7\().4s
+
+        // First step of the 4x4 transpose of r8-r12, into r1-r7
+        trn1            \r1\().4s,  \r8\().4s,  \r10\().4s
+        trn2            \r3\().4s,  \r8\().4s,  \r10\().4s
+        trn1            \r5\().4s,  \r12\().4s, \r14\().4s
+        trn2            \r7\().4s,  \r12\().4s, \r14\().4s
+
+        // Second step of the 4x4 transpose of r1-r7 (now in t0-r3), into r8-r12
+        trn1            \r8\().2d,  \t0\().2d,  \t2\().2d
+        trn2            \r12\().2d, \t0\().2d,  \t2\().2d
+        trn1            \r10\().2d, \t1\().2d,  \t3\().2d
+        trn2            \r14\().2d, \t1\().2d,  \t3\().2d
+
+        // Second step of the 4x4 transpose of r8-r12 (now in r1-r7), in place as far as possible
+        trn1            \t0\().2d,  \r1\().2d,  \r5\().2d
+        trn2            \r5\().2d,  \r1\().2d,  \r5\().2d
+        trn1            \t1\().2d,  \r3\().2d,  \r7\().2d
+        trn2            \r7\().2d,  \r3\().2d,  \r7\().2d
+
+        // Move the outputs of trn1 back in place
+        mov             \r1\().16b,  \t0\().16b
+        mov             \r3\().16b,  \t1\().16b
+.endm
+
+// out1 = ((in1 + in2) * d0[0] + (1 << 13)) >> 14
+// out2 = ((in1 - in2) * d0[0] + (1 << 13)) >> 14
+// in/out are .4s registers; this can do with 4 temp registers, but is
+// more efficient if 6 temp registers are available.
+.macro dmbutterfly0 out1, out2, in1, in2, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, neg=0
+.if \neg > 0
+        neg             \tmp4\().4s, v0.4s
+.endif
+        add             \tmp1\().4s, \in1\().4s,  \in2\().4s
+        sub             \tmp2\().4s, \in1\().4s,  \in2\().4s
+.if \neg > 0
+        smull           \tmp3\().2d, \tmp1\().2s, \tmp4\().s[0]
+        smull2          \tmp4\().2d, \tmp1\().4s, \tmp4\().s[0]
+.else
+        smull           \tmp3\().2d, \tmp1\().2s, v0.s[0]
+        smull2          \tmp4\().2d, \tmp1\().4s, v0.s[0]
+.endif
+.ifb \tmp5
+        rshrn           \out1\().2s, \tmp3\().2d, #14
+        rshrn2          \out1\().4s, \tmp4\().2d, #14
+        smull           \tmp3\().2d, \tmp2\().2s, v0.s[0]
+        smull2          \tmp4\().2d, \tmp2\().4s, v0.s[0]
+        rshrn           \out2\().2s, \tmp3\().2d, #14
+        rshrn2          \out2\().4s, \tmp4\().2d, #14
+.else
+        smull           \tmp5\().2d, \tmp2\().2s, v0.s[0]
+        smull2          \tmp6\().2d, \tmp2\().4s, v0.s[0]
+        rshrn           \out1\().2s, \tmp3\().2d, #14
+        rshrn2          \out1\().4s, \tmp4\().2d, #14
+        rshrn           \out2\().2s, \tmp5\().2d, #14
+        rshrn2          \out2\().4s, \tmp6\().2d, #14
+.endif
+.endm
+
+// Same as dmbutterfly0 above, but treating the input in in2 as zero,
+// writing the same output into both out1 and out2.
+.macro dmbutterfly0_h out1, out2, in1, in2, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6
+        smull           \tmp1\().2d, \in1\().2s,  v0.s[0]
+        smull2          \tmp2\().2d, \in1\().4s,  v0.s[0]
+        rshrn           \out1\().2s, \tmp1\().2d, #14
+        rshrn2          \out1\().4s, \tmp2\().2d, #14
+        rshrn           \out2\().2s, \tmp1\().2d, #14
+        rshrn2          \out2\().4s, \tmp2\().2d, #14
+.endm
+
+// out1,out2 = in1 * coef1 - in2 * coef2
+// out3,out4 = in1 * coef2 + in2 * coef1
+// out are 4 x .2d registers, in are 2 x .4s registers
+.macro dmbutterfly_l out1, out2, out3, out4, in1, in2, coef1, coef2
+        smull           \out1\().2d, \in1\().2s, \coef1
+        smull2          \out2\().2d, \in1\().4s, \coef1
+        smull           \out3\().2d, \in1\().2s, \coef2
+        smull2          \out4\().2d, \in1\().4s, \coef2
+        smlsl           \out1\().2d, \in2\().2s, \coef2
+        smlsl2          \out2\().2d, \in2\().4s, \coef2
+        smlal           \out3\().2d, \in2\().2s, \coef1
+        smlal2          \out4\().2d, \in2\().4s, \coef1
+.endm
+
+// inout1 = (inout1 * coef1 - inout2 * coef2 + (1 << 13)) >> 14
+// inout2 = (inout1 * coef2 + inout2 * coef1 + (1 << 13)) >> 14
+// inout are 2 x .4s registers
+.macro dmbutterfly inout1, inout2, coef1, coef2, tmp1, tmp2, tmp3, tmp4, neg=0
+        dmbutterfly_l   \tmp1, \tmp2, \tmp3, \tmp4, \inout1, \inout2, \coef1, \coef2
+.if \neg > 0
+        neg             \tmp3\().2d, \tmp3\().2d
+        neg             \tmp4\().2d, \tmp4\().2d
+.endif
+        rshrn           \inout1\().2s, \tmp1\().2d,  #14
+        rshrn2          \inout1\().4s, \tmp2\().2d,  #14
+        rshrn           \inout2\().2s, \tmp3\().2d,  #14
+        rshrn2          \inout2\().4s, \tmp4\().2d,  #14
+.endm
+
+// Same as dmbutterfly above, but treating the input in inout2 as zero
+.macro dmbutterfly_h1 inout1, inout2, coef1, coef2, tmp1, tmp2, tmp3, tmp4
+        smull           \tmp1\().2d, \inout1\().2s, \coef1
+        smull2          \tmp2\().2d, \inout1\().4s, \coef1
+        smull           \tmp3\().2d, \inout1\().2s, \coef2
+        smull2          \tmp4\().2d, \inout1\().4s, \coef2
+        rshrn           \inout1\().2s, \tmp1\().2d, #14
+        rshrn2          \inout1\().4s, \tmp2\().2d, #14
+        rshrn           \inout2\().2s, \tmp3\().2d, #14
+        rshrn2          \inout2\().4s, \tmp4\().2d, #14
+.endm
+
+// Same as dmbutterfly above, but treating the input in inout1 as zero
+.macro dmbutterfly_h2 inout1, inout2, coef1, coef2, tmp1, tmp2, tmp3, tmp4
+        smull           \tmp1\().2d, \inout2\().2s, \coef2
+        smull2          \tmp2\().2d, \inout2\().4s, \coef2
+        smull           \tmp3\().2d, \inout2\().2s, \coef1
+        smull2          \tmp4\().2d, \inout2\().4s, \coef1
+        neg             \tmp1\().2d, \tmp1\().2d
+        neg             \tmp2\().2d, \tmp2\().2d
+        rshrn           \inout2\().2s, \tmp3\().2d, #14
+        rshrn2          \inout2\().4s, \tmp4\().2d, #14
+        rshrn           \inout1\().2s, \tmp1\().2d, #14
+        rshrn2          \inout1\().4s, \tmp2\().2d, #14
+.endm
+
+.macro dsmull_h out1, out2, in, coef
+        smull           \out1\().2d, \in\().2s, \coef
+        smull2          \out2\().2d, \in\().4s, \coef
+.endm
+
+.macro drshrn_h out, in1, in2, shift
+        rshrn           \out\().2s, \in1\().2d, \shift
+        rshrn2          \out\().4s, \in2\().2d, \shift
+.endm
+
+
+// out1 = in1 + in2
+// out2 = in1 - in2
+.macro butterfly_4s out1, out2, in1, in2
+        add             \out1\().4s, \in1\().4s, \in2\().4s
+        sub             \out2\().4s, \in1\().4s, \in2\().4s
+.endm
+
+// out1 = in1 - in2
+// out2 = in1 + in2
+.macro butterfly_4s_r out1, out2, in1, in2
+        sub             \out1\().4s, \in1\().4s, \in2\().4s
+        add             \out2\().4s, \in1\().4s, \in2\().4s
+.endm
+
+// out1 = (in1,in2 + in3,in4 + (1 << 13)) >> 14
+// out2 = (in1,in2 - in3,in4 + (1 << 13)) >> 14
+// out are 2 x .4s registers, in are 4 x .2d registers
+.macro dbutterfly_n out1, out2, in1, in2, in3, in4, tmp1, tmp2, tmp3, tmp4
+        add             \tmp1\().2d, \in1\().2d, \in3\().2d
+        add             \tmp2\().2d, \in2\().2d, \in4\().2d
+        sub             \tmp3\().2d, \in1\().2d, \in3\().2d
+        sub             \tmp4\().2d, \in2\().2d, \in4\().2d
+        rshrn           \out1\().2s, \tmp1\().2d,  #14
+        rshrn2          \out1\().4s, \tmp2\().2d,  #14
+        rshrn           \out2\().2s, \tmp3\().2d,  #14
+        rshrn2          \out2\().4s, \tmp4\().2d,  #14
+.endm
+
+.macro iwht4_10 c0, c1, c2, c3
+        add             \c0\().4s, \c0\().4s, \c1\().4s
+        sub             v17.4s,    \c2\().4s, \c3\().4s
+        sub             v16.4s,    \c0\().4s, v17.4s
+        sshr            v16.4s,    v16.4s,    #1
+        sub             \c2\().4s, v16.4s,    \c1\().4s
+        sub             \c1\().4s, v16.4s,    \c3\().4s
+        add             \c3\().4s, v17.4s,    \c2\().4s
+        sub             \c0\().4s, \c0\().4s, \c1\().4s
+.endm
+
+.macro iwht4_12 c0, c1, c2, c3
+        iwht4_10        \c0, \c1, \c2, \c3
+.endm
+
+.macro idct4_10 c0, c1, c2, c3
+        mul             v22.4s,    \c1\().4s, v0.s[3]
+        mul             v20.4s,    \c1\().4s, v0.s[2]
+        add             v16.4s,    \c0\().4s, \c2\().4s
+        sub             v17.4s,    \c0\().4s, \c2\().4s
+        mla             v22.4s,    \c3\().4s, v0.s[2]
+        mul             v18.4s,    v16.4s,    v0.s[0]
+        mul             v24.4s,    v17.4s,    v0.s[0]
+        mls             v20.4s,    \c3\().4s, v0.s[3]
+        srshr           v22.4s,    v22.4s,    #14
+        srshr           v18.4s,    v18.4s,    #14
+        srshr           v24.4s,    v24.4s,    #14
+        srshr           v20.4s,    v20.4s,    #14
+        add             \c0\().4s, v18.4s,    v22.4s
+        sub             \c3\().4s, v18.4s,    v22.4s
+        add             \c1\().4s, v24.4s,    v20.4s
+        sub             \c2\().4s, v24.4s,    v20.4s
+.endm
+
+.macro idct4_12 c0, c1, c2, c3
+        smull           v22.2d,    \c1\().2s, v0.s[3]
+        smull2          v23.2d,    \c1\().4s, v0.s[3]
+        smull           v20.2d,    \c1\().2s, v0.s[2]
+        smull2          v21.2d,    \c1\().4s, v0.s[2]
+        add             v16.4s,    \c0\().4s, \c2\().4s
+        sub             v17.4s,    \c0\().4s, \c2\().4s
+        smlal           v22.2d,    \c3\().2s, v0.s[2]
+        smlal2          v23.2d,    \c3\().4s, v0.s[2]
+        smull           v18.2d,    v16.2s,    v0.s[0]
+        smull2          v19.2d,    v16.4s,    v0.s[0]
+        smull           v24.2d,    v17.2s,    v0.s[0]
+        smull2          v25.2d,    v17.4s,    v0.s[0]
+        smlsl           v20.2d,    \c3\().2s, v0.s[3]
+        smlsl2          v21.2d,    \c3\().4s, v0.s[3]
+        rshrn           v22.2s,    v22.2d,    #14
+        rshrn2          v22.4s,    v23.2d,    #14
+        rshrn           v18.2s,    v18.2d,    #14
+        rshrn2          v18.4s,    v19.2d,    #14
+        rshrn           v24.2s,    v24.2d,    #14
+        rshrn2          v24.4s,    v25.2d,    #14
+        rshrn           v20.2s,    v20.2d,    #14
+        rshrn2          v20.4s,    v21.2d,    #14
+        add             \c0\().4s, v18.4s,    v22.4s
+        sub             \c3\().4s, v18.4s,    v22.4s
+        add             \c1\().4s, v24.4s,    v20.4s
+        sub             \c2\().4s, v24.4s,    v20.4s
+.endm
+
+.macro iadst4_10 c0, c1, c2, c3
+        mul             v16.4s,    \c0\().4s, v1.s[0]
+        mla             v16.4s,    \c2\().4s, v1.s[1]
+        mla             v16.4s,    \c3\().4s, v1.s[2]
+        mul             v18.4s,    \c0\().4s, v1.s[2]
+        mls             v18.4s,    \c2\().4s, v1.s[0]
+        sub             \c0\().4s, \c0\().4s, \c2\().4s
+        mls             v18.4s,    \c3\().4s, v1.s[1]
+        add             \c0\().4s, \c0\().4s, \c3\().4s
+        mul             v22.4s,    \c1\().4s, v1.s[3]
+        mul             v20.4s,    \c0\().4s, v1.s[3]
+        add             v24.4s,    v16.4s,    v22.4s
+        add             v26.4s,    v18.4s,    v22.4s
+        srshr           \c0\().4s, v24.4s,    #14
+        add             v16.4s,    v16.4s,    v18.4s
+        srshr           \c1\().4s, v26.4s,    #14
+        sub             v16.4s,    v16.4s,    v22.4s
+        srshr           \c2\().4s, v20.4s,    #14
+        srshr           \c3\().4s, v16.4s,    #14
+.endm
+
+.macro iadst4_12 c0, c1, c2, c3
+        smull           v16.2d,    \c0\().2s, v1.s[0]
+        smull2          v17.2d,    \c0\().4s, v1.s[0]
+        smlal           v16.2d,    \c2\().2s, v1.s[1]
+        smlal2          v17.2d,    \c2\().4s, v1.s[1]
+        smlal           v16.2d,    \c3\().2s, v1.s[2]
+        smlal2          v17.2d,    \c3\().4s, v1.s[2]
+        smull           v18.2d,    \c0\().2s, v1.s[2]
+        smull2          v19.2d,    \c0\().4s, v1.s[2]
+        smlsl           v18.2d,    \c2\().2s, v1.s[0]
+        smlsl2          v19.2d,    \c2\().4s, v1.s[0]
+        sub             \c0\().4s, \c0\().4s, \c2\().4s
+        smlsl           v18.2d,    \c3\().2s, v1.s[1]
+        smlsl2          v19.2d,    \c3\().4s, v1.s[1]
+        add             \c0\().4s, \c0\().4s, \c3\().4s
+        smull           v22.2d,    \c1\().2s, v1.s[3]
+        smull2          v23.2d,    \c1\().4s, v1.s[3]
+        smull           v20.2d,    \c0\().2s, v1.s[3]
+        smull2          v21.2d,    \c0\().4s, v1.s[3]
+        add             v24.2d,    v16.2d,    v22.2d
+        add             v25.2d,    v17.2d,    v23.2d
+        add             v26.2d,    v18.2d,    v22.2d
+        add             v27.2d,    v19.2d,    v23.2d
+        rshrn           \c0\().2s, v24.2d,    #14
+        rshrn2          \c0\().4s, v25.2d,    #14
+        add             v16.2d,    v16.2d,    v18.2d
+        add             v17.2d,    v17.2d,    v19.2d
+        rshrn           \c1\().2s, v26.2d,    #14
+        rshrn2          \c1\().4s, v27.2d,    #14
+        sub             v16.2d,    v16.2d,    v22.2d
+        sub             v17.2d,    v17.2d,    v23.2d
+        rshrn           \c2\().2s, v20.2d,    #14
+        rshrn2          \c2\().4s, v21.2d,    #14
+        rshrn           \c3\().2s, v16.2d,    #14
+        rshrn2          \c3\().4s, v17.2d,    #14
+.endm
+
+// The public functions in this file have got the following signature:
+// void itxfm_add(uint8_t *dst, ptrdiff_t stride, int16_t *block, int eob);
+
+.macro itxfm_func4x4 txfm1, txfm2, bpp
+function ff_vp9_\txfm1\()_\txfm2\()_4x4_add_\bpp\()_neon, export=1
+.ifc \txfm1,\txfm2
+.ifc \txfm1,idct
+        movrel          x4,  itxfm4_coeffs
+        ld1             {v0.4h}, [x4]
+        sxtl            v0.4s,  v0.4h
+.endif
+.ifc \txfm1,iadst
+        movrel          x4,  iadst4_coeffs
+        ld1             {v0.d}[1], [x4]
+        sxtl2           v1.4s,  v0.8h
+.endif
+.else
+        movrel          x4,  itxfm4_coeffs
+        ld1             {v0.8h}, [x4]
+        sxtl2           v1.4s,  v0.8h
+        sxtl            v0.4s,  v0.4h
+.endif
+
+        movi            v30.4s, #0
+        movi            v31.4s, #0
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             w3,  #1
+        b.ne            1f
+        // DC-only for idct/idct
+        ld1             {v2.s}[0],  [x2]
+        smull           v2.2d,  v2.2s, v0.s[0]
+        rshrn           v2.2s,  v2.2d, #14
+        smull           v2.2d,  v2.2s, v0.s[0]
+        rshrn           v2.2s,  v2.2d, #14
+        st1             {v31.s}[0], [x2]
+        dup             v4.4s,  v2.s[0]
+        mov             v5.16b, v4.16b
+        mov             v6.16b, v4.16b
+        mov             v7.16b, v4.16b
+        b               2f
+.endif
+
+1:
+        ld1             {v4.4s,v5.4s,v6.4s,v7.4s},  [x2]
+        st1             {v30.4s,v31.4s}, [x2], #32
+
+.ifc \txfm1,iwht
+        sshr            v4.4s,  v4.4s,  #2
+        sshr            v5.4s,  v5.4s,  #2
+        sshr            v6.4s,  v6.4s,  #2
+        sshr            v7.4s,  v7.4s,  #2
+.endif
+
+        \txfm1\()4_\bpp v4,  v5,  v6,  v7
+
+        st1             {v30.4s,v31.4s}, [x2], #32
+        // Transpose 4x4 with 32 bit elements
+        transpose_4x4s  v4,  v5,  v6,  v7,  v16, v17, v18, v19
+
+        \txfm2\()4_\bpp v4,  v5,  v6,  v7
+2:
+        mvni            v31.8h, #((0xff << (\bpp - 8)) & 0xff), lsl #8
+        ld1             {v0.4h},   [x0], x1
+        ld1             {v1.4h},   [x0], x1
+.ifnc \txfm1,iwht
+        srshr           v4.4s,  v4.4s,  #4
+        srshr           v5.4s,  v5.4s,  #4
+        srshr           v6.4s,  v6.4s,  #4
+        srshr           v7.4s,  v7.4s,  #4
+.endif
+        uaddw           v4.4s,  v4.4s,  v0.4h
+        uaddw           v5.4s,  v5.4s,  v1.4h
+        ld1             {v2.4h},   [x0], x1
+        ld1             {v3.4h},   [x0], x1
+        sqxtun          v0.4h,  v4.4s
+        sqxtun2         v0.8h,  v5.4s
+        sub             x0,  x0,  x1, lsl #2
+
+        uaddw           v6.4s,  v6.4s,  v2.4h
+        umin            v0.8h,  v0.8h,  v31.8h
+        uaddw           v7.4s,  v7.4s,  v3.4h
+        st1             {v0.4h},   [x0], x1
+        sqxtun          v2.4h,  v6.4s
+        sqxtun2         v2.8h,  v7.4s
+        umin            v2.8h,  v2.8h,  v31.8h
+
+        st1             {v0.d}[1], [x0], x1
+        st1             {v2.4h},   [x0], x1
+        st1             {v2.d}[1], [x0], x1
+
+        ret
+endfunc
+.endm
+
+.macro itxfm_funcs4x4 bpp
+itxfm_func4x4 idct,  idct,  \bpp
+itxfm_func4x4 iadst, idct,  \bpp
+itxfm_func4x4 idct,  iadst, \bpp
+itxfm_func4x4 iadst, iadst, \bpp
+itxfm_func4x4 iwht,  iwht,  \bpp
+.endm
+
+itxfm_funcs4x4 10
+itxfm_funcs4x4 12
+
+function idct8x8_dc_add_neon
+        movrel          x4,  idct_coeffs
+        ld1             {v0.4h}, [x4]
+
+        movi            v1.4h,  #0
+        sxtl            v0.4s,  v0.4h
+
+        ld1             {v2.s}[0],  [x2]
+        smull           v2.2d,  v2.2s,  v0.s[0]
+        rshrn           v2.2s,  v2.2d,  #14
+        smull           v2.2d,  v2.2s,  v0.s[0]
+        rshrn           v2.2s,  v2.2d,  #14
+        st1             {v1.s}[0],  [x2]
+        dup             v2.4s,  v2.s[0]
+
+        srshr           v2.4s,  v2.4s,  #5
+
+        mov             x4,  #8
+        mov             x3,  x0
+        dup             v31.8h, w5
+1:
+        // Loop to add the constant from v2 into all 8x8 outputs
+        subs            x4,  x4,  #2
+        ld1             {v3.8h},  [x0], x1
+        ld1             {v4.8h},  [x0], x1
+        uaddw           v16.4s, v2.4s,  v3.4h
+        uaddw2          v17.4s, v2.4s,  v3.8h
+        uaddw           v18.4s, v2.4s,  v4.4h
+        uaddw2          v19.4s, v2.4s,  v4.8h
+        sqxtun          v3.4h,  v16.4s
+        sqxtun2         v3.8h,  v17.4s
+        sqxtun          v4.4h,  v18.4s
+        sqxtun2         v4.8h,  v19.4s
+        umin            v3.8h,  v3.8h,  v31.8h
+        umin            v4.8h,  v4.8h,  v31.8h
+        st1             {v3.8h},  [x3], x1
+        st1             {v4.8h},  [x3], x1
+        b.ne            1b
+
+        ret
+endfunc
+
+.macro idct8 r0, r1, r2, r3, r4, r5, r6, r7, t0, t1, t2, t3, t4, t5
+        dmbutterfly0    \r0, \r4, \r0, \r4, \t0, \t1, \t2, \t3, \t4, \t5 // r0 = t0a, r4 = t1a
+        dmbutterfly     \r2, \r6, v0.s[2], v0.s[3], \t0, \t1, \t2, \t3   // r2 = t2a, r6 = t3a
+        dmbutterfly     \r1, \r7, v1.s[0], v1.s[1], \t0, \t1, \t2, \t3   // r1 = t4a, r7 = t7a
+        dmbutterfly     \r5, \r3, v1.s[2], v1.s[3], \t0, \t1, \t2, \t3   // r5 = t5a, r3 = t6a
+
+        butterfly_4s    \t0, \t1, \r0, \r6 // t0 = t0, t1 = t3
+        butterfly_4s    \t2, \r5, \r1, \r5 // t2 = t4, r5 = t5a
+        butterfly_4s    \t3, \r6, \r7, \r3 // t3 = t7, r6 = t6a
+        butterfly_4s    \r7, \r4, \r4, \r2 // r7 = t1, r4 = t2
+
+        dmbutterfly0    \r6, \r5, \r6, \r5, \r0, \r1, \r2, \r3, \t4, \t5 // r6 = t6, r5 = t5
+
+        butterfly_4s    \r1, \r6, \r7, \r6 // r1 = out[1], r6 = out[6]
+        butterfly_4s    \r0, \r7, \t0, \t3 // r0 = out[0], r7 = out[7]
+        butterfly_4s    \r2, \r5, \r4, \r5 // r2 = out[2], r5 = out[5]
+        butterfly_4s    \r3, \r4, \t1, \t2 // r3 = out[3], r4 = out[4]
+.endm
+
+.macro iadst8 r0, r1, r2, r3, r4, r5, r6, r7, t0, t1, t2, t3, t4, t5
+        dmbutterfly_l   \t2, \t3, \t0, \t1, \r7, \r0, v2.s[1], v2.s[0]   // t2,t3 = t1a, t0,t1 = t0a
+        dmbutterfly_l   \r0, \r7, \t4, \t5, \r3, \r4, v3.s[1], v3.s[0]   // r0,r7 = t5a, t4,t5 = t4a
+
+        dbutterfly_n    \r3, \t0, \t0, \t1, \t4, \t5, \r3, \r4, \t0, \t1 // r3 = t0, t0 = t4
+        dbutterfly_n    \r4, \t1, \t2, \t3, \r0, \r7, \r4, \t1, \t4, \t5 // r4 = t1, t1 = t5
+
+        dmbutterfly_l   \t4, \t5, \t2, \t3, \r5, \r2, v2.s[3], v2.s[2]   // t4,t5 = t3a, t2,t3 = t2a
+        dmbutterfly_l   \r2, \r5, \r0, \r7, \r1, \r6, v3.s[3], v3.s[2]   // r2,r5 = t7a, r0,r7 = t6a
+
+        dbutterfly_n    \r1, \t2, \t2, \t3, \r0, \r7, \r1, \r6, \t2, \t3 // r1 = t2, t2 = t6
+        dbutterfly_n    \r0, \t4, \t4, \t5, \r2, \r5, \r0, \r7, \t4, \t5 // r0 = t3, t4 = t7
+
+        butterfly_4s    \r7, \r4, \r4, \r0   // r7 = -out[7], r4 = t3
+        neg             \r7\().4s, \r7\().4s // r7 = out[7]
+        butterfly_4s    \r0, \r1, \r3, \r1   // r0 = out[0],  r1 = t2
+
+        dmbutterfly_l   \r2, \r3, \t3, \t5, \t0, \t1, v0.s[2], v0.s[3]   // r2,r3 = t5a, t3,t5 = t4a
+        dmbutterfly_l   \t0, \t1, \r5, \r6, \t4, \t2, v0.s[3], v0.s[2]   // t0,t1 = t6a, r5,r6 = t7a
+
+        dbutterfly_n    \r6, \t2, \r2, \r3, \r5, \r6, \t2, \t4, \r2, \r3 // r6 = out[6],  t2 = t7
+
+        dmbutterfly0    \r3, \r4, \r1, \r4, \t4, \r5, \r1, \r2           // r3 = -out[3], r4 = out[4]
+        neg             \r3\().4s, \r3\().4s  // r3 = out[3]
+
+        dbutterfly_n    \r1, \t0, \t3, \t5, \t0, \t1, \r1, \r2, \t0, \t1 // r1 = -out[1], t0 = t6
+        neg             \r1\().4s, \r1\().4s  // r1 = out[1]
+
+        dmbutterfly0    \r2, \r5, \t0, \t2, \t1, \t3, \t4, \t5           // r2 = out[2],  r5 = -out[5]
+        neg             \r5\().4s, \r5\().4s  // r5 = out[5]
+.endm
+
+
+.macro itxfm_func8x8 txfm1, txfm2
+function vp9_\txfm1\()_\txfm2\()_8x8_add_16_neon
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             w3,  #1
+        b.eq            idct8x8_dc_add_neon
+.endif
+        // The iadst also uses a few coefficients from
+        // idct, so those always need to be loaded.
+.ifc \txfm1\()_\txfm2,idct_idct
+        movrel          x4,  idct_coeffs
+.else
+        movrel          x4,  iadst8_coeffs
+        ld1             {v1.8h}, [x4], #16
+        stp             d8,  d9,  [sp, #-0x10]!
+        sxtl2           v3.4s,  v1.8h
+        sxtl            v2.4s,  v1.4h
+.endif
+        ld1             {v0.8h}, [x4]
+        sxtl2           v1.4s,  v0.8h
+        sxtl            v0.4s,  v0.4h
+
+        movi            v4.4s, #0
+        movi            v5.4s, #0
+        movi            v6.4s, #0
+        movi            v7.4s, #0
+
+1:
+        ld1             {v16.4s,v17.4s,v18.4s,v19.4s},  [x2], #64
+        ld1             {v20.4s,v21.4s,v22.4s,v23.4s},  [x2], #64
+        ld1             {v24.4s,v25.4s,v26.4s,v27.4s},  [x2], #64
+        ld1             {v28.4s,v29.4s,v30.4s,v31.4s},  [x2], #64
+        sub             x2,  x2,  #256
+        st1             {v4.4s,v5.4s,v6.4s,v7.4s},      [x2], #64
+        st1             {v4.4s,v5.4s,v6.4s,v7.4s},      [x2], #64
+        st1             {v4.4s,v5.4s,v6.4s,v7.4s},      [x2], #64
+        st1             {v4.4s,v5.4s,v6.4s,v7.4s},      [x2], #64
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        idct8           v16, v18, v20, v22, v24, v26, v28, v30, v2,  v3,  v4,  v5,  v6,  v7
+        idct8           v17, v19, v21, v23, v25, v27, v29, v31, v2,  v3,  v4,  v5,  v6,  v7
+.else
+        \txfm1\()8      v16, v18, v20, v22, v24, v26, v28, v30, v4,  v5,  v6,  v7,  v8,  v9
+        \txfm1\()8      v17, v19, v21, v23, v25, v27, v29, v31, v4,  v5,  v6,  v7,  v8,  v9
+.endif
+
+        // Transpose 8x8 with 16 bit elements
+        transpose_8x8s  v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v4, v5, v6, v7
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        idct8           v16, v18, v20, v22, v24, v26, v28, v30, v2,  v3,  v4,  v5,  v6,  v7
+        idct8           v17, v19, v21, v23, v25, v27, v29, v31, v2,  v3,  v4,  v5,  v6,  v7
+.else
+        \txfm2\()8      v16, v18, v20, v22, v24, v26, v28, v30, v4,  v5,  v6,  v7,  v8,  v9
+        \txfm2\()8      v17, v19, v21, v23, v25, v27, v29, v31, v4,  v5,  v6,  v7,  v8,  v9
+.endif
+2:
+        mov             x3,  x0
+        // Add into the destination
+        ld1             {v0.8h},  [x0], x1
+        srshr           v16.4s, v16.4s, #5
+        srshr           v17.4s, v17.4s, #5
+        ld1             {v1.8h},  [x0], x1
+        srshr           v18.4s, v18.4s, #5
+        srshr           v19.4s, v19.4s, #5
+        ld1             {v2.8h},  [x0], x1
+        srshr           v20.4s, v20.4s, #5
+        srshr           v21.4s, v21.4s, #5
+        uaddw           v16.4s, v16.4s, v0.4h
+        uaddw2          v17.4s, v17.4s, v0.8h
+        ld1             {v3.8h},  [x0], x1
+        srshr           v22.4s, v22.4s, #5
+        srshr           v23.4s, v23.4s, #5
+        uaddw           v18.4s, v18.4s, v1.4h
+        uaddw2          v19.4s, v19.4s, v1.8h
+        ld1             {v4.8h},  [x0], x1
+        srshr           v24.4s, v24.4s, #5
+        srshr           v25.4s, v25.4s, #5
+        uaddw           v20.4s, v20.4s, v2.4h
+        uaddw2          v21.4s, v21.4s, v2.8h
+        sqxtun          v0.4h,  v16.4s
+        sqxtun2         v0.8h,  v17.4s
+        dup             v16.8h, w5
+        ld1             {v5.8h},  [x0], x1
+        srshr           v26.4s, v26.4s, #5
+        srshr           v27.4s, v27.4s, #5
+        uaddw           v22.4s, v22.4s, v3.4h
+        uaddw2          v23.4s, v23.4s, v3.8h
+        sqxtun          v1.4h,  v18.4s
+        sqxtun2         v1.8h,  v19.4s
+        umin            v0.8h,  v0.8h,  v16.8h
+        ld1             {v6.8h},  [x0], x1
+        srshr           v28.4s, v28.4s, #5
+        srshr           v29.4s, v29.4s, #5
+        uaddw           v24.4s, v24.4s, v4.4h
+        uaddw2          v25.4s, v25.4s, v4.8h
+        sqxtun          v2.4h,  v20.4s
+        sqxtun2         v2.8h,  v21.4s
+        umin            v1.8h,  v1.8h,  v16.8h
+        ld1             {v7.8h},  [x0], x1
+        srshr           v30.4s, v30.4s, #5
+        srshr           v31.4s, v31.4s, #5
+        uaddw           v26.4s, v26.4s, v5.4h
+        uaddw2          v27.4s, v27.4s, v5.8h
+        sqxtun          v3.4h,  v22.4s
+        sqxtun2         v3.8h,  v23.4s
+        umin            v2.8h,  v2.8h,  v16.8h
+
+        st1             {v0.8h},  [x3], x1
+        uaddw           v28.4s, v28.4s, v6.4h
+        uaddw2          v29.4s, v29.4s, v6.8h
+        st1             {v1.8h},  [x3], x1
+        sqxtun          v4.4h,  v24.4s
+        sqxtun2         v4.8h,  v25.4s
+        umin            v3.8h,  v3.8h,  v16.8h
+        st1             {v2.8h},  [x3], x1
+        uaddw           v30.4s, v30.4s, v7.4h
+        uaddw2          v31.4s, v31.4s, v7.8h
+        st1             {v3.8h},  [x3], x1
+        sqxtun          v5.4h,  v26.4s
+        sqxtun2         v5.8h,  v27.4s
+        umin            v4.8h,  v4.8h,  v16.8h
+        st1             {v4.8h},  [x3], x1
+        sqxtun          v6.4h,  v28.4s
+        sqxtun2         v6.8h,  v29.4s
+        umin            v5.8h,  v5.8h,  v16.8h
+        st1             {v5.8h},  [x3], x1
+        sqxtun          v7.4h,  v30.4s
+        sqxtun2         v7.8h,  v31.4s
+        umin            v6.8h,  v6.8h,  v16.8h
+
+        st1             {v6.8h},  [x3], x1
+        umin            v7.8h,  v7.8h,  v16.8h
+        st1             {v7.8h},  [x3], x1
+
+.ifnc \txfm1\()_\txfm2,idct_idct
+        ldp             d8,  d9,  [sp], 0x10
+.endif
+        ret
+endfunc
+
+function ff_vp9_\txfm1\()_\txfm2\()_8x8_add_10_neon, export=1
+        mov             x5,  #0x03ff
+        b               vp9_\txfm1\()_\txfm2\()_8x8_add_16_neon
+endfunc
+
+function ff_vp9_\txfm1\()_\txfm2\()_8x8_add_12_neon, export=1
+        mov             x5,  #0x0fff
+        b               vp9_\txfm1\()_\txfm2\()_8x8_add_16_neon
+endfunc
+.endm
+
+itxfm_func8x8 idct,  idct
+itxfm_func8x8 iadst, idct
+itxfm_func8x8 idct,  iadst
+itxfm_func8x8 iadst, iadst
+
+
+function idct16x16_dc_add_neon
+        movrel          x4,  idct_coeffs
+        ld1             {v0.4h}, [x4]
+        sxtl            v0.4s,  v0.4h
+
+        movi            v1.4h,  #0
+
+        ld1             {v2.s}[0],  [x2]
+        smull           v2.2d,  v2.2s,  v0.s[0]
+        rshrn           v2.2s,  v2.2d,  #14
+        smull           v2.2d,  v2.2s,  v0.s[0]
+        rshrn           v2.2s,  v2.2d,  #14
+        st1             {v1.s}[0],  [x2]
+        dup             v2.4s,  v2.s[0]
+
+        srshr           v0.4s,  v2.4s,  #6
+
+        mov             x3, x0
+        mov             x4, #16
+        dup             v31.8h, w13
+1:
+        // Loop to add the constant from v2 into all 16x16 outputs
+        subs            x4,  x4,  #2
+        ld1             {v1.8h,v2.8h},  [x0], x1
+        uaddw           v16.4s, v0.4s,  v1.4h
+        uaddw2          v17.4s, v0.4s,  v1.8h
+        ld1             {v3.8h,v4.8h},  [x0], x1
+        uaddw           v18.4s, v0.4s,  v2.4h
+        uaddw2          v19.4s, v0.4s,  v2.8h
+        uaddw           v20.4s, v0.4s,  v3.4h
+        uaddw2          v21.4s, v0.4s,  v3.8h
+        uaddw           v22.4s, v0.4s,  v4.4h
+        uaddw2          v23.4s, v0.4s,  v4.8h
+        sqxtun          v1.4h,  v16.4s
+        sqxtun2         v1.8h,  v17.4s
+        sqxtun          v2.4h,  v18.4s
+        sqxtun2         v2.8h,  v19.4s
+        sqxtun          v3.4h,  v20.4s
+        sqxtun2         v3.8h,  v21.4s
+        sqxtun          v4.4h,  v22.4s
+        sqxtun2         v4.8h,  v23.4s
+        umin            v1.8h,  v1.8h,  v31.8h
+        umin            v2.8h,  v2.8h,  v31.8h
+        st1             {v1.8h,v2.8h},  [x3], x1
+        umin            v3.8h,  v3.8h,  v31.8h
+        umin            v4.8h,  v4.8h,  v31.8h
+        st1             {v3.8h,v4.8h},  [x3], x1
+        b.ne            1b
+
+        ret
+endfunc
+
+.macro idct16_end
+        butterfly_4s    v18, v7,  v4,  v7                // v18 = t0a,  v7  = t7a
+        butterfly_4s    v19, v22, v5,  v22               // v19 = t1a,  v22 = t6
+        butterfly_4s    v4,  v26, v20, v26               // v4  = t2a,  v26 = t5
+        butterfly_4s    v5,  v6,  v28, v6                // v5  = t3a,  v6  = t4
+        butterfly_4s    v20, v28, v16, v24               // v20 = t8a,  v28 = t11a
+        butterfly_4s    v24, v21, v23, v21               // v24 = t9,   v21 = t10
+        butterfly_4s    v23, v27, v25, v27               // v23 = t14,  v27 = t13
+        butterfly_4s    v25, v29, v29, v17               // v25 = t15a, v29 = t12a
+
+        dmbutterfly0    v8,  v9,  v27, v21, v8,  v9,  v16, v17, v30, v31 // v8  = t13a, v9  = t10a
+        dmbutterfly0    v28, v27, v29, v28, v21, v29, v16, v17, v30, v31 // v28 = t12,  v27 = t11
+
+        butterfly_4s    v16, v31, v18, v25               // v16 = out[0], v31 = out[15]
+        butterfly_4s    v17, v30, v19, v23               // v17 = out[1], v30 = out[14]
+        butterfly_4s_r  v25, v22, v22, v24               // v25 = out[9], v22 = out[6]
+        butterfly_4s    v23, v24, v7,  v20               // v23 = out[7], v24 = out[8]
+        butterfly_4s    v18, v29, v4,  v8                // v18 = out[2], v29 = out[13]
+        butterfly_4s    v19, v28, v5,  v28               // v19 = out[3], v28 = out[12]
+        butterfly_4s    v20, v27, v6,  v27               // v20 = out[4], v27 = out[11]
+        butterfly_4s    v21, v26, v26, v9                // v21 = out[5], v26 = out[10]
+        ret
+.endm
+
+function idct16
+        dmbutterfly0    v16, v24, v16, v24, v4, v5, v6, v7, v8, v9 // v16 = t0a,  v24 = t1a
+        dmbutterfly     v20, v28, v0.s[2], v0.s[3], v4, v5, v6, v7 // v20 = t2a,  v28 = t3a
+        dmbutterfly     v18, v30, v1.s[0], v1.s[1], v4, v5, v6, v7 // v18 = t4a,  v30 = t7a
+        dmbutterfly     v26, v22, v1.s[2], v1.s[3], v4, v5, v6, v7 // v26 = t5a,  v22 = t6a
+        dmbutterfly     v17, v31, v2.s[0], v2.s[1], v4, v5, v6, v7 // v17 = t8a,  v31 = t15a
+        dmbutterfly     v25, v23, v2.s[2], v2.s[3], v4, v5, v6, v7 // v25 = t9a,  v23 = t14a
+        dmbutterfly     v21, v27, v3.s[0], v3.s[1], v4, v5, v6, v7 // v21 = t10a, v27 = t13a
+        dmbutterfly     v29, v19, v3.s[2], v3.s[3], v4, v5, v6, v7 // v29 = t11a, v19 = t12a
+
+        butterfly_4s    v4,  v28, v16, v28               // v4  = t0,   v28 = t3
+        butterfly_4s    v5,  v20, v24, v20               // v5  = t1,   v20 = t2
+        butterfly_4s    v6,  v26, v18, v26               // v6  = t4,   v26 = t5
+        butterfly_4s    v7,  v22, v30, v22               // v7  = t7,   v22 = t6
+        butterfly_4s    v16, v25, v17, v25               // v16 = t8,   v25 = t9
+        butterfly_4s    v24, v21, v29, v21               // v24 = t11,  v21 = t10
+        butterfly_4s    v17, v27, v19, v27               // v17 = t12,  v27 = t13
+        butterfly_4s    v29, v23, v31, v23               // v29 = t15,  v23 = t14
+
+        dmbutterfly0    v22, v26, v22, v26, v8, v9, v18, v19, v30, v31        // v22 = t6a,  v26 = t5a
+        dmbutterfly     v23, v25, v0.s[2], v0.s[3], v18, v19, v30, v31        // v23 = t9a,  v25 = t14a
+        dmbutterfly     v27, v21, v0.s[2], v0.s[3], v18, v19, v30, v31, neg=1 // v27 = t13a, v21 = t10a
+        idct16_end
+endfunc
+
+function idct16_half
+        dmbutterfly0_h  v16, v24, v16, v24, v4, v5, v6, v7, v8, v9 // v16 = t0a,  v24 = t1a
+        dmbutterfly_h1  v20, v28, v0.s[2], v0.s[3], v4, v5, v6, v7 // v20 = t2a,  v28 = t3a
+        dmbutterfly_h1  v18, v30, v1.s[0], v1.s[1], v4, v5, v6, v7 // v18 = t4a,  v30 = t7a
+        dmbutterfly_h2  v26, v22, v1.s[2], v1.s[3], v4, v5, v6, v7 // v26 = t5a,  v22 = t6a
+        dmbutterfly_h1  v17, v31, v2.s[0], v2.s[1], v4, v5, v6, v7 // v17 = t8a,  v31 = t15a
+        dmbutterfly_h2  v25, v23, v2.s[2], v2.s[3], v4, v5, v6, v7 // v25 = t9a,  v23 = t14a
+        dmbutterfly_h1  v21, v27, v3.s[0], v3.s[1], v4, v5, v6, v7 // v21 = t10a, v27 = t13a
+        dmbutterfly_h2  v29, v19, v3.s[2], v3.s[3], v4, v5, v6, v7 // v29 = t11a, v19 = t12a
+
+        butterfly_4s    v4,  v28, v16, v28               // v4  = t0,   v28 = t3
+        butterfly_4s    v5,  v20, v24, v20               // v5  = t1,   v20 = t2
+        butterfly_4s    v6,  v26, v18, v26               // v6  = t4,   v26 = t5
+        butterfly_4s    v7,  v22, v30, v22               // v7  = t7,   v22 = t6
+        butterfly_4s    v16, v25, v17, v25               // v16 = t8,   v25 = t9
+        butterfly_4s    v24, v21, v29, v21               // v24 = t11,  v21 = t10
+        butterfly_4s    v17, v27, v19, v27               // v17 = t12,  v27 = t13
+        butterfly_4s    v29, v23, v31, v23               // v29 = t15,  v23 = t14
+
+        dmbutterfly0    v22, v26, v22, v26, v8, v9, v18, v19, v30, v31        // v22 = t6a,  v26 = t5a
+        dmbutterfly     v23, v25, v0.s[2], v0.s[3], v18, v19, v30, v31        // v23 = t9a,  v25 = t14a
+        dmbutterfly     v27, v21, v0.s[2], v0.s[3], v18, v19, v30, v31, neg=1 // v27 = t13a, v21 = t10a
+        idct16_end
+endfunc
+
+function idct16_quarter
+        dsmull_h        v24, v25, v19, v3.s[3]
+        dsmull_h        v4,  v5,  v17, v2.s[0]
+        dsmull_h        v7,  v6,  v18, v1.s[1]
+        dsmull_h        v30, v31, v18, v1.s[0]
+        neg             v24.2d,  v24.2d
+        neg             v25.2d,  v25.2d
+        dsmull_h        v29, v28, v17, v2.s[1]
+        dsmull_h        v26, v27, v19, v3.s[2]
+        dsmull_h        v22, v23, v16, v0.s[0]
+        drshrn_h        v24, v24, v25, #14
+        drshrn_h        v16, v4,  v5,  #14
+        drshrn_h        v7,  v7,  v6,  #14
+        drshrn_h        v6,  v30, v31, #14
+        drshrn_h        v29, v29, v28, #14
+        drshrn_h        v17, v26, v27, #14
+        drshrn_h        v28, v22, v23, #14
+
+        dmbutterfly_l   v20, v21, v22, v23, v17, v24, v0.s[2], v0.s[3]
+        dmbutterfly_l   v18, v19, v30, v31, v29, v16, v0.s[2], v0.s[3]
+        neg             v22.2d,  v22.2d
+        neg             v23.2d,  v23.2d
+        drshrn_h        v27, v20, v21, #14
+        drshrn_h        v21, v22, v23, #14
+        drshrn_h        v23, v18, v19, #14
+        drshrn_h        v25, v30, v31, #14
+        mov             v4.16b,  v28.16b
+        mov             v5.16b,  v28.16b
+        dmbutterfly0    v22, v26, v7,  v6,  v18, v19, v30, v31
+        mov             v20.16b, v28.16b
+        idct16_end
+endfunc
+
+function iadst16
+        ld1             {v0.8h,v1.8h}, [x11]
+        sxtl            v2.4s,  v1.4h
+        sxtl2           v3.4s,  v1.8h
+        sxtl2           v1.4s,  v0.8h
+        sxtl            v0.4s,  v0.4h
+
+        dmbutterfly_l   v6,  v7,  v4,  v5,  v31, v16, v0.s[1], v0.s[0]   // v6,v7   = t1,   v4,v5   = t0
+        dmbutterfly_l   v10, v11, v8,  v9,  v23, v24, v1.s[1], v1.s[0]   // v10,v11 = t9,   v8,v9   = t8
+        dbutterfly_n    v31, v24, v6,  v7,  v10, v11, v12, v13, v10, v11 // v31     = t1a,  v24     = t9a
+        dmbutterfly_l   v14, v15, v12, v13, v29, v18, v0.s[3], v0.s[2]   // v14,v15 = t3,   v12,v13 = t2
+        dbutterfly_n    v16, v23, v4,  v5,  v8,  v9,  v6,  v7,  v8,  v9  // v16     = t0a,  v23     = t8a
+
+        dmbutterfly_l   v6,  v7,  v4,  v5,  v21, v26, v1.s[3], v1.s[2]   // v6,v7   = t11,  v4,v5   = t10
+        dbutterfly_n    v29, v26, v14, v15, v6,  v7,  v8,  v9,  v6,  v7  // v29     = t3a,  v26     = t11a
+        dmbutterfly_l   v10, v11, v8,  v9,  v27, v20, v2.s[1], v2.s[0]   // v10,v11 = t5,   v8,v9   = t4
+        dbutterfly_n    v18, v21, v12, v13, v4,  v5,  v6,  v7,  v4,  v5  // v18     = t2a,  v21     = t10a
+
+        dmbutterfly_l   v14, v15, v12, v13, v19, v28, v3.s[1], v3.s[0]   // v14,v15 = t13,  v12,v13 = t12
+        dbutterfly_n    v20, v28, v10, v11, v14, v15, v4,  v5,  v14, v15 // v20     = t5a,  v28     = t13a
+        dmbutterfly_l   v6,  v7,  v4,  v5,  v25, v22, v2.s[3], v2.s[2]   // v6,v7   = t7,   v4,v5   = t6
+        dbutterfly_n    v27, v19, v8,  v9,  v12, v13, v10, v11, v12, v13 // v27     = t4a,  v19     = t12a
+
+        dmbutterfly_l   v10, v11, v8,  v9,  v17, v30, v3.s[3], v3.s[2]   // v10,v11 = t15,  v8,v9   = t14
+        ld1             {v0.8h}, [x10]
+        dbutterfly_n    v22, v30, v6,  v7,  v10, v11, v12, v13, v10, v11 // v22     = t7a,  v30     = t15a
+        sxtl2           v1.4s,  v0.8h
+        sxtl            v0.4s,  v0.4h
+        dmbutterfly_l   v14, v15, v12, v13, v23, v24, v1.s[0], v1.s[1]   // v14,v15 = t9,   v12,v13 = t8
+        dbutterfly_n    v25, v17, v4,  v5,  v8,  v9,  v6,  v7,  v8,  v9  // v25     = t6a,  v17     = t14a
+
+        dmbutterfly_l   v4,  v5,  v6,  v7,  v28, v19, v1.s[1], v1.s[0]   // v4,v5   = t12,  v6,v7   = t13
+        dbutterfly_n    v23, v19, v12, v13, v4,  v5,  v8,  v9,  v4,  v5  // v23     = t8a,  v19     = t12a
+        dmbutterfly_l   v10, v11, v8,  v9,  v21, v26, v1.s[2], v1.s[3]   // v10,v11 = t11,  v8,v9   = t10
+        butterfly_4s_r  v4,  v27, v16, v27               // v4  = t4,   v27 = t0
+        dbutterfly_n    v24, v28, v14, v15, v6,  v7,  v12, v13, v6,  v7  // v24     = t9a,  v28     = t13a
+
+        dmbutterfly_l   v12, v13, v14, v15, v30, v17, v1.s[3], v1.s[2]   // v12,v13 = t14,  v14,v15 = t15
+        butterfly_4s_r  v5,  v20, v31, v20               // v5  = t5, v20 = t1
+        dbutterfly_n    v21, v17, v8,  v9,  v12, v13, v6,  v7,  v12, v13 // v21     = t10a, v17     = t14a
+        dbutterfly_n    v26, v30, v10, v11, v14, v15, v8,  v9,  v14, v15 // v26     = t11a, v30     = t15a
+
+        butterfly_4s_r  v6,  v25, v18, v25               // v6  = t6, v25 = t2
+        butterfly_4s_r  v7,  v22, v29, v22               // v7  = t7, v22 = t3
+
+        dmbutterfly_l   v10, v11, v8,  v9,  v19, v28, v0.s[2], v0.s[3]   // v10,v11 = t13,  v8,v9   = t12
+        dmbutterfly_l   v12, v13, v14, v15, v30, v17, v0.s[3], v0.s[2]   // v12,v13 = t14,  v14,v15 = t15
+
+        dbutterfly_n    v18, v30, v8,  v9,  v12, v13, v16, v17, v12, v13 // v18   = out[2], v30     = t14a
+        dbutterfly_n    v29, v17, v10, v11, v14, v15, v12, v13, v14, v15 // v29 = -out[13], v17     = t15a
+        neg             v29.4s, v29.4s                   // v29 = out[13]
+
+        dmbutterfly_l   v10, v11, v8,  v9,  v4,  v5,  v0.s[2], v0.s[3]   // v10,v11 = t5a,  v8,v9   = t4a
+        dmbutterfly_l   v12, v13, v14, v15, v7,  v6,  v0.s[3], v0.s[2]   // v12,v13 = t6a,  v14,v15 = t7a
+
+        butterfly_4s    v2,  v6,  v27, v25               // v2 = out[0], v6 = t2a
+        butterfly_4s    v3,  v7,  v23, v21               // v3 =-out[1], v7 = t10
+
+        dbutterfly_n    v19, v31, v8,  v9,  v12, v13, v4,  v5,  v8,  v9  // v19 = -out[3],  v31 = t6
+        neg             v19.4s, v19.4s                   // v19 = out[3]
+        dbutterfly_n    v28, v16, v10, v11, v14, v15, v4,  v5,  v10, v11 // v28 = out[12],  v16 = t7
+
+        butterfly_4s    v5,  v8,  v20, v22               // v5 =-out[15],v8 = t3a
+        butterfly_4s    v4,  v9,  v24, v26               // v4 = out[14],v9 = t11
+
+        dmbutterfly0    v23, v24, v6,  v8,  v10, v11, v12, v13, v14, v15, 1 // v23 = out[7], v24 = out[8]
+        dmbutterfly0    v21, v26, v30, v17, v10, v11, v12, v13, v14, v15, 1 // v21 = out[5], v26 = out[10]
+        dmbutterfly0    v20, v27, v16, v31, v10, v11, v12, v13, v14, v15    // v20 = out[4], v27 = out[11]
+        dmbutterfly0    v22, v25, v9,  v7,  v10, v11, v12, v13, v14, v15    // v22 = out[6], v25 = out[9]
+
+        neg             v31.4s,  v5.4s                    // v31 = out[15]
+        neg             v17.4s,  v3.4s                    // v17 = out[1]
+
+        mov             v16.16b, v2.16b
+        mov             v30.16b, v4.16b
+        ret
+endfunc
+
+// Helper macros; we can't use these expressions directly within
+// e.g. .irp due to the extra concatenation \(). Therefore wrap
+// them in macros to allow using .irp below.
+.macro load i, src, inc
+        ld1             {v\i\().4s},  [\src], \inc
+.endm
+.macro store i, dst, inc
+        st1             {v\i\().4s},  [\dst], \inc
+.endm
+.macro movi_v i, size, imm
+        movi            v\i\()\size,  \imm
+.endm
+.macro load_clear i, src, inc
+        ld1             {v\i\().4s}, [\src]
+        st1             {v4.4s},  [\src], \inc
+.endm
+
+.macro load_add_store coef0, coef1, coef2, coef3, coef4, coef5, coef6, coef7
+        srshr           \coef0, \coef0, #6
+        ld1             {v4.4h},   [x0], x1
+        srshr           \coef1, \coef1, #6
+        ld1             {v4.d}[1], [x3], x1
+        srshr           \coef2, \coef2, #6
+        ld1             {v5.4h},   [x0], x1
+        srshr           \coef3, \coef3, #6
+        uaddw           \coef0, \coef0, v4.4h
+        ld1             {v5.d}[1], [x3], x1
+        srshr           \coef4, \coef4, #6
+        uaddw2          \coef1, \coef1, v4.8h
+        ld1             {v6.4h},   [x0], x1
+        srshr           \coef5, \coef5, #6
+        uaddw           \coef2, \coef2, v5.4h
+        ld1             {v6.d}[1], [x3], x1
+        sqxtun          v4.4h,  \coef0
+        srshr           \coef6, \coef6, #6
+        uaddw2          \coef3, \coef3, v5.8h
+        ld1             {v7.4h},   [x0], x1
+        sqxtun2         v4.8h,  \coef1
+        srshr           \coef7, \coef7, #6
+        uaddw           \coef4, \coef4, v6.4h
+        ld1             {v7.d}[1], [x3], x1
+        umin            v4.8h,  v4.8h,  v8.8h
+        sub             x0,  x0,  x1, lsl #2
+        sub             x3,  x3,  x1, lsl #2
+        sqxtun          v5.4h,  \coef2
+        uaddw2          \coef5, \coef5, v6.8h
+        st1             {v4.4h},   [x0], x1
+        sqxtun2         v5.8h,  \coef3
+        uaddw           \coef6, \coef6, v7.4h
+        st1             {v4.d}[1], [x3], x1
+        umin            v5.8h,  v5.8h,  v8.8h
+        sqxtun          v6.4h,  \coef4
+        uaddw2          \coef7, \coef7, v7.8h
+        st1             {v5.4h},   [x0], x1
+        sqxtun2         v6.8h,  \coef5
+        st1             {v5.d}[1], [x3], x1
+        umin            v6.8h,  v6.8h,  v8.8h
+        sqxtun          v7.4h,  \coef6
+        st1             {v6.4h},   [x0], x1
+        sqxtun2         v7.8h,  \coef7
+        st1             {v6.d}[1], [x3], x1
+        umin            v7.8h,  v7.8h,  v8.8h
+        st1             {v7.4h},   [x0], x1
+        st1             {v7.d}[1], [x3], x1
+.endm
+
+// Read a vertical 4x16 slice out of a 16x16 matrix, do a transform on it,
+// transpose into a horizontal 16x4 slice and store.
+// x0 = dst (temp buffer)
+// x1 = slice offset
+// x2 = src
+// x9 = input stride
+.macro itxfm16_1d_funcs txfm
+function \txfm\()16_1d_4x16_pass1_neon
+        mov             x14, x30
+
+        movi            v4.4s, #0
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        load_clear      \i,  x2,  x9
+.endr
+
+        bl              \txfm\()16
+
+        // Do four 4x4 transposes. Originally, v16-v31 contain the
+        // 16 rows. Afterwards, v16-v19, v20-v23, v24-v27 and v28-v31
+        // contain the four transposed 4x4 blocks.
+        transpose_4x4s  v16, v17, v18, v19, v4, v5, v6, v7
+        transpose_4x4s  v20, v21, v22, v23, v4, v5, v6, v7
+        transpose_4x4s  v24, v25, v26, v27, v4, v5, v6, v7
+        transpose_4x4s  v28, v29, v30, v31, v4, v5, v6, v7
+
+        // Store the transposed 4x4 blocks horizontally.
+        cmp             x1,  #12
+        b.eq            1f
+.irp i, 16, 20, 24, 28, 17, 21, 25, 29, 18, 22, 26, 30, 19, 23, 27, 31
+        store           \i,  x0,  #16
+.endr
+        br              x14
+1:
+        // Special case: For the last input column (x1 == 12),
+        // which would be stored as the last row in the temp buffer,
+        // don't store the first 4x4 block, but keep it in registers
+        // for the first slice of the second pass (where it is the
+        // last 4x4 block).
+        add             x0,  x0,  #16
+        st1             {v20.4s},  [x0], #16
+        st1             {v24.4s},  [x0], #16
+        st1             {v28.4s},  [x0], #16
+        add             x0,  x0,  #16
+        st1             {v21.4s},  [x0], #16
+        st1             {v25.4s},  [x0], #16
+        st1             {v29.4s},  [x0], #16
+        add             x0,  x0,  #16
+        st1             {v22.4s},  [x0], #16
+        st1             {v26.4s},  [x0], #16
+        st1             {v30.4s},  [x0], #16
+        add             x0,  x0,  #16
+        st1             {v23.4s},  [x0], #16
+        st1             {v27.4s},  [x0], #16
+        st1             {v31.4s},  [x0], #16
+
+        mov             v28.16b, v16.16b
+        mov             v29.16b, v17.16b
+        mov             v30.16b, v18.16b
+        mov             v31.16b, v19.16b
+        br              x14
+endfunc
+
+// Read a vertical 4x16 slice out of a 16x16 matrix, do a transform on it,
+// load the destination pixels (from a similar 4x16 slice), add and store back.
+// x0 = dst
+// x1 = dst stride
+// x2 = src (temp buffer)
+// x3 = slice offset
+// x9 = temp buffer stride
+function \txfm\()16_1d_4x16_pass2_neon
+        mov             x14, x30
+
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27
+        load            \i,  x2,  x9
+.endr
+        cbz             x3,  1f
+.irp i, 28, 29, 30, 31
+        load            \i,  x2,  x9
+.endr
+1:
+
+        add             x3,  x0,  x1
+        lsl             x1,  x1,  #1
+        bl              \txfm\()16
+
+        dup             v8.8h, w13
+        load_add_store  v16.4s, v17.4s, v18.4s, v19.4s, v20.4s, v21.4s, v22.4s, v23.4s
+        load_add_store  v24.4s, v25.4s, v26.4s, v27.4s, v28.4s, v29.4s, v30.4s, v31.4s
+
+        br              x14
+endfunc
+.endm
+
+itxfm16_1d_funcs idct
+itxfm16_1d_funcs iadst
+
+// This is the minimum eob value for each subpartition, in increments of 4
+const min_eob_idct_idct_16, align=4
+        .short  0, 10, 38, 89
+endconst
+
+.macro itxfm_func16x16 txfm1, txfm2
+function vp9_\txfm1\()_\txfm2\()_16x16_add_16_neon
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             w3,  #1
+        b.eq            idct16x16_dc_add_neon
+.endif
+        mov             x15, x30
+        // iadst16 requires clobbering v8-v15, idct16 only clobbers v8-v9.
+.ifnc \txfm1\()_\txfm2,idct_idct
+        stp             d14, d15, [sp, #-0x10]!
+        stp             d12, d13, [sp, #-0x10]!
+        stp             d10, d11, [sp, #-0x10]!
+.endif
+        stp             d8,  d9,  [sp, #-0x10]!
+
+        sub             sp,  sp,  #1024
+
+        mov             x4,  x0
+        mov             x5,  x1
+        mov             x6,  x2
+
+        movrel          x10, idct_coeffs
+.ifnc \txfm1\()_\txfm2,idct_idct
+        movrel          x11, iadst16_coeffs
+.endif
+.ifc \txfm1,idct
+        ld1             {v0.8h,v1.8h}, [x10]
+        sxtl            v2.4s,  v1.4h
+        sxtl2           v3.4s,  v1.8h
+        sxtl2           v1.4s,  v0.8h
+        sxtl            v0.4s,  v0.4h
+.endif
+        mov             x9,  #64
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             w3,  #10
+        b.le            idct16x16_quarter_add_16_neon
+        cmp             w3,  #38
+        b.le            idct16x16_half_add_16_neon
+
+        movrel          x12, min_eob_idct_idct_16, 2
+.endif
+
+.irp i, 0, 4, 8, 12
+        add             x0,  sp,  #(\i*64)
+.ifc \txfm1\()_\txfm2,idct_idct
+.if \i > 0
+        ldrh            w1,  [x12], #2
+        cmp             w3,  w1
+        mov             x1,  #(16 - \i)/4
+        b.le            1f
+.endif
+.endif
+        mov             x1,  #\i
+        add             x2,  x6,  #(\i*4)
+        bl              \txfm1\()16_1d_4x16_pass1_neon
+.endr
+.ifc \txfm1\()_\txfm2,iadst_idct
+        ld1             {v0.8h,v1.8h}, [x10]
+        sxtl            v2.4s,  v1.4h
+        sxtl2           v3.4s,  v1.8h
+        sxtl2           v1.4s,  v0.8h
+        sxtl            v0.4s,  v0.4h
+.endif
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        b               3f
+1:
+        // Set v28-v31 to zero, for the in-register passthrough of
+        // coefficients to pass 2.
+        movi            v28.4s,  #0
+        movi            v29.4s,  #0
+        movi            v30.4s,  #0
+        movi            v31.4s,  #0
+2:
+        subs            x1,  x1,  #1
+.rept 4
+        st1             {v28.4s,v29.4s,v30.4s,v31.4s}, [x0], x9
+.endr
+        b.ne            2b
+3:
+.endif
+
+.irp i, 0, 4, 8, 12
+        add             x0,  x4,  #(\i*2)
+        mov             x1,  x5
+        add             x2,  sp,  #(\i*4)
+        mov             x3,  #\i
+        bl              \txfm2\()16_1d_4x16_pass2_neon
+.endr
+
+        add             sp,  sp,  #1024
+        ldp             d8,  d9,  [sp], 0x10
+.ifnc \txfm1\()_\txfm2,idct_idct
+        ldp             d10, d11, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d14, d15, [sp], 0x10
+.endif
+        br              x15
+endfunc
+
+function ff_vp9_\txfm1\()_\txfm2\()_16x16_add_10_neon, export=1
+        mov             x13, #0x03ff
+        b               vp9_\txfm1\()_\txfm2\()_16x16_add_16_neon
+endfunc
+
+function ff_vp9_\txfm1\()_\txfm2\()_16x16_add_12_neon, export=1
+        mov             x13, #0x0fff
+        b               vp9_\txfm1\()_\txfm2\()_16x16_add_16_neon
+endfunc
+.endm
+
+itxfm_func16x16 idct,  idct
+itxfm_func16x16 iadst, idct
+itxfm_func16x16 idct,  iadst
+itxfm_func16x16 iadst, iadst
+
+function idct16_1d_4x16_pass1_quarter_neon
+        mov             x14, x30
+
+        movi            v4.4s, #0
+.irp i, 16, 17, 18, 19
+        load_clear      \i,  x2,  x9
+.endr
+
+        bl              idct16_quarter
+
+        // Do four 4x4 transposes. Originally, v16-v31 contain the
+        // 16 rows. Afterwards, v16-v19, v20-v23, v24-v27 and v28-v31
+        // contain the four transposed 4x4 blocks.
+        transpose_4x4s  v16, v17, v18, v19, v4, v5, v6, v7
+        transpose_4x4s  v20, v21, v22, v23, v4, v5, v6, v7
+        transpose_4x4s  v24, v25, v26, v27, v4, v5, v6, v7
+        transpose_4x4s  v28, v29, v30, v31, v4, v5, v6, v7
+
+        // Store the transposed 4x4 blocks horizontally.
+        // The first 4x4 block is kept in registers for the second pass,
+        // store the rest in the temp buffer.
+        add             x0,  x0,  #16
+        st1             {v20.4s},  [x0], #16
+        st1             {v24.4s},  [x0], #16
+        st1             {v28.4s},  [x0], #16
+        add             x0,  x0,  #16
+        st1             {v21.4s},  [x0], #16
+        st1             {v25.4s},  [x0], #16
+        st1             {v29.4s},  [x0], #16
+        add             x0,  x0,  #16
+        st1             {v22.4s},  [x0], #16
+        st1             {v26.4s},  [x0], #16
+        st1             {v30.4s},  [x0], #16
+        add             x0,  x0,  #16
+        st1             {v23.4s},  [x0], #16
+        st1             {v27.4s},  [x0], #16
+        st1             {v31.4s},  [x0], #16
+        br              x14
+endfunc
+
+function idct16_1d_4x16_pass2_quarter_neon
+        mov             x14, x30
+
+        // Only load the top 4 lines, and only do it for the later slices.
+        // For the first slice, d16-d19 is kept in registers from the first pass.
+        cbz             x3,  1f
+.irp i, 16, 17, 18, 19
+        load            \i,  x2,  x9
+.endr
+1:
+
+        add             x3,  x0,  x1
+        lsl             x1,  x1,  #1
+        bl              idct16_quarter
+
+        dup             v8.8h, w13
+        load_add_store  v16.4s, v17.4s, v18.4s, v19.4s, v20.4s, v21.4s, v22.4s, v23.4s
+        load_add_store  v24.4s, v25.4s, v26.4s, v27.4s, v28.4s, v29.4s, v30.4s, v31.4s
+
+        br              x14
+endfunc
+
+function idct16_1d_4x16_pass1_half_neon
+        mov             x14, x30
+
+        movi            v4.4s, #0
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load_clear      \i,  x2,  x9
+.endr
+
+        bl              idct16_half
+
+        // Do four 4x4 transposes. Originally, v16-v31 contain the
+        // 16 rows. Afterwards, v16-v19, v20-v23, v24-v27 and v28-v31
+        // contain the four transposed 4x4 blocks.
+        transpose_4x4s  v16, v17, v18, v19, v4, v5, v6, v7
+        transpose_4x4s  v20, v21, v22, v23, v4, v5, v6, v7
+        transpose_4x4s  v24, v25, v26, v27, v4, v5, v6, v7
+        transpose_4x4s  v28, v29, v30, v31, v4, v5, v6, v7
+
+        // Store the transposed 4x4 blocks horizontally.
+        cmp             x1,  #4
+        b.eq            1f
+.irp i, 16, 20, 24, 28, 17, 21, 25, 29, 18, 22, 26, 30, 19, 23, 27, 31
+        store           \i,  x0,  #16
+.endr
+        br              x14
+1:
+        // Special case: For the second input column (r1 == 4),
+        // which would be stored as the second row in the temp buffer,
+        // don't store the first 4x4 block, but keep it in registers
+        // for the first slice of the second pass (where it is the
+        // second 4x4 block).
+        add             x0,  x0,  #16
+        st1             {v20.4s},  [x0], #16
+        st1             {v24.4s},  [x0], #16
+        st1             {v28.4s},  [x0], #16
+        add             x0,  x0,  #16
+        st1             {v21.4s},  [x0], #16
+        st1             {v25.4s},  [x0], #16
+        st1             {v29.4s},  [x0], #16
+        add             x0,  x0,  #16
+        st1             {v22.4s},  [x0], #16
+        st1             {v26.4s},  [x0], #16
+        st1             {v30.4s},  [x0], #16
+        add             x0,  x0,  #16
+        st1             {v23.4s},  [x0], #16
+        st1             {v27.4s},  [x0], #16
+        st1             {v31.4s},  [x0], #16
+
+        mov             v20.16b, v16.16b
+        mov             v21.16b, v17.16b
+        mov             v22.16b, v18.16b
+        mov             v23.16b, v19.16b
+        br              x14
+endfunc
+
+function idct16_1d_4x16_pass2_half_neon
+        mov             x14, x30
+
+.irp i, 16, 17, 18, 19
+        load            \i,  x2,  x9
+.endr
+        cbz             x3,  1f
+.irp i, 20, 21, 22, 23
+        load            \i,  x2,  x9
+.endr
+1:
+
+        add             x3,  x0,  x1
+        lsl             x1,  x1,  #1
+        bl              idct16_half
+
+        dup             v8.8h, w13
+        load_add_store  v16.4s, v17.4s, v18.4s, v19.4s, v20.4s, v21.4s, v22.4s, v23.4s
+        load_add_store  v24.4s, v25.4s, v26.4s, v27.4s, v28.4s, v29.4s, v30.4s, v31.4s
+
+        br              x14
+endfunc
+
+.macro idct16_partial size
+function idct16x16_\size\()_add_16_neon
+        add             x0,  sp,  #(0*64)
+        mov             x1,  #0
+        add             x2,  x6,  #(0*4)
+        bl              idct16_1d_4x16_pass1_\size\()_neon
+.ifc \size,half
+        add             x0,  sp,  #(4*64)
+        mov             x1,  #4
+        add             x2,  x6,  #(4*4)
+        bl              idct16_1d_4x16_pass1_\size\()_neon
+.endif
+
+.irp i, 0, 4, 8, 12
+        add             x0,  x4,  #(\i*2)
+        mov             x1,  x5
+        add             x2,  sp,  #(\i*4)
+        mov             x3,  #\i
+        bl              idct16_1d_4x16_pass2_\size\()_neon
+.endr
+
+        add             sp,  sp,  #1024
+        ldp             d8,  d9,  [sp], 0x10
+        br              x15
+endfunc
+.endm
+
+idct16_partial quarter
+idct16_partial half
+
+function idct32x32_dc_add_neon
+        movrel          x4,  idct_coeffs
+        ld1             {v0.4h}, [x4]
+        sxtl            v0.4s,  v0.4h
+
+        movi            v1.4h,  #0
+
+        ld1             {v2.s}[0],  [x2]
+        smull           v2.2d,  v2.2s,  v0.s[0]
+        rshrn           v2.2s,  v2.2d,  #14
+        smull           v2.2d,  v2.2s,  v0.s[0]
+        rshrn           v2.2s,  v2.2d,  #14
+        st1             {v1.s}[0],  [x2]
+        dup             v2.4s,  v2.s[0]
+
+        srshr           v0.4s,  v2.4s,  #6
+
+        mov             x3,  x0
+        mov             x4,  #32
+        sub             x1,  x1,  #32
+        dup             v31.8h, w13
+1:
+        // Loop to add the constant v0 into all 32x32 outputs
+        subs            x4,  x4,  #1
+        ld1             {v1.8h,v2.8h},  [x0], #32
+        uaddw           v16.4s, v0.4s,  v1.4h
+        uaddw2          v17.4s, v0.4s,  v1.8h
+        ld1             {v3.8h,v4.8h},  [x0], x1
+        uaddw           v18.4s, v0.4s,  v2.4h
+        uaddw2          v19.4s, v0.4s,  v2.8h
+        uaddw           v20.4s, v0.4s,  v3.4h
+        uaddw2          v21.4s, v0.4s,  v3.8h
+        uaddw           v22.4s, v0.4s,  v4.4h
+        uaddw2          v23.4s, v0.4s,  v4.8h
+        sqxtun          v1.4h,  v16.4s
+        sqxtun2         v1.8h,  v17.4s
+        sqxtun          v2.4h,  v18.4s
+        sqxtun2         v2.8h,  v19.4s
+        sqxtun          v3.4h,  v20.4s
+        sqxtun2         v3.8h,  v21.4s
+        sqxtun          v4.4h,  v22.4s
+        sqxtun2         v4.8h,  v23.4s
+        umin            v1.8h,  v1.8h,  v31.8h
+        umin            v2.8h,  v2.8h,  v31.8h
+        st1             {v1.8h,v2.8h},  [x3], #32
+        umin            v3.8h,  v3.8h,  v31.8h
+        umin            v4.8h,  v4.8h,  v31.8h
+        st1             {v3.8h,v4.8h},  [x3], x1
+        b.ne            1b
+
+        ret
+endfunc
+
+.macro idct32_end
+        butterfly_4s    v16, v5,  v4,  v5  // v16 = t16a, v5  = t19a
+        butterfly_4s    v17, v20, v23, v20 // v17 = t17,  v20 = t18
+        butterfly_4s    v18, v6,  v7,  v6  // v18 = t23a, v6  = t20a
+        butterfly_4s    v19, v21, v22, v21 // v19 = t22,  v21 = t21
+        butterfly_4s    v4,  v28, v28, v30 // v4  = t24a, v28 = t27a
+        butterfly_4s    v23, v26, v25, v26 // v23 = t25,  v26 = t26
+        butterfly_4s    v7,  v8,  v29, v31 // v7  = t31a, v3  = t28a
+        butterfly_4s    v22, v27, v24, v27 // v22 = t30,  v27 = t29
+
+        dmbutterfly     v27, v20, v0.s[2], v0.s[3], v24, v25, v30, v31        // v27 = t18a, v20 = t29a
+        dmbutterfly     v8,  v5,  v0.s[2], v0.s[3], v24, v25, v30, v31        // v3  = t19,  v5  = t28
+        dmbutterfly     v28, v6,  v0.s[2], v0.s[3], v24, v25, v30, v31, neg=1 // v28 = t27,  v6  = t20
+        dmbutterfly     v26, v21, v0.s[2], v0.s[3], v24, v25, v30, v31, neg=1 // v26 = t26a, v21 = t21a
+
+        butterfly_4s    v31, v24, v7,  v4  // v31 = t31,  v24 = t24
+        butterfly_4s    v30, v25, v22, v23 // v30 = t30a, v25 = t25a
+        butterfly_4s_r  v23, v16, v16, v18 // v23 = t23,  v16 = t16
+        butterfly_4s_r  v22, v17, v17, v19 // v22 = t22a, v17 = t17a
+        butterfly_4s    v18, v21, v27, v21 // v18 = t18,  v21 = t21
+        butterfly_4s_r  v27, v28, v5,  v28 // v27 = t27a, v28 = t28a
+        butterfly_4s    v29, v26, v20, v26 // v29 = t29,  v26 = t26
+        butterfly_4s    v19, v20, v8,  v6  // v19 = t19a, v20 = t20
+
+        dmbutterfly0    v27, v20, v27, v20, v4, v5, v6, v7, v8, v9 // v27 = t27,  v20 = t20
+        dmbutterfly0    v26, v21, v26, v21, v4, v5, v6, v7, v8, v9 // v26 = t26a, v21 = t21a
+        dmbutterfly0    v25, v22, v25, v22, v4, v5, v6, v7, v8, v9 // v25 = t25,  v22 = t22
+        dmbutterfly0    v24, v23, v24, v23, v4, v5, v6, v7, v8, v9 // v24 = t24a, v23 = t23a
+        ret
+.endm
+
+function idct32_odd
+        dmbutterfly     v16, v31, v10.s[0], v10.s[1], v4, v5, v6, v7 // v16 = t16a, v31 = t31a
+        dmbutterfly     v24, v23, v10.s[2], v10.s[3], v4, v5, v6, v7 // v24 = t17a, v23 = t30a
+        dmbutterfly     v20, v27, v11.s[0], v11.s[1], v4, v5, v6, v7 // v20 = t18a, v27 = t29a
+        dmbutterfly     v28, v19, v11.s[2], v11.s[3], v4, v5, v6, v7 // v28 = t19a, v19 = t28a
+        dmbutterfly     v18, v29, v12.s[0], v12.s[1], v4, v5, v6, v7 // v18 = t20a, v29 = t27a
+        dmbutterfly     v26, v21, v12.s[2], v12.s[3], v4, v5, v6, v7 // v26 = t21a, v21 = t26a
+        dmbutterfly     v22, v25, v13.s[0], v13.s[1], v4, v5, v6, v7 // v22 = t22a, v25 = t25a
+        dmbutterfly     v30, v17, v13.s[2], v13.s[3], v4, v5, v6, v7 // v30 = t23a, v17 = t24a
+
+        butterfly_4s    v4,  v24, v16, v24 // v4  = t16, v24 = t17
+        butterfly_4s    v5,  v20, v28, v20 // v5  = t19, v20 = t18
+        butterfly_4s    v6,  v26, v18, v26 // v6  = t20, v26 = t21
+        butterfly_4s    v7,  v22, v30, v22 // v7  = t23, v22 = t22
+        butterfly_4s    v28, v25, v17, v25 // v28 = t24, v25 = t25
+        butterfly_4s    v30, v21, v29, v21 // v30 = t27, v21 = t26
+        butterfly_4s    v29, v23, v31, v23 // v29 = t31, v23 = t30
+        butterfly_4s    v31, v27, v19, v27 // v31 = t28, v27 = t29
+
+        dmbutterfly     v23, v24, v1.s[0], v1.s[1], v16, v17, v18, v19        // v23 = t17a, v24 = t30a
+        dmbutterfly     v27, v20, v1.s[0], v1.s[1], v16, v17, v18, v19, neg=1 // v27 = t29a, v20 = t18a
+        dmbutterfly     v21, v26, v1.s[2], v1.s[3], v16, v17, v18, v19        // v21 = t21a, v26 = t26a
+        dmbutterfly     v25, v22, v1.s[2], v1.s[3], v16, v17, v18, v19, neg=1 // v25 = t25a, v22 = t22a
+        idct32_end
+endfunc
+
+function idct32_odd_half
+        dmbutterfly_h1  v16, v31, v10.s[0], v10.s[1], v4, v5, v6, v7 // v16 = t16a, v31 = t31a
+        dmbutterfly_h2  v24, v23, v10.s[2], v10.s[3], v4, v5, v6, v7 // v24 = t17a, v23 = t30a
+        dmbutterfly_h1  v20, v27, v11.s[0], v11.s[1], v4, v5, v6, v7 // v20 = t18a, v27 = t29a
+        dmbutterfly_h2  v28, v19, v11.s[2], v11.s[3], v4, v5, v6, v7 // v28 = t19a, v19 = t28a
+        dmbutterfly_h1  v18, v29, v12.s[0], v12.s[1], v4, v5, v6, v7 // v18 = t20a, v29 = t27a
+        dmbutterfly_h2  v26, v21, v12.s[2], v12.s[3], v4, v5, v6, v7 // v26 = t21a, v21 = t26a
+        dmbutterfly_h1  v22, v25, v13.s[0], v13.s[1], v4, v5, v6, v7 // v22 = t22a, v25 = t25a
+        dmbutterfly_h2  v30, v17, v13.s[2], v13.s[3], v4, v5, v6, v7 // v30 = t23a, v17 = t24a
+
+        butterfly_4s    v4,  v24, v16, v24 // v4  = t16, v24 = t17
+        butterfly_4s    v5,  v20, v28, v20 // v5  = t19, v20 = t18
+        butterfly_4s    v6,  v26, v18, v26 // v6  = t20, v26 = t21
+        butterfly_4s    v7,  v22, v30, v22 // v7  = t23, v22 = t22
+        butterfly_4s    v28, v25, v17, v25 // v28 = t24, v25 = t25
+        butterfly_4s    v30, v21, v29, v21 // v30 = t27, v21 = t26
+        butterfly_4s    v29, v23, v31, v23 // v29 = t31, v23 = t30
+        butterfly_4s    v31, v27, v19, v27 // v31 = t28, v27 = t29
+
+        dmbutterfly     v23, v24, v1.s[0], v1.s[1], v16, v17, v18, v19        // v23 = t17a, v24 = t30a
+        dmbutterfly     v27, v20, v1.s[0], v1.s[1], v16, v17, v18, v19, neg=1 // v27 = t29a, v20 = t18a
+        dmbutterfly     v21, v26, v1.s[2], v1.s[3], v16, v17, v18, v19        // v21 = t21a, v26 = t26a
+        dmbutterfly     v25, v22, v1.s[2], v1.s[3], v16, v17, v18, v19, neg=1 // v25 = t25a, v22 = t22a
+        idct32_end
+endfunc
+
+function idct32_odd_quarter
+        dsmull_h        v4,  v5,  v16, v10.s[0]
+        dsmull_h        v28, v29, v19, v11.s[3]
+        dsmull_h        v30, v31, v16, v10.s[1]
+        dsmull_h        v22, v23, v17, v13.s[2]
+        dsmull_h        v7,  v6,  v17, v13.s[3]
+        dsmull_h        v26, v27, v19, v11.s[2]
+        dsmull_h        v20, v21, v18, v12.s[0]
+        dsmull_h        v24, v25, v18, v12.s[1]
+
+        neg             v28.2d, v28.2d
+        neg             v29.2d, v29.2d
+        neg             v7.2d,  v7.2d
+        neg             v6.2d,  v6.2d
+
+        drshrn_h        v4,  v4,  v5,  #14
+        drshrn_h        v5,  v28, v29, #14
+        drshrn_h        v29, v30, v31, #14
+        drshrn_h        v28, v22, v23, #14
+        drshrn_h        v7,  v7,  v6,  #14
+        drshrn_h        v31, v26, v27, #14
+        drshrn_h        v6,  v20, v21, #14
+        drshrn_h        v30, v24, v25, #14
+
+        dmbutterfly_l   v16, v17, v18, v19, v29, v4,  v1.s[0], v1.s[1]
+        dmbutterfly_l   v27, v26, v20, v21, v31, v5,  v1.s[0], v1.s[1]
+        drshrn_h        v23, v16, v17, #14
+        drshrn_h        v24, v18, v19, #14
+        neg             v20.2d, v20.2d
+        neg             v21.2d, v21.2d
+        drshrn_h        v27, v27, v26, #14
+        drshrn_h        v20, v20, v21, #14
+        dmbutterfly_l   v16, v17, v18, v19, v30, v6,  v1.s[2], v1.s[3]
+        drshrn_h        v21, v16, v17, #14
+        drshrn_h        v26, v18, v19, #14
+        dmbutterfly_l   v16, v17, v18, v19, v28, v7,  v1.s[2], v1.s[3]
+        drshrn_h        v25, v16, v17, #14
+        neg             v18.2d, v18.2d
+        neg             v19.2d, v19.2d
+        drshrn_h        v22, v18, v19, #14
+
+        idct32_end
+endfunc
+
+.macro idct32_funcs suffix
+// Do an 32-point IDCT of a 4x32 slice out of a 32x32 matrix.
+// The 32-point IDCT can be decomposed into two 16-point IDCTs;
+// a normal IDCT16 with every other input component (the even ones, with
+// each output written twice), followed by a separate 16-point IDCT
+// of the odd inputs, added/subtracted onto the outputs of the first idct16.
+// x0 = dst (temp buffer)
+// x1 = unused
+// x2 = src
+// x9 = double input stride
+function idct32_1d_4x32_pass1\suffix\()_neon
+        mov             x14, x30
+
+        movi            v4.4s,  #0
+
+        // v16 = IN(0), v17 = IN(2) ... v31 = IN(30)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        load_clear      \i, x2, x9
+.endr
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        load_clear      \i, x2, x9
+.endr
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load_clear      \i, x2, x9
+.endr
+.endif
+
+        bl              idct16\suffix
+
+        // Do four 4x4 transposes. Originally, v16-v31 contain the
+        // 16 rows. Afterwards, v16-v19, v20-v23, v24-v27 and v28-v31
+        // contain the four transposed 4x4 blocks.
+        transpose_4x4s  v16, v17, v18, v19, v4, v5, v6, v7
+        transpose_4x4s  v20, v21, v22, v23, v4, v5, v6, v7
+        transpose_4x4s  v24, v25, v26, v27, v4, v5, v6, v7
+        transpose_4x4s  v28, v29, v30, v31, v4, v5, v6, v7
+
+        // Store the registers a, b, c, d horizontally, followed by the
+        // same registers d, c, b, a mirrored.
+.macro store_rev a, b, c, d
+        // There's no rev128 instruction, but we reverse each 64 bit
+        // half, and then flip them using an ext with 8 bytes offset.
+        rev64           v7.4s, \d
+        st1             {\a},  [x0], #16
+        ext             v7.16b, v7.16b, v7.16b, #8
+        st1             {\b},  [x0], #16
+        rev64           v6.4s, \c
+        st1             {\c},  [x0], #16
+        ext             v6.16b, v6.16b, v6.16b, #8
+        st1             {\d},  [x0], #16
+        rev64           v5.4s, \b
+        st1             {v7.4s},  [x0], #16
+        ext             v5.16b, v5.16b, v5.16b, #8
+        st1             {v6.4s},  [x0], #16
+        rev64           v4.4s, \a
+        st1             {v5.4s},  [x0], #16
+        ext             v4.16b, v4.16b, v4.16b, #8
+        st1             {v4.4s},  [x0], #16
+.endm
+        store_rev       v16.4s, v20.4s, v24.4s, v28.4s
+        store_rev       v17.4s, v21.4s, v25.4s, v29.4s
+        store_rev       v18.4s, v22.4s, v26.4s, v30.4s
+        store_rev       v19.4s, v23.4s, v27.4s, v31.4s
+        sub             x0,  x0,  #512
+.purgem store_rev
+
+        // Move x2 back to the start of the input, and move
+        // to the first odd row
+.ifb \suffix
+        sub             x2,  x2,  x9, lsl #4
+.endif
+.ifc \suffix,_quarter
+        sub             x2,  x2,  x9, lsl #2
+.endif
+.ifc \suffix,_half
+        sub             x2,  x2,  x9, lsl #3
+.endif
+        add             x2,  x2,  #128
+
+        movi            v4.4s,  #0
+        // v16 = IN(1), v17 = IN(3) ... v31 = IN(31)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        load_clear      \i, x2, x9
+.endr
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        load_clear      \i, x2, x9
+.endr
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load_clear      \i, x2, x9
+.endr
+.endif
+
+        bl              idct32_odd\suffix
+
+        transpose_4x4s  v31, v30, v29, v28, v4, v5, v6, v7
+        transpose_4x4s  v27, v26, v25, v24, v4, v5, v6, v7
+        transpose_4x4s  v23, v22, v21, v20, v4, v5, v6, v7
+        transpose_4x4s  v19, v18, v17, v16, v4, v5, v6, v7
+
+        // Store the registers a, b, c, d horizontally,
+        // adding into the output first, and the mirrored,
+        // subtracted from the output.
+.macro store_rev a, b, c, d, a16b, b16b
+        ld1             {v4.4s},  [x0]
+        rev64           v9.4s, \d
+        add             v4.4s, v4.4s, \a
+        st1             {v4.4s},  [x0], #16
+        rev64           v8.4s, \c
+        ld1             {v4.4s},  [x0]
+        ext             v9.16b, v9.16b, v9.16b, #8
+        add             v4.4s, v4.4s, \b
+        st1             {v4.4s},  [x0], #16
+        ext             v8.16b, v8.16b, v8.16b, #8
+        ld1             {v4.4s},  [x0]
+        rev64           \b, \b
+        add             v4.4s, v4.4s, \c
+        st1             {v4.4s},  [x0], #16
+        rev64           \a, \a
+        ld1             {v4.4s},  [x0]
+        ext             \b16b, \b16b, \b16b, #8
+        add             v4.4s, v4.4s, \d
+        st1             {v4.4s},  [x0], #16
+        ext             \a16b, \a16b, \a16b, #8
+        ld1             {v4.4s},  [x0]
+        sub             v4.4s, v4.4s, v9.4s
+        st1             {v4.4s},  [x0], #16
+        ld1             {v4.4s},  [x0]
+        sub             v4.4s, v4.4s, v8.4s
+        st1             {v4.4s},  [x0], #16
+        ld1             {v4.4s},  [x0]
+        sub             v4.4s, v4.4s, \b
+        st1             {v4.4s},  [x0], #16
+        ld1             {v4.4s},  [x0]
+        sub             v4.4s, v4.4s, \a
+        st1             {v4.4s},  [x0], #16
+.endm
+
+        store_rev       v31.4s, v27.4s, v23.4s, v19.4s, v31.16b, v27.16b
+        store_rev       v30.4s, v26.4s, v22.4s, v18.4s, v30.16b, v26.16b
+        store_rev       v29.4s, v25.4s, v21.4s, v17.4s, v29.16b, v25.16b
+        store_rev       v28.4s, v24.4s, v20.4s, v16.4s, v28.16b, v24.16b
+.purgem store_rev
+        br              x14
+endfunc
+
+// This is mostly the same as 4x32_pass1, but without the transpose,
+// and use the source as temp buffer between the two idct passes, and
+// add into the destination.
+// x0 = dst
+// x1 = dst stride
+// x2 = src (temp buffer)
+// x7 = negative double temp buffer stride
+// x9 = double temp buffer stride
+function idct32_1d_4x32_pass2\suffix\()_neon
+        mov             x14, x30
+
+        // v16 = IN(0), v17 = IN(2) ... v31 = IN(30)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #4
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #2
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #3
+.endif
+
+        bl              idct16\suffix
+
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        store           \i, x2, x9
+.endr
+
+        sub             x2,  x2,  x9, lsl #4
+        add             x2,  x2,  #128
+
+        // v16 = IN(1), v17 = IN(3) ... v31 = IN(31)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #4
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #2
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #3
+.endif
+        sub             x2,  x2,  #128
+
+        bl              idct32_odd\suffix
+
+.macro load_acc_store a, b, c, d, neg=0
+.if \neg == 0
+        ld1             {v4.4s},  [x2], x9
+        ld1             {v5.4s},  [x2], x9
+        add             v4.4s, v4.4s, \a
+        ld1             {v6.4s},  [x2], x9
+        add             v5.4s, v5.4s, \b
+        ld1             {v7.4s},  [x2], x9
+        add             v6.4s, v6.4s, \c
+        add             v7.4s, v7.4s, \d
+.else
+        ld1             {v4.4s},  [x2], x7
+        ld1             {v5.4s},  [x2], x7
+        sub             v4.4s, v4.4s, \a
+        ld1             {v6.4s},  [x2], x7
+        sub             v5.4s, v5.4s, \b
+        ld1             {v7.4s},  [x2], x7
+        sub             v6.4s, v6.4s, \c
+        sub             v7.4s, v7.4s, \d
+.endif
+        ld1             {v8.4h},   [x0], x1
+        ld1             {v8.d}[1], [x0], x1
+        srshr           v4.4s, v4.4s, #6
+        ld1             {v9.4h},   [x0], x1
+        srshr           v5.4s, v5.4s, #6
+        uaddw           v4.4s, v4.4s, v8.4h
+        ld1             {v9.d}[1], [x0], x1
+        srshr           v6.4s, v6.4s, #6
+        uaddw2          v5.4s, v5.4s, v8.8h
+        srshr           v7.4s, v7.4s, #6
+        sub             x0,  x0,  x1, lsl #2
+        uaddw           v6.4s, v6.4s, v9.4h
+        sqxtun          v4.4h, v4.4s
+        uaddw2          v7.4s, v7.4s, v9.8h
+        sqxtun2         v4.8h, v5.4s
+        umin            v4.8h, v4.8h, v15.8h
+        st1             {v4.4h},   [x0], x1
+        sqxtun          v5.4h, v6.4s
+        st1             {v4.d}[1], [x0], x1
+        sqxtun2         v5.8h, v7.4s
+        umin            v5.8h, v5.8h, v15.8h
+        st1             {v5.4h},   [x0], x1
+        st1             {v5.d}[1], [x0], x1
+.endm
+        load_acc_store  v31.4s, v30.4s, v29.4s, v28.4s
+        load_acc_store  v27.4s, v26.4s, v25.4s, v24.4s
+        load_acc_store  v23.4s, v22.4s, v21.4s, v20.4s
+        load_acc_store  v19.4s, v18.4s, v17.4s, v16.4s
+        sub             x2,  x2,  x9
+        load_acc_store  v16.4s, v17.4s, v18.4s, v19.4s, 1
+        load_acc_store  v20.4s, v21.4s, v22.4s, v23.4s, 1
+        load_acc_store  v24.4s, v25.4s, v26.4s, v27.4s, 1
+        load_acc_store  v28.4s, v29.4s, v30.4s, v31.4s, 1
+.purgem load_acc_store
+        br              x14
+endfunc
+.endm
+
+idct32_funcs
+idct32_funcs _quarter
+idct32_funcs _half
+
+const min_eob_idct_idct_32, align=4
+        .short  0, 9, 34, 70, 135, 240, 336, 448
+endconst
+
+function vp9_idct_idct_32x32_add_16_neon
+        cmp             w3,  #1
+        b.eq            idct32x32_dc_add_neon
+
+        movrel          x10, idct_coeffs
+
+        mov             x15, x30
+        stp             d8,  d9,  [sp, #-0x10]!
+        stp             d10, d11, [sp, #-0x10]!
+        stp             d12, d13, [sp, #-0x10]!
+        stp             d14, d15, [sp, #-0x10]!
+
+        sub             sp,  sp,  #4096
+
+        mov             x4,  x0
+        mov             x5,  x1
+        mov             x6,  x2
+
+        // Double stride of the input, since we only read every other line
+        mov             x9,  #256
+        neg             x7,  x9
+
+        ld1             {v0.8h,v1.8h},   [x10], #32
+        sxtl            v2.4s,  v1.4h
+        sxtl2           v3.4s,  v1.8h
+        sxtl2           v1.4s,  v0.8h
+        sxtl            v0.4s,  v0.4h
+        ld1             {v10.8h,v11.8h}, [x10]
+        sxtl            v12.4s, v11.4h
+        sxtl2           v13.4s, v11.8h
+        sxtl2           v11.4s, v10.8h
+        sxtl            v10.4s, v10.4h
+
+        dup             v15.8h, w13
+
+        cmp             w3,  #34
+        b.le            idct32x32_quarter_add_16_neon
+        cmp             w3,  #135
+        b.le            idct32x32_half_add_16_neon
+
+        movrel          x12, min_eob_idct_idct_32, 2
+
+.irp i, 0, 4, 8, 12, 16, 20, 24, 28
+        add             x0,  sp,  #(\i*128)
+.if \i > 0
+        ldrh            w1,  [x12], #2
+        cmp             w3,  w1
+        mov             x1,  #(32 - \i)/4
+        b.le            1f
+.endif
+        add             x2,  x6,  #(\i*4)
+        bl              idct32_1d_4x32_pass1_neon
+.endr
+        b               3f
+
+1:
+        // Write zeros to the temp buffer for pass 2
+        movi            v16.4s,  #0
+        movi            v17.4s,  #0
+        movi            v18.4s,  #0
+        movi            v19.4s,  #0
+2:
+        subs            x1,  x1,  #1
+.rept 4
+        st1             {v16.4s,v17.4s,v18.4s,v19.4s},  [x0], #64
+        st1             {v16.4s,v17.4s,v18.4s,v19.4s},  [x0], #64
+.endr
+        b.ne            2b
+3:
+.irp i, 0, 4, 8, 12, 16, 20, 24, 28
+        add             x0,  x4,  #(\i*2)
+        mov             x1,  x5
+        add             x2,  sp,  #(\i*4)
+        bl              idct32_1d_4x32_pass2_neon
+.endr
+
+        add             sp,  sp,  #4096
+        ldp             d14, d15, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+        ldp             d8,  d9,  [sp], 0x10
+
+        br              x15
+endfunc
+
+function ff_vp9_idct_idct_32x32_add_10_neon, export=1
+        mov             x13, #0x03ff
+        b               vp9_idct_idct_32x32_add_16_neon
+endfunc
+
+function ff_vp9_idct_idct_32x32_add_12_neon, export=1
+        mov             x13, #0x0fff
+        b               vp9_idct_idct_32x32_add_16_neon
+endfunc
+
+.macro idct32_partial size
+function idct32x32_\size\()_add_16_neon
+.irp i, 0, 4
+        add             x0,  sp,  #(\i*128)
+.ifc \size,quarter
+.if \i == 4
+        cmp             w3,  #9
+        b.le            1f
+.endif
+.endif
+        add             x2,  x6,  #(\i*4)
+        bl              idct32_1d_4x32_pass1_\size\()_neon
+.endr
+
+.ifc \size,half
+.irp i, 8, 12
+        add             x0,  sp,  #(\i*128)
+.if \i == 12
+        cmp             w3,  #70
+        b.le            1f
+.endif
+        add             x2,  x6,  #(\i*4)
+        bl              idct32_1d_4x32_pass1_\size\()_neon
+.endr
+.endif
+        b               3f
+
+1:
+        // Write zeros to the temp buffer for pass 2
+        movi            v16.4s,  #0
+        movi            v17.4s,  #0
+        movi            v18.4s,  #0
+        movi            v19.4s,  #0
+
+.rept 4
+        st1             {v16.4s,v17.4s,v18.4s,v19.4s},  [x0], #64
+        st1             {v16.4s,v17.4s,v18.4s,v19.4s},  [x0], #64
+.endr
+
+3:
+.irp i, 0, 4, 8, 12, 16, 20, 24, 28
+        add             x0,  x4,  #(\i*2)
+        mov             x1,  x5
+        add             x2,  sp,  #(\i*4)
+        bl              idct32_1d_4x32_pass2_\size\()_neon
+.endr
+
+        add             sp,  sp,  #4096
+        ldp             d14, d15, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+        ldp             d8,  d9,  [sp], 0x10
+
+        br              x15
+endfunc
+.endm
+
+idct32_partial quarter
+idct32_partial half
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/vp9itxfm_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9itxfm_neon.S
new file mode 100644
index 00000000000..99413b0f707
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9itxfm_neon.S
@@ -0,0 +1,1580 @@
+/*
+ * Copyright (c) 2016 Google Inc.
+ *
+ * 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/aarch64/asm.S"
+#include "neon.S"
+
+const itxfm4_coeffs, align=4
+        .short  11585, 0, 6270, 15137
+iadst4_coeffs:
+        .short  5283, 15212, 9929, 13377
+endconst
+
+const iadst8_coeffs, align=4
+        .short  16305, 1606, 14449, 7723, 10394, 12665, 4756, 15679
+idct_coeffs:
+        .short  11585, 0, 6270, 15137, 3196, 16069, 13623, 9102
+        .short  1606, 16305, 12665, 10394, 7723, 14449, 15679, 4756
+        .short  804, 16364, 12140, 11003, 7005, 14811, 15426, 5520
+        .short  3981, 15893, 14053, 8423, 9760, 13160, 16207, 2404
+endconst
+
+const iadst16_coeffs, align=4
+        .short  16364, 804, 15893, 3981, 11003, 12140, 8423, 14053
+        .short  14811, 7005, 13160, 9760, 5520, 15426, 2404, 16207
+endconst
+
+// out1 = ((in1 + in2) * v0[0] + (1 << 13)) >> 14
+// out2 = ((in1 - in2) * v0[0] + (1 << 13)) >> 14
+// in/out are .8h registers; this can do with 4 temp registers, but is
+// more efficient if 6 temp registers are available.
+.macro dmbutterfly0 out1, out2, in1, in2, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, neg=0
+.if \neg > 0
+        neg             \tmp4\().4h, v0.4h
+.endif
+        add             \tmp1\().8h, \in1\().8h,  \in2\().8h
+        sub             \tmp2\().8h, \in1\().8h,  \in2\().8h
+.if \neg > 0
+        smull           \tmp3\().4s, \tmp1\().4h, \tmp4\().h[0]
+        smull2          \tmp4\().4s, \tmp1\().8h, \tmp4\().h[0]
+.else
+        smull           \tmp3\().4s, \tmp1\().4h, v0.h[0]
+        smull2          \tmp4\().4s, \tmp1\().8h, v0.h[0]
+.endif
+.ifb \tmp5
+        rshrn           \out1\().4h, \tmp3\().4s, #14
+        rshrn2          \out1\().8h, \tmp4\().4s, #14
+        smull           \tmp3\().4s, \tmp2\().4h, v0.h[0]
+        smull2          \tmp4\().4s, \tmp2\().8h, v0.h[0]
+        rshrn           \out2\().4h, \tmp3\().4s, #14
+        rshrn2          \out2\().8h, \tmp4\().4s, #14
+.else
+        smull           \tmp5\().4s, \tmp2\().4h, v0.h[0]
+        smull2          \tmp6\().4s, \tmp2\().8h, v0.h[0]
+        rshrn           \out1\().4h, \tmp3\().4s, #14
+        rshrn2          \out1\().8h, \tmp4\().4s, #14
+        rshrn           \out2\().4h, \tmp5\().4s, #14
+        rshrn2          \out2\().8h, \tmp6\().4s, #14
+.endif
+.endm
+
+// Same as dmbutterfly0 above, but treating the input in in2 as zero,
+// writing the same output into both out1 and out2.
+.macro dmbutterfly0_h out1, out2, in1, in2, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6
+        smull           \tmp1\().4s,  \in1\().4h,  v0.h[0]
+        smull2          \tmp2\().4s,  \in1\().8h,  v0.h[0]
+        rshrn           \out1\().4h,  \tmp1\().4s, #14
+        rshrn2          \out1\().8h,  \tmp2\().4s, #14
+        rshrn           \out2\().4h,  \tmp1\().4s, #14
+        rshrn2          \out2\().8h,  \tmp2\().4s, #14
+.endm
+
+// out1,out2 = in1 * coef1 - in2 * coef2
+// out3,out4 = in1 * coef2 + in2 * coef1
+// out are 4 x .4s registers, in are 2 x .8h registers
+.macro dmbutterfly_l out1, out2, out3, out4, in1, in2, coef1, coef2
+        smull           \out1\().4s, \in1\().4h, \coef1
+        smull2          \out2\().4s, \in1\().8h, \coef1
+        smull           \out3\().4s, \in1\().4h, \coef2
+        smull2          \out4\().4s, \in1\().8h, \coef2
+        smlsl           \out1\().4s, \in2\().4h, \coef2
+        smlsl2          \out2\().4s, \in2\().8h, \coef2
+        smlal           \out3\().4s, \in2\().4h, \coef1
+        smlal2          \out4\().4s, \in2\().8h, \coef1
+.endm
+
+// inout1 = (inout1 * coef1 - inout2 * coef2 + (1 << 13)) >> 14
+// inout2 = (inout1 * coef2 + inout2 * coef1 + (1 << 13)) >> 14
+// inout are 2 x .8h registers
+.macro dmbutterfly inout1, inout2, coef1, coef2, tmp1, tmp2, tmp3, tmp4, neg=0
+        dmbutterfly_l   \tmp1, \tmp2, \tmp3, \tmp4, \inout1, \inout2, \coef1, \coef2
+.if \neg > 0
+        neg             \tmp3\().4s, \tmp3\().4s
+        neg             \tmp4\().4s, \tmp4\().4s
+.endif
+        rshrn           \inout1\().4h, \tmp1\().4s,  #14
+        rshrn2          \inout1\().8h, \tmp2\().4s,  #14
+        rshrn           \inout2\().4h, \tmp3\().4s,  #14
+        rshrn2          \inout2\().8h, \tmp4\().4s,  #14
+.endm
+
+// Same as dmbutterfly above, but treating the input in inout2 as zero
+.macro dmbutterfly_h1 inout1, inout2, coef1, coef2, tmp1, tmp2, tmp3, tmp4
+        smull           \tmp1\().4s, \inout1\().4h, \coef1
+        smull2          \tmp2\().4s, \inout1\().8h, \coef1
+        smull           \tmp3\().4s, \inout1\().4h, \coef2
+        smull2          \tmp4\().4s, \inout1\().8h, \coef2
+        rshrn           \inout1\().4h, \tmp1\().4s, #14
+        rshrn2          \inout1\().8h, \tmp2\().4s, #14
+        rshrn           \inout2\().4h, \tmp3\().4s, #14
+        rshrn2          \inout2\().8h, \tmp4\().4s, #14
+.endm
+
+// Same as dmbutterfly above, but treating the input in inout1 as zero
+.macro dmbutterfly_h2 inout1, inout2, coef1, coef2, tmp1, tmp2, tmp3, tmp4
+        smull           \tmp1\().4s, \inout2\().4h, \coef2
+        smull2          \tmp2\().4s, \inout2\().8h, \coef2
+        smull           \tmp3\().4s, \inout2\().4h, \coef1
+        smull2          \tmp4\().4s, \inout2\().8h, \coef1
+        neg             \tmp1\().4s, \tmp1\().4s
+        neg             \tmp2\().4s, \tmp2\().4s
+        rshrn           \inout2\().4h, \tmp3\().4s, #14
+        rshrn2          \inout2\().8h, \tmp4\().4s, #14
+        rshrn           \inout1\().4h, \tmp1\().4s, #14
+        rshrn2          \inout1\().8h, \tmp2\().4s, #14
+.endm
+
+.macro dsmull_h out1, out2, in, coef
+        smull           \out1\().4s, \in\().4h, \coef
+        smull2          \out2\().4s, \in\().8h, \coef
+.endm
+
+.macro drshrn_h out, in1, in2, shift
+        rshrn           \out\().4h, \in1\().4s, \shift
+        rshrn2          \out\().8h, \in2\().4s, \shift
+.endm
+
+
+// out1 = in1 + in2
+// out2 = in1 - in2
+.macro butterfly_8h out1, out2, in1, in2
+        add             \out1\().8h, \in1\().8h, \in2\().8h
+        sub             \out2\().8h, \in1\().8h, \in2\().8h
+.endm
+
+// out1 = in1 - in2
+// out2 = in1 + in2
+.macro butterfly_8h_r out1, out2, in1, in2
+        sub             \out1\().8h, \in1\().8h, \in2\().8h
+        add             \out2\().8h, \in1\().8h, \in2\().8h
+.endm
+
+// out1 = (in1,in2 + in3,in4 + (1 << 13)) >> 14
+// out2 = (in1,in2 - in3,in4 + (1 << 13)) >> 14
+// out are 2 x .8h registers, in are 4 x .4s registers
+.macro dbutterfly_n out1, out2, in1, in2, in3, in4, tmp1, tmp2, tmp3, tmp4
+        add             \tmp1\().4s, \in1\().4s, \in3\().4s
+        add             \tmp2\().4s, \in2\().4s, \in4\().4s
+        sub             \tmp3\().4s, \in1\().4s, \in3\().4s
+        sub             \tmp4\().4s, \in2\().4s, \in4\().4s
+        rshrn           \out1\().4h, \tmp1\().4s,  #14
+        rshrn2          \out1\().8h, \tmp2\().4s,  #14
+        rshrn           \out2\().4h, \tmp3\().4s,  #14
+        rshrn2          \out2\().8h, \tmp4\().4s,  #14
+.endm
+
+.macro iwht4 c0, c1, c2, c3
+        add             \c0\().4h, \c0\().4h, \c1\().4h
+        sub             v17.4h,    \c2\().4h, \c3\().4h
+        sub             v16.4h,    \c0\().4h, v17.4h
+        sshr            v16.4h,    v16.4h,    #1
+        sub             \c2\().4h, v16.4h,    \c1\().4h
+        sub             \c1\().4h, v16.4h,    \c3\().4h
+        add             \c3\().4h, v17.4h,    \c2\().4h
+        sub             \c0\().4h, \c0\().4h, \c1\().4h
+.endm
+
+.macro idct4 c0, c1, c2, c3
+        smull           v22.4s,    \c1\().4h, v0.h[3]
+        smull           v20.4s,    \c1\().4h, v0.h[2]
+        add             v16.4h,    \c0\().4h, \c2\().4h
+        sub             v17.4h,    \c0\().4h, \c2\().4h
+        smlal           v22.4s,    \c3\().4h, v0.h[2]
+        smull           v18.4s,    v16.4h,    v0.h[0]
+        smull           v19.4s,    v17.4h,    v0.h[0]
+        smlsl           v20.4s,    \c3\().4h, v0.h[3]
+        rshrn           v22.4h,    v22.4s,    #14
+        rshrn           v18.4h,    v18.4s,    #14
+        rshrn           v19.4h,    v19.4s,    #14
+        rshrn           v20.4h,    v20.4s,    #14
+        add             \c0\().4h, v18.4h,    v22.4h
+        sub             \c3\().4h, v18.4h,    v22.4h
+        add             \c1\().4h, v19.4h,    v20.4h
+        sub             \c2\().4h, v19.4h,    v20.4h
+.endm
+
+.macro iadst4 c0, c1, c2, c3
+        smull           v16.4s,    \c0\().4h, v0.h[4]
+        smlal           v16.4s,    \c2\().4h, v0.h[5]
+        smlal           v16.4s,    \c3\().4h, v0.h[6]
+        smull           v17.4s,    \c0\().4h, v0.h[6]
+        smlsl           v17.4s,    \c2\().4h, v0.h[4]
+        sub             \c0\().4h, \c0\().4h, \c2\().4h
+        smlsl           v17.4s,    \c3\().4h, v0.h[5]
+        add             \c0\().4h, \c0\().4h, \c3\().4h
+        smull           v19.4s,    \c1\().4h, v0.h[7]
+        smull           v18.4s,    \c0\().4h, v0.h[7]
+        add             v20.4s,    v16.4s,    v19.4s
+        add             v21.4s,    v17.4s,    v19.4s
+        rshrn           \c0\().4h, v20.4s,    #14
+        add             v16.4s,    v16.4s,    v17.4s
+        rshrn           \c1\().4h, v21.4s,    #14
+        sub             v16.4s,    v16.4s,    v19.4s
+        rshrn           \c2\().4h, v18.4s,    #14
+        rshrn           \c3\().4h, v16.4s,    #14
+.endm
+
+// The public functions in this file have got the following signature:
+// void itxfm_add(uint8_t *dst, ptrdiff_t stride, int16_t *block, int eob);
+
+.macro itxfm_func4x4 txfm1, txfm2
+function ff_vp9_\txfm1\()_\txfm2\()_4x4_add_neon, export=1
+.ifc \txfm1,\txfm2
+.ifc \txfm1,idct
+        movrel          x4,  itxfm4_coeffs
+        ld1             {v0.4h}, [x4]
+.endif
+.ifc \txfm1,iadst
+        movrel          x4,  iadst4_coeffs
+        ld1             {v0.d}[1], [x4]
+.endif
+.else
+        movrel          x4,  itxfm4_coeffs
+        ld1             {v0.8h}, [x4]
+.endif
+
+        movi            v31.8h, #0
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             w3,  #1
+        b.ne            1f
+        // DC-only for idct/idct
+        ld1             {v2.h}[0], [x2]
+        smull           v2.4s,  v2.4h, v0.h[0]
+        rshrn           v2.4h,  v2.4s, #14
+        smull           v2.4s,  v2.4h, v0.h[0]
+        rshrn           v2.4h,  v2.4s, #14
+        st1             {v31.h}[0], [x2]
+        dup             v4.4h,  v2.h[0]
+        mov             v5.16b, v4.16b
+        mov             v6.16b, v4.16b
+        mov             v7.16b, v4.16b
+        b               2f
+.endif
+
+1:
+        ld1             {v4.4h,v5.4h,v6.4h,v7.4h},  [x2]
+        st1             {v31.8h}, [x2], #16
+
+.ifc \txfm1,iwht
+        sshr            v4.4h,  v4.4h,  #2
+        sshr            v5.4h,  v5.4h,  #2
+        sshr            v6.4h,  v6.4h,  #2
+        sshr            v7.4h,  v7.4h,  #2
+.endif
+
+        \txfm1\()4      v4,  v5,  v6,  v7
+
+        st1             {v31.8h}, [x2], #16
+        // Transpose 4x4 with 16 bit elements
+        transpose_4x4H  v4,  v5,  v6,  v7,  v16, v17, v18, v19
+
+        \txfm2\()4      v4,  v5,  v6,  v7
+2:
+        ld1             {v0.s}[0],   [x0], x1
+        ld1             {v1.s}[0],   [x0], x1
+.ifnc \txfm1,iwht
+        srshr           v4.4h,  v4.4h,  #4
+        srshr           v5.4h,  v5.4h,  #4
+        srshr           v6.4h,  v6.4h,  #4
+        srshr           v7.4h,  v7.4h,  #4
+.endif
+        uaddw           v4.8h,  v4.8h,  v0.8b
+        uaddw           v5.8h,  v5.8h,  v1.8b
+        ld1             {v2.s}[0],   [x0], x1
+        ld1             {v3.s}[0],   [x0], x1
+        sqxtun          v0.8b,  v4.8h
+        sqxtun          v1.8b,  v5.8h
+        sub             x0,  x0,  x1, lsl #2
+
+        uaddw           v6.8h,  v6.8h,  v2.8b
+        uaddw           v7.8h,  v7.8h,  v3.8b
+        st1             {v0.s}[0],  [x0], x1
+        sqxtun          v2.8b,  v6.8h
+        sqxtun          v3.8b,  v7.8h
+
+        st1             {v1.s}[0],  [x0], x1
+        st1             {v2.s}[0],  [x0], x1
+        st1             {v3.s}[0],  [x0], x1
+
+        ret
+endfunc
+.endm
+
+itxfm_func4x4 idct,  idct
+itxfm_func4x4 iadst, idct
+itxfm_func4x4 idct,  iadst
+itxfm_func4x4 iadst, iadst
+itxfm_func4x4 iwht,  iwht
+
+
+.macro idct8
+        dmbutterfly0    v16, v20, v16, v20, v2, v3, v4, v5, v6, v7 // v16 = t0a, v20 = t1a
+        dmbutterfly     v18, v22, v0.h[2], v0.h[3], v2, v3, v4, v5 // v18 = t2a, v22 = t3a
+        dmbutterfly     v17, v23, v0.h[4], v0.h[5], v2, v3, v4, v5 // v17 = t4a, v23 = t7a
+        dmbutterfly     v21, v19, v0.h[6], v0.h[7], v2, v3, v4, v5 // v21 = t5a, v19 = t6a
+
+        butterfly_8h    v24, v25, v16, v22 // v24 = t0, v25 = t3
+        butterfly_8h    v28, v29, v17, v21 // v28 = t4, v29 = t5a
+        butterfly_8h    v30, v31, v23, v19 // v30 = t7, v31 = t6a
+        butterfly_8h    v26, v27, v20, v18 // v26 = t1, v27 = t2
+
+        dmbutterfly0    v31, v29, v31, v29, v2, v3, v4, v5, v6, v7 // v31 = t6, v29 = t5
+
+        butterfly_8h    v16, v23, v24, v30 // v16 = out[0], v23 = out[7]
+        butterfly_8h    v17, v22, v26, v31 // v17 = out[1], v22 = out[6]
+        butterfly_8h    v18, v21, v27, v29 // q13 = out[2], q10 = out[5]
+        butterfly_8h    v19, v20, v25, v28 // v17 = out[3], q12 = out[4]
+.endm
+
+.macro iadst8
+        dmbutterfly_l   v24, v25, v26, v27, v23, v16, v1.h[1], v1.h[0]   // v24,v25 = t1a, v26,v27 = t0a
+        dmbutterfly_l   v28, v29, v30, v31, v21, v18, v1.h[3], v1.h[2]   // v28,v29 = t3a, v30,v31 = t2a
+        dmbutterfly_l   v2,  v3,  v4,  v5,  v19, v20, v1.h[5], v1.h[4]   // v2,v3   = t5a, v4,v5   = t4a
+        dmbutterfly_l   v16, v18, v21, v23, v17, v22, v1.h[7], v1.h[6]   // v16,v18 = t7a, v21,v23 = t6a
+
+        dbutterfly_n    v4,  v5,  v26, v27, v4,  v5,  v6,  v7, v26, v27  // v4  = t0, v5  = t4
+        dbutterfly_n    v2,  v3,  v24, v25, v2,  v3,  v6,  v7, v26, v27  // v2  = t1, v3  = t5
+        dbutterfly_n    v24, v25, v30, v31, v21, v23, v6,  v7, v26, v27  // v24 = t2, v25 = t6
+        dbutterfly_n    v30, v31, v28, v29, v16, v18, v6,  v7, v26, v27  // v30 = t3, v31 = t7
+
+        butterfly_8h    v16, v6,  v4, v24 // v16 = out[0],  v6 = t2
+        butterfly_8h    v23, v7,  v2, v30 // v23 = -out[7], v7 = t3
+        neg             v23.8h,   v23.8h  // v23 = out[7]
+
+        dmbutterfly0    v19, v20, v6, v7, v24, v26, v27, v28, v29, v30   // v19 = -out[3], v20 = out[4]
+        neg             v19.8h,   v19.8h  // v19 = out[3]
+
+        dmbutterfly_l   v26, v27, v28, v29, v5,  v3,  v0.h[2], v0.h[3]   // v26,v27 = t5a, v28,v29 = t4a
+        dmbutterfly_l   v2,  v3,  v4,  v5,  v31, v25, v0.h[3], v0.h[2]   // v2,v3   = t6a, v4,v5   = t7a
+
+        dbutterfly_n    v17, v30, v28, v29, v2,  v3,  v6,  v7,  v24, v25 // v17 = -out[1], v30 = t6
+        dbutterfly_n    v22, v31, v26, v27, v4,  v5,  v6,  v7,  v24, v25 // v22 = out[6],  v31 = t7
+        neg             v17.8h,   v17.8h  // v17 = out[1]
+
+        dmbutterfly0    v18, v21, v30, v31, v2,  v3,  v4,  v5,  v6,  v7  // v18 = out[2], v21 = -out[5]
+        neg             v21.8h,   v21.8h  // v21 = out[5]
+.endm
+
+
+.macro itxfm_func8x8 txfm1, txfm2
+function ff_vp9_\txfm1\()_\txfm2\()_8x8_add_neon, export=1
+        // The iadst also uses a few coefficients from
+        // idct, so those always need to be loaded.
+.ifc \txfm1\()_\txfm2,idct_idct
+        movrel          x4,  idct_coeffs
+.else
+        movrel          x4,  iadst8_coeffs
+        ld1             {v1.8h}, [x4], #16
+.endif
+        ld1             {v0.8h}, [x4]
+
+        movi            v2.8h, #0
+        movi            v3.8h, #0
+        movi            v4.8h, #0
+        movi            v5.8h, #0
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             w3,  #1
+        b.ne            1f
+        // DC-only for idct/idct
+        ld1             {v2.h}[0],  [x2]
+        smull           v2.4s,  v2.4h, v0.h[0]
+        rshrn           v2.4h,  v2.4s, #14
+        smull           v2.4s,  v2.4h, v0.h[0]
+        rshrn           v2.4h,  v2.4s, #14
+        st1             {v3.h}[0],  [x2]
+        dup             v16.8h,  v2.h[0]
+        mov             v17.16b, v16.16b
+        mov             v18.16b, v16.16b
+        mov             v19.16b, v16.16b
+        mov             v20.16b, v16.16b
+        mov             v21.16b, v16.16b
+        mov             v22.16b, v16.16b
+        mov             v23.16b, v16.16b
+        b               2f
+.endif
+1:
+        ld1             {v16.8h,v17.8h,v18.8h,v19.8h},  [x2], #64
+        ld1             {v20.8h,v21.8h,v22.8h,v23.8h},  [x2], #64
+        sub             x2,  x2,  #128
+        st1             {v2.8h,v3.8h,v4.8h,v5.8h},      [x2], #64
+        st1             {v2.8h,v3.8h,v4.8h,v5.8h},      [x2], #64
+
+        \txfm1\()8
+
+        // Transpose 8x8 with 16 bit elements
+        transpose_8x8H  v16, v17, v18, v19, v20, v21, v22, v23, v24, v25
+
+        \txfm2\()8
+2:
+        mov             x3,  x0
+        // Add into the destination
+        ld1             {v0.8b},  [x0], x1
+        srshr           v16.8h, v16.8h, #5
+        ld1             {v1.8b},  [x0], x1
+        srshr           v17.8h, v17.8h, #5
+        ld1             {v2.8b},  [x0], x1
+        srshr           v18.8h, v18.8h, #5
+        uaddw           v16.8h, v16.8h, v0.8b
+        ld1             {v3.8b},  [x0], x1
+        srshr           v19.8h, v19.8h, #5
+        uaddw           v17.8h, v17.8h, v1.8b
+        ld1             {v4.8b},  [x0], x1
+        srshr           v20.8h, v20.8h, #5
+        uaddw           v18.8h, v18.8h, v2.8b
+        sqxtun          v0.8b,  v16.8h
+        ld1             {v5.8b},  [x0], x1
+        srshr           v21.8h, v21.8h, #5
+        uaddw           v19.8h, v19.8h, v3.8b
+        sqxtun          v1.8b,  v17.8h
+        ld1             {v6.8b},  [x0], x1
+        srshr           v22.8h, v22.8h, #5
+        uaddw           v20.8h, v20.8h, v4.8b
+        sqxtun          v2.8b,  v18.8h
+        ld1             {v7.8b},  [x0], x1
+        srshr           v23.8h, v23.8h, #5
+        uaddw           v21.8h, v21.8h, v5.8b
+        sqxtun          v3.8b,  v19.8h
+
+        st1             {v0.8b},  [x3], x1
+        uaddw           v22.8h, v22.8h, v6.8b
+        st1             {v1.8b},  [x3], x1
+        sqxtun          v4.8b,  v20.8h
+        st1             {v2.8b},  [x3], x1
+        uaddw           v23.8h, v23.8h, v7.8b
+        st1             {v3.8b},  [x3], x1
+        sqxtun          v5.8b,  v21.8h
+        st1             {v4.8b},  [x3], x1
+        sqxtun          v6.8b,  v22.8h
+        st1             {v5.8b},  [x3], x1
+        sqxtun          v7.8b,  v23.8h
+
+        st1             {v6.8b},  [x3], x1
+        st1             {v7.8b},  [x3], x1
+
+        ret
+endfunc
+.endm
+
+itxfm_func8x8 idct,  idct
+itxfm_func8x8 iadst, idct
+itxfm_func8x8 idct,  iadst
+itxfm_func8x8 iadst, iadst
+
+
+function idct16x16_dc_add_neon
+        movrel          x4,  idct_coeffs
+        ld1             {v0.4h}, [x4]
+
+        movi            v1.4h,  #0
+
+        ld1             {v2.h}[0], [x2]
+        smull           v2.4s,  v2.4h,  v0.h[0]
+        rshrn           v2.4h,  v2.4s,  #14
+        smull           v2.4s,  v2.4h,  v0.h[0]
+        rshrn           v2.4h,  v2.4s,  #14
+        dup             v2.8h,  v2.h[0]
+        st1             {v1.h}[0], [x2]
+
+        srshr           v2.8h,  v2.8h,  #6
+
+        mov             x3,  x0
+        mov             x4,  #16
+1:
+        // Loop to add the constant from v2 into all 16x16 outputs
+        subs            x4,  x4,  #2
+        ld1             {v3.16b},  [x0], x1
+        ld1             {v4.16b},  [x0], x1
+        uaddw           v16.8h, v2.8h,  v3.8b
+        uaddw2          v17.8h, v2.8h,  v3.16b
+        uaddw           v18.8h, v2.8h,  v4.8b
+        uaddw2          v19.8h, v2.8h,  v4.16b
+        sqxtun          v3.8b,  v16.8h
+        sqxtun2         v3.16b, v17.8h
+        sqxtun          v4.8b,  v18.8h
+        sqxtun2         v4.16b, v19.8h
+        st1             {v3.16b},  [x3], x1
+        st1             {v4.16b},  [x3], x1
+        b.ne            1b
+
+        ret
+endfunc
+
+.macro idct16_end
+        butterfly_8h    v18, v7,  v4,  v7                // v18 = t0a,  v7  = t7a
+        butterfly_8h    v19, v22, v5,  v22               // v19 = t1a,  v22 = t6
+        butterfly_8h    v4,  v26, v20, v26               // v4  = t2a,  v26 = t5
+        butterfly_8h    v5,  v6,  v28, v6                // v5  = t3a,  v6  = t4
+        butterfly_8h    v20, v28, v16, v24               // v20 = t8a,  v28 = t11a
+        butterfly_8h    v24, v21, v23, v21               // v24 = t9,   v21 = t10
+        butterfly_8h    v23, v27, v25, v27               // v23 = t14,  v27 = t13
+        butterfly_8h    v25, v29, v29, v17               // v25 = t15a, v29 = t12a
+
+        dmbutterfly0    v2,  v3,  v27, v21, v2,  v3,  v16, v17, v30, v31 // v2  = t13a, v3  = t10a
+        dmbutterfly0    v28, v27, v29, v28, v21, v29, v16, v17, v30, v31 // v28 = t12,  v27 = t11
+
+        butterfly_8h    v16, v31, v18, v25               // v16 = out[0], v31 = out[15]
+        butterfly_8h    v17, v30, v19, v23               // v17 = out[1], v30 = out[14]
+        butterfly_8h_r  v25, v22, v22, v24               // v25 = out[9], v22 = out[6]
+        butterfly_8h    v23, v24, v7,  v20               // v23 = out[7], v24 = out[8]
+        butterfly_8h    v18, v29, v4,  v2                // v18 = out[2], v29 = out[13]
+        butterfly_8h    v19, v28, v5,  v28               // v19 = out[3], v28 = out[12]
+        butterfly_8h    v20, v27, v6,  v27               // v20 = out[4], v27 = out[11]
+        butterfly_8h    v21, v26, v26, v3                // v21 = out[5], v26 = out[10]
+        ret
+.endm
+
+function idct16
+        dmbutterfly0    v16, v24, v16, v24, v2, v3, v4, v5, v6, v7 // v16 = t0a,  v24 = t1a
+        dmbutterfly     v20, v28, v0.h[2], v0.h[3], v2, v3, v4, v5 // v20 = t2a,  v28 = t3a
+        dmbutterfly     v18, v30, v0.h[4], v0.h[5], v2, v3, v4, v5 // v18 = t4a,  v30 = t7a
+        dmbutterfly     v26, v22, v0.h[6], v0.h[7], v2, v3, v4, v5 // v26 = t5a,  v22 = t6a
+        dmbutterfly     v17, v31, v1.h[0], v1.h[1], v2, v3, v4, v5 // v17 = t8a,  v31 = t15a
+        dmbutterfly     v25, v23, v1.h[2], v1.h[3], v2, v3, v4, v5 // v25 = t9a,  v23 = t14a
+        dmbutterfly     v21, v27, v1.h[4], v1.h[5], v2, v3, v4, v5 // v21 = t10a, v27 = t13a
+        dmbutterfly     v29, v19, v1.h[6], v1.h[7], v2, v3, v4, v5 // v29 = t11a, v19 = t12a
+
+        butterfly_8h    v4,  v28, v16, v28               // v4  = t0,   v28 = t3
+        butterfly_8h    v5,  v20, v24, v20               // v5  = t1,   v20 = t2
+        butterfly_8h    v6,  v26, v18, v26               // v6  = t4,   v26 = t5
+        butterfly_8h    v7,  v22, v30, v22               // v7  = t7,   v22 = t6
+        butterfly_8h    v16, v25, v17, v25               // v16 = t8,   v25 = t9
+        butterfly_8h    v24, v21, v29, v21               // v24 = t11,  v21 = t10
+        butterfly_8h    v17, v27, v19, v27               // v17 = t12,  v27 = t13
+        butterfly_8h    v29, v23, v31, v23               // v29 = t15,  v23 = t14
+
+        dmbutterfly0    v22, v26, v22, v26, v2, v3, v18, v19, v30, v31        // v22 = t6a,  v26 = t5a
+        dmbutterfly     v23, v25, v0.h[2], v0.h[3], v18, v19, v30, v31        // v23 = t9a,  v25 = t14a
+        dmbutterfly     v27, v21, v0.h[2], v0.h[3], v18, v19, v30, v31, neg=1 // v27 = t13a, v21 = t10a
+        idct16_end
+endfunc
+
+function idct16_half
+        dmbutterfly0_h  v16, v24, v16, v24, v2, v3, v4, v5, v6, v7 // v16 = t0a,  v24 = t1a
+        dmbutterfly_h1  v20, v28, v0.h[2], v0.h[3], v2, v3, v4, v5 // v20 = t2a,  v28 = t3a
+        dmbutterfly_h1  v18, v30, v0.h[4], v0.h[5], v2, v3, v4, v5 // v18 = t4a,  v30 = t7a
+        dmbutterfly_h2  v26, v22, v0.h[6], v0.h[7], v2, v3, v4, v5 // v26 = t5a,  v22 = t6a
+        dmbutterfly_h1  v17, v31, v1.h[0], v1.h[1], v2, v3, v4, v5 // v17 = t8a,  v31 = t15a
+        dmbutterfly_h2  v25, v23, v1.h[2], v1.h[3], v2, v3, v4, v5 // v25 = t9a,  v23 = t14a
+        dmbutterfly_h1  v21, v27, v1.h[4], v1.h[5], v2, v3, v4, v5 // v21 = t10a, v27 = t13a
+        dmbutterfly_h2  v29, v19, v1.h[6], v1.h[7], v2, v3, v4, v5 // v29 = t11a, v19 = t12a
+
+        butterfly_8h    v4,  v28, v16, v28               // v4  = t0,   v28 = t3
+        butterfly_8h    v5,  v20, v24, v20               // v5  = t1,   v20 = t2
+        butterfly_8h    v6,  v26, v18, v26               // v6  = t4,   v26 = t5
+        butterfly_8h    v7,  v22, v30, v22               // v7  = t7,   v22 = t6
+        butterfly_8h    v16, v25, v17, v25               // v16 = t8,   v25 = t9
+        butterfly_8h    v24, v21, v29, v21               // v24 = t11,  v21 = t10
+        butterfly_8h    v17, v27, v19, v27               // v17 = t12,  v27 = t13
+        butterfly_8h    v29, v23, v31, v23               // v29 = t15,  v23 = t14
+
+        dmbutterfly0    v22, v26, v22, v26, v2, v3, v18, v19, v30, v31        // v22 = t6a,  v26 = t5a
+        dmbutterfly     v23, v25, v0.h[2], v0.h[3], v18, v19, v30, v31        // v23 = t9a,  v25 = t14a
+        dmbutterfly     v27, v21, v0.h[2], v0.h[3], v18, v19, v30, v31, neg=1 // v27 = t13a, v21 = t10a
+        idct16_end
+endfunc
+
+function idct16_quarter
+        dsmull_h        v24, v25, v19, v1.h[7]
+        dsmull_h        v4,  v5,  v17, v1.h[0]
+        dsmull_h        v7,  v6,  v18, v0.h[5]
+        dsmull_h        v30, v31, v18, v0.h[4]
+        neg             v24.4s,  v24.4s
+        neg             v25.4s,  v25.4s
+        dsmull_h        v29, v28, v17, v1.h[1]
+        dsmull_h        v26, v27, v19, v1.h[6]
+        dsmull_h        v22, v23, v16, v0.h[0]
+        drshrn_h        v24, v24, v25, #14
+        drshrn_h        v16, v4,  v5,  #14
+        drshrn_h        v7,  v7,  v6,  #14
+        drshrn_h        v6,  v30, v31, #14
+        drshrn_h        v29, v29, v28, #14
+        drshrn_h        v17, v26, v27, #14
+        drshrn_h        v28, v22, v23, #14
+
+        dmbutterfly_l   v20, v21, v22, v23, v17, v24, v0.h[2], v0.h[3]
+        dmbutterfly_l   v18, v19, v30, v31, v29, v16, v0.h[2], v0.h[3]
+        neg             v22.4s,  v22.4s
+        neg             v23.4s,  v23.4s
+        drshrn_h        v27, v20, v21, #14
+        drshrn_h        v21, v22, v23, #14
+        drshrn_h        v23, v18, v19, #14
+        drshrn_h        v25, v30, v31, #14
+        mov             v4.16b,  v28.16b
+        mov             v5.16b,  v28.16b
+        dmbutterfly0    v22, v26, v7,  v6,  v18, v19, v30, v31
+        mov             v20.16b, v28.16b
+        idct16_end
+endfunc
+
+function iadst16
+        ld1             {v0.8h,v1.8h}, [x11]
+
+        dmbutterfly_l   v6,  v7,  v4,  v5,  v31, v16, v0.h[1], v0.h[0]   // v6,v7   = t1,   v4,v5   = t0
+        dmbutterfly_l   v10, v11, v8,  v9,  v23, v24, v0.h[5], v0.h[4]   // v10,v11 = t9,   v8,v9   = t8
+        dbutterfly_n    v31, v24, v6,  v7,  v10, v11, v12, v13, v10, v11 // v31     = t1a,  v24     = t9a
+        dmbutterfly_l   v14, v15, v12, v13, v29, v18, v0.h[3], v0.h[2]   // v14,v15 = t3,   v12,v13 = t2
+        dbutterfly_n    v16, v23, v4,  v5,  v8,  v9,  v6,  v7,  v8,  v9  // v16     = t0a,  v23     = t8a
+
+        dmbutterfly_l   v6,  v7,  v4,  v5,  v21, v26, v0.h[7], v0.h[6]   // v6,v7   = t11,  v4,v5   = t10
+        dbutterfly_n    v29, v26, v14, v15, v6,  v7,  v8,  v9,  v6,  v7  // v29     = t3a,  v26     = t11a
+        dmbutterfly_l   v10, v11, v8,  v9,  v27, v20, v1.h[1], v1.h[0]   // v10,v11 = t5,   v8,v9   = t4
+        dbutterfly_n    v18, v21, v12, v13, v4,  v5,  v6,  v7,  v4,  v5  // v18     = t2a,  v21     = t10a
+
+        dmbutterfly_l   v14, v15, v12, v13, v19, v28, v1.h[5], v1.h[4]   // v14,v15 = t13,  v12,v13 = t12
+        dbutterfly_n    v20, v28, v10, v11, v14, v15, v4,  v5,  v14, v15 // v20     = t5a,  v28     = t13a
+        dmbutterfly_l   v6,  v7,  v4,  v5,  v25, v22, v1.h[3], v1.h[2]   // v6,v7   = t7,   v4,v5   = t6
+        dbutterfly_n    v27, v19, v8,  v9,  v12, v13, v10, v11, v12, v13 // v27     = t4a,  v19     = t12a
+
+        dmbutterfly_l   v10, v11, v8,  v9,  v17, v30, v1.h[7], v1.h[6]   // v10,v11 = t15,  v8,v9   = t14
+        ld1             {v0.8h}, [x10]
+        dbutterfly_n    v22, v30, v6,  v7,  v10, v11, v12, v13, v10, v11 // v22     = t7a,  v30     = t15a
+        dmbutterfly_l   v14, v15, v12, v13, v23, v24, v0.h[4], v0.h[5]   // v14,v15 = t9,   v12,v13 = t8
+        dbutterfly_n    v25, v17, v4,  v5,  v8,  v9,  v6,  v7,  v8,  v9  // v25     = t6a,  v17     = t14a
+
+        dmbutterfly_l   v4,  v5,  v6,  v7,  v28, v19, v0.h[5], v0.h[4]   // v4,v5   = t12,  v6,v7   = t13
+        dbutterfly_n    v23, v19, v12, v13, v4,  v5,  v8,  v9,  v4,  v5  // v23     = t8a,  v19     = t12a
+        dmbutterfly_l   v10, v11, v8,  v9,  v21, v26, v0.h[6], v0.h[7]   // v10,v11 = t11,  v8,v9   = t10
+        butterfly_8h_r  v4,  v27, v16, v27               // v4  = t4,   v27 = t0
+        dbutterfly_n    v24, v28, v14, v15, v6,  v7,  v12, v13, v6,  v7  // v24     = t9a,  v28     = t13a
+
+        dmbutterfly_l   v12, v13, v14, v15, v30, v17, v0.h[7], v0.h[6]   // v12,v13 = t14,  v14,v15 = t15
+        butterfly_8h_r  v5,  v20, v31, v20               // v5  = t5, v20 = t1
+        dbutterfly_n    v21, v17, v8,  v9,  v12, v13, v6,  v7,  v12, v13 // v21     = t10a, v17     = t14a
+        dbutterfly_n    v26, v30, v10, v11, v14, v15, v8,  v9,  v14, v15 // v26     = t11a, v30     = t15a
+
+        butterfly_8h_r  v6,  v25, v18, v25               // v6  = t6, v25 = t2
+        butterfly_8h_r  v7,  v22, v29, v22               // v7  = t7, v22 = t3
+
+        dmbutterfly_l   v10, v11, v8,  v9,  v19, v28, v0.h[2], v0.h[3]   // v10,v11 = t13,  v8,v9   = t12
+        dmbutterfly_l   v12, v13, v14, v15, v30, v17, v0.h[3], v0.h[2]   // v12,v13 = t14,  v14,v15 = t15
+
+        dbutterfly_n    v18, v30, v8,  v9,  v12, v13, v16, v17, v12, v13 // v18   = out[2], v30     = t14a
+        dbutterfly_n    v29, v17, v10, v11, v14, v15, v12, v13, v14, v15 // v29 = -out[13], v17     = t15a
+        neg             v29.8h, v29.8h                   // v29 = out[13]
+
+        dmbutterfly_l   v10, v11, v8,  v9,  v4,  v5,  v0.h[2], v0.h[3]   // v10,v11 = t5a,  v8,v9   = t4a
+        dmbutterfly_l   v12, v13, v14, v15, v7,  v6,  v0.h[3], v0.h[2]   // v12,v13 = t6a,  v14,v15 = t7a
+
+        butterfly_8h    v2,  v6,  v27, v25               // v2 = out[0], v6 = t2a
+        butterfly_8h    v3,  v7,  v23, v21               // v3 =-out[1], v7 = t10
+
+        dbutterfly_n    v19, v31, v8,  v9,  v12, v13, v4,  v5,  v8,  v9  // v19 = -out[3],  v31 = t6
+        neg             v19.8h, v19.8h                   // v19 = out[3]
+        dbutterfly_n    v28, v16, v10, v11, v14, v15, v4,  v5,  v10, v11 // v28 = out[12],  v16 = t7
+
+        butterfly_8h    v5,  v8,  v20, v22               // v5 =-out[15],v8 = t3a
+        butterfly_8h    v4,  v9,  v24, v26               // v4 = out[14],v9 = t11
+
+        dmbutterfly0    v23, v24, v6,  v8,  v10, v11, v12, v13, v14, v15, 1 // v23 = out[7], v24 = out[8]
+        dmbutterfly0    v21, v26, v30, v17, v10, v11, v12, v13, v14, v15, 1 // v21 = out[5], v26 = out[10]
+        dmbutterfly0    v20, v27, v16, v31, v10, v11, v12, v13, v14, v15    // v20 = out[4], v27 = out[11]
+        dmbutterfly0    v22, v25, v9,  v7,  v10, v11, v12, v13, v14, v15    // v22 = out[6], v25 = out[9]
+
+        neg             v31.8h,  v5.8h                    // v31 = out[15]
+        neg             v17.8h,  v3.8h                    // v17 = out[1]
+
+        mov             v16.16b, v2.16b
+        mov             v30.16b, v4.16b
+        ret
+endfunc
+
+// Helper macros; we can't use these expressions directly within
+// e.g. .irp due to the extra concatenation \(). Therefore wrap
+// them in macros to allow using .irp below.
+.macro load i, src, inc
+        ld1             {v\i\().8h},  [\src], \inc
+.endm
+.macro store i, dst, inc
+        st1             {v\i\().8h},  [\dst], \inc
+.endm
+.macro movi_v i, size, imm
+        movi            v\i\()\size,  \imm
+.endm
+.macro load_clear i, src, inc
+        ld1             {v\i\().8h}, [\src]
+        st1             {v2.8h},  [\src], \inc
+.endm
+
+.macro load_add_store coef0, coef1, coef2, coef3, coef4, coef5, coef6, coef7, tmp1, tmp2
+        srshr           \coef0, \coef0, #6
+        ld1             {v2.8b},  [x0], x1
+        srshr           \coef1, \coef1, #6
+        ld1             {v3.8b},  [x3], x1
+        srshr           \coef2, \coef2, #6
+        ld1             {v4.8b},  [x0], x1
+        srshr           \coef3, \coef3, #6
+        uaddw           \coef0, \coef0, v2.8b
+        ld1             {v5.8b},  [x3], x1
+        uaddw           \coef1, \coef1, v3.8b
+        srshr           \coef4, \coef4, #6
+        ld1             {v6.8b},  [x0], x1
+        srshr           \coef5, \coef5, #6
+        ld1             {v7.8b},  [x3], x1
+        sqxtun          v2.8b,  \coef0
+        srshr           \coef6, \coef6, #6
+        sqxtun          v3.8b,  \coef1
+        srshr           \coef7, \coef7, #6
+        uaddw           \coef2, \coef2, v4.8b
+        ld1             {\tmp1},  [x0], x1
+        uaddw           \coef3, \coef3, v5.8b
+        ld1             {\tmp2},  [x3], x1
+        sqxtun          v4.8b,  \coef2
+        sub             x0,  x0,  x1, lsl #2
+        sub             x3,  x3,  x1, lsl #2
+        sqxtun          v5.8b,  \coef3
+        uaddw           \coef4, \coef4, v6.8b
+        st1             {v2.8b},  [x0], x1
+        uaddw           \coef5, \coef5, v7.8b
+        st1             {v3.8b},  [x3], x1
+        sqxtun          v6.8b,  \coef4
+        st1             {v4.8b},  [x0], x1
+        sqxtun          v7.8b,  \coef5
+        st1             {v5.8b},  [x3], x1
+        uaddw           \coef6, \coef6, \tmp1
+        st1             {v6.8b},  [x0], x1
+        uaddw           \coef7, \coef7, \tmp2
+        st1             {v7.8b},  [x3], x1
+        sqxtun          \tmp1,  \coef6
+        sqxtun          \tmp2,  \coef7
+        st1             {\tmp1},  [x0], x1
+        st1             {\tmp2},  [x3], x1
+.endm
+
+// Read a vertical 8x16 slice out of a 16x16 matrix, do a transform on it,
+// transpose into a horizontal 16x8 slice and store.
+// x0 = dst (temp buffer)
+// x1 = slice offset
+// x2 = src
+// x9 = input stride
+.macro itxfm16_1d_funcs txfm
+function \txfm\()16_1d_8x16_pass1_neon
+        mov             x14, x30
+
+        movi            v2.8h, #0
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        load_clear      \i,  x2,  x9
+.endr
+
+        bl              \txfm\()16
+
+        // Do two 8x8 transposes. Originally, v16-v31 contain the
+        // 16 rows. Afterwards, v16-v23 and v24-v31 contain the two
+        // transposed 8x8 blocks.
+        transpose_8x8H  v16, v17, v18, v19, v20, v21, v22, v23, v2, v3
+        transpose_8x8H  v24, v25, v26, v27, v28, v29, v30, v31, v2, v3
+
+        // Store the transposed 8x8 blocks horizontally.
+        cmp             x1,  #8
+        b.eq            1f
+.irp i, 16, 24, 17, 25, 18, 26, 19, 27, 20, 28, 21, 29, 22, 30, 23, 31
+        store           \i,  x0,  #16
+.endr
+        br              x14
+1:
+        // Special case: For the last input column (x1 == 8),
+        // which would be stored as the last row in the temp buffer,
+        // don't store the first 8x8 block, but keep it in registers
+        // for the first slice of the second pass (where it is the
+        // last 8x8 block).
+.irp i, 24, 25, 26, 27, 28, 29, 30, 31
+        add             x0,  x0,  #16
+        store           \i,  x0,  #16
+.endr
+        mov             v24.16b, v16.16b
+        mov             v25.16b, v17.16b
+        mov             v26.16b, v18.16b
+        mov             v27.16b, v19.16b
+        mov             v28.16b, v20.16b
+        mov             v29.16b, v21.16b
+        mov             v30.16b, v22.16b
+        mov             v31.16b, v23.16b
+        br              x14
+endfunc
+
+// Read a vertical 8x16 slice out of a 16x16 matrix, do a transform on it,
+// load the destination pixels (from a similar 8x16 slice), add and store back.
+// x0 = dst
+// x1 = dst stride
+// x2 = src (temp buffer)
+// x3 = slice offset
+// x9 = temp buffer stride
+function \txfm\()16_1d_8x16_pass2_neon
+        mov             x14, x30
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load            \i,  x2,  x9
+.endr
+        cbz             x3,  1f
+.irp i, 24, 25, 26, 27, 28, 29, 30, 31
+        load            \i,  x2,  x9
+.endr
+1:
+
+        add             x3,  x0,  x1
+        lsl             x1,  x1,  #1
+        bl              \txfm\()16
+
+        load_add_store  v16.8h, v17.8h, v18.8h, v19.8h, v20.8h, v21.8h, v22.8h, v23.8h, v16.8b, v17.8b
+        load_add_store  v24.8h, v25.8h, v26.8h, v27.8h, v28.8h, v29.8h, v30.8h, v31.8h, v16.8b, v17.8b
+
+        br              x14
+endfunc
+.endm
+
+itxfm16_1d_funcs idct
+itxfm16_1d_funcs iadst
+
+.macro itxfm_func16x16 txfm1, txfm2
+function ff_vp9_\txfm1\()_\txfm2\()_16x16_add_neon, export=1
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             w3,  #1
+        b.eq            idct16x16_dc_add_neon
+.endif
+        mov             x15, x30
+        // iadst16 requires clobbering v8-v15, but idct16 doesn't need to.
+.ifnc \txfm1\()_\txfm2,idct_idct
+        stp             d14, d15, [sp, #-0x10]!
+        stp             d12, d13, [sp, #-0x10]!
+        stp             d10, d11, [sp, #-0x10]!
+        stp             d8,  d9,  [sp, #-0x10]!
+.endif
+
+        sub             sp,  sp,  #512
+
+        mov             x4,  x0
+        mov             x5,  x1
+        mov             x6,  x2
+
+        movrel          x10, idct_coeffs
+.ifnc \txfm1\()_\txfm2,idct_idct
+        movrel          x11, iadst16_coeffs
+.endif
+.ifc \txfm1,idct
+        ld1             {v0.8h,v1.8h}, [x10]
+.endif
+        mov             x9,  #32
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             w3,  #10
+        b.le            idct16x16_quarter_add_neon
+        cmp             w3,  #38
+        b.le            idct16x16_half_add_neon
+.endif
+
+.irp i, 0, 8
+        add             x0,  sp,  #(\i*32)
+.ifc \txfm1\()_\txfm2,idct_idct
+.if \i == 8
+        cmp             w3,  #38
+        b.le            1f
+.endif
+.endif
+        mov             x1,  #\i
+        add             x2,  x6,  #(\i*2)
+        bl              \txfm1\()16_1d_8x16_pass1_neon
+.endr
+.ifc \txfm1\()_\txfm2,iadst_idct
+        ld1             {v0.8h,v1.8h}, [x10]
+.endif
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        b               3f
+1:
+        // Set v24-v31 to zero, for the in-register passthrough of
+        // coefficients to pass 2. Since we only do two slices, this can
+        // only ever happen for the second slice. So we only need to store
+        // zeros to the temp buffer for the second half of the buffer.
+        // Move x0 to the second half, and use x9 == 32 as increment.
+        add             x0,  x0,  #16
+.irp i, 24, 25, 26, 27, 28, 29, 30, 31
+        movi_v          \i,  .16b, #0
+        st1             {v24.8h},  [x0], x9
+.endr
+3:
+.endif
+
+.irp i, 0, 8
+        add             x0,  x4,  #(\i)
+        mov             x1,  x5
+        add             x2,  sp,  #(\i*2)
+        mov             x3,  #\i
+        bl              \txfm2\()16_1d_8x16_pass2_neon
+.endr
+
+        add             sp,  sp,  #512
+.ifnc \txfm1\()_\txfm2,idct_idct
+        ldp             d8,  d9,  [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d14, d15, [sp], 0x10
+.endif
+        br              x15
+endfunc
+.endm
+
+itxfm_func16x16 idct,  idct
+itxfm_func16x16 iadst, idct
+itxfm_func16x16 idct,  iadst
+itxfm_func16x16 iadst, iadst
+
+function idct16_1d_8x16_pass1_quarter_neon
+        mov             x14, x30
+        movi            v2.8h, #0
+.irp i, 16, 17, 18, 19
+        load_clear      \i,  x2,  x9
+.endr
+
+        bl              idct16_quarter
+
+        // Do two 8x8 transposes. Originally, v16-v31 contain the
+        // 16 rows. Afterwards, v16-v23 and v24-v31 contain the two
+        // transposed 8x8 blocks.
+        transpose_8x8H  v16, v17, v18, v19, v20, v21, v22, v23, v2, v3
+        transpose_8x8H  v24, v25, v26, v27, v28, v29, v30, v31, v2, v3
+
+        // Store the transposed 8x8 blocks horizontally.
+        // The first 8x8 block is kept in registers for the second pass,
+        // store the rest in the temp buffer.
+        // Since only a 4x4 part of the input was nonzero, this means that
+        // only 4 rows are nonzero after transposing, and the second pass
+        // only reads the topmost 4 rows. Therefore only store the topmost
+        // 4 rows.
+        add             x0,  x0,  #16
+.irp i, 24, 25, 26, 27
+        store           \i,  x0,  x9
+.endr
+        br              x14
+endfunc
+
+function idct16_1d_8x16_pass2_quarter_neon
+        mov             x14, x30
+        cbz             x3,  1f
+.irp i, 16, 17, 18, 19
+        load            \i,  x2,  x9
+.endr
+1:
+
+        add             x3,  x0,  x1
+        lsl             x1,  x1,  #1
+        bl              idct16_quarter
+
+        load_add_store  v16.8h, v17.8h, v18.8h, v19.8h, v20.8h, v21.8h, v22.8h, v23.8h, v16.8b, v17.8b
+        load_add_store  v24.8h, v25.8h, v26.8h, v27.8h, v28.8h, v29.8h, v30.8h, v31.8h, v16.8b, v17.8b
+
+        br              x14
+endfunc
+
+function idct16_1d_8x16_pass1_half_neon
+        mov             x14, x30
+        movi            v2.8h, #0
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load_clear      \i,  x2,  x9
+.endr
+
+        bl              idct16_half
+
+        // Do two 8x8 transposes. Originally, v16-v31 contain the
+        // 16 rows. Afterwards, v16-v23 and v24-v31 contain the two
+        // transposed 8x8 blocks.
+        transpose_8x8H  v16, v17, v18, v19, v20, v21, v22, v23, v2, v3
+        transpose_8x8H  v24, v25, v26, v27, v28, v29, v30, v31, v2, v3
+
+        // Store the transposed 8x8 blocks horizontally.
+        // The first 8x8 block is kept in registers for the second pass,
+        // store the rest in the temp buffer.
+        add             x0,  x0,  #16
+.irp i, 24, 25, 26, 27, 28, 29, 30, 31
+        store           \i,  x0,  x9
+.endr
+        br              x14
+endfunc
+
+function idct16_1d_8x16_pass2_half_neon
+        mov             x14, x30
+        cbz             x3,  1f
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load            \i,  x2,  x9
+.endr
+1:
+
+        add             x3,  x0,  x1
+        lsl             x1,  x1,  #1
+        bl              idct16_half
+
+        load_add_store  v16.8h, v17.8h, v18.8h, v19.8h, v20.8h, v21.8h, v22.8h, v23.8h, v16.8b, v17.8b
+        load_add_store  v24.8h, v25.8h, v26.8h, v27.8h, v28.8h, v29.8h, v30.8h, v31.8h, v16.8b, v17.8b
+
+        br              x14
+endfunc
+
+.macro idct16_partial size
+function idct16x16_\size\()_add_neon
+        add             x0,  sp,  #(0*32)
+        add             x2,  x6,  #(0*2)
+        bl              idct16_1d_8x16_pass1_\size\()_neon
+.irp i, 0, 8
+        add             x0,  x4,  #(\i)
+        mov             x1,  x5
+        add             x2,  sp,  #(\i*2)
+        mov             x3,  #\i
+        bl              idct16_1d_8x16_pass2_\size\()_neon
+.endr
+
+        add             sp,  sp,  #512
+        br              x15
+endfunc
+.endm
+
+idct16_partial quarter
+idct16_partial half
+
+function idct32x32_dc_add_neon
+        movrel          x4,  idct_coeffs
+        ld1             {v0.4h}, [x4]
+
+        movi            v1.4h,  #0
+
+        ld1             {v2.h}[0], [x2]
+        smull           v2.4s,  v2.4h,  v0.h[0]
+        rshrn           v2.4h,  v2.4s,  #14
+        smull           v2.4s,  v2.4h,  v0.h[0]
+        rshrn           v2.4h,  v2.4s,  #14
+        dup             v2.8h,  v2.h[0]
+        st1             {v1.h}[0], [x2]
+
+        srshr           v0.8h,  v2.8h,  #6
+
+        mov             x3,  x0
+        mov             x4,  #32
+1:
+        // Loop to add the constant v0 into all 32x32 outputs
+        subs            x4,  x4,  #2
+        ld1             {v1.16b,v2.16b},  [x0], x1
+        uaddw           v16.8h, v0.8h,  v1.8b
+        uaddw2          v17.8h, v0.8h,  v1.16b
+        ld1             {v3.16b,v4.16b},  [x0], x1
+        uaddw           v18.8h, v0.8h,  v2.8b
+        uaddw2          v19.8h, v0.8h,  v2.16b
+        uaddw           v20.8h, v0.8h,  v3.8b
+        uaddw2          v21.8h, v0.8h,  v3.16b
+        uaddw           v22.8h, v0.8h,  v4.8b
+        uaddw2          v23.8h, v0.8h,  v4.16b
+        sqxtun          v1.8b,  v16.8h
+        sqxtun2         v1.16b, v17.8h
+        sqxtun          v2.8b,  v18.8h
+        sqxtun2         v2.16b, v19.8h
+        sqxtun          v3.8b,  v20.8h
+        sqxtun2         v3.16b, v21.8h
+        st1             {v1.16b,v2.16b},  [x3], x1
+        sqxtun          v4.8b,  v22.8h
+        sqxtun2         v4.16b, v23.8h
+        st1             {v3.16b,v4.16b},  [x3], x1
+        b.ne            1b
+
+        ret
+endfunc
+
+.macro idct32_end
+        butterfly_8h    v16, v5,  v4,  v5  // v16 = t16a, v5  = t19a
+        butterfly_8h    v17, v20, v23, v20 // v17 = t17,  v20 = t18
+        butterfly_8h    v18, v6,  v7,  v6  // v18 = t23a, v6  = t20a
+        butterfly_8h    v19, v21, v22, v21 // v19 = t22,  v21 = t21
+        butterfly_8h    v4,  v28, v28, v30 // v4  = t24a, v28 = t27a
+        butterfly_8h    v23, v26, v25, v26 // v23 = t25,  v26 = t26
+        butterfly_8h    v7,  v3,  v29, v31 // v7  = t31a, v3  = t28a
+        butterfly_8h    v22, v27, v24, v27 // v22 = t30,  v27 = t29
+
+        dmbutterfly     v27, v20, v0.h[2], v0.h[3], v24, v25, v30, v31        // v27 = t18a, v20 = t29a
+        dmbutterfly     v3,  v5,  v0.h[2], v0.h[3], v24, v25, v30, v31        // v3  = t19,  v5  = t28
+        dmbutterfly     v28, v6,  v0.h[2], v0.h[3], v24, v25, v30, v31, neg=1 // v28 = t27,  v6  = t20
+        dmbutterfly     v26, v21, v0.h[2], v0.h[3], v24, v25, v30, v31, neg=1 // v26 = t26a, v21 = t21a
+
+        butterfly_8h    v31, v24, v7,  v4  // v31 = t31,  v24 = t24
+        butterfly_8h    v30, v25, v22, v23 // v30 = t30a, v25 = t25a
+        butterfly_8h_r  v23, v16, v16, v18 // v23 = t23,  v16 = t16
+        butterfly_8h_r  v22, v17, v17, v19 // v22 = t22a, v17 = t17a
+        butterfly_8h    v18, v21, v27, v21 // v18 = t18,  v21 = t21
+        butterfly_8h_r  v27, v28, v5,  v28 // v27 = t27a, v28 = t28a
+        butterfly_8h    v29, v26, v20, v26 // v29 = t29,  v26 = t26
+        butterfly_8h    v19, v20, v3,  v6  // v19 = t19a, v20 = t20
+
+        dmbutterfly0    v27, v20, v27, v20, v2, v3, v4, v5, v6, v7 // v27 = t27,  v20 = t20
+        dmbutterfly0    v26, v21, v26, v21, v2, v3, v4, v5, v6, v7 // v26 = t26a, v21 = t21a
+        dmbutterfly0    v25, v22, v25, v22, v2, v3, v4, v5, v6, v7 // v25 = t25,  v22 = t22
+        dmbutterfly0    v24, v23, v24, v23, v2, v3, v4, v5, v6, v7 // v24 = t24a, v23 = t23a
+        ret
+.endm
+
+function idct32_odd
+        dmbutterfly     v16, v31, v8.h[0], v8.h[1], v4, v5, v6, v7 // v16 = t16a, v31 = t31a
+        dmbutterfly     v24, v23, v8.h[2], v8.h[3], v4, v5, v6, v7 // v24 = t17a, v23 = t30a
+        dmbutterfly     v20, v27, v8.h[4], v8.h[5], v4, v5, v6, v7 // v20 = t18a, v27 = t29a
+        dmbutterfly     v28, v19, v8.h[6], v8.h[7], v4, v5, v6, v7 // v28 = t19a, v19 = t28a
+        dmbutterfly     v18, v29, v9.h[0], v9.h[1], v4, v5, v6, v7 // v18 = t20a, v29 = t27a
+        dmbutterfly     v26, v21, v9.h[2], v9.h[3], v4, v5, v6, v7 // v26 = t21a, v21 = t26a
+        dmbutterfly     v22, v25, v9.h[4], v9.h[5], v4, v5, v6, v7 // v22 = t22a, v25 = t25a
+        dmbutterfly     v30, v17, v9.h[6], v9.h[7], v4, v5, v6, v7 // v30 = t23a, v17 = t24a
+
+        butterfly_8h    v4,  v24, v16, v24 // v4  = t16, v24 = t17
+        butterfly_8h    v5,  v20, v28, v20 // v5  = t19, v20 = t18
+        butterfly_8h    v6,  v26, v18, v26 // v6  = t20, v26 = t21
+        butterfly_8h    v7,  v22, v30, v22 // v7  = t23, v22 = t22
+        butterfly_8h    v28, v25, v17, v25 // v28 = t24, v25 = t25
+        butterfly_8h    v30, v21, v29, v21 // v30 = t27, v21 = t26
+        butterfly_8h    v29, v23, v31, v23 // v29 = t31, v23 = t30
+        butterfly_8h    v31, v27, v19, v27 // v31 = t28, v27 = t29
+
+        dmbutterfly     v23, v24, v0.h[4], v0.h[5], v16, v17, v18, v19        // v23 = t17a, v24 = t30a
+        dmbutterfly     v27, v20, v0.h[4], v0.h[5], v16, v17, v18, v19, neg=1 // v27 = t29a, v20 = t18a
+        dmbutterfly     v21, v26, v0.h[6], v0.h[7], v16, v17, v18, v19        // v21 = t21a, v26 = t26a
+        dmbutterfly     v25, v22, v0.h[6], v0.h[7], v16, v17, v18, v19, neg=1 // v25 = t25a, v22 = t22a
+        idct32_end
+endfunc
+
+function idct32_odd_half
+        dmbutterfly_h1  v16, v31, v8.h[0], v8.h[1], v4, v5, v6, v7 // v16 = t16a, v31 = t31a
+        dmbutterfly_h2  v24, v23, v8.h[2], v8.h[3], v4, v5, v6, v7 // v24 = t17a, v23 = t30a
+        dmbutterfly_h1  v20, v27, v8.h[4], v8.h[5], v4, v5, v6, v7 // v20 = t18a, v27 = t29a
+        dmbutterfly_h2  v28, v19, v8.h[6], v8.h[7], v4, v5, v6, v7 // v28 = t19a, v19 = t28a
+        dmbutterfly_h1  v18, v29, v9.h[0], v9.h[1], v4, v5, v6, v7 // v18 = t20a, v29 = t27a
+        dmbutterfly_h2  v26, v21, v9.h[2], v9.h[3], v4, v5, v6, v7 // v26 = t21a, v21 = t26a
+        dmbutterfly_h1  v22, v25, v9.h[4], v9.h[5], v4, v5, v6, v7 // v22 = t22a, v25 = t25a
+        dmbutterfly_h2  v30, v17, v9.h[6], v9.h[7], v4, v5, v6, v7 // v30 = t23a, v17 = t24a
+
+        butterfly_8h    v4,  v24, v16, v24 // v4  = t16, v24 = t17
+        butterfly_8h    v5,  v20, v28, v20 // v5  = t19, v20 = t18
+        butterfly_8h    v6,  v26, v18, v26 // v6  = t20, v26 = t21
+        butterfly_8h    v7,  v22, v30, v22 // v7  = t23, v22 = t22
+        butterfly_8h    v28, v25, v17, v25 // v28 = t24, v25 = t25
+        butterfly_8h    v30, v21, v29, v21 // v30 = t27, v21 = t26
+        butterfly_8h    v29, v23, v31, v23 // v29 = t31, v23 = t30
+        butterfly_8h    v31, v27, v19, v27 // v31 = t28, v27 = t29
+
+        dmbutterfly     v23, v24, v0.h[4], v0.h[5], v16, v17, v18, v19        // v23 = t17a, v24 = t30a
+        dmbutterfly     v27, v20, v0.h[4], v0.h[5], v16, v17, v18, v19, neg=1 // v27 = t29a, v20 = t18a
+        dmbutterfly     v21, v26, v0.h[6], v0.h[7], v16, v17, v18, v19        // v21 = t21a, v26 = t26a
+        dmbutterfly     v25, v22, v0.h[6], v0.h[7], v16, v17, v18, v19, neg=1 // v25 = t25a, v22 = t22a
+        idct32_end
+endfunc
+
+function idct32_odd_quarter
+        dsmull_h        v4,  v5,  v16, v8.h[0]
+        dsmull_h        v28, v29, v19, v8.h[7]
+        dsmull_h        v30, v31, v16, v8.h[1]
+        dsmull_h        v22, v23, v17, v9.h[6]
+        dsmull_h        v7,  v6,  v17, v9.h[7]
+        dsmull_h        v26, v27, v19, v8.h[6]
+        dsmull_h        v20, v21, v18, v9.h[0]
+        dsmull_h        v24, v25, v18, v9.h[1]
+
+        neg             v28.4s, v28.4s
+        neg             v29.4s, v29.4s
+        neg             v7.4s,  v7.4s
+        neg             v6.4s,  v6.4s
+
+        drshrn_h        v4,  v4,  v5,  #14
+        drshrn_h        v5,  v28, v29, #14
+        drshrn_h        v29, v30, v31, #14
+        drshrn_h        v28, v22, v23, #14
+        drshrn_h        v7,  v7,  v6,  #14
+        drshrn_h        v31, v26, v27, #14
+        drshrn_h        v6,  v20, v21, #14
+        drshrn_h        v30, v24, v25, #14
+
+        dmbutterfly_l   v16, v17, v18, v19, v29, v4,  v0.h[4], v0.h[5]
+        dmbutterfly_l   v27, v26, v20, v21, v31, v5,  v0.h[4], v0.h[5]
+        drshrn_h        v23, v16, v17, #14
+        drshrn_h        v24, v18, v19, #14
+        neg             v20.4s, v20.4s
+        neg             v21.4s, v21.4s
+        drshrn_h        v27, v27, v26, #14
+        drshrn_h        v20, v20, v21, #14
+        dmbutterfly_l   v16, v17, v18, v19, v30, v6,  v0.h[6], v0.h[7]
+        drshrn_h        v21, v16, v17, #14
+        drshrn_h        v26, v18, v19, #14
+        dmbutterfly_l   v16, v17, v18, v19, v28, v7,  v0.h[6], v0.h[7]
+        drshrn_h        v25, v16, v17, #14
+        neg             v18.4s, v18.4s
+        neg             v19.4s, v19.4s
+        drshrn_h        v22, v18, v19, #14
+
+        idct32_end
+endfunc
+
+.macro idct32_funcs suffix
+// Do an 32-point IDCT of a 8x32 slice out of a 32x32 matrix.
+// The 32-point IDCT can be decomposed into two 16-point IDCTs;
+// a normal IDCT16 with every other input component (the even ones, with
+// each output written twice), followed by a separate 16-point IDCT
+// of the odd inputs, added/subtracted onto the outputs of the first idct16.
+// x0 = dst (temp buffer)
+// x1 = unused
+// x2 = src
+// x9 = double input stride
+function idct32_1d_8x32_pass1\suffix\()_neon
+        mov             x14, x30
+        movi            v2.8h,  #0
+
+        // v16 = IN(0), v17 = IN(2) ... v31 = IN(30)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        load_clear      \i, x2, x9
+.endr
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        load_clear      \i, x2, x9
+.endr
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load_clear      \i, x2, x9
+.endr
+.endif
+
+        bl              idct16\suffix
+
+        // Do two 8x8 transposes. Originally, v16-v31 contain the
+        // 16 rows. Afterwards, v16-v23 and v24-v31 contain the
+        // two transposed 8x8 blocks.
+        transpose_8x8H  v16, v17, v18, v19, v20, v21, v22, v23, v2, v3
+        transpose_8x8H  v24, v25, v26, v27, v28, v29, v30, v31, v2, v3
+
+        // Store the registers a, b horizontally, followed by the
+        // same registers b, a mirrored.
+.macro store_rev a, b
+        // There's no rev128 instruction, but we reverse each 64 bit
+        // half, and then flip them using an ext with 8 bytes offset.
+        rev64           v3.8h, \b
+        st1             {\a},  [x0], #16
+        rev64           v2.8h, \a
+        ext             v3.16b, v3.16b, v3.16b, #8
+        st1             {\b},  [x0], #16
+        ext             v2.16b, v2.16b, v2.16b, #8
+        st1             {v3.8h},  [x0], #16
+        st1             {v2.8h},  [x0], #16
+.endm
+        store_rev       v16.8h, v24.8h
+        store_rev       v17.8h, v25.8h
+        store_rev       v18.8h, v26.8h
+        store_rev       v19.8h, v27.8h
+        store_rev       v20.8h, v28.8h
+        store_rev       v21.8h, v29.8h
+        store_rev       v22.8h, v30.8h
+        store_rev       v23.8h, v31.8h
+        sub             x0,  x0,  #512
+.purgem store_rev
+
+        // Move x2 back to the start of the input, and move
+        // to the first odd row
+.ifb \suffix
+        sub             x2,  x2,  x9, lsl #4
+.endif
+.ifc \suffix,_quarter
+        sub             x2,  x2,  x9, lsl #2
+.endif
+.ifc \suffix,_half
+        sub             x2,  x2,  x9, lsl #3
+.endif
+        add             x2,  x2,  #64
+
+        movi            v2.8h,  #0
+        // v16 = IN(1), v17 = IN(3) ... v31 = IN(31)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        load_clear      \i, x2, x9
+.endr
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        load_clear      \i, x2, x9
+.endr
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load_clear      \i, x2, x9
+.endr
+.endif
+
+        bl              idct32_odd\suffix
+
+        transpose_8x8H  v31, v30, v29, v28, v27, v26, v25, v24, v2, v3
+        transpose_8x8H  v23, v22, v21, v20, v19, v18, v17, v16, v2, v3
+
+        // Store the registers a, b horizontally,
+        // adding into the output first, and the mirrored,
+        // subtracted from the output.
+.macro store_rev a, b
+        ld1             {v4.8h},  [x0]
+        rev64           v3.8h, \b
+        add             v4.8h, v4.8h, \a
+        rev64           v2.8h, \a
+        st1             {v4.8h},  [x0], #16
+        ext             v3.16b, v3.16b, v3.16b, #8
+        ld1             {v5.8h},  [x0]
+        ext             v2.16b, v2.16b, v2.16b, #8
+        add             v5.8h, v5.8h, \b
+        st1             {v5.8h},  [x0], #16
+        ld1             {v6.8h},  [x0]
+        sub             v6.8h, v6.8h, v3.8h
+        st1             {v6.8h},  [x0], #16
+        ld1             {v7.8h},  [x0]
+        sub             v7.8h, v7.8h, v2.8h
+        st1             {v7.8h},  [x0], #16
+.endm
+
+        store_rev       v31.8h, v23.8h
+        store_rev       v30.8h, v22.8h
+        store_rev       v29.8h, v21.8h
+        store_rev       v28.8h, v20.8h
+        store_rev       v27.8h, v19.8h
+        store_rev       v26.8h, v18.8h
+        store_rev       v25.8h, v17.8h
+        store_rev       v24.8h, v16.8h
+.purgem store_rev
+        br              x14
+endfunc
+
+// This is mostly the same as 8x32_pass1, but without the transpose,
+// and use the source as temp buffer between the two idct passes, and
+// add into the destination.
+// x0 = dst
+// x1 = dst stride
+// x2 = src (temp buffer)
+// x7 = negative double temp buffer stride
+// x9 = double temp buffer stride
+function idct32_1d_8x32_pass2\suffix\()_neon
+        mov             x14, x30
+        // v16 = IN(0), v17 = IN(2) ... v31 = IN(30)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #4
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #2
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #3
+.endif
+
+        bl              idct16\suffix
+
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        store           \i, x2, x9
+.endr
+
+        sub             x2,  x2,  x9, lsl #4
+        add             x2,  x2,  #64
+
+        // v16 = IN(1), v17 = IN(3) ... v31 = IN(31)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #4
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #2
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        load            \i, x2, x9
+.endr
+        sub             x2,  x2,  x9, lsl #3
+.endif
+        sub             x2,  x2,  #64
+
+        bl              idct32_odd\suffix
+
+.macro load_acc_store a, b, c, d, neg=0
+.if \neg == 0
+        ld1             {v4.8h},  [x2], x9
+        ld1             {v5.8h},  [x2], x9
+        add             v4.8h, v4.8h, \a
+        ld1             {v6.8h},  [x2], x9
+        add             v5.8h, v5.8h, \b
+        ld1             {v7.8h},  [x2], x9
+        add             v6.8h, v6.8h, \c
+        add             v7.8h, v7.8h, \d
+.else
+        ld1             {v4.8h},  [x2], x7
+        ld1             {v5.8h},  [x2], x7
+        sub             v4.8h, v4.8h, \a
+        ld1             {v6.8h},  [x2], x7
+        sub             v5.8h, v5.8h, \b
+        ld1             {v7.8h},  [x2], x7
+        sub             v6.8h, v6.8h, \c
+        sub             v7.8h, v7.8h, \d
+.endif
+        ld1             {v10.8b}, [x0], x1
+        ld1             {v11.8b}, [x0], x1
+        srshr           v4.8h, v4.8h, #6
+        ld1             {v2.8b}, [x0], x1
+        srshr           v5.8h, v5.8h, #6
+        uaddw           v4.8h, v4.8h, v10.8b
+        ld1             {v3.8b}, [x0], x1
+        srshr           v6.8h, v6.8h, #6
+        uaddw           v5.8h, v5.8h, v11.8b
+        srshr           v7.8h, v7.8h, #6
+        sub             x0,  x0,  x1, lsl #2
+        uaddw           v6.8h, v6.8h, v2.8b
+        sqxtun          v4.8b, v4.8h
+        uaddw           v7.8h, v7.8h, v3.8b
+        sqxtun          v5.8b, v5.8h
+        st1             {v4.8b}, [x0], x1
+        sqxtun          v6.8b, v6.8h
+        st1             {v5.8b}, [x0], x1
+        sqxtun          v7.8b, v7.8h
+        st1             {v6.8b}, [x0], x1
+        st1             {v7.8b}, [x0], x1
+.endm
+        load_acc_store  v31.8h, v30.8h, v29.8h, v28.8h
+        load_acc_store  v27.8h, v26.8h, v25.8h, v24.8h
+        load_acc_store  v23.8h, v22.8h, v21.8h, v20.8h
+        load_acc_store  v19.8h, v18.8h, v17.8h, v16.8h
+        sub             x2,  x2,  x9
+        load_acc_store  v16.8h, v17.8h, v18.8h, v19.8h, 1
+        load_acc_store  v20.8h, v21.8h, v22.8h, v23.8h, 1
+        load_acc_store  v24.8h, v25.8h, v26.8h, v27.8h, 1
+        load_acc_store  v28.8h, v29.8h, v30.8h, v31.8h, 1
+.purgem load_acc_store
+        br              x14
+endfunc
+.endm
+
+idct32_funcs
+idct32_funcs _quarter
+idct32_funcs _half
+
+const min_eob_idct_idct_32, align=4
+        .short  0, 34, 135, 336
+endconst
+
+function ff_vp9_idct_idct_32x32_add_neon, export=1
+        cmp             w3,  #1
+        b.eq            idct32x32_dc_add_neon
+
+        movrel          x10, idct_coeffs
+
+        mov             x15, x30
+
+        stp             d10, d11, [sp, #-0x10]!
+        stp             d8,  d9,  [sp, #-0x10]!
+
+        sub             sp,  sp,  #2048
+
+        mov             x4,  x0
+        mov             x5,  x1
+        mov             x6,  x2
+
+        // Double stride of the input, since we only read every other line
+        mov             x9,  #128
+        neg             x7,  x9
+
+        ld1             {v0.8h,v1.8h}, [x10], #32
+        ld1             {v8.8h,v9.8h}, [x10]
+
+        cmp             w3,  #34
+        b.le            idct32x32_quarter_add_neon
+        cmp             w3,  #135
+        b.le            idct32x32_half_add_neon
+
+        movrel          x12, min_eob_idct_idct_32, 2
+
+.irp i, 0, 8, 16, 24
+        add             x0,  sp,  #(\i*64)
+.if \i > 0
+        ldrh            w1,  [x12], #2
+        cmp             w3,  w1
+        mov             x1,  #(32 - \i)/4
+        b.le            1f
+.endif
+        add             x2,  x6,  #(\i*2)
+        bl              idct32_1d_8x32_pass1_neon
+.endr
+        b               3f
+
+1:
+        // Write zeros to the temp buffer for pass 2
+        movi            v16.8h,  #0
+        movi            v17.8h,  #0
+        movi            v18.8h,  #0
+        movi            v19.8h,  #0
+2:
+        subs            x1,  x1,  #1
+.rept 4
+        st1             {v16.8h,v17.8h,v18.8h,v19.8h},  [x0], #64
+.endr
+        b.ne            2b
+3:
+.irp i, 0, 8, 16, 24
+        add             x0,  x4,  #(\i)
+        mov             x1,  x5
+        add             x2,  sp,  #(\i*2)
+        bl              idct32_1d_8x32_pass2_neon
+.endr
+
+        add             sp,  sp,  #2048
+
+        ldp             d8,  d9,  [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+
+        br              x15
+endfunc
+
+.macro idct32_partial size
+function idct32x32_\size\()_add_neon
+        add             x0,  sp,  #(0*64)
+        add             x2,  x6,  #(0*2)
+        bl              idct32_1d_8x32_pass1_\size\()_neon
+.ifc \size,half
+        add             x0,  sp,  #(8*64)
+        add             x2,  x6,  #(8*2)
+        bl              idct32_1d_8x32_pass1_\size\()_neon
+.endif
+.irp i, 0, 8, 16, 24
+        add             x0,  x4,  #(\i)
+        mov             x1,  x5
+        add             x2,  sp,  #(\i*2)
+        bl              idct32_1d_8x32_pass2_\size\()_neon
+.endr
+
+        add             sp,  sp,  #2048
+
+        ldp             d8,  d9,  [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+
+        br              x15
+endfunc
+.endm
+
+idct32_partial quarter
+idct32_partial half
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/vp9lpf_16bpp_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9lpf_16bpp_neon.S
new file mode 100644
index 00000000000..9075f3d4061
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9lpf_16bpp_neon.S
@@ -0,0 +1,873 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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/aarch64/asm.S"
+#include "neon.S"
+
+
+.macro transpose_4x8H r0, r1, r2, r3, t4, t5, t6, t7
+        trn1            \t4\().8h,  \r0\().8h,  \r1\().8h
+        trn2            \t5\().8h,  \r0\().8h,  \r1\().8h
+        trn1            \t6\().8h,  \r2\().8h,  \r3\().8h
+        trn2            \t7\().8h,  \r2\().8h,  \r3\().8h
+
+        trn1            \r0\().4s,  \t4\().4s,  \t6\().4s
+        trn2            \r2\().4s,  \t4\().4s,  \t6\().4s
+        trn1            \r1\().4s,  \t5\().4s,  \t7\().4s
+        trn2            \r3\().4s,  \t5\().4s,  \t7\().4s
+.endm
+
+// The input to and output from this macro is in the registers v16-v31,
+// and v0-v7 are used as scratch registers.
+// p7 = v16 .. p3 = v20, p0 = v23, q0 = v24, q3 = v27, q7 = v31
+// Depending on the width of the loop filter, we either use v16-v19
+// and v28-v31 as temp registers, or v8-v15.
+.macro loop_filter wd, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8
+        dup             v0.8h,  w2                   // E
+        dup             v2.8h,  w3                   // I
+        dup             v3.8h,  w4                   // H
+
+        uabd            v4.8h,  v20.8h, v21.8h       // abs(p3 - p2)
+        uabd            v5.8h,  v21.8h, v22.8h       // abs(p2 - p1)
+        uabd            v6.8h,  v22.8h, v23.8h       // abs(p1 - p0)
+        uabd            v7.8h,  v24.8h, v25.8h       // abs(q0 - q1)
+        uabd            \tmp1\().8h,  v25.8h, v26.8h // abs(q1 - q2)
+        uabd            \tmp2\().8h,  v26.8h, v27.8h // abs(q2 - q3)
+        umax            v4.8h,  v4.8h,  v5.8h
+        umax            v5.8h,  v6.8h,  v7.8h
+        umax            \tmp1\().8h,  \tmp1\().8h, \tmp2\().8h
+        uabd            v6.8h,  v23.8h, v24.8h       // abs(p0 - q0)
+        umax            v4.8h,  v4.8h,  v5.8h
+        add             v6.8h,  v6.8h,  v6.8h        // abs(p0 - q0) * 2
+        uabd            v5.8h,  v22.8h, v25.8h       // abs(p1 - q1)
+        umax            v4.8h,  v4.8h,  \tmp1\().8h  // max(abs(p3 - p2), ..., abs(q2 - q3))
+        ushr            v5.8h,  v5.8h,  #1
+        cmhs            v4.8h,  v2.8h,  v4.8h        // max(abs()) <= I
+        add             v6.8h,  v6.8h,  v5.8h        // abs(p0 - q0) * 2 + abs(p1 - q1) >> 1
+        cmhs            v6.8h,  v0.8h,  v6.8h
+        and             v4.16b, v4.16b, v6.16b       // fm
+
+        // If no pixels need filtering, just exit as soon as possible
+        mov             x11, v4.d[0]
+        mov             x12, v4.d[1]
+        adds            x11, x11, x12
+        b.ne            1f
+        br              x10
+1:
+
+.if \wd >= 8
+        dup             v0.8h,  w5
+
+        uabd            v6.8h,  v20.8h, v23.8h       // abs(p3 - p0)
+        uabd            v2.8h,  v21.8h, v23.8h       // abs(p2 - p0)
+        uabd            v1.8h,  v22.8h, v23.8h       // abs(p1 - p0)
+        uabd            \tmp1\().8h,  v25.8h, v24.8h // abs(q1 - q0)
+        uabd            \tmp2\().8h,  v26.8h, v24.8h // abs(q2 - q0)
+        uabd            \tmp3\().8h,  v27.8h, v24.8h // abs(q3 - q0)
+        umax            v6.8h,  v6.8h,  v2.8h
+        umax            v1.8h,  v1.8h,  \tmp1\().8h
+        umax            \tmp2\().8h,  \tmp2\().8h,  \tmp3\().8h
+.if \wd == 16
+        uabd            v7.8h,  v16.8h, v23.8h       // abs(p7 - p0)
+        umax            v6.8h,  v6.8h,  v1.8h
+        uabd            v2.8h,  v17.8h, v23.8h       // abs(p6 - p0)
+        umax            v6.8h,  v6.8h,  \tmp2\().8h
+        uabd            v1.8h,  v18.8h, v23.8h       // abs(p5 - p0)
+        cmhs            v6.8h,  v0.8h,  v6.8h        // flat8in
+        uabd            v8.8h,  v19.8h, v23.8h       // abs(p4 - p0)
+        and             v6.16b, v6.16b, v4.16b       // flat8in && fm
+        uabd            v9.8h,  v28.8h, v24.8h       // abs(q4 - q0)
+        bic             v4.16b, v4.16b, v6.16b       // fm && !flat8in
+        uabd            v10.8h, v29.8h, v24.8h       // abs(q5 - q0)
+        uabd            v11.8h, v30.8h, v24.8h       // abs(q6 - q0)
+        uabd            v12.8h, v31.8h, v24.8h       // abs(q7 - q0)
+
+        umax            v7.8h,  v7.8h,  v2.8h
+        umax            v1.8h,  v1.8h,  v8.8h
+        umax            v9.8h,  v9.8h,  v10.8h
+        umax            v11.8h, v11.8h, v12.8h
+        // The rest of the calculation of flat8out is interleaved below
+.else
+        // The rest of the calculation of flat8in is interleaved below
+.endif
+.endif
+
+        // Calculate the normal inner loop filter for 2 or 4 pixels
+        uabd            v5.8h,  v22.8h, v23.8h                  // abs(p1 - p0)
+.if \wd == 16
+        umax            v7.8h,  v7.8h,  v1.8h
+        umax            v9.8h,  v9.8h,  v11.8h
+.elseif \wd == 8
+        umax            v6.8h,  v6.8h,  v1.8h
+.endif
+        uabd            v1.8h,  v25.8h, v24.8h                  // abs(q1 - q0)
+.if \wd == 16
+        umax            v7.8h,  v7.8h,  v9.8h
+.elseif \wd == 8
+        umax            v6.8h,  v6.8h,  \tmp2\().8h
+.endif
+        dup             \tmp2\().8h,  w6                        // left shift for saturation
+        sub             \tmp1\().8h,  v22.8h,  v25.8h           // p1 - q1
+        neg             \tmp6\().8h,  \tmp2\().8h               // negative left shift after saturation
+        umax            v5.8h,  v5.8h,  v1.8h                   // max(abs(p1 - p0), abs(q1 - q0))
+        sub             \tmp3\().8h,  v24.8h,  v23.8h           // q0 - p0
+        movi            \tmp5\().8h,  #3
+.if \wd == 8
+        cmhs            v6.8h,  v0.8h,  v6.8h                   // flat8in
+.endif
+        cmhs            v5.8h,  v3.8h,  v5.8h                   // !hev
+.if \wd == 8
+        and             v6.16b, v6.16b, v4.16b                  // flat8in && fm
+.endif
+        sqshl           \tmp1\().8h,  \tmp1\().8h,  \tmp2\().8h
+.if \wd == 16
+        cmhs            v7.8h,  v0.8h,  v7.8h                   // flat8out
+.elseif \wd == 8
+        bic             v4.16b, v4.16b, v6.16b                  // fm && !flat8in
+.endif
+        and             v5.16b,  v5.16b,  v4.16b                // !hev && fm && !flat8in
+.if \wd == 16
+        and             v7.16b, v7.16b, v6.16b                  // flat8out && flat8in && fm
+.endif
+        sshl            \tmp1\().8h,  \tmp1\().8h,  \tmp6\().8h // av_clip_int2p(p1 - q1, BIT_DEPTH - 1)
+
+        mul             \tmp3\().8h,  \tmp3\().8h,  \tmp5\().8h // 3 * (q0 - p0)
+        bic             \tmp1\().16b, \tmp1\().16b, v5.16b      // if (!hev) av_clip_int8 = 0
+        movi            v2.8h,  #4
+        add             \tmp3\().8h,  \tmp3\().8h,  \tmp1\().8h // 3 * (q0 - p0) [+ av_clip_int8(p1 - q1)]
+        movi            v3.8h,  #3
+        sqshl           \tmp1\().8h,  \tmp3\().8h,  \tmp2\().8h
+        movi            \tmp5\().8h,  #0
+        sshl            \tmp1\().8h,  \tmp1\().8h,  \tmp6\().8h // av_clip_int2p(3 * (q0 - p0) [+ av_clip_int2p(p1 - q1)], BIT_DEPTH - 1) = f
+        dup             \tmp6\().8h,  w7                        // max pixel value
+.if \wd == 16
+        bic             v6.16b, v6.16b, v7.16b                  // fm && flat8in && !flat8out
+.endif
+
+        ushr            \tmp2\().8h,  \tmp6\().8h,  #1          // (1 << (BIT_DEPTH - 1)) - 1
+
+        add             \tmp3\().8h,  \tmp1\().8h,  v2.8h       // f + 4
+        add             \tmp4\().8h,  \tmp1\().8h,  v3.8h       // f + 3
+        smin            \tmp3\().8h,  \tmp3\().8h,  \tmp2\().8h // FFMIN(f + 4, (1 << (BIT_DEPTH - 1)) - 1)
+        smin            \tmp4\().8h,  \tmp4\().8h,  \tmp2\().8h // FFMIN(f + 3, (1 << (BIT_DEPTH - 1)) - 1)
+        sshr            \tmp3\().8h,  \tmp3\().8h,  #3          // f1
+        sshr            \tmp4\().8h,  \tmp4\().8h,  #3          // f2
+
+        add             v0.8h,   v23.8h,  \tmp4\().8h           // p0 + f2
+        sub             v2.8h,   v24.8h,  \tmp3\().8h           // q0 - f1
+        smin            v0.8h,   v0.8h,   \tmp6\().8h
+        smin            v2.8h,   v2.8h,   \tmp6\().8h
+        srshr           \tmp3\().8h, \tmp3\().8h, #1            // f = (f1 + 1) >> 1
+        smax            v0.8h,   v0.8h,   \tmp5\().8h           // out p0
+        smax            v2.8h,   v2.8h,   \tmp5\().8h           // out q0
+        bit             v23.16b, v0.16b,  v4.16b                // if (fm && !flat8in)
+        bit             v24.16b, v2.16b,  v4.16b
+
+        add             v0.8h,  v22.8h,  \tmp3\().8h            // p1 + f
+        sub             v2.8h,  v25.8h,  \tmp3\().8h            // q1 - f
+.if \wd >= 8
+        mov             x11, v6.d[0]
+.endif
+        smin            v0.8h,  v0.8h,  \tmp6\().8h
+        smin            v2.8h,  v2.8h,  \tmp6\().8h
+.if \wd >= 8
+        mov             x12, v6.d[1]
+.endif
+        smax            v0.8h,  v0.8h,  \tmp5\().8h             // out p1
+        smax            v2.8h,  v2.8h,  \tmp5\().8h             // out q1
+.if \wd >= 8
+        adds            x11, x11, x12
+.endif
+        bit             v22.16b, v0.16b,  v5.16b                // if (!hev && fm && !flat8in)
+        bit             v25.16b, v2.16b,  v5.16b
+
+        // If no pixels need flat8in, jump to flat8out
+        // (or to a writeout of the inner 4 pixels, for wd=8)
+.if \wd >= 8
+.if \wd == 16
+        b.eq            6f
+.else
+        b.ne            1f
+        br              x13
+1:
+.endif
+
+        // flat8in
+        add             \tmp1\().8h, v20.8h, v21.8h
+        add             \tmp3\().8h, v22.8h, v25.8h
+        add             \tmp5\().8h, v20.8h, v22.8h
+        add             \tmp7\().8h, v23.8h, v26.8h
+        add             v0.8h,  \tmp1\().8h, \tmp1\().8h
+        add             v0.8h,  v0.8h,  v23.8h
+        add             v0.8h,  v0.8h,  v24.8h
+        add             v0.8h,  v0.8h,  \tmp5\().8h
+        sub             \tmp3\().8h, \tmp3\().8h, \tmp1\().8h
+        sub             \tmp7\().8h, \tmp7\().8h, \tmp5\().8h
+        urshr           v2.8h,  v0.8h,  #3                      // out p2
+
+        add             v0.8h,  v0.8h,  \tmp3\().8h
+        add             \tmp1\().8h, v20.8h,  v23.8h
+        add             \tmp3\().8h, v24.8h,  v27.8h
+        urshr           v3.8h,  v0.8h,  #3                      // out p1
+
+        add             v0.8h,  v0.8h,  \tmp7\().8h
+        sub             \tmp3\().8h, \tmp3\().8h, \tmp1\().8h
+        add             \tmp5\().8h, v21.8h,  v24.8h
+        add             \tmp7\().8h, v25.8h,  v27.8h
+        urshr           v4.8h,  v0.8h,  #3                      // out p0
+
+        add             v0.8h,  v0.8h,  \tmp3\().8h
+        sub             \tmp7\().8h, \tmp7\().8h, \tmp5\().8h
+        add             \tmp1\().8h, v22.8h,  v25.8h
+        add             \tmp3\().8h, v26.8h,  v27.8h
+        urshr           v5.8h,  v0.8h,  #3                      // out q0
+
+        add             v0.8h,  v0.8h,  \tmp7\().8h
+        sub             \tmp3\().8h, \tmp3\().8h, \tmp1\().8h
+        urshr           \tmp5\().8h, v0.8h,  #3                 // out q1
+
+        add             v0.8h,  v0.8h,  \tmp3\().8h
+        // The output here is written back into the input registers. This doesn't
+        // matter for the flat8part below, since we only update those pixels
+        // which won't be touched below.
+        bit             v21.16b, v2.16b,  v6.16b
+        bit             v22.16b, v3.16b,  v6.16b
+        bit             v23.16b, v4.16b,  v6.16b
+        urshr           \tmp6\().8h,  v0.8h,  #3                // out q2
+        bit             v24.16b, v5.16b,  v6.16b
+        bit             v25.16b, \tmp5\().16b,  v6.16b
+        bit             v26.16b, \tmp6\().16b,  v6.16b
+.endif
+.if \wd == 16
+6:
+        orr             v2.16b,  v6.16b,  v7.16b
+        mov             x11, v2.d[0]
+        mov             x12, v2.d[1]
+        adds            x11, x11, x12
+        b.ne            1f
+        // If no pixels needed flat8in nor flat8out, jump to a
+        // writeout of the inner 4 pixels
+        br              x14
+1:
+
+        mov             x11, v7.d[0]
+        mov             x12, v7.d[1]
+        adds            x11, x11, x12
+        b.ne            1f
+        // If no pixels need flat8out, jump to a writeout of the inner 6 pixels
+        br              x15
+
+1:
+        // flat8out
+        // This writes all outputs into v2-v17 (skipping v6 and v16).
+        // If this part is skipped, the output is read from v21-v26 (which is the input
+        // to this section).
+        shl             v0.8h,   v16.8h,  #3     // 8 * v16
+        sub             v0.8h,   v0.8h,   v16.8h // 7 * v16
+        add             v0.8h,   v0.8h,   v17.8h
+        add             v8.8h,   v17.8h,  v18.8h
+        add             v10.8h,  v19.8h,  v20.8h
+        add             v0.8h,   v0.8h,   v8.8h
+        add             v8.8h,   v16.8h,  v17.8h
+        add             v12.8h,  v21.8h,  v22.8h
+        add             v0.8h,   v0.8h,   v10.8h
+        add             v10.8h,  v18.8h,  v25.8h
+        add             v14.8h,  v23.8h,  v24.8h
+        sub             v10.8h,  v10.8h,  v8.8h
+        add             v0.8h,   v0.8h,   v12.8h
+        add             v0.8h,   v0.8h,   v14.8h
+        add             v12.8h,  v16.8h,  v18.8h
+        add             v14.8h,  v19.8h,  v26.8h
+        urshr           v2.8h,   v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v10.8h
+        add             v8.8h,   v16.8h,  v19.8h
+        add             v10.8h,  v20.8h,  v27.8h
+        sub             v14.8h,  v14.8h,  v12.8h
+        bif             v2.16b,  v17.16b, v7.16b
+        urshr           v3.8h ,  v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v14.8h
+        add             v12.8h,  v16.8h,  v20.8h
+        add             v14.8h,  v21.8h,  v28.8h
+        sub             v10.8h,  v10.8h,  v8.8h
+        bif             v3.16b,  v18.16b, v7.16b
+        urshr           v4.8h,   v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v10.8h
+        add             v8.8h,   v16.8h,  v21.8h
+        add             v10.8h,  v22.8h,  v29.8h
+        sub             v14.8h,  v14.8h,  v12.8h
+        bif             v4.16b,  v19.16b, v7.16b
+        urshr           v5.8h,   v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v14.8h
+        add             v12.8h,  v16.8h,  v22.8h
+        add             v14.8h,  v23.8h,  v30.8h
+        sub             v10.8h,  v10.8h,  v8.8h
+        bif             v5.16b,  v20.16b, v7.16b
+        urshr           v6.8h,   v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v10.8h
+        add             v10.8h,  v16.8h,  v23.8h
+        sub             v14.8h,  v14.8h,  v12.8h
+        add             v12.8h,  v24.8h,  v31.8h
+        bif             v6.16b,  v21.16b, v7.16b
+        urshr           v8.8h,   v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v14.8h
+        sub             v10.8h,  v12.8h,  v10.8h
+        add             v12.8h,  v17.8h,  v24.8h
+        add             v14.8h,  v25.8h,  v31.8h
+        bif             v8.16b,  v22.16b, v7.16b
+        urshr           v9.8h,   v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v10.8h
+        sub             v14.8h,  v14.8h,  v12.8h
+        add             v12.8h,  v26.8h,  v31.8h
+        bif             v9.16b,  v23.16b, v7.16b
+        urshr           v10.8h,  v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v14.8h
+        add             v14.8h,  v18.8h,  v25.8h
+        add             v18.8h,  v19.8h,  v26.8h
+        sub             v12.8h,  v12.8h,  v14.8h
+        add             v14.8h,  v27.8h,  v31.8h
+        bif             v10.16b, v24.16b, v7.16b
+        urshr           v11.8h,  v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v12.8h
+        add             v12.8h,  v20.8h,  v27.8h
+        sub             v14.8h,  v14.8h,  v18.8h
+        add             v18.8h,  v28.8h,  v31.8h
+        bif             v11.16b, v25.16b, v7.16b
+        sub             v18.8h,  v18.8h,  v12.8h
+        urshr           v12.8h,  v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v14.8h
+        add             v14.8h,  v21.8h,  v28.8h
+        add             v20.8h,  v29.8h,  v31.8h
+        bif             v12.16b, v26.16b, v7.16b
+        urshr           v13.8h,  v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v18.8h
+        sub             v20.8h,  v20.8h,  v14.8h
+        add             v18.8h,  v22.8h,  v29.8h
+        add             v22.8h,  v30.8h,  v31.8h
+        bif             v13.16b, v27.16b, v7.16b
+        urshr           v14.8h,  v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v20.8h
+        sub             v22.8h,  v22.8h,  v18.8h
+        bif             v14.16b, v28.16b, v7.16b
+        urshr           v15.8h,  v0.8h,   #4
+
+        add             v0.8h,   v0.8h,   v22.8h
+        bif             v15.16b, v29.16b, v7.16b
+        urshr           v17.8h,  v0.8h,   #4
+        bif             v17.16b, v30.16b, v7.16b
+.endif
+.endm
+
+// For wd <= 8, we use v16-v19 and v28-v31 for temp registers,
+// while we need those for inputs/outputs in wd=16 and use v8-v15
+// for temp registers there instead.
+function vp9_loop_filter_4
+        loop_filter     4,  v16, v17, v18, v19, v28, v29, v30, v31
+        ret
+endfunc
+
+function vp9_loop_filter_8
+        loop_filter     8,  v16, v17, v18, v19, v28, v29, v30, v31
+        ret
+endfunc
+
+function vp9_loop_filter_16
+        loop_filter     16, v8,  v9,  v10, v11, v12, v13, v14, v15
+        ret
+endfunc
+
+.macro loop_filter_4
+        bl              vp9_loop_filter_4
+.endm
+
+.macro loop_filter_8
+        // calculate alternative 'return' targets
+        adr             x13, 6f
+        bl              vp9_loop_filter_8
+.endm
+
+.macro loop_filter_16
+        // calculate alternative 'return' targets
+        adr             x14, 7f
+        adr             x15, 8f
+        bl              vp9_loop_filter_16
+.endm
+
+
+// The public functions in this file have got the following signature:
+// void loop_filter(uint8_t *dst, ptrdiff_t stride, int mb_lim, int lim, int hev_thr);
+
+.macro bpp_frontend func, bpp, push
+function ff_\func\()_\bpp\()_neon, export=1
+.if \push
+        mov             x16, x30
+        stp             d14, d15, [sp, #-0x10]!
+        stp             d12, d13, [sp, #-0x10]!
+        stp             d10, d11, [sp, #-0x10]!
+        stp             d8,  d9,  [sp, #-0x10]!
+.endif
+        lsl             w2,  w2,  #\bpp - 8
+        lsl             w3,  w3,  #\bpp - 8
+        lsl             w4,  w4,  #\bpp - 8
+        mov             x5,  #1 << (\bpp - 8)
+        mov             x6,  #16 - \bpp
+        mov             x7,  #((1 << \bpp) - 1)
+.if \push
+        bl              \func\()_16_neon
+        ldp             d8,  d9,  [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d14, d15, [sp], 0x10
+        br              x16
+.else
+        b               \func\()_16_neon
+.endif
+endfunc
+.endm
+
+.macro bpp_frontends func, push=0
+        bpp_frontend    \func, 10, \push
+        bpp_frontend    \func, 12, \push
+.endm
+
+.macro bpp_frontend_rep func, suffix, int_suffix, dir, bpp, push
+function ff_\func\()_\suffix\()_\bpp\()_neon, export=1
+        mov             x16, x30
+.if \push
+        stp             d14, d15, [sp, #-0x10]!
+        stp             d12, d13, [sp, #-0x10]!
+        stp             d10, d11, [sp, #-0x10]!
+        stp             d8,  d9,  [sp, #-0x10]!
+.endif
+        lsl             w2,  w2,  #\bpp - 8
+        lsl             w3,  w3,  #\bpp - 8
+        lsl             w4,  w4,  #\bpp - 8
+        mov             x5,  #1 << (\bpp - 8)
+        mov             x6,  #16 - \bpp
+        mov             x7,  #((1 << \bpp) - 1)
+        bl              \func\()_\int_suffix\()_16_neon
+.ifc \dir,h
+        add             x0,  x0,  x1, lsl #3
+.else
+        add             x0,  x0,  #16
+.endif
+        bl              \func\()_\int_suffix\()_16_neon
+.if \push
+        ldp             d8,  d9,  [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d14, d15, [sp], 0x10
+.endif
+        br              x16
+endfunc
+.endm
+
+.macro bpp_frontends_rep func, suffix, int_suffix, dir, push=0
+        bpp_frontend_rep \func, \suffix, \int_suffix, \dir, 10, \push
+        bpp_frontend_rep \func, \suffix, \int_suffix, \dir, 12, \push
+.endm
+
+.macro bpp_frontend_mix2 wd1, wd2, dir, bpp
+function ff_vp9_loop_filter_\dir\()_\wd1\()\wd2\()_16_\bpp\()_neon, export=1
+        mov             x16, x30
+        lsr             w8,  w2,  #8
+        lsr             w14, w3,  #8
+        lsr             w15, w4,  #8
+        and             w2,  w2,  #0xff
+        and             w3,  w3,  #0xff
+        and             w4,  w4,  #0xff
+        lsl             w2,  w2,  #\bpp - 8
+        lsl             w3,  w3,  #\bpp - 8
+        lsl             w4,  w4,  #\bpp - 8
+        mov             x5,  #1 << (\bpp - 8)
+        mov             x6,  #16 - \bpp
+        mov             x7,  #((1 << \bpp) - 1)
+        bl              vp9_loop_filter_\dir\()_\wd1\()_8_16_neon
+.ifc \dir,h
+        add             x0,  x0,  x1, lsl #3
+.else
+        add             x0,  x0,  #16
+.endif
+        lsl             w2,  w8,  #\bpp - 8
+        lsl             w3,  w14, #\bpp - 8
+        lsl             w4,  w15, #\bpp - 8
+        bl              vp9_loop_filter_\dir\()_\wd2\()_8_16_neon
+        br              x16
+endfunc
+.endm
+
+.macro bpp_frontends_mix2 wd1, wd2
+        bpp_frontend_mix2 \wd1, \wd2, v, 10
+        bpp_frontend_mix2 \wd1, \wd2, v, 12
+        bpp_frontend_mix2 \wd1, \wd2, h, 10
+        bpp_frontend_mix2 \wd1, \wd2, h, 12
+.endm
+
+function vp9_loop_filter_v_4_8_16_neon
+        mov             x10, x30
+        sub             x9,  x0,  x1, lsl #2
+        ld1             {v20.8h}, [x9], x1 // p3
+        ld1             {v24.8h}, [x0], x1 // q0
+        ld1             {v21.8h}, [x9], x1 // p2
+        ld1             {v25.8h}, [x0], x1 // q1
+        ld1             {v22.8h}, [x9], x1 // p1
+        ld1             {v26.8h}, [x0], x1 // q2
+        ld1             {v23.8h}, [x9], x1 // p0
+        ld1             {v27.8h}, [x0], x1 // q3
+        sub             x0,  x0,  x1, lsl #2
+        sub             x9,  x9,  x1, lsl #1
+
+        loop_filter_4
+
+        st1             {v22.8h}, [x9], x1
+        st1             {v24.8h}, [x0], x1
+        st1             {v23.8h}, [x9], x1
+        st1             {v25.8h}, [x0], x1
+        sub             x0,  x0,  x1, lsl #1
+
+        br              x10
+endfunc
+
+bpp_frontends vp9_loop_filter_v_4_8
+
+function vp9_loop_filter_h_4_8_16_neon
+        mov             x10, x30
+        sub             x9,  x0,  #8
+        add             x0,  x9,  x1, lsl #2
+        ld1             {v20.8h}, [x9], x1
+        ld1             {v24.8h}, [x0], x1
+        ld1             {v21.8h}, [x9], x1
+        ld1             {v25.8h}, [x0], x1
+        ld1             {v22.8h}, [x9], x1
+        ld1             {v26.8h}, [x0], x1
+        ld1             {v23.8h}, [x9], x1
+        ld1             {v27.8h}, [x0], x1
+
+        sub             x9,  x9,  x1, lsl #2
+        sub             x0,  x0,  x1, lsl #3
+        add             x0,  x0,  #8
+
+        transpose_8x8H  v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        loop_filter_4
+
+        // Move x9 forward by 2 pixels; we don't need to rewrite the
+        // outermost 2 pixels since they aren't changed.
+        add             x9,  x9,  #4
+        add             x0,  x9,  x1, lsl #2
+
+        // We only will write the mid 4 pixels back; after the loop filter,
+        // these are in v22, v23, v24, v25, ordered as rows (8x4 pixels).
+        // We need to transpose them to columns, done with a 4x8 transpose
+        // (which in practice is two 4x4 transposes of the two 4x4 halves
+        // of the 8x4 pixels; into 4x8 pixels).
+        transpose_4x8H  v22, v23, v24, v25, v26, v27, v28, v29
+        st1             {v22.d}[0], [x9], x1
+        st1             {v22.d}[1], [x0], x1
+        st1             {v23.d}[0], [x9], x1
+        st1             {v23.d}[1], [x0], x1
+        st1             {v24.d}[0], [x9], x1
+        st1             {v24.d}[1], [x0], x1
+        st1             {v25.d}[0], [x9], x1
+        st1             {v25.d}[1], [x0], x1
+        sub             x0,  x0,  x1, lsl #3
+        add             x0,  x0,  #4
+
+        br              x10
+endfunc
+
+bpp_frontends vp9_loop_filter_h_4_8
+
+function vp9_loop_filter_v_8_8_16_neon
+        mov             x10, x30
+        sub             x9,  x0,  x1, lsl #2
+        ld1             {v20.8h}, [x9], x1 // p3
+        ld1             {v24.8h}, [x0], x1 // q0
+        ld1             {v21.8h}, [x9], x1 // p2
+        ld1             {v25.8h}, [x0], x1 // q1
+        ld1             {v22.8h}, [x9], x1 // p1
+        ld1             {v26.8h}, [x0], x1 // q2
+        ld1             {v23.8h}, [x9], x1 // p0
+        ld1             {v27.8h}, [x0], x1 // q3
+        sub             x9,  x9,  x1, lsl #2
+        sub             x0,  x0,  x1, lsl #2
+        add             x9,  x9,  x1
+
+        loop_filter_8
+
+        st1             {v21.8h}, [x9], x1
+        st1             {v24.8h}, [x0], x1
+        st1             {v22.8h}, [x9], x1
+        st1             {v25.8h}, [x0], x1
+        st1             {v23.8h}, [x9], x1
+        st1             {v26.8h}, [x0], x1
+        sub             x0,  x0,  x1, lsl #1
+        sub             x0,  x0,  x1
+
+        br              x10
+6:
+        sub             x9,  x0,  x1, lsl #1
+        st1             {v22.8h}, [x9], x1
+        st1             {v24.8h}, [x0], x1
+        st1             {v23.8h}, [x9], x1
+        st1             {v25.8h}, [x0], x1
+        sub             x0,  x0,  x1, lsl #1
+        br              x10
+endfunc
+
+bpp_frontends vp9_loop_filter_v_8_8
+
+function vp9_loop_filter_h_8_8_16_neon
+        mov             x10, x30
+        sub             x9,  x0,  #8
+        add             x0,  x9,  x1, lsl #2
+        ld1             {v20.8h}, [x9], x1
+        ld1             {v24.8h}, [x0], x1
+        ld1             {v21.8h}, [x9], x1
+        ld1             {v25.8h}, [x0], x1
+        ld1             {v22.8h}, [x9], x1
+        ld1             {v26.8h}, [x0], x1
+        ld1             {v23.8h}, [x9], x1
+        ld1             {v27.8h}, [x0], x1
+
+        sub             x9,  x9,  x1, lsl #2
+        sub             x0,  x0,  x1, lsl #3
+        add             x0,  x0,  #8
+
+        transpose_8x8H  v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        loop_filter_8
+
+        add             x0,  x9,  x1, lsl #2
+
+        // Even though only 6 pixels per row have been changed, we write the
+        // full 8 pixel registers.
+        transpose_8x8H  v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        st1             {v20.8h}, [x9], x1
+        st1             {v24.8h}, [x0], x1
+        st1             {v21.8h}, [x9], x1
+        st1             {v25.8h}, [x0], x1
+        st1             {v22.8h}, [x9], x1
+        st1             {v26.8h}, [x0], x1
+        st1             {v23.8h}, [x9], x1
+        st1             {v27.8h}, [x0], x1
+        sub             x0,  x0,  x1, lsl #3
+        add             x0,  x0,  #8
+
+        br              x10
+6:
+        // If we didn't need to do the flat8in part, we use the same writeback
+        // as in loop_filter_h_4_8.
+        add             x9,  x9,  #4
+        add             x0,  x9,  x1, lsl #2
+        transpose_4x8H  v22, v23, v24, v25, v26, v27, v28, v29
+        st1             {v22.d}[0], [x9], x1
+        st1             {v22.d}[1], [x0], x1
+        st1             {v23.d}[0], [x9], x1
+        st1             {v23.d}[1], [x0], x1
+        st1             {v24.d}[0], [x9], x1
+        st1             {v24.d}[1], [x0], x1
+        st1             {v25.d}[0], [x9], x1
+        st1             {v25.d}[1], [x0], x1
+        sub             x0,  x0,  x1, lsl #3
+        add             x0,  x0,  #4
+        br              x10
+endfunc
+
+bpp_frontends vp9_loop_filter_h_8_8
+
+bpp_frontends_mix2 4, 4
+bpp_frontends_mix2 4, 8
+bpp_frontends_mix2 8, 4
+bpp_frontends_mix2 8, 8
+
+function vp9_loop_filter_v_16_8_16_neon
+        mov             x10, x30
+        sub             x9,  x0,  x1, lsl #3
+        ld1             {v16.8h}, [x9], x1 // p7
+        ld1             {v24.8h}, [x0], x1 // q0
+        ld1             {v17.8h}, [x9], x1 // p6
+        ld1             {v25.8h}, [x0], x1 // q1
+        ld1             {v18.8h}, [x9], x1 // p5
+        ld1             {v26.8h}, [x0], x1 // q2
+        ld1             {v19.8h}, [x9], x1 // p4
+        ld1             {v27.8h}, [x0], x1 // q3
+        ld1             {v20.8h}, [x9], x1 // p3
+        ld1             {v28.8h}, [x0], x1 // q4
+        ld1             {v21.8h}, [x9], x1 // p2
+        ld1             {v29.8h}, [x0], x1 // q5
+        ld1             {v22.8h}, [x9], x1 // p1
+        ld1             {v30.8h}, [x0], x1 // q6
+        ld1             {v23.8h}, [x9], x1 // p0
+        ld1             {v31.8h}, [x0], x1 // q7
+        sub             x9,  x9,  x1, lsl #3
+        sub             x0,  x0,  x1, lsl #3
+        add             x9,  x9,  x1
+
+        loop_filter_16
+
+        // If we did the flat8out part, we get the output in
+        // v2-v17 (skipping v7 and v16). x9 points to x0 - 7 * stride,
+        // store v2-v9 there, and v10-v17 into x0.
+        st1             {v2.8h},  [x9], x1
+        st1             {v10.8h}, [x0], x1
+        st1             {v3.8h},  [x9], x1
+        st1             {v11.8h}, [x0], x1
+        st1             {v4.8h},  [x9], x1
+        st1             {v12.8h}, [x0], x1
+        st1             {v5.8h},  [x9], x1
+        st1             {v13.8h}, [x0], x1
+        st1             {v6.8h},  [x9], x1
+        st1             {v14.8h}, [x0], x1
+        st1             {v8.8h},  [x9], x1
+        st1             {v15.8h}, [x0], x1
+        st1             {v9.8h},  [x9], x1
+        st1             {v17.8h}, [x0], x1
+        sub             x0,  x0,  x1, lsl #3
+        add             x0,  x0,  x1
+
+        br              x10
+8:
+        add             x9,  x9,  x1, lsl #2
+        // If we didn't do the flat8out part, the output is left in the
+        // input registers.
+        st1             {v21.8h}, [x9], x1
+        st1             {v24.8h}, [x0], x1
+        st1             {v22.8h}, [x9], x1
+        st1             {v25.8h}, [x0], x1
+        st1             {v23.8h}, [x9], x1
+        st1             {v26.8h}, [x0], x1
+        sub             x0,  x0,  x1, lsl #1
+        sub             x0,  x0,  x1
+        br              x10
+7:
+        sub             x9,  x0,  x1, lsl #1
+        st1             {v22.8h}, [x9], x1
+        st1             {v24.8h}, [x0], x1
+        st1             {v23.8h}, [x9], x1
+        st1             {v25.8h}, [x0], x1
+        sub             x0,  x0,  x1, lsl #1
+        br              x10
+endfunc
+
+bpp_frontends vp9_loop_filter_v_16_8, push=1
+bpp_frontends_rep vp9_loop_filter_v_16, 16, 8, v, push=1
+
+function vp9_loop_filter_h_16_8_16_neon
+        mov             x10, x30
+        sub             x9,  x0,  #16
+        ld1             {v16.8h}, [x9], x1
+        ld1             {v24.8h}, [x0], x1
+        ld1             {v17.8h}, [x9], x1
+        ld1             {v25.8h}, [x0], x1
+        ld1             {v18.8h}, [x9], x1
+        ld1             {v26.8h}, [x0], x1
+        ld1             {v19.8h}, [x9], x1
+        ld1             {v27.8h}, [x0], x1
+        ld1             {v20.8h}, [x9], x1
+        ld1             {v28.8h}, [x0], x1
+        ld1             {v21.8h}, [x9], x1
+        ld1             {v29.8h}, [x0], x1
+        ld1             {v22.8h}, [x9], x1
+        ld1             {v30.8h}, [x0], x1
+        ld1             {v23.8h}, [x9], x1
+        ld1             {v31.8h}, [x0], x1
+        sub             x0,  x0,  x1, lsl #3
+        sub             x9,  x9,  x1, lsl #3
+
+        // The 16x8 pixels read above is in two 8x8 blocks; the left
+        // half in v16-v23, and the right half in v24-v31. Do two 8x8 transposes
+        // of this, to get one column per register.
+        transpose_8x8H  v16, v17, v18, v19, v20, v21, v22, v23, v0, v1
+        transpose_8x8H  v24, v25, v26, v27, v28, v29, v30, v31, v0, v1
+
+        loop_filter_16
+
+        transpose_8x8H  v16, v2,  v3,  v4,  v5,  v6,  v8,  v9,  v0, v1
+        transpose_8x8H  v10, v11, v12, v13, v14, v15, v17, v31, v0, v1
+
+        st1             {v16.8h}, [x9], x1
+        st1             {v10.8h}, [x0], x1
+        st1             {v2.8h},  [x9], x1
+        st1             {v11.8h}, [x0], x1
+        st1             {v3.8h},  [x9], x1
+        st1             {v12.8h}, [x0], x1
+        st1             {v4.8h},  [x9], x1
+        st1             {v13.8h}, [x0], x1
+        st1             {v5.8h},  [x9], x1
+        st1             {v14.8h}, [x0], x1
+        st1             {v6.8h},  [x9], x1
+        st1             {v15.8h}, [x0], x1
+        st1             {v8.8h},  [x9], x1
+        st1             {v17.8h}, [x0], x1
+        st1             {v9.8h},  [x9], x1
+        st1             {v31.8h}, [x0], x1
+        sub             x0,  x0,  x1, lsl #3
+
+        br              x10
+8:
+        // The same writeback as in loop_filter_h_8_8
+        sub             x9,  x0,  #8
+        add             x0,  x9,  x1, lsl #2
+        transpose_8x8H  v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        st1             {v20.8h}, [x9], x1
+        st1             {v24.8h}, [x0], x1
+        st1             {v21.8h}, [x9], x1
+        st1             {v25.8h}, [x0], x1
+        st1             {v22.8h}, [x9], x1
+        st1             {v26.8h}, [x0], x1
+        st1             {v23.8h}, [x9], x1
+        st1             {v27.8h}, [x0], x1
+        sub             x0,  x0,  x1, lsl #3
+        add             x0,  x0,  #8
+        br              x10
+7:
+        // The same writeback as in loop_filter_h_4_8
+        sub             x9,  x0,  #4
+        add             x0,  x9,  x1, lsl #2
+        transpose_4x8H  v22, v23, v24, v25, v26, v27, v28, v29
+        st1             {v22.d}[0], [x9], x1
+        st1             {v22.d}[1], [x0], x1
+        st1             {v23.d}[0], [x9], x1
+        st1             {v23.d}[1], [x0], x1
+        st1             {v24.d}[0], [x9], x1
+        st1             {v24.d}[1], [x0], x1
+        st1             {v25.d}[0], [x9], x1
+        st1             {v25.d}[1], [x0], x1
+        sub             x0,  x0,  x1, lsl #3
+        add             x0,  x0,  #4
+        br              x10
+endfunc
+
+bpp_frontends vp9_loop_filter_h_16_8, push=1
+bpp_frontends_rep vp9_loop_filter_h_16, 16, 8, h, push=1
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/vp9lpf_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9lpf_neon.S
new file mode 100644
index 00000000000..0878763020a
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9lpf_neon.S
@@ -0,0 +1,1334 @@
+/*
+ * Copyright (c) 2016 Google Inc.
+ *
+ * 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/aarch64/asm.S"
+#include "neon.S"
+
+
+// The main loop filter macro is templated and can produce filters for
+// vectors of 8 or 16 bytes. The register mapping throughout the filter
+// is close to identical to the arm version (please try to maintain this,
+// if either is changed!). When the arm version uses e.g. d20 for the
+// input variable p3, the aarch64 version uses v20.8b or v20.16b, depending
+// on vector length.
+//
+// The number of elements in the vector is passed in via the macro parameter
+// \sz, which is either .8b or .16b. For simple instructions that doesn't
+// lengthen or narrow things, this can easily be templated like this:
+//      uabd            v4\sz,  v20\sz, v21\sz
+//
+// For instructions that lengthen or narrow content, the arm version would
+// have used q registers. For these instructions, we have macros that expand
+// into either a single e.g. uaddl instruction, or into a uaddl + uaddl2
+// pair, depending on the \sz parameter. Wherever the arm version would have
+// used a q register, these macros instead take two v registers, i.e. q3
+// is mapped to v6+v7. For the case with 8 byte input vectors, such a
+// lengthening operation is only stored in v6.8h (what was in q3 in the arm
+// case), while the 16 byte input vectors will use v6.8h + v7.8h.
+// Such a macro invocation would look like this:
+//      uaddl_sz        v8.8h,  v9.8h,  v17, v18, \sz
+//
+// That is, in the 8 byte input vector case, the second register in these
+// register pairs will be unused.
+// Unfortunately, this makes the code quite hard to read. For readability,
+// see the arm version instead.
+
+
+.macro add_sz dst1, dst2, in1, in2, in3, in4, sz
+        add             \dst1,  \in1,  \in3
+.ifc \sz, .16b
+        add             \dst2,  \in2,  \in4
+.endif
+.endm
+
+.macro sub_sz dst1, dst2, in1, in2, in3, in4, sz
+        sub             \dst1,  \in1,  \in3
+.ifc \sz, .16b
+        sub             \dst2,  \in2,  \in4
+.endif
+.endm
+
+.macro uaddw_sz dst1, dst2, in1, in2, in3, sz
+        uaddw           \dst1,  \in1, \in3\().8b
+.ifc \sz, .16b
+        uaddw2          \dst2,  \in2, \in3\().16b
+.endif
+.endm
+
+.macro usubw_sz dst1, dst2, in1, in2, in3, sz
+        usubw           \dst1,  \in1, \in3\().8b
+.ifc \sz, .16b
+        usubw2          \dst2,  \in2, \in3\().16b
+.endif
+.endm
+
+.macro usubl_sz dst1, dst2, in1, in2, sz
+        usubl           \dst1,  \in1\().8b,  \in2\().8b
+.ifc \sz, .16b
+        usubl2          \dst2,  \in1\().16b, \in2\().16b
+.endif
+.endm
+
+.macro sqxtn_sz dst, in1, in2, sz
+        sqxtn           \dst\().8b,  \in1
+.ifc \sz, .16b
+        sqxtn2          \dst\().16b, \in2
+.endif
+.endm
+
+.macro sqxtun_sz dst, in1, in2, sz
+        sqxtun          \dst\().8b,  \in1
+.ifc \sz, .16b
+        sqxtun2         \dst\().16b, \in2
+.endif
+.endm
+
+.macro mul_sz dst1, dst2, in1, in2, in3, in4, sz
+        mul             \dst1,  \in1,  \in3
+.ifc \sz, .16b
+        mul             \dst2,  \in2,  \in4
+.endif
+.endm
+
+.macro saddw_sz dst1, dst2, in1, in2, in3, sz
+        saddw           \dst1,  \in1, \in3\().8b
+.ifc \sz, .16b
+        saddw2          \dst2,  \in2, \in3\().16b
+.endif
+.endm
+
+.macro ssubw_sz dst1, dst2, in1, in2, in3, sz
+        ssubw           \dst1,  \in1, \in3\().8b
+.ifc \sz, .16b
+        ssubw2          \dst2,  \in2, \in3\().16b
+.endif
+.endm
+
+.macro uxtl_sz dst1, dst2, in, sz
+        uxtl            \dst1,  \in\().8b
+.ifc \sz, .16b
+        uxtl2           \dst2,  \in\().16b
+.endif
+.endm
+
+.macro uaddl_sz dst1, dst2, in1, in2, sz
+        uaddl           \dst1,  \in1\().8b,  \in2\().8b
+.ifc \sz, .16b
+        uaddl2          \dst2,  \in1\().16b, \in2\().16b
+.endif
+.endm
+
+.macro rshrn_sz dst, in1, in2, shift, sz
+        rshrn           \dst\().8b,  \in1, \shift
+.ifc \sz, .16b
+        rshrn2          \dst\().16b, \in2, \shift
+.endif
+.endm
+
+.macro ushll_sz dst1, dst2, in, shift, sz
+        ushll           \dst1,  \in\().8b,  \shift
+.ifc \sz, .16b
+        ushll2          \dst2,  \in\().16b, \shift
+.endif
+.endm
+
+// The input to and output from this macro is in the registers v16-v31,
+// and v0-v7 are used as scratch registers.
+// p7 = v16 .. p3 = v20, p0 = v23, q0 = v24, q3 = v27, q7 = v31
+// Depending on the width of the loop filter, we either use v16-v19
+// and v28-v31 as temp registers, or v8-v15.
+// When comparing to the arm version, tmpq1 == tmp1 + tmp2,
+// tmpq2 == tmp3 + tmp4, etc.
+.macro loop_filter wd, sz, mix, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8
+.if \mix == 0
+        dup             v0\sz,  w2        // E
+        dup             v2\sz,  w3        // I
+        dup             v3\sz,  w4        // H
+.else
+        dup             v0.8h,  w2        // E
+        dup             v2.8h,  w3        // I
+        dup             v3.8h,  w4        // H
+        rev16           v1.16b, v0.16b    // E
+        rev16           v4.16b, v2.16b    // I
+        rev16           v5.16b, v3.16b    // H
+        uzp1            v0.16b, v0.16b, v1.16b
+        uzp1            v2.16b, v2.16b, v4.16b
+        uzp1            v3.16b, v3.16b, v5.16b
+.endif
+
+        uabd            v4\sz,  v20\sz, v21\sz        // abs(p3 - p2)
+        uabd            v5\sz,  v21\sz, v22\sz        // abs(p2 - p1)
+        uabd            v6\sz,  v22\sz, v23\sz        // abs(p1 - p0)
+        uabd            v7\sz,  v24\sz, v25\sz        // abs(q0 - q1)
+        uabd            \tmp1\sz,  v25\sz, v26\sz     // abs(q1 - q2)
+        uabd            \tmp2\sz,  v26\sz, v27\sz     // abs(q2 - q3)
+        umax            v4\sz,  v4\sz,  v5\sz
+        umax            v5\sz,  v6\sz,  v7\sz
+        umax            \tmp1\sz, \tmp1\sz, \tmp2\sz
+        uabd            v6\sz,  v23\sz, v24\sz        // abs(p0 - q0)
+        umax            v4\sz,  v4\sz,  v5\sz
+        uqadd           v6\sz,  v6\sz,  v6\sz         // abs(p0 - q0) * 2
+        uabd            v5\sz,  v22\sz, v25\sz        // abs(p1 - q1)
+        umax            v4\sz,  v4\sz,  \tmp1\sz      // max(abs(p3 - p2), ..., abs(q2 - q3))
+        ushr            v5\sz,  v5\sz,  #1
+        cmhs            v4\sz,  v2\sz,  v4\sz         // max(abs()) <= I
+        uqadd           v6\sz,  v6\sz,  v5\sz         // abs(p0 - q0) * 2 + abs(p1 - q1) >> 1
+        cmhs            v5\sz,  v0\sz,  v6\sz
+        and             v4\sz,  v4\sz,  v5\sz         // fm
+
+        // If no pixels need filtering, just exit as soon as possible
+        mov             x5,  v4.d[0]
+.ifc \sz, .16b
+        mov             x6,  v4.d[1]
+        adds            x5,  x5,  x6
+        b.eq            9f
+.else
+        cbz             x5,  9f
+.endif
+
+.if \wd >= 8
+        movi            v0\sz,  #1
+
+        uabd            v6\sz,  v20\sz, v23\sz    // abs(p3 - p0)
+        uabd            v2\sz,  v21\sz, v23\sz    // abs(p2 - p0)
+        uabd            v1\sz,  v22\sz, v23\sz    // abs(p1 - p0)
+        uabd            \tmp1\sz,  v25\sz, v24\sz // abs(q1 - q0)
+        uabd            \tmp2\sz,  v26\sz, v24\sz // abs(q2 - q0)
+        uabd            \tmp3\sz,  v27\sz, v24\sz // abs(q3 - q0)
+        umax            v6\sz,  v6\sz,  v2\sz
+        umax            v1\sz,  v1\sz,  \tmp1\sz
+        umax            \tmp2\sz,  \tmp2\sz,  \tmp3\sz
+.if \wd == 16
+        uabd            v7\sz,  v16\sz, v23\sz    // abs(p7 - p0)
+        umax            v6\sz,  v6\sz,  v1\sz
+        uabd            v2\sz,  v17\sz, v23\sz    // abs(p6 - p0)
+        umax            v6\sz,  v6\sz,  \tmp2\sz
+        uabd            v1\sz,  v18\sz, v23\sz    // abs(p5 - p0)
+        cmhs            v6\sz,  v0\sz,  v6\sz     // flat8in
+        uabd            v8\sz,  v19\sz, v23\sz    // abs(p4 - p0)
+        and             v6\sz,  v6\sz,  v4\sz     // flat8in && fm
+        uabd            v9\sz,  v28\sz, v24\sz    // abs(q4 - q0)
+        bic             v4\sz,  v4\sz,  v6\sz     // fm && !flat8in
+        uabd            v10\sz, v29\sz, v24\sz    // abs(q5 - q0)
+        uabd            v11\sz, v30\sz, v24\sz    // abs(q6 - q0)
+        uabd            v12\sz, v31\sz, v24\sz    // abs(q7 - q0)
+
+        umax            v7\sz,  v7\sz,  v2\sz
+        umax            v1\sz,  v1\sz,  v8\sz
+        umax            v9\sz,  v9\sz,  v10\sz
+        umax            v11\sz, v11\sz, v12\sz
+        // The rest of the calculation of flat8out is interleaved below
+.else
+        // The rest of the calculation of flat8in is interleaved below
+.endif
+.endif
+
+        // Calculate the normal inner loop filter for 2 or 4 pixels
+        uabd            v5\sz,  v22\sz, v23\sz // abs(p1 - p0)
+.if \wd == 16
+        umax            v7\sz,  v7\sz,  v1\sz
+        umax            v9\sz,  v9\sz,  v11\sz
+.elseif \wd == 8
+        umax            v6\sz,  v6\sz,  v1\sz
+.endif
+        uabd            v1\sz,  v25\sz, v24\sz // abs(q1 - q0)
+.if \wd == 16
+        umax            v7\sz,  v7\sz,  v9\sz
+.elseif \wd == 8
+        umax            v6\sz,  v6\sz,  \tmp2\sz
+.endif
+        usubl_sz        \tmp1\().8h,  \tmp2\().8h,  v22,  v25, \sz // p1 - q1
+        umax            v5\sz,  v5\sz,  v1\sz  // max(abs(p1 - p0), abs(q1 - q0))
+.if \mix != 0
+        mov             v1.d[0], x11
+.endif
+        usubl_sz        \tmp3\().8h,  \tmp4\().8h,  v24,  v23, \sz // q0 - p0
+        movi            \tmp5\().8h,  #3
+.if \wd == 8
+        cmhs            v6\sz,  v0\sz,  v6\sz  // flat8in
+.endif
+.if \mix != 0
+        sxtl            v1.8h,  v1.8b
+.endif
+        cmhs            v5\sz,  v3\sz,  v5\sz  // !hev
+.if \wd == 8
+        // If a 4/8 or 8/4 mix is used, clear the relevant half of v6
+.if \mix != 0
+        and             v6\sz,  v6\sz,  v1.16b
+.endif
+        and             v6\sz,  v6\sz,  v4\sz  // flat8in && fm
+.endif
+        sqxtn_sz        \tmp1,        \tmp1\().8h,  \tmp2\().8h, \sz // av_clip_int8(p1 - q1)
+.if \wd == 16
+        cmhs            v7\sz,  v0\sz,  v7\sz  // flat8out
+.elseif \wd == 8
+        bic             v4\sz,  v4\sz,  v6\sz  // fm && !flat8in
+.endif
+        and             v5\sz,  v5\sz,  v4\sz  // !hev && fm && !flat8in
+.if \wd == 16
+        and             v7\sz,  v7\sz,  v6\sz  // flat8out && flat8in && fm
+.endif
+
+        mul_sz          \tmp3\().8h,  \tmp4\().8h,  \tmp3\().8h, \tmp4\().8h,  \tmp5\().8h,  \tmp5\().8h, \sz // 3 * (q0 - p0)
+        bic             \tmp1\sz,  \tmp1\sz,  v5\sz    // if (!hev) av_clip_int8 = 0
+        movi            v2\sz,  #4
+        saddw_sz        \tmp3\().8h,  \tmp4\().8h,  \tmp3\().8h, \tmp4\().8h,  \tmp1, \sz // 3 * (q0 - p0) [+ av_clip_int8(p1 - q1)]
+        movi            v3\sz,  #3
+        sqxtn_sz        \tmp1,        \tmp3\().8h,  \tmp4\().8h, \sz       // f
+.if \wd == 16
+        bic             v6\sz,  v6\sz,  v7\sz  // fm && flat8in && !flat8out
+.endif
+
+        sqadd           \tmp3\sz,  \tmp1\sz,  v2\sz // FFMIN(f + 4, 127)
+        sqadd           \tmp4\sz,  \tmp1\sz,  v3\sz // FFMIN(f + 3, 127)
+        uxtl_sz         v0.8h,  v1.8h,  v23, \sz    // p0
+        sshr            \tmp3\sz,  \tmp3\sz,  #3    // f1
+        sshr            \tmp4\sz,  \tmp4\sz,  #3    // f2
+
+        uxtl_sz         v2.8h,  v3.8h,  v24, \sz    // q0
+        saddw_sz        v0.8h,  v1.8h,  v0.8h,  v1.8h,  \tmp4, \sz // p0 + f2
+        ssubw_sz        v2.8h,  v3.8h,  v2.8h,  v3.8h,  \tmp3, \sz // q0 - f1
+        sqxtun_sz       v0,  v0.8h,  v1.8h,  \sz    // out p0
+        sqxtun_sz       v1,  v2.8h,  v3.8h,  \sz    // out q0
+        srshr           \tmp3\sz, \tmp3\sz, #1      // f = (f1 + 1) >> 1
+        bit             v23\sz, v0\sz,  v4\sz       // if (fm && !flat8in)
+        bit             v24\sz, v1\sz,  v4\sz
+
+        uxtl_sz         v0.8h,  v1.8h,  v22, \sz    // p1
+        uxtl_sz         v2.8h,  v3.8h,  v25, \sz    // q1
+.if \wd >= 8
+        mov             x5,  v6.d[0]
+.ifc \sz, .16b
+        mov             x6,  v6.d[1]
+.endif
+.endif
+        saddw_sz        v0.8h,  v1.8h,  v0.8h,  v1.8h,  \tmp3, \sz // p1 + f
+        ssubw_sz        v2.8h,  v3.8h,  v2.8h,  v3.8h,  \tmp3, \sz // q1 - f
+        sqxtun_sz       v0,  v0.8h,  v1.8h, \sz     // out p1
+        sqxtun_sz       v2,  v2.8h,  v3.8h, \sz     // out q1
+.if \wd >= 8
+.ifc \sz, .16b
+        adds            x5,  x5,  x6
+.endif
+.endif
+        bit             v22\sz, v0\sz,  v5\sz       // if (!hev && fm && !flat8in)
+        bit             v25\sz, v2\sz,  v5\sz
+
+        // If no pixels need flat8in, jump to flat8out
+        // (or to a writeout of the inner 4 pixels, for wd=8)
+.if \wd >= 8
+.ifc \sz, .16b
+        b.eq            6f
+.else
+        cbz             x5,  6f
+.endif
+
+        // flat8in
+        uaddl_sz        \tmp1\().8h, \tmp2\().8h,  v20, v21, \sz
+        uaddl_sz        \tmp3\().8h, \tmp4\().8h,  v22, v25, \sz
+        uaddl_sz        \tmp5\().8h, \tmp6\().8h,  v20, v22, \sz
+        uaddl_sz        \tmp7\().8h, \tmp8\().8h,  v23, v26, \sz
+        add_sz          v0.8h,  v1.8h,  \tmp1\().8h, \tmp2\().8h, \tmp1\().8h, \tmp2\().8h, \sz
+        uaddw_sz        v0.8h,  v1.8h,  v0.8h,  v1.8h,  v23, \sz
+        uaddw_sz        v0.8h,  v1.8h,  v0.8h,  v1.8h,  v24, \sz
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  \tmp5\().8h, \tmp6\().8h, \sz
+        sub_sz          \tmp3\().8h, \tmp4\().8h,  \tmp3\().8h, \tmp4\().8h,  \tmp1\().8h, \tmp2\().8h, \sz
+        sub_sz          \tmp7\().8h, \tmp8\().8h,  \tmp7\().8h, \tmp8\().8h,  \tmp5\().8h, \tmp6\().8h, \sz
+        rshrn_sz        v2,  v0.8h,  v1.8h,  #3,  \sz // out p2
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  \tmp3\().8h, \tmp4\().8h, \sz
+        uaddl_sz        \tmp1\().8h, \tmp2\().8h,  v20,  v23, \sz
+        uaddl_sz        \tmp3\().8h, \tmp4\().8h,  v24,  v27, \sz
+        rshrn_sz        v3,  v0.8h,  v1.8h,  #3,  \sz // out p1
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  \tmp7\().8h, \tmp8\().8h, \sz
+        sub_sz          \tmp3\().8h, \tmp4\().8h,  \tmp3\().8h, \tmp4\().8h,  \tmp1\().8h, \tmp2\().8h, \sz
+        uaddl_sz        \tmp5\().8h, \tmp6\().8h,  v21,  v24, \sz
+        uaddl_sz        \tmp7\().8h, \tmp8\().8h,  v25,  v27, \sz
+        rshrn_sz        v4,  v0.8h,  v1.8h,  #3,  \sz // out p0
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  \tmp3\().8h, \tmp4\().8h, \sz
+        sub_sz          \tmp7\().8h, \tmp8\().8h,  \tmp7\().8h, \tmp8\().8h,  \tmp5\().8h, \tmp6\().8h, \sz
+        uaddl_sz        \tmp1\().8h, \tmp2\().8h,  v22,  v25, \sz
+        uaddl_sz        \tmp3\().8h, \tmp4\().8h,  v26,  v27, \sz
+        rshrn_sz        v5,  v0.8h,  v1.8h,  #3,  \sz // out q0
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  \tmp7\().8h, \tmp8\().8h, \sz
+        sub_sz          \tmp3\().8h, \tmp4\().8h,  \tmp3\().8h, \tmp4\().8h,  \tmp1\().8h, \tmp2\().8h, \sz
+        rshrn_sz        \tmp5,  v0.8h,  v1.8h,  #3,  \sz // out q1
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  \tmp3\().8h, \tmp4\().8h, \sz
+        // The output here is written back into the input registers. This doesn't
+        // matter for the flat8part below, since we only update those pixels
+        // which won't be touched below.
+        bit             v21\sz, v2\sz,  v6\sz
+        bit             v22\sz, v3\sz,  v6\sz
+        bit             v23\sz, v4\sz,  v6\sz
+        rshrn_sz        \tmp6,  v0.8h,  v1.8h,  #3,  \sz // out q2
+        bit             v24\sz, v5\sz,  v6\sz
+        bit             v25\sz, \tmp5\sz,  v6\sz
+        bit             v26\sz, \tmp6\sz,  v6\sz
+.endif
+.if \wd == 16
+6:
+        orr             v2\sz,  v6\sz,  v7\sz
+        mov             x5,  v2.d[0]
+.ifc \sz, .16b
+        mov             x6,  v2.d[1]
+        adds            x5,  x5,  x6
+        b.ne            1f
+.else
+        cbnz            x5,  1f
+.endif
+        // If no pixels needed flat8in nor flat8out, jump to a
+        // writeout of the inner 4 pixels
+        br              x14
+1:
+
+        mov             x5,  v7.d[0]
+.ifc \sz, .16b
+        mov             x6,  v7.d[1]
+        adds            x5,  x5,  x6
+        b.ne            1f
+.else
+        cbnz            x5,  1f
+.endif
+        // If no pixels need flat8out, jump to a writeout of the inner 6 pixels
+        br              x15
+
+1:
+        // flat8out
+        // This writes all outputs into v2-v17 (skipping v6 and v16).
+        // If this part is skipped, the output is read from v21-v26 (which is the input
+        // to this section).
+        ushll_sz        v0.8h,  v1.8h,  v16,  #3,  \sz           // 8 * v16
+        usubw_sz        v0.8h,  v1.8h,  v0.8h,  v1.8h,  v16, \sz // 7 * v16
+        uaddw_sz        v0.8h,  v1.8h,  v0.8h,  v1.8h,  v17, \sz
+        uaddl_sz        v8.8h,  v9.8h,  v17, v18, \sz
+        uaddl_sz        v10.8h, v11.8h, v19, v20, \sz
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v8.8h,  v9.8h,  \sz
+        uaddl_sz        v8.8h,  v9.8h,  v16, v17, \sz
+        uaddl_sz        v12.8h, v13.8h, v21, v22, \sz
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v10.8h, v11.8h, \sz
+        uaddl_sz        v10.8h, v11.8h, v18, v25, \sz
+        uaddl_sz        v14.8h, v15.8h, v23, v24, \sz
+        sub_sz          v10.8h, v11.8h, v10.8h, v11.8h, v8.8h,  v9.8h,  \sz
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v12.8h, v13.8h, \sz
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v14.8h, v15.8h, \sz
+        uaddl_sz        v12.8h, v13.8h, v16, v18, \sz
+        uaddl_sz        v14.8h, v15.8h, v19, v26, \sz
+        rshrn_sz        v2,  v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v10.8h, v11.8h, \sz
+        uaddl_sz        v8.8h,  v9.8h,  v16, v19, \sz
+        uaddl_sz        v10.8h, v11.8h, v20, v27, \sz
+        sub_sz          v14.8h, v15.8h, v14.8h, v15.8h, v12.8h, v13.8h, \sz
+        bif             v2\sz,  v17\sz, v7\sz
+        rshrn_sz        v3,  v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v14.8h, v15.8h, \sz
+        uaddl_sz        v12.8h, v13.8h, v16, v20, \sz
+        uaddl_sz        v14.8h, v15.8h, v21, v28, \sz
+        sub_sz          v10.8h, v11.8h, v10.8h, v11.8h, v8.8h,  v9.8h,  \sz
+        bif             v3\sz,  v18\sz, v7\sz
+        rshrn_sz        v4,  v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v10.8h, v11.8h, \sz
+        uaddl_sz        v8.8h,  v9.8h,  v16, v21, \sz
+        uaddl_sz        v10.8h, v11.8h, v22, v29, \sz
+        sub_sz          v14.8h, v15.8h, v14.8h, v15.8h, v12.8h, v13.8h, \sz
+        bif             v4\sz,  v19\sz, v7\sz
+        rshrn_sz        v5,  v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v14.8h, v15.8h, \sz
+        uaddl_sz        v12.8h, v13.8h, v16, v22, \sz
+        uaddl_sz        v14.8h, v15.8h, v23, v30, \sz
+        sub_sz          v10.8h, v11.8h, v10.8h, v11.8h, v8.8h,  v9.8h,  \sz
+        bif             v5\sz,  v20\sz, v7\sz
+        rshrn_sz        v6,  v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v10.8h, v11.8h, \sz
+        uaddl_sz        v10.8h, v11.8h, v16, v23, \sz
+        sub_sz          v14.8h, v15.8h, v14.8h, v15.8h, v12.8h, v13.8h, \sz
+        uaddl_sz        v12.8h, v13.8h, v24, v31, \sz
+        bif             v6\sz,  v21\sz, v7\sz
+        rshrn_sz        v8,  v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v14.8h, v15.8h, \sz
+        sub_sz          v10.8h, v11.8h, v12.8h, v13.8h, v10.8h, v11.8h, \sz
+        uaddl_sz        v12.8h, v13.8h, v17, v24, \sz
+        uaddl_sz        v14.8h, v15.8h, v25, v31, \sz
+        bif             v8\sz,  v22\sz, v7\sz
+        rshrn_sz        v9,  v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v10.8h, v11.8h, \sz
+        sub_sz          v14.8h, v15.8h, v14.8h, v15.8h, v12.8h, v13.8h, \sz
+        uaddl_sz        v12.8h, v13.8h, v26, v31, \sz
+        bif             v9\sz,  v23\sz, v7\sz
+        rshrn_sz        v10, v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v14.8h, v15.8h, \sz
+        uaddl_sz        v14.8h, v15.8h, v18, v25, \sz
+        uaddl_sz        v18.8h, v19.8h, v19, v26, \sz
+        sub_sz          v12.8h, v13.8h, v12.8h, v13.8h, v14.8h, v15.8h, \sz
+        uaddl_sz        v14.8h, v15.8h, v27, v31, \sz
+        bif             v10\sz, v24\sz, v7\sz
+        rshrn_sz        v11, v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v12.8h, v13.8h, \sz
+        uaddl_sz        v12.8h, v13.8h, v20, v27, \sz
+        sub_sz          v14.8h, v15.8h, v14.8h, v15.8h, v18.8h, v19.8h, \sz
+        uaddl_sz        v18.8h, v19.8h, v28, v31, \sz
+        bif             v11\sz, v25\sz, v7\sz
+        sub_sz          v18.8h, v19.8h, v18.8h, v19.8h, v12.8h, v13.8h, \sz
+        rshrn_sz        v12, v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v14.8h, v15.8h, \sz
+        uaddl_sz        v14.8h, v15.8h, v21, v28, \sz
+        uaddl_sz        v20.8h, v21.8h, v29, v31, \sz
+        bif             v12\sz, v26\sz, v7\sz
+        rshrn_sz        v13, v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v18.8h, v19.8h, \sz
+        sub_sz          v20.8h, v21.8h, v20.8h, v21.8h, v14.8h, v15.8h, \sz
+        uaddl_sz        v18.8h, v19.8h, v22, v29, \sz
+        uaddl_sz        v22.8h, v23.8h, v30, v31, \sz
+        bif             v13\sz, v27\sz, v7\sz
+        rshrn_sz        v14, v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v20.8h, v21.8h, \sz
+        sub_sz          v22.8h, v23.8h, v22.8h, v23.8h, v18.8h, v19.8h, \sz
+        bif             v14\sz, v28\sz, v7\sz
+        rshrn_sz        v15, v0.8h,  v1.8h,  #4,  \sz
+
+        add_sz          v0.8h,  v1.8h,  v0.8h,  v1.8h,  v22.8h, v23.8h, \sz
+        bif             v15\sz, v29\sz, v7\sz
+        rshrn_sz        v17, v0.8h,  v1.8h,  #4,  \sz
+        bif             v17\sz, v30\sz, v7\sz
+.endif
+.endm
+
+// For wd <= 8, we use v16-v19 and v28-v31 for temp registers,
+// while we need those for inputs/outputs in wd=16 and use v8-v15
+// for temp registers there instead.
+function vp9_loop_filter_4
+        loop_filter     4,  .8b,  0,    v16, v17, v18, v19, v28, v29, v30, v31
+        ret
+9:
+        br              x10
+endfunc
+
+function vp9_loop_filter_4_16b_mix_44
+        loop_filter     4,  .16b, 44,   v16, v17, v18, v19, v28, v29, v30, v31
+        ret
+9:
+        br              x10
+endfunc
+
+function vp9_loop_filter_8
+        loop_filter     8,  .8b,  0,    v16, v17, v18, v19, v28, v29, v30, v31
+        ret
+6:
+        br              x13
+9:
+        br              x10
+endfunc
+
+function vp9_loop_filter_8_16b_mix
+        loop_filter     8,  .16b, 88,   v16, v17, v18, v19, v28, v29, v30, v31
+        ret
+6:
+        br              x13
+9:
+        br              x10
+endfunc
+
+function vp9_loop_filter_16
+        loop_filter     16, .8b,  0,    v8,  v9,  v10, v11, v12, v13, v14, v15
+        ret
+9:
+        ldp             d8,  d9,  [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d14, d15, [sp], 0x10
+        br              x10
+endfunc
+
+function vp9_loop_filter_16_16b
+        loop_filter     16, .16b, 0,    v8,  v9,  v10, v11, v12, v13, v14, v15
+        ret
+9:
+        ldp             d8,  d9,  [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d14, d15, [sp], 0x10
+        br              x10
+endfunc
+
+.macro loop_filter_4
+        bl              vp9_loop_filter_4
+.endm
+
+.macro loop_filter_4_16b_mix mix
+        bl              vp9_loop_filter_4_16b_mix_\mix
+.endm
+
+.macro loop_filter_8
+        // calculate alternative 'return' targets
+        adr             x13, 6f
+        bl              vp9_loop_filter_8
+.endm
+
+.macro loop_filter_8_16b_mix mix
+        // calculate alternative 'return' targets
+        adr             x13, 6f
+.if \mix == 48
+        mov             x11, #0xffffffff00000000
+.elseif \mix == 84
+        mov             x11, #0x00000000ffffffff
+.else
+        mov             x11, #0xffffffffffffffff
+.endif
+        bl              vp9_loop_filter_8_16b_mix
+.endm
+
+.macro loop_filter_16
+        // calculate alternative 'return' targets
+        adr             x14, 7f
+        adr             x15, 8f
+        bl              vp9_loop_filter_16
+.endm
+
+.macro loop_filter_16_16b
+        // calculate alternative 'return' targets
+        adr             x14, 7f
+        adr             x15, 8f
+        bl              vp9_loop_filter_16_16b
+.endm
+
+
+// The public functions in this file have got the following signature:
+// void loop_filter(uint8_t *dst, ptrdiff_t stride, int mb_lim, int lim, int hev_thr);
+
+function ff_vp9_loop_filter_v_4_8_neon, export=1
+        mov             x10, x30
+        sub             x9,  x0,  x1, lsl #2
+        ld1             {v20.8b}, [x9], x1 // p3
+        ld1             {v24.8b}, [x0], x1 // q0
+        ld1             {v21.8b}, [x9], x1 // p2
+        ld1             {v25.8b}, [x0], x1 // q1
+        ld1             {v22.8b}, [x9], x1 // p1
+        ld1             {v26.8b}, [x0], x1 // q2
+        ld1             {v23.8b}, [x9], x1 // p0
+        ld1             {v27.8b}, [x0], x1 // q3
+        sub             x0,  x0,  x1, lsl #2
+        sub             x9,  x9,  x1, lsl #1
+
+        loop_filter_4
+
+        st1             {v22.8b}, [x9], x1
+        st1             {v24.8b}, [x0], x1
+        st1             {v23.8b}, [x9], x1
+        st1             {v25.8b}, [x0], x1
+
+        br              x10
+endfunc
+
+function ff_vp9_loop_filter_v_44_16_neon, export=1
+        mov             x10, x30
+        sub             x9,  x0,  x1, lsl #2
+        ld1             {v20.16b}, [x9], x1 // p3
+        ld1             {v24.16b}, [x0], x1 // q0
+        ld1             {v21.16b}, [x9], x1 // p2
+        ld1             {v25.16b}, [x0], x1 // q1
+        ld1             {v22.16b}, [x9], x1 // p1
+        ld1             {v26.16b}, [x0], x1 // q2
+        ld1             {v23.16b}, [x9], x1 // p0
+        ld1             {v27.16b}, [x0], x1 // q3
+        sub             x0,  x0,  x1, lsl #2
+        sub             x9,  x9,  x1, lsl #1
+
+        loop_filter_4_16b_mix 44
+
+        st1             {v22.16b}, [x9], x1
+        st1             {v24.16b}, [x0], x1
+        st1             {v23.16b}, [x9], x1
+        st1             {v25.16b}, [x0], x1
+
+        br              x10
+endfunc
+
+function ff_vp9_loop_filter_h_4_8_neon, export=1
+        mov             x10, x30
+        sub             x9,  x0,  #4
+        add             x0,  x9,  x1, lsl #2
+        ld1             {v20.8b}, [x9], x1
+        ld1             {v24.8b}, [x0], x1
+        ld1             {v21.8b}, [x9], x1
+        ld1             {v25.8b}, [x0], x1
+        ld1             {v22.8b}, [x9], x1
+        ld1             {v26.8b}, [x0], x1
+        ld1             {v23.8b}, [x9], x1
+        ld1             {v27.8b}, [x0], x1
+
+        sub             x9,  x9,  x1, lsl #2
+        sub             x0,  x0,  x1, lsl #2
+        // Move x0/x9 forward by 2 pixels; we don't need to rewrite the
+        // outermost 2 pixels since they aren't changed.
+        add             x9,  x9,  #2
+        add             x0,  x0,  #2
+
+        transpose_8x8B  v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        loop_filter_4
+
+        // We only will write the mid 4 pixels back; after the loop filter,
+        // these are in v22, v23, v24, v25, ordered as rows (8x4 pixels).
+        // We need to transpose them to columns, done with a 4x8 transpose
+        // (which in practice is two 4x4 transposes of the two 4x4 halves
+        // of the 8x4 pixels; into 4x8 pixels).
+        transpose_4x8B  v22, v23, v24, v25, v26, v27, v28, v29
+        st1             {v22.s}[0], [x9], x1
+        st1             {v22.s}[1], [x0], x1
+        st1             {v23.s}[0], [x9], x1
+        st1             {v23.s}[1], [x0], x1
+        st1             {v24.s}[0], [x9], x1
+        st1             {v24.s}[1], [x0], x1
+        st1             {v25.s}[0], [x9], x1
+        st1             {v25.s}[1], [x0], x1
+
+        br              x10
+endfunc
+
+function ff_vp9_loop_filter_h_44_16_neon, export=1
+        mov             x10, x30
+        sub             x9,  x0,  #4
+        add             x0,  x9,  x1, lsl #3
+        ld1             {v20.8b},   [x9], x1
+        ld1             {v20.d}[1], [x0], x1
+        ld1             {v21.8b},   [x9], x1
+        ld1             {v21.d}[1], [x0], x1
+        ld1             {v22.8b},   [x9], x1
+        ld1             {v22.d}[1], [x0], x1
+        ld1             {v23.8b},   [x9], x1
+        ld1             {v23.d}[1], [x0], x1
+        ld1             {v24.8b},   [x9], x1
+        ld1             {v24.d}[1], [x0], x1
+        ld1             {v25.8b},   [x9], x1
+        ld1             {v25.d}[1], [x0], x1
+        ld1             {v26.8b},   [x9], x1
+        ld1             {v26.d}[1], [x0], x1
+        ld1             {v27.8b},   [x9], x1
+        ld1             {v27.d}[1], [x0], x1
+
+        sub             x9,  x9,  x1, lsl #3
+        sub             x0,  x0,  x1, lsl #3
+        add             x9,  x9,  #2
+        add             x0,  x0,  #2
+
+        transpose_8x16B v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        loop_filter_4_16b_mix 44
+
+        transpose_4x16B v22, v23, v24, v25, v26, v27, v28, v29
+
+        st1             {v22.s}[0], [x9], x1
+        st1             {v22.s}[2], [x0], x1
+        st1             {v23.s}[0], [x9], x1
+        st1             {v23.s}[2], [x0], x1
+        st1             {v24.s}[0], [x9], x1
+        st1             {v24.s}[2], [x0], x1
+        st1             {v25.s}[0], [x9], x1
+        st1             {v25.s}[2], [x0], x1
+        st1             {v22.s}[1], [x9], x1
+        st1             {v22.s}[3], [x0], x1
+        st1             {v23.s}[1], [x9], x1
+        st1             {v23.s}[3], [x0], x1
+        st1             {v24.s}[1], [x9], x1
+        st1             {v24.s}[3], [x0], x1
+        st1             {v25.s}[1], [x9], x1
+        st1             {v25.s}[3], [x0], x1
+
+        br              x10
+endfunc
+
+function ff_vp9_loop_filter_v_8_8_neon, export=1
+        mov             x10, x30
+        sub             x9,  x0,  x1, lsl #2
+        ld1             {v20.8b}, [x9], x1 // p3
+        ld1             {v24.8b}, [x0], x1 // q0
+        ld1             {v21.8b}, [x9], x1 // p2
+        ld1             {v25.8b}, [x0], x1 // q1
+        ld1             {v22.8b}, [x9], x1 // p1
+        ld1             {v26.8b}, [x0], x1 // q2
+        ld1             {v23.8b}, [x9], x1 // p0
+        ld1             {v27.8b}, [x0], x1 // q3
+        sub             x9,  x9,  x1, lsl #2
+        sub             x0,  x0,  x1, lsl #2
+        add             x9,  x9,  x1
+
+        loop_filter_8
+
+        st1             {v21.8b}, [x9], x1
+        st1             {v24.8b}, [x0], x1
+        st1             {v22.8b}, [x9], x1
+        st1             {v25.8b}, [x0], x1
+        st1             {v23.8b}, [x9], x1
+        st1             {v26.8b}, [x0], x1
+
+        br              x10
+6:
+        sub             x9,  x0,  x1, lsl #1
+        st1             {v22.8b}, [x9], x1
+        st1             {v24.8b}, [x0], x1
+        st1             {v23.8b}, [x9], x1
+        st1             {v25.8b}, [x0], x1
+        br              x10
+endfunc
+
+.macro mix_v_16 mix
+function ff_vp9_loop_filter_v_\mix\()_16_neon, export=1
+        mov             x10, x30
+        sub             x9,  x0,  x1, lsl #2
+        ld1             {v20.16b}, [x9], x1 // p3
+        ld1             {v24.16b}, [x0], x1 // q0
+        ld1             {v21.16b}, [x9], x1 // p2
+        ld1             {v25.16b}, [x0], x1 // q1
+        ld1             {v22.16b}, [x9], x1 // p1
+        ld1             {v26.16b}, [x0], x1 // q2
+        ld1             {v23.16b}, [x9], x1 // p0
+        ld1             {v27.16b}, [x0], x1 // q3
+        sub             x9,  x9,  x1, lsl #2
+        sub             x0,  x0,  x1, lsl #2
+        add             x9,  x9,  x1
+
+        loop_filter_8_16b_mix \mix
+
+        st1             {v21.16b}, [x9], x1
+        st1             {v24.16b}, [x0], x1
+        st1             {v22.16b}, [x9], x1
+        st1             {v25.16b}, [x0], x1
+        st1             {v23.16b}, [x9], x1
+        st1             {v26.16b}, [x0], x1
+
+        br              x10
+6:
+        sub             x9,  x0,  x1, lsl #1
+        st1             {v22.16b}, [x9], x1
+        st1             {v24.16b}, [x0], x1
+        st1             {v23.16b}, [x9], x1
+        st1             {v25.16b}, [x0], x1
+        br              x10
+endfunc
+.endm
+
+mix_v_16 48
+mix_v_16 84
+mix_v_16 88
+
+function ff_vp9_loop_filter_h_8_8_neon, export=1
+        mov             x10, x30
+        sub             x9,  x0,  #4
+        add             x0,  x9,  x1, lsl #2
+        ld1             {v20.8b}, [x9], x1
+        ld1             {v24.8b}, [x0], x1
+        ld1             {v21.8b}, [x9], x1
+        ld1             {v25.8b}, [x0], x1
+        ld1             {v22.8b}, [x9], x1
+        ld1             {v26.8b}, [x0], x1
+        ld1             {v23.8b}, [x9], x1
+        ld1             {v27.8b}, [x0], x1
+
+        sub             x9,  x9,  x1, lsl #2
+        sub             x0,  x0,  x1, lsl #2
+
+        transpose_8x8B  v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        loop_filter_8
+
+        // Even though only 6 pixels per row have been changed, we write the
+        // full 8 pixel registers.
+        transpose_8x8B  v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        st1             {v20.8b}, [x9], x1
+        st1             {v24.8b}, [x0], x1
+        st1             {v21.8b}, [x9], x1
+        st1             {v25.8b}, [x0], x1
+        st1             {v22.8b}, [x9], x1
+        st1             {v26.8b}, [x0], x1
+        st1             {v23.8b}, [x9], x1
+        st1             {v27.8b}, [x0], x1
+
+        br              x10
+6:
+        // If we didn't need to do the flat8in part, we use the same writeback
+        // as in loop_filter_h_4_8.
+        add             x9,  x9,  #2
+        add             x0,  x0,  #2
+        transpose_4x8B  v22, v23, v24, v25, v26, v27, v28, v29
+        st1             {v22.s}[0], [x9], x1
+        st1             {v22.s}[1], [x0], x1
+        st1             {v23.s}[0], [x9], x1
+        st1             {v23.s}[1], [x0], x1
+        st1             {v24.s}[0], [x9], x1
+        st1             {v24.s}[1], [x0], x1
+        st1             {v25.s}[0], [x9], x1
+        st1             {v25.s}[1], [x0], x1
+        br              x10
+endfunc
+
+.macro mix_h_16 mix
+function ff_vp9_loop_filter_h_\mix\()_16_neon, export=1
+        mov             x10, x30
+        sub             x9,  x0,  #4
+        add             x0,  x9,  x1, lsl #3
+        ld1             {v20.8b},   [x9], x1
+        ld1             {v20.d}[1], [x0], x1
+        ld1             {v21.8b},   [x9], x1
+        ld1             {v21.d}[1], [x0], x1
+        ld1             {v22.8b},   [x9], x1
+        ld1             {v22.d}[1], [x0], x1
+        ld1             {v23.8b},   [x9], x1
+        ld1             {v23.d}[1], [x0], x1
+        ld1             {v24.8b},   [x9], x1
+        ld1             {v24.d}[1], [x0], x1
+        ld1             {v25.8b},   [x9], x1
+        ld1             {v25.d}[1], [x0], x1
+        ld1             {v26.8b},   [x9], x1
+        ld1             {v26.d}[1], [x0], x1
+        ld1             {v27.8b},   [x9], x1
+        ld1             {v27.d}[1], [x0], x1
+
+        sub             x9,  x9,  x1, lsl #3
+        sub             x0,  x0,  x1, lsl #3
+
+        transpose_8x16B v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        loop_filter_8_16b_mix \mix
+
+        transpose_8x16B v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        st1             {v20.8b},   [x9], x1
+        st1             {v20.d}[1], [x0], x1
+        st1             {v21.8b},   [x9], x1
+        st1             {v21.d}[1], [x0], x1
+        st1             {v22.8b},   [x9], x1
+        st1             {v22.d}[1], [x0], x1
+        st1             {v23.8b},   [x9], x1
+        st1             {v23.d}[1], [x0], x1
+        st1             {v24.8b},   [x9], x1
+        st1             {v24.d}[1], [x0], x1
+        st1             {v25.8b},   [x9], x1
+        st1             {v25.d}[1], [x0], x1
+        st1             {v26.8b},   [x9], x1
+        st1             {v26.d}[1], [x0], x1
+        st1             {v27.8b},   [x9], x1
+        st1             {v27.d}[1], [x0], x1
+
+        br              x10
+6:
+        add             x9,  x9,  #2
+        add             x0,  x0,  #2
+        transpose_4x16B v22, v23, v24, v25, v26, v27, v28, v29
+        st1             {v22.s}[0], [x9], x1
+        st1             {v22.s}[2], [x0], x1
+        st1             {v23.s}[0], [x9], x1
+        st1             {v23.s}[2], [x0], x1
+        st1             {v24.s}[0], [x9], x1
+        st1             {v24.s}[2], [x0], x1
+        st1             {v25.s}[0], [x9], x1
+        st1             {v25.s}[2], [x0], x1
+        st1             {v22.s}[1], [x9], x1
+        st1             {v22.s}[3], [x0], x1
+        st1             {v23.s}[1], [x9], x1
+        st1             {v23.s}[3], [x0], x1
+        st1             {v24.s}[1], [x9], x1
+        st1             {v24.s}[3], [x0], x1
+        st1             {v25.s}[1], [x9], x1
+        st1             {v25.s}[3], [x0], x1
+        br              x10
+endfunc
+.endm
+
+mix_h_16 48
+mix_h_16 84
+mix_h_16 88
+
+function ff_vp9_loop_filter_v_16_8_neon, export=1
+        mov             x10, x30
+        stp             d14, d15, [sp, #-0x10]!
+        stp             d12, d13, [sp, #-0x10]!
+        stp             d10, d11, [sp, #-0x10]!
+        stp             d8,  d9,  [sp, #-0x10]!
+        sub             x9,  x0,  x1, lsl #3
+        ld1             {v16.8b}, [x9], x1 // p7
+        ld1             {v24.8b}, [x0], x1 // q0
+        ld1             {v17.8b}, [x9], x1 // p6
+        ld1             {v25.8b}, [x0], x1 // q1
+        ld1             {v18.8b}, [x9], x1 // p5
+        ld1             {v26.8b}, [x0], x1 // q2
+        ld1             {v19.8b}, [x9], x1 // p4
+        ld1             {v27.8b}, [x0], x1 // q3
+        ld1             {v20.8b}, [x9], x1 // p3
+        ld1             {v28.8b}, [x0], x1 // q4
+        ld1             {v21.8b}, [x9], x1 // p2
+        ld1             {v29.8b}, [x0], x1 // q5
+        ld1             {v22.8b}, [x9], x1 // p1
+        ld1             {v30.8b}, [x0], x1 // q6
+        ld1             {v23.8b}, [x9], x1 // p0
+        ld1             {v31.8b}, [x0], x1 // q7
+        sub             x9,  x9,  x1, lsl #3
+        sub             x0,  x0,  x1, lsl #3
+        add             x9,  x9,  x1
+
+        loop_filter_16
+
+        // If we did the flat8out part, we get the output in
+        // v2-v17 (skipping v7 and v16). x9 points to x0 - 7 * stride,
+        // store v2-v9 there, and v10-v17 into x0.
+        st1             {v2.8b},  [x9], x1
+        st1             {v10.8b}, [x0], x1
+        st1             {v3.8b},  [x9], x1
+        st1             {v11.8b}, [x0], x1
+        st1             {v4.8b},  [x9], x1
+        st1             {v12.8b}, [x0], x1
+        st1             {v5.8b},  [x9], x1
+        st1             {v13.8b}, [x0], x1
+        st1             {v6.8b},  [x9], x1
+        st1             {v14.8b}, [x0], x1
+        st1             {v8.8b},  [x9], x1
+        st1             {v15.8b}, [x0], x1
+        st1             {v9.8b},  [x9], x1
+        st1             {v17.8b}, [x0], x1
+9:
+        ldp             d8,  d9,  [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d14, d15, [sp], 0x10
+        br              x10
+8:
+        add             x9,  x9,  x1, lsl #2
+        // If we didn't do the flat8out part, the output is left in the
+        // input registers.
+        st1             {v21.8b}, [x9], x1
+        st1             {v24.8b}, [x0], x1
+        st1             {v22.8b}, [x9], x1
+        st1             {v25.8b}, [x0], x1
+        st1             {v23.8b}, [x9], x1
+        st1             {v26.8b}, [x0], x1
+        b               9b
+7:
+        sub             x9,  x0,  x1, lsl #1
+        st1             {v22.8b}, [x9], x1
+        st1             {v24.8b}, [x0], x1
+        st1             {v23.8b}, [x9], x1
+        st1             {v25.8b}, [x0], x1
+        b               9b
+endfunc
+
+function ff_vp9_loop_filter_v_16_16_neon, export=1
+        mov             x10, x30
+        stp             d14, d15, [sp, #-0x10]!
+        stp             d12, d13, [sp, #-0x10]!
+        stp             d10, d11, [sp, #-0x10]!
+        stp             d8,  d9,  [sp, #-0x10]!
+        sub             x9,  x0,  x1, lsl #3
+        ld1             {v16.16b}, [x9], x1 // p7
+        ld1             {v24.16b}, [x0], x1 // q0
+        ld1             {v17.16b}, [x9], x1 // p6
+        ld1             {v25.16b}, [x0], x1 // q1
+        ld1             {v18.16b}, [x9], x1 // p5
+        ld1             {v26.16b}, [x0], x1 // q2
+        ld1             {v19.16b}, [x9], x1 // p4
+        ld1             {v27.16b}, [x0], x1 // q3
+        ld1             {v20.16b}, [x9], x1 // p3
+        ld1             {v28.16b}, [x0], x1 // q4
+        ld1             {v21.16b}, [x9], x1 // p2
+        ld1             {v29.16b}, [x0], x1 // q5
+        ld1             {v22.16b}, [x9], x1 // p1
+        ld1             {v30.16b}, [x0], x1 // q6
+        ld1             {v23.16b}, [x9], x1 // p0
+        ld1             {v31.16b}, [x0], x1 // q7
+        sub             x9,  x9,  x1, lsl #3
+        sub             x0,  x0,  x1, lsl #3
+        add             x9,  x9,  x1
+
+        loop_filter_16_16b
+
+        st1             {v2.16b},  [x9], x1
+        st1             {v10.16b}, [x0], x1
+        st1             {v3.16b},  [x9], x1
+        st1             {v11.16b}, [x0], x1
+        st1             {v4.16b},  [x9], x1
+        st1             {v12.16b}, [x0], x1
+        st1             {v5.16b},  [x9], x1
+        st1             {v13.16b}, [x0], x1
+        st1             {v6.16b},  [x9], x1
+        st1             {v14.16b}, [x0], x1
+        st1             {v8.16b},  [x9], x1
+        st1             {v15.16b}, [x0], x1
+        st1             {v9.16b},  [x9], x1
+        st1             {v17.16b}, [x0], x1
+9:
+        ldp             d8,  d9,  [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d14, d15, [sp], 0x10
+        br              x10
+8:
+        add             x9,  x9,  x1, lsl #2
+        st1             {v21.16b}, [x9], x1
+        st1             {v24.16b}, [x0], x1
+        st1             {v22.16b}, [x9], x1
+        st1             {v25.16b}, [x0], x1
+        st1             {v23.16b}, [x9], x1
+        st1             {v26.16b}, [x0], x1
+        b               9b
+7:
+        sub             x9,  x0,  x1, lsl #1
+        st1             {v22.16b}, [x9], x1
+        st1             {v24.16b}, [x0], x1
+        st1             {v23.16b}, [x9], x1
+        st1             {v25.16b}, [x0], x1
+        b               9b
+endfunc
+
+function ff_vp9_loop_filter_h_16_8_neon, export=1
+        mov             x10, x30
+        stp             d14, d15, [sp, #-0x10]!
+        stp             d12, d13, [sp, #-0x10]!
+        stp             d10, d11, [sp, #-0x10]!
+        stp             d8,  d9,  [sp, #-0x10]!
+        sub             x9,  x0,  #8
+        ld1             {v16.8b}, [x9], x1
+        ld1             {v24.8b}, [x0], x1
+        ld1             {v17.8b}, [x9], x1
+        ld1             {v25.8b}, [x0], x1
+        ld1             {v18.8b}, [x9], x1
+        ld1             {v26.8b}, [x0], x1
+        ld1             {v19.8b}, [x9], x1
+        ld1             {v27.8b}, [x0], x1
+        ld1             {v20.8b}, [x9], x1
+        ld1             {v28.8b}, [x0], x1
+        ld1             {v21.8b}, [x9], x1
+        ld1             {v29.8b}, [x0], x1
+        ld1             {v22.8b}, [x9], x1
+        ld1             {v30.8b}, [x0], x1
+        ld1             {v23.8b}, [x9], x1
+        ld1             {v31.8b}, [x0], x1
+        sub             x0,  x0,  x1, lsl #3
+        sub             x9,  x9,  x1, lsl #3
+
+        // The 16x8 pixels read above is in two 8x8 blocks; the left
+        // half in v16-v23, and the right half in v24-v31. Do two 8x8 transposes
+        // of this, to get one column per register.
+        transpose_8x8B  v16, v17, v18, v19, v20, v21, v22, v23, v0, v1
+        transpose_8x8B  v24, v25, v26, v27, v28, v29, v30, v31, v0, v1
+
+        loop_filter_16
+
+        transpose_8x8B  v16, v2,  v3,  v4,  v5,  v6,  v8,  v9,  v0, v1
+        transpose_8x8B  v10, v11, v12, v13, v14, v15, v17, v31, v0, v1
+
+        st1             {v16.8b}, [x9], x1
+        st1             {v10.8b}, [x0], x1
+        st1             {v2.8b},  [x9], x1
+        st1             {v11.8b}, [x0], x1
+        st1             {v3.8b},  [x9], x1
+        st1             {v12.8b}, [x0], x1
+        st1             {v4.8b},  [x9], x1
+        st1             {v13.8b}, [x0], x1
+        st1             {v5.8b},  [x9], x1
+        st1             {v14.8b}, [x0], x1
+        st1             {v6.8b},  [x9], x1
+        st1             {v15.8b}, [x0], x1
+        st1             {v8.8b},  [x9], x1
+        st1             {v17.8b}, [x0], x1
+        st1             {v9.8b},  [x9], x1
+        st1             {v31.8b}, [x0], x1
+9:
+        ldp             d8,  d9,  [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d14, d15, [sp], 0x10
+        br              x10
+8:
+        // The same writeback as in loop_filter_h_8_8
+        sub             x9,  x0,  #4
+        add             x0,  x9,  x1, lsl #2
+        transpose_8x8B  v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        st1             {v20.8b}, [x9], x1
+        st1             {v24.8b}, [x0], x1
+        st1             {v21.8b}, [x9], x1
+        st1             {v25.8b}, [x0], x1
+        st1             {v22.8b}, [x9], x1
+        st1             {v26.8b}, [x0], x1
+        st1             {v23.8b}, [x9], x1
+        st1             {v27.8b}, [x0], x1
+        b               9b
+7:
+        // The same writeback as in loop_filter_h_4_8
+        sub             x9,  x0,  #2
+        add             x0,  x9,  x1, lsl #2
+        transpose_4x8B  v22, v23, v24, v25, v26, v27, v28, v29
+        st1             {v22.s}[0], [x9], x1
+        st1             {v22.s}[1], [x0], x1
+        st1             {v23.s}[0], [x9], x1
+        st1             {v23.s}[1], [x0], x1
+        st1             {v24.s}[0], [x9], x1
+        st1             {v24.s}[1], [x0], x1
+        st1             {v25.s}[0], [x9], x1
+        st1             {v25.s}[1], [x0], x1
+        b               9b
+endfunc
+
+function ff_vp9_loop_filter_h_16_16_neon, export=1
+        mov             x10, x30
+        stp             d14, d15, [sp, #-0x10]!
+        stp             d12, d13, [sp, #-0x10]!
+        stp             d10, d11, [sp, #-0x10]!
+        stp             d8,  d9,  [sp, #-0x10]!
+        sub             x9,  x0,  #8
+        ld1             {v16.8b},   [x9], x1
+        ld1             {v24.8b},   [x0], x1
+        ld1             {v17.8b},   [x9], x1
+        ld1             {v25.8b},   [x0], x1
+        ld1             {v18.8b},   [x9], x1
+        ld1             {v26.8b},   [x0], x1
+        ld1             {v19.8b},   [x9], x1
+        ld1             {v27.8b},   [x0], x1
+        ld1             {v20.8b},   [x9], x1
+        ld1             {v28.8b},   [x0], x1
+        ld1             {v21.8b},   [x9], x1
+        ld1             {v29.8b},   [x0], x1
+        ld1             {v22.8b},   [x9], x1
+        ld1             {v30.8b},   [x0], x1
+        ld1             {v23.8b},   [x9], x1
+        ld1             {v31.8b},   [x0], x1
+        ld1             {v16.d}[1], [x9], x1
+        ld1             {v24.d}[1], [x0], x1
+        ld1             {v17.d}[1], [x9], x1
+        ld1             {v25.d}[1], [x0], x1
+        ld1             {v18.d}[1], [x9], x1
+        ld1             {v26.d}[1], [x0], x1
+        ld1             {v19.d}[1], [x9], x1
+        ld1             {v27.d}[1], [x0], x1
+        ld1             {v20.d}[1], [x9], x1
+        ld1             {v28.d}[1], [x0], x1
+        ld1             {v21.d}[1], [x9], x1
+        ld1             {v29.d}[1], [x0], x1
+        ld1             {v22.d}[1], [x9], x1
+        ld1             {v30.d}[1], [x0], x1
+        ld1             {v23.d}[1], [x9], x1
+        ld1             {v31.d}[1], [x0], x1
+        sub             x0,  x0,  x1, lsl #4
+        sub             x9,  x9,  x1, lsl #4
+
+        transpose_8x16B v16, v17, v18, v19, v20, v21, v22, v23, v0, v1
+        transpose_8x16B v24, v25, v26, v27, v28, v29, v30, v31, v0, v1
+
+        loop_filter_16_16b
+
+        transpose_8x16B v16, v2,  v3,  v4,  v5,  v6,  v8,  v9,  v0, v1
+        transpose_8x16B v10, v11, v12, v13, v14, v15, v17, v31, v0, v1
+
+        st1             {v16.8b},   [x9], x1
+        st1             {v10.8b},   [x0], x1
+        st1             {v2.8b},    [x9], x1
+        st1             {v11.8b},   [x0], x1
+        st1             {v3.8b},    [x9], x1
+        st1             {v12.8b},   [x0], x1
+        st1             {v4.8b},    [x9], x1
+        st1             {v13.8b},   [x0], x1
+        st1             {v5.8b},    [x9], x1
+        st1             {v14.8b},   [x0], x1
+        st1             {v6.8b},    [x9], x1
+        st1             {v15.8b},   [x0], x1
+        st1             {v8.8b},    [x9], x1
+        st1             {v17.8b},   [x0], x1
+        st1             {v9.8b},    [x9], x1
+        st1             {v31.8b},   [x0], x1
+        st1             {v16.d}[1], [x9], x1
+        st1             {v10.d}[1], [x0], x1
+        st1             {v2.d}[1],  [x9], x1
+        st1             {v11.d}[1], [x0], x1
+        st1             {v3.d}[1],  [x9], x1
+        st1             {v12.d}[1], [x0], x1
+        st1             {v4.d}[1],  [x9], x1
+        st1             {v13.d}[1], [x0], x1
+        st1             {v5.d}[1],  [x9], x1
+        st1             {v14.d}[1], [x0], x1
+        st1             {v6.d}[1],  [x9], x1
+        st1             {v15.d}[1], [x0], x1
+        st1             {v8.d}[1],  [x9], x1
+        st1             {v17.d}[1], [x0], x1
+        st1             {v9.d}[1],  [x9], x1
+        st1             {v31.d}[1], [x0], x1
+9:
+        ldp             d8,  d9,  [sp], 0x10
+        ldp             d10, d11, [sp], 0x10
+        ldp             d12, d13, [sp], 0x10
+        ldp             d14, d15, [sp], 0x10
+        br              x10
+8:
+        sub             x9,  x0,  #4
+        add             x0,  x9,  x1, lsl #3
+        transpose_8x16B v20, v21, v22, v23, v24, v25, v26, v27, v28, v29
+
+        st1             {v20.8b},   [x9], x1
+        st1             {v20.d}[1], [x0], x1
+        st1             {v21.8b},   [x9], x1
+        st1             {v21.d}[1], [x0], x1
+        st1             {v22.8b},   [x9], x1
+        st1             {v22.d}[1], [x0], x1
+        st1             {v23.8b},   [x9], x1
+        st1             {v23.d}[1], [x0], x1
+        st1             {v24.8b},   [x9], x1
+        st1             {v24.d}[1], [x0], x1
+        st1             {v25.8b},   [x9], x1
+        st1             {v25.d}[1], [x0], x1
+        st1             {v26.8b},   [x9], x1
+        st1             {v26.d}[1], [x0], x1
+        st1             {v27.8b},   [x9], x1
+        st1             {v27.d}[1], [x0], x1
+        b               9b
+7:
+        sub             x9,  x0,  #2
+        add             x0,  x9,  x1, lsl #3
+        transpose_4x16B v22, v23, v24, v25, v26, v27, v28, v29
+        st1             {v22.s}[0], [x9], x1
+        st1             {v22.s}[2], [x0], x1
+        st1             {v23.s}[0], [x9], x1
+        st1             {v23.s}[2], [x0], x1
+        st1             {v24.s}[0], [x9], x1
+        st1             {v24.s}[2], [x0], x1
+        st1             {v25.s}[0], [x9], x1
+        st1             {v25.s}[2], [x0], x1
+        st1             {v22.s}[1], [x9], x1
+        st1             {v22.s}[3], [x0], x1
+        st1             {v23.s}[1], [x9], x1
+        st1             {v23.s}[3], [x0], x1
+        st1             {v24.s}[1], [x9], x1
+        st1             {v24.s}[3], [x0], x1
+        st1             {v25.s}[1], [x9], x1
+        st1             {v25.s}[3], [x0], x1
+        b               9b
+endfunc
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/vp9mc_16bpp_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9mc_16bpp_neon.S
new file mode 100644
index 00000000000..cac6428709b
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9mc_16bpp_neon.S
@@ -0,0 +1,631 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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/aarch64/asm.S"
+
+// All public functions in this file have the following signature:
+// typedef void (*vp9_mc_func)(uint8_t *dst, ptrdiff_t dst_stride,
+//                            const uint8_t *ref, ptrdiff_t ref_stride,
+//                            int h, int mx, int my);
+
+function ff_vp9_copy128_aarch64, export=1
+1:
+        ldp             x5,  x6,  [x2]
+        ldp             x7,  x8,  [x2, #16]
+        stp             x5,  x6,  [x0]
+        ldp             x9,  x10, [x2, #32]
+        stp             x7,  x8,  [x0, #16]
+        subs            w4,  w4,  #1
+        ldp             x11, x12, [x2, #48]
+        stp             x9,  x10, [x0, #32]
+        stp             x11, x12, [x0, #48]
+        ldp             x5,  x6,  [x2, #64]
+        ldp             x7,  x8,  [x2, #80]
+        stp             x5,  x6,  [x0, #64]
+        ldp             x9,  x10, [x2, #96]
+        stp             x7,  x8,  [x0, #80]
+        ldp             x11, x12, [x2, #112]
+        stp             x9,  x10, [x0, #96]
+        stp             x11, x12, [x0, #112]
+        add             x2,  x2,  x3
+        add             x0,  x0,  x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg64_16_neon, export=1
+        mov             x5,  x0
+        sub             x1,  x1,  #64
+        sub             x3,  x3,  #64
+1:
+        ld1             {v4.8h,  v5.8h,  v6.8h,  v7.8h},  [x2], #64
+        ld1             {v0.8h,  v1.8h,  v2.8h,  v3.8h},  [x0], #64
+        ld1             {v20.8h, v21.8h, v22.8h, v23.8h}, [x2], x3
+        urhadd          v0.8h,  v0.8h,  v4.8h
+        urhadd          v1.8h,  v1.8h,  v5.8h
+        ld1             {v16.8h, v17.8h, v18.8h, v19.8h}, [x0], x1
+        urhadd          v2.8h,  v2.8h,  v6.8h
+        urhadd          v3.8h,  v3.8h,  v7.8h
+        subs            w4,  w4,  #1
+        urhadd          v16.8h, v16.8h, v20.8h
+        urhadd          v17.8h, v17.8h, v21.8h
+        st1             {v0.8h,  v1.8h,  v2.8h,  v3.8h},  [x5], #64
+        urhadd          v18.8h, v18.8h, v22.8h
+        urhadd          v19.8h, v19.8h, v23.8h
+        st1             {v16.8h, v17.8h, v18.8h, v19.8h}, [x5], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg32_16_neon, export=1
+        mov             x5,  x0
+1:
+        ld1             {v4.8h,  v5.8h,  v6.8h,  v7.8h},  [x2], x3
+        ld1             {v0.8h,  v1.8h,  v2.8h,  v3.8h},  [x0], x1
+        ld1             {v20.8h, v21.8h, v22.8h, v23.8h}, [x2], x3
+        urhadd          v0.8h,  v0.8h,  v4.8h
+        urhadd          v1.8h,  v1.8h,  v5.8h
+        ld1             {v16.8h, v17.8h, v18.8h, v19.8h}, [x0], x1
+        urhadd          v2.8h,  v2.8h,  v6.8h
+        urhadd          v3.8h,  v3.8h,  v7.8h
+        subs            w4,  w4,  #2
+        urhadd          v16.8h, v16.8h, v20.8h
+        urhadd          v17.8h, v17.8h, v21.8h
+        st1             {v0.8h,  v1.8h,  v2.8h,  v3.8h},  [x5], x1
+        urhadd          v18.8h, v18.8h, v22.8h
+        urhadd          v19.8h, v19.8h, v23.8h
+        st1             {v16.8h, v17.8h, v18.8h, v19.8h}, [x5], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg16_16_neon, export=1
+1:
+        ld1             {v2.8h, v3.8h},  [x2], x3
+        ld1             {v0.8h, v1.8h},  [x0]
+        urhadd          v0.8h,  v0.8h,  v2.8h
+        urhadd          v1.8h,  v1.8h,  v3.8h
+        subs            w4,  w4,  #1
+        st1             {v0.8h, v1.8h},  [x0], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg8_16_neon, export=1
+        mov             x5,  x0
+1:
+        ld1             {v2.8h},  [x2], x3
+        ld1             {v0.8h},  [x0], x1
+        ld1             {v3.8h},  [x2], x3
+        urhadd          v0.8h,  v0.8h,  v2.8h
+        ld1             {v1.8h},  [x0], x1
+        urhadd          v1.8h,  v1.8h,  v3.8h
+        subs            w4,  w4,  #2
+        st1             {v0.8h},  [x5], x1
+        st1             {v1.8h},  [x5], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg4_16_neon, export=1
+        mov             x5,  x0
+1:
+        ld1             {v2.4h},  [x2], x3
+        ld1             {v0.4h},  [x0], x1
+        ld1             {v3.4h},  [x2], x3
+        urhadd          v0.4h,  v0.4h,  v2.4h
+        ld1             {v1.4h},  [x0], x1
+        urhadd          v1.4h,  v1.4h,  v3.4h
+        subs            w4,  w4,  #2
+        st1             {v0.4h},  [x5], x1
+        st1             {v1.8b},  [x5], x1
+        b.ne            1b
+        ret
+endfunc
+
+
+// Extract a vector from src1-src2 and src4-src5 (src1-src3 and src4-src6
+// for size >= 16), and multiply-accumulate into dst1 and dst5 (or
+// dst1-dst2 and dst5-dst6 for size >= 8 and dst1-dst4 and dst5-dst8
+// for size >= 16)
+.macro extmlal dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8, src1, src2, src3, src4, src5, src6, offset, size
+        ext             v20.16b, \src1\().16b, \src2\().16b, #(2*\offset)
+        ext             v22.16b, \src4\().16b, \src5\().16b, #(2*\offset)
+        smlal           \dst1\().4s, v20.4h, v0.h[\offset]
+        smlal           \dst5\().4s, v22.4h, v0.h[\offset]
+.if \size >= 16
+        ext             v21.16b, \src2\().16b, \src3\().16b, #(2*\offset)
+        ext             v23.16b, \src5\().16b, \src6\().16b, #(2*\offset)
+.endif
+.if \size >= 8
+        smlal2          \dst2\().4s, v20.8h, v0.h[\offset]
+        smlal2          \dst6\().4s, v22.8h, v0.h[\offset]
+.endif
+.if \size >= 16
+        smlal           \dst3\().4s, v21.4h, v0.h[\offset]
+        smlal           \dst7\().4s, v23.4h, v0.h[\offset]
+        smlal2          \dst4\().4s, v21.8h, v0.h[\offset]
+        smlal2          \dst8\().4s, v23.8h, v0.h[\offset]
+.endif
+.endm
+
+
+// Instantiate a horizontal filter function for the given size.
+// This can work on 4, 8 or 16 pixels in parallel; for larger
+// widths it will do 16 pixels at a time and loop horizontally.
+// The actual width (in bytes) is passed in x5, the height in w4 and
+// the filter coefficients in x9.
+.macro do_8tap_h type, size
+function \type\()_8tap_\size\()h
+        sub             x2,  x2,  #6
+        add             x6,  x0,  x1
+        add             x7,  x2,  x3
+        add             x1,  x1,  x1
+        add             x3,  x3,  x3
+        // Only size >= 16 loops horizontally and needs
+        // reduced dst stride
+.if \size >= 16
+        sub             x1,  x1,  x5
+.endif
+        // size >= 16 loads two qwords and increments r2,
+        // for size 4/8 it's enough with one qword and no
+        // postincrement
+.if \size >= 16
+        sub             x3,  x3,  x5
+        sub             x3,  x3,  #16
+.endif
+        // Load the filter vector
+        ld1             {v0.8h},  [x9]
+1:
+.if \size >= 16
+        mov             x9,  x5
+.endif
+        // Load src
+.if \size >= 16
+        ld1             {v5.8h,  v6.8h,  v7.8h},  [x2], #48
+        ld1             {v16.8h, v17.8h, v18.8h}, [x7], #48
+.else
+        ld1             {v5.8h,  v6.8h},  [x2]
+        ld1             {v16.8h, v17.8h}, [x7]
+.endif
+2:
+
+        smull           v1.4s,  v5.4h,  v0.h[0]
+        smull           v24.4s, v16.4h, v0.h[0]
+.if \size >= 8
+        smull2          v2.4s,  v5.8h,  v0.h[0]
+        smull2          v25.4s, v16.8h, v0.h[0]
+.endif
+.if \size >= 16
+        smull           v3.4s,  v6.4h,  v0.h[0]
+        smull           v26.4s, v17.4h, v0.h[0]
+        smull2          v4.4s,  v6.8h,  v0.h[0]
+        smull2          v27.4s, v17.8h, v0.h[0]
+.endif
+        extmlal         v1,  v2,  v3,  v4,  v24, v25, v26, v27, v5,  v6,  v7,  v16, v17, v18, 1, \size
+        extmlal         v1,  v2,  v3,  v4,  v24, v25, v26, v27, v5,  v6,  v7,  v16, v17, v18, 2, \size
+        extmlal         v1,  v2,  v3,  v4,  v24, v25, v26, v27, v5,  v6,  v7,  v16, v17, v18, 3, \size
+        extmlal         v1,  v2,  v3,  v4,  v24, v25, v26, v27, v5,  v6,  v7,  v16, v17, v18, 4, \size
+        extmlal         v1,  v2,  v3,  v4,  v24, v25, v26, v27, v5,  v6,  v7,  v16, v17, v18, 5, \size
+        extmlal         v1,  v2,  v3,  v4,  v24, v25, v26, v27, v5,  v6,  v7,  v16, v17, v18, 6, \size
+        extmlal         v1,  v2,  v3,  v4,  v24, v25, v26, v27, v5,  v6,  v7,  v16, v17, v18, 7, \size
+
+        // Round, shift and saturate
+        // The sqrshrun takes care of clamping negative values to zero, but
+        // we manually need to do umin with the max pixel value.
+        sqrshrun        v1.4h,  v1.4s,  #7
+        sqrshrun        v24.4h, v24.4s, #7
+.if \size >= 8
+        sqrshrun2       v1.8h,  v2.4s,  #7
+        sqrshrun2       v24.8h, v25.4s, #7
+        umin            v1.8h,  v1.8h,  v31.8h
+        umin            v24.8h, v24.8h, v31.8h
+.if \size >= 16
+        sqrshrun        v2.4h,  v3.4s,  #7
+        sqrshrun        v25.4h, v26.4s, #7
+        sqrshrun2       v2.8h,  v4.4s,  #7
+        sqrshrun2       v25.8h, v27.4s, #7
+        umin            v2.8h,  v2.8h,  v31.8h
+        umin            v25.8h, v25.8h, v31.8h
+.endif
+.else
+        umin            v1.4h,  v1.4h,  v31.4h
+        umin            v24.4h, v24.4h, v31.4h
+.endif
+        // Average
+.ifc \type,avg
+.if \size >= 16
+        ld1             {v3.8h,  v4.8h},  [x0]
+        ld1             {v29.8h, v30.8h}, [x6]
+        urhadd          v1.8h,  v1.8h,  v3.8h
+        urhadd          v2.8h,  v2.8h,  v4.8h
+        urhadd          v24.8h, v24.8h, v29.8h
+        urhadd          v25.8h, v25.8h, v30.8h
+.elseif \size >= 8
+        ld1             {v3.8h},  [x0]
+        ld1             {v4.8h},  [x6]
+        urhadd          v1.8h,  v1.8h,  v3.8h
+        urhadd          v24.8h, v24.8h, v4.8h
+.else
+        ld1             {v3.4h},  [x0]
+        ld1             {v4.4h},  [x6]
+        urhadd          v1.4h,  v1.4h,  v3.4h
+        urhadd          v24.4h, v24.4h, v4.4h
+.endif
+.endif
+        // Store and loop horizontally (for size >= 16)
+.if \size >= 16
+        subs            x9,  x9,  #32
+        st1             {v1.8h,  v2.8h},  [x0], #32
+        st1             {v24.8h, v25.8h}, [x6], #32
+        b.eq            3f
+        mov             v5.16b,  v7.16b
+        mov             v16.16b, v18.16b
+        ld1             {v6.8h,  v7.8h},  [x2], #32
+        ld1             {v17.8h, v18.8h}, [x7], #32
+        b               2b
+.elseif \size == 8
+        st1             {v1.8h},  [x0]
+        st1             {v24.8h}, [x6]
+.else // \size == 4
+        st1             {v1.4h},  [x0]
+        st1             {v24.4h}, [x6]
+.endif
+3:
+        // Loop vertically
+        add             x0,  x0,  x1
+        add             x6,  x6,  x1
+        add             x2,  x2,  x3
+        add             x7,  x7,  x3
+        subs            w4,  w4,  #2
+        b.ne            1b
+        ret
+endfunc
+.endm
+
+.macro do_8tap_h_size size
+do_8tap_h put, \size
+do_8tap_h avg, \size
+.endm
+
+do_8tap_h_size 4
+do_8tap_h_size 8
+do_8tap_h_size 16
+
+.macro do_8tap_h_func type, filter, offset, size, bpp
+function ff_vp9_\type\()_\filter\()\size\()_h_\bpp\()_neon, export=1
+        mvni            v31.8h, #((0xff << (\bpp - 8)) & 0xff), lsl #8
+        movrel          x6,  X(ff_vp9_subpel_filters), 256*\offset
+        cmp             w5,  #8
+        add             x9,  x6,  w5, uxtw #4
+        mov             x5,  #2*\size
+.if \size >= 16
+        b               \type\()_8tap_16h
+.else
+        b               \type\()_8tap_\size\()h
+.endif
+endfunc
+.endm
+
+.macro do_8tap_h_filters size, bpp
+do_8tap_h_func put, regular, 1, \size, \bpp
+do_8tap_h_func avg, regular, 1, \size, \bpp
+do_8tap_h_func put, sharp,   2, \size, \bpp
+do_8tap_h_func avg, sharp,   2, \size, \bpp
+do_8tap_h_func put, smooth,  0, \size, \bpp
+do_8tap_h_func avg, smooth,  0, \size, \bpp
+.endm
+
+.macro do_8tap_h_filters_bpp bpp
+do_8tap_h_filters 64, \bpp
+do_8tap_h_filters 32, \bpp
+do_8tap_h_filters 16, \bpp
+do_8tap_h_filters 8,  \bpp
+do_8tap_h_filters 4,  \bpp
+.endm
+
+do_8tap_h_filters_bpp 10
+do_8tap_h_filters_bpp 12
+
+
+// Vertical filters
+
+// Round, shift and saturate and store reg1-reg4
+.macro do_store4 reg1, reg2, reg3, reg4, tmp1, tmp2, tmp3, tmp4, minreg, type
+        sqrshrun        \reg1\().4h,  \reg1\().4s, #7
+        sqrshrun        \reg2\().4h,  \reg2\().4s, #7
+        sqrshrun        \reg3\().4h,  \reg3\().4s, #7
+        sqrshrun        \reg4\().4h,  \reg4\().4s, #7
+.ifc \type,avg
+        ld1             {\tmp1\().4h},  [x7], x1
+        ld1             {\tmp2\().4h},  [x7], x1
+        ld1             {\tmp3\().4h},  [x7], x1
+        ld1             {\tmp4\().4h},  [x7], x1
+.endif
+        umin            \reg1\().4h,  \reg1\().4h,  \minreg\().4h
+        umin            \reg2\().4h,  \reg2\().4h,  \minreg\().4h
+        umin            \reg3\().4h,  \reg3\().4h,  \minreg\().4h
+        umin            \reg4\().4h,  \reg4\().4h,  \minreg\().4h
+.ifc \type,avg
+        urhadd          \reg1\().4h,  \reg1\().4h,  \tmp1\().4h
+        urhadd          \reg2\().4h,  \reg2\().4h,  \tmp2\().4h
+        urhadd          \reg3\().4h,  \reg3\().4h,  \tmp3\().4h
+        urhadd          \reg4\().4h,  \reg4\().4h,  \tmp4\().4h
+.endif
+        st1             {\reg1\().4h},  [x0], x1
+        st1             {\reg2\().4h},  [x0], x1
+        st1             {\reg3\().4h},  [x0], x1
+        st1             {\reg4\().4h},  [x0], x1
+.endm
+
+// Round, shift and saturate and store reg1-8, where
+// reg1-2, reg3-4 etc pairwise correspond to 4 rows.
+.macro do_store8 reg1, reg2, reg3, reg4, reg5, reg6, reg7, reg8, minreg, type
+        sqrshrun        \reg1\().4h,  \reg1\().4s, #7
+        sqrshrun2       \reg1\().8h,  \reg2\().4s, #7
+        sqrshrun        \reg2\().4h,  \reg3\().4s, #7
+        sqrshrun2       \reg2\().8h,  \reg4\().4s, #7
+        sqrshrun        \reg3\().4h,  \reg5\().4s, #7
+        sqrshrun2       \reg3\().8h,  \reg6\().4s, #7
+        sqrshrun        \reg4\().4h,  \reg7\().4s, #7
+        sqrshrun2       \reg4\().8h,  \reg8\().4s, #7
+.ifc \type,avg
+        ld1             {\reg5\().8h},  [x7], x1
+        ld1             {\reg6\().8h},  [x7], x1
+        ld1             {\reg7\().8h},  [x7], x1
+        ld1             {\reg8\().8h},  [x7], x1
+.endif
+        umin            \reg1\().8h,  \reg1\().8h,  \minreg\().8h
+        umin            \reg2\().8h,  \reg2\().8h,  \minreg\().8h
+        umin            \reg3\().8h,  \reg3\().8h,  \minreg\().8h
+        umin            \reg4\().8h,  \reg4\().8h,  \minreg\().8h
+.ifc \type,avg
+        urhadd          \reg1\().8h,  \reg1\().8h,  \reg5\().8h
+        urhadd          \reg2\().8h,  \reg2\().8h,  \reg6\().8h
+        urhadd          \reg3\().8h,  \reg3\().8h,  \reg7\().8h
+        urhadd          \reg4\().8h,  \reg4\().8h,  \reg8\().8h
+.endif
+        st1             {\reg1\().8h},  [x0], x1
+        st1             {\reg2\().8h},  [x0], x1
+        st1             {\reg3\().8h},  [x0], x1
+        st1             {\reg4\().8h},  [x0], x1
+.endm
+
+// Evaluate the filter twice in parallel, from the inputs src1-src9 into dst1-dst2
+// (src1-src8 into dst1, src2-src9 into dst2).
+.macro convolve4 dst1, dst2, src1, src2, src3, src4, src5, src6, src7, src8, src9, tmp1, tmp2
+        smull           \dst1\().4s, \src1\().4h, v0.h[0]
+        smull           \dst2\().4s, \src2\().4h, v0.h[0]
+        smull           \tmp1\().4s, \src2\().4h, v0.h[1]
+        smull           \tmp2\().4s, \src3\().4h, v0.h[1]
+        smlal           \dst1\().4s, \src3\().4h, v0.h[2]
+        smlal           \dst2\().4s, \src4\().4h, v0.h[2]
+        smlal           \tmp1\().4s, \src4\().4h, v0.h[3]
+        smlal           \tmp2\().4s, \src5\().4h, v0.h[3]
+        smlal           \dst1\().4s, \src5\().4h, v0.h[4]
+        smlal           \dst2\().4s, \src6\().4h, v0.h[4]
+        smlal           \tmp1\().4s, \src6\().4h, v0.h[5]
+        smlal           \tmp2\().4s, \src7\().4h, v0.h[5]
+        smlal           \dst1\().4s, \src7\().4h, v0.h[6]
+        smlal           \dst2\().4s, \src8\().4h, v0.h[6]
+        smlal           \tmp1\().4s, \src8\().4h, v0.h[7]
+        smlal           \tmp2\().4s, \src9\().4h, v0.h[7]
+        add             \dst1\().4s, \dst1\().4s, \tmp1\().4s
+        add             \dst2\().4s, \dst2\().4s, \tmp2\().4s
+.endm
+
+// Evaluate the filter twice in parallel, from the inputs src1-src9 into dst1-dst4
+// (src1-src8 into dst1-dst2, src2-src9 into dst3-dst4).
+.macro convolve8 dst1, dst2, dst3, dst4, src1, src2, src3, src4, src5, src6, src7, src8, src9
+        smull           \dst1\().4s, \src1\().4h, v0.h[0]
+        smull2          \dst2\().4s, \src1\().8h, v0.h[0]
+        smull           \dst3\().4s, \src2\().4h, v0.h[0]
+        smull2          \dst4\().4s, \src2\().8h, v0.h[0]
+        smlal           \dst1\().4s, \src2\().4h, v0.h[1]
+        smlal2          \dst2\().4s, \src2\().8h, v0.h[1]
+        smlal           \dst3\().4s, \src3\().4h, v0.h[1]
+        smlal2          \dst4\().4s, \src3\().8h, v0.h[1]
+        smlal           \dst1\().4s, \src3\().4h, v0.h[2]
+        smlal2          \dst2\().4s, \src3\().8h, v0.h[2]
+        smlal           \dst3\().4s, \src4\().4h, v0.h[2]
+        smlal2          \dst4\().4s, \src4\().8h, v0.h[2]
+        smlal           \dst1\().4s, \src4\().4h, v0.h[3]
+        smlal2          \dst2\().4s, \src4\().8h, v0.h[3]
+        smlal           \dst3\().4s, \src5\().4h, v0.h[3]
+        smlal2          \dst4\().4s, \src5\().8h, v0.h[3]
+        smlal           \dst1\().4s, \src5\().4h, v0.h[4]
+        smlal2          \dst2\().4s, \src5\().8h, v0.h[4]
+        smlal           \dst3\().4s, \src6\().4h, v0.h[4]
+        smlal2          \dst4\().4s, \src6\().8h, v0.h[4]
+        smlal           \dst1\().4s, \src6\().4h, v0.h[5]
+        smlal2          \dst2\().4s, \src6\().8h, v0.h[5]
+        smlal           \dst3\().4s, \src7\().4h, v0.h[5]
+        smlal2          \dst4\().4s, \src7\().8h, v0.h[5]
+        smlal           \dst1\().4s, \src7\().4h, v0.h[6]
+        smlal2          \dst2\().4s, \src7\().8h, v0.h[6]
+        smlal           \dst3\().4s, \src8\().4h, v0.h[6]
+        smlal2          \dst4\().4s, \src8\().8h, v0.h[6]
+        smlal           \dst1\().4s, \src8\().4h, v0.h[7]
+        smlal2          \dst2\().4s, \src8\().8h, v0.h[7]
+        smlal           \dst3\().4s, \src9\().4h, v0.h[7]
+        smlal2          \dst4\().4s, \src9\().8h, v0.h[7]
+.endm
+
+// Instantiate a vertical filter function for filtering 8 pixels at a time.
+// The height is passed in x4, the width in x5 and the filter coefficients
+// in x6.
+.macro do_8tap_8v type
+function \type\()_8tap_8v
+        sub             x2,  x2,  x3, lsl #1
+        sub             x2,  x2,  x3
+        ld1             {v0.8h},  [x6]
+1:
+.ifc \type,avg
+        mov             x7,  x0
+.endif
+        mov             x6,  x4
+
+        ld1             {v17.8h}, [x2], x3
+        ld1             {v18.8h}, [x2], x3
+        ld1             {v19.8h}, [x2], x3
+        ld1             {v20.8h}, [x2], x3
+        ld1             {v21.8h}, [x2], x3
+        ld1             {v22.8h}, [x2], x3
+        ld1             {v23.8h}, [x2], x3
+2:
+        ld1             {v24.8h}, [x2], x3
+        ld1             {v25.8h}, [x2], x3
+        ld1             {v26.8h}, [x2], x3
+        ld1             {v27.8h}, [x2], x3
+
+        convolve8       v2,  v3,  v4,  v5,  v17, v18, v19, v20, v21, v22, v23, v24, v25
+        convolve8       v6,  v7,  v30, v31, v19, v20, v21, v22, v23, v24, v25, v26, v27
+        do_store8       v2,  v3,  v4,  v5,  v6,  v7,  v30, v31, v1,  \type
+
+        subs            x6,  x6,  #4
+        b.eq            8f
+
+        ld1             {v16.8h}, [x2], x3
+        ld1             {v17.8h}, [x2], x3
+        ld1             {v18.8h}, [x2], x3
+        ld1             {v19.8h}, [x2], x3
+        convolve8       v2,  v3,  v4,  v5,  v21, v22, v23, v24, v25, v26, v27, v16, v17
+        convolve8       v6,  v7,  v20, v21, v23, v24, v25, v26, v27, v16, v17, v18, v19
+        do_store8       v2,  v3,  v4,  v5,  v6,  v7,  v20, v21, v1,  \type
+
+        subs            x6,  x6,  #4
+        b.eq            8f
+
+        ld1             {v20.8h}, [x2], x3
+        ld1             {v21.8h}, [x2], x3
+        ld1             {v22.8h}, [x2], x3
+        ld1             {v23.8h}, [x2], x3
+        convolve8       v2,  v3,  v4,  v5,  v25, v26, v27, v16, v17, v18, v19, v20, v21
+        convolve8       v6,  v7,  v24, v25, v27, v16, v17, v18, v19, v20, v21, v22, v23
+        do_store8       v2,  v3,  v4,  v5,  v6,  v7,  v24, v25, v1,  \type
+
+        subs            x6,  x6,  #4
+        b.ne            2b
+
+8:
+        subs            x5,  x5,  #8
+        b.eq            9f
+        // x0 -= h * dst_stride
+        msub            x0,  x1,  x4, x0
+        // x2 -= h * src_stride
+        msub            x2,  x3,  x4, x2
+        // x2 -= 8 * src_stride
+        sub             x2,  x2,  x3, lsl #3
+        // x2 += 1 * src_stride
+        add             x2,  x2,  x3
+        add             x2,  x2,  #16
+        add             x0,  x0,  #16
+        b               1b
+9:
+        ret
+endfunc
+.endm
+
+do_8tap_8v put
+do_8tap_8v avg
+
+
+// Instantiate a vertical filter function for filtering a 4 pixels wide
+// slice. This only is designed to work for 4 or 8 output lines.
+.macro do_8tap_4v type
+function \type\()_8tap_4v
+        sub             x2,  x2,  x3, lsl #1
+        sub             x2,  x2,  x3
+        ld1             {v0.8h},  [x6]
+.ifc \type,avg
+        mov             x7,  x0
+.endif
+
+        ld1             {v16.4h}, [x2], x3
+        ld1             {v17.4h}, [x2], x3
+        ld1             {v18.4h}, [x2], x3
+        ld1             {v19.4h}, [x2], x3
+        ld1             {v20.4h}, [x2], x3
+        ld1             {v21.4h}, [x2], x3
+        ld1             {v22.4h}, [x2], x3
+        ld1             {v23.4h}, [x2], x3
+        ld1             {v24.4h}, [x2], x3
+        ld1             {v25.4h}, [x2], x3
+        ld1             {v26.4h}, [x2], x3
+
+        convolve4       v2,  v3,  v16, v17, v18, v19, v20, v21, v22, v23, v24, v30, v31
+        convolve4       v4,  v5,  v18, v19, v20, v21, v22, v23, v24, v25, v26, v30, v31
+        do_store4       v2,  v3,  v4,  v5,  v28, v29, v30, v31, v1,  \type
+
+        subs            x4,  x4,  #4
+        b.eq            9f
+
+        ld1             {v27.4h}, [x2], x3
+        ld1             {v28.4h}, [x2], x3
+        ld1             {v29.4h}, [x2], x3
+        ld1             {v30.4h}, [x2], x3
+
+        convolve4       v2,  v3,  v20, v21, v22, v23, v24, v25, v26, v27, v28, v16, v17
+        convolve4       v4,  v5,  v22, v23, v24, v25, v26, v27, v28, v29, v30, v16, v17
+        do_store4       v2,  v3,  v4,  v5,  v16, v17, v18, v19, v1,  \type
+
+9:
+        ret
+endfunc
+.endm
+
+do_8tap_4v put
+do_8tap_4v avg
+
+
+.macro do_8tap_v_func type, filter, offset, size, bpp
+function ff_vp9_\type\()_\filter\()\size\()_v_\bpp\()_neon, export=1
+        uxtw            x4,  w4
+        mvni            v1.8h, #((0xff << (\bpp - 8)) & 0xff), lsl #8
+        movrel          x5,  X(ff_vp9_subpel_filters), 256*\offset
+        add             x6,  x5,  w6, uxtw #4
+        mov             x5,  #\size
+.if \size >= 8
+        b               \type\()_8tap_8v
+.else
+        b               \type\()_8tap_4v
+.endif
+endfunc
+.endm
+
+.macro do_8tap_v_filters size, bpp
+do_8tap_v_func put, regular, 1, \size, \bpp
+do_8tap_v_func avg, regular, 1, \size, \bpp
+do_8tap_v_func put, sharp,   2, \size, \bpp
+do_8tap_v_func avg, sharp,   2, \size, \bpp
+do_8tap_v_func put, smooth,  0, \size, \bpp
+do_8tap_v_func avg, smooth,  0, \size, \bpp
+.endm
+
+.macro do_8tap_v_filters_bpp bpp
+do_8tap_v_filters 64, \bpp
+do_8tap_v_filters 32, \bpp
+do_8tap_v_filters 16, \bpp
+do_8tap_v_filters 8,  \bpp
+do_8tap_v_filters 4,  \bpp
+.endm
+
+do_8tap_v_filters_bpp 10
+do_8tap_v_filters_bpp 12
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/vp9mc_neon.S b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9mc_neon.S
new file mode 100644
index 00000000000..f67624ca048
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/aarch64/vp9mc_neon.S
@@ -0,0 +1,687 @@
+/*
+ * Copyright (c) 2016 Google Inc.
+ *
+ * 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/aarch64/asm.S"
+
+// All public functions in this file have the following signature:
+// typedef void (*vp9_mc_func)(uint8_t *dst, ptrdiff_t dst_stride,
+//                            const uint8_t *ref, ptrdiff_t ref_stride,
+//                            int h, int mx, int my);
+
+function ff_vp9_copy64_aarch64, export=1
+1:
+        ldp             x5,  x6,  [x2]
+        ldp             x7,  x8,  [x2, #16]
+        stp             x5,  x6,  [x0]
+        ldp             x9,  x10, [x2, #32]
+        stp             x7,  x8,  [x0, #16]
+        subs            w4,  w4,  #1
+        ldp             x11, x12, [x2, #48]
+        stp             x9,  x10, [x0, #32]
+        stp             x11, x12, [x0, #48]
+        add             x2,  x2,  x3
+        add             x0,  x0,  x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg64_neon, export=1
+        mov             x5,  x0
+1:
+        ld1             {v4.16b,  v5.16b,  v6.16b,  v7.16b},  [x2], x3
+        ld1             {v0.16b,  v1.16b,  v2.16b,  v3.16b},  [x0], x1
+        ld1             {v20.16b, v21.16b, v22.16b, v23.16b}, [x2], x3
+        urhadd          v0.16b,  v0.16b,  v4.16b
+        urhadd          v1.16b,  v1.16b,  v5.16b
+        ld1             {v16.16b, v17.16b, v18.16b, v19.16b}, [x0], x1
+        urhadd          v2.16b,  v2.16b,  v6.16b
+        urhadd          v3.16b,  v3.16b,  v7.16b
+        subs            w4,  w4,  #2
+        urhadd          v16.16b, v16.16b, v20.16b
+        urhadd          v17.16b, v17.16b, v21.16b
+        st1             {v0.16b,  v1.16b,  v2.16b,  v3.16b},  [x5], x1
+        urhadd          v18.16b, v18.16b, v22.16b
+        urhadd          v19.16b, v19.16b, v23.16b
+        st1             {v16.16b, v17.16b, v18.16b, v19.16b}, [x5], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_copy32_aarch64, export=1
+1:
+        ldp             x5,  x6,  [x2]
+        ldp             x7,  x8,  [x2, #16]
+        stp             x5,  x6,  [x0]
+        subs            w4,  w4,  #1
+        stp             x7,  x8,  [x0, #16]
+        add             x2,  x2,  x3
+        add             x0,  x0,  x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg32_neon, export=1
+1:
+        ld1             {v2.16b, v3.16b},  [x2], x3
+        ld1             {v0.16b, v1.16b},  [x0]
+        urhadd          v0.16b,  v0.16b,  v2.16b
+        urhadd          v1.16b,  v1.16b,  v3.16b
+        subs            w4,  w4,  #1
+        st1             {v0.16b, v1.16b},  [x0], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_copy16_neon, export=1
+        add             x5,  x0,  x1
+        lsl             x1,  x1,  #1
+        add             x6,  x2,  x3
+        lsl             x3,  x3,  #1
+1:
+        ld1             {v0.16b},  [x2], x3
+        ld1             {v1.16b},  [x6], x3
+        ld1             {v2.16b},  [x2], x3
+        ld1             {v3.16b},  [x6], x3
+        subs            w4,  w4,  #4
+        st1             {v0.16b},  [x0], x1
+        st1             {v1.16b},  [x5], x1
+        st1             {v2.16b},  [x0], x1
+        st1             {v3.16b},  [x5], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg16_neon, export=1
+        mov             x5,  x0
+1:
+        ld1             {v2.16b},  [x2], x3
+        ld1             {v0.16b},  [x0], x1
+        ld1             {v3.16b},  [x2], x3
+        urhadd          v0.16b,  v0.16b,  v2.16b
+        ld1             {v1.16b},  [x0], x1
+        urhadd          v1.16b,  v1.16b,  v3.16b
+        subs            w4,  w4,  #2
+        st1             {v0.16b},  [x5], x1
+        st1             {v1.16b},  [x5], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_copy8_neon, export=1
+1:
+        ld1             {v0.8b},  [x2], x3
+        ld1             {v1.8b},  [x2], x3
+        subs            w4,  w4,  #2
+        st1             {v0.8b},  [x0], x1
+        st1             {v1.8b},  [x0], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg8_neon, export=1
+        mov             x5,  x0
+1:
+        ld1             {v2.8b},  [x2], x3
+        ld1             {v0.8b},  [x0], x1
+        ld1             {v3.8b},  [x2], x3
+        urhadd          v0.8b,  v0.8b,  v2.8b
+        ld1             {v1.8b},  [x0], x1
+        urhadd          v1.8b,  v1.8b,  v3.8b
+        subs            w4,  w4,  #2
+        st1             {v0.8b},  [x5], x1
+        st1             {v1.8b},  [x5], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_copy4_neon, export=1
+1:
+        ld1             {v0.s}[0], [x2], x3
+        ld1             {v1.s}[0], [x2], x3
+        st1             {v0.s}[0], [x0], x1
+        ld1             {v2.s}[0], [x2], x3
+        st1             {v1.s}[0], [x0], x1
+        ld1             {v3.s}[0], [x2], x3
+        subs            w4,  w4,  #4
+        st1             {v2.s}[0], [x0], x1
+        st1             {v3.s}[0], [x0], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg4_neon, export=1
+        mov             x5,  x0
+1:
+        ld1             {v2.s}[0], [x2], x3
+        ld1             {v0.s}[0], [x0], x1
+        ld1             {v2.s}[1], [x2], x3
+        ld1             {v0.s}[1], [x0], x1
+        ld1             {v3.s}[0], [x2], x3
+        ld1             {v1.s}[0], [x0], x1
+        ld1             {v3.s}[1], [x2], x3
+        ld1             {v1.s}[1], [x0], x1
+        subs            w4,  w4,  #4
+        urhadd          v0.8b,  v0.8b,  v2.8b
+        urhadd          v1.8b,  v1.8b,  v3.8b
+        st1             {v0.s}[0], [x5], x1
+        st1             {v0.s}[1], [x5], x1
+        st1             {v1.s}[0], [x5], x1
+        st1             {v1.s}[1], [x5], x1
+        b.ne            1b
+        ret
+endfunc
+
+
+// Extract a vector from src1-src2 and src4-src5 (src1-src3 and src4-src6
+// for size >= 16), and multiply-accumulate into dst1 and dst3 (or
+// dst1-dst2 and dst3-dst4 for size >= 16)
+.macro extmla dst1, dst2, dst3, dst4, src1, src2, src3, src4, src5, src6, offset, size
+        ext             v20.16b, \src1\().16b, \src2\().16b, #(2*\offset)
+        ext             v22.16b, \src4\().16b, \src5\().16b, #(2*\offset)
+.if \size >= 16
+        mla             \dst1\().8h, v20.8h, v0.h[\offset]
+        ext             v21.16b, \src2\().16b, \src3\().16b, #(2*\offset)
+        mla             \dst3\().8h, v22.8h, v0.h[\offset]
+        ext             v23.16b, \src5\().16b, \src6\().16b, #(2*\offset)
+        mla             \dst2\().8h, v21.8h, v0.h[\offset]
+        mla             \dst4\().8h, v23.8h, v0.h[\offset]
+.elseif \size == 8
+        mla             \dst1\().8h, v20.8h, v0.h[\offset]
+        mla             \dst3\().8h, v22.8h, v0.h[\offset]
+.else
+        mla             \dst1\().4h, v20.4h, v0.h[\offset]
+        mla             \dst3\().4h, v22.4h, v0.h[\offset]
+.endif
+.endm
+// The same as above, but don't accumulate straight into the
+// destination, but use a temp register and accumulate with saturation.
+.macro extmulqadd dst1, dst2, dst3, dst4, src1, src2, src3, src4, src5, src6, offset, size
+        ext             v20.16b, \src1\().16b, \src2\().16b, #(2*\offset)
+        ext             v22.16b, \src4\().16b, \src5\().16b, #(2*\offset)
+.if \size >= 16
+        mul             v20.8h, v20.8h, v0.h[\offset]
+        ext             v21.16b, \src2\().16b, \src3\().16b, #(2*\offset)
+        mul             v22.8h, v22.8h, v0.h[\offset]
+        ext             v23.16b, \src5\().16b, \src6\().16b, #(2*\offset)
+        mul             v21.8h, v21.8h, v0.h[\offset]
+        mul             v23.8h, v23.8h, v0.h[\offset]
+.elseif \size == 8
+        mul             v20.8h, v20.8h, v0.h[\offset]
+        mul             v22.8h, v22.8h, v0.h[\offset]
+.else
+        mul             v20.4h, v20.4h, v0.h[\offset]
+        mul             v22.4h, v22.4h, v0.h[\offset]
+.endif
+.if \size == 4
+        sqadd           \dst1\().4h, \dst1\().4h, v20.4h
+        sqadd           \dst3\().4h, \dst3\().4h, v22.4h
+.else
+        sqadd           \dst1\().8h, \dst1\().8h, v20.8h
+        sqadd           \dst3\().8h, \dst3\().8h, v22.8h
+.if \size >= 16
+        sqadd           \dst2\().8h, \dst2\().8h, v21.8h
+        sqadd           \dst4\().8h, \dst4\().8h, v23.8h
+.endif
+.endif
+.endm
+
+
+// Instantiate a horizontal filter function for the given size.
+// This can work on 4, 8 or 16 pixels in parallel; for larger
+// widths it will do 16 pixels at a time and loop horizontally.
+// The actual width is passed in x5, the height in w4 and the
+// filter coefficients in x9. idx2 is the index of the largest
+// filter coefficient (3 or 4) and idx1 is the other one of them.
+.macro do_8tap_h type, size, idx1, idx2
+function \type\()_8tap_\size\()h_\idx1\idx2
+        sub             x2,  x2,  #3
+        add             x6,  x0,  x1
+        add             x7,  x2,  x3
+        add             x1,  x1,  x1
+        add             x3,  x3,  x3
+        // Only size >= 16 loops horizontally and needs
+        // reduced dst stride
+.if \size >= 16
+        sub             x1,  x1,  x5
+.endif
+        // size >= 16 loads two qwords and increments x2,
+        // for size 4/8 it's enough with one qword and no
+        // postincrement
+.if \size >= 16
+        sub             x3,  x3,  x5
+        sub             x3,  x3,  #8
+.endif
+        // Load the filter vector
+        ld1             {v0.8h},  [x9]
+1:
+.if \size >= 16
+        mov             x9,  x5
+.endif
+        // Load src
+.if \size >= 16
+        ld1             {v4.8b,  v5.8b,  v6.8b},  [x2], #24
+        ld1             {v16.8b, v17.8b, v18.8b}, [x7], #24
+.else
+        ld1             {v4.8b,  v5.8b},  [x2]
+        ld1             {v16.8b, v17.8b}, [x7]
+.endif
+        uxtl            v4.8h,  v4.8b
+        uxtl            v5.8h,  v5.8b
+        uxtl            v16.8h, v16.8b
+        uxtl            v17.8h, v17.8b
+.if \size >= 16
+        uxtl            v6.8h,  v6.8b
+        uxtl            v18.8h, v18.8b
+.endif
+2:
+
+        // Accumulate, adding idx2 last with a separate
+        // saturating add. The positive filter coefficients
+        // for all indices except idx2 must add up to less
+        // than 127 for this not to overflow.
+        mul             v1.8h,  v4.8h,  v0.h[0]
+        mul             v24.8h, v16.8h, v0.h[0]
+.if \size >= 16
+        mul             v2.8h,  v5.8h,  v0.h[0]
+        mul             v25.8h, v17.8h, v0.h[0]
+.endif
+        extmla          v1,  v2,  v24, v25, v4,  v5,  v6,  v16, v17, v18, 1,     \size
+        extmla          v1,  v2,  v24, v25, v4,  v5,  v6,  v16, v17, v18, 2,     \size
+        extmla          v1,  v2,  v24, v25, v4,  v5,  v6,  v16, v17, v18, \idx1, \size
+        extmla          v1,  v2,  v24, v25, v4,  v5,  v6,  v16, v17, v18, 5,     \size
+        extmla          v1,  v2,  v24, v25, v4,  v5,  v6,  v16, v17, v18, 6,     \size
+        extmla          v1,  v2,  v24, v25, v4,  v5,  v6,  v16, v17, v18, 7,     \size
+        extmulqadd      v1,  v2,  v24, v25, v4,  v5,  v6,  v16, v17, v18, \idx2, \size
+
+        // Round, shift and saturate
+        sqrshrun        v1.8b,   v1.8h,  #7
+        sqrshrun        v24.8b,  v24.8h, #7
+.if \size >= 16
+        sqrshrun2       v1.16b,  v2.8h,  #7
+        sqrshrun2       v24.16b, v25.8h, #7
+.endif
+        // Average
+.ifc \type,avg
+.if \size >= 16
+        ld1             {v2.16b}, [x0]
+        ld1             {v3.16b}, [x6]
+        urhadd          v1.16b,  v1.16b,  v2.16b
+        urhadd          v24.16b, v24.16b, v3.16b
+.elseif \size == 8
+        ld1             {v2.8b},  [x0]
+        ld1             {v3.8b},  [x6]
+        urhadd          v1.8b,  v1.8b,  v2.8b
+        urhadd          v24.8b, v24.8b, v3.8b
+.else
+        ld1             {v2.s}[0], [x0]
+        ld1             {v3.s}[0], [x6]
+        urhadd          v1.8b,  v1.8b,  v2.8b
+        urhadd          v24.8b, v24.8b, v3.8b
+.endif
+.endif
+        // Store and loop horizontally (for size >= 16)
+.if \size >= 16
+        subs            x9,  x9,  #16
+        st1             {v1.16b},  [x0], #16
+        st1             {v24.16b}, [x6], #16
+        b.eq            3f
+        mov             v4.16b,  v6.16b
+        mov             v16.16b, v18.16b
+        ld1             {v6.16b},  [x2], #16
+        ld1             {v18.16b}, [x7], #16
+        uxtl            v5.8h,  v6.8b
+        uxtl2           v6.8h,  v6.16b
+        uxtl            v17.8h, v18.8b
+        uxtl2           v18.8h, v18.16b
+        b               2b
+.elseif \size == 8
+        st1             {v1.8b},    [x0]
+        st1             {v24.8b},   [x6]
+.else // \size == 4
+        st1             {v1.s}[0],  [x0]
+        st1             {v24.s}[0], [x6]
+.endif
+3:
+        // Loop vertically
+        add             x0,  x0,  x1
+        add             x6,  x6,  x1
+        add             x2,  x2,  x3
+        add             x7,  x7,  x3
+        subs            w4,  w4,  #2
+        b.ne            1b
+        ret
+endfunc
+.endm
+
+.macro do_8tap_h_size size
+do_8tap_h put, \size, 3, 4
+do_8tap_h avg, \size, 3, 4
+do_8tap_h put, \size, 4, 3
+do_8tap_h avg, \size, 4, 3
+.endm
+
+do_8tap_h_size 4
+do_8tap_h_size 8
+do_8tap_h_size 16
+
+.macro do_8tap_h_func type, filter, offset, size
+function ff_vp9_\type\()_\filter\()\size\()_h_neon, export=1
+        movrel          x6,  X(ff_vp9_subpel_filters), 256*\offset
+        cmp             w5,  #8
+        add             x9,  x6,  w5, uxtw #4
+        mov             x5,  #\size
+.if \size >= 16
+        b.ge            \type\()_8tap_16h_34
+        b               \type\()_8tap_16h_43
+.else
+        b.ge            \type\()_8tap_\size\()h_34
+        b               \type\()_8tap_\size\()h_43
+.endif
+endfunc
+.endm
+
+.macro do_8tap_h_filters size
+do_8tap_h_func put, regular, 1, \size
+do_8tap_h_func avg, regular, 1, \size
+do_8tap_h_func put, sharp,   2, \size
+do_8tap_h_func avg, sharp,   2, \size
+do_8tap_h_func put, smooth,  0, \size
+do_8tap_h_func avg, smooth,  0, \size
+.endm
+
+do_8tap_h_filters 64
+do_8tap_h_filters 32
+do_8tap_h_filters 16
+do_8tap_h_filters 8
+do_8tap_h_filters 4
+
+
+// Vertical filters
+
+// Round, shift and saturate and store reg1-reg2 over 4 lines
+.macro do_store4 reg1, reg2, tmp1, tmp2, type
+        sqrshrun        \reg1\().8b,  \reg1\().8h, #7
+        sqrshrun        \reg2\().8b,  \reg2\().8h, #7
+.ifc \type,avg
+        ld1             {\tmp1\().s}[0],  [x7], x1
+        ld1             {\tmp2\().s}[0],  [x7], x1
+        ld1             {\tmp1\().s}[1],  [x7], x1
+        ld1             {\tmp2\().s}[1],  [x7], x1
+        urhadd          \reg1\().8b,  \reg1\().8b,  \tmp1\().8b
+        urhadd          \reg2\().8b,  \reg2\().8b,  \tmp2\().8b
+.endif
+        st1             {\reg1\().s}[0],  [x0], x1
+        st1             {\reg2\().s}[0],  [x0], x1
+        st1             {\reg1\().s}[1],  [x0], x1
+        st1             {\reg2\().s}[1],  [x0], x1
+.endm
+
+// Round, shift and saturate and store reg1-4
+.macro do_store reg1, reg2, reg3, reg4, tmp1, tmp2, tmp3, tmp4, type
+        sqrshrun        \reg1\().8b,  \reg1\().8h, #7
+        sqrshrun        \reg2\().8b,  \reg2\().8h, #7
+        sqrshrun        \reg3\().8b,  \reg3\().8h, #7
+        sqrshrun        \reg4\().8b,  \reg4\().8h, #7
+.ifc \type,avg
+        ld1             {\tmp1\().8b},  [x7], x1
+        ld1             {\tmp2\().8b},  [x7], x1
+        ld1             {\tmp3\().8b},  [x7], x1
+        ld1             {\tmp4\().8b},  [x7], x1
+        urhadd          \reg1\().8b,  \reg1\().8b,  \tmp1\().8b
+        urhadd          \reg2\().8b,  \reg2\().8b,  \tmp2\().8b
+        urhadd          \reg3\().8b,  \reg3\().8b,  \tmp3\().8b
+        urhadd          \reg4\().8b,  \reg4\().8b,  \tmp4\().8b
+.endif
+        st1             {\reg1\().8b},  [x0], x1
+        st1             {\reg2\().8b},  [x0], x1
+        st1             {\reg3\().8b},  [x0], x1
+        st1             {\reg4\().8b},  [x0], x1
+.endm
+
+// Evaluate the filter twice in parallel, from the inputs src1-src9 into dst1-dst2
+// (src1-src8 into dst1, src2-src9 into dst2), adding idx2 separately
+// at the end with saturation. Indices 0 and 7 always have negative or zero
+// coefficients, so they can be accumulated into tmp1-tmp2 together with the
+// largest coefficient.
+.macro convolve dst1, dst2, src1, src2, src3, src4, src5, src6, src7, src8, src9, idx1, idx2, tmp1, tmp2
+        mul             \dst1\().8h, \src2\().8h, v0.h[1]
+        mul             \dst2\().8h, \src3\().8h, v0.h[1]
+        mul             \tmp1\().8h, \src1\().8h, v0.h[0]
+        mul             \tmp2\().8h, \src2\().8h, v0.h[0]
+        mla             \dst1\().8h, \src3\().8h, v0.h[2]
+        mla             \dst2\().8h, \src4\().8h, v0.h[2]
+.if \idx1 == 3
+        mla             \dst1\().8h, \src4\().8h, v0.h[3]
+        mla             \dst2\().8h, \src5\().8h, v0.h[3]
+.else
+        mla             \dst1\().8h, \src5\().8h, v0.h[4]
+        mla             \dst2\().8h, \src6\().8h, v0.h[4]
+.endif
+        mla             \dst1\().8h, \src6\().8h, v0.h[5]
+        mla             \dst2\().8h, \src7\().8h, v0.h[5]
+        mla             \tmp1\().8h, \src8\().8h, v0.h[7]
+        mla             \tmp2\().8h, \src9\().8h, v0.h[7]
+        mla             \dst1\().8h, \src7\().8h, v0.h[6]
+        mla             \dst2\().8h, \src8\().8h, v0.h[6]
+.if \idx2 == 3
+        mla             \tmp1\().8h, \src4\().8h, v0.h[3]
+        mla             \tmp2\().8h, \src5\().8h, v0.h[3]
+.else
+        mla             \tmp1\().8h, \src5\().8h, v0.h[4]
+        mla             \tmp2\().8h, \src6\().8h, v0.h[4]
+.endif
+        sqadd           \dst1\().8h, \dst1\().8h, \tmp1\().8h
+        sqadd           \dst2\().8h, \dst2\().8h, \tmp2\().8h
+.endm
+
+// Load pixels and extend them to 16 bit
+.macro loadl dst1, dst2, dst3, dst4
+        ld1             {v1.8b}, [x2], x3
+        ld1             {v2.8b}, [x2], x3
+        ld1             {v3.8b}, [x2], x3
+.ifnb \dst4
+        ld1             {v4.8b}, [x2], x3
+.endif
+        uxtl            \dst1\().8h, v1.8b
+        uxtl            \dst2\().8h, v2.8b
+        uxtl            \dst3\().8h, v3.8b
+.ifnb \dst4
+        uxtl            \dst4\().8h, v4.8b
+.endif
+.endm
+
+// Instantiate a vertical filter function for filtering 8 pixels at a time.
+// The height is passed in x4, the width in x5 and the filter coefficients
+// in x6. idx2 is the index of the largest filter coefficient (3 or 4)
+// and idx1 is the other one of them.
+.macro do_8tap_8v type, idx1, idx2
+function \type\()_8tap_8v_\idx1\idx2
+        sub             x2,  x2,  x3, lsl #1
+        sub             x2,  x2,  x3
+        ld1             {v0.8h},  [x6]
+1:
+.ifc \type,avg
+        mov             x7,  x0
+.endif
+        mov             x6,  x4
+
+        loadl           v17, v18, v19
+
+        loadl           v20, v21, v22, v23
+2:
+        loadl           v24, v25, v26, v27
+        convolve        v1,  v2,  v17, v18, v19, v20, v21, v22, v23, v24, v25, \idx1, \idx2, v5,  v6
+        convolve        v3,  v4,  v19, v20, v21, v22, v23, v24, v25, v26, v27, \idx1, \idx2, v5,  v6
+        do_store        v1,  v2,  v3,  v4,  v5,  v6,  v7,  v28, \type
+
+        subs            x6,  x6,  #4
+        b.eq            8f
+
+        loadl           v16, v17, v18, v19
+        convolve        v1,  v2,  v21, v22, v23, v24, v25, v26, v27, v16, v17, \idx1, \idx2, v5,  v6
+        convolve        v3,  v4,  v23, v24, v25, v26, v27, v16, v17, v18, v19, \idx1, \idx2, v5,  v6
+        do_store        v1,  v2,  v3,  v4,  v5,  v6,  v7,  v28, \type
+
+        subs            x6,  x6,  #4
+        b.eq            8f
+
+        loadl           v20, v21, v22, v23
+        convolve        v1,  v2,  v25, v26, v27, v16, v17, v18, v19, v20, v21, \idx1, \idx2, v5,  v6
+        convolve        v3,  v4,  v27, v16, v17, v18, v19, v20, v21, v22, v23, \idx1, \idx2, v5,  v6
+        do_store        v1,  v2,  v3,  v4,  v5,  v6,  v7,  v28, \type
+
+        subs            x6,  x6,  #4
+        b.ne            2b
+
+8:
+        subs            x5,  x5,  #8
+        b.eq            9f
+        // x0 -= h * dst_stride
+        msub            x0,  x1,  x4, x0
+        // x2 -= h * src_stride
+        msub            x2,  x3,  x4, x2
+        // x2 -= 8 * src_stride
+        sub             x2,  x2,  x3, lsl #3
+        // x2 += 1 * src_stride
+        add             x2,  x2,  x3
+        add             x2,  x2,  #8
+        add             x0,  x0,  #8
+        b               1b
+9:
+        ret
+endfunc
+.endm
+
+do_8tap_8v put, 3, 4
+do_8tap_8v put, 4, 3
+do_8tap_8v avg, 3, 4
+do_8tap_8v avg, 4, 3
+
+
+// Instantiate a vertical filter function for filtering a 4 pixels wide
+// slice. The first half of the registers contain one row, while the second
+// half of a register contains the second-next row (also stored in the first
+// half of the register two steps ahead). The convolution does two outputs
+// at a time; the output of v17-v24 into one, and v18-v25 into another one.
+// The first half of first output is the first output row, the first half
+// of the other output is the second output row. The second halves of the
+// registers are rows 3 and 4.
+// This only is designed to work for 4 or 8 output lines.
+.macro do_8tap_4v type, idx1, idx2
+function \type\()_8tap_4v_\idx1\idx2
+        sub             x2,  x2,  x3, lsl #1
+        sub             x2,  x2,  x3
+        ld1             {v0.8h},  [x6]
+.ifc \type,avg
+        mov             x7,  x0
+.endif
+
+        ld1             {v1.s}[0],  [x2], x3
+        ld1             {v2.s}[0],  [x2], x3
+        ld1             {v3.s}[0],  [x2], x3
+        ld1             {v4.s}[0],  [x2], x3
+        ld1             {v5.s}[0],  [x2], x3
+        ld1             {v6.s}[0],  [x2], x3
+        trn1            v1.2s,  v1.2s,  v3.2s
+        ld1             {v7.s}[0],  [x2], x3
+        trn1            v2.2s,  v2.2s,  v4.2s
+        ld1             {v26.s}[0], [x2], x3
+        uxtl            v17.8h, v1.8b
+        trn1            v3.2s,  v3.2s,  v5.2s
+        ld1             {v27.s}[0], [x2], x3
+        uxtl            v18.8h, v2.8b
+        trn1            v4.2s,  v4.2s,  v6.2s
+        ld1             {v28.s}[0], [x2], x3
+        uxtl            v19.8h, v3.8b
+        trn1            v5.2s,  v5.2s,  v7.2s
+        ld1             {v29.s}[0], [x2], x3
+        uxtl            v20.8h, v4.8b
+        trn1            v6.2s,  v6.2s,  v26.2s
+        uxtl            v21.8h, v5.8b
+        trn1            v7.2s,  v7.2s,  v27.2s
+        uxtl            v22.8h, v6.8b
+        trn1            v26.2s, v26.2s, v28.2s
+        uxtl            v23.8h, v7.8b
+        trn1            v27.2s, v27.2s, v29.2s
+        uxtl            v24.8h, v26.8b
+        uxtl            v25.8h, v27.8b
+
+        convolve        v1,  v2,  v17, v18, v19, v20, v21, v22, v23, v24, v25, \idx1, \idx2, v3,  v4
+        do_store4       v1,  v2,  v5,  v6,  \type
+
+        subs            x4,  x4,  #4
+        b.eq            9f
+
+        ld1             {v1.s}[0],  [x2], x3
+        ld1             {v2.s}[0],  [x2], x3
+        trn1            v28.2s, v28.2s, v1.2s
+        trn1            v29.2s, v29.2s, v2.2s
+        ld1             {v1.s}[1],  [x2], x3
+        uxtl            v26.8h, v28.8b
+        ld1             {v2.s}[1],  [x2], x3
+        uxtl            v27.8h, v29.8b
+        uxtl            v28.8h, v1.8b
+        uxtl            v29.8h, v2.8b
+
+        convolve        v1,  v2,  v21, v22, v23, v24, v25, v26, v27, v28, v29, \idx1, \idx2, v3,  v4
+        do_store4       v1,  v2,  v5,  v6,  \type
+
+9:
+        ret
+endfunc
+.endm
+
+do_8tap_4v put, 3, 4
+do_8tap_4v put, 4, 3
+do_8tap_4v avg, 3, 4
+do_8tap_4v avg, 4, 3
+
+
+.macro do_8tap_v_func type, filter, offset, size
+function ff_vp9_\type\()_\filter\()\size\()_v_neon, export=1
+        uxtw            x4,  w4
+        movrel          x5,  X(ff_vp9_subpel_filters), 256*\offset
+        cmp             w6,  #8
+        add             x6,  x5,  w6, uxtw #4
+        mov             x5,  #\size
+.if \size >= 8
+        b.ge            \type\()_8tap_8v_34
+        b               \type\()_8tap_8v_43
+.else
+        b.ge            \type\()_8tap_4v_34
+        b               \type\()_8tap_4v_43
+.endif
+endfunc
+.endm
+
+.macro do_8tap_v_filters size
+do_8tap_v_func put, regular, 1, \size
+do_8tap_v_func avg, regular, 1, \size
+do_8tap_v_func put, sharp,   2, \size
+do_8tap_v_func avg, sharp,   2, \size
+do_8tap_v_func put, smooth,  0, \size
+do_8tap_v_func avg, smooth,  0, \size
+.endm
+
+do_8tap_v_filters 64
+do_8tap_v_filters 32
+do_8tap_v_filters 16
+do_8tap_v_filters 8
+do_8tap_v_filters 4
diff --git a/mythtv/external/FFmpeg/libavcodec/aasc.c b/mythtv/external/FFmpeg/libavcodec/aasc.c
index fd63aba4b8b..58cc3c85ba8 100644
--- a/mythtv/external/FFmpeg/libavcodec/aasc.c
+++ b/mythtv/external/FFmpeg/libavcodec/aasc.c
@@ -159,4 +159,5 @@ AVCodec ff_aasc_decoder = {
     .close          = aasc_decode_end,
     .decode         = aasc_decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/ac3dec.c b/mythtv/external/FFmpeg/libavcodec/ac3dec.c
index a95c2049b52..c393076aec2 100644
--- a/mythtv/external/FFmpeg/libavcodec/ac3dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ac3dec.c
@@ -362,52 +362,62 @@ static int parse_frame_header(AC3DecodeContext *s)
  * Set stereo downmixing coefficients based on frame header info.
  * reference: Section 7.8.2 Downmixing Into Two Channels
  */
-static void set_downmix_coeffs(AC3DecodeContext *s)
+static int set_downmix_coeffs(AC3DecodeContext *s)
 {
     int i;
     float cmix = gain_levels[s->  center_mix_level];
     float smix = gain_levels[s->surround_mix_level];
     float norm0, norm1;
-    float downmix_coeffs[AC3_MAX_CHANNELS][2];
+    float downmix_coeffs[2][AC3_MAX_CHANNELS];
+
+    if (!s->downmix_coeffs[0]) {
+        s->downmix_coeffs[0] = av_malloc_array(2 * AC3_MAX_CHANNELS,
+                                               sizeof(**s->downmix_coeffs));
+        if (!s->downmix_coeffs[0])
+            return AVERROR(ENOMEM);
+        s->downmix_coeffs[1] = s->downmix_coeffs[0] + AC3_MAX_CHANNELS;
+    }
 
     for (i = 0; i < s->fbw_channels; i++) {
-        downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
-        downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
+        downmix_coeffs[0][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
+        downmix_coeffs[1][i] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
     }
     if (s->channel_mode > 1 && s->channel_mode & 1) {
-        downmix_coeffs[1][0] = downmix_coeffs[1][1] = cmix;
+        downmix_coeffs[0][1] = downmix_coeffs[1][1] = cmix;
     }
     if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
         int nf = s->channel_mode - 2;
-        downmix_coeffs[nf][0] = downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
+        downmix_coeffs[0][nf] = downmix_coeffs[1][nf] = smix * LEVEL_MINUS_3DB;
     }
     if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
         int nf = s->channel_mode - 4;
-        downmix_coeffs[nf][0] = downmix_coeffs[nf+1][1] = smix;
+        downmix_coeffs[0][nf] = downmix_coeffs[1][nf+1] = smix;
     }
 
     /* renormalize */
     norm0 = norm1 = 0.0;
     for (i = 0; i < s->fbw_channels; i++) {
-        norm0 += downmix_coeffs[i][0];
-        norm1 += downmix_coeffs[i][1];
+        norm0 += downmix_coeffs[0][i];
+        norm1 += downmix_coeffs[1][i];
     }
     norm0 = 1.0f / norm0;
     norm1 = 1.0f / norm1;
     for (i = 0; i < s->fbw_channels; i++) {
-        downmix_coeffs[i][0] *= norm0;
-        downmix_coeffs[i][1] *= norm1;
+        downmix_coeffs[0][i] *= norm0;
+        downmix_coeffs[1][i] *= norm1;
     }
 
     if (s->output_mode == AC3_CHMODE_MONO) {
         for (i = 0; i < s->fbw_channels; i++)
-            downmix_coeffs[i][0] = (downmix_coeffs[i][0] +
-                                    downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
+            downmix_coeffs[0][i] = (downmix_coeffs[0][i] +
+                                    downmix_coeffs[1][i]) * LEVEL_MINUS_3DB;
     }
     for (i = 0; i < s->fbw_channels; i++) {
-        s->downmix_coeffs[i][0] = FIXR12(downmix_coeffs[i][0]);
-        s->downmix_coeffs[i][1] = FIXR12(downmix_coeffs[i][1]);
+        s->downmix_coeffs[0][i] = FIXR12(downmix_coeffs[0][i]);
+        s->downmix_coeffs[1][i] = FIXR12(downmix_coeffs[1][i]);
     }
+
+    return 0;
 }
 
 /**
@@ -426,6 +436,10 @@ static int decode_exponents(AC3DecodeContext *s,
     group_size = exp_strategy + (exp_strategy == EXP_D45);
     for (grp = 0, i = 0; grp < ngrps; grp++) {
         expacc = get_bits(gbc, 7);
+        if (expacc >= 125) {
+            av_log(s->avctx, AV_LOG_ERROR, "expacc %d is out-of-range\n", expacc);
+            return AVERROR_INVALIDDATA;
+        }
         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
@@ -589,8 +603,8 @@ static void remove_dithering(AC3DecodeContext *s) {
     }
 }
 
-static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
-                                       mant_groups *m)
+static inline void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk,
+                                              int ch, mant_groups *m)
 {
     if (!s->channel_uses_aht[ch]) {
         ac3_decode_transform_coeffs_ch(s, ch, m);
@@ -609,7 +623,7 @@ static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
 /**
  * Decode the transform coefficients.
  */
-static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
+static inline void decode_transform_coeffs(AC3DecodeContext *s, int blk)
 {
     int ch, end;
     int got_cplchan = 0;
@@ -747,30 +761,31 @@ static void ac3_upmix_delay(AC3DecodeContext *s)
  * @param[in] default_band_struct default band structure table
  * @param[out] num_bands number of bands (optionally NULL)
  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
+ * @param[in,out] band_struct current band structure
  */
 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
                                   int ecpl, int start_subband, int end_subband,
                                   const uint8_t *default_band_struct,
-                                  int *num_bands, uint8_t *band_sizes)
+                                  int *num_bands, uint8_t *band_sizes,
+                                  uint8_t *band_struct, int band_struct_size)
 {
     int subbnd, bnd, n_subbands, n_bands=0;
     uint8_t bnd_sz[22];
-    uint8_t coded_band_struct[22];
-    const uint8_t *band_struct;
 
     n_subbands = end_subband - start_subband;
 
+    if (!blk)
+        memcpy(band_struct, default_band_struct, band_struct_size);
+
+    av_assert0(band_struct_size >= start_subband + n_subbands);
+
+    band_struct += start_subband + 1;
+
     /* decode band structure from bitstream or use default */
     if (!eac3 || get_bits1(gbc)) {
         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
-            coded_band_struct[subbnd] = get_bits1(gbc);
+            band_struct[subbnd] = get_bits1(gbc);
         }
-        band_struct = coded_band_struct;
-    } else if (!blk) {
-        band_struct = &default_band_struct[start_subband+1];
-    } else {
-        /* no change in band structure */
-        return;
     }
 
     /* calculate number of bands and band sizes based on band structure.
@@ -797,6 +812,254 @@ static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
         memcpy(band_sizes, bnd_sz, n_bands);
 }
 
+static inline int spx_strategy(AC3DecodeContext *s, int blk)
+{
+    GetBitContext *bc = &s->gbc;
+    int fbw_channels = s->fbw_channels;
+    int dst_start_freq, dst_end_freq, src_start_freq,
+        start_subband, end_subband, ch;
+
+    /* determine which channels use spx */
+    if (s->channel_mode == AC3_CHMODE_MONO) {
+        s->channel_uses_spx[1] = 1;
+    } else {
+        for (ch = 1; ch <= fbw_channels; ch++)
+            s->channel_uses_spx[ch] = get_bits1(bc);
+    }
+
+    /* get the frequency bins of the spx copy region and the spx start
+       and end subbands */
+    dst_start_freq = get_bits(bc, 2);
+    start_subband  = get_bits(bc, 3) + 2;
+    if (start_subband > 7)
+        start_subband += start_subband - 7;
+    end_subband    = get_bits(bc, 3) + 5;
+#if USE_FIXED
+    s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
+#endif
+    if (end_subband   > 7)
+        end_subband   += end_subband   - 7;
+    dst_start_freq = dst_start_freq * 12 + 25;
+    src_start_freq = start_subband  * 12 + 25;
+    dst_end_freq   = end_subband    * 12 + 25;
+
+    /* check validity of spx ranges */
+    if (start_subband >= end_subband) {
+        av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
+               "range (%d >= %d)\n", start_subband, end_subband);
+        return AVERROR_INVALIDDATA;
+    }
+    if (dst_start_freq >= src_start_freq) {
+        av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
+               "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
+        return AVERROR_INVALIDDATA;
+    }
+
+    s->spx_dst_start_freq = dst_start_freq;
+    s->spx_src_start_freq = src_start_freq;
+    if (!USE_FIXED)
+        s->spx_dst_end_freq   = dst_end_freq;
+
+    decode_band_structure(bc, blk, s->eac3, 0,
+                          start_subband, end_subband,
+                          ff_eac3_default_spx_band_struct,
+                          &s->num_spx_bands,
+                          s->spx_band_sizes,
+                          s->spx_band_struct, sizeof(s->spx_band_struct));
+    return 0;
+}
+
+static inline void spx_coordinates(AC3DecodeContext *s)
+{
+    GetBitContext *bc = &s->gbc;
+    int fbw_channels = s->fbw_channels;
+    int ch, bnd;
+
+    for (ch = 1; ch <= fbw_channels; ch++) {
+        if (s->channel_uses_spx[ch]) {
+            if (s->first_spx_coords[ch] || get_bits1(bc)) {
+                INTFLOAT spx_blend;
+                int bin, master_spx_coord;
+
+                s->first_spx_coords[ch] = 0;
+                spx_blend = AC3_SPX_BLEND(get_bits(bc, 5));
+                master_spx_coord = get_bits(bc, 2) * 3;
+
+                bin = s->spx_src_start_freq;
+                for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
+                    int bandsize = s->spx_band_sizes[bnd];
+                    int spx_coord_exp, spx_coord_mant;
+                    INTFLOAT nratio, sblend, nblend;
+#if USE_FIXED
+                    /* calculate blending factors */
+                    int64_t accu = ((bin << 23) + (bandsize << 22))
+                                 * (int64_t)s->spx_dst_end_freq;
+                    nratio = (int)(accu >> 32);
+                    nratio -= spx_blend << 18;
+
+                    if (nratio < 0) {
+                        nblend = 0;
+                        sblend = 0x800000;
+                    } else if (nratio > 0x7fffff) {
+                        nblend = 14529495; // sqrt(3) in FP.23
+                        sblend = 0;
+                    } else {
+                        nblend = fixed_sqrt(nratio, 23);
+                        accu = (int64_t)nblend * 1859775393;
+                        nblend = (int)((accu + (1<<29)) >> 30);
+                        sblend = fixed_sqrt(0x800000 - nratio, 23);
+                    }
+#else
+                    float spx_coord;
+
+                    /* calculate blending factors */
+                    nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
+                    nratio = av_clipf(nratio, 0.0f, 1.0f);
+                    nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
+                                                   // to give unity variance
+                    sblend = sqrtf(1.0f - nratio);
+#endif
+                    bin += bandsize;
+
+                    /* decode spx coordinates */
+                    spx_coord_exp  = get_bits(bc, 4);
+                    spx_coord_mant = get_bits(bc, 2);
+                    if (spx_coord_exp == 15) spx_coord_mant <<= 1;
+                    else                     spx_coord_mant += 4;
+                    spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
+
+                    /* multiply noise and signal blending factors by spx coordinate */
+#if USE_FIXED
+                    accu = (int64_t)nblend * spx_coord_mant;
+                    s->spx_noise_blend[ch][bnd]  = (int)((accu + (1<<22)) >> 23);
+                    accu = (int64_t)sblend * spx_coord_mant;
+                    s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
+#else
+                    spx_coord = spx_coord_mant * (1.0f / (1 << 23));
+                    s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
+                    s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
+#endif
+                }
+            }
+        } else {
+            s->first_spx_coords[ch] = 1;
+        }
+    }
+}
+
+static inline int coupling_strategy(AC3DecodeContext *s, int blk,
+                                    uint8_t *bit_alloc_stages)
+{
+    GetBitContext *bc = &s->gbc;
+    int fbw_channels = s->fbw_channels;
+    int channel_mode = s->channel_mode;
+    int ch;
+
+    memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
+    if (!s->eac3)
+        s->cpl_in_use[blk] = get_bits1(bc);
+    if (s->cpl_in_use[blk]) {
+        /* coupling in use */
+        int cpl_start_subband, cpl_end_subband;
+
+        if (channel_mode < AC3_CHMODE_STEREO) {
+            av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
+            return AVERROR_INVALIDDATA;
+        }
+
+        /* check for enhanced coupling */
+        if (s->eac3 && get_bits1(bc)) {
+            /* TODO: parse enhanced coupling strategy info */
+            avpriv_request_sample(s->avctx, "Enhanced coupling");
+            return AVERROR_PATCHWELCOME;
+        }
+
+        /* determine which channels are coupled */
+        if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
+            s->channel_in_cpl[1] = 1;
+            s->channel_in_cpl[2] = 1;
+        } else {
+            for (ch = 1; ch <= fbw_channels; ch++)
+                s->channel_in_cpl[ch] = get_bits1(bc);
+        }
+
+        /* phase flags in use */
+        if (channel_mode == AC3_CHMODE_STEREO)
+            s->phase_flags_in_use = get_bits1(bc);
+
+        /* coupling frequency range */
+        cpl_start_subband = get_bits(bc, 4);
+        cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
+                                          get_bits(bc, 4) + 3;
+        if (cpl_start_subband >= cpl_end_subband) {
+            av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
+                   cpl_start_subband, cpl_end_subband);
+            return AVERROR_INVALIDDATA;
+        }
+        s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
+        s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
+
+        decode_band_structure(bc, blk, s->eac3, 0, cpl_start_subband,
+                              cpl_end_subband,
+                              ff_eac3_default_cpl_band_struct,
+                              &s->num_cpl_bands, s->cpl_band_sizes,
+                              s->cpl_band_struct, sizeof(s->cpl_band_struct));
+    } else {
+        /* coupling not in use */
+        for (ch = 1; ch <= fbw_channels; ch++) {
+            s->channel_in_cpl[ch] = 0;
+            s->first_cpl_coords[ch] = 1;
+        }
+        s->first_cpl_leak = s->eac3;
+        s->phase_flags_in_use = 0;
+    }
+
+    return 0;
+}
+
+static inline int coupling_coordinates(AC3DecodeContext *s, int blk)
+{
+    GetBitContext *bc = &s->gbc;
+    int fbw_channels = s->fbw_channels;
+    int ch, bnd;
+    int cpl_coords_exist = 0;
+
+    for (ch = 1; ch <= fbw_channels; ch++) {
+        if (s->channel_in_cpl[ch]) {
+            if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(bc)) {
+                int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
+                s->first_cpl_coords[ch] = 0;
+                cpl_coords_exist = 1;
+                master_cpl_coord = 3 * get_bits(bc, 2);
+                for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
+                    cpl_coord_exp  = get_bits(bc, 4);
+                    cpl_coord_mant = get_bits(bc, 4);
+                    if (cpl_coord_exp == 15)
+                        s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
+                    else
+                        s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
+                    s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
+                }
+            } else if (!blk) {
+                av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
+                       "be present in block 0\n");
+                return AVERROR_INVALIDDATA;
+            }
+        } else {
+            /* channel not in coupling */
+            s->first_cpl_coords[ch] = 1;
+        }
+    }
+    /* phase flags */
+    if (s->channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
+        for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
+            s->phase_flags[bnd] = s->phase_flags_in_use ? get_bits1(bc) : 0;
+        }
+    }
+
+    return 0;
+}
+
 /**
  * Decode a single audio block from the AC-3 bitstream.
  */
@@ -804,7 +1067,7 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
 {
     int fbw_channels = s->fbw_channels;
     int channel_mode = s->channel_mode;
-    int i, bnd, seg, ch;
+    int i, bnd, seg, ch, ret;
     int different_transforms;
     int downmix_output;
     int cpl_in_use;
@@ -849,55 +1112,8 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
     if (s->eac3 && (!blk || get_bits1(gbc))) {
         s->spx_in_use = get_bits1(gbc);
         if (s->spx_in_use) {
-            int dst_start_freq, dst_end_freq, src_start_freq,
-                start_subband, end_subband;
-
-            /* determine which channels use spx */
-            if (s->channel_mode == AC3_CHMODE_MONO) {
-                s->channel_uses_spx[1] = 1;
-            } else {
-                for (ch = 1; ch <= fbw_channels; ch++)
-                    s->channel_uses_spx[ch] = get_bits1(gbc);
-            }
-
-            /* get the frequency bins of the spx copy region and the spx start
-               and end subbands */
-            dst_start_freq = get_bits(gbc, 2);
-            start_subband  = get_bits(gbc, 3) + 2;
-            if (start_subband > 7)
-                start_subband += start_subband - 7;
-            end_subband    = get_bits(gbc, 3) + 5;
-#if USE_FIXED
-            s->spx_dst_end_freq = end_freq_inv_tab[end_subband-5];
-#endif
-            if (end_subband   > 7)
-                end_subband   += end_subband   - 7;
-            dst_start_freq = dst_start_freq * 12 + 25;
-            src_start_freq = start_subband  * 12 + 25;
-            dst_end_freq   = end_subband    * 12 + 25;
-
-            /* check validity of spx ranges */
-            if (start_subband >= end_subband) {
-                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
-                       "range (%d >= %d)\n", start_subband, end_subband);
-                return AVERROR_INVALIDDATA;
-            }
-            if (dst_start_freq >= src_start_freq) {
-                av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
-                       "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
-                return AVERROR_INVALIDDATA;
-            }
-
-            s->spx_dst_start_freq = dst_start_freq;
-            s->spx_src_start_freq = src_start_freq;
-            if (!USE_FIXED)
-                s->spx_dst_end_freq   = dst_end_freq;
-
-            decode_band_structure(gbc, blk, s->eac3, 0,
-                                  start_subband, end_subband,
-                                  ff_eac3_default_spx_band_struct,
-                                  &s->num_spx_bands,
-                                  s->spx_band_sizes);
+            if ((ret = spx_strategy(s, blk)) < 0)
+                return ret;
         }
     }
     if (!s->eac3 || !s->spx_in_use) {
@@ -909,138 +1125,13 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
     }
 
     /* spectral extension coordinates */
-    if (s->spx_in_use) {
-        for (ch = 1; ch <= fbw_channels; ch++) {
-            if (s->channel_uses_spx[ch]) {
-                if (s->first_spx_coords[ch] || get_bits1(gbc)) {
-                    INTFLOAT spx_blend;
-                    int bin, master_spx_coord;
-
-                    s->first_spx_coords[ch] = 0;
-                    spx_blend = AC3_SPX_BLEND(get_bits(gbc, 5));
-                    master_spx_coord = get_bits(gbc, 2) * 3;
-
-                    bin = s->spx_src_start_freq;
-                    for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
-                        int bandsize = s->spx_band_sizes[bnd];
-                        int spx_coord_exp, spx_coord_mant;
-                        INTFLOAT nratio, sblend, nblend;
-#if USE_FIXED
-                        /* calculate blending factors */
-                        int64_t accu = ((bin << 23) + (bandsize << 22))
-                                     * (int64_t)s->spx_dst_end_freq;
-                        nratio = (int)(accu >> 32);
-                        nratio -= spx_blend << 18;
-
-                        if (nratio < 0) {
-                            nblend = 0;
-                            sblend = 0x800000;
-                        } else if (nratio > 0x7fffff) {
-                            nblend = 14529495; // sqrt(3) in FP.23
-                            sblend = 0;
-                        } else {
-                            nblend = fixed_sqrt(nratio, 23);
-                            accu = (int64_t)nblend * 1859775393;
-                            nblend = (int)((accu + (1<<29)) >> 30);
-                            sblend = fixed_sqrt(0x800000 - nratio, 23);
-                        }
-#else
-                        float spx_coord;
-
-                        /* calculate blending factors */
-                        nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
-                        nratio = av_clipf(nratio, 0.0f, 1.0f);
-                        nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
-                                                       // to give unity variance
-                        sblend = sqrtf(1.0f - nratio);
-#endif
-                        bin += bandsize;
-
-                        /* decode spx coordinates */
-                        spx_coord_exp  = get_bits(gbc, 4);
-                        spx_coord_mant = get_bits(gbc, 2);
-                        if (spx_coord_exp == 15) spx_coord_mant <<= 1;
-                        else                     spx_coord_mant += 4;
-                        spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
-
-                        /* multiply noise and signal blending factors by spx coordinate */
-#if USE_FIXED
-                        accu = (int64_t)nblend * spx_coord_mant;
-                        s->spx_noise_blend[ch][bnd]  = (int)((accu + (1<<22)) >> 23);
-                        accu = (int64_t)sblend * spx_coord_mant;
-                        s->spx_signal_blend[ch][bnd] = (int)((accu + (1<<22)) >> 23);
-#else
-                        spx_coord = spx_coord_mant * (1.0f / (1 << 23));
-                        s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
-                        s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
-#endif
-                    }
-                }
-            } else {
-                s->first_spx_coords[ch] = 1;
-            }
-        }
-    }
+    if (s->spx_in_use)
+        spx_coordinates(s);
 
     /* coupling strategy */
     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
-        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
-        if (!s->eac3)
-            s->cpl_in_use[blk] = get_bits1(gbc);
-        if (s->cpl_in_use[blk]) {
-            /* coupling in use */
-            int cpl_start_subband, cpl_end_subband;
-
-            if (channel_mode < AC3_CHMODE_STEREO) {
-                av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
-                return AVERROR_INVALIDDATA;
-            }
-
-            /* check for enhanced coupling */
-            if (s->eac3 && get_bits1(gbc)) {
-                /* TODO: parse enhanced coupling strategy info */
-                avpriv_request_sample(s->avctx, "Enhanced coupling");
-                return AVERROR_PATCHWELCOME;
-            }
-
-            /* determine which channels are coupled */
-            if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
-                s->channel_in_cpl[1] = 1;
-                s->channel_in_cpl[2] = 1;
-            } else {
-                for (ch = 1; ch <= fbw_channels; ch++)
-                    s->channel_in_cpl[ch] = get_bits1(gbc);
-            }
-
-            /* phase flags in use */
-            if (channel_mode == AC3_CHMODE_STEREO)
-                s->phase_flags_in_use = get_bits1(gbc);
-
-            /* coupling frequency range */
-            cpl_start_subband = get_bits(gbc, 4);
-            cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
-                                              get_bits(gbc, 4) + 3;
-            if (cpl_start_subband >= cpl_end_subband) {
-                av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
-                       cpl_start_subband, cpl_end_subband);
-                return AVERROR_INVALIDDATA;
-            }
-            s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
-            s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
-
-            decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
-                                  cpl_end_subband,
-                                  ff_eac3_default_cpl_band_struct,
-                                  &s->num_cpl_bands, s->cpl_band_sizes);
-        } else {
-            /* coupling not in use */
-            for (ch = 1; ch <= fbw_channels; ch++) {
-                s->channel_in_cpl[ch] = 0;
-                s->first_cpl_coords[ch] = 1;
-            }
-            s->first_cpl_leak = s->eac3;
-            s->phase_flags_in_use = 0;
-        }
+        if ((ret = coupling_strategy(s, blk, bit_alloc_stages)) < 0)
+            return ret;
     } else if (!s->eac3) {
         if (!blk) {
             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
@@ -1054,40 +1145,8 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
 
     /* coupling coordinates */
     if (cpl_in_use) {
-        int cpl_coords_exist = 0;
-
-        for (ch = 1; ch <= fbw_channels; ch++) {
-            if (s->channel_in_cpl[ch]) {
-                if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
-                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
-                    s->first_cpl_coords[ch] = 0;
-                    cpl_coords_exist = 1;
-                    master_cpl_coord = 3 * get_bits(gbc, 2);
-                    for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
-                        cpl_coord_exp = get_bits(gbc, 4);
-                        cpl_coord_mant = get_bits(gbc, 4);
-                        if (cpl_coord_exp == 15)
-                            s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
-                        else
-                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
-                        s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
-                    }
-                } else if (!blk) {
-                    av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
-                           "be present in block 0\n");
-                    return AVERROR_INVALIDDATA;
-                }
-            } else {
-                /* channel not in coupling */
-                s->first_cpl_coords[ch] = 1;
-            }
-        }
-        /* phase flags */
-        if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
-            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
-                s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
-            }
-        }
+        if ((ret = coupling_coordinates(s, blk)) < 0)
+            return ret;
     }
 
     /* stereo rematrixing strategy and band structure */
@@ -1313,8 +1372,7 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
     /* unused dummy data */
     if (s->skip_syntax && get_bits1(gbc)) {
         int skipl = get_bits(gbc, 9);
-        while (skipl--)
-            skip_bits(gbc, 8);
+        skip_bits_long(gbc, 8 * skipl);
     }
 
     /* unpack the transform coefficients
@@ -1331,7 +1389,7 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
     for (ch = 1; ch <= s->channels; ch++) {
         int audio_channel = 0;
         INTFLOAT gain;
-        if (s->channel_mode == AC3_CHMODE_DUALMONO)
+        if (s->channel_mode == AC3_CHMODE_DUALMONO && ch <= 2)
             audio_channel = 2-ch;
         if (s->heavy_compression && s->compression_exists[audio_channel])
             gain = s->heavy_dynamic_range[audio_channel];
@@ -1375,19 +1433,19 @@ static int decode_audio_block(AC3DecodeContext *s, int blk)
             ac3_downmix_c_fixed16(s->outptr, s->downmix_coeffs,
                               s->out_channels, s->fbw_channels, 256);
 #else
-            s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
+            ff_ac3dsp_downmix(&s->ac3dsp, s->outptr, s->downmix_coeffs,
                               s->out_channels, s->fbw_channels, 256);
 #endif
         }
     } else {
         if (downmix_output) {
-            s->ac3dsp.AC3_RENAME(downmix)(s->xcfptr + 1, s->downmix_coeffs,
+            AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->xcfptr + 1, s->downmix_coeffs,
                                           s->out_channels, s->fbw_channels, 256);
         }
 
         if (downmix_output && !s->downmixed) {
             s->downmixed = 1;
-            s->ac3dsp.AC3_RENAME(downmix)(s->dlyptr, s->downmix_coeffs,
+            AC3_RENAME(ff_ac3dsp_downmix)(&s->ac3dsp, s->dlyptr, s->downmix_coeffs,
                                           s->out_channels, s->fbw_channels, 128);
         }
 
@@ -1422,6 +1480,13 @@ static int ac3_decode_frame(AVCodecContext * avctx, void *data,
                             (const uint16_t *) buf, cnt);
     } else
         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
+
+    /* if consistent noise generation is enabled, seed the linear feedback generator
+     * with the contents of the AC-3 frame so that the noise is identical across
+     * decodes given the same AC-3 frame data, for use with non-linear edititing software. */
+    if (s->consistent_noise_generation)
+        av_lfg_init_from_data(&s->dith_state, s->input_buffer, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
+
     buf = s->input_buffer;
     /* initialize the GetBitContext with the start of valid AC-3 Frame */
     if ((ret = init_get_bits8(&s->gbc, buf, buf_size)) < 0)
@@ -1510,7 +1575,10 @@ static int ac3_decode_frame(AVCodecContext * avctx, void *data,
         /* set downmixing coefficients if needed */
         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
                 s->fbw_channels == s->out_channels)) {
-            set_downmix_coeffs(s);
+            if ((ret = set_downmix_coeffs(s)) < 0) {
+                av_log(avctx, AV_LOG_ERROR, "error setting downmix coeffs\n");
+                return ret;
+            }
         }
     } else if (!s->channels) {
         av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
@@ -1557,7 +1625,7 @@ static int ac3_decode_frame(AVCodecContext * avctx, void *data,
         }
     }
 
-    av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
+    frame->decode_error_flags = err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0;
 
     /* keep last block for error concealment in next frame */
     for (ch = 0; ch < s->out_channels; ch++)
@@ -1633,6 +1701,7 @@ static av_cold int ac3_decode_end(AVCodecContext *avctx)
     ff_mdct_end(&s->imdct_512);
     ff_mdct_end(&s->imdct_256);
     av_freep(&s->fdsp);
+    av_freep(&s->downmix_coeffs[0]);
 
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/ac3dec.h b/mythtv/external/FFmpeg/libavcodec/ac3dec.h
index 6cd67c0f210..aa4cf04f8a9 100644
--- a/mythtv/external/FFmpeg/libavcodec/ac3dec.h
+++ b/mythtv/external/FFmpeg/libavcodec/ac3dec.h
@@ -128,6 +128,7 @@ typedef struct AC3DecodeContext {
     int phase_flags_in_use;                 ///< phase flags in use                     (phsflginu)
     int phase_flags[AC3_MAX_CPL_BANDS];     ///< phase flags                            (phsflg)
     int num_cpl_bands;                      ///< number of coupling bands               (ncplbnd)
+    uint8_t cpl_band_struct[AC3_MAX_CPL_BANDS];
     uint8_t cpl_band_sizes[AC3_MAX_CPL_BANDS]; ///< number of coeffs in each coupling band
     int firstchincpl;                       ///< first channel in coupling
     int first_cpl_coords[AC3_MAX_CHANNELS]; ///< first coupling coordinates states      (firstcplcos)
@@ -144,6 +145,7 @@ typedef struct AC3DecodeContext {
     int spx_dst_start_freq;                     ///< spx starting frequency bin for copying (copystartmant)
                                                 ///< the copy region ends at the start of the spx region.
     int num_spx_bands;                          ///< number of spx bands                    (nspxbnds)
+    uint8_t spx_band_struct[SPX_MAX_BANDS];
     uint8_t spx_band_sizes[SPX_MAX_BANDS];      ///< number of bins in each spx band
     uint8_t first_spx_coords[AC3_MAX_CHANNELS]; ///< first spx coordinates states           (firstspxcos)
     INTFLOAT spx_noise_blend[AC3_MAX_CHANNELS][SPX_MAX_BANDS]; ///< spx noise blending factor  (nblendfact)
@@ -159,7 +161,7 @@ typedef struct AC3DecodeContext {
     int fbw_channels;                           ///< number of full-bandwidth channels
     int channels;                               ///< number of total channels
     int lfe_ch;                                 ///< index of LFE channel
-    SHORTFLOAT downmix_coeffs[AC3_MAX_CHANNELS][2];  ///< stereo downmix coefficients
+    SHORTFLOAT *downmix_coeffs[2];              ///< stereo downmix coefficients
     int downmixed;                              ///< indicates if coeffs are currently downmixed
     int output_mode;                            ///< output channel configuration
     int out_channels;                           ///< number of output channels
@@ -177,6 +179,10 @@ typedef struct AC3DecodeContext {
     int end_freq[AC3_MAX_CHANNELS];         ///< end frequency bin                      (endmant)
 ///@}
 
+///@name Consistent noise generation
+    int consistent_noise_generation;        ///< seed noise generation with AC-3 frame on decode
+///@}
+
 ///@name Rematrixing
     int num_rematrixing_bands;              ///< number of rematrixing bands            (nrematbnd)
     int rematrixing_flags[4];               ///< rematrixing flags                      (rematflg)
diff --git a/mythtv/external/FFmpeg/libavcodec/ac3dec_fixed.c b/mythtv/external/FFmpeg/libavcodec/ac3dec_fixed.c
index 6416da436ec..9a6d7a08b1c 100644
--- a/mythtv/external/FFmpeg/libavcodec/ac3dec_fixed.c
+++ b/mythtv/external/FFmpeg/libavcodec/ac3dec_fixed.c
@@ -65,11 +65,11 @@ static void scale_coefs (
     int len)
 {
     int i, shift, round;
-    int16_t mul;
+    unsigned mul;
     int temp, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
 
     mul = (dynrng & 0x1f) + 0x20;
-    shift = 4 - ((dynrng << 23) >> 28);
+    shift = 4 - (sign_extend(dynrng, 9) >> 5);
     if (shift > 0 ) {
       round = 1 << (shift-1);
       for (i=0; i<len; i+=8) {
@@ -139,7 +139,7 @@ static void scale_coefs (
  * Downmix samples from original signal to stereo or mono (this is for 16-bit samples
  * and fixed point decoder - original (for 32-bit samples) is in ac3dsp.c).
  */
-static void ac3_downmix_c_fixed16(int16_t **samples, int16_t (*matrix)[2],
+static void ac3_downmix_c_fixed16(int16_t **samples, int16_t **matrix,
                                   int out_ch, int in_ch, int len)
 {
     int i, j;
@@ -148,8 +148,8 @@ static void ac3_downmix_c_fixed16(int16_t **samples, int16_t (*matrix)[2],
         for (i = 0; i < len; i++) {
             v0 = v1 = 0;
             for (j = 0; j < in_ch; j++) {
-                v0 += samples[j][i] * matrix[j][0];
-                v1 += samples[j][i] * matrix[j][1];
+                v0 += samples[j][i] * matrix[0][j];
+                v1 += samples[j][i] * matrix[1][j];
             }
             samples[0][i] = (v0+2048)>>12;
             samples[1][i] = (v1+2048)>>12;
@@ -158,7 +158,7 @@ static void ac3_downmix_c_fixed16(int16_t **samples, int16_t (*matrix)[2],
         for (i = 0; i < len; i++) {
             v0 = 0;
             for (j = 0; j < in_ch; j++)
-                v0 += samples[j][i] * matrix[j][0];
+                v0 += samples[j][i] * matrix[0][j];
             samples[0][i] = (v0+2048)>>12;
         }
     }
@@ -168,6 +168,7 @@ static void ac3_downmix_c_fixed16(int16_t **samples, int16_t (*matrix)[2],
 #include "ac3dec.c"
 
 static const AVOption options[] = {
+    { "cons_noisegen", "enable consistent noise generation", OFFSET(consistent_noise_generation), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, PAR },
     { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
     { "heavy_compr", "enable heavy dynamic range compression", OFFSET(heavy_compression), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, PAR },
     { NULL},
diff --git a/mythtv/external/FFmpeg/libavcodec/ac3dec_float.c b/mythtv/external/FFmpeg/libavcodec/ac3dec_float.c
index 0a5319a3037..b85a4ce3362 100644
--- a/mythtv/external/FFmpeg/libavcodec/ac3dec_float.c
+++ b/mythtv/external/FFmpeg/libavcodec/ac3dec_float.c
@@ -32,6 +32,7 @@
 #include "ac3dec.c"
 
 static const AVOption options[] = {
+    { "cons_noisegen", "enable consistent noise generation", OFFSET(consistent_noise_generation), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, PAR },
     { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 6.0, PAR },
     { "heavy_compr", "enable heavy dynamic range compression", OFFSET(heavy_compression), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, PAR },
     { "target_level", "target level in -dBFS (0 not applied)", OFFSET(target_level), AV_OPT_TYPE_INT, {.i64 = 0 }, -31, 0, PAR },
diff --git a/mythtv/external/FFmpeg/libavcodec/ac3dsp.c b/mythtv/external/FFmpeg/libavcodec/ac3dsp.c
index 9902f905f0c..43438da1314 100644
--- a/mythtv/external/FFmpeg/libavcodec/ac3dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/ac3dsp.c
@@ -213,17 +213,58 @@ static void ac3_sum_square_butterfly_float_c(float sum[4],
     }
 }
 
-static void ac3_downmix_c(float **samples, float (*matrix)[2],
+static void ac3_downmix_5_to_2_symmetric_c(float **samples, float **matrix,
+                                           int len)
+{
+    int i;
+    float v0, v1;
+    float front_mix    = matrix[0][0];
+    float center_mix   = matrix[0][1];
+    float surround_mix = matrix[0][3];
+
+    for (i = 0; i < len; i++) {
+        v0 = samples[0][i] * front_mix  +
+             samples[1][i] * center_mix +
+             samples[3][i] * surround_mix;
+
+        v1 = samples[1][i] * center_mix +
+             samples[2][i] * front_mix  +
+             samples[4][i] * surround_mix;
+
+        samples[0][i] = v0;
+        samples[1][i] = v1;
+    }
+}
+
+static void ac3_downmix_5_to_1_symmetric_c(float **samples, float **matrix,
+                                           int len)
+{
+    int i;
+    float front_mix    = matrix[0][0];
+    float center_mix   = matrix[0][1];
+    float surround_mix = matrix[0][3];
+
+    for (i = 0; i < len; i++) {
+        samples[0][i] = samples[0][i] * front_mix    +
+                        samples[1][i] * center_mix   +
+                        samples[2][i] * front_mix    +
+                        samples[3][i] * surround_mix +
+                        samples[4][i] * surround_mix;
+    }
+}
+
+static void ac3_downmix_c(float **samples, float **matrix,
                           int out_ch, int in_ch, int len)
 {
     int i, j;
     float v0, v1;
+
     if (out_ch == 2) {
         for (i = 0; i < len; i++) {
             v0 = v1 = 0.0f;
             for (j = 0; j < in_ch; j++) {
-                v0 += samples[j][i] * matrix[j][0];
-                v1 += samples[j][i] * matrix[j][1];
+                v0 += samples[j][i] * matrix[0][j];
+                v1 += samples[j][i] * matrix[1][j];
             }
             samples[0][i] = v0;
             samples[1][i] = v1;
@@ -232,13 +273,56 @@ static void ac3_downmix_c(float **samples, float (*matrix)[2],
         for (i = 0; i < len; i++) {
             v0 = 0.0f;
             for (j = 0; j < in_ch; j++)
-                v0 += samples[j][i] * matrix[j][0];
+                v0 += samples[j][i] * matrix[0][j];
             samples[0][i] = v0;
         }
     }
 }
 
-static void ac3_downmix_c_fixed(int32_t **samples, int16_t (*matrix)[2],
+static void ac3_downmix_5_to_2_symmetric_c_fixed(int32_t **samples, int16_t **matrix,
+                                           int len)
+{
+    int i;
+    int64_t v0, v1;
+    int16_t front_mix    = matrix[0][0];
+    int16_t center_mix   = matrix[0][1];
+    int16_t surround_mix = matrix[0][3];
+
+    for (i = 0; i < len; i++) {
+        v0 = (int64_t)samples[0][i] * front_mix  +
+             (int64_t)samples[1][i] * center_mix +
+             (int64_t)samples[3][i] * surround_mix;
+
+        v1 = (int64_t)samples[1][i] * center_mix +
+             (int64_t)samples[2][i] * front_mix  +
+             (int64_t)samples[4][i] * surround_mix;
+
+        samples[0][i] = (v0+2048)>>12;
+        samples[1][i] = (v1+2048)>>12;
+    }
+}
+
+static void ac3_downmix_5_to_1_symmetric_c_fixed(int32_t **samples, int16_t **matrix,
+                                                 int len)
+{
+    int i;
+    int64_t v0;
+    int16_t front_mix    = matrix[0][0];
+    int16_t center_mix   = matrix[0][1];
+    int16_t surround_mix = matrix[0][3];
+
+    for (i = 0; i < len; i++) {
+        v0 = (int64_t)samples[0][i] * front_mix    +
+             (int64_t)samples[1][i] * center_mix   +
+             (int64_t)samples[2][i] * front_mix    +
+             (int64_t)samples[3][i] * surround_mix +
+             (int64_t)samples[4][i] * surround_mix;
+
+        samples[0][i] = (v0+2048)>>12;
+    }
+}
+
+static void ac3_downmix_c_fixed(int32_t **samples, int16_t **matrix,
                                 int out_ch, int in_ch, int len)
 {
     int i, j;
@@ -247,8 +331,8 @@ static void ac3_downmix_c_fixed(int32_t **samples, int16_t (*matrix)[2],
         for (i = 0; i < len; i++) {
             v0 = v1 = 0;
             for (j = 0; j < in_ch; j++) {
-                v0 += (int64_t)samples[j][i] * matrix[j][0];
-                v1 += (int64_t)samples[j][i] * matrix[j][1];
+                v0 += (int64_t)samples[j][i] * matrix[0][j];
+                v1 += (int64_t)samples[j][i] * matrix[1][j];
             }
             samples[0][i] = (v0+2048)>>12;
             samples[1][i] = (v1+2048)>>12;
@@ -257,12 +341,39 @@ static void ac3_downmix_c_fixed(int32_t **samples, int16_t (*matrix)[2],
         for (i = 0; i < len; i++) {
             v0 = 0;
             for (j = 0; j < in_ch; j++)
-                v0 += (int64_t)samples[j][i] * matrix[j][0];
+                v0 += (int64_t)samples[j][i] * matrix[0][j];
             samples[0][i] = (v0+2048)>>12;
         }
     }
 }
 
+void ff_ac3dsp_downmix_fixed(AC3DSPContext *c, int32_t **samples, int16_t **matrix,
+                             int out_ch, int in_ch, int len)
+{
+    if (c->in_channels != in_ch || c->out_channels != out_ch) {
+        c->in_channels  = in_ch;
+        c->out_channels = out_ch;
+        c->downmix_fixed = NULL;
+
+        if (in_ch == 5 && out_ch == 2 &&
+            !(matrix[1][0] | matrix[0][2]  |
+              matrix[1][3] | matrix[0][4]  |
+             (matrix[0][1] ^ matrix[1][1]) |
+             (matrix[0][0] ^ matrix[1][2]))) {
+            c->downmix_fixed = ac3_downmix_5_to_2_symmetric_c_fixed;
+        } else if (in_ch == 5 && out_ch == 1 &&
+                   matrix[0][0] == matrix[0][2] &&
+                   matrix[0][3] == matrix[0][4]) {
+            c->downmix_fixed = ac3_downmix_5_to_1_symmetric_c_fixed;
+        }
+    }
+
+    if (c->downmix_fixed)
+        c->downmix_fixed(samples, matrix, len);
+    else
+        ac3_downmix_c_fixed(samples, matrix, out_ch, in_ch, len);
+}
+
 static void apply_window_int16_c(int16_t *output, const int16_t *input,
                                  const int16_t *window, unsigned int len)
 {
@@ -276,6 +387,38 @@ static void apply_window_int16_c(int16_t *output, const int16_t *input,
     }
 }
 
+void ff_ac3dsp_downmix(AC3DSPContext *c, float **samples, float **matrix,
+                       int out_ch, int in_ch, int len)
+{
+    if (c->in_channels != in_ch || c->out_channels != out_ch) {
+        int **matrix_cmp = (int **)matrix;
+
+        c->in_channels  = in_ch;
+        c->out_channels = out_ch;
+        c->downmix      = NULL;
+
+        if (in_ch == 5 && out_ch == 2 &&
+            !(matrix_cmp[1][0] | matrix_cmp[0][2]   |
+              matrix_cmp[1][3] | matrix_cmp[0][4]   |
+             (matrix_cmp[0][1] ^ matrix_cmp[1][1]) |
+             (matrix_cmp[0][0] ^ matrix_cmp[1][2]))) {
+            c->downmix = ac3_downmix_5_to_2_symmetric_c;
+        } else if (in_ch == 5 && out_ch == 1 &&
+                   matrix_cmp[0][0] == matrix_cmp[0][2] &&
+                   matrix_cmp[0][3] == matrix_cmp[0][4]) {
+            c->downmix = ac3_downmix_5_to_1_symmetric_c;
+        }
+
+        if (ARCH_X86)
+            ff_ac3dsp_set_downmix_x86(c);
+    }
+
+    if (c->downmix)
+        c->downmix(samples, matrix, len);
+    else
+        ac3_downmix_c(samples, matrix, out_ch, in_ch, len);
+}
+
 av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
 {
     c->ac3_exponent_min = ac3_exponent_min_c;
@@ -289,8 +432,10 @@ av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
     c->extract_exponents = ac3_extract_exponents_c;
     c->sum_square_butterfly_int32 = ac3_sum_square_butterfly_int32_c;
     c->sum_square_butterfly_float = ac3_sum_square_butterfly_float_c;
-    c->downmix = ac3_downmix_c;
-    c->downmix_fixed = ac3_downmix_c_fixed;
+    c->in_channels           = 0;
+    c->out_channels          = 0;
+    c->downmix               = NULL;
+    c->downmix_fixed         = NULL;
     c->apply_window_int16 = apply_window_int16_c;
 
     if (ARCH_ARM)
diff --git a/mythtv/external/FFmpeg/libavcodec/ac3dsp.h b/mythtv/external/FFmpeg/libavcodec/ac3dsp.h
index ed98c8ce6ae..161de4cb86d 100644
--- a/mythtv/external/FFmpeg/libavcodec/ac3dsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/ac3dsp.h
@@ -132,11 +132,10 @@ typedef struct AC3DSPContext {
     void (*sum_square_butterfly_float)(float sum[4], const float *coef0,
                                        const float *coef1, int len);
 
-    void (*downmix)(float **samples, float (*matrix)[2], int out_ch,
-                    int in_ch, int len);
-
-    void (*downmix_fixed)(int32_t **samples, int16_t (*matrix)[2], int out_ch,
-                          int in_ch, int len);
+    int out_channels;
+    int in_channels;
+    void (*downmix)(float **samples, float **matrix, int len);
+    void (*downmix_fixed)(int32_t **samples, int16_t **matrix, int len);
 
     /**
      * Apply symmetric window in 16-bit fixed-point.
@@ -158,4 +157,11 @@ void ff_ac3dsp_init_arm(AC3DSPContext *c, int bit_exact);
 void ff_ac3dsp_init_x86(AC3DSPContext *c, int bit_exact);
 void ff_ac3dsp_init_mips(AC3DSPContext *c, int bit_exact);
 
+void ff_ac3dsp_downmix(AC3DSPContext *c, float **samples, float **matrix,
+                       int out_ch, int in_ch, int len);
+void ff_ac3dsp_downmix_fixed(AC3DSPContext *c, int32_t **samples, int16_t **matrix,
+                             int out_ch, int in_ch, int len);
+
+void ff_ac3dsp_set_downmix_x86(AC3DSPContext *c);
+
 #endif /* AVCODEC_AC3DSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/ac3enc_fixed.c b/mythtv/external/FFmpeg/libavcodec/ac3enc_fixed.c
index 9d39026dd58..b23fc64776d 100644
--- a/mythtv/external/FFmpeg/libavcodec/ac3enc_fixed.c
+++ b/mythtv/external/FFmpeg/libavcodec/ac3enc_fixed.c
@@ -43,34 +43,6 @@ static const AVClass ac3enc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-#include "ac3enc_template.c"
-
-
-/**
- * Finalize MDCT and free allocated memory.
- *
- * @param s  AC-3 encoder private context
- */
-av_cold void AC3_NAME(mdct_end)(AC3EncodeContext *s)
-{
-    ff_mdct_end(&s->mdct);
-}
-
-
-/**
- * Initialize MDCT tables.
- *
- * @param s  AC-3 encoder private context
- * @return   0 on success, negative error code on failure
- */
-av_cold int AC3_NAME(mdct_init)(AC3EncodeContext *s)
-{
-    int ret = ff_mdct_init(&s->mdct, 9, 0, -1.0);
-    s->mdct_window = ff_ac3_window;
-    return ret;
-}
-
-
 /*
  * Normalize the input samples to use the maximum available precision.
  * This assumes signed 16-bit input samples.
@@ -135,6 +107,34 @@ static CoefType calc_cpl_coord(CoefSumType energy_ch, CoefSumType energy_cpl)
 }
 
 
+#include "ac3enc_template.c"
+
+
+/**
+ * Finalize MDCT and free allocated memory.
+ *
+ * @param s  AC-3 encoder private context
+ */
+av_cold void ff_ac3_fixed_mdct_end(AC3EncodeContext *s)
+{
+    ff_mdct_end(&s->mdct);
+}
+
+
+/**
+ * Initialize MDCT tables.
+ *
+ * @param s  AC-3 encoder private context
+ * @return   0 on success, negative error code on failure
+ */
+av_cold int ff_ac3_fixed_mdct_init(AC3EncodeContext *s)
+{
+    int ret = ff_mdct_init(&s->mdct, 9, 0, -1.0);
+    s->mdct_window = ff_ac3_window;
+    return ret;
+}
+
+
 static av_cold int ac3_fixed_encode_init(AVCodecContext *avctx)
 {
     AC3EncodeContext *s = avctx->priv_data;
diff --git a/mythtv/external/FFmpeg/libavcodec/ac3enc_float.c b/mythtv/external/FFmpeg/libavcodec/ac3enc_float.c
index 6c91f459d00..d6e658b2b42 100644
--- a/mythtv/external/FFmpeg/libavcodec/ac3enc_float.c
+++ b/mythtv/external/FFmpeg/libavcodec/ac3enc_float.c
@@ -43,6 +43,49 @@ static const AVClass ac3enc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
+
+/*
+ * Scale MDCT coefficients from float to 24-bit fixed-point.
+ */
+static void scale_coefficients(AC3EncodeContext *s)
+{
+    int chan_size = AC3_MAX_COEFS * s->num_blocks;
+    int cpl       = s->cpl_on;
+    s->ac3dsp.float_to_fixed24(s->fixed_coef_buffer + (chan_size * !cpl),
+                               s->mdct_coef_buffer  + (chan_size * !cpl),
+                               chan_size * (s->channels + cpl));
+}
+
+
+/*
+ * Clip MDCT coefficients to allowable range.
+ */
+static void clip_coefficients(AudioDSPContext *adsp, float *coef,
+                              unsigned int len)
+{
+    adsp->vector_clipf(coef, coef, len, COEF_MIN, COEF_MAX);
+}
+
+
+/*
+ * Calculate a single coupling coordinate.
+ */
+static CoefType calc_cpl_coord(CoefSumType energy_ch, CoefSumType energy_cpl)
+{
+    float coord = 0.125;
+    if (energy_cpl > 0)
+        coord *= sqrtf(energy_ch / energy_cpl);
+    return FFMIN(coord, COEF_MAX);
+}
+
+static void sum_square_butterfly(AC3EncodeContext *s, float sum[4],
+                                 const float *coef0, const float *coef1,
+                                 int len)
+{
+    s->ac3dsp.sum_square_butterfly_float(sum, coef0, coef1, len);
+}
+
+
 #include "ac3enc_template.c"
 
 
@@ -86,56 +129,6 @@ av_cold int ff_ac3_float_mdct_init(AC3EncodeContext *s)
 }
 
 
-/*
- * Normalize the input samples.
- * Not needed for the floating-point encoder.
- */
-static int normalize_samples(AC3EncodeContext *s)
-{
-    return 0;
-}
-
-
-/*
- * Scale MDCT coefficients from float to 24-bit fixed-point.
- */
-static void scale_coefficients(AC3EncodeContext *s)
-{
-    int chan_size = AC3_MAX_COEFS * s->num_blocks;
-    int cpl       = s->cpl_on;
-    s->ac3dsp.float_to_fixed24(s->fixed_coef_buffer + (chan_size * !cpl),
-                               s->mdct_coef_buffer  + (chan_size * !cpl),
-                               chan_size * (s->channels + cpl));
-}
-
-static void sum_square_butterfly(AC3EncodeContext *s, float sum[4],
-                                 const float *coef0, const float *coef1,
-                                 int len)
-{
-    s->ac3dsp.sum_square_butterfly_float(sum, coef0, coef1, len);
-}
-
-/*
- * Clip MDCT coefficients to allowable range.
- */
-static void clip_coefficients(AudioDSPContext *adsp, float *coef,
-                              unsigned int len)
-{
-    adsp->vector_clipf(coef, coef, COEF_MIN, COEF_MAX, len);
-}
-
-
-/*
- * Calculate a single coupling coordinate.
- */
-static CoefType calc_cpl_coord(CoefSumType energy_ch, CoefSumType energy_cpl)
-{
-    float coord = 0.125;
-    if (energy_cpl > 0)
-        coord *= sqrtf(energy_ch / energy_cpl);
-    return FFMIN(coord, COEF_MAX);
-}
-
 av_cold int ff_ac3_float_encode_init(AVCodecContext *avctx)
 {
     AC3EncodeContext *s = avctx->priv_data;
diff --git a/mythtv/external/FFmpeg/libavcodec/ac3enc_template.c b/mythtv/external/FFmpeg/libavcodec/ac3enc_template.c
index 9dec9ae9cf3..be659872f73 100644
--- a/mythtv/external/FFmpeg/libavcodec/ac3enc_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/ac3enc_template.c
@@ -36,20 +36,6 @@
 #include "ac3enc.h"
 #include "eac3enc.h"
 
-/* prototypes for static functions in ac3enc_fixed.c and ac3enc_float.c */
-
-static void scale_coefficients(AC3EncodeContext *s);
-
-static int normalize_samples(AC3EncodeContext *s);
-
-static void clip_coefficients(AudioDSPContext *adsp, CoefType *coef,
-                              unsigned int len);
-
-static CoefType calc_cpl_coord(CoefSumType energy_ch, CoefSumType energy_cpl);
-
-static void sum_square_butterfly(AC3EncodeContext *s, CoefSumType sum[4],
-                                 const CoefType *coef0, const CoefType *coef1,
-                                 int len);
 
 int AC3_NAME(allocate_sample_buffers)(AC3EncodeContext *s)
 {
@@ -113,10 +99,10 @@ static void apply_mdct(AC3EncodeContext *s)
 #else
             s->ac3dsp.apply_window_int16(s->windowed_samples, input_samples,
                                          s->mdct_window, AC3_WINDOW_SIZE);
-#endif
 
             if (s->fixed_point)
                 block->coeff_shift[ch+1] = normalize_samples(s);
+#endif
 
             s->mdct.mdct_calcw(&s->mdct, block->mdct_coef[ch+1],
                                s->windowed_samples);
diff --git a/mythtv/external/FFmpeg/libavcodec/acelp_pitch_delay.c b/mythtv/external/FFmpeg/libavcodec/acelp_pitch_delay.c
index 8ec1ba3a839..c345a99c816 100644
--- a/mythtv/external/FFmpeg/libavcodec/acelp_pitch_delay.c
+++ b/mythtv/external/FFmpeg/libavcodec/acelp_pitch_delay.c
@@ -135,7 +135,7 @@ float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy,
         ff_exp10(0.05 *
               (avpriv_scalarproduct_float_c(pred_table, prediction_error, 4) +
                energy_mean)) /
-        sqrtf(fixed_mean_energy);
+        sqrtf(fixed_mean_energy ? fixed_mean_energy : 1.0);
 
     // update quantified prediction error energy history
     memmove(&prediction_error[0], &prediction_error[1],
diff --git a/mythtv/external/FFmpeg/libavcodec/adpcm.c b/mythtv/external/FFmpeg/libavcodec/adpcm.c
index cb7f644f66a..be206c55ba4 100644
--- a/mythtv/external/FFmpeg/libavcodec/adpcm.c
+++ b/mythtv/external/FFmpeg/libavcodec/adpcm.c
@@ -343,7 +343,7 @@ static inline int16_t adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, uint8_t
     c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;
     c->predictor = av_clip_int16(c->predictor);
     c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
-    c->step = av_clip(c->step, 127, 24567);
+    c->step = av_clip(c->step, 127, 24576);
     return c->predictor;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/adpcm_data.c b/mythtv/external/FFmpeg/libavcodec/adpcm_data.c
index 52271be26e1..4cce0a58572 100644
--- a/mythtv/external/FFmpeg/libavcodec/adpcm_data.c
+++ b/mythtv/external/FFmpeg/libavcodec/adpcm_data.c
@@ -106,7 +106,7 @@ const int8_t ff_adpcm_yamaha_difflookup[] = {
     -1, -3, -5, -7, -9, -11, -13, -15
 };
 
-const int16_t ff_adpcm_afc_coeffs[2][16] = {
+const uint16_t ff_adpcm_afc_coeffs[2][16] = {
     { 0, 2048, 0, 1024, 4096, 3584, 3072, 4608, 4200, 4800, 5120, 2048, 1024, 64512, 64512, 63488 },
     { 0, 0, 2048, 1024, 63488, 64000, 64512, 62976, 63288, 63236, 62464, 63488, 64512, 1024, 0, 0 }
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/adpcmenc.c b/mythtv/external/FFmpeg/libavcodec/adpcmenc.c
index 36974fd9531..668939c7789 100644
--- a/mythtv/external/FFmpeg/libavcodec/adpcmenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/adpcmenc.c
@@ -258,7 +258,7 @@ static inline uint8_t adpcm_yamaha_compress_sample(ADPCMChannelStatus *c,
     c->predictor += ((c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8);
     c->predictor = av_clip_int16(c->predictor);
     c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;
-    c->step = av_clip(c->step, 127, 24567);
+    c->step = av_clip(c->step, 127, 24576);
 
     return nibble;
 }
@@ -415,7 +415,7 @@ static void adpcm_compress_trellis(AVCodecContext *avctx,
             } else { //AV_CODEC_ID_ADPCM_YAMAHA
                 LOOP_NODES(yamaha, step,
                            av_clip((step * ff_adpcm_yamaha_indexscale[nibble]) >> 8,
-                                   127, 24567));
+                                   127, 24576));
 #undef LOOP_NODES
 #undef STORE_NODE
             }
diff --git a/mythtv/external/FFmpeg/libavcodec/adxdec.c b/mythtv/external/FFmpeg/libavcodec/adxdec.c
index 32cc0f005a4..178ea99dcfc 100644
--- a/mythtv/external/FFmpeg/libavcodec/adxdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/adxdec.c
@@ -81,7 +81,7 @@ static int adx_decode(ADXContext *c, int16_t *out, int offset,
     s2 = prev->s2;
     for (i = 0; i < BLOCK_SAMPLES; i++) {
         d  = get_sbits(&gb, 4);
-        s0 = ((d << COEFF_BITS) * scale + c->coeff[0] * s1 + c->coeff[1] * s2) >> COEFF_BITS;
+        s0 = ((d * (1 << COEFF_BITS)) * scale + c->coeff[0] * s1 + c->coeff[1] * s2) >> COEFF_BITS;
         s2 = s1;
         s1 = av_clip_int16(s0);
         *out++ = s1;
diff --git a/mythtv/external/FFmpeg/libavcodec/aic.c b/mythtv/external/FFmpeg/libavcodec/aic.c
index ff8e3922bea..67d78c5ddd2 100644
--- a/mythtv/external/FFmpeg/libavcodec/aic.c
+++ b/mythtv/external/FFmpeg/libavcodec/aic.c
@@ -449,7 +449,7 @@ static av_cold int aic_decode_init(AVCodecContext *avctx)
 
     ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
     ctx->slice_width  = 16;
-    for (i = 1; i < 32; i++) {
+    for (i = 1; i < ctx->mb_width; i++) {
         if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
             ctx->slice_width  = ctx->mb_width / i;
             ctx->num_x_slices = i;
@@ -492,4 +492,5 @@ AVCodec ff_aic_decoder = {
     .decode         = aic_decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
     .init_thread_copy = ONLY_IF_THREADS_ENABLED(aic_decode_init),
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/alac.c b/mythtv/external/FFmpeg/libavcodec/alac.c
index b9c34009a59..d6bd21ba135 100644
--- a/mythtv/external/FFmpeg/libavcodec/alac.c
+++ b/mythtv/external/FFmpeg/libavcodec/alac.c
@@ -76,6 +76,7 @@ typedef struct ALACContext {
     uint8_t  rice_history_mult;
     uint8_t  rice_initial_history;
     uint8_t  rice_limit;
+    int      sample_rate;
 
     int extra_bits;     /**< number of extra bits beyond 16-bit */
     int nb_samples;     /**< number of samples in the current frame */
@@ -250,7 +251,7 @@ static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index,
     alac->extra_bits = get_bits(&alac->gb, 2) << 3;
     bps = alac->sample_size - alac->extra_bits + channels - 1;
     if (bps > 32U) {
-        av_log(avctx, AV_LOG_ERROR, "bps is unsupported: %d\n", bps);
+        avpriv_report_missing_feature(avctx, "bps %d", bps);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -430,7 +431,7 @@ static int alac_decode_frame(AVCodecContext *avctx, void *data,
             break;
         }
         if (element > TYPE_CPE && element != TYPE_LFE) {
-            av_log(avctx, AV_LOG_ERROR, "syntax element unsupported: %d\n", element);
+            avpriv_report_missing_feature(avctx, "Syntax element %d", element);
             return AVERROR_PATCHWELCOME;
         }
 
@@ -459,7 +460,7 @@ static int alac_decode_frame(AVCodecContext *avctx, void *data,
                avpkt->size * 8 - get_bits_count(&alac->gb));
     }
 
-    if (alac->channels == ch)
+    if (alac->channels == ch && alac->nb_samples)
         *got_frame_ptr = 1;
     else
         av_log(avctx, AV_LOG_WARNING, "Failed to decode all channels\n");
@@ -538,7 +539,7 @@ static int alac_set_info(ALACContext *alac)
     bytestream2_get_be16u(&gb); // maxRun
     bytestream2_get_be32u(&gb); // max coded frame size
     bytestream2_get_be32u(&gb); // average bitrate
-    bytestream2_get_be32u(&gb); // samplerate
+    alac->sample_rate          = bytestream2_get_be32u(&gb);
 
     return 0;
 }
@@ -570,6 +571,7 @@ static av_cold int alac_decode_init(AVCodecContext * avctx)
              return AVERROR_PATCHWELCOME;
     }
     avctx->bits_per_raw_sample = alac->sample_size;
+    avctx->sample_rate         = alac->sample_rate;
 
     if (alac->channels < 1) {
         av_log(avctx, AV_LOG_WARNING, "Invalid channel count\n");
@@ -581,8 +583,8 @@ static av_cold int alac_decode_init(AVCodecContext * avctx)
             avctx->channels = alac->channels;
     }
     if (avctx->channels > ALAC_MAX_CHANNELS || avctx->channels <= 0 ) {
-        av_log(avctx, AV_LOG_ERROR, "Unsupported channel count: %d\n",
-               avctx->channels);
+        avpriv_report_missing_feature(avctx, "Channel count %d",
+                                      avctx->channels);
         return AVERROR_PATCHWELCOME;
     }
     avctx->channel_layout = ff_alac_channel_layouts[alac->channels - 1];
diff --git a/mythtv/external/FFmpeg/libavcodec/allcodecs.c b/mythtv/external/FFmpeg/libavcodec/allcodecs.c
index b592aa3b268..4f34312e673 100644
--- a/mythtv/external/FFmpeg/libavcodec/allcodecs.c
+++ b/mythtv/external/FFmpeg/libavcodec/allcodecs.c
@@ -25,6 +25,7 @@
  */
 
 #include "config.h"
+#include "libavutil/thread.h"
 #include "avcodec.h"
 #include "version.h"
 
@@ -58,20 +59,14 @@
             av_register_codec_parser(&ff_##x##_parser);                 \
     }
 
-void avcodec_register_all(void)
+static void register_all(void)
 {
-    static int initialized;
-
-    if (initialized)
-        return;
-    initialized = 1;
-
     /* hardware accelerators */
-    REGISTER_HWACCEL(H263_CUVID,        h263_cuvid);
     REGISTER_HWACCEL(H263_VAAPI,        h263_vaapi);
     REGISTER_HWACCEL(H263_VIDEOTOOLBOX, h263_videotoolbox);
     REGISTER_HWACCEL(H264_CUVID,        h264_cuvid);
     REGISTER_HWACCEL(H264_D3D11VA,      h264_d3d11va);
+    REGISTER_HWACCEL(H264_D3D11VA2,     h264_d3d11va2);
     REGISTER_HWACCEL(H264_DXVA2,        h264_dxva2);
     REGISTER_HWACCEL(H264_MEDIACODEC,   h264_mediacodec);
     REGISTER_HWACCEL(H264_MMAL,         h264_mmal);
@@ -83,11 +78,13 @@ void avcodec_register_all(void)
     REGISTER_HWACCEL(H264_VIDEOTOOLBOX, h264_videotoolbox);
     REGISTER_HWACCEL(HEVC_CUVID,        hevc_cuvid);
     REGISTER_HWACCEL(HEVC_D3D11VA,      hevc_d3d11va);
+    REGISTER_HWACCEL(HEVC_D3D11VA2,     hevc_d3d11va2);
     REGISTER_HWACCEL(HEVC_DXVA2,        hevc_dxva2);
     REGISTER_HWACCEL(HEVC_MEDIACODEC,   hevc_mediacodec);
     REGISTER_HWACCEL(HEVC_QSV,          hevc_qsv);
     REGISTER_HWACCEL(HEVC_VAAPI,        hevc_vaapi);
     REGISTER_HWACCEL(HEVC_VDPAU,        hevc_vdpau);
+    REGISTER_HWACCEL(HEVC_VIDEOTOOLBOX, hevc_videotoolbox);
     REGISTER_HWACCEL(MJPEG_CUVID,       mjpeg_cuvid);
     REGISTER_HWACCEL(MPEG1_CUVID,       mpeg1_cuvid);
     REGISTER_HWACCEL(MPEG1_XVMC,        mpeg1_xvmc);
@@ -96,12 +93,14 @@ void avcodec_register_all(void)
     REGISTER_HWACCEL(MPEG2_CUVID,       mpeg2_cuvid);
     REGISTER_HWACCEL(MPEG2_XVMC,        mpeg2_xvmc);
     REGISTER_HWACCEL(MPEG2_D3D11VA,     mpeg2_d3d11va);
+    REGISTER_HWACCEL(MPEG2_D3D11VA2,    mpeg2_d3d11va2);
     REGISTER_HWACCEL(MPEG2_DXVA2,       mpeg2_dxva2);
     REGISTER_HWACCEL(MPEG2_MMAL,        mpeg2_mmal);
     REGISTER_HWACCEL(MPEG2_QSV,         mpeg2_qsv);
     REGISTER_HWACCEL(MPEG2_VAAPI,       mpeg2_vaapi);
     REGISTER_HWACCEL(MPEG2_VDPAU,       mpeg2_vdpau);
     REGISTER_HWACCEL(MPEG2_VIDEOTOOLBOX, mpeg2_videotoolbox);
+    REGISTER_HWACCEL(MPEG2_MEDIACODEC,  mpeg2_mediacodec);
     REGISTER_HWACCEL(MPEG4_CUVID,       mpeg4_cuvid);
     REGISTER_HWACCEL(MPEG4_MEDIACODEC,  mpeg4_mediacodec);
     REGISTER_HWACCEL(MPEG4_MMAL,        mpeg4_mmal);
@@ -110,6 +109,7 @@ void avcodec_register_all(void)
     REGISTER_HWACCEL(MPEG4_VIDEOTOOLBOX, mpeg4_videotoolbox);
     REGISTER_HWACCEL(VC1_CUVID,         vc1_cuvid);
     REGISTER_HWACCEL(VC1_D3D11VA,       vc1_d3d11va);
+    REGISTER_HWACCEL(VC1_D3D11VA2,      vc1_d3d11va2);
     REGISTER_HWACCEL(VC1_DXVA2,         vc1_dxva2);
     REGISTER_HWACCEL(VC1_VAAPI,         vc1_vaapi);
     REGISTER_HWACCEL(VC1_VDPAU,         vc1_vdpau);
@@ -117,12 +117,15 @@ void avcodec_register_all(void)
     REGISTER_HWACCEL(VC1_QSV,           vc1_qsv);
     REGISTER_HWACCEL(VP8_CUVID,         vp8_cuvid);
     REGISTER_HWACCEL(VP8_MEDIACODEC,    vp8_mediacodec);
+    REGISTER_HWACCEL(VP8_QSV,           vp8_qsv);
     REGISTER_HWACCEL(VP9_CUVID,         vp9_cuvid);
     REGISTER_HWACCEL(VP9_D3D11VA,       vp9_d3d11va);
+    REGISTER_HWACCEL(VP9_D3D11VA2,      vp9_d3d11va2);
     REGISTER_HWACCEL(VP9_DXVA2,         vp9_dxva2);
     REGISTER_HWACCEL(VP9_MEDIACODEC,    vp9_mediacodec);
     REGISTER_HWACCEL(VP9_VAAPI,         vp9_vaapi);
     REGISTER_HWACCEL(WMV3_D3D11VA,      wmv3_d3d11va);
+    REGISTER_HWACCEL(WMV3_D3D11VA2,     wmv3_d3d11va2);
     REGISTER_HWACCEL(WMV3_DXVA2,        wmv3_dxva2);
     REGISTER_HWACCEL(WMV3_VAAPI,        wmv3_vaapi);
     REGISTER_HWACCEL(WMV3_VDPAU,        wmv3_vdpau);
@@ -158,6 +161,7 @@ void avcodec_register_all(void)
     REGISTER_DECODER(CDXL,              cdxl);
     REGISTER_DECODER(CFHD,              cfhd);
     REGISTER_ENCDEC (CINEPAK,           cinepak);
+    REGISTER_DECODER(CLEARVIDEO,        clearvideo);
     REGISTER_ENCDEC (CLJR,              cljr);
     REGISTER_DECODER(CLLC,              cllc);
     REGISTER_ENCDEC (COMFORTNOISE,      comfortnoise);
@@ -189,24 +193,30 @@ void avcodec_register_all(void)
     REGISTER_ENCDEC (FFV1,              ffv1);
     REGISTER_ENCDEC (FFVHUFF,           ffvhuff);
     REGISTER_DECODER(FIC,               fic);
+    REGISTER_ENCDEC (FITS,              fits);
     REGISTER_ENCDEC (FLASHSV,           flashsv);
     REGISTER_ENCDEC (FLASHSV2,          flashsv2);
     REGISTER_DECODER(FLIC,              flic);
     REGISTER_ENCDEC (FLV,               flv);
+    REGISTER_DECODER(FMVC,              fmvc);
     REGISTER_DECODER(FOURXM,            fourxm);
     REGISTER_DECODER(FRAPS,             fraps);
     REGISTER_DECODER(FRWU,              frwu);
     REGISTER_DECODER(G2M,               g2m);
+    REGISTER_DECODER(GDV,               gdv);
     REGISTER_ENCDEC (GIF,               gif);
     REGISTER_ENCDEC (H261,              h261);
     REGISTER_ENCDEC (H263,              h263);
     REGISTER_DECODER(H263I,             h263i);
     REGISTER_ENCDEC (H263P,             h263p);
+    REGISTER_DECODER(H263_V4L2M2M,      h263_v4l2m2m);
     REGISTER_DECODER(H264,              h264);
     REGISTER_DECODER(H264_CRYSTALHD,    h264_crystalhd);
+    REGISTER_DECODER(H264_V4L2M2M,      h264_v4l2m2m);
     REGISTER_DECODER(H264_MEDIACODEC,   h264_mediacodec);
     REGISTER_DECODER(H264_MMAL,         h264_mmal);
     REGISTER_DECODER(H264_QSV,          h264_qsv);
+    REGISTER_DECODER(H264_RKMPP,        h264_rkmpp);
     REGISTER_DECODER(H264_VDA,          h264_vda);
 #if FF_API_VDPAU
     REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
@@ -214,6 +224,8 @@ void avcodec_register_all(void)
     REGISTER_ENCDEC (HAP,               hap);
     REGISTER_DECODER(HEVC,              hevc);
     REGISTER_DECODER(HEVC_QSV,          hevc_qsv);
+    REGISTER_DECODER(HEVC_RKMPP,        hevc_rkmpp);
+    REGISTER_DECODER(HEVC_V4L2M2M,      hevc_v4l2m2m);
     REGISTER_DECODER(HNM4_VIDEO,        hnm4_video);
     REGISTER_DECODER(HQ_HQA,            hq_hqa);
     REGISTER_DECODER(HQX,               hqx);
@@ -248,6 +260,7 @@ void avcodec_register_all(void)
     REGISTER_ENCDEC (MPEG2VIDEO,        mpeg2video);
     REGISTER_ENCDEC (MPEG4,             mpeg4);
     REGISTER_DECODER(MPEG4_CRYSTALHD,   mpeg4_crystalhd);
+    REGISTER_DECODER(MPEG4_V4L2M2M,     mpeg4_v4l2m2m);
     REGISTER_DECODER(MPEG4_MMAL,        mpeg4_mmal);
 #if FF_API_VDPAU
     REGISTER_DECODER(MPEG4_VDPAU,       mpeg4_vdpau);
@@ -257,14 +270,18 @@ void avcodec_register_all(void)
     REGISTER_DECODER(MPEG_VDPAU,        mpeg_vdpau);
     REGISTER_DECODER(MPEG1_VDPAU,       mpeg1_vdpau);
 #endif
+    REGISTER_DECODER(MPEG1_V4L2M2M,     mpeg1_v4l2m2m);
     REGISTER_DECODER(MPEG2_MMAL,        mpeg2_mmal);
     REGISTER_DECODER(MPEG2_CRYSTALHD,   mpeg2_crystalhd);
+    REGISTER_DECODER(MPEG2_V4L2M2M,     mpeg2_v4l2m2m);
     REGISTER_DECODER(MPEG2_QSV,         mpeg2_qsv);
+    REGISTER_DECODER(MPEG2_MEDIACODEC,  mpeg2_mediacodec);
     REGISTER_DECODER(MSA1,              msa1);
-    REGISTER_DECODER(MSMPEG4_CRYSTALHD, msmpeg4_crystalhd);
+    REGISTER_DECODER(MSCC,              mscc);
     REGISTER_DECODER(MSMPEG4V1,         msmpeg4v1);
     REGISTER_ENCDEC (MSMPEG4V2,         msmpeg4v2);
     REGISTER_ENCDEC (MSMPEG4V3,         msmpeg4v3);
+    REGISTER_DECODER(MSMPEG4_CRYSTALHD, msmpeg4_crystalhd);
     REGISTER_DECODER(MSRLE,             msrle);
     REGISTER_DECODER(MSS1,              mss1);
     REGISTER_DECODER(MSS2,              mss2);
@@ -282,12 +299,14 @@ void avcodec_register_all(void)
     REGISTER_ENCDEC (PGM,               pgm);
     REGISTER_ENCDEC (PGMYUV,            pgmyuv);
     REGISTER_DECODER(PICTOR,            pictor);
+    REGISTER_DECODER(PIXLET,            pixlet);
     REGISTER_ENCDEC (PNG,               png);
     REGISTER_ENCDEC (PPM,               ppm);
     REGISTER_ENCDEC (PRORES,            prores);
     REGISTER_ENCODER(PRORES_AW,         prores_aw);
     REGISTER_ENCODER(PRORES_KS,         prores_ks);
     REGISTER_DECODER(PRORES_LGPL,       prores_lgpl);
+    REGISTER_DECODER(PSD,               psd);
     REGISTER_DECODER(PTX,               ptx);
     REGISTER_DECODER(QDRAW,             qdraw);
     REGISTER_DECODER(QPEG,              qpeg);
@@ -305,6 +324,7 @@ void avcodec_register_all(void)
     REGISTER_DECODER(RV40,              rv40);
     REGISTER_ENCDEC (S302M,             s302m);
     REGISTER_DECODER(SANM,              sanm);
+    REGISTER_DECODER(SCPR,              scpr);
     REGISTER_DECODER(SCREENPRESSO,      screenpresso);
     REGISTER_DECODER(SDX2_DPCM,         sdx2_dpcm);
     REGISTER_ENCDEC (SGI,               sgi);
@@ -315,6 +335,8 @@ void avcodec_register_all(void)
     REGISTER_DECODER(SMVJPEG,           smvjpeg);
     REGISTER_ENCDEC (SNOW,              snow);
     REGISTER_DECODER(SP5X,              sp5x);
+    REGISTER_DECODER(SPEEDHQ,           speedhq);
+    REGISTER_DECODER(SRGC,              srgc);
     REGISTER_ENCDEC (SUNRAST,           sunrast);
     REGISTER_ENCDEC (SVQ1,              svq1);
     REGISTER_DECODER(SVQ3,              svq3);
@@ -349,6 +371,7 @@ void avcodec_register_all(void)
     REGISTER_DECODER(VC1IMAGE,          vc1image);
     REGISTER_DECODER(VC1_MMAL,          vc1_mmal);
     REGISTER_DECODER(VC1_QSV,           vc1_qsv);
+    REGISTER_DECODER(VC1_V4L2M2M,       vc1_v4l2m2m);
     REGISTER_ENCODER(VC2,               vc2);
     REGISTER_DECODER(VCR1,              vcr1);
     REGISTER_DECODER(VMDVIDEO,          vmdvideo);
@@ -360,10 +383,15 @@ void avcodec_register_all(void)
     REGISTER_DECODER(VP6F,              vp6f);
     REGISTER_DECODER(VP7,               vp7);
     REGISTER_DECODER(VP8,               vp8);
+    REGISTER_DECODER(VP8_RKMPP,         vp8_rkmpp);
+    REGISTER_DECODER(VP8_V4L2M2M,       vp8_v4l2m2m);
     REGISTER_DECODER(VP9,               vp9);
+    REGISTER_DECODER(VP9_RKMPP,         vp9_rkmpp);
+    REGISTER_DECODER(VP9_V4L2M2M,       vp9_v4l2m2m);
     REGISTER_DECODER(VQA,               vqa);
+    REGISTER_DECODER(BITPACKED,         bitpacked);
     REGISTER_DECODER(WEBP,              webp);
-    REGISTER_ENCODER(WRAPPED_AVFRAME,   wrapped_avframe);
+    REGISTER_ENCDEC (WRAPPED_AVFRAME,   wrapped_avframe);
     REGISTER_ENCDEC (WMV1,              wmv1);
     REGISTER_ENCDEC (WMV2,              wmv2);
     REGISTER_DECODER(WMV3,              wmv3);
@@ -378,6 +406,7 @@ void avcodec_register_all(void)
     REGISTER_ENCDEC (XBM,               xbm);
     REGISTER_ENCDEC (XFACE,             xface);
     REGISTER_DECODER(XL,                xl);
+    REGISTER_DECODER(XPM,               xpm);
     REGISTER_ENCDEC (XWD,               xwd);
     REGISTER_ENCDEC (Y41P,              y41p);
     REGISTER_DECODER(YLC,               ylc);
@@ -401,12 +430,15 @@ void avcodec_register_all(void)
     REGISTER_DECODER(APE,               ape);
     REGISTER_DECODER(ATRAC1,            atrac1);
     REGISTER_DECODER(ATRAC3,            atrac3);
+    REGISTER_DECODER(ATRAC3AL,          atrac3al);
     REGISTER_DECODER(ATRAC3P,           atrac3p);
+    REGISTER_DECODER(ATRAC3PAL,         atrac3pal);
     REGISTER_DECODER(BINKAUDIO_DCT,     binkaudio_dct);
     REGISTER_DECODER(BINKAUDIO_RDFT,    binkaudio_rdft);
     REGISTER_DECODER(BMV_AUDIO,         bmv_audio);
     REGISTER_DECODER(COOK,              cook);
     REGISTER_ENCDEC (DCA,               dca);
+    REGISTER_DECODER(DOLBY_E,           dolby_e);
     REGISTER_DECODER(DSD_LSBF,          dsd_lsbf);
     REGISTER_DECODER(DSD_MSBF,          dsd_msbf);
     REGISTER_DECODER(DSD_LSBF_PLANAR,   dsd_lsbf_planar);
@@ -444,10 +476,11 @@ void avcodec_register_all(void)
     REGISTER_DECODER(MPC8,              mpc8);
     REGISTER_ENCDEC (NELLYMOSER,        nellymoser);
     REGISTER_DECODER(ON2AVC,            on2avc);
-    REGISTER_DECODER(OPUS,              opus);
+    REGISTER_ENCDEC (OPUS,              opus);
     REGISTER_DECODER(PAF_AUDIO,         paf_audio);
     REGISTER_DECODER(QCELP,             qcelp);
     REGISTER_DECODER(QDM2,              qdm2);
+    REGISTER_DECODER(QDMC,              qdmc);
     REGISTER_ENCDEC (RA_144,            ra_144);
     REGISTER_DECODER(RA_288,            ra_288);
     REGISTER_DECODER(RALF,              ralf);
@@ -477,6 +510,8 @@ void avcodec_register_all(void)
     REGISTER_ENCDEC (PCM_ALAW,          pcm_alaw);
     REGISTER_DECODER(PCM_BLURAY,        pcm_bluray);
     REGISTER_DECODER(PCM_DVD,           pcm_dvd);
+    REGISTER_DECODER(PCM_F16LE,         pcm_f16le);
+    REGISTER_DECODER(PCM_F24LE,         pcm_f24le);
     REGISTER_ENCDEC (PCM_F32BE,         pcm_f32be);
     REGISTER_ENCDEC (PCM_F32LE,         pcm_f32le);
     REGISTER_ENCDEC (PCM_F64BE,         pcm_f64be);
@@ -508,6 +543,7 @@ void avcodec_register_all(void)
     REGISTER_DECODER(PCM_ZORK,          pcm_zork);
 
     /* DPCM codecs */
+    REGISTER_DECODER(GREMLIN_DPCM,      gremlin_dpcm);
     REGISTER_DECODER(INTERPLAY_DPCM,    interplay_dpcm);
     REGISTER_ENCDEC (ROQ_DPCM,          roq_dpcm);
     REGISTER_DECODER(SOL_DPCM,          sol_dpcm);
@@ -528,7 +564,7 @@ void avcodec_register_all(void)
     REGISTER_DECODER(ADPCM_EA_XAS,      adpcm_ea_xas);
     REGISTER_ENCDEC (ADPCM_G722,        adpcm_g722);
     REGISTER_ENCDEC (ADPCM_G726,        adpcm_g726);
-    REGISTER_DECODER(ADPCM_G726LE,      adpcm_g726le);
+    REGISTER_ENCDEC (ADPCM_G726LE,      adpcm_g726le);
     REGISTER_DECODER(ADPCM_IMA_AMV,     adpcm_ima_amv);
     REGISTER_DECODER(ADPCM_IMA_APC,     adpcm_ima_apc);
     REGISTER_DECODER(ADPCM_IMA_DAT4,    adpcm_ima_dat4);
@@ -606,7 +642,7 @@ void avcodec_register_all(void)
     REGISTER_DECODER(LIBOPENCORE_AMRWB, libopencore_amrwb);
     REGISTER_ENCDEC (LIBOPENJPEG,       libopenjpeg);
     REGISTER_ENCDEC (LIBOPUS,           libopus);
-    REGISTER_ENCDEC (LIBSCHROEDINGER,   libschroedinger);
+    REGISTER_DECODER(LIBRSVG,           librsvg);
     REGISTER_ENCODER(LIBSHINE,          libshine);
     REGISTER_ENCDEC (LIBSPEEX,          libspeex);
     REGISTER_ENCODER(LIBTHEORA,         libtheora);
@@ -633,12 +669,13 @@ void avcodec_register_all(void)
 
     /* external libraries, that shouldn't be used by default if one of the
      * above is available */
+    REGISTER_ENCODER(H263_V4L2M2M,      h263_v4l2m2m);
     REGISTER_ENCDEC (LIBOPENH264,       libopenh264);
-    REGISTER_DECODER(H263_CUVID,        h263_cuvid);
     REGISTER_DECODER(H264_CUVID,        h264_cuvid);
     REGISTER_ENCODER(H264_NVENC,        h264_nvenc);
     REGISTER_ENCODER(H264_OMX,          h264_omx);
     REGISTER_ENCODER(H264_QSV,          h264_qsv);
+    REGISTER_ENCODER(H264_V4L2M2M,      h264_v4l2m2m);
     REGISTER_ENCODER(H264_VAAPI,        h264_vaapi);
     REGISTER_ENCODER(H264_VIDEOTOOLBOX, h264_videotoolbox);
 #if FF_API_NVENC_OLD_NAME
@@ -650,6 +687,7 @@ void avcodec_register_all(void)
     REGISTER_DECODER(HEVC_MEDIACODEC,   hevc_mediacodec);
     REGISTER_ENCODER(HEVC_NVENC,        hevc_nvenc);
     REGISTER_ENCODER(HEVC_QSV,          hevc_qsv);
+    REGISTER_ENCODER(HEVC_V4L2M2M,      hevc_v4l2m2m);
     REGISTER_ENCODER(HEVC_VAAPI,        hevc_vaapi);
     REGISTER_ENCODER(LIBKVAZAAR,        libkvazaar);
     REGISTER_DECODER(MJPEG_CUVID,       mjpeg_cuvid);
@@ -657,13 +695,19 @@ void avcodec_register_all(void)
     REGISTER_DECODER(MPEG1_CUVID,       mpeg1_cuvid);
     REGISTER_DECODER(MPEG2_CUVID,       mpeg2_cuvid);
     REGISTER_ENCODER(MPEG2_QSV,         mpeg2_qsv);
+    REGISTER_ENCODER(MPEG2_VAAPI,       mpeg2_vaapi);
     REGISTER_DECODER(MPEG4_CUVID,       mpeg4_cuvid);
     REGISTER_DECODER(MPEG4_MEDIACODEC,  mpeg4_mediacodec);
+    REGISTER_ENCODER(MPEG4_V4L2M2M,     mpeg4_v4l2m2m);
     REGISTER_DECODER(VC1_CUVID,         vc1_cuvid);
     REGISTER_DECODER(VP8_CUVID,         vp8_cuvid);
     REGISTER_DECODER(VP8_MEDIACODEC,    vp8_mediacodec);
+    REGISTER_DECODER(VP8_QSV,           vp8_qsv);
+    REGISTER_ENCODER(VP8_V4L2M2M,       vp8_v4l2m2m);
+    REGISTER_ENCODER(VP8_VAAPI,         vp8_vaapi);
     REGISTER_DECODER(VP9_CUVID,         vp9_cuvid);
     REGISTER_DECODER(VP9_MEDIACODEC,    vp9_mediacodec);
+    REGISTER_ENCODER(VP9_VAAPI,         vp9_vaapi);
 
     /* parsers */
     REGISTER_PARSER(AAC,                aac);
@@ -698,10 +742,19 @@ void avcodec_register_all(void)
     REGISTER_PARSER(PNM,                pnm);
     REGISTER_PARSER(RV30,               rv30);
     REGISTER_PARSER(RV40,               rv40);
+    REGISTER_PARSER(SIPR,               sipr);
     REGISTER_PARSER(TAK,                tak);
     REGISTER_PARSER(VC1,                vc1);
     REGISTER_PARSER(VORBIS,             vorbis);
     REGISTER_PARSER(VP3,                vp3);
     REGISTER_PARSER(VP8,                vp8);
     REGISTER_PARSER(VP9,                vp9);
+    REGISTER_PARSER(XMA,                xma);
+}
+
+void avcodec_register_all(void)
+{
+    static AVOnce control = AV_ONCE_INIT;
+
+    ff_thread_once(&control, register_all);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/alpha/idctdsp_alpha.h b/mythtv/external/FFmpeg/libavcodec/alpha/idctdsp_alpha.h
index bf984950f2c..8cc969d7dee 100644
--- a/mythtv/external/FFmpeg/libavcodec/alpha/idctdsp_alpha.h
+++ b/mythtv/external/FFmpeg/libavcodec/alpha/idctdsp_alpha.h
@@ -28,7 +28,7 @@ extern void (*add_pixels_clamped_axp_p)(const int16_t *block, uint8_t *pixels,
                                         ptrdiff_t line_size);
 
 void ff_simple_idct_axp(int16_t *block);
-void ff_simple_idct_put_axp(uint8_t *dest, int line_size, int16_t *block);
-void ff_simple_idct_add_axp(uint8_t *dest, int line_size, int16_t *block);
+void ff_simple_idct_put_axp(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct_add_axp(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 
 #endif /* AVCODEC_ALPHA_IDCTDSP_ALPHA_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/alpha/pixblockdsp_alpha.c b/mythtv/external/FFmpeg/libavcodec/alpha/pixblockdsp_alpha.c
index 866b762b162..c2f1a1d79c5 100644
--- a/mythtv/external/FFmpeg/libavcodec/alpha/pixblockdsp_alpha.c
+++ b/mythtv/external/FFmpeg/libavcodec/alpha/pixblockdsp_alpha.c
@@ -23,7 +23,7 @@
 #include "asm.h"
 
 static void get_pixels_mvi(int16_t *restrict block,
-                           const uint8_t *restrict pixels, ptrdiff_t line_size)
+                           const uint8_t *restrict pixels, ptrdiff_t stride)
 {
     int h = 8;
 
@@ -34,13 +34,14 @@ static void get_pixels_mvi(int16_t *restrict block,
         stq(unpkbw(p),       block);
         stq(unpkbw(p >> 32), block + 4);
 
-        pixels += line_size;
+        pixels += stride;
         block += 8;
     } while (--h);
 }
 
 static void diff_pixels_mvi(int16_t *block, const uint8_t *s1, const uint8_t *s2,
-                            int stride) {
+                            ptrdiff_t stride)
+{
     int h = 8;
     uint64_t mask = 0x4040;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/alpha/simple_idct_alpha.c b/mythtv/external/FFmpeg/libavcodec/alpha/simple_idct_alpha.c
index 04be0cef061..6e377ef2435 100644
--- a/mythtv/external/FFmpeg/libavcodec/alpha/simple_idct_alpha.c
+++ b/mythtv/external/FFmpeg/libavcodec/alpha/simple_idct_alpha.c
@@ -290,13 +290,13 @@ void ff_simple_idct_axp(int16_t *block)
     }
 }
 
-void ff_simple_idct_put_axp(uint8_t *dest, int line_size, int16_t *block)
+void ff_simple_idct_put_axp(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     ff_simple_idct_axp(block);
     put_pixels_clamped_axp_p(block, dest, line_size);
 }
 
-void ff_simple_idct_add_axp(uint8_t *dest, int line_size, int16_t *block)
+void ff_simple_idct_add_axp(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     ff_simple_idct_axp(block);
     add_pixels_clamped_axp_p(block, dest, line_size);
diff --git a/mythtv/external/FFmpeg/libavcodec/alsdec.c b/mythtv/external/FFmpeg/libavcodec/alsdec.c
index 3986347ee2e..13bd52f297f 100644
--- a/mythtv/external/FFmpeg/libavcodec/alsdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/alsdec.c
@@ -31,7 +31,6 @@
 #include "get_bits.h"
 #include "unary.h"
 #include "mpeg4audio.h"
-#include "bytestream.h"
 #include "bgmc.h"
 #include "bswapdsp.h"
 #include "internal.h"
@@ -762,7 +761,7 @@ static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
             }
 
             for (k = 2; k < opt_order; k++)
-                quant_cof[k] = (quant_cof[k] << 14) + (add_base << 13);
+                quant_cof[k] = (quant_cof[k] * (1 << 14)) + (add_base << 13);
         }
     }
 
@@ -867,7 +866,7 @@ static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
                     res >>= 1;
 
                     if (cur_k) {
-                        res <<= cur_k;
+                        res  *= 1 << cur_k;
                         res  |= get_bits_long(gb, cur_k);
                     }
                 }
@@ -1500,7 +1499,7 @@ static int read_diff_float_data(ALSDecContext *ctx, unsigned int ra_frame) {
 
                 tmp_32 = ff_mlz_decompression(ctx->mlz, gb, nchars, larray);
                 if(tmp_32 != nchars) {
-                    av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%d, %d).\n", tmp_32, nchars);
+                    av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%"PRId32", %d).\n", tmp_32, nchars);
                     return AVERROR_INVALIDDATA;
                 }
 
@@ -1543,7 +1542,7 @@ static int read_diff_float_data(ALSDecContext *ctx, unsigned int ra_frame) {
 
                 tmp_32 = ff_mlz_decompression(ctx->mlz, gb, nchars, larray);
                 if(tmp_32 != nchars) {
-                    av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%d, %d).\n", tmp_32, nchars);
+                    av_log(ctx->avctx, AV_LOG_ERROR, "Error in MLZ decompression (%"PRId32", %d).\n", tmp_32, nchars);
                     return AVERROR_INVALIDDATA;
                 }
 
@@ -1637,7 +1636,7 @@ static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
                     independent_bs = 2;
 
             // if this is the last channel, it has to be decoded independently
-            if (c == avctx->channels - 1)
+            if (c == avctx->channels - 1 || (c & 1))
                 independent_bs = 1;
 
             if (independent_bs) {
diff --git a/mythtv/external/FFmpeg/libavcodec/amrwbdata.h b/mythtv/external/FFmpeg/libavcodec/amrwbdata.h
index e0152a651ee..8a8cbfdddf2 100644
--- a/mythtv/external/FFmpeg/libavcodec/amrwbdata.h
+++ b/mythtv/external/FFmpeg/libavcodec/amrwbdata.h
@@ -673,7 +673,7 @@ static const uint16_t order_MODE_23k85[] = {
 };
 
 /** Reordering array addresses for each mode */
-static const uint16_t* amr_bit_orderings_by_mode[] = {
+static const uint16_t * const amr_bit_orderings_by_mode[] = {
     order_MODE_6k60,
     order_MODE_8k85,
     order_MODE_12k65,
diff --git a/mythtv/external/FFmpeg/libavcodec/amrwbdec.c b/mythtv/external/FFmpeg/libavcodec/amrwbdec.c
index 7d0c135c5ec..7f2874d35f3 100644
--- a/mythtv/external/FFmpeg/libavcodec/amrwbdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/amrwbdec.c
@@ -262,7 +262,7 @@ static void decode_pitch_lag_high(int *lag_int, int *lag_frac, int pitch_index,
             *lag_frac = pitch_index - (*lag_int << 2) + 136;
         } else if (pitch_index < 440) {
             *lag_int  = (pitch_index + 257 - 376) >> 1;
-            *lag_frac = (pitch_index - (*lag_int << 1) + 256 - 376) << 1;
+            *lag_frac = (pitch_index - (*lag_int << 1) + 256 - 376) * 2;
             /* the actual resolution is 1/2 but expressed as 1/4 */
         } else {
             *lag_int  = pitch_index - 280;
@@ -292,7 +292,7 @@ static void decode_pitch_lag_low(int *lag_int, int *lag_frac, int pitch_index,
     if (subframe == 0 || (subframe == 2 && mode != MODE_6k60)) {
         if (pitch_index < 116) {
             *lag_int  = (pitch_index + 69) >> 1;
-            *lag_frac = (pitch_index - (*lag_int << 1) + 68) << 1;
+            *lag_frac = (pitch_index - (*lag_int << 1) + 68) * 2;
         } else {
             *lag_int  = pitch_index - 24;
             *lag_frac = 0;
@@ -302,7 +302,7 @@ static void decode_pitch_lag_low(int *lag_int, int *lag_frac, int pitch_index,
                                 AMRWB_P_DELAY_MIN, AMRWB_P_DELAY_MAX - 15);
     } else {
         *lag_int  = (pitch_index + 1) >> 1;
-        *lag_frac = (pitch_index - (*lag_int << 1)) << 1;
+        *lag_frac = (pitch_index - (*lag_int << 1)) * 2;
         *lag_int += *base_lag_int;
     }
 }
@@ -611,7 +611,7 @@ static float voice_factor(float *p_vector, float p_gain,
                                                           AMRWB_SFR_SIZE) *
                     f_gain * f_gain;
 
-    return (p_ener - f_ener) / (p_ener + f_ener);
+    return (p_ener - f_ener) / (p_ener + f_ener + 0.01);
 }
 
 /**
diff --git a/mythtv/external/FFmpeg/libavcodec/anm.c b/mythtv/external/FFmpeg/libavcodec/anm.c
index 29d59fbceb6..72684189bbb 100644
--- a/mythtv/external/FFmpeg/libavcodec/anm.c
+++ b/mythtv/external/FFmpeg/libavcodec/anm.c
@@ -199,4 +199,5 @@ AVCodec ff_anm_decoder = {
     .close          = decode_end,
     .decode         = decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/ansi.c b/mythtv/external/FFmpeg/libavcodec/ansi.c
index 19c88d8d516..f1fafab771b 100644
--- a/mythtv/external/FFmpeg/libavcodec/ansi.c
+++ b/mythtv/external/FFmpeg/libavcodec/ansi.c
@@ -80,10 +80,6 @@ static av_cold int decode_init(AVCodecContext *avctx)
     AnsiContext *s = avctx->priv_data;
     avctx->pix_fmt = AV_PIX_FMT_PAL8;
 
-    s->frame = av_frame_alloc();
-    if (!s->frame)
-        return AVERROR(ENOMEM);
-
     /* defaults */
     s->font        = avpriv_vga16_font;
     s->font_height = 16;
@@ -98,6 +94,11 @@ static av_cold int decode_init(AVCodecContext *avctx)
         av_log(avctx, AV_LOG_ERROR, "Invalid dimensions %d %d\n", avctx->width, avctx->height);
         return AVERROR(EINVAL);
     }
+
+    s->frame = av_frame_alloc();
+    if (!s->frame)
+        return AVERROR(ENOMEM);
+
     return 0;
 }
 
@@ -482,4 +483,5 @@ AVCodec ff_ansi_decoder = {
     .close          = decode_close,
     .decode         = decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/apedec.c b/mythtv/external/FFmpeg/libavcodec/apedec.c
index b99598b4ee7..15eb416ba4e 100644
--- a/mythtv/external/FFmpeg/libavcodec/apedec.c
+++ b/mythtv/external/FFmpeg/libavcodec/apedec.c
@@ -495,7 +495,7 @@ static inline int ape_decode_value_3860(APEContext *ctx, GetBitContext *gb,
     else if(rice->k <= MIN_CACHE_BITS) {
         x = (overflow << rice->k) + get_bits(gb, rice->k);
     } else {
-        av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %d\n", rice->k);
+        av_log(ctx->avctx, AV_LOG_ERROR, "Too many bits: %"PRIu32"\n", rice->k);
         return AVERROR_INVALIDDATA;
     }
     rice->ksum += x - (rice->ksum + 8 >> 4);
@@ -1412,6 +1412,7 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
     int32_t *sample24;
     int i, ch, ret;
     int blockstodecode;
+    uint64_t decoded_buffer_size;
 
     /* this should never be negative, but bad things will happen if it is, so
        check it just to make sure. */
@@ -1467,7 +1468,7 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
                 skip_bits_long(&s->gb, offset);
         }
 
-        if (!nblocks || nblocks > INT_MAX) {
+        if (!nblocks || nblocks > INT_MAX / 2 / sizeof(*s->decoded_buffer) - 8) {
             av_log(avctx, AV_LOG_ERROR, "Invalid sample count: %"PRIu32".\n",
                    nblocks);
             return AVERROR_INVALIDDATA;
@@ -1493,8 +1494,9 @@ static int ape_decode_frame(AVCodecContext *avctx, void *data,
         blockstodecode = s->samples;
 
     /* reallocate decoded sample buffer if needed */
-    av_fast_malloc(&s->decoded_buffer, &s->decoded_size,
-                   2 * FFALIGN(blockstodecode, 8) * sizeof(*s->decoded_buffer));
+    decoded_buffer_size = 2LL * FFALIGN(blockstodecode, 8) * sizeof(*s->decoded_buffer);
+    av_assert0(decoded_buffer_size <= INT_MAX);
+    av_fast_malloc(&s->decoded_buffer, &s->decoded_size, decoded_buffer_size);
     if (!s->decoded_buffer)
         return AVERROR(ENOMEM);
     memset(s->decoded_buffer, 0, s->decoded_size);
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/Makefile b/mythtv/external/FFmpeg/libavcodec/arm/Makefile
index a4ceca7f467..1eeac5449ee 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/Makefile
+++ b/mythtv/external/FFmpeg/libavcodec/arm/Makefile
@@ -44,6 +44,9 @@ OBJS-$(CONFIG_MLP_DECODER)             += arm/mlpdsp_init_arm.o
 OBJS-$(CONFIG_RV40_DECODER)            += arm/rv40dsp_init_arm.o
 OBJS-$(CONFIG_VORBIS_DECODER)          += arm/vorbisdsp_init_arm.o
 OBJS-$(CONFIG_VP6_DECODER)             += arm/vp6dsp_init_arm.o
+OBJS-$(CONFIG_VP9_DECODER)             += arm/vp9dsp_init_10bpp_arm.o   \
+                                          arm/vp9dsp_init_12bpp_arm.o   \
+                                          arm/vp9dsp_init_arm.o
 
 
 # ARMv5 optimizations
@@ -139,3 +142,9 @@ NEON-OBJS-$(CONFIG_RV40_DECODER)       += arm/rv34dsp_neon.o            \
                                           arm/rv40dsp_neon.o
 NEON-OBJS-$(CONFIG_VORBIS_DECODER)     += arm/vorbisdsp_neon.o
 NEON-OBJS-$(CONFIG_VP6_DECODER)        += arm/vp6dsp_neon.o
+NEON-OBJS-$(CONFIG_VP9_DECODER)        += arm/vp9itxfm_16bpp_neon.o     \
+                                          arm/vp9itxfm_neon.o           \
+                                          arm/vp9lpf_16bpp_neon.o       \
+                                          arm/vp9lpf_neon.o             \
+                                          arm/vp9mc_16bpp_neon.o        \
+                                          arm/vp9mc_neon.o
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/aacpsdsp_init_arm.c b/mythtv/external/FFmpeg/libavcodec/arm/aacpsdsp_init_arm.c
index e04787caae0..6eb979ed1d9 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/aacpsdsp_init_arm.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/aacpsdsp_init_arm.c
@@ -29,7 +29,7 @@ void ff_ps_mul_pair_single_neon(float (*dst)[2], float (*src0)[2],
                                 float *src1, int n);
 void ff_ps_hybrid_analysis_neon(float (*out)[2], float (*in)[2],
                                 const float (*filter)[8][2],
-                                int stride, int n);
+                                ptrdiff_t stride, int n);
 void ff_ps_hybrid_analysis_ileave_neon(float (*out)[32][2], float L[2][38][64],
                                        int i, int len);
 void ff_ps_hybrid_synthesis_deint_neon(float out[2][38][64], float (*in)[32][2],
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/aacpsdsp_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/aacpsdsp_neon.S
index a93bbfea9c6..3b1bed2aa70 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/aacpsdsp_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/aacpsdsp_neon.S
@@ -232,12 +232,11 @@ endfunc
 function ff_ps_stereo_interpolate_neon, export=1
         vld1.32         {q0},     [r2]
         vld1.32         {q14},    [r3]
-        vadd.f32        q15, q14, q14
         mov             r2,  r0
         mov             r3,  r1
         ldr             r12, [sp]
         vadd.f32        q1,  q0,  q14
-        vadd.f32        q0,  q0,  q15
+        vadd.f32        q0,  q1,  q14
         vld1.32         {q2},     [r0,:64]!
         vld1.32         {q3},     [r1,:64]!
         subs            r12, r12, #1
@@ -251,8 +250,10 @@ function ff_ps_stereo_interpolate_neon, export=1
         vmla.f32        d17, d7,  d1[0]
         vmla.f32        d18, d6,  d3[1]
         vmla.f32        d19, d7,  d1[1]
-        vadd.f32        q1,  q1,  q15
-        vadd.f32        q0,  q0,  q15
+        vadd.f32        q1,  q1,  q14
+        vadd.f32        q0,  q0,  q14
+        vadd.f32        q1,  q1,  q14
+        vadd.f32        q0,  q0,  q14
         vld1.32         {q2},     [r0,:64]!
         vld1.32         {q3},     [r1,:64]!
         vst1.32         {q8},     [r2,:64]!
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/audiodsp_init_neon.c b/mythtv/external/FFmpeg/libavcodec/arm/audiodsp_init_neon.c
index f7bd162482f..6902db86b4c 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/audiodsp_init_neon.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/audiodsp_init_neon.c
@@ -25,8 +25,7 @@
 #include "libavcodec/audiodsp.h"
 #include "audiodsp_arm.h"
 
-void ff_vector_clipf_neon(float *dst, const float *src, float min, float max,
-                          int len);
+void ff_vector_clipf_neon(float *dst, const float *src, int len, float min, float max);
 void ff_vector_clip_int32_neon(int32_t *dst, const int32_t *src, int32_t min,
                                int32_t max, unsigned int len);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/audiodsp_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/audiodsp_neon.S
index ab32cef7ab5..cea700c84de 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/audiodsp_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/audiodsp_neon.S
@@ -24,9 +24,8 @@
 function ff_vector_clipf_neon, export=1
 VFP     vdup.32         q1,  d0[1]
 VFP     vdup.32         q0,  d0[0]
-NOVFP   vdup.32         q0,  r2
-NOVFP   vdup.32         q1,  r3
-NOVFP   ldr             r2,  [sp]
+NOVFP   vdup.32         q0,  r3
+NOVFP   vld1.32         {d2[],d3[]}, [sp]
         vld1.f32        {q2},[r1,:128]!
         vmin.f32        q10, q2,  q1
         vld1.f32        {q3},[r1,:128]!
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/blockdsp_init_neon.c b/mythtv/external/FFmpeg/libavcodec/arm/blockdsp_init_neon.c
index 87c0d6d6eb8..0600bc6e507 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/blockdsp_init_neon.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/blockdsp_init_neon.c
@@ -30,6 +30,6 @@ void ff_clear_blocks_neon(int16_t *blocks);
 
 av_cold void ff_blockdsp_init_neon(BlockDSPContext *c)
 {
-      c->clear_block  = ff_clear_block_neon;
-      c->clear_blocks = ff_clear_blocks_neon;
+    c->clear_block  = ff_clear_block_neon;
+    c->clear_blocks = ff_clear_blocks_neon;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/h264chroma_init_arm.c b/mythtv/external/FFmpeg/libavcodec/arm/h264chroma_init_arm.c
index 13f7e0d7026..aae804b6212 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/h264chroma_init_arm.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/h264chroma_init_arm.c
@@ -26,13 +26,19 @@
 #include "libavutil/arm/cpu.h"
 #include "libavcodec/h264chroma.h"
 
-void ff_put_h264_chroma_mc8_neon(uint8_t *, uint8_t *, int, int, int, int);
-void ff_put_h264_chroma_mc4_neon(uint8_t *, uint8_t *, int, int, int, int);
-void ff_put_h264_chroma_mc2_neon(uint8_t *, uint8_t *, int, int, int, int);
+void ff_put_h264_chroma_mc8_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                 int h, int x, int y);
+void ff_put_h264_chroma_mc4_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                 int h, int x, int y);
+void ff_put_h264_chroma_mc2_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                 int h, int x, int y);
 
-void ff_avg_h264_chroma_mc8_neon(uint8_t *, uint8_t *, int, int, int, int);
-void ff_avg_h264_chroma_mc4_neon(uint8_t *, uint8_t *, int, int, int, int);
-void ff_avg_h264_chroma_mc2_neon(uint8_t *, uint8_t *, int, int, int, int);
+void ff_avg_h264_chroma_mc8_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                 int h, int x, int y);
+void ff_avg_h264_chroma_mc4_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                 int h, int x, int y);
+void ff_avg_h264_chroma_mc2_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                 int h, int x, int y);
 
 av_cold void ff_h264chroma_init_arm(H264ChromaContext *c, int bit_depth)
 {
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/h264cmc_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/h264cmc_neon.S
index fc48a6f8f6b..5a4159eedde 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/h264cmc_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/h264cmc_neon.S
@@ -20,7 +20,7 @@
 
 #include "libavutil/arm/asm.S"
 
-/* chroma_mc8(uint8_t *dst, uint8_t *src, int stride, int h, int x, int y) */
+/* chroma_mc8(uint8_t *dst, uint8_t *src, ptrdiff_t stride, int h, int x, int y) */
 .macro  h264_chroma_mc8 type, codec=h264
 function ff_\type\()_\codec\()_chroma_mc8_neon, export=1
         push            {r4-r7, lr}
@@ -195,7 +195,7 @@ T       cmp             r7,  #0
 endfunc
 .endm
 
-/* chroma_mc4(uint8_t *dst, uint8_t *src, int stride, int h, int x, int y) */
+/* chroma_mc4(uint8_t *dst, uint8_t *src, ptrdiff_t stride, int h, int x, int y) */
 .macro  h264_chroma_mc4 type, codec=h264
 function ff_\type\()_\codec\()_chroma_mc4_neon, export=1
         push            {r4-r7, lr}
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/hevcdsp_idct_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/hevcdsp_idct_neon.S
index 13d540e5ffe..e39d00634b6 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/hevcdsp_idct_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/hevcdsp_idct_neon.S
@@ -97,7 +97,7 @@ function ff_hevc_idct_32x32_dc_neon_8, export=1
         bx lr
 endfunc
 
-function ff_hevc_transform_add_4x4_neon_8, export=1
+function ff_hevc_add_residual_4x4_neon_8, export=1
         vldm        r1, {q0-q1}
         vld1.32     d4[0], [r0], r2
         vld1.32     d4[1], [r0], r2
@@ -117,7 +117,7 @@ function ff_hevc_transform_add_4x4_neon_8, export=1
         bx          lr
 endfunc
 
-function ff_hevc_transform_add_8x8_neon_8, export=1
+function ff_hevc_add_residual_8x8_neon_8, export=1
         mov         r3,   #8
 1:      subs        r3,   #1
         vld1.16     {q0}, [r1]!
@@ -130,7 +130,7 @@ function ff_hevc_transform_add_8x8_neon_8, export=1
         bx          lr
 endfunc
 
-function ff_hevc_transform_add_16x16_neon_8, export=1
+function ff_hevc_add_residual_16x16_neon_8, export=1
         mov         r3,   #16
 1:      subs        r3,   #1
         vld1.16     {q0, q1}, [r1]!
@@ -146,7 +146,7 @@ function ff_hevc_transform_add_16x16_neon_8, export=1
         bx          lr
 endfunc
 
-function ff_hevc_transform_add_32x32_neon_8, export=1
+function ff_hevc_add_residual_32x32_neon_8, export=1
         mov         r3,   #32
 1:      subs        r3,   #1
         vldm        r1!, {q0-q3}
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/hevcdsp_init_neon.c b/mythtv/external/FFmpeg/libavcodec/arm/hevcdsp_init_neon.c
index 55918077e2b..1a3912c6097 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/hevcdsp_init_neon.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/hevcdsp_init_neon.c
@@ -34,14 +34,14 @@ void ff_hevc_idct_8x8_dc_neon_8(int16_t *coeffs);
 void ff_hevc_idct_16x16_dc_neon_8(int16_t *coeffs);
 void ff_hevc_idct_32x32_dc_neon_8(int16_t *coeffs);
 void ff_hevc_transform_luma_4x4_neon_8(int16_t *coeffs);
-void ff_hevc_transform_add_4x4_neon_8(uint8_t *_dst, int16_t *coeffs,
-                                      ptrdiff_t stride);
-void ff_hevc_transform_add_8x8_neon_8(uint8_t *_dst, int16_t *coeffs,
-                                      ptrdiff_t stride);
-void ff_hevc_transform_add_16x16_neon_8(uint8_t *_dst, int16_t *coeffs,
-                                      ptrdiff_t stride);
-void ff_hevc_transform_add_32x32_neon_8(uint8_t *_dst, int16_t *coeffs,
-                                      ptrdiff_t stride);
+void ff_hevc_add_residual_4x4_neon_8(uint8_t *_dst, int16_t *coeffs,
+                                     ptrdiff_t stride);
+void ff_hevc_add_residual_8x8_neon_8(uint8_t *_dst, int16_t *coeffs,
+                                     ptrdiff_t stride);
+void ff_hevc_add_residual_16x16_neon_8(uint8_t *_dst, int16_t *coeffs,
+                                       ptrdiff_t stride);
+void ff_hevc_add_residual_32x32_neon_8(uint8_t *_dst, int16_t *coeffs,
+                                       ptrdiff_t stride);
 
 #define PUT_PIXELS(name) \
     void name(int16_t *dst, uint8_t *src, \
@@ -156,11 +156,11 @@ av_cold void ff_hevcdsp_init_neon(HEVCDSPContext *c, const int bit_depth)
         c->idct_dc[1]                  = ff_hevc_idct_8x8_dc_neon_8;
         c->idct_dc[2]                  = ff_hevc_idct_16x16_dc_neon_8;
         c->idct_dc[3]                  = ff_hevc_idct_32x32_dc_neon_8;
-        c->transform_add[0]            = ff_hevc_transform_add_4x4_neon_8;
-        c->transform_add[1]            = ff_hevc_transform_add_8x8_neon_8;
-        c->transform_add[2]            = ff_hevc_transform_add_16x16_neon_8;
-        c->transform_add[3]            = ff_hevc_transform_add_32x32_neon_8;
-        c->idct_4x4_luma               = ff_hevc_transform_luma_4x4_neon_8;
+        c->add_residual[0]             = ff_hevc_add_residual_4x4_neon_8;
+        c->add_residual[1]             = ff_hevc_add_residual_8x8_neon_8;
+        c->add_residual[2]             = ff_hevc_add_residual_16x16_neon_8;
+        c->add_residual[3]             = ff_hevc_add_residual_32x32_neon_8;
+        c->transform_4x4_luma          = ff_hevc_transform_luma_4x4_neon_8;
         put_hevc_qpel_neon[1][0]       = ff_hevc_put_qpel_v1_neon_8;
         put_hevc_qpel_neon[2][0]       = ff_hevc_put_qpel_v2_neon_8;
         put_hevc_qpel_neon[3][0]       = ff_hevc_put_qpel_v3_neon_8;
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/hpeldsp_arm.S b/mythtv/external/FFmpeg/libavcodec/arm/hpeldsp_arm.S
index 219f793d992..6f3e3fb0d1e 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/hpeldsp_arm.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/hpeldsp_arm.S
@@ -90,7 +90,7 @@
 
 @ ----------------------------------------------------------------
 function ff_put_pixels16_arm, export=1, align=5
-        @ void func(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+        @ void func(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
         @ block = word aligned, pixles = unaligned
         pld             [r1]
         push            {r4-r11, lr}
@@ -141,7 +141,7 @@ endfunc
 
 @ ----------------------------------------------------------------
 function ff_put_pixels8_arm, export=1, align=5
-        @ void func(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+        @ void func(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
         @ block = word aligned, pixles = unaligned
         pld             [r1]
         push            {r4-r5,lr}
@@ -192,7 +192,7 @@ endfunc
 
 @ ----------------------------------------------------------------
 function ff_put_pixels8_x2_arm, export=1, align=5
-        @ void func(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+        @ void func(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
         @ block = word aligned, pixles = unaligned
         pld             [r1]
         push            {r4-r10,lr}
@@ -250,7 +250,7 @@ function ff_put_pixels8_x2_arm, export=1, align=5
 endfunc
 
 function ff_put_no_rnd_pixels8_x2_arm, export=1, align=5
-        @ void func(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+        @ void func(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
         @ block = word aligned, pixles = unaligned
         pld             [r1]
         push            {r4-r10,lr}
@@ -310,7 +310,7 @@ endfunc
 
 @ ----------------------------------------------------------------
 function ff_put_pixels8_y2_arm, export=1, align=5
-        @ void func(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+        @ void func(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
         @ block = word aligned, pixles = unaligned
         pld             [r1]
         push            {r4-r11,lr}
@@ -407,7 +407,7 @@ function ff_put_pixels8_y2_arm, export=1, align=5
 endfunc
 
 function ff_put_no_rnd_pixels8_y2_arm, export=1, align=5
-        @ void func(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+        @ void func(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
         @ block = word aligned, pixles = unaligned
         pld             [r1]
         push            {r4-r11,lr}
@@ -573,7 +573,7 @@ endfunc
 .endm
 
 function ff_put_pixels8_xy2_arm, export=1, align=5
-        @ void func(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+        @ void func(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
         @ block = word aligned, pixles = unaligned
         pld             [r1]
         push            {r4-r11,lr} @ R14 is also called LR
@@ -588,7 +588,7 @@ function ff_put_pixels8_xy2_arm, export=1, align=5
 endfunc
 
 function ff_put_no_rnd_pixels8_xy2_arm, export=1, align=5
-        @ void func(uint8_t *block, const uint8_t *pixels, int line_size, int h)
+        @ void func(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
         @ block = word aligned, pixles = unaligned
         pld             [r1]
         push            {r4-r11,lr}
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/idct.h b/mythtv/external/FFmpeg/libavcodec/arm/idct.h
index 39cef3a8746..6c79a69c5fb 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/idct.h
+++ b/mythtv/external/FFmpeg/libavcodec/arm/idct.h
@@ -19,6 +19,7 @@
 #ifndef AVCODEC_ARM_IDCT_H
 #define AVCODEC_ARM_IDCT_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 void ff_j_rev_dct_arm(int16_t *data);
@@ -26,15 +27,15 @@ void ff_j_rev_dct_arm(int16_t *data);
 void ff_simple_idct_arm(int16_t *data);
 
 void ff_simple_idct_armv5te(int16_t *data);
-void ff_simple_idct_put_armv5te(uint8_t *dest, int line_size, int16_t *data);
-void ff_simple_idct_add_armv5te(uint8_t *dest, int line_size, int16_t *data);
+void ff_simple_idct_put_armv5te(uint8_t *dest, ptrdiff_t line_size, int16_t *data);
+void ff_simple_idct_add_armv5te(uint8_t *dest, ptrdiff_t line_size, int16_t *data);
 
 void ff_simple_idct_armv6(int16_t *data);
-void ff_simple_idct_put_armv6(uint8_t *dest, int line_size, int16_t *data);
-void ff_simple_idct_add_armv6(uint8_t *dest, int line_size, int16_t *data);
+void ff_simple_idct_put_armv6(uint8_t *dest, ptrdiff_t line_size, int16_t *data);
+void ff_simple_idct_add_armv6(uint8_t *dest, ptrdiff_t line_size, int16_t *data);
 
 void ff_simple_idct_neon(int16_t *data);
-void ff_simple_idct_put_neon(uint8_t *dest, int line_size, int16_t *data);
-void ff_simple_idct_add_neon(uint8_t *dest, int line_size, int16_t *data);
+void ff_simple_idct_put_neon(uint8_t *dest, ptrdiff_t line_size, int16_t *data);
+void ff_simple_idct_add_neon(uint8_t *dest, ptrdiff_t line_size, int16_t *data);
 
 #endif /* AVCODEC_ARM_IDCT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/idctdsp_init_arm.c b/mythtv/external/FFmpeg/libavcodec/arm/idctdsp_init_arm.c
index 0068e3f86c8..ebc90e4b49e 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/idctdsp_init_arm.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/idctdsp_init_arm.c
@@ -19,6 +19,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "libavutil/attributes.h"
@@ -34,28 +35,32 @@ void ff_add_pixels_clamped_arm(const int16_t *block, uint8_t *dest,
 
 /* XXX: those functions should be suppressed ASAP when all IDCTs are
  * converted */
-static void j_rev_dct_arm_put(uint8_t *dest, int line_size, int16_t *block)
+static void j_rev_dct_arm_put(uint8_t *dest, ptrdiff_t line_size,
+                              int16_t *block)
 {
     ff_j_rev_dct_arm(block);
-    ff_put_pixels_clamped(block, dest, line_size);
+    ff_put_pixels_clamped_c(block, dest, line_size);
 }
 
-static void j_rev_dct_arm_add(uint8_t *dest, int line_size, int16_t *block)
+static void j_rev_dct_arm_add(uint8_t *dest, ptrdiff_t line_size,
+                              int16_t *block)
 {
     ff_j_rev_dct_arm(block);
-    ff_add_pixels_clamped(block, dest, line_size);
+    ff_add_pixels_clamped_arm(block, dest, line_size);
 }
 
-static void simple_idct_arm_put(uint8_t *dest, int line_size, int16_t *block)
+static void simple_idct_arm_put(uint8_t *dest, ptrdiff_t line_size,
+                                int16_t *block)
 {
     ff_simple_idct_arm(block);
-    ff_put_pixels_clamped(block, dest, line_size);
+    ff_put_pixels_clamped_c(block, dest, line_size);
 }
 
-static void simple_idct_arm_add(uint8_t *dest, int line_size, int16_t *block)
+static void simple_idct_arm_add(uint8_t *dest, ptrdiff_t line_size,
+                                int16_t *block)
 {
     ff_simple_idct_arm(block);
-    ff_add_pixels_clamped(block, dest, line_size);
+    ff_add_pixels_clamped_arm(block, dest, line_size);
 }
 
 av_cold void ff_idctdsp_init_arm(IDCTDSPContext *c, AVCodecContext *avctx,
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/mpegaudiodsp_init_arm.c b/mythtv/external/FFmpeg/libavcodec/arm/mpegaudiodsp_init_arm.c
index 98e0c8a3a83..d87bd27ad8d 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/mpegaudiodsp_init_arm.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/mpegaudiodsp_init_arm.c
@@ -26,7 +26,7 @@
 #include "config.h"
 
 void ff_mpadsp_apply_window_fixed_armv6(int32_t *synth_buf, int32_t *window,
-                                        int *dither, int16_t *out, int incr);
+                                        int *dither, int16_t *out, ptrdiff_t incr);
 
 av_cold void ff_mpadsp_init_arm(MPADSPContext *s)
 {
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/neontest.c b/mythtv/external/FFmpeg/libavcodec/arm/neontest.c
index 56f950abe01..f9c0dbf12e1 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/neontest.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/neontest.c
@@ -83,9 +83,9 @@ wrap(avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt))
     testneonclobbers(avcodec_send_packet, avctx, avpkt);
 }
 
-wrap(avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame))
+wrap(avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt))
 {
-    testneonclobbers(avcodec_receive_frame, avctx, frame);
+    testneonclobbers(avcodec_receive_packet, avctx, avpkt);
 }
 
 wrap(avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame))
@@ -93,7 +93,7 @@ wrap(avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame))
     testneonclobbers(avcodec_send_frame, avctx, frame);
 }
 
-wrap(avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt))
+wrap(avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame))
 {
-    testneonclobbers(avcodec_receive_packet, avctx, avpkt);
+    testneonclobbers(avcodec_receive_frame, avctx, frame);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/pixblockdsp_init_arm.c b/mythtv/external/FFmpeg/libavcodec/arm/pixblockdsp_init_arm.c
index 76d75097286..59d2b493816 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/pixblockdsp_init_arm.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/pixblockdsp_init_arm.c
@@ -24,9 +24,10 @@
 #include "libavcodec/avcodec.h"
 #include "libavcodec/pixblockdsp.h"
 
-void ff_get_pixels_armv6(int16_t *block, const uint8_t *pixels, ptrdiff_t stride);
+void ff_get_pixels_armv6(int16_t *block, const uint8_t *pixels,
+                         ptrdiff_t stride);
 void ff_diff_pixels_armv6(int16_t *block, const uint8_t *s1,
-                          const uint8_t *s2, int stride);
+                          const uint8_t *s2, ptrdiff_t stride);
 
 av_cold void ff_pixblockdsp_init_arm(PixblockDSPContext *c,
                                      AVCodecContext *avctx,
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/rdft_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/rdft_neon.S
index 781d976354f..eabb92b4bdb 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/rdft_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/rdft_neon.S
@@ -30,18 +30,21 @@ function ff_rdft_calc_neon, export=1
 
         lsls            r6,  r6,  #31
         bne             1f
-        add             r0,  r4,  #20
+        add             r0,  r4,  #24
         bl              X(ff_fft_permute_neon)
-        add             r0,  r4,  #20
+        add             r0,  r4,  #24
         mov             r1,  r5
         bl              X(ff_fft_calc_neon)
 1:
         ldr             r12, [r4, #0]           @ nbits
         mov             r2,  #1
+        ldr             r8,  [r4, #20]          @ negative_sin
         lsl             r12, r2,  r12
         add             r0,  r5,  #8
+        lsl             r8,  r8,  #31
         add             r1,  r5,  r12, lsl #2
         lsr             r12, r12, #2
+        vdup.32         d26, r8
         ldr             r2,  [r4, #12]          @ tcos
         sub             r12, r12, #2
         ldr             r3,  [r4, #16]          @ tsin
@@ -55,6 +58,7 @@ function ff_rdft_calc_neon, export=1
         vld1.32         {d5},     [r3,:64]!     @ tsin[i]
         vmov.f32        d18, #0.5               @ k1
         vdup.32         d19, r6
+        veor            d5,  d26, d5
         pld             [r0, #32]
         veor            d19, d18, d19           @ k2
         vmov.i32        d16, #0
@@ -90,6 +94,7 @@ function ff_rdft_calc_neon, export=1
         vld1.32         {d5},     [r3,:64]!     @  tsin[i]
         veor            d24, d22, d17           @  ev.re,-ev.im
         vrev64.32       d3,  d23                @  od.re, od.im
+        veor            d5, d26, d5
         pld             [r2, #32]
         veor            d2,  d3,  d16           @ -od.re, od.im
         pld             [r3, #32]
@@ -140,10 +145,10 @@ function ff_rdft_calc_neon, export=1
 
         vmul.f32        d22, d22, d18
         vst1.32         {d22},    [r5,:64]
-        add             r0,  r4,  #20
+        add             r0,  r4,  #24
         mov             r1,  r5
         bl              X(ff_fft_permute_neon)
-        add             r0,  r4,  #20
+        add             r0,  r4,  #24
         mov             r1,  r5
         pop             {r4-r8,lr}
         b               X(ff_fft_calc_neon)
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_armv5te.S b/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_armv5te.S
index d1f10b75cbc..a8d03469abe 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_armv5te.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_armv5te.S
@@ -148,12 +148,6 @@ endfunc
         ldr    a4, [a1]              /* a4 = col[1:0] */
         mov    ip, #16384
         sub    ip, ip, #1            /* ip = W4 */
-#if 0
-        mov    v1, #(1<<(COL_SHIFT-1))
-        smlabt v2, ip, a4, v1        /* v2 = W4*col[1] + (1<<(COL_SHIFT-1)) */
-        smlabb v1, ip, a4, v1        /* v1 = W4*col[0] + (1<<(COL_SHIFT-1)) */
-        ldr    a4, [a1, #(16*4)]
-#else
         mov    v1, #((1<<(COL_SHIFT-1))/W4) /* this matches the C version */
         add    v2, v1, a4, asr #16
         rsb    v2, v2, v2, lsl #14
@@ -161,7 +155,6 @@ endfunc
         add    v1, v1, a4, asr #16
         ldr    a4, [a1, #(16*4)]
         rsb    v1, v1, v1, lsl #14
-#endif
 
         smulbb lr, ip, a4
         smulbt a3, ip, a4
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_armv6.S b/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_armv6.S
index 79cf5d41fb6..f95c20d2953 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_armv6.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_armv6.S
@@ -390,7 +390,7 @@ function ff_simple_idct_armv6, export=1
         pop    {r4-r11, pc}
 endfunc
 
-/* ff_simple_idct_add_armv6(uint8_t *dest, int line_size, int16_t *data); */
+/* ff_simple_idct_add_armv6(uint8_t *dest, ptrdiff_t line_size, int16_t *data); */
 function ff_simple_idct_add_armv6, export=1
         push   {r0, r1, r4-r11, lr}
         sub    sp, sp, #128
@@ -407,7 +407,7 @@ function ff_simple_idct_add_armv6, export=1
         pop    {r4-r11, pc}
 endfunc
 
-/* ff_simple_idct_put_armv6(uint8_t *dest, int line_size, int16_t *data); */
+/* ff_simple_idct_put_armv6(uint8_t *dest, ptrdiff_t line_size, int16_t *data); */
 function ff_simple_idct_put_armv6, export=1
         push   {r0, r1, r4-r11, lr}
         sub    sp, sp, #128
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_neon.S
index c3e573c00a8..726d4cbefa8 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/simple_idct_neon.S
@@ -261,7 +261,7 @@ endconst
         pop             {r4-r7, pc}
         .endm
 
-/* void ff_simple_idct_put_neon(uint8_t *dst, int line_size, int16_t *data); */
+/* void ff_simple_idct_put_neon(uint8_t *dst, ptrdiff_t line_size, int16_t *data); */
 function ff_simple_idct_put_neon, export=1
         idct_start      r2
 
@@ -316,7 +316,7 @@ function idct_col4_add8_neon
         bx              lr
 endfunc
 
-/* void ff_simple_idct_add_neon(uint8_t *dst, int line_size, int16_t *data); */
+/* void ff_simple_idct_add_neon(uint8_t *dst, ptrdiff_t line_size, int16_t *data); */
 function ff_simple_idct_add_neon, export=1
         idct_start      r2
 
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vc1dsp_init_neon.c b/mythtv/external/FFmpeg/libavcodec/arm/vc1dsp_init_neon.c
index bb873e687e1..005d45ce8f2 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/vc1dsp_init_neon.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vc1dsp_init_neon.c
@@ -25,14 +25,14 @@
 #include "config.h"
 
 void ff_vc1_inv_trans_8x8_neon(int16_t *block);
-void ff_vc1_inv_trans_4x8_neon(uint8_t *dest, int linesize, int16_t *block);
-void ff_vc1_inv_trans_8x4_neon(uint8_t *dest, int linesize, int16_t *block);
-void ff_vc1_inv_trans_4x4_neon(uint8_t *dest, int linesize, int16_t *block);
+void ff_vc1_inv_trans_4x8_neon(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+void ff_vc1_inv_trans_8x4_neon(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+void ff_vc1_inv_trans_4x4_neon(uint8_t *dest, ptrdiff_t stride, int16_t *block);
 
-void ff_vc1_inv_trans_8x8_dc_neon(uint8_t *dest, int linesize, int16_t *block);
-void ff_vc1_inv_trans_4x8_dc_neon(uint8_t *dest, int linesize, int16_t *block);
-void ff_vc1_inv_trans_8x4_dc_neon(uint8_t *dest, int linesize, int16_t *block);
-void ff_vc1_inv_trans_4x4_dc_neon(uint8_t *dest, int linesize, int16_t *block);
+void ff_vc1_inv_trans_8x8_dc_neon(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+void ff_vc1_inv_trans_4x8_dc_neon(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+void ff_vc1_inv_trans_8x4_dc_neon(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+void ff_vc1_inv_trans_4x4_dc_neon(uint8_t *dest, ptrdiff_t stride, int16_t *block);
 
 void ff_put_pixels8x8_neon(uint8_t *block, const uint8_t *pixels,
                            ptrdiff_t line_size, int rnd);
@@ -70,14 +70,14 @@ DECL_PUT(3, 1)
 DECL_PUT(3, 2)
 DECL_PUT(3, 3)
 
-void ff_put_vc1_chroma_mc8_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                int x, int y);
-void ff_avg_vc1_chroma_mc8_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                int x, int y);
-void ff_put_vc1_chroma_mc4_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                int x, int y);
-void ff_avg_vc1_chroma_mc4_neon(uint8_t *dst, uint8_t *src, int stride, int h,
-                                int x, int y);
+void ff_put_vc1_chroma_mc8_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                int h, int x, int y);
+void ff_avg_vc1_chroma_mc8_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                int h, int x, int y);
+void ff_put_vc1_chroma_mc4_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                int h, int x, int y);
+void ff_avg_vc1_chroma_mc4_neon(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
+                                int h, int x, int y);
 
 #define FN_ASSIGN(X, Y) \
     dsp->put_vc1_mspel_pixels_tab[0][X+4*Y] = ff_put_vc1_mspel_mc##X##Y##_16_neon; \
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vc1dsp_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/vc1dsp_neon.S
index c4f4db9c8e6..611cbf2234f 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/vc1dsp_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vc1dsp_neon.S
@@ -426,7 +426,7 @@ function ff_vc1_inv_trans_8x8_neon, export=1
         bx              lr
 endfunc
 
-@ (uint8_t *dest [r0], int linesize [r1], int16_t *block [r2])
+@ (uint8_t *dest [r0], ptrdiff_t stride [r1], int16_t *block [r2])
 function ff_vc1_inv_trans_8x4_neon, export=1
         vld1.64         {q0-q1}, [r2,:128]!     @ load 8 * 4 * 2 = 64 bytes / 16 bytes per quad = 4 quad registers
         vld1.64         {q2-q3}, [r2,:128]
@@ -511,7 +511,7 @@ function ff_vc1_inv_trans_8x4_neon, export=1
         bx              lr
 endfunc
 
-@ (uint8_t *dest [r0], int linesize [r1], int16_t *block [r2])
+@ (uint8_t *dest [r0], ptrdiff_t stride [r1], int16_t *block [r2])
 function ff_vc1_inv_trans_4x8_neon, export=1
         mov             r12, #(8 * 2)  @ 8 elements per line, each element 2 bytes
         vld4.16         {d0[],  d2[],  d4[],  d6[]},  [r2,:64], r12     @ read each column into a q register
@@ -593,7 +593,7 @@ endfunc
         vshr.s16        q1,  q1,  #\rshift      @ dst[3,1] >>= rshift
 .endm
 
-@ (uint8_t *dest [r0], int linesize [r1], int16_t *block [r2])
+@ (uint8_t *dest [r0], ptrdiff_t stride [r1], int16_t *block [r2])
 function ff_vc1_inv_trans_4x4_neon, export=1
         mov             r12, #(8 * 2)  @ 8 elements per line, each element 2 bytes
         vld4.16         {d0[],  d1[],  d2[],  d3[]},  [r2,:64], r12     @ read each column into a register
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp3dsp_init_arm.c b/mythtv/external/FFmpeg/libavcodec/arm/vp3dsp_init_arm.c
index d9246365dfe..65ea53fe0f7 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/vp3dsp_init_arm.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp3dsp_init_arm.c
@@ -23,9 +23,9 @@
 #include "libavutil/arm/cpu.h"
 #include "libavcodec/vp3dsp.h"
 
-void ff_vp3_idct_put_neon(uint8_t *dest, int line_size, int16_t *data);
-void ff_vp3_idct_add_neon(uint8_t *dest, int line_size, int16_t *data);
-void ff_vp3_idct_dc_add_neon(uint8_t *dest, int line_size, int16_t *data);
+void ff_vp3_idct_put_neon(uint8_t *dest, ptrdiff_t stride, int16_t *data);
+void ff_vp3_idct_add_neon(uint8_t *dest, ptrdiff_t stride, int16_t *data);
+void ff_vp3_idct_dc_add_neon(uint8_t *dest, ptrdiff_t stride, int16_t *data);
 
 void ff_vp3_v_loop_filter_neon(uint8_t *, int, int *);
 void ff_vp3_h_loop_filter_neon(uint8_t *, int, int *);
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp6dsp_init_arm.c b/mythtv/external/FFmpeg/libavcodec/arm/vp6dsp_init_arm.c
index ed6832145e4..a59d61278cd 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/vp6dsp_init_arm.c
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp6dsp_init_arm.c
@@ -22,13 +22,13 @@
 
 #include "libavutil/attributes.h"
 #include "libavutil/arm/cpu.h"
-#include "libavcodec/avcodec.h"
+
 #include "libavcodec/vp56dsp.h"
 
-void ff_vp6_edge_filter_hor_neon(uint8_t *yuv, int stride, int t);
-void ff_vp6_edge_filter_ver_neon(uint8_t *yuv, int stride, int t);
+void ff_vp6_edge_filter_hor_neon(uint8_t *yuv, ptrdiff_t stride, int t);
+void ff_vp6_edge_filter_ver_neon(uint8_t *yuv, ptrdiff_t stride, int t);
 
-av_cold void ff_vp6dsp_init_arm(VP56DSPContext *s, enum AVCodecID codec)
+av_cold void ff_vp6dsp_init_arm(VP56DSPContext *s)
 {
     int cpu_flags = av_get_cpu_flags();
 
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp8dsp_armv6.S b/mythtv/external/FFmpeg/libavcodec/arm/vp8dsp_armv6.S
index 1adcbbdbb10..2320bf4d237 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/vp8dsp_armv6.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp8dsp_armv6.S
@@ -192,7 +192,7 @@ function ff_vp8_luma_dc_wht_dc_armv6, export=1
         bx              lr
 endfunc
 
-@ void vp8_idct_add(uint8_t *dst, int16_t block[16], int stride)
+@ void vp8_idct_add(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
 function ff_vp8_idct_add_armv6, export=1
         push            {r4-r12, lr}
         sub             sp,  sp,  #32
@@ -314,7 +314,7 @@ function ff_vp8_idct_add_armv6, export=1
         pop             {r4-r12, pc}
 endfunc
 
-@ void vp8_idct_dc_add(uint8_t *dst, int16_t block[16], int stride)
+@ void vp8_idct_dc_add(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
 function ff_vp8_idct_dc_add_armv6, export=1
         push            {r4-r6, lr}
         add             r6,  r0,  r2,  lsl #1
@@ -355,7 +355,7 @@ function ff_vp8_idct_dc_add_armv6, export=1
         pop             {r4-r6, pc}
 endfunc
 
-@ void vp8_idct_dc_add4uv(uint8_t *dst, int16_t block[4][16], int stride)
+@ void vp8_idct_dc_add4uv(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride)
 function ff_vp8_idct_dc_add4uv_armv6, export=1
         push            {r4, lr}
 
@@ -371,7 +371,7 @@ function ff_vp8_idct_dc_add4uv_armv6, export=1
         pop             {r4, pc}
 endfunc
 
-@ void vp8_idct_dc_add4y(uint8_t *dst, int16_t block[4][16], int stride)
+@ void vp8_idct_dc_add4y(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride)
 function ff_vp8_idct_dc_add4y_armv6, export=1
         push            {r4, lr}
 
@@ -455,7 +455,7 @@ endfunc
         eor             r5,  r5,  r2            @ *oq0 = u ^ 0x80
 .endm
 
-@ void vp8_v_loop_filter16_simple(uint8_t *dst, int stride, int flim)
+@ void vp8_v_loop_filter16_simple(uint8_t *dst, ptrdiff_t stride, int flim)
 function ff_vp8_v_loop_filter16_simple_armv6, export=1
         push            {r4-r11, lr}
 
@@ -866,7 +866,7 @@ function ff_vp8_v_loop_filter8uv_armv6, export=1
         b               vp8_v_loop_filter_armv6
 endfunc
 
-@ void vp8_h_loop_filter16_simple(uint8_t *dst, int stride, int flim)
+@ void vp8_h_loop_filter16_simple(uint8_t *dst, ptrdiff_t stride, int flim)
 function ff_vp8_h_loop_filter16_simple_armv6, export=1
         push            {r4-r11, lr}
         orr             r12, r2,  r2,  lsl #16
@@ -1113,8 +1113,8 @@ endfunc
 
 @ MC
 
-@ void put_vp8_pixels16(uint8_t *dst, int dststride, uint8_t *src,
-@                       int srcstride, int h, int mx, int my)
+@ void put_vp8_pixels16(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+@                       ptrdiff_t srcstride, int h, int mx, int my)
 function ff_put_vp8_pixels16_armv6, export=1
         push            {r4-r11}
         ldr             r12, [sp, #32]          @ h
@@ -1137,8 +1137,8 @@ function ff_put_vp8_pixels16_armv6, export=1
         bx              lr
 endfunc
 
-@ void put_vp8_pixels8(uint8_t *dst, int dststride, uint8_t *src,
-@                      int srcstride, int h, int mx, int my)
+@ void put_vp8_pixels8(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+@                      ptrdiff_t srcstride, int h, int mx, int my)
 function ff_put_vp8_pixels8_armv6, export=1
         push            {r4-r11}
         ldr             r12, [sp, #32]          @ h
@@ -1161,8 +1161,8 @@ function ff_put_vp8_pixels8_armv6, export=1
         bx              lr
 endfunc
 
-@ void put_vp8_pixels4(uint8_t *dst, int dststride, uint8_t *src,
-@                      int srcstride, int h, int mx, int my)
+@ void put_vp8_pixels4(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+@                      ptrdiff_t srcstride, int h, int mx, int my)
 function ff_put_vp8_pixels4_armv6, export=1
         ldr             r12, [sp, #0]           @ h
         push            {r4-r6,lr}
@@ -1181,7 +1181,7 @@ function ff_put_vp8_pixels4_armv6, export=1
 endfunc
 
 @ note: worst case sum of all 6-tap filter values * 255 is 0x7f80 so 16 bit
-@ arithmatic can be used to apply filters
+@ arithmetic can be used to apply filters
 const   sixtap_filters_13245600, align=4
         .short     2, 108, -11,  36,  -8, 1, 0, 0
         .short     3,  77, -16,  77, -16, 3, 0, 0
@@ -1226,13 +1226,8 @@ vp8_mc_1                bilin,  8, v
 vp8_mc_1                bilin,  4, h
 vp8_mc_1                bilin,  4, v
 
-/* True relational expressions have the value -1 in the GNU assembler,
-   +1 in Apple's. */
-#ifdef __APPLE__
-#   define TMPSIZE \size * (8 + 8*(\size > 4) + \ytaps - 1)
-#else
-#   define TMPSIZE \size * (8 - 8*(\size > 4) + \ytaps - 1)
-#endif
+@ 4 and 8 pixel wide mc blocks might have height of 8 or 16 lines
+#define TMPSIZE \size * (16 / ((16 / \size + 1) / 2) + \ytaps - 1)
 
 .macro  vp8_mc_hv       name, size, h, v, ytaps
 function ff_put_vp8_\name\size\()_\h\v\()_armv6, export=1
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp8dsp_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/vp8dsp_neon.S
index 2e87fb0cc72..fcb424881b0 100644
--- a/mythtv/external/FFmpeg/libavcodec/arm/vp8dsp_neon.S
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp8dsp_neon.S
@@ -1562,7 +1562,7 @@ function ff_put_vp8_epel4_h4v4_neon, export=1
 endfunc
 
 @ note: worst case sum of all 6-tap filter values * 255 is 0x7f80 so 16 bit
-@ arithmatic can be used to apply filters
+@ arithmetic can be used to apply filters
 const   subpel_filters, align=4
         .short     0,   6, 123,  12,   1,   0,   0,   0
         .short     2,  11, 108,  36,   8,   1,   0,   0
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init.h b/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init.h
new file mode 100644
index 00000000000..0dc1c2dc209
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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_ARM_VP9DSP_INIT_H
+#define AVCODEC_ARM_VP9DSP_INIT_H
+
+#include "libavcodec/vp9dsp.h"
+
+void ff_vp9dsp_init_10bpp_arm(VP9DSPContext *dsp);
+void ff_vp9dsp_init_12bpp_arm(VP9DSPContext *dsp);
+
+#endif /* AVCODEC_ARM_VP9DSP_INIT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_10bpp_arm.c b/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_10bpp_arm.c
new file mode 100644
index 00000000000..b8cb293b20c
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_10bpp_arm.c
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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
+ */
+
+#define BPP 10
+#define INIT_FUNC ff_vp9dsp_init_10bpp_arm
+#include "vp9dsp_init_16bpp_arm_template.c"
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_12bpp_arm.c b/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_12bpp_arm.c
new file mode 100644
index 00000000000..fa65eb260bc
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_12bpp_arm.c
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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
+ */
+
+#define BPP 12
+#define INIT_FUNC ff_vp9dsp_init_12bpp_arm
+#include "vp9dsp_init_16bpp_arm_template.c"
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_16bpp_arm_template.c b/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_16bpp_arm_template.c
new file mode 100644
index 00000000000..1b0007859d3
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_16bpp_arm_template.c
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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 <stdint.h>
+
+#include "libavutil/attributes.h"
+#include "libavutil/internal.h"
+#include "libavutil/arm/cpu.h"
+#include "vp9dsp_init.h"
+
+#define declare_fpel(type, sz, suffix)                                          \
+void ff_vp9_##type##sz##suffix##_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                                      const uint8_t *src, ptrdiff_t src_stride, \
+                                      int h, int mx, int my)
+
+#define decl_mc_func(op, filter, dir, sz, bpp)                                                   \
+void ff_vp9_##op##_##filter##sz##_##dir##_##bpp##_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                                                       const uint8_t *src, ptrdiff_t src_stride, \
+                                                       int h, int mx, int my)
+
+#define define_8tap_2d_fn(op, filter, sz, bpp)                                      \
+static void op##_##filter##sz##_hv_##bpp##_neon(uint8_t *dst, ptrdiff_t dst_stride, \
+                                                const uint8_t *src,                 \
+                                                ptrdiff_t src_stride,               \
+                                                int h, int mx, int my)              \
+{                                                                                   \
+    LOCAL_ALIGNED_16(uint8_t, temp, [((1 + (sz < 64)) * sz + 8) * sz * 2]);         \
+    /* We only need h + 7 lines, but the horizontal filter assumes an               \
+     * even number of rows, so filter h + 8 lines here. */                          \
+    ff_vp9_put_##filter##sz##_h_##bpp##_neon(temp, 2 * sz,                          \
+                                             src - 3 * src_stride, src_stride,      \
+                                             h + 8, mx, 0);                         \
+    ff_vp9_##op##_##filter##sz##_v_##bpp##_neon(dst, dst_stride,                    \
+                                                temp + 3 * 2 * sz, 2 * sz,          \
+                                                h, 0, my);                          \
+}
+
+#define decl_filter_funcs(op, dir, sz, bpp)  \
+    decl_mc_func(op, regular, dir, sz, bpp); \
+    decl_mc_func(op, sharp,   dir, sz, bpp); \
+    decl_mc_func(op, smooth,  dir, sz, bpp)
+
+#define decl_mc_funcs(sz, bpp)      \
+    decl_filter_funcs(put, h,  sz, bpp); \
+    decl_filter_funcs(avg, h,  sz, bpp); \
+    decl_filter_funcs(put, v,  sz, bpp); \
+    decl_filter_funcs(avg, v,  sz, bpp); \
+    decl_filter_funcs(put, hv, sz, bpp); \
+    decl_filter_funcs(avg, hv, sz, bpp)
+
+declare_fpel(copy, 128, );
+declare_fpel(copy, 64,  );
+declare_fpel(copy, 32,  );
+declare_fpel(copy, 16,  );
+declare_fpel(copy, 8,   );
+declare_fpel(avg, 64, _16);
+declare_fpel(avg, 32, _16);
+declare_fpel(avg, 16, _16);
+declare_fpel(avg, 8,  _16);
+declare_fpel(avg, 4,  _16);
+
+decl_mc_funcs(64, BPP);
+decl_mc_funcs(32, BPP);
+decl_mc_funcs(16, BPP);
+decl_mc_funcs(8,  BPP);
+decl_mc_funcs(4,  BPP);
+
+#define define_8tap_2d_funcs(sz, bpp)        \
+    define_8tap_2d_fn(put, regular, sz, bpp) \
+    define_8tap_2d_fn(put, sharp,   sz, bpp) \
+    define_8tap_2d_fn(put, smooth,  sz, bpp) \
+    define_8tap_2d_fn(avg, regular, sz, bpp) \
+    define_8tap_2d_fn(avg, sharp,   sz, bpp) \
+    define_8tap_2d_fn(avg, smooth,  sz, bpp)
+
+define_8tap_2d_funcs(64, BPP)
+define_8tap_2d_funcs(32, BPP)
+define_8tap_2d_funcs(16, BPP)
+define_8tap_2d_funcs(8,  BPP)
+define_8tap_2d_funcs(4,  BPP)
+
+
+static av_cold void vp9dsp_mc_init_arm(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+#define init_fpel(idx1, idx2, sz, type, suffix)      \
+    dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_8TAP_SHARP  ][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_BILINEAR    ][idx2][0][0] = ff_vp9_##type##sz##suffix##_neon
+
+#define init_copy_avg(idx, sz1, sz2) \
+    init_fpel(idx, 0, sz2, copy, );  \
+    init_fpel(idx, 1, sz1, avg, _16)
+
+#define init_mc_func(idx1, idx2, op, filter, fname, dir, mx, my, sz, pfx, bpp) \
+    dsp->mc[idx1][filter][idx2][mx][my] = pfx##op##_##fname##sz##_##dir##_##bpp##_neon
+
+#define init_mc_funcs(idx, dir, mx, my, sz, pfx, bpp)                                   \
+    init_mc_func(idx, 0, put, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx, bpp); \
+    init_mc_func(idx, 0, put, FILTER_8TAP_SHARP,   sharp,   dir, mx, my, sz, pfx, bpp); \
+    init_mc_func(idx, 0, put, FILTER_8TAP_SMOOTH,  smooth,  dir, mx, my, sz, pfx, bpp); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx, bpp); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_SHARP,   sharp,   dir, mx, my, sz, pfx, bpp); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_SMOOTH,  smooth,  dir, mx, my, sz, pfx, bpp)
+
+#define init_mc_funcs_dirs(idx, sz, bpp)            \
+    init_mc_funcs(idx, h,  1, 0, sz, ff_vp9_, bpp); \
+    init_mc_funcs(idx, v,  0, 1, sz, ff_vp9_, bpp); \
+    init_mc_funcs(idx, hv, 1, 1, sz,        , bpp)
+
+        init_copy_avg(0, 64, 128);
+        init_copy_avg(1, 32, 64);
+        init_copy_avg(2, 16, 32);
+        init_copy_avg(3, 8,  16);
+        init_copy_avg(4, 4,  8);
+
+        init_mc_funcs_dirs(0, 64, BPP);
+        init_mc_funcs_dirs(1, 32, BPP);
+        init_mc_funcs_dirs(2, 16, BPP);
+        init_mc_funcs_dirs(3, 8,  BPP);
+        init_mc_funcs_dirs(4, 4,  BPP);
+    }
+}
+
+#define define_itxfm2(type_a, type_b, sz, bpp)                                     \
+void ff_vp9_##type_a##_##type_b##_##sz##x##sz##_add_##bpp##_neon(uint8_t *_dst,    \
+                                                                 ptrdiff_t stride, \
+                                                                 int16_t *_block, int eob)
+#define define_itxfm(type_a, type_b, sz, bpp) define_itxfm2(type_a, type_b, sz, bpp)
+
+#define define_itxfm_funcs(sz, bpp)      \
+    define_itxfm(idct,  idct,  sz, bpp); \
+    define_itxfm(iadst, idct,  sz, bpp); \
+    define_itxfm(idct,  iadst, sz, bpp); \
+    define_itxfm(iadst, iadst, sz, bpp)
+
+define_itxfm_funcs(4,  BPP);
+define_itxfm_funcs(8,  BPP);
+define_itxfm_funcs(16, BPP);
+define_itxfm(idct, idct, 32, BPP);
+define_itxfm(iwht, iwht, 4,  BPP);
+
+
+static av_cold void vp9dsp_itxfm_init_arm(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+#define init_itxfm2(tx, sz, bpp)                                               \
+    dsp->itxfm_add[tx][DCT_DCT]   = ff_vp9_idct_idct_##sz##_add_##bpp##_neon;  \
+    dsp->itxfm_add[tx][DCT_ADST]  = ff_vp9_iadst_idct_##sz##_add_##bpp##_neon; \
+    dsp->itxfm_add[tx][ADST_DCT]  = ff_vp9_idct_iadst_##sz##_add_##bpp##_neon; \
+    dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_iadst_iadst_##sz##_add_##bpp##_neon
+#define init_itxfm(tx, sz, bpp) init_itxfm2(tx, sz, bpp)
+
+#define init_idct2(tx, nm, bpp)     \
+    dsp->itxfm_add[tx][DCT_DCT]   = \
+    dsp->itxfm_add[tx][ADST_DCT]  = \
+    dsp->itxfm_add[tx][DCT_ADST]  = \
+    dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_##nm##_add_##bpp##_neon
+#define init_idct(tx, nm, bpp) init_idct2(tx, nm, bpp)
+
+        init_itxfm(TX_4X4,   4x4,   BPP);
+        init_itxfm(TX_8X8,   8x8,   BPP);
+        init_itxfm(TX_16X16, 16x16, BPP);
+        init_idct(TX_32X32, idct_idct_32x32, BPP);
+        init_idct(4,        iwht_iwht_4x4,   BPP);
+    }
+}
+
+#define define_loop_filter(dir, wd, size, bpp) \
+void ff_vp9_loop_filter_##dir##_##wd##_##size##_##bpp##_neon(uint8_t *dst, ptrdiff_t stride, int E, int I, int H)
+
+#define define_loop_filters(wd, size, bpp) \
+    define_loop_filter(h, wd, size, bpp);  \
+    define_loop_filter(v, wd, size, bpp)
+
+define_loop_filters(4,  8,  BPP);
+define_loop_filters(8,  8,  BPP);
+define_loop_filters(16, 8,  BPP);
+
+define_loop_filters(16, 16, BPP);
+
+define_loop_filters(44, 16, BPP);
+define_loop_filters(48, 16, BPP);
+define_loop_filters(84, 16, BPP);
+define_loop_filters(88, 16, BPP);
+
+static av_cold void vp9dsp_loopfilter_init_arm(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+#define init_lpf_func_8(idx1, idx2, dir, wd, bpp) \
+    dsp->loop_filter_8[idx1][idx2] = ff_vp9_loop_filter_##dir##_##wd##_8_##bpp##_neon
+
+#define init_lpf_func_16(idx, dir, bpp) \
+    dsp->loop_filter_16[idx] = ff_vp9_loop_filter_##dir##_16_16_##bpp##_neon
+
+#define init_lpf_func_mix2(idx1, idx2, idx3, dir, wd, bpp) \
+    dsp->loop_filter_mix2[idx1][idx2][idx3] = ff_vp9_loop_filter_##dir##_##wd##_16_##bpp##_neon
+
+#define init_lpf_funcs_8_wd(idx, wd, bpp) \
+    init_lpf_func_8(idx, 0, h, wd, bpp);  \
+    init_lpf_func_8(idx, 1, v, wd, bpp)
+
+#define init_lpf_funcs_16(bpp)   \
+    init_lpf_func_16(0, h, bpp); \
+    init_lpf_func_16(1, v, bpp)
+
+#define init_lpf_funcs_mix2_wd(idx1, idx2, wd, bpp) \
+    init_lpf_func_mix2(idx1, idx2, 0, h, wd, bpp);  \
+    init_lpf_func_mix2(idx1, idx2, 1, v, wd, bpp)
+
+#define init_lpf_funcs_8(bpp)        \
+    init_lpf_funcs_8_wd(0, 4,  bpp); \
+    init_lpf_funcs_8_wd(1, 8,  bpp); \
+    init_lpf_funcs_8_wd(2, 16, bpp)
+
+#define init_lpf_funcs_mix2(bpp)           \
+    init_lpf_funcs_mix2_wd(0, 0, 44, bpp); \
+    init_lpf_funcs_mix2_wd(0, 1, 48, bpp); \
+    init_lpf_funcs_mix2_wd(1, 0, 84, bpp); \
+    init_lpf_funcs_mix2_wd(1, 1, 88, bpp)
+
+        init_lpf_funcs_8(BPP);
+        init_lpf_funcs_16(BPP);
+        init_lpf_funcs_mix2(BPP);
+    }
+}
+
+av_cold void INIT_FUNC(VP9DSPContext *dsp)
+{
+    vp9dsp_mc_init_arm(dsp);
+    vp9dsp_loopfilter_init_arm(dsp);
+    vp9dsp_itxfm_init_arm(dsp);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_arm.c b/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_arm.c
new file mode 100644
index 00000000000..cb7f48d5cac
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp9dsp_init_arm.c
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2016 Google Inc.
+ *
+ * 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 <stdint.h>
+
+#include "libavutil/attributes.h"
+#include "libavutil/internal.h"
+#include "libavutil/arm/cpu.h"
+#include "libavcodec/vp9dsp.h"
+#include "vp9dsp_init.h"
+
+#define declare_fpel(type, sz)                                          \
+void ff_vp9_##type##sz##_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                              const uint8_t *src, ptrdiff_t src_stride, \
+                              int h, int mx, int my)
+
+#define declare_copy_avg(sz) \
+    declare_fpel(copy, sz);  \
+    declare_fpel(avg , sz)
+
+#define decl_mc_func(op, filter, dir, sz)                                                \
+void ff_vp9_##op##_##filter##sz##_##dir##_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                                               const uint8_t *src, ptrdiff_t src_stride, \
+                                               int h, int mx, int my)
+
+#define define_8tap_2d_fn(op, filter, sz)                                         \
+static void op##_##filter##sz##_hv_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                                        const uint8_t *src, ptrdiff_t src_stride, \
+                                        int h, int mx, int my)                    \
+{                                                                                 \
+    LOCAL_ALIGNED_16(uint8_t, temp, [((1 + (sz < 64)) * sz + 8) * sz]);           \
+    /* We only need h + 7 lines, but the horizontal filter assumes an             \
+     * even number of rows, so filter h + 8 lines here. */                        \
+    ff_vp9_put_##filter##sz##_h_neon(temp, sz,                                    \
+                                     src - 3 * src_stride, src_stride,            \
+                                     h + 8, mx, 0);                               \
+    ff_vp9_##op##_##filter##sz##_v_neon(dst, dst_stride,                          \
+                                        temp + 3 * sz, sz,                        \
+                                        h, 0, my);                                \
+}
+
+#define decl_filter_funcs(op, dir, sz)  \
+    decl_mc_func(op, regular, dir, sz); \
+    decl_mc_func(op, sharp,   dir, sz); \
+    decl_mc_func(op, smooth,  dir, sz)
+
+#define decl_mc_funcs(sz)           \
+    decl_filter_funcs(put, h,  sz); \
+    decl_filter_funcs(avg, h,  sz); \
+    decl_filter_funcs(put, v,  sz); \
+    decl_filter_funcs(avg, v,  sz); \
+    decl_filter_funcs(put, hv, sz); \
+    decl_filter_funcs(avg, hv, sz)
+
+declare_copy_avg(64);
+declare_copy_avg(32);
+declare_copy_avg(16);
+declare_copy_avg(8);
+declare_copy_avg(4);
+
+decl_mc_funcs(64);
+decl_mc_funcs(32);
+decl_mc_funcs(16);
+decl_mc_funcs(8);
+decl_mc_funcs(4);
+
+#define define_8tap_2d_funcs(sz)        \
+    define_8tap_2d_fn(put, regular, sz) \
+    define_8tap_2d_fn(put, sharp,   sz) \
+    define_8tap_2d_fn(put, smooth,  sz) \
+    define_8tap_2d_fn(avg, regular, sz) \
+    define_8tap_2d_fn(avg, sharp,   sz) \
+    define_8tap_2d_fn(avg, smooth,  sz)
+
+define_8tap_2d_funcs(64)
+define_8tap_2d_funcs(32)
+define_8tap_2d_funcs(16)
+define_8tap_2d_funcs(8)
+define_8tap_2d_funcs(4)
+
+
+static av_cold void vp9dsp_mc_init_arm(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+#define init_fpel(idx1, idx2, sz, type)              \
+    dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_8TAP_SHARP  ][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_BILINEAR    ][idx2][0][0] = ff_vp9_##type##sz##_neon
+
+#define init_copy_avg(idx, sz)   \
+    init_fpel(idx, 0, sz, copy); \
+    init_fpel(idx, 1, sz, avg)
+
+#define init_mc_func(idx1, idx2, op, filter, fname, dir, mx, my, sz, pfx) \
+    dsp->mc[idx1][filter][idx2][mx][my] = pfx##op##_##fname##sz##_##dir##_neon
+
+#define init_mc_funcs(idx, dir, mx, my, sz, pfx)                                   \
+    init_mc_func(idx, 0, put, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 0, put, FILTER_8TAP_SHARP,   sharp,   dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 0, put, FILTER_8TAP_SMOOTH,  smooth,  dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_SHARP,   sharp,   dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_SMOOTH,  smooth,  dir, mx, my, sz, pfx)
+
+#define init_mc_funcs_dirs(idx, sz)            \
+    init_mc_funcs(idx, h,  1, 0, sz, ff_vp9_); \
+    init_mc_funcs(idx, v,  0, 1, sz, ff_vp9_); \
+    init_mc_funcs(idx, hv, 1, 1, sz,)
+
+        init_copy_avg(0, 64);
+        init_copy_avg(1, 32);
+        init_copy_avg(2, 16);
+        init_copy_avg(3, 8);
+        init_copy_avg(4, 4);
+
+        init_mc_funcs_dirs(0, 64);
+        init_mc_funcs_dirs(1, 32);
+        init_mc_funcs_dirs(2, 16);
+        init_mc_funcs_dirs(3, 8);
+        init_mc_funcs_dirs(4, 4);
+    }
+}
+
+#define define_itxfm(type_a, type_b, sz)                                   \
+void ff_vp9_##type_a##_##type_b##_##sz##x##sz##_add_neon(uint8_t *_dst,    \
+                                                         ptrdiff_t stride, \
+                                                         int16_t *_block, int eob)
+
+#define define_itxfm_funcs(sz)      \
+    define_itxfm(idct,  idct,  sz); \
+    define_itxfm(iadst, idct,  sz); \
+    define_itxfm(idct,  iadst, sz); \
+    define_itxfm(iadst, iadst, sz)
+
+define_itxfm_funcs(4);
+define_itxfm_funcs(8);
+define_itxfm_funcs(16);
+define_itxfm(idct, idct, 32);
+define_itxfm(iwht, iwht, 4);
+
+
+static av_cold void vp9dsp_itxfm_init_arm(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+#define init_itxfm(tx, sz)                                             \
+    dsp->itxfm_add[tx][DCT_DCT]   = ff_vp9_idct_idct_##sz##_add_neon;  \
+    dsp->itxfm_add[tx][DCT_ADST]  = ff_vp9_iadst_idct_##sz##_add_neon; \
+    dsp->itxfm_add[tx][ADST_DCT]  = ff_vp9_idct_iadst_##sz##_add_neon; \
+    dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_iadst_iadst_##sz##_add_neon
+
+#define init_idct(tx, nm)           \
+    dsp->itxfm_add[tx][DCT_DCT]   = \
+    dsp->itxfm_add[tx][ADST_DCT]  = \
+    dsp->itxfm_add[tx][DCT_ADST]  = \
+    dsp->itxfm_add[tx][ADST_ADST] = ff_vp9_##nm##_add_neon
+
+        init_itxfm(TX_4X4, 4x4);
+        init_itxfm(TX_8X8, 8x8);
+        init_itxfm(TX_16X16, 16x16);
+        init_idct(TX_32X32, idct_idct_32x32);
+        init_idct(4, iwht_iwht_4x4);
+    }
+}
+
+#define define_loop_filter(dir, wd, size) \
+void ff_vp9_loop_filter_##dir##_##wd##_##size##_neon(uint8_t *dst, ptrdiff_t stride, int E, int I, int H)
+
+#define define_loop_filters(wd, size) \
+    define_loop_filter(h, wd, size);  \
+    define_loop_filter(v, wd, size)
+
+define_loop_filters(4, 8);
+define_loop_filters(8, 8);
+define_loop_filters(16, 8);
+define_loop_filters(16, 16);
+
+define_loop_filters(44, 16);
+
+#define lf_mix_fn(dir, wd1, wd2, stridea)                                                         \
+static void loop_filter_##dir##_##wd1##wd2##_16_neon(uint8_t *dst,                                \
+                                                     ptrdiff_t stride,                            \
+                                                     int E, int I, int H)                         \
+{                                                                                                 \
+    ff_vp9_loop_filter_##dir##_##wd1##_8_neon(dst, stride, E & 0xff, I & 0xff, H & 0xff);         \
+    ff_vp9_loop_filter_##dir##_##wd2##_8_neon(dst + 8 * stridea, stride, E >> 8, I >> 8, H >> 8); \
+}
+
+#define lf_mix_fns(wd1, wd2)       \
+    lf_mix_fn(h, wd1, wd2, stride) \
+    lf_mix_fn(v, wd1, wd2, sizeof(uint8_t))
+
+lf_mix_fns(4, 8)
+lf_mix_fns(8, 4)
+lf_mix_fns(8, 8)
+
+static av_cold void vp9dsp_loopfilter_init_arm(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+        dsp->loop_filter_8[0][1] = ff_vp9_loop_filter_v_4_8_neon;
+        dsp->loop_filter_8[0][0] = ff_vp9_loop_filter_h_4_8_neon;
+        dsp->loop_filter_8[1][1] = ff_vp9_loop_filter_v_8_8_neon;
+        dsp->loop_filter_8[1][0] = ff_vp9_loop_filter_h_8_8_neon;
+        dsp->loop_filter_8[2][1] = ff_vp9_loop_filter_v_16_8_neon;
+        dsp->loop_filter_8[2][0] = ff_vp9_loop_filter_h_16_8_neon;
+
+        dsp->loop_filter_16[0] = ff_vp9_loop_filter_h_16_16_neon;
+        dsp->loop_filter_16[1] = ff_vp9_loop_filter_v_16_16_neon;
+
+        dsp->loop_filter_mix2[0][0][0] = ff_vp9_loop_filter_h_44_16_neon;
+        dsp->loop_filter_mix2[0][0][1] = ff_vp9_loop_filter_v_44_16_neon;
+        dsp->loop_filter_mix2[0][1][0] = loop_filter_h_48_16_neon;
+        dsp->loop_filter_mix2[0][1][1] = loop_filter_v_48_16_neon;
+        dsp->loop_filter_mix2[1][0][0] = loop_filter_h_84_16_neon;
+        dsp->loop_filter_mix2[1][0][1] = loop_filter_v_84_16_neon;
+        dsp->loop_filter_mix2[1][1][0] = loop_filter_h_88_16_neon;
+        dsp->loop_filter_mix2[1][1][1] = loop_filter_v_88_16_neon;
+    }
+}
+
+av_cold void ff_vp9dsp_init_arm(VP9DSPContext *dsp, int bpp)
+{
+    if (bpp == 10) {
+        ff_vp9dsp_init_10bpp_arm(dsp);
+        return;
+    } else if (bpp == 12) {
+        ff_vp9dsp_init_12bpp_arm(dsp);
+        return;
+    } else if (bpp != 8)
+        return;
+
+    vp9dsp_mc_init_arm(dsp);
+    vp9dsp_loopfilter_init_arm(dsp);
+    vp9dsp_itxfm_init_arm(dsp);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp9itxfm_16bpp_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/vp9itxfm_16bpp_neon.S
new file mode 100644
index 00000000000..b4f615ebb81
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp9itxfm_16bpp_neon.S
@@ -0,0 +1,1945 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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/arm/asm.S"
+#include "neon.S"
+
+const itxfm4_coeffs, align=4
+        .short  11585, 0, 6270, 15137
+iadst4_coeffs:
+        .short  5283, 15212, 9929, 13377
+endconst
+
+const iadst8_coeffs, align=4
+        .short  16305, 1606, 14449, 7723, 10394, 12665, 4756, 15679
+idct_coeffs:
+        .short  11585, 0, 6270, 15137, 3196, 16069, 13623, 9102
+        .short  1606, 16305, 12665, 10394, 7723, 14449, 15679, 4756
+        .short  804, 16364, 12140, 11003, 7005, 14811, 15426, 5520
+        .short  3981, 15893, 14053, 8423, 9760, 13160, 16207, 2404
+endconst
+
+const iadst16_coeffs, align=4
+        .short  16364, 804, 15893, 3981, 11003, 12140, 8423, 14053
+        .short  14811, 7005, 13160, 9760, 5520, 15426, 2404, 16207
+endconst
+
+@ Do two 4x4 transposes, using q registers for the subtransposes that don't
+@ need to address the individual d registers.
+@ r0,r1 == rq1, r2,r3 == rq1, etc
+.macro transpose32_q_2x_4x4 rq0, rq1, rq2, rq3, rq4, rq5, rq6, rq7, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15
+        vswp             \r1,  \r4  @ vtrn.64 \rq0, \rq2
+        vswp             \r3,  \r6  @ vtrn.64 \rq1, \rq3
+        vswp             \r9,  \r12 @ vtrn.64 \rq4, \rq6
+        vswp             \r11, \r14 @ vtrn.64 \rq5, \rq7
+        vtrn.32          \rq0, \rq1
+        vtrn.32          \rq2, \rq3
+        vtrn.32          \rq4, \rq5
+        vtrn.32          \rq6, \rq7
+.endm
+
+@ Do eight 2x2 transposes.
+.macro transpose32_8x_2x2 r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15
+        vtrn.32          \r0,  \r1
+        vtrn.32          \r2,  \r3
+        vtrn.32          \r4,  \r5
+        vtrn.32          \r6,  \r7
+        vtrn.32          \r8,  \r9
+        vtrn.32          \r10, \r11
+        vtrn.32          \r12, \r13
+        vtrn.32          \r14, \r15
+.endm
+
+@ out1 = ((in1 + in2) * d0[0] + (1 << 13)) >> 14
+@ out2 = ((in1 - in2) * d0[0] + (1 << 13)) >> 14
+@ in/out are d registers
+.macro mbutterfly0 out1, out2, in1, in2, tmpd1, tmpd2, tmpq3, tmpq4, neg=0
+        vadd.s32        \tmpd1, \in1,  \in2
+        vsub.s32        \tmpd2, \in1,  \in2
+.if \neg > 0
+        vneg.s32        \tmpd1, \tmpd1
+.endif
+        vmull.s32       \tmpq3, \tmpd1, d0[0]
+        vmull.s32       \tmpq4, \tmpd2, d0[0]
+        vrshrn.s64      \out1, \tmpq3, #14
+        vrshrn.s64      \out2, \tmpq4, #14
+.endm
+
+@ Same as mbutterfly0 above, but treating the input in in2 as zero,
+@ writing the same output into both out1 and out2.
+.macro mbutterfly0_h out1, out2, in1, in2, tmpd1, tmpd2, tmpq3, tmpq4
+        vmull.s32       \tmpq3, \in1, d0[0]
+        vrshrn.s64      \out1, \tmpq3, #14
+        vrshrn.s64      \out2, \tmpq3, #14
+.endm
+
+@ out1,out2 = ((in1 + in2) * d0[0] + (1 << 13)) >> 14
+@ out3,out4 = ((in1 - in2) * d0[0] + (1 << 13)) >> 14
+@ Same as mbutterfly0, but with input being 2 q registers, output
+@ being 4 d registers.
+@ This can do with either 4 or 6 temporary q registers.
+.macro dmbutterfly0 out1, out2, out3, out4, in1, in2, tmpq1, tmpq2, tmpd11, tmpd12, tmpd21, tmpd22, tmpq3, tmpq4, tmpq5, tmpq6
+        vadd.s32        \tmpq1, \in1,  \in2
+        vsub.s32        \tmpq2, \in1,  \in2
+        vmull.s32       \tmpq3, \tmpd11, d0[0]
+        vmull.s32       \tmpq4, \tmpd12, d0[0]
+.ifb \tmpq5
+        vrshrn.s64      \out1, \tmpq3, #14
+        vrshrn.s64      \out2, \tmpq4, #14
+        vmull.s32       \tmpq3, \tmpd21, d0[0]
+        vmull.s32       \tmpq4, \tmpd22, d0[0]
+        vrshrn.s64      \out3, \tmpq3, #14
+        vrshrn.s64      \out4, \tmpq4, #14
+.else
+        vmull.s32       \tmpq5, \tmpd21, d0[0]
+        vmull.s32       \tmpq6, \tmpd22, d0[0]
+        vrshrn.s64      \out1, \tmpq3, #14
+        vrshrn.s64      \out2, \tmpq4, #14
+        vrshrn.s64      \out3, \tmpq5, #14
+        vrshrn.s64      \out4, \tmpq6, #14
+.endif
+.endm
+
+@ out1 = in1 * coef1 - in2 * coef2
+@ out2 = in1 * coef2 + in2 * coef1
+@ out are 2 q registers, in are 2 d registers
+.macro mbutterfly_l out1, out2, in1, in2, coef1, coef2, neg=0
+        vmull.s32       \out1, \in1, \coef1
+        vmlsl.s32       \out1, \in2, \coef2
+.if \neg
+        vmov.s64        \out2, #0
+        vmlsl.s32       \out2, \in1, \coef2
+        vmlsl.s32       \out2, \in2, \coef1
+.else
+        vmull.s32       \out2, \in1, \coef2
+        vmlal.s32       \out2, \in2, \coef1
+.endif
+.endm
+
+@ out1,out2 = in1,in2 * coef1 - in3,in4 * coef2
+@ out3,out4 = in1,in2 * coef2 + in3,in4 * coef1
+@ out are 4 q registers, in are 4 d registers
+.macro dmbutterfly_l out1, out2, out3, out4, in1, in2, in3, in4, coef1, coef2
+        vmull.s32       \out1, \in1, \coef1
+        vmull.s32       \out2, \in2, \coef1
+        vmull.s32       \out3, \in1, \coef2
+        vmull.s32       \out4, \in2, \coef2
+        vmlsl.s32       \out1, \in3, \coef2
+        vmlsl.s32       \out2, \in4, \coef2
+        vmlal.s32       \out3, \in3, \coef1
+        vmlal.s32       \out4, \in4, \coef1
+.endm
+
+@ inout1 = (inout1 * coef1 - inout2 * coef2 + (1 << 13)) >> 14
+@ inout2 = (inout1 * coef2 + inout2 * coef1 + (1 << 13)) >> 14
+@ inout are 2 d registers, tmp are 2 q registers
+.macro mbutterfly inout1, inout2, coef1, coef2, tmp1, tmp2, neg=0
+        mbutterfly_l    \tmp1, \tmp2, \inout1, \inout2, \coef1, \coef2, \neg
+        vrshrn.s64      \inout1, \tmp1,  #14
+        vrshrn.s64      \inout2, \tmp2,  #14
+.endm
+
+@ Same as mbutterfly above, but treating the input in inout2 as zero
+.macro mbutterfly_h1 inout1, inout2, coef1, coef2, tmp1, tmp2
+        vmull.s32       \tmp1,   \inout1, \coef1
+        vmull.s32       \tmp2,   \inout1, \coef2
+        vrshrn.s64      \inout1, \tmp1,   #14
+        vrshrn.s64      \inout2, \tmp2,   #14
+.endm
+
+@ Same as mbutterfly above, but treating the input in inout1 as zero
+.macro mbutterfly_h2 inout1, inout2, coef1, coef2, tmp1, tmp2
+        vmov.s64        \tmp1,   #0
+        vmull.s32       \tmp2,   \inout2, \coef1
+        vmlsl.s32       \tmp1,   \inout2, \coef2
+        vrshrn.s64      \inout2, \tmp2,   #14
+        vrshrn.s64      \inout1, \tmp1,   #14
+.endm
+
+@ inout1,inout2 = (inout1,inout2 * coef1 - inout3,inout4 * coef2 + (1 << 13)) >> 14
+@ inout3,inout4 = (inout1,inout2 * coef2 + inout3,inout4 * coef1 + (1 << 13)) >> 14
+@ inout are 4 d registers, tmp are 4 q registers
+.macro dmbutterfly inout1, inout2, inout3, inout4, coef1, coef2, tmp1, tmp2, tmp3, tmp4
+        dmbutterfly_l   \tmp1, \tmp2, \tmp3, \tmp4, \inout1, \inout2, \inout3, \inout4, \coef1, \coef2
+        vrshrn.s64      \inout1, \tmp1,  #14
+        vrshrn.s64      \inout2, \tmp2,  #14
+        vrshrn.s64      \inout3, \tmp3,  #14
+        vrshrn.s64      \inout4, \tmp4,  #14
+.endm
+
+@ out1 = in1 + in2
+@ out2 = in1 - in2
+.macro butterfly out1, out2, in1, in2
+        vadd.s32        \out1, \in1, \in2
+        vsub.s32        \out2, \in1, \in2
+.endm
+
+@ out1 = in1 - in2
+@ out2 = in1 + in2
+.macro butterfly_r out1, out2, in1, in2
+        vsub.s32        \out1, \in1, \in2
+        vadd.s32        \out2, \in1, \in2
+.endm
+
+@ out1 = (in1 + in2 + (1 << 13)) >> 14
+@ out2 = (in1 - in2 + (1 << 13)) >> 14
+@ out are 2 d registers, in are 2 q registers, tmp are 2 q registers
+.macro butterfly_n out1, out2, in1, in2, tmp1, tmp2
+        vadd.s64        \tmp1, \in1, \in2
+        vsub.s64        \tmp2, \in1, \in2
+        vrshrn.s64      \out1, \tmp1,  #14
+        vrshrn.s64      \out2, \tmp2,  #14
+.endm
+
+@ out1,out2 = (in1,in2 + in3,in4 + (1 << 13)) >> 14
+@ out3,out4 = (in1,in2 - in3,in4 + (1 << 13)) >> 14
+@ out are 4 d registers, in are 4 q registers, tmp are 4 q registers
+.macro dbutterfly_n out1, out2, out3, out4, in1, in2, in3, in4, tmp1, tmp2, tmp3, tmp4
+        vadd.s64        \tmp1, \in1, \in3
+        vadd.s64        \tmp2, \in2, \in4
+        vsub.s64        \tmp3, \in1, \in3
+        vsub.s64        \tmp4, \in2, \in4
+        vrshrn.s64      \out1, \tmp1,  #14
+        vrshrn.s64      \out2, \tmp2,  #14
+        vrshrn.s64      \out3, \tmp3,  #14
+        vrshrn.s64      \out4, \tmp4,  #14
+.endm
+
+
+.macro iwht4_10 c0, c1, c2, c3, cd0, cd1, cd2, cd3, cd4, cd5, cd6, cd7
+        vadd.i32        \c0,  \c0,  \c1
+        vsub.i32        q11,  \c2,  \c3
+        vsub.i32        q10,  \c0,  q11
+        vshr.s32        q10,  q10,  #1
+        vsub.i32        \c2,  q10,  \c1
+        vsub.i32        \c1,  q10,  \c3
+        vadd.i32        \c3,  q11,  \c2
+        vsub.i32        \c0,  \c0,  \c1
+.endm
+
+.macro iwht4_12 c0, c1, c2, c3, cd0, cd1, cd2, cd3, cd4, cd5, cd6, cd7
+        iwht4_10        \c0, \c1, \c2, \c3, \cd0, \cd1, \cd2, \cd3, \cd4, \cd5, \cd6, \cd7
+.endm
+
+@ c0 == cd0,cd1, c1 == cd2,cd3
+.macro idct4_10 c0, c1, c2, c3, cd0, cd1, cd2, cd3, cd4, cd5, cd6, cd7
+        vmul.s32        q13,  \c1,  d1[1]
+        vmul.s32        q11,  \c1,  d1[0]
+        vadd.i32        q14,  \c0,  \c2
+        vsub.i32        q15,  \c0,  \c2
+        vmla.s32        q13,  \c3,  d1[0]
+        vmul.s32        q12,  q14,  d0[0]
+        vmul.s32        q10,  q15,  d0[0]
+        vmls.s32        q11,  \c3,  d1[1]
+        vrshr.s32       q13,  q13,  #14
+        vrshr.s32       q12,  q12,  #14
+        vrshr.s32       q10,  q10,  #14
+        vrshr.s32       q11,  q11,  #14
+        vadd.i32        \c0,  q12,  q13
+        vsub.i32        \c3,  q12,  q13
+        vadd.i32        \c1,  q10,  q11
+        vsub.i32        \c2,  q10,  q11
+.endm
+
+.macro idct4_12 c0, c1, c2, c3, cd0, cd1, cd2, cd3, cd4, cd5, cd6, cd7
+        vmull.s32       q13,  \cd2, d1[1]
+        vmull.s32       q15,  \cd3, d1[1]
+        vmull.s32       q11,  \cd2, d1[0]
+        vmull.s32       q3,   \cd3, d1[0]
+        vadd.i32        q14,  \c0,  \c2
+        vsub.i32        q2,   \c0,  \c2
+        vmlal.s32       q13,  \cd6, d1[0]
+        vmlal.s32       q15,  \cd7, d1[0]
+        vmull.s32       q12,  d28,  d0[0]
+        vmull.s32       q14,  d29,  d0[0]
+        vmull.s32       q10,  d4,   d0[0]
+        vmull.s32       q8,   d5,   d0[0]
+        vmlsl.s32       q11,  \cd6, d1[1]
+        vmlsl.s32       q3,   \cd7, d1[1]
+        vrshrn.s64      d26,  q13,  #14
+        vrshrn.s64      d27,  q15,  #14
+        vrshrn.s64      d24,  q12,  #14
+        vrshrn.s64      d25,  q14,  #14
+        vrshrn.s64      d20,  q10,  #14
+        vrshrn.s64      d21,  q8,   #14
+        vrshrn.s64      d22,  q11,  #14
+        vrshrn.s64      d23,  q3,   #14
+        vadd.i32        \c0,  q12,  q13
+        vsub.i32        \c3,  q12,  q13
+        vadd.i32        \c1,  q10,  q11
+        vsub.i32        \c2,  q10,  q11
+.endm
+
+.macro iadst4_10 c0, c1, c2, c3, cd0, cd1, cd2, cd3, cd4, cd5, cd6, cd7
+        vmul.s32        q10,  \c0,  d2[0]
+        vmla.s32        q10,  \c2,  d2[1]
+        vmla.s32        q10,  \c3,  d3[0]
+        vmul.s32        q11,  \c0,  d3[0]
+        vmls.s32        q11,  \c2,  d2[0]
+        vsub.s32        \c0,  \c0,  \c2
+        vmls.s32        q11,  \c3,  d2[1]
+        vadd.s32        \c0,  \c0,  \c3
+        vmul.s32        q13,  \c1,  d3[1]
+        vmul.s32        q12,  \c0,  d3[1]
+        vadd.s32        q14,  q10,  q13
+        vadd.s32        q15,  q11,  q13
+        vrshr.s32       \c0,  q14,  #14
+        vadd.s32        q10,  q10,  q11
+        vrshr.s32       \c1,  q15,  #14
+        vsub.s32        q10,  q10,  q13
+        vrshr.s32       \c2,  q12,  #14
+        vrshr.s32       \c3,  q10,  #14
+.endm
+
+.macro iadst4_12 c0, c1, c2, c3, cd0, cd1, cd2, cd3, cd4, cd5, cd6, cd7
+        vmull.s32       q10,  \cd0, d2[0]
+        vmull.s32       q4,   \cd1, d2[0]
+        vmlal.s32       q10,  \cd4, d2[1]
+        vmlal.s32       q4,   \cd5, d2[1]
+        vmlal.s32       q10,  \cd6, d3[0]
+        vmlal.s32       q4,   \cd7, d3[0]
+        vmull.s32       q11,  \cd0, d3[0]
+        vmull.s32       q5,   \cd1, d3[0]
+        vmlsl.s32       q11,  \cd4, d2[0]
+        vmlsl.s32       q5,   \cd5, d2[0]
+        vsub.s32        \c0,  \c0,  \c2
+        vmlsl.s32       q11,  \cd6, d2[1]
+        vmlsl.s32       q5,   \cd7, d2[1]
+        vadd.s32        \c0,  \c0,  \c3
+        vmull.s32       q13,  \cd2, d3[1]
+        vmull.s32       q6,   \cd3, d3[1]
+        vmull.s32       q12,  \cd0, d3[1]
+        vmull.s32       q7,   \cd1, d3[1]
+        vadd.s64        q14,  q10,  q13
+        vadd.s64        q2,   q4,   q6
+        vadd.s64        q15,  q11,  q13
+        vadd.s64        q3,   q5,   q6
+        vrshrn.s64      \cd1, q2,   #14
+        vrshrn.s64      \cd0, q14,  #14
+        vadd.s64        q10,  q10,  q11
+        vadd.s64        q4,   q4,   q5
+        vrshrn.s64      \cd3, q3,   #14
+        vrshrn.s64      \cd2, q15,  #14
+        vsub.s64        q10,  q10,  q13
+        vsub.s64        q4,   q4,   q6
+        vrshrn.s64      \cd4, q12,  #14
+        vrshrn.s64      \cd5, q7,   #14
+        vrshrn.s64      \cd6, q10,  #14
+        vrshrn.s64      \cd7, q4,   #14
+.endm
+
+@ The public functions in this file have got the following signature:
+@ void itxfm_add(uint8_t *dst, ptrdiff_t stride, int16_t *block, int eob);
+
+.macro itxfm_func4x4 txfm1, txfm2, bpp
+function ff_vp9_\txfm1\()_\txfm2\()_4x4_add_\bpp\()_neon, export=1
+.ifc \txfm1,\txfm2
+.ifc \txfm1,idct
+        movrel          r12, itxfm4_coeffs
+        vld1.16         {d0}, [r12,:64]
+        vmovl.s16       q0,  d0
+.endif
+.ifc \txfm1,iadst
+        movrel          r12, iadst4_coeffs
+        vld1.16         {d1}, [r12,:64]
+        vmovl.s16       q1,  d1
+.endif
+.else
+        movrel          r12, itxfm4_coeffs
+        vld1.16         {q0}, [r12,:128]
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+.endif
+.if \bpp > 10
+.ifnc \txfm1\()_\txfm2,idct_idct
+        @ iadst4_12 needs q4-q7
+        vpush           {q4-q7}
+.endif
+.endif
+
+        vmov.i32        q14, #0
+        vmov.i32        q15, #0
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             r3,  #1
+        bne             1f
+        @ DC-only for idct/idct
+        vld1.32         {d4[]},   [r2,:32]
+        vmull.s32       q2,  d4,  d0[0]
+        vrshrn.s64      d4,  q2,  #14
+        vmull.s32       q2,  d4,  d0[0]
+        vrshrn.s64      d4,  q2,  #14
+        vst1.32         {d30[0]}, [r2,:32]
+        vdup.32         q2,  d4[0]
+        vmov            q3,  q2
+        vmov            q8,  q2
+        vmov            q9,  q2
+        b               2f
+.endif
+
+1:
+        vld1.32         {q2-q3},   [r2,:128]
+        vst1.32         {q14-q15}, [r2,:128]!
+        vld1.32         {q8-q9},   [r2,:128]
+
+.ifc \txfm1,iwht
+        vshr.s32        q2,  q2,  #2
+        vshr.s32        q3,  q3,  #2
+        vshr.s32        q8,  q8,  #2
+        vshr.s32        q9,  q9,  #2
+.endif
+
+        vst1.16         {q14-q15}, [r2,:128]!
+        \txfm1\()4_\bpp q2,  q3,  q8,  q9,  d4,  d5,  d6,  d7,  d16, d17, d18, d19
+
+        @ Transpose 4x4 with 32 bit elements
+        vtrn.32         q2,  q3
+        vtrn.32         q8,  q9
+        vswp            d5,  d16
+        vswp            d7,  d18
+
+        \txfm2\()4_\bpp q2,  q3,  q8,  q9,  d4,  d5,  d6,  d7,  d16, d17, d18, d19
+2:
+        vmvn.u16        q15, #((0xffff << \bpp) & 0xffff)
+        vld1.16         {d0},  [r0,:64], r1
+        vld1.16         {d1},  [r0,:64], r1
+.ifnc \txfm1,iwht
+        vrshr.s32       q2,  q2,  #4
+        vrshr.s32       q3,  q3,  #4
+        vrshr.s32       q8,  q8,  #4
+        vrshr.s32       q9,  q9,  #4
+.endif
+        vaddw.u16       q2,  q2,  d0
+        vaddw.u16       q3,  q3,  d1
+        vld1.16         {d2},  [r0,:64], r1
+        vld1.16         {d3},  [r0,:64], r1
+        vqmovun.s32     d0,  q2
+        vqmovun.s32     d1,  q3
+        sub             r0,  r0,  r1, lsl #2
+
+        vaddw.u16       q8,  q8,  d2
+        vmin.u16        q0,  q0,  q15
+        vaddw.u16       q9,  q9,  d3
+        vst1.16         {d0},  [r0,:64], r1
+        vqmovun.s32     d2,  q8
+        vqmovun.s32     d3,  q9
+        vmin.u16        q1,  q1,  q15
+
+        vst1.16         {d1},  [r0,:64], r1
+        vst1.16         {d2},  [r0,:64], r1
+        vst1.16         {d3},  [r0,:64], r1
+
+.if \bpp > 10
+.ifnc \txfm1\()_\txfm2,idct_idct
+        vpop            {q4-q7}
+.endif
+.endif
+        bx              lr
+endfunc
+.endm
+
+.macro itxfm_funcs4x4 bpp
+itxfm_func4x4 idct,  idct,  \bpp
+itxfm_func4x4 iadst, idct,  \bpp
+itxfm_func4x4 idct,  iadst, \bpp
+itxfm_func4x4 iadst, iadst, \bpp
+itxfm_func4x4 iwht,  iwht,  \bpp
+.endm
+
+itxfm_funcs4x4 10
+itxfm_funcs4x4 12
+
+.macro idct8
+        dmbutterfly0    d16, d17, d24, d25, q8,  q12, q2, q4, d4, d5, d8, d9, q3, q2, q5, q4 @ q8 = t0a, q12 = t1a
+        dmbutterfly     d20, d21, d28, d29, d1[0], d1[1], q2,  q3,  q4,  q5 @ q10 = t2a, q14 = t3a
+        dmbutterfly     d18, d19, d30, d31, d2[0], d2[1], q2,  q3,  q4,  q5 @ q9  = t4a, q15 = t7a
+        dmbutterfly     d26, d27, d22, d23, d3[0], d3[1], q2,  q3,  q4,  q5 @ q13 = t5a, q11 = t6a
+
+        butterfly       q2,  q14, q8,  q14 @ q2 = t0, q14 = t3
+        butterfly       q3,  q10, q12, q10 @ q3 = t1, q10 = t2
+        butterfly       q4,  q13, q9,  q13 @ q4 = t4, q13 = t5a
+        butterfly       q5,  q11, q15, q11 @ q5 = t7, q11 = t6a
+
+        butterfly       q8,  q15, q2,  q5  @ q8 = out[0], q15 = out[7]
+
+        dmbutterfly0    d4,  d5,  d10, d11, q11, q13, q9,  q13, d18, d19, d26, d27, q2,  q5, q11, q12 @ q2 = t6, q5 = t5
+
+        butterfly       q11, q12, q14, q4  @ q11 = out[3], q12 = out[4]
+        butterfly       q9,  q14, q3,  q2  @ q9 = out[1],  q14 = out[6]
+        butterfly_r     q13, q10, q10, q5  @ q13 = out[5], q10 = out[2]
+.endm
+
+.macro iadst8
+        movrel          r12, iadst8_coeffs
+        vld1.16         {q1}, [r12,:128]!
+        vmovl.s16       q0,  d2
+        vmovl.s16       q1,  d3
+
+        dmbutterfly_l   q4,  q5,  q2,  q3,  d30, d31, d16, d17, d0[1], d0[0] @ q4,q5  = t1a, q2,q3 = t0a
+        dmbutterfly_l   q8,  q15, q6,  q7,  d22, d23, d24, d25, d2[1], d2[0] @ q8,q15 = t5a, q6,q7 = t4a
+
+        dbutterfly_n    d22, d23, d4,  d5,  q2,  q3,  q6,  q7,  q11, q12, q2,  q3 @ q11 = t0, q2 = t4
+
+        dbutterfly_n    d24, d25, d6,  d7,  q4,  q5,  q8,  q15, q12, q3,  q6,  q7 @ q12 = t1, q3 = t5
+
+        dmbutterfly_l   q6,  q7,  q4,  q5,  d26, d27, d20, d21, d1[1], d1[0] @ q6,q7 = t3a, q4,q5 = t2a
+        dmbutterfly_l   q10, q13, q8,  q15, d18, d19, d28, d29, d3[1], d3[0] @ q10,q13 = t7a, q8,q15 = t6a
+
+        dbutterfly_n    d18, d19, d8,  d9,  q4,  q5,  q8,  q15, q9,  q14, q4, q5 @ q9 = t2, q4 = t6
+        dbutterfly_n    d16, d17, d12, d13, q6,  q7,  q10, q13, q8,  q15, q6, q7 @ q8 = t3, q6 = t7
+
+        movrel          r12, idct_coeffs
+        vld1.16         {q0}, [r12,:128]
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+
+        butterfly       q15, q12, q12, q8 @ q15 = -out[7], q12 = t3
+        vneg.s32        q15, q15          @ q15 = out[7]
+        butterfly       q8,  q9,  q11, q9 @ q8 = out[0], q9 = t2
+
+        dmbutterfly_l   q10, q11, q5,  q7,  d4,  d5,  d6,  d7,  d1[0], d1[1] @ q10,q11 = t5a, q5,q7 = t4a
+        dmbutterfly_l   q2,  q3,  q13, q14, d12, d13, d8,  d9,  d1[1], d1[0] @ q2,q3 = t6a, q13,q14 = t7a
+
+        dbutterfly_n    d28, d29, d8,  d9,  q10, q11, q13, q14, q4,  q6,  q10, q11 @ q14 = out[6], q4 = t7
+
+        dmbutterfly0    d22, d23, d24, d25, q9,  q12, q6, q13, d12, d13, d26, d27, q9, q10 @ q11 = -out[3], q12 = out[4]
+        vneg.s32        q11, q11      @ q11 = out[3]
+
+        dbutterfly_n    d18, d19, d4,  d5,  q5,  q7,  q2,  q3,  q9, q10, q2,  q3 @ q9 = -out[1], q2 = t6
+        vneg.s32        q9,  q9       @ q9 = out[1]
+
+        dmbutterfly0    d20, d21, d26, d27, q2,  q4,  q3, q5,  d6,  d7,  d10, d11, q6,  q7 @ q10 = out[2], q13 = -out[5]
+        vneg.s32        q13, q13      @ q13 = out[5]
+.endm
+
+function idct8x8_dc_add_neon
+        movrel          r12, idct_coeffs
+        vld1.16         {d0}, [r12,:64]
+
+        vmov.i32        q2,  #0
+        vmovl.s16       q0,  d0
+
+        vld1.32         {d16[]}, [r2,:32]
+        vmull.s32       q8,  d16, d0[0]
+        vrshrn.s64      d16, q8,  #14
+        vmull.s32       q8,  d16, d0[0]
+        vrshrn.s64      d16, q8,  #14
+        vdup.32         q8,  d16[0]
+        vst1.32         {d4[0]}, [r2,:32]
+
+        vrshr.s32       q8,  q8,  #5
+        vdup.s16        q15, r8
+
+        mov             r3,  r0
+        mov             r12, #8
+1:
+        @ Loop to add the constant from q8 into all 8x8 outputs
+        subs            r12, r12, #2
+        vld1.16         {q2},  [r0,:128], r1
+        vaddw.u16       q10, q8,  d4
+        vld1.16         {q3},  [r0,:128], r1
+        vaddw.u16       q11, q8,  d5
+        vaddw.u16       q12, q8,  d6
+        vaddw.u16       q13, q8,  d7
+        vqmovun.s32     d4,  q10
+        vqmovun.s32     d5,  q11
+        vqmovun.s32     d6,  q12
+        vqmovun.s32     d7,  q13
+        vmin.u16        q2,  q2,  q15
+        vst1.16         {q2},  [r3,:128], r1
+        vmin.u16        q3,  q3,  q15
+        vst1.16         {q3},  [r3,:128], r1
+        bne             1b
+
+        pop             {r4-r8,pc}
+endfunc
+.ltorg
+
+.macro itxfm8_1d_funcs txfm
+@ Read a vertical 4x8 slice out of a 8x8 matrix, do a transform on it,
+@ transpose into a horizontal 8x4 slice and store.
+@ r0 = dst (temp buffer)
+@ r1 = slice offset
+@ r2 = src
+function \txfm\()8_1d_4x8_pass1_neon
+        mov             r12, #32
+        vmov.s32        q2,  #0
+.irp i, 8, 9, 10, 11, 12, 13, 14, 15
+        vld1.32         {q\i}, [r2,:128]
+        vst1.32         {q2},  [r2,:128], r12
+.endr
+
+        \txfm\()8
+
+        @ Do two 4x4 transposes. Originally, q8-q15 contain the
+        @ 8 rows. Afterwards, q8-q11, q12-q15 contain the transposed
+        @ 4x4 blocks.
+        transpose32_q_2x_4x4 q8,  q9,  q10, q11, q12, q13, q14, q15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31
+
+        @ Store the transposed 4x4 blocks horizontally.
+        cmp             r1,  #4
+        beq             1f
+.irp i, 8, 12, 9, 13, 10, 14, 11, 15
+        vst1.32         {q\i}, [r0,:128]!
+.endr
+        bx              lr
+1:
+        @ Special case: For the last input column (r1 == 4),
+        @ which would be stored as the last row in the temp buffer,
+        @ don't store the first 4x4 block, but keep it in registers
+        @ for the first slice of the second pass (where it is the
+        @ last 4x4 block).
+.irp i, 12, 13, 14, 15
+        add             r0,  r0,  #16
+        vst1.32         {q\i}, [r0,:128]!
+.endr
+        vmov            q12, q8
+        vmov            q13, q9
+        vmov            q14, q10
+        vmov            q15, q11
+        bx              lr
+endfunc
+
+@ Read a vertical 4x8 slice out of a 8x8 matrix, do a transform on it,
+@ load the destination pixels (from a similar 4x8 slice), add and store back.
+@ r0 = dst
+@ r1 = dst stride
+@ r2 = src (temp buffer)
+@ r3 = slice offset
+function \txfm\()8_1d_4x8_pass2_neon
+        mov             r12, #32
+.irp i, 8, 9, 10, 11
+        vld1.32         {q\i}, [r2,:128], r12
+.endr
+        cmp             r3,  #0
+        beq             1f
+.irp i, 12, 13, 14, 15
+        vld1.32         {q\i}, [r2,:128], r12
+.endr
+1:
+
+        add             r3,  r0,  r1
+        lsl             r1,  r1,  #1
+        \txfm\()8
+
+        vdup.s16        q4,  r8
+.macro load_add_store coef0, coef1, coef2, coef3
+        vld1.16         {d4},   [r0,:64], r1
+        vld1.16         {d5},   [r3,:64], r1
+        vld1.16         {d6},   [r0,:64], r1
+        vld1.16         {d7},   [r3,:64], r1
+
+        vrshr.s32       \coef0, \coef0, #5
+        vrshr.s32       \coef1, \coef1, #5
+        vrshr.s32       \coef2, \coef2, #5
+        vrshr.s32       \coef3, \coef3, #5
+
+        vaddw.u16       \coef0, \coef0, d4
+        vaddw.u16       \coef1, \coef1, d5
+        vaddw.u16       \coef2, \coef2, d6
+        vaddw.u16       \coef3, \coef3, d7
+
+        sub             r0,  r0,  r1, lsl #1
+        sub             r3,  r3,  r1, lsl #1
+
+        vqmovun.s32     d4,  \coef0
+        vqmovun.s32     d5,  \coef1
+        vqmovun.s32     d6,  \coef2
+        vqmovun.s32     d7,  \coef3
+
+        vmin.u16        q2,  q2,  q4
+        vmin.u16        q3,  q3,  q4
+
+        vst1.16         {d4},  [r0,:64], r1
+        vst1.16         {d5},  [r3,:64], r1
+        vst1.16         {d6},  [r0,:64], r1
+        vst1.16         {d7},  [r3,:64], r1
+.endm
+        load_add_store  q8,  q9,  q10, q11
+        load_add_store  q12, q13, q14, q15
+.purgem load_add_store
+
+        bx              lr
+endfunc
+.endm
+
+itxfm8_1d_funcs idct
+itxfm8_1d_funcs iadst
+
+.macro itxfm_func8x8 txfm1, txfm2
+function vp9_\txfm1\()_\txfm2\()_8x8_add_16_neon
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             r3,  #1
+        beq             idct8x8_dc_add_neon
+.endif
+.ifnc \txfm1\()_\txfm2,idct_idct
+        vpush           {q4-q7}
+.else
+        vpush           {q4-q5}
+.endif
+
+        @ Align the stack, allocate a temp buffer
+T       mov             r7,  sp
+T       and             r7,  r7,  #15
+A       and             r7,  sp,  #15
+        add             r7,  r7,  #256
+        sub             sp,  sp,  r7
+
+        mov             r4,  r0
+        mov             r5,  r1
+        mov             r6,  r2
+
+.ifc \txfm1,idct
+        movrel          r12, idct_coeffs
+        vld1.16         {q0}, [r12,:128]
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+.endif
+
+.irp i, 0, 4
+        add             r0,  sp,  #(\i*32)
+.ifc \txfm1\()_\txfm2,idct_idct
+.if \i == 4
+        cmp             r3,  #12
+        ble             1f
+.endif
+.endif
+        mov             r1,  #\i
+        add             r2,  r6,  #(\i*4)
+        bl              \txfm1\()8_1d_4x8_pass1_neon
+.endr
+.ifc \txfm1\()_\txfm2,idct_idct
+        b               3f
+1:
+        @ For all-zero slices in pass 1, set q12-q15 to zero, for the in-register
+        @ passthrough of coefficients to pass 2 and clear the end of the temp buffer
+        vmov.i32        q12, #0
+        vmov.i32        q13, #0
+        vmov.i32        q14, #0
+        vmov.i32        q15, #0
+.rept 4
+        vst1.32         {q12-q13}, [r0,:128]!
+.endr
+3:
+.endif
+.ifc \txfm1\()_\txfm2,iadst_idct
+        movrel          r12, idct_coeffs
+        vld1.16         {q0}, [r12,:128]
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+.endif
+.irp i, 0, 4
+        add             r0,  r4,  #(\i*2)
+        mov             r1,  r5
+        add             r2,  sp,  #(\i*4)
+        mov             r3,  #\i
+        bl              \txfm2\()8_1d_4x8_pass2_neon
+.endr
+
+        add             sp,  sp,  r7
+.ifnc \txfm1\()_\txfm2,idct_idct
+        vpop            {q4-q7}
+.else
+        vpop            {q4-q5}
+.endif
+        pop             {r4-r8,pc}
+endfunc
+
+function ff_vp9_\txfm1\()_\txfm2\()_8x8_add_10_neon, export=1
+        push            {r4-r8,lr}
+        movw            r8,  #0x03ff
+        b               vp9_\txfm1\()_\txfm2\()_8x8_add_16_neon
+endfunc
+
+function ff_vp9_\txfm1\()_\txfm2\()_8x8_add_12_neon, export=1
+        push            {r4-r8,lr}
+        movw            r8,  #0x0fff
+        b               vp9_\txfm1\()_\txfm2\()_8x8_add_16_neon
+endfunc
+.endm
+
+itxfm_func8x8 idct,  idct
+itxfm_func8x8 iadst, idct
+itxfm_func8x8 idct,  iadst
+itxfm_func8x8 iadst, iadst
+
+function idct16x16_dc_add_neon
+        movrel          r12, idct_coeffs
+        vld1.16         {d0}, [r12,:64]
+
+        vmov.i32        q2,  #0
+        vmovl.s16       q0,  d0
+
+        vld1.32         {d16[]}, [r2,:32]
+        vmull.s32       q8,  d16, d0[0]
+        vrshrn.s64      d16, q8,  #14
+        vmull.s32       q8,  d16, d0[0]
+        vrshrn.s64      d16, q8,  #14
+        vdup.32         q8,  d16[0]
+        vst1.32         {d4[0]}, [r2,:32]
+
+        vrshr.s32       q8,  q8,  #6
+        vdup.s16        q15, r9
+
+        mov             r3,  r0
+        mov             r12, #16
+1:
+        @ Loop to add the constant from q8 into all 16x16 outputs
+        subs            r12, r12, #2
+        vld1.16         {q0-q1},  [r0,:128], r1
+        vaddw.u16       q9,  q8,  d0
+        vaddw.u16       q10, q8,  d1
+        vld1.16         {q2-q3},  [r0,:128], r1
+        vaddw.u16       q11, q8,  d2
+        vaddw.u16       q12, q8,  d3
+        vaddw.u16       q13, q8,  d4
+        vaddw.u16       q14, q8,  d5
+        vqmovun.s32     d0,  q9
+        vaddw.u16       q9,  q8,  d6
+        vqmovun.s32     d1,  q10
+        vaddw.u16       q10, q8,  d7
+        vqmovun.s32     d2,  q11
+        vqmovun.s32     d3,  q12
+        vqmovun.s32     d4,  q13
+        vqmovun.s32     d5,  q14
+        vmin.u16        q0,  q0,  q15
+        vmin.u16        q1,  q1,  q15
+        vqmovun.s32     d6,  q9
+        vqmovun.s32     d7,  q10
+        vst1.16         {q0-q1},  [r3,:128], r1
+        vmin.u16        q2,  q2,  q15
+        vmin.u16        q3,  q3,  q15
+        vst1.16         {q2-q3},  [r3,:128], r1
+        bne             1b
+
+        pop             {r4-r9,pc}
+endfunc
+.ltorg
+
+.macro idct16_end
+        butterfly       d18, d11, d8,  d11               @ d18 = t0a,  d11 = t7a
+        butterfly       d19, d22, d9,  d22               @ d19 = t1a,  d22 = t6
+        butterfly       d8,  d26, d20, d26               @ d8  = t2a,  d26 = t5
+        butterfly       d9,  d10, d28, d10               @ d9  = t3a,  d10 = t4
+        butterfly       d20, d28, d16, d24               @ d20 = t8a,  d28 = t11a
+        butterfly       d24, d21, d23, d21               @ d24 = t9,   d21 = t10
+        butterfly       d23, d27, d25, d27               @ d23 = t14,  d27 = t13
+        butterfly       d25, d29, d29, d17               @ d25 = t15a, d29 = t12a
+
+        mbutterfly0     d27, d21, d27, d21, d16, d30, q8, q15 @ d27 = t13a, d21 = t10a
+        mbutterfly0     d29, d28, d29, d28, d16, d30, q8, q15 @ d29 = t12,  d28 = t11
+
+        vswp            d27, d29                         @ d27 = t12, d29 = t13a
+        vswp            d28, d27                         @ d28 = t12, d27 = t11
+        butterfly       d16, d31, d18, d25               @ d16 = out[0], d31 = out[15]
+        butterfly       d17, d30, d19, d23               @ d17 = out[1], d30 = out[14]
+        butterfly_r     d25, d22, d22, d24               @ d25 = out[9], d22 = out[6]
+        butterfly       d23, d24, d11, d20               @ d23 = out[7], d24 = out[8]
+        butterfly       d18, d29, d8,  d29               @ d18 = out[2], d29 = out[13]
+        butterfly       d19, d28, d9,  d28               @ d19 = out[3], d28 = out[12]
+        vmov            d8,  d21                         @ d8  = t10a
+        butterfly       d20, d27, d10, d27               @ d20 = out[4], d27 = out[11]
+        butterfly       d21, d26, d26, d8                @ d21 = out[5], d26 = out[10]
+        bx              lr
+.endm
+
+function idct16
+        mbutterfly0     d16, d24, d16, d24, d8, d10, q4,  q5 @ d16 = t0a,  d24 = t1a
+        mbutterfly      d20, d28, d1[0], d1[1], q4,  q5  @ d20 = t2a,  d28 = t3a
+        mbutterfly      d18, d30, d2[0], d2[1], q4,  q5  @ d18 = t4a,  d30 = t7a
+        mbutterfly      d26, d22, d3[0], d3[1], q4,  q5  @ d26 = t5a,  d22 = t6a
+        mbutterfly      d17, d31, d4[0], d4[1], q4,  q5  @ d17 = t8a,  d31 = t15a
+        mbutterfly      d25, d23, d5[0], d5[1], q4,  q5  @ d25 = t9a,  d23 = t14a
+        mbutterfly      d21, d27, d6[0], d6[1], q4,  q5  @ d21 = t10a, d27 = t13a
+        mbutterfly      d29, d19, d7[0], d7[1], q4,  q5  @ d29 = t11a, d19 = t12a
+
+        butterfly       d8,  d28, d16, d28               @ d8  = t0,   d28 = t3
+        butterfly       d9,  d20, d24, d20               @ d9  = t1,   d20 = t2
+        butterfly       d10, d26, d18, d26               @ d10 = t4,   d26 = t5
+        butterfly       d11, d22, d30, d22               @ d11 = t7,   d22 = t6
+        butterfly       d16, d25, d17, d25               @ d16 = t8,   d25 = t9
+        butterfly       d24, d21, d29, d21               @ d24 = t11,  d21 = t10
+        butterfly       d17, d27, d19, d27               @ d17 = t12,  d27 = t13
+        butterfly       d29, d23, d31, d23               @ d29 = t15,  d23 = t14
+
+        mbutterfly0     d22, d26, d22, d26, d18, d30, q9,  q15  @ d22 = t6a, d26 = t5a
+        mbutterfly      d23, d25, d1[0], d1[1], q9,  q15        @ d23 = t9a,  d25 = t14a
+        mbutterfly      d27, d21, d1[0], d1[1], q9,  q15, neg=1 @ d27 = t13a, d21 = t10a
+        idct16_end
+endfunc
+
+function idct16_half
+        mbutterfly0_h   d16, d24, d16, d24, d8, d10, q4,  q5 @ d16 = t0a,  d24 = t1a
+        mbutterfly_h1   d20, d28, d1[0], d1[1], q4,  q5  @ d20 = t2a,  d28 = t3a
+        mbutterfly_h1   d18, d30, d2[0], d2[1], q4,  q5  @ d18 = t4a,  d30 = t7a
+        mbutterfly_h2   d26, d22, d3[0], d3[1], q4,  q5  @ d26 = t5a,  d22 = t6a
+        mbutterfly_h1   d17, d31, d4[0], d4[1], q4,  q5  @ d17 = t8a,  d31 = t15a
+        mbutterfly_h2   d25, d23, d5[0], d5[1], q4,  q5  @ d25 = t9a,  d23 = t14a
+        mbutterfly_h1   d21, d27, d6[0], d6[1], q4,  q5  @ d21 = t10a, d27 = t13a
+        mbutterfly_h2   d29, d19, d7[0], d7[1], q4,  q5  @ d29 = t11a, d19 = t12a
+
+        butterfly       d8,  d28, d16, d28               @ d8  = t0,   d28 = t3
+        butterfly       d9,  d20, d24, d20               @ d9  = t1,   d20 = t2
+        butterfly       d10, d26, d18, d26               @ d10 = t4,   d26 = t5
+        butterfly       d11, d22, d30, d22               @ d11 = t7,   d22 = t6
+        butterfly       d16, d25, d17, d25               @ d16 = t8,   d25 = t9
+        butterfly       d24, d21, d29, d21               @ d24 = t11,  d21 = t10
+        butterfly       d17, d27, d19, d27               @ d17 = t12,  d27 = t13
+        butterfly       d29, d23, d31, d23               @ d29 = t15,  d23 = t14
+
+        mbutterfly0     d22, d26, d22, d26, d18, d30, q9,  q15  @ d22 = t6a, d26 = t5a
+        mbutterfly      d23, d25, d1[0], d1[1], q9,  q15        @ d23 = t9a,  d25 = t14a
+        mbutterfly      d27, d21, d1[0], d1[1], q9,  q15, neg=1 @ d27 = t13a, d21 = t10a
+        idct16_end
+endfunc
+
+function idct16_quarter
+        vmov.s64        q12, #0
+        vmull.s32       q4,  d17, d4[0]
+        vmull.s32       q5,  d18, d2[1]
+        vmull.s32       q15, d18, d2[0]
+        vmlsl.s32       q12, d19, d7[1]
+        vmull.s32       q14, d17, d4[1]
+        vmull.s32       q13, d19, d7[0]
+        vmull.s32       q11, d16, d0[0]
+        vrshrn.s64      d16, q4,  #14
+        vrshrn.s64      d11, q5,  #14
+        vrshrn.s64      d10, q15, #14
+        vrshrn.s64      d24, q12, #14
+        vrshrn.s64      d29, q14, #14
+        vrshrn.s64      d17, q13, #14
+        vrshrn.s64      d28, q11, #14
+
+        mbutterfly_l    q10, q11, d17, d24, d1[0], d1[1], neg=1
+        mbutterfly_l    q9,  q15, d29, d16, d1[0], d1[1]
+        vrshrn.s64      d27, q10, #14
+        vrshrn.s64      d21, q11, #14
+        vrshrn.s64      d23, q9,  #14
+        vrshrn.s64      d25, q15, #14
+        vmov            d8,  d28
+        vmov            d9,  d28
+        mbutterfly0     d22, d26, d11, d10, d18, d30, q9,  q15
+        vmov            d20, d28
+        idct16_end
+endfunc
+
+function iadst16
+        movrel          r12, iadst16_coeffs
+        vld1.16         {q0},  [r12,:128]!
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+
+        mbutterfly_l    q3,  q2,  d31, d16, d0[1], d0[0] @ q3  = t1,   q2  = t0
+        mbutterfly_l    q5,  q4,  d23, d24, d2[1], d2[0] @ q5  = t9,   q4  = t8
+        butterfly_n     d31, d24, q3,  q5,  q6,  q5      @ d31 = t1a,  d24 = t9a
+        mbutterfly_l    q7,  q6,  d29, d18, d1[1], d1[0] @ q7  = t3,   q6  = t2
+        butterfly_n     d16, d23, q2,  q4,  q3,  q4      @ d16 = t0a,  d23 = t8a
+        mbutterfly_l    q3,  q2,  d21, d26, d3[1], d3[0] @ q3  = t11,  q2  = t10
+
+        vld1.16         {q0},  [r12,:128]!
+        butterfly_n     d29, d26, q7,  q3,  q4,  q3      @ d29 = t3a,  d26 = t11a
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+        mbutterfly_l    q5,  q4,  d27, d20, d0[1], d0[0] @ q5  = t5,   q4  = t4
+        butterfly_n     d18, d21, q6,  q2,  q3,  q2      @ d18 = t2a,  d21 = t10a
+
+        mbutterfly_l    q7,  q6,  d19, d28, d2[1], d2[0] @ q7  = t13,  q6  = t12
+        butterfly_n     d20, d28, q5,  q7,  q2,  q7      @ d20 = t5a,  d28 = t13a
+        mbutterfly_l    q3,  q2,  d25, d22, d1[1], d1[0] @ q3  = t7,   q2  = t6
+        butterfly_n     d27, d19, q4,  q6,  q5,  q6      @ d27 = t4a,  d19 = t12a
+
+        mbutterfly_l    q5,  q4,  d17, d30, d3[1], d3[0] @ q5  = t15,  q4  = t14
+        movrel          r12, idct_coeffs
+        vld1.16         {q0}, [r12,:128]
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+        butterfly_n     d22, d30, q3,  q5,  q6,  q5      @ d22 = t7a,  d30 = t15a
+        mbutterfly_l    q7,  q6,  d23, d24, d2[0], d2[1] @ q7  = t9,   q6  = t8
+        butterfly_n     d25, d17, q2,  q4,  q3,  q4      @ d25 = t6a,  d17 = t14a
+
+        mbutterfly_l    q2,  q3,  d28, d19, d2[1], d2[0] @ q2  = t12,  q3  = t13
+        butterfly_n     d23, d19, q6,  q2,  q4,  q2      @ d23 = t8a,  d19 = t12a
+        mbutterfly_l    q5,  q4,  d21, d26, d3[0], d3[1] @ q5  = t11,  q4  = t10
+        butterfly_r     d4,  d27, d16, d27               @ d4  = t4,   d27 = t0
+        butterfly_n     d24, d28, q7,  q3,  q6,  q3      @ d24 = t9a,  d28 = t13a
+
+        mbutterfly_l    q6,  q7,  d30, d17, d3[1], d3[0] @ q6  = t14,  q7  = t15
+        butterfly_r     d5,  d20, d31, d20               @ d5  = t5,   d20 = t1
+        butterfly_n     d21, d17, q4,  q6,  q3,  q6      @ d21 = t10a, d17 = t14a
+        butterfly_n     d26, d30, q5,  q7,  q4,  q7      @ d26 = t11a, d30 = t15a
+
+        butterfly_r     d6,  d25, d18, d25               @ d6  = t6,   d25 = t2
+        butterfly_r     d7,  d22, d29, d22               @ d7  = t7,   d22 = t3
+
+        mbutterfly_l    q5,  q4,  d19, d28, d1[0], d1[1] @ q5  = t13,  q4  = t12
+        mbutterfly_l    q6,  q7,  d30, d17, d1[1], d1[0] @ q6  = t14,  q7  = t15
+
+        butterfly_n     d18, d30, q4,  q6,  q8,  q6      @ d18 = out[2],   d30 = t14a
+        butterfly_n     d29, d17, q5,  q7,  q6,  q7      @ d29 = -out[13], d17 = t15a
+        vneg.s32        d29, d29                         @ d29 = out[13]
+
+        mbutterfly_l    q5,  q4,  d4,  d5,  d1[0], d1[1] @ q5  = t5a,  q4  = t4a
+        mbutterfly_l    q6,  q7,  d7,  d6,  d1[1], d1[0] @ q6  = t6a,  q7  = t7a
+
+        butterfly       d2,  d6,  d27, d25               @ d2 = out[0], d6 = t2a
+        butterfly       d3,  d7,  d23, d21               @ d3 =-out[1], d7 = t10
+
+        butterfly_n     d19, d31, q4,  q6,  q2,  q4      @ d19 = -out[3],  d31 = t6
+        vneg.s32        d19, d19                         @ d19 = out[3]
+        butterfly_n     d28, d16, q5,  q7,  q2,  q5      @ d28 = out[12],  d16 = t7
+
+        butterfly       d5,  d8,  d20, d22               @ d5 =-out[15],d8 = t3a
+        butterfly       d4,  d9,  d24, d26               @ d4 = out[14],d9 = t11
+
+        mbutterfly0     d23, d24, d6,  d8,  d10, d11, q6,  q7, 1 @ d23 = out[7], d24 = out[8]
+        mbutterfly0     d20, d27, d16, d31, d10, d11, q6,  q7    @ d20 = out[4], d27 = out[11]
+        mbutterfly0     d22, d25, d9,  d7,  d10, d11, q6,  q7    @ d22 = out[6], d25 = out[9]
+        mbutterfly0     d21, d26, d30, d17, d10, d11, q6,  q7, 1 @ d21 = out[5], d26 = out[10]
+
+        vneg.s32        d31, d5                          @ d31 = out[15]
+        vneg.s32        d17, d3                          @ d17 = out[1]
+
+        vmov            d16, d2
+        vmov            d30, d4
+        bx              lr
+endfunc
+
+.macro itxfm16_1d_funcs txfm, suffix
+@ Read a vertical 2x16 slice out of a 16x16 matrix, do a transform on it,
+@ transpose into a horizontal 16x2 slice and store.
+@ r0 = dst (temp buffer)
+@ r2 = src
+function \txfm\()16_1d_2x16_pass1\suffix\()_neon
+        push            {lr}
+
+        mov             r12, #64
+        vmov.s32        q4,  #0
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vld1.32         {d\i}, [r2,:64]
+        vst1.32         {d8},  [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        vld1.32         {d\i}, [r2,:64]
+        vst1.32         {d8},  [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        vld1.32         {d\i}, [r2,:64]
+        vst1.32         {d8},  [r2,:64], r12
+.endr
+.endif
+
+        bl              \txfm\()16\suffix
+
+        @ Do eight 2x2 transposes. Originally, d16-d31 contain the
+        @ 16 rows. Afterwards, d16-d17, d18-d19 etc contain the eight
+        @ transposed 2x2 blocks.
+        transpose32_8x_2x2 d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31
+
+        @ Store the transposed 2x2 blocks horizontally.
+.irp i, 16, 18, 20, 22, 24, 26, 28, 30, 17, 19, 21, 23, 25, 27, 29, 31
+        vst1.32         {d\i}, [r0,:64]!
+.endr
+        pop             {pc}
+endfunc
+
+@ Read a vertical 2x16 slice out of a 16x16 matrix, do a transform on it,
+@ load the destination pixels (from a similar 2x16 slice), add and store back.
+@ r0 = dst
+@ r1 = dst stride
+@ r2 = src (temp buffer)
+function \txfm\()16_1d_2x16_pass2\suffix\()_neon
+        push            {lr}
+
+        mov             r12, #64
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19, 20
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+.endif
+
+        add             r3,  r0,  r1
+        lsl             r1,  r1,  #1
+        bl              \txfm\()16\suffix
+
+.macro load_add_store coef0, coef1, coef2, coef3
+        vrshr.s32       \coef0, \coef0, #6
+        vrshr.s32       \coef1, \coef1, #6
+
+        vld1.32         {d8[]},   [r0,:32], r1
+        vld1.32         {d8[1]},  [r3,:32], r1
+        vrshr.s32       \coef2, \coef2, #6
+        vrshr.s32       \coef3, \coef3, #6
+        vld1.32         {d9[]},   [r0,:32], r1
+        vld1.32         {d9[1]},  [r3,:32], r1
+        vaddw.u16       \coef0, \coef0, d8
+        vld1.32         {d10[]},  [r0,:32], r1
+        vld1.32         {d10[1]}, [r3,:32], r1
+        vaddw.u16       \coef1, \coef1, d9
+        vld1.32         {d11[]},  [r0,:32], r1
+        vld1.32         {d11[1]}, [r3,:32], r1
+
+        vqmovun.s32     d8,  \coef0
+        vdup.s16        q8,  r9
+        vqmovun.s32     d9,  \coef1
+        sub             r0,  r0,  r1, lsl #2
+        sub             r3,  r3,  r1, lsl #2
+        vaddw.u16       \coef2, \coef2, d10
+        vaddw.u16       \coef3, \coef3, d11
+        vmin.u16        q4,  q4,  q8
+        vst1.32         {d8[0]},  [r0,:32], r1
+        vst1.32         {d8[1]},  [r3,:32], r1
+        vqmovun.s32     d10, \coef2
+        vst1.32         {d9[0]},  [r0,:32], r1
+        vst1.32         {d9[1]},  [r3,:32], r1
+        vqmovun.s32     d11, \coef3
+        vmin.u16        q5,  q5,  q8
+
+        vst1.32         {d10[0]}, [r0,:32], r1
+        vst1.32         {d10[1]}, [r3,:32], r1
+        vst1.32         {d11[0]}, [r0,:32], r1
+        vst1.32         {d11[1]}, [r3,:32], r1
+.endm
+        load_add_store  q8,  q9,  q10, q11
+        load_add_store  q12, q13, q14, q15
+.purgem load_add_store
+
+        pop             {pc}
+endfunc
+.endm
+
+itxfm16_1d_funcs idct
+itxfm16_1d_funcs iadst
+itxfm16_1d_funcs idct, _quarter
+itxfm16_1d_funcs idct, _half
+.ltorg
+
+@ This is the minimum eob value for each subpartition, in increments of 2
+const min_eob_idct_idct_16, align=4
+        .short  0, 3, 10, 22, 38, 62, 89, 121
+endconst
+
+.macro itxfm_func16x16 txfm1, txfm2
+function vp9_\txfm1\()_\txfm2\()_16x16_add_16_neon
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             r3,  #1
+        beq             idct16x16_dc_add_neon
+.endif
+.ifnc \txfm1\()_\txfm2,idct_idct
+        vpush           {q4-q7}
+.else
+        vpush           {q4-q5}
+.endif
+
+        @ Align the stack, allocate a temp buffer
+T       mov             r7,  sp
+T       and             r7,  r7,  #15
+A       and             r7,  sp,  #15
+        add             r7,  r7,  #1024
+        sub             sp,  sp,  r7
+
+        mov             r4,  r0
+        mov             r5,  r1
+        mov             r6,  r2
+
+.ifc \txfm1,idct
+        movrel          r12, idct_coeffs
+        vld1.16         {q0-q1}, [r12,:128]
+        vmovl.s16       q2,  d2
+        vmovl.s16       q3,  d3
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+.endif
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             r3,  #10
+        ble             idct16x16_quarter_add_16_neon
+        cmp             r3,  #38
+        ble             idct16x16_half_add_16_neon
+
+        movrel          r8,  min_eob_idct_idct_16 + 2
+.endif
+
+.irp i, 0, 2, 4, 6, 8, 10, 12, 14
+        add             r0,  sp,  #(\i*64)
+.ifc \txfm1\()_\txfm2,idct_idct
+.if \i > 0
+        ldrh_post       r1,  r8,  #2
+        cmp             r3,  r1
+        it              le
+        movle           r1,  #(16 - \i)/2
+        ble             1f
+.endif
+.endif
+        add             r2,  r6,  #(\i*4)
+        bl              \txfm1\()16_1d_2x16_pass1_neon
+.endr
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        b               3f
+1:
+        vmov.i32        q14, #0
+        vmov.i32        q15, #0
+2:
+        subs            r1,  r1,  #1
+        @ Unroll for 2 lines
+.rept 2
+        @ Fill one line with zeros
+        vst1.32         {q14-q15}, [r0,:128]!
+        vst1.32         {q14-q15}, [r0,:128]!
+.endr
+        bne             2b
+3:
+.endif
+
+.ifc \txfm1\()_\txfm2,iadst_idct
+        movrel          r12, idct_coeffs
+        vld1.16         {q0-q1}, [r12,:128]
+        vmovl.s16       q2,  d2
+        vmovl.s16       q3,  d3
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+.endif
+.irp i, 0, 2, 4, 6, 8, 10, 12, 14
+        add             r0,  r4,  #(\i*2)
+        mov             r1,  r5
+        add             r2,  sp,  #(\i*4)
+        bl              \txfm2\()16_1d_2x16_pass2_neon
+.endr
+
+        add             sp,  sp,  r7
+.ifnc \txfm1\()_\txfm2,idct_idct
+        vpop            {q4-q7}
+.else
+        vpop            {q4-q5}
+.endif
+        pop             {r4-r9,pc}
+endfunc
+
+function ff_vp9_\txfm1\()_\txfm2\()_16x16_add_10_neon, export=1
+        push            {r4-r9,lr}
+        movw            r9,  #0x03ff
+        b               vp9_\txfm1\()_\txfm2\()_16x16_add_16_neon
+endfunc
+
+function ff_vp9_\txfm1\()_\txfm2\()_16x16_add_12_neon, export=1
+        push            {r4-r9,lr}
+        movw            r9,  #0x0fff
+        b               vp9_\txfm1\()_\txfm2\()_16x16_add_16_neon
+endfunc
+.endm
+
+itxfm_func16x16 idct,  idct
+itxfm_func16x16 iadst, idct
+itxfm_func16x16 idct,  iadst
+itxfm_func16x16 iadst, iadst
+.ltorg
+
+.macro idct16_partial size
+function idct16x16_\size\()_add_16_neon
+.irp i, 0, 2
+        add             r0,  sp,  #(\i*64)
+.ifc \size,quarter
+.if \i == 2
+        cmp             r3,  #3
+        ble             1f
+.endif
+.endif
+        add             r2,  r6,  #(\i*4)
+        bl              idct16_1d_2x16_pass1_\size\()_neon
+.endr
+
+.ifc \size,half
+.irp i, 4, 6
+        add             r0,  sp,  #(\i*64)
+.if \i == 6
+        cmp             r3,  #22
+        ble             1f
+.endif
+        add             r2,  r6,  #(\i*4)
+        bl              idct16_1d_2x16_pass1_\size\()_neon
+.endr
+.endif
+
+        b               3f
+1:
+        vmov.i32        q14, #0
+        vmov.i32        q15, #0
+
+        @ Unroll for 2 lines
+.rept 2
+        @ Fill one line with zeros
+        vst1.32         {q14-q15}, [r0,:128]!
+        vst1.32         {q14-q15}, [r0,:128]!
+.endr
+
+3:
+
+.irp i, 0, 2, 4, 6, 8, 10, 12, 14
+        add             r0,  r4,  #(\i*2)
+        mov             r1,  r5
+        add             r2,  sp,  #(\i*4)
+        bl              idct16_1d_2x16_pass2_\size\()_neon
+.endr
+
+        add             sp,  sp,  r7
+        vpop            {q4-q5}
+        pop             {r4-r9,pc}
+endfunc
+.endm
+
+idct16_partial quarter
+idct16_partial half
+
+function idct32x32_dc_add_neon
+        movrel          r12, idct_coeffs
+        vld1.16         {d0}, [r12,:64]
+
+        vmov.i32        q2,  #0
+        vmovl.s16       q0,  d0
+
+        vld1.32         {d16[]}, [r2,:32]
+        vmull.s32       q8,  d16, d0[0]
+        vrshrn.s64      d16, q8,  #14
+        vmull.s32       q8,  d16, d0[0]
+        vrshrn.s64      d16, q8,  #14
+        vdup.32         q8,  d16[0]
+        vst1.32         {d4[0]}, [r2,:32]
+
+        vrshr.s32       q8,  q8,  #6
+        vdup.s16        q15, r9
+
+        mov             r3,  r0
+        mov             r12, #32
+        sub             r1,  r1,  #32
+1:
+        @ Loop to add the constant from q8 into all 32x32 outputs
+        subs            r12, r12, #1
+        vld1.16         {q0-q1},  [r0,:128]!
+        vaddw.u16       q9,  q8,  d0
+        vaddw.u16       q10, q8,  d1
+        vld1.16         {q2-q3},  [r0,:128], r1
+        vaddw.u16       q11, q8,  d2
+        vaddw.u16       q12, q8,  d3
+        vaddw.u16       q13, q8,  d4
+        vaddw.u16       q14, q8,  d5
+        vqmovun.s32     d0,  q9
+        vaddw.u16       q9,  q8,  d6
+        vqmovun.s32     d1,  q10
+        vaddw.u16       q10, q8,  d7
+        vqmovun.s32     d2,  q11
+        vqmovun.s32     d3,  q12
+        vqmovun.s32     d4,  q13
+        vqmovun.s32     d5,  q14
+        vmin.u16        q0,  q0,  q15
+        vmin.u16        q1,  q1,  q15
+        vqmovun.s32     d6,  q9
+        vqmovun.s32     d7,  q10
+        vst1.16         {q0-q1},  [r3,:128]!
+        vmin.u16        q2,  q2,  q15
+        vmin.u16        q3,  q3,  q15
+        vst1.16         {q2-q3},  [r3,:128], r1
+        bne             1b
+
+        pop             {r4-r9,pc}
+endfunc
+
+.macro idct32_end
+        butterfly       d16, d9,  d8,  d9  @ d16 = t16a, d9  = t19a
+        butterfly       d17, d20, d23, d20 @ d17 = t17,  d20 = t18
+        butterfly       d18, d10, d11, d10 @ d18 = t23a, d10 = t20a
+        butterfly       d19, d21, d22, d21 @ d19 = t22,  d21 = t21
+        butterfly       d8,  d28, d28, d30 @ d8  = t24a, d28 = t27a
+        butterfly       d23, d26, d25, d26 @ d23 = t25,  d26 = t26
+        butterfly       d11, d29, d29, d31 @ d11 = t31a, d29 = t28a
+        butterfly       d22, d27, d24, d27 @ d22 = t30,  d27 = t29
+
+        mbutterfly      d27, d20, d1[0], d1[1], q12, q15        @ d27 = t18a, d20 = t29a
+        mbutterfly      d29, d9,  d1[0], d1[1], q12, q15        @ d29 = t19,  d9  = t28
+        mbutterfly      d28, d10, d1[0], d1[1], q12, q15, neg=1 @ d28 = t27,  d10 = t20
+        mbutterfly      d26, d21, d1[0], d1[1], q12, q15, neg=1 @ d26 = t26a, d21 = t21a
+
+        butterfly       d31, d24, d11, d8  @ d31 = t31,  d24 = t24
+        butterfly       d30, d25, d22, d23 @ d30 = t30a, d25 = t25a
+        butterfly_r     d23, d16, d16, d18 @ d23 = t23,  d16 = t16
+        butterfly_r     d22, d17, d17, d19 @ d22 = t22a, d17 = t17a
+        butterfly       d18, d21, d27, d21 @ d18 = t18,  d21 = t21
+        butterfly_r     d27, d28, d9,  d28 @ d27 = t27a, d28 = t28a
+        butterfly       d8,  d26, d20, d26 @ d8  = t29,  d26 = t26
+        butterfly       d19, d20, d29, d10 @ d19 = t19a, d20 = t20
+        vmov            d29, d8            @ d29 = t29
+
+        mbutterfly0     d27, d20, d27, d20, d8, d10, q4, q5 @ d27 = t27,  d20 = t20
+        mbutterfly0     d26, d21, d26, d21, d8, d10, q4, q5 @ d26 = t26a, d21 = t21a
+        mbutterfly0     d25, d22, d25, d22, d8, d10, q4, q5 @ d25 = t25,  d22 = t22
+        mbutterfly0     d24, d23, d24, d23, d8, d10, q4, q5 @ d24 = t24a, d23 = t23a
+        bx              lr
+.endm
+
+function idct32_odd
+        movrel          r12, idct_coeffs
+
+        @ Overwrite the idct16 coeffs with the stored ones for idct32
+        vmovl.s16       q0,  d12
+        vmovl.s16       q1,  d13
+        vmovl.s16       q2,  d14
+        vmovl.s16       q3,  d15
+
+        mbutterfly      d16, d31, d0[0], d0[1], q4, q5 @ d16 = t16a, d31 = t31a
+        mbutterfly      d24, d23, d1[0], d1[1], q4, q5 @ d24 = t17a, d23 = t30a
+        mbutterfly      d20, d27, d2[0], d2[1], q4, q5 @ d20 = t18a, d27 = t29a
+        mbutterfly      d28, d19, d3[0], d3[1], q4, q5 @ d28 = t19a, d19 = t28a
+        mbutterfly      d18, d29, d4[0], d4[1], q4, q5 @ d18 = t20a, d29 = t27a
+        mbutterfly      d26, d21, d5[0], d5[1], q4, q5 @ d26 = t21a, d21 = t26a
+        mbutterfly      d22, d25, d6[0], d6[1], q4, q5 @ d22 = t22a, d25 = t25a
+        mbutterfly      d30, d17, d7[0], d7[1], q4, q5 @ d30 = t23a, d17 = t24a
+
+        @ Reload the idct16 coefficients. We could swap the coefficients between
+        @ q0-q3 and q6-q7 by narrowing/lengthening, but that's slower than just
+        @ loading and lengthening.
+        vld1.16         {q0-q1}, [r12,:128]
+
+        butterfly       d8,  d24, d16, d24 @ d8  = t16, d24 = t17
+        butterfly       d9,  d20, d28, d20 @ d9  = t19, d20 = t18
+        butterfly       d10, d26, d18, d26 @ d10 = t20, d26 = t21
+        butterfly       d11, d22, d30, d22 @ d11 = t23, d22 = t22
+        vmovl.s16       q2,  d2
+        vmovl.s16       q3,  d3
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+        butterfly       d28, d25, d17, d25 @ d28 = t24, d25 = t25
+        butterfly       d30, d21, d29, d21 @ d30 = t27, d21 = t26
+        butterfly       d29, d23, d31, d23 @ d29 = t31, d23 = t30
+        butterfly       d31, d27, d19, d27 @ d31 = t28, d27 = t29
+
+        mbutterfly      d23, d24, d2[0], d2[1], q8, q9        @ d23 = t17a, d24 = t30a
+        mbutterfly      d27, d20, d2[0], d2[1], q8, q9, neg=1 @ d27 = t29a, d20 = t18a
+        mbutterfly      d21, d26, d3[0], d3[1], q8, q9        @ d21 = t21a, d26 = t26a
+        mbutterfly      d25, d22, d3[0], d3[1], q8, q9, neg=1 @ d25 = t25a, d22 = t22a
+        idct32_end
+endfunc
+
+function idct32_odd_half
+        movrel          r12, idct_coeffs
+
+        vmovl.s16       q0,  d12
+        vmovl.s16       q1,  d13
+        vmovl.s16       q2,  d14
+        vmovl.s16       q3,  d15
+
+        mbutterfly_h1   d16, d31, d0[0], d0[1], q4, q5 @ d16 = t16a, d31 = t31a
+        mbutterfly_h2   d24, d23, d1[0], d1[1], q4, q5 @ d24 = t17a, d23 = t30a
+        mbutterfly_h1   d20, d27, d2[0], d2[1], q4, q5 @ d20 = t18a, d27 = t29a
+        mbutterfly_h2   d28, d19, d3[0], d3[1], q4, q5 @ d28 = t19a, d19 = t28a
+        mbutterfly_h1   d18, d29, d4[0], d4[1], q4, q5 @ d18 = t20a, d29 = t27a
+        mbutterfly_h2   d26, d21, d5[0], d5[1], q4, q5 @ d26 = t21a, d21 = t26a
+        mbutterfly_h1   d22, d25, d6[0], d6[1], q4, q5 @ d22 = t22a, d25 = t25a
+        mbutterfly_h2   d30, d17, d7[0], d7[1], q4, q5 @ d30 = t23a, d17 = t24a
+
+        vld1.16         {q0-q1}, [r12,:128]
+
+        butterfly       d8,  d24, d16, d24 @ d8  = t16, d24 = t17
+        butterfly       d9,  d20, d28, d20 @ d9  = t19, d20 = t18
+        butterfly       d10, d26, d18, d26 @ d10 = t20, d26 = t21
+        butterfly       d11, d22, d30, d22 @ d11 = t23, d22 = t22
+        vmovl.s16       q2,  d2
+        vmovl.s16       q3,  d3
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+        butterfly       d28, d25, d17, d25 @ d28 = t24, d25 = t25
+        butterfly       d30, d21, d29, d21 @ d30 = t27, d21 = t26
+        butterfly       d29, d23, d31, d23 @ d29 = t31, d23 = t30
+        butterfly       d31, d27, d19, d27 @ d31 = t28, d27 = t29
+
+        mbutterfly      d23, d24, d2[0], d2[1], q8, q9        @ d23 = t17a, d24 = t30a
+        mbutterfly      d27, d20, d2[0], d2[1], q8, q9, neg=1 @ d27 = t29a, d20 = t18a
+        mbutterfly      d21, d26, d3[0], d3[1], q8, q9        @ d21 = t21a, d26 = t26a
+        mbutterfly      d25, d22, d3[0], d3[1], q8, q9, neg=1 @ d25 = t25a, d22 = t22a
+        idct32_end
+endfunc
+
+function idct32_odd_quarter
+        movrel          r12, idct_coeffs
+
+        vmovl.s16       q0,  d12
+        vmovl.s16       q1,  d13
+        vmovl.s16       q2,  d14
+        vmovl.s16       q3,  d15
+
+        vmov.s64        q14, #0
+        vmov.s64        q5,  #0
+
+        vmull.s32       q4,  d16, d0[0]
+        vmlsl.s32       q14, d19, d3[1]
+        vmull.s32       q15, d16, d0[1]
+        vmull.s32       q11, d17, d7[0]
+        vmlsl.s32       q5,  d17, d7[1]
+        vmull.s32       q13, d19, d3[0]
+        vmull.s32       q10, d18, d4[0]
+        vmull.s32       q12, d18, d4[1]
+
+        vld1.16         {q0-q1}, [r12,:128]
+
+        vrshrn.s64      d8,  q4,  #14
+        vrshrn.s64      d9,  q14, #14
+        vrshrn.s64      d29, q15, #14
+        vrshrn.s64      d28, q11, #14
+
+        vmovl.s16       q2,  d2
+        vmovl.s16       q3,  d3
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+
+        vrshrn.s64      d11, q5,  #14
+        vrshrn.s64      d31, q13, #14
+        vrshrn.s64      d10, q10, #14
+        vrshrn.s64      d30, q12, #14
+
+        mbutterfly_l    q8,  q9,  d29, d8,  d2[0], d2[1]
+        mbutterfly_l    q13, q10, d31, d9,  d2[0], d2[1], neg=1
+        vrshrn.s64      d23, q8,  #14
+        vrshrn.s64      d24, q9,  #14
+        vrshrn.s64      d27, q13, #14
+        vrshrn.s64      d20, q10, #14
+        mbutterfly_l    q8,  q9,  d30, d10, d3[0], d3[1]
+        vrshrn.s64      d21, q8,  #14
+        vrshrn.s64      d26, q9,  #14
+        mbutterfly_l    q8,  q9,  d28, d11, d3[0], d3[1], neg=1
+        vrshrn.s64      d25, q8,  #14
+        vrshrn.s64      d22, q9,  #14
+
+        idct32_end
+endfunc
+
+.macro idct32_funcs suffix
+@ Do an 32-point IDCT of a 2x32 slice out of a 32x32 matrix.
+@ We don't have register space to do a single pass IDCT of 2x32 though,
+@ but the 32-point IDCT can be decomposed into two 16-point IDCTs;
+@ a normal IDCT16 with every other input component (the even ones, with
+@ each output written twice), followed by a separate 16-point IDCT
+@ of the odd inputs, added/subtracted onto the outputs of the first idct16.
+@ r0 = dst (temp buffer)
+@ r1 = unused
+@ r2 = src
+function idct32_1d_2x32_pass1\suffix\()_neon
+        push            {lr}
+
+        @ Double stride of the input, since we only read every other line
+        mov             r12, #256
+        vmov.s32        d8,  #0
+
+        @ d16 = IN(0), d17 = IN(2) ... d31 = IN(30)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vld1.32         {d\i}, [r2,:64]
+        vst1.32         {d8},  [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        vld1.32         {d\i}, [r2,:64]
+        vst1.32         {d8},  [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        vld1.32         {d\i}, [r2,:64]
+        vst1.32         {d8},  [r2,:64], r12
+.endr
+.endif
+
+        bl              idct16\suffix
+
+        @ Do eight 2x2 transposes. Originally, d16-d31 contain the
+        @ 16 rows. Afterwards, d16-d17, d18-d19 etc contain the eight
+        @ transposed 2x2 blocks.
+        transpose32_8x_2x2 d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31
+
+        @ Store the registers a, b, c, d, e, f, g, h horizontally, followed
+        @ by the same registers h, g, f, e, d, c, b, a mirrored.
+.macro store_rev a, b, c, d, e, f, g, h
+.irp i, \a, \b, \c, \d, \e, \f, \g, \h
+        vst1.32         {d\i}, [r0,:64]!
+        vrev64.32       d\i, d\i
+.endr
+.irp i, \h, \g, \f, \e, \d, \c, \b, \a
+        vst1.32         {d\i}, [r0,:64]!
+.endr
+.endm
+        store_rev       16, 18, 20, 22, 24, 26, 28, 30
+        store_rev       17, 19, 21, 23, 25, 27, 29, 31
+        sub             r0,  r0,  #256
+.purgem store_rev
+
+        @ Move r2 back to the start of the input, and move
+        @ to the first odd row
+.ifb \suffix
+        sub             r2,  r2,  r12, lsl #4
+.endif
+.ifc \suffix,_quarter
+        sub             r2,  r2,  r12, lsl #2
+.endif
+.ifc \suffix,_half
+        sub             r2,  r2,  r12, lsl #3
+.endif
+        add             r2,  r2,  #128
+
+        vmov.s32        d8,  #0
+        @ d16 = IN(1), d17 = IN(3) ... d31 = IN(31)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d8},  [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d8},  [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d8},  [r2,:64], r12
+.endr
+.endif
+
+        bl              idct32_odd\suffix
+
+        transpose32_8x_2x2 d31, d30, d29, d28, d27, d26, d25, d24, d23, d22, d21, d20, d19, d18, d17, d16
+
+        @ Store the registers a, b, c, d, e, f, g, h horizontally,
+        @ adding into the output first, and then mirrored, subtracted
+        @ from the output.
+.macro store_rev a, b, c, d, e, f, g, h
+.irp i, \a, \b, \c, \d, \e, \f, \g, \h
+        vld1.32         {d8},  [r0,:64]
+        vadd.s32        d8, d8, d\i
+        vst1.32         {d8},  [r0,:64]!
+        vrev64.32       d\i, d\i
+.endr
+.irp i, \h, \g, \f, \e, \d, \c, \b, \a
+        vld1.32         {d8},  [r0,:64]
+        vsub.s32        d8, d8, d\i
+        vst1.32         {d8},  [r0,:64]!
+.endr
+.endm
+
+        store_rev       31, 29, 27, 25, 23, 21, 19, 17
+        store_rev       30, 28, 26, 24, 22, 20, 18, 16
+.purgem store_rev
+        pop             {pc}
+endfunc
+.ltorg
+
+@ This is mostly the same as 2x32_pass1, but without the transpose,
+@ and use the source as temp buffer between the two idct passes, and
+@ add into the destination.
+@ r0 = dst
+@ r1 = dst stride
+@ r2 = src (temp buffer)
+function idct32_1d_2x32_pass2\suffix\()_neon
+        push            {lr}
+
+        mov             r12, #256
+        @ d16 = IN(0), d17 = IN(2) ... d31 = IN(30)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vld1.32         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #4
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        vld1.32         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #2
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        vld1.32         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #3
+.endif
+
+        bl              idct16\suffix
+
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vst1.32         {d\i}, [r2,:64], r12
+.endr
+
+        sub             r2,  r2,  r12, lsl #4
+        add             r2,  r2,  #128
+
+        @ d16 = IN(1), d17 = IN(3) ... d31 = IN(31)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vld1.32         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #4
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        vld1.32         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #2
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        vld1.32         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #3
+.endif
+        sub             r2,  r2,  #128
+
+        bl              idct32_odd\suffix
+
+        @ Narrow the ict16 coefficients in q0-q3 into q0-q1, to
+        @ allow clobbering q2-q3 below.
+        vmovn.s32       d0,  q0
+        vmovn.s32       d1,  q1
+        vmovn.s32       d2,  q2
+        vmovn.s32       d3,  q3
+
+        mov             r12, #256
+        vdup.s16        q4,  r9
+.macro load_acc_store a, b, c, d, neg=0
+        vld1.32         {d4},  [r2,:64], r12
+        vld1.32         {d5},  [r2,:64], r12
+.if \neg == 0
+        vadd.s32        d4,  d4,  d\a
+        vld1.32         {d6},  [r2,:64], r12
+        vadd.s32        d5,  d5,  d\b
+        vld1.32         {d7},  [r2,:64], r12
+        vadd.s32        d6,  d6,  d\c
+        vadd.s32        d7,  d7,  d\d
+.else
+        vsub.s32        d4,  d4,  d\a
+        vld1.32         {d6},  [r2,:64], r12
+        vsub.s32        d5,  d5,  d\b
+        vld1.32         {d7},  [r2,:64], r12
+        vsub.s32        d6,  d6,  d\c
+        vsub.s32        d7,  d7,  d\d
+.endif
+        vld1.32         {d10[]},  [r0,:32], r1
+        vld1.32         {d10[1]}, [r0,:32], r1
+        vrshr.s32       q2,  q2,  #6
+        vld1.32         {d11[]},  [r0,:32], r1
+        vrshr.s32       q3,  q3,  #6
+        vld1.32         {d11[1]}, [r0,:32], r1
+        sub             r0,  r0,  r1, lsl #2
+        vaddw.u16       q2,  q2,  d10
+        vaddw.u16       q3,  q3,  d11
+        vqmovun.s32     d4,  q2
+        vqmovun.s32     d5,  q3
+        vmin.u16        q2,  q2,  q4
+        vst1.32         {d4[0]},  [r0,:32], r1
+        vst1.32         {d4[1]},  [r0,:32], r1
+        vst1.32         {d5[0]},  [r0,:32], r1
+        vst1.32         {d5[1]},  [r0,:32], r1
+.endm
+        load_acc_store  31, 30, 29, 28
+        load_acc_store  27, 26, 25, 24
+        load_acc_store  23, 22, 21, 20
+        load_acc_store  19, 18, 17, 16
+        sub             r2,  r2,  r12
+        neg             r12, r12
+        load_acc_store  16, 17, 18, 19, 1
+        load_acc_store  20, 21, 22, 23, 1
+        load_acc_store  24, 25, 26, 27, 1
+        load_acc_store  28, 29, 30, 31, 1
+.purgem load_acc_store
+        @ Lengthen the idct16 coeffs back into 32 bit form
+        vmovl.s16       q2,  d2
+        vmovl.s16       q3,  d3
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+        pop             {pc}
+endfunc
+.endm
+
+idct32_funcs
+idct32_funcs _quarter
+idct32_funcs _half
+
+const min_eob_idct_idct_32, align=4
+        .short  0, 3, 9, 21, 34, 51, 70, 98, 135, 176, 240, 258, 336, 357, 448, 472
+endconst
+
+function vp9_idct_idct_32x32_add_16_neon
+        cmp             r3,  #1
+        beq             idct32x32_dc_add_neon
+        vpush           {q4-q7}
+        movrel          r8,  min_eob_idct_idct_32 + 2
+
+        @ Align the stack, allocate a temp buffer
+T       mov             r7,  sp
+T       and             r7,  r7,  #15
+A       and             r7,  sp,  #15
+        add             r7,  r7,  #4096
+        sub             sp,  sp,  r7
+
+        mov             r4,  r0
+        mov             r5,  r1
+        mov             r6,  r2
+
+        movrel          r12, idct_coeffs
+        vld1.16         {q0-q1}, [r12,:128]!
+        vld1.16         {q6-q7}, [r12,:128]
+        vmovl.s16       q2,  d2
+        vmovl.s16       q3,  d3
+        vmovl.s16       q1,  d1
+        vmovl.s16       q0,  d0
+
+        cmp             r3,  #34
+        ble             idct32x32_quarter_add_16_neon
+        cmp             r3,  #135
+        ble             idct32x32_half_add_16_neon
+
+.irp i, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30
+        add             r0,  sp,  #(\i*128)
+.if \i > 0
+        ldrh_post       r1,  r8,  #2
+        cmp             r3,  r1
+        it              le
+        movle           r1,  #(32 - \i)/2
+        ble             1f
+.endif
+        add             r2,  r6,  #(\i*4)
+        bl              idct32_1d_2x32_pass1_neon
+.endr
+        b               3f
+
+1:
+        @ Write zeros to the temp buffer for pass 2
+        vmov.i16        q14, #0
+        vmov.i16        q15, #0
+2:
+        subs            r1,  r1,  #1
+.rept 2
+        @ Fill one line with zeros
+        vst1.16         {q14-q15}, [r0,:128]!
+        vst1.16         {q14-q15}, [r0,:128]!
+        vst1.16         {q14-q15}, [r0,:128]!
+        vst1.16         {q14-q15}, [r0,:128]!
+.endr
+        bne             2b
+3:
+.irp i, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30
+        add             r0,  r4,  #(\i*2)
+        mov             r1,  r5
+        add             r2,  sp,  #(\i*4)
+        bl              idct32_1d_2x32_pass2_neon
+.endr
+
+        add             sp,  sp,  r7
+        vpop            {q4-q7}
+        pop             {r4-r9,pc}
+endfunc
+
+function ff_vp9_idct_idct_32x32_add_10_neon, export=1
+        push            {r4-r9,lr}
+        movw            r9,  #0x03ff
+        b               vp9_idct_idct_32x32_add_16_neon
+endfunc
+
+function ff_vp9_idct_idct_32x32_add_12_neon, export=1
+        push            {r4-r9,lr}
+        movw            r9,  #0x0fff
+        b               vp9_idct_idct_32x32_add_16_neon
+endfunc
+
+.macro idct32_partial size, rows
+function idct32x32_\size\()_add_16_neon
+.irp i, 0, 2, 4, 6
+        add             r0,  sp,  #(\i*128)
+.ifc \size,quarter
+.if \i > 0
+        ldrh_post       r1,  r8,  #2
+        cmp             r3,  r1
+        it              le
+        movle           r1,  #(\rows - \i)/2
+        ble             1f
+.endif
+.endif
+        add             r2,  r6,  #(\i*4)
+        bl              idct32_1d_2x32_pass1_\size\()_neon
+.endr
+.ifc \size,half
+        add             r8,  r8,  #8
+.irp i, 8, 10, 12, 14
+        add             r0,  sp,  #(\i*128)
+.if \i > 8
+        ldrh_post       r1,  r8,  #2
+        cmp             r3,  r1
+        it              le
+        movle           r1,  #(\rows - \i)/2
+        ble             1f
+.endif
+        add             r2,  r6,  #(\i*4)
+        bl              idct32_1d_2x32_pass1_\size\()_neon
+.endr
+.endif
+        b               3f
+
+1:
+        @ Write zeros to the temp buffer for pass 2
+        vmov.i16        q14, #0
+        vmov.i16        q15, #0
+2:
+        subs            r1,  r1,  #1
+.rept 2
+        @ Fill one line with zeros
+        vst1.16         {q14-q15}, [r0,:128]!
+        vst1.16         {q14-q15}, [r0,:128]!
+        vst1.16         {q14-q15}, [r0,:128]!
+        vst1.16         {q14-q15}, [r0,:128]!
+.endr
+        bne             2b
+3:
+.irp i, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30
+        add             r0,  r4,  #(\i*2)
+        mov             r1,  r5
+        add             r2,  sp,  #(\i*4)
+        bl              idct32_1d_2x32_pass2_\size\()_neon
+.endr
+
+        add             sp,  sp,  r7
+        vpop            {q4-q7}
+        pop             {r4-r9,pc}
+endfunc
+.endm
+
+idct32_partial quarter, 8
+idct32_partial half, 16
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp9itxfm_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/vp9itxfm_neon.S
new file mode 100644
index 00000000000..6c09922caee
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp9itxfm_neon.S
@@ -0,0 +1,1688 @@
+/*
+ * Copyright (c) 2016 Google Inc.
+ *
+ * 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/arm/asm.S"
+#include "neon.S"
+
+const itxfm4_coeffs, align=4
+        .short  11585, 0, 6270, 15137
+iadst4_coeffs:
+        .short  5283, 15212, 9929, 13377
+endconst
+
+const iadst8_coeffs, align=4
+        .short  16305, 1606, 14449, 7723, 10394, 12665, 4756, 15679
+idct_coeffs:
+        .short  11585, 0, 6270, 15137, 3196, 16069, 13623, 9102
+        .short  1606, 16305, 12665, 10394, 7723, 14449, 15679, 4756
+        .short  804, 16364, 12140, 11003, 7005, 14811, 15426, 5520
+        .short  3981, 15893, 14053, 8423, 9760, 13160, 16207, 2404
+endconst
+
+const iadst16_coeffs, align=4
+        .short  16364, 804, 15893, 3981, 11003, 12140, 8423, 14053
+        .short  14811, 7005, 13160, 9760, 5520, 15426, 2404, 16207
+endconst
+
+@ Do four 4x4 transposes, using q registers for the subtransposes that don't
+@ need to address the individual d registers.
+@ r0,r1 == rq1, r2,r3 == rq1, etc
+.macro transpose16_q_4x_4x4 rq0, rq1, rq2, rq3, rq4, rq5, rq6, rq7, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15
+        vtrn.32          \rq0, \rq1
+        vtrn.32          \rq2, \rq3
+        vtrn.32          \rq4, \rq5
+        vtrn.32          \rq6, \rq7
+        vtrn.16          \r0,  \r1
+        vtrn.16          \r2,  \r3
+        vtrn.16          \r4,  \r5
+        vtrn.16          \r6,  \r7
+        vtrn.16          \r8,  \r9
+        vtrn.16          \r10, \r11
+        vtrn.16          \r12, \r13
+        vtrn.16          \r14, \r15
+.endm
+
+@ out1 = ((in1 + in2) * d0[0] + (1 << 13)) >> 14
+@ out2 = ((in1 - in2) * d0[0] + (1 << 13)) >> 14
+@ in/out are d registers
+.macro mbutterfly0 out1, out2, in1, in2, tmpd1, tmpd2, tmpq3, tmpq4, neg=0
+        vadd.s16        \tmpd1, \in1,  \in2
+        vsub.s16        \tmpd2, \in1,  \in2
+        vmull.s16       \tmpq3, \tmpd1, d0[0]
+        vmull.s16       \tmpq4, \tmpd2, d0[0]
+.if \neg > 0
+        vneg.s32        \tmpq3, \tmpq3
+.endif
+        vrshrn.s32      \out1, \tmpq3, #14
+        vrshrn.s32      \out2, \tmpq4, #14
+.endm
+
+@ Same as mbutterfly0 above, but treating the input in in2 as zero,
+@ writing the same output into both out1 and out2.
+.macro mbutterfly0_h out1, out2, in1, in2, tmpd1, tmpd2, tmpq3, tmpq4
+        vmull.s16       \tmpq3, \in1, d0[0]
+        vrshrn.s32      \out1,  \tmpq3, #14
+        vrshrn.s32      \out2,  \tmpq3, #14
+.endm
+
+@ out1,out2 = ((in1 + in2) * d0[0] + (1 << 13)) >> 14
+@ out3,out4 = ((in1 - in2) * d0[0] + (1 << 13)) >> 14
+@ Same as mbutterfly0, but with input being 2 q registers, output
+@ being 4 d registers.
+@ This can do with either 4 or 6 temporary q registers.
+.macro dmbutterfly0 out1, out2, out3, out4, in1, in2, tmpq1, tmpq2, tmpd11, tmpd12, tmpd21, tmpd22, tmpq3, tmpq4, tmpq5, tmpq6
+        vadd.s16        \tmpq1, \in1,  \in2
+        vsub.s16        \tmpq2, \in1,  \in2
+        vmull.s16       \tmpq3, \tmpd11, d0[0]
+        vmull.s16       \tmpq4, \tmpd12, d0[0]
+.ifb \tmpq5
+        vrshrn.s32      \out1, \tmpq3, #14
+        vrshrn.s32      \out2, \tmpq4, #14
+        vmull.s16       \tmpq3, \tmpd21, d0[0]
+        vmull.s16       \tmpq4, \tmpd22, d0[0]
+        vrshrn.s32      \out3, \tmpq3, #14
+        vrshrn.s32      \out4, \tmpq4, #14
+.else
+        vmull.s16       \tmpq5, \tmpd21, d0[0]
+        vmull.s16       \tmpq6, \tmpd22, d0[0]
+        vrshrn.s32      \out1, \tmpq3, #14
+        vrshrn.s32      \out2, \tmpq4, #14
+        vrshrn.s32      \out3, \tmpq5, #14
+        vrshrn.s32      \out4, \tmpq6, #14
+.endif
+.endm
+
+@ out1 = in1 * coef1 - in2 * coef2
+@ out2 = in1 * coef2 + in2 * coef1
+@ out are 2 q registers, in are 2 d registers
+.macro mbutterfly_l out1, out2, in1, in2, coef1, coef2
+        vmull.s16       \out1, \in1, \coef1
+        vmlsl.s16       \out1, \in2, \coef2
+        vmull.s16       \out2, \in1, \coef2
+        vmlal.s16       \out2, \in2, \coef1
+.endm
+
+@ out1,out2 = in1,in2 * coef1 - in3,in4 * coef2
+@ out3,out4 = in1,in2 * coef2 + in3,in4 * coef1
+@ out are 4 q registers, in are 4 d registers
+.macro dmbutterfly_l out1, out2, out3, out4, in1, in2, in3, in4, coef1, coef2
+        vmull.s16       \out1, \in1, \coef1
+        vmull.s16       \out2, \in2, \coef1
+        vmull.s16       \out3, \in1, \coef2
+        vmull.s16       \out4, \in2, \coef2
+        vmlsl.s16       \out1, \in3, \coef2
+        vmlsl.s16       \out2, \in4, \coef2
+        vmlal.s16       \out3, \in3, \coef1
+        vmlal.s16       \out4, \in4, \coef1
+.endm
+
+@ inout1 = (inout1 * coef1 - inout2 * coef2 + (1 << 13)) >> 14
+@ inout2 = (inout1 * coef2 + inout2 * coef1 + (1 << 13)) >> 14
+@ inout are 2 d registers, tmp are 2 q registers
+.macro mbutterfly inout1, inout2, coef1, coef2, tmp1, tmp2, neg=0
+        mbutterfly_l    \tmp1, \tmp2, \inout1, \inout2, \coef1, \coef2
+.if \neg > 0
+        vneg.s32        \tmp2, \tmp2
+.endif
+        vrshrn.s32      \inout1, \tmp1,  #14
+        vrshrn.s32      \inout2, \tmp2,  #14
+.endm
+
+@ Same as mbutterfly above, but treating the input in inout2 as zero
+.macro mbutterfly_h1 inout1, inout2, coef1, coef2, tmp1, tmp2
+        vmull.s16       \tmp1,   \inout1, \coef1
+        vmull.s16       \tmp2,   \inout1, \coef2
+        vrshrn.s32      \inout1, \tmp1,   #14
+        vrshrn.s32      \inout2, \tmp2,   #14
+.endm
+
+@ Same as mbutterfly above, but treating the input in inout1 as zero
+.macro mbutterfly_h2 inout1, inout2, coef1, coef2, tmp1, tmp2
+        vmull.s16       \tmp1,   \inout2, \coef2
+        vmull.s16       \tmp2,   \inout2, \coef1
+        vneg.s32        \tmp1,   \tmp1
+        vrshrn.s32      \inout2, \tmp2,   #14
+        vrshrn.s32      \inout1, \tmp1,   #14
+.endm
+
+@ inout1,inout2 = (inout1,inout2 * coef1 - inout3,inout4 * coef2 + (1 << 13)) >> 14
+@ inout3,inout4 = (inout1,inout2 * coef2 + inout3,inout4 * coef1 + (1 << 13)) >> 14
+@ inout are 4 d registers, tmp are 4 q registers
+.macro dmbutterfly inout1, inout2, inout3, inout4, coef1, coef2, tmp1, tmp2, tmp3, tmp4
+        dmbutterfly_l   \tmp1, \tmp2, \tmp3, \tmp4, \inout1, \inout2, \inout3, \inout4, \coef1, \coef2
+        vrshrn.s32      \inout1, \tmp1,  #14
+        vrshrn.s32      \inout2, \tmp2,  #14
+        vrshrn.s32      \inout3, \tmp3,  #14
+        vrshrn.s32      \inout4, \tmp4,  #14
+.endm
+
+@ out1 = in1 + in2
+@ out2 = in1 - in2
+.macro butterfly out1, out2, in1, in2
+        vadd.s16        \out1, \in1, \in2
+        vsub.s16        \out2, \in1, \in2
+.endm
+
+@ out1 = in1 - in2
+@ out2 = in1 + in2
+.macro butterfly_r out1, out2, in1, in2
+        vsub.s16        \out1, \in1, \in2
+        vadd.s16        \out2, \in1, \in2
+.endm
+
+@ out1 = (in1 + in2 + (1 << 13)) >> 14
+@ out2 = (in1 - in2 + (1 << 13)) >> 14
+@ out are 2 d registers, in are 2 q registers, tmp are 2 q registers
+.macro butterfly_n out1, out2, in1, in2, tmp1, tmp2
+        vadd.s32        \tmp1, \in1, \in2
+        vsub.s32        \tmp2, \in1, \in2
+        vrshrn.s32      \out1, \tmp1,  #14
+        vrshrn.s32      \out2, \tmp2,  #14
+.endm
+
+@ out1,out2 = (in1,in2 + in3,in4 + (1 << 13)) >> 14
+@ out3,out4 = (in1,in2 - in3,in4 + (1 << 13)) >> 14
+@ out are 4 d registers, in are 4 q registers, tmp are 4 q registers
+.macro dbutterfly_n out1, out2, out3, out4, in1, in2, in3, in4, tmp1, tmp2, tmp3, tmp4
+        vadd.s32        \tmp1, \in1, \in3
+        vadd.s32        \tmp2, \in2, \in4
+        vsub.s32        \tmp3, \in1, \in3
+        vsub.s32        \tmp4, \in2, \in4
+        vrshrn.s32      \out1, \tmp1,  #14
+        vrshrn.s32      \out2, \tmp2,  #14
+        vrshrn.s32      \out3, \tmp3,  #14
+        vrshrn.s32      \out4, \tmp4,  #14
+.endm
+
+
+.macro iwht4 c0, c1, c2, c3
+        vadd.i16        \c0,  \c0,  \c1
+        vsub.i16        d17,  \c2,  \c3
+        vsub.i16        d16,  \c0,  d17
+        vshr.s16        d16,  d16,  #1
+        vsub.i16        \c2,  d16,  \c1
+        vsub.i16        \c1,  d16,  \c3
+        vadd.i16        \c3,  d17,  \c2
+        vsub.i16        \c0,  \c0,  \c1
+.endm
+
+.macro idct4 c0, c1, c2, c3
+        vmull.s16       q13,  \c1,  d0[3]
+        vmull.s16       q11,  \c1,  d0[2]
+        vadd.i16        d16,  \c0,  \c2
+        vsub.i16        d17,  \c0,  \c2
+        vmlal.s16       q13,  \c3,  d0[2]
+        vmull.s16       q9,   d16,  d0[0]
+        vmull.s16       q10,  d17,  d0[0]
+        vmlsl.s16       q11,  \c3,  d0[3]
+        vrshrn.s32      d26,  q13,  #14
+        vrshrn.s32      d18,  q9,   #14
+        vrshrn.s32      d20,  q10,  #14
+        vrshrn.s32      d22,  q11,  #14
+        vadd.i16        \c0,  d18,  d26
+        vsub.i16        \c3,  d18,  d26
+        vadd.i16        \c1,  d20,  d22
+        vsub.i16        \c2,  d20,  d22
+.endm
+
+.macro iadst4 c0, c1, c2, c3
+        vmull.s16       q10,  \c0,  d1[0]
+        vmlal.s16       q10,  \c2,  d1[1]
+        vmlal.s16       q10,  \c3,  d1[2]
+        vmull.s16       q11,  \c0,  d1[2]
+        vmlsl.s16       q11,  \c2,  d1[0]
+        vsub.s16        \c0,  \c0,  \c2
+        vmlsl.s16       q11,  \c3,  d1[1]
+        vadd.s16        \c0,  \c0,  \c3
+        vmull.s16       q13,  \c1,  d1[3]
+        vmull.s16       q12,  \c0,  d1[3]
+        vadd.s32        q14,  q10,  q13
+        vadd.s32        q1,   q11,  q13
+        vrshrn.s32      \c0,  q14,  #14
+        vadd.s32        q10,  q10,  q11
+        vrshrn.s32      \c1,  q1,   #14
+        vsub.s32        q10,  q10,  q13
+        vrshrn.s32      \c2,  q12,  #14
+        vrshrn.s32      \c3,  q10,  #14
+.endm
+
+@ The public functions in this file have got the following signature:
+@ void itxfm_add(uint8_t *dst, ptrdiff_t stride, int16_t *block, int eob);
+
+.macro itxfm_func4x4 txfm1, txfm2
+function ff_vp9_\txfm1\()_\txfm2\()_4x4_add_neon, export=1
+.ifc \txfm1,\txfm2
+.ifc \txfm1,idct
+        movrel          r12, itxfm4_coeffs
+        vld1.16         {d0}, [r12,:64]
+.endif
+.ifc \txfm1,iadst
+        movrel          r12, iadst4_coeffs
+        vld1.16         {d1}, [r12,:64]
+.endif
+.else
+        movrel          r12, itxfm4_coeffs
+        vld1.16         {q0}, [r12,:128]
+.endif
+
+        vmov.i16        q15, #0
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             r3,  #1
+        bne             1f
+        @ DC-only for idct/idct
+        vld1.16         {d4[]},   [r2,:16]
+        vmull.s16       q2,  d4,  d0[0]
+        vrshrn.s32      d4,  q2,  #14
+        vmull.s16       q2,  d4,  d0[0]
+        vrshrn.s32      d4,  q2,  #14
+        vst1.16         {d30[0]}, [r2,:16]
+        vdup.16         q2,  d4[0]
+        vmov            q3,  q2
+        b               2f
+.endif
+
+1:
+        vld1.16         {d4-d7},  [r2,:128]
+        vst1.16         {q15}, [r2,:128]!
+
+.ifc \txfm1,iwht
+        vshr.s16        q2,  q2,  #2
+        vshr.s16        q3,  q3,  #2
+.endif
+
+        \txfm1\()4      d4,  d5,  d6,  d7
+
+        vst1.16         {q15}, [r2,:128]!
+        @ Transpose 4x4 with 16 bit elements
+        vtrn.16         d4,  d5
+        vtrn.16         d6,  d7
+        vtrn.32         q2,  q3
+
+        \txfm2\()4      d4,  d5,  d6,  d7
+2:
+        vld1.32         {d0[]},   [r0,:32], r1
+        vld1.32         {d0[1]},  [r0,:32], r1
+.ifnc \txfm1,iwht
+        vrshr.s16       q2,  q2,  #4
+        vrshr.s16       q3,  q3,  #4
+.endif
+        vaddw.u8        q2,  q2,  d0
+        vld1.32         {d1[]},   [r0,:32], r1
+        vld1.32         {d1[1]},  [r0,:32], r1
+        vqmovun.s16     d0,  q2
+        sub             r0,  r0,  r1, lsl #2
+
+        vaddw.u8        q3,  q3,  d1
+        vst1.32         {d0[0]},  [r0,:32], r1
+        vqmovun.s16     d1,  q3
+
+        vst1.32         {d0[1]},  [r0,:32], r1
+        vst1.32         {d1[0]},  [r0,:32], r1
+        vst1.32         {d1[1]},  [r0,:32], r1
+
+        bx              lr
+endfunc
+.endm
+
+itxfm_func4x4 idct,  idct
+itxfm_func4x4 iadst, idct
+itxfm_func4x4 idct,  iadst
+itxfm_func4x4 iadst, iadst
+itxfm_func4x4 iwht,  iwht
+
+
+.macro idct8
+        dmbutterfly0    d16, d17, d24, d25, q8,  q12, q2, q4, d4, d5, d8, d9, q3, q2, q5, q4 @ q8 = t0a, q12 = t1a
+        dmbutterfly     d20, d21, d28, d29, d0[2], d0[3], q2,  q3,  q4,  q5 @ q10 = t2a, q14 = t3a
+        dmbutterfly     d18, d19, d30, d31, d1[0], d1[1], q2,  q3,  q4,  q5 @ q9  = t4a, q15 = t7a
+        dmbutterfly     d26, d27, d22, d23, d1[2], d1[3], q2,  q3,  q4,  q5 @ q13 = t5a, q11 = t6a
+
+        butterfly       q2,  q14, q8,  q14 @ q2 = t0, q14 = t3
+        butterfly       q3,  q10, q12, q10 @ q3 = t1, q10 = t2
+        butterfly       q4,  q13, q9,  q13 @ q4 = t4, q13 = t5a
+        butterfly       q5,  q11, q15, q11 @ q5 = t7, q11 = t6a
+
+        butterfly       q8,  q15, q2,  q5  @ q8 = out[0], q15 = out[7]
+
+        dmbutterfly0    d4,  d5,  d10, d11, q11, q13, q9,  q13, d18, d19, d26, d27, q2,  q5, q11, q12 @ q2 = t6, q5 = t5
+
+        butterfly       q11, q12, q14, q4  @ q11 = out[3], q12 = out[4]
+        butterfly       q9,  q14, q3,  q2  @ q9 = out[1],  q14 = out[6]
+        butterfly_r     q13, q10, q10, q5  @ q13 = out[5], q10 = out[2]
+.endm
+
+.macro iadst8
+        dmbutterfly_l   q4,  q5,  q2,  q3,  d30, d31, d16, d17, d2[1], d2[0] @ q4,q5  = t1a, q2,q3 = t0a
+        dmbutterfly_l   q8,  q15, q6,  q7,  d22, d23, d24, d25, d3[1], d3[0] @ q8,q15 = t5a, q6,q7 = t4a
+
+        dbutterfly_n    d22, d23, d4,  d5,  q2,  q3,  q6,  q7,  q11, q12, q2,  q3 @ q11 = t0, q2 = t4
+
+        dbutterfly_n    d24, d25, d6,  d7,  q4,  q5,  q8,  q15, q12, q3,  q6,  q7 @ q12 = t1, q3 = t5
+
+        dmbutterfly_l   q6,  q7,  q4,  q5,  d26, d27, d20, d21, d2[3], d2[2] @ q6,q7 = t3a, q4,q5 = t2a
+        dmbutterfly_l   q10, q13, q8,  q15, d18, d19, d28, d29, d3[3], d3[2] @ q10,q13 = t7a, q8,q15 = t6a
+
+        dbutterfly_n    d18, d19, d8,  d9,  q4,  q5,  q8,  q15, q9,  q14, q4, q5 @ q9 = t2, q4 = t6
+        dbutterfly_n    d16, d17, d12, d13, q6,  q7,  q10, q13, q8,  q15, q6, q7 @ q8 = t3, q6 = t7
+
+        butterfly       q15, q12, q12, q8 @ q15 = -out[7], q12 = t3
+        vneg.s16        q15, q15          @ q15 = out[7]
+        butterfly       q8,  q9,  q11, q9 @ q8 = out[0], q9 = t2
+
+        dmbutterfly_l   q10, q11, q5,  q7,  d4,  d5,  d6,  d7,  d0[2], d0[3] @ q10,q11 = t5a, q5,q7 = t4a
+        dmbutterfly_l   q2,  q3,  q13, q14, d12, d13, d8,  d9,  d0[3], d0[2] @ q2,q3 = t6a, q13,q14 = t7a
+
+        dbutterfly_n    d28, d29, d8,  d9,  q10, q11, q13, q14, q4,  q6,  q10, q11 @ q14 = out[6], q4 = t7
+
+        dmbutterfly0    d22, d23, d24, d25, q9,  q12, q6, q13, d12, d13, d26, d27, q9, q10 @ q11 = -out[3], q12 = out[4]
+        vneg.s16        q11, q11      @ q11 = out[3]
+
+        dbutterfly_n    d18, d19, d4,  d5,  q5,  q7,  q2,  q3,  q9, q10, q2,  q3 @ q9 = -out[1], q2 = t6
+        vneg.s16        q9,  q9       @ q9 = out[1]
+
+        dmbutterfly0    d20, d21, d26, d27, q2,  q4,  q3, q5,  d6,  d7,  d10, d11, q6,  q7 @ q10 = out[2], q13 = -out[5]
+        vneg.s16        q13, q13      @ q13 = out[5]
+.endm
+
+
+.macro itxfm_func8x8 txfm1, txfm2
+function ff_vp9_\txfm1\()_\txfm2\()_8x8_add_neon, export=1
+        @ Push q4-q7 if iadst is used, idct requires
+        @ a few scratch registers less, so only push q4-q5
+        @ if only idct is involved.
+        @ The iadst also uses a few coefficients from
+        @ idct, so those always need to be loaded.
+.ifc \txfm1\()_\txfm2,idct_idct
+        movrel          r12, idct_coeffs
+        vpush           {q4-q5}
+.else
+        movrel          r12, iadst8_coeffs
+        vld1.16         {q1}, [r12,:128]!
+        vpush           {q4-q7}
+.endif
+        vld1.16         {q0}, [r12,:128]
+
+        vmov.i16        q2, #0
+        vmov.i16        q3, #0
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             r3,  #1
+        bne             1f
+        @ DC-only for idct/idct
+        vld1.16         {d16[]}, [r2,:16]
+        vmull.s16       q8,  d16, d0[0]
+        vrshrn.s32      d16, q8,  #14
+        vmull.s16       q8,  d16, d0[0]
+        vrshrn.s32      d16, q8,  #14
+        vdup.16         q8,  d16[0]
+        vmov            q9,  q8
+        vmov            q10, q8
+        vmov            q11, q8
+        vmov            q12, q8
+        vmov            q13, q8
+        vmov            q14, q8
+        vmov            q15, q8
+        vst1.16         {d4[0]}, [r2,:16]
+        b               2f
+.endif
+1:
+        vld1.16         {q8-q9},    [r2,:128]!
+        vld1.16         {q10-q11},  [r2,:128]!
+        vld1.16         {q12-q13},  [r2,:128]!
+        vld1.16         {q14-q15},  [r2,:128]!
+        sub             r2,  r2,  #128
+        vst1.16         {q2-q3}, [r2,:128]!
+        vst1.16         {q2-q3}, [r2,:128]!
+        vst1.16         {q2-q3}, [r2,:128]!
+        vst1.16         {q2-q3}, [r2,:128]!
+
+        \txfm1\()8
+
+        @ Transpose 8x8 with 16 bit elements
+        vswp            d17, d24
+        vswp            d19, d26
+        vswp            d21, d28
+        vswp            d23, d30
+        transpose16_4x4 q8, q9, q10, q11, q12, q13, q14, q15
+
+        \txfm2\()8
+2:
+        mov             r3,  r0
+        @ Add into the destination
+        vld1.8          {d4},  [r0,:64], r1
+        vrshr.s16       q8,  q8,  #5
+        vld1.8          {d5},  [r0,:64], r1
+        vrshr.s16       q9,  q9,  #5
+        vld1.8          {d6},  [r0,:64], r1
+        vrshr.s16       q10, q10, #5
+        vaddw.u8        q8,  q8,  d4
+        vld1.8          {d7},  [r0,:64], r1
+        vrshr.s16       q11, q11, #5
+        vaddw.u8        q9,  q9,  d5
+        vld1.8          {d8},  [r0,:64], r1
+        vrshr.s16       q12, q12, #5
+        vaddw.u8        q10, q10, d6
+        vqmovun.s16     d4,  q8
+        vld1.8          {d9},  [r0,:64], r1
+        vrshr.s16       q13, q13, #5
+        vaddw.u8        q11, q11, d7
+        vqmovun.s16     d5,  q9
+        vld1.8          {d10}, [r0,:64], r1
+        vrshr.s16       q14, q14, #5
+        vaddw.u8        q12, q12, d8
+        vqmovun.s16     d6,  q10
+        vld1.8          {d11}, [r0,:64], r1
+        vrshr.s16       q15, q15, #5
+        vaddw.u8        q13, q13, d9
+        vqmovun.s16     d7,  q11
+
+
+        vst1.8          {d4},  [r3,:64], r1
+        vaddw.u8        q14, q14, d10
+        vst1.8          {d5},  [r3,:64], r1
+        vqmovun.s16     d8,  q12
+        vst1.8          {d6},  [r3,:64], r1
+        vaddw.u8        q15, q15, d11
+        vst1.8          {d7},  [r3,:64], r1
+        vqmovun.s16     d9,  q13
+        vst1.8          {d8},  [r3,:64], r1
+        vqmovun.s16     d10, q14
+        vst1.8          {d9},  [r3,:64], r1
+        vqmovun.s16     d11, q15
+
+        vst1.8          {d10}, [r3,:64], r1
+        vst1.8          {d11}, [r3,:64], r1
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        vpop            {q4-q5}
+.else
+        vpop            {q4-q7}
+.endif
+        bx              lr
+endfunc
+.endm
+
+itxfm_func8x8 idct,  idct
+itxfm_func8x8 iadst, idct
+.ltorg
+itxfm_func8x8 idct,  iadst
+itxfm_func8x8 iadst, iadst
+
+
+function idct16x16_dc_add_neon
+        movrel          r12, idct_coeffs
+        vld1.16         {d0}, [r12,:64]
+
+        vmov.i16        q2,  #0
+
+        vld1.16         {d16[]}, [r2,:16]
+        vmull.s16       q8,  d16, d0[0]
+        vrshrn.s32      d16, q8,  #14
+        vmull.s16       q8,  d16, d0[0]
+        vrshrn.s32      d16, q8,  #14
+        vdup.16         q8,  d16[0]
+        vst1.16         {d4[0]}, [r2,:16]
+
+        vrshr.s16       q8,  q8,  #6
+
+        mov             r3,  r0
+        mov             r12, #16
+1:
+        @ Loop to add the constant from q8 into all 16x16 outputs
+        subs            r12, r12, #2
+        vld1.8          {q2},  [r0,:128], r1
+        vaddw.u8        q10, q8,  d4
+        vld1.8          {q3},  [r0,:128], r1
+        vaddw.u8        q11, q8,  d5
+        vaddw.u8        q12, q8,  d6
+        vaddw.u8        q13, q8,  d7
+        vqmovun.s16     d4,  q10
+        vqmovun.s16     d5,  q11
+        vqmovun.s16     d6,  q12
+        vst1.8          {q2},  [r3,:128], r1
+        vqmovun.s16     d7,  q13
+        vst1.8          {q3},  [r3,:128], r1
+        bne             1b
+
+        bx              lr
+endfunc
+.ltorg
+
+.macro idct16_end
+        butterfly       d18, d7,  d4,  d7                @ d18 = t0a,  d7  = t7a
+        butterfly       d19, d22, d5,  d22               @ d19 = t1a,  d22 = t6
+        butterfly       d4,  d26, d20, d26               @ d4  = t2a,  d26 = t5
+        butterfly       d5,  d6,  d28, d6                @ d5  = t3a,  d6  = t4
+        butterfly       d20, d28, d16, d24               @ d20 = t8a,  d28 = t11a
+        butterfly       d24, d21, d23, d21               @ d24 = t9,   d21 = t10
+        butterfly       d23, d27, d25, d27               @ d23 = t14,  d27 = t13
+        butterfly       d25, d29, d29, d17               @ d25 = t15a, d29 = t12a
+
+        mbutterfly0     d27, d21, d27, d21, d16, d30, q8, q15 @ d27 = t13a, d21 = t10a
+        mbutterfly0     d29, d28, d29, d28, d16, d30, q8, q15 @ d29 = t12,  d28 = t11
+
+        vswp            d27, d29                         @ d27 = t12, d29 = t13a
+        vswp            d28, d27                         @ d28 = t12, d27 = t11
+        butterfly       d16, d31, d18, d25               @ d16 = out[0], d31 = out[15]
+        butterfly       d17, d30, d19, d23               @ d17 = out[1], d30 = out[14]
+        butterfly_r     d25, d22, d22, d24               @ d25 = out[9], d22 = out[6]
+        butterfly       d23, d24, d7,  d20               @ d23 = out[7], d24 = out[8]
+        butterfly       d18, d29, d4,  d29               @ d18 = out[2], d29 = out[13]
+        butterfly       d19, d28, d5,  d28               @ d19 = out[3], d28 = out[12]
+        vmov            d4,  d21                         @ d4  = t10a
+        butterfly       d20, d27, d6,  d27               @ d20 = out[4], d27 = out[11]
+        butterfly       d21, d26, d26, d4                @ d21 = out[5], d26 = out[10]
+        bx              lr
+.endm
+
+function idct16
+        mbutterfly0     d16, d24, d16, d24, d4, d6,  q2,  q3 @ d16 = t0a,  d24 = t1a
+        mbutterfly      d20, d28, d0[2], d0[3], q2,  q3  @ d20 = t2a,  d28 = t3a
+        mbutterfly      d18, d30, d1[0], d1[1], q2,  q3  @ d18 = t4a,  d30 = t7a
+        mbutterfly      d26, d22, d1[2], d1[3], q2,  q3  @ d26 = t5a,  d22 = t6a
+        mbutterfly      d17, d31, d2[0], d2[1], q2,  q3  @ d17 = t8a,  d31 = t15a
+        mbutterfly      d25, d23, d2[2], d2[3], q2,  q3  @ d25 = t9a,  d23 = t14a
+        mbutterfly      d21, d27, d3[0], d3[1], q2,  q3  @ d21 = t10a, d27 = t13a
+        mbutterfly      d29, d19, d3[2], d3[3], q2,  q3  @ d29 = t11a, d19 = t12a
+
+        butterfly       d4,  d28, d16, d28               @ d4  = t0,   d28 = t3
+        butterfly       d5,  d20, d24, d20               @ d5  = t1,   d20 = t2
+        butterfly       d6,  d26, d18, d26               @ d6  = t4,   d26 = t5
+        butterfly       d7,  d22, d30, d22               @ d7  = t7,   d22 = t6
+        butterfly       d16, d25, d17, d25               @ d16 = t8,   d25 = t9
+        butterfly       d24, d21, d29, d21               @ d24 = t11,  d21 = t10
+        butterfly       d17, d27, d19, d27               @ d17 = t12,  d27 = t13
+        butterfly       d29, d23, d31, d23               @ d29 = t15,  d23 = t14
+
+        mbutterfly0     d22, d26, d22, d26, d18, d30, q9,  q15  @ d22 = t6a, d26 = t5a
+        mbutterfly      d23, d25, d0[2], d0[3], q9,  q15        @ d23 = t9a,  d25 = t14a
+        mbutterfly      d27, d21, d0[2], d0[3], q9,  q15, neg=1 @ d27 = t13a, d21 = t10a
+        idct16_end
+endfunc
+
+function idct16_half
+        mbutterfly0_h   d16, d24, d16, d24, d4, d6,  q2,  q3 @ d16 = t0a,  d24 = t1a
+        mbutterfly_h1   d20, d28, d0[2], d0[3], q2,  q3  @ d20 = t2a,  d28 = t3a
+        mbutterfly_h1   d18, d30, d1[0], d1[1], q2,  q3  @ d18 = t4a,  d30 = t7a
+        mbutterfly_h2   d26, d22, d1[2], d1[3], q2,  q3  @ d26 = t5a,  d22 = t6a
+        mbutterfly_h1   d17, d31, d2[0], d2[1], q2,  q3  @ d17 = t8a,  d31 = t15a
+        mbutterfly_h2   d25, d23, d2[2], d2[3], q2,  q3  @ d25 = t9a,  d23 = t14a
+        mbutterfly_h1   d21, d27, d3[0], d3[1], q2,  q3  @ d21 = t10a, d27 = t13a
+        mbutterfly_h2   d29, d19, d3[2], d3[3], q2,  q3  @ d29 = t11a, d19 = t12a
+
+        butterfly       d4,  d28, d16, d28               @ d4  = t0,   d28 = t3
+        butterfly       d5,  d20, d24, d20               @ d5  = t1,   d20 = t2
+        butterfly       d6,  d26, d18, d26               @ d6  = t4,   d26 = t5
+        butterfly       d7,  d22, d30, d22               @ d7  = t7,   d22 = t6
+        butterfly       d16, d25, d17, d25               @ d16 = t8,   d25 = t9
+        butterfly       d24, d21, d29, d21               @ d24 = t11,  d21 = t10
+        butterfly       d17, d27, d19, d27               @ d17 = t12,  d27 = t13
+        butterfly       d29, d23, d31, d23               @ d29 = t15,  d23 = t14
+
+        mbutterfly0     d22, d26, d22, d26, d18, d30, q9,  q15  @ d22 = t6a, d26 = t5a
+        mbutterfly      d23, d25, d0[2], d0[3], q9,  q15        @ d23 = t9a,  d25 = t14a
+        mbutterfly      d27, d21, d0[2], d0[3], q9,  q15, neg=1 @ d27 = t13a, d21 = t10a
+        idct16_end
+endfunc
+
+function idct16_quarter
+        vmull.s16       q12, d19, d3[3]
+        vmull.s16       q2,  d17, d2[0]
+        vmull.s16       q3,  d18, d1[1]
+        vmull.s16       q15, d18, d1[0]
+        vneg.s32        q12, q12
+        vmull.s16       q14, d17, d2[1]
+        vmull.s16       q13, d19, d3[2]
+        vmull.s16       q11, d16, d0[0]
+        vrshrn.s32      d24, q12, #14
+        vrshrn.s32      d16, q2,  #14
+        vrshrn.s32      d7,  q3,  #14
+        vrshrn.s32      d6,  q15, #14
+        vrshrn.s32      d29, q14, #14
+        vrshrn.s32      d17, q13, #14
+        vrshrn.s32      d28, q11, #14
+
+        mbutterfly_l    q10, q11, d17, d24, d0[2], d0[3]
+        mbutterfly_l    q9,  q15, d29, d16, d0[2], d0[3]
+        vneg.s32        q11, q11
+        vrshrn.s32      d27, q10, #14
+        vrshrn.s32      d21, q11, #14
+        vrshrn.s32      d23, q9,  #14
+        vrshrn.s32      d25, q15, #14
+        vmov            d4,  d28
+        vmov            d5,  d28
+        mbutterfly0     d22, d26, d7,  d6,  d18, d30, q9,  q15
+        vmov            d20, d28
+        idct16_end
+endfunc
+
+function iadst16
+        movrel          r12, iadst16_coeffs
+        vld1.16         {q0-q1}, [r12,:128]
+
+        mbutterfly_l    q3,  q2,  d31, d16, d0[1], d0[0] @ q3  = t1,   q2  = t0
+        mbutterfly_l    q5,  q4,  d23, d24, d1[1], d1[0] @ q5  = t9,   q4  = t8
+        butterfly_n     d31, d24, q3,  q5,  q6,  q5      @ d31 = t1a,  d24 = t9a
+        mbutterfly_l    q7,  q6,  d29, d18, d0[3], d0[2] @ q7  = t3,   q6  = t2
+        butterfly_n     d16, d23, q2,  q4,  q3,  q4      @ d16 = t0a,  d23 = t8a
+
+        mbutterfly_l    q3,  q2,  d21, d26, d1[3], d1[2] @ q3  = t11,  q2  = t10
+        butterfly_n     d29, d26, q7,  q3,  q4,  q3      @ d29 = t3a,  d26 = t11a
+        mbutterfly_l    q5,  q4,  d27, d20, d2[1], d2[0] @ q5  = t5,   q4  = t4
+        butterfly_n     d18, d21, q6,  q2,  q3,  q2      @ d18 = t2a,  d21 = t10a
+
+        mbutterfly_l    q7,  q6,  d19, d28, d3[1], d3[0] @ q7  = t13,  q6  = t12
+        butterfly_n     d20, d28, q5,  q7,  q2,  q7      @ d20 = t5a,  d28 = t13a
+        mbutterfly_l    q3,  q2,  d25, d22, d2[3], d2[2] @ q3  = t7,   q2  = t6
+        butterfly_n     d27, d19, q4,  q6,  q5,  q6      @ d27 = t4a,  d19 = t12a
+
+        mbutterfly_l    q5,  q4,  d17, d30, d3[3], d3[2] @ q5  = t15,  q4  = t14
+        movrel          r12, idct_coeffs
+        vld1.16         {q0}, [r12,:128]
+        butterfly_n     d22, d30, q3,  q5,  q6,  q5      @ d22 = t7a,  d30 = t15a
+        mbutterfly_l    q7,  q6,  d23, d24, d1[0], d1[1] @ q7  = t9,   q6  = t8
+        butterfly_n     d25, d17, q2,  q4,  q3,  q4      @ d25 = t6a,  d17 = t14a
+
+        mbutterfly_l    q2,  q3,  d28, d19, d1[1], d1[0] @ q2  = t12,  q3  = t13
+        butterfly_n     d23, d19, q6,  q2,  q4,  q2      @ d23 = t8a,  d19 = t12a
+        mbutterfly_l    q5,  q4,  d21, d26, d1[2], d1[3] @ q5  = t11,  q4  = t10
+        butterfly_r     d4,  d27, d16, d27               @ d4  = t4,   d27 = t0
+        butterfly_n     d24, d28, q7,  q3,  q6,  q3      @ d24 = t9a,  d28 = t13a
+
+        mbutterfly_l    q6,  q7,  d30, d17, d1[3], d1[2] @ q6  = t14,  q7  = t15
+        butterfly_r     d5,  d20, d31, d20               @ d5  = t5,   d20 = t1
+        butterfly_n     d21, d17, q4,  q6,  q3,  q6      @ d21 = t10a, d17 = t14a
+        butterfly_n     d26, d30, q5,  q7,  q4,  q7      @ d26 = t11a, d30 = t15a
+
+        butterfly_r     d6,  d25, d18, d25               @ d6  = t6,   d25 = t2
+        butterfly_r     d7,  d22, d29, d22               @ d7  = t7,   d22 = t3
+
+        mbutterfly_l    q5,  q4,  d19, d28, d0[2], d0[3] @ q5  = t13,  q4  = t12
+        mbutterfly_l    q6,  q7,  d30, d17, d0[3], d0[2] @ q6  = t14,  q7  = t15
+
+        butterfly_n     d18, d30, q4,  q6,  q8,  q6      @ d18 = out[2],   d30 = t14a
+        butterfly_n     d29, d17, q5,  q7,  q6,  q7      @ d29 = -out[13], d17 = t15a
+        vneg.s16        d29, d29                         @ d29 = out[13]
+
+        mbutterfly_l    q5,  q4,  d4,  d5,  d0[2], d0[3] @ q5  = t5a,  q4  = t4a
+        mbutterfly_l    q6,  q7,  d7,  d6,  d0[3], d0[2] @ q6  = t6a,  q7  = t7a
+
+        butterfly       d2,  d6,  d27, d25               @ d2 = out[0], d6 = t2a
+        butterfly       d3,  d7,  d23, d21               @ d3 =-out[1], d7 = t10
+
+        butterfly_n     d19, d31, q4,  q6,  q2,  q4      @ d19 = -out[3],  d31 = t6
+        vneg.s16        d19, d19                         @ d19 = out[3]
+        butterfly_n     d28, d16, q5,  q7,  q2,  q5      @ d28 = out[12],  d16 = t7
+
+        butterfly       d5,  d8,  d20, d22               @ d5 =-out[15],d8 = t3a
+        butterfly       d4,  d9,  d24, d26               @ d4 = out[14],d9 = t11
+
+        mbutterfly0     d23, d24, d6,  d8,  d10, d11, q6,  q7, 1 @ d23 = out[7], d24 = out[8]
+        mbutterfly0     d20, d27, d16, d31, d10, d11, q6,  q7    @ d20 = out[4], d27 = out[11]
+        mbutterfly0     d22, d25, d9,  d7,  d10, d11, q6,  q7    @ d22 = out[6], d25 = out[9]
+        mbutterfly0     d21, d26, d30, d17, d10, d11, q6,  q7, 1 @ d21 = out[5], d26 = out[10]
+
+        vneg.s16        d31, d5                          @ d31 = out[15]
+        vneg.s16        d17, d3                          @ d17 = out[1]
+
+        vmov            d16, d2
+        vmov            d30, d4
+        bx              lr
+endfunc
+
+.macro load_add_store coef0, coef1, coef2, coef3
+        vrshr.s16       \coef0, \coef0, #6
+        vrshr.s16       \coef1, \coef1, #6
+
+        vld1.32         {d4[]},   [r0,:32], r1
+        vld1.32         {d4[1]},  [r3,:32], r1
+        vrshr.s16       \coef2, \coef2, #6
+        vrshr.s16       \coef3, \coef3, #6
+        vld1.32         {d5[]},   [r0,:32], r1
+        vld1.32         {d5[1]},  [r3,:32], r1
+        vaddw.u8        \coef0, \coef0, d4
+        vld1.32         {d6[]},   [r0,:32], r1
+        vld1.32         {d6[1]},  [r3,:32], r1
+        vaddw.u8        \coef1, \coef1, d5
+        vld1.32         {d7[]},   [r0,:32], r1
+        vld1.32         {d7[1]},  [r3,:32], r1
+
+        vqmovun.s16     d4,  \coef0
+        vqmovun.s16     d5,  \coef1
+        sub             r0,  r0,  r1, lsl #2
+        sub             r3,  r3,  r1, lsl #2
+        vaddw.u8        \coef2, \coef2, d6
+        vaddw.u8        \coef3, \coef3, d7
+        vst1.32         {d4[0]},  [r0,:32], r1
+        vst1.32         {d4[1]},  [r3,:32], r1
+        vqmovun.s16     d6,  \coef2
+        vst1.32         {d5[0]},  [r0,:32], r1
+        vst1.32         {d5[1]},  [r3,:32], r1
+        vqmovun.s16     d7,  \coef3
+
+        vst1.32         {d6[0]},  [r0,:32], r1
+        vst1.32         {d6[1]},  [r3,:32], r1
+        vst1.32         {d7[0]},  [r0,:32], r1
+        vst1.32         {d7[1]},  [r3,:32], r1
+.endm
+
+.macro itxfm16_1d_funcs txfm
+@ Read a vertical 4x16 slice out of a 16x16 matrix, do a transform on it,
+@ transpose into a horizontal 16x4 slice and store.
+@ r0 = dst (temp buffer)
+@ r1 = slice offset
+@ r2 = src
+function \txfm\()16_1d_4x16_pass1_neon
+        push            {lr}
+
+        mov             r12, #32
+        vmov.s16        q2,  #0
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d4},  [r2,:64], r12
+.endr
+
+        bl              \txfm\()16
+
+        @ Do four 4x4 transposes. Originally, d16-d31 contain the
+        @ 16 rows. Afterwards, d16-d19, d20-d23, d24-d27, d28-d31
+        @ contain the transposed 4x4 blocks.
+        transpose16_q_4x_4x4 q8,  q9,  q10, q11, q12, q13, q14, q15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31
+
+        @ Store the transposed 4x4 blocks horizontally.
+        cmp             r1,  #12
+        beq             1f
+.irp i, 16, 20, 24, 28, 17, 21, 25, 29, 18, 22, 26, 30, 19, 23, 27, 31
+        vst1.16         {d\i}, [r0,:64]!
+.endr
+        pop             {pc}
+1:
+        @ Special case: For the last input column (r1 == 12),
+        @ which would be stored as the last row in the temp buffer,
+        @ don't store the first 4x4 block, but keep it in registers
+        @ for the first slice of the second pass (where it is the
+        @ last 4x4 block).
+        add             r0,  r0,  #8
+        vst1.16         {d20}, [r0,:64]!
+        vst1.16         {d24}, [r0,:64]!
+        vst1.16         {d28}, [r0,:64]!
+        add             r0,  r0,  #8
+        vst1.16         {d21}, [r0,:64]!
+        vst1.16         {d25}, [r0,:64]!
+        vst1.16         {d29}, [r0,:64]!
+        add             r0,  r0,  #8
+        vst1.16         {d22}, [r0,:64]!
+        vst1.16         {d26}, [r0,:64]!
+        vst1.16         {d30}, [r0,:64]!
+        add             r0,  r0,  #8
+        vst1.16         {d23}, [r0,:64]!
+        vst1.16         {d27}, [r0,:64]!
+        vst1.16         {d31}, [r0,:64]!
+        vmov            d28, d16
+        vmov            d29, d17
+        vmov            d30, d18
+        vmov            d31, d19
+        pop             {pc}
+endfunc
+
+@ Read a vertical 4x16 slice out of a 16x16 matrix, do a transform on it,
+@ load the destination pixels (from a similar 4x16 slice), add and store back.
+@ r0 = dst
+@ r1 = dst stride
+@ r2 = src (temp buffer)
+@ r3 = slice offset
+function \txfm\()16_1d_4x16_pass2_neon
+        push            {lr}
+        mov             r12, #32
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+        cmp             r3,  #0
+        beq             1f
+.irp i, 28, 29, 30, 31
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+1:
+
+        add             r3,  r0,  r1
+        lsl             r1,  r1,  #1
+        bl              \txfm\()16
+
+        load_add_store  q8,  q9,  q10, q11
+        load_add_store  q12, q13, q14, q15
+
+        pop             {pc}
+endfunc
+.endm
+
+itxfm16_1d_funcs idct
+itxfm16_1d_funcs iadst
+
+@ This is the minimum eob value for each subpartition, in increments of 4
+const min_eob_idct_idct_16, align=4
+        .short  0, 10, 38, 89
+endconst
+
+.macro itxfm_func16x16 txfm1, txfm2
+function ff_vp9_\txfm1\()_\txfm2\()_16x16_add_neon, export=1
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             r3,  #1
+        beq             idct16x16_dc_add_neon
+.endif
+        push            {r4-r8,lr}
+.ifnc \txfm1\()_\txfm2,idct_idct
+        vpush           {q4-q7}
+.endif
+
+        @ Align the stack, allocate a temp buffer
+T       mov             r7,  sp
+T       and             r7,  r7,  #15
+A       and             r7,  sp,  #15
+        add             r7,  r7,  #512
+        sub             sp,  sp,  r7
+
+        mov             r4,  r0
+        mov             r5,  r1
+        mov             r6,  r2
+
+.ifc \txfm1,idct
+        movrel          r12, idct_coeffs
+        vld1.16         {q0-q1}, [r12,:128]
+.endif
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        cmp             r3,  #10
+        ble             idct16x16_quarter_add_neon
+        cmp             r3,  #38
+        ble             idct16x16_half_add_neon
+
+        movrel          r8,  min_eob_idct_idct_16 + 2
+.endif
+
+.irp i, 0, 4, 8, 12
+        add             r0,  sp,  #(\i*32)
+.ifc \txfm1\()_\txfm2,idct_idct
+.if \i > 0
+        ldrh_post       r1,  r8,  #2
+        cmp             r3,  r1
+        it              le
+        movle           r1,  #(16 - \i)/4
+        ble             1f
+.endif
+.endif
+        mov             r1,  #\i
+        add             r2,  r6,  #(\i*2)
+        bl              \txfm1\()16_1d_4x16_pass1_neon
+.endr
+
+.ifc \txfm1\()_\txfm2,idct_idct
+        b               3f
+1:
+        @ For all-zero slices in pass 1, set d28-d31 to zero, for the in-register
+        @ passthrough of coefficients to pass 2 and clear the end of the temp buffer
+        vmov.i16        q14, #0
+        vmov.i16        q15, #0
+2:
+        subs            r1,  r1,  #1
+.rept 4
+        vst1.16         {q14-q15}, [r0,:128]!
+.endr
+        bne             2b
+3:
+.endif
+
+.ifc \txfm1\()_\txfm2,iadst_idct
+        movrel          r12, idct_coeffs
+        vld1.16         {q0-q1}, [r12,:128]
+.endif
+.irp i, 0, 4, 8, 12
+        add             r0,  r4,  #(\i)
+        mov             r1,  r5
+        add             r2,  sp,  #(\i*2)
+        mov             r3,  #\i
+        bl              \txfm2\()16_1d_4x16_pass2_neon
+.endr
+
+        add             sp,  sp,  r7
+.ifnc \txfm1\()_\txfm2,idct_idct
+        vpop            {q4-q7}
+.endif
+        pop             {r4-r8,pc}
+endfunc
+.endm
+
+itxfm_func16x16 idct,  idct
+itxfm_func16x16 iadst, idct
+itxfm_func16x16 idct,  iadst
+itxfm_func16x16 iadst, iadst
+.ltorg
+
+function idct16_1d_4x16_pass1_quarter_neon
+        push            {lr}
+        mov             r12, #32
+        vmov.s16        q2, #0
+.irp i, 16, 17, 18, 19
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d4},  [r2,:64], r12
+.endr
+
+        bl              idct16_quarter
+
+        @ Do four 4x4 transposes. Originally, d16-d31 contain the
+        @ 16 rows. Afterwards, d16-d19, d20-d23, d24-d27, d28-d31
+        @ contain the transposed 4x4 blocks.
+        transpose16_q_4x_4x4 q8,  q9,  q10, q11, q12, q13, q14, q15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31
+
+        @ Store the transposed 4x4 blocks horizontally.
+        @ The first 4x4 block is kept in registers for the second pass,
+        @ store the rest in the temp buffer.
+        add             r0,  r0,  #8
+        vst1.16         {d20}, [r0,:64]!
+        vst1.16         {d24}, [r0,:64]!
+        vst1.16         {d28}, [r0,:64]!
+        add             r0,  r0,  #8
+        vst1.16         {d21}, [r0,:64]!
+        vst1.16         {d25}, [r0,:64]!
+        vst1.16         {d29}, [r0,:64]!
+        add             r0,  r0,  #8
+        vst1.16         {d22}, [r0,:64]!
+        vst1.16         {d26}, [r0,:64]!
+        vst1.16         {d30}, [r0,:64]!
+        add             r0,  r0,  #8
+        vst1.16         {d23}, [r0,:64]!
+        vst1.16         {d27}, [r0,:64]!
+        vst1.16         {d31}, [r0,:64]!
+        pop             {pc}
+endfunc
+
+function idct16_1d_4x16_pass2_quarter_neon
+        push            {lr}
+        @ Only load the top 4 lines, and only do it for the later slices.
+        @ For the first slice, d16-d19 is kept in registers from the first pass.
+        cmp             r3,  #0
+        beq             1f
+        mov             r12, #32
+.irp i, 16, 17, 18, 19
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+1:
+
+        add             r3,  r0,  r1
+        lsl             r1,  r1,  #1
+        bl              idct16_quarter
+
+        load_add_store  q8,  q9,  q10, q11
+        load_add_store  q12, q13, q14, q15
+
+        pop             {pc}
+endfunc
+
+function idct16_1d_4x16_pass1_half_neon
+        push            {lr}
+        mov             r12, #32
+        vmov.s16        q2, #0
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d4},  [r2,:64], r12
+.endr
+
+        bl              idct16_half
+
+        @ Do four 4x4 transposes. Originally, d16-d31 contain the
+        @ 16 rows. Afterwards, d16-d19, d20-d23, d24-d27, d28-d31
+        @ contain the transposed 4x4 blocks.
+        transpose16_q_4x_4x4 q8,  q9,  q10, q11, q12, q13, q14, q15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31
+
+        @ Store the transposed 4x4 blocks horizontally.
+        cmp             r1,  #4
+        beq             1f
+.irp i, 16, 20, 24, 28, 17, 21, 25, 29, 18, 22, 26, 30, 19, 23, 27, 31
+        vst1.16         {d\i}, [r0,:64]!
+.endr
+        pop             {pc}
+1:
+        @ Special case: For the second input column (r1 == 4),
+        @ which would be stored as the second row in the temp buffer,
+        @ don't store the first 4x4 block, but keep it in registers
+        @ for the first slice of the second pass (where it is the
+        @ second 4x4 block).
+        add             r0,  r0,  #8
+        vst1.16         {d20}, [r0,:64]!
+        vst1.16         {d24}, [r0,:64]!
+        vst1.16         {d28}, [r0,:64]!
+        add             r0,  r0,  #8
+        vst1.16         {d21}, [r0,:64]!
+        vst1.16         {d25}, [r0,:64]!
+        vst1.16         {d29}, [r0,:64]!
+        add             r0,  r0,  #8
+        vst1.16         {d22}, [r0,:64]!
+        vst1.16         {d26}, [r0,:64]!
+        vst1.16         {d30}, [r0,:64]!
+        add             r0,  r0,  #8
+        vst1.16         {d23}, [r0,:64]!
+        vst1.16         {d27}, [r0,:64]!
+        vst1.16         {d31}, [r0,:64]!
+        vmov            d20, d16
+        vmov            d21, d17
+        vmov            d22, d18
+        vmov            d23, d19
+        pop             {pc}
+endfunc
+
+function idct16_1d_4x16_pass2_half_neon
+        push            {lr}
+        mov             r12, #32
+        cmp             r3,  #0
+.irp i, 16, 17, 18, 19
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+        beq             1f
+.irp i, 20, 21, 22, 23
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+1:
+
+        add             r3,  r0,  r1
+        lsl             r1,  r1,  #1
+        bl              idct16_half
+
+        load_add_store  q8,  q9,  q10, q11
+        load_add_store  q12, q13, q14, q15
+
+        pop             {pc}
+endfunc
+.purgem load_add_store
+
+.macro idct16_partial size
+function idct16x16_\size\()_add_neon
+        add             r0,  sp,  #(0*32)
+        mov             r1,  #0
+        add             r2,  r6,  #(0*2)
+        bl              idct16_1d_4x16_pass1_\size\()_neon
+.ifc \size,half
+        add             r0,  sp,  #(4*32)
+        mov             r1,  #4
+        add             r2,  r6,  #(4*2)
+        bl              idct16_1d_4x16_pass1_\size\()_neon
+.endif
+.irp i, 0, 4, 8, 12
+        add             r0,  r4,  #(\i)
+        mov             r1,  r5
+        add             r2,  sp,  #(\i*2)
+        mov             r3,  #\i
+        bl              idct16_1d_4x16_pass2_\size\()_neon
+.endr
+
+        add             sp,  sp,  r7
+        pop             {r4-r8,pc}
+endfunc
+.endm
+
+idct16_partial quarter
+idct16_partial half
+
+function idct32x32_dc_add_neon
+        movrel          r12, idct_coeffs
+        vld1.16         {d0}, [r12,:64]
+
+        vmov.i16        q2,  #0
+
+        vld1.16         {d16[]}, [r2,:16]
+        vmull.s16       q8,  d16, d0[0]
+        vrshrn.s32      d16, q8,  #14
+        vmull.s16       q8,  d16, d0[0]
+        vrshrn.s32      d16, q8,  #14
+        vdup.16         q8,  d16[0]
+        vst1.16         {d4[0]}, [r2,:16]
+
+        vrshr.s16       q8,  q8,  #6
+
+        mov             r3,  r0
+        mov             r12, #32
+1:
+        @ Loop to add the constant from q8 into all 32x32 outputs
+        subs            r12, r12, #2
+        vld1.8          {q0-q1},  [r0,:128], r1
+        vaddw.u8        q9,  q8,  d0
+        vaddw.u8        q10, q8,  d1
+        vld1.8          {q2-q3},  [r0,:128], r1
+        vaddw.u8        q11, q8,  d2
+        vaddw.u8        q12, q8,  d3
+        vaddw.u8        q13, q8,  d4
+        vaddw.u8        q14, q8,  d5
+        vaddw.u8        q15, q8,  d6
+        vqmovun.s16     d0,  q9
+        vaddw.u8        q9,  q8,  d7
+        vqmovun.s16     d1,  q10
+        vqmovun.s16     d2,  q11
+        vqmovun.s16     d3,  q12
+        vqmovun.s16     d4,  q13
+        vqmovun.s16     d5,  q14
+        vst1.8          {q0-q1},  [r3,:128], r1
+        vqmovun.s16     d6,  q15
+        vqmovun.s16     d7,  q9
+        vst1.8          {q2-q3},  [r3,:128], r1
+        bne             1b
+
+        bx              lr
+endfunc
+
+.macro idct32_end
+        butterfly       d16, d9,  d8,  d9  @ d16 = t16a, d9  = t19a
+        butterfly       d17, d20, d23, d20 @ d17 = t17,  d20 = t18
+        butterfly       d18, d10, d11, d10 @ d18 = t23a, d10 = t20a
+        butterfly       d19, d21, d22, d21 @ d19 = t22,  d21 = t21
+        butterfly       d8,  d28, d28, d30 @ d8  = t24a, d28 = t27a
+        butterfly       d23, d26, d25, d26 @ d23 = t25,  d26 = t26
+        butterfly       d11, d29, d29, d31 @ d11 = t31a, d29 = t28a
+        butterfly       d22, d27, d24, d27 @ d22 = t30,  d27 = t29
+
+        mbutterfly      d27, d20, d0[2], d0[3], q12, q15        @ d27 = t18a, d20 = t29a
+        mbutterfly      d29, d9,  d0[2], d0[3], q12, q15        @ d29 = t19,  d5  = t28
+        mbutterfly      d28, d10, d0[2], d0[3], q12, q15, neg=1 @ d28 = t27,  d6  = t20
+        mbutterfly      d26, d21, d0[2], d0[3], q12, q15, neg=1 @ d26 = t26a, d21 = t21a
+
+        butterfly       d31, d24, d11, d8  @ d31 = t31,  d24 = t24
+        butterfly       d30, d25, d22, d23 @ d30 = t30a, d25 = t25a
+        butterfly_r     d23, d16, d16, d18 @ d23 = t23,  d16 = t16
+        butterfly_r     d22, d17, d17, d19 @ d22 = t22a, d17 = t17a
+        butterfly       d18, d21, d27, d21 @ d18 = t18,  d21 = t21
+        butterfly_r     d27, d28, d9,  d28 @ d27 = t27a, d28 = t28a
+        butterfly       d8,  d26, d20, d26 @ d8  = t29,  d26 = t26
+        butterfly       d19, d20, d29, d10 @ d19 = t19a, d20 = t20
+        vmov            d29, d8            @ d29 = t29
+
+        mbutterfly0     d27, d20, d27, d20, d8, d10, q4, q5 @ d27 = t27,  d20 = t20
+        mbutterfly0     d26, d21, d26, d21, d8, d10, q4, q5 @ d26 = t26a, d21 = t21a
+        mbutterfly0     d25, d22, d25, d22, d8, d10, q4, q5 @ d25 = t25,  d22 = t22
+        mbutterfly0     d24, d23, d24, d23, d8, d10, q4, q5 @ d24 = t24a, d23 = t23a
+        bx              lr
+.endm
+
+function idct32_odd
+        mbutterfly      d16, d31, d4[0], d4[1], q4, q5 @ d16 = t16a, d31 = t31a
+        mbutterfly      d24, d23, d4[2], d4[3], q4, q5 @ d24 = t17a, d23 = t30a
+        mbutterfly      d20, d27, d5[0], d5[1], q4, q5 @ d20 = t18a, d27 = t29a
+        mbutterfly      d28, d19, d5[2], d5[3], q4, q5 @ d28 = t19a, d19 = t28a
+        mbutterfly      d18, d29, d6[0], d6[1], q4, q5 @ d18 = t20a, d29 = t27a
+        mbutterfly      d26, d21, d6[2], d6[3], q4, q5 @ d26 = t21a, d21 = t26a
+        mbutterfly      d22, d25, d7[0], d7[1], q4, q5 @ d22 = t22a, d25 = t25a
+        mbutterfly      d30, d17, d7[2], d7[3], q4, q5 @ d30 = t23a, d17 = t24a
+
+        butterfly       d8,  d24, d16, d24 @ d8  = t16, d24 = t17
+        butterfly       d9,  d20, d28, d20 @ d9  = t19, d20 = t18
+        butterfly       d10, d26, d18, d26 @ d10 = t20, d26 = t21
+        butterfly       d11, d22, d30, d22 @ d11 = t23, d22 = t22
+        butterfly       d28, d25, d17, d25 @ d28 = t24, d25 = t25
+        butterfly       d30, d21, d29, d21 @ d30 = t27, d21 = t26
+        butterfly       d29, d23, d31, d23 @ d29 = t31, d23 = t30
+        butterfly       d31, d27, d19, d27 @ d31 = t28, d27 = t29
+
+        mbutterfly      d23, d24, d1[0], d1[1], q8, q9        @ d23 = t17a, d24 = t30a
+        mbutterfly      d27, d20, d1[0], d1[1], q8, q9, neg=1 @ d27 = t29a, d20 = t18a
+        mbutterfly      d21, d26, d1[2], d1[3], q8, q9        @ d21 = t21a, d26 = t26a
+        mbutterfly      d25, d22, d1[2], d1[3], q8, q9, neg=1 @ d25 = t25a, d22 = t22a
+        idct32_end
+endfunc
+
+function idct32_odd_half
+        mbutterfly_h1   d16, d31, d4[0], d4[1], q4, q5 @ d16 = t16a, d31 = t31a
+        mbutterfly_h2   d24, d23, d4[2], d4[3], q4, q5 @ d24 = t17a, d23 = t30a
+        mbutterfly_h1   d20, d27, d5[0], d5[1], q4, q5 @ d20 = t18a, d27 = t29a
+        mbutterfly_h2   d28, d19, d5[2], d5[3], q4, q5 @ d28 = t19a, d19 = t28a
+        mbutterfly_h1   d18, d29, d6[0], d6[1], q4, q5 @ d18 = t20a, d29 = t27a
+        mbutterfly_h2   d26, d21, d6[2], d6[3], q4, q5 @ d26 = t21a, d21 = t26a
+        mbutterfly_h1   d22, d25, d7[0], d7[1], q4, q5 @ d22 = t22a, d25 = t25a
+        mbutterfly_h2   d30, d17, d7[2], d7[3], q4, q5 @ d30 = t23a, d17 = t24a
+
+        butterfly       d8,  d24, d16, d24 @ d8  = t16, d24 = t17
+        butterfly       d9,  d20, d28, d20 @ d9  = t19, d20 = t18
+        butterfly       d10, d26, d18, d26 @ d10 = t20, d26 = t21
+        butterfly       d11, d22, d30, d22 @ d11 = t23, d22 = t22
+        butterfly       d28, d25, d17, d25 @ d28 = t24, d25 = t25
+        butterfly       d30, d21, d29, d21 @ d30 = t27, d21 = t26
+        butterfly       d29, d23, d31, d23 @ d29 = t31, d23 = t30
+        butterfly       d31, d27, d19, d27 @ d31 = t28, d27 = t29
+
+        mbutterfly      d23, d24, d1[0], d1[1], q8, q9        @ d23 = t17a, d24 = t30a
+        mbutterfly      d27, d20, d1[0], d1[1], q8, q9, neg=1 @ d27 = t29a, d20 = t18a
+        mbutterfly      d21, d26, d1[2], d1[3], q8, q9        @ d21 = t21a, d26 = t26a
+        mbutterfly      d25, d22, d1[2], d1[3], q8, q9, neg=1 @ d25 = t25a, d22 = t22a
+
+        idct32_end
+endfunc
+
+function idct32_odd_quarter
+        vmull.s16       q4,  d16, d4[0]
+        vmull.s16       q14, d19, d5[3]
+        vmull.s16       q15, d16, d4[1]
+        vmull.s16       q11, d17, d7[2]
+        vmull.s16       q5,  d17, d7[3]
+        vmull.s16       q13, d19, d5[2]
+        vmull.s16       q10, d18, d6[0]
+        vmull.s16       q12, d18, d6[1]
+
+        vneg.s32        q14, q14
+        vneg.s32        q5,  q5
+
+        vrshrn.s32      d8,  q4,  #14
+        vrshrn.s32      d9,  q14, #14
+        vrshrn.s32      d29, q15, #14
+        vrshrn.s32      d28, q11, #14
+        vrshrn.s32      d11, q5,  #14
+        vrshrn.s32      d31, q13, #14
+        vrshrn.s32      d10, q10, #14
+        vrshrn.s32      d30, q12, #14
+
+        mbutterfly_l    q8,  q9,  d29, d8,  d1[0], d1[1]
+        mbutterfly_l    q13, q10, d31, d9,  d1[0], d1[1]
+        vrshrn.s32      d23, q8,  #14
+        vrshrn.s32      d24, q9,  #14
+        vneg.s32        q10, q10
+        vrshrn.s32      d27, q13, #14
+        vrshrn.s32      d20, q10, #14
+        mbutterfly_l    q8,  q9,  d30, d10, d1[2], d1[3]
+        vrshrn.s32      d21, q8,  #14
+        vrshrn.s32      d26, q9,  #14
+        mbutterfly_l    q8,  q9,  d28, d11, d1[2], d1[3]
+        vrshrn.s32      d25, q8,  #14
+        vneg.s32        q9,  q9
+        vrshrn.s32      d22, q9,  #14
+
+        idct32_end
+endfunc
+
+.macro idct32_funcs suffix
+@ Do an 32-point IDCT of a 4x32 slice out of a 32x32 matrix.
+@ We don't have register space to do a single pass IDCT of 4x32 though,
+@ but the 32-point IDCT can be decomposed into two 16-point IDCTs;
+@ a normal IDCT16 with every other input component (the even ones, with
+@ each output written twice), followed by a separate 16-point IDCT
+@ of the odd inputs, added/subtracted onto the outputs of the first idct16.
+@ r0 = dst (temp buffer)
+@ r1 = unused
+@ r2 = src
+function idct32_1d_4x32_pass1\suffix\()_neon
+        push            {lr}
+
+        @ idct16 clobbers q2-q3 (since it doesn't clobber q4-q7 at all
+        @ when doing the normal 16x16 idct), so move the idct32_odd coeffs
+        @ to q4-q5
+        vmov            q4,  q2
+        vmov            q5,  q3
+
+        @ Double stride of the input, since we only read every other line
+        mov             r12, #128
+        vmov.s16        d4,  #0
+
+        @ d16 = IN(0), d17 = IN(2) ... d31 = IN(30)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d4},  [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d4},  [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d4},  [r2,:64], r12
+.endr
+.endif
+
+        bl              idct16\suffix
+
+        @ Move the idct32_odd coeffs back into q2-q3 for idct32_odd;
+        @ the constants for a vmul with a lane must be in q0-q3.
+        vmov            q2,  q4
+        vmov            q3,  q5
+
+        @ Do four 4x4 transposes. Originally, d16-d31 contain the
+        @ 16 rows. Afterwards, d16-d19, d20-d23, d24-d27, d28-d31
+        @ contain the transposed 4x4 blocks.
+        transpose16_q_4x_4x4 q8,  q9,  q10, q11, q12, q13, q14, q15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31
+        @ Store the registers a, b, c, d horizontally, followed
+        @ by the same registers d, c, b, a mirrored.
+.macro store_rev a, b, c, d
+.irp i, \a, \b, \c, \d
+        vst1.16         {d\i}, [r0,:64]!
+        vrev64.16       d\i, d\i
+.endr
+.irp i, \d, \c, \b, \a
+        vst1.16         {d\i}, [r0,:64]!
+.endr
+.endm
+        store_rev       16, 20, 24, 28
+        store_rev       17, 21, 25, 29
+        store_rev       18, 22, 26, 30
+        store_rev       19, 23, 27, 31
+        sub             r0,  r0,  #256
+.purgem store_rev
+
+        @ Move r2 back to the start of the input, and move
+        @ to the first odd row
+.ifb \suffix
+        sub             r2,  r2,  r12, lsl #4
+.endif
+.ifc \suffix,_quarter
+        sub             r2,  r2,  r12, lsl #2
+.endif
+.ifc \suffix,_half
+        sub             r2,  r2,  r12, lsl #3
+.endif
+        add             r2,  r2,  #64
+
+        vmov.s16        d8,  #0
+        @ d16 = IN(1), d17 = IN(3) ... d31 = IN(31)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d8},  [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d8},  [r2,:64], r12
+.endr
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        vld1.16         {d\i}, [r2,:64]
+        vst1.16         {d8},  [r2,:64], r12
+.endr
+.endif
+
+        bl              idct32_odd\suffix
+
+        transpose16_q_4x_4x4 q15, q14, q13, q12, q11, q10, q9,  q8,  d31, d30, d29, d28, d27, d26, d25, d24, d23, d22, d21, d20, d19, d18, d17, d16
+
+        @ Store the registers a, b, c, d horizontally,
+        @ adding into the output first, and then mirrored, subtracted
+        @ from the output.
+.macro store_rev a, b, c, d
+.irp i, \a, \b, \c, \d
+        vld1.16         {d8},  [r0,:64]
+        vadd.s16        d8,  d8,  d\i
+        vst1.16         {d8},  [r0,:64]!
+        vrev64.16       d\i, d\i
+.endr
+.irp i, \d, \c, \b, \a
+        vld1.16         {d8},  [r0,:64]
+        vsub.s16        d8,  d8,  d\i
+        vst1.16         {d8},  [r0,:64]!
+.endr
+.endm
+
+        store_rev       31, 27, 23, 19
+        store_rev       30, 26, 22, 18
+        store_rev       29, 25, 21, 17
+        store_rev       28, 24, 20, 16
+.purgem store_rev
+        pop             {pc}
+endfunc
+.ltorg
+
+@ This is mostly the same as 4x32_pass1, but without the transpose,
+@ and use the source as temp buffer between the two idct passes, and
+@ add into the destination.
+@ r0 = dst
+@ r1 = dst stride
+@ r2 = src (temp buffer)
+function idct32_1d_4x32_pass2\suffix\()_neon
+        push            {lr}
+        vmov            q4,  q2
+        vmov            q5,  q3
+
+        mov             r12, #128
+        @ d16 = IN(0), d17 = IN(2) ... d31 = IN(30)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #4
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #2
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #3
+.endif
+
+        bl              idct16\suffix
+
+        vmov            q2,  q4
+        vmov            q3,  q5
+
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vst1.16         {d\i}, [r2,:64], r12
+.endr
+
+        sub             r2,  r2,  r12, lsl #4
+        add             r2,  r2,  #64
+
+        @ d16 = IN(1), d17 = IN(3) ... d31 = IN(31)
+.ifb \suffix
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #4
+.endif
+.ifc \suffix,_quarter
+.irp i, 16, 17, 18, 19
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #2
+.endif
+.ifc \suffix,_half
+.irp i, 16, 17, 18, 19, 20, 21, 22, 23
+        vld1.16         {d\i}, [r2,:64], r12
+.endr
+        sub             r2,  r2,  r12, lsl #3
+.endif
+        sub             r2,  r2,  #64
+
+        bl              idct32_odd\suffix
+
+        mov             r12, #128
+.macro load_acc_store a, b, c, d, neg=0
+        vld1.16         {d8},  [r2,:64], r12
+        vld1.16         {d9},  [r2,:64], r12
+.if \neg == 0
+        vadd.s16        d8,  d8,  d\a
+        vld1.16         {d10}, [r2,:64], r12
+        vadd.s16        d9,  d9,  d\b
+        vld1.16         {d11}, [r2,:64], r12
+        vadd.s16        d10, d10, d\c
+        vadd.s16        d11, d11, d\d
+.else
+        vsub.s16        d8,  d8,  d\a
+        vld1.16         {d10}, [r2,:64], r12
+        vsub.s16        d9,  d9,  d\b
+        vld1.16         {d11}, [r2,:64], r12
+        vsub.s16        d10, d10, d\c
+        vsub.s16        d11, d11, d\d
+.endif
+        vld1.32         {d12[]},  [r0,:32], r1
+        vld1.32         {d12[1]}, [r0,:32], r1
+        vrshr.s16       q4,  q4,  #6
+        vld1.32         {d13[]},  [r0,:32], r1
+        vrshr.s16       q5,  q5,  #6
+        vld1.32         {d13[1]}, [r0,:32], r1
+        sub             r0,  r0,  r1, lsl #2
+        vaddw.u8        q4,  q4,  d12
+        vaddw.u8        q5,  q5,  d13
+        vqmovun.s16     d8,  q4
+        vqmovun.s16     d9,  q5
+        vst1.32         {d8[0]},  [r0,:32], r1
+        vst1.32         {d8[1]},  [r0,:32], r1
+        vst1.32         {d9[0]},  [r0,:32], r1
+        vst1.32         {d9[1]},  [r0,:32], r1
+.endm
+        load_acc_store  31, 30, 29, 28
+        load_acc_store  27, 26, 25, 24
+        load_acc_store  23, 22, 21, 20
+        load_acc_store  19, 18, 17, 16
+        sub             r2,  r2,  r12
+        neg             r12, r12
+        load_acc_store  16, 17, 18, 19, 1
+        load_acc_store  20, 21, 22, 23, 1
+        load_acc_store  24, 25, 26, 27, 1
+        load_acc_store  28, 29, 30, 31, 1
+.purgem load_acc_store
+        pop             {pc}
+endfunc
+.endm
+
+idct32_funcs
+idct32_funcs _quarter
+idct32_funcs _half
+
+const min_eob_idct_idct_32, align=4
+        .short  0, 9, 34, 70, 135, 240, 336, 448
+endconst
+
+function ff_vp9_idct_idct_32x32_add_neon, export=1
+        cmp             r3,  #1
+        beq             idct32x32_dc_add_neon
+        push            {r4-r8,lr}
+        vpush           {q4-q6}
+
+        @ Align the stack, allocate a temp buffer
+T       mov             r7,  sp
+T       and             r7,  r7,  #15
+A       and             r7,  sp,  #15
+        add             r7,  r7,  #2048
+        sub             sp,  sp,  r7
+
+        mov             r4,  r0
+        mov             r5,  r1
+        mov             r6,  r2
+
+        movrel          r12, idct_coeffs
+        vld1.16         {q0-q1}, [r12,:128]!
+        vld1.16         {q2-q3}, [r12,:128]
+
+        cmp             r3,  #34
+        ble             idct32x32_quarter_add_neon
+        cmp             r3,  #135
+        ble             idct32x32_half_add_neon
+
+        movrel          r8,  min_eob_idct_idct_32 + 2
+
+.irp i, 0, 4, 8, 12, 16, 20, 24, 28
+        add             r0,  sp,  #(\i*64)
+.if \i > 0
+        ldrh_post       r1,  r8,  #2
+        cmp             r3,  r1
+        it              le
+        movle           r1,  #(32 - \i)/2
+        ble             1f
+.endif
+        add             r2,  r6,  #(\i*2)
+        bl              idct32_1d_4x32_pass1_neon
+.endr
+        b               3f
+
+1:
+        @ Write zeros to the temp buffer for pass 2
+        vmov.i16        q14, #0
+        vmov.i16        q15, #0
+2:
+        subs            r1,  r1,  #1
+.rept 4
+        vst1.16         {q14-q15}, [r0,:128]!
+.endr
+        bne             2b
+3:
+.irp i, 0, 4, 8, 12, 16, 20, 24, 28
+        add             r0,  r4,  #(\i)
+        mov             r1,  r5
+        add             r2,  sp,  #(\i*2)
+        bl              idct32_1d_4x32_pass2_neon
+.endr
+
+        add             sp,  sp,  r7
+        vpop            {q4-q6}
+        pop             {r4-r8,pc}
+endfunc
+
+.macro idct32_partial size
+function idct32x32_\size\()_add_neon
+.irp i, 0, 4
+        add             r0,  sp,  #(\i*64)
+.ifc \size,quarter
+.if \i == 4
+        cmp             r3,  #9
+        ble             1f
+.endif
+.endif
+        add             r2,  r6,  #(\i*2)
+        bl              idct32_1d_4x32_pass1_\size\()_neon
+.endr
+
+.ifc \size,half
+.irp i, 8, 12
+        add             r0,  sp,  #(\i*64)
+.if \i == 12
+        cmp             r3,  #70
+        ble             1f
+.endif
+        add             r2,  r6,  #(\i*2)
+        bl              idct32_1d_4x32_pass1_\size\()_neon
+.endr
+.endif
+        b               3f
+
+1:
+        @ Write zeros to the temp buffer for pass 2
+        vmov.i16        q14, #0
+        vmov.i16        q15, #0
+.rept 8
+        vst1.16         {q14-q15}, [r0,:128]!
+.endr
+
+3:
+.irp i, 0, 4, 8, 12, 16, 20, 24, 28
+        add             r0,  r4,  #(\i)
+        mov             r1,  r5
+        add             r2,  sp,  #(\i*2)
+        bl              idct32_1d_4x32_pass2_\size\()_neon
+.endr
+
+        add             sp,  sp,  r7
+        vpop            {q4-q6}
+        pop             {r4-r8,pc}
+endfunc
+.endm
+
+idct32_partial quarter
+idct32_partial half
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp9lpf_16bpp_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/vp9lpf_16bpp_neon.S
new file mode 100644
index 00000000000..7d2571dcc08
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp9lpf_16bpp_neon.S
@@ -0,0 +1,1044 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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/arm/asm.S"
+
+.macro transpose16_q_8x8 rq0, rq1, rq2, rq3, rq4, rq5, rq6, rq7, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15
+        vswp             \r1,  \r8  @ vtrn.64 \rq0, \rq4
+        vswp             \r3,  \r10 @ vtrn.64 \rq1, \rq5
+        vswp             \r5,  \r12 @ vtrn.64 \rq2, \rq6
+        vswp             \r7,  \r14 @ vtrn.64 \rq3, \rq7
+        vtrn.32          \rq0, \rq2
+        vtrn.32          \rq1, \rq3
+        vtrn.32          \rq4, \rq6
+        vtrn.32          \rq5, \rq7
+        vtrn.16          \rq0, \rq1
+        vtrn.16          \rq2, \rq3
+        vtrn.16          \rq4, \rq5
+        vtrn.16          \rq6, \rq7
+.endm
+
+.macro transpose16_4x4 r0, r1, r2, r3
+        vtrn.32          \r0, \r2
+        vtrn.32          \r1, \r3
+        vtrn.16          \r0, \r1
+        vtrn.16          \r2, \r3
+.endm
+
+@ Do a 4x4 transpose, using q registers for the subtransposes that don't
+@ need to address the indiviudal d registers.
+@ r0,r1 == rq0, r2,r3 == rq1
+.macro transpose16_q_4x4 rq0, rq1, r0, r1, r2, r3
+        vtrn.32         \rq0, \rq1
+        vtrn.16         \r0,  \r1
+        vtrn.16         \r2,  \r3
+.endm
+
+@ The input to and output from this macro is in the registers q8-q15,
+@ and q0-q7 are used as scratch registers.
+@ p3 = q8, p0 = q11, q0 = q12, q3 = q15
+.macro loop_filter_q wd
+        vdup.u16        q0,  r2          @ E
+        vdup.u16        q1,  r3          @ I
+
+        vabd.u16        q2,  q8,  q9     @ abs(p3 - p2)
+        vabd.u16        q3,  q9,  q10    @ abs(p2 - p1)
+        vabd.u16        q4,  q10, q11    @ abs(p1 - p0)
+        vabd.u16        q5,  q12, q13    @ abs(q0 - q1)
+        vabd.u16        q6,  q13, q14    @ abs(q1 - q2)
+        vabd.u16        q7,  q14, q15    @ abs(q2 - q3)
+        vmax.u16        q2,  q2,  q3
+        vmax.u16        q3,  q4,  q5
+        vmax.u16        q4,  q6,  q7
+        vabd.u16        q5,  q11, q12    @ abs(p0 - q0)
+        vmax.u16        q2,  q2,  q3
+        vadd.u16        q5,  q5,  q5     @ abs(p0 - q0) * 2
+        vabd.u16        q6,  q10, q13    @ abs(p1 - q1)
+        vmax.u16        q2,  q2,  q4     @ max(abs(p3 - p2), ..., abs(q2 - q3))
+        vshr.u16        q6,  q6,  #1
+        vcle.u16        q2,  q2,  q1     @ max(abs()) <= I
+        vadd.u16        q5,  q5,  q6     @ abs(p0 - q0) * 2 + abs(p1 - q1) >> 1
+        vcle.u16        q5,  q5,  q0
+        vand            q2,  q2,  q5     @ fm
+
+        vmovn.u16       d10, q2
+        vmov            r8,  r9,  d10
+        orrs            r8,  r8,  r9
+        @ If no pixels need filtering, just exit as soon as possible
+        beq             9f
+
+.if \wd >= 8
+        vdup.u16        q0,  r5
+
+        vabd.u16        q1,  q8,  q11    @ abs(p3 - p0)
+        vabd.u16        q3,  q9,  q11    @ abs(p2 - p0)
+        vabd.u16        q4,  q10, q11    @ abs(p1 - p0)
+        vabd.u16        q5,  q13, q12    @ abs(q1 - q0)
+        vabd.u16        q6,  q14, q12    @ abs(q2 - q0)
+        vabd.u16        q7,  q15, q12    @ abs(q3 - q0)
+        vmax.u16        q1,  q1,  q3
+        vmax.u16        q4,  q4,  q5
+        vmax.u16        q6,  q6,  q7
+        @ The rest of the calculation of flat8in is interleaved below
+.endif
+
+        @ Calculate the normal inner loop filter for 2 or 4 pixels
+        vabd.u16        q3,  q10, q11    @ abs(p1 - p0)
+.if \wd == 8
+        vmax.u16        q1,  q1,  q4
+.endif
+        vabd.u16        q4,  q13, q12    @ abs(q1 - q0)
+.if \wd == 8
+        vmax.u16        q1,  q1,  q6
+.endif
+
+        vsub.u16        q5,  q10, q13    @ p1 - q1
+        vmax.u16        q3,  q3,  q4     @ max(abs(p1 - p0), abs(q1 - q0))
+        vdup.u16        q4,  r4          @ H
+        vsub.u16        q6,  q12, q11    @ q0 - p0
+.if \wd == 8
+        vcle.u16        q1,  q1,  q0     @ flat8in
+.endif
+        vdup.u16        q0,  r6          @ left shift for saturation
+        vcle.u16        q3,  q3,  q4     @ !hev
+.if \wd == 8
+        vand            q1,  q1,  q2     @ flat8in && fm
+.endif
+        vneg.s16        q4,  q0          @ negative left shift after saturation
+        vqshl.s16       q5,  q5,  q0
+.if \wd == 8
+        vbic            q2,  q2,  q1     @ fm && !flat8in
+.endif
+        vmov.s16        q7,  #3
+        vand            q3,  q3,  q2     @ !hev && fm && !flat8in
+        vshl.s16        q5,  q5,  q4     @ av_clip_int2p(p1 - q1, BIT_DEPTH - 1)
+
+        vmul.s16        q6,  q6,  q7     @ 3 * (q0 - p0)
+        vbic            q5,  q5,  q3     @ if (!hev) av_clip_int2p = 0
+        vadd.s16        q6,  q6,  q5     @ 3 * (q0 - p0) [+ av_clip_int2p(p1 - q1)]
+        vmov.s16        q5,  #4
+        vqshl.s16       q6,  q6,  q0
+        vmov.s16        q0,  #3
+        vshl.s16        q6,  q6,  q4     @ av_clip_int2p(3 * (q0 - p0) [+ av_clip_int2p(p1 - q1)], BIT_DEPTH - 1) = f
+        vdup.u16        q4,  r7          @ max pixel value
+
+        vshr.u16        q4,  q4,  #1     @ (1 << (BIT_DEPTH - 1)) - 1)
+
+        vadd.s16        q5,  q6,  q5     @ f + 4
+        vadd.s16        q0,  q6,  q0     @ f + 3
+        vmov.s16        q6,  #0
+        vmin.s16        q5,  q5,  q4     @ FFMIN(f + 4, (1 << (BIT_DEPTH - 1)) - 1)
+        vmin.s16        q0,  q0,  q4     @ FFMIN(f + 3, (1 << (BIT_DEPTH - 1)) - 1)
+        vdup.u16        q4,  r7          @ max pixel value
+        vshr.s16        q5,  q5,  #3     @ f1
+        vshr.s16        q0,  q0,  #3     @ f2
+
+        vadd.s16        q0,  q11, q0     @ p0 + f2
+        vsub.s16        q7,  q12, q5     @ q0 - f1
+        vmin.s16        q0,  q0,  q4
+        vmin.s16        q7,  q7,  q4
+        vrshr.s16       q5,  q5,  #1     @ f = (f1 + 1) >> 1
+        vmax.s16        q0,  q0,  q6     @ out p0
+        vmax.s16        q7,  q7,  q6     @ out q0
+        vbit            q11, q0,  q2     @ if (fm && !flat8in)
+        vbit            q12, q7,  q2
+.if \wd >= 8
+        vmovn.u16       d4,  q1
+.endif
+
+        vadd.s16        q0,  q10, q5     @ p1 + f
+        vsub.s16        q7,  q13, q5     @ q1 - f
+.if \wd >= 8
+        vmov            r8,  r9,  d4
+.endif
+        vmin.s16        q0,  q0,  q4
+        vmin.s16        q7,  q7,  q4
+.if \wd >= 8
+        orrs            r8,  r8,  r9
+.endif
+        vmax.s16        q0,  q0,  q6     @ out p1
+        vmax.s16        q7,  q7,  q6     @ out q1
+        vbit            q10, q0,  q3     @ if (!hev && fm && !flat8in)
+        vbit            q13, q7,  q3
+
+.if \wd >= 8
+        @ If no pixels need flat8in, jump to a writeout of the inner 4 pixels
+        beq             6f
+
+        @ flat8in
+        vadd.u16        q2,  q8,  q9
+        vadd.u16        q3,  q10, q13
+        vadd.u16        q4,  q8,  q10
+        vadd.u16        q5,  q11, q14
+        vadd.u16        q0,  q2,  q2
+        vadd.u16        q0,  q0,  q11
+        vadd.u16        q0,  q0,  q12
+        vadd.u16        q0,  q0,  q4
+        vsub.s16        q3,  q3,  q2
+        vsub.s16        q5,  q5,  q4
+        vrshr.u16       q6,  q0,  #3     @ out p2
+
+        vadd.u16        q0,  q0,  q3
+        vadd.u16        q2,  q8,  q11
+        vadd.u16        q3,  q12, q15
+        vrshr.u16       q7,  q0,  #3     @ out p1
+
+        vadd.u16        q0,  q0,  q5
+        vsub.s16        q3,  q3,  q2
+        vadd.u16        q4,  q9,  q12
+        vbit            q9,  q6,  q1
+        vadd.u16        q5,  q13, q15
+        vrshr.u16       q6,  q0,  #3     @ out p0
+
+        vadd.u16        q0,  q0,  q3
+        vsub.s16        q5,  q5,  q4
+        vadd.u16        q2,  q10, q13
+        vbit            q10, q7,  q1
+        vadd.u16        q3,  q14, q15
+        vrshr.u16       q7,  q0,  #3     @ out q0
+
+        vadd.u16        q0,  q0,  q5
+        vsub.s16        q3,  q3,  q2
+        vbit            q11, q6,  q1
+        vrshr.u16       q6,  q0,  #3     @ out q1
+
+        vadd.u16        q0,  q0,  q3
+        vbit            q12, q7,  q1
+        vrshr.u16       q7,  q0,  #3     @ out q2
+        vbit            q13, q6,  q1
+        vbit            q14, q7,  q1
+.endif
+.endm
+
+@ The input to and output from this macro is in the registers d16-d31,
+@ and d0-d7 are used as scratch registers.
+@ p7 = d16 .. p3 = d20, p0 = d23, q0 = d24, q3 = d27, q7 = d31
+@ Depending on the width of the loop filter, we either use d16-d19
+@ and d28-d31 as temp registers, or d8-d15.
+@ In practice, this is only ever instantiated once, so the macro parameters
+@ could be hardcoded, but keeping them as is, to keep similarities to the
+@ 8 bpp and aarch64 versions.
+.macro loop_filter wd, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8
+        vdup.u16        d0,  r2          @ E
+        vdup.u16        d2,  r3          @ I
+
+        vabd.u16        d4,  d20, d21    @ abs(p3 - p2)
+        vabd.u16        d5,  d21, d22    @ abs(p2 - p1)
+        vabd.u16        d6,  d22, d23    @ abs(p1 - p0)
+        vabd.u16        d7,  d24, d25    @ abs(q0 - q1)
+        vabd.u16        \tmp1,  d25, d26 @ abs(q1 - q2)
+        vabd.u16        \tmp2,  d26, d27 @ abs(q2 - q3)
+        vmax.u16        d4,  d4,  d5
+        vmax.u16        d5,  d6,  d7
+        vmax.u16        \tmp1,  \tmp1,  \tmp2
+        vabd.u16        d6,  d23, d24    @ abs(p0 - q0)
+        vmax.u16        d4,  d4,  d5
+        vadd.u16        d6,  d6,  d6     @ abs(p0 - q0) * 2
+        vabd.u16        d5,  d22, d25    @ abs(p1 - q1)
+        vmax.u16        d4,  d4,  \tmp1  @ max(abs(p3 - p2), ..., abs(q2 - q3))
+        vshr.u16        d5,  d5,  #1
+        vcle.u16        d4,  d4,  d2     @ max(abs()) <= I
+        vadd.u16        d6,  d6,  d5     @ abs(p0 - q0) * 2 + abs(p1 - q1) >> 1
+        vcle.u16        d6,  d6,  d0
+        vand            d4,  d4,  d6     @ fm
+
+        vdup.u16        d3,  r4          @ H
+        vmov            r8,  r9,  d4
+        orrs            r8,  r8,  r9
+        @ If no pixels need filtering, just exit as soon as possible
+        beq             9f
+
+.if \wd >= 8
+        vdup.u16        d0,  r5
+
+        vabd.u16        d6,  d20, d23    @ abs(p3 - p0)
+        vabd.u16        d2,  d21, d23    @ abs(p2 - p0)
+        vabd.u16        d1,  d22, d23    @ abs(p1 - p0)
+        vabd.u16        \tmp1,  d25, d24 @ abs(q1 - q0)
+        vabd.u16        \tmp2,  d26, d24 @ abs(q2 - q0)
+        vabd.u16        \tmp3,  d27, d24 @ abs(q3 - q0)
+        vmax.u16        d6,  d6,  d2
+        vmax.u16        d1,  d1,  \tmp1
+        vmax.u16        \tmp2,  \tmp2,  \tmp3
+.if \wd == 16
+        vabd.u16        d7,  d16, d23    @ abs(p7 - p0)
+        vmax.u16        d6,  d6,  d1
+        vabd.u16        d2,  d17, d23    @ abs(p6 - p0)
+        vmax.u16        d6,  d6,  \tmp2
+        vabd.u16        d1,  d18, d23    @ abs(p5 - p0)
+        vcle.u16        d6,  d6,  d0     @ flat8in
+        vabd.u16        d8,  d19, d23    @ abs(p4 - p0)
+        vand            d6,  d6,  d4     @ flat8in && fm
+        vabd.u16        d9,  d28, d24    @ abs(q4 - q0)
+        vbic            d4,  d4,  d6     @ fm && !flat8in
+        vabd.u16        d10, d29, d24    @ abs(q5 - q0)
+        vabd.u16        d11, d30, d24    @ abs(q6 - q0)
+        vabd.u16        d12, d31, d24    @ abs(q7 - q0)
+
+        vmax.u16        d7,  d7,  d2
+        vmax.u16        d1,  d1,  d8
+        vmax.u16        d9,  d9,  d10
+        vmax.u16        d11, d11, d12
+        @ The rest of the calculation of flat8out is interleaved below
+.else
+        @ The rest of the calculation of flat8in is interleaved below
+.endif
+.endif
+
+        @ Calculate the normal inner loop filter for 2 or 4 pixels
+        vabd.u16        d5,  d22, d23           @ abs(p1 - p0)
+.if \wd == 16
+        vmax.u16        d7,  d7,  d1
+        vmax.u16        d9,  d9,  d11
+.elseif \wd == 8
+        vmax.u16        d6,  d6,  d1
+.endif
+        vabd.u16        d1,  d25, d24           @ abs(q1 - q0)
+.if \wd == 16
+        vmax.u16        d7,  d7,  d9
+.elseif \wd == 8
+        vmax.u16        d6,  d6,  \tmp2
+.endif
+        vdup.u16        \tmp2,  r6              @ left shift for saturation
+        vsub.u16        \tmp1,  d22, d25        @ p1 - q1
+        vneg.s16        \tmp6,  \tmp2           @ negative left shift after saturation
+        vmax.u16        d5,  d5,  d1            @ max(abs(p1 - p0), abs(q1 - q0))
+        vsub.u16        \tmp3,   d24, d23       @ q0 - p0
+        vmov.s16        \tmp5,  #3
+.if \wd == 8
+        vcle.u16        d6,  d6,  d0            @ flat8in
+.endif
+        vcle.u16        d5,  d5,  d3            @ !hev
+.if \wd == 8
+        vand            d6,  d6,  d4            @ flat8in && fm
+.endif
+        vqshl.s16       \tmp1,  \tmp1,  \tmp2
+.if \wd == 16
+        vcle.u16        d7,  d7,  d0            @ flat8out
+.elseif \wd == 8
+        vbic            d4,  d4,  d6            @ fm && !flat8in
+.endif
+        vand            d5,  d5,  d4            @ !hev && fm && !flat8in
+.if \wd == 16
+        vand            d7,  d7,  d6            @ flat8out && flat8in && fm
+.endif
+        vshl.s16        \tmp1,  \tmp1,  \tmp6   @ av_clip_int2p(p1 - q1, BIT_DEPTH - 1)
+
+        vmul.s16        \tmp3,  \tmp3,  \tmp5   @ 3 * (q0 - p0)
+        vbic            \tmp1,  \tmp1,   d5     @ if (!hev) av_clip_int2p = 0
+        vmov.s16        d2,  #4
+        vadd.s16        \tmp3,  \tmp3,  \tmp1   @ 3 * (q0 - p0) [+ av_clip_int2p(p1 - q1)]
+        vmov.s16        d3,  #3
+        vqshl.s16       \tmp1,  \tmp3,  \tmp2
+        vmov.s16        \tmp5,  #0
+        vshl.s16        \tmp1,  \tmp1,  \tmp6   @ av_clip_int2p(3 * (q0 - p0) [+ av_clip_int2p(p1 - q1)], BIT_DEPTH - 1) = f
+        vdup.u16        \tmp6,  r7              @ max pixel value
+.if \wd == 16
+        vbic            d6,  d6,  d7            @ fm && flat8in && !flat8out
+.endif
+
+        vshr.u16        \tmp2,  \tmp6,  #1      @ (1 << (BIT_DEPTH - 1)) - 1
+
+        vadd.s16        \tmp3,  \tmp1,  d2      @ f + 4
+        vadd.s16        \tmp4,  \tmp1,  d3      @ f + 3
+        vmin.s16        \tmp3,  \tmp3,  \tmp2   @ FFMIN(f + 4, (1 << (BIT_DEPTH - 1)) - 1)
+        vmin.s16        \tmp4,  \tmp4,  \tmp2   @ FFMIN(f + 3, (1 << (BIT_DEPTH - 1)) - 1)
+        vshr.s16        \tmp3,  \tmp3,  #3      @ f1
+        vshr.s16        \tmp4,  \tmp4,  #3      @ f2
+
+        vadd.s16        d0,  d23, \tmp4         @ p0 + f2
+        vsub.s16        d2,  d24, \tmp3         @ q0 - f1
+        vmin.s16        d0,  d0,  \tmp6
+        vmin.s16        d2,  d2,  \tmp6
+        vrshr.s16       \tmp3,  \tmp3,  #1      @ f = (f1 + 1) >> 1
+        vmax.s16        d0,  d0,  \tmp5         @ out p0
+        vmax.s16        d2,  d2,  \tmp5         @ out q0
+        vbit            d23, d0,  d4            @ if (fm && !flat8in)
+        vbit            d24, d2,  d4
+
+        vadd.s16        d0,  d22, \tmp3         @ p1 + f
+        vsub.s16        d2,  d25, \tmp3         @ q1 - f
+.if \wd >= 8
+        vmov            r8,  r9,  d6
+.endif
+        vmin.s16        d0,  d0,  \tmp6
+        vmin.s16        d2,  d2,  \tmp6
+.if \wd >= 8
+        orrs            r8,  r8,  r9
+.endif
+        vmax.s16        d0,  d0,  \tmp5         @ out p1
+        vmax.s16        d2,  d2,  \tmp5         @ out q1
+        vbit            d22, d0,  d5            @ if (!hev && fm && !flat8in)
+        vbit            d25, d2,  d5
+
+.if \wd >= 8
+        @ If no pixels need flat8in, jump to flat8out
+        @ (or to a writeout of the inner 4 pixels, for wd=8)
+        beq             6f
+
+        @ flat8in
+        vadd.u16        \tmp1,  d20, d21
+        vadd.u16        \tmp3,  d22, d25
+        vadd.u16        \tmp5,  d20, d22
+        vadd.u16        \tmp7,  d23, d26
+        vadd.u16        d0,  \tmp1,  \tmp1
+        vadd.u16        d0,  d0,  d23
+        vadd.u16        d0,  d0,  d24
+        vadd.u16        d0,  d0,  \tmp5
+        vsub.s16        \tmp3,  \tmp3,  \tmp1
+        vsub.s16        \tmp7,  \tmp7,  \tmp5
+        vrshr.u16       d2,  d0,  #3            @ out p2
+
+        vadd.u16        d0,  d0,  \tmp3
+        vadd.u16        \tmp1,  d20, d23
+        vadd.u16        \tmp3,  d24, d27
+        vrshr.u16       d3,  d0,  #3            @ out p1
+
+        vadd.u16        d0,  d0,  \tmp7
+        vsub.s16        \tmp3,  \tmp3,  \tmp1
+        vadd.u16        \tmp5,  d21, d24
+        vadd.u16        \tmp7,  d25, d27
+        vrshr.u16       d4,  d0,  #3            @ out p0
+
+        vadd.u16        d0,  d0,  \tmp3
+        vsub.s16        \tmp7,  \tmp7,  \tmp5
+        vadd.u16        \tmp1,  d22, d25
+        vadd.u16        \tmp3,  d26, d27
+        vrshr.u16       d5,  d0,  #3            @ out d0
+
+        vadd.u16        d0,  d0,  \tmp7
+        vsub.s16        \tmp3,  \tmp3,  \tmp1
+        vrshr.u16       \tmp5,  d0,  #3         @ out q1
+
+        vadd.u16        d0,  d0,  \tmp3
+        @ The output here is written back into the input registers. This doesn't
+        @ matter for the flat8out part below, since we only update those pixels
+        @ which won't be touched below.
+        vbit            d21, d2,  d6
+        vbit            d22, d3,  d6
+        vbit            d23, d4,  d6
+        vrshr.u16       \tmp6,  d0,  #3         @ out q2
+        vbit            d24, d5,  d6
+        vbit            d25, \tmp5,  d6
+        vbit            d26, \tmp6,  d6
+.endif
+.if \wd == 16
+6:
+        vorr            d2,  d6,  d7
+        vmov            r8,  r9,  d2
+        orrs            r8,  r8,  r9
+        @ If no pixels needed flat8in nor flat8out, jump to a
+        @ writeout of the inner 4 pixels
+        beq             7f
+        vmov            r8,  r9,  d7
+        orrs            r8,  r8,  r9
+        @ If no pixels need flat8out, jump to a writeout of the inner 6 pixels
+        beq             8f
+
+        @ flat8out
+        @ This writes all outputs into d2-d17 (skipping d6 and d16).
+        @ If this part is skipped, the output is read from d21-d26 (which is the input
+        @ to this section).
+        vshl.u16        d0,  d16, #3  @ 8 * d16
+        vsub.u16        d0,  d0,  d16 @ 7 * d16
+        vadd.u16        d0,  d0,  d17
+        vadd.u16        d8,  d17, d18
+        vadd.u16        d10, d19, d20
+        vadd.s16        d0,  d0,  d8
+        vadd.u16        d8,  d16, d17
+        vadd.u16        d12, d21, d22
+        vadd.s16        d0,  d0,  d10
+        vadd.u16        d10, d18, d25
+        vadd.u16        d14, d23, d24
+        vsub.s16        d10, d10, d8
+        vadd.s16        d0,  d0,  d12
+        vadd.s16        d0,  d0,  d14
+        vadd.u16        d12, d16, d18
+        vadd.u16        d14, d19, d26
+        vrshr.u16       d2,  d0,  #4
+
+        vadd.s16        d0,  d0,  d10
+        vadd.u16        d8,  d16, d19
+        vadd.u16        d10, d20, d27
+        vsub.s16        d14, d14, d12
+        vbif            d2,  d17, d7
+        vrshr.u16       d3,  d0,  #4
+
+        vadd.s16        d0,  d0,  d14
+        vadd.u16        d12, d16, d20
+        vadd.u16        d14, d21, d28
+        vsub.s16        d10, d10, d8
+        vbif            d3,  d18, d7
+        vrshr.u16       d4,  d0,  #4
+
+        vadd.s16        d0,  d0,  d10
+        vadd.u16        d8,  d16, d21
+        vadd.u16        d10, d22, d29
+        vsub.s16        d14, d14, d12
+        vbif            d4,  d19, d7
+        vrshr.u16       d5,  d0,  #4
+
+        vadd.s16        d0,  d0,  d14
+        vadd.u16        d12, d16, d22
+        vadd.u16        d14, d23, d30
+        vsub.s16        d10, d10, d8
+        vbif            d5,  d20, d7
+        vrshr.u16       d6,  d0,  #4
+
+        vadd.s16        d0,  d0,  d10
+        vadd.u16        d10, d16, d23
+        vsub.s16        d14, d14, d12
+        vadd.u16        d12, d24, d31
+        vbif            d6,  d21, d7
+        vrshr.u16       d8,  d0,  #4
+
+        vadd.s16        d0,  d0,  d14
+        vsub.s16        d10, d12, d10
+        vadd.u16        d12, d17, d24
+        vadd.u16        d14, d25, d31
+        vbif            d8,  d22, d7
+        vrshr.u16       d9,  d0,  #4
+
+        vadd.s16        d0,  d0,  d10
+        vsub.s16        d14, d14, d12
+        vadd.u16        d12, d26, d31
+        vbif            d9,  d23, d7
+        vrshr.u16       d10, d0,  #4
+
+        vadd.s16        d0,  d0,  d14
+        vadd.u16        d14, d18, d25
+        vadd.u16        d18, d19, d26
+        vsub.s16        d12, d12, d14
+        vadd.u16        d14, d27, d31
+        vbif            d10, d24, d7
+        vrshr.u16       d11, d0,  #4
+
+        vadd.s16        d0,  d0,  d12
+        vadd.u16        d12, d20, d27
+        vsub.s16        d14, d14, d18
+        vadd.u16        d18, d28, d31
+        vbif            d11, d25, d7
+        vsub.s16        d18, d18, d12
+        vrshr.u16       d12, d0,  #4
+
+        vadd.s16        d0,  d0,  d14
+        vadd.u16        d14, d21, d28
+        vadd.u16        d20, d29, d31
+        vbif            d12, d26, d7
+        vrshr.u16       d13, d0,  #4
+
+        vadd.s16        d0,  d0,  d18
+        vsub.s16        d20, d20, d14
+        vadd.u16        d18, d22, d29
+        vadd.u16        d22, d30, d31
+        vbif            d13, d27, d7
+        vrshr.u16       d14, d0,  #4
+
+        vadd.s16        d0,  d0,  d20
+        vsub.s16        d22, d22, d18
+        vbif            d14, d28, d7
+        vrshr.u16       d15, d0,  #4
+
+        vadd.s16        d0,  d0,  d22
+        vbif            d15, d29, d7
+        vrshr.u16       d17, d0,  #4
+        vbif            d17, d30, d7
+.endif
+.endm
+
+.macro loop_filter_q_4
+        loop_filter_q   4
+.endm
+
+.macro loop_filter_q_8
+        loop_filter_q   8
+.endm
+
+.macro loop_filter_16
+        loop_filter     16, d8,  d9,  d10, d11, d12, d13, d14, d15
+.endm
+
+
+@ The public functions in this file have got the following signature:
+@ void loop_filter(uint8_t *dst, ptrdiff_t stride, int mb_lim, int lim, int hev_thr);
+
+.macro bpp_frontend func, bpp
+function ff_\func\()_\bpp\()_neon, export=1
+        push            {r4-r9,lr}
+        ldr             r4,  [sp, #28]
+        vpush           {q4-q7}
+        lsl             r2,  r2,  #\bpp - 8
+        lsl             r3,  r3,  #\bpp - 8
+        lsl             r4,  r4,  #\bpp - 8
+        mov             r5,  #1 << (\bpp - 8)
+        mov             r6,  #16 - \bpp
+        movw            r7,  #((1 << \bpp) - 1)
+        bl              \func\()_16_neon
+        vpop            {q4-q7}
+        pop             {r4-r9,pc}
+endfunc
+.endm
+
+.macro bpp_frontends func
+        bpp_frontend    \func, 10
+        bpp_frontend    \func, 12
+.endm
+
+.macro bpp_frontend_rep func, suffix, int_suffix, rep, dir, bpp
+function ff_\func\()_\suffix\()_\bpp\()_neon, export=1
+        push            {r4-r9,lr}
+        ldr             r4,  [sp, #28]
+        vpush           {q4-q7}
+        lsl             r2,  r2,  #\bpp - 8
+        lsl             r3,  r3,  #\bpp - 8
+        lsl             r4,  r4,  #\bpp - 8
+        mov             r5,  #1 << (\bpp - 8)
+        mov             r6,  #16 - \bpp
+        movw            r7,  #((1 << \bpp) - 1)
+        bl              \func\()_\int_suffix\()_16_neon
+.ifc \dir,h
+        add             r0,  r0,  r1, lsl #2
+.else
+        add             r0,  r0,  #8
+.endif
+        bl              \func\()_\int_suffix\()_16_neon
+.if \rep >= 4
+.ifc \dir,h
+        add             r0,  r0,  r1, lsl #2
+        bl              \func\()_\int_suffix\()_16_neon
+        add             r0,  r0,  r1, lsl #2
+        bl              \func\()_\int_suffix\()_16_neon
+.else
+        add             r0,  r0,  #8
+        bl              \func\()_\int_suffix\()_16_neon
+        add             r0,  r0,  #8
+        bl              \func\()_\int_suffix\()_16_neon
+.endif
+.endif
+        vpop            {q4-q7}
+        pop             {r4-r9,pc}
+endfunc
+.endm
+
+.macro bpp_frontends_rep func, suffix, int_suffix, rep, dir
+        bpp_frontend_rep \func, \suffix, \int_suffix, \rep, \dir, 10
+        bpp_frontend_rep \func, \suffix, \int_suffix, \rep, \dir, 12
+.endm
+
+.macro bpp_frontend_mix2 wd1, wd2, dir, bpp
+function ff_vp9_loop_filter_\dir\()_\wd1\()\wd2\()_16_\bpp\()_neon, export=1
+        push            {r4-r9,lr}
+        ldr             r4,  [sp, #28]
+        vpush           {q4-q7}
+        push            {r2, r3, r4}
+        and             r2,  r2,  #0xff
+        and             r3,  r3,  #0xff
+        and             r4,  r4,  #0xff
+        lsl             r2,  r2,  #\bpp - 8
+        lsl             r3,  r3,  #\bpp - 8
+        lsl             r4,  r4,  #\bpp - 8
+        mov             r5,  #1 << (\bpp - 8)
+        mov             r6,  #16 - \bpp
+        movw            r7,  #((1 << \bpp) - 1)
+        bl              vp9_loop_filter_\dir\()_\wd1\()_8_16_neon
+.ifc \dir,h
+        add             r0,  r0,  r1, lsl #3
+.else
+        add             r0,  r0,  #16
+.endif
+        pop             {r2, r3, r4}
+        lsr             r2,  r2,  #8
+        lsr             r3,  r3,  #8
+        lsr             r4,  r4,  #8
+        lsl             r2,  r2,  #\bpp - 8
+        lsl             r3,  r3,  #\bpp - 8
+        lsl             r4,  r4,  #\bpp - 8
+        bl              vp9_loop_filter_\dir\()_\wd2\()_8_16_neon
+        vpop            {q4-q7}
+        pop             {r4-r9,pc}
+endfunc
+.endm
+
+.macro bpp_frontends_mix2 wd1, wd2
+        bpp_frontend_mix2 \wd1, \wd2, v, 10
+        bpp_frontend_mix2 \wd1, \wd2, v, 12
+        bpp_frontend_mix2 \wd1, \wd2, h, 10
+        bpp_frontend_mix2 \wd1, \wd2, h, 12
+.endm
+
+function vp9_loop_filter_v_4_8_16_neon
+        sub             r12, r0,  r1, lsl #2
+        vld1.16         {q8},  [r12,:128], r1 @ p3
+        vld1.16         {q12}, [r0, :128], r1 @ q0
+        vld1.16         {q9},  [r12,:128], r1 @ p2
+        vld1.16         {q13}, [r0, :128], r1 @ q1
+        vld1.16         {q10}, [r12,:128], r1 @ p1
+        vld1.16         {q14}, [r0, :128], r1 @ q2
+        vld1.16         {q11}, [r12,:128], r1 @ p0
+        vld1.16         {q15}, [r0, :128], r1 @ q3
+        sub             r0,  r0,  r1, lsl #2
+        sub             r12, r12, r1, lsl #1
+
+        loop_filter_q_4
+
+        vst1.16         {q10}, [r12,:128], r1
+        vst1.16         {q12}, [r0, :128], r1
+        vst1.16         {q11}, [r12,:128], r1
+        vst1.16         {q13}, [r0, :128], r1
+        sub             r0,  r0,  r1, lsl #1
+9:
+        bx              lr
+endfunc
+
+bpp_frontends vp9_loop_filter_v_4_8
+
+
+function vp9_loop_filter_h_4_8_16_neon
+        sub             r12, r0,  #8
+        add             r0,  r12, r1, lsl #2
+        vld1.16         {q8},  [r12,:64], r1
+        vld1.16         {q12}, [r0, :64], r1
+        vld1.16         {q9},  [r12,:64], r1
+        vld1.16         {q13}, [r0, :64], r1
+        vld1.16         {q10}, [r12,:64], r1
+        vld1.16         {q14}, [r0, :64], r1
+        vld1.16         {q11}, [r12,:64], r1
+        vld1.16         {q15}, [r0, :64], r1
+
+        sub             r12, r12, r1, lsl #2
+        sub             r0,  r0,  r1, lsl #2
+        @ Move r0/r12 forward by 2 pixels; we don't need to rewrite the
+        @ outermost 2 pixels since they aren't changed.
+        add             r12, r12, #4
+        add             r0,  r0,  #4
+
+        transpose16_q_8x8 q8, q9, q10, q11, q12, q13, q14, q15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31
+
+        loop_filter_q_4
+
+        @ We only will write the mid 4 pixels back; after the loop filter,
+        @ these are in q10, q11, q12, q13, ordered as rows (8x4 pixels).
+        @ We need to transpose them to columns, done with a
+        @ 4x4 transpose (which in practice is two 4x4 transposes of the two
+        @ 4x4 halves of the 8x4 pixels; into 4x8 pixels).
+        transpose16_4x4 q10, q11, q12, q13
+
+        vst1.16         {d20}, [r12], r1
+        vst1.16         {d21}, [r0],  r1
+        vst1.16         {d22}, [r12], r1
+        vst1.16         {d23}, [r0],  r1
+        vst1.16         {d24}, [r12], r1
+        vst1.16         {d25}, [r0],  r1
+        vst1.16         {d26}, [r12], r1
+        vst1.16         {d27}, [r0],  r1
+        sub             r12, r12, r1, lsl #2
+9:
+        add             r0,  r12, #4
+        bx              lr
+endfunc
+
+bpp_frontends vp9_loop_filter_h_4_8
+
+
+function vp9_loop_filter_v_8_8_16_neon
+        sub             r12, r0,  r1, lsl #2
+        vld1.16         {q8},  [r12,:128], r1 @ p3
+        vld1.16         {q12}, [r0, :128], r1 @ q0
+        vld1.16         {q9},  [r12,:128], r1 @ p2
+        vld1.16         {q13}, [r0, :128], r1 @ q1
+        vld1.16         {q10}, [r12,:128], r1 @ p1
+        vld1.16         {q14}, [r0, :128], r1 @ q2
+        vld1.16         {q11}, [r12,:128], r1 @ p0
+        vld1.16         {q15}, [r0, :128], r1 @ q3
+        sub             r12, r12, r1, lsl #2
+        sub             r0,  r0,  r1, lsl #2
+        add             r12, r12, r1
+
+        loop_filter_q_8
+
+        vst1.16         {q9},  [r12,:128], r1
+        vst1.16         {q12}, [r0, :128], r1
+        vst1.16         {q10}, [r12,:128], r1
+        vst1.16         {q13}, [r0, :128], r1
+        vst1.16         {q11}, [r12,:128], r1
+        vst1.16         {q14}, [r0, :128], r1
+        sub             r0,  r0,  r1, lsl #1
+        sub             r0,  r0,  r1
+9:
+        bx              lr
+6:
+        sub             r12, r0,  r1, lsl #1
+        vst1.16         {q10}, [r12,:128], r1
+        vst1.16         {q12}, [r0, :128], r1
+        vst1.16         {q11}, [r12,:128], r1
+        vst1.16         {q13}, [r0, :128], r1
+        sub             r0,  r0,  r1, lsl #1
+        bx              lr
+endfunc
+
+bpp_frontends vp9_loop_filter_v_8_8
+
+
+function vp9_loop_filter_h_8_8_16_neon
+        sub             r12, r0,  #8
+        add             r0,  r12, r1, lsl #2
+        vld1.16         {q8},  [r12,:64], r1
+        vld1.16         {q12}, [r0, :64], r1
+        vld1.16         {q9},  [r12,:64], r1
+        vld1.16         {q13}, [r0, :64], r1
+        vld1.16         {q10}, [r12,:64], r1
+        vld1.16         {q14}, [r0, :64], r1
+        vld1.16         {q11}, [r12,:64], r1
+        vld1.16         {q15}, [r0, :64], r1
+
+        sub             r12, r12, r1, lsl #2
+        sub             r0,  r0,  r1, lsl #2
+
+        transpose16_q_8x8 q8, q9, q10, q11, q12, q13, q14, q15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31
+
+        loop_filter_q_8
+
+        @ Even though only 6 pixels per row have been changed, we write the
+        @ full 8 pixel registers.
+        transpose16_q_8x8 q8, q9, q10, q11, q12, q13, q14, q15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31
+
+        vst1.16         {q8},  [r12,:64], r1
+        vst1.16         {q12}, [r0, :64], r1
+        vst1.16         {q9},  [r12,:64], r1
+        vst1.16         {q13}, [r0, :64], r1
+        vst1.16         {q10}, [r12,:64], r1
+        vst1.16         {q14}, [r0, :64], r1
+        vst1.16         {q11}, [r12,:64], r1
+        vst1.16         {q15}, [r0, :64], r1
+        sub             r12, r12, r1, lsl #2
+9:
+        add             r0,  r12, #8
+        bx              lr
+6:
+        @ If we didn't need to do the flat8in part, we use the same writeback
+        @ as in loop_filter_h_4_8.
+        add             r12, r12, #4
+        add             r0,  r0,  #4
+        transpose16_4x4 q10, q11, q12, q13
+
+        vst1.16         {d20}, [r12], r1
+        vst1.16         {d21}, [r0],  r1
+        vst1.16         {d22}, [r12], r1
+        vst1.16         {d23}, [r0],  r1
+        vst1.16         {d24}, [r12], r1
+        vst1.16         {d25}, [r0],  r1
+        vst1.16         {d26}, [r12], r1
+        vst1.16         {d27}, [r0],  r1
+        sub             r12, r12, r1, lsl #2
+        add             r0,  r12, #4
+        bx              lr
+endfunc
+
+bpp_frontends vp9_loop_filter_h_8_8
+
+bpp_frontends_mix2 4, 4
+bpp_frontends_mix2 4, 8
+bpp_frontends_mix2 8, 4
+bpp_frontends_mix2 8, 8
+
+function vp9_loop_filter_v_16_4_16_neon
+        sub             r12, r0,  r1, lsl #3
+        @ Read p7-p0 using r12 and q0-q7 using r0
+        vld1.16         {d16}, [r12,:64], r1 @ p7
+        vld1.16         {d24}, [r0, :64], r1 @ q0
+        vld1.16         {d17}, [r12,:64], r1 @ p6
+        vld1.16         {d25}, [r0, :64], r1 @ q1
+        vld1.16         {d18}, [r12,:64], r1 @ p5
+        vld1.16         {d26}, [r0, :64], r1 @ q2
+        vld1.16         {d19}, [r12,:64], r1 @ p4
+        vld1.16         {d27}, [r0, :64], r1 @ q3
+        vld1.16         {d20}, [r12,:64], r1 @ p3
+        vld1.16         {d28}, [r0, :64], r1 @ q4
+        vld1.16         {d21}, [r12,:64], r1 @ p2
+        vld1.16         {d29}, [r0, :64], r1 @ q5
+        vld1.16         {d22}, [r12,:64], r1 @ p1
+        vld1.16         {d30}, [r0, :64], r1 @ q6
+        vld1.16         {d23}, [r12,:64], r1 @ p0
+        vld1.16         {d31}, [r0, :64], r1 @ q7
+        sub             r12, r12, r1, lsl #3
+        sub             r0,  r0,  r1, lsl #3
+        add             r12, r12, r1
+
+        loop_filter_16
+
+        @ If we did the flat8out part, we get the output in
+        @ d2-d17 (skipping d7 and d16). r12 points to r0 - 7 * stride,
+        @ store d2-d9 there, and d10-d17 into r0.
+        vst1.16         {d2},  [r12,:64], r1
+        vst1.16         {d10}, [r0, :64], r1
+        vst1.16         {d3},  [r12,:64], r1
+        vst1.16         {d11}, [r0, :64], r1
+        vst1.16         {d4},  [r12,:64], r1
+        vst1.16         {d12}, [r0, :64], r1
+        vst1.16         {d5},  [r12,:64], r1
+        vst1.16         {d13}, [r0, :64], r1
+        vst1.16         {d6},  [r12,:64], r1
+        vst1.16         {d14}, [r0, :64], r1
+        vst1.16         {d8},  [r12,:64], r1
+        vst1.16         {d15}, [r0, :64], r1
+        vst1.16         {d9},  [r12,:64], r1
+        vst1.16         {d17}, [r0, :64], r1
+        sub             r0,  r0,  r1, lsl #3
+        add             r0,  r0,  r1
+
+9:
+        bx              lr
+
+8:
+        add             r12, r12, r1, lsl #2
+        @ If we didn't do the flat8out part, the output is left in the
+        @ input registers.
+        vst1.16         {d21}, [r12,:64], r1
+        vst1.16         {d24}, [r0, :64], r1
+        vst1.16         {d22}, [r12,:64], r1
+        vst1.16         {d25}, [r0, :64], r1
+        vst1.16         {d23}, [r12,:64], r1
+        vst1.16         {d26}, [r0, :64], r1
+        sub             r0,  r0,  r1, lsl #1
+        sub             r0,  r0,  r1
+        bx              lr
+7:
+        sub             r12, r0,  r1, lsl #1
+        vst1.16         {d22}, [r12,:64], r1
+        vst1.16         {d24}, [r0, :64], r1
+        vst1.16         {d23}, [r12,:64], r1
+        vst1.16         {d25}, [r0, :64], r1
+        sub             r0,  r0,  r1, lsl #1
+        bx              lr
+endfunc
+
+bpp_frontends_rep vp9_loop_filter_v_16, 8,  4, 2, v
+bpp_frontends_rep vp9_loop_filter_v_16, 16, 4, 4, v
+
+function vp9_loop_filter_h_16_4_16_neon
+        sub             r12, r0,  #16
+        sub             r0,  r0,  #8
+        vld1.16         {d16}, [r12,:64], r1
+        vld1.16         {d20}, [r0, :64], r1
+        vld1.16         {d17}, [r12,:64], r1
+        vld1.16         {d21}, [r0, :64], r1
+        vld1.16         {d18}, [r12,:64], r1
+        vld1.16         {d22}, [r0, :64], r1
+        vld1.16         {d19}, [r12,:64], r1
+        vld1.16         {d23}, [r0, :64], r1
+        sub             r12, r12, r1, lsl #2
+        sub             r0,  r0,  r1, lsl #2
+        add             r12, r12, #16
+        add             r0,  r0,  #16
+        vld1.16         {d24}, [r12,:64], r1
+        vld1.16         {d28}, [r0, :64], r1
+        vld1.16         {d25}, [r12,:64], r1
+        vld1.16         {d29}, [r0, :64], r1
+        vld1.16         {d26}, [r12,:64], r1
+        vld1.16         {d30}, [r0, :64], r1
+        vld1.16         {d27}, [r12,:64], r1
+        vld1.16         {d31}, [r0, :64], r1
+        sub             r0,  r0,  r1, lsl #2
+        sub             r12, r12, r1, lsl #2
+        sub             r12, r12, #16
+        sub             r0,  r0,  #16
+
+        @ The 16x4 pixels read above is in four 4x4 blocks
+        transpose16_q_4x4 q8,  q9,  d16, d17, d18, d19
+        transpose16_q_4x4 q10, q11, d20, d21, d22, d23
+        transpose16_q_4x4 q12, q13, d24, d25, d26, d27
+        transpose16_q_4x4 q14, q15, d28, d29, d30, d31
+
+        loop_filter_16
+
+        @ Transpose back; this is the same transpose as above, but
+        @ we can't take advantage of q registers for the transpose, since
+        @ all d registers in the transpose aren't consecutive.
+        transpose16_4x4 d16, d2,  d3,  d4
+        transpose16_4x4 d5,  d6,  d8,  d9
+        transpose16_4x4 d10, d11, d12, d13
+        transpose16_4x4 d14, d15, d17, d31
+
+        vst1.16         {d16}, [r12,:64], r1
+        vst1.16         {d5},  [r0, :64], r1
+
+        vst1.16         {d2},  [r12,:64], r1
+        vst1.16         {d6},  [r0, :64], r1
+
+        vst1.16         {d3},  [r12,:64], r1
+        vst1.16         {d8},  [r0, :64], r1
+
+        vst1.16         {d4},  [r12,:64], r1
+        vst1.16         {d9},  [r0, :64], r1
+
+        sub             r12, r12, r1, lsl #2
+        sub             r0,  r0,  r1, lsl #2
+        add             r12, r12, #16
+        add             r0,  r0,  #16
+
+        vst1.16         {d10}, [r12,:64], r1
+        vst1.16         {d14}, [r0, :64], r1
+
+        vst1.16         {d11}, [r12,:64], r1
+        vst1.16         {d15}, [r0, :64], r1
+
+        vst1.16         {d12}, [r12,:64], r1
+        vst1.16         {d17}, [r0, :64], r1
+
+        vst1.16         {d13}, [r12,:64], r1
+        vst1.16         {d31}, [r0, :64], r1
+        sub             r0,  r0,  r1, lsl #2
+        sub             r0,  r0,  #8
+        bx              lr
+9:
+        add             r0,  r0,  #8
+        bx              lr
+8:
+        add             r12, r12, #8
+        add             r0,  r0,  #8
+        transpose16_q_4x4 q10, q11, d20, d21, d22, d23
+        transpose16_q_4x4 q12, q13, d24, d25, d26, d27
+
+        vst1.16         {d20}, [r12,:64], r1
+        vst1.16         {d24}, [r0, :64], r1
+        vst1.16         {d21}, [r12,:64], r1
+        vst1.16         {d25}, [r0, :64], r1
+        vst1.16         {d22}, [r12,:64], r1
+        vst1.16         {d26}, [r0, :64], r1
+        vst1.16         {d23}, [r12,:64], r1
+        vst1.16         {d27}, [r0, :64], r1
+        sub             r0,  r0,  r1, lsl #2
+        bx              lr
+7:
+        add             r12, r12, #12
+        add             r0,  r12, r1, lsl #1
+        transpose16_q_4x4 q11, q12, d22, d23, d24, d25
+
+        vst1.16         {d22}, [r12], r1
+        vst1.16         {d24}, [r0],  r1
+        vst1.16         {d23}, [r12], r1
+        vst1.16         {d25}, [r0],  r1
+        sub             r0,  r0,  r1, lsl #2
+        add             r0,  r0,  #4
+        bx              lr
+endfunc
+
+bpp_frontends_rep vp9_loop_filter_h_16, 8,  4, 2, h
+bpp_frontends_rep vp9_loop_filter_h_16, 16, 4, 4, h
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp9lpf_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/vp9lpf_neon.S
new file mode 100644
index 00000000000..4b3608064a5
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp9lpf_neon.S
@@ -0,0 +1,959 @@
+/*
+ * Copyright (c) 2016 Google Inc.
+ *
+ * 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/arm/asm.S"
+#include "neon.S"
+
+@ Do an 8x8 transpose, using q registers for the subtransposes that don't
+@ need to address the indiviudal d registers.
+@ r0,r1 == rq0, r2,r3 == rq1, etc
+.macro transpose_q_8x8 rq0, rq1, rq2, rq3, r0, r1, r2, r3, r4, r5, r6, r7
+        vtrn.32         \rq0, \rq2
+        vtrn.32         \rq1, \rq3
+        vtrn.16         \rq0, \rq1
+        vtrn.16         \rq2, \rq3
+        vtrn.8          \r0,  \r1
+        vtrn.8          \r2,  \r3
+        vtrn.8          \r4,  \r5
+        vtrn.8          \r6,  \r7
+.endm
+
+@ Do a 4x4 transpose, using q registers for the subtransposes that don't
+@ need to address the indiviudal d registers.
+@ r0,r1 == rq0, r2,r3 == rq1
+.macro transpose_q_4x4 rq0, rq1, r0, r1, r2, r3
+        vtrn.16         \rq0, \rq1
+        vtrn.8          \r0,  \r1
+        vtrn.8          \r2,  \r3
+.endm
+
+@ The input to and output from this macro is in the registers q8-q15,
+@ and q0-q7 are used as scratch registers.
+@ p3 = q8, p0 = q11, q0 = q12, q3 = q15
+.macro loop_filter_q
+        vdup.u8         d0,  r2          @ E
+        lsr             r2,  r2,  #8
+        vdup.u8         d2,  r3          @ I
+        lsr             r3,  r3,  #8
+        vdup.u8         d1,  r2          @ E
+        vdup.u8         d3,  r3          @ I
+
+        vabd.u8         q2,  q8,  q9     @ abs(p3 - p2)
+        vabd.u8         q3,  q9,  q10    @ abs(p2 - p1)
+        vabd.u8         q4,  q10, q11    @ abs(p1 - p0)
+        vabd.u8         q5,  q12, q13    @ abs(q0 - q1)
+        vabd.u8         q6,  q13, q14    @ abs(q1 - q2)
+        vabd.u8         q7,  q14, q15    @ abs(q2 - q3)
+        vmax.u8         q2,  q2,  q3
+        vmax.u8         q3,  q4,  q5
+        vmax.u8         q4,  q6,  q7
+        vabd.u8         q5,  q11, q12    @ abs(p0 - q0)
+        vmax.u8         q2,  q2,  q3
+        vqadd.u8        q5,  q5,  q5     @ abs(p0 - q0) * 2
+        vabd.u8         q7,  q10, q13    @ abs(p1 - q1)
+        vmax.u8         q2,  q2,  q4     @ max(abs(p3 - p2), ..., abs(q2 - q3))
+        vshr.u8         q7,  q7,  #1
+        vcle.u8         q2,  q2,  q1     @ max(abs()) <= I
+        vqadd.u8        q5,  q5,  q7     @ abs(p0 - q0) * 2 + abs(p1 - q1) >> 1
+        vcle.u8         q5,  q5,  q0
+        vand            q2,  q2,  q5     @ fm
+
+        vshrn.u16       d10, q2,  #4
+        vmov            r2,  r3,  d10
+        orrs            r2,  r2,  r3
+        @ If no pixels need filtering, just exit as soon as possible
+        beq             9f
+
+        @ Calculate the normal inner loop filter for 2 or 4 pixels
+        ldr             r3,  [sp, #64]
+        vabd.u8         q3,  q10, q11    @ abs(p1 - p0)
+        vabd.u8         q4,  q13, q12    @ abs(q1 - q0)
+
+        vsubl.u8        q5,  d20, d26    @ p1 - q1
+        vsubl.u8        q6,  d21, d27    @ p1 - q1
+        vmax.u8         q3,  q3,  q4     @ max(abs(p1 - p0), abs(q1 - q0))
+        vqmovn.s16      d10, q5          @ av_clip_int8p(p1 - q1)
+        vqmovn.s16      d11, q6          @ av_clip_int8p(p1 - q1)
+        vdup.u8         d8,  r3          @ H
+        lsr             r3,  r3,  #8
+        vdup.u8         d9,  r3          @ H
+        vsubl.u8        q6,  d24, d22    @ q0 - p0
+        vsubl.u8        q7,  d25, d23    @ q0 - p0
+        vcle.u8         q3,  q3,  q4     @ hev
+        vmov.s16        q0,  #3
+        vand            q3,  q3,  q2     @ !hev && fm && !flat8in
+
+        vmul.s16        q6,  q6,  q0     @ 3 * (q0 - p0)
+        vmul.s16        q7,  q7,  q0     @ 3 * (q0 - p0)
+        vbic            q5,  q5,  q3     @ if (!hev) av_clip_int8 = 0
+        vaddw.s8        q6,  q6,  d10    @ 3 * (q0 - p0) [+ av_clip_int8(p1 - q1)]
+        vaddw.s8        q7,  q7,  d11    @ 3 * (q0 - p0) [+ av_clip_int8(p1 - q1)]
+        vmov.s8         q5,  #4
+        vqmovn.s16      d12, q6
+        vqmovn.s16      d13, q7          @ av_clip_int8(3 * (q0 - p0) [+ av_clip_int8(p1 - q1)], BIT_DEPTH - 1) = f
+        vmov.s8         q0,  #3
+
+        vqadd.s8        q5,  q6,  q5     @ FFMIN(f + 4, 127)
+        vqadd.s8        q0,  q6,  q0     @ FFMIN(f + 3, 127)
+        vmovl.u8        q6,  d22         @ p0
+        vmovl.u8        q7,  d23         @ p0
+        vshr.s8         q5,  q5,  #3     @ f1
+        vshr.s8         q0,  q0,  #3     @ f2
+
+        vaddw.s8        q6,  q6,  d0     @ p0 + f2
+        vaddw.s8        q7,  q7,  d1     @ p0 + f2
+        vqmovun.s16     d0,  q6          @ out p0
+        vmovl.u8        q6,  d24         @ q0
+        vqmovun.s16     d1,  q7          @ out p0
+        vmovl.u8        q7,  d25         @ q0
+        vsubw.s8        q6,  q6,  d10    @ q0 - f1
+        vsubw.s8        q7,  q7,  d11    @ q0 - f1
+        vqmovun.s16     d12, q6          @ out q0
+        vqmovun.s16     d13, q7          @ out q0
+        vrshr.s8        q5,  q5,  #1     @ f = (f1 + 1) >> 1
+        vbit            q11, q0,  q2     @ if (fm && !flat8in)
+        vbit            q12, q6,  q2
+
+        vmovl.u8        q0,  d20         @ p1
+        vmovl.u8        q2,  d21         @ p1
+        vmovl.u8        q6,  d26         @ q1
+        vmovl.u8        q7,  d27         @ q1
+        vaddw.s8        q0,  q0,  d10    @ p1 + f
+        vaddw.s8        q2,  q2,  d11    @ p1 + f
+        vsubw.s8        q6,  q6,  d10    @ q1 - f
+        vsubw.s8        q7,  q7,  d11    @ q1 - f
+        vqmovun.s16     d0,  q0          @ out p1
+        vqmovun.s16     d1,  q2          @ out p1
+        vqmovun.s16     d12, q6          @ out q1
+        vqmovun.s16     d13, q7          @ out q1
+        vbit            q10, q0,  q3     @ if (!hev && fm && !flat8in)
+        vbit            q13, q6,  q3
+.endm
+
+@ The input to and output from this macro is in the registers d16-d31,
+@ and d0-d7 are used as scratch registers.
+@ p7 = d16 .. p3 = d20, p0 = d23, q0 = d24, q3 = d27, q7 = d31
+@ Depending on the width of the loop filter, we either use d16-d19
+@ and d28-d31 as temp registers, or d8-d15.
+@ tmp1,tmp2 = tmpq1, tmp3,tmp4 = tmpq2, tmp5,tmp6 = tmpq3, tmp7,tmp8 = tmpq4
+.macro loop_filter wd, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmpq1, tmpq2, tmpq3, tmpq4
+        vdup.u8         d0,  r2 @ E
+        vdup.u8         d2,  r3 @ I
+        ldr             r3,  [sp]
+
+        vabd.u8         d4,  d20, d21    @ abs(p3 - p2)
+        vabd.u8         d5,  d21, d22    @ abs(p2 - p1)
+        vabd.u8         d6,  d22, d23    @ abs(p1 - p0)
+        vabd.u8         d7,  d24, d25    @ abs(q0 - q1)
+        vabd.u8         \tmp1,  d25, d26 @ abs(q1 - q2)
+        vabd.u8         \tmp2,  d26, d27 @ abs(q2 - q3)
+        vmax.u8         d4,  d4,  d5
+        vmax.u8         d5,  d6,  d7
+        vmax.u8         \tmp1,  \tmp1,  \tmp2
+        vabd.u8         d6,  d23, d24    @ abs(p0 - q0)
+        vmax.u8         d4,  d4,  d5
+        vqadd.u8        d6,  d6,  d6     @ abs(p0 - q0) * 2
+        vabd.u8         d5,  d22, d25    @ abs(p1 - q1)
+        vmax.u8         d4,  d4,  \tmp1  @ max(abs(p3 - p2), ..., abs(q2 - q3))
+        vshr.u8         d5,  d5,  #1
+        vcle.u8         d4,  d4,  d2     @ max(abs()) <= I
+        vqadd.u8        d6,  d6,  d5     @ abs(p0 - q0) * 2 + abs(p1 - q1) >> 1
+        vcle.u8         d5,  d6,  d0
+        vand            d4,  d4,  d5     @ fm
+
+        vdup.u8         d3,  r3          @ H
+        vmov            r2,  r3,  d4
+        orrs            r2,  r2,  r3
+        @ If no pixels need filtering, just exit as soon as possible
+        beq             9f
+
+.if \wd >= 8
+        vmov.u8         d0,  #1
+
+        vabd.u8         d6,  d20, d23    @ abs(p3 - p0)
+        vabd.u8         d2,  d21, d23    @ abs(p2 - p0)
+        vabd.u8         d1,  d22, d23    @ abs(p1 - p0)
+        vabd.u8         \tmp1,  d25, d24 @ abs(q1 - q0)
+        vabd.u8         \tmp2,  d26, d24 @ abs(q2 - q0)
+        vabd.u8         \tmp3,  d27, d24 @ abs(q3 - q0)
+        vmax.u8         d6,  d6,  d2
+        vmax.u8         d1,  d1,  \tmp1
+        vmax.u8         \tmp2,  \tmp2,  \tmp3
+.if \wd == 16
+        vabd.u8         d7,  d16, d23    @ abs(p7 - p0)
+        vmax.u8         d6,  d6,  d1
+        vabd.u8         d2,  d17, d23    @ abs(p6 - p0)
+        vmax.u8         d6,  d6,  \tmp2
+        vabd.u8         d1,  d18, d23    @ abs(p5 - p0)
+        vcle.u8         d6,  d6,  d0     @ flat8in
+        vabd.u8         d8,  d19, d23    @ abs(p4 - p0)
+        vand            d6,  d6,  d4     @ flat8in && fm
+        vabd.u8         d9,  d28, d24    @ abs(q4 - q0)
+        vbic            d4,  d4,  d6     @ fm && !flat8in
+        vabd.u8         d10, d29, d24    @ abs(q5 - q0)
+        vabd.u8         d11, d30, d24    @ abs(q6 - q0)
+        vabd.u8         d12, d31, d24    @ abs(q7 - q0)
+
+        vmax.u8         d7,  d7,  d2
+        vmax.u8         d1,  d1,  d8
+        vmax.u8         d9,  d9,  d10
+        vmax.u8         d11, d11, d12
+        @ The rest of the calculation of flat8out is interleaved below
+.else
+        @ The rest of the calculation of flat8in is interleaved below
+.endif
+.endif
+
+        @ Calculate the normal inner loop filter for 2 or 4 pixels
+        vabd.u8         d5,  d22, d23           @ abs(p1 - p0)
+.if \wd == 16
+        vmax.u8         d7,  d7,  d1
+        vmax.u8         d9,  d9,  d11
+.elseif \wd == 8
+        vmax.u8         d6,  d6,  d1
+.endif
+        vabd.u8         d1,  d25, d24           @ abs(q1 - q0)
+.if \wd == 16
+        vmax.u8         d7,  d7,  d9
+.elseif \wd == 8
+        vmax.u8         d6,  d6,  \tmp2
+.endif
+        vsubl.u8        \tmpq1,  d22, d25       @ p1 - q1
+        vmax.u8         d5,  d5,  d1            @ max(abs(p1 - p0), abs(q1 - q0))
+        vsubl.u8        \tmpq2,  d24, d23       @ q0 - p0
+        vmov.s16        \tmpq3,  #3
+.if \wd == 8
+        vcle.u8         d6,  d6,  d0            @ flat8in
+.endif
+        vcle.u8         d5,  d5,  d3            @ !hev
+.if \wd == 8
+        vand            d6,  d6,  d4            @ flat8in && fm
+.endif
+        vqmovn.s16      \tmp1,   \tmpq1         @ av_clip_int8(p1 - q1)
+.if \wd == 16
+        vcle.u8         d7,  d7,  d0            @ flat8out
+.elseif \wd == 8
+        vbic            d4,  d4,  d6            @ fm && !flat8in
+.endif
+        vand            d5,  d5,  d4            @ !hev && fm && !flat8in
+.if \wd == 16
+        vand            d7,  d7,  d6            @ flat8out && flat8in && fm
+.endif
+
+        vmul.s16        \tmpq2,  \tmpq2, \tmpq3 @ 3 * (q0 - p0)
+        vbic            \tmp1,   \tmp1,   d5    @ if (!hev) av_clip_int8 = 0
+        vmov.s8         d2,  #4
+        vaddw.s8        \tmpq2,  \tmpq2,  \tmp1 @ 3 * (q0 - p0) [+ av_clip_int8(p1 - q1)]
+        vmov.s8         d3,  #3
+        vqmovn.s16      \tmp1,   \tmpq2         @ f
+.if \wd == 16
+        vbic            d6,  d6,  d7            @ fm && flat8in && !flat8out
+.endif
+
+        vqadd.s8        \tmp3, \tmp1,  d2       @ FFMIN(f + 4, 127)
+        vqadd.s8        \tmp4, \tmp1,  d3       @ FFMIN(f + 3, 127)
+        vmovl.u8        q0,  d23                @ p0
+        vshr.s8         \tmp3, \tmp3,  #3       @ f1
+        vshr.s8         \tmp4, \tmp4,  #3       @ f2
+
+        vmovl.u8        q1,  d24                @ q0
+        vaddw.s8        q0,  q0,  \tmp4         @ p0 + f2
+        vsubw.s8        q1,  q1,  \tmp3         @ q0 - f1
+        vqmovun.s16     d0,  q0                 @ out p0
+        vqmovun.s16     d1,  q1                 @ out q0
+        vrshr.s8        \tmp3, \tmp3, #1        @ f = (f1 + 1) >> 1
+        vbit            d23, d0,  d4            @ if (fm && !flat8in)
+        vbit            d24, d1,  d4
+
+        vmovl.u8        q0,  d22                @ p1
+        vmovl.u8        q1,  d25                @ q1
+.if \wd >= 8
+        vmov            r2,  r3,  d6
+.endif
+        vaddw.s8        q0,  q0,  \tmp3         @ p1 + f
+        vsubw.s8        q1,  q1,  \tmp3         @ q1 - f
+.if \wd >= 8
+        orrs            r2,  r2,  r3
+.endif
+        vqmovun.s16     d0,  q0                 @ out p1
+        vqmovun.s16     d2,  q1                 @ out q1
+        vbit            d22, d0,  d5            @ if (!hev && fm && !flat8in)
+        vbit            d25, d2,  d5
+
+.if \wd >= 8
+        @ If no pixels need flat8in, jump to flat8out
+        @ (or to a writeout of the inner 4 pixels, for wd=8)
+        beq             6f
+
+        @ flat8in
+        vaddl.u8        \tmpq1, d20, d21
+        vaddl.u8        \tmpq2, d22, d25
+        vaddl.u8        \tmpq3, d20, d22
+        vaddl.u8        \tmpq4, d23, d26
+        vadd.u16        q0,  \tmpq1, \tmpq1
+        vaddw.u8        q0,  q0,  d23
+        vaddw.u8        q0,  q0,  d24
+        vadd.u16        q0,  q0,  \tmpq3
+        vsub.s16        \tmpq2, \tmpq2, \tmpq1
+        vsub.s16        \tmpq4, \tmpq4, \tmpq3
+        vrshrn.u16      d2,  q0,  #3            @ out p2
+
+        vadd.u16        q0,  q0,  \tmpq2
+        vaddl.u8        \tmpq1, d20, d23
+        vaddl.u8        \tmpq2, d24, d27
+        vrshrn.u16      d3,  q0,  #3            @ out p1
+
+        vadd.u16        q0,  q0,  \tmpq4
+        vsub.s16        \tmpq2, \tmpq2, \tmpq1
+        vaddl.u8        \tmpq3, d21, d24
+        vaddl.u8        \tmpq4, d25, d27
+        vrshrn.u16      d4,  q0,  #3            @ out p0
+
+        vadd.u16        q0,  q0,  \tmpq2
+        vsub.s16        \tmpq4, \tmpq4, \tmpq3
+        vaddl.u8        \tmpq1, d22, d25
+        vaddl.u8        \tmpq2, d26, d27
+        vrshrn.u16      d5,  q0,  #3            @ out q0
+
+        vadd.u16        q0,  q0,  \tmpq4
+        vsub.s16        \tmpq2, \tmpq2, \tmpq1
+        vrshrn.u16      \tmp5,  q0,  #3         @ out q1
+
+        vadd.u16        q0,  q0,  \tmpq2
+        @ The output here is written back into the input registers. This doesn't
+        @ matter for the flat8out part below, since we only update those pixels
+        @ which won't be touched below.
+        vbit            d21, d2,  d6
+        vbit            d22, d3,  d6
+        vbit            d23, d4,  d6
+        vrshrn.u16      \tmp6,  q0,  #3         @ out q2
+        vbit            d24, d5,  d6
+        vbit            d25, \tmp5,  d6
+        vbit            d26, \tmp6,  d6
+.endif
+.if \wd == 16
+6:
+        vorr            d2,  d6,  d7
+        vmov            r2,  r3,  d2
+        orrs            r2,  r2,  r3
+        @ If no pixels needed flat8in nor flat8out, jump to a
+        @ writeout of the inner 4 pixels
+        beq             7f
+        vmov            r2,  r3,  d7
+        orrs            r2,  r2,  r3
+        @ If no pixels need flat8out, jump to a writeout of the inner 6 pixels
+        beq             8f
+
+        @ flat8out
+        @ This writes all outputs into d2-d17 (skipping d6 and d16).
+        @ If this part is skipped, the output is read from d21-d26 (which is the input
+        @ to this section).
+        vshll.u8        q0,  d16, #3  @ 8 * d16
+        vsubw.u8        q0,  q0,  d16 @ 7 * d16
+        vaddw.u8        q0,  q0,  d17
+        vaddl.u8        q4,  d17, d18
+        vaddl.u8        q5,  d19, d20
+        vadd.s16        q0,  q0,  q4
+        vaddl.u8        q4,  d16, d17
+        vaddl.u8        q6,  d21, d22
+        vadd.s16        q0,  q0,  q5
+        vaddl.u8        q5,  d18, d25
+        vaddl.u8        q7,  d23, d24
+        vsub.s16        q5,  q5,  q4
+        vadd.s16        q0,  q0,  q6
+        vadd.s16        q0,  q0,  q7
+        vaddl.u8        q6,  d16, d18
+        vaddl.u8        q7,  d19, d26
+        vrshrn.u16      d2,  q0,  #4
+
+        vadd.s16        q0,  q0,  q5
+        vaddl.u8        q4,  d16, d19
+        vaddl.u8        q5,  d20, d27
+        vsub.s16        q7,  q7,  q6
+        vbif            d2,  d17, d7
+        vrshrn.u16      d3,  q0,  #4
+
+        vadd.s16        q0,  q0,  q7
+        vaddl.u8        q6,  d16, d20
+        vaddl.u8        q7,  d21, d28
+        vsub.s16        q5,  q5,  q4
+        vbif            d3,  d18, d7
+        vrshrn.u16      d4,  q0,  #4
+
+        vadd.s16        q0,  q0,  q5
+        vaddl.u8        q4,  d16, d21
+        vaddl.u8        q5,  d22, d29
+        vsub.s16        q7,  q7,  q6
+        vbif            d4,  d19, d7
+        vrshrn.u16      d5,  q0,  #4
+
+        vadd.s16        q0,  q0,  q7
+        vaddl.u8        q6,  d16, d22
+        vaddl.u8        q7,  d23, d30
+        vsub.s16        q5,  q5,  q4
+        vbif            d5,  d20, d7
+        vrshrn.u16      d6,  q0,  #4
+
+        vadd.s16        q0,  q0,  q5
+        vaddl.u8        q5,  d16, d23
+        vsub.s16        q7,  q7,  q6
+        vaddl.u8        q6,  d24, d31
+        vbif            d6,  d21, d7
+        vrshrn.u16      d8,  q0,  #4
+
+        vadd.s16        q0,  q0,  q7
+        vsub.s16        q5,  q6,  q5
+        vaddl.u8        q6,  d17, d24
+        vaddl.u8        q7,  d25, d31
+        vbif            d8,  d22, d7
+        vrshrn.u16      d9,  q0,  #4
+
+        vadd.s16        q0,  q0,  q5
+        vsub.s16        q7,  q7,  q6
+        vaddl.u8        q6,  d26, d31
+        vbif            d9,  d23, d7
+        vrshrn.u16      d10, q0,  #4
+
+        vadd.s16        q0,  q0,  q7
+        vaddl.u8        q7,  d18, d25
+        vaddl.u8        q9,  d19, d26
+        vsub.s16        q6,  q6,  q7
+        vaddl.u8        q7,  d27, d31
+        vbif            d10, d24, d7
+        vrshrn.u16      d11, q0,  #4
+
+        vadd.s16        q0,  q0,  q6
+        vaddl.u8        q6,  d20, d27
+        vsub.s16        q7,  q7,  q9
+        vaddl.u8        q9,  d28, d31
+        vbif            d11, d25, d7
+        vsub.s16        q9,  q9,  q6
+        vrshrn.u16      d12, q0,  #4
+
+        vadd.s16        q0,  q0,  q7
+        vaddl.u8        q7,  d21, d28
+        vaddl.u8        q10, d29, d31
+        vbif            d12, d26, d7
+        vrshrn.u16      d13, q0,  #4
+
+        vadd.s16        q0,  q0,  q9
+        vsub.s16        q10, q10, q7
+        vaddl.u8        q9,  d22, d29
+        vaddl.u8        q11, d30, d31
+        vbif            d13, d27, d7
+        vrshrn.u16      d14, q0,  #4
+
+        vadd.s16        q0,  q0,  q10
+        vsub.s16        q11, q11, q9
+        vbif            d14, d28, d7
+        vrshrn.u16      d15, q0,  #4
+
+        vadd.s16        q0,  q0,  q11
+        vbif            d15, d29, d7
+        vrshrn.u16      d17, q0,  #4
+        vbif            d17, d30, d7
+.endif
+.endm
+
+@ For wd <= 8, we use d16-d19 and d28-d31 for temp registers,
+@ while we need those for inputs/outputs in wd=16 and use d8-d15
+@ for temp registers there instead.
+.macro loop_filter_4
+        loop_filter     4,  d16, d17, d18, d19, d28, d29, d30, d31, q8,  q9,  q14, q15
+.endm
+
+.macro loop_filter_8
+        loop_filter     8,  d16, d17, d18, d19, d28, d29, d30, d31, q8,  q9,  q14, q15
+.endm
+
+.macro loop_filter_16
+        loop_filter     16, d8,  d9,  d10, d11, d12, d13, d14, d15, q4,  q5,  q6,  q7
+.endm
+
+
+@ The public functions in this file have got the following signature:
+@ void loop_filter(uint8_t *dst, ptrdiff_t stride, int mb_lim, int lim, int hev_thr);
+
+function ff_vp9_loop_filter_v_4_8_neon, export=1
+        sub             r12, r0,  r1, lsl #2
+        vld1.8          {d20}, [r12,:64], r1 @ p3
+        vld1.8          {d24}, [r0, :64], r1 @ q0
+        vld1.8          {d21}, [r12,:64], r1 @ p2
+        vld1.8          {d25}, [r0, :64], r1 @ q1
+        vld1.8          {d22}, [r12,:64], r1 @ p1
+        vld1.8          {d26}, [r0, :64], r1 @ q2
+        vld1.8          {d23}, [r12,:64], r1 @ p0
+        vld1.8          {d27}, [r0, :64], r1 @ q3
+        sub             r0,  r0,  r1, lsl #2
+        sub             r12, r12, r1, lsl #1
+
+        loop_filter_4
+
+        vst1.8          {d22}, [r12,:64], r1
+        vst1.8          {d24}, [r0, :64], r1
+        vst1.8          {d23}, [r12,:64], r1
+        vst1.8          {d25}, [r0, :64], r1
+9:
+        bx              lr
+endfunc
+
+function ff_vp9_loop_filter_h_4_8_neon, export=1
+        sub             r12, r0,  #4
+        add             r0,  r12, r1, lsl #2
+        vld1.8          {d20}, [r12], r1
+        vld1.8          {d24}, [r0],  r1
+        vld1.8          {d21}, [r12], r1
+        vld1.8          {d25}, [r0],  r1
+        vld1.8          {d22}, [r12], r1
+        vld1.8          {d26}, [r0],  r1
+        vld1.8          {d23}, [r12], r1
+        vld1.8          {d27}, [r0],  r1
+
+        sub             r12, r12, r1, lsl #2
+        sub             r0,  r0,  r1, lsl #2
+        @ Move r0/r12 forward by 2 pixels; we don't need to rewrite the
+        @ outermost 2 pixels since they aren't changed.
+        add             r12, r12, #2
+        add             r0,  r0,  #2
+
+        @ Transpose the 8x8 pixels, taking advantage of q registers, to get
+        @ one register per column.
+        transpose_q_8x8 q10, q11, q12, q13, d20, d21, d22, d23, d24, d25, d26, d27
+
+        loop_filter_4
+
+        @ We only will write the mid 4 pixels back; after the loop filter,
+        @ these are in d22, d23, d24, d25 (q11, q12), ordered as rows
+        @ (8x4 pixels). We need to transpose them to columns, done with a
+        @ 4x4 transpose (which in practice is two 4x4 transposes of the two
+        @ 4x4 halves of the 8x4 pixels; into 4x8 pixels).
+        transpose_q_4x4 q11, q12, d22, d23, d24, d25
+
+        vst1.32         {d22[0]}, [r12], r1
+        vst1.32         {d22[1]}, [r0],  r1
+        vst1.32         {d23[0]}, [r12], r1
+        vst1.32         {d23[1]}, [r0],  r1
+        vst1.32         {d24[0]}, [r12], r1
+        vst1.32         {d24[1]}, [r0],  r1
+        vst1.32         {d25[0]}, [r12], r1
+        vst1.32         {d25[1]}, [r0],  r1
+9:
+        bx              lr
+endfunc
+
+function ff_vp9_loop_filter_v_44_16_neon, export=1
+        vpush           {q4-q7}
+        sub             r12, r0,  r1, lsl #2
+        vld1.8          {q8},  [r12,:128], r1 @ p3
+        vld1.8          {q12}, [r0, :128], r1 @ q0
+        vld1.8          {q9},  [r12,:128], r1 @ p2
+        vld1.8          {q13}, [r0, :128], r1 @ q1
+        vld1.8          {q10}, [r12,:128], r1 @ p1
+        vld1.8          {q14}, [r0, :128], r1 @ q2
+        vld1.8          {q11}, [r12,:128], r1 @ p0
+        vld1.8          {q15}, [r0, :128], r1 @ q3
+        sub             r0,  r0,  r1, lsl #2
+        sub             r12, r12, r1, lsl #1
+
+        loop_filter_q
+
+        vst1.8          {q10}, [r12,:128], r1
+        vst1.8          {q12}, [r0, :128], r1
+        vst1.8          {q11}, [r12,:128], r1
+        vst1.8          {q13}, [r0, :128], r1
+9:
+        vpop            {q4-q7}
+        bx              lr
+endfunc
+
+function ff_vp9_loop_filter_h_44_16_neon, export=1
+        vpush           {q4-q7}
+        sub             r12, r0,  #4
+        add             r0,  r12, r1, lsl #2
+        vld1.8          {d16}, [r12], r1
+        vld1.8          {d24}, [r0],  r1
+        vld1.8          {d18}, [r12], r1
+        vld1.8          {d26}, [r0],  r1
+        vld1.8          {d20}, [r12], r1
+        vld1.8          {d28}, [r0],  r1
+        vld1.8          {d22}, [r12], r1
+        vld1.8          {d30}, [r0],  r1
+        mov             r12, r0
+        add             r0,  r0,  r1, lsl #2
+        vld1.8          {d17}, [r12], r1
+        vld1.8          {d25}, [r0],  r1
+        vld1.8          {d19}, [r12], r1
+        vld1.8          {d27}, [r0],  r1
+        vld1.8          {d21}, [r12], r1
+        vld1.8          {d29}, [r0],  r1
+        vld1.8          {d23}, [r12], r1
+        vld1.8          {d31}, [r0],  r1
+
+        @ Transpose the 16x8 pixels, as two 8x8 parts
+        transpose_8x8   q8,  q9,  q10, q11, q12, q13, q14, q15
+
+        loop_filter_q
+
+        sub             r12, r0,  r1, lsl #4
+        add             r0,  r12, r1, lsl #3
+        @ Move r0/r12 forward by 2 pixels; we don't need to rewrite the
+        @ outermost 2 pixels since they aren't changed.
+        add             r12, r12, #2
+        add             r0,  r0,  #2
+
+        @ We only will write the mid 4 pixels back; after the loop filter,
+        @ these are in q10, q11, q12, q13, ordered as rows (16x4 pixels).
+        @ We need to transpose them to columns, done with a 4x4 transpose
+        @ (which in practice is four 4x4 transposes of the 4x4 blocks of
+        @ the 16x4 pixels; into 4x16 pixels).
+        transpose_4x4   q10, q11, q12, q13
+
+        vst1.32         {d20[0]}, [r12], r1
+        vst1.32         {d21[0]}, [r0],  r1
+        vst1.32         {d22[0]}, [r12], r1
+        vst1.32         {d23[0]}, [r0],  r1
+        vst1.32         {d24[0]}, [r12], r1
+        vst1.32         {d25[0]}, [r0],  r1
+        vst1.32         {d26[0]}, [r12], r1
+        vst1.32         {d27[0]}, [r0],  r1
+        vst1.32         {d20[1]}, [r12], r1
+        vst1.32         {d21[1]}, [r0],  r1
+        vst1.32         {d22[1]}, [r12], r1
+        vst1.32         {d23[1]}, [r0],  r1
+        vst1.32         {d24[1]}, [r12], r1
+        vst1.32         {d25[1]}, [r0],  r1
+        vst1.32         {d26[1]}, [r12], r1
+        vst1.32         {d27[1]}, [r0],  r1
+9:
+        vpop            {q4-q7}
+        bx              lr
+endfunc
+
+function ff_vp9_loop_filter_v_8_8_neon, export=1
+        sub             r12, r0,  r1, lsl #2
+        vld1.8          {d20}, [r12,:64], r1 @ p3
+        vld1.8          {d24}, [r0, :64], r1 @ q0
+        vld1.8          {d21}, [r12,:64], r1 @ p2
+        vld1.8          {d25}, [r0, :64], r1 @ q1
+        vld1.8          {d22}, [r12,:64], r1 @ p1
+        vld1.8          {d26}, [r0, :64], r1 @ q2
+        vld1.8          {d23}, [r12,:64], r1 @ p0
+        vld1.8          {d27}, [r0, :64], r1 @ q3
+        sub             r12, r12, r1, lsl #2
+        sub             r0,  r0,  r1, lsl #2
+        add             r12, r12, r1
+
+        loop_filter_8
+
+        vst1.8          {d21}, [r12,:64], r1
+        vst1.8          {d24}, [r0, :64], r1
+        vst1.8          {d22}, [r12,:64], r1
+        vst1.8          {d25}, [r0, :64], r1
+        vst1.8          {d23}, [r12,:64], r1
+        vst1.8          {d26}, [r0, :64], r1
+9:
+        bx              lr
+6:
+        sub             r12, r0,  r1, lsl #1
+        vst1.8          {d22}, [r12,:64], r1
+        vst1.8          {d24}, [r0, :64], r1
+        vst1.8          {d23}, [r12,:64], r1
+        vst1.8          {d25}, [r0, :64], r1
+        bx              lr
+endfunc
+
+function ff_vp9_loop_filter_h_8_8_neon, export=1
+        sub             r12, r0,  #4
+        add             r0,  r12, r1, lsl #2
+        vld1.8          {d20}, [r12], r1
+        vld1.8          {d24}, [r0],  r1
+        vld1.8          {d21}, [r12], r1
+        vld1.8          {d25}, [r0],  r1
+        vld1.8          {d22}, [r12], r1
+        vld1.8          {d26}, [r0],  r1
+        vld1.8          {d23}, [r12], r1
+        vld1.8          {d27}, [r0],  r1
+
+        sub             r12, r12, r1, lsl #2
+        sub             r0,  r0,  r1, lsl #2
+
+        transpose_q_8x8 q10, q11, q12, q13, d20, d21, d22, d23, d24, d25, d26, d27
+
+        loop_filter_8
+
+        @ Even though only 6 pixels per row have been changed, we write the
+        @ full 8 pixel registers.
+        transpose_q_8x8 q10, q11, q12, q13, d20, d21, d22, d23, d24, d25, d26, d27
+
+        vst1.8          {d20}, [r12], r1
+        vst1.8          {d24}, [r0],  r1
+        vst1.8          {d21}, [r12], r1
+        vst1.8          {d25}, [r0],  r1
+        vst1.8          {d22}, [r12], r1
+        vst1.8          {d26}, [r0],  r1
+        vst1.8          {d23}, [r12], r1
+        vst1.8          {d27}, [r0],  r1
+9:
+        bx              lr
+6:
+        @ If we didn't need to do the flat8in part, we use the same writeback
+        @ as in loop_filter_h_4_8.
+        add             r12, r12, #2
+        add             r0,  r0,  #2
+        transpose_q_4x4 q11, q12, d22, d23, d24, d25
+        vst1.32         {d22[0]}, [r12], r1
+        vst1.32         {d22[1]}, [r0],  r1
+        vst1.32         {d23[0]}, [r12], r1
+        vst1.32         {d23[1]}, [r0],  r1
+        vst1.32         {d24[0]}, [r12], r1
+        vst1.32         {d24[1]}, [r0],  r1
+        vst1.32         {d25[0]}, [r12], r1
+        vst1.32         {d25[1]}, [r0],  r1
+        bx              lr
+endfunc
+
+function vp9_loop_filter_v_16_neon
+        sub             r12, r0,  r1, lsl #3
+        @ Read p7-p0 using r12 and q0-q7 using r0
+        vld1.8          {d16}, [r12,:64], r1 @ p7
+        vld1.8          {d24}, [r0, :64], r1 @ q0
+        vld1.8          {d17}, [r12,:64], r1 @ p6
+        vld1.8          {d25}, [r0, :64], r1 @ q1
+        vld1.8          {d18}, [r12,:64], r1 @ p5
+        vld1.8          {d26}, [r0, :64], r1 @ q2
+        vld1.8          {d19}, [r12,:64], r1 @ p4
+        vld1.8          {d27}, [r0, :64], r1 @ q3
+        vld1.8          {d20}, [r12,:64], r1 @ p3
+        vld1.8          {d28}, [r0, :64], r1 @ q4
+        vld1.8          {d21}, [r12,:64], r1 @ p2
+        vld1.8          {d29}, [r0, :64], r1 @ q5
+        vld1.8          {d22}, [r12,:64], r1 @ p1
+        vld1.8          {d30}, [r0, :64], r1 @ q6
+        vld1.8          {d23}, [r12,:64], r1 @ p0
+        vld1.8          {d31}, [r0, :64], r1 @ q7
+        sub             r12, r12, r1, lsl #3
+        sub             r0,  r0,  r1, lsl #3
+        add             r12, r12, r1
+
+        loop_filter_16
+
+        @ If we did the flat8out part, we get the output in
+        @ d2-d17 (skipping d7 and d16). r12 points to r0 - 7 * stride,
+        @ store d2-d9 there, and d10-d17 into r0.
+        vst1.8          {d2},  [r12,:64], r1
+        vst1.8          {d10}, [r0, :64], r1
+        vst1.8          {d3},  [r12,:64], r1
+        vst1.8          {d11}, [r0, :64], r1
+        vst1.8          {d4},  [r12,:64], r1
+        vst1.8          {d12}, [r0, :64], r1
+        vst1.8          {d5},  [r12,:64], r1
+        vst1.8          {d13}, [r0, :64], r1
+        vst1.8          {d6},  [r12,:64], r1
+        vst1.8          {d14}, [r0, :64], r1
+        vst1.8          {d8},  [r12,:64], r1
+        vst1.8          {d15}, [r0, :64], r1
+        vst1.8          {d9},  [r12,:64], r1
+        vst1.8          {d17}, [r0, :64], r1
+        sub             r0,  r0,  r1, lsl #3
+        add             r0,  r0,  r1
+
+9:
+        bx              lr
+
+8:
+        add             r12, r12, r1, lsl #2
+        @ If we didn't do the flat8out part, the output is left in the
+        @ input registers.
+        vst1.8          {d21}, [r12,:64], r1
+        vst1.8          {d24}, [r0, :64], r1
+        vst1.8          {d22}, [r12,:64], r1
+        vst1.8          {d25}, [r0, :64], r1
+        vst1.8          {d23}, [r12,:64], r1
+        vst1.8          {d26}, [r0, :64], r1
+        sub             r0,  r0,  r1, lsl #1
+        sub             r0,  r0,  r1
+        bx              lr
+7:
+        sub             r12, r0,  r1, lsl #1
+        vst1.8          {d22}, [r12,:64], r1
+        vst1.8          {d24}, [r0, :64], r1
+        vst1.8          {d23}, [r12,:64], r1
+        vst1.8          {d25}, [r0, :64], r1
+        sub             r0,  r0,  r1, lsl #1
+        bx              lr
+endfunc
+
+function ff_vp9_loop_filter_v_16_8_neon, export=1
+        ldr             r12, [sp]
+        push            {lr}
+        vpush           {q4-q7}
+        push            {r12}
+        bl              vp9_loop_filter_v_16_neon
+        add             sp,  sp,  #4
+        vpop            {q4-q7}
+        pop             {pc}
+endfunc
+
+function ff_vp9_loop_filter_v_16_16_neon, export=1
+        ldr             r12, [sp]
+        // The filter clobbers r2 and r3, but we need to keep them for the second round
+        push            {r2, r3, lr}
+        vpush           {q4-q7}
+        push            {r12}
+        bl              vp9_loop_filter_v_16_neon
+        add             r0,  #8
+        ldr             r2,  [sp, #68]
+        ldr             r3,  [sp, #72]
+        bl              vp9_loop_filter_v_16_neon
+        add             sp,  sp,  #4
+        vpop            {q4-q7}
+        pop             {r2, r3, pc}
+endfunc
+
+function vp9_loop_filter_h_16_neon
+        sub             r12, r0,  #8
+        vld1.8          {d16}, [r12,:64], r1
+        vld1.8          {d24}, [r0, :64], r1
+        vld1.8          {d17}, [r12,:64], r1
+        vld1.8          {d25}, [r0, :64], r1
+        vld1.8          {d18}, [r12,:64], r1
+        vld1.8          {d26}, [r0, :64], r1
+        vld1.8          {d19}, [r12,:64], r1
+        vld1.8          {d27}, [r0, :64], r1
+        vld1.8          {d20}, [r12,:64], r1
+        vld1.8          {d28}, [r0, :64], r1
+        vld1.8          {d21}, [r12,:64], r1
+        vld1.8          {d29}, [r0, :64], r1
+        vld1.8          {d22}, [r12,:64], r1
+        vld1.8          {d30}, [r0, :64], r1
+        vld1.8          {d23}, [r12,:64], r1
+        vld1.8          {d31}, [r0, :64], r1
+        sub             r0,  r0,  r1, lsl #3
+        sub             r12, r12, r1, lsl #3
+
+        @ The 16x8 pixels read above is in two 8x8 blocks; the left
+        @ half in d16-d23, and the right half in d24-d31. Do two 8x8 transposes
+        @ of this, to get one column per register. This could be done with two
+        @ transpose_8x8 as below, but this takes advantage of the q registers.
+        transpose16_4x4 q8,  q9,  q10, q11, q12, q13, q14, q15
+        vtrn.8          d16, d17
+        vtrn.8          d18, d19
+        vtrn.8          d20, d21
+        vtrn.8          d22, d23
+        vtrn.8          d24, d25
+        vtrn.8          d26, d27
+        vtrn.8          d28, d29
+        vtrn.8          d30, d31
+
+        loop_filter_16
+
+        @ Transpose back; this is the same transpose as above, but
+        @ we can't take advantage of q registers for the transpose, since
+        @ all d registers in the transpose aren't consecutive.
+        transpose_8x8   d16, d2,  d3,  d4,  d5,  d6,  d8,  d9
+        transpose_8x8   d10, d11, d12, d13, d14, d15, d17, d31
+
+        vst1.8          {d16}, [r12,:64], r1
+        vst1.8          {d10}, [r0, :64], r1
+
+        vst1.8          {d2},  [r12,:64], r1
+        vst1.8          {d11}, [r0, :64], r1
+
+        vst1.8          {d3},  [r12,:64], r1
+        vst1.8          {d12}, [r0, :64], r1
+
+        vst1.8          {d4},  [r12,:64], r1
+        vst1.8          {d13}, [r0, :64], r1
+
+        vst1.8          {d5},  [r12,:64], r1
+        vst1.8          {d14}, [r0, :64], r1
+
+        vst1.8          {d6},  [r12,:64], r1
+        vst1.8          {d15}, [r0, :64], r1
+
+        vst1.8          {d8},  [r12,:64], r1
+        vst1.8          {d17}, [r0, :64], r1
+
+        vst1.8          {d9},  [r12,:64], r1
+        vst1.8          {d31}, [r0, :64], r1
+        sub             r0,  r0,  r1, lsl #3
+9:
+        bx              lr
+8:
+        @ The same writeback as in loop_filter_h_8_8
+        sub             r12, r0,  #4
+        add             r0,  r12, r1, lsl #2
+        transpose_q_8x8 q10, q11, q12, q13, d20, d21, d22, d23, d24, d25, d26, d27
+
+        vst1.8          {d20}, [r12], r1
+        vst1.8          {d24}, [r0],  r1
+        vst1.8          {d21}, [r12], r1
+        vst1.8          {d25}, [r0],  r1
+        vst1.8          {d22}, [r12], r1
+        vst1.8          {d26}, [r0],  r1
+        vst1.8          {d23}, [r12], r1
+        vst1.8          {d27}, [r0],  r1
+        sub             r0,  r0,  r1, lsl #3
+        add             r0,  r0,  #4
+        bx              lr
+7:
+        @ The same writeback as in loop_filter_h_4_8
+        sub             r12, r0,  #2
+        add             r0,  r12, r1, lsl #2
+        transpose_q_4x4 q11, q12, d22, d23, d24, d25
+        vst1.32         {d22[0]}, [r12], r1
+        vst1.32         {d22[1]}, [r0],  r1
+        vst1.32         {d23[0]}, [r12], r1
+        vst1.32         {d23[1]}, [r0],  r1
+        vst1.32         {d24[0]}, [r12], r1
+        vst1.32         {d24[1]}, [r0],  r1
+        vst1.32         {d25[0]}, [r12], r1
+        vst1.32         {d25[1]}, [r0],  r1
+        sub             r0,  r0,  r1, lsl #3
+        add             r0,  r0,  #2
+        bx              lr
+endfunc
+
+function ff_vp9_loop_filter_h_16_8_neon, export=1
+        ldr             r12, [sp]
+        push            {lr}
+        vpush           {q4-q7}
+        push            {r12}
+        bl              vp9_loop_filter_h_16_neon
+        add             sp,  sp,  #4
+        vpop            {q4-q7}
+        pop             {pc}
+endfunc
+
+function ff_vp9_loop_filter_h_16_16_neon, export=1
+        ldr             r12, [sp]
+        // The filter clobbers r2 and r3, but we need to keep them for the second round
+        push            {r2, r3, lr}
+        vpush           {q4-q7}
+        push            {r12}
+        bl              vp9_loop_filter_h_16_neon
+        add             r0,  r0,  r1, lsl #3
+        ldr             r2,  [sp, #68]
+        ldr             r3,  [sp, #72]
+        bl              vp9_loop_filter_h_16_neon
+        add             sp,  sp,  #4
+        vpop            {q4-q7}
+        pop             {r2, r3, pc}
+endfunc
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp9mc_16bpp_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/vp9mc_16bpp_neon.S
new file mode 100644
index 00000000000..f6ec0375f26
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp9mc_16bpp_neon.S
@@ -0,0 +1,615 @@
+/*
+ * Copyright (c) 2017 Google Inc.
+ *
+ * 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/arm/asm.S"
+
+@ All public functions in this file have the following signature:
+@ typedef void (*vp9_mc_func)(uint8_t *dst, ptrdiff_t dst_stride,
+@                            const uint8_t *ref, ptrdiff_t ref_stride,
+@                            int h, int mx, int my);
+
+function ff_vp9_copy128_neon, export=1
+        ldr             r12, [sp]
+        sub             r1,  r1,  #96
+        sub             r3,  r3,  #96
+1:
+        subs            r12, r12, #1
+        vld1.16         {q0,  q1},  [r2]!
+        vst1.16         {q0,  q1},  [r0, :128]!
+        vld1.16         {q2,  q3},  [r2]!
+        vst1.16         {q2,  q3},  [r0, :128]!
+        vld1.16         {q8,  q9},  [r2]!
+        vst1.16         {q8,  q9},  [r0, :128]!
+        vld1.16         {q10, q11}, [r2], r3
+        vst1.16         {q10, q11}, [r0, :128], r1
+        bne             1b
+        bx              lr
+endfunc
+
+function ff_vp9_avg64_16_neon, export=1
+        push            {lr}
+        ldr             r12, [sp, #4]
+        sub             r1,  r1,  #96
+        sub             r3,  r3,  #96
+        mov             lr,  r0
+1:
+        subs            r12, r12, #1
+        vld1.16         {q8,  q9},  [r2]!
+        vld1.16         {q0,  q1},  [r0, :128]!
+        vld1.16         {q10, q11}, [r2]!
+        vrhadd.u16      q0,  q0,  q8
+        vld1.16         {q2,  q3},  [r0, :128]!
+        vrhadd.u16      q1,  q1,  q9
+        vld1.16         {q12, q13}, [r2]!
+        vrhadd.u16      q2,  q2,  q10
+        vst1.16         {q0,  q1},  [lr, :128]!
+        vrhadd.u16      q3,  q3,  q11
+        vld1.16         {q8,  q9},  [r0, :128]!
+        vst1.16         {q2,  q3},  [lr, :128]!
+        vrhadd.u16      q8,  q8,  q12
+        vld1.16         {q14, q15}, [r2], r3
+        vrhadd.u16      q9,  q9,  q13
+        vld1.16         {q10, q11}, [r0, :128], r1
+        vrhadd.u16      q10, q10, q14
+        vst1.16         {q8,  q9},  [lr, :128]!
+        vrhadd.u16      q11, q11, q15
+        vst1.16         {q10, q11}, [lr, :128], r1
+        bne             1b
+        pop             {pc}
+endfunc
+
+function ff_vp9_avg32_16_neon, export=1
+        push            {lr}
+        ldr             r12, [sp, #4]
+        sub             r1,  r1,  #32
+        sub             r3,  r3,  #32
+        mov             lr,  r0
+1:
+        subs            r12, r12, #1
+        vld1.16         {q8,  q9},  [r2]!
+        vld1.16         {q0,  q1},  [r0, :128]!
+        vld1.16         {q10, q11}, [r2], r3
+        vrhadd.u16      q0,  q0,  q8
+        vld1.16         {q2,  q3},  [r0, :128], r1
+        vrhadd.u16      q1,  q1,  q9
+        vrhadd.u16      q2,  q2,  q10
+        vst1.16         {q0, q1},  [lr, :128]!
+        vrhadd.u16      q3,  q3,  q11
+        vst1.16         {q2, q3},  [lr, :128], r1
+        bne             1b
+        pop             {pc}
+endfunc
+
+function ff_vp9_avg16_16_neon, export=1
+        ldr             r12, [sp]
+1:
+        subs            r12, r12, #1
+        vld1.16         {q2,  q3},  [r2], r3
+        vld1.16         {q0,  q1},  [r0, :128]
+        vrhadd.u16      q0,  q0,  q2
+        vrhadd.u16      q1,  q1,  q3
+        vst1.16         {q0,  q1},  [r0, :128], r1
+        bne             1b
+        bx              lr
+endfunc
+
+function ff_vp9_avg8_16_neon, export=1
+        push            {lr}
+        ldr             r12, [sp, #4]
+        mov             lr,  r0
+1:
+        subs            r12, r12, #2
+        vld1.16         {q2},  [r2], r3
+        vld1.16         {q0},  [r0, :128], r1
+        vld1.16         {q3},  [r2], r3
+        vrhadd.u16      q0,  q0,  q2
+        vld1.16         {q1},  [r0, :128], r1
+        vrhadd.u16      q1,  q1,  q3
+        vst1.16         {q0},  [lr, :128], r1
+        vst1.16         {q1},  [lr, :128], r1
+        bne             1b
+        pop             {pc}
+endfunc
+
+function ff_vp9_avg4_16_neon, export=1
+        ldr             r12, [sp]
+1:
+        subs            r12, r12, #2
+        vld1.16         {d2},  [r2], r3
+        vld1.16         {d0},  [r0, :64], r1
+        vld1.16         {d3},  [r2], r3
+        vrhadd.u16      d0,  d0,  d2
+        vld1.16         {d1},  [r0, :64]
+        sub             r0,  r0,  r1
+        vrhadd.u16      d1,  d1,  d3
+        vst1.16         {d0},  [r0, :64], r1
+        vst1.16         {d1},  [r0, :64], r1
+        bne             1b
+        bx              lr
+endfunc
+
+@ Helper macros for vmull/vmlal with a constant from either d0 or d1 depending on index
+.macro vmull_lane dst, src, idx
+.if \idx < 4
+       vmull.s16        \dst, \src, d0[\idx]
+.else
+       vmull.s16        \dst, \src, d1[\idx - 4]
+.endif
+.endm
+.macro vmlal_lane dst, src, idx
+.if \idx < 4
+       vmlal.s16        \dst, \src, d0[\idx]
+.else
+       vmlal.s16        \dst, \src, d1[\idx - 4]
+.endif
+.endm
+
+@ Extract a vector from src1-src2 and src3-src4, andmultiply-accumulate
+@ into dst1 and dst3 (or dst1-dst2 and dst3-dst4 for size >= 8)
+.macro extmlal dst1, dst2, dst3, dst4, src1, src2, src3, src4, offset, size
+        vext.8          q14, \src1, \src2, #(2*\offset)
+        vext.8          q15, \src3, \src4, #(2*\offset)
+        vmlal_lane      \dst1,  d28, \offset
+        vmlal_lane      \dst3,  d30, \offset
+.if \size >= 8
+        vmlal_lane      \dst2,  d29, \offset
+        vmlal_lane      \dst4,  d31, \offset
+.endif
+.endm
+
+
+@ Instantiate a horizontal filter function for the given size.
+@ This can work on 4 or 8 pixels in parallel; for larger
+@ widths it will do 8 pixels at a time and loop horizontally.
+@ The actual width (in bytes) is passed in r5, the height in r4 and
+@ the filter coefficients in r12.
+.macro do_8tap_h type, size
+function \type\()_8tap_\size\()h
+        sub             r2,  r2,  #6
+        add             r6,  r0,  r1
+        add             r7,  r2,  r3
+        add             r1,  r1,  r1
+        add             r3,  r3,  r3
+        @ Only size >= 8 loops horizontally and needs
+        @ reduced dst stride
+.if \size >= 8
+        sub             r1,  r1,  r5
+.endif
+        @ size >= 8 loads two qwords and increments r2,
+        @ for size 4 it's enough with three dwords and no
+        @ postincrement
+.if \size >= 8
+        sub             r3,  r3,  r5
+        sub             r3,  r3,  #16
+.endif
+        @ Load the filter vector
+        vld1.16         {q0},  [r12,:128]
+1:
+.if \size >= 8
+        mov             r12, r5
+.endif
+        @ Load src
+.if \size >= 8
+        vld1.16         {q8,  q9},  [r2]!
+        vld1.16         {q10, q11}, [r7]!
+.else
+        vld1.16         {d16, d17, d18}, [r2]
+        vld1.16         {d20, d21, d22}, [r7]
+.endif
+2:
+
+        vmull.s16       q1,  d16, d0[0]
+        vmull.s16       q12, d20, d0[0]
+.if \size >= 8
+        vmull.s16       q2,  d17, d0[0]
+        vmull.s16       q13, d21, d0[0]
+.endif
+        extmlal         q1,  q2,  q12, q13, q8,  q9,  q10, q11, 1, \size
+        extmlal         q1,  q2,  q12, q13, q8,  q9,  q10, q11, 2, \size
+        extmlal         q1,  q2,  q12, q13, q8,  q9,  q10, q11, 3, \size
+        extmlal         q1,  q2,  q12, q13, q8,  q9,  q10, q11, 4, \size
+        extmlal         q1,  q2,  q12, q13, q8,  q9,  q10, q11, 5, \size
+        extmlal         q1,  q2,  q12, q13, q8,  q9,  q10, q11, 6, \size
+        extmlal         q1,  q2,  q12, q13, q8,  q9,  q10, q11, 7, \size
+
+        @ Round, shift and saturate.
+        @ The vqrshrun takes care of clamping negative values to zero, but
+        @ we manually need to do vmin with the max pixel value.
+        vqrshrun.s32    d2,  q1,  #7
+        vqrshrun.s32    d24, q12, #7
+.if \size >= 8
+        vqrshrun.s32    d3,  q2,  #7
+        vqrshrun.s32    d25, q13, #7
+        vmin.u16        q1,  q1,  q3
+        vmin.u16        q12, q12, q3
+.else
+        vmin.u16        d2,  d2,  d6
+        vmin.u16        d24, d24, d6
+.endif
+        @ Average
+.ifc \type,avg
+.if \size >= 8
+        vld1.16         {q14}, [r0,:128]
+        vld1.16         {q15}, [r6,:128]
+        vrhadd.u16      q1,  q1,  q14
+        vrhadd.u16      q12, q12, q15
+.else
+        vld1.16         {d28}, [r0,:64]
+        vld1.16         {d30}, [r6,:64]
+        vrhadd.u16      d2,  d2,  d28
+        vrhadd.u16      d24, d24, d30
+.endif
+.endif
+        @ Store and loop horizontally (for size >= 8)
+.if \size >= 8
+        subs            r12, r12, #16
+        vst1.16         {q1},  [r0,:128]!
+        vst1.16         {q12}, [r6,:128]!
+        beq             3f
+        vmov            q8,  q9
+        vmov            q10, q11
+        vld1.16         {q9},  [r2]!
+        vld1.16         {q11}, [r7]!
+        b               2b
+.else @ \size == 4
+        vst1.16         {d2},  [r0,:64]
+        vst1.16         {d24}, [r6,:64]
+.endif
+3:
+        @ Loop vertically
+        add             r0,  r0,  r1
+        add             r6,  r6,  r1
+        add             r2,  r2,  r3
+        add             r7,  r7,  r3
+        subs            r4,  r4,  #2
+        bne             1b
+        pop             {r4-r7}
+        bx              lr
+endfunc
+.endm
+
+.macro do_8tap_h_size size
+do_8tap_h put, \size
+do_8tap_h avg, \size
+.endm
+
+do_8tap_h_size 4
+do_8tap_h_size 8
+
+.macro do_8tap_h_func type, filter, offset, size, bpp
+function ff_vp9_\type\()_\filter\()\size\()_h_\bpp\()_neon, export=1
+        push            {r4-r7}
+        ldr             r4,  [sp, #16]
+        ldr             r5,  [sp, #20]
+        vmvn.u16        q3,  #((0xffff << \bpp) & 0xffff)
+        movrelx         r12, X(ff_vp9_subpel_filters), r6
+        add             r12, r12, 256*\offset
+        add             r12, r12, r5, lsl #4
+        mov             r5,  #2*\size
+.if \size >= 8
+        b               \type\()_8tap_8h
+.else
+        b               \type\()_8tap_4h
+.endif
+endfunc
+.endm
+
+.macro do_8tap_h_filters size, bpp
+do_8tap_h_func put, regular, 1, \size, \bpp
+do_8tap_h_func avg, regular, 1, \size, \bpp
+do_8tap_h_func put, sharp,   2, \size, \bpp
+do_8tap_h_func avg, sharp,   2, \size, \bpp
+do_8tap_h_func put, smooth,  0, \size, \bpp
+do_8tap_h_func avg, smooth,  0, \size, \bpp
+.endm
+
+.macro do_8tap_h_filters_bpp bpp
+do_8tap_h_filters 64, \bpp
+do_8tap_h_filters 32, \bpp
+do_8tap_h_filters 16, \bpp
+do_8tap_h_filters 8,  \bpp
+do_8tap_h_filters 4,  \bpp
+.endm
+
+do_8tap_h_filters_bpp 10
+do_8tap_h_filters_bpp 12
+
+.ltorg
+
+@ Vertical filters
+
+@ Round, shift and saturate and store qreg1-4
+.macro do_store4 qreg1, dreg1, qreg2, dreg2, qreg3, dreg3, qreg4, dreg4, tmp1, tmp2, tmp3, tmp4, minreg, type
+        vqrshrun.s32    \dreg1,  \qreg1, #7
+        vqrshrun.s32    \dreg2,  \qreg2, #7
+        vqrshrun.s32    \dreg3,  \qreg3, #7
+        vqrshrun.s32    \dreg4,  \qreg4, #7
+.ifc \type,avg
+        vld1.16         {\tmp1},  [r6,:64], r1
+        vld1.16         {\tmp2},  [r6,:64], r1
+        vld1.16         {\tmp3},  [r6,:64], r1
+        vld1.16         {\tmp4},  [r6,:64], r1
+.endif
+        vmin.u16        \dreg1,  \dreg1,  \minreg
+        vmin.u16        \dreg2,  \dreg2,  \minreg
+        vmin.u16        \dreg3,  \dreg3,  \minreg
+        vmin.u16        \dreg4,  \dreg4,  \minreg
+.ifc \type,avg
+        vrhadd.u16      \dreg1,  \dreg1,  \tmp1
+        vrhadd.u16      \dreg2,  \dreg2,  \tmp2
+        vrhadd.u16      \dreg3,  \dreg3,  \tmp3
+        vrhadd.u16      \dreg4,  \dreg4,  \tmp4
+.endif
+        vst1.16         {\dreg1}, [r0,:64], r1
+        vst1.16         {\dreg2}, [r0,:64], r1
+        vst1.16         {\dreg3}, [r0,:64], r1
+        vst1.16         {\dreg4}, [r0,:64], r1
+.endm
+
+@ Round, shift and saturate and store qreg1-4
+@ qreg1-2 belong to one line and qreg3-4 to the second line.
+@ dreg1-2 == qreg1, dreg3-4 == qreg2.
+.macro do_store8 qreg1, qreg2, qreg3, qreg4, dreg1, dreg2, dreg3, dreg4, minreg, type
+        vqrshrun.s32    \dreg1,  \qreg1, #7
+        vqrshrun.s32    \dreg2,  \qreg2, #7
+        vqrshrun.s32    \dreg3,  \qreg3, #7
+        vqrshrun.s32    \dreg4,  \qreg4, #7
+.ifc \type,avg
+        vld1.16         {\qreg3},  [r6,:128], r1
+        vld1.16         {\qreg4},  [r6,:128], r1
+.endif
+        vmin.u16        \qreg1,  \qreg1,  \minreg
+        vmin.u16        \qreg2,  \qreg2,  \minreg
+.ifc \type,avg
+        vrhadd.u16      \qreg1,  \qreg1,  \qreg3
+        vrhadd.u16      \qreg2,  \qreg2,  \qreg4
+.endif
+        vst1.16         {\qreg1}, [r0,:128], r1
+        vst1.16         {\qreg2}, [r0,:128], r1
+.endm
+
+@ Evaluate the filter twice in parallel, from the inputs src1-src9 into dst1-dst2
+@ (src1-src8 into dst1, src2-src9 into dst2).
+.macro convolve4 dst1, dst2, src1, src2, src3, src4, src5, src6, src7, src8, src9, tmp1, tmp2
+        vmull.s16       \dst1, \src1, d0[0]
+        vmull.s16       \dst2, \src2, d0[0]
+        vmull.s16       \tmp1, \src2, d0[1]
+        vmull.s16       \tmp2, \src3, d0[1]
+        vmlal.s16       \dst1, \src3, d0[2]
+        vmlal.s16       \dst2, \src4, d0[2]
+        vmlal.s16       \tmp1, \src4, d0[3]
+        vmlal.s16       \tmp2, \src5, d0[3]
+        vmlal.s16       \dst1, \src5, d1[0]
+        vmlal.s16       \dst2, \src6, d1[0]
+        vmlal.s16       \tmp1, \src6, d1[1]
+        vmlal.s16       \tmp2, \src7, d1[1]
+        vmlal.s16       \dst1, \src7, d1[2]
+        vmlal.s16       \dst2, \src8, d1[2]
+        vmlal.s16       \tmp1, \src8, d1[3]
+        vmlal.s16       \tmp2, \src9, d1[3]
+        vadd.s32        \dst1, \dst1, \tmp1
+        vadd.s32        \dst2, \dst2, \tmp2
+.endm
+
+@ Evaluate the filter twice in parallel. This does the same as convolve4 above,
+@ but with double width (two input/output registers per row).
+.macro convolve8 dst1, dst2, dst3, dst4, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10, src11, src12, src13, src14, src15, src16, src17, src18
+        vmull.s16       \dst1, \src1,  d0[0]
+        vmull.s16       \dst2, \src2,  d0[0]
+        vmull.s16       \dst3, \src3,  d0[0]
+        vmull.s16       \dst4, \src4,  d0[0]
+        vmlal.s16       \dst1, \src3,  d0[1]
+        vmlal.s16       \dst2, \src4,  d0[1]
+        vmlal.s16       \dst3, \src5,  d0[1]
+        vmlal.s16       \dst4, \src6,  d0[1]
+        vmlal.s16       \dst1, \src5,  d0[2]
+        vmlal.s16       \dst2, \src6,  d0[2]
+        vmlal.s16       \dst3, \src7,  d0[2]
+        vmlal.s16       \dst4, \src8,  d0[2]
+        vmlal.s16       \dst1, \src7,  d0[3]
+        vmlal.s16       \dst2, \src8,  d0[3]
+        vmlal.s16       \dst3, \src9,  d0[3]
+        vmlal.s16       \dst4, \src10, d0[3]
+        vmlal.s16       \dst1, \src9,  d1[0]
+        vmlal.s16       \dst2, \src10, d1[0]
+        vmlal.s16       \dst3, \src11, d1[0]
+        vmlal.s16       \dst4, \src12, d1[0]
+        vmlal.s16       \dst1, \src11, d1[1]
+        vmlal.s16       \dst2, \src12, d1[1]
+        vmlal.s16       \dst3, \src13, d1[1]
+        vmlal.s16       \dst4, \src14, d1[1]
+        vmlal.s16       \dst1, \src13, d1[2]
+        vmlal.s16       \dst2, \src14, d1[2]
+        vmlal.s16       \dst3, \src15, d1[2]
+        vmlal.s16       \dst4, \src16, d1[2]
+        vmlal.s16       \dst1, \src15, d1[3]
+        vmlal.s16       \dst2, \src16, d1[3]
+        vmlal.s16       \dst3, \src17, d1[3]
+        vmlal.s16       \dst4, \src18, d1[3]
+.endm
+
+@ Instantiate a vertical filter function for filtering 8 pixels at a time.
+@ The height is passed in r4, the width in r5 and the filter coefficients
+@ in r12.
+.macro do_8tap_8v type
+function \type\()_8tap_8v
+        sub             r2,  r2,  r3, lsl #1
+        sub             r2,  r2,  r3
+        vld1.16         {q0},  [r12, :128]
+1:
+.ifc \type,avg
+        mov             r6,  r0
+.endif
+        mov             r12, r4
+
+        vld1.16         {q5},  [r2], r3
+        vld1.16         {q6},  [r2], r3
+        vld1.16         {q7},  [r2], r3
+        vld1.16         {q8},  [r2], r3
+        vld1.16         {q9},  [r2], r3
+        vld1.16         {q10}, [r2], r3
+        vld1.16         {q11}, [r2], r3
+2:
+        vld1.16         {q12}, [r2], r3
+        vld1.16         {q13}, [r2], r3
+        vld1.16         {q14}, [r2], r3
+        vld1.16         {q15}, [r2], r3
+        convolve8       q2,  q3,  q4,  q5,  d10, d11, d12, d13, d14, d15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27
+        do_store8       q2,  q3,  q4,  q5,  d4,  d5,  d6,  d7,  q1,  \type
+        convolve8       q2,  q3,  q4,  q5,  d14, d15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31
+        do_store8       q2,  q3,  q4,  q5,  d4,  d5,  d6,  d7,  q1,  \type
+
+        subs            r12, r12, #4
+        beq             8f
+
+        vld1.16         {q4},  [r2], r3
+        vld1.16         {q5},  [r2], r3
+        vld1.16         {q6},  [r2], r3
+        vld1.16         {q7},  [r2], r3
+        convolve8       q2,  q3,  q8,  q9,  d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31, d8,  d9,  d10, d11
+        do_store8       q2,  q3,  q8,  q9,  d4,  d5,  d6,  d7,  q1,  \type
+        convolve8       q2,  q3,  q8,  q9,  d22, d23, d24, d25, d26, d27, d28, d29, d30, d31, d8,  d9,  d10, d11, d12, d13, d14, d15
+        do_store8       q2,  q3,  q8,  q9,  d4,  d5,  d6,  d7,  q1,  \type
+
+        subs            r12, r12, #4
+        beq             8f
+
+        vld1.16         {q8},  [r2], r3
+        vld1.16         {q9},  [r2], r3
+        vld1.16         {q10}, [r2], r3
+        vld1.16         {q11}, [r2], r3
+        convolve8       q2,  q3,  q12, q13, d26, d27, d28, d29, d30, d31, d8,  d9,  d10, d11, d12, d13, d14, d15, d16, d17, d18, d19
+        do_store8       q2,  q3,  q12, q13, d4,  d5,  d6,  d7,  q1,  \type
+        convolve8       q2,  q3,  q12, q13, d30, d31, d8,  d9,  d10, d11, d12, d13, d14, d15, d16, d17, d18, d19, d20, d21, d22, d23
+        do_store8       q2,  q3,  q12, q13, d4,  d5,  d6,  d7,  q1,  \type
+
+        subs            r12, r12, #4
+        bne             2b
+
+8:
+        subs            r5,  r5,  #8
+        beq             9f
+        @ r0 -= h * dst_stride
+        mls             r0,  r1,  r4, r0
+        @ r2 -= h * src_stride
+        mls             r2,  r3,  r4, r2
+        @ r2 -= 8 * src_stride
+        sub             r2,  r2,  r3, lsl #3
+        @ r2 += 1 * src_stride
+        add             r2,  r2,  r3
+        add             r2,  r2,  #16
+        add             r0,  r0,  #16
+        b               1b
+9:
+        vpop            {q4-q7}
+        pop             {r4-r6}
+        bx              lr
+endfunc
+.endm
+
+do_8tap_8v put
+do_8tap_8v avg
+
+@ Instantiate a vertical filter function for filtering a 4 pixels wide
+@ slice. This only is designed to work for 4 or 8 output lines.
+.macro do_8tap_4v type
+function \type\()_8tap_4v
+        sub             r2,  r2,  r3, lsl #1
+        sub             r2,  r2,  r3
+        vld1.16         {q0},  [r12, :128]
+.ifc \type,avg
+        mov             r6,  r0
+.endif
+
+        vld1.16         {d16}, [r2], r3
+        vld1.16         {d17}, [r2], r3
+        vld1.16         {d18}, [r2], r3
+        vld1.16         {d19}, [r2], r3
+        vld1.16         {d20}, [r2], r3
+        vld1.16         {d21}, [r2], r3
+        vld1.16         {d22}, [r2], r3
+        vld1.16         {d23}, [r2], r3
+        vld1.16         {d24}, [r2], r3
+        vld1.16         {d25}, [r2], r3
+        vld1.16         {d26}, [r2], r3
+        convolve4       q2,  q3,  d16, d17, d18, d19, d20, d21, d22, d23, d24, q14, q15
+        convolve4       q14, q15, d18, d19, d20, d21, d22, d23, d24, d25, d26, q8,  q9
+        do_store4       q2,  d4,  q3,  d6,  q14, d28, q15, d30, d5,  d7,  d29, d31, d2,  \type
+
+        subs            r4,  r4,  #4
+        beq             9f
+
+        vld1.16         {d27}, [r2], r3
+        vld1.16         {d28}, [r2], r3
+        vld1.16         {d29}, [r2], r3
+        vld1.16         {d30}, [r2], r3
+        convolve4       q2,  q3,  d20, d21, d22, d23, d24, d25, d26, d27, d28, q8,  q9
+        convolve4       q8,  q9,  d22, d23, d24, d25, d26, d27, d28, d29, d30, q10, q11
+        do_store4       q2,  d4,  q3,  d6,  q8,  d16, q9,  d18, d5,  d7,  d17, d19, d2,  \type
+
+9:
+        pop             {r4-r6}
+        bx              lr
+endfunc
+.endm
+
+do_8tap_4v put
+do_8tap_4v avg
+
+.macro do_8tap_v_func type, filter, offset, size, bpp
+function ff_vp9_\type\()_\filter\()\size\()_v_\bpp\()_neon, export=1
+        push            {r4-r6}
+        ldr             r4,  [sp, #12]
+        ldr             r5,  [sp, #20]
+.if \size >= 8
+        vpush           {q4-q7}
+.endif
+        vmvn.u16        q1,  #((0xffff << \bpp) & 0xffff)
+        movrelx         r12, X(ff_vp9_subpel_filters), r6
+        add             r12, r12, 256*\offset
+        add             r12, r12, r5, lsl #4
+        mov             r5,  #\size
+.if \size >= 8
+        b               \type\()_8tap_8v
+.else
+        b               \type\()_8tap_4v
+.endif
+endfunc
+.endm
+
+.macro do_8tap_v_filters size, bpp
+do_8tap_v_func put, regular, 1, \size, \bpp
+do_8tap_v_func avg, regular, 1, \size, \bpp
+do_8tap_v_func put, sharp,   2, \size, \bpp
+do_8tap_v_func avg, sharp,   2, \size, \bpp
+do_8tap_v_func put, smooth,  0, \size, \bpp
+do_8tap_v_func avg, smooth,  0, \size, \bpp
+.endm
+
+.macro do_8tap_v_filters_bpp bpp
+do_8tap_v_filters 64, \bpp
+do_8tap_v_filters 32, \bpp
+do_8tap_v_filters 16, \bpp
+do_8tap_v_filters 8,  \bpp
+do_8tap_v_filters 4,  \bpp
+.endm
+
+do_8tap_v_filters_bpp 10
+do_8tap_v_filters_bpp 12
diff --git a/mythtv/external/FFmpeg/libavcodec/arm/vp9mc_neon.S b/mythtv/external/FFmpeg/libavcodec/arm/vp9mc_neon.S
new file mode 100644
index 00000000000..bd8cda7c308
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/arm/vp9mc_neon.S
@@ -0,0 +1,720 @@
+/*
+ * Copyright (c) 2016 Google Inc.
+ *
+ * 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/arm/asm.S"
+
+@ All public functions in this file have the following signature:
+@ typedef void (*vp9_mc_func)(uint8_t *dst, ptrdiff_t dst_stride,
+@                            const uint8_t *ref, ptrdiff_t ref_stride,
+@                            int h, int mx, int my);
+
+function ff_vp9_copy64_neon, export=1
+        ldr             r12, [sp]
+        sub             r1,  r1,  #32
+        sub             r3,  r3,  #32
+1:
+        vld1.8          {q0,  q1},  [r2]!
+        vst1.8          {q0,  q1},  [r0, :128]!
+        vld1.8          {q2,  q3},  [r2], r3
+        subs            r12, r12, #1
+        vst1.8          {q2,  q3},  [r0, :128], r1
+        bne             1b
+        bx              lr
+endfunc
+
+function ff_vp9_avg64_neon, export=1
+        push            {lr}
+        ldr             r12, [sp, #4]
+        sub             r1,  r1,  #32
+        sub             r3,  r3,  #32
+        mov             lr,  r0
+1:
+        vld1.8          {q8,  q9},  [r2]!
+        vld1.8          {q0,  q1},  [r0, :128]!
+        vld1.8          {q10, q11}, [r2], r3
+        vrhadd.u8       q0,  q0,  q8
+        vld1.8          {q2,  q3},  [r0, :128], r1
+        vrhadd.u8       q1,  q1,  q9
+        vrhadd.u8       q2,  q2,  q10
+        vst1.8          {q0,  q1},  [lr, :128]!
+        vrhadd.u8       q3,  q3,  q11
+        vst1.8          {q2,  q3},  [lr, :128], r1
+        subs            r12, r12, #1
+        bne             1b
+        pop             {pc}
+endfunc
+
+function ff_vp9_copy32_neon, export=1
+        ldr             r12, [sp]
+1:
+        vld1.8          {q0,  q1},  [r2], r3
+        subs            r12, r12, #1
+        vst1.8          {q0,  q1},  [r0, :128], r1
+        bne             1b
+        bx              lr
+endfunc
+
+function ff_vp9_avg32_neon, export=1
+        ldr             r12, [sp]
+1:
+        vld1.8          {q2,  q3},  [r2], r3
+        vld1.8          {q0,  q1},  [r0, :128]
+        vrhadd.u8       q0,  q0,  q2
+        vrhadd.u8       q1,  q1,  q3
+        subs            r12, r12, #1
+        vst1.8          {q0,  q1},  [r0, :128], r1
+        bne             1b
+        bx              lr
+endfunc
+
+function ff_vp9_copy16_neon, export=1
+        push            {r4,lr}
+        ldr             r12, [sp, #8]
+        add             r4,  r0,  r1
+        add             lr,  r2,  r3
+        add             r1,  r1,  r1
+        add             r3,  r3,  r3
+1:
+        vld1.8          {q0},  [r2], r3
+        vld1.8          {q1},  [lr], r3
+        subs            r12, r12, #2
+        vst1.8          {q0},  [r0, :128], r1
+        vst1.8          {q1},  [r4, :128], r1
+        bne             1b
+        pop             {r4,pc}
+endfunc
+
+function ff_vp9_avg16_neon, export=1
+        push            {lr}
+        ldr             r12, [sp, #4]
+        mov             lr,  r0
+1:
+        vld1.8          {q2},  [r2], r3
+        vld1.8          {q0},  [r0, :128], r1
+        vld1.8          {q3},  [r2], r3
+        vrhadd.u8       q0,  q0,  q2
+        vld1.8          {q1},  [r0, :128], r1
+        vrhadd.u8       q1,  q1,  q3
+        subs            r12, r12, #2
+        vst1.8          {q0},  [lr, :128], r1
+        vst1.8          {q1},  [lr, :128], r1
+        bne             1b
+        pop             {pc}
+endfunc
+
+function ff_vp9_copy8_neon, export=1
+        ldr             r12, [sp]
+1:
+        vld1.8          {d0},  [r2], r3
+        vld1.8          {d1},  [r2], r3
+        subs            r12, r12, #2
+        vst1.8          {d0},  [r0, :64], r1
+        vst1.8          {d1},  [r0, :64], r1
+        bne             1b
+        bx              lr
+endfunc
+
+function ff_vp9_avg8_neon, export=1
+        ldr             r12, [sp]
+1:
+        vld1.8          {d2},  [r2], r3
+        vld1.8          {d0},  [r0, :64], r1
+        vld1.8          {d3},  [r2], r3
+        vrhadd.u8       d0,  d0,  d2
+        vld1.8          {d1},  [r0, :64]
+        sub             r0,  r0,  r1
+        vrhadd.u8       d1,  d1,  d3
+        subs            r12, r12, #2
+        vst1.8          {d0},  [r0, :64], r1
+        vst1.8          {d1},  [r0, :64], r1
+        bne             1b
+        bx              lr
+endfunc
+
+function ff_vp9_copy4_neon, export=1
+        ldr             r12, [sp]
+1:
+        vld1.32         {d0[]},   [r2], r3
+        vld1.32         {d1[]},   [r2], r3
+        vst1.32         {d0[0]},  [r0, :32], r1
+        vld1.32         {d2[]},   [r2], r3
+        vst1.32         {d1[0]},  [r0, :32], r1
+        vld1.32         {d3[]},   [r2], r3
+        subs            r12, r12, #4
+        vst1.32         {d2[0]},  [r0, :32], r1
+        vst1.32         {d3[0]},  [r0, :32], r1
+        bne             1b
+        bx              lr
+endfunc
+
+function ff_vp9_avg4_neon, export=1
+        push            {lr}
+        ldr             r12, [sp, #4]
+        mov             lr,  r0
+1:
+        vld1.32         {d4[]},   [r2], r3
+        vld1.32         {d0[]},   [r0, :32], r1
+        vld1.32         {d5[]},   [r2], r3
+        vrhadd.u8       d0,  d0,  d4
+        vld1.32         {d1[]},   [r0, :32], r1
+        vld1.32         {d6[]},   [r2], r3
+        vrhadd.u8       d1,  d1,  d5
+        vld1.32         {d2[]},   [r0, :32], r1
+        vld1.32         {d7[]},   [r2], r3
+        vrhadd.u8       d2,  d2,  d6
+        vld1.32         {d3[]},   [r0, :32], r1
+        subs            r12, r12, #4
+        vst1.32         {d0[0]},  [lr, :32], r1
+        vrhadd.u8       d3,  d3,  d7
+        vst1.32         {d1[0]},  [lr, :32], r1
+        vst1.32         {d2[0]},  [lr, :32], r1
+        vst1.32         {d3[0]},  [lr, :32], r1
+        bne             1b
+        pop             {pc}
+endfunc
+
+@ Helper macros for vmul/vmla with a constant from either d0 or d1 depending on index
+.macro vmul_lane dst, src, idx
+.if \idx < 4
+       vmul.s16         \dst, \src, d0[\idx]
+.else
+       vmul.s16         \dst, \src, d1[\idx - 4]
+.endif
+.endm
+.macro vmla_lane dst, src, idx
+.if \idx < 4
+       vmla.s16         \dst, \src, d0[\idx]
+.else
+       vmla.s16         \dst, \src, d1[\idx - 4]
+.endif
+.endm
+
+@ Extract a vector from src1-src2 and src4-src5 (src1-src3 and src4-src6
+@ for size >= 16), and multiply-accumulate into dst1 and dst3 (or
+@ dst1-dst2 and dst3-dst4 for size >= 16)
+.macro extmla dst1, dst2, dst3, dst4, dst1d, dst3d, src1, src2, src3, src4, src5, src6, offset, size
+        vext.8          q14, \src1, \src2, #(2*\offset)
+        vext.8          q15, \src4, \src5, #(2*\offset)
+.if \size >= 16
+        vmla_lane       \dst1,  q14, \offset
+        vext.8          q5,  \src2, \src3, #(2*\offset)
+        vmla_lane       \dst3,  q15, \offset
+        vext.8          q6,  \src5, \src6, #(2*\offset)
+        vmla_lane       \dst2,  q5,  \offset
+        vmla_lane       \dst4,  q6,  \offset
+.elseif \size == 8
+        vmla_lane       \dst1,  q14, \offset
+        vmla_lane       \dst3,  q15, \offset
+.else
+        vmla_lane       \dst1d, d28, \offset
+        vmla_lane       \dst3d, d30, \offset
+.endif
+.endm
+@ The same as above, but don't accumulate straight into the
+@ destination, but use a temp register and accumulate with saturation.
+.macro extmulqadd dst1, dst2, dst3, dst4, dst1d, dst3d, src1, src2, src3, src4, src5, src6, offset, size
+        vext.8          q14, \src1, \src2, #(2*\offset)
+        vext.8          q15, \src4, \src5, #(2*\offset)
+.if \size >= 16
+        vmul_lane       q14, q14, \offset
+        vext.8          q5,  \src2, \src3, #(2*\offset)
+        vmul_lane       q15, q15, \offset
+        vext.8          q6,  \src5, \src6, #(2*\offset)
+        vmul_lane       q5,  q5,  \offset
+        vmul_lane       q6,  q6,  \offset
+.elseif \size == 8
+        vmul_lane       q14, q14, \offset
+        vmul_lane       q15, q15, \offset
+.else
+        vmul_lane       d28, d28, \offset
+        vmul_lane       d30, d30, \offset
+.endif
+.if \size == 4
+        vqadd.s16       \dst1d, \dst1d, d28
+        vqadd.s16       \dst3d, \dst3d, d30
+.else
+        vqadd.s16       \dst1,  \dst1,  q14
+        vqadd.s16       \dst3,  \dst3,  q15
+.if \size >= 16
+        vqadd.s16       \dst2,  \dst2,  q5
+        vqadd.s16       \dst4,  \dst4,  q6
+.endif
+.endif
+.endm
+
+
+@ Instantiate a horizontal filter function for the given size.
+@ This can work on 4, 8 or 16 pixels in parallel; for larger
+@ widths it will do 16 pixels at a time and loop horizontally.
+@ The actual width is passed in r5, the height in r4 and
+@ the filter coefficients in r12. idx2 is the index of the largest
+@ filter coefficient (3 or 4) and idx1 is the other one of them.
+.macro do_8tap_h type, size, idx1, idx2
+function \type\()_8tap_\size\()h_\idx1\idx2
+        sub             r2,  r2,  #3
+        add             r6,  r0,  r1
+        add             r7,  r2,  r3
+        add             r1,  r1,  r1
+        add             r3,  r3,  r3
+        @ Only size >= 16 loops horizontally and needs
+        @ reduced dst stride
+.if \size >= 16
+        sub             r1,  r1,  r5
+.endif
+        @ size >= 16 loads two qwords and increments r2,
+        @ for size 4/8 it's enough with one qword and no
+        @ postincrement
+.if \size >= 16
+        sub             r3,  r3,  r5
+        sub             r3,  r3,  #8
+.endif
+        @ Load the filter vector
+        vld1.16         {q0},  [r12,:128]
+1:
+.if \size >= 16
+        mov             r12, r5
+.endif
+        @ Load src
+.if \size >= 16
+        vld1.8          {d18, d19, d20}, [r2]!
+        vld1.8          {d24, d25, d26}, [r7]!
+.else
+        vld1.8          {q9},  [r2]
+        vld1.8          {q12}, [r7]
+.endif
+        vmovl.u8        q8,  d18
+        vmovl.u8        q9,  d19
+        vmovl.u8        q11, d24
+        vmovl.u8        q12, d25
+.if \size >= 16
+        vmovl.u8        q10, d20
+        vmovl.u8        q13, d26
+.endif
+2:
+
+        @ Accumulate, adding idx2 last with a separate
+        @ saturating add. The positive filter coefficients
+        @ for all indices except idx2 must add up to less
+        @ than 127 for this not to overflow.
+        vmul.s16        q1,  q8,  d0[0]
+        vmul.s16        q3,  q11, d0[0]
+.if \size >= 16
+        vmul.s16        q2,  q9,  d0[0]
+        vmul.s16        q4,  q12, d0[0]
+.endif
+        extmla          q1,  q2,  q3,  q4,  d2,  d6,  q8,  q9,  q10, q11, q12, q13, 1,     \size
+        extmla          q1,  q2,  q3,  q4,  d2,  d6,  q8,  q9,  q10, q11, q12, q13, 2,     \size
+        extmla          q1,  q2,  q3,  q4,  d2,  d6,  q8,  q9,  q10, q11, q12, q13, \idx1, \size
+        extmla          q1,  q2,  q3,  q4,  d2,  d6,  q8,  q9,  q10, q11, q12, q13, 5,     \size
+        extmla          q1,  q2,  q3,  q4,  d2,  d6,  q8,  q9,  q10, q11, q12, q13, 6,     \size
+        extmla          q1,  q2,  q3,  q4,  d2,  d6,  q8,  q9,  q10, q11, q12, q13, 7,     \size
+        extmulqadd      q1,  q2,  q3,  q4,  d2,  d6,  q8,  q9,  q10, q11, q12, q13, \idx2, \size
+
+        @ Round, shift and saturate
+        vqrshrun.s16    d2,  q1,  #7
+        vqrshrun.s16    d6,  q3,  #7
+.if \size >= 16
+        vqrshrun.s16    d3,  q2,  #7
+        vqrshrun.s16    d7,  q4,  #7
+.endif
+        @ Average
+.ifc \type,avg
+.if \size >= 16
+        vld1.8          {q14}, [r0,:128]
+        vld1.8          {q15}, [r6,:128]
+        vrhadd.u8       q1,  q1,  q14
+        vrhadd.u8       q3,  q3,  q15
+.elseif \size == 8
+        vld1.8          {d28}, [r0,:64]
+        vld1.8          {d30}, [r6,:64]
+        vrhadd.u8       d2,  d2,  d28
+        vrhadd.u8       d6,  d6,  d30
+.else
+        @ We only need d28[0], but [] is faster on some cores
+        vld1.32         {d28[]}, [r0,:32]
+        vld1.32         {d30[]}, [r6,:32]
+        vrhadd.u8       d2,  d2,  d28
+        vrhadd.u8       d6,  d6,  d30
+.endif
+.endif
+        @ Store and loop horizontally (for size >= 16)
+.if \size >= 16
+        subs            r12, r12, #16
+        vst1.8          {q1}, [r0,:128]!
+        vst1.8          {q3}, [r6,:128]!
+        beq             3f
+        vmov            q8,  q10
+        vmov            q11, q13
+        vld1.8          {q10}, [r2]!
+        vld1.8          {q13}, [r7]!
+        vmovl.u8        q9,  d20
+        vmovl.u8        q10, d21
+        vmovl.u8        q12, d26
+        vmovl.u8        q13, d27
+        b               2b
+.elseif \size == 8
+        vst1.8          {d2}, [r0,:64]
+        vst1.8          {d6}, [r6,:64]
+.else @ \size == 4
+        vst1.32         {d2[0]}, [r0,:32]
+        vst1.32         {d6[0]}, [r6,:32]
+.endif
+3:
+        @ Loop vertically
+        add             r0,  r0,  r1
+        add             r6,  r6,  r1
+        add             r2,  r2,  r3
+        add             r7,  r7,  r3
+        subs            r4,  r4,  #2
+        bne             1b
+.if \size >= 16
+        vpop            {q4-q6}
+.endif
+        pop             {r4-r7}
+        bx              lr
+endfunc
+.endm
+
+.macro do_8tap_h_size size
+do_8tap_h put, \size, 3, 4
+do_8tap_h avg, \size, 3, 4
+do_8tap_h put, \size, 4, 3
+do_8tap_h avg, \size, 4, 3
+.endm
+
+do_8tap_h_size 4
+do_8tap_h_size 8
+do_8tap_h_size 16
+
+.macro do_8tap_h_func type, filter, offset, size
+function ff_vp9_\type\()_\filter\()\size\()_h_neon, export=1
+        push            {r4-r7}
+.if \size >= 16
+        vpush           {q4-q6}
+        ldr             r4,  [sp, #64]
+        ldr             r5,  [sp, #68]
+.else
+        ldr             r4,  [sp, #16]
+        ldr             r5,  [sp, #20]
+.endif
+        movrelx         r12, X(ff_vp9_subpel_filters), r6
+        add             r12, r12, 256*\offset
+        cmp             r5,  #8
+        add             r12, r12, r5, lsl #4
+        mov             r5,  #\size
+.if \size >= 16
+        bge             \type\()_8tap_16h_34
+        b               \type\()_8tap_16h_43
+.else
+        bge             \type\()_8tap_\size\()h_34
+        b               \type\()_8tap_\size\()h_43
+.endif
+endfunc
+.endm
+
+.macro do_8tap_h_filters size
+do_8tap_h_func put, regular, 1, \size
+do_8tap_h_func avg, regular, 1, \size
+do_8tap_h_func put, sharp,   2, \size
+do_8tap_h_func avg, sharp,   2, \size
+do_8tap_h_func put, smooth,  0, \size
+do_8tap_h_func avg, smooth,  0, \size
+.endm
+
+do_8tap_h_filters 64
+do_8tap_h_filters 32
+do_8tap_h_filters 16
+do_8tap_h_filters 8
+do_8tap_h_filters 4
+
+.ltorg
+
+@ Vertical filters
+
+@ Round, shift and saturate and store qreg1-2 over 4 lines
+.macro do_store4 qreg1, dreg1, qreg2, dreg2, tmp1, tmp2, type
+        vqrshrun.s16    \dreg1,  \qreg1, #7
+        vqrshrun.s16    \dreg2,  \qreg2, #7
+.ifc \type,avg
+        vld1.32         {\tmp1[]},   [r0,:32], r1
+        vld1.32         {\tmp2[]},   [r0,:32], r1
+        vld1.32         {\tmp1[1]},  [r0,:32], r1
+        vld1.32         {\tmp2[1]},  [r0,:32], r1
+        vrhadd.u8       \dreg1,  \dreg1,  \tmp1
+        vrhadd.u8       \dreg2,  \dreg2,  \tmp2
+        sub             r0,  r0,  r1, lsl #2
+.endif
+        vst1.32         {\dreg1[0]}, [r0,:32], r1
+        vst1.32         {\dreg2[0]}, [r0,:32], r1
+        vst1.32         {\dreg1[1]}, [r0,:32], r1
+        vst1.32         {\dreg2[1]}, [r0,:32], r1
+.endm
+
+@ Round, shift and saturate and store qreg1-4
+.macro do_store qreg1, dreg1, qreg2, dreg2, qreg3, dreg3, qreg4, dreg4, tmp1, tmp2, tmp3, tmp4, type
+        vqrshrun.s16    \dreg1,  \qreg1, #7
+        vqrshrun.s16    \dreg2,  \qreg2, #7
+        vqrshrun.s16    \dreg3,  \qreg3, #7
+        vqrshrun.s16    \dreg4,  \qreg4, #7
+.ifc \type,avg
+        vld1.8          {\tmp1},  [r0,:64], r1
+        vld1.8          {\tmp2},  [r0,:64], r1
+        vld1.8          {\tmp3},  [r0,:64], r1
+        vld1.8          {\tmp4},  [r0,:64], r1
+        vrhadd.u8       \dreg1,  \dreg1,  \tmp1
+        vrhadd.u8       \dreg2,  \dreg2,  \tmp2
+        vrhadd.u8       \dreg3,  \dreg3,  \tmp3
+        vrhadd.u8       \dreg4,  \dreg4,  \tmp4
+        sub             r0,  r0,  r1, lsl #2
+.endif
+        vst1.8          {\dreg1}, [r0,:64], r1
+        vst1.8          {\dreg2}, [r0,:64], r1
+        vst1.8          {\dreg3}, [r0,:64], r1
+        vst1.8          {\dreg4}, [r0,:64], r1
+.endm
+
+@ Evaluate the filter twice in parallel, from the inputs src1-src9 into dst1-dst2
+@ (src1-src8 into dst1, src2-src9 into dst2), adding idx2 separately
+@ at the end with saturation. Indices 0 and 7 always have negative or zero
+@ coefficients, so they can be accumulated into tmp1-tmp2 together with the
+@ largest coefficient.
+.macro convolve dst1, dst2, src1, src2, src3, src4, src5, src6, src7, src8, src9, idx1, idx2, tmp1, tmp2
+        vmul.s16        \dst1, \src2, d0[1]
+        vmul.s16        \dst2, \src3, d0[1]
+        vmul.s16        \tmp1, \src1, d0[0]
+        vmul.s16        \tmp2, \src2, d0[0]
+        vmla.s16        \dst1, \src3, d0[2]
+        vmla.s16        \dst2, \src4, d0[2]
+.if \idx1 == 3
+        vmla.s16        \dst1, \src4, d0[3]
+        vmla.s16        \dst2, \src5, d0[3]
+.else
+        vmla.s16        \dst1, \src5, d1[0]
+        vmla.s16        \dst2, \src6, d1[0]
+.endif
+        vmla.s16        \dst1, \src6, d1[1]
+        vmla.s16        \dst2, \src7, d1[1]
+        vmla.s16        \tmp1, \src8, d1[3]
+        vmla.s16        \tmp2, \src9, d1[3]
+        vmla.s16        \dst1, \src7, d1[2]
+        vmla.s16        \dst2, \src8, d1[2]
+.if \idx2 == 3
+        vmla.s16        \tmp1, \src4, d0[3]
+        vmla.s16        \tmp2, \src5, d0[3]
+.else
+        vmla.s16        \tmp1, \src5, d1[0]
+        vmla.s16        \tmp2, \src6, d1[0]
+.endif
+        vqadd.s16       \dst1, \dst1, \tmp1
+        vqadd.s16       \dst2, \dst2, \tmp2
+.endm
+
+@ Load pixels and extend them to 16 bit
+.macro loadl dst1, dst2, dst3, dst4
+        vld1.8          {d2}, [r2], r3
+        vld1.8          {d3}, [r2], r3
+        vld1.8          {d4}, [r2], r3
+.ifnb \dst4
+        vld1.8          {d5}, [r2], r3
+.endif
+        vmovl.u8        \dst1, d2
+        vmovl.u8        \dst2, d3
+        vmovl.u8        \dst3, d4
+.ifnb \dst4
+        vmovl.u8        \dst4, d5
+.endif
+.endm
+
+@ Instantiate a vertical filter function for filtering 8 pixels at a time.
+@ The height is passed in r4, the width in r5 and the filter coefficients
+@ in r12. idx2 is the index of the largest filter coefficient (3 or 4)
+@ and idx1 is the other one of them.
+.macro do_8tap_8v type, idx1, idx2
+function \type\()_8tap_8v_\idx1\idx2
+        sub             r2,  r2,  r3, lsl #1
+        sub             r2,  r2,  r3
+        vld1.16         {q0},  [r12, :128]
+1:
+        mov             r12, r4
+
+        loadl           q5,  q6,  q7
+        loadl           q8,  q9,  q10, q11
+2:
+        loadl           q12, q13, q14, q15
+        convolve        q1,  q2,  q5,  q6,  q7,  q8,  q9,  q10, q11, q12, q13, \idx1, \idx2, q4,  q5
+        convolve        q3,  q4,  q7,  q8,  q9,  q10, q11, q12, q13, q14, q15, \idx1, \idx2, q5,  q6
+        do_store        q1,  d2,  q2,  d4,  q3,  d6,  q4,  d8,  d3,  d5,  d7,  d9,  \type
+
+        subs            r12, r12, #4
+        beq             8f
+
+        loadl           q4,  q5,  q6,  q7
+        convolve        q1,  q2,  q9,  q10, q11, q12, q13, q14, q15, q4,  q5,  \idx1, \idx2, q8,  q9
+        convolve        q3,  q8,  q11, q12, q13, q14, q15, q4,  q5,  q6,  q7,  \idx1, \idx2, q9,  q10
+        do_store        q1,  d2,  q2,  d4,  q3,  d6,  q8,  d16, d3,  d5,  d7,  d17, \type
+
+        subs            r12, r12, #4
+        beq             8f
+
+        loadl           q8,  q9,  q10, q11
+        convolve        q1,  q2,  q13, q14, q15, q4,  q5,  q6,  q7,  q8,  q9,  \idx1, \idx2, q12, q13
+        convolve        q3,  q12, q15, q4,  q5,  q6,  q7,  q8,  q9,  q10, q11, \idx1, \idx2, q13, q14
+        do_store        q1,  d2,  q2,  d4,  q3,  d6,  q12, d24, d3,  d5,  d7,  d25, \type
+
+        subs            r12, r12, #4
+        bne             2b
+
+8:
+        subs            r5,  r5,  #8
+        beq             9f
+        @ r0 -= h * dst_stride
+        mls             r0,  r1,  r4, r0
+        @ r2 -= h * src_stride
+        mls             r2,  r3,  r4, r2
+        @ r2 -= 8 * src_stride
+        sub             r2,  r2,  r3, lsl #3
+        @ r2 += 1 * src_stride
+        add             r2,  r2,  r3
+        add             r2,  r2,  #8
+        add             r0,  r0,  #8
+        b               1b
+9:
+        vpop            {q4-q7}
+        pop             {r4-r5}
+        bx              lr
+endfunc
+.endm
+
+do_8tap_8v put, 3, 4
+do_8tap_8v put, 4, 3
+do_8tap_8v avg, 3, 4
+do_8tap_8v avg, 4, 3
+
+@ Instantiate a vertical filter function for filtering a 4 pixels wide
+@ slice. The first half of the registers contain one row, while the second
+@ half of a register contains the second-next row (also stored in the first
+@ half of the register two steps ahead). The convolution does two outputs
+@ at a time; the output of q5-q12 into one, and q4-q13 into another one.
+@ The first half of first output is the first output row, the first half
+@ of the other output is the second output row. The second halves of the
+@ registers are rows 3 and 4.
+@ This only is designed to work for 4 or 8 output lines.
+.macro do_8tap_4v type, idx1, idx2
+function \type\()_8tap_4v_\idx1\idx2
+        sub             r2,  r2,  r3, lsl #1
+        sub             r2,  r2,  r3
+        vld1.16         {q0},  [r12, :128]
+
+        vld1.32         {d2[]},   [r2], r3
+        vld1.32         {d3[]},   [r2], r3
+        vld1.32         {d4[]},   [r2], r3
+        vld1.32         {d5[]},   [r2], r3
+        vld1.32         {d6[]},   [r2], r3
+        vld1.32         {d7[]},   [r2], r3
+        vext.8          d2,  d2,  d4,  #4
+        vld1.32         {d8[]},   [r2], r3
+        vext.8          d3,  d3,  d5,  #4
+        vld1.32         {d9[]},   [r2], r3
+        vmovl.u8        q5,  d2
+        vext.8          d4,  d4,  d6,  #4
+        vld1.32         {d28[]},  [r2], r3
+        vmovl.u8        q6,  d3
+        vext.8          d5,  d5,  d7,  #4
+        vld1.32         {d29[]},  [r2], r3
+        vmovl.u8        q7,  d4
+        vext.8          d6,  d6,  d8,  #4
+        vld1.32         {d30[]},  [r2], r3
+        vmovl.u8        q8,  d5
+        vext.8          d7,  d7,  d9,  #4
+        vmovl.u8        q9,  d6
+        vext.8          d8,  d8,  d28, #4
+        vmovl.u8        q10, d7
+        vext.8          d9,  d9,  d29, #4
+        vmovl.u8        q11, d8
+        vext.8          d28, d28, d30, #4
+        vmovl.u8        q12, d9
+        vmovl.u8        q13, d28
+
+        convolve        q1,  q2,  q5,  q6,  q7,  q8,  q9,  q10, q11, q12, q13, \idx1, \idx2, q4, q3
+        do_store4       q1,  d2,  q2,  d4,  d3,  d5,  \type
+        subs            r4,  r4,  #4
+        beq             9f
+
+        vld1.32         {d2[]},   [r2], r3
+        vld1.32         {d3[]},   [r2], r3
+        vext.8          d29, d29, d2,  #4
+        vext.8          d30, d30, d3,  #4
+        vld1.32         {d2[1]},  [r2], r3
+        vmovl.u8        q14, d29
+        vld1.32         {d3[1]},  [r2], r3
+        vmovl.u8        q15, d30
+        vmovl.u8        q5,  d2
+        vmovl.u8        q6,  d3
+
+        convolve        q1,  q2,  q9,  q10, q11, q12, q13, q14, q15, q5,  q6,  \idx1, \idx2, q4, q3
+        do_store4       q1,  d2,  q2,  d4,  d3,  d5,  \type
+
+9:
+        vpop            {q4-q7}
+        pop             {r4-r5}
+        bx              lr
+endfunc
+.endm
+
+do_8tap_4v put, 3, 4
+do_8tap_4v put, 4, 3
+do_8tap_4v avg, 3, 4
+do_8tap_4v avg, 4, 3
+
+.macro do_8tap_v_func type, filter, offset, size
+function ff_vp9_\type\()_\filter\()\size\()_v_neon, export=1
+        push            {r4-r5}
+        vpush           {q4-q7}
+        ldr             r4,  [sp, #72]
+        movrelx         r12, X(ff_vp9_subpel_filters), r5
+        ldr             r5,  [sp, #80]
+        add             r12, r12, 256*\offset
+        add             r12, r12, r5, lsl #4
+        cmp             r5,  #8
+        mov             r5,  #\size
+.if \size >= 8
+        bge             \type\()_8tap_8v_34
+        b               \type\()_8tap_8v_43
+.else
+        bge             \type\()_8tap_4v_34
+        b               \type\()_8tap_4v_43
+.endif
+endfunc
+.endm
+
+.macro do_8tap_v_filters size
+do_8tap_v_func put, regular, 1, \size
+do_8tap_v_func avg, regular, 1, \size
+do_8tap_v_func put, sharp,   2, \size
+do_8tap_v_func avg, sharp,   2, \size
+do_8tap_v_func put, smooth,  0, \size
+do_8tap_v_func avg, smooth,  0, \size
+.endm
+
+do_8tap_v_filters 64
+do_8tap_v_filters 32
+do_8tap_v_filters 16
+do_8tap_v_filters 8
+do_8tap_v_filters 4
diff --git a/mythtv/external/FFmpeg/libavcodec/ass_split.c b/mythtv/external/FFmpeg/libavcodec/ass_split.c
index d3e8a8d5559..872528bdfa6 100644
--- a/mythtv/external/FFmpeg/libavcodec/ass_split.c
+++ b/mythtv/external/FFmpeg/libavcodec/ass_split.c
@@ -275,7 +275,7 @@ static const char *ass_split_section(ASSSplitContext *ctx, const char *buf)
         }
         if (section->format_header && !order) {
             len = strlen(section->format_header);
-            if (buf[len] == ':' && !strncmp(buf, section->format_header, len)) {
+            if (!strncmp(buf, section->format_header, len) && buf[len] == ':') {
                 buf += len + 1;
                 while (!is_eol(*buf)) {
                     buf = skip_space(buf);
diff --git a/mythtv/external/FFmpeg/libavcodec/asv.h b/mythtv/external/FFmpeg/libavcodec/asv.h
index e2cdc813006..a1366b6fe45 100644
--- a/mythtv/external/FFmpeg/libavcodec/asv.h
+++ b/mythtv/external/FFmpeg/libavcodec/asv.h
@@ -54,7 +54,7 @@ typedef struct ASV1Context {
     int mb_height;
     int mb_width2;
     int mb_height2;
-    DECLARE_ALIGNED(16, int16_t, block)[6][64];
+    DECLARE_ALIGNED(32, int16_t, block)[6][64];
     uint16_t intra_matrix[64];
     int q_intra_matrix[64];
     uint8_t *bitstream_buffer;
diff --git a/mythtv/external/FFmpeg/libavcodec/asvdec.c b/mythtv/external/FFmpeg/libavcodec/asvdec.c
index 036d56ed0d8..9a11446f52e 100644
--- a/mythtv/external/FFmpeg/libavcodec/asvdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/asvdec.c
@@ -163,19 +163,19 @@ static inline int asv2_decode_block(ASV1Context *a, int16_t block[64])
 
 static inline int decode_mb(ASV1Context *a, int16_t block[6][64])
 {
-    int i;
+    int i, ret;
 
     a->bdsp.clear_blocks(block[0]);
 
     if (a->avctx->codec_id == AV_CODEC_ID_ASV1) {
         for (i = 0; i < 6; i++) {
-            if (asv1_decode_block(a, block[i]) < 0)
-                return -1;
+            if ((ret = asv1_decode_block(a, block[i])) < 0)
+                return ret;
         }
     } else {
         for (i = 0; i < 6; i++) {
-            if (asv2_decode_block(a, block[i]) < 0)
-                return -1;
+            if ((ret = asv2_decode_block(a, block[i])) < 0)
+                return ret;
         }
     }
     return 0;
@@ -210,6 +210,9 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     AVFrame *const p = data;
     int mb_x, mb_y, ret;
 
+    if (buf_size * 8LL < a->mb_height * a->mb_width * 13LL)
+        return AVERROR_INVALIDDATA;
+
     if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
         return ret;
     p->pict_type = AV_PICTURE_TYPE_I;
diff --git a/mythtv/external/FFmpeg/libavcodec/atrac3.c b/mythtv/external/FFmpeg/libavcodec/atrac3.c
index 256990b3114..6cdcdf19644 100644
--- a/mythtv/external/FFmpeg/libavcodec/atrac3.c
+++ b/mythtv/external/FFmpeg/libavcodec/atrac3.c
@@ -48,8 +48,12 @@
 #include "atrac.h"
 #include "atrac3data.h"
 
+#define MIN_CHANNELS    1
+#define MAX_CHANNELS    8
+#define MAX_JS_PAIRS    8 / 2
+
 #define JOINT_STEREO    0x12
-#define STEREO          0x2
+#define SINGLE          0x2
 
 #define SAMPLES_PER_FRAME 1024
 #define MDCT_SIZE          512
@@ -90,10 +94,10 @@ typedef struct ATRAC3Context {
     //@}
     //@{
     /** joint-stereo related variables */
-    int matrix_coeff_index_prev[4];
-    int matrix_coeff_index_now[4];
-    int matrix_coeff_index_next[4];
-    int weighting_delay[6];
+    int matrix_coeff_index_prev[MAX_JS_PAIRS][4];
+    int matrix_coeff_index_now[MAX_JS_PAIRS][4];
+    int matrix_coeff_index_next[MAX_JS_PAIRS][4];
+    int weighting_delay[MAX_JS_PAIRS][6];
     //@}
     //@{
     /** data buffers */
@@ -567,7 +571,7 @@ static void channel_weighting(float *su1, float *su2, int *p3)
  * @param snd           the channel unit to be used
  * @param output        the decoded samples before IQMF in float representation
  * @param channel_num   channel number
- * @param coding_mode   the coding mode (JOINT_STEREO or regular stereo/mono)
+ * @param coding_mode   the coding mode (JOINT_STEREO or single channels)
  */
 static int decode_channel_sound_unit(ATRAC3Context *q, GetBitContext *gb,
                                      ChannelUnit *snd, float *output,
@@ -577,7 +581,7 @@ static int decode_channel_sound_unit(ATRAC3Context *q, GetBitContext *gb,
     GainBlock *gain1 = &snd->gain_block[    snd->gc_blk_switch];
     GainBlock *gain2 = &snd->gain_block[1 - snd->gc_blk_switch];
 
-    if (coding_mode == JOINT_STEREO && channel_num == 1) {
+    if (coding_mode == JOINT_STEREO && (channel_num % 2) == 1) {
         if (get_bits(gb, 2) != 3) {
             av_log(NULL,AV_LOG_ERROR,"JS mono Sound Unit id != 3.\n");
             return AVERROR_INVALIDDATA;
@@ -640,69 +644,87 @@ static int decode_frame(AVCodecContext *avctx, const uint8_t *databuf,
                         float **out_samples)
 {
     ATRAC3Context *q = avctx->priv_data;
-    int ret, i;
+    int ret, i, ch;
     uint8_t *ptr1;
 
     if (q->coding_mode == JOINT_STEREO) {
         /* channel coupling mode */
-        /* decode Sound Unit 1 */
-        init_get_bits(&q->gb, databuf, avctx->block_align * 8);
 
-        ret = decode_channel_sound_unit(q, &q->gb, q->units, out_samples[0], 0,
-                                        JOINT_STEREO);
-        if (ret != 0)
-            return ret;
+        /* Decode sound unit pairs (channels are expected to be even).
+         * Multichannel joint stereo interleaves pairs (6ch: 2ch + 2ch + 2ch) */
+        const uint8_t *js_databuf;
+        int js_pair, js_block_align;
 
-        /* Framedata of the su2 in the joint-stereo mode is encoded in
-         * reverse byte order so we need to swap it first. */
-        if (databuf == q->decoded_bytes_buffer) {
-            uint8_t *ptr2 = q->decoded_bytes_buffer + avctx->block_align - 1;
-            ptr1          = q->decoded_bytes_buffer;
-            for (i = 0; i < avctx->block_align / 2; i++, ptr1++, ptr2--)
-                FFSWAP(uint8_t, *ptr1, *ptr2);
-        } else {
-            const uint8_t *ptr2 = databuf + avctx->block_align - 1;
-            for (i = 0; i < avctx->block_align; i++)
-                q->decoded_bytes_buffer[i] = *ptr2--;
-        }
+        js_block_align = (avctx->block_align / avctx->channels) * 2; /* block pair */
 
-        /* Skip the sync codes (0xF8). */
-        ptr1 = q->decoded_bytes_buffer;
-        for (i = 4; *ptr1 == 0xF8; i++, ptr1++) {
-            if (i >= avctx->block_align)
-                return AVERROR_INVALIDDATA;
-        }
+        for (ch = 0; ch < avctx->channels; ch = ch + 2) {
+            js_pair = ch/2;
+            js_databuf = databuf + js_pair * js_block_align; /* align to current pair */
+
+            /* Set the bitstream reader at the start of first channel sound unit. */
+            init_get_bits(&q->gb,
+                          js_databuf, js_block_align * 8);
 
+            /* decode Sound Unit 1 */
+            ret = decode_channel_sound_unit(q, &q->gb, &q->units[ch],
+                                            out_samples[ch], ch, JOINT_STEREO);
+            if (ret != 0)
+                return ret;
 
-        /* set the bitstream reader at the start of the second Sound Unit*/
-        init_get_bits8(&q->gb, ptr1, q->decoded_bytes_buffer + avctx->block_align - ptr1);
+            /* Framedata of the su2 in the joint-stereo mode is encoded in
+             * reverse byte order so we need to swap it first. */
+            if (js_databuf == q->decoded_bytes_buffer) {
+                uint8_t *ptr2 = q->decoded_bytes_buffer + js_block_align - 1;
+                ptr1          = q->decoded_bytes_buffer;
+                for (i = 0; i < js_block_align / 2; i++, ptr1++, ptr2--)
+                    FFSWAP(uint8_t, *ptr1, *ptr2);
+            } else {
+                const uint8_t *ptr2 = js_databuf + js_block_align - 1;
+                for (i = 0; i < js_block_align; i++)
+                    q->decoded_bytes_buffer[i] = *ptr2--;
+            }
 
-        /* Fill the Weighting coeffs delay buffer */
-        memmove(q->weighting_delay, &q->weighting_delay[2],
-                4 * sizeof(*q->weighting_delay));
-        q->weighting_delay[4] = get_bits1(&q->gb);
-        q->weighting_delay[5] = get_bits(&q->gb, 3);
+            /* Skip the sync codes (0xF8). */
+            ptr1 = q->decoded_bytes_buffer;
+            for (i = 4; *ptr1 == 0xF8; i++, ptr1++) {
+                if (i >= js_block_align)
+                    return AVERROR_INVALIDDATA;
+            }
 
-        for (i = 0; i < 4; i++) {
-            q->matrix_coeff_index_prev[i] = q->matrix_coeff_index_now[i];
-            q->matrix_coeff_index_now[i]  = q->matrix_coeff_index_next[i];
-            q->matrix_coeff_index_next[i] = get_bits(&q->gb, 2);
-        }
 
-        /* Decode Sound Unit 2. */
-        ret = decode_channel_sound_unit(q, &q->gb, &q->units[1],
-                                        out_samples[1], 1, JOINT_STEREO);
-        if (ret != 0)
-            return ret;
+            /* set the bitstream reader at the start of the second Sound Unit */
+            ret = init_get_bits8(&q->gb,
+                           ptr1, q->decoded_bytes_buffer + js_block_align - ptr1);
+            if (ret < 0)
+                return ret;
 
-        /* Reconstruct the channel coefficients. */
-        reverse_matrixing(out_samples[0], out_samples[1],
-                          q->matrix_coeff_index_prev,
-                          q->matrix_coeff_index_now);
+            /* Fill the Weighting coeffs delay buffer */
+            memmove(q->weighting_delay[js_pair], &q->weighting_delay[js_pair][2],
+                    4 * sizeof(*q->weighting_delay[js_pair]));
+            q->weighting_delay[js_pair][4] = get_bits1(&q->gb);
+            q->weighting_delay[js_pair][5] = get_bits(&q->gb, 3);
 
-        channel_weighting(out_samples[0], out_samples[1], q->weighting_delay);
+            for (i = 0; i < 4; i++) {
+                q->matrix_coeff_index_prev[js_pair][i] = q->matrix_coeff_index_now[js_pair][i];
+                q->matrix_coeff_index_now[js_pair][i]  = q->matrix_coeff_index_next[js_pair][i];
+                q->matrix_coeff_index_next[js_pair][i] = get_bits(&q->gb, 2);
+            }
+
+            /* Decode Sound Unit 2. */
+            ret = decode_channel_sound_unit(q, &q->gb, &q->units[ch+1],
+                                            out_samples[ch+1], ch+1, JOINT_STEREO);
+            if (ret != 0)
+                return ret;
+
+            /* Reconstruct the channel coefficients. */
+            reverse_matrixing(out_samples[ch], out_samples[ch+1],
+                              q->matrix_coeff_index_prev[js_pair],
+                              q->matrix_coeff_index_now[js_pair]);
+
+            channel_weighting(out_samples[ch], out_samples[ch+1], q->weighting_delay[js_pair]);
+        }
     } else {
-        /* normal stereo mode or mono */
+        /* single channels */
         /* Decode the channel sound units. */
         for (i = 0; i < avctx->channels; i++) {
             /* Set the bitstream reader at the start of a channel sound unit. */
@@ -731,6 +753,40 @@ static int decode_frame(AVCodecContext *avctx, const uint8_t *databuf,
     return 0;
 }
 
+static int al_decode_frame(AVCodecContext *avctx, const uint8_t *databuf,
+                           int size, float **out_samples)
+{
+    ATRAC3Context *q = avctx->priv_data;
+    int ret, i;
+
+    /* Set the bitstream reader at the start of a channel sound unit. */
+    init_get_bits(&q->gb, databuf, size * 8);
+    /* single channels */
+    /* Decode the channel sound units. */
+    for (i = 0; i < avctx->channels; i++) {
+        ret = decode_channel_sound_unit(q, &q->gb, &q->units[i],
+                                        out_samples[i], i, q->coding_mode);
+        if (ret != 0)
+            return ret;
+        while (i < avctx->channels && get_bits_left(&q->gb) > 6 && show_bits(&q->gb, 6) != 0x28) {
+            skip_bits(&q->gb, 1);
+        }
+    }
+
+    /* Apply the iQMF synthesis filter. */
+    for (i = 0; i < avctx->channels; i++) {
+        float *p1 = out_samples[i];
+        float *p2 = p1 + 256;
+        float *p3 = p2 + 256;
+        float *p4 = p3 + 256;
+        ff_atrac_iqmf(p1, p2, 256, p1, q->units[i].delay_buf1, q->temp_buf);
+        ff_atrac_iqmf(p4, p3, 256, p3, q->units[i].delay_buf2, q->temp_buf);
+        ff_atrac_iqmf(p1, p3, 512, p1, q->units[i].delay_buf3, q->temp_buf);
+    }
+
+    return 0;
+}
+
 static int atrac3_decode_frame(AVCodecContext *avctx, void *data,
                                int *got_frame_ptr, AVPacket *avpkt)
 {
@@ -771,6 +827,28 @@ static int atrac3_decode_frame(AVCodecContext *avctx, void *data,
     return avctx->block_align;
 }
 
+static int atrac3al_decode_frame(AVCodecContext *avctx, void *data,
+                                 int *got_frame_ptr, AVPacket *avpkt)
+{
+    AVFrame *frame = data;
+    int ret;
+
+    frame->nb_samples = SAMPLES_PER_FRAME;
+    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
+        return ret;
+
+    ret = al_decode_frame(avctx, avpkt->data, avpkt->size,
+                          (float **)frame->extended_data);
+    if (ret) {
+        av_log(avctx, AV_LOG_ERROR, "Frame decoding error!\n");
+        return ret;
+    }
+
+    *got_frame_ptr = 1;
+
+    return avpkt->size;
+}
+
 static av_cold void atrac3_init_static_data(void)
 {
     int i;
@@ -792,12 +870,12 @@ static av_cold void atrac3_init_static_data(void)
 static av_cold int atrac3_decode_init(AVCodecContext *avctx)
 {
     static int static_init_done;
-    int i, ret;
+    int i, js_pair, ret;
     int version, delay, samples_per_frame, frame_factor;
     const uint8_t *edata_ptr = avctx->extradata;
     ATRAC3Context *q = avctx->priv_data;
 
-    if (avctx->channels <= 0 || avctx->channels > 2) {
+    if (avctx->channels < MIN_CHANNELS || avctx->channels > MAX_CHANNELS) {
         av_log(avctx, AV_LOG_ERROR, "Channel configuration error!\n");
         return AVERROR(EINVAL);
     }
@@ -807,7 +885,12 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)
     static_init_done = 1;
 
     /* Take care of the codec-specific extradata. */
-    if (avctx->extradata_size == 14) {
+    if (avctx->codec_id == AV_CODEC_ID_ATRAC3AL) {
+        version           = 4;
+        samples_per_frame = SAMPLES_PER_FRAME * avctx->channels;
+        delay             = 0x88E;
+        q->coding_mode    = SINGLE;
+    } else if (avctx->extradata_size == 14) {
         /* Parse the extradata, WAV format */
         av_log(avctx, AV_LOG_DEBUG, "[0-1] %d\n",
                bytestream_get_le16(&edata_ptr));  // Unknown value always 1
@@ -823,7 +906,7 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)
         samples_per_frame    = SAMPLES_PER_FRAME * avctx->channels;
         version              = 4;
         delay                = 0x88E;
-        q->coding_mode       = q->coding_mode ? JOINT_STEREO : STEREO;
+        q->coding_mode       = q->coding_mode ? JOINT_STEREO : SINGLE;
         q->scrambled_stream  = 0;
 
         if (avctx->block_align !=  96 * avctx->channels * frame_factor &&
@@ -855,8 +938,7 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)
         return AVERROR_INVALIDDATA;
     }
 
-    if (samples_per_frame != SAMPLES_PER_FRAME &&
-        samples_per_frame != SAMPLES_PER_FRAME * 2) {
+    if (samples_per_frame != SAMPLES_PER_FRAME * avctx->channels) {
         av_log(avctx, AV_LOG_ERROR, "Unknown amount of samples per frame %d.\n",
                samples_per_frame);
         return AVERROR_INVALIDDATA;
@@ -868,11 +950,11 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)
         return AVERROR_INVALIDDATA;
     }
 
-    if (q->coding_mode == STEREO)
-        av_log(avctx, AV_LOG_DEBUG, "Normal stereo detected.\n");
+    if (q->coding_mode == SINGLE)
+        av_log(avctx, AV_LOG_DEBUG, "Single channels detected.\n");
     else if (q->coding_mode == JOINT_STEREO) {
-        if (avctx->channels != 2) {
-            av_log(avctx, AV_LOG_ERROR, "Invalid coding mode\n");
+        if (avctx->channels % 2 == 1) { /* Joint stereo channels must be even */
+            av_log(avctx, AV_LOG_ERROR, "Invalid joint stereo channel configuration.\n");
             return AVERROR_INVALIDDATA;
         }
         av_log(avctx, AV_LOG_DEBUG, "Joint stereo detected.\n");
@@ -900,17 +982,19 @@ static av_cold int atrac3_decode_init(AVCodecContext *avctx)
     }
 
     /* init the joint-stereo decoding data */
-    q->weighting_delay[0] = 0;
-    q->weighting_delay[1] = 7;
-    q->weighting_delay[2] = 0;
-    q->weighting_delay[3] = 7;
-    q->weighting_delay[4] = 0;
-    q->weighting_delay[5] = 7;
-
-    for (i = 0; i < 4; i++) {
-        q->matrix_coeff_index_prev[i] = 3;
-        q->matrix_coeff_index_now[i]  = 3;
-        q->matrix_coeff_index_next[i] = 3;
+    for (js_pair = 0; js_pair < MAX_JS_PAIRS; js_pair++) {
+        q->weighting_delay[js_pair][0] = 0;
+        q->weighting_delay[js_pair][1] = 7;
+        q->weighting_delay[js_pair][2] = 0;
+        q->weighting_delay[js_pair][3] = 7;
+        q->weighting_delay[js_pair][4] = 0;
+        q->weighting_delay[js_pair][5] = 7;
+
+        for (i = 0; i < 4; i++) {
+            q->matrix_coeff_index_prev[js_pair][i] = 3;
+            q->matrix_coeff_index_now[js_pair][i]  = 3;
+            q->matrix_coeff_index_next[js_pair][i] = 3;
+        }
     }
 
     ff_atrac_init_gain_compensation(&q->gainc_ctx, 4, 3);
@@ -938,3 +1022,17 @@ AVCodec ff_atrac3_decoder = {
     .sample_fmts      = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
                                                         AV_SAMPLE_FMT_NONE },
 };
+
+AVCodec ff_atrac3al_decoder = {
+    .name             = "atrac3al",
+    .long_name        = NULL_IF_CONFIG_SMALL("ATRAC3 AL (Adaptive TRansform Acoustic Coding 3 Advanced Lossless)"),
+    .type             = AVMEDIA_TYPE_AUDIO,
+    .id               = AV_CODEC_ID_ATRAC3AL,
+    .priv_data_size   = sizeof(ATRAC3Context),
+    .init             = atrac3_decode_init,
+    .close            = atrac3_decode_close,
+    .decode           = atrac3al_decode_frame,
+    .capabilities     = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
+    .sample_fmts      = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
+                                                        AV_SAMPLE_FMT_NONE },
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/atrac3plus.c b/mythtv/external/FFmpeg/libavcodec/atrac3plus.c
index 46e0beafc20..3e3bba801b9 100644
--- a/mythtv/external/FFmpeg/libavcodec/atrac3plus.c
+++ b/mythtv/external/FFmpeg/libavcodec/atrac3plus.c
@@ -109,8 +109,8 @@ av_cold void ff_atrac3p_init_vlcs(void)
         NULL, NULL, atrac3p_ct_huff_xlat1, NULL
     };
 
-    static const  int sf_nb_bits[8]  = {  9,  9,  9,  9,  6,  6,  7,  7 };
-    static const  int sf_nb_codes[8] = { 64, 64, 64, 64, 16, 16, 16, 16 };
+    static const int sf_nb_bits[8]  = {  9,  9,  9,  9,  6,  6,  7,  7 };
+    static const int sf_nb_codes[8] = { 64, 64, 64, 64, 16, 16, 16, 16 };
     static const uint8_t  * const sf_bits[8]  = {
         atrac3p_sf_huff_bits1, atrac3p_sf_huff_bits1, atrac3p_sf_huff_bits2,
         atrac3p_sf_huff_bits3, atrac3p_sf_huff_bits4, atrac3p_sf_huff_bits4,
diff --git a/mythtv/external/FFmpeg/libavcodec/atrac3plus.h b/mythtv/external/FFmpeg/libavcodec/atrac3plus.h
index a33c38a3ee2..3c39e293c74 100644
--- a/mythtv/external/FFmpeg/libavcodec/atrac3plus.h
+++ b/mythtv/external/FFmpeg/libavcodec/atrac3plus.h
@@ -199,13 +199,14 @@ void ff_atrac3p_generate_tones(Atrac3pChanUnitCtx *ch_unit, AVFloatDSPContext *f
  * Perform power compensation aka noise dithering.
  *
  * @param[in]      ctx         ptr to the channel context
+ * @param[in]      fdsp        pointer to float DSP context
  * @param[in]      ch_index    which channel to process
  * @param[in,out]  sp          ptr to channel spectrum to process
  * @param[in]      rng_index   indicates which RNG table to use
  * @param[in]      sb_num      which subband to process
  */
-void ff_atrac3p_power_compensation(Atrac3pChanUnitCtx *ctx, int ch_index,
-                                   float *sp, int rng_index, int sb_num);
+void ff_atrac3p_power_compensation(Atrac3pChanUnitCtx *ctx, AVFloatDSPContext *fdsp,
+                                   int ch_index, float *sp, int rng_index, int sb_num);
 
 /**
  * Regular IMDCT and windowing without overlapping,
diff --git a/mythtv/external/FFmpeg/libavcodec/atrac3plusdec.c b/mythtv/external/FFmpeg/libavcodec/atrac3plusdec.c
index ec2b1ad3b21..666d1a5c018 100644
--- a/mythtv/external/FFmpeg/libavcodec/atrac3plusdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/atrac3plusdec.c
@@ -198,7 +198,7 @@ static av_cold int atrac3p_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-static void decode_residual_spectrum(Atrac3pChanUnitCtx *ctx,
+static void decode_residual_spectrum(ATRAC3PContext *ctx, Atrac3pChanUnitCtx *ch_unit,
                                      float out[2][ATRAC3P_FRAME_SAMPLES],
                                      int num_channels,
                                      AVCodecContext *avctx)
@@ -209,17 +209,17 @@ static void decode_residual_spectrum(Atrac3pChanUnitCtx *ctx,
     /* calculate RNG table index for each subband */
     int sb_RNG_index[ATRAC3P_SUBBANDS] = { 0 };
 
-    if (ctx->mute_flag) {
+    if (ch_unit->mute_flag) {
         for (ch = 0; ch < num_channels; ch++)
             memset(out[ch], 0, ATRAC3P_FRAME_SAMPLES * sizeof(*out[ch]));
         return;
     }
 
-    for (qu = 0, RNG_index = 0; qu < ctx->used_quant_units; qu++)
-        RNG_index += ctx->channels[0].qu_sf_idx[qu] +
-                     ctx->channels[1].qu_sf_idx[qu];
+    for (qu = 0, RNG_index = 0; qu < ch_unit->used_quant_units; qu++)
+        RNG_index += ch_unit->channels[0].qu_sf_idx[qu] +
+                     ch_unit->channels[1].qu_sf_idx[qu];
 
-    for (sb = 0; sb < ctx->num_coded_subbands; sb++, RNG_index += 128)
+    for (sb = 0; sb < ch_unit->num_coded_subbands; sb++, RNG_index += 128)
         sb_RNG_index[sb] = RNG_index & 0x3FC;
 
     /* inverse quant and power compensation */
@@ -227,35 +227,35 @@ static void decode_residual_spectrum(Atrac3pChanUnitCtx *ctx,
         /* clear channel's residual spectrum */
         memset(out[ch], 0, ATRAC3P_FRAME_SAMPLES * sizeof(*out[ch]));
 
-        for (qu = 0; qu < ctx->used_quant_units; qu++) {
-            src        = &ctx->channels[ch].spectrum[ff_atrac3p_qu_to_spec_pos[qu]];
+        for (qu = 0; qu < ch_unit->used_quant_units; qu++) {
+            src        = &ch_unit->channels[ch].spectrum[ff_atrac3p_qu_to_spec_pos[qu]];
             dst        = &out[ch][ff_atrac3p_qu_to_spec_pos[qu]];
             nspeclines = ff_atrac3p_qu_to_spec_pos[qu + 1] -
                          ff_atrac3p_qu_to_spec_pos[qu];
 
-            if (ctx->channels[ch].qu_wordlen[qu] > 0) {
-                q = ff_atrac3p_sf_tab[ctx->channels[ch].qu_sf_idx[qu]] *
-                    ff_atrac3p_mant_tab[ctx->channels[ch].qu_wordlen[qu]];
+            if (ch_unit->channels[ch].qu_wordlen[qu] > 0) {
+                q = ff_atrac3p_sf_tab[ch_unit->channels[ch].qu_sf_idx[qu]] *
+                    ff_atrac3p_mant_tab[ch_unit->channels[ch].qu_wordlen[qu]];
                 for (i = 0; i < nspeclines; i++)
                     dst[i] = src[i] * q;
             }
         }
 
-        for (sb = 0; sb < ctx->num_coded_subbands; sb++)
-            ff_atrac3p_power_compensation(ctx, ch, &out[ch][0],
+        for (sb = 0; sb < ch_unit->num_coded_subbands; sb++)
+            ff_atrac3p_power_compensation(ch_unit, ctx->fdsp, ch, &out[ch][0],
                                           sb_RNG_index[sb], sb);
     }
 
-    if (ctx->unit_type == CH_UNIT_STEREO) {
-        for (sb = 0; sb < ctx->num_coded_subbands; sb++) {
-            if (ctx->swap_channels[sb]) {
+    if (ch_unit->unit_type == CH_UNIT_STEREO) {
+        for (sb = 0; sb < ch_unit->num_coded_subbands; sb++) {
+            if (ch_unit->swap_channels[sb]) {
                 for (i = 0; i < ATRAC3P_SUBBAND_SAMPLES; i++)
                     FFSWAP(float, out[0][sb * ATRAC3P_SUBBAND_SAMPLES + i],
                                   out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i]);
             }
 
             /* flip coefficients' sign if requested */
-            if (ctx->negate_coeffs[sb])
+            if (ch_unit->negate_coeffs[sb])
                 for (i = 0; i < ATRAC3P_SUBBAND_SAMPLES; i++)
                     out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i] = -(out[1][sb * ATRAC3P_SUBBAND_SAMPLES + i]);
         }
@@ -369,7 +369,7 @@ static int atrac3p_decode_frame(AVCodecContext *avctx, void *data,
                                                   avctx)) < 0)
             return ret;
 
-        decode_residual_spectrum(&ctx->ch_units[ch_block], ctx->samples,
+        decode_residual_spectrum(ctx, &ctx->ch_units[ch_block], ctx->samples,
                                  channels_to_process, avctx);
         reconstruct_frame(ctx, &ctx->ch_units[ch_block],
                           channels_to_process, avctx);
@@ -384,7 +384,7 @@ static int atrac3p_decode_frame(AVCodecContext *avctx, void *data,
 
     *got_frame_ptr = 1;
 
-    return FFMIN(avctx->block_align, avpkt->size);
+    return avctx->codec_id == AV_CODEC_ID_ATRAC3P ? FFMIN(avctx->block_align, avpkt->size) : avpkt->size;
 }
 
 AVCodec ff_atrac3p_decoder = {
@@ -398,3 +398,15 @@ AVCodec ff_atrac3p_decoder = {
     .close          = atrac3p_decode_close,
     .decode         = atrac3p_decode_frame,
 };
+
+AVCodec ff_atrac3pal_decoder = {
+    .name           = "atrac3plusal",
+    .long_name      = NULL_IF_CONFIG_SMALL("ATRAC3+ AL (Adaptive TRansform Acoustic Coding 3+ Advanced Lossless)"),
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = AV_CODEC_ID_ATRAC3PAL,
+    .capabilities   = AV_CODEC_CAP_DR1,
+    .priv_data_size = sizeof(ATRAC3PContext),
+    .init           = atrac3p_decode_init,
+    .close          = atrac3p_decode_close,
+    .decode         = atrac3p_decode_frame,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/atrac3plusdsp.c b/mythtv/external/FFmpeg/libavcodec/atrac3plusdsp.c
index d089588274c..96aa402c2b2 100644
--- a/mythtv/external/FFmpeg/libavcodec/atrac3plusdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/atrac3plusdsp.c
@@ -415,11 +415,12 @@ static const int subband_to_qu[17] = {
     0, 8, 12, 16, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32
 };
 
-void ff_atrac3p_power_compensation(Atrac3pChanUnitCtx *ctx, int ch_index,
-                                   float *sp, int rng_index, int sb)
+void ff_atrac3p_power_compensation(Atrac3pChanUnitCtx *ctx, AVFloatDSPContext *fdsp,
+                                   int ch_index, float *sp, int rng_index, int sb)
 {
     AtracGainInfo *g1, *g2;
-    float pwcsp[ATRAC3P_SUBBAND_SAMPLES], *dst, grp_lev, qu_lev;
+    LOCAL_ALIGNED_32(float, pwcsp, [ATRAC3P_SUBBAND_SAMPLES]);
+    float *dst, grp_lev, qu_lev;
     int i, gain_lev, gcv = 0, qu, nsp;
     int swap_ch = (ctx->unit_type == CH_UNIT_STEREO && ctx->swap_channels[sb]) ? 1 : 0;
 
@@ -456,8 +457,7 @@ void ff_atrac3p_power_compensation(Atrac3pChanUnitCtx *ctx, int ch_index,
         dst = &sp[ff_atrac3p_qu_to_spec_pos[qu]];
         nsp = ff_atrac3p_qu_to_spec_pos[qu + 1] - ff_atrac3p_qu_to_spec_pos[qu];
 
-        for (i = 0; i < nsp; i++)
-            dst[i] += pwcsp[i] * qu_lev;
+        fdsp->vector_fmac_scalar(dst, pwcsp, qu_lev, nsp);
     }
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/audiodsp.c b/mythtv/external/FFmpeg/libavcodec/audiodsp.c
index 85b5a749477..3c7a3a7583a 100644
--- a/mythtv/external/FFmpeg/libavcodec/audiodsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/audiodsp.c
@@ -55,8 +55,8 @@ static void vector_clipf_c_opposite_sign(float *dst, const float *src,
     }
 }
 
-static void vector_clipf_c(float *dst, const float *src,
-                           float min, float max, int len)
+static void vector_clipf_c(float *dst, const float *src, int len,
+                           float min, float max)
 {
     int i;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/audiodsp.h b/mythtv/external/FFmpeg/libavcodec/audiodsp.h
index b55bf858e0b..aa6fa7898b5 100644
--- a/mythtv/external/FFmpeg/libavcodec/audiodsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/audiodsp.h
@@ -45,10 +45,11 @@ typedef struct AudioDSPContext {
      */
     void (*vector_clip_int32)(int32_t *dst, const int32_t *src, int32_t min,
                               int32_t max, unsigned int len);
-    /* assume len is a multiple of 8, and arrays are 16-byte aligned */
+    /* assume len is a multiple of 16, and arrays are 16-byte aligned */
     void (*vector_clipf)(float *dst /* align 16 */,
                          const float *src /* align 16 */,
-                         float min, float max, int len /* align 16 */);
+                         int len /* align 16 */,
+                         float min, float max);
 } AudioDSPContext;
 
 void ff_audiodsp_init(AudioDSPContext *c);
diff --git a/mythtv/external/FFmpeg/libavcodec/audiotoolboxdec.c b/mythtv/external/FFmpeg/libavcodec/audiotoolboxdec.c
index 91e2fcb3fb3..e1f8368c78f 100644
--- a/mythtv/external/FFmpeg/libavcodec/audiotoolboxdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/audiotoolboxdec.c
@@ -32,7 +32,7 @@
 #include "libavutil/opt.h"
 #include "libavutil/log.h"
 
-#ifndef __MAC_10_11
+#if __MAC_OS_X_VERSION_MIN_REQUIRED < 101100
 #define kAudioFormatEnhancedAC3 'ec-3'
 #endif
 
@@ -43,7 +43,6 @@ typedef struct ATDecodeContext {
     AudioStreamPacketDescription pkt_desc;
     AVPacket in_pkt;
     AVPacket new_in_pkt;
-    AVBSFContext *bsf;
     char *decoded_data;
     int channel_map[64];
 
@@ -399,8 +398,13 @@ static av_cold int ffat_create_decoder(AVCodecContext *avctx, AVPacket *pkt)
 static av_cold int ffat_init_decoder(AVCodecContext *avctx)
 {
     ATDecodeContext *at = avctx->priv_data;
-    at->extradata = avctx->extradata;
-    at->extradata_size = avctx->extradata_size;
+    if (avctx->extradata_size) {
+        at->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+        if (!at->extradata)
+            return AVERROR(ENOMEM);
+        at->extradata_size = avctx->extradata_size;
+        memcpy(at->extradata, avctx->extradata, avctx->extradata_size);
+    }
 
     if ((avctx->channels && avctx->sample_rate) || ffat_usable_extradata(avctx))
         return ffat_create_decoder(avctx, NULL);
@@ -473,46 +477,28 @@ static int ffat_decode(AVCodecContext *avctx, void *data,
     ATDecodeContext *at = avctx->priv_data;
     AVFrame *frame = data;
     int pkt_size = avpkt->size;
-    AVPacket filtered_packet = {0};
     OSStatus ret;
     AudioBufferList out_buffers;
 
-    if (avctx->codec_id == AV_CODEC_ID_AAC && avpkt->size > 2 &&
-        (AV_RB16(avpkt->data) & 0xfff0) == 0xfff0) {
-        AVPacket filter_pkt = {0};
-        if (!at->bsf) {
-            const AVBitStreamFilter *bsf = av_bsf_get_by_name("aac_adtstoasc");
-            if(!bsf)
-                return AVERROR_BSF_NOT_FOUND;
-            if ((ret = av_bsf_alloc(bsf, &at->bsf)))
-                return ret;
-            if (((ret = avcodec_parameters_from_context(at->bsf->par_in, avctx)) < 0) ||
-                ((ret = av_bsf_init(at->bsf)) < 0)) {
-                av_bsf_free(&at->bsf);
-                return ret;
+    if (avctx->codec_id == AV_CODEC_ID_AAC) {
+        if (!at->extradata_size) {
+            uint8_t *side_data;
+            int side_data_size = 0;
+
+            side_data = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
+                                                &side_data_size);
+            if (side_data_size) {
+                at->extradata = av_mallocz(side_data_size + AV_INPUT_BUFFER_PADDING_SIZE);
+                if (!at->extradata)
+                    return AVERROR(ENOMEM);
+                at->extradata_size = side_data_size;
+                memcpy(at->extradata, side_data, side_data_size);
             }
         }
-
-        if ((ret = av_packet_ref(&filter_pkt, avpkt)) < 0)
-            return ret;
-
-        if ((ret = av_bsf_send_packet(at->bsf, &filter_pkt)) < 0) {
-            av_packet_unref(&filter_pkt);
-            return ret;
-        }
-
-        if ((ret = av_bsf_receive_packet(at->bsf, &filtered_packet)) < 0)
-            return ret;
-
-        at->extradata = at->bsf->par_out->extradata;
-        at->extradata_size = at->bsf->par_out->extradata_size;
-
-        avpkt = &filtered_packet;
     }
 
     if (!at->converter) {
         if ((ret = ffat_create_decoder(avctx, avpkt)) < 0) {
-            av_packet_unref(&filtered_packet);
             return ret;
         }
     }
@@ -531,9 +517,7 @@ static int ffat_decode(AVCodecContext *avctx, void *data,
     av_packet_unref(&at->new_in_pkt);
 
     if (avpkt->size) {
-        if (filtered_packet.data) {
-            at->new_in_pkt = filtered_packet;
-        } else if ((ret = av_packet_ref(&at->new_in_pkt, avpkt)) < 0) {
+        if ((ret = av_packet_ref(&at->new_in_pkt, avpkt)) < 0) {
             return ret;
         }
     } else {
@@ -582,11 +566,12 @@ static av_cold void ffat_decode_flush(AVCodecContext *avctx)
 static av_cold int ffat_close_decoder(AVCodecContext *avctx)
 {
     ATDecodeContext *at = avctx->priv_data;
-    AudioConverterDispose(at->converter);
-    av_bsf_free(&at->bsf);
+    if (at->converter)
+        AudioConverterDispose(at->converter);
     av_packet_unref(&at->new_in_pkt);
     av_packet_unref(&at->in_pkt);
-    av_free(at->decoded_data);
+    av_freep(&at->decoded_data);
+    av_freep(&at->extradata);
     return 0;
 }
 
@@ -596,7 +581,7 @@ static av_cold int ffat_close_decoder(AVCodecContext *avctx)
         .version    = LIBAVUTIL_VERSION_INT, \
     };
 
-#define FFAT_DEC(NAME, ID) \
+#define FFAT_DEC(NAME, ID, bsf_name) \
     FFAT_DEC_CLASS(NAME) \
     AVCodec ff_##NAME##_at_decoder = { \
         .name           = #NAME "_at", \
@@ -609,22 +594,23 @@ static av_cold int ffat_close_decoder(AVCodecContext *avctx)
         .decode         = ffat_decode, \
         .flush          = ffat_decode_flush, \
         .priv_class     = &ffat_##NAME##_dec_class, \
+        .bsfs           = bsf_name, \
         .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY, \
-        .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE, \
+        .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, \
     };
 
-FFAT_DEC(aac,          AV_CODEC_ID_AAC)
-FFAT_DEC(ac3,          AV_CODEC_ID_AC3)
-FFAT_DEC(adpcm_ima_qt, AV_CODEC_ID_ADPCM_IMA_QT)
-FFAT_DEC(alac,         AV_CODEC_ID_ALAC)
-FFAT_DEC(amr_nb,       AV_CODEC_ID_AMR_NB)
-FFAT_DEC(eac3,         AV_CODEC_ID_EAC3)
-FFAT_DEC(gsm_ms,       AV_CODEC_ID_GSM_MS)
-FFAT_DEC(ilbc,         AV_CODEC_ID_ILBC)
-FFAT_DEC(mp1,          AV_CODEC_ID_MP1)
-FFAT_DEC(mp2,          AV_CODEC_ID_MP2)
-FFAT_DEC(mp3,          AV_CODEC_ID_MP3)
-FFAT_DEC(pcm_alaw,     AV_CODEC_ID_PCM_ALAW)
-FFAT_DEC(pcm_mulaw,    AV_CODEC_ID_PCM_MULAW)
-FFAT_DEC(qdmc,         AV_CODEC_ID_QDMC)
-FFAT_DEC(qdm2,         AV_CODEC_ID_QDM2)
+FFAT_DEC(aac,          AV_CODEC_ID_AAC, "aac_adtstoasc")
+FFAT_DEC(ac3,          AV_CODEC_ID_AC3, NULL)
+FFAT_DEC(adpcm_ima_qt, AV_CODEC_ID_ADPCM_IMA_QT, NULL)
+FFAT_DEC(alac,         AV_CODEC_ID_ALAC, NULL)
+FFAT_DEC(amr_nb,       AV_CODEC_ID_AMR_NB, NULL)
+FFAT_DEC(eac3,         AV_CODEC_ID_EAC3, NULL)
+FFAT_DEC(gsm_ms,       AV_CODEC_ID_GSM_MS, NULL)
+FFAT_DEC(ilbc,         AV_CODEC_ID_ILBC, NULL)
+FFAT_DEC(mp1,          AV_CODEC_ID_MP1, NULL)
+FFAT_DEC(mp2,          AV_CODEC_ID_MP2, NULL)
+FFAT_DEC(mp3,          AV_CODEC_ID_MP3, NULL)
+FFAT_DEC(pcm_alaw,     AV_CODEC_ID_PCM_ALAW, NULL)
+FFAT_DEC(pcm_mulaw,    AV_CODEC_ID_PCM_MULAW, NULL)
+FFAT_DEC(qdmc,         AV_CODEC_ID_QDMC, NULL)
+FFAT_DEC(qdm2,         AV_CODEC_ID_QDM2, NULL)
diff --git a/mythtv/external/FFmpeg/libavcodec/aura.c b/mythtv/external/FFmpeg/libavcodec/aura.c
index 5f84d957fcf..5ef9316632a 100644
--- a/mythtv/external/FFmpeg/libavcodec/aura.c
+++ b/mythtv/external/FFmpeg/libavcodec/aura.c
@@ -105,4 +105,5 @@ AVCodec ff_aura2_decoder = {
     .init           = aura_decode_init,
     .decode         = aura_decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/avcodec.h b/mythtv/external/FFmpeg/libavcodec/avcodec.h
index d70c5bf5c63..b4d6054d084 100644
--- a/mythtv/external/FFmpeg/libavcodec/avcodec.h
+++ b/mythtv/external/FFmpeg/libavcodec/avcodec.h
@@ -89,7 +89,7 @@
  * - Send valid input:
  *   - For decoding, call avcodec_send_packet() to give the decoder raw
  *     compressed data in an AVPacket.
- *   - For encoding, call avcodec_send_frame() to give the decoder an AVFrame
+ *   - For encoding, call avcodec_send_frame() to give the encoder an AVFrame
  *     containing uncompressed audio or video.
  *   In both cases, it is recommended that AVPackets and AVFrames are
  *   refcounted, or libavcodec might have to copy the input data. (libavformat
@@ -112,6 +112,12 @@
  * are filled. This situation is handled transparently if you follow the steps
  * outlined above.
  *
+ * In theory, sending input can result in EAGAIN - this should happen only if
+ * not all output was received. You can use this to structure alternative decode
+ * or encode loops other than the one suggested above. For example, you could
+ * try sending new input on each iteration, and try to receive output if that
+ * returns EAGAIN.
+ *
  * End of stream situations. These require "flushing" (aka draining) the codec,
  * as the codec might buffer multiple frames or packets internally for
  * performance or out of necessity (consider B-frames).
@@ -136,8 +142,9 @@
  *
  * Not all codecs will follow a rigid and predictable dataflow; the only
  * guarantee is that an AVERROR(EAGAIN) return value on a send/receive call on
- * one end implies that a receive/send call on the other end will succeed. In
- * general, no codec will permit unlimited buffering of input or output.
+ * one end implies that a receive/send call on the other end will succeed, or
+ * at least will not fail with AVERROR(EAGAIN). In general, no codec will
+ * permit unlimited buffering of input or output.
  *
  * This API replaces the following legacy functions:
  * - avcodec_decode_video2() and avcodec_decode_audio4():
@@ -146,7 +153,8 @@
  *   Unlike with the old video decoding API, multiple frames might result from
  *   a packet. For audio, splitting the input packet into frames by partially
  *   decoding packets becomes transparent to the API user. You never need to
- *   feed an AVPacket to the API twice.
+ *   feed an AVPacket to the API twice (unless it is rejected with AVERROR(EAGAIN) - then
+ *   no data was read from the packet).
  *   Additionally, sending a flush/draining packet is required only once.
  * - avcodec_encode_video2()/avcodec_encode_audio2():
  *   Use avcodec_send_frame() to feed input to the encoder, then use
@@ -159,7 +167,22 @@
  * and will result in undefined behavior.
  *
  * Some codecs might require using the new API; using the old API will return
- * an error when calling it.
+ * an error when calling it. All codecs support the new API.
+ *
+ * A codec is not allowed to return AVERROR(EAGAIN) for both sending and receiving. This
+ * would be an invalid state, which could put the codec user into an endless
+ * loop. The API has no concept of time either: it cannot happen that trying to
+ * do avcodec_send_packet() results in AVERROR(EAGAIN), but a repeated call 1 second
+ * later accepts the packet (with no other receive/flush API calls involved).
+ * The API is a strict state machine, and the passage of time is not supposed
+ * to influence it. Some timing-dependent behavior might still be deemed
+ * acceptable in certain cases. But it must never result in both send/receive
+ * returning EAGAIN at the same time at any point. It must also absolutely be
+ * avoided that the current state is "unstable" and can "flip-flop" between
+ * the send/receive APIs allowing progress. For example, it's not allowed that
+ * the codec randomly decides that it actually wants to consume a packet now
+ * instead of returning a frame, after it just returned AVERROR(EAGAIN) on an
+ * avcodec_send_packet() call.
  * @}
  */
 
@@ -411,6 +434,20 @@ enum AVCodecID {
     AV_CODEC_ID_MAGICYUV,
     AV_CODEC_ID_SHEERVIDEO,
     AV_CODEC_ID_YLC,
+    AV_CODEC_ID_PSD,
+    AV_CODEC_ID_PIXLET,
+    AV_CODEC_ID_SPEEDHQ,
+    AV_CODEC_ID_FMVC,
+    AV_CODEC_ID_SCPR,
+    AV_CODEC_ID_CLEARVIDEO,
+    AV_CODEC_ID_XPM,
+    AV_CODEC_ID_AV1,
+    AV_CODEC_ID_BITPACKED,
+    AV_CODEC_ID_MSCC,
+    AV_CODEC_ID_SRGC,
+    AV_CODEC_ID_SVG,
+    AV_CODEC_ID_GDV,
+    AV_CODEC_ID_FITS,
 
     /* various PCM "codecs" */
     AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
@@ -448,6 +485,8 @@ enum AVCodecID {
 
     AV_CODEC_ID_PCM_S64LE = 0x10800,
     AV_CODEC_ID_PCM_S64BE,
+    AV_CODEC_ID_PCM_F16LE,
+    AV_CODEC_ID_PCM_F24LE,
 
     /* various ADPCM codecs */
     AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
@@ -511,6 +550,7 @@ enum AVCodecID {
     AV_CODEC_ID_SOL_DPCM,
 
     AV_CODEC_ID_SDX2_DPCM = 0x14800,
+    AV_CODEC_ID_GREMLIN_DPCM,
 
     /* audio codecs */
     AV_CODEC_ID_MP2 = 0x15000,
@@ -598,6 +638,9 @@ enum AVCodecID {
     AV_CODEC_ID_XMA1,
     AV_CODEC_ID_XMA2,
     AV_CODEC_ID_DST,
+    AV_CODEC_ID_ATRAC3AL,
+    AV_CODEC_ID_ATRAC3PAL,
+    AV_CODEC_ID_DOLBY_E,
 
     /* subtitle codecs */
     AV_CODEC_ID_FIRST_SUBTITLE = 0x17000,          ///< A dummy ID pointing at the start of subtitle codecs.
@@ -696,7 +739,7 @@ typedef struct AVCodecDescriptor {
 
 /**
  * Codec uses only intra compression.
- * Video codecs only.
+ * Video and audio codecs only.
  */
 #define AV_CODEC_PROP_INTRA_ONLY    (1 << 0)
 /**
@@ -1367,6 +1410,11 @@ typedef struct AVCPBProperties {
  * @{
  */
 enum AVPacketSideDataType {
+    /**
+     * An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE
+     * bytes worth of palette. This side data signals that a new palette is
+     * present.
+     */
     AV_PKT_DATA_PALETTE,
 
     /**
@@ -1540,10 +1588,40 @@ enum AVPacketSideDataType {
 
     /**
      * Mastering display metadata (based on SMPTE-2086:2014). This metadata
-     * should be associated with a video stream and containts data in the form
+     * should be associated with a video stream and contains data in the form
      * of the AVMasteringDisplayMetadata struct.
      */
-    AV_PKT_DATA_MASTERING_DISPLAY_METADATA
+    AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
+
+    /**
+     * This side data should be associated with a video stream and corresponds
+     * to the AVSphericalMapping structure.
+     */
+    AV_PKT_DATA_SPHERICAL,
+
+    /**
+     * Content light level (based on CTA-861.3). This metadata should be
+     * associated with a video stream and contains data in the form of the
+     * AVContentLightMetadata struct.
+     */
+    AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
+
+    /**
+     * ATSC A53 Part 4 Closed Captions. This metadata should be associated with
+     * a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.
+     * The number of bytes of CC data is AVPacketSideData.size.
+     */
+    AV_PKT_DATA_A53_CC,
+
+    /**
+     * The number of side data elements (in fact a bit more than it).
+     * This is not part of the public API/ABI in the sense that it may
+     * change when new side data types are added.
+     * This must stay the last enum value.
+     * If its value becomes huge, some code using it
+     * needs to be updated as it assumes it to be smaller than other limits.
+     */
+    AV_PKT_DATA_NB
 };
 
 #define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED
@@ -1645,6 +1723,13 @@ typedef struct AVPacket {
  * after decoding.
  **/
 #define AV_PKT_FLAG_DISCARD   0x0004
+/**
+ * The packet comes from a trusted source.
+ *
+ * Otherwise-unsafe constructs such as arbitrary pointers to data
+ * outside the packet may be followed.
+ */
+#define AV_PKT_FLAG_TRUSTED   0x0008
 
 enum AVSideDataParamChangeFlags {
     AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT  = 0x0001,
@@ -1672,7 +1757,7 @@ enum AVFieldOrder {
  * New fields can be added to the end with minor version bumps.
  * Removal, reordering and changes to existing fields require a major
  * version bump.
- * Please use AVOptions (av_opt* / av_set/get*()) to access these fields from user
+ * You can use AVOptions (av_opt* / av_set/get*()) to access these fields from user
  * applications.
  * The name string for AVOptions options matches the associated command line
  * parameter name and can be found in libavcodec/options_table.h
@@ -2612,6 +2697,7 @@ typedef struct AVCodecContext {
      * - encoding: unused
      * - decoding: set by the caller before avcodec_open2().
      */
+    attribute_deprecated
     int refcounted_frames;
 
     /**
@@ -2894,6 +2980,7 @@ typedef struct AVCodecContext {
 #define FF_BUG_DC_CLIP          4096
 #define FF_BUG_MS               8192 ///< Work around various bugs in Microsoft's broken decoders.
 #define FF_BUG_TRUNCATED       16384
+#define FF_BUG_IEDGE           32768
 
     /**
      * strictly follow the standard (MPEG-4, ...).
@@ -2951,8 +3038,8 @@ typedef struct AVCodecContext {
 #define FF_DEBUG_MMCO        0x00000800
 #define FF_DEBUG_BUGS        0x00001000
 #if FF_API_DEBUG_MV
-#define FF_DEBUG_VIS_QP      0x00002000 ///< only access through AVOptions from outside libavcodec
-#define FF_DEBUG_VIS_MB_TYPE 0x00004000 ///< only access through AVOptions from outside libavcodec
+#define FF_DEBUG_VIS_QP      0x00002000
+#define FF_DEBUG_VIS_MB_TYPE 0x00004000
 #endif
 #define FF_DEBUG_BUFFERS     0x00008000
 #define FF_DEBUG_THREADS     0x00010000
@@ -2962,7 +3049,6 @@ typedef struct AVCodecContext {
 #if FF_API_DEBUG_MV
     /**
      * debug
-     * Code outside libavcodec should access this field using AVOptions
      * - encoding: Set by user.
      * - decoding: Set by user.
      */
@@ -3076,6 +3162,7 @@ typedef struct AVCodecContext {
 #if FF_API_ARCH_ALPHA
 #define FF_IDCT_SIMPLEALPHA   23
 #endif
+#define FF_IDCT_NONE          24 /* Used by XvMC to extract IDCT coefficients with FF_IDCT_PERM_NONE */
 #define FF_IDCT_SIMPLEAUTO    128
 
     /**
@@ -3097,8 +3184,6 @@ typedef struct AVCodecContext {
      * low resolution decoding, 1-> 1/2 size, 2->1/4 size
      * - encoding: unused
      * - decoding: Set by user.
-     * Code outside libavcodec should access this field using:
-     * av_codec_{get,set}_lowres(avctx)
      */
      int lowres;
 #endif
@@ -3399,8 +3484,6 @@ typedef struct AVCodecContext {
 
     /**
      * Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
-     * Code outside libavcodec should access this field using:
-     * av_codec_{get,set}_pkt_timebase(avctx)
      * - encoding unused.
      * - decoding set by user.
      */
@@ -3408,8 +3491,6 @@ typedef struct AVCodecContext {
 
     /**
      * AVCodecDescriptor
-     * Code outside libavcodec should access this field using:
-     * av_codec_{get,set}_codec_descriptor(avctx)
      * - encoding: unused.
      * - decoding: set by libavcodec.
      */
@@ -3420,8 +3501,6 @@ typedef struct AVCodecContext {
      * low resolution decoding, 1-> 1/2 size, 2->1/4 size
      * - encoding: unused
      * - decoding: Set by user.
-     * Code outside libavcodec should access this field using:
-     * av_codec_{get,set}_lowres(avctx)
      */
      int lowres;
 #endif
@@ -3462,7 +3541,6 @@ typedef struct AVCodecContext {
      * However for formats that do not use pre-multiplied alpha
      * there might be serious artefacts (though e.g. libswscale currently
      * assumes pre-multiplied alpha anyway).
-     * Code outside libavcodec should access this field using AVOptions
      *
      * - decoding: set by user
      * - encoding: unused
@@ -3479,7 +3557,6 @@ typedef struct AVCodecContext {
 #if !FF_API_DEBUG_MV
     /**
      * debug motion vectors
-     * Code outside libavcodec should access this field using AVOptions
      * - encoding: Set by user.
      * - decoding: Set by user.
      */
@@ -3491,7 +3568,6 @@ typedef struct AVCodecContext {
 
     /**
      * custom intra quantization matrix
-     * Code outside libavcodec should access this field using av_codec_g/set_chroma_intra_matrix()
      * - encoding: Set by user, can be NULL.
      * - decoding: unused.
      */
@@ -3500,8 +3576,6 @@ typedef struct AVCodecContext {
     /**
      * dump format separator.
      * can be ", " or "\n      " or anything else
-     * Code outside libavcodec should access this field using AVOptions
-     * (NO direct access).
      * - encoding: Set by user.
      * - decoding: Set by user.
      */
@@ -3511,13 +3585,12 @@ typedef struct AVCodecContext {
      * ',' separated list of allowed decoders.
      * If NULL then all are allowed
      * - encoding: unused
-     * - decoding: set by user through AVOPtions (NO direct access)
+     * - decoding: set by user
      */
     char *codec_whitelist;
 
-    /*
+    /**
      * Properties of the stream that gets decoded
-     * To be accessed through av_codec_get_properties() (NO direct access)
      * - encoding: unused
      * - decoding: set by libavcodec
      */
@@ -3537,7 +3610,8 @@ typedef struct AVCodecContext {
     /**
      * A reference to the AVHWFramesContext describing the input (for encoding)
      * or output (decoding) frames. The reference is set by the caller and
-     * afterwards owned (and freed) by libavcodec.
+     * afterwards owned (and freed) by libavcodec - it should never be read by
+     * the caller after being set.
      *
      * - decoding: This field should be set by the caller from the get_format()
      *             callback. The previous reference (if any) will always be
@@ -3579,6 +3653,71 @@ typedef struct AVCodecContext {
      */
     int trailing_padding;
 
+    /**
+     * The number of pixels per image to maximally accept.
+     *
+     * - decoding: set by user
+     * - encoding: set by user
+     */
+    int64_t max_pixels;
+
+    /**
+     * A reference to the AVHWDeviceContext describing the device which will
+     * be used by a hardware encoder/decoder.  The reference is set by the
+     * caller and afterwards owned (and freed) by libavcodec.
+     *
+     * This should be used if either the codec device does not require
+     * hardware frames or any that are used are to be allocated internally by
+     * libavcodec.  If the user wishes to supply any of the frames used as
+     * encoder input or decoder output then hw_frames_ctx should be used
+     * instead.  When hw_frames_ctx is set in get_format() for a decoder, this
+     * field will be ignored while decoding the associated stream segment, but
+     * may again be used on a following one after another get_format() call.
+     *
+     * For both encoders and decoders this field should be set before
+     * avcodec_open2() is called and must not be written to thereafter.
+     *
+     * Note that some decoders may require this field to be set initially in
+     * order to support hw_frames_ctx at all - in that case, all frames
+     * contexts used must be created on the same device.
+     */
+    AVBufferRef *hw_device_ctx;
+
+    /**
+     * Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated
+     * decoding (if active).
+     * - encoding: unused
+     * - decoding: Set by user (either before avcodec_open2(), or in the
+     *             AVCodecContext.get_format callback)
+     */
+    int hwaccel_flags;
+
+    /**
+     * Video decoding only. Certain video codecs support cropping, meaning that
+     * only a sub-rectangle of the decoded frame is intended for display.  This
+     * option controls how cropping is handled by libavcodec.
+     *
+     * When set to 1 (the default), libavcodec will apply cropping internally.
+     * I.e. it will modify the output frame width/height fields and offset the
+     * data pointers (only by as much as possible while preserving alignment, or
+     * by the full amount if the AV_CODEC_FLAG_UNALIGNED flag is set) so that
+     * the frames output by the decoder refer only to the cropped area. The
+     * crop_* fields of the output frames will be zero.
+     *
+     * When set to 0, the width/height fields of the output frames will be set
+     * to the coded dimensions and the crop_* fields will describe the cropping
+     * rectangle. Applying the cropping is left to the caller.
+     *
+     * @warning When hardware acceleration with opaque output frames is used,
+     * libavcodec is unable to apply cropping from the top/left border.
+     *
+     * @note when this option is set to zero, the width/height fields of the
+     * AVCodecContext and output AVFrames have different meanings. The codec
+     * context fields store display dimensions (with the coded dimensions in
+     * coded_width/height), while the frame fields store the coded dimensions
+     * (with the display dimensions being determined by the crop_* fields).
+     */
+    int apply_cropping;
 } AVCodecContext;
 
 AVRational av_codec_get_pkt_timebase         (const AVCodecContext *avctx);
@@ -3638,7 +3777,7 @@ typedef struct AVCodec {
     const int *supported_samplerates;       ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
     const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
     const uint64_t *channel_layouts;         ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
-    uint8_t max_lowres;                     ///< maximum value for lowres supported by the decoder, no direct access, use av_codec_get_max_lowres()
+    uint8_t max_lowres;                     ///< maximum value for lowres supported by the decoder
     const AVClass *priv_class;              ///< AVClass for the private context
     const AVProfile *profiles;              ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
 
@@ -3699,20 +3838,22 @@ typedef struct AVCodec {
     int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt);
     int (*close)(AVCodecContext *);
     /**
-     * Decode/encode API with decoupled packet/frame dataflow. The API is the
+     * Encode API with decoupled packet/frame dataflow. The API is the
      * same as the avcodec_ prefixed APIs (avcodec_send_frame() etc.), except
      * that:
      * - never called if the codec is closed or the wrong type,
-     * - AVPacket parameter change side data is applied right before calling
-     *   AVCodec->send_packet,
-     * - if AV_CODEC_CAP_DELAY is not set, drain packets or frames are never sent,
-     * - only one drain packet is ever passed down (until the next flush()),
-     * - a drain AVPacket is always NULL (no need to check for avpkt->size).
+     * - if AV_CODEC_CAP_DELAY is not set, drain frames are never sent,
+     * - only one drain frame is ever passed down,
      */
     int (*send_frame)(AVCodecContext *avctx, const AVFrame *frame);
-    int (*send_packet)(AVCodecContext *avctx, const AVPacket *avpkt);
-    int (*receive_frame)(AVCodecContext *avctx, AVFrame *frame);
     int (*receive_packet)(AVCodecContext *avctx, AVPacket *avpkt);
+
+    /**
+     * Decode API with decoupled packet/frame dataflow. This function is called
+     * to get one output frame. It should call ff_decode_get_packet() to obtain
+     * input data.
+     */
+    int (*receive_frame)(AVCodecContext *avctx, AVFrame *frame);
     /**
      * Flush buffers.
      * Will be called when seeking
@@ -3723,6 +3864,12 @@ typedef struct AVCodec {
      * See FF_CODEC_CAP_* in internal.h
      */
     int caps_internal;
+
+    /**
+     * Decoding only, a comma-separated list of bitstream filters to apply to
+     * packets before decoding.
+     */
+    const char *bsfs;
 } AVCodec;
 
 int av_codec_get_max_lowres(const AVCodec *codec);
@@ -3764,7 +3911,7 @@ typedef struct AVHWAccel {
 
     /**
      * Hardware accelerated codec capabilities.
-     * see HWACCEL_CODEC_CAP_*
+     * see AV_HWACCEL_CODEC_CAP_*
      */
     int capabilities;
 
@@ -3835,7 +3982,7 @@ typedef struct AVHWAccel {
     /**
      * Called for every Macroblock in a slice.
      *
-     * XvMC uses it to replace the ff_mpv_decode_mb().
+     * XvMC uses it to replace the ff_mpv_reconstruct_mb().
      * Instead of decoding to raw picture, MB parameters are
      * stored in an array provided by the video driver.
      *
@@ -3865,8 +4012,19 @@ typedef struct AVHWAccel {
      * AVCodecInternal.hwaccel_priv_data.
      */
     int priv_data_size;
+
+    /**
+     * Internal hwaccel capabilities.
+     */
+    int caps_internal;
 } AVHWAccel;
 
+/**
+ * HWAccel is experimental and is thus avoided in favor of non experimental
+ * codecs
+ */
+#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL 0x0200
+
 /**
  * Hardware acceleration should be used for decoding even if the codec level
  * used is unknown or higher than the maximum supported level reported by the
@@ -3883,6 +4041,20 @@ typedef struct AVHWAccel {
  */
 #define AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH (1 << 1)
 
+/**
+ * Hardware acceleration should still be attempted for decoding when the
+ * codec profile does not match the reported capabilities of the hardware.
+ *
+ * For example, this can be used to try to decode baseline profile H.264
+ * streams in hardware - it will often succeed, because many streams marked
+ * as baseline profile actually conform to constrained baseline profile.
+ *
+ * @warning If the stream is actually not supported then the behaviour is
+ *          undefined, and may include returning entirely incorrect output
+ *          while indicating success.
+ */
+#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH (1 << 2)
+
 /**
  * @}
  */
@@ -4397,13 +4569,13 @@ AVPacket *av_packet_alloc(void);
  * @see av_packet_alloc
  * @see av_packet_ref
  */
-AVPacket *av_packet_clone(AVPacket *src);
+AVPacket *av_packet_clone(const AVPacket *src);
 
 /**
  * Free the packet, if the packet is reference counted, it will be
  * unreferenced first.
  *
- * @param packet packet to be freed. The pointer will be set to NULL.
+ * @param pkt packet to be freed. The pointer will be set to NULL.
  * @note passing NULL is a no-op.
  */
 void av_packet_free(AVPacket **pkt);
@@ -4472,14 +4644,20 @@ int av_dup_packet(AVPacket *pkt);
  * Copy packet, including contents
  *
  * @return 0 on success, negative AVERROR on fail
+ *
+ * @deprecated Use av_packet_ref
  */
+attribute_deprecated
 int av_copy_packet(AVPacket *dst, const AVPacket *src);
 
 /**
  * Copy packet side data
  *
  * @return 0 on success, negative AVERROR on fail
+ *
+ * @deprecated Use av_packet_copy_props
  */
+attribute_deprecated
 int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src);
 
 /**
@@ -4538,12 +4716,16 @@ int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
  * @param size pointer for side information size to store (optional)
  * @return pointer to data if present or NULL otherwise
  */
-uint8_t* av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
+uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
                                  int *size);
 
+#if FF_API_MERGE_SD_API
+attribute_deprecated
 int av_packet_merge_side_data(AVPacket *pkt);
 
+attribute_deprecated
 int av_packet_split_side_data(AVPacket *pkt);
+#endif
 
 const char *av_packet_side_data_name(enum AVPacketSideDataType type);
 
@@ -4843,13 +5025,13 @@ int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
  * and reusing a get_buffer written for video codecs would probably perform badly
  * due to a potentially very different allocation pattern.
  *
- * Some decoders (those marked with CODEC_CAP_DELAY) have a delay between input
+ * Some decoders (those marked with AV_CODEC_CAP_DELAY) have a delay between input
  * and output. This means that for some packets they will not immediately
  * produce decoded output and need to be flushed at the end of decoding to get
  * all the decoded data. Flushing is done by calling this function with packets
  * with avpkt->data set to NULL and avpkt->size set to 0 until it stops
  * returning subtitles. It is safe to flush even those decoders that are not
- * marked with CODEC_CAP_DELAY, then no subtitles will be returned.
+ * marked with AV_CODEC_CAP_DELAY, then no subtitles will be returned.
  *
  * @note The AVCodecContext MUST have been opened with @ref avcodec_open2()
  * before packets may be fed to the decoder.
@@ -4903,8 +5085,10 @@ int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
  *                  a flush packet.
  *
  * @return 0 on success, otherwise negative error code:
- *      AVERROR(EAGAIN):   input is not accepted right now - the packet must be
- *                         resent after trying to read output
+ *      AVERROR(EAGAIN):   input is not accepted in the current state - user
+ *                         must read output with avcodec_receive_frame() (once
+ *                         all output is read, the packet should be resent, and
+ *                         the call will not fail with EAGAIN).
  *      AVERROR_EOF:       the decoder has been flushed, and no new packets can
  *                         be sent to it (also returned if more than 1 flush
  *                         packet is sent)
@@ -4925,7 +5109,7 @@ int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt);
  *
  * @return
  *      0:                 success, a frame was returned
- *      AVERROR(EAGAIN):   output is not available right now - user must try
+ *      AVERROR(EAGAIN):   output is not available in this state - user must try
  *                         to send new input
  *      AVERROR_EOF:       the decoder has been fully flushed, and there will be
  *                         no more output frames
@@ -4958,8 +5142,10 @@ int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame);
  *                  avctx->frame_size for all frames except the last.
  *                  The final frame may be smaller than avctx->frame_size.
  * @return 0 on success, otherwise negative error code:
- *      AVERROR(EAGAIN):   input is not accepted right now - the frame must be
- *                         resent after trying to read output packets
+ *      AVERROR(EAGAIN):   input is not accepted in the current state - user
+ *                         must read output with avcodec_receive_packet() (once
+ *                         all output is read, the packet should be resent, and
+ *                         the call will not fail with EAGAIN).
  *      AVERROR_EOF:       the encoder has been flushed, and no new frames can
  *                         be sent to it
  *      AVERROR(EINVAL):   codec not opened, refcounted_frames not set, it is a
@@ -4977,8 +5163,8 @@ int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame);
  *              encoder. Note that the function will always call
  *              av_frame_unref(frame) before doing anything else.
  * @return 0 on success, otherwise negative error code:
- *      AVERROR(EAGAIN):   output is not available right now - user must try
- *                         to send input
+ *      AVERROR(EAGAIN):   output is not available in the current state - user
+ *                         must try to send input
  *      AVERROR_EOF:       the encoder has been fully flushed, and there will be
  *                         no more output packets
  *      AVERROR(EINVAL):   codec not opened, or it is an encoder
@@ -5529,22 +5715,14 @@ int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width,
  * @{
  */
 
+#if FF_API_GETCHROMA
 /**
- * Utility function to access log2_chroma_w log2_chroma_h from
- * the pixel format AVPixFmtDescriptor.
- *
- * This function asserts that pix_fmt is valid. See av_pix_fmt_get_chroma_sub_sample
- * for one that returns a failure code and continues in case of invalid
- * pix_fmts.
- *
- * @param[in]  pix_fmt the pixel format
- * @param[out] h_shift store log2_chroma_w
- * @param[out] v_shift store log2_chroma_h
- *
- * @see av_pix_fmt_get_chroma_sub_sample
+ * @deprecated Use av_pix_fmt_get_chroma_sub_sample
  */
 
+attribute_deprecated
 void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift);
+#endif
 
 /**
  * Return a value representing the fourCC code associated to the
@@ -5604,6 +5782,7 @@ attribute_deprecated
 void avcodec_set_dimensions(AVCodecContext *s, int width, int height);
 #endif
 
+#if FF_API_TAG_STRING
 /**
  * Put a string representing the codec tag codec_tag in buf.
  *
@@ -5612,8 +5791,12 @@ void avcodec_set_dimensions(AVCodecContext *s, int width, int height);
  * @param codec_tag codec tag to assign
  * @return the length of the string that would have been generated if
  * enough space had been available, excluding the trailing null
+ *
+ * @deprecated see av_fourcc_make_string() and av_fourcc2str().
  */
+attribute_deprecated
 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag);
+#endif
 
 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
 
@@ -5726,7 +5909,7 @@ int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes);
 #if FF_API_OLD_BSF
 typedef struct AVBitStreamFilterContext {
     void *priv_data;
-    struct AVBitStreamFilter *filter;
+    const struct AVBitStreamFilter *filter;
     AVCodecParserContext *parser;
     struct AVBitStreamFilterContext *next;
     /**
@@ -5773,12 +5956,15 @@ typedef struct AVBSFContext {
     void *priv_data;
 
     /**
-     * Parameters of the input stream. Set by the caller before av_bsf_init().
+     * Parameters of the input stream. This field is allocated in
+     * av_bsf_alloc(), it needs to be filled by the caller before
+     * av_bsf_init().
      */
     AVCodecParameters *par_in;
 
     /**
-     * Parameters of the output stream. Set by the filter in av_bsf_init().
+     * Parameters of the output stream. This field is allocated in
+     * av_bsf_alloc(), it is set by the filter in av_bsf_init().
      */
     AVCodecParameters *par_out;
 
@@ -5956,8 +6142,7 @@ int av_bsf_init(AVBSFContext *ctx);
  * av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or
  * AVERROR_EOF.
  *
- * @param pkt the packet to filter. pkt must contain some payload (i.e data or
- * side data must be present in pkt). The bitstream filter will take ownership of
+ * @param pkt the packet to filter. The bitstream filter will take ownership of
  * the packet and reset the contents of pkt. pkt is not touched if an error occurs.
  * This parameter may be NULL, which signals the end of the stream (i.e. no more
  * packets will be sent). That will cause the filter to output any packets it
diff --git a/mythtv/external/FFmpeg/libavcodec/avpacket.c b/mythtv/external/FFmpeg/libavcodec/avpacket.c
index c3f871c3478..d1f4ea9eb3f 100644
--- a/mythtv/external/FFmpeg/libavcodec/avpacket.c
+++ b/mythtv/external/FFmpeg/libavcodec/avpacket.c
@@ -247,8 +247,6 @@ int av_copy_packet_side_data(AVPacket *pkt, const AVPacket *src)
     av_packet_unref(pkt);
     return AVERROR(ENOMEM);
 }
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
 
 int av_dup_packet(AVPacket *pkt)
 {
@@ -266,6 +264,8 @@ int av_copy_packet(AVPacket *dst, const AVPacket *src)
     *dst = *src;
     return copy_packet_data(dst, src, 0);
 }
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
 
 void av_packet_free_side_data(AVPacket *pkt)
 {
@@ -295,16 +295,28 @@ FF_ENABLE_DEPRECATION_WARNINGS
 int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
                             uint8_t *data, size_t size)
 {
-    int elems = pkt->side_data_elems;
+    AVPacketSideData *tmp;
+    int i, elems = pkt->side_data_elems;
+
+    for (i = 0; i < elems; i++) {
+        AVPacketSideData *sd = &pkt->side_data[i];
+
+        if (sd->type == type) {
+            av_free(sd->data);
+            sd->data = data;
+            sd->size = size;
+            return 0;
+        }
+    }
 
-    if ((unsigned)elems + 1 > INT_MAX / sizeof(*pkt->side_data))
+    if ((unsigned)elems + 1 > AV_PKT_DATA_NB)
         return AVERROR(ERANGE);
 
-    pkt->side_data = av_realloc(pkt->side_data,
-                                (elems + 1) * sizeof(*pkt->side_data));
-    if (!pkt->side_data)
+    tmp = av_realloc(pkt->side_data, (elems + 1) * sizeof(*tmp));
+    if (!tmp)
         return AVERROR(ENOMEM);
 
+    pkt->side_data = tmp;
     pkt->side_data[elems].data = data;
     pkt->side_data[elems].size = size;
     pkt->side_data[elems].type = type;
@@ -335,7 +347,7 @@ uint8_t *av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
     return data;
 }
 
-uint8_t *av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
+uint8_t *av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
                                  int *size)
 {
     int i;
@@ -347,6 +359,8 @@ uint8_t *av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
             return pkt->side_data[i].data;
         }
     }
+    if (size)
+        *size = 0;
     return NULL;
 }
 
@@ -371,10 +385,15 @@ const char *av_packet_side_data_name(enum AVPacketSideDataType type)
     case AV_PKT_DATA_METADATA_UPDATE:            return "Metadata Update";
     case AV_PKT_DATA_MPEGTS_STREAM_ID:           return "MPEGTS Stream ID";
     case AV_PKT_DATA_MASTERING_DISPLAY_METADATA: return "Mastering display metadata";
+    case AV_PKT_DATA_CONTENT_LIGHT_LEVEL:        return "Content light level metadata";
+    case AV_PKT_DATA_SPHERICAL:                  return "Spherical Mapping";
+    case AV_PKT_DATA_A53_CC:                     return "A53 Closed Captions";
     }
     return NULL;
 }
 
+#if FF_API_MERGE_SD_API
+
 #define FF_MERGE_MARKER 0x8c4d9d108e25e9feULL
 
 int av_packet_merge_side_data(AVPacket *pkt){
@@ -430,6 +449,9 @@ int av_packet_split_side_data(AVPacket *pkt){
             p-= size+5;
         }
 
+        if (i > AV_PKT_DATA_NB)
+            return AVERROR(ERANGE);
+
         pkt->side_data = av_malloc_array(i, sizeof(*pkt->side_data));
         if (!pkt->side_data)
             return AVERROR(ENOMEM);
@@ -455,6 +477,35 @@ int av_packet_split_side_data(AVPacket *pkt){
     }
     return 0;
 }
+#endif
+
+#if FF_API_MERGE_SD
+int ff_packet_split_and_drop_side_data(AVPacket *pkt){
+    if (!pkt->side_data_elems && pkt->size >12 && AV_RB64(pkt->data + pkt->size - 8) == FF_MERGE_MARKER){
+        int i;
+        unsigned int size;
+        uint8_t *p;
+
+        p = pkt->data + pkt->size - 8 - 5;
+        for (i=1; ; i++){
+            size = AV_RB32(p);
+            if (size>INT_MAX - 5 || p - pkt->data < size)
+                return 0;
+            if (p[4]&128)
+                break;
+            if (p - pkt->data < size + 5)
+                return 0;
+            p-= size+5;
+            if (i > AV_PKT_DATA_NB)
+                return 0;
+        }
+        pkt->size = p - pkt->data - size;
+        av_assert0(pkt->size >= 0);
+        return 1;
+    }
+    return 0;
+}
+#endif
 
 uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size)
 {
@@ -504,7 +555,7 @@ int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **di
         const uint8_t *key = data;
         const uint8_t *val = data + strlen(key) + 1;
 
-        if (val >= end)
+        if (val >= end || !*key)
             return AVERROR_INVALIDDATA;
 
         ret = av_dict_set(dict, key, val, 0);
@@ -606,7 +657,7 @@ int av_packet_ref(AVPacket *dst, const AVPacket *src)
     return ret;
 }
 
-AVPacket *av_packet_clone(AVPacket *src)
+AVPacket *av_packet_clone(const AVPacket *src)
 {
     AVPacket *ret = av_packet_alloc();
 
diff --git a/mythtv/external/FFmpeg/libavcodec/avrndec.c b/mythtv/external/FFmpeg/libavcodec/avrndec.c
index cdec99c9906..c37f99661b5 100644
--- a/mythtv/external/FFmpeg/libavcodec/avrndec.c
+++ b/mythtv/external/FFmpeg/libavcodec/avrndec.c
@@ -170,4 +170,5 @@ AVCodec ff_avrn_decoder = {
     .decode         = decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
     .max_lowres     = 3,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/avs.c b/mythtv/external/FFmpeg/libavcodec/avs.c
index 345d628dd56..66724d47b72 100644
--- a/mythtv/external/FFmpeg/libavcodec/avs.c
+++ b/mythtv/external/FFmpeg/libavcodec/avs.c
@@ -186,4 +186,5 @@ AVCodec ff_avs_decoder = {
     .decode         = avs_decode_frame,
     .close          = avs_decode_end,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/avuidec.c b/mythtv/external/FFmpeg/libavcodec/avuidec.c
index 5117844fa9d..4cf620d43a9 100644
--- a/mythtv/external/FFmpeg/libavcodec/avuidec.c
+++ b/mythtv/external/FFmpeg/libavcodec/avuidec.c
@@ -127,4 +127,5 @@ AVCodec ff_avui_decoder = {
     .init         = avui_decode_init,
     .decode       = avui_decode_frame,
     .capabilities = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/bethsoftvideo.c b/mythtv/external/FFmpeg/libavcodec/bethsoftvideo.c
index 97b745d38a0..274516bf4d8 100644
--- a/mythtv/external/FFmpeg/libavcodec/bethsoftvideo.c
+++ b/mythtv/external/FFmpeg/libavcodec/bethsoftvideo.c
@@ -163,4 +163,5 @@ AVCodec ff_bethsoftvid_decoder = {
     .close          = bethsoftvid_decode_end,
     .decode         = bethsoftvid_decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/bfi.c b/mythtv/external/FFmpeg/libavcodec/bfi.c
index 6727629b52b..233a1d27a8f 100644
--- a/mythtv/external/FFmpeg/libavcodec/bfi.c
+++ b/mythtv/external/FFmpeg/libavcodec/bfi.c
@@ -185,4 +185,5 @@ AVCodec ff_bfi_decoder = {
     .close          = bfi_decode_close,
     .decode         = bfi_decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/bink.c b/mythtv/external/FFmpeg/libavcodec/bink.c
index cc558701145..346b6cda9df 100644
--- a/mythtv/external/FFmpeg/libavcodec/bink.c
+++ b/mythtv/external/FFmpeg/libavcodec/bink.c
@@ -813,7 +813,7 @@ static int binkb_decode_plane(BinkContext *c, AVFrame *frame, GetBitContext *gb,
     int v, col[2];
     const uint8_t *scan;
     int xoff, yoff;
-    LOCAL_ALIGNED_16(int16_t, block, [64]);
+    LOCAL_ALIGNED_32(int16_t, block, [64]);
     LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
     int coordmap[64];
     int ybias = is_key ? -15 : 0;
@@ -976,7 +976,7 @@ static int bink_decode_plane(BinkContext *c, AVFrame *frame, GetBitContext *gb,
     uint8_t *dst, *prev, *ref_start, *ref_end;
     int v, col[2];
     const uint8_t *scan;
-    LOCAL_ALIGNED_16(int16_t, block, [64]);
+    LOCAL_ALIGNED_32(int16_t, block, [64]);
     LOCAL_ALIGNED_16(uint8_t, ublock, [64]);
     LOCAL_ALIGNED_16(int32_t, dctblock, [64]);
     int coordmap[64];
diff --git a/mythtv/external/FFmpeg/libavcodec/binkaudio.c b/mythtv/external/FFmpeg/libavcodec/binkaudio.c
index f1fa2ab882c..e0f3d14eef2 100644
--- a/mythtv/external/FFmpeg/libavcodec/binkaudio.c
+++ b/mythtv/external/FFmpeg/libavcodec/binkaudio.c
@@ -34,6 +34,7 @@
 #define BITSTREAM_READER_LE
 #include "avcodec.h"
 #include "dct.h"
+#include "decode.h"
 #include "get_bits.h"
 #include "internal.h"
 #include "rdft.h"
@@ -57,7 +58,7 @@ typedef struct BinkAudioContext {
     float root;
     DECLARE_ALIGNED(32, FFTSample, coeffs)[BINK_BLOCK_MAX_SIZE];
     float previous[MAX_CHANNELS][BINK_BLOCK_MAX_SIZE / 16];  ///< coeffs from previous audio block
-    uint8_t *packet_buffer;
+    AVPacket *pkt;
     union {
         RDFTContext rdft;
         DCTContext dct;
@@ -140,6 +141,10 @@ static av_cold int decode_init(AVCodecContext *avctx)
     else
         return -1;
 
+    s->pkt = av_packet_alloc();
+    if (!s->pkt)
+        return AVERROR(ENOMEM);
+
     return 0;
 }
 
@@ -269,12 +274,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
 {
     BinkAudioContext * s = avctx->priv_data;
     av_freep(&s->bands);
-    av_freep(&s->packet_buffer);
     if (CONFIG_BINKAUDIO_RDFT_DECODER && avctx->codec->id == AV_CODEC_ID_BINKAUDIO_RDFT)
         ff_rdft_end(&s->trans.rdft);
     else if (CONFIG_BINKAUDIO_DCT_DECODER)
         ff_dct_end(&s->trans.dct);
 
+    av_packet_free(&s->pkt);
+
     return 0;
 }
 
@@ -284,34 +290,26 @@ static void get_bits_align32(GetBitContext *s)
     if (n) skip_bits(s, n);
 }
 
-static int decode_frame(AVCodecContext *avctx, void *data,
-                        int *got_frame_ptr, AVPacket *avpkt)
+static int binkaudio_receive_frame(AVCodecContext *avctx, AVFrame *frame)
 {
     BinkAudioContext *s = avctx->priv_data;
-    AVFrame *frame      = data;
     GetBitContext *gb = &s->gb;
-    int ret, consumed = 0;
+    int ret;
 
-    if (!get_bits_left(gb)) {
-        uint8_t *buf;
-        /* handle end-of-stream */
-        if (!avpkt->size) {
-            *got_frame_ptr = 0;
-            return 0;
-        }
-        if (avpkt->size < 4) {
+    if (!s->pkt->data) {
+        ret = ff_decode_get_packet(avctx, s->pkt);
+        if (ret < 0)
+            return ret;
+
+        if (s->pkt->size < 4) {
             av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
-            return AVERROR_INVALIDDATA;
+            ret = AVERROR_INVALIDDATA;
+            goto fail;
         }
-        buf = av_realloc(s->packet_buffer, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
-        if (!buf)
-            return AVERROR(ENOMEM);
-        memset(buf + avpkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
-        s->packet_buffer = buf;
-        memcpy(s->packet_buffer, avpkt->data, avpkt->size);
-        if ((ret = init_get_bits8(gb, s->packet_buffer, avpkt->size)) < 0)
-            return ret;
-        consumed = avpkt->size;
+
+        ret = init_get_bits8(gb, s->pkt->data, s->pkt->size);
+        if (ret < 0)
+            goto fail;
 
         /* skip reported size */
         skip_bits_long(gb, 32);
@@ -328,11 +326,17 @@ static int decode_frame(AVCodecContext *avctx, void *data,
         return AVERROR_INVALIDDATA;
     }
     get_bits_align32(gb);
+    if (!get_bits_left(gb)) {
+        memset(gb, 0, sizeof(*gb));
+        av_packet_unref(s->pkt);
+    }
 
     frame->nb_samples = s->block_size / avctx->channels;
-    *got_frame_ptr    = 1;
 
-    return consumed;
+    return 0;
+fail:
+    av_packet_unref(s->pkt);
+    return ret;
 }
 
 AVCodec ff_binkaudio_rdft_decoder = {
@@ -343,7 +347,7 @@ AVCodec ff_binkaudio_rdft_decoder = {
     .priv_data_size = sizeof(BinkAudioContext),
     .init           = decode_init,
     .close          = decode_end,
-    .decode         = decode_frame,
+    .receive_frame  = binkaudio_receive_frame,
     .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
 };
 
@@ -355,6 +359,6 @@ AVCodec ff_binkaudio_dct_decoder = {
     .priv_data_size = sizeof(BinkAudioContext),
     .init           = decode_init,
     .close          = decode_end,
-    .decode         = decode_frame,
+    .receive_frame  = binkaudio_receive_frame,
     .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/binkdsp.h b/mythtv/external/FFmpeg/libavcodec/binkdsp.h
index f319d1ffe52..b089a9863fb 100644
--- a/mythtv/external/FFmpeg/libavcodec/binkdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/binkdsp.h
@@ -29,11 +29,13 @@
 
 #include <stdint.h>
 
+#include "config.h"
+
 typedef struct BinkDSPContext {
     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, int32_t *block/*align 16*/);
     void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, int32_t *block/*align 16*/);
     void (*scale_block)(const uint8_t src[64]/*align 8*/, uint8_t *dst/*align 8*/, int linesize);
-    void (*add_pixels8)(uint8_t *pixels, int16_t *block, int line_size);
+    void (*add_pixels8)(uint8_t *av_restrict pixels, int16_t *block, int line_size);
 } BinkDSPContext;
 
 void ff_binkdsp_init(BinkDSPContext *c);
diff --git a/mythtv/external/FFmpeg/libavcodec/bitpacked.c b/mythtv/external/FFmpeg/libavcodec/bitpacked.c
new file mode 100644
index 00000000000..f0b417d595b
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/bitpacked.c
@@ -0,0 +1,149 @@
+/*
+ * Unpack bit-packed streams to formats supported by FFmpeg
+ * Copyright (c) 2017 Savoir-faire Linux, Inc
+ *
+ * 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
+ */
+
+/* Development sponsored by CBC/Radio-Canada */
+
+/**
+ * @file
+ * Bitpacked
+ */
+
+#include "avcodec.h"
+#include "internal.h"
+#include "get_bits.h"
+#include "libavutil/imgutils.h"
+
+struct BitpackedContext {
+    int (*decode)(AVCodecContext *avctx, AVFrame *frame,
+                  AVPacket *pkt);
+};
+
+/* For this format, it's a simple passthrough */
+static int bitpacked_decode_uyvy422(AVCodecContext *avctx, AVFrame *frame,
+                                    AVPacket *avpkt)
+{
+    int ret;
+
+    /* there is no need to copy as the data already match
+     * a known pixel format */
+    frame->buf[0] = av_buffer_ref(avpkt->buf);
+    ret = av_image_fill_arrays(frame->data, frame->linesize, avpkt->data,
+                               avctx->pix_fmt, avctx->width, avctx->height, 1);
+    if (ret < 0) {
+        av_buffer_unref(&frame->buf[0]);
+        return ret;
+    }
+
+    return 0;
+}
+
+static int bitpacked_decode_yuv422p10(AVCodecContext *avctx, AVFrame *frame,
+                                      AVPacket *avpkt)
+{
+    uint64_t frame_size = (uint64_t)avctx->width * (uint64_t)avctx->height * 20;
+    uint64_t packet_size = (uint64_t)avpkt->size * 8;
+    GetBitContext bc;
+    uint16_t *y, *u, *v;
+    int ret, i, j;
+
+    ret = ff_get_buffer(avctx, frame, 0);
+    if (ret < 0)
+        return ret;
+
+    if (frame_size > packet_size)
+        return AVERROR_INVALIDDATA;
+
+    if (avctx->width % 2)
+        return AVERROR_PATCHWELCOME;
+
+    ret = init_get_bits(&bc, avpkt->data, avctx->width * avctx->height * 20);
+    if (ret)
+        return ret;
+
+    for (i = 0; i < avctx->height; i++) {
+        y = (uint16_t*)(frame->data[0] + i * frame->linesize[0]);
+        u = (uint16_t*)(frame->data[1] + i * frame->linesize[1]);
+        v = (uint16_t*)(frame->data[2] + i * frame->linesize[2]);
+
+        for (j = 0; j < avctx->width; j += 2) {
+            *u++ = get_bits(&bc, 10);
+            *y++ = get_bits(&bc, 10);
+            *v++ = get_bits(&bc, 10);
+            *y++ = get_bits(&bc, 10);
+        }
+    }
+
+    return 0;
+}
+
+static av_cold int bitpacked_init_decoder(AVCodecContext *avctx)
+{
+    struct BitpackedContext *bc = avctx->priv_data;
+
+    if (!avctx->codec_tag || !avctx->width || !avctx->height)
+        return AVERROR_INVALIDDATA;
+
+    if (avctx->codec_tag == MKTAG('U', 'Y', 'V', 'Y')) {
+        if (avctx->bits_per_coded_sample == 16 &&
+            avctx->pix_fmt == AV_PIX_FMT_UYVY422)
+            bc->decode = bitpacked_decode_uyvy422;
+        else if (avctx->bits_per_coded_sample == 20 &&
+                 avctx->pix_fmt == AV_PIX_FMT_YUV422P10)
+            bc->decode = bitpacked_decode_yuv422p10;
+        else
+            return AVERROR_INVALIDDATA;
+    } else {
+        return AVERROR_INVALIDDATA;
+    }
+
+    return 0;
+}
+
+static int bitpacked_decode(AVCodecContext *avctx, void *data, int *got_frame,
+                            AVPacket *avpkt)
+{
+    struct BitpackedContext *bc = avctx->priv_data;
+    int buf_size = avpkt->size;
+    AVFrame *frame = data;
+    int res;
+
+    frame->pict_type = AV_PICTURE_TYPE_I;
+    frame->key_frame = 1;
+
+    res = bc->decode(avctx, frame, avpkt);
+    if (res)
+        return res;
+
+    *got_frame = 1;
+    return buf_size;
+
+}
+
+AVCodec ff_bitpacked_decoder = {
+    .name   = "bitpacked",
+    .long_name = NULL_IF_CONFIG_SMALL("Bitpacked"),
+    .type = AVMEDIA_TYPE_VIDEO,
+    .id = AV_CODEC_ID_BITPACKED,
+    .priv_data_size        = sizeof(struct BitpackedContext),
+    .init = bitpacked_init_decoder,
+    .decode = bitpacked_decode,
+    .capabilities = AV_CODEC_CAP_EXPERIMENTAL,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/bitstream.c b/mythtv/external/FFmpeg/libavcodec/bitstream.c
index 562ca1cb823..ed528fe4af7 100644
--- a/mythtv/external/FFmpeg/libavcodec/bitstream.c
+++ b/mythtv/external/FFmpeg/libavcodec/bitstream.c
@@ -28,7 +28,6 @@
  * bitstream api.
  */
 
-#include "libavutil/atomic.h"
 #include "libavutil/avassert.h"
 #include "libavutil/qsort.h"
 #include "avcodec.h"
@@ -99,9 +98,11 @@ void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
     case 2:                                                 \
         v = *(const uint16_t *)ptr;                         \
         break;                                              \
-    default:                                                \
+    case 4:                                                 \
         v = *(const uint32_t *)ptr;                         \
         break;                                              \
+    default:                                                \
+        av_assert1(0);                                      \
     }                                                       \
 }
 
@@ -126,14 +127,6 @@ static int alloc_table(VLC *vlc, int size, int use_static)
     return index;
 }
 
-static av_always_inline uint32_t bitswap_32(uint32_t x)
-{
-    return (uint32_t)ff_reverse[ x        & 0xFF] << 24 |
-           (uint32_t)ff_reverse[(x >> 8)  & 0xFF] << 16 |
-           (uint32_t)ff_reverse[(x >> 16) & 0xFF] << 8  |
-           (uint32_t)ff_reverse[ x >> 24];
-}
-
 typedef struct VLCcode {
     uint8_t bits;
     uint16_t symbol;
@@ -183,7 +176,7 @@ static int build_table(VLC *vlc, int table_nb_bits, int nb_codes,
         n      = codes[i].bits;
         code   = codes[i].code;
         symbol = codes[i].symbol;
-        ff_dlog(NULL, "i=%d n=%d code=0x%x\n", i, n, code);
+        ff_dlog(NULL, "i=%d n=%d code=0x%"PRIx32"\n", i, n, code);
         if (n <= table_nb_bits) {
             /* no need to add another table */
             j = code >> (32 - table_nb_bits);
@@ -264,7 +257,7 @@ static int build_table(VLC *vlc, int table_nb_bits, int nb_codes,
    'bits' or 'codes' tables.
 
    'xxx_size' : gives the number of bytes of each entry of the 'bits'
-   or 'codes' tables.
+   or 'codes' tables. Currently 1,2 and 4 are supported.
 
    'wrap' and 'size' make it possible to use any memory configuration and types
    (byte/word/long) to store the 'bits', 'codes', and 'symbols' tables.
@@ -317,7 +310,8 @@ int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes,
         }                                                                   \
         GET_DATA(buf[j].code, codes, i, codes_wrap, codes_size);            \
         if (buf[j].code >= (1LL<<buf[j].bits)) {                            \
-            av_log(NULL, AV_LOG_ERROR, "Invalid code %x for %d in init_vlc\n", buf[j].code, i);\
+            av_log(NULL, AV_LOG_ERROR, "Invalid code %"PRIx32" for %d in "  \
+                   "init_vlc\n", buf[j].code, i);                           \
             if (!(flags & INIT_VLC_USE_NEW_STATIC))                         \
                 av_free(buf);                                               \
             return -1;                                                      \
diff --git a/mythtv/external/FFmpeg/libavcodec/bitstream_filter.c b/mythtv/external/FFmpeg/libavcodec/bitstream_filter.c
index 02878e3bf3e..8599b90d4a2 100644
--- a/mythtv/external/FFmpeg/libavcodec/bitstream_filter.c
+++ b/mythtv/external/FFmpeg/libavcodec/bitstream_filter.c
@@ -21,7 +21,6 @@
 #include <string.h>
 
 #include "avcodec.h"
-#include "libavutil/atomic.h"
 #include "libavutil/internal.h"
 #include "libavutil/mem.h"
 #include "libavutil/opt.h"
@@ -123,6 +122,8 @@ int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
                 shorthand[0] = opt->name;
 
             ret = av_opt_set_from_string(priv->ctx->priv_data, bsfc->args, shorthand, "=", ":");
+            if (ret < 0)
+                return ret;
         }
 
         ret = av_bsf_init(priv->ctx);
diff --git a/mythtv/external/FFmpeg/libavcodec/bitstream_filters.c b/mythtv/external/FFmpeg/libavcodec/bitstream_filters.c
index 840bb43e4dd..ce34de640d3 100644
--- a/mythtv/external/FFmpeg/libavcodec/bitstream_filters.c
+++ b/mythtv/external/FFmpeg/libavcodec/bitstream_filters.c
@@ -28,6 +28,7 @@ extern const AVBitStreamFilter ff_aac_adtstoasc_bsf;
 extern const AVBitStreamFilter ff_chomp_bsf;
 extern const AVBitStreamFilter ff_dump_extradata_bsf;
 extern const AVBitStreamFilter ff_dca_core_bsf;
+extern const AVBitStreamFilter ff_extract_extradata_bsf;
 extern const AVBitStreamFilter ff_h264_mp4toannexb_bsf;
 extern const AVBitStreamFilter ff_hevc_mp4toannexb_bsf;
 extern const AVBitStreamFilter ff_imx_dump_header_bsf;
@@ -37,9 +38,12 @@ extern const AVBitStreamFilter ff_mp3_header_decompress_bsf;
 extern const AVBitStreamFilter ff_mpeg4_unpack_bframes_bsf;
 extern const AVBitStreamFilter ff_mov2textsub_bsf;
 extern const AVBitStreamFilter ff_noise_bsf;
+extern const AVBitStreamFilter ff_null_bsf;
 extern const AVBitStreamFilter ff_remove_extradata_bsf;
 extern const AVBitStreamFilter ff_text2movsub_bsf;
+extern const AVBitStreamFilter ff_vp9_raw_reorder_bsf;
 extern const AVBitStreamFilter ff_vp9_superframe_bsf;
+extern const AVBitStreamFilter ff_vp9_superframe_split_bsf;
 
 #include "libavcodec/bsf_list.c"
 
diff --git a/mythtv/external/FFmpeg/libavcodec/blockdsp.c b/mythtv/external/FFmpeg/libavcodec/blockdsp.c
index a5c527a4dac..c7efe7e77b0 100644
--- a/mythtv/external/FFmpeg/libavcodec/blockdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/blockdsp.c
@@ -35,7 +35,8 @@ static void clear_blocks_c(int16_t *blocks)
     memset(blocks, 0, sizeof(int16_t) * 6 * 64);
 }
 
-static void fill_block16_c(uint8_t *block, uint8_t value, int line_size, int h)
+static void fill_block16_c(uint8_t *block, uint8_t value, ptrdiff_t line_size,
+                           int h)
 {
     int i;
 
@@ -45,7 +46,8 @@ static void fill_block16_c(uint8_t *block, uint8_t value, int line_size, int h)
     }
 }
 
-static void fill_block8_c(uint8_t *block, uint8_t value, int line_size, int h)
+static void fill_block8_c(uint8_t *block, uint8_t value, ptrdiff_t line_size,
+                          int h)
 {
     int i;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/blockdsp.h b/mythtv/external/FFmpeg/libavcodec/blockdsp.h
index 95e1d0f32e1..6e27a02ba52 100644
--- a/mythtv/external/FFmpeg/libavcodec/blockdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/blockdsp.h
@@ -19,6 +19,7 @@
 #ifndef AVCODEC_BLOCKDSP_H
 #define AVCODEC_BLOCKDSP_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "avcodec.h"
@@ -29,7 +30,7 @@
  * h for op_pixels_func is limited to { width / 2, width },
  * but never larger than 16 and never smaller than 4. */
 typedef void (*op_fill_func)(uint8_t *block /* align width (8 or 16) */,
-                             uint8_t value, int line_size, int h);
+                             uint8_t value, ptrdiff_t line_size, int h);
 
 typedef struct BlockDSPContext {
     void (*clear_block)(int16_t *block /* align 16 */);
diff --git a/mythtv/external/FFmpeg/libavcodec/bmp.c b/mythtv/external/FFmpeg/libavcodec/bmp.c
index fa1d6a53f25..65d239e4f8d 100644
--- a/mythtv/external/FFmpeg/libavcodec/bmp.c
+++ b/mythtv/external/FFmpeg/libavcodec/bmp.c
@@ -100,7 +100,8 @@ static int bmp_decode_frame(AVCodecContext *avctx,
         height = bytestream_get_le16(&buf);
         break;
     default:
-        av_log(avctx, AV_LOG_ERROR, "unsupported BMP file, patch welcome\n");
+        avpriv_report_missing_feature(avctx, "Information header size %u",
+                                      ihsize);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -132,8 +133,11 @@ static int bmp_decode_frame(AVCodecContext *avctx,
         alpha = bytestream_get_le32(&buf);
     }
 
-    avctx->width  = width;
-    avctx->height = height > 0 ? height : -height;
+    ret = ff_set_dimensions(avctx, width, height > 0 ? height : -(unsigned)height);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to set dimensions %d %d\n", width, height);
+        return AVERROR_INVALIDDATA;
+    }
 
     avctx->pix_fmt = AV_PIX_FMT_NONE;
 
@@ -149,7 +153,8 @@ static int bmp_decode_frame(AVCodecContext *avctx,
             else if (rgb[0] == 0x000000FF && rgb[1] == 0x0000FF00 && rgb[2] == 0x00FF0000)
                 avctx->pix_fmt = alpha ? AV_PIX_FMT_RGBA : AV_PIX_FMT_RGB0;
             else {
-                av_log(avctx, AV_LOG_ERROR, "Unknown bitfields %0X %0X %0X\n", rgb[0], rgb[1], rgb[2]);
+                av_log(avctx, AV_LOG_ERROR, "Unknown bitfields "
+                       "%0"PRIX32" %0"PRIX32" %0"PRIX32"\n", rgb[0], rgb[1], rgb[2]);
                 return AVERROR(EINVAL);
             }
         } else {
diff --git a/mythtv/external/FFmpeg/libavcodec/bmvvideo.c b/mythtv/external/FFmpeg/libavcodec/bmvvideo.c
index 97f850dbae5..679b14208ae 100644
--- a/mythtv/external/FFmpeg/libavcodec/bmvvideo.c
+++ b/mythtv/external/FFmpeg/libavcodec/bmvvideo.c
@@ -107,7 +107,7 @@ static int decode_bmv_frame(const uint8_t *source, int src_len, uint8_t *frame,
                     if (src < source || src >= source_end)
                         return AVERROR_INVALIDDATA;
                     shift += 2;
-                    val |= *src << shift;
+                    val |= (unsigned)*src << shift;
                     if (*src & 0xC)
                         break;
                 }
@@ -193,7 +193,6 @@ static int decode_bmv_frame(const uint8_t *source, int src_len, uint8_t *frame,
         if (dst == dst_end)
             return 0;
     }
-    return 0;
 }
 
 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
@@ -295,4 +294,5 @@ AVCodec ff_bmv_video_decoder = {
     .init           = decode_init,
     .decode         = decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/bsf.c b/mythtv/external/FFmpeg/libavcodec/bsf.c
index dfb127e7eb3..38b423101c3 100644
--- a/mythtv/external/FFmpeg/libavcodec/bsf.c
+++ b/mythtv/external/FFmpeg/libavcodec/bsf.c
@@ -21,7 +21,6 @@
 #include "libavutil/log.h"
 #include "libavutil/mem.h"
 #include "libavutil/opt.h"
-#include "libavutil/avassert.h"
 #include "libavutil/avstring.h"
 #include "libavutil/bprint.h"
 
@@ -175,13 +174,11 @@ int av_bsf_init(AVBSFContext *ctx)
 
 int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
 {
-    if (!pkt) {
+    if (!pkt || (!pkt->data && !pkt->side_data_elems)) {
         ctx->internal->eof = 1;
         return 0;
     }
 
-    av_assert0(pkt->data || pkt->side_data);
-
     if (ctx->internal->eof) {
         av_log(ctx, AV_LOG_ERROR, "A non-NULL packet sent after an EOF.\n");
         return AVERROR(EINVAL);
@@ -403,7 +400,7 @@ void av_bsf_list_free(AVBSFList **lst)
 {
     int i;
 
-    if (*lst)
+    if (!*lst)
         return;
 
     for (i = 0; i < (*lst)->nb_bsfs; ++i)
@@ -514,8 +511,10 @@ int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
     if (!lst)
         return AVERROR(ENOMEM);
 
-    if (!(dup = buf = av_strdup(str)))
-        return AVERROR(ENOMEM);
+    if (!(dup = buf = av_strdup(str))) {
+        ret = AVERROR(ENOMEM);
+        goto end;
+    }
 
     while (1) {
         bsf_str = av_strtok(buf, ",", &saveptr);
diff --git a/mythtv/external/FFmpeg/libavcodec/bytestream.h b/mythtv/external/FFmpeg/libavcodec/bytestream.h
index 7c05ea6cf54..7be7fc22fc8 100644
--- a/mythtv/external/FFmpeg/libavcodec/bytestream.h
+++ b/mythtv/external/FFmpeg/libavcodec/bytestream.h
@@ -94,7 +94,7 @@ DEF(unsigned int, be24, 3, AV_RB24, AV_WB24)
 DEF(unsigned int, be16, 2, AV_RB16, AV_WB16)
 DEF(unsigned int, byte, 1, AV_RB8 , AV_WB8)
 
-#if HAVE_BIGENDIAN
+#if AV_HAVE_BIGENDIAN
 #   define bytestream2_get_ne16  bytestream2_get_be16
 #   define bytestream2_get_ne24  bytestream2_get_be24
 #   define bytestream2_get_ne32  bytestream2_get_be32
diff --git a/mythtv/external/FFmpeg/libavcodec/c93.c b/mythtv/external/FFmpeg/libavcodec/c93.c
index fd026acb8a0..b708659cca9 100644
--- a/mythtv/external/FFmpeg/libavcodec/c93.c
+++ b/mythtv/external/FFmpeg/libavcodec/c93.c
@@ -269,4 +269,5 @@ AVCodec ff_c93_decoder = {
     .close          = decode_end,
     .decode         = decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/cavs.c b/mythtv/external/FFmpeg/libavcodec/cavs.c
index 10e118e55b7..ba2b6ef2329 100644
--- a/mythtv/external/FFmpeg/libavcodec/cavs.c
+++ b/mythtv/external/FFmpeg/libavcodec/cavs.c
@@ -256,7 +256,7 @@ void ff_cavs_load_intra_pred_chroma(AVSContext *h)
     }
 }
 
-static void intra_pred_vert(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
+static void intra_pred_vert(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride)
 {
     int y;
     uint64_t a = AV_RN64(&top[1]);
@@ -264,7 +264,7 @@ static void intra_pred_vert(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
         *((uint64_t *)(d + y * stride)) = a;
 }
 
-static void intra_pred_horiz(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
+static void intra_pred_horiz(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride)
 {
     int y;
     uint64_t a;
@@ -274,7 +274,7 @@ static void intra_pred_horiz(uint8_t *d, uint8_t *top, uint8_t *left, int stride
     }
 }
 
-static void intra_pred_dc_128(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
+static void intra_pred_dc_128(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride)
 {
     int y;
     uint64_t a = 0x8080808080808080ULL;
@@ -282,7 +282,7 @@ static void intra_pred_dc_128(uint8_t *d, uint8_t *top, uint8_t *left, int strid
         *((uint64_t *)(d + y * stride)) = a;
 }
 
-static void intra_pred_plane(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
+static void intra_pred_plane(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride)
 {
     int x, y, ia;
     int ih = 0;
@@ -304,7 +304,7 @@ static void intra_pred_plane(uint8_t *d, uint8_t *top, uint8_t *left, int stride
 #define LOWPASS(ARRAY, INDEX)                                           \
     ((ARRAY[(INDEX) - 1] + 2 * ARRAY[(INDEX)] + ARRAY[(INDEX) + 1] + 2) >> 2)
 
-static void intra_pred_lp(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
+static void intra_pred_lp(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride)
 {
     int x, y;
     for (y = 0; y < 8; y++)
@@ -312,7 +312,7 @@ static void intra_pred_lp(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
             d[y * stride + x] = (LOWPASS(top, x + 1) + LOWPASS(left, y + 1)) >> 1;
 }
 
-static void intra_pred_down_left(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
+static void intra_pred_down_left(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride)
 {
     int x, y;
     for (y = 0; y < 8; y++)
@@ -320,7 +320,7 @@ static void intra_pred_down_left(uint8_t *d, uint8_t *top, uint8_t *left, int st
             d[y * stride + x] = (LOWPASS(top, x + y + 2) + LOWPASS(left, x + y + 2)) >> 1;
 }
 
-static void intra_pred_down_right(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
+static void intra_pred_down_right(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride)
 {
     int x, y;
     for (y = 0; y < 8; y++)
@@ -333,7 +333,7 @@ static void intra_pred_down_right(uint8_t *d, uint8_t *top, uint8_t *left, int s
                 d[y * stride + x] = LOWPASS(left, y - x);
 }
 
-static void intra_pred_lp_left(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
+static void intra_pred_lp_left(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride)
 {
     int x, y;
     for (y = 0; y < 8; y++)
@@ -341,7 +341,7 @@ static void intra_pred_lp_left(uint8_t *d, uint8_t *top, uint8_t *left, int stri
             d[y * stride + x] = LOWPASS(left, y + 1);
 }
 
-static void intra_pred_lp_top(uint8_t *d, uint8_t *top, uint8_t *left, int stride)
+static void intra_pred_lp_top(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride)
 {
     int x, y;
     for (y = 0; y < 8; y++)
@@ -537,8 +537,7 @@ void ff_cavs_inter(AVSContext *h, enum cavs_mb mb_type)
 static inline void scale_mv(AVSContext *h, int *d_x, int *d_y,
                             cavs_vector *src, int distp)
 {
-    int den = h->scale_den[FFMAX(src->ref, 0)];
-
+    int64_t den = h->scale_den[FFMAX(src->ref, 0)];
     *d_x = (src->x * distp * den + 256 + FF_SIGNBIT(src->x)) >> 9;
     *d_y = (src->y * distp * den + 256 + FF_SIGNBIT(src->y)) >> 9;
 }
@@ -613,8 +612,15 @@ void ff_cavs_mv(AVSContext *h, enum cavs_mv_loc nP, enum cavs_mv_loc nC,
         mv_pred_median(h, mvP, mvA, mvB, mvC);
 
     if (mode < MV_PRED_PSKIP) {
-        mvP->x += get_se_golomb(&h->gb);
-        mvP->y += get_se_golomb(&h->gb);
+        int mx = get_se_golomb(&h->gb) + (unsigned)mvP->x;
+        int my = get_se_golomb(&h->gb) + (unsigned)mvP->y;
+
+        if (mx != (int16_t)mx || my != (int16_t)my) {
+            av_log(h->avctx, AV_LOG_ERROR, "MV %d %d out of supported range\n", mx, my);
+        } else {
+            mvP->x = mx;
+            mvP->y = my;
+        }
     }
     set_mvs(mvP, size);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/cavs.h b/mythtv/external/FFmpeg/libavcodec/cavs.h
index fb9df151940..6bfb22ce483 100644
--- a/mythtv/external/FFmpeg/libavcodec/cavs.h
+++ b/mythtv/external/FFmpeg/libavcodec/cavs.h
@@ -227,8 +227,8 @@ typedef struct AVSContext {
     uint8_t intern_border_y[26];
     uint8_t topleft_border_y, topleft_border_u, topleft_border_v;
 
-    void (*intra_pred_l[8])(uint8_t *d,uint8_t *top,uint8_t *left,int stride);
-    void (*intra_pred_c[7])(uint8_t *d,uint8_t *top,uint8_t *left,int stride);
+    void (*intra_pred_l[8])(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride);
+    void (*intra_pred_c[7])(uint8_t *d, uint8_t *top, uint8_t *left, ptrdiff_t stride);
     uint8_t *col_type_base;
 
     /* scaling factors for MV prediction */
diff --git a/mythtv/external/FFmpeg/libavcodec/cavsdec.c b/mythtv/external/FFmpeg/libavcodec/cavsdec.c
index 73a923df309..06c752735ec 100644
--- a/mythtv/external/FFmpeg/libavcodec/cavsdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/cavsdec.c
@@ -465,7 +465,7 @@ static inline void mv_pred_direct(AVSContext *h, cavs_vector *pmv_fw,
                                   cavs_vector *col_mv)
 {
     cavs_vector *pmv_bw = pmv_fw + MV_BWD_OFFS;
-    int den = h->direct_den[col_mv->ref];
+    unsigned den = h->direct_den[col_mv->ref];
     int m = FF_SIGNBIT(col_mv->x);
 
     pmv_fw->dist = h->dist[1];
@@ -545,7 +545,7 @@ static inline int dequant(AVSContext *h, int16_t *level_buf, uint8_t *run_buf,
  */
 static int decode_residual_block(AVSContext *h, GetBitContext *gb,
                                  const struct dec_2dvlc *r, int esc_golomb_order,
-                                 int qp, uint8_t *dst, int stride)
+                                 int qp, uint8_t *dst, ptrdiff_t stride)
 {
     int i, esc_code, level, mask, ret;
     unsigned int level_code, run;
@@ -615,7 +615,7 @@ static inline int decode_residual_inter(AVSContext *h)
 
     /* get quantizer */
     if (h->cbp && !h->qp_fixed)
-        h->qp = (h->qp + get_se_golomb(&h->gb)) & 63;
+        h->qp = (h->qp + (unsigned)get_se_golomb(&h->gb)) & 63;
     for (block = 0; block < 4; block++)
         if (h->cbp & (1 << block))
             decode_residual_block(h, &h->gb, inter_dec, 0, h->qp,
@@ -684,7 +684,7 @@ static int decode_mb_i(AVSContext *h, int cbp_code)
     }
     h->cbp = cbp_tab[cbp_code][0];
     if (h->cbp && !h->qp_fixed)
-        h->qp = (h->qp + get_se_golomb(gb)) & 63; //qp_delta
+        h->qp = (h->qp + (unsigned)get_se_golomb(gb)) & 63; //qp_delta
 
     /* luma intra prediction interleaved with residual decode/transform/add */
     for (block = 0; block < 4; block++) {
@@ -1031,6 +1031,10 @@ static int decode_pic(AVSContext *h)
     h->scale_den[1] = h->dist[1] ? 512/h->dist[1] : 0;
     if (h->cur.f->pict_type == AV_PICTURE_TYPE_B) {
         h->sym_factor = h->dist[0] * h->scale_den[1];
+        if (FFABS(h->sym_factor) > 32768) {
+            av_log(h->avctx, AV_LOG_ERROR, "sym_factor %d too large\n", h->sym_factor);
+            return AVERROR_INVALIDDATA;
+        }
     } else {
         h->direct_den[0] = h->dist[0] ? 16384 / h->dist[0] : 0;
         h->direct_den[1] = h->dist[1] ? 16384 / h->dist[1] : 0;
@@ -1066,10 +1070,14 @@ static int decode_pic(AVSContext *h)
     } else {
         h->alpha_offset = h->beta_offset  = 0;
     }
+
+    ret = 0;
     if (h->cur.f->pict_type == AV_PICTURE_TYPE_I) {
         do {
             check_for_slice(h);
-            decode_mb_i(h, 0);
+            ret = decode_mb_i(h, 0);
+            if (ret < 0)
+                break;
         } while (ff_cavs_next_mb(h));
     } else if (h->cur.f->pict_type == AV_PICTURE_TYPE_P) {
         do {
@@ -1082,10 +1090,12 @@ static int decode_pic(AVSContext *h)
             } else {
                 mb_type = get_ue_golomb(&h->gb) + P_SKIP + h->skip_mode_flag;
                 if (mb_type > P_8X8)
-                    decode_mb_i(h, mb_type - P_8X8 - 1);
+                    ret = decode_mb_i(h, mb_type - P_8X8 - 1);
                 else
                     decode_mb_p(h, mb_type);
             }
+            if (ret < 0)
+                break;
         } while (ff_cavs_next_mb(h));
     } else { /* AV_PICTURE_TYPE_B */
         do {
@@ -1094,23 +1104,25 @@ static int decode_pic(AVSContext *h)
             if (h->skip_mode_flag && (skip_count < 0))
                 skip_count = get_ue_golomb(&h->gb);
             if (h->skip_mode_flag && skip_count--) {
-                decode_mb_b(h, B_SKIP);
+                ret = decode_mb_b(h, B_SKIP);
             } else {
                 mb_type = get_ue_golomb(&h->gb) + B_SKIP + h->skip_mode_flag;
                 if (mb_type > B_8X8)
-                    decode_mb_i(h, mb_type - B_8X8 - 1);
+                    ret = decode_mb_i(h, mb_type - B_8X8 - 1);
                 else
-                    decode_mb_b(h, mb_type);
+                    ret = decode_mb_b(h, mb_type);
             }
+            if (ret < 0)
+                break;
         } while (ff_cavs_next_mb(h));
     }
     emms_c();
-    if (h->cur.f->pict_type != AV_PICTURE_TYPE_B) {
+    if (ret >= 0 && h->cur.f->pict_type != AV_PICTURE_TYPE_B) {
         av_frame_unref(h->DPB[1].f);
         FFSWAP(AVSFrame, h->cur, h->DPB[1]);
         FFSWAP(AVSFrame, h->DPB[0], h->DPB[1]);
     }
-    return 0;
+    return ret;
 }
 
 /*****************************************************************************
diff --git a/mythtv/external/FFmpeg/libavcodec/cavsdsp.c b/mythtv/external/FFmpeg/libavcodec/cavsdsp.c
index df9490ad8f7..90a67e910ce 100644
--- a/mythtv/external/FFmpeg/libavcodec/cavsdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/cavsdsp.c
@@ -42,7 +42,8 @@
 #define Q1 p0_p[ 1*stride]
 #define Q2 p0_p[ 2*stride]
 
-static inline void loop_filter_l2(uint8_t *p0_p,int stride,int alpha, int beta) {
+static inline void loop_filter_l2(uint8_t *p0_p, ptrdiff_t stride, int alpha, int beta)
+{
     int p0 = P0;
     int q0 = Q0;
 
@@ -62,7 +63,8 @@ static inline void loop_filter_l2(uint8_t *p0_p,int stride,int alpha, int beta)
     }
 }
 
-static inline void loop_filter_l1(uint8_t *p0_p, int stride, int alpha, int beta, int tc) {
+static inline void loop_filter_l1(uint8_t *p0_p, ptrdiff_t stride, int alpha, int beta, int tc)
+{
     int p0 = P0;
     int q0 = Q0;
 
@@ -81,7 +83,8 @@ static inline void loop_filter_l1(uint8_t *p0_p, int stride, int alpha, int beta
     }
 }
 
-static inline void loop_filter_c2(uint8_t *p0_p,int stride,int alpha, int beta) {
+static inline void loop_filter_c2(uint8_t *p0_p, ptrdiff_t stride, int alpha, int beta)
+{
     int p0 = P0;
     int q0 = Q0;
 
@@ -99,8 +102,9 @@ static inline void loop_filter_c2(uint8_t *p0_p,int stride,int alpha, int beta)
     }
 }
 
-static inline void loop_filter_c1(uint8_t *p0_p,int stride,int alpha, int beta,
-                                  int tc) {
+static inline void loop_filter_c1(uint8_t *p0_p, ptrdiff_t stride, int alpha, int beta,
+                                  int tc)
+{
     if(abs(P0-Q0)<alpha && abs(P1-P0)<beta && abs(Q1-Q0)<beta) {
         int delta = av_clip(((Q0-P0)*3+P1-Q1+4)>>3, -tc, tc);
         P0 = av_clip_uint8(P0+delta);
@@ -115,8 +119,9 @@ static inline void loop_filter_c1(uint8_t *p0_p,int stride,int alpha, int beta,
 #undef Q1
 #undef Q2
 
-static void cavs_filter_lv_c(uint8_t *d, int stride, int alpha, int beta, int tc,
-                           int bs1, int bs2) {
+static void cavs_filter_lv_c(uint8_t *d, ptrdiff_t stride, int alpha, int beta, int tc,
+                             int bs1, int bs2)
+{
     int i;
     if(bs1==2)
         for(i=0;i<16;i++)
@@ -131,8 +136,9 @@ static void cavs_filter_lv_c(uint8_t *d, int stride, int alpha, int beta, int tc
     }
 }
 
-static void cavs_filter_lh_c(uint8_t *d, int stride, int alpha, int beta, int tc,
-                           int bs1, int bs2) {
+static void cavs_filter_lh_c(uint8_t *d, ptrdiff_t stride, int alpha, int beta, int tc,
+                             int bs1, int bs2)
+{
     int i;
     if(bs1==2)
         for(i=0;i<16;i++)
@@ -147,8 +153,9 @@ static void cavs_filter_lh_c(uint8_t *d, int stride, int alpha, int beta, int tc
     }
 }
 
-static void cavs_filter_cv_c(uint8_t *d, int stride, int alpha, int beta, int tc,
-                           int bs1, int bs2) {
+static void cavs_filter_cv_c(uint8_t *d, ptrdiff_t stride, int alpha, int beta, int tc,
+                             int bs1, int bs2)
+{
     int i;
     if(bs1==2)
         for(i=0;i<8;i++)
@@ -163,8 +170,9 @@ static void cavs_filter_cv_c(uint8_t *d, int stride, int alpha, int beta, int tc
     }
 }
 
-static void cavs_filter_ch_c(uint8_t *d, int stride, int alpha, int beta, int tc,
-                           int bs1, int bs2) {
+static void cavs_filter_ch_c(uint8_t *d, ptrdiff_t stride, int alpha, int beta, int tc,
+                             int bs1, int bs2)
+{
     int i;
     if(bs1==2)
         for(i=0;i<8;i++)
@@ -185,7 +193,8 @@ static void cavs_filter_ch_c(uint8_t *d, int stride, int alpha, int beta, int tc
  *
  ****************************************************************************/
 
-static void cavs_idct8_add_c(uint8_t *dst, int16_t *block, int stride) {
+static void cavs_idct8_add_c(uint8_t *dst, int16_t *block, ptrdiff_t stride)
+{
     int i;
     int16_t (*src)[8] = (int16_t(*)[8])block;
 
@@ -260,7 +269,8 @@ static void cavs_idct8_add_c(uint8_t *dst, int16_t *block, int stride) {
  ****************************************************************************/
 
 #define CAVS_SUBPIX(OPNAME, OP, NAME, A, B, C, D, E, F) \
-static void OPNAME ## cavs_filt8_h_ ## NAME(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_filt8_h_ ## NAME(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     const int h=8;\
     const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;\
     int i;\
@@ -279,7 +289,8 @@ static void OPNAME ## cavs_filt8_h_ ## NAME(uint8_t *dst, const uint8_t *src, in
     }\
 }\
 \
-static void OPNAME ## cavs_filt8_v_  ## NAME(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_filt8_v_  ## NAME(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     const int w=8;\
     const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;\
     int i;\
@@ -311,7 +322,8 @@ static void OPNAME ## cavs_filt8_v_  ## NAME(uint8_t *dst, const uint8_t *src, i
     }\
 }\
 \
-static void OPNAME ## cavs_filt16_v_ ## NAME(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_filt16_v_ ## NAME(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     OPNAME ## cavs_filt8_v_ ## NAME(dst  , src  , dstStride, srcStride);\
     OPNAME ## cavs_filt8_v_ ## NAME(dst+8, src+8, dstStride, srcStride);\
     src += 8*srcStride;\
@@ -320,7 +332,8 @@ static void OPNAME ## cavs_filt16_v_ ## NAME(uint8_t *dst, const uint8_t *src, i
     OPNAME ## cavs_filt8_v_ ## NAME(dst+8, src+8, dstStride, srcStride);\
 }\
 \
-static void OPNAME ## cavs_filt16_h_ ## NAME(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_filt16_h_ ## NAME(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     OPNAME ## cavs_filt8_h_ ## NAME(dst  , src  , dstStride, srcStride);\
     OPNAME ## cavs_filt8_h_ ## NAME(dst+8, src+8, dstStride, srcStride);\
     src += 8*srcStride;\
@@ -330,7 +343,8 @@ static void OPNAME ## cavs_filt16_h_ ## NAME(uint8_t *dst, const uint8_t *src, i
 }\
 
 #define CAVS_SUBPIX_HV(OPNAME, OP, NAME, AH, BH, CH, DH, EH, FH, AV, BV, CV, DV, EV, FV, FULL) \
-static void OPNAME ## cavs_filt8_hv_ ## NAME(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dstStride, int srcStride){\
+static void OPNAME ## cavs_filt8_hv_ ## NAME(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     int16_t temp[8*(8+5)];\
     int16_t *tmp = temp;\
     const int h=8;\
@@ -411,7 +425,8 @@ static void OPNAME ## cavs_filt8_hv_ ## NAME(uint8_t *dst, const uint8_t *src1,
     }\
 }\
 \
-static void OPNAME ## cavs_filt16_hv_ ## NAME(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dstStride, int srcStride){ \
+static void OPNAME ## cavs_filt16_hv_ ## NAME(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     OPNAME ## cavs_filt8_hv_ ## NAME(dst  , src1,   src2  , dstStride, srcStride); \
     OPNAME ## cavs_filt8_hv_ ## NAME(dst+8, src1+8, src2+8, dstStride, srcStride); \
     src1 += 8*srcStride;\
diff --git a/mythtv/external/FFmpeg/libavcodec/cavsdsp.h b/mythtv/external/FFmpeg/libavcodec/cavsdsp.h
index 847f5c4c87d..9ccaa0addd0 100644
--- a/mythtv/external/FFmpeg/libavcodec/cavsdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/cavsdsp.h
@@ -30,11 +30,11 @@
 typedef struct CAVSDSPContext {
     qpel_mc_func put_cavs_qpel_pixels_tab[2][16];
     qpel_mc_func avg_cavs_qpel_pixels_tab[2][16];
-    void (*cavs_filter_lv)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
-    void (*cavs_filter_lh)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
-    void (*cavs_filter_cv)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
-    void (*cavs_filter_ch)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
-    void (*cavs_idct8_add)(uint8_t *dst, int16_t *block, int stride);
+    void (*cavs_filter_lv)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int tc, int bs1, int bs2);
+    void (*cavs_filter_lh)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int tc, int bs1, int bs2);
+    void (*cavs_filter_cv)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int tc, int bs1, int bs2);
+    void (*cavs_filter_ch)(uint8_t *pix, ptrdiff_t stride, int alpha, int beta, int tc, int bs1, int bs2);
+    void (*cavs_idct8_add)(uint8_t *dst, int16_t *block, ptrdiff_t stride);
     int idct_perm;
 } CAVSDSPContext;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/cbrt_data.h b/mythtv/external/FFmpeg/libavcodec/cbrt_data.h
index 232f74fbf37..89117f85b32 100644
--- a/mythtv/external/FFmpeg/libavcodec/cbrt_data.h
+++ b/mythtv/external/FFmpeg/libavcodec/cbrt_data.h
@@ -23,6 +23,8 @@
 
 #include <stdint.h>
 
+#include "config.h"
+
 #if CONFIG_HARDCODED_TABLES
 #define ff_cbrt_tableinit_fixed()
 #define ff_cbrt_tableinit()
diff --git a/mythtv/external/FFmpeg/libavcodec/ccaption_dec.c b/mythtv/external/FFmpeg/libavcodec/ccaption_dec.c
index 33e2130f8e5..09ceb1b3bf1 100644
--- a/mythtv/external/FFmpeg/libavcodec/ccaption_dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ccaption_dec.c
@@ -831,7 +831,7 @@ static const AVClass ccaption_dec_class = {
 
 AVCodec ff_ccaption_decoder = {
     .name           = "cc_dec",
-    .long_name      = NULL_IF_CONFIG_SMALL("Closed Caption (EIA-608 / CEA-708) Decoder"),
+    .long_name      = NULL_IF_CONFIG_SMALL("Closed Caption (EIA-608 / CEA-708)"),
     .type           = AVMEDIA_TYPE_SUBTITLE,
     .id             = AV_CODEC_ID_EIA_608,
     .priv_data_size = sizeof(CCaptionSubContext),
diff --git a/mythtv/external/FFmpeg/libavcodec/cdxl.c b/mythtv/external/FFmpeg/libavcodec/cdxl.c
index c8d66b5845e..78f5d50102f 100644
--- a/mythtv/external/FFmpeg/libavcodec/cdxl.c
+++ b/mythtv/external/FFmpeg/libavcodec/cdxl.c
@@ -275,11 +275,11 @@ static int cdxl_decode_frame(AVCodecContext *avctx, void *data,
     else
         aligned_width = FFALIGN(c->avctx->width, 16);
     c->padded_bits  = aligned_width - c->avctx->width;
-    if (c->video_size < aligned_width * avctx->height * c->bpp / 8)
+    if (c->video_size < aligned_width * avctx->height * (int64_t)c->bpp / 8)
         return AVERROR_INVALIDDATA;
-    if (!encoding && c->palette_size && c->bpp <= 8) {
+    if (!encoding && c->palette_size && c->bpp <= 8 && c->format != CHUNKY) {
         avctx->pix_fmt = AV_PIX_FMT_PAL8;
-    } else if (encoding == 1 && (c->bpp == 6 || c->bpp == 8)) {
+    } else if (encoding == 1 && (c->bpp == 6 || c->bpp == 8) && c->format != CHUNKY) {
         if (c->palette_size != (1 << (c->bpp - 1)))
             return AVERROR_INVALIDDATA;
         avctx->pix_fmt = AV_PIX_FMT_BGR24;
diff --git a/mythtv/external/FFmpeg/libavcodec/celp_filters.c b/mythtv/external/FFmpeg/libavcodec/celp_filters.c
index a81fd8831b9..fafedd99a35 100644
--- a/mythtv/external/FFmpeg/libavcodec/celp_filters.c
+++ b/mythtv/external/FFmpeg/libavcodec/celp_filters.c
@@ -67,7 +67,7 @@ int ff_celp_lp_synthesis_filter(int16_t *out, const int16_t *filter_coeffs,
     for (n = 0; n < buffer_length; n++) {
         int sum = -rounder, sum1;
         for (i = 1; i <= filter_length; i++)
-            sum += filter_coeffs[i-1] * out[n-i];
+            sum += (unsigned)(filter_coeffs[i-1] * out[n-i]);
 
         sum1 = ((-sum >> 12) + in[n]) >> shift;
         sum  = av_clip_int16(sum1);
diff --git a/mythtv/external/FFmpeg/libavcodec/cfhd.c b/mythtv/external/FFmpeg/libavcodec/cfhd.c
index ef97b547ab8..5ea8f24821a 100644
--- a/mythtv/external/FFmpeg/libavcodec/cfhd.c
+++ b/mythtv/external/FFmpeg/libavcodec/cfhd.c
@@ -258,6 +258,11 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
             s->coded_height = data;
         } else if (tag == 101) {
             av_log(avctx, AV_LOG_DEBUG, "Bits per component: %"PRIu16"\n", data);
+            if (data < 1 || data > 31) {
+                av_log(avctx, AV_LOG_ERROR, "Bits per component %d is invalid\n", data);
+                ret = AVERROR(EINVAL);
+                break;
+            }
             s->bpc = data;
         } else if (tag == 12) {
             av_log(avctx, AV_LOG_DEBUG, "Channel Count: %"PRIu16"\n", data);
@@ -317,22 +322,22 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
             s->prescale_shift[2] = (data >> 6) & 0x7;
             av_log(avctx, AV_LOG_DEBUG, "Prescale shift (VC-5): %x\n", data);
         } else if (tag == 27) {
-            s->plane[s->channel_num].band[0][0].width  = data;
-            s->plane[s->channel_num].band[0][0].stride = data;
             av_log(avctx, AV_LOG_DEBUG, "Lowpass width %"PRIu16"\n", data);
             if (data < 3 || data > s->plane[s->channel_num].band[0][0].a_width) {
                 av_log(avctx, AV_LOG_ERROR, "Invalid lowpass width\n");
                 ret = AVERROR(EINVAL);
                 break;
             }
+            s->plane[s->channel_num].band[0][0].width  = data;
+            s->plane[s->channel_num].band[0][0].stride = data;
         } else if (tag == 28) {
-            s->plane[s->channel_num].band[0][0].height = data;
             av_log(avctx, AV_LOG_DEBUG, "Lowpass height %"PRIu16"\n", data);
-            if (data < 3 || data > s->plane[s->channel_num].band[0][0].height) {
+            if (data < 3 || data > s->plane[s->channel_num].band[0][0].a_height) {
                 av_log(avctx, AV_LOG_ERROR, "Invalid lowpass height\n");
                 ret = AVERROR(EINVAL);
                 break;
             }
+            s->plane[s->channel_num].band[0][0].height = data;
         } else if (tag == 1)
             av_log(avctx, AV_LOG_DEBUG, "Sample type? %"PRIu16"\n", data);
         else if (tag == 10) {
@@ -363,39 +368,39 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
                 av_log(avctx, AV_LOG_DEBUG, "Tag/Value = %x %x\n", tag2, val2);
             }
         } else if (tag == 41) {
-            s->plane[s->channel_num].band[s->level][s->subband_num].width  = data;
-            s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);
             av_log(avctx, AV_LOG_DEBUG, "Highpass width %i channel %i level %i subband %i\n", data, s->channel_num, s->level, s->subband_num);
             if (data < 3) {
                 av_log(avctx, AV_LOG_ERROR, "Invalid highpass width\n");
                 ret = AVERROR(EINVAL);
                 break;
             }
+            s->plane[s->channel_num].band[s->level][s->subband_num].width  = data;
+            s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);
         } else if (tag == 42) {
-            s->plane[s->channel_num].band[s->level][s->subband_num].height = data;
             av_log(avctx, AV_LOG_DEBUG, "Highpass height %i\n", data);
             if (data < 3) {
                 av_log(avctx, AV_LOG_ERROR, "Invalid highpass height\n");
                 ret = AVERROR(EINVAL);
                 break;
             }
+            s->plane[s->channel_num].band[s->level][s->subband_num].height = data;
         } else if (tag == 49) {
-            s->plane[s->channel_num].band[s->level][s->subband_num].width  = data;
-            s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);
             av_log(avctx, AV_LOG_DEBUG, "Highpass width2 %i\n", data);
             if (data < 3) {
                 av_log(avctx, AV_LOG_ERROR, "Invalid highpass width2\n");
                 ret = AVERROR(EINVAL);
                 break;
             }
+            s->plane[s->channel_num].band[s->level][s->subband_num].width  = data;
+            s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);
         } else if (tag == 50) {
-            s->plane[s->channel_num].band[s->level][s->subband_num].height = data;
             av_log(avctx, AV_LOG_DEBUG, "Highpass height2 %i\n", data);
             if (data < 3) {
                 av_log(avctx, AV_LOG_ERROR, "Invalid highpass height2\n");
                 ret = AVERROR(EINVAL);
                 break;
             }
+            s->plane[s->channel_num].band[s->level][s->subband_num].height = data;
         } else if (tag == 71) {
             s->codebook = data;
             av_log(avctx, AV_LOG_DEBUG, "Codebook %i\n", s->codebook);
@@ -404,12 +409,12 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
             av_log(avctx, AV_LOG_DEBUG, "Other codebook? %i\n", s->codebook);
         } else if (tag == 70) {
             av_log(avctx, AV_LOG_DEBUG, "Subsampling or bit-depth flag? %i\n", data);
-            s->bpc = data;
-            if (!(s->bpc == 10 || s->bpc == 12)) {
+            if (!(data == 10 || data == 12)) {
                 av_log(avctx, AV_LOG_ERROR, "Invalid bits per channel\n");
                 ret = AVERROR(EINVAL);
                 break;
             }
+            s->bpc = data;
         } else if (tag == 84) {
             av_log(avctx, AV_LOG_DEBUG, "Sample format? %i\n", data);
             if (data == 1)
@@ -501,7 +506,7 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
             int highpass_a_width = s->plane[s->channel_num].band[s->level][s->subband_num].a_width;
             int highpass_a_height = s->plane[s->channel_num].band[s->level][s->subband_num].a_height;
             int highpass_stride = s->plane[s->channel_num].band[s->level][s->subband_num].stride;
-            int expected = highpass_height * highpass_stride;
+            int expected;
             int a_expected = highpass_a_height * highpass_a_width;
             int level, run, coeff;
             int count = 0, bytes;
@@ -512,11 +517,12 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
                 goto end;
             }
 
-            if (highpass_height > highpass_a_height || highpass_width > highpass_a_width || a_expected < expected) {
+            if (highpass_height > highpass_a_height || highpass_width > highpass_a_width || a_expected < highpass_height * (uint64_t)highpass_stride) {
                 av_log(avctx, AV_LOG_ERROR, "Too many highpass coefficients\n");
                 ret = AVERROR(EINVAL);
                 goto end;
             }
+            expected = highpass_height * highpass_stride;
 
             av_log(avctx, AV_LOG_DEBUG, "Start subband coeffs plane %i level %i codebook %i expected %i\n", s->channel_num, s->level, s->codebook, expected);
 
@@ -657,7 +663,7 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
             output = s->plane[plane].subband[0];
             for (i = 0; i < lowpass_height * 2; i++) {
                 for (j = 0; j < lowpass_width * 2; j++)
-                    output[j] <<= 2;
+                    output[j] *= 4;
 
                 output += lowpass_width * 2;
             }
@@ -710,7 +716,7 @@ static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
         output = s->plane[plane].subband[0];
         for (i = 0; i < lowpass_height * 2; i++) {
             for (j = 0; j < lowpass_width * 2; j++)
-                output[j] <<= 2;
+                output[j] *= 4;
 
             output += lowpass_width * 2;
         }
diff --git a/mythtv/external/FFmpeg/libavcodec/cinepak.c b/mythtv/external/FFmpeg/libavcodec/cinepak.c
index a2190d7598f..89e940ae0df 100644
--- a/mythtv/external/FFmpeg/libavcodec/cinepak.c
+++ b/mythtv/external/FFmpeg/libavcodec/cinepak.c
@@ -155,8 +155,8 @@ static int cinepak_decode_vectors (CinepakContext *s, cvid_strip *strip,
                 }
             }
         }
-/* to get the correct picture for not-multiple-of-4 cases let us fill
- * each block from the bottom up, thus possibly overwriting the top line
+/* to get the correct picture for not-multiple-of-4 cases let us fill each
+ * block from the bottom up, thus possibly overwriting the bottommost line
  * more than once but ending with the correct data in place
  * (instead of in-loop checking) */
 
@@ -322,9 +322,6 @@ static int cinepak_decode (CinepakContext *s)
     int           y0 = 0;
     int           encoded_buf_size;
 
-    if (s->size < 10)
-        return AVERROR_INVALIDDATA;
-
     frame_flags = s->data[0];
     num_strips  = AV_RB16 (&s->data[8]);
     encoded_buf_size = AV_RB24(&s->data[1]);
@@ -439,14 +436,20 @@ static int cinepak_decode_frame(AVCodecContext *avctx,
     s->data = buf;
     s->size = buf_size;
 
+    if (s->size < 10)
+        return AVERROR_INVALIDDATA;
+
     if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
         return ret;
 
     if (s->palette_video) {
-        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
-        if (pal) {
+        int size;
+        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
+        if (pal && size == AVPALETTE_SIZE) {
             s->frame->palette_has_changed = 1;
             memcpy(s->pal, pal, AVPALETTE_SIZE);
+        } else if (pal) {
+            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
         }
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/cinepakenc.c b/mythtv/external/FFmpeg/libavcodec/cinepakenc.c
index 06b06da95fa..a28f6690708 100644
--- a/mythtv/external/FFmpeg/libavcodec/cinepakenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/cinepakenc.c
@@ -1,5 +1,5 @@
 /*
- * Cinepak encoder (c) 2011 Tomas H�rdin
+ * Cinepak encoder (c) 2011 Tomas Härdin
  * http://titan.codemill.se/~tomhar/cinepakenc.patch
  *
  * Fixes and improvements, vintage decoders compatibility
@@ -23,9 +23,6 @@ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 
- * TODO:
- * - optimize: color space conversion, ...
- * - implement options to set the min/max number of strips?
  * MAYBE:
  * - "optimally" split the frame into several non-regular areas
  *   using a separate codebook pair for each area and approximating
@@ -92,7 +89,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #define MAX_STRIPS  32      //Note: having fewer choices regarding the number of strips speeds up encoding (obviously)
 #define MIN_STRIPS  1       //Note: having more strips speeds up encoding the frame (this is less obvious)
 // MAX_STRIPS limits the maximum quality you can reach
-//            when you want hight quality on high resolutions,
+//            when you want high quality on high resolutions,
 // MIN_STRIPS limits the minimum efficiently encodable bit rate
 //            on low resolutions
 // the numbers are only used for brute force optimization for the first frame,
@@ -119,7 +116,7 @@ typedef enum {
 typedef struct {
     int v1_vector;                  //index into v1 codebook
     int v1_error;                   //error when using V1 encoding
-    int v4_vector[4];               //indices into v4 codebooks
+    int v4_vector[4];               //indices into v4 codebook
     int v4_error;                   //error when using V4 encoding
     int skip_error;                 //error when block is skipped (aka copied from last frame)
     mb_encoding best_encoding;      //last result from calculate_mode_score()
@@ -1385,6 +1382,6 @@ AVCodec ff_cinepak_encoder = {
     .encode2        = cinepak_encode_frame,
     .close          = cinepak_encode_end,
     .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_RGB24, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE},
-    .long_name      = NULL_IF_CONFIG_SMALL("Cinepak / CVID"),
+    .long_name      = NULL_IF_CONFIG_SMALL("Cinepak"),
     .priv_class     = &cinepak_class,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/clearvideo.c b/mythtv/external/FFmpeg/libavcodec/clearvideo.c
new file mode 100644
index 00000000000..067942a1316
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/clearvideo.c
@@ -0,0 +1,396 @@
+/*
+ * ClearVideo decoder
+ * Copyright (c) 2012 Konstantin Shishkov
+ *
+ * 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
+ * ClearVideo decoder
+ */
+
+#include "avcodec.h"
+#include "idctdsp.h"
+#include "internal.h"
+#include "get_bits.h"
+#include "bytestream.h"
+
+#define NUM_DC_CODES 127
+#define NUM_AC_CODES 103
+
+static const uint8_t clv_dc_codes[NUM_DC_CODES] = {
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+    0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+    0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x07, 0x0B,
+    0x0C, 0x08, 0x08, 0x09, 0x04, 0x06, 0x07, 0x05,
+    0x04, 0x05, 0x04, 0x06, 0x05, 0x06, 0x07, 0x05,
+    0x06, 0x07, 0x06, 0x07, 0x08, 0x06, 0x07, 0x08,
+    0x09, 0x0A, 0x0B, 0x07, 0x08, 0x09, 0x07, 0x08,
+    0x06, 0x07, 0x08, 0x06, 0x04, 0x05, 0x02, 0x01,
+    0x03, 0x06, 0x07, 0x07, 0x09, 0x0A, 0x0B, 0x09,
+    0x0A, 0x0B, 0x0A, 0x0B, 0x0C, 0x0D, 0x0C, 0x09,
+    0x0D, 0x0A, 0x0B, 0x08, 0x09, 0x0A, 0x0B, 0x07,
+    0x08, 0x09, 0x0A, 0x0B, 0x06, 0x07, 0x06, 0x08,
+    0x07, 0x09, 0x0A, 0x0B, 0x09, 0x0A, 0x0B, 0x0C,
+    0x14, 0x0D, 0x0D, 0x0E, 0x0F, 0x15, 0x15, 0x16,
+    0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
+    0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
+};
+
+static const uint8_t clv_dc_bits[NUM_DC_CODES] = {
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 21, 22, 22, 19, 20,
+    20, 19, 18, 18, 15, 17, 17, 16,
+    14, 15, 12, 13, 14, 14, 14, 12,
+    12, 12, 11, 11, 11, 10, 10, 10,
+    10, 10, 10,  9,  9,  9,  8,  8,
+     7,  7,  7,  6,  5,  5,  3,  1,
+     3,  5,  5,  6,  7,  7,  7,  8,
+     8,  8,  9,  9,  9,  9, 10, 11,
+    10, 11, 11, 12, 12, 12, 12, 13,
+    14, 14, 14, 14, 15, 15, 16, 17,
+    16, 17, 18, 18, 19, 19, 19, 19,
+    21, 19, 20, 19, 19, 21, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22,
+};
+
+static const uint16_t clv_ac_syms[NUM_AC_CODES] = {
+    0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
+    0x0009, 0x000A, 0x000B, 0x000C, 0x0011, 0x0012, 0x0013, 0x0014,
+    0x0015, 0x0016, 0x0021, 0x0022, 0x0023, 0x0024, 0x0031, 0x0032,
+    0x0033, 0x0041, 0x0042, 0x0043, 0x0051, 0x0052, 0x0053, 0x0061,
+    0x0062, 0x0063, 0x0071, 0x0072, 0x0081, 0x0082, 0x0091, 0x0092,
+    0x00A1, 0x00A2, 0x00B1, 0x00C1, 0x00D1, 0x00E1, 0x00F1, 0x0101,
+    0x0111, 0x0121, 0x0131, 0x0141, 0x0151, 0x0161, 0x0171, 0x0181,
+    0x0191, 0x01A1, 0x1001, 0x1002, 0x1003, 0x1011, 0x1012, 0x1021,
+    0x1031, 0x1041, 0x1051, 0x1061, 0x1071, 0x1081, 0x1091, 0x10A1,
+    0x10B1, 0x10C1, 0x10D1, 0x10E1, 0x10F1, 0x1101, 0x1111, 0x1121,
+    0x1131, 0x1141, 0x1151, 0x1161, 0x1171, 0x1181, 0x1191, 0x11A1,
+    0x11B1, 0x11C1, 0x11D1, 0x11E1, 0x11F1, 0x1201, 0x1211, 0x1221,
+    0x1231, 0x1241, 0x1251, 0x1261, 0x1271, 0x1281, 0x1BFF,
+};
+
+static const uint8_t clv_ac_codes[NUM_AC_CODES] = {
+    0x02, 0x0F, 0x15, 0x17, 0x1F, 0x25, 0x24, 0x21,
+    0x20, 0x07, 0x06, 0x20, 0x06, 0x14, 0x1E, 0x0F,
+    0x21, 0x50, 0x0E, 0x1D, 0x0E, 0x51, 0x0D, 0x23,
+    0x0D, 0x0C, 0x22, 0x52, 0x0B, 0x0C, 0x53, 0x13,
+    0x0B, 0x54, 0x12, 0x0A, 0x11, 0x09, 0x10, 0x08,
+    0x16, 0x55, 0x15, 0x14, 0x1C, 0x1B, 0x21, 0x20,
+    0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x22, 0x23,
+    0x56, 0x57, 0x07, 0x19, 0x05, 0x0F, 0x04, 0x0E,
+    0x0D, 0x0C, 0x13, 0x12, 0x11, 0x10, 0x1A, 0x19,
+    0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x18, 0x17,
+    0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x07, 0x06,
+    0x05, 0x04, 0x24, 0x25, 0x26, 0x27, 0x58, 0x59,
+    0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x03,
+};
+
+static const uint8_t clv_ac_bits[NUM_AC_CODES] = {
+     2,  4,  6,  7,  8,  9,  9, 10,
+    10, 11, 11, 11,  3,  6,  8, 10,
+    11, 12,  4,  8, 10, 12,  5,  9,
+    10,  5,  9, 12,  5, 10, 12,  6,
+    10, 12,  6, 10,  6, 10,  6, 10,
+     7, 12,  7,  7,  8,  8,  9,  9,
+     9,  9,  9,  9,  9,  9, 11, 11,
+    12, 12,  4,  9, 11,  6, 11,  6,
+     6,  6,  7,  7,  7,  7,  8,  8,
+     8,  8,  8,  8,  8,  8,  9,  9,
+     9,  9,  9,  9,  9,  9, 10, 10,
+    10, 10, 11, 11, 11, 11, 12, 12,
+    12, 12, 12, 12, 12, 12,  7,
+};
+
+typedef struct CLVContext {
+    AVCodecContext *avctx;
+    IDCTDSPContext idsp;
+    AVFrame        *pic;
+    GetBitContext  gb;
+    int            mb_width, mb_height;
+    VLC            dc_vlc, ac_vlc;
+    int            luma_dc_quant, chroma_dc_quant, ac_quant;
+    DECLARE_ALIGNED(16, int16_t, block)[64];
+    int            top_dc[3], left_dc[4];
+} CLVContext;
+
+static inline int decode_block(CLVContext *ctx, int16_t *blk, int has_ac,
+                               int ac_quant)
+{
+    GetBitContext *gb = &ctx->gb;
+    int idx = 1, last = 0, val, skip;
+
+    memset(blk, 0, sizeof(*blk) * 64);
+    blk[0] = get_vlc2(gb, ctx->dc_vlc.table, 9, 3);
+    if (blk[0] < 0)
+        return AVERROR_INVALIDDATA;
+    blk[0] -= 63;
+
+    if (!has_ac)
+        return 0;
+
+    while (idx < 64 && !last) {
+        val = get_vlc2(gb, ctx->ac_vlc.table, 9, 2);
+        if (val < 0)
+            return AVERROR_INVALIDDATA;
+        if (val != 0x1BFF) {
+            last =  val >> 12;
+            skip = (val >> 4) & 0xFF;
+            val &= 0xF;
+            if (get_bits1(gb))
+                val = -val;
+        } else {
+            last = get_bits1(gb);
+            skip = get_bits(gb, 6);
+            val  = get_sbits(gb, 8);
+        }
+        if (val) {
+            int aval = FFABS(val), sign = val < 0;
+            val = ac_quant * (2 * aval + 1);
+            if (!(ac_quant & 1))
+                val--;
+            if (sign)
+                val = -val;
+        }
+        idx += skip;
+        if (idx >= 64)
+            return AVERROR_INVALIDDATA;
+        blk[ff_zigzag_direct[idx++]] = val;
+    }
+
+    return (idx <= 64 && last) ? 0 : -1;
+}
+
+#define DCT_TEMPLATE(blk, step, bias, shift, dshift, OP)                \
+    const int t0 = OP( 2841 * blk[1 * step] +  565 * blk[7 * step]);    \
+    const int t1 = OP(  565 * blk[1 * step] - 2841 * blk[7 * step]);    \
+    const int t2 = OP( 1609 * blk[5 * step] + 2408 * blk[3 * step]);    \
+    const int t3 = OP( 2408 * blk[5 * step] - 1609 * blk[3 * step]);    \
+    const int t4 = OP( 1108 * blk[2 * step] - 2676 * blk[6 * step]);    \
+    const int t5 = OP( 2676 * blk[2 * step] + 1108 * blk[6 * step]);    \
+    const int t6 = ((blk[0 * step] + blk[4 * step]) * (1 << dshift)) + bias;  \
+    const int t7 = ((blk[0 * step] - blk[4 * step]) * (1 << dshift)) + bias;  \
+    const int t8 = t0 + t2;                                             \
+    const int t9 = t0 - t2;                                             \
+    const int tA = (int)(181U * (t9 + (t1 - t3)) + 0x80) >> 8;          \
+    const int tB = (int)(181U * (t9 - (t1 - t3)) + 0x80) >> 8;          \
+    const int tC = t1 + t3;                                             \
+                                                                        \
+    blk[0 * step] = (t6 + t5 + t8) >> shift;                            \
+    blk[1 * step] = (t7 + t4 + tA) >> shift;                            \
+    blk[2 * step] = (t7 - t4 + tB) >> shift;                            \
+    blk[3 * step] = (t6 - t5 + tC) >> shift;                            \
+    blk[4 * step] = (t6 - t5 - tC) >> shift;                            \
+    blk[5 * step] = (t7 - t4 - tB) >> shift;                            \
+    blk[6 * step] = (t7 + t4 - tA) >> shift;                            \
+    blk[7 * step] = (t6 + t5 - t8) >> shift;                            \
+
+#define ROP(x) x
+#define COP(x) (((x) + 4) >> 3)
+
+static void clv_dct(int16_t *block)
+{
+    int i;
+    int16_t *ptr;
+
+    ptr = block;
+    for (i = 0; i < 8; i++) {
+        DCT_TEMPLATE(ptr, 1, 0x80, 8, 11, ROP);
+        ptr += 8;
+    }
+
+    ptr = block;
+    for (i = 0; i < 8; i++) {
+        DCT_TEMPLATE(ptr, 8, 0x2000, 14, 8, COP);
+        ptr++;
+    }
+}
+
+static int decode_mb(CLVContext *c, int x, int y)
+{
+    int i;
+    int has_ac[6];
+    int off;
+
+    for (i = 0; i < 6; i++)
+        has_ac[i] = get_bits1(&c->gb);
+
+    off = x * 16 + y * 16 * c->pic->linesize[0];
+    for (i = 0; i < 4; i++) {
+        if (decode_block(c, c->block, has_ac[i], c->ac_quant) < 0)
+            return AVERROR_INVALIDDATA;
+        if (!x && !(i & 1)) {
+            c->block[0] += c->top_dc[0];
+            c->top_dc[0] = c->block[0];
+        } else {
+            c->block[0] += c->left_dc[(i & 2) >> 1];
+        }
+        c->left_dc[(i & 2) >> 1] = c->block[0];
+        c->block[0]             *= c->luma_dc_quant;
+        clv_dct(c->block);
+        if (i == 2)
+            off += c->pic->linesize[0] * 8;
+        c->idsp.put_pixels_clamped(c->block, c->pic->data[0] + off + (i & 1) * 8,
+                                   c->pic->linesize[0]);
+    }
+
+    off = x * 8 + y * 8 * c->pic->linesize[1];
+    for (i = 1; i < 3; i++) {
+        if (decode_block(c, c->block, has_ac[i + 3], c->ac_quant) < 0)
+            return AVERROR_INVALIDDATA;
+        if (!x) {
+            c->block[0] += c->top_dc[i];
+            c->top_dc[i] = c->block[0];
+        } else {
+            c->block[0] += c->left_dc[i + 1];
+        }
+        c->left_dc[i + 1] = c->block[0];
+        c->block[0]      *= c->chroma_dc_quant;
+        clv_dct(c->block);
+        c->idsp.put_pixels_clamped(c->block, c->pic->data[i] + off,
+                                   c->pic->linesize[i]);
+    }
+
+    return 0;
+}
+
+static int clv_decode_frame(AVCodecContext *avctx, void *data,
+                            int *got_frame, AVPacket *avpkt)
+{
+    const uint8_t *buf = avpkt->data;
+    int buf_size = avpkt->size;
+    CLVContext *c = avctx->priv_data;
+    GetByteContext gb;
+    uint32_t frame_type;
+    int i, j;
+    int ret;
+    int mb_ret = 0;
+
+    bytestream2_init(&gb, buf, buf_size);
+    if (avctx->codec_tag == MKTAG('C','L','V','1')) {
+        int skip = bytestream2_get_byte(&gb);
+        bytestream2_skip(&gb, (skip + 1) * 8);
+    }
+
+    frame_type = bytestream2_get_byte(&gb);
+
+    if (frame_type & 0x2) {
+        if (buf_size < c->mb_width * c->mb_height) {
+            av_log(avctx, AV_LOG_ERROR, "Packet too small\n");
+            return AVERROR_INVALIDDATA;
+        }
+
+        if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
+            return ret;
+
+        c->pic->key_frame = frame_type & 0x20 ? 1 : 0;
+        c->pic->pict_type = frame_type & 0x20 ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
+
+        bytestream2_get_be32(&gb); // frame size;
+        c->ac_quant        = bytestream2_get_byte(&gb);
+        c->luma_dc_quant   = 32;
+        c->chroma_dc_quant = 32;
+
+        if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
+                                  (buf_size - bytestream2_tell(&gb)))) < 0)
+            return ret;
+
+        for (i = 0; i < 3; i++)
+            c->top_dc[i] = 32;
+        for (i = 0; i < 4; i++)
+            c->left_dc[i] = 32;
+
+        for (j = 0; j < c->mb_height; j++) {
+            for (i = 0; i < c->mb_width; i++) {
+                ret = decode_mb(c, i, j);
+                if (ret < 0)
+                    mb_ret = ret;
+            }
+        }
+
+        if ((ret = av_frame_ref(data, c->pic)) < 0)
+            return ret;
+
+        *got_frame = 1;
+    } else {
+    }
+
+    return mb_ret < 0 ? mb_ret : buf_size;
+}
+
+static av_cold int clv_decode_init(AVCodecContext *avctx)
+{
+    CLVContext * const c = avctx->priv_data;
+    int ret;
+
+    c->avctx = avctx;
+
+    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
+
+    c->pic = av_frame_alloc();
+    if (!c->pic)
+        return AVERROR(ENOMEM);
+
+    c->mb_width  = FFALIGN(avctx->width,  16) >> 4;
+    c->mb_height = FFALIGN(avctx->height, 16) >> 4;
+
+    ff_idctdsp_init(&c->idsp, avctx);
+    ret = init_vlc(&c->dc_vlc, 9, NUM_DC_CODES,
+                   clv_dc_bits,  1, 1,
+                   clv_dc_codes, 1, 1, 0);
+    if (ret) {
+        av_log(avctx, AV_LOG_ERROR, "Error initialising DC VLC\n");
+        return ret;
+    }
+    ret = ff_init_vlc_sparse(&c->ac_vlc, 9, NUM_AC_CODES,
+                             clv_ac_bits,  1, 1,
+                             clv_ac_codes, 1, 1,
+                             clv_ac_syms,  2, 2, 0);
+    if (ret) {
+        av_log(avctx, AV_LOG_ERROR, "Error initialising AC VLC\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+static av_cold int clv_decode_end(AVCodecContext *avctx)
+{
+    CLVContext * const c = avctx->priv_data;
+
+    av_frame_free(&c->pic);
+
+    ff_free_vlc(&c->dc_vlc);
+    ff_free_vlc(&c->ac_vlc);
+
+    return 0;
+}
+
+AVCodec ff_clearvideo_decoder = {
+    .name           = "clearvideo",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_CLEARVIDEO,
+    .priv_data_size = sizeof(CLVContext),
+    .init           = clv_decode_init,
+    .close          = clv_decode_end,
+    .decode         = clv_decode_frame,
+    .capabilities   = AV_CODEC_CAP_DR1,
+    .long_name      = NULL_IF_CONFIG_SMALL("Iterated Systems ClearVideo"),
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/cllc.c b/mythtv/external/FFmpeg/libavcodec/cllc.c
index 1c6902afd43..af0f6da2e99 100644
--- a/mythtv/external/FFmpeg/libavcodec/cllc.c
+++ b/mythtv/external/FFmpeg/libavcodec/cllc.c
@@ -28,6 +28,11 @@
 #include "get_bits.h"
 #include "avcodec.h"
 #include "internal.h"
+#include "thread.h"
+
+#define VLC_BITS 7
+#define VLC_DEPTH 2
+
 
 typedef struct CLLCContext {
     AVCodecContext *avctx;
@@ -51,6 +56,13 @@ static int read_code_table(CLLCContext *ctx, GetBitContext *gb, VLC *vlc)
 
     num_lens = get_bits(gb, 5);
 
+    if (num_lens > VLC_BITS * VLC_DEPTH) {
+        vlc->table = NULL;
+
+        av_log(ctx->avctx, AV_LOG_ERROR, "To long VLCs %d\n", num_lens);
+        return AVERROR_INVALIDDATA;
+    }
+
     for (i = 0; i < num_lens; i++) {
         num_codes      = get_bits(gb, 9);
         num_codes_sum += num_codes;
@@ -70,11 +82,15 @@ static int read_code_table(CLLCContext *ctx, GetBitContext *gb, VLC *vlc)
 
             count++;
         }
+        if (prefix > (65535 - 256)/2) {
+            vlc->table = NULL;
+            return AVERROR_INVALIDDATA;
+        }
 
         prefix <<= 1;
     }
 
-    return ff_init_vlc_sparse(vlc, 7, count, bits, 1, 1,
+    return ff_init_vlc_sparse(vlc, VLC_BITS, count, bits, 1, 1,
                               codes, 2, 2, symbols, 1, 1, 0);
 }
 
@@ -101,7 +117,7 @@ static int read_argb_line(CLLCContext *ctx, GetBitContext *gb, int *top_left,
     for (i = 0; i < ctx->avctx->width; i++) {
         /* Always get the alpha component */
         UPDATE_CACHE(bits, gb);
-        GET_VLC(code, bits, gb, vlc[0].table, 7, 2);
+        GET_VLC(code, bits, gb, vlc[0].table, VLC_BITS, VLC_DEPTH);
 
         pred[0] += code;
         dst[0]   = pred[0];
@@ -110,21 +126,21 @@ static int read_argb_line(CLLCContext *ctx, GetBitContext *gb, int *top_left,
         if (dst[0]) {
             /* Red */
             UPDATE_CACHE(bits, gb);
-            GET_VLC(code, bits, gb, vlc[1].table, 7, 2);
+            GET_VLC(code, bits, gb, vlc[1].table, VLC_BITS, VLC_DEPTH);
 
             pred[1] += code;
             dst[1]   = pred[1];
 
             /* Green */
             UPDATE_CACHE(bits, gb);
-            GET_VLC(code, bits, gb, vlc[2].table, 7, 2);
+            GET_VLC(code, bits, gb, vlc[2].table, VLC_BITS, VLC_DEPTH);
 
             pred[2] += code;
             dst[2]   = pred[2];
 
             /* Blue */
             UPDATE_CACHE(bits, gb);
-            GET_VLC(code, bits, gb, vlc[3].table, 7, 2);
+            GET_VLC(code, bits, gb, vlc[3].table, VLC_BITS, VLC_DEPTH);
 
             pred[3] += code;
             dst[3]   = pred[3];
@@ -166,7 +182,7 @@ static int read_rgb24_component_line(CLLCContext *ctx, GetBitContext *gb,
     /* Simultaneously read and restore the line */
     for (i = 0; i < ctx->avctx->width; i++) {
         UPDATE_CACHE(bits, gb);
-        GET_VLC(code, bits, gb, vlc->table, 7, 2);
+        GET_VLC(code, bits, gb, vlc->table, VLC_BITS, VLC_DEPTH);
 
         pred  += code;
         dst[0] = pred;
@@ -195,7 +211,7 @@ static int read_yuv_component_line(CLLCContext *ctx, GetBitContext *gb,
     /* Simultaneously read and restore the line */
     for (i = 0; i < ctx->avctx->width >> is_chroma; i++) {
         UPDATE_CACHE(bits, gb);
-        GET_VLC(code, bits, gb, vlc->table, 7, 2);
+        GET_VLC(code, bits, gb, vlc->table, VLC_BITS, VLC_DEPTH);
 
         pred     += code;
         outbuf[i] = pred;
@@ -357,6 +373,7 @@ static int cllc_decode_frame(AVCodecContext *avctx, void *data,
 {
     CLLCContext *ctx = avctx->priv_data;
     AVFrame *pic = data;
+    ThreadFrame frame = { .f = data };
     uint8_t *src = avpkt->data;
     uint32_t info_tag, info_offset;
     int data_size;
@@ -412,12 +429,15 @@ static int cllc_decode_frame(AVCodecContext *avctx, void *data,
     coding_type = (AV_RL32(src) >> 8) & 0xFF;
     av_log(avctx, AV_LOG_DEBUG, "Frame coding type: %d\n", coding_type);
 
+    if(get_bits_left(&gb) < avctx->height * avctx->width)
+        return AVERROR_INVALIDDATA;
+
     switch (coding_type) {
     case 0:
         avctx->pix_fmt             = AV_PIX_FMT_YUV422P;
         avctx->bits_per_raw_sample = 8;
 
-        if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
+        if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
             return ret;
 
         ret = decode_yuv_frame(ctx, &gb, pic);
@@ -430,7 +450,7 @@ static int cllc_decode_frame(AVCodecContext *avctx, void *data,
         avctx->pix_fmt             = AV_PIX_FMT_RGB24;
         avctx->bits_per_raw_sample = 8;
 
-        if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
+        if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
             return ret;
 
         ret = decode_rgb24_frame(ctx, &gb, pic);
@@ -442,7 +462,7 @@ static int cllc_decode_frame(AVCodecContext *avctx, void *data,
         avctx->pix_fmt             = AV_PIX_FMT_ARGB;
         avctx->bits_per_raw_sample = 8;
 
-        if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
+        if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
             return ret;
 
         ret = decode_argb_frame(ctx, &gb, pic);
@@ -463,6 +483,19 @@ static int cllc_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
+#if HAVE_THREADS
+static int cllc_init_thread_copy(AVCodecContext *avctx)
+{
+    CLLCContext *ctx = avctx->priv_data;
+
+    ctx->avctx            = avctx;
+    ctx->swapped_buf      = NULL;
+    ctx->swapped_buf_size = 0;
+
+    return 0;
+}
+#endif
+
 static av_cold int cllc_decode_close(AVCodecContext *avctx)
 {
     CLLCContext *ctx = avctx->priv_data;
@@ -493,7 +526,9 @@ AVCodec ff_cllc_decoder = {
     .id             = AV_CODEC_ID_CLLC,
     .priv_data_size = sizeof(CLLCContext),
     .init           = cllc_decode_init,
+    .init_thread_copy = ONLY_IF_THREADS_ENABLED(cllc_init_thread_copy),
     .decode         = cllc_decode_frame,
     .close          = cllc_decode_close,
-    .capabilities   = AV_CODEC_CAP_DR1,
+    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/cngdec.c b/mythtv/external/FFmpeg/libavcodec/cngdec.c
index 34f881448de..28432ac7194 100644
--- a/mythtv/external/FFmpeg/libavcodec/cngdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/cngdec.c
@@ -23,6 +23,7 @@
 
 #include "libavutil/common.h"
 #include "libavutil/ffmath.h"
+#include "libavutil/intreadwrite.h"
 #include "avcodec.h"
 #include "celp_filters.h"
 #include "internal.h"
@@ -120,6 +121,11 @@ static int cng_decode_frame(AVCodecContext *avctx, void *data,
         }
     }
 
+    if (avctx->internal->skip_samples > 10 * avctx->frame_size) {
+        avctx->internal->skip_samples = 0;
+        return AVERROR_INVALIDDATA;
+    }
+
     if (p->inited) {
         p->energy = p->energy / 2 + p->target_energy / 2;
         for (i = 0; i < p->order; i++)
@@ -147,7 +153,7 @@ static int cng_decode_frame(AVCodecContext *avctx, void *data,
         return ret;
     buf_out = (int16_t *)frame->data[0];
     for (i = 0; i < avctx->frame_size; i++)
-        buf_out[i] = p->filter_out[i + p->order];
+        buf_out[i] = av_clip_int16(p->filter_out[i + p->order]);
     memcpy(p->filter_out, p->filter_out + avctx->frame_size,
            p->order * sizeof(*p->filter_out));
 
diff --git a/mythtv/external/FFmpeg/libavcodec/cngenc.c b/mythtv/external/FFmpeg/libavcodec/cngenc.c
index 302c703f721..e185c4a40a9 100644
--- a/mythtv/external/FFmpeg/libavcodec/cngenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/cngenc.c
@@ -91,7 +91,7 @@ static int cng_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     } else {
         qdbov = 127;
     }
-    ret = ff_lpc_calc_ref_coefs(&p->lpc, p->samples32, p->order, p->ref_coef);
+    ff_lpc_calc_ref_coefs(&p->lpc, p->samples32, p->order, p->ref_coef);
     avpkt->data[0] = qdbov;
     for (i = 0; i < p->order; i++)
         avpkt->data[1 + i] = p->ref_coef[i] * 127 + 127;
diff --git a/mythtv/external/FFmpeg/libavcodec/codec_desc.c b/mythtv/external/FFmpeg/libavcodec/codec_desc.c
index a56f9d5c8b2..f302e63606f 100644
--- a/mythtv/external/FFmpeg/libavcodec/codec_desc.c
+++ b/mythtv/external/FFmpeg/libavcodec/codec_desc.c
@@ -169,6 +169,14 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .long_name = NULL_IF_CONFIG_SMALL("FLV / Sorenson Spark / Sorenson H.263 (Flash Video)"),
         .props     = AV_CODEC_PROP_LOSSY,
     },
+    {
+        .id        = AV_CODEC_ID_SVG,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "svg",
+        .long_name = NULL_IF_CONFIG_SMALL("Scalable Vector Graphics"),
+        .props     = AV_CODEC_PROP_LOSSLESS,
+        .mime_types= MT("image/svg+xml"),
+    },
     {
         .id        = AV_CODEC_ID_SVQ1,
         .type      = AVMEDIA_TYPE_VIDEO,
@@ -520,7 +528,7 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .type      = AVMEDIA_TYPE_VIDEO,
         .name      = "fraps",
         .long_name = NULL_IF_CONFIG_SMALL("Fraps"),
-        .props     = AV_CODEC_PROP_LOSSLESS,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_TRUEMOTION2,
@@ -1107,7 +1115,7 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .type      = AVMEDIA_TYPE_VIDEO,
         .name      = "y41p",
         .long_name = NULL_IF_CONFIG_SMALL("Uncompressed YUV 4:1:1 12-bit"),
-        .props     = AV_CODEC_PROP_INTRA_ONLY,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_ESCAPE130,
@@ -1121,56 +1129,56 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .type      = AVMEDIA_TYPE_VIDEO,
         .name      = "avrp",
         .long_name = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),
-        .props     = AV_CODEC_PROP_INTRA_ONLY,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_012V,
         .type      = AVMEDIA_TYPE_VIDEO,
         .name      = "012v",
         .long_name = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
-        .props     = AV_CODEC_PROP_INTRA_ONLY,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_AVUI,
         .type      = AVMEDIA_TYPE_VIDEO,
         .name      = "avui",
         .long_name = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),
-        .props     = AV_CODEC_PROP_INTRA_ONLY,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_AYUV,
         .type      = AVMEDIA_TYPE_VIDEO,
         .name      = "ayuv",
         .long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed MS 4:4:4:4"),
-        .props     = AV_CODEC_PROP_INTRA_ONLY,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_TARGA_Y216,
         .type      = AVMEDIA_TYPE_VIDEO,
         .name      = "targa_y216",
         .long_name = NULL_IF_CONFIG_SMALL("Pinnacle TARGA CineWave YUV16"),
-        .props     = AV_CODEC_PROP_INTRA_ONLY,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_V308,
         .type      = AVMEDIA_TYPE_VIDEO,
         .name      = "v308",
         .long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:4:4"),
-        .props     = AV_CODEC_PROP_INTRA_ONLY,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_V408,
         .type      = AVMEDIA_TYPE_VIDEO,
         .name      = "v408",
         .long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed QT 4:4:4:4"),
-        .props     = AV_CODEC_PROP_INTRA_ONLY,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_YUV4,
         .type      = AVMEDIA_TYPE_VIDEO,
         .name      = "yuv4",
         .long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:2:0"),
-        .props     = AV_CODEC_PROP_INTRA_ONLY,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_AVRN,
@@ -1273,7 +1281,7 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .id        = AV_CODEC_ID_HAP,
         .type      = AVMEDIA_TYPE_VIDEO,
         .name      = "hap",
-        .long_name = NULL_IF_CONFIG_SMALL("Vidvox Hap decoder"),
+        .long_name = NULL_IF_CONFIG_SMALL("Vidvox Hap"),
         .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSY,
     },
     {
@@ -1290,6 +1298,13 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .long_name = NULL_IF_CONFIG_SMALL("Screenpresso"),
         .props     = AV_CODEC_PROP_LOSSLESS,
     },
+    {
+        .id        = AV_CODEC_ID_SPEEDHQ,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "speedhq",
+        .long_name = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSY,
+    },
     {
         .id        = AV_CODEC_ID_WRAPPED_AVFRAME,
         .type      = AVMEDIA_TYPE_VIDEO,
@@ -1339,6 +1354,69 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .long_name = NULL_IF_CONFIG_SMALL("YUY2 Lossless Codec"),
         .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
+    {
+        .id        = AV_CODEC_ID_PIXLET,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "pixlet",
+        .long_name = NULL_IF_CONFIG_SMALL("Apple Pixlet"),
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSY,
+    },
+    {
+        .id        = AV_CODEC_ID_FMVC,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "fmvc",
+        .long_name = NULL_IF_CONFIG_SMALL("FM Screen Capture Codec"),
+        .props     = AV_CODEC_PROP_LOSSLESS,
+    },
+    {
+        .id        = AV_CODEC_ID_SCPR,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "scpr",
+        .long_name = NULL_IF_CONFIG_SMALL("ScreenPressor"),
+        .props     = AV_CODEC_PROP_LOSSLESS | AV_CODEC_PROP_LOSSY,
+    },
+    {
+        .id        = AV_CODEC_ID_CLEARVIDEO,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "clearvideo",
+        .long_name = NULL_IF_CONFIG_SMALL("Iterated Systems ClearVideo"),
+        .props     = AV_CODEC_PROP_LOSSY,
+    },
+    {
+        .id        = AV_CODEC_ID_AV1,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "av1",
+        .long_name = NULL_IF_CONFIG_SMALL("Alliance for Open Media AV1"),
+        .props     = AV_CODEC_PROP_LOSSY,
+    },
+    {
+        .id        = AV_CODEC_ID_BITPACKED,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "bitpacked",
+        .long_name = NULL_IF_CONFIG_SMALL("Bitpacked"),
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
+    },
+    {
+        .id        = AV_CODEC_ID_MSCC,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "mscc",
+        .long_name = NULL_IF_CONFIG_SMALL("Mandsoft Screen Capture Codec"),
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
+    },
+    {
+        .id        = AV_CODEC_ID_SRGC,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "srgc",
+        .long_name = NULL_IF_CONFIG_SMALL("Screen Recorder Gold Codec"),
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
+    },
+    {
+        .id        = AV_CODEC_ID_GDV,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "gdv",
+        .long_name = NULL_IF_CONFIG_SMALL("Gremlin Digital Video"),
+        .props     = AV_CODEC_PROP_LOSSY,
+    },
 
     /* image codecs */
     {
@@ -1385,6 +1463,13 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSY |
                      AV_CODEC_PROP_LOSSLESS,
     },
+    {
+        .id        = AV_CODEC_ID_FITS,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "fits",
+        .long_name = NULL_IF_CONFIG_SMALL("FITS (Flexible Image Transport System)"),
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
+    },
     {
         .id        = AV_CODEC_ID_GIF,
         .type      = AVMEDIA_TYPE_VIDEO,
@@ -1460,6 +1545,13 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .long_name = NULL_IF_CONFIG_SMALL("PPM (Portable PixelMap) image"),
         .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
+    {
+        .id        = AV_CODEC_ID_PSD,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "psd",
+        .long_name = NULL_IF_CONFIG_SMALL("Photoshop PSD file"),
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
+    },
     {
         .id        = AV_CODEC_ID_PTX,
         .type      = AVMEDIA_TYPE_VIDEO,
@@ -1547,6 +1639,15 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .name      = "xbm",
         .long_name = NULL_IF_CONFIG_SMALL("XBM (X BitMap) image"),
         .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
+        .mime_types= MT("image/x-xbitmap"),
+    },
+    {
+        .id        = AV_CODEC_ID_XPM,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "xpm",
+        .long_name = NULL_IF_CONFIG_SMALL("XPM (X PixMap) image"),
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
+        .mime_types= MT("image/x-xpixmap"),
     },
     {
         .id        = AV_CODEC_ID_XWD,
@@ -1741,6 +1842,20 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .long_name = NULL_IF_CONFIG_SMALL("PCM signed 20|24-bit big-endian"),
         .props     = AV_CODEC_PROP_LOSSLESS,
     },
+    {
+        .id        = AV_CODEC_ID_PCM_F16LE,
+        .type      = AVMEDIA_TYPE_AUDIO,
+        .name      = "pcm_f16le",
+        .long_name = NULL_IF_CONFIG_SMALL("PCM 16.8 floating point little-endian"),
+        .props     = AV_CODEC_PROP_LOSSLESS,
+    },
+    {
+        .id        = AV_CODEC_ID_PCM_F24LE,
+        .type      = AVMEDIA_TYPE_AUDIO,
+        .name      = "pcm_f24le",
+        .long_name = NULL_IF_CONFIG_SMALL("PCM 24.0 floating point little-endian"),
+        .props     = AV_CODEC_PROP_LOSSLESS,
+    },
     {
         .id        = AV_CODEC_ID_PCM_F32BE,
         .type      = AVMEDIA_TYPE_AUDIO,
@@ -2148,6 +2263,13 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .long_name = NULL_IF_CONFIG_SMALL("DPCM Squareroot-Delta-Exact"),
         .props     = AV_CODEC_PROP_LOSSY,
     },
+    {
+        .id        = AV_CODEC_ID_GREMLIN_DPCM,
+        .type      = AVMEDIA_TYPE_AUDIO,
+        .name      = "gremlin_dpcm",
+        .long_name = NULL_IF_CONFIG_SMALL("DPCM Gremlin"),
+        .props     = AV_CODEC_PROP_LOSSY,
+    },
 
     /* audio codecs */
     {
@@ -2241,7 +2363,7 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .type      = AVMEDIA_TYPE_AUDIO,
         .name      = "flac",
         .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
-        .props     = AV_CODEC_PROP_LOSSLESS,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_MP3ADU,
@@ -2269,7 +2391,7 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .type      = AVMEDIA_TYPE_AUDIO,
         .name      = "alac",
         .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
-        .props     = AV_CODEC_PROP_LOSSLESS,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_WESTWOOD_SND1,
@@ -2311,7 +2433,7 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .type      = AVMEDIA_TYPE_AUDIO,
         .name      = "tta",
         .long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"),
-        .props     = AV_CODEC_PROP_LOSSLESS,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_SMACKAUDIO,
@@ -2332,7 +2454,8 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .type      = AVMEDIA_TYPE_AUDIO,
         .name      = "wavpack",
         .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
-        .props     = AV_CODEC_PROP_LOSSY | AV_CODEC_PROP_LOSSLESS,
+        .props     = AV_CODEC_PROP_INTRA_ONLY |
+                     AV_CODEC_PROP_LOSSY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_DSICINAUDIO,
@@ -2441,6 +2564,20 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .long_name = NULL_IF_CONFIG_SMALL("ATRAC3+ (Adaptive TRansform Acoustic Coding 3+)"),
         .props     = AV_CODEC_PROP_LOSSY,
     },
+    {
+        .id        = AV_CODEC_ID_ATRAC3PAL,
+        .type      = AVMEDIA_TYPE_AUDIO,
+        .name      = "atrac3pal",
+        .long_name = NULL_IF_CONFIG_SMALL("ATRAC3+ AL (Adaptive TRansform Acoustic Coding 3+ Advanced Lossless)"),
+        .props     = AV_CODEC_PROP_LOSSLESS,
+    },
+    {
+        .id        = AV_CODEC_ID_ATRAC3AL,
+        .type      = AVMEDIA_TYPE_AUDIO,
+        .name      = "atrac3al",
+        .long_name = NULL_IF_CONFIG_SMALL("ATRAC3 AL (Adaptive TRansform Acoustic Coding 3 Advanced Lossless)"),
+        .props     = AV_CODEC_PROP_LOSSLESS,
+    },
     {
         .id        = AV_CODEC_ID_EAC3,
         .type      = AVMEDIA_TYPE_AUDIO,
@@ -2540,6 +2677,13 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .long_name = NULL_IF_CONFIG_SMALL("Digital Speech Standard - Standard Play mode (DSS SP)"),
         .props     = AV_CODEC_PROP_LOSSY,
     },
+    {
+        .id        = AV_CODEC_ID_DOLBY_E,
+        .type      = AVMEDIA_TYPE_AUDIO,
+        .name      = "dolby_e",
+        .long_name = NULL_IF_CONFIG_SMALL("Dolby E"),
+        .props     = AV_CODEC_PROP_LOSSY,
+    },
     {
         .id        = AV_CODEC_ID_G729,
         .type      = AVMEDIA_TYPE_AUDIO,
@@ -2626,7 +2770,7 @@ static const AVCodecDescriptor codec_descriptors[] = {
         .type      = AVMEDIA_TYPE_AUDIO,
         .name      = "tak",
         .long_name = NULL_IF_CONFIG_SMALL("TAK (Tom's lossless Audio Kompressor)"),
-        .props     = AV_CODEC_PROP_LOSSLESS,
+        .props     = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
     },
     {
         .id        = AV_CODEC_ID_METASOUND,
diff --git a/mythtv/external/FFmpeg/libavcodec/cook.c b/mythtv/external/FFmpeg/libavcodec/cook.c
index 794a47582d6..53cb83852e3 100644
--- a/mythtv/external/FFmpeg/libavcodec/cook.c
+++ b/mythtv/external/FFmpeg/libavcodec/cook.c
@@ -882,7 +882,7 @@ static inline void decode_bytes_and_gain(COOKContext *q, COOKSubpacket *p,
 static void saturate_output_float(COOKContext *q, float *out)
 {
     q->adsp.vector_clipf(out, q->mono_mdct_output + q->samples_per_channel,
-                         -1.0f, 1.0f, FFALIGN(q->samples_per_channel, 8));
+                         FFALIGN(q->samples_per_channel, 8), -1.0f, 1.0f);
 }
 
 
@@ -1053,9 +1053,7 @@ static void dump_cook_context(COOKContext *q)
 static av_cold int cook_decode_init(AVCodecContext *avctx)
 {
     COOKContext *q = avctx->priv_data;
-    const uint8_t *edata_ptr = avctx->extradata;
-    const uint8_t *edata_ptr_end = edata_ptr + avctx->extradata_size;
-    int extradata_size = avctx->extradata_size;
+    GetByteContext gb;
     int s = 0;
     unsigned int channel_mask = 0;
     int samples_per_frame = 0;
@@ -1063,12 +1061,14 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)
     q->avctx = avctx;
 
     /* Take care of the codec specific extradata. */
-    if (extradata_size < 8) {
+    if (avctx->extradata_size < 8) {
         av_log(avctx, AV_LOG_ERROR, "Necessary extradata missing!\n");
         return AVERROR_INVALIDDATA;
     }
     av_log(avctx, AV_LOG_DEBUG, "codecdata_length=%d\n", avctx->extradata_size);
 
+    bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
+
     /* Take data from the AVCodecContext (RM container). */
     if (!avctx->channels) {
         av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
@@ -1080,26 +1080,19 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)
 
     ff_audiodsp_init(&q->adsp);
 
-    while (edata_ptr < edata_ptr_end) {
+    while (bytestream2_get_bytes_left(&gb)) {
         /* 8 for mono, 16 for stereo, ? for multichannel
            Swap to right endianness so we don't need to care later on. */
-        if (extradata_size >= 8) {
-            q->subpacket[s].cookversion = bytestream_get_be32(&edata_ptr);
-            samples_per_frame           = bytestream_get_be16(&edata_ptr);
-            q->subpacket[s].subbands = bytestream_get_be16(&edata_ptr);
-            extradata_size -= 8;
-        }
-        if (extradata_size >= 8) {
-            bytestream_get_be32(&edata_ptr);    // Unknown unused
-            q->subpacket[s].js_subband_start = bytestream_get_be16(&edata_ptr);
-            if (q->subpacket[s].js_subband_start >= 51) {
-                av_log(avctx, AV_LOG_ERROR, "js_subband_start %d is too large\n", q->subpacket[s].js_subband_start);
-                return AVERROR_INVALIDDATA;
-            }
-
-            q->subpacket[s].js_vlc_bits = bytestream_get_be16(&edata_ptr);
-            extradata_size -= 8;
+        q->subpacket[s].cookversion      = bytestream2_get_be32(&gb);
+        samples_per_frame                = bytestream2_get_be16(&gb);
+        q->subpacket[s].subbands         = bytestream2_get_be16(&gb);
+        bytestream2_get_be32(&gb);    // Unknown unused
+        q->subpacket[s].js_subband_start = bytestream2_get_be16(&gb);
+        if (q->subpacket[s].js_subband_start >= 51) {
+            av_log(avctx, AV_LOG_ERROR, "js_subband_start %d is too large\n", q->subpacket[s].js_subband_start);
+            return AVERROR_INVALIDDATA;
         }
+        q->subpacket[s].js_vlc_bits      = bytestream2_get_be16(&gb);
 
         /* Initialize extradata related variables. */
         q->subpacket[s].samples_per_channel = samples_per_frame / avctx->channels;
@@ -1151,8 +1144,7 @@ static av_cold int cook_decode_init(AVCodecContext *avctx)
             break;
         case MC_COOK:
             av_log(avctx, AV_LOG_DEBUG, "MULTI_CHANNEL\n");
-            if (extradata_size >= 4)
-                channel_mask |= q->subpacket[s].channel_mask = bytestream_get_be32(&edata_ptr);
+            channel_mask |= q->subpacket[s].channel_mask = bytestream2_get_be32(&gb);
 
             if (av_get_channel_layout_nb_channels(q->subpacket[s].channel_mask) > 1) {
                 q->subpacket[s].total_subbands = q->subpacket[s].subbands +
diff --git a/mythtv/external/FFmpeg/libavcodec/copy_block.h b/mythtv/external/FFmpeg/libavcodec/copy_block.h
index 9ed451f2940..393d45578e7 100644
--- a/mythtv/external/FFmpeg/libavcodec/copy_block.h
+++ b/mythtv/external/FFmpeg/libavcodec/copy_block.h
@@ -19,22 +19,22 @@
 #ifndef AVCODEC_COPY_BLOCK_H
 #define AVCODEC_COPY_BLOCK_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "libavutil/intreadwrite.h"
 
-static inline void copy_block2(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
+static inline void copy_block2(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
 {
     int i;
-    for(i=0; i<h; i++)
-    {
+    for (i = 0; i < h; i++) {
         AV_COPY16U(dst, src);
-        dst+=dstStride;
-        src+=srcStride;
+        dst += dstStride;
+        src += srcStride;
     }
 }
 
-static inline void copy_block4(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
+static inline void copy_block4(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
 {
     int i;
     for (i = 0; i < h; i++) {
@@ -44,7 +44,7 @@ static inline void copy_block4(uint8_t *dst, const uint8_t *src, int dstStride,
     }
 }
 
-static inline void copy_block8(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
+static inline void copy_block8(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
 {
     int i;
     for (i = 0; i < h; i++) {
@@ -54,7 +54,7 @@ static inline void copy_block8(uint8_t *dst, const uint8_t *src, int dstStride,
     }
 }
 
-static inline void copy_block9(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
+static inline void copy_block9(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
 {
     int i;
     for (i = 0; i < h; i++) {
@@ -65,7 +65,7 @@ static inline void copy_block9(uint8_t *dst, const uint8_t *src, int dstStride,
     }
 }
 
-static inline void copy_block16(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
+static inline void copy_block16(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
 {
     int i;
     for (i = 0; i < h; i++) {
@@ -75,7 +75,7 @@ static inline void copy_block16(uint8_t *dst, const uint8_t *src, int dstStride,
     }
 }
 
-static inline void copy_block17(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
+static inline void copy_block17(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
 {
     int i;
     for (i = 0; i < h; i++) {
diff --git a/mythtv/external/FFmpeg/libavcodec/cpia.c b/mythtv/external/FFmpeg/libavcodec/cpia.c
index 07cdd503687..58833b2f267 100644
--- a/mythtv/external/FFmpeg/libavcodec/cpia.c
+++ b/mythtv/external/FFmpeg/libavcodec/cpia.c
@@ -113,12 +113,12 @@ static int cpia_decode_frame(AVCodecContext *avctx,
         src += 2;
 
         if (src_size < linelength) {
-            av_frame_set_decode_error_flags(frame, FF_DECODE_ERROR_INVALID_BITSTREAM);
+            frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
             av_log(avctx, AV_LOG_WARNING, "Frame ended unexpectedly!\n");
             break;
         }
         if (src[linelength - 1] != EOL) {
-            av_frame_set_decode_error_flags(frame, FF_DECODE_ERROR_INVALID_BITSTREAM);
+            frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
             av_log(avctx, AV_LOG_WARNING, "Wrong line length %d or line not terminated properly (found 0x%02x)!\n", linelength, src[linelength - 1]);
             break;
         }
@@ -139,7 +139,7 @@ static int cpia_decode_frame(AVCodecContext *avctx,
              */
             for (j = 0; j < linelength - 1; j++) {
                 if (y > y_end) {
-                    av_frame_set_decode_error_flags(frame, FF_DECODE_ERROR_INVALID_BITSTREAM);
+                    frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
                     av_log(avctx, AV_LOG_WARNING, "Decoded data exceeded linesize!\n");
                     break;
                 }
@@ -159,7 +159,7 @@ static int cpia_decode_frame(AVCodecContext *avctx,
              */
             for (j = 0; j < linelength - 4; ) {
                 if (y + 1 > y_end || u > u_end || v > v_end) {
-                    av_frame_set_decode_error_flags(frame, FF_DECODE_ERROR_INVALID_BITSTREAM);
+                    frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
                     av_log(avctx, AV_LOG_WARNING, "Decoded data exceeded linesize!\n");
                     break;
                 }
diff --git a/mythtv/external/FFmpeg/libavcodec/crystalhd.c b/mythtv/external/FFmpeg/libavcodec/crystalhd.c
index 912094088a1..83bc8bf3641 100644
--- a/mythtv/external/FFmpeg/libavcodec/crystalhd.c
+++ b/mythtv/external/FFmpeg/libavcodec/crystalhd.c
@@ -34,39 +34,11 @@
  * is not just a function of time, but also one of the dependency on additional
  * frames being fed into the decoder to satisfy the b-frame dependencies.
  *
- * As such, a pipeline will build up that is roughly equivalent to the required
- * DPB for the file being played. If that was all it took, things would still
- * be simple - so, of course, it isn't.
- *
- * The hardware has a way of indicating that a picture is ready to be copied out,
- * but this is unreliable - and sometimes the attempt will still fail so, based
- * on testing, the code will wait until 3 pictures are ready before starting
- * to copy out - and this has the effect of extending the pipeline.
- *
- * Finally, while it is tempting to say that once the decoder starts outputting
- * frames, the software should never fail to return a frame from a decode(),
- * this is a hard assertion to make, because the stream may switch between
- * differently encoded content (number of b-frames, interlacing, etc) which
- * might require a longer pipeline than before. If that happened, you could
- * deadlock trying to retrieve a frame that can't be decoded without feeding
- * in additional packets.
- *
- * As such, the code will return in the event that a picture cannot be copied
- * out, leading to an increase in the length of the pipeline. This in turn,
- * means we have to be sensitive to the time it takes to decode a picture;
- * We do not want to give up just because the hardware needed a little more
- * time to prepare the picture! For this reason, there are delays included
- * in the decode() path that ensure that, under normal conditions, the hardware
- * will only fail to return a frame if it really needs additional packets to
- * complete the decoding.
- *
- * Finally, to be explicit, we do not want the pipeline to grow without bound
- * for two reasons: 1) The hardware can only buffer a finite number of packets,
- * and 2) The client application may not be able to cope with arbitrarily long
- * delays in the video path relative to the audio path. For example. MPlayer
- * can only handle a 20 picture delay (although this is arbitrary, and needs
- * to be extended to fully support the CrystalHD where the delay could be up
- * to 32 pictures - consider PAFF H.264 content with 16 b-frames).
+ * As such, the hardware can only be used effectively with a decode API that
+ * doesn't assume a 1:1 relationship between input packets and output frames.
+ * The new avcodec decode API is such an API (an m:n API) while the old one is
+ * 1:1. Consequently, we no longer support the old API, which allows us to avoid
+ * the vicious hacks that are required to approximate 1:1 operation.
  */
 
 /*****************************************************************************
@@ -83,7 +55,7 @@
 #include <libcrystalhd/libcrystalhd_if.h>
 
 #include "avcodec.h"
-#include "h264dec.h"
+#include "decode.h"
 #include "internal.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/intreadwrite.h"
@@ -97,10 +69,6 @@
 #define OUTPUT_PROC_TIMEOUT 50
 /** Step between fake timestamps passed to hardware in units of 100ns */
 #define TIMESTAMP_UNIT 100000
-/** Initial value in us of the wait in decode() */
-#define BASE_WAIT 10000
-/** Increment in us to adjust wait in decode() */
-#define WAIT_UNIT 1000
 
 
 /*****************************************************************************
@@ -111,39 +79,22 @@ typedef enum {
     RET_ERROR           = -1,
     RET_OK              = 0,
     RET_COPY_AGAIN      = 1,
-    RET_SKIP_NEXT_COPY  = 2,
-    RET_COPY_NEXT_FIELD = 3,
 } CopyRet;
 
 typedef struct OpaqueList {
     struct OpaqueList *next;
     uint64_t fake_timestamp;
     uint64_t reordered_opaque;
-    uint8_t pic_type;
 } OpaqueList;
 
 typedef struct {
     AVClass *av_class;
     AVCodecContext *avctx;
-    AVFrame *pic;
     HANDLE dev;
 
-    uint8_t *orig_extradata;
-    uint32_t orig_extradata_size;
-
-    AVBSFContext *bsfc;
-    AVCodecParserContext *parser;
-
     uint8_t is_70012;
-    uint8_t *sps_pps_buf;
-    uint32_t sps_pps_size;
-    uint8_t is_nal;
-    uint8_t output_ready;
     uint8_t need_second_field;
-    uint8_t skip_next_output;
-    uint64_t decode_wait;
-
-    uint64_t last_picture;
+    uint8_t draining;
 
     OpaqueList *head;
     OpaqueList *tail;
@@ -180,7 +131,7 @@ static inline BC_MEDIA_SUBTYPE id2subtype(CHDContext *priv, enum AVCodecID id)
     case AV_CODEC_ID_WMV3:
         return BC_MSUBTYPE_WMV3;
     case AV_CODEC_ID_H264:
-        return priv->is_nal ? BC_MSUBTYPE_AVC1 : BC_MSUBTYPE_H264;
+        return BC_MSUBTYPE_H264;
     default:
         return BC_MSUBTYPE_INVALID;
     }
@@ -188,42 +139,42 @@ static inline BC_MEDIA_SUBTYPE id2subtype(CHDContext *priv, enum AVCodecID id)
 
 static inline void print_frame_info(CHDContext *priv, BC_DTS_PROC_OUT *output)
 {
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tYBuffSz: %u\n", output->YbuffSz);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tYBuffDoneSz: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tYBuffSz: %u\n", output->YbuffSz);
+    av_log(priv->avctx, AV_LOG_TRACE, "\tYBuffDoneSz: %u\n",
            output->YBuffDoneSz);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tUVBuffDoneSz: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tUVBuffDoneSz: %u\n",
            output->UVBuffDoneSz);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tTimestamp: %"PRIu64"\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tTimestamp: %"PRIu64"\n",
            output->PicInfo.timeStamp);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tPicture Number: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tPicture Number: %u\n",
            output->PicInfo.picture_number);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tWidth: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tWidth: %u\n",
            output->PicInfo.width);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tHeight: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tHeight: %u\n",
            output->PicInfo.height);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tChroma: 0x%03x\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tChroma: 0x%03x\n",
            output->PicInfo.chroma_format);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tPulldown: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tPulldown: %u\n",
            output->PicInfo.pulldown);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tFlags: 0x%08x\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tFlags: 0x%08x\n",
            output->PicInfo.flags);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tFrame Rate/Res: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tFrame Rate/Res: %u\n",
            output->PicInfo.frame_rate);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tAspect Ratio: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tAspect Ratio: %u\n",
            output->PicInfo.aspect_ratio);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tColor Primaries: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tColor Primaries: %u\n",
            output->PicInfo.colour_primaries);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tMetaData: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tMetaData: %u\n",
            output->PicInfo.picture_meta_payload);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tSession Number: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tSession Number: %u\n",
            output->PicInfo.sess_num);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tycom: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tycom: %u\n",
            output->PicInfo.ycom);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tCustom Aspect: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tCustom Aspect: %u\n",
            output->PicInfo.custom_aspect_ratio_width_height);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tFrames to Drop: %u\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tFrames to Drop: %u\n",
            output->PicInfo.n_drop);
-    av_log(priv->avctx, AV_LOG_VERBOSE, "\tH264 Valid Fields: 0x%08x\n",
+    av_log(priv->avctx, AV_LOG_TRACE, "\tH264 Valid Fields: 0x%08x\n",
            output->PicInfo.other.h264.valid);
 }
 
@@ -232,8 +183,7 @@ static inline void print_frame_info(CHDContext *priv, BC_DTS_PROC_OUT *output)
  * OpaqueList functions
  ****************************************************************************/
 
-static uint64_t opaque_list_push(CHDContext *priv, uint64_t reordered_opaque,
-                                 uint8_t pic_type)
+static uint64_t opaque_list_push(CHDContext *priv, uint64_t reordered_opaque)
 {
     OpaqueList *newNode = av_mallocz(sizeof (OpaqueList));
     if (!newNode) {
@@ -250,7 +200,6 @@ static uint64_t opaque_list_push(CHDContext *priv, uint64_t reordered_opaque,
     }
     priv->tail = newNode;
     newNode->reordered_opaque = reordered_opaque;
-    newNode->pic_type = pic_type;
 
     return newNode->fake_timestamp;
 }
@@ -319,14 +268,8 @@ static void flush(AVCodecContext *avctx)
 {
     CHDContext *priv = avctx->priv_data;
 
-    avctx->has_b_frames     = 0;
-    priv->last_picture      = -1;
-    priv->output_ready      = 0;
     priv->need_second_field = 0;
-    priv->skip_next_output  = 0;
-    priv->decode_wait       = BASE_WAIT;
-
-    av_frame_unref (priv->pic);
+    priv->draining          = 0;
 
     /* Flush mode 4 flushes all software and hardware buffers. */
     DtsFlushInput(priv->dev, 4);
@@ -343,28 +286,6 @@ static av_cold int uninit(AVCodecContext *avctx)
     DtsCloseDecoder(device);
     DtsDeviceClose(device);
 
-    /*
-     * Restore original extradata, so that if the decoder is
-     * reinitialised, the bitstream detection and filtering
-     * will work as expected.
-     */
-    if (priv->orig_extradata) {
-        av_free(avctx->extradata);
-        avctx->extradata = priv->orig_extradata;
-        avctx->extradata_size = priv->orig_extradata_size;
-        priv->orig_extradata = NULL;
-        priv->orig_extradata_size = 0;
-    }
-
-    av_parser_close(priv->parser);
-    if (priv->bsfc) {
-        av_bsf_free(&priv->bsfc);
-    }
-
-    av_freep(&priv->sps_pps_buf);
-
-    av_frame_free (&priv->pic);
-
     if (priv->head) {
        OpaqueList *node = priv->head;
        while (node) {
@@ -377,60 +298,9 @@ static av_cold int uninit(AVCodecContext *avctx)
     return 0;
 }
 
-
-static av_cold int init_bsf(AVCodecContext *avctx, const char *bsf_name)
-{
-    CHDContext *priv = avctx->priv_data;
-    const AVBitStreamFilter *bsf;
-    int avret;
-    void *extradata = NULL;
-    size_t size = 0;
-
-    bsf = av_bsf_get_by_name(bsf_name);
-    if (!bsf) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Cannot open the %s BSF!\n", bsf_name);
-        return AVERROR_BSF_NOT_FOUND;
-    }
-
-    avret = av_bsf_alloc(bsf, &priv->bsfc);
-    if (avret != 0) {
-        return avret;
-    }
-
-    avret = avcodec_parameters_from_context(priv->bsfc->par_in, avctx);
-    if (avret != 0) {
-        return avret;
-    }
-
-    avret = av_bsf_init(priv->bsfc);
-    if (avret != 0) {
-        return avret;
-    }
-
-    /* Back up the extradata so it can be restored at close time. */
-    priv->orig_extradata = avctx->extradata;
-    priv->orig_extradata_size = avctx->extradata_size;
-
-    size = priv->bsfc->par_out->extradata_size;
-    extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
-    if (!extradata) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Failed to allocate copy of extradata\n");
-        return AVERROR(ENOMEM);
-    }
-    memcpy(extradata, priv->bsfc->par_out->extradata, size);
-
-    avctx->extradata = extradata;
-    avctx->extradata_size = size;
-
-    return 0;
-}
-
 static av_cold int init(AVCodecContext *avctx)
 {
     CHDContext* priv;
-    int avret;
     BC_STATUS ret;
     BC_INFO_CRYSTAL version;
     BC_INPUT_FORMAT format = {
@@ -458,31 +328,10 @@ static av_cold int init(AVCodecContext *avctx)
     /* Initialize the library */
     priv               = avctx->priv_data;
     priv->avctx        = avctx;
-    priv->is_nal       = avctx->extradata_size > 0 && *(avctx->extradata) == 1;
-    priv->last_picture = -1;
-    priv->decode_wait  = BASE_WAIT;
-    priv->pic          = av_frame_alloc();
+    priv->draining     = 0;
 
     subtype = id2subtype(priv, avctx->codec->id);
     switch (subtype) {
-    case BC_MSUBTYPE_AVC1:
-        avret = init_bsf(avctx, "h264_mp4toannexb");
-        if (avret != 0) {
-            return avret;
-        }
-        subtype = BC_MSUBTYPE_H264;
-        format.startCodeSz = 4;
-        format.pMetaData  = avctx->extradata;
-        format.metaDataSz = avctx->extradata_size;
-        break;
-    case BC_MSUBTYPE_DIVX:
-        avret = init_bsf(avctx, "mpeg4_unpack_bframes");
-        if (avret != 0) {
-            return avret;
-        }
-        format.pMetaData  = avctx->extradata;
-        format.metaDataSz = avctx->extradata_size;
-        break;
     case BC_MSUBTYPE_H264:
         format.startCodeSz = 4;
         // Fall-through
@@ -491,6 +340,7 @@ static av_cold int init(AVCodecContext *avctx)
     case BC_MSUBTYPE_WMV3:
     case BC_MSUBTYPE_WMVA:
     case BC_MSUBTYPE_MPEG2VIDEO:
+    case BC_MSUBTYPE_DIVX:
     case BC_MSUBTYPE_DIVX311:
         format.pMetaData  = avctx->extradata;
         format.metaDataSz = avctx->extradata_size;
@@ -558,14 +408,6 @@ static av_cold int init(AVCodecContext *avctx)
         goto fail;
     }
 
-    if (avctx->codec->id == AV_CODEC_ID_H264) {
-        priv->parser = av_parser_init(avctx->codec->id);
-        if (!priv->parser)
-            av_log(avctx, AV_LOG_WARNING,
-                   "Cannot open the h.264 parser! Interlaced h.264 content "
-                   "will not be detected reliably.\n");
-        priv->parser->flags = PARSER_FLAG_COMPLETE_FRAMES;
-    }
     av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Init complete.\n");
 
     return 0;
@@ -578,16 +420,14 @@ static av_cold int init(AVCodecContext *avctx)
 
 static inline CopyRet copy_frame(AVCodecContext *avctx,
                                  BC_DTS_PROC_OUT *output,
-                                 void *data, int *got_frame)
+                                 AVFrame *frame, int *got_frame)
 {
     BC_STATUS ret;
     BC_DTS_STATUS decoder_status = { 0, };
-    uint8_t trust_interlaced;
     uint8_t interlaced;
 
     CHDContext *priv = avctx->priv_data;
     int64_t pkt_pts  = AV_NOPTS_VALUE;
-    uint8_t pic_type = 0;
 
     uint8_t bottom_field = (output->PicInfo.flags & VDEC_FLAG_BOTTOMFIELD) ==
                            VDEC_FLAG_BOTTOMFIELD;
@@ -605,23 +445,18 @@ static inline CopyRet copy_frame(AVCodecContext *avctx,
         OpaqueList *node = opaque_list_pop(priv, output->PicInfo.timeStamp);
         if (node) {
             pkt_pts = node->reordered_opaque;
-            pic_type = node->pic_type;
             av_free(node);
         } else {
             /*
              * We will encounter a situation where a timestamp cannot be
              * popped if a second field is being returned. In this case,
              * each field has the same timestamp and the first one will
-             * cause it to be popped. To keep subsequent calculations
-             * simple, pic_type should be set a FIELD value - doesn't
-             * matter which, but I chose BOTTOM.
+             * cause it to be popped. We'll avoid overwriting the valid
+             * timestamp below.
              */
-            pic_type = PICT_BOTTOM_FIELD;
         }
         av_log(avctx, AV_LOG_VERBOSE, "output \"pts\": %"PRIu64"\n",
                output->PicInfo.timeStamp);
-        av_log(avctx, AV_LOG_VERBOSE, "output picture type %d\n",
-               pic_type);
     }
 
     ret = DtsGetDriverStatus(priv->dev, &decoder_status);
@@ -631,63 +466,22 @@ static inline CopyRet copy_frame(AVCodecContext *avctx,
        return RET_ERROR;
     }
 
-    /*
-     * For most content, we can trust the interlaced flag returned
-     * by the hardware, but sometimes we can't. These are the
-     * conditions under which we can trust the flag:
-     *
-     * 1) It's not h.264 content
-     * 2) The UNKNOWN_SRC flag is not set
-     * 3) We know we're expecting a second field
-     * 4) The hardware reports this picture and the next picture
-     *    have the same picture number.
-     *
-     * Note that there can still be interlaced content that will
-     * fail this check, if the hardware hasn't decoded the next
-     * picture or if there is a corruption in the stream. (In either
-     * case a 0 will be returned for the next picture number)
-     */
-    trust_interlaced = avctx->codec->id != AV_CODEC_ID_H264 ||
-                       !(output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) ||
-                       priv->need_second_field ||
-                       (decoder_status.picNumFlags & ~0x40000000) ==
-                       output->PicInfo.picture_number;
-
-    /*
-     * If we got a false negative for trust_interlaced on the first field,
-     * we will realise our mistake here when we see that the picture number is that
-     * of the previous picture. We cannot recover the frame and should discard the
-     * second field to keep the correct number of output frames.
-     */
-    if (output->PicInfo.picture_number == priv->last_picture && !priv->need_second_field) {
-        av_log(avctx, AV_LOG_WARNING,
-               "Incorrectly guessed progressive frame. Discarding second field\n");
-        /* Returning without providing a picture. */
-        return RET_OK;
-    }
-
-    interlaced = (output->PicInfo.flags & VDEC_FLAG_INTERLACED_SRC) &&
-                 trust_interlaced;
+    interlaced = output->PicInfo.flags & VDEC_FLAG_INTERLACED_SRC;
 
-    if (!trust_interlaced && (decoder_status.picNumFlags & ~0x40000000) == 0) {
-        av_log(avctx, AV_LOG_VERBOSE,
-               "Next picture number unknown. Assuming progressive frame.\n");
-    }
-
-    av_log(avctx, AV_LOG_VERBOSE, "Interlaced state: %d | trust_interlaced %d\n",
-           interlaced, trust_interlaced);
-
-    if (priv->pic->data[0] && !priv->need_second_field)
-        av_frame_unref(priv->pic);
+    av_log(avctx, AV_LOG_VERBOSE, "Interlaced state: %d\n",
+           interlaced);
 
     priv->need_second_field = interlaced && !priv->need_second_field;
 
-    if (!priv->pic->data[0]) {
-        if (ff_get_buffer(avctx, priv->pic, AV_GET_BUFFER_FLAG_REF) < 0)
+    if (!frame->data[0]) {
+        if (ff_get_buffer(avctx, frame, 0) < 0)
             return RET_ERROR;
     }
 
     bwidth = av_image_get_linesize(avctx->pix_fmt, width, 0);
+    if (bwidth < 0)
+       return RET_ERROR;
+
     if (priv->is_70012) {
         int pStride;
 
@@ -697,15 +491,26 @@ static inline CopyRet copy_frame(AVCodecContext *avctx,
             pStride = 1280;
         else pStride = 1920;
         sStride = av_image_get_linesize(avctx->pix_fmt, pStride, 0);
+        if (sStride < 0)
+            return RET_ERROR;
     } else {
         sStride = bwidth;
     }
 
-    dStride = priv->pic->linesize[0];
-    dst     = priv->pic->data[0];
+    dStride = frame->linesize[0];
+    dst     = frame->data[0];
 
     av_log(priv->avctx, AV_LOG_VERBOSE, "CrystalHD: Copying out frame\n");
 
+    /*
+     * The hardware doesn't return the first sample of a picture.
+     * Ignoring why it behaves this way, it's better to copy the sample from
+     * the second line, rather than the next sample across because the chroma
+     * values should be correct (assuming the decoded video was 4:2:0, which
+     * it was).
+     */
+    *((uint32_t *)src) = *((uint32_t *)(src + sStride));
+
     if (interlaced) {
         int dY = 0;
         int sY = 0;
@@ -727,63 +532,33 @@ static inline CopyRet copy_frame(AVCodecContext *avctx,
         av_image_copy_plane(dst, dStride, src, sStride, bwidth, height);
     }
 
-    priv->pic->interlaced_frame = interlaced;
+    frame->interlaced_frame = interlaced;
     if (interlaced)
-        priv->pic->top_field_first = !bottom_first;
+        frame->top_field_first = !bottom_first;
 
-    if (pkt_pts != AV_NOPTS_VALUE) {
-        priv->pic->pts = pkt_pts;
+    frame->pts = pkt_pts;
 #if FF_API_PKT_PTS
 FF_DISABLE_DEPRECATION_WARNINGS
-        priv->pic->pkt_pts = pkt_pts;
+    frame->pkt_pts = pkt_pts;
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
-    }
-    av_frame_set_pkt_pos(priv->pic, -1);
-    av_frame_set_pkt_duration(priv->pic, 0);
-    av_frame_set_pkt_size(priv->pic, -1);
+
+    frame->pkt_pos = -1;
+    frame->pkt_duration = 0;
+    frame->pkt_size = -1;
 
     if (!priv->need_second_field) {
         *got_frame       = 1;
-        if ((ret = av_frame_ref(data, priv->pic)) < 0) {
-            return ret;
-        }
-    }
-
-    /*
-     * Two types of PAFF content have been observed. One form causes the
-     * hardware to return a field pair and the other individual fields,
-     * even though the input is always individual fields. We must skip
-     * copying on the next decode() call to maintain pipeline length in
-     * the first case.
-     */
-    if (!interlaced && (output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) &&
-        (pic_type == PICT_TOP_FIELD || pic_type == PICT_BOTTOM_FIELD)) {
-        av_log(priv->avctx, AV_LOG_VERBOSE, "Fieldpair from two packets.\n");
-        return RET_SKIP_NEXT_COPY;
+    } else {
+        return RET_COPY_AGAIN;
     }
 
-    /*
-     * The logic here is purely based on empirical testing with samples.
-     * If we need a second field, it could come from a second input packet,
-     * or it could come from the same field-pair input packet at the current
-     * field. In the first case, we should return and wait for the next time
-     * round to get the second field, while in the second case, we should
-     * ask the decoder for it immediately.
-     *
-     * Testing has shown that we are dealing with the fieldpair -> two fields
-     * case if the VDEC_FLAG_UNKNOWN_SRC is not set or if the input picture
-     * type was PICT_FRAME (in this second case, the flag might still be set)
-     */
-    return priv->need_second_field &&
-           (!(output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) ||
-            pic_type == PICT_FRAME) ?
-           RET_COPY_NEXT_FIELD : RET_OK;
+    return RET_OK;
 }
 
 
 static inline CopyRet receive_frame(AVCodecContext *avctx,
-                                    void *data, int *got_frame)
+                                    AVFrame *frame, int *got_frame)
 {
     BC_STATUS ret;
     BC_DTS_PROC_OUT output = {
@@ -855,47 +630,16 @@ static inline CopyRet receive_frame(AVCodecContext *avctx,
     } else if (ret == BC_STS_SUCCESS) {
         int copy_ret = -1;
         if (output.PoutFlags & BC_POUT_FLAGS_PIB_VALID) {
-            if (priv->last_picture == -1) {
-                /*
-                 * Init to one less, so that the incrementing code doesn't
-                 * need to be special-cased.
-                 */
-                priv->last_picture = output.PicInfo.picture_number - 1;
-            }
-
             print_frame_info(priv, &output);
 
-            if (priv->last_picture + 1 < output.PicInfo.picture_number) {
-                av_log(avctx, AV_LOG_WARNING,
-                       "CrystalHD: Picture Number discontinuity\n");
-                /*
-                 * Have we lost frames? If so, we need to shrink the
-                 * pipeline length appropriately.
-                 *
-                 * XXX: I have no idea what the semantics of this situation
-                 * are so I don't even know if we've lost frames or which
-                 * ones.
-                 *
-                 * In any case, only warn the first time.
-                 */
-               priv->last_picture = output.PicInfo.picture_number - 1;
-            }
-
-            copy_ret = copy_frame(avctx, &output, data, got_frame);
-            if (*got_frame > 0) {
-                avctx->has_b_frames--;
-                priv->last_picture++;
-                av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Pipeline length: %u\n",
-                       avctx->has_b_frames);
-            }
+            copy_ret = copy_frame(avctx, &output, frame, got_frame);
         } else {
             /*
              * An invalid frame has been consumed.
              */
             av_log(avctx, AV_LOG_ERROR, "CrystalHD: ProcOutput succeeded with "
                                         "invalid PIB\n");
-            avctx->has_b_frames--;
-            copy_ret = RET_OK;
+            copy_ret = RET_COPY_AGAIN;
         }
         DtsReleaseOutputBuffs(dev, NULL, FALSE);
 
@@ -908,372 +652,164 @@ static inline CopyRet receive_frame(AVCodecContext *avctx,
     }
 }
 
-
-static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
+static int crystalhd_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
 {
-    BC_STATUS ret;
-    BC_DTS_STATUS decoder_status = { 0, };
-    CopyRet rec_ret;
+    BC_STATUS bc_ret;
     CHDContext *priv   = avctx->priv_data;
     HANDLE dev         = priv->dev;
-    uint8_t *in_data   = avpkt->data;
-    int len            = avpkt->size;
-    int free_data      = 0;
-    uint8_t pic_type   = 0;
-
-    av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: decode_frame\n");
-
-    if (len) {
-        int32_t tx_free = (int32_t)DtsTxFreeSize(dev);
-
-        if (priv->bsfc) {
-            int ret = 0;
-            AVPacket filter_packet = { 0 };
-            AVPacket filtered_packet = { 0 };
-
-            ret = av_packet_ref(&filter_packet, avpkt);
-            if (ret < 0) {
-                av_log(avctx, AV_LOG_ERROR, "CrystalHD: mpv4toannexb filter "
-                       "failed to ref input packet\n");
-                return ret;
-            }
-
-              ret = av_bsf_send_packet(priv->bsfc, &filter_packet);
-              if (ret < 0) {
-                av_log(avctx, AV_LOG_ERROR, "CrystalHD: mpv4toannexb filter "
-                       "failed to send input packet\n");
-                return ret;
-            }
-
-            ret = av_bsf_receive_packet(priv->bsfc, &filtered_packet);
-            if (ret < 0) {
-                av_log(avctx, AV_LOG_ERROR, "CrystalHD: mpv4toannexb filter "
-                       "failed to receive output packet\n");
-                return ret;
-            }
-
-            in_data = filtered_packet.data;
-            len = filtered_packet.size;
-
-            av_packet_unref(&filter_packet);
-        }
+    AVPacket filtered_packet = { 0 };
+    int ret = 0;
 
-        if (priv->parser) {
-            int ret = 0;
-
-            free_data = ret > 0;
-
-            if (ret >= 0) {
-                uint8_t *pout;
-                int psize;
-                int index;
-                H264Context *h = priv->parser->priv_data;
-
-                index = av_parser_parse2(priv->parser, avctx, &pout, &psize,
-                                         in_data, len, avpkt->pts,
-                                         avpkt->dts, 0);
-                if (index < 0) {
-                    av_log(avctx, AV_LOG_WARNING,
-                           "CrystalHD: Failed to parse h.264 packet to "
-                           "detect interlacing.\n");
-                } else if (index != len) {
-                    av_log(avctx, AV_LOG_WARNING,
-                           "CrystalHD: Failed to parse h.264 packet "
-                           "completely. Interlaced frames may be "
-                           "incorrectly detected.\n");
-                } else {
-                    av_log(avctx, AV_LOG_VERBOSE,
-                           "CrystalHD: parser picture type %d\n",
-                           h->picture_structure);
-                    pic_type = h->picture_structure;
-                }
-            } else {
-                av_log(avctx, AV_LOG_WARNING,
-                       "CrystalHD: mp4toannexb filter failed to filter "
-                       "packet. Interlaced frames may be incorrectly "
-                       "detected.\n");
-            }
-        }
+    av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: decode_packet\n");
 
-        if (len < tx_free - 1024) {
-            /*
-             * Despite being notionally opaque, either libcrystalhd or
-             * the hardware itself will mangle pts values that are too
-             * small or too large. The docs claim it should be in units
-             * of 100ns. Given that we're nominally dealing with a black
-             * box on both sides, any transform we do has no guarantee of
-             * avoiding mangling so we need to build a mapping to values
-             * we know will not be mangled.
-             */
-            int64_t safe_pts = avpkt->pts == AV_NOPTS_VALUE ? 0 : avpkt->pts;
-            uint64_t pts = opaque_list_push(priv, safe_pts, pic_type);
-            if (!pts) {
-                if (free_data) {
-                    av_freep(&in_data);
-                }
-                return AVERROR(ENOMEM);
-            }
-            av_log(priv->avctx, AV_LOG_VERBOSE,
-                   "input \"pts\": %"PRIu64"\n", pts);
-            ret = DtsProcInput(dev, in_data, len, pts, 0);
-            if (free_data) {
-                av_freep(&in_data);
-            }
-            if (ret == BC_STS_BUSY) {
-                av_log(avctx, AV_LOG_WARNING,
-                       "CrystalHD: ProcInput returned busy\n");
-                usleep(BASE_WAIT);
-                return AVERROR(EBUSY);
-            } else if (ret != BC_STS_SUCCESS) {
-                av_log(avctx, AV_LOG_ERROR,
-                       "CrystalHD: ProcInput failed: %u\n", ret);
-                return -1;
-            }
-            avctx->has_b_frames++;
-        } else {
-            av_log(avctx, AV_LOG_WARNING, "CrystalHD: Input buffer full\n");
-            len = 0; // We didn't consume any bytes.
+    if (avpkt && avpkt->size) {
+        uint64_t pts;
+
+        /*
+         * Despite being notionally opaque, either libcrystalhd or
+         * the hardware itself will mangle pts values that are too
+         * small or too large. The docs claim it should be in units
+         * of 100ns. Given that we're nominally dealing with a black
+         * box on both sides, any transform we do has no guarantee of
+         * avoiding mangling so we need to build a mapping to values
+         * we know will not be mangled.
+         */
+        pts = opaque_list_push(priv, avpkt->pts);
+        if (!pts) {
+            ret = AVERROR(ENOMEM);
+            goto exit;
+        }
+        av_log(priv->avctx, AV_LOG_VERBOSE,
+               "input \"pts\": %"PRIu64"\n", pts);
+        bc_ret = DtsProcInput(dev, avpkt->data, avpkt->size, pts, 0);
+        if (bc_ret == BC_STS_BUSY) {
+            av_log(avctx, AV_LOG_WARNING,
+                   "CrystalHD: ProcInput returned busy\n");
+            ret = AVERROR(EAGAIN);
+            goto exit;
+        } else if (bc_ret != BC_STS_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR,
+                   "CrystalHD: ProcInput failed: %u\n", ret);
+            ret = -1;
+            goto exit;
         }
     } else {
         av_log(avctx, AV_LOG_INFO, "CrystalHD: No more input data\n");
+        priv->draining = 1;
+        ret = AVERROR_EOF;
+        goto exit;
     }
+ exit:
+    av_packet_unref(&filtered_packet);
+    return ret;
+}
 
-    if (priv->skip_next_output) {
-        av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Skipping next output.\n");
-        priv->skip_next_output = 0;
-        avctx->has_b_frames--;
-        return len;
-    }
+static int crystalhd_receive_frame(AVCodecContext *avctx, AVFrame *frame)
+{
+    BC_STATUS bc_ret;
+    BC_DTS_STATUS decoder_status = { 0, };
+    CopyRet rec_ret;
+    CHDContext *priv   = avctx->priv_data;
+    HANDLE dev         = priv->dev;
+    int got_frame = 0;
+    int ret = 0;
+    AVPacket pkt = {0};
 
-    ret = DtsGetDriverStatus(dev, &decoder_status);
-    if (ret != BC_STS_SUCCESS) {
-        av_log(avctx, AV_LOG_ERROR, "CrystalHD: GetDriverStatus failed\n");
-        return -1;
+    av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: receive_frame\n");
+
+    ret = ff_decode_get_packet(avctx, &pkt);
+    if (ret < 0 && ret != AVERROR_EOF) {
+        return ret;
     }
 
-    /*
-     * No frames ready. Don't try to extract.
-     *
-     * Empirical testing shows that ReadyListCount can be a damn lie,
-     * and ProcOut still fails when count > 0. The same testing showed
-     * that two more iterations were needed before ProcOutput would
-     * succeed.
-     */
-    if (priv->output_ready < 2) {
-        if (decoder_status.ReadyListCount != 0)
-            priv->output_ready++;
-        usleep(BASE_WAIT);
-        av_log(avctx, AV_LOG_INFO, "CrystalHD: Filling pipeline.\n");
-        return len;
-    } else if (decoder_status.ReadyListCount == 0) {
+    while (pkt.size > DtsTxFreeSize(dev)) {
         /*
-         * After the pipeline is established, if we encounter a lack of frames
-         * that probably means we're not giving the hardware enough time to
-         * decode them, so start increasing the wait time at the end of a
-         * decode call.
+         * Block until there is space in the buffer for the next packet.
+         * We assume that the hardware will make forward progress at this
+         * point, although in pathological cases that may not happen.
          */
-        usleep(BASE_WAIT);
-        priv->decode_wait += WAIT_UNIT;
-        av_log(avctx, AV_LOG_INFO, "CrystalHD: No frames ready. Returning\n");
-        return len;
+        av_log(avctx, AV_LOG_TRACE, "CrystalHD: Waiting for space in input buffer\n");
+    }
+
+    ret = crystalhd_decode_packet(avctx, &pkt);
+    av_packet_unref(&pkt);
+    // crystalhd_is_buffer_full() should avoid this.
+    if (ret == AVERROR(EAGAIN)) {
+        ret = AVERROR_EXTERNAL;
+    }
+    if (ret < 0 && ret != AVERROR_EOF) {
+        return ret;
     }
 
     do {
-        rec_ret = receive_frame(avctx, data, got_frame);
-        if (rec_ret == RET_OK && *got_frame == 0) {
-            /*
-             * This case is for when the encoded fields are stored
-             * separately and we get a separate avpkt for each one. To keep
-             * the pipeline stable, we should return nothing and wait for
-             * the next time round to grab the second field.
-             * H.264 PAFF is an example of this.
-             */
-            av_log(avctx, AV_LOG_VERBOSE, "Returning after first field.\n");
-            avctx->has_b_frames--;
-        } else if (rec_ret == RET_COPY_NEXT_FIELD) {
-            /*
-             * This case is for when the encoded fields are stored in a
-             * single avpkt but the hardware returns then separately. Unless
-             * we grab the second field before returning, we'll slip another
-             * frame in the pipeline and if that happens a lot, we're sunk.
-             * So we have to get that second field now.
-             * Interlaced mpeg2 and vc1 are examples of this.
-             */
-            av_log(avctx, AV_LOG_VERBOSE, "Trying to get second field.\n");
-            while (1) {
-                usleep(priv->decode_wait);
-                ret = DtsGetDriverStatus(dev, &decoder_status);
-                if (ret == BC_STS_SUCCESS &&
-                    decoder_status.ReadyListCount > 0) {
-                    rec_ret = receive_frame(avctx, data, got_frame);
-                    if ((rec_ret == RET_OK && *got_frame > 0) ||
-                        rec_ret == RET_ERROR)
-                        break;
-                }
-            }
-            av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Got second field.\n");
-        } else if (rec_ret == RET_SKIP_NEXT_COPY) {
-            /*
-             * Two input packets got turned into a field pair. Gawd.
-             */
-            av_log(avctx, AV_LOG_VERBOSE,
-                   "Don't output on next decode call.\n");
-            priv->skip_next_output = 1;
+        bc_ret = DtsGetDriverStatus(dev, &decoder_status);
+        if (bc_ret != BC_STS_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "CrystalHD: GetDriverStatus failed\n");
+            return -1;
         }
-        /*
-         * If rec_ret == RET_COPY_AGAIN, that means that either we just handled
-         * a FMT_CHANGE event and need to go around again for the actual frame,
-         * we got a busy status and need to try again, or we're dealing with
-         * packed b-frames, where the hardware strangely returns the packed
-         * p-frame twice. We choose to keep the second copy as it carries the
-         * valid pts.
-         */
+
+        if (decoder_status.ReadyListCount == 0) {
+            av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Insufficient frames ready. Returning\n");
+            got_frame = 0;
+            rec_ret = RET_OK;
+            break;
+        }
+
+        rec_ret = receive_frame(avctx, frame, &got_frame);
     } while (rec_ret == RET_COPY_AGAIN);
-    usleep(priv->decode_wait);
-    return len;
+
+    if (rec_ret == RET_ERROR) {
+        return -1;
+    } else if (got_frame == 0) {
+        return priv->draining ? AVERROR_EOF : AVERROR(EAGAIN);
+    } else {
+        return 0;
+    }
 }
 
+#define DEFINE_CRYSTALHD_DECODER(x, X, bsf_name) \
+    static const AVClass x##_crystalhd_class = { \
+        .class_name = #x "_crystalhd", \
+        .item_name = av_default_item_name, \
+        .option = options, \
+        .version = LIBAVUTIL_VERSION_INT, \
+    }; \
+    AVCodec ff_##x##_crystalhd_decoder = { \
+        .name           = #x "_crystalhd", \
+        .long_name      = NULL_IF_CONFIG_SMALL("CrystalHD " #X " decoder"), \
+        .type           = AVMEDIA_TYPE_VIDEO, \
+        .id             = AV_CODEC_ID_##X, \
+        .priv_data_size = sizeof(CHDContext), \
+        .priv_class     = &x##_crystalhd_class, \
+        .init           = init, \
+        .close          = uninit, \
+        .receive_frame  = crystalhd_receive_frame, \
+        .flush          = flush, \
+        .bsfs           = bsf_name, \
+        .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING, \
+        .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE}, \
+    };
 
 #if CONFIG_H264_CRYSTALHD_DECODER
-static AVClass h264_class = {
-    "h264_crystalhd",
-    av_default_item_name,
-    options,
-    LIBAVUTIL_VERSION_INT,
-};
-
-AVCodec ff_h264_crystalhd_decoder = {
-    .name           = "h264_crystalhd",
-    .long_name      = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (CrystalHD acceleration)"),
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_H264,
-    .priv_data_size = sizeof(CHDContext),
-    .init           = init,
-    .close          = uninit,
-    .decode         = decode,
-    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
-    .flush          = flush,
-    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
-    .priv_class     = &h264_class,
-};
+DEFINE_CRYSTALHD_DECODER(h264, H264, "h264_mp4toannexb")
 #endif
 
 #if CONFIG_MPEG2_CRYSTALHD_DECODER
-static AVClass mpeg2_class = {
-    "mpeg2_crystalhd",
-    av_default_item_name,
-    options,
-    LIBAVUTIL_VERSION_INT,
-};
-
-AVCodec ff_mpeg2_crystalhd_decoder = {
-    .name           = "mpeg2_crystalhd",
-    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 Video (CrystalHD acceleration)"),
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_MPEG2VIDEO,
-    .priv_data_size = sizeof(CHDContext),
-    .init           = init,
-    .close          = uninit,
-    .decode         = decode,
-    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
-    .flush          = flush,
-    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
-    .priv_class     = &mpeg2_class,
-};
+DEFINE_CRYSTALHD_DECODER(mpeg2, MPEG2VIDEO, NULL)
 #endif
 
 #if CONFIG_MPEG4_CRYSTALHD_DECODER
-static AVClass mpeg4_class = {
-    "mpeg4_crystalhd",
-    av_default_item_name,
-    options,
-    LIBAVUTIL_VERSION_INT,
-};
-
-AVCodec ff_mpeg4_crystalhd_decoder = {
-    .name           = "mpeg4_crystalhd",
-    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 (CrystalHD acceleration)"),
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_MPEG4,
-    .priv_data_size = sizeof(CHDContext),
-    .init           = init,
-    .close          = uninit,
-    .decode         = decode,
-    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
-    .flush          = flush,
-    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
-    .priv_class     = &mpeg4_class,
-};
+DEFINE_CRYSTALHD_DECODER(mpeg4, MPEG4, "mpeg4_unpack_bframes")
 #endif
 
 #if CONFIG_MSMPEG4_CRYSTALHD_DECODER
-static AVClass msmpeg4_class = {
-    "msmpeg4_crystalhd",
-    av_default_item_name,
-    options,
-    LIBAVUTIL_VERSION_INT,
-};
-
-AVCodec ff_msmpeg4_crystalhd_decoder = {
-    .name           = "msmpeg4_crystalhd",
-    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 Microsoft variant version 3 (CrystalHD acceleration)"),
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_MSMPEG4V3,
-    .priv_data_size = sizeof(CHDContext),
-    .init           = init,
-    .close          = uninit,
-    .decode         = decode,
-    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_EXPERIMENTAL,
-    .flush          = flush,
-    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
-    .priv_class     = &msmpeg4_class,
-};
+DEFINE_CRYSTALHD_DECODER(msmpeg4, MSMPEG4V3, NULL)
 #endif
 
 #if CONFIG_VC1_CRYSTALHD_DECODER
-static AVClass vc1_class = {
-    "vc1_crystalhd",
-    av_default_item_name,
-    options,
-    LIBAVUTIL_VERSION_INT,
-};
-
-AVCodec ff_vc1_crystalhd_decoder = {
-    .name           = "vc1_crystalhd",
-    .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 (CrystalHD acceleration)"),
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_VC1,
-    .priv_data_size = sizeof(CHDContext),
-    .init           = init,
-    .close          = uninit,
-    .decode         = decode,
-    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
-    .flush          = flush,
-    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
-    .priv_class     = &vc1_class,
-};
+DEFINE_CRYSTALHD_DECODER(vc1, VC1, NULL)
 #endif
 
 #if CONFIG_WMV3_CRYSTALHD_DECODER
-static AVClass wmv3_class = {
-    "wmv3_crystalhd",
-    av_default_item_name,
-    options,
-    LIBAVUTIL_VERSION_INT,
-};
-
-AVCodec ff_wmv3_crystalhd_decoder = {
-    .name           = "wmv3_crystalhd",
-    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 (CrystalHD acceleration)"),
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_WMV3,
-    .priv_data_size = sizeof(CHDContext),
-    .init           = init,
-    .close          = uninit,
-    .decode         = decode,
-    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
-    .flush          = flush,
-    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
-    .priv_class     = &wmv3_class,
-};
+DEFINE_CRYSTALHD_DECODER(wmv3, WMV3, NULL)
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/cuvid.c b/mythtv/external/FFmpeg/libavcodec/cuvid.c
index 24ade94ab9a..2ba8e00c6af 100644
--- a/mythtv/external/FFmpeg/libavcodec/cuvid.c
+++ b/mythtv/external/FFmpeg/libavcodec/cuvid.c
@@ -19,21 +19,21 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "compat/cuda/dynlink_loader.h"
+
 #include "libavutil/buffer.h"
 #include "libavutil/mathematics.h"
 #include "libavutil/hwcontext.h"
-#include "libavutil/hwcontext_cuda.h"
+#include "libavutil/hwcontext_cuda_internal.h"
 #include "libavutil/fifo.h"
 #include "libavutil/log.h"
 #include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
 
 #include "avcodec.h"
+#include "decode.h"
 #include "internal.h"
 
-#include "compat/cuda/nvcuvid.h"
-
-#define MAX_FRAME_COUNT 25
-
 typedef struct CuvidContext
 {
     AVClass *avclass;
@@ -42,6 +42,22 @@ typedef struct CuvidContext
     CUvideoparser cuparser;
 
     char *cu_gpu;
+    int nb_surfaces;
+    int drop_second_field;
+    char *crop_expr;
+    char *resize_expr;
+
+    struct {
+        int left;
+        int top;
+        int right;
+        int bottom;
+    } crop;
+
+    struct {
+        int width;
+        int height;
+    } resize;
 
     AVBufferRef *hwdevice;
     AVBufferRef *hwframe;
@@ -51,6 +67,7 @@ typedef struct CuvidContext
     AVFifoBuffer *frame_queue;
 
     int deint_mode;
+    int deint_mode_current;
     int64_t prev_pts;
 
     int internal_error;
@@ -59,8 +76,13 @@ typedef struct CuvidContext
     cudaVideoCodec codec_type;
     cudaVideoChromaFormat chroma_format;
 
+    CUVIDDECODECAPS caps8, caps10, caps12;
+
     CUVIDPARSERPARAMS cuparseinfo;
     CUVIDEOFORMATEX cuparse_ext;
+
+    CudaFunctions *cudl;
+    CuvidFunctions *cvdl;
 } CuvidContext;
 
 typedef struct CuvidParsedFrame
@@ -72,6 +94,7 @@ typedef struct CuvidParsedFrame
 
 static int check_cu(AVCodecContext *avctx, CUresult err, const char *func)
 {
+    CuvidContext *ctx = avctx->priv_data;
     const char *err_name;
     const char *err_string;
 
@@ -80,8 +103,8 @@ static int check_cu(AVCodecContext *avctx, CUresult err, const char *func)
     if (err == CUDA_SUCCESS)
         return 0;
 
-    cuGetErrorName(err, &err_name);
-    cuGetErrorString(err, &err_string);
+    ctx->cudl->cuGetErrorName(err, &err_name);
+    ctx->cudl->cuGetErrorString(err, &err_string);
 
     av_log(avctx, AV_LOG_ERROR, "%s failed", func);
     if (err_name && err_string)
@@ -98,20 +121,111 @@ static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT* form
     AVCodecContext *avctx = opaque;
     CuvidContext *ctx = avctx->priv_data;
     AVHWFramesContext *hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
+    CUVIDDECODECAPS *caps = NULL;
     CUVIDDECODECREATEINFO cuinfo;
+    int surface_fmt;
+
+    int old_width = avctx->width;
+    int old_height = avctx->height;
+
+    enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
+                                       AV_PIX_FMT_NONE,  // Will be updated below
+                                       AV_PIX_FMT_NONE };
 
     av_log(avctx, AV_LOG_TRACE, "pfnSequenceCallback, progressive_sequence=%d\n", format->progressive_sequence);
 
+    memset(&cuinfo, 0, sizeof(cuinfo));
+
     ctx->internal_error = 0;
 
-    avctx->width = format->display_area.right;
-    avctx->height = format->display_area.bottom;
+    avctx->coded_width = cuinfo.ulWidth = format->coded_width;
+    avctx->coded_height = cuinfo.ulHeight = format->coded_height;
+
+    // apply cropping
+    cuinfo.display_area.left = format->display_area.left + ctx->crop.left;
+    cuinfo.display_area.top = format->display_area.top + ctx->crop.top;
+    cuinfo.display_area.right = format->display_area.right - ctx->crop.right;
+    cuinfo.display_area.bottom = format->display_area.bottom - ctx->crop.bottom;
+
+    // width and height need to be set before calling ff_get_format
+    if (ctx->resize_expr) {
+        avctx->width = ctx->resize.width;
+        avctx->height = ctx->resize.height;
+    } else {
+        avctx->width = cuinfo.display_area.right - cuinfo.display_area.left;
+        avctx->height = cuinfo.display_area.bottom - cuinfo.display_area.top;
+    }
+
+    // target width/height need to be multiples of two
+    cuinfo.ulTargetWidth = avctx->width = (avctx->width + 1) & ~1;
+    cuinfo.ulTargetHeight = avctx->height = (avctx->height + 1) & ~1;
+
+    // aspect ratio conversion, 1:1, depends on scaled resolution
+    cuinfo.target_rect.left = 0;
+    cuinfo.target_rect.top = 0;
+    cuinfo.target_rect.right = cuinfo.ulTargetWidth;
+    cuinfo.target_rect.bottom = cuinfo.ulTargetHeight;
+
+    switch (format->bit_depth_luma_minus8) {
+    case 0: // 8-bit
+        pix_fmts[1] = AV_PIX_FMT_NV12;
+        caps = &ctx->caps8;
+        break;
+    case 2: // 10-bit
+        pix_fmts[1] = AV_PIX_FMT_P010;
+        caps = &ctx->caps10;
+        break;
+    case 4: // 12-bit
+        pix_fmts[1] = AV_PIX_FMT_P016;
+        caps = &ctx->caps12;
+        break;
+    default:
+        break;
+    }
+
+    if (!caps || !caps->bIsSupported) {
+        av_log(avctx, AV_LOG_ERROR, "unsupported bit depth: %d\n",
+               format->bit_depth_luma_minus8 + 8);
+        ctx->internal_error = AVERROR(EINVAL);
+        return 0;
+    }
+
+    surface_fmt = ff_get_format(avctx, pix_fmts);
+    if (surface_fmt < 0) {
+        av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", surface_fmt);
+        ctx->internal_error = AVERROR(EINVAL);
+        return 0;
+    }
+
+    av_log(avctx, AV_LOG_VERBOSE, "Formats: Original: %s | HW: %s | SW: %s\n",
+           av_get_pix_fmt_name(avctx->pix_fmt),
+           av_get_pix_fmt_name(surface_fmt),
+           av_get_pix_fmt_name(avctx->sw_pix_fmt));
+
+    avctx->pix_fmt = surface_fmt;
+
+    // Update our hwframe ctx, as the get_format callback might have refreshed it!
+    if (avctx->hw_frames_ctx) {
+        av_buffer_unref(&ctx->hwframe);
+
+        ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
+        if (!ctx->hwframe) {
+            ctx->internal_error = AVERROR(ENOMEM);
+            return 0;
+        }
+
+        hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
+    }
 
     ff_set_sar(avctx, av_div_q(
         (AVRational){ format->display_aspect_ratio.x, format->display_aspect_ratio.y },
         (AVRational){ avctx->width, avctx->height }));
 
-    if (!format->progressive_sequence && ctx->deint_mode == cudaVideoDeinterlaceMode_Weave)
+    ctx->deint_mode_current = format->progressive_sequence
+                              ? cudaVideoDeinterlaceMode_Weave
+                              : ctx->deint_mode;
+
+    if (!format->progressive_sequence && ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave)
         avctx->flags |= AV_CODEC_FLAG_INTERLACED_DCT;
     else
         avctx->flags &= ~AV_CODEC_FLAG_INTERLACED_DCT;
@@ -136,13 +250,15 @@ static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT* form
     if (ctx->cudecoder
             && avctx->coded_width == format->coded_width
             && avctx->coded_height == format->coded_height
+            && avctx->width == old_width
+            && avctx->height == old_height
             && ctx->chroma_format == format->chroma_format
             && ctx->codec_type == format->codec)
         return 1;
 
     if (ctx->cudecoder) {
         av_log(avctx, AV_LOG_TRACE, "Re-initializing decoder\n");
-        ctx->internal_error = CHECK_CU(cuvidDestroyDecoder(ctx->cudecoder));
+        ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder));
         if (ctx->internal_error < 0)
             return 0;
         ctx->cudecoder = NULL;
@@ -152,8 +268,13 @@ static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT* form
             hwframe_ctx->width < avctx->width ||
             hwframe_ctx->height < avctx->height ||
             hwframe_ctx->format != AV_PIX_FMT_CUDA ||
-            hwframe_ctx->sw_format != AV_PIX_FMT_NV12)) {
+            hwframe_ctx->sw_format != avctx->sw_pix_fmt)) {
         av_log(avctx, AV_LOG_ERROR, "AVHWFramesContext is already initialized with incompatible parameters\n");
+        av_log(avctx, AV_LOG_DEBUG, "width: %d <-> %d\n", hwframe_ctx->width, avctx->width);
+        av_log(avctx, AV_LOG_DEBUG, "height: %d <-> %d\n", hwframe_ctx->height, avctx->height);
+        av_log(avctx, AV_LOG_DEBUG, "format: %s <-> cuda\n", av_get_pix_fmt_name(hwframe_ctx->format));
+        av_log(avctx, AV_LOG_DEBUG, "sw_format: %s <-> %s\n",
+               av_get_pix_fmt_name(hwframe_ctx->sw_format), av_get_pix_fmt_name(avctx->sw_pix_fmt));
         ctx->internal_error = AVERROR(EINVAL);
         return 0;
     }
@@ -164,48 +285,41 @@ static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT* form
         return 0;
     }
 
-    avctx->coded_width = format->coded_width;
-    avctx->coded_height = format->coded_height;
-
     ctx->chroma_format = format->chroma_format;
 
-    memset(&cuinfo, 0, sizeof(cuinfo));
-
     cuinfo.CodecType = ctx->codec_type = format->codec;
     cuinfo.ChromaFormat = format->chroma_format;
-    cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
-
-    cuinfo.ulWidth = avctx->coded_width;
-    cuinfo.ulHeight = avctx->coded_height;
-    cuinfo.ulTargetWidth = cuinfo.ulWidth;
-    cuinfo.ulTargetHeight = cuinfo.ulHeight;
 
-    cuinfo.target_rect.left = 0;
-    cuinfo.target_rect.top = 0;
-    cuinfo.target_rect.right = cuinfo.ulWidth;
-    cuinfo.target_rect.bottom = cuinfo.ulHeight;
+    switch (avctx->sw_pix_fmt) {
+    case AV_PIX_FMT_NV12:
+        cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
+        break;
+    case AV_PIX_FMT_P010:
+    case AV_PIX_FMT_P016:
+        cuinfo.OutputFormat = cudaVideoSurfaceFormat_P016;
+        break;
+    default:
+        av_log(avctx, AV_LOG_ERROR, "Output formats other than NV12, P010 or P016 are not supported\n");
+        ctx->internal_error = AVERROR(EINVAL);
+        return 0;
+    }
 
-    cuinfo.ulNumDecodeSurfaces = MAX_FRAME_COUNT;
+    cuinfo.ulNumDecodeSurfaces = ctx->nb_surfaces;
     cuinfo.ulNumOutputSurfaces = 1;
     cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
     cuinfo.bitDepthMinus8 = format->bit_depth_luma_minus8;
+    cuinfo.DeinterlaceMode = ctx->deint_mode_current;
 
-    if (format->progressive_sequence) {
-        ctx->deint_mode = cuinfo.DeinterlaceMode = cudaVideoDeinterlaceMode_Weave;
-    } else {
-        cuinfo.DeinterlaceMode = ctx->deint_mode;
-    }
-
-    if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave)
+    if (ctx->deint_mode_current != cudaVideoDeinterlaceMode_Weave && !ctx->drop_second_field)
         avctx->framerate = av_mul_q(avctx->framerate, (AVRational){2, 1});
 
-    ctx->internal_error = CHECK_CU(cuvidCreateDecoder(&ctx->cudecoder, &cuinfo));
+    ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidCreateDecoder(&ctx->cudecoder, &cuinfo));
     if (ctx->internal_error < 0)
         return 0;
 
     if (!hwframe_ctx->pool) {
         hwframe_ctx->format = AV_PIX_FMT_CUDA;
-        hwframe_ctx->sw_format = AV_PIX_FMT_NV12;
+        hwframe_ctx->sw_format = avctx->sw_pix_fmt;
         hwframe_ctx->width = avctx->width;
         hwframe_ctx->height = avctx->height;
 
@@ -225,7 +339,7 @@ static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS* pic
 
     av_log(avctx, AV_LOG_TRACE, "pfnDecodePicture\n");
 
-    ctx->internal_error = CHECK_CU(cuvidDecodePicture(ctx->cudecoder, picparams));
+    ctx->internal_error = CHECK_CU(ctx->cvdl->cuvidDecodePicture(ctx->cudecoder, picparams));
     if (ctx->internal_error < 0)
         return 0;
 
@@ -236,22 +350,32 @@ static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINF
 {
     AVCodecContext *avctx = opaque;
     CuvidContext *ctx = avctx->priv_data;
-    CuvidParsedFrame parsed_frame = { *dispinfo, 0, 0 };
+    CuvidParsedFrame parsed_frame = { { 0 } };
 
+    parsed_frame.dispinfo = *dispinfo;
     ctx->internal_error = 0;
 
-    if (ctx->deint_mode == cudaVideoDeinterlaceMode_Weave) {
+    if (ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave) {
         av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
     } else {
         parsed_frame.is_deinterlacing = 1;
         av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
-        parsed_frame.second_field = 1;
-        av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
+        if (!ctx->drop_second_field) {
+            parsed_frame.second_field = 1;
+            av_fifo_generic_write(ctx->frame_queue, &parsed_frame, sizeof(CuvidParsedFrame), NULL);
+        }
     }
 
     return 1;
 }
 
+static int cuvid_is_buffer_full(AVCodecContext *avctx)
+{
+    CuvidContext *ctx = avctx->priv_data;
+
+    return (av_fifo_size(ctx->frame_queue) / sizeof(CuvidParsedFrame)) + 2 > ctx->nb_surfaces;
+}
+
 static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
 {
     CuvidContext *ctx = avctx->priv_data;
@@ -268,7 +392,7 @@ static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
     if (is_flush && avpkt && avpkt->size)
         return AVERROR_EOF;
 
-    if (av_fifo_size(ctx->frame_queue) / sizeof(CuvidParsedFrame) > MAX_FRAME_COUNT - 2 && avpkt && avpkt->size)
+    if (cuvid_is_buffer_full(avctx) && avpkt && avpkt->size)
         return AVERROR(EAGAIN);
 
     if (ctx->bsf && avpkt && avpkt->size) {
@@ -291,7 +415,7 @@ static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
         avpkt = &filtered_packet;
     }
 
-    ret = CHECK_CU(cuCtxPushCurrent(cuda_ctx));
+    ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
     if (ret < 0) {
         av_packet_unref(&filtered_packet);
         return ret;
@@ -315,7 +439,7 @@ static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
         ctx->decoder_flushing = 1;
     }
 
-    ret = CHECK_CU(cuvidParseVideoData(ctx->cuparser, &cupkt));
+    ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &cupkt));
 
     av_packet_unref(&filtered_packet);
 
@@ -330,7 +454,7 @@ static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
     }
 
 error:
-    eret = CHECK_CU(cuCtxPopCurrent(&dummy));
+    eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
 
     if (eret < 0)
         return eret;
@@ -359,7 +483,21 @@ static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
             return ret;
     }
 
-    ret = CHECK_CU(cuCtxPushCurrent(cuda_ctx));
+    if (!cuvid_is_buffer_full(avctx)) {
+        AVPacket pkt = {0};
+        ret = ff_decode_get_packet(avctx, &pkt);
+        if (ret < 0 && ret != AVERROR_EOF)
+            return ret;
+        ret = cuvid_decode_packet(avctx, &pkt);
+        av_packet_unref(&pkt);
+        // cuvid_is_buffer_full() should avoid this.
+        if (ret == AVERROR(EAGAIN))
+            ret = AVERROR_EXTERNAL;
+        if (ret < 0 && ret != AVERROR_EOF)
+            return ret;
+    }
+
+    ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
     if (ret < 0)
         return ret;
 
@@ -377,7 +515,7 @@ static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
         params.second_field = parsed_frame.second_field;
         params.top_field_first = parsed_frame.dispinfo.top_field_first;
 
-        ret = CHECK_CU(cuvidMapVideoFrame(ctx->cudecoder, parsed_frame.dispinfo.picture_index, &mapped_frame, &pitch, &params));
+        ret = CHECK_CU(ctx->cvdl->cuvidMapVideoFrame(ctx->cudecoder, parsed_frame.dispinfo.picture_index, &mapped_frame, &pitch, &params));
         if (ret < 0)
             goto error;
 
@@ -407,13 +545,15 @@ static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
                     .Height        = avctx->height >> (i ? 1 : 0),
                 };
 
-                ret = CHECK_CU(cuMemcpy2D(&cpy));
+                ret = CHECK_CU(ctx->cudl->cuMemcpy2D(&cpy));
                 if (ret < 0)
                     goto error;
 
-                offset += avctx->coded_height;
+                offset += avctx->height;
             }
-        } else if (avctx->pix_fmt == AV_PIX_FMT_NV12) {
+        } else if (avctx->pix_fmt == AV_PIX_FMT_NV12 ||
+                   avctx->pix_fmt == AV_PIX_FMT_P010 ||
+                   avctx->pix_fmt == AV_PIX_FMT_P016) {
             AVFrame *tmp_frame = av_frame_alloc();
             if (!tmp_frame) {
                 av_log(avctx, AV_LOG_ERROR, "av_frame_alloc failed\n");
@@ -425,7 +565,7 @@ static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
             tmp_frame->hw_frames_ctx = av_buffer_ref(ctx->hwframe);
             tmp_frame->data[0]       = (uint8_t*)mapped_frame;
             tmp_frame->linesize[0]   = pitch;
-            tmp_frame->data[1]       = (uint8_t*)(mapped_frame + avctx->coded_height * pitch);
+            tmp_frame->data[1]       = (uint8_t*)(mapped_frame + avctx->height * pitch);
             tmp_frame->linesize[1]   = pitch;
             tmp_frame->width         = avctx->width;
             tmp_frame->height        = avctx->height;
@@ -443,7 +583,6 @@ static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
                 av_frame_free(&tmp_frame);
                 goto error;
             }
-
             av_frame_free(&tmp_frame);
         } else {
             ret = AVERROR_BUG;
@@ -476,9 +615,9 @@ FF_DISABLE_DEPRECATION_WARNINGS
         frame->pkt_pts = frame->pts;
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
-        av_frame_set_pkt_pos(frame, -1);
-        av_frame_set_pkt_duration(frame, 0);
-        av_frame_set_pkt_size(frame, -1);
+        frame->pkt_pos = -1;
+        frame->pkt_duration = 0;
+        frame->pkt_size = -1;
 
         frame->interlaced_frame = !parsed_frame.is_deinterlacing && !parsed_frame.dispinfo.progressive_frame;
 
@@ -492,9 +631,9 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
 error:
     if (mapped_frame)
-        eret = CHECK_CU(cuvidUnmapVideoFrame(ctx->cudecoder, mapped_frame));
+        eret = CHECK_CU(ctx->cvdl->cuvidUnmapVideoFrame(ctx->cudecoder, mapped_frame));
 
-    eret = CHECK_CU(cuCtxPopCurrent(&dummy));
+    eret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
 
     if (eret < 0)
         return eret;
@@ -510,7 +649,7 @@ static int cuvid_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 
     av_log(avctx, AV_LOG_TRACE, "cuvid_decode_frame\n");
 
-    if (ctx->deint_mode != cudaVideoDeinterlaceMode_Weave) {
+    if (ctx->deint_mode_current != cudaVideoDeinterlaceMode_Weave) {
         av_log(avctx, AV_LOG_ERROR, "Deinterlacing is not supported via the old API\n");
         return AVERROR(EINVAL);
     }
@@ -543,53 +682,105 @@ static av_cold int cuvid_decode_end(AVCodecContext *avctx)
         av_bsf_free(&ctx->bsf);
 
     if (ctx->cuparser)
-        cuvidDestroyVideoParser(ctx->cuparser);
+        ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
 
     if (ctx->cudecoder)
-        cuvidDestroyDecoder(ctx->cudecoder);
+        ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
+
+    ctx->cudl = NULL;
 
     av_buffer_unref(&ctx->hwframe);
     av_buffer_unref(&ctx->hwdevice);
 
+    cuvid_free_functions(&ctx->cvdl);
+
     return 0;
 }
 
-static int cuvid_test_dummy_decoder(AVCodecContext *avctx, CUVIDPARSERPARAMS *cuparseinfo)
+static int cuvid_test_capabilities(AVCodecContext *avctx,
+                                   const CUVIDPARSERPARAMS *cuparseinfo,
+                                   int probed_width,
+                                   int probed_height,
+                                   int bit_depth)
 {
-    CUVIDDECODECREATEINFO cuinfo;
-    CUvideodecoder cudec = 0;
-    int ret = 0;
-
-    memset(&cuinfo, 0, sizeof(cuinfo));
-
-    cuinfo.CodecType = cuparseinfo->CodecType;
-    cuinfo.ChromaFormat = cudaVideoChromaFormat_420;
-    cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
-
-    cuinfo.ulWidth = 1280;
-    cuinfo.ulHeight = 720;
-    cuinfo.ulTargetWidth = cuinfo.ulWidth;
-    cuinfo.ulTargetHeight = cuinfo.ulHeight;
+    CuvidContext *ctx = avctx->priv_data;
+    CUVIDDECODECAPS *caps;
+    int res8 = 0, res10 = 0, res12 = 0;
+
+    if (!ctx->cvdl->cuvidGetDecoderCaps) {
+        av_log(avctx, AV_LOG_WARNING, "Used Nvidia driver is too old to perform a capability check.\n");
+        av_log(avctx, AV_LOG_WARNING, "The minimum required version is "
+#if defined(_WIN32) || defined(__CYGWIN__)
+            "378.66"
+#else
+            "378.13"
+#endif
+            ". Continuing blind.\n");
+        ctx->caps8.bIsSupported = ctx->caps10.bIsSupported = 1;
+        // 12 bit was not supported before the capability check was introduced, so disable it.
+        ctx->caps12.bIsSupported = 0;
+        return 0;
+    }
 
-    cuinfo.target_rect.left = 0;
-    cuinfo.target_rect.top = 0;
-    cuinfo.target_rect.right = cuinfo.ulWidth;
-    cuinfo.target_rect.bottom = cuinfo.ulHeight;
+    ctx->caps8.eCodecType = ctx->caps10.eCodecType = ctx->caps12.eCodecType
+        = cuparseinfo->CodecType;
+    ctx->caps8.eChromaFormat = ctx->caps10.eChromaFormat = ctx->caps12.eChromaFormat
+        = cudaVideoChromaFormat_420;
+
+    ctx->caps8.nBitDepthMinus8 = 0;
+    ctx->caps10.nBitDepthMinus8 = 2;
+    ctx->caps12.nBitDepthMinus8 = 4;
+
+    res8 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps8));
+    res10 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps10));
+    res12 = CHECK_CU(ctx->cvdl->cuvidGetDecoderCaps(&ctx->caps12));
+
+    av_log(avctx, AV_LOG_VERBOSE, "CUVID capabilities for %s:\n", avctx->codec->name);
+    av_log(avctx, AV_LOG_VERBOSE, "8 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
+           ctx->caps8.bIsSupported, ctx->caps8.nMinWidth, ctx->caps8.nMaxWidth, ctx->caps8.nMinHeight, ctx->caps8.nMaxHeight);
+    av_log(avctx, AV_LOG_VERBOSE, "10 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
+           ctx->caps10.bIsSupported, ctx->caps10.nMinWidth, ctx->caps10.nMaxWidth, ctx->caps10.nMinHeight, ctx->caps10.nMaxHeight);
+    av_log(avctx, AV_LOG_VERBOSE, "12 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
+           ctx->caps12.bIsSupported, ctx->caps12.nMinWidth, ctx->caps12.nMaxWidth, ctx->caps12.nMinHeight, ctx->caps12.nMaxHeight);
+
+    switch (bit_depth) {
+    case 10:
+        caps = &ctx->caps10;
+        if (res10 < 0)
+            return res10;
+        break;
+    case 12:
+        caps = &ctx->caps12;
+        if (res12 < 0)
+            return res12;
+        break;
+    default:
+        caps = &ctx->caps8;
+        if (res8 < 0)
+            return res8;
+    }
 
-    cuinfo.ulNumDecodeSurfaces = MAX_FRAME_COUNT;
-    cuinfo.ulNumOutputSurfaces = 1;
-    cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
-    cuinfo.bitDepthMinus8 = 0;
+    if (!ctx->caps8.bIsSupported) {
+        av_log(avctx, AV_LOG_ERROR, "Codec %s is not supported.\n", avctx->codec->name);
+        return AVERROR(EINVAL);
+    }
 
-    cuinfo.DeinterlaceMode = cudaVideoDeinterlaceMode_Weave;
+    if (!caps->bIsSupported) {
+        av_log(avctx, AV_LOG_ERROR, "Bit depth %d is not supported.\n", bit_depth);
+        return AVERROR(EINVAL);
+    }
 
-    ret = CHECK_CU(cuvidCreateDecoder(&cudec, &cuinfo));
-    if (ret < 0)
-        return ret;
+    if (probed_width > caps->nMaxWidth || probed_width < caps->nMinWidth) {
+        av_log(avctx, AV_LOG_ERROR, "Video width %d not within range from %d to %d\n",
+               probed_width, caps->nMinWidth, caps->nMaxWidth);
+        return AVERROR(EINVAL);
+    }
 
-    ret = CHECK_CU(cuvidDestroyDecoder(cudec));
-    if (ret < 0)
-        return ret;
+    if (probed_height > caps->nMaxHeight || probed_height < caps->nMinHeight) {
+        av_log(avctx, AV_LOG_ERROR, "Video height %d not within range from %d to %d\n",
+               probed_height, caps->nMinHeight, caps->nMaxHeight);
+        return AVERROR(EINVAL);
+    }
 
     return 0;
 }
@@ -610,20 +801,52 @@ static av_cold int cuvid_decode_init(AVCodecContext *avctx)
                                        AV_PIX_FMT_NV12,
                                        AV_PIX_FMT_NONE };
 
+    int probed_width = avctx->coded_width ? avctx->coded_width : 1280;
+    int probed_height = avctx->coded_height ? avctx->coded_height : 720;
+    int probed_bit_depth = 8;
+
+    const AVPixFmtDescriptor *probe_desc = av_pix_fmt_desc_get(avctx->pix_fmt);
+    if (probe_desc && probe_desc->nb_components)
+        probed_bit_depth = probe_desc->comp[0].depth;
+
+    // Accelerated transcoding scenarios with 'ffmpeg' require that the
+    // pix_fmt be set to AV_PIX_FMT_CUDA early. The sw_pix_fmt, and the
+    // pix_fmt for non-accelerated transcoding, do not need to be correct
+    // but need to be set to something. We arbitrarily pick NV12.
     ret = ff_get_format(avctx, pix_fmts);
     if (ret < 0) {
         av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", ret);
         return ret;
     }
+    avctx->pix_fmt = ret;
+
+    if (ctx->resize_expr && sscanf(ctx->resize_expr, "%dx%d",
+                                   &ctx->resize.width, &ctx->resize.height) != 2) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid resize expressions\n");
+        ret = AVERROR(EINVAL);
+        goto error;
+    }
+
+    if (ctx->crop_expr && sscanf(ctx->crop_expr, "%dx%dx%dx%d",
+                                 &ctx->crop.top, &ctx->crop.bottom,
+                                 &ctx->crop.left, &ctx->crop.right) != 4) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid cropping expressions\n");
+        ret = AVERROR(EINVAL);
+        goto error;
+    }
+
+    ret = cuvid_load_functions(&ctx->cvdl);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed loading nvcuvid.\n");
+        goto error;
+    }
 
-    ctx->frame_queue = av_fifo_alloc(MAX_FRAME_COUNT * sizeof(CuvidParsedFrame));
+    ctx->frame_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(CuvidParsedFrame));
     if (!ctx->frame_queue) {
         ret = AVERROR(ENOMEM);
         goto error;
     }
 
-    avctx->pix_fmt = ret;
-
     if (avctx->hw_frames_ctx) {
         ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
         if (!ctx->hwframe) {
@@ -639,9 +862,17 @@ static av_cold int cuvid_decode_init(AVCodecContext *avctx)
             goto error;
         }
     } else {
-        ret = av_hwdevice_ctx_create(&ctx->hwdevice, AV_HWDEVICE_TYPE_CUDA, ctx->cu_gpu, NULL, 0);
-        if (ret < 0)
-            goto error;
+        if (avctx->hw_device_ctx) {
+            ctx->hwdevice = av_buffer_ref(avctx->hw_device_ctx);
+            if (!ctx->hwdevice) {
+                ret = AVERROR(ENOMEM);
+                goto error;
+            }
+        } else {
+            ret = av_hwdevice_ctx_create(&ctx->hwdevice, AV_HWDEVICE_TYPE_CUDA, ctx->cu_gpu, NULL, 0);
+            if (ret < 0)
+                goto error;
+        }
 
         ctx->hwframe = av_hwframe_ctx_alloc(ctx->hwdevice);
         if (!ctx->hwframe) {
@@ -655,7 +886,9 @@ static av_cold int cuvid_decode_init(AVCodecContext *avctx)
 
     device_ctx = hwframe_ctx->device_ctx;
     device_hwctx = device_ctx->hwctx;
+
     cuda_ctx = device_hwctx->cuda_ctx;
+    ctx->cudl = device_hwctx->internal->cuda_dl;
 
     memset(&ctx->cuparseinfo, 0, sizeof(ctx->cuparseinfo));
     memset(&ctx->cuparse_ext, 0, sizeof(ctx->cuparse_ext));
@@ -664,11 +897,6 @@ static av_cold int cuvid_decode_init(AVCodecContext *avctx)
     ctx->cuparseinfo.pExtVideoInfo = &ctx->cuparse_ext;
 
     switch (avctx->codec->id) {
-#if CONFIG_H263_CUVID_DECODER
-    case AV_CODEC_ID_H263:
-        ctx->cuparseinfo.CodecType = cudaVideoCodec_MPEG4;
-        break;
-#endif
 #if CONFIG_H264_CUVID_DECODER
     case AV_CODEC_ID_H264:
         ctx->cuparseinfo.CodecType = cudaVideoCodec_H264;
@@ -748,22 +976,25 @@ static av_cold int cuvid_decode_init(AVCodecContext *avctx)
                FFMIN(sizeof(ctx->cuparse_ext.raw_seqhdr_data), avctx->extradata_size));
     }
 
-    ctx->cuparseinfo.ulMaxNumDecodeSurfaces = MAX_FRAME_COUNT;
+    ctx->cuparseinfo.ulMaxNumDecodeSurfaces = ctx->nb_surfaces;
     ctx->cuparseinfo.ulMaxDisplayDelay = 4;
     ctx->cuparseinfo.pUserData = avctx;
     ctx->cuparseinfo.pfnSequenceCallback = cuvid_handle_video_sequence;
     ctx->cuparseinfo.pfnDecodePicture = cuvid_handle_picture_decode;
     ctx->cuparseinfo.pfnDisplayPicture = cuvid_handle_picture_display;
 
-    ret = CHECK_CU(cuCtxPushCurrent(cuda_ctx));
+    ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
     if (ret < 0)
         goto error;
 
-    ret = cuvid_test_dummy_decoder(avctx, &ctx->cuparseinfo);
+    ret = cuvid_test_capabilities(avctx, &ctx->cuparseinfo,
+                                  probed_width,
+                                  probed_height,
+                                  probed_bit_depth);
     if (ret < 0)
         goto error;
 
-    ret = CHECK_CU(cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
+    ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
     if (ret < 0)
         goto error;
 
@@ -771,12 +1002,12 @@ static av_cold int cuvid_decode_init(AVCodecContext *avctx)
     seq_pkt.payload_size = ctx->cuparse_ext.format.seqhdr_data_length;
 
     if (seq_pkt.payload && seq_pkt.payload_size) {
-        ret = CHECK_CU(cuvidParseVideoData(ctx->cuparser, &seq_pkt));
+        ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
         if (ret < 0)
             goto error;
     }
 
-    ret = CHECK_CU(cuCtxPopCurrent(&dummy));
+    ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
     if (ret < 0)
         goto error;
 
@@ -801,29 +1032,29 @@ static void cuvid_flush(AVCodecContext *avctx)
     CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
     int ret;
 
-    ret = CHECK_CU(cuCtxPushCurrent(cuda_ctx));
+    ret = CHECK_CU(ctx->cudl->cuCtxPushCurrent(cuda_ctx));
     if (ret < 0)
         goto error;
 
     av_fifo_freep(&ctx->frame_queue);
 
-    ctx->frame_queue = av_fifo_alloc(MAX_FRAME_COUNT * sizeof(CuvidParsedFrame));
+    ctx->frame_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(CuvidParsedFrame));
     if (!ctx->frame_queue) {
         av_log(avctx, AV_LOG_ERROR, "Failed to recreate frame queue on flush\n");
         return;
     }
 
     if (ctx->cudecoder) {
-        cuvidDestroyDecoder(ctx->cudecoder);
+        ctx->cvdl->cuvidDestroyDecoder(ctx->cudecoder);
         ctx->cudecoder = NULL;
     }
 
     if (ctx->cuparser) {
-        cuvidDestroyVideoParser(ctx->cuparser);
+        ctx->cvdl->cuvidDestroyVideoParser(ctx->cuparser);
         ctx->cuparser = NULL;
     }
 
-    ret = CHECK_CU(cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
+    ret = CHECK_CU(ctx->cvdl->cuvidCreateVideoParser(&ctx->cuparser, &ctx->cuparseinfo));
     if (ret < 0)
         goto error;
 
@@ -831,12 +1062,12 @@ static void cuvid_flush(AVCodecContext *avctx)
     seq_pkt.payload_size = ctx->cuparse_ext.format.seqhdr_data_length;
 
     if (seq_pkt.payload && seq_pkt.payload_size) {
-        ret = CHECK_CU(cuvidParseVideoData(ctx->cuparser, &seq_pkt));
+        ret = CHECK_CU(ctx->cvdl->cuvidParseVideoData(ctx->cuparser, &seq_pkt));
         if (ret < 0)
             goto error;
     }
 
-    ret = CHECK_CU(cuCtxPopCurrent(&dummy));
+    ret = CHECK_CU(ctx->cudl->cuCtxPopCurrent(&dummy));
     if (ret < 0)
         goto error;
 
@@ -856,6 +1087,10 @@ static const AVOption options[] = {
     { "bob",      "Bob deinterlacing",                       0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob      }, 0, 0, VD, "deint" },
     { "adaptive", "Adaptive deinterlacing",                  0, AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0, VD, "deint" },
     { "gpu",      "GPU to be used for decoding", OFFSET(cu_gpu), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
+    { "surfaces", "Maximum surfaces to be used for decoding", OFFSET(nb_surfaces), AV_OPT_TYPE_INT, { .i64 = 25 }, 0, INT_MAX, VD },
+    { "drop_second_field", "Drop second field when deinterlacing", OFFSET(drop_second_field), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
+    { "crop",     "Crop (top)x(bottom)x(left)x(right)", OFFSET(crop_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
+    { "resize",   "Resize (width)x(height)", OFFSET(resize_expr), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
     { NULL }
 };
 
@@ -882,12 +1117,13 @@ static const AVOption options[] = {
         .init           = cuvid_decode_init, \
         .close          = cuvid_decode_end, \
         .decode         = cuvid_decode_frame, \
-        .send_packet    = cuvid_decode_packet, \
         .receive_frame  = cuvid_output_frame, \
         .flush          = cuvid_flush, \
         .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING, \
         .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_CUDA, \
                                                         AV_PIX_FMT_NV12, \
+                                                        AV_PIX_FMT_P010, \
+                                                        AV_PIX_FMT_P016, \
                                                         AV_PIX_FMT_NONE }, \
     };
 
@@ -895,10 +1131,6 @@ static const AVOption options[] = {
 DEFINE_CUVID_CODEC(hevc, HEVC)
 #endif
 
-#if CONFIG_H263_CUVID_DECODER
-DEFINE_CUVID_CODEC(h263, H263)
-#endif
-
 #if CONFIG_H264_CUVID_DECODER
 DEFINE_CUVID_CODEC(h264, H264)
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/cyuv.c b/mythtv/external/FFmpeg/libavcodec/cyuv.c
index 8e6749b0f4f..f2b0a7cbab7 100644
--- a/mythtv/external/FFmpeg/libavcodec/cyuv.c
+++ b/mythtv/external/FFmpeg/libavcodec/cyuv.c
@@ -185,6 +185,7 @@ AVCodec ff_aura_decoder = {
     .init           = cyuv_decode_init,
     .decode         = cyuv_decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
 #endif
 
@@ -198,5 +199,6 @@ AVCodec ff_cyuv_decoder = {
     .init           = cyuv_decode_init,
     .decode         = cyuv_decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/dca.c b/mythtv/external/FFmpeg/libavcodec/dca.c
index 58f340e6da8..307b21471e6 100644
--- a/mythtv/external/FFmpeg/libavcodec/dca.c
+++ b/mythtv/external/FFmpeg/libavcodec/dca.c
@@ -28,7 +28,9 @@
 #include "libavutil/error.h"
 
 #include "dca.h"
+#include "dca_core.h"
 #include "dca_syncwords.h"
+#include "get_bits.h"
 #include "put_bits.h"
 
 const uint32_t avpriv_dca_sample_rates[16] = {
@@ -45,6 +47,10 @@ const uint8_t ff_dca_freq_ranges[16] = {
     0, 1, 2, 3, 4, 1, 2, 3, 4, 4, 0, 1, 2, 3, 4, 4
 };
 
+const uint8_t ff_dca_bits_per_sample[8] = {
+    16, 16, 20, 20, 0, 24, 24, 0
+};
+
 int avpriv_dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
                              int max_size)
 {
@@ -81,3 +87,71 @@ int avpriv_dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
         return AVERROR_INVALIDDATA;
     }
 }
+
+int ff_dca_parse_core_frame_header(DCACoreFrameHeader *h, GetBitContext *gb)
+{
+    if (get_bits_long(gb, 32) != DCA_SYNCWORD_CORE_BE)
+        return DCA_PARSE_ERROR_SYNC_WORD;
+
+    h->normal_frame = get_bits1(gb);
+    h->deficit_samples = get_bits(gb, 5) + 1;
+    if (h->deficit_samples != DCA_PCMBLOCK_SAMPLES)
+        return DCA_PARSE_ERROR_DEFICIT_SAMPLES;
+
+    h->crc_present = get_bits1(gb);
+    h->npcmblocks = get_bits(gb, 7) + 1;
+    if (h->npcmblocks & (DCA_SUBBAND_SAMPLES - 1))
+        return DCA_PARSE_ERROR_PCM_BLOCKS;
+
+    h->frame_size = get_bits(gb, 14) + 1;
+    if (h->frame_size < 96)
+        return DCA_PARSE_ERROR_FRAME_SIZE;
+
+    h->audio_mode = get_bits(gb, 6);
+    if (h->audio_mode >= DCA_AMODE_COUNT)
+        return DCA_PARSE_ERROR_AMODE;
+
+    h->sr_code = get_bits(gb, 4);
+    if (!avpriv_dca_sample_rates[h->sr_code])
+        return DCA_PARSE_ERROR_SAMPLE_RATE;
+
+    h->br_code = get_bits(gb, 5);
+    if (get_bits1(gb))
+        return DCA_PARSE_ERROR_RESERVED_BIT;
+
+    h->drc_present = get_bits1(gb);
+    h->ts_present = get_bits1(gb);
+    h->aux_present = get_bits1(gb);
+    h->hdcd_master = get_bits1(gb);
+    h->ext_audio_type = get_bits(gb, 3);
+    h->ext_audio_present = get_bits1(gb);
+    h->sync_ssf = get_bits1(gb);
+    h->lfe_present = get_bits(gb, 2);
+    if (h->lfe_present == DCA_LFE_FLAG_INVALID)
+        return DCA_PARSE_ERROR_LFE_FLAG;
+
+    h->predictor_history = get_bits1(gb);
+    if (h->crc_present)
+        skip_bits(gb, 16);
+    h->filter_perfect = get_bits1(gb);
+    h->encoder_rev = get_bits(gb, 4);
+    h->copy_hist = get_bits(gb, 2);
+    h->pcmr_code = get_bits(gb, 3);
+    if (!ff_dca_bits_per_sample[h->pcmr_code])
+        return DCA_PARSE_ERROR_PCM_RES;
+
+    h->sumdiff_front = get_bits1(gb);
+    h->sumdiff_surround = get_bits1(gb);
+    h->dn_code = get_bits(gb, 4);
+    return 0;
+}
+
+int avpriv_dca_parse_core_frame_header(DCACoreFrameHeader *h, uint8_t *buf, int size)
+{
+    GetBitContext gb;
+
+    if (init_get_bits8(&gb, buf, size) < 0)
+        return DCA_PARSE_ERROR_INVALIDDATA;
+
+    return ff_dca_parse_core_frame_header(h, &gb);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/dca.h b/mythtv/external/FFmpeg/libavcodec/dca.h
index bd96bc9ee34..172c965b3b4 100644
--- a/mythtv/external/FFmpeg/libavcodec/dca.h
+++ b/mythtv/external/FFmpeg/libavcodec/dca.h
@@ -32,6 +32,50 @@
 #include "libavutil/internal.h"
 #include "libavutil/intreadwrite.h"
 
+#include "get_bits.h"
+
+#define DCA_CORE_FRAME_HEADER_SIZE      18
+
+enum DCAParseError {
+    DCA_PARSE_ERROR_SYNC_WORD       = -1,
+    DCA_PARSE_ERROR_DEFICIT_SAMPLES = -2,
+    DCA_PARSE_ERROR_PCM_BLOCKS      = -3,
+    DCA_PARSE_ERROR_FRAME_SIZE      = -4,
+    DCA_PARSE_ERROR_AMODE           = -5,
+    DCA_PARSE_ERROR_SAMPLE_RATE     = -6,
+    DCA_PARSE_ERROR_RESERVED_BIT    = -7,
+    DCA_PARSE_ERROR_LFE_FLAG        = -8,
+    DCA_PARSE_ERROR_PCM_RES         = -9,
+    DCA_PARSE_ERROR_INVALIDDATA     = -10,
+};
+
+typedef struct DCACoreFrameHeader {
+    uint8_t     normal_frame;       ///< Frame type
+    uint8_t     deficit_samples;    ///< Deficit sample count
+    uint8_t     crc_present;        ///< CRC present flag
+    uint8_t     npcmblocks;         ///< Number of PCM sample blocks
+    uint16_t    frame_size;         ///< Primary frame byte size
+    uint8_t     audio_mode;         ///< Audio channel arrangement
+    uint8_t     sr_code;            ///< Core audio sampling frequency
+    uint8_t     br_code;            ///< Transmission bit rate
+    uint8_t     drc_present;        ///< Embedded dynamic range flag
+    uint8_t     ts_present;         ///< Embedded time stamp flag
+    uint8_t     aux_present;        ///< Auxiliary data flag
+    uint8_t     hdcd_master;        ///< HDCD mastering flag
+    uint8_t     ext_audio_type;     ///< Extension audio descriptor flag
+    uint8_t     ext_audio_present;  ///< Extended coding flag
+    uint8_t     sync_ssf;           ///< Audio sync word insertion flag
+    uint8_t     lfe_present;        ///< Low frequency effects flag
+    uint8_t     predictor_history;  ///< Predictor history flag switch
+    uint8_t     filter_perfect;     ///< Multirate interpolator switch
+    uint8_t     encoder_rev;        ///< Encoder software revision
+    uint8_t     copy_hist;          ///< Copy history
+    uint8_t     pcmr_code;          ///< Source PCM resolution
+    uint8_t     sumdiff_front;      ///< Front sum/difference flag
+    uint8_t     sumdiff_surround;   ///< Surround sum/difference flag
+    uint8_t     dn_code;            ///< Dialog normalization / unspecified
+} DCACoreFrameHeader;
+
 enum DCASpeaker {
     DCA_SPEAKER_C,    DCA_SPEAKER_L,    DCA_SPEAKER_R,    DCA_SPEAKER_Ls,
     DCA_SPEAKER_Rs,   DCA_SPEAKER_LFE1, DCA_SPEAKER_Cs,   DCA_SPEAKER_Lsr,
@@ -156,6 +200,8 @@ extern av_export const uint32_t avpriv_dca_sample_rates[16];
 
 extern const uint32_t ff_dca_sampling_freqs[16];
 extern const uint8_t ff_dca_freq_ranges[16];
+extern const uint8_t ff_dca_bits_per_sample[8];
+
 
 /**
  * Convert bitstream to one representation based on sync marker
@@ -163,4 +209,12 @@ extern const uint8_t ff_dca_freq_ranges[16];
 int avpriv_dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
                                  int max_size);
 
+/**
+ * Parse and validate core frame header
+ * @return 0 on success, negative DCA_PARSE_ERROR_ code on failure
+ */
+int avpriv_dca_parse_core_frame_header(DCACoreFrameHeader *h, uint8_t *buf, int size);
+
+int ff_dca_parse_core_frame_header(DCACoreFrameHeader *h, GetBitContext *gb);
+
 #endif /* AVCODEC_DCA_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/dca_core.c b/mythtv/external/FFmpeg/libavcodec/dca_core.c
index 46825edbd41..accc5efd515 100644
--- a/mythtv/external/FFmpeg/libavcodec/dca_core.c
+++ b/mythtv/external/FFmpeg/libavcodec/dca_core.c
@@ -18,6 +18,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "dcaadpcm.h"
 #include "dcadec.h"
 #include "dcadata.h"
 #include "dcahuff.h"
@@ -34,35 +35,7 @@ enum HeaderType {
     HEADER_XXCH
 };
 
-enum AudioMode {
-    AMODE_MONO,             // Mode 0: A (mono)
-    AMODE_MONO_DUAL,        // Mode 1: A + B (dual mono)
-    AMODE_STEREO,           // Mode 2: L + R (stereo)
-    AMODE_STEREO_SUMDIFF,   // Mode 3: (L+R) + (L-R) (sum-diff)
-    AMODE_STEREO_TOTAL,     // Mode 4: LT + RT (left and right total)
-    AMODE_3F,               // Mode 5: C + L + R
-    AMODE_2F1R,             // Mode 6: L + R + S
-    AMODE_3F1R,             // Mode 7: C + L + R + S
-    AMODE_2F2R,             // Mode 8: L + R + SL + SR
-    AMODE_3F2R,             // Mode 9: C + L + R + SL + SR
-
-    AMODE_COUNT
-};
-
-enum ExtAudioType {
-    EXT_AUDIO_XCH   = 0,
-    EXT_AUDIO_X96   = 2,
-    EXT_AUDIO_XXCH  = 6
-};
-
-enum LFEFlag {
-    LFE_FLAG_NONE,
-    LFE_FLAG_128,
-    LFE_FLAG_64,
-    LFE_FLAG_INVALID
-};
-
-static const int8_t prm_ch_to_spkr_map[AMODE_COUNT][5] = {
+static const int8_t prm_ch_to_spkr_map[DCA_AMODE_COUNT][5] = {
     { DCA_SPEAKER_C,            -1,             -1,             -1,             -1 },
     { DCA_SPEAKER_L, DCA_SPEAKER_R,             -1,             -1,             -1 },
     { DCA_SPEAKER_L, DCA_SPEAKER_R,             -1,             -1,             -1 },
@@ -75,7 +48,7 @@ static const int8_t prm_ch_to_spkr_map[AMODE_COUNT][5] = {
     { DCA_SPEAKER_C, DCA_SPEAKER_L, DCA_SPEAKER_R,  DCA_SPEAKER_Ls, DCA_SPEAKER_Rs }
 };
 
-static const uint8_t audio_mode_ch_mask[AMODE_COUNT] = {
+static const uint8_t audio_mode_ch_mask[DCA_AMODE_COUNT] = {
     DCA_SPEAKER_LAYOUT_MONO,
     DCA_SPEAKER_LAYOUT_STEREO,
     DCA_SPEAKER_LAYOUT_STEREO,
@@ -92,14 +65,6 @@ static const uint8_t block_code_nbits[7] = {
     7, 10, 12, 13, 15, 17, 19
 };
 
-static const uint8_t quant_index_sel_nbits[DCA_CODE_BOOKS] = {
-    1, 2, 2, 2, 2, 3, 3, 3, 3, 3
-};
-
-static const uint8_t quant_index_group_size[DCA_CODE_BOOKS] = {
-    1, 3, 3, 3, 3, 7, 7, 7, 7, 7
-};
-
 static int dca_get_vlc(GetBitContext *s, DCAVLC *v, int i)
 {
     return get_vlc2(s, v->vlc[i].table, v->vlc[i].bits, v->max_depth) + v->offset;
@@ -116,114 +81,68 @@ static void get_array(GetBitContext *s, int32_t *array, int size, int n)
 // 5.3.1 - Bit stream header
 static int parse_frame_header(DCACoreDecoder *s)
 {
-    int normal_frame, pcmr_index;
-
-    // Frame type
-    normal_frame = get_bits1(&s->gb);
-
-    // Deficit sample count
-    if (get_bits(&s->gb, 5) != DCA_PCMBLOCK_SAMPLES - 1) {
-        av_log(s->avctx, AV_LOG_ERROR, "Deficit samples are not supported\n");
-        return normal_frame ? AVERROR_INVALIDDATA : AVERROR_PATCHWELCOME;
-    }
-
-    // CRC present flag
-    s->crc_present = get_bits1(&s->gb);
-
-    // Number of PCM sample blocks
-    s->npcmblocks = get_bits(&s->gb, 7) + 1;
-    if (s->npcmblocks & (DCA_SUBBAND_SAMPLES - 1)) {
-        av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of PCM sample blocks (%d)\n", s->npcmblocks);
-        return (s->npcmblocks < 6 || normal_frame) ? AVERROR_INVALIDDATA : AVERROR_PATCHWELCOME;
-    }
-
-    // Primary frame byte size
-    s->frame_size = get_bits(&s->gb, 14) + 1;
-    if (s->frame_size < 96) {
-        av_log(s->avctx, AV_LOG_ERROR, "Invalid core frame size (%d bytes)\n", s->frame_size);
-        return AVERROR_INVALIDDATA;
-    }
-
-    // Audio channel arrangement
-    s->audio_mode = get_bits(&s->gb, 6);
-    if (s->audio_mode >= AMODE_COUNT) {
-        av_log(s->avctx, AV_LOG_ERROR, "Unsupported audio channel arrangement (%d)\n", s->audio_mode);
-        return AVERROR_PATCHWELCOME;
-    }
-
-    // Core audio sampling frequency
-    s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
-    if (!s->sample_rate) {
-        av_log(s->avctx, AV_LOG_ERROR, "Invalid core audio sampling frequency\n");
-        return AVERROR_INVALIDDATA;
-    }
-
-    // Transmission bit rate
-    s->bit_rate = ff_dca_bit_rates[get_bits(&s->gb, 5)];
-
-    // Reserved field
-    skip_bits1(&s->gb);
-
-    // Embedded dynamic range flag
-    s->drc_present = get_bits1(&s->gb);
+    DCACoreFrameHeader h = { 0 };
+    int err = ff_dca_parse_core_frame_header(&h, &s->gb);
 
-    // Embedded time stamp flag
-    s->ts_present = get_bits1(&s->gb);
+    if (err < 0) {
+        switch (err) {
+        case DCA_PARSE_ERROR_DEFICIT_SAMPLES:
+            av_log(s->avctx, AV_LOG_ERROR, "Deficit samples are not supported\n");
+            return h.normal_frame ? AVERROR_INVALIDDATA : AVERROR_PATCHWELCOME;
 
-    // Auxiliary data flag
-    s->aux_present = get_bits1(&s->gb);
+        case DCA_PARSE_ERROR_PCM_BLOCKS:
+            av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of PCM sample blocks (%d)\n", h.npcmblocks);
+            return (h.npcmblocks < 6 || h.normal_frame) ? AVERROR_INVALIDDATA : AVERROR_PATCHWELCOME;
 
-    // HDCD mastering flag
-    skip_bits1(&s->gb);
-
-    // Extension audio descriptor flag
-    s->ext_audio_type = get_bits(&s->gb, 3);
-
-    // Extended coding flag
-    s->ext_audio_present = get_bits1(&s->gb);
-
-    // Audio sync word insertion flag
-    s->sync_ssf = get_bits1(&s->gb);
-
-    // Low frequency effects flag
-    s->lfe_present = get_bits(&s->gb, 2);
-    if (s->lfe_present == LFE_FLAG_INVALID) {
-        av_log(s->avctx, AV_LOG_ERROR, "Invalid low frequency effects flag\n");
-        return AVERROR_INVALIDDATA;
-    }
+        case DCA_PARSE_ERROR_FRAME_SIZE:
+            av_log(s->avctx, AV_LOG_ERROR, "Invalid core frame size (%d bytes)\n", h.frame_size);
+            return AVERROR_INVALIDDATA;
 
-    // Predictor history flag switch
-    s->predictor_history = get_bits1(&s->gb);
+        case DCA_PARSE_ERROR_AMODE:
+            av_log(s->avctx, AV_LOG_ERROR, "Unsupported audio channel arrangement (%d)\n", h.audio_mode);
+            return AVERROR_PATCHWELCOME;
 
-    // Header CRC check bytes
-    if (s->crc_present)
-        skip_bits(&s->gb, 16);
+        case DCA_PARSE_ERROR_SAMPLE_RATE:
+            av_log(s->avctx, AV_LOG_ERROR, "Invalid core audio sampling frequency\n");
+            return AVERROR_INVALIDDATA;
 
-    // Multirate interpolator switch
-    s->filter_perfect = get_bits1(&s->gb);
+        case DCA_PARSE_ERROR_RESERVED_BIT:
+            av_log(s->avctx, AV_LOG_ERROR, "Reserved bit set\n");
+            return AVERROR_INVALIDDATA;
 
-    // Encoder software revision
-    skip_bits(&s->gb, 4);
+        case DCA_PARSE_ERROR_LFE_FLAG:
+            av_log(s->avctx, AV_LOG_ERROR, "Invalid low frequency effects flag\n");
+            return AVERROR_INVALIDDATA;
 
-    // Copy history
-    skip_bits(&s->gb, 2);
+        case DCA_PARSE_ERROR_PCM_RES:
+            av_log(s->avctx, AV_LOG_ERROR, "Invalid source PCM resolution\n");
+            return AVERROR_INVALIDDATA;
 
-    // Source PCM resolution
-    s->source_pcm_res = ff_dca_bits_per_sample[pcmr_index = get_bits(&s->gb, 3)];
-    if (!s->source_pcm_res) {
-        av_log(s->avctx, AV_LOG_ERROR, "Invalid source PCM resolution\n");
-        return AVERROR_INVALIDDATA;
+        default:
+            av_log(s->avctx, AV_LOG_ERROR, "Unknown core frame header error\n");
+            return AVERROR_INVALIDDATA;
+        }
     }
-    s->es_format = pcmr_index & 1;
-
-    // Front sum/difference flag
-    s->sumdiff_front = get_bits1(&s->gb);
 
-    // Surround sum/difference flag
-    s->sumdiff_surround = get_bits1(&s->gb);
-
-    // Dialog normalization / unspecified
-    skip_bits(&s->gb, 4);
+    s->crc_present          = h.crc_present;
+    s->npcmblocks           = h.npcmblocks;
+    s->frame_size           = h.frame_size;
+    s->audio_mode           = h.audio_mode;
+    s->sample_rate          = avpriv_dca_sample_rates[h.sr_code];
+    s->bit_rate             = ff_dca_bit_rates[h.br_code];
+    s->drc_present          = h.drc_present;
+    s->ts_present           = h.ts_present;
+    s->aux_present          = h.aux_present;
+    s->ext_audio_type       = h.ext_audio_type;
+    s->ext_audio_present    = h.ext_audio_present;
+    s->sync_ssf             = h.sync_ssf;
+    s->lfe_present          = h.lfe_present;
+    s->predictor_history    = h.predictor_history;
+    s->filter_perfect       = h.filter_perfect;
+    s->source_pcm_res       = ff_dca_bits_per_sample[h.pcmr_code];
+    s->es_format            = h.pcmr_code & 1;
+    s->sumdiff_front        = h.sumdiff_front;
+    s->sumdiff_surround     = h.sumdiff_surround;
 
     return 0;
 }
@@ -400,12 +319,12 @@ static int parse_coding_header(DCACoreDecoder *s, enum HeaderType header, int xc
     // Quantization index codebook select
     for (n = 0; n < DCA_CODE_BOOKS; n++)
         for (ch = xch_base; ch < s->nchannels; ch++)
-            s->quant_index_sel[ch][n] = get_bits(&s->gb, quant_index_sel_nbits[n]);
+            s->quant_index_sel[ch][n] = get_bits(&s->gb, ff_dca_quant_index_sel_nbits[n]);
 
     // Scale factor adjustment index
     for (n = 0; n < DCA_CODE_BOOKS; n++)
         for (ch = xch_base; ch < s->nchannels; ch++)
-            if (s->quant_index_sel[ch][n] < quant_index_group_size[n])
+            if (s->quant_index_sel[ch][n] < ff_dca_quant_index_group_size[n])
                 s->scale_factor_adj[ch][n] = ff_dca_scale_factor_adj[get_bits(&s->gb, 2)];
 
     if (header == HEADER_XXCH) {
@@ -663,7 +582,7 @@ static inline int extract_audio(DCACoreDecoder *s, int32_t *audio, int abits, in
 
     if (abits <= DCA_CODE_BOOKS) {
         int sel = s->quant_index_sel[ch][abits - 1];
-        if (sel < quant_index_group_size[abits - 1]) {
+        if (sel < ff_dca_quant_index_group_size[abits - 1]) {
             // Huffman codes
             return parse_huffman_codes(s, audio, abits, sel);
         }
@@ -678,46 +597,21 @@ static inline int extract_audio(DCACoreDecoder *s, int32_t *audio, int abits, in
     return 0;
 }
 
-static inline void dequantize(int32_t *output, const int32_t *input,
-                              int32_t step_size, int32_t scale, int residual)
-{
-    // Account for quantizer step size
-    int64_t step_scale = (int64_t)step_size * scale;
-    int n, shift = 0;
-
-    // Limit scale factor resolution to 22 bits
-    if (step_scale > (1 << 23)) {
-        shift = av_log2(step_scale >> 23) + 1;
-        step_scale >>= shift;
-    }
-
-    // Scale the samples
-    if (residual) {
-        for (n = 0; n < DCA_SUBBAND_SAMPLES; n++)
-            output[n] += clip23(norm__(input[n] * step_scale, 22 - shift));
-    } else {
-        for (n = 0; n < DCA_SUBBAND_SAMPLES; n++)
-            output[n]  = clip23(norm__(input[n] * step_scale, 22 - shift));
-    }
-}
-
 static inline void inverse_adpcm(int32_t **subband_samples,
                                  const int16_t *vq_index,
                                  const int8_t *prediction_mode,
                                  int sb_start, int sb_end,
                                  int ofs, int len)
 {
-    int i, j, k;
+    int i, j;
 
     for (i = sb_start; i < sb_end; i++) {
         if (prediction_mode[i]) {
-            const int16_t *coeff = ff_dca_adpcm_vb[vq_index[i]];
+            const int pred_id = vq_index[i];
             int32_t *ptr = subband_samples[i] + ofs;
             for (j = 0; j < len; j++) {
-                int64_t err = 0;
-                for (k = 0; k < DCA_ADPCM_COEFFS; k++)
-                    err += (int64_t)ptr[j - k - 1] * coeff[k];
-                ptr[j] = clip23(ptr[j] + clip23(norm13(err)));
+                int32_t x = ff_dcaadpcm_predict(pred_id, ptr + j - DCA_ADPCM_COEFFS);
+                ptr[j] = clip23(ptr[j] + x);
             }
         }
     }
@@ -825,8 +719,8 @@ static int parse_subframe_audio(DCACoreDecoder *s, int sf, enum HeaderType heade
                     scale = clip23(adj * scale >> 22);
                 }
 
-                dequantize(s->subband_samples[ch][band] + ofs,
-                           audio, step_size, scale, 0);
+                ff_dca_core_dequantize(s->subband_samples[ch][band] + ofs,
+                           audio, step_size, scale, 0, DCA_SUBBAND_SAMPLES);
             }
         }
 
@@ -1154,8 +1048,8 @@ static int parse_xbr_subframe(DCACoreDecoder *s, int xbr_base_ch, int xbr_nchann
                 else
                     scale = xbr_scale_factors[ch][band][1];
 
-                dequantize(s->subband_samples[ch][band] + ofs,
-                           audio, step_size, scale, 1);
+                ff_dca_core_dequantize(s->subband_samples[ch][band] + ofs,
+                           audio, step_size, scale, 1, DCA_SUBBAND_SAMPLES);
             }
         }
 
@@ -1334,8 +1228,8 @@ static int parse_x96_subframe_audio(DCACoreDecoder *s, int sf, int xch_base, int
                 // Get the scale factor
                 scale = s->scale_factors[ch][band >> 1][band & 1];
 
-                dequantize(s->x96_subband_samples[ch][band] + ofs,
-                           audio, step_size, scale, 0);
+                ff_dca_core_dequantize(s->x96_subband_samples[ch][band] + ofs,
+                           audio, step_size, scale, 0, DCA_SUBBAND_SAMPLES);
             }
         }
 
@@ -1562,7 +1456,7 @@ static int parse_x96_coding_header(DCACoreDecoder *s, int exss, int xch_base)
     // Quantization index codebook select
     for (n = 0; n < 6 + 4 * s->x96_high_res; n++)
         for (ch = xch_base; ch < s->x96_nchannels; ch++)
-            s->quant_index_sel[ch][n] = get_bits(&s->gb, quant_index_sel_nbits[n]);
+            s->quant_index_sel[ch][n] = get_bits(&s->gb, ff_dca_quant_index_sel_nbits[n]);
 
     if (exss) {
         // Reserved
@@ -1810,12 +1704,13 @@ static int parse_optional_info(DCACoreDecoder *s)
         int sync_pos = FFMIN(s->frame_size / 4, s->gb.size_in_bits / 32) - 1;
         int last_pos = get_bits_count(&s->gb) / 32;
         int size, dist;
+        uint32_t w1, w2 = 0;
 
         // Search for extension sync words aligned on 4-byte boundary. Search
         // must be done backwards from the end of core frame to work around
         // sync word aliasing issues.
         switch (s->ext_audio_type) {
-        case EXT_AUDIO_XCH:
+        case DCA_EXT_AUDIO_XCH:
             if (dca->request_channel_layout)
                 break;
 
@@ -1824,15 +1719,15 @@ static int parse_optional_info(DCACoreDecoder *s)
             // compatibility with legacy bitstreams. Minimum XCH frame size is
             // 96 bytes. AMODE and PCHS are further checked to reduce
             // probability of alias sync detection.
-            for (; sync_pos >= last_pos; sync_pos--) {
-                if (AV_RB32(s->gb.buffer + sync_pos * 4) == DCA_SYNCWORD_XCH) {
-                    s->gb.index = (sync_pos + 1) * 32;
-                    size = get_bits(&s->gb, 10) + 1;
+            for (; sync_pos >= last_pos; sync_pos--, w2 = w1) {
+                w1 = AV_RB32(s->gb.buffer + sync_pos * 4);
+                if (w1 == DCA_SYNCWORD_XCH) {
+                    size = (w2 >> 22) + 1;
                     dist = s->frame_size - sync_pos * 4;
                     if (size >= 96
                         && (size == dist || size - 1 == dist)
-                        && get_bits(&s->gb, 7) == 0x08) {
-                        s->xch_pos = get_bits_count(&s->gb);
+                        && (w2 >> 15 & 0x7f) == 0x08) {
+                        s->xch_pos = sync_pos * 32 + 49;
                         break;
                     }
                 }
@@ -1845,17 +1740,17 @@ static int parse_optional_info(DCACoreDecoder *s)
             }
             break;
 
-        case EXT_AUDIO_X96:
+        case DCA_EXT_AUDIO_X96:
             // The distance between X96 sync word and end of the core frame
             // must be equal to X96 frame size. Minimum X96 frame size is 96
             // bytes.
-            for (; sync_pos >= last_pos; sync_pos--) {
-                if (AV_RB32(s->gb.buffer + sync_pos * 4) == DCA_SYNCWORD_X96) {
-                    s->gb.index = (sync_pos + 1) * 32;
-                    size = get_bits(&s->gb, 12) + 1;
+            for (; sync_pos >= last_pos; sync_pos--, w2 = w1) {
+                w1 = AV_RB32(s->gb.buffer + sync_pos * 4);
+                if (w1 == DCA_SYNCWORD_X96) {
+                    size = (w2 >> 20) + 1;
                     dist = s->frame_size - sync_pos * 4;
                     if (size >= 96 && size == dist) {
-                        s->x96_pos = get_bits_count(&s->gb);
+                        s->x96_pos = sync_pos * 32 + 44;
                         break;
                     }
                 }
@@ -1868,16 +1763,16 @@ static int parse_optional_info(DCACoreDecoder *s)
             }
             break;
 
-        case EXT_AUDIO_XXCH:
+        case DCA_EXT_AUDIO_XXCH:
             if (dca->request_channel_layout)
                 break;
 
             // XXCH frame header CRC must be valid. Minimum XXCH frame header
             // size is 11 bytes.
-            for (; sync_pos >= last_pos; sync_pos--) {
-                if (AV_RB32(s->gb.buffer + sync_pos * 4) == DCA_SYNCWORD_XXCH) {
-                    s->gb.index = (sync_pos + 1) * 32;
-                    size = get_bits(&s->gb, 6) + 1;
+            for (; sync_pos >= last_pos; sync_pos--, w2 = w1) {
+                w1 = AV_RB32(s->gb.buffer + sync_pos * 4);
+                if (w1 == DCA_SYNCWORD_XXCH) {
+                    size = (w2 >> 26) + 1;
                     dist = s->gb.size_in_bits / 8 - sync_pos * 4;
                     if (size >= 11 && size <= dist &&
                         !av_crc(dca->crctab, 0xffff, s->gb.buffer +
@@ -1909,8 +1804,8 @@ int ff_dca_core_parse(DCACoreDecoder *s, uint8_t *data, int size)
 
     if ((ret = init_get_bits8(&s->gb, data, size)) < 0)
         return ret;
+    s->gb_in = s->gb;
 
-    skip_bits_long(&s->gb, 32);
     if ((ret = parse_frame_header(s)) < 0)
         return ret;
     if ((ret = alloc_sample_buffer(s)) < 0)
@@ -1921,7 +1816,7 @@ int ff_dca_core_parse(DCACoreDecoder *s, uint8_t *data, int size)
         return ret;
 
     // Workaround for DTS in WAV
-    if (s->frame_size > size && s->frame_size < size + 4)
+    if (s->frame_size > size)
         s->frame_size = size;
 
     if (ff_dca_seek_bits(&s->gb, s->frame_size * 8)) {
@@ -1937,7 +1832,6 @@ int ff_dca_core_parse_exss(DCACoreDecoder *s, uint8_t *data, DCAExssAsset *asset
 {
     AVCodecContext *avctx = s->avctx;
     DCAContext *dca = avctx->priv_data;
-    GetBitContext gb = s->gb;
     int exss_mask = asset ? asset->extension_mask : 0;
     int ret = 0, ext = 0;
 
@@ -1949,11 +1843,13 @@ int ff_dca_core_parse_exss(DCACoreDecoder *s, uint8_t *data, DCAExssAsset *asset
             ret = parse_xxch_frame(s);
             ext = DCA_EXSS_XXCH;
         } else if (s->xxch_pos) {
-            s->gb.index = s->xxch_pos;
+            s->gb = s->gb_in;
+            skip_bits_long(&s->gb, s->xxch_pos);
             ret = parse_xxch_frame(s);
             ext = DCA_CSS_XXCH;
         } else if (s->xch_pos) {
-            s->gb.index = s->xch_pos;
+            s->gb = s->gb_in;
+            skip_bits_long(&s->gb, s->xch_pos);
             ret = parse_xch_frame(s);
             ext = DCA_CSS_XCH;
         }
@@ -1995,8 +1891,8 @@ int ff_dca_core_parse_exss(DCACoreDecoder *s, uint8_t *data, DCAExssAsset *asset
                 s->ext_audio_mask |= DCA_EXSS_X96;
             }
         } else if (s->x96_pos) {
-            s->gb = gb;
-            s->gb.index = s->x96_pos;
+            s->gb = s->gb_in;
+            skip_bits_long(&s->gb, s->x96_pos);
             if ((ret = parse_x96_frame(s)) < 0) {
                 if (ret == AVERROR(ENOMEM) || (avctx->err_recognition & AV_EF_EXPLODE))
                     return ret;
@@ -2134,7 +2030,7 @@ int ff_dca_core_filter_fixed(DCACoreDecoder *s, int x96_synth)
         int nlfesamples = s->npcmblocks >> 1;
 
         // Check LFF
-        if (s->lfe_present == LFE_FLAG_128) {
+        if (s->lfe_present == DCA_LFE_FLAG_128) {
             av_log(s->avctx, AV_LOG_ERROR, "Fixed point mode doesn't support LFF=1\n");
             return AVERROR(EINVAL);
         }
@@ -2184,7 +2080,7 @@ static int filter_frame_fixed(DCACoreDecoder *s, AVFrame *frame)
 
     // Undo embedded XCH downmix
     if (s->es_format && (s->ext_audio_mask & DCA_CSS_XCH)
-        && s->audio_mode >= AMODE_2F2R) {
+        && s->audio_mode >= DCA_AMODE_2F2R) {
         s->dcadsp->dmix_sub_xch(s->output_samples[DCA_SPEAKER_Ls],
                                 s->output_samples[DCA_SPEAKER_Rs],
                                 s->output_samples[DCA_SPEAKER_Cs],
@@ -2228,15 +2124,15 @@ static int filter_frame_fixed(DCACoreDecoder *s, AVFrame *frame)
 
     if (!(s->ext_audio_mask & (DCA_CSS_XXCH | DCA_CSS_XCH | DCA_EXSS_XXCH))) {
         // Front sum/difference decoding
-        if ((s->sumdiff_front && s->audio_mode > AMODE_MONO)
-            || s->audio_mode == AMODE_STEREO_SUMDIFF) {
+        if ((s->sumdiff_front && s->audio_mode > DCA_AMODE_MONO)
+            || s->audio_mode == DCA_AMODE_STEREO_SUMDIFF) {
             s->fixed_dsp->butterflies_fixed(s->output_samples[DCA_SPEAKER_L],
                                             s->output_samples[DCA_SPEAKER_R],
                                             nsamples);
         }
 
         // Surround sum/difference decoding
-        if (s->sumdiff_surround && s->audio_mode >= AMODE_2F2R) {
+        if (s->sumdiff_surround && s->audio_mode >= DCA_AMODE_2F2R) {
             s->fixed_dsp->butterflies_fixed(s->output_samples[DCA_SPEAKER_Ls],
                                             s->output_samples[DCA_SPEAKER_Rs],
                                             nsamples);
@@ -2340,7 +2236,7 @@ static int filter_frame_float(DCACoreDecoder *s, AVFrame *frame)
 
     // Filter LFE channel
     if (s->lfe_present) {
-        int dec_select = (s->lfe_present == LFE_FLAG_128);
+        int dec_select = (s->lfe_present == DCA_LFE_FLAG_128);
         float *samples = output_samples[DCA_SPEAKER_LFE1];
         int nlfesamples = s->npcmblocks >> (dec_select + 1);
 
@@ -2374,7 +2270,7 @@ static int filter_frame_float(DCACoreDecoder *s, AVFrame *frame)
 
     // Undo embedded XCH downmix
     if (s->es_format && (s->ext_audio_mask & DCA_CSS_XCH)
-        && s->audio_mode >= AMODE_2F2R) {
+        && s->audio_mode >= DCA_AMODE_2F2R) {
         s->float_dsp->vector_fmac_scalar(output_samples[DCA_SPEAKER_Ls],
                                          output_samples[DCA_SPEAKER_Cs],
                                          -M_SQRT1_2, nsamples);
@@ -2421,15 +2317,15 @@ static int filter_frame_float(DCACoreDecoder *s, AVFrame *frame)
 
     if (!(s->ext_audio_mask & (DCA_CSS_XXCH | DCA_CSS_XCH | DCA_EXSS_XXCH))) {
         // Front sum/difference decoding
-        if ((s->sumdiff_front && s->audio_mode > AMODE_MONO)
-            || s->audio_mode == AMODE_STEREO_SUMDIFF) {
+        if ((s->sumdiff_front && s->audio_mode > DCA_AMODE_MONO)
+            || s->audio_mode == DCA_AMODE_STEREO_SUMDIFF) {
             s->float_dsp->butterflies_float(output_samples[DCA_SPEAKER_L],
                                             output_samples[DCA_SPEAKER_R],
                                             nsamples);
         }
 
         // Surround sum/difference decoding
-        if (s->sumdiff_surround && s->audio_mode >= AMODE_2F2R) {
+        if (s->sumdiff_surround && s->audio_mode >= DCA_AMODE_2F2R) {
             s->float_dsp->butterflies_float(output_samples[DCA_SPEAKER_Ls],
                                             output_samples[DCA_SPEAKER_Rs],
                                             nsamples);
@@ -2456,7 +2352,7 @@ int ff_dca_core_filter_frame(DCACoreDecoder *s, AVFrame *frame)
 
     // Handle downmixing to stereo request
     if (dca->request_channel_layout == DCA_SPEAKER_LAYOUT_STEREO
-        && s->audio_mode > AMODE_MONO && s->prim_dmix_embedded
+        && s->audio_mode > DCA_AMODE_MONO && s->prim_dmix_embedded
         && (s->prim_dmix_type == DCA_DMIX_TYPE_LoRo ||
             s->prim_dmix_type == DCA_DMIX_TYPE_LtRt))
         s->request_mask = DCA_SPEAKER_LAYOUT_STEREO;
@@ -2489,8 +2385,8 @@ int ff_dca_core_filter_frame(DCACoreDecoder *s, AVFrame *frame)
     else
         avctx->bit_rate = 0;
 
-    if (s->audio_mode == AMODE_STEREO_TOTAL || (s->request_mask != s->ch_mask &&
-                                                s->prim_dmix_type == DCA_DMIX_TYPE_LtRt))
+    if (s->audio_mode == DCA_AMODE_STEREO_TOTAL || (s->request_mask != s->ch_mask &&
+                                                    s->prim_dmix_type == DCA_DMIX_TYPE_LtRt))
         matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
     else
         matrix_encoding = AV_MATRIX_ENCODING_NONE;
diff --git a/mythtv/external/FFmpeg/libavcodec/dca_core.h b/mythtv/external/FFmpeg/libavcodec/dca_core.h
index e84bdab18e6..10128d1e32c 100644
--- a/mythtv/external/FFmpeg/libavcodec/dca_core.h
+++ b/mythtv/external/FFmpeg/libavcodec/dca_core.h
@@ -33,6 +33,7 @@
 #include "dca_exss.h"
 #include "dcadsp.h"
 #include "dcadct.h"
+#include "dcamath.h"
 #include "dcahuff.h"
 #include "fft.h"
 #include "synth_filter.h"
@@ -43,7 +44,6 @@
 #define DCA_SUBFRAMES           16
 #define DCA_SUBBAND_SAMPLES     8
 #define DCA_PCMBLOCK_SAMPLES    32
-#define DCA_ADPCM_COEFFS        4
 #define DCA_LFE_HISTORY         8
 #define DCA_ABITS_MAX           26
 
@@ -56,6 +56,34 @@
 #define DCA_FILTER_MODE_X96     0x01
 #define DCA_FILTER_MODE_FIXED   0x02
 
+enum DCACoreAudioMode {
+    DCA_AMODE_MONO,             // Mode 0: A (mono)
+    DCA_AMODE_MONO_DUAL,        // Mode 1: A + B (dual mono)
+    DCA_AMODE_STEREO,           // Mode 2: L + R (stereo)
+    DCA_AMODE_STEREO_SUMDIFF,   // Mode 3: (L+R) + (L-R) (sum-diff)
+    DCA_AMODE_STEREO_TOTAL,     // Mode 4: LT + RT (left and right total)
+    DCA_AMODE_3F,               // Mode 5: C + L + R
+    DCA_AMODE_2F1R,             // Mode 6: L + R + S
+    DCA_AMODE_3F1R,             // Mode 7: C + L + R + S
+    DCA_AMODE_2F2R,             // Mode 8: L + R + SL + SR
+    DCA_AMODE_3F2R,             // Mode 9: C + L + R + SL + SR
+
+    DCA_AMODE_COUNT
+};
+
+enum DCACoreExtAudioType {
+    DCA_EXT_AUDIO_XCH   = 0,
+    DCA_EXT_AUDIO_X96   = 2,
+    DCA_EXT_AUDIO_XXCH  = 6
+};
+
+enum DCACoreLFEFlag {
+    DCA_LFE_FLAG_NONE,
+    DCA_LFE_FLAG_128,
+    DCA_LFE_FLAG_64,
+    DCA_LFE_FLAG_INVALID
+};
+
 typedef struct DCADSPData {
     union {
         struct {
@@ -73,6 +101,7 @@ typedef struct DCADSPData {
 typedef struct DCACoreDecoder {
     AVCodecContext  *avctx;
     GetBitContext   gb;
+    GetBitContext   gb_in;
 
     // Bit stream header
     int     crc_present;        ///< CRC present flag
@@ -195,6 +224,29 @@ static inline int ff_dca_core_map_spkr(DCACoreDecoder *core, int spkr)
     return -1;
 }
 
+static inline void ff_dca_core_dequantize(int32_t *output, const int32_t *input,
+                                          int32_t step_size, int32_t scale, int residual, int len)
+{
+    // Account for quantizer step size
+    int64_t step_scale = (int64_t)step_size * scale;
+    int n, shift = 0;
+
+    // Limit scale factor resolution to 22 bits
+    if (step_scale > (1 << 23)) {
+        shift = av_log2(step_scale >> 23) + 1;
+        step_scale >>= shift;
+    }
+
+    // Scale the samples
+    if (residual) {
+        for (n = 0; n < len; n++)
+            output[n] += clip23(norm__(input[n] * step_scale, 22 - shift));
+    } else {
+        for (n = 0; n < len; n++)
+            output[n]  = clip23(norm__(input[n] * step_scale, 22 - shift));
+    }
+}
+
 int ff_dca_core_parse(DCACoreDecoder *s, uint8_t *data, int size);
 int ff_dca_core_parse_exss(DCACoreDecoder *s, uint8_t *data, DCAExssAsset *asset);
 int ff_dca_core_filter_fixed(DCACoreDecoder *s, int x96_synth);
diff --git a/mythtv/external/FFmpeg/libavcodec/dca_lbr.c b/mythtv/external/FFmpeg/libavcodec/dca_lbr.c
index 342603c7d43..3b50a99cf6d 100644
--- a/mythtv/external/FFmpeg/libavcodec/dca_lbr.c
+++ b/mythtv/external/FFmpeg/libavcodec/dca_lbr.c
@@ -30,11 +30,6 @@
 
 #define AMP_MAX     56
 
-enum LBRHeader {
-    LBR_HEADER_SYNC_ONLY    = 1,
-    LBR_HEADER_DECODER_INIT = 2
-};
-
 enum LBRFlags {
     LBR_FLAG_24_BIT             = 0x01,
     LBR_FLAG_LFE_PRESENT        = 0x02,
@@ -310,7 +305,7 @@ static int parse_tonal(DCALbrDecoder *s, int group)
                 break;  // End of subframe
 
             freq += diff - 2;
-            if (freq >> (5 - group) > s->nsubbands * 4 - 5) {
+            if (freq >> (5 - group) > s->nsubbands * 4 - 6) {
                 av_log(s->avctx, AV_LOG_ERROR, "Invalid spectral line offset\n");
                 return -1;
             }
@@ -1171,13 +1166,13 @@ int ff_dca_lbr_parse(DCALbrDecoder *s, uint8_t *data, DCAExssAsset *asset)
 
     // LBR header type
     switch (bytestream2_get_byte(&gb)) {
-    case LBR_HEADER_SYNC_ONLY:
+    case DCA_LBR_HEADER_SYNC_ONLY:
         if (!s->sample_rate) {
             av_log(s->avctx, AV_LOG_ERROR, "LBR decoder not initialized\n");
             return AVERROR_INVALIDDATA;
         }
         break;
-    case LBR_HEADER_DECODER_INIT:
+    case DCA_LBR_HEADER_DECODER_INIT:
         if ((ret = parse_decoder_init(s, &gb)) < 0) {
             s->sample_rate = 0;
             return ret;
diff --git a/mythtv/external/FFmpeg/libavcodec/dca_lbr.h b/mythtv/external/FFmpeg/libavcodec/dca_lbr.h
index e6ca8057e9d..6d4c0a8a635 100644
--- a/mythtv/external/FFmpeg/libavcodec/dca_lbr.h
+++ b/mythtv/external/FFmpeg/libavcodec/dca_lbr.h
@@ -41,6 +41,11 @@
 #define DCA_LBR_TIME_SAMPLES    128
 #define DCA_LBR_TIME_HISTORY    8
 
+enum DCALBRHeader {
+    DCA_LBR_HEADER_SYNC_ONLY    = 1,
+    DCA_LBR_HEADER_DECODER_INIT = 2
+};
+
 typedef struct DCALbrTone {
     uint8_t     x_freq;     ///< Spectral line offset
     uint8_t     f_delt;     ///< Difference between original and center frequency
diff --git a/mythtv/external/FFmpeg/libavcodec/dca_parser.c b/mythtv/external/FFmpeg/libavcodec/dca_parser.c
index e5bea3347cc..80d665985e8 100644
--- a/mythtv/external/FFmpeg/libavcodec/dca_parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/dca_parser.c
@@ -23,7 +23,9 @@
  */
 
 #include "dca.h"
+#include "dca_core.h"
 #include "dca_exss.h"
+#include "dca_lbr.h"
 #include "dca_syncwords.h"
 #include "get_bits.h"
 #include "parser.h"
@@ -122,13 +124,13 @@ static int dca_find_frame_end(DCAParseContext *pc1, const uint8_t *buf,
                     break;
                 case DCA_SYNCWORD_CORE_14B_BE:
                     if (size == 4) {
-                        pc1->framesize = CORE_FRAMESIZE(STATE_14(state)) * 8 / 14 * 2;
+                        pc1->framesize = CORE_FRAMESIZE(STATE_14(state));
                         start_found    = 4;
                     }
                     break;
                 case DCA_SYNCWORD_CORE_14B_LE:
                     if (size == 4) {
-                        pc1->framesize = CORE_FRAMESIZE(STATE_14(STATE_LE(state))) * 8 / 14 * 2;
+                        pc1->framesize = CORE_FRAMESIZE(STATE_14(STATE_LE(state)));
                         start_found    = 4;
                     }
                     break;
@@ -189,18 +191,19 @@ static av_cold int dca_parse_init(AVCodecParserContext *s)
 }
 
 static int dca_parse_params(DCAParseContext *pc1, const uint8_t *buf,
-                            int buf_size, int *duration, int *sample_rate)
+                            int buf_size, int *duration, int *sample_rate,
+                            int *profile)
 {
+    DCAExssAsset *asset = &pc1->exss.assets[0];
     GetBitContext gb;
-    uint8_t hdr[12 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
-    int ret, sample_blocks;
+    DCACoreFrameHeader h;
+    uint8_t hdr[DCA_CORE_FRAME_HEADER_SIZE + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
+    int ret, frame_size;
 
-    if (buf_size < 12)
+    if (buf_size < DCA_CORE_FRAME_HEADER_SIZE)
         return AVERROR_INVALIDDATA;
 
     if (AV_RB32(buf) == DCA_SYNCWORD_SUBSTREAM) {
-        DCAExssAsset *asset = &pc1->exss.assets[0];
-
         if ((ret = ff_dca_exss_parse(&pc1->exss, buf, buf_size)) < 0)
             return ret;
 
@@ -212,9 +215,9 @@ static int dca_parse_params(DCAParseContext *pc1, const uint8_t *buf,
                 return AVERROR_INVALIDDATA;
 
             switch (get_bits(&gb, 8)) {
-            case 2:
+            case DCA_LBR_HEADER_DECODER_INIT:
                 pc1->sr_code = get_bits(&gb, 8);
-            case 1:
+            case DCA_LBR_HEADER_SYNC_ONLY:
                 break;
             default:
                 return AVERROR_INVALIDDATA;
@@ -225,6 +228,7 @@ static int dca_parse_params(DCAParseContext *pc1, const uint8_t *buf,
 
             *sample_rate = ff_dca_sampling_freqs[pc1->sr_code];
             *duration = 1024 << ff_dca_freq_ranges[pc1->sr_code];
+            *profile = FF_PROFILE_DTS_EXPRESS;
             return 0;
         }
 
@@ -249,27 +253,52 @@ static int dca_parse_params(DCAParseContext *pc1, const uint8_t *buf,
 
             *sample_rate = asset->max_sample_rate;
             *duration = (1 + (*sample_rate > 96000)) << nsamples_log2;
+            *profile = FF_PROFILE_DTS_HD_MA;
             return 0;
         }
 
         return AVERROR_INVALIDDATA;
     }
 
-    if ((ret = avpriv_dca_convert_bitstream(buf, 12, hdr, 12)) < 0)
+    if ((ret = avpriv_dca_convert_bitstream(buf, DCA_CORE_FRAME_HEADER_SIZE,
+                                            hdr, DCA_CORE_FRAME_HEADER_SIZE)) < 0)
         return ret;
+    if (avpriv_dca_parse_core_frame_header(&h, hdr, ret) < 0)
+        return AVERROR_INVALIDDATA;
 
-    init_get_bits(&gb, hdr, 96);
+    *duration = h.npcmblocks * DCA_PCMBLOCK_SAMPLES;
+    *sample_rate = avpriv_dca_sample_rates[h.sr_code];
+    if (*profile != FF_PROFILE_UNKNOWN)
+        return 0;
+
+    *profile = FF_PROFILE_DTS;
+    if (h.ext_audio_present) {
+        switch (h.ext_audio_type) {
+        case DCA_EXT_AUDIO_XCH:
+        case DCA_EXT_AUDIO_XXCH:
+            *profile = FF_PROFILE_DTS_ES;
+            break;
+        case DCA_EXT_AUDIO_X96:
+            *profile = FF_PROFILE_DTS_96_24;
+            break;
+        }
+    }
 
-    skip_bits_long(&gb, 39);
-    sample_blocks = get_bits(&gb, 7) + 1;
-    if (sample_blocks < 8)
-        return AVERROR_INVALIDDATA;
-    *duration = 256 * (sample_blocks / 8);
+    frame_size = FFALIGN(h.frame_size, 4);
+    if (buf_size - 4 < frame_size)
+        return 0;
 
-    skip_bits(&gb, 20);
-    *sample_rate = avpriv_dca_sample_rates[get_bits(&gb, 4)];
-    if (*sample_rate == 0)
-        return AVERROR_INVALIDDATA;
+    buf      += frame_size;
+    buf_size -= frame_size;
+    if (AV_RB32(buf) != DCA_SYNCWORD_SUBSTREAM)
+        return 0;
+    if (ff_dca_exss_parse(&pc1->exss, buf, buf_size) < 0)
+        return 0;
+
+    if (asset->extension_mask & DCA_EXSS_XLL)
+        *profile = FF_PROFILE_DTS_HD_MA;
+    else if (asset->extension_mask & (DCA_EXSS_XBR | DCA_EXSS_XXCH | DCA_EXSS_X96))
+        *profile = FF_PROFILE_DTS_HD_HRA;
 
     return 0;
 }
@@ -302,7 +331,7 @@ static int dca_parse(AVCodecParserContext *s, AVCodecContext *avctx,
     }
 
     /* read the duration and sample rate from the frame header */
-    if (!dca_parse_params(pc1, buf, buf_size, &duration, &sample_rate)) {
+    if (!dca_parse_params(pc1, buf, buf_size, &duration, &sample_rate, &avctx->profile)) {
         if (!avctx->sample_rate)
             avctx->sample_rate = sample_rate;
         s->duration = av_rescale(duration, avctx->sample_rate, sample_rate);
diff --git a/mythtv/external/FFmpeg/libavcodec/dca_xll.c b/mythtv/external/FFmpeg/libavcodec/dca_xll.c
index 1d616c298c8..d265cab8dfa 100644
--- a/mythtv/external/FFmpeg/libavcodec/dca_xll.c
+++ b/mythtv/external/FFmpeg/libavcodec/dca_xll.c
@@ -143,7 +143,7 @@ static int chs_parse_header(DCAXllDecoder *s, DCAXllChSet *c, DCAExssAsset *asse
 
     // Storage unit width
     c->storage_bit_res = get_bits(&s->gb, 5) + 1;
-    if (c->storage_bit_res != 16 && c->storage_bit_res != 24) {
+    if (c->storage_bit_res != 16 && c->storage_bit_res != 20 && c->storage_bit_res != 24) {
         avpriv_request_sample(s->avctx, "%d-bit XLL storage resolution", c->storage_bit_res);
         return AVERROR_PATCHWELCOME;
     }
@@ -652,13 +652,13 @@ static void chs_filter_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band)
                 int64_t err = 0;
                 for (k = 0; k < order; k++)
                     err += (int64_t)buf[j + k] * coeff[order - k - 1];
-                buf[j + k] -= clip23(norm16(err));
+                buf[j + k] -= (SUINT)clip23(norm16(err));
             }
         } else {
             // Inverse fixed coefficient prediction
             for (j = 0; j < b->fixed_pred_order[i]; j++)
                 for (k = 1; k < nsamples; k++)
-                    buf[k] += buf[k - 1];
+                    buf[k] += (unsigned)buf[k - 1];
         }
     }
 
@@ -717,10 +717,10 @@ static void chs_assemble_msbs_lsbs(DCAXllDecoder *s, DCAXllChSet *c, int band)
                 int32_t *lsb = b->lsb_sample_buffer[ch];
                 int adj = b->bit_width_adjust[ch];
                 for (n = 0; n < nsamples; n++)
-                    msb[n] = msb[n] * (1 << shift) + (lsb[n] << adj);
+                    msb[n] = msb[n] * (SUINT)(1 << shift) + (lsb[n] << adj);
             } else {
                 for (n = 0; n < nsamples; n++)
-                    msb[n] = msb[n] * (1 << shift);
+                    msb[n] = msb[n] * (SUINT)(1 << shift);
             }
         }
     }
@@ -1028,7 +1028,7 @@ static int parse_band_data(DCAXllDecoder *s)
                             return ret;
                         chs_clear_band_data(s, c, band, seg);
                     }
-                    s->gb.index = navi_pos;
+                    skip_bits_long(&s->gb, navi_pos - get_bits_count(&s->gb));
                 }
                 navi_ptr++;
             }
@@ -1308,11 +1308,11 @@ static int combine_residual_frame(DCAXllDecoder *s, DCAXllChSet *c)
             // Undo embedded core downmix pre-scaling
             int scale_inv = o->dmix_scale_inv[c->hier_ofs + ch];
             for (n = 0; n < nsamples; n++)
-                dst[n] += clip23((mul16(src[n], scale_inv) + round) >> shift);
+                dst[n] += (SUINT)clip23((mul16(src[n], scale_inv) + round) >> shift);
         } else {
             // No downmix scaling
             for (n = 0; n < nsamples; n++)
-                dst[n] += (src[n] + round) >> shift;
+                dst[n] += (unsigned)((src[n] + round) >> shift);
         }
     }
 
@@ -1415,9 +1415,12 @@ int ff_dca_xll_filter_frame(DCAXllDecoder *s, AVFrame *frame)
     switch (p->storage_bit_res) {
     case 16:
         avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
+        shift = 16 - p->pcm_bit_res;
         break;
+    case 20:
     case 24:
         avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
+        shift = 24 - p->pcm_bit_res;
         break;
     default:
         return AVERROR(EINVAL);
@@ -1438,17 +1441,16 @@ int ff_dca_xll_filter_frame(DCAXllDecoder *s, AVFrame *frame)
                                        s->output_mask);
     }
 
-    shift = p->storage_bit_res - p->pcm_bit_res;
     for (i = 0; i < avctx->channels; i++) {
         int32_t *samples = s->output_samples[ch_remap[i]];
         if (frame->format == AV_SAMPLE_FMT_S16P) {
             int16_t *plane = (int16_t *)frame->extended_data[i];
             for (k = 0; k < nsamples; k++)
-                plane[k] = av_clip_int16(samples[k] * (1 << shift));
+                plane[k] = av_clip_int16(samples[k] * (SUINT)(1 << shift));
         } else {
             int32_t *plane = (int32_t *)frame->extended_data[i];
             for (k = 0; k < nsamples; k++)
-                plane[k] = clip23(samples[k] * (1 << shift)) * (1 << 8);
+                plane[k] = clip23(samples[k] * (SUINT)(1 << shift)) * (1 << 8);
         }
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/dcaadpcm.c b/mythtv/external/FFmpeg/libavcodec/dcaadpcm.c
new file mode 100644
index 00000000000..9f615e37935
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/dcaadpcm.c
@@ -0,0 +1,231 @@
+/*
+ * DCA ADPCM engine
+ * Copyright (C) 2017 Daniil Cherednik
+ *
+ * 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 "dcaadpcm.h"
+#include "dcaenc.h"
+#include "dca_core.h"
+#include "mathops.h"
+
+typedef int32_t premultiplied_coeffs[10];
+
+//assume we have DCA_ADPCM_COEFFS values before x
+static inline int64_t calc_corr(const int32_t *x, int len, int j, int k)
+{
+    int n;
+    int64_t s = 0;
+    for (n = 0; n < len; n++)
+        s += MUL64(x[n-j], x[n-k]);
+    return s;
+}
+
+static inline int64_t apply_filter(const int16_t a[DCA_ADPCM_COEFFS], const int64_t corr[15], const int32_t aa[10])
+{
+    int64_t err = 0;
+    int64_t tmp = 0;
+
+    err = corr[0];
+
+    tmp += MUL64(a[0], corr[1]);
+    tmp += MUL64(a[1], corr[2]);
+    tmp += MUL64(a[2], corr[3]);
+    tmp += MUL64(a[3], corr[4]);
+
+    tmp = norm__(tmp, 13);
+    tmp += tmp;
+
+    err -= tmp;
+    tmp = 0;
+
+    tmp += MUL64(corr[5], aa[0]);
+    tmp += MUL64(corr[6], aa[1]);
+    tmp += MUL64(corr[7], aa[2]);
+    tmp += MUL64(corr[8], aa[3]);
+
+    tmp += MUL64(corr[9], aa[4]);
+    tmp += MUL64(corr[10], aa[5]);
+    tmp += MUL64(corr[11], aa[6]);
+
+    tmp += MUL64(corr[12], aa[7]);
+    tmp += MUL64(corr[13], aa[8]);
+
+    tmp += MUL64(corr[14], aa[9]);
+
+    tmp = norm__(tmp, 26);
+
+    err += tmp;
+
+    return llabs(err);
+}
+
+static int64_t find_best_filter(const DCAADPCMEncContext *s, const int32_t *in, int len)
+{
+    const premultiplied_coeffs *precalc_data = s->private_data;
+    int i, j, k = 0;
+    int vq = -1;
+    int64_t err;
+    int64_t min_err = 1ll << 62;
+    int64_t corr[15];
+
+    for (i = 0; i <= DCA_ADPCM_COEFFS; i++)
+        for (j = i; j <= DCA_ADPCM_COEFFS; j++)
+            corr[k++] = calc_corr(in+4, len, i, j);
+
+    for (i = 0; i < DCA_ADPCM_VQCODEBOOK_SZ; i++) {
+        err = apply_filter(ff_dca_adpcm_vb[i], corr, *precalc_data);
+        if (err < min_err) {
+            min_err = err;
+            vq = i;
+        }
+        precalc_data++;
+    }
+
+    return vq;
+}
+
+static inline int64_t calc_prediction_gain(int pred_vq, const int32_t *in, int32_t *out, int len)
+{
+    int i;
+    int32_t error;
+
+    int64_t signal_energy = 0;
+    int64_t error_energy = 0;
+
+    for (i = 0; i < len; i++) {
+        error = in[DCA_ADPCM_COEFFS + i] - ff_dcaadpcm_predict(pred_vq, in + i);
+        out[i] = error;
+        signal_energy += MUL64(in[DCA_ADPCM_COEFFS + i], in[DCA_ADPCM_COEFFS + i]);
+        error_energy += MUL64(error, error);
+    }
+
+    if (!error_energy)
+        return -1;
+
+    return signal_energy / error_energy;
+}
+
+int ff_dcaadpcm_subband_analysis(const DCAADPCMEncContext *s, const int32_t *in, int len, int *diff)
+{
+    int pred_vq, i;
+    int32_t input_buffer[16 + DCA_ADPCM_COEFFS];
+    int32_t input_buffer2[16 + DCA_ADPCM_COEFFS];
+
+    int32_t max = 0;
+    int shift_bits;
+    uint64_t pg = 0;
+
+    for (i = 0; i < len + DCA_ADPCM_COEFFS; i++)
+        max |= FFABS(in[i]);
+
+    // normalize input to simplify apply_filter
+    shift_bits = av_log2(max) - 11;
+
+    for (i = 0; i < len + DCA_ADPCM_COEFFS; i++) {
+        input_buffer[i] = norm__(in[i], 7);
+        input_buffer2[i] = norm__(in[i], shift_bits);
+    }
+
+    pred_vq = find_best_filter(s, input_buffer2, len);
+
+    if (pred_vq < 0)
+        return -1;
+
+    pg = calc_prediction_gain(pred_vq, input_buffer, diff, len);
+
+    // Greater than 10db (10*log(10)) prediction gain to use ADPCM.
+    // TODO: Tune it.
+    if (pg < 10)
+        return -1;
+
+    for (i = 0; i < len; i++)
+        diff[i] <<= 7;
+
+    return pred_vq;
+}
+
+static void precalc(premultiplied_coeffs *data)
+{
+    int i, j, k;
+
+    for (i = 0; i < DCA_ADPCM_VQCODEBOOK_SZ; i++) {
+        int id = 0;
+        int32_t t = 0;
+        for (j = 0; j < DCA_ADPCM_COEFFS; j++) {
+            for (k = j; k < DCA_ADPCM_COEFFS; k++) {
+                t = (int32_t)ff_dca_adpcm_vb[i][j] * (int32_t)ff_dca_adpcm_vb[i][k];
+                if (j != k)
+                    t *= 2;
+                (*data)[id++] = t;
+             }
+        }
+        data++;
+    }
+}
+
+int ff_dcaadpcm_do_real(int pred_vq_index,
+                        softfloat quant, int32_t scale_factor, int32_t step_size,
+                        const int32_t *prev_hist, const int32_t *in, int32_t *next_hist, int32_t *out,
+                        int len, int32_t peak)
+{
+    int i;
+    int64_t delta;
+    int32_t dequant_delta;
+    int32_t work_bufer[16 + DCA_ADPCM_COEFFS];
+
+    memcpy(work_bufer, prev_hist, sizeof(int32_t) * DCA_ADPCM_COEFFS);
+
+    for (i = 0; i < len; i++) {
+        work_bufer[DCA_ADPCM_COEFFS + i] = ff_dcaadpcm_predict(pred_vq_index, &work_bufer[i]);
+
+        delta = (int64_t)in[i] - ((int64_t)work_bufer[DCA_ADPCM_COEFFS + i] << 7);
+
+        out[i] = quantize_value(av_clip64(delta, -peak, peak), quant);
+
+        ff_dca_core_dequantize(&dequant_delta, &out[i], step_size, scale_factor, 0, 1);
+
+        work_bufer[DCA_ADPCM_COEFFS+i] += dequant_delta;
+    }
+
+    memcpy(next_hist, &work_bufer[len], sizeof(int32_t) * DCA_ADPCM_COEFFS);
+
+    return 0;
+}
+
+av_cold int ff_dcaadpcm_init(DCAADPCMEncContext *s)
+{
+    if (!s)
+        return -1;
+
+    s->private_data = av_malloc(sizeof(premultiplied_coeffs) * DCA_ADPCM_VQCODEBOOK_SZ);
+    if (!s->private_data)
+        return AVERROR(ENOMEM);
+
+    precalc(s->private_data);
+    return 0;
+}
+
+av_cold void ff_dcaadpcm_free(DCAADPCMEncContext *s)
+{
+    if (!s)
+        return;
+
+    av_freep(&s->private_data);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/dcaadpcm.h b/mythtv/external/FFmpeg/libavcodec/dcaadpcm.h
new file mode 100644
index 00000000000..23bfa796366
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/dcaadpcm.h
@@ -0,0 +1,54 @@
+/*
+ * DCA ADPCM engine
+ * Copyright (C) 2017 Daniil Cherednik
+ *
+ * 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_DCAADPCM_H
+#define AVCODEC_DCAADPCM_H
+
+#include "dcamath.h"
+#include "dcadata.h"
+#include "dcaenc.h"
+
+typedef struct DCAADPCMEncContext {
+    void *private_data;
+} DCAADPCMEncContext;
+
+static inline int64_t ff_dcaadpcm_predict(int pred_vq_index, const int32_t *input)
+{
+    int i;
+    const int16_t *coeff = ff_dca_adpcm_vb[pred_vq_index];
+    int64_t pred = 0;
+    for (i = 0; i < DCA_ADPCM_COEFFS; i++)
+        pred += (int64_t)input[DCA_ADPCM_COEFFS - 1 - i] * coeff[i];
+
+    return clip23(norm13(pred));
+}
+
+int ff_dcaadpcm_subband_analysis(const DCAADPCMEncContext *s, const int32_t *input, int len, int *diff);
+
+int ff_dcaadpcm_do_real(int pred_vq_index,
+                        softfloat quant, int32_t scale_factor, int32_t step_size,
+                        const int32_t *prev_hist, const int32_t *in, int32_t *next_hist, int32_t *out,
+                        int len, int32_t peak);
+
+av_cold int ff_dcaadpcm_init(DCAADPCMEncContext *s);
+av_cold void ff_dcaadpcm_free(DCAADPCMEncContext *s);
+
+#endif /* AVCODEC_DCAADPCM_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/dcadata.c b/mythtv/external/FFmpeg/libavcodec/dcadata.c
index b2e0f6cfb14..1b646a7aa61 100644
--- a/mythtv/external/FFmpeg/libavcodec/dcadata.c
+++ b/mythtv/external/FFmpeg/libavcodec/dcadata.c
@@ -42,18 +42,22 @@ const uint8_t ff_dca_channels[16] = {
     1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8
 };
 
-const uint8_t ff_dca_bits_per_sample[8] = {
-    16, 16, 20, 20, 0, 24, 24, 0
-};
-
 const uint8_t ff_dca_dmix_primary_nch[8] = {
     1, 2, 2, 3, 3, 4, 4, 0
 };
 
+const uint8_t ff_dca_quant_index_sel_nbits[DCA_CODE_BOOKS] = {
+    1, 2, 2, 2, 2, 3, 3, 3, 3, 3
+};
+
+const uint8_t ff_dca_quant_index_group_size[DCA_CODE_BOOKS] = {
+    1, 3, 3, 3, 3, 7, 7, 7, 7, 7
+};
+
 /* ADPCM data */
 
 /* 16 bits signed fractional Q13 binary codes */
-const int16_t ff_dca_adpcm_vb[4096][4] = {
+const int16_t ff_dca_adpcm_vb[DCA_ADPCM_VQCODEBOOK_SZ][DCA_ADPCM_COEFFS] = {
     {   9928,  -2618,  -1093, -1263 },
     {  11077,  -2876,  -1747,  -308 },
     {  10503,  -1082,  -1426, -1167 },
diff --git a/mythtv/external/FFmpeg/libavcodec/dcadata.h b/mythtv/external/FFmpeg/libavcodec/dcadata.h
index 17aa7120e8b..5aa85b34144 100644
--- a/mythtv/external/FFmpeg/libavcodec/dcadata.h
+++ b/mythtv/external/FFmpeg/libavcodec/dcadata.h
@@ -23,15 +23,21 @@
 
 #include <stdint.h>
 
+#include "dcahuff.h"
+
+#define DCA_ADPCM_COEFFS        4
+#define DCA_ADPCM_VQCODEBOOK_SZ 4096
+
 extern const uint32_t ff_dca_bit_rates[32];
 
 extern const uint8_t ff_dca_channels[16];
 
-extern const uint8_t ff_dca_bits_per_sample[8];
-
 extern const uint8_t ff_dca_dmix_primary_nch[8];
 
-extern const int16_t ff_dca_adpcm_vb[4096][4];
+extern const uint8_t ff_dca_quant_index_sel_nbits[DCA_CODE_BOOKS];
+extern const uint8_t ff_dca_quant_index_group_size[DCA_CODE_BOOKS];
+
+extern const int16_t ff_dca_adpcm_vb[DCA_ADPCM_VQCODEBOOK_SZ][DCA_ADPCM_COEFFS];
 
 extern const uint32_t ff_dca_scale_factor_quant6[64];
 extern const uint32_t ff_dca_scale_factor_quant7[128];
diff --git a/mythtv/external/FFmpeg/libavcodec/dcadec.h b/mythtv/external/FFmpeg/libavcodec/dcadec.h
index 456f3c433bb..9da8d3b444c 100644
--- a/mythtv/external/FFmpeg/libavcodec/dcadec.h
+++ b/mythtv/external/FFmpeg/libavcodec/dcadec.h
@@ -88,9 +88,9 @@ static inline int ff_dca_check_crc(AVCodecContext *avctx, GetBitContext *s,
 
 static inline int ff_dca_seek_bits(GetBitContext *s, int p)
 {
-    if (p < s->index || p > s->size_in_bits)
+    if (p < get_bits_count(s) || p > s->size_in_bits)
         return -1;
-    s->index = p;
+    skip_bits_long(s, p - get_bits_count(s));
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/dcadsp.c b/mythtv/external/FFmpeg/libavcodec/dcadsp.c
index 1cd2e4eddfb..fade1a6c02c 100644
--- a/mythtv/external/FFmpeg/libavcodec/dcadsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/dcadsp.c
@@ -300,7 +300,7 @@ static void decor_c(int32_t *dst, const int32_t *src, int coeff, ptrdiff_t len)
     int i;
 
     for (i = 0; i < len; i++)
-        dst[i] += src[i] * coeff + (1 << 2) >> 3;
+        dst[i] += (SUINT)((int)(src[i] * (SUINT)coeff + (1 << 2)) >> 3);
 }
 
 static void dmix_sub_xch_c(int32_t *dst1, int32_t *dst2,
@@ -320,7 +320,7 @@ static void dmix_sub_c(int32_t *dst, const int32_t *src, int coeff, ptrdiff_t le
     int i;
 
     for (i = 0; i < len; i++)
-        dst[i] -= mul15(src[i], coeff);
+        dst[i] -= (unsigned)mul15(src[i], coeff);
 }
 
 static void dmix_add_c(int32_t *dst, const int32_t *src, int coeff, ptrdiff_t len)
@@ -347,7 +347,7 @@ static void dmix_scale_inv_c(int32_t *dst, int scale_inv, ptrdiff_t len)
         dst[i] = mul16(dst[i], scale_inv);
 }
 
-static void filter0(int32_t *dst, const int32_t *src, int32_t coeff, ptrdiff_t len)
+static void filter0(SUINT32 *dst, const int32_t *src, int32_t coeff, ptrdiff_t len)
 {
     int i;
 
@@ -355,7 +355,7 @@ static void filter0(int32_t *dst, const int32_t *src, int32_t coeff, ptrdiff_t l
         dst[i] -= mul22(src[i], coeff);
 }
 
-static void filter1(int32_t *dst, const int32_t *src, int32_t coeff, ptrdiff_t len)
+static void filter1(SUINT32 *dst, const int32_t *src, int32_t coeff, ptrdiff_t len)
 {
     int i;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/dcaenc.c b/mythtv/external/FFmpeg/libavcodec/dcaenc.c
index 6bb7d2908ca..dd601ffae00 100644
--- a/mythtv/external/FFmpeg/libavcodec/dcaenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/dcaenc.c
@@ -25,8 +25,12 @@
 #include "libavutil/channel_layout.h"
 #include "libavutil/common.h"
 #include "libavutil/ffmath.h"
+#include "libavutil/opt.h"
 #include "avcodec.h"
 #include "dca.h"
+#include "dcaadpcm.h"
+#include "dcamath.h"
+#include "dca_core.h"
 #include "dcadata.h"
 #include "dcaenc.h"
 #include "internal.h"
@@ -44,8 +48,15 @@
 #define SUBBAND_SAMPLES (SUBFRAMES * SUBSUBFRAMES * 8)
 #define AUBANDS 25
 
+typedef struct CompressionOptions {
+    int adpcm_mode;
+} CompressionOptions;
+
 typedef struct DCAEncContext {
+    AVClass *class;
     PutBitContext pb;
+    DCAADPCMEncContext adpcm_ctx;
+    CompressionOptions options;
     int frame_size;
     int frame_bits;
     int fullband_channels;
@@ -61,20 +72,26 @@ typedef struct DCAEncContext {
     int32_t lfe_peak_cb;
     const int8_t *channel_order_tab;  ///< channel reordering table, lfe and non lfe
 
-    int32_t history[512][MAX_CHANNELS]; /* This is a circular buffer */
-    int32_t subband[SUBBAND_SAMPLES][DCAENC_SUBBANDS][MAX_CHANNELS];
-    int32_t quantized[SUBBAND_SAMPLES][DCAENC_SUBBANDS][MAX_CHANNELS];
-    int32_t peak_cb[DCAENC_SUBBANDS][MAX_CHANNELS];
+    int32_t prediction_mode[MAX_CHANNELS][DCAENC_SUBBANDS];
+    int32_t adpcm_history[MAX_CHANNELS][DCAENC_SUBBANDS][DCA_ADPCM_COEFFS * 2];
+    int32_t history[MAX_CHANNELS][512]; /* This is a circular buffer */
+    int32_t *subband[MAX_CHANNELS][DCAENC_SUBBANDS];
+    int32_t quantized[MAX_CHANNELS][DCAENC_SUBBANDS][SUBBAND_SAMPLES];
+    int32_t peak_cb[MAX_CHANNELS][DCAENC_SUBBANDS];
+    int32_t diff_peak_cb[MAX_CHANNELS][DCAENC_SUBBANDS]; ///< expected peak of residual signal
     int32_t downsampled_lfe[DCA_LFE_SAMPLES];
     int32_t masking_curve_cb[SUBSUBFRAMES][256];
-    int abits[DCAENC_SUBBANDS][MAX_CHANNELS];
-    int scale_factor[DCAENC_SUBBANDS][MAX_CHANNELS];
-    softfloat quant[DCAENC_SUBBANDS][MAX_CHANNELS];
+    int32_t bit_allocation_sel[MAX_CHANNELS];
+    int abits[MAX_CHANNELS][DCAENC_SUBBANDS];
+    int scale_factor[MAX_CHANNELS][DCAENC_SUBBANDS];
+    softfloat quant[MAX_CHANNELS][DCAENC_SUBBANDS];
+    int32_t quant_index_sel[MAX_CHANNELS][DCA_CODE_BOOKS];
     int32_t eff_masking_curve_cb[256];
     int32_t band_masking_cb[32];
     int32_t worst_quantization_noise;
     int32_t worst_noise_ever;
     int consumed_bits;
+    int consumed_adpcm_bits; ///< Number of bits to transmit ADPCM related info
 } DCAEncContext;
 
 static int32_t cos_table[2048];
@@ -105,11 +122,41 @@ static double gammafilter(int i, double f)
     return 20 * log10(h);
 }
 
+static int subband_bufer_alloc(DCAEncContext *c)
+{
+    int ch, band;
+    int32_t *bufer = av_calloc(MAX_CHANNELS * DCAENC_SUBBANDS *
+                               (SUBBAND_SAMPLES + DCA_ADPCM_COEFFS),
+                               sizeof(int32_t));
+    if (!bufer)
+        return -1;
+
+    /* we need a place for DCA_ADPCM_COEFF samples from previous frame
+     * to calc prediction coefficients for each subband */
+    for (ch = 0; ch < MAX_CHANNELS; ch++) {
+        for (band = 0; band < DCAENC_SUBBANDS; band++) {
+            c->subband[ch][band] = bufer +
+                                   ch * DCAENC_SUBBANDS * (SUBBAND_SAMPLES + DCA_ADPCM_COEFFS) +
+                                   band * (SUBBAND_SAMPLES + DCA_ADPCM_COEFFS) + DCA_ADPCM_COEFFS;
+        }
+    }
+    return 0;
+}
+
+static void subband_bufer_free(DCAEncContext *c)
+{
+    int32_t *bufer = c->subband[0][0] - DCA_ADPCM_COEFFS;
+    av_freep(&bufer);
+}
+
 static int encode_init(AVCodecContext *avctx)
 {
     DCAEncContext *c = avctx->priv_data;
     uint64_t layout = avctx->channel_layout;
-    int i, min_frame_bits;
+    int i, j, min_frame_bits;
+
+    if (subband_bufer_alloc(c))
+        return AVERROR(ENOMEM);
 
     c->fullband_channels = c->channels = avctx->channels;
     c->lfe_channel = (avctx->channels == 3 || avctx->channels == 6);
@@ -117,6 +164,10 @@ static int encode_init(AVCodecContext *avctx)
     c->band_spectrum = band_spectrum[1];
     c->worst_quantization_noise = -2047;
     c->worst_noise_ever = -2047;
+    c->consumed_adpcm_bits = 0;
+
+    if (ff_dcaadpcm_init(&c->adpcm_ctx))
+        return AVERROR(ENOMEM);
 
     if (!layout) {
         av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The "
@@ -142,6 +193,20 @@ static int encode_init(AVCodecContext *avctx)
         c->channel_order_tab = channel_reorder_nolfe[c->channel_config];
     }
 
+    for (i = 0; i < MAX_CHANNELS; i++) {
+        for (j = 0; j < DCA_CODE_BOOKS; j++) {
+            c->quant_index_sel[i][j] = ff_dca_quant_index_group_size[j];
+        }
+        /* 6 - no Huffman */
+        c->bit_allocation_sel[i] = 6;
+
+        for (j = 0; j < DCAENC_SUBBANDS; j++) {
+            /* -1 - no ADPCM */
+            c->prediction_mode[i][j] = -1;
+            memset(c->adpcm_history[i][j], 0, sizeof(int32_t)*DCA_ADPCM_COEFFS);
+        }
+    }
+
     for (i = 0; i < 9; i++) {
         if (sample_rates[i] == avctx->sample_rate)
             break;
@@ -151,7 +216,7 @@ static int encode_init(AVCodecContext *avctx)
     c->samplerate_index = i;
 
     if (avctx->bit_rate < 32000 || avctx->bit_rate > 3840000) {
-        av_log(avctx, AV_LOG_ERROR, "Bit rate %"PRId64" not supported.", (int64_t)avctx->bit_rate);
+        av_log(avctx, AV_LOG_ERROR, "Bit rate %"PRId64" not supported.", avctx->bit_rate);
         return AVERROR(EINVAL);
     }
     for (i = 0; ff_dca_bit_rates[i] < avctx->bit_rate; i++)
@@ -228,6 +293,16 @@ static int encode_init(AVCodecContext *avctx)
     return 0;
 }
 
+static av_cold int encode_close(AVCodecContext *avctx)
+{
+    if (avctx->priv_data) {
+        DCAEncContext *c = avctx->priv_data;
+        subband_bufer_free(c);
+        ff_dcaadpcm_free(&c->adpcm_ctx);
+    }
+    return 0;
+}
+
 static inline int32_t cos_t(int x)
 {
     return cos_table[x & 2047];
@@ -243,12 +318,6 @@ static inline int32_t half32(int32_t a)
     return (a + 1) >> 1;
 }
 
-static inline int32_t mul32(int32_t a, int32_t b)
-{
-    int64_t r = (int64_t)a * b + 0x80000000ULL;
-    return r >> 32;
-}
-
 static void subband_transform(DCAEncContext *c, const int32_t *input)
 {
     int ch, subs, i, k, j;
@@ -259,8 +328,7 @@ static void subband_transform(DCAEncContext *c, const int32_t *input)
         int hist_start = 0;
         const int chi = c->channel_order_tab[ch];
 
-        for (i = 0; i < 512; i++)
-            hist[i] = c->history[i][ch];
+        memcpy(hist, &c->history[ch][0], 512 * sizeof(int32_t));
 
         for (subs = 0; subs < SUBBAND_SAMPLES; subs++) {
             int32_t accum[64];
@@ -268,8 +336,7 @@ static void subband_transform(DCAEncContext *c, const int32_t *input)
             int band;
 
             /* Calculate the convolutions at once */
-            for (i = 0; i < 64; i++)
-                accum[i] = 0;
+            memset(accum, 0, 64 * sizeof(int32_t));
 
             for (k = 0, i = hist_start, j = 0;
                     i < 512; k = (k + 1) & 63, i++, j++)
@@ -289,12 +356,13 @@ static void subband_transform(DCAEncContext *c, const int32_t *input)
                     resp += mul32(accum[i], cos_t(s << 3)) >> 3;
                 }
 
-                c->subband[subs][band][ch] = ((band + 1) & 2) ? -resp : resp;
+                c->subband[ch][band][subs] = ((band + 1) & 2) ? -resp : resp;
             }
 
             /* Copy in 32 new samples from input */
             for (i = 0; i < 32; i++)
                 hist[i + hist_start] = input[(subs * 32 + i) * c->channels + chi];
+
             hist_start = (hist_start + 32) & 511;
         }
     }
@@ -309,8 +377,7 @@ static void lfe_downsample(DCAEncContext *c, const int32_t *input)
     int32_t accum;
     int hist_start = 0;
 
-    for (i = 0; i < 512; i++)
-        hist[i] = c->history[i][c->channels - 1];
+    memcpy(hist, &c->history[c->channels - 1][0], 512 * sizeof(int32_t));
 
     for (lfes = 0; lfes < DCA_LFE_SAMPLES; lfes++) {
         /* Calculate the convolution */
@@ -516,7 +583,7 @@ static void calc_masking(DCAEncContext *c, const int32_t *input)
             const int chi = c->channel_order_tab[ch];
 
             for (i = 0, k = 128 + 256 * ssf; k < 512; i++, k++)
-                data[i] = c->history[k][ch];
+                data[i] = c->history[ch][k];
             for (k -= 512; i < 512; i++, k++)
                 data[i] = input[k * c->channels + chi];
             adjust_jnd(c->samplerate_index, data, c->masking_curve_cb[ssf]);
@@ -537,72 +604,283 @@ static void calc_masking(DCAEncContext *c, const int32_t *input)
     }
 }
 
+static inline int32_t find_peak(const int32_t *in, int len) {
+    int sample;
+    int32_t m = 0;
+    for (sample = 0; sample < len; sample++) {
+        int32_t s = abs(in[sample]);
+        if (m < s) {
+            m = s;
+        }
+    }
+    return get_cb(m);
+}
+
 static void find_peaks(DCAEncContext *c)
 {
     int band, ch;
 
-    for (band = 0; band < 32; band++)
-        for (ch = 0; ch < c->fullband_channels; ch++) {
-            int sample;
-            int32_t m = 0;
-
-            for (sample = 0; sample < SUBBAND_SAMPLES; sample++) {
-                int32_t s = abs(c->subband[sample][band][ch]);
-                if (m < s)
-                    m = s;
-            }
-            c->peak_cb[band][ch] = get_cb(m);
+    for (ch = 0; ch < c->fullband_channels; ch++) {
+        for (band = 0; band < 32; band++) {
+            c->peak_cb[ch][band] = find_peak(c->subband[ch][band], SUBBAND_SAMPLES);
         }
+    }
 
     if (c->lfe_channel) {
-        int sample;
-        int32_t m = 0;
+        c->lfe_peak_cb = find_peak(c->downsampled_lfe, DCA_LFE_SAMPLES);
+    }
+}
+
+static void adpcm_analysis(DCAEncContext *c)
+{
+    int ch, band;
+    int pred_vq_id;
+    int32_t *samples;
+    int32_t estimated_diff[SUBBAND_SAMPLES];
 
-        for (sample = 0; sample < DCA_LFE_SAMPLES; sample++)
-            if (m < abs(c->downsampled_lfe[sample]))
-                m = abs(c->downsampled_lfe[sample]);
-        c->lfe_peak_cb = get_cb(m);
+    c->consumed_adpcm_bits = 0;
+    for (ch = 0; ch < c->fullband_channels; ch++) {
+        for (band = 0; band < 32; band++) {
+            samples = c->subband[ch][band] - DCA_ADPCM_COEFFS;
+            pred_vq_id = ff_dcaadpcm_subband_analysis(&c->adpcm_ctx, samples, SUBBAND_SAMPLES, estimated_diff);
+            if (pred_vq_id >= 0) {
+                c->prediction_mode[ch][band] = pred_vq_id;
+                c->consumed_adpcm_bits += 12; //12 bits to transmit prediction vq index
+                c->diff_peak_cb[ch][band] = find_peak(estimated_diff, 16);
+            } else {
+                c->prediction_mode[ch][band] = -1;
+            }
+        }
     }
 }
 
 static const int snr_fudge = 128;
 #define USED_1ABITS 1
-#define USED_NABITS 2
 #define USED_26ABITS 4
 
-static int init_quantization_noise(DCAEncContext *c, int noise)
+static inline int32_t get_step_size(const DCAEncContext *c, int ch, int band)
+{
+    int32_t step_size;
+
+    if (c->bitrate_index == 3)
+        step_size = ff_dca_lossless_quant[c->abits[ch][band]];
+    else
+        step_size = ff_dca_lossy_quant[c->abits[ch][band]];
+
+    return step_size;
+}
+
+static int calc_one_scale(int32_t peak_cb, int abits, softfloat *quant)
+{
+    int32_t peak;
+    int our_nscale, try_remove;
+    softfloat our_quant;
+
+    av_assert0(peak_cb <= 0);
+    av_assert0(peak_cb >= -2047);
+
+    our_nscale = 127;
+    peak = cb_to_level[-peak_cb];
+
+    for (try_remove = 64; try_remove > 0; try_remove >>= 1) {
+        if (scalefactor_inv[our_nscale - try_remove].e + stepsize_inv[abits].e <= 17)
+            continue;
+        our_quant.m = mul32(scalefactor_inv[our_nscale - try_remove].m, stepsize_inv[abits].m);
+        our_quant.e = scalefactor_inv[our_nscale - try_remove].e + stepsize_inv[abits].e - 17;
+        if ((ff_dca_quant_levels[abits] - 1) / 2 < quantize_value(peak, our_quant))
+            continue;
+        our_nscale -= try_remove;
+    }
+
+    if (our_nscale >= 125)
+        our_nscale = 124;
+
+    quant->m = mul32(scalefactor_inv[our_nscale].m, stepsize_inv[abits].m);
+    quant->e = scalefactor_inv[our_nscale].e + stepsize_inv[abits].e - 17;
+    av_assert0((ff_dca_quant_levels[abits] - 1) / 2 >= quantize_value(peak, *quant));
+
+    return our_nscale;
+}
+
+static inline void quantize_adpcm_subband(DCAEncContext *c, int ch, int band)
+{
+    int32_t step_size;
+    int32_t diff_peak_cb = c->diff_peak_cb[ch][band];
+    c->scale_factor[ch][band] = calc_one_scale(diff_peak_cb,
+                                               c->abits[ch][band],
+                                               &c->quant[ch][band]);
+
+    step_size = get_step_size(c, ch, band);
+    ff_dcaadpcm_do_real(c->prediction_mode[ch][band],
+                        c->quant[ch][band], ff_dca_scale_factor_quant7[c->scale_factor[ch][band]], step_size,
+                        c->adpcm_history[ch][band], c->subband[ch][band], c->adpcm_history[ch][band]+4, c->quantized[ch][band],
+                        SUBBAND_SAMPLES, cb_to_level[-diff_peak_cb]);
+}
+
+static void quantize_adpcm(DCAEncContext *c)
+{
+    int band, ch;
+
+    for (ch = 0; ch < c->fullband_channels; ch++)
+        for (band = 0; band < 32; band++)
+            if (c->prediction_mode[ch][band] >= 0)
+                quantize_adpcm_subband(c, ch, band);
+}
+
+static void quantize_pcm(DCAEncContext *c)
+{
+    int sample, band, ch;
+
+    for (ch = 0; ch < c->fullband_channels; ch++)
+        for (band = 0; band < 32; band++)
+            if (c->prediction_mode[ch][band] == -1)
+                for (sample = 0; sample < SUBBAND_SAMPLES; sample++)
+                    c->quantized[ch][band][sample] = quantize_value(c->subband[ch][band][sample], c->quant[ch][band]);
+}
+
+static void accumulate_huff_bit_consumption(int abits, int32_t *quantized, uint32_t *result)
+{
+    uint8_t sel, id = abits - 1;
+    for (sel = 0; sel < ff_dca_quant_index_group_size[id]; sel++)
+        result[sel] += ff_dca_vlc_calc_quant_bits(quantized, SUBBAND_SAMPLES, sel, id);
+}
+
+static uint32_t set_best_code(uint32_t vlc_bits[DCA_CODE_BOOKS][7], uint32_t clc_bits[DCA_CODE_BOOKS], int32_t res[DCA_CODE_BOOKS])
+{
+    uint8_t i, sel;
+    uint32_t best_sel_bits[DCA_CODE_BOOKS];
+    int32_t best_sel_id[DCA_CODE_BOOKS];
+    uint32_t t, bits = 0;
+
+    for (i = 0; i < DCA_CODE_BOOKS; i++) {
+
+        av_assert0(!((!!vlc_bits[i][0]) ^ (!!clc_bits[i])));
+        if (vlc_bits[i][0] == 0) {
+            /* do not transmit adjustment index for empty codebooks */
+            res[i] = ff_dca_quant_index_group_size[i];
+            /* and skip it */
+            continue;
+        }
+
+        best_sel_bits[i] = vlc_bits[i][0];
+        best_sel_id[i] = 0;
+        for (sel = 0; sel < ff_dca_quant_index_group_size[i]; sel++) {
+            if (best_sel_bits[i] > vlc_bits[i][sel] && vlc_bits[i][sel]) {
+                best_sel_bits[i] = vlc_bits[i][sel];
+                best_sel_id[i] = sel;
+            }
+        }
+
+        /* 2 bits to transmit scale factor adjustment index */
+        t = best_sel_bits[i] + 2;
+        if (t < clc_bits[i]) {
+            res[i] = best_sel_id[i];
+            bits += t;
+        } else {
+            res[i] = ff_dca_quant_index_group_size[i];
+            bits += clc_bits[i];
+        }
+    }
+    return bits;
+}
+
+static uint32_t set_best_abits_code(int abits[DCAENC_SUBBANDS], int bands, int32_t *res)
 {
-    int ch, band, ret = 0;
+    uint8_t i;
+    uint32_t t;
+    int32_t best_sel = 6;
+    int32_t best_bits = bands * 5;
+
+    /* Check do we have subband which cannot be encoded by Huffman tables */
+    for (i = 0; i < bands; i++) {
+        if (abits[i] > 12 || abits[i] == 0) {
+            *res = best_sel;
+            return best_bits;
+        }
+    }
 
-    c->consumed_bits = 132 + 493 * c->fullband_channels;
+    for (i = 0; i < DCA_BITALLOC_12_COUNT; i++) {
+        t = ff_dca_vlc_calc_alloc_bits(abits, bands, i);
+        if (t < best_bits) {
+            best_bits = t;
+            best_sel = i;
+        }
+    }
+
+    *res = best_sel;
+    return best_bits;
+}
+
+static int init_quantization_noise(DCAEncContext *c, int noise, int forbid_zero)
+{
+    int ch, band, ret = USED_26ABITS | USED_1ABITS;
+    uint32_t huff_bit_count_accum[MAX_CHANNELS][DCA_CODE_BOOKS][7];
+    uint32_t clc_bit_count_accum[MAX_CHANNELS][DCA_CODE_BOOKS];
+    uint32_t bits_counter = 0;
+
+    c->consumed_bits = 132 + 333 * c->fullband_channels;
+    c->consumed_bits += c->consumed_adpcm_bits;
     if (c->lfe_channel)
         c->consumed_bits += 72;
 
     /* attempt to guess the bit distribution based on the prevoius frame */
     for (ch = 0; ch < c->fullband_channels; ch++) {
         for (band = 0; band < 32; band++) {
-            int snr_cb = c->peak_cb[band][ch] - c->band_masking_cb[band] - noise;
+            int snr_cb = c->peak_cb[ch][band] - c->band_masking_cb[band] - noise;
 
             if (snr_cb >= 1312) {
-                c->abits[band][ch] = 26;
-                ret |= USED_26ABITS;
+                c->abits[ch][band] = 26;
+                ret &= ~USED_1ABITS;
             } else if (snr_cb >= 222) {
-                c->abits[band][ch] = 8 + mul32(snr_cb - 222, 69000000);
-                ret |= USED_NABITS;
+                c->abits[ch][band] = 8 + mul32(snr_cb - 222, 69000000);
+                ret &= ~(USED_26ABITS | USED_1ABITS);
             } else if (snr_cb >= 0) {
-                c->abits[band][ch] = 2 + mul32(snr_cb, 106000000);
-                ret |= USED_NABITS;
+                c->abits[ch][band] = 2 + mul32(snr_cb, 106000000);
+                ret &= ~(USED_26ABITS | USED_1ABITS);
+            } else if (forbid_zero || snr_cb >= -140) {
+                c->abits[ch][band] = 1;
+                ret &= ~USED_26ABITS;
             } else {
-                c->abits[band][ch] = 1;
-                ret |= USED_1ABITS;
+                c->abits[ch][band] = 0;
+                ret &= ~(USED_26ABITS | USED_1ABITS);
             }
         }
+        c->consumed_bits += set_best_abits_code(c->abits[ch], 32, &c->bit_allocation_sel[ch]);
     }
 
-    for (band = 0; band < 32; band++)
-        for (ch = 0; ch < c->fullband_channels; ch++) {
-            c->consumed_bits += bit_consumption[c->abits[band][ch]];
+    /* Recalc scale_factor each time to get bits consumption in case of Huffman coding.
+       It is suboptimal solution */
+    /* TODO: May be cache scaled values */
+    for (ch = 0; ch < c->fullband_channels; ch++) {
+        for (band = 0; band < 32; band++) {
+            if (c->prediction_mode[ch][band] == -1) {
+                c->scale_factor[ch][band] = calc_one_scale(c->peak_cb[ch][band],
+                                                           c->abits[ch][band],
+                                                           &c->quant[ch][band]);
+            }
         }
+    }
+    quantize_adpcm(c);
+    quantize_pcm(c);
+
+    memset(huff_bit_count_accum, 0, MAX_CHANNELS * DCA_CODE_BOOKS * 7 * sizeof(uint32_t));
+    memset(clc_bit_count_accum, 0, MAX_CHANNELS * DCA_CODE_BOOKS * sizeof(uint32_t));
+    for (ch = 0; ch < c->fullband_channels; ch++) {
+        for (band = 0; band < 32; band++) {
+            if (c->abits[ch][band] && c->abits[ch][band] <= DCA_CODE_BOOKS) {
+                accumulate_huff_bit_consumption(c->abits[ch][band], c->quantized[ch][band], huff_bit_count_accum[ch][c->abits[ch][band] - 1]);
+                clc_bit_count_accum[ch][c->abits[ch][band] - 1] += bit_consumption[c->abits[ch][band]];
+            } else {
+                bits_counter += bit_consumption[c->abits[ch][band]];
+            }
+        }
+    }
+
+    for (ch = 0; ch < c->fullband_channels; ch++) {
+        bits_counter += set_best_code(huff_bit_count_accum[ch], clc_bit_count_accum[ch], c->quant_index_sel[ch]);
+    }
+
+    c->consumed_bits += bits_counter;
 
     return ret;
 }
@@ -612,15 +890,19 @@ static void assign_bits(DCAEncContext *c)
     /* Find the bounds where the binary search should work */
     int low, high, down;
     int used_abits = 0;
-
-    init_quantization_noise(c, c->worst_quantization_noise);
+    int forbid_zero = 1;
+restart:
+    init_quantization_noise(c, c->worst_quantization_noise, forbid_zero);
     low = high = c->worst_quantization_noise;
     if (c->consumed_bits > c->frame_bits) {
         while (c->consumed_bits > c->frame_bits) {
-            av_assert0(used_abits != USED_1ABITS);
+            if (used_abits == USED_1ABITS && forbid_zero) {
+                forbid_zero = 0;
+                goto restart;
+            }
             low = high;
             high += snr_fudge;
-            used_abits = init_quantization_noise(c, high);
+            used_abits = init_quantization_noise(c, high, forbid_zero);
         }
     } else {
         while (c->consumed_bits <= c->frame_bits) {
@@ -628,17 +910,17 @@ static void assign_bits(DCAEncContext *c)
             if (used_abits == USED_26ABITS)
                 goto out; /* The requested bitrate is too high, pad with zeros */
             low -= snr_fudge;
-            used_abits = init_quantization_noise(c, low);
+            used_abits = init_quantization_noise(c, low, forbid_zero);
         }
     }
 
     /* Now do a binary search between low and high to see what fits */
     for (down = snr_fudge >> 1; down; down >>= 1) {
-        init_quantization_noise(c, high - down);
+        init_quantization_noise(c, high - down, forbid_zero);
         if (c->consumed_bits <= c->frame_bits)
             high -= down;
     }
-    init_quantization_noise(c, high);
+    init_quantization_noise(c, high, forbid_zero);
 out:
     c->worst_quantization_noise = high;
     if (high > c->worst_noise_ever)
@@ -653,75 +935,51 @@ static void shift_history(DCAEncContext *c, const int32_t *input)
         for (ch = 0; ch < c->channels; ch++) {
             const int chi = c->channel_order_tab[ch];
 
-            c->history[k][ch] = input[k * c->channels + chi];
+            c->history[ch][k] = input[k * c->channels + chi];
         }
 }
 
-static int32_t quantize_value(int32_t value, softfloat quant)
-{
-    int32_t offset = 1 << (quant.e - 1);
-
-    value = mul32(value, quant.m) + offset;
-    value = value >> quant.e;
-    return value;
-}
-
-static int calc_one_scale(int32_t peak_cb, int abits, softfloat *quant)
+static void fill_in_adpcm_bufer(DCAEncContext *c)
 {
-    int32_t peak;
-    int our_nscale, try_remove;
-    softfloat our_quant;
-
-    av_assert0(peak_cb <= 0);
-    av_assert0(peak_cb >= -2047);
-
-    our_nscale = 127;
-    peak = cb_to_level[-peak_cb];
-
-    for (try_remove = 64; try_remove > 0; try_remove >>= 1) {
-        if (scalefactor_inv[our_nscale - try_remove].e + stepsize_inv[abits].e <= 17)
-            continue;
-        our_quant.m = mul32(scalefactor_inv[our_nscale - try_remove].m, stepsize_inv[abits].m);
-        our_quant.e = scalefactor_inv[our_nscale - try_remove].e + stepsize_inv[abits].e - 17;
-        if ((ff_dca_quant_levels[abits] - 1) / 2 < quantize_value(peak, our_quant))
-            continue;
-        our_nscale -= try_remove;
-    }
-
-    if (our_nscale >= 125)
-        our_nscale = 124;
-
-    quant->m = mul32(scalefactor_inv[our_nscale].m, stepsize_inv[abits].m);
-    quant->e = scalefactor_inv[our_nscale].e + stepsize_inv[abits].e - 17;
-    av_assert0((ff_dca_quant_levels[abits] - 1) / 2 >= quantize_value(peak, *quant));
+     int ch, band;
+     int32_t step_size;
+     /* We fill in ADPCM work buffer for subbands which hasn't been ADPCM coded
+      * in current frame - we need this data if subband of next frame is
+      * ADPCM
+      */
+     for (ch = 0; ch < c->channels; ch++) {
+        for (band = 0; band < 32; band++) {
+            int32_t *samples = c->subband[ch][band] - DCA_ADPCM_COEFFS;
+            if (c->prediction_mode[ch][band] == -1) {
+                step_size = get_step_size(c, ch, band);
 
-    return our_nscale;
+                ff_dca_core_dequantize(c->adpcm_history[ch][band],
+                                       c->quantized[ch][band]+12, step_size, ff_dca_scale_factor_quant7[c->scale_factor[ch][band]], 0, 4);
+            } else {
+                AV_COPY128U(c->adpcm_history[ch][band], c->adpcm_history[ch][band]+4);
+            }
+            /* Copy dequantized values for LPC analysis.
+             * It reduces artifacts in case of extreme quantization,
+             * example: in current frame abits is 1 and has no prediction flag,
+             * but end of this frame is sine like signal. In this case, if LPC analysis uses
+             * original values, likely LPC analysis returns good prediction gain, and sets prediction flag.
+             * But there are no proper value in decoder history, so likely result will be no good.
+             * Bitstream has "Predictor history flag switch", but this flag disables history for all subbands
+             */
+            samples[0] = c->adpcm_history[ch][band][0] << 7;
+            samples[1] = c->adpcm_history[ch][band][1] << 7;
+            samples[2] = c->adpcm_history[ch][band][2] << 7;
+            samples[3] = c->adpcm_history[ch][band][3] << 7;
+        }
+     }
 }
 
-static void calc_scales(DCAEncContext *c)
+static void calc_lfe_scales(DCAEncContext *c)
 {
-    int band, ch;
-
-    for (band = 0; band < 32; band++)
-        for (ch = 0; ch < c->fullband_channels; ch++)
-            c->scale_factor[band][ch] = calc_one_scale(c->peak_cb[band][ch],
-                                                       c->abits[band][ch],
-                                                       &c->quant[band][ch]);
-
     if (c->lfe_channel)
         c->lfe_scale_factor = calc_one_scale(c->lfe_peak_cb, 11, &c->lfe_quant);
 }
 
-static void quantize_all(DCAEncContext *c)
-{
-    int sample, band, ch;
-
-    for (sample = 0; sample < SUBBAND_SAMPLES; sample++)
-        for (band = 0; band < 32; band++)
-            for (ch = 0; ch < c->fullband_channels; ch++)
-                c->quantized[sample][band][ch] = quantize_value(c->subband[sample][band][ch], c->quant[band][ch]);
-}
-
 static void put_frame_header(DCAEncContext *c)
 {
     /* SYNC */
@@ -807,9 +1065,6 @@ static void put_frame_header(DCAEncContext *c)
 
 static void put_primary_audio_header(DCAEncContext *c)
 {
-    static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
-    static const int thr[11]    = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
-
     int ch, i;
     /* Number of subframes */
     put_bits(&c->pb, 4, SUBFRAMES - 1);
@@ -839,38 +1094,53 @@ static void put_primary_audio_header(DCAEncContext *c)
 
     /* Bit allocation quantizer select: linear 5-bit */
     for (ch = 0; ch < c->fullband_channels; ch++)
-        put_bits(&c->pb, 3, 6);
+        put_bits(&c->pb, 3, c->bit_allocation_sel[ch]);
 
-    /* Quantization index codebook select: dummy data
-       to avoid transmission of scale factor adjustment */
-    for (i = 1; i < 11; i++)
+    /* Quantization index codebook select */
+    for (i = 0; i < DCA_CODE_BOOKS; i++)
         for (ch = 0; ch < c->fullband_channels; ch++)
-            put_bits(&c->pb, bitlen[i], thr[i]);
+            put_bits(&c->pb, ff_dca_quant_index_sel_nbits[i], c->quant_index_sel[ch][i]);
+
+    /* Scale factor adjustment index: transmitted in case of Huffman coding */
+    for (i = 0; i < DCA_CODE_BOOKS; i++)
+        for (ch = 0; ch < c->fullband_channels; ch++)
+            if (c->quant_index_sel[ch][i] < ff_dca_quant_index_group_size[i])
+                put_bits(&c->pb, 2, 0);
 
-    /* Scale factor adjustment index: not transmitted */
     /* Audio header CRC check word: not transmitted */
 }
 
 static void put_subframe_samples(DCAEncContext *c, int ss, int band, int ch)
 {
-    if (c->abits[band][ch] <= 7) {
-        int sum, i, j;
-        for (i = 0; i < 8; i += 4) {
-            sum = 0;
-            for (j = 3; j >= 0; j--) {
-                sum *= ff_dca_quant_levels[c->abits[band][ch]];
-                sum += c->quantized[ss * 8 + i + j][band][ch];
-                sum += (ff_dca_quant_levels[c->abits[band][ch]] - 1) / 2;
-            }
-            put_bits(&c->pb, bit_consumption[c->abits[band][ch]] / 4, sum);
+    int i, j, sum, bits, sel;
+    if (c->abits[ch][band] <= DCA_CODE_BOOKS) {
+        av_assert0(c->abits[ch][band] > 0);
+        sel = c->quant_index_sel[ch][c->abits[ch][band] - 1];
+        // Huffman codes
+        if (sel < ff_dca_quant_index_group_size[c->abits[ch][band] - 1]) {
+            ff_dca_vlc_enc_quant(&c->pb, &c->quantized[ch][band][ss * 8], 8, sel, c->abits[ch][band] - 1);
+            return;
         }
-    } else {
-        int i;
-        for (i = 0; i < 8; i++) {
-            int bits = bit_consumption[c->abits[band][ch]] / 16;
-            put_sbits(&c->pb, bits, c->quantized[ss * 8 + i][band][ch]);
+
+        // Block codes
+        if (c->abits[ch][band] <= 7) {
+            for (i = 0; i < 8; i += 4) {
+                sum = 0;
+                for (j = 3; j >= 0; j--) {
+                    sum *= ff_dca_quant_levels[c->abits[ch][band]];
+                    sum += c->quantized[ch][band][ss * 8 + i + j];
+                    sum += (ff_dca_quant_levels[c->abits[ch][band]] - 1) / 2;
+                }
+                put_bits(&c->pb, bit_consumption[c->abits[ch][band]] / 4, sum);
+            }
+            return;
         }
     }
+
+    for (i = 0; i < 8; i++) {
+        bits = bit_consumption[c->abits[ch][band]] / 16;
+        put_sbits(&c->pb, bits, c->quantized[ch][band][ss * 8 + i]);
+    }
 }
 
 static void put_subframe(DCAEncContext *c, int subframe)
@@ -886,25 +1156,38 @@ static void put_subframe(DCAEncContext *c, int subframe)
     /* Prediction mode: no ADPCM, in each channel and subband */
     for (ch = 0; ch < c->fullband_channels; ch++)
         for (band = 0; band < DCAENC_SUBBANDS; band++)
-            put_bits(&c->pb, 1, 0);
+            put_bits(&c->pb, 1, !(c->prediction_mode[ch][band] == -1));
 
-    /* Prediction VQ address: not transmitted */
-    /* Bit allocation index */
+    /* Prediction VQ address */
     for (ch = 0; ch < c->fullband_channels; ch++)
         for (band = 0; band < DCAENC_SUBBANDS; band++)
-            put_bits(&c->pb, 5, c->abits[band][ch]);
+            if (c->prediction_mode[ch][band] >= 0)
+                put_bits(&c->pb, 12, c->prediction_mode[ch][band]);
+
+    /* Bit allocation index */
+    for (ch = 0; ch < c->fullband_channels; ch++) {
+        if (c->bit_allocation_sel[ch] == 6) {
+            for (band = 0; band < DCAENC_SUBBANDS; band++) {
+                put_bits(&c->pb, 5, c->abits[ch][band]);
+            }
+        } else {
+            ff_dca_vlc_enc_alloc(&c->pb, c->abits[ch], DCAENC_SUBBANDS, c->bit_allocation_sel[ch]);
+        }
+    }
 
     if (SUBSUBFRAMES > 1) {
         /* Transition mode: none for each channel and subband */
         for (ch = 0; ch < c->fullband_channels; ch++)
             for (band = 0; band < DCAENC_SUBBANDS; band++)
-                put_bits(&c->pb, 1, 0); /* codebook A4 */
+                if (c->abits[ch][band])
+                    put_bits(&c->pb, 1, 0); /* codebook A4 */
     }
 
     /* Scale factors */
     for (ch = 0; ch < c->fullband_channels; ch++)
         for (band = 0; band < DCAENC_SUBBANDS; band++)
-            put_bits(&c->pb, 7, c->scale_factor[band][ch]);
+            if (c->abits[ch][band])
+                put_bits(&c->pb, 7, c->scale_factor[ch][band]);
 
     /* Joint subband scale factor codebook select: not transmitted */
     /* Scale factors for joint subband coding: not transmitted */
@@ -924,6 +1207,7 @@ static void put_subframe(DCAEncContext *c, int subframe)
     for (ss = 0; ss < SUBSUBFRAMES ; ss++)
         for (ch = 0; ch < c->fullband_channels; ch++)
             for (band = 0; band < DCAENC_SUBBANDS; band++)
+                if (c->abits[ch][band])
                     put_subframe_samples(c, ss, band, ch);
 
     /* DSYNC */
@@ -947,13 +1231,15 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
         lfe_downsample(c, samples);
 
     calc_masking(c, samples);
+    if (c->options.adpcm_mode)
+        adpcm_analysis(c);
     find_peaks(c);
     assign_bits(c);
-    calc_scales(c);
-    quantize_all(c);
+    calc_lfe_scales(c);
     shift_history(c, samples);
 
     init_put_bits(&c->pb, avpkt->data, avpkt->size);
+    fill_in_adpcm_bufer(c);
     put_frame_header(c);
     put_primary_audio_header(c);
     for (i = 0; i < SUBFRAMES; i++)
@@ -972,6 +1258,20 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     return 0;
 }
 
+#define DCAENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
+
+static const AVOption options[] = {
+    { "dca_adpcm", "Use ADPCM encoding", offsetof(DCAEncContext, options.adpcm_mode), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DCAENC_FLAGS },
+    { NULL },
+};
+
+static const AVClass dcaenc_class = {
+    .class_name = "DCA (DTS Coherent Acoustics)",
+    .item_name = av_default_item_name,
+    .option = options,
+    .version = LIBAVUTIL_VERSION_INT,
+};
+
 static const AVCodecDefault defaults[] = {
     { "b",          "1411200" },
     { NULL },
@@ -984,6 +1284,7 @@ AVCodec ff_dca_encoder = {
     .id                    = AV_CODEC_ID_DTS,
     .priv_data_size        = sizeof(DCAEncContext),
     .init                  = encode_init,
+    .close                 = encode_close,
     .encode2               = encode_frame,
     .capabilities          = AV_CODEC_CAP_EXPERIMENTAL,
     .sample_fmts           = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32,
@@ -996,4 +1297,5 @@ AVCodec ff_dca_encoder = {
                                                   AV_CH_LAYOUT_5POINT1,
                                                   0 },
     .defaults              = defaults,
+    .priv_class            = &dcaenc_class,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/dcaenc.h b/mythtv/external/FFmpeg/libavcodec/dcaenc.h
index eccfb423210..63fdaf074eb 100644
--- a/mythtv/external/FFmpeg/libavcodec/dcaenc.h
+++ b/mythtv/external/FFmpeg/libavcodec/dcaenc.h
@@ -24,6 +24,8 @@
 
 #include <stdint.h>
 
+#include "dcamath.h"
+
 typedef struct {
     int32_t m;
     int32_t e;
@@ -95,7 +97,6 @@ static const softfloat scalefactor_inv[128] = {
 
 /* manually derived from
  * Table B.5: Selection of quantization levels and codebooks
- * FIXME: will become invalid when Huffman codes are introduced.
  */
 static const int bit_consumption[27] = {
     -8, 28, 40, 48, 52, 60, 68, 76, 80, 96,
@@ -145,4 +146,13 @@ static const int8_t channel_reorder_nolfe[16][9] = {
     { 3,  2,  4,  0,  1,  5,  7,  6, -1 },
 };
 
+static inline int32_t quantize_value(int32_t value, softfloat quant)
+{
+    int32_t offset = 1 << (quant.e - 1);
+
+    value = mul32(value, quant.m) + offset;
+    value = value >> quant.e;
+    return value;
+}
+
 #endif /* AVCODEC_DCAENC_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/dcahuff.c b/mythtv/external/FFmpeg/libavcodec/dcahuff.c
index bea35302145..0a3eeb4d224 100644
--- a/mythtv/external/FFmpeg/libavcodec/dcahuff.c
+++ b/mythtv/external/FFmpeg/libavcodec/dcahuff.c
@@ -42,13 +42,12 @@ static const uint8_t tmode_bits[TMODE_COUNT][4] = {
     { 2, 2, 2, 2 }
 };
 
-#define BITALLOC_12_COUNT    5
 #define BITALLOC_12_VLC_BITS 9
-static const uint8_t bitalloc_12_vlc_bits[BITALLOC_12_COUNT] = {
+static const uint8_t bitalloc_12_vlc_bits[DCA_BITALLOC_12_COUNT] = {
     9, 7, 7, 9, 9
 };
 
-static const uint16_t bitalloc_12_codes[BITALLOC_12_COUNT][12] = {
+static const uint16_t bitalloc_12_codes[DCA_BITALLOC_12_COUNT][12] = {
     { 0x0000, 0x0002, 0x0006, 0x000E, 0x001E, 0x003E, 0x00FF, 0x00FE,
       0x01FB, 0x01FA, 0x01F9, 0x01F8, },
     { 0x0001, 0x0000, 0x0002, 0x000F, 0x000C, 0x001D, 0x0039, 0x0038,
@@ -61,7 +60,7 @@ static const uint16_t bitalloc_12_codes[BITALLOC_12_COUNT][12] = {
       0x0079, 0x0078, 0x00FB, 0x00FA, }
 };
 
-static const uint8_t bitalloc_12_bits[BITALLOC_12_COUNT][12] = {
+static const uint8_t bitalloc_12_bits[DCA_BITALLOC_12_COUNT][12] = {
     { 1, 2, 3, 4, 5, 6, 8, 8, 9, 9,  9,  9 },
     { 1, 2, 3, 5, 5, 6, 7, 7, 7, 7,  7,  7 },
     { 2, 3, 3, 3, 3, 4, 4, 4, 5, 6,  7,  7 },
@@ -1335,3 +1334,45 @@ av_cold void ff_dca_init_vlcs(void)
 
     vlcs_initialized = 1;
 }
+
+uint32_t ff_dca_vlc_calc_quant_bits(int *values, uint8_t n, uint8_t sel, uint8_t table)
+{
+    uint8_t i, id;
+    uint32_t sum = 0;
+    for (i = 0; i < n; i++) {
+        id = values[i] - bitalloc_offsets[table];
+        av_assert0(id < bitalloc_sizes[table]);
+        sum += bitalloc_bits[table][sel][id];
+    }
+    return sum;
+}
+
+void ff_dca_vlc_enc_quant(PutBitContext *pb, int *values, uint8_t n, uint8_t sel, uint8_t table)
+{
+    uint8_t i, id;
+    for (i = 0; i < n; i++) {
+        id = values[i] - bitalloc_offsets[table];
+        av_assert0(id < bitalloc_sizes[table]);
+        put_bits(pb, bitalloc_bits[table][sel][id], bitalloc_codes[table][sel][id]);
+    }
+}
+
+uint32_t ff_dca_vlc_calc_alloc_bits(int *values, uint8_t n, uint8_t sel)
+{
+    uint8_t i, id;
+    uint32_t sum = 0;
+    for (i = 0; i < n; i++) {
+        id = values[i] - 1;
+        sum += bitalloc_12_bits[sel][id];
+    }
+    return sum;
+}
+
+void ff_dca_vlc_enc_alloc(PutBitContext *pb, int *values, uint8_t n, uint8_t sel)
+{
+    uint8_t i, id;
+    for (i = 0; i < n; i++) {
+        id = values[i] - 1;
+        put_bits(pb, bitalloc_12_bits[sel][id], bitalloc_12_codes[sel][id]);
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/dcahuff.h b/mythtv/external/FFmpeg/libavcodec/dcahuff.h
index b1d5735d575..02b0e375aeb 100644
--- a/mythtv/external/FFmpeg/libavcodec/dcahuff.h
+++ b/mythtv/external/FFmpeg/libavcodec/dcahuff.h
@@ -27,8 +27,10 @@
 
 #include "avcodec.h"
 #include "get_bits.h"
+#include "put_bits.h"
 
 #define DCA_CODE_BOOKS      10
+#define DCA_BITALLOC_12_COUNT    5
 
 typedef struct DCAVLC {
     int offset;         ///< Code values offset
@@ -55,5 +57,9 @@ extern VLC  ff_dca_vlc_grid_3;
 extern VLC  ff_dca_vlc_rsd;
 
 av_cold void ff_dca_init_vlcs(void);
+uint32_t ff_dca_vlc_calc_quant_bits(int *values, uint8_t n, uint8_t sel, uint8_t abits);
+void ff_dca_vlc_enc_quant(PutBitContext *pb, int *values, uint8_t n, uint8_t sel, uint8_t abits);
+uint32_t ff_dca_vlc_calc_alloc_bits(int *values, uint8_t n, uint8_t sel);
+void ff_dca_vlc_enc_alloc(PutBitContext *pb, int *values, uint8_t n, uint8_t sel);
 
 #endif /* AVCODEC_DCAHUFF_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/dcamath.h b/mythtv/external/FFmpeg/libavcodec/dcamath.h
index e0d6f4fdaa2..38fa9a6235b 100644
--- a/mythtv/external/FFmpeg/libavcodec/dcamath.h
+++ b/mythtv/external/FFmpeg/libavcodec/dcamath.h
@@ -49,6 +49,7 @@ static inline int32_t mul17(int32_t a, int32_t b) { return mul__(a, b, 17); }
 static inline int32_t mul22(int32_t a, int32_t b) { return mul__(a, b, 22); }
 static inline int32_t mul23(int32_t a, int32_t b) { return mul__(a, b, 23); }
 static inline int32_t mul31(int32_t a, int32_t b) { return mul__(a, b, 31); }
+static inline int32_t mul32(int32_t a, int32_t b) { return mul__(a, b, 32); }
 
 static inline int32_t clip23(int32_t a) { return av_clip_intp2(a, 23); }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/dct.h b/mythtv/external/FFmpeg/libavcodec/dct.h
index 05297ba9dbf..0a03e256d13 100644
--- a/mythtv/external/FFmpeg/libavcodec/dct.h
+++ b/mythtv/external/FFmpeg/libavcodec/dct.h
@@ -24,6 +24,7 @@
 #if !defined(AVCODEC_DCT_H) && (!defined(FFT_FLOAT) || FFT_FLOAT)
 #define AVCODEC_DCT_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "rdft.h"
@@ -62,7 +63,7 @@ void ff_j_rev_dct(int16_t *data);
 void ff_j_rev_dct4(int16_t *data);
 void ff_j_rev_dct2(int16_t *data);
 void ff_j_rev_dct1(int16_t *data);
-void ff_jref_idct_put(uint8_t *dest, int line_size, int16_t *block);
-void ff_jref_idct_add(uint8_t *dest, int line_size, int16_t *block);
+void ff_jref_idct_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_jref_idct_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 
 #endif /* AVCODEC_DCT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/dct32_template.c b/mythtv/external/FFmpeg/libavcodec/dct32_template.c
index c70396e5f54..51cebc053fd 100644
--- a/mythtv/external/FFmpeg/libavcodec/dct32_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/dct32_template.c
@@ -21,17 +21,28 @@
 
 #include "dct32.h"
 #include "mathops.h"
+#include "libavutil/internal.h"
+
+#ifdef CHECKED
+#define SUINT   int
+#define SUINT32 int32_t
+#else
+#define SUINT   unsigned
+#define SUINT32 uint32_t
+#endif
 
 #if DCT32_FLOAT
 #   define dct32 ff_dct32_float
 #   define FIXHR(x)       ((float)(x))
 #   define MULH3(x, y, s) ((s)*(y)*(x))
 #   define INTFLOAT float
+#   define SUINTFLOAT float
 #else
 #   define dct32 ff_dct32_fixed
 #   define FIXHR(a)       ((int)((a) * (1LL<<32) + 0.5))
 #   define MULH3(x, y, s) MULH((s)*(x), y)
 #   define INTFLOAT int
+#   define SUINTFLOAT SUINT
 #endif
 
 
@@ -112,11 +123,12 @@
 #define ADD(a, b) val##a += val##b
 
 /* DCT32 without 1/sqrt(2) coef zero scaling. */
-void dct32(INTFLOAT *out, const INTFLOAT *tab)
+void dct32(INTFLOAT *out, const INTFLOAT *tab_arg)
 {
-    INTFLOAT tmp0, tmp1;
+    const SUINTFLOAT *tab = tab_arg;
+    SUINTFLOAT tmp0, tmp1;
 
-    INTFLOAT val0 , val1 , val2 , val3 , val4 , val5 , val6 , val7 ,
+    SUINTFLOAT val0 , val1 , val2 , val3 , val4 , val5 , val6 , val7 ,
              val8 , val9 , val10, val11, val12, val13, val14, val15,
              val16, val17, val18, val19, val20, val21, val22, val23,
              val24, val25, val26, val27, val28, val29, val30, val31;
diff --git a/mythtv/external/FFmpeg/libavcodec/dds.c b/mythtv/external/FFmpeg/libavcodec/dds.c
index 43319a84413..f026f9cd5a4 100644
--- a/mythtv/external/FFmpeg/libavcodec/dds.c
+++ b/mythtv/external/FFmpeg/libavcodec/dds.c
@@ -39,7 +39,7 @@
 
 #define DDPF_FOURCC    (1 <<  2)
 #define DDPF_PALETTE   (1 <<  5)
-#define DDPF_NORMALMAP (1 << 31)
+#define DDPF_NORMALMAP (1U << 31)
 
 enum DDSPostProc {
     DDS_NONE = 0,
@@ -117,7 +117,6 @@ static int parse_pixel_format(AVCodecContext *avctx)
 {
     DDSContext *ctx = avctx->priv_data;
     GetByteContext *gbc = &ctx->gbc;
-    char buf[32];
     uint32_t flags, fourcc, gimp_tag;
     enum DDSDXGIFormat dxgi;
     int size, bpp, r, g, b, a;
@@ -161,13 +160,10 @@ static int parse_pixel_format(AVCodecContext *avctx)
     bytestream2_skip(gbc, 4); // caps4
     bytestream2_skip(gbc, 4); // reserved2
 
-    av_get_codec_tag_string(buf, sizeof(buf), fourcc);
     av_log(avctx, AV_LOG_VERBOSE, "fourcc %s bpp %d "
-           "r 0x%x g 0x%x b 0x%x a 0x%x\n", buf, bpp, r, g, b, a);
-    if (gimp_tag) {
-        av_get_codec_tag_string(buf, sizeof(buf), gimp_tag);
-        av_log(avctx, AV_LOG_VERBOSE, "and GIMP-DDS tag %s\n", buf);
-    }
+           "r 0x%x g 0x%x b 0x%x a 0x%x\n", av_fourcc2str(fourcc), bpp, r, g, b, a);
+    if (gimp_tag)
+        av_log(avctx, AV_LOG_VERBOSE, "and GIMP-DDS tag %s\n", av_fourcc2str(gimp_tag));
 
     if (ctx->compressed)
         avctx->pix_fmt = AV_PIX_FMT_RGBA;
@@ -344,7 +340,7 @@ static int parse_pixel_format(AVCodecContext *avctx)
             }
             break;
         default:
-            av_log(avctx, AV_LOG_ERROR, "Unsupported %s fourcc.\n", buf);
+            av_log(avctx, AV_LOG_ERROR, "Unsupported %s fourcc.\n", av_fourcc2str(fourcc));
             return AVERROR_INVALIDDATA;
         }
     } else if (ctx->paletted) {
@@ -680,7 +676,7 @@ static int dds_decode(AVCodecContext *avctx, void *data,
         /* Use the decompress function on the texture, one block per thread. */
         ctx->tex_data = gbc->buffer;
         avctx->execute2(avctx, decompress_texture_thread, frame, NULL, ctx->slice_count);
-    } else if (!ctx->paletted && ctx->bpp == 4) {
+    } else if (!ctx->paletted && ctx->bpp == 4 && avctx->pix_fmt == AV_PIX_FMT_PAL8) {
         uint8_t *dst = frame->data[0];
         int x, y, i;
 
@@ -691,7 +687,7 @@ static int dds_decode(AVCodecContext *avctx, void *data,
                     (frame->data[1][2+i*4]<<0)+
                     (frame->data[1][1+i*4]<<8)+
                     (frame->data[1][0+i*4]<<16)+
-                    (frame->data[1][3+i*4]<<24)
+                    ((unsigned)frame->data[1][3+i*4]<<24)
             );
         }
         frame->palette_has_changed = 1;
@@ -722,7 +718,7 @@ static int dds_decode(AVCodecContext *avctx, void *data,
                         (frame->data[1][2+i*4]<<0)+
                         (frame->data[1][1+i*4]<<8)+
                         (frame->data[1][0+i*4]<<16)+
-                        (frame->data[1][3+i*4]<<24)
+                        ((unsigned)frame->data[1][3+i*4]<<24)
                 );
 
             frame->palette_has_changed = 1;
diff --git a/mythtv/external/FFmpeg/libavcodec/decode.c b/mythtv/external/FFmpeg/libavcodec/decode.c
new file mode 100644
index 00000000000..fb1824be1c2
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/decode.c
@@ -0,0 +1,1761 @@
+/*
+ * generic decoding-related code
+ *
+ * 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 <stdint.h>
+#include <string.h>
+
+#include "config.h"
+
+#if CONFIG_ICONV
+# include <iconv.h>
+#endif
+
+#include "libavutil/avassert.h"
+#include "libavutil/avstring.h"
+#include "libavutil/bprint.h"
+#include "libavutil/common.h"
+#include "libavutil/frame.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/internal.h"
+#include "libavutil/intmath.h"
+
+#include "avcodec.h"
+#include "bytestream.h"
+#include "decode.h"
+#include "internal.h"
+#include "thread.h"
+
+static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
+{
+    int size = 0, ret;
+    const uint8_t *data;
+    uint32_t flags;
+    int64_t val;
+
+    data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
+    if (!data)
+        return 0;
+
+    if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
+        av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
+               "changes, but PARAM_CHANGE side data was sent to it.\n");
+        ret = AVERROR(EINVAL);
+        goto fail2;
+    }
+
+    if (size < 4)
+        goto fail;
+
+    flags = bytestream_get_le32(&data);
+    size -= 4;
+
+    if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
+        if (size < 4)
+            goto fail;
+        val = bytestream_get_le32(&data);
+        if (val <= 0 || val > INT_MAX) {
+            av_log(avctx, AV_LOG_ERROR, "Invalid channel count");
+            ret = AVERROR_INVALIDDATA;
+            goto fail2;
+        }
+        avctx->channels = val;
+        size -= 4;
+    }
+    if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
+        if (size < 8)
+            goto fail;
+        avctx->channel_layout = bytestream_get_le64(&data);
+        size -= 8;
+    }
+    if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
+        if (size < 4)
+            goto fail;
+        val = bytestream_get_le32(&data);
+        if (val <= 0 || val > INT_MAX) {
+            av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
+            ret = AVERROR_INVALIDDATA;
+            goto fail2;
+        }
+        avctx->sample_rate = val;
+        size -= 4;
+    }
+    if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
+        if (size < 8)
+            goto fail;
+        avctx->width  = bytestream_get_le32(&data);
+        avctx->height = bytestream_get_le32(&data);
+        size -= 8;
+        ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
+        if (ret < 0)
+            goto fail2;
+    }
+
+    return 0;
+fail:
+    av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
+    ret = AVERROR_INVALIDDATA;
+fail2:
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
+        if (avctx->err_recognition & AV_EF_EXPLODE)
+            return ret;
+    }
+    return 0;
+}
+
+static int extract_packet_props(AVCodecInternal *avci, const AVPacket *pkt)
+{
+    int ret = 0;
+
+    av_packet_unref(avci->last_pkt_props);
+    if (pkt) {
+        ret = av_packet_copy_props(avci->last_pkt_props, pkt);
+        if (!ret)
+            avci->last_pkt_props->size = pkt->size; // HACK: Needed for ff_init_buffer_info().
+    }
+    return ret;
+}
+
+static int unrefcount_frame(AVCodecInternal *avci, AVFrame *frame)
+{
+    int ret;
+
+    /* move the original frame to our backup */
+    av_frame_unref(avci->to_free);
+    av_frame_move_ref(avci->to_free, frame);
+
+    /* now copy everything except the AVBufferRefs back
+     * note that we make a COPY of the side data, so calling av_frame_free() on
+     * the caller's frame will work properly */
+    ret = av_frame_copy_props(frame, avci->to_free);
+    if (ret < 0)
+        return ret;
+
+    memcpy(frame->data,     avci->to_free->data,     sizeof(frame->data));
+    memcpy(frame->linesize, avci->to_free->linesize, sizeof(frame->linesize));
+    if (avci->to_free->extended_data != avci->to_free->data) {
+        int planes = avci->to_free->channels;
+        int size   = planes * sizeof(*frame->extended_data);
+
+        if (!size) {
+            av_frame_unref(frame);
+            return AVERROR_BUG;
+        }
+
+        frame->extended_data = av_malloc(size);
+        if (!frame->extended_data) {
+            av_frame_unref(frame);
+            return AVERROR(ENOMEM);
+        }
+        memcpy(frame->extended_data, avci->to_free->extended_data,
+               size);
+    } else
+        frame->extended_data = frame->data;
+
+    frame->format         = avci->to_free->format;
+    frame->width          = avci->to_free->width;
+    frame->height         = avci->to_free->height;
+    frame->channel_layout = avci->to_free->channel_layout;
+    frame->nb_samples     = avci->to_free->nb_samples;
+    frame->channels       = avci->to_free->channels;
+
+    return 0;
+}
+
+static int bsfs_init(AVCodecContext *avctx)
+{
+    AVCodecInternal *avci = avctx->internal;
+    DecodeFilterContext *s = &avci->filter;
+    const char *bsfs_str;
+    int ret;
+
+    if (s->nb_bsfs)
+        return 0;
+
+    bsfs_str = avctx->codec->bsfs ? avctx->codec->bsfs : "null";
+    while (bsfs_str && *bsfs_str) {
+        AVBSFContext **tmp;
+        const AVBitStreamFilter *filter;
+        char *bsf;
+
+        bsf = av_get_token(&bsfs_str, ",");
+        if (!bsf) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+
+        filter = av_bsf_get_by_name(bsf);
+        if (!filter) {
+            av_log(avctx, AV_LOG_ERROR, "A non-existing bitstream filter %s "
+                   "requested by a decoder. This is a bug, please report it.\n",
+                   bsf);
+            ret = AVERROR_BUG;
+            av_freep(&bsf);
+            goto fail;
+        }
+        av_freep(&bsf);
+
+        tmp = av_realloc_array(s->bsfs, s->nb_bsfs + 1, sizeof(*s->bsfs));
+        if (!tmp) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+        s->bsfs = tmp;
+        s->nb_bsfs++;
+
+        ret = av_bsf_alloc(filter, &s->bsfs[s->nb_bsfs - 1]);
+        if (ret < 0)
+            goto fail;
+
+        if (s->nb_bsfs == 1) {
+            /* We do not currently have an API for passing the input timebase into decoders,
+             * but no filters used here should actually need it.
+             * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
+            s->bsfs[s->nb_bsfs - 1]->time_base_in = (AVRational){ 1, 90000 };
+            ret = avcodec_parameters_from_context(s->bsfs[s->nb_bsfs - 1]->par_in,
+                                                  avctx);
+        } else {
+            s->bsfs[s->nb_bsfs - 1]->time_base_in = s->bsfs[s->nb_bsfs - 2]->time_base_out;
+            ret = avcodec_parameters_copy(s->bsfs[s->nb_bsfs - 1]->par_in,
+                                          s->bsfs[s->nb_bsfs - 2]->par_out);
+        }
+        if (ret < 0)
+            goto fail;
+
+        ret = av_bsf_init(s->bsfs[s->nb_bsfs - 1]);
+        if (ret < 0)
+            goto fail;
+    }
+
+    return 0;
+fail:
+    ff_decode_bsfs_uninit(avctx);
+    return ret;
+}
+
+/* try to get one output packet from the filter chain */
+static int bsfs_poll(AVCodecContext *avctx, AVPacket *pkt)
+{
+    DecodeFilterContext *s = &avctx->internal->filter;
+    int idx, ret;
+
+    /* start with the last filter in the chain */
+    idx = s->nb_bsfs - 1;
+    while (idx >= 0) {
+        /* request a packet from the currently selected filter */
+        ret = av_bsf_receive_packet(s->bsfs[idx], pkt);
+        if (ret == AVERROR(EAGAIN)) {
+            /* no packets available, try the next filter up the chain */
+            ret = 0;
+            idx--;
+            continue;
+        } else if (ret < 0 && ret != AVERROR_EOF) {
+            return ret;
+        }
+
+        /* got a packet or EOF -- pass it to the caller or to the next filter
+         * down the chain */
+        if (idx == s->nb_bsfs - 1) {
+            return ret;
+        } else {
+            idx++;
+            ret = av_bsf_send_packet(s->bsfs[idx], ret < 0 ? NULL : pkt);
+            if (ret < 0) {
+                av_log(avctx, AV_LOG_ERROR,
+                       "Error pre-processing a packet before decoding\n");
+                av_packet_unref(pkt);
+                return ret;
+            }
+        }
+    }
+
+    return AVERROR(EAGAIN);
+}
+
+int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
+{
+    AVCodecInternal *avci = avctx->internal;
+    int ret;
+
+    if (avci->draining)
+        return AVERROR_EOF;
+
+    ret = bsfs_poll(avctx, pkt);
+    if (ret == AVERROR_EOF)
+        avci->draining = 1;
+    if (ret < 0)
+        return ret;
+
+    ret = extract_packet_props(avctx->internal, pkt);
+    if (ret < 0)
+        goto finish;
+
+    ret = apply_param_change(avctx, pkt);
+    if (ret < 0)
+        goto finish;
+
+    if (avctx->codec->receive_frame)
+        avci->compat_decode_consumed += pkt->size;
+
+    return 0;
+finish:
+    av_packet_unref(pkt);
+    return ret;
+}
+
+/**
+ * Attempt to guess proper monotonic timestamps for decoded video frames
+ * which might have incorrect times. Input timestamps may wrap around, in
+ * which case the output will as well.
+ *
+ * @param pts the pts field of the decoded AVPacket, as passed through
+ * AVFrame.pts
+ * @param dts the dts field of the decoded AVPacket
+ * @return one of the input values, may be AV_NOPTS_VALUE
+ */
+static int64_t guess_correct_pts(AVCodecContext *ctx,
+                                 int64_t reordered_pts, int64_t dts)
+{
+    int64_t pts = AV_NOPTS_VALUE;
+
+    if (dts != AV_NOPTS_VALUE) {
+        ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
+        ctx->pts_correction_last_dts = dts;
+    } else if (reordered_pts != AV_NOPTS_VALUE)
+        ctx->pts_correction_last_dts = reordered_pts;
+
+    if (reordered_pts != AV_NOPTS_VALUE) {
+        ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
+        ctx->pts_correction_last_pts = reordered_pts;
+    } else if(dts != AV_NOPTS_VALUE)
+        ctx->pts_correction_last_pts = dts;
+
+    if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
+       && reordered_pts != AV_NOPTS_VALUE)
+        pts = reordered_pts;
+    else
+        pts = dts;
+
+    return pts;
+}
+
+/*
+ * The core of the receive_frame_wrapper for the decoders implementing
+ * the simple API. Certain decoders might consume partial packets without
+ * returning any output, so this function needs to be called in a loop until it
+ * returns EAGAIN.
+ **/
+static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame)
+{
+    AVCodecInternal   *avci = avctx->internal;
+    DecodeSimpleContext *ds = &avci->ds;
+    AVPacket           *pkt = ds->in_pkt;
+    // copy to ensure we do not change pkt
+    AVPacket tmp;
+    int got_frame, actual_got_frame, did_split;
+    int ret;
+
+    if (!pkt->data && !avci->draining) {
+        av_packet_unref(pkt);
+        ret = ff_decode_get_packet(avctx, pkt);
+        if (ret < 0 && ret != AVERROR_EOF)
+            return ret;
+    }
+
+    // Some codecs (at least wma lossless) will crash when feeding drain packets
+    // after EOF was signaled.
+    if (avci->draining_done)
+        return AVERROR_EOF;
+
+    if (!pkt->data &&
+        !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
+          avctx->active_thread_type & FF_THREAD_FRAME))
+        return AVERROR_EOF;
+
+    tmp = *pkt;
+#if FF_API_MERGE_SD
+FF_DISABLE_DEPRECATION_WARNINGS
+    did_split = avci->compat_decode_partial_size ?
+                ff_packet_split_and_drop_side_data(&tmp) :
+                av_packet_split_side_data(&tmp);
+
+    if (did_split) {
+        ret = extract_packet_props(avctx->internal, &tmp);
+        if (ret < 0)
+            return ret;
+
+        ret = apply_param_change(avctx, &tmp);
+        if (ret < 0)
+            return ret;
+    }
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
+    got_frame = 0;
+
+    if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
+        ret = ff_thread_decode_frame(avctx, frame, &got_frame, &tmp);
+    } else {
+        ret = avctx->codec->decode(avctx, frame, &got_frame, &tmp);
+
+        if (!(avctx->codec->caps_internal & FF_CODEC_CAP_SETS_PKT_DTS))
+            frame->pkt_dts = pkt->dts;
+        if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
+            if(!avctx->has_b_frames)
+                frame->pkt_pos = pkt->pos;
+            //FIXME these should be under if(!avctx->has_b_frames)
+            /* get_buffer is supposed to set frame parameters */
+            if (!(avctx->codec->capabilities & AV_CODEC_CAP_DR1)) {
+                if (!frame->sample_aspect_ratio.num)  frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
+                if (!frame->width)                    frame->width               = avctx->width;
+                if (!frame->height)                   frame->height              = avctx->height;
+                if (frame->format == AV_PIX_FMT_NONE) frame->format              = avctx->pix_fmt;
+            }
+        }
+    }
+    emms_c();
+    actual_got_frame = got_frame;
+
+    if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
+        if (frame->flags & AV_FRAME_FLAG_DISCARD)
+            got_frame = 0;
+        if (got_frame)
+            frame->best_effort_timestamp = guess_correct_pts(avctx,
+                                                             frame->pts,
+                                                             frame->pkt_dts);
+    } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
+        uint8_t *side;
+        int side_size;
+        uint32_t discard_padding = 0;
+        uint8_t skip_reason = 0;
+        uint8_t discard_reason = 0;
+
+        if (ret >= 0 && got_frame) {
+            frame->best_effort_timestamp = guess_correct_pts(avctx,
+                                                             frame->pts,
+                                                             frame->pkt_dts);
+            if (frame->format == AV_SAMPLE_FMT_NONE)
+                frame->format = avctx->sample_fmt;
+            if (!frame->channel_layout)
+                frame->channel_layout = avctx->channel_layout;
+            if (!frame->channels)
+                frame->channels = avctx->channels;
+            if (!frame->sample_rate)
+                frame->sample_rate = avctx->sample_rate;
+        }
+
+        side= av_packet_get_side_data(avci->last_pkt_props, AV_PKT_DATA_SKIP_SAMPLES, &side_size);
+        if(side && side_size>=10) {
+            avctx->internal->skip_samples = AV_RL32(side) * avctx->internal->skip_samples_multiplier;
+            discard_padding = AV_RL32(side + 4);
+            av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
+                   avctx->internal->skip_samples, (int)discard_padding);
+            skip_reason = AV_RL8(side + 8);
+            discard_reason = AV_RL8(side + 9);
+        }
+
+        if ((frame->flags & AV_FRAME_FLAG_DISCARD) && got_frame &&
+            !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
+            avctx->internal->skip_samples = FFMAX(0, avctx->internal->skip_samples - frame->nb_samples);
+            got_frame = 0;
+        }
+
+        if (avctx->internal->skip_samples > 0 && got_frame &&
+            !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
+            if(frame->nb_samples <= avctx->internal->skip_samples){
+                got_frame = 0;
+                avctx->internal->skip_samples -= frame->nb_samples;
+                av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
+                       avctx->internal->skip_samples);
+            } else {
+                av_samples_copy(frame->extended_data, frame->extended_data, 0, avctx->internal->skip_samples,
+                                frame->nb_samples - avctx->internal->skip_samples, avctx->channels, frame->format);
+                if(avctx->pkt_timebase.num && avctx->sample_rate) {
+                    int64_t diff_ts = av_rescale_q(avctx->internal->skip_samples,
+                                                   (AVRational){1, avctx->sample_rate},
+                                                   avctx->pkt_timebase);
+                    if(frame->pts!=AV_NOPTS_VALUE)
+                        frame->pts += diff_ts;
+#if FF_API_PKT_PTS
+FF_DISABLE_DEPRECATION_WARNINGS
+                    if(frame->pkt_pts!=AV_NOPTS_VALUE)
+                        frame->pkt_pts += diff_ts;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+                    if(frame->pkt_dts!=AV_NOPTS_VALUE)
+                        frame->pkt_dts += diff_ts;
+                    if (frame->pkt_duration >= diff_ts)
+                        frame->pkt_duration -= diff_ts;
+                } else {
+                    av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
+                }
+                av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
+                       avctx->internal->skip_samples, frame->nb_samples);
+                frame->nb_samples -= avctx->internal->skip_samples;
+                avctx->internal->skip_samples = 0;
+            }
+        }
+
+        if (discard_padding > 0 && discard_padding <= frame->nb_samples && got_frame &&
+            !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
+            if (discard_padding == frame->nb_samples) {
+                got_frame = 0;
+            } else {
+                if(avctx->pkt_timebase.num && avctx->sample_rate) {
+                    int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
+                                                   (AVRational){1, avctx->sample_rate},
+                                                   avctx->pkt_timebase);
+                    frame->pkt_duration = diff_ts;
+                } else {
+                    av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
+                }
+                av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
+                       (int)discard_padding, frame->nb_samples);
+                frame->nb_samples -= discard_padding;
+            }
+        }
+
+        if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL) && got_frame) {
+            AVFrameSideData *fside = av_frame_new_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES, 10);
+            if (fside) {
+                AV_WL32(fside->data, avctx->internal->skip_samples);
+                AV_WL32(fside->data + 4, discard_padding);
+                AV_WL8(fside->data + 8, skip_reason);
+                AV_WL8(fside->data + 9, discard_reason);
+                avctx->internal->skip_samples = 0;
+            }
+        }
+    }
+#if FF_API_MERGE_SD
+    if (did_split) {
+        av_packet_free_side_data(&tmp);
+        if(ret == tmp.size)
+            ret = pkt->size;
+    }
+#endif
+
+    if (avctx->codec->type == AVMEDIA_TYPE_AUDIO &&
+        !avci->showed_multi_packet_warning &&
+        ret >= 0 && ret != pkt->size && !(avctx->codec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
+        av_log(avctx, AV_LOG_WARNING, "Multiple frames in a packet.\n");
+        avci->showed_multi_packet_warning = 1;
+    }
+
+    if (!got_frame)
+        av_frame_unref(frame);
+
+    if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO && !(avctx->flags & AV_CODEC_FLAG_TRUNCATED))
+        ret = pkt->size;
+
+#if FF_API_AVCTX_TIMEBASE
+    if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
+        avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
+#endif
+
+    /* do not stop draining when actual_got_frame != 0 or ret < 0 */
+    /* got_frame == 0 but actual_got_frame != 0 when frame is discarded */
+    if (avctx->internal->draining && !actual_got_frame) {
+        if (ret < 0) {
+            /* prevent infinite loop if a decoder wrongly always return error on draining */
+            /* reasonable nb_errors_max = maximum b frames + thread count */
+            int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
+                                avctx->thread_count : 1);
+
+            if (avci->nb_draining_errors++ >= nb_errors_max) {
+                av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
+                       "Stop draining and force EOF.\n");
+                avci->draining_done = 1;
+                ret = AVERROR_BUG;
+            }
+        } else {
+            avci->draining_done = 1;
+        }
+    }
+
+    avci->compat_decode_consumed += ret;
+
+    if (ret >= pkt->size || ret < 0) {
+        av_packet_unref(pkt);
+    } else {
+        int consumed = ret;
+
+        pkt->data                += consumed;
+        pkt->size                -= consumed;
+        avci->last_pkt_props->size -= consumed; // See extract_packet_props() comment.
+        pkt->pts                  = AV_NOPTS_VALUE;
+        pkt->dts                  = AV_NOPTS_VALUE;
+        avci->last_pkt_props->pts = AV_NOPTS_VALUE;
+        avci->last_pkt_props->dts = AV_NOPTS_VALUE;
+    }
+
+    if (got_frame)
+        av_assert0(frame->buf[0]);
+
+    return ret < 0 ? ret : 0;
+}
+
+static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
+{
+    int ret;
+
+    while (!frame->buf[0]) {
+        ret = decode_simple_internal(avctx, frame);
+        if (ret < 0)
+            return ret;
+    }
+
+    return 0;
+}
+
+static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
+{
+    AVCodecInternal *avci = avctx->internal;
+    int ret;
+
+    av_assert0(!frame->buf[0]);
+
+    if (avctx->codec->receive_frame)
+        ret = avctx->codec->receive_frame(avctx, frame);
+    else
+        ret = decode_simple_receive_frame(avctx, frame);
+
+    if (ret == AVERROR_EOF)
+        avci->draining_done = 1;
+
+    return ret;
+}
+
+int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
+{
+    AVCodecInternal *avci = avctx->internal;
+    int ret;
+
+    if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
+        return AVERROR(EINVAL);
+
+    if (avctx->internal->draining)
+        return AVERROR_EOF;
+
+    if (avpkt && !avpkt->size && avpkt->data)
+        return AVERROR(EINVAL);
+
+    ret = bsfs_init(avctx);
+    if (ret < 0)
+        return ret;
+
+    av_packet_unref(avci->buffer_pkt);
+    if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
+        ret = av_packet_ref(avci->buffer_pkt, avpkt);
+        if (ret < 0)
+            return ret;
+    }
+
+    ret = av_bsf_send_packet(avci->filter.bsfs[0], avci->buffer_pkt);
+    if (ret < 0) {
+        av_packet_unref(avci->buffer_pkt);
+        return ret;
+    }
+
+    if (!avci->buffer_frame->buf[0]) {
+        ret = decode_receive_frame_internal(avctx, avci->buffer_frame);
+        if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
+            return ret;
+    }
+
+    return 0;
+}
+
+static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
+{
+    /* make sure we are noisy about decoders returning invalid cropping data */
+    if (frame->crop_left >= INT_MAX - frame->crop_right        ||
+        frame->crop_top  >= INT_MAX - frame->crop_bottom       ||
+        (frame->crop_left + frame->crop_right) >= frame->width ||
+        (frame->crop_top + frame->crop_bottom) >= frame->height) {
+        av_log(avctx, AV_LOG_WARNING,
+               "Invalid cropping information set by a decoder: "
+               "%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER" "
+               "(frame size %dx%d). This is a bug, please report it\n",
+               frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
+               frame->width, frame->height);
+        frame->crop_left   = 0;
+        frame->crop_right  = 0;
+        frame->crop_top    = 0;
+        frame->crop_bottom = 0;
+        return 0;
+    }
+
+    if (!avctx->apply_cropping)
+        return 0;
+
+    return av_frame_apply_cropping(frame, avctx->flags & AV_CODEC_FLAG_UNALIGNED ?
+                                          AV_FRAME_CROP_UNALIGNED : 0);
+}
+
+int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
+{
+    AVCodecInternal *avci = avctx->internal;
+    int ret;
+
+    av_frame_unref(frame);
+
+    if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
+        return AVERROR(EINVAL);
+
+    ret = bsfs_init(avctx);
+    if (ret < 0)
+        return ret;
+
+    if (avci->buffer_frame->buf[0]) {
+        av_frame_move_ref(frame, avci->buffer_frame);
+    } else {
+        ret = decode_receive_frame_internal(avctx, frame);
+        if (ret < 0)
+            return ret;
+    }
+
+    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
+        ret = apply_cropping(avctx, frame);
+        if (ret < 0) {
+            av_frame_unref(frame);
+            return ret;
+        }
+    }
+
+    avctx->frame_number++;
+
+    return 0;
+}
+
+static int compat_decode(AVCodecContext *avctx, AVFrame *frame,
+                         int *got_frame, const AVPacket *pkt)
+{
+    AVCodecInternal *avci = avctx->internal;
+    int ret = 0;
+
+    av_assert0(avci->compat_decode_consumed == 0);
+
+    if (avci->draining_done && pkt && pkt->size != 0) {
+        av_log(avctx, AV_LOG_WARNING, "Got unexpected packet after EOF\n");
+        avcodec_flush_buffers(avctx);
+    }
+
+    *got_frame = 0;
+    avci->compat_decode = 1;
+
+    if (avci->compat_decode_partial_size > 0 &&
+        avci->compat_decode_partial_size != pkt->size) {
+        av_log(avctx, AV_LOG_ERROR,
+               "Got unexpected packet size after a partial decode\n");
+        ret = AVERROR(EINVAL);
+        goto finish;
+    }
+
+    if (!avci->compat_decode_partial_size) {
+        ret = avcodec_send_packet(avctx, pkt);
+        if (ret == AVERROR_EOF)
+            ret = 0;
+        else if (ret == AVERROR(EAGAIN)) {
+            /* we fully drain all the output in each decode call, so this should not
+             * ever happen */
+            ret = AVERROR_BUG;
+            goto finish;
+        } else if (ret < 0)
+            goto finish;
+    }
+
+    while (ret >= 0) {
+        ret = avcodec_receive_frame(avctx, frame);
+        if (ret < 0) {
+            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+                ret = 0;
+            goto finish;
+        }
+
+        if (frame != avci->compat_decode_frame) {
+            if (!avctx->refcounted_frames) {
+                ret = unrefcount_frame(avci, frame);
+                if (ret < 0)
+                    goto finish;
+            }
+
+            *got_frame = 1;
+            frame = avci->compat_decode_frame;
+        } else {
+            if (!avci->compat_decode_warned) {
+                av_log(avctx, AV_LOG_WARNING, "The deprecated avcodec_decode_* "
+                       "API cannot return all the frames for this decoder. "
+                       "Some frames will be dropped. Update your code to the "
+                       "new decoding API to fix this.\n");
+                avci->compat_decode_warned = 1;
+            }
+        }
+
+        if (avci->draining || (!avctx->codec->bsfs && avci->compat_decode_consumed < pkt->size))
+            break;
+    }
+
+finish:
+    if (ret == 0) {
+        /* if there are any bsfs then assume full packet is always consumed */
+        if (avctx->codec->bsfs)
+            ret = pkt->size;
+        else
+            ret = FFMIN(avci->compat_decode_consumed, pkt->size);
+    }
+    avci->compat_decode_consumed = 0;
+    avci->compat_decode_partial_size = (ret >= 0) ? pkt->size - ret : 0;
+
+    return ret;
+}
+
+int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
+                                              int *got_picture_ptr,
+                                              const AVPacket *avpkt)
+{
+    return compat_decode(avctx, picture, got_picture_ptr, avpkt);
+}
+
+int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
+                                              AVFrame *frame,
+                                              int *got_frame_ptr,
+                                              const AVPacket *avpkt)
+{
+    return compat_decode(avctx, frame, got_frame_ptr, avpkt);
+}
+
+static void get_subtitle_defaults(AVSubtitle *sub)
+{
+    memset(sub, 0, sizeof(*sub));
+    sub->pts = AV_NOPTS_VALUE;
+}
+
+#define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
+static int recode_subtitle(AVCodecContext *avctx,
+                           AVPacket *outpkt, const AVPacket *inpkt)
+{
+#if CONFIG_ICONV
+    iconv_t cd = (iconv_t)-1;
+    int ret = 0;
+    char *inb, *outb;
+    size_t inl, outl;
+    AVPacket tmp;
+#endif
+
+    if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0)
+        return 0;
+
+#if CONFIG_ICONV
+    cd = iconv_open("UTF-8", avctx->sub_charenc);
+    av_assert0(cd != (iconv_t)-1);
+
+    inb = inpkt->data;
+    inl = inpkt->size;
+
+    if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
+        av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
+        ret = AVERROR(ENOMEM);
+        goto end;
+    }
+
+    ret = av_new_packet(&tmp, inl * UTF8_MAX_BYTES);
+    if (ret < 0)
+        goto end;
+    outpkt->buf  = tmp.buf;
+    outpkt->data = tmp.data;
+    outpkt->size = tmp.size;
+    outb = outpkt->data;
+    outl = outpkt->size;
+
+    if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
+        iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
+        outl >= outpkt->size || inl != 0) {
+        ret = FFMIN(AVERROR(errno), -1);
+        av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
+               "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
+        av_packet_unref(&tmp);
+        goto end;
+    }
+    outpkt->size -= outl;
+    memset(outpkt->data + outpkt->size, 0, outl);
+
+end:
+    if (cd != (iconv_t)-1)
+        iconv_close(cd);
+    return ret;
+#else
+    av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
+    return AVERROR(EINVAL);
+#endif
+}
+
+static int utf8_check(const uint8_t *str)
+{
+    const uint8_t *byte;
+    uint32_t codepoint, min;
+
+    while (*str) {
+        byte = str;
+        GET_UTF8(codepoint, *(byte++), return 0;);
+        min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
+              1 << (5 * (byte - str) - 4);
+        if (codepoint < min || codepoint >= 0x110000 ||
+            codepoint == 0xFFFE /* BOM */ ||
+            codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
+            return 0;
+        str = byte;
+    }
+    return 1;
+}
+
+#if FF_API_ASS_TIMING
+static void insert_ts(AVBPrint *buf, int ts)
+{
+    if (ts == -1) {
+        av_bprintf(buf, "9:59:59.99,");
+    } else {
+        int h, m, s;
+
+        h = ts/360000;  ts -= 360000*h;
+        m = ts/  6000;  ts -=   6000*m;
+        s = ts/   100;  ts -=    100*s;
+        av_bprintf(buf, "%d:%02d:%02d.%02d,", h, m, s, ts);
+    }
+}
+
+static int convert_sub_to_old_ass_form(AVSubtitle *sub, const AVPacket *pkt, AVRational tb)
+{
+    int i;
+    AVBPrint buf;
+
+    av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
+
+    for (i = 0; i < sub->num_rects; i++) {
+        char *final_dialog;
+        const char *dialog;
+        AVSubtitleRect *rect = sub->rects[i];
+        int ts_start, ts_duration = -1;
+        long int layer;
+
+        if (rect->type != SUBTITLE_ASS || !strncmp(rect->ass, "Dialogue: ", 10))
+            continue;
+
+        av_bprint_clear(&buf);
+
+        /* skip ReadOrder */
+        dialog = strchr(rect->ass, ',');
+        if (!dialog)
+            continue;
+        dialog++;
+
+        /* extract Layer or Marked */
+        layer = strtol(dialog, (char**)&dialog, 10);
+        if (*dialog != ',')
+            continue;
+        dialog++;
+
+        /* rescale timing to ASS time base (ms) */
+        ts_start = av_rescale_q(pkt->pts, tb, av_make_q(1, 100));
+        if (pkt->duration != -1)
+            ts_duration = av_rescale_q(pkt->duration, tb, av_make_q(1, 100));
+        sub->end_display_time = FFMAX(sub->end_display_time, 10 * ts_duration);
+
+        /* construct ASS (standalone file form with timestamps) string */
+        av_bprintf(&buf, "Dialogue: %ld,", layer);
+        insert_ts(&buf, ts_start);
+        insert_ts(&buf, ts_duration == -1 ? -1 : ts_start + ts_duration);
+        av_bprintf(&buf, "%s\r\n", dialog);
+
+        final_dialog = av_strdup(buf.str);
+        if (!av_bprint_is_complete(&buf) || !final_dialog) {
+            av_freep(&final_dialog);
+            av_bprint_finalize(&buf, NULL);
+            return AVERROR(ENOMEM);
+        }
+        av_freep(&rect->ass);
+        rect->ass = final_dialog;
+    }
+
+    av_bprint_finalize(&buf, NULL);
+    return 0;
+}
+#endif
+
+int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
+                             int *got_sub_ptr,
+                             AVPacket *avpkt)
+{
+    int i, ret = 0;
+    AVCodecInternal *avci = avctx->internal;
+
+    if (!avpkt->data && avpkt->size) {
+        av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
+        return AVERROR(EINVAL);
+    }
+    if (!avctx->codec)
+        return AVERROR(EINVAL);
+    if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
+        return AVERROR(EINVAL);
+    }
+
+    *got_sub_ptr = 0;
+    get_subtitle_defaults(sub);
+
+    if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
+        AVPacket pkt_recoded;
+        AVPacket tmp = *avpkt;
+#if FF_API_MERGE_SD
+FF_DISABLE_DEPRECATION_WARNINGS
+        int did_split = avci->compat_decode_partial_size ?
+                        ff_packet_split_and_drop_side_data(&tmp) :
+                        av_packet_split_side_data(&tmp);
+        //apply_param_change(avctx, &tmp);
+
+        if (did_split) {
+            /* FFMIN() prevents overflow in case the packet wasn't allocated with
+             * proper padding.
+             * If the side data is smaller than the buffer padding size, the
+             * remaining bytes should have already been filled with zeros by the
+             * original packet allocation anyway. */
+            memset(tmp.data + tmp.size, 0,
+                   FFMIN(avpkt->size - tmp.size, AV_INPUT_BUFFER_PADDING_SIZE));
+        }
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
+        pkt_recoded = tmp;
+        ret = recode_subtitle(avctx, &pkt_recoded, &tmp);
+        if (ret < 0) {
+            *got_sub_ptr = 0;
+        } else {
+             ret = extract_packet_props(avctx->internal, &pkt_recoded);
+             if (ret < 0)
+                return ret;
+
+            if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
+                sub->pts = av_rescale_q(avpkt->pts,
+                                        avctx->pkt_timebase, AV_TIME_BASE_Q);
+            ret = avctx->codec->decode(avctx, sub, got_sub_ptr, &pkt_recoded);
+            av_assert1((ret >= 0) >= !!*got_sub_ptr &&
+                       !!*got_sub_ptr >= !!sub->num_rects);
+
+#if FF_API_ASS_TIMING
+            if (avctx->sub_text_format == FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS
+                && *got_sub_ptr && sub->num_rects) {
+                const AVRational tb = avctx->pkt_timebase.num ? avctx->pkt_timebase
+                                                              : avctx->time_base;
+                int err = convert_sub_to_old_ass_form(sub, avpkt, tb);
+                if (err < 0)
+                    ret = err;
+            }
+#endif
+
+            if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
+                avctx->pkt_timebase.num) {
+                AVRational ms = { 1, 1000 };
+                sub->end_display_time = av_rescale_q(avpkt->duration,
+                                                     avctx->pkt_timebase, ms);
+            }
+
+            if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB)
+                sub->format = 0;
+            else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
+                sub->format = 1;
+
+            for (i = 0; i < sub->num_rects; i++) {
+                if (sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
+                    av_log(avctx, AV_LOG_ERROR,
+                           "Invalid UTF-8 in decoded subtitles text; "
+                           "maybe missing -sub_charenc option\n");
+                    avsubtitle_free(sub);
+                    ret = AVERROR_INVALIDDATA;
+                    break;
+                }
+            }
+
+            if (tmp.data != pkt_recoded.data) { // did we recode?
+                /* prevent from destroying side data from original packet */
+                pkt_recoded.side_data = NULL;
+                pkt_recoded.side_data_elems = 0;
+
+                av_packet_unref(&pkt_recoded);
+            }
+        }
+
+#if FF_API_MERGE_SD
+        if (did_split) {
+            av_packet_free_side_data(&tmp);
+            if(ret == tmp.size)
+                ret = avpkt->size;
+        }
+#endif
+
+        if (*got_sub_ptr)
+            avctx->frame_number++;
+    }
+
+    return ret;
+}
+
+static int is_hwaccel_pix_fmt(enum AVPixelFormat pix_fmt)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+    return desc->flags & AV_PIX_FMT_FLAG_HWACCEL;
+}
+
+enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
+{
+    while (*fmt != AV_PIX_FMT_NONE && is_hwaccel_pix_fmt(*fmt))
+        ++fmt;
+    return fmt[0];
+}
+
+static AVHWAccel *find_hwaccel(enum AVCodecID codec_id,
+                               enum AVPixelFormat pix_fmt)
+{
+    AVHWAccel *hwaccel = NULL;
+
+    while ((hwaccel = av_hwaccel_next(hwaccel)))
+        if (hwaccel->id == codec_id
+            && hwaccel->pix_fmt == pix_fmt)
+            return hwaccel;
+    return NULL;
+}
+
+static int setup_hwaccel(AVCodecContext *avctx,
+                         const enum AVPixelFormat fmt,
+                         const char *name)
+{
+    AVHWAccel *hwa = find_hwaccel(avctx->codec_id, fmt);
+    int ret        = 0;
+
+    if (!hwa) {
+        av_log(avctx, AV_LOG_ERROR,
+               "Could not find an AVHWAccel for the pixel format: %s",
+               name);
+        return AVERROR(ENOENT);
+    }
+
+    if (hwa->capabilities & AV_HWACCEL_CODEC_CAP_EXPERIMENTAL &&
+        avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
+        av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
+               hwa->name);
+        return AVERROR_PATCHWELCOME;
+    }
+
+    if (hwa->priv_data_size) {
+        avctx->internal->hwaccel_priv_data = av_mallocz(hwa->priv_data_size);
+        if (!avctx->internal->hwaccel_priv_data)
+            return AVERROR(ENOMEM);
+    }
+
+    avctx->hwaccel = hwa;
+    if (hwa->init) {
+        ret = hwa->init(avctx);
+        if (ret < 0) {
+            av_freep(&avctx->internal->hwaccel_priv_data);
+            avctx->hwaccel = NULL;
+            return ret;
+        }
+    }
+
+    return 0;
+}
+
+int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
+{
+    const AVPixFmtDescriptor *desc;
+    enum AVPixelFormat *choices;
+    enum AVPixelFormat ret;
+    unsigned n = 0;
+
+    while (fmt[n] != AV_PIX_FMT_NONE)
+        ++n;
+
+    av_assert0(n >= 1);
+    avctx->sw_pix_fmt = fmt[n - 1];
+    av_assert2(!is_hwaccel_pix_fmt(avctx->sw_pix_fmt));
+
+    choices = av_malloc_array(n + 1, sizeof(*choices));
+    if (!choices)
+        return AV_PIX_FMT_NONE;
+
+    memcpy(choices, fmt, (n + 1) * sizeof(*choices));
+
+    for (;;) {
+        if (avctx->hwaccel && avctx->hwaccel->uninit)
+            avctx->hwaccel->uninit(avctx);
+        av_freep(&avctx->internal->hwaccel_priv_data);
+        avctx->hwaccel = NULL;
+
+        av_buffer_unref(&avctx->hw_frames_ctx);
+
+        ret = avctx->get_format(avctx, choices);
+
+        desc = av_pix_fmt_desc_get(ret);
+        if (!desc) {
+            ret = AV_PIX_FMT_NONE;
+            break;
+        }
+
+        if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
+            break;
+#if FF_API_CAP_VDPAU
+        if (avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU)
+            break;
+#endif
+
+        if (avctx->hw_frames_ctx) {
+            AVHWFramesContext *hw_frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+            if (hw_frames_ctx->format != ret) {
+                av_log(avctx, AV_LOG_ERROR, "Format returned from get_buffer() "
+                       "does not match the format of provided AVHWFramesContext\n");
+                ret = AV_PIX_FMT_NONE;
+                break;
+            }
+        }
+
+        if (!setup_hwaccel(avctx, ret, desc->name))
+            break;
+
+        /* Remove failed hwaccel from choices */
+        for (n = 0; choices[n] != ret; n++)
+            av_assert0(choices[n] != AV_PIX_FMT_NONE);
+
+        do
+            choices[n] = choices[n + 1];
+        while (choices[n++] != AV_PIX_FMT_NONE);
+    }
+
+    av_freep(&choices);
+    return ret;
+}
+
+static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
+{
+    FramePool *pool = avctx->internal->pool;
+    int i, ret;
+
+    switch (avctx->codec_type) {
+    case AVMEDIA_TYPE_VIDEO: {
+        uint8_t *data[4];
+        int linesize[4];
+        int size[4] = { 0 };
+        int w = frame->width;
+        int h = frame->height;
+        int tmpsize, unaligned;
+
+        if (pool->format == frame->format &&
+            pool->width == frame->width && pool->height == frame->height)
+            return 0;
+
+        avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
+
+        do {
+            // NOTE: do not align linesizes individually, this breaks e.g. assumptions
+            // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
+            ret = av_image_fill_linesizes(linesize, avctx->pix_fmt, w);
+            if (ret < 0)
+                return ret;
+            // increase alignment of w for next try (rhs gives the lowest bit set in w)
+            w += w & ~(w - 1);
+
+            unaligned = 0;
+            for (i = 0; i < 4; i++)
+                unaligned |= linesize[i] % pool->stride_align[i];
+        } while (unaligned);
+
+        tmpsize = av_image_fill_pointers(data, avctx->pix_fmt, h,
+                                         NULL, linesize);
+        if (tmpsize < 0)
+            return -1;
+
+        for (i = 0; i < 3 && data[i + 1]; i++)
+            size[i] = data[i + 1] - data[i];
+        size[i] = tmpsize - (data[i] - data[0]);
+
+        for (i = 0; i < 4; i++) {
+            av_buffer_pool_uninit(&pool->pools[i]);
+            pool->linesize[i] = linesize[i];
+            if (size[i]) {
+                pool->pools[i] = av_buffer_pool_init(size[i] + 16 + STRIDE_ALIGN - 1,
+                                                     CONFIG_MEMORY_POISONING ?
+                                                        NULL :
+                                                        av_buffer_allocz);
+                if (!pool->pools[i]) {
+                    ret = AVERROR(ENOMEM);
+                    goto fail;
+                }
+            }
+        }
+        pool->format = frame->format;
+        pool->width  = frame->width;
+        pool->height = frame->height;
+
+        break;
+        }
+    case AVMEDIA_TYPE_AUDIO: {
+        int ch     = frame->channels; //av_get_channel_layout_nb_channels(frame->channel_layout);
+        int planar = av_sample_fmt_is_planar(frame->format);
+        int planes = planar ? ch : 1;
+
+        if (pool->format == frame->format && pool->planes == planes &&
+            pool->channels == ch && frame->nb_samples == pool->samples)
+            return 0;
+
+        av_buffer_pool_uninit(&pool->pools[0]);
+        ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
+                                         frame->nb_samples, frame->format, 0);
+        if (ret < 0)
+            goto fail;
+
+        pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
+        if (!pool->pools[0]) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+
+        pool->format     = frame->format;
+        pool->planes     = planes;
+        pool->channels   = ch;
+        pool->samples = frame->nb_samples;
+        break;
+        }
+    default: av_assert0(0);
+    }
+    return 0;
+fail:
+    for (i = 0; i < 4; i++)
+        av_buffer_pool_uninit(&pool->pools[i]);
+    pool->format = -1;
+    pool->planes = pool->channels = pool->samples = 0;
+    pool->width  = pool->height = 0;
+    return ret;
+}
+
+static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
+{
+    FramePool *pool = avctx->internal->pool;
+    int planes = pool->planes;
+    int i;
+
+    frame->linesize[0] = pool->linesize[0];
+
+    if (planes > AV_NUM_DATA_POINTERS) {
+        frame->extended_data = av_mallocz_array(planes, sizeof(*frame->extended_data));
+        frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
+        frame->extended_buf  = av_mallocz_array(frame->nb_extended_buf,
+                                          sizeof(*frame->extended_buf));
+        if (!frame->extended_data || !frame->extended_buf) {
+            av_freep(&frame->extended_data);
+            av_freep(&frame->extended_buf);
+            return AVERROR(ENOMEM);
+        }
+    } else {
+        frame->extended_data = frame->data;
+        av_assert0(frame->nb_extended_buf == 0);
+    }
+
+    for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
+        frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
+        if (!frame->buf[i])
+            goto fail;
+        frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
+    }
+    for (i = 0; i < frame->nb_extended_buf; i++) {
+        frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
+        if (!frame->extended_buf[i])
+            goto fail;
+        frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
+    }
+
+    if (avctx->debug & FF_DEBUG_BUFFERS)
+        av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
+
+    return 0;
+fail:
+    av_frame_unref(frame);
+    return AVERROR(ENOMEM);
+}
+
+static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
+{
+    FramePool *pool = s->internal->pool;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pic->format);
+    int i;
+
+    if (pic->data[0] || pic->data[1] || pic->data[2] || pic->data[3]) {
+        av_log(s, AV_LOG_ERROR, "pic->data[*]!=NULL in avcodec_default_get_buffer\n");
+        return -1;
+    }
+
+    if (!desc) {
+        av_log(s, AV_LOG_ERROR,
+            "Unable to get pixel format descriptor for format %s\n",
+            av_get_pix_fmt_name(pic->format));
+        return AVERROR(EINVAL);
+    }
+
+    memset(pic->data, 0, sizeof(pic->data));
+    pic->extended_data = pic->data;
+
+    for (i = 0; i < 4 && pool->pools[i]; i++) {
+        pic->linesize[i] = pool->linesize[i];
+
+        pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
+        if (!pic->buf[i])
+            goto fail;
+
+        pic->data[i] = pic->buf[i]->data;
+    }
+    for (; i < AV_NUM_DATA_POINTERS; i++) {
+        pic->data[i] = NULL;
+        pic->linesize[i] = 0;
+    }
+    if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
+        desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
+        avpriv_set_systematic_pal2((uint32_t *)pic->data[1], pic->format);
+
+    if (s->debug & FF_DEBUG_BUFFERS)
+        av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
+
+    return 0;
+fail:
+    av_frame_unref(pic);
+    return AVERROR(ENOMEM);
+}
+
+int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
+{
+    int ret;
+
+    if (avctx->hw_frames_ctx) {
+        ret = av_hwframe_get_buffer(avctx->hw_frames_ctx, frame, 0);
+        frame->width  = avctx->coded_width;
+        frame->height = avctx->coded_height;
+        return ret;
+    }
+
+    if ((ret = update_frame_pool(avctx, frame)) < 0)
+        return ret;
+
+    switch (avctx->codec_type) {
+    case AVMEDIA_TYPE_VIDEO:
+        return video_get_buffer(avctx, frame);
+    case AVMEDIA_TYPE_AUDIO:
+        return audio_get_buffer(avctx, frame);
+    default:
+        return -1;
+    }
+}
+
+static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
+{
+    int size;
+    const uint8_t *side_metadata;
+
+    AVDictionary **frame_md = &frame->metadata;
+
+    side_metadata = av_packet_get_side_data(avpkt,
+                                            AV_PKT_DATA_STRINGS_METADATA, &size);
+    return av_packet_unpack_dictionary(side_metadata, size, frame_md);
+}
+
+int ff_init_buffer_info(AVCodecContext *avctx, AVFrame *frame)
+{
+    const AVPacket *pkt = avctx->internal->last_pkt_props;
+    int i;
+    static const struct {
+        enum AVPacketSideDataType packet;
+        enum AVFrameSideDataType frame;
+    } sd[] = {
+        { AV_PKT_DATA_REPLAYGAIN ,                AV_FRAME_DATA_REPLAYGAIN },
+        { AV_PKT_DATA_DISPLAYMATRIX,              AV_FRAME_DATA_DISPLAYMATRIX },
+        { AV_PKT_DATA_SPHERICAL,                  AV_FRAME_DATA_SPHERICAL },
+        { AV_PKT_DATA_STEREO3D,                   AV_FRAME_DATA_STEREO3D },
+        { AV_PKT_DATA_AUDIO_SERVICE_TYPE,         AV_FRAME_DATA_AUDIO_SERVICE_TYPE },
+        { AV_PKT_DATA_MASTERING_DISPLAY_METADATA, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA },
+        { AV_PKT_DATA_CONTENT_LIGHT_LEVEL,        AV_FRAME_DATA_CONTENT_LIGHT_LEVEL },
+        { AV_PKT_DATA_A53_CC,                     AV_FRAME_DATA_A53_CC },
+    };
+
+    if (pkt) {
+        frame->pts = pkt->pts;
+#if FF_API_PKT_PTS
+FF_DISABLE_DEPRECATION_WARNINGS
+        frame->pkt_pts = pkt->pts;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+        frame->pkt_pos      = pkt->pos;
+        frame->pkt_duration = pkt->duration;
+        frame->pkt_size     = pkt->size;
+
+        for (i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
+            int size;
+            uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
+            if (packet_sd) {
+                AVFrameSideData *frame_sd = av_frame_new_side_data(frame,
+                                                                   sd[i].frame,
+                                                                   size);
+                if (!frame_sd)
+                    return AVERROR(ENOMEM);
+
+                memcpy(frame_sd->data, packet_sd, size);
+            }
+        }
+        add_metadata_from_side_data(pkt, frame);
+
+        if (pkt->flags & AV_PKT_FLAG_DISCARD) {
+            frame->flags |= AV_FRAME_FLAG_DISCARD;
+        } else {
+            frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
+        }
+    }
+    frame->reordered_opaque = avctx->reordered_opaque;
+
+    if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
+        frame->color_primaries = avctx->color_primaries;
+    if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
+        frame->color_trc = avctx->color_trc;
+    if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
+        frame->colorspace = avctx->colorspace;
+    if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
+        frame->color_range = avctx->color_range;
+    if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
+        frame->chroma_location = avctx->chroma_sample_location;
+
+    switch (avctx->codec->type) {
+    case AVMEDIA_TYPE_VIDEO:
+        frame->format              = avctx->pix_fmt;
+        if (!frame->sample_aspect_ratio.num)
+            frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
+
+        if (frame->width && frame->height &&
+            av_image_check_sar(frame->width, frame->height,
+                               frame->sample_aspect_ratio) < 0) {
+            av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
+                   frame->sample_aspect_ratio.num,
+                   frame->sample_aspect_ratio.den);
+            frame->sample_aspect_ratio = (AVRational){ 0, 1 };
+        }
+
+        break;
+    case AVMEDIA_TYPE_AUDIO:
+        if (!frame->sample_rate)
+            frame->sample_rate    = avctx->sample_rate;
+        if (frame->format < 0)
+            frame->format         = avctx->sample_fmt;
+        if (!frame->channel_layout) {
+            if (avctx->channel_layout) {
+                 if (av_get_channel_layout_nb_channels(avctx->channel_layout) !=
+                     avctx->channels) {
+                     av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
+                            "configuration.\n");
+                     return AVERROR(EINVAL);
+                 }
+
+                frame->channel_layout = avctx->channel_layout;
+            } else {
+                if (avctx->channels > FF_SANE_NB_CHANNELS) {
+                    av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
+                           avctx->channels);
+                    return AVERROR(ENOSYS);
+                }
+            }
+        }
+        frame->channels = avctx->channels;
+        break;
+    }
+    return 0;
+}
+
+int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
+{
+    return ff_init_buffer_info(avctx, frame);
+}
+
+static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
+{
+    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
+        int i;
+        int num_planes = av_pix_fmt_count_planes(frame->format);
+        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
+        int flags = desc ? desc->flags : 0;
+        if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
+            num_planes = 2;
+        for (i = 0; i < num_planes; i++) {
+            av_assert0(frame->data[i]);
+        }
+        // For now do not enforce anything for palette of pseudopal formats
+        if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PSEUDOPAL))
+            num_planes = 2;
+        // For formats without data like hwaccel allow unused pointers to be non-NULL.
+        for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
+            if (frame->data[i])
+                av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
+            frame->data[i] = NULL;
+        }
+    }
+}
+
+static int get_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
+{
+    const AVHWAccel *hwaccel = avctx->hwaccel;
+    int override_dimensions = 1;
+    int ret;
+
+    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
+        if ((ret = av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx)) < 0 || avctx->pix_fmt<0) {
+            av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
+            return AVERROR(EINVAL);
+        }
+
+        if (frame->width <= 0 || frame->height <= 0) {
+            frame->width  = FFMAX(avctx->width,  AV_CEIL_RSHIFT(avctx->coded_width,  avctx->lowres));
+            frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
+            override_dimensions = 0;
+        }
+
+        if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
+            av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
+            return AVERROR(EINVAL);
+        }
+    }
+    ret = ff_decode_frame_props(avctx, frame);
+    if (ret < 0)
+        return ret;
+
+    if (hwaccel) {
+        if (hwaccel->alloc_frame) {
+            ret = hwaccel->alloc_frame(avctx, frame);
+            goto end;
+        }
+    } else
+        avctx->sw_pix_fmt = avctx->pix_fmt;
+
+    ret = avctx->get_buffer2(avctx, frame, flags);
+    if (ret >= 0)
+        validate_avframe_allocation(avctx, frame);
+
+end:
+    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
+        !(avctx->codec->caps_internal & FF_CODEC_CAP_EXPORTS_CROPPING)) {
+        frame->width  = avctx->width;
+        frame->height = avctx->height;
+    }
+
+    return ret;
+}
+
+int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
+{
+    int ret = get_buffer_internal(avctx, frame, flags);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        frame->width = frame->height = 0;
+    }
+    return ret;
+}
+
+static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame)
+{
+    AVFrame *tmp;
+    int ret;
+
+    av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO);
+
+    if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
+        av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
+               frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
+        av_frame_unref(frame);
+    }
+
+    ff_init_buffer_info(avctx, frame);
+
+    if (!frame->data[0])
+        return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
+
+    if (av_frame_is_writable(frame))
+        return ff_decode_frame_props(avctx, frame);
+
+    tmp = av_frame_alloc();
+    if (!tmp)
+        return AVERROR(ENOMEM);
+
+    av_frame_move_ref(tmp, frame);
+
+    ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
+    if (ret < 0) {
+        av_frame_free(&tmp);
+        return ret;
+    }
+
+    av_frame_copy(frame, tmp);
+    av_frame_free(&tmp);
+
+    return 0;
+}
+
+int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
+{
+    int ret = reget_buffer_internal(avctx, frame);
+    if (ret < 0)
+        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
+    return ret;
+}
+
+void avcodec_flush_buffers(AVCodecContext *avctx)
+{
+    avctx->internal->draining      = 0;
+    avctx->internal->draining_done = 0;
+    avctx->internal->nb_draining_errors = 0;
+    av_frame_unref(avctx->internal->buffer_frame);
+    av_frame_unref(avctx->internal->compat_decode_frame);
+    av_packet_unref(avctx->internal->buffer_pkt);
+    avctx->internal->buffer_pkt_valid = 0;
+
+    av_packet_unref(avctx->internal->ds.in_pkt);
+
+    if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
+        ff_thread_flush(avctx);
+    else if (avctx->codec->flush)
+        avctx->codec->flush(avctx);
+
+    avctx->pts_correction_last_pts =
+    avctx->pts_correction_last_dts = INT64_MIN;
+
+    ff_decode_bsfs_uninit(avctx);
+
+    if (!avctx->refcounted_frames)
+        av_frame_unref(avctx->internal->to_free);
+}
+
+void ff_decode_bsfs_uninit(AVCodecContext *avctx)
+{
+    DecodeFilterContext *s = &avctx->internal->filter;
+    int i;
+
+    for (i = 0; i < s->nb_bsfs; i++)
+        av_bsf_free(&s->bsfs[i]);
+    av_freep(&s->bsfs);
+    s->nb_bsfs = 0;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/decode.h b/mythtv/external/FFmpeg/libavcodec/decode.h
new file mode 100644
index 00000000000..c9630228dc5
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/decode.h
@@ -0,0 +1,39 @@
+/*
+ * generic decoding-related code
+ *
+ * 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_DECODE_H
+#define AVCODEC_DECODE_H
+
+#include "avcodec.h"
+
+/**
+ * Called by decoders to get the next packet for decoding.
+ *
+ * @param pkt An empty packet to be filled with data.
+ * @return 0 if a new reference has been successfully written to pkt
+ *         AVERROR(EAGAIN) if no data is currently available
+ *         AVERROR_EOF if and end of stream has been reached, so no more data
+ *                     will be available
+ */
+int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt);
+
+void ff_decode_bsfs_uninit(AVCodecContext *avctx);
+
+#endif /* AVCODEC_DECODE_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/dfa.c b/mythtv/external/FFmpeg/libavcodec/dfa.c
index f45d019a792..43dba2c8e96 100644
--- a/mythtv/external/FFmpeg/libavcodec/dfa.c
+++ b/mythtv/external/FFmpeg/libavcodec/dfa.c
@@ -67,7 +67,8 @@ static int decode_tsw1(GetByteContext *gb, uint8_t *frame, int width, int height
     const uint8_t *frame_start = frame;
     const uint8_t *frame_end   = frame + width * height;
     int mask = 0x10000, bitbuf = 0;
-    int v, count, segments;
+    int v, count;
+    unsigned segments;
     unsigned offset;
 
     segments = bytestream2_get_le32(gb);
@@ -175,7 +176,7 @@ static int decode_dds1(GetByteContext *gb, uint8_t *frame, int width, int height
                 return AVERROR_INVALIDDATA;
             frame += v;
         } else {
-            if (frame_end - frame < width + 3)
+            if (frame_end - frame < width + 4)
                 return AVERROR_INVALIDDATA;
             frame[0] = frame[1] =
             frame[width] = frame[width + 1] =  bytestream2_get_byte(gb);
@@ -249,7 +250,7 @@ static int decode_wdlt(GetByteContext *gb, uint8_t *frame, int width, int height
         segments = bytestream2_get_le16u(gb);
         while ((segments & 0xC000) == 0xC000) {
             unsigned skip_lines = -(int16_t)segments;
-            unsigned delta = -((int16_t)segments * width);
+            int64_t delta = -((int16_t)segments * (int64_t)width);
             if (frame_end - frame <= delta || y + lines + skip_lines > height)
                 return AVERROR_INVALIDDATA;
             frame    += delta;
@@ -329,7 +330,7 @@ static const chunk_decoder decoder[8] = {
     decode_tdlt, decode_dsw1, decode_blck, decode_dds1,
 };
 
-static const char* chunk_name[8] = {
+static const char * const chunk_name[8] = {
     "COPY", "TSW1", "BDLT", "WDLT", "TDLT", "DSW1", "BLCK", "DDS1"
 };
 
diff --git a/mythtv/external/FFmpeg/libavcodec/dirac_arith.c b/mythtv/external/FFmpeg/libavcodec/dirac_arith.c
index bf913928b32..7eb9bd60b2f 100644
--- a/mythtv/external/FFmpeg/libavcodec/dirac_arith.c
+++ b/mythtv/external/FFmpeg/libavcodec/dirac_arith.c
@@ -83,6 +83,16 @@ const uint8_t ff_dirac_next_ctx[DIRAC_CTX_COUNT] = {
 
 int16_t ff_dirac_prob_branchless[256][2];
 
+av_cold void ff_dirac_init_arith_tables(void)
+{
+    int i;
+
+    for (i = 0; i < 256; i++) {
+        ff_dirac_prob_branchless[i][0] =  ff_dirac_prob[255-i];
+        ff_dirac_prob_branchless[i][1] = -ff_dirac_prob[i];
+    }
+}
+
 void ff_dirac_init_arith_decoder(DiracArith *c, GetBitContext *gb, int length)
 {
     int i;
@@ -106,11 +116,6 @@ void ff_dirac_init_arith_decoder(DiracArith *c, GetBitContext *gb, int length)
     c->counter = -16;
     c->range   = 0xffff;
 
-    for (i = 0; i < 256; i++) {
-        ff_dirac_prob_branchless[i][0] =  ff_dirac_prob[255-i];
-        ff_dirac_prob_branchless[i][1] = -ff_dirac_prob[i];
-    }
-
     for (i = 0; i < DIRAC_CTX_COUNT; i++)
         c->contexts[i] = 0x8000;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/dirac_arith.h b/mythtv/external/FFmpeg/libavcodec/dirac_arith.h
index 003430a48d1..24a7ca390e7 100644
--- a/mythtv/external/FFmpeg/libavcodec/dirac_arith.h
+++ b/mythtv/external/FFmpeg/libavcodec/dirac_arith.h
@@ -190,6 +190,7 @@ static inline int dirac_get_arith_int(DiracArith *c, int follow_ctx, int data_ct
     return ret;
 }
 
+void ff_dirac_init_arith_tables(void);
 void ff_dirac_init_arith_decoder(DiracArith *c, GetBitContext *gb, int length);
 
 #endif /* AVCODEC_DIRAC_ARITH_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/dirac_dwt.h b/mythtv/external/FFmpeg/libavcodec/dirac_dwt.h
index 4d338651fae..50c8b1e3946 100644
--- a/mythtv/external/FFmpeg/libavcodec/dirac_dwt.h
+++ b/mythtv/external/FFmpeg/libavcodec/dirac_dwt.h
@@ -93,16 +93,16 @@ void ff_spatial_idwt_slice2(DWTContext *d, int y);
 
 // shared stuff for simd optimizations
 #define COMPOSE_53iL0(b0, b1, b2)\
-    (b1 - ((b0 + b2 + 2) >> 2))
+    (b1 - ((int)(b0 + (unsigned)(b2) + 2) >> 2))
 
 #define COMPOSE_DIRAC53iH0(b0, b1, b2)\
-    (b1 + ((b0 + b2 + 1) >> 1))
+    (b1 + ((int)(b0 + (unsigned)(b2) + 1) >> 1))
 
 #define COMPOSE_DD97iH0(b0, b1, b2, b3, b4)\
-    (b2 + ((-b0 + 9*b1 + 9*b3 - b4 + 8) >> 4))
+    (b2 + ((int)(-b0 + 9U*b1 + 9U*b3 - b4 + 8) >> 4))
 
 #define COMPOSE_DD137iL0(b0, b1, b2, b3, b4)\
-    (b2 - ((-b0 + 9*b1 + 9*b3 - b4 + 16) >> 5))
+    (b2 - ((int)(-b0 + 9U*b1 + 9U*b3 - b4 + 16) >> 5))
 
 #define COMPOSE_HAARiL0(b0, b1)\
     (b0 - ((b1 + 1) >> 1))
@@ -111,22 +111,22 @@ void ff_spatial_idwt_slice2(DWTContext *d, int y);
     (b0 + b1)
 
 #define COMPOSE_FIDELITYiL0(b0, b1, b2, b3, b4, b5, b6, b7, b8)\
-    (b4 - ((-8*(b0+b8) + 21*(b1+b7) - 46*(b2+b6) + 161*(b3+b5) + 128) >> 8))
+    ((unsigned)b4 - ((int)(-8*(b0+(unsigned)b8) + 21*(b1+(unsigned)b7) - 46*(b2+(unsigned)b6) + 161*(b3+(unsigned)b5) + 128) >> 8))
 
 #define COMPOSE_FIDELITYiH0(b0, b1, b2, b3, b4, b5, b6, b7, b8)\
-    (b4 + ((-2*(b0+b8) + 10*(b1+b7) - 25*(b2+b6) + 81*(b3+b5) + 128) >> 8))
+    ((unsigned)b4 + ((int)(-2*(b0+(unsigned)b8) + 10*(b1+(unsigned)b7) - 25*(b2+(unsigned)b6) +  81*(b3+(unsigned)b5) + 128) >> 8))
 
 #define COMPOSE_DAUB97iL1(b0, b1, b2)\
-    (b1 - ((1817*(b0 + b2) + 2048) >> 12))
+    ((unsigned)(b1) - ((int)(1817*(b0 + (unsigned)b2) + 2048) >> 12))
 
 #define COMPOSE_DAUB97iH1(b0, b1, b2)\
-    (b1 - (( 113*(b0 + b2) + 64) >> 7))
+    ((unsigned)(b1) - ((int)( 113*(b0 + (unsigned)b2) + 64) >> 7))
 
 #define COMPOSE_DAUB97iL0(b0, b1, b2)\
-    (b1 + (( 217*(b0 + b2) + 2048) >> 12))
+    ((unsigned)(b1) + ((int)( 217*(b0 + (unsigned)b2) + 2048) >> 12))
 
 #define COMPOSE_DAUB97iH0(b0, b1, b2)\
-    (b1 + ((6497*(b0 + b2) + 2048) >> 12))
+    ((unsigned)(b1) + ((int)(6497*(b0 + (unsigned)b2) + 2048) >> 12))
 
 
 #endif /* AVCODEC_DWT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/dirac_dwt_template.c b/mythtv/external/FFmpeg/libavcodec/dirac_dwt_template.c
index 972c711cfff..e436c247a1f 100644
--- a/mythtv/external/FFmpeg/libavcodec/dirac_dwt_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/dirac_dwt_template.c
@@ -49,7 +49,7 @@ static void RENAME(vertical_compose53iL0)(uint8_t *_b0, uint8_t *_b1, uint8_t *_
     TYPE *b1 = (TYPE *)_b1;
     TYPE *b2 = (TYPE *)_b2;
     for (i = 0; i < width; i++)
-        b1[i] -= (b0[i] + b2[i] + 2) >> 2;
+        b1[i] -= (int)(b0[i] + (unsigned)b2[i] + 2) >> 2;
 }
 
 static av_always_inline void RENAME(interleave)(TYPE *dst, TYPE *src0, TYPE *src1, int w2,
diff --git a/mythtv/external/FFmpeg/libavcodec/dirac_vlc.c b/mythtv/external/FFmpeg/libavcodec/dirac_vlc.c
index 336d22a1829..496d8177cd8 100644
--- a/mythtv/external/FFmpeg/libavcodec/dirac_vlc.c
+++ b/mythtv/external/FFmpeg/libavcodec/dirac_vlc.c
@@ -37,7 +37,7 @@
 
 #define APPEND_RESIDUE(N, M)                                                   \
     N          |= M >> (N ## _bits);                                           \
-    N ## _bits +=      (M ## _bits)
+    N ## _bits  = (N ## _bits + (M ## _bits)) & 0x3F
 
 int ff_dirac_golomb_read_32bit(DiracGolombLUT *lut_ctx, const uint8_t *buf,
                                int bytes, uint8_t *_dst, int coeffs)
@@ -216,9 +216,14 @@ static void generate_offset_lut(DiracGolombLUT *lut, int off)
         INIT_RESIDUE(res);
         SET_RESIDUE(res, idx, LUT_BITS);
 
-        l->preamble      = CONVERT_TO_RESIDUE(res >> (RSIZE_BITS - off), off);
         l->preamble_bits = off;
-        l->sign = ((l->preamble >> (RSIZE_BITS - l->preamble_bits)) & 1) ? -1 : +1;
+        if (off) {
+            l->preamble  = CONVERT_TO_RESIDUE(res >> (RSIZE_BITS - off), off);
+            l->sign      = ((l->preamble >> (RSIZE_BITS - l->preamble_bits)) & 1) ? -1 : +1;
+        } else {
+            l->preamble  = 0;
+            l->sign = 1;
+        }
 
         search_for_golomb(l, res << off, LUT_BITS - off);
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/diracdec.c b/mythtv/external/FFmpeg/libavcodec/diracdec.c
index b183fad584f..0abb8b05990 100644
--- a/mythtv/external/FFmpeg/libavcodec/diracdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/diracdec.c
@@ -26,6 +26,7 @@
  * @author Marco Gerards <marco@gnu.org>, David Conrad, Jordi Ortiz <nenjordi@gmail.com>
  */
 
+#include "libavutil/thread.h"
 #include "avcodec.h"
 #include "get_bits.h"
 #include "bytestream.h"
@@ -248,7 +249,7 @@ enum dirac_subband {
 /* magic number division by 3 from schroedinger */
 static inline int divide3(int x)
 {
-    return ((x+1)*21845 + 10922) >> 16;
+    return (int)((x+1U)*21845 + 10922) >> 16;
 }
 
 static DiracFrame *remove_frame(DiracFrame *framelist[], int picnum)
@@ -379,10 +380,12 @@ static void free_sequence_buffers(DiracContext *s)
     av_freep(&s->mcscratch);
 }
 
+static AVOnce dirac_arith_init = AV_ONCE_INIT;
+
 static av_cold int dirac_decode_init(AVCodecContext *avctx)
 {
     DiracContext *s = avctx->priv_data;
-    int i;
+    int i, ret;
 
     s->avctx = avctx;
     s->frame_number = -1;
@@ -404,6 +407,9 @@ static av_cold int dirac_decode_init(AVCodecContext *avctx)
             return AVERROR(ENOMEM);
         }
     }
+    ret = ff_thread_once(&dirac_arith_init, ff_dirac_init_arith_tables);
+    if (ret != 0)
+        return AVERROR_UNKNOWN;
 
     return 0;
 }
@@ -436,7 +442,7 @@ static av_cold int dirac_decode_end(AVCodecContext *avctx)
 static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
 {
     int coeff = dirac_get_se_golomb(gb);
-    const int sign = FFSIGN(coeff);
+    const unsigned sign = FFSIGN(coeff);
     if (coeff)
         coeff = sign*((sign * coeff * qfactor + qoffset) >> 2);
     return coeff;
@@ -448,7 +454,8 @@ static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffse
     static inline void coeff_unpack_arith_##n(DiracArith *c, int qfactor, int qoffset, \
                                               SubBand *b, type *buf, int x, int y) \
     { \
-        int coeff, sign, sign_pred = 0, pred_ctx = CTX_ZPZN_F1; \
+        int sign, sign_pred = 0, pred_ctx = CTX_ZPZN_F1; \
+        unsigned coeff; \
         const int mstride = -(b->stride >> (1+b->pshift)); \
         if (b->parent) { \
             const type *pbuf = (type *)b->parent->ibuf; \
@@ -579,7 +586,7 @@ static inline void codeblock(DiracContext *s, SubBand *b,
     } \
 
 INTRA_DC_PRED(8, int16_t)
-INTRA_DC_PRED(10, int32_t)
+INTRA_DC_PRED(10, uint32_t)
 
 /**
  * Dirac Specification ->
@@ -817,7 +824,7 @@ static int decode_hq_slice(DiracContext *s, DiracSlice *slice, uint8_t *tmp_buf)
     skip_bits_long(gb, 8*s->highquality.prefix_bytes);
     quant_idx = get_bits(gb, 8);
 
-    if (quant_idx > DIRAC_MAX_QUANT_INDEX) {
+    if (quant_idx > DIRAC_MAX_QUANT_INDEX - 1) {
         av_log(s->avctx, AV_LOG_ERROR, "Invalid quantization index - %i\n", quant_idx);
         return AVERROR_INVALIDDATA;
     }
@@ -907,9 +914,10 @@ static int decode_lowdelay(DiracContext *s)
     int slice_num = 0;
 
     if (s->slice_params_num_buf != (s->num_x * s->num_y)) {
-        s->slice_params_buf = av_realloc_f(s->thread_buf, s->num_x * s->num_y, sizeof(DiracSlice));
+        s->slice_params_buf = av_realloc_f(s->slice_params_buf, s->num_x * s->num_y, sizeof(DiracSlice));
         if (!s->slice_params_buf) {
             av_log(s->avctx, AV_LOG_ERROR, "slice params buffer allocation failure\n");
+            s->slice_params_num_buf = 0;
             return AVERROR(ENOMEM);
         }
         s->slice_params_num_buf = s->num_x * s->num_y;
@@ -1153,6 +1161,10 @@ static int dirac_unpack_prediction_parameters(DiracContext *s)
                 s->globalmc[ref].perspective[0]  = dirac_get_se_golomb(gb);
                 s->globalmc[ref].perspective[1]  = dirac_get_se_golomb(gb);
             }
+            if (s->globalmc[ref].perspective_exp + (uint64_t)s->globalmc[ref].zrs_exp > 30) {
+                return AVERROR_INVALIDDATA;
+            }
+
         }
     }
 
@@ -1171,6 +1183,11 @@ static int dirac_unpack_prediction_parameters(DiracContext *s)
 
     if (get_bits1(gb)) {
         s->weight_log2denom = get_interleaved_ue_golomb(gb);
+        if (s->weight_log2denom < 1 || s->weight_log2denom > 8) {
+            av_log(s->avctx, AV_LOG_ERROR, "weight_log2denom unsupported or invalid\n");
+            s->weight_log2denom = 1;
+            return AVERROR_INVALIDDATA;
+        }
         s->weight[0] = dirac_get_se_golomb(gb);
         if (s->num_refs == 2)
             s->weight[1] = dirac_get_se_golomb(gb);
@@ -1250,11 +1267,10 @@ static int dirac_unpack_idwt_params(DiracContext *s)
         if (get_bits1(gb)) {
             av_log(s->avctx,AV_LOG_DEBUG,"Low Delay: Has Custom Quantization Matrix!\n");
             /* custom quantization matrix */
-            s->lowdelay.quant[0][0] = get_interleaved_ue_golomb(gb);
             for (level = 0; level < s->wavelet_depth; level++) {
-                s->lowdelay.quant[level][1] = get_interleaved_ue_golomb(gb);
-                s->lowdelay.quant[level][2] = get_interleaved_ue_golomb(gb);
-                s->lowdelay.quant[level][3] = get_interleaved_ue_golomb(gb);
+                for (i = !!level; i < 4; i++) {
+                    s->lowdelay.quant[level][i] = get_interleaved_ue_golomb(gb);
+                }
             }
         } else {
             if (s->wavelet_depth > 4) {
@@ -1405,7 +1421,7 @@ static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock
     if (!block->ref) {
         pred_block_dc(block, stride, x, y);
         for (i = 0; i < 3; i++)
-            block->u.dc[i] += dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
+            block->u.dc[i] += (unsigned)dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
         return;
     }
 
@@ -1974,7 +1990,9 @@ static int dirac_decode_picture_header(DiracContext *s)
             for (j = 0; j < MAX_FRAMES; j++)
                 if (!s->all_frames[j].avframe->data[0]) {
                     s->ref_pics[i] = &s->all_frames[j];
-                    get_buffer_with_edge(s->avctx, s->ref_pics[i]->avframe, AV_GET_BUFFER_FLAG_REF);
+                    ret = get_buffer_with_edge(s->avctx, s->ref_pics[i]->avframe, AV_GET_BUFFER_FLAG_REF);
+                    if (ret < 0)
+                        return ret;
                     break;
                 }
 
@@ -2038,9 +2056,9 @@ static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
 
     if (out) {
         out->reference ^= DELAYED_PIC_REF;
-        *got_frame = 1;
         if((ret = av_frame_ref(picture, out->avframe)) < 0)
             return ret;
+        *got_frame = 1;
     }
 
     return 0;
@@ -2082,7 +2100,10 @@ static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int
             return ret;
         }
 
-        ret = ff_set_dimensions(avctx, dsh->width, dsh->height);
+        if (CALC_PADDING((int64_t)dsh->width, MAX_DWT_LEVELS) * CALC_PADDING((int64_t)dsh->height, MAX_DWT_LEVELS) > avctx->max_pixels)
+            ret = AVERROR(ERANGE);
+        if (ret >= 0)
+            ret = ff_set_dimensions(avctx, dsh->width, dsh->height);
         if (ret < 0) {
             av_freep(&dsh);
             return ret;
@@ -2296,5 +2317,6 @@ AVCodec ff_dirac_decoder = {
     .close          = dirac_decode_end,
     .decode         = dirac_decode_frame,
     .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
     .flush          = dirac_decode_flush,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/diracdsp.c b/mythtv/external/FFmpeg/libavcodec/diracdsp.c
index cd1209e209d..2dd56f83f33 100644
--- a/mythtv/external/FFmpeg/libavcodec/diracdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/diracdsp.c
@@ -159,10 +159,10 @@ static void put_signed_rect_clamped_ ## PX ## bit_c(uint8_t *_dst, int dst_strid
     int32_t *src = (int32_t *)_src;                                                                     \
     for (y = 0; y < height; y++) {                                                                      \
         for (x = 0; x < width; x+=4) {                                                                  \
-            dst[x  ] = av_clip_uintp2(src[x  ] + (1 << (PX - 1)), PX);                                  \
-            dst[x+1] = av_clip_uintp2(src[x+1] + (1 << (PX - 1)), PX);                                  \
-            dst[x+2] = av_clip_uintp2(src[x+2] + (1 << (PX - 1)), PX);                                  \
-            dst[x+3] = av_clip_uintp2(src[x+3] + (1 << (PX - 1)), PX);                                  \
+            dst[x  ] = av_clip_uintp2(src[x  ] + (1U << (PX - 1)), PX);                                  \
+            dst[x+1] = av_clip_uintp2(src[x+1] + (1U << (PX - 1)), PX);                                  \
+            dst[x+2] = av_clip_uintp2(src[x+2] + (1U << (PX - 1)), PX);                                  \
+            dst[x+3] = av_clip_uintp2(src[x+3] + (1U << (PX - 1)), PX);                                  \
         }                                                                                               \
         dst += dst_stride >> 1;                                                                         \
         src += src_stride >> 2;                                                                         \
@@ -199,7 +199,7 @@ static void dequant_subband_ ## PX ## _c(uint8_t *src, uint8_t *dst, ptrdiff_t s
         for (i = 0; i < tot_h; i++) {                                                      \
             c = *src_r++;                                                                  \
             sign = FFSIGN(c)*(!!c);                                                        \
-            c = (FFABS(c)*qf + qs) >> 2;                                                   \
+            c = (FFABS(c)*(unsigned)qf + qs) >> 2;                                                   \
             *dst_r++ = c*sign;                                                             \
         }                                                                                  \
         src += tot_h << (sizeof(PX) >> 1);                                                 \
diff --git a/mythtv/external/FFmpeg/libavcodec/dnxhd_parser.c b/mythtv/external/FFmpeg/libavcodec/dnxhd_parser.c
index 033b8ee7e11..79ca1d67188 100644
--- a/mythtv/external/FFmpeg/libavcodec/dnxhd_parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/dnxhd_parser.c
@@ -29,8 +29,9 @@
 
 typedef struct {
     ParseContext pc;
-    int interlaced;
-    int cur_field; /* first field is 0, second is 1 */
+    int cur_byte;
+    int remaining;
+    int w, h;
 } DNXHDParserContext;
 
 static int dnxhd_find_frame_end(DNXHDParserContext *dctx,
@@ -40,8 +41,6 @@ static int dnxhd_find_frame_end(DNXHDParserContext *dctx,
     uint64_t state = pc->state64;
     int pic_found = pc->frame_start_found;
     int i = 0;
-    int interlaced = dctx->interlaced;
-    int cur_field = dctx->cur_field;
 
     if (!pic_found) {
         for (i = 0; i < buf_size; i++) {
@@ -49,37 +48,66 @@ static int dnxhd_find_frame_end(DNXHDParserContext *dctx,
             if (ff_dnxhd_check_header_prefix(state & 0xffffffffff00LL) != 0) {
                 i++;
                 pic_found = 1;
-                interlaced = (state&2)>>1; /* byte following the 5-byte header prefix */
-                cur_field = state&1;
+                dctx->cur_byte = 0;
+                dctx->remaining = 0;
                 break;
             }
         }
     }
 
-    if (pic_found) {
+    if (pic_found && !dctx->remaining) {
         if (!buf_size) /* EOF considered as end of frame */
             return 0;
         for (; i < buf_size; i++) {
+            dctx->cur_byte++;
             state = (state << 8) | buf[i];
-            if (ff_dnxhd_check_header_prefix(state & 0xffffffffff00LL) != 0) {
-                if (!interlaced || dctx->cur_field) {
+
+            if (dctx->cur_byte == 24) {
+                dctx->h = (state >> 32) & 0xFFFF;
+            } else if (dctx->cur_byte == 26) {
+                dctx->w = (state >> 32) & 0xFFFF;
+            } else if (dctx->cur_byte == 42) {
+                int cid = (state >> 32) & 0xFFFFFFFF;
+                int remaining;
+
+                if (cid <= 0)
+                    continue;
+
+                remaining = avpriv_dnxhd_get_frame_size(cid);
+                if (remaining <= 0) {
+                    remaining = ff_dnxhd_get_hr_frame_size(cid, dctx->w, dctx->h);
+                    if (remaining <= 0)
+                        continue;
+                }
+                dctx->remaining = remaining;
+                if (buf_size - i + 47 >= dctx->remaining) {
+                    int remaining = dctx->remaining;
+
                     pc->frame_start_found = 0;
                     pc->state64 = -1;
-                    dctx->interlaced = interlaced;
-                    dctx->cur_field = 0;
-                    return i - 5;
+                    dctx->cur_byte = 0;
+                    dctx->remaining = 0;
+                    return remaining;
                 } else {
-                    /* continue, to get the second field */
-                    dctx->interlaced = interlaced = (state&2)>>1;
-                    dctx->cur_field = cur_field = state&1;
+                    dctx->remaining -= buf_size;
                 }
             }
         }
+    } else if (pic_found) {
+        if (dctx->remaining > buf_size) {
+            dctx->remaining -= buf_size;
+        } else {
+            int remaining = dctx->remaining;
+
+            pc->frame_start_found = 0;
+            pc->state64 = -1;
+            dctx->cur_byte = 0;
+            dctx->remaining = 0;
+            return remaining;
+        }
     }
     pc->frame_start_found = pic_found;
     pc->state64 = state;
-    dctx->interlaced = interlaced;
-    dctx->cur_field = cur_field;
     return END_NOT_FOUND;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/dnxhddata.h b/mythtv/external/FFmpeg/libavcodec/dnxhddata.h
index 89262a13c1c..c96c5e8f65a 100644
--- a/mythtv/external/FFmpeg/libavcodec/dnxhddata.h
+++ b/mythtv/external/FFmpeg/libavcodec/dnxhddata.h
@@ -91,6 +91,19 @@ static av_always_inline uint64_t ff_dnxhd_parse_header_prefix(const uint8_t *buf
     return ff_dnxhd_check_header_prefix(prefix);
 }
 
+static av_always_inline int ff_dnxhd_get_hr_frame_size(int cid, int w, int h)
+{
+    int result, i = ff_dnxhd_get_cid_table(cid);
+
+    if (i < 0)
+        return i;
+
+    result = ((h + 15) / 16) * ((w + 15) / 16) * (int64_t)ff_dnxhd_cid_table[i].packet_scale.num / ff_dnxhd_cid_table[i].packet_scale.den;
+    result = (result + 2048) / 4096 * 4096;
+
+    return FFMAX(result, 8192);
+}
+
 int avpriv_dnxhd_get_frame_size(int cid);
 int avpriv_dnxhd_get_interlaced(int cid);
 #if LIBAVCODEC_VERSION_MAJOR < 58
diff --git a/mythtv/external/FFmpeg/libavcodec/dnxhddec.c b/mythtv/external/FFmpeg/libavcodec/dnxhddec.c
index 4d1b006bb50..f46e41a4562 100644
--- a/mythtv/external/FFmpeg/libavcodec/dnxhddec.c
+++ b/mythtv/external/FFmpeg/libavcodec/dnxhddec.c
@@ -58,7 +58,7 @@ typedef struct DNXHDContext {
     unsigned int width, height;
     enum AVPixelFormat pix_fmt;
     unsigned int mb_width, mb_height;
-    uint32_t mb_scan_index[256];
+    uint32_t mb_scan_index[512];
     int data_offset;                    // End of mb_scan_index, where macroblocks start
     int cur_field;                      ///< current interlaced field
     VLC ac_vlc, dc_vlc, run_vlc;
@@ -111,7 +111,7 @@ static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
         int index;
 
         if ((index = ff_dnxhd_get_cid_table(cid)) < 0) {
-            av_log(ctx->avctx, AV_LOG_ERROR, "unsupported cid %d\n", cid);
+            av_log(ctx->avctx, AV_LOG_ERROR, "unsupported cid %"PRIu32"\n", cid);
             return AVERROR(ENOSYS);
         }
         if (ff_dnxhd_cid_table[index].bit_depth != bitdepth &&
@@ -120,7 +120,7 @@ static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)
             return AVERROR_INVALIDDATA;
         }
         ctx->cid_table = &ff_dnxhd_cid_table[index];
-        av_log(ctx->avctx, AV_LOG_VERBOSE, "Profile cid %d.\n", cid);
+        av_log(ctx->avctx, AV_LOG_VERBOSE, "Profile cid %"PRIu32".\n", cid);
 
         ff_free_vlc(&ctx->ac_vlc);
         ff_free_vlc(&ctx->dc_vlc);
@@ -145,6 +145,7 @@ static av_cold int dnxhd_decode_init_thread_copy(AVCodecContext *avctx)
 {
     DNXHDContext *ctx = avctx->priv_data;
 
+    ctx->avctx = avctx;
     // make sure VLC tables will be loaded when cid is parsed
     ctx->cid = -1;
 
@@ -234,7 +235,7 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
     ctx->is_444 = (buf[0x2C] >> 6) & 1;
     if (ctx->is_444) {
         if (bitdepth == 8) {
-            avpriv_request_sample(ctx->avctx, "4:4:4 8 bits\n");
+            avpriv_request_sample(ctx->avctx, "4:4:4 8 bits");
             return AVERROR_INVALIDDATA;
         } else if (bitdepth == 10) {
             ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
@@ -249,7 +250,10 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
         ctx->decode_dct_block = dnxhd_decode_dct_block_12;
         ctx->pix_fmt = AV_PIX_FMT_YUV422P12;
     } else if (bitdepth == 10) {
-        ctx->decode_dct_block = dnxhd_decode_dct_block_10;
+        if (ctx->avctx->profile == FF_PROFILE_DNXHR_HQX)
+            ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
+        else
+            ctx->decode_dct_block = dnxhd_decode_dct_block_10;
         ctx->pix_fmt = AV_PIX_FMT_YUV422P10;
     } else {
         ctx->decode_dct_block = dnxhd_decode_dct_block_8;
@@ -275,13 +279,13 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
     }
 
     if (buf_size < ctx->cid_table->coding_unit_size) {
-        av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size (%d < %d).\n",
+        av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size (%d < %u).\n",
                buf_size, ctx->cid_table->coding_unit_size);
         return AVERROR_INVALIDDATA;
     }
 
     ctx->mb_width  = (ctx->width + 15)>> 4;
-    ctx->mb_height = buf[0x16d];
+    ctx->mb_height = AV_RB16(buf + 0x16c);
 
     if ((ctx->height + 15) >> 4 == ctx->mb_height && frame->interlaced_frame)
         ctx->height <<= 1;
@@ -294,14 +298,18 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
     if (ctx->mb_height > 68 && ff_dnxhd_check_header_prefix_hr(header_prefix)) {
         ctx->data_offset = 0x170 + (ctx->mb_height << 2);
     } else {
-        if (ctx->mb_height > 68 ||
-            (ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) {
+        if (ctx->mb_height > 68) {
             av_log(ctx->avctx, AV_LOG_ERROR,
                    "mb height too big: %d\n", ctx->mb_height);
             return AVERROR_INVALIDDATA;
         }
         ctx->data_offset = 0x280;
     }
+    if ((ctx->mb_height << frame->interlaced_frame) > (ctx->height + 15) >> 4) {
+        av_log(ctx->avctx, AV_LOG_ERROR,
+                "mb height too big: %d\n", ctx->mb_height);
+        return AVERROR_INVALIDDATA;
+    }
 
     if (buf_size < ctx->data_offset) {
         av_log(ctx->avctx, AV_LOG_ERROR,
@@ -309,14 +317,19 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
         return AVERROR_INVALIDDATA;
     }
 
-    av_assert0((unsigned)ctx->mb_height <= FF_ARRAY_ELEMS(ctx->mb_scan_index));
+    if (ctx->mb_height > FF_ARRAY_ELEMS(ctx->mb_scan_index)) {
+        av_log(ctx->avctx, AV_LOG_ERROR,
+               "mb_height too big (%d > %"SIZE_SPECIFIER").\n", ctx->mb_height, FF_ARRAY_ELEMS(ctx->mb_scan_index));
+        return AVERROR_INVALIDDATA;
+    }
 
     for (i = 0; i < ctx->mb_height; i++) {
         ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i << 2));
-        ff_dlog(ctx->avctx, "mb scan index %d, pos %d: %u\n", i, 0x170 + (i << 2), ctx->mb_scan_index[i]);
+        ff_dlog(ctx->avctx, "mb scan index %d, pos %d: %"PRIu32"\n",
+                i, 0x170 + (i << 2), ctx->mb_scan_index[i]);
         if (buf_size - ctx->data_offset < ctx->mb_scan_index[i]) {
             av_log(ctx->avctx, AV_LOG_ERROR,
-                   "invalid mb scan index (%u vs %u).\n",
+                   "invalid mb scan index (%"PRIu32" vs %u).\n",
                    ctx->mb_scan_index[i], buf_size - ctx->data_offset);
             return AVERROR_INVALIDDATA;
         }
@@ -605,7 +618,7 @@ static int dnxhd_decode_frame(AVCodecContext *avctx, void *data,
 
     if ((avctx->width || avctx->height) &&
         (ctx->width != avctx->width || ctx->height != avctx->height)) {
-        av_log(avctx, AV_LOG_WARNING, "frame size changed: %dx%d -> %dx%d\n",
+        av_log(avctx, AV_LOG_WARNING, "frame size changed: %dx%d -> %ux%u\n",
                avctx->width, avctx->height, ctx->width, ctx->height);
         first_field = 1;
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/dnxhdenc.c b/mythtv/external/FFmpeg/libavcodec/dnxhdenc.c
index 60bea83c1fe..0d80381a2da 100644
--- a/mythtv/external/FFmpeg/libavcodec/dnxhdenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/dnxhdenc.c
@@ -112,6 +112,65 @@ void dnxhd_10bit_get_pixels_8x4_sym(int16_t *av_restrict block,
     memcpy(block + 4 * 8, pixels + 3 * line_size, 8 * sizeof(*block));
 }
 
+static int dnxhd_10bit_dct_quantize_444(MpegEncContext *ctx, int16_t *block,
+                                        int n, int qscale, int *overflow)
+{
+    int i, j, level, last_non_zero, start_i;
+    const int *qmat;
+    const uint8_t *scantable= ctx->intra_scantable.scantable;
+    int bias;
+    int max = 0;
+    unsigned int threshold1, threshold2;
+
+    ctx->fdsp.fdct(block);
+
+    block[0] = (block[0] + 2) >> 2;
+    start_i = 1;
+    last_non_zero = 0;
+    qmat = n < 4 ? ctx->q_intra_matrix[qscale] : ctx->q_chroma_intra_matrix[qscale];
+    bias= ctx->intra_quant_bias * (1 << (16 - 8));
+    threshold1 = (1 << 16) - bias - 1;
+    threshold2 = (threshold1 << 1);
+
+    for (i = 63; i >= start_i; i--) {
+        j = scantable[i];
+        level = block[j] * qmat[j];
+
+        if (((unsigned)(level + threshold1)) > threshold2) {
+            last_non_zero = i;
+            break;
+        } else{
+            block[j]=0;
+        }
+    }
+
+    for (i = start_i; i <= last_non_zero; i++) {
+        j = scantable[i];
+        level = block[j] * qmat[j];
+
+        if (((unsigned)(level + threshold1)) > threshold2) {
+            if (level > 0) {
+                level = (bias + level) >> 16;
+                block[j] = level;
+            } else{
+                level = (bias - level) >> 16;
+                block[j] = -level;
+            }
+            max |= level;
+        } else {
+            block[j] = 0;
+        }
+    }
+    *overflow = ctx->max_qcoeff < max; //overflow might have happened
+
+    /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
+    if (ctx->idsp.perm_type != FF_IDCT_PERM_NONE)
+        ff_block_permute(block, ctx->idsp.idct_permutation,
+                         scantable, last_non_zero);
+
+    return last_non_zero;
+}
+
 static int dnxhd_10bit_dct_quantize(MpegEncContext *ctx, int16_t *block,
                                     int n, int qscale, int *overflow)
 {
@@ -146,7 +205,7 @@ static int dnxhd_10bit_dct_quantize(MpegEncContext *ctx, int16_t *block,
 static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx)
 {
     int i, j, level, run;
-    int max_level = 1 << (ctx->cid_table->bit_depth + 2);
+    int max_level = 1 << (ctx->bit_depth + 2);
 
     FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->vlc_codes,
                       max_level, 4 * sizeof(*ctx->vlc_codes), fail);
@@ -223,7 +282,7 @@ static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
                       (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t),
                       fail);
 
-    if (ctx->cid_table->bit_depth == 8) {
+    if (ctx->bit_depth == 8) {
         for (i = 1; i < 64; i++) {
             int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
             weight_matrix[j] = ctx->cid_table->luma_weight[i];
@@ -303,23 +362,19 @@ static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
     return AVERROR(ENOMEM);
 }
 
-static int dnxhd_get_hr_frame_size(const CIDEntry* profile, int mb_num)
-{
-  int result = mb_num * profile->packet_scale.num / profile->packet_scale.den;
-  result = (result + 2048) / 4096 * 4096;
-  return FFMAX(result, 8192);
-}
 static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
 {
     DNXHDEncContext *ctx = avctx->priv_data;
-    int i, index, bit_depth, ret;
+    int i, index, ret;
 
     switch (avctx->pix_fmt) {
     case AV_PIX_FMT_YUV422P:
-        bit_depth = 8;
+        ctx->bit_depth = 8;
         break;
     case AV_PIX_FMT_YUV422P10:
-        bit_depth = 10;
+    case AV_PIX_FMT_YUV444P10:
+    case AV_PIX_FMT_GBRP10:
+        ctx->bit_depth = 10;
         break;
     default:
         av_log(avctx, AV_LOG_ERROR,
@@ -327,15 +382,32 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
         return AVERROR(EINVAL);
     }
 
-    if (ctx->profile == FF_PROFILE_DNXHR_444 ||
-        ctx->profile == FF_PROFILE_DNXHR_HQX) {
-        avpriv_report_missing_feature(avctx,
-               "dnxhr_444 or dnxhr_hqx profile");
-        return AVERROR_PATCHWELCOME;
+    if ((ctx->profile == FF_PROFILE_DNXHR_444 && (avctx->pix_fmt != AV_PIX_FMT_YUV444P10 &&
+                                                  avctx->pix_fmt != AV_PIX_FMT_GBRP10)) ||
+        (ctx->profile != FF_PROFILE_DNXHR_444 && (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 ||
+                                                  avctx->pix_fmt == AV_PIX_FMT_GBRP10))) {
+        av_log(avctx, AV_LOG_ERROR,
+               "pixel format is incompatible with DNxHD profile\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (ctx->profile == FF_PROFILE_DNXHR_HQX && avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
+        av_log(avctx, AV_LOG_ERROR,
+               "pixel format is incompatible with DNxHR HQX profile\n");
+        return AVERROR(EINVAL);
     }
 
+    if ((ctx->profile == FF_PROFILE_DNXHR_LB ||
+         ctx->profile == FF_PROFILE_DNXHR_SQ ||
+         ctx->profile == FF_PROFILE_DNXHR_HQ) && avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
+        av_log(avctx, AV_LOG_ERROR,
+               "pixel format is incompatible with DNxHR LB/SQ/HQ profile\n");
+        return AVERROR(EINVAL);
+    }
+
+    ctx->is_444 = ctx->profile == FF_PROFILE_DNXHR_444;
     avctx->profile = ctx->profile;
-    ctx->cid = ff_dnxhd_find_cid(avctx, bit_depth);
+    ctx->cid = ff_dnxhd_find_cid(avctx, ctx->bit_depth);
     if (!ctx->cid) {
         av_log(avctx, AV_LOG_ERROR,
                "video parameters incompatible with DNxHD. Valid DNxHD profiles:\n");
@@ -362,7 +434,7 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
     ctx->m.mb_intra = 1;
     ctx->m.h263_aic = 1;
 
-    avctx->bits_per_raw_sample = ctx->cid_table->bit_depth;
+    avctx->bits_per_raw_sample = ctx->bit_depth;
 
     ff_blockdsp_init(&ctx->bdsp, avctx);
     ff_fdctdsp_init(&ctx->m.fdsp, avctx);
@@ -372,12 +444,16 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
     ff_dct_encode_init(&ctx->m);
 
     if (ctx->profile != FF_PROFILE_DNXHD)
-        ff_videodsp_init(&ctx->m.vdsp, bit_depth);
+        ff_videodsp_init(&ctx->m.vdsp, ctx->bit_depth);
 
     if (!ctx->m.dct_quantize)
         ctx->m.dct_quantize = ff_dct_quantize_c;
 
-    if (ctx->cid_table->bit_depth == 10) {
+    if (ctx->is_444 || ctx->profile == FF_PROFILE_DNXHR_HQX) {
+        ctx->m.dct_quantize     = dnxhd_10bit_dct_quantize_444;
+        ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym;
+        ctx->block_width_l2     = 4;
+    } else if (ctx->bit_depth == 10) {
         ctx->m.dct_quantize     = dnxhd_10bit_dct_quantize;
         ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym;
         ctx->block_width_l2     = 4;
@@ -400,8 +476,9 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
     ctx->m.mb_num = ctx->m.mb_height * ctx->m.mb_width;
 
     if (ctx->cid_table->frame_size == DNXHD_VARIABLE) {
-        ctx->frame_size = dnxhd_get_hr_frame_size(ctx->cid_table,
-                                                  ctx->m.mb_num);
+        ctx->frame_size = ff_dnxhd_get_hr_frame_size(ctx->cid,
+                                                     avctx->width, avctx->height);
+        av_assert0(ctx->frame_size >= 0);
         ctx->coding_unit_size = ctx->frame_size;
     } else {
         ctx->frame_size = ctx->cid_table->frame_size;
@@ -449,9 +526,11 @@ FF_DISABLE_DEPRECATION_WARNINGS
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
 
-    if (avctx->thread_count > MAX_THREADS) {
-        av_log(avctx, AV_LOG_ERROR, "too many threads\n");
-        return AVERROR(EINVAL);
+    if (avctx->active_thread_type == FF_THREAD_SLICE) {
+        if (avctx->thread_count > MAX_THREADS) {
+            av_log(avctx, AV_LOG_ERROR, "too many threads\n");
+            return AVERROR(EINVAL);
+        }
     }
 
     if (avctx->qmax <= 1) {
@@ -460,9 +539,11 @@ FF_ENABLE_DEPRECATION_WARNINGS
     }
 
     ctx->thread[0] = ctx;
-    for (i = 1; i < avctx->thread_count; i++) {
-        ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext));
-        memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext));
+    if (avctx->active_thread_type == FF_THREAD_SLICE) {
+        for (i = 1; i < avctx->thread_count; i++) {
+            ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext));
+            memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext));
+        }
     }
 
     return 0;
@@ -490,16 +571,16 @@ static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
     AV_WB16(buf + 0x1a, avctx->width);  // SPL
     AV_WB16(buf + 0x1d, avctx->height >> ctx->interlaced); // NAL
 
-    buf[0x21] = ctx->cid_table->bit_depth == 10 ? 0x58 : 0x38;
+    buf[0x21] = ctx->bit_depth == 10 ? 0x58 : 0x38;
     buf[0x22] = 0x88 + (ctx->interlaced << 2);
     AV_WB32(buf + 0x28, ctx->cid); // CID
-    buf[0x2c] = ctx->interlaced ? 0 : 0x80;
+    buf[0x2c] = (!ctx->interlaced << 7) | (ctx->is_444 << 6) | (avctx->pix_fmt == AV_PIX_FMT_YUV444P10);
 
     buf[0x5f] = 0x01; // UDL
 
     buf[0x167] = 0x02; // reserved
     AV_WB16(buf + 0x16a, ctx->m.mb_height * 4 + 4); // MSIPS
-    buf[0x16d] = ctx->m.mb_height; // Ns
+    AV_WB16(buf + 0x16c, ctx->m.mb_height); // Ns
     buf[0x16f] = 0x10; // reserved
 
     ctx->msip = buf + 0x170;
@@ -554,8 +635,13 @@ void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n,
     int level;
     int i;
 
-    weight_matrix = (n & 2) ? ctx->cid_table->chroma_weight
-                            : ctx->cid_table->luma_weight;
+    if (ctx->is_444) {
+        weight_matrix = ((n % 6) < 2) ? ctx->cid_table->luma_weight
+                                      : ctx->cid_table->chroma_weight;
+    } else {
+        weight_matrix = (n & 2) ? ctx->cid_table->chroma_weight
+                                : ctx->cid_table->luma_weight;
+    }
 
     for (i = 1; i <= last_index; i++) {
         int j = ctx->m.intra_scantable.permutated[i];
@@ -563,7 +649,7 @@ void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n,
         if (level) {
             if (level < 0) {
                 level = (1 - 2 * level) * qscale * weight_matrix[i];
-                if (ctx->cid_table->bit_depth == 10) {
+                if (ctx->bit_depth == 10) {
                     if (weight_matrix[i] != 8)
                         level += 8;
                     level >>= 4;
@@ -575,7 +661,7 @@ void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n,
                 level = -level;
             } else {
                 level = (2 * level + 1) * qscale * weight_matrix[i];
-                if (ctx->cid_table->bit_depth == 10) {
+                if (ctx->bit_depth == 10) {
                     if (weight_matrix[i] != 8)
                         level += 8;
                     level >>= 4;
@@ -630,14 +716,14 @@ void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
     const uint8_t *ptr_y = ctx->thread[0]->src[0] +
                            ((mb_y << 4) * ctx->m.linesize) + (mb_x << bs + 1);
     const uint8_t *ptr_u = ctx->thread[0]->src[1] +
-                           ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs);
+                           ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
     const uint8_t *ptr_v = ctx->thread[0]->src[2] +
-                           ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs);
+                           ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
     PixblockDSPContext *pdsp = &ctx->m.pdsp;
     VideoDSPContext *vdsp = &ctx->m.vdsp;
 
-    if (vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
-                                   (mb_y << 4) + 16 > ctx->m.avctx->height)) {
+    if (ctx->bit_depth != 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
+                                                           (mb_y << 4) + 16 > ctx->m.avctx->height)) {
         int y_w = ctx->m.avctx->width  - (mb_x << 4);
         int y_h = ctx->m.avctx->height - (mb_y << 4);
         int uv_w = (y_w + 1) / 2;
@@ -663,50 +749,101 @@ void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
         ptr_y = &ctx->edge_buf_y[0];
         ptr_u = &ctx->edge_buf_uv[0][0];
         ptr_v = &ctx->edge_buf_uv[1][0];
+    } else if (ctx->bit_depth == 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
+                                                                  (mb_y << 4) + 16 > ctx->m.avctx->height)) {
+        int y_w = ctx->m.avctx->width  - (mb_x << 4);
+        int y_h = ctx->m.avctx->height - (mb_y << 4);
+        int uv_w = ctx->is_444 ? y_w : (y_w + 1) / 2;
+        int uv_h = y_h;
+        linesize = 32;
+        uvlinesize = 16 + 16 * ctx->is_444;
+
+        vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y,
+                               linesize, ctx->m.linesize,
+                               linesize / 2, 16,
+                               0, 0, y_w, y_h);
+        vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u,
+                               uvlinesize, ctx->m.uvlinesize,
+                               uvlinesize / 2, 16,
+                               0, 0, uv_w, uv_h);
+        vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v,
+                               uvlinesize, ctx->m.uvlinesize,
+                               uvlinesize / 2, 16,
+                               0, 0, uv_w, uv_h);
+
+        dct_y_offset =  bw * linesize / 2;
+        dct_uv_offset = bw * uvlinesize / 2;
+        ptr_y = &ctx->edge_buf_y[0];
+        ptr_u = &ctx->edge_buf_uv[0][0];
+        ptr_v = &ctx->edge_buf_uv[1][0];
     }
 
-    pdsp->get_pixels(ctx->blocks[0], ptr_y,      linesize);
-    pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize);
-    pdsp->get_pixels(ctx->blocks[2], ptr_u,      uvlinesize);
-    pdsp->get_pixels(ctx->blocks[3], ptr_v,      uvlinesize);
-
-    if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
-        if (ctx->interlaced) {
-            ctx->get_pixels_8x4_sym(ctx->blocks[4],
-                                    ptr_y + dct_y_offset,
-                                    linesize);
-            ctx->get_pixels_8x4_sym(ctx->blocks[5],
-                                    ptr_y + dct_y_offset + bw,
-                                    linesize);
-            ctx->get_pixels_8x4_sym(ctx->blocks[6],
-                                    ptr_u + dct_uv_offset,
-                                    uvlinesize);
-            ctx->get_pixels_8x4_sym(ctx->blocks[7],
-                                    ptr_v + dct_uv_offset,
-                                    uvlinesize);
+    if (!ctx->is_444) {
+        pdsp->get_pixels(ctx->blocks[0], ptr_y,      linesize);
+        pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize);
+        pdsp->get_pixels(ctx->blocks[2], ptr_u,      uvlinesize);
+        pdsp->get_pixels(ctx->blocks[3], ptr_v,      uvlinesize);
+
+        if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
+            if (ctx->interlaced) {
+                ctx->get_pixels_8x4_sym(ctx->blocks[4],
+                                        ptr_y + dct_y_offset,
+                                        linesize);
+                ctx->get_pixels_8x4_sym(ctx->blocks[5],
+                                        ptr_y + dct_y_offset + bw,
+                                        linesize);
+                ctx->get_pixels_8x4_sym(ctx->blocks[6],
+                                        ptr_u + dct_uv_offset,
+                                        uvlinesize);
+                ctx->get_pixels_8x4_sym(ctx->blocks[7],
+                                        ptr_v + dct_uv_offset,
+                                        uvlinesize);
+            } else {
+                ctx->bdsp.clear_block(ctx->blocks[4]);
+                ctx->bdsp.clear_block(ctx->blocks[5]);
+                ctx->bdsp.clear_block(ctx->blocks[6]);
+                ctx->bdsp.clear_block(ctx->blocks[7]);
+            }
         } else {
-            ctx->bdsp.clear_block(ctx->blocks[4]);
-            ctx->bdsp.clear_block(ctx->blocks[5]);
-            ctx->bdsp.clear_block(ctx->blocks[6]);
-            ctx->bdsp.clear_block(ctx->blocks[7]);
+            pdsp->get_pixels(ctx->blocks[4],
+                             ptr_y + dct_y_offset, linesize);
+            pdsp->get_pixels(ctx->blocks[5],
+                             ptr_y + dct_y_offset + bw, linesize);
+            pdsp->get_pixels(ctx->blocks[6],
+                             ptr_u + dct_uv_offset, uvlinesize);
+            pdsp->get_pixels(ctx->blocks[7],
+                             ptr_v + dct_uv_offset, uvlinesize);
         }
     } else {
-        pdsp->get_pixels(ctx->blocks[4],
-                         ptr_y + dct_y_offset, linesize);
-        pdsp->get_pixels(ctx->blocks[5],
-                         ptr_y + dct_y_offset + bw, linesize);
-        pdsp->get_pixels(ctx->blocks[6],
-                         ptr_u + dct_uv_offset, uvlinesize);
-        pdsp->get_pixels(ctx->blocks[7],
-                         ptr_v + dct_uv_offset, uvlinesize);
+        pdsp->get_pixels(ctx->blocks[0], ptr_y,      linesize);
+        pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize);
+        pdsp->get_pixels(ctx->blocks[6], ptr_y + dct_y_offset, linesize);
+        pdsp->get_pixels(ctx->blocks[7], ptr_y + dct_y_offset + bw, linesize);
+
+        pdsp->get_pixels(ctx->blocks[2], ptr_u,      uvlinesize);
+        pdsp->get_pixels(ctx->blocks[3], ptr_u + bw, uvlinesize);
+        pdsp->get_pixels(ctx->blocks[8], ptr_u + dct_uv_offset, uvlinesize);
+        pdsp->get_pixels(ctx->blocks[9], ptr_u + dct_uv_offset + bw, uvlinesize);
+
+        pdsp->get_pixels(ctx->blocks[4], ptr_v,      uvlinesize);
+        pdsp->get_pixels(ctx->blocks[5], ptr_v + bw, uvlinesize);
+        pdsp->get_pixels(ctx->blocks[10], ptr_v + dct_uv_offset, uvlinesize);
+        pdsp->get_pixels(ctx->blocks[11], ptr_v + dct_uv_offset + bw, uvlinesize);
     }
 }
 
 static av_always_inline
 int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i)
 {
-    const static uint8_t component[8]={0,0,1,2,0,0,1,2};
-    return component[i];
+    int x;
+
+    if (ctx->is_444) {
+        x = (i >> 1) % 3;
+    } else {
+        const static uint8_t component[8]={0,0,1,2,0,0,1,2};
+        x = component[i];
+    }
+    return x;
 }
 
 static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
@@ -720,7 +857,7 @@ static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
 
     ctx->m.last_dc[0] =
     ctx->m.last_dc[1] =
-    ctx->m.last_dc[2] = 1 << (ctx->cid_table->bit_depth + 2);
+    ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
 
     for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
         unsigned mb = mb_y * ctx->m.mb_width + mb_x;
@@ -731,13 +868,14 @@ static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
 
         dnxhd_get_blocks(ctx, mb_x, mb_y);
 
-        for (i = 0; i < 8; i++) {
+        for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
             int16_t *src_block = ctx->blocks[i];
             int overflow, nbits, diff, last_index;
             int n = dnxhd_switch_matrix(ctx, i);
 
             memcpy(block, src_block, 64 * sizeof(*block));
-            last_index = ctx->m.dct_quantize(&ctx->m, block, 4 & (2*i),
+            last_index = ctx->m.dct_quantize(&ctx->m, block,
+                                             ctx->is_444 ? 4 * (n > 0): 4 & (2*i),
                                              qscale, &overflow);
             ac_bits   += dnxhd_calc_ac_bits(ctx, block, last_index);
 
@@ -747,7 +885,7 @@ static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
             else
                 nbits = av_log2_16bit(2 * diff);
 
-            av_assert1(nbits < ctx->cid_table->bit_depth + 4);
+            av_assert1(nbits < ctx->bit_depth + 4);
             dc_bits += ctx->cid_table->dc_bits[nbits] + nbits;
 
             ctx->m.last_dc[n] = block[0];
@@ -760,7 +898,7 @@ static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
         }
         ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].ssd  = ssd;
         ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].bits = ac_bits + dc_bits + 12 +
-                                      8 * ctx->vlc_bits[0];
+                                     (1 + ctx->is_444) * 8 * ctx->vlc_bits[0];
     }
     return 0;
 }
@@ -776,20 +914,22 @@ static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg,
 
     ctx->m.last_dc[0] =
     ctx->m.last_dc[1] =
-    ctx->m.last_dc[2] = 1 << (ctx->cid_table->bit_depth + 2);
+    ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
     for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
         unsigned mb = mb_y * ctx->m.mb_width + mb_x;
         int qscale = ctx->mb_qscale[mb];
         int i;
 
-        put_bits(&ctx->m.pb, 12, qscale << 1);
+        put_bits(&ctx->m.pb, 11, qscale);
+        put_bits(&ctx->m.pb, 1, avctx->pix_fmt == AV_PIX_FMT_YUV444P10);
 
         dnxhd_get_blocks(ctx, mb_x, mb_y);
 
-        for (i = 0; i < 8; i++) {
+        for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
             int16_t *block = ctx->blocks[i];
             int overflow, n = dnxhd_switch_matrix(ctx, i);
-            int last_index = ctx->m.dct_quantize(&ctx->m, block, 4 & (2*i),
+            int last_index = ctx->m.dct_quantize(&ctx->m, block,
+                                                 ctx->is_444 ? (((i >> 1) % 3) < 1 ? 0 : 4): 4 & (2*i),
                                                  qscale, &overflow);
             // START_TIMER;
             dnxhd_encode_block(ctx, block, last_index, n);
@@ -830,7 +970,7 @@ static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg,
                            ((avctx->height >> ctx->interlaced) & 0xF);
 
     ctx = ctx->thread[threadnr];
-    if (ctx->cid_table->bit_depth == 8) {
+    if (ctx->bit_depth == 8) {
         uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y << 4) * ctx->m.linesize);
         for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x, pix += 16) {
             unsigned mb = mb_y * ctx->m.mb_width + mb_x;
@@ -934,9 +1074,6 @@ static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
             if (bits > ctx->frame_bits)
                 break;
         }
-        // ff_dlog(ctx->m.avctx,
-        //         "lambda %d, up %u, down %u, bits %d, frame %d\n",
-        //         lambda, last_higher, last_lower, bits, ctx->frame_bits);
         if (end) {
             if (bits > ctx->frame_bits)
                 return AVERROR(EINVAL);
@@ -965,7 +1102,6 @@ static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
             down_step = 1<<LAMBDA_FRAC_BITS;
         }
     }
-    //ff_dlog(ctx->m.avctx, "out lambda %d\n", lambda);
     ctx->lambda = lambda;
     return 0;
 }
@@ -994,10 +1130,6 @@ static int dnxhd_find_qscale(DNXHDEncContext *ctx)
             if (bits > ctx->frame_bits)
                 break;
         }
-        // ff_dlog(ctx->m.avctx,
-        //         "%d, qscale %d, bits %d, frame %d, higher %d, lower %d\n",
-        //         ctx->m.avctx->frame_number, qscale, bits, ctx->frame_bits,
-        //         last_higher, last_lower);
         if (bits < ctx->frame_bits) {
             if (qscale == 1)
                 return 1;
@@ -1026,7 +1158,6 @@ static int dnxhd_find_qscale(DNXHDEncContext *ctx)
                 return AVERROR(EINVAL);
         }
     }
-    //ff_dlog(ctx->m.avctx, "out qscale %d\n", qscale);
     ctx->qscale = qscale;
     return 0;
 }
@@ -1223,7 +1354,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
 static av_cold int dnxhd_encode_end(AVCodecContext *avctx)
 {
     DNXHDEncContext *ctx = avctx->priv_data;
-    int max_level        = 1 << (ctx->cid_table->bit_depth + 2);
+    int max_level        = 1 << (ctx->bit_depth + 2);
     int i;
 
     av_free(ctx->vlc_codes - max_level * 2);
@@ -1264,10 +1395,12 @@ AVCodec ff_dnxhd_encoder = {
     .init           = dnxhd_encode_init,
     .encode2        = dnxhd_encode_picture,
     .close          = dnxhd_encode_end,
-    .capabilities   = AV_CODEC_CAP_SLICE_THREADS,
+    .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
     .pix_fmts       = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_YUV422P,
         AV_PIX_FMT_YUV422P10,
+        AV_PIX_FMT_YUV444P10,
+        AV_PIX_FMT_GBRP10,
         AV_PIX_FMT_NONE
     },
     .priv_class     = &dnxhd_class,
diff --git a/mythtv/external/FFmpeg/libavcodec/dnxhdenc.h b/mythtv/external/FFmpeg/libavcodec/dnxhdenc.h
index 91ef6d06022..963821ac81a 100644
--- a/mythtv/external/FFmpeg/libavcodec/dnxhdenc.h
+++ b/mythtv/external/FFmpeg/libavcodec/dnxhdenc.h
@@ -26,6 +26,8 @@
 
 #include <stdint.h>
 
+#include "config.h"
+
 #include "mpegvideo.h"
 #include "dnxhddata.h"
 
@@ -46,6 +48,8 @@ typedef struct DNXHDEncContext {
 
     int cid;
     int profile;
+    int bit_depth;
+    int is_444;
     const CIDEntry *cid_table;
     uint8_t *msip; ///< Macroblock Scan Indexes Payload
     uint32_t *slice_size;
@@ -70,9 +74,9 @@ typedef struct DNXHDEncContext {
     unsigned min_padding;
     int intra_quant_bias;
 
-    DECLARE_ALIGNED(16, int16_t, blocks)[8][64];
-    uint8_t edge_buf_y[256];
-    uint8_t edge_buf_uv[2][128];
+    DECLARE_ALIGNED(32, int16_t, blocks)[12][64];
+    DECLARE_ALIGNED(16, uint8_t, edge_buf_y)[512]; // has to hold 16x16 uint16 when depth=10
+    DECLARE_ALIGNED(16, uint8_t, edge_buf_uv)[2][512]; // has to hold 16x16 uint16_t when depth=10
 
     int      (*qmatrix_c)     [64];
     int      (*qmatrix_l)     [64];
@@ -99,8 +103,8 @@ typedef struct DNXHDEncContext {
     RCCMPEntry *mb_cmp_tmp;
     RCEntry    *mb_rc;
 
-    void (*get_pixels_8x4_sym)(int16_t * /* align 16 */,
-                               const uint8_t *, ptrdiff_t);
+    void (*get_pixels_8x4_sym)(int16_t *av_restrict /* align 16 */ block,
+                               const uint8_t *pixels, ptrdiff_t line_size);
 } DNXHDEncContext;
 
 void ff_dnxhdenc_init_x86(DNXHDEncContext *ctx);
diff --git a/mythtv/external/FFmpeg/libavcodec/dolby_e.c b/mythtv/external/FFmpeg/libavcodec/dolby_e.c
new file mode 100644
index 00000000000..91a00ce8785
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/dolby_e.c
@@ -0,0 +1,718 @@
+/*
+ * Copyright (C) 2017 foo86
+ *
+ * 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/float_dsp.h"
+#include "libavutil/thread.h"
+#include "libavutil/mem.h"
+
+#include "internal.h"
+#include "get_bits.h"
+#include "put_bits.h"
+#include "dolby_e.h"
+#include "fft.h"
+
+static int skip_input(DBEContext *s, int nb_words)
+{
+    if (nb_words > s->input_size) {
+        av_log(s->avctx, AV_LOG_ERROR, "Packet too short\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    s->input      += nb_words * s->word_bytes;
+    s->input_size -= nb_words;
+    return 0;
+}
+
+static int parse_key(DBEContext *s)
+{
+    if (s->key_present) {
+        uint8_t *key = s->input;
+        int      ret = skip_input(s, 1);
+        if (ret < 0)
+            return ret;
+        return AV_RB24(key) >> 24 - s->word_bits;
+    }
+    return 0;
+}
+
+static int convert_input(DBEContext *s, int nb_words, int key)
+{
+    uint8_t *src = s->input;
+    uint8_t *dst = s->buffer;
+    PutBitContext pb;
+    int i;
+
+    av_assert0(nb_words <= 1024u);
+
+    if (nb_words > s->input_size) {
+        av_log(s->avctx, AV_LOG_ERROR, "Packet too short\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    switch (s->word_bits) {
+    case 16:
+        for (i = 0; i < nb_words; i++, src += 2, dst += 2)
+            AV_WB16(dst, AV_RB16(src) ^ key);
+        break;
+    case 20:
+        init_put_bits(&pb, s->buffer, sizeof(s->buffer));
+        for (i = 0; i < nb_words; i++, src += 3)
+            put_bits(&pb, 20, AV_RB24(src) >> 4 ^ key);
+        flush_put_bits(&pb);
+        break;
+    case 24:
+        for (i = 0; i < nb_words; i++, src += 3, dst += 3)
+            AV_WB24(dst, AV_RB24(src) ^ key);
+        break;
+    default:
+        av_assert0(0);
+    }
+
+    return init_get_bits(&s->gb, s->buffer, nb_words * s->word_bits);
+}
+
+static int parse_metadata(DBEContext *s)
+{
+    int i, ret, key, mtd_size;
+
+    if ((key = parse_key(s)) < 0)
+        return key;
+    if ((ret = convert_input(s, 1, key)) < 0)
+        return ret;
+
+    skip_bits(&s->gb, 4);
+    mtd_size = get_bits(&s->gb, 10);
+    if (!mtd_size) {
+        av_log(s->avctx, AV_LOG_ERROR, "Invalid metadata size\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    if ((ret = convert_input(s, mtd_size, key)) < 0)
+        return ret;
+
+    skip_bits(&s->gb, 14);
+    s->prog_conf = get_bits(&s->gb, 6);
+    if (s->prog_conf > MAX_PROG_CONF) {
+        av_log(s->avctx, AV_LOG_ERROR, "Invalid program configuration\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    s->nb_channels = nb_channels_tab[s->prog_conf];
+    s->nb_programs = nb_programs_tab[s->prog_conf];
+
+    s->fr_code      = get_bits(&s->gb, 4);
+    s->fr_code_orig = get_bits(&s->gb, 4);
+    if (!sample_rate_tab[s->fr_code] ||
+        !sample_rate_tab[s->fr_code_orig]) {
+        av_log(s->avctx, AV_LOG_ERROR, "Invalid frame rate code\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    skip_bits_long(&s->gb, 88);
+    for (i = 0; i < s->nb_channels; i++)
+        s->ch_size[i] = get_bits(&s->gb, 10);
+    s->mtd_ext_size = get_bits(&s->gb, 8);
+    s->meter_size   = get_bits(&s->gb, 8);
+
+    skip_bits_long(&s->gb, 10 * s->nb_programs);
+    for (i = 0; i < s->nb_channels; i++) {
+        s->rev_id[i]     = get_bits(&s->gb,  4);
+        skip_bits1(&s->gb);
+        s->begin_gain[i] = get_bits(&s->gb, 10);
+        s->end_gain[i]   = get_bits(&s->gb, 10);
+    }
+
+    if (get_bits_left(&s->gb) < 0) {
+        av_log(s->avctx, AV_LOG_ERROR, "Read past end of metadata\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    return skip_input(s, mtd_size + 1);
+}
+
+static int parse_metadata_ext(DBEContext *s)
+{
+    if (s->mtd_ext_size)
+        return skip_input(s, s->key_present + s->mtd_ext_size + 1);
+    return 0;
+}
+
+static void unbias_exponents(DBEContext *s, DBEChannel *c, DBEGroup *g)
+{
+    int mstr_exp[MAX_MSTR_EXP];
+    int bias_exp[MAX_BIAS_EXP];
+    int i, j, k;
+
+    for (i = 0; i < c->nb_mstr_exp; i++)
+        mstr_exp[i] = get_bits(&s->gb, 2) * 6;
+
+    for (i = 0; i < g->nb_exponent; i++)
+        bias_exp[i] = get_bits(&s->gb, 5);
+
+    for (i = k = 0; i < c->nb_mstr_exp; i++)
+        for (j = 0; j < g->nb_bias_exp[i]; j++, k++)
+            c->exponents[g->exp_ofs + k] = mstr_exp[i] + bias_exp[k];
+}
+
+static int parse_exponents(DBEContext *s, DBEChannel *c)
+{
+    DBEGroup *p, *g;
+    int i;
+
+    for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
+        c->exp_strategy[i] = !i || g->nb_exponent != p->nb_exponent || get_bits1(&s->gb);
+        if (c->exp_strategy[i]) {
+            unbias_exponents(s, c, g);
+        } else {
+            memcpy(c->exponents + g->exp_ofs,
+                   c->exponents + p->exp_ofs,
+                   g->nb_exponent * sizeof(c->exponents[0]));
+        }
+    }
+
+    return 0;
+}
+
+static inline int log_add(int a, int b)
+{
+    int c = FFABS(a - b) >> 1;
+    return FFMAX(a, b) + log_add_tab[FFMIN(c, 211)];
+}
+
+static void calc_lowcomp(int *msk_val)
+{
+    int lwc_val[17] = { 0 };
+    int i, j, k;
+
+    for (i = 0; i < 11; i++) {
+        int max_j = 0;
+        int max_v = INT_MIN;
+        int thr   = 0;
+
+        for (j = FFMAX(i - 3, 0), k = 0; j <= i + 3; j++, k++) {
+            int v = msk_val[j] + lwc_gain_tab[i][k];
+            if (v > max_v) {
+                max_j = j;
+                max_v = v;
+            }
+            thr = log_add(thr, v);
+        }
+
+        if (msk_val[i] < thr) {
+            for (j = FFMAX(max_j - 3, 0),
+                 k = FFMAX(3 - max_j, 0);
+                 j <= max_j + 3; j++, k++)
+                lwc_val[j] += lwc_adj_tab[k];
+        }
+    }
+
+    for (i = 0; i < 16; i++) {
+        int v = FFMAX(lwc_val[i], -512);
+        msk_val[i] = FFMAX(msk_val[i] + v, 0);
+    }
+}
+
+static void bit_allocate(int nb_exponent, int nb_code, int fr_code,
+                         int *exp, int *bap,
+                         int fg_spc, int fg_ofs, int msk_mod, int snr_ofs)
+{
+    int msk_val[MAX_BIAS_EXP];
+    int psd_val[MAX_BIAS_EXP];
+    int fast_leak  = 0;
+    int slow_leak  = 0;
+    int dc_code    = dc_code_tab[fr_code - 1];
+    int ht_code    = ht_code_tab[fr_code - 1];
+    int fast_gain  = fast_gain_tab[fg_ofs];
+    int slow_decay = slow_decay_tab[dc_code][msk_mod];
+    int misc_decay = misc_decay_tab[nb_code][dc_code][msk_mod];
+    const uint16_t *slow_gain      = slow_gain_tab[nb_code][msk_mod];
+    const uint16_t *fast_decay     = fast_decay_tab[nb_code][dc_code][msk_mod];
+    const uint16_t *fast_gain_adj  = fast_gain_adj_tab[nb_code][dc_code];
+    const uint16_t *hearing_thresh = hearing_thresh_tab[nb_code][ht_code];
+    int i;
+
+    for (i = 0; i < nb_exponent; i++)
+        psd_val[i] = (48 - exp[i]) * 64;
+
+    fast_gain_adj += band_ofs_tab[nb_code][fg_spc];
+    for (i = 0; i < nb_exponent; i++) {
+        fast_leak = log_add(fast_leak  - fast_decay[i],
+                            psd_val[i] - fast_gain + fast_gain_adj[i]);
+        slow_leak = log_add(slow_leak  - slow_decay,
+                            psd_val[i] - slow_gain[i]);
+        msk_val[i] = FFMAX(fast_leak, slow_leak);
+    }
+
+    fast_leak = 0;
+    for (i = nb_exponent - 1; i > band_low_tab[nb_code]; i--) {
+        fast_leak = log_add(fast_leak - misc_decay, psd_val[i] - fast_gain);
+        msk_val[i] = FFMAX(msk_val[i], fast_leak);
+    }
+
+    for (i = 0; i < nb_exponent; i++)
+        msk_val[i] = FFMAX(msk_val[i], hearing_thresh[i]);
+
+    if (!nb_code)
+        calc_lowcomp(msk_val);
+
+    for (i = 0; i < nb_exponent; i++) {
+        int v = 16 * (snr_ofs - 64) + psd_val[i] - msk_val[i] >> 5;
+        bap[i] = bap_tab[av_clip_uintp2(v, 6)];
+    }
+}
+
+static int parse_bit_alloc(DBEContext *s, DBEChannel *c)
+{
+    DBEGroup *p, *g;
+    int bap_strategy[MAX_GROUPS], fg_spc[MAX_GROUPS];
+    int fg_ofs[MAX_GROUPS], msk_mod[MAX_GROUPS];
+    int i, snr_ofs;
+
+    for (i = 0; i < c->nb_groups; i++) {
+        bap_strategy[i] = !i || get_bits1(&s->gb);
+        if (bap_strategy[i]) {
+             fg_spc[i] = get_bits(&s->gb, 2);
+             fg_ofs[i] = get_bits(&s->gb, 3);
+            msk_mod[i] = get_bits1(&s->gb);
+        } else {
+             fg_spc[i] =  fg_spc[i - 1];
+             fg_ofs[i] =  fg_ofs[i - 1];
+            msk_mod[i] = msk_mod[i - 1];
+        }
+    }
+
+    if (get_bits1(&s->gb)) {
+        avpriv_report_missing_feature(s->avctx, "Delta bit allocation");
+        return AVERROR_PATCHWELCOME;
+    }
+
+    snr_ofs = get_bits(&s->gb, 8);
+    if (!snr_ofs) {
+        memset(c->bap, 0, sizeof(c->bap));
+        return 0;
+    }
+
+    for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
+        if (c->exp_strategy[i] || bap_strategy[i]) {
+            bit_allocate(g->nb_exponent, g->imdct_idx, s->fr_code,
+                         c->exponents + g->exp_ofs, c->bap + g->exp_ofs,
+                         fg_spc[i], fg_ofs[i], msk_mod[i], snr_ofs);
+        } else {
+            memcpy(c->bap + g->exp_ofs,
+                   c->bap + p->exp_ofs,
+                   g->nb_exponent * sizeof(c->bap[0]));
+        }
+    }
+
+    return 0;
+}
+
+static int parse_indices(DBEContext *s, DBEChannel *c)
+{
+    DBEGroup *p, *g;
+    int i, j;
+
+    for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
+        if (get_bits1(&s->gb)) {
+            int start = get_bits(&s->gb, 6);
+
+            if (start > g->nb_exponent) {
+                av_log(s->avctx, AV_LOG_ERROR, "Invalid start index\n");
+                return AVERROR_INVALIDDATA;
+            }
+
+            for (j = 0; j < start; j++)
+                c->idx[g->exp_ofs + j] = 0;
+
+            for (; j < g->nb_exponent; j++)
+                c->idx[g->exp_ofs + j] = get_bits(&s->gb, 2);
+        } else if (i && g->nb_exponent == p->nb_exponent) {
+            memcpy(c->idx + g->exp_ofs,
+                   c->idx + p->exp_ofs,
+                   g->nb_exponent * sizeof(c->idx[0]));
+        } else {
+            memset(c->idx + g->exp_ofs, 0, g->nb_exponent * sizeof(c->idx[0]));
+        }
+    }
+
+    return 0;
+}
+
+static int parse_mantissas(DBEContext *s, DBEChannel *c)
+{
+    DBEGroup *g;
+    int i, j, k;
+
+    for (i = 0, g = c->groups; i < c->nb_groups; i++, g++) {
+        float *mnt = c->mantissas + g->mnt_ofs;
+
+        for (j = 0; j < g->nb_exponent; j++) {
+            int bap     = c->bap[g->exp_ofs + j];
+            int idx     = c->idx[g->exp_ofs + j];
+            int size1   = mantissa_size1[bap][idx];
+            int count   = g->nb_mantissa[j];
+            float exp   = exponent_tab[c->exponents[g->exp_ofs + j]];
+            float scale = mantissa_tab1[size1][idx] * exp;
+
+            if (!size1) {
+                memset(mnt, 0, count * sizeof(*mnt));
+            } else if (idx) {
+                int values[100];
+                int escape = -(1 << size1 - 1);
+
+                for (k = 0; k < count; k++)
+                    values[k] = get_sbits(&s->gb, size1);
+
+                for (k = 0; k < count; k++) {
+                    if (values[k] != escape) {
+                        mnt[k] = values[k] * scale;
+                    } else {
+                        int size2 = mantissa_size2[bap][idx];
+                        int value = get_sbits(&s->gb, size2);
+                        float a = mantissa_tab2[size2][idx];
+                        float b = mantissa_tab3[size2][idx];
+                        if (value < 0)
+                            mnt[k] = ((value + 1) * a - b) * exp;
+                        else
+                            mnt[k] = (value * a + b) * exp;
+                    }
+                }
+            } else {
+                for (k = 0; k < count; k++)
+                    mnt[k] = get_sbits(&s->gb, size1) * scale;
+            }
+
+            mnt += count;
+        }
+
+        for (; j < g->nb_exponent + c->bw_code; j++) {
+            memset(mnt, 0, g->nb_mantissa[j] * sizeof(*mnt));
+            mnt += g->nb_mantissa[j];
+        }
+    }
+
+    return 0;
+}
+
+static int parse_channel(DBEContext *s, int ch, int seg_id)
+{
+    DBEChannel *c = &s->channels[seg_id][ch];
+    int i, ret;
+
+    if (s->rev_id[ch] > 1) {
+        avpriv_report_missing_feature(s->avctx, "Encoder revision %d", s->rev_id[ch]);
+        return AVERROR_PATCHWELCOME;
+    }
+
+    if (ch == lfe_channel_tab[s->prog_conf]) {
+        c->gr_code = 3;
+        c->bw_code = 29;
+    } else {
+        c->gr_code = get_bits(&s->gb, 2);
+        c->bw_code = get_bits(&s->gb, 3);
+        if (c->gr_code == 3) {
+            av_log(s->avctx, AV_LOG_ERROR, "Invalid group type code\n");
+            return AVERROR_INVALIDDATA;
+        }
+    }
+
+    c->nb_groups   = nb_groups_tab[c->gr_code];
+    c->nb_mstr_exp = nb_mstr_exp_tab[c->gr_code];
+
+    for (i = 0; i < c->nb_groups; i++) {
+        c->groups[i] = frm_ofs_tab[seg_id][c->gr_code][i];
+        if (c->nb_mstr_exp == 2) {
+            c->groups[i].nb_exponent    -= c->bw_code;
+            c->groups[i].nb_bias_exp[1] -= c->bw_code;
+        }
+    }
+
+    if ((ret = parse_exponents(s, c)) < 0)
+        return ret;
+    if ((ret = parse_bit_alloc(s, c)) < 0)
+        return ret;
+    if ((ret = parse_indices(s, c)) < 0)
+        return ret;
+    if ((ret = parse_mantissas(s, c)) < 0)
+        return ret;
+
+    if (get_bits_left(&s->gb) < 0) {
+        av_log(s->avctx, AV_LOG_ERROR, "Read past end of channel %d\n", ch);
+        return AVERROR_INVALIDDATA;
+    }
+
+    return 0;
+}
+
+static int parse_audio(DBEContext *s, int start, int end, int seg_id)
+{
+    int ch, ret, key;
+
+    if ((key = parse_key(s)) < 0)
+        return key;
+
+    for (ch = start; ch < end; ch++) {
+        if (!s->ch_size[ch]) {
+            s->channels[seg_id][ch].nb_groups = 0;
+            continue;
+        }
+        if ((ret = convert_input(s, s->ch_size[ch], key)) < 0)
+            return ret;
+        if ((ret = parse_channel(s, ch, seg_id)) < 0) {
+            if (s->avctx->err_recognition & AV_EF_EXPLODE)
+                return ret;
+            s->channels[seg_id][ch].nb_groups = 0;
+        }
+        if ((ret = skip_input(s, s->ch_size[ch])) < 0)
+            return ret;
+    }
+
+    return skip_input(s, 1);
+}
+
+static int parse_meter(DBEContext *s)
+{
+    if (s->meter_size)
+        return skip_input(s, s->key_present + s->meter_size + 1);
+    return 0;
+}
+
+static void imdct_calc(DBEContext *s, DBEGroup *g, float *result, float *values)
+{
+    FFTContext *imdct = &s->imdct[g->imdct_idx];
+    int n   = 1 << imdct_bits_tab[g->imdct_idx];
+    int n2  = n >> 1;
+    int i;
+
+    switch (g->imdct_phs) {
+    case 0:
+        imdct->imdct_half(imdct, result, values);
+        for (i = 0; i < n2; i++)
+            result[n2 + i] = result[n2 - i - 1];
+        break;
+    case 1:
+        imdct->imdct_calc(imdct, result, values);
+        break;
+    case 2:
+        imdct->imdct_half(imdct, result + n2, values);
+        for (i = 0; i < n2; i++)
+            result[i] = -result[n - i - 1];
+        break;
+    default:
+        av_assert0(0);
+    }
+}
+
+static void transform(DBEContext *s, DBEChannel *c, float *history, float *output)
+{
+    LOCAL_ALIGNED_32(float, buffer, [2048]);
+    LOCAL_ALIGNED_32(float, result, [1152]);
+    DBEGroup *g;
+    int i;
+
+    memset(result, 0, 1152 * sizeof(float));
+    for (i = 0, g = c->groups; i < c->nb_groups; i++, g++) {
+        float *src = buffer + g->src_ofs;
+        float *dst = result + g->dst_ofs;
+        float *win = window + g->win_ofs;
+
+        imdct_calc(s, g, buffer, c->mantissas + g->mnt_ofs);
+        s->fdsp->vector_fmul_add(dst, src, win, dst, g->win_len);
+    }
+
+    for (i = 0; i < 256; i++)
+        output[i] = history[i] + result[i];
+    for (i = 256; i < 896; i++)
+        output[i] = result[i];
+    for (i = 0; i < 256; i++)
+        history[i] = result[896 + i];
+}
+
+static void apply_gain(DBEContext *s, int begin, int end, float *output)
+{
+    if (begin == 960 && end == 960)
+        return;
+
+    if (begin == end) {
+        s->fdsp->vector_fmul_scalar(output, output, gain_tab[end], FRAME_SAMPLES);
+    } else {
+        float a = gain_tab[begin] * (1.0f / (FRAME_SAMPLES - 1));
+        float b = gain_tab[end  ] * (1.0f / (FRAME_SAMPLES - 1));
+        int i;
+
+        for (i = 0; i < FRAME_SAMPLES; i++)
+            output[i] *= a * (FRAME_SAMPLES - i - 1) + b * i;
+    }
+}
+
+static int filter_frame(DBEContext *s, AVFrame *frame)
+{
+    const uint8_t *reorder;
+    int ch, ret;
+
+    if (s->nb_channels == 4)
+        reorder = ch_reorder_4;
+    else if (s->nb_channels == 6)
+        reorder = ch_reorder_6;
+    else if (s->nb_programs == 1 && !(s->avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE))
+        reorder = ch_reorder_8;
+    else
+        reorder = ch_reorder_n;
+
+    frame->nb_samples = FRAME_SAMPLES;
+    if ((ret = ff_get_buffer(s->avctx, frame, 0)) < 0)
+        return ret;
+
+    for (ch = 0; ch < s->nb_channels; ch++) {
+        float *output = (float *)frame->extended_data[reorder[ch]];
+        transform(s, &s->channels[0][ch], s->history[ch], output);
+        transform(s, &s->channels[1][ch], s->history[ch], output + FRAME_SAMPLES / 2);
+        apply_gain(s, s->begin_gain[ch], s->end_gain[ch], output);
+    }
+
+    return 0;
+}
+
+static int dolby_e_decode_frame(AVCodecContext *avctx, void *data,
+                                int *got_frame_ptr, AVPacket *avpkt)
+{
+    DBEContext *s = avctx->priv_data;
+    int i, j, hdr, ret;
+
+    if (avpkt->size < 3)
+        return AVERROR_INVALIDDATA;
+
+    hdr = AV_RB24(avpkt->data);
+    if ((hdr & 0xfffffe) == 0x7888e) {
+        s->word_bits = 24;
+    } else if ((hdr & 0xffffe0) == 0x788e0) {
+        s->word_bits = 20;
+    } else if ((hdr & 0xfffe00) == 0x78e00) {
+        s->word_bits = 16;
+    } else {
+        av_log(avctx, AV_LOG_ERROR, "Invalid frame header\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    s->word_bytes  = s->word_bits + 7 >> 3;
+    s->input       = avpkt->data + s->word_bytes;
+    s->input_size  = avpkt->size / s->word_bytes - 1;
+    s->key_present = hdr >> 24 - s->word_bits & 1;
+
+    if ((ret = parse_metadata(s)) < 0)
+        return ret;
+
+    if (s->nb_programs > 1 && !s->multi_prog_warned) {
+        av_log(avctx, AV_LOG_WARNING, "Stream has %d programs (configuration %d), "
+               "channels will be output in native order.\n", s->nb_programs, s->prog_conf);
+        s->multi_prog_warned = 1;
+    }
+
+    switch (s->nb_channels) {
+    case 4:
+        avctx->channel_layout = AV_CH_LAYOUT_4POINT0;
+        break;
+    case 6:
+        avctx->channel_layout = AV_CH_LAYOUT_5POINT1;
+        break;
+    case 8:
+        avctx->channel_layout = AV_CH_LAYOUT_7POINT1;
+        break;
+    }
+
+    avctx->channels    = s->nb_channels;
+    avctx->sample_rate = sample_rate_tab[s->fr_code];
+    avctx->sample_fmt  = AV_SAMPLE_FMT_FLTP;
+
+    i = s->nb_channels / 2;
+    j = s->nb_channels;
+    if ((ret = parse_audio(s, 0, i, 0)) < 0)
+        return ret;
+    if ((ret = parse_audio(s, i, j, 0)) < 0)
+        return ret;
+    if ((ret = parse_metadata_ext(s)) < 0)
+        return ret;
+    if ((ret = parse_audio(s, 0, i, 1)) < 0)
+        return ret;
+    if ((ret = parse_audio(s, i, j, 1)) < 0)
+        return ret;
+    if ((ret = parse_meter(s)) < 0)
+        return ret;
+    if ((ret = filter_frame(s, data)) < 0)
+        return ret;
+
+    *got_frame_ptr = 1;
+    return avpkt->size;
+}
+
+static av_cold void dolby_e_flush(AVCodecContext *avctx)
+{
+    DBEContext *s = avctx->priv_data;
+
+    memset(s->history, 0, sizeof(s->history));
+}
+
+static av_cold int dolby_e_close(AVCodecContext *avctx)
+{
+    DBEContext *s = avctx->priv_data;
+    int i;
+
+    for (i = 0; i < 3; i++)
+        ff_mdct_end(&s->imdct[i]);
+
+    av_freep(&s->fdsp);
+    return 0;
+}
+
+static av_cold int dolby_e_init(AVCodecContext *avctx)
+{
+    static AVOnce init_once = AV_ONCE_INIT;
+    DBEContext *s = avctx->priv_data;
+    int i;
+
+    if (ff_thread_once(&init_once, init_tables))
+        return AVERROR_UNKNOWN;
+
+    for (i = 0; i < 3; i++)
+        if (ff_mdct_init(&s->imdct[i], imdct_bits_tab[i], 1, 2.0) < 0)
+            return AVERROR(ENOMEM);
+
+    if (!(s->fdsp = avpriv_float_dsp_alloc(0)))
+        return AVERROR(ENOMEM);
+
+    s->multi_prog_warned = !!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE);
+    s->avctx = avctx;
+    return 0;
+}
+
+AVCodec ff_dolby_e_decoder = {
+    .name           = "dolby_e",
+    .long_name      = NULL_IF_CONFIG_SMALL("Dolby E"),
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = AV_CODEC_ID_DOLBY_E,
+    .priv_data_size = sizeof(DBEContext),
+    .init           = dolby_e_init,
+    .decode         = dolby_e_decode_frame,
+    .close          = dolby_e_close,
+    .flush          = dolby_e_flush,
+    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
+    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/dolby_e.h b/mythtv/external/FFmpeg/libavcodec/dolby_e.h
new file mode 100644
index 00000000000..0390233720e
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/dolby_e.h
@@ -0,0 +1,733 @@
+/*
+ * Copyright (C) 2017 foo86
+ *
+ * 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_DOLBY_E_H
+#define AVCODEC_DOLBY_E_H
+
+#include "libavutil/float_dsp.h"
+#include "libavutil/libm.h"
+#include "libavutil/mem.h"
+
+#include "internal.h"
+#include "get_bits.h"
+#include "kbdwin.h"
+#include "fft.h"
+
+#define FRAME_SAMPLES   1792
+
+#define MAX_PROG_CONF   23
+#define MAX_PROGRAMS    8
+#define MAX_CHANNELS    8
+#define MAX_SEGMENTS    2
+
+#define MAX_GROUPS      8
+#define MAX_EXPONENTS   304
+#define MAX_MANTISSAS   1024
+
+#define MAX_MSTR_EXP    2
+#define MAX_BIAS_EXP    50
+
+typedef struct DBEGroup {
+    uint8_t         nb_exponent;
+    uint8_t         nb_bias_exp[MAX_MSTR_EXP];
+    uint16_t        exp_ofs;
+    uint16_t        mnt_ofs;
+    const uint8_t   *nb_mantissa;
+    uint8_t         imdct_idx;
+    uint8_t         imdct_phs;
+    uint16_t        win_len;
+    uint16_t        dst_ofs;
+    uint16_t        win_ofs;
+    uint16_t        src_ofs;
+} DBEGroup;
+
+typedef struct DBEChannel {
+    int     gr_code;
+    int     bw_code;
+
+    int         nb_groups;
+    int         nb_mstr_exp;
+    DBEGroup    groups[MAX_GROUPS];
+
+    int     exp_strategy[MAX_GROUPS];
+    int     exponents[MAX_EXPONENTS];
+    int     bap[MAX_EXPONENTS];
+    int     idx[MAX_EXPONENTS];
+
+    DECLARE_ALIGNED(32, float, mantissas)[MAX_MANTISSAS];
+} DBEChannel;
+
+typedef struct DBEContext {
+    AVCodecContext  *avctx;
+    GetBitContext   gb;
+
+    uint8_t     *input;
+    int         input_size;
+
+    int         word_bits;
+    int         word_bytes;
+    int         key_present;
+
+    int         prog_conf;
+    int         nb_channels;
+    int         nb_programs;
+
+    int         fr_code;
+    int         fr_code_orig;
+
+    int         ch_size[MAX_CHANNELS];
+    int         mtd_ext_size;
+    int         meter_size;
+
+    int         rev_id[MAX_CHANNELS];
+    int         begin_gain[MAX_CHANNELS];
+    int         end_gain[MAX_CHANNELS];
+
+    int         multi_prog_warned;
+
+    DBEChannel  channels[MAX_SEGMENTS][MAX_CHANNELS];
+
+    DECLARE_ALIGNED(32, float, history)[MAX_CHANNELS][256];
+
+    FFTContext          imdct[3];
+    AVFloatDSPContext   *fdsp;
+
+    uint8_t     buffer[1024 * 3 + AV_INPUT_BUFFER_PADDING_SIZE];
+} DBEContext;
+
+static const uint8_t nb_programs_tab[MAX_PROG_CONF + 1] = {
+    2, 3, 2, 3, 4, 5, 4, 5, 6, 7, 8, 1, 2, 3, 3, 4, 5, 6, 1, 2, 3, 4, 1, 1
+};
+
+static const uint8_t nb_channels_tab[MAX_PROG_CONF + 1] = {
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 6, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4, 8, 8
+};
+
+static const int8_t lfe_channel_tab[MAX_PROG_CONF + 1] = {
+     5,  5, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  5, 5
+};
+
+static const uint8_t ch_reorder_4[4] = { 0, 2, 1, 3 };
+static const uint8_t ch_reorder_6[6] = { 0, 2, 4, 1, 3, 5 };
+static const uint8_t ch_reorder_8[8] = { 0, 2, 6, 4, 1, 3, 7, 5 };
+static const uint8_t ch_reorder_n[8] = { 0, 2, 4, 6, 1, 3, 5, 7 };
+
+static const uint16_t sample_rate_tab[16] = {
+    0, 42965, 43008, 44800, 53706, 53760
+};
+
+static const uint8_t nb_groups_tab[4] = { 1, 8, 7, 1 };
+
+static const uint8_t nb_mstr_exp_tab[4] = { 2, 2, 2, 1 };
+
+static const uint8_t nb_mantissa_38[38] = {
+     1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+     2,  2,  2,  2,  2,  2,  3,  3,  3,  4,  4,  4,  5,  5,  6,  6,
+     7,  8,  9, 10, 11, 12,
+};
+
+static const uint8_t nb_mantissa_44[44] = {
+     1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  2,
+     2,  2,  2,  2,  2,  3,  3,  3,  3,  4,  4,  5,  5,  6,  7,  7,
+     8,  9, 10, 11, 12, 13, 15, 16, 18, 20, 22, 25,
+};
+
+static const uint8_t nb_mantissa_50[50] = {
+     1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  3,  3,  3,
+     3,  4,  4,  5,  5,  6,  6,  7,  8,  9,  9, 10, 12, 13, 14, 16,
+    18, 19, 22, 24, 27, 29, 32, 36, 40, 44, 49, 54, 60, 66, 74, 82,
+    90, 100,
+};
+
+static const uint8_t imdct_bits_tab[3] = { 8, 9, 11 };
+
+static const DBEGroup grp_tab_0[1] = {
+    { 50, { 27, 23 }, 0, 0, nb_mantissa_50, 2, 0, 1152, 0, 1408, 0 },
+};
+
+static const DBEGroup grp_tab_1[8] = {
+    { 38, { 12, 26 }, 0, 0, nb_mantissa_38, 0, 0, 192, 0, 256, 0 },
+    { 38, { 12, 26 }, 38, 128, nb_mantissa_38, 0, 1, 256, 64, 448, 0 },
+    { 38, { 12, 26 }, 76, 256, nb_mantissa_38, 0, 1, 256, 192, 704, 0 },
+    { 38, { 12, 26 }, 114, 384, nb_mantissa_38, 0, 1, 256, 320, 0, 0 },
+    { 38, { 12, 26 }, 152, 512, nb_mantissa_38, 0, 1, 256, 448, 0, 0 },
+    { 38, { 12, 26 }, 190, 640, nb_mantissa_38, 0, 1, 256, 576, 0, 0 },
+    { 38, { 12, 26 }, 228, 768, nb_mantissa_38, 0, 1, 256, 704, 0, 0 },
+    { 38, { 12, 26 }, 266, 896, nb_mantissa_38, 0, 1, 256, 832, 0, 0 },
+};
+
+static const DBEGroup grp_tab_2[7] = {
+    { 38, { 12, 26 }, 0, 0, nb_mantissa_38, 0, 0, 192, 0, 256, 0 },
+    { 38, { 12, 26 }, 38, 128, nb_mantissa_38, 0, 1, 256, 64, 448, 0 },
+    { 38, { 12, 26 }, 76, 256, nb_mantissa_38, 0, 1, 256, 192, 704, 0 },
+    { 38, { 12, 26 }, 114, 384, nb_mantissa_38, 0, 1, 256, 320, 0, 0 },
+    { 38, { 12, 26 }, 152, 512, nb_mantissa_38, 0, 1, 256, 448, 0, 0 },
+    { 38, { 12, 26 }, 190, 640, nb_mantissa_38, 0, 1, 256, 576, 0, 0 },
+    { 44, { 19, 25 }, 228, 768, nb_mantissa_44, 1, 1, 448, 704, 960, 64 },
+};
+
+static const DBEGroup grp_tab_3[1] = {
+    { 21, { 21 }, 0, 0, nb_mantissa_50, 2, 0, 1152, 0, 1408, 0 },
+};
+
+static const DBEGroup grp_tab_4[1] = {
+    { 50, { 27, 23 }, 0, 0, nb_mantissa_50, 2, 2, 1152, 0, 1408, 896 },
+};
+
+static const DBEGroup grp_tab_5[8] = {
+    { 38, { 12, 26 }, 0, 0, nb_mantissa_38, 0, 1, 256, 64, 0, 0 },
+    { 38, { 12, 26 }, 38, 128, nb_mantissa_38, 0, 1, 256, 192, 0, 0 },
+    { 38, { 12, 26 }, 76, 256, nb_mantissa_38, 0, 1, 256, 320, 0, 0 },
+    { 38, { 12, 26 }, 114, 384, nb_mantissa_38, 0, 1, 256, 448, 0, 0 },
+    { 38, { 12, 26 }, 152, 512, nb_mantissa_38, 0, 1, 256, 576, 0, 0 },
+    { 38, { 12, 26 }, 190, 640, nb_mantissa_38, 0, 1, 256, 704, 3008, 0 },
+    { 38, { 12, 26 }, 228, 768, nb_mantissa_38, 0, 1, 256, 832, 2752, 0 },
+    { 38, { 12, 26 }, 266, 896, nb_mantissa_38, 0, 2, 192, 960, 2560, 64 },
+};
+
+static const DBEGroup grp_tab_6[7] = {
+    { 44, { 19, 25 }, 0, 0, nb_mantissa_44, 1, 1, 448, 0, 3264, 0 },
+    { 38, { 12, 26 }, 44, 256, nb_mantissa_38, 0, 1, 256, 320, 0, 0 },
+    { 38, { 12, 26 }, 82, 384, nb_mantissa_38, 0, 1, 256, 448, 0, 0 },
+    { 38, { 12, 26 }, 120, 512, nb_mantissa_38, 0, 1, 256, 576, 0, 0 },
+    { 38, { 12, 26 }, 158, 640, nb_mantissa_38, 0, 1, 256, 704, 3008, 0 },
+    { 38, { 12, 26 }, 196, 768, nb_mantissa_38, 0, 1, 256, 832, 2752, 0 },
+    { 38, { 12, 26 }, 234, 896, nb_mantissa_38, 0, 2, 192, 960, 2560, 64 },
+};
+
+static const DBEGroup grp_tab_7[1] = {
+    { 21, { 21 }, 0, 0, nb_mantissa_50, 2, 2, 1152, 0, 1408, 896 },
+};
+
+static const DBEGroup *const frm_ofs_tab[2][4] = {
+    { grp_tab_0, grp_tab_1, grp_tab_2, grp_tab_3 },
+    { grp_tab_4, grp_tab_5, grp_tab_6, grp_tab_7 }
+};
+
+static const uint8_t mantissa_size1[16][4] = {
+    {  0,  0,  0,  0 }, {  2,  1,  1,  1 }, {  3,  2,  1,  1 }, {  4,  3,  2,  1 },
+    {  5,  4,  3,  2 }, {  6,  5,  4,  3 }, {  7,  6,  5,  4 }, {  8,  7,  6,  5 },
+    {  9,  8,  7,  6 }, { 10,  9,  8,  7 }, { 11, 10,  9,  8 }, { 12, 11, 10,  9 },
+    { 13, 12, 11, 10 }, { 14, 13, 12, 11 }, { 15, 14, 13, 12 }, { 16, 15, 14, 13 },
+};
+
+static const uint8_t mantissa_size2[16][4] = {
+    {  0,  0,  0,  0 }, {  2,  1,  2,  2 }, {  3,  2,  3,  3 }, {  4,  3,  4,  4 },
+    {  5,  4,  5,  5 }, {  6,  5,  6,  6 }, {  7,  6,  7,  7 }, {  8,  7,  8,  8 },
+    {  9,  8,  9,  9 }, { 10,  9, 10, 10 }, { 11, 10, 11, 11 }, { 12, 11, 12, 12 },
+    { 13, 12, 13, 13 }, { 14, 13, 14, 14 }, { 15, 14, 15, 15 }, { 16, 15, 16, 16 },
+};
+
+static const float start_window[192] = {
+    0.00161569379826, 0.00185748233347, 0.00198562758548, 0.00207834078104,
+    0.00215717748523, 0.00223067096393, 0.00230299213147, 0.00237651215396,
+    0.00245275561606, 0.00253281402069, 0.00261754673613, 0.00270768786168,
+    0.00280390761895, 0.00290684998656, 0.00301715751161, 0.00313548872798,
+    0.00326253122934, 0.00339901215995, 0.00354570716636, 0.00370344845023,
+    0.00387313232586, 0.00405572653911, 0.00425227750970, 0.00446391759265,
+    0.00469187240551, 0.00493746822816, 0.00520213944619, 0.00548743597507,
+    0.00579503056737, 0.00612672586953, 0.00648446105606, 0.00687031782873,
+    0.00728652552677, 0.00773546505205, 0.00821967127415, 0.00874183354619,
+    0.00930479393832, 0.00991154278653, 0.01056521116692, 0.01126905994567,
+    0.01202646513050, 0.01284089936559, 0.01371590957417, 0.01465509096066,
+    0.01566205783408, 0.01674041199523, 0.01789370972358, 0.01912542867865,
+    0.02043893626265, 0.02183746113793, 0.02332406961796, 0.02490164852364,
+    0.02657289580178, 0.02834031974193, 0.03020624702903, 0.03217283918354,
+    0.03424211623810, 0.03641598586180, 0.03869627565015, 0.04108476601498,
+    0.04358322107390, 0.04619341515939, 0.04891715301882, 0.05175628239149,
+
+    0.05471237327267, 0.05778734733755, 0.06098291402413, 0.06430101352084,
+    0.06774345212186, 0.07131188644726, 0.07500780649199, 0.07883251748595,
+    0.08278712056651, 0.08687249228061, 0.09108926295730, 0.09543779401074,
+    0.09991815425851, 0.10453009536427, 0.10927302653894, 0.11414598865987,
+    0.11914762799220, 0.12427616972097, 0.12952939152560, 0.13490459744934,
+    0.14039859233595, 0.14600765712201, 0.15172752528722, 0.15755336077528,
+    0.16347973770491, 0.16950062219342, 0.17560935661442, 0.18179864660619,
+    0.18806055113821, 0.19438647593012, 0.20076717050010, 0.20719272909882,
+    0.21365259576030, 0.22013557367283, 0.22662983904194, 0.23312295958328,
+    0.23960191774666, 0.24605313873388, 0.25246252333253, 0.25881548554631,
+    0.26509699495987, 0.27129162373316, 0.27738359807707, 0.28335685401987,
+    0.28919509723179, 0.29488186663467, 0.30040060148455, 0.30573471157819,
+    0.31086765019993, 0.31578298939317, 0.32046449711227, 0.32489621578468,
+    0.32906254179156, 0.33294830535654, 0.33653885031840, 0.33982011325336,
+    0.34277870140679, 0.34540196889300, 0.34767809062480, 0.34959613344194,
+    0.35114612391958, 0.35231911235422, 0.35310723244504, 0.35350375621308,
+
+    0.35350314372945, 0.35310108725579, 0.35229454943591, 0.35108179521634,
+    0.34946241721522, 0.34743735430290, 0.34500890320420, 0.34218072298001,
+    0.33895783229541, 0.33534659943168, 0.33135472505060, 0.32699121776996,
+    0.32226636266000, 0.31719168282019, 0.31177989424432, 0.30604485422875,
+    0.30000150362379, 0.29366580327088, 0.28705466500775, 0.28018587766131,
+    0.27307802848095, 0.26575042049535, 0.25822298630189, 0.25051619882000,
+    0.24265097955783, 0.23464860495522, 0.22653061137548, 0.21831869932335,
+    0.21003463746705, 0.20170016703857, 0.19333690717811, 0.18496626177620,
+    0.17660932835062, 0.16828680947474, 0.16001892724986, 0.15182534128597,
+    0.14372507062477, 0.13573642000364, 0.12787691082233, 0.12016321713317,
+    0.11261110693234, 0.10523538898282, 0.09804986534955, 0.09106728977263,
+    0.08429933194438, 0.07775654768810, 0.07144835495683, 0.06538301547324,
+    0.05956762170687, 0.05400808871425, 0.04870915012107, 0.04367435714993,
+    0.03890607899172, 0.03440550179663, 0.03017262174627, 0.02620622428513,
+    0.02250383492507, 0.01906161305732, 0.01587412848221, 0.01293388032354,
+    0.01023019677288, 0.00774641320626, 0.00545109736891, 0.00325868651263,
+};
+
+static const float short_window2[192] = {
+    0.00018861094606, 0.00033433010202, 0.00050309624485, 0.00070306161748,
+    0.00093995174533, 0.00121913067128, 0.00154606505568, 0.00192647806126,
+    0.00236641248692, 0.00287225985240, 0.00345077377440, 0.00410907465023,
+    0.00485464855241, 0.00569534163219, 0.00663935063508, 0.00769520981249,
+    0.00887177436246, 0.01017820046395, 0.01162392194150, 0.01321862359335,
+    0.01497221122468, 0.01689477844427, 0.01899657030441, 0.02128794388846,
+    0.02377932597692, 0.02648116795039, 0.02940389811590, 0.03255787167130,
+    0.03595331854986, 0.03960028941437, 0.04350860009563, 0.04768777479454,
+    0.05214698838949, 0.05689500821121, 0.06194013566525, 0.06729014809766,
+    0.07295224131210, 0.07893297315602, 0.08523820859989, 0.09187306673620,
+    0.09884187012422, 0.10614809690222, 0.11379433608064, 0.12178224641797,
+    0.13011251926531, 0.13878484574660, 0.14779788861830, 0.15714925912610,
+    0.16683549914631, 0.17685206886673, 0.18719334022589, 0.19785259629099,
+    0.20882203671372, 0.22009278936030, 0.23165492816694, 0.24349749722585,
+    0.25560854105961, 0.26797514099368, 0.28058345748882, 0.29341877824732,
+    0.30646557185942, 0.31970754671026, 0.33312771482295, 0.34670846027024,
+
+    0.36043161174692, 0.37427851885723, 0.38823013163645, 0.40226708279486,
+    0.41636977214436, 0.43051845264462, 0.44469331748632, 0.45887458761470,
+    0.47304259908636, 0.48717788964798, 0.50126128392546, 0.51527397661778,
+    0.52919761310050, 0.54301436685998, 0.55670701320069, 0.57025899869448,
+    0.58365450587230, 0.59687851269542, 0.60991684638414, 0.62275623122793,
+    0.63538433005035, 0.64778977905593, 0.65996221584264, 0.67189230042379,
+    0.68357172916486, 0.69499324160511, 0.70615062019861, 0.71703868307548,
+    0.72765326998919, 0.73799122168099, 0.74805035295521, 0.75782941981995,
+    0.76732808110520, 0.77654685502339, 0.78548707118622, 0.79415081863423,
+    0.80254089047207, 0.81066072573188, 0.81851434910893, 0.82610630922734,
+    0.83344161609862, 0.84052567843230, 0.84736424144524, 0.85396332579459,
+    0.86032916822973, 0.86646816451999, 0.87238681516918, 0.87809167437532,
+    0.88358930263537, 0.88888622333073, 0.89398888356256, 0.89890361943564,
+    0.90363662591861, 0.90819393133744, 0.91258137648979, 0.91680459830070,
+    0.92086901787718, 0.92477983276087, 0.92854201312583, 0.93216030163834,
+    0.93563921662343, 0.93898305819384, 0.94219591693690, 0.94528168477979,
+
+    0.94823843319821, 0.95106834367330, 0.95377776558539, 0.95636718335775,
+    0.95883679961479, 0.96118650212341, 0.96341583179195, 0.96552395212906,
+    0.96750962060547, 0.96937116231768, 0.97110644638309, 0.97271286544154,
+    0.97418731862798, 0.97552619834964, 0.97672538116257, 0.97778022299974,
+    0.97868555895586, 0.97943570778357, 0.98002448120255, 0.98044519806866,
+    0.98069070339493, 0.98075339216123, 0.98062523779637, 0.98029782516478,
+    0.97976238784222, 0.97900984942031, 0.97803086854002, 0.97681588731895,
+    0.97535518280755, 0.97363892108474, 0.97165721358452, 0.96940017523145,
+    0.96685798395452, 0.96402094114589, 0.96087953263194, 0.95742448973047,
+    0.95364684997699, 0.94953801711660, 0.94508981997396, 0.94029456983253,
+    0.93514511597504, 0.92963489905951, 0.92375800202883, 0.91750919827624,
+    0.91088399681406, 0.90387868421832, 0.89649036314692, 0.88871698725397,
+    0.88055739234735, 0.87201132366062, 0.86307945913336, 0.85376342861693,
+    0.84406582894455, 0.83399023482637, 0.82354120554757, 0.81272428745995,
+    0.80154601230457, 0.79001389138101, 0.77813640562199, 0.76592299164227,
+    0.75338402384395, 0.74053079267526, 0.72737547915460, 0.71393112578527,
+};
+
+static const float short_window3[64] = {
+    0.00326887936450, 0.00550242900936, 0.00786846643791, 0.01045683453520,
+    0.01330402120132, 0.01643221072863, 0.01985798040609, 0.02359509464766,
+    0.02765559221954, 0.03205025893128, 0.03678884369614, 0.04188015679495,
+    0.04733210987781, 0.05315172583924, 0.05934513287609, 0.06591755045290,
+    0.07287327156378, 0.08021564389822, 0.08794705152307, 0.09606889811179,
+    0.10458159240070, 0.11348453632940, 0.12277611617809, 0.13245369691511,
+    0.14251361989876, 0.15295120402567, 0.16376075037904, 0.17493555039885,
+    0.18646789757072, 0.19834910260891, 0.21056951208995, 0.22311853047787,
+    0.23598464546683, 0.24915545655419, 0.26261770674500, 0.27635731727778,
+    0.29035942525136, 0.30460842402318, 0.31908800624032, 0.33378120935681,
+    0.34867046348260, 0.36373764140285, 0.37896411059909, 0.39433078709788,
+    0.40981819096657, 0.42540650327031, 0.44107562429959, 0.45680523287270,
+    0.47257484651351, 0.48836388230077, 0.50415171818214, 0.51991775454258,
+    0.53564147581496, 0.55130251191887, 0.56688069931047, 0.58235614142007,
+    0.59770926827271, 0.61292089506118, 0.62797227945823, 0.64284517745255,
+    0.65752189749349, 0.67198535273209, 0.68621911114984, 0.70020744337099,
+};
+
+static const uint8_t dc_code_tab[5] = { 0, 0, 0, 1, 1 };
+
+static const uint8_t ht_code_tab[5] = { 0, 0, 1, 2, 2 };
+
+static const uint8_t band_ofs_tab[3][4] = {
+    { 12, 8, 4, 0 }, { 14, 10, 6, 0 }, { 12, 8, 4, 0 }
+};
+
+static const uint8_t band_low_tab[3] = { 9, 17, 24 };
+
+static const uint16_t fast_gain_tab[8] = {
+    128, 256, 384, 512, 640, 768, 896, 1024
+};
+
+static const uint16_t slow_decay_tab[2][2] = { { 27, -1 }, { 32, 21 } };
+
+static const uint16_t misc_decay_tab[3][2][2] = {
+    { { 354, -1 }, { 425, 425 } },
+    { { 266, -1 }, { 320,  -1 } },
+    { { 213, -1 }, { 256,  -1 } }
+};
+
+static const uint16_t fast_decay_tab[3][2][2][50] = {
+    {{{
+        142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
+        142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
+        142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
+        142, 142, 142, 142, 142, 142, 142, 142,
+    }, {
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+    }}, {{
+        170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
+        170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
+        170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
+        170, 170, 170, 170, 170, 170, 170, 170,
+    }, {
+         64,  64,  64,  64,  64,  64,  64,  64,  64,  64,
+         64,  64,  64,  64,  64,  64,  64,  64,  64,  64,
+         64,  64,  64,  64,  64,  64,  64,  64,  64,  64,
+         64,  64,  64,  64,  64,  64,  64,  64,
+    }}}, {{{
+        266, 266, 106, 106, 106, 106, 106, 106, 106, 106,
+        106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
+        106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
+        106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
+        106, 106, 106, 106,
+    }, {
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,
+    }}, {{
+        319, 319, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128,
+    }, {
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,
+    }}}, {{{
+        106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
+        106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
+        106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
+        106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
+        106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
+    }, {
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+    }}, {{
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+        128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+    }, {
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+         -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+    }}}
+};
+
+static const uint16_t fast_gain_adj_tab[3][2][62] = {
+    {{
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   1,   2,   4,   7,  11,  16,  29,  44,  59,
+         76,  94, 116, 142, 179, 221, 252, 285, 312, 334,
+    }, {
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          2,   5,   8,  10,  15,  28,  42,  57,  75,  93,
+        115, 140, 177, 219, 247, 280, 308, 330, 427, 533,
+    }}, {{
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   2,   5,   8,  12,  21,  35,  51,  69,  89,
+        111, 138, 176, 220, 251, 284, 312, 334,
+    }, {
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   2,
+          5,   8,  11,  18,  33,  49,  65,  84, 106, 132,
+        168, 214, 245, 279, 308, 329, 427, 533,
+    }}, {{
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   1,   4,   7,  10,  17,
+         31,  47,  65,  84, 107, 134, 171, 215, 250, 283,
+        312, 334,
+    }, {
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   3,   6,   9,  13,  27,  43,
+         60,  79, 100, 126, 160, 207, 242, 276, 307, 329,
+        427, 533,
+    }}
+};
+
+static const uint16_t slow_gain_tab[3][2][50] = {
+    {{
+        3072, 3072, 3072, 3072, 3072, 3072, 1063, 1063, 1063, 1063,
+        1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063,
+        1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063,
+        1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063,
+    }, {
+        3072, 3072, 3072, 3072, 3072, 3072,  850,  850,  850,  850,
+         850,  850,  850,  850,  850,  850,  850,  850,  850,  850,
+         850,  850,  850,  850,  850,  850,  850,  850,  850,  850,
+         850,  850,  850,  850,  850,  850,  850,  850,
+    }}, {{
+        3072, 1212, 1212, 1212,  999,  999,  999,  999,  999,  999,
+         999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
+         999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
+         999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
+         999,  999,  999,  999,
+    }, {
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,
+    }}, {{
+        3072, 3072, 3072, 3072, 3072, 3072, 3072, 3072, 3072, 3072,
+         999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
+         999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
+         999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
+         999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
+    }, {
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+    }}
+};
+
+static const uint16_t hearing_thresh_tab[3][3][50] = {
+    {{
+        1403, 1141, 1000,  959,  948,  957,  946,  925,  899,  871,
+         843,  815,  789,  766,  745,  727,  705,  687,  681,  686,
+         701,  725,  768,  854,  940, 1018, 1075, 1103, 1111, 1106,
+        1098, 1105, 1142, 1237, 1419, 1721, 2169, 2805,
+    }, {
+        1401, 1130,  995,  957,  947,  955,  941,  918,  890,  861,
+         831,  803,  777,  754,  734,  717,  698,  684,  682,  692,
+         712,  743,  798,  894,  976, 1045, 1091, 1109, 1110, 1102,
+        1098, 1116, 1174, 1300, 1526, 1884, 2401, 3072,
+    }, {
+        1393, 1086,  974,  949,  957,  941,  913,  878,  843,  808,
+         777,  750,  727,  708,  695,  686,  681,  689,  714,  752,
+         811,  888,  971, 1044, 1087, 1108, 1110, 1102, 1098, 1115,
+        1172, 1290, 1489, 1812, 2293, 2964, 3072, 3072,
+    }}, {{
+        1412, 1343, 1141, 1047, 1000,  974,  959,  951,  948,  947,
+         957,  953,  946,  936,  925,  906,  878,  850,  822,  795,
+         771,  745,  719,  700,  687,  681,  685,  701,  733,  784,
+         885,  977, 1047, 1092, 1110, 1108, 1099, 1102, 1138, 1233,
+        1413, 1711, 2157, 2797,
+    }, {
+        1412, 1336, 1130, 1040,  995,  970,  957,  950,  947,  947,
+         955,  950,  941,  930,  918,  897,  868,  838,  810,  783,
+         759,  734,  710,  693,  684,  681,  690,  712,  752,  823,
+         924, 1009, 1069, 1102, 1111, 1104, 1098, 1111, 1168, 1295,
+        1518, 1873, 2388, 3072,
+    }, {
+        1411, 1293, 1086, 1009,  974,  957,  949,  947,  957,  951,
+         941,  928,  913,  896,  878,  852,  817,  785,  756,  732,
+         713,  695,  683,  682,  689,  710,  746,  811,  906,  992,
+        1061, 1099, 1111, 1106, 1098, 1107, 1155, 1266, 1471, 1799,
+        2277, 2945, 3072, 3072,
+    }}, {{
+        1431, 1412, 1403, 1379, 1343, 1293, 1229, 1180, 1125, 1075,
+        1040, 1014,  996,  979,  965,  957,  951,  948,  947,  957,
+         951,  940,  924,  903,  877,  846,  815,  785,  753,  725,
+         702,  686,  681,  689,  714,  760,  847,  947, 1028, 1083,
+        1108, 1109, 1101, 1100, 1132, 1222, 1402, 1705, 2160, 2803,
+    }, {
+        1431, 1412, 1401, 1375, 1336, 1278, 1215, 1168, 1115, 1066,
+        1032, 1008,  991,  975,  962,  954,  950,  947,  947,  955,
+         948,  935,  916,  894,  866,  835,  803,  772,  742,  715,
+         695,  683,  683,  697,  729,  784,  887,  982, 1054, 1096,
+        1111, 1106, 1098, 1107, 1159, 1281, 1505, 1865, 2391, 3072,
+    }, {
+        1427, 1411, 1393, 1353, 1293, 1215, 1160, 1118, 1072, 1031,
+        1003,  984,  971,  960,  952,  948,  947,  957,  952,  941,
+         924,  902,  876,  847,  815,  781,  750,  723,  700,  685,
+         681,  691,  719,  766,  858,  958, 1039, 1089, 1109, 1108,
+        1099, 1102, 1141, 1245, 1442, 1766, 2250, 2930, 3072, 3072,
+    }}
+};
+
+static const int16_t lwc_gain_tab[11][7] = {
+    {   -21,  -197,  -271,  -466, 32767, 32767, 32767 },
+    {  -197,   -29,  -244,  -271,  -540, 32767, 32767 },
+    {  -271,  -244,   -29,  -249,  -271,  -593, 32767 },
+    {  -466,  -271,  -249,   -29,  -251,  -271,  -632 },
+    {  -540,  -271,  -251,   -29,  -251,  -271,  -664 },
+    {  -593,  -271,  -251,   -29,  -252,  -271,  -690 },
+    {  -632,  -271,  -252,   -29,  -252,  -271,  -711 },
+    {  -664,  -271,  -252,   -29,  -252,  -271,  -730 },
+    {  -690,  -271,  -252,   -29,  -252,  -271,  -745 },
+    {  -711,  -271,  -252,   -29,  -253,  -271,  -759 },
+    {  -730,  -271,  -253,   -29,  -253,  -271,  -771 },
+};
+
+static const int16_t lwc_adj_tab[7] = {
+    -192, -320, -448, -512, -448, -320, -192,
+};
+
+static const uint8_t log_add_tab[212] = {
+    64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 52, 51, 50,
+    49, 48, 47, 47, 46, 45, 44, 44, 43, 42, 41, 41, 40, 39, 38, 38,
+    37, 36, 36, 35, 35, 34, 33, 33, 32, 32, 31, 30, 30, 29, 29, 28,
+    28, 27, 27, 26, 26, 25, 25, 24, 24, 23, 23, 22, 22, 21, 21, 21,
+    20, 20, 19, 19, 19, 18, 18, 18, 17, 17, 17, 16, 16, 16, 15, 15,
+    15, 14, 14, 14, 13, 13, 13, 13, 12, 12, 12, 12, 11, 11, 11, 11,
+    10, 10, 10, 10, 10,  9,  9,  9,  9,  9,  8,  8,  8,  8,  8,  8,
+     7,  7,  7,  7,  7,  7,  6,  6,  6,  6,  6,  6,  6,  6,  5,  5,
+     5,  5,  5,  5,  5,  5,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+     4,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  2,
+     2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+     2,  2,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  0,  0,
+};
+
+static const uint8_t bap_tab[64] = {
+     0,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  3,  3,  3,  3,  4,
+     4,  4,  4,  5,  5,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,
+     8,  8,  8,  9,  9,  9,  9, 10, 10, 10, 10, 11, 11, 11, 11, 12,
+    12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 15,
+};
+
+static float mantissa_tab1[17][4];
+static float mantissa_tab2[17][4];
+static float mantissa_tab3[17][4];
+static float exponent_tab[50];
+static float gain_tab[1024];
+
+DECLARE_ALIGNED(32, static float, window)[3712];
+
+static av_cold void init_tables(void)
+{
+    int i, j;
+
+    for (i = 1; i < 17; i++)
+        mantissa_tab1[i][0] = 1.0f / (1 << i - 1);
+
+    for (i = 2; i < 16; i++) {
+        mantissa_tab1[i][1] = 1.0f  / ((1 << i) - 1);
+        mantissa_tab1[i][2] = 0.5f  / ((1 << i) - 1);
+        mantissa_tab1[i][3] = 0.25f / ((1 << i) - 1);
+    }
+
+    mantissa_tab1[i][1] = 0.5f   / (1 << 15);
+    mantissa_tab1[i][2] = 0.75f  / (1 << 15);
+    mantissa_tab1[i][3] = 0.875f / (1 << 15);
+
+    for (i = 1; i < 17; i++) {
+        mantissa_tab2[i][1] = mantissa_tab1[i][0] * 0.5f;
+        mantissa_tab2[i][2] = mantissa_tab1[i][0] * 0.75f;
+        mantissa_tab2[i][3] = mantissa_tab1[i][0] * 0.875f;
+        for (j = 1; j < 4; j++)
+            mantissa_tab3[i][j] = 1.0f / (1 << i) + 1.0f / (1 << j) - 1.0f / (1 << i + j);
+    }
+
+    mantissa_tab3[1][3] = 0.6875f;
+
+    for (i = 0; i < 25; i++) {
+        exponent_tab[i * 2    ] = 1.0f      / (1 << i);
+        exponent_tab[i * 2 + 1] = M_SQRT1_2 / (1 << i);
+    }
+
+    for (i = 1; i < 1024; i++)
+        gain_tab[i] = exp2f((i - 960) / 64.0f);
+
+    // short 1
+    ff_kbd_window_init(window, 3.0f, 128);
+    for (i = 0; i < 128; i++)
+        window[128 + i] = window[127 - i];
+
+    // start
+    for (i = 0; i < 192; i++)
+        window[256 + i] = start_window[i];
+
+    // short 2
+    for (i = 0; i < 192; i++)
+        window[448 + i] = short_window2[i];
+    for (i = 0; i < 64; i++)
+        window[640 + i] = window[63 - i];
+
+    // short 3
+    for (i = 0; i < 64; i++)
+        window[704 + i] = short_window3[i];
+    for (i = 0; i < 192; i++)
+        window[768 + i] = window[64 + i];
+
+    // bridge
+    for (i = 0; i < 128; i++)
+        window[960 + i] = window[i];
+    for (i = 0; i < 64; i++)
+        window[1088 + i] = 1.0f;
+
+    // long
+    ff_kbd_window_init(window + 1408, 3.0f, 256);
+    for (i = 0; i < 640; i++)
+        window[1664 + i] = 1.0f;
+    for (i = 0; i < 256; i++)
+        window[2304 + i] = window[1152 + i] = window[1663 - i];
+
+    // reverse start
+    for (i = 0; i < 192; i++)
+        window[2560 + i] = window[447 - i];
+
+    // reverse short 2
+    for (i = 0; i < 256; i++)
+        window[2752 + i] = window[703 - i];
+
+    // reverse short 3
+    for (i = 0; i < 256; i++)
+        window[3008 + i] = window[959 - i];
+
+    // reverse bridge
+    for (i = 0; i < 448; i++)
+        window[3264 + i] = window[1407 - i];
+}
+
+#endif
diff --git a/mythtv/external/FFmpeg/libavcodec/dpcm.c b/mythtv/external/FFmpeg/libavcodec/dpcm.c
index 2edd4d5b0a4..7d3934ee35f 100644
--- a/mythtv/external/FFmpeg/libavcodec/dpcm.c
+++ b/mythtv/external/FFmpeg/libavcodec/dpcm.c
@@ -44,7 +44,7 @@
 #include "mathops.h"
 
 typedef struct DPCMContext {
-    int16_t square_array[256];
+    int16_t array[256];
     int sample[2];                  ///< previous sample (for SOL_DPCM)
     const int8_t *sol_table;        ///< delta table for SOL_DPCM
 } DPCMContext;
@@ -130,8 +130,8 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx)
         /* initialize square table */
         for (i = 0; i < 128; i++) {
             int16_t square = i * i;
-            s->square_array[i      ] =  square;
-            s->square_array[i + 128] = -square;
+            s->array[i      ] =  square;
+            s->array[i + 128] = -square;
         }
         break;
 
@@ -156,7 +156,25 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx)
     case AV_CODEC_ID_SDX2_DPCM:
         for (i = -128; i < 128; i++) {
             int16_t square = i * i * 2;
-            s->square_array[i+128] = i < 0 ? -square: square;
+            s->array[i+128] = i < 0 ? -square: square;
+        }
+        break;
+
+    case AV_CODEC_ID_GREMLIN_DPCM: {
+        int delta = 0;
+        int code = 64;
+        int step = 45;
+
+        s->array[0] = 0;
+        for (i = 0; i < 127; i++) {
+            delta += (code >> 5);
+            code  += step;
+            step  += 2;
+
+            s->array[i*2 + 1] =  delta;
+            s->array[i*2 + 2] = -delta;
+        }
+        s->array[255] = delta + (code >> 5);
         }
         break;
 
@@ -207,6 +225,7 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
         else
             out = buf_size;
         break;
+    case AV_CODEC_ID_GREMLIN_DPCM:
     case AV_CODEC_ID_SDX2_DPCM:
         out = buf_size;
         break;
@@ -240,7 +259,7 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
 
         /* decode the samples */
         while (output_samples < samples_end) {
-            predictor[ch] += s->square_array[bytestream2_get_byteu(&gb)];
+            predictor[ch] += s->array[bytestream2_get_byteu(&gb)];
             predictor[ch]  = av_clip_int16(predictor[ch]);
             *output_samples++ = predictor[ch];
 
@@ -335,12 +354,24 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
 
             if (!(n & 1))
                 s->sample[ch] = 0;
-            s->sample[ch] += s->square_array[n + 128];
+            s->sample[ch] += s->array[n + 128];
             s->sample[ch]  = av_clip_int16(s->sample[ch]);
             *output_samples++ = s->sample[ch];
             ch ^= stereo;
         }
         break;
+
+    case AV_CODEC_ID_GREMLIN_DPCM: {
+        int idx = 0;
+
+        while (output_samples < samples_end) {
+            uint8_t n = bytestream2_get_byteu(&gb);
+
+            *output_samples++ = s->sample[idx] += s->array[n];
+            idx ^= 1;
+        }
+        }
+        break;
     }
 
     *got_frame_ptr = 1;
@@ -360,6 +391,7 @@ AVCodec ff_ ## name_ ## _decoder = {                        \
     .capabilities   = AV_CODEC_CAP_DR1,                     \
 }
 
+DPCM_DECODER(AV_CODEC_ID_GREMLIN_DPCM,   gremlin_dpcm,   "DPCM Gremlin");
 DPCM_DECODER(AV_CODEC_ID_INTERPLAY_DPCM, interplay_dpcm, "DPCM Interplay");
 DPCM_DECODER(AV_CODEC_ID_ROQ_DPCM,       roq_dpcm,       "DPCM id RoQ");
 DPCM_DECODER(AV_CODEC_ID_SDX2_DPCM,      sdx2_dpcm,      "DPCM Squareroot-Delta-Exact");
diff --git a/mythtv/external/FFmpeg/libavcodec/dpx.c b/mythtv/external/FFmpeg/libavcodec/dpx.c
index e4dd1b05b5b..1aa2cbd1c8a 100644
--- a/mythtv/external/FFmpeg/libavcodec/dpx.c
+++ b/mythtv/external/FFmpeg/libavcodec/dpx.c
@@ -243,6 +243,10 @@ static int decode_frame(AVCodecContext *avctx,
     case 6080:
         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
         break;
+    case 6121:
+    case 6120:
+        avctx->pix_fmt = AV_PIX_FMT_GRAY12;
+        break;
     case 50081:
     case 50080:
         avctx->pix_fmt = AV_PIX_FMT_RGB24;
@@ -345,12 +349,12 @@ static int decode_frame(AVCodecContext *avctx,
                                 (uint16_t*)ptr[2],
                                 (uint16_t*)ptr[3]};
             for (y = 0; y < avctx->width; y++) {
-                *dst[2] = read16(&buf, endian) >> 4;
-                dst[2]++;
+                if (elements >= 3)
+                    *dst[2]++ = read16(&buf, endian) >> 4;
                 *dst[0] = read16(&buf, endian) >> 4;
                 dst[0]++;
-                *dst[1] = read16(&buf, endian) >> 4;
-                dst[1]++;
+                if (elements >= 2)
+                    *dst[1]++ = read16(&buf, endian) >> 4;
                 if (elements == 4)
                     *dst[3]++ = read16(&buf, endian) >> 4;
             }
diff --git a/mythtv/external/FFmpeg/libavcodec/dsddec.c b/mythtv/external/FFmpeg/libavcodec/dsddec.c
index 880d69191c5..2c5c357acc5 100644
--- a/mythtv/external/FFmpeg/libavcodec/dsddec.c
+++ b/mythtv/external/FFmpeg/libavcodec/dsddec.c
@@ -31,10 +31,18 @@
 #include "avcodec.h"
 #include "dsd.h"
 
+#define DSD_SILENCE 0x69
+/* 0x69 = 01101001
+ * This pattern "on repeat" makes a low energy 352.8 kHz tone
+ * and a high energy 1.0584 MHz tone which should be filtered
+ * out completely by any playback system --> silence
+ */
+
 static av_cold int decode_init(AVCodecContext *avctx)
 {
     DSDContext * s;
     int i;
+    uint8_t silence;
 
     ff_init_dsd_data();
 
@@ -42,15 +50,10 @@ static av_cold int decode_init(AVCodecContext *avctx)
     if (!s)
         return AVERROR(ENOMEM);
 
+    silence = avctx->codec_id == AV_CODEC_ID_DSD_LSBF || avctx->codec_id == AV_CODEC_ID_DSD_LSBF_PLANAR ? ff_reverse[DSD_SILENCE] : DSD_SILENCE;
     for (i = 0; i < avctx->channels; i++) {
         s[i].pos = 0;
-        memset(s[i].buf, 0x69, sizeof(s[i].buf));
-
-        /* 0x69 = 01101001
-         * This pattern "on repeat" makes a low energy 352.8 kHz tone
-         * and a high energy 1.0584 MHz tone which should be filtered
-         * out completely by any playback system --> silence
-         */
+        memset(s[i].buf, silence, sizeof(s[i].buf));
     }
 
     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
diff --git a/mythtv/external/FFmpeg/libavcodec/dss_sp.c b/mythtv/external/FFmpeg/libavcodec/dss_sp.c
index ddea48304fb..14025fcddee 100644
--- a/mythtv/external/FFmpeg/libavcodec/dss_sp.c
+++ b/mythtv/external/FFmpeg/libavcodec/dss_sp.c
@@ -33,7 +33,7 @@
 
 #define DSS_SP_FRAME_SIZE        42
 #define DSS_SP_SAMPLE_COUNT     (66 * SUBFRAMES)
-#define DSS_SP_FORMULA(a, b, c) (((((a) << 15) + (b) * (c)) + 0x4000) >> 15)
+#define DSS_SP_FORMULA(a, b, c) ((int)((((a) * (1 << 15)) + (b) * (unsigned)(c)) + 0x4000) >> 15)
 
 typedef struct DssSpSubframe {
     int16_t gain;
@@ -499,7 +499,7 @@ static void dss_sp_scale_vector(int32_t *vec, int bits, int size)
             vec[i] = vec[i] >> -bits;
     else
         for (i = 0; i < size; i++)
-            vec[i] = vec[i] << bits;
+            vec[i] = vec[i] * (1 << bits);
 }
 
 static void dss_sp_update_buf(int32_t *hist, int32_t *vector)
@@ -524,12 +524,12 @@ static void dss_sp_shift_sq_sub(const int32_t *filter_buf,
         tmp = dst[a] * filter_buf[0];
 
         for (i = 14; i > 0; i--)
-            tmp -= error_buf[i] * filter_buf[i];
+            tmp -= error_buf[i] * (unsigned)filter_buf[i];
 
         for (i = 14; i > 0; i--)
             error_buf[i] = error_buf[i - 1];
 
-        tmp = (tmp + 4096) >> 13;
+        tmp = (int)(tmp + 4096U) >> 13;
 
         error_buf[1] = tmp;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/dv.h b/mythtv/external/FFmpeg/libavcodec/dv.h
index 3367f9252a9..0e97bb200ea 100644
--- a/mythtv/external/FFmpeg/libavcodec/dv.h
+++ b/mythtv/external/FFmpeg/libavcodec/dv.h
@@ -38,6 +38,7 @@ typedef struct DVwork_chunk {
 } DVwork_chunk;
 
 typedef struct DVVideoContext {
+    AVClass *avclass;
     const AVDVProfile *sys;
     const AVFrame   *frame;
     AVCodecContext  *avctx;
@@ -45,12 +46,14 @@ typedef struct DVVideoContext {
 
     uint8_t dv_zigzag[2][64];
 
-    void (*get_pixels)(int16_t *block, const uint8_t *pixels, ptrdiff_t line_size);
+    void (*get_pixels)(int16_t *block, const uint8_t *pixels, ptrdiff_t linesize);
     void (*fdct[2])(int16_t *block);
-    void (*idct_put[2])(uint8_t *dest, int line_size, int16_t *block);
+    void (*idct_put[2])(uint8_t *dest, ptrdiff_t stride, int16_t *block);
     me_cmp_func ildct_cmp;
     DVwork_chunk work_chunks[4 * 12 * 27];
     uint32_t idct_factor[2 * 4 * 16 * 64];
+
+    int quant_deadzone;
 } DVVideoContext;
 
 enum dv_section_type {
diff --git a/mythtv/external/FFmpeg/libavcodec/dvbsubdec.c b/mythtv/external/FFmpeg/libavcodec/dvbsubdec.c
index f9b8b22b599..0c78cae4d43 100644
--- a/mythtv/external/FFmpeg/libavcodec/dvbsubdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/dvbsubdec.c
@@ -24,6 +24,7 @@
 #include "bytestream.h"
 #include "internal.h"
 #include "libavutil/colorspace.h"
+#include "libavutil/imgutils.h"
 #include "libavutil/opt.h"
 
 #define DVBSUB_PAGE_SEGMENT     0x10
@@ -35,121 +36,6 @@
 
 #define cm (ff_crop_tab + MAX_NEG_CROP)
 
-#ifdef DEBUG
-#if 0
-static void png_save(const char *filename, uint8_t *bitmap, int w, int h,
-                     uint32_t *rgba_palette)
-{
-    int x, y, v;
-    FILE *f;
-    char fname[40], fname2[40];
-    char command[1024];
-
-    snprintf(fname, 40, "%s.ppm", filename);
-
-    f = fopen(fname, "w");
-    if (!f) {
-        perror(fname);
-        return;
-    }
-    fprintf(f, "P6\n"
-            "%d %d\n"
-            "%d\n",
-            w, h, 255);
-    for(y = 0; y < h; y++) {
-        for(x = 0; x < w; x++) {
-            v = rgba_palette[bitmap[y * w + x]];
-            putc((v >> 16) & 0xff, f);
-            putc((v >> 8) & 0xff, f);
-            putc((v >> 0) & 0xff, f);
-        }
-    }
-    fclose(f);
-
-
-    snprintf(fname2, 40, "%s-a.pgm", filename);
-
-    f = fopen(fname2, "w");
-    if (!f) {
-        perror(fname2);
-        return;
-    }
-    fprintf(f, "P5\n"
-            "%d %d\n"
-            "%d\n",
-            w, h, 255);
-    for(y = 0; y < h; y++) {
-        for(x = 0; x < w; x++) {
-            v = rgba_palette[bitmap[y * w + x]];
-            putc((v >> 24) & 0xff, f);
-        }
-    }
-    fclose(f);
-
-    snprintf(command, 1024, "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
-    system(command);
-
-    snprintf(command, 1024, "rm %s %s", fname, fname2);
-    system(command);
-}
-#endif
-
-static void png_save2(const char *filename, uint32_t *bitmap, int w, int h)
-{
-    int x, y, v;
-    FILE *f;
-    char fname[40], fname2[40];
-    char command[1024];
-
-    snprintf(fname, sizeof(fname), "%s.ppm", filename);
-
-    f = fopen(fname, "w");
-    if (!f) {
-        perror(fname);
-        return;
-    }
-    fprintf(f, "P6\n"
-            "%d %d\n"
-            "%d\n",
-            w, h, 255);
-    for(y = 0; y < h; y++) {
-        for(x = 0; x < w; x++) {
-            v = bitmap[y * w + x];
-            putc((v >> 16) & 0xff, f);
-            putc((v >> 8) & 0xff, f);
-            putc((v >> 0) & 0xff, f);
-        }
-    }
-    fclose(f);
-
-
-    snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
-
-    f = fopen(fname2, "w");
-    if (!f) {
-        perror(fname2);
-        return;
-    }
-    fprintf(f, "P5\n"
-            "%d %d\n"
-            "%d\n",
-            w, h, 255);
-    for(y = 0; y < h; y++) {
-        for(x = 0; x < w; x++) {
-            v = bitmap[y * w + x];
-            putc((v >> 24) & 0xff, f);
-        }
-    }
-    fclose(f);
-
-    snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
-    system(command);
-
-    snprintf(command, sizeof(command), "rm %s %s", fname, fname2);
-    system(command);
-}
-#endif
-
 #define RGBA(r,g,b,a) (((unsigned)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
 
 typedef struct DVBSubCLUT {
@@ -810,7 +696,7 @@ static void compute_default_clut(AVSubtitleRect *rect, int w, int h)
         list_inv[     i ] = bestv;
     }
 
-    count = i - 1;
+    count = FFMAX(i - 1, 1);
     for (i--; i>=0; i--) {
         int v = i*255/count;
         AV_WN32(rect->data[1] + 4*list_inv[i], RGBA(v/2,v,v/2,v));
@@ -1242,9 +1128,9 @@ static int dvbsub_parse_clut_segment(AVCodecContext *avctx,
             r = g = b = 0;
         }
 
-        if (depth & 0x80)
+        if (depth & 0x80 && entry_id < 4)
             clut->clut4[entry_id] = RGBA(r,g,b,255 - alpha);
-        else if (depth & 0x40)
+        else if (depth & 0x40 && entry_id < 16)
             clut->clut16[entry_id] = RGBA(r,g,b,255 - alpha);
         else if (depth & 0x20)
             clut->clut256[entry_id] = RGBA(r,g,b,255 - alpha);
@@ -1267,6 +1153,7 @@ static int dvbsub_parse_region_segment(AVCodecContext *avctx,
     DVBSubObject *object;
     DVBSubObjectDisplay *display;
     int fill;
+    int ret;
 
     if (buf_size < 10)
         return AVERROR_INVALIDDATA;
@@ -1295,6 +1182,16 @@ static int dvbsub_parse_region_segment(AVCodecContext *avctx,
     region->height = AV_RB16(buf);
     buf += 2;
 
+    ret = av_image_check_size2(region->width, region->height, avctx->max_pixels, AV_PIX_FMT_PAL8, 0, avctx);
+    if (ret >= 0 && region->width * region->height * 2 > 320 * 1024 * 8) {
+        ret = AVERROR_INVALIDDATA;
+        av_log(avctx, AV_LOG_ERROR, "Pixel buffer memory constraint violated\n");
+    }
+    if (ret < 0) {
+        region->width= region->height= 0;
+        return ret;
+    }
+
     if (region->width * region->height != region->buf_size) {
         av_free(region->pbuf);
 
@@ -1430,6 +1327,15 @@ static int dvbsub_parse_page_segment(AVCodecContext *avctx,
         region_id = *buf++;
         buf += 1;
 
+        display = ctx->display_list;
+        while (display && display->region_id != region_id) {
+            display = display->next;
+        }
+        if (display) {
+            av_log(avctx, AV_LOG_ERROR, "duplicate region\n");
+            break;
+        }
+
         display = tmp_display_list;
         tmp_ptr = &tmp_display_list;
 
@@ -1472,6 +1378,67 @@ static int dvbsub_parse_page_segment(AVCodecContext *avctx,
 
 
 #ifdef DEBUG
+static void png_save(DVBSubContext *ctx, const char *filename, uint32_t *bitmap, int w, int h)
+{
+    int x, y, v;
+    FILE *f;
+    char fname[40], fname2[40];
+    char command[1024];
+
+    snprintf(fname, sizeof(fname), "%s.ppm", filename);
+
+    f = fopen(fname, "w");
+    if (!f) {
+        perror(fname);
+        return;
+    }
+    fprintf(f, "P6\n"
+            "%d %d\n"
+            "%d\n",
+            w, h, 255);
+    for(y = 0; y < h; y++) {
+        for(x = 0; x < w; x++) {
+            v = bitmap[y * w + x];
+            putc((v >> 16) & 0xff, f);
+            putc((v >> 8) & 0xff, f);
+            putc((v >> 0) & 0xff, f);
+        }
+    }
+    fclose(f);
+
+
+    snprintf(fname2, sizeof(fname2), "%s-a.pgm", filename);
+
+    f = fopen(fname2, "w");
+    if (!f) {
+        perror(fname2);
+        return;
+    }
+    fprintf(f, "P5\n"
+            "%d %d\n"
+            "%d\n",
+            w, h, 255);
+    for(y = 0; y < h; y++) {
+        for(x = 0; x < w; x++) {
+            v = bitmap[y * w + x];
+            putc((v >> 24) & 0xff, f);
+        }
+    }
+    fclose(f);
+
+    snprintf(command, sizeof(command), "pnmtopng -alpha %s %s > %s.png 2> /dev/null", fname2, fname, filename);
+    if (system(command) != 0) {
+        av_log(ctx, AV_LOG_ERROR, "Error running pnmtopng\n");
+        return;
+    }
+
+    snprintf(command, sizeof(command), "rm %s %s", fname, fname2);
+    if (system(command) != 0) {
+        av_log(ctx, AV_LOG_ERROR, "Error removing %s and %s\n", fname, fname2);
+        return;
+    }
+}
+
 static int save_display_set(DVBSubContext *ctx)
 {
     DVBSubRegion *region;
@@ -1565,7 +1532,7 @@ static int save_display_set(DVBSubContext *ctx)
 
         snprintf(filename, sizeof(filename), "dvbs.%d", fileno_index);
 
-        png_save2(filename, pbuf, width, height);
+        png_save(ctx, filename, pbuf, width, height);
 
         av_freep(&pbuf);
     }
@@ -1573,7 +1540,7 @@ static int save_display_set(DVBSubContext *ctx)
     fileno_index++;
     return 0;
 }
-#endif
+#endif /* DEBUG */
 
 static int dvbsub_parse_display_definition_segment(AVCodecContext *avctx,
                                                    const uint8_t *buf,
diff --git a/mythtv/external/FFmpeg/libavcodec/dvdec.c b/mythtv/external/FFmpeg/libavcodec/dvdec.c
index 0b4c1bc2879..7b16787e274 100644
--- a/mythtv/external/FFmpeg/libavcodec/dvdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/dvdec.c
@@ -54,7 +54,7 @@ typedef struct BlockInfo {
     const uint32_t *factor_table;
     const uint8_t *scan_table;
     uint8_t pos; /* position in block */
-    void (*idct_put)(uint8_t *dest, int line_size, int16_t *block);
+    void (*idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
     uint8_t partial_bit_count;
     uint32_t partial_bit_buffer;
     int shift_offset;
@@ -222,8 +222,8 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
 
     /* get the AC coefficients until last_index is reached */
     for (;;) {
-        ff_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
-                re_index);
+        ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n",
+                pos, SHOW_UBITS(re, gb, 16), re_index);
         /* our own optimized GET_RL_VLC */
         index   = NEG_USR32(re_cache, TEX_VLC_BITS);
         vlc_len = ff_dv_rl_vlc[index].len;
diff --git a/mythtv/external/FFmpeg/libavcodec/dvdsubdec.c b/mythtv/external/FFmpeg/libavcodec/dvdsubdec.c
index 1b7cfeada52..b55afc97ead 100644
--- a/mythtv/external/FFmpeg/libavcodec/dvdsubdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/dvdsubdec.c
@@ -60,7 +60,7 @@ static void yuv_a_to_rgba(const uint8_t *ycbcr, const uint8_t *alpha, uint32_t *
         cb = *ycbcr++;
         YUV_TO_RGB1_CCIR(cb, cr);
         YUV_TO_RGB2_CCIR(r, g, b, y);
-        *rgba++ = (*alpha++ << 24) | (r << 16) | (g << 8) | b;
+        *rgba++ = ((unsigned)*alpha++ << 24) | (r << 16) | (g << 8) | b;
     }
 }
 
@@ -189,12 +189,12 @@ static void guess_palette(DVDSubContext* ctx,
                 r = (((subtitle_color >> 16) & 0xff) * level) >> 8;
                 g = (((subtitle_color >> 8) & 0xff) * level) >> 8;
                 b = (((subtitle_color >> 0) & 0xff) * level) >> 8;
-                rgba_palette[i] = b | (g << 8) | (r << 16) | ((alpha[i] * 17) << 24);
+                rgba_palette[i] = b | (g << 8) | (r << 16) | ((alpha[i] * 17U) << 24);
                 color_used[colormap[i]] = (i + 1);
                 j++;
             } else {
                 rgba_palette[i] = (rgba_palette[color_used[colormap[i]] - 1] & 0x00ffffff) |
-                                    ((alpha[i] * 17) << 24);
+                                    ((alpha[i] * 17U) << 24);
             }
         }
     }
@@ -750,7 +750,7 @@ static av_cold int dvdsub_init(AVCodecContext *avctx)
         int i;
         av_log(avctx, AV_LOG_DEBUG, "palette:");
         for(i=0;i<16;i++)
-            av_log(avctx, AV_LOG_DEBUG, " 0x%06x", ctx->palette[i]);
+            av_log(avctx, AV_LOG_DEBUG, " 0x%06"PRIx32, ctx->palette[i]);
         av_log(avctx, AV_LOG_DEBUG, "\n");
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/dvdsubenc.c b/mythtv/external/FFmpeg/libavcodec/dvdsubenc.c
index 29e0322daac..26afdc666b4 100644
--- a/mythtv/external/FFmpeg/libavcodec/dvdsubenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/dvdsubenc.c
@@ -343,7 +343,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
     av_log(avctx, AV_LOG_DEBUG, "Selected palette:");
     for (i = 0; i < 4; i++)
-        av_log(avctx, AV_LOG_DEBUG, " 0x%06x@@%02x (0x%x,0x%x)",
+        av_log(avctx, AV_LOG_DEBUG, " 0x%06"PRIx32"@@%02x (0x%x,0x%x)",
                dvdc->global_palette[out_palette[i]], out_alpha[i],
                out_palette[i], out_alpha[i] >> 4);
     av_log(avctx, AV_LOG_DEBUG, "\n");
diff --git a/mythtv/external/FFmpeg/libavcodec/dvenc.c b/mythtv/external/FFmpeg/libavcodec/dvenc.c
index a27b9ef0daa..ce2fc75daa1 100644
--- a/mythtv/external/FFmpeg/libavcodec/dvenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/dvenc.c
@@ -17,6 +17,8 @@
  * 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
+ *
+ * quant_deadzone code and fixes sponsored by NOA GmbH
  */
 
 /**
@@ -28,6 +30,7 @@
 
 #include "libavutil/attributes.h"
 #include "libavutil/internal.h"
+#include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
 
 #include "avcodec.h"
@@ -204,7 +207,7 @@ static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
 }
 
 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
-                                              int linesize)
+                                              ptrdiff_t linesize)
 {
     if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
         int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
@@ -241,8 +244,8 @@ static const int dv_weight_248[64] = {
 };
 
 static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
-                                              int linesize, DVVideoContext *s,
-                                              int bias)
+                                              ptrdiff_t linesize,
+                                              DVVideoContext *s, int bias)
 {
     const int *weight;
     const uint8_t *zigzag_scan;
@@ -265,6 +268,8 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
 #endif
     int max  = classes[0];
     int prev = 0;
+    const unsigned deadzone = s->quant_deadzone;
+    const unsigned threshold = 2 * deadzone;
 
     av_assert2((((int) blk) & 15) == 0);
 
@@ -297,13 +302,15 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
         for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
             int level = blk[zigzag_scan[i]];
 
-            if (level + 15 > 30U) {
+            if (level + deadzone > threshold) {
                 bi->sign[i] = (level >> 31) & 1;
                 /* Weight it and shift down into range, adding for rounding.
                  * The extra division by a factor of 2^4 reverses the 8x
                  * expansion of the DCT AND the 2x doubling of the weights. */
                 level     = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
                             (dv_weight_bits + 4);
+                if (!level)
+                    continue;
                 bi->mb[i] = level;
                 if (level > max)
                     max = level;
@@ -420,7 +427,8 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
     DVVideoContext *s = avctx->priv_data;
     DVwork_chunk *work_chunk = arg;
     int mb_index, i, j;
-    int mb_x, mb_y, c_offset, linesize, y_stride;
+    int mb_x, mb_y, c_offset;
+    ptrdiff_t linesize, y_stride;
     uint8_t *y_ptr;
     uint8_t *dif;
     LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
@@ -745,6 +753,20 @@ FF_ENABLE_DEPRECATION_WARNINGS
     return 0;
 }
 
+#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+#define OFFSET(x) offsetof(DVVideoContext, x)
+static const AVOption dv_options[] = {
+    { "quant_deadzone",        "Quantizer dead zone",    OFFSET(quant_deadzone),       AV_OPT_TYPE_INT, { .i64 = 7 }, 0, 1024, VE },
+    { NULL },
+};
+
+static const AVClass dvvideo_encode_class = {
+    .class_name = "dvvideo encoder",
+    .item_name  = av_default_item_name,
+    .option     = dv_options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
 AVCodec ff_dvvideo_encoder = {
     .name           = "dvvideo",
     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
@@ -758,4 +780,5 @@ AVCodec ff_dvvideo_encoder = {
         AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
         AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
     },
+    .priv_class     = &dvvideo_encode_class,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/dxtory.c b/mythtv/external/FFmpeg/libavcodec/dxtory.c
index ea5da610da3..6f8652ad499 100644
--- a/mythtv/external/FFmpeg/libavcodec/dxtory.c
+++ b/mythtv/external/FFmpeg/libavcodec/dxtory.c
@@ -201,12 +201,12 @@ static int check_slice_size(AVCodecContext *avctx,
 
     if (slice_size > src_size - off) {
         av_log(avctx, AV_LOG_ERROR,
-               "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
+               "invalid slice size %d (only %d bytes left)\n",
                slice_size, src_size - off);
         return AVERROR_INVALIDDATA;
     }
     if (slice_size <= 16) {
-        av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n",
+        av_log(avctx, AV_LOG_ERROR, "invalid slice size %d\n",
                slice_size);
         return AVERROR_INVALIDDATA;
     }
@@ -214,7 +214,7 @@ static int check_slice_size(AVCodecContext *avctx,
     cur_slice_size = AV_RL32(src + off);
     if (cur_slice_size != slice_size - 16) {
         av_log(avctx, AV_LOG_ERROR,
-               "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
+               "Slice sizes mismatch: got %d instead of %d\n",
                cur_slice_size, slice_size - 16);
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/dxv.c b/mythtv/external/FFmpeg/libavcodec/dxv.c
index 05a9aadd24b..529e2112589 100644
--- a/mythtv/external/FFmpeg/libavcodec/dxv.c
+++ b/mythtv/external/FFmpeg/libavcodec/dxv.c
@@ -133,7 +133,7 @@ static int dxv_decompress_dxt1(AVCodecContext *avctx)
     AV_WL32(ctx->tex_data + 4, bytestream2_get_le32(gbc));
 
     /* Process input until the whole texture has been filled */
-    while (pos < ctx->tex_size / 4) {
+    while (pos + 2 <= ctx->tex_size / 4) {
         CHECKPOINT(2);
 
         /* Copy two elements from a previous offset or from the input buffer */
@@ -186,7 +186,7 @@ static int dxv_decompress_dxt5(AVCodecContext *avctx)
     AV_WL32(ctx->tex_data + 12, bytestream2_get_le32(gbc));
 
     /* Process input until the whole texture has been filled */
-    while (pos < ctx->tex_size / 4) {
+    while (pos + 2 <= ctx->tex_size / 4) {
         if (run) {
             run--;
 
@@ -197,6 +197,8 @@ static int dxv_decompress_dxt5(AVCodecContext *avctx)
             AV_WL32(ctx->tex_data + 4 * pos, prev);
             pos++;
         } else {
+            if (bytestream2_get_bytes_left(gbc) < 1)
+                return AVERROR_INVALIDDATA;
             if (state == 0) {
                 value = bytestream2_get_le32(gbc);
                 state = 16;
@@ -215,7 +217,7 @@ static int dxv_decompress_dxt5(AVCodecContext *avctx)
                         check += probe;
                     } while (probe == 0xFFFF);
                 }
-                while (check && pos < ctx->tex_size / 4) {
+                while (check && pos + 4 <= ctx->tex_size / 4) {
                     prev = AV_RL32(ctx->tex_data + 4 * (pos - 4));
                     AV_WL32(ctx->tex_data + 4 * pos, prev);
                     pos++;
@@ -260,10 +262,8 @@ static int dxv_decompress_dxt5(AVCodecContext *avctx)
             case 2:
                 /* Copy two dwords from a previous index */
                 idx = 8 + bytestream2_get_le16(gbc);
-                if (idx > pos) {
-                    av_log(avctx, AV_LOG_ERROR, "idx %d > %d\n", idx, pos);
+                if (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4)
                     return AVERROR_INVALIDDATA;
-                }
                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
                 AV_WL32(ctx->tex_data + 4 * pos, prev);
                 pos++;
@@ -286,9 +286,13 @@ static int dxv_decompress_dxt5(AVCodecContext *avctx)
         }
 
         CHECKPOINT(4);
+        if (pos + 2 > ctx->tex_size / 4)
+            return AVERROR_INVALIDDATA;
 
         /* Copy two elements from a previous offset or from the input buffer */
         if (op) {
+            if (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4)
+                return AVERROR_INVALIDDATA;
             prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
             AV_WL32(ctx->tex_data + 4 * pos, prev);
             pos++;
@@ -299,6 +303,8 @@ static int dxv_decompress_dxt5(AVCodecContext *avctx)
         } else {
             CHECKPOINT(4);
 
+            if (op && (idx > pos || (unsigned int)(pos - idx) + 2 > ctx->tex_size / 4))
+                return AVERROR_INVALIDDATA;
             if (op)
                 prev = AV_RL32(ctx->tex_data + 4 * (pos - idx));
             else
@@ -331,6 +337,9 @@ static int dxv_decompress_raw(AVCodecContext *avctx)
     DXVContext *ctx = avctx->priv_data;
     GetByteContext *gbc = &ctx->gbc;
 
+    if (bytestream2_get_bytes_left(gbc) < ctx->tex_size)
+        return AVERROR_INVALIDDATA;
+
     bytestream2_get_buffer(gbc, ctx->tex_data, ctx->tex_size);
     return 0;
 }
@@ -370,7 +379,7 @@ static int dxv_decode(AVCodecContext *avctx, void *data,
         break;
     case MKBETAG('Y', 'C', 'G', '6'):
     case MKBETAG('Y', 'G', '1', '0'):
-        avpriv_report_missing_feature(avctx, "Tag 0x%08X", tag);
+        avpriv_report_missing_feature(avctx, "Tag 0x%08"PRIX32, tag);
         return AVERROR_PATCHWELCOME;
     default:
         /* Old version does not have a real header, just size and type. */
@@ -397,7 +406,7 @@ static int dxv_decode(AVCodecContext *avctx, void *data,
             ctx->tex_funct = ctx->texdsp.dxt1_block;
             ctx->tex_step  = 8;
         } else {
-            av_log(avctx, AV_LOG_ERROR, "Unsupported header (0x%08X)\n.", tag);
+            av_log(avctx, AV_LOG_ERROR, "Unsupported header (0x%08"PRIX32")\n.", tag);
             return AVERROR_INVALIDDATA;
         }
         ctx->tex_rat = 1;
@@ -425,7 +434,7 @@ static int dxv_decode(AVCodecContext *avctx, void *data,
 
     if (size != bytestream2_get_bytes_left(gbc)) {
         av_log(avctx, AV_LOG_ERROR,
-               "Incomplete or invalid file (header %d, left %d).\n",
+               "Incomplete or invalid file (header %d, left %u).\n",
                size, bytestream2_get_bytes_left(gbc));
         return AVERROR_INVALIDDATA;
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/dxva2.c b/mythtv/external/FFmpeg/libavcodec/dxva2.c
index 04a9c1129d0..afcd361ef68 100644
--- a/mythtv/external/FFmpeg/libavcodec/dxva2.c
+++ b/mythtv/external/FFmpeg/libavcodec/dxva2.c
@@ -22,15 +22,747 @@
 
 #include <assert.h>
 #include <string.h>
+#include <initguid.h>
 
+#include "libavutil/common.h"
 #include "libavutil/log.h"
 #include "libavutil/time.h"
 
 #include "avcodec.h"
 #include "dxva2_internal.h"
 
-void *ff_dxva2_get_surface(const AVFrame *frame)
+/* define all the GUIDs used directly here,
+ to avoid problems with inconsistent dxva2api.h versions in mingw-w64 and different MSVC version */
+DEFINE_GUID(ff_DXVA2_ModeMPEG2_VLD,      0xee27417f, 0x5e28,0x4e65,0xbe,0xea,0x1d,0x26,0xb5,0x08,0xad,0xc9);
+DEFINE_GUID(ff_DXVA2_ModeMPEG2and1_VLD,  0x86695f12, 0x340e,0x4f04,0x9f,0xd3,0x92,0x53,0xdd,0x32,0x74,0x60);
+DEFINE_GUID(ff_DXVA2_ModeH264_E,         0x1b81be68, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(ff_DXVA2_ModeH264_F,         0x1b81be69, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(ff_DXVADDI_Intel_ModeH264_E, 0x604F8E68, 0x4951,0x4C54,0x88,0xFE,0xAB,0xD2,0x5C,0x15,0xB3,0xD6);
+DEFINE_GUID(ff_DXVA2_ModeVC1_D,          0x1b81beA3, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(ff_DXVA2_ModeVC1_D2010,      0x1b81beA4, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(ff_DXVA2_ModeHEVC_VLD_Main,  0x5b11d51b, 0x2f4c,0x4452,0xbc,0xc3,0x09,0xf2,0xa1,0x16,0x0c,0xc0);
+DEFINE_GUID(ff_DXVA2_ModeHEVC_VLD_Main10,0x107af0e0, 0xef1a,0x4d19,0xab,0xa8,0x67,0xa1,0x63,0x07,0x3d,0x13);
+DEFINE_GUID(ff_DXVA2_ModeVP9_VLD_Profile0,0x463707f8,0xa1d0,0x4585,0x87,0x6d,0x83,0xaa,0x6d,0x60,0xb8,0x9e);
+DEFINE_GUID(ff_DXVA2_NoEncrypt,          0x1b81beD0, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(ff_GUID_NULL,                0x00000000, 0x0000,0x0000,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00);
+DEFINE_GUID(ff_IID_IDirectXVideoDecoderService, 0xfc51a551,0xd5e7,0x11d9,0xaf,0x55,0x00,0x05,0x4e,0x43,0xff,0x02);
+
+typedef struct dxva_mode {
+    const GUID     *guid;
+    enum AVCodecID codec;
+    // List of supported profiles, terminated by a FF_PROFILE_UNKNOWN entry.
+    // If NULL, don't check profile.
+    const int      *profiles;
+} dxva_mode;
+
+static const int prof_mpeg2_main[]   = {FF_PROFILE_MPEG2_SIMPLE,
+                                        FF_PROFILE_MPEG2_MAIN,
+                                        FF_PROFILE_UNKNOWN};
+static const int prof_h264_high[]    = {FF_PROFILE_H264_CONSTRAINED_BASELINE,
+                                        FF_PROFILE_H264_MAIN,
+                                        FF_PROFILE_H264_HIGH,
+                                        FF_PROFILE_UNKNOWN};
+static const int prof_hevc_main[]    = {FF_PROFILE_HEVC_MAIN,
+                                        FF_PROFILE_UNKNOWN};
+static const int prof_hevc_main10[]  = {FF_PROFILE_HEVC_MAIN_10,
+                                        FF_PROFILE_UNKNOWN};
+
+static const dxva_mode dxva_modes[] = {
+    /* MPEG-2 */
+    { &ff_DXVA2_ModeMPEG2_VLD,       AV_CODEC_ID_MPEG2VIDEO, prof_mpeg2_main },
+    { &ff_DXVA2_ModeMPEG2and1_VLD,   AV_CODEC_ID_MPEG2VIDEO, prof_mpeg2_main },
+
+    /* H.264 */
+    { &ff_DXVA2_ModeH264_F,          AV_CODEC_ID_H264, prof_h264_high },
+    { &ff_DXVA2_ModeH264_E,          AV_CODEC_ID_H264, prof_h264_high },
+    /* Intel specific H.264 mode */
+    { &ff_DXVADDI_Intel_ModeH264_E,  AV_CODEC_ID_H264, prof_h264_high },
+
+    /* VC-1 / WMV3 */
+    { &ff_DXVA2_ModeVC1_D2010,       AV_CODEC_ID_VC1 },
+    { &ff_DXVA2_ModeVC1_D2010,       AV_CODEC_ID_WMV3 },
+    { &ff_DXVA2_ModeVC1_D,           AV_CODEC_ID_VC1 },
+    { &ff_DXVA2_ModeVC1_D,           AV_CODEC_ID_WMV3 },
+
+    /* HEVC/H.265 */
+    { &ff_DXVA2_ModeHEVC_VLD_Main10, AV_CODEC_ID_HEVC, prof_hevc_main10 },
+    { &ff_DXVA2_ModeHEVC_VLD_Main,   AV_CODEC_ID_HEVC, prof_hevc_main },
+
+    /* VP8/9 */
+    { &ff_DXVA2_ModeVP9_VLD_Profile0,AV_CODEC_ID_VP9 },
+
+    { NULL,                          0 },
+};
+
+static int dxva_get_decoder_configuration(AVCodecContext *avctx,
+                                          const void *cfg_list,
+                                          unsigned cfg_count)
+{
+    FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+    unsigned i, best_score = 0;
+    int best_cfg = -1;
+
+    for (i = 0; i < cfg_count; i++) {
+        unsigned score;
+        UINT ConfigBitstreamRaw;
+        GUID guidConfigBitstreamEncryption;
+
+#if CONFIG_D3D11VA
+        if (sctx->pix_fmt == AV_PIX_FMT_D3D11) {
+            D3D11_VIDEO_DECODER_CONFIG *cfg = &((D3D11_VIDEO_DECODER_CONFIG *)cfg_list)[i];
+            ConfigBitstreamRaw = cfg->ConfigBitstreamRaw;
+            guidConfigBitstreamEncryption = cfg->guidConfigBitstreamEncryption;
+        }
+#endif
+#if CONFIG_DXVA2
+        if (sctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
+            DXVA2_ConfigPictureDecode *cfg = &((DXVA2_ConfigPictureDecode *)cfg_list)[i];
+            ConfigBitstreamRaw = cfg->ConfigBitstreamRaw;
+            guidConfigBitstreamEncryption = cfg->guidConfigBitstreamEncryption;
+        }
+#endif
+
+        if (ConfigBitstreamRaw == 1)
+            score = 1;
+        else if (avctx->codec_id == AV_CODEC_ID_H264 && ConfigBitstreamRaw == 2)
+            score = 2;
+        else
+            continue;
+        if (IsEqualGUID(&guidConfigBitstreamEncryption, &ff_DXVA2_NoEncrypt))
+            score += 16;
+        if (score > best_score) {
+            best_score = score;
+            best_cfg = i;
+        }
+    }
+
+    if (!best_score) {
+        av_log(avctx, AV_LOG_VERBOSE, "No valid decoder configuration available\n");
+        return AVERROR(EINVAL);
+    }
+
+    return best_cfg;
+}
+
+#if CONFIG_D3D11VA
+static int d3d11va_validate_output(void *service, GUID guid, const void *surface_format)
+{
+    HRESULT hr;
+    BOOL is_supported = FALSE;
+    hr = ID3D11VideoDevice_CheckVideoDecoderFormat((ID3D11VideoDevice *)service,
+                                                   &guid,
+                                                   *(DXGI_FORMAT *)surface_format,
+                                                   &is_supported);
+    return SUCCEEDED(hr) && is_supported;
+}
+#endif
+
+#if CONFIG_DXVA2
+static int dxva2_validate_output(void *decoder_service, GUID guid, const void *surface_format)
+{
+    HRESULT hr;
+    int ret = 0;
+    unsigned j, target_count;
+    D3DFORMAT *target_list;
+    hr = IDirectXVideoDecoderService_GetDecoderRenderTargets((IDirectXVideoDecoderService *)decoder_service, &guid, &target_count, &target_list);
+    if (SUCCEEDED(hr)) {
+        for (j = 0; j < target_count; j++) {
+            const D3DFORMAT format = target_list[j];
+            if (format == *(D3DFORMAT *)surface_format) {
+                ret = 1;
+                break;
+            }
+        }
+        CoTaskMemFree(target_list);
+    }
+    return ret;
+}
+#endif
+
+static int dxva_check_codec_compatibility(AVCodecContext *avctx, const dxva_mode *mode)
+{
+    if (mode->codec != avctx->codec_id)
+            return 0;
+
+    if (mode->profiles && !(avctx->hwaccel_flags & AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH)) {
+        int i, found = 0;
+        for (i = 0; mode->profiles[i] != FF_PROFILE_UNKNOWN; i++) {
+            if (avctx->profile == mode->profiles[i]) {
+                found = 1;
+                break;
+            }
+        }
+        if (!found)
+            return 0;
+    }
+
+    return 1;
+}
+
+static void dxva_list_guids_debug(AVCodecContext *avctx, void *service,
+                                 unsigned guid_count, const GUID *guid_list)
+{
+    FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+    int i;
+
+    av_log(avctx, AV_LOG_VERBOSE, "Decoder GUIDs reported as supported:\n");
+
+    for (i = 0; i < guid_count; i++) {
+        const GUID *guid = &guid_list[i];
+
+        av_log(avctx, AV_LOG_VERBOSE,
+             "{%8.8x-%4.4x-%4.4x-%2.2x%2.2x-%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x}",
+             (unsigned) guid->Data1, guid->Data2, guid->Data3,
+             guid->Data4[0], guid->Data4[1],
+             guid->Data4[2], guid->Data4[3],
+             guid->Data4[4], guid->Data4[5],
+             guid->Data4[6], guid->Data4[7]);
+
+#if CONFIG_D3D11VA
+        if (sctx->pix_fmt == AV_PIX_FMT_D3D11) {
+            DXGI_FORMAT format;
+            // We don't know the maximum valid DXGI_FORMAT, so use 200 as
+            // arbitrary upper bound (that could become outdated).
+            for (format = 0; format < 200; format++) {
+                if (d3d11va_validate_output(service, *guid, &format))
+                    av_log(avctx, AV_LOG_VERBOSE, " %d", (int)format);
+            }
+        }
+#endif
+#if CONFIG_DXVA2
+        if (sctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
+            const D3DFORMAT formats[] = {MKTAG('N', 'V', '1', '2'),
+                                         MKTAG('P', '0', '1', '0')};
+            int i;
+            for (i = 0; i < FF_ARRAY_ELEMS(formats); i++) {
+                if (dxva2_validate_output(service, *guid, &formats[i]))
+                    av_log(avctx, AV_LOG_VERBOSE, " %d", i);
+            }
+        }
+#endif
+        av_log(avctx, AV_LOG_VERBOSE, "\n");
+    }
+}
+
+static int dxva_get_decoder_guid(AVCodecContext *avctx, void *service, void *surface_format,
+                                 unsigned guid_count, const GUID *guid_list, GUID *decoder_guid)
+{
+    FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+    unsigned i, j;
+
+    dxva_list_guids_debug(avctx, service, guid_count, guid_list);
+
+    *decoder_guid = ff_GUID_NULL;
+    for (i = 0; dxva_modes[i].guid; i++) {
+        const dxva_mode *mode = &dxva_modes[i];
+        int validate;
+        if (!dxva_check_codec_compatibility(avctx, mode))
+            continue;
+
+        for (j = 0; j < guid_count; j++) {
+            if (IsEqualGUID(mode->guid, &guid_list[j]))
+                break;
+        }
+        if (j == guid_count)
+            continue;
+
+#if CONFIG_D3D11VA
+        if (sctx->pix_fmt == AV_PIX_FMT_D3D11)
+            validate = d3d11va_validate_output(service, *mode->guid, surface_format);
+#endif
+#if CONFIG_DXVA2
+        if (sctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD)
+            validate = dxva2_validate_output(service, *mode->guid, surface_format);
+#endif
+        if (validate) {
+            *decoder_guid = *mode->guid;
+            break;
+        }
+    }
+
+    if (IsEqualGUID(decoder_guid, &ff_GUID_NULL)) {
+        av_log(avctx, AV_LOG_VERBOSE, "No decoder device for codec found\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (IsEqualGUID(decoder_guid, &ff_DXVADDI_Intel_ModeH264_E))
+        sctx->workaround |= FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO;
+
+    return 0;
+}
+
+static void bufref_free_interface(void *opaque, uint8_t *data)
+{
+    IUnknown_Release((IUnknown *)opaque);
+}
+
+static AVBufferRef *bufref_wrap_interface(IUnknown *iface)
+{
+    return av_buffer_create((uint8_t*)iface, 1, bufref_free_interface, iface, 0);
+}
+
+#if CONFIG_DXVA2
+
+static int dxva2_get_decoder_configuration(AVCodecContext *avctx, const GUID *device_guid,
+                                           const DXVA2_VideoDesc *desc,
+                                           DXVA2_ConfigPictureDecode *config)
 {
+    FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+    unsigned cfg_count;
+    DXVA2_ConfigPictureDecode *cfg_list;
+    HRESULT hr;
+    int ret;
+
+    hr = IDirectXVideoDecoderService_GetDecoderConfigurations(sctx->dxva2_service, device_guid, desc, NULL, &cfg_count, &cfg_list);
+    if (FAILED(hr)) {
+        av_log(avctx, AV_LOG_ERROR, "Unable to retrieve decoder configurations\n");
+        return AVERROR(EINVAL);
+    }
+
+    ret = dxva_get_decoder_configuration(avctx, cfg_list, cfg_count);
+    if (ret >= 0)
+        *config = cfg_list[ret];
+    CoTaskMemFree(cfg_list);
+    return ret;
+}
+
+static int dxva2_create_decoder(AVCodecContext *avctx)
+{
+    FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+    GUID *guid_list;
+    unsigned guid_count;
+    GUID device_guid;
+    D3DFORMAT surface_format = avctx->sw_pix_fmt == AV_PIX_FMT_YUV420P10 ?
+                               MKTAG('P', '0', '1', '0') : MKTAG('N', 'V', '1', '2');
+    DXVA2_VideoDesc desc = { 0 };
+    DXVA2_ConfigPictureDecode config;
+    HRESULT hr;
+    int ret;
+    HANDLE device_handle;
+    AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+    AVDXVA2FramesContext *frames_hwctx = frames_ctx->hwctx;
+    AVDXVA2DeviceContext *device_hwctx = frames_ctx->device_ctx->hwctx;
+
+    hr = IDirect3DDeviceManager9_OpenDeviceHandle(device_hwctx->devmgr,
+                                                  &device_handle);
+    if (FAILED(hr)) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to open a device handle\n");
+        goto fail;
+    }
+
+    hr = IDirect3DDeviceManager9_GetVideoService(device_hwctx->devmgr, device_handle,
+                                                 &ff_IID_IDirectXVideoDecoderService,
+                                                 (void **)&sctx->dxva2_service);
+    IDirect3DDeviceManager9_CloseDeviceHandle(device_hwctx->devmgr, device_handle);
+    if (FAILED(hr)) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create IDirectXVideoDecoderService\n");
+        goto fail;
+    }
+
+    hr = IDirectXVideoDecoderService_GetDecoderDeviceGuids(sctx->dxva2_service, &guid_count, &guid_list);
+    if (FAILED(hr)) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to retrieve decoder device GUIDs\n");
+        goto fail;
+    }
+
+    ret = dxva_get_decoder_guid(avctx, sctx->dxva2_service, &surface_format,
+                                guid_count, guid_list, &device_guid);
+    CoTaskMemFree(guid_list);
+    if (ret < 0) {
+        goto fail;
+    }
+
+    desc.SampleWidth  = avctx->coded_width;
+    desc.SampleHeight = avctx->coded_height;
+    desc.Format       = surface_format;
+
+    ret = dxva2_get_decoder_configuration(avctx, &device_guid, &desc, &config);
+    if (ret < 0) {
+        goto fail;
+    }
+
+    hr = IDirectXVideoDecoderService_CreateVideoDecoder(sctx->dxva2_service, &device_guid,
+                                                        &desc, &config, frames_hwctx->surfaces,
+                                                        frames_hwctx->nb_surfaces, &sctx->dxva2_decoder);
+    if (FAILED(hr)) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create DXVA2 video decoder\n");
+        goto fail;
+    }
+
+    sctx->dxva2_config = config;
+
+    sctx->decoder_ref = bufref_wrap_interface((IUnknown *)sctx->dxva2_decoder);
+    if (!sctx->decoder_ref)
+        return AVERROR(ENOMEM);
+
+    return 0;
+fail:
+    return AVERROR(EINVAL);
+}
+
+#endif
+
+#if CONFIG_D3D11VA
+
+static int d3d11va_get_decoder_configuration(AVCodecContext *avctx,
+                                             ID3D11VideoDevice *video_device,
+                                             const D3D11_VIDEO_DECODER_DESC *desc,
+                                             D3D11_VIDEO_DECODER_CONFIG *config)
+{
+    unsigned cfg_count = 0;
+    D3D11_VIDEO_DECODER_CONFIG *cfg_list = NULL;
+    HRESULT hr;
+    int i, ret;
+
+    hr = ID3D11VideoDevice_GetVideoDecoderConfigCount(video_device, desc, &cfg_count);
+    if (FAILED(hr)) {
+        av_log(avctx, AV_LOG_ERROR, "Unable to retrieve decoder configurations\n");
+        return AVERROR(EINVAL);
+    }
+
+    cfg_list = av_malloc_array(cfg_count, sizeof(D3D11_VIDEO_DECODER_CONFIG));
+    if (cfg_list == NULL)
+        return AVERROR(ENOMEM);
+    for (i = 0; i < cfg_count; i++) {
+        hr = ID3D11VideoDevice_GetVideoDecoderConfig(video_device, desc, i, &cfg_list[i]);
+        if (FAILED(hr)) {
+            av_log(avctx, AV_LOG_ERROR, "Unable to retrieve decoder configurations. (hr=0x%lX)\n", hr);
+            av_free(cfg_list);
+            return AVERROR(EINVAL);
+        }
+    }
+
+    ret = dxva_get_decoder_configuration(avctx, cfg_list, cfg_count);
+    if (ret >= 0)
+        *config = cfg_list[ret];
+    av_free(cfg_list);
+    return ret;
+}
+
+static DXGI_FORMAT d3d11va_map_sw_to_hw_format(enum AVPixelFormat pix_fmt)
+{
+    switch (pix_fmt) {
+    case AV_PIX_FMT_NV12:       return DXGI_FORMAT_NV12;
+    case AV_PIX_FMT_P010:       return DXGI_FORMAT_P010;
+    case AV_PIX_FMT_YUV420P:    return DXGI_FORMAT_420_OPAQUE;
+    default:                    return DXGI_FORMAT_UNKNOWN;
+    }
+}
+
+static int d3d11va_create_decoder(AVCodecContext *avctx)
+{
+    FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+    GUID *guid_list;
+    unsigned guid_count, i;
+    GUID decoder_guid;
+    D3D11_VIDEO_DECODER_DESC desc = { 0 };
+    D3D11_VIDEO_DECODER_CONFIG config;
+    AVHWFramesContext *frames_ctx = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
+    AVD3D11VADeviceContext *device_hwctx = frames_ctx->device_ctx->hwctx;
+    AVD3D11VAFramesContext *frames_hwctx = frames_ctx->hwctx;
+    DXGI_FORMAT surface_format = d3d11va_map_sw_to_hw_format(frames_ctx->sw_format);
+    D3D11_TEXTURE2D_DESC texdesc;
+    HRESULT hr;
+    int ret;
+
+    if (!frames_hwctx->texture) {
+        av_log(avctx, AV_LOG_ERROR, "AVD3D11VAFramesContext.texture not set.\n");
+        return AVERROR(EINVAL);
+    }
+    ID3D11Texture2D_GetDesc(frames_hwctx->texture, &texdesc);
+
+    guid_count = ID3D11VideoDevice_GetVideoDecoderProfileCount(device_hwctx->video_device);
+    guid_list = av_malloc_array(guid_count, sizeof(*guid_list));
+    if (guid_list == NULL || guid_count == 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to get the decoder GUIDs\n");
+        av_free(guid_list);
+        return AVERROR(EINVAL);
+    }
+    for (i = 0; i < guid_count; i++) {
+        hr = ID3D11VideoDevice_GetVideoDecoderProfile(device_hwctx->video_device, i, &guid_list[i]);
+        if (FAILED(hr)) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to retrieve decoder GUID %d\n", i);
+            av_free(guid_list);
+            return AVERROR(EINVAL);
+        }
+    }
+
+    ret = dxva_get_decoder_guid(avctx, device_hwctx->video_device, &surface_format,
+                                guid_count, guid_list, &decoder_guid);
+    av_free(guid_list);
+    if (ret < 0)
+        return AVERROR(EINVAL);
+
+    desc.SampleWidth  = avctx->coded_width;
+    desc.SampleHeight = avctx->coded_height;
+    desc.OutputFormat = surface_format;
+    desc.Guid         = decoder_guid;
+
+    ret = d3d11va_get_decoder_configuration(avctx, device_hwctx->video_device, &desc, &config);
+    if (ret < 0)
+        return AVERROR(EINVAL);
+
+    sctx->d3d11_views = av_mallocz_array(texdesc.ArraySize, sizeof(sctx->d3d11_views[0]));
+    if (!sctx->d3d11_views)
+        return AVERROR(ENOMEM);
+    sctx->nb_d3d11_views = texdesc.ArraySize;
+
+    for (i = 0; i < sctx->nb_d3d11_views; i++) {
+        D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc = {
+            .DecodeProfile = decoder_guid,
+            .ViewDimension = D3D11_VDOV_DIMENSION_TEXTURE2D,
+            .Texture2D = {
+                .ArraySlice = i,
+            }
+        };
+        hr = ID3D11VideoDevice_CreateVideoDecoderOutputView(device_hwctx->video_device,
+                                                            (ID3D11Resource*) frames_hwctx->texture,
+                                                            &viewDesc,
+                                                            (ID3D11VideoDecoderOutputView**) &sctx->d3d11_views[i]);
+        if (FAILED(hr)) {
+            av_log(avctx, AV_LOG_ERROR, "Could not create the decoder output view %d\n", i);
+            return AVERROR_UNKNOWN;
+        }
+    }
+
+    hr = ID3D11VideoDevice_CreateVideoDecoder(device_hwctx->video_device, &desc,
+                                              &config, &sctx->d3d11_decoder);
+    if (FAILED(hr)) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create D3D11VA video decoder\n");
+        return AVERROR(EINVAL);
+    }
+
+    sctx->d3d11_config = config;
+    sctx->d3d11_texture = frames_hwctx->texture;
+
+    sctx->decoder_ref = bufref_wrap_interface((IUnknown *)sctx->d3d11_decoder);
+    if (!sctx->decoder_ref)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+#endif
+
+static void ff_dxva2_lock(AVCodecContext *avctx)
+{
+#if CONFIG_D3D11VA
+    if (ff_dxva2_is_d3d11(avctx)) {
+        FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+        AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
+        if (D3D11VA_CONTEXT(ctx)->context_mutex != INVALID_HANDLE_VALUE)
+            WaitForSingleObjectEx(D3D11VA_CONTEXT(ctx)->context_mutex, INFINITE, FALSE);
+        if (sctx->device_ctx) {
+            AVD3D11VADeviceContext *hwctx = sctx->device_ctx->hwctx;
+            hwctx->lock(hwctx->lock_ctx);
+        }
+    }
+#endif
+}
+
+static void ff_dxva2_unlock(AVCodecContext *avctx)
+{
+#if CONFIG_D3D11VA
+    if (ff_dxva2_is_d3d11(avctx)) {
+        FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+        AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
+        if (D3D11VA_CONTEXT(ctx)->context_mutex != INVALID_HANDLE_VALUE)
+            ReleaseMutex(D3D11VA_CONTEXT(ctx)->context_mutex);
+        if (sctx->device_ctx) {
+            AVD3D11VADeviceContext *hwctx = sctx->device_ctx->hwctx;
+            hwctx->unlock(hwctx->lock_ctx);
+        }
+    }
+#endif
+}
+
+// This must work before the decoder is created.
+// This somehow needs to be exported to the user.
+static void dxva_adjust_hwframes(AVCodecContext *avctx, AVHWFramesContext *frames_ctx)
+{
+    FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+    int surface_alignment, num_surfaces;
+
+    frames_ctx->format = sctx->pix_fmt;
+
+    /* decoding MPEG-2 requires additional alignment on some Intel GPUs,
+    but it causes issues for H.264 on certain AMD GPUs..... */
+    if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO)
+        surface_alignment = 32;
+    /* the HEVC DXVA2 spec asks for 128 pixel aligned surfaces to ensure
+    all coding features have enough room to work with */
+    else if (avctx->codec_id == AV_CODEC_ID_HEVC)
+        surface_alignment = 128;
+    else
+        surface_alignment = 16;
+
+    /* 4 base work surfaces */
+    num_surfaces = 4;
+
+    /* add surfaces based on number of possible refs */
+    if (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC)
+        num_surfaces += 16;
+    else if (avctx->codec_id == AV_CODEC_ID_VP9)
+        num_surfaces += 8;
+    else
+        num_surfaces += 2;
+
+    /* add extra surfaces for frame threading */
+    if (avctx->active_thread_type & FF_THREAD_FRAME)
+        num_surfaces += avctx->thread_count;
+
+    frames_ctx->sw_format = avctx->sw_pix_fmt == AV_PIX_FMT_YUV420P10 ?
+                            AV_PIX_FMT_P010 : AV_PIX_FMT_NV12;
+    frames_ctx->width = FFALIGN(avctx->coded_width, surface_alignment);
+    frames_ctx->height = FFALIGN(avctx->coded_height, surface_alignment);
+    frames_ctx->initial_pool_size = num_surfaces;
+
+
+#if CONFIG_DXVA2
+    if (frames_ctx->format == AV_PIX_FMT_DXVA2_VLD) {
+        AVDXVA2FramesContext *frames_hwctx = frames_ctx->hwctx;
+
+        frames_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;
+    }
+#endif
+
+#if CONFIG_D3D11VA
+    if (frames_ctx->format == AV_PIX_FMT_D3D11) {
+        AVD3D11VAFramesContext *frames_hwctx = frames_ctx->hwctx;
+
+        frames_hwctx->BindFlags |= D3D11_BIND_DECODER;
+    }
+#endif
+}
+
+int ff_dxva2_decode_init(AVCodecContext *avctx)
+{
+    FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+    AVHWFramesContext *frames_ctx = NULL;
+    int ret = 0;
+
+    // Old API.
+    if (avctx->hwaccel_context)
+        return 0;
+
+    // (avctx->pix_fmt is not updated yet at this point)
+    sctx->pix_fmt = avctx->hwaccel->pix_fmt;
+
+    if (!avctx->hw_frames_ctx && !avctx->hw_device_ctx) {
+        av_log(avctx, AV_LOG_ERROR, "Either a hw_frames_ctx or a hw_device_ctx needs to be set for hardware decoding.\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (avctx->hw_frames_ctx) {
+        frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+    } else {
+        avctx->hw_frames_ctx = av_hwframe_ctx_alloc(avctx->hw_device_ctx);
+        if (!avctx->hw_frames_ctx)
+            return AVERROR(ENOMEM);
+
+        frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+
+        dxva_adjust_hwframes(avctx, frames_ctx);
+
+        ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
+        if (ret < 0)
+            goto fail;
+    }
+
+    sctx->device_ctx = frames_ctx->device_ctx;
+
+    if (frames_ctx->format != sctx->pix_fmt ||
+        !((sctx->pix_fmt == AV_PIX_FMT_D3D11 && CONFIG_D3D11VA) ||
+          (sctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD && CONFIG_DXVA2))) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid pixfmt for hwaccel!\n");
+        ret = AVERROR(EINVAL);
+        goto fail;
+    }
+
+#if CONFIG_D3D11VA
+    if (sctx->pix_fmt == AV_PIX_FMT_D3D11) {
+        AVD3D11VADeviceContext *device_hwctx = frames_ctx->device_ctx->hwctx;
+        AVD3D11VAContext *d3d11_ctx = &sctx->ctx.d3d11va;
+
+        ff_dxva2_lock(avctx);
+        ret = d3d11va_create_decoder(avctx);
+        ff_dxva2_unlock(avctx);
+        if (ret < 0)
+            goto fail;
+
+        d3d11_ctx->decoder       = sctx->d3d11_decoder;
+        d3d11_ctx->video_context = device_hwctx->video_context;
+        d3d11_ctx->cfg           = &sctx->d3d11_config;
+        d3d11_ctx->surface_count = sctx->nb_d3d11_views;
+        d3d11_ctx->surface       = sctx->d3d11_views;
+        d3d11_ctx->workaround    = sctx->workaround;
+        d3d11_ctx->context_mutex = INVALID_HANDLE_VALUE;
+    }
+#endif
+
+#if CONFIG_DXVA2
+    if (sctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD) {
+        AVDXVA2FramesContext *frames_hwctx = frames_ctx->hwctx;
+        struct dxva_context *dxva_ctx = &sctx->ctx.dxva2;
+
+        ff_dxva2_lock(avctx);
+        ret = dxva2_create_decoder(avctx);
+        ff_dxva2_unlock(avctx);
+        if (ret < 0)
+            goto fail;
+
+        dxva_ctx->decoder       = sctx->dxva2_decoder;
+        dxva_ctx->cfg           = &sctx->dxva2_config;
+        dxva_ctx->surface       = frames_hwctx->surfaces;
+        dxva_ctx->surface_count = frames_hwctx->nb_surfaces;
+        dxva_ctx->workaround    = sctx->workaround;
+    }
+#endif
+
+    return 0;
+
+fail:
+    ff_dxva2_decode_uninit(avctx);
+    return ret;
+}
+
+int ff_dxva2_decode_uninit(AVCodecContext *avctx)
+{
+    FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+    int i;
+
+    av_buffer_unref(&sctx->decoder_ref);
+
+#if CONFIG_D3D11VA
+    for (i = 0; i < sctx->nb_d3d11_views; i++) {
+        if (sctx->d3d11_views[i])
+            ID3D11VideoDecoderOutputView_Release(sctx->d3d11_views[i]);
+    }
+    av_freep(&sctx->d3d11_views);
+#endif
+
+#if CONFIG_DXVA2
+    if (sctx->dxva2_service)
+        IDirectXVideoDecoderService_Release(sctx->dxva2_service);
+#endif
+
+    return 0;
+}
+
+static void *get_surface(const AVCodecContext *avctx, const AVFrame *frame)
+{
+#if CONFIG_D3D11VA
+    if (frame->format == AV_PIX_FMT_D3D11) {
+        FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+        intptr_t index = (intptr_t)frame->data[1];
+        if (index < 0 || index >= sctx->nb_d3d11_views ||
+            sctx->d3d11_texture != (ID3D11Texture2D *)frame->data[0]) {
+            av_log((void *)avctx, AV_LOG_ERROR, "get_buffer frame is invalid!\n");
+            return NULL;
+        }
+        return sctx->d3d11_views[index];
+    }
+#endif
     return frame->data[3];
 }
 
@@ -38,23 +770,24 @@ unsigned ff_dxva2_get_surface_index(const AVCodecContext *avctx,
                                     const AVDXVAContext *ctx,
                                     const AVFrame *frame)
 {
-    void *surface = ff_dxva2_get_surface(frame);
+    void *surface = get_surface(avctx, frame);
     unsigned i;
 
-    for (i = 0; i < DXVA_CONTEXT_COUNT(avctx, ctx); i++) {
 #if CONFIG_D3D11VA
-        if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD && ctx->d3d11va.surface[i] == surface)
-        {
-            D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc;
-            ID3D11VideoDecoderOutputView_GetDesc(ctx->d3d11va.surface[i], &viewDesc);
-            return viewDesc.Texture2D.ArraySlice;
-        }
+    if (avctx->pix_fmt == AV_PIX_FMT_D3D11)
+        return (intptr_t)frame->data[1];
+    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+        D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc;
+        ID3D11VideoDecoderOutputView_GetDesc((ID3D11VideoDecoderOutputView*) surface, &viewDesc);
+        return viewDesc.Texture2D.ArraySlice;
+    }
 #endif
 #if CONFIG_DXVA2
+    for (i = 0; i < DXVA_CONTEXT_COUNT(avctx, ctx); i++) {
         if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD && ctx->dxva2.surface[i] == surface)
             return i;
-#endif
     }
+#endif
 
     assert(0);
     return 0;
@@ -72,7 +805,7 @@ int ff_dxva2_commit_buffer(AVCodecContext *avctx,
     HRESULT hr = 0;
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+    if (ff_dxva2_is_d3d11(avctx))
         hr = ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context,
                                                  D3D11VA_CONTEXT(ctx)->decoder,
                                                  type,
@@ -84,15 +817,15 @@ int ff_dxva2_commit_buffer(AVCodecContext *avctx,
                                             &dxva_data, &dxva_size);
 #endif
     if (FAILED(hr)) {
-        av_log(avctx, AV_LOG_ERROR, "Failed to get a buffer for %u: 0x%lx\n",
-               type, hr);
+        av_log(avctx, AV_LOG_ERROR, "Failed to get a buffer for %u: 0x%x\n",
+               type, (unsigned)hr);
         return -1;
     }
     if (size <= dxva_size) {
         memcpy(dxva_data, data, size);
 
 #if CONFIG_D3D11VA
-        if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+        if (ff_dxva2_is_d3d11(avctx)) {
             D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = dsc;
             memset(dsc11, 0, sizeof(*dsc11));
             dsc11->BufferType           = type;
@@ -117,7 +850,7 @@ int ff_dxva2_commit_buffer(AVCodecContext *avctx,
     }
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+    if (ff_dxva2_is_d3d11(avctx))
         hr = ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type);
 #endif
 #if CONFIG_DXVA2
@@ -126,13 +859,29 @@ int ff_dxva2_commit_buffer(AVCodecContext *avctx,
 #endif
     if (FAILED(hr)) {
         av_log(avctx, AV_LOG_ERROR,
-               "Failed to release buffer type %u: 0x%lx\n",
-               type, hr);
+               "Failed to release buffer type %u: 0x%x\n",
+               type, (unsigned)hr);
         result = -1;
     }
     return result;
 }
 
+static int frame_add_buf(AVFrame *frame, AVBufferRef *ref)
+{
+    int i;
+
+    for (i = 0; i < AV_NUM_DATA_POINTERS; i++) {
+        if (!frame->buf[i]) {
+            frame->buf[i] = av_buffer_ref(ref);
+            return frame->buf[i] ? 0 : AVERROR(ENOMEM);
+        }
+    }
+
+    // For now we expect that the caller does not use more than
+    // AV_NUM_DATA_POINTERS-1 buffers if the user uses a custom pool.
+    return AVERROR(EINVAL);
+}
+
 int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
                               const void *pp, unsigned pp_size,
                               const void *qm, unsigned qm_size,
@@ -140,7 +889,7 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
                                                   DECODER_BUFFER_DESC *bs,
                                                   DECODER_BUFFER_DESC *slice))
 {
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     unsigned               buffer_count = 0;
 #if CONFIG_D3D11VA
     D3D11_VIDEO_DECODER_BUFFER_DESC buffer11[4];
@@ -152,45 +901,42 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
     int result, runs = 0;
     HRESULT hr;
     unsigned type;
+    FFDXVASharedContext *sctx = DXVA_SHARED_CONTEXT(avctx);
+
+    if (sctx->decoder_ref) {
+        result = frame_add_buf(frame, sctx->decoder_ref);
+        if (result < 0)
+            return result;
+    }
 
     do {
+        ff_dxva2_lock(avctx);
 #if CONFIG_D3D11VA
-        if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
-            if (D3D11VA_CONTEXT(ctx)->context_mutex != INVALID_HANDLE_VALUE)
-                WaitForSingleObjectEx(D3D11VA_CONTEXT(ctx)->context_mutex, INFINITE, FALSE);
+        if (ff_dxva2_is_d3d11(avctx))
             hr = ID3D11VideoContext_DecoderBeginFrame(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder,
-                                                      ff_dxva2_get_surface(frame),
+                                                      get_surface(avctx, frame),
                                                       0, NULL);
-        }
 #endif
 #if CONFIG_DXVA2
         if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD)
             hr = IDirectXVideoDecoder_BeginFrame(DXVA2_CONTEXT(ctx)->decoder,
-                                                 ff_dxva2_get_surface(frame),
+                                                 get_surface(avctx, frame),
                                                  NULL);
 #endif
         if (hr != E_PENDING || ++runs > 50)
             break;
-#if CONFIG_D3D11VA
-        if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
-            if (D3D11VA_CONTEXT(ctx)->context_mutex != INVALID_HANDLE_VALUE)
-                ReleaseMutex(D3D11VA_CONTEXT(ctx)->context_mutex);
-#endif
+        ff_dxva2_unlock(avctx);
         av_usleep(2000);
     } while(1);
 
     if (FAILED(hr)) {
-        av_log(avctx, AV_LOG_ERROR, "Failed to begin frame: 0x%lx\n", hr);
-#if CONFIG_D3D11VA
-        if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
-            if (D3D11VA_CONTEXT(ctx)->context_mutex != INVALID_HANDLE_VALUE)
-                ReleaseMutex(D3D11VA_CONTEXT(ctx)->context_mutex);
-#endif
+        av_log(avctx, AV_LOG_ERROR, "Failed to begin frame: 0x%x\n", (unsigned)hr);
+        ff_dxva2_unlock(avctx);
         return -1;
     }
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         buffer = &buffer11[buffer_count];
         type = D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS;
     }
@@ -213,7 +959,7 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
 
     if (qm_size > 0) {
 #if CONFIG_D3D11VA
-        if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+        if (ff_dxva2_is_d3d11(avctx)) {
             buffer = &buffer11[buffer_count];
             type = D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX;
         }
@@ -236,7 +982,7 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
     }
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         buffer       = &buffer11[buffer_count + 0];
         buffer_slice = &buffer11[buffer_count + 1];
     }
@@ -263,7 +1009,7 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
     assert(buffer_count == 1 + (qm_size > 0) + 2);
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+    if (ff_dxva2_is_d3d11(avctx))
         hr = ID3D11VideoContext_SubmitDecoderBuffers(D3D11VA_CONTEXT(ctx)->video_context,
                                                      D3D11VA_CONTEXT(ctx)->decoder,
                                                      buffer_count, buffer11);
@@ -279,26 +1025,33 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
     }
 #endif
     if (FAILED(hr)) {
-        av_log(avctx, AV_LOG_ERROR, "Failed to execute: 0x%lx\n", hr);
+        av_log(avctx, AV_LOG_ERROR, "Failed to execute: 0x%x\n", (unsigned)hr);
         result = -1;
     }
 
 end:
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx))
         hr = ID3D11VideoContext_DecoderEndFrame(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder);
-        if (D3D11VA_CONTEXT(ctx)->context_mutex != INVALID_HANDLE_VALUE)
-            ReleaseMutex(D3D11VA_CONTEXT(ctx)->context_mutex);
-    }
 #endif
 #if CONFIG_DXVA2
     if (avctx->pix_fmt == AV_PIX_FMT_DXVA2_VLD)
         hr = IDirectXVideoDecoder_EndFrame(DXVA2_CONTEXT(ctx)->decoder, NULL);
 #endif
+    ff_dxva2_unlock(avctx);
     if (FAILED(hr)) {
-        av_log(avctx, AV_LOG_ERROR, "Failed to end frame: 0x%lx\n", hr);
+        av_log(avctx, AV_LOG_ERROR, "Failed to end frame: 0x%x\n", (unsigned)hr);
         result = -1;
     }
 
     return result;
 }
+
+int ff_dxva2_is_d3d11(const AVCodecContext *avctx)
+{
+    if (CONFIG_D3D11VA)
+        return avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD ||
+               avctx->pix_fmt == AV_PIX_FMT_D3D11;
+    else
+        return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/dxva2_h264.c b/mythtv/external/FFmpeg/libavcodec/dxva2_h264.c
index 82a772d38ba..e3a3f7866ed 100644
--- a/mythtv/external/FFmpeg/libavcodec/dxva2_h264.c
+++ b/mythtv/external/FFmpeg/libavcodec/dxva2_h264.c
@@ -222,7 +222,7 @@ static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice,
 {
     const H264Context *h = avctx->priv_data;
     H264SliceContext *sl = &h->slice_ctx[0];
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     unsigned list;
 
     memset(slice, 0, sizeof(*slice));
@@ -304,7 +304,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
 {
     const H264Context *h = avctx->priv_data;
     const unsigned mb_count = h->mb_width * h->mb_height;
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     const H264Picture *current_picture = h->cur_pic_ptr;
     struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
     DXVA_Slice_H264_Short *slice = NULL;
@@ -319,7 +319,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
 
     /* Create an annex B bitstream buffer with only slice NAL and finalize slice */
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         type = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM;
         if (FAILED(ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context,
                                                        D3D11VA_CONTEXT(ctx)->decoder,
@@ -390,7 +390,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
         slice->SliceBytesInBuffer += padding;
     }
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+    if (ff_dxva2_is_d3d11(avctx))
         if (FAILED(ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type)))
             return -1;
 #endif
@@ -403,7 +403,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
         return -1;
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = bs;
         memset(dsc11, 0, sizeof(*dsc11));
         dsc11->BufferType           = type;
@@ -447,12 +447,10 @@ static int dxva2_h264_start_frame(AVCodecContext *avctx,
                                   av_unused uint32_t size)
 {
     const H264Context *h = avctx->priv_data;
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     struct dxva2_picture_context *ctx_pic = h->cur_pic_ptr->hwaccel_picture_private;
 
-    if (DXVA_CONTEXT_DECODER(avctx, ctx) == NULL ||
-        DXVA_CONTEXT_CFG(avctx, ctx) == NULL ||
-        DXVA_CONTEXT_COUNT(avctx, ctx) <= 0)
+    if (!DXVA_CONTEXT_VALID(avctx, ctx))
         return -1;
     assert(ctx_pic);
 
@@ -474,7 +472,7 @@ static int dxva2_h264_decode_slice(AVCodecContext *avctx,
 {
     const H264Context *h = avctx->priv_data;
     const H264SliceContext *sl = &h->slice_ctx[0];
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     const H264Picture *current_picture = h->cur_pic_ptr;
     struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
     unsigned position;
@@ -525,10 +523,13 @@ AVHWAccel ff_h264_dxva2_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H264,
     .pix_fmt        = AV_PIX_FMT_DXVA2_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_h264_start_frame,
     .decode_slice   = dxva2_h264_decode_slice,
     .end_frame      = dxva2_h264_end_frame,
     .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
 
@@ -538,9 +539,28 @@ AVHWAccel ff_h264_d3d11va_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H264,
     .pix_fmt        = AV_PIX_FMT_D3D11VA_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_h264_start_frame,
     .decode_slice   = dxva2_h264_decode_slice,
     .end_frame      = dxva2_h264_end_frame,
     .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
+};
+#endif
+
+#if CONFIG_H264_D3D11VA2_HWACCEL
+AVHWAccel ff_h264_d3d11va2_hwaccel = {
+    .name           = "h264_d3d11va2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_H264,
+    .pix_fmt        = AV_PIX_FMT_D3D11,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
+    .start_frame    = dxva2_h264_start_frame,
+    .decode_slice   = dxva2_h264_decode_slice,
+    .end_frame      = dxva2_h264_end_frame,
+    .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/dxva2_hevc.c b/mythtv/external/FFmpeg/libavcodec/dxva2_hevc.c
index 5a312eaf233..88f887a1b5a 100644
--- a/mythtv/external/FFmpeg/libavcodec/dxva2_hevc.c
+++ b/mythtv/external/FFmpeg/libavcodec/dxva2_hevc.c
@@ -22,7 +22,8 @@
 
 #include "libavutil/avassert.h"
 
-#include "hevc.h"
+#include "hevc_data.h"
+#include "hevcdec.h"
 
 // The headers above may include w32threads.h, which uses the original
 // _WIN32_WINNT define, while dxva2_internal.h redefines it to target a
@@ -242,7 +243,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
                                              DECODER_BUFFER_DESC *sc)
 {
     const HEVCContext *h = avctx->priv_data;
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     const HEVCFrame *current_picture = h->ref;
     struct hevc_dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
     DXVA_Slice_HEVC_Short *slice = NULL;
@@ -257,7 +258,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
 
     /* Create an annex B bitstream buffer with only slice NAL and finalize slice */
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         type = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM;
         if (FAILED(ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context,
                                                        D3D11VA_CONTEXT(ctx)->decoder,
@@ -311,7 +312,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
         slice->SliceBytesInBuffer += padding;
     }
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+    if (ff_dxva2_is_d3d11(avctx))
         if (FAILED(ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type)))
             return -1;
 #endif
@@ -324,7 +325,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
         return -1;
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = bs;
         memset(dsc11, 0, sizeof(*dsc11));
         dsc11->BufferType           = type;
@@ -361,12 +362,10 @@ static int dxva2_hevc_start_frame(AVCodecContext *avctx,
                                   av_unused uint32_t size)
 {
     const HEVCContext *h = avctx->priv_data;
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     struct hevc_dxva2_picture_context *ctx_pic = h->ref->hwaccel_picture_private;
 
-    if (DXVA_CONTEXT_DECODER(avctx, ctx) == NULL ||
-        DXVA_CONTEXT_CFG(avctx, ctx) == NULL ||
-        DXVA_CONTEXT_COUNT(avctx, ctx) <= 0)
+    if (!DXVA_CONTEXT_VALID(avctx, ctx))
         return -1;
     av_assert0(ctx_pic);
 
@@ -428,10 +427,13 @@ AVHWAccel ff_hevc_dxva2_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_HEVC,
     .pix_fmt        = AV_PIX_FMT_DXVA2_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_hevc_start_frame,
     .decode_slice   = dxva2_hevc_decode_slice,
     .end_frame      = dxva2_hevc_end_frame,
     .frame_priv_data_size = sizeof(struct hevc_dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
 
@@ -441,9 +443,28 @@ AVHWAccel ff_hevc_d3d11va_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_HEVC,
     .pix_fmt        = AV_PIX_FMT_D3D11VA_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_hevc_start_frame,
     .decode_slice   = dxva2_hevc_decode_slice,
     .end_frame      = dxva2_hevc_end_frame,
     .frame_priv_data_size = sizeof(struct hevc_dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
+};
+#endif
+
+#if CONFIG_HEVC_D3D11VA2_HWACCEL
+AVHWAccel ff_hevc_d3d11va2_hwaccel = {
+    .name           = "hevc_d3d11va2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_HEVC,
+    .pix_fmt        = AV_PIX_FMT_D3D11,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
+    .start_frame    = dxva2_hevc_start_frame,
+    .decode_slice   = dxva2_hevc_decode_slice,
+    .end_frame      = dxva2_hevc_end_frame,
+    .frame_priv_data_size = sizeof(struct hevc_dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/dxva2_internal.h b/mythtv/external/FFmpeg/libavcodec/dxva2_internal.h
index 24adb99272d..352a9db1abd 100644
--- a/mythtv/external/FFmpeg/libavcodec/dxva2_internal.h
+++ b/mythtv/external/FFmpeg/libavcodec/dxva2_internal.h
@@ -32,11 +32,12 @@
 
 #if CONFIG_DXVA2
 #include "dxva2.h"
+#include "libavutil/hwcontext_dxva2.h"
 #endif
 #if CONFIG_D3D11VA
 #include "d3d11va.h"
+#include "libavutil/hwcontext_d3d11va.h"
 #endif
-
 #if HAVE_DXVA_H
 /* When targeting WINAPI_FAMILY_PHONE_APP or WINAPI_FAMILY_APP, dxva.h
  * defines nothing. Force the struct definitions to be visible. */
@@ -47,7 +48,10 @@
 #include <dxva.h>
 #endif
 
+#include "libavutil/hwcontext.h"
+
 #include "avcodec.h"
+#include "internal.h"
 
 typedef void DECODER_BUFFER_DESC;
 
@@ -60,22 +64,55 @@ typedef union {
 #endif
 } AVDXVAContext;
 
+typedef struct FFDXVASharedContext {
+    AVBufferRef *decoder_ref;
+
+    // FF_DXVA2_WORKAROUND_* flags
+    uint64_t workaround;
+
+    // E.g. AV_PIX_FMT_D3D11 (same as AVCodecContext.pix_fmt, except during init)
+    enum AVPixelFormat pix_fmt;
+
+    AVHWDeviceContext *device_ctx;
+
 #if CONFIG_D3D11VA
-#define D3D11VA_CONTEXT(ctx) (&ctx->d3d11va)
+    ID3D11VideoDecoder             *d3d11_decoder;
+    D3D11_VIDEO_DECODER_CONFIG      d3d11_config;
+    ID3D11VideoDecoderOutputView  **d3d11_views;
+    int                          nb_d3d11_views;
+    ID3D11Texture2D                *d3d11_texture;
 #endif
+
 #if CONFIG_DXVA2
-#define DXVA2_CONTEXT(ctx)   (&ctx->dxva2)
+    IDirectXVideoDecoder           *dxva2_decoder;
+    IDirectXVideoDecoderService    *dxva2_service;
+    DXVA2_ConfigPictureDecode       dxva2_config;
 #endif
 
+    // Legacy (but used by code outside of setup)
+    // In generic mode, DXVA_CONTEXT() will return a pointer to this.
+    AVDXVAContext ctx;
+} FFDXVASharedContext;
+
+#define DXVA_SHARED_CONTEXT(avctx) ((FFDXVASharedContext *)((avctx)->internal->hwaccel_priv_data))
+
+#define DXVA_CONTEXT(avctx) (AVDXVAContext *)((avctx)->hwaccel_context ? (avctx)->hwaccel_context : (&(DXVA_SHARED_CONTEXT(avctx)->ctx)))
+
+#define D3D11VA_CONTEXT(ctx) (&ctx->d3d11va)
+#define DXVA2_CONTEXT(ctx)   (&ctx->dxva2)
+
 #if CONFIG_D3D11VA && CONFIG_DXVA2
-#define DXVA_CONTEXT_WORKAROUND(avctx, ctx)     (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD ? ctx->d3d11va.workaround : ctx->dxva2.workaround)
-#define DXVA_CONTEXT_COUNT(avctx, ctx)          (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD ? ctx->d3d11va.surface_count : ctx->dxva2.surface_count)
-#define DXVA_CONTEXT_DECODER(avctx, ctx)        (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD ? ctx->d3d11va.decoder : ctx->dxva2.decoder)
-#define DXVA_CONTEXT_REPORT_ID(avctx, ctx)      (*(avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD ? &ctx->d3d11va.report_id : &ctx->dxva2.report_id))
-#define DXVA_CONTEXT_CFG(avctx, ctx)            (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD ? ctx->d3d11va.cfg : ctx->dxva2.cfg)
-#define DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx)  (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD ? ctx->d3d11va.cfg->ConfigBitstreamRaw : ctx->dxva2.cfg->ConfigBitstreamRaw)
-#define DXVA_CONTEXT_CFG_INTRARESID(avctx, ctx) (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD ? ctx->d3d11va.cfg->ConfigIntraResidUnsigned : ctx->dxva2.cfg->ConfigIntraResidUnsigned)
-#define DXVA_CONTEXT_CFG_RESIDACCEL(avctx, ctx) (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD ? ctx->d3d11va.cfg->ConfigResidDiffAccelerator : ctx->dxva2.cfg->ConfigResidDiffAccelerator)
+#define DXVA_CONTEXT_WORKAROUND(avctx, ctx)     (ff_dxva2_is_d3d11(avctx) ? ctx->d3d11va.workaround : ctx->dxva2.workaround)
+#define DXVA_CONTEXT_COUNT(avctx, ctx)          (ff_dxva2_is_d3d11(avctx) ? ctx->d3d11va.surface_count : ctx->dxva2.surface_count)
+#define DXVA_CONTEXT_DECODER(avctx, ctx)        (ff_dxva2_is_d3d11(avctx) ? ctx->d3d11va.decoder : ctx->dxva2.decoder)
+#define DXVA_CONTEXT_REPORT_ID(avctx, ctx)      (*(ff_dxva2_is_d3d11(avctx) ? &ctx->d3d11va.report_id : &ctx->dxva2.report_id))
+#define DXVA_CONTEXT_CFG(avctx, ctx)            (ff_dxva2_is_d3d11(avctx) ? ctx->d3d11va.cfg : ctx->dxva2.cfg)
+#define DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx)  (ff_dxva2_is_d3d11(avctx) ? ctx->d3d11va.cfg->ConfigBitstreamRaw : ctx->dxva2.cfg->ConfigBitstreamRaw)
+#define DXVA_CONTEXT_CFG_INTRARESID(avctx, ctx) (ff_dxva2_is_d3d11(avctx) ? ctx->d3d11va.cfg->ConfigIntraResidUnsigned : ctx->dxva2.cfg->ConfigIntraResidUnsigned)
+#define DXVA_CONTEXT_CFG_RESIDACCEL(avctx, ctx) (ff_dxva2_is_d3d11(avctx) ? ctx->d3d11va.cfg->ConfigResidDiffAccelerator : ctx->dxva2.cfg->ConfigResidDiffAccelerator)
+#define DXVA_CONTEXT_VALID(avctx, ctx)          (DXVA_CONTEXT_DECODER(avctx, ctx) && \
+                                                 DXVA_CONTEXT_CFG(avctx, ctx)     && \
+                                                 (ff_dxva2_is_d3d11(avctx) || ctx->dxva2.surface_count))
 #elif CONFIG_DXVA2
 #define DXVA_CONTEXT_WORKAROUND(avctx, ctx)     (ctx->dxva2.workaround)
 #define DXVA_CONTEXT_COUNT(avctx, ctx)          (ctx->dxva2.surface_count)
@@ -85,6 +122,7 @@ typedef union {
 #define DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx)  (ctx->dxva2.cfg->ConfigBitstreamRaw)
 #define DXVA_CONTEXT_CFG_INTRARESID(avctx, ctx) (ctx->dxva2.cfg->ConfigIntraResidUnsigned)
 #define DXVA_CONTEXT_CFG_RESIDACCEL(avctx, ctx) (ctx->dxva2.cfg->ConfigResidDiffAccelerator)
+#define DXVA_CONTEXT_VALID(avctx, ctx)          (ctx->dxva2.decoder && ctx->dxva2.cfg && ctx->dxva2.surface_count)
 #elif CONFIG_D3D11VA
 #define DXVA_CONTEXT_WORKAROUND(avctx, ctx)     (ctx->d3d11va.workaround)
 #define DXVA_CONTEXT_COUNT(avctx, ctx)          (ctx->d3d11va.surface_count)
@@ -94,10 +132,9 @@ typedef union {
 #define DXVA_CONTEXT_CFG_BITSTREAM(avctx, ctx)  (ctx->d3d11va.cfg->ConfigBitstreamRaw)
 #define DXVA_CONTEXT_CFG_INTRARESID(avctx, ctx) (ctx->d3d11va.cfg->ConfigIntraResidUnsigned)
 #define DXVA_CONTEXT_CFG_RESIDACCEL(avctx, ctx) (ctx->d3d11va.cfg->ConfigResidDiffAccelerator)
+#define DXVA_CONTEXT_VALID(avctx, ctx)          (ctx->d3d11va.decoder && ctx->d3d11va.cfg)
 #endif
 
-void *ff_dxva2_get_surface(const AVFrame *frame);
-
 unsigned ff_dxva2_get_surface_index(const AVCodecContext *avctx,
                                     const AVDXVAContext *,
                                     const AVFrame *frame);
@@ -115,4 +152,10 @@ int ff_dxva2_common_end_frame(AVCodecContext *, AVFrame *,
                                                   DECODER_BUFFER_DESC *bs,
                                                   DECODER_BUFFER_DESC *slice));
 
+int ff_dxva2_decode_init(AVCodecContext *avctx);
+
+int ff_dxva2_decode_uninit(AVCodecContext *avctx);
+
+int ff_dxva2_is_d3d11(const AVCodecContext *avctx);
+
 #endif /* AVCODEC_DXVA2_INTERNAL_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/dxva2_mpeg2.c b/mythtv/external/FFmpeg/libavcodec/dxva2_mpeg2.c
index c2f0b58beeb..b7c69378f09 100644
--- a/mythtv/external/FFmpeg/libavcodec/dxva2_mpeg2.c
+++ b/mythtv/external/FFmpeg/libavcodec/dxva2_mpeg2.c
@@ -155,7 +155,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
                                              DECODER_BUFFER_DESC *sc)
 {
     const struct MpegEncContext *s = avctx->priv_data;
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     struct dxva2_picture_context *ctx_pic =
         s->current_picture_ptr->hwaccel_picture_private;
     const int is_field = s->picture_structure != PICT_FRAME;
@@ -167,7 +167,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
     unsigned type;
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         type = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM;
         if (FAILED(ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context,
                                                        D3D11VA_CONTEXT(ctx)->decoder,
@@ -211,7 +211,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
         current += size;
     }
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+    if (ff_dxva2_is_d3d11(avctx))
         if (FAILED(ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type)))
             return -1;
 #endif
@@ -224,7 +224,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
         return -1;
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = bs;
         memset(dsc11, 0, sizeof(*dsc11));
         dsc11->BufferType           = type;
@@ -258,13 +258,11 @@ static int dxva2_mpeg2_start_frame(AVCodecContext *avctx,
                                    av_unused uint32_t size)
 {
     const struct MpegEncContext *s = avctx->priv_data;
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     struct dxva2_picture_context *ctx_pic =
         s->current_picture_ptr->hwaccel_picture_private;
 
-    if (DXVA_CONTEXT_DECODER(avctx, ctx) == NULL ||
-        DXVA_CONTEXT_CFG(avctx, ctx) == NULL ||
-        DXVA_CONTEXT_COUNT(avctx, ctx) <= 0)
+    if (!DXVA_CONTEXT_VALID(avctx, ctx))
         return -1;
     assert(ctx_pic);
 
@@ -324,10 +322,13 @@ AVHWAccel ff_mpeg2_dxva2_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_MPEG2VIDEO,
     .pix_fmt        = AV_PIX_FMT_DXVA2_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_mpeg2_start_frame,
     .decode_slice   = dxva2_mpeg2_decode_slice,
     .end_frame      = dxva2_mpeg2_end_frame,
     .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
 
@@ -337,9 +338,28 @@ AVHWAccel ff_mpeg2_d3d11va_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_MPEG2VIDEO,
     .pix_fmt        = AV_PIX_FMT_D3D11VA_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_mpeg2_start_frame,
     .decode_slice   = dxva2_mpeg2_decode_slice,
     .end_frame      = dxva2_mpeg2_end_frame,
     .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
+};
+#endif
+
+#if CONFIG_MPEG2_D3D11VA2_HWACCEL
+AVHWAccel ff_mpeg2_d3d11va2_hwaccel = {
+    .name           = "mpeg2_d3d11va2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_MPEG2VIDEO,
+    .pix_fmt        = AV_PIX_FMT_D3D11,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
+    .start_frame    = dxva2_mpeg2_start_frame,
+    .decode_slice   = dxva2_mpeg2_decode_slice,
+    .end_frame      = dxva2_mpeg2_end_frame,
+    .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/dxva2_vc1.c b/mythtv/external/FFmpeg/libavcodec/dxva2_vc1.c
index 7cbbc7ef753..e5353cdddca 100644
--- a/mythtv/external/FFmpeg/libavcodec/dxva2_vc1.c
+++ b/mythtv/external/FFmpeg/libavcodec/dxva2_vc1.c
@@ -29,9 +29,11 @@
 // potentially newer version.
 #include "dxva2_internal.h"
 
+#define MAX_SLICES 1024
 struct dxva2_picture_context {
     DXVA_PictureParameters pp;
-    DXVA_SliceInfo         si;
+    unsigned               slice_count;
+    DXVA_SliceInfo         slice[MAX_SLICES];
 
     const uint8_t          *bitstream;
     unsigned               bitstream_size;
@@ -174,7 +176,8 @@ static void fill_slice(AVCodecContext *avctx, DXVA_SliceInfo *slice,
     slice->bStartCodeBitOffset = 0;
     slice->bReservedBits       = (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type) ? v->bfraction_lut_index + 9 : 0;
     slice->wMBbitOffset        = v->p_frame_skipped ? 0xffff : get_bits_count(&s->gb) + (avctx->codec_id == AV_CODEC_ID_VC1 ? 32 : 0);
-    slice->wNumberMBsInSlice   = s->mb_width * s->mb_height; /* XXX We assume 1 slice */
+    /* XXX We store the index of the first MB and it will be fixed later */
+    slice->wNumberMBsInSlice   = (s->mb_y >> v->field_mode) * s->mb_width + s->mb_x;
     slice->wQuantizerScaleCode = v->pq;
     slice->wBadSliceChopping   = 0;
 }
@@ -184,26 +187,23 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
                                              DECODER_BUFFER_DESC *sc)
 {
     const VC1Context *v = avctx->priv_data;
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     const MpegEncContext *s = &v->s;
     struct dxva2_picture_context *ctx_pic = s->current_picture_ptr->hwaccel_picture_private;
 
-    DXVA_SliceInfo *slice = &ctx_pic->si;
-
     static const uint8_t start_code[] = { 0, 0, 1, 0x0d };
     const unsigned start_code_size = avctx->codec_id == AV_CODEC_ID_VC1 ? sizeof(start_code) : 0;
-    const unsigned slice_size = slice->dwSliceBitsInBuffer / 8;
-    const unsigned padding = 128 - ((start_code_size + slice_size) & 127);
-    const unsigned data_size = start_code_size + slice_size + padding;
-
+    const unsigned mb_count = s->mb_width * (s->mb_height >> v->field_mode);
+    DXVA_SliceInfo *slice = NULL;
     void     *dxva_data_ptr;
-    uint8_t  *dxva_data;
+    uint8_t  *dxva_data, *current, *end;
     unsigned dxva_size;
-    int result;
+    unsigned padding;
+    unsigned i;
     unsigned type;
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         type = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM;
         if (FAILED(ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context,
                                                        D3D11VA_CONTEXT(ctx)->decoder,
@@ -223,21 +223,51 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
 #endif
 
     dxva_data = dxva_data_ptr;
-    result = data_size <= dxva_size ? 0 : -1;
-    if (!result) {
-        if (start_code_size > 0) {
-            memcpy(dxva_data, start_code, start_code_size);
-            if (v->second_field)
-                dxva_data[3] = 0x0c;
+    current = dxva_data;
+    end = dxva_data + dxva_size;
+
+    for (i = 0; i < ctx_pic->slice_count; i++) {
+        unsigned position, size;
+        slice    = &ctx_pic->slice[i];
+        position = slice->dwSliceDataLocation;
+        size     = slice->dwSliceBitsInBuffer / 8;
+        if (start_code_size + size > end - current) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to build bitstream");
+            break;
         }
-        memcpy(dxva_data + start_code_size,
-               ctx_pic->bitstream + slice->dwSliceDataLocation, slice_size);
-        if (padding > 0)
-            memset(dxva_data + start_code_size + slice_size, 0, padding);
-        slice->dwSliceBitsInBuffer = 8 * data_size;
+        slice->dwSliceDataLocation = current - dxva_data;
+
+        if (i < ctx_pic->slice_count - 1)
+            slice->wNumberMBsInSlice =
+                slice[1].wNumberMBsInSlice - slice[0].wNumberMBsInSlice;
+        else
+            slice->wNumberMBsInSlice =
+                mb_count - slice[0].wNumberMBsInSlice;
+
+        /* write the appropriate frame, field or slice start code */
+        if (start_code_size) {
+            memcpy(current, start_code, start_code_size);
+            if (i == 0 && v->second_field)
+                current[3] = 0x0c;
+            else if (i > 0)
+                current[3] = 0x0b;
+
+            current += start_code_size;
+            slice->dwSliceBitsInBuffer += start_code_size * 8;
+        }
+
+        memcpy(current, &ctx_pic->bitstream[position], size);
+        current += size;
     }
+    padding = FFMIN(128 - ((current - dxva_data) & 127), end - current);
+    if (slice && padding > 0) {
+        memset(current, 0, padding);
+        current += padding;
+        slice->dwSliceBitsInBuffer += padding * 8;
+    }
+
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+    if (ff_dxva2_is_d3d11(avctx))
         if (FAILED(ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type)))
             return -1;
 #endif
@@ -246,16 +276,16 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
         if (FAILED(IDirectXVideoDecoder_ReleaseBuffer(DXVA2_CONTEXT(ctx)->decoder, type)))
             return -1;
 #endif
-    if (result)
-        return result;
+    if (i < ctx_pic->slice_count)
+        return -1;
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = bs;
         memset(dsc11, 0, sizeof(*dsc11));
         dsc11->BufferType           = type;
-        dsc11->DataSize             = data_size;
-        dsc11->NumMBsInBuffer       = s->mb_width * s->mb_height;
+        dsc11->DataSize             = current - dxva_data;
+        dsc11->NumMBsInBuffer       = mb_count;
 
         type = D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL;
     }
@@ -265,17 +295,18 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
         DXVA2_DecodeBufferDesc *dsc2 = bs;
         memset(dsc2, 0, sizeof(*dsc2));
         dsc2->CompressedBufferType = type;
-        dsc2->DataSize             = data_size;
-        dsc2->NumMBsInBuffer       = s->mb_width * s->mb_height;
+        dsc2->DataSize             = current - dxva_data;
+        dsc2->NumMBsInBuffer       = mb_count;
 
         type = DXVA2_SliceControlBufferType;
     }
 #endif
-    assert((data_size & 127) == 0);
 
     return ff_dxva2_commit_buffer(avctx, ctx, sc,
                                   type,
-                                  slice, sizeof(*slice), s->mb_width * s->mb_height);
+                                  ctx_pic->slice,
+                                  ctx_pic->slice_count * sizeof(*ctx_pic->slice),
+                                  mb_count);
 }
 
 static int dxva2_vc1_start_frame(AVCodecContext *avctx,
@@ -283,17 +314,16 @@ static int dxva2_vc1_start_frame(AVCodecContext *avctx,
                                  av_unused uint32_t size)
 {
     const VC1Context *v = avctx->priv_data;
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private;
 
-    if (DXVA_CONTEXT_DECODER(avctx, ctx) == NULL ||
-        DXVA_CONTEXT_CFG(avctx, ctx) == NULL ||
-        DXVA_CONTEXT_COUNT(avctx, ctx) <= 0)
+    if (!DXVA_CONTEXT_VALID(avctx, ctx))
         return -1;
     assert(ctx_pic);
 
     fill_picture_parameters(avctx, ctx, v, &ctx_pic->pp);
 
+    ctx_pic->slice_count    = 0;
     ctx_pic->bitstream_size = 0;
     ctx_pic->bitstream      = NULL;
     return 0;
@@ -306,9 +336,13 @@ static int dxva2_vc1_decode_slice(AVCodecContext *avctx,
     const VC1Context *v = avctx->priv_data;
     const Picture *current_picture = v->s.current_picture_ptr;
     struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
+    unsigned position;
 
-    if (ctx_pic->bitstream_size > 0)
+    if (ctx_pic->slice_count >= MAX_SLICES) {
+        avpriv_request_sample(avctx, "%d slices in dxva2",
+                              ctx_pic->slice_count);
         return -1;
+    }
 
     if (avctx->codec_id == AV_CODEC_ID_VC1 &&
         size >= 4 && IS_MARKER(AV_RB32(buffer))) {
@@ -316,10 +350,12 @@ static int dxva2_vc1_decode_slice(AVCodecContext *avctx,
         size   -= 4;
     }
 
-    ctx_pic->bitstream_size = size;
-    ctx_pic->bitstream      = buffer;
+    if (!ctx_pic->bitstream)
+        ctx_pic->bitstream = buffer;
+    ctx_pic->bitstream_size += size;
 
-    fill_slice(avctx, &ctx_pic->si, 0, size);
+    position = buffer - ctx_pic->bitstream;
+    fill_slice(avctx, &ctx_pic->slice[ctx_pic->slice_count++], position, size);
     return 0;
 }
 
@@ -329,7 +365,7 @@ static int dxva2_vc1_end_frame(AVCodecContext *avctx)
     struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->hwaccel_picture_private;
     int ret;
 
-    if (ctx_pic->bitstream_size <= 0)
+    if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0)
         return -1;
 
     ret = ff_dxva2_common_end_frame(avctx, v->s.current_picture_ptr->f,
@@ -347,10 +383,13 @@ AVHWAccel ff_wmv3_dxva2_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_WMV3,
     .pix_fmt        = AV_PIX_FMT_DXVA2_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_vc1_start_frame,
     .decode_slice   = dxva2_vc1_decode_slice,
     .end_frame      = dxva2_vc1_end_frame,
     .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
 
@@ -360,10 +399,13 @@ AVHWAccel ff_vc1_dxva2_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_VC1,
     .pix_fmt        = AV_PIX_FMT_DXVA2_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_vc1_start_frame,
     .decode_slice   = dxva2_vc1_decode_slice,
     .end_frame      = dxva2_vc1_end_frame,
     .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
 
@@ -373,10 +415,29 @@ AVHWAccel ff_wmv3_d3d11va_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_WMV3,
     .pix_fmt        = AV_PIX_FMT_D3D11VA_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
+    .start_frame    = dxva2_vc1_start_frame,
+    .decode_slice   = dxva2_vc1_decode_slice,
+    .end_frame      = dxva2_vc1_end_frame,
+    .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
+};
+#endif
+
+#if CONFIG_WMV3_D3D11VA2_HWACCEL
+AVHWAccel ff_wmv3_d3d11va2_hwaccel = {
+    .name           = "wmv3_d3d11va2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_WMV3,
+    .pix_fmt        = AV_PIX_FMT_D3D11,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_vc1_start_frame,
     .decode_slice   = dxva2_vc1_decode_slice,
     .end_frame      = dxva2_vc1_end_frame,
     .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
 
@@ -386,9 +447,28 @@ AVHWAccel ff_vc1_d3d11va_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_VC1,
     .pix_fmt        = AV_PIX_FMT_D3D11VA_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
+    .start_frame    = dxva2_vc1_start_frame,
+    .decode_slice   = dxva2_vc1_decode_slice,
+    .end_frame      = dxva2_vc1_end_frame,
+    .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
+};
+#endif
+
+#if CONFIG_VC1_D3D11VA2_HWACCEL
+AVHWAccel ff_vc1_d3d11va2_hwaccel = {
+    .name           = "vc1_d3d11va2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_VC1,
+    .pix_fmt        = AV_PIX_FMT_D3D11,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_vc1_start_frame,
     .decode_slice   = dxva2_vc1_decode_slice,
     .end_frame      = dxva2_vc1_end_frame,
     .frame_priv_data_size = sizeof(struct dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/dxva2_vp9.c b/mythtv/external/FFmpeg/libavcodec/dxva2_vp9.c
index 0c4996c0209..6d87fdd9f24 100644
--- a/mythtv/external/FFmpeg/libavcodec/dxva2_vp9.c
+++ b/mythtv/external/FFmpeg/libavcodec/dxva2_vp9.c
@@ -23,7 +23,7 @@
 #include "libavutil/avassert.h"
 #include "libavutil/pixdesc.h"
 
-#include "vp9.h"
+#include "vp9shared.h"
 
 // The headers above may include w32threads.h, which uses the original
 // _WIN32_WINNT define, while dxva2_internal.h redefines it to target a
@@ -170,7 +170,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
                                              DECODER_BUFFER_DESC *sc)
 {
     const VP9SharedContext *h = avctx->priv_data;
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     struct vp9_dxva2_picture_context *ctx_pic = h->frames[CUR_FRAME].hwaccel_picture_private;
     void     *dxva_data_ptr;
     uint8_t  *dxva_data;
@@ -179,7 +179,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
     unsigned type;
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         type = D3D11_VIDEO_DECODER_BUFFER_BITSTREAM;
         if (FAILED(ID3D11VideoContext_GetDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context,
                                                        D3D11VA_CONTEXT(ctx)->decoder,
@@ -214,7 +214,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
     }
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD)
+    if (ff_dxva2_is_d3d11(avctx))
         if (FAILED(ID3D11VideoContext_ReleaseDecoderBuffer(D3D11VA_CONTEXT(ctx)->video_context, D3D11VA_CONTEXT(ctx)->decoder, type)))
             return -1;
 #endif
@@ -225,7 +225,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
 #endif
 
 #if CONFIG_D3D11VA
-    if (avctx->pix_fmt == AV_PIX_FMT_D3D11VA_VLD) {
+    if (ff_dxva2_is_d3d11(avctx)) {
         D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = bs;
         memset(dsc11, 0, sizeof(*dsc11));
         dsc11->BufferType           = type;
@@ -258,12 +258,10 @@ static int dxva2_vp9_start_frame(AVCodecContext *avctx,
                                  av_unused uint32_t size)
 {
     const VP9SharedContext *h = avctx->priv_data;
-    AVDXVAContext *ctx = avctx->hwaccel_context;
+    AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     struct vp9_dxva2_picture_context *ctx_pic = h->frames[CUR_FRAME].hwaccel_picture_private;
 
-    if (DXVA_CONTEXT_DECODER(avctx, ctx) == NULL ||
-        DXVA_CONTEXT_CFG(avctx, ctx) == NULL ||
-        DXVA_CONTEXT_COUNT(avctx, ctx) <= 0)
+    if (!DXVA_CONTEXT_VALID(avctx, ctx))
         return -1;
     av_assert0(ctx_pic);
 
@@ -316,10 +314,13 @@ AVHWAccel ff_vp9_dxva2_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_VP9,
     .pix_fmt        = AV_PIX_FMT_DXVA2_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_vp9_start_frame,
     .decode_slice   = dxva2_vp9_decode_slice,
     .end_frame      = dxva2_vp9_end_frame,
     .frame_priv_data_size = sizeof(struct vp9_dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
 
@@ -329,9 +330,28 @@ AVHWAccel ff_vp9_d3d11va_hwaccel = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_VP9,
     .pix_fmt        = AV_PIX_FMT_D3D11VA_VLD,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
     .start_frame    = dxva2_vp9_start_frame,
     .decode_slice   = dxva2_vp9_decode_slice,
     .end_frame      = dxva2_vp9_end_frame,
     .frame_priv_data_size = sizeof(struct vp9_dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
+};
+#endif
+
+#if CONFIG_VP9_D3D11VA2_HWACCEL
+AVHWAccel ff_vp9_d3d11va2_hwaccel = {
+    .name           = "vp9_d3d11va2",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_VP9,
+    .pix_fmt        = AV_PIX_FMT_D3D11,
+    .init           = ff_dxva2_decode_init,
+    .uninit         = ff_dxva2_decode_uninit,
+    .start_frame    = dxva2_vp9_start_frame,
+    .decode_slice   = dxva2_vp9_decode_slice,
+    .end_frame      = dxva2_vp9_end_frame,
+    .frame_priv_data_size = sizeof(struct vp9_dxva2_picture_context),
+    .priv_data_size = sizeof(FFDXVASharedContext),
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/eac3dec.c b/mythtv/external/FFmpeg/libavcodec/eac3dec.c
index 83a54bcfab9..c971879b2dc 100644
--- a/mythtv/external/FFmpeg/libavcodec/eac3dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/eac3dec.c
@@ -252,7 +252,7 @@ static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
             /* Vector Quantization */
             int v = get_bits(gbc, bits);
             for (blk = 0; blk < 6; blk++) {
-                s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8;
+                s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] * (1 << 8);
             }
         } else {
             /* Gain Adaptive Quantization */
@@ -271,16 +271,16 @@ static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)
                     int b;
                     int mbits = bits - (2 - log_gain);
                     mant = get_sbits(gbc, mbits);
-                    mant <<= (23 - (mbits - 1));
+                    mant = ((unsigned)mant) << (23 - (mbits - 1));
                     /* remap mantissa value to correct for asymmetric quantization */
                     if (mant >= 0)
                         b = 1 << (23 - log_gain);
                     else
-                        b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] << 8;
+                        b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] * (1 << 8);
                     mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b;
                 } else {
                     /* small mantissa, no GAQ, or Gk=1 */
-                    mant <<= 24 - bits;
+                    mant *= (1 << 24 - bits);
                     if (!log_gain) {
                         /* remap mantissa value for no GAQ or Gk=1 */
                         mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15;
diff --git a/mythtv/external/FFmpeg/libavcodec/eacmv.c b/mythtv/external/FFmpeg/libavcodec/eacmv.c
index 047be813b10..bf4404ce426 100644
--- a/mythtv/external/FFmpeg/libavcodec/eacmv.c
+++ b/mythtv/external/FFmpeg/libavcodec/eacmv.c
@@ -72,8 +72,8 @@ static void cmv_decode_intra(CmvContext * s, AVFrame *frame,
     }
 }
 
-static void cmv_motcomp(unsigned char *dst, int dst_stride,
-                        const unsigned char *src, int src_stride,
+static void cmv_motcomp(unsigned char *dst, ptrdiff_t dst_stride,
+                        const unsigned char *src, ptrdiff_t src_stride,
                         int x, int y,
                         int xoffset, int yoffset,
                         int width, int height){
diff --git a/mythtv/external/FFmpeg/libavcodec/eaidct.c b/mythtv/external/FFmpeg/libavcodec/eaidct.c
index e4840f26535..038ee2ac7a9 100644
--- a/mythtv/external/FFmpeg/libavcodec/eaidct.c
+++ b/mythtv/external/FFmpeg/libavcodec/eaidct.c
@@ -77,7 +77,8 @@ static inline void ea_idct_col(int16_t *dest, const int16_t *src) {
         IDCT_COL(dest, src);
 }
 
-void ff_ea_idct_put_c(uint8_t *dest, int linesize, int16_t *block) {
+void ff_ea_idct_put_c(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
+{
     int i;
     int16_t temp[64];
     block[0] += 4;
diff --git a/mythtv/external/FFmpeg/libavcodec/eaidct.h b/mythtv/external/FFmpeg/libavcodec/eaidct.h
index 6b9ec1c91c8..a46dae939b6 100644
--- a/mythtv/external/FFmpeg/libavcodec/eaidct.h
+++ b/mythtv/external/FFmpeg/libavcodec/eaidct.h
@@ -19,8 +19,9 @@
 #ifndef AVCODEC_EAIDCT_H
 #define AVCODEC_EAIDCT_H
 
+#include <stddef.h>
 #include <stdint.h>
 
-void ff_ea_idct_put_c(uint8_t *dest, int linesize, int16_t *block);
+void ff_ea_idct_put_c(uint8_t *dest, ptrdiff_t linesize, int16_t *block);
 
 #endif /* AVCODEC_EAIDCT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/eamad.c b/mythtv/external/FFmpeg/libavcodec/eamad.c
index bb0f0053ff3..7f28abbafea 100644
--- a/mythtv/external/FFmpeg/libavcodec/eamad.c
+++ b/mythtv/external/FFmpeg/libavcodec/eamad.c
@@ -54,7 +54,7 @@ typedef struct MadContext {
     GetBitContext gb;
     void *bitstream_buf;
     unsigned int bitstream_buf_size;
-    DECLARE_ALIGNED(16, int16_t, block)[64];
+    DECLARE_ALIGNED(32, int16_t, block)[64];
     ScanTable scantable;
     uint16_t quant_matrix[64];
     int mb_x;
@@ -80,8 +80,8 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-static inline void comp(unsigned char *dst, int dst_stride,
-                        unsigned char *src, int src_stride, int add)
+static inline void comp(unsigned char *dst, ptrdiff_t dst_stride,
+                        unsigned char *src, ptrdiff_t src_stride, int add)
 {
     int j, i;
     for (j=0; j<8; j++)
@@ -284,7 +284,7 @@ static int decode_frame(AVCodecContext *avctx,
 
     if (avctx->width != width || avctx->height != height) {
         av_frame_unref(s->last_frame);
-        if((width * height)/2048*7 > bytestream2_get_bytes_left(&gb))
+        if((width * (int64_t)height)/2048*7 > bytestream2_get_bytes_left(&gb))
             return AVERROR_INVALIDDATA;
         if ((ret = ff_set_dimensions(avctx, width, height)) < 0)
             return ret;
diff --git a/mythtv/external/FFmpeg/libavcodec/eatgq.c b/mythtv/external/FFmpeg/libavcodec/eatgq.c
index a43d688e721..1308c07cff4 100644
--- a/mythtv/external/FFmpeg/libavcodec/eatgq.c
+++ b/mythtv/external/FFmpeg/libavcodec/eatgq.c
@@ -107,7 +107,7 @@ static void tgq_decode_block(TgqContext *s, int16_t block[64], GetBitContext *gb
 static void tgq_idct_put_mb(TgqContext *s, int16_t (*block)[64], AVFrame *frame,
                             int mb_x, int mb_y)
 {
-    int linesize = frame->linesize[0];
+    ptrdiff_t linesize = frame->linesize[0];
     uint8_t *dest_y  = frame->data[0] + (mb_y * 16 * linesize)           + mb_x * 16;
     uint8_t *dest_cb = frame->data[1] + (mb_y * 8  * frame->linesize[1]) + mb_x * 8;
     uint8_t *dest_cr = frame->data[2] + (mb_y * 8  * frame->linesize[2]) + mb_x * 8;
@@ -123,7 +123,7 @@ static void tgq_idct_put_mb(TgqContext *s, int16_t (*block)[64], AVFrame *frame,
 }
 
 static inline void tgq_dconly(TgqContext *s, unsigned char *dst,
-                              int dst_stride, int dc)
+                              ptrdiff_t dst_stride, int dc)
 {
     int level = av_clip_uint8((dc*s->qtable[0] + 2056) >> 4);
     int j;
@@ -134,7 +134,7 @@ static inline void tgq_dconly(TgqContext *s, unsigned char *dst,
 static void tgq_idct_put_mb_dconly(TgqContext *s, AVFrame *frame,
                                    int mb_x, int mb_y, const int8_t *dc)
 {
-    int linesize = frame->linesize[0];
+    ptrdiff_t linesize = frame->linesize[0];
     uint8_t *dest_y  = frame->data[0] + (mb_y * 16 * linesize)             + mb_x * 16;
     uint8_t *dest_cb = frame->data[1] + (mb_y * 8  * frame->linesize[1]) + mb_x * 8;
     uint8_t *dest_cr = frame->data[2] + (mb_y * 8  * frame->linesize[2]) + mb_x * 8;
diff --git a/mythtv/external/FFmpeg/libavcodec/eatgv.c b/mythtv/external/FFmpeg/libavcodec/eatgv.c
index 60399c5593e..93e291f0534 100644
--- a/mythtv/external/FFmpeg/libavcodec/eatgv.c
+++ b/mythtv/external/FFmpeg/libavcodec/eatgv.c
@@ -227,7 +227,7 @@ static int tgv_decode_inter(TgvContext *s, AVFrame *frame,
         for (x = 0; x < s->avctx->width / 4; x++) {
             unsigned int vector = get_bits(&gb, vector_bits);
             const uint8_t *src;
-            int src_stride;
+            ptrdiff_t src_stride;
 
             if (vector < num_mvs) {
                 int mx = x * 4 + s->mv_codebook[vector][0];
diff --git a/mythtv/external/FFmpeg/libavcodec/eatqi.c b/mythtv/external/FFmpeg/libavcodec/eatqi.c
index 8fd5cdb17f6..1a847a35da4 100644
--- a/mythtv/external/FFmpeg/libavcodec/eatqi.c
+++ b/mythtv/external/FFmpeg/libavcodec/eatqi.c
@@ -51,7 +51,7 @@ typedef struct TqiContext {
     uint16_t intra_matrix[64];
     int last_dc[3];
 
-    DECLARE_ALIGNED(16, int16_t, block)[6][64];
+    DECLARE_ALIGNED(32, int16_t, block)[6][64];
 } TqiContext;
 
 static av_cold int tqi_decode_init(AVCodecContext *avctx)
@@ -94,7 +94,7 @@ static inline void tqi_idct_put(AVCodecContext *avctx, AVFrame *frame,
                                 int16_t (*block)[64])
 {
     TqiContext *t = avctx->priv_data;
-    int linesize = frame->linesize[0];
+    ptrdiff_t linesize = frame->linesize[0];
     uint8_t *dest_y  = frame->data[0] + t->mb_y * 16 * linesize           + t->mb_x * 16;
     uint8_t *dest_cb = frame->data[1] + t->mb_y *  8 * frame->linesize[1] + t->mb_x *  8;
     uint8_t *dest_cr = frame->data[2] + t->mb_y *  8 * frame->linesize[2] + t->mb_x *  8;
@@ -112,7 +112,7 @@ static inline void tqi_idct_put(AVCodecContext *avctx, AVFrame *frame,
 
 static void tqi_calculate_qtable(TqiContext *t, int quant)
 {
-    const int qscale = (215 - 2*quant)*5;
+    const int64_t qscale = (215 - 2*quant)*5;
     int i;
 
     t->intra_matrix[0] = (ff_inv_aanscales[0] * ff_mpeg1_default_intra_matrix[0]) >> 11;
diff --git a/mythtv/external/FFmpeg/libavcodec/encode.c b/mythtv/external/FFmpeg/libavcodec/encode.c
new file mode 100644
index 00000000000..c961dbace10
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/encode.c
@@ -0,0 +1,460 @@
+/*
+ * generic encoding-related code
+ *
+ * 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 "libavutil/avassert.h"
+#include "libavutil/frame.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/internal.h"
+#include "libavutil/samplefmt.h"
+
+#include "avcodec.h"
+#include "frame_thread_encoder.h"
+#include "internal.h"
+
+int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
+{
+    if (avpkt->size < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid negative user packet size %d\n", avpkt->size);
+        return AVERROR(EINVAL);
+    }
+    if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid minimum required packet size %"PRId64" (max allowed is %d)\n",
+               size, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
+        return AVERROR(EINVAL);
+    }
+
+    if (avctx && 2*min_size < size) { // FIXME The factor needs to be finetuned
+        av_assert0(!avpkt->data || avpkt->data != avctx->internal->byte_buffer);
+        if (!avpkt->data || avpkt->size < size) {
+            av_fast_padded_malloc(&avctx->internal->byte_buffer, &avctx->internal->byte_buffer_size, size);
+            avpkt->data = avctx->internal->byte_buffer;
+            avpkt->size = avctx->internal->byte_buffer_size;
+        }
+    }
+
+    if (avpkt->data) {
+        AVBufferRef *buf = avpkt->buf;
+
+        if (avpkt->size < size) {
+            av_log(avctx, AV_LOG_ERROR, "User packet is too small (%d < %"PRId64")\n", avpkt->size, size);
+            return AVERROR(EINVAL);
+        }
+
+        av_init_packet(avpkt);
+        avpkt->buf      = buf;
+        avpkt->size     = size;
+        return 0;
+    } else {
+        int ret = av_new_packet(avpkt, size);
+        if (ret < 0)
+            av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %"PRId64"\n", size);
+        return ret;
+    }
+}
+
+int ff_alloc_packet(AVPacket *avpkt, int size)
+{
+    return ff_alloc_packet2(NULL, avpkt, size, 0);
+}
+
+/**
+ * Pad last frame with silence.
+ */
+static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
+{
+    AVFrame *frame = NULL;
+    int ret;
+
+    if (!(frame = av_frame_alloc()))
+        return AVERROR(ENOMEM);
+
+    frame->format         = src->format;
+    frame->channel_layout = src->channel_layout;
+    frame->channels       = src->channels;
+    frame->nb_samples     = s->frame_size;
+    ret = av_frame_get_buffer(frame, 32);
+    if (ret < 0)
+        goto fail;
+
+    ret = av_frame_copy_props(frame, src);
+    if (ret < 0)
+        goto fail;
+
+    if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
+                               src->nb_samples, s->channels, s->sample_fmt)) < 0)
+        goto fail;
+    if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
+                                      frame->nb_samples - src->nb_samples,
+                                      s->channels, s->sample_fmt)) < 0)
+        goto fail;
+
+    *dst = frame;
+
+    return 0;
+
+fail:
+    av_frame_free(&frame);
+    return ret;
+}
+
+int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
+                                              AVPacket *avpkt,
+                                              const AVFrame *frame,
+                                              int *got_packet_ptr)
+{
+    AVFrame *extended_frame = NULL;
+    AVFrame *padded_frame = NULL;
+    int ret;
+    AVPacket user_pkt = *avpkt;
+    int needs_realloc = !user_pkt.data;
+
+    *got_packet_ptr = 0;
+
+    if (!avctx->codec->encode2) {
+        av_log(avctx, AV_LOG_ERROR, "This encoder requires using the avcodec_send_frame() API.\n");
+        return AVERROR(ENOSYS);
+    }
+
+    if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
+        av_packet_unref(avpkt);
+        av_init_packet(avpkt);
+        return 0;
+    }
+
+    /* ensure that extended_data is properly set */
+    if (frame && !frame->extended_data) {
+        if (av_sample_fmt_is_planar(avctx->sample_fmt) &&
+            avctx->channels > AV_NUM_DATA_POINTERS) {
+            av_log(avctx, AV_LOG_ERROR, "Encoding to a planar sample format, "
+                                        "with more than %d channels, but extended_data is not set.\n",
+                   AV_NUM_DATA_POINTERS);
+            return AVERROR(EINVAL);
+        }
+        av_log(avctx, AV_LOG_WARNING, "extended_data is not set.\n");
+
+        extended_frame = av_frame_alloc();
+        if (!extended_frame)
+            return AVERROR(ENOMEM);
+
+        memcpy(extended_frame, frame, sizeof(AVFrame));
+        extended_frame->extended_data = extended_frame->data;
+        frame = extended_frame;
+    }
+
+    /* extract audio service type metadata */
+    if (frame) {
+        AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_AUDIO_SERVICE_TYPE);
+        if (sd && sd->size >= sizeof(enum AVAudioServiceType))
+            avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;
+    }
+
+    /* check for valid frame size */
+    if (frame) {
+        if (avctx->codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME) {
+            if (frame->nb_samples > avctx->frame_size) {
+                av_log(avctx, AV_LOG_ERROR, "more samples than frame size (avcodec_encode_audio2)\n");
+                ret = AVERROR(EINVAL);
+                goto end;
+            }
+        } else if (!(avctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)) {
+            if (frame->nb_samples < avctx->frame_size &&
+                !avctx->internal->last_audio_frame) {
+                ret = pad_last_frame(avctx, &padded_frame, frame);
+                if (ret < 0)
+                    goto end;
+
+                frame = padded_frame;
+                avctx->internal->last_audio_frame = 1;
+            }
+
+            if (frame->nb_samples != avctx->frame_size) {
+                av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) != frame_size (%d) (avcodec_encode_audio2)\n", frame->nb_samples, avctx->frame_size);
+                ret = AVERROR(EINVAL);
+                goto end;
+            }
+        }
+    }
+
+    av_assert0(avctx->codec->encode2);
+
+    ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
+    if (!ret) {
+        if (*got_packet_ptr) {
+            if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY)) {
+                if (avpkt->pts == AV_NOPTS_VALUE)
+                    avpkt->pts = frame->pts;
+                if (!avpkt->duration)
+                    avpkt->duration = ff_samples_to_time_base(avctx,
+                                                              frame->nb_samples);
+            }
+            avpkt->dts = avpkt->pts;
+        } else {
+            avpkt->size = 0;
+        }
+    }
+    if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
+        needs_realloc = 0;
+        if (user_pkt.data) {
+            if (user_pkt.size >= avpkt->size) {
+                memcpy(user_pkt.data, avpkt->data, avpkt->size);
+            } else {
+                av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
+                avpkt->size = user_pkt.size;
+                ret = -1;
+            }
+            avpkt->buf      = user_pkt.buf;
+            avpkt->data     = user_pkt.data;
+        } else if (!avpkt->buf) {
+            AVPacket tmp = { 0 };
+            ret = av_packet_ref(&tmp, avpkt);
+            av_packet_unref(avpkt);
+            if (ret < 0)
+                goto end;
+            *avpkt = tmp;
+        }
+    }
+
+    if (!ret) {
+        if (needs_realloc && avpkt->data) {
+            ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
+            if (ret >= 0)
+                avpkt->data = avpkt->buf->data;
+        }
+
+        avctx->frame_number++;
+    }
+
+    if (ret < 0 || !*got_packet_ptr) {
+        av_packet_unref(avpkt);
+        av_init_packet(avpkt);
+        goto end;
+    }
+
+    /* NOTE: if we add any audio encoders which output non-keyframe packets,
+     *       this needs to be moved to the encoders, but for now we can do it
+     *       here to simplify things */
+    avpkt->flags |= AV_PKT_FLAG_KEY;
+
+end:
+    av_frame_free(&padded_frame);
+    av_free(extended_frame);
+
+#if FF_API_AUDIOENC_DELAY
+    avctx->delay = avctx->initial_padding;
+#endif
+
+    return ret;
+}
+
+int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
+                                              AVPacket *avpkt,
+                                              const AVFrame *frame,
+                                              int *got_packet_ptr)
+{
+    int ret;
+    AVPacket user_pkt = *avpkt;
+    int needs_realloc = !user_pkt.data;
+
+    *got_packet_ptr = 0;
+
+    if (!avctx->codec->encode2) {
+        av_log(avctx, AV_LOG_ERROR, "This encoder requires using the avcodec_send_frame() API.\n");
+        return AVERROR(ENOSYS);
+    }
+
+    if(CONFIG_FRAME_THREAD_ENCODER &&
+       avctx->internal->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))
+        return ff_thread_video_encode_frame(avctx, avpkt, frame, got_packet_ptr);
+
+    if ((avctx->flags&AV_CODEC_FLAG_PASS1) && avctx->stats_out)
+        avctx->stats_out[0] = '\0';
+
+    if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
+        av_packet_unref(avpkt);
+        av_init_packet(avpkt);
+        avpkt->size = 0;
+        return 0;
+    }
+
+    if (av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx))
+        return AVERROR(EINVAL);
+
+    if (frame && frame->format == AV_PIX_FMT_NONE)
+        av_log(avctx, AV_LOG_WARNING, "AVFrame.format is not set\n");
+    if (frame && (frame->width == 0 || frame->height == 0))
+        av_log(avctx, AV_LOG_WARNING, "AVFrame.width or height is not set\n");
+
+    av_assert0(avctx->codec->encode2);
+
+    ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
+    av_assert0(ret <= 0);
+
+    emms_c();
+
+    if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
+        needs_realloc = 0;
+        if (user_pkt.data) {
+            if (user_pkt.size >= avpkt->size) {
+                memcpy(user_pkt.data, avpkt->data, avpkt->size);
+            } else {
+                av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
+                avpkt->size = user_pkt.size;
+                ret = -1;
+            }
+            avpkt->buf      = user_pkt.buf;
+            avpkt->data     = user_pkt.data;
+        } else if (!avpkt->buf) {
+            AVPacket tmp = { 0 };
+            ret = av_packet_ref(&tmp, avpkt);
+            av_packet_unref(avpkt);
+            if (ret < 0)
+                return ret;
+            *avpkt = tmp;
+        }
+    }
+
+    if (!ret) {
+        if (!*got_packet_ptr)
+            avpkt->size = 0;
+        else if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
+            avpkt->pts = avpkt->dts = frame->pts;
+
+        if (needs_realloc && avpkt->data) {
+            ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
+            if (ret >= 0)
+                avpkt->data = avpkt->buf->data;
+        }
+
+        avctx->frame_number++;
+    }
+
+    if (ret < 0 || !*got_packet_ptr)
+        av_packet_unref(avpkt);
+
+    return ret;
+}
+
+int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
+                            const AVSubtitle *sub)
+{
+    int ret;
+    if (sub->start_display_time) {
+        av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
+        return -1;
+    }
+
+    ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
+    avctx->frame_number++;
+    return ret;
+}
+
+static int do_encode(AVCodecContext *avctx, const AVFrame *frame, int *got_packet)
+{
+    int ret;
+    *got_packet = 0;
+
+    av_packet_unref(avctx->internal->buffer_pkt);
+    avctx->internal->buffer_pkt_valid = 0;
+
+    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
+        ret = avcodec_encode_video2(avctx, avctx->internal->buffer_pkt,
+                                    frame, got_packet);
+    } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
+        ret = avcodec_encode_audio2(avctx, avctx->internal->buffer_pkt,
+                                    frame, got_packet);
+    } else {
+        ret = AVERROR(EINVAL);
+    }
+
+    if (ret >= 0 && *got_packet) {
+        // Encoders must always return ref-counted buffers.
+        // Side-data only packets have no data and can be not ref-counted.
+        av_assert0(!avctx->internal->buffer_pkt->data || avctx->internal->buffer_pkt->buf);
+        avctx->internal->buffer_pkt_valid = 1;
+        ret = 0;
+    } else {
+        av_packet_unref(avctx->internal->buffer_pkt);
+    }
+
+    return ret;
+}
+
+int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
+{
+    if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
+        return AVERROR(EINVAL);
+
+    if (avctx->internal->draining)
+        return AVERROR_EOF;
+
+    if (!frame) {
+        avctx->internal->draining = 1;
+
+        if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
+            return 0;
+    }
+
+    if (avctx->codec->send_frame)
+        return avctx->codec->send_frame(avctx, frame);
+
+    // Emulation via old API. Do it here instead of avcodec_receive_packet, because:
+    // 1. if the AVFrame is not refcounted, the copying will be much more
+    //    expensive than copying the packet data
+    // 2. assume few users use non-refcounted AVPackets, so usually no copy is
+    //    needed
+
+    if (avctx->internal->buffer_pkt_valid)
+        return AVERROR(EAGAIN);
+
+    return do_encode(avctx, frame, &(int){0});
+}
+
+int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
+{
+    av_packet_unref(avpkt);
+
+    if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
+        return AVERROR(EINVAL);
+
+    if (avctx->codec->receive_packet) {
+        if (avctx->internal->draining && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
+            return AVERROR_EOF;
+        return avctx->codec->receive_packet(avctx, avpkt);
+    }
+
+    // Emulation via old API.
+
+    if (!avctx->internal->buffer_pkt_valid) {
+        int got_packet;
+        int ret;
+        if (!avctx->internal->draining)
+            return AVERROR(EAGAIN);
+        ret = do_encode(avctx, NULL, &got_packet);
+        if (ret < 0)
+            return ret;
+        if (ret >= 0 && !got_packet)
+            return AVERROR_EOF;
+    }
+
+    av_packet_move_ref(avpkt, avctx->internal->buffer_pkt);
+    avctx->internal->buffer_pkt_valid = 0;
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/error_resilience.c b/mythtv/external/FFmpeg/libavcodec/error_resilience.c
index 2790599744e..5364940e946 100644
--- a/mythtv/external/FFmpeg/libavcodec/error_resilience.c
+++ b/mythtv/external/FFmpeg/libavcodec/error_resilience.c
@@ -42,7 +42,7 @@
  * @param stride the number of MVs to get to the next row
  * @param mv_step the number of MVs per row or column in a macroblock
  */
-static void set_mv_strides(ERContext *s, int *mv_step, int *stride)
+static void set_mv_strides(ERContext *s, ptrdiff_t *mv_step, ptrdiff_t *stride)
 {
     if (s->avctx->codec_id == AV_CODEC_ID_H264) {
         av_assert0(s->quarter_sample);
@@ -95,7 +95,7 @@ static void put_dc(ERContext *s, uint8_t *dest_y, uint8_t *dest_cb,
     }
 }
 
-static void filter181(int16_t *data, int width, int height, int stride)
+static void filter181(int16_t *data, int width, int height, ptrdiff_t stride)
 {
     int x, y;
 
@@ -137,7 +137,7 @@ static void filter181(int16_t *data, int width, int height, int stride)
  * @param h     height in 8 pixel blocks
  */
 static void guess_dc(ERContext *s, int16_t *dc, int w,
-                     int h, int stride, int is_luma)
+                     int h, ptrdiff_t stride, int is_luma)
 {
     int b_x, b_y;
     int16_t  (*col )[4] = av_malloc_array(stride, h*sizeof( int16_t)*4);
@@ -240,9 +240,10 @@ static void guess_dc(ERContext *s, int16_t *dc, int w,
  * @param h     height in 8 pixel blocks
  */
 static void h_block_filter(ERContext *s, uint8_t *dst, int w,
-                           int h, int stride, int is_luma)
+                           int h, ptrdiff_t stride, int is_luma)
 {
-    int b_x, b_y, mvx_stride, mvy_stride;
+    int b_x, b_y;
+    ptrdiff_t mvx_stride, mvy_stride;
     const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
     set_mv_strides(s, &mvx_stride, &mvy_stride);
     mvx_stride >>= is_luma;
@@ -308,9 +309,10 @@ static void h_block_filter(ERContext *s, uint8_t *dst, int w,
  * @param h     height in 8 pixel blocks
  */
 static void v_block_filter(ERContext *s, uint8_t *dst, int w, int h,
-                           int stride, int is_luma)
+                           ptrdiff_t stride, int is_luma)
 {
-    int b_x, b_y, mvx_stride, mvy_stride;
+    int b_x, b_y;
+    ptrdiff_t mvx_stride, mvy_stride;
     const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
     set_mv_strides(s, &mvx_stride, &mvy_stride);
     mvx_stride >>= is_luma;
@@ -373,23 +375,40 @@ static void v_block_filter(ERContext *s, uint8_t *dst, int w, int h,
     }
 }
 
+#define MV_FROZEN    8
+#define MV_CHANGED   4
+#define MV_UNCHANGED 2
+#define MV_LISTED    1
+static av_always_inline void add_blocklist(int (*blocklist)[2], int *blocklist_length, uint8_t *fixed, int mb_x, int mb_y, int mb_xy)
+{
+    if (fixed[mb_xy])
+        return;
+    fixed[mb_xy] = MV_LISTED;
+    blocklist[ *blocklist_length   ][0] = mb_x;
+    blocklist[(*blocklist_length)++][1] = mb_y;
+}
+
 static void guess_mv(ERContext *s)
 {
-    uint8_t *fixed = s->er_temp_buffer;
-#define MV_FROZEN    3
-#define MV_CHANGED   2
-#define MV_UNCHANGED 1
-    const int mb_stride = s->mb_stride;
+    int (*blocklist)[2], (*next_blocklist)[2];
+    uint8_t *fixed;
+    const ptrdiff_t mb_stride = s->mb_stride;
     const int mb_width  = s->mb_width;
     int mb_height = s->mb_height;
     int i, depth, num_avail;
-    int mb_x, mb_y, mot_step, mot_stride;
+    int mb_x, mb_y;
+    ptrdiff_t mot_step, mot_stride;
+    int blocklist_length, next_blocklist_length;
 
     if (s->last_pic.f && s->last_pic.f->data[0])
         mb_height = FFMIN(mb_height, (s->last_pic.f->height+15)>>4);
     if (s->next_pic.f && s->next_pic.f->data[0])
         mb_height = FFMIN(mb_height, (s->next_pic.f->height+15)>>4);
 
+    blocklist      = (int (*)[2])s->er_temp_buffer;
+    next_blocklist = blocklist + s->mb_stride * s->mb_height;
+    fixed          = (uint8_t *)(next_blocklist + s->mb_stride * s->mb_height);
+
     set_mv_strides(s, &mot_step, &mot_stride);
 
     num_avail = 0;
@@ -439,237 +458,265 @@ static void guess_mv(ERContext *s)
         return;
     }
 
+    blocklist_length = 0;
+    for (mb_y = 0; mb_y < mb_height; mb_y++) {
+        for (mb_x = 0; mb_x < mb_width; mb_x++) {
+            const int mb_xy = mb_x + mb_y * mb_stride;
+            if (fixed[mb_xy] == MV_FROZEN) {
+                if (mb_x)               add_blocklist(blocklist, &blocklist_length, fixed, mb_x - 1, mb_y, mb_xy - 1);
+                if (mb_y)               add_blocklist(blocklist, &blocklist_length, fixed, mb_x, mb_y - 1, mb_xy - mb_stride);
+                if (mb_x+1 < mb_width)  add_blocklist(blocklist, &blocklist_length, fixed, mb_x + 1, mb_y, mb_xy + 1);
+                if (mb_y+1 < mb_height) add_blocklist(blocklist, &blocklist_length, fixed, mb_x, mb_y + 1, mb_xy + mb_stride);
+            }
+        }
+    }
+
     for (depth = 0; ; depth++) {
         int changed, pass, none_left;
+        int blocklist_index;
 
         none_left = 1;
         changed   = 1;
         for (pass = 0; (changed || pass < 2) && pass < 10; pass++) {
-            int mb_x, mb_y;
             int score_sum = 0;
 
             changed = 0;
-            for (mb_y = 0; mb_y < mb_height; mb_y++) {
-                for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
-                    const int mb_xy        = mb_x + mb_y * s->mb_stride;
-                    int mv_predictor[8][2] = { { 0 } };
-                    int ref[8]             = { 0 };
-                    int pred_count         = 0;
-                    int j;
-                    int best_score         = 256 * 256 * 256 * 64;
-                    int best_pred          = 0;
-                    const int mot_index    = (mb_x + mb_y * mot_stride) * mot_step;
-                    int prev_x = 0, prev_y = 0, prev_ref = 0;
-
-                    if ((mb_x ^ mb_y ^ pass) & 1)
-                        continue;
-
-                    if (fixed[mb_xy] == MV_FROZEN)
-                        continue;
-                    av_assert1(!IS_INTRA(s->cur_pic.mb_type[mb_xy]));
-                    av_assert1(s->last_pic.f && s->last_pic.f->data[0]);
-
-                    j = 0;
-                    if (mb_x > 0             && fixed[mb_xy - 1]         == MV_FROZEN)
-                        j = 1;
-                    if (mb_x + 1 < mb_width  && fixed[mb_xy + 1]         == MV_FROZEN)
-                        j = 1;
-                    if (mb_y > 0             && fixed[mb_xy - mb_stride] == MV_FROZEN)
-                        j = 1;
-                    if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] == MV_FROZEN)
-                        j = 1;
-                    if (j == 0)
-                        continue;
+            for (blocklist_index = 0; blocklist_index < blocklist_length; blocklist_index++) {
+                const int mb_x = blocklist[blocklist_index][0];
+                const int mb_y = blocklist[blocklist_index][1];
+                const int mb_xy = mb_x + mb_y * mb_stride;
+                int mv_predictor[8][2];
+                int ref[8];
+                int pred_count;
+                int j;
+                int best_score;
+                int best_pred;
+                int mot_index;
+                int prev_x, prev_y, prev_ref;
 
-                    j = 0;
-                    if (mb_x > 0             && fixed[mb_xy - 1        ] == MV_CHANGED)
-                        j = 1;
-                    if (mb_x + 1 < mb_width  && fixed[mb_xy + 1        ] == MV_CHANGED)
-                        j = 1;
-                    if (mb_y > 0             && fixed[mb_xy - mb_stride] == MV_CHANGED)
-                        j = 1;
-                    if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] == MV_CHANGED)
-                        j = 1;
-                    if (j == 0 && pass > 1)
-                        continue;
+                if ((mb_x ^ mb_y ^ pass) & 1)
+                    continue;
+                av_assert2(fixed[mb_xy] != MV_FROZEN);
 
-                    none_left = 0;
 
-                    if (mb_x > 0 && fixed[mb_xy - 1]) {
-                        mv_predictor[pred_count][0] =
-                            s->cur_pic.motion_val[0][mot_index - mot_step][0];
-                        mv_predictor[pred_count][1] =
-                            s->cur_pic.motion_val[0][mot_index - mot_step][1];
-                        ref[pred_count] =
-                            s->cur_pic.ref_index[0][4 * (mb_xy - 1)];
-                        pred_count++;
-                    }
-                    if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {
-                        mv_predictor[pred_count][0] =
-                            s->cur_pic.motion_val[0][mot_index + mot_step][0];
-                        mv_predictor[pred_count][1] =
-                            s->cur_pic.motion_val[0][mot_index + mot_step][1];
-                        ref[pred_count] =
-                            s->cur_pic.ref_index[0][4 * (mb_xy + 1)];
-                        pred_count++;
-                    }
-                    if (mb_y > 0 && fixed[mb_xy - mb_stride]) {
-                        mv_predictor[pred_count][0] =
-                            s->cur_pic.motion_val[0][mot_index - mot_stride * mot_step][0];
-                        mv_predictor[pred_count][1] =
-                            s->cur_pic.motion_val[0][mot_index - mot_stride * mot_step][1];
-                        ref[pred_count] =
-                            s->cur_pic.ref_index[0][4 * (mb_xy - s->mb_stride)];
-                        pred_count++;
-                    }
-                    if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride]) {
-                        mv_predictor[pred_count][0] =
-                            s->cur_pic.motion_val[0][mot_index + mot_stride * mot_step][0];
-                        mv_predictor[pred_count][1] =
-                            s->cur_pic.motion_val[0][mot_index + mot_stride * mot_step][1];
-                        ref[pred_count] =
-                            s->cur_pic.ref_index[0][4 * (mb_xy + s->mb_stride)];
-                        pred_count++;
-                    }
-                    if (pred_count == 0)
-                        continue;
+                av_assert1(!IS_INTRA(s->cur_pic.mb_type[mb_xy]));
+                av_assert1(s->last_pic.f && s->last_pic.f->data[0]);
 
-                    if (pred_count > 1) {
-                        int sum_x = 0, sum_y = 0, sum_r = 0;
-                        int max_x, max_y, min_x, min_y, max_r, min_r;
-
-                        for (j = 0; j < pred_count; j++) {
-                            sum_x += mv_predictor[j][0];
-                            sum_y += mv_predictor[j][1];
-                            sum_r += ref[j];
-                            if (j && ref[j] != ref[j - 1])
-                                goto skip_mean_and_median;
-                        }
-
-                        /* mean */
-                        mv_predictor[pred_count][0] = sum_x / j;
-                        mv_predictor[pred_count][1] = sum_y / j;
-                                 ref[pred_count]    = sum_r / j;
-
-                        /* median */
-                        if (pred_count >= 3) {
-                            min_y = min_x = min_r =  99999;
-                            max_y = max_x = max_r = -99999;
-                        } else {
-                            min_x = min_y = max_x = max_y = min_r = max_r = 0;
-                        }
-                        for (j = 0; j < pred_count; j++) {
-                            max_x = FFMAX(max_x, mv_predictor[j][0]);
-                            max_y = FFMAX(max_y, mv_predictor[j][1]);
-                            max_r = FFMAX(max_r, ref[j]);
-                            min_x = FFMIN(min_x, mv_predictor[j][0]);
-                            min_y = FFMIN(min_y, mv_predictor[j][1]);
-                            min_r = FFMIN(min_r, ref[j]);
-                        }
-                        mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x;
-                        mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y;
-                                 ref[pred_count + 1]    = sum_r - max_r - min_r;
-
-                        if (pred_count == 4) {
-                            mv_predictor[pred_count + 1][0] /= 2;
-                            mv_predictor[pred_count + 1][1] /= 2;
-                                     ref[pred_count + 1]    /= 2;
-                        }
-                        pred_count += 2;
-                    }
+                j = 0;
+                if (mb_x > 0)
+                    j |= fixed[mb_xy - 1];
+                if (mb_x + 1 < mb_width)
+                    j |= fixed[mb_xy + 1];
+                if (mb_y > 0)
+                    j |= fixed[mb_xy - mb_stride];
+                if (mb_y + 1 < mb_height)
+                    j |= fixed[mb_xy + mb_stride];
 
-skip_mean_and_median:
-                    /* zero MV */
-                    pred_count++;
+                av_assert2(j & MV_FROZEN);
 
-                    prev_x   = s->cur_pic.motion_val[0][mot_index][0];
-                    prev_y   = s->cur_pic.motion_val[0][mot_index][1];
-                    prev_ref = s->cur_pic.ref_index[0][4 * mb_xy];
+                if (!(j & MV_CHANGED) && pass > 1)
+                    continue;
 
-                    /* last MV */
-                    mv_predictor[pred_count][0] = prev_x;
-                    mv_predictor[pred_count][1] = prev_y;
-                             ref[pred_count]    = prev_ref;
+                none_left = 0;
+                pred_count = 0;
+                mot_index  = (mb_x + mb_y * mot_stride) * mot_step;
+
+                if (mb_x > 0 && fixed[mb_xy - 1] > 1) {
+                    mv_predictor[pred_count][0] =
+                        s->cur_pic.motion_val[0][mot_index - mot_step][0];
+                    mv_predictor[pred_count][1] =
+                        s->cur_pic.motion_val[0][mot_index - mot_step][1];
+                    ref[pred_count] =
+                        s->cur_pic.ref_index[0][4 * (mb_xy - 1)];
+                    pred_count++;
+                }
+                if (mb_x + 1 < mb_width && fixed[mb_xy + 1] > 1) {
+                    mv_predictor[pred_count][0] =
+                        s->cur_pic.motion_val[0][mot_index + mot_step][0];
+                    mv_predictor[pred_count][1] =
+                        s->cur_pic.motion_val[0][mot_index + mot_step][1];
+                    ref[pred_count] =
+                        s->cur_pic.ref_index[0][4 * (mb_xy + 1)];
+                    pred_count++;
+                }
+                if (mb_y > 0 && fixed[mb_xy - mb_stride] > 1) {
+                    mv_predictor[pred_count][0] =
+                        s->cur_pic.motion_val[0][mot_index - mot_stride * mot_step][0];
+                    mv_predictor[pred_count][1] =
+                        s->cur_pic.motion_val[0][mot_index - mot_stride * mot_step][1];
+                    ref[pred_count] =
+                        s->cur_pic.ref_index[0][4 * (mb_xy - s->mb_stride)];
                     pred_count++;
+                }
+                if (mb_y + 1<mb_height && fixed[mb_xy + mb_stride] > 1) {
+                    mv_predictor[pred_count][0] =
+                        s->cur_pic.motion_val[0][mot_index + mot_stride * mot_step][0];
+                    mv_predictor[pred_count][1] =
+                        s->cur_pic.motion_val[0][mot_index + mot_stride * mot_step][1];
+                    ref[pred_count] =
+                        s->cur_pic.ref_index[0][4 * (mb_xy + s->mb_stride)];
+                    pred_count++;
+                }
+                if (pred_count == 0)
+                    continue;
+
+                if (pred_count > 1) {
+                    int sum_x = 0, sum_y = 0, sum_r = 0;
+                    int max_x, max_y, min_x, min_y, max_r, min_r;
 
                     for (j = 0; j < pred_count; j++) {
-                        int *linesize = s->cur_pic.f->linesize;
-                        int score = 0;
-                        uint8_t *src = s->cur_pic.f->data[0] +
-                                       mb_x * 16 + mb_y * 16 * linesize[0];
+                        sum_x += mv_predictor[j][0];
+                        sum_y += mv_predictor[j][1];
+                        sum_r += ref[j];
+                        if (j && ref[j] != ref[j - 1])
+                            goto skip_mean_and_median;
+                    }
 
-                        s->cur_pic.motion_val[0][mot_index][0] =
-                            s->mv[0][0][0] = mv_predictor[j][0];
-                        s->cur_pic.motion_val[0][mot_index][1] =
-                            s->mv[0][0][1] = mv_predictor[j][1];
-
-                        // predictor intra or otherwise not available
-                        if (ref[j] < 0)
-                            continue;
-
-                        s->decode_mb(s->opaque, ref[j], MV_DIR_FORWARD,
-                                     MV_TYPE_16X16, &s->mv, mb_x, mb_y, 0, 0);
-
-                        if (mb_x > 0 && fixed[mb_xy - 1]) {
-                            int k;
-                            for (k = 0; k < 16; k++)
-                                score += FFABS(src[k * linesize[0] - 1] -
-                                               src[k * linesize[0]]);
-                        }
-                        if (mb_x + 1 < mb_width && fixed[mb_xy + 1]) {
-                            int k;
-                            for (k = 0; k < 16; k++)
-                                score += FFABS(src[k * linesize[0] + 15] -
-                                               src[k * linesize[0] + 16]);
-                        }
-                        if (mb_y > 0 && fixed[mb_xy - mb_stride]) {
-                            int k;
-                            for (k = 0; k < 16; k++)
-                                score += FFABS(src[k - linesize[0]] - src[k]);
-                        }
-                        if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride]) {
-                            int k;
-                            for (k = 0; k < 16; k++)
-                                score += FFABS(src[k + linesize[0] * 15] -
-                                               src[k + linesize[0] * 16]);
-                        }
-
-                        if (score <= best_score) { // <= will favor the last MV
-                            best_score = score;
-                            best_pred  = j;
-                        }
+                    /* mean */
+                    mv_predictor[pred_count][0] = sum_x / j;
+                    mv_predictor[pred_count][1] = sum_y / j;
+                             ref[pred_count]    = sum_r / j;
+
+                    /* median */
+                    if (pred_count >= 3) {
+                        min_y = min_x = min_r =  99999;
+                        max_y = max_x = max_r = -99999;
+                    } else {
+                        min_x = min_y = max_x = max_y = min_r = max_r = 0;
                     }
-                    score_sum += best_score;
-                    s->mv[0][0][0] = mv_predictor[best_pred][0];
-                    s->mv[0][0][1] = mv_predictor[best_pred][1];
+                    for (j = 0; j < pred_count; j++) {
+                        max_x = FFMAX(max_x, mv_predictor[j][0]);
+                        max_y = FFMAX(max_y, mv_predictor[j][1]);
+                        max_r = FFMAX(max_r, ref[j]);
+                        min_x = FFMIN(min_x, mv_predictor[j][0]);
+                        min_y = FFMIN(min_y, mv_predictor[j][1]);
+                        min_r = FFMIN(min_r, ref[j]);
+                    }
+                    mv_predictor[pred_count + 1][0] = sum_x - max_x - min_x;
+                    mv_predictor[pred_count + 1][1] = sum_y - max_y - min_y;
+                             ref[pred_count + 1]    = sum_r - max_r - min_r;
+
+                    if (pred_count == 4) {
+                        mv_predictor[pred_count + 1][0] /= 2;
+                        mv_predictor[pred_count + 1][1] /= 2;
+                                 ref[pred_count + 1]    /= 2;
+                    }
+                    pred_count += 2;
+                }
 
-                    for (i = 0; i < mot_step; i++)
-                        for (j = 0; j < mot_step; j++) {
-                            s->cur_pic.motion_val[0][mot_index + i + j * mot_stride][0] = s->mv[0][0][0];
-                            s->cur_pic.motion_val[0][mot_index + i + j * mot_stride][1] = s->mv[0][0][1];
-                        }
+skip_mean_and_median:
+                /* zero MV */
+                mv_predictor[pred_count][0] =
+                mv_predictor[pred_count][1] =
+                         ref[pred_count]    = 0;
+                pred_count++;
+
+                prev_x   = s->cur_pic.motion_val[0][mot_index][0];
+                prev_y   = s->cur_pic.motion_val[0][mot_index][1];
+                prev_ref = s->cur_pic.ref_index[0][4 * mb_xy];
+
+                /* last MV */
+                mv_predictor[pred_count][0] = prev_x;
+                mv_predictor[pred_count][1] = prev_y;
+                         ref[pred_count]    = prev_ref;
+                pred_count++;
+
+                best_pred = 0;
+                best_score = 256 * 256 * 256 * 64;
+                for (j = 0; j < pred_count; j++) {
+                    int *linesize = s->cur_pic.f->linesize;
+                    int score = 0;
+                    uint8_t *src = s->cur_pic.f->data[0] +
+                                   mb_x * 16 + mb_y * 16 * linesize[0];
+
+                    s->cur_pic.motion_val[0][mot_index][0] =
+                        s->mv[0][0][0] = mv_predictor[j][0];
+                    s->cur_pic.motion_val[0][mot_index][1] =
+                        s->mv[0][0][1] = mv_predictor[j][1];
+
+                    // predictor intra or otherwise not available
+                    if (ref[j] < 0)
+                        continue;
 
-                    s->decode_mb(s->opaque, ref[best_pred], MV_DIR_FORWARD,
+                    s->decode_mb(s->opaque, ref[j], MV_DIR_FORWARD,
                                  MV_TYPE_16X16, &s->mv, mb_x, mb_y, 0, 0);
 
+                    if (mb_x > 0 && fixed[mb_xy - 1] > 1) {
+                        int k;
+                        for (k = 0; k < 16; k++)
+                            score += FFABS(src[k * linesize[0] - 1] -
+                                           src[k * linesize[0]]);
+                    }
+                    if (mb_x + 1 < mb_width && fixed[mb_xy + 1] > 1) {
+                        int k;
+                        for (k = 0; k < 16; k++)
+                            score += FFABS(src[k * linesize[0] + 15] -
+                                           src[k * linesize[0] + 16]);
+                    }
+                    if (mb_y > 0 && fixed[mb_xy - mb_stride] > 1) {
+                        int k;
+                        for (k = 0; k < 16; k++)
+                            score += FFABS(src[k - linesize[0]] - src[k]);
+                    }
+                    if (mb_y + 1 < mb_height && fixed[mb_xy + mb_stride] > 1) {
+                        int k;
+                        for (k = 0; k < 16; k++)
+                            score += FFABS(src[k + linesize[0] * 15] -
+                                           src[k + linesize[0] * 16]);
+                    }
 
-                    if (s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y) {
-                        fixed[mb_xy] = MV_CHANGED;
-                        changed++;
-                    } else
-                        fixed[mb_xy] = MV_UNCHANGED;
+                    if (score <= best_score) { // <= will favor the last MV
+                        best_score = score;
+                        best_pred  = j;
+                    }
                 }
+                score_sum += best_score;
+                s->mv[0][0][0] = mv_predictor[best_pred][0];
+                s->mv[0][0][1] = mv_predictor[best_pred][1];
+
+                for (i = 0; i < mot_step; i++)
+                    for (j = 0; j < mot_step; j++) {
+                        s->cur_pic.motion_val[0][mot_index + i + j * mot_stride][0] = s->mv[0][0][0];
+                        s->cur_pic.motion_val[0][mot_index + i + j * mot_stride][1] = s->mv[0][0][1];
+                    }
+
+                s->decode_mb(s->opaque, ref[best_pred], MV_DIR_FORWARD,
+                             MV_TYPE_16X16, &s->mv, mb_x, mb_y, 0, 0);
+
+
+                if (s->mv[0][0][0] != prev_x || s->mv[0][0][1] != prev_y) {
+                    fixed[mb_xy] = MV_CHANGED;
+                    changed++;
+                } else
+                    fixed[mb_xy] = MV_UNCHANGED;
             }
         }
 
         if (none_left)
             return;
 
-        for (i = 0; i < mb_width * mb_height; i++) {
-            int mb_xy = s->mb_index2xy[i];
-            if (fixed[mb_xy])
+        next_blocklist_length = 0;
+
+        for (blocklist_index = 0; blocklist_index < blocklist_length; blocklist_index++) {
+            const int mb_x = blocklist[blocklist_index][0];
+            const int mb_y = blocklist[blocklist_index][1];
+            const int mb_xy = mb_x + mb_y * mb_stride;
+
+            if (fixed[mb_xy] & (MV_CHANGED|MV_UNCHANGED|MV_FROZEN)) {
                 fixed[mb_xy] = MV_FROZEN;
+                if (mb_x > 0)
+                    add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x - 1, mb_y, mb_xy - 1);
+                if (mb_y > 0)
+                    add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x, mb_y - 1, mb_xy - mb_stride);
+                if (mb_x + 1 < mb_width)
+                    add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x + 1, mb_y, mb_xy + 1);
+                if (mb_y + 1 < mb_height)
+                    add_blocklist(next_blocklist, &next_blocklist_length, fixed, mb_x, mb_y + 1, mb_xy + mb_stride);
+            }
         }
+        av_assert0(next_blocklist_length <= mb_height * mb_width);
+        FFSWAP(int , blocklist_length, next_blocklist_length);
+        FFSWAP(void*, blocklist, next_blocklist);
     }
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/error_resilience.h b/mythtv/external/FFmpeg/libavcodec/error_resilience.h
index d444ec3a3cf..27c20086948 100644
--- a/mythtv/external/FFmpeg/libavcodec/error_resilience.h
+++ b/mythtv/external/FFmpeg/libavcodec/error_resilience.h
@@ -57,8 +57,8 @@ typedef struct ERContext {
     int *mb_index2xy;
     int mb_num;
     int mb_width, mb_height;
-    int mb_stride;
-    int b8_stride;
+    ptrdiff_t mb_stride;
+    ptrdiff_t b8_stride;
 
     volatile int error_count;
     int error_occurred;
diff --git a/mythtv/external/FFmpeg/libavcodec/escape124.c b/mythtv/external/FFmpeg/libavcodec/escape124.c
index b872b3a53d7..eb051eba54a 100644
--- a/mythtv/external/FFmpeg/libavcodec/escape124.c
+++ b/mythtv/external/FFmpeg/libavcodec/escape124.c
@@ -249,6 +249,10 @@ static int escape124_decode_frame(AVCodecContext *avctx,
                 // This codebook can be cut off at places other than
                 // powers of 2, leaving some of the entries undefined.
                 cb_size = get_bits_long(&gb, 20);
+                if (!cb_size) {
+                    av_log(avctx, AV_LOG_ERROR, "Invalid codebook size 0.\n");
+                    return AVERROR_INVALIDDATA;
+                }
                 cb_depth = av_log2(cb_size - 1) + 1;
             } else {
                 cb_depth = get_bits(&gb, 4);
@@ -263,6 +267,11 @@ static int escape124_decode_frame(AVCodecContext *avctx,
                     cb_size = s->num_superblocks << cb_depth;
                 }
             }
+            if (s->num_superblocks >= INT_MAX >> cb_depth) {
+                av_log(avctx, AV_LOG_ERROR, "Depth or num_superblocks are too large\n");
+                return AVERROR_INVALIDDATA;
+            }
+
             av_freep(&s->codebooks[i].blocks);
             s->codebooks[i] = unpack_codebook(&gb, cb_depth, cb_size);
             if (!s->codebooks[i].blocks)
diff --git a/mythtv/external/FFmpeg/libavcodec/exr.c b/mythtv/external/FFmpeg/libavcodec/exr.c
index c250eea423a..b1ecde4ebd3 100644
--- a/mythtv/external/FFmpeg/libavcodec/exr.c
+++ b/mythtv/external/FFmpeg/libavcodec/exr.c
@@ -3,7 +3,7 @@
  * Copyright (c) 2006 Industrial Light & Magic, a division of Lucas Digital Ltd. LLC
  * Copyright (c) 2009 Jimmy Christensen
  *
- * B44/B44A, Tile added by Jokyo Images support by CNC - French National Center for Cinema
+ * B44/B44A, Tile, UINT32 added by Jokyo Images support by CNC - French National Center for Cinema
  *
  * This file is part of FFmpeg.
  *
@@ -37,6 +37,7 @@
 #include <float.h>
 #include <zlib.h>
 
+#include "libavutil/avassert.h"
 #include "libavutil/common.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/intfloat.h"
@@ -45,6 +46,12 @@
 
 #include "avcodec.h"
 #include "bytestream.h"
+
+#if HAVE_BIGENDIAN
+#include "bswapdsp.h"
+#endif
+
+#include "exrdsp.h"
 #include "get_bits.h"
 #include "internal.h"
 #include "mathops.h"
@@ -59,6 +66,8 @@ enum ExrCompr {
     EXR_PXR24,
     EXR_B44,
     EXR_B44A,
+    EXR_DWA,
+    EXR_DWB,
     EXR_UNKN,
 };
 
@@ -113,6 +122,11 @@ typedef struct EXRContext {
     AVClass *class;
     AVFrame *picture;
     AVCodecContext *avctx;
+    ExrDSPContext dsp;
+
+#if HAVE_BIGENDIAN
+    BswapDSPContext bbdsp;
+#endif
 
     enum ExrCompr compression;
     enum ExrPixelType pixel_type;
@@ -218,9 +232,9 @@ static union av_intfloat32 exr_half2float(uint16_t hf)
  *
  * @return normalized 16-bit unsigned int
  */
-static inline uint16_t exr_flt2uint(uint32_t v)
+static inline uint16_t exr_flt2uint(int32_t v)
 {
-    unsigned int exp = v >> 23;
+    int32_t exp = v >> 23;
     // "HACK": negative values result in exp<  0, so clipping them to 0
     // is also handled by this condition, avoids explicit check for sign bit.
     if (exp <= 127 + 7 - 24) // we would shift out all bits anyway
@@ -251,39 +265,7 @@ static inline uint16_t exr_halflt2uint(uint16_t v)
     return (v + (1 << 16)) >> (exp + 1);
 }
 
-static void predictor(uint8_t *src, int size)
-{
-    uint8_t *t    = src + 1;
-    uint8_t *stop = src + size;
-
-    while (t < stop) {
-        int d = (int) t[-1] + (int) t[0] - 128;
-        t[0] = d;
-        ++t;
-    }
-}
-
-static void reorder_pixels(uint8_t *src, uint8_t *dst, int size)
-{
-    const int8_t *t1 = src;
-    const int8_t *t2 = src + (size + 1) / 2;
-    int8_t *s        = dst;
-    int8_t *stop     = s + size;
-
-    while (1) {
-        if (s < stop)
-            *(s++) = *(t1++);
-        else
-            break;
-
-        if (s < stop)
-            *(s++) = *(t2++);
-        else
-            break;
-    }
-}
-
-static int zip_uncompress(const uint8_t *src, int compressed_size,
+static int zip_uncompress(EXRContext *s, const uint8_t *src, int compressed_size,
                           int uncompressed_size, EXRThreadData *td)
 {
     unsigned long dest_len = uncompressed_size;
@@ -292,13 +274,15 @@ static int zip_uncompress(const uint8_t *src, int compressed_size,
         dest_len != uncompressed_size)
         return AVERROR_INVALIDDATA;
 
-    predictor(td->tmp, uncompressed_size);
-    reorder_pixels(td->tmp, td->uncompressed_data, uncompressed_size);
+    av_assert1(uncompressed_size % 2 == 0);
+
+    s->dsp.predictor(td->tmp, uncompressed_size);
+    s->dsp.reorder_pixels(td->uncompressed_data, td->tmp, uncompressed_size);
 
     return 0;
 }
 
-static int rle_uncompress(const uint8_t *src, int compressed_size,
+static int rle_uncompress(EXRContext *ctx, const uint8_t *src, int compressed_size,
                           int uncompressed_size, EXRThreadData *td)
 {
     uint8_t *d      = td->tmp;
@@ -337,8 +321,10 @@ static int rle_uncompress(const uint8_t *src, int compressed_size,
     if (dend != d)
         return AVERROR_INVALIDDATA;
 
-    predictor(td->tmp, uncompressed_size);
-    reorder_pixels(td->tmp, td->uncompressed_data, uncompressed_size);
+    av_assert1(uncompressed_size % 2 == 0);
+
+    ctx->dsp.predictor(td->tmp, uncompressed_size);
+    ctx->dsp.reorder_pixels(td->uncompressed_data, td->tmp, uncompressed_size);
 
     return 0;
 }
@@ -749,7 +735,8 @@ static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize,
     uint16_t maxval, min_non_zero, max_non_zero;
     uint16_t *ptr;
     uint16_t *tmp = (uint16_t *)td->tmp;
-    uint8_t *out;
+    uint16_t *out;
+    uint16_t *in;
     int ret, i, j;
     int pixel_half_size;/* 1 for half, 2 for float and uint32 */
     EXRChannel *channel;
@@ -801,12 +788,11 @@ static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize,
 
     apply_lut(td->lut, tmp, dsize / sizeof(uint16_t));
 
-    out = td->uncompressed_data;
+    out = (uint16_t *)td->uncompressed_data;
     for (i = 0; i < td->ysize; i++) {
         tmp_offset = 0;
         for (j = 0; j < s->nb_channels; j++) {
-            uint16_t *in;
-            EXRChannel *channel = &s->channels[j];
+            channel = &s->channels[j];
             if (channel->pixel_type == EXR_HALF)
                 pixel_half_size = 1;
             else
@@ -814,8 +800,13 @@ static int piz_uncompress(EXRContext *s, const uint8_t *src, int ssize,
 
             in = tmp + tmp_offset * td->xsize * td->ysize + i * td->xsize * pixel_half_size;
             tmp_offset += pixel_half_size;
+
+#if HAVE_BIGENDIAN
+            s->bbdsp.bswap16_buf(out, in, td->xsize * pixel_half_size);
+#else
             memcpy(out, in, td->xsize * 2 * pixel_half_size);
-            out += td->xsize * 2 * pixel_half_size;
+#endif
+            out += td->xsize * pixel_half_size;
         }
     }
 
@@ -864,7 +855,7 @@ static int pxr24_uncompress(EXRContext *s, const uint8_t *src,
                 in     = ptr[2] + td->xsize;
 
                 for (j = 0; j < td->xsize; ++j) {
-                    uint32_t diff = (*(ptr[0]++) << 24) |
+                    uint32_t diff = ((unsigned)*(ptr[0]++) << 24) |
                                     (*(ptr[1]++) << 16) |
                                     (*(ptr[2]++) << 8);
                     pixel += diff;
@@ -882,6 +873,22 @@ static int pxr24_uncompress(EXRContext *s, const uint8_t *src,
                     bytestream_put_le16(&out, pixel);
                 }
                 break;
+            case EXR_UINT:
+                ptr[0] = in;
+                ptr[1] = ptr[0] + s->xdelta;
+                ptr[2] = ptr[1] + s->xdelta;
+                ptr[3] = ptr[2] + s->xdelta;
+                in     = ptr[3] + s->xdelta;
+
+                for (j = 0; j < s->xdelta; ++j) {
+                    uint32_t diff = (*(ptr[0]++) << 24) |
+                    (*(ptr[1]++) << 16) |
+                    (*(ptr[2]++) << 8 ) |
+                    (*(ptr[3]++));
+                    pixel += diff;
+                    bytestream_put_le32(&out, pixel);
+                }
+                break;
             default:
                 return AVERROR_INVALIDDATA;
             }
@@ -1031,7 +1038,7 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
     uint8_t *ptr;
     uint32_t data_size;
     uint64_t line, col = 0;
-    uint64_t tileX, tileY, tileLevelX, tileLevelY;
+    uint64_t tile_x, tile_y, tile_level_x, tile_level_y;
     const uint8_t *src;
     int axmax = (avctx->width - (s->xmax + 1)) * 2 * s->desc->nb_components; /* nb pixel to add at the right of the datawindow */
     int bxmin = s->xmin * 2 * s->desc->nb_components; /* nb pixel to add at the left of the datawindow */
@@ -1049,16 +1056,16 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
 
         src  = buf + line_offset + 20;
 
-        tileX = AV_RL32(src - 20);
-        tileY = AV_RL32(src - 16);
-        tileLevelX = AV_RL32(src - 12);
-        tileLevelY = AV_RL32(src - 8);
+        tile_x = AV_RL32(src - 20);
+        tile_y = AV_RL32(src - 16);
+        tile_level_x = AV_RL32(src - 12);
+        tile_level_y = AV_RL32(src - 8);
 
         data_size = AV_RL32(src - 4);
         if (data_size <= 0 || data_size > buf_size)
             return AVERROR_INVALIDDATA;
 
-        if (tileLevelX || tileLevelY) { /* tile level, is not the full res level */
+        if (tile_level_x || tile_level_y) { /* tile level, is not the full res level */
             avpriv_report_missing_feature(s->avctx, "Subres tile before full res tile");
             return AVERROR_PATCHWELCOME;
         }
@@ -1068,15 +1075,15 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
             return AVERROR_PATCHWELCOME;
         }
 
-        line = s->tile_attr.ySize * tileY;
-        col = s->tile_attr.xSize * tileX;
+        line = s->tile_attr.ySize * tile_y;
+        col = s->tile_attr.xSize * tile_x;
 
         if (line < s->ymin || line > s->ymax ||
             col  < s->xmin || col  > s->xmax)
             return AVERROR_INVALIDDATA;
 
-        td->ysize = FFMIN(s->tile_attr.ySize, s->ydelta - tileY * s->tile_attr.ySize);
-        td->xsize = FFMIN(s->tile_attr.xSize, s->xdelta - tileX * s->tile_attr.xSize);
+        td->ysize = FFMIN(s->tile_attr.ySize, s->ydelta - tile_y * s->tile_attr.ySize);
+        td->xsize = FFMIN(s->tile_attr.xSize, s->xdelta - tile_x * s->tile_attr.xSize);
 
         if (col) { /* not the first tile of the line */
             bxmin = 0; /* doesn't add pixel at the left of the datawindow */
@@ -1123,7 +1130,7 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
 
     if (data_size < uncompressed_size) {
         av_fast_padded_malloc(&td->uncompressed_data,
-                              &td->uncompressed_size, uncompressed_size);
+                              &td->uncompressed_size, uncompressed_size + 64);/* Force 64 padding for AVX2 reorder_pixels dst */
 
         if (!td->uncompressed_data)
             return AVERROR(ENOMEM);
@@ -1132,7 +1139,7 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
         switch (s->compression) {
         case EXR_ZIP1:
         case EXR_ZIP16:
-            ret = zip_uncompress(src, data_size, uncompressed_size, td);
+            ret = zip_uncompress(s, src, data_size, uncompressed_size, td);
             break;
         case EXR_PIZ:
             ret = piz_uncompress(s, src, data_size, uncompressed_size, td);
@@ -1141,7 +1148,7 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
             ret = pxr24_uncompress(s, src, data_size, uncompressed_size, td);
             break;
         case EXR_RLE:
-            ret = rle_uncompress(src, data_size, uncompressed_size, td);
+            ret = rle_uncompress(s, src, data_size, uncompressed_size, td);
             break;
         case EXR_B44:
         case EXR_B44A:
@@ -1218,7 +1225,7 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
                         *ptr_x++ = exr_flt2uint(bytestream_get_le32(&a));
                 }
             }
-        } else {
+        } else if (s->pixel_type == EXR_HALF) {
             // 16-bit
             for (x = 0; x < td->xsize; x++) {
                 int c;
@@ -1229,6 +1236,15 @@ static int decode_block(AVCodecContext *avctx, void *tdata,
                 if (channel_buffer[3])
                     *ptr_x++ = exr_halflt2uint(bytestream_get_le16(&a));
             }
+        } else if (s->pixel_type == EXR_UINT) {
+            for (x = 0; x < td->xsize; x++) {
+                for (c = 0; c < rgb_channel_count; c++) {
+                    *ptr_x++ = bytestream_get_le32(&rgb[c]) >> 16;
+                }
+
+                if (channel_buffer[3])
+                    *ptr_x++ = bytestream_get_le32(&a) >> 16;
+            }
         }
 
         // Zero out the end if xmax+1 is not w
@@ -1285,8 +1301,9 @@ static int check_header_variable(EXRContext *s,
     return var_size;
 }
 
-static int decode_header(EXRContext *s)
+static int decode_header(EXRContext *s, AVFrame *frame)
 {
+    AVDictionary *metadata = NULL;
     int magic_number, version, i, flags, sar = 0;
     int layer_match = 0;
 
@@ -1428,17 +1445,15 @@ static int decode_header(EXRContext *s)
                     return AVERROR_PATCHWELCOME;
                 }
 
-                if (s->channel_offsets[channel_index] == -1){/* channel have not been previously assign */
-                    if (channel_index >= 0) {
-                        if (s->pixel_type != EXR_UNKNOWN &&
-                            s->pixel_type != current_pixel_type) {
-                            av_log(s->avctx, AV_LOG_ERROR,
-                                   "RGB channels not of the same depth.\n");
-                            return AVERROR_INVALIDDATA;
-                        }
-                        s->pixel_type                     = current_pixel_type;
-                        s->channel_offsets[channel_index] = s->current_channel_offset;
+                if (channel_index >= 0 && s->channel_offsets[channel_index] == -1) { /* channel has not been previously assigned */
+                    if (s->pixel_type != EXR_UNKNOWN &&
+                        s->pixel_type != current_pixel_type) {
+                        av_log(s->avctx, AV_LOG_ERROR,
+                               "RGB channels not of the same depth.\n");
+                        return AVERROR_INVALIDDATA;
                     }
+                    s->pixel_type                     = current_pixel_type;
+                    s->channel_offsets[channel_index] = s->current_channel_offset;
                 }
 
                 s->channels = av_realloc(s->channels,
@@ -1450,7 +1465,11 @@ static int decode_header(EXRContext *s)
                 channel->xsub       = xsub;
                 channel->ysub       = ysub;
 
-                s->current_channel_offset += 1 << current_pixel_type;
+                if (current_pixel_type == EXR_HALF) {
+                    s->current_channel_offset += 2;
+                } else {/* Float or UINT32 */
+                    s->current_channel_offset += 4;
+                }
             }
 
             /* Check if all channels are set with an offset or if the channels
@@ -1556,6 +1575,14 @@ static int decode_header(EXRContext *s)
                 return AVERROR_PATCHWELCOME;
             }
 
+            continue;
+        } else if ((var_size = check_header_variable(s, "writer",
+                                                     "string", 1)) >= 0) {
+            uint8_t key[256] = { 0 };
+
+            bytestream2_get_buffer(&s->gb, key, FFMIN(sizeof(key) - 1, var_size));
+            av_dict_set(&metadata, "writer", key, 0);
+
             continue;
         }
 
@@ -1592,6 +1619,8 @@ static int decode_header(EXRContext *s)
         return AVERROR_INVALIDDATA;
     }
 
+    frame->metadata = metadata;
+
     // aaand we are done
     bytestream2_skip(&s->gb, 1);
     return 0;
@@ -1607,16 +1636,20 @@ static int decode_frame(AVCodecContext *avctx, void *data,
 
     int y, ret;
     int out_line_size;
-    int nb_blocks;/* nb scanline or nb tile */
+    int nb_blocks;   /* nb scanline or nb tile */
+    uint64_t start_offset_table;
+    uint64_t start_next_scanline;
+    PutByteContext offset_table_writer;
 
     bytestream2_init(&s->gb, avpkt->data, avpkt->size);
 
-    if ((ret = decode_header(s)) < 0)
+    if ((ret = decode_header(s, picture)) < 0)
         return ret;
 
     switch (s->pixel_type) {
     case EXR_FLOAT:
     case EXR_HALF:
+    case EXR_UINT:
         if (s->channel_offsets[3] >= 0) {
             if (!s->is_luma) {
                 avctx->pix_fmt = AV_PIX_FMT_RGBA64;
@@ -1631,9 +1664,6 @@ static int decode_frame(AVCodecContext *avctx, void *data,
             }
         }
         break;
-    case EXR_UINT:
-        avpriv_request_sample(avctx, "32-bit unsigned int");
-        return AVERROR_PATCHWELCOME;
     default:
         av_log(avctx, AV_LOG_ERROR, "Missing channel list.\n");
         return AVERROR_INVALIDDATA;
@@ -1695,6 +1725,25 @@ static int decode_frame(AVCodecContext *avctx, void *data,
     if (bytestream2_get_bytes_left(&s->gb) < nb_blocks * 8)
         return AVERROR_INVALIDDATA;
 
+    // check offset table and recreate it if need
+    if (!s->is_tile && bytestream2_peek_le64(&s->gb) == 0) {
+        av_log(s->avctx, AV_LOG_DEBUG, "recreating invalid scanline offset table\n");
+
+        start_offset_table = bytestream2_tell(&s->gb);
+        start_next_scanline = start_offset_table + nb_blocks * 8;
+        bytestream2_init_writer(&offset_table_writer, &avpkt->data[start_offset_table], nb_blocks * 8);
+
+        for (y = 0; y < nb_blocks; y++) {
+            /* write offset of prev scanline in offset table */
+            bytestream2_put_le64(&offset_table_writer, start_next_scanline);
+
+            /* get len of next scanline */
+            bytestream2_seek(&s->gb, start_next_scanline + 4, SEEK_SET);/* skip line number */
+            start_next_scanline += (bytestream2_get_le32(&s->gb) + 8);
+        }
+        bytestream2_seek(&s->gb, start_offset_table, SEEK_SET);
+    }
+
     // save pointer we are going to use in decode_block
     s->buf      = avpkt->data;
     s->buf_size = avpkt->size;
@@ -1711,6 +1760,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
     avctx->execute2(avctx, decode_block, s->thread_data, NULL, nb_blocks);
 
     // Zero out the end if ymax+1 is not h
+    ptr = picture->data[0] + ((s->ymax+1) * picture->linesize[0]);
     for (y = s->ymax + 1; y < avctx->height; y++) {
         memset(ptr, 0, out_line_size);
         ptr += picture->linesize[0];
@@ -1732,6 +1782,12 @@ static av_cold int decode_init(AVCodecContext *avctx)
 
     s->avctx              = avctx;
 
+    ff_exrdsp_init(&s->dsp);
+
+#if HAVE_BIGENDIAN
+    ff_bswapdsp_init(&s->bbdsp);
+#endif
+
     trc_func = avpriv_get_trc_function_from_trc(s->apply_trc_type);
     if (trc_func) {
         for (i = 0; i < 65536; ++i) {
diff --git a/mythtv/external/FFmpeg/libavcodec/exrdsp.c b/mythtv/external/FFmpeg/libavcodec/exrdsp.c
new file mode 100644
index 00000000000..42dbf1f54a7
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/exrdsp.c
@@ -0,0 +1,56 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * Copyright (c) 2006 Industrial Light & Magic, a division of Lucas Digital Ltd. LLC
+ *
+ * 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 <stdint.h>
+
+#include "libavutil/attributes.h"
+#include "exrdsp.h"
+#include "config.h"
+
+static void reorder_pixels_scalar(uint8_t *dst, const uint8_t *src, ptrdiff_t size)
+{
+    const uint8_t *t1 = src;
+    int half_size     = size / 2;
+    const uint8_t *t2 = src + half_size;
+    uint8_t *s        = dst;
+    int i;
+
+    for (i = 0; i < half_size; i++) {
+        *(s++) = *(t1++);
+        *(s++) = *(t2++);
+    }
+}
+
+static void predictor_scalar(uint8_t *src, ptrdiff_t size)
+{
+    ptrdiff_t i;
+
+    for (i = 1; i < size; i++)
+        src[i] += src[i-1] - 128;
+}
+
+av_cold void ff_exrdsp_init(ExrDSPContext *c)
+{
+    c->reorder_pixels   = reorder_pixels_scalar;
+    c->predictor        = predictor_scalar;
+
+    if (ARCH_X86)
+        ff_exrdsp_init_x86(c);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/exrdsp.h b/mythtv/external/FFmpeg/libavcodec/exrdsp.h
new file mode 100644
index 00000000000..2c4dc3af888
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/exrdsp.h
@@ -0,0 +1,33 @@
+/*
+ * 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_EXRDSP_H
+#define AVCODEC_EXRDSP_H
+
+#include <stdint.h>
+#include "libavutil/common.h"
+
+typedef struct ExrDSPContext {
+    void (*reorder_pixels)(uint8_t *dst, const uint8_t *src, ptrdiff_t size);
+    void (*predictor)(uint8_t *src, ptrdiff_t size);
+} ExrDSPContext;
+
+void ff_exrdsp_init(ExrDSPContext *c);
+void ff_exrdsp_init_x86(ExrDSPContext *c);
+
+#endif /* AVCODEC_EXRDSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/extract_extradata_bsf.c b/mythtv/external/FFmpeg/libavcodec/extract_extradata_bsf.c
new file mode 100644
index 00000000000..d40907a675c
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/extract_extradata_bsf.c
@@ -0,0 +1,338 @@
+/*
+ * 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 <stdint.h>
+
+#include "libavutil/common.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/log.h"
+#include "libavutil/opt.h"
+
+#include "avcodec.h"
+#include "bsf.h"
+#include "h2645_parse.h"
+#include "h264.h"
+#include "hevc.h"
+#include "vc1_common.h"
+
+typedef struct ExtractExtradataContext {
+    const AVClass *class;
+
+    int (*extract)(AVBSFContext *ctx, AVPacket *pkt,
+                   uint8_t **data, int *size);
+
+    /* AVOptions */
+    int remove;
+} ExtractExtradataContext;
+
+static int val_in_array(const int *arr, int len, int val)
+{
+    int i;
+    for (i = 0; i < len; i++)
+        if (arr[i] == val)
+            return 1;
+    return 0;
+}
+
+static int extract_extradata_h2645(AVBSFContext *ctx, AVPacket *pkt,
+                                   uint8_t **data, int *size)
+{
+    static const int extradata_nal_types_hevc[] = {
+        HEVC_NAL_VPS, HEVC_NAL_SPS, HEVC_NAL_PPS,
+    };
+    static const int extradata_nal_types_h264[] = {
+        H264_NAL_SPS, H264_NAL_PPS,
+    };
+
+    ExtractExtradataContext *s = ctx->priv_data;
+
+    H2645Packet h2645_pkt = { 0 };
+    int extradata_size = 0;
+    const int *extradata_nal_types;
+    int nb_extradata_nal_types;
+    int i, has_sps = 0, has_vps = 0, ret = 0;
+
+    if (ctx->par_in->codec_id == AV_CODEC_ID_HEVC) {
+        extradata_nal_types    = extradata_nal_types_hevc;
+        nb_extradata_nal_types = FF_ARRAY_ELEMS(extradata_nal_types_hevc);
+    } else {
+        extradata_nal_types    = extradata_nal_types_h264;
+        nb_extradata_nal_types = FF_ARRAY_ELEMS(extradata_nal_types_h264);
+    }
+
+    ret = ff_h2645_packet_split(&h2645_pkt, pkt->data, pkt->size,
+                                ctx, 0, 0, ctx->par_in->codec_id, 1);
+    if (ret < 0)
+        goto fail;
+
+    for (i = 0; i < h2645_pkt.nb_nals; i++) {
+        H2645NAL *nal = &h2645_pkt.nals[i];
+        if (val_in_array(extradata_nal_types, nb_extradata_nal_types, nal->type)) {
+            extradata_size += nal->raw_size + 3;
+            if (ctx->par_in->codec_id == AV_CODEC_ID_HEVC) {
+                if (nal->type == HEVC_NAL_SPS) has_sps = 1;
+                if (nal->type == HEVC_NAL_VPS) has_vps = 1;
+            } else {
+                if (nal->type == H264_NAL_SPS) has_sps = 1;
+            }
+        }
+    }
+
+    if (extradata_size &&
+        ((ctx->par_in->codec_id == AV_CODEC_ID_HEVC && has_sps && has_vps) ||
+         (ctx->par_in->codec_id == AV_CODEC_ID_H264 && has_sps))) {
+        AVBufferRef *filtered_buf;
+        uint8_t *extradata, *filtered_data;
+
+        if (s->remove) {
+            filtered_buf = av_buffer_alloc(pkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
+            if (!filtered_buf) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+            filtered_data = filtered_buf->data;
+        }
+
+        extradata = av_malloc(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+        if (!extradata) {
+            av_buffer_unref(&filtered_buf);
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+
+        *data = extradata;
+        *size = extradata_size;
+
+        for (i = 0; i < h2645_pkt.nb_nals; i++) {
+            H2645NAL *nal = &h2645_pkt.nals[i];
+            if (val_in_array(extradata_nal_types, nb_extradata_nal_types,
+                             nal->type)) {
+                AV_WB24(extradata, 1); // startcode
+                memcpy(extradata + 3, nal->raw_data, nal->raw_size);
+                extradata += 3 + nal->raw_size;
+            } else if (s->remove) {
+                AV_WB24(filtered_data, 1); // startcode
+                memcpy(filtered_data + 3, nal->raw_data, nal->raw_size);
+                filtered_data += 3 + nal->raw_size;
+            }
+        }
+
+        if (s->remove) {
+            av_buffer_unref(&pkt->buf);
+            pkt->buf  = filtered_buf;
+            pkt->data = filtered_buf->data;
+            pkt->size = filtered_data - filtered_buf->data;
+        }
+    }
+
+fail:
+    ff_h2645_packet_uninit(&h2645_pkt);
+    return ret;
+}
+
+static int extract_extradata_vc1(AVBSFContext *ctx, AVPacket *pkt,
+                                 uint8_t **data, int *size)
+{
+    ExtractExtradataContext *s = ctx->priv_data;
+    const uint8_t *ptr = pkt->data, *end = pkt->data + pkt->size;
+    uint32_t state = UINT32_MAX;
+    int has_extradata = 0, extradata_size = 0;
+
+    while (ptr < end) {
+        ptr = avpriv_find_start_code(ptr, end, &state);
+        if (state == VC1_CODE_SEQHDR || state == VC1_CODE_ENTRYPOINT) {
+            has_extradata = 1;
+        } else if (has_extradata && IS_MARKER(state)) {
+            extradata_size = ptr - 4 - pkt->data;
+            break;
+        }
+    }
+
+    if (extradata_size) {
+        *data = av_malloc(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+        if (!*data)
+            return AVERROR(ENOMEM);
+
+        memcpy(*data, pkt->data, extradata_size);
+        *size = extradata_size;
+
+        if (s->remove) {
+            pkt->data += extradata_size;
+            pkt->size -= extradata_size;
+        }
+    }
+
+    return 0;
+}
+
+static int extract_extradata_mpeg12(AVBSFContext *ctx, AVPacket *pkt,
+                                     uint8_t **data, int *size)
+{
+    ExtractExtradataContext *s = ctx->priv_data;
+    uint32_t state = UINT32_MAX;
+    int i, found = 0;
+
+    for (i = 0; i < pkt->size; i++) {
+        state = (state << 8) | pkt->data[i];
+        if (state == 0x1B3)
+            found = 1;
+        else if (found && state != 0x1B5 && state < 0x200 && state >= 0x100) {
+            if (i > 3) {
+                *size = i - 3;
+                *data = av_malloc(*size + AV_INPUT_BUFFER_PADDING_SIZE);
+                if (!*data)
+                    return AVERROR(ENOMEM);
+
+                memcpy(*data, pkt->data, *size);
+
+                if (s->remove) {
+                    pkt->data += *size;
+                    pkt->size -= *size;
+                }
+            }
+            break;
+        }
+    }
+    return 0;
+}
+
+static int extract_extradata_mpeg4(AVBSFContext *ctx, AVPacket *pkt,
+                                   uint8_t **data, int *size)
+{
+    ExtractExtradataContext *s = ctx->priv_data;
+    const uint8_t *ptr = pkt->data, *end = pkt->data + pkt->size;
+    uint32_t state = UINT32_MAX;
+
+    while (ptr < end) {
+        ptr = avpriv_find_start_code(ptr, end, &state);
+        if (state == 0x1B3 || state == 0x1B6) {
+            if (ptr - pkt->data > 4) {
+                *size = ptr - 4 - pkt->data;
+                *data = av_malloc(*size + AV_INPUT_BUFFER_PADDING_SIZE);
+                if (!*data)
+                    return AVERROR(ENOMEM);
+
+                memcpy(*data, pkt->data, *size);
+
+                if (s->remove) {
+                    pkt->data += *size;
+                    pkt->size -= *size;
+                }
+            }
+            break;
+        }
+    }
+    return 0;
+}
+
+static const struct {
+    enum AVCodecID id;
+    int (*extract)(AVBSFContext *ctx, AVPacket *pkt,
+                   uint8_t **data, int *size);
+} extract_tab[] = {
+    { AV_CODEC_ID_CAVS,       extract_extradata_mpeg4   },
+    { AV_CODEC_ID_H264,       extract_extradata_h2645   },
+    { AV_CODEC_ID_HEVC,       extract_extradata_h2645   },
+    { AV_CODEC_ID_MPEG1VIDEO, extract_extradata_mpeg12  },
+    { AV_CODEC_ID_MPEG2VIDEO, extract_extradata_mpeg12  },
+    { AV_CODEC_ID_MPEG4,      extract_extradata_mpeg4   },
+    { AV_CODEC_ID_VC1,        extract_extradata_vc1     },
+};
+
+static int extract_extradata_init(AVBSFContext *ctx)
+{
+    ExtractExtradataContext *s = ctx->priv_data;
+    int i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(extract_tab); i++) {
+        if (extract_tab[i].id == ctx->par_in->codec_id) {
+            s->extract = extract_tab[i].extract;
+            break;
+        }
+    }
+    if (!s->extract)
+        return AVERROR_BUG;
+
+    return 0;
+}
+
+static int extract_extradata_filter(AVBSFContext *ctx, AVPacket *out)
+{
+    ExtractExtradataContext *s = ctx->priv_data;
+    AVPacket *in;
+    uint8_t *extradata = NULL;
+    int extradata_size;
+    int ret = 0;
+
+    ret = ff_bsf_get_packet(ctx, &in);
+    if (ret < 0)
+        return ret;
+
+    ret = s->extract(ctx, in, &extradata, &extradata_size);
+    if (ret < 0)
+        goto fail;
+
+    if (extradata) {
+        ret = av_packet_add_side_data(in, AV_PKT_DATA_NEW_EXTRADATA,
+                                      extradata, extradata_size);
+        if (ret < 0) {
+            av_freep(&extradata);
+            goto fail;
+        }
+    }
+
+    av_packet_move_ref(out, in);
+
+fail:
+    av_packet_free(&in);
+    return ret;
+}
+
+static const enum AVCodecID codec_ids[] = {
+    AV_CODEC_ID_CAVS,
+    AV_CODEC_ID_H264,
+    AV_CODEC_ID_HEVC,
+    AV_CODEC_ID_MPEG1VIDEO,
+    AV_CODEC_ID_MPEG2VIDEO,
+    AV_CODEC_ID_MPEG4,
+    AV_CODEC_ID_VC1,
+    AV_CODEC_ID_NONE,
+};
+
+#define OFFSET(x) offsetof(ExtractExtradataContext, x)
+static const AVOption options[] = {
+    { "remove", "remove the extradata from the bitstream", OFFSET(remove), AV_OPT_TYPE_INT,
+        { .i64 = 0 }, 0, 1 },
+    { NULL },
+};
+
+static const AVClass extract_extradata_class = {
+    .class_name = "extract_extradata",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+const AVBitStreamFilter ff_extract_extradata_bsf = {
+    .name           = "extract_extradata",
+    .codec_ids      = codec_ids,
+    .priv_data_size = sizeof(ExtractExtradataContext),
+    .priv_class     = &extract_extradata_class,
+    .init           = extract_extradata_init,
+    .filter         = extract_extradata_filter,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/faandct.c b/mythtv/external/FFmpeg/libavcodec/faandct.c
index b6830725d21..38c392bbae0 100644
--- a/mythtv/external/FFmpeg/libavcodec/faandct.c
+++ b/mythtv/external/FFmpeg/libavcodec/faandct.c
@@ -96,17 +96,9 @@ static av_always_inline void row_fdct(FLOAT temp[64], int16_t *data)
         tmp5 += tmp6;
         tmp6 += tmp7;
 
-#if 0
-        {
-            FLOAT z5;
-            z5 = (tmp4 - tmp6) * A5;
-            z2 =  tmp4         * A2 + z5;
-            z4 =  tmp6         * A4 + z5;
-        }
-#else
         z2= tmp4*(A2+A5) - tmp6*A5;
         z4= tmp6*(A4-A5) + tmp4*A5;
-#endif
+
         tmp5*=A1;
 
         z11= tmp7 + tmp5;
@@ -158,17 +150,9 @@ void ff_faandct(int16_t *data)
         tmp5 += tmp6;
         tmp6 += tmp7;
 
-#if 0
-        {
-            FLOAT z5;
-            z5 = (tmp4 - tmp6) * A5;
-            z2 =  tmp4         * A2 + z5;
-            z4 =  tmp6         * A4 + z5;
-        }
-#else
         z2= tmp4*(A2+A5) - tmp6*A5;
         z4= tmp6*(A4-A5) + tmp4*A5;
-#endif
+
         tmp5*=A1;
 
         z11= tmp7 + tmp5;
diff --git a/mythtv/external/FFmpeg/libavcodec/faanidct.c b/mythtv/external/FFmpeg/libavcodec/faanidct.c
index bbaaa3fd5db..3921f82dae4 100644
--- a/mythtv/external/FFmpeg/libavcodec/faanidct.c
+++ b/mythtv/external/FFmpeg/libavcodec/faanidct.c
@@ -47,7 +47,9 @@ B6*B0/8, B6*B1/8, B6*B2/8, B6*B3/8, B6*B4/8, B6*B5/8, B6*B6/8, B6*B7/8,
 B7*B0/8, B7*B1/8, B7*B2/8, B7*B3/8, B7*B4/8, B7*B5/8, B7*B6/8, B7*B7/8,
 };
 
-static inline void p8idct(int16_t data[64], FLOAT temp[64], uint8_t *dest, int stride, int x, int y, int type){
+static inline void p8idct(int16_t data[64], FLOAT temp[64], uint8_t *dest,
+                          ptrdiff_t stride, int x, int y, int type)
+{
     int i;
     FLOAT s04, d04, s17, d17, s26, d26, s53, d53;
     FLOAT os07, os16, os25, os34;
@@ -62,17 +64,8 @@ static inline void p8idct(int16_t data[64], FLOAT temp[64], uint8_t *dest, int s
         od07=  s17 + s53;
         od25= (s17 - s53)*(2*A4);
 
-#if 0 //these 2 are equivalent
-        {
-            FLOAT tmp0;
-            tmp0 = (d17 + d53) *  (2 * A2);
-            od34 =  d17        *  (2 * B6) - tmp0;
-            od16 =  d53        * (-2 * B2) + tmp0;
-        }
-#else
         od34=  d17*(2*(B6-A2)) - d53*(2*A2);
         od16=  d53*(2*(A2-B2)) + d17*(2*A2);
-#endif
 
         od16 -= od07;
         od25 -= od16;
@@ -144,7 +137,8 @@ void ff_faanidct(int16_t block[64]){
     p8idct(block, temp, NULL, 0, 8, 1, 1);
 }
 
-void ff_faanidct_add(uint8_t *dest, int line_size, int16_t block[64]){
+void ff_faanidct_add(uint8_t *dest, ptrdiff_t line_size, int16_t block[64])
+{
     FLOAT temp[64];
     int i;
 
@@ -157,7 +151,8 @@ void ff_faanidct_add(uint8_t *dest, int line_size, int16_t block[64]){
     p8idct(NULL , temp, dest, line_size, 8, 1, 2);
 }
 
-void ff_faanidct_put(uint8_t *dest, int line_size, int16_t block[64]){
+void ff_faanidct_put(uint8_t *dest, ptrdiff_t line_size, int16_t block[64])
+{
     FLOAT temp[64];
     int i;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/faanidct.h b/mythtv/external/FFmpeg/libavcodec/faanidct.h
index 4cd2c7858f8..6f4da67c1b1 100644
--- a/mythtv/external/FFmpeg/libavcodec/faanidct.h
+++ b/mythtv/external/FFmpeg/libavcodec/faanidct.h
@@ -22,10 +22,11 @@
 #ifndef AVCODEC_FAANIDCT_H
 #define AVCODEC_FAANIDCT_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 void ff_faanidct(int16_t block[64]);
-void ff_faanidct_add(uint8_t *dest, int line_size, int16_t block[64]);
-void ff_faanidct_put(uint8_t *dest, int line_size, int16_t block[64]);
+void ff_faanidct_add(uint8_t *dest, ptrdiff_t line_size, int16_t block[64]);
+void ff_faanidct_put(uint8_t *dest, ptrdiff_t line_size, int16_t block[64]);
 
 #endif /* AVCODEC_FAANIDCT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/ffjni.c b/mythtv/external/FFmpeg/libavcodec/ffjni.c
index 3f4c3806730..f5b581f0f68 100644
--- a/mythtv/external/FFmpeg/libavcodec/ffjni.c
+++ b/mythtv/external/FFmpeg/libavcodec/ffjni.c
@@ -85,7 +85,7 @@ JNIEnv *ff_jni_get_env(void *log_ctx)
         av_log(log_ctx, AV_LOG_ERROR, "The specified JNI version is not supported\n");
         break;
     default:
-        av_log(log_ctx, AV_LOG_ERROR, "Failed to get the JNI environment attached to this thread");
+        av_log(log_ctx, AV_LOG_ERROR, "Failed to get the JNI environment attached to this thread\n");
         break;
     }
 
@@ -303,6 +303,11 @@ int ff_jni_init_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfi
 
             last_clazz = *(jclass*)((uint8_t*)jfields + jfields_mapping[i].offset) =
                     global ? (*env)->NewGlobalRef(env, clazz) : clazz;
+
+            if (global) {
+                (*env)->DeleteLocalRef(env, clazz);
+            }
+
         } else {
 
             if (!last_clazz) {
diff --git a/mythtv/external/FFmpeg/libavcodec/fft_template.c b/mythtv/external/FFmpeg/libavcodec/fft_template.c
index 480557f49f7..6c77854e411 100644
--- a/mythtv/external/FFmpeg/libavcodec/fft_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/fft_template.c
@@ -29,11 +29,19 @@
 #include <stdlib.h>
 #include <string.h>
 #include "libavutil/mathematics.h"
+#include "libavutil/thread.h"
 #include "fft.h"
 #include "fft-internal.h"
 
 #if FFT_FIXED_32
 #include "fft_table.h"
+
+static void av_cold fft_lut_init(void)
+{
+    int n = 0;
+    ff_fft_lut_init(ff_fft_offsets_lut, 0, 1 << 17, &n);
+}
+
 #else /* FFT_FIXED_32 */
 
 /* cos(2*pi*x/n) for 0<=x<=n/4, followed by its reverse */
@@ -52,6 +60,66 @@ COSTABLE(16384);
 COSTABLE(32768);
 COSTABLE(65536);
 COSTABLE(131072);
+
+static av_cold void init_ff_cos_tabs(int index)
+{
+    int i;
+    int m = 1<<index;
+    double freq = 2*M_PI/m;
+    FFTSample *tab = FFT_NAME(ff_cos_tabs)[index];
+    for(i=0; i<=m/4; i++)
+        tab[i] = FIX15(cos(i*freq));
+    for(i=1; i<m/4; i++)
+        tab[m/2-i] = tab[i];
+}
+
+typedef struct CosTabsInitOnce {
+    void (*func)(void);
+    AVOnce control;
+} CosTabsInitOnce;
+
+#define INIT_FF_COS_TABS_FUNC(index, size)          \
+static av_cold void init_ff_cos_tabs_ ## size (void)\
+{                                                   \
+    init_ff_cos_tabs(index);                        \
+}
+
+INIT_FF_COS_TABS_FUNC(4, 16)
+INIT_FF_COS_TABS_FUNC(5, 32)
+INIT_FF_COS_TABS_FUNC(6, 64)
+INIT_FF_COS_TABS_FUNC(7, 128)
+INIT_FF_COS_TABS_FUNC(8, 256)
+INIT_FF_COS_TABS_FUNC(9, 512)
+INIT_FF_COS_TABS_FUNC(10, 1024)
+INIT_FF_COS_TABS_FUNC(11, 2048)
+INIT_FF_COS_TABS_FUNC(12, 4096)
+INIT_FF_COS_TABS_FUNC(13, 8192)
+INIT_FF_COS_TABS_FUNC(14, 16384)
+INIT_FF_COS_TABS_FUNC(15, 32768)
+INIT_FF_COS_TABS_FUNC(16, 65536)
+INIT_FF_COS_TABS_FUNC(17, 131072)
+
+static CosTabsInitOnce cos_tabs_init_once[] = {
+    { NULL },
+    { NULL },
+    { NULL },
+    { NULL },
+    { init_ff_cos_tabs_16, AV_ONCE_INIT },
+    { init_ff_cos_tabs_32, AV_ONCE_INIT },
+    { init_ff_cos_tabs_64, AV_ONCE_INIT },
+    { init_ff_cos_tabs_128, AV_ONCE_INIT },
+    { init_ff_cos_tabs_256, AV_ONCE_INIT },
+    { init_ff_cos_tabs_512, AV_ONCE_INIT },
+    { init_ff_cos_tabs_1024, AV_ONCE_INIT },
+    { init_ff_cos_tabs_2048, AV_ONCE_INIT },
+    { init_ff_cos_tabs_4096, AV_ONCE_INIT },
+    { init_ff_cos_tabs_8192, AV_ONCE_INIT },
+    { init_ff_cos_tabs_16384, AV_ONCE_INIT },
+    { init_ff_cos_tabs_32768, AV_ONCE_INIT },
+    { init_ff_cos_tabs_65536, AV_ONCE_INIT },
+    { init_ff_cos_tabs_131072, AV_ONCE_INIT },
+};
+
 #endif
 COSTABLE_CONST FFTSample * const FFT_NAME(ff_cos_tabs)[] = {
     NULL, NULL, NULL, NULL,
@@ -90,14 +158,7 @@ static int split_radix_permutation(int i, int n, int inverse)
 av_cold void ff_init_ff_cos_tabs(int index)
 {
 #if (!CONFIG_HARDCODED_TABLES) && (!FFT_FIXED_32)
-    int i;
-    int m = 1<<index;
-    double freq = 2*M_PI/m;
-    FFTSample *tab = FFT_NAME(ff_cos_tabs)[index];
-    for(i=0; i<=m/4; i++)
-        tab[i] = FIX15(cos(i*freq));
-    for(i=1; i<m/4; i++)
-        tab[m/2-i] = tab[i];
+    ff_thread_once(&cos_tabs_init_once[index].control, cos_tabs_init_once[index].func);
 #endif
 }
 
@@ -176,8 +237,8 @@ av_cold int ff_fft_init(FFTContext *s, int nbits, int inverse)
 
 #if FFT_FIXED_32
     {
-        int n=0;
-        ff_fft_lut_init(ff_fft_offsets_lut, 0, 1 << 17, &n);
+        static AVOnce control = AV_ONCE_INIT;
+        ff_thread_once(&control, fft_lut_init);
     }
 #else /* FFT_FIXED_32 */
 #if FFT_FLOAT
@@ -249,7 +310,7 @@ static void fft_calc_c(FFTContext *s, FFTComplex *z) {
 
     int nbits, i, n, num_transforms, offset, step;
     int n4, n2, n34;
-    FFTSample tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
+    unsigned tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
     FFTComplex *tmpz;
     const int fft_size = (1 << s->nbits);
     int64_t accu;
@@ -260,14 +321,14 @@ static void fft_calc_c(FFTContext *s, FFTComplex *z) {
         offset = ff_fft_offsets_lut[n] << 2;
         tmpz = z + offset;
 
-        tmp1 = tmpz[0].re + tmpz[1].re;
-        tmp5 = tmpz[2].re + tmpz[3].re;
-        tmp2 = tmpz[0].im + tmpz[1].im;
-        tmp6 = tmpz[2].im + tmpz[3].im;
-        tmp3 = tmpz[0].re - tmpz[1].re;
-        tmp8 = tmpz[2].im - tmpz[3].im;
-        tmp4 = tmpz[0].im - tmpz[1].im;
-        tmp7 = tmpz[2].re - tmpz[3].re;
+        tmp1 = tmpz[0].re + (unsigned)tmpz[1].re;
+        tmp5 = tmpz[2].re + (unsigned)tmpz[3].re;
+        tmp2 = tmpz[0].im + (unsigned)tmpz[1].im;
+        tmp6 = tmpz[2].im + (unsigned)tmpz[3].im;
+        tmp3 = tmpz[0].re - (unsigned)tmpz[1].re;
+        tmp8 = tmpz[2].im - (unsigned)tmpz[3].im;
+        tmp4 = tmpz[0].im - (unsigned)tmpz[1].im;
+        tmp7 = tmpz[2].re - (unsigned)tmpz[3].re;
 
         tmpz[0].re = tmp1 + tmp5;
         tmpz[2].re = tmp1 - tmp5;
@@ -288,19 +349,19 @@ static void fft_calc_c(FFTContext *s, FFTComplex *z) {
         offset = ff_fft_offsets_lut[n] << 3;
         tmpz = z + offset;
 
-        tmp1 = tmpz[4].re + tmpz[5].re;
-        tmp3 = tmpz[6].re + tmpz[7].re;
-        tmp2 = tmpz[4].im + tmpz[5].im;
-        tmp4 = tmpz[6].im + tmpz[7].im;
+        tmp1 = tmpz[4].re + (unsigned)tmpz[5].re;
+        tmp3 = tmpz[6].re + (unsigned)tmpz[7].re;
+        tmp2 = tmpz[4].im + (unsigned)tmpz[5].im;
+        tmp4 = tmpz[6].im + (unsigned)tmpz[7].im;
         tmp5 = tmp1 + tmp3;
         tmp7 = tmp1 - tmp3;
         tmp6 = tmp2 + tmp4;
         tmp8 = tmp2 - tmp4;
 
-        tmp1 = tmpz[4].re - tmpz[5].re;
-        tmp2 = tmpz[4].im - tmpz[5].im;
-        tmp3 = tmpz[6].re - tmpz[7].re;
-        tmp4 = tmpz[6].im - tmpz[7].im;
+        tmp1 = tmpz[4].re - (unsigned)tmpz[5].re;
+        tmp2 = tmpz[4].im - (unsigned)tmpz[5].im;
+        tmp3 = tmpz[6].re - (unsigned)tmpz[7].re;
+        tmp4 = tmpz[6].im - (unsigned)tmpz[7].im;
 
         tmpz[4].re = tmpz[0].re - tmp5;
         tmpz[0].re = tmpz[0].re + tmp5;
@@ -311,13 +372,13 @@ static void fft_calc_c(FFTContext *s, FFTComplex *z) {
         tmpz[6].im = tmpz[2].im + tmp7;
         tmpz[2].im = tmpz[2].im - tmp7;
 
-        accu = (int64_t)Q31(M_SQRT1_2)*(tmp1 + tmp2);
+        accu = (int64_t)Q31(M_SQRT1_2)*(int)(tmp1 + tmp2);
         tmp5 = (int32_t)((accu + 0x40000000) >> 31);
-        accu = (int64_t)Q31(M_SQRT1_2)*(tmp3 - tmp4);
+        accu = (int64_t)Q31(M_SQRT1_2)*(int)(tmp3 - tmp4);
         tmp7 = (int32_t)((accu + 0x40000000) >> 31);
-        accu = (int64_t)Q31(M_SQRT1_2)*(tmp2 - tmp1);
+        accu = (int64_t)Q31(M_SQRT1_2)*(int)(tmp2 - tmp1);
         tmp6 = (int32_t)((accu + 0x40000000) >> 31);
-        accu = (int64_t)Q31(M_SQRT1_2)*(tmp3 + tmp4);
+        accu = (int64_t)Q31(M_SQRT1_2)*(int)(tmp3 + tmp4);
         tmp8 = (int32_t)((accu + 0x40000000) >> 31);
         tmp1 = tmp5 + tmp7;
         tmp3 = tmp5 - tmp7;
@@ -348,10 +409,10 @@ static void fft_calc_c(FFTContext *s, FFTComplex *z) {
             offset = ff_fft_offsets_lut[n] << nbits;
             tmpz = z + offset;
 
-            tmp5 = tmpz[ n2].re + tmpz[n34].re;
-            tmp1 = tmpz[ n2].re - tmpz[n34].re;
-            tmp6 = tmpz[ n2].im + tmpz[n34].im;
-            tmp2 = tmpz[ n2].im - tmpz[n34].im;
+            tmp5 = tmpz[ n2].re + (unsigned)tmpz[n34].re;
+            tmp1 = tmpz[ n2].re - (unsigned)tmpz[n34].re;
+            tmp6 = tmpz[ n2].im + (unsigned)tmpz[n34].im;
+            tmp2 = tmpz[ n2].im - (unsigned)tmpz[n34].im;
 
             tmpz[ n2].re = tmpz[ 0].re - tmp5;
             tmpz[  0].re = tmpz[ 0].re + tmp5;
diff --git a/mythtv/external/FFmpeg/libavcodec/ffv1.h b/mythtv/external/FFmpeg/libavcodec/ffv1.h
index c2bae1e6da1..653138b0702 100644
--- a/mythtv/external/FFmpeg/libavcodec/ffv1.h
+++ b/mythtv/external/FFmpeg/libavcodec/ffv1.h
@@ -74,7 +74,7 @@ typedef struct PlaneContext {
     uint8_t interlace_bit_state[2];
 } PlaneContext;
 
-#define MAX_SLICES 256
+#define MAX_SLICES 1024
 
 typedef struct FFV1Context {
     AVClass *class;
diff --git a/mythtv/external/FFmpeg/libavcodec/ffv1dec.c b/mythtv/external/FFmpeg/libavcodec/ffv1dec.c
index d8f35c34b99..5eadb6b1586 100644
--- a/mythtv/external/FFmpeg/libavcodec/ffv1dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ffv1dec.c
@@ -45,7 +45,8 @@ static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state,
     if (get_rac(c, state + 0))
         return 0;
     else {
-        int i, e, a;
+        int i, e;
+        unsigned a;
         e = 0;
         while (get_rac(c, state + 1 + FFMIN(e, 9))) { // 1..10
             e++;
@@ -83,12 +84,7 @@ static inline int get_vlc_symbol(GetBitContext *gb, VlcState *const state,
     ff_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
             v, state->bias, state->error_sum, state->drift, state->count, k);
 
-#if 0 // JPEG LS
-    if (k == 0 && 2 * state->drift <= -state->count)
-        v ^= (-1);
-#else
     v ^= ((2 * state->drift + state->count) >> 31);
-#endif
 
     ret = fold(v + state->bias, bits);
 
@@ -97,6 +93,19 @@ static inline int get_vlc_symbol(GetBitContext *gb, VlcState *const state,
     return ret;
 }
 
+static int is_input_end(FFV1Context *s)
+{
+    if (s->ac != AC_GOLOMB_RICE) {
+        RangeCoder *const c = &s->c;
+        if (c->overread > MAX_OVERREAD)
+            return AVERROR_INVALIDDATA;
+    } else {
+        if (get_bits_left(&s->gb) < 1)
+            return AVERROR_INVALIDDATA;
+    }
+    return 0;
+}
+
 #define TYPE int16_t
 #define RENAME(name) name
 #include "ffv1dec_template.c"
@@ -107,7 +116,7 @@ static inline int get_vlc_symbol(GetBitContext *gb, VlcState *const state,
 #define RENAME(name) name ## 32
 #include "ffv1dec_template.c"
 
-static void decode_plane(FFV1Context *s, uint8_t *src,
+static int decode_plane(FFV1Context *s, uint8_t *src,
                          int w, int h, int stride, int plane_index,
                          int pixel_stride)
 {
@@ -131,23 +140,28 @@ static void decode_plane(FFV1Context *s, uint8_t *src,
 
 // { START_TIMER
         if (s->avctx->bits_per_raw_sample <= 8) {
-            decode_line(s, w, sample, plane_index, 8);
+            int ret = decode_line(s, w, sample, plane_index, 8);
+            if (ret < 0)
+                return ret;
             for (x = 0; x < w; x++)
                 src[x*pixel_stride + stride * y] = sample[1][x];
         } else {
-            decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
+            int ret = decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
+            if (ret < 0)
+                return ret;
             if (s->packed_at_lsb) {
                 for (x = 0; x < w; x++) {
                     ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x];
                 }
             } else {
                 for (x = 0; x < w; x++) {
-                    ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
+                    ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x] << (16 - s->avctx->bits_per_raw_sample) | ((uint16_t **)sample)[1][x] >> (2 * s->avctx->bits_per_raw_sample - 16);
                 }
             }
         }
 // STOP_TIMER("decode-line") }
     }
+    return 0;
 }
 
 static int decode_slice_header(FFV1Context *f, FFV1Context *fs)
@@ -358,7 +372,7 @@ static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
     memset(state, 128, sizeof(state));
 
     for (v = 0; i < 128; v++) {
-        unsigned len = get_symbol(c, state, 0) + 1;
+        unsigned len = get_symbol(c, state, 0) + 1U;
 
         if (len > 128 - i || !len)
             return AVERROR_INVALIDDATA;
@@ -575,8 +589,19 @@ static int read_header(FFV1Context *f)
         if (!f->transparency && !f->chroma_planes) {
             if (f->avctx->bits_per_raw_sample <= 8)
                 f->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
-            else
+            else if (f->avctx->bits_per_raw_sample == 10) {
+                f->packed_at_lsb = 1;
+                f->avctx->pix_fmt = AV_PIX_FMT_GRAY10;
+            } else if (f->avctx->bits_per_raw_sample == 12) {
+                f->packed_at_lsb = 1;
+                f->avctx->pix_fmt = AV_PIX_FMT_GRAY12;
+            } else if (f->avctx->bits_per_raw_sample == 16) {
+                f->packed_at_lsb = 1;
+                f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
+            } else if (f->avctx->bits_per_raw_sample < 16) {
                 f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
+            } else
+                return AVERROR(ENOSYS);
         } else if (f->transparency && !f->chroma_planes) {
             if (f->avctx->bits_per_raw_sample <= 8)
                 f->avctx->pix_fmt = AV_PIX_FMT_YA8;
@@ -625,13 +650,22 @@ static int read_header(FFV1Context *f)
             case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P10; break;
             case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P10; break;
             }
+        } else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency) {
+            f->packed_at_lsb = 1;
+            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
+            case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P12; break;
+            case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P12; break;
+            case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P12; break;
+            }
         } else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency){
+            f->packed_at_lsb = 1;
             switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
             case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P16; break;
             case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P16; break;
             case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P16; break;
             }
         } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency){
+            f->packed_at_lsb = 1;
             switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
             case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P16; break;
             case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P16; break;
@@ -683,7 +717,7 @@ static int read_header(FFV1Context *f)
     } else {
         const uint8_t *p = c->bytestream_end;
         for (f->slice_count = 0;
-             f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start;
+             f->slice_count < MAX_SLICES && 3 + 5*!!f->ec < p - c->bytestream_start;
              f->slice_count++) {
             int trailer = 3 + 5*!!f->ec;
             int size = AV_RB24(p-trailer);
@@ -855,7 +889,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
                 fs->slice_damaged = 1;
             }
             if (avctx->debug & FF_DEBUG_PICT_INFO) {
-                av_log(avctx, AV_LOG_DEBUG, "slice %d, CRC: 0x%08X\n", i, AV_RB32(buf_p + v - 4));
+                av_log(avctx, AV_LOG_DEBUG, "slice %d, CRC: 0x%08"PRIX32"\n", i, AV_RB32(buf_p + v - 4));
             }
         }
 
@@ -883,7 +917,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
             const uint8_t *src[4];
             uint8_t *dst[4];
             ff_thread_await_progress(&f->last_picture, INT_MAX, 0);
-            for (j = 0; j < 4; j++) {
+            for (j = 0; j < desc->nb_components; j++) {
                 int pixshift = desc->comp[j].depth > 8;
                 int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
                 int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
@@ -891,6 +925,12 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
                          (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
                 src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] *
                          (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
+
+            }
+            if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
+                desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
+                dst[1] = p->data[1];
+                src[1] = f->last_picture.f->data[1];
             }
             av_image_copy(dst, p->linesize, src,
                           f->last_picture.f->linesize,
diff --git a/mythtv/external/FFmpeg/libavcodec/ffv1dec_template.c b/mythtv/external/FFmpeg/libavcodec/ffv1dec_template.c
index 21af155bba2..37df7667737 100644
--- a/mythtv/external/FFmpeg/libavcodec/ffv1dec_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/ffv1dec_template.c
@@ -20,7 +20,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-static av_always_inline void RENAME(decode_line)(FFV1Context *s, int w,
+static av_always_inline int RENAME(decode_line)(FFV1Context *s, int w,
                                                  TYPE *sample[2],
                                                  int plane_index, int bits)
 {
@@ -31,6 +31,9 @@ static av_always_inline void RENAME(decode_line)(FFV1Context *s, int w,
     int run_mode  = 0;
     int run_index = s->run_index;
 
+    if (is_input_end(s))
+        return AVERROR_INVALIDDATA;
+
     if (s->slice_coding_mode == 1) {
         int i;
         for (x = 0; x < w; x++) {
@@ -41,7 +44,7 @@ static av_always_inline void RENAME(decode_line)(FFV1Context *s, int w,
             }
             sample[1][x] = v;
         }
-        return;
+        return 0;
     }
 
     for (x = 0; x < w; x++) {
@@ -96,11 +99,12 @@ static av_always_inline void RENAME(decode_line)(FFV1Context *s, int w,
         }
 
         if (sign)
-            diff = -diff;
+            diff = -(unsigned)diff;
 
-        sample[1][x] = av_mod_uintp2(RENAME(predict)(sample[1] + x, sample[0] + x) + diff, bits);
+        sample[1][x] = av_mod_uintp2(RENAME(predict)(sample[1] + x, sample[0] + x) + (SUINT)diff, bits);
     }
     s->run_index = run_index;
+    return 0;
 }
 
 static void RENAME(decode_rgb_frame)(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3])
@@ -149,7 +153,7 @@ static void RENAME(decode_rgb_frame)(FFV1Context *s, uint8_t *src[3], int w, int
             }
 
             if (lbd)
-                *((uint32_t*)(src[0] + x*4 + stride[0]*y)) = b + (g<<8) + (r<<16) + (a<<24);
+                *((uint32_t*)(src[0] + x*4 + stride[0]*y)) = b + ((unsigned)g<<8) + ((unsigned)r<<16) + ((unsigned)a<<24);
             else if (sizeof(TYPE) == 4) {
                 *((uint16_t*)(src[0] + x*2 + stride[0]*y)) = g;
                 *((uint16_t*)(src[1] + x*2 + stride[1]*y)) = b;
diff --git a/mythtv/external/FFmpeg/libavcodec/ffv1enc.c b/mythtv/external/FFmpeg/libavcodec/ffv1enc.c
index 68d311d1b87..c9a885ebfaa 100644
--- a/mythtv/external/FFmpeg/libavcodec/ffv1enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/ffv1enc.c
@@ -252,14 +252,7 @@ static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,
 
     av_assert2(k <= 13);
 
-#if 0 // JPEG LS
-    if (k == 0 && 2 * state->drift <= -state->count)
-        code = v ^ (-1);
-    else
-        code = v;
-#else
     code = v ^ ((2 * state->drift + state->count) >> 31);
-#endif
 
     ff_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
             state->bias, state->error_sum, state->drift, state->count, k);
@@ -573,15 +566,22 @@ FF_ENABLE_DEPRECATION_WARNINGS
     case AV_PIX_FMT_YUVA420P9:
         if (!avctx->bits_per_raw_sample)
             s->bits_per_raw_sample = 9;
+    case AV_PIX_FMT_GRAY10:
     case AV_PIX_FMT_YUV444P10:
     case AV_PIX_FMT_YUV420P10:
     case AV_PIX_FMT_YUV422P10:
     case AV_PIX_FMT_YUVA444P10:
     case AV_PIX_FMT_YUVA422P10:
     case AV_PIX_FMT_YUVA420P10:
-        s->packed_at_lsb = 1;
         if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
             s->bits_per_raw_sample = 10;
+    case AV_PIX_FMT_GRAY12:
+    case AV_PIX_FMT_YUV444P12:
+    case AV_PIX_FMT_YUV420P12:
+    case AV_PIX_FMT_YUV422P12:
+        s->packed_at_lsb = 1;
+        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
+            s->bits_per_raw_sample = 12;
     case AV_PIX_FMT_GRAY16:
     case AV_PIX_FMT_YUV444P16:
     case AV_PIX_FMT_YUV422P16:
@@ -848,10 +848,22 @@ FF_ENABLE_DEPRECATION_WARNINGS
     }
 
     if (s->version > 1) {
+        int plane_count = 1 + 2*s->chroma_planes + s->transparency;
+        int max_h_slices = AV_CEIL_RSHIFT(avctx->width , s->chroma_h_shift);
+        int max_v_slices = AV_CEIL_RSHIFT(avctx->height, s->chroma_v_shift);
         s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;
-        for (; s->num_v_slices < 9; s->num_v_slices++) {
+
+        s->num_v_slices = FFMIN(s->num_v_slices, max_v_slices);
+
+        for (; s->num_v_slices < 32; s->num_v_slices++) {
             for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {
-                if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)
+                int maxw = (avctx->width  + s->num_h_slices - 1) / s->num_h_slices;
+                int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;
+                if (s->num_h_slices > max_h_slices || s->num_v_slices > max_v_slices)
+                    continue;
+                if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)
+                    continue;
+                if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
                     goto slices_ok;
             }
         }
@@ -1089,7 +1101,6 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     FFV1Context *f      = avctx->priv_data;
     RangeCoder *const c = &f->slice_context[0]->c;
     AVFrame *const p    = f->picture.f;
-    int used_count      = 0;
     uint8_t keystate    = 128;
     uint8_t *buf_p;
     int i, ret;
@@ -1145,6 +1156,11 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     if (f->version > 3)
         maxsize = AV_INPUT_BUFFER_MIN_SIZE + avctx->width*avctx->height*3LL*4;
 
+    if (maxsize > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32) {
+        av_log(avctx, AV_LOG_WARNING, "Cannot allocate worst case packet size, the encoding could fail\n");
+        maxsize = INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE - 32;
+    }
+
     if ((ret = ff_alloc_packet2(avctx, pkt, maxsize, 0)) < 0)
         return ret;
 
@@ -1178,11 +1194,17 @@ FF_ENABLE_DEPRECATION_WARNINGS
         }
     }
 
-    for (i = 1; i < f->slice_count; i++) {
+    for (i = 0; i < f->slice_count; i++) {
         FFV1Context *fs = f->slice_context[i];
-        uint8_t *start  = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;
+        uint8_t *start  = pkt->data + pkt->size * (int64_t)i / f->slice_count;
         int len         = pkt->size / f->slice_count;
-        ff_init_range_encoder(&fs->c, start, len);
+        if (i) {
+            ff_init_range_encoder(&fs->c, start, len);
+        } else {
+            av_assert0(fs->c.bytestream_end >= fs->c.bytestream_start + len);
+            av_assert0(fs->c.bytestream < fs->c.bytestream_start + len);
+            fs->c.bytestream_end = fs->c.bytestream_start + len;
+        }
     }
     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,
                    f->slice_count, sizeof(void *));
@@ -1292,12 +1314,14 @@ AVCodec ff_ffv1_encoder = {
         AV_PIX_FMT_YUV410P,   AV_PIX_FMT_0RGB32,    AV_PIX_FMT_RGB32,     AV_PIX_FMT_YUV420P16,
         AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,
         AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
+        AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
         AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
         AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
         AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
         AV_PIX_FMT_GRAY16,    AV_PIX_FMT_GRAY8,     AV_PIX_FMT_GBRP9,     AV_PIX_FMT_GBRP10,
         AV_PIX_FMT_GBRP12,    AV_PIX_FMT_GBRP14,
         AV_PIX_FMT_YA8,
+        AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
         AV_PIX_FMT_GBRP16, AV_PIX_FMT_RGB48,
         AV_PIX_FMT_NONE
 
diff --git a/mythtv/external/FFmpeg/libavcodec/fic.c b/mythtv/external/FFmpeg/libavcodec/fic.c
index d3952a4c015..d7ee370423c 100644
--- a/mythtv/external/FFmpeg/libavcodec/fic.c
+++ b/mythtv/external/FFmpeg/libavcodec/fic.c
@@ -34,6 +34,7 @@ typedef struct FICThreadContext {
     int slice_h;
     int src_size;
     int y_off;
+    int p_frame;
 } FICThreadContext;
 
 typedef struct FICContext {
@@ -84,26 +85,26 @@ static const uint8_t fic_header[7] = { 0, 0, 1, 'F', 'I', 'C', 'V' };
 
 static av_always_inline void fic_idct(int16_t *blk, int step, int shift, int rnd)
 {
-    const int t0 =  27246 * blk[3 * step] + 18405 * blk[5 * step];
-    const int t1 =  27246 * blk[5 * step] - 18405 * blk[3 * step];
-    const int t2 =   6393 * blk[7 * step] + 32139 * blk[1 * step];
-    const int t3 =   6393 * blk[1 * step] - 32139 * blk[7 * step];
-    const int t4 = 5793 * (t2 + t0 + 0x800 >> 12);
-    const int t5 = 5793 * (t3 + t1 + 0x800 >> 12);
-    const int t6 = t2 - t0;
-    const int t7 = t3 - t1;
-    const int t8 =  17734 * blk[2 * step] - 42813 * blk[6 * step];
-    const int t9 =  17734 * blk[6 * step] + 42814 * blk[2 * step];
-    const int tA = (blk[0 * step] - blk[4 * step] << 15) + rnd;
-    const int tB = (blk[0 * step] + blk[4 * step] << 15) + rnd;
-    blk[0 * step] = (  t4       + t9 + tB) >> shift;
-    blk[1 * step] = (  t6 + t7  + t8 + tA) >> shift;
-    blk[2 * step] = (  t6 - t7  - t8 + tA) >> shift;
-    blk[3 * step] = (  t5       - t9 + tB) >> shift;
-    blk[4 * step] = ( -t5       - t9 + tB) >> shift;
-    blk[5 * step] = (-(t6 - t7) - t8 + tA) >> shift;
-    blk[6 * step] = (-(t6 + t7) + t8 + tA) >> shift;
-    blk[7 * step] = ( -t4       + t9 + tB) >> shift;
+    const unsigned t0 =  27246 * blk[3 * step] + 18405 * blk[5 * step];
+    const unsigned t1 =  27246 * blk[5 * step] - 18405 * blk[3 * step];
+    const unsigned t2 =   6393 * blk[7 * step] + 32139 * blk[1 * step];
+    const unsigned t3 =   6393 * blk[1 * step] - 32139 * blk[7 * step];
+    const unsigned t4 = 5793U * ((int)(t2 + t0 + 0x800) >> 12);
+    const unsigned t5 = 5793U * ((int)(t3 + t1 + 0x800) >> 12);
+    const unsigned t6 = t2 - t0;
+    const unsigned t7 = t3 - t1;
+    const unsigned t8 =  17734 * blk[2 * step] - 42813 * blk[6 * step];
+    const unsigned t9 =  17734 * blk[6 * step] + 42814 * blk[2 * step];
+    const unsigned tA = (blk[0 * step] - blk[4 * step]) * 32768 + rnd;
+    const unsigned tB = (blk[0 * step] + blk[4 * step]) * 32768 + rnd;
+    blk[0 * step] = (int)(  t4       + t9 + tB) >> shift;
+    blk[1 * step] = (int)(  t6 + t7  + t8 + tA) >> shift;
+    blk[2 * step] = (int)(  t6 - t7  - t8 + tA) >> shift;
+    blk[3 * step] = (int)(  t5       - t9 + tB) >> shift;
+    blk[4 * step] = (int)( -t5       - t9 + tB) >> shift;
+    blk[5 * step] = (int)(-(t6 - t7) - t8 + tA) >> shift;
+    blk[6 * step] = (int)(-(t6 + t7) + t8 + tA) >> shift;
+    blk[7 * step] = (int)( -t4       + t9 + tB) >> shift;
 }
 
 static void fic_idct_put(uint8_t *dst, int stride, int16_t *block)
@@ -133,16 +134,13 @@ static void fic_idct_put(uint8_t *dst, int stride, int16_t *block)
     }
 }
 static int fic_decode_block(FICContext *ctx, GetBitContext *gb,
-                            uint8_t *dst, int stride, int16_t *block)
+                            uint8_t *dst, int stride, int16_t *block, int *is_p)
 {
     int i, num_coeff;
 
     /* Is it a skip block? */
     if (get_bits1(gb)) {
-        /* This is a P-frame. */
-        ctx->frame->key_frame = 0;
-        ctx->frame->pict_type = AV_PICTURE_TYPE_P;
-
+        *is_p = 1;
         return 0;
     }
 
@@ -152,9 +150,13 @@ static int fic_decode_block(FICContext *ctx, GetBitContext *gb,
     if (num_coeff > 64)
         return AVERROR_INVALIDDATA;
 
-    for (i = 0; i < num_coeff; i++)
-        block[ff_zigzag_direct[i]] = get_se_golomb(gb) *
+    for (i = 0; i < num_coeff; i++) {
+        int v = get_se_golomb(gb);
+        if (v < -2048 || v > 2048)
+             return AVERROR_INVALIDDATA;
+        block[ff_zigzag_direct[i]] = v *
                                      ctx->qmat[ff_zigzag_direct[i]];
+    }
 
     fic_idct_put(dst, stride, block);
 
@@ -182,7 +184,8 @@ static int fic_decode_slice(AVCodecContext *avctx, void *tdata)
             for (x = 0; x < (ctx->aligned_width >> !!p); x += 8) {
                 int ret;
 
-                if ((ret = fic_decode_block(ctx, &gb, dst + x, stride, tctx->block)) != 0)
+                if ((ret = fic_decode_block(ctx, &gb, dst + x, stride,
+                                            tctx->block, &tctx->p_frame)) != 0)
                     return ret;
             }
 
@@ -348,15 +351,6 @@ static int fic_decode_frame(AVCodecContext *avctx, void *data,
         return AVERROR_INVALIDDATA;
     }
 
-    /*
-     * Set the frametype to I initially. It will be set to P if the frame
-     * has any dependencies (skip blocks). There will be a race condition
-     * inside the slice decode function to set these, but we do not care.
-     * since they will only ever be set to 0/P.
-     */
-    ctx->frame->key_frame = 1;
-    ctx->frame->pict_type = AV_PICTURE_TYPE_I;
-
     /* Allocate slice data. */
     av_fast_malloc(&ctx->slice_data, &ctx->slice_data_size,
                    nslices * sizeof(ctx->slice_data[0]));
@@ -398,6 +392,15 @@ static int fic_decode_frame(AVCodecContext *avctx, void *data,
                               NULL, nslices, sizeof(ctx->slice_data[0]))) < 0)
         return ret;
 
+    ctx->frame->key_frame = 1;
+    ctx->frame->pict_type = AV_PICTURE_TYPE_I;
+    for (slice = 0; slice < nslices; slice++) {
+        if (ctx->slice_data[slice].p_frame) {
+            ctx->frame->key_frame = 0;
+            ctx->frame->pict_type = AV_PICTURE_TYPE_P;
+            break;
+        }
+    }
     av_frame_free(&ctx->final_frame);
     ctx->final_frame = av_frame_clone(ctx->frame);
     if (!ctx->final_frame) {
diff --git a/mythtv/external/FFmpeg/libavcodec/fits.c b/mythtv/external/FFmpeg/libavcodec/fits.c
new file mode 100644
index 00000000000..365347fc640
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/fits.c
@@ -0,0 +1,203 @@
+/*
+ * FITS implementation of common functions
+ * Copyright (c) 2017 Paras Chadha
+ *
+ * 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 "avcodec.h"
+#include "libavutil/dict.h"
+#include "fits.h"
+
+int avpriv_fits_header_init(FITSHeader *header, FITSHeaderState state)
+{
+    header->state = state;
+    header->naxis_index = 0;
+    header->blank_found = 0;
+    header->pcount = 0;
+    header->gcount = 1;
+    header->groups = 0;
+    header->rgb = 0;
+    header->image_extension = 0;
+    header->bscale = 1.0;
+    header->bzero = 0;
+    header->data_min_found = 0;
+    header->data_max_found = 0;
+    return 0;
+}
+
+static int dict_set_if_not_null(AVDictionary ***metadata, char *keyword, char *value)
+{
+    if (metadata)
+        av_dict_set(*metadata, keyword, value, 0);
+    return 0;
+}
+
+/**
+ * Extract keyword and value from a header line (80 bytes) and store them in keyword and value strings respectively
+ * @param ptr8 pointer to the data
+ * @param keyword pointer to the char array in which keyword is to be stored
+ * @param value pointer to the char array in which value is to be stored
+ * @return 0 if calculated successfully otherwise AVERROR_INVALIDDATA
+ */
+static int read_keyword_value(const uint8_t *ptr8, char *keyword, char *value)
+{
+    int i;
+
+    for (i = 0; i < 8 && ptr8[i] != ' '; i++) {
+        keyword[i] = ptr8[i];
+    }
+    keyword[i] = '\0';
+
+    if (ptr8[8] == '=') {
+        i = 10;
+        while (i < 80 && ptr8[i] == ' ') {
+            i++;
+        }
+
+        if (i < 80) {
+            *value++ = ptr8[i];
+            i++;
+            if (ptr8[i-1] == '\'') {
+                for (; i < 80 && ptr8[i] != '\''; i++) {
+                    *value++ = ptr8[i];
+                }
+                *value++ = '\'';
+            } else if (ptr8[i-1] == '(') {
+                for (; i < 80 && ptr8[i] != ')'; i++) {
+                    *value++ = ptr8[i];
+                }
+                *value++ = ')';
+            } else {
+                for (; i < 80 && ptr8[i] != ' ' && ptr8[i] != '/'; i++) {
+                    *value++ = ptr8[i];
+                }
+            }
+        }
+    }
+    *value = '\0';
+    return 0;
+}
+
+#define CHECK_KEYWORD(key) \
+    if (strcmp(keyword, key)) { \
+        av_log(avcl, AV_LOG_ERROR, "expected %s keyword, found %s = %s\n", key, keyword, value); \
+        return AVERROR_INVALIDDATA; \
+    }
+
+#define CHECK_VALUE(key, val) \
+    if (sscanf(value, "%d", &header->val) != 1) { \
+        av_log(avcl, AV_LOG_ERROR, "invalid value of %s keyword, %s = %s\n", key, keyword, value); \
+        return AVERROR_INVALIDDATA; \
+    }
+
+int avpriv_fits_header_parse_line(void *avcl, FITSHeader *header, const uint8_t line[80], AVDictionary ***metadata)
+{
+    int dim_no, ret;
+    int64_t t;
+    double d;
+    char keyword[10], value[72], c;
+
+    read_keyword_value(line, keyword, value);
+    switch (header->state) {
+    case STATE_SIMPLE:
+        CHECK_KEYWORD("SIMPLE");
+
+        if (value[0] == 'F') {
+            av_log(avcl, AV_LOG_WARNING, "not a standard FITS file\n");
+        } else if (value[0] != 'T') {
+            av_log(avcl, AV_LOG_ERROR, "invalid value of SIMPLE keyword, SIMPLE = %c\n", value[0]);
+            return AVERROR_INVALIDDATA;
+        }
+
+        header->state = STATE_BITPIX;
+        break;
+    case STATE_XTENSION:
+        CHECK_KEYWORD("XTENSION");
+
+        if (!strcmp(value, "'IMAGE   '")) {
+            header->image_extension = 1;
+        }
+
+        header->state = STATE_BITPIX;
+        break;
+    case STATE_BITPIX:
+        CHECK_KEYWORD("BITPIX");
+        CHECK_VALUE("BITPIX", bitpix);
+        dict_set_if_not_null(metadata, keyword, value);
+
+        header->state = STATE_NAXIS;
+        break;
+    case STATE_NAXIS:
+        CHECK_KEYWORD("NAXIS");
+        CHECK_VALUE("NAXIS", naxis);
+        dict_set_if_not_null(metadata, keyword, value);
+
+        if (header->naxis) {
+            header->state = STATE_NAXIS_N;
+        } else {
+            header->state = STATE_REST;
+        }
+        break;
+    case STATE_NAXIS_N:
+        ret = sscanf(keyword, "NAXIS%d", &dim_no);
+        if (ret != 1 || dim_no != header->naxis_index + 1) {
+            av_log(avcl, AV_LOG_ERROR, "expected NAXIS%d keyword, found %s = %s\n", header->naxis_index + 1, keyword, value);
+            return AVERROR_INVALIDDATA;
+        }
+
+        if (sscanf(value, "%d", &header->naxisn[header->naxis_index]) != 1) {
+            av_log(avcl, AV_LOG_ERROR, "invalid value of NAXIS%d keyword, %s = %s\n", header->naxis_index + 1, keyword, value);
+            return AVERROR_INVALIDDATA;
+        }
+
+        dict_set_if_not_null(metadata, keyword, value);
+        header->naxis_index++;
+        if (header->naxis_index == header->naxis) {
+            header->state = STATE_REST;
+        }
+        break;
+    case STATE_REST:
+        if (!strcmp(keyword, "BLANK") && sscanf(value, "%"SCNd64"", &t) == 1) {
+            header->blank = t;
+            header->blank_found = 1;
+        } else if (!strcmp(keyword, "BSCALE") && sscanf(value, "%lf", &d) == 1) {
+            header->bscale = d;
+        } else if (!strcmp(keyword, "BZERO") && sscanf(value, "%lf", &d) == 1) {
+            header->bzero = d;
+        } else if (!strcmp(keyword, "CTYPE3") && !strncmp(value, "'RGB", 4)) {
+            header->rgb = 1;
+        } else if (!strcmp(keyword, "DATAMAX") && sscanf(value, "%lf", &d) == 1) {
+            header->data_max_found = 1;
+            header->data_max = d;
+        } else if (!strcmp(keyword, "DATAMIN") && sscanf(value, "%lf", &d) == 1) {
+            header->data_min_found = 1;
+            header->data_min = d;
+        } else if (!strcmp(keyword, "END")) {
+            return 1;
+        } else if (!strcmp(keyword, "GROUPS") && sscanf(value, "%c", &c) == 1) {
+            header->groups = (c == 'T');
+        } else if (!strcmp(keyword, "GCOUNT") && sscanf(value, "%"SCNd64"", &t) == 1) {
+            header->gcount = t;
+        } else if (!strcmp(keyword, "PCOUNT") && sscanf(value, "%"SCNd64"", &t) == 1) {
+            header->pcount = t;
+        }
+        dict_set_if_not_null(metadata, keyword, value);
+        break;
+    }
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/fits.h b/mythtv/external/FFmpeg/libavcodec/fits.h
new file mode 100644
index 00000000000..ebae85c9e55
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/fits.h
@@ -0,0 +1,83 @@
+/*
+ * FITS image format common prototypes and structures
+ * Copyright (c) 2017 Paras Chadha
+ *
+ * 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_FITS_H
+#define AVCODEC_FITS_H
+
+#include <inttypes.h>
+
+#include "libavutil/dict.h"
+
+typedef enum FITSHeaderState {
+    STATE_SIMPLE,
+    STATE_XTENSION,
+    STATE_BITPIX,
+    STATE_NAXIS,
+    STATE_NAXIS_N,
+    STATE_PCOUNT,
+    STATE_GCOUNT,
+    STATE_REST,
+} FITSHeaderState;
+
+/**
+ * Structure to store the header keywords in FITS file
+ */
+typedef struct FITSHeader {
+    FITSHeaderState state;
+    unsigned naxis_index;
+    int bitpix;
+    int64_t blank;
+    int blank_found;
+    int naxis;
+    int naxisn[999];
+    int pcount;
+    int gcount;
+    int groups;
+    int rgb; /**< 1 if file contains RGB image, 0 otherwise */
+    int image_extension;
+    double bscale;
+    double bzero;
+    int data_min_found;
+    double data_min;
+    int data_max_found;
+    double data_max;
+} FITSHeader;
+
+
+/**
+ * Initialize a single header line
+ * @param header pointer to the header
+ * @param state current state of parsing the header
+ * @return 0 if successful otherwise AVERROR_INVALIDDATA
+ */
+int avpriv_fits_header_init(FITSHeader *header, FITSHeaderState state);
+
+/**
+ * Parse a single header line
+ * @param avcl used in av_log
+ * @param header pointer to the header
+ * @param line one header line
+ * @param metadata used to store metadata while decoding
+ * @return 0 if successful otherwise AVERROR_INVALIDDATA
+ */
+int avpriv_fits_header_parse_line(void *avcl, FITSHeader *header, const uint8_t line[80], AVDictionary ***metadata);
+
+#endif /* AVCODEC_FITS_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/fitsdec.c b/mythtv/external/FFmpeg/libavcodec/fitsdec.c
new file mode 100644
index 00000000000..b0753813c9c
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/fitsdec.c
@@ -0,0 +1,317 @@
+/*
+ * FITS image decoder
+ * Copyright (c) 2017 Paras Chadha
+ *
+ * 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
+ * FITS image decoder
+ *
+ * Specification: https://fits.gsfc.nasa.gov/fits_standard.html Version 3.0
+ *
+ * Support all 2d images alongwith, bzero, bscale and blank keywords.
+ * RGBA images are supported as NAXIS3 = 3 or 4 i.e. Planes in RGBA order. Also CTYPE = 'RGB ' should be present.
+ * Also to interpret data, values are linearly scaled using min-max scaling but not RGB images.
+ */
+
+#include "avcodec.h"
+#include "internal.h"
+#include <float.h>
+#include "libavutil/intreadwrite.h"
+#include "libavutil/intfloat.h"
+#include "libavutil/dict.h"
+#include "libavutil/opt.h"
+#include "fits.h"
+
+typedef struct FITSContext {
+    const AVClass *class;
+    int blank_val;
+} FITSContext;
+
+/**
+ * Calculate the data_min and data_max values from the data.
+ * This is called if the values are not present in the header.
+ * @param ptr8 pointer to the data
+ * @param header pointer to the header
+ * @param end pointer to end of packet
+ * @return 0 if calculated successfully otherwise AVERROR_INVALIDDATA
+ */
+static int fill_data_min_max(const uint8_t *ptr8, FITSHeader *header, const uint8_t *end)
+{
+    uint8_t t8;
+    int16_t t16;
+    int32_t t32;
+    int64_t t64;
+    float tflt;
+    double tdbl;
+    int i, j;
+
+    header->data_min = DBL_MAX;
+    header->data_max = DBL_MIN;
+    switch (header->bitpix) {
+#define CASE_N(a, t, rd) \
+    case a: \
+        for (i = 0; i < header->naxisn[1]; i++) { \
+            for (j = 0; j < header->naxisn[0]; j++) { \
+                t = rd; \
+                if (!header->blank_found || t != header->blank) { \
+                    if (t > header->data_max) \
+                        header->data_max = t; \
+                    if (t < header->data_min) \
+                        header->data_min = t; \
+                } \
+                ptr8 += abs(a) >> 3; \
+            } \
+        } \
+        break
+
+        CASE_N(-64, tdbl, av_int2double(AV_RB64(ptr8)));
+        CASE_N(-32, tflt, av_int2float(AV_RB32(ptr8)));
+        CASE_N(8, t8, ptr8[0]);
+        CASE_N(16, t16, AV_RB16(ptr8));
+        CASE_N(32, t32, AV_RB32(ptr8));
+        CASE_N(64, t64, AV_RB64(ptr8));
+        default:
+            return AVERROR_INVALIDDATA;
+    }
+    return 0;
+}
+
+/**
+ * Read the fits header and store the values in FITSHeader pointed by header
+ * @param avctx AVCodec context
+ * @param ptr pointer to pointer to the data
+ * @param header pointer to the FITSHeader
+ * @param end pointer to end of packet
+ * @param metadata pointer to pointer to AVDictionary to store metadata
+ * @return 0 if calculated successfully otherwise AVERROR_INVALIDDATA
+ */
+static int fits_read_header(AVCodecContext *avctx, const uint8_t **ptr, FITSHeader *header,
+                            const uint8_t *end, AVDictionary **metadata)
+{
+    const uint8_t *ptr8 = *ptr;
+    int lines_read, bytes_left, i, ret;
+    size_t size;
+
+    lines_read = 1; // to account for first header line, SIMPLE or XTENSION which is not included in packet...
+    avpriv_fits_header_init(header, STATE_BITPIX);
+    do {
+        if (end - ptr8 < 80)
+            return AVERROR_INVALIDDATA;
+        ret = avpriv_fits_header_parse_line(avctx, header, ptr8, &metadata);
+        ptr8 += 80;
+        lines_read++;
+    } while (!ret);
+    if (ret < 0)
+        return ret;
+
+    bytes_left = (((lines_read + 35) / 36) * 36 - lines_read) * 80;
+    if (end - ptr8 < bytes_left)
+        return AVERROR_INVALIDDATA;
+    ptr8 += bytes_left;
+
+    if (header->rgb && (header->naxis != 3 || (header->naxisn[2] != 3 && header->naxisn[2] != 4))) {
+        av_log(avctx, AV_LOG_ERROR, "File contains RGB image but NAXIS = %d and NAXIS3 = %d\n", header->naxis, header->naxisn[2]);
+        return AVERROR_INVALIDDATA;
+    }
+
+    if (!header->rgb && header->naxis != 2) {
+        av_log(avctx, AV_LOG_ERROR, "unsupported number of dimensions, NAXIS = %d\n", header->naxis);
+        return AVERROR_INVALIDDATA;
+    }
+
+    if (header->blank_found && (header->bitpix == -32 || header->bitpix == -64)) {
+        av_log(avctx, AV_LOG_WARNING, "BLANK keyword found but BITPIX = %d\n. Ignoring BLANK", header->bitpix);
+        header->blank_found = 0;
+    }
+
+    size = abs(header->bitpix) >> 3;
+    for (i = 0; i < header->naxis; i++) {
+        if (header->naxisn[i] > SIZE_MAX / size) {
+            av_log(avctx, AV_LOG_ERROR, "unsupported size of FITS image");
+            return AVERROR_INVALIDDATA;
+        }
+        size *= header->naxisn[i];
+    }
+
+    if (end - ptr8 < size)
+        return AVERROR_INVALIDDATA;
+    *ptr = ptr8;
+
+    if (!header->rgb && (!header->data_min_found || !header->data_max_found)) {
+        ret = fill_data_min_max(ptr8, header, end);
+        if (ret < 0) {
+            av_log(avctx, AV_LOG_ERROR, "invalid BITPIX, %d\n", header->bitpix);
+            return ret;
+        }
+    } else {
+        /*
+         * instead of applying bscale and bzero to every element,
+         * we can do inverse transformation on data_min and data_max
+         */
+        header->data_min = (header->data_min - header->bzero) / header->bscale;
+        header->data_max = (header->data_max - header->bzero) / header->bscale;
+    }
+
+    return 0;
+}
+
+static int fits_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
+{
+    AVFrame *p=data;
+    const uint8_t *ptr8 = avpkt->data, *end;
+    uint8_t t8;
+    int16_t t16;
+    int32_t t32;
+    int64_t t64;
+    float   tflt;
+    double  tdbl;
+    int ret, i, j, k;
+    const int map[] = {2, 0, 1, 3}; // mapping from GBRA -> RGBA as RGBA is to be stored in FITS file..
+    uint8_t *dst8;
+    uint16_t *dst16;
+    uint64_t t;
+    FITSHeader header;
+    FITSContext * fitsctx = avctx->priv_data;
+
+    end = ptr8 + avpkt->size;
+    p->metadata = NULL;
+    ret = fits_read_header(avctx, &ptr8, &header, end, &p->metadata);
+    if (ret < 0)
+        return ret;
+
+    if (header.rgb) {
+        if (header.bitpix == 8) {
+            if (header.naxisn[2] == 3) {
+                avctx->pix_fmt = AV_PIX_FMT_GBRP;
+            } else {
+                avctx->pix_fmt = AV_PIX_FMT_GBRAP;
+            }
+        } else if (header.bitpix == 16) {
+            if (header.naxisn[2] == 3) {
+                avctx->pix_fmt = AV_PIX_FMT_GBRP16;
+            } else {
+                avctx->pix_fmt = AV_PIX_FMT_GBRAP16;
+            }
+        } else {
+            av_log(avctx, AV_LOG_ERROR, "unsupported BITPIX = %d\n", header.bitpix);
+            return AVERROR_INVALIDDATA;
+        }
+    } else {
+        if (header.bitpix == 8) {
+            avctx->pix_fmt = AV_PIX_FMT_GRAY8;
+        } else {
+            avctx->pix_fmt = AV_PIX_FMT_GRAY16;
+        }
+    }
+
+    if ((ret = ff_set_dimensions(avctx, header.naxisn[0], header.naxisn[1])) < 0)
+        return ret;
+
+    if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
+        return ret;
+
+    /*
+     * FITS stores images with bottom row first. Therefore we have
+     * to fill the image from bottom to top.
+     */
+    if (header.rgb) {
+        switch(header.bitpix) {
+#define CASE_RGB(cas, dst, type, dref) \
+    case cas: \
+        for (k = 0; k < header.naxisn[2]; k++) { \
+            for (i = 0; i < avctx->height; i++) { \
+                dst = (type *) (p->data[map[k]] + (avctx->height - i - 1) * p->linesize[map[k]]); \
+                for (j = 0; j < avctx->width; j++) { \
+                    t32 = dref(ptr8); \
+                    if (!header.blank_found || t32 != header.blank) { \
+                        t = t32 * header.bscale + header.bzero; \
+                    } else { \
+                        t = fitsctx->blank_val; \
+                    } \
+                    *dst++ = (type) t; \
+                    ptr8 += cas >> 3; \
+                } \
+            } \
+        } \
+        break
+
+            CASE_RGB(8, dst8, uint8_t, *);
+            CASE_RGB(16, dst16, uint16_t, AV_RB16);
+        }
+    } else {
+        switch (header.bitpix) {
+#define CASE_GRAY(cas, dst, type, t, rd) \
+    case cas: \
+        for (i = 0; i < avctx->height; i++) { \
+            dst = (type *) (p->data[0] + (avctx->height-i-1)* p->linesize[0]); \
+            for (j = 0; j < avctx->width; j++) { \
+                t = rd; \
+                if (!header.blank_found || t != header.blank) { \
+                    *dst++ = ((t - header.data_min) * ((1 << (sizeof(type) * 8)) - 1)) / (header.data_max - header.data_min); \
+                } else { \
+                    *dst++ = fitsctx->blank_val; \
+                } \
+                ptr8 += abs(cas) >> 3; \
+            } \
+        } \
+        break
+
+            CASE_GRAY(-64, dst16, uint16_t, tdbl, av_int2double(AV_RB64(ptr8)));
+            CASE_GRAY(-32, dst16, uint16_t, tflt, av_int2float(AV_RB32(ptr8)));
+            CASE_GRAY(8, dst8, uint8_t, t8, ptr8[0]);
+            CASE_GRAY(16, dst16, uint16_t, t16, AV_RB16(ptr8));
+            CASE_GRAY(32, dst16, uint16_t, t32, AV_RB32(ptr8));
+            CASE_GRAY(64, dst16, uint16_t, t64, AV_RB64(ptr8));
+            default:
+                av_log(avctx, AV_LOG_ERROR, "invalid BITPIX, %d\n", header.bitpix);
+                return AVERROR_INVALIDDATA;
+        }
+    }
+
+    p->key_frame = 1;
+    p->pict_type = AV_PICTURE_TYPE_I;
+
+    *got_frame = 1;
+
+    return avpkt->size;
+}
+
+static const AVOption fits_options[] = {
+    { "blank_value", "value that is used to replace BLANK pixels in data array", offsetof(FITSContext, blank_val), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 65535, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM},
+    { NULL },
+};
+
+static const AVClass fits_decoder_class = {
+    .class_name = "FITS decoder",
+    .item_name  = av_default_item_name,
+    .option     = fits_options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVCodec ff_fits_decoder = {
+    .name           = "fits",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_FITS,
+    .priv_data_size = sizeof(FITSContext),
+    .decode         = fits_decode_frame,
+    .capabilities   = AV_CODEC_CAP_DR1,
+    .long_name      = NULL_IF_CONFIG_SMALL("Flexible Image Transport System"),
+    .priv_class     = &fits_decoder_class
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/fitsenc.c b/mythtv/external/FFmpeg/libavcodec/fitsenc.c
new file mode 100644
index 00000000000..b44507e4366
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/fitsenc.c
@@ -0,0 +1,129 @@
+/*
+ * FITS image encoder
+ * Copyright (c) 2017 Paras Chadha
+ *
+ * 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
+ * FITS image encoder
+ *
+ * Specification: https://fits.gsfc.nasa.gov/fits_standard.html Version 3.0
+ *
+ * RGBA images are encoded as planes in RGBA order. So, NAXIS3 is 3 or 4 for them.
+ * Also CTYPE3 = 'RGB ' is added to the header to distinguish them from 3d images.
+ */
+
+#include "libavutil/intreadwrite.h"
+#include "avcodec.h"
+#include "bytestream.h"
+#include "internal.h"
+
+static int fits_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+                            const AVFrame *pict, int *got_packet)
+{
+    AVFrame * const p = (AVFrame *)pict;
+    uint8_t *bytestream, *bytestream_start, *ptr;
+    const uint16_t flip = (1 << 15);
+    uint64_t data_size = 0, padded_data_size = 0;
+    int ret, bitpix, naxis3 = 1, i, j, k, bytes_left;
+    int map[] = {2, 0, 1, 3}; // mapping from GBRA -> RGBA as RGBA is to be stored in FITS file..
+
+    switch (avctx->pix_fmt) {
+    case AV_PIX_FMT_GRAY8:
+    case AV_PIX_FMT_GRAY16BE:
+        map[0] = 0; // grayscale images should be directly mapped
+        if (avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
+            bitpix = 8;
+        } else {
+            bitpix = 16;
+        }
+        break;
+    case AV_PIX_FMT_GBRP:
+    case AV_PIX_FMT_GBRAP:
+        bitpix = 8;
+        if (avctx->pix_fmt == AV_PIX_FMT_GBRP) {
+            naxis3 = 3;
+        } else {
+            naxis3 = 4;
+        }
+        break;
+    case AV_PIX_FMT_GBRP16BE:
+    case AV_PIX_FMT_GBRAP16BE:
+        bitpix = 16;
+        if (avctx->pix_fmt == AV_PIX_FMT_GBRP16BE) {
+            naxis3 = 3;
+        } else {
+            naxis3 = 4;
+        }
+        break;
+    default:
+        av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
+        return AVERROR(EINVAL);
+    }
+
+    data_size = (bitpix >> 3) * avctx->height * avctx->width * naxis3;
+    padded_data_size = ((data_size + 2879) / 2880 ) * 2880;
+
+    if ((ret = ff_alloc_packet2(avctx, pkt, padded_data_size, 0)) < 0)
+        return ret;
+
+    bytestream_start =
+    bytestream       = pkt->data;
+
+    for (k = 0; k < naxis3; k++) {
+        for (i = 0; i < avctx->height; i++) {
+            ptr = p->data[map[k]] + (avctx->height - i - 1) * p->linesize[map[k]];
+            if (bitpix == 16) {
+                for (j = 0; j < avctx->width; j++) {
+                    // subtracting bzero is equivalent to first bit flip
+                    bytestream_put_be16(&bytestream, AV_RB16(ptr) ^ flip);
+                    ptr += 2;
+                }
+            } else {
+                memcpy(bytestream, ptr, avctx->width);
+                bytestream += avctx->width;
+            }
+        }
+    }
+
+    bytes_left = padded_data_size - data_size;
+    memset(bytestream, 0, bytes_left);
+    bytestream += bytes_left;
+
+    pkt->size   = bytestream - bytestream_start;
+    pkt->flags |= AV_PKT_FLAG_KEY;
+    *got_packet = 1;
+
+    return 0;
+}
+
+AVCodec ff_fits_encoder = {
+    .name           = "fits",
+    .long_name      = NULL_IF_CONFIG_SMALL("Flexible Image Transport System"),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_FITS,
+    .encode2        = fits_encode_frame,
+    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_GBRAP16BE,
+                                                     AV_PIX_FMT_GBRP16BE,
+                                                     AV_PIX_FMT_GBRP,
+                                                     AV_PIX_FMT_GBRAP,
+                                                     AV_PIX_FMT_GRAY16BE,
+                                                     AV_PIX_FMT_GRAY8,
+                                                     AV_PIX_FMT_NONE },
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/flac.c b/mythtv/external/FFmpeg/libavcodec/flac.c
index f5154b9149d..5ffbf93190e 100644
--- a/mythtv/external/FFmpeg/libavcodec/flac.c
+++ b/mythtv/external/FFmpeg/libavcodec/flac.c
@@ -201,7 +201,7 @@ void ff_flac_set_channel_layout(AVCodecContext *avctx)
         avctx->channel_layout = 0;
 }
 
-void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
+int ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
                               const uint8_t *buffer)
 {
     GetBitContext gb;
@@ -213,6 +213,7 @@ void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
                s->max_blocksize);
         s->max_blocksize = 16;
+        return AVERROR_INVALIDDATA;
     }
 
     skip_bits(&gb, 24); /* skip min frame size */
@@ -222,6 +223,12 @@ void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
     s->channels = get_bits(&gb, 3) + 1;
     s->bps = get_bits(&gb, 5) + 1;
 
+    if (s->bps < 4) {
+        av_log(avctx, AV_LOG_ERROR, "invalid bps: %d\n", s->bps);
+        s->bps = 16;
+        return AVERROR_INVALIDDATA;
+    }
+
     avctx->channels = s->channels;
     avctx->sample_rate = s->samplerate;
     avctx->bits_per_raw_sample = s->bps;
@@ -234,4 +241,6 @@ void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
 
     skip_bits_long(&gb, 64); /* md5 sum */
     skip_bits_long(&gb, 64); /* md5 sum */
+
+    return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/flac.h b/mythtv/external/FFmpeg/libavcodec/flac.h
index 96d971c9d7e..991ab43f3cc 100644
--- a/mythtv/external/FFmpeg/libavcodec/flac.h
+++ b/mythtv/external/FFmpeg/libavcodec/flac.h
@@ -95,8 +95,10 @@ typedef struct FLACFrameInfo {
  * @param[out] avctx   codec context to set basic stream parameters
  * @param[out] s       where parsed information is stored
  * @param[in]  buffer  pointer to start of 34-byte streaminfo data
+ *
+ * @return negative error code on faiure or >= 0 on success
  */
-void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
+int ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
                               const uint8_t *buffer);
 
 /**
diff --git a/mythtv/external/FFmpeg/libavcodec/flac_parser.c b/mythtv/external/FFmpeg/libavcodec/flac_parser.c
index f5cc35a4f2d..84da23f327e 100644
--- a/mythtv/external/FFmpeg/libavcodec/flac_parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/flac_parser.c
@@ -586,10 +586,12 @@ static int flac_parse(AVCodecParserContext *s, AVCodecContext *avctx,
             temp = curr->next;
             av_freep(&curr->link_penalty);
             av_free(curr);
+            fpc->nb_headers_buffered--;
         }
         fpc->headers = fpc->best_header->next;
         av_freep(&fpc->best_header->link_penalty);
         av_freep(&fpc->best_header);
+        fpc->nb_headers_buffered--;
     }
 
     /* Find and score new headers.                                     */
@@ -638,7 +640,7 @@ static int flac_parse(AVCodecParserContext *s, AVCodecContext *avctx,
                                   read_end - read_start, NULL);
         } else {
             int8_t pad[MAX_FRAME_HEADER_SIZE] = { 0 };
-            av_fifo_generic_write(fpc->fifo_buf, (void*) pad, sizeof(pad), NULL);
+            av_fifo_generic_write(fpc->fifo_buf, pad, sizeof(pad), NULL);
         }
 
         /* Tag headers and update sequences. */
diff --git a/mythtv/external/FFmpeg/libavcodec/flacdec.c b/mythtv/external/FFmpeg/libavcodec/flacdec.c
index b7237e18f04..581c73efc80 100644
--- a/mythtv/external/FFmpeg/libavcodec/flacdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/flacdec.c
@@ -109,7 +109,9 @@ static av_cold int flac_decode_init(AVCodecContext *avctx)
         return AVERROR_INVALIDDATA;
 
     /* initialize based on the demuxer-supplied streamdata header */
-    ff_flac_parse_streaminfo(avctx, &s->flac_stream_info, streaminfo);
+    ret = ff_flac_parse_streaminfo(avctx, &s->flac_stream_info, streaminfo);
+    if (ret < 0)
+        return ret;
     ret = allocate_buffers(s);
     if (ret < 0)
         return ret;
@@ -175,7 +177,9 @@ static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
         metadata_size != FLAC_STREAMINFO_SIZE) {
         return AVERROR_INVALIDDATA;
     }
-    ff_flac_parse_streaminfo(s->avctx, &s->flac_stream_info, &buf[8]);
+    ret = ff_flac_parse_streaminfo(s->avctx, &s->flac_stream_info, &buf[8]);
+    if (ret < 0)
+        return ret;
     ret = allocate_buffers(s);
     if (ret < 0)
         return ret;
@@ -201,12 +205,12 @@ static int get_metadata_size(const uint8_t *buf, int buf_size)
     buf += 4;
     do {
         if (buf_end - buf < 4)
-            return 0;
+            return AVERROR_INVALIDDATA;
         flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
         buf += 4;
         if (buf_end - buf < metadata_size) {
             /* need more data in order to read the complete header */
-            return 0;
+            return AVERROR_INVALIDDATA;
         }
         buf += metadata_size;
     } while (!metadata_last);
@@ -254,8 +258,15 @@ static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
             for (; i < samples; i++)
                 *decoded++ = get_sbits_long(&s->gb, tmp);
         } else {
+            int real_limit = tmp ? (INT_MAX >> tmp) + 2 : INT_MAX;
             for (; i < samples; i++) {
-                *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
+                int v = get_sr_golomb_flac(&s->gb, tmp, real_limit, 0);
+                if (v == 0x80000000){
+                    av_log(s->avctx, AV_LOG_ERROR, "invalid residual\n");
+                    return AVERROR_INVALIDDATA;
+                }
+
+                *decoded++ = v;
             }
         }
         i= 0;
@@ -268,7 +279,8 @@ static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
                                  int pred_order, int bps)
 {
     const int blocksize = s->blocksize;
-    int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
+    unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
+    int i;
     int ret;
 
     /* warm up samples */
@@ -315,7 +327,7 @@ static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
     return 0;
 }
 
-static void lpc_analyze_remodulate(int32_t *decoded, const int coeffs[32],
+static void lpc_analyze_remodulate(SUINT32 *decoded, const int coeffs[32],
                                    int order, int qlevel, int len, int bps)
 {
     int i, j;
@@ -331,7 +343,7 @@ static void lpc_analyze_remodulate(int32_t *decoded, const int coeffs[32],
     for (i = len - 1; i >= order; i--) {
         int64_t p = 0;
         for (j = 0; j < order; j++)
-            p += coeffs[j] * (int64_t)decoded[i-order+j];
+            p += coeffs[j] * (int64_t)(int32_t)decoded[i-order+j];
         decoded[i] -= p >> qlevel;
     }
     for (i = order; i < len; i++, decoded++) {
@@ -447,7 +459,7 @@ static inline int decode_subframe(FLACContext *s, int channel)
     if (wasted) {
         int i;
         for (i = 0; i < s->blocksize; i++)
-            decoded[i] <<= wasted;
+            decoded[i] = (unsigned)decoded[i] << wasted;
     }
 
     return 0;
diff --git a/mythtv/external/FFmpeg/libavcodec/flacdsp.c b/mythtv/external/FFmpeg/libavcodec/flacdsp.c
index 30b66484e87..bc9a5dbed91 100644
--- a/mythtv/external/FFmpeg/libavcodec/flacdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/flacdsp.c
@@ -49,8 +49,8 @@ static void flac_lpc_16_c(int32_t *decoded, const int coeffs[32],
     int i, j;
 
     for (i = pred_order; i < len - 1; i += 2, decoded += 2) {
-        int c = coeffs[0];
-        int d = decoded[0];
+        SUINT c = coeffs[0];
+        SUINT d = decoded[0];
         int s0 = 0, s1 = 0;
         for (j = 1; j < pred_order; j++) {
             s0 += c*d;
@@ -59,15 +59,15 @@ static void flac_lpc_16_c(int32_t *decoded, const int coeffs[32],
             c = coeffs[j];
         }
         s0 += c*d;
-        d = decoded[j] += s0 >> qlevel;
+        d = decoded[j] += (SUINT)(s0 >> qlevel);
         s1 += c*d;
-        decoded[j + 1] += s1 >> qlevel;
+        decoded[j + 1] += (SUINT)(s1 >> qlevel);
     }
     if (i < len) {
         int sum = 0;
         for (j = 0; j < pred_order; j++)
-            sum += coeffs[j] * decoded[j];
-        decoded[j] += sum >> qlevel;
+            sum += coeffs[j] * (SUINT)decoded[j];
+        decoded[j] = decoded[j] + (unsigned)(sum >> qlevel);
     }
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/flacdsp.h b/mythtv/external/FFmpeg/libavcodec/flacdsp.h
index f5cbd947246..7bb0dd0e9a2 100644
--- a/mythtv/external/FFmpeg/libavcodec/flacdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/flacdsp.h
@@ -20,6 +20,7 @@
 #define AVCODEC_FLACDSP_H
 
 #include <stdint.h>
+#include "libavutil/internal.h"
 #include "libavutil/samplefmt.h"
 
 typedef struct FLACDSPContext {
diff --git a/mythtv/external/FFmpeg/libavcodec/flacdsp_template.c b/mythtv/external/FFmpeg/libavcodec/flacdsp_template.c
index 62c0a15ff61..776c78da719 100644
--- a/mythtv/external/FFmpeg/libavcodec/flacdsp_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/flacdsp_template.c
@@ -56,7 +56,7 @@ static void FUNC(flac_decorrelate_indep_c)(uint8_t **out, int32_t **in,
 
     for (j = 0; j < len; j++)
         for (i = 0; i < channels; i++)
-            S(samples, i, j) = in[i][j] << shift;
+            S(samples, i, j) = (int)((unsigned)in[i][j] << shift);
 }
 
 static void FUNC(flac_decorrelate_ls_c)(uint8_t **out, int32_t **in,
diff --git a/mythtv/external/FFmpeg/libavcodec/flacenc.c b/mythtv/external/FFmpeg/libavcodec/flacenc.c
index 3575f5391dc..170c3caf484 100644
--- a/mythtv/external/FFmpeg/libavcodec/flacenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/flacenc.c
@@ -268,7 +268,7 @@ static av_cold int flac_encode_init(AVCodecContext *avctx)
 
     /* find samplerate in table */
     if (freq < 1)
-        return -1;
+        return AVERROR(EINVAL);
     for (i = 4; i < 12; i++) {
         if (freq == ff_flac_sample_rate_table[i]) {
             s->samplerate = ff_flac_sample_rate_table[i];
diff --git a/mythtv/external/FFmpeg/libavcodec/flicvideo.c b/mythtv/external/FFmpeg/libavcodec/flicvideo.c
index c9c6c24e555..ba5bda48c48 100644
--- a/mythtv/external/FFmpeg/libavcodec/flicvideo.c
+++ b/mythtv/external/FFmpeg/libavcodec/flicvideo.c
@@ -27,8 +27,7 @@
  * variations, visit:
  *   http://www.compuphase.com/flic.htm
  *
- * This decoder outputs PAL8/RGB555/RGB565 and maybe one day RGB24
- * colorspace data, depending on the FLC. To use this decoder, be
+ * This decoder outputs PAL8/RGB555/RGB565/BGR24. To use this decoder, be
  * sure that your demuxer sends the FLI file header to the decoder via
  * the extradata chunk in AVCodecContext. The chunk should be 128 bytes
  * large. The only exception is for FLI files from the game "Magic Carpet",
@@ -133,9 +132,7 @@ static av_cold int flic_decode_init(AVCodecContext *avctx)
         case 8  : avctx->pix_fmt = AV_PIX_FMT_PAL8; break;
         case 15 : avctx->pix_fmt = AV_PIX_FMT_RGB555; break;
         case 16 : avctx->pix_fmt = AV_PIX_FMT_RGB565; break;
-        case 24 : avctx->pix_fmt = AV_PIX_FMT_BGR24; /* Supposedly BGR, but no files to test with */
-                  avpriv_request_sample(avctx, "24Bpp FLC/FLX");
-                  return AVERROR_PATCHWELCOME;
+        case 24 : avctx->pix_fmt = AV_PIX_FMT_BGR24; break;
         default :
                   av_log(avctx, AV_LOG_ERROR, "Unknown FLC/FLX depth of %d Bpp is unsupported.\n",depth);
                   return AVERROR_INVALIDDATA;
@@ -202,6 +199,9 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx,
     num_chunks = bytestream2_get_le16(&g2);
     bytestream2_skip(&g2, 8);  /* skip padding */
 
+    if (frame_size < 16)
+        return AVERROR_INVALIDDATA;
+
     frame_size -= 16;
 
     /* iterate through the chunks */
@@ -272,10 +272,14 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx,
             while (compressed_lines > 0) {
                 if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
                     break;
+                if (y_ptr > pixel_limit)
+                    return AVERROR_INVALIDDATA;
                 line_packets = bytestream2_get_le16(&g2);
                 if ((line_packets & 0xC000) == 0xC000) {
                     // line skip opcode
                     line_packets = -line_packets;
+                    if (line_packets > s->avctx->height)
+                        return AVERROR_INVALIDDATA;
                     y_ptr += line_packets * s->frame->linesize[0];
                 } else if ((line_packets & 0xC000) == 0x4000) {
                     av_log(avctx, AV_LOG_ERROR, "Undefined opcode (%x) in DELTA_FLI\n", line_packets);
@@ -324,6 +328,8 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx,
         case FLI_LC:
             /* line compressed */
             starting_line = bytestream2_get_le16(&g2);
+            if (starting_line >= s->avctx->height)
+                return AVERROR_INVALIDDATA;
             y_ptr = 0;
             y_ptr += starting_line * s->frame->linesize[0];
 
@@ -447,8 +453,12 @@ static int flic_decode_frame_8BPP(AVCodecContext *avctx,
             break;
         }
 
-        if (stream_ptr_after_chunk - bytestream2_tell(&g2) > 0)
+        if (stream_ptr_after_chunk - bytestream2_tell(&g2) >= 0) {
             bytestream2_skip(&g2, stream_ptr_after_chunk - bytestream2_tell(&g2));
+        } else {
+            av_log(avctx, AV_LOG_ERROR, "Chunk overread\n");
+            break;
+        }
 
         frame_size -= chunk_size;
         num_chunks--;
@@ -522,6 +532,8 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx,
     if (frame_size > buf_size)
         frame_size = buf_size;
 
+    if (frame_size < 16)
+        return AVERROR_INVALIDDATA;
     frame_size -= 16;
 
     /* iterate through the chunks */
@@ -558,9 +570,13 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx,
             while (compressed_lines > 0) {
                 if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
                     break;
+                if (y_ptr > pixel_limit)
+                    return AVERROR_INVALIDDATA;
                 line_packets = bytestream2_get_le16(&g2);
                 if (line_packets < 0) {
                     line_packets = -line_packets;
+                    if (line_packets > s->avctx->height)
+                        return AVERROR_INVALIDDATA;
                     y_ptr += line_packets * s->frame->linesize[0];
                 } else {
                     compressed_lines--;
@@ -745,6 +761,13 @@ static int flic_decode_frame_15_16BPP(AVCodecContext *avctx,
             break;
         }
 
+        if (stream_ptr_after_chunk - bytestream2_tell(&g2) >= 0) {
+            bytestream2_skip(&g2, stream_ptr_after_chunk - bytestream2_tell(&g2));
+        } else {
+            av_log(avctx, AV_LOG_ERROR, "Chunk overread\n");
+            break;
+        }
+
         frame_size -= chunk_size;
         num_chunks--;
     }
@@ -767,8 +790,287 @@ static int flic_decode_frame_24BPP(AVCodecContext *avctx,
                                    void *data, int *got_frame,
                                    const uint8_t *buf, int buf_size)
 {
-  av_log(avctx, AV_LOG_ERROR, "24Bpp FLC Unsupported due to lack of test files.\n");
-  return AVERROR_PATCHWELCOME;
+    FlicDecodeContext *s = avctx->priv_data;
+
+    GetByteContext g2;
+    int pixel_ptr;
+    unsigned char palette_idx1;
+
+    unsigned int frame_size;
+    int num_chunks;
+
+    unsigned int chunk_size;
+    int chunk_type;
+
+    int i, j, ret;
+
+    int lines;
+    int compressed_lines;
+    signed short line_packets;
+    int y_ptr;
+    int byte_run;
+    int pixel_skip;
+    int pixel_countdown;
+    unsigned char *pixels;
+    int pixel;
+    unsigned int pixel_limit;
+
+    bytestream2_init(&g2, buf, buf_size);
+
+    if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
+        return ret;
+
+    pixels = s->frame->data[0];
+    pixel_limit = s->avctx->height * s->frame->linesize[0];
+
+    frame_size = bytestream2_get_le32(&g2);
+    bytestream2_skip(&g2, 2);  /* skip the magic number */
+    num_chunks = bytestream2_get_le16(&g2);
+    bytestream2_skip(&g2, 8);  /* skip padding */
+    if (frame_size > buf_size)
+        frame_size = buf_size;
+
+    if (frame_size < 16)
+        return AVERROR_INVALIDDATA;
+    frame_size -= 16;
+
+    /* iterate through the chunks */
+    while ((frame_size > 0) && (num_chunks > 0) &&
+            bytestream2_get_bytes_left(&g2) >= 4) {
+        int stream_ptr_after_chunk;
+        chunk_size = bytestream2_get_le32(&g2);
+        if (chunk_size > frame_size) {
+            av_log(avctx, AV_LOG_WARNING,
+                   "Invalid chunk_size = %u > frame_size = %u\n", chunk_size, frame_size);
+            chunk_size = frame_size;
+        }
+        stream_ptr_after_chunk = bytestream2_tell(&g2) - 4 + chunk_size;
+
+        chunk_type = bytestream2_get_le16(&g2);
+
+
+        switch (chunk_type) {
+        case FLI_256_COLOR:
+        case FLI_COLOR:
+            /* For some reason, it seems that non-palettized flics do
+             * include one of these chunks in their first frame.
+             * Why I do not know, it seems rather extraneous. */
+            ff_dlog(avctx,
+                    "Unexpected Palette chunk %d in non-palettized FLC\n",
+                    chunk_type);
+            bytestream2_skip(&g2, chunk_size - 6);
+            break;
+
+        case FLI_DELTA:
+        case FLI_DTA_LC:
+            y_ptr = 0;
+            compressed_lines = bytestream2_get_le16(&g2);
+            while (compressed_lines > 0) {
+                if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
+                    break;
+                if (y_ptr > pixel_limit)
+                    return AVERROR_INVALIDDATA;
+                line_packets = bytestream2_get_le16(&g2);
+                if (line_packets < 0) {
+                    line_packets = -line_packets;
+                    if (line_packets > s->avctx->height)
+                        return AVERROR_INVALIDDATA;
+                    y_ptr += line_packets * s->frame->linesize[0];
+                } else {
+                    compressed_lines--;
+                    pixel_ptr = y_ptr;
+                    CHECK_PIXEL_PTR(0);
+                    pixel_countdown = s->avctx->width;
+                    for (i = 0; i < line_packets; i++) {
+                        /* account for the skip bytes */
+                        if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
+                            break;
+                        pixel_skip = bytestream2_get_byte(&g2);
+                        pixel_ptr += (pixel_skip*3); /* Pixel is 3 bytes wide */
+                        pixel_countdown -= pixel_skip;
+                        byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
+                        if (byte_run < 0) {
+                            byte_run = -byte_run;
+                            pixel    = bytestream2_get_le24(&g2);
+                            CHECK_PIXEL_PTR(3 * byte_run);
+                            for (j = 0; j < byte_run; j++, pixel_countdown -= 1) {
+                                AV_WL24(&pixels[pixel_ptr], pixel);
+                                pixel_ptr += 3;
+                            }
+                        } else {
+                            if (bytestream2_tell(&g2) + 2*byte_run > stream_ptr_after_chunk)
+                                break;
+                            CHECK_PIXEL_PTR(2 * byte_run);
+                            for (j = 0; j < byte_run; j++, pixel_countdown--) {
+                                pixel = bytestream2_get_le24(&g2);
+                                AV_WL24(&pixels[pixel_ptr], pixel);
+                                pixel_ptr += 3;
+                            }
+                        }
+                    }
+
+                    y_ptr += s->frame->linesize[0];
+                }
+            }
+            break;
+
+        case FLI_LC:
+            av_log(avctx, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-palettized FLC\n");
+            bytestream2_skip(&g2, chunk_size - 6);
+            break;
+
+        case FLI_BLACK:
+            /* set the whole frame to 0x00 which is black for 24 bit mode. */
+            memset(pixels, 0x00,
+                   s->frame->linesize[0] * s->avctx->height);
+            break;
+
+        case FLI_BRUN:
+            y_ptr = 0;
+            for (lines = 0; lines < s->avctx->height; lines++) {
+                pixel_ptr = y_ptr;
+                /* disregard the line packets; instead, iterate through all
+                 * pixels on a row */
+                bytestream2_skip(&g2, 1);
+                pixel_countdown = (s->avctx->width * 3);
+
+                while (pixel_countdown > 0) {
+                    if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
+                        break;
+                    byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
+                    if (byte_run > 0) {
+                        palette_idx1 = bytestream2_get_byte(&g2);
+                        CHECK_PIXEL_PTR(byte_run);
+                        for (j = 0; j < byte_run; j++) {
+                            pixels[pixel_ptr++] = palette_idx1;
+                            pixel_countdown--;
+                            if (pixel_countdown < 0)
+                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) (linea%d)\n",
+                                       pixel_countdown, lines);
+                        }
+                    } else {  /* copy bytes if byte_run < 0 */
+                        byte_run = -byte_run;
+                        if (bytestream2_tell(&g2) + byte_run > stream_ptr_after_chunk)
+                            break;
+                        CHECK_PIXEL_PTR(byte_run);
+                        for (j = 0; j < byte_run; j++) {
+                            palette_idx1 = bytestream2_get_byte(&g2);
+                            pixels[pixel_ptr++] = palette_idx1;
+                            pixel_countdown--;
+                            if (pixel_countdown < 0)
+                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
+                                       pixel_countdown, lines);
+                        }
+                    }
+                }
+
+                y_ptr += s->frame->linesize[0];
+            }
+            break;
+
+        case FLI_DTA_BRUN:
+            y_ptr = 0;
+            for (lines = 0; lines < s->avctx->height; lines++) {
+                pixel_ptr = y_ptr;
+                /* disregard the line packets; instead, iterate through all
+                 * pixels on a row */
+                bytestream2_skip(&g2, 1);
+                pixel_countdown = s->avctx->width; /* Width is in pixels, not bytes */
+
+                while (pixel_countdown > 0) {
+                    if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
+                        break;
+                    byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
+                    if (byte_run > 0) {
+                        pixel = bytestream2_get_le24(&g2);
+                        CHECK_PIXEL_PTR(3 * byte_run);
+                        for (j = 0; j < byte_run; j++) {
+                            AV_WL24(pixels + pixel_ptr, pixel);
+                            pixel_ptr += 3;
+                            pixel_countdown--;
+                            if (pixel_countdown < 0)
+                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
+                                       pixel_countdown);
+                        }
+                    } else {  /* copy pixels if byte_run < 0 */
+                        byte_run = -byte_run;
+                        if (bytestream2_tell(&g2) + 3 * byte_run > stream_ptr_after_chunk)
+                            break;
+                        CHECK_PIXEL_PTR(3 * byte_run);
+                        for (j = 0; j < byte_run; j++) {
+                            pixel = bytestream2_get_le24(&g2);
+                            AV_WL24(pixels + pixel_ptr, pixel);
+                            pixel_ptr  += 3;
+                            pixel_countdown--;
+                            if (pixel_countdown < 0)
+                                av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
+                                       pixel_countdown);
+                        }
+                    }
+                }
+
+                y_ptr += s->frame->linesize[0];
+            }
+            break;
+
+        case FLI_COPY:
+        case FLI_DTA_COPY:
+            /* copy the chunk (uncompressed frame) */
+            if (chunk_size - 6 > (unsigned int)(FFALIGN(s->avctx->width, 2) * s->avctx->height)*3) {
+                av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \
+                       "bigger than image, skipping chunk\n", chunk_size - 6);
+                bytestream2_skip(&g2, chunk_size - 6);
+            } else {
+                for (y_ptr = 0; y_ptr < s->frame->linesize[0] * s->avctx->height;
+                     y_ptr += s->frame->linesize[0]) {
+
+                    pixel_countdown = s->avctx->width;
+                    pixel_ptr = 0;
+                    while (pixel_countdown > 0) {
+                        pixel = bytestream2_get_le24(&g2);
+                        AV_WL24(&pixels[y_ptr + pixel_ptr], pixel);
+                        pixel_ptr += 3;
+                        pixel_countdown--;
+                    }
+                    if (s->avctx->width & 1)
+                        bytestream2_skip(&g2, 3);
+                }
+            }
+            break;
+
+        case FLI_MINI:
+            /* some sort of a thumbnail? disregard this chunk... */
+            bytestream2_skip(&g2, chunk_size - 6);
+            break;
+
+        default:
+            av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);
+            break;
+        }
+
+        if (stream_ptr_after_chunk - bytestream2_tell(&g2) >= 0) {
+            bytestream2_skip(&g2, stream_ptr_after_chunk - bytestream2_tell(&g2));
+        } else {
+            av_log(avctx, AV_LOG_ERROR, "Chunk overread\n");
+            break;
+        }
+
+        frame_size -= chunk_size;
+        num_chunks--;
+    }
+
+    /* by the end of the chunk, the stream ptr should equal the frame
+     * size (minus 1, possibly); if it doesn't, issue a warning */
+    if ((bytestream2_get_bytes_left(&g2) != 0) && (bytestream2_get_bytes_left(&g2) != 1))
+        av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
+               "and final chunk ptr = %d\n", buf_size, bytestream2_tell(&g2));
+
+    if ((ret = av_frame_ref(data, s->frame)) < 0)
+        return ret;
+
+    *got_frame = 1;
+
+    return buf_size;
 }
 
 static int flic_decode_frame(AVCodecContext *avctx,
@@ -778,17 +1080,15 @@ static int flic_decode_frame(AVCodecContext *avctx,
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
-      return flic_decode_frame_8BPP(avctx, data, got_frame,
-                                    buf, buf_size);
-    }
-    else if ((avctx->pix_fmt == AV_PIX_FMT_RGB555) ||
-             (avctx->pix_fmt == AV_PIX_FMT_RGB565)) {
-      return flic_decode_frame_15_16BPP(avctx, data, got_frame,
-                                        buf, buf_size);
-    }
-    else if (avctx->pix_fmt == AV_PIX_FMT_BGR24) {
-      return flic_decode_frame_24BPP(avctx, data, got_frame,
-                                     buf, buf_size);
+        return flic_decode_frame_8BPP(avctx, data, got_frame,
+                                      buf, buf_size);
+    } else if ((avctx->pix_fmt == AV_PIX_FMT_RGB555) ||
+               (avctx->pix_fmt == AV_PIX_FMT_RGB565)) {
+        return flic_decode_frame_15_16BPP(avctx, data, got_frame,
+                                          buf, buf_size);
+    } else if (avctx->pix_fmt == AV_PIX_FMT_BGR24) {
+        return flic_decode_frame_24BPP(avctx, data, got_frame,
+                                       buf, buf_size);
     }
 
     /* Should not get  here, ever as the pix_fmt is processed */
diff --git a/mythtv/external/FFmpeg/libavcodec/flvdec.c b/mythtv/external/FFmpeg/libavcodec/flvdec.c
index f74ba3f018c..f9beb40afa6 100644
--- a/mythtv/external/FFmpeg/libavcodec/flvdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/flvdec.c
@@ -123,6 +123,7 @@ AVCodec ff_flv_decoder = {
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .max_lowres     = 3,
     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
                                                      AV_PIX_FMT_NONE },
diff --git a/mythtv/external/FFmpeg/libavcodec/fmvc.c b/mythtv/external/FFmpeg/libavcodec/fmvc.c
new file mode 100644
index 00000000000..74e9bdd8a08
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/fmvc.c
@@ -0,0 +1,630 @@
+/*
+ * FM Screen Capture Codec decoder
+ *
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "avcodec.h"
+#include "bytestream.h"
+#include "internal.h"
+
+#define BLOCK_HEIGHT 112u
+#define BLOCK_WIDTH  84u
+
+typedef struct InterBlock {
+    int      w, h;
+    int      size;
+    int      xor;
+} InterBlock;
+
+typedef struct FMVCContext {
+    GetByteContext  gb;
+    PutByteContext  pb;
+    uint8_t        *buffer;
+    size_t          buffer_size;
+    uint8_t        *pbuffer;
+    size_t          pbuffer_size;
+    int             stride;
+    int             bpp;
+    int             yb, xb;
+    InterBlock     *blocks;
+    int             nb_blocks;
+} FMVCContext;
+
+static int decode_type2(GetByteContext *gb, PutByteContext *pb)
+{
+    unsigned repeat = 0, first = 1, opcode = 0;
+    int i, len, pos;
+
+    while (bytestream2_get_bytes_left(gb) > 0) {
+        GetByteContext gbc;
+
+        while (bytestream2_get_bytes_left(gb) > 0) {
+            if (first) {
+                first = 0;
+                if (bytestream2_peek_byte(gb) > 17) {
+                    len = bytestream2_get_byte(gb) - 17;
+                    if (len < 4) {
+                        do {
+                            bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                            --len;
+                        } while (len);
+                        opcode = bytestream2_peek_byte(gb);
+                        continue;
+                    } else {
+                        do {
+                            bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                            --len;
+                        } while (len);
+                        opcode = bytestream2_peek_byte(gb);
+                        if (opcode < 0x10) {
+                            bytestream2_skip(gb, 1);
+                            pos = - (opcode >> 2) - 4 * bytestream2_get_byte(gb) - 2049;
+
+                            bytestream2_init(&gbc, pb->buffer_start, pb->buffer_end - pb->buffer_start);
+                            bytestream2_seek(&gbc, bytestream2_tell_p(pb) + pos, SEEK_SET);
+
+                            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                            len = opcode & 3;
+                            if (!len) {
+                                repeat = 1;
+                            } else {
+                                do {
+                                    bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                                    --len;
+                                } while (len);
+                                opcode = bytestream2_peek_byte(gb);
+                            }
+                            continue;
+                        }
+                    }
+                    repeat = 0;
+                }
+                repeat = 1;
+            }
+            if (repeat) {
+                repeat = 0;
+                opcode = bytestream2_peek_byte(gb);
+                if (opcode < 0x10) {
+                    bytestream2_skip(gb, 1);
+                    if (!opcode) {
+                        if (!bytestream2_peek_byte(gb)) {
+                            do {
+                                bytestream2_skip(gb, 1);
+                                opcode += 255;
+                            } while (!bytestream2_peek_byte(gb) && bytestream2_get_bytes_left(gb) > 0);
+                        }
+                        opcode += bytestream2_get_byte(gb) + 15;
+                    }
+                    bytestream2_put_le32(pb, bytestream2_get_le32(gb));
+                    for (i = opcode - 1; i > 0; --i)
+                        bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                    opcode = bytestream2_peek_byte(gb);
+                    if (opcode < 0x10) {
+                        bytestream2_skip(gb, 1);
+                        pos = - (opcode >> 2) - 4 * bytestream2_get_byte(gb) - 2049;
+
+                        bytestream2_init(&gbc, pb->buffer_start, pb->buffer_end - pb->buffer_start);
+                        bytestream2_seek(&gbc, bytestream2_tell_p(pb) + pos, SEEK_SET);
+
+                        bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                        bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                        bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                        len = opcode & 3;
+                        if (!len) {
+                            repeat = 1;
+                        } else {
+                            do {
+                                bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                                --len;
+                            } while (len);
+                            opcode = bytestream2_peek_byte(gb);
+                        }
+                        continue;
+                    }
+                }
+            }
+
+            if (opcode >= 0x40) {
+                bytestream2_skip(gb, 1);
+                pos = - ((opcode >> 2) & 7) - 1 - 8 * bytestream2_get_byte(gb);
+                len = (opcode >> 5) - 1;
+
+                bytestream2_init(&gbc, pb->buffer_start, pb->buffer_end - pb->buffer_start);
+                bytestream2_seek(&gbc, bytestream2_tell_p(pb) + pos, SEEK_SET);
+
+                bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                do {
+                    bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                    --len;
+                } while (len);
+
+                len = opcode & 3;
+
+                if (!len) {
+                    repeat = 1;
+                } else {
+                    do {
+                        bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                        --len;
+                    } while (len);
+                    opcode = bytestream2_peek_byte(gb);
+                }
+                continue;
+            } else if (opcode < 0x20) {
+                break;
+            }
+            len = opcode & 0x1F;
+            bytestream2_skip(gb, 1);
+            if (!len) {
+                if (!bytestream2_peek_byte(gb)) {
+                    do {
+                        bytestream2_skip(gb, 1);
+                        len += 255;
+                    } while (!bytestream2_peek_byte(gb) && bytestream2_get_bytes_left(gb) > 0);
+                }
+                len += bytestream2_get_byte(gb) + 31;
+            }
+            i = bytestream2_get_le16(gb);
+            pos = - (i >> 2) - 1;
+
+            bytestream2_init(&gbc, pb->buffer_start, pb->buffer_end - pb->buffer_start);
+            bytestream2_seek(&gbc, bytestream2_tell_p(pb) + pos, SEEK_SET);
+
+            if (len < 6 || bytestream2_tell_p(pb) - bytestream2_tell(&gbc) < 4) {
+                bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                do {
+                    bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                    --len;
+                } while (len);
+            } else {
+                bytestream2_put_le32(pb, bytestream2_get_le32(&gbc));
+                for (len = len - 2; len; --len)
+                    bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+            }
+            len = i & 3;
+            if (!len) {
+                repeat = 1;
+            } else {
+                do {
+                    bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                    --len;
+                } while (len);
+                opcode = bytestream2_peek_byte(gb);
+            }
+        }
+        bytestream2_skip(gb, 1);
+        if (opcode < 0x10) {
+            pos = -(opcode >> 2) - 1 - 4 * bytestream2_get_byte(gb);
+
+            bytestream2_init(&gbc, pb->buffer_start, pb->buffer_end - pb->buffer_start);
+            bytestream2_seek(&gbc, bytestream2_tell_p(pb) + pos, SEEK_SET);
+
+            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+            len = opcode & 3;
+            if (!len) {
+                repeat = 1;
+            } else {
+                do {
+                    bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                    --len;
+                } while (len);
+                opcode = bytestream2_peek_byte(gb);
+            }
+            continue;
+        }
+        len = opcode & 7;
+        if (!len) {
+            if (!bytestream2_peek_byte(gb)) {
+                do {
+                    bytestream2_skip(gb, 1);
+                    len += 255;
+                } while (!bytestream2_peek_byte(gb) && bytestream2_get_bytes_left(gb) > 0);
+            }
+            len += bytestream2_get_byte(gb) + 7;
+        }
+        i = bytestream2_get_le16(gb);
+        pos = bytestream2_tell_p(pb) - 2048 * (opcode & 8);
+        pos = pos - (i >> 2);
+        if (pos == bytestream2_tell_p(pb))
+            break;
+
+        pos = pos - 0x4000;
+        bytestream2_init(&gbc, pb->buffer_start, pb->buffer_end - pb->buffer_start);
+        bytestream2_seek(&gbc, pos, SEEK_SET);
+
+        if (len < 6 || bytestream2_tell_p(pb) - bytestream2_tell(&gbc) < 4) {
+            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+            do {
+                bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                --len;
+            } while (len);
+        } else {
+            bytestream2_put_le32(pb, bytestream2_get_le32(&gbc));
+            for (len = len - 2; len; --len)
+                bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+        }
+
+        len = i & 3;
+        if (!len) {
+            repeat = 1;
+        } else {
+            do {
+                bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                --len;
+            } while (len);
+            opcode = bytestream2_peek_byte(gb);
+        }
+    }
+
+    return 0;
+}
+
+static int decode_type1(GetByteContext *gb, PutByteContext *pb)
+{
+    unsigned opcode = 0, len;
+    int high = 0;
+    int i, pos;
+
+    while (bytestream2_get_bytes_left(gb) > 0) {
+        GetByteContext gbc;
+
+        while (bytestream2_get_bytes_left(gb) > 0) {
+            while (bytestream2_get_bytes_left(gb) > 0) {
+                opcode = bytestream2_get_byte(gb);
+                high = opcode >= 0x20;
+                if (high)
+                    break;
+                if (opcode)
+                    break;
+                opcode = bytestream2_get_byte(gb);
+                if (opcode < 0xF8) {
+                    opcode = opcode + 32;
+                    break;
+                }
+                i = opcode - 0xF8;
+                if (i) {
+                    len = 256;
+                    do {
+                        len *= 2;
+                        --i;
+                    } while (i);
+                } else {
+                    len = 280;
+                }
+                do {
+                    bytestream2_put_le32(pb, bytestream2_get_le32(gb));
+                    bytestream2_put_le32(pb, bytestream2_get_le32(gb));
+                    len -= 8;
+                } while (len && bytestream2_get_bytes_left(gb) > 0);
+            }
+
+            if (!high) {
+                do {
+                    bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                    --opcode;
+                } while (opcode && bytestream2_get_bytes_left(gb) > 0);
+
+                while (bytestream2_get_bytes_left(gb) > 0) {
+                    GetByteContext gbc;
+
+                    opcode = bytestream2_get_byte(gb);
+                    if (opcode >= 0x20)
+                        break;
+                    bytestream2_init(&gbc, pb->buffer_start, pb->buffer_end - pb->buffer_start);
+
+                    pos = -(opcode | 32 * bytestream2_get_byte(gb)) - 1;
+                    bytestream2_seek(&gbc, bytestream2_tell_p(pb) + pos, SEEK_SET);
+                    bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                    bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                    bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                    bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                }
+            }
+            high = 0;
+            if (opcode < 0x40)
+                break;
+            bytestream2_init(&gbc, pb->buffer_start, pb->buffer_end - pb->buffer_start);
+            pos = (-((opcode & 0x1F) | 32 * bytestream2_get_byte(gb)) - 1);
+            bytestream2_seek(&gbc, bytestream2_tell_p(pb) + pos, SEEK_SET);
+            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+            len = (opcode >> 5) - 1;
+            do {
+                bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+                --len;
+            } while (len && bytestream2_get_bytes_left(&gbc) > 0);
+        }
+        len = opcode & 0x1F;
+        if (!len) {
+            if (!bytestream2_peek_byte(gb)) {
+                do {
+                    bytestream2_skip(gb, 1);
+                    len += 255;
+                } while (!bytestream2_peek_byte(gb) && bytestream2_get_bytes_left(gb) > 0);
+            }
+            len += bytestream2_get_byte(gb) + 31;
+        }
+        pos = -bytestream2_get_byte(gb);
+        bytestream2_init(&gbc, pb->buffer_start, pb->buffer_end - pb->buffer_start);
+        bytestream2_seek(&gbc, bytestream2_tell_p(pb) + pos - (bytestream2_get_byte(gb) << 8), SEEK_SET);
+        if (bytestream2_tell_p(pb) == bytestream2_tell(&gbc))
+            break;
+        if (len < 5 || bytestream2_tell_p(pb) - bytestream2_tell(&gbc) < 4) {
+            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+        } else {
+            bytestream2_put_le32(pb, bytestream2_get_le32(&gbc));
+            len--;
+        }
+        do {
+            bytestream2_put_byte(pb, bytestream2_get_byte(&gbc));
+            len--;
+        } while (len && bytestream2_get_bytes_left(&gbc) > 0);
+    }
+
+    return 0;
+}
+
+static int decode_frame(AVCodecContext *avctx,
+                        void *data, int *got_frame,
+                        AVPacket *avpkt)
+{
+    FMVCContext *s = avctx->priv_data;
+    GetByteContext *gb = &s->gb;
+    PutByteContext *pb = &s->pb;
+    AVFrame *frame = data;
+    int ret, y, x;
+
+    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
+        return ret;
+
+    bytestream2_init(gb, avpkt->data, avpkt->size);
+    bytestream2_skip(gb, 2);
+
+    frame->key_frame = !!bytestream2_get_le16(gb);
+    frame->pict_type = frame->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
+
+    if (frame->key_frame) {
+        const uint8_t *src;
+        int type, size;
+        uint8_t *dst;
+
+        type = bytestream2_get_le16(gb);
+        size = bytestream2_get_le16(gb);
+        if (size > bytestream2_get_bytes_left(gb))
+            return AVERROR_INVALIDDATA;
+
+        bytestream2_init_writer(pb, s->buffer, s->buffer_size);
+        if (type == 1) {
+            decode_type1(gb, pb);
+        } else if (type == 2){
+            decode_type2(gb, pb);
+        } else {
+            avpriv_report_missing_feature(avctx, "compression %d", type);
+            return AVERROR_PATCHWELCOME;
+        }
+
+        src = s->buffer;
+        dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
+        for (y = 0; y < avctx->height; y++) {
+            memcpy(dst, src, avctx->width * s->bpp);
+            dst -= frame->linesize[0];
+            src += s->stride * 4;
+        }
+    } else {
+        int block, nb_blocks, type, k, l;
+        uint8_t *ssrc, *ddst;
+        const uint32_t *src;
+        uint32_t *dst;
+
+        for (block = 0; block < s->nb_blocks; block++)
+            s->blocks[block].xor = 0;
+
+        nb_blocks = bytestream2_get_le16(gb);
+        if (nb_blocks > s->nb_blocks)
+            return AVERROR_INVALIDDATA;
+
+        bytestream2_init_writer(pb, s->pbuffer, s->pbuffer_size);
+
+        type = bytestream2_get_le16(gb);
+        for (block = 0; block < nb_blocks; block++) {
+            int size, offset, start = 0;
+
+            offset = bytestream2_get_le16(gb);
+            if (offset >= s->nb_blocks)
+                return AVERROR_INVALIDDATA;
+
+            size = bytestream2_get_le16(gb);
+            if (size > bytestream2_get_bytes_left(gb))
+                return AVERROR_INVALIDDATA;
+
+            start = bytestream2_tell_p(pb);
+            if (type == 1) {
+                decode_type1(gb, pb);
+            } else if (type == 2){
+                decode_type2(gb, pb);
+            } else {
+                avpriv_report_missing_feature(avctx, "compression %d", type);
+                return AVERROR_PATCHWELCOME;
+            }
+
+            if (s->blocks[offset].size * 4 != bytestream2_tell_p(pb) - start)
+                return AVERROR_INVALIDDATA;
+
+            s->blocks[offset].xor = 1;
+        }
+
+        src = (const uint32_t *)s->pbuffer;
+        dst = (uint32_t *)s->buffer;
+
+        for (block = 0, y = 0; y < s->yb; y++) {
+            int block_h = s->blocks[block].h;
+            uint32_t *rect = dst;
+
+            for (x = 0; x < s->xb; x++) {
+                int block_w = s->blocks[block].w;
+                uint32_t *row = dst;
+
+                block_h = s->blocks[block].h;
+                if (s->blocks[block].xor) {
+                    for (k = 0; k < block_h; k++) {
+                        uint32_t *column = dst;
+                        for (l = 0; l < block_w; l++) {
+                            *dst++ ^= *src++;
+                        }
+                        dst = &column[s->stride];
+                    }
+                }
+                dst = &row[block_w];
+                ++block;
+            }
+            dst = &rect[block_h * s->stride];
+        }
+
+        ssrc = s->buffer;
+        ddst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
+        for (y = 0; y < avctx->height; y++) {
+            memcpy(ddst, ssrc, avctx->width * s->bpp);
+            ddst -= frame->linesize[0];
+            ssrc += s->stride * 4;
+        }
+    }
+
+    *got_frame = 1;
+
+    return avpkt->size;
+}
+
+static av_cold int decode_init(AVCodecContext *avctx)
+{
+    FMVCContext *s = avctx->priv_data;
+    int i, j, m, block = 0, h = BLOCK_HEIGHT, w = BLOCK_WIDTH;
+
+    switch (avctx->bits_per_coded_sample) {
+    case 16: avctx->pix_fmt = AV_PIX_FMT_RGB555; break;
+    case 24: avctx->pix_fmt = AV_PIX_FMT_BGR24;  break;
+    case 32: avctx->pix_fmt = AV_PIX_FMT_BGRA;   break;
+    default:
+        av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", avctx->bits_per_coded_sample);
+        return AVERROR_INVALIDDATA;
+    }
+
+    s->stride = (avctx->width * avctx->bits_per_coded_sample + 31) / 32;
+    s->xb = s->stride / BLOCK_WIDTH;
+    m = s->stride % BLOCK_WIDTH;
+    if (m) {
+        if (m < 37) {
+            w = m + BLOCK_WIDTH;
+        } else {
+            w = m;
+            s->xb++;
+        }
+    }
+
+    s->yb = avctx->height / BLOCK_HEIGHT;
+    m = avctx->height % BLOCK_HEIGHT;
+    if (m) {
+        if (m < 49) {
+            h = m + BLOCK_HEIGHT;
+        } else {
+            h = m;
+            s->yb++;
+        }
+    }
+
+    s->nb_blocks = s->xb * s->yb;
+    if (!s->nb_blocks)
+        return AVERROR_INVALIDDATA;
+
+    s->blocks = av_calloc(s->nb_blocks, sizeof(*s->blocks));
+    if (!s->blocks)
+        return AVERROR(ENOMEM);
+
+    for (i = 0; i < s->yb; i++) {
+        for (j = 0; j < s->xb; j++) {
+            if (i != (s->yb - 1) || j != (s->xb - 1)) {
+                if (i == s->yb - 1) {
+                    s->blocks[block].w = BLOCK_WIDTH;
+                    s->blocks[block].h = h;
+                    s->blocks[block].size = BLOCK_WIDTH * h;
+                } else if (j == s->xb - 1) {
+                    s->blocks[block].w = w;
+                    s->blocks[block].h = BLOCK_HEIGHT;
+                    s->blocks[block].size = BLOCK_HEIGHT * w;
+                } else {
+                    s->blocks[block].w = BLOCK_WIDTH;
+                    s->blocks[block].h = BLOCK_HEIGHT;
+                    s->blocks[block].size = BLOCK_WIDTH * BLOCK_HEIGHT;
+                }
+            } else {
+                s->blocks[block].w = w;
+                s->blocks[block].h = h;
+                s->blocks[block].size = w * h;
+            }
+            block++;
+        }
+    }
+
+    s->bpp = avctx->bits_per_coded_sample >> 3;
+    s->buffer_size = avctx->width * avctx->height * 4;
+    s->pbuffer_size = avctx->width * avctx->height * 4;
+    s->buffer = av_mallocz(s->buffer_size);
+    s->pbuffer = av_mallocz(s->pbuffer_size);
+    if (!s->buffer || !s->pbuffer)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+static av_cold int decode_close(AVCodecContext *avctx)
+{
+    FMVCContext *s = avctx->priv_data;
+
+    av_freep(&s->buffer);
+    av_freep(&s->pbuffer);
+    av_freep(&s->blocks);
+
+    return 0;
+}
+
+AVCodec ff_fmvc_decoder = {
+    .name             = "fmvc",
+    .long_name        = NULL_IF_CONFIG_SMALL("FM Screen Capture Codec"),
+    .type             = AVMEDIA_TYPE_VIDEO,
+    .id               = AV_CODEC_ID_FMVC,
+    .priv_data_size   = sizeof(FMVCContext),
+    .init             = decode_init,
+    .close            = decode_close,
+    .decode           = decode_frame,
+    .capabilities     = AV_CODEC_CAP_DR1,
+    .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
+                        FF_CODEC_CAP_INIT_CLEANUP,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/frame_thread_encoder.c b/mythtv/external/FFmpeg/libavcodec/frame_thread_encoder.c
index 27ae356af30..215aee9fc06 100644
--- a/mythtv/external/FFmpeg/libavcodec/frame_thread_encoder.c
+++ b/mythtv/external/FFmpeg/libavcodec/frame_thread_encoder.c
@@ -18,11 +18,14 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <stdatomic.h>
+
 #include "frame_thread_encoder.h"
 
 #include "libavutil/fifo.h"
 #include "libavutil/avassert.h"
 #include "libavutil/imgutils.h"
+#include "libavutil/opt.h"
 #include "libavutil/thread.h"
 #include "avcodec.h"
 #include "internal.h"
@@ -54,7 +57,7 @@ typedef struct{
     unsigned finished_task_index;
 
     pthread_t worker[MAX_THREADS];
-    int exit;
+    atomic_int exit;
 } ThreadContext;
 
 static void * attribute_align_arg worker(void *v){
@@ -62,18 +65,18 @@ static void * attribute_align_arg worker(void *v){
     ThreadContext *c = avctx->internal->frame_thread_encoder;
     AVPacket *pkt = NULL;
 
-    while(!c->exit){
+    while (!atomic_load(&c->exit)) {
         int got_packet, ret;
         AVFrame *frame;
         Task task;
 
-        if(!pkt) pkt= av_mallocz(sizeof(*pkt));
+        if(!pkt) pkt = av_packet_alloc();
         if(!pkt) continue;
         av_init_packet(pkt);
 
         pthread_mutex_lock(&c->task_fifo_mutex);
-        while (av_fifo_size(c->task_fifo) <= 0 || c->exit) {
-            if(c->exit){
+        while (av_fifo_size(c->task_fifo) <= 0 || atomic_load(&c->exit)) {
+            if (atomic_load(&c->exit)) {
                 pthread_mutex_unlock(&c->task_fifo_mutex);
                 goto end;
             }
@@ -186,18 +189,28 @@ int ff_frame_thread_encoder_init(AVCodecContext *avctx, AVDictionary *options){
     pthread_mutex_init(&c->buffer_mutex, NULL);
     pthread_cond_init(&c->task_fifo_cond, NULL);
     pthread_cond_init(&c->finished_task_cond, NULL);
+    atomic_init(&c->exit, 0);
 
     for(i=0; i<avctx->thread_count ; i++){
         AVDictionary *tmp = NULL;
+        int ret;
         void *tmpv;
         AVCodecContext *thread_avctx = avcodec_alloc_context3(avctx->codec);
         if(!thread_avctx)
             goto fail;
         tmpv = thread_avctx->priv_data;
         *thread_avctx = *avctx;
+        ret = av_opt_copy(thread_avctx, avctx);
+        if (ret < 0)
+            goto fail;
         thread_avctx->priv_data = tmpv;
         thread_avctx->internal = NULL;
-        memcpy(thread_avctx->priv_data, avctx->priv_data, avctx->codec->priv_data_size);
+        if (avctx->codec->priv_class) {
+            int ret = av_opt_copy(thread_avctx->priv_data, avctx->priv_data);
+            if (ret < 0)
+                goto fail;
+        } else
+            memcpy(thread_avctx->priv_data, avctx->priv_data, avctx->codec->priv_data_size);
         thread_avctx->thread_count = 1;
         thread_avctx->active_thread_type &= ~FF_THREAD_FRAME;
 
@@ -230,7 +243,7 @@ void ff_frame_thread_encoder_free(AVCodecContext *avctx){
     ThreadContext *c= avctx->internal->frame_thread_encoder;
 
     pthread_mutex_lock(&c->task_fifo_mutex);
-    c->exit = 1;
+    atomic_store(&c->exit, 1);
     pthread_cond_broadcast(&c->task_fifo_cond);
     pthread_mutex_unlock(&c->task_fifo_mutex);
 
@@ -272,15 +285,16 @@ int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVF
         pthread_mutex_unlock(&c->task_fifo_mutex);
 
         c->task_index = (c->task_index+1) % BUFFER_SIZE;
-
-        if(!c->finished_tasks[c->finished_task_index].outdata && (c->task_index - c->finished_task_index) % BUFFER_SIZE <= avctx->thread_count)
-            return 0;
     }
 
-    if(c->task_index == c->finished_task_index)
-        return 0;
-
     pthread_mutex_lock(&c->finished_task_mutex);
+    if (c->task_index == c->finished_task_index ||
+        (frame && !c->finished_tasks[c->finished_task_index].outdata &&
+         (c->task_index - c->finished_task_index) % BUFFER_SIZE <= avctx->thread_count)) {
+            pthread_mutex_unlock(&c->finished_task_mutex);
+            return 0;
+        }
+
     while (!c->finished_tasks[c->finished_task_index].outdata) {
         pthread_cond_wait(&c->finished_task_cond, &c->finished_task_mutex);
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/fraps.c b/mythtv/external/FFmpeg/libavcodec/fraps.c
index 57e13f2685a..7a7673f73fe 100644
--- a/mythtv/external/FFmpeg/libavcodec/fraps.c
+++ b/mythtv/external/FFmpeg/libavcodec/fraps.c
@@ -146,6 +146,7 @@ static int decode_frame(AVCodecContext *avctx,
     uint32_t offs[4];
     int i, j, ret, is_chroma;
     const int planes = 3;
+    int is_pal;
     uint8_t *out;
 
     if (buf_size < 4) {
@@ -155,18 +156,26 @@ static int decode_frame(AVCodecContext *avctx,
 
     header      = AV_RL32(buf);
     version     = header & 0xff;
+    is_pal      = buf[1] == 2 && version == 1;
     header_size = (header & (1<<30))? 8 : 4; /* bit 30 means pad to 8 bytes */
 
     if (version > 5) {
-        av_log(avctx, AV_LOG_ERROR,
-               "This file is encoded with Fraps version %d. " \
-               "This codec can only decode versions <= 5.\n", version);
+        avpriv_report_missing_feature(avctx, "Fraps version %u", version);
         return AVERROR_PATCHWELCOME;
     }
 
     buf += header_size;
 
-    if (version < 2) {
+    if (is_pal) {
+        unsigned needed_size = avctx->width * avctx->height + 1024;
+        needed_size += header_size;
+        if (buf_size != needed_size) {
+            av_log(avctx, AV_LOG_ERROR,
+                   "Invalid frame length %d (should be %d)\n",
+                   buf_size, needed_size);
+            return AVERROR_INVALIDDATA;
+        }
+    } else if (version < 2) {
         unsigned needed_size = avctx->width * avctx->height * 3;
         if (version == 0) needed_size /= 2;
         needed_size += header_size;
@@ -209,7 +218,7 @@ static int decode_frame(AVCodecContext *avctx,
     f->pict_type = AV_PICTURE_TYPE_I;
     f->key_frame = 1;
 
-    avctx->pix_fmt = version & 1 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_YUVJ420P;
+    avctx->pix_fmt = version & 1 ? is_pal ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_BGR24 : AV_PIX_FMT_YUVJ420P;
     avctx->color_range = version & 1 ? AVCOL_RANGE_UNSPECIFIED
                                      : AVCOL_RANGE_JPEG;
     avctx->colorspace = version & 1 ? AVCOL_SPC_UNSPECIFIED : AVCOL_SPC_BT709;
@@ -245,11 +254,25 @@ static int decode_frame(AVCodecContext *avctx,
         break;
 
     case 1:
+        if (is_pal) {
+            uint32_t *pal = (uint32_t *)f->data[1];
+
+            for (y = 0; y < 256; y++) {
+                pal[y] = AV_RL32(buf) | 0xFF000000;
+                buf += 4;
+            }
+
+            for (y = 0; y <avctx->height; y++)
+                memcpy(&f->data[0][y * f->linesize[0]],
+                       &buf[y * avctx->width],
+                       avctx->width);
+        } else {
         /* Fraps v1 is an upside-down BGR24 */
             for (y = 0; y<avctx->height; y++)
                 memcpy(&f->data[0][(avctx->height - y - 1) * f->linesize[0]],
                        &buf[y * avctx->width * 3],
                        3 * avctx->width);
+        }
         break;
 
     case 2:
@@ -325,4 +348,5 @@ AVCodec ff_fraps_decoder = {
     .close          = decode_end,
     .decode         = decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/g2meet.c b/mythtv/external/FFmpeg/libavcodec/g2meet.c
index b0af3ec046a..842095ba3b4 100644
--- a/mythtv/external/FFmpeg/libavcodec/g2meet.c
+++ b/mythtv/external/FFmpeg/libavcodec/g2meet.c
@@ -122,7 +122,7 @@ typedef struct JPGContext {
 
     VLC        dc_vlc[2], ac_vlc[2];
     int        prev_dc[3];
-    DECLARE_ALIGNED(16, int16_t, block)[6][64];
+    DECLARE_ALIGNED(32, int16_t, block)[6][64];
 
     uint8_t    *buf;
 } JPGContext;
@@ -1442,9 +1442,8 @@ static int g2m_decode_frame(AVCodecContext *avctx, void *data,
             }
             c->compression = bytestream2_get_be32(&bc);
             if (c->compression != 2 && c->compression != 3) {
-                av_log(avctx, AV_LOG_ERROR,
-                       "Unknown compression method %d\n",
-                       c->compression);
+                avpriv_report_missing_feature(avctx, "Compression method %d",
+                                              c->compression);
                 ret = AVERROR_PATCHWELCOME;
                 goto header_fail;
             }
@@ -1475,9 +1474,9 @@ static int g2m_decode_frame(AVCodecContext *avctx, void *data,
                 g_mask = bytestream2_get_be32(&bc);
                 b_mask = bytestream2_get_be32(&bc);
                 if (r_mask != 0xFF0000 || g_mask != 0xFF00 || b_mask != 0xFF) {
-                    av_log(avctx, AV_LOG_ERROR,
-                           "Invalid or unsupported bitmasks: R=%"PRIX32", G=%"PRIX32", B=%"PRIX32"\n",
-                           r_mask, g_mask, b_mask);
+                    avpriv_report_missing_feature(avctx,
+                                                  "Bitmasks: R=%"PRIX32", G=%"PRIX32", B=%"PRIX32,
+                                                  r_mask, g_mask, b_mask);
                     ret = AVERROR_PATCHWELCOME;
                     goto header_fail;
                 }
diff --git a/mythtv/external/FFmpeg/libavcodec/g722.c b/mythtv/external/FFmpeg/libavcodec/g722.c
index ee3b85f845e..ef7ca6d446d 100644
--- a/mythtv/external/FFmpeg/libavcodec/g722.c
+++ b/mythtv/external/FFmpeg/libavcodec/g722.c
@@ -88,14 +88,14 @@ static inline void s_zero(int cur_diff, struct G722Band *band)
         ACCUM(3, band->diff_mem[2], 1);
         ACCUM(2, band->diff_mem[1], 1);
         ACCUM(1, band->diff_mem[0], 1);
-        ACCUM(0, cur_diff << 1, 1);
+        ACCUM(0, cur_diff * 2, 1);
     } else {
         ACCUM(5, band->diff_mem[4], 0);
         ACCUM(4, band->diff_mem[3], 0);
         ACCUM(3, band->diff_mem[2], 0);
         ACCUM(2, band->diff_mem[1], 0);
         ACCUM(1, band->diff_mem[0], 0);
-        ACCUM(0, cur_diff << 1, 0);
+        ACCUM(0, cur_diff * 2, 0);
     }
     #undef ACCUM
     band->s_zero = s_zero;
@@ -119,14 +119,14 @@ static void do_adaptive_prediction(struct G722Band *band, const int cur_diff)
     band->part_reconst_mem[0] = cur_part_reconst;
 
     band->pole_mem[1] = av_clip((sg[0] * av_clip(band->pole_mem[0], -8191, 8191) >> 5) +
-                                (sg[1] << 7) + (band->pole_mem[1] * 127 >> 7), -12288, 12288);
+                                (sg[1] * 128) + (band->pole_mem[1] * 127 >> 7), -12288, 12288);
 
     limit = 15360 - band->pole_mem[1];
     band->pole_mem[0] = av_clip(-192 * sg[0] + (band->pole_mem[0] * 255 >> 8), -limit, limit);
 
     s_zero(cur_diff, band);
 
-    cur_qtzd_reconst = av_clip_int16((band->s_predictor + cur_diff) << 1);
+    cur_qtzd_reconst = av_clip_int16((band->s_predictor + cur_diff) * 2);
     band->s_predictor = av_clip_int16(band->s_zero +
                                       (band->pole_mem[0] * cur_qtzd_reconst >> 15) +
                                       (band->pole_mem[1] * band->prev_qtzd_reconst >> 15));
diff --git a/mythtv/external/FFmpeg/libavcodec/g722dec.c b/mythtv/external/FFmpeg/libavcodec/g722dec.c
index 0bfa82a3943..000b591fe62 100644
--- a/mythtv/external/FFmpeg/libavcodec/g722dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/g722dec.c
@@ -80,8 +80,8 @@ static const int16_t low_inv_quant5[32] = {
 };
 
 static const int16_t * const low_inv_quants[3] = { ff_g722_low_inv_quant6,
-                                                    low_inv_quant5,
-                                            ff_g722_low_inv_quant4 };
+                                                           low_inv_quant5,
+                                                   ff_g722_low_inv_quant4 };
 
 static int g722_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame_ptr, AVPacket *avpkt)
diff --git a/mythtv/external/FFmpeg/libavcodec/g722enc.c b/mythtv/external/FFmpeg/libavcodec/g722enc.c
index 01a3db26fd6..25b61df19e5 100644
--- a/mythtv/external/FFmpeg/libavcodec/g722enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/g722enc.c
@@ -61,11 +61,6 @@ static av_cold int g722_encode_init(AVCodecContext * avctx)
     G722Context *c = avctx->priv_data;
     int ret;
 
-    if (avctx->channels != 1) {
-        av_log(avctx, AV_LOG_ERROR, "Only mono tracks are allowed.\n");
-        return AVERROR_INVALIDDATA;
-    }
-
     c->band[0].scale_factor = 8;
     c->band[1].scale_factor = 2;
     c->prev_samples_pos = 22;
@@ -381,15 +376,15 @@ static int g722_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 }
 
 AVCodec ff_adpcm_g722_encoder = {
-    .name           = "g722",
-    .long_name      = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
-    .type           = AVMEDIA_TYPE_AUDIO,
-    .id             = AV_CODEC_ID_ADPCM_G722,
-    .priv_data_size = sizeof(G722Context),
-    .init           = g722_encode_init,
-    .close          = g722_encode_close,
-    .encode2        = g722_encode_frame,
-    .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME,
-    .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
-                                                     AV_SAMPLE_FMT_NONE },
+    .name            = "g722",
+    .long_name       = NULL_IF_CONFIG_SMALL("G.722 ADPCM"),
+    .type            = AVMEDIA_TYPE_AUDIO,
+    .id              = AV_CODEC_ID_ADPCM_G722,
+    .priv_data_size  = sizeof(G722Context),
+    .init            = g722_encode_init,
+    .close           = g722_encode_close,
+    .encode2         = g722_encode_frame,
+    .capabilities    = AV_CODEC_CAP_SMALL_LAST_FRAME,
+    .sample_fmts     = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE },
+    .channel_layouts = (const uint64_t[]){ AV_CH_LAYOUT_MONO, 0 },
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/g723_1.c b/mythtv/external/FFmpeg/libavcodec/g723_1.c
index a11fec8a9ee..1deff495de5 100644
--- a/mythtv/external/FFmpeg/libavcodec/g723_1.c
+++ b/mythtv/external/FFmpeg/libavcodec/g723_1.c
@@ -41,7 +41,7 @@ int ff_g723_1_scale_vector(int16_t *dst, const int16_t *vector, int length)
     bits= FFMAX(bits, 0);
 
     for (i = 0; i < length; i++)
-        dst[i] = vector[i] << bits >> 3;
+        dst[i] = (vector[i] * (1 << bits)) >> 3;
 
     return bits - 3;
 }
@@ -125,9 +125,9 @@ static void lsp2lpc(int16_t *lpc)
     for (j = 0; j < LPC_ORDER; j++) {
         int index     = (lpc[j] >> 7) & 0x1FF;
         int offset    = lpc[j] & 0x7f;
-        int temp1     = cos_tab[index] << 16;
+        int temp1     = cos_tab[index] * (1 << 16);
         int temp2     = (cos_tab[index + 1] - cos_tab[index]) *
-                          ((offset << 8) + 0x80) << 1;
+                          (((offset << 8) + 0x80) << 1);
 
         lpc[j] = -(av_sat_dadd32(1 << 15, temp1 + temp2) >> 16);
     }
@@ -138,11 +138,11 @@ static void lsp2lpc(int16_t *lpc)
      */
     /* Initialize with values in Q28 */
     f1[0] = 1 << 28;
-    f1[1] = (lpc[0] << 14) + (lpc[2] << 14);
+    f1[1] = (lpc[0] + lpc[2]) * (1 << 14);
     f1[2] = lpc[0] * lpc[2] + (2 << 28);
 
     f2[0] = 1 << 28;
-    f2[1] = (lpc[1] << 14) + (lpc[3] << 14);
+    f2[1] = (lpc[1] + lpc[3]) * (1 << 14);
     f2[2] = lpc[1] * lpc[3] + (2 << 28);
 
     /*
@@ -150,8 +150,8 @@ static void lsp2lpc(int16_t *lpc)
      * each iteration for a final scaling factor of Q25
      */
     for (i = 2; i < LPC_ORDER / 2; i++) {
-        f1[i + 1] = f1[i - 1] + MULL2(f1[i], lpc[2 * i]);
-        f2[i + 1] = f2[i - 1] + MULL2(f2[i], lpc[2 * i + 1]);
+        f1[i + 1] = av_clipl_int32(f1[i - 1] + (int64_t)MULL2(f1[i], lpc[2 * i]));
+        f2[i + 1] = av_clipl_int32(f2[i - 1] + (int64_t)MULL2(f2[i], lpc[2 * i + 1]));
 
         for (j = i; j >= 2; j--) {
             f1[j] = MULL2(f1[j - 1], lpc[2 * i]) +
@@ -162,8 +162,8 @@ static void lsp2lpc(int16_t *lpc)
 
         f1[0] >>= 1;
         f2[0] >>= 1;
-        f1[1] = ((lpc[2 * i]     << 16 >> i) + f1[1]) >> 1;
-        f2[1] = ((lpc[2 * i + 1] << 16 >> i) + f2[1]) >> 1;
+        f1[1] = ((lpc[2 * i]     * 65536 >> i) + f1[1]) >> 1;
+        f2[1] = ((lpc[2 * i + 1] * 65536 >> i) + f2[1]) >> 1;
     }
 
     /* Convert polynomial coefficients to LPC coefficients */
@@ -171,8 +171,8 @@ static void lsp2lpc(int16_t *lpc)
         int64_t ff1 = f1[i + 1] + f1[i];
         int64_t ff2 = f2[i + 1] - f2[i];
 
-        lpc[i] = av_clipl_int32(((ff1 + ff2) << 3) + (1 << 15)) >> 16;
-        lpc[LPC_ORDER - i - 1] = av_clipl_int32(((ff1 - ff2) << 3) +
+        lpc[i] = av_clipl_int32(((ff1 + ff2) * 8) + (1 << 15)) >> 16;
+        lpc[LPC_ORDER - i - 1] = av_clipl_int32(((ff1 - ff2) * 8) +
                                                 (1 << 15)) >> 16;
     }
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/g723_1.h b/mythtv/external/FFmpeg/libavcodec/g723_1.h
index 40d6e700b1b..f833af01c64 100644
--- a/mythtv/external/FFmpeg/libavcodec/g723_1.h
+++ b/mythtv/external/FFmpeg/libavcodec/g723_1.h
@@ -55,7 +55,7 @@
  * @param b 16 bit multiplier
  */
 #define MULL2(a, b) \
-        ((((a) >> 16) * (b) << 1) + (((a) & 0xffff) * (b) >> 15))
+        ((((a) >> 16) * (b) * 2) + (((a) & 0xffff) * (b) >> 15))
 
 /**
  * G723.1 frame types
diff --git a/mythtv/external/FFmpeg/libavcodec/g723_1dec.c b/mythtv/external/FFmpeg/libavcodec/g723_1dec.c
index e9896b5e7af..c8202a937c4 100644
--- a/mythtv/external/FFmpeg/libavcodec/g723_1dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/g723_1dec.c
@@ -488,7 +488,7 @@ static void residual_interp(int16_t *buf, int16_t *out, int lag,
                           (FRAME_LEN - lag) * sizeof(*out));
     } else {  /* Unvoiced */
         for (i = 0; i < FRAME_LEN; i++) {
-            *rseed = *rseed * 521 + 259;
+            *rseed = (int16_t)(*rseed * 521 + 259);
             out[i] = gain * *rseed >> 15;
         }
         memset(buf, 0, (FRAME_LEN + PITCH_MAX) * sizeof(*buf));
@@ -517,7 +517,7 @@ static void residual_interp(int16_t *buf, int16_t *out, int lag,
                       (iir_coef)[n - 1] * ((dest)[m - n] >> in_shift);\
         }\
 \
-        (dest)[m] = av_clipl_int32(((src)[m] << 16) + (filter << 3) +\
+        (dest)[m] = av_clipl_int32(((src)[m] * 65536) + (filter * 8) +\
                                    (1 << 15)) >> res_shift;\
     }\
 }
@@ -660,11 +660,17 @@ static int estimate_sid_gain(G723_1_Context *p)
     int i, shift, seg, seg2, t, val, val_add, x, y;
 
     shift = 16 - p->cur_gain * 2;
-    if (shift > 0)
-        t = p->sid_gain << shift;
-    else
+    if (shift > 0) {
+        if (p->sid_gain == 0) {
+            t = 0;
+        } else if (shift >= 31 || (int32_t)((uint32_t)p->sid_gain << shift) >> shift != p->sid_gain) {
+            if (p->sid_gain < 0) t = INT32_MIN;
+            else                 t = INT32_MAX;
+        } else
+            t = p->sid_gain << shift;
+    }else
         t = p->sid_gain >> -shift;
-    x = t * cng_filt[0] >> 16;
+    x = av_clipl_int32(t * (int64_t)cng_filt[0] >> 16);
 
     if (x >= cng_bseg[2])
         return 0x3F;
@@ -695,13 +701,13 @@ static int estimate_sid_gain(G723_1_Context *p)
     if (y <= 0) {
         t = seg * 32 + (val + 1 << seg2);
         t = t * t - x;
-        val = (seg2 - 1 << 4) + val;
+        val = (seg2 - 1) * 16 + val;
         if (t >= y)
             val++;
     } else {
         t = seg * 32 + (val - 1 << seg2);
         t = t * t - x;
-        val = (seg2 - 1 << 4) + val;
+        val = (seg2 - 1) * 16 + val;
         if (t >= y)
             val--;
     }
@@ -733,7 +739,7 @@ static void generate_noise(G723_1_Context *p)
         off[i * 2 + 1] = ((t >> 1) & 1) + SUBFRAME_LEN;
         t >>= 2;
         for (j = 0; j < 11; j++) {
-            signs[i * 11 + j] = (t & 1) * 2 - 1 << 14;
+            signs[i * 11 + j] = ((t & 1) * 2 - 1)  * (1 << 14);
             t >>= 1;
         }
     }
@@ -777,7 +783,7 @@ static void generate_noise(G723_1_Context *p)
         sum = 0;
         if (shift < 0) {
            for (j = 0; j < SUBFRAME_LEN * 2; j++) {
-               t      = vector_ptr[j] << -shift;
+               t      = vector_ptr[j] * (1 << -shift);
                sum   += t * t;
                tmp[j] = t;
            }
@@ -815,7 +821,7 @@ static void generate_noise(G723_1_Context *p)
         if (shift < 0)
            x >>= -shift;
         else
-           x <<= shift;
+           x *= 1 << shift;
         x = av_clip(x, -10000, 10000);
 
         for (j = 0; j < 11; j++) {
@@ -904,7 +910,7 @@ static int g723_1_decode_frame(AVCodecContext *avctx, void *data,
                                              &p->subframe[i], p->cur_rate);
                 /* Get the total excitation */
                 for (j = 0; j < SUBFRAME_LEN; j++) {
-                    int v = av_clip_int16(vector_ptr[j] << 1);
+                    int v = av_clip_int16(vector_ptr[j] * 2);
                     vector_ptr[j] = av_clip_int16(v + acb_vector[j]);
                 }
                 vector_ptr += SUBFRAME_LEN;
diff --git a/mythtv/external/FFmpeg/libavcodec/g723_1enc.c b/mythtv/external/FFmpeg/libavcodec/g723_1enc.c
index e7afa4d3731..4a4525eda99 100644
--- a/mythtv/external/FFmpeg/libavcodec/g723_1enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/g723_1enc.c
@@ -57,7 +57,8 @@ static av_cold int g723_1_encode_init(AVCodecContext *avctx)
     if (avctx->bit_rate == 6300) {
         p->cur_rate = RATE_6300;
     } else if (avctx->bit_rate == 5300) {
-        av_log(avctx, AV_LOG_ERROR, "Bitrate not supported yet, use 6300\n");
+        av_log(avctx, AV_LOG_ERROR, "Use bitrate 6300 instead of 5300.\n");
+        avpriv_report_missing_feature(avctx, "Bitrate 5300");
         return AVERROR_PATCHWELCOME;
     } else {
         av_log(avctx, AV_LOG_ERROR, "Bitrate not supported, use 6300\n");
diff --git a/mythtv/external/FFmpeg/libavcodec/g726.c b/mythtv/external/FFmpeg/libavcodec/g726.c
index ca7f856eacd..80cb0649128 100644
--- a/mythtv/external/FFmpeg/libavcodec/g726.c
+++ b/mythtv/external/FFmpeg/libavcodec/g726.c
@@ -269,7 +269,7 @@ static int16_t g726_decode(G726Context* c, int I)
         c->se += mult(i2f(c->a[i] >> 2, &f), &c->sr[i]);
     c->se >>= 1;
 
-    return av_clip(re_signal << 2, -0xffff, 0xffff);
+    return av_clip(re_signal * 4, -0xffff, 0xffff);
 }
 
 static av_cold int g726_reset(G726Context *c)
@@ -292,7 +292,7 @@ static av_cold int g726_reset(G726Context *c)
     return 0;
 }
 
-#if CONFIG_ADPCM_G726_ENCODER
+#if CONFIG_ADPCM_G726_ENCODER || CONFIG_ADPCM_G726LE_ENCODER
 static int16_t g726_encode(G726Context* c, int16_t sig)
 {
     uint8_t i;
@@ -308,6 +308,8 @@ static av_cold int g726_encode_init(AVCodecContext *avctx)
 {
     G726Context* c = avctx->priv_data;
 
+    c->little_endian = !strcmp(avctx->codec->name, "g726le");
+
     if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL &&
         avctx->sample_rate != 8000) {
         av_log(avctx, AV_LOG_ERROR, "Sample rates other than 8kHz are not "
@@ -356,9 +358,17 @@ static int g726_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     init_put_bits(&pb, avpkt->data, avpkt->size);
 
     for (i = 0; i < frame->nb_samples; i++)
-        put_bits(&pb, c->code_size, g726_encode(c, *samples++));
-
-    flush_put_bits(&pb);
+        if (c->little_endian) {
+            put_bits_le(&pb, c->code_size, g726_encode(c, *samples++));
+        } else {
+            put_bits(&pb, c->code_size, g726_encode(c, *samples++));
+        }
+
+    if (c->little_endian) {
+        flush_put_bits_le(&pb);
+    } else {
+        flush_put_bits(&pb);
+    }
 
     avpkt->size = out_size;
     *got_packet_ptr = 1;
@@ -372,6 +382,13 @@ static const AVOption options[] = {
     { NULL },
 };
 
+static const AVCodecDefault defaults[] = {
+    { "b", "0" },
+    { NULL },
+};
+#endif
+
+#if CONFIG_ADPCM_G726_ENCODER
 static const AVClass g726_class = {
     .class_name = "g726",
     .item_name  = av_default_item_name,
@@ -379,11 +396,6 @@ static const AVClass g726_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-static const AVCodecDefault defaults[] = {
-    { "b", "0" },
-    { NULL },
-};
-
 AVCodec ff_adpcm_g726_encoder = {
     .name           = "g726",
     .long_name      = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
@@ -400,6 +412,30 @@ AVCodec ff_adpcm_g726_encoder = {
 };
 #endif
 
+#if CONFIG_ADPCM_G726LE_ENCODER
+static const AVClass g726le_class = {
+    .class_name = "g726le",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVCodec ff_adpcm_g726le_encoder = {
+    .name           = "g726le",
+    .long_name      = NULL_IF_CONFIG_SMALL("G.726 little endian ADPCM (\"right-justified\")"),
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = AV_CODEC_ID_ADPCM_G726LE,
+    .priv_data_size = sizeof(G726Context),
+    .init           = g726_encode_init,
+    .encode2        = g726_encode_frame,
+    .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME,
+    .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
+                                                     AV_SAMPLE_FMT_NONE },
+    .priv_class     = &g726le_class,
+    .defaults       = defaults,
+};
+#endif
+
 #if CONFIG_ADPCM_G726_DECODER || CONFIG_ADPCM_G726LE_DECODER
 static av_cold int g726_decode_init(AVCodecContext *avctx)
 {
diff --git a/mythtv/external/FFmpeg/libavcodec/gdv.c b/mythtv/external/FFmpeg/libavcodec/gdv.c
new file mode 100644
index 00000000000..dc91869edf9
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/gdv.c
@@ -0,0 +1,515 @@
+/*
+ * Gremlin Digital Video (GDV) decoder
+ * Copyright (c) 2017 Konstantin Shishkov
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/common.h"
+#include "avcodec.h"
+#include "bytestream.h"
+#include "internal.h"
+
+typedef struct GDVContext {
+    AVCodecContext *avctx;
+
+    GetByteContext gb;
+    GetByteContext g2;
+    PutByteContext pb;
+
+    uint32_t pal[256];
+    uint8_t *frame;
+    unsigned frame_size;
+    unsigned scale_h, scale_v;
+} GDVContext;
+
+typedef struct Bits8 {
+    uint8_t queue;
+    uint8_t fill;
+} Bits8;
+
+typedef struct Bits32 {
+    uint32_t queue;
+    uint8_t  fill;
+} Bits32;
+
+#define PREAMBLE_SIZE 4096
+
+static av_cold int gdv_decode_init(AVCodecContext *avctx)
+{
+    GDVContext *gdv = avctx->priv_data;
+    int i, j, k;
+
+    avctx->pix_fmt  = AV_PIX_FMT_PAL8;
+    gdv->frame_size = avctx->width * avctx->height + PREAMBLE_SIZE;
+    gdv->frame = av_calloc(gdv->frame_size, 1);
+    if (!gdv->frame)
+        return AVERROR(ENOMEM);
+
+    for (i = 0; i < 2; i++) {
+        for (j = 0; j < 256; j++) {
+            for (k = 0; k < 8; k++) {
+                gdv->frame[i * 2048 + j * 8 + k] = j;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static void rescale(GDVContext *gdv, uint8_t *dst, int w, int h, int scale_v, int scale_h)
+{
+    int i, j, y, x;
+
+    if ((gdv->scale_v == scale_v) && (gdv->scale_h == scale_h)) {
+        return;
+    }
+
+    if (gdv->scale_h && gdv->scale_v) {
+        for (j = 0; j < h; j++) {
+            int y = h - j - 1;
+            for (i = 0; i < w; i++) {
+                int x = w - i - 1;
+                dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x/2 + (y/2) * (w/2)];
+            }
+        }
+    } else if (gdv->scale_h) {
+        for (j = 0; j < h; j++) {
+            int y = h - j - 1;
+            for (x = 0; x < w; x++) {
+                dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x + (y/2) * w];
+            }
+        }
+    } else if (gdv->scale_v) {
+        for (j = 0; j < h; j++) {
+            int y = h - j - 1;
+            for (i = 0; i < w; i++) {
+                int x = w - i - 1;
+                dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x/2 + y * (w/2)];
+            }
+        }
+    }
+
+    if (scale_h && scale_v) {
+        for (y = 0; y < h/2; y++) {
+            for (x = 0; x < w/2; x++) {
+                dst[PREAMBLE_SIZE + x + y * (w/2)] = dst[PREAMBLE_SIZE + x*2 + y*2 * w];
+            }
+        }
+    } else if (scale_h) {
+        for (y = 0; y < h/2; y++) {
+            for (x = 0; x < w; x++) {
+                dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x + y*2 * w];
+            }
+        }
+    } else if (scale_v) {
+        for (y = 0; y < h; y++) {
+            for (x = 0; x < w/2; x++) {
+                dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x*2 + y * w];
+            }
+        }
+    }
+
+    gdv->scale_v = scale_v;
+    gdv->scale_h = scale_h;
+}
+
+static int read_bits2(Bits8 *bits, GetByteContext *gb)
+{
+    int res;
+
+    if (bits->fill == 0) {
+        bits->queue |= bytestream2_get_byte(gb);
+        bits->fill   = 8;
+    }
+    res = bits->queue >> 6;
+    bits->queue <<= 2;
+    bits->fill   -= 2;
+
+    return res;
+}
+
+static void fill_bits32(Bits32 *bits, GetByteContext *gb)
+{
+    bits->queue = bytestream2_get_le32(gb);
+    bits->fill  = 32;
+}
+
+static int read_bits32(Bits32 *bits, GetByteContext *gb, int nbits)
+{
+    int res = bits->queue & ((1 << nbits) - 1);
+
+    bits->queue >>= nbits;
+    bits->fill   -= nbits;
+    if (bits->fill <= 16) {
+        bits->queue |= bytestream2_get_le16(gb) << bits->fill;
+        bits->fill  += 16;
+    }
+
+    return res;
+}
+
+static void lz_copy(PutByteContext *pb, GetByteContext *g2, int offset, unsigned len)
+{
+    int i;
+
+    if (offset == -1) {
+        int c;
+
+        bytestream2_seek(g2, bytestream2_tell_p(pb) - 1, SEEK_SET);
+        c = bytestream2_get_byte(g2);
+        for (i = 0; i < len; i++) {
+            bytestream2_put_byte(pb, c);
+        }
+    } else if (offset < 0) {
+        int start = bytestream2_tell_p(pb) - (-offset);
+
+        bytestream2_seek(g2, start, SEEK_SET);
+        for (i = 0; i < len; i++) {
+            bytestream2_put_byte(pb, bytestream2_get_byte(g2));
+        }
+    } else {
+        int start = bytestream2_tell_p(pb) + offset;
+
+        bytestream2_seek(g2, start, SEEK_SET);
+        for (i = 0; i < len; i++) {
+            bytestream2_put_byte(pb, bytestream2_get_byte(g2));
+        }
+    }
+}
+
+static int decompress_2(AVCodecContext *avctx)
+{
+    GDVContext *gdv = avctx->priv_data;
+    GetByteContext *gb = &gdv->gb;
+    GetByteContext *g2 = &gdv->g2;
+    PutByteContext *pb = &gdv->pb;
+    Bits8 bits = { 0 };
+    int c, i;
+
+    bytestream2_init(g2, gdv->frame, gdv->frame_size);
+    bytestream2_skip_p(pb, PREAMBLE_SIZE);
+
+    for (c = 0; c < 256; c++) {
+        for (i = 0; i < 16; i++) {
+            gdv->frame[c * 16 + i] = c;
+        }
+    }
+
+    while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
+        int tag = read_bits2(&bits, gb);
+        if (tag == 0) {
+            bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+        } else if (tag == 1) {
+            int b = bytestream2_get_byte(gb);
+            int len = (b & 0xF) + 3;
+            int top = (b >> 4) & 0xF;
+            int off = (bytestream2_get_byte(gb) << 4) + top - 4096;
+            lz_copy(pb, g2, off, len);
+        } else if (tag == 2) {
+            int len = (bytestream2_get_byte(gb)) + 2;
+            bytestream2_skip_p(pb, len);
+        } else {
+            break;
+        }
+    }
+    return 0;
+}
+
+static int decompress_5(AVCodecContext *avctx, unsigned skip)
+{
+    GDVContext *gdv = avctx->priv_data;
+    GetByteContext *gb = &gdv->gb;
+    GetByteContext *g2 = &gdv->g2;
+    PutByteContext *pb = &gdv->pb;
+    Bits8 bits = { 0 };
+
+    bytestream2_init(g2, gdv->frame, gdv->frame_size);
+    bytestream2_skip_p(pb, skip + PREAMBLE_SIZE);
+
+    while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
+        int tag = read_bits2(&bits, gb);
+        if (tag == 0) {
+            bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+        } else if (tag == 1) {
+            int b = bytestream2_get_byte(gb);
+            int len = (b & 0xF) + 3;
+            int top = b >> 4;
+            int off = (bytestream2_get_byte(gb) << 4) + top - 4096;
+            lz_copy(pb, g2, off, len);
+        } else if (tag == 2) {
+            int len;
+            int b = bytestream2_get_byte(gb);
+            if (b == 0) {
+                break;
+            }
+            if (b != 0xFF) {
+                len = b;
+            } else {
+                len = bytestream2_get_le16(gb);
+            }
+            bytestream2_skip_p(pb, len + 1);
+        } else {
+            int b = bytestream2_get_byte(gb);
+            int len = (b & 0x3) + 2;
+            int off = -(b >> 2) - 1;
+            lz_copy(pb, g2, off, len);
+        }
+    }
+    return 0;
+}
+
+static int decompress_68(AVCodecContext *avctx, unsigned skip, unsigned use8)
+{
+    GDVContext *gdv = avctx->priv_data;
+    GetByteContext *gb = &gdv->gb;
+    GetByteContext *g2 = &gdv->g2;
+    PutByteContext *pb = &gdv->pb;
+    Bits32 bits;
+
+    bytestream2_init(g2, gdv->frame, gdv->frame_size);
+    bytestream2_skip_p(pb, skip + PREAMBLE_SIZE);
+    fill_bits32(&bits, gb);
+
+    while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
+        int tag = read_bits32(&bits, gb, 2);
+        if (tag == 0) {
+            int b = read_bits32(&bits, gb, 1);
+            if (b == 0) {
+                bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+            } else {
+                int i, len = 2;
+                int lbits = 0;
+                while (1) {
+                    int val;
+
+                    lbits += 1;
+                    val = read_bits32(&bits, gb, lbits);
+                    len += val;
+                    if (val != ((1 << lbits) - 1)) {
+                        break;
+                    }
+                    assert(lbits < 16);
+                }
+                for (i = 0; i < len; i++) {
+                    bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                }
+            }
+        } else if (tag == 1) {
+            int b = read_bits32(&bits, gb, 1);
+            int len;
+
+            if (b == 0) {
+                len = (read_bits32(&bits, gb, 4)) + 2;
+            } else {
+                int bb = bytestream2_get_byte(gb);
+                if ((bb & 0x80) == 0) {
+                    len = bb + 18;
+                } else {
+                    int top = (bb & 0x7F) << 8;
+                    len = top + bytestream2_get_byte(gb) + 146;
+                }
+            }
+            bytestream2_skip_p(pb, len);
+        } else if (tag == 2) {
+            int i, subtag = read_bits32(&bits, gb, 2);
+
+            if (subtag != 3) {
+                int top = (read_bits32(&bits, gb, 4)) << 8;
+                int offs = top + bytestream2_get_byte(gb);
+                if ((subtag != 0) || (offs <= 0xF80)) {
+                    int len = (subtag) + 3;
+                    lz_copy(pb, g2, (offs) - 4096, len);
+                } else {
+                    int real_off, len, c1, c2;
+
+                    if (offs == 0xFFF) {
+                        return 0;
+                    }
+
+                    real_off = ((offs >> 4) & 0x7) + 1;
+                    len = ((offs & 0xF) + 2) * 2;
+                    c1 = gdv->frame[bytestream2_tell_p(pb) - real_off];
+                    c2 = gdv->frame[bytestream2_tell_p(pb) - real_off + 1];
+                    for (i = 0; i < len/2; i++) {
+                        bytestream2_put_byte(pb, c1);
+                        bytestream2_put_byte(pb, c2);
+                    }
+                }
+            } else {
+                int b = bytestream2_get_byte(gb);
+                int off = ((b & 0x7F)) + 1;
+                int len = ((b & 0x80) == 0) ? 2 : 3;
+
+                lz_copy(pb, g2, -off, len);
+            }
+        } else {
+            int len;
+            int off;
+            if (use8) {
+                int q, b = bytestream2_get_byte(gb);
+                if ((b & 0xC0) == 0xC0) {
+                    len = ((b & 0x3F)) + 8;
+                    q = read_bits32(&bits, gb, 4);
+                    off = (q << 8) + (bytestream2_get_byte(gb)) + 1;
+                } else {
+                    int ofs1;
+                    if ((b & 0x80) == 0) {
+                        len = ((b >> 4)) + 6;
+                        ofs1 = (b & 0xF);
+                    } else {
+                        len = ((b & 0x3F)) + 14;
+                        ofs1 = read_bits32(&bits, gb, 4);
+                    }
+                    off = (ofs1 << 8) + (bytestream2_get_byte(gb)) - 4096;
+                }
+            } else {
+                int ofs1, b = bytestream2_get_byte(gb);
+
+                if ((b >> 4) == 0xF) {
+                    len = bytestream2_get_byte(gb) + 21;
+                } else {
+                    len = (b >> 4) + 6;
+                }
+                ofs1 = (b & 0xF);
+                off = (ofs1 << 8) + bytestream2_get_byte(gb) - 4096;
+            }
+            lz_copy(pb, g2, off, len);
+        }
+    }
+
+    return 0;
+}
+
+static int gdv_decode_frame(AVCodecContext *avctx, void *data,
+                            int *got_frame, AVPacket *avpkt)
+{
+    GDVContext *gdv = avctx->priv_data;
+    GetByteContext *gb = &gdv->gb;
+    PutByteContext *pb = &gdv->pb;
+    AVFrame *frame = data;
+    int ret, i, pal_size;
+    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &pal_size);
+    int compression;
+    unsigned flags;
+    uint8_t *dst;
+
+    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
+        return ret;
+    if (pal && pal_size == AVPALETTE_SIZE)
+        memcpy(gdv->pal, pal, AVPALETTE_SIZE);
+
+    bytestream2_init(gb, avpkt->data, avpkt->size);
+    bytestream2_init_writer(pb, gdv->frame, gdv->frame_size);
+
+    flags = bytestream2_get_le32(gb);
+    compression = flags & 0xF;
+
+    rescale(gdv, gdv->frame, avctx->width, avctx->height,
+            !!(flags & 0x10), !!(flags & 0x20));
+
+    switch (compression) {
+    case 1:
+        memset(gdv->frame + PREAMBLE_SIZE, 0, gdv->frame_size - PREAMBLE_SIZE);
+    case 0:
+        if (bytestream2_get_bytes_left(gb) < 256*3)
+            return AVERROR_INVALIDDATA;
+        for (i = 0; i < 256; i++) {
+            unsigned r = bytestream2_get_byte(gb);
+            unsigned g = bytestream2_get_byte(gb);
+            unsigned b = bytestream2_get_byte(gb);
+            gdv->pal[i] = 0xFFU << 24 | r << 18 | g << 10 | b << 2;
+        }
+        break;
+    case 2:
+        ret = decompress_2(avctx);
+        break;
+    case 3:
+        break;
+    case 5:
+        ret = decompress_5(avctx, flags >> 8);
+        break;
+    case 6:
+        ret = decompress_68(avctx, flags >> 8, 0);
+        break;
+    case 8:
+        ret = decompress_68(avctx, flags >> 8, 1);
+        break;
+    default:
+        return AVERROR_INVALIDDATA;
+    }
+
+    memcpy(frame->data[1], gdv->pal, AVPALETTE_SIZE);
+    dst = frame->data[0];
+
+    if (!gdv->scale_v && !gdv->scale_h) {
+        int sidx = PREAMBLE_SIZE, didx = 0;
+        int y, x;
+
+        for (y = 0; y < avctx->height; y++) {
+            for (x = 0; x < avctx->width; x++) {
+                dst[x+didx] = gdv->frame[x+sidx];
+            }
+            sidx += avctx->width;
+            didx += frame->linesize[0];
+        }
+    } else {
+        int sidx = PREAMBLE_SIZE, didx = 0;
+        int y, x;
+
+        for (y = 0; y < avctx->height; y++) {
+            if (!gdv->scale_v) {
+                for (x = 0; x < avctx->width; x++) {
+                    dst[didx + x] = gdv->frame[sidx + x];
+                }
+            } else {
+                for (x = 0; x < avctx->width; x++) {
+                    dst[didx + x] = gdv->frame[sidx + x/2];
+                }
+            }
+            if (!gdv->scale_h || ((y & 1) == 1)) {
+                sidx += !gdv->scale_v ? avctx->width : avctx->width/2;
+            }
+            didx += frame->linesize[0];
+        }
+    }
+
+    *got_frame = 1;
+
+    return ret < 0 ? ret : avpkt->size;
+}
+
+static av_cold int gdv_decode_close(AVCodecContext *avctx)
+{
+    GDVContext *gdv = avctx->priv_data;
+    av_freep(&gdv->frame);
+    return 0;
+}
+
+AVCodec ff_gdv_decoder = {
+    .name           = "gdv",
+    .long_name      = NULL_IF_CONFIG_SMALL("Gremlin Digital Video"),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_GDV,
+    .priv_data_size = sizeof(GDVContext),
+    .init           = gdv_decode_init,
+    .close          = gdv_decode_close,
+    .decode         = gdv_decode_frame,
+    .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/get_bits.h b/mythtv/external/FFmpeg/libavcodec/get_bits.h
index 2259a38035a..816ed0b295d 100644
--- a/mythtv/external/FFmpeg/libavcodec/get_bits.h
+++ b/mythtv/external/FFmpeg/libavcodec/get_bits.h
@@ -233,6 +233,20 @@ static inline int get_xbits(GetBitContext *s, int n)
     return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
 }
 
+static inline int get_xbits_le(GetBitContext *s, int n)
+{
+    register int sign;
+    register int32_t cache;
+    OPEN_READER(re, s);
+    av_assert2(n>0 && n<=25);
+    UPDATE_CACHE_LE(re, s);
+    cache = GET_CACHE(re, s);
+    sign  = sign_extend(~cache, n) >> 31;
+    LAST_SKIP_BITS(re, s, n);
+    CLOSE_READER(re, s);
+    return (zero_extend(sign ^ cache, n) ^ sign) - sign;
+}
+
 static inline int get_sbits(GetBitContext *s, int n)
 {
     int tmp;
@@ -335,6 +349,7 @@ static inline void skip_bits1(GetBitContext *s)
  */
 static inline unsigned int get_bits_long(GetBitContext *s, int n)
 {
+    av_assert2(n>=0 && n<=32);
     if (!n) {
         return 0;
     } else if (n <= MIN_CACHE_BITS) {
@@ -373,6 +388,10 @@ static inline uint64_t get_bits64(GetBitContext *s, int n)
  */
 static inline int get_sbits_long(GetBitContext *s, int n)
 {
+    // sign_extend(x, 0) is undefined
+    if (!n)
+        return 0;
+
     return sign_extend(get_bits_long(s, n), n);
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/gifdec.c b/mythtv/external/FFmpeg/libavcodec/gifdec.c
index 48345db5459..2eeed4c4c70 100644
--- a/mythtv/external/FFmpeg/libavcodec/gifdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/gifdec.c
@@ -468,7 +468,7 @@ FF_DISABLE_DEPRECATION_WARNINGS
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
     s->frame->pkt_dts = avpkt->dts;
-    av_frame_set_pkt_duration(s->frame, avpkt->duration);
+    s->frame->pkt_duration = avpkt->duration;
 
     if (avpkt->size >= 6) {
         s->keyframe = memcmp(avpkt->data, gif87a_sig, 6) == 0 ||
diff --git a/mythtv/external/FFmpeg/libavcodec/golomb.h b/mythtv/external/FFmpeg/libavcodec/golomb.h
index 34b20612d75..49e15d7ca67 100644
--- a/mythtv/external/FFmpeg/libavcodec/golomb.h
+++ b/mythtv/external/FFmpeg/libavcodec/golomb.h
@@ -314,6 +314,8 @@ static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit,
 
     log = av_log2(buf);
 
+    av_assert2(k <= 31);
+
     if (log - k >= 32 - MIN_CACHE_BITS + (MIN_CACHE_BITS == 32) &&
         32 - log < limit) {
         buf >>= log - k;
@@ -326,7 +328,9 @@ static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit,
         int i;
         for (i = 0; i < limit && SHOW_UBITS(re, gb, 1) == 0; i++) {
             if (gb->size_in_bits <= (int)re_index)
+                CLOSE_READER(re, gb);
                 return -1;
+            }
             LAST_SKIP_BITS(re, gb, 1);
             UPDATE_CACHE(re, gb);
         }
@@ -348,16 +352,17 @@ static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit,
                 buf = 0;
             }
 
-            CLOSE_READER(re, gb);
-            return buf + (i << k);
+            buf += ((SUINT)i << k);
         } else if (i == limit - 1) {
             buf = SHOW_UBITS(re, gb, esc_len);
             LAST_SKIP_BITS(re, gb, esc_len);
-            CLOSE_READER(re, gb);
 
-            return buf + 1;
-        } else
-            return -1;
+            buf ++;
+        } else {
+            buf = -1;
+        }
+        CLOSE_READER(re, gb);
+        return buf;
     }
 }
 
@@ -445,19 +450,20 @@ static inline int get_te(GetBitContext *s, int r, char *file, const char *func,
     return i;
 }
 
-#define get_ue_golomb(a) get_ue(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#define get_se_golomb(a) get_se(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#define get_te_golomb(a, r)  get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#define get_te0_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
+#define get_ue_golomb(a) get_ue(a, __FILE__, __func__, __LINE__)
+#define get_se_golomb(a) get_se(a, __FILE__, __func__, __LINE__)
+#define get_te_golomb(a, r)  get_te(a, r, __FILE__, __func__, __LINE__)
+#define get_te0_golomb(a, r) get_te(a, r, __FILE__, __func__, __LINE__)
 
 #endif /* TRACE */
 
 /**
- * write unsigned exp golomb code.
+ * write unsigned exp golomb code. 2^16 - 2 at most
  */
 static inline void set_ue_golomb(PutBitContext *pb, int i)
 {
     av_assert2(i >= 0);
+    av_assert2(i <= 0xFFFE);
 
     if (i < 256)
         put_bits(pb, ff_ue_golomb_len[i], i + 1);
@@ -467,6 +473,21 @@ static inline void set_ue_golomb(PutBitContext *pb, int i)
     }
 }
 
+/**
+ * write unsigned exp golomb code. 2^32-2 at most.
+ */
+static inline void set_ue_golomb_long(PutBitContext *pb, uint32_t i)
+{
+    av_assert2(i <= (UINT32_MAX - 1));
+
+    if (i < 256)
+        put_bits(pb, ff_ue_golomb_len[i], i + 1);
+    else {
+        int e = av_log2(i + 1);
+        put_bits64(pb, 2 * e + 1, i + 1);
+    }
+}
+
 /**
  * write truncated unsigned exp golomb code.
  */
@@ -486,19 +507,9 @@ static inline void set_te_golomb(PutBitContext *pb, int i, int range)
  */
 static inline void set_se_golomb(PutBitContext *pb, int i)
 {
-#if 0
-    if (i <= 0)
-        i = -2 * i;
-    else
-        i = 2 * i - 1;
-#elif 1
     i = 2 * i - 1;
     if (i < 0)
         i ^= -1;    //FIXME check if gcc does the right thing
-#else
-    i  = 2 * i - 1;
-    i ^= (i >> 31);
-#endif
     set_ue_golomb(pb, i);
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/gsmdec_template.c b/mythtv/external/FFmpeg/libavcodec/gsmdec_template.c
index 9b3c0e9719b..4e40a20106a 100644
--- a/mythtv/external/FFmpeg/libavcodec/gsmdec_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/gsmdec_template.c
@@ -41,7 +41,7 @@ static void apcm_dequant_add(GetBitContext *gb, int16_t *dst, const int *frame_b
 
 static inline int gsm_mult(int a, int b)
 {
-    return (a * b + (1 << 14)) >> 15;
+    return (int)(a * (SUINT)b + (1 << 14)) >> 15;
 }
 
 static void long_term_synth(int16_t *dst, int lag, int gain_idx)
diff --git a/mythtv/external/FFmpeg/libavcodec/h261dec.c b/mythtv/external/FFmpeg/libavcodec/h261dec.c
index 7f2fff8684e..14a874c45d7 100644
--- a/mythtv/external/FFmpeg/libavcodec/h261dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/h261dec.c
@@ -223,7 +223,7 @@ static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2)
             s->current_picture.motion_val[0][b_xy][1] = s->mv[0][0][1];
         }
 
-        ff_mpv_decode_mb(s, s->block);
+        ff_mpv_reconstruct_mb(s, s->block);
     }
 
     return 0;
@@ -466,7 +466,7 @@ static int h261_decode_mb(H261Context *h)
             s->block_last_index[i] = -1;
     }
 
-    ff_mpv_decode_mb(s, s->block);
+    ff_mpv_reconstruct_mb(s, s->block);
 
     return SLICE_OK;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/h263.c b/mythtv/external/FFmpeg/libavcodec/h263.c
index 0855ee790f2..bc5c0d599ff 100644
--- a/mythtv/external/FFmpeg/libavcodec/h263.c
+++ b/mythtv/external/FFmpeg/libavcodec/h263.c
@@ -141,8 +141,6 @@ void ff_h263_loop_filter(MpegEncContext * s){
     uint8_t *dest_cb= s->dest[1];
     uint8_t *dest_cr= s->dest[2];
 
-//    if(s->pict_type==AV_PICTURE_TYPE_B && !s->readable) return;
-
     /*
        Diag Top
        Left Center
diff --git a/mythtv/external/FFmpeg/libavcodec/h263dec.c b/mythtv/external/FFmpeg/libavcodec/h263dec.c
index d0da1d31c17..bcb2b08bb0f 100644
--- a/mythtv/external/FFmpeg/libavcodec/h263dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/h263dec.c
@@ -261,7 +261,7 @@ static int decode_slice(MpegEncContext *s)
             if (ret < 0) {
                 const int xy = s->mb_x + s->mb_y * s->mb_stride;
                 if (ret == SLICE_END) {
-                    ff_mpv_decode_mb(s, s->block);
+                    ff_mpv_reconstruct_mb(s, s->block);
                     if (s->loop_filter)
                         ff_h263_loop_filter(s);
 
@@ -294,7 +294,7 @@ static int decode_slice(MpegEncContext *s)
                 return AVERROR_INVALIDDATA;
             }
 
-            ff_mpv_decode_mb(s, s->block);
+            ff_mpv_reconstruct_mb(s, s->block);
             if (s->loop_filter)
                 ff_h263_loop_filter(s);
         }
@@ -600,7 +600,7 @@ int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
         return ret;
 
-    if (!s->divx_packed && !avctx->hwaccel)
+    if (!s->divx_packed)
         ff_thread_finish_setup(avctx);
 
 #if FF_API_CAP_VDPAU
@@ -713,7 +713,7 @@ int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     }
 
     if (slice_ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
-        return ret;
+        return slice_ret;
     else
         return get_consumed_bytes(s, buf_size);
 }
@@ -743,6 +743,7 @@ AVCodec ff_h263_decoder = {
     .decode         = ff_h263_decode_frame,
     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
                       AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY,
+    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .flush          = ff_mpeg_flush,
     .max_lowres     = 3,
     .pix_fmts       = ff_h263_hwaccel_pixfmt_list_420,
@@ -759,6 +760,7 @@ AVCodec ff_h263p_decoder = {
     .decode         = ff_h263_decode_frame,
     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
                       AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY,
+    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .flush          = ff_mpeg_flush,
     .max_lowres     = 3,
     .pix_fmts       = ff_h263_hwaccel_pixfmt_list_420,
diff --git a/mythtv/external/FFmpeg/libavcodec/h2645_parse.c b/mythtv/external/FFmpeg/libavcodec/h2645_parse.c
index c3961a5e90c..b0d9ff66f00 100644
--- a/mythtv/external/FFmpeg/libavcodec/h2645_parse.c
+++ b/mythtv/external/FFmpeg/libavcodec/h2645_parse.c
@@ -150,31 +150,31 @@ int ff_h2645_extract_rbsp(const uint8_t *src, int length,
 static const char *nal_unit_name(int nal_type)
 {
     switch(nal_type) {
-    case NAL_TRAIL_N    : return "TRAIL_N";
-    case NAL_TRAIL_R    : return "TRAIL_R";
-    case NAL_TSA_N      : return "TSA_N";
-    case NAL_TSA_R      : return "TSA_R";
-    case NAL_STSA_N     : return "STSA_N";
-    case NAL_STSA_R     : return "STSA_R";
-    case NAL_RADL_N     : return "RADL_N";
-    case NAL_RADL_R     : return "RADL_R";
-    case NAL_RASL_N     : return "RASL_N";
-    case NAL_RASL_R     : return "RASL_R";
-    case NAL_BLA_W_LP   : return "BLA_W_LP";
-    case NAL_BLA_W_RADL : return "BLA_W_RADL";
-    case NAL_BLA_N_LP   : return "BLA_N_LP";
-    case NAL_IDR_W_RADL : return "IDR_W_RADL";
-    case NAL_IDR_N_LP   : return "IDR_N_LP";
-    case NAL_CRA_NUT    : return "CRA_NUT";
-    case NAL_VPS        : return "VPS";
-    case NAL_SPS        : return "SPS";
-    case NAL_PPS        : return "PPS";
-    case NAL_AUD        : return "AUD";
-    case NAL_EOS_NUT    : return "EOS_NUT";
-    case NAL_EOB_NUT    : return "EOB_NUT";
-    case NAL_FD_NUT     : return "FD_NUT";
-    case NAL_SEI_PREFIX : return "SEI_PREFIX";
-    case NAL_SEI_SUFFIX : return "SEI_SUFFIX";
+    case HEVC_NAL_TRAIL_N    : return "TRAIL_N";
+    case HEVC_NAL_TRAIL_R    : return "TRAIL_R";
+    case HEVC_NAL_TSA_N      : return "TSA_N";
+    case HEVC_NAL_TSA_R      : return "TSA_R";
+    case HEVC_NAL_STSA_N     : return "STSA_N";
+    case HEVC_NAL_STSA_R     : return "STSA_R";
+    case HEVC_NAL_RADL_N     : return "RADL_N";
+    case HEVC_NAL_RADL_R     : return "RADL_R";
+    case HEVC_NAL_RASL_N     : return "RASL_N";
+    case HEVC_NAL_RASL_R     : return "RASL_R";
+    case HEVC_NAL_BLA_W_LP   : return "BLA_W_LP";
+    case HEVC_NAL_BLA_W_RADL : return "BLA_W_RADL";
+    case HEVC_NAL_BLA_N_LP   : return "BLA_N_LP";
+    case HEVC_NAL_IDR_W_RADL : return "IDR_W_RADL";
+    case HEVC_NAL_IDR_N_LP   : return "IDR_N_LP";
+    case HEVC_NAL_CRA_NUT    : return "CRA_NUT";
+    case HEVC_NAL_VPS        : return "VPS";
+    case HEVC_NAL_SPS        : return "SPS";
+    case HEVC_NAL_PPS        : return "PPS";
+    case HEVC_NAL_AUD        : return "AUD";
+    case HEVC_NAL_EOS_NUT    : return "EOS_NUT";
+    case HEVC_NAL_EOB_NUT    : return "EOB_NUT";
+    case HEVC_NAL_FD_NUT     : return "FD_NUT";
+    case HEVC_NAL_SEI_PREFIX : return "SEI_PREFIX";
+    case HEVC_NAL_SEI_SUFFIX : return "SEI_SUFFIX";
     default : return "?";
     }
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/h2645_parse.h b/mythtv/external/FFmpeg/libavcodec/h2645_parse.h
index 3a60f3fb9b7..5f3e17a0f25 100644
--- a/mythtv/external/FFmpeg/libavcodec/h2645_parse.h
+++ b/mythtv/external/FFmpeg/libavcodec/h2645_parse.h
@@ -104,7 +104,7 @@ static inline int get_nalsize(int nal_length_size, const uint8_t *buf,
         nalsize = ((unsigned)nalsize << 8) | buf[(*buf_index)++];
     if (nalsize <= 0 || nalsize > buf_size - *buf_index) {
         av_log(logctx, AV_LOG_ERROR,
-               "Invalid nal size %d\n", nalsize);
+               "Invalid NAL unit size (%d > %d).\n", nalsize, buf_size - *buf_index);
         return AVERROR_INVALIDDATA;
     }
     return nalsize;
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_cabac.c b/mythtv/external/FFmpeg/libavcodec/h264_cabac.c
index fe83425d131..345834645cb 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_cabac.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_cabac.c
@@ -43,7 +43,7 @@
 #include "mpegutils.h"
 
 #if ARCH_X86
-#include "x86/h264_i386.h"
+#include "x86/h264_cabac.c"
 #endif
 
 /* Cabac pre state table */
@@ -1725,7 +1725,7 @@ decode_cabac_residual_internal(const H264Context *h, H264SliceContext *sl,
                 ((type*)block)[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; \
             } \
         } else { \
-            int coeff_abs = 2; \
+            unsigned coeff_abs = 2; \
             ctx = coeff_abs_levelgt1_ctx[is_dc && chroma422][node_ctx] + abs_level_m1_ctx_base; \
             node_ctx = coeff_abs_level_transition[1][node_ctx]; \
 \
@@ -1743,7 +1743,7 @@ decode_cabac_residual_internal(const H264Context *h, H264SliceContext *sl,
                 while( j-- ) { \
                     coeff_abs += coeff_abs + get_cabac_bypass( CC ); \
                 } \
-                coeff_abs+= 14; \
+                coeff_abs+= 14U; \
             } \
 \
             if( is_dc ) { \
@@ -1916,8 +1916,8 @@ int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
     const SPS *sps = h->ps.sps;
     int mb_xy;
     int mb_type, partition_count, cbp = 0;
-    int dct8x8_allowed= h->ps.pps->transform_8x8_mode;
-    int decode_chroma = sps->chroma_format_idc == 1 || sps->chroma_format_idc == 2;
+    int dct8x8_allowed = h->ps.pps->transform_8x8_mode;
+    const int decode_chroma = sps->chroma_format_idc == 1 || sps->chroma_format_idc == 2;
     const int pixel_shift = h->pixel_shift;
 
     mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
@@ -2347,21 +2347,40 @@ int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
     if (CHROMA444(h) && IS_8x8DCT(mb_type)){
         int i;
         uint8_t *nnz_cache = sl->non_zero_count_cache;
-        for (i = 0; i < 2; i++){
-            if (sl->left_type[LEFT(i)] && !IS_8x8DCT(sl->left_type[LEFT(i)])) {
-                nnz_cache[3+8* 1 + 2*8*i]=
-                nnz_cache[3+8* 2 + 2*8*i]=
-                nnz_cache[3+8* 6 + 2*8*i]=
-                nnz_cache[3+8* 7 + 2*8*i]=
-                nnz_cache[3+8*11 + 2*8*i]=
-                nnz_cache[3+8*12 + 2*8*i]= IS_INTRA(mb_type) ? 64 : 0;
+        if (h->sei.unregistered.x264_build < 151U) {
+            for (i = 0; i < 2; i++){
+                if (sl->left_type[LEFT(i)] && !IS_8x8DCT(sl->left_type[LEFT(i)])) {
+                    nnz_cache[3+8* 1 + 2*8*i]=
+                    nnz_cache[3+8* 2 + 2*8*i]=
+                    nnz_cache[3+8* 6 + 2*8*i]=
+                    nnz_cache[3+8* 7 + 2*8*i]=
+                    nnz_cache[3+8*11 + 2*8*i]=
+                    nnz_cache[3+8*12 + 2*8*i]= IS_INTRA(mb_type) ? 64 : 0;
+                }
+            }
+            if (sl->top_type && !IS_8x8DCT(sl->top_type)){
+                uint32_t top_empty = !IS_INTRA(mb_type) ? 0 : 0x40404040;
+                AV_WN32A(&nnz_cache[4+8* 0], top_empty);
+                AV_WN32A(&nnz_cache[4+8* 5], top_empty);
+                AV_WN32A(&nnz_cache[4+8*10], top_empty);
+            }
+        } else {
+            for (i = 0; i < 2; i++){
+                if (sl->left_type[LEFT(i)] && !IS_8x8DCT(sl->left_type[LEFT(i)])) {
+                    nnz_cache[3+8* 1 + 2*8*i]=
+                    nnz_cache[3+8* 2 + 2*8*i]=
+                    nnz_cache[3+8* 6 + 2*8*i]=
+                    nnz_cache[3+8* 7 + 2*8*i]=
+                    nnz_cache[3+8*11 + 2*8*i]=
+                    nnz_cache[3+8*12 + 2*8*i]= !IS_INTRA_PCM(sl->left_type[LEFT(i)]) ? 0 : 64;
+                }
+            }
+            if (sl->top_type && !IS_8x8DCT(sl->top_type)){
+                uint32_t top_empty = !IS_INTRA_PCM(sl->top_type) ? 0 : 0x40404040;
+                AV_WN32A(&nnz_cache[4+8* 0], top_empty);
+                AV_WN32A(&nnz_cache[4+8* 5], top_empty);
+                AV_WN32A(&nnz_cache[4+8*10], top_empty);
             }
-        }
-        if (sl->top_type && !IS_8x8DCT(sl->top_type)){
-            uint32_t top_empty = !IS_INTRA(mb_type) ? 0 : 0x40404040;
-            AV_WN32A(&nnz_cache[4+8* 0], top_empty);
-            AV_WN32A(&nnz_cache[4+8* 5], top_empty);
-            AV_WN32A(&nnz_cache[4+8*10], top_empty);
         }
     }
     h->cur_pic.mb_type[mb_xy] = mb_type;
@@ -2370,14 +2389,6 @@ int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
         const uint8_t *scan, *scan8x8;
         const uint32_t *qmul;
 
-        if(IS_INTERLACED(mb_type)){
-            scan8x8 = sl->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
-            scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
-        }else{
-            scan8x8 = sl->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
-            scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
-        }
-
         // decode_cabac_mb_dqp
         if(get_cabac_noinline( &sl->cabac, &sl->cabac_state[60 + (sl->last_qscale_diff != 0)])){
             int val = 1;
@@ -2408,6 +2419,14 @@ int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
         }else
             sl->last_qscale_diff=0;
 
+        if(IS_INTERLACED(mb_type)){
+            scan8x8 = sl->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
+            scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
+        }else{
+            scan8x8 = sl->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
+            scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
+        }
+
         decode_cabac_luma_residual(h, sl, scan, scan8x8, pixel_shift, mb_type, cbp, 0);
         if (CHROMA444(h)) {
             decode_cabac_luma_residual(h, sl, scan, scan8x8, pixel_shift, mb_type, cbp, 1);
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_cavlc.c b/mythtv/external/FFmpeg/libavcodec/h264_cavlc.c
index 069b52129c7..187b1c64e26 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_cavlc.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_cavlc.c
@@ -248,19 +248,19 @@ static VLC chroma422_dc_coeff_token_vlc;
 static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2];
 static const int chroma422_dc_coeff_token_vlc_table_size = 8192;
 
-static VLC total_zeros_vlc[15];
+static VLC total_zeros_vlc[15+1];
 static VLC_TYPE total_zeros_vlc_tables[15][512][2];
 static const int total_zeros_vlc_tables_size = 512;
 
-static VLC chroma_dc_total_zeros_vlc[3];
+static VLC chroma_dc_total_zeros_vlc[3+1];
 static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
 static const int chroma_dc_total_zeros_vlc_tables_size = 8;
 
-static VLC chroma422_dc_total_zeros_vlc[7];
+static VLC chroma422_dc_total_zeros_vlc[7+1];
 static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2];
 static const int chroma422_dc_total_zeros_vlc_tables_size = 32;
 
-static VLC run_vlc[6];
+static VLC run_vlc[6+1];
 static VLC_TYPE run_vlc_tables[6][8][2];
 static const int run_vlc_tables_size = 8;
 
@@ -364,9 +364,9 @@ av_cold void ff_h264_decode_init_vlc(void){
         av_assert0(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
 
         for(i=0; i<3; i++){
-            chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
-            chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
-            init_vlc(&chroma_dc_total_zeros_vlc[i],
+            chroma_dc_total_zeros_vlc[i+1].table = chroma_dc_total_zeros_vlc_tables[i];
+            chroma_dc_total_zeros_vlc[i+1].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
+            init_vlc(&chroma_dc_total_zeros_vlc[i+1],
                      CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
                      &chroma_dc_total_zeros_len [i][0], 1, 1,
                      &chroma_dc_total_zeros_bits[i][0], 1, 1,
@@ -374,9 +374,9 @@ av_cold void ff_h264_decode_init_vlc(void){
         }
 
         for(i=0; i<7; i++){
-            chroma422_dc_total_zeros_vlc[i].table = chroma422_dc_total_zeros_vlc_tables[i];
-            chroma422_dc_total_zeros_vlc[i].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
-            init_vlc(&chroma422_dc_total_zeros_vlc[i],
+            chroma422_dc_total_zeros_vlc[i+1].table = chroma422_dc_total_zeros_vlc_tables[i];
+            chroma422_dc_total_zeros_vlc[i+1].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
+            init_vlc(&chroma422_dc_total_zeros_vlc[i+1],
                      CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
                      &chroma422_dc_total_zeros_len [i][0], 1, 1,
                      &chroma422_dc_total_zeros_bits[i][0], 1, 1,
@@ -384,9 +384,9 @@ av_cold void ff_h264_decode_init_vlc(void){
         }
 
         for(i=0; i<15; i++){
-            total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
-            total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
-            init_vlc(&total_zeros_vlc[i],
+            total_zeros_vlc[i+1].table = total_zeros_vlc_tables[i];
+            total_zeros_vlc[i+1].table_allocated = total_zeros_vlc_tables_size;
+            init_vlc(&total_zeros_vlc[i+1],
                      TOTAL_ZEROS_VLC_BITS, 16,
                      &total_zeros_len [i][0], 1, 1,
                      &total_zeros_bits[i][0], 1, 1,
@@ -394,9 +394,9 @@ av_cold void ff_h264_decode_init_vlc(void){
         }
 
         for(i=0; i<6; i++){
-            run_vlc[i].table = run_vlc_tables[i];
-            run_vlc[i].table_allocated = run_vlc_tables_size;
-            init_vlc(&run_vlc[i],
+            run_vlc[i+1].table = run_vlc_tables[i];
+            run_vlc[i+1].table_allocated = run_vlc_tables_size;
+            init_vlc(&run_vlc[i+1],
                      RUN_VLC_BITS, 7,
                      &run_len [i][0], 1, 1,
                      &run_bits[i][0], 1, 1,
@@ -570,13 +570,13 @@ static int decode_residual(const H264Context *h, H264SliceContext *sl,
     else{
         if (max_coeff <= 8) {
             if (max_coeff == 4)
-                zeros_left = get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[total_coeff].table,
+                zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff].table,
                                       CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
             else
-                zeros_left = get_vlc2(gb, (chroma422_dc_total_zeros_vlc-1)[total_coeff].table,
+                zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff].table,
                                       CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
         } else {
-            zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
+            zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
         }
     }
 
@@ -586,7 +586,7 @@ static int decode_residual(const H264Context *h, H264SliceContext *sl,
         ((type*)block)[*scantable] = level[0]; \
         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
             if(zeros_left < 7) \
-                run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
+                run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
             else \
                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
             zeros_left -= run_before; \
@@ -601,7 +601,7 @@ static int decode_residual(const H264Context *h, H264SliceContext *sl,
         ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
             if(zeros_left < 7) \
-                run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
+                run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
             else \
                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
             zeros_left -= run_before; \
@@ -704,8 +704,8 @@ int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
     int mb_xy;
     int partition_count;
     unsigned int mb_type, cbp;
-    int dct8x8_allowed= h->ps.pps->transform_8x8_mode;
-    int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
+    int dct8x8_allowed = h->ps.pps->transform_8x8_mode;
+    const int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
     const int pixel_shift = h->pixel_shift;
 
     mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
@@ -1102,17 +1102,9 @@ int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
         const uint8_t *scan, *scan8x8;
         const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
 
-        if(IS_INTERLACED(mb_type)){
-            scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
-            scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
-        }else{
-            scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
-            scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
-        }
-
         dquant= get_se_golomb(&sl->gb);
 
-        sl->qscale += dquant;
+        sl->qscale += (unsigned)dquant;
 
         if (((unsigned)sl->qscale) > max_qp){
             if (sl->qscale < 0) sl->qscale += max_qp + 1;
@@ -1126,6 +1118,14 @@ int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
         sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
         sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
 
+        if(IS_INTERLACED(mb_type)){
+            scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
+            scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
+        }else{
+            scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
+            scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
+        }
+
         if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
             return -1;
         }
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_direct.c b/mythtv/external/FFmpeg/libavcodec/h264_direct.c
index 107c905db12..a7a107c8c21 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_direct.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_direct.c
@@ -39,12 +39,22 @@ static int get_scale_factor(H264SliceContext *sl,
                             int poc, int poc1, int i)
 {
     int poc0 = sl->ref_list[0][i].poc;
-    int td = av_clip_int8(poc1 - poc0);
+    int64_t pocdiff = poc1 - (int64_t)poc0;
+    int td = av_clip_int8(pocdiff);
+
+    if (pocdiff != (int)pocdiff)
+        avpriv_request_sample(sl->h264->avctx, "pocdiff overflow\n");
+
     if (td == 0 || sl->ref_list[0][i].parent->long_ref) {
         return 256;
     } else {
-        int tb = av_clip_int8(poc - poc0);
+        int64_t pocdiff0 = poc - (int64_t)poc0;
+        int tb = av_clip_int8(pocdiff0);
         int tx = (16384 + (FFABS(td) >> 1)) / td;
+
+        if (pocdiff0 != (int)pocdiff0)
+            av_log(sl->h264->avctx, AV_LOG_DEBUG, "pocdiff0 overflow\n");
+
         return av_clip_intp2((tb * tx + 32) >> 6, 10);
     }
 }
@@ -128,7 +138,11 @@ void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *
         memcpy(cur->ref_poc[1],   cur->ref_poc[0],   sizeof(cur->ref_poc[0]));
     }
 
-    cur->mbaff = FRAME_MBAFF(h);
+    if (h->current_slice == 0) {
+        cur->mbaff = FRAME_MBAFF(h);
+    } else {
+        av_assert0(cur->mbaff == FRAME_MBAFF(h));
+    }
 
     sl->col_fieldoff = 0;
 
@@ -614,7 +628,7 @@ static void pred_temp_direct_motion(const H264Context *const h, H264SliceContext
 
                 {
                     const int16_t *mv_col = l1mv[x8 * 3 + y8 * b4_stride];
-                    int my_col            = (mv_col[1] << y_shift) / 2;
+                    int my_col            = (mv_col[1] * (1 << y_shift)) / 2;
                     int mx                = (scale * mv_col[0] + 128) >> 8;
                     int my                = (scale * my_col    + 128) >> 8;
                     fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8,
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_loopfilter.c b/mythtv/external/FFmpeg/libavcodec/h264_loopfilter.c
index 0b448823792..0924f32613f 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_loopfilter.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_loopfilter.c
@@ -527,7 +527,7 @@ static av_always_inline void filter_mb_dir(const H264Context *h, H264SliceContex
                 // Do not use s->qscale as luma quantizer because it has not the same
                 // value in IPCM macroblocks.
                 qp = (h->cur_pic.qscale_table[mb_xy] + h->cur_pic.qscale_table[mbn_xy] + 1) >> 1;
-                ff_tlog(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, tmp_linesize, tmp_uvlinesize);
+                ff_tlog(h->avctx, "filter mb:%d/%d dir:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, qp, tmp_linesize, tmp_uvlinesize);
                 { int i; for (i = 0; i < 4; i++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); }
                 filter_mb_edgeh( &img_y[j*linesize], tmp_linesize, bS, qp, a, b, h, 0 );
                 chroma_qp_avg[0] = (sl->chroma_qp[0] + get_chroma_qp(h->ps.pps, 0, h->cur_pic.qscale_table[mbn_xy]) + 1) >> 1;
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_mb.c b/mythtv/external/FFmpeg/libavcodec/h264_mb.c
index 638dcba2f96..cb9fe856b26 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_mb.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_mb.c
@@ -637,7 +637,7 @@ static av_always_inline void hl_decode_mb_predict_luma(const H264Context *h,
                 uint8_t *const ptr = dest_y + block_offset[i];
                 const int dir      = sl->intra4x4_pred_mode_cache[scan8[i]];
                 if (transform_bypass && h->ps.sps->profile_idc == 244 && dir <= 1) {
-                    if (h->sei.unregistered.x264_build != -1) {
+                    if (h->sei.unregistered.x264_build < 151U) {
                         h->hpc.pred8x8l_add[dir](ptr, sl->mb + (i * 16 + p * 256 << pixel_shift), linesize);
                     } else
                         h->hpc.pred8x8l_filter_add[dir](ptr, sl->mb + (i * 16 + p * 256 << pixel_shift),
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_mvpred.h b/mythtv/external/FFmpeg/libavcodec/h264_mvpred.h
index 24f250d7945..bf395e3fe29 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_mvpred.h
+++ b/mythtv/external/FFmpeg/libavcodec/h264_mvpred.h
@@ -68,7 +68,7 @@ static av_always_inline int fetch_diagonal_mv(const H264Context *h, H264SliceCon
             }
             if (MB_FIELD(sl) && !IS_INTERLACED(sl->left_type[0])) {
                 // left shift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's OK.
-                SET_DIAG_MV(/ 2, << 1, sl->left_mb_xy[i >= 36], ((i >> 2)) & 3);
+                SET_DIAG_MV(/ 2, *2, sl->left_mb_xy[i >= 36], ((i >> 2)) & 3);
             }
         }
 #undef SET_DIAG_MV
@@ -248,7 +248,7 @@ static av_always_inline void pred_8x16_motion(const H264Context *const h,
             if (IS_INTERLACED(type)) {          \
                 refn >>= 1;                     \
                 AV_COPY32(mvbuf[idx], mvn);     \
-                mvbuf[idx][1] <<= 1;            \
+                mvbuf[idx][1] *= 2;             \
                 mvn = mvbuf[idx];               \
             }                                   \
         }                                       \
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_parse.c b/mythtv/external/FFmpeg/libavcodec/h264_parse.c
index 0c873196dcf..a7c71d9bbbb 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_parse.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_parse.c
@@ -26,28 +26,30 @@
 
 int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
                               const int *ref_count, int slice_type_nos,
-                              H264PredWeightTable *pwt, void *logctx)
+                              H264PredWeightTable *pwt,
+                              int picture_structure, void *logctx)
 {
     int list, i, j;
     int luma_def, chroma_def;
 
     pwt->use_weight             = 0;
     pwt->use_weight_chroma      = 0;
-    pwt->luma_log2_weight_denom = get_ue_golomb(gb);
-    if (sps->chroma_format_idc)
-        pwt->chroma_log2_weight_denom = get_ue_golomb(gb);
 
+    pwt->luma_log2_weight_denom = get_ue_golomb(gb);
     if (pwt->luma_log2_weight_denom > 7U) {
         av_log(logctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is out of range\n", pwt->luma_log2_weight_denom);
         pwt->luma_log2_weight_denom = 0;
     }
-    if (pwt->chroma_log2_weight_denom > 7U) {
-        av_log(logctx, AV_LOG_ERROR, "chroma_log2_weight_denom %d is out of range\n", pwt->chroma_log2_weight_denom);
-        pwt->chroma_log2_weight_denom = 0;
-    }
+    luma_def = 1 << pwt->luma_log2_weight_denom;
 
-    luma_def   = 1 << pwt->luma_log2_weight_denom;
-    chroma_def = 1 << pwt->chroma_log2_weight_denom;
+    if (sps->chroma_format_idc) {
+        pwt->chroma_log2_weight_denom = get_ue_golomb(gb);
+        if (pwt->chroma_log2_weight_denom > 7U) {
+            av_log(logctx, AV_LOG_ERROR, "chroma_log2_weight_denom %d is out of range\n", pwt->chroma_log2_weight_denom);
+            pwt->chroma_log2_weight_denom = 0;
+        }
+        chroma_def = 1 << pwt->chroma_log2_weight_denom;
+    }
 
     for (list = 0; list < 2; list++) {
         pwt->luma_weight_flag[list]   = 0;
@@ -59,6 +61,9 @@ int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
             if (luma_weight_flag) {
                 pwt->luma_weight[i][list][0] = get_se_golomb(gb);
                 pwt->luma_weight[i][list][1] = get_se_golomb(gb);
+                if ((int8_t)pwt->luma_weight[i][list][0] != pwt->luma_weight[i][list][0] ||
+                    (int8_t)pwt->luma_weight[i][list][1] != pwt->luma_weight[i][list][1])
+                    goto out_range_weight;
                 if (pwt->luma_weight[i][list][0] != luma_def ||
                     pwt->luma_weight[i][list][1] != 0) {
                     pwt->use_weight             = 1;
@@ -76,6 +81,9 @@ int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
                     for (j = 0; j < 2; j++) {
                         pwt->chroma_weight[i][list][j][0] = get_se_golomb(gb);
                         pwt->chroma_weight[i][list][j][1] = get_se_golomb(gb);
+                        if ((int8_t)pwt->chroma_weight[i][list][j][0] != pwt->chroma_weight[i][list][j][0] ||
+                            (int8_t)pwt->chroma_weight[i][list][j][1] != pwt->chroma_weight[i][list][j][1])
+                            goto out_range_weight;
                         if (pwt->chroma_weight[i][list][j][0] != chroma_def ||
                             pwt->chroma_weight[i][list][j][1] != 0) {
                             pwt->use_weight_chroma        = 1;
@@ -92,11 +100,15 @@ int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
             }
 
             // for MBAFF
-            pwt->luma_weight[16 + 2 * i][list][0] = pwt->luma_weight[16 + 2 * i + 1][list][0] = pwt->luma_weight[i][list][0];
-            pwt->luma_weight[16 + 2 * i][list][1] = pwt->luma_weight[16 + 2 * i + 1][list][1] = pwt->luma_weight[i][list][1];
-            for (j = 0; j < 2; j++) {
-                pwt->chroma_weight[16 + 2 * i][list][j][0] = pwt->chroma_weight[16 + 2 * i + 1][list][j][0] = pwt->chroma_weight[i][list][j][0];
-                pwt->chroma_weight[16 + 2 * i][list][j][1] = pwt->chroma_weight[16 + 2 * i + 1][list][j][1] = pwt->chroma_weight[i][list][j][1];
+            if (picture_structure == PICT_FRAME) {
+                pwt->luma_weight[16 + 2 * i][list][0] = pwt->luma_weight[16 + 2 * i + 1][list][0] = pwt->luma_weight[i][list][0];
+                pwt->luma_weight[16 + 2 * i][list][1] = pwt->luma_weight[16 + 2 * i + 1][list][1] = pwt->luma_weight[i][list][1];
+                if (sps->chroma_format_idc) {
+                    for (j = 0; j < 2; j++) {
+                        pwt->chroma_weight[16 + 2 * i][list][j][0] = pwt->chroma_weight[16 + 2 * i + 1][list][j][0] = pwt->chroma_weight[i][list][j][0];
+                        pwt->chroma_weight[16 + 2 * i][list][j][1] = pwt->chroma_weight[16 + 2 * i + 1][list][j][1] = pwt->chroma_weight[i][list][j][1];
+                    }
+                }
             }
         }
         if (slice_type_nos != AV_PICTURE_TYPE_B)
@@ -104,6 +116,9 @@ int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
     }
     pwt->use_weight = pwt->use_weight || pwt->use_weight_chroma;
     return 0;
+out_range_weight:
+    avpriv_request_sample(logctx, "Out of range weight\n");
+    return AVERROR_INVALIDDATA;
 }
 
 /**
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_parse.h b/mythtv/external/FFmpeg/libavcodec/h264_parse.h
index 290da34d443..4d016201256 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_parse.h
+++ b/mythtv/external/FFmpeg/libavcodec/h264_parse.h
@@ -55,7 +55,8 @@ typedef struct H264POCContext {
 
 int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
                               const int *ref_count, int slice_type_nos,
-                              H264PredWeightTable *pwt, void *logctx);
+                              H264PredWeightTable *pwt,
+                              int picture_structure, void *logctx);
 
 /**
  * Check if the top & left blocks are available if needed & change the
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_parser.c b/mythtv/external/FFmpeg/libavcodec/h264_parser.c
index bca00717c4e..dd0a965af03 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_parser.c
@@ -202,7 +202,7 @@ static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb,
     if ((p->ps.pps->weighted_pred && slice_type_nos == AV_PICTURE_TYPE_P) ||
         (p->ps.pps->weighted_bipred_idc == 1 && slice_type_nos == AV_PICTURE_TYPE_B))
         ff_h264_pred_weight_table(gb, p->ps.sps, ref_count, slice_type_nos,
-                                  &pwt, logctx);
+                                  &pwt, p->picture_structure, logctx);
 
     if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag
         int i;
@@ -471,25 +471,25 @@ static inline int parse_nal_units(AVCodecParserContext *s,
                 }
             }
 
-            if (sps->pic_struct_present_flag) {
+            if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
                 switch (p->sei.picture_timing.pic_struct) {
-                case SEI_PIC_STRUCT_TOP_FIELD:
-                case SEI_PIC_STRUCT_BOTTOM_FIELD:
+                case H264_SEI_PIC_STRUCT_TOP_FIELD:
+                case H264_SEI_PIC_STRUCT_BOTTOM_FIELD:
                     s->repeat_pict = 0;
                     break;
-                case SEI_PIC_STRUCT_FRAME:
-                case SEI_PIC_STRUCT_TOP_BOTTOM:
-                case SEI_PIC_STRUCT_BOTTOM_TOP:
+                case H264_SEI_PIC_STRUCT_FRAME:
+                case H264_SEI_PIC_STRUCT_TOP_BOTTOM:
+                case H264_SEI_PIC_STRUCT_BOTTOM_TOP:
                     s->repeat_pict = 1;
                     break;
-                case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
-                case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
+                case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
+                case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
                     s->repeat_pict = 2;
                     break;
-                case SEI_PIC_STRUCT_FRAME_DOUBLING:
+                case H264_SEI_PIC_STRUCT_FRAME_DOUBLING:
                     s->repeat_pict = 3;
                     break;
-                case SEI_PIC_STRUCT_FRAME_TRIPLING:
+                case H264_SEI_PIC_STRUCT_FRAME_TRIPLING:
                     s->repeat_pict = 5;
                     break;
                 default:
@@ -502,14 +502,14 @@ static inline int parse_nal_units(AVCodecParserContext *s,
 
             if (p->picture_structure == PICT_FRAME) {
                 s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;
-                if (sps->pic_struct_present_flag) {
+                if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
                     switch (p->sei.picture_timing.pic_struct) {
-                    case SEI_PIC_STRUCT_TOP_BOTTOM:
-                    case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
+                    case H264_SEI_PIC_STRUCT_TOP_BOTTOM:
+                    case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
                         s->field_order = AV_FIELD_TT;
                         break;
-                    case SEI_PIC_STRUCT_BOTTOM_TOP:
-                    case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
+                    case H264_SEI_PIC_STRUCT_BOTTOM_TOP:
+                    case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
                         s->field_order = AV_FIELD_BB;
                         break;
                     default:
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_picture.c b/mythtv/external/FFmpeg/libavcodec/h264_picture.c
index f634d2a1a70..99d9f9075c4 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_picture.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_picture.c
@@ -70,8 +70,8 @@ int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)
 
     av_assert0(!dst->f->buf[0]);
     av_assert0(src->f->buf[0]);
+    av_assert0(src->tf.f == src->f);
 
-    src->tf.f = src->f;
     dst->tf.f = dst->f;
     ret = ff_thread_ref_frame(&dst->tf, &src->tf);
     if (ret < 0)
@@ -109,14 +109,10 @@ int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)
     dst->poc           = src->poc;
     dst->frame_num     = src->frame_num;
     dst->mmco_reset    = src->mmco_reset;
-    dst->pic_id        = src->pic_id;
     dst->long_ref      = src->long_ref;
     dst->mbaff         = src->mbaff;
     dst->field_picture = src->field_picture;
     dst->reference     = src->reference;
-    dst->crop          = src->crop;
-    dst->crop_left     = src->crop_left;
-    dst->crop_top      = src->crop_top;
     dst->recovered     = src->recovered;
     dst->invalid_gap   = src->invalid_gap;
     dst->sei_recovery_frame_cnt = src->sei_recovery_frame_cnt;
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_ps.c b/mythtv/external/FFmpeg/libavcodec/h264_ps.c
index 4a5f66e184f..b7d5f65d326 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_ps.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_ps.c
@@ -168,11 +168,13 @@ static inline int decode_vui_parameters(GetBitContext *gb, AVCodecContext *avctx
             sps->color_primaries = get_bits(gb, 8); /* colour_primaries */
             sps->color_trc       = get_bits(gb, 8); /* transfer_characteristics */
             sps->colorspace      = get_bits(gb, 8); /* matrix_coefficients */
-            if (sps->color_primaries >= AVCOL_PRI_NB)
+
+            // Set invalid values to "unspecified"
+            if (!av_color_primaries_name(sps->color_primaries))
                 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
-            if (sps->color_trc >= AVCOL_TRC_NB)
+            if (!av_color_transfer_name(sps->color_trc))
                 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
-            if (sps->colorspace >= AVCOL_SPC_NB)
+            if (!av_color_space_name(sps->colorspace))
                 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
         }
     }
@@ -247,7 +249,7 @@ static inline int decode_vui_parameters(GetBitContext *gb, AVCodecContext *avctx
     return 0;
 }
 
-static void decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size,
+static int decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size,
                                 const uint8_t *jvt_list,
                                 const uint8_t *fallback_list)
 {
@@ -257,14 +259,21 @@ static void decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size,
         memcpy(factors, fallback_list, size * sizeof(uint8_t));
     else
         for (i = 0; i < size; i++) {
-            if (next)
-                next = (last + get_se_golomb(gb)) & 0xff;
+            if (next) {
+                int v = get_se_golomb(gb);
+                if (v < -128 || v > 127) {
+                    av_log(NULL, AV_LOG_ERROR, "delta scale %d is invalid\n", v);
+                    return AVERROR_INVALIDDATA;
+                }
+                next = (last + v) & 0xff;
+            }
             if (!i && !next) { /* matrix not written, we use the preset one */
                 memcpy(factors, jvt_list, size * sizeof(uint8_t));
                 break;
             }
             last = factors[scan[i]] = next ? next : last;
         }
+    return 0;
 }
 
 /* returns non zero if the provided SPS scaling matrix has been filled */
@@ -282,23 +291,24 @@ static int decode_scaling_matrices(GetBitContext *gb, const SPS *sps,
     };
     int ret = 0;
     if (get_bits1(gb)) {
-        ret = is_sps;
-        decode_scaling_list(gb, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
-        decode_scaling_list(gb, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
-        decode_scaling_list(gb, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
-        decode_scaling_list(gb, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
-        decode_scaling_list(gb, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
-        decode_scaling_list(gb, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
+        ret |= decode_scaling_list(gb, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
+        ret |= decode_scaling_list(gb, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
+        ret |= decode_scaling_list(gb, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
+        ret |= decode_scaling_list(gb, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
+        ret |= decode_scaling_list(gb, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
+        ret |= decode_scaling_list(gb, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
         if (is_sps || pps->transform_8x8_mode) {
-            decode_scaling_list(gb, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
-            decode_scaling_list(gb, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
+            ret |= decode_scaling_list(gb, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
+            ret |= decode_scaling_list(gb, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
             if (sps->chroma_format_idc == 3) {
-                decode_scaling_list(gb, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
-                decode_scaling_list(gb, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
-                decode_scaling_list(gb, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
-                decode_scaling_list(gb, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
+                ret |= decode_scaling_list(gb, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
+                ret |= decode_scaling_list(gb, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
+                ret |= decode_scaling_list(gb, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
+                ret |= decode_scaling_list(gb, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
             }
         }
+        if (!ret)
+            ret = is_sps;
     }
 
     return ret;
@@ -329,6 +339,7 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
     unsigned int sps_id;
     int i, log2_max_frame_num_minus4;
     SPS *sps;
+    int ret;
 
     sps_buf = av_buffer_allocz(sizeof(*sps));
     if (!sps_buf)
@@ -407,8 +418,11 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
             goto fail;
         }
         sps->transform_bypass = get_bits1(gb);
-        sps->scaling_matrix_present |= decode_scaling_matrices(gb, sps, NULL, 1,
-                                sps->scaling_matrix4, sps->scaling_matrix8);
+        ret = decode_scaling_matrices(gb, sps, NULL, 1,
+                                      sps->scaling_matrix4, sps->scaling_matrix8);
+        if (ret < 0)
+            goto fail;
+        sps->scaling_matrix_present |= ret;
     } else {
         sps->chroma_format_idc = 1;
         sps->bit_depth_luma    = 8;
@@ -467,15 +481,22 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
     sps->mb_height                      = get_ue_golomb(gb) + 1;
 
     sps->frame_mbs_only_flag = get_bits1(gb);
+
+    if (sps->mb_height >= INT_MAX / 2U) {
+        av_log(avctx, AV_LOG_ERROR, "height overflow\n");
+        goto fail;
+    }
+    sps->mb_height *= 2 - sps->frame_mbs_only_flag;
+
     if (!sps->frame_mbs_only_flag)
         sps->mb_aff = get_bits1(gb);
     else
         sps->mb_aff = 0;
 
     if ((unsigned)sps->mb_width  >= INT_MAX / 16 ||
-        (unsigned)sps->mb_height >= INT_MAX / (16 * (2 - sps->frame_mbs_only_flag)) ||
+        (unsigned)sps->mb_height >= INT_MAX / 16 ||
         av_image_check_size(16 * sps->mb_width,
-                            16 * sps->mb_height * (2 - sps->frame_mbs_only_flag), 0, avctx)) {
+                            16 * sps->mb_height, 0, avctx)) {
         av_log(avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
         goto fail;
     }
@@ -494,7 +515,7 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
         unsigned int crop_top    = get_ue_golomb(gb);
         unsigned int crop_bottom = get_ue_golomb(gb);
         int width  = 16 * sps->mb_width;
-        int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
+        int height = 16 * sps->mb_height;
 
         if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
             av_log(avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
@@ -512,15 +533,6 @@ int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
             int step_x = 1 << hsub;
             int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
 
-            if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
-                !(avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
-                crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
-                av_log(avctx, AV_LOG_WARNING,
-                       "Reducing left cropping to %d "
-                       "chroma samples to preserve alignment.\n",
-                       crop_left);
-            }
-
             if (crop_left  > (unsigned)INT_MAX / 4 / step_x ||
                 crop_right > (unsigned)INT_MAX / 4 / step_x ||
                 crop_top   > (unsigned)INT_MAX / 4 / step_y ||
@@ -755,8 +767,8 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avct
         ret = AVERROR_INVALIDDATA;
         goto fail;
     } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Unimplemented luma bit depth=%d\n",
+        avpriv_report_missing_feature(avctx,
+               "Unimplemented luma bit depth=%d",
                sps->bit_depth_luma);
         ret = AVERROR_PATCHWELCOME;
         goto fail;
@@ -768,37 +780,6 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avct
     if (pps->slice_group_count > 1) {
         pps->mb_slice_group_map_type = get_ue_golomb(gb);
         av_log(avctx, AV_LOG_ERROR, "FMO not supported\n");
-        switch (pps->mb_slice_group_map_type) {
-        case 0:
-#if 0
-    |       for (i = 0; i <= num_slice_groups_minus1; i++)  |   |      |
-    |           run_length[i]                               |1  |ue(v) |
-#endif
-            break;
-        case 2:
-#if 0
-    |       for (i = 0; i < num_slice_groups_minus1; i++) { |   |      |
-    |           top_left_mb[i]                              |1  |ue(v) |
-    |           bottom_right_mb[i]                          |1  |ue(v) |
-    |       }                                               |   |      |
-#endif
-            break;
-        case 3:
-        case 4:
-        case 5:
-#if 0
-    |       slice_group_change_direction_flag               |1  |u(1)  |
-    |       slice_group_change_rate_minus1                  |1  |ue(v) |
-#endif
-            break;
-        case 6:
-#if 0
-    |       slice_group_id_cnt_minus1                       |1  |ue(v) |
-    |       for (i = 0; i <= slice_group_id_cnt_minus1; i++)|   |      |
-    |           slice_group_id[i]                           |1  |u(v)  |
-#endif
-            break;
-        }
     }
     pps->ref_count[0] = get_ue_golomb(gb) + 1;
     pps->ref_count[1] = get_ue_golomb(gb) + 1;
@@ -812,9 +793,14 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avct
 
     pps->weighted_pred                        = get_bits1(gb);
     pps->weighted_bipred_idc                  = get_bits(gb, 2);
-    pps->init_qp                              = get_se_golomb(gb) + 26 + qp_bd_offset;
-    pps->init_qs                              = get_se_golomb(gb) + 26 + qp_bd_offset;
+    pps->init_qp                              = get_se_golomb(gb) + 26U + qp_bd_offset;
+    pps->init_qs                              = get_se_golomb(gb) + 26U + qp_bd_offset;
     pps->chroma_qp_index_offset[0]            = get_se_golomb(gb);
+    if (pps->chroma_qp_index_offset[0] < -12 || pps->chroma_qp_index_offset[0] > 12) {
+        ret = AVERROR_INVALIDDATA;
+        goto fail;
+    }
+
     pps->deblocking_filter_parameters_present = get_bits1(gb);
     pps->constrained_intra_pred               = get_bits1(gb);
     pps->redundant_pic_cnt_present            = get_bits1(gb);
@@ -828,10 +814,16 @@ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avct
     bits_left = bit_length - get_bits_count(gb);
     if (bits_left > 0 && more_rbsp_data_in_pps(sps, avctx)) {
         pps->transform_8x8_mode = get_bits1(gb);
-        decode_scaling_matrices(gb, sps, pps, 0,
+        ret = decode_scaling_matrices(gb, sps, pps, 0,
                                 pps->scaling_matrix4, pps->scaling_matrix8);
+        if (ret < 0)
+            goto fail;
         // second_chroma_qp_index_offset
         pps->chroma_qp_index_offset[1] = get_se_golomb(gb);
+        if (pps->chroma_qp_index_offset[1] < -12 || pps->chroma_qp_index_offset[1] > 12) {
+            ret = AVERROR_INVALIDDATA;
+            goto fail;
+        }
     } else {
         pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_ps.h b/mythtv/external/FFmpeg/libavcodec/h264_ps.h
index 9b9e295c830..51b6694b5f4 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_ps.h
+++ b/mythtv/external/FFmpeg/libavcodec/h264_ps.h
@@ -56,7 +56,8 @@ typedef struct SPS {
     int ref_frame_count;               ///< num_ref_frames
     int gaps_in_frame_num_allowed_flag;
     int mb_width;                      ///< pic_width_in_mbs_minus1 + 1
-    int mb_height;                     ///< pic_height_in_map_units_minus1 + 1
+    ///< (pic_height_in_map_units_minus1 + 1) * (2 - frame_mbs_only_flag)
+    int mb_height;
     int frame_mbs_only_flag;
     int mb_aff;                        ///< mb_adaptive_frame_field_flag
     int direct_8x8_inference_flag;
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_refs.c b/mythtv/external/FFmpeg/libavcodec/h264_refs.c
index 0811f097ee1..ba7a2a01d2a 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_refs.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_refs.c
@@ -571,8 +571,7 @@ void ff_h264_remove_all_refs(H264Context *h)
 
     if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {
         ff_h264_unref_picture(h, &h->last_pic_for_ec);
-        if (h->short_ref[0]->f->buf[0])
-            ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]);
+        ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]);
     }
 
     for (i = 0; i < h->short_ref_count; i++) {
@@ -855,15 +854,6 @@ int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb,
                     mmco[i].short_pic_num =
                         (sl->curr_pic_num - get_ue_golomb_long(gb) - 1) &
                             (sl->max_pic_num - 1);
-#if 0
-                    if (mmco[i].short_pic_num >= h->short_ref_count ||
-                        !h->short_ref[mmco[i].short_pic_num]) {
-                        av_log(s->avctx, AV_LOG_ERROR,
-                               "illegal short ref in memory management control "
-                               "operation %d\n", mmco);
-                        return -1;
-                    }
-#endif
                 }
                 if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
                     opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_sei.c b/mythtv/external/FFmpeg/libavcodec/h264_sei.c
index 5053962fe1a..332ae508606 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_sei.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_sei.c
@@ -45,6 +45,7 @@ void ff_h264_sei_uninit(H264SEIContext *h)
     h->picture_timing.dpb_output_delay  = 0;
     h->picture_timing.cpb_removal_delay = -1;
 
+    h->picture_timing.present      = 0;
     h->buffering_period.present    = 0;
     h->frame_packing.present       = 0;
     h->display_orientation.present = 0;
@@ -80,7 +81,7 @@ static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb,
         h->pic_struct = get_bits(gb, 4);
         h->ct_type    = 0;
 
-        if (h->pic_struct > SEI_PIC_STRUCT_FRAME_TRIPLING)
+        if (h->pic_struct > H264_SEI_PIC_STRUCT_FRAME_TRIPLING)
             return AVERROR_INVALIDDATA;
 
         num_clock_ts = sei_num_clock_ts_table[h->pic_struct];
@@ -119,6 +120,8 @@ static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb,
         av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",
                h->ct_type, h->pic_struct);
     }
+
+    h->present = 1;
     return 0;
 }
 
@@ -379,6 +382,14 @@ static int decode_green_metadata(H264SEIGreenMetaData *h, GetBitContext *gb)
     return 0;
 }
 
+static int decode_alternative_transfer(H264SEIAlternativeTransfer *h,
+                                       GetBitContext *gb)
+{
+    h->present = 1;
+    h->preferred_transfer_characteristics = get_bits(gb, 8);
+    return 0;
+}
+
 int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb,
                        const H264ParamSets *ps, void *logctx)
 {
@@ -410,30 +421,33 @@ int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb,
         next = get_bits_count(gb) + 8 * size;
 
         switch (type) {
-        case SEI_TYPE_PIC_TIMING: // Picture timing SEI
+        case H264_SEI_TYPE_PIC_TIMING: // Picture timing SEI
             ret = decode_picture_timing(&h->picture_timing, gb, ps, logctx);
             break;
-        case SEI_TYPE_USER_DATA_REGISTERED:
+        case H264_SEI_TYPE_USER_DATA_REGISTERED:
             ret = decode_registered_user_data(h, gb, logctx, size);
             break;
-        case SEI_TYPE_USER_DATA_UNREGISTERED:
+        case H264_SEI_TYPE_USER_DATA_UNREGISTERED:
             ret = decode_unregistered_user_data(&h->unregistered, gb, logctx, size);
             break;
-        case SEI_TYPE_RECOVERY_POINT:
+        case H264_SEI_TYPE_RECOVERY_POINT:
             ret = decode_recovery_point(&h->recovery_point, gb);
             break;
-        case SEI_TYPE_BUFFERING_PERIOD:
+        case H264_SEI_TYPE_BUFFERING_PERIOD:
             ret = decode_buffering_period(&h->buffering_period, gb, ps, logctx);
             break;
-        case SEI_TYPE_FRAME_PACKING:
+        case H264_SEI_TYPE_FRAME_PACKING:
             ret = decode_frame_packing_arrangement(&h->frame_packing, gb);
             break;
-        case SEI_TYPE_DISPLAY_ORIENTATION:
+        case H264_SEI_TYPE_DISPLAY_ORIENTATION:
             ret = decode_display_orientation(&h->display_orientation, gb);
             break;
-        case SEI_TYPE_GREEN_METADATA:
+        case H264_SEI_TYPE_GREEN_METADATA:
             ret = decode_green_metadata(&h->green_metadata, gb);
             break;
+        case H264_SEI_TYPE_ALTERNATIVE_TRANSFER:
+            ret = decode_alternative_transfer(&h->alternative_transfer, gb);
+            break;
         default:
             av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
         }
@@ -455,37 +469,37 @@ const char *ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
 {
     if (h->frame_packing_arrangement_cancel_flag == 0) {
         switch (h->frame_packing_arrangement_type) {
-            case SEI_FPA_TYPE_CHECKERBOARD:
+            case H264_SEI_FPA_TYPE_CHECKERBOARD:
                 if (h->content_interpretation_type == 2)
                     return "checkerboard_rl";
                 else
                     return "checkerboard_lr";
-            case SEI_FPA_TYPE_INTERLEAVE_COLUMN:
+            case H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN:
                 if (h->content_interpretation_type == 2)
                     return "col_interleaved_rl";
                 else
                     return "col_interleaved_lr";
-            case SEI_FPA_TYPE_INTERLEAVE_ROW:
+            case H264_SEI_FPA_TYPE_INTERLEAVE_ROW:
                 if (h->content_interpretation_type == 2)
                     return "row_interleaved_rl";
                 else
                     return "row_interleaved_lr";
-            case SEI_FPA_TYPE_SIDE_BY_SIDE:
+            case H264_SEI_FPA_TYPE_SIDE_BY_SIDE:
                 if (h->content_interpretation_type == 2)
                     return "right_left";
                 else
                     return "left_right";
-            case SEI_FPA_TYPE_TOP_BOTTOM:
+            case H264_SEI_FPA_TYPE_TOP_BOTTOM:
                 if (h->content_interpretation_type == 2)
                     return "bottom_top";
                 else
                     return "top_bottom";
-            case SEI_FPA_TYPE_INTERLEAVE_TEMPORAL:
+            case H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL:
                 if (h->content_interpretation_type == 2)
                     return "block_rl";
                 else
                     return "block_lr";
-            case SEI_FPA_TYPE_2D:
+            case H264_SEI_FPA_TYPE_2D:
             default:
                 return "mono";
         }
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_sei.h b/mythtv/external/FFmpeg/libavcodec/h264_sei.h
index 91977952ca7..a53f1899fad 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_sei.h
+++ b/mythtv/external/FFmpeg/libavcodec/h264_sei.h
@@ -25,46 +25,49 @@
  * SEI message types
  */
 typedef enum {
-    SEI_TYPE_BUFFERING_PERIOD       = 0,   ///< buffering period (H.264, D.1.1)
-    SEI_TYPE_PIC_TIMING             = 1,   ///< picture timing
-    SEI_TYPE_USER_DATA_REGISTERED   = 4,   ///< registered user data as specified by Rec. ITU-T T.35
-    SEI_TYPE_USER_DATA_UNREGISTERED = 5,   ///< unregistered user data
-    SEI_TYPE_RECOVERY_POINT         = 6,   ///< recovery point (frame # to decoder sync)
-    SEI_TYPE_FRAME_PACKING          = 45,  ///< frame packing arrangement
-    SEI_TYPE_DISPLAY_ORIENTATION    = 47,  ///< display orientation
-    SEI_TYPE_GREEN_METADATA         = 56   ///< GreenMPEG information
-} SEI_Type;
+    H264_SEI_TYPE_BUFFERING_PERIOD       = 0,   ///< buffering period (H.264, D.1.1)
+    H264_SEI_TYPE_PIC_TIMING             = 1,   ///< picture timing
+    H264_SEI_TYPE_FILLER_PAYLOAD         = 3,   ///< filler data
+    H264_SEI_TYPE_USER_DATA_REGISTERED   = 4,   ///< registered user data as specified by Rec. ITU-T T.35
+    H264_SEI_TYPE_USER_DATA_UNREGISTERED = 5,   ///< unregistered user data
+    H264_SEI_TYPE_RECOVERY_POINT         = 6,   ///< recovery point (frame # to decoder sync)
+    H264_SEI_TYPE_FRAME_PACKING          = 45,  ///< frame packing arrangement
+    H264_SEI_TYPE_DISPLAY_ORIENTATION    = 47,  ///< display orientation
+    H264_SEI_TYPE_GREEN_METADATA         = 56,  ///< GreenMPEG information
+    H264_SEI_TYPE_ALTERNATIVE_TRANSFER   = 147, ///< alternative transfer
+} H264_SEI_Type;
 
 /**
  * pic_struct in picture timing SEI message
  */
 typedef enum {
-    SEI_PIC_STRUCT_FRAME             = 0, ///<  0: %frame
-    SEI_PIC_STRUCT_TOP_FIELD         = 1, ///<  1: top field
-    SEI_PIC_STRUCT_BOTTOM_FIELD      = 2, ///<  2: bottom field
-    SEI_PIC_STRUCT_TOP_BOTTOM        = 3, ///<  3: top field, bottom field, in that order
-    SEI_PIC_STRUCT_BOTTOM_TOP        = 4, ///<  4: bottom field, top field, in that order
-    SEI_PIC_STRUCT_TOP_BOTTOM_TOP    = 5, ///<  5: top field, bottom field, top field repeated, in that order
-    SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6, ///<  6: bottom field, top field, bottom field repeated, in that order
-    SEI_PIC_STRUCT_FRAME_DOUBLING    = 7, ///<  7: %frame doubling
-    SEI_PIC_STRUCT_FRAME_TRIPLING    = 8  ///<  8: %frame tripling
-} SEI_PicStructType;
+    H264_SEI_PIC_STRUCT_FRAME             = 0, ///<  0: %frame
+    H264_SEI_PIC_STRUCT_TOP_FIELD         = 1, ///<  1: top field
+    H264_SEI_PIC_STRUCT_BOTTOM_FIELD      = 2, ///<  2: bottom field
+    H264_SEI_PIC_STRUCT_TOP_BOTTOM        = 3, ///<  3: top field, bottom field, in that order
+    H264_SEI_PIC_STRUCT_BOTTOM_TOP        = 4, ///<  4: bottom field, top field, in that order
+    H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP    = 5, ///<  5: top field, bottom field, top field repeated, in that order
+    H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6, ///<  6: bottom field, top field, bottom field repeated, in that order
+    H264_SEI_PIC_STRUCT_FRAME_DOUBLING    = 7, ///<  7: %frame doubling
+    H264_SEI_PIC_STRUCT_FRAME_TRIPLING    = 8  ///<  8: %frame tripling
+} H264_SEI_PicStructType;
 
 /**
  * frame_packing_arrangement types
  */
 typedef enum {
-    SEI_FPA_TYPE_CHECKERBOARD        = 0,
-    SEI_FPA_TYPE_INTERLEAVE_COLUMN   = 1,
-    SEI_FPA_TYPE_INTERLEAVE_ROW      = 2,
-    SEI_FPA_TYPE_SIDE_BY_SIDE        = 3,
-    SEI_FPA_TYPE_TOP_BOTTOM          = 4,
-    SEI_FPA_TYPE_INTERLEAVE_TEMPORAL = 5,
-    SEI_FPA_TYPE_2D                  = 6,
-} SEI_FpaType;
+    H264_SEI_FPA_TYPE_CHECKERBOARD        = 0,
+    H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN   = 1,
+    H264_SEI_FPA_TYPE_INTERLEAVE_ROW      = 2,
+    H264_SEI_FPA_TYPE_SIDE_BY_SIDE        = 3,
+    H264_SEI_FPA_TYPE_TOP_BOTTOM          = 4,
+    H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL = 5,
+    H264_SEI_FPA_TYPE_2D                  = 6,
+} H264_SEI_FpaType;
 
 typedef struct H264SEIPictureTiming {
-    SEI_PicStructType pic_struct;
+    int present;
+    H264_SEI_PicStructType pic_struct;
 
     /**
      * Bit set of clock types for fields/frames in picture timing SEI message.
@@ -118,7 +121,7 @@ typedef struct H264SEIFramePacking {
     int present;
     int frame_packing_arrangement_id;
     int frame_packing_arrangement_cancel_flag;  ///< is previous arrangement canceled, -1 if never received
-    SEI_FpaType frame_packing_arrangement_type;
+    H264_SEI_FpaType frame_packing_arrangement_type;
     int frame_packing_arrangement_repetition_period;
     int content_interpretation_type;
     int quincunx_sampling_flag;
@@ -143,6 +146,11 @@ typedef struct H264SEIGreenMetaData {
     uint16_t xsd_metric_value;
 } H264SEIGreenMetaData;
 
+typedef struct H264SEIAlternativeTransfer {
+    int present;
+    int preferred_transfer_characteristics;
+} H264SEIAlternativeTransfer;
+
 typedef struct H264SEIContext {
     H264SEIPictureTiming picture_timing;
     H264SEIAFD afd;
@@ -153,6 +161,7 @@ typedef struct H264SEIContext {
     H264SEIFramePacking frame_packing;
     H264SEIDisplayOrientation display_orientation;
     H264SEIGreenMetaData green_metadata;
+    H264SEIAlternativeTransfer alternative_transfer;
 } H264SEIContext;
 
 struct H264ParamSets;
diff --git a/mythtv/external/FFmpeg/libavcodec/h264_slice.c b/mythtv/external/FFmpeg/libavcodec/h264_slice.c
index 25a5890aa89..2577edd8a6d 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264_slice.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264_slice.c
@@ -44,6 +44,7 @@
 #include "golomb.h"
 #include "mathops.h"
 #include "mpegutils.h"
+#include "mpegvideo.h"
 #include "rectangle.h"
 #include "thread.h"
 
@@ -196,10 +197,6 @@ static int alloc_picture(H264Context *h, H264Picture *pic)
     if (ret < 0)
         goto fail;
 
-    pic->crop     = h->ps.sps->crop;
-    pic->crop_top = h->ps.sps->crop_top;
-    pic->crop_left= h->ps.sps->crop_left;
-
     if (h->avctx->hwaccel) {
         const AVHWAccel *hwaccel = h->avctx->hwaccel;
         av_assert0(!pic->hwaccel_picture_private);
@@ -253,25 +250,15 @@ static int alloc_picture(H264Context *h, H264Picture *pic)
     return (ret < 0) ? ret : AVERROR(ENOMEM);
 }
 
-static inline int pic_is_unused(H264Context *h, H264Picture *pic)
-{
-    if (!pic->f->buf[0])
-        return 1;
-    return 0;
-}
-
 static int find_unused_picture(H264Context *h)
 {
     int i;
 
     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
-        if (pic_is_unused(h, &h->DPB[i]))
-            break;
+        if (!h->DPB[i].f->buf[0])
+            return i;
     }
-    if (i == H264_MAX_PICTURE_COUNT)
-        return AVERROR_INVALIDDATA;
-
-    return i;
+    return AVERROR_INVALIDDATA;
 }
 
 
@@ -387,14 +374,13 @@ int ff_h264_update_thread_context(AVCodecContext *dst,
     h->avctx->coded_width   = h1->avctx->coded_width;
     h->avctx->width         = h1->avctx->width;
     h->avctx->height        = h1->avctx->height;
+    h->width_from_caller    = h1->width_from_caller;
+    h->height_from_caller   = h1->height_from_caller;
     h->coded_picture_number = h1->coded_picture_number;
     h->first_field          = h1->first_field;
     h->picture_structure    = h1->picture_structure;
     h->mb_aff_frame         = h1->mb_aff_frame;
     h->droppable            = h1->droppable;
-    h->backup_width         = h1->backup_width;
-    h->backup_height        = h1->backup_height;
-    h->backup_pix_fmt       = h1->backup_pix_fmt;
 
     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
         ff_h264_unref_picture(h, &h->DPB[i]);
@@ -422,7 +408,6 @@ int ff_h264_update_thread_context(AVCodecContext *dst,
 
     memcpy(&h->poc,        &h1->poc,        sizeof(h->poc));
 
-    memcpy(h->default_ref, h1->default_ref, sizeof(h->default_ref));
     memcpy(h->short_ref,   h1->short_ref,   sizeof(h->short_ref));
     memcpy(h->long_ref,    h1->long_ref,    sizeof(h->long_ref));
     memcpy(h->delayed_pic, h1->delayed_pic, sizeof(h->delayed_pic));
@@ -505,6 +490,11 @@ static int h264_frame_start(H264Context *h)
 
     pic->f->pict_type = h->slice_ctx[0].slice_type;
 
+    pic->f->crop_left   = h->crop_left;
+    pic->f->crop_right  = h->crop_right;
+    pic->f->crop_top    = h->crop_top;
+    pic->f->crop_bottom = h->crop_bottom;
+
     if ((ret = alloc_picture(h, pic)) < 0)
         return ret;
     if(!h->frame_recovered && !h->avctx->hwaccel
@@ -767,7 +757,7 @@ static void init_scan_tables(H264Context *h)
 static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
 {
 #define HWACCEL_MAX (CONFIG_H264_DXVA2_HWACCEL + \
-                     CONFIG_H264_D3D11VA_HWACCEL + \
+                     (CONFIG_H264_D3D11VA_HWACCEL * 2) + \
                      CONFIG_H264_VAAPI_HWACCEL + \
                      (CONFIG_H264_VDA_HWACCEL * 2) + \
                      CONFIG_H264_VIDEOTOOLBOX_HWACCEL + \
@@ -843,6 +833,7 @@ static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
 #endif
 #if CONFIG_H264_D3D11VA_HWACCEL
             *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
+            *fmt++ = AV_PIX_FMT_D3D11;
 #endif
 #if CONFIG_H264_VAAPI_HWACCEL
             *fmt++ = AV_PIX_FMT_VAAPI;
@@ -880,25 +871,41 @@ static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
 static int init_dimensions(H264Context *h)
 {
     const SPS *sps = (const SPS*)h->ps.sps;
-    int width  = h->width  - (sps->crop_right + sps->crop_left);
-    int height = h->height - (sps->crop_top   + sps->crop_bottom);
+    int cr = sps->crop_right;
+    int cl = sps->crop_left;
+    int ct = sps->crop_top;
+    int cb = sps->crop_bottom;
+    int width  = h->width  - (cr + cl);
+    int height = h->height - (ct + cb);
     av_assert0(sps->crop_right + sps->crop_left < (unsigned)h->width);
     av_assert0(sps->crop_top + sps->crop_bottom < (unsigned)h->height);
 
     /* handle container cropping */
-    if (FFALIGN(h->avctx->width,  16) == FFALIGN(width,  16) &&
-        FFALIGN(h->avctx->height, 16) == FFALIGN(height, 16) &&
-        h->avctx->width  <= width &&
-        h->avctx->height <= height
-    ) {
-        width  = h->avctx->width;
-        height = h->avctx->height;
+    if (h->width_from_caller > 0 && h->height_from_caller > 0     &&
+        !sps->crop_top && !sps->crop_left                         &&
+        FFALIGN(h->width_from_caller,  16) == FFALIGN(width,  16) &&
+        FFALIGN(h->height_from_caller, 16) == FFALIGN(height, 16) &&
+        h->width_from_caller  <= width &&
+        h->height_from_caller <= height) {
+        width  = h->width_from_caller;
+        height = h->height_from_caller;
+        cl = 0;
+        ct = 0;
+        cr = h->width - width;
+        cb = h->height - height;
+    } else {
+        h->width_from_caller  = 0;
+        h->height_from_caller = 0;
     }
 
     h->avctx->coded_width  = h->width;
     h->avctx->coded_height = h->height;
     h->avctx->width        = width;
     h->avctx->height       = height;
+    h->crop_right          = cr;
+    h->crop_left           = cl;
+    h->crop_top            = ct;
+    h->crop_bottom         = cb;
 
     return 0;
 }
@@ -1032,7 +1039,7 @@ static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_sl
         h->ps.sps = (const SPS*)h->ps.sps_ref->data;
 
         if (h->mb_width  != h->ps.sps->mb_width ||
-            h->mb_height != h->ps.sps->mb_height * (2 - h->ps.sps->frame_mbs_only_flag) ||
+            h->mb_height != h->ps.sps->mb_height ||
             h->cur_bit_depth_luma    != h->ps.sps->bit_depth_luma ||
             h->cur_chroma_format_idc != h->ps.sps->chroma_format_idc
         )
@@ -1046,11 +1053,11 @@ static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_sl
 
     must_reinit = (h->context_initialized &&
                     (   16*sps->mb_width != h->avctx->coded_width
-                     || 16*sps->mb_height * (2 - sps->frame_mbs_only_flag) != h->avctx->coded_height
+                     || 16*sps->mb_height != h->avctx->coded_height
                      || h->cur_bit_depth_luma    != sps->bit_depth_luma
                      || h->cur_chroma_format_idc != sps->chroma_format_idc
                      || h->mb_width  != sps->mb_width
-                     || h->mb_height != sps->mb_height * (2 - sps->frame_mbs_only_flag)
+                     || h->mb_height != sps->mb_height
                     ));
     if (h->avctx->pix_fmt == AV_PIX_FMT_NONE
         || (non_j_pixfmt(h->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h, 0))))
@@ -1065,7 +1072,7 @@ static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_sl
         h->avctx->refs    = sps->ref_frame_count;
 
         h->mb_width  = sps->mb_width;
-        h->mb_height = sps->mb_height * (2 - sps->frame_mbs_only_flag);
+        h->mb_height = sps->mb_height;
         h->mb_num    = h->mb_width * h->mb_height;
         h->mb_stride = h->mb_width + 1;
 
@@ -1140,40 +1147,40 @@ static int h264_export_frame_props(H264Context *h)
     /* Prioritize picture timing SEI information over used
      * decoding process if it exists. */
 
-    if (sps->pic_struct_present_flag) {
+    if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
         H264SEIPictureTiming *pt = &h->sei.picture_timing;
         switch (pt->pic_struct) {
-        case SEI_PIC_STRUCT_FRAME:
+        case H264_SEI_PIC_STRUCT_FRAME:
             break;
-        case SEI_PIC_STRUCT_TOP_FIELD:
-        case SEI_PIC_STRUCT_BOTTOM_FIELD:
+        case H264_SEI_PIC_STRUCT_TOP_FIELD:
+        case H264_SEI_PIC_STRUCT_BOTTOM_FIELD:
             cur->f->interlaced_frame = 1;
             break;
-        case SEI_PIC_STRUCT_TOP_BOTTOM:
-        case SEI_PIC_STRUCT_BOTTOM_TOP:
+        case H264_SEI_PIC_STRUCT_TOP_BOTTOM:
+        case H264_SEI_PIC_STRUCT_BOTTOM_TOP:
             if (FIELD_OR_MBAFF_PICTURE(h))
                 cur->f->interlaced_frame = 1;
             else
                 // try to flag soft telecine progressive
                 cur->f->interlaced_frame = h->prev_interlaced_frame;
             break;
-        case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
-        case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
+        case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
+        case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
             /* Signal the possibility of telecined film externally
              * (pic_struct 5,6). From these hints, let the applications
              * decide if they apply deinterlacing. */
             cur->f->repeat_pict = 1;
             break;
-        case SEI_PIC_STRUCT_FRAME_DOUBLING:
+        case H264_SEI_PIC_STRUCT_FRAME_DOUBLING:
             cur->f->repeat_pict = 2;
             break;
-        case SEI_PIC_STRUCT_FRAME_TRIPLING:
+        case H264_SEI_PIC_STRUCT_FRAME_TRIPLING:
             cur->f->repeat_pict = 4;
             break;
         }
 
         if ((pt->ct_type & 3) &&
-            pt->pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)
+            pt->pic_struct <= H264_SEI_PIC_STRUCT_BOTTOM_TOP)
             cur->f->interlaced_frame = (pt->ct_type & (1 << 1)) != 0;
     } else {
         /* Derive interlacing flag from used decoding process. */
@@ -1185,11 +1192,11 @@ static int h264_export_frame_props(H264Context *h)
         /* Derive top_field_first from field pocs. */
         cur->f->top_field_first = cur->field_poc[0] < cur->field_poc[1];
     } else {
-        if (sps->pic_struct_present_flag) {
+        if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
             /* Use picture timing SEI information. Even if it is a
              * information of a past frame, better than nothing. */
-            if (h->sei.picture_timing.pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM ||
-                h->sei.picture_timing.pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
+            if (h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM ||
+                h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
                 cur->f->top_field_first = 1;
             else
                 cur->f->top_field_first = 0;
@@ -1280,6 +1287,111 @@ static int h264_export_frame_props(H264Context *h)
         h->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
     }
 
+    if (h->sei.alternative_transfer.present &&
+        av_color_transfer_name(h->sei.alternative_transfer.preferred_transfer_characteristics) &&
+        h->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
+        h->avctx->color_trc = cur->f->color_trc = h->sei.alternative_transfer.preferred_transfer_characteristics;
+    }
+
+    return 0;
+}
+
+static int h264_select_output_frame(H264Context *h)
+{
+    const SPS *sps = h->ps.sps;
+    H264Picture *out = h->cur_pic_ptr;
+    H264Picture *cur = h->cur_pic_ptr;
+    int i, pics, out_of_order, out_idx;
+
+    cur->mmco_reset = h->mmco_reset;
+    h->mmco_reset = 0;
+
+    if (sps->bitstream_restriction_flag ||
+        h->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
+        h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, sps->num_reorder_frames);
+    }
+
+    for (i = 0; 1; i++) {
+        if(i == MAX_DELAYED_PIC_COUNT || cur->poc < h->last_pocs[i]){
+            if(i)
+                h->last_pocs[i-1] = cur->poc;
+            break;
+        } else if(i) {
+            h->last_pocs[i-1]= h->last_pocs[i];
+        }
+    }
+    out_of_order = MAX_DELAYED_PIC_COUNT - i;
+    if(   cur->f->pict_type == AV_PICTURE_TYPE_B
+       || (h->last_pocs[MAX_DELAYED_PIC_COUNT-2] > INT_MIN && h->last_pocs[MAX_DELAYED_PIC_COUNT-1] - h->last_pocs[MAX_DELAYED_PIC_COUNT-2] > 2))
+        out_of_order = FFMAX(out_of_order, 1);
+    if (out_of_order == MAX_DELAYED_PIC_COUNT) {
+        av_log(h->avctx, AV_LOG_VERBOSE, "Invalid POC %d<%d\n", cur->poc, h->last_pocs[0]);
+        for (i = 1; i < MAX_DELAYED_PIC_COUNT; i++)
+            h->last_pocs[i] = INT_MIN;
+        h->last_pocs[0] = cur->poc;
+        cur->mmco_reset = 1;
+    } else if(h->avctx->has_b_frames < out_of_order && !sps->bitstream_restriction_flag){
+        int loglevel = h->avctx->frame_number > 1 ? AV_LOG_WARNING : AV_LOG_VERBOSE;
+        av_log(h->avctx, loglevel, "Increasing reorder buffer to %d\n", out_of_order);
+        h->avctx->has_b_frames = out_of_order;
+    }
+
+    pics = 0;
+    while (h->delayed_pic[pics])
+        pics++;
+
+    av_assert0(pics <= MAX_DELAYED_PIC_COUNT);
+
+    h->delayed_pic[pics++] = cur;
+    if (cur->reference == 0)
+        cur->reference = DELAYED_PIC_REF;
+
+    out     = h->delayed_pic[0];
+    out_idx = 0;
+    for (i = 1; h->delayed_pic[i] &&
+                !h->delayed_pic[i]->f->key_frame &&
+                !h->delayed_pic[i]->mmco_reset;
+         i++)
+        if (h->delayed_pic[i]->poc < out->poc) {
+            out     = h->delayed_pic[i];
+            out_idx = i;
+        }
+    if (h->avctx->has_b_frames == 0 &&
+        (h->delayed_pic[0]->f->key_frame || h->delayed_pic[0]->mmco_reset))
+        h->next_outputed_poc = INT_MIN;
+    out_of_order = out->poc < h->next_outputed_poc;
+
+    if (out_of_order || pics > h->avctx->has_b_frames) {
+        out->reference &= ~DELAYED_PIC_REF;
+        for (i = out_idx; h->delayed_pic[i]; i++)
+            h->delayed_pic[i] = h->delayed_pic[i + 1];
+    }
+    if (!out_of_order && pics > h->avctx->has_b_frames) {
+        h->next_output_pic = out;
+        if (out_idx == 0 && h->delayed_pic[0] && (h->delayed_pic[0]->f->key_frame || h->delayed_pic[0]->mmco_reset)) {
+            h->next_outputed_poc = INT_MIN;
+        } else
+            h->next_outputed_poc = out->poc;
+
+        if (out->recovered) {
+            // We have reached an recovery point and all frames after it in
+            // display order are "recovered".
+            h->frame_recovered |= FRAME_RECOVERED_SEI;
+        }
+        out->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_SEI);
+
+        if (!out->recovered) {
+            if (!(h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) &&
+                !(h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL)) {
+                h->next_output_pic = NULL;
+            } else {
+                out->f->flags |= AV_FRAME_FLAG_CORRUPT;
+            }
+        }
+    } else {
+        av_log(h->avctx, AV_LOG_DEBUG, "no picture %s\n", out_of_order ? "ooo" : "");
+    }
+
     return 0;
 }
 
@@ -1336,14 +1448,14 @@ static int h264_field_start(H264Context *h, const H264SliceContext *sl,
      * We have to do that before the "dummy" in-between frame allocation,
      * since that can modify h->cur_pic_ptr. */
     if (h->first_field) {
+        int last_field = last_pic_structure == PICT_BOTTOM_FIELD;
         av_assert0(h->cur_pic_ptr);
         av_assert0(h->cur_pic_ptr->f->buf[0]);
         assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
 
         /* Mark old field/frame as completed */
-        if (h->cur_pic_ptr->tf.owner == h->avctx) {
-            ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
-                                      last_pic_structure == PICT_BOTTOM_FIELD);
+        if (h->cur_pic_ptr->tf.owner[last_field] == h->avctx) {
+            ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, last_field);
         }
 
         /* figure out if we have a complementary field pair */
@@ -1424,6 +1536,9 @@ static int h264_field_start(H264Context *h, const H264SliceContext *sl,
                 h->short_ref[0]->f->width == prev->f->width &&
                 h->short_ref[0]->f->height == prev->f->height &&
                 h->short_ref[0]->f->format == prev->f->format) {
+                ff_thread_await_progress(&prev->tf, INT_MAX, 0);
+                if (prev->field_picture)
+                    ff_thread_await_progress(&prev->tf, INT_MAX, 1);
                 av_image_copy(h->short_ref[0]->f->data,
                               h->short_ref[0]->f->linesize,
                               (const uint8_t **)prev->f->data,
@@ -1478,7 +1593,9 @@ static int h264_field_start(H264Context *h, const H264SliceContext *sl,
             return AVERROR_INVALIDDATA;
         }
     } else {
+        int field = h->picture_structure == PICT_BOTTOM_FIELD;
         release_unused_pictures(h, 0);
+        h->cur_pic_ptr->tf.owner[field] = h->avctx;
     }
     /* Some macroblocks can be accessed before they're available in case
     * of lost slices, MBAFF or threading. */
@@ -1534,10 +1651,14 @@ static int h264_field_start(H264Context *h, const H264SliceContext *sl,
     /* Set the frame properties/side data. Only done for the second field in
      * field coded frames, since some SEI information is present for each field
      * and is merged by the SEI parsing code. */
-    if (!FIELD_PICTURE(h) || !h->first_field) {
+    if (!FIELD_PICTURE(h) || !h->first_field || h->missing_fields > 1) {
         ret = h264_export_frame_props(h);
         if (ret < 0)
             return ret;
+
+        ret = h264_select_output_frame(h);
+        if (ret < 0)
+            return ret;
     }
 
     return 0;
@@ -1684,9 +1805,13 @@ static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
     }
     if ((pps->weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
         (pps->weighted_bipred_idc == 1 &&
-         sl->slice_type_nos == AV_PICTURE_TYPE_B))
-        ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,
-                                  sl->slice_type_nos, &sl->pwt, h->avctx);
+         sl->slice_type_nos == AV_PICTURE_TYPE_B)) {
+        ret = ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,
+                                  sl->slice_type_nos, &sl->pwt,
+                                  picture_structure, h->avctx);
+        if (ret < 0)
+            return ret;
+    }
 
     sl->explicit_ref_marking = 0;
     if (nal->ref_idc) {
@@ -1705,7 +1830,7 @@ static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
     }
 
     sl->last_qscale_diff = 0;
-    tmp = pps->init_qp + get_se_golomb(&sl->gb);
+    tmp = pps->init_qp + (unsigned)get_se_golomb(&sl->gb);
     if (tmp > 51 + 6 * (sps->bit_depth_luma - 8)) {
         av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
         return AVERROR_INVALIDDATA;
@@ -1735,138 +1860,31 @@ static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
             sl->deblocking_filter ^= 1;  // 1<->0
 
         if (sl->deblocking_filter) {
-            sl->slice_alpha_c0_offset = get_se_golomb(&sl->gb) * 2;
-            sl->slice_beta_offset     = get_se_golomb(&sl->gb) * 2;
-            if (sl->slice_alpha_c0_offset >  12 ||
-                sl->slice_alpha_c0_offset < -12 ||
-                sl->slice_beta_offset >  12     ||
-                sl->slice_beta_offset < -12) {
+            int slice_alpha_c0_offset_div2 = get_se_golomb(&sl->gb);
+            int slice_beta_offset_div2     = get_se_golomb(&sl->gb);
+            if (slice_alpha_c0_offset_div2 >  6 ||
+                slice_alpha_c0_offset_div2 < -6 ||
+                slice_beta_offset_div2 >  6     ||
+                slice_beta_offset_div2 < -6) {
                 av_log(h->avctx, AV_LOG_ERROR,
                        "deblocking filter parameters %d %d out of range\n",
-                       sl->slice_alpha_c0_offset, sl->slice_beta_offset);
+                       slice_alpha_c0_offset_div2, slice_beta_offset_div2);
                 return AVERROR_INVALIDDATA;
             }
+            sl->slice_alpha_c0_offset = slice_alpha_c0_offset_div2 * 2;
+            sl->slice_beta_offset     = slice_beta_offset_div2 * 2;
         }
     }
 
     return 0;
 }
 
-/**
- * Decode a slice header.
- * This will (re)initialize the decoder and call h264_frame_start() as needed.
- *
- * @param h h264context
- *
- * @return 0 if okay, <0 if an error occurred
- */
-int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl,
-                                const H2645NAL *nal)
+/* do all the per-slice initialization needed before we can start decoding the
+ * actual MBs */
+static int h264_slice_init(H264Context *h, H264SliceContext *sl,
+                           const H2645NAL *nal)
 {
     int i, j, ret = 0;
-    int first_slice = sl == h->slice_ctx && !h->current_slice;
-
-    ret = h264_slice_header_parse(h, sl, nal);
-    if (ret < 0)
-        return ret;
-
-    // discard redundant pictures
-    if (sl->redundant_pic_count > 0)
-        return 0;
-
-    if (sl->first_mb_addr == 0 || !h->current_slice) {
-        if (h->setup_finished) {
-            av_log(h->avctx, AV_LOG_ERROR, "Too many fields\n");
-            return AVERROR_INVALIDDATA;
-        }
-    }
-
-    if (sl->first_mb_addr == 0) { // FIXME better field boundary detection
-        if (h->current_slice) {
-            if (h->max_contexts > 1) {
-                if (!h->single_decode_warning) {
-                    av_log(h->avctx, AV_LOG_WARNING, "Cannot decode multiple access units as slice threads\n");
-                    h->single_decode_warning = 1;
-                }
-                h->max_contexts = 1;
-                return SLICE_SINGLETHREAD;
-            }
-
-            if (h->cur_pic_ptr && FIELD_PICTURE(h) && h->first_field) {
-                ret = ff_h264_field_end(h, h->slice_ctx, 1);
-                h->current_slice = 0;
-                if (ret < 0)
-                    return ret;
-            } else if (h->cur_pic_ptr && !FIELD_PICTURE(h) && !h->first_field && h->nal_unit_type  == H264_NAL_IDR_SLICE) {
-                av_log(h, AV_LOG_WARNING, "Broken frame packetizing\n");
-                ret = ff_h264_field_end(h, h->slice_ctx, 1);
-                h->current_slice = 0;
-                ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
-                ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
-                h->cur_pic_ptr = NULL;
-                if (ret < 0)
-                    return ret;
-            } else
-                return AVERROR_INVALIDDATA;
-        }
-
-        if (!h->first_field) {
-            if (h->cur_pic_ptr && !h->droppable) {
-                ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
-                                          h->picture_structure == PICT_BOTTOM_FIELD);
-            }
-            h->cur_pic_ptr = NULL;
-        }
-    }
-
-    if (!h->current_slice)
-        av_assert0(sl == h->slice_ctx);
-
-    if (h->current_slice == 0 && !h->first_field) {
-        if (
-            (h->avctx->skip_frame >= AVDISCARD_NONREF && !h->nal_ref_idc) ||
-            (h->avctx->skip_frame >= AVDISCARD_BIDIR  && sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
-            (h->avctx->skip_frame >= AVDISCARD_NONINTRA && sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
-            (h->avctx->skip_frame >= AVDISCARD_NONKEY && h->nal_unit_type != H264_NAL_IDR_SLICE && h->sei.recovery_point.recovery_frame_cnt < 0) ||
-            h->avctx->skip_frame >= AVDISCARD_ALL) {
-            return SLICE_SKIPED;
-        }
-    }
-
-    if (!first_slice) {
-        const PPS *pps = (const PPS*)h->ps.pps_list[sl->pps_id]->data;
-
-        if (h->ps.pps->sps_id != pps->sps_id ||
-            h->ps.pps->transform_8x8_mode != pps->transform_8x8_mode /*||
-            (h->setup_finished && h->ps.pps != pps)*/) {
-            av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");
-            return AVERROR_INVALIDDATA;
-        }
-        if (h->ps.sps != (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data) {
-            av_log(h->avctx, AV_LOG_ERROR,
-               "SPS changed in the middle of the frame\n");
-            return AVERROR_INVALIDDATA;
-        }
-    }
-
-    if (h->current_slice == 0) {
-        ret = h264_field_start(h, sl, nal, first_slice);
-        if (ret < 0)
-            return ret;
-    } else {
-        if (h->picture_structure != sl->picture_structure ||
-            h->droppable         != (nal->ref_idc == 0)) {
-            av_log(h->avctx, AV_LOG_ERROR,
-                   "Changing field mode (%d -> %d) between slices is not allowed\n",
-                   h->picture_structure, sl->picture_structure);
-            return AVERROR_INVALIDDATA;
-        } else if (!h->cur_pic_ptr) {
-            av_log(h->avctx, AV_LOG_ERROR,
-                   "unset cur_pic_ptr on slice %d\n",
-                   h->current_slice + 1);
-            return AVERROR_INVALIDDATA;
-        }
-    }
 
     if (h->picture_idr && nal->type != H264_NAL_IDR_SLICE) {
         av_log(h->avctx, AV_LOG_ERROR, "Invalid mix of IDR and non-IDR slices\n");
@@ -1901,7 +1919,8 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl,
 
     if (sl->slice_type_nos == AV_PICTURE_TYPE_B && !sl->direct_spatial_mv_pred)
         ff_h264_direct_dist_scale_factor(h, sl);
-    ff_h264_direct_ref_list_init(h, sl);
+    if (!h->setup_finished)
+        ff_h264_direct_ref_list_init(h, sl);
 
     if (h->avctx->skip_loop_filter >= AVDISCARD_ALL ||
         (h->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&
@@ -1914,7 +1933,7 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl,
          nal->ref_idc == 0))
         sl->deblocking_filter = 0;
 
-    if (sl->deblocking_filter == 1 && h->max_contexts > 1) {
+    if (sl->deblocking_filter == 1 && h->nb_slice_ctx > 1) {
         if (h->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
             /* Cheat slightly for speed:
              * Do not bother to deblock across slices. */
@@ -1998,6 +2017,131 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl,
     return 0;
 }
 
+int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
+{
+    H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
+    int first_slice = sl == h->slice_ctx && !h->current_slice;
+    int ret;
+
+    sl->gb = nal->gb;
+
+    ret = h264_slice_header_parse(h, sl, nal);
+    if (ret < 0)
+        return ret;
+
+    // discard redundant pictures
+    if (sl->redundant_pic_count > 0) {
+        sl->ref_count[0] = sl->ref_count[1] = 0;
+        return 0;
+    }
+
+    if (sl->first_mb_addr == 0 || !h->current_slice) {
+        if (h->setup_finished) {
+            av_log(h->avctx, AV_LOG_ERROR, "Too many fields\n");
+            return AVERROR_INVALIDDATA;
+        }
+    }
+
+    if (sl->first_mb_addr == 0) { // FIXME better field boundary detection
+        if (h->current_slice) {
+            // this slice starts a new field
+            // first decode any pending queued slices
+            if (h->nb_slice_ctx_queued) {
+                H264SliceContext tmp_ctx;
+
+                ret = ff_h264_execute_decode_slices(h);
+                if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
+                    return ret;
+
+                memcpy(&tmp_ctx, h->slice_ctx, sizeof(tmp_ctx));
+                memcpy(h->slice_ctx, sl, sizeof(tmp_ctx));
+                memcpy(sl, &tmp_ctx, sizeof(tmp_ctx));
+                sl = h->slice_ctx;
+            }
+
+            if (h->cur_pic_ptr && FIELD_PICTURE(h) && h->first_field) {
+                ret = ff_h264_field_end(h, h->slice_ctx, 1);
+                if (ret < 0)
+                    return ret;
+            } else if (h->cur_pic_ptr && !FIELD_PICTURE(h) && !h->first_field && h->nal_unit_type  == H264_NAL_IDR_SLICE) {
+                av_log(h, AV_LOG_WARNING, "Broken frame packetizing\n");
+                ret = ff_h264_field_end(h, h->slice_ctx, 1);
+                ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
+                ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
+                h->cur_pic_ptr = NULL;
+                if (ret < 0)
+                    return ret;
+            } else
+                return AVERROR_INVALIDDATA;
+        }
+
+        if (!h->first_field) {
+            if (h->cur_pic_ptr && !h->droppable) {
+                ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
+                                          h->picture_structure == PICT_BOTTOM_FIELD);
+            }
+            h->cur_pic_ptr = NULL;
+        }
+    }
+
+    if (!h->current_slice)
+        av_assert0(sl == h->slice_ctx);
+
+    if (h->current_slice == 0 && !h->first_field) {
+        if (
+            (h->avctx->skip_frame >= AVDISCARD_NONREF && !h->nal_ref_idc) ||
+            (h->avctx->skip_frame >= AVDISCARD_BIDIR  && sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
+            (h->avctx->skip_frame >= AVDISCARD_NONINTRA && sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
+            (h->avctx->skip_frame >= AVDISCARD_NONKEY && h->nal_unit_type != H264_NAL_IDR_SLICE && h->sei.recovery_point.recovery_frame_cnt < 0) ||
+            h->avctx->skip_frame >= AVDISCARD_ALL) {
+            return 0;
+        }
+    }
+
+    if (!first_slice) {
+        const PPS *pps = (const PPS*)h->ps.pps_list[sl->pps_id]->data;
+
+        if (h->ps.pps->sps_id != pps->sps_id ||
+            h->ps.pps->transform_8x8_mode != pps->transform_8x8_mode /*||
+            (h->setup_finished && h->ps.pps != pps)*/) {
+            av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");
+            return AVERROR_INVALIDDATA;
+        }
+        if (h->ps.sps != (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data) {
+            av_log(h->avctx, AV_LOG_ERROR,
+               "SPS changed in the middle of the frame\n");
+            return AVERROR_INVALIDDATA;
+        }
+    }
+
+    if (h->current_slice == 0) {
+        ret = h264_field_start(h, sl, nal, first_slice);
+        if (ret < 0)
+            return ret;
+    } else {
+        if (h->picture_structure != sl->picture_structure ||
+            h->droppable         != (nal->ref_idc == 0)) {
+            av_log(h->avctx, AV_LOG_ERROR,
+                   "Changing field mode (%d -> %d) between slices is not allowed\n",
+                   h->picture_structure, sl->picture_structure);
+            return AVERROR_INVALIDDATA;
+        } else if (!h->cur_pic_ptr) {
+            av_log(h->avctx, AV_LOG_ERROR,
+                   "unset cur_pic_ptr on slice %d\n",
+                   h->current_slice + 1);
+            return AVERROR_INVALIDDATA;
+        }
+    }
+
+    ret = h264_slice_init(h, sl, nal);
+    if (ret < 0)
+        return ret;
+
+    h->nb_slice_ctx_queued++;
+
+    return 0;
+}
+
 int ff_h264_get_slice_type(const H264SliceContext *sl)
 {
     switch (sl->slice_type) {
@@ -2583,33 +2727,35 @@ static int decode_slice(struct AVCodecContext *avctx, void *arg)
  * Call decode_slice() for each context.
  *
  * @param h h264 master context
- * @param context_count number of contexts to execute
  */
-int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count)
+int ff_h264_execute_decode_slices(H264Context *h)
 {
     AVCodecContext *const avctx = h->avctx;
     H264SliceContext *sl;
+    int context_count = h->nb_slice_ctx_queued;
+    int ret = 0;
     int i, j;
 
-    av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
-
     h->slice_ctx[0].next_slice_idx = INT_MAX;
 
-    if (h->avctx->hwaccel
+    if (h->avctx->hwaccel || context_count < 1
 #if FF_API_CAP_VDPAU
         || h->avctx->codec->capabilities & AV_CODEC_CAP_HWACCEL_VDPAU
 #endif
         )
         return 0;
+
+    av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
+
     if (context_count == 1) {
-        int ret;
 
         h->slice_ctx[0].next_slice_idx = h->mb_width * h->mb_height;
         h->postpone_filter = 0;
 
         ret = decode_slice(avctx, &h->slice_ctx[0]);
         h->mb_y = h->slice_ctx[0].mb_y;
-        return ret;
+        if (ret < 0)
+            goto finish;
     } else {
         av_assert0(context_count > 0);
         for (i = 0; i < context_count; i++) {
@@ -2664,5 +2810,7 @@ int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count)
         }
     }
 
-    return 0;
+finish:
+    h->nb_slice_ctx_queued = 0;
+    return ret;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/h264chroma.h b/mythtv/external/FFmpeg/libavcodec/h264chroma.h
index e0f45ad13bd..5c89fd12df6 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264chroma.h
+++ b/mythtv/external/FFmpeg/libavcodec/h264chroma.h
@@ -19,9 +19,10 @@
 #ifndef AVCODEC_H264CHROMA_H
 #define AVCODEC_H264CHROMA_H
 
+#include <stddef.h>
 #include <stdint.h>
 
-typedef void (*h264_chroma_mc_func)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x, int y);
+typedef void (*h264_chroma_mc_func)(uint8_t *dst /*align 8*/, uint8_t *src /*align 1*/, ptrdiff_t srcStride, int h, int x, int y);
 
 typedef struct H264ChromaContext {
     h264_chroma_mc_func put_h264_chroma_pixels_tab[4];
diff --git a/mythtv/external/FFmpeg/libavcodec/h264chroma_template.c b/mythtv/external/FFmpeg/libavcodec/h264chroma_template.c
index 072b5e03f75..a3ca07b518f 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264chroma_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264chroma_template.c
@@ -19,12 +19,14 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "libavutil/avassert.h"
 
+#include <stddef.h>
+
+#include "libavutil/avassert.h"
 #include "bit_depth_template.c"
 
 #define H264_CHROMA_MC(OPNAME, OP)\
-static void FUNCC(OPNAME ## h264_chroma_mc1)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
+static void FUNCC(OPNAME ## h264_chroma_mc1)(uint8_t *_dst /*align 8*/, uint8_t *_src /*align 1*/, ptrdiff_t stride, int h, int x, int y){\
     pixel *dst = (pixel*)_dst;\
     pixel *src = (pixel*)_src;\
     const int A=(8-x)*(8-y);\
@@ -58,7 +60,8 @@ static void FUNCC(OPNAME ## h264_chroma_mc1)(uint8_t *_dst/*align 8*/, uint8_t *
         }\
     }\
 }\
-static void FUNCC(OPNAME ## h264_chroma_mc2)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
+static void FUNCC(OPNAME ## h264_chroma_mc2)(uint8_t *_dst /*align 8*/, uint8_t *_src /*align 1*/, ptrdiff_t stride, int h, int x, int y)\
+{\
     pixel *dst = (pixel*)_dst;\
     pixel *src = (pixel*)_src;\
     const int A=(8-x)*(8-y);\
@@ -79,7 +82,7 @@ static void FUNCC(OPNAME ## h264_chroma_mc2)(uint8_t *_dst/*align 8*/, uint8_t *
         }\
     } else if (B + C) {\
         const int E= B+C;\
-        const int step= C ? stride : 1;\
+        const ptrdiff_t step = C ? stride : 1;\
         for(i=0; i<h; i++){\
             OP(dst[0], (A*src[0] + E*src[step+0]));\
             OP(dst[1], (A*src[1] + E*src[step+1]));\
@@ -96,7 +99,8 @@ static void FUNCC(OPNAME ## h264_chroma_mc2)(uint8_t *_dst/*align 8*/, uint8_t *
     }\
 }\
 \
-static void FUNCC(OPNAME ## h264_chroma_mc4)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
+static void FUNCC(OPNAME ## h264_chroma_mc4)(uint8_t *_dst /*align 8*/, uint8_t *_src /*align 1*/, ptrdiff_t stride, int h, int x, int y)\
+{\
     pixel *dst = (pixel*)_dst;\
     pixel *src = (pixel*)_src;\
     const int A=(8-x)*(8-y);\
@@ -119,7 +123,7 @@ static void FUNCC(OPNAME ## h264_chroma_mc4)(uint8_t *_dst/*align 8*/, uint8_t *
         }\
     } else if (B + C) {\
         const int E= B+C;\
-        const int step= C ? stride : 1;\
+        const ptrdiff_t step = C ? stride : 1;\
         for(i=0; i<h; i++){\
             OP(dst[0], (A*src[0] + E*src[step+0]));\
             OP(dst[1], (A*src[1] + E*src[step+1]));\
@@ -140,7 +144,8 @@ static void FUNCC(OPNAME ## h264_chroma_mc4)(uint8_t *_dst/*align 8*/, uint8_t *
     }\
 }\
 \
-static void FUNCC(OPNAME ## h264_chroma_mc8)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
+static void FUNCC(OPNAME ## h264_chroma_mc8)(uint8_t *_dst /*align 8*/, uint8_t *_src /*align 1*/, ptrdiff_t stride, int h, int x, int y)\
+{\
     pixel *dst = (pixel*)_dst;\
     pixel *src = (pixel*)_src;\
     const int A=(8-x)*(8-y);\
@@ -167,7 +172,7 @@ static void FUNCC(OPNAME ## h264_chroma_mc8)(uint8_t *_dst/*align 8*/, uint8_t *
         }\
     } else if (B + C) {\
         const int E= B+C;\
-        const int step= C ? stride : 1;\
+        const ptrdiff_t step = C ? stride : 1;\
         for(i=0; i<h; i++){\
             OP(dst[0], (A*src[0] + E*src[step+0]));\
             OP(dst[1], (A*src[1] + E*src[step+1]));\
diff --git a/mythtv/external/FFmpeg/libavcodec/h264dec.c b/mythtv/external/FFmpeg/libavcodec/h264dec.c
index ed0b7246b74..f29c3f90488 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264dec.c
@@ -55,8 +55,6 @@
 #include "thread.h"
 #include "vdpau_compat.h"
 
-static int h264_decode_end(AVCodecContext *avctx);
-
 const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 };
 
 int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
@@ -285,7 +283,7 @@ int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
                           mb_array_size * sizeof(uint8_t), fail);
 
         FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer,
-                         h->mb_height * h->mb_stride, fail);
+                         h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail);
 
         FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base,
                           yc_size * sizeof(int16_t), fail);
@@ -307,11 +305,11 @@ static int h264_init_context(AVCodecContext *avctx, H264Context *h)
     int i;
 
     h->avctx                 = avctx;
-    h->backup_width          = -1;
-    h->backup_height         = -1;
-    h->backup_pix_fmt        = AV_PIX_FMT_NONE;
     h->cur_chroma_format_idc = -1;
 
+    h->width_from_caller     = avctx->width;
+    h->height_from_caller    = avctx->height;
+
     h->picture_structure     = PICT_FRAME;
     h->workaround_bugs       = avctx->workaround_bugs;
     h->flags                 = avctx->flags;
@@ -391,7 +389,7 @@ static av_cold int h264_decode_end(AVCodecContext *avctx)
 
 static AVOnce h264_vlc_init = AV_ONCE_INIT;
 
-av_cold int ff_h264_decode_init(AVCodecContext *avctx)
+static av_cold int h264_decode_init(AVCodecContext *avctx)
 {
     H264Context *h = avctx->priv_data;
     int ret;
@@ -466,130 +464,6 @@ static int decode_init_thread_copy(AVCodecContext *avctx)
 }
 #endif
 
-/**
- * Run setup operations that must be run after slice header decoding.
- * This includes finding the next displayed frame.
- *
- * @param h h264 master context
- * @param setup_finished enough NALs have been read that we can call
- * ff_thread_finish_setup()
- */
-static void decode_postinit(H264Context *h, int setup_finished)
-{
-    const SPS *sps = h->ps.sps;
-    H264Picture *out = h->cur_pic_ptr;
-    H264Picture *cur = h->cur_pic_ptr;
-    int i, pics, out_of_order, out_idx;
-
-    if (h->next_output_pic)
-        return;
-
-    if (cur->field_poc[0] == INT_MAX || cur->field_poc[1] == INT_MAX) {
-        /* FIXME: if we have two PAFF fields in one packet, we can't start
-         * the next thread here. If we have one field per packet, we can.
-         * The check in decode_nal_units() is not good enough to find this
-         * yet, so we assume the worst for now. */
-        // if (setup_finished)
-        //    ff_thread_finish_setup(h->avctx);
-        if (cur->field_poc[0] == INT_MAX && cur->field_poc[1] == INT_MAX)
-            return;
-        if (h->avctx->hwaccel || h->missing_fields <=1)
-            return;
-    }
-
-    cur->mmco_reset = h->mmco_reset;
-    h->mmco_reset = 0;
-
-    // FIXME do something with unavailable reference frames
-
-    /* Sort B-frames into display order */
-    if (sps->bitstream_restriction_flag ||
-        h->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
-        h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, sps->num_reorder_frames);
-    }
-
-    for (i = 0; 1; i++) {
-        if(i == MAX_DELAYED_PIC_COUNT || cur->poc < h->last_pocs[i]){
-            if(i)
-                h->last_pocs[i-1] = cur->poc;
-            break;
-        } else if(i) {
-            h->last_pocs[i-1]= h->last_pocs[i];
-        }
-    }
-    out_of_order = MAX_DELAYED_PIC_COUNT - i;
-    if(   cur->f->pict_type == AV_PICTURE_TYPE_B
-       || (h->last_pocs[MAX_DELAYED_PIC_COUNT-2] > INT_MIN && h->last_pocs[MAX_DELAYED_PIC_COUNT-1] - h->last_pocs[MAX_DELAYED_PIC_COUNT-2] > 2))
-        out_of_order = FFMAX(out_of_order, 1);
-    if (out_of_order == MAX_DELAYED_PIC_COUNT) {
-        av_log(h->avctx, AV_LOG_VERBOSE, "Invalid POC %d<%d\n", cur->poc, h->last_pocs[0]);
-        for (i = 1; i < MAX_DELAYED_PIC_COUNT; i++)
-            h->last_pocs[i] = INT_MIN;
-        h->last_pocs[0] = cur->poc;
-        cur->mmco_reset = 1;
-    } else if(h->avctx->has_b_frames < out_of_order && !sps->bitstream_restriction_flag){
-        int loglevel = h->avctx->frame_number > 1 ? AV_LOG_WARNING : AV_LOG_VERBOSE;
-        av_log(h->avctx, loglevel, "Increasing reorder buffer to %d\n", out_of_order);
-        h->avctx->has_b_frames = out_of_order;
-    }
-
-    pics = 0;
-    while (h->delayed_pic[pics])
-        pics++;
-
-    av_assert0(pics <= MAX_DELAYED_PIC_COUNT);
-
-    h->delayed_pic[pics++] = cur;
-    if (cur->reference == 0)
-        cur->reference = DELAYED_PIC_REF;
-
-    out     = h->delayed_pic[0];
-    out_idx = 0;
-    for (i = 1; h->delayed_pic[i] &&
-                !h->delayed_pic[i]->f->key_frame &&
-                !h->delayed_pic[i]->mmco_reset;
-         i++)
-        if (h->delayed_pic[i]->poc < out->poc) {
-            out     = h->delayed_pic[i];
-            out_idx = i;
-        }
-    if (h->avctx->has_b_frames == 0 &&
-        (h->delayed_pic[0]->f->key_frame || h->delayed_pic[0]->mmco_reset))
-        h->next_outputed_poc = INT_MIN;
-    out_of_order = out->poc < h->next_outputed_poc;
-
-    if (out_of_order || pics > h->avctx->has_b_frames) {
-        out->reference &= ~DELAYED_PIC_REF;
-        for (i = out_idx; h->delayed_pic[i]; i++)
-            h->delayed_pic[i] = h->delayed_pic[i + 1];
-    }
-    if (!out_of_order && pics > h->avctx->has_b_frames) {
-        h->next_output_pic = out;
-        if (out_idx == 0 && h->delayed_pic[0] && (h->delayed_pic[0]->f->key_frame || h->delayed_pic[0]->mmco_reset)) {
-            h->next_outputed_poc = INT_MIN;
-        } else
-            h->next_outputed_poc = out->poc;
-    } else {
-        av_log(h->avctx, AV_LOG_DEBUG, "no picture %s\n", out_of_order ? "ooo" : "");
-    }
-
-    if (h->next_output_pic) {
-        if (h->next_output_pic->recovered) {
-            // We have reached an recovery point and all frames after it in
-            // display order are "recovered".
-            h->frame_recovered |= FRAME_RECOVERED_SEI;
-        }
-        h->next_output_pic->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_SEI);
-    }
-
-    if (setup_finished && !h->avctx->hwaccel) {
-        ff_thread_finish_setup(h->avctx);
-
-        if (h->avctx->active_thread_type & FF_THREAD_FRAME)
-            h->setup_finished = 1;
-    }
-}
-
 /**
  * instantaneous decoder refresh.
  */
@@ -625,7 +499,6 @@ void ff_h264_flush_change(H264Context *h)
     ff_h264_unref_picture(h, &h->last_pic_for_ec);
 
     h->first_field = 0;
-    ff_h264_sei_uninit(&h->sei);
     h->recovery_frame = -1;
     h->frame_recovered = 0;
     h->current_slice = 0;
@@ -641,6 +514,7 @@ static void flush_dpb(AVCodecContext *avctx)
     memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
 
     ff_h264_flush_change(h);
+    ff_h264_sei_uninit(&h->sei);
 
     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++)
         ff_h264_unref_picture(h, &h->DPB[i]);
@@ -661,8 +535,7 @@ static int get_last_needed_nal(H264Context *h)
 {
     int nals_needed = 0;
     int first_slice = 0;
-    int i;
-    int ret;
+    int i, ret;
 
     for (i = 0; i < h->pkt.nb_nals; i++) {
         H2645NAL *nal = &h->pkt.nals[i];
@@ -680,9 +553,14 @@ static int get_last_needed_nal(H264Context *h)
         case H264_NAL_DPA:
         case H264_NAL_IDR_SLICE:
         case H264_NAL_SLICE:
-            ret = init_get_bits8(&gb, nal->data + 1, (nal->size - 1));
-            if (ret < 0)
-                return ret;
+            ret = init_get_bits8(&gb, nal->data + 1, nal->size - 1);
+            if (ret < 0) {
+                av_log(h->avctx, AV_LOG_ERROR, "Invalid zero-sized VCL NAL unit\n");
+                if (h->avctx->err_recognition & AV_EF_EXPLODE)
+                    return ret;
+
+                break;
+            }
             if (!get_ue_golomb_long(&gb) ||  // first_mb_in_slice
                 !first_slice ||
                 first_slice != nal->type)
@@ -726,14 +604,13 @@ static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)
 static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
 {
     AVCodecContext *const avctx = h->avctx;
-    unsigned context_count = 0;
     int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
     int idr_cleared=0;
     int i, ret = 0;
 
+    h->has_slice = 0;
     h->nal_unit_type= 0;
 
-    h->max_contexts = h->nb_slice_ctx;
     if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
         h->current_slice = 0;
         if (!h->first_field)
@@ -763,14 +640,12 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
 
     for (i = 0; i < h->pkt.nb_nals; i++) {
         H2645NAL *nal = &h->pkt.nals[i];
-        H264SliceContext *sl = &h->slice_ctx[context_count];
-        int err;
+        int max_slice_ctx, err;
 
         if (avctx->skip_frame >= AVDISCARD_NONREF &&
             nal->ref_idc == 0 && nal->type != H264_NAL_SEI)
             continue;
 
-again:
         // FIXME these should stop being context-global variables
         h->nal_ref_idc   = nal->ref_idc;
         h->nal_unit_type = nal->type;
@@ -795,17 +670,20 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
             idr_cleared = 1;
             h->has_recovery_point = 1;
         case H264_NAL_SLICE:
-            sl->gb = nal->gb;
-
-            if ((err = ff_h264_decode_slice_header(h, sl, nal)))
-                break;
+            h->has_slice = 1;
 
-            if (sl->redundant_pic_count > 0)
+            if ((err = ff_h264_queue_decode_slice(h, nal))) {
+                H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
+                sl->ref_count[0] = sl->ref_count[1] = 0;
                 break;
+            }
 
             if (h->current_slice == 1) {
-                if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS))
-                    decode_postinit(h, i >= nals_needed);
+                if (avctx->active_thread_type & FF_THREAD_FRAME &&
+                    i >= nals_needed && !h->setup_finished && h->cur_pic_ptr) {
+                    ff_thread_finish_setup(avctx);
+                    h->setup_finished = 1;
+                }
 
                 if (h->avctx->hwaccel &&
                     (ret = h->avctx->hwaccel->start_frame(h->avctx, buf, buf_size)) < 0)
@@ -817,14 +695,14 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
 #endif
             }
 
-            if (avctx->hwaccel) {
-                ret = avctx->hwaccel->decode_slice(avctx,
-                                                   nal->raw_data,
-                                                   nal->raw_size);
-                if (ret < 0)
-                    goto end;
+            max_slice_ctx = avctx->hwaccel ? 1 : h->nb_slice_ctx;
+            if (h->nb_slice_ctx_queued == max_slice_ctx) {
+                if (h->avctx->hwaccel) {
+                    ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size);
+                    h->nb_slice_ctx_queued = 0;
+                } else
 #if FF_API_CAP_VDPAU
-            } else if (CONFIG_H264_VDPAU_DECODER &&
+            if (CONFIG_H264_VDPAU_DECODER &&
                        h->avctx->codec->capabilities & AV_CODEC_CAP_HWACCEL_VDPAU) {
                 ff_vdpau_add_data_chunk(h->cur_pic_ptr->f->data[0],
                                         start_code,
@@ -832,9 +710,13 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
                 ff_vdpau_add_data_chunk(h->cur_pic_ptr->f->data[0],
                                         nal->raw_data,
                                         nal->raw_size);
-#endif
+                ret = 0;
             } else
-                context_count++;
+#endif
+                    ret = ff_h264_execute_decode_slices(h);
+                if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
+                    goto end;
+            }
             break;
         case H264_NAL_DPA:
         case H264_NAL_DPB:
@@ -884,34 +766,14 @@ FF_ENABLE_DEPRECATION_WARNINGS
                    nal->type, nal->size_bits);
         }
 
-        if (context_count == h->max_contexts) {
-            ret = ff_h264_execute_decode_slices(h, context_count);
-            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
-                goto end;
-            context_count = 0;
-        }
-
-        if (err < 0 || err == SLICE_SKIPED) {
-            if (err < 0)
-                av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
-            sl->ref_count[0] = sl->ref_count[1] = sl->list_count = 0;
-        } else if (err == SLICE_SINGLETHREAD) {
-            if (context_count > 0) {
-                ret = ff_h264_execute_decode_slices(h, context_count);
-                if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
-                    goto end;
-                context_count = 0;
-            }
-            /* Slice could not be decoded in parallel mode, restart. */
-            sl               = &h->slice_ctx[0];
-            goto again;
+        if (err < 0) {
+            av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
         }
     }
-    if (context_count) {
-        ret = ff_h264_execute_decode_slices(h, context_count);
-        if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
-            goto end;
-    }
+
+    ret = ff_h264_execute_decode_slices(h);
+    if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
+        goto end;
 
     ret = 0;
 end:
@@ -960,7 +822,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
     }
 #endif /* CONFIG_ERROR_RESILIENCE */
     /* clean up */
-    if (h->cur_pic_ptr && !h->droppable) {
+    if (h->cur_pic_ptr && !h->droppable && h->has_slice) {
         ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
                                   h->picture_structure == PICT_BOTTOM_FIELD);
     }
@@ -984,34 +846,20 @@ static int get_consumed_bytes(int pos, int buf_size)
 static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
 {
     AVFrame *src = srcp->f;
-    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(src->format);
-    int i;
-    int ret = av_frame_ref(dst, src);
+    int ret;
+
+    if (src->format == AV_PIX_FMT_VIDEOTOOLBOX && src->buf[0]->size == 1)
+        return AVERROR_EXTERNAL;
+
+    ret = av_frame_ref(dst, src);
     if (ret < 0)
         return ret;
 
     av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.frame_packing), 0);
 
-    h->backup_width   = h->avctx->width;
-    h->backup_height  = h->avctx->height;
-    h->backup_pix_fmt = h->avctx->pix_fmt;
-
-    h->avctx->width   = dst->width;
-    h->avctx->height  = dst->height;
-    h->avctx->pix_fmt = dst->format;
-
     if (srcp->sei_recovery_frame_cnt == 0)
         dst->key_frame = 1;
-    if (!srcp->crop)
-        return 0;
 
-    for (i = 0; i < desc->nb_components; i++) {
-        int hshift = (i > 0) ? desc->log2_chroma_w : 0;
-        int vshift = (i > 0) ? desc->log2_chroma_h : 0;
-        int off    = ((srcp->crop_left >> hshift) << h->pixel_shift) +
-                      (srcp->crop_top  >> vshift) * dst->linesize[i];
-        dst->data[i] += off;
-    }
     return 0;
 }
 
@@ -1037,6 +885,89 @@ static int is_extra(const uint8_t *buf, int buf_size)
     return 1;
 }
 
+static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
+{
+    int ret;
+
+    if (((h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) ||
+         (h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) ||
+         out->recovered)) {
+
+        if (!h->avctx->hwaccel &&
+            (out->field_poc[0] == INT_MAX ||
+             out->field_poc[1] == INT_MAX)
+           ) {
+            int p;
+            AVFrame *f = out->f;
+            int field = out->field_poc[0] == INT_MAX;
+            uint8_t *dst_data[4];
+            int linesizes[4];
+            const uint8_t *src_data[4];
+
+            av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field);
+
+            for (p = 0; p<4; p++) {
+                dst_data[p] = f->data[p] + (field^1)*f->linesize[p];
+                src_data[p] = f->data[p] +  field   *f->linesize[p];
+                linesizes[p] = 2*f->linesize[p];
+            }
+
+            av_image_copy(dst_data, linesizes, src_data, linesizes,
+                          f->format, f->width, f->height>>1);
+        }
+
+        ret = output_frame(h, dst, out);
+        if (ret < 0)
+            return ret;
+
+        *got_frame = 1;
+
+        if (CONFIG_MPEGVIDEO) {
+            ff_print_debug_info2(h->avctx, dst, NULL,
+                                 out->mb_type,
+                                 out->qscale_table,
+                                 out->motion_val,
+                                 NULL,
+                                 h->mb_width, h->mb_height, h->mb_stride, 1);
+        }
+    }
+
+    return 0;
+}
+
+static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame,
+                                   int *got_frame, int buf_index)
+{
+    int ret, i, out_idx;
+    H264Picture *out = h->delayed_pic[0];
+
+    h->cur_pic_ptr = NULL;
+    h->first_field = 0;
+
+    out_idx = 0;
+    for (i = 1;
+         h->delayed_pic[i] &&
+         !h->delayed_pic[i]->f->key_frame &&
+         !h->delayed_pic[i]->mmco_reset;
+         i++)
+        if (h->delayed_pic[i]->poc < out->poc) {
+            out     = h->delayed_pic[i];
+            out_idx = i;
+        }
+
+    for (i = out_idx; h->delayed_pic[i]; i++)
+        h->delayed_pic[i] = h->delayed_pic[i + 1];
+
+    if (out) {
+        out->reference &= ~DELAYED_PIC_REF;
+        ret = finalize_frame(h, dst_frame, out, got_frame);
+        if (ret < 0)
+            return ret;
+    }
+
+    return buf_index;
+}
+
 static int h264_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame, AVPacket *avpkt)
 {
@@ -1044,62 +975,19 @@ static int h264_decode_frame(AVCodecContext *avctx, void *data,
     int buf_size       = avpkt->size;
     H264Context *h     = avctx->priv_data;
     AVFrame *pict      = data;
-    int buf_index      = 0;
-    H264Picture *out;
-    int i, out_idx;
+    int buf_index;
     int ret;
 
     h->flags = avctx->flags;
     h->setup_finished = 0;
-
-    if (h->backup_width != -1) {
-        avctx->width    = h->backup_width;
-        h->backup_width = -1;
-    }
-    if (h->backup_height != -1) {
-        avctx->height    = h->backup_height;
-        h->backup_height = -1;
-    }
-    if (h->backup_pix_fmt != AV_PIX_FMT_NONE) {
-        avctx->pix_fmt    = h->backup_pix_fmt;
-        h->backup_pix_fmt = AV_PIX_FMT_NONE;
-    }
+    h->nb_slice_ctx_queued = 0;
 
     ff_h264_unref_picture(h, &h->last_pic_for_ec);
 
     /* end of stream, output what is still in the buffers */
-    if (buf_size == 0) {
- out:
-
-        h->cur_pic_ptr = NULL;
-        h->first_field = 0;
-
-        // FIXME factorize this with the output code below
-        out     = h->delayed_pic[0];
-        out_idx = 0;
-        for (i = 1;
-             h->delayed_pic[i] &&
-             !h->delayed_pic[i]->f->key_frame &&
-             !h->delayed_pic[i]->mmco_reset;
-             i++)
-            if (h->delayed_pic[i]->poc < out->poc) {
-                out     = h->delayed_pic[i];
-                out_idx = i;
-            }
-
-        for (i = out_idx; h->delayed_pic[i]; i++)
-            h->delayed_pic[i] = h->delayed_pic[i + 1];
-
-        if (out) {
-            out->reference &= ~DELAYED_PIC_REF;
-            ret = output_frame(h, pict, out);
-            if (ret < 0)
-                return ret;
-            *got_frame = 1;
-        }
+    if (buf_size == 0)
+        return send_next_delayed_frame(h, pict, got_frame, 0);
 
-        return buf_index;
-    }
     if (h->is_avc && av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) {
         int side_size;
         uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
@@ -1121,10 +1009,10 @@ static int h264_decode_frame(AVCodecContext *avctx, void *data,
 
     if (!h->cur_pic_ptr && h->nal_unit_type == H264_NAL_END_SEQUENCE) {
         av_assert0(buf_index <= buf_size);
-        goto out;
+        return send_next_delayed_frame(h, pict, got_frame, buf_index);
     }
 
-    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && !h->cur_pic_ptr) {
+    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && (!h->cur_pic_ptr || !h->has_slice)) {
         if (avctx->skip_frame >= AVDISCARD_NONREF ||
             buf_size >= 4 && !memcmp("Q264", buf, 4))
             return buf_size;
@@ -1134,55 +1022,14 @@ static int h264_decode_frame(AVCodecContext *avctx, void *data,
 
     if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) ||
         (h->mb_y >= h->mb_height && h->mb_height)) {
-        if (avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)
-            decode_postinit(h, 1);
-
         if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0)
             return ret;
 
         /* Wait for second field. */
-        *got_frame = 0;
-        if (h->next_output_pic && ((avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) ||
-                                   (avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) ||
-                                   h->next_output_pic->recovered)) {
-            if (!h->next_output_pic->recovered)
-                h->next_output_pic->f->flags |= AV_FRAME_FLAG_CORRUPT;
-
-            if (!h->avctx->hwaccel &&
-                 (h->next_output_pic->field_poc[0] == INT_MAX ||
-                  h->next_output_pic->field_poc[1] == INT_MAX)
-            ) {
-                int p;
-                AVFrame *f = h->next_output_pic->f;
-                int field = h->next_output_pic->field_poc[0] == INT_MAX;
-                uint8_t *dst_data[4];
-                int linesizes[4];
-                const uint8_t *src_data[4];
-
-                av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field);
-
-                for (p = 0; p<4; p++) {
-                    dst_data[p] = f->data[p] + (field^1)*f->linesize[p];
-                    src_data[p] = f->data[p] +  field   *f->linesize[p];
-                    linesizes[p] = 2*f->linesize[p];
-                }
-
-                av_image_copy(dst_data, linesizes, src_data, linesizes,
-                              f->format, f->width, f->height>>1);
-            }
-
-            ret = output_frame(h, pict, h->next_output_pic);
+        if (h->next_output_pic) {
+            ret = finalize_frame(h, pict, h->next_output_pic, got_frame);
             if (ret < 0)
                 return ret;
-            *got_frame = 1;
-            if (CONFIG_MPEGVIDEO) {
-                ff_print_debug_info2(h->avctx, pict, NULL,
-                                    h->next_output_pic->mb_type,
-                                    h->next_output_pic->qscale_table,
-                                    h->next_output_pic->motion_val,
-                                    NULL,
-                                    h->mb_width, h->mb_height, h->mb_stride, 1);
-            }
         }
     }
 
@@ -1196,8 +1043,8 @@ static int h264_decode_frame(AVCodecContext *avctx, void *data,
 #define OFFSET(x) offsetof(H264Context, x)
 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
 static const AVOption h264_options[] = {
-    {"is_avc", "is avc", offsetof(H264Context, is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0},
-    {"nal_length_size", "nal_length_size", offsetof(H264Context, nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0},
+    { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0 },
+    { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0 },
     { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD },
     { NULL },
 };
@@ -1215,13 +1062,13 @@ AVCodec ff_h264_decoder = {
     .type                  = AVMEDIA_TYPE_VIDEO,
     .id                    = AV_CODEC_ID_H264,
     .priv_data_size        = sizeof(H264Context),
-    .init                  = ff_h264_decode_init,
+    .init                  = h264_decode_init,
     .close                 = h264_decode_end,
     .decode                = h264_decode_frame,
     .capabilities          = /*AV_CODEC_CAP_DRAW_HORIZ_BAND |*/ AV_CODEC_CAP_DR1 |
                              AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS |
                              AV_CODEC_CAP_FRAME_THREADS,
-    .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE,
+    .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING,
     .flush                 = flush_dpb,
     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
     .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context),
@@ -1243,7 +1090,7 @@ AVCodec ff_h264_vdpau_decoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H264,
     .priv_data_size = sizeof(H264Context),
-    .init           = ff_h264_decode_init,
+    .init           = h264_decode_init,
     .close          = h264_decode_end,
     .decode         = h264_decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
diff --git a/mythtv/external/FFmpeg/libavcodec/h264dec.h b/mythtv/external/FFmpeg/libavcodec/h264dec.h
index c8b7e663b3d..de8b7c38b93 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264dec.h
+++ b/mythtv/external/FFmpeg/libavcodec/h264dec.h
@@ -161,10 +161,6 @@ typedef struct H264Picture {
     int recovered;          ///< picture at IDR or recovery point + recovery count
     int invalid_gap;
     int sei_recovery_frame_cnt;
-
-    int crop;
-    int crop_left;
-    int crop_top;
 } H264Picture;
 
 typedef struct H264Ref {
@@ -353,6 +349,7 @@ typedef struct H264Context {
 
     H264SliceContext *slice_ctx;
     int            nb_slice_ctx;
+    int            nb_slice_ctx_queued;
 
     H2645Packet pkt;
 
@@ -362,14 +359,6 @@ typedef struct H264Context {
     int width, height;
     int chroma_x_shift, chroma_y_shift;
 
-    /**
-     * Backup frame properties: needed, because they can be different
-     * between returned frame and last decoded frame.
-     **/
-    int backup_width;
-    int backup_height;
-    enum AVPixelFormat backup_pix_fmt;
-
     int droppable;
     int coded_picture_number;
 
@@ -387,6 +376,11 @@ typedef struct H264Context {
      */
     int picture_idr;
 
+    int crop_left;
+    int crop_right;
+    int crop_top;
+    int crop_bottom;
+
     int8_t(*intra4x4_pred_mode);
     H264PredContext hpc;
 
@@ -422,6 +416,7 @@ typedef struct H264Context {
     uint8_t (*mvd_table[2])[2];
     uint8_t *direct_table;
 
+    uint8_t scan_padding[16];
     uint8_t zigzag_scan[16];
     uint8_t zigzag_scan8x8[64];
     uint8_t zigzag_scan8x8_cavlc[64];
@@ -446,6 +441,8 @@ typedef struct H264Context {
     int nal_ref_idc;
     int nal_unit_type;
 
+    int has_slice;          ///< slice NAL is found in the packet, set by decode_nal_units, its state does not need to be preserved outside h264_decode_frame()
+
     /**
      * Used to parse AVC variant of H.264
      */
@@ -489,20 +486,6 @@ typedef struct H264Context {
      */
     int current_slice;
 
-    /**
-     * Max number of threads / contexts.
-     * This is equal to AVCodecContext.thread_count unless
-     * multithreaded decoding is impossible, in which case it is
-     * reduced to 1.
-     */
-    int max_contexts;
-
-    /**
-     *  1 if the single thread fallback warning has already been
-     *  displayed, 0 otherwise.
-     */
-    int single_decode_warning;
-
     /** @} */
 
     /**
@@ -553,6 +536,11 @@ typedef struct H264Context {
     int cur_bit_depth_luma;
     int16_t slice_row[MAX_SLICES]; ///< to detect when MAX_SLICES is too low
 
+    /* original AVCodecContext dimensions, used to handle container
+     * cropping */
+    int width_from_caller;
+    int height_from_caller;
+
     int enable_er;
 
     H264SEIContext sei;
@@ -590,7 +578,6 @@ int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb,
                                    const H2645NAL *nal, void *logctx);
 
 void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl);
-int ff_h264_decode_init(AVCodecContext *avctx);
 void ff_h264_decode_init_vlc(void);
 
 /**
@@ -846,10 +833,14 @@ void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y,
 
 int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl,
                                 const H2645NAL *nal);
-#define SLICE_SINGLETHREAD 1
-#define SLICE_SKIPED 2
-
-int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count);
+/**
+ * Submit a slice for decoding.
+ *
+ * Parse the slice header, starting a new field/frame if necessary. If any
+ * slices are queued for the previous field, they are decoded.
+ */
+int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal);
+int ff_h264_execute_decode_slices(H264Context *h);
 int ff_h264_update_thread_context(AVCodecContext *dst,
                                   const AVCodecContext *src);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/h264idct_template.c b/mythtv/external/FFmpeg/libavcodec/h264idct_template.c
index a90c4073880..5993ae2e6e7 100644
--- a/mythtv/external/FFmpeg/libavcodec/h264idct_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/h264idct_template.c
@@ -40,10 +40,10 @@ void FUNCC(ff_h264_idct_add)(uint8_t *_dst, int16_t *_block, int stride)
     block[0] += 1 << 5;
 
     for(i=0; i<4; i++){
-        const int z0=  block[i + 4*0]     +  block[i + 4*2];
-        const int z1=  block[i + 4*0]     -  block[i + 4*2];
-        const int z2= (block[i + 4*1]>>1) -  block[i + 4*3];
-        const int z3=  block[i + 4*1]     + (block[i + 4*3]>>1);
+        const SUINT z0=  block[i + 4*0]     +  (unsigned)block[i + 4*2];
+        const SUINT z1=  block[i + 4*0]     -  (unsigned)block[i + 4*2];
+        const SUINT z2= (block[i + 4*1]>>1) -  (unsigned)block[i + 4*3];
+        const SUINT z3=  block[i + 4*1]     + (unsigned)(block[i + 4*3]>>1);
 
         block[i + 4*0]= z0 + z3;
         block[i + 4*1]= z1 + z2;
@@ -52,15 +52,15 @@ void FUNCC(ff_h264_idct_add)(uint8_t *_dst, int16_t *_block, int stride)
     }
 
     for(i=0; i<4; i++){
-        const int z0=  block[0 + 4*i]     +  block[2 + 4*i];
-        const int z1=  block[0 + 4*i]     -  block[2 + 4*i];
-        const int z2= (block[1 + 4*i]>>1) -  block[3 + 4*i];
-        const int z3=  block[1 + 4*i]     + (block[3 + 4*i]>>1);
-
-        dst[i + 0*stride]= av_clip_pixel(dst[i + 0*stride] + ((z0 + z3) >> 6));
-        dst[i + 1*stride]= av_clip_pixel(dst[i + 1*stride] + ((z1 + z2) >> 6));
-        dst[i + 2*stride]= av_clip_pixel(dst[i + 2*stride] + ((z1 - z2) >> 6));
-        dst[i + 3*stride]= av_clip_pixel(dst[i + 3*stride] + ((z0 - z3) >> 6));
+        const SUINT z0=  block[0 + 4*i]     +  (SUINT)block[2 + 4*i];
+        const SUINT z1=  block[0 + 4*i]     -  (SUINT)block[2 + 4*i];
+        const SUINT z2= (block[1 + 4*i]>>1) -  (SUINT)block[3 + 4*i];
+        const SUINT z3=  block[1 + 4*i]     + (SUINT)(block[3 + 4*i]>>1);
+
+        dst[i + 0*stride]= av_clip_pixel(dst[i + 0*stride] + ((int)(z0 + z3) >> 6));
+        dst[i + 1*stride]= av_clip_pixel(dst[i + 1*stride] + ((int)(z1 + z2) >> 6));
+        dst[i + 2*stride]= av_clip_pixel(dst[i + 2*stride] + ((int)(z1 - z2) >> 6));
+        dst[i + 3*stride]= av_clip_pixel(dst[i + 3*stride] + ((int)(z0 - z3) >> 6));
     }
 
     memset(block, 0, 16 * sizeof(dctcoef));
@@ -76,25 +76,25 @@ void FUNCC(ff_h264_idct8_add)(uint8_t *_dst, int16_t *_block, int stride){
 
     for( i = 0; i < 8; i++ )
     {
-        const int a0 =  block[i+0*8] + block[i+4*8];
-        const int a2 =  block[i+0*8] - block[i+4*8];
-        const int a4 = (block[i+2*8]>>1) - block[i+6*8];
-        const int a6 = (block[i+6*8]>>1) + block[i+2*8];
-
-        const int b0 = a0 + a6;
-        const int b2 = a2 + a4;
-        const int b4 = a2 - a4;
-        const int b6 = a0 - a6;
-
-        const int a1 = -block[i+3*8] + block[i+5*8] - block[i+7*8] - (block[i+7*8]>>1);
-        const int a3 =  block[i+1*8] + block[i+7*8] - block[i+3*8] - (block[i+3*8]>>1);
-        const int a5 = -block[i+1*8] + block[i+7*8] + block[i+5*8] + (block[i+5*8]>>1);
-        const int a7 =  block[i+3*8] + block[i+5*8] + block[i+1*8] + (block[i+1*8]>>1);
-
-        const int b1 = (a7>>2) + a1;
-        const int b3 =  a3 + (a5>>2);
-        const int b5 = (a3>>2) - a5;
-        const int b7 =  a7 - (a1>>2);
+        const unsigned int a0 =  block[i+0*8] + (unsigned)block[i+4*8];
+        const unsigned int a2 =  block[i+0*8] - (unsigned)block[i+4*8];
+        const unsigned int a4 = (block[i+2*8]>>1) - (unsigned)block[i+6*8];
+        const unsigned int a6 = (block[i+6*8]>>1) + (unsigned)block[i+2*8];
+
+        const unsigned int b0 = a0 + a6;
+        const unsigned int b2 = a2 + a4;
+        const unsigned int b4 = a2 - a4;
+        const unsigned int b6 = a0 - a6;
+
+        const int a1 = -block[i+3*8] + (unsigned)block[i+5*8] - block[i+7*8] - (block[i+7*8]>>1);
+        const int a3 =  block[i+1*8] + (unsigned)block[i+7*8] - block[i+3*8] - (block[i+3*8]>>1);
+        const int a5 = -block[i+1*8] + (unsigned)block[i+7*8] + block[i+5*8] + (block[i+5*8]>>1);
+        const int a7 =  block[i+3*8] + (unsigned)block[i+5*8] + block[i+1*8] + (block[i+1*8]>>1);
+
+        const int b1 = (a7>>2) + (unsigned)a1;
+        const int b3 =  (unsigned)a3 + (a5>>2);
+        const int b5 = (a3>>2) - (unsigned)a5;
+        const int b7 =  (unsigned)a7 - (a1>>2);
 
         block[i+0*8] = b0 + b7;
         block[i+7*8] = b0 - b7;
@@ -107,34 +107,34 @@ void FUNCC(ff_h264_idct8_add)(uint8_t *_dst, int16_t *_block, int stride){
     }
     for( i = 0; i < 8; i++ )
     {
-        const int a0 =  block[0+i*8] + block[4+i*8];
-        const int a2 =  block[0+i*8] - block[4+i*8];
-        const int a4 = (block[2+i*8]>>1) - block[6+i*8];
-        const int a6 = (block[6+i*8]>>1) + block[2+i*8];
-
-        const int b0 = a0 + a6;
-        const int b2 = a2 + a4;
-        const int b4 = a2 - a4;
-        const int b6 = a0 - a6;
-
-        const int a1 = -block[3+i*8] + block[5+i*8] - block[7+i*8] - (block[7+i*8]>>1);
-        const int a3 =  block[1+i*8] + block[7+i*8] - block[3+i*8] - (block[3+i*8]>>1);
-        const int a5 = -block[1+i*8] + block[7+i*8] + block[5+i*8] + (block[5+i*8]>>1);
-        const int a7 =  block[3+i*8] + block[5+i*8] + block[1+i*8] + (block[1+i*8]>>1);
-
-        const int b1 = (a7>>2) + a1;
-        const int b3 =  a3 + (a5>>2);
-        const int b5 = (a3>>2) - a5;
-        const int b7 =  a7 - (a1>>2);
-
-        dst[i + 0*stride] = av_clip_pixel( dst[i + 0*stride] + ((b0 + b7) >> 6) );
-        dst[i + 1*stride] = av_clip_pixel( dst[i + 1*stride] + ((b2 + b5) >> 6) );
-        dst[i + 2*stride] = av_clip_pixel( dst[i + 2*stride] + ((b4 + b3) >> 6) );
-        dst[i + 3*stride] = av_clip_pixel( dst[i + 3*stride] + ((b6 + b1) >> 6) );
-        dst[i + 4*stride] = av_clip_pixel( dst[i + 4*stride] + ((b6 - b1) >> 6) );
-        dst[i + 5*stride] = av_clip_pixel( dst[i + 5*stride] + ((b4 - b3) >> 6) );
-        dst[i + 6*stride] = av_clip_pixel( dst[i + 6*stride] + ((b2 - b5) >> 6) );
-        dst[i + 7*stride] = av_clip_pixel( dst[i + 7*stride] + ((b0 - b7) >> 6) );
+        const unsigned a0 =  block[0+i*8] + (unsigned)block[4+i*8];
+        const unsigned a2 =  block[0+i*8] - (unsigned)block[4+i*8];
+        const unsigned a4 = (block[2+i*8]>>1) - (unsigned)block[6+i*8];
+        const unsigned a6 = (block[6+i*8]>>1) + (unsigned)block[2+i*8];
+
+        const unsigned b0 = a0 + a6;
+        const unsigned b2 = a2 + a4;
+        const unsigned b4 = a2 - a4;
+        const unsigned b6 = a0 - a6;
+
+        const int a1 = -(unsigned)block[3+i*8] + block[5+i*8] - block[7+i*8] - (block[7+i*8]>>1);
+        const int a3 =  (unsigned)block[1+i*8] + block[7+i*8] - block[3+i*8] - (block[3+i*8]>>1);
+        const int a5 = -(unsigned)block[1+i*8] + block[7+i*8] + block[5+i*8] + (block[5+i*8]>>1);
+        const int a7 =  (unsigned)block[3+i*8] + block[5+i*8] + block[1+i*8] + (block[1+i*8]>>1);
+
+        const unsigned b1 = (a7>>2) + (unsigned)a1;
+        const unsigned b3 =  (unsigned)a3 + (a5>>2);
+        const unsigned b5 = (a3>>2) - (unsigned)a5;
+        const unsigned b7 =  (unsigned)a7 - (a1>>2);
+
+        dst[i + 0*stride] = av_clip_pixel( dst[i + 0*stride] + ((int)(b0 + b7) >> 6) );
+        dst[i + 1*stride] = av_clip_pixel( dst[i + 1*stride] + ((int)(b2 + b5) >> 6) );
+        dst[i + 2*stride] = av_clip_pixel( dst[i + 2*stride] + ((int)(b4 + b3) >> 6) );
+        dst[i + 3*stride] = av_clip_pixel( dst[i + 3*stride] + ((int)(b6 + b1) >> 6) );
+        dst[i + 4*stride] = av_clip_pixel( dst[i + 4*stride] + ((int)(b6 - b1) >> 6) );
+        dst[i + 5*stride] = av_clip_pixel( dst[i + 5*stride] + ((int)(b4 - b3) >> 6) );
+        dst[i + 6*stride] = av_clip_pixel( dst[i + 6*stride] + ((int)(b2 - b5) >> 6) );
+        dst[i + 7*stride] = av_clip_pixel( dst[i + 7*stride] + ((int)(b0 - b7) >> 6) );
     }
 
     memset(block, 0, 64 * sizeof(dctcoef));
@@ -261,15 +261,15 @@ void FUNCC(ff_h264_luma_dc_dequant_idct)(int16_t *_output, int16_t *_input, int
 
     for(i=0; i<4; i++){
         const int offset= x_offset[i];
-        const int z0= temp[4*0+i] + temp[4*2+i];
-        const int z1= temp[4*0+i] - temp[4*2+i];
-        const int z2= temp[4*1+i] - temp[4*3+i];
-        const int z3= temp[4*1+i] + temp[4*3+i];
-
-        output[stride* 0+offset]= ((((z0 + z3)*qmul + 128 ) >> 8));
-        output[stride* 1+offset]= ((((z1 + z2)*qmul + 128 ) >> 8));
-        output[stride* 4+offset]= ((((z1 - z2)*qmul + 128 ) >> 8));
-        output[stride* 5+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));
+        const SUINT z0= temp[4*0+i] + temp[4*2+i];
+        const SUINT z1= temp[4*0+i] - temp[4*2+i];
+        const SUINT z2= temp[4*1+i] - temp[4*3+i];
+        const SUINT z3= temp[4*1+i] + temp[4*3+i];
+
+        output[stride* 0+offset]= (int)((z0 + z3)*qmul + 128 ) >> 8;
+        output[stride* 1+offset]= (int)((z1 + z2)*qmul + 128 ) >> 8;
+        output[stride* 4+offset]= (int)((z1 - z2)*qmul + 128 ) >> 8;
+        output[stride* 5+offset]= (int)((z0 - z3)*qmul + 128 ) >> 8;
     }
 #undef stride
 }
@@ -289,22 +289,22 @@ void FUNCC(ff_h264_chroma422_dc_dequant_idct)(int16_t *_block, int qmul){
 
     for(i=0; i<2; i++){
         const int offset= x_offset[i];
-        const int z0= temp[2*0+i] + temp[2*2+i];
-        const int z1= temp[2*0+i] - temp[2*2+i];
-        const int z2= temp[2*1+i] - temp[2*3+i];
-        const int z3= temp[2*1+i] + temp[2*3+i];
-
-        block[stride*0+offset]= ((z0 + z3)*qmul + 128) >> 8;
-        block[stride*1+offset]= ((z1 + z2)*qmul + 128) >> 8;
-        block[stride*2+offset]= ((z1 - z2)*qmul + 128) >> 8;
-        block[stride*3+offset]= ((z0 - z3)*qmul + 128) >> 8;
+        const SUINT z0= temp[2*0+i] + temp[2*2+i];
+        const SUINT z1= temp[2*0+i] - temp[2*2+i];
+        const SUINT z2= temp[2*1+i] - temp[2*3+i];
+        const SUINT z3= temp[2*1+i] + temp[2*3+i];
+
+        block[stride*0+offset]= (int)((z0 + z3)*qmul + 128) >> 8;
+        block[stride*1+offset]= (int)((z1 + z2)*qmul + 128) >> 8;
+        block[stride*2+offset]= (int)((z1 - z2)*qmul + 128) >> 8;
+        block[stride*3+offset]= (int)((z0 - z3)*qmul + 128) >> 8;
     }
 }
 
 void FUNCC(ff_h264_chroma_dc_dequant_idct)(int16_t *_block, int qmul){
     const int stride= 16*2;
     const int xStride= 16;
-    int a,b,c,d,e;
+    SUINT a,b,c,d,e;
     dctcoef *block = (dctcoef*)_block;
 
     a= block[stride*0 + xStride*0];
@@ -317,8 +317,8 @@ void FUNCC(ff_h264_chroma_dc_dequant_idct)(int16_t *_block, int qmul){
     b= c-d;
     c= c+d;
 
-    block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;
-    block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;
-    block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;
-    block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;
+    block[stride*0 + xStride*0]= (int)((a+c)*qmul) >> 7;
+    block[stride*0 + xStride*1]= (int)((e+b)*qmul) >> 7;
+    block[stride*1 + xStride*0]= (int)((a-c)*qmul) >> 7;
+    block[stride*1 + xStride*1]= (int)((e-b)*qmul) >> 7;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/hap.h b/mythtv/external/FFmpeg/libavcodec/hap.h
index e4762ee4387..0ee65335d91 100644
--- a/mythtv/external/FFmpeg/libavcodec/hap.h
+++ b/mythtv/external/FFmpeg/libavcodec/hap.h
@@ -34,6 +34,7 @@ enum HapTextureFormat {
     HAP_FMT_RGBDXT1   = 0x0B,
     HAP_FMT_RGBADXT5  = 0x0E,
     HAP_FMT_YCOCGDXT5 = 0x0F,
+    HAP_FMT_RGTC1     = 0x01,
 };
 
 enum HapCompressor {
@@ -65,6 +66,7 @@ typedef struct HapContext {
 
     enum HapTextureFormat opt_tex_fmt; /* Texture type (encoder only) */
     int opt_chunk_count; /* User-requested chunk count (encoder only) */
+    int opt_compressor; /* User-requested compressor (encoder only) */
 
     int chunk_count;
     HapChunk *chunks;
diff --git a/mythtv/external/FFmpeg/libavcodec/hapdec.c b/mythtv/external/FFmpeg/libavcodec/hapdec.c
index f1d44cda24b..fc9dff10f19 100644
--- a/mythtv/external/FFmpeg/libavcodec/hapdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/hapdec.c
@@ -24,7 +24,7 @@
  * @file
  * Hap decoder
  *
- * Fourcc: Hap1, Hap5, HapY
+ * Fourcc: Hap1, Hap5, HapY, HapA, HapM
  *
  * https://github.com/Vidvox/hap/blob/master/documentation/HapVideoDRAFT.md
  */
@@ -163,7 +163,8 @@ static int hap_parse_frame_header(AVCodecContext *avctx)
 
     if ((avctx->codec_tag == MKTAG('H','a','p','1') && (section_type & 0x0F) != HAP_FMT_RGBDXT1) ||
         (avctx->codec_tag == MKTAG('H','a','p','5') && (section_type & 0x0F) != HAP_FMT_RGBADXT5) ||
-        (avctx->codec_tag == MKTAG('H','a','p','Y') && (section_type & 0x0F) != HAP_FMT_YCOCGDXT5)) {
+        (avctx->codec_tag == MKTAG('H','a','p','Y') && (section_type & 0x0F) != HAP_FMT_YCOCGDXT5) ||
+        (avctx->codec_tag == MKTAG('H','a','p','A') && (section_type & 0x0F) != HAP_FMT_RGTC1)) {
         av_log(avctx, AV_LOG_ERROR,
                "Invalid texture format %#04x.\n", section_type & 0x0F);
         return AVERROR_INVALIDDATA;
@@ -403,6 +404,15 @@ static av_cold int hap_init(AVCodecContext *avctx)
         ctx->tex_fun = ctx->dxtc.dxt5ys_block;
         avctx->pix_fmt = AV_PIX_FMT_RGB0;
         break;
+    case MKTAG('H','a','p','A'):
+        texture_name = "RGTC1";
+        ctx->tex_rat = 8;
+        ctx->tex_fun = ctx->dxtc.rgtc1u_block;
+        avctx->pix_fmt = AV_PIX_FMT_RGB0;
+        break;
+    case MKTAG('H','a','p','M'):
+        avpriv_report_missing_feature(avctx, "HapQAlpha");
+        return AVERROR_PATCHWELCOME;
     default:
         return AVERROR_DECODER_NOT_FOUND;
     }
@@ -426,7 +436,7 @@ static av_cold int hap_close(AVCodecContext *avctx)
 
 AVCodec ff_hap_decoder = {
     .name           = "hap",
-    .long_name      = NULL_IF_CONFIG_SMALL("Vidvox Hap decoder"),
+    .long_name      = NULL_IF_CONFIG_SMALL("Vidvox Hap"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_HAP,
     .init           = hap_init,
diff --git a/mythtv/external/FFmpeg/libavcodec/hapenc.c b/mythtv/external/FFmpeg/libavcodec/hapenc.c
index cb5dcfac56f..3a1bc870b13 100644
--- a/mythtv/external/FFmpeg/libavcodec/hapenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/hapenc.c
@@ -52,12 +52,14 @@ enum HapHeaderLength {
     HAP_HDR_LONG = 8,
 };
 
-static void compress_texture(AVCodecContext *avctx, const AVFrame *f)
+static int compress_texture(AVCodecContext *avctx, uint8_t *out, int out_length, const AVFrame *f)
 {
     HapContext *ctx = avctx->priv_data;
-    uint8_t *out = ctx->tex_buf;
     int i, j;
 
+    if (ctx->tex_size > out_length)
+        return AVERROR_BUFFER_TOO_SMALL;
+
     for (j = 0; j < avctx->height; j += 4) {
         for (i = 0; i < avctx->width; i += 4) {
             uint8_t *p = f->data[0] + i * 4 + j * f->linesize[0];
@@ -65,6 +67,8 @@ static void compress_texture(AVCodecContext *avctx, const AVFrame *f)
             out += step;
         }
     }
+
+    return 0;
 }
 
 /* section_length does not include the header */
@@ -118,7 +122,7 @@ static int hap_compress_frame(AVCodecContext *avctx, uint8_t *dst)
         /* If there is no gain from snappy, just use the raw texture. */
         if (chunk->compressed_size >= chunk->uncompressed_size) {
             av_log(avctx, AV_LOG_VERBOSE,
-                   "Snappy buffer bigger than uncompressed (%lu >= %lu bytes).\n",
+                   "Snappy buffer bigger than uncompressed (%"SIZE_SPECIFIER" >= %"SIZE_SPECIFIER" bytes).\n",
                    chunk->compressed_size, chunk->uncompressed_size);
             memcpy(chunk_dst, chunk_src, chunk->uncompressed_size);
             chunk->compressor = HAP_COMP_NONE;
@@ -200,13 +204,25 @@ static int hap_encode(AVCodecContext *avctx, AVPacket *pkt,
     if (ret < 0)
         return ret;
 
-    /* DXTC compression. */
-    compress_texture(avctx, frame);
+    if (ctx->opt_compressor == HAP_COMP_NONE) {
+        /* DXTC compression directly to the packet buffer. */
+        ret = compress_texture(avctx, pkt->data + header_length, pkt->size - header_length, frame);
+        if (ret < 0)
+            return ret;
 
-    /* Compress (using Snappy) the frame */
-    final_data_size = hap_compress_frame(avctx, pkt->data + header_length);
-    if (final_data_size < 0)
-        return final_data_size;
+        ctx->chunks[0].compressor = HAP_COMP_NONE;
+        final_data_size = ctx->tex_size;
+    } else {
+        /* DXTC compression. */
+        ret = compress_texture(avctx, ctx->tex_buf, ctx->tex_size, frame);
+        if (ret < 0)
+            return ret;
+
+        /* Compress (using Snappy) the frame */
+        final_data_size = hap_compress_frame(avctx, pkt->data + header_length);
+        if (final_data_size < 0)
+            return final_data_size;
+    }
 
     /* Write header at the start. */
     hap_write_frame_header(ctx, pkt->data, final_data_size + header_length);
@@ -267,10 +283,30 @@ static av_cold int hap_init(AVCodecContext *avctx)
     ctx->tex_size   = FFALIGN(avctx->width,  TEXTURE_BLOCK_W) *
                       FFALIGN(avctx->height, TEXTURE_BLOCK_H) * 4 / ratio;
 
-    /* Round the chunk count to divide evenly on DXT block edges */
-    corrected_chunk_count = av_clip(ctx->opt_chunk_count, 1, HAP_MAX_CHUNKS);
-    while ((ctx->tex_size / (64 / ratio)) % corrected_chunk_count != 0) {
-        corrected_chunk_count--;
+    switch (ctx->opt_compressor) {
+    case HAP_COMP_NONE:
+        /* No benefit chunking uncompressed data */
+        corrected_chunk_count = 1;
+
+        ctx->max_snappy = ctx->tex_size;
+        ctx->tex_buf = NULL;
+        break;
+    case HAP_COMP_SNAPPY:
+        /* Round the chunk count to divide evenly on DXT block edges */
+        corrected_chunk_count = av_clip(ctx->opt_chunk_count, 1, HAP_MAX_CHUNKS);
+        while ((ctx->tex_size / (64 / ratio)) % corrected_chunk_count != 0) {
+            corrected_chunk_count--;
+        }
+
+        ctx->max_snappy = snappy_max_compressed_length(ctx->tex_size / corrected_chunk_count);
+        ctx->tex_buf = av_malloc(ctx->tex_size);
+        if (!ctx->tex_buf) {
+            return AVERROR(ENOMEM);
+        }
+        break;
+    default:
+        av_log(avctx, AV_LOG_ERROR, "Invalid compresor %02X\n", ctx->opt_compressor);
+        return AVERROR_INVALIDDATA;
     }
     if (corrected_chunk_count != ctx->opt_chunk_count) {
         av_log(avctx, AV_LOG_INFO, "%d chunks requested but %d used.\n",
@@ -280,12 +316,6 @@ static av_cold int hap_init(AVCodecContext *avctx)
     if (ret != 0)
         return ret;
 
-    ctx->max_snappy = snappy_max_compressed_length(ctx->tex_size / corrected_chunk_count);
-
-    ctx->tex_buf  = av_malloc(ctx->tex_size);
-    if (!ctx->tex_buf)
-        return AVERROR(ENOMEM);
-
     return 0;
 }
 
@@ -306,6 +336,9 @@ static const AVOption options[] = {
         { "hap_alpha", "Hap Alpha (DXT5 textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_RGBADXT5  }, 0, 0, FLAGS, "format" },
         { "hap_q",     "Hap Q (DXT5-YCoCg textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_YCOCGDXT5 }, 0, 0, FLAGS, "format" },
     { "chunks", "chunk count", OFFSET(opt_chunk_count), AV_OPT_TYPE_INT, {.i64 = 1 }, 1, HAP_MAX_CHUNKS, FLAGS, },
+    { "compressor", "second-stage compressor", OFFSET(opt_compressor), AV_OPT_TYPE_INT, { .i64 = HAP_COMP_SNAPPY }, HAP_COMP_NONE, HAP_COMP_SNAPPY, FLAGS, "compressor" },
+        { "none",       "None", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_COMP_NONE }, 0, 0, FLAGS, "compressor" },
+        { "snappy",     "Snappy", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_COMP_SNAPPY }, 0, 0, FLAGS, "compressor" },
     { NULL },
 };
 
@@ -318,7 +351,7 @@ static const AVClass hapenc_class = {
 
 AVCodec ff_hap_encoder = {
     .name           = "hap",
-    .long_name      = NULL_IF_CONFIG_SMALL("Vidvox Hap encoder"),
+    .long_name      = NULL_IF_CONFIG_SMALL("Vidvox Hap"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_HAP,
     .priv_data_size = sizeof(HapContext),
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc.h b/mythtv/external/FFmpeg/libavcodec/hevc.h
index 6a3c7506c2a..f0fb919a7f2 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc.h
+++ b/mythtv/external/FFmpeg/libavcodec/hevc.h
@@ -1,7 +1,5 @@
 /*
- * HEVC video decoder
- *
- * Copyright (C) 2012 - 2013 Guillaume Martres
+ * HEVC shared code
  *
  * This file is part of FFmpeg.
  *
@@ -23,1062 +21,72 @@
 #ifndef AVCODEC_HEVC_H
 #define AVCODEC_HEVC_H
 
-#include "libavutil/buffer.h"
-#include "libavutil/md5.h"
-
-#include "avcodec.h"
-#include "bswapdsp.h"
-#include "cabac.h"
-#include "get_bits.h"
-#include "hevcpred.h"
-#include "h2645_parse.h"
-#include "hevcdsp.h"
-#include "internal.h"
-#include "thread.h"
-#include "videodsp.h"
-
-#define MAX_DPB_SIZE 16 // A.4.1
-#define MAX_REFS 16
-
-#define MAX_NB_THREADS 16
-#define SHIFT_CTB_WPP 2
-
-/**
- * 7.4.2.1
- */
-#define MAX_SUB_LAYERS 7
-#define MAX_VPS_COUNT 16
-#define MAX_SPS_COUNT 32
-#define MAX_PPS_COUNT 256
-#define MAX_SHORT_TERM_RPS_COUNT 64
-#define MAX_CU_SIZE 128
-
-//TODO: check if this is really the maximum
-#define MAX_TRANSFORM_DEPTH 5
-
-#define MAX_TB_SIZE 32
-#define MAX_LOG2_CTB_SIZE 6
-#define MAX_QP 51
-#define DEFAULT_INTRA_TC_OFFSET 2
-
-#define HEVC_CONTEXTS 199
-
-#define MRG_MAX_NUM_CANDS     5
-
-#define L0 0
-#define L1 1
-
-#define EPEL_EXTRA_BEFORE 1
-#define EPEL_EXTRA_AFTER  2
-#define EPEL_EXTRA        3
-#define QPEL_EXTRA_BEFORE 3
-#define QPEL_EXTRA_AFTER  4
-#define QPEL_EXTRA        7
-
-#define EDGE_EMU_BUFFER_STRIDE 80
-
-/**
- * Value of the luma sample at position (x, y) in the 2D array tab.
- */
-#define SAMPLE(tab, x, y) ((tab)[(y) * s->sps->width + (x)])
-#define SAMPLE_CTB(tab, x, y) ((tab)[(y) * min_cb_width + (x)])
-
-#define IS_IDR(s) ((s)->nal_unit_type == NAL_IDR_W_RADL || (s)->nal_unit_type == NAL_IDR_N_LP)
-#define IS_BLA(s) ((s)->nal_unit_type == NAL_BLA_W_RADL || (s)->nal_unit_type == NAL_BLA_W_LP || \
-                   (s)->nal_unit_type == NAL_BLA_N_LP)
-#define IS_IRAP(s) ((s)->nal_unit_type >= 16 && (s)->nal_unit_type <= 23)
-
 /**
  * Table 7-3: NAL unit type codes
  */
-enum NALUnitType {
-    NAL_TRAIL_N    = 0,
-    NAL_TRAIL_R    = 1,
-    NAL_TSA_N      = 2,
-    NAL_TSA_R      = 3,
-    NAL_STSA_N     = 4,
-    NAL_STSA_R     = 5,
-    NAL_RADL_N     = 6,
-    NAL_RADL_R     = 7,
-    NAL_RASL_N     = 8,
-    NAL_RASL_R     = 9,
-    NAL_BLA_W_LP   = 16,
-    NAL_BLA_W_RADL = 17,
-    NAL_BLA_N_LP   = 18,
-    NAL_IDR_W_RADL = 19,
-    NAL_IDR_N_LP   = 20,
-    NAL_CRA_NUT    = 21,
-    NAL_VPS        = 32,
-    NAL_SPS        = 33,
-    NAL_PPS        = 34,
-    NAL_AUD        = 35,
-    NAL_EOS_NUT    = 36,
-    NAL_EOB_NUT    = 37,
-    NAL_FD_NUT     = 38,
-    NAL_SEI_PREFIX = 39,
-    NAL_SEI_SUFFIX = 40,
-};
-
-enum RPSType {
-    ST_CURR_BEF = 0,
-    ST_CURR_AFT,
-    ST_FOLL,
-    LT_CURR,
-    LT_FOLL,
-    NB_RPS_TYPE,
-};
-
-enum SliceType {
-    B_SLICE = 0,
-    P_SLICE = 1,
-    I_SLICE = 2,
-};
-
-enum SyntaxElement {
-    SAO_MERGE_FLAG = 0,
-    SAO_TYPE_IDX,
-    SAO_EO_CLASS,
-    SAO_BAND_POSITION,
-    SAO_OFFSET_ABS,
-    SAO_OFFSET_SIGN,
-    END_OF_SLICE_FLAG,
-    SPLIT_CODING_UNIT_FLAG,
-    CU_TRANSQUANT_BYPASS_FLAG,
-    SKIP_FLAG,
-    CU_QP_DELTA,
-    PRED_MODE_FLAG,
-    PART_MODE,
-    PCM_FLAG,
-    PREV_INTRA_LUMA_PRED_FLAG,
-    MPM_IDX,
-    REM_INTRA_LUMA_PRED_MODE,
-    INTRA_CHROMA_PRED_MODE,
-    MERGE_FLAG,
-    MERGE_IDX,
-    INTER_PRED_IDC,
-    REF_IDX_L0,
-    REF_IDX_L1,
-    ABS_MVD_GREATER0_FLAG,
-    ABS_MVD_GREATER1_FLAG,
-    ABS_MVD_MINUS2,
-    MVD_SIGN_FLAG,
-    MVP_LX_FLAG,
-    NO_RESIDUAL_DATA_FLAG,
-    SPLIT_TRANSFORM_FLAG,
-    CBF_LUMA,
-    CBF_CB_CR,
-    TRANSFORM_SKIP_FLAG,
-    EXPLICIT_RDPCM_FLAG,
-    EXPLICIT_RDPCM_DIR_FLAG,
-    LAST_SIGNIFICANT_COEFF_X_PREFIX,
-    LAST_SIGNIFICANT_COEFF_Y_PREFIX,
-    LAST_SIGNIFICANT_COEFF_X_SUFFIX,
-    LAST_SIGNIFICANT_COEFF_Y_SUFFIX,
-    SIGNIFICANT_COEFF_GROUP_FLAG,
-    SIGNIFICANT_COEFF_FLAG,
-    COEFF_ABS_LEVEL_GREATER1_FLAG,
-    COEFF_ABS_LEVEL_GREATER2_FLAG,
-    COEFF_ABS_LEVEL_REMAINING,
-    COEFF_SIGN_FLAG,
-    LOG2_RES_SCALE_ABS,
-    RES_SCALE_SIGN_FLAG,
-    CU_CHROMA_QP_OFFSET_FLAG,
-    CU_CHROMA_QP_OFFSET_IDX,
-};
-
-enum PartMode {
-    PART_2Nx2N = 0,
-    PART_2NxN  = 1,
-    PART_Nx2N  = 2,
-    PART_NxN   = 3,
-    PART_2NxnU = 4,
-    PART_2NxnD = 5,
-    PART_nLx2N = 6,
-    PART_nRx2N = 7,
+enum HEVCNALUnitType {
+    HEVC_NAL_TRAIL_N    = 0,
+    HEVC_NAL_TRAIL_R    = 1,
+    HEVC_NAL_TSA_N      = 2,
+    HEVC_NAL_TSA_R      = 3,
+    HEVC_NAL_STSA_N     = 4,
+    HEVC_NAL_STSA_R     = 5,
+    HEVC_NAL_RADL_N     = 6,
+    HEVC_NAL_RADL_R     = 7,
+    HEVC_NAL_RASL_N     = 8,
+    HEVC_NAL_RASL_R     = 9,
+    HEVC_NAL_VCL_N10    = 10,
+    HEVC_NAL_VCL_R11    = 11,
+    HEVC_NAL_VCL_N12    = 12,
+    HEVC_NAL_VCL_R13    = 13,
+    HEVC_NAL_VCL_N14    = 14,
+    HEVC_NAL_VCL_R15    = 15,
+    HEVC_NAL_BLA_W_LP   = 16,
+    HEVC_NAL_BLA_W_RADL = 17,
+    HEVC_NAL_BLA_N_LP   = 18,
+    HEVC_NAL_IDR_W_RADL = 19,
+    HEVC_NAL_IDR_N_LP   = 20,
+    HEVC_NAL_CRA_NUT    = 21,
+    HEVC_NAL_IRAP_VCL22 = 22,
+    HEVC_NAL_IRAP_VCL23 = 23,
+    HEVC_NAL_RSV_VCL24  = 24,
+    HEVC_NAL_RSV_VCL25  = 25,
+    HEVC_NAL_RSV_VCL26  = 26,
+    HEVC_NAL_RSV_VCL27  = 27,
+    HEVC_NAL_RSV_VCL28  = 28,
+    HEVC_NAL_RSV_VCL29  = 29,
+    HEVC_NAL_RSV_VCL30  = 30,
+    HEVC_NAL_RSV_VCL31  = 31,
+    HEVC_NAL_VPS        = 32,
+    HEVC_NAL_SPS        = 33,
+    HEVC_NAL_PPS        = 34,
+    HEVC_NAL_AUD        = 35,
+    HEVC_NAL_EOS_NUT    = 36,
+    HEVC_NAL_EOB_NUT    = 37,
+    HEVC_NAL_FD_NUT     = 38,
+    HEVC_NAL_SEI_PREFIX = 39,
+    HEVC_NAL_SEI_SUFFIX = 40,
 };
 
-enum PredMode {
-    MODE_INTER = 0,
-    MODE_INTRA,
-    MODE_SKIP,
+enum HEVCSliceType {
+    HEVC_SLICE_B = 0,
+    HEVC_SLICE_P = 1,
+    HEVC_SLICE_I = 2,
 };
 
-enum InterPredIdc {
-    PRED_L0 = 0,
-    PRED_L1,
-    PRED_BI,
-};
-
-enum PredFlag {
-    PF_INTRA = 0,
-    PF_L0,
-    PF_L1,
-    PF_BI,
-};
-
-enum IntraPredMode {
-    INTRA_PLANAR = 0,
-    INTRA_DC,
-    INTRA_ANGULAR_2,
-    INTRA_ANGULAR_3,
-    INTRA_ANGULAR_4,
-    INTRA_ANGULAR_5,
-    INTRA_ANGULAR_6,
-    INTRA_ANGULAR_7,
-    INTRA_ANGULAR_8,
-    INTRA_ANGULAR_9,
-    INTRA_ANGULAR_10,
-    INTRA_ANGULAR_11,
-    INTRA_ANGULAR_12,
-    INTRA_ANGULAR_13,
-    INTRA_ANGULAR_14,
-    INTRA_ANGULAR_15,
-    INTRA_ANGULAR_16,
-    INTRA_ANGULAR_17,
-    INTRA_ANGULAR_18,
-    INTRA_ANGULAR_19,
-    INTRA_ANGULAR_20,
-    INTRA_ANGULAR_21,
-    INTRA_ANGULAR_22,
-    INTRA_ANGULAR_23,
-    INTRA_ANGULAR_24,
-    INTRA_ANGULAR_25,
-    INTRA_ANGULAR_26,
-    INTRA_ANGULAR_27,
-    INTRA_ANGULAR_28,
-    INTRA_ANGULAR_29,
-    INTRA_ANGULAR_30,
-    INTRA_ANGULAR_31,
-    INTRA_ANGULAR_32,
-    INTRA_ANGULAR_33,
-    INTRA_ANGULAR_34,
-};
-
-enum SAOType {
-    SAO_NOT_APPLIED = 0,
-    SAO_BAND,
-    SAO_EDGE,
-    SAO_APPLIED
-};
-
-enum SAOEOClass {
-    SAO_EO_HORIZ = 0,
-    SAO_EO_VERT,
-    SAO_EO_135D,
-    SAO_EO_45D,
-};
-
-enum ScanType {
-    SCAN_DIAG = 0,
-    SCAN_HORIZ,
-    SCAN_VERT,
-};
-
-typedef struct ShortTermRPS {
-    unsigned int num_negative_pics;
-    int num_delta_pocs;
-    int rps_idx_num_delta_pocs;
-    int32_t delta_poc[32];
-    uint8_t used[32];
-} ShortTermRPS;
-
-typedef struct LongTermRPS {
-    int     poc[32];
-    uint8_t used[32];
-    uint8_t nb_refs;
-} LongTermRPS;
-
-typedef struct RefPicList {
-    struct HEVCFrame *ref[MAX_REFS];
-    int list[MAX_REFS];
-    int isLongTerm[MAX_REFS];
-    int nb_refs;
-} RefPicList;
-
-typedef struct RefPicListTab {
-    RefPicList refPicList[2];
-} RefPicListTab;
-
-typedef struct HEVCWindow {
-    unsigned int left_offset;
-    unsigned int right_offset;
-    unsigned int top_offset;
-    unsigned int bottom_offset;
-} HEVCWindow;
-
-typedef struct VUI {
-    AVRational sar;
-
-    int overscan_info_present_flag;
-    int overscan_appropriate_flag;
-
-    int video_signal_type_present_flag;
-    int video_format;
-    int video_full_range_flag;
-    int colour_description_present_flag;
-    uint8_t colour_primaries;
-    uint8_t transfer_characteristic;
-    uint8_t matrix_coeffs;
-
-    int chroma_loc_info_present_flag;
-    int chroma_sample_loc_type_top_field;
-    int chroma_sample_loc_type_bottom_field;
-    int neutra_chroma_indication_flag;
-
-    int field_seq_flag;
-    int frame_field_info_present_flag;
-
-    int default_display_window_flag;
-    HEVCWindow def_disp_win;
-
-    int vui_timing_info_present_flag;
-    uint32_t vui_num_units_in_tick;
-    uint32_t vui_time_scale;
-    int vui_poc_proportional_to_timing_flag;
-    int vui_num_ticks_poc_diff_one_minus1;
-    int vui_hrd_parameters_present_flag;
-
-    int bitstream_restriction_flag;
-    int tiles_fixed_structure_flag;
-    int motion_vectors_over_pic_boundaries_flag;
-    int restricted_ref_pic_lists_flag;
-    int min_spatial_segmentation_idc;
-    int max_bytes_per_pic_denom;
-    int max_bits_per_min_cu_denom;
-    int log2_max_mv_length_horizontal;
-    int log2_max_mv_length_vertical;
-} VUI;
-
-typedef struct PTLCommon {
-    uint8_t profile_space;
-    uint8_t tier_flag;
-    uint8_t profile_idc;
-    uint8_t profile_compatibility_flag[32];
-    uint8_t level_idc;
-    uint8_t progressive_source_flag;
-    uint8_t interlaced_source_flag;
-    uint8_t non_packed_constraint_flag;
-    uint8_t frame_only_constraint_flag;
-} PTLCommon;
-
-typedef struct PTL {
-    PTLCommon general_ptl;
-    PTLCommon sub_layer_ptl[MAX_SUB_LAYERS];
-
-    uint8_t sub_layer_profile_present_flag[MAX_SUB_LAYERS];
-    uint8_t sub_layer_level_present_flag[MAX_SUB_LAYERS];
-} PTL;
-
-typedef struct HEVCVPS {
-    uint8_t vps_temporal_id_nesting_flag;
-    int vps_max_layers;
-    int vps_max_sub_layers; ///< vps_max_temporal_layers_minus1 + 1
-
-    PTL ptl;
-    int vps_sub_layer_ordering_info_present_flag;
-    unsigned int vps_max_dec_pic_buffering[MAX_SUB_LAYERS];
-    unsigned int vps_num_reorder_pics[MAX_SUB_LAYERS];
-    unsigned int vps_max_latency_increase[MAX_SUB_LAYERS];
-    int vps_max_layer_id;
-    int vps_num_layer_sets; ///< vps_num_layer_sets_minus1 + 1
-    uint8_t vps_timing_info_present_flag;
-    uint32_t vps_num_units_in_tick;
-    uint32_t vps_time_scale;
-    uint8_t vps_poc_proportional_to_timing_flag;
-    int vps_num_ticks_poc_diff_one; ///< vps_num_ticks_poc_diff_one_minus1 + 1
-    int vps_num_hrd_parameters;
-
-    uint8_t data[4096];
-    int data_size;
-} HEVCVPS;
-
-typedef struct ScalingList {
-    /* This is a little wasteful, since sizeID 0 only needs 8 coeffs,
-     * and size ID 3 only has 2 arrays, not 6. */
-    uint8_t sl[4][6][64];
-    uint8_t sl_dc[2][6];
-} ScalingList;
-
-typedef struct HEVCSPS {
-    unsigned vps_id;
-    int chroma_format_idc;
-    uint8_t separate_colour_plane_flag;
-
-    ///< output (i.e. cropped) values
-    int output_width, output_height;
-    HEVCWindow output_window;
-
-    HEVCWindow pic_conf_win;
-
-    int bit_depth;
-    int pixel_shift;
-    enum AVPixelFormat pix_fmt;
-
-    unsigned int log2_max_poc_lsb;
-    int pcm_enabled_flag;
-
-    int max_sub_layers;
-    struct {
-        int max_dec_pic_buffering;
-        int num_reorder_pics;
-        int max_latency_increase;
-    } temporal_layer[MAX_SUB_LAYERS];
-
-    VUI vui;
-    PTL ptl;
-
-    uint8_t scaling_list_enable_flag;
-    ScalingList scaling_list;
-
-    unsigned int nb_st_rps;
-    ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT];
-
-    uint8_t amp_enabled_flag;
-    uint8_t sao_enabled;
-
-    uint8_t long_term_ref_pics_present_flag;
-    uint16_t lt_ref_pic_poc_lsb_sps[32];
-    uint8_t used_by_curr_pic_lt_sps_flag[32];
-    uint8_t num_long_term_ref_pics_sps;
-
-    struct {
-        uint8_t bit_depth;
-        uint8_t bit_depth_chroma;
-        unsigned int log2_min_pcm_cb_size;
-        unsigned int log2_max_pcm_cb_size;
-        uint8_t loop_filter_disable_flag;
-    } pcm;
-    uint8_t sps_temporal_mvp_enabled_flag;
-    uint8_t sps_strong_intra_smoothing_enable_flag;
-
-    unsigned int log2_min_cb_size;
-    unsigned int log2_diff_max_min_coding_block_size;
-    unsigned int log2_min_tb_size;
-    unsigned int log2_max_trafo_size;
-    unsigned int log2_ctb_size;
-    unsigned int log2_min_pu_size;
-
-    int max_transform_hierarchy_depth_inter;
-    int max_transform_hierarchy_depth_intra;
-
-    int transform_skip_rotation_enabled_flag;
-    int transform_skip_context_enabled_flag;
-    int implicit_rdpcm_enabled_flag;
-    int explicit_rdpcm_enabled_flag;
-    int intra_smoothing_disabled_flag;
-    int persistent_rice_adaptation_enabled_flag;
-
-    ///< coded frame dimension in various units
-    int width;
-    int height;
-    int ctb_width;
-    int ctb_height;
-    int ctb_size;
-    int min_cb_width;
-    int min_cb_height;
-    int min_tb_width;
-    int min_tb_height;
-    int min_pu_width;
-    int min_pu_height;
-    int tb_mask;
-
-    int hshift[3];
-    int vshift[3];
-
-    int qp_bd_offset;
-
-    uint8_t data[4096];
-    int data_size;
-} HEVCSPS;
-
-typedef struct HEVCPPS {
-    unsigned int sps_id; ///< seq_parameter_set_id
-
-    uint8_t sign_data_hiding_flag;
-
-    uint8_t cabac_init_present_flag;
-
-    int num_ref_idx_l0_default_active; ///< num_ref_idx_l0_default_active_minus1 + 1
-    int num_ref_idx_l1_default_active; ///< num_ref_idx_l1_default_active_minus1 + 1
-    int pic_init_qp_minus26;
-
-    uint8_t constrained_intra_pred_flag;
-    uint8_t transform_skip_enabled_flag;
-
-    uint8_t cu_qp_delta_enabled_flag;
-    int diff_cu_qp_delta_depth;
-
-    int cb_qp_offset;
-    int cr_qp_offset;
-    uint8_t pic_slice_level_chroma_qp_offsets_present_flag;
-    uint8_t weighted_pred_flag;
-    uint8_t weighted_bipred_flag;
-    uint8_t output_flag_present_flag;
-    uint8_t transquant_bypass_enable_flag;
-
-    uint8_t dependent_slice_segments_enabled_flag;
-    uint8_t tiles_enabled_flag;
-    uint8_t entropy_coding_sync_enabled_flag;
-
-    int num_tile_columns;   ///< num_tile_columns_minus1 + 1
-    int num_tile_rows;      ///< num_tile_rows_minus1 + 1
-    uint8_t uniform_spacing_flag;
-    uint8_t loop_filter_across_tiles_enabled_flag;
-
-    uint8_t seq_loop_filter_across_slices_enabled_flag;
-
-    uint8_t deblocking_filter_control_present_flag;
-    uint8_t deblocking_filter_override_enabled_flag;
-    uint8_t disable_dbf;
-    int beta_offset;    ///< beta_offset_div2 * 2
-    int tc_offset;      ///< tc_offset_div2 * 2
-
-    uint8_t scaling_list_data_present_flag;
-    ScalingList scaling_list;
-
-    uint8_t lists_modification_present_flag;
-    int log2_parallel_merge_level; ///< log2_parallel_merge_level_minus2 + 2
-    int num_extra_slice_header_bits;
-    uint8_t slice_header_extension_present_flag;
-    uint8_t log2_max_transform_skip_block_size;
-    uint8_t cross_component_prediction_enabled_flag;
-    uint8_t chroma_qp_offset_list_enabled_flag;
-    uint8_t diff_cu_chroma_qp_offset_depth;
-    uint8_t chroma_qp_offset_list_len_minus1;
-    int8_t  cb_qp_offset_list[5];
-    int8_t  cr_qp_offset_list[5];
-    uint8_t log2_sao_offset_scale_luma;
-    uint8_t log2_sao_offset_scale_chroma;
-
-    // Inferred parameters
-    unsigned int *column_width;  ///< ColumnWidth
-    unsigned int *row_height;    ///< RowHeight
-    unsigned int *col_bd;        ///< ColBd
-    unsigned int *row_bd;        ///< RowBd
-    int *col_idxX;
-
-    int *ctb_addr_rs_to_ts; ///< CtbAddrRSToTS
-    int *ctb_addr_ts_to_rs; ///< CtbAddrTSToRS
-    int *tile_id;           ///< TileId
-    int *tile_pos_rs;       ///< TilePosRS
-    int *min_tb_addr_zs;    ///< MinTbAddrZS
-    int *min_tb_addr_zs_tab;///< MinTbAddrZS
-
-    uint8_t data[4096];
-    int data_size;
-} HEVCPPS;
-
-typedef struct HEVCParamSets {
-    AVBufferRef *vps_list[MAX_VPS_COUNT];
-    AVBufferRef *sps_list[MAX_SPS_COUNT];
-    AVBufferRef *pps_list[MAX_PPS_COUNT];
-
-    /* currently active parameter sets */
-    const HEVCVPS *vps;
-    const HEVCSPS *sps;
-    const HEVCPPS *pps;
-} HEVCParamSets;
-
-typedef struct SliceHeader {
-    unsigned int pps_id;
-
-    ///< address (in raster order) of the first block in the current slice segment
-    unsigned int   slice_segment_addr;
-    ///< address (in raster order) of the first block in the current slice
-    unsigned int   slice_addr;
-
-    enum SliceType slice_type;
-
-    int pic_order_cnt_lsb;
-
-    uint8_t first_slice_in_pic_flag;
-    uint8_t dependent_slice_segment_flag;
-    uint8_t pic_output_flag;
-    uint8_t colour_plane_id;
-
-    ///< RPS coded in the slice header itself is stored here
-    int short_term_ref_pic_set_sps_flag;
-    int short_term_ref_pic_set_size;
-    ShortTermRPS slice_rps;
-    const ShortTermRPS *short_term_rps;
-    int long_term_ref_pic_set_size;
-    LongTermRPS long_term_rps;
-    unsigned int list_entry_lx[2][32];
-
-    uint8_t rpl_modification_flag[2];
-    uint8_t no_output_of_prior_pics_flag;
-    uint8_t slice_temporal_mvp_enabled_flag;
-
-    unsigned int nb_refs[2];
-
-    uint8_t slice_sample_adaptive_offset_flag[3];
-    uint8_t mvd_l1_zero_flag;
-
-    uint8_t cabac_init_flag;
-    uint8_t disable_deblocking_filter_flag; ///< slice_header_disable_deblocking_filter_flag
-    uint8_t slice_loop_filter_across_slices_enabled_flag;
-    uint8_t collocated_list;
-
-    unsigned int collocated_ref_idx;
-
-    int slice_qp_delta;
-    int slice_cb_qp_offset;
-    int slice_cr_qp_offset;
-
-    uint8_t cu_chroma_qp_offset_enabled_flag;
-
-    int beta_offset;    ///< beta_offset_div2 * 2
-    int tc_offset;      ///< tc_offset_div2 * 2
-
-    unsigned int max_num_merge_cand; ///< 5 - 5_minus_max_num_merge_cand
-
-    unsigned *entry_point_offset;
-    int * offset;
-    int * size;
-    int num_entry_point_offsets;
-
-    int8_t slice_qp;
-
-    uint8_t luma_log2_weight_denom;
-    int16_t chroma_log2_weight_denom;
-
-    int16_t luma_weight_l0[16];
-    int16_t chroma_weight_l0[16][2];
-    int16_t chroma_weight_l1[16][2];
-    int16_t luma_weight_l1[16];
-
-    int16_t luma_offset_l0[16];
-    int16_t chroma_offset_l0[16][2];
-
-    int16_t luma_offset_l1[16];
-    int16_t chroma_offset_l1[16][2];
-
-    int slice_ctb_addr_rs;
-} SliceHeader;
-
-typedef struct CodingUnit {
-    int x;
-    int y;
-
-    enum PredMode pred_mode;    ///< PredMode
-    enum PartMode part_mode;    ///< PartMode
-
-    // Inferred parameters
-    uint8_t intra_split_flag;   ///< IntraSplitFlag
-    uint8_t max_trafo_depth;    ///< MaxTrafoDepth
-    uint8_t cu_transquant_bypass_flag;
-} CodingUnit;
-
-typedef struct Mv {
-    int16_t x;  ///< horizontal component of motion vector
-    int16_t y;  ///< vertical component of motion vector
-} Mv;
-
-typedef struct MvField {
-    DECLARE_ALIGNED(4, Mv, mv)[2];
-    int8_t ref_idx[2];
-    int8_t pred_flag;
-} MvField;
-
-typedef struct NeighbourAvailable {
-    int cand_bottom_left;
-    int cand_left;
-    int cand_up;
-    int cand_up_left;
-    int cand_up_right;
-    int cand_up_right_sap;
-} NeighbourAvailable;
-
-typedef struct PredictionUnit {
-    int mpm_idx;
-    int rem_intra_luma_pred_mode;
-    uint8_t intra_pred_mode[4];
-    Mv mvd;
-    uint8_t merge_flag;
-    uint8_t intra_pred_mode_c[4];
-    uint8_t chroma_mode_c[4];
-} PredictionUnit;
-
-typedef struct TransformUnit {
-    int cu_qp_delta;
-
-    int res_scale_val;
-
-    // Inferred parameters;
-    int intra_pred_mode;
-    int intra_pred_mode_c;
-    int chroma_mode_c;
-    uint8_t is_cu_qp_delta_coded;
-    uint8_t is_cu_chroma_qp_offset_coded;
-    int8_t  cu_qp_offset_cb;
-    int8_t  cu_qp_offset_cr;
-    uint8_t cross_pf;
-} TransformUnit;
-
-typedef struct DBParams {
-    int beta_offset;
-    int tc_offset;
-} DBParams;
-
-#define HEVC_FRAME_FLAG_OUTPUT    (1 << 0)
-#define HEVC_FRAME_FLAG_SHORT_REF (1 << 1)
-#define HEVC_FRAME_FLAG_LONG_REF  (1 << 2)
-#define HEVC_FRAME_FLAG_BUMPING   (1 << 3)
-
-typedef struct HEVCFrame {
-    AVFrame *frame;
-    ThreadFrame tf;
-    MvField *tab_mvf;
-    RefPicList *refPicList;
-    RefPicListTab **rpl_tab;
-    int ctb_count;
-    int poc;
-    struct HEVCFrame *collocated_ref;
-
-    HEVCWindow window;
-
-    AVBufferRef *tab_mvf_buf;
-    AVBufferRef *rpl_tab_buf;
-    AVBufferRef *rpl_buf;
-
-    AVBufferRef *hwaccel_priv_buf;
-    void *hwaccel_picture_private;
-
-    /**
-     * A sequence counter, so that old frames are output first
-     * after a POC reset
-     */
-    uint16_t sequence;
-
-    /**
-     * A combination of HEVC_FRAME_FLAG_*
-     */
-    uint8_t flags;
-} HEVCFrame;
-
-typedef struct HEVCLocalContext {
-    uint8_t cabac_state[HEVC_CONTEXTS];
-
-    uint8_t stat_coeff[4];
-
-    uint8_t first_qp_group;
-
-    GetBitContext gb;
-    CABACContext cc;
-
-    int8_t qp_y;
-    int8_t curr_qp_y;
-
-    int qPy_pred;
-
-    TransformUnit tu;
-
-    uint8_t ctb_left_flag;
-    uint8_t ctb_up_flag;
-    uint8_t ctb_up_right_flag;
-    uint8_t ctb_up_left_flag;
-    int     end_of_tiles_x;
-    int     end_of_tiles_y;
-    /* +7 is for subpixel interpolation, *2 for high bit depths */
-    DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer)[(MAX_PB_SIZE + 7) * EDGE_EMU_BUFFER_STRIDE * 2];
-    /* The extended size between the new edge emu buffer is abused by SAO */
-    DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer2)[(MAX_PB_SIZE + 7) * EDGE_EMU_BUFFER_STRIDE * 2];
-    DECLARE_ALIGNED(32, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
-
-    int ct_depth;
-    CodingUnit cu;
-    PredictionUnit pu;
-    NeighbourAvailable na;
-
-#define BOUNDARY_LEFT_SLICE     (1 << 0)
-#define BOUNDARY_LEFT_TILE      (1 << 1)
-#define BOUNDARY_UPPER_SLICE    (1 << 2)
-#define BOUNDARY_UPPER_TILE     (1 << 3)
-    /* properties of the boundary of the current CTB for the purposes
-     * of the deblocking filter */
-    int boundary_flags;
-} HEVCLocalContext;
-
-typedef struct HEVCContext {
-    const AVClass *c;  // needed by private avoptions
-    AVCodecContext *avctx;
-
-    struct HEVCContext  *sList[MAX_NB_THREADS];
-
-    HEVCLocalContext    *HEVClcList[MAX_NB_THREADS];
-    HEVCLocalContext    *HEVClc;
-
-    uint8_t             threads_type;
-    uint8_t             threads_number;
-
-    int                 width;
-    int                 height;
-
-    uint8_t *cabac_state;
-
-    /** 1 if the independent slice segment header was successfully parsed */
-    uint8_t slice_initialized;
-
-    AVFrame *frame;
-    AVFrame *output_frame;
-    uint8_t *sao_pixel_buffer_h[3];
-    uint8_t *sao_pixel_buffer_v[3];
-
-    HEVCParamSets ps;
-
-    AVBufferPool *tab_mvf_pool;
-    AVBufferPool *rpl_tab_pool;
-
-    ///< candidate references for the current frame
-    RefPicList rps[5];
-
-    SliceHeader sh;
-    SAOParams *sao;
-    DBParams *deblock;
-    enum NALUnitType nal_unit_type;
-    int temporal_id;  ///< temporal_id_plus1 - 1
-    HEVCFrame *ref;
-    HEVCFrame DPB[32];
-    int poc;
-    int pocTid0;
-    int slice_idx; ///< number of the slice being currently decoded
-    int eos;       ///< current packet contains an EOS/EOB NAL
-    int last_eos;  ///< last packet contains an EOS/EOB NAL
-    int max_ra;
-    int bs_width;
-    int bs_height;
-
-    int is_decoded;
-    int no_rasl_output_flag;
-
-    HEVCPredContext hpc;
-    HEVCDSPContext hevcdsp;
-    VideoDSPContext vdsp;
-    BswapDSPContext bdsp;
-    int8_t *qp_y_tab;
-    uint8_t *horizontal_bs;
-    uint8_t *vertical_bs;
-
-    int32_t *tab_slice_address;
-
-    //  CU
-    uint8_t *skip_flag;
-    uint8_t *tab_ct_depth;
-    // PU
-    uint8_t *tab_ipm;
-
-    uint8_t *cbf_luma; // cbf_luma of colocated TU
-    uint8_t *is_pcm;
-
-    // CTB-level flags affecting loop filter operation
-    uint8_t *filter_slice_edges;
-
-    /** used on BE to byteswap the lines for checksumming */
-    uint8_t *checksum_buf;
-    int      checksum_buf_size;
-
-    /**
-     * Sequence counters for decoded and output frames, so that old
-     * frames are output first after a POC reset
-     */
-    uint16_t seq_decode;
-    uint16_t seq_output;
-
-    int enable_parallel_tiles;
-    int wpp_err;
-
-    const uint8_t *data;
-
-    H2645Packet pkt;
-    // type of the first VCL NAL of the current frame
-    enum NALUnitType first_nal_type;
-
-    // for checking the frame checksums
-    struct AVMD5 *md5_ctx;
-    uint8_t       md5[3][16];
-    uint8_t is_md5;
-
-    uint8_t context_initialized;
-    uint8_t is_nalff;       ///< this flag is != 0 if bitstream is encapsulated
-                            ///< as a format defined in 14496-15
-    int apply_defdispwin;
-
-    int active_seq_parameter_set_id;
-
-    int nal_length_size;    ///< Number of bytes used for nal length (1, 2 or 4)
-    int nuh_layer_id;
-
-    /** frame packing arrangement variables */
-    int sei_frame_packing_present;
-    int frame_packing_arrangement_type;
-    int content_interpretation_type;
-    int quincunx_subsampling;
-
-    /** display orientation */
-    int sei_display_orientation_present;
-    int sei_anticlockwise_rotation;
-    int sei_hflip, sei_vflip;
-
-    int picture_struct;
-
-    uint8_t* a53_caption;
-    int a53_caption_size;
-
-    /** mastering display */
-    int sei_mastering_display_info_present;
-    uint16_t display_primaries[3][2];
-    uint16_t white_point[2];
-    uint32_t max_mastering_luminance;
-    uint32_t min_mastering_luminance;
-
-} HEVCContext;
-
-int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
-                                  ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header);
-
-/**
- * Parse the SPS from the bitstream into the provided HEVCSPS struct.
- *
- * @param sps_id the SPS id will be written here
- * @param apply_defdispwin if set 1, the default display window from the VUI
- *                         will be applied to the video dimensions
- * @param vps_list if non-NULL, this function will validate that the SPS refers
- *                 to an existing VPS
- */
-int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
-                      int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx);
-
-int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
-                           HEVCParamSets *ps);
-int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
-                           HEVCParamSets *ps, int apply_defdispwin);
-int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
-                           HEVCParamSets *ps);
-int ff_hevc_decode_nal_sei(HEVCContext *s);
-
-/**
- * Mark all frames in DPB as unused for reference.
- */
-void ff_hevc_clear_refs(HEVCContext *s);
-
-/**
- * Drop all frames currently in DPB.
- */
-void ff_hevc_flush_dpb(HEVCContext *s);
-
-/**
- * Compute POC of the current frame and return it.
- */
-int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb);
-
-RefPicList *ff_hevc_get_ref_list(HEVCContext *s, HEVCFrame *frame,
-                                 int x0, int y0);
-
-/**
- * Construct the reference picture sets for the current frame.
- */
-int ff_hevc_frame_rps(HEVCContext *s);
-
 /**
- * Construct the reference picture list(s) for the current slice.
- */
-int ff_hevc_slice_rpl(HEVCContext *s);
-
-void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts);
-void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts);
-int ff_hevc_sao_merge_flag_decode(HEVCContext *s);
-int ff_hevc_sao_type_idx_decode(HEVCContext *s);
-int ff_hevc_sao_band_position_decode(HEVCContext *s);
-int ff_hevc_sao_offset_abs_decode(HEVCContext *s);
-int ff_hevc_sao_offset_sign_decode(HEVCContext *s);
-int ff_hevc_sao_eo_class_decode(HEVCContext *s);
-int ff_hevc_end_of_slice_flag_decode(HEVCContext *s);
-int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s);
-int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0,
-                             int x_cb, int y_cb);
-int ff_hevc_pred_mode_decode(HEVCContext *s);
-int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth,
-                                          int x0, int y0);
-int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size);
-int ff_hevc_pcm_flag_decode(HEVCContext *s);
-int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s);
-int ff_hevc_mpm_idx_decode(HEVCContext *s);
-int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s);
-int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s);
-int ff_hevc_merge_idx_decode(HEVCContext *s);
-int ff_hevc_merge_flag_decode(HEVCContext *s);
-int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH);
-int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx);
-int ff_hevc_mvp_lx_flag_decode(HEVCContext *s);
-int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s);
-int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size);
-int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth);
-int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth);
-int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx);
-int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx);
-
-/**
- * Get the number of candidate references for the current frame.
- */
-int ff_hevc_frame_nb_refs(HEVCContext *s);
-
-int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc);
-
-/**
- * Find next frame in output order and put a reference to it in frame.
- * @return 1 if a frame was output, 0 otherwise
- */
-int ff_hevc_output_frame(HEVCContext *s, AVFrame *frame, int flush);
-
-void ff_hevc_bump_frame(HEVCContext *s);
-
-void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags);
-
-void ff_hevc_set_neighbour_available(HEVCContext *s, int x0, int y0,
-                                     int nPbW, int nPbH);
-void ff_hevc_luma_mv_merge_mode(HEVCContext *s, int x0, int y0,
-                                int nPbW, int nPbH, int log2_cb_size,
-                                int part_idx, int merge_idx, MvField *mv);
-void ff_hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0,
-                              int nPbW, int nPbH, int log2_cb_size,
-                              int part_idx, int merge_idx,
-                              MvField *mv, int mvp_lx_flag, int LX);
-void ff_hevc_set_qPy(HEVCContext *s, int xBase, int yBase,
-                     int log2_cb_size);
-void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0,
-                                           int log2_trafo_size);
-int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s);
-int ff_hevc_cu_qp_delta_abs(HEVCContext *s);
-int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s);
-int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s);
-void ff_hevc_hls_filter(HEVCContext *s, int x, int y, int ctb_size);
-void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size);
-void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
-                                 int log2_trafo_size, enum ScanType scan_idx,
-                                 int c_idx);
-
-void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size);
-
-
-int ff_hevc_encode_nal_vps(HEVCVPS *vps, unsigned int id,
-                           uint8_t *buf, int buf_size);
-
-/**
- * Reset SEI values that are stored on the Context.
- * e.g. Caption data that was extracted during NAL
- * parsing.
- *
- * @param s HEVCContext.
+ * 7.4.2.1
  */
-void ff_hevc_reset_sei(HEVCContext *s);
+#define HEVC_MAX_SUB_LAYERS 7
+#define HEVC_MAX_VPS_COUNT 16
+#define HEVC_MAX_SPS_COUNT 32
+#define HEVC_MAX_PPS_COUNT 256
+#define HEVC_MAX_SHORT_TERM_RPS_COUNT 64
+#define HEVC_MAX_CU_SIZE 128
 
-extern const uint8_t ff_hevc_qpel_extra_before[4];
-extern const uint8_t ff_hevc_qpel_extra_after[4];
-extern const uint8_t ff_hevc_qpel_extra[4];
+#define HEVC_MAX_REFS 16
+#define HEVC_MAX_DPB_SIZE 16 // A.4.1
 
-extern const uint8_t ff_hevc_diag_scan4x4_x[16];
-extern const uint8_t ff_hevc_diag_scan4x4_y[16];
-extern const uint8_t ff_hevc_diag_scan8x8_x[64];
-extern const uint8_t ff_hevc_diag_scan8x8_y[64];
+#define HEVC_MAX_LOG2_CTB_SIZE 6
 
 #endif /* AVCODEC_HEVC_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_cabac.c b/mythtv/external/FFmpeg/libavcodec/hevc_cabac.c
index 05b28218406..853fd3f7229 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_cabac.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_cabac.c
@@ -25,14 +25,16 @@
 #include "libavutil/common.h"
 
 #include "cabac_functions.h"
+#include "hevc_data.h"
 #include "hevc.h"
+#include "hevcdec.h"
 
 #define CABAC_MAX_BIN 31
 
 /**
  * number of bin by SyntaxElement.
  */
-av_unused static const int8_t num_bins_in_se[] = {
+static const int8_t num_bins_in_se[] = {
      1, // sao_merge_flag
      1, // sao_type_idx
      0, // sao_eo_class
@@ -460,17 +462,17 @@ static void load_states(HEVCContext *s)
     memcpy(s->HEVClc->cabac_state, s->cabac_state, HEVC_CONTEXTS);
 }
 
-static void cabac_reinit(HEVCLocalContext *lc)
+static int cabac_reinit(HEVCLocalContext *lc)
 {
-    skip_bytes(&lc->cc, 0);
+    return skip_bytes(&lc->cc, 0) == NULL ? AVERROR_INVALIDDATA : 0;
 }
 
-static void cabac_init_decoder(HEVCContext *s)
+static int cabac_init_decoder(HEVCContext *s)
 {
     GetBitContext *gb = &s->HEVClc->gb;
     skip_bits(gb, 1);
     align_get_bits(gb);
-    ff_init_cabac_decoder(&s->HEVClc->cc,
+    return ff_init_cabac_decoder(&s->HEVClc->cc,
                           gb->buffer + get_bits_count(gb) / 8,
                           (get_bits_left(gb) + 7) / 8);
 }
@@ -480,7 +482,7 @@ static void cabac_init_state(HEVCContext *s)
     int init_type = 2 - s->sh.slice_type;
     int i;
 
-    if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE)
+    if (s->sh.cabac_init_flag && s->sh.slice_type != HEVC_SLICE_I)
         init_type ^= 3;
 
     for (i = 0; i < HEVC_CONTEXTS; i++) {
@@ -499,10 +501,12 @@ static void cabac_init_state(HEVCContext *s)
         s->HEVClc->stat_coeff[i] = 0;
 }
 
-void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
+int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
 {
     if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
-        cabac_init_decoder(s);
+        int ret = cabac_init_decoder(s);
+        if (ret < 0)
+            return ret;
         if (s->sh.dependent_slice_segment_flag == 0 ||
             (s->ps.pps->tiles_enabled_flag &&
              s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
@@ -520,19 +524,27 @@ void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
     } else {
         if (s->ps.pps->tiles_enabled_flag &&
             s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
+            int ret;
             if (s->threads_number == 1)
-                cabac_reinit(s->HEVClc);
-            else
-                cabac_init_decoder(s);
+                ret = cabac_reinit(s->HEVClc);
+            else {
+                ret = cabac_init_decoder(s);
+            }
+            if (ret < 0)
+                return ret;
             cabac_init_state(s);
         }
         if (s->ps.pps->entropy_coding_sync_enabled_flag) {
             if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
+                int ret;
                 get_cabac_terminate(&s->HEVClc->cc);
                 if (s->threads_number == 1)
-                    cabac_reinit(s->HEVClc);
-                else
-                    cabac_init_decoder(s);
+                    ret = cabac_reinit(s->HEVClc);
+                else {
+                    ret = cabac_init_decoder(s);
+                }
+                if (ret < 0)
+                    return ret;
 
                 if (s->ps.sps->ctb_width == 1)
                     cabac_init_state(s);
@@ -541,6 +553,7 @@ void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
             }
         }
     }
+    return 0;
 }
 
 #define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
@@ -1476,7 +1489,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
                     FFSWAP(int16_t, coeffs[i], coeffs[16 - i - 1]);
             }
 
-            s->hevcdsp.transform_skip(coeffs, log2_trafo_size);
+            s->hevcdsp.dequant(coeffs, log2_trafo_size);
 
             if (explicit_rdpcm_flag || (s->ps.sps->implicit_rdpcm_enabled_flag &&
                                         lc->cu.pred_mode == MODE_INTRA &&
@@ -1486,11 +1499,11 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
                 s->hevcdsp.transform_rdpcm(coeffs, log2_trafo_size, mode);
             }
         } else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 && log2_trafo_size == 2) {
-            s->hevcdsp.idct_4x4_luma(coeffs);
+            s->hevcdsp.transform_4x4_luma(coeffs);
         } else {
             int max_xy = FFMAX(last_significant_coeff_x, last_significant_coeff_y);
             if (max_xy == 0)
-                s->hevcdsp.idct_dc[log2_trafo_size-2](coeffs);
+                s->hevcdsp.idct_dc[log2_trafo_size - 2](coeffs);
             else {
                 int col_limit = last_significant_coeff_x + last_significant_coeff_y + 4;
                 if (max_xy < 4)
@@ -1499,7 +1512,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
                     col_limit = FFMIN(8, col_limit);
                 else if (max_xy < 12)
                     col_limit = FFMIN(24, col_limit);
-                s->hevcdsp.idct[log2_trafo_size-2](coeffs, col_limit);
+                s->hevcdsp.idct[log2_trafo_size - 2](coeffs, col_limit);
             }
         }
     }
@@ -1510,7 +1523,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
             coeffs[i] = coeffs[i] + ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
         }
     }
-    s->hevcdsp.transform_add[log2_trafo_size-2](dst, coeffs, stride);
+    s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
 }
 
 void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_data.c b/mythtv/external/FFmpeg/libavcodec/hevc_data.c
index f74f2725c0b..1633a41c136 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_data.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_data.c
@@ -20,7 +20,7 @@
 
 #include <stdint.h>
 
-#include "hevc.h"
+#include "hevc_data.h"
 
 const uint8_t ff_hevc_diag_scan4x4_x[16] = {
     0, 0, 1, 0,
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_data.h b/mythtv/external/FFmpeg/libavcodec/hevc_data.h
new file mode 100644
index 00000000000..74558f0a989
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_data.h
@@ -0,0 +1,31 @@
+/*
+ * HEVC shared data tables
+ *
+ * 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_HEVC_DATA_H
+#define AVCODEC_HEVC_DATA_H
+
+#include <stdint.h>
+
+extern const uint8_t ff_hevc_diag_scan4x4_x[16];
+extern const uint8_t ff_hevc_diag_scan4x4_y[16];
+extern const uint8_t ff_hevc_diag_scan8x8_x[64];
+extern const uint8_t ff_hevc_diag_scan8x8_y[64];
+
+#endif /* AVCODEC_HEVC_DATA_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_filter.c b/mythtv/external/FFmpeg/libavcodec/hevc_filter.c
index 6918a553f26..b53f4cc7212 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_filter.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_filter.c
@@ -26,7 +26,7 @@
 #include "libavutil/internal.h"
 
 #include "cabac_functions.h"
-#include "hevc.h"
+#include "hevcdec.h"
 
 #include "bit_depth_template.c"
 
@@ -139,7 +139,7 @@ static int get_qPy(HEVCContext *s, int xC, int yC)
 }
 
 static void copy_CTB(uint8_t *dst, const uint8_t *src, int width, int height,
-                     intptr_t stride_dst, intptr_t stride_src)
+                     ptrdiff_t stride_dst, ptrdiff_t stride_src)
 {
 int i, j;
 
@@ -170,7 +170,7 @@ static void copy_pixel(uint8_t *dst, const uint8_t *src, int pixel_shift)
 
 static void copy_vert(uint8_t *dst, const uint8_t *src,
                       int pixel_shift, int height,
-                      int stride_dst, int stride_src)
+                      ptrdiff_t stride_dst, ptrdiff_t stride_src)
 {
     int i;
     if (pixel_shift == 0) {
@@ -189,7 +189,7 @@ static void copy_vert(uint8_t *dst, const uint8_t *src,
 }
 
 static void copy_CTB_to_hv(HEVCContext *s, const uint8_t *src,
-                           int stride_src, int x, int y, int width, int height,
+                           ptrdiff_t stride_src, int x, int y, int width, int height,
                            int c_idx, int x_ctb, int y_ctb)
 {
     int sh = s->ps.sps->pixel_shift;
@@ -306,14 +306,14 @@ static void sao_filter_CTB(HEVCContext *s, int x, int y)
     for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
         int x0       = x >> s->ps.sps->hshift[c_idx];
         int y0       = y >> s->ps.sps->vshift[c_idx];
-        int stride_src = s->frame->linesize[c_idx];
+        ptrdiff_t stride_src = s->frame->linesize[c_idx];
         int ctb_size_h = (1 << (s->ps.sps->log2_ctb_size)) >> s->ps.sps->hshift[c_idx];
         int ctb_size_v = (1 << (s->ps.sps->log2_ctb_size)) >> s->ps.sps->vshift[c_idx];
         int width    = FFMIN(ctb_size_h, (s->ps.sps->width  >> s->ps.sps->hshift[c_idx]) - x0);
         int height   = FFMIN(ctb_size_v, (s->ps.sps->height >> s->ps.sps->vshift[c_idx]) - y0);
         int tab      = sao_tab[(FFALIGN(width, 8) >> 3) - 1];
         uint8_t *src = &s->frame->data[c_idx][y0 * stride_src + (x0 << s->ps.sps->pixel_shift)];
-        int stride_dst;
+        ptrdiff_t stride_dst;
         uint8_t *dst;
 
         switch (sao->type_idx[c_idx]) {
@@ -470,7 +470,7 @@ static int get_pcm(HEVCContext *s, int x, int y)
 
 #define TC_CALC(qp, bs)                                                 \
     tctable[av_clip((qp) + DEFAULT_INTRA_TC_OFFSET * ((bs) - 1) +       \
-                    (tc_offset >> 1 << 1),                              \
+                    (tc_offset & -2),                                   \
                     0, MAX_QP + DEFAULT_INTRA_TC_OFFSET)]
 
 static void deblocking_filter_CTB(HEVCContext *s, int x0, int y0)
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_mp4toannexb_bsf.c b/mythtv/external/FFmpeg/libavcodec/hevc_mp4toannexb_bsf.c
index 5cc642b0d3a..09bce5b34c2 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_mp4toannexb_bsf.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_mp4toannexb_bsf.c
@@ -55,8 +55,8 @@ static int hevc_extradata_to_annexb(AVBSFContext *ctx)
         int type = bytestream2_get_byte(&gb) & 0x3f;
         int cnt  = bytestream2_get_be16(&gb);
 
-        if (!(type == NAL_VPS || type == NAL_SPS || type == NAL_PPS ||
-              type == NAL_SEI_PREFIX || type == NAL_SEI_SUFFIX)) {
+        if (!(type == HEVC_NAL_VPS || type == HEVC_NAL_SPS || type == HEVC_NAL_PPS ||
+              type == HEVC_NAL_SEI_PREFIX || type == HEVC_NAL_SEI_SUFFIX)) {
             av_log(ctx, AV_LOG_ERROR, "Invalid NAL unit type in extradata: %d\n",
                    type);
             ret = AVERROR_INVALIDDATA;
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_mvs.c b/mythtv/external/FFmpeg/libavcodec/hevc_mvs.c
index 4a6dde0f674..a8f7876b59b 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_mvs.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_mvs.c
@@ -22,6 +22,7 @@
  */
 
 #include "hevc.h"
+#include "hevcdec.h"
 
 static const uint8_t l0_l1_cand_idx[12][2] = {
     { 0, 1, },
@@ -315,7 +316,7 @@ static void derive_spatial_merge_candidates(HEVCContext *s, int x0, int y0,
     const int xB2    = x0 - 1;
     const int yB2    = y0 - 1;
 
-    const int nb_refs = (s->sh.slice_type == P_SLICE) ?
+    const int nb_refs = (s->sh.slice_type == HEVC_SLICE_P) ?
                         s->sh.nb_refs[0] : FFMIN(s->sh.nb_refs[0], s->sh.nb_refs[1]);
 
     int zero_idx = 0;
@@ -411,7 +412,7 @@ static void derive_spatial_merge_candidates(HEVCContext *s, int x0, int y0,
         Mv mv_l0_col = { 0 }, mv_l1_col = { 0 };
         int available_l0 = temporal_luma_motion_vector(s, x0, y0, nPbW, nPbH,
                                                        0, &mv_l0_col, 0);
-        int available_l1 = (s->sh.slice_type == B_SLICE) ?
+        int available_l1 = (s->sh.slice_type == HEVC_SLICE_B) ?
                            temporal_luma_motion_vector(s, x0, y0, nPbW, nPbH,
                                                        0, &mv_l1_col, 1) : 0;
 
@@ -430,7 +431,7 @@ static void derive_spatial_merge_candidates(HEVCContext *s, int x0, int y0,
     nb_orig_merge_cand = nb_merge_cand;
 
     // combined bi-predictive merge candidates  (applies for B slices)
-    if (s->sh.slice_type == B_SLICE && nb_orig_merge_cand > 1 &&
+    if (s->sh.slice_type == HEVC_SLICE_B && nb_orig_merge_cand > 1 &&
         nb_orig_merge_cand < s->sh.max_num_merge_cand) {
         int comb_idx = 0;
 
@@ -459,7 +460,7 @@ static void derive_spatial_merge_candidates(HEVCContext *s, int x0, int y0,
 
     // append Zero motion vector candidates
     while (nb_merge_cand < s->sh.max_num_merge_cand) {
-        mergecandlist[nb_merge_cand].pred_flag    = PF_L0 + ((s->sh.slice_type == B_SLICE) << 1);
+        mergecandlist[nb_merge_cand].pred_flag    = PF_L0 + ((s->sh.slice_type == HEVC_SLICE_B) << 1);
         AV_ZERO32(mergecandlist[nb_merge_cand].mv + 0);
         AV_ZERO32(mergecandlist[nb_merge_cand].mv + 1);
         mergecandlist[nb_merge_cand].ref_idx[0]   = zero_idx < nb_refs ? zero_idx : 0;
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_parse.c b/mythtv/external/FFmpeg/libavcodec/hevc_parse.c
index cf04bc2ffff..1122a60af39 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_parse.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_parse.c
@@ -22,7 +22,8 @@
 #include "hevc_parse.h"
 
 static int hevc_decode_nal_units(const uint8_t *buf, int buf_size, HEVCParamSets *ps,
-                                 int is_nalff, int nal_length_size, void *logctx)
+                                 HEVCSEIContext *sei, int is_nalff, int nal_length_size,
+                                 int err_recognition, int apply_defdispwin, void *logctx)
 {
     int i;
     int ret = 0;
@@ -38,40 +39,44 @@ static int hevc_decode_nal_units(const uint8_t *buf, int buf_size, HEVCParamSets
 
         /* ignore everything except parameter sets and VCL NALUs */
         switch (nal->type) {
-        case NAL_VPS: ff_hevc_decode_nal_vps(&nal->gb, logctx, ps);    break;
-        case NAL_SPS: ff_hevc_decode_nal_sps(&nal->gb, logctx, ps, 1); break;
-        case NAL_PPS: ff_hevc_decode_nal_pps(&nal->gb, logctx, ps);    break;
-        case NAL_TRAIL_R:
-        case NAL_TRAIL_N:
-        case NAL_TSA_N:
-        case NAL_TSA_R:
-        case NAL_STSA_N:
-        case NAL_STSA_R:
-        case NAL_BLA_W_LP:
-        case NAL_BLA_W_RADL:
-        case NAL_BLA_N_LP:
-        case NAL_IDR_W_RADL:
-        case NAL_IDR_N_LP:
-        case NAL_CRA_NUT:
-        case NAL_RADL_N:
-        case NAL_RADL_R:
-        case NAL_RASL_N:
-        case NAL_RASL_R:
-            av_log(logctx, AV_LOG_ERROR, "Invalid NAL unit: %d\n", nal->type);
-            ret = AVERROR_INVALIDDATA;
-            goto done;
+        case HEVC_NAL_VPS:
+            ret = ff_hevc_decode_nal_vps(&nal->gb, logctx, ps);
+            if (ret < 0)
+                goto done;
+            break;
+        case HEVC_NAL_SPS:
+            ret = ff_hevc_decode_nal_sps(&nal->gb, logctx, ps, apply_defdispwin);
+            if (ret < 0)
+                goto done;
+            break;
+        case HEVC_NAL_PPS:
+            ret = ff_hevc_decode_nal_pps(&nal->gb, logctx, ps);
+            if (ret < 0)
+                goto done;
+            break;
+        case HEVC_NAL_SEI_PREFIX:
+        case HEVC_NAL_SEI_SUFFIX:
+            ret = ff_hevc_decode_nal_sei(&nal->gb, logctx, sei, ps, nal->type);
+            if (ret < 0)
+                goto done;
+            break;
+        default:
+            av_log(logctx, AV_LOG_VERBOSE, "Ignoring NAL type %d in extradata\n", nal->type);
             break;
         }
     }
 
 done:
     ff_h2645_packet_uninit(&pkt);
-    return ret;
+    if (err_recognition & AV_EF_EXPLODE)
+        return ret;
+
+    return 0;
 }
 
 int ff_hevc_decode_extradata(const uint8_t *data, int size, HEVCParamSets *ps,
-                             int *is_nalff, int *nal_length_size,
-                             int err_recognition, void *logctx)
+                             HEVCSEIContext *sei, int *is_nalff, int *nal_length_size,
+                             int err_recognition, int apply_defdispwin, void *logctx)
 {
     int ret = 0;
     GetByteContext gb;
@@ -109,7 +114,9 @@ int ff_hevc_decode_extradata(const uint8_t *data, int size, HEVCParamSets *ps,
                     return AVERROR_INVALIDDATA;
                 }
 
-                ret = hevc_decode_nal_units(gb.buffer, nalsize, ps, *is_nalff, *nal_length_size, logctx);
+                ret = hevc_decode_nal_units(gb.buffer, nalsize, ps, sei, *is_nalff,
+                                            *nal_length_size, err_recognition, apply_defdispwin,
+                                            logctx);
                 if (ret < 0) {
                     av_log(logctx, AV_LOG_ERROR,
                            "Decoding nal unit %d %d from hvcC failed\n",
@@ -125,7 +132,8 @@ int ff_hevc_decode_extradata(const uint8_t *data, int size, HEVCParamSets *ps,
         *nal_length_size = nal_len_size;
     } else {
         *is_nalff = 0;
-        ret = hevc_decode_nal_units(data, size, ps, *is_nalff, *nal_length_size, logctx);
+        ret = hevc_decode_nal_units(data, size, ps, sei, *is_nalff, *nal_length_size,
+                                    err_recognition, apply_defdispwin, logctx);
         if (ret < 0)
             return ret;
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_parse.h b/mythtv/external/FFmpeg/libavcodec/hevc_parse.h
index 877356a6871..02e1d5b324b 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_parse.h
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_parse.h
@@ -24,10 +24,13 @@
 #ifndef AVCODEC_HEVC_PARSE_H
 #define AVCODEC_HEVC_PARSE_H
 
-#include "hevc.h"
+#include <stdint.h>
+
+#include "hevc_ps.h"
+#include "hevc_sei.h"
 
 int ff_hevc_decode_extradata(const uint8_t *data, int size, HEVCParamSets *ps,
-                             int *is_nalff, int *nal_length_size,
-                             int err_recognition, void *logctx);
+                             HEVCSEIContext *sei, int *is_nalff, int *nal_length_size,
+                             int err_recognition, int apply_defdispwin, void *logctx);
 
 #endif /* AVCODEC_HEVC_PARSE_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_parser.c b/mythtv/external/FFmpeg/libavcodec/hevc_parser.c
index d93586ba7db..dc63c6b9543 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_parser.c
@@ -24,71 +24,173 @@
 
 #include "golomb.h"
 #include "hevc.h"
+#include "hevc_ps.h"
+#include "hevc_sei.h"
 #include "h2645_parse.h"
+#include "internal.h"
 #include "parser.h"
 
 #define START_CODE 0x000001 ///< start_code_prefix_one_3bytes
 
 #define IS_IRAP_NAL(nal) (nal->type >= 16 && nal->type <= 23)
-
-#define ADVANCED_PARSER CONFIG_HEVC_DECODER
+#define IS_IDR_NAL(nal) (nal->type == HEVC_NAL_IDR_W_RADL || nal->type == HEVC_NAL_IDR_N_LP)
 
 typedef struct HEVCParserContext {
     ParseContext pc;
 
     H2645Packet pkt;
     HEVCParamSets ps;
+    HEVCSEIContext sei;
+    SliceHeader sh;
 
     int parsed_extradata;
 
-#if ADVANCED_PARSER
-    HEVCContext h;
-#endif
+    int poc;
+    int pocTid0;
 } HEVCParserContext;
 
-#if !ADVANCED_PARSER
 static int hevc_parse_slice_header(AVCodecParserContext *s, H2645NAL *nal,
                                    AVCodecContext *avctx)
 {
     HEVCParserContext *ctx = s->priv_data;
+    HEVCParamSets *ps = &ctx->ps;
+    HEVCSEIContext *sei = &ctx->sei;
+    SliceHeader *sh = &ctx->sh;
     GetBitContext *gb = &nal->gb;
+    const HEVCWindow *ow;
+    int i, num = 0, den = 0;
 
-    HEVCPPS *pps;
-    HEVCSPS *sps;
-    unsigned int pps_id;
+    sh->first_slice_in_pic_flag = get_bits1(gb);
+    s->picture_structure = sei->picture_timing.picture_struct;
+    s->field_order = sei->picture_timing.picture_struct;
 
-    get_bits1(gb);          // first slice in pic
-    if (IS_IRAP_NAL(nal))
-        get_bits1(gb);      // no output of prior pics
+    if (IS_IRAP_NAL(nal)) {
+        s->key_frame = 1;
+        sh->no_output_of_prior_pics_flag = get_bits1(gb);
+    }
 
-    pps_id = get_ue_golomb_long(gb);
-    if (pps_id >= MAX_PPS_COUNT || !ctx->ps.pps_list[pps_id]) {
-        av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
+    sh->pps_id = get_ue_golomb(gb);
+    if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !ps->pps_list[sh->pps_id]) {
+        av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
         return AVERROR_INVALIDDATA;
     }
-    pps = (HEVCPPS*)ctx->ps.pps_list[pps_id]->data;
-    sps = (HEVCSPS*)ctx->ps.sps_list[pps->sps_id]->data;
+    ps->pps = (HEVCPPS*)ps->pps_list[sh->pps_id]->data;
 
-    /* export the stream parameters */
-    s->coded_width  = sps->width;
-    s->coded_height = sps->height;
-    s->width        = sps->output_width;
-    s->height       = sps->output_height;
-    s->format       = sps->pix_fmt;
-    avctx->profile  = sps->ptl.general_ptl.profile_idc;
-    avctx->level    = sps->ptl.general_ptl.level_idc;
+    if (ps->pps->sps_id >= HEVC_MAX_SPS_COUNT || !ps->sps_list[ps->pps->sps_id]) {
+        av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", ps->pps->sps_id);
+        return AVERROR_INVALIDDATA;
+    }
+    if (ps->sps != (HEVCSPS*)ps->sps_list[ps->pps->sps_id]->data) {
+        ps->sps = (HEVCSPS*)ps->sps_list[ps->pps->sps_id]->data;
+        ps->vps = (HEVCVPS*)ps->vps_list[ps->sps->vps_id]->data;
+    }
+    ow  = &ps->sps->output_window;
+
+    s->coded_width  = ps->sps->width;
+    s->coded_height = ps->sps->height;
+    s->width        = ps->sps->width  - ow->left_offset - ow->right_offset;
+    s->height       = ps->sps->height - ow->top_offset  - ow->bottom_offset;
+    s->format       = ps->sps->pix_fmt;
+    avctx->profile  = ps->sps->ptl.general_ptl.profile_idc;
+    avctx->level    = ps->sps->ptl.general_ptl.level_idc;
+
+    if (ps->vps->vps_timing_info_present_flag) {
+        num = ps->vps->vps_num_units_in_tick;
+        den = ps->vps->vps_time_scale;
+    } else if (ps->sps->vui.vui_timing_info_present_flag) {
+        num = ps->sps->vui.vui_num_units_in_tick;
+        den = ps->sps->vui.vui_time_scale;
+    }
 
-    /* ignore the rest for now*/
+    if (num != 0 && den != 0)
+        av_reduce(&avctx->framerate.den, &avctx->framerate.num,
+                  num, den, 1 << 30);
+
+    if (!sh->first_slice_in_pic_flag) {
+        int slice_address_length;
+
+        if (ps->pps->dependent_slice_segments_enabled_flag)
+            sh->dependent_slice_segment_flag = get_bits1(gb);
+        else
+            sh->dependent_slice_segment_flag = 0;
+
+        slice_address_length = av_ceil_log2_c(ps->sps->ctb_width *
+                                              ps->sps->ctb_height);
+        sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
+        if (sh->slice_segment_addr >= ps->sps->ctb_width * ps->sps->ctb_height) {
+            av_log(avctx, AV_LOG_ERROR, "Invalid slice segment address: %u.\n",
+                   sh->slice_segment_addr);
+            return AVERROR_INVALIDDATA;
+        }
+    } else
+        sh->dependent_slice_segment_flag = 0;
 
-    return 0;
+    if (sh->dependent_slice_segment_flag)
+        return 0; /* break; */
+
+    for (i = 0; i < ps->pps->num_extra_slice_header_bits; i++)
+        skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
+
+    sh->slice_type = get_ue_golomb(gb);
+    if (!(sh->slice_type == HEVC_SLICE_I || sh->slice_type == HEVC_SLICE_P ||
+          sh->slice_type == HEVC_SLICE_B)) {
+        av_log(avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
+               sh->slice_type);
+        return AVERROR_INVALIDDATA;
+    }
+    s->pict_type = sh->slice_type == HEVC_SLICE_B ? AV_PICTURE_TYPE_B :
+                   sh->slice_type == HEVC_SLICE_P ? AV_PICTURE_TYPE_P :
+                                               AV_PICTURE_TYPE_I;
+
+    if (ps->pps->output_flag_present_flag)
+        sh->pic_output_flag = get_bits1(gb);
+
+    if (ps->sps->separate_colour_plane_flag)
+        sh->colour_plane_id = get_bits(gb, 2);
+
+    if (!IS_IDR_NAL(nal)) {
+        sh->pic_order_cnt_lsb = get_bits(gb, ps->sps->log2_max_poc_lsb);
+        s->output_picture_number = ctx->poc = ff_hevc_compute_poc(ps->sps, ctx->pocTid0, sh->pic_order_cnt_lsb, nal->type);
+    } else
+        s->output_picture_number = ctx->poc = 0;
+
+    if (nal->temporal_id == 0 &&
+        nal->type != HEVC_NAL_TRAIL_N &&
+        nal->type != HEVC_NAL_TSA_N &&
+        nal->type != HEVC_NAL_STSA_N &&
+        nal->type != HEVC_NAL_RADL_N &&
+        nal->type != HEVC_NAL_RASL_N &&
+        nal->type != HEVC_NAL_RADL_R &&
+        nal->type != HEVC_NAL_RASL_R)
+        ctx->pocTid0 = ctx->poc;
+
+    return 1; /* no need to evaluate the rest */
 }
 
+/**
+ * Parse NAL units of found picture and decode some basic information.
+ *
+ * @param s parser context.
+ * @param avctx codec context.
+ * @param buf buffer with field/frame data.
+ * @param buf_size size of the buffer.
+ */
 static int parse_nal_units(AVCodecParserContext *s, const uint8_t *buf,
                            int buf_size, AVCodecContext *avctx)
 {
     HEVCParserContext *ctx = s->priv_data;
+    HEVCParamSets *ps = &ctx->ps;
+    HEVCSEIContext *sei = &ctx->sei;
+    int is_global = buf == avctx->extradata;
     int ret, i;
 
+    /* set some sane default values */
+    s->pict_type         = AV_PICTURE_TYPE_I;
+    s->key_frame         = 0;
+    s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;
+
+    ff_hevc_reset_sei(sei);
+
     ret = ff_h2645_packet_split(&ctx->pkt, buf, buf_size, avctx, 0, 0,
                                 AV_CODEC_ID_HEVC, 1);
     if (ret < 0)
@@ -96,40 +198,55 @@ static int parse_nal_units(AVCodecParserContext *s, const uint8_t *buf,
 
     for (i = 0; i < ctx->pkt.nb_nals; i++) {
         H2645NAL *nal = &ctx->pkt.nals[i];
+        GetBitContext *gb = &nal->gb;
 
-        /* ignore everything except parameter sets and VCL NALUs */
         switch (nal->type) {
-        case NAL_VPS: ff_hevc_decode_nal_vps(&nal->gb, avctx, &ctx->ps);    break;
-        case NAL_SPS: ff_hevc_decode_nal_sps(&nal->gb, avctx, &ctx->ps, 1); break;
-        case NAL_PPS: ff_hevc_decode_nal_pps(&nal->gb, avctx, &ctx->ps);    break;
-        case NAL_TRAIL_R:
-        case NAL_TRAIL_N:
-        case NAL_TSA_N:
-        case NAL_TSA_R:
-        case NAL_STSA_N:
-        case NAL_STSA_R:
-        case NAL_BLA_W_LP:
-        case NAL_BLA_W_RADL:
-        case NAL_BLA_N_LP:
-        case NAL_IDR_W_RADL:
-        case NAL_IDR_N_LP:
-        case NAL_CRA_NUT:
-        case NAL_RADL_N:
-        case NAL_RADL_R:
-        case NAL_RASL_N:
-        case NAL_RASL_R:
-            if (buf == avctx->extradata) {
+        case HEVC_NAL_VPS:
+            ff_hevc_decode_nal_vps(gb, avctx, ps);
+            break;
+        case HEVC_NAL_SPS:
+            ff_hevc_decode_nal_sps(gb, avctx, ps, 1);
+            break;
+        case HEVC_NAL_PPS:
+            ff_hevc_decode_nal_pps(gb, avctx, ps);
+            break;
+        case HEVC_NAL_SEI_PREFIX:
+        case HEVC_NAL_SEI_SUFFIX:
+            ff_hevc_decode_nal_sei(gb, avctx, sei, ps, nal->type);
+            break;
+        case HEVC_NAL_TRAIL_N:
+        case HEVC_NAL_TRAIL_R:
+        case HEVC_NAL_TSA_N:
+        case HEVC_NAL_TSA_R:
+        case HEVC_NAL_STSA_N:
+        case HEVC_NAL_STSA_R:
+        case HEVC_NAL_BLA_W_LP:
+        case HEVC_NAL_BLA_W_RADL:
+        case HEVC_NAL_BLA_N_LP:
+        case HEVC_NAL_IDR_W_RADL:
+        case HEVC_NAL_IDR_N_LP:
+        case HEVC_NAL_CRA_NUT:
+        case HEVC_NAL_RADL_N:
+        case HEVC_NAL_RADL_R:
+        case HEVC_NAL_RASL_N:
+        case HEVC_NAL_RASL_R:
+
+            if (is_global) {
                 av_log(avctx, AV_LOG_ERROR, "Invalid NAL unit: %d\n", nal->type);
                 return AVERROR_INVALIDDATA;
             }
-            hevc_parse_slice_header(s, nal, avctx);
+
+            ret = hevc_parse_slice_header(s, nal, avctx);
+            if (ret)
+                return ret;
             break;
         }
     }
-
-    return 0;
+    /* didn't find a picture! */
+    if (!is_global)
+        av_log(avctx, AV_LOG_ERROR, "missing picture in access unit\n");
+    return -1;
 }
-#endif
 
 /**
  * Find the end of the current frame in the bitstream.
@@ -138,8 +255,9 @@ static int parse_nal_units(AVCodecParserContext *s, const uint8_t *buf,
 static int hevc_find_frame_end(AVCodecParserContext *s, const uint8_t *buf,
                                int buf_size)
 {
+    HEVCParserContext *ctx = s->priv_data;
+    ParseContext       *pc = &ctx->pc;
     int i;
-    ParseContext *pc = s->priv_data;
 
     for (i = 0; i < buf_size; i++) {
         int nut;
@@ -151,14 +269,14 @@ static int hevc_find_frame_end(AVCodecParserContext *s, const uint8_t *buf,
 
         nut = (pc->state64 >> 2 * 8 + 1) & 0x3F;
         // Beginning of access unit
-        if ((nut >= NAL_VPS && nut <= NAL_AUD) || nut == NAL_SEI_PREFIX ||
+        if ((nut >= HEVC_NAL_VPS && nut <= HEVC_NAL_EOB_NUT) || nut == HEVC_NAL_SEI_PREFIX ||
             (nut >= 41 && nut <= 44) || (nut >= 48 && nut <= 55)) {
             if (pc->frame_start_found) {
                 pc->frame_start_found = 0;
                 return i - 5;
             }
-        } else if (nut <= NAL_RASL_R ||
-                   (nut >= NAL_BLA_W_LP && nut <= NAL_CRA_NUT)) {
+        } else if (nut <= HEVC_NAL_RASL_R ||
+                   (nut >= HEVC_NAL_BLA_W_LP && nut <= HEVC_NAL_CRA_NUT)) {
             int first_slice_segment_in_pic_flag = buf[i] >> 7;
             if (first_slice_segment_in_pic_flag) {
                 if (!pc->frame_start_found) {
@@ -174,215 +292,7 @@ static int hevc_find_frame_end(AVCodecParserContext *s, const uint8_t *buf,
     return END_NOT_FOUND;
 }
 
-#if ADVANCED_PARSER
-/**
- * Parse NAL units of found picture and decode some basic information.
- *
- * @param s parser context.
- * @param avctx codec context.
- * @param buf buffer with field/frame data.
- * @param buf_size size of the buffer.
- */
-static inline int parse_nal_units(AVCodecParserContext *s, const uint8_t *buf,
-                           int buf_size, AVCodecContext *avctx)
-{
-    HEVCParserContext *ctx = s->priv_data;
-    HEVCContext       *h   = &ctx->h;
-    GetBitContext      *gb;
-    SliceHeader        *sh = &h->sh;
-    HEVCParamSets *ps = &h->ps;
-    H2645Packet   *pkt = &ctx->pkt;
-    const uint8_t *buf_end = buf + buf_size;
-    int state = -1, i;
-    H2645NAL *nal;
-    int is_global = buf == avctx->extradata;
-
-    if (!h->HEVClc)
-        h->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
-    if (!h->HEVClc)
-        return AVERROR(ENOMEM);
-
-    gb = &h->HEVClc->gb;
-
-    /* set some sane default values */
-    s->pict_type         = AV_PICTURE_TYPE_I;
-    s->key_frame         = 0;
-    s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;
-
-    h->avctx = avctx;
-
-    ff_hevc_reset_sei(h);
-
-    if (!buf_size)
-        return 0;
-
-    if (pkt->nals_allocated < 1) {
-        H2645NAL *tmp = av_realloc_array(pkt->nals, 1, sizeof(*tmp));
-        if (!tmp)
-            return AVERROR(ENOMEM);
-        pkt->nals = tmp;
-        memset(pkt->nals, 0, sizeof(*tmp));
-        pkt->nals_allocated = 1;
-    }
-
-    nal = &pkt->nals[0];
-
-    for (;;) {
-        int src_length, consumed;
-        int ret;
-        buf = avpriv_find_start_code(buf, buf_end, &state);
-        if (--buf + 2 >= buf_end)
-            break;
-        src_length = buf_end - buf;
-
-        h->nal_unit_type = (*buf >> 1) & 0x3f;
-        h->temporal_id   = (*(buf + 1) & 0x07) - 1;
-        if (h->nal_unit_type <= NAL_CRA_NUT) {
-            // Do not walk the whole buffer just to decode slice segment header
-            if (src_length > 20)
-                src_length = 20;
-        }
-
-        consumed = ff_h2645_extract_rbsp(buf, src_length, nal, 1);
-        if (consumed < 0)
-            return consumed;
-
-        ret = init_get_bits8(gb, nal->data + 2, nal->size);
-        if (ret < 0)
-            return ret;
-
-        switch (h->nal_unit_type) {
-        case NAL_VPS:
-            ff_hevc_decode_nal_vps(gb, avctx, ps);
-            break;
-        case NAL_SPS:
-            ff_hevc_decode_nal_sps(gb, avctx, ps, 1);
-            break;
-        case NAL_PPS:
-            ff_hevc_decode_nal_pps(gb, avctx, ps);
-            break;
-        case NAL_SEI_PREFIX:
-        case NAL_SEI_SUFFIX:
-            ff_hevc_decode_nal_sei(h);
-            break;
-        case NAL_TRAIL_N:
-        case NAL_TRAIL_R:
-        case NAL_TSA_N:
-        case NAL_TSA_R:
-        case NAL_STSA_N:
-        case NAL_STSA_R:
-        case NAL_RADL_N:
-        case NAL_RADL_R:
-        case NAL_RASL_N:
-        case NAL_RASL_R:
-        case NAL_BLA_W_LP:
-        case NAL_BLA_W_RADL:
-        case NAL_BLA_N_LP:
-        case NAL_IDR_W_RADL:
-        case NAL_IDR_N_LP:
-        case NAL_CRA_NUT:
-
-            if (is_global) {
-                av_log(avctx, AV_LOG_ERROR, "Invalid NAL unit: %d\n", h->nal_unit_type);
-                return AVERROR_INVALIDDATA;
-            }
-
-            sh->first_slice_in_pic_flag = get_bits1(gb);
-            s->picture_structure = h->picture_struct;
-            s->field_order = h->picture_struct;
-
-            if (IS_IRAP(h)) {
-                s->key_frame = 1;
-                sh->no_output_of_prior_pics_flag = get_bits1(gb);
-            }
-
-            sh->pps_id = get_ue_golomb(gb);
-            if (sh->pps_id >= MAX_PPS_COUNT || !ps->pps_list[sh->pps_id]) {
-                av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
-                return AVERROR_INVALIDDATA;
-            }
-            ps->pps = (HEVCPPS*)ps->pps_list[sh->pps_id]->data;
-
-            if (ps->pps->sps_id >= MAX_SPS_COUNT || !ps->sps_list[ps->pps->sps_id]) {
-                av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", ps->pps->sps_id);
-                return AVERROR_INVALIDDATA;
-            }
-            if (ps->sps != (HEVCSPS*)ps->sps_list[ps->pps->sps_id]->data) {
-                ps->sps = (HEVCSPS*)ps->sps_list[ps->pps->sps_id]->data;
-                ps->vps = (HEVCVPS*)ps->vps_list[ps->sps->vps_id]->data;
-            }
-
-            if (!sh->first_slice_in_pic_flag) {
-                int slice_address_length;
-
-                if (ps->pps->dependent_slice_segments_enabled_flag)
-                    sh->dependent_slice_segment_flag = get_bits1(gb);
-                else
-                    sh->dependent_slice_segment_flag = 0;
-
-                slice_address_length = av_ceil_log2_c(ps->sps->ctb_width *
-                                                      ps->sps->ctb_height);
-                sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
-                if (sh->slice_segment_addr >= ps->sps->ctb_width * ps->sps->ctb_height) {
-                    av_log(avctx, AV_LOG_ERROR, "Invalid slice segment address: %u.\n",
-                           sh->slice_segment_addr);
-                    return AVERROR_INVALIDDATA;
-                }
-            } else
-                sh->dependent_slice_segment_flag = 0;
-
-            if (sh->dependent_slice_segment_flag)
-                break;
-
-            for (i = 0; i < ps->pps->num_extra_slice_header_bits; i++)
-                skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
-
-            sh->slice_type = get_ue_golomb(gb);
-            if (!(sh->slice_type == I_SLICE || sh->slice_type == P_SLICE ||
-                  sh->slice_type == B_SLICE)) {
-                av_log(avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
-                       sh->slice_type);
-                return AVERROR_INVALIDDATA;
-            }
-            s->pict_type = sh->slice_type == B_SLICE ? AV_PICTURE_TYPE_B :
-                           sh->slice_type == P_SLICE ? AV_PICTURE_TYPE_P :
-                                                       AV_PICTURE_TYPE_I;
-
-            if (ps->pps->output_flag_present_flag)
-                sh->pic_output_flag = get_bits1(gb);
-
-            if (ps->sps->separate_colour_plane_flag)
-                sh->colour_plane_id = get_bits(gb, 2);
-
-            if (!IS_IDR(h)) {
-                sh->pic_order_cnt_lsb = get_bits(gb, ps->sps->log2_max_poc_lsb);
-                s->output_picture_number = h->poc = ff_hevc_compute_poc(h, sh->pic_order_cnt_lsb);
-            } else
-                s->output_picture_number = h->poc = 0;
-
-            if (h->temporal_id == 0 &&
-                h->nal_unit_type != NAL_TRAIL_N &&
-                h->nal_unit_type != NAL_TSA_N &&
-                h->nal_unit_type != NAL_STSA_N &&
-                h->nal_unit_type != NAL_RADL_N &&
-                h->nal_unit_type != NAL_RASL_N &&
-                h->nal_unit_type != NAL_RADL_R &&
-                h->nal_unit_type != NAL_RASL_R)
-                h->pocTid0 = h->poc;
-
-            return 0; /* no need to evaluate the rest */
-        }
-        buf += consumed;
-    }
-    /* didn't find a picture! */
-    if (!is_global)
-        av_log(h->avctx, AV_LOG_ERROR, "missing picture in access unit\n");
-    return -1;
-}
-#endif
-
-static int hevc_parse(AVCodecParserContext *s,
-                      AVCodecContext *avctx,
+static int hevc_parse(AVCodecParserContext *s, AVCodecContext *avctx,
                       const uint8_t **poutbuf, int *poutbuf_size,
                       const uint8_t *buf, int buf_size)
 {
@@ -428,14 +338,14 @@ static int hevc_split(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
         if ((state >> 8) != START_CODE)
             break;
         nut = (state >> 1) & 0x3F;
-        if (nut == NAL_VPS)
+        if (nut == HEVC_NAL_VPS)
             has_vps = 1;
-        else if (nut == NAL_SPS)
+        else if (nut == HEVC_NAL_SPS)
             has_sps = 1;
-        else if (nut == NAL_PPS)
+        else if (nut == HEVC_NAL_PPS)
             has_pps = 1;
-        else if ((nut != NAL_SEI_PREFIX || has_pps) &&
-                  nut != NAL_AUD) {
+        else if ((nut != HEVC_NAL_SEI_PREFIX || has_pps) &&
+                  nut != HEVC_NAL_AUD) {
             if (has_vps && has_sps) {
                 while (ptr - 4 > buf && ptr[-5] == 0)
                     ptr--;
@@ -451,21 +361,6 @@ static void hevc_parser_close(AVCodecParserContext *s)
     HEVCParserContext *ctx = s->priv_data;
     int i;
 
-#if ADVANCED_PARSER
-    HEVCContext  *h  = &ctx->h;
-
-    for (i = 0; i < FF_ARRAY_ELEMS(h->ps.vps_list); i++)
-        av_buffer_unref(&h->ps.vps_list[i]);
-    for (i = 0; i < FF_ARRAY_ELEMS(h->ps.sps_list); i++)
-        av_buffer_unref(&h->ps.sps_list[i]);
-    for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++)
-        av_buffer_unref(&h->ps.pps_list[i]);
-
-    h->ps.sps = NULL;
-
-    av_freep(&h->HEVClc);
-#endif
-
     for (i = 0; i < FF_ARRAY_ELEMS(ctx->ps.vps_list); i++)
         av_buffer_unref(&ctx->ps.vps_list[i]);
     for (i = 0; i < FF_ARRAY_ELEMS(ctx->ps.sps_list); i++)
@@ -476,6 +371,7 @@ static void hevc_parser_close(AVCodecParserContext *s)
     ctx->ps.sps = NULL;
 
     ff_h2645_packet_uninit(&ctx->pkt);
+    ff_hevc_reset_sei(&ctx->sei);
 
     av_freep(&ctx->pc.buffer);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_ps.c b/mythtv/external/FFmpeg/libavcodec/hevc_ps.c
index d08ba346ec3..902917d4dda 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_ps.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_ps.c
@@ -25,7 +25,8 @@
 
 #include "libavutil/imgutils.h"
 #include "golomb.h"
-#include "hevc.h"
+#include "hevc_data.h"
+#include "hevc_ps.h"
 
 static const uint8_t default_scaling_list_intra[] = {
     16, 16, 16, 16, 17, 18, 21, 24,
@@ -169,6 +170,12 @@ int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
             }
         }
 
+        if (k >= FF_ARRAY_ELEMS(rps->used)) {
+            av_log(avctx, AV_LOG_ERROR,
+                   "Invalid num_delta_pocs: %d\n", k);
+            return AVERROR_INVALIDDATA;
+        }
+
         rps->num_delta_pocs    = k;
         rps->num_negative_pics = k0;
         // sort in increasing order (smallest first)
@@ -207,8 +214,8 @@ int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
         rps->num_negative_pics = get_ue_golomb_long(gb);
         nb_positive_pics       = get_ue_golomb_long(gb);
 
-        if (rps->num_negative_pics >= MAX_REFS ||
-            nb_positive_pics >= MAX_REFS) {
+        if (rps->num_negative_pics >= HEVC_MAX_REFS ||
+            nb_positive_pics >= HEVC_MAX_REFS) {
             av_log(avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
             return AVERROR_INVALIDDATA;
         }
@@ -218,6 +225,12 @@ int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
             prev = 0;
             for (i = 0; i < rps->num_negative_pics; i++) {
                 delta_poc = get_ue_golomb_long(gb) + 1;
+                if (delta_poc < 1 || delta_poc > 32768) {
+                    av_log(avctx, AV_LOG_ERROR,
+                        "Invalid value of delta_poc: %d\n",
+                        delta_poc);
+                    return AVERROR_INVALIDDATA;
+                }
                 prev -= delta_poc;
                 rps->delta_poc[i] = prev;
                 rps->used[i]      = get_bits1(gb);
@@ -225,6 +238,12 @@ int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
             prev = 0;
             for (i = 0; i < nb_positive_pics; i++) {
                 delta_poc = get_ue_golomb_long(gb) + 1;
+                if (delta_poc < 1 || delta_poc > 32768) {
+                    av_log(avctx, AV_LOG_ERROR,
+                        "Invalid value of delta_poc: %d\n",
+                        delta_poc);
+                    return AVERROR_INVALIDDATA;
+                }
                 prev += delta_poc;
                 rps->delta_poc[rps->num_negative_pics + i] = prev;
                 rps->used[rps->num_negative_pics + i]      = get_bits1(gb);
@@ -421,7 +440,7 @@ int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
     memcpy(vps->data, gb->buffer, vps->data_size);
 
     vps_id = get_bits(gb, 4);
-    if (vps_id >= MAX_VPS_COUNT) {
+    if (vps_id >= HEVC_MAX_VPS_COUNT) {
         av_log(avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", vps_id);
         goto err;
     }
@@ -440,7 +459,7 @@ int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
         goto err;
     }
 
-    if (vps->vps_max_sub_layers > MAX_SUB_LAYERS) {
+    if (vps->vps_max_sub_layers > HEVC_MAX_SUB_LAYERS) {
         av_log(avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
                vps->vps_max_sub_layers);
         goto err;
@@ -457,7 +476,7 @@ int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
         vps->vps_num_reorder_pics[i]      = get_ue_golomb_long(gb);
         vps->vps_max_latency_increase[i]  = get_ue_golomb_long(gb) - 1;
 
-        if (vps->vps_max_dec_pic_buffering[i] > MAX_DPB_SIZE || !vps->vps_max_dec_pic_buffering[i]) {
+        if (vps->vps_max_dec_pic_buffering[i] > HEVC_MAX_DPB_SIZE || !vps->vps_max_dec_pic_buffering[i]) {
             av_log(avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
                    vps->vps_max_dec_pic_buffering[i] - 1);
             goto err;
@@ -531,7 +550,7 @@ int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
 static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
                        int apply_defdispwin, HEVCSPS *sps)
 {
-    VUI *vui          = &sps->vui;
+    VUI backup_vui, *vui = &sps->vui;
     GetBitContext backup;
     int sar_present, alt = 0;
 
@@ -567,11 +586,11 @@ static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
             vui->matrix_coeffs           = get_bits(gb, 8);
 
             // Set invalid values to "unspecified"
-            if (vui->colour_primaries >= AVCOL_PRI_NB)
+            if (!av_color_primaries_name(vui->colour_primaries))
                 vui->colour_primaries = AVCOL_PRI_UNSPECIFIED;
-            if (vui->transfer_characteristic >= AVCOL_TRC_NB)
+            if (!av_color_transfer_name(vui->transfer_characteristic))
                 vui->transfer_characteristic = AVCOL_TRC_UNSPECIFIED;
-            if (vui->matrix_coeffs >= AVCOL_SPC_NB)
+            if (!av_color_space_name(vui->matrix_coeffs))
                 vui->matrix_coeffs = AVCOL_SPC_UNSPECIFIED;
             if (vui->matrix_coeffs == AVCOL_SPC_RGB) {
                 switch (sps->pix_fmt) {
@@ -599,13 +618,14 @@ static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
     vui->field_seq_flag                = get_bits1(gb);
     vui->frame_field_info_present_flag = get_bits1(gb);
 
+    // Backup context in case an alternate header is detected
+    memcpy(&backup, gb, sizeof(backup));
+    memcpy(&backup_vui, vui, sizeof(backup_vui));
     if (get_bits_left(gb) >= 68 && show_bits_long(gb, 21) == 0x100000) {
         vui->default_display_window_flag = 0;
         av_log(avctx, AV_LOG_WARNING, "Invalid default display window\n");
     } else
         vui->default_display_window_flag = get_bits1(gb);
-    // Backup context in case an alternate header is detected
-    memcpy(&backup, gb, sizeof(backup));
 
     if (vui->default_display_window_flag) {
         int vert_mult  = 1 + (sps->chroma_format_idc < 2);
@@ -632,23 +652,24 @@ static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
         }
     }
 
+timing_info:
     vui->vui_timing_info_present_flag = get_bits1(gb);
 
     if (vui->vui_timing_info_present_flag) {
-        if( get_bits_left(gb) < 66) {
+        if( get_bits_left(gb) < 66 && !alt) {
             // The alternate syntax seem to have timing info located
             // at where def_disp_win is normally located
             av_log(avctx, AV_LOG_WARNING,
                    "Strange VUI timing information, retrying...\n");
-            vui->default_display_window_flag = 0;
-            memset(&vui->def_disp_win, 0, sizeof(vui->def_disp_win));
+            memcpy(vui, &backup_vui, sizeof(backup_vui));
             memcpy(gb, &backup, sizeof(backup));
             alt = 1;
+            goto timing_info;
         }
         vui->vui_num_units_in_tick               = get_bits_long(gb, 32);
         vui->vui_time_scale                      = get_bits_long(gb, 32);
         if (alt) {
-            av_log(avctx, AV_LOG_INFO, "Retry got %i/%i fps\n",
+            av_log(avctx, AV_LOG_INFO, "Retry got %"PRIu32"/%"PRIu32" fps\n",
                    vui->vui_time_scale, vui->vui_num_units_in_tick);
         }
         vui->vui_poc_proportional_to_timing_flag = get_bits1(gb);
@@ -661,6 +682,15 @@ static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
 
     vui->bitstream_restriction_flag = get_bits1(gb);
     if (vui->bitstream_restriction_flag) {
+        if (get_bits_left(gb) < 8 && !alt) {
+            av_log(avctx, AV_LOG_WARNING,
+                   "Strange VUI bitstream restriction information, retrying"
+                   " from timing information...\n");
+            memcpy(vui, &backup_vui, sizeof(backup_vui));
+            memcpy(gb, &backup, sizeof(backup));
+            alt = 1;
+            goto timing_info;
+        }
         vui->tiles_fixed_structure_flag              = get_bits1(gb);
         vui->motion_vectors_over_pic_boundaries_flag = get_bits1(gb);
         vui->restricted_ref_pic_lists_flag           = get_bits1(gb);
@@ -670,6 +700,16 @@ static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
         vui->log2_max_mv_length_horizontal           = get_ue_golomb_long(gb);
         vui->log2_max_mv_length_vertical             = get_ue_golomb_long(gb);
     }
+
+    if (get_bits_left(gb) < 1 && !alt) {
+        // XXX: Alternate syntax when sps_range_extension_flag != 0?
+        av_log(avctx, AV_LOG_WARNING,
+               "Overread in VUI, retrying from timing information...\n");
+        memcpy(vui, &backup_vui, sizeof(backup_vui));
+        memcpy(gb, &backup, sizeof(backup));
+        alt = 1;
+        goto timing_info;
+    }
 }
 
 static void set_default_scaling_list_data(ScalingList *sl)
@@ -718,6 +758,7 @@ static int scaling_list_data(GetBitContext *gb, AVCodecContext *avctx, ScalingLi
                  * which should already be in the arrays. */
                 if (delta) {
                     // Copy from previous array.
+                    delta *= (size_id == 3) ? 3 : 1;
                     if (matrix_id < delta) {
                         av_log(avctx, AV_LOG_ERROR,
                                "Invalid delta in scaling list data: %d.\n", delta);
@@ -750,7 +791,7 @@ static int scaling_list_data(GetBitContext *gb, AVCodecContext *avctx, ScalingLi
                                   ff_hevc_diag_scan8x8_x[i];
 
                     scaling_list_delta_coef = get_se_golomb(gb);
-                    next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
+                    next_coef = (next_coef + 256U + scaling_list_delta_coef) % 256;
                     sl->sl[size_id][matrix_id][pos] = next_coef;
                 }
             }
@@ -790,22 +831,21 @@ static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
         if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
         break;
     case 10:
-        if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
+        if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY10;
         if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
         if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
         if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
         break;
     case 12:
-        if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
+        if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY12;
         if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
         if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
         if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
         break;
     default:
         av_log(avctx, AV_LOG_ERROR,
-               "4:2:0, 4:2:2, 4:4:4 supports are currently specified for 8, 10 and 12 bits.\n");
-        av_log(avctx, AV_LOG_ERROR,
-               "chroma_format_idc is %d, depth is %d",
+               "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
+               "chroma_format_idc is %d, depth is %d\n",
                sps->chroma_format_idc, sps->bit_depth);
         return AVERROR_INVALIDDATA;
     }
@@ -826,6 +866,7 @@ static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
 int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
                       int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx)
 {
+    HEVCWindow *ow;
     int ret = 0;
     int log2_diff_max_min_transform_block_size;
     int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
@@ -834,7 +875,7 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
     // Coded parameters
 
     sps->vps_id = get_bits(gb, 4);
-    if (sps->vps_id >= MAX_VPS_COUNT) {
+    if (sps->vps_id >= HEVC_MAX_VPS_COUNT) {
         av_log(avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
         return AVERROR_INVALIDDATA;
     }
@@ -846,19 +887,19 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
     }
 
     sps->max_sub_layers = get_bits(gb, 3) + 1;
-    if (sps->max_sub_layers > MAX_SUB_LAYERS) {
+    if (sps->max_sub_layers > HEVC_MAX_SUB_LAYERS) {
         av_log(avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
                sps->max_sub_layers);
         return AVERROR_INVALIDDATA;
     }
 
-    skip_bits1(gb); // temporal_id_nesting_flag
+    sps->temporal_id_nesting_flag = get_bits(gb, 1);
 
     if ((ret = parse_ptl(gb, avctx, &sps->ptl, sps->max_sub_layers)) < 0)
         return ret;
 
     *sps_id = get_ue_golomb_long(gb);
-    if (*sps_id >= MAX_SPS_COUNT) {
+    if (*sps_id >= HEVC_MAX_SPS_COUNT) {
         av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", *sps_id);
         return AVERROR_INVALIDDATA;
     }
@@ -915,6 +956,7 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
                sps->bit_depth, bit_depth_chroma);
         return AVERROR_INVALIDDATA;
     }
+    sps->bit_depth_chroma = bit_depth_chroma;
 
     ret = map_pixel_format(avctx, sps);
     if (ret < 0)
@@ -933,16 +975,16 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
         sps->temporal_layer[i].max_dec_pic_buffering = get_ue_golomb_long(gb) + 1;
         sps->temporal_layer[i].num_reorder_pics      = get_ue_golomb_long(gb);
         sps->temporal_layer[i].max_latency_increase  = get_ue_golomb_long(gb) - 1;
-        if (sps->temporal_layer[i].max_dec_pic_buffering > MAX_DPB_SIZE) {
+        if (sps->temporal_layer[i].max_dec_pic_buffering > (unsigned)HEVC_MAX_DPB_SIZE) {
             av_log(avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
-                   sps->temporal_layer[i].max_dec_pic_buffering - 1);
+                   sps->temporal_layer[i].max_dec_pic_buffering - 1U);
             return AVERROR_INVALIDDATA;
         }
         if (sps->temporal_layer[i].num_reorder_pics > sps->temporal_layer[i].max_dec_pic_buffering - 1) {
             av_log(avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
                    sps->temporal_layer[i].num_reorder_pics);
             if (avctx->err_recognition & AV_EF_EXPLODE ||
-                sps->temporal_layer[i].num_reorder_pics > MAX_DPB_SIZE - 1) {
+                sps->temporal_layer[i].num_reorder_pics > HEVC_MAX_DPB_SIZE - 1) {
                 return AVERROR_INVALIDDATA;
             }
             sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[i].num_reorder_pics + 1;
@@ -1008,10 +1050,10 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
         sps->pcm.log2_min_pcm_cb_size = get_ue_golomb_long(gb) + 3;
         sps->pcm.log2_max_pcm_cb_size = sps->pcm.log2_min_pcm_cb_size +
                                         get_ue_golomb_long(gb);
-        if (sps->pcm.bit_depth > sps->bit_depth) {
+        if (FFMAX(sps->pcm.bit_depth, sps->pcm.bit_depth_chroma) > sps->bit_depth) {
             av_log(avctx, AV_LOG_ERROR,
-                   "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
-                   sps->pcm.bit_depth, sps->bit_depth);
+                   "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
+                   sps->pcm.bit_depth, sps->pcm.bit_depth_chroma, sps->bit_depth);
             return AVERROR_INVALIDDATA;
         }
 
@@ -1019,7 +1061,7 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
     }
 
     sps->nb_st_rps = get_ue_golomb_long(gb);
-    if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
+    if (sps->nb_st_rps > HEVC_MAX_SHORT_TERM_RPS_COUNT) {
         av_log(avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
                sps->nb_st_rps);
         return AVERROR_INVALIDDATA;
@@ -1092,30 +1134,21 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
         sps->output_window.top_offset    += sps->vui.def_disp_win.top_offset;
         sps->output_window.bottom_offset += sps->vui.def_disp_win.bottom_offset;
     }
-    if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift)) &&
-        !(avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
-        sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));
-        av_log(avctx, AV_LOG_WARNING, "Reducing left output window to %d "
-               "chroma samples to preserve alignment.\n",
-               sps->output_window.left_offset);
-    }
-    sps->output_width  = sps->width -
-                         (sps->output_window.left_offset + sps->output_window.right_offset);
-    sps->output_height = sps->height -
-                         (sps->output_window.top_offset + sps->output_window.bottom_offset);
-    if (sps->width  <= sps->output_window.left_offset + (int64_t)sps->output_window.right_offset  ||
-        sps->height <= sps->output_window.top_offset  + (int64_t)sps->output_window.bottom_offset) {
-        av_log(avctx, AV_LOG_WARNING, "Invalid visible frame dimensions: %dx%d.\n",
-               sps->output_width, sps->output_height);
+
+    ow = &sps->output_window;
+    if (ow->left_offset >= INT_MAX - ow->right_offset     ||
+        ow->top_offset  >= INT_MAX - ow->bottom_offset    ||
+        ow->left_offset + ow->right_offset  >= sps->width ||
+        ow->top_offset  + ow->bottom_offset >= sps->height) {
+        av_log(avctx, AV_LOG_WARNING, "Invalid cropping offsets: %u/%u/%u/%u\n",
+               ow->left_offset, ow->right_offset, ow->top_offset, ow->bottom_offset);
         if (avctx->err_recognition & AV_EF_EXPLODE) {
             return AVERROR_INVALIDDATA;
         }
         av_log(avctx, AV_LOG_WARNING,
                "Displaying the whole video surface.\n");
+        memset(ow, 0, sizeof(*ow));
         memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));
-        memset(&sps->output_window, 0, sizeof(sps->output_window));
-        sps->output_width               = sps->width;
-        sps->output_height              = sps->height;
     }
 
     // Inferred parameters
@@ -1123,7 +1156,7 @@ int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
                          sps->log2_diff_max_min_coding_block_size;
     sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
 
-    if (sps->log2_ctb_size > MAX_LOG2_CTB_SIZE) {
+    if (sps->log2_ctb_size > HEVC_MAX_LOG2_CTB_SIZE) {
         av_log(avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
         return AVERROR_INVALIDDATA;
     }
@@ -1221,7 +1254,8 @@ int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
                "Parsed SPS: id %d; coded wxh: %dx%d; "
                "cropped wxh: %dx%d; pix_fmt: %s.\n",
                sps_id, sps->width, sps->height,
-               sps->output_width, sps->output_height,
+               sps->width - (sps->output_window.left_offset + sps->output_window.right_offset),
+               sps->height - (sps->output_window.top_offset + sps->output_window.bottom_offset),
                av_get_pix_fmt_name(sps->pix_fmt));
     }
 
@@ -1269,7 +1303,7 @@ static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx,
     if (pps->chroma_qp_offset_list_enabled_flag) {
         pps->diff_cu_chroma_qp_offset_depth = get_ue_golomb_long(gb);
         pps->chroma_qp_offset_list_len_minus1 = get_ue_golomb_long(gb);
-        if (pps->chroma_qp_offset_list_len_minus1 && pps->chroma_qp_offset_list_len_minus1 >= 5) {
+        if (pps->chroma_qp_offset_list_len_minus1 > 5) {
             av_log(avctx, AV_LOG_ERROR,
                    "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
             return AVERROR_INVALIDDATA;
@@ -1432,6 +1466,7 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
     int i, ret = 0;
     unsigned int pps_id = 0;
     ptrdiff_t nal_size;
+    unsigned log2_parallel_merge_level_minus2;
 
     AVBufferRef *pps_buf;
     HEVCPPS *pps = av_mallocz(sizeof(*pps));
@@ -1471,13 +1506,13 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
 
     // Coded parameters
     pps_id = get_ue_golomb_long(gb);
-    if (pps_id >= MAX_PPS_COUNT) {
+    if (pps_id >= HEVC_MAX_PPS_COUNT) {
         av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
         ret = AVERROR_INVALIDDATA;
         goto err;
     }
     pps->sps_id = get_ue_golomb_long(gb);
-    if (pps->sps_id >= MAX_SPS_COUNT) {
+    if (pps->sps_id >= HEVC_MAX_SPS_COUNT) {
         av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
         ret = AVERROR_INVALIDDATA;
         goto err;
@@ -1602,20 +1637,22 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
         pps->deblocking_filter_override_enabled_flag = get_bits1(gb);
         pps->disable_dbf                             = get_bits1(gb);
         if (!pps->disable_dbf) {
-            pps->beta_offset = get_se_golomb(gb) * 2;
-            pps->tc_offset = get_se_golomb(gb) * 2;
-            if (pps->beta_offset/2 < -6 || pps->beta_offset/2 > 6) {
+            int beta_offset_div2 = get_se_golomb(gb);
+            int tc_offset_div2   = get_se_golomb(gb) ;
+            if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
                 av_log(avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
-                       pps->beta_offset/2);
+                       beta_offset_div2);
                 ret = AVERROR_INVALIDDATA;
                 goto err;
             }
-            if (pps->tc_offset/2 < -6 || pps->tc_offset/2 > 6) {
+            if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
                 av_log(avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
-                       pps->tc_offset/2);
+                       tc_offset_div2);
                 ret = AVERROR_INVALIDDATA;
                 goto err;
             }
+            pps->beta_offset = 2 * beta_offset_div2;
+            pps->tc_offset   = 2 *   tc_offset_div2;
         }
     }
 
@@ -1627,13 +1664,14 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
             goto err;
     }
     pps->lists_modification_present_flag = get_bits1(gb);
-    pps->log2_parallel_merge_level       = get_ue_golomb_long(gb) + 2;
-    if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
+    log2_parallel_merge_level_minus2     = get_ue_golomb_long(gb);
+    if (log2_parallel_merge_level_minus2 > sps->log2_ctb_size) {
         av_log(avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
-               pps->log2_parallel_merge_level - 2);
+               log2_parallel_merge_level_minus2);
         ret = AVERROR_INVALIDDATA;
         goto err;
     }
+    pps->log2_parallel_merge_level       = log2_parallel_merge_level_minus2 + 2;
 
     pps->slice_header_extension_present_flag = get_bits1(gb);
 
@@ -1665,3 +1703,26 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
     av_buffer_unref(&pps_buf);
     return ret;
 }
+
+int ff_hevc_compute_poc(const HEVCSPS *sps, int pocTid0, int poc_lsb, int nal_unit_type)
+{
+    int max_poc_lsb  = 1 << sps->log2_max_poc_lsb;
+    int prev_poc_lsb = pocTid0 % max_poc_lsb;
+    int prev_poc_msb = pocTid0 - prev_poc_lsb;
+    int poc_msb;
+
+    if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
+        poc_msb = prev_poc_msb + max_poc_lsb;
+    else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
+        poc_msb = prev_poc_msb - max_poc_lsb;
+    else
+        poc_msb = prev_poc_msb;
+
+    // For BLA picture types, POCmsb is set to 0.
+    if (nal_unit_type == HEVC_NAL_BLA_W_LP   ||
+        nal_unit_type == HEVC_NAL_BLA_W_RADL ||
+        nal_unit_type == HEVC_NAL_BLA_N_LP)
+        poc_msb = 0;
+
+    return poc_msb + poc_lsb;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_ps.h b/mythtv/external/FFmpeg/libavcodec/hevc_ps.h
new file mode 100644
index 00000000000..76f8eb31e6a
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_ps.h
@@ -0,0 +1,435 @@
+/*
+ * HEVC parameter set parsing
+ *
+ * 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_HEVC_PS_H
+#define AVCODEC_HEVC_PS_H
+
+#include <stdint.h>
+
+#include "libavutil/buffer.h"
+#include "libavutil/pixfmt.h"
+#include "libavutil/rational.h"
+
+#include "avcodec.h"
+#include "get_bits.h"
+#include "hevc.h"
+
+typedef struct ShortTermRPS {
+    unsigned int num_negative_pics;
+    int num_delta_pocs;
+    int rps_idx_num_delta_pocs;
+    int32_t delta_poc[32];
+    uint8_t used[32];
+} ShortTermRPS;
+
+typedef struct LongTermRPS {
+    int     poc[32];
+    uint8_t used[32];
+    uint8_t nb_refs;
+} LongTermRPS;
+
+typedef struct SliceHeader {
+    unsigned int pps_id;
+
+    ///< address (in raster order) of the first block in the current slice segment
+    unsigned int   slice_segment_addr;
+    ///< address (in raster order) of the first block in the current slice
+    unsigned int   slice_addr;
+
+    enum HEVCSliceType slice_type;
+
+    int pic_order_cnt_lsb;
+
+    uint8_t first_slice_in_pic_flag;
+    uint8_t dependent_slice_segment_flag;
+    uint8_t pic_output_flag;
+    uint8_t colour_plane_id;
+
+    ///< RPS coded in the slice header itself is stored here
+    int short_term_ref_pic_set_sps_flag;
+    int short_term_ref_pic_set_size;
+    ShortTermRPS slice_rps;
+    const ShortTermRPS *short_term_rps;
+    int long_term_ref_pic_set_size;
+    LongTermRPS long_term_rps;
+    unsigned int list_entry_lx[2][32];
+
+    uint8_t rpl_modification_flag[2];
+    uint8_t no_output_of_prior_pics_flag;
+    uint8_t slice_temporal_mvp_enabled_flag;
+
+    unsigned int nb_refs[2];
+
+    uint8_t slice_sample_adaptive_offset_flag[3];
+    uint8_t mvd_l1_zero_flag;
+
+    uint8_t cabac_init_flag;
+    uint8_t disable_deblocking_filter_flag; ///< slice_header_disable_deblocking_filter_flag
+    uint8_t slice_loop_filter_across_slices_enabled_flag;
+    uint8_t collocated_list;
+
+    unsigned int collocated_ref_idx;
+
+    int slice_qp_delta;
+    int slice_cb_qp_offset;
+    int slice_cr_qp_offset;
+
+    uint8_t cu_chroma_qp_offset_enabled_flag;
+
+    int beta_offset;    ///< beta_offset_div2 * 2
+    int tc_offset;      ///< tc_offset_div2 * 2
+
+    unsigned int max_num_merge_cand; ///< 5 - 5_minus_max_num_merge_cand
+
+    unsigned *entry_point_offset;
+    int * offset;
+    int * size;
+    int num_entry_point_offsets;
+
+    int8_t slice_qp;
+
+    uint8_t luma_log2_weight_denom;
+    int16_t chroma_log2_weight_denom;
+
+    int16_t luma_weight_l0[16];
+    int16_t chroma_weight_l0[16][2];
+    int16_t chroma_weight_l1[16][2];
+    int16_t luma_weight_l1[16];
+
+    int16_t luma_offset_l0[16];
+    int16_t chroma_offset_l0[16][2];
+
+    int16_t luma_offset_l1[16];
+    int16_t chroma_offset_l1[16][2];
+
+    int slice_ctb_addr_rs;
+} SliceHeader;
+
+typedef struct HEVCWindow {
+    unsigned int left_offset;
+    unsigned int right_offset;
+    unsigned int top_offset;
+    unsigned int bottom_offset;
+} HEVCWindow;
+
+typedef struct VUI {
+    AVRational sar;
+
+    int overscan_info_present_flag;
+    int overscan_appropriate_flag;
+
+    int video_signal_type_present_flag;
+    int video_format;
+    int video_full_range_flag;
+    int colour_description_present_flag;
+    uint8_t colour_primaries;
+    uint8_t transfer_characteristic;
+    uint8_t matrix_coeffs;
+
+    int chroma_loc_info_present_flag;
+    int chroma_sample_loc_type_top_field;
+    int chroma_sample_loc_type_bottom_field;
+    int neutra_chroma_indication_flag;
+
+    int field_seq_flag;
+    int frame_field_info_present_flag;
+
+    int default_display_window_flag;
+    HEVCWindow def_disp_win;
+
+    int vui_timing_info_present_flag;
+    uint32_t vui_num_units_in_tick;
+    uint32_t vui_time_scale;
+    int vui_poc_proportional_to_timing_flag;
+    int vui_num_ticks_poc_diff_one_minus1;
+    int vui_hrd_parameters_present_flag;
+
+    int bitstream_restriction_flag;
+    int tiles_fixed_structure_flag;
+    int motion_vectors_over_pic_boundaries_flag;
+    int restricted_ref_pic_lists_flag;
+    int min_spatial_segmentation_idc;
+    int max_bytes_per_pic_denom;
+    int max_bits_per_min_cu_denom;
+    int log2_max_mv_length_horizontal;
+    int log2_max_mv_length_vertical;
+} VUI;
+
+typedef struct PTLCommon {
+    uint8_t profile_space;
+    uint8_t tier_flag;
+    uint8_t profile_idc;
+    uint8_t profile_compatibility_flag[32];
+    uint8_t level_idc;
+    uint8_t progressive_source_flag;
+    uint8_t interlaced_source_flag;
+    uint8_t non_packed_constraint_flag;
+    uint8_t frame_only_constraint_flag;
+} PTLCommon;
+
+typedef struct PTL {
+    PTLCommon general_ptl;
+    PTLCommon sub_layer_ptl[HEVC_MAX_SUB_LAYERS];
+
+    uint8_t sub_layer_profile_present_flag[HEVC_MAX_SUB_LAYERS];
+    uint8_t sub_layer_level_present_flag[HEVC_MAX_SUB_LAYERS];
+} PTL;
+
+typedef struct HEVCVPS {
+    uint8_t vps_temporal_id_nesting_flag;
+    int vps_max_layers;
+    int vps_max_sub_layers; ///< vps_max_temporal_layers_minus1 + 1
+
+    PTL ptl;
+    int vps_sub_layer_ordering_info_present_flag;
+    unsigned int vps_max_dec_pic_buffering[HEVC_MAX_SUB_LAYERS];
+    unsigned int vps_num_reorder_pics[HEVC_MAX_SUB_LAYERS];
+    unsigned int vps_max_latency_increase[HEVC_MAX_SUB_LAYERS];
+    int vps_max_layer_id;
+    int vps_num_layer_sets; ///< vps_num_layer_sets_minus1 + 1
+    uint8_t vps_timing_info_present_flag;
+    uint32_t vps_num_units_in_tick;
+    uint32_t vps_time_scale;
+    uint8_t vps_poc_proportional_to_timing_flag;
+    int vps_num_ticks_poc_diff_one; ///< vps_num_ticks_poc_diff_one_minus1 + 1
+    int vps_num_hrd_parameters;
+
+    uint8_t data[4096];
+    int data_size;
+} HEVCVPS;
+
+typedef struct ScalingList {
+    /* This is a little wasteful, since sizeID 0 only needs 8 coeffs,
+     * and size ID 3 only has 2 arrays, not 6. */
+    uint8_t sl[4][6][64];
+    uint8_t sl_dc[2][6];
+} ScalingList;
+
+typedef struct HEVCSPS {
+    unsigned vps_id;
+    int chroma_format_idc;
+    uint8_t separate_colour_plane_flag;
+
+    HEVCWindow output_window;
+
+    HEVCWindow pic_conf_win;
+
+    int bit_depth;
+    int bit_depth_chroma;
+    int pixel_shift;
+    enum AVPixelFormat pix_fmt;
+
+    unsigned int log2_max_poc_lsb;
+    int pcm_enabled_flag;
+
+    int max_sub_layers;
+    struct {
+        int max_dec_pic_buffering;
+        int num_reorder_pics;
+        int max_latency_increase;
+    } temporal_layer[HEVC_MAX_SUB_LAYERS];
+    uint8_t temporal_id_nesting_flag;
+
+    VUI vui;
+    PTL ptl;
+
+    uint8_t scaling_list_enable_flag;
+    ScalingList scaling_list;
+
+    unsigned int nb_st_rps;
+    ShortTermRPS st_rps[HEVC_MAX_SHORT_TERM_RPS_COUNT];
+
+    uint8_t amp_enabled_flag;
+    uint8_t sao_enabled;
+
+    uint8_t long_term_ref_pics_present_flag;
+    uint16_t lt_ref_pic_poc_lsb_sps[32];
+    uint8_t used_by_curr_pic_lt_sps_flag[32];
+    uint8_t num_long_term_ref_pics_sps;
+
+    struct {
+        uint8_t bit_depth;
+        uint8_t bit_depth_chroma;
+        unsigned int log2_min_pcm_cb_size;
+        unsigned int log2_max_pcm_cb_size;
+        uint8_t loop_filter_disable_flag;
+    } pcm;
+    uint8_t sps_temporal_mvp_enabled_flag;
+    uint8_t sps_strong_intra_smoothing_enable_flag;
+
+    unsigned int log2_min_cb_size;
+    unsigned int log2_diff_max_min_coding_block_size;
+    unsigned int log2_min_tb_size;
+    unsigned int log2_max_trafo_size;
+    unsigned int log2_ctb_size;
+    unsigned int log2_min_pu_size;
+
+    int max_transform_hierarchy_depth_inter;
+    int max_transform_hierarchy_depth_intra;
+
+    int transform_skip_rotation_enabled_flag;
+    int transform_skip_context_enabled_flag;
+    int implicit_rdpcm_enabled_flag;
+    int explicit_rdpcm_enabled_flag;
+    int intra_smoothing_disabled_flag;
+    int persistent_rice_adaptation_enabled_flag;
+
+    ///< coded frame dimension in various units
+    int width;
+    int height;
+    int ctb_width;
+    int ctb_height;
+    int ctb_size;
+    int min_cb_width;
+    int min_cb_height;
+    int min_tb_width;
+    int min_tb_height;
+    int min_pu_width;
+    int min_pu_height;
+    int tb_mask;
+
+    int hshift[3];
+    int vshift[3];
+
+    int qp_bd_offset;
+
+    uint8_t data[4096];
+    int data_size;
+} HEVCSPS;
+
+typedef struct HEVCPPS {
+    unsigned int sps_id; ///< seq_parameter_set_id
+
+    uint8_t sign_data_hiding_flag;
+
+    uint8_t cabac_init_present_flag;
+
+    int num_ref_idx_l0_default_active; ///< num_ref_idx_l0_default_active_minus1 + 1
+    int num_ref_idx_l1_default_active; ///< num_ref_idx_l1_default_active_minus1 + 1
+    int pic_init_qp_minus26;
+
+    uint8_t constrained_intra_pred_flag;
+    uint8_t transform_skip_enabled_flag;
+
+    uint8_t cu_qp_delta_enabled_flag;
+    int diff_cu_qp_delta_depth;
+
+    int cb_qp_offset;
+    int cr_qp_offset;
+    uint8_t pic_slice_level_chroma_qp_offsets_present_flag;
+    uint8_t weighted_pred_flag;
+    uint8_t weighted_bipred_flag;
+    uint8_t output_flag_present_flag;
+    uint8_t transquant_bypass_enable_flag;
+
+    uint8_t dependent_slice_segments_enabled_flag;
+    uint8_t tiles_enabled_flag;
+    uint8_t entropy_coding_sync_enabled_flag;
+
+    int num_tile_columns;   ///< num_tile_columns_minus1 + 1
+    int num_tile_rows;      ///< num_tile_rows_minus1 + 1
+    uint8_t uniform_spacing_flag;
+    uint8_t loop_filter_across_tiles_enabled_flag;
+
+    uint8_t seq_loop_filter_across_slices_enabled_flag;
+
+    uint8_t deblocking_filter_control_present_flag;
+    uint8_t deblocking_filter_override_enabled_flag;
+    uint8_t disable_dbf;
+    int beta_offset;    ///< beta_offset_div2 * 2
+    int tc_offset;      ///< tc_offset_div2 * 2
+
+    uint8_t scaling_list_data_present_flag;
+    ScalingList scaling_list;
+
+    uint8_t lists_modification_present_flag;
+    int log2_parallel_merge_level; ///< log2_parallel_merge_level_minus2 + 2
+    int num_extra_slice_header_bits;
+    uint8_t slice_header_extension_present_flag;
+    uint8_t log2_max_transform_skip_block_size;
+    uint8_t cross_component_prediction_enabled_flag;
+    uint8_t chroma_qp_offset_list_enabled_flag;
+    uint8_t diff_cu_chroma_qp_offset_depth;
+    uint8_t chroma_qp_offset_list_len_minus1;
+    int8_t  cb_qp_offset_list[6];
+    int8_t  cr_qp_offset_list[6];
+    uint8_t log2_sao_offset_scale_luma;
+    uint8_t log2_sao_offset_scale_chroma;
+
+    // Inferred parameters
+    unsigned int *column_width;  ///< ColumnWidth
+    unsigned int *row_height;    ///< RowHeight
+    unsigned int *col_bd;        ///< ColBd
+    unsigned int *row_bd;        ///< RowBd
+    int *col_idxX;
+
+    int *ctb_addr_rs_to_ts; ///< CtbAddrRSToTS
+    int *ctb_addr_ts_to_rs; ///< CtbAddrTSToRS
+    int *tile_id;           ///< TileId
+    int *tile_pos_rs;       ///< TilePosRS
+    int *min_tb_addr_zs;    ///< MinTbAddrZS
+    int *min_tb_addr_zs_tab;///< MinTbAddrZS
+
+    uint8_t data[4096];
+    int data_size;
+} HEVCPPS;
+
+typedef struct HEVCParamSets {
+    AVBufferRef *vps_list[HEVC_MAX_VPS_COUNT];
+    AVBufferRef *sps_list[HEVC_MAX_SPS_COUNT];
+    AVBufferRef *pps_list[HEVC_MAX_PPS_COUNT];
+
+    /* currently active parameter sets */
+    const HEVCVPS *vps;
+    const HEVCSPS *sps;
+    const HEVCPPS *pps;
+} HEVCParamSets;
+
+/**
+ * Parse the SPS from the bitstream into the provided HEVCSPS struct.
+ *
+ * @param sps_id the SPS id will be written here
+ * @param apply_defdispwin if set 1, the default display window from the VUI
+ *                         will be applied to the video dimensions
+ * @param vps_list if non-NULL, this function will validate that the SPS refers
+ *                 to an existing VPS
+ */
+int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
+                      int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx);
+
+int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
+                           HEVCParamSets *ps);
+int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
+                           HEVCParamSets *ps, int apply_defdispwin);
+int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
+                           HEVCParamSets *ps);
+
+int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
+                                  ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header);
+
+int ff_hevc_encode_nal_vps(HEVCVPS *vps, unsigned int id,
+                           uint8_t *buf, int buf_size);
+
+/**
+ * Compute POC of the current frame and return it.
+ */
+int ff_hevc_compute_poc(const HEVCSPS *sps, int pocTid0, int poc_lsb, int nal_unit_type);
+
+#endif /* AVCODEC_HEVC_PS_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_ps_enc.c b/mythtv/external/FFmpeg/libavcodec/hevc_ps_enc.c
index c05bf63d3b2..4c71cf41ca3 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_ps_enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_ps_enc.c
@@ -19,7 +19,7 @@
  */
 
 #include "golomb.h"
-#include "hevc.h"
+#include "hevc_ps.h"
 #include "put_bits.h"
 
 static void write_ptl_layer(PutBitContext *pb, PTLCommon *ptl)
@@ -90,9 +90,10 @@ int ff_hevc_encode_nal_vps(HEVCVPS *vps, unsigned int id,
     put_bits(&pb, 6, vps->vps_max_layer_id);
     set_ue_golomb(&pb, vps->vps_num_layer_sets - 1);
 
-    // writing layer_id_included_flag not supported
-    if (vps->vps_num_layer_sets > 1)
+    if (vps->vps_num_layer_sets > 1) {
+        avpriv_report_missing_feature(NULL, "Writing layer_id_included_flag");
         return AVERROR_PATCHWELCOME;
+    }
 
     put_bits(&pb, 1, vps->vps_timing_info_present_flag);
     if (vps->vps_timing_info_present_flag) {
@@ -102,9 +103,10 @@ int ff_hevc_encode_nal_vps(HEVCVPS *vps, unsigned int id,
         if (vps->vps_poc_proportional_to_timing_flag)
             set_ue_golomb(&pb, vps->vps_num_ticks_poc_diff_one - 1);
 
-        // writing HRD parameters not supported
-        if (vps->vps_num_hrd_parameters)
+        if (vps->vps_num_hrd_parameters) {
+            avpriv_report_missing_feature(NULL, "Writing HRD parameters");
             return AVERROR_PATCHWELCOME;
+        }
     }
 
     put_bits(&pb, 1, 0);    // extension flag
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_refs.c b/mythtv/external/FFmpeg/libavcodec/hevc_refs.c
index 611ad458def..ac462d350b0 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_refs.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_refs.c
@@ -27,6 +27,7 @@
 #include "internal.h"
 #include "thread.h"
 #include "hevc.h"
+#include "hevcdec.h"
 
 void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
 {
@@ -108,8 +109,8 @@ static HEVCFrame *alloc_frame(HEVCContext *s)
         for (j = 0; j < frame->ctb_count; j++)
             frame->rpl_tab[j] = (RefPicListTab *)frame->rpl_buf->data;
 
-        frame->frame->top_field_first  = s->picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD;
-        frame->frame->interlaced_frame = (s->picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD) || (s->picture_struct == AV_PICTURE_STRUCTURE_BOTTOM_FIELD);
+        frame->frame->top_field_first  = s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD;
+        frame->frame->interlaced_frame = (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD) || (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_BOTTOM_FIELD);
 
         if (s->avctx->hwaccel) {
             const AVHWAccel *hwaccel = s->avctx->hwaccel;
@@ -162,7 +163,10 @@ int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)
 
     ref->poc      = poc;
     ref->sequence = s->seq_decode;
-    ref->window   = s->ps.sps->output_window;
+    ref->frame->crop_left   = s->ps.sps->output_window.left_offset;
+    ref->frame->crop_right  = s->ps.sps->output_window.right_offset;
+    ref->frame->crop_top    = s->ps.sps->output_window.top_offset;
+    ref->frame->crop_bottom = s->ps.sps->output_window.bottom_offset;
 
     return 0;
 }
@@ -203,12 +207,11 @@ int ff_hevc_output_frame(HEVCContext *s, AVFrame *out, int flush)
 
         if (nb_output) {
             HEVCFrame *frame = &s->DPB[min_idx];
-            AVFrame *dst = out;
-            AVFrame *src = frame->frame;
-            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(src->format);
-            int pixel_shift = !!(desc->comp[0].depth > 8);
 
-            ret = av_frame_ref(out, src);
+            if (frame->frame->format == AV_PIX_FMT_VIDEOTOOLBOX && frame->frame->buf[0]->size == 1)
+                return 0;
+
+            ret = av_frame_ref(out, frame->frame);
             if (frame->flags & HEVC_FRAME_FLAG_BUMPING)
                 ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT | HEVC_FRAME_FLAG_BUMPING);
             else
@@ -216,13 +219,6 @@ int ff_hevc_output_frame(HEVCContext *s, AVFrame *out, int flush)
             if (ret < 0)
                 return ret;
 
-            for (i = 0; i < 3; i++) {
-                int hshift = (i > 0) ? desc->log2_chroma_w : 0;
-                int vshift = (i > 0) ? desc->log2_chroma_h : 0;
-                int off = ((frame->window.left_offset >> hshift) << pixel_shift) +
-                          (frame->window.top_offset   >> vshift) * dst->linesize[i];
-                dst->data[i] += off;
-            }
             av_log(s->avctx, AV_LOG_DEBUG,
                    "Output frame with POC %d.\n", frame->poc);
             return 1;
@@ -299,7 +295,7 @@ int ff_hevc_slice_rpl(HEVCContext *s)
 {
     SliceHeader *sh = &s->sh;
 
-    uint8_t nb_list = sh->slice_type == B_SLICE ? 2 : 1;
+    uint8_t nb_list = sh->slice_type == HEVC_SLICE_B ? 2 : 1;
     uint8_t list_idx;
     int i, j, ret;
 
@@ -328,7 +324,7 @@ int ff_hevc_slice_rpl(HEVCContext *s)
         while (rpl_tmp.nb_refs < sh->nb_refs[list_idx]) {
             for (i = 0; i < FF_ARRAY_ELEMS(cand_lists); i++) {
                 RefPicList *rps = &s->rps[cand_lists[i]];
-                for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < MAX_REFS; j++) {
+                for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < HEVC_MAX_REFS; j++) {
                     rpl_tmp.list[rpl_tmp.nb_refs]       = rps->list[j];
                     rpl_tmp.ref[rpl_tmp.nb_refs]        = rps->ref[j];
                     rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = i == 2;
@@ -386,7 +382,7 @@ static HEVCFrame *find_ref_idx(HEVCContext *s, int poc)
         }
     }
 
-    if (s->nal_unit_type != NAL_CRA_NUT && !IS_BLA(s))
+    if (s->nal_unit_type != HEVC_NAL_CRA_NUT && !IS_BLA(s))
         av_log(s->avctx, AV_LOG_ERROR,
                "Could not find ref with POC %d\n", poc);
     return NULL;
@@ -438,7 +434,7 @@ static int add_candidate_ref(HEVCContext *s, RefPicList *list,
 {
     HEVCFrame *ref = find_ref_idx(s, poc);
 
-    if (ref == s->ref)
+    if (ref == s->ref || list->nb_refs >= HEVC_MAX_REFS)
         return AVERROR_INVALIDDATA;
 
     if (!ref) {
@@ -515,29 +511,6 @@ int ff_hevc_frame_rps(HEVCContext *s)
     return ret;
 }
 
-int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb)
-{
-    int max_poc_lsb  = 1 << s->ps.sps->log2_max_poc_lsb;
-    int prev_poc_lsb = s->pocTid0 % max_poc_lsb;
-    int prev_poc_msb = s->pocTid0 - prev_poc_lsb;
-    int poc_msb;
-
-    if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
-        poc_msb = prev_poc_msb + max_poc_lsb;
-    else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
-        poc_msb = prev_poc_msb - max_poc_lsb;
-    else
-        poc_msb = prev_poc_msb;
-
-    // For BLA picture types, POCmsb is set to 0.
-    if (s->nal_unit_type == NAL_BLA_W_LP   ||
-        s->nal_unit_type == NAL_BLA_W_RADL ||
-        s->nal_unit_type == NAL_BLA_N_LP)
-        poc_msb = 0;
-
-    return poc_msb + poc_lsb;
-}
-
 int ff_hevc_frame_nb_refs(HEVCContext *s)
 {
     int ret = 0;
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_sei.c b/mythtv/external/FFmpeg/libavcodec/hevc_sei.c
index 148f246df1f..d0f9966a295 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc_sei.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_sei.c
@@ -23,43 +23,15 @@
  */
 
 #include "golomb.h"
-#include "hevc.h"
-
-enum HEVC_SEI_TYPE {
-    SEI_TYPE_BUFFERING_PERIOD                     = 0,
-    SEI_TYPE_PICTURE_TIMING                       = 1,
-    SEI_TYPE_PAN_SCAN_RECT                        = 2,
-    SEI_TYPE_FILLER_PAYLOAD                       = 3,
-    SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35       = 4,
-    SEI_TYPE_USER_DATA_UNREGISTERED               = 5,
-    SEI_TYPE_RECOVERY_POINT                       = 6,
-    SEI_TYPE_SCENE_INFO                           = 9,
-    SEI_TYPE_FULL_FRAME_SNAPSHOT                  = 15,
-    SEI_TYPE_PROGRESSIVE_REFINEMENT_SEGMENT_START = 16,
-    SEI_TYPE_PROGRESSIVE_REFINEMENT_SEGMENT_END   = 17,
-    SEI_TYPE_FILM_GRAIN_CHARACTERISTICS           = 19,
-    SEI_TYPE_POST_FILTER_HINT                     = 22,
-    SEI_TYPE_TONE_MAPPING_INFO                    = 23,
-    SEI_TYPE_FRAME_PACKING                        = 45,
-    SEI_TYPE_DISPLAY_ORIENTATION                  = 47,
-    SEI_TYPE_SOP_DESCRIPTION                      = 128,
-    SEI_TYPE_ACTIVE_PARAMETER_SETS                = 129,
-    SEI_TYPE_DECODING_UNIT_INFO                   = 130,
-    SEI_TYPE_TEMPORAL_LEVEL0_INDEX                = 131,
-    SEI_TYPE_DECODED_PICTURE_HASH                 = 132,
-    SEI_TYPE_SCALABLE_NESTING                     = 133,
-    SEI_TYPE_REGION_REFRESH_INFO                  = 134,
-    SEI_TYPE_MASTERING_DISPLAY_INFO               = 137,
-    SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO             = 144,
-};
-
-static int decode_nal_sei_decoded_picture_hash(HEVCContext *s)
+#include "hevc_ps.h"
+#include "hevc_sei.h"
+
+static int decode_nal_sei_decoded_picture_hash(HEVCSEIPictureHash *s, GetBitContext *gb)
 {
     int cIdx, i;
     uint8_t hash_type;
     //uint16_t picture_crc;
     //uint32_t picture_checksum;
-    GetBitContext *gb = &s->HEVClc->gb;
     hash_type = get_bits(gb, 8);
 
     for (cIdx = 0; cIdx < 3/*((s->sps->chroma_format_idc == 0) ? 1 : 3)*/; cIdx++) {
@@ -78,9 +50,8 @@ static int decode_nal_sei_decoded_picture_hash(HEVCContext *s)
     return 0;
 }
 
-static int decode_nal_sei_mastering_display_info(HEVCContext *s)
+static int decode_nal_sei_mastering_display_info(HEVCSEIMasteringDisplay *s, GetBitContext *gb)
 {
-    GetBitContext *gb = &s->HEVClc->gb;
     int i;
     // Mastering primaries
     for (i = 0; i < 3; i++) {
@@ -92,25 +63,35 @@ static int decode_nal_sei_mastering_display_info(HEVCContext *s)
     s->white_point[1] = get_bits(gb, 16);
 
     // Max and min luminance of mastering display
-    s->max_mastering_luminance = get_bits_long(gb, 32);
-    s->min_mastering_luminance = get_bits_long(gb, 32);
+    s->max_luminance = get_bits_long(gb, 32);
+    s->min_luminance = get_bits_long(gb, 32);
 
     // As this SEI message comes before the first frame that references it,
     // initialize the flag to 2 and decrement on IRAP access unit so it
     // persists for the coded video sequence (e.g., between two IRAPs)
-    s->sei_mastering_display_info_present = 2;
+    s->present = 2;
     return 0;
 }
 
-static int decode_nal_sei_frame_packing_arrangement(HEVCContext *s)
+static int decode_nal_sei_content_light_info(HEVCSEIContentLight *s, GetBitContext *gb)
 {
-    GetBitContext *gb = &s->HEVClc->gb;
+    // Max and average light levels
+    s->max_content_light_level     = get_bits_long(gb, 16);
+    s->max_pic_average_light_level = get_bits_long(gb, 16);
+    // As this SEI message comes before the first frame that references it,
+    // initialize the flag to 2 and decrement on IRAP access unit so it
+    // persists for the coded video sequence (e.g., between two IRAPs)
+    s->present = 2;
+    return  0;
+}
 
+static int decode_nal_sei_frame_packing_arrangement(HEVCSEIFramePacking *s, GetBitContext *gb)
+{
     get_ue_golomb_long(gb);             // frame_packing_arrangement_id
-    s->sei_frame_packing_present = !get_bits1(gb);
+    s->present = !get_bits1(gb);
 
-    if (s->sei_frame_packing_present) {
-        s->frame_packing_arrangement_type = get_bits(gb, 7);
+    if (s->present) {
+        s->arrangement_type               = get_bits(gb, 7);
         s->quincunx_subsampling           = get_bits1(gb);
         s->content_interpretation_type    = get_bits(gb, 6);
 
@@ -119,7 +100,7 @@ static int decode_nal_sei_frame_packing_arrangement(HEVCContext *s)
         // frame0_self_contained_flag frame1_self_contained_flag
         skip_bits(gb, 6);
 
-        if (!s->quincunx_subsampling && s->frame_packing_arrangement_type != 5)
+        if (!s->quincunx_subsampling && s->arrangement_type != 5)
             skip_bits(gb, 16);  // frame[01]_grid_position_[xy]
         skip_bits(gb, 8);       // frame_packing_arrangement_reserved_byte
         skip_bits1(gb);         // frame_packing_arrangement_persistence_flag
@@ -128,56 +109,58 @@ static int decode_nal_sei_frame_packing_arrangement(HEVCContext *s)
     return 0;
 }
 
-static int decode_nal_sei_display_orientation(HEVCContext *s)
+static int decode_nal_sei_display_orientation(HEVCSEIDisplayOrientation *s, GetBitContext *gb)
 {
-    GetBitContext *gb = &s->HEVClc->gb;
+    s->present = !get_bits1(gb);
 
-    s->sei_display_orientation_present = !get_bits1(gb);
+    if (s->present) {
+        s->hflip = get_bits1(gb);     // hor_flip
+        s->vflip = get_bits1(gb);     // ver_flip
 
-    if (s->sei_display_orientation_present) {
-        s->sei_hflip = get_bits1(gb);     // hor_flip
-        s->sei_vflip = get_bits1(gb);     // ver_flip
-
-        s->sei_anticlockwise_rotation = get_bits(gb, 16);
+        s->anticlockwise_rotation = get_bits(gb, 16);
         skip_bits1(gb);     // display_orientation_persistence_flag
     }
 
     return 0;
 }
 
-static int decode_pic_timing(HEVCContext *s)
+static int decode_nal_sei_pic_timing(HEVCSEIContext *s, GetBitContext *gb, const HEVCParamSets *ps,
+                                     void *logctx, int size)
 {
-    GetBitContext *gb = &s->HEVClc->gb;
+    HEVCSEIPictureTiming *h = &s->picture_timing;
     HEVCSPS *sps;
 
-    if (!s->ps.sps_list[s->active_seq_parameter_set_id])
+    if (!ps->sps_list[s->active_seq_parameter_set_id])
         return(AVERROR(ENOMEM));
-    sps = (HEVCSPS*)s->ps.sps_list[s->active_seq_parameter_set_id]->data;
+    sps = (HEVCSPS*)ps->sps_list[s->active_seq_parameter_set_id]->data;
 
     if (sps->vui.frame_field_info_present_flag) {
         int pic_struct = get_bits(gb, 4);
-        s->picture_struct = AV_PICTURE_STRUCTURE_UNKNOWN;
-        if (pic_struct == 2) {
-            av_log(s->avctx, AV_LOG_DEBUG, "BOTTOM Field\n");
-            s->picture_struct = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;
-        } else if (pic_struct == 1) {
-            av_log(s->avctx, AV_LOG_DEBUG, "TOP Field\n");
-            s->picture_struct = AV_PICTURE_STRUCTURE_TOP_FIELD;
+        h->picture_struct = AV_PICTURE_STRUCTURE_UNKNOWN;
+        if (pic_struct == 2 || pic_struct == 10 || pic_struct == 12) {
+            av_log(logctx, AV_LOG_DEBUG, "BOTTOM Field\n");
+            h->picture_struct = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;
+        } else if (pic_struct == 1 || pic_struct == 9 || pic_struct == 11) {
+            av_log(logctx, AV_LOG_DEBUG, "TOP Field\n");
+            h->picture_struct = AV_PICTURE_STRUCTURE_TOP_FIELD;
         }
         get_bits(gb, 2);                   // source_scan_type
         get_bits(gb, 1);                   // duplicate_flag
+        skip_bits1(gb);
+        size--;
     }
-    return 1;
+    skip_bits_long(gb, 8 * size);
+
+    return 0;
 }
 
-static int decode_registered_user_data_closed_caption(HEVCContext *s, int size)
+static int decode_registered_user_data_closed_caption(HEVCSEIA53Caption *s, GetBitContext *gb,
+                                                      int size)
 {
     int flag;
     int user_data_type_code;
     int cc_count;
 
-    GetBitContext *gb = &s->HEVClc->gb;
-
     if (size < 3)
        return AVERROR(EINVAL);
 
@@ -222,13 +205,12 @@ static int decode_registered_user_data_closed_caption(HEVCContext *s, int size)
     return 0;
 }
 
-static int decode_nal_sei_user_data_registered_itu_t_t35(HEVCContext *s, int size)
+static int decode_nal_sei_user_data_registered_itu_t_t35(HEVCSEIContext *s, GetBitContext *gb,
+                                                         int size)
 {
     uint32_t country_code;
     uint32_t user_identifier;
 
-    GetBitContext *gb = &s->HEVClc->gb;
-
     if (size < 7)
         return AVERROR(EINVAL);
     size -= 7;
@@ -246,7 +228,7 @@ static int decode_nal_sei_user_data_registered_itu_t_t35(HEVCContext *s, int siz
 
     switch (user_identifier) {
         case MKBETAG('G', 'A', '9', '4'):
-            return decode_registered_user_data_closed_caption(s, size);
+            return decode_registered_user_data_closed_caption(&s->a53_caption, gb, size);
         default:
             skip_bits_long(gb, size * 8);
             break;
@@ -254,9 +236,8 @@ static int decode_nal_sei_user_data_registered_itu_t_t35(HEVCContext *s, int siz
     return 0;
 }
 
-static int active_parameter_sets(HEVCContext *s)
+static int decode_nal_sei_active_parameter_sets(HEVCSEIContext *s, GetBitContext *gb, void *logctx)
 {
-    GetBitContext *gb = &s->HEVClc->gb;
     int num_sps_ids_minus1;
     int i;
     unsigned active_seq_parameter_set_id;
@@ -267,13 +248,13 @@ static int active_parameter_sets(HEVCContext *s)
     num_sps_ids_minus1 = get_ue_golomb_long(gb); // num_sps_ids_minus1
 
     if (num_sps_ids_minus1 < 0 || num_sps_ids_minus1 > 15) {
-        av_log(s->avctx, AV_LOG_ERROR, "num_sps_ids_minus1 %d invalid\n", num_sps_ids_minus1);
+        av_log(logctx, AV_LOG_ERROR, "num_sps_ids_minus1 %d invalid\n", num_sps_ids_minus1);
         return AVERROR_INVALIDDATA;
     }
 
     active_seq_parameter_set_id = get_ue_golomb_long(gb);
-    if (active_seq_parameter_set_id >= MAX_SPS_COUNT) {
-        av_log(s->avctx, AV_LOG_ERROR, "active_parameter_set_id %d invalid\n", active_seq_parameter_set_id);
+    if (active_seq_parameter_set_id >= HEVC_MAX_SPS_COUNT) {
+        av_log(logctx, AV_LOG_ERROR, "active_parameter_set_id %d invalid\n", active_seq_parameter_set_id);
         return AVERROR_INVALIDDATA;
     }
     s->active_seq_parameter_set_id = active_seq_parameter_set_id;
@@ -284,61 +265,63 @@ static int active_parameter_sets(HEVCContext *s)
     return 0;
 }
 
-static int decode_nal_sei_prefix(HEVCContext *s, int type, int size)
+static int decode_nal_sei_alternative_transfer(HEVCSEIAlternativeTransfer *s, GetBitContext *gb)
 {
-    GetBitContext *gb = &s->HEVClc->gb;
+    s->present = 1;
+    s->preferred_transfer_characteristics = get_bits(gb, 8);
+    return 0;
+}
 
+static int decode_nal_sei_prefix(GetBitContext *gb, HEVCSEIContext *s, const HEVCParamSets *ps,
+                                 int type, int size, void *logctx)
+{
     switch (type) {
     case 256:  // Mismatched value from HM 8.1
-        return decode_nal_sei_decoded_picture_hash(s);
-    case SEI_TYPE_FRAME_PACKING:
-        return decode_nal_sei_frame_packing_arrangement(s);
-    case SEI_TYPE_DISPLAY_ORIENTATION:
-        return decode_nal_sei_display_orientation(s);
-    case SEI_TYPE_PICTURE_TIMING:
-        {
-            int ret = decode_pic_timing(s);
-            av_log(s->avctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type);
-            skip_bits(gb, 8 * size);
-            return ret;
-        }
-    case SEI_TYPE_MASTERING_DISPLAY_INFO:
-        return decode_nal_sei_mastering_display_info(s);
-    case SEI_TYPE_ACTIVE_PARAMETER_SETS:
-        active_parameter_sets(s);
-        av_log(s->avctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type);
-        return 0;
-    case SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35:
-        return decode_nal_sei_user_data_registered_itu_t_t35(s, size);
+        return decode_nal_sei_decoded_picture_hash(&s->picture_hash, gb);
+    case HEVC_SEI_TYPE_FRAME_PACKING:
+        return decode_nal_sei_frame_packing_arrangement(&s->frame_packing, gb);
+    case HEVC_SEI_TYPE_DISPLAY_ORIENTATION:
+        return decode_nal_sei_display_orientation(&s->display_orientation, gb);
+    case HEVC_SEI_TYPE_PICTURE_TIMING:
+        return decode_nal_sei_pic_timing(s, gb, ps, logctx, size);
+    case HEVC_SEI_TYPE_MASTERING_DISPLAY_INFO:
+        return decode_nal_sei_mastering_display_info(&s->mastering_display, gb);
+    case HEVC_SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO:
+        return decode_nal_sei_content_light_info(&s->content_light, gb);
+    case HEVC_SEI_TYPE_ACTIVE_PARAMETER_SETS:
+        return decode_nal_sei_active_parameter_sets(s, gb, logctx);
+    case HEVC_SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35:
+        return decode_nal_sei_user_data_registered_itu_t_t35(s, gb, size);
+    case HEVC_SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS:
+        return decode_nal_sei_alternative_transfer(&s->alternative_transfer, gb);
     default:
-        av_log(s->avctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type);
+        av_log(logctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type);
         skip_bits_long(gb, 8 * size);
         return 0;
     }
 }
 
-static int decode_nal_sei_suffix(HEVCContext *s, int type, int size)
+static int decode_nal_sei_suffix(GetBitContext *gb, HEVCSEIContext *s,
+                                 int type, int size, void *logctx)
 {
-    GetBitContext *gb = &s->HEVClc->gb;
-
     switch (type) {
-    case SEI_TYPE_DECODED_PICTURE_HASH:
-        return decode_nal_sei_decoded_picture_hash(s);
+    case HEVC_SEI_TYPE_DECODED_PICTURE_HASH:
+        return decode_nal_sei_decoded_picture_hash(&s->picture_hash, gb);
     default:
-        av_log(s->avctx, AV_LOG_DEBUG, "Skipped SUFFIX SEI %d\n", type);
+        av_log(logctx, AV_LOG_DEBUG, "Skipped SUFFIX SEI %d\n", type);
         skip_bits_long(gb, 8 * size);
         return 0;
     }
 }
 
-static int decode_nal_sei_message(HEVCContext *s)
+static int decode_nal_sei_message(GetBitContext *gb, HEVCSEIContext *s,
+                                  const HEVCParamSets *ps, int nal_unit_type,
+                                  void *logctx)
 {
-    GetBitContext *gb = &s->HEVClc->gb;
-
     int payload_type = 0;
     int payload_size = 0;
     int byte = 0xFF;
-    av_log(s->avctx, AV_LOG_DEBUG, "Decoding SEI\n");
+    av_log(logctx, AV_LOG_DEBUG, "Decoding SEI\n");
 
     while (byte == 0xFF) {
         byte          = get_bits(gb, 8);
@@ -349,12 +332,11 @@ static int decode_nal_sei_message(HEVCContext *s)
         byte          = get_bits(gb, 8);
         payload_size += byte;
     }
-    if (s->nal_unit_type == NAL_SEI_PREFIX) {
-        return decode_nal_sei_prefix(s, payload_type, payload_size);
+    if (nal_unit_type == HEVC_NAL_SEI_PREFIX) {
+        return decode_nal_sei_prefix(gb, s, ps, payload_type, payload_size, logctx);
     } else { /* nal_unit_type == NAL_SEI_SUFFIX */
-        return decode_nal_sei_suffix(s, payload_type, payload_size);
+        return decode_nal_sei_suffix(gb, s, payload_type, payload_size, logctx);
     }
-    return 1;
 }
 
 static int more_rbsp_data(GetBitContext *gb)
@@ -362,20 +344,21 @@ static int more_rbsp_data(GetBitContext *gb)
     return get_bits_left(gb) > 0 && show_bits(gb, 8) != 0x80;
 }
 
-int ff_hevc_decode_nal_sei(HEVCContext *s)
+int ff_hevc_decode_nal_sei(GetBitContext *gb, void *logctx, HEVCSEIContext *s,
+                           const HEVCParamSets *ps, int type)
 {
     int ret;
 
     do {
-        ret = decode_nal_sei_message(s);
+        ret = decode_nal_sei_message(gb, s, ps, type, logctx);
         if (ret < 0)
-            return(AVERROR(ENOMEM));
-    } while (more_rbsp_data(&s->HEVClc->gb));
+            return ret;
+    } while (more_rbsp_data(gb));
     return 1;
 }
 
-void ff_hevc_reset_sei(HEVCContext *s)
+void ff_hevc_reset_sei(HEVCSEIContext *s)
 {
-    s->a53_caption_size = 0;
-    av_freep(&s->a53_caption);
+    s->a53_caption.a53_caption_size = 0;
+    av_freep(&s->a53_caption.a53_caption);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc_sei.h b/mythtv/external/FFmpeg/libavcodec/hevc_sei.h
new file mode 100644
index 00000000000..1b522227ecf
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/hevc_sei.h
@@ -0,0 +1,135 @@
+/*
+ * HEVC Supplementary Enhancement Information messages
+ *
+ * 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_HEVC_SEI_H
+#define AVCODEC_HEVC_SEI_H
+
+#include <stdint.h>
+
+#include "libavutil/md5.h"
+
+#include "get_bits.h"
+
+/**
+ * SEI message types
+ */
+typedef enum {
+    HEVC_SEI_TYPE_BUFFERING_PERIOD                     = 0,
+    HEVC_SEI_TYPE_PICTURE_TIMING                       = 1,
+    HEVC_SEI_TYPE_PAN_SCAN_RECT                        = 2,
+    HEVC_SEI_TYPE_FILLER_PAYLOAD                       = 3,
+    HEVC_SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35       = 4,
+    HEVC_SEI_TYPE_USER_DATA_UNREGISTERED               = 5,
+    HEVC_SEI_TYPE_RECOVERY_POINT                       = 6,
+    HEVC_SEI_TYPE_SCENE_INFO                           = 9,
+    HEVC_SEI_TYPE_FULL_FRAME_SNAPSHOT                  = 15,
+    HEVC_SEI_TYPE_PROGRESSIVE_REFINEMENT_SEGMENT_START = 16,
+    HEVC_SEI_TYPE_PROGRESSIVE_REFINEMENT_SEGMENT_END   = 17,
+    HEVC_SEI_TYPE_FILM_GRAIN_CHARACTERISTICS           = 19,
+    HEVC_SEI_TYPE_POST_FILTER_HINT                     = 22,
+    HEVC_SEI_TYPE_TONE_MAPPING_INFO                    = 23,
+    HEVC_SEI_TYPE_FRAME_PACKING                        = 45,
+    HEVC_SEI_TYPE_DISPLAY_ORIENTATION                  = 47,
+    HEVC_SEI_TYPE_SOP_DESCRIPTION                      = 128,
+    HEVC_SEI_TYPE_ACTIVE_PARAMETER_SETS                = 129,
+    HEVC_SEI_TYPE_DECODING_UNIT_INFO                   = 130,
+    HEVC_SEI_TYPE_TEMPORAL_LEVEL0_INDEX                = 131,
+    HEVC_SEI_TYPE_DECODED_PICTURE_HASH                 = 132,
+    HEVC_SEI_TYPE_SCALABLE_NESTING                     = 133,
+    HEVC_SEI_TYPE_REGION_REFRESH_INFO                  = 134,
+    HEVC_SEI_TYPE_MASTERING_DISPLAY_INFO               = 137,
+    HEVC_SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO             = 144,
+    HEVC_SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS = 147,
+} HEVC_SEI_Type;
+
+typedef struct HEVCSEIPictureHash {
+    struct AVMD5 *md5_ctx;
+    uint8_t       md5[3][16];
+    uint8_t is_md5;
+} HEVCSEIPictureHash;
+
+typedef struct HEVCSEIFramePacking {
+    int present;
+    int arrangement_type;
+    int content_interpretation_type;
+    int quincunx_subsampling;
+} HEVCSEIFramePacking;
+
+typedef struct HEVCSEIDisplayOrientation {
+    int present;
+    int anticlockwise_rotation;
+    int hflip, vflip;
+} HEVCSEIDisplayOrientation;
+
+typedef struct HEVCSEIPictureTiming {
+    int picture_struct;
+} HEVCSEIPictureTiming;
+
+typedef struct HEVCSEIA53Caption {
+    int a53_caption_size;
+    uint8_t *a53_caption;
+} HEVCSEIA53Caption;
+
+typedef struct HEVCSEIMasteringDisplay {
+    int present;
+    uint16_t display_primaries[3][2];
+    uint16_t white_point[2];
+    uint32_t max_luminance;
+    uint32_t min_luminance;
+} HEVCSEIMasteringDisplay;
+
+typedef struct HEVCSEIContentLight {
+    int present;
+    uint16_t max_content_light_level;
+    uint16_t max_pic_average_light_level;
+} HEVCSEIContentLight;
+
+typedef struct HEVCSEIAlternativeTransfer {
+    int present;
+    int preferred_transfer_characteristics;
+} HEVCSEIAlternativeTransfer;
+
+typedef struct HEVCSEIContext {
+    HEVCSEIPictureHash picture_hash;
+    HEVCSEIFramePacking frame_packing;
+    HEVCSEIDisplayOrientation display_orientation;
+    HEVCSEIPictureTiming picture_timing;
+    HEVCSEIA53Caption a53_caption;
+    HEVCSEIMasteringDisplay mastering_display;
+    HEVCSEIContentLight content_light;
+    int active_seq_parameter_set_id;
+    HEVCSEIAlternativeTransfer alternative_transfer;
+} HEVCSEIContext;
+
+struct HEVCParamSets;
+
+int ff_hevc_decode_nal_sei(GetBitContext *gb, void *logctx, HEVCSEIContext *s,
+                           const struct HEVCParamSets *ps, int type);
+
+/**
+ * Reset SEI values that are stored on the Context.
+ * e.g. Caption data that was extracted during NAL
+ * parsing.
+ *
+ * @param s HEVCContext.
+ */
+void ff_hevc_reset_sei(HEVCSEIContext *s);
+
+#endif /* AVCODEC_HEVC_SEI_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/hevc.c b/mythtv/external/FFmpeg/libavcodec/hevcdec.c
similarity index 90%
rename from mythtv/external/FFmpeg/libavcodec/hevc.c
rename to mythtv/external/FFmpeg/libavcodec/hevcdec.c
index 764e0938bbd..2e4add2ae30 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevc.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevcdec.c
@@ -23,7 +23,6 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "libavutil/atomic.h"
 #include "libavutil/attributes.h"
 #include "libavutil/common.h"
 #include "libavutil/display.h"
@@ -39,6 +38,9 @@
 #include "cabac_functions.h"
 #include "golomb.h"
 #include "hevc.h"
+#include "hevc_data.h"
+#include "hevc_parse.h"
+#include "hevcdec.h"
 #include "profiles.h"
 
 const uint8_t ff_hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
@@ -137,7 +139,7 @@ static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
     return AVERROR(ENOMEM);
 }
 
-static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
+static int pred_weight_table(HEVCContext *s, GetBitContext *gb)
 {
     int i = 0;
     int j = 0;
@@ -180,6 +182,12 @@ static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
             for (j = 0; j < 2; j++) {
                 int delta_chroma_weight_l0 = get_se_golomb(gb);
                 int delta_chroma_offset_l0 = get_se_golomb(gb);
+
+                if (   (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
+                    || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
+                    return AVERROR_INVALIDDATA;
+                }
+
                 s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
                 s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
                                                                                     >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
@@ -191,7 +199,7 @@ static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
             s->sh.chroma_offset_l0[i][1] = 0;
         }
     }
-    if (s->sh.slice_type == B_SLICE) {
+    if (s->sh.slice_type == HEVC_SLICE_B) {
         for (i = 0; i < s->sh.nb_refs[L1]; i++) {
             luma_weight_l1_flag[i] = get_bits1(gb);
             if (!luma_weight_l1_flag[i]) {
@@ -216,6 +224,12 @@ static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
                 for (j = 0; j < 2; j++) {
                     int delta_chroma_weight_l1 = get_se_golomb(gb);
                     int delta_chroma_offset_l1 = get_se_golomb(gb);
+
+                    if (   (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
+                        || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
+                        return AVERROR_INVALIDDATA;
+                    }
+
                     s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
                     s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
                                                                                         >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
@@ -228,6 +242,7 @@ static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
             }
         }
     }
+    return 0;
 }
 
 static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
@@ -246,6 +261,8 @@ static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
         nb_sps = get_ue_golomb_long(gb);
     nb_sh = get_ue_golomb_long(gb);
 
+    if (nb_sps > sps->num_long_term_ref_pics_sps)
+        return AVERROR_INVALIDDATA;
     if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
         return AVERROR_INVALIDDATA;
 
@@ -269,12 +286,16 @@ static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
 
         delta_poc_msb_present = get_bits1(gb);
         if (delta_poc_msb_present) {
-            int delta = get_ue_golomb_long(gb);
+            int64_t delta = get_ue_golomb_long(gb);
+            int64_t poc;
 
             if (i && i != nb_sps)
                 delta += prev_delta_msb;
 
-            rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
+            poc = rps->poc[i] + s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
+            if (poc != (int32_t)poc)
+                return AVERROR_INVALIDDATA;
+            rps->poc[i] = poc;
             prev_delta_msb = delta;
         }
     }
@@ -286,13 +307,14 @@ static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
                                  const HEVCSPS *sps)
 {
     const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
+    const HEVCWindow *ow = &sps->output_window;
     unsigned int num = 0, den = 0;
 
     avctx->pix_fmt             = sps->pix_fmt;
     avctx->coded_width         = sps->width;
     avctx->coded_height        = sps->height;
-    avctx->width               = sps->output_width;
-    avctx->height              = sps->output_height;
+    avctx->width               = sps->width  - ow->left_offset - ow->right_offset;
+    avctx->height              = sps->height - ow->top_offset  - ow->bottom_offset;
     avctx->has_b_frames        = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
     avctx->profile             = sps->ptl.general_ptl.profile_idc;
     avctx->level               = sps->ptl.general_ptl.level_idc;
@@ -328,24 +350,14 @@ static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
                   num, den, 1 << 30);
 }
 
-static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fmt)
+static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
 {
-    #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
+#define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
+                     CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
+                     CONFIG_HEVC_VAAPI_HWACCEL + \
+                     CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
+                     CONFIG_HEVC_VDPAU_HWACCEL)
     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
-    int ret, i;
-
-    pic_arrays_free(s);
-    s->ps.sps = NULL;
-    s->ps.vps = NULL;
-
-    if (!sps)
-        return 0;
-
-    ret = pic_arrays_init(s, sps);
-    if (ret < 0)
-        goto fail;
-
-    export_stream_params(s->avctx, &s->ps, sps);
 
     switch (sps->pix_fmt) {
     case AV_PIX_FMT_YUV420P:
@@ -355,12 +367,16 @@ static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fm
 #endif
 #if CONFIG_HEVC_D3D11VA_HWACCEL
         *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
+        *fmt++ = AV_PIX_FMT_D3D11;
 #endif
 #if CONFIG_HEVC_VAAPI_HWACCEL
         *fmt++ = AV_PIX_FMT_VAAPI;
 #endif
 #if CONFIG_HEVC_VDPAU_HWACCEL
         *fmt++ = AV_PIX_FMT_VDPAU;
+#endif
+#if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
+        *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
 #endif
         break;
     case AV_PIX_FMT_YUV420P10:
@@ -369,25 +385,42 @@ static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fm
 #endif
 #if CONFIG_HEVC_D3D11VA_HWACCEL
         *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
+        *fmt++ = AV_PIX_FMT_D3D11;
 #endif
 #if CONFIG_HEVC_VAAPI_HWACCEL
         *fmt++ = AV_PIX_FMT_VAAPI;
+#endif
+#if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
+        *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
 #endif
         break;
     }
 
-    if (pix_fmt == AV_PIX_FMT_NONE) {
-        *fmt++ = sps->pix_fmt;
-        *fmt = AV_PIX_FMT_NONE;
+    *fmt++ = sps->pix_fmt;
+    *fmt = AV_PIX_FMT_NONE;
 
-        ret = ff_thread_get_format(s->avctx, pix_fmts);
-        if (ret < 0)
-            goto fail;
-        s->avctx->pix_fmt = ret;
-    }
-    else {
-        s->avctx->pix_fmt = pix_fmt;
-    }
+    return ff_thread_get_format(s->avctx, pix_fmts);
+}
+
+static int set_sps(HEVCContext *s, const HEVCSPS *sps,
+                   enum AVPixelFormat pix_fmt)
+{
+    int ret, i;
+
+    pic_arrays_free(s);
+    s->ps.sps = NULL;
+    s->ps.vps = NULL;
+
+    if (!sps)
+        return 0;
+
+    ret = pic_arrays_init(s, sps);
+    if (ret < 0)
+        goto fail;
+
+    export_stream_params(s->avctx, &s->ps, sps);
+
+    s->avctx->pix_fmt = pix_fmt;
 
     ff_hevc_pred_init(&s->hpc,     sps->bit_depth);
     ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
@@ -444,7 +477,7 @@ static int hls_slice_header(HEVCContext *s)
         sh->no_output_of_prior_pics_flag = get_bits1(gb);
 
     sh->pps_id = get_ue_golomb_long(gb);
-    if (sh->pps_id >= MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
+    if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
         av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
         return AVERROR_INVALIDDATA;
     }
@@ -454,20 +487,27 @@ static int hls_slice_header(HEVCContext *s)
         return AVERROR_INVALIDDATA;
     }
     s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
-    if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)
+    if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
         sh->no_output_of_prior_pics_flag = 1;
 
     if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
-        const HEVCSPS* last_sps = s->ps.sps;
-        s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
-        if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {
-            if (s->ps.sps->width !=  last_sps->width || s->ps.sps->height != last_sps->height ||
-                s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering !=
+        const HEVCSPS *sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
+        const HEVCSPS *last_sps = s->ps.sps;
+        enum AVPixelFormat pix_fmt;
+
+        if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) {
+            if (sps->width != last_sps->width || sps->height != last_sps->height ||
+                sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering !=
                 last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
                 sh->no_output_of_prior_pics_flag = 0;
         }
         ff_hevc_clear_refs(s);
-        ret = set_sps(s, s->ps.sps, AV_PIX_FMT_NONE);
+
+        pix_fmt = get_format(s, sps);
+        if (pix_fmt < 0)
+            return pix_fmt;
+
+        ret = set_sps(s, sps, pix_fmt);
         if (ret < 0)
             return ret;
 
@@ -509,14 +549,14 @@ static int hls_slice_header(HEVCContext *s)
             skip_bits(gb, 1);  // slice_reserved_undetermined_flag[]
 
         sh->slice_type = get_ue_golomb_long(gb);
-        if (!(sh->slice_type == I_SLICE ||
-              sh->slice_type == P_SLICE ||
-              sh->slice_type == B_SLICE)) {
+        if (!(sh->slice_type == HEVC_SLICE_I ||
+              sh->slice_type == HEVC_SLICE_P ||
+              sh->slice_type == HEVC_SLICE_B)) {
             av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
                    sh->slice_type);
             return AVERROR_INVALIDDATA;
         }
-        if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
+        if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
             av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
             return AVERROR_INVALIDDATA;
         }
@@ -533,7 +573,7 @@ static int hls_slice_header(HEVCContext *s)
             int poc, pos;
 
             sh->pic_order_cnt_lsb = get_bits(gb, s->ps.sps->log2_max_poc_lsb);
-            poc = ff_hevc_compute_poc(s, sh->pic_order_cnt_lsb);
+            poc = ff_hevc_compute_poc(s->ps.sps, s->pocTid0, sh->pic_order_cnt_lsb, s->nal_unit_type);
             if (!sh->first_slice_in_pic_flag && poc != s->poc) {
                 av_log(s->avctx, AV_LOG_WARNING,
                        "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
@@ -584,14 +624,14 @@ static int hls_slice_header(HEVCContext *s)
         }
 
         /* 8.3.1 */
-        if (s->temporal_id == 0 &&
-            s->nal_unit_type != NAL_TRAIL_N &&
-            s->nal_unit_type != NAL_TSA_N   &&
-            s->nal_unit_type != NAL_STSA_N  &&
-            s->nal_unit_type != NAL_RADL_N  &&
-            s->nal_unit_type != NAL_RADL_R  &&
-            s->nal_unit_type != NAL_RASL_N  &&
-            s->nal_unit_type != NAL_RASL_R)
+        if (sh->first_slice_in_pic_flag && s->temporal_id == 0 &&
+            s->nal_unit_type != HEVC_NAL_TRAIL_N &&
+            s->nal_unit_type != HEVC_NAL_TSA_N   &&
+            s->nal_unit_type != HEVC_NAL_STSA_N  &&
+            s->nal_unit_type != HEVC_NAL_RADL_N  &&
+            s->nal_unit_type != HEVC_NAL_RADL_R  &&
+            s->nal_unit_type != HEVC_NAL_RASL_N  &&
+            s->nal_unit_type != HEVC_NAL_RASL_R)
             s->pocTid0 = s->poc;
 
         if (s->ps.sps->sao_enabled) {
@@ -607,19 +647,19 @@ static int hls_slice_header(HEVCContext *s)
         }
 
         sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
-        if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
+        if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
             int nb_refs;
 
             sh->nb_refs[L0] = s->ps.pps->num_ref_idx_l0_default_active;
-            if (sh->slice_type == B_SLICE)
+            if (sh->slice_type == HEVC_SLICE_B)
                 sh->nb_refs[L1] = s->ps.pps->num_ref_idx_l1_default_active;
 
             if (get_bits1(gb)) { // num_ref_idx_active_override_flag
                 sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
-                if (sh->slice_type == B_SLICE)
+                if (sh->slice_type == HEVC_SLICE_B)
                     sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
             }
-            if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
+            if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
                 av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
                        sh->nb_refs[L0], sh->nb_refs[L1]);
                 return AVERROR_INVALIDDATA;
@@ -640,7 +680,7 @@ static int hls_slice_header(HEVCContext *s)
                         sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
                 }
 
-                if (sh->slice_type == B_SLICE) {
+                if (sh->slice_type == HEVC_SLICE_B) {
                     sh->rpl_modification_flag[1] = get_bits1(gb);
                     if (sh->rpl_modification_flag[1] == 1)
                         for (i = 0; i < sh->nb_refs[L1]; i++)
@@ -648,7 +688,7 @@ static int hls_slice_header(HEVCContext *s)
                 }
             }
 
-            if (sh->slice_type == B_SLICE)
+            if (sh->slice_type == HEVC_SLICE_B)
                 sh->mvd_l1_zero_flag = get_bits1(gb);
 
             if (s->ps.pps->cabac_init_present_flag)
@@ -659,7 +699,7 @@ static int hls_slice_header(HEVCContext *s)
             sh->collocated_ref_idx = 0;
             if (sh->slice_temporal_mvp_enabled_flag) {
                 sh->collocated_list = L0;
-                if (sh->slice_type == B_SLICE)
+                if (sh->slice_type == HEVC_SLICE_B)
                     sh->collocated_list = !get_bits1(gb);
 
                 if (sh->nb_refs[sh->collocated_list] > 1) {
@@ -673,9 +713,11 @@ static int hls_slice_header(HEVCContext *s)
                 }
             }
 
-            if ((s->ps.pps->weighted_pred_flag   && sh->slice_type == P_SLICE) ||
-                (s->ps.pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
-                pred_weight_table(s, gb);
+            if ((s->ps.pps->weighted_pred_flag   && sh->slice_type == HEVC_SLICE_P) ||
+                (s->ps.pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
+                int ret = pred_weight_table(s, gb);
+                if (ret < 0)
+                    return ret;
             }
 
             sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
@@ -711,8 +753,17 @@ static int hls_slice_header(HEVCContext *s)
             if (deblocking_filter_override_flag) {
                 sh->disable_deblocking_filter_flag = get_bits1(gb);
                 if (!sh->disable_deblocking_filter_flag) {
-                    sh->beta_offset = get_se_golomb(gb) * 2;
-                    sh->tc_offset   = get_se_golomb(gb) * 2;
+                    int beta_offset_div2 = get_se_golomb(gb);
+                    int tc_offset_div2   = get_se_golomb(gb) ;
+                    if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
+                        tc_offset_div2   < -6 || tc_offset_div2   > 6) {
+                        av_log(s->avctx, AV_LOG_ERROR,
+                            "Invalid deblock filter offsets: %d, %d\n",
+                            beta_offset_div2, tc_offset_div2);
+                        return AVERROR_INVALIDDATA;
+                    }
+                    sh->beta_offset = beta_offset_div2 * 2;
+                    sh->tc_offset   =   tc_offset_div2 * 2;
                 }
             } else {
                 sh->disable_deblocking_filter_flag = s->ps.pps->disable_dbf;
@@ -825,8 +876,6 @@ static int hls_slice_header(HEVCContext *s)
     s->HEVClc->tu.cu_qp_offset_cb = 0;
     s->HEVClc->tu.cu_qp_offset_cr = 0;
 
-    s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == NAL_CRA_NUT && s->last_eos);
-
     return 0;
 }
 
@@ -1052,7 +1101,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int y0,
                         for (i = 0; i < (size * size); i++) {
                             coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
                         }
-                        s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
+                        s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
                     }
             }
 
@@ -1081,7 +1130,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int y0,
                         for (i = 0; i < (size * size); i++) {
                             coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
                         }
-                        s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
+                        s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
                     }
             }
         } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
@@ -1283,11 +1332,11 @@ static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
     HEVCLocalContext *lc = s->HEVClc;
     GetBitContext gb;
     int cb_size   = 1 << log2_cb_size;
-    int stride0   = s->frame->linesize[0];
+    ptrdiff_t stride0 = s->frame->linesize[0];
+    ptrdiff_t stride1 = s->frame->linesize[1];
+    ptrdiff_t stride2 = s->frame->linesize[2];
     uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
-    int   stride1 = s->frame->linesize[1];
     uint8_t *dst1 = &s->frame->data[1][(y0 >> s->ps.sps->vshift[1]) * stride1 + ((x0 >> s->ps.sps->hshift[1]) << s->ps.sps->pixel_shift)];
-    int   stride2 = s->frame->linesize[2];
     uint8_t *dst2 = &s->frame->data[2][(y0 >> s->ps.sps->vshift[2]) * stride2 + ((x0 >> s->ps.sps->hshift[2]) << s->ps.sps->pixel_shift)];
 
     int length         = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
@@ -1346,8 +1395,8 @@ static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
     int pic_height       = s->ps.sps->height;
     int mx               = mv->x & 3;
     int my               = mv->y & 3;
-    int weight_flag      = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
-                           (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag);
+    int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
+                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
     int idx              = ff_hevc_pel_weight[block_w];
 
     x_off += mv->x >> 2;
@@ -1357,7 +1406,7 @@ static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
     if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
         x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
         y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
-        const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
+        const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
         int offset     = QPEL_EXTRA_BEFORE * srcstride       + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
         int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
 
@@ -1409,8 +1458,8 @@ static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
     int my0              = mv0->y & 3;
     int mx1              = mv1->x & 3;
     int my1              = mv1->y & 3;
-    int weight_flag      = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
-                           (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag);
+    int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
+                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
     int x_off0           = x_off + (mv0->x >> 2);
     int y_off0           = y_off + (mv0->y >> 2);
     int x_off1           = x_off + (mv1->x >> 2);
@@ -1423,7 +1472,7 @@ static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
     if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
         x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
         y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
-        const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
+        const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
         int offset     = QPEL_EXTRA_BEFORE * src0stride       + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
         int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
 
@@ -1440,7 +1489,7 @@ static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
     if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
         x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
         y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
-        const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
+        const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
         int offset     = QPEL_EXTRA_BEFORE * src1stride       + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
         int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
 
@@ -1495,8 +1544,8 @@ static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
     int pic_width        = s->ps.sps->width >> s->ps.sps->hshift[1];
     int pic_height       = s->ps.sps->height >> s->ps.sps->vshift[1];
     const Mv *mv         = &current_mv->mv[reflist];
-    int weight_flag      = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
-                           (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag);
+    int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
+                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
     int idx              = ff_hevc_pel_weight[block_w];
     int hshift           = s->ps.sps->hshift[1];
     int vshift           = s->ps.sps->vshift[1];
@@ -1560,8 +1609,8 @@ static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVF
     uint8_t *src2        = ref1->data[cidx+1];
     ptrdiff_t src1stride = ref0->linesize[cidx+1];
     ptrdiff_t src2stride = ref1->linesize[cidx+1];
-    int weight_flag      = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
-                           (s->sh.slice_type == B_SLICE && s->ps.pps->weighted_bipred_flag);
+    int weight_flag      = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
+                           (s->sh.slice_type == HEVC_SLICE_B && s->ps.pps->weighted_bipred_flag);
     int pic_width        = s->ps.sps->width >> s->ps.sps->hshift[1];
     int pic_height       = s->ps.sps->height >> s->ps.sps->vshift[1];
     Mv *mv0              = &current_mv->mv[0];
@@ -1645,10 +1694,11 @@ static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVF
 static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref,
                                 const Mv *mv, int y0, int height)
 {
-    int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
+    if (s->threads_type == FF_THREAD_FRAME ) {
+        int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
 
-    if (s->threads_type == FF_THREAD_FRAME )
         ff_thread_await_progress(&ref->tf, y, 0);
+    }
 }
 
 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
@@ -1661,7 +1711,7 @@ static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
 
     ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
     mv->pred_flag = 0;
-    if (s->sh.slice_type == B_SLICE)
+    if (s->sh.slice_type == HEVC_SLICE_B)
         inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
 
     if (inter_pred_idc != PRED_L1) {
@@ -2039,7 +2089,7 @@ static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
     } else
         lc->cu.cu_transquant_bypass_flag = 0;
 
-    if (s->sh.slice_type != I_SLICE) {
+    if (s->sh.slice_type != HEVC_SLICE_I) {
         uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
 
         x = y_cb * min_cb_width + x_cb;
@@ -2065,7 +2115,7 @@ static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
     } else {
         int pcm_flag = 0;
 
-        if (s->sh.slice_type != I_SLICE)
+        if (s->sh.slice_type != HEVC_SLICE_I)
             lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
         if (lc->cu.pred_mode != MODE_INTRA ||
             log2_cb_size == s->ps.sps->log2_min_cb_size) {
@@ -2315,6 +2365,7 @@ static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
     int x_ctb       = 0;
     int y_ctb       = 0;
     int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
+    int ret;
 
     if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
         av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
@@ -2336,7 +2387,11 @@ static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
         y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
         hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
 
-        ff_hevc_cabac_init(s, ctb_addr_ts);
+        ret = ff_hevc_cabac_init(s, ctb_addr_ts);
+        if (ret < 0) {
+            s->tab_slice_address[ctb_addr_rs] = -1;
+            return ret;
+        }
 
         hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
 
@@ -2392,9 +2447,8 @@ static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int
 
     if(ctb_row) {
         ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
-
         if (ret < 0)
-            return ret;
+            goto error;
         ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
     }
 
@@ -2406,20 +2460,20 @@ static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int
 
         ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
 
-        if (avpriv_atomic_int_get(&s1->wpp_err)){
+        if (atomic_load(&s1->wpp_err)) {
             ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
             return 0;
         }
 
-        ff_hevc_cabac_init(s, ctb_addr_ts);
+        ret = ff_hevc_cabac_init(s, ctb_addr_ts);
+        if (ret < 0)
+            goto error;
         hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
         more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
 
         if (more_data < 0) {
-            s->tab_slice_address[ctb_addr_rs] = -1;
-            avpriv_atomic_int_set(&s1->wpp_err,  1);
-            ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
-            return more_data;
+            ret = more_data;
+            goto error;
         }
 
         ctb_addr_ts++;
@@ -2429,7 +2483,7 @@ static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int
         ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
 
         if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
-            avpriv_atomic_int_set(&s1->wpp_err,  1);
+            atomic_store(&s1->wpp_err, 1);
             ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
             return 0;
         }
@@ -2449,6 +2503,11 @@ static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int
     ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
 
     return 0;
+error:
+    s->tab_slice_address[ctb_addr_rs] = -1;
+    atomic_store(&s1->wpp_err, 1);
+    ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
+    return ret;
 }
 
 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
@@ -2530,7 +2589,7 @@ static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
         s->sList[i]->HEVClc = s->HEVClcList[i];
     }
 
-    avpriv_atomic_int_set(&s->wpp_err, 0);
+    atomic_store(&s->wpp_err, 0);
     ff_reset_entries(s->avctx);
 
     for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
@@ -2553,18 +2612,18 @@ static int set_side_data(HEVCContext *s)
 {
     AVFrame *out = s->ref->frame;
 
-    if (s->sei_frame_packing_present &&
-        s->frame_packing_arrangement_type >= 3 &&
-        s->frame_packing_arrangement_type <= 5 &&
-        s->content_interpretation_type > 0 &&
-        s->content_interpretation_type < 3) {
+    if (s->sei.frame_packing.present &&
+        s->sei.frame_packing.arrangement_type >= 3 &&
+        s->sei.frame_packing.arrangement_type <= 5 &&
+        s->sei.frame_packing.content_interpretation_type > 0 &&
+        s->sei.frame_packing.content_interpretation_type < 3) {
         AVStereo3D *stereo = av_stereo3d_create_side_data(out);
         if (!stereo)
             return AVERROR(ENOMEM);
 
-        switch (s->frame_packing_arrangement_type) {
+        switch (s->sei.frame_packing.arrangement_type) {
         case 3:
-            if (s->quincunx_subsampling)
+            if (s->sei.frame_packing.quincunx_subsampling)
                 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
             else
                 stereo->type = AV_STEREO3D_SIDEBYSIDE;
@@ -2577,13 +2636,14 @@ static int set_side_data(HEVCContext *s)
             break;
         }
 
-        if (s->content_interpretation_type == 2)
+        if (s->sei.frame_packing.content_interpretation_type == 2)
             stereo->flags = AV_STEREO3D_FLAG_INVERT;
     }
 
-    if (s->sei_display_orientation_present &&
-        (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
-        double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
+    if (s->sei.display_orientation.present &&
+        (s->sei.display_orientation.anticlockwise_rotation ||
+         s->sei.display_orientation.hflip || s->sei.display_orientation.vflip)) {
+        double angle = s->sei.display_orientation.anticlockwise_rotation * 360 / (double) (1 << 16);
         AVFrameSideData *rotation = av_frame_new_side_data(out,
                                                            AV_FRAME_DATA_DISPLAYMATRIX,
                                                            sizeof(int32_t) * 9);
@@ -2592,16 +2652,17 @@ static int set_side_data(HEVCContext *s)
 
         av_display_rotation_set((int32_t *)rotation->data, angle);
         av_display_matrix_flip((int32_t *)rotation->data,
-                               s->sei_hflip, s->sei_vflip);
+                               s->sei.display_orientation.hflip,
+                               s->sei.display_orientation.vflip);
     }
 
     // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
     // so the side data persists for the entire coded video sequence.
-    if (s->sei_mastering_display_info_present > 0 &&
+    if (s->sei.mastering_display.present > 0 &&
         IS_IRAP(s) && s->no_rasl_output_flag) {
-        s->sei_mastering_display_info_present--;
+        s->sei.mastering_display.present--;
     }
-    if (s->sei_mastering_display_info_present) {
+    if (s->sei.mastering_display.present) {
         // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
         const int mapping[3] = {2, 0, 1};
         const int chroma_den = 50000;
@@ -2614,19 +2675,19 @@ static int set_side_data(HEVCContext *s)
 
         for (i = 0; i < 3; i++) {
             const int j = mapping[i];
-            metadata->display_primaries[i][0].num = s->display_primaries[j][0];
+            metadata->display_primaries[i][0].num = s->sei.mastering_display.display_primaries[j][0];
             metadata->display_primaries[i][0].den = chroma_den;
-            metadata->display_primaries[i][1].num = s->display_primaries[j][1];
+            metadata->display_primaries[i][1].num = s->sei.mastering_display.display_primaries[j][1];
             metadata->display_primaries[i][1].den = chroma_den;
         }
-        metadata->white_point[0].num = s->white_point[0];
+        metadata->white_point[0].num = s->sei.mastering_display.white_point[0];
         metadata->white_point[0].den = chroma_den;
-        metadata->white_point[1].num = s->white_point[1];
+        metadata->white_point[1].num = s->sei.mastering_display.white_point[1];
         metadata->white_point[1].den = chroma_den;
 
-        metadata->max_luminance.num = s->max_mastering_luminance;
+        metadata->max_luminance.num = s->sei.mastering_display.max_luminance;
         metadata->max_luminance.den = luma_den;
-        metadata->min_luminance.num = s->min_mastering_luminance;
+        metadata->min_luminance.num = s->sei.mastering_display.min_luminance;
         metadata->min_luminance.den = luma_den;
         metadata->has_luminance = 1;
         metadata->has_primaries = 1;
@@ -2645,18 +2706,42 @@ static int set_side_data(HEVCContext *s)
                "min_luminance=%f, max_luminance=%f\n",
                av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
     }
+    // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
+    // so the side data persists for the entire coded video sequence.
+    if (s->sei.content_light.present > 0 &&
+        IS_IRAP(s) && s->no_rasl_output_flag) {
+        s->sei.content_light.present--;
+    }
+    if (s->sei.content_light.present) {
+        AVContentLightMetadata *metadata =
+            av_content_light_metadata_create_side_data(out);
+        if (!metadata)
+            return AVERROR(ENOMEM);
+        metadata->MaxCLL  = s->sei.content_light.max_content_light_level;
+        metadata->MaxFALL = s->sei.content_light.max_pic_average_light_level;
+
+        av_log(s->avctx, AV_LOG_DEBUG, "Content Light Level Metadata:\n");
+        av_log(s->avctx, AV_LOG_DEBUG, "MaxCLL=%d, MaxFALL=%d\n",
+               metadata->MaxCLL, metadata->MaxFALL);
+    }
 
-    if (s->a53_caption) {
+    if (s->sei.a53_caption.a53_caption) {
         AVFrameSideData* sd = av_frame_new_side_data(out,
                                                      AV_FRAME_DATA_A53_CC,
-                                                     s->a53_caption_size);
+                                                     s->sei.a53_caption.a53_caption_size);
         if (sd)
-            memcpy(sd->data, s->a53_caption, s->a53_caption_size);
-        av_freep(&s->a53_caption);
-        s->a53_caption_size = 0;
+            memcpy(sd->data, s->sei.a53_caption.a53_caption, s->sei.a53_caption.a53_caption_size);
+        av_freep(&s->sei.a53_caption.a53_caption);
+        s->sei.a53_caption.a53_caption_size = 0;
         s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
     }
 
+    if (s->sei.alternative_transfer.present &&
+        av_color_transfer_name(s->sei.alternative_transfer.preferred_transfer_characteristics) &&
+        s->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
+        s->avctx->color_trc = out->color_trc = s->sei.alternative_transfer.preferred_transfer_characteristics;
+    }
+
     return 0;
 }
 
@@ -2676,6 +2761,8 @@ static int hevc_frame_start(HEVCContext *s)
     s->is_decoded        = 0;
     s->first_nal_type    = s->nal_unit_type;
 
+    s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
+
     if (s->ps.pps->tiles_enabled_flag)
         lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
 
@@ -2728,67 +2815,67 @@ static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
     s->temporal_id   = nal->temporal_id;
 
     switch (s->nal_unit_type) {
-    case NAL_VPS:
+    case HEVC_NAL_VPS:
         ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
         if (ret < 0)
             goto fail;
         break;
-    case NAL_SPS:
+    case HEVC_NAL_SPS:
         ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
                                      s->apply_defdispwin);
         if (ret < 0)
             goto fail;
         break;
-    case NAL_PPS:
+    case HEVC_NAL_PPS:
         ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
         if (ret < 0)
             goto fail;
         break;
-    case NAL_SEI_PREFIX:
-    case NAL_SEI_SUFFIX:
-        ret = ff_hevc_decode_nal_sei(s);
+    case HEVC_NAL_SEI_PREFIX:
+    case HEVC_NAL_SEI_SUFFIX:
+        ret = ff_hevc_decode_nal_sei(gb, s->avctx, &s->sei, &s->ps, s->nal_unit_type);
         if (ret < 0)
             goto fail;
         break;
-    case NAL_TRAIL_R:
-    case NAL_TRAIL_N:
-    case NAL_TSA_N:
-    case NAL_TSA_R:
-    case NAL_STSA_N:
-    case NAL_STSA_R:
-    case NAL_BLA_W_LP:
-    case NAL_BLA_W_RADL:
-    case NAL_BLA_N_LP:
-    case NAL_IDR_W_RADL:
-    case NAL_IDR_N_LP:
-    case NAL_CRA_NUT:
-    case NAL_RADL_N:
-    case NAL_RADL_R:
-    case NAL_RASL_N:
-    case NAL_RASL_R:
+    case HEVC_NAL_TRAIL_R:
+    case HEVC_NAL_TRAIL_N:
+    case HEVC_NAL_TSA_N:
+    case HEVC_NAL_TSA_R:
+    case HEVC_NAL_STSA_N:
+    case HEVC_NAL_STSA_R:
+    case HEVC_NAL_BLA_W_LP:
+    case HEVC_NAL_BLA_W_RADL:
+    case HEVC_NAL_BLA_N_LP:
+    case HEVC_NAL_IDR_W_RADL:
+    case HEVC_NAL_IDR_N_LP:
+    case HEVC_NAL_CRA_NUT:
+    case HEVC_NAL_RADL_N:
+    case HEVC_NAL_RADL_R:
+    case HEVC_NAL_RASL_N:
+    case HEVC_NAL_RASL_R:
         ret = hls_slice_header(s);
         if (ret < 0)
             return ret;
 
-        if (s->max_ra == INT_MAX) {
-            if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
-                s->max_ra = s->poc;
+        if (s->sh.first_slice_in_pic_flag) {
+            if (s->max_ra == INT_MAX) {
+                if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
+                    s->max_ra = s->poc;
+                } else {
+                    if (IS_IDR(s))
+                        s->max_ra = INT_MIN;
+                }
+            }
+
+            if ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
+                s->poc <= s->max_ra) {
+                s->is_decoded = 0;
+                break;
             } else {
-                if (IS_IDR(s))
+                if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
                     s->max_ra = INT_MIN;
             }
-        }
-
-        if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
-            s->poc <= s->max_ra) {
-            s->is_decoded = 0;
-            break;
-        } else {
-            if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
-                s->max_ra = INT_MIN;
-        }
 
-        if (s->sh.first_slice_in_pic_flag) {
             ret = hevc_frame_start(s);
             if (ret < 0)
                 return ret;
@@ -2805,7 +2892,7 @@ static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
         }
 
         if (!s->sh.dependent_slice_segment_flag &&
-            s->sh.slice_type != I_SLICE) {
+            s->sh.slice_type != HEVC_SLICE_I) {
             ret = ff_hevc_slice_rpl(s);
             if (ret < 0) {
                 av_log(s->avctx, AV_LOG_WARNING,
@@ -2839,13 +2926,13 @@ static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
             }
         }
         break;
-    case NAL_EOS_NUT:
-    case NAL_EOB_NUT:
+    case HEVC_NAL_EOS_NUT:
+    case HEVC_NAL_EOB_NUT:
         s->seq_decode = (s->seq_decode + 1) & 0xff;
         s->max_ra     = INT_MAX;
         break;
-    case NAL_AUD:
-    case NAL_FD_NUT:
+    case HEVC_NAL_AUD:
+    case HEVC_NAL_FD_NUT:
         break;
     default:
         av_log(s->avctx, AV_LOG_INFO,
@@ -2862,6 +2949,7 @@ static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
 {
     int i, ret = 0;
+    int eos_at_start = 1;
 
     s->ref = NULL;
     s->last_eos = s->eos;
@@ -2878,9 +2966,16 @@ static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
     }
 
     for (i = 0; i < s->pkt.nb_nals; i++) {
-        if (s->pkt.nals[i].type == NAL_EOB_NUT ||
-            s->pkt.nals[i].type == NAL_EOS_NUT)
-            s->eos = 1;
+        if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
+            s->pkt.nals[i].type == HEVC_NAL_EOS_NUT) {
+            if (eos_at_start) {
+                s->last_eos = 1;
+            } else {
+                s->eos = 1;
+            }
+        } else {
+            eos_at_start = 0;
+        }
     }
 
     /* decode the NAL units */
@@ -2940,7 +3035,7 @@ static int verify_md5(HEVCContext *s, AVFrame *frame)
         int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
         uint8_t md5[16];
 
-        av_md5_init(s->md5_ctx);
+        av_md5_init(s->sei.picture_hash.md5_ctx);
         for (j = 0; j < h; j++) {
             const uint8_t *src = frame->data[i] + j * frame->linesize[i];
 #if HAVE_BIGENDIAN
@@ -2950,11 +3045,11 @@ static int verify_md5(HEVCContext *s, AVFrame *frame)
                 src = s->checksum_buf;
             }
 #endif
-            av_md5_update(s->md5_ctx, src, w << pixel_shift);
+            av_md5_update(s->sei.picture_hash.md5_ctx, src, w << pixel_shift);
         }
-        av_md5_final(s->md5_ctx, md5);
+        av_md5_final(s->sei.picture_hash.md5_ctx, md5);
 
-        if (!memcmp(md5, s->md5[i], 16)) {
+        if (!memcmp(md5, s->sei.picture_hash.md5[i], 16)) {
             av_log   (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
             print_md5(s->avctx, AV_LOG_DEBUG, md5);
             av_log   (s->avctx, AV_LOG_DEBUG, "; ");
@@ -2962,7 +3057,7 @@ static int verify_md5(HEVCContext *s, AVFrame *frame)
             av_log   (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
             print_md5(s->avctx, AV_LOG_ERROR, md5);
             av_log   (s->avctx, AV_LOG_ERROR, " != ");
-            print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
+            print_md5(s->avctx, AV_LOG_ERROR, s->sei.picture_hash.md5[i]);
             av_log   (s->avctx, AV_LOG_ERROR, "\n");
             return AVERROR_INVALIDDATA;
         }
@@ -2973,10 +3068,34 @@ static int verify_md5(HEVCContext *s, AVFrame *frame)
     return 0;
 }
 
+static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
+{
+    int ret, i;
+
+    ret = ff_hevc_decode_extradata(buf, length, &s->ps, &s->sei, &s->is_nalff,
+                                   &s->nal_length_size, s->avctx->err_recognition,
+                                   s->apply_defdispwin, s->avctx);
+    if (ret < 0)
+        return ret;
+
+    /* export stream parameters from the first SPS */
+    for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
+        if (first && s->ps.sps_list[i]) {
+            const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
+            export_stream_params(s->avctx, &s->ps, sps);
+            break;
+        }
+    }
+
+    return 0;
+}
+
 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
                              AVPacket *avpkt)
 {
     int ret;
+    int new_extradata_size;
+    uint8_t *new_extradata;
     HEVCContext *s = avctx->priv_data;
 
     if (!avpkt->size) {
@@ -2988,6 +3107,14 @@ static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
         return 0;
     }
 
+    new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
+                                            &new_extradata_size);
+    if (new_extradata && new_extradata_size > 0) {
+        ret = hevc_decode_extradata(s, new_extradata, new_extradata_size, 0);
+        if (ret < 0)
+            return ret;
+    }
+
     s->ref = NULL;
     ret    = decode_nal_units(s, avpkt->data, avpkt->size);
     if (ret < 0)
@@ -3003,7 +3130,7 @@ static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
     } else {
         /* verify the SEI checksum */
         if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
-            s->is_md5) {
+            s->sei.picture_hash.is_md5) {
             ret = verify_md5(s, s->ref->frame);
             if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
                 ff_hevc_unref_frame(s, s->ref, ~0);
@@ -3011,7 +3138,7 @@ static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
             }
         }
     }
-    s->is_md5 = 0;
+    s->sei.picture_hash.is_md5 = 0;
 
     if (s->is_decoded) {
         av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
@@ -3050,7 +3177,6 @@ static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
 
     dst->poc        = src->poc;
     dst->ctb_count  = src->ctb_count;
-    dst->window     = src->window;
     dst->flags      = src->flags;
     dst->sequence   = src->sequence;
 
@@ -3074,7 +3200,7 @@ static av_cold int hevc_decode_free(AVCodecContext *avctx)
 
     pic_arrays_free(s);
 
-    av_freep(&s->md5_ctx);
+    av_freep(&s->sei.picture_hash.md5_ctx);
 
     av_freep(&s->cabac_state);
 
@@ -3149,8 +3275,8 @@ static av_cold int hevc_init_context(AVCodecContext *avctx)
 
     s->max_ra = INT_MAX;
 
-    s->md5_ctx = av_md5_alloc();
-    if (!s->md5_ctx)
+    s->sei.picture_hash.md5_ctx = av_md5_alloc();
+    if (!s->sei.picture_hash.md5_ctx)
         goto fail;
 
     ff_bswapdsp_init(&s->bdsp);
@@ -3158,7 +3284,7 @@ static av_cold int hevc_init_context(AVCodecContext *avctx)
     s->context_initialized = 1;
     s->eos = 0;
 
-    ff_hevc_reset_sei(s);
+    ff_hevc_reset_sei(&s->sei);
 
     return 0;
 
@@ -3240,79 +3366,11 @@ static int hevc_update_thread_context(AVCodecContext *dst,
         s->max_ra = INT_MAX;
     }
 
-    return 0;
-}
-
-static int hevc_decode_extradata(HEVCContext *s)
-{
-    AVCodecContext *avctx = s->avctx;
-    GetByteContext gb;
-    int ret, i;
-
-    bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
-
-    if (avctx->extradata_size > 3 &&
-        (avctx->extradata[0] || avctx->extradata[1] ||
-         avctx->extradata[2] > 1)) {
-        /* It seems the extradata is encoded as hvcC format.
-         * Temporarily, we support configurationVersion==0 until 14496-15 3rd
-         * is finalized. When finalized, configurationVersion will be 1 and we
-         * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
-        int i, j, num_arrays, nal_len_size;
-
-        s->is_nalff = 1;
-
-        bytestream2_skip(&gb, 21);
-        nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
-        num_arrays   = bytestream2_get_byte(&gb);
-
-        /* nal units in the hvcC always have length coded with 2 bytes,
-         * so put a fake nal_length_size = 2 while parsing them */
-        s->nal_length_size = 2;
-
-        /* Decode nal units from hvcC. */
-        for (i = 0; i < num_arrays; i++) {
-            int type = bytestream2_get_byte(&gb) & 0x3f;
-            int cnt  = bytestream2_get_be16(&gb);
-
-            for (j = 0; j < cnt; j++) {
-                // +2 for the nal size field
-                int nalsize = bytestream2_peek_be16(&gb) + 2;
-                if (bytestream2_get_bytes_left(&gb) < nalsize) {
-                    av_log(s->avctx, AV_LOG_ERROR,
-                           "Invalid NAL unit size in extradata.\n");
-                    return AVERROR_INVALIDDATA;
-                }
-
-                ret = decode_nal_units(s, gb.buffer, nalsize);
-                if (ret < 0) {
-                    av_log(avctx, AV_LOG_ERROR,
-                           "Decoding nal unit %d %d from hvcC failed\n",
-                           type, i);
-                    return ret;
-                }
-                bytestream2_skip(&gb, nalsize);
-            }
-        }
-
-        /* Now store right nal length size, that will be used to parse
-         * all other nals */
-        s->nal_length_size = nal_len_size;
-    } else {
-        s->is_nalff = 0;
-        ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
-        if (ret < 0)
-            return ret;
-    }
-
-    /* export stream parameters from the first SPS */
-    for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
-        if (s->ps.sps_list[i]) {
-            const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
-            export_stream_params(s->avctx, &s->ps, sps);
-            break;
-        }
-    }
+    s->sei.frame_packing        = s0->sei.frame_packing;
+    s->sei.display_orientation  = s0->sei.display_orientation;
+    s->sei.mastering_display    = s0->sei.mastering_display;
+    s->sei.content_light        = s0->sei.content_light;
+    s->sei.alternative_transfer = s0->sei.alternative_transfer;
 
     return 0;
 }
@@ -3329,16 +3387,18 @@ static av_cold int hevc_decode_init(AVCodecContext *avctx)
         return ret;
 
     s->enable_parallel_tiles = 0;
-    s->picture_struct = 0;
+    s->sei.picture_timing.picture_struct = 0;
     s->eos = 1;
 
+    atomic_init(&s->wpp_err, 0);
+
     if(avctx->active_thread_type & FF_THREAD_SLICE)
         s->threads_number = avctx->thread_count;
     else
         s->threads_number = 1;
 
     if (avctx->extradata_size > 0 && avctx->extradata) {
-        ret = hevc_decode_extradata(s);
+        ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size, 1);
         if (ret < 0) {
             hevc_decode_free(avctx);
             return ret;
@@ -3408,5 +3468,6 @@ AVCodec ff_hevc_decoder = {
     .init_thread_copy      = hevc_init_thread_copy,
     .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
                              AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
+    .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING,
     .profiles              = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/hevcdec.h b/mythtv/external/FFmpeg/libavcodec/hevcdec.h
new file mode 100644
index 00000000000..293beb70832
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/hevcdec.h
@@ -0,0 +1,589 @@
+/*
+ * HEVC video decoder
+ *
+ * Copyright (C) 2012 - 2013 Guillaume Martres
+ *
+ * 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_HEVCDEC_H
+#define AVCODEC_HEVCDEC_H
+
+#include <stdatomic.h>
+
+#include "libavutil/buffer.h"
+
+#include "avcodec.h"
+#include "bswapdsp.h"
+#include "cabac.h"
+#include "get_bits.h"
+#include "hevcpred.h"
+#include "h2645_parse.h"
+#include "hevc.h"
+#include "hevc_ps.h"
+#include "hevc_sei.h"
+#include "hevcdsp.h"
+#include "internal.h"
+#include "thread.h"
+#include "videodsp.h"
+
+#define MAX_NB_THREADS 16
+#define SHIFT_CTB_WPP 2
+
+//TODO: check if this is really the maximum
+#define MAX_TRANSFORM_DEPTH 5
+
+#define MAX_TB_SIZE 32
+#define MAX_QP 51
+#define DEFAULT_INTRA_TC_OFFSET 2
+
+#define HEVC_CONTEXTS 199
+
+#define MRG_MAX_NUM_CANDS     5
+
+#define L0 0
+#define L1 1
+
+#define EPEL_EXTRA_BEFORE 1
+#define EPEL_EXTRA_AFTER  2
+#define EPEL_EXTRA        3
+#define QPEL_EXTRA_BEFORE 3
+#define QPEL_EXTRA_AFTER  4
+#define QPEL_EXTRA        7
+
+#define EDGE_EMU_BUFFER_STRIDE 80
+
+/**
+ * Value of the luma sample at position (x, y) in the 2D array tab.
+ */
+#define SAMPLE(tab, x, y) ((tab)[(y) * s->sps->width + (x)])
+#define SAMPLE_CTB(tab, x, y) ((tab)[(y) * min_cb_width + (x)])
+
+#define IS_IDR(s) ((s)->nal_unit_type == HEVC_NAL_IDR_W_RADL || (s)->nal_unit_type == HEVC_NAL_IDR_N_LP)
+#define IS_BLA(s) ((s)->nal_unit_type == HEVC_NAL_BLA_W_RADL || (s)->nal_unit_type == HEVC_NAL_BLA_W_LP || \
+                   (s)->nal_unit_type == HEVC_NAL_BLA_N_LP)
+#define IS_IRAP(s) ((s)->nal_unit_type >= 16 && (s)->nal_unit_type <= 23)
+
+enum RPSType {
+    ST_CURR_BEF = 0,
+    ST_CURR_AFT,
+    ST_FOLL,
+    LT_CURR,
+    LT_FOLL,
+    NB_RPS_TYPE,
+};
+
+enum SyntaxElement {
+    SAO_MERGE_FLAG = 0,
+    SAO_TYPE_IDX,
+    SAO_EO_CLASS,
+    SAO_BAND_POSITION,
+    SAO_OFFSET_ABS,
+    SAO_OFFSET_SIGN,
+    END_OF_SLICE_FLAG,
+    SPLIT_CODING_UNIT_FLAG,
+    CU_TRANSQUANT_BYPASS_FLAG,
+    SKIP_FLAG,
+    CU_QP_DELTA,
+    PRED_MODE_FLAG,
+    PART_MODE,
+    PCM_FLAG,
+    PREV_INTRA_LUMA_PRED_FLAG,
+    MPM_IDX,
+    REM_INTRA_LUMA_PRED_MODE,
+    INTRA_CHROMA_PRED_MODE,
+    MERGE_FLAG,
+    MERGE_IDX,
+    INTER_PRED_IDC,
+    REF_IDX_L0,
+    REF_IDX_L1,
+    ABS_MVD_GREATER0_FLAG,
+    ABS_MVD_GREATER1_FLAG,
+    ABS_MVD_MINUS2,
+    MVD_SIGN_FLAG,
+    MVP_LX_FLAG,
+    NO_RESIDUAL_DATA_FLAG,
+    SPLIT_TRANSFORM_FLAG,
+    CBF_LUMA,
+    CBF_CB_CR,
+    TRANSFORM_SKIP_FLAG,
+    EXPLICIT_RDPCM_FLAG,
+    EXPLICIT_RDPCM_DIR_FLAG,
+    LAST_SIGNIFICANT_COEFF_X_PREFIX,
+    LAST_SIGNIFICANT_COEFF_Y_PREFIX,
+    LAST_SIGNIFICANT_COEFF_X_SUFFIX,
+    LAST_SIGNIFICANT_COEFF_Y_SUFFIX,
+    SIGNIFICANT_COEFF_GROUP_FLAG,
+    SIGNIFICANT_COEFF_FLAG,
+    COEFF_ABS_LEVEL_GREATER1_FLAG,
+    COEFF_ABS_LEVEL_GREATER2_FLAG,
+    COEFF_ABS_LEVEL_REMAINING,
+    COEFF_SIGN_FLAG,
+    LOG2_RES_SCALE_ABS,
+    RES_SCALE_SIGN_FLAG,
+    CU_CHROMA_QP_OFFSET_FLAG,
+    CU_CHROMA_QP_OFFSET_IDX,
+};
+
+enum PartMode {
+    PART_2Nx2N = 0,
+    PART_2NxN  = 1,
+    PART_Nx2N  = 2,
+    PART_NxN   = 3,
+    PART_2NxnU = 4,
+    PART_2NxnD = 5,
+    PART_nLx2N = 6,
+    PART_nRx2N = 7,
+};
+
+enum PredMode {
+    MODE_INTER = 0,
+    MODE_INTRA,
+    MODE_SKIP,
+};
+
+enum InterPredIdc {
+    PRED_L0 = 0,
+    PRED_L1,
+    PRED_BI,
+};
+
+enum PredFlag {
+    PF_INTRA = 0,
+    PF_L0,
+    PF_L1,
+    PF_BI,
+};
+
+enum IntraPredMode {
+    INTRA_PLANAR = 0,
+    INTRA_DC,
+    INTRA_ANGULAR_2,
+    INTRA_ANGULAR_3,
+    INTRA_ANGULAR_4,
+    INTRA_ANGULAR_5,
+    INTRA_ANGULAR_6,
+    INTRA_ANGULAR_7,
+    INTRA_ANGULAR_8,
+    INTRA_ANGULAR_9,
+    INTRA_ANGULAR_10,
+    INTRA_ANGULAR_11,
+    INTRA_ANGULAR_12,
+    INTRA_ANGULAR_13,
+    INTRA_ANGULAR_14,
+    INTRA_ANGULAR_15,
+    INTRA_ANGULAR_16,
+    INTRA_ANGULAR_17,
+    INTRA_ANGULAR_18,
+    INTRA_ANGULAR_19,
+    INTRA_ANGULAR_20,
+    INTRA_ANGULAR_21,
+    INTRA_ANGULAR_22,
+    INTRA_ANGULAR_23,
+    INTRA_ANGULAR_24,
+    INTRA_ANGULAR_25,
+    INTRA_ANGULAR_26,
+    INTRA_ANGULAR_27,
+    INTRA_ANGULAR_28,
+    INTRA_ANGULAR_29,
+    INTRA_ANGULAR_30,
+    INTRA_ANGULAR_31,
+    INTRA_ANGULAR_32,
+    INTRA_ANGULAR_33,
+    INTRA_ANGULAR_34,
+};
+
+enum SAOType {
+    SAO_NOT_APPLIED = 0,
+    SAO_BAND,
+    SAO_EDGE,
+    SAO_APPLIED
+};
+
+enum SAOEOClass {
+    SAO_EO_HORIZ = 0,
+    SAO_EO_VERT,
+    SAO_EO_135D,
+    SAO_EO_45D,
+};
+
+enum ScanType {
+    SCAN_DIAG = 0,
+    SCAN_HORIZ,
+    SCAN_VERT,
+};
+
+typedef struct RefPicList {
+    struct HEVCFrame *ref[HEVC_MAX_REFS];
+    int list[HEVC_MAX_REFS];
+    int isLongTerm[HEVC_MAX_REFS];
+    int nb_refs;
+} RefPicList;
+
+typedef struct RefPicListTab {
+    RefPicList refPicList[2];
+} RefPicListTab;
+
+typedef struct CodingUnit {
+    int x;
+    int y;
+
+    enum PredMode pred_mode;    ///< PredMode
+    enum PartMode part_mode;    ///< PartMode
+
+    // Inferred parameters
+    uint8_t intra_split_flag;   ///< IntraSplitFlag
+    uint8_t max_trafo_depth;    ///< MaxTrafoDepth
+    uint8_t cu_transquant_bypass_flag;
+} CodingUnit;
+
+typedef struct Mv {
+    int16_t x;  ///< horizontal component of motion vector
+    int16_t y;  ///< vertical component of motion vector
+} Mv;
+
+typedef struct MvField {
+    DECLARE_ALIGNED(4, Mv, mv)[2];
+    int8_t ref_idx[2];
+    int8_t pred_flag;
+} MvField;
+
+typedef struct NeighbourAvailable {
+    int cand_bottom_left;
+    int cand_left;
+    int cand_up;
+    int cand_up_left;
+    int cand_up_right;
+    int cand_up_right_sap;
+} NeighbourAvailable;
+
+typedef struct PredictionUnit {
+    int mpm_idx;
+    int rem_intra_luma_pred_mode;
+    uint8_t intra_pred_mode[4];
+    Mv mvd;
+    uint8_t merge_flag;
+    uint8_t intra_pred_mode_c[4];
+    uint8_t chroma_mode_c[4];
+} PredictionUnit;
+
+typedef struct TransformUnit {
+    int cu_qp_delta;
+
+    int res_scale_val;
+
+    // Inferred parameters;
+    int intra_pred_mode;
+    int intra_pred_mode_c;
+    int chroma_mode_c;
+    uint8_t is_cu_qp_delta_coded;
+    uint8_t is_cu_chroma_qp_offset_coded;
+    int8_t  cu_qp_offset_cb;
+    int8_t  cu_qp_offset_cr;
+    uint8_t cross_pf;
+} TransformUnit;
+
+typedef struct DBParams {
+    int beta_offset;
+    int tc_offset;
+} DBParams;
+
+#define HEVC_FRAME_FLAG_OUTPUT    (1 << 0)
+#define HEVC_FRAME_FLAG_SHORT_REF (1 << 1)
+#define HEVC_FRAME_FLAG_LONG_REF  (1 << 2)
+#define HEVC_FRAME_FLAG_BUMPING   (1 << 3)
+
+typedef struct HEVCFrame {
+    AVFrame *frame;
+    ThreadFrame tf;
+    MvField *tab_mvf;
+    RefPicList *refPicList;
+    RefPicListTab **rpl_tab;
+    int ctb_count;
+    int poc;
+    struct HEVCFrame *collocated_ref;
+
+    AVBufferRef *tab_mvf_buf;
+    AVBufferRef *rpl_tab_buf;
+    AVBufferRef *rpl_buf;
+
+    AVBufferRef *hwaccel_priv_buf;
+    void *hwaccel_picture_private;
+
+    /**
+     * A sequence counter, so that old frames are output first
+     * after a POC reset
+     */
+    uint16_t sequence;
+
+    /**
+     * A combination of HEVC_FRAME_FLAG_*
+     */
+    uint8_t flags;
+} HEVCFrame;
+
+typedef struct HEVCLocalContext {
+    uint8_t cabac_state[HEVC_CONTEXTS];
+
+    uint8_t stat_coeff[4];
+
+    uint8_t first_qp_group;
+
+    GetBitContext gb;
+    CABACContext cc;
+
+    int8_t qp_y;
+    int8_t curr_qp_y;
+
+    int qPy_pred;
+
+    TransformUnit tu;
+
+    uint8_t ctb_left_flag;
+    uint8_t ctb_up_flag;
+    uint8_t ctb_up_right_flag;
+    uint8_t ctb_up_left_flag;
+    int     end_of_tiles_x;
+    int     end_of_tiles_y;
+    /* +7 is for subpixel interpolation, *2 for high bit depths */
+    DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer)[(MAX_PB_SIZE + 7) * EDGE_EMU_BUFFER_STRIDE * 2];
+    /* The extended size between the new edge emu buffer is abused by SAO */
+    DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer2)[(MAX_PB_SIZE + 7) * EDGE_EMU_BUFFER_STRIDE * 2];
+    DECLARE_ALIGNED(32, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
+
+    int ct_depth;
+    CodingUnit cu;
+    PredictionUnit pu;
+    NeighbourAvailable na;
+
+#define BOUNDARY_LEFT_SLICE     (1 << 0)
+#define BOUNDARY_LEFT_TILE      (1 << 1)
+#define BOUNDARY_UPPER_SLICE    (1 << 2)
+#define BOUNDARY_UPPER_TILE     (1 << 3)
+    /* properties of the boundary of the current CTB for the purposes
+     * of the deblocking filter */
+    int boundary_flags;
+} HEVCLocalContext;
+
+typedef struct HEVCContext {
+    const AVClass *c;  // needed by private avoptions
+    AVCodecContext *avctx;
+
+    struct HEVCContext  *sList[MAX_NB_THREADS];
+
+    HEVCLocalContext    *HEVClcList[MAX_NB_THREADS];
+    HEVCLocalContext    *HEVClc;
+
+    uint8_t             threads_type;
+    uint8_t             threads_number;
+
+    int                 width;
+    int                 height;
+
+    uint8_t *cabac_state;
+
+    /** 1 if the independent slice segment header was successfully parsed */
+    uint8_t slice_initialized;
+
+    AVFrame *frame;
+    AVFrame *output_frame;
+    uint8_t *sao_pixel_buffer_h[3];
+    uint8_t *sao_pixel_buffer_v[3];
+
+    HEVCParamSets ps;
+
+    AVBufferPool *tab_mvf_pool;
+    AVBufferPool *rpl_tab_pool;
+
+    ///< candidate references for the current frame
+    RefPicList rps[5];
+
+    SliceHeader sh;
+    SAOParams *sao;
+    DBParams *deblock;
+    enum HEVCNALUnitType nal_unit_type;
+    int temporal_id;  ///< temporal_id_plus1 - 1
+    HEVCFrame *ref;
+    HEVCFrame DPB[32];
+    int poc;
+    int pocTid0;
+    int slice_idx; ///< number of the slice being currently decoded
+    int eos;       ///< current packet contains an EOS/EOB NAL
+    int last_eos;  ///< last packet contains an EOS/EOB NAL
+    int max_ra;
+    int bs_width;
+    int bs_height;
+
+    int is_decoded;
+    int no_rasl_output_flag;
+
+    HEVCPredContext hpc;
+    HEVCDSPContext hevcdsp;
+    VideoDSPContext vdsp;
+    BswapDSPContext bdsp;
+    int8_t *qp_y_tab;
+    uint8_t *horizontal_bs;
+    uint8_t *vertical_bs;
+
+    int32_t *tab_slice_address;
+
+    //  CU
+    uint8_t *skip_flag;
+    uint8_t *tab_ct_depth;
+    // PU
+    uint8_t *tab_ipm;
+
+    uint8_t *cbf_luma; // cbf_luma of colocated TU
+    uint8_t *is_pcm;
+
+    // CTB-level flags affecting loop filter operation
+    uint8_t *filter_slice_edges;
+
+    /** used on BE to byteswap the lines for checksumming */
+    uint8_t *checksum_buf;
+    int      checksum_buf_size;
+
+    /**
+     * Sequence counters for decoded and output frames, so that old
+     * frames are output first after a POC reset
+     */
+    uint16_t seq_decode;
+    uint16_t seq_output;
+
+    int enable_parallel_tiles;
+    atomic_int wpp_err;
+
+    const uint8_t *data;
+
+    H2645Packet pkt;
+    // type of the first VCL NAL of the current frame
+    enum HEVCNALUnitType first_nal_type;
+
+    uint8_t context_initialized;
+    int is_nalff;           ///< this flag is != 0 if bitstream is encapsulated
+                            ///< as a format defined in 14496-15
+    int apply_defdispwin;
+
+    int nal_length_size;    ///< Number of bytes used for nal length (1, 2 or 4)
+    int nuh_layer_id;
+
+    HEVCSEIContext sei;
+} HEVCContext;
+
+/**
+ * Mark all frames in DPB as unused for reference.
+ */
+void ff_hevc_clear_refs(HEVCContext *s);
+
+/**
+ * Drop all frames currently in DPB.
+ */
+void ff_hevc_flush_dpb(HEVCContext *s);
+
+RefPicList *ff_hevc_get_ref_list(HEVCContext *s, HEVCFrame *frame,
+                                 int x0, int y0);
+
+/**
+ * Construct the reference picture sets for the current frame.
+ */
+int ff_hevc_frame_rps(HEVCContext *s);
+
+/**
+ * Construct the reference picture list(s) for the current slice.
+ */
+int ff_hevc_slice_rpl(HEVCContext *s);
+
+void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts);
+int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts);
+int ff_hevc_sao_merge_flag_decode(HEVCContext *s);
+int ff_hevc_sao_type_idx_decode(HEVCContext *s);
+int ff_hevc_sao_band_position_decode(HEVCContext *s);
+int ff_hevc_sao_offset_abs_decode(HEVCContext *s);
+int ff_hevc_sao_offset_sign_decode(HEVCContext *s);
+int ff_hevc_sao_eo_class_decode(HEVCContext *s);
+int ff_hevc_end_of_slice_flag_decode(HEVCContext *s);
+int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s);
+int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0,
+                             int x_cb, int y_cb);
+int ff_hevc_pred_mode_decode(HEVCContext *s);
+int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth,
+                                          int x0, int y0);
+int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size);
+int ff_hevc_pcm_flag_decode(HEVCContext *s);
+int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s);
+int ff_hevc_mpm_idx_decode(HEVCContext *s);
+int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s);
+int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s);
+int ff_hevc_merge_idx_decode(HEVCContext *s);
+int ff_hevc_merge_flag_decode(HEVCContext *s);
+int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH);
+int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx);
+int ff_hevc_mvp_lx_flag_decode(HEVCContext *s);
+int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s);
+int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size);
+int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth);
+int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth);
+int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx);
+int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx);
+
+/**
+ * Get the number of candidate references for the current frame.
+ */
+int ff_hevc_frame_nb_refs(HEVCContext *s);
+
+int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc);
+
+/**
+ * Find next frame in output order and put a reference to it in frame.
+ * @return 1 if a frame was output, 0 otherwise
+ */
+int ff_hevc_output_frame(HEVCContext *s, AVFrame *frame, int flush);
+
+void ff_hevc_bump_frame(HEVCContext *s);
+
+void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags);
+
+void ff_hevc_set_neighbour_available(HEVCContext *s, int x0, int y0,
+                                     int nPbW, int nPbH);
+void ff_hevc_luma_mv_merge_mode(HEVCContext *s, int x0, int y0,
+                                int nPbW, int nPbH, int log2_cb_size,
+                                int part_idx, int merge_idx, MvField *mv);
+void ff_hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0,
+                              int nPbW, int nPbH, int log2_cb_size,
+                              int part_idx, int merge_idx,
+                              MvField *mv, int mvp_lx_flag, int LX);
+void ff_hevc_set_qPy(HEVCContext *s, int xBase, int yBase,
+                     int log2_cb_size);
+void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0,
+                                           int log2_trafo_size);
+int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s);
+int ff_hevc_cu_qp_delta_abs(HEVCContext *s);
+int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s);
+int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s);
+void ff_hevc_hls_filter(HEVCContext *s, int x, int y, int ctb_size);
+void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size);
+void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
+                                 int log2_trafo_size, enum ScanType scan_idx,
+                                 int c_idx);
+
+void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size);
+
+extern const uint8_t ff_hevc_qpel_extra_before[4];
+extern const uint8_t ff_hevc_qpel_extra_after[4];
+extern const uint8_t ff_hevc_qpel_extra[4];
+
+#endif /* AVCODEC_HEVCDEC_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/hevcdsp.c b/mythtv/external/FFmpeg/libavcodec/hevcdsp.c
index 9d773d960ef..76ae72b6d4c 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevcdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevcdsp.c
@@ -195,13 +195,13 @@ void ff_hevc_dsp_init(HEVCDSPContext *hevcdsp, int bit_depth)
 
 #define HEVC_DSP(depth)                                                     \
     hevcdsp->put_pcm                = FUNC(put_pcm, depth);                 \
-    hevcdsp->transform_add[0]       = FUNC(transform_add4x4, depth);        \
-    hevcdsp->transform_add[1]       = FUNC(transform_add8x8, depth);        \
-    hevcdsp->transform_add[2]       = FUNC(transform_add16x16, depth);      \
-    hevcdsp->transform_add[3]       = FUNC(transform_add32x32, depth);      \
-    hevcdsp->transform_skip         = FUNC(transform_skip, depth);          \
+    hevcdsp->add_residual[0]        = FUNC(add_residual4x4, depth);         \
+    hevcdsp->add_residual[1]        = FUNC(add_residual8x8, depth);         \
+    hevcdsp->add_residual[2]        = FUNC(add_residual16x16, depth);       \
+    hevcdsp->add_residual[3]        = FUNC(add_residual32x32, depth);       \
+    hevcdsp->dequant                = FUNC(dequant, depth);                 \
     hevcdsp->transform_rdpcm        = FUNC(transform_rdpcm, depth);         \
-    hevcdsp->idct_4x4_luma          = FUNC(transform_4x4_luma, depth);      \
+    hevcdsp->transform_4x4_luma     = FUNC(transform_4x4_luma, depth);      \
     hevcdsp->idct[0]                = FUNC(idct_4x4, depth);                \
     hevcdsp->idct[1]                = FUNC(idct_8x8, depth);                \
     hevcdsp->idct[2]                = FUNC(idct_16x16, depth);              \
@@ -257,6 +257,8 @@ int i = 0;
         break;
     }
 
+    if (ARCH_PPC)
+        ff_hevc_dsp_init_ppc(hevcdsp, bit_depth);
     if (ARCH_X86)
         ff_hevc_dsp_init_x86(hevcdsp, bit_depth);
     if (ARCH_ARM)
diff --git a/mythtv/external/FFmpeg/libavcodec/hevcdsp.h b/mythtv/external/FFmpeg/libavcodec/hevcdsp.h
index 9f1f6dd59ff..dc48ebca111 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevcdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/hevcdsp.h
@@ -46,13 +46,13 @@ typedef struct HEVCDSPContext {
     void (*put_pcm)(uint8_t *_dst, ptrdiff_t _stride, int width, int height,
                     struct GetBitContext *gb, int pcm_bit_depth);
 
-    void (*transform_add[4])(uint8_t *_dst, int16_t *coeffs, ptrdiff_t _stride);
+    void (*add_residual[4])(uint8_t *dst, int16_t *res, ptrdiff_t stride);
 
-    void (*transform_skip)(int16_t *coeffs, int16_t log2_size);
+    void (*dequant)(int16_t *coeffs, int16_t log2_size);
 
     void (*transform_rdpcm)(int16_t *coeffs, int16_t log2_size, int mode);
 
-    void (*idct_4x4_luma)(int16_t *coeffs);
+    void (*transform_4x4_luma)(int16_t *coeffs);
 
     void (*idct[4])(int16_t *coeffs, int col_limit);
 
@@ -127,6 +127,7 @@ void ff_hevc_dsp_init(HEVCDSPContext *hpc, int bit_depth);
 extern const int8_t ff_hevc_epel_filters[7][4];
 extern const int8_t ff_hevc_qpel_filters[3][16];
 
+void ff_hevc_dsp_init_ppc(HEVCDSPContext *c, const int bit_depth);
 void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth);
 void ff_hevcdsp_init_arm(HEVCDSPContext *c, const int bit_depth);
 void ff_hevc_dsp_init_mips(HEVCDSPContext *c, const int bit_depth);
diff --git a/mythtv/external/FFmpeg/libavcodec/hevcdsp_template.c b/mythtv/external/FFmpeg/libavcodec/hevcdsp_template.c
index b840d179c33..0623cfad896 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevcdsp_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevcdsp_template.c
@@ -21,12 +21,11 @@
  */
 
 #include "get_bits.h"
-#include "hevc.h"
+#include "hevcdec.h"
 
 #include "bit_depth_template.c"
 #include "hevcdsp.h"
 
-
 static void FUNC(put_pcm)(uint8_t *_dst, ptrdiff_t stride, int width, int height,
                           GetBitContext *gb, int pcm_bit_depth)
 {
@@ -42,8 +41,8 @@ static void FUNC(put_pcm)(uint8_t *_dst, ptrdiff_t stride, int width, int height
     }
 }
 
-static av_always_inline void FUNC(transquant_bypass)(uint8_t *_dst, int16_t *coeffs,
-                                                     ptrdiff_t stride, int size)
+static av_always_inline void FUNC(add_residual)(uint8_t *_dst, int16_t *res,
+                                                ptrdiff_t stride, int size)
 {
     int x, y;
     pixel *dst = (pixel *)_dst;
@@ -52,38 +51,37 @@ static av_always_inline void FUNC(transquant_bypass)(uint8_t *_dst, int16_t *coe
 
     for (y = 0; y < size; y++) {
         for (x = 0; x < size; x++) {
-            dst[x] = av_clip_pixel(dst[x] + *coeffs);
-            coeffs++;
+            dst[x] = av_clip_pixel(dst[x] + *res);
+            res++;
         }
         dst += stride;
     }
 }
 
-static void FUNC(transform_add4x4)(uint8_t *_dst, int16_t *coeffs,
-                                       ptrdiff_t stride)
+static void FUNC(add_residual4x4)(uint8_t *_dst, int16_t *res,
+                                  ptrdiff_t stride)
 {
-    FUNC(transquant_bypass)(_dst, coeffs, stride, 4);
+    FUNC(add_residual)(_dst, res, stride, 4);
 }
 
-static void FUNC(transform_add8x8)(uint8_t *_dst, int16_t *coeffs,
-                                       ptrdiff_t stride)
+static void FUNC(add_residual8x8)(uint8_t *_dst, int16_t *res,
+                                  ptrdiff_t stride)
 {
-    FUNC(transquant_bypass)(_dst, coeffs, stride, 8);
+    FUNC(add_residual)(_dst, res, stride, 8);
 }
 
-static void FUNC(transform_add16x16)(uint8_t *_dst, int16_t *coeffs,
-                                         ptrdiff_t stride)
+static void FUNC(add_residual16x16)(uint8_t *_dst, int16_t *res,
+                                    ptrdiff_t stride)
 {
-    FUNC(transquant_bypass)(_dst, coeffs, stride, 16);
+    FUNC(add_residual)(_dst, res, stride, 16);
 }
 
-static void FUNC(transform_add32x32)(uint8_t *_dst, int16_t *coeffs,
-                                         ptrdiff_t stride)
+static void FUNC(add_residual32x32)(uint8_t *_dst, int16_t *res,
+                                    ptrdiff_t stride)
 {
-    FUNC(transquant_bypass)(_dst, coeffs, stride, 32);
+    FUNC(add_residual)(_dst, res, stride, 32);
 }
 
-
 static void FUNC(transform_rdpcm)(int16_t *_coeffs, int16_t log2_size, int mode)
 {
     int16_t *coeffs = (int16_t *) _coeffs;
@@ -106,13 +104,11 @@ static void FUNC(transform_rdpcm)(int16_t *_coeffs, int16_t log2_size, int mode)
     }
 }
 
-static void FUNC(transform_skip)(int16_t *_coeffs, int16_t log2_size)
+static void FUNC(dequant)(int16_t *coeffs, int16_t log2_size)
 {
     int shift  = 15 - BIT_DEPTH - log2_size;
     int x, y;
     int size = 1 << log2_size;
-    int16_t *coeffs = _coeffs;
-
 
     if (shift > 0) {
         int offset = 1 << (shift - 1);
@@ -134,8 +130,6 @@ static void FUNC(transform_skip)(int16_t *_coeffs, int16_t log2_size)
 
 #define SET(dst, x)   (dst) = (x)
 #define SCALE(dst, x) (dst) = av_clip_int16(((x) + add) >> shift)
-#define ADD_AND_SCALE(dst, x)                                           \
-    (dst) = av_clip_pixel((dst) + av_clip_int16(((x) + add) >> shift))
 
 #define TR_4x4_LUMA(dst, src, step, assign)                             \
     do {                                                                \
@@ -174,112 +168,113 @@ static void FUNC(transform_4x4_luma)(int16_t *coeffs)
 
 #undef TR_4x4_LUMA
 
-#define TR_4(dst, src, dstep, sstep, assign, end)                              \
-    do {                                                                       \
-        const int e0 = 64 * src[0 * sstep] + 64 * src[2 * sstep];              \
-        const int e1 = 64 * src[0 * sstep] - 64 * src[2 * sstep];              \
-        const int o0 = 83 * src[1 * sstep] + 36 * src[3 * sstep];              \
-        const int o1 = 36 * src[1 * sstep] - 83 * src[3 * sstep];              \
-                                                                               \
-        assign(dst[0 * dstep], e0 + o0);                                       \
-        assign(dst[1 * dstep], e1 + o1);                                       \
-        assign(dst[2 * dstep], e1 - o1);                                       \
-        assign(dst[3 * dstep], e0 - o0);                                       \
+#define TR_4(dst, src, dstep, sstep, assign, end)                 \
+    do {                                                          \
+        const int e0 = 64 * src[0 * sstep] + 64 * src[2 * sstep]; \
+        const int e1 = 64 * src[0 * sstep] - 64 * src[2 * sstep]; \
+        const int o0 = 83 * src[1 * sstep] + 36 * src[3 * sstep]; \
+        const int o1 = 36 * src[1 * sstep] - 83 * src[3 * sstep]; \
+                                                                  \
+        assign(dst[0 * dstep], e0 + o0);                          \
+        assign(dst[1 * dstep], e1 + o1);                          \
+        assign(dst[2 * dstep], e1 - o1);                          \
+        assign(dst[3 * dstep], e0 - o0);                          \
     } while (0)
 
-#define TR_8(dst, src, dstep, sstep, assign, end)                              \
-    do {                                                                       \
-        int i, j;                                                              \
-        int e_8[4];                                                            \
-        int o_8[4] = { 0 };                                                    \
-        for (i = 0; i < 4; i++)                                                \
-            for (j = 1; j < end; j += 2)                                       \
-                o_8[i] += transform[4 * j][i] * src[j * sstep];                \
-        TR_4(e_8, src, 1, 2 * sstep, SET, 4);                                  \
-                                                                               \
-        for (i = 0; i < 4; i++) {                                              \
-            assign(dst[i * dstep], e_8[i] + o_8[i]);                           \
-            assign(dst[(7 - i) * dstep], e_8[i] - o_8[i]);                     \
-        }                                                                      \
+#define TR_8(dst, src, dstep, sstep, assign, end)                 \
+    do {                                                          \
+        int i, j;                                                 \
+        int e_8[4];                                               \
+        int o_8[4] = { 0 };                                       \
+        for (i = 0; i < 4; i++)                                   \
+            for (j = 1; j < end; j += 2)                          \
+                o_8[i] += transform[4 * j][i] * src[j * sstep];   \
+        TR_4(e_8, src, 1, 2 * sstep, SET, 4);                     \
+                                                                  \
+        for (i = 0; i < 4; i++) {                                 \
+            assign(dst[i * dstep], e_8[i] + o_8[i]);              \
+            assign(dst[(7 - i) * dstep], e_8[i] - o_8[i]);        \
+        }                                                         \
     } while (0)
 
-#define TR_16(dst, src, dstep, sstep, assign, end)                             \
-    do {                                                                       \
-        int i, j;                                                              \
-        int e_16[8];                                                           \
-        int o_16[8] = { 0 };                                                   \
-        for (i = 0; i < 8; i++)                                                \
-            for (j = 1; j < end; j += 2)                                       \
-                o_16[i] += transform[2 * j][i] * src[j * sstep];               \
-        TR_8(e_16, src, 1, 2 * sstep, SET, 8);                                 \
-                                                                               \
-        for (i = 0; i < 8; i++) {                                              \
-            assign(dst[i * dstep], e_16[i] + o_16[i]);                         \
-            assign(dst[(15 - i) * dstep], e_16[i] - o_16[i]);                  \
-        }                                                                      \
+#define TR_16(dst, src, dstep, sstep, assign, end)                \
+    do {                                                          \
+        int i, j;                                                 \
+        int e_16[8];                                              \
+        int o_16[8] = { 0 };                                      \
+        for (i = 0; i < 8; i++)                                   \
+            for (j = 1; j < end; j += 2)                          \
+                o_16[i] += transform[2 * j][i] * src[j * sstep];  \
+        TR_8(e_16, src, 1, 2 * sstep, SET, 8);                    \
+                                                                  \
+        for (i = 0; i < 8; i++) {                                 \
+            assign(dst[i * dstep], e_16[i] + o_16[i]);            \
+            assign(dst[(15 - i) * dstep], e_16[i] - o_16[i]);     \
+        }                                                         \
     } while (0)
 
-#define TR_32(dst, src, dstep, sstep, assign, end)                             \
-    do {                                                                       \
-        int i, j;                                                              \
-        int e_32[16];                                                          \
-        int o_32[16] = { 0 };                                                  \
-        for (i = 0; i < 16; i++)                                               \
-            for (j = 1; j < end; j += 2)                                       \
-                o_32[i] += transform[j][i] * src[j * sstep];                   \
-        TR_16(e_32, src, 1, 2 * sstep, SET, end/2);                            \
-                                                                               \
-        for (i = 0; i < 16; i++) {                                             \
-            assign(dst[i * dstep], e_32[i] + o_32[i]);                         \
-            assign(dst[(31 - i) * dstep], e_32[i] - o_32[i]);                  \
-        }                                                                      \
+#define TR_32(dst, src, dstep, sstep, assign, end)                \
+    do {                                                          \
+        int i, j;                                                 \
+        int e_32[16];                                             \
+        int o_32[16] = { 0 };                                     \
+        for (i = 0; i < 16; i++)                                  \
+            for (j = 1; j < end; j += 2)                          \
+                o_32[i] += transform[j][i] * src[j * sstep];      \
+        TR_16(e_32, src, 1, 2 * sstep, SET, end / 2);             \
+                                                                  \
+        for (i = 0; i < 16; i++) {                                \
+            assign(dst[i * dstep], e_32[i] + o_32[i]);            \
+            assign(dst[(31 - i) * dstep], e_32[i] - o_32[i]);     \
+        }                                                         \
     } while (0)
 
-#define IDCT_VAR4(H)                                                          \
-    int      limit2   = FFMIN(col_limit + 4, H)
-#define IDCT_VAR8(H)                                                          \
-        int      limit   = FFMIN(col_limit, H);                               \
-        int      limit2   = FFMIN(col_limit + 4, H)
+#define IDCT_VAR4(H)                                              \
+    int limit2 = FFMIN(col_limit + 4, H)
+#define IDCT_VAR8(H)                                              \
+    int limit  = FFMIN(col_limit, H);                             \
+    int limit2 = FFMIN(col_limit + 4, H)
 #define IDCT_VAR16(H)   IDCT_VAR8(H)
 #define IDCT_VAR32(H)   IDCT_VAR8(H)
 
-#define IDCT(H)                                                              \
-static void FUNC(idct_##H ##x ##H )(                                         \
-                   int16_t *coeffs, int col_limit) {                         \
-    int i;                                                                   \
-    int      shift   = 7;                                                    \
-    int      add     = 1 << (shift - 1);                                     \
-    int16_t *src     = coeffs;                                               \
-    IDCT_VAR ##H(H);                                                         \
-                                                                             \
-    for (i = 0; i < H; i++) {                                                \
-        TR_ ## H(src, src, H, H, SCALE, limit2);                             \
-        if (limit2 < H && i%4 == 0 && !!i)                                   \
-            limit2 -= 4;                                                     \
-        src++;                                                               \
-    }                                                                        \
-                                                                             \
-    shift   = 20 - BIT_DEPTH;                                                \
-    add     = 1 << (shift - 1);                                              \
-    for (i = 0; i < H; i++) {                                                \
-        TR_ ## H(coeffs, coeffs, 1, 1, SCALE, limit);                        \
-        coeffs += H;                                                         \
-    }                                                                        \
+#define IDCT(H)                                                   \
+static void FUNC(idct_ ## H ## x ## H )(int16_t *coeffs,          \
+                                        int col_limit)            \
+{                                                                 \
+    int i;                                                        \
+    int      shift = 7;                                           \
+    int      add   = 1 << (shift - 1);                            \
+    int16_t *src   = coeffs;                                      \
+    IDCT_VAR ## H(H);                                             \
+                                                                  \
+    for (i = 0; i < H; i++) {                                     \
+        TR_ ## H(src, src, H, H, SCALE, limit2);                  \
+        if (limit2 < H && i%4 == 0 && !!i)                        \
+            limit2 -= 4;                                          \
+        src++;                                                    \
+    }                                                             \
+                                                                  \
+    shift = 20 - BIT_DEPTH;                                       \
+    add   = 1 << (shift - 1);                                     \
+    for (i = 0; i < H; i++) {                                     \
+        TR_ ## H(coeffs, coeffs, 1, 1, SCALE, limit);             \
+        coeffs += H;                                              \
+    }                                                             \
 }
 
-#define IDCT_DC(H)                                                           \
-static void FUNC(idct_##H ##x ##H ##_dc)(                                    \
-                   int16_t *coeffs) {                                        \
-    int i, j;                                                                \
-    int      shift   = 14 - BIT_DEPTH;                                       \
-    int      add     = 1 << (shift - 1);                                     \
-    int      coeff   = (((coeffs[0] + 1) >> 1) + add) >> shift;              \
-                                                                             \
-    for (j = 0; j < H; j++) {                                                \
-        for (i = 0; i < H; i++) {                                            \
-            coeffs[i+j*H] = coeff;                                           \
-        }                                                                    \
-    }                                                                        \
+#define IDCT_DC(H)                                                \
+static void FUNC(idct_ ## H ## x ## H ## _dc)(int16_t *coeffs)    \
+{                                                                 \
+    int i, j;                                                     \
+    int shift = 14 - BIT_DEPTH;                                   \
+    int add   = 1 << (shift - 1);                                 \
+    int coeff = (((coeffs[0] + 1) >> 1) + add) >> shift;          \
+                                                                  \
+    for (j = 0; j < H; j++) {                                     \
+        for (i = 0; i < H; i++) {                                 \
+            coeffs[i + j * H] = coeff;                            \
+        }                                                         \
+    }                                                             \
 }
 
 IDCT( 4)
@@ -299,7 +294,6 @@ IDCT_DC(32)
 
 #undef SET
 #undef SCALE
-#undef ADD_AND_SCALE
 
 static void FUNC(sao_band_filter)(uint8_t *_dst, uint8_t *_src,
                                   ptrdiff_t stride_dst, ptrdiff_t stride_src,
@@ -399,8 +393,8 @@ static void FUNC(sao_edge_restore_0)(uint8_t *_dst, uint8_t *_src,
         }
         if (borders[3]) {
             int offset_val   = sao_offset_val[0];
-            int y_stride_dst = stride_dst * (height - 1);
-            int y_stride_src = stride_src * (height - 1);
+            ptrdiff_t y_stride_dst = stride_dst * (height - 1);
+            ptrdiff_t y_stride_src = stride_src * (height - 1);
             for (x = init_x; x < width; x++)
                 dst[x + y_stride_dst] = av_clip_pixel(src[x + y_stride_src] + offset_val);
             height--;
@@ -450,8 +444,8 @@ static void FUNC(sao_edge_restore_1)(uint8_t *_dst, uint8_t *_src,
         }
         if (borders[3]) {
             int offset_val   = sao_offset_val[0];
-            int y_stride_dst = stride_dst * (height - 1);
-            int y_stride_src = stride_src * (height - 1);
+            ptrdiff_t y_stride_dst = stride_dst * (height - 1);
+            ptrdiff_t y_stride_src = stride_src * (height - 1);
             for (x = init_x; x < width; x++)
                 dst[x + y_stride_dst] = av_clip_pixel(src[x + y_stride_src] + offset_val);
             height--;
@@ -599,7 +593,7 @@ static void FUNC(put_hevc_pel_bi_w_pixels)(uint8_t *_dst, ptrdiff_t _dststride,
     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
     for (y = 0; y < height; y++) {
         for (x = 0; x < width; x++) {
-            dst[x] = av_clip_pixel(( (src[x] << (14 - BIT_DEPTH)) * wx1 + src2[x] * wx0 + ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
+            dst[x] = av_clip_pixel(( (src[x] << (14 - BIT_DEPTH)) * wx1 + src2[x] * wx0 + (ox0 + ox1 + 1) * (1 << log2Wd)) >> (log2Wd + 1));
         }
         src  += srcstride;
         dst  += dststride;
@@ -1361,7 +1355,7 @@ static void FUNC(put_hevc_epel_bi_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint
     for (y = 0; y < height; y++) {
         for (x = 0; x < width; x++)
             dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
-                                    ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
+                                    ((ox0 + ox1 + 1) * (1 << log2Wd))) >> (log2Wd + 1));
         src  += srcstride;
         dst  += dststride;
         src2 += MAX_PB_SIZE;
@@ -1413,7 +1407,7 @@ static void FUNC(put_hevc_epel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint
     for (y = 0; y < height; y++) {
         for (x = 0; x < width; x++)
             dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
-                                    ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
+                                    ((ox0 + ox1 + 1) * (1 << log2Wd))) >> (log2Wd + 1));
         src  += srcstride;
         dst  += dststride;
         src2 += MAX_PB_SIZE;
@@ -1492,12 +1486,14 @@ static void FUNC(put_hevc_epel_bi_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uin
     for (y = 0; y < height; y++) {
         for (x = 0; x < width; x++)
             dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx1 + src2[x] * wx0 +
-                                    ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
+                                    ((ox0 + ox1 + 1) * (1 << log2Wd))) >> (log2Wd + 1));
         tmp  += MAX_PB_SIZE;
         dst  += dststride;
         src2 += MAX_PB_SIZE;
     }
-}// line zero
+}
+
+// line zero
 #define P3 pix[-4 * xstride]
 #define P2 pix[-3 * xstride]
 #define P1 pix[-2 * xstride]
diff --git a/mythtv/external/FFmpeg/libavcodec/hevcpred.c b/mythtv/external/FFmpeg/libavcodec/hevcpred.c
index 02c17660594..7a86ed3d311 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevcpred.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevcpred.c
@@ -20,7 +20,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "hevc.h"
+#include "hevcdec.h"
 
 #include "hevcpred.h"
 
diff --git a/mythtv/external/FFmpeg/libavcodec/hevcpred_template.c b/mythtv/external/FFmpeg/libavcodec/hevcpred_template.c
index 6ae87cca130..6fe33546b10 100644
--- a/mythtv/external/FFmpeg/libavcodec/hevcpred_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/hevcpred_template.c
@@ -35,7 +35,7 @@ static av_always_inline void FUNC(intra_pred)(HEVCContext *s, int x0, int y0,
 #define MVF(x, y) \
     (s->ref->tab_mvf[(x) + (y) * min_pu_width])
 #define MVF_PU(x, y) \
-    MVF(PU(x0 + ((x) << hshift)), PU(y0 + ((y) << vshift)))
+    MVF(PU(x0 + ((x) * (1 << hshift))), PU(y0 + ((y) * (1 << vshift))))
 #define IS_INTRA(x, y) \
     (MVF_PU(x, y).pred_flag == PF_INTRA)
 #define MIN_TB_ADDR_ZS(x, y) \
diff --git a/mythtv/external/FFmpeg/libavcodec/hpeldsp.h b/mythtv/external/FFmpeg/libavcodec/hpeldsp.h
index 1a3cea54b88..768139bfc96 100644
--- a/mythtv/external/FFmpeg/libavcodec/hpeldsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/hpeldsp.h
@@ -76,6 +76,8 @@ typedef struct HpelDSPContext {
      * @param pixels source
      * @param line_size number of bytes in a horizontal line of block
      * @param h height
+     * @note The size is kept at [4][4] to match the above pixel_tabs and avoid
+     *       out of bounds reads in the motion estimation code.
      */
     op_pixels_func put_no_rnd_pixels_tab[4][4];
 
diff --git a/mythtv/external/FFmpeg/libavcodec/hq_hqa.c b/mythtv/external/FFmpeg/libavcodec/hq_hqa.c
index 5cf5fcfe2be..f88ad7d5f5a 100644
--- a/mythtv/external/FFmpeg/libavcodec/hq_hqa.c
+++ b/mythtv/external/FFmpeg/libavcodec/hq_hqa.c
@@ -68,11 +68,11 @@ static int hq_decode_block(HQContext *c, GetBitContext *gb, int16_t block[64],
     memset(block, 0, 64 * sizeof(*block));
 
     if (!is_hqa) {
-        block[0] = get_sbits(gb, 9) << 6;
+        block[0] = get_sbits(gb, 9) * 64;
         q = ff_hq_quants[qsel][is_chroma][get_bits(gb, 2)];
     } else {
         q = ff_hq_quants[qsel][is_chroma][get_bits(gb, 2)];
-        block[0] = get_sbits(gb, 9) << 6;
+        block[0] = get_sbits(gb, 9) * 64;
     }
 
     for (;;) {
@@ -83,7 +83,7 @@ static int hq_decode_block(HQContext *c, GetBitContext *gb, int16_t block[64],
         pos += ff_hq_ac_skips[val];
         if (pos >= 64)
             break;
-        block[ff_zigzag_direct[pos]] = (ff_hq_ac_syms[val] * q[pos]) >> 12;
+        block[ff_zigzag_direct[pos]] = (int)(ff_hq_ac_syms[val] * (unsigned)q[pos]) >> 12;
         pos++;
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/hq_hqadsp.c b/mythtv/external/FFmpeg/libavcodec/hq_hqadsp.c
index db1ea2e2462..1b9f138c726 100644
--- a/mythtv/external/FFmpeg/libavcodec/hq_hqadsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/hq_hqadsp.c
@@ -30,7 +30,7 @@
 #define FIX_1_414 23170
 #define FIX_2_613 21407 // divided by two to fit the range
 
-#define IDCTMUL(a, b) ((a) * (b) >> 16)
+#define IDCTMUL(a, b) ((int)((a) * (unsigned)(b)) >> 16)
 
 static inline void idct_row(int16_t *blk)
 {
diff --git a/mythtv/external/FFmpeg/libavcodec/hqx.c b/mythtv/external/FFmpeg/libavcodec/hqx.c
index 138d9604118..bc24ba91d12 100644
--- a/mythtv/external/FFmpeg/libavcodec/hqx.c
+++ b/mythtv/external/FFmpeg/libavcodec/hqx.c
@@ -27,6 +27,7 @@
 #include "canopus.h"
 #include "get_bits.h"
 #include "internal.h"
+#include "thread.h"
 
 #include "hqx.h"
 #include "hqxdsp.h"
@@ -405,6 +406,7 @@ static int hqx_decode_frame(AVCodecContext *avctx, void *data,
                             int *got_picture_ptr, AVPacket *avpkt)
 {
     HQXContext *ctx = avctx->priv_data;
+    ThreadFrame frame = { .f = data };
     uint8_t *src = avpkt->data;
     uint32_t info_tag;
     int data_start;
@@ -417,7 +419,7 @@ static int hqx_decode_frame(AVCodecContext *avctx, void *data,
 
     info_tag    = AV_RL32(src);
     if (info_tag == MKTAG('I', 'N', 'F', 'O')) {
-        unsigned info_offset = AV_RL32(src + 4);
+        uint32_t info_offset = AV_RL32(src + 4);
         if (info_offset > INT_MAX || info_offset + 8 > avpkt->size) {
             av_log(avctx, AV_LOG_ERROR,
                    "Invalid INFO header offset: 0x%08"PRIX32" is too large.\n",
@@ -491,7 +493,7 @@ static int hqx_decode_frame(AVCodecContext *avctx, void *data,
         return AVERROR_INVALIDDATA;
     }
 
-    ret = ff_get_buffer(avctx, ctx->pic, 0);
+    ret = ff_thread_get_buffer(avctx, &frame, 0);
     if (ret < 0)
         return ret;
 
@@ -510,6 +512,9 @@ static av_cold int hqx_decode_close(AVCodecContext *avctx)
     int i;
     HQXContext *ctx = avctx->priv_data;
 
+    if (avctx->internal->is_copy)
+        return 0;
+
     ff_free_vlc(&ctx->cbp_vlc);
     for (i = 0; i < 3; i++) {
         ff_free_vlc(&ctx->dc_vlc[i]);
@@ -536,7 +541,8 @@ AVCodec ff_hqx_decoder = {
     .init           = hqx_decode_init,
     .decode         = hqx_decode_frame,
     .close          = hqx_decode_close,
-    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS,
+    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS |
+                      AV_CODEC_CAP_FRAME_THREADS,
     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
                       FF_CODEC_CAP_INIT_CLEANUP,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/hqxdsp.c b/mythtv/external/FFmpeg/libavcodec/hqxdsp.c
index feff9c0b687..7f8044e463c 100644
--- a/mythtv/external/FFmpeg/libavcodec/hqxdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/hqxdsp.c
@@ -39,18 +39,18 @@ static inline void idct_col(int16_t *blk, const uint8_t *quant)
     s6 = (int) blk[6 * 8] * quant[6 * 8];
     s7 = (int) blk[7 * 8] * quant[7 * 8];
 
-    t0  =  (s3 * 19266 + s5 * 12873) >> 15;
-    t1  =  (s5 * 19266 - s3 * 12873) >> 15;
-    t2  = ((s7 * 4520  + s1 * 22725) >> 15) - t0;
-    t3  = ((s1 * 4520  - s7 * 22725) >> 15) - t1;
+    t0  =  (int)(s3 * 19266U + s5 * 12873U) >> 15;
+    t1  =  (int)(s5 * 19266U - s3 * 12873U) >> 15;
+    t2  = ((int)(s7 * 4520U  + s1 * 22725U) >> 15) - t0;
+    t3  = ((int)(s1 * 4520U  - s7 * 22725U) >> 15) - t1;
     t4  = t0 * 2 + t2;
     t5  = t1 * 2 + t3;
     t6  = t2 - t3;
     t7  = t3 * 2 + t6;
-    t8  = (t6 * 11585) >> 14;
-    t9  = (t7 * 11585) >> 14;
-    tA  = (s2 * 8867 - s6 * 21407) >> 14;
-    tB  = (s6 * 8867 + s2 * 21407) >> 14;
+    t8  = (int)(t6 * 11585U) >> 14;
+    t9  = (int)(t7 * 11585U) >> 14;
+    tA  = (int)(s2 * 8867U - s6 * 21407U) >> 14;
+    tB  = (int)(s6 * 8867U + s2 * 21407U) >> 14;
     tC  = (s0 >> 1) - (s4 >> 1);
     tD  = (s4 >> 1) * 2 + tC;
     tE  = tC - (tA >> 1);
diff --git a/mythtv/external/FFmpeg/libavcodec/htmlsubtitles.c b/mythtv/external/FFmpeg/libavcodec/htmlsubtitles.c
index a2cd40fad30..fb9f9004222 100644
--- a/mythtv/external/FFmpeg/libavcodec/htmlsubtitles.c
+++ b/mythtv/external/FFmpeg/libavcodec/htmlsubtitles.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2010  Aurelien Jacobs <aurel@gnuage.org>
+ * Copyright (c) 2017  Clément Bœsch <u@pkh.me>
  *
  * This file is part of FFmpeg.
  *
@@ -18,6 +19,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/avassert.h"
 #include "libavutil/avstring.h"
 #include "libavutil/common.h"
 #include "libavutil/parseutils.h"
@@ -26,40 +28,90 @@
 static int html_color_parse(void *log_ctx, const char *str)
 {
     uint8_t rgba[4];
+    int nb_sharps = 0;
+    while (str[nb_sharps] == '#')
+        nb_sharps++;
+    str += FFMAX(0, nb_sharps - 1);
     if (av_parse_color(rgba, str, strcspn(str, "\" >"), log_ctx) < 0)
         return -1;
     return rgba[0] | rgba[1] << 8 | rgba[2] << 16;
 }
 
-enum {
-    PARAM_UNKNOWN = -1,
-    PARAM_SIZE,
-    PARAM_COLOR,
-    PARAM_FACE,
-    PARAM_NUMBER
-};
-
-typedef struct SrtStack {
-    char tag[128];
-    char param[PARAM_NUMBER][128];
-} SrtStack;
-
 static void rstrip_spaces_buf(AVBPrint *buf)
 {
-    while (buf->len > 0 && buf->str[buf->len - 1] == ' ')
-        buf->str[--buf->len] = 0;
+    if (av_bprint_is_complete(buf))
+        while (buf->len > 0 && buf->str[buf->len - 1] == ' ')
+            buf->str[--buf->len] = 0;
+}
+
+/* skip all {\xxx} substrings except for {\an%d}
+   and all microdvd like styles such as {Y:xxx} */
+static void handle_open_brace(AVBPrint *dst, const char **inp, int *an, int *closing_brace_missing)
+{
+    int len = 0;
+    const char *in = *inp;
+
+    *an += sscanf(in, "{\\an%*1u}%n", &len) >= 0 && len > 0;
+
+    if (!*closing_brace_missing) {
+        if (   (*an != 1 && in[1] == '\\')
+            || (in[1] && strchr("CcFfoPSsYy", in[1]) && in[2] == ':')) {
+            char *bracep = strchr(in+2, '}');
+            if (bracep) {
+                *inp = bracep;
+                return;
+            } else
+                *closing_brace_missing = 1;
+        }
+    }
+
+    av_bprint_chars(dst, *in, 1);
 }
 
-void ff_htmlmarkup_to_ass(void *log_ctx, AVBPrint *dst, const char *in)
+struct font_tag {
+    char face[128];
+    int size;
+    uint32_t color;
+};
+
+/*
+ * The general politic of the convert is to mask unsupported tags or formatting
+ * errors (but still alert the user/subtitles writer with an error/warning)
+ * without dropping any actual text content for the final user.
+ */
+int ff_htmlmarkup_to_ass(void *log_ctx, AVBPrint *dst, const char *in)
 {
-    char *param, buffer[128], tmp[128];
-    int len, tag_close, sptr = 1, line_start = 1, an = 0, end = 0;
-    SrtStack stack[16];
+    char *param, buffer[128];
+    int len, tag_close, sptr = 0, line_start = 1, an = 0, end = 0;
+    int closing_brace_missing = 0;
+    int i, likely_a_tag;
+
+    /*
+     * state stack is only present for fonts since they are the only tags where
+     * the state is not binary. Here is a typical use case:
+     *
+     *   <font color="red" size=10>
+     *     red 10
+     *     <font size=50> RED AND BIG </font>
+     *     red 10 again
+     *   </font>
+     *
+     * On the other hand, using the state system for all the tags should be
+     * avoided because it breaks wrongly nested tags such as:
+     *
+     *   <b> foo <i> bar </b> bla </i>
+     *
+     * We don't want to break here; instead, we will treat all these tags as
+     * binary state markers. Basically, "<b>" will activate bold, and "</b>"
+     * will deactivate it, whatever the current state.
+     *
+     * This will also prevents cases where we have a random closing tag
+     * remaining after the opening one was dropped. Yes, this happens and we
+     * still don't want to print a "</b>" at the end of the dialog event.
+     */
+    struct font_tag stack[16];
 
-    stack[0].tag[0] = 0;
-    strcpy(stack[0].param[PARAM_SIZE],  "{\\fs}");
-    strcpy(stack[0].param[PARAM_COLOR], "{\\c}");
-    strcpy(stack[0].param[PARAM_FACE],  "{\\fn}");
+    memset(&stack[0], 0, sizeof(stack[0]));
 
     for (; !end && *in; in++) {
         switch (*in) {
@@ -78,91 +130,128 @@ void ff_htmlmarkup_to_ass(void *log_ctx, AVBPrint *dst, const char *in)
             if (!line_start)
                 av_bprint_chars(dst, *in, 1);
             break;
-        case '{':    /* skip all {\xxx} substrings except for {\an%d}
-                        and all microdvd like styles such as {Y:xxx} */
-            len = 0;
-            an += sscanf(in, "{\\an%*1u}%n", &len) >= 0 && len > 0;
-            if ((an != 1 && (len = 0, sscanf(in, "{\\%*[^}]}%n", &len) >= 0 && len > 0)) ||
-                (len = 0, sscanf(in, "{%*1[CcFfoPSsYy]:%*[^}]}%n", &len) >= 0 && len > 0)) {
-                in += len - 1;
-            } else
-                av_bprint_chars(dst, *in, 1);
+        case '{':
+            handle_open_brace(dst, &in, &an, &closing_brace_missing);
             break;
         case '<':
+            /*
+             * "<<" are likely latin guillemets in ASCII or some kind of random
+             * style effect; see sub/badsyntax.srt in the FATE samples
+             * directory for real test cases.
+             */
+
+            likely_a_tag = 1;
+            for (i = 0; in[1] == '<'; i++) {
+                av_bprint_chars(dst, '<', 1);
+                likely_a_tag = 0;
+                in++;
+            }
+
             tag_close = in[1] == '/';
+            if (tag_close)
+                likely_a_tag = 1;
+
+            av_assert0(in[0] == '<');
+
             len = 0;
-            if (sscanf(in+tag_close+1, "%127[^>]>%n", buffer, &len) >= 1 && len > 0) {
+
+            if (sscanf(in+tag_close+1, "%127[^<>]>%n", buffer, &len) >= 1 && len > 0) {
+                const int skip = len + tag_close;
                 const char *tagname = buffer;
-                while (*tagname == ' ')
+                while (*tagname == ' ') {
+                    likely_a_tag = 0;
                     tagname++;
+                }
                 if ((param = strchr(tagname, ' ')))
                     *param++ = 0;
-                if ((!tag_close && sptr < FF_ARRAY_ELEMS(stack)) ||
-                    ( tag_close && sptr > 0 && !strcmp(stack[sptr-1].tag, tagname))) {
-                    int i, j, unknown = 0;
-                    in += len + tag_close;
-                    if (!tag_close)
-                        memset(stack+sptr, 0, sizeof(*stack));
-                    if (!strcmp(tagname, "font")) {
-                        if (tag_close) {
-                            for (i=PARAM_NUMBER-1; i>=0; i--)
-                                if (stack[sptr-1].param[i][0])
-                                    for (j=sptr-2; j>=0; j--)
-                                        if (stack[j].param[i][0]) {
-                                            av_bprintf(dst, "%s", stack[j].param[i]);
-                                            break;
-                                        }
-                        } else {
-                            while (param) {
-                                if (!strncmp(param, "size=", 5)) {
-                                    unsigned font_size;
-                                    param += 5 + (param[5] == '"');
-                                    if (sscanf(param, "%u", &font_size) == 1) {
-                                        snprintf(stack[sptr].param[PARAM_SIZE],
-                                             sizeof(stack[0].param[PARAM_SIZE]),
-                                             "{\\fs%u}", font_size);
-                                    }
-                                } else if (!strncmp(param, "color=", 6)) {
-                                    param += 6 + (param[6] == '"');
-                                    snprintf(stack[sptr].param[PARAM_COLOR],
-                                         sizeof(stack[0].param[PARAM_COLOR]),
-                                         "{\\c&H%X&}",
-                                         html_color_parse(log_ctx, param));
-                                } else if (!strncmp(param, "face=", 5)) {
-                                    param += 5 + (param[5] == '"');
-                                    len = strcspn(param,
-                                                  param[-1] == '"' ? "\"" :" ");
-                                    av_strlcpy(tmp, param,
-                                               FFMIN(sizeof(tmp), len+1));
-                                    param += len;
-                                    snprintf(stack[sptr].param[PARAM_FACE],
-                                             sizeof(stack[0].param[PARAM_FACE]),
-                                             "{\\fn%s}", tmp);
+
+                /* Check if this is likely a tag */
+#define LIKELY_A_TAG_CHAR(x) (((x) >= '0' && (x) <= '9') || \
+                              ((x) >= 'a' && (x) <= 'z') || \
+                              ((x) >= 'A' && (x) <= 'Z') || \
+                               (x) == '_' || (x) == '/')
+                for (i = 0; tagname[i]; i++) {
+                    if (!LIKELY_A_TAG_CHAR(tagname[i])) {
+                        likely_a_tag = 0;
+                        break;
+                    }
+                }
+
+                if (!av_strcasecmp(tagname, "font")) {
+                    if (tag_close && sptr > 0) {
+                        struct font_tag *cur_tag  = &stack[sptr--];
+                        struct font_tag *last_tag = &stack[sptr];
+
+                        if (cur_tag->size) {
+                            if (!last_tag->size)
+                                av_bprintf(dst, "{\\fs}");
+                            else if (last_tag->size != cur_tag->size)
+                                av_bprintf(dst, "{\\fs%d}", last_tag->size);
+                        }
+
+                        if (cur_tag->color & 0xff000000) {
+                            if (!(last_tag->color & 0xff000000))
+                                av_bprintf(dst, "{\\c}");
+                            else if (last_tag->color != cur_tag->color)
+                                av_bprintf(dst, "{\\c&H%"PRIX32"&}", last_tag->color & 0xffffff);
+                        }
+
+                        if (cur_tag->face[0]) {
+                            if (!last_tag->face[0])
+                                av_bprintf(dst, "{\\fn}");
+                            else if (strcmp(last_tag->face, cur_tag->face))
+                                av_bprintf(dst, "{\\fn%s}", last_tag->face);
+                        }
+                    } else if (!tag_close && sptr < FF_ARRAY_ELEMS(stack) - 1) {
+                        struct font_tag *new_tag = &stack[sptr + 1];
+
+                        *new_tag = stack[sptr++];
+
+                        while (param) {
+                            if (!av_strncasecmp(param, "size=", 5)) {
+                                param += 5 + (param[5] == '"');
+                                if (sscanf(param, "%u", &new_tag->size) == 1)
+                                    av_bprintf(dst, "{\\fs%u}", new_tag->size);
+                            } else if (!av_strncasecmp(param, "color=", 6)) {
+                                int color;
+                                param += 6 + (param[6] == '"');
+                                color = html_color_parse(log_ctx, param);
+                                if (color >= 0) {
+                                    new_tag->color = 0xff000000 | color;
+                                    av_bprintf(dst, "{\\c&H%"PRIX32"&}", new_tag->color & 0xffffff);
                                 }
-                                if ((param = strchr(param, ' ')))
-                                    param++;
+                            } else if (!av_strncasecmp(param, "face=", 5)) {
+                                param += 5 + (param[5] == '"');
+                                len = strcspn(param,
+                                              param[-1] == '"' ? "\"" :" ");
+                                av_strlcpy(new_tag->face, param,
+                                           FFMIN(sizeof(new_tag->face), len+1));
+                                param += len;
+                                av_bprintf(dst, "{\\fn%s}", new_tag->face);
                             }
-                            for (i=0; i<PARAM_NUMBER; i++)
-                                if (stack[sptr].param[i][0])
-                                    av_bprintf(dst, "%s", stack[sptr].param[i]);
+                            if ((param = strchr(param, ' ')))
+                                param++;
                         }
-                    } else if (!tagname[1] && strspn(tagname, "bisu") == 1) {
-                        av_bprintf(dst, "{\\%c%d}", tagname[0], !tag_close);
-                    } else {
-                        unknown = 1;
-                        snprintf(tmp, sizeof(tmp), "</%s>", tagname);
                     }
-                    if (tag_close) {
-                        sptr--;
-                    } else if (unknown && !strstr(in, tmp)) {
-                        in -= len + tag_close;
-                        av_bprint_chars(dst, *in, 1);
-                    } else
-                        av_strlcpy(stack[sptr++].tag, tagname,
-                                   sizeof(stack[0].tag));
-                    break;
+                    in += skip;
+                } else if (tagname[0] && !tagname[1] && strchr("bisu", av_tolower(tagname[0]))) {
+                    av_bprintf(dst, "{\\%c%d}", (char)av_tolower(tagname[0]), !tag_close);
+                    in += skip;
+                } else if (!av_strncasecmp(tagname, "br", 2) &&
+                           (!tagname[2] || (tagname[2] == '/' && !tagname[3]))) {
+                    av_bprintf(dst, "\\N");
+                    in += skip;
+                } else if (likely_a_tag) {
+                    if (!tag_close) // warn only once
+                        av_log(log_ctx, AV_LOG_WARNING, "Unrecognized tag %s\n", tagname);
+                    in += skip;
+                } else {
+                    av_bprint_chars(dst, '<', 1);
                 }
+            } else {
+                av_bprint_chars(dst, *in, 1);
             }
+            break;
         default:
             av_bprint_chars(dst, *in, 1);
             break;
@@ -171,8 +260,13 @@ void ff_htmlmarkup_to_ass(void *log_ctx, AVBPrint *dst, const char *in)
             line_start = 0;
     }
 
+    if (!av_bprint_is_complete(dst))
+        return AVERROR(ENOMEM);
+
     while (dst->len >= 2 && !strncmp(&dst->str[dst->len - 2], "\\N", 2))
         dst->len -= 2;
     dst->str[dst->len] = 0;
     rstrip_spaces_buf(dst);
+
+    return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/htmlsubtitles.h b/mythtv/external/FFmpeg/libavcodec/htmlsubtitles.h
index e10cdda241e..f3a8ef5d8b4 100644
--- a/mythtv/external/FFmpeg/libavcodec/htmlsubtitles.h
+++ b/mythtv/external/FFmpeg/libavcodec/htmlsubtitles.h
@@ -23,6 +23,6 @@
 
 #include "libavutil/bprint.h"
 
-void ff_htmlmarkup_to_ass(void *log_ctx, AVBPrint *dst, const char *in);
+int ff_htmlmarkup_to_ass(void *log_ctx, AVBPrint *dst, const char *in);
 
 #endif /* AVCODEC_HTMLSUBTITLES_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/huffyuv.c b/mythtv/external/FFmpeg/libavcodec/huffyuv.c
index 492155550f0..e582060cc3c 100644
--- a/mythtv/external/FFmpeg/libavcodec/huffyuv.c
+++ b/mythtv/external/FFmpeg/libavcodec/huffyuv.c
@@ -76,7 +76,6 @@ av_cold void ff_huffyuv_common_init(AVCodecContext *avctx)
     s->flags = avctx->flags;
 
     ff_bswapdsp_init(&s->bdsp);
-    ff_llviddsp_init(&s->llviddsp, avctx);
 
     s->width = avctx->width;
     s->height = avctx->height;
diff --git a/mythtv/external/FFmpeg/libavcodec/huffyuv.h b/mythtv/external/FFmpeg/libavcodec/huffyuv.h
index c18247ed0f7..83309d4b116 100644
--- a/mythtv/external/FFmpeg/libavcodec/huffyuv.h
+++ b/mythtv/external/FFmpeg/libavcodec/huffyuv.h
@@ -38,6 +38,7 @@
 #include "huffyuvencdsp.h"
 #include "put_bits.h"
 #include "lossless_videodsp.h"
+#include "lossless_videoencdsp.h"
 
 #define VLC_BITS 12
 
@@ -89,6 +90,7 @@ typedef struct HYuvContext {
     HuffYUVDSPContext hdsp;
     HuffYUVEncDSPContext hencdsp;
     LLVidDSPContext llviddsp;
+    LLVidEncDSPContext llvidencdsp;
     int non_determ; // non-deterministic, multi-threaded encoder allowed
 } HYuvContext;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/huffyuvdec.c b/mythtv/external/FFmpeg/libavcodec/huffyuvdec.c
index 7314519fca1..979c4b9d5c1 100644
--- a/mythtv/external/FFmpeg/libavcodec/huffyuvdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/huffyuvdec.c
@@ -36,6 +36,7 @@
 #include "get_bits.h"
 #include "huffyuv.h"
 #include "huffyuvdsp.h"
+#include "lossless_videodsp.h"
 #include "thread.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/pixdesc.h"
@@ -296,7 +297,8 @@ static av_cold int decode_init(AVCodecContext *avctx)
     if (ret < 0)
         return ret;
 
-    ff_huffyuvdsp_init(&s->hdsp);
+    ff_huffyuvdsp_init(&s->hdsp, avctx->pix_fmt);
+    ff_llviddsp_init(&s->llviddsp);
     memset(s->vlc, 0, 4 * sizeof(VLC));
 
     s->interlaced = avctx->height > 288;
@@ -577,6 +579,8 @@ static av_cold int decode_init_thread_copy(AVCodecContext *avctx)
     HYuvContext *s = avctx->priv_data;
     int i, ret;
 
+    s->avctx = avctx;
+
     if ((ret = ff_huffyuv_alloc_temp(s)) < 0) {
         ff_huffyuv_common_end(s);
         return ret;
@@ -878,27 +882,27 @@ static void draw_slice(HYuvContext *s, AVFrame *frame, int y)
 static int left_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int acc)
 {
     if (s->bps <= 8) {
-        return s->hdsp.add_hfyu_left_pred(dst, src, w, acc);
+        return s->llviddsp.add_left_pred(dst, src, w, acc);
     } else {
-        return s->llviddsp.add_hfyu_left_pred_int16((      uint16_t *)dst, (const uint16_t *)src, s->n-1, w, acc);
+        return s->llviddsp.add_left_pred_int16((      uint16_t *)dst, (const uint16_t *)src, s->n-1, w, acc);
     }
 }
 
 static void add_bytes(HYuvContext *s, uint8_t *dst, uint8_t *src, int w)
 {
     if (s->bps <= 8) {
-        s->hdsp.add_bytes(dst, src, w);
+        s->llviddsp.add_bytes(dst, src, w);
     } else {
-        s->llviddsp.add_int16((uint16_t*)dst, (const uint16_t*)src, s->n - 1, w);
+        s->hdsp.add_int16((uint16_t*)dst, (const uint16_t*)src, s->n - 1, w);
     }
 }
 
 static void add_median_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, const uint8_t *diff, int w, int *left, int *left_top)
 {
     if (s->bps <= 8) {
-        s->hdsp.add_hfyu_median_pred(dst, src, diff, w, left, left_top);
+        s->llviddsp.add_median_pred(dst, src, diff, w, left, left_top);
     } else {
-        s->llviddsp.add_hfyu_median_pred_int16((uint16_t *)dst, (const uint16_t *)src, (const uint16_t *)diff, s->n-1, w, left, left_top);
+        s->hdsp.add_hfyu_median_pred_int16((uint16_t *)dst, (const uint16_t *)src, (const uint16_t *)diff, s->n-1, w, left, left_top);
     }
 }
 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
@@ -1038,11 +1042,11 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
             case LEFT:
             case PLANE:
                 decode_422_bitstream(s, width - 2);
-                lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + 2, s->temp[0],
+                lefty = s->llviddsp.add_left_pred(p->data[0] + 2, s->temp[0],
                                                    width - 2, lefty);
                 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
-                    leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
-                    leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
+                    leftu = s->llviddsp.add_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
+                    leftv = s->llviddsp.add_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
                 }
 
                 for (cy = y = 1; y < s->height; y++, cy++) {
@@ -1053,11 +1057,11 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 
                         ydst = p->data[0] + p->linesize[0] * y;
 
-                        lefty = s->hdsp.add_hfyu_left_pred(ydst, s->temp[0],
+                        lefty = s->llviddsp.add_left_pred(ydst, s->temp[0],
                                                            width, lefty);
                         if (s->predictor == PLANE) {
                             if (y > s->interlaced)
-                                s->hdsp.add_bytes(ydst, ydst - fake_ystride, width);
+                                s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width);
                         }
                         y++;
                         if (y >= s->height)
@@ -1071,18 +1075,18 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                     vdst = p->data[2] + p->linesize[2] * cy;
 
                     decode_422_bitstream(s, width);
-                    lefty = s->hdsp.add_hfyu_left_pred(ydst, s->temp[0],
+                    lefty = s->llviddsp.add_left_pred(ydst, s->temp[0],
                                                        width, lefty);
                     if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
-                        leftu = s->hdsp.add_hfyu_left_pred(udst, s->temp[1], width2, leftu);
-                        leftv = s->hdsp.add_hfyu_left_pred(vdst, s->temp[2], width2, leftv);
+                        leftu = s->llviddsp.add_left_pred(udst, s->temp[1], width2, leftu);
+                        leftv = s->llviddsp.add_left_pred(vdst, s->temp[2], width2, leftv);
                     }
                     if (s->predictor == PLANE) {
                         if (cy > s->interlaced) {
-                            s->hdsp.add_bytes(ydst, ydst - fake_ystride, width);
+                            s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width);
                             if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
-                                s->hdsp.add_bytes(udst, udst - fake_ustride, width2);
-                                s->hdsp.add_bytes(vdst, vdst - fake_vstride, width2);
+                                s->llviddsp.add_bytes(udst, udst - fake_ustride, width2);
+                                s->llviddsp.add_bytes(vdst, vdst - fake_vstride, width2);
                             }
                         }
                     }
@@ -1093,11 +1097,11 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
             case MEDIAN:
                 /* first line except first 2 pixels is left predicted */
                 decode_422_bitstream(s, width - 2);
-                lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + 2, s->temp[0],
+                lefty = s->llviddsp.add_left_pred(p->data[0] + 2, s->temp[0],
                                                    width - 2, lefty);
                 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
-                    leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
-                    leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
+                    leftu = s->llviddsp.add_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
+                    leftv = s->llviddsp.add_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
                 }
 
                 cy = y = 1;
@@ -1105,11 +1109,11 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                 /* second line is left predicted for interlaced case */
                 if (s->interlaced) {
                     decode_422_bitstream(s, width);
-                    lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + p->linesize[0],
+                    lefty = s->llviddsp.add_left_pred(p->data[0] + p->linesize[0],
                                                        s->temp[0], width, lefty);
                     if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
-                        leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
-                        leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
+                        leftu = s->llviddsp.add_left_pred(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
+                        leftv = s->llviddsp.add_left_pred(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
                     }
                     y++;
                     cy++;
@@ -1117,24 +1121,24 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 
                 /* next 4 pixels are left predicted too */
                 decode_422_bitstream(s, 4);
-                lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + fake_ystride,
+                lefty = s->llviddsp.add_left_pred(p->data[0] + fake_ystride,
                                                    s->temp[0], 4, lefty);
                 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
-                    leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
-                    leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
+                    leftu = s->llviddsp.add_left_pred(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
+                    leftv = s->llviddsp.add_left_pred(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
                 }
 
                 /* next line except the first 4 pixels is median predicted */
                 lefttopy = p->data[0][3];
                 decode_422_bitstream(s, width - 4);
-                s->hdsp.add_hfyu_median_pred(p->data[0] + fake_ystride + 4,
+                s->llviddsp.add_median_pred(p->data[0] + fake_ystride + 4,
                                              p->data[0] + 4, s->temp[0],
                                              width - 4, &lefty, &lefttopy);
                 if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
                     lefttopu = p->data[1][1];
                     lefttopv = p->data[2][1];
-                    s->hdsp.add_hfyu_median_pred(p->data[1] + fake_ustride + 2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
-                    s->hdsp.add_hfyu_median_pred(p->data[2] + fake_vstride + 2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
+                    s->llviddsp.add_median_pred(p->data[1] + fake_ustride + 2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
+                    s->llviddsp.add_median_pred(p->data[2] + fake_vstride + 2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
                 }
                 y++;
                 cy++;
@@ -1146,7 +1150,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                         while (2 * cy > y) {
                             decode_gray_bitstream(s, width);
                             ydst = p->data[0] + p->linesize[0] * y;
-                            s->hdsp.add_hfyu_median_pred(ydst, ydst - fake_ystride,
+                            s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
                                                          s->temp[0], width,
                                                          &lefty, &lefttopy);
                             y++;
@@ -1162,12 +1166,12 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                     udst = p->data[1] + p->linesize[1] * cy;
                     vdst = p->data[2] + p->linesize[2] * cy;
 
-                    s->hdsp.add_hfyu_median_pred(ydst, ydst - fake_ystride,
+                    s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
                                                  s->temp[0], width,
                                                  &lefty, &lefttopy);
                     if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
-                        s->hdsp.add_hfyu_median_pred(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
-                        s->hdsp.add_hfyu_median_pred(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
+                        s->llviddsp.add_median_pred(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
+                        s->llviddsp.add_median_pred(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
                     }
                 }
 
@@ -1210,7 +1214,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                         if (s->bitstream_bpp != 32)
                             left[A] = 0;
                         if (y < s->height - 1 - s->interlaced) {
-                            s->hdsp.add_bytes(p->data[0] + p->linesize[0] * y,
+                            s->llviddsp.add_bytes(p->data[0] + p->linesize[0] * y,
                                               p->data[0] + p->linesize[0] * y +
                                               fake_ystride, 4 * width);
                         }
diff --git a/mythtv/external/FFmpeg/libavcodec/huffyuvdsp.c b/mythtv/external/FFmpeg/libavcodec/huffyuvdsp.c
index e8a05f6592a..7b865fe40c5 100644
--- a/mythtv/external/FFmpeg/libavcodec/huffyuvdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/huffyuvdsp.c
@@ -23,36 +23,32 @@
 #include "mathops.h"
 #include "huffyuvdsp.h"
 
-// 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size
-#define pb_7f (~0UL / 255 * 0x7f)
-#define pb_80 (~0UL / 255 * 0x80)
+// 0x00010001 or 0x0001000100010001 or whatever, depending on the cpu's native arithmetic size
+#define pw_1 (ULONG_MAX / UINT16_MAX)
 
-static void add_bytes_c(uint8_t *dst, uint8_t *src, intptr_t w)
-{
+static void add_int16_c(uint16_t *dst, const uint16_t *src, unsigned mask, int w){
     long i;
-
-    for (i = 0; i <= w - (int) sizeof(long); i += sizeof(long)) {
-        long a = *(long *) (src + i);
-        long b = *(long *) (dst + i);
-        *(long *) (dst + i) = ((a & pb_7f) + (b & pb_7f)) ^ ((a ^ b) & pb_80);
+    unsigned long pw_lsb = (mask >> 1) * pw_1;
+    unsigned long pw_msb = pw_lsb +  pw_1;
+    for (i = 0; i <= w - (int)sizeof(long)/2; i += sizeof(long)/2) {
+        long a = *(long*)(src+i);
+        long b = *(long*)(dst+i);
+        *(long*)(dst+i) = ((a&pw_lsb) + (b&pw_lsb)) ^ ((a^b)&pw_msb);
     }
-    for (; i < w; i++)
-        dst[i + 0] += src[i + 0];
+    for(; i<w; i++)
+        dst[i] = (dst[i] + src[i]) & mask;
 }
 
-static void add_hfyu_median_pred_c(uint8_t *dst, const uint8_t *src1,
-                                   const uint8_t *diff, intptr_t w,
-                                   int *left, int *left_top)
-{
+static void add_hfyu_median_pred_int16_c(uint16_t *dst, const uint16_t *src, const uint16_t *diff, unsigned mask, int w, int *left, int *left_top){
     int i;
-    uint8_t l, lt;
+    uint16_t l, lt;
 
     l  = *left;
     lt = *left_top;
 
-    for (i = 0; i < w; i++) {
-        l      = mid_pred(l, src1[i], (l + src1[i] - lt) & 0xFF) + diff[i];
-        lt     = src1[i];
+    for(i=0; i<w; i++){
+        l  = (mid_pred(l, src[i], (l + src[i] - lt) & mask) + diff[i]) & mask;
+        lt = src[i];
         dst[i] = l;
     }
 
@@ -60,27 +56,6 @@ static void add_hfyu_median_pred_c(uint8_t *dst, const uint8_t *src1,
     *left_top = lt;
 }
 
-static int add_hfyu_left_pred_c(uint8_t *dst, const uint8_t *src, intptr_t w,
-                                int acc)
-{
-    int i;
-
-    for (i = 0; i < w - 1; i++) {
-        acc   += src[i];
-        dst[i] = acc;
-        i++;
-        acc   += src[i];
-        dst[i] = acc;
-    }
-
-    for (; i < w; i++) {
-        acc   += src[i];
-        dst[i] = acc;
-    }
-
-    return acc;
-}
-
 static void add_hfyu_left_pred_bgr32_c(uint8_t *dst, const uint8_t *src,
                                        intptr_t w, uint8_t *left)
 {
@@ -105,13 +80,12 @@ static void add_hfyu_left_pred_bgr32_c(uint8_t *dst, const uint8_t *src,
     left[A] = a;
 }
 
-av_cold void ff_huffyuvdsp_init(HuffYUVDSPContext *c)
+av_cold void ff_huffyuvdsp_init(HuffYUVDSPContext *c, enum AVPixelFormat pix_fmt)
 {
-    c->add_bytes                = add_bytes_c;
-    c->add_hfyu_median_pred     = add_hfyu_median_pred_c;
-    c->add_hfyu_left_pred       = add_hfyu_left_pred_c;
+    c->add_int16 = add_int16_c;
+    c->add_hfyu_median_pred_int16 = add_hfyu_median_pred_int16_c;
     c->add_hfyu_left_pred_bgr32 = add_hfyu_left_pred_bgr32_c;
 
     if (ARCH_X86)
-        ff_huffyuvdsp_init_x86(c);
+        ff_huffyuvdsp_init_x86(c, pix_fmt);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/huffyuvdsp.h b/mythtv/external/FFmpeg/libavcodec/huffyuvdsp.h
index db377289eef..e5f5b054667 100644
--- a/mythtv/external/FFmpeg/libavcodec/huffyuvdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/huffyuvdsp.h
@@ -20,6 +20,7 @@
 #define AVCODEC_HUFFYUVDSP_H
 
 #include <stdint.h>
+#include "libavutil/pixfmt.h"
 #include "config.h"
 
 #if HAVE_BIGENDIAN
@@ -35,19 +36,17 @@
 #endif
 
 typedef struct HuffYUVDSPContext {
-    void (*add_bytes)(uint8_t *dst /* align 16 */, uint8_t *src /* align 16 */,
-                      intptr_t w);
-    void (*add_hfyu_median_pred)(uint8_t *dst, const uint8_t *top,
-                                 const uint8_t *diff, intptr_t w,
-                                 int *left, int *left_top);
-    int (*add_hfyu_left_pred)(uint8_t *dst, const uint8_t *src,
-                              intptr_t w, int left);
+    void (*add_int16)(uint16_t *dst/*align 16*/, const uint16_t *src/*align 16*/,
+                      unsigned mask, int w);
+
+    void (*add_hfyu_median_pred_int16)(uint16_t *dst, const uint16_t *top,
+                                       const uint16_t *diff, unsigned mask,
+                                       int w, int *left, int *left_top);
     void (*add_hfyu_left_pred_bgr32)(uint8_t *dst, const uint8_t *src,
                                      intptr_t w, uint8_t *left);
 } HuffYUVDSPContext;
 
-void ff_huffyuvdsp_init(HuffYUVDSPContext *c);
-void ff_huffyuvdsp_init_ppc(HuffYUVDSPContext *c);
-void ff_huffyuvdsp_init_x86(HuffYUVDSPContext *c);
+void ff_huffyuvdsp_init(HuffYUVDSPContext *c, enum AVPixelFormat pix_fmt);
+void ff_huffyuvdsp_init_x86(HuffYUVDSPContext *c, enum AVPixelFormat pix_fmt);
 
 #endif /* AVCODEC_HUFFYUVDSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/huffyuvenc.c b/mythtv/external/FFmpeg/libavcodec/huffyuvenc.c
index 572de16a1f7..89639b75df0 100644
--- a/mythtv/external/FFmpeg/libavcodec/huffyuvenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/huffyuvenc.c
@@ -33,6 +33,7 @@
 #include "huffman.h"
 #include "huffyuvencdsp.h"
 #include "internal.h"
+#include "lossless_videoencdsp.h"
 #include "put_bits.h"
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
@@ -41,9 +42,9 @@ static inline void diff_bytes(HYuvContext *s, uint8_t *dst,
                               const uint8_t *src0, const uint8_t *src1, int w)
 {
     if (s->bps <= 8) {
-        s->hencdsp.diff_bytes(dst, src0, src1, w);
+        s->llvidencdsp.diff_bytes(dst, src0, src1, w);
     } else {
-        s->llviddsp.diff_int16((uint16_t *)dst, (const uint16_t *)src0, (const uint16_t *)src1, s->n - 1, w);
+        s->hencdsp.diff_int16((uint16_t *)dst, (const uint16_t *)src0, (const uint16_t *)src1, s->n - 1, w);
     }
 }
 
@@ -65,7 +66,7 @@ static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst,
                 dst[i] = temp - left;
                 left   = temp;
             }
-            s->hencdsp.diff_bytes(dst + 32, src + 32, src + 31, w - 32);
+            s->llvidencdsp.diff_bytes(dst + 32, src + 32, src + 31, w - 32);
             return src[w-1];
         }
     } else {
@@ -84,7 +85,7 @@ static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst,
                 dst16[i] = temp - left;
                 left   = temp;
             }
-            s->llviddsp.diff_int16(dst16 + 16, src16 + 16, src16 + 15, s->n - 1, w - 16);
+            s->hencdsp.diff_int16(dst16 + 16, src16 + 16, src16 + 15, s->n - 1, w - 16);
             return src16[w-1];
         }
     }
@@ -117,7 +118,7 @@ static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst,
         a = at;
     }
 
-    s->hencdsp.diff_bytes(dst + 16, src + 16, src + 12, w * 4 - 16);
+    s->llvidencdsp.diff_bytes(dst + 16, src + 16, src + 12, w * 4 - 16);
 
     *red   = src[(w - 1) * 4 + R];
     *green = src[(w - 1) * 4 + G];
@@ -146,7 +147,7 @@ static inline void sub_left_prediction_rgb24(HYuvContext *s, uint8_t *dst,
         b = bt;
     }
 
-    s->hencdsp.diff_bytes(dst + 48, src + 48, src + 48 - 3, w * 3 - 48);
+    s->llvidencdsp.diff_bytes(dst + 48, src + 48, src + 48 - 3, w * 3 - 48);
 
     *red   = src[(w - 1) * 3 + 0];
     *green = src[(w - 1) * 3 + 1];
@@ -156,9 +157,9 @@ static inline void sub_left_prediction_rgb24(HYuvContext *s, uint8_t *dst,
 static void sub_median_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w, int *left, int *left_top)
 {
     if (s->bps <= 8) {
-        s->hencdsp.sub_hfyu_median_pred(dst, src1, src2, w , left, left_top);
+        s->llvidencdsp.sub_median_pred(dst, src1, src2, w , left, left_top);
     } else {
-        s->llviddsp.sub_hfyu_median_pred_int16((uint16_t *)dst, (const uint16_t *)src1, (const uint16_t *)src2, s->n - 1, w , left, left_top);
+        s->hencdsp.sub_hfyu_median_pred_int16((uint16_t *)dst, (const uint16_t *)src1, (const uint16_t *)src2, s->n - 1, w , left, left_top);
     }
 }
 
@@ -217,7 +218,8 @@ static av_cold int encode_init(AVCodecContext *avctx)
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
 
     ff_huffyuv_common_init(avctx);
-    ff_huffyuvencdsp_init(&s->hencdsp);
+    ff_huffyuvencdsp_init(&s->hencdsp, avctx);
+    ff_llvidencdsp_init(&s->llvidencdsp);
 
     avctx->extradata = av_mallocz(3*MAX_N + 4);
     if (s->flags&AV_CODEC_FLAG_PASS1) {
@@ -823,9 +825,9 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
             lefttopy = p->data[0][3];
             lefttopu = p->data[1][1];
             lefttopv = p->data[2][1];
-            s->hencdsp.sub_hfyu_median_pred(s->temp[0], p->data[0] + 4, p->data[0] + fake_ystride + 4, width  - 4, &lefty, &lefttopy);
-            s->hencdsp.sub_hfyu_median_pred(s->temp[1], p->data[1] + 2, p->data[1] + fake_ustride + 2, width2 - 2, &leftu, &lefttopu);
-            s->hencdsp.sub_hfyu_median_pred(s->temp[2], p->data[2] + 2, p->data[2] + fake_vstride + 2, width2 - 2, &leftv, &lefttopv);
+            s->llvidencdsp.sub_median_pred(s->temp[0], p->data[0] + 4, p->data[0] + fake_ystride + 4, width  - 4, &lefty, &lefttopy);
+            s->llvidencdsp.sub_median_pred(s->temp[1], p->data[1] + 2, p->data[1] + fake_ustride + 2, width2 - 2, &leftu, &lefttopu);
+            s->llvidencdsp.sub_median_pred(s->temp[2], p->data[2] + 2, p->data[2] + fake_vstride + 2, width2 - 2, &leftv, &lefttopv);
             encode_422_bitstream(s, 0, width - 4);
             y++; cy++;
 
@@ -835,7 +837,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                 if (s->bitstream_bpp == 12) {
                     while (2 * cy > y) {
                         ydst = p->data[0] + p->linesize[0] * y;
-                        s->hencdsp.sub_hfyu_median_pred(s->temp[0], ydst - fake_ystride, ydst, width, &lefty, &lefttopy);
+                        s->llvidencdsp.sub_median_pred(s->temp[0], ydst - fake_ystride, ydst, width, &lefty, &lefttopy);
                         encode_gray_bitstream(s, width);
                         y++;
                     }
@@ -845,9 +847,9 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                 udst = p->data[1] + p->linesize[1] * cy;
                 vdst = p->data[2] + p->linesize[2] * cy;
 
-                s->hencdsp.sub_hfyu_median_pred(s->temp[0], ydst - fake_ystride, ydst, width,  &lefty, &lefttopy);
-                s->hencdsp.sub_hfyu_median_pred(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
-                s->hencdsp.sub_hfyu_median_pred(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
+                s->llvidencdsp.sub_median_pred(s->temp[0], ydst - fake_ystride, ydst, width,  &lefty, &lefttopy);
+                s->llvidencdsp.sub_median_pred(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
+                s->llvidencdsp.sub_median_pred(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
 
                 encode_422_bitstream(s, 0, width);
             }
@@ -860,7 +862,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                     ydst = p->data[0] + p->linesize[0] * y;
 
                     if (s->predictor == PLANE && s->interlaced < y) {
-                        s->hencdsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
+                        s->llvidencdsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
 
                         lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
                     } else {
@@ -876,9 +878,9 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                 vdst = p->data[2] + p->linesize[2] * cy;
 
                 if (s->predictor == PLANE && s->interlaced < cy) {
-                    s->hencdsp.diff_bytes(s->temp[1],          ydst, ydst - fake_ystride, width);
-                    s->hencdsp.diff_bytes(s->temp[2],          udst, udst - fake_ustride, width2);
-                    s->hencdsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
+                    s->llvidencdsp.diff_bytes(s->temp[1],          ydst, ydst - fake_ystride, width);
+                    s->llvidencdsp.diff_bytes(s->temp[2],          udst, udst - fake_ustride, width2);
+                    s->llvidencdsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
 
                     lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
                     leftu = sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
@@ -911,7 +913,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
         for (y = 1; y < s->height; y++) {
             uint8_t *dst = data + y*stride;
             if (s->predictor == PLANE && s->interlaced < y) {
-                s->hencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width * 4);
+                s->llvidencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width * 4);
                 sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width,
                                           &leftr, &leftg, &leftb, &lefta);
             } else {
@@ -939,7 +941,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
         for (y = 1; y < s->height; y++) {
             uint8_t *dst = data + y * stride;
             if (s->predictor == PLANE && s->interlaced < y) {
-                s->hencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride,
+                s->llvidencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride,
                                       width * 3);
                 sub_left_prediction_rgb24(s, s->temp[0], s->temp[1], width,
                                           &leftr, &leftg, &leftb);
diff --git a/mythtv/external/FFmpeg/libavcodec/huffyuvencdsp.c b/mythtv/external/FFmpeg/libavcodec/huffyuvencdsp.c
index fdcd0b06aa7..427d118be45 100644
--- a/mythtv/external/FFmpeg/libavcodec/huffyuvencdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/huffyuvencdsp.c
@@ -21,64 +21,58 @@
 #include "huffyuvencdsp.h"
 #include "mathops.h"
 
-// 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size
-#define pb_7f (~0UL / 255 * 0x7f)
-#define pb_80 (~0UL / 255 * 0x80)
+// 0x00010001 or 0x0001000100010001 or whatever, depending on the cpu's native arithmetic size
+#define pw_1 (ULONG_MAX / UINT16_MAX)
 
-static void diff_bytes_c(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, intptr_t w)
-{
+static void diff_int16_c(uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w){
     long i;
-
 #if !HAVE_FAST_UNALIGNED
-    if (((long)src1 | (long)src2) & (sizeof(long) - 1)) {
-        for (i = 0; i + 7 < w; i += 8) {
-            dst[i + 0] = src1[i + 0] - src2[i + 0];
-            dst[i + 1] = src1[i + 1] - src2[i + 1];
-            dst[i + 2] = src1[i + 2] - src2[i + 2];
-            dst[i + 3] = src1[i + 3] - src2[i + 3];
-            dst[i + 4] = src1[i + 4] - src2[i + 4];
-            dst[i + 5] = src1[i + 5] - src2[i + 5];
-            dst[i + 6] = src1[i + 6] - src2[i + 6];
-            dst[i + 7] = src1[i + 7] - src2[i + 7];
+    if((long)src2 & (sizeof(long)-1)){
+        for(i=0; i+3<w; i+=4){
+            dst[i+0] = (src1[i+0]-src2[i+0]) & mask;
+            dst[i+1] = (src1[i+1]-src2[i+1]) & mask;
+            dst[i+2] = (src1[i+2]-src2[i+2]) & mask;
+            dst[i+3] = (src1[i+3]-src2[i+3]) & mask;
         }
-    } else
+    }else
 #endif
-    for (i = 0; i <= w - (int) sizeof(long); i += sizeof(long)) {
-        long a = *(long *) (src1 + i);
-        long b = *(long *) (src2 + i);
-        *(long *) (dst + i) = ((a | pb_80) - (b & pb_7f)) ^
-                              ((a ^ b ^ pb_80) & pb_80);
+    {
+        unsigned long pw_lsb = (mask >> 1) * pw_1;
+        unsigned long pw_msb = pw_lsb +  pw_1;
+
+        for (i = 0; i <= w - (int)sizeof(long)/2; i += sizeof(long)/2) {
+            long a = *(long*)(src1+i);
+            long b = *(long*)(src2+i);
+            *(long*)(dst+i) = ((a|pw_msb) - (b&pw_lsb)) ^ ((a^b^pw_msb)&pw_msb);
+        }
     }
-    for (; i < w; i++)
-        dst[i + 0] = src1[i + 0] - src2[i + 0];
+    for (; i<w; i++)
+        dst[i] = (src1[i] - src2[i]) & mask;
 }
 
-static void sub_hfyu_median_pred_c(uint8_t *dst, const uint8_t *src1,
-                                   const uint8_t *src2, intptr_t w,
-                                   int *left, int *left_top)
-{
+static void sub_hfyu_median_pred_int16_c(uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w, int *left, int *left_top){
     int i;
-    uint8_t l, lt;
+    uint16_t l, lt;
 
     l  = *left;
     lt = *left_top;
 
-    for (i = 0; i < w; i++) {
-        const int pred = mid_pred(l, src1[i], (l + src1[i] - lt) & 0xFF);
-        lt     = src1[i];
-        l      = src2[i];
-        dst[i] = l - pred;
+    for(i=0; i<w; i++){
+        const int pred = mid_pred(l, src1[i], (l + src1[i] - lt) & mask);
+        lt = src1[i];
+        l  = src2[i];
+        dst[i] = (l - pred) & mask;
     }
 
     *left     = l;
     *left_top = lt;
 }
 
-av_cold void ff_huffyuvencdsp_init(HuffYUVEncDSPContext *c)
+av_cold void ff_huffyuvencdsp_init(HuffYUVEncDSPContext *c, AVCodecContext *avctx)
 {
-    c->diff_bytes           = diff_bytes_c;
-    c->sub_hfyu_median_pred = sub_hfyu_median_pred_c;
+    c->diff_int16           = diff_int16_c;
+    c->sub_hfyu_median_pred_int16 = sub_hfyu_median_pred_int16_c;
 
     if (ARCH_X86)
-        ff_huffyuvencdsp_init_x86(c);
+        ff_huffyuvencdsp_init_x86(c, avctx);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/huffyuvencdsp.h b/mythtv/external/FFmpeg/libavcodec/huffyuvencdsp.h
index 9d090953747..603f9c8c2c2 100644
--- a/mythtv/external/FFmpeg/libavcodec/huffyuvencdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/huffyuvencdsp.h
@@ -21,21 +21,20 @@
 
 #include <stdint.h>
 
+#include "avcodec.h"
+
 typedef struct HuffYUVEncDSPContext {
-    void (*diff_bytes)(uint8_t *dst /* align 16 */,
-                       const uint8_t *src1 /* align 16 */,
-                       const uint8_t *src2 /* align 1 */,
-                       intptr_t w);
-    /**
-     * Subtract HuffYUV's variant of median prediction.
-     * Note, this might read from src1[-1], src2[-1].
-     */
-    void (*sub_hfyu_median_pred)(uint8_t *dst, const uint8_t *src1,
-                                 const uint8_t *src2, intptr_t w,
-                                 int *left, int *left_top);
+    void (*diff_int16)(uint16_t *dst /* align 16 */,
+                       const uint16_t *src1 /* align 16 */,
+                       const uint16_t *src2 /* align 1 */,
+                       unsigned mask, int w);
+
+    void (*sub_hfyu_median_pred_int16)(uint16_t *dst, const uint16_t *src1,
+                                       const uint16_t *src2, unsigned mask,
+                                       int w, int *left, int *left_top);
 } HuffYUVEncDSPContext;
 
-void ff_huffyuvencdsp_init(HuffYUVEncDSPContext *c);
-void ff_huffyuvencdsp_init_x86(HuffYUVEncDSPContext *c);
+void ff_huffyuvencdsp_init(HuffYUVEncDSPContext *c, AVCodecContext *avctx);
+void ff_huffyuvencdsp_init_x86(HuffYUVEncDSPContext *c, AVCodecContext *avctx);
 
 #endif /* AVCODEC_HUFFYUVENCDSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/hwaccel.h b/mythtv/external/FFmpeg/libavcodec/hwaccel.h
new file mode 100644
index 00000000000..124fbbf1fdf
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/hwaccel.h
@@ -0,0 +1,24 @@
+/*
+ * 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_HWACCEL_H
+#define AVCODEC_HWACCEL_H
+
+#define HWACCEL_CAP_ASYNC_SAFE      (1 << 0)
+
+#endif /* AVCODEC_HWACCEL_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/idcinvideo.c b/mythtv/external/FFmpeg/libavcodec/idcinvideo.c
index 0870172794e..cff9ad31ac3 100644
--- a/mythtv/external/FFmpeg/libavcodec/idcinvideo.c
+++ b/mythtv/external/FFmpeg/libavcodec/idcinvideo.c
@@ -214,7 +214,8 @@ static int idcin_decode_frame(AVCodecContext *avctx,
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     IdcinContext *s = avctx->priv_data;
-    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
+    int pal_size;
+    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &pal_size);
     AVFrame *frame = data;
     int ret;
 
@@ -227,9 +228,11 @@ static int idcin_decode_frame(AVCodecContext *avctx,
     if (idcin_decode_vlcs(s, frame))
         return AVERROR_INVALIDDATA;
 
-    if (pal) {
+    if (pal && pal_size == AVPALETTE_SIZE) {
         frame->palette_has_changed = 1;
         memcpy(s->pal, pal, AVPALETTE_SIZE);
+    } else if (pal) {
+        av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", pal_size);
     }
     /* make the palette available on the way out */
     memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);
diff --git a/mythtv/external/FFmpeg/libavcodec/idctdsp.c b/mythtv/external/FFmpeg/libavcodec/idctdsp.c
index 63e9b5216b0..0122d29efa3 100644
--- a/mythtv/external/FFmpeg/libavcodec/idctdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/idctdsp.c
@@ -80,11 +80,8 @@ av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation,
     }
 }
 
-void (*ff_put_pixels_clamped)(const int16_t *block, uint8_t *pixels, ptrdiff_t line_size);
-void (*ff_add_pixels_clamped)(const int16_t *block, uint8_t *pixels, ptrdiff_t line_size);
-
-static void put_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
-                                 ptrdiff_t line_size)
+void ff_put_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
+                             ptrdiff_t line_size)
 {
     int i;
 
@@ -157,8 +154,8 @@ static void put_signed_pixels_clamped_c(const int16_t *block,
     }
 }
 
-static void add_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
-                                 ptrdiff_t line_size)
+void ff_add_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
+                             ptrdiff_t line_size)
 {
     int i;
 
@@ -207,33 +204,33 @@ static void add_pixels_clamped2_c(const int16_t *block, uint8_t *av_restrict pix
     }
 }
 
-static void ff_jref_idct4_put(uint8_t *dest, int line_size, int16_t *block)
+static void ff_jref_idct4_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     ff_j_rev_dct4 (block);
     put_pixels_clamped4_c(block, dest, line_size);
 }
-static void ff_jref_idct4_add(uint8_t *dest, int line_size, int16_t *block)
+static void ff_jref_idct4_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     ff_j_rev_dct4 (block);
     add_pixels_clamped4_c(block, dest, line_size);
 }
 
-static void ff_jref_idct2_put(uint8_t *dest, int line_size, int16_t *block)
+static void ff_jref_idct2_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     ff_j_rev_dct2 (block);
     put_pixels_clamped2_c(block, dest, line_size);
 }
-static void ff_jref_idct2_add(uint8_t *dest, int line_size, int16_t *block)
+static void ff_jref_idct2_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     ff_j_rev_dct2 (block);
     add_pixels_clamped2_c(block, dest, line_size);
 }
 
-static void ff_jref_idct1_put(uint8_t *dest, int line_size, int16_t *block)
+static void ff_jref_idct1_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     dest[0] = av_clip_uint8((block[0] + 4)>>3);
 }
-static void ff_jref_idct1_add(uint8_t *dest, int line_size, int16_t *block)
+static void ff_jref_idct1_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     dest[0] = av_clip_uint8(dest[0] + ((block[0] + 4)>>3));
 }
@@ -282,6 +279,7 @@ av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
                 c->perm_type = FF_IDCT_PERM_NONE;
 #endif /* CONFIG_FAANIDCT */
             } else { // accurate/default
+                /* Be sure FF_IDCT_NONE will select this one, since it uses FF_IDCT_PERM_NONE */
                 c->idct_put  = ff_simple_idct_put_8;
                 c->idct_add  = ff_simple_idct_add_8;
                 c->idct      = ff_simple_idct_8;
@@ -290,13 +288,15 @@ av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
         }
     }
 
-    c->put_pixels_clamped        = put_pixels_clamped_c;
+    c->put_pixels_clamped        = ff_put_pixels_clamped_c;
     c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
-    c->add_pixels_clamped        = add_pixels_clamped_c;
+    c->add_pixels_clamped        = ff_add_pixels_clamped_c;
 
     if (CONFIG_MPEG4_DECODER && avctx->idct_algo == FF_IDCT_XVID)
         ff_xvid_idct_init(c, avctx);
 
+    if (ARCH_AARCH64)
+        ff_idctdsp_init_aarch64(c, avctx, high_bit_depth);
     if (ARCH_ALPHA)
         ff_idctdsp_init_alpha(c, avctx, high_bit_depth);
     if (ARCH_ARM)
@@ -308,9 +308,6 @@ av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
     if (ARCH_MIPS)
         ff_idctdsp_init_mips(c, avctx, high_bit_depth);
 
-    ff_put_pixels_clamped = c->put_pixels_clamped;
-    ff_add_pixels_clamped = c->add_pixels_clamped;
-
     ff_init_scantable_permutation(c->idct_permutation,
                                   c->perm_type);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/idctdsp.h b/mythtv/external/FFmpeg/libavcodec/idctdsp.h
index b180a6762a7..26221f6a9de 100644
--- a/mythtv/external/FFmpeg/libavcodec/idctdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/idctdsp.h
@@ -21,6 +21,8 @@
 
 #include <stdint.h>
 
+#include "config.h"
+
 #include "avcodec.h"
 
 /**
@@ -51,13 +53,13 @@ int ff_init_scantable_permutation_x86(uint8_t *idct_permutation,
 typedef struct IDCTDSPContext {
     /* pixel ops : interface with DCT */
     void (*put_pixels_clamped)(const int16_t *block /* align 16 */,
-                               uint8_t *pixels /* align 8 */,
+                               uint8_t *av_restrict pixels /* align 8 */,
                                ptrdiff_t line_size);
     void (*put_signed_pixels_clamped)(const int16_t *block /* align 16 */,
-                                      uint8_t *pixels /* align 8 */,
+                                      uint8_t *av_restrict pixels /* align 8 */,
                                       ptrdiff_t line_size);
     void (*add_pixels_clamped)(const int16_t *block /* align 16 */,
-                               uint8_t *pixels /* align 8 */,
+                               uint8_t *av_restrict pixels /* align 8 */,
                                ptrdiff_t line_size);
 
     void (*idct)(int16_t *block /* align 16 */);
@@ -68,14 +70,14 @@ typedef struct IDCTDSPContext {
      * @param line_size size in bytes of a horizontal line of dest
      */
     void (*idct_put)(uint8_t *dest /* align 8 */,
-                     int line_size, int16_t *block /* align 16 */);
+                     ptrdiff_t line_size, int16_t *block /* align 16 */);
 
     /**
      * block -> idct -> add dest -> clip to unsigned 8 bit -> dest.
      * @param line_size size in bytes of a horizontal line of dest
      */
     void (*idct_add)(uint8_t *dest /* align 8 */,
-                     int line_size, int16_t *block /* align 16 */);
+                     ptrdiff_t line_size, int16_t *block /* align 16 */);
 
     /**
      * IDCT input permutation.
@@ -95,11 +97,15 @@ typedef struct IDCTDSPContext {
     enum idct_permutation_type perm_type;
 } IDCTDSPContext;
 
-extern void (*ff_put_pixels_clamped)(const int16_t *block, uint8_t *pixels, ptrdiff_t line_size);
-extern void (*ff_add_pixels_clamped)(const int16_t *block, uint8_t *pixels, ptrdiff_t line_size);
+void ff_put_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
+                             ptrdiff_t line_size);
+void ff_add_pixels_clamped_c(const int16_t *block, uint8_t *av_restrict pixels,
+                             ptrdiff_t line_size);
 
 void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx);
 
+void ff_idctdsp_init_aarch64(IDCTDSPContext *c, AVCodecContext *avctx,
+                             unsigned high_bit_depth);
 void ff_idctdsp_init_alpha(IDCTDSPContext *c, AVCodecContext *avctx,
                            unsigned high_bit_depth);
 void ff_idctdsp_init_arm(IDCTDSPContext *c, AVCodecContext *avctx,
diff --git a/mythtv/external/FFmpeg/libavcodec/iff.c b/mythtv/external/FFmpeg/libavcodec/iff.c
index c1c451cf6c4..33cf2e3a947 100644
--- a/mythtv/external/FFmpeg/libavcodec/iff.c
+++ b/mythtv/external/FFmpeg/libavcodec/iff.c
@@ -413,7 +413,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     if ((err = av_image_check_size(avctx->width, avctx->height, 0, avctx)))
         return err;
     s->planesize = FFALIGN(avctx->width, 16) >> 3; // Align plane size in bits to word-boundary
-    s->planebuf  = av_malloc(s->planesize + AV_INPUT_BUFFER_PADDING_SIZE);
+    s->planebuf  = av_malloc(s->planesize * avctx->height + AV_INPUT_BUFFER_PADDING_SIZE);
     if (!s->planebuf)
         return AVERROR(ENOMEM);
 
@@ -557,6 +557,76 @@ static int decode_byterun(uint8_t *dst, int dst_size,
     return bytestream2_tell(gb);
 }
 
+static int decode_byterun2(uint8_t *dst, int height, int line_size,
+                           GetByteContext *gb)
+{
+    GetByteContext cmds;
+    unsigned count;
+    int i, y_pos = 0, x_pos = 0;
+
+    if (bytestream2_get_be32(gb) != MKBETAG('V', 'D', 'A', 'T'))
+        return 0;
+
+    bytestream2_skip(gb, 4);
+    count = bytestream2_get_be16(gb) - 2;
+    if (bytestream2_get_bytes_left(gb) < count)
+        return 0;
+
+    bytestream2_init(&cmds, gb->buffer, count);
+    bytestream2_skip(gb, count);
+
+    for (i = 0; i < count && x_pos < line_size; i++) {
+        int8_t cmd = bytestream2_get_byte(&cmds);
+        int l, r;
+
+        if (cmd == 0) {
+            l = bytestream2_get_be16(gb);
+            while (l-- > 0 && x_pos < line_size) {
+                dst[x_pos + y_pos   * line_size    ] = bytestream2_get_byte(gb);
+                dst[x_pos + y_pos++ * line_size + 1] = bytestream2_get_byte(gb);
+                if (y_pos >= height) {
+                    y_pos  = 0;
+                    x_pos += 2;
+                }
+            }
+        } else if (cmd < 0) {
+            l = -cmd;
+            while (l-- > 0 && x_pos < line_size) {
+                dst[x_pos + y_pos   * line_size    ] = bytestream2_get_byte(gb);
+                dst[x_pos + y_pos++ * line_size + 1] = bytestream2_get_byte(gb);
+                if (y_pos >= height) {
+                    y_pos  = 0;
+                    x_pos += 2;
+                }
+            }
+        } else if (cmd == 1) {
+            l = bytestream2_get_be16(gb);
+            r = bytestream2_get_be16(gb);
+            while (l-- > 0 && x_pos < line_size) {
+                dst[x_pos + y_pos   * line_size    ] = r >> 8;
+                dst[x_pos + y_pos++ * line_size + 1] = r & 0xFF;
+                if (y_pos >= height) {
+                    y_pos  = 0;
+                    x_pos += 2;
+                }
+            }
+        } else {
+            l = cmd;
+            r = bytestream2_get_be16(gb);
+            while (l-- > 0 && x_pos < line_size) {
+                dst[x_pos + y_pos   * line_size    ] = r >> 8;
+                dst[x_pos + y_pos++ * line_size + 1] = r & 0xFF;
+                if (y_pos >= height) {
+                    y_pos  = 0;
+                    x_pos += 2;
+                }
+            }
+        }
+    }
+
+    return bytestream2_tell(gb);
+}
+
 #define DECODE_RGBX_COMMON(type) \
     if (!length) { \
         length = bytestream2_get_byte(gb); \
@@ -864,7 +934,7 @@ static void decode_delta_j(uint8_t *dst,
                 offset = bytestream2_get_be16(&gb);
 
                 if (cols * bpp == 0 || bytestream2_get_bytes_left(&gb) < cols * bpp) {
-                    av_log(NULL, AV_LOG_ERROR, "cols*bpp is invalid (%d*%d)", cols, bpp);
+                    av_log(NULL, AV_LOG_ERROR, "cols*bpp is invalid (%"PRId32"*%d)", cols, bpp);
                     return;
                 }
 
@@ -912,7 +982,7 @@ static void decode_delta_j(uint8_t *dst,
                         unsigned noffset = offset + (r * pitch) + d * planepitch;
 
                         if (!bytes || bytestream2_get_bytes_left(&gb) < bytes) {
-                            av_log(NULL, AV_LOG_ERROR, "bytes %d is invalid", bytes);
+                            av_log(NULL, AV_LOG_ERROR, "bytes %"PRId32" is invalid", bytes);
                             return;
                         }
 
@@ -1547,6 +1617,8 @@ static int decode_frame(AVCodecContext *avctx,
                 }
             } else
                 return unsupported(avctx);
+        } else {
+            return unsupported(avctx);
         }
         break;
     case 0x1:
@@ -1621,6 +1693,47 @@ static int decode_frame(AVCodecContext *avctx,
                 decode_deep_rle32(frame->data[0], buf, buf_size, avctx->width, avctx->height, frame->linesize[0]);
             else
                 return unsupported(avctx);
+        } else if (avctx->codec_tag == MKTAG('A', 'C', 'B', 'M')) {
+            if (avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
+                memset(frame->data[0], 0, avctx->height * frame->linesize[0]);
+                for (plane = 0; plane < s->bpp; plane++) {
+                    for (y = 0; y < avctx->height && buf < buf_end; y++) {
+                        uint8_t *row = &frame->data[0][y * frame->linesize[0]];
+                        decodeplane8(row, buf, FFMIN(s->planesize, buf_end - buf), plane);
+                        buf += s->planesize;
+                    }
+                }
+            } else if (s->ham) { // HAM to AV_PIX_FMT_BGR32
+                memset(frame->data[0], 0, avctx->height * frame->linesize[0]);
+                for (y = 0; y < avctx->height; y++) {
+                    uint8_t *row = &frame->data[0][y * frame->linesize[0]];
+                    memset(s->ham_buf, 0, s->planesize * 8);
+                    for (plane = 0; plane < s->bpp; plane++) {
+                        const uint8_t * start = buf + (plane * avctx->height + y) * s->planesize;
+                        if (start >= buf_end)
+                            break;
+                        decodeplane8(s->ham_buf, start, FFMIN(s->planesize, buf_end - start), plane);
+                    }
+                    decode_ham_plane32((uint32_t *)row, s->ham_buf, s->ham_palbuf, s->planesize);
+                }
+            } else {
+                return unsupported(avctx);
+            }
+        } else {
+            return unsupported(avctx);
+        }
+        break;
+    case 0x2:
+        if (avctx->codec_tag == MKTAG('I', 'L', 'B', 'M') && avctx->pix_fmt == AV_PIX_FMT_PAL8) {
+            for (plane = 0; plane < s->bpp; plane++) {
+                decode_byterun2(s->planebuf, avctx->height, s->planesize, gb);
+                for (y = 0; y < avctx->height; y++) {
+                    uint8_t *row = &frame->data[0][y * frame->linesize[0]];
+                    decodeplane8(row, s->planebuf + s->planesize * y, s->planesize, plane);
+                }
+            }
+        } else {
+            return unsupported(avctx);
         }
         break;
     case 0x4:
@@ -1765,6 +1878,7 @@ AVCodec ff_iff_ilbm_decoder = {
     .init           = decode_init,
     .close          = decode_end,
     .decode         = decode_frame,
+    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
     .capabilities   = AV_CODEC_CAP_DR1,
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/iirfilter.c b/mythtv/external/FFmpeg/libavcodec/iirfilter.c
index a8c9b9b826e..b2025158278 100644
--- a/mythtv/external/FFmpeg/libavcodec/iirfilter.c
+++ b/mythtv/external/FFmpeg/libavcodec/iirfilter.c
@@ -278,7 +278,8 @@ av_cold struct FFIIRFilterState *ff_iir_filter_init_state(int order)
 
 void ff_iir_filter(const struct FFIIRFilterCoeffs *c,
                    struct FFIIRFilterState *s, int size,
-                   const int16_t *src, int sstep, int16_t *dst, int dstep)
+                   const int16_t *src, ptrdiff_t sstep,
+                   int16_t *dst, ptrdiff_t dstep)
 {
     if (c->order == 2) {
         FILTER_O2(int16_t, S16)
@@ -291,7 +292,8 @@ void ff_iir_filter(const struct FFIIRFilterCoeffs *c,
 
 void ff_iir_filter_flt(const struct FFIIRFilterCoeffs *c,
                        struct FFIIRFilterState *s, int size,
-                       const float *src, int sstep, float *dst, int dstep)
+                       const float *src, ptrdiff_t sstep,
+                       float *dst, ptrdiff_t dstep)
 {
     if (c->order == 2) {
         FILTER_O2(float, FLT)
diff --git a/mythtv/external/FFmpeg/libavcodec/iirfilter.h b/mythtv/external/FFmpeg/libavcodec/iirfilter.h
index 6f7bba67ac3..5ffa1ce53ab 100644
--- a/mythtv/external/FFmpeg/libavcodec/iirfilter.h
+++ b/mythtv/external/FFmpeg/libavcodec/iirfilter.h
@@ -27,7 +27,8 @@
 #ifndef AVCODEC_IIRFILTER_H
 #define AVCODEC_IIRFILTER_H
 
-#include "avcodec.h"
+#include <stddef.h>
+#include <stdint.h>
 
 struct FFIIRFilterCoeffs;
 struct FFIIRFilterState;
@@ -61,7 +62,7 @@ typedef struct FFIIRFilterContext {
     */
     void (*filter_flt)(const struct FFIIRFilterCoeffs *coeffs,
                         struct FFIIRFilterState *state, int size,
-                        const float *src, int sstep, float *dst, int dstep);
+                        const float *src, ptrdiff_t sstep, float *dst, ptrdiff_t dstep);
 } FFIIRFilterContext;
 
 /**
@@ -125,7 +126,7 @@ void ff_iir_filter_free_statep(struct FFIIRFilterState **state);
  * @param dstep  destination stride
  */
 void ff_iir_filter(const struct FFIIRFilterCoeffs *coeffs, struct FFIIRFilterState *state,
-                   int size, const int16_t *src, int sstep, int16_t *dst, int dstep);
+                   int size, const int16_t *src, ptrdiff_t sstep, int16_t *dst, ptrdiff_t dstep);
 
 /**
  * Perform IIR filtering on floating-point input samples.
@@ -140,6 +141,7 @@ void ff_iir_filter(const struct FFIIRFilterCoeffs *coeffs, struct FFIIRFilterSta
  */
 void ff_iir_filter_flt(const struct FFIIRFilterCoeffs *coeffs,
                        struct FFIIRFilterState *state, int size,
-                       const float *src, int sstep, float *dst, int dstep);
+                       const float *src, ptrdiff_t sstep,
+                       float *dst, ptrdiff_t dstep);
 
 #endif /* AVCODEC_IIRFILTER_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/imc.c b/mythtv/external/FFmpeg/libavcodec/imc.c
index ac209206d11..7cd6db930b3 100644
--- a/mythtv/external/FFmpeg/libavcodec/imc.c
+++ b/mythtv/external/FFmpeg/libavcodec/imc.c
@@ -828,7 +828,7 @@ static void imc_refine_bit_allocation(IMCContext *q, IMCChannel *chctx)
         for (j = band_tab[i]; j < band_tab[i + 1]; j++)
             chctx->sumLenArr[i] += chctx->CWlengthT[j];
         if (chctx->bandFlagsBuf[i])
-            if ((((band_tab[i + 1] - band_tab[i]) * 1.5) > chctx->sumLenArr[i]) && (chctx->sumLenArr[i] > 0))
+            if (((int)((band_tab[i + 1] - band_tab[i]) * 1.5) > chctx->sumLenArr[i]) && (chctx->sumLenArr[i] > 0))
                 chctx->skipFlagRaw[i] = 1;
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/imdct15.c b/mythtv/external/FFmpeg/libavcodec/imdct15.c
deleted file mode 100644
index e91aa110852..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/imdct15.c
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- * Copyright (c) 2013-2014 Mozilla Corporation
- *
- * 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
- * Celt non-power of 2 iMDCT
- */
-
-#include <float.h>
-#include <math.h>
-#include <stddef.h>
-
-#include "config.h"
-
-#include "libavutil/attributes.h"
-#include "libavutil/common.h"
-
-#include "avfft.h"
-#include "imdct15.h"
-#include "opus.h"
-
-// minimal iMDCT size to make SIMD opts easier
-#define CELT_MIN_IMDCT_SIZE 120
-
-// complex c = a * b
-#define CMUL3(cre, cim, are, aim, bre, bim)          \
-do {                                                 \
-    cre = are * bre - aim * bim;                     \
-    cim = are * bim + aim * bre;                     \
-} while (0)
-
-#define CMUL(c, a, b) CMUL3((c).re, (c).im, (a).re, (a).im, (b).re, (b).im)
-
-// complex c = a * b
-//         d = a * conjugate(b)
-#define CMUL2(c, d, a, b)                            \
-do {                                                 \
-    float are = (a).re;                              \
-    float aim = (a).im;                              \
-    float bre = (b).re;                              \
-    float bim = (b).im;                              \
-    float rr  = are * bre;                           \
-    float ri  = are * bim;                           \
-    float ir  = aim * bre;                           \
-    float ii  = aim * bim;                           \
-    (c).re =  rr - ii;                               \
-    (c).im =  ri + ir;                               \
-    (d).re =  rr + ii;                               \
-    (d).im = -ri + ir;                               \
-} while (0)
-
-av_cold void ff_imdct15_uninit(IMDCT15Context **ps)
-{
-    IMDCT15Context *s = *ps;
-    int i;
-
-    if (!s)
-        return;
-
-    for (i = 0; i < FF_ARRAY_ELEMS(s->exptab); i++)
-        av_freep(&s->exptab[i]);
-
-    av_freep(&s->twiddle_exptab);
-
-    av_freep(&s->tmp);
-
-    av_freep(ps);
-}
-
-static void imdct15_half(IMDCT15Context *s, float *dst, const float *src,
-                         ptrdiff_t stride, float scale);
-
-av_cold int ff_imdct15_init(IMDCT15Context **ps, int N)
-{
-    IMDCT15Context *s;
-    int len2 = 15 * (1 << N);
-    int len  = 2 * len2;
-    int i, j;
-
-    if (len2 > CELT_MAX_FRAME_SIZE || len2 < CELT_MIN_IMDCT_SIZE)
-        return AVERROR(EINVAL);
-
-    s = av_mallocz(sizeof(*s));
-    if (!s)
-        return AVERROR(ENOMEM);
-
-    s->fft_n = N - 1;
-    s->len4 = len2 / 2;
-    s->len2 = len2;
-
-    s->tmp  = av_malloc_array(len, 2 * sizeof(*s->tmp));
-    if (!s->tmp)
-        goto fail;
-
-    s->twiddle_exptab  = av_malloc_array(s->len4, sizeof(*s->twiddle_exptab));
-    if (!s->twiddle_exptab)
-        goto fail;
-
-    for (i = 0; i < s->len4; i++) {
-        s->twiddle_exptab[i].re = cos(2 * M_PI * (i + 0.125 + s->len4) / len);
-        s->twiddle_exptab[i].im = sin(2 * M_PI * (i + 0.125 + s->len4) / len);
-    }
-
-    for (i = 0; i < FF_ARRAY_ELEMS(s->exptab); i++) {
-        int N = 15 * (1 << i);
-        s->exptab[i] = av_malloc(sizeof(*s->exptab[i]) * FFMAX(N, 19));
-        if (!s->exptab[i])
-            goto fail;
-
-        for (j = 0; j < N; j++) {
-            s->exptab[i][j].re = cos(2 * M_PI * j / N);
-            s->exptab[i][j].im = sin(2 * M_PI * j / N);
-        }
-    }
-
-    // wrap around to simplify fft15
-    for (j = 15; j < 19; j++)
-        s->exptab[0][j] = s->exptab[0][j - 15];
-
-    s->imdct_half = imdct15_half;
-
-    if (ARCH_AARCH64)
-        ff_imdct15_init_aarch64(s);
-
-    *ps = s;
-
-    return 0;
-
-fail:
-    ff_imdct15_uninit(&s);
-    return AVERROR(ENOMEM);
-}
-
-static void fft5(FFTComplex *out, const FFTComplex *in, ptrdiff_t stride)
-{
-    // [0] = exp(2 * i * pi / 5), [1] = exp(2 * i * pi * 2 / 5)
-    static const FFTComplex fact[] = { { 0.30901699437494745,  0.95105651629515353 },
-                                       { -0.80901699437494734, 0.58778525229247325 } };
-
-    FFTComplex z[4][4];
-
-    CMUL2(z[0][0], z[0][3], in[1 * stride], fact[0]);
-    CMUL2(z[0][1], z[0][2], in[1 * stride], fact[1]);
-    CMUL2(z[1][0], z[1][3], in[2 * stride], fact[0]);
-    CMUL2(z[1][1], z[1][2], in[2 * stride], fact[1]);
-    CMUL2(z[2][0], z[2][3], in[3 * stride], fact[0]);
-    CMUL2(z[2][1], z[2][2], in[3 * stride], fact[1]);
-    CMUL2(z[3][0], z[3][3], in[4 * stride], fact[0]);
-    CMUL2(z[3][1], z[3][2], in[4 * stride], fact[1]);
-
-    out[0].re = in[0].re + in[stride].re + in[2 * stride].re + in[3 * stride].re + in[4 * stride].re;
-    out[0].im = in[0].im + in[stride].im + in[2 * stride].im + in[3 * stride].im + in[4 * stride].im;
-
-    out[1].re = in[0].re + z[0][0].re + z[1][1].re + z[2][2].re + z[3][3].re;
-    out[1].im = in[0].im + z[0][0].im + z[1][1].im + z[2][2].im + z[3][3].im;
-
-    out[2].re = in[0].re + z[0][1].re + z[1][3].re + z[2][0].re + z[3][2].re;
-    out[2].im = in[0].im + z[0][1].im + z[1][3].im + z[2][0].im + z[3][2].im;
-
-    out[3].re = in[0].re + z[0][2].re + z[1][0].re + z[2][3].re + z[3][1].re;
-    out[3].im = in[0].im + z[0][2].im + z[1][0].im + z[2][3].im + z[3][1].im;
-
-    out[4].re = in[0].re + z[0][3].re + z[1][2].re + z[2][1].re + z[3][0].re;
-    out[4].im = in[0].im + z[0][3].im + z[1][2].im + z[2][1].im + z[3][0].im;
-}
-
-static void fft15(IMDCT15Context *s, FFTComplex *out, const FFTComplex *in,
-                  ptrdiff_t stride)
-{
-    const FFTComplex *exptab = s->exptab[0];
-    FFTComplex tmp[5];
-    FFTComplex tmp1[5];
-    FFTComplex tmp2[5];
-    int k;
-
-    fft5(tmp,  in,              stride * 3);
-    fft5(tmp1, in +     stride, stride * 3);
-    fft5(tmp2, in + 2 * stride, stride * 3);
-
-    for (k = 0; k < 5; k++) {
-        FFTComplex t1, t2;
-
-        CMUL(t1, tmp1[k], exptab[k]);
-        CMUL(t2, tmp2[k], exptab[2 * k]);
-        out[k].re = tmp[k].re + t1.re + t2.re;
-        out[k].im = tmp[k].im + t1.im + t2.im;
-
-        CMUL(t1, tmp1[k], exptab[k + 5]);
-        CMUL(t2, tmp2[k], exptab[2 * (k + 5)]);
-        out[k + 5].re = tmp[k].re + t1.re + t2.re;
-        out[k + 5].im = tmp[k].im + t1.im + t2.im;
-
-        CMUL(t1, tmp1[k], exptab[k + 10]);
-        CMUL(t2, tmp2[k], exptab[2 * k + 5]);
-        out[k + 10].re = tmp[k].re + t1.re + t2.re;
-        out[k + 10].im = tmp[k].im + t1.im + t2.im;
-    }
-}
-
-/*
- * FFT of the length 15 * (2^N)
- */
-static void fft_calc(IMDCT15Context *s, FFTComplex *out, const FFTComplex *in,
-                     int N, ptrdiff_t stride)
-{
-    if (N) {
-        const FFTComplex *exptab = s->exptab[N];
-        const int len2 = 15 * (1 << (N - 1));
-        int k;
-
-        fft_calc(s, out,        in,          N - 1, stride * 2);
-        fft_calc(s, out + len2, in + stride, N - 1, stride * 2);
-
-        for (k = 0; k < len2; k++) {
-            FFTComplex t;
-
-            CMUL(t, out[len2 + k], exptab[k]);
-
-            out[len2 + k].re = out[k].re - t.re;
-            out[len2 + k].im = out[k].im - t.im;
-
-            out[k].re += t.re;
-            out[k].im += t.im;
-        }
-    } else
-        fft15(s, out, in, stride);
-}
-
-static void imdct15_half(IMDCT15Context *s, float *dst, const float *src,
-                         ptrdiff_t stride, float scale)
-{
-    FFTComplex *z = (FFTComplex *)dst;
-    const int len8 = s->len4 / 2;
-    const float *in1 = src;
-    const float *in2 = src + (s->len2 - 1) * stride;
-    int i;
-
-    for (i = 0; i < s->len4; i++) {
-        FFTComplex tmp = { *in2, *in1 };
-        CMUL(s->tmp[i], tmp, s->twiddle_exptab[i]);
-        in1 += 2 * stride;
-        in2 -= 2 * stride;
-    }
-
-    fft_calc(s, z, s->tmp, s->fft_n, 1);
-
-    for (i = 0; i < len8; i++) {
-        float r0, i0, r1, i1;
-
-        CMUL3(r0, i1, z[len8 - i - 1].im, z[len8 - i - 1].re,  s->twiddle_exptab[len8 - i - 1].im, s->twiddle_exptab[len8 - i - 1].re);
-        CMUL3(r1, i0, z[len8 + i].im,     z[len8 + i].re,      s->twiddle_exptab[len8 + i].im,     s->twiddle_exptab[len8 + i].re);
-        z[len8 - i - 1].re = scale * r0;
-        z[len8 - i - 1].im = scale * i0;
-        z[len8 + i].re     = scale * r1;
-        z[len8 + i].im     = scale * i1;
-    }
-}
diff --git a/mythtv/external/FFmpeg/libavcodec/indeo2.c b/mythtv/external/FFmpeg/libavcodec/indeo2.c
index c89845233e8..4971b84308f 100644
--- a/mythtv/external/FFmpeg/libavcodec/indeo2.c
+++ b/mythtv/external/FFmpeg/libavcodec/indeo2.c
@@ -69,6 +69,8 @@ static int ir2_decode_plane(Ir2Context *ctx, int width, int height, uint8_t *dst
             for (i = 0; i < c * 2; i++)
                 dst[out++] = 0x80;
         } else { /* copy two values from table */
+            if (c <= 0)
+                return AVERROR_INVALIDDATA;
             dst[out++] = table[c * 2];
             dst[out++] = table[(c * 2) + 1];
         }
@@ -77,6 +79,8 @@ static int ir2_decode_plane(Ir2Context *ctx, int width, int height, uint8_t *dst
 
     for (j = 1; j < height; j++) {
         out = 0;
+        if (get_bits_left(&ctx->gb) <= 0)
+            return AVERROR_INVALIDDATA;
         while (out < width) {
             int c = ir2_get_code(&ctx->gb);
             if (c >= 0x80) { /* we have a skip */
@@ -88,7 +92,10 @@ static int ir2_decode_plane(Ir2Context *ctx, int width, int height, uint8_t *dst
                     out++;
                 }
             } else { /* add two deltas from table */
-                int t    = dst[out - pitch] + (table[c * 2] - 128);
+                int t;
+                if (c <= 0)
+                    return AVERROR_INVALIDDATA;
+                t        = dst[out - pitch] + (table[c * 2] - 128);
                 t        = av_clip_uint8(t);
                 dst[out] = t;
                 out++;
@@ -116,12 +123,16 @@ static int ir2_decode_plane_inter(Ir2Context *ctx, int width, int height, uint8_
 
     for (j = 0; j < height; j++) {
         out = 0;
+        if (get_bits_left(&ctx->gb) <= 0)
+            return AVERROR_INVALIDDATA;
         while (out < width) {
             c = ir2_get_code(&ctx->gb);
             if (c >= 0x80) { /* we have a skip */
                 c   -= 0x7F;
                 out += c * 2;
             } else { /* add two deltas from table */
+                if (c <= 0)
+                    return AVERROR_INVALIDDATA;
                 t        = dst[out] + (((table[c * 2] - 128)*3) >> 2);
                 t        = av_clip_uint8(t);
                 dst[out] = t;
diff --git a/mythtv/external/FFmpeg/libavcodec/indeo3.c b/mythtv/external/FFmpeg/libavcodec/indeo3.c
index e161f83f91f..71d478c9fc5 100644
--- a/mythtv/external/FFmpeg/libavcodec/indeo3.c
+++ b/mythtv/external/FFmpeg/libavcodec/indeo3.c
@@ -66,7 +66,7 @@ typedef struct Plane {
     uint8_t         *pixels[2]; ///< pointer to the actual pixel data of the buffers above
     uint32_t        width;
     uint32_t        height;
-    uint32_t        pitch;
+    ptrdiff_t       pitch;
 } Plane;
 
 #define CELL_STACK_MAX  20
@@ -166,7 +166,8 @@ static av_cold int allocate_frame_buffers(Indeo3DecodeContext *ctx,
                                           AVCodecContext *avctx, int luma_width, int luma_height)
 {
     int p, chroma_width, chroma_height;
-    int luma_pitch, chroma_pitch, luma_size, chroma_size;
+    int luma_size, chroma_size;
+    ptrdiff_t luma_pitch, chroma_pitch;
 
     if (luma_width  < 16 || luma_width  > 640 ||
         luma_height < 16 || luma_height > 480 ||
@@ -425,7 +426,7 @@ if (*data_ptr >= last_ptr) \
 
 static int decode_cell_data(Indeo3DecodeContext *ctx, Cell *cell,
                             uint8_t *block, uint8_t *ref_block,
-                            int pitch, int h_zoom, int v_zoom, int mode,
+                            ptrdiff_t row_offset, int h_zoom, int v_zoom, int mode,
                             const vqEntry *delta[2], int swap_quads[2],
                             const uint8_t **data_ptr, const uint8_t *last_ptr)
 {
@@ -436,9 +437,8 @@ static int decode_cell_data(Indeo3DecodeContext *ctx, Cell *cell,
     unsigned int  dyad1, dyad2;
     uint64_t      pix64;
     int           skip_flag = 0, is_top_of_cell, is_first_row = 1;
-    int           row_offset, blk_row_offset, line_offset;
+    int           blk_row_offset, line_offset;
 
-    row_offset     =  pitch;
     blk_row_offset = (row_offset << (2 + v_zoom)) - (cell->width << 2);
     line_offset    = v_zoom ? row_offset : 0;
 
@@ -1025,11 +1025,11 @@ static int decode_frame_headers(Indeo3DecodeContext *ctx, AVCodecContext *avctx,
  *  @param[in]  dst_height   output plane height
  */
 static void output_plane(const Plane *plane, int buf_sel, uint8_t *dst,
-                         int dst_pitch, int dst_height)
+                         ptrdiff_t dst_pitch, int dst_height)
 {
     int             x,y;
     const uint8_t   *src  = plane->pixels[buf_sel];
-    uint32_t        pitch = plane->pitch;
+    ptrdiff_t       pitch = plane->pitch;
 
     dst_height = FFMIN(dst_height, plane->height);
     for (y = 0; y < dst_height; y++) {
diff --git a/mythtv/external/FFmpeg/libavcodec/indeo4.c b/mythtv/external/FFmpeg/libavcodec/indeo4.c
index 594c56d163c..a3562f6fd8f 100644
--- a/mythtv/external/FFmpeg/libavcodec/indeo4.c
+++ b/mythtv/external/FFmpeg/libavcodec/indeo4.c
@@ -187,7 +187,7 @@ static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)
 
     /* check if picture layout was changed and reallocate buffers */
     if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf)) {
-        if (ff_ivi_init_planes(ctx->planes, &pic_conf, 1)) {
+        if (ff_ivi_init_planes(avctx, ctx->planes, &pic_conf, 1)) {
             av_log(avctx, AV_LOG_ERROR, "Couldn't reallocate color planes!\n");
             ctx->pic_conf.luma_bands = 0;
             return AVERROR(ENOMEM);
@@ -237,6 +237,8 @@ static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)
     /* skip picture header extension if any */
     while (get_bits1(&ctx->gb)) {
         ff_dlog(avctx, "Pic hdr extension encountered!\n");
+        if (get_bits_left(&ctx->gb) < 10)
+            return AVERROR_INVALIDDATA;
         skip_bits(&ctx->gb, 8);
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/indeo5.c b/mythtv/external/FFmpeg/libavcodec/indeo5.c
index 5f931c8b985..81b4514038a 100644
--- a/mythtv/external/FFmpeg/libavcodec/indeo5.c
+++ b/mythtv/external/FFmpeg/libavcodec/indeo5.c
@@ -113,7 +113,7 @@ static int decode_gop_header(IVI45DecContext *ctx, AVCodecContext *avctx)
 
     /* check if picture layout was changed and reallocate buffers */
     if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf) || ctx->gop_invalid) {
-        result = ff_ivi_init_planes(ctx->planes, &pic_conf, 0);
+        result = ff_ivi_init_planes(avctx, ctx->planes, &pic_conf, 0);
         if (result < 0) {
             av_log(avctx, AV_LOG_ERROR, "Couldn't reallocate color planes!\n");
             return result;
@@ -657,7 +657,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     ctx->pic_conf.tile_height   = avctx->height;
     ctx->pic_conf.luma_bands    = ctx->pic_conf.chroma_bands = 1;
 
-    result = ff_ivi_init_planes(ctx->planes, &ctx->pic_conf, 0);
+    result = ff_ivi_init_planes(avctx, ctx->planes, &ctx->pic_conf, 0);
     if (result) {
         av_log(avctx, AV_LOG_ERROR, "Couldn't allocate color planes!\n");
         return AVERROR_INVALIDDATA;
diff --git a/mythtv/external/FFmpeg/libavcodec/intelh263dec.c b/mythtv/external/FFmpeg/libavcodec/intelh263dec.c
index ebf42c63eef..d321dd4dba5 100644
--- a/mythtv/external/FFmpeg/libavcodec/intelh263dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/intelh263dec.c
@@ -138,6 +138,7 @@ AVCodec ff_h263i_decoder = {
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .pix_fmts       = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_YUV420P,
         AV_PIX_FMT_NONE
diff --git a/mythtv/external/FFmpeg/libavcodec/internal.h b/mythtv/external/FFmpeg/libavcodec/internal.h
index dfc3f8de92d..a410c3114bf 100644
--- a/mythtv/external/FFmpeg/libavcodec/internal.h
+++ b/mythtv/external/FFmpeg/libavcodec/internal.h
@@ -48,8 +48,8 @@
 #define FF_CODEC_CAP_INIT_CLEANUP           (1 << 1)
 /**
  * Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set
- * AVFrame.pkt_dts manually. If the flag is set, utils.c won't overwrite
- * this field. If it's unset, utils.c tries to guess the pkt_dts field
+ * AVFrame.pkt_dts manually. If the flag is set, decode.c won't overwrite
+ * this field. If it's unset, decode.c tries to guess the pkt_dts field
  * from the input AVPacket.
  */
 #define FF_CODEC_CAP_SETS_PKT_DTS           (1 << 2)
@@ -58,6 +58,16 @@
  * skipped due to the skip_frame setting.
  */
 #define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM  (1 << 3)
+/**
+ * The decoder sets the cropping fields in the output frames manually.
+ * If this cap is set, the generic code will initialize output frame
+ * dimensions to coded rather than display values.
+ */
+#define FF_CODEC_CAP_EXPORTS_CROPPING       (1 << 4)
+/**
+ * Codec initializes slice-based threading with a main function
+ */
+#define FF_CODEC_CAP_SLICE_THREAD_HAS_MF    (1 << 5)
 
 #ifdef TRACE
 #   define ff_tlog(ctx, ...) av_log(ctx, AV_LOG_TRACE, __VA_ARGS__)
@@ -70,11 +80,18 @@
 #define FF_DEFAULT_QUANT_BIAS 999999
 #endif
 
+#if !FF_API_QSCALE_TYPE
+#define FF_QSCALE_TYPE_MPEG1 0
+#define FF_QSCALE_TYPE_MPEG2 1
+#define FF_QSCALE_TYPE_H264  2
+#define FF_QSCALE_TYPE_VP56  3
+#endif
+
 #define FF_SANE_NB_CHANNELS 64U
 
 #define FF_SIGNBIT(x) ((x) >> CHAR_BIT * sizeof(x) - 1)
 
-#if HAVE_AVX
+#if HAVE_SIMD_ALIGN_32
 #   define STRIDE_ALIGN 32
 #elif HAVE_SIMD_ALIGN_16
 #   define STRIDE_ALIGN 16
@@ -101,6 +118,16 @@ typedef struct FramePool {
     int samples;
 } FramePool;
 
+typedef struct DecodeSimpleContext {
+    AVPacket *in_pkt;
+    AVFrame  *out_frame;
+} DecodeSimpleContext;
+
+typedef struct DecodeFilterContext {
+    AVBSFContext **bsfs;
+    int         nb_bsfs;
+} DecodeFilterContext;
+
 typedef struct AVCodecInternal {
     /**
      * Whether the parent AVCodecContext is a copy of the context which had
@@ -137,11 +164,14 @@ typedef struct AVCodecInternal {
 
     void *thread_ctx;
 
+    DecodeSimpleContext ds;
+    DecodeFilterContext filter;
+
     /**
-     * Current packet as passed into the decoder, to avoid having to pass the
-     * packet into every function.
+     * Properties (timestamps+side data) extracted from the last packet passed
+     * for decoding.
      */
-    AVPacket *pkt;
+    AVPacket *last_pkt_props;
 
     /**
      * temporary buffer used for encoders to store their bitstream
@@ -173,7 +203,23 @@ typedef struct AVCodecInternal {
     int buffer_pkt_valid; // encoding: packet without data can be valid
     AVFrame *buffer_frame;
     int draining_done;
+    /* set to 1 when the caller is using the old decoding API */
+    int compat_decode;
+    int compat_decode_warned;
+    /* this variable is set by the decoder internals to signal to the old
+     * API compat wrappers the amount of data consumed from the last packet */
+    size_t compat_decode_consumed;
+    /* when a partial packet has been consumed, this stores the remaining size
+     * of the packet (that should be submitted in the next decode call */
+    size_t compat_decode_partial_size;
+    AVFrame *compat_decode_frame;
+
     int showed_multi_packet_warning;
+
+    int skip_samples_multiplier;
+
+    /* to prevent infinite loop on errors when draining */
+    int nb_draining_errors;
 } AVCodecInternal;
 
 struct AVCodecDefault {
@@ -270,7 +316,7 @@ static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx,
 static av_always_inline float ff_exp2fi(int x) {
     /* Normal range */
     if (-126 <= x && x <= 128)
-        return av_int2float(x+127 << 23);
+        return av_int2float((x+127) << 23);
     /* Too large */
     else if (x > 128)
         return INFINITY;
@@ -335,6 +381,10 @@ int ff_set_sar(AVCodecContext *avctx, AVRational sar);
 int ff_side_data_update_matrix_encoding(AVFrame *frame,
                                         enum AVMatrixEncoding matrix_encoding);
 
+#if FF_API_MERGE_SD
+int ff_packet_split_and_drop_side_data(AVPacket *pkt);
+#endif
+
 /**
  * Select the (possibly hardware accelerated) pixel format.
  * This is a wrapper around AVCodecContext.get_format() and should be used
@@ -369,4 +419,10 @@ int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, i
 int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len,
                      void **data, size_t *sei_size);
 
+/**
+ * Get an estimated video bitrate based on frame size, frame rate and coded
+ * bits per pixel.
+ */
+int64_t ff_guess_coded_bitrate(AVCodecContext *avctx);
+
 #endif /* AVCODEC_INTERNAL_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/interplayacm.c b/mythtv/external/FFmpeg/libavcodec/interplayacm.c
index 0fd350167a8..c897e72bb62 100644
--- a/mythtv/external/FFmpeg/libavcodec/interplayacm.c
+++ b/mythtv/external/FFmpeg/libavcodec/interplayacm.c
@@ -62,6 +62,11 @@ static av_cold int decode_init(AVCodecContext *avctx)
     if (avctx->extradata_size < 14)
         return AVERROR_INVALIDDATA;
 
+    if (avctx->channels <= 0) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid number of channels: %d\n", avctx->channels);
+        return AVERROR_INVALIDDATA;
+    }
+
     s->level = AV_RL16(avctx->extradata + 12) & 0xf;
     s->rows  = AV_RL16(avctx->extradata + 12) >>  4;
     s->cols  = 1 << s->level;
@@ -72,7 +77,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     s->block   = av_calloc(s->block_len, sizeof(int));
     s->wrapbuf = av_calloc(s->wrapbuf_len, sizeof(int));
     s->ampbuf  = av_calloc(0x10000, sizeof(int));
-    s->bitstream = av_calloc(s->max_framesize, sizeof(*s->bitstream));
+    s->bitstream = av_calloc(s->max_framesize + AV_INPUT_BUFFER_PADDING_SIZE / sizeof(*s->bitstream) + 1, sizeof(*s->bitstream));
     if (!s->block || !s->wrapbuf || !s->ampbuf || !s->bitstream)
         return AVERROR(ENOMEM);
 
@@ -326,6 +331,10 @@ static int t15(InterplayACMContext *s, unsigned ind, unsigned col)
     for (i = 0; i < s->rows; i++) {
         /* b = (x1) + (x2 * 3) + (x3 * 9) */
         b = get_bits(gb, 5);
+        if (b > 26) {
+            av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 26\n", b);
+            return AVERROR_INVALIDDATA;
+        }
 
         n1 =  (mul_3x3[b] & 0x0F) - 1;
         n2 = ((mul_3x3[b] >> 4) & 0x0F) - 1;
@@ -351,6 +360,10 @@ static int t27(InterplayACMContext *s, unsigned ind, unsigned col)
     for (i = 0; i < s->rows; i++) {
         /* b = (x1) + (x2 * 5) + (x3 * 25) */
         b = get_bits(gb, 7);
+        if (b > 124) {
+            av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 124\n", b);
+            return AVERROR_INVALIDDATA;
+        }
 
         n1 =  (mul_3x5[b] & 0x0F) - 2;
         n2 = ((mul_3x5[b] >> 4) & 0x0F) - 2;
@@ -375,6 +388,10 @@ static int t37(InterplayACMContext *s, unsigned ind, unsigned col)
     for (i = 0; i < s->rows; i++) {
         /* b = (x1) + (x2 * 11) */
         b = get_bits(gb, 7);
+        if (b > 120) {
+            av_log(NULL, AV_LOG_ERROR, "Too large b = %d > 120\n", b);
+            return AVERROR_INVALIDDATA;
+        }
 
         n1 =  (mul_2x11[b] & 0x0F) - 5;
         n2 = ((mul_2x11[b] >> 4) & 0x0F) - 5;
diff --git a/mythtv/external/FFmpeg/libavcodec/interplayvideo.c b/mythtv/external/FFmpeg/libavcodec/interplayvideo.c
index abfc935f7b4..deaa09cba60 100644
--- a/mythtv/external/FFmpeg/libavcodec/interplayvideo.c
+++ b/mythtv/external/FFmpeg/libavcodec/interplayvideo.c
@@ -55,8 +55,15 @@ typedef struct IpvideoContext {
     HpelDSPContext hdsp;
     AVFrame *second_last_frame;
     AVFrame *last_frame;
+
+    /* For format 0x10 */
+    AVFrame *cur_decode_frame;
+    AVFrame *prev_decode_frame;
+
     const unsigned char *decoding_map;
     int decoding_map_size;
+    const unsigned char *skip_map;
+    int skip_map_size;
 
     int is_16bpp;
     GetByteContext stream_ptr, mv_ptr;
@@ -903,7 +910,193 @@ static int (* const ipvideo_decode_block16[])(IpvideoContext *s, AVFrame *frame)
     ipvideo_decode_block_opcode_0xE_16, ipvideo_decode_block_opcode_0x1,
 };
 
-static void ipvideo_decode_opcodes(IpvideoContext *s, AVFrame *frame)
+static void ipvideo_format_06_firstpass(IpvideoContext *s, AVFrame *frame, int16_t opcode)
+{
+    int line;
+
+    if (!opcode) {
+        for (line = 0; line < 8; ++line) {
+            bytestream2_get_buffer(&s->stream_ptr, s->pixel_ptr, 8);
+            s->pixel_ptr += s->stride;
+        }
+    } else {
+        /* Don't try to copy second_last_frame data on the first frames */
+        if (s->avctx->frame_number > 2)
+            copy_from(s, s->second_last_frame, frame, 0, 0);
+    }
+}
+
+static void ipvideo_format_06_secondpass(IpvideoContext *s, AVFrame *frame, int16_t opcode)
+{
+    int off_x, off_y;
+
+    if (opcode < 0) {
+        off_x = ((uint16_t)opcode - 0xC000) % frame->linesize[0];
+        off_y = ((uint16_t)opcode - 0xC000) / frame->linesize[0];
+        copy_from(s, s->last_frame, frame, off_x, off_y);
+    } else if (opcode > 0) {
+        off_x = ((uint16_t)opcode - 0x4000) % frame->linesize[0];
+        off_y = ((uint16_t)opcode - 0x4000) / frame->linesize[0];
+        copy_from(s, frame, frame, off_x, off_y);
+    }
+}
+
+static void (* const ipvideo_format_06_passes[])(IpvideoContext *s, AVFrame *frame, int16_t op) = {
+    ipvideo_format_06_firstpass, ipvideo_format_06_secondpass,
+};
+
+static void ipvideo_decode_format_06_opcodes(IpvideoContext *s, AVFrame *frame)
+{
+    int pass, x, y;
+    int16_t opcode;
+    GetByteContext decoding_map_ptr;
+
+    /* this is PAL8, so make the palette available */
+    memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);
+    s->stride = frame->linesize[0];
+
+    s->line_inc = s->stride - 8;
+    s->upper_motion_limit_offset = (s->avctx->height - 8) * frame->linesize[0]
+                                  + (s->avctx->width - 8) * (1 + s->is_16bpp);
+
+    bytestream2_init(&decoding_map_ptr, s->decoding_map, s->decoding_map_size);
+
+    for (pass = 0; pass < 2; ++pass) {
+        bytestream2_seek(&decoding_map_ptr, 0, SEEK_SET);
+        for (y = 0; y < s->avctx->height; y += 8) {
+            for (x = 0; x < s->avctx->width; x += 8) {
+                opcode = bytestream2_get_le16(&decoding_map_ptr);
+
+                ff_tlog(s->avctx,
+                        "  block @ (%3d, %3d): opcode 0x%X, data ptr offset %d\n",
+                        x, y, opcode, bytestream2_tell(&s->stream_ptr));
+
+                s->pixel_ptr = frame->data[0] + x + y * frame->linesize[0];
+                ipvideo_format_06_passes[pass](s, frame, opcode);
+            }
+        }
+    }
+
+    if (bytestream2_get_bytes_left(&s->stream_ptr) > 1) {
+        av_log(s->avctx, AV_LOG_DEBUG,
+               "decode finished with %d bytes left over\n",
+               bytestream2_get_bytes_left(&s->stream_ptr));
+    }
+}
+
+static void ipvideo_format_10_firstpass(IpvideoContext *s, AVFrame *frame, int16_t opcode)
+{
+    int line;
+
+    if (!opcode) {
+        for (line = 0; line < 8; ++line) {
+            bytestream2_get_buffer(&s->stream_ptr, s->pixel_ptr, 8);
+            s->pixel_ptr += s->stride;
+        }
+    }
+}
+
+static void ipvideo_format_10_secondpass(IpvideoContext *s, AVFrame *frame, int16_t opcode)
+{
+    int off_x, off_y;
+
+    if (opcode < 0) {
+        off_x = ((uint16_t)opcode - 0xC000) % s->cur_decode_frame->linesize[0];
+        off_y = ((uint16_t)opcode - 0xC000) / s->cur_decode_frame->linesize[0];
+        copy_from(s, s->prev_decode_frame, s->cur_decode_frame, off_x, off_y);
+    } else if (opcode > 0) {
+        off_x = ((uint16_t)opcode - 0x4000) % s->cur_decode_frame->linesize[0];
+        off_y = ((uint16_t)opcode - 0x4000) / s->cur_decode_frame->linesize[0];
+        copy_from(s, s->cur_decode_frame, s->cur_decode_frame, off_x, off_y);
+    }
+}
+
+static void (* const ipvideo_format_10_passes[])(IpvideoContext *s, AVFrame *frame, int16_t op) = {
+    ipvideo_format_10_firstpass, ipvideo_format_10_secondpass,
+};
+
+static void ipvideo_decode_format_10_opcodes(IpvideoContext *s, AVFrame *frame)
+{
+    int pass, x, y, changed_block;
+    int16_t opcode, skip;
+    GetByteContext decoding_map_ptr;
+    GetByteContext skip_map_ptr;
+
+    bytestream2_skip(&s->stream_ptr, 14); /* data starts 14 bytes in */
+
+    /* this is PAL8, so make the palette available */
+    memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);
+    s->stride = frame->linesize[0];
+
+    s->line_inc = s->stride - 8;
+    s->upper_motion_limit_offset = (s->avctx->height - 8) * frame->linesize[0]
+                                  + (s->avctx->width - 8) * (1 + s->is_16bpp);
+
+    bytestream2_init(&decoding_map_ptr, s->decoding_map, s->decoding_map_size);
+    bytestream2_init(&skip_map_ptr, s->skip_map, s->skip_map_size);
+
+    for (pass = 0; pass < 2; ++pass) {
+        bytestream2_seek(&decoding_map_ptr, 0, SEEK_SET);
+        bytestream2_seek(&skip_map_ptr, 0, SEEK_SET);
+        skip = bytestream2_get_le16(&skip_map_ptr);
+
+        for (y = 0; y < s->avctx->height; y += 8) {
+            for (x = 0; x < s->avctx->width; x += 8) {
+                s->pixel_ptr = s->cur_decode_frame->data[0] + x + y * s->cur_decode_frame->linesize[0];
+
+                while (skip <= 0)  {
+                    if (skip != -0x8000 && skip) {
+                        opcode = bytestream2_get_le16(&decoding_map_ptr);
+                        ipvideo_format_10_passes[pass](s, frame, opcode);
+                        break;
+                    }
+                    if (bytestream2_get_bytes_left(&skip_map_ptr) < 2)
+                        return;
+                    skip = bytestream2_get_le16(&skip_map_ptr);
+                }
+                skip *= 2;
+            }
+        }
+    }
+
+    bytestream2_seek(&skip_map_ptr, 0, SEEK_SET);
+    skip = bytestream2_get_le16(&skip_map_ptr);
+    for (y = 0; y < s->avctx->height; y += 8) {
+        for (x = 0; x < s->avctx->width; x += 8) {
+            changed_block = 0;
+            s->pixel_ptr = frame->data[0] + x + y*frame->linesize[0];
+
+            while (skip <= 0)  {
+                if (skip != -0x8000 && skip) {
+                    changed_block = 1;
+                    break;
+                }
+                if (bytestream2_get_bytes_left(&skip_map_ptr) < 2)
+                    return;
+                skip = bytestream2_get_le16(&skip_map_ptr);
+            }
+
+            if (changed_block) {
+                copy_from(s, s->cur_decode_frame, frame, 0, 0);
+            } else {
+                /* Don't try to copy last_frame data on the first frame */
+                if (s->avctx->frame_number)
+                    copy_from(s, s->last_frame, frame, 0, 0);
+            }
+            skip *= 2;
+        }
+    }
+
+    FFSWAP(AVFrame*, s->prev_decode_frame, s->cur_decode_frame);
+
+    if (bytestream2_get_bytes_left(&s->stream_ptr) > 1) {
+        av_log(s->avctx, AV_LOG_DEBUG,
+               "decode finished with %d bytes left over\n",
+               bytestream2_get_bytes_left(&s->stream_ptr));
+    }
+}
+
+static void ipvideo_decode_format_11_opcodes(IpvideoContext *s, AVFrame *frame)
 {
     int x, y;
     unsigned char opcode;
@@ -928,6 +1121,8 @@ static void ipvideo_decode_opcodes(IpvideoContext *s, AVFrame *frame)
     init_get_bits(&gb, s->decoding_map, s->decoding_map_size * 8);
     for (y = 0; y < s->avctx->height; y += 8) {
         for (x = 0; x < s->avctx->width; x += 8) {
+            if (get_bits_left(&gb) < 4)
+                return;
             opcode = get_bits(&gb, 4);
 
             ff_tlog(s->avctx,
@@ -960,6 +1155,7 @@ static void ipvideo_decode_opcodes(IpvideoContext *s, AVFrame *frame)
 static av_cold int ipvideo_decode_init(AVCodecContext *avctx)
 {
     IpvideoContext *s = avctx->priv_data;
+    int ret;
 
     s->avctx = avctx;
 
@@ -970,13 +1166,36 @@ static av_cold int ipvideo_decode_init(AVCodecContext *avctx)
 
     s->last_frame        = av_frame_alloc();
     s->second_last_frame = av_frame_alloc();
-    if (!s->last_frame || !s->second_last_frame) {
-        av_frame_free(&s->last_frame);
-        av_frame_free(&s->second_last_frame);
-        return AVERROR(ENOMEM);
+    s->cur_decode_frame  = av_frame_alloc();
+    s->prev_decode_frame = av_frame_alloc();
+    if (!s->last_frame || !s->second_last_frame ||
+        !s->cur_decode_frame || !s->prev_decode_frame) {
+        ret = AVERROR(ENOMEM);
+        goto error;
     }
 
+    s->cur_decode_frame->width   = avctx->width;
+    s->prev_decode_frame->width  = avctx->width;
+    s->cur_decode_frame->height  = avctx->height;
+    s->prev_decode_frame->height = avctx->height;
+    s->cur_decode_frame->format  = avctx->pix_fmt;
+    s->prev_decode_frame->format = avctx->pix_fmt;
+
+    ret = ff_get_buffer(avctx, s->cur_decode_frame, 0);
+    if (ret < 0)
+        goto error;
+
+    ret = ff_get_buffer(avctx, s->prev_decode_frame, 0);
+    if (ret < 0)
+        goto error;
+
     return 0;
+error:
+    av_frame_free(&s->last_frame);
+    av_frame_free(&s->second_last_frame);
+    av_frame_free(&s->cur_decode_frame);
+    av_frame_free(&s->prev_decode_frame);
+    return ret;
 }
 
 static int ipvideo_decode_frame(AVCodecContext *avctx,
@@ -988,26 +1207,122 @@ static int ipvideo_decode_frame(AVCodecContext *avctx,
     IpvideoContext *s = avctx->priv_data;
     AVFrame *frame = data;
     int ret;
+    int send_buffer;
+    int frame_format;
+    int video_data_size;
 
-    if (buf_size < 2)
+    if (av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, NULL)) {
+        av_frame_unref(s->last_frame);
+        av_frame_unref(s->second_last_frame);
+        av_frame_unref(s->cur_decode_frame);
+        av_frame_unref(s->prev_decode_frame);
+    }
+
+    if (!s->cur_decode_frame->data[0]) {
+        ret = ff_get_buffer(avctx, s->cur_decode_frame, 0);
+        if (ret < 0)
+            return ret;
+
+        ret = ff_get_buffer(avctx, s->prev_decode_frame, 0);
+        if (ret < 0) {
+            av_frame_unref(s->cur_decode_frame);
+            return ret;
+        }
+    }
+
+    if (buf_size < 8)
         return AVERROR_INVALIDDATA;
 
-    /* decoding map contains 4 bits of information per 8x8 block */
-    s->decoding_map_size = AV_RL16(avpkt->data);
+    frame_format         = AV_RL8(buf);
+    send_buffer          = AV_RL8(buf + 1);
+    video_data_size      = AV_RL16(buf + 2);
+    s->decoding_map_size = AV_RL16(buf + 4);
+    s->skip_map_size     = AV_RL16(buf + 6);
+
+    switch(frame_format) {
+        case 0x06:
+            if (s->decoding_map_size) {
+                av_log(avctx, AV_LOG_ERROR, "Decoding map for format 0x06\n");
+                return AVERROR_INVALIDDATA;
+            }
 
-    /* compressed buffer needs to be large enough to at least hold an entire
-     * decoding map */
-    if (buf_size < s->decoding_map_size + 2)
-        return buf_size;
+            if (s->skip_map_size) {
+                av_log(avctx, AV_LOG_ERROR, "Skip map for format 0x06\n");
+                return AVERROR_INVALIDDATA;
+            }
 
-    if (av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, NULL)) {
-        av_frame_unref(s->last_frame);
-        av_frame_unref(s->second_last_frame);
+            if (s->is_16bpp) {
+                av_log(avctx, AV_LOG_ERROR, "Video format 0x06 does not support 16bpp movies\n");
+                return AVERROR_INVALIDDATA;
+            }
+
+            /* Decoding map for 0x06 frame format is at the top of pixeldata */
+            s->decoding_map_size = ((s->avctx->width / 8) * (s->avctx->height / 8)) * 2;
+            s->decoding_map = buf + 8 + 14; /* 14 bits of op data */
+            video_data_size -= s->decoding_map_size + 14;
+            if (video_data_size <= 0)
+                return AVERROR_INVALIDDATA;
+
+            if (buf_size < 8 + s->decoding_map_size + 14 + video_data_size)
+                return AVERROR_INVALIDDATA;
+
+            bytestream2_init(&s->stream_ptr, buf + 8 + s->decoding_map_size + 14, video_data_size);
+
+            break;
+
+        case 0x10:
+            if (! s->decoding_map_size) {
+                av_log(avctx, AV_LOG_ERROR, "Empty decoding map for format 0x10\n");
+                return AVERROR_INVALIDDATA;
+            }
+
+            if (! s->skip_map_size) {
+                av_log(avctx, AV_LOG_ERROR, "Empty skip map for format 0x10\n");
+                return AVERROR_INVALIDDATA;
+            }
+
+            if (s->is_16bpp) {
+                av_log(avctx, AV_LOG_ERROR, "Video format 0x10 does not support 16bpp movies\n");
+                return AVERROR_INVALIDDATA;
+            }
+
+            if (buf_size < 8 + video_data_size + s->decoding_map_size + s->skip_map_size)
+                return AVERROR_INVALIDDATA;
+
+            bytestream2_init(&s->stream_ptr, buf + 8, video_data_size);
+            s->decoding_map = buf + 8 + video_data_size;
+            s->skip_map = buf + 8 + video_data_size + s->decoding_map_size;
+
+            break;
+
+        case 0x11:
+            if (! s->decoding_map_size) {
+                av_log(avctx, AV_LOG_ERROR, "Empty decoding map for format 0x11\n");
+                return AVERROR_INVALIDDATA;
+            }
+
+            if (s->skip_map_size) {
+                av_log(avctx, AV_LOG_ERROR, "Skip map for format 0x11\n");
+                return AVERROR_INVALIDDATA;
+            }
+
+            if (buf_size < 8 + video_data_size + s->decoding_map_size)
+                return AVERROR_INVALIDDATA;
+
+            bytestream2_init(&s->stream_ptr, buf + 8, video_data_size);
+            s->decoding_map = buf + 8 + video_data_size;
+
+            break;
+
+        default:
+            av_log(avctx, AV_LOG_ERROR, "Frame type 0x%02X unsupported\n", frame_format);
     }
 
-    s->decoding_map = buf + 2;
-    bytestream2_init(&s->stream_ptr, buf + 2 + s->decoding_map_size,
-                     buf_size - s->decoding_map_size);
+    /* ensure we can't overread the packet */
+    if (buf_size < 8 + s->decoding_map_size + video_data_size + s->skip_map_size) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid IP packet size\n");
+        return AVERROR_INVALIDDATA;
+    }
 
     if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
         return ret;
@@ -1023,9 +1338,19 @@ static int ipvideo_decode_frame(AVCodecContext *avctx,
         }
     }
 
-    ipvideo_decode_opcodes(s, frame);
+    switch(frame_format) {
+        case 0x06:
+            ipvideo_decode_format_06_opcodes(s, frame);
+            break;
+        case 0x10:
+            ipvideo_decode_format_10_opcodes(s, frame);
+            break;
+        case 0x11:
+            ipvideo_decode_format_11_opcodes(s, frame);
+            break;
+    }
 
-    *got_frame = 1;
+    *got_frame = send_buffer;
 
     /* shuffle frames */
     av_frame_unref(s->second_last_frame);
@@ -1043,6 +1368,8 @@ static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
 
     av_frame_free(&s->last_frame);
     av_frame_free(&s->second_last_frame);
+    av_frame_free(&s->cur_decode_frame);
+    av_frame_free(&s->prev_decode_frame);
 
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/intrax8.c b/mythtv/external/FFmpeg/libavcodec/intrax8.c
index 5e1233bf0a3..d46f97c7a4b 100644
--- a/mythtv/external/FFmpeg/libavcodec/intrax8.c
+++ b/mythtv/external/FFmpeg/libavcodec/intrax8.c
@@ -544,7 +544,7 @@ static void x8_ac_compensation(IntraX8Context *const w, const int direction,
 }
 
 static void dsp_x8_put_solidcolor(const uint8_t pix, uint8_t *dst,
-                                  const int linesize)
+                                  const ptrdiff_t linesize)
 {
     int k;
     for (k = 0; k < 8; k++) {
@@ -696,7 +696,7 @@ static int x8_decode_intra_mb(IntraX8Context *const w, const int chroma)
 
     if (w->loopfilter) {
         uint8_t *ptr = w->dest[chroma];
-        int linesize = w->frame->linesize[!!chroma];
+        ptrdiff_t linesize = w->frame->linesize[!!chroma];
 
         if (!((w->edges & 2) || (zeros_only && (w->orient | 4) == 4)))
             w->dsp.h_loop_filter(ptr, linesize, w->quant);
@@ -712,8 +712,8 @@ static void x8_init_block_index(IntraX8Context *w, AVFrame *frame)
 {
     // not parent codec linesize as this would be wrong for field pics
     // not that IntraX8 has interlacing support ;)
-    const int linesize   = frame->linesize[0];
-    const int uvlinesize = frame->linesize[1];
+    const ptrdiff_t linesize   = frame->linesize[0];
+    const ptrdiff_t uvlinesize = frame->linesize[1];
 
     w->dest[0] = frame->data[0];
     w->dest[1] = frame->data[1];
@@ -770,7 +770,7 @@ av_cold void ff_intrax8_common_end(IntraX8Context *w)
     av_freep(&w->prediction_table);
 }
 
-int ff_intrax8_decode_picture(IntraX8Context *const w, Picture *pict,
+int ff_intrax8_decode_picture(IntraX8Context *w, Picture *pict,
                               GetBitContext *gb, int *mb_x, int *mb_y,
                               int dquant, int quant_offset,
                               int loopfilter, int lowdelay)
diff --git a/mythtv/external/FFmpeg/libavcodec/intrax8dsp.c b/mythtv/external/FFmpeg/libavcodec/intrax8dsp.c
index 5520e3c8ad7..80c3929f710 100644
--- a/mythtv/external/FFmpeg/libavcodec/intrax8dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/intrax8dsp.c
@@ -63,8 +63,8 @@
                 4   - mb_x>= (mb_width-1) last block in the row, interpolate area #5;
 -*/
 static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst,
-                                          int linesize, int *range, int *psum,
-                                          int edges)
+                                          ptrdiff_t stride, int *range,
+                                          int *psum, int edges)
 {
     uint8_t *ptr;
     int sum;
@@ -98,12 +98,12 @@ static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst,
             max_pix        = FFMAX(max_pix, c);
             dst[area2 + i] = c;
 
-            ptr += linesize;
+            ptr += stride;
         }
     }
 
     if (!(edges & 2)) { // (mb_y != 0) // there is row above
-        ptr = src - linesize; // top line
+        ptr = src - stride; // top line
         for (i = 0; i < 8; i++) {
             c       = *(ptr + i);
             sum    += c;
@@ -117,7 +117,7 @@ static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst,
             memcpy(dst + area4, ptr, 16); // both area4 and 5
         }
         // area6 always present in the above block
-        memcpy(dst + area6, ptr - linesize, 8);
+        memcpy(dst + area6, ptr - stride, 8);
     }
     // now calculate the stuff we need
     if (edges & 3) { // mb_x ==0 || mb_y == 0) {
@@ -131,7 +131,7 @@ static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst,
         sum += avg * 9;
     } else {
         // the edge pixel, in the top line and left column
-        uint8_t c = *(src - 1 - linesize);
+        uint8_t c = *(src - 1 - stride);
         dst[area3] = c;
         sum       += c;
         // edge pixel is not part of min/max
@@ -160,7 +160,7 @@ static const uint16_t zero_prediction_weights[64 * 2] = {
     317,  846, 366,  731, 458,  611, 499, 499,
 };
 
-static void spatial_compensation_0(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_0(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int i, j;
     int x, y;
@@ -208,55 +208,55 @@ static void spatial_compensation_0(uint8_t *src, uint8_t *dst, int linesize)
             dst[x] = ((uint32_t)  top_sum[0][x] * zero_prediction_weights[y * 16 + x * 2 + 0] +
                       (uint32_t) left_sum[0][y] * zero_prediction_weights[y * 16 + x * 2 + 1] +
                       0x8000) >> 16;
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void spatial_compensation_1(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_1(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int x, y;
 
     for (y = 0; y < 8; y++) {
         for (x = 0; x < 8; x++)
             dst[x] = src[area4 + FFMIN(2 * y + x + 2, 15)];
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void spatial_compensation_2(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_2(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int x, y;
 
     for (y = 0; y < 8; y++) {
         for (x = 0; x < 8; x++)
             dst[x] = src[area4 + 1 + y + x];
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void spatial_compensation_3(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_3(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int x, y;
 
     for (y = 0; y < 8; y++) {
         for (x = 0; x < 8; x++)
             dst[x] = src[area4 + ((y + 1) >> 1) + x];
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void spatial_compensation_4(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_4(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int x, y;
 
     for (y = 0; y < 8; y++) {
         for (x = 0; x < 8; x++)
             dst[x] = (src[area4 + x] + src[area6 + x] + 1) >> 1;
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void spatial_compensation_5(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_5(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int x, y;
 
@@ -267,22 +267,22 @@ static void spatial_compensation_5(uint8_t *src, uint8_t *dst, int linesize)
             else
                 dst[x] = src[area4 + x - ((y + 1) >> 1)];
         }
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void spatial_compensation_6(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_6(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int x, y;
 
     for (y = 0; y < 8; y++) {
         for (x = 0; x < 8; x++)
             dst[x] = src[area3 + x - y];
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void spatial_compensation_7(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_7(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int x, y;
 
@@ -293,55 +293,56 @@ static void spatial_compensation_7(uint8_t *src, uint8_t *dst, int linesize)
             else
                 dst[x] = src[area2 + 8 - y + (x >> 1)];
         }
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void spatial_compensation_8(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_8(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int x, y;
 
     for (y = 0; y < 8; y++) {
         for (x = 0; x < 8; x++)
             dst[x] = (src[area1 + 7 - y] + src[area2 + 7 - y] + 1) >> 1;
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void spatial_compensation_9(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_9(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int x, y;
 
     for (y = 0; y < 8; y++) {
         for (x = 0; x < 8; x++)
             dst[x] = src[area2 + 6 - FFMIN(x + y, 6)];
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void spatial_compensation_10(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_10(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int x, y;
 
     for (y = 0; y < 8; y++) {
         for (x = 0; x < 8; x++)
             dst[x] = (src[area2 + 7 - y] * (8 - x) + src[area4 + x] * x + 4) >> 3;
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void spatial_compensation_11(uint8_t *src, uint8_t *dst, int linesize)
+static void spatial_compensation_11(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
 {
     int x, y;
 
     for (y = 0; y < 8; y++) {
         for (x = 0; x < 8; x++)
             dst[x] = (src[area2 + 7 - y] * y + src[area4 + x] * (8 - y) + 4) >> 3;
-        dst += linesize;
+        dst += stride;
     }
 }
 
-static void x8_loop_filter(uint8_t *ptr, const int a_stride, const int b_stride, int quant)
+static void x8_loop_filter(uint8_t *ptr, const ptrdiff_t a_stride,
+                           const ptrdiff_t b_stride, int quant)
 {
     int i, t;
     int p0, p1, p2, p3, p4, p5, p6, p7, p8, p9;
@@ -434,12 +435,12 @@ static void x8_loop_filter(uint8_t *ptr, const int a_stride, const int b_stride,
     }
 }
 
-static void x8_h_loop_filter(uint8_t *src, int stride, int qscale)
+static void x8_h_loop_filter(uint8_t *src, ptrdiff_t stride, int qscale)
 {
     x8_loop_filter(src, stride, 1, qscale);
 }
 
-static void x8_v_loop_filter(uint8_t *src, int stride, int qscale)
+static void x8_v_loop_filter(uint8_t *src, ptrdiff_t stride, int qscale)
 {
     x8_loop_filter(src, 1, stride, qscale);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/intrax8dsp.h b/mythtv/external/FFmpeg/libavcodec/intrax8dsp.h
index b5d160713fd..bf42698ed7f 100644
--- a/mythtv/external/FFmpeg/libavcodec/intrax8dsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/intrax8dsp.h
@@ -19,15 +19,18 @@
 #ifndef AVCODEC_INTRAX8DSP_H
 #define AVCODEC_INTRAX8DSP_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 typedef struct IntraX8DSPContext {
-    void (*v_loop_filter)(uint8_t *src, int stride, int qscale);
-    void (*h_loop_filter)(uint8_t *src, int stride, int qscale);
+    void (*v_loop_filter)(uint8_t *src, ptrdiff_t stride, int qscale);
+    void (*h_loop_filter)(uint8_t *src, ptrdiff_t stride, int qscale);
 
-    void (*spatial_compensation[12])(uint8_t *src, uint8_t *dst, int linesize);
-    void (*setup_spatial_compensation)(uint8_t *src, uint8_t *dst, int linesize,
-                                       int *range, int *sum, int edges);
+    void (*spatial_compensation[12])(uint8_t *src, uint8_t *dst,
+                                     ptrdiff_t stride);
+    void (*setup_spatial_compensation)(uint8_t *src, uint8_t *dst,
+                                       ptrdiff_t stride, int *range,
+                                       int *sum, int edges);
 } IntraX8DSPContext;
 
 void ff_intrax8dsp_init(IntraX8DSPContext *dsp);
diff --git a/mythtv/external/FFmpeg/libavcodec/ituh263dec.c b/mythtv/external/FFmpeg/libavcodec/ituh263dec.c
index a26244f3931..fc95a532ce7 100644
--- a/mythtv/external/FFmpeg/libavcodec/ituh263dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ituh263dec.c
@@ -167,6 +167,7 @@ static int h263_decode_gob_header(MpegEncContext *s)
         /* We have a GBSC probably with GSTUFF */
     skip_bits(&s->gb, 16); /* Drop the zeros */
     left= get_bits_left(&s->gb);
+    left = FFMIN(left, 32);
     //MN: we must check the bits left or we might end in an infinite loop (or segfault)
     for(;left>13; left--){
         if(get_bits1(&s->gb)) break; /* Seek the '1' bit */
@@ -302,6 +303,10 @@ static int h263p_decode_umotion(MpegEncContext * s, int pred)
    {
       code <<= 1;
       code += get_bits1(&s->gb);
+      if (code >= 32768) {
+          avpriv_request_sample(s->avctx, "Huge DMV");
+          return 0xffff;
+      }
    }
    sign = code & 1;
    code >>= 1;
@@ -363,14 +368,14 @@ static void preview_obmc(MpegEncContext *s){
                 /* 16x16 motion prediction */
                 mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
                 if (s->umvplus)
-                   mx = h263p_decode_umotion(s, pred_x);
+                    mx = h263p_decode_umotion(s, pred_x);
                 else
-                   mx = ff_h263_decode_motion(s, pred_x, 1);
+                    mx = ff_h263_decode_motion(s, pred_x, 1);
 
                 if (s->umvplus)
-                   my = h263p_decode_umotion(s, pred_y);
+                    my = h263p_decode_umotion(s, pred_y);
                 else
-                   my = ff_h263_decode_motion(s, pred_y, 1);
+                    my = ff_h263_decode_motion(s, pred_y, 1);
 
                 mot_val[0       ]= mot_val[2       ]=
                 mot_val[0+stride]= mot_val[2+stride]= mx;
@@ -381,16 +386,16 @@ static void preview_obmc(MpegEncContext *s){
             for(i=0;i<4;i++) {
                 mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
                 if (s->umvplus)
-                  mx = h263p_decode_umotion(s, pred_x);
+                    mx = h263p_decode_umotion(s, pred_x);
                 else
-                  mx = ff_h263_decode_motion(s, pred_x, 1);
+                    mx = ff_h263_decode_motion(s, pred_x, 1);
 
                 if (s->umvplus)
-                  my = h263p_decode_umotion(s, pred_y);
+                    my = h263p_decode_umotion(s, pred_y);
                 else
-                  my = ff_h263_decode_motion(s, pred_y, 1);
+                    my = ff_h263_decode_motion(s, pred_y, 1);
                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
-                  skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
+                    skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
                 mot_val[0] = mx;
                 mot_val[1] = my;
             }
@@ -523,7 +528,7 @@ static int h263_decode_block(MpegEncContext * s, int16_t * block,
                     }else{
                         level = SHOW_UBITS(re, &s->gb, 5);
                         SKIP_CACHE(re, &s->gb, 5);
-                        level |= SHOW_SBITS(re, &s->gb, 6)<<5;
+                        level |= SHOW_SBITS(re, &s->gb, 6) * (1<<5);
                         SKIP_COUNTER(re, &s->gb, 5 + 6);
                     }
                 }
@@ -569,7 +574,7 @@ static int h263_decode_block(MpegEncContext * s, int16_t * block,
 
 static int h263_skip_b_part(MpegEncContext *s, int cbp)
 {
-    LOCAL_ALIGNED_16(int16_t, dblock, [64]);
+    LOCAL_ALIGNED_32(int16_t, dblock, [64]);
     int i, mbi;
     int bli[6];
 
@@ -607,6 +612,73 @@ static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)
     return mv;
 }
 
+#define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0]))
+#define tab_bias (tab_size / 2)
+static inline void set_one_direct_mv(MpegEncContext *s, Picture *p, int i)
+{
+    int xy           = s->block_index[i];
+    uint16_t time_pp = s->pp_time;
+    uint16_t time_pb = s->pb_time;
+    int p_mx, p_my;
+
+    p_mx = p->motion_val[0][xy][0];
+    if ((unsigned)(p_mx + tab_bias) < tab_size) {
+        s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias];
+        s->mv[1][i][0] = s->direct_scale_mv[1][p_mx + tab_bias];
+    } else {
+        s->mv[0][i][0] = p_mx * time_pb / time_pp;
+        s->mv[1][i][0] = p_mx * (time_pb - time_pp) / time_pp;
+    }
+    p_my = p->motion_val[0][xy][1];
+    if ((unsigned)(p_my + tab_bias) < tab_size) {
+        s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias];
+        s->mv[1][i][1] = s->direct_scale_mv[1][p_my + tab_bias];
+    } else {
+        s->mv[0][i][1] = p_my * time_pb / time_pp;
+        s->mv[1][i][1] = p_my * (time_pb - time_pp) / time_pp;
+    }
+}
+
+/**
+ * @return the mb_type
+ */
+static int set_direct_mv(MpegEncContext *s)
+{
+    const int mb_index = s->mb_x + s->mb_y * s->mb_stride;
+    Picture *p = &s->next_picture;
+    int colocated_mb_type = p->mb_type[mb_index];
+    int i;
+
+    if (s->codec_tag == AV_RL32("U263") && p->f->pict_type == AV_PICTURE_TYPE_I) {
+        p = &s->last_picture;
+        colocated_mb_type = p->mb_type[mb_index];
+    }
+
+    if (IS_8X8(colocated_mb_type)) {
+        s->mv_type = MV_TYPE_8X8;
+        for (i = 0; i < 4; i++)
+            set_one_direct_mv(s, p, i);
+        return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;
+    } else {
+        set_one_direct_mv(s, p, 0);
+        s->mv[0][1][0] =
+        s->mv[0][2][0] =
+        s->mv[0][3][0] = s->mv[0][0][0];
+        s->mv[0][1][1] =
+        s->mv[0][2][1] =
+        s->mv[0][3][1] = s->mv[0][0][1];
+        s->mv[1][1][0] =
+        s->mv[1][2][0] =
+        s->mv[1][3][0] = s->mv[1][0][0];
+        s->mv[1][1][1] =
+        s->mv[1][2][1] =
+        s->mv[1][3][1] = s->mv[1][0][1];
+        s->mv_type = MV_TYPE_8X8;
+        // Note see prev line
+        return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1;
+    }
+}
+
 int ff_h263_decode_mb(MpegEncContext *s,
                       int16_t block[6][64])
 {
@@ -635,7 +707,7 @@ int ff_h263_decode_mb(MpegEncContext *s,
             cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
             if (cbpc < 0){
                 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
-                return -1;
+                return SLICE_ERROR;
             }
         }while(cbpc == 20);
 
@@ -649,6 +721,11 @@ int ff_h263_decode_mb(MpegEncContext *s,
             pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);
         cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 
+        if (cbpy < 0) {
+            av_log(s->avctx, AV_LOG_ERROR, "cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
+            return SLICE_ERROR;
+        }
+
         if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
             cbpy ^= 0xF;
 
@@ -669,7 +746,7 @@ int ff_h263_decode_mb(MpegEncContext *s,
                mx = ff_h263_decode_motion(s, pred_x, 1);
 
             if (mx >= 0xffff)
-                return -1;
+                return SLICE_ERROR;
 
             if (s->umvplus)
                my = h263p_decode_umotion(s, pred_y);
@@ -677,7 +754,7 @@ int ff_h263_decode_mb(MpegEncContext *s,
                my = ff_h263_decode_motion(s, pred_y, 1);
 
             if (my >= 0xffff)
-                return -1;
+                return SLICE_ERROR;
             s->mv[0][0][0] = mx;
             s->mv[0][0][1] = my;
 
@@ -689,18 +766,18 @@ int ff_h263_decode_mb(MpegEncContext *s,
             for(i=0;i<4;i++) {
                 mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
                 if (s->umvplus)
-                  mx = h263p_decode_umotion(s, pred_x);
+                    mx = h263p_decode_umotion(s, pred_x);
                 else
-                  mx = ff_h263_decode_motion(s, pred_x, 1);
+                    mx = ff_h263_decode_motion(s, pred_x, 1);
                 if (mx >= 0xffff)
-                    return -1;
+                    return SLICE_ERROR;
 
                 if (s->umvplus)
-                  my = h263p_decode_umotion(s, pred_y);
+                    my = h263p_decode_umotion(s, pred_y);
                 else
-                  my = ff_h263_decode_motion(s, pred_y, 1);
+                    my = ff_h263_decode_motion(s, pred_y, 1);
                 if (my >= 0xffff)
-                    return -1;
+                    return SLICE_ERROR;
                 s->mv[0][i][0] = mx;
                 s->mv[0][i][1] = my;
                 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
@@ -726,7 +803,7 @@ int ff_h263_decode_mb(MpegEncContext *s,
             mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);
             if (mb_type < 0){
                 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);
-                return -1;
+                return SLICE_ERROR;
             }
 
             mb_type= h263_mb_type_b_map[ mb_type ];
@@ -745,7 +822,7 @@ int ff_h263_decode_mb(MpegEncContext *s,
 
             if (cbpy < 0){
                 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
-                return -1;
+                return SLICE_ERROR;
             }
 
             if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)
@@ -763,18 +840,32 @@ int ff_h263_decode_mb(MpegEncContext *s,
 
         if(IS_DIRECT(mb_type)){
             s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
-            mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
+            mb_type |= set_direct_mv(s);
         }else{
             s->mv_dir = 0;
             s->mv_type= MV_TYPE_16X16;
 //FIXME UMV
 
             if(USES_LIST(mb_type, 0)){
-                int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &mx, &my);
+                int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
                 s->mv_dir = MV_DIR_FORWARD;
 
-                mx = ff_h263_decode_motion(s, mx, 1);
-                my = ff_h263_decode_motion(s, my, 1);
+                if (s->umvplus)
+                    mx = h263p_decode_umotion(s, pred_x);
+                else
+                    mx = ff_h263_decode_motion(s, pred_x, 1);
+                if (mx >= 0xffff)
+                    return SLICE_ERROR;
+
+                if (s->umvplus)
+                    my = h263p_decode_umotion(s, pred_y);
+                else
+                    my = ff_h263_decode_motion(s, pred_y, 1);
+                if (my >= 0xffff)
+                    return SLICE_ERROR;
+
+                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
+                    skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
 
                 s->mv[0][0][0] = mx;
                 s->mv[0][0][1] = my;
@@ -783,11 +874,25 @@ int ff_h263_decode_mb(MpegEncContext *s,
             }
 
             if(USES_LIST(mb_type, 1)){
-                int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &mx, &my);
+                int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &pred_x, &pred_y);
                 s->mv_dir |= MV_DIR_BACKWARD;
 
-                mx = ff_h263_decode_motion(s, mx, 1);
-                my = ff_h263_decode_motion(s, my, 1);
+                if (s->umvplus)
+                    mx = h263p_decode_umotion(s, pred_x);
+                else
+                    mx = ff_h263_decode_motion(s, pred_x, 1);
+                if (mx >= 0xffff)
+                    return SLICE_ERROR;
+
+                if (s->umvplus)
+                    my = h263p_decode_umotion(s, pred_y);
+                else
+                    my = ff_h263_decode_motion(s, pred_y, 1);
+                if (my >= 0xffff)
+                    return SLICE_ERROR;
+
+                if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)
+                    skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
 
                 s->mv[1][0][0] = mx;
                 s->mv[1][0][1] = my;
@@ -802,7 +907,7 @@ int ff_h263_decode_mb(MpegEncContext *s,
             cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
             if (cbpc < 0){
                 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
-                return -1;
+                return SLICE_ERROR;
             }
         }while(cbpc == 8);
 
@@ -827,7 +932,7 @@ int ff_h263_decode_mb(MpegEncContext *s,
         cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
         if(cbpy<0){
             av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
-            return -1;
+            return SLICE_ERROR;
         }
         cbp = (cbpc & 3) | (cbpy << 2);
         if (dquant) {
@@ -857,6 +962,9 @@ int ff_h263_decode_mb(MpegEncContext *s,
     }
 end:
 
+    if (get_bits_left(&s->gb) < 0)
+        return AVERROR_INVALIDDATA;
+
         /* per-MB end of slice check */
     {
         int v= show_bits(&s->gb, 16);
@@ -899,8 +1007,9 @@ int ff_h263_decode_picture_header(MpegEncContext *s)
     }
     /* temporal reference */
     i = get_bits(&s->gb, 8); /* picture timestamp */
-    if( (s->picture_number&~0xFF)+i < s->picture_number)
-        i+= 256;
+
+    i -= (i - (s->picture_number & 0xFF) + 128) & ~0xFF;
+
     s->picture_number= (s->picture_number&~0xFF) + i;
 
     /* PTYPE starts here */
@@ -1080,6 +1189,12 @@ int ff_h263_decode_picture_header(MpegEncContext *s)
                     av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");
                 }
             }
+            if (s->pict_type == AV_PICTURE_TYPE_B) {
+                skip_bits(&s->gb, 4); //ELNUM
+                if (ufep == 1) {
+                    skip_bits(&s->gb, 4); // RLNUM
+                }
+            }
         }
 
         s->qscale = get_bits(&s->gb, 5);
@@ -1132,6 +1247,9 @@ int ff_h263_decode_picture_header(MpegEncContext *s)
     }
     s->f_code = 1;
 
+    if (s->pict_type == AV_PICTURE_TYPE_B)
+        s->low_delay = 0;
+
     if(s->h263_aic){
          s->y_dc_scale_table=
          s->c_dc_scale_table= ff_aic_dc_scale_table;
diff --git a/mythtv/external/FFmpeg/libavcodec/ivi.c b/mythtv/external/FFmpeg/libavcodec/ivi.c
index 70f08a8503a..cea40d82ca2 100644
--- a/mythtv/external/FFmpeg/libavcodec/ivi.c
+++ b/mythtv/external/FFmpeg/libavcodec/ivi.c
@@ -74,10 +74,10 @@ static VLC ivi_mb_vlc_tabs [8]; ///< static macroblock Huffman tables
 static VLC ivi_blk_vlc_tabs[8]; ///< static block Huffman tables
 
 typedef void (*ivi_mc_func) (int16_t *buf, const int16_t *ref_buf,
-                             uint32_t pitch, int mc_type);
+                             ptrdiff_t pitch, int mc_type);
 typedef void (*ivi_mc_avg_func) (int16_t *buf, const int16_t *ref_buf1,
                                  const int16_t *ref_buf2,
-                                 uint32_t pitch, int mc_type, int mc_type2);
+                                 ptrdiff_t pitch, int mc_type, int mc_type2);
 
 static int ivi_mc(IVIBandDesc *band, ivi_mc_func mc, ivi_mc_avg_func mc_avg,
                   int offs, int mv_x, int mv_y, int mv_x2, int mv_y2,
@@ -302,7 +302,7 @@ static av_cold void ivi_free_buffers(IVIPlaneDesc *planes)
     }
 }
 
-av_cold int ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg,
+av_cold int ff_ivi_init_planes(AVCodecContext *avctx, IVIPlaneDesc *planes, const IVIPicConfig *cfg,
                                int is_indeo4)
 {
     int p, b;
@@ -312,7 +312,7 @@ av_cold int ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg,
 
     ivi_free_buffers(planes);
 
-    if (av_image_check_size(cfg->pic_width, cfg->pic_height, 0, NULL) < 0 ||
+    if (av_image_check_size2(cfg->pic_width, cfg->pic_height, avctx->max_pixels, AV_PIX_FMT_YUV410P, 0, avctx) < 0 ||
         cfg->luma_bands < 1 || cfg->chroma_bands < 1)
         return AVERROR_INVALIDDATA;
 
@@ -903,11 +903,11 @@ static uint16_t ivi_calc_band_checksum(IVIBandDesc *band)
  *  @param[out]  dst        pointer to the buffer receiving converted pixels
  *  @param[in]   dst_pitch  pitch for moving to the next y line
  */
-static void ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, int dst_pitch)
+static void ivi_output_plane(IVIPlaneDesc *plane, uint8_t *dst, ptrdiff_t dst_pitch)
 {
     int             x, y;
     const int16_t   *src  = plane->bands[0].buf;
-    uint32_t        pitch = plane->bands[0].pitch;
+    ptrdiff_t       pitch = plane->bands[0].pitch;
 
     if (!src)
         return;
@@ -1060,7 +1060,9 @@ int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     int             buf_size = avpkt->size;
     int             result, p, b;
 
-    init_get_bits(&ctx->gb, buf, buf_size * 8);
+    result = init_get_bits8(&ctx->gb, buf, buf_size);
+    if (result < 0)
+        return result;
     ctx->frame_data = buf;
     ctx->frame_size = buf_size;
 
@@ -1204,6 +1206,9 @@ av_cold int ff_ivi_decode_close(AVCodecContext *avctx)
     if (ctx->mb_vlc.cust_tab.table)
         ff_free_vlc(&ctx->mb_vlc.cust_tab);
 
+    if (ctx->blk_vlc.cust_tab.table)
+        ff_free_vlc(&ctx->blk_vlc.cust_tab);
+
     av_frame_free(&ctx->p_frame);
 
     return 0;
diff --git a/mythtv/external/FFmpeg/libavcodec/ivi.h b/mythtv/external/FFmpeg/libavcodec/ivi.h
index 35718082477..1427535547c 100644
--- a/mythtv/external/FFmpeg/libavcodec/ivi.h
+++ b/mythtv/external/FFmpeg/libavcodec/ivi.h
@@ -87,8 +87,8 @@ extern const uint8_t ff_ivi_direct_scan_4x4[16];
 /**
  *  Declare inverse transform function types
  */
-typedef void (InvTransformPtr)(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags);
-typedef void (DCTransformPtr) (const int32_t *in, int16_t *out, uint32_t pitch, int blk_size);
+typedef void (InvTransformPtr)(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags);
+typedef void (DCTransformPtr) (const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size);
 
 
 /**
@@ -153,7 +153,7 @@ typedef struct IVIBandDesc {
     int16_t         *ref_buf;       ///< pointer to the reference frame buffer (for motion compensation)
     int16_t         *b_ref_buf;     ///< pointer to the second reference frame buffer (for motion compensation)
     int16_t         *bufs[4];       ///< array of pointers to the band buffers
-    int             pitch;          ///< pitch associated with the buffers above
+    ptrdiff_t       pitch;          ///< pitch associated with the buffers above
     int             is_empty;       ///< = 1 if this band doesn't contain any data
     int             mb_size;        ///< macroblock size
     int             blk_size;       ///< block size
@@ -322,8 +322,8 @@ int  ff_ivi_dec_huff_desc(GetBitContext *gb, int desc_coded, int which_tab,
  *  @param[in]      is_indeo4  flag signalling if it is Indeo 4 or not
  *  @return             result code: 0 - OK
  */
-int  ff_ivi_init_planes(IVIPlaneDesc *planes, const IVIPicConfig *cfg,
-                        int is_indeo4);
+int  ff_ivi_init_planes(AVCodecContext *avctx, IVIPlaneDesc *planes,
+                        const IVIPicConfig *cfg, int is_indeo4);
 
 /**
  *  Initialize tile and macroblock descriptors.
diff --git a/mythtv/external/FFmpeg/libavcodec/ivi_dsp.c b/mythtv/external/FFmpeg/libavcodec/ivi_dsp.c
index 52112695f1b..4aedf179072 100644
--- a/mythtv/external/FFmpeg/libavcodec/ivi_dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/ivi_dsp.c
@@ -31,13 +31,13 @@
 #include "ivi_dsp.h"
 
 void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,
-                        const int dst_pitch)
+                        const ptrdiff_t dst_pitch)
 {
     int             x, y, indx;
     int32_t         p0, p1, p2, p3, tmp0, tmp1, tmp2;
     int32_t         b0_1, b0_2, b1_1, b1_2, b1_3, b2_1, b2_2, b2_3, b2_4, b2_5, b2_6;
     int32_t         b3_1, b3_2, b3_3, b3_4, b3_5, b3_6, b3_7, b3_8, b3_9;
-    int32_t         pitch, back_pitch;
+    ptrdiff_t       pitch, back_pitch;
     const short     *b0_ptr, *b1_ptr, *b2_ptr, *b3_ptr;
     const int       num_bands = 4;
 
@@ -116,10 +116,10 @@ void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,
                 b0_2 = b0_ptr[pitch+indx+1];
                 tmp1 = tmp0 + b0_1;
 
-                p0 =  tmp0 << 4;
-                p1 =  tmp1 << 3;
-                p2 = (tmp0 + tmp2) << 3;
-                p3 = (tmp1 + tmp2 + b0_2) << 2;
+                p0 =  tmp0 * 16;
+                p1 =  tmp1 * 8;
+                p2 = (tmp0 + tmp2) * 8;
+                p3 = (tmp1 + tmp2 + b0_2) * 4;
             }
 
             /* process the HL-band by applying HPF vertically and LPF horizontally */
@@ -132,10 +132,10 @@ void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,
                 tmp2 = tmp1 - tmp0*6 + b1_3;
                 b1_3 = b1_1 - b1_2*6 + b1_ptr[pitch+indx+1];
 
-                p0 += (tmp0 + tmp1) << 3;
-                p1 += (tmp0 + tmp1 + b1_1 + b1_2) << 2;
-                p2 +=  tmp2 << 2;
-                p3 += (tmp2 + b1_3) << 1;
+                p0 += (tmp0 + tmp1) * 8;
+                p1 += (tmp0 + tmp1 + b1_1 + b1_2) * 4;
+                p2 +=  tmp2 * 4;
+                p3 += (tmp2 + b1_3) * 2;
             }
 
             /* process the LH-band by applying LPF vertically and HPF horizontally */
@@ -146,10 +146,10 @@ void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,
                 tmp0 = b2_1 + b2_2;
                 tmp1 = b2_1 - b2_2*6 + b2_3;
 
-                p0 += tmp0 << 3;
-                p1 += tmp1 << 2;
-                p2 += (tmp0 + b2_4 + b2_5) << 2;
-                p3 += (tmp1 + b2_4 - b2_5*6 + b2_6) << 1;
+                p0 += tmp0 * 8;
+                p1 += tmp1 * 4;
+                p2 += (tmp0 + b2_4 + b2_5) * 4;
+                p3 += (tmp1 + b2_4 - b2_5*6 + b2_6) * 2;
             }
 
             /* process the HH-band by applying HPF both vertically and horizontally */
@@ -163,9 +163,9 @@ void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,
 
                 b3_9 = b3_3 - b3_6*6 + b3_ptr[pitch+indx+1];
 
-                p0 += (tmp0 + tmp1) << 2;
-                p1 += (tmp0 - tmp1*6 + tmp2) << 1;
-                p2 += (b3_7 + b3_8) << 1;
+                p0 += (tmp0 + tmp1) * 4;
+                p1 += (tmp0 - tmp1*6 + tmp2) * 2;
+                p2 += (b3_7 + b3_8) * 2;
                 p3 +=  b3_7 - b3_8*6 + b3_9;
             }
 
@@ -188,11 +188,11 @@ void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,
 }
 
 void ff_ivi_recompose_haar(const IVIPlaneDesc *plane, uint8_t *dst,
-                           const int dst_pitch)
+                           const ptrdiff_t dst_pitch)
 {
     int             x, y, indx, b0, b1, b2, b3, p0, p1, p2, p3;
     const short     *b0_ptr, *b1_ptr, *b2_ptr, *b3_ptr;
-    int32_t         pitch;
+    ptrdiff_t       pitch;
 
     /* all bands should have the same pitch */
     pitch = plane->bands[0].pitch;
@@ -243,7 +243,7 @@ void ff_ivi_recompose_haar(const IVIPlaneDesc *plane, uint8_t *dst,
 #define INV_HAAR8(s1, s5, s3, s7, s2, s4, s6, s8,\
                   d1, d2, d3, d4, d5, d6, d7, d8,\
                   t0, t1, t2, t3, t4, t5, t6, t7, t8) {\
-    t1 = (s1) << 1; t5 = (s5) << 1;\
+    t1 = (s1) * 2; t5 = (s5) * 2;\
     IVI_HAAR_BFLY(t1, t5, t1, t5, t0); IVI_HAAR_BFLY(t1, s3, t1, t3, t0);\
     IVI_HAAR_BFLY(t5, s7, t5, t7, t0); IVI_HAAR_BFLY(t1, s2, t1, t2, t0);\
     IVI_HAAR_BFLY(t3, s4, t3, t4, t0); IVI_HAAR_BFLY(t5, s6, t5, t6, t0);\
@@ -267,7 +267,7 @@ void ff_ivi_recompose_haar(const IVIPlaneDesc *plane, uint8_t *dst,
     d3 = COMPENSATE(t2);\
     d4 = COMPENSATE(t3); }
 
-void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                              const uint8_t *flags)
 {
     int     i, shift, sp1, sp2, sp3, sp4;
@@ -284,10 +284,10 @@ void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, uint32_t pitch,
         if (flags[i]) {
             /* pre-scaling */
             shift = !(i & 4);
-            sp1 = src[ 0] << shift;
-            sp2 = src[ 8] << shift;
-            sp3 = src[16] << shift;
-            sp4 = src[24] << shift;
+            sp1 = src[ 0] * (1 << shift);
+            sp2 = src[ 8] * (1 << shift);
+            sp3 = src[16] * (1 << shift);
+            sp4 = src[24] * (1 << shift);
             INV_HAAR8(    sp1,     sp2,     sp3,     sp4,
                       src[32], src[40], src[48], src[56],
                       dst[ 0], dst[ 8], dst[16], dst[24],
@@ -322,7 +322,7 @@ void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, uint32_t pitch,
 #undef  COMPENSATE
 }
 
-void ff_ivi_row_haar8(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_row_haar8(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                       const uint8_t *flags)
 {
     int     i;
@@ -347,7 +347,7 @@ void ff_ivi_row_haar8(const int32_t *in, int16_t *out, uint32_t pitch,
 #undef  COMPENSATE
 }
 
-void ff_ivi_col_haar8(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_col_haar8(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                       const uint8_t *flags)
 {
     int     i;
@@ -376,7 +376,7 @@ void ff_ivi_col_haar8(const int32_t *in, int16_t *out, uint32_t pitch,
 #undef  COMPENSATE
 }
 
-void ff_ivi_inverse_haar_4x4(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_inverse_haar_4x4(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                              const uint8_t *flags)
 {
     int     i, shift, sp1, sp2;
@@ -393,8 +393,8 @@ void ff_ivi_inverse_haar_4x4(const int32_t *in, int16_t *out, uint32_t pitch,
         if (flags[i]) {
             /* pre-scaling */
             shift = !(i & 2);
-            sp1 = src[0] << shift;
-            sp2 = src[4] << shift;
+            sp1 = src[0] * (1 << shift);
+            sp2 = src[4] * (1 << shift);
             INV_HAAR4(   sp1,    sp2, src[8], src[12],
                       dst[0], dst[4], dst[8], dst[12],
                       t0, t1, t2, t3, t4);
@@ -423,7 +423,7 @@ void ff_ivi_inverse_haar_4x4(const int32_t *in, int16_t *out, uint32_t pitch,
 #undef  COMPENSATE
 }
 
-void ff_ivi_row_haar4(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_row_haar4(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                       const uint8_t *flags)
 {
     int     i;
@@ -445,7 +445,7 @@ void ff_ivi_row_haar4(const int32_t *in, int16_t *out, uint32_t pitch,
 #undef  COMPENSATE
 }
 
-void ff_ivi_col_haar4(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_col_haar4(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                       const uint8_t *flags)
 {
     int     i;
@@ -469,7 +469,7 @@ void ff_ivi_col_haar4(const int32_t *in, int16_t *out, uint32_t pitch,
 #undef  COMPENSATE
 }
 
-void ff_ivi_dc_haar_2d(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_dc_haar_2d(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                        int blk_size)
 {
     int     x, y;
@@ -533,7 +533,7 @@ void ff_ivi_dc_haar_2d(const int32_t *in, int16_t *out, uint32_t pitch,
     d3 = COMPENSATE(t3);\
     d4 = COMPENSATE(t4);}
 
-void ff_ivi_inverse_slant_8x8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)
+void ff_ivi_inverse_slant_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
 {
     int     i;
     const int32_t *src;
@@ -573,7 +573,7 @@ void ff_ivi_inverse_slant_8x8(const int32_t *in, int16_t *out, uint32_t pitch, c
 #undef COMPENSATE
 }
 
-void ff_ivi_inverse_slant_4x4(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)
+void ff_ivi_inverse_slant_4x4(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
 {
     int     i;
     const int32_t *src;
@@ -613,7 +613,7 @@ void ff_ivi_inverse_slant_4x4(const int32_t *in, int16_t *out, uint32_t pitch, c
 #undef COMPENSATE
 }
 
-void ff_ivi_dc_slant_2d(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size)
+void ff_ivi_dc_slant_2d(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size)
 {
     int     x, y;
     int16_t dc_coeff;
@@ -626,7 +626,7 @@ void ff_ivi_dc_slant_2d(const int32_t *in, int16_t *out, uint32_t pitch, int blk
     }
 }
 
-void ff_ivi_row_slant8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)
+void ff_ivi_row_slant8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
 {
     int     i;
     int     t0, t1, t2, t3, t4, t5, t6, t7, t8;
@@ -646,7 +646,7 @@ void ff_ivi_row_slant8(const int32_t *in, int16_t *out, uint32_t pitch, const ui
 #undef COMPENSATE
 }
 
-void ff_ivi_dc_row_slant(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size)
+void ff_ivi_dc_row_slant(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size)
 {
     int     x, y;
     int16_t dc_coeff;
@@ -664,7 +664,7 @@ void ff_ivi_dc_row_slant(const int32_t *in, int16_t *out, uint32_t pitch, int bl
     }
 }
 
-void ff_ivi_col_slant8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)
+void ff_ivi_col_slant8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
 {
     int     i, row2, row4, row8;
     int     t0, t1, t2, t3, t4, t5, t6, t7, t8;
@@ -691,7 +691,7 @@ void ff_ivi_col_slant8(const int32_t *in, int16_t *out, uint32_t pitch, const ui
 #undef COMPENSATE
 }
 
-void ff_ivi_dc_col_slant(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size)
+void ff_ivi_dc_col_slant(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size)
 {
     int     x, y;
     int16_t dc_coeff;
@@ -705,7 +705,7 @@ void ff_ivi_dc_col_slant(const int32_t *in, int16_t *out, uint32_t pitch, int bl
     }
 }
 
-void ff_ivi_row_slant4(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)
+void ff_ivi_row_slant4(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
 {
     int     i;
     int     t0, t1, t2, t3, t4;
@@ -725,7 +725,7 @@ void ff_ivi_row_slant4(const int32_t *in, int16_t *out, uint32_t pitch, const ui
 #undef COMPENSATE
 }
 
-void ff_ivi_col_slant4(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags)
+void ff_ivi_col_slant4(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
 {
     int     i, row2;
     int     t0, t1, t2, t3, t4;
@@ -748,7 +748,7 @@ void ff_ivi_col_slant4(const int32_t *in, int16_t *out, uint32_t pitch, const ui
 #undef COMPENSATE
 }
 
-void ff_ivi_put_pixels_8x8(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_put_pixels_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                            const uint8_t *flags)
 {
     int     x, y;
@@ -758,7 +758,7 @@ void ff_ivi_put_pixels_8x8(const int32_t *in, int16_t *out, uint32_t pitch,
             out[x] = in[x];
 }
 
-void ff_ivi_put_dc_pixel_8x8(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_put_dc_pixel_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                              int blk_size)
 {
     int     y;
@@ -773,9 +773,9 @@ void ff_ivi_put_dc_pixel_8x8(const int32_t *in, int16_t *out, uint32_t pitch,
 
 #define IVI_MC_TEMPLATE(size, suffix, OP) \
 static void ivi_mc_ ## size ##x## size ## suffix(int16_t *buf, \
-                                                 uint32_t dpitch, \
+                                                 ptrdiff_t dpitch, \
                                                  const int16_t *ref_buf, \
-                                                 uint32_t pitch, int mc_type) \
+                                                 ptrdiff_t pitch, int mc_type) \
 { \
     int     i, j; \
     const int16_t *wptr; \
@@ -809,7 +809,7 @@ static void ivi_mc_ ## size ##x## size ## suffix(int16_t *buf, \
 } \
 \
 void ff_ivi_mc_ ## size ##x## size ## suffix(int16_t *buf, const int16_t *ref_buf, \
-                                             uint32_t pitch, int mc_type) \
+                                             ptrdiff_t pitch, int mc_type) \
 { \
     ivi_mc_ ## size ##x## size ## suffix(buf, pitch, ref_buf, pitch, mc_type); \
 } \
@@ -818,7 +818,7 @@ void ff_ivi_mc_ ## size ##x## size ## suffix(int16_t *buf, const int16_t *ref_bu
 void ff_ivi_mc_avg_ ## size ##x## size ## suffix(int16_t *buf, \
                                                  const int16_t *ref_buf, \
                                                  const int16_t *ref_buf2, \
-                                                 uint32_t pitch, \
+                                                 ptrdiff_t pitch, \
                                                  int mc_type, int mc_type2) \
 { \
     int16_t tmp[size * size]; \
diff --git a/mythtv/external/FFmpeg/libavcodec/ivi_dsp.h b/mythtv/external/FFmpeg/libavcodec/ivi_dsp.h
index c38bb3bb385..2704d2b9a54 100644
--- a/mythtv/external/FFmpeg/libavcodec/ivi_dsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/ivi_dsp.h
@@ -29,6 +29,7 @@
 #ifndef AVCODEC_IVI_DSP_H
 #define AVCODEC_IVI_DSP_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "ivi.h"
@@ -41,7 +42,7 @@
  *  @param[in]   dst_pitch    pitch of the destination buffer
  */
 void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,
-                        const int dst_pitch);
+                        const ptrdiff_t dst_pitch);
 
 /**
  *  Haar wavelet recomposition filter for Indeo 4
@@ -51,7 +52,7 @@ void ff_ivi_recompose53(const IVIPlaneDesc *plane, uint8_t *dst,
  *  @param[in]  dst_pitch    pitch of the destination buffer
  */
 void ff_ivi_recompose_haar(const IVIPlaneDesc *plane, uint8_t *dst,
-                           const int dst_pitch);
+                           const ptrdiff_t dst_pitch);
 
 /**
  *  two-dimensional inverse Haar 8x8 transform for Indeo 4
@@ -63,7 +64,7 @@ void ff_ivi_recompose_haar(const IVIPlaneDesc *plane, uint8_t *dst,
  *                        != 0 - non_empty column, 0 - empty one
  *                        (this array must be filled by caller)
  */
-void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                              const uint8_t *flags);
 void ff_ivi_inverse_haar_8x1(const int32_t *in, int16_t *out, uint32_t pitch,
                              const uint8_t *flags);
@@ -80,7 +81,7 @@ void ff_ivi_inverse_haar_1x8(const int32_t *in, int16_t *out, uint32_t pitch,
  *                        != 0 - non_empty column, 0 - empty one
  *                        (this array must be filled by caller)
  */
-void ff_ivi_row_haar8(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_row_haar8(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                       const uint8_t *flags);
 
 /**
@@ -93,7 +94,7 @@ void ff_ivi_row_haar8(const int32_t *in, int16_t *out, uint32_t pitch,
  *                        != 0 - non_empty column, 0 - empty one
  *                        (this array must be filled by caller)
  */
-void ff_ivi_col_haar8(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_col_haar8(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                       const uint8_t *flags);
 
 /**
@@ -106,7 +107,7 @@ void ff_ivi_col_haar8(const int32_t *in, int16_t *out, uint32_t pitch,
  *                        != 0 - non_empty column, 0 - empty one
  *                        (this array must be filled by caller)
  */
-void ff_ivi_inverse_haar_4x4(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_inverse_haar_4x4(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                              const uint8_t *flags);
 
 /**
@@ -119,7 +120,7 @@ void ff_ivi_inverse_haar_4x4(const int32_t *in, int16_t *out, uint32_t pitch,
  *                        != 0 - non_empty column, 0 - empty one
  *                        (this array must be filled by caller)
  */
-void ff_ivi_row_haar4(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_row_haar4(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                       const uint8_t *flags);
 
 /**
@@ -132,7 +133,7 @@ void ff_ivi_row_haar4(const int32_t *in, int16_t *out, uint32_t pitch,
  *                        != 0 - non_empty column, 0 - empty one
  *                        (this array must be filled by caller)
  */
-void ff_ivi_col_haar4(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_col_haar4(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                       const uint8_t *flags);
 
 /**
@@ -145,7 +146,7 @@ void ff_ivi_col_haar4(const int32_t *in, int16_t *out, uint32_t pitch,
  *  @param[in]  pitch       pitch to move to the next y line
  *  @param[in]  blk_size    transform block size
  */
-void ff_ivi_dc_haar_2d(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_dc_haar_2d(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                        int blk_size);
 
 /**
@@ -158,7 +159,7 @@ void ff_ivi_dc_haar_2d(const int32_t *in, int16_t *out, uint32_t pitch,
  *                        != 0 - non_empty column, 0 - empty one
  *                        (this array must be filled by caller)
  */
-void ff_ivi_inverse_slant_8x8(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_inverse_slant_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                               const uint8_t *flags);
 
 /**
@@ -171,7 +172,7 @@ void ff_ivi_inverse_slant_8x8(const int32_t *in, int16_t *out, uint32_t pitch,
  *                        != 0 - non_empty column, 0 - empty one
  *                        (this array must be filled by caller)
  */
-void ff_ivi_inverse_slant_4x4(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_inverse_slant_4x4(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                               const uint8_t *flags);
 
 /**
@@ -185,7 +186,7 @@ void ff_ivi_inverse_slant_4x4(const int32_t *in, int16_t *out, uint32_t pitch,
  *  @param[in]    pitch       pitch to move to the next y line
  *  @param[in]    blk_size    transform block size
  */
-void ff_ivi_dc_slant_2d(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size);
+void ff_ivi_dc_slant_2d(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size);
 
 /**
  *  inverse 1D row slant transform
@@ -195,7 +196,7 @@ void ff_ivi_dc_slant_2d(const int32_t *in, int16_t *out, uint32_t pitch, int blk
  *  @param[in]    pitch   pitch to move to the next y line
  *  @param[in]    flags   pointer to the array of column flags (unused here)
  */
-void ff_ivi_row_slant8(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_row_slant8(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                        const uint8_t *flags);
 
 /**
@@ -208,7 +209,7 @@ void ff_ivi_row_slant8(const int32_t *in, int16_t *out, uint32_t pitch,
  *                        != 0 - non_empty column, 0 - empty one
  *                        (this array must be filled by caller)
  */
-void ff_ivi_col_slant8(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_col_slant8(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                        const uint8_t *flags);
 
 /**
@@ -219,7 +220,7 @@ void ff_ivi_col_slant8(const int32_t *in, int16_t *out, uint32_t pitch,
  *  @param[in]    pitch   pitch to move to the next y line
  *  @param[in]    flags   pointer to the array of column flags (unused here)
  */
-void ff_ivi_row_slant4(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_row_slant4(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                        const uint8_t *flags);
 
 /**
@@ -232,29 +233,29 @@ void ff_ivi_row_slant4(const int32_t *in, int16_t *out, uint32_t pitch,
  *                        != 0 - non_empty column, 0 - empty one
  *                        (this array must be filled by caller)
  */
-void ff_ivi_col_slant4(const int32_t *in, int16_t *out, uint32_t pitch,
+void ff_ivi_col_slant4(const int32_t *in, int16_t *out, ptrdiff_t pitch,
                        const uint8_t *flags);
 
 /**
  *  DC-only inverse row slant transform
  */
-void ff_ivi_dc_row_slant(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size);
+void ff_ivi_dc_row_slant(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size);
 
 /**
  *  DC-only inverse column slant transform
  */
-void ff_ivi_dc_col_slant(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size);
+void ff_ivi_dc_col_slant(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size);
 
 /**
  *  Copy the pixels into the frame buffer.
  */
-void ff_ivi_put_pixels_8x8(const int32_t *in, int16_t *out, uint32_t pitch, const uint8_t *flags);
+void ff_ivi_put_pixels_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags);
 
 /**
  *  Copy the DC coefficient into the first pixel of the block and
  *  zero all others.
  */
-void ff_ivi_put_dc_pixel_8x8(const int32_t *in, int16_t *out, uint32_t pitch, int blk_size);
+void ff_ivi_put_dc_pixel_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size);
 
 /**
  *  8x8 block motion compensation with adding delta
@@ -264,7 +265,7 @@ void ff_ivi_put_dc_pixel_8x8(const int32_t *in, int16_t *out, uint32_t pitch, in
  *  @param[in]       pitch    pitch for moving to the next y line
  *  @param[in]       mc_type  interpolation type
  */
-void ff_ivi_mc_8x8_delta(int16_t *buf, const int16_t *ref_buf, uint32_t pitch, int mc_type);
+void ff_ivi_mc_8x8_delta(int16_t *buf, const int16_t *ref_buf, ptrdiff_t pitch, int mc_type);
 
 /**
  *  4x4 block motion compensation with adding delta
@@ -274,7 +275,7 @@ void ff_ivi_mc_8x8_delta(int16_t *buf, const int16_t *ref_buf, uint32_t pitch, i
  *  @param[in]       pitch    pitch for moving to the next y line
  *  @param[in]       mc_type  interpolation type
  */
-void ff_ivi_mc_4x4_delta(int16_t *buf, const int16_t *ref_buf, uint32_t pitch, int mc_type);
+void ff_ivi_mc_4x4_delta(int16_t *buf, const int16_t *ref_buf, ptrdiff_t pitch, int mc_type);
 
 /**
  *  motion compensation without adding delta
@@ -284,7 +285,7 @@ void ff_ivi_mc_4x4_delta(int16_t *buf, const int16_t *ref_buf, uint32_t pitch, i
  *  @param[in]      pitch    pitch for moving to the next y line
  *  @param[in]      mc_type  interpolation type
  */
-void ff_ivi_mc_8x8_no_delta(int16_t *buf, const int16_t *ref_buf, uint32_t pitch, int mc_type);
+void ff_ivi_mc_8x8_no_delta(int16_t *buf, const int16_t *ref_buf, ptrdiff_t pitch, int mc_type);
 
 /**
  *  4x4 block motion compensation without adding delta
@@ -294,7 +295,7 @@ void ff_ivi_mc_8x8_no_delta(int16_t *buf, const int16_t *ref_buf, uint32_t pitch
  *  @param[in]      pitch    pitch for moving to the next y line
  *  @param[in]      mc_type  interpolation type
  */
-void ff_ivi_mc_4x4_no_delta(int16_t *buf, const int16_t *ref_buf, uint32_t pitch, int mc_type);
+void ff_ivi_mc_4x4_no_delta(int16_t *buf, const int16_t *ref_buf, ptrdiff_t pitch, int mc_type);
 
 /**
  *  8x8 block motion compensation with adding delta
@@ -306,7 +307,7 @@ void ff_ivi_mc_4x4_no_delta(int16_t *buf, const int16_t *ref_buf, uint32_t pitch
  *  @param[in]      mc_type  interpolation type for backward reference
  *  @param[in]      mc_type2 interpolation type for forward reference
  */
-void ff_ivi_mc_avg_8x8_delta(int16_t *buf, const int16_t *ref_buf, const int16_t *ref_buf2, uint32_t pitch, int mc_type, int mc_type2);
+void ff_ivi_mc_avg_8x8_delta(int16_t *buf, const int16_t *ref_buf, const int16_t *ref_buf2, ptrdiff_t pitch, int mc_type, int mc_type2);
 
 /**
  *  4x4 block motion compensation with adding delta
@@ -318,7 +319,7 @@ void ff_ivi_mc_avg_8x8_delta(int16_t *buf, const int16_t *ref_buf, const int16_t
  *  @param[in]      mc_type  interpolation type for backward reference
  *  @param[in]      mc_type2 interpolation type for forward reference
  */
-void ff_ivi_mc_avg_4x4_delta(int16_t *buf, const int16_t *ref_buf, const int16_t *ref_buf2, uint32_t pitch, int mc_type, int mc_type2);
+void ff_ivi_mc_avg_4x4_delta(int16_t *buf, const int16_t *ref_buf, const int16_t *ref_buf2, ptrdiff_t pitch, int mc_type, int mc_type2);
 
 /**
  *  motion compensation without adding delta for B-frames
@@ -330,7 +331,7 @@ void ff_ivi_mc_avg_4x4_delta(int16_t *buf, const int16_t *ref_buf, const int16_t
  *  @param[in]      mc_type  interpolation type for backward reference
  *  @param[in]      mc_type2 interpolation type for forward reference
  */
-void ff_ivi_mc_avg_8x8_no_delta(int16_t *buf, const int16_t *ref_buf, const int16_t *ref_buf2, uint32_t pitch, int mc_type, int mc_type2);
+void ff_ivi_mc_avg_8x8_no_delta(int16_t *buf, const int16_t *ref_buf, const int16_t *ref_buf2, ptrdiff_t pitch, int mc_type, int mc_type2);
 
 /**
  *  4x4 block motion compensation without adding delta for B-frames
@@ -342,6 +343,6 @@ void ff_ivi_mc_avg_8x8_no_delta(int16_t *buf, const int16_t *ref_buf, const int1
  *  @param[in]      mc_type  interpolation type for backward reference
  *  @param[in]      mc_type2 interpolation type for forward reference
  */
-void ff_ivi_mc_avg_4x4_no_delta(int16_t *buf, const int16_t *ref_buf, const int16_t *ref_buf2, uint32_t pitch, int mc_type, int mc_type2);
+void ff_ivi_mc_avg_4x4_no_delta(int16_t *buf, const int16_t *ref_buf, const int16_t *ref_buf2, ptrdiff_t pitch, int mc_type, int mc_type2);
 
 #endif /* AVCODEC_IVI_DSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/j2kenc.c b/mythtv/external/FFmpeg/libavcodec/j2kenc.c
index c8d38617327..baaf47422c6 100644
--- a/mythtv/external/FFmpeg/libavcodec/j2kenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/j2kenc.c
@@ -688,7 +688,8 @@ static void encode_cblk(Jpeg2000EncoderContext *s, Jpeg2000T1Context *t1, Jpeg20
     cblk->npasses = passno;
     cblk->ninclpasses = passno;
 
-    cblk->passes[passno-1].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno-1].flushed, &cblk->passes[passno-1].flushed_len);
+    if (passno)
+        cblk->passes[passno-1].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno-1].flushed, &cblk->passes[passno-1].flushed_len);
 }
 
 /* tier-2 routines: */
diff --git a/mythtv/external/FFmpeg/libavcodec/jfdctint_template.c b/mythtv/external/FFmpeg/libavcodec/jfdctint_template.c
index 3ea2f5dadc4..67fb77b5e12 100644
--- a/mythtv/external/FFmpeg/libavcodec/jfdctint_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/jfdctint_template.c
@@ -69,12 +69,7 @@
 #define GLOBAL(x) x
 #define RIGHT_SHIFT(x, n) ((x) >> (n))
 #define MULTIPLY16C16(var,const) ((var)*(const))
-
-#if 1 //def USE_ACCURATE_ROUNDING
 #define DESCALE(x,n)  RIGHT_SHIFT((x) + (1 << ((n) - 1)), n)
-#else
-#define DESCALE(x,n)  RIGHT_SHIFT(x, n)
-#endif
 
 
 /*
diff --git a/mythtv/external/FFmpeg/libavcodec/jpeg2000.c b/mythtv/external/FFmpeg/libavcodec/jpeg2000.c
index 94efc94c4df..afeb9df27c4 100644
--- a/mythtv/external/FFmpeg/libavcodec/jpeg2000.c
+++ b/mythtv/external/FFmpeg/libavcodec/jpeg2000.c
@@ -506,6 +506,9 @@ int ff_jpeg2000_init_component(Jpeg2000Component *comp,
         // update precincts size: 2^n value
         reslevel->log2_prec_width  = codsty->log2_prec_widths[reslevelno];
         reslevel->log2_prec_height = codsty->log2_prec_heights[reslevelno];
+        if (!reslevel->log2_prec_width || !reslevel->log2_prec_height) {
+            return AVERROR_INVALIDDATA;
+        }
 
         /* Number of bands for each resolution level */
         if (reslevelno == 0)
diff --git a/mythtv/external/FFmpeg/libavcodec/jpeg2000.h b/mythtv/external/FFmpeg/libavcodec/jpeg2000.h
index ed3b421ad81..8a022ad9188 100644
--- a/mythtv/external/FFmpeg/libavcodec/jpeg2000.h
+++ b/mythtv/external/FFmpeg/libavcodec/jpeg2000.h
@@ -215,12 +215,12 @@ typedef struct Jpeg2000Component {
 /* misc tools */
 static inline int ff_jpeg2000_ceildivpow2(int a, int b)
 {
-    return -(((int64_t)(-a)) >> b);
+    return -((-(int64_t)a) >> b);
 }
 
 static inline int ff_jpeg2000_ceildiv(int a, int b)
 {
-    return (a + b - 1) / b;
+    return (a + (int64_t)b - 1) / b;
 }
 
 /* TIER-1 routines */
diff --git a/mythtv/external/FFmpeg/libavcodec/jpeg2000dec.c b/mythtv/external/FFmpeg/libavcodec/jpeg2000dec.c
index e9f5f51af32..9a5e64e8540 100644
--- a/mythtv/external/FFmpeg/libavcodec/jpeg2000dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/jpeg2000dec.c
@@ -26,6 +26,7 @@
  */
 
 #include <inttypes.h>
+#include <math.h>
 
 #include "libavutil/attributes.h"
 #include "libavutil/avassert.h"
@@ -106,6 +107,7 @@ typedef struct Jpeg2000DecoderContext {
     int             tile_width, tile_height;
     unsigned        numXtiles, numYtiles;
     int             maxtilelen;
+    AVRational      sar;
 
     Jpeg2000CodingStyle codsty[4];
     Jpeg2000QuantStyle  qntsty[4];
@@ -260,6 +262,7 @@ static int get_siz(Jpeg2000DecoderContext *s)
     uint32_t log2_chroma_wh = 0;
     const enum AVPixelFormat *possible_fmts = NULL;
     int possible_fmts_nb = 0;
+    int ret;
 
     if (bytestream2_get_bytes_left(&s->g) < 36) {
         av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
@@ -298,6 +301,16 @@ static int get_siz(Jpeg2000DecoderContext *s)
         return AVERROR_PATCHWELCOME;
     }
 
+    if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
+        s->image_offset_x < s->tile_offset_x ||
+        s->image_offset_y < s->tile_offset_y ||
+        s->tile_width  + (int64_t)s->tile_offset_x <= s->image_offset_x ||
+        s->tile_height + (int64_t)s->tile_offset_y <= s->image_offset_y
+    ) {
+        av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
+        return AVERROR_INVALIDDATA;
+    }
+
     s->ncomponents = ncomponents;
 
     if (s->tile_width <= 0 || s->tile_height <= 0) {
@@ -349,10 +362,13 @@ static int get_siz(Jpeg2000DecoderContext *s)
     }
 
     /* compute image size with reduction factor */
-    s->avctx->width  = ff_jpeg2000_ceildivpow2(s->width  - s->image_offset_x,
-                                               s->reduction_factor);
-    s->avctx->height = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
-                                               s->reduction_factor);
+    ret = ff_set_dimensions(s->avctx,
+            ff_jpeg2000_ceildivpow2(s->width  - s->image_offset_x,
+                                               s->reduction_factor),
+            ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
+                                               s->reduction_factor));
+    if (ret < 0)
+        return ret;
 
     if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
         s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
@@ -946,9 +962,9 @@ static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
             if (!cblk->npasses) {
                 int v = expn[bandno] + numgbits - 1 -
                         tag_tree_decode(s, prec->zerobits + cblkno, 100);
-                if (v < 0) {
+                if (v < 0 || v > 30) {
                     av_log(s->avctx, AV_LOG_ERROR,
-                           "nonzerobits %d invalid\n", v);
+                           "nonzerobits %d invalid or unsupported\n", v);
                     return AVERROR_INVALIDDATA;
                 }
                 cblk->nonzerobits = v;
@@ -1982,6 +1998,7 @@ static int jp2_find_codestream(Jpeg2000DecoderContext *s)
                 atom2_end  = bytestream2_tell(&s->g) + atom2_size - 8;
                 if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
                     break;
+                atom2_size -= 8;
                 if (atom2 == JP2_CODESTREAM) {
                     return 1;
                 } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
@@ -2043,6 +2060,39 @@ static int jp2_find_codestream(Jpeg2000DecoderContext *s)
                         if (cn < 4 && asoc < 4)
                             s->cdef[cn] = asoc;
                     }
+                } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
+                    int64_t vnum, vden, hnum, hden, vexp, hexp;
+                    uint32_t resx;
+                    bytestream2_skip(&s->g, 4);
+                    resx = bytestream2_get_be32u(&s->g);
+                    if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
+                        bytestream2_seek(&s->g, atom2_end, SEEK_SET);
+                        continue;
+                    }
+                    vnum = bytestream2_get_be16u(&s->g);
+                    vden = bytestream2_get_be16u(&s->g);
+                    hnum = bytestream2_get_be16u(&s->g);
+                    hden = bytestream2_get_be16u(&s->g);
+                    vexp = bytestream2_get_byteu(&s->g);
+                    hexp = bytestream2_get_byteu(&s->g);
+                    if (!vnum || !vden || !hnum || !hden) {
+                        bytestream2_seek(&s->g, atom2_end, SEEK_SET);
+                        av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
+                        continue;
+                    }
+                    if (vexp > hexp) {
+                        vexp -= hexp;
+                        hexp = 0;
+                    } else {
+                        hexp -= vexp;
+                        vexp = 0;
+                    }
+                    if (   INT64_MAX / (hnum * vden) > pow(10, hexp)
+                        && INT64_MAX / (vnum * hden) > pow(10, vexp))
+                        av_reduce(&s->sar.den, &s->sar.num,
+                                  hnum * vden * pow(10, hexp),
+                                  vnum * hden * pow(10, vexp),
+                                  INT32_MAX);
                 }
                 bytestream2_seek(&s->g, atom2_end, SEEK_SET);
             } while (atom_end - atom2_end >= 8);
@@ -2125,6 +2175,9 @@ static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
 
     if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
         memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
+    if (s->sar.num && s->sar.den)
+        avctx->sample_aspect_ratio = s->sar;
+    s->sar.num = s->sar.den = 0;
 
     return bytestream2_tell(&s->g);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/jpeg2000dsp.c b/mythtv/external/FFmpeg/libavcodec/jpeg2000dsp.c
index d183cbb87dc..85a12d0e9b7 100644
--- a/mythtv/external/FFmpeg/libavcodec/jpeg2000dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/jpeg2000dsp.c
@@ -64,10 +64,10 @@ static void ict_int(void *_src0, void *_src1, void *_src2, int csize)
     int i;
 
     for (i = 0; i < csize; i++) {
-        i0 = *src0 + (((i_ict_params[0] * *src2) + (1 << 15)) >> 16);
-        i1 = *src0 - (((i_ict_params[1] * *src1) + (1 << 15)) >> 16)
+        i0 = *src0 + *src2 + (((26345 * *src2) + (1 << 15)) >> 16);
+        i1 = *src0 - ((int)(((unsigned)i_ict_params[1] * *src1) + (1 << 15)) >> 16)
                    - (((i_ict_params[2] * *src2) + (1 << 15)) >> 16);
-        i2 = *src0 + (((i_ict_params[3] * *src1) + (1 << 15)) >> 16);
+        i2 = *src0 + (2 * *src1) + ((int)((-14942U * *src1) + (1 << 15)) >> 16);
         *src0++ = i0;
         *src1++ = i1;
         *src2++ = i2;
diff --git a/mythtv/external/FFmpeg/libavcodec/jpeg2000dwt.c b/mythtv/external/FFmpeg/libavcodec/jpeg2000dwt.c
index 188cc261a41..55dd5e89b52 100644
--- a/mythtv/external/FFmpeg/libavcodec/jpeg2000dwt.c
+++ b/mythtv/external/FFmpeg/libavcodec/jpeg2000dwt.c
@@ -464,16 +464,16 @@ static void sr_1d97_int(int32_t *p, int i0, int i1)
     extend97_int(p, i0, i1);
 
     for (i = (i0 >> 1) - 1; i < (i1 >> 1) + 2; i++)
-        p[2 * i]     -= (I_LFTG_DELTA * (p[2 * i - 1] + p[2 * i + 1]) + (1 << 15)) >> 16;
+        p[2 * i]     -= (I_LFTG_DELTA * (p[2 * i - 1] + (int64_t)p[2 * i + 1]) + (1 << 15)) >> 16;
     /* step 4 */
     for (i = (i0 >> 1) - 1; i < (i1 >> 1) + 1; i++)
-        p[2 * i + 1] -= (I_LFTG_GAMMA * (p[2 * i]     + p[2 * i + 2]) + (1 << 15)) >> 16;
+        p[2 * i + 1] -= (I_LFTG_GAMMA * (p[2 * i]     + (int64_t)p[2 * i + 2]) + (1 << 15)) >> 16;
     /*step 5*/
     for (i = (i0 >> 1); i < (i1 >> 1) + 1; i++)
-        p[2 * i]     += (I_LFTG_BETA  * (p[2 * i - 1] + p[2 * i + 1]) + (1 << 15)) >> 16;
+        p[2 * i]     += (I_LFTG_BETA  * (p[2 * i - 1] + (int64_t)p[2 * i + 1]) + (1 << 15)) >> 16;
     /* step 6 */
     for (i = (i0 >> 1); i < (i1 >> 1); i++)
-        p[2 * i + 1] += (I_LFTG_ALPHA * (p[2 * i]     + p[2 * i + 2]) + (1 << 15)) >> 16;
+        p[2 * i + 1] += (I_LFTG_ALPHA * (p[2 * i]     + (int64_t)p[2 * i + 2]) + (1 << 15)) >> 16;
 }
 
 static void dwt_decode97_int(DWTContext *s, int32_t *t)
@@ -488,7 +488,7 @@ static void dwt_decode97_int(DWTContext *s, int32_t *t)
     line += 5;
 
     for (i = 0; i < w * h; i++)
-        data[i] <<= I_PRESHIFT;
+        data[i] *= 1LL << I_PRESHIFT;
 
     for (lev = 0; lev < s->ndeclevels; lev++) {
         int lh = s->linelen[lev][0],
diff --git a/mythtv/external/FFmpeg/libavcodec/jpeglsdec.c b/mythtv/external/FFmpeg/libavcodec/jpeglsdec.c
index 68151cbbd8e..5308b744df1 100644
--- a/mythtv/external/FFmpeg/libavcodec/jpeglsdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/jpeglsdec.c
@@ -233,6 +233,9 @@ static inline void ls_decode_line(JLSState *state, MJpegDecodeContext *s,
     while (x < w) {
         int err, pred;
 
+        if (get_bits_left(&s->gb) <= 0)
+            return;
+
         /* compute gradients */
         Ra = x ? R(dst, x - stride) : R(last, x);
         Rb = R(last, x);
@@ -375,6 +378,11 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near,
     else
         shift = point_transform + (16 - s->bits);
 
+    if (shift >= 16) {
+        ret = AVERROR_INVALIDDATA;
+        goto end;
+    }
+
     if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
         av_log(s->avctx, AV_LOG_DEBUG,
                "JPEG-LS params: %ix%i NEAR=%i MV=%i T(%i,%i,%i) "
@@ -385,6 +393,10 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near,
         av_log(s->avctx, AV_LOG_DEBUG, "JPEG params: ILV=%i Pt=%i BPP=%i, scan = %i\n",
                 ilv, point_transform, s->bits, s->cur_scan);
     }
+    if (get_bits_left(&s->gb) < s->height) {
+        ret = AVERROR_INVALIDDATA;
+        goto end;
+    }
     if (ilv == 0) { /* separate planes */
         if (s->cur_scan > s->nb_components) {
             ret = AVERROR_INVALIDDATA;
@@ -434,6 +446,10 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near,
         avpriv_report_missing_feature(s->avctx, "Sample interleaved images");
         ret = AVERROR_PATCHWELCOME;
         goto end;
+    } else { /* unknown interleaving */
+        avpriv_report_missing_feature(s->avctx, "Unknown interleaved images");
+        ret = AVERROR_PATCHWELCOME;
+        goto end;
     }
 
     if (s->xfrm && s->nb_components == 3) {
diff --git a/mythtv/external/FFmpeg/libavcodec/jrevdct.c b/mythtv/external/FFmpeg/libavcodec/jrevdct.c
index 55a7392e98d..3b15a526770 100644
--- a/mythtv/external/FFmpeg/libavcodec/jrevdct.c
+++ b/mythtv/external/FFmpeg/libavcodec/jrevdct.c
@@ -1156,14 +1156,14 @@ void ff_j_rev_dct1(DCTBLOCK data){
 #undef FIX
 #undef CONST_BITS
 
-void ff_jref_idct_put(uint8_t *dest, int line_size, int16_t *block)
+void ff_jref_idct_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     ff_j_rev_dct(block);
-    ff_put_pixels_clamped(block, dest, line_size);
+    ff_put_pixels_clamped_c(block, dest, line_size);
 }
 
-void ff_jref_idct_add(uint8_t *dest, int line_size, int16_t *block)
+void ff_jref_idct_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     ff_j_rev_dct(block);
-    ff_add_pixels_clamped(block, dest, line_size);
+    ff_add_pixels_clamped_c(block, dest, line_size);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/kgv1dec.c b/mythtv/external/FFmpeg/libavcodec/kgv1dec.c
index 5359411c761..a6bd9400ac1 100644
--- a/mythtv/external/FFmpeg/libavcodec/kgv1dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/kgv1dec.c
@@ -62,6 +62,9 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     h = (buf[1] + 1) * 8;
     buf += 2;
 
+    if (avpkt->size < 2 + w*h / 513)
+        return AVERROR_INVALIDDATA;
+
     if (w != avctx->width || h != avctx->height) {
         av_freep(&c->frame_buffer);
         av_freep(&c->last_frame_buffer);
diff --git a/mythtv/external/FFmpeg/libavcodec/kmvc.c b/mythtv/external/FFmpeg/libavcodec/kmvc.c
index 7acaba7d21c..ffe6a142e97 100644
--- a/mythtv/external/FFmpeg/libavcodec/kmvc.c
+++ b/mythtv/external/FFmpeg/libavcodec/kmvc.c
@@ -268,7 +268,8 @@ static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame,
     int i, ret;
     int header;
     int blocksize;
-    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
+    int pal_size;
+    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &pal_size);
 
     bytestream2_init(&ctx->g, avpkt->data, avpkt->size);
 
@@ -303,9 +304,11 @@ static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame,
         }
     }
 
-    if (pal) {
+    if (pal && pal_size == AVPALETTE_SIZE) {
         frame->palette_has_changed = 1;
         memcpy(ctx->pal, pal, AVPALETTE_SIZE);
+    } else if (pal) {
+        av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", pal_size);
     }
 
     if (ctx->setpal) {
diff --git a/mythtv/external/FFmpeg/libavcodec/lagarith.c b/mythtv/external/FFmpeg/libavcodec/lagarith.c
index 93d13448c95..0f4aa89486e 100644
--- a/mythtv/external/FFmpeg/libavcodec/lagarith.c
+++ b/mythtv/external/FFmpeg/libavcodec/lagarith.c
@@ -30,8 +30,8 @@
 #include "avcodec.h"
 #include "get_bits.h"
 #include "mathops.h"
-#include "huffyuvdsp.h"
 #include "lagarithrac.h"
+#include "lossless_videodsp.h"
 #include "thread.h"
 
 enum LagarithFrameType {
@@ -50,7 +50,7 @@ enum LagarithFrameType {
 
 typedef struct LagarithContext {
     AVCodecContext *avctx;
-    HuffYUVDSPContext hdsp;
+    LLVidDSPContext llviddsp;
     int zeros;                  /**< number of consecutive zero bytes encountered */
     int zeros_rem;              /**< number of zero bytes remaining to output */
     uint8_t *rgb_planes;
@@ -91,14 +91,14 @@ static uint32_t softfloat_mul(uint32_t x, uint64_t mantissa)
     uint64_t h = x * (mantissa >> 32);
     h += l >> 32;
     l &= 0xffffffff;
-    l += 1 << av_log2(h >> 21);
+    l += 1LL << av_log2(h >> 21);
     h += l >> 32;
     return h >> 20;
 }
 
 static uint8_t lag_calc_zero_run(int8_t x)
 {
-    return (x << 1) ^ (x >> 7);
+    return (x * 2) ^ (x >> 7);
 }
 
 static int lag_decode_prob(GetBitContext *gb, uint32_t *value)
@@ -191,7 +191,9 @@ static int lag_read_prob_header(lag_rac *rac, GetBitContext *gb)
         }
 
         scale_factor++;
-        cumulative_target = 1 << scale_factor;
+        if (scale_factor >= 32U)
+            return AVERROR_INVALIDDATA;
+        cumulative_target = 1U << scale_factor;
 
         if (scaled_cumul_prob > cumulative_target) {
             av_log(rac->avctx, AV_LOG_ERROR,
@@ -260,7 +262,7 @@ static void lag_pred_line(LagarithContext *l, uint8_t *buf,
 
     if (!line) {
         /* Left prediction only for first line */
-        L = l->hdsp.add_hfyu_left_pred(buf, buf, width, 0);
+        L = l->llviddsp.add_left_pred(buf, buf, width, 0);
     } else {
         /* Left pixel is actually prev_row[width] */
         L = buf[width - stride - 1];
@@ -289,7 +291,7 @@ static void lag_pred_line_yuy2(LagarithContext *l, uint8_t *buf,
         L= buf[0];
         if (is_luma)
             buf[0] = 0;
-        l->hdsp.add_hfyu_left_pred(buf, buf, width, 0);
+        l->llviddsp.add_left_pred(buf, buf, width, 0);
         if (is_luma)
             buf[0] = L;
         return;
@@ -312,7 +314,7 @@ static void lag_pred_line_yuy2(LagarithContext *l, uint8_t *buf,
     } else {
         TL = buf[width - (2 * stride) - 1];
         L  = buf[width - stride - 1];
-        l->hdsp.add_hfyu_median_pred(buf, buf - stride, buf, width, &L, &TL);
+        l->llviddsp.add_median_pred(buf, buf - stride, buf, width, &L, &TL);
     }
 }
 
@@ -453,10 +455,12 @@ static int lag_decode_arith_plane(LagarithContext *l, uint8_t *dst,
             return -1;
 
         ff_lag_rac_init(&rac, &gb, length - stride);
-
-        for (i = 0; i < height; i++)
+        for (i = 0; i < height; i++) {
+            if (rac.overread > MAX_OVERREAD)
+                return AVERROR_INVALIDDATA;
             read += lag_decode_line(l, &rac, dst + (i * stride), width,
                                     stride, esc_count);
+        }
 
         if (read > length)
             av_log(l->avctx, AV_LOG_WARNING,
@@ -725,10 +729,20 @@ static av_cold int lag_decode_init(AVCodecContext *avctx)
     LagarithContext *l = avctx->priv_data;
     l->avctx = avctx;
 
-    ff_huffyuvdsp_init(&l->hdsp);
+    ff_llviddsp_init(&l->llviddsp);
+
+    return 0;
+}
+
+#if HAVE_THREADS
+static av_cold int lag_decode_init_thread_copy(AVCodecContext *avctx)
+{
+    LagarithContext *l = avctx->priv_data;
+    l->avctx = avctx;
 
     return 0;
 }
+#endif
 
 static av_cold int lag_decode_end(AVCodecContext *avctx)
 {
@@ -746,6 +760,7 @@ AVCodec ff_lagarith_decoder = {
     .id             = AV_CODEC_ID_LAGARITH,
     .priv_data_size = sizeof(LagarithContext),
     .init           = lag_decode_init,
+    .init_thread_copy = ONLY_IF_THREADS_ENABLED(lag_decode_init_thread_copy),
     .close          = lag_decode_end,
     .decode         = lag_decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
diff --git a/mythtv/external/FFmpeg/libavcodec/lagarithrac.c b/mythtv/external/FFmpeg/libavcodec/lagarithrac.c
index 3d36d1b9e99..cdda67fb815 100644
--- a/mythtv/external/FFmpeg/libavcodec/lagarithrac.c
+++ b/mythtv/external/FFmpeg/libavcodec/lagarithrac.c
@@ -46,6 +46,7 @@ void ff_lag_rac_init(lag_rac *l, GetBitContext *gb, int length)
     l->range        = 0x80;
     l->low          = *l->bytestream >> 1;
     l->hash_shift   = FFMAX(l->scale, 10) - 10;
+    l->overread     = 0;
 
     for (i = j = 0; i < 1024; i++) {
         unsigned r = i << l->hash_shift;
diff --git a/mythtv/external/FFmpeg/libavcodec/lagarithrac.h b/mythtv/external/FFmpeg/libavcodec/lagarithrac.h
index dfdfea0db38..ee836d01db4 100644
--- a/mythtv/external/FFmpeg/libavcodec/lagarithrac.h
+++ b/mythtv/external/FFmpeg/libavcodec/lagarithrac.h
@@ -47,6 +47,9 @@ typedef struct lag_rac {
     const uint8_t *bytestream;        /**< Current position in input bytestream. */
     const uint8_t *bytestream_end;    /**< End position of input bytestream. */
 
+    int overread;
+#define MAX_OVERREAD 4
+
     uint32_t prob[258];         /**< Table of cumulative probability for each symbol. */
     uint8_t  range_hash[1024];   /**< Hash table mapping upper byte to approximate symbol. */
 } lag_rac;
@@ -62,6 +65,8 @@ static inline void lag_rac_refill(lag_rac *l)
         l->low |= 0xff & (AV_RB16(l->bytestream) >> 1);
         if (l->bytestream < l->bytestream_end)
             l->bytestream++;
+        else
+            l->overread++;
     }
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/lcldec.c b/mythtv/external/FFmpeg/libavcodec/lcldec.c
index b1335e1d2f8..104defa5f57 100644
--- a/mythtv/external/FFmpeg/libavcodec/lcldec.c
+++ b/mythtv/external/FFmpeg/libavcodec/lcldec.c
@@ -46,6 +46,7 @@
 #include "bytestream.h"
 #include "internal.h"
 #include "lcl.h"
+#include "thread.h"
 
 #if CONFIG_ZLIB_DECODER
 #include <zlib.h>
@@ -157,6 +158,7 @@ static int zlib_decomp(AVCodecContext *avctx, const uint8_t *src, int src_len, i
 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
 {
     AVFrame *frame = data;
+    ThreadFrame tframe = { .f = data };
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     LclDecContext * const c = avctx->priv_data;
@@ -173,7 +175,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
     unsigned int len = buf_size;
     int linesize;
 
-    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
+    if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
         return ret;
 
     outptr = frame->data[0]; // Output image pointer
@@ -458,6 +460,9 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
         return AVERROR_INVALIDDATA;
     }
 
+    frame->key_frame = 1;
+    frame->pict_type = AV_PICTURE_TYPE_I;
+
     *got_frame = 1;
 
     /* always report that the buffer was completely consumed */
@@ -618,6 +623,13 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
+#if HAVE_THREADS
+static int init_thread_copy(AVCodecContext *avctx)
+{
+    return decode_init(avctx);
+}
+#endif
+
 static av_cold int decode_end(AVCodecContext *avctx)
 {
     LclDecContext * const c = avctx->priv_data;
@@ -639,9 +651,11 @@ AVCodec ff_mszh_decoder = {
     .id             = AV_CODEC_ID_MSZH,
     .priv_data_size = sizeof(LclDecContext),
     .init           = decode_init,
+    .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
     .close          = decode_end,
     .decode         = decode_frame,
-    .capabilities   = AV_CODEC_CAP_DR1,
+    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
 #endif
 
@@ -653,8 +667,10 @@ AVCodec ff_zlib_decoder = {
     .id             = AV_CODEC_ID_ZLIB,
     .priv_data_size = sizeof(LclDecContext),
     .init           = decode_init,
+    .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
     .close          = decode_end,
     .decode         = decode_frame,
-    .capabilities   = AV_CODEC_CAP_DR1,
+    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/libfdk-aacdec.c b/mythtv/external/FFmpeg/libavcodec/libfdk-aacdec.c
index e5f7c4ebdc9..2857b9453f9 100644
--- a/mythtv/external/FFmpeg/libavcodec/libfdk-aacdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/libfdk-aacdec.c
@@ -325,7 +325,7 @@ static int fdk_aac_decode_frame(AVCodecContext *avctx, void *data,
         return AVERROR_INVALIDDATA;
     }
 
-    err = aacDecoder_DecodeFrame(s->handle, (INT_PCM *) s->decoder_buffer, s->decoder_buffer_size, 0);
+    err = aacDecoder_DecodeFrame(s->handle, (INT_PCM *) s->decoder_buffer, s->decoder_buffer_size / sizeof(INT_PCM), 0);
     if (err == AAC_DEC_NOT_ENOUGH_BITS) {
         ret = avpkt->size - valid;
         goto end;
diff --git a/mythtv/external/FFmpeg/libavcodec/libfdk-aacenc.c b/mythtv/external/FFmpeg/libavcodec/libfdk-aacenc.c
index 98a817b537e..0e2051b468a 100644
--- a/mythtv/external/FFmpeg/libavcodec/libfdk-aacenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/libfdk-aacenc.c
@@ -216,7 +216,7 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
         if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATE,
                                        avctx->bit_rate)) != AACENC_OK) {
             av_log(avctx, AV_LOG_ERROR, "Unable to set the bitrate %"PRId64": %s\n",
-                   (int64_t)avctx->bit_rate, aac_get_error(err));
+                   avctx->bit_rate, aac_get_error(err));
             goto error;
         }
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/libgsmenc.c b/mythtv/external/FFmpeg/libavcodec/libgsmenc.c
index 69ce439ec1d..e25db951810 100644
--- a/mythtv/external/FFmpeg/libavcodec/libgsmenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/libgsmenc.c
@@ -63,7 +63,7 @@ static av_cold int libgsm_encode_init(AVCodecContext *avctx) {
         avctx->bit_rate != 13200 /* Very common */ &&
         avctx->bit_rate != 0 /* Unknown; a.o. mov does not set bitrate when decoding */ ) {
         av_log(avctx, AV_LOG_ERROR, "Bitrate 13000bps required for GSM, got %"PRId64"bps\n",
-               (int64_t)avctx->bit_rate);
+               avctx->bit_rate);
         if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)
             return -1;
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/libkvazaar.c b/mythtv/external/FFmpeg/libavcodec/libkvazaar.c
index 79fde41bfbb..f35b0df61d5 100644
--- a/mythtv/external/FFmpeg/libavcodec/libkvazaar.c
+++ b/mythtv/external/FFmpeg/libavcodec/libkvazaar.c
@@ -21,13 +21,17 @@
  */
 
 #include <kvazaar.h>
+#include <stdint.h>
 #include <string.h>
 
+#include "libavutil/attributes.h"
 #include "libavutil/avassert.h"
 #include "libavutil/dict.h"
 #include "libavutil/error.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/internal.h"
+#include "libavutil/log.h"
+#include "libavutil/mem.h"
 #include "libavutil/pixdesc.h"
 #include "libavutil/opt.h"
 
diff --git a/mythtv/external/FFmpeg/libavcodec/libmp3lame.c b/mythtv/external/FFmpeg/libavcodec/libmp3lame.c
index e55aa8537a7..5e26743f297 100644
--- a/mythtv/external/FFmpeg/libavcodec/libmp3lame.c
+++ b/mythtv/external/FFmpeg/libavcodec/libmp3lame.c
@@ -125,6 +125,10 @@ static av_cold int mp3lame_encode_init(AVCodecContext *avctx)
         }
     }
 
+    /* lowpass cutoff frequency */
+    if (avctx->cutoff)
+        lame_set_lowpassfreq(s->gfp, avctx->cutoff);
+
     /* do not get a Xing VBR header frame from LAME */
     lame_set_bWriteVbrTag(s->gfp,0);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/libopenh264dec.c b/mythtv/external/FFmpeg/libavcodec/libopenh264dec.c
index ab0a84c6981..d12e7151172 100644
--- a/mythtv/external/FFmpeg/libavcodec/libopenh264dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/libopenh264dec.c
@@ -35,28 +35,15 @@
 
 typedef struct SVCContext {
     ISVCDecoder *decoder;
-    AVBSFContext *bsf;
-    AVFifoBuffer *packet_fifo;
-    AVPacket pkt_filtered;
 } SVCContext;
 
 static av_cold int svc_decode_close(AVCodecContext *avctx)
 {
     SVCContext *s = avctx->priv_data;
-    AVPacket pkt;
 
     if (s->decoder)
         WelsDestroyDecoder(s->decoder);
 
-    while (s->packet_fifo && av_fifo_size(s->packet_fifo) >= sizeof(pkt)) {
-        av_fifo_generic_read(s->packet_fifo, &pkt, sizeof(pkt), NULL);
-        av_packet_unref(&pkt);
-    }
-
-    av_bsf_free(&s->bsf);
-    av_packet_unref(&s->pkt_filtered);
-    av_fifo_free(s->packet_fifo);
-
     return 0;
 }
 
@@ -71,16 +58,9 @@ static av_cold int svc_decode_init(AVCodecContext *avctx)
     if ((err = ff_libopenh264_check_version(avctx)) < 0)
         return err;
 
-    s->packet_fifo = av_fifo_alloc(sizeof(AVPacket));
-    if (!s->packet_fifo) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-
     if (WelsCreateDecoder(&s->decoder)) {
         av_log(avctx, AV_LOG_ERROR, "Unable to create decoder\n");
-        err = AVERROR_UNKNOWN;
-        goto fail;
+        return AVERROR_UNKNOWN;
     }
 
     // Pass all libopenh264 messages to our callback, to allow ourselves to filter them.
@@ -98,46 +78,12 @@ static av_cold int svc_decode_init(AVCodecContext *avctx)
 
     if ((*s->decoder)->Initialize(s->decoder, &param) != cmResultSuccess) {
         av_log(avctx, AV_LOG_ERROR, "Initialize failed\n");
-        err = AVERROR_UNKNOWN;
-        goto fail;
+        return AVERROR_UNKNOWN;
     }
 
     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 
-fail:
-    return err;
-}
-
-static int init_bsf(AVCodecContext *avctx)
-{
-    SVCContext *s = avctx->priv_data;
-    const AVBitStreamFilter *filter;
-    int ret;
-
-    if (s->bsf)
-        return 0;
-
-    // If the input stream already is annex b, this BSF only passes the
-    // packets through unchanged.
-    filter = av_bsf_get_by_name("h264_mp4toannexb");
-    if (!filter)
-        return AVERROR_BUG;
-
-    ret = av_bsf_alloc(filter, &s->bsf);
-    if (ret < 0)
-        return ret;
-
-    ret = avcodec_parameters_from_context(s->bsf->par_in, avctx);
-    if (ret < 0)
-        return ret;
-
-    s->bsf->time_base_in = avctx->time_base;
-
-    ret = av_bsf_init(s->bsf);
-    if (ret < 0)
-        return ret;
-
-    return ret;
+    return 0;
 }
 
 static int svc_decode_frame(AVCodecContext *avctx, void *data,
@@ -146,89 +92,43 @@ static int svc_decode_frame(AVCodecContext *avctx, void *data,
     SVCContext *s = avctx->priv_data;
     SBufferInfo info = { 0 };
     uint8_t* ptrs[3];
-    int linesize[3];
+    int ret, linesize[3];
     AVFrame *avframe = data;
-    int ret;
     DECODING_STATE state;
 
-    if ((ret = init_bsf(avctx)) < 0)
-        return ret;
+    state = (*s->decoder)->DecodeFrame2(s->decoder, avpkt->data, avpkt->size, ptrs, &info);
+    if (state != dsErrorFree) {
+        av_log(avctx, AV_LOG_ERROR, "DecodeFrame2 failed\n");
+        return AVERROR_UNKNOWN;
+    }
+    if (info.iBufferStatus != 1) {
+        av_log(avctx, AV_LOG_DEBUG, "No frame produced\n");
+        return avpkt->size;
+    }
 
-    if (avpkt->size) {
-        AVPacket input_ref = { 0 };
-        if (av_fifo_space(s->packet_fifo) < sizeof(input_ref)) {
-            ret = av_fifo_realloc2(s->packet_fifo,
-                                   av_fifo_size(s->packet_fifo) + sizeof(input_ref));
-            if (ret < 0)
-                return ret;
-        }
-
-        ret = av_packet_ref(&input_ref, avpkt);
-        if (ret < 0)
-            return ret;
-        av_fifo_generic_write(s->packet_fifo, &input_ref, sizeof(input_ref), NULL);
+    ret = ff_set_dimensions(avctx, info.UsrData.sSystemBuffer.iWidth, info.UsrData.sSystemBuffer.iHeight);
+    if (ret < 0)
+        return ret;
+    // The decoder doesn't (currently) support decoding into a user
+    // provided buffer, so do a copy instead.
+    if (ff_get_buffer(avctx, avframe, 0) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Unable to allocate buffer\n");
+        return AVERROR(ENOMEM);
     }
 
-    while (!*got_frame) {
-        /* prepare the input data -- convert to Annex B if needed */
-        if (s->pkt_filtered.size <= 0) {
-            AVPacket input_ref;
-
-            /* no more data */
-            if (av_fifo_size(s->packet_fifo) < sizeof(AVPacket))
-                return avpkt->size ? avpkt->size : 0;
-
-            av_packet_unref(&s->pkt_filtered);
-
-            av_fifo_generic_read(s->packet_fifo, &input_ref, sizeof(input_ref), NULL);
-            ret = av_bsf_send_packet(s->bsf, &input_ref);
-            if (ret < 0) {
-                av_packet_unref(&input_ref);
-                return ret;
-            }
-
-            ret = av_bsf_receive_packet(s->bsf, &s->pkt_filtered);
-            if (ret < 0)
-                av_packet_move_ref(&s->pkt_filtered, &input_ref);
-            else
-                av_packet_unref(&input_ref);
-        }
-
-        state = (*s->decoder)->DecodeFrame2(s->decoder, s->pkt_filtered.data, s->pkt_filtered.size, ptrs, &info);
-        s->pkt_filtered.size = 0;
-        if (state != dsErrorFree) {
-            av_log(avctx, AV_LOG_ERROR, "DecodeFrame2 failed\n");
-            return AVERROR_UNKNOWN;
-        }
-        if (info.iBufferStatus != 1) {
-            av_log(avctx, AV_LOG_DEBUG, "No frame produced\n");
-            continue;
-        }
-
-        ret = ff_set_dimensions(avctx, info.UsrData.sSystemBuffer.iWidth, info.UsrData.sSystemBuffer.iHeight);
-        if (ret < 0)
-            return ret;
-        // The decoder doesn't (currently) support decoding into a user
-        // provided buffer, so do a copy instead.
-        if (ff_get_buffer(avctx, avframe, 0) < 0) {
-            av_log(avctx, AV_LOG_ERROR, "Unable to allocate buffer\n");
-            return AVERROR(ENOMEM);
-        }
-
-        linesize[0] = info.UsrData.sSystemBuffer.iStride[0];
-        linesize[1] = linesize[2] = info.UsrData.sSystemBuffer.iStride[1];
-        av_image_copy(avframe->data, avframe->linesize, (const uint8_t **) ptrs, linesize, avctx->pix_fmt, avctx->width, avctx->height);
-
-        avframe->pts     = s->pkt_filtered.pts;
-        avframe->pkt_dts = s->pkt_filtered.dts;
+    linesize[0] = info.UsrData.sSystemBuffer.iStride[0];
+    linesize[1] = linesize[2] = info.UsrData.sSystemBuffer.iStride[1];
+    av_image_copy(avframe->data, avframe->linesize, (const uint8_t **) ptrs, linesize, avctx->pix_fmt, avctx->width, avctx->height);
+
+    avframe->pts     = avpkt->pts;
+    avframe->pkt_dts = avpkt->dts;
 #if FF_API_PKT_PTS
 FF_DISABLE_DEPRECATION_WARNINGS
-        avframe->pkt_pts = s->pkt_filtered.pts;
+    avframe->pkt_pts = avpkt->pts;
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
 
-        *got_frame = 1;
-    }
+    *got_frame = 1;
     return avpkt->size;
 }
 
@@ -246,4 +146,5 @@ AVCodec ff_libopenh264_decoder = {
     .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS | FF_CODEC_CAP_INIT_THREADSAFE |
                       FF_CODEC_CAP_INIT_CLEANUP,
+    .bsfs           = "h264_mp4toannexb",
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/libopenh264enc.c b/mythtv/external/FFmpeg/libavcodec/libopenh264enc.c
index 14afe907959..9c22bf4f30c 100644
--- a/mythtv/external/FFmpeg/libavcodec/libopenh264enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/libopenh264enc.c
@@ -100,8 +100,6 @@ static av_cold int svc_encode_init(AVCodecContext *avctx)
 
     if ((err = ff_libopenh264_check_version(avctx)) < 0)
         return err;
-    // Use a default error for multiple error paths below
-    err = AVERROR_UNKNOWN;
 
     if (WelsCreateSVCEncoder(&s->encoder)) {
         av_log(avctx, AV_LOG_ERROR, "Unable to create encoder\n");
@@ -114,10 +112,10 @@ static av_cold int svc_encode_init(AVCodecContext *avctx)
 
     // Set the logging callback function to one that uses av_log() (see implementation above).
     callback_function = (WelsTraceCallback) ff_libopenh264_trace_callback;
-    (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_CALLBACK, (void *)&callback_function);
+    (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_CALLBACK, &callback_function);
 
     // Set the AVCodecContext as the libopenh264 callback context so that it can be passed to av_log().
-    (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, (void *)&avctx);
+    (*s->encoder)->SetOption(s->encoder, ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, &avctx);
 
     (*s->encoder)->GetDefaultParams(s->encoder, &param);
 
@@ -167,7 +165,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
         av_log(avctx, AV_LOG_ERROR,
                "Invalid combination -slices %d and -max_nal_size %d.\n",
                avctx->slices, s->max_nal_size);
-        goto fail;
+        return AVERROR(EINVAL);
     }
 
     if (avctx->slices > 1)
@@ -195,13 +193,13 @@ FF_ENABLE_DEPRECATION_WARNINGS
         } else {
             av_log(avctx, AV_LOG_ERROR, "Invalid -max_nal_size, "
                    "specify a valid max_nal_size to use -slice_mode dyn\n");
-            goto fail;
+            return AVERROR(EINVAL);
         }
     }
 
     if ((*s->encoder)->InitializeExt(s->encoder, &param) != cmResultSuccess) {
         av_log(avctx, AV_LOG_ERROR, "Initialize failed\n");
-        goto fail;
+        return AVERROR_UNKNOWN;
     }
 
     if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
@@ -211,27 +209,19 @@ FF_ENABLE_DEPRECATION_WARNINGS
         for (i = 0; i < fbi.sLayerInfo[0].iNalCount; i++)
             size += fbi.sLayerInfo[0].pNalLengthInByte[i];
         avctx->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
-        if (!avctx->extradata) {
-            err = AVERROR(ENOMEM);
-            goto fail;
-        }
+        if (!avctx->extradata)
+            return AVERROR(ENOMEM);
         avctx->extradata_size = size;
         memcpy(avctx->extradata, fbi.sLayerInfo[0].pBsBuf, size);
     }
 
     props = ff_add_cpb_side_data(avctx);
-    if (!props) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
+    if (!props)
+        return AVERROR(ENOMEM);
     props->max_bitrate = param.iMaxBitrate;
     props->avg_bitrate = param.iTargetBitrate;
 
     return 0;
-
-fail:
-    svc_encode_close(avctx);
-    return err;
 }
 
 static int svc_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
@@ -304,6 +294,7 @@ AVCodec ff_libopenh264_encoder = {
     .encode2        = svc_encode_frame,
     .close          = svc_encode_close,
     .capabilities   = AV_CODEC_CAP_AUTO_THREADS,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
                                                     AV_PIX_FMT_NONE },
     .priv_class     = &class,
diff --git a/mythtv/external/FFmpeg/libavcodec/libopenjpegdec.c b/mythtv/external/FFmpeg/libavcodec/libopenjpegdec.c
index b4ce834778b..67d47bd6a0a 100644
--- a/mythtv/external/FFmpeg/libavcodec/libopenjpegdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/libopenjpegdec.c
@@ -34,7 +34,11 @@
 #include "internal.h"
 #include "thread.h"
 
-#if HAVE_OPENJPEG_2_1_OPENJPEG_H
+#if HAVE_OPENJPEG_2_3_OPENJPEG_H
+#  include <openjpeg-2.3/openjpeg.h>
+#elif HAVE_OPENJPEG_2_2_OPENJPEG_H
+#  include <openjpeg-2.2/openjpeg.h>
+#elif HAVE_OPENJPEG_2_1_OPENJPEG_H
 #  include <openjpeg-2.1/openjpeg.h>
 #elif HAVE_OPENJPEG_2_0_OPENJPEG_H
 #  include <openjpeg-2.0/openjpeg.h>
@@ -44,7 +48,7 @@
 #  include <openjpeg.h>
 #endif
 
-#if HAVE_OPENJPEG_2_1_OPENJPEG_H || HAVE_OPENJPEG_2_0_OPENJPEG_H
+#if HAVE_OPENJPEG_2_3_OPENJPEG_H || HAVE_OPENJPEG_2_2_OPENJPEG_H || HAVE_OPENJPEG_2_1_OPENJPEG_H || HAVE_OPENJPEG_2_0_OPENJPEG_H
 #  define OPENJPEG_MAJOR_VERSION 2
 #  define OPJ(x) OPJ_##x
 #else
@@ -429,7 +433,7 @@ static int libopenjpeg_decode_frame(AVCodecContext *avctx,
     opj_stream_set_read_function(stream, stream_read);
     opj_stream_set_skip_function(stream, stream_skip);
     opj_stream_set_seek_function(stream, stream_seek);
-#if HAVE_OPENJPEG_2_1_OPENJPEG_H
+#if HAVE_OPENJPEG_2_3_OPENJPEG_H || HAVE_OPENJPEG_2_2_OPENJPEG_H || HAVE_OPENJPEG_2_1_OPENJPEG_H
     opj_stream_set_user_data(stream, &reader, NULL);
 #elif HAVE_OPENJPEG_2_0_OPENJPEG_H
     opj_stream_set_user_data(stream, &reader);
@@ -540,12 +544,14 @@ static int libopenjpeg_decode_frame(AVCodecContext *avctx,
         }
         break;
     default:
-        av_log(avctx, AV_LOG_ERROR, "unsupported pixel size %d\n", pixel_size);
+        avpriv_report_missing_feature(avctx, "Pixel size %d", pixel_size);
         ret = AVERROR_PATCHWELCOME;
         goto done;
     }
 
     *got_frame = 1;
+    picture->pict_type = AV_PICTURE_TYPE_I;
+    picture->key_frame = 1;
     ret        = buf_size;
 
 done:
diff --git a/mythtv/external/FFmpeg/libavcodec/libopenjpegenc.c b/mythtv/external/FFmpeg/libavcodec/libopenjpegenc.c
index 1b7e1684af9..92b4433b047 100644
--- a/mythtv/external/FFmpeg/libavcodec/libopenjpegenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/libopenjpegenc.c
@@ -32,7 +32,11 @@
 #include "avcodec.h"
 #include "internal.h"
 
-#if HAVE_OPENJPEG_2_1_OPENJPEG_H
+#if HAVE_OPENJPEG_2_3_OPENJPEG_H
+#  include <openjpeg-2.3/openjpeg.h>
+#elif HAVE_OPENJPEG_2_2_OPENJPEG_H
+#  include <openjpeg-2.2/openjpeg.h>
+#elif HAVE_OPENJPEG_2_1_OPENJPEG_H
 #  include <openjpeg-2.1/openjpeg.h>
 #elif HAVE_OPENJPEG_2_0_OPENJPEG_H
 #  include <openjpeg-2.0/openjpeg.h>
@@ -42,7 +46,7 @@
 #  include <openjpeg.h>
 #endif
 
-#if HAVE_OPENJPEG_2_1_OPENJPEG_H || HAVE_OPENJPEG_2_0_OPENJPEG_H
+#if HAVE_OPENJPEG_2_3_OPENJPEG_H || HAVE_OPENJPEG_2_2_OPENJPEG_H || HAVE_OPENJPEG_2_1_OPENJPEG_H || HAVE_OPENJPEG_2_0_OPENJPEG_H
 #  define OPENJPEG_MAJOR_VERSION 2
 #  define OPJ(x) OPJ_##x
 #else
@@ -64,9 +68,8 @@ typedef struct LibOpenJPEGContext {
     int prog_order;
     int cinema_mode;
     int numresolution;
-    int numlayers;
+    int irreversible;
     int disto_alloc;
-    int fixed_alloc;
     int fixed_quality;
 } LibOpenJPEGContext;
 
@@ -306,7 +309,7 @@ static av_cold int libopenjpeg_encode_init(AVCodecContext *avctx)
 
     opj_set_default_encoder_parameters(&ctx->enc_params);
 
-#if HAVE_OPENJPEG_2_1_OPENJPEG_H
+#if HAVE_OPENJPEG_2_3_OPENJPEG_H || HAVE_OPENJPEG_2_2_OPENJPEG_H || HAVE_OPENJPEG_2_1_OPENJPEG_H
     switch (ctx->cinema_mode) {
     case OPJ_CINEMA2K_24:
         ctx->enc_params.rsiz = OPJ_PROFILE_CINEMA_2K;
@@ -358,13 +361,12 @@ static av_cold int libopenjpeg_encode_init(AVCodecContext *avctx)
             ctx->numresolution --;
     }
 
-    ctx->enc_params.mode = !!avctx->global_quality;
     ctx->enc_params.prog_order = ctx->prog_order;
     ctx->enc_params.numresolution = ctx->numresolution;
+    ctx->enc_params.irreversible = ctx->irreversible;
     ctx->enc_params.cp_disto_alloc = ctx->disto_alloc;
-    ctx->enc_params.cp_fixed_alloc = ctx->fixed_alloc;
     ctx->enc_params.cp_fixed_quality = ctx->fixed_quality;
-    ctx->enc_params.tcp_numlayers = ctx->numlayers;
+    ctx->enc_params.tcp_numlayers = 1;
     ctx->enc_params.tcp_rates[0] = FFMAX(avctx->compression_level, 0) * 2;
 
     if (ctx->cinema_mode > 0) {
@@ -771,7 +773,7 @@ static int libopenjpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     opj_stream_set_write_function(stream, stream_write);
     opj_stream_set_skip_function(stream, stream_skip);
     opj_stream_set_seek_function(stream, stream_seek);
-#if HAVE_OPENJPEG_2_1_OPENJPEG_H
+#if HAVE_OPENJPEG_2_3_OPENJPEG_H || HAVE_OPENJPEG_2_2_OPENJPEG_H || HAVE_OPENJPEG_2_1_OPENJPEG_H
     opj_stream_set_user_data(stream, &writer, NULL);
 #elif HAVE_OPENJPEG_2_0_OPENJPEG_H
     opj_stream_set_user_data(stream, &writer);
@@ -838,11 +840,10 @@ static const AVOption options[] = {
     { "rpcl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(RPCL)    }, 0,         0,           VE, "prog_order"  },
     { "pcrl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(PCRL)    }, 0,         0,           VE, "prog_order"  },
     { "cprl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OPJ(CPRL)    }, 0,         0,           VE, "prog_order"  },
-    { "numresolution", NULL,                OFFSET(numresolution), AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         INT_MAX,     VE                },
-    { "numlayers",     NULL,                OFFSET(numlayers),     AV_OPT_TYPE_INT,   { .i64 = 1           }, 1,         10,          VE                },
-    { "disto_alloc",   NULL,                OFFSET(disto_alloc),   AV_OPT_TYPE_INT,   { .i64 = 1           }, 0,         1,           VE                },
-    { "fixed_alloc",   NULL,                OFFSET(fixed_alloc),   AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         1,           VE                },
-    { "fixed_quality", NULL,                OFFSET(fixed_quality), AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         1,           VE                },
+    { "numresolution", NULL,                OFFSET(numresolution), AV_OPT_TYPE_INT,   { .i64 = 6            }, 0,         33,          VE                },
+    { "irreversible",  NULL,                OFFSET(irreversible),  AV_OPT_TYPE_INT,   { .i64 = 0            }, 0,         1,           VE                },
+    { "disto_alloc",   NULL,                OFFSET(disto_alloc),   AV_OPT_TYPE_INT,   { .i64 = 1            }, 0,         1,           VE                },
+    { "fixed_quality", NULL,                OFFSET(fixed_quality), AV_OPT_TYPE_INT,   { .i64 = 0            }, 0,         1,           VE                },
     { NULL },
 };
 
diff --git a/mythtv/external/FFmpeg/libavcodec/libopusdec.c b/mythtv/external/FFmpeg/libavcodec/libopusdec.c
index acc62f14d86..e6ca61a78f3 100644
--- a/mythtv/external/FFmpeg/libavcodec/libopusdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/libopusdec.c
@@ -47,6 +47,13 @@ static av_cold int libopus_decode_init(AVCodecContext *avc)
     int ret, channel_map = 0, gain_db = 0, nb_streams, nb_coupled;
     uint8_t mapping_arr[8] = { 0, 1 }, *mapping;
 
+    avc->channels = avc->extradata_size >= 10 ? avc->extradata[9] : (avc->channels == 1) ? 1 : 2;
+    if (avc->channels <= 0) {
+        av_log(avc, AV_LOG_WARNING,
+               "Invalid number of channels %d, defaulting to stereo\n", avc->channels);
+        avc->channels = 2;
+    }
+
     avc->sample_rate    = 48000;
     avc->sample_fmt     = avc->request_sample_fmt == AV_SAMPLE_FMT_FLT ?
                           AV_SAMPLE_FMT_FLT : AV_SAMPLE_FMT_S16;
diff --git a/mythtv/external/FFmpeg/libavcodec/libopusenc.c b/mythtv/external/FFmpeg/libavcodec/libopusenc.c
index c40fcde7ba0..3d88c296d32 100644
--- a/mythtv/external/FFmpeg/libavcodec/libopusenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/libopusenc.c
@@ -351,12 +351,12 @@ static av_cold int libopus_encode_init(AVCodecContext *avctx)
         avctx->bit_rate = 64000 * opus->stream_count +
                           32000 * coupled_stream_count;
         av_log(avctx, AV_LOG_WARNING,
-               "No bit rate set. Defaulting to %"PRId64" bps.\n", (int64_t)avctx->bit_rate);
+               "No bit rate set. Defaulting to %"PRId64" bps.\n", avctx->bit_rate);
     }
 
     if (avctx->bit_rate < 500 || avctx->bit_rate > 256000 * avctx->channels) {
         av_log(avctx, AV_LOG_ERROR, "The bit rate %"PRId64" bps is unsupported. "
-               "Please choose a value between 500 and %d.\n", (int64_t)avctx->bit_rate,
+               "Please choose a value between 500 and %d.\n", avctx->bit_rate,
                256000 * avctx->channels);
         ret = AVERROR(EINVAL);
         goto fail;
@@ -368,7 +368,7 @@ static av_cold int libopus_encode_init(AVCodecContext *avctx)
         goto fail;
     }
 
-    /* Header includes channel mapping table if and only if mapping family is 0 */
+    /* Header includes channel mapping table if and only if mapping family is NOT 0 */
     header_size = 19 + (mapping_family == 0 ? 0 : 2 + avctx->channels);
     avctx->extradata = av_malloc(header_size + AV_INPUT_BUFFER_PADDING_SIZE);
     if (!avctx->extradata) {
diff --git a/mythtv/external/FFmpeg/libavcodec/librsvgdec.c b/mythtv/external/FFmpeg/libavcodec/librsvgdec.c
new file mode 100644
index 00000000000..77c771003ce
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/librsvgdec.c
@@ -0,0 +1,127 @@
+/*
+ * Librsvg rasterization wrapper
+ * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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 "avcodec.h"
+#include "internal.h"
+#include "libavutil/opt.h"
+#include "librsvg-2.0/librsvg/rsvg.h"
+
+typedef struct LibRSVGContext {
+    AVClass *class;
+
+    int width;
+    int height;
+    int keep_ar;
+} LibRSVGContext;
+
+static int librsvg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
+{
+    int ret;
+    LibRSVGContext *s = avctx->priv_data;
+    AVFrame *frame = data;
+
+    RsvgHandle *handle;
+    RsvgDimensionData unscaled_dimensions, dimensions;
+    cairo_surface_t *image;
+    cairo_t *crender = NULL;
+    GError *error = NULL;
+
+    *got_frame = 0;
+
+    handle = rsvg_handle_new_from_data(pkt->data, pkt->size, &error);
+    if (error) {
+        av_log(avctx, AV_LOG_ERROR, "Error parsing svg!\n");
+        g_error_free(error);
+        return AVERROR_INVALIDDATA;
+    }
+
+    rsvg_handle_get_dimensions(handle, &dimensions);
+    rsvg_handle_get_dimensions(handle, &unscaled_dimensions);
+    dimensions.width  = s->width  ? s->width  : dimensions.width;
+    dimensions.height = s->height ? s->height : dimensions.height;
+    if (s->keep_ar && (s->width || s->height)) {
+        double default_ar = unscaled_dimensions.width/(double)unscaled_dimensions.height;
+        if (!s->width)
+            dimensions.width  = lrintf(dimensions.height * default_ar);
+        else
+            dimensions.height = lrintf(dimensions.width  / default_ar);
+    }
+
+    if ((ret = ff_set_dimensions(avctx, dimensions.width, dimensions.height)))
+        return ret;
+    avctx->pix_fmt = AV_PIX_FMT_RGB32;
+
+    if ((ret = ff_get_buffer(avctx, frame, 0)))
+        return ret;
+    frame->pict_type = AV_PICTURE_TYPE_I;
+    frame->key_frame = 1;
+
+    image = cairo_image_surface_create_for_data(frame->data[0], CAIRO_FORMAT_ARGB32,
+                                                frame->width, frame->height,
+                                                frame->linesize[0]);
+    if (cairo_surface_status(image) != CAIRO_STATUS_SUCCESS)
+        return AVERROR_INVALIDDATA;
+
+    crender = cairo_create(image);
+
+    cairo_set_source_rgba(crender, 0.0, 0.0, 0.0, 1.0f);
+    cairo_paint_with_alpha(crender, 0.0f);
+
+    cairo_scale(crender, dimensions.width / (double)unscaled_dimensions.width,
+                dimensions.height / (double)unscaled_dimensions.height);
+
+    rsvg_handle_render_cairo(handle, crender);
+
+    cairo_destroy(crender);
+    cairo_surface_destroy(image);
+    g_object_unref(handle);
+
+    *got_frame = 1;
+
+    return 0;
+}
+
+#define OFFSET(x) offsetof(LibRSVGContext, x)
+#define DEC (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
+static const AVOption options[] = {
+    { "width", "Width to render to (0 for default)", OFFSET(width), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, DEC },
+    { "height", "Height to render to (0 for default)", OFFSET(height), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, DEC },
+    { "keep_ar", "Keep aspect ratio with custom width/height", OFFSET(keep_ar), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, DEC },
+    { NULL },
+};
+
+static const AVClass librsvg_decoder_class = {
+    .class_name = "Librsvg",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVCodec ff_librsvg_decoder = {
+    .name           = "librsvg",
+    .long_name      = NULL_IF_CONFIG_SMALL("Librsvg rasterizer"),
+    .priv_class     = &librsvg_decoder_class,
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_SVG,
+    .decode         = librsvg_decode_frame,
+    .priv_data_size = sizeof(LibRSVGContext),
+    .capabilities   = AV_CODEC_CAP_LOSSLESS | AV_CODEC_CAP_DR1,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/libschroedinger.c b/mythtv/external/FFmpeg/libavcodec/libschroedinger.c
deleted file mode 100644
index 0b02b2c2402..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/libschroedinger.c
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
- * Copyright (c) 2008 BBC, Anuradha Suraparaju <asuraparaju at gmail dot com >
- *
- * 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
-* function definitions common to libschroedinger decoder and encoder
-*/
-
-#include "libavutil/attributes.h"
-#include "libavutil/mem.h"
-#include "libschroedinger.h"
-#include "internal.h"
-
-static const SchroVideoFormatInfo ff_schro_video_format_info[] = {
-    { 640,  480,  24000, 1001},
-    { 176,  120,  15000, 1001},
-    { 176,  144,  25,    2   },
-    { 352,  240,  15000, 1001},
-    { 352,  288,  25,    2   },
-    { 704,  480,  15000, 1001},
-    { 704,  576,  25,    2   },
-    { 720,  480,  30000, 1001},
-    { 720,  576,  25,    1   },
-    { 1280, 720,  60000, 1001},
-    { 1280, 720,  50,    1   },
-    { 1920, 1080, 30000, 1001},
-    { 1920, 1080, 25,    1   },
-    { 1920, 1080, 60000, 1001},
-    { 1920, 1080, 50,    1   },
-    { 2048, 1080, 24,    1   },
-    { 4096, 2160, 24,    1   },
-};
-
-static unsigned int get_video_format_idx(AVCodecContext *avctx)
-{
-    unsigned int ret_idx = 0;
-    unsigned int idx;
-    unsigned int num_formats = sizeof(ff_schro_video_format_info) /
-                               sizeof(ff_schro_video_format_info[0]);
-
-    for (idx = 1; idx < num_formats; ++idx) {
-        const SchroVideoFormatInfo *vf = &ff_schro_video_format_info[idx];
-        if (avctx->width  == vf->width &&
-            avctx->height == vf->height) {
-            ret_idx = idx;
-            if (avctx->time_base.den == vf->frame_rate_num &&
-                avctx->time_base.num == vf->frame_rate_denom)
-                return idx;
-        }
-    }
-    return ret_idx;
-}
-
-av_cold void ff_schro_queue_init(FFSchroQueue *queue)
-{
-    queue->p_head = queue->p_tail = NULL;
-    queue->size = 0;
-}
-
-void ff_schro_queue_free(FFSchroQueue *queue, void (*free_func)(void *))
-{
-    while (queue->p_head)
-        free_func(ff_schro_queue_pop(queue));
-}
-
-int ff_schro_queue_push_back(FFSchroQueue *queue, void *p_data)
-{
-    FFSchroQueueElement *p_new = av_mallocz(sizeof(FFSchroQueueElement));
-
-    if (!p_new)
-        return -1;
-
-    p_new->data = p_data;
-
-    if (!queue->p_head)
-        queue->p_head = p_new;
-    else
-        queue->p_tail->next = p_new;
-    queue->p_tail = p_new;
-
-    ++queue->size;
-    return 0;
-}
-
-void *ff_schro_queue_pop(FFSchroQueue *queue)
-{
-    FFSchroQueueElement *top = queue->p_head;
-
-    if (top) {
-        void *data = top->data;
-        queue->p_head = queue->p_head->next;
-        --queue->size;
-        av_freep(&top);
-        return data;
-    }
-
-    return NULL;
-}
-
-/**
-* Schroedinger video preset table. Ensure that this tables matches up correctly
-* with the ff_schro_video_format_info table.
-*/
-static const SchroVideoFormatEnum ff_schro_video_formats[]={
-    SCHRO_VIDEO_FORMAT_CUSTOM     ,
-    SCHRO_VIDEO_FORMAT_QSIF       ,
-    SCHRO_VIDEO_FORMAT_QCIF       ,
-    SCHRO_VIDEO_FORMAT_SIF        ,
-    SCHRO_VIDEO_FORMAT_CIF        ,
-    SCHRO_VIDEO_FORMAT_4SIF       ,
-    SCHRO_VIDEO_FORMAT_4CIF       ,
-    SCHRO_VIDEO_FORMAT_SD480I_60  ,
-    SCHRO_VIDEO_FORMAT_SD576I_50  ,
-    SCHRO_VIDEO_FORMAT_HD720P_60  ,
-    SCHRO_VIDEO_FORMAT_HD720P_50  ,
-    SCHRO_VIDEO_FORMAT_HD1080I_60 ,
-    SCHRO_VIDEO_FORMAT_HD1080I_50 ,
-    SCHRO_VIDEO_FORMAT_HD1080P_60 ,
-    SCHRO_VIDEO_FORMAT_HD1080P_50 ,
-    SCHRO_VIDEO_FORMAT_DC2K_24    ,
-    SCHRO_VIDEO_FORMAT_DC4K_24    ,
-};
-
-SchroVideoFormatEnum ff_get_schro_video_format_preset(AVCodecContext *avctx)
-{
-    unsigned int num_formats = sizeof(ff_schro_video_formats) /
-                               sizeof(ff_schro_video_formats[0]);
-
-    unsigned int idx = get_video_format_idx(avctx);
-
-    return (idx < num_formats) ? ff_schro_video_formats[idx] :
-                                 SCHRO_VIDEO_FORMAT_CUSTOM;
-}
-
-int ff_get_schro_frame_format (SchroChromaFormat schro_pix_fmt,
-                               SchroFrameFormat  *schro_frame_fmt)
-{
-    unsigned int num_formats = sizeof(schro_pixel_format_map) /
-                               sizeof(schro_pixel_format_map[0]);
-
-    int idx;
-
-    for (idx = 0; idx < num_formats; ++idx) {
-        if (schro_pixel_format_map[idx].schro_pix_fmt == schro_pix_fmt) {
-            *schro_frame_fmt = schro_pixel_format_map[idx].schro_frame_fmt;
-            return 0;
-        }
-    }
-    return -1;
-}
-
-static void free_schro_frame(SchroFrame *frame, void *priv)
-{
-    AVFrame *p_pic = priv;
-    av_frame_free(&p_pic);
-}
-
-SchroFrame *ff_create_schro_frame(AVCodecContext *avctx,
-                                  SchroFrameFormat schro_frame_fmt)
-{
-    AVFrame *p_pic;
-    SchroFrame *p_frame;
-    int y_width, uv_width;
-    int y_height, uv_height;
-    int i;
-
-    y_width   = avctx->width;
-    y_height  = avctx->height;
-    uv_width  = y_width  >> (SCHRO_FRAME_FORMAT_H_SHIFT(schro_frame_fmt));
-    uv_height = y_height >> (SCHRO_FRAME_FORMAT_V_SHIFT(schro_frame_fmt));
-
-    p_pic = av_frame_alloc();
-    if (!p_pic)
-        return NULL;
-
-    if (ff_get_buffer(avctx, p_pic, AV_GET_BUFFER_FLAG_REF) < 0) {
-        av_frame_free(&p_pic);
-        return NULL;
-    }
-
-    p_frame         = schro_frame_new();
-    p_frame->format = schro_frame_fmt;
-    p_frame->width  = y_width;
-    p_frame->height = y_height;
-    schro_frame_set_free_callback(p_frame, free_schro_frame, (void *)p_pic);
-
-    for (i = 0; i < 3; ++i) {
-        p_frame->components[i].width  = i ? uv_width : y_width;
-        p_frame->components[i].stride = p_pic->linesize[i];
-        p_frame->components[i].height = i ? uv_height : y_height;
-        p_frame->components[i].length =
-                 p_frame->components[i].stride * p_frame->components[i].height;
-        p_frame->components[i].data   = p_pic->data[i];
-
-        if (i) {
-            p_frame->components[i].v_shift =
-                SCHRO_FRAME_FORMAT_V_SHIFT(p_frame->format);
-            p_frame->components[i].h_shift =
-                SCHRO_FRAME_FORMAT_H_SHIFT(p_frame->format);
-        }
-    }
-
-    return p_frame;
-}
diff --git a/mythtv/external/FFmpeg/libavcodec/libschroedinger.h b/mythtv/external/FFmpeg/libavcodec/libschroedinger.h
deleted file mode 100644
index 12fe57c7f17..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/libschroedinger.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (c) 2008 BBC, Anuradha Suraparaju <asuraparaju at gmail dot com >
- *
- * 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
-* data structures common to libschroedinger decoder and encoder
-*/
-
-#ifndef AVCODEC_LIBSCHROEDINGER_H
-#define AVCODEC_LIBSCHROEDINGER_H
-
-#include <schroedinger/schrobitstream.h>
-#include <schroedinger/schroframe.h>
-
-#include "avcodec.h"
-
-typedef struct SchroVideoFormatInfo {
-    uint16_t width;
-    uint16_t height;
-    uint16_t frame_rate_num;
-    uint16_t frame_rate_denom;
-} SchroVideoFormatInfo;
-
-/**
-* contains a single encoded frame returned from Dirac or Schroedinger
-*/
-typedef struct FFSchroEncodedFrame {
-    /** encoded frame data */
-    uint8_t *p_encbuf;
-
-    /** encoded frame size */
-    uint32_t size;
-
-    /** encoded frame number. Will be used as pts */
-    uint32_t frame_num;
-
-    /** key frame flag. 1 : is key frame , 0 : in not key frame */
-    uint16_t key_frame;
-} FFSchroEncodedFrame;
-
-/**
-* queue element
-*/
-typedef struct FFSchroQueueElement {
-    /** Data to be stored in queue*/
-    void *data;
-    /** Pointer to next element queue */
-    struct FFSchroQueueElement *next;
-} FFSchroQueueElement;
-
-
-/**
-* A simple queue implementation used in libschroedinger
-*/
-typedef struct FFSchroQueue {
-    /** Pointer to head of queue */
-    FFSchroQueueElement *p_head;
-    /** Pointer to tail of queue */
-    FFSchroQueueElement *p_tail;
-    /** Queue size*/
-    int size;
-} FFSchroQueue;
-
-/**
-* Initialise the queue
-*/
-void ff_schro_queue_init(FFSchroQueue *queue);
-
-/**
-* Add an element to the end of the queue
-*/
-int ff_schro_queue_push_back(FFSchroQueue *queue, void *p_data);
-
-/**
-* Return the first element in the queue
-*/
-void *ff_schro_queue_pop(FFSchroQueue *queue);
-
-/**
-* Free the queue resources. free_func is a function supplied by the caller to
-* free any resources allocated by the caller. The data field of the queue
-* element is passed to it.
-*/
-void ff_schro_queue_free(FFSchroQueue *queue, void (*free_func)(void *));
-
-static const struct {
-    enum AVPixelFormat  ff_pix_fmt;
-    SchroChromaFormat schro_pix_fmt;
-    SchroFrameFormat  schro_frame_fmt;
-} schro_pixel_format_map[] = {
-    { AV_PIX_FMT_YUV420P, SCHRO_CHROMA_420, SCHRO_FRAME_FORMAT_U8_420 },
-    { AV_PIX_FMT_YUV422P, SCHRO_CHROMA_422, SCHRO_FRAME_FORMAT_U8_422 },
-    { AV_PIX_FMT_YUV444P, SCHRO_CHROMA_444, SCHRO_FRAME_FORMAT_U8_444 },
-};
-
-/**
-* Returns the video format preset matching the input video dimensions and
-* time base.
-*/
-SchroVideoFormatEnum ff_get_schro_video_format_preset (AVCodecContext *avctx);
-
-/**
-* Sets the Schroedinger frame format corresponding to the Schro chroma format
-* passed. Returns 0 on success, -1 on failure.
-*/
-int ff_get_schro_frame_format(SchroChromaFormat schro_chroma_fmt,
-                              SchroFrameFormat  *schro_frame_fmt);
-
-/**
-* Create a Schro frame based on the dimensions and frame format
-* passed. Returns a pointer to a frame on success, NULL on failure.
-*/
-SchroFrame *ff_create_schro_frame(AVCodecContext *avctx,
-                                  SchroFrameFormat schro_frame_fmt);
-
-#endif /* AVCODEC_LIBSCHROEDINGER_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/libschroedingerdec.c b/mythtv/external/FFmpeg/libavcodec/libschroedingerdec.c
deleted file mode 100644
index c9930c717c8..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/libschroedingerdec.c
+++ /dev/null
@@ -1,393 +0,0 @@
-/*
- * Dirac decoder support via Schroedinger libraries
- * Copyright (c) 2008 BBC, Anuradha Suraparaju <asuraparaju at gmail dot com >
- *
- * 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
-* Dirac decoder support via libschroedinger-1.0 libraries. More details about
-* the Schroedinger project can be found at http://www.diracvideo.org/.
-* The library implements Dirac Specification Version 2.2.
-* (http://dirac.sourceforge.net/specification.html).
-*/
-
-#include <string.h>
-
-#include "libavutil/imgutils.h"
-#include "libavutil/internal.h"
-#include "libavutil/intreadwrite.h"
-#include "libavutil/mem.h"
-#include "avcodec.h"
-#include "internal.h"
-#include "libschroedinger.h"
-
-#include <schroedinger/schro.h>
-#include <schroedinger/schrodebug.h>
-#include <schroedinger/schrovideoformat.h>
-
-/** SchroFrame and Pts relation */
-typedef struct LibSchroFrameContext {
-     SchroFrame *frame;
-     int64_t pts;
-} LibSchroFrameContext;
-
-/** libschroedinger decoder private data */
-typedef struct SchroDecoderParams {
-    /** Schroedinger video format */
-    SchroVideoFormat *format;
-
-    /** Schroedinger frame format */
-    SchroFrameFormat frame_format;
-
-    /** decoder handle */
-    SchroDecoder* decoder;
-
-    /** queue storing decoded frames */
-    FFSchroQueue dec_frame_queue;
-
-    /** end of sequence signalled */
-    int eos_signalled;
-
-    /** end of sequence pulled */
-    int eos_pulled;
-} SchroDecoderParams;
-
-typedef struct SchroParseUnitContext {
-    const uint8_t *buf;
-    int           buf_size;
-} SchroParseUnitContext;
-
-
-static void libschroedinger_decode_buffer_free(SchroBuffer *schro_buf,
-                                               void *priv)
-{
-    av_freep(&priv);
-}
-
-static void parse_context_init(SchroParseUnitContext *parse_ctx,
-                               const uint8_t *buf, int buf_size)
-{
-    parse_ctx->buf           = buf;
-    parse_ctx->buf_size      = buf_size;
-}
-
-static SchroBuffer *find_next_parse_unit(SchroParseUnitContext *parse_ctx)
-{
-    SchroBuffer *enc_buf = NULL;
-    int next_pu_offset = 0;
-    unsigned char *in_buf;
-
-    if (parse_ctx->buf_size < 13 ||
-        parse_ctx->buf[0] != 'B' ||
-        parse_ctx->buf[1] != 'B' ||
-        parse_ctx->buf[2] != 'C' ||
-        parse_ctx->buf[3] != 'D')
-        return NULL;
-
-    next_pu_offset = (parse_ctx->buf[5] << 24) +
-                     (parse_ctx->buf[6] << 16) +
-                     (parse_ctx->buf[7] <<  8) +
-                      parse_ctx->buf[8];
-
-    if (next_pu_offset == 0 &&
-        SCHRO_PARSE_CODE_IS_END_OF_SEQUENCE(parse_ctx->buf[4]))
-        next_pu_offset = 13;
-
-    if (next_pu_offset <= 0 || parse_ctx->buf_size < next_pu_offset)
-        return NULL;
-
-    in_buf = av_malloc(next_pu_offset);
-    if (!in_buf) {
-        av_log(parse_ctx, AV_LOG_ERROR, "Unable to allocate input buffer\n");
-        return NULL;
-    }
-
-    memcpy(in_buf, parse_ctx->buf, next_pu_offset);
-    enc_buf       = schro_buffer_new_with_data(in_buf, next_pu_offset);
-    enc_buf->free = libschroedinger_decode_buffer_free;
-    enc_buf->priv = in_buf;
-
-    parse_ctx->buf      += next_pu_offset;
-    parse_ctx->buf_size -= next_pu_offset;
-
-    return enc_buf;
-}
-
-/**
-* Returns FFmpeg chroma format.
-*/
-static enum AVPixelFormat get_chroma_format(SchroChromaFormat schro_pix_fmt)
-{
-    int num_formats = sizeof(schro_pixel_format_map) /
-                      sizeof(schro_pixel_format_map[0]);
-    int idx;
-
-    for (idx = 0; idx < num_formats; ++idx)
-        if (schro_pixel_format_map[idx].schro_pix_fmt == schro_pix_fmt)
-            return schro_pixel_format_map[idx].ff_pix_fmt;
-    return AV_PIX_FMT_NONE;
-}
-
-static av_cold int libschroedinger_decode_init(AVCodecContext *avctx)
-{
-
-    SchroDecoderParams *p_schro_params = avctx->priv_data;
-    /* First of all, initialize our supporting libraries. */
-    schro_init();
-
-    schro_debug_set_level(avctx->debug);
-    p_schro_params->decoder = schro_decoder_new();
-    schro_decoder_set_skip_ratio(p_schro_params->decoder, 1);
-
-    if (!p_schro_params->decoder)
-        return -1;
-
-    /* Initialize the decoded frame queue. */
-    ff_schro_queue_init(&p_schro_params->dec_frame_queue);
-    return 0;
-}
-
-static void libschroedinger_decode_frame_free(void *frame)
-{
-    schro_frame_unref(frame);
-}
-
-static void libschroedinger_handle_first_access_unit(AVCodecContext *avctx)
-{
-    SchroDecoderParams *p_schro_params = avctx->priv_data;
-    SchroDecoder *decoder = p_schro_params->decoder;
-
-    p_schro_params->format = schro_decoder_get_video_format(decoder);
-
-    /* Tell FFmpeg about sequence details. */
-    if (av_image_check_size(p_schro_params->format->width,
-                            p_schro_params->format->height, 0, avctx) < 0) {
-        av_log(avctx, AV_LOG_ERROR, "invalid dimensions (%dx%d)\n",
-               p_schro_params->format->width, p_schro_params->format->height);
-        avctx->height = avctx->width = 0;
-        return;
-    }
-    avctx->height  = p_schro_params->format->height;
-    avctx->width   = p_schro_params->format->width;
-    avctx->pix_fmt = get_chroma_format(p_schro_params->format->chroma_format);
-
-    if (ff_get_schro_frame_format(p_schro_params->format->chroma_format,
-                                  &p_schro_params->frame_format) == -1) {
-        av_log(avctx, AV_LOG_ERROR,
-               "This codec currently only supports planar YUV 4:2:0, 4:2:2 "
-               "and 4:4:4 formats.\n");
-        return;
-    }
-
-    avctx->framerate.num = p_schro_params->format->frame_rate_numerator;
-    avctx->framerate.den = p_schro_params->format->frame_rate_denominator;
-}
-
-static int libschroedinger_decode_frame(AVCodecContext *avctx,
-                                        void *data, int *got_frame,
-                                        AVPacket *avpkt)
-{
-    const uint8_t *buf = avpkt->data;
-    int buf_size = avpkt->size;
-    int64_t pts  = avpkt->pts;
-    SchroTag *tag;
-
-    SchroDecoderParams *p_schro_params = avctx->priv_data;
-    SchroDecoder *decoder = p_schro_params->decoder;
-    SchroBuffer *enc_buf;
-    SchroFrame* frame;
-    AVFrame *avframe = data;
-    int state;
-    int go = 1;
-    int outer = 1;
-    SchroParseUnitContext parse_ctx;
-    LibSchroFrameContext *framewithpts = NULL;
-
-    *got_frame = 0;
-
-    parse_context_init(&parse_ctx, buf, buf_size);
-    if (!buf_size) {
-        if (!p_schro_params->eos_signalled) {
-            state = schro_decoder_push_end_of_stream(decoder);
-            p_schro_params->eos_signalled = 1;
-        }
-    }
-
-    /* Loop through all the individual parse units in the input buffer */
-    do {
-        if ((enc_buf = find_next_parse_unit(&parse_ctx))) {
-            /* Set Schrotag with the pts to be recovered after decoding*/
-            enc_buf->tag = schro_tag_new(av_malloc(sizeof(int64_t)), av_free);
-            if (!enc_buf->tag->value) {
-                av_log(avctx, AV_LOG_ERROR, "Unable to allocate SchroTag\n");
-                return AVERROR(ENOMEM);
-            }
-            AV_WN(64, enc_buf->tag->value, pts);
-            /* Push buffer into decoder. */
-            if (SCHRO_PARSE_CODE_IS_PICTURE(enc_buf->data[4]) &&
-                SCHRO_PARSE_CODE_NUM_REFS(enc_buf->data[4]) > 0)
-                avctx->has_b_frames = 1;
-            state = schro_decoder_push(decoder, enc_buf);
-            if (state == SCHRO_DECODER_FIRST_ACCESS_UNIT)
-                libschroedinger_handle_first_access_unit(avctx);
-            go = 1;
-        } else
-            outer = 0;
-
-        while (go) {
-            /* Parse data and process result. */
-            state = schro_decoder_wait(decoder);
-            switch (state) {
-            case SCHRO_DECODER_FIRST_ACCESS_UNIT:
-                libschroedinger_handle_first_access_unit(avctx);
-                break;
-
-            case SCHRO_DECODER_NEED_BITS:
-                /* Need more input data - stop iterating over what we have. */
-                go = 0;
-                break;
-
-            case SCHRO_DECODER_NEED_FRAME:
-                /* Decoder needs a frame - create one and push it in. */
-                frame = ff_create_schro_frame(avctx,
-                                              p_schro_params->frame_format);
-                if (!frame)
-                    return AVERROR(ENOMEM);
-                schro_decoder_add_output_picture(decoder, frame);
-                break;
-
-            case SCHRO_DECODER_OK:
-                /* Pull a frame out of the decoder. */
-                tag   = schro_decoder_get_picture_tag(decoder);
-                frame = schro_decoder_pull(decoder);
-
-                if (frame) {
-                    /* Add relation between schroframe and pts. */
-                    framewithpts = av_malloc(sizeof(LibSchroFrameContext));
-                    if (!framewithpts) {
-                        av_log(avctx, AV_LOG_ERROR, "Unable to allocate FrameWithPts\n");
-                        return AVERROR(ENOMEM);
-                    }
-                    framewithpts->frame = frame;
-                    framewithpts->pts   = AV_RN64(tag->value);
-                    ff_schro_queue_push_back(&p_schro_params->dec_frame_queue,
-                                             framewithpts);
-                }
-                break;
-            case SCHRO_DECODER_EOS:
-                go = 0;
-                p_schro_params->eos_pulled = 1;
-                schro_decoder_reset(decoder);
-                outer = 0;
-                break;
-
-            case SCHRO_DECODER_ERROR:
-                return -1;
-                break;
-            }
-        }
-    } while (outer);
-
-    /* Grab next frame to be returned from the top of the queue. */
-    framewithpts = ff_schro_queue_pop(&p_schro_params->dec_frame_queue);
-
-    if (framewithpts && framewithpts->frame) {
-        int ret;
-
-        if ((ret = ff_get_buffer(avctx, avframe, 0)) < 0)
-            return ret;
-
-        memcpy(avframe->data[0],
-               framewithpts->frame->components[0].data,
-               framewithpts->frame->components[0].length);
-
-        memcpy(avframe->data[1],
-               framewithpts->frame->components[1].data,
-               framewithpts->frame->components[1].length);
-
-        memcpy(avframe->data[2],
-               framewithpts->frame->components[2].data,
-               framewithpts->frame->components[2].length);
-
-        /* Fill frame with current buffer data from Schroedinger. */
-        avframe->pts = framewithpts->pts;
-#if FF_API_PKT_PTS
-FF_DISABLE_DEPRECATION_WARNINGS
-        avframe->pkt_pts = avframe->pts;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-        avframe->linesize[0] = framewithpts->frame->components[0].stride;
-        avframe->linesize[1] = framewithpts->frame->components[1].stride;
-        avframe->linesize[2] = framewithpts->frame->components[2].stride;
-
-        *got_frame      = 1;
-
-        /* Now free the frame resources. */
-        libschroedinger_decode_frame_free(framewithpts->frame);
-        av_free(framewithpts);
-    } else {
-        data       = NULL;
-        *got_frame = 0;
-    }
-    return buf_size;
-}
-
-
-static av_cold int libschroedinger_decode_close(AVCodecContext *avctx)
-{
-    SchroDecoderParams *p_schro_params = avctx->priv_data;
-    /* Free the decoder. */
-    schro_decoder_free(p_schro_params->decoder);
-    av_freep(&p_schro_params->format);
-
-    /* Free data in the output frame queue. */
-    ff_schro_queue_free(&p_schro_params->dec_frame_queue,
-                        libschroedinger_decode_frame_free);
-
-    return 0;
-}
-
-static void libschroedinger_flush(AVCodecContext *avctx)
-{
-    /* Got a seek request. Free the decoded frames queue and then reset
-     * the decoder */
-    SchroDecoderParams *p_schro_params = avctx->priv_data;
-
-    /* Free data in the output frame queue. */
-    ff_schro_queue_free(&p_schro_params->dec_frame_queue,
-                        libschroedinger_decode_frame_free);
-
-    ff_schro_queue_init(&p_schro_params->dec_frame_queue);
-    schro_decoder_reset(p_schro_params->decoder);
-    p_schro_params->eos_pulled = 0;
-    p_schro_params->eos_signalled = 0;
-}
-
-AVCodec ff_libschroedinger_decoder = {
-    .name           = "libschroedinger",
-    .long_name      = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"),
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_DIRAC,
-    .priv_data_size = sizeof(SchroDecoderParams),
-    .init           = libschroedinger_decode_init,
-    .close          = libschroedinger_decode_close,
-    .decode         = libschroedinger_decode_frame,
-    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
-    .flush          = libschroedinger_flush,
-};
diff --git a/mythtv/external/FFmpeg/libavcodec/libschroedingerenc.c b/mythtv/external/FFmpeg/libavcodec/libschroedingerenc.c
deleted file mode 100644
index cf4baa1d827..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/libschroedingerenc.c
+++ /dev/null
@@ -1,485 +0,0 @@
-/*
- * Dirac encoder support via Schroedinger libraries
- * Copyright (c) 2008 BBC, Anuradha Suraparaju <asuraparaju at gmail dot com >
- *
- * 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
-* Dirac encoder support via libschroedinger-1.0 libraries. More details about
-* the Schroedinger project can be found at http://www.diracvideo.org/.
-* The library implements Dirac Specification Version 2.2
-* (http://dirac.sourceforge.net/specification.html).
-*/
-
-#include <schroedinger/schro.h>
-#include <schroedinger/schrodebug.h>
-#include <schroedinger/schrovideoformat.h>
-
-#include "libavutil/attributes.h"
-#include "libavutil/avassert.h"
-#include "libavutil/imgutils.h"
-#include "libavutil/opt.h"
-
-#include "avcodec.h"
-#include "internal.h"
-#include "libschroedinger.h"
-#include "bytestream.h"
-
-
-/** libschroedinger encoder private data */
-typedef struct SchroEncoderParams {
-    AVClass        *class;
-
-    /** Schroedinger video format */
-    SchroVideoFormat *format;
-
-    /** Schroedinger frame format */
-    SchroFrameFormat frame_format;
-
-    /** frame size */
-    int frame_size;
-
-    /** Schroedinger encoder handle*/
-    SchroEncoder* encoder;
-
-    /** buffer to store encoder output before writing it to the frame queue*/
-    unsigned char *enc_buf;
-
-    /** Size of encoder buffer*/
-    int enc_buf_size;
-
-    /** queue storing encoded frames */
-    FFSchroQueue enc_frame_queue;
-
-    /** end of sequence signalled */
-    int eos_signalled;
-
-    /** end of sequence pulled */
-    int eos_pulled;
-
-    /* counter for frames submitted to encoder, used as dts */
-    int64_t dts;
-
-    /** enable noarith */
-    int noarith;
-} SchroEncoderParams;
-
-/**
-* Works out Schro-compatible chroma format.
-*/
-static int set_chroma_format(AVCodecContext *avctx)
-{
-    int num_formats = sizeof(schro_pixel_format_map) /
-                      sizeof(schro_pixel_format_map[0]);
-    int idx;
-
-    SchroEncoderParams *p_schro_params = avctx->priv_data;
-
-    for (idx = 0; idx < num_formats; ++idx) {
-        if (schro_pixel_format_map[idx].ff_pix_fmt == avctx->pix_fmt) {
-            p_schro_params->format->chroma_format =
-                            schro_pixel_format_map[idx].schro_pix_fmt;
-            return 0;
-        }
-    }
-
-    av_log(avctx, AV_LOG_ERROR,
-           "This codec currently only supports planar YUV 4:2:0, 4:2:2"
-           " and 4:4:4 formats.\n");
-
-    return -1;
-}
-
-static av_cold int libschroedinger_encode_init(AVCodecContext *avctx)
-{
-    SchroEncoderParams *p_schro_params = avctx->priv_data;
-    SchroVideoFormatEnum preset;
-
-    /* Initialize the libraries that libschroedinger depends on. */
-    schro_init();
-
-    /* Create an encoder object. */
-    p_schro_params->encoder = schro_encoder_new();
-
-    if (!p_schro_params->encoder) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Unrecoverable Error: schro_encoder_new failed. ");
-        return -1;
-    }
-
-    /* Initialize the format. */
-    preset = ff_get_schro_video_format_preset(avctx);
-    p_schro_params->format =
-                    schro_encoder_get_video_format(p_schro_params->encoder);
-    schro_video_format_set_std_video_format(p_schro_params->format, preset);
-    p_schro_params->format->width  = avctx->width;
-    p_schro_params->format->height = avctx->height;
-
-    if (set_chroma_format(avctx) == -1)
-        return -1;
-
-    if (avctx->color_primaries == AVCOL_PRI_BT709) {
-        p_schro_params->format->colour_primaries = SCHRO_COLOUR_PRIMARY_HDTV;
-    } else if (avctx->color_primaries == AVCOL_PRI_BT470BG) {
-        p_schro_params->format->colour_primaries = SCHRO_COLOUR_PRIMARY_SDTV_625;
-    } else if (avctx->color_primaries == AVCOL_PRI_SMPTE170M) {
-        p_schro_params->format->colour_primaries = SCHRO_COLOUR_PRIMARY_SDTV_525;
-    }
-
-    if (avctx->colorspace == AVCOL_SPC_BT709) {
-        p_schro_params->format->colour_matrix = SCHRO_COLOUR_MATRIX_HDTV;
-    } else if (avctx->colorspace == AVCOL_SPC_BT470BG) {
-        p_schro_params->format->colour_matrix = SCHRO_COLOUR_MATRIX_SDTV;
-    }
-
-    if (avctx->color_trc == AVCOL_TRC_BT709) {
-        p_schro_params->format->transfer_function = SCHRO_TRANSFER_CHAR_TV_GAMMA;
-    }
-
-    if (ff_get_schro_frame_format(p_schro_params->format->chroma_format,
-                                  &p_schro_params->frame_format) == -1) {
-        av_log(avctx, AV_LOG_ERROR,
-               "This codec currently supports only planar YUV 4:2:0, 4:2:2"
-               " and 4:4:4 formats.\n");
-        return -1;
-    }
-
-    p_schro_params->format->frame_rate_numerator   = avctx->time_base.den;
-    p_schro_params->format->frame_rate_denominator = avctx->time_base.num;
-
-    p_schro_params->frame_size = av_image_get_buffer_size(avctx->pix_fmt,
-                                                          avctx->width,
-                                                          avctx->height, 1);
-
-    if (!avctx->gop_size) {
-        schro_encoder_setting_set_double(p_schro_params->encoder,
-                                         "gop_structure",
-                                         SCHRO_ENCODER_GOP_INTRA_ONLY);
-
-#if FF_API_CODER_TYPE
-FF_DISABLE_DEPRECATION_WARNINGS
-        if (avctx->coder_type != FF_CODER_TYPE_VLC)
-            p_schro_params->noarith = 0;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-        schro_encoder_setting_set_double(p_schro_params->encoder,
-                                         "enable_noarith",
-                                         p_schro_params->noarith);
-    } else {
-        schro_encoder_setting_set_double(p_schro_params->encoder,
-                                         "au_distance", avctx->gop_size);
-        avctx->has_b_frames = 1;
-        p_schro_params->dts = -1;
-    }
-
-    /* FIXME - Need to handle SCHRO_ENCODER_RATE_CONTROL_LOW_DELAY. */
-    if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
-        if (!avctx->global_quality) {
-            /* lossless coding */
-            schro_encoder_setting_set_double(p_schro_params->encoder,
-                                             "rate_control",
-                                             SCHRO_ENCODER_RATE_CONTROL_LOSSLESS);
-        } else {
-            int quality;
-            schro_encoder_setting_set_double(p_schro_params->encoder,
-                                             "rate_control",
-                                             SCHRO_ENCODER_RATE_CONTROL_CONSTANT_QUALITY);
-
-            quality = avctx->global_quality / FF_QP2LAMBDA;
-            if (quality > 10)
-                quality = 10;
-            schro_encoder_setting_set_double(p_schro_params->encoder,
-                                             "quality", quality);
-        }
-    } else {
-        schro_encoder_setting_set_double(p_schro_params->encoder,
-                                         "rate_control",
-                                         SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE);
-
-        schro_encoder_setting_set_double(p_schro_params->encoder,
-                                         "bitrate", avctx->bit_rate);
-    }
-
-    if (avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)
-        /* All material can be coded as interlaced or progressive
-           irrespective of the type of source material. */
-        schro_encoder_setting_set_double(p_schro_params->encoder,
-                                         "interlaced_coding", 1);
-
-    schro_encoder_setting_set_double(p_schro_params->encoder, "open_gop",
-                                     !(avctx->flags & AV_CODEC_FLAG_CLOSED_GOP));
-
-    /* FIXME: Signal range hardcoded to 8-bit data until both libschroedinger
-     * and libdirac support other bit-depth data. */
-    schro_video_format_set_std_signal_range(p_schro_params->format,
-                                            SCHRO_SIGNAL_RANGE_8BIT_VIDEO);
-
-    /* Set the encoder format. */
-    schro_encoder_set_video_format(p_schro_params->encoder,
-                                   p_schro_params->format);
-
-    /* Set the debug level. */
-    schro_debug_set_level(avctx->debug);
-
-    schro_encoder_start(p_schro_params->encoder);
-
-    /* Initialize the encoded frame queue. */
-    ff_schro_queue_init(&p_schro_params->enc_frame_queue);
-    return 0;
-}
-
-static SchroFrame *libschroedinger_frame_from_data(AVCodecContext *avctx,
-                                                   const AVFrame *frame)
-{
-    SchroEncoderParams *p_schro_params = avctx->priv_data;
-    SchroFrame *in_frame = ff_create_schro_frame(avctx,
-                                                 p_schro_params->frame_format);
-
-    if (in_frame) {
-        /* Copy input data to SchroFrame buffers (they match the ones
-         * referenced by the AVFrame stored in priv) */
-        if (av_frame_copy(in_frame->priv, frame) < 0) {
-            av_log(avctx, AV_LOG_ERROR, "Failed to copy input data\n");
-            return NULL;
-        }
-    }
-
-    return in_frame;
-}
-
-static void libschroedinger_free_frame(void *data)
-{
-    FFSchroEncodedFrame *enc_frame = data;
-
-    av_freep(&enc_frame->p_encbuf);
-    av_free(enc_frame);
-}
-
-static int libschroedinger_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
-                                        const AVFrame *frame, int *got_packet)
-{
-    int enc_size = 0;
-    SchroEncoderParams *p_schro_params = avctx->priv_data;
-    SchroEncoder *encoder = p_schro_params->encoder;
-    struct FFSchroEncodedFrame *p_frame_output = NULL;
-    int go = 1;
-    SchroBuffer *enc_buf;
-    int presentation_frame;
-    int parse_code;
-    int last_frame_in_sequence = 0;
-    int pkt_size, ret;
-
-    if (!frame) {
-        /* Push end of sequence if not already signalled. */
-        if (!p_schro_params->eos_signalled) {
-            schro_encoder_end_of_stream(encoder);
-            p_schro_params->eos_signalled = 1;
-        }
-    } else {
-        /* Allocate frame data to schro input buffer. */
-        SchroFrame *in_frame = libschroedinger_frame_from_data(avctx, frame);
-        if (!in_frame)
-            return AVERROR(ENOMEM);
-        /* Load next frame. */
-        schro_encoder_push_frame(encoder, in_frame);
-    }
-
-    if (p_schro_params->eos_pulled)
-        go = 0;
-
-    /* Now check to see if we have any output from the encoder. */
-    while (go) {
-        int err;
-        SchroStateEnum state;
-        state = schro_encoder_wait(encoder);
-        switch (state) {
-        case SCHRO_STATE_HAVE_BUFFER:
-        case SCHRO_STATE_END_OF_STREAM:
-            enc_buf = schro_encoder_pull(encoder, &presentation_frame);
-            if (enc_buf->length <= 0)
-                return AVERROR_BUG;
-            parse_code = enc_buf->data[4];
-
-            /* All non-frame data is prepended to actual frame data to
-             * be able to set the pts correctly. So we don't write data
-             * to the frame output queue until we actually have a frame
-             */
-            if ((err = av_reallocp(&p_schro_params->enc_buf,
-                                   p_schro_params->enc_buf_size +
-                                   enc_buf->length)) < 0) {
-                p_schro_params->enc_buf_size = 0;
-                return err;
-            }
-
-            memcpy(p_schro_params->enc_buf + p_schro_params->enc_buf_size,
-                   enc_buf->data, enc_buf->length);
-            p_schro_params->enc_buf_size += enc_buf->length;
-
-
-            if (state == SCHRO_STATE_END_OF_STREAM) {
-                p_schro_params->eos_pulled = 1;
-                go = 0;
-            }
-
-            if (!SCHRO_PARSE_CODE_IS_PICTURE(parse_code)) {
-                schro_buffer_unref(enc_buf);
-                break;
-            }
-
-            /* Create output frame. */
-            p_frame_output = av_mallocz(sizeof(FFSchroEncodedFrame));
-            if (!p_frame_output)
-                return AVERROR(ENOMEM);
-            /* Set output data. */
-            p_frame_output->size     = p_schro_params->enc_buf_size;
-            p_frame_output->p_encbuf = p_schro_params->enc_buf;
-            if (SCHRO_PARSE_CODE_IS_INTRA(parse_code) &&
-                SCHRO_PARSE_CODE_IS_REFERENCE(parse_code))
-                p_frame_output->key_frame = 1;
-
-            /* Parse the coded frame number from the bitstream. Bytes 14
-             * through 17 represent the frame number. */
-            p_frame_output->frame_num = AV_RB32(enc_buf->data + 13);
-
-            ff_schro_queue_push_back(&p_schro_params->enc_frame_queue,
-                                     p_frame_output);
-            p_schro_params->enc_buf_size = 0;
-            p_schro_params->enc_buf      = NULL;
-
-            schro_buffer_unref(enc_buf);
-
-            break;
-
-        case SCHRO_STATE_NEED_FRAME:
-            go = 0;
-            break;
-
-        case SCHRO_STATE_AGAIN:
-            break;
-
-        default:
-            av_log(avctx, AV_LOG_ERROR, "Unknown Schro Encoder state\n");
-            return -1;
-        }
-    }
-
-    /* Copy 'next' frame in queue. */
-
-    if (p_schro_params->enc_frame_queue.size == 1 &&
-        p_schro_params->eos_pulled)
-        last_frame_in_sequence = 1;
-
-    p_frame_output = ff_schro_queue_pop(&p_schro_params->enc_frame_queue);
-
-    if (!p_frame_output)
-        return 0;
-
-    pkt_size = p_frame_output->size;
-    if (last_frame_in_sequence && p_schro_params->enc_buf_size > 0)
-        pkt_size += p_schro_params->enc_buf_size;
-    if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
-        goto error;
-
-    memcpy(pkt->data, p_frame_output->p_encbuf, p_frame_output->size);
-#if FF_API_CODED_FRAME
-FF_DISABLE_DEPRECATION_WARNINGS
-    avctx->coded_frame->key_frame = p_frame_output->key_frame;
-    avctx->coded_frame->pts = p_frame_output->frame_num;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-    /* Use the frame number of the encoded frame as the pts. It is OK to
-     * do so since Dirac is a constant frame rate codec. It expects input
-     * to be of constant frame rate. */
-    pkt->pts = p_frame_output->frame_num;
-    pkt->dts = p_schro_params->dts++;
-    enc_size = p_frame_output->size;
-
-    /* Append the end of sequence information to the last frame in the
-     * sequence. */
-    if (last_frame_in_sequence && p_schro_params->enc_buf_size > 0) {
-        memcpy(pkt->data + enc_size, p_schro_params->enc_buf,
-               p_schro_params->enc_buf_size);
-        enc_size += p_schro_params->enc_buf_size;
-        av_freep(&p_schro_params->enc_buf);
-        p_schro_params->enc_buf_size = 0;
-    }
-
-    if (p_frame_output->key_frame)
-        pkt->flags |= AV_PKT_FLAG_KEY;
-    *got_packet = 1;
-
-error:
-    /* free frame */
-    libschroedinger_free_frame(p_frame_output);
-    return ret;
-}
-
-
-static int libschroedinger_encode_close(AVCodecContext *avctx)
-{
-    SchroEncoderParams *p_schro_params = avctx->priv_data;
-
-    /* Close the encoder. */
-    schro_encoder_free(p_schro_params->encoder);
-
-    /* Free data in the output frame queue. */
-    ff_schro_queue_free(&p_schro_params->enc_frame_queue,
-                        libschroedinger_free_frame);
-
-
-    /* Free the encoder buffer. */
-    if (p_schro_params->enc_buf_size)
-        av_freep(&p_schro_params->enc_buf);
-
-    /* Free the video format structure. */
-    av_freep(&p_schro_params->format);
-
-    return 0;
-}
-
-#define OFFSET(x) offsetof(SchroEncoderParams, x)
-#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
-static const AVOption options[] = {
-    { "noarith", "Enable noarith", OFFSET(noarith), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
-
-    { NULL },
-};
-
-static const AVClass libschroedinger_class = {
-    .class_name = "libschroedinger",
-    .item_name  = av_default_item_name,
-    .option     = options,
-    .version    = LIBAVUTIL_VERSION_INT,
-};
-
-AVCodec ff_libschroedinger_encoder = {
-    .name           = "libschroedinger",
-    .long_name      = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"),
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_DIRAC,
-    .priv_data_size = sizeof(SchroEncoderParams),
-    .priv_class     = &libschroedinger_class,
-    .init           = libschroedinger_encode_init,
-    .encode2        = libschroedinger_encode_frame,
-    .close          = libschroedinger_encode_close,
-    .capabilities   = AV_CODEC_CAP_DELAY,
-    .pix_fmts       = (const enum AVPixelFormat[]){
-        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_NONE
-    },
-};
diff --git a/mythtv/external/FFmpeg/libavcodec/libspeexenc.c b/mythtv/external/FFmpeg/libavcodec/libspeexenc.c
index 4bdb9618dd3..a2b07a41cbf 100644
--- a/mythtv/external/FFmpeg/libavcodec/libspeexenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/libspeexenc.c
@@ -125,10 +125,10 @@ static av_cold void print_enc_params(AVCodecContext *avctx,
         av_log(avctx, AV_LOG_DEBUG, "  quality: %f\n", s->vbr_quality);
     } else if (s->abr) {
         av_log(avctx, AV_LOG_DEBUG, "rate control: ABR\n");
-        av_log(avctx, AV_LOG_DEBUG, "  bitrate: %"PRId64" bps\n", (int64_t)avctx->bit_rate);
+        av_log(avctx, AV_LOG_DEBUG, "  bitrate: %"PRId64" bps\n", avctx->bit_rate);
     } else {
         av_log(avctx, AV_LOG_DEBUG, "rate control: CBR\n");
-        av_log(avctx, AV_LOG_DEBUG, "  bitrate: %"PRId64" bps\n", (int64_t)avctx->bit_rate);
+        av_log(avctx, AV_LOG_DEBUG, "  bitrate: %"PRId64" bps\n", avctx->bit_rate);
     }
     av_log(avctx, AV_LOG_DEBUG, "complexity: %d\n",
            avctx->compression_level);
diff --git a/mythtv/external/FFmpeg/libavcodec/libvpxdec.c b/mythtv/external/FFmpeg/libavcodec/libvpxdec.c
index 5204c993cd7..ad0ea3b02aa 100644
--- a/mythtv/external/FFmpeg/libavcodec/libvpxdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/libvpxdec.c
@@ -244,6 +244,13 @@ static int vpx_decode(AVCodecContext *avctx,
          (img_alpha = vpx_codec_get_frame(&ctx->decoder_alpha, &iter_alpha)))) {
         uint8_t *planes[4];
         int linesizes[4];
+
+        if (img->d_w > img->w || img->d_h > img->h) {
+            av_log(avctx, AV_LOG_ERROR, "Display dimensions %dx%d exceed storage %dx%d\n",
+                   img->d_w, img->d_h, img->w, img->h);
+            return AVERROR_EXTERNAL;
+        }
+
         if ((ret = set_pix_fmt(avctx, img, ctx->has_alpha_channel)) < 0) {
 #ifdef VPX_IMG_FMT_HIGHBITDEPTH
             av_log(avctx, AV_LOG_ERROR, "Unsupported output colorspace (%d) / bit_depth (%d)\n",
diff --git a/mythtv/external/FFmpeg/libavcodec/libvpxenc.c b/mythtv/external/FFmpeg/libavcodec/libvpxenc.c
index 68f25a48187..64a74593310 100644
--- a/mythtv/external/FFmpeg/libavcodec/libvpxenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/libvpxenc.c
@@ -107,6 +107,8 @@ typedef struct VPxEncoderContext {
     int drop_threshold;
     int noise_sensitivity;
     int vpx_cs;
+    float level;
+    int row_mt;
 } VPxContext;
 
 /** String mappings for enum vp8e_enc_control_id */
@@ -134,6 +136,13 @@ static const char *const ctlidstr[] = {
 #if VPX_ENCODER_ABI_VERSION >= 11
     [VP9E_SET_COLOR_RANGE]             = "VP9E_SET_COLOR_RANGE",
 #endif
+#if VPX_ENCODER_ABI_VERSION >= 12
+    [VP9E_SET_TARGET_LEVEL]            = "VP9E_SET_TARGET_LEVEL",
+    [VP9E_GET_LEVEL]                   = "VP9E_GET_LEVEL",
+#endif
+#ifdef VPX_CTRL_VP9E_SET_ROW_MT
+    [VP9E_SET_ROW_MT]                  = "VP9E_SET_ROW_MT",
+#endif
 #endif
 };
 
@@ -260,10 +269,42 @@ static av_cold int codecctl_int(AVCodecContext *avctx,
     return res == VPX_CODEC_OK ? 0 : AVERROR(EINVAL);
 }
 
+#if VPX_ENCODER_ABI_VERSION >= 12
+static av_cold int codecctl_intp(AVCodecContext *avctx,
+                                 enum vp8e_enc_control_id id, int *val)
+{
+    VPxContext *ctx = avctx->priv_data;
+    char buf[80];
+    int width = -30;
+    int res;
+
+    snprintf(buf, sizeof(buf), "%s:", ctlidstr[id]);
+    av_log(avctx, AV_LOG_DEBUG, "  %*s%d\n", width, buf, *val);
+
+    res = vpx_codec_control(&ctx->encoder, id, val);
+    if (res != VPX_CODEC_OK) {
+        snprintf(buf, sizeof(buf), "Failed to set %s codec control",
+                 ctlidstr[id]);
+        log_encoder_error(avctx, buf);
+    }
+
+    return res == VPX_CODEC_OK ? 0 : AVERROR(EINVAL);
+}
+#endif
+
 static av_cold int vpx_free(AVCodecContext *avctx)
 {
     VPxContext *ctx = avctx->priv_data;
 
+#if VPX_ENCODER_ABI_VERSION >= 12
+    if (avctx->codec_id == AV_CODEC_ID_VP9 && ctx->level >= 0 &&
+        !(avctx->flags & AV_CODEC_FLAG_PASS1)) {
+        int level_out = 0;
+        if (!codecctl_intp(avctx, VP9E_GET_LEVEL, &level_out))
+            av_log(avctx, AV_LOG_INFO, "Encoded level %.1f\n", level_out * 0.1);
+    }
+#endif
+
     vpx_codec_destroy(&ctx->encoder);
     if (ctx->is_alpha)
         vpx_codec_destroy(&ctx->encoder_alpha);
@@ -679,6 +720,13 @@ FF_ENABLE_DEPRECATION_WARNINGS
 #endif
 #if VPX_ENCODER_ABI_VERSION >= 11
         set_color_range(avctx);
+#endif
+#if VPX_ENCODER_ABI_VERSION >= 12
+        codecctl_int(avctx, VP9E_SET_TARGET_LEVEL, ctx->level < 0 ? 255 : lrint(ctx->level * 10));
+#endif
+#ifdef VPX_CTRL_VP9E_SET_ROW_MT
+        if (ctx->row_mt >= 0)
+            codecctl_int(avctx, VP9E_SET_ROW_MT, ctx->row_mt);
 #endif
     }
 #endif
@@ -972,6 +1020,16 @@ static int vpx_encode(AVCodecContext *avctx, AVPacket *pkt,
             rawimg_alpha->stride[VPX_PLANE_V] = frame->linesize[2];
         }
         timestamp                   = frame->pts;
+#if VPX_IMAGE_ABI_VERSION >= 4
+        switch (frame->color_range) {
+        case AVCOL_RANGE_MPEG:
+            rawimg->range = VPX_CR_STUDIO_RANGE;
+            break;
+        case AVCOL_RANGE_JPEG:
+            rawimg->range = VPX_CR_FULL_RANGE;
+            break;
+        }
+#endif
         if (frame->pict_type == AV_PICTURE_TYPE_I)
             flags |= VPX_EFLAG_FORCE_KF;
     }
@@ -1084,11 +1142,22 @@ static const AVOption vp9_options[] = {
     { "tile-columns",    "Number of tile columns to use, log2",         OFFSET(tile_columns),    AV_OPT_TYPE_INT, {.i64 = -1}, -1, 6, VE},
     { "tile-rows",       "Number of tile rows to use, log2",            OFFSET(tile_rows),       AV_OPT_TYPE_INT, {.i64 = -1}, -1, 2, VE},
     { "frame-parallel",  "Enable frame parallel decodability features", OFFSET(frame_parallel),  AV_OPT_TYPE_BOOL,{.i64 = -1}, -1, 1, VE},
+#if VPX_ENCODER_ABI_VERSION >= 12
+    { "aq-mode",         "adaptive quantization mode",                  OFFSET(aq_mode),         AV_OPT_TYPE_INT, {.i64 = -1}, -1, 4, VE, "aq_mode"},
+#else
     { "aq-mode",         "adaptive quantization mode",                  OFFSET(aq_mode),         AV_OPT_TYPE_INT, {.i64 = -1}, -1, 3, VE, "aq_mode"},
+#endif
     { "none",            "Aq not used",         0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, VE, "aq_mode" },
     { "variance",        "Variance based Aq",   0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "aq_mode" },
     { "complexity",      "Complexity based Aq", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "aq_mode" },
     { "cyclic",          "Cyclic Refresh Aq",   0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "aq_mode" },
+#if VPX_ENCODER_ABI_VERSION >= 12
+    { "equator360",      "360 video Aq",        0, AV_OPT_TYPE_CONST, {.i64 = 4}, 0, 0, VE, "aq_mode" },
+    {"level", "Specify level", OFFSET(level), AV_OPT_TYPE_FLOAT, {.dbl=-1}, -1, 6.2, VE},
+#endif
+#ifdef VPX_CTRL_VP9E_SET_ROW_MT
+    {"row-mt", "Row based multi-threading", OFFSET(row_mt), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, VE},
+#endif
     LEGACY_OPTIONS
     { NULL }
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/libx264.c b/mythtv/external/FFmpeg/libavcodec/libx264.c
index 9e1246477e6..6b058463654 100644
--- a/mythtv/external/FFmpeg/libavcodec/libx264.c
+++ b/mythtv/external/FFmpeg/libavcodec/libx264.c
@@ -272,6 +272,7 @@ static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame,
                       int *got_packet)
 {
     X264Context *x4 = ctx->priv_data;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(ctx->pix_fmt);
     x264_nal_t *nal;
     int nnal, i, ret;
     x264_picture_t pic_out = {0};
@@ -279,7 +280,7 @@ static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame,
 
     x264_picture_init( &x4->pic );
     x4->pic.img.i_csp   = x4->params.i_csp;
-    if (x264_bit_depth > 8)
+    if (desc->comp[0].depth > 8)
         x4->pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
     x4->pic.img.i_plane = avfmt2_num_planes(ctx->pix_fmt);
 
@@ -293,8 +294,8 @@ static int X264_frame(AVCodecContext *ctx, AVPacket *pkt, const AVFrame *frame,
 
         switch (frame->pict_type) {
         case AV_PICTURE_TYPE_I:
-            x4->pic.i_type = x4->forced_idr >= 0 ? X264_TYPE_IDR
-                                                 : X264_TYPE_KEYFRAME;
+            x4->pic.i_type = x4->forced_idr > 0 ? X264_TYPE_IDR
+                                                : X264_TYPE_KEYFRAME;
             break;
         case AV_PICTURE_TYPE_P:
             x4->pic.i_type = X264_TYPE_P;
@@ -739,6 +740,9 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
     x4->params.i_width          = avctx->width;
     x4->params.i_height         = avctx->height;
+#if X264_BUILD >= 153
+    x4->params.i_bitdepth       = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
+#endif
     av_reduce(&sw, &sh, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 4096);
     x4->params.vui.i_sar_width  = sw;
     x4->params.vui.i_sar_height = sh;
@@ -852,6 +856,24 @@ FF_ENABLE_DEPRECATION_WARNINGS
     return 0;
 }
 
+static const enum AVPixelFormat pix_fmts[] = {
+    AV_PIX_FMT_YUV420P,
+    AV_PIX_FMT_YUVJ420P,
+    AV_PIX_FMT_YUV422P,
+    AV_PIX_FMT_YUVJ422P,
+    AV_PIX_FMT_YUV444P,
+    AV_PIX_FMT_YUVJ444P,
+    AV_PIX_FMT_YUV420P10,
+    AV_PIX_FMT_YUV422P10,
+    AV_PIX_FMT_YUV444P10,
+    AV_PIX_FMT_NV12,
+    AV_PIX_FMT_NV16,
+    AV_PIX_FMT_NV20,
+#ifdef X264_CSP_NV21
+    AV_PIX_FMT_NV21,
+#endif
+    AV_PIX_FMT_NONE
+};
 static const enum AVPixelFormat pix_fmts_8bit[] = {
     AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUVJ420P,
@@ -889,12 +911,16 @@ static const enum AVPixelFormat pix_fmts_8bit_rgb[] = {
 
 static av_cold void X264_init_static(AVCodec *codec)
 {
+#if X264_BUILD < 153
     if (x264_bit_depth == 8)
         codec->pix_fmts = pix_fmts_8bit;
     else if (x264_bit_depth == 9)
         codec->pix_fmts = pix_fmts_9bit;
     else if (x264_bit_depth == 10)
         codec->pix_fmts = pix_fmts_10bit;
+#else
+    codec->pix_fmts = pix_fmts;
+#endif
 }
 
 #define OFFSET(x) offsetof(X264Context, x)
@@ -964,7 +990,7 @@ static const AVOption options[] = {
     { "umh",           NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_UMH },  INT_MIN, INT_MAX, VE, "motion-est" },
     { "esa",           NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_ESA },  INT_MIN, INT_MAX, VE, "motion-est" },
     { "tesa",          NULL, 0, AV_OPT_TYPE_CONST, { .i64 = X264_ME_TESA }, INT_MIN, INT_MAX, VE, "motion-est" },
-    { "forced-idr",   "If forcing keyframes, force them as IDR frames.",                                  OFFSET(forced_idr),  AV_OPT_TYPE_BOOL,   { .i64 = -1 }, -1, 1, VE },
+    { "forced-idr",   "If forcing keyframes, force them as IDR frames.",                                  OFFSET(forced_idr),  AV_OPT_TYPE_BOOL,   { .i64 = 0 }, -1, 1, VE },
     { "coder",    "Coder type",                                           OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "coder" },
     { "default",          NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, VE, "coder" },
     { "cavlc",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 },  INT_MIN, INT_MAX, VE, "coder" },
diff --git a/mythtv/external/FFmpeg/libavcodec/libx265.c b/mythtv/external/FFmpeg/libavcodec/libx265.c
index d25be70ffd7..784b51c52d4 100644
--- a/mythtv/external/FFmpeg/libavcodec/libx265.c
+++ b/mythtv/external/FFmpeg/libavcodec/libx265.c
@@ -42,6 +42,7 @@ typedef struct libx265Context {
     const x265_api *api;
 
     float crf;
+    int   forced_idr;
     char *preset;
     char *tune;
     char *x265_opts;
@@ -166,6 +167,8 @@ static av_cold int libx265_encode_init(AVCodecContext *avctx)
         ctx->params->internalCsp = X265_CSP_I444;
         break;
     case AV_PIX_FMT_GRAY8:
+    case AV_PIX_FMT_GRAY10:
+    case AV_PIX_FMT_GRAY12:
         if (ctx->api->api_build_number < 85) {
             av_log(avctx, AV_LOG_ERROR,
                    "libx265 version is %d, must be at least 85 for gray encoding.\n",
@@ -273,7 +276,8 @@ static int libx265_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
         x265pic.pts      = pic->pts;
         x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
 
-        x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ? X265_TYPE_I :
+        x265pic.sliceType = pic->pict_type == AV_PICTURE_TYPE_I ?
+                                              (ctx->forced_idr ? X265_TYPE_IDR : X265_TYPE_I) :
                             pic->pict_type == AV_PICTURE_TYPE_P ? X265_TYPE_P :
                             pic->pict_type == AV_PICTURE_TYPE_B ? X265_TYPE_B :
                             X265_TYPE_AUTO;
@@ -348,6 +352,7 @@ static const enum AVPixelFormat x265_csp_ten[] = {
     AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_GBRP10,
     AV_PIX_FMT_GRAY8,
+    AV_PIX_FMT_GRAY10,
     AV_PIX_FMT_NONE
 };
 
@@ -365,6 +370,8 @@ static const enum AVPixelFormat x265_csp_twelve[] = {
     AV_PIX_FMT_YUV444P12,
     AV_PIX_FMT_GBRP12,
     AV_PIX_FMT_GRAY8,
+    AV_PIX_FMT_GRAY10,
+    AV_PIX_FMT_GRAY12,
     AV_PIX_FMT_NONE
 };
 
@@ -382,6 +389,7 @@ static av_cold void libx265_encode_init_csp(AVCodec *codec)
 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 static const AVOption options[] = {
     { "crf",         "set the x265 crf",                                                            OFFSET(crf),       AV_OPT_TYPE_FLOAT,  { .dbl = -1 }, -1, FLT_MAX, VE },
+    { "forced-idr",  "if forcing keyframes, force them as IDR frames",                              OFFSET(forced_idr),AV_OPT_TYPE_BOOL,   { .i64 =  0 },  0,       1, VE },
     { "preset",      "set the x265 preset",                                                         OFFSET(preset),    AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
     { "tune",        "set the x265 tune parameter",                                                 OFFSET(tune),      AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
     { "x265-params", "set the x265 configuration using a :-separated list of key=value parameters", OFFSET(x265_opts), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE },
diff --git a/mythtv/external/FFmpeg/libavcodec/libxvid.h b/mythtv/external/FFmpeg/libavcodec/libxvid.h
index ef9a5a9c59c..58bef616608 100644
--- a/mythtv/external/FFmpeg/libavcodec/libxvid.h
+++ b/mythtv/external/FFmpeg/libavcodec/libxvid.h
@@ -26,4 +26,11 @@
  * common functions for use with the Xvid wrappers
  */
 
+struct MpegEncContext;
+
+/* rate control */
+int ff_xvid_rate_control_init(struct MpegEncContext *s);
+void ff_xvid_rate_control_uninit(struct MpegEncContext *s);
+float ff_xvid_rate_estimate_qscale(struct MpegEncContext *s, int dry_run);
+
 #endif /* AVCODEC_LIBXVID_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/libxvid_rc.c b/mythtv/external/FFmpeg/libavcodec/libxvid_rc.c
index 0e25a07502a..076c32c4135 100644
--- a/mythtv/external/FFmpeg/libavcodec/libxvid_rc.c
+++ b/mythtv/external/FFmpeg/libavcodec/libxvid_rc.c
@@ -48,7 +48,7 @@ av_cold int ff_xvid_rate_control_init(MpegEncContext *s)
 
     fd = avpriv_tempfile("xvidrc.", &tmp_name, 0, s->avctx);
     if (fd < 0) {
-        av_log(NULL, AV_LOG_ERROR, "Can't create temporary pass2 file.\n");
+        av_log(s, AV_LOG_ERROR, "Can't create temporary pass2 file.\n");
         return fd;
     }
 
@@ -69,7 +69,7 @@ av_cold int ff_xvid_rate_control_init(MpegEncContext *s)
 
         if (write(fd, tmp, strlen(tmp)) < 0) {
             int ret = AVERROR(errno);
-            av_log(NULL, AV_LOG_ERROR, "Error %s writing 2pass logfile\n", av_err2str(ret));
+            av_log(s, AV_LOG_ERROR, "Error %s writing 2pass logfile\n", av_err2str(ret));
             av_free(tmp_name);
             close(fd);
             return ret;
@@ -92,7 +92,7 @@ av_cold int ff_xvid_rate_control_init(MpegEncContext *s)
 
     if (xvid_plugin_2pass2(NULL, XVID_PLG_CREATE, &xvid_plg_create,
                            &s->rc_context.non_lavc_opaque) < 0) {
-        av_log(NULL, AV_LOG_ERROR, "xvid_plugin_2pass2 failed\n");
+        av_log(s, AV_LOG_ERROR, "xvid_plugin_2pass2 failed\n");
         return -1;
     }
     return 0;
@@ -127,7 +127,7 @@ float ff_xvid_rate_estimate_qscale(MpegEncContext *s, int dry_run)
             xvid_plg_data.type          = s->last_pict_type;
             if (xvid_plugin_2pass2(s->rc_context.non_lavc_opaque,
                                    XVID_PLG_AFTER, &xvid_plg_data, NULL)) {
-                av_log(s->avctx, AV_LOG_ERROR,
+                av_log(s, AV_LOG_ERROR,
                        "xvid_plugin_2pass2(handle, XVID_PLG_AFTER, ...) FAILED\n");
                 return -1;
             }
@@ -137,7 +137,7 @@ float ff_xvid_rate_estimate_qscale(MpegEncContext *s, int dry_run)
         xvid_plg_data.quant               = 0;
         if (xvid_plugin_2pass2(s->rc_context.non_lavc_opaque,
                                XVID_PLG_BEFORE, &xvid_plg_data, NULL)) {
-            av_log(s->avctx, AV_LOG_ERROR,
+            av_log(s, AV_LOG_ERROR,
                    "xvid_plugin_2pass2(handle, XVID_PLG_BEFORE, ...) FAILED\n");
             return -1;
         }
diff --git a/mythtv/external/FFmpeg/libavcodec/libzvbi-teletextdec.c b/mythtv/external/FFmpeg/libavcodec/libzvbi-teletextdec.c
index d1f0a9f78e5..687b6af1293 100644
--- a/mythtv/external/FFmpeg/libavcodec/libzvbi-teletextdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/libzvbi-teletextdec.c
@@ -395,7 +395,7 @@ static int teletext_decode_frame(AVCodecContext *avctx, void *data, int *data_si
     if (!ctx->vbi) {
         if (!(ctx->vbi = vbi_decoder_new()))
             return AVERROR(ENOMEM);
-        if (!vbi_event_handler_add(ctx->vbi, VBI_EVENT_TTX_PAGE, handler, ctx)) {
+        if (!vbi_event_handler_register(ctx->vbi, VBI_EVENT_TTX_PAGE, handler, ctx)) {
             vbi_decoder_delete(ctx->vbi);
             ctx->vbi = NULL;
             return AVERROR(ENOMEM);
diff --git a/mythtv/external/FFmpeg/libavcodec/ljpegenc.c b/mythtv/external/FFmpeg/libavcodec/ljpegenc.c
index afaab05568a..924d2e2fff6 100644
--- a/mythtv/external/FFmpeg/libavcodec/ljpegenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/ljpegenc.c
@@ -40,7 +40,6 @@
 #include "jpegtables.h"
 #include "mjpegenc_common.h"
 #include "mjpeg.h"
-#include "mjpegenc.h"
 
 typedef struct LJpegEncContext {
     AVClass *class;
diff --git a/mythtv/external/FFmpeg/libavcodec/lossless_videodsp.c b/mythtv/external/FFmpeg/libavcodec/lossless_videodsp.c
index 3491621dc48..b5b96e61296 100644
--- a/mythtv/external/FFmpeg/libavcodec/lossless_videodsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/lossless_videodsp.c
@@ -21,55 +21,36 @@
 #include "lossless_videodsp.h"
 #include "libavcodec/mathops.h"
 
-static void add_int16_c(uint16_t *dst, const uint16_t *src, unsigned mask, int w){
-    long i;
-    unsigned long pw_lsb = (mask >> 1) * 0x0001000100010001ULL;
-    unsigned long pw_msb = pw_lsb +  0x0001000100010001ULL;
-    for (i = 0; i <= w - (int)sizeof(long)/2; i += sizeof(long)/2) {
-        long a = *(long*)(src+i);
-        long b = *(long*)(dst+i);
-        *(long*)(dst+i) = ((a&pw_lsb) + (b&pw_lsb)) ^ ((a^b)&pw_msb);
-    }
-    for(; i<w; i++)
-        dst[i] = (dst[i] + src[i]) & mask;
-}
+// 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size
+#define pb_7f (~0UL / 255 * 0x7f)
+#define pb_80 (~0UL / 255 * 0x80)
 
-static void diff_int16_c(uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w){
+static void add_bytes_c(uint8_t *dst, uint8_t *src, ptrdiff_t w)
+{
     long i;
-#if !HAVE_FAST_UNALIGNED
-    if((long)src2 & (sizeof(long)-1)){
-        for(i=0; i+3<w; i+=4){
-            dst[i+0] = (src1[i+0]-src2[i+0]) & mask;
-            dst[i+1] = (src1[i+1]-src2[i+1]) & mask;
-            dst[i+2] = (src1[i+2]-src2[i+2]) & mask;
-            dst[i+3] = (src1[i+3]-src2[i+3]) & mask;
-        }
-    }else
-#endif
-    {
-        unsigned long pw_lsb = (mask >> 1) * 0x0001000100010001ULL;
-        unsigned long pw_msb = pw_lsb +  0x0001000100010001ULL;
-
-        for (i = 0; i <= w - (int)sizeof(long)/2; i += sizeof(long)/2) {
-            long a = *(long*)(src1+i);
-            long b = *(long*)(src2+i);
-            *(long*)(dst+i) = ((a|pw_msb) - (b&pw_lsb)) ^ ((a^b^pw_msb)&pw_msb);
-        }
+
+    for (i = 0; i <= w - (int) sizeof(long); i += sizeof(long)) {
+        long a = *(long *) (src + i);
+        long b = *(long *) (dst + i);
+        *(long *) (dst + i) = ((a & pb_7f) + (b & pb_7f)) ^ ((a ^ b) & pb_80);
     }
-    for (; i<w; i++)
-        dst[i] = (src1[i] - src2[i]) & mask;
+    for (; i < w; i++)
+        dst[i + 0] += src[i + 0];
 }
 
-static void add_hfyu_median_pred_int16_c(uint16_t *dst, const uint16_t *src, const uint16_t *diff, unsigned mask, int w, int *left, int *left_top){
+static void add_median_pred_c(uint8_t *dst, const uint8_t *src1,
+                              const uint8_t *diff, ptrdiff_t w,
+                              int *left, int *left_top)
+{
     int i;
-    uint16_t l, lt;
+    uint8_t l, lt;
 
     l  = *left;
     lt = *left_top;
 
-    for(i=0; i<w; i++){
-        l  = (mid_pred(l, src[i], (l + src[i] - lt) & mask) + diff[i]) & mask;
-        lt = src[i];
+    for (i = 0; i < w; i++) {
+        l      = mid_pred(l, src1[i], (l + src1[i] - lt) & 0xFF) + diff[i];
+        lt     = src1[i];
         dst[i] = l;
     }
 
@@ -77,52 +58,57 @@ static void add_hfyu_median_pred_int16_c(uint16_t *dst, const uint16_t *src, con
     *left_top = lt;
 }
 
-static void sub_hfyu_median_pred_int16_c(uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w, int *left, int *left_top){
+static int add_left_pred_c(uint8_t *dst, const uint8_t *src, ptrdiff_t w,
+                           int acc)
+{
     int i;
-    uint16_t l, lt;
 
-    l  = *left;
-    lt = *left_top;
+    for (i = 0; i < w - 1; i++) {
+        acc   += src[i];
+        dst[i] = acc;
+        i++;
+        acc   += src[i];
+        dst[i] = acc;
+    }
 
-    for(i=0; i<w; i++){
-        const int pred = mid_pred(l, src1[i], (l + src1[i] - lt) & mask);
-        lt = src1[i];
-        l  = src2[i];
-        dst[i] = (l - pred) & mask;
+    for (; i < w; i++) {
+        acc   += src[i];
+        dst[i] = acc;
     }
 
-    *left     = l;
-    *left_top = lt;
+    return acc;
 }
 
-static int add_hfyu_left_pred_int16_c(uint16_t *dst, const uint16_t *src, unsigned mask, int w, unsigned acc){
+static int add_left_pred_int16_c(uint16_t *dst, const uint16_t *src, unsigned mask, ptrdiff_t w, unsigned acc){
     int i;
 
     for(i=0; i<w-1; i++){
         acc+= src[i];
-        dst[i]= acc & mask;
+        dst[i]= acc &= mask;
         i++;
         acc+= src[i];
-        dst[i]= acc & mask;
+        dst[i]= acc &= mask;
     }
 
     for(; i<w; i++){
         acc+= src[i];
-        dst[i]= acc & mask;
+        dst[i]= acc &= mask;
     }
 
     return acc;
 }
 
 
-void ff_llviddsp_init(LLVidDSPContext *c, AVCodecContext *avctx)
+void ff_llviddsp_init(LLVidDSPContext *c)
 {
-    c->add_int16 = add_int16_c;
-    c->diff_int16= diff_int16_c;
-    c->add_hfyu_left_pred_int16   = add_hfyu_left_pred_int16_c;
-    c->add_hfyu_median_pred_int16 = add_hfyu_median_pred_int16_c;
-    c->sub_hfyu_median_pred_int16 = sub_hfyu_median_pred_int16_c;
+    c->add_bytes                  = add_bytes_c;
+    c->add_median_pred            = add_median_pred_c;
+    c->add_left_pred              = add_left_pred_c;
+
+    c->add_left_pred_int16        = add_left_pred_int16_c;
 
+    if (ARCH_PPC)
+        ff_llviddsp_init_ppc(c);
     if (ARCH_X86)
-        ff_llviddsp_init_x86(c, avctx);
+        ff_llviddsp_init_x86(c);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/lossless_videodsp.h b/mythtv/external/FFmpeg/libavcodec/lossless_videodsp.h
index 040902e7ba1..cecf0fe1e51 100644
--- a/mythtv/external/FFmpeg/libavcodec/lossless_videodsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/lossless_videodsp.h
@@ -22,19 +22,27 @@
 #ifndef AVCODEC_LOSSLESS_VIDEODSP_H
 #define AVCODEC_LOSSLESS_VIDEODSP_H
 
+#include <stdint.h>
+#include <stddef.h>
+
 #include "avcodec.h"
 #include "libavutil/cpu.h"
 
 typedef struct LLVidDSPContext {
-    void (*add_int16)(uint16_t *dst/*align 16*/, const uint16_t *src/*align 16*/, unsigned mask, int w);
-    void (*diff_int16)(uint16_t *dst/*align 16*/, const uint16_t *src1/*align 16*/, const uint16_t *src2/*align 1*/, unsigned mask, int w);
+    void (*add_bytes)(uint8_t *dst /* align 16 */, uint8_t *src /* align 16 */,
+                      ptrdiff_t w);
+    void (*add_median_pred)(uint8_t *dst, const uint8_t *top,
+                            const uint8_t *diff, ptrdiff_t w,
+                            int *left, int *left_top);
+    int (*add_left_pred)(uint8_t *dst, const uint8_t *src,
+                         ptrdiff_t w, int left);
 
-    void (*sub_hfyu_median_pred_int16)(uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w, int *left, int *left_top);
-    void (*add_hfyu_median_pred_int16)(uint16_t *dst, const uint16_t *top, const uint16_t *diff, unsigned mask, int w, int *left, int *left_top);
-    int  (*add_hfyu_left_pred_int16)(uint16_t *dst, const uint16_t *src, unsigned mask, int w, unsigned left);
+    int  (*add_left_pred_int16)(uint16_t *dst, const uint16_t *src,
+                                unsigned mask, ptrdiff_t w, unsigned left);
 } LLVidDSPContext;
 
-void ff_llviddsp_init(LLVidDSPContext *llviddsp, AVCodecContext *avctx);
-void ff_llviddsp_init_x86(LLVidDSPContext *llviddsp, AVCodecContext *avctx);
+void ff_llviddsp_init(LLVidDSPContext *llviddsp);
+void ff_llviddsp_init_x86(LLVidDSPContext *llviddsp);
+void ff_llviddsp_init_ppc(LLVidDSPContext *llviddsp);
 
 #endif //AVCODEC_LOSSLESS_VIDEODSP_H
diff --git a/mythtv/external/FFmpeg/libavcodec/lossless_videoencdsp.c b/mythtv/external/FFmpeg/libavcodec/lossless_videoencdsp.c
new file mode 100644
index 00000000000..5cc4934c0ef
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/lossless_videoencdsp.c
@@ -0,0 +1,84 @@
+/*
+ * 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 "lossless_videoencdsp.h"
+#include "mathops.h"
+
+// 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size
+#define pb_7f (~0UL / 255 * 0x7f)
+#define pb_80 (~0UL / 255 * 0x80)
+
+static void diff_bytes_c(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, intptr_t w)
+{
+    long i;
+
+#if !HAVE_FAST_UNALIGNED
+    if (((long)src1 | (long)src2) & (sizeof(long) - 1)) {
+        for (i = 0; i + 7 < w; i += 8) {
+            dst[i + 0] = src1[i + 0] - src2[i + 0];
+            dst[i + 1] = src1[i + 1] - src2[i + 1];
+            dst[i + 2] = src1[i + 2] - src2[i + 2];
+            dst[i + 3] = src1[i + 3] - src2[i + 3];
+            dst[i + 4] = src1[i + 4] - src2[i + 4];
+            dst[i + 5] = src1[i + 5] - src2[i + 5];
+            dst[i + 6] = src1[i + 6] - src2[i + 6];
+            dst[i + 7] = src1[i + 7] - src2[i + 7];
+        }
+    } else
+#endif
+    for (i = 0; i <= w - (int) sizeof(long); i += sizeof(long)) {
+        long a = *(long *) (src1 + i);
+        long b = *(long *) (src2 + i);
+        *(long *) (dst + i) = ((a | pb_80) - (b & pb_7f)) ^
+                              ((a ^ b ^ pb_80) & pb_80);
+    }
+    for (; i < w; i++)
+        dst[i + 0] = src1[i + 0] - src2[i + 0];
+}
+
+static void sub_median_pred_c(uint8_t *dst, const uint8_t *src1,
+                              const uint8_t *src2, intptr_t w,
+                              int *left, int *left_top)
+{
+    int i;
+    uint8_t l, lt;
+
+    l  = *left;
+    lt = *left_top;
+
+    for (i = 0; i < w; i++) {
+        const int pred = mid_pred(l, src1[i], (l + src1[i] - lt) & 0xFF);
+        lt     = src1[i];
+        l      = src2[i];
+        dst[i] = l - pred;
+    }
+
+    *left     = l;
+    *left_top = lt;
+}
+
+av_cold void ff_llvidencdsp_init(LLVidEncDSPContext *c)
+{
+    c->diff_bytes      = diff_bytes_c;
+    c->sub_median_pred = sub_median_pred_c;
+
+    if (ARCH_X86)
+        ff_llvidencdsp_init_x86(c);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/lossless_videoencdsp.h b/mythtv/external/FFmpeg/libavcodec/lossless_videoencdsp.h
new file mode 100644
index 00000000000..3d645b159ad
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/lossless_videoencdsp.h
@@ -0,0 +1,41 @@
+/*
+ * 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_LOSSLESS_VIDEOENCDSP_H
+#define AVCODEC_LOSSLESS_VIDEOENCDSP_H
+
+#include <stdint.h>
+
+typedef struct LLVidEncDSPContext {
+    void (*diff_bytes)(uint8_t *dst /* align 16 */,
+                       const uint8_t *src1 /* align 16 */,
+                       const uint8_t *src2 /* align 1 */,
+                       intptr_t w);
+    /**
+     * Subtract HuffYUV's variant of median prediction.
+     * Note, this might read from src1[-1], src2[-1].
+     */
+    void (*sub_median_pred)(uint8_t *dst, const uint8_t *src1,
+                            const uint8_t *src2, intptr_t w,
+                            int *left, int *left_top);
+} LLVidEncDSPContext;
+
+void ff_llvidencdsp_init(LLVidEncDSPContext *c);
+void ff_llvidencdsp_init_x86(LLVidEncDSPContext *c);
+
+#endif /* AVCODEC_LOSSLESS_VIDEOENCDSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/lpc.h b/mythtv/external/FFmpeg/libavcodec/lpc.h
index 182adfa8cae..88ca247f87b 100644
--- a/mythtv/external/FFmpeg/libavcodec/lpc.h
+++ b/mythtv/external/FFmpeg/libavcodec/lpc.h
@@ -117,11 +117,14 @@ void ff_lpc_end(LPCContext *s);
 
 #if USE_FIXED
 typedef int LPC_TYPE;
+typedef unsigned LPC_TYPE_U;
 #else
 #ifdef LPC_USE_DOUBLE
 typedef double LPC_TYPE;
+typedef double LPC_TYPE_U;
 #else
 typedef float LPC_TYPE;
+typedef float LPC_TYPE_U;
 #endif
 #endif // USE_FIXED
 
@@ -192,8 +195,8 @@ static inline int AAC_RENAME(compute_lpc_coefs)(const LPC_TYPE *autoc, int max_o
         for(j=0; j < (i+1)>>1; j++) {
             LPC_TYPE f = lpc_last[    j];
             LPC_TYPE b = lpc_last[i-1-j];
-            lpc[    j] = f + AAC_MUL26(r, b);
-            lpc[i-1-j] = b + AAC_MUL26(r, f);
+            lpc[    j] = f + (LPC_TYPE_U)AAC_MUL26(r, b);
+            lpc[i-1-j] = b + (LPC_TYPE_U)AAC_MUL26(r, f);
         }
 
         if (fail && err < 0)
diff --git a/mythtv/external/FFmpeg/libavcodec/lzf.c b/mythtv/external/FFmpeg/libavcodec/lzf.c
index 409a7ffdd39..5b7526ef185 100644
--- a/mythtv/external/FFmpeg/libavcodec/lzf.c
+++ b/mythtv/external/FFmpeg/libavcodec/lzf.c
@@ -53,6 +53,7 @@ int ff_lzf_uncompress(GetByteContext *gb, uint8_t **buf, int64_t *size)
                 ret = av_reallocp(buf, *size);
                 if (ret < 0)
                     return ret;
+                p = *buf + len;
             }
 
             bytestream2_get_buffer(gb, p, s);
@@ -75,6 +76,7 @@ int ff_lzf_uncompress(GetByteContext *gb, uint8_t **buf, int64_t *size)
                 ret = av_reallocp(buf, *size);
                 if (ret < 0)
                     return ret;
+                p = *buf + len;
             }
 
             av_memcpy_backptr(p, off, l);
diff --git a/mythtv/external/FFmpeg/libavcodec/m101.c b/mythtv/external/FFmpeg/libavcodec/m101.c
index 939d337bfff..d2549668fd6 100644
--- a/mythtv/external/FFmpeg/libavcodec/m101.c
+++ b/mythtv/external/FFmpeg/libavcodec/m101.c
@@ -27,7 +27,7 @@
 static av_cold int m101_decode_init(AVCodecContext *avctx)
 {
     if (avctx->extradata_size < 6*4) {
-        avpriv_request_sample(avctx, "Missing or too small extradata (size %d)\n", avctx->extradata_size);
+        avpriv_request_sample(avctx, "Missing or too small extradata (size %d)", avctx->extradata_size);
         return AVERROR_INVALIDDATA;
     }
 
@@ -36,7 +36,7 @@ static av_cold int m101_decode_init(AVCodecContext *avctx)
     else if (avctx->extradata[2*4] == 8) {
         avctx->pix_fmt = AV_PIX_FMT_YUYV422;
     } else {
-        avpriv_request_sample(avctx, "BPS %d\n", avctx->extradata[2*4]);
+        avpriv_request_sample(avctx, "BPS %d", avctx->extradata[2*4]);
         return AVERROR_INVALIDDATA;
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/magicyuv.c b/mythtv/external/FFmpeg/libavcodec/magicyuv.c
index 2c312bec170..3c1a89077bf 100644
--- a/mythtv/external/FFmpeg/libavcodec/magicyuv.c
+++ b/mythtv/external/FFmpeg/libavcodec/magicyuv.c
@@ -30,6 +30,7 @@
 #include "get_bits.h"
 #include "huffyuvdsp.h"
 #include "internal.h"
+#include "lossless_videodsp.h"
 #include "thread.h"
 
 typedef struct Slice {
@@ -44,26 +45,33 @@ typedef enum Prediction {
 } Prediction;
 
 typedef struct HuffEntry {
-    uint8_t  sym;
+    uint16_t sym;
     uint8_t  len;
     uint32_t code;
 } HuffEntry;
 
 typedef struct MagicYUVContext {
     AVFrame          *p;
+    int               max;
+    int               bps;
     int               slice_height;
     int               nb_slices;
     int               planes;         // number of encoded planes in bitstream
     int               decorrelate;    // postprocessing work
+    int               color_matrix;   // video color matrix
+    int               flags;
     int               interlaced;     // video is interlaced
     uint8_t          *buf;            // pointer to AVPacket->data
     int               hshift[4];
     int               vshift[4];
     Slice            *slices[4];      // slice bitstream positions for each plane
     unsigned int      slices_size[4]; // slice sizes for each plane
-    uint8_t           len[4][256];    // table of code lengths for each plane
+    uint8_t           len[4][4096];   // table of code lengths for each plane
     VLC               vlc[4];         // VLC for each plane
-    HuffYUVDSPContext hdsp;
+    int (*huff_build)(VLC *vlc, uint8_t *len);
+    int (*magy_decode_slice)(AVCodecContext *avctx, void *tdata,
+                             int j, int threadnr);
+    LLVidDSPContext   llviddsp;
 } MagicYUVContext;
 
 static int huff_cmp_len(const void *a, const void *b)
@@ -72,6 +80,82 @@ static int huff_cmp_len(const void *a, const void *b)
     return (aa->len - bb->len) * 256 + aa->sym - bb->sym;
 }
 
+static int huff_cmp_len10(const void *a, const void *b)
+{
+    const HuffEntry *aa = a, *bb = b;
+    return (aa->len - bb->len) * 1024 + aa->sym - bb->sym;
+}
+
+static int huff_cmp_len12(const void *a, const void *b)
+{
+    const HuffEntry *aa = a, *bb = b;
+    return (aa->len - bb->len) * 4096 + aa->sym - bb->sym;
+}
+
+static int huff_build10(VLC *vlc, uint8_t *len)
+{
+    HuffEntry he[1024];
+    uint32_t codes[1024];
+    uint8_t bits[1024];
+    uint16_t syms[1024];
+    uint32_t code;
+    int i;
+
+    for (i = 0; i < 1024; i++) {
+        he[i].sym = 1023 - i;
+        he[i].len = len[i];
+        if (len[i] == 0 || len[i] > 32)
+            return AVERROR_INVALIDDATA;
+    }
+    AV_QSORT(he, 1024, HuffEntry, huff_cmp_len10);
+
+    code = 1;
+    for (i = 1023; i >= 0; i--) {
+        codes[i] = code >> (32 - he[i].len);
+        bits[i]  = he[i].len;
+        syms[i]  = he[i].sym;
+        code += 0x80000000u >> (he[i].len - 1);
+    }
+
+    ff_free_vlc(vlc);
+    return ff_init_vlc_sparse(vlc, FFMIN(he[1023].len, 12), 1024,
+                              bits,  sizeof(*bits),  sizeof(*bits),
+                              codes, sizeof(*codes), sizeof(*codes),
+                              syms,  sizeof(*syms),  sizeof(*syms), 0);
+}
+
+static int huff_build12(VLC *vlc, uint8_t *len)
+{
+    HuffEntry he[4096];
+    uint32_t codes[4096];
+    uint8_t bits[4096];
+    uint16_t syms[4096];
+    uint32_t code;
+    int i;
+
+    for (i = 0; i < 4096; i++) {
+        he[i].sym = 4095 - i;
+        he[i].len = len[i];
+        if (len[i] == 0 || len[i] > 32)
+            return AVERROR_INVALIDDATA;
+    }
+    AV_QSORT(he, 4096, HuffEntry, huff_cmp_len12);
+
+    code = 1;
+    for (i = 4095; i >= 0; i--) {
+        codes[i] = code >> (32 - he[i].len);
+        bits[i]  = he[i].len;
+        syms[i]  = he[i].sym;
+        code += 0x80000000u >> (he[i].len - 1);
+    }
+
+    ff_free_vlc(vlc);
+    return ff_init_vlc_sparse(vlc, FFMIN(he[4095].len, 14), 4096,
+                              bits,  sizeof(*bits),  sizeof(*bits),
+                              codes, sizeof(*codes), sizeof(*codes),
+                              syms,  sizeof(*syms),  sizeof(*syms), 0);
+}
+
 static int huff_build(VLC *vlc, uint8_t *len)
 {
     HuffEntry he[256];
@@ -84,6 +168,8 @@ static int huff_build(VLC *vlc, uint8_t *len)
     for (i = 0; i < 256; i++) {
         he[i].sym = 255 - i;
         he[i].len = len[i];
+        if (len[i] == 0 || len[i] > 32)
+            return AVERROR_INVALIDDATA;
     }
     AV_QSORT(he, 256, HuffEntry, huff_cmp_len);
 
@@ -102,6 +188,160 @@ static int huff_build(VLC *vlc, uint8_t *len)
                               syms,  sizeof(*syms),  sizeof(*syms), 0);
 }
 
+static void magicyuv_median_pred16(uint16_t *dst, const uint16_t *src1,
+                                   const uint16_t *diff, intptr_t w,
+                                   int *left, int *left_top, int max)
+{
+    int i;
+    uint16_t l, lt;
+
+    l  = *left;
+    lt = *left_top;
+
+    for (i = 0; i < w; i++) {
+        l      = mid_pred(l, src1[i], (l + src1[i] - lt)) + diff[i];
+        l     &= max;
+        lt     = src1[i];
+        dst[i] = l;
+    }
+
+    *left     = l;
+    *left_top = lt;
+}
+
+static int magy_decode_slice10(AVCodecContext *avctx, void *tdata,
+                               int j, int threadnr)
+{
+    MagicYUVContext *s = avctx->priv_data;
+    int interlaced = s->interlaced;
+    const int bps = s->bps;
+    const int max = s->max - 1;
+    AVFrame *p = s->p;
+    int i, k, x;
+    GetBitContext gb;
+    uint16_t *dst;
+
+    for (i = 0; i < s->planes; i++) {
+        int left, lefttop, top;
+        int height = AV_CEIL_RSHIFT(FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height), s->vshift[i]);
+        int width = AV_CEIL_RSHIFT(avctx->coded_width, s->hshift[i]);
+        int sheight = AV_CEIL_RSHIFT(s->slice_height, s->vshift[i]);
+        ptrdiff_t fake_stride = (p->linesize[i] / 2) * (1 + interlaced);
+        ptrdiff_t stride = p->linesize[i] / 2;
+        int flags, pred;
+        int ret = init_get_bits8(&gb, s->buf + s->slices[i][j].start,
+                                 s->slices[i][j].size);
+
+        if (ret < 0)
+            return ret;
+
+        flags = get_bits(&gb, 8);
+        pred  = get_bits(&gb, 8);
+
+        dst = (uint16_t *)p->data[i] + j * sheight * stride;
+        if (flags & 1) {
+            for (k = 0; k < height; k++) {
+                for (x = 0; x < width; x++)
+                    dst[x] = get_bits(&gb, bps);
+
+                dst += stride;
+            }
+        } else {
+            for (k = 0; k < height; k++) {
+                for (x = 0; x < width; x++) {
+                    int pix;
+                    if (get_bits_left(&gb) <= 0)
+                        return AVERROR_INVALIDDATA;
+
+                    pix = get_vlc2(&gb, s->vlc[i].table, s->vlc[i].bits, 3);
+                    if (pix < 0)
+                        return AVERROR_INVALIDDATA;
+
+                    dst[x] = max - pix;
+                }
+                dst += stride;
+            }
+        }
+
+        switch (pred) {
+        case LEFT:
+            dst = (uint16_t *)p->data[i] + j * sheight * stride;
+            s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
+            dst += stride;
+            if (interlaced) {
+                s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
+                dst += stride;
+            }
+            for (k = 1 + interlaced; k < height; k++) {
+                s->llviddsp.add_left_pred_int16(dst, dst, max, width, dst[-fake_stride]);
+                dst += stride;
+            }
+            break;
+        case GRADIENT:
+            dst = (uint16_t *)p->data[i] + j * sheight * stride;
+            s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
+            left = lefttop = 0;
+            dst += stride;
+            if (interlaced) {
+                s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
+                left = lefttop = 0;
+                dst += stride;
+            }
+            for (k = 1 + interlaced; k < height; k++) {
+                top = dst[-fake_stride];
+                left = top + dst[0];
+                dst[0] = left & max;
+                for (x = 1; x < width; x++) {
+                    top = dst[x - fake_stride];
+                    lefttop = dst[x - (fake_stride + 1)];
+                    left += top - lefttop + dst[x];
+                    dst[x] = left & max;
+                }
+                dst += stride;
+            }
+            break;
+        case MEDIAN:
+            dst = (uint16_t *)p->data[i] + j * sheight * stride;
+            lefttop = left = dst[0];
+            s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
+            dst += stride;
+            if (interlaced) {
+                lefttop = left = dst[0];
+                s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
+                dst += stride;
+            }
+            for (k = 1 + interlaced; k < height; k++) {
+                magicyuv_median_pred16(dst, dst - fake_stride, dst, width, &left, &lefttop, max);
+                lefttop = left = dst[0];
+                dst += stride;
+            }
+            break;
+        default:
+            avpriv_request_sample(avctx, "Unknown prediction: %d", pred);
+        }
+    }
+
+    if (s->decorrelate) {
+        int height = FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height);
+        int width = avctx->coded_width;
+        uint16_t *r = (uint16_t *)p->data[0] + j * s->slice_height * p->linesize[0] / 2;
+        uint16_t *g = (uint16_t *)p->data[1] + j * s->slice_height * p->linesize[1] / 2;
+        uint16_t *b = (uint16_t *)p->data[2] + j * s->slice_height * p->linesize[2] / 2;
+
+        for (i = 0; i < height; i++) {
+            for (k = 0; k < width; k++) {
+                b[k] = (b[k] + g[k]) & max;
+                r[k] = (r[k] + g[k]) & max;
+            }
+            b += p->linesize[0] / 2;
+            g += p->linesize[1] / 2;
+            r += p->linesize[2] / 2;
+        }
+    }
+
+    return 0;
+}
+
 static int magy_decode_slice(AVCodecContext *avctx, void *tdata,
                              int j, int threadnr)
 {
@@ -157,24 +397,24 @@ static int magy_decode_slice(AVCodecContext *avctx, void *tdata,
         switch (pred) {
         case LEFT:
             dst = p->data[i] + j * sheight * stride;
-            s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
+            s->llviddsp.add_left_pred(dst, dst, width, 0);
             dst += stride;
             if (interlaced) {
-                s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
+                s->llviddsp.add_left_pred(dst, dst, width, 0);
                 dst += stride;
             }
             for (k = 1 + interlaced; k < height; k++) {
-                s->hdsp.add_hfyu_left_pred(dst, dst, width, dst[-fake_stride]);
+                s->llviddsp.add_left_pred(dst, dst, width, dst[-fake_stride]);
                 dst += stride;
             }
             break;
         case GRADIENT:
             dst = p->data[i] + j * sheight * stride;
-            s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
+            s->llviddsp.add_left_pred(dst, dst, width, 0);
             left = lefttop = 0;
             dst += stride;
             if (interlaced) {
-                s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
+                s->llviddsp.add_left_pred(dst, dst, width, 0);
                 left = lefttop = 0;
                 dst += stride;
             }
@@ -194,15 +434,15 @@ static int magy_decode_slice(AVCodecContext *avctx, void *tdata,
         case MEDIAN:
             dst = p->data[i] + j * sheight * stride;
             lefttop = left = dst[0];
-            s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
+            s->llviddsp.add_left_pred(dst, dst, width, 0);
             dst += stride;
             if (interlaced) {
                 lefttop = left = dst[0];
-                s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
+                s->llviddsp.add_left_pred(dst, dst, width, 0);
                 dst += stride;
             }
             for (k = 1 + interlaced; k < height; k++) {
-                s->hdsp.add_hfyu_median_pred(dst, dst - fake_stride,
+                s->llviddsp.add_median_pred(dst, dst - fake_stride,
                                              dst, width, &left, &lefttop);
                 lefttop = left = dst[0];
                 dst += stride;
@@ -221,8 +461,8 @@ static int magy_decode_slice(AVCodecContext *avctx, void *tdata,
         uint8_t *r = p->data[2] + j * s->slice_height * p->linesize[2];
 
         for (i = 0; i < height; i++) {
-            s->hdsp.add_bytes(b, g, width);
-            s->hdsp.add_bytes(r, g, width);
+            s->llviddsp.add_bytes(b, g, width);
+            s->llviddsp.add_bytes(r, g, width);
             b += p->linesize[0];
             g += p->linesize[1];
             r += p->linesize[2];
@@ -232,6 +472,46 @@ static int magy_decode_slice(AVCodecContext *avctx, void *tdata,
     return 0;
 }
 
+static int build_huffman(AVCodecContext *avctx, GetBitContext *gbit, int max)
+{
+    MagicYUVContext *s = avctx->priv_data;
+    int i = 0, j = 0, k;
+
+    memset(s->len, 0, sizeof(s->len));
+    while (get_bits_left(gbit) >= 8) {
+        int b = get_bits(gbit, 1);
+        int x = get_bits(gbit, 7);
+        int l = get_bitsz(gbit, b * 8) + 1;
+
+        for (k = 0; k < l; k++)
+            if (j + k < max)
+                s->len[i][j + k] = x;
+
+        j += l;
+        if (j == max) {
+            j = 0;
+            if (s->huff_build(&s->vlc[i], s->len[i])) {
+                av_log(avctx, AV_LOG_ERROR, "Cannot build Huffman codes\n");
+                return AVERROR_INVALIDDATA;
+            }
+            i++;
+            if (i == s->planes) {
+                break;
+            }
+        } else if (j > max) {
+            av_log(avctx, AV_LOG_ERROR, "Invalid Huffman codes\n");
+            return AVERROR_INVALIDDATA;
+        }
+    }
+
+    if (i != s->planes) {
+        av_log(avctx, AV_LOG_ERROR, "Huffman tables too short\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    return 0;
+}
+
 static int magy_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame, AVPacket *avpkt)
 {
@@ -242,7 +522,7 @@ static int magy_decode_frame(AVCodecContext *avctx, void *data,
     GetBitContext gbit;
     uint32_t first_offset, offset, next_offset, header_size, slice_width;
     int width, height, format, version, table_size;
-    int ret, i, j, k;
+    int ret, i, j;
 
     bytestream2_init(&gbyte, avpkt->data, avpkt->size);
     if (bytestream2_get_le32(&gbyte) != MKTAG('M', 'A', 'G', 'Y'))
@@ -266,6 +546,10 @@ static int magy_decode_frame(AVCodecContext *avctx, void *data,
     s->hshift[2] =
     s->vshift[2] = 0;
     s->decorrelate = 0;
+    s->max = 256;
+    s->bps = 8;
+    s->huff_build = huff_build;
+    s->magy_decode_slice = magy_decode_slice;
 
     format = bytestream2_get_byte(&gbyte);
     switch (format) {
@@ -298,14 +582,64 @@ static int magy_decode_frame(AVCodecContext *avctx, void *data,
     case 0x6b:
         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
         break;
+    case 0x6c:
+        avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
+        s->hshift[1] =
+        s->hshift[2] = 1;
+        s->max = 1024;
+        s->huff_build = huff_build10;
+        s->magy_decode_slice = magy_decode_slice10;
+        s->bps = 10;
+        break;
+    case 0x6d:
+        avctx->pix_fmt = AV_PIX_FMT_GBRP10;
+        s->decorrelate = 1;
+        s->max = 1024;
+        s->huff_build = huff_build10;
+        s->magy_decode_slice = magy_decode_slice10;
+        s->bps = 10;
+        break;
+    case 0x6e:
+        avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
+        s->decorrelate = 1;
+        s->max = 1024;
+        s->huff_build = huff_build10;
+        s->magy_decode_slice = magy_decode_slice10;
+        s->bps = 10;
+        break;
+    case 0x6f:
+        avctx->pix_fmt = AV_PIX_FMT_GBRP12;
+        s->decorrelate = 1;
+        s->max = 4096;
+        s->huff_build = huff_build12;
+        s->magy_decode_slice = magy_decode_slice10;
+        s->bps = 12;
+        break;
+    case 0x70:
+        avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
+        s->decorrelate = 1;
+        s->max = 4096;
+        s->huff_build = huff_build12;
+        s->magy_decode_slice = magy_decode_slice10;
+        s->bps = 12;
+        break;
+    case 0x73:
+        avctx->pix_fmt = AV_PIX_FMT_GRAY10;
+        s->max = 1024;
+        s->huff_build = huff_build10;
+        s->magy_decode_slice = magy_decode_slice10;
+        s->bps = 10;
+        break;
     default:
         avpriv_request_sample(avctx, "Format 0x%X", format);
         return AVERROR_PATCHWELCOME;
     }
     s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
 
-    bytestream2_skip(&gbyte, 2);
-    s->interlaced = !!(bytestream2_get_byte(&gbyte) & 2);
+    bytestream2_skip(&gbyte, 1);
+    s->color_matrix = bytestream2_get_byte(&gbyte);
+    s->flags        = bytestream2_get_byte(&gbyte);
+    s->interlaced   = !!(s->flags & 2);
     bytestream2_skip(&gbyte, 3);
 
     width  = bytestream2_get_le32(&gbyte);
@@ -375,37 +709,9 @@ static int magy_decode_frame(AVCodecContext *avctx, void *data,
     if (ret < 0)
         return ret;
 
-    memset(s->len, 0, sizeof(s->len));
-    j = i = 0;
-    while (get_bits_left(&gbit) >= 8) {
-        int b = get_bits(&gbit, 4);
-        int x = get_bits(&gbit, 4);
-        int l = get_bitsz(&gbit, b) + 1;
-
-        for (k = 0; k < l; k++)
-            if (j + k < 256)
-                s->len[i][j + k] = x;
-
-        j += l;
-        if (j == 256) {
-            j = 0;
-            if (huff_build(&s->vlc[i], s->len[i])) {
-                av_log(avctx, AV_LOG_ERROR, "Cannot build Huffman codes\n");
-                return AVERROR_INVALIDDATA;
-            }
-            i++;
-            if (i == s->planes) {
-                break;
-            }
-        } else if (j > 256) {
-            return AVERROR_INVALIDDATA;
-        }
-    }
-
-    if (i != s->planes) {
-        av_log(avctx, AV_LOG_ERROR, "Huffman tables too short\n");
-        return AVERROR_INVALIDDATA;
-    }
+    ret = build_huffman(avctx, &gbit, s->max);
+    if (ret < 0)
+        return ret;
 
     p->pict_type = AV_PICTURE_TYPE_I;
     p->key_frame = 1;
@@ -415,12 +721,26 @@ static int magy_decode_frame(AVCodecContext *avctx, void *data,
 
     s->buf = avpkt->data;
     s->p = p;
-    avctx->execute2(avctx, magy_decode_slice, NULL, NULL, s->nb_slices);
-
-    if (avctx->pix_fmt == AV_PIX_FMT_GBRP ||
-        avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
+    avctx->execute2(avctx, s->magy_decode_slice, NULL, NULL, s->nb_slices);
+
+    if (avctx->pix_fmt == AV_PIX_FMT_GBRP   ||
+        avctx->pix_fmt == AV_PIX_FMT_GBRAP  ||
+        avctx->pix_fmt == AV_PIX_FMT_GBRP10 ||
+        avctx->pix_fmt == AV_PIX_FMT_GBRAP10||
+        avctx->pix_fmt == AV_PIX_FMT_GBRAP12||
+        avctx->pix_fmt == AV_PIX_FMT_GBRP12) {
         FFSWAP(uint8_t*, p->data[0], p->data[1]);
         FFSWAP(int, p->linesize[0], p->linesize[1]);
+    } else {
+        switch (s->color_matrix) {
+        case 1:
+            p->colorspace = AVCOL_SPC_BT470BG;
+            break;
+        case 2:
+            p->colorspace = AVCOL_SPC_BT709;
+            break;
+        }
+        p->color_range = (s->flags & 4) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
     }
 
     *got_frame = 1;
@@ -446,7 +766,7 @@ static int magy_init_thread_copy(AVCodecContext *avctx)
 static av_cold int magy_decode_init(AVCodecContext *avctx)
 {
     MagicYUVContext *s = avctx->priv_data;
-    ff_huffyuvdsp_init(&s->hdsp);
+    ff_llviddsp_init(&s->llviddsp);
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mathops.h b/mythtv/external/FFmpeg/libavcodec/mathops.h
index 5168dc2ce00..1c35664318f 100644
--- a/mythtv/external/FFmpeg/libavcodec/mathops.h
+++ b/mythtv/external/FFmpeg/libavcodec/mathops.h
@@ -25,6 +25,7 @@
 #include <stdint.h>
 
 #include "libavutil/common.h"
+#include "libavutil/reverse.h"
 #include "config.h"
 
 #define MAX_NEG_CROP 1024
@@ -96,15 +97,6 @@ static av_always_inline unsigned UMULH(unsigned a, unsigned b){
 #define mid_pred mid_pred
 static inline av_const int mid_pred(int a, int b, int c)
 {
-#if 0
-    int t= (a-b)&((a-b)>>31);
-    a-=t;
-    b+=t;
-    b-= (b-c)&((b-c)>>31);
-    b+= (a-b)&((a-b)>>31);
-
-    return b;
-#else
     if(a>b){
         if(c>b){
             if(c>a) b=a;
@@ -117,7 +109,6 @@ static inline av_const int mid_pred(int a, int b, int c)
         }
     }
     return b;
-#endif
 }
 #endif
 
@@ -249,4 +240,12 @@ static inline int8_t ff_u8_to_s8(uint8_t a)
     return b.s8;
 }
 
+static av_always_inline uint32_t bitswap_32(uint32_t x)
+{
+    return (uint32_t)ff_reverse[ x        & 0xFF] << 24 |
+           (uint32_t)ff_reverse[(x >> 8)  & 0xFF] << 16 |
+           (uint32_t)ff_reverse[(x >> 16) & 0xFF] << 8  |
+           (uint32_t)ff_reverse[ x >> 24];
+}
+
 #endif /* AVCODEC_MATHOPS_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/mdct15.c b/mythtv/external/FFmpeg/libavcodec/mdct15.c
new file mode 100644
index 00000000000..6f35059bfe8
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mdct15.c
@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) 2013-2014 Mozilla Corporation
+ * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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
+ * Celt non-power of 2 iMDCT
+ */
+
+#include <float.h>
+#include <math.h>
+#include <stddef.h>
+
+#include "config.h"
+
+#include "libavutil/attributes.h"
+#include "libavutil/common.h"
+
+#include "mdct15.h"
+
+#define FFT_FLOAT 1
+#include "fft-internal.h"
+
+#define CMUL3(c, a, b) CMUL((c).re, (c).im, (a).re, (a).im, (b).re, (b).im)
+
+av_cold void ff_mdct15_uninit(MDCT15Context **ps)
+{
+    MDCT15Context *s = *ps;
+
+    if (!s)
+        return;
+
+    ff_fft_end(&s->ptwo_fft);
+
+    av_freep(&s->pfa_prereindex);
+    av_freep(&s->pfa_postreindex);
+    av_freep(&s->twiddle_exptab);
+    av_freep(&s->tmp);
+
+    av_freep(ps);
+}
+
+static inline int init_pfa_reindex_tabs(MDCT15Context *s)
+{
+    int i, j;
+    const int b_ptwo = s->ptwo_fft.nbits; /* Bits for the power of two FFTs */
+    const int l_ptwo = 1 << b_ptwo; /* Total length for the power of two FFTs */
+    const int inv_1 = l_ptwo << ((4 - b_ptwo) & 3); /* (2^b_ptwo)^-1 mod 15 */
+    const int inv_2 = 0xeeeeeeef & ((1U << b_ptwo) - 1); /* 15^-1 mod 2^b_ptwo */
+
+    s->pfa_prereindex = av_malloc_array(15 * l_ptwo, sizeof(*s->pfa_prereindex));
+    if (!s->pfa_prereindex)
+        return 1;
+
+    s->pfa_postreindex = av_malloc_array(15 * l_ptwo, sizeof(*s->pfa_postreindex));
+    if (!s->pfa_postreindex)
+        return 1;
+
+    /* Pre/Post-reindex */
+    for (i = 0; i < l_ptwo; i++) {
+        for (j = 0; j < 15; j++) {
+            const int q_pre = ((l_ptwo * j)/15 + i) >> b_ptwo;
+            const int q_post = (((j*inv_1)/15) + (i*inv_2)) >> b_ptwo;
+            const int k_pre = 15*i + (j - q_pre*15)*(1 << b_ptwo);
+            const int k_post = i*inv_2*15 + j*inv_1 - 15*q_post*l_ptwo;
+            s->pfa_prereindex[i*15 + j] = k_pre << 1;
+            s->pfa_postreindex[k_post] = l_ptwo*j + i;
+        }
+    }
+
+    return 0;
+}
+
+/* Stride is hardcoded to 3 */
+static inline void fft5(FFTComplex *out, FFTComplex *in, FFTComplex exptab[2])
+{
+    FFTComplex z0[4], t[6];
+
+    t[0].re = in[3].re + in[12].re;
+    t[0].im = in[3].im + in[12].im;
+    t[1].im = in[3].re - in[12].re;
+    t[1].re = in[3].im - in[12].im;
+    t[2].re = in[6].re + in[ 9].re;
+    t[2].im = in[6].im + in[ 9].im;
+    t[3].im = in[6].re - in[ 9].re;
+    t[3].re = in[6].im - in[ 9].im;
+
+    out[0].re = in[0].re + in[3].re + in[6].re + in[9].re + in[12].re;
+    out[0].im = in[0].im + in[3].im + in[6].im + in[9].im + in[12].im;
+
+    t[4].re = exptab[0].re * t[2].re - exptab[1].re * t[0].re;
+    t[4].im = exptab[0].re * t[2].im - exptab[1].re * t[0].im;
+    t[0].re = exptab[0].re * t[0].re - exptab[1].re * t[2].re;
+    t[0].im = exptab[0].re * t[0].im - exptab[1].re * t[2].im;
+    t[5].re = exptab[0].im * t[3].re - exptab[1].im * t[1].re;
+    t[5].im = exptab[0].im * t[3].im - exptab[1].im * t[1].im;
+    t[1].re = exptab[0].im * t[1].re + exptab[1].im * t[3].re;
+    t[1].im = exptab[0].im * t[1].im + exptab[1].im * t[3].im;
+
+    z0[0].re = t[0].re - t[1].re;
+    z0[0].im = t[0].im - t[1].im;
+    z0[1].re = t[4].re + t[5].re;
+    z0[1].im = t[4].im + t[5].im;
+
+    z0[2].re = t[4].re - t[5].re;
+    z0[2].im = t[4].im - t[5].im;
+    z0[3].re = t[0].re + t[1].re;
+    z0[3].im = t[0].im + t[1].im;
+
+    out[1].re = in[0].re + z0[3].re;
+    out[1].im = in[0].im + z0[0].im;
+    out[2].re = in[0].re + z0[2].re;
+    out[2].im = in[0].im + z0[1].im;
+    out[3].re = in[0].re + z0[1].re;
+    out[3].im = in[0].im + z0[2].im;
+    out[4].re = in[0].re + z0[0].re;
+    out[4].im = in[0].im + z0[3].im;
+}
+
+static void fft15_c(FFTComplex *out, FFTComplex *in, FFTComplex *exptab, ptrdiff_t stride)
+{
+    int k;
+    FFTComplex tmp1[5], tmp2[5], tmp3[5];
+
+    fft5(tmp1, in + 0, exptab + 19);
+    fft5(tmp2, in + 1, exptab + 19);
+    fft5(tmp3, in + 2, exptab + 19);
+
+    for (k = 0; k < 5; k++) {
+        FFTComplex t[2];
+
+        CMUL3(t[0], tmp2[k], exptab[k]);
+        CMUL3(t[1], tmp3[k], exptab[2 * k]);
+        out[stride*k].re = tmp1[k].re + t[0].re + t[1].re;
+        out[stride*k].im = tmp1[k].im + t[0].im + t[1].im;
+
+        CMUL3(t[0], tmp2[k], exptab[k + 5]);
+        CMUL3(t[1], tmp3[k], exptab[2 * (k + 5)]);
+        out[stride*(k + 5)].re = tmp1[k].re + t[0].re + t[1].re;
+        out[stride*(k + 5)].im = tmp1[k].im + t[0].im + t[1].im;
+
+        CMUL3(t[0], tmp2[k], exptab[k + 10]);
+        CMUL3(t[1], tmp3[k], exptab[2 * k + 5]);
+        out[stride*(k + 10)].re = tmp1[k].re + t[0].re + t[1].re;
+        out[stride*(k + 10)].im = tmp1[k].im + t[0].im + t[1].im;
+    }
+}
+
+static void mdct15(MDCT15Context *s, float *dst, const float *src, ptrdiff_t stride)
+{
+    int i, j;
+    const int len4 = s->len4, len3 = len4 * 3, len8 = len4 >> 1;
+    const int l_ptwo = 1 << s->ptwo_fft.nbits;
+    FFTComplex fft15in[15];
+
+    /* Folding and pre-reindexing */
+    for (i = 0; i < l_ptwo; i++) {
+        for (j = 0; j < 15; j++) {
+            const int k = s->pfa_prereindex[i*15 + j];
+            FFTComplex tmp, exp = s->twiddle_exptab[k >> 1];
+            if (k < len4) {
+                tmp.re = -src[ len4 + k] + src[1*len4 - 1 - k];
+                tmp.im = -src[ len3 + k] - src[1*len3 - 1 - k];
+            } else {
+                tmp.re = -src[ len4 + k] - src[5*len4 - 1 - k];
+                tmp.im =  src[-len4 + k] - src[1*len3 - 1 - k];
+            }
+            CMUL(fft15in[j].im, fft15in[j].re, tmp.re, tmp.im, exp.re, exp.im);
+        }
+        s->fft15(s->tmp + s->ptwo_fft.revtab[i], fft15in, s->exptab, l_ptwo);
+    }
+
+    /* Then a 15xN FFT (where N is a power of two) */
+    for (i = 0; i < 15; i++)
+        s->ptwo_fft.fft_calc(&s->ptwo_fft, s->tmp + l_ptwo*i);
+
+    /* Reindex again, apply twiddles and output */
+    for (i = 0; i < len8; i++) {
+        const int i0 = len8 + i, i1 = len8 - i - 1;
+        const int s0 = s->pfa_postreindex[i0], s1 = s->pfa_postreindex[i1];
+
+        CMUL(dst[2*i1*stride + stride], dst[2*i0*stride], s->tmp[s0].re, s->tmp[s0].im,
+             s->twiddle_exptab[i0].im, s->twiddle_exptab[i0].re);
+        CMUL(dst[2*i0*stride + stride], dst[2*i1*stride], s->tmp[s1].re, s->tmp[s1].im,
+             s->twiddle_exptab[i1].im, s->twiddle_exptab[i1].re);
+    }
+}
+
+static void imdct15_half(MDCT15Context *s, float *dst, const float *src,
+                         ptrdiff_t stride)
+{
+    FFTComplex fft15in[15];
+    FFTComplex *z = (FFTComplex *)dst;
+    int i, j, len8 = s->len4 >> 1, l_ptwo = 1 << s->ptwo_fft.nbits;
+    const float *in1 = src, *in2 = src + (s->len2 - 1) * stride;
+
+    /* Reindex input, putting it into a buffer and doing an Nx15 FFT */
+    for (i = 0; i < l_ptwo; i++) {
+        for (j = 0; j < 15; j++) {
+            const int k = s->pfa_prereindex[i*15 + j];
+            FFTComplex tmp = { in2[-k*stride], in1[k*stride] };
+            CMUL3(fft15in[j], tmp, s->twiddle_exptab[k >> 1]);
+        }
+        s->fft15(s->tmp + s->ptwo_fft.revtab[i], fft15in, s->exptab, l_ptwo);
+    }
+
+    /* Then a 15xN FFT (where N is a power of two) */
+    for (i = 0; i < 15; i++)
+        s->ptwo_fft.fft_calc(&s->ptwo_fft, s->tmp + l_ptwo*i);
+
+    /* Reindex again, apply twiddles and output */
+    s->postreindex(z, s->tmp, s->twiddle_exptab, s->pfa_postreindex, len8);
+}
+
+static void postrotate_c(FFTComplex *out, FFTComplex *in, FFTComplex *exp,
+                         int *lut, ptrdiff_t len8)
+{
+    int i;
+
+    /* Reindex again, apply twiddles and output */
+    for (i = 0; i < len8; i++) {
+        const int i0 = len8 + i, i1 = len8 - i - 1;
+        const int s0 = lut[i0], s1 = lut[i1];
+
+        CMUL(out[i1].re, out[i0].im, in[s1].im, in[s1].re, exp[i1].im, exp[i1].re);
+        CMUL(out[i0].re, out[i1].im, in[s0].im, in[s0].re, exp[i0].im, exp[i0].re);
+    }
+}
+
+av_cold int ff_mdct15_init(MDCT15Context **ps, int inverse, int N, double scale)
+{
+    MDCT15Context *s;
+    double alpha, theta;
+    int len2 = 15 * (1 << N);
+    int len  = 2 * len2;
+    int i;
+
+    /* Tested and verified to work on everything in between */
+    if ((N < 2) || (N > 13))
+        return AVERROR(EINVAL);
+
+    s = av_mallocz(sizeof(*s));
+    if (!s)
+        return AVERROR(ENOMEM);
+
+    s->fft_n       = N - 1;
+    s->len4        = len2 / 2;
+    s->len2        = len2;
+    s->inverse     = inverse;
+    s->fft15       = fft15_c;
+    s->mdct        = mdct15;
+    s->imdct_half  = imdct15_half;
+    s->postreindex = postrotate_c;
+
+    if (ff_fft_init(&s->ptwo_fft, N - 1, s->inverse) < 0)
+        goto fail;
+
+    if (init_pfa_reindex_tabs(s))
+        goto fail;
+
+    s->tmp  = av_malloc_array(len, 2 * sizeof(*s->tmp));
+    if (!s->tmp)
+        goto fail;
+
+    s->twiddle_exptab = av_malloc_array(s->len4, sizeof(*s->twiddle_exptab));
+    if (!s->twiddle_exptab)
+        goto fail;
+
+    theta = 0.125f + (scale < 0 ? s->len4 : 0);
+    scale = sqrt(fabs(scale));
+    for (i = 0; i < s->len4; i++) {
+        alpha = 2 * M_PI * (i + theta) / len;
+        s->twiddle_exptab[i].re = cosf(alpha) * scale;
+        s->twiddle_exptab[i].im = sinf(alpha) * scale;
+    }
+
+    /* 15-point FFT exptab */
+    for (i = 0; i < 19; i++) {
+        if (i < 15) {
+            double theta = (2.0f * M_PI * i) / 15.0f;
+            if (!s->inverse)
+                theta *= -1;
+            s->exptab[i].re = cosf(theta);
+            s->exptab[i].im = sinf(theta);
+        } else { /* Wrap around to simplify fft15 */
+            s->exptab[i] = s->exptab[i - 15];
+        }
+    }
+
+    /* 5-point FFT exptab */
+    s->exptab[19].re = cosf(2.0f * M_PI / 5.0f);
+    s->exptab[19].im = sinf(2.0f * M_PI / 5.0f);
+    s->exptab[20].re = cosf(1.0f * M_PI / 5.0f);
+    s->exptab[20].im = sinf(1.0f * M_PI / 5.0f);
+
+    /* Invert the phase for an inverse transform, do nothing for a forward transform */
+    if (s->inverse) {
+        s->exptab[19].im *= -1;
+        s->exptab[20].im *= -1;
+    }
+
+    if (ARCH_X86)
+        ff_mdct15_init_x86(s);
+
+    *ps = s;
+
+    return 0;
+
+fail:
+    ff_mdct15_uninit(&s);
+    return AVERROR(ENOMEM);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/mdct15.h b/mythtv/external/FFmpeg/libavcodec/mdct15.h
new file mode 100644
index 00000000000..42e60f3e102
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mdct15.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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_MDCT15_H
+#define AVCODEC_MDCT15_H
+
+#include <stddef.h>
+
+#include "fft.h"
+
+typedef struct MDCT15Context {
+    int fft_n;
+    int len2;
+    int len4;
+    int inverse;
+    int *pfa_prereindex;
+    int *pfa_postreindex;
+
+    FFTContext ptwo_fft;
+    FFTComplex *tmp;
+    FFTComplex *twiddle_exptab;
+
+    DECLARE_ALIGNED(32, FFTComplex, exptab)[64];
+
+    /* 15-point FFT */
+    void (*fft15)(FFTComplex *out, FFTComplex *in, FFTComplex *exptab, ptrdiff_t stride);
+
+    /* PFA postrotate and exptab */
+    void (*postreindex)(FFTComplex *out, FFTComplex *in, FFTComplex *exp, int *lut, ptrdiff_t len8);
+
+    /* Calculate a full 2N -> N MDCT */
+    void (*mdct)(struct MDCT15Context *s, float *dst, const float *src, ptrdiff_t stride);
+
+    /* Calculate the middle half of the iMDCT */
+    void (*imdct_half)(struct MDCT15Context *s, float *dst, const float *src,
+                       ptrdiff_t stride);
+} MDCT15Context;
+
+/* Init an (i)MDCT of the length 2 * 15 * (2^N) */
+int ff_mdct15_init(MDCT15Context **ps, int inverse, int N, double scale);
+void ff_mdct15_uninit(MDCT15Context **ps);
+
+void ff_mdct15_init_x86(MDCT15Context *s);
+
+#endif /* AVCODEC_MDCT15_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/mdct_fixed.c b/mythtv/external/FFmpeg/libavcodec/mdct_fixed.c
index a32cb00ca03..aabf0c88f8d 100644
--- a/mythtv/external/FFmpeg/libavcodec/mdct_fixed.c
+++ b/mythtv/external/FFmpeg/libavcodec/mdct_fixed.c
@@ -39,13 +39,13 @@ void ff_mdct_calcw_c(FFTContext *s, FFTDouble *out, const FFTSample *input)
 
     /* pre rotation */
     for(i=0;i<n8;i++) {
-        re = RSCALE(-input[2*i+n3] - input[n3-1-2*i]);
-        im = RSCALE(-input[n4+2*i] + input[n4-1-2*i]);
+        re = RSCALE(-input[2*i+n3], - input[n3-1-2*i]);
+        im = RSCALE(-input[n4+2*i], + input[n4-1-2*i]);
         j = revtab[i];
         CMUL(x[j].re, x[j].im, re, im, -tcos[i], tsin[i]);
 
-        re = RSCALE( input[2*i]    - input[n2-1-2*i]);
-        im = RSCALE(-input[n2+2*i] - input[ n-1-2*i]);
+        re = RSCALE( input[2*i]   , - input[n2-1-2*i]);
+        im = RSCALE(-input[n2+2*i], - input[ n-1-2*i]);
         j = revtab[n8 + i];
         CMUL(x[j].re, x[j].im, re, im, -tcos[n8 + i], tsin[n8 + i]);
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/mdct_template.c b/mythtv/external/FFmpeg/libavcodec/mdct_template.c
index 04396b46d6c..e0ad9f1e531 100644
--- a/mythtv/external/FFmpeg/libavcodec/mdct_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/mdct_template.c
@@ -33,12 +33,12 @@
  */
 
 #if FFT_FLOAT
-#   define RSCALE(x) (x)
+#   define RSCALE(x, y) ((x) + (y))
 #else
 #if FFT_FIXED_32
-#   define RSCALE(x) (((x) + 32) >> 6)
+#   define RSCALE(x, y) ((int)((x) + (unsigned)(y) + 32) >> 6)
 #else /* FFT_FIXED_32 */
-#   define RSCALE(x) ((x) >> 1)
+#   define RSCALE(x, y) ((int)((x) + (unsigned)(y)) >> 1)
 #endif /* FFT_FIXED_32 */
 #endif
 
@@ -181,13 +181,13 @@ void ff_mdct_calc_c(FFTContext *s, FFTSample *out, const FFTSample *input)
 
     /* pre rotation */
     for(i=0;i<n8;i++) {
-        re = RSCALE(-input[2*i+n3] - input[n3-1-2*i]);
-        im = RSCALE(-input[n4+2*i] + input[n4-1-2*i]);
+        re = RSCALE(-input[2*i+n3], - input[n3-1-2*i]);
+        im = RSCALE(-input[n4+2*i], + input[n4-1-2*i]);
         j = revtab[i];
         CMUL(x[j].re, x[j].im, re, im, -tcos[i], tsin[i]);
 
-        re = RSCALE( input[2*i]    - input[n2-1-2*i]);
-        im = RSCALE(-input[n2+2*i] - input[ n-1-2*i]);
+        re = RSCALE( input[2*i]   , - input[n2-1-2*i]);
+        im = RSCALE(-input[n2+2*i], - input[ n-1-2*i]);
         j = revtab[n8 + i];
         CMUL(x[j].re, x[j].im, re, im, -tcos[n8 + i], tsin[n8 + i]);
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/mdec.c b/mythtv/external/FFmpeg/libavcodec/mdec.c
index 1cc4ca4742f..330b7612790 100644
--- a/mythtv/external/FFmpeg/libavcodec/mdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/mdec.c
@@ -48,7 +48,8 @@ typedef struct MDECContext {
     int mb_width;
     int mb_height;
     int mb_x, mb_y;
-    DECLARE_ALIGNED(16, int16_t, block)[6][64];
+    DECLARE_ALIGNED(32, int16_t, block)[6][64];
+    DECLARE_ALIGNED(16, uint16_t, quant_matrix)[64];
     uint8_t *bitstream_buffer;
     unsigned int bitstream_buffer_size;
     int block_last_index[6];
@@ -61,7 +62,7 @@ static inline int mdec_decode_block_intra(MDECContext *a, int16_t *block, int n)
     int component;
     RLTable *rl = &ff_rl_mpeg1;
     uint8_t * const scantable = a->scantable.permutated;
-    const uint16_t *quant_matrix = ff_mpeg1_default_intra_matrix;
+    const uint16_t *quant_matrix = a->quant_matrix;
     const int qscale = a->qscale;
 
     /* DC coefficient */
@@ -73,7 +74,7 @@ static inline int mdec_decode_block_intra(MDECContext *a, int16_t *block, int n)
         if (diff >= 0xffff)
             return AVERROR_INVALIDDATA;
         a->last_dc[component] += diff;
-        block[0] = a->last_dc[component] << 3;
+        block[0] = a->last_dc[component] * (1 << 3);
     }
 
     i = 0;
@@ -111,11 +112,11 @@ static inline int mdec_decode_block_intra(MDECContext *a, int16_t *block, int n)
                 j = scantable[i];
                 if (level < 0) {
                     level = -level;
-                    level = (level * qscale * quant_matrix[j]) >> 3;
+                    level = (level * (unsigned)qscale * quant_matrix[j]) >> 3;
                     level = (level - 1) | 1;
                     level = -level;
                 } else {
-                    level = (level * qscale * quant_matrix[j]) >> 3;
+                    level = (level * (unsigned)qscale * quant_matrix[j]) >> 3;
                     level = (level - 1) | 1;
                 }
             }
@@ -212,6 +213,7 @@ static int decode_frame(AVCodecContext *avctx,
 static av_cold int decode_init(AVCodecContext *avctx)
 {
     MDECContext * const a = avctx->priv_data;
+    int i;
 
     a->mb_width  = (avctx->coded_width  + 15) / 16;
     a->mb_height = (avctx->coded_height + 15) / 16;
@@ -225,11 +227,16 @@ static av_cold int decode_init(AVCodecContext *avctx)
     ff_init_scantable(a->idsp.idct_permutation, &a->scantable,
                       ff_zigzag_direct);
 
-    if (avctx->idct_algo == FF_IDCT_AUTO)
-        avctx->idct_algo = FF_IDCT_SIMPLE;
     avctx->pix_fmt  = AV_PIX_FMT_YUVJ420P;
     avctx->color_range = AVCOL_RANGE_JPEG;
 
+    /* init q matrix */
+    for (i = 0; i < 64; i++) {
+        int j = a->idsp.idct_permutation[i];
+
+        a->quant_matrix[j] = ff_mpeg1_default_intra_matrix[i];
+    }
+
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/me_cmp.c b/mythtv/external/FFmpeg/libavcodec/me_cmp.c
index 6639b919ff4..5e34a11593d 100644
--- a/mythtv/external/FFmpeg/libavcodec/me_cmp.c
+++ b/mythtv/external/FFmpeg/libavcodec/me_cmp.c
@@ -628,7 +628,7 @@ static int dct_sad8x8_c(MpegEncContext *s, uint8_t *src1,
 
     av_assert2(h == 8);
 
-    s->pdsp.diff_pixels(temp, src1, src2, stride);
+    s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride);
     s->fdsp.fdct(temp);
     return s->mecc.sum_abs_dctelem(temp);
 }
@@ -668,7 +668,7 @@ static int dct264_sad8x8_c(MpegEncContext *s, uint8_t *src1,
     int16_t dct[8][8];
     int i, sum = 0;
 
-    s->pdsp.diff_pixels(dct[0], src1, src2, stride);
+    s->pdsp.diff_pixels_unaligned(dct[0], src1, src2, stride);
 
 #define SRC(x) dct[i][x]
 #define DST(x, v) dct[i][x] = v
@@ -695,7 +695,7 @@ static int dct_max8x8_c(MpegEncContext *s, uint8_t *src1,
 
     av_assert2(h == 8);
 
-    s->pdsp.diff_pixels(temp, src1, src2, stride);
+    s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride);
     s->fdsp.fdct(temp);
 
     for (i = 0; i < 64; i++)
@@ -714,7 +714,7 @@ static int quant_psnr8x8_c(MpegEncContext *s, uint8_t *src1,
     av_assert2(h == 8);
     s->mb_intra = 0;
 
-    s->pdsp.diff_pixels(temp, src1, src2, stride);
+    s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride);
 
     memcpy(bak, temp, 64 * sizeof(int16_t));
 
@@ -817,7 +817,7 @@ static int bit8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2,
 
     av_assert2(h == 8);
 
-    s->pdsp.diff_pixels(temp, src1, src2, stride);
+    s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride);
 
     s->block_last_index[0 /* FIXME */] =
     last                               =
diff --git a/mythtv/external/FFmpeg/libavcodec/me_cmp.h b/mythtv/external/FFmpeg/libavcodec/me_cmp.h
index 5666f59adeb..0dbbcbb1d9a 100644
--- a/mythtv/external/FFmpeg/libavcodec/me_cmp.h
+++ b/mythtv/external/FFmpeg/libavcodec/me_cmp.h
@@ -76,7 +76,7 @@ typedef struct MECmpContext {
     me_cmp_func frame_skip_cmp[6]; // only width 8 used
 
     me_cmp_func pix_abs[2][4];
-    me_cmp_func median_sad[2];
+    me_cmp_func median_sad[6];
 } MECmpContext;
 
 void ff_me_cmp_init_static(void);
diff --git a/mythtv/external/FFmpeg/libavcodec/mediacodec.c b/mythtv/external/FFmpeg/libavcodec/mediacodec.c
index 4ad5921bc20..610bb49a733 100644
--- a/mythtv/external/FFmpeg/libavcodec/mediacodec.c
+++ b/mythtv/external/FFmpeg/libavcodec/mediacodec.c
@@ -31,7 +31,6 @@
 #include <jni.h>
 
 #include "libavcodec/avcodec.h"
-#include "libavutil/atomic.h"
 #include "libavutil/mem.h"
 
 #include "ffjni.h"
@@ -90,9 +89,9 @@ void av_mediacodec_default_free(AVCodecContext *avctx)
 int av_mediacodec_release_buffer(AVMediaCodecBuffer *buffer, int render)
 {
     MediaCodecDecContext *ctx = buffer->ctx;
-    int released = avpriv_atomic_int_add_and_fetch(&buffer->released, 1);
+    int released = atomic_fetch_add(&buffer->released, 1);
 
-    if (released == 1) {
+    if (!released) {
         return ff_AMediaCodec_releaseOutputBuffer(ctx->codec, buffer->index, render);
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mediacodec_wrapper.c b/mythtv/external/FFmpeg/libavcodec/mediacodec_wrapper.c
index c2af950f390..f34450a6d8f 100644
--- a/mythtv/external/FFmpeg/libavcodec/mediacodec_wrapper.c
+++ b/mythtv/external/FFmpeg/libavcodec/mediacodec_wrapper.c
@@ -66,7 +66,7 @@ struct JNIAMediaCodecListFields {
     jfieldID hevc_profile_main10_id;
     jfieldID hevc_profile_main10_hdr10_id;
 
-} JNIAMediaCodecListFields;
+};
 
 static const struct FFJniField jni_amediacodeclist_mapping[] = {
     { "android/media/MediaCodecList", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecListFields, mediacodec_list_class), 1 },
@@ -125,7 +125,7 @@ struct JNIAMediaFormatFields {
 
     jmethodID to_string_id;
 
-} JNIAMediaFormatFields;
+};
 
 static const struct FFJniField jni_amediaformat_mapping[] = {
     { "android/media/MediaFormat", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaFormatFields, mediaformat_class), 1 },
@@ -210,7 +210,7 @@ struct JNIAMediaCodecFields {
     jfieldID presentation_time_us_id;
     jfieldID size_id;
 
-} JNIAMediaCodecFields;
+};
 
 static const struct FFJniField jni_amediacodec_mapping[] = {
     { "android/media/MediaCodec", NULL, NULL, FF_JNI_CLASS, offsetof(struct JNIAMediaCodecFields, mediacodec_class), 1 },
@@ -608,6 +608,7 @@ FFAMediaFormat *ff_AMediaFormat_new(void)
 {
     JNIEnv *env = NULL;
     FFAMediaFormat *format = NULL;
+    jobject object = NULL;
 
     format = av_mallocz(sizeof(FFAMediaFormat));
     if (!format) {
@@ -625,23 +626,27 @@ FFAMediaFormat *ff_AMediaFormat_new(void)
         goto fail;
     }
 
-    format->object = (*env)->NewObject(env, format->jfields.mediaformat_class, format->jfields.init_id);
-    if (!format->object) {
+    object = (*env)->NewObject(env, format->jfields.mediaformat_class, format->jfields.init_id);
+    if (!object) {
         goto fail;
     }
 
-    format->object = (*env)->NewGlobalRef(env, format->object);
+    format->object = (*env)->NewGlobalRef(env, object);
     if (!format->object) {
         goto fail;
     }
 
-    return format;
 fail:
-    ff_jni_reset_jfields(env, &format->jfields, jni_amediaformat_mapping, 1, format);
+    if (object) {
+        (*env)->DeleteLocalRef(env, object);
+    }
 
-    av_freep(&format);
+    if (!format->object) {
+        ff_jni_reset_jfields(env, &format->jfields, jni_amediaformat_mapping, 1, format);
+        av_freep(&format);
+    }
 
-    return NULL;
+    return format;
 }
 
 static FFAMediaFormat *ff_AMediaFormat_newFromObject(void *object)
@@ -1129,9 +1134,11 @@ static int codec_init_static_fields(FFAMediaCodec *codec)
 
 FFAMediaCodec* ff_AMediaCodec_createCodecByName(const char *name)
 {
+    int ret = -1;
     JNIEnv *env = NULL;
     FFAMediaCodec *codec = NULL;
     jstring codec_name = NULL;
+    jobject object = NULL;
 
     codec = av_mallocz(sizeof(FFAMediaCodec));
     if (!codec) {
@@ -1154,12 +1161,12 @@ FFAMediaCodec* ff_AMediaCodec_createCodecByName(const char *name)
         goto fail;
     }
 
-    codec->object = (*env)->CallStaticObjectMethod(env, codec->jfields.mediacodec_class, codec->jfields.create_by_codec_name_id, codec_name);
+    object = (*env)->CallStaticObjectMethod(env, codec->jfields.mediacodec_class, codec->jfields.create_by_codec_name_id, codec_name);
     if (ff_jni_exception_check(env, 1, codec) < 0) {
         goto fail;
     }
 
-    codec->object = (*env)->NewGlobalRef(env, codec->object);
+    codec->object = (*env)->NewGlobalRef(env, object);
     if (!codec->object) {
         goto fail;
     }
@@ -1172,24 +1179,31 @@ FFAMediaCodec* ff_AMediaCodec_createCodecByName(const char *name)
         codec->has_get_i_o_buffer = 1;
     }
 
-    return codec;
+    ret = 0;
 fail:
-    ff_jni_reset_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec);
-
     if (codec_name) {
         (*env)->DeleteLocalRef(env, codec_name);
     }
 
-    av_freep(&codec);
+    if (object) {
+        (*env)->DeleteLocalRef(env, object);
+    }
 
-    return NULL;
+    if (ret < 0) {
+        ff_jni_reset_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec);
+        av_freep(&codec);
+    }
+
+    return codec;
 }
 
 FFAMediaCodec* ff_AMediaCodec_createDecoderByType(const char *mime)
 {
+    int ret = -1;
     JNIEnv *env = NULL;
     FFAMediaCodec *codec = NULL;
     jstring mime_type = NULL;
+    jobject object = NULL;
 
     codec = av_mallocz(sizeof(FFAMediaCodec));
     if (!codec) {
@@ -1212,12 +1226,12 @@ FFAMediaCodec* ff_AMediaCodec_createDecoderByType(const char *mime)
         goto fail;
     }
 
-    codec->object = (*env)->CallStaticObjectMethod(env, codec->jfields.mediacodec_class, codec->jfields.create_decoder_by_type_id, mime_type);
+    object = (*env)->CallStaticObjectMethod(env, codec->jfields.mediacodec_class, codec->jfields.create_decoder_by_type_id, mime_type);
     if (ff_jni_exception_check(env, 1, codec) < 0) {
         goto fail;
     }
 
-    codec->object = (*env)->NewGlobalRef(env, codec->object);
+    codec->object = (*env)->NewGlobalRef(env, object);
     if (!codec->object) {
         goto fail;
     }
@@ -1230,24 +1244,31 @@ FFAMediaCodec* ff_AMediaCodec_createDecoderByType(const char *mime)
         codec->has_get_i_o_buffer = 1;
     }
 
-    return codec;
+    ret = 0;
 fail:
-    ff_jni_reset_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec);
-
     if (mime_type) {
         (*env)->DeleteLocalRef(env, mime_type);
     }
 
-    av_freep(&codec);
+    if (object) {
+        (*env)->DeleteLocalRef(env, object);
+    }
 
-    return NULL;
+    if (ret < 0) {
+        ff_jni_reset_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec);
+        av_freep(&codec);
+    }
+
+    return codec;
 }
 
 FFAMediaCodec* ff_AMediaCodec_createEncoderByType(const char *mime)
 {
+    int ret = -1;
     JNIEnv *env = NULL;
     FFAMediaCodec *codec = NULL;
     jstring mime_type = NULL;
+    jobject object = NULL;
 
     codec = av_mallocz(sizeof(FFAMediaCodec));
     if (!codec) {
@@ -1270,12 +1291,12 @@ FFAMediaCodec* ff_AMediaCodec_createEncoderByType(const char *mime)
         goto fail;
     }
 
-    codec->object = (*env)->CallStaticObjectMethod(env, codec->jfields.mediacodec_class, codec->jfields.create_encoder_by_type_id, mime_type);
+    object = (*env)->CallStaticObjectMethod(env, codec->jfields.mediacodec_class, codec->jfields.create_encoder_by_type_id, mime_type);
     if (ff_jni_exception_check(env, 1, codec) < 0) {
         goto fail;
     }
 
-    codec->object = (*env)->NewGlobalRef(env, codec->object);
+    codec->object = (*env)->NewGlobalRef(env, object);
     if (!codec->object) {
         goto fail;
     }
@@ -1288,17 +1309,22 @@ FFAMediaCodec* ff_AMediaCodec_createEncoderByType(const char *mime)
         codec->has_get_i_o_buffer = 1;
     }
 
-    return codec;
+    ret = 0;
 fail:
-    ff_jni_reset_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec);
-
     if (mime_type) {
         (*env)->DeleteLocalRef(env, mime_type);
     }
 
-    av_freep(&codec);
+    if (object) {
+        (*env)->DeleteLocalRef(env, object);
+    }
 
-    return NULL;
+    if  (ret < 0) {
+        ff_jni_reset_jfields(env, &codec->jfields, jni_amediacodec_mapping, 1, codec);
+        av_freep(&codec);
+    }
+
+    return codec;
 }
 
 int ff_AMediaCodec_delete(FFAMediaCodec* codec)
@@ -1422,7 +1448,7 @@ int ff_AMediaCodec_releaseOutputBuffer(FFAMediaCodec* codec, size_t idx, int ren
 
     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
 
-    (*env)->CallVoidMethod(env, codec->object, codec->jfields.release_output_buffer_id, idx, render);
+    (*env)->CallVoidMethod(env, codec->object, codec->jfields.release_output_buffer_id, (jint)idx, (jboolean)render);
     if (ff_jni_exception_check(env, 1, codec) < 0) {
         ret = AVERROR_EXTERNAL;
         goto fail;
@@ -1439,7 +1465,7 @@ int ff_AMediaCodec_releaseOutputBufferAtTime(FFAMediaCodec *codec, size_t idx, i
 
     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
 
-    (*env)->CallVoidMethod(env, codec->object, codec->jfields.release_output_buffer_at_time_id, idx, timestampNs);
+    (*env)->CallVoidMethod(env, codec->object, codec->jfields.release_output_buffer_at_time_id, (jint)idx, timestampNs);
     if (ff_jni_exception_check(env, 1, codec) < 0) {
         ret = AVERROR_EXTERNAL;
         goto fail;
@@ -1473,7 +1499,7 @@ int ff_AMediaCodec_queueInputBuffer(FFAMediaCodec* codec, size_t idx, off_t offs
 
     JNI_GET_ENV_OR_RETURN(env, codec, AVERROR_EXTERNAL);
 
-    (*env)->CallVoidMethod(env, codec->object, codec->jfields.queue_input_buffer_id, idx, offset, size, time, flags);
+    (*env)->CallVoidMethod(env, codec->object, codec->jfields.queue_input_buffer_id, (jint)idx, (jint)offset, (jint)size, time, flags);
     if ((ret = ff_jni_exception_check(env, 1, codec)) < 0) {
         ret = AVERROR_EXTERNAL;
         goto fail;
@@ -1541,22 +1567,23 @@ uint8_t* ff_AMediaCodec_getInputBuffer(FFAMediaCodec* codec, size_t idx, size_t
     JNIEnv *env = NULL;
 
     jobject buffer = NULL;
+    jobject input_buffers = NULL;
 
     JNI_GET_ENV_OR_RETURN(env, codec, NULL);
 
     if (codec->has_get_i_o_buffer) {
-        buffer = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_input_buffer_id, idx);
+        buffer = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_input_buffer_id, (jint)idx);
         if (ff_jni_exception_check(env, 1, codec) < 0) {
             goto fail;
         }
     } else {
         if (!codec->input_buffers) {
-            codec->input_buffers = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_input_buffers_id);
+            input_buffers = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_input_buffers_id);
             if (ff_jni_exception_check(env, 1, codec) < 0) {
                 goto fail;
             }
 
-            codec->input_buffers = (*env)->NewGlobalRef(env, codec->input_buffers);
+            codec->input_buffers = (*env)->NewGlobalRef(env, input_buffers);
             if (ff_jni_exception_check(env, 1, codec) < 0) {
                 goto fail;
             }
@@ -1575,6 +1602,10 @@ uint8_t* ff_AMediaCodec_getInputBuffer(FFAMediaCodec* codec, size_t idx, size_t
         (*env)->DeleteLocalRef(env, buffer);
     }
 
+    if (input_buffers) {
+        (*env)->DeleteLocalRef(env, input_buffers);
+    }
+
     return ret;
 }
 
@@ -1584,22 +1615,23 @@ uint8_t* ff_AMediaCodec_getOutputBuffer(FFAMediaCodec* codec, size_t idx, size_t
     JNIEnv *env = NULL;
 
     jobject buffer = NULL;
+    jobject output_buffers = NULL;
 
     JNI_GET_ENV_OR_RETURN(env, codec, NULL);
 
     if (codec->has_get_i_o_buffer) {
-        buffer = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffer_id, idx);
+        buffer = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffer_id, (jint)idx);
         if (ff_jni_exception_check(env, 1, codec) < 0) {
             goto fail;
         }
     } else {
         if (!codec->output_buffers) {
-            codec->output_buffers = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffers_id);
+            output_buffers = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffers_id);
             if (ff_jni_exception_check(env, 1, codec) < 0) {
                 goto fail;
             }
 
-            codec->output_buffers = (*env)->NewGlobalRef(env, codec->output_buffers);
+            codec->output_buffers = (*env)->NewGlobalRef(env, output_buffers);
             if (ff_jni_exception_check(env, 1, codec) < 0) {
                 goto fail;
             }
@@ -1618,6 +1650,10 @@ uint8_t* ff_AMediaCodec_getOutputBuffer(FFAMediaCodec* codec, size_t idx, size_t
         (*env)->DeleteLocalRef(env, buffer);
     }
 
+    if (output_buffers) {
+        (*env)->DeleteLocalRef(env, output_buffers);
+    }
+
     return ret;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mediacodecdec.c b/mythtv/external/FFmpeg/libavcodec/mediacodecdec.c
index 2e645caafd9..6962ce2474f 100644
--- a/mythtv/external/FFmpeg/libavcodec/mediacodecdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/mediacodecdec.c
@@ -1,5 +1,5 @@
 /*
- * Android MediaCodec H.264 / H.265 / MPEG-4 / VP8 / VP9 decoders
+ * Android MediaCodec MPEG-2 / H.264 / H.265 / MPEG-4 / VP8 / VP9 decoders
  *
  * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
  *
@@ -29,7 +29,6 @@
 #include "libavutil/opt.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/pixfmt.h"
-#include "libavutil/atomic.h"
 
 #include "avcodec.h"
 #include "h264_parse.h"
@@ -42,11 +41,9 @@ typedef struct MediaCodecH264DecContext {
 
     MediaCodecDecContext *ctx;
 
-    AVBSFContext *bsf;
-
     AVFifoBuffer *fifo;
 
-    AVPacket filtered_pkt;
+    AVPacket buffered_pkt;
 
 } MediaCodecH264DecContext;
 
@@ -59,8 +56,7 @@ static av_cold int mediacodec_decode_close(AVCodecContext *avctx)
 
     av_fifo_free(s->fifo);
 
-    av_bsf_free(&s->bsf);
-    av_packet_unref(&s->filtered_pkt);
+    av_packet_unref(&s->buffered_pkt);
 
     return 0;
 }
@@ -186,6 +182,7 @@ static int hevc_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
     int ret;
 
     HEVCParamSets ps;
+    HEVCSEIContext sei;
 
     const HEVCVPS *vps = NULL;
     const HEVCPPS *pps = NULL;
@@ -201,21 +198,22 @@ static int hevc_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
     int pps_data_size = 0;
 
     memset(&ps, 0, sizeof(ps));
+    memset(&sei, 0, sizeof(sei));
 
     ret = ff_hevc_decode_extradata(avctx->extradata, avctx->extradata_size,
-                                &ps, &is_nalff, &nal_length_size, 0, avctx);
+                                   &ps, &sei, &is_nalff, &nal_length_size, 0, 1, avctx);
     if (ret < 0) {
         goto done;
     }
 
-    for (i = 0; i < MAX_VPS_COUNT; i++) {
+    for (i = 0; i < HEVC_MAX_VPS_COUNT; i++) {
         if (ps.vps_list[i]) {
             vps = (const HEVCVPS*)ps.vps_list[i]->data;
             break;
         }
     }
 
-    for (i = 0; i < MAX_PPS_COUNT; i++) {
+    for (i = 0; i < HEVC_MAX_PPS_COUNT; i++) {
         if (ps.pps_list[i]) {
             pps = (const HEVCPPS*)ps.pps_list[i]->data;
             break;
@@ -266,6 +264,19 @@ static int hevc_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
 }
 #endif
 
+#if CONFIG_MPEG2_MEDIACODEC_DECODER
+static int mpeg2_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
+{
+    int ret = 0;
+
+    if (avctx->extradata) {
+        ff_AMediaFormat_setBuffer(format, "csd-0", avctx->extradata, avctx->extradata_size);
+    }
+
+    return ret;
+}
+#endif
+
 #if CONFIG_MPEG4_MEDIACODEC_DECODER
 static int mpeg4_set_extradata(AVCodecContext *avctx, FFAMediaFormat *format)
 {
@@ -298,9 +309,6 @@ static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
 
     const char *codec_mime = NULL;
 
-    const char *bsf_name = NULL;
-    const AVBitStreamFilter *bsf = NULL;
-
     FFAMediaFormat *format = NULL;
     MediaCodecH264DecContext *s = avctx->priv_data;
 
@@ -315,7 +323,6 @@ static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
 #if CONFIG_H264_MEDIACODEC_DECODER
     case AV_CODEC_ID_H264:
         codec_mime = "video/avc";
-        bsf_name = "h264_mp4toannexb";
 
         ret = h264_set_extradata(avctx, format);
         if (ret < 0)
@@ -325,13 +332,21 @@ static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
 #if CONFIG_HEVC_MEDIACODEC_DECODER
     case AV_CODEC_ID_HEVC:
         codec_mime = "video/hevc";
-        bsf_name = "hevc_mp4toannexb";
 
         ret = hevc_set_extradata(avctx, format);
         if (ret < 0)
             goto done;
         break;
 #endif
+#if CONFIG_MPEG2_MEDIACODEC_DECODER
+    case AV_CODEC_ID_MPEG2VIDEO:
+        codec_mime = "video/mpeg2";
+
+        ret = mpeg2_set_extradata(avctx, format);
+        if (ret < 0)
+            goto done;
+        break;
+#endif
 #if CONFIG_MPEG4_MEDIACODEC_DECODER
     case AV_CODEC_ID_MPEG4:
         codec_mime = "video/mp4v-es",
@@ -387,25 +402,6 @@ static av_cold int mediacodec_decode_init(AVCodecContext *avctx)
         goto done;
     }
 
-    if (bsf_name) {
-    bsf = av_bsf_get_by_name(bsf_name);
-    if(!bsf) {
-        ret = AVERROR_BSF_NOT_FOUND;
-        goto done;
-    }
-
-    if ((ret = av_bsf_alloc(bsf, &s->bsf))) {
-        goto done;
-    }
-
-    if (((ret = avcodec_parameters_from_context(s->bsf->par_in, avctx)) < 0) ||
-        ((ret = av_bsf_init(s->bsf)) < 0)) {
-          goto done;
-    }
-    }
-
-    av_init_packet(&s->filtered_pkt);
-
 done:
     if (format) {
         ff_AMediaFormat_delete(format);
@@ -479,11 +475,9 @@ static int mediacodec_decode_frame(AVCodecContext *avctx, void *data,
 
     /* process buffered data */
     while (!*got_frame) {
-        /* prepare the input data -- convert to Annex B if needed */
-        if (s->filtered_pkt.size <= 0) {
-            AVPacket input_pkt = { 0 };
-
-            av_packet_unref(&s->filtered_pkt);
+        /* prepare the input data */
+        if (s->buffered_pkt.size <= 0) {
+            av_packet_unref(&s->buffered_pkt);
 
             /* no more data */
             if (av_fifo_size(s->fifo) < sizeof(AVPacket)) {
@@ -491,38 +485,17 @@ static int mediacodec_decode_frame(AVCodecContext *avctx, void *data,
                     ff_mediacodec_dec_decode(avctx, s->ctx, frame, got_frame, avpkt);
             }
 
-            av_fifo_generic_read(s->fifo, &input_pkt, sizeof(input_pkt), NULL);
-
-            if (s->bsf) {
-            ret = av_bsf_send_packet(s->bsf, &input_pkt);
-            if (ret < 0) {
-                return ret;
-            }
-
-            ret = av_bsf_receive_packet(s->bsf, &s->filtered_pkt);
-            if (ret == AVERROR(EAGAIN)) {
-                goto done;
-            }
-            } else {
-                av_packet_move_ref(&s->filtered_pkt, &input_pkt);
-            }
-
-            /* {h264,hevc}_mp4toannexb are used here and do not require flushing */
-            av_assert0(ret != AVERROR_EOF);
-
-            if (ret < 0) {
-                return ret;
-            }
+            av_fifo_generic_read(s->fifo, &s->buffered_pkt, sizeof(s->buffered_pkt), NULL);
         }
 
-        ret = mediacodec_process_data(avctx, frame, got_frame, &s->filtered_pkt);
+        ret = mediacodec_process_data(avctx, frame, got_frame, &s->buffered_pkt);
         if (ret < 0)
             return ret;
 
-        s->filtered_pkt.size -= ret;
-        s->filtered_pkt.data += ret;
+        s->buffered_pkt.size -= ret;
+        s->buffered_pkt.data += ret;
     }
-done:
+
     return avpkt->size;
 }
 
@@ -537,7 +510,7 @@ static void mediacodec_decode_flush(AVCodecContext *avctx)
     }
     av_fifo_reset(s->fifo);
 
-    av_packet_unref(&s->filtered_pkt);
+    av_packet_unref(&s->buffered_pkt);
 
     ff_mediacodec_dec_flush(avctx, s->ctx);
 }
@@ -553,8 +526,9 @@ AVCodec ff_h264_mediacodec_decoder = {
     .decode         = mediacodec_decode_frame,
     .flush          = mediacodec_decode_flush,
     .close          = mediacodec_decode_close,
-    .capabilities   = CODEC_CAP_DELAY,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING,
     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
+    .bsfs           = "h264_mp4toannexb",
 };
 #endif
 
@@ -569,7 +543,24 @@ AVCodec ff_hevc_mediacodec_decoder = {
     .decode         = mediacodec_decode_frame,
     .flush          = mediacodec_decode_flush,
     .close          = mediacodec_decode_close,
-    .capabilities   = CODEC_CAP_DELAY,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING,
+    .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
+    .bsfs           = "hevc_mp4toannexb",
+};
+#endif
+
+#if CONFIG_MPEG2_MEDIACODEC_DECODER
+AVCodec ff_mpeg2_mediacodec_decoder = {
+    .name           = "mpeg2_mediacodec",
+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 Android MediaCodec decoder"),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_MPEG2VIDEO,
+    .priv_data_size = sizeof(MediaCodecH264DecContext),
+    .init           = mediacodec_decode_init,
+    .decode         = mediacodec_decode_frame,
+    .flush          = mediacodec_decode_flush,
+    .close          = mediacodec_decode_close,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING,
     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
 };
 #endif
@@ -585,7 +576,7 @@ AVCodec ff_mpeg4_mediacodec_decoder = {
     .decode         = mediacodec_decode_frame,
     .flush          = mediacodec_decode_flush,
     .close          = mediacodec_decode_close,
-    .capabilities   = CODEC_CAP_DELAY,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING,
     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
 };
 #endif
@@ -601,7 +592,7 @@ AVCodec ff_vp8_mediacodec_decoder = {
     .decode         = mediacodec_decode_frame,
     .flush          = mediacodec_decode_flush,
     .close          = mediacodec_decode_close,
-    .capabilities   = CODEC_CAP_DELAY,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING,
     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
 };
 #endif
@@ -617,7 +608,7 @@ AVCodec ff_vp9_mediacodec_decoder = {
     .decode         = mediacodec_decode_frame,
     .flush          = mediacodec_decode_flush,
     .close          = mediacodec_decode_close,
-    .capabilities   = CODEC_CAP_DELAY,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING,
     .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS,
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/mediacodecdec_common.c b/mythtv/external/FFmpeg/libavcodec/mediacodecdec_common.c
index dfc7f5514a9..afa054f83e4 100644
--- a/mythtv/external/FFmpeg/libavcodec/mediacodecdec_common.c
+++ b/mythtv/external/FFmpeg/libavcodec/mediacodecdec_common.c
@@ -23,7 +23,6 @@
 #include <string.h>
 #include <sys/types.h>
 
-#include "libavutil/atomic.h"
 #include "libavutil/common.h"
 #include "libavutil/mem.h"
 #include "libavutil/log.h"
@@ -143,7 +142,7 @@ static enum AVPixelFormat mcdec_map_color_format(AVCodecContext *avctx,
 
 static void ff_mediacodec_dec_ref(MediaCodecDecContext *s)
 {
-    avpriv_atomic_int_add_and_fetch(&s->refcount, 1);
+    atomic_fetch_add(&s->refcount, 1);
 }
 
 static void ff_mediacodec_dec_unref(MediaCodecDecContext *s)
@@ -151,7 +150,7 @@ static void ff_mediacodec_dec_unref(MediaCodecDecContext *s)
     if (!s)
         return;
 
-    if (!avpriv_atomic_int_add_and_fetch(&s->refcount, -1)) {
+    if (atomic_fetch_sub(&s->refcount, 1) == 1) {
         if (s->codec) {
             ff_AMediaCodec_delete(s->codec);
             s->codec = NULL;
@@ -176,7 +175,7 @@ static void mediacodec_buffer_release(void *opaque, uint8_t *data)
 {
     AVMediaCodecBuffer *buffer = opaque;
     MediaCodecDecContext *ctx = buffer->ctx;
-    int released = avpriv_atomic_int_get(&buffer->released);
+    int released = atomic_load(&buffer->released);
 
     if (!released) {
         ff_AMediaCodec_releaseOutputBuffer(ctx->codec, buffer->index, 0);
@@ -221,7 +220,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
         goto fail;
     }
 
-    buffer->released = 0;
+    atomic_init(&buffer->released, 0);
 
     frame->buf[0] = av_buffer_create(NULL,
                                      0,
@@ -283,10 +282,16 @@ static int mediacodec_wrap_sw_buffer(AVCodecContext *avctx,
      * on the last avpacket received which is not in sync with the frame:
      *   * N avpackets can be pushed before 1 frame is actually returned
      *   * 0-sized avpackets are pushed to flush remaining frames at EOS */
-    frame->pts = info->presentationTimeUs;
+    if (avctx->pkt_timebase.num && avctx->pkt_timebase.den) {
+        frame->pts = av_rescale_q(info->presentationTimeUs,
+                                      av_make_q(1, 1000000),
+                                      avctx->pkt_timebase);
+    } else {
+        frame->pts = info->presentationTimeUs;
+    }
 #if FF_API_PKT_PTS
 FF_DISABLE_DEPRECATION_WARNINGS
-    frame->pkt_pts = info->presentationTimeUs;
+    frame->pkt_pts = frame->pts;
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
     frame->pkt_dts = AV_NOPTS_VALUE;
@@ -465,7 +470,7 @@ int ff_mediacodec_dec_init(AVCodecContext *avctx, MediaCodecDecContext *s,
         AV_PIX_FMT_NONE,
     };
 
-    s->refcount = 1;
+    atomic_init(&s->refcount, 1);
 
     pix_fmt = ff_get_format(avctx, pix_fmts);
     if (pix_fmt == AV_PIX_FMT_MEDIACODEC) {
@@ -479,7 +484,7 @@ int ff_mediacodec_dec_init(AVCodecContext *avctx, MediaCodecDecContext *s,
 
     profile = ff_AMediaCodecProfile_getProfileFromAVCodecContext(avctx);
     if (profile < 0) {
-        av_log(avctx, AV_LOG_WARNING, "Unsupported or unknown profile");
+        av_log(avctx, AV_LOG_WARNING, "Unsupported or unknown profile\n");
     }
 
     s->codec_name = ff_AMediaCodecList_getCodecNameByType(mime, profile, 0, avctx);
@@ -614,7 +619,7 @@ int ff_mediacodec_dec_decode(AVCodecContext *avctx, MediaCodecDecContext *s,
             memcpy(data, pkt->data + offset, size);
             offset += size;
 
-            if (s->surface && avctx->pkt_timebase.num && avctx->pkt_timebase.den) {
+            if (avctx->pkt_timebase.num && avctx->pkt_timebase.den) {
                 pts = av_rescale_q(pts, avctx->pkt_timebase, av_make_q(1, 1000000));
             }
 
@@ -725,7 +730,7 @@ int ff_mediacodec_dec_decode(AVCodecContext *avctx, MediaCodecDecContext *s,
 
 int ff_mediacodec_dec_flush(AVCodecContext *avctx, MediaCodecDecContext *s)
 {
-    if (!s->surface || avpriv_atomic_int_get(&s->refcount) == 1) {
+    if (!s->surface || atomic_load(&s->refcount) == 1) {
         int ret;
 
         /* No frames (holding a reference to the codec) are retained by the
@@ -767,6 +772,13 @@ AVHWAccel ff_hevc_mediacodec_hwaccel = {
     .pix_fmt = AV_PIX_FMT_MEDIACODEC,
 };
 
+AVHWAccel ff_mpeg2_mediacodec_hwaccel = {
+    .name    = "mediacodec",
+    .type    = AVMEDIA_TYPE_VIDEO,
+    .id      = AV_CODEC_ID_MPEG2VIDEO,
+    .pix_fmt = AV_PIX_FMT_MEDIACODEC,
+};
+
 AVHWAccel ff_mpeg4_mediacodec_hwaccel = {
     .name    = "mediacodec",
     .type    = AVMEDIA_TYPE_VIDEO,
diff --git a/mythtv/external/FFmpeg/libavcodec/mediacodecdec_common.h b/mythtv/external/FFmpeg/libavcodec/mediacodecdec_common.h
index c00c2e89f3b..10f38277b54 100644
--- a/mythtv/external/FFmpeg/libavcodec/mediacodecdec_common.h
+++ b/mythtv/external/FFmpeg/libavcodec/mediacodecdec_common.h
@@ -24,6 +24,7 @@
 #define AVCODEC_MEDIACODECDEC_COMMON_H
 
 #include <stdint.h>
+#include <stdatomic.h>
 #include <sys/types.h>
 
 #include "libavutil/frame.h"
@@ -34,7 +35,7 @@
 
 typedef struct MediaCodecDecContext {
 
-    volatile int refcount;
+    atomic_int refcount;
 
     char *codec_name;
 
@@ -88,7 +89,7 @@ typedef struct MediaCodecBuffer {
     MediaCodecDecContext *ctx;
     ssize_t index;
     int64_t pts;
-    volatile int released;
+    atomic_int released;
 
 } MediaCodecBuffer;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/metasound.c b/mythtv/external/FFmpeg/libavcodec/metasound.c
index 6a7e31a26b1..87cd7cb2110 100644
--- a/mythtv/external/FFmpeg/libavcodec/metasound.c
+++ b/mythtv/external/FFmpeg/libavcodec/metasound.c
@@ -170,9 +170,10 @@ static int metasound_read_bitstream(AVCodecContext *avctx, TwinVQContext *tctx,
     int channels              = tctx->avctx->channels;
     int sub;
     GetBitContext gb;
-    int i, j, k;
+    int i, j, k, ret;
 
-    init_get_bits(&gb, buf, buf_size * 8);
+    if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)
+        return ret;
 
     for (tctx->cur_frame = 0; tctx->cur_frame < tctx->frames_per_packet;
          tctx->cur_frame++) {
diff --git a/mythtv/external/FFmpeg/libavcodec/metasound_data.c b/mythtv/external/FFmpeg/libavcodec/metasound_data.c
index 6d87117406b..da2548af9d7 100644
--- a/mythtv/external/FFmpeg/libavcodec/metasound_data.c
+++ b/mythtv/external/FFmpeg/libavcodec/metasound_data.c
@@ -14946,11 +14946,6 @@ static const uint16_t bark_tab_s16_128[] = {
     2, 2, 2, 3, 3, 5, 7, 12, 25, 67
 };
 
-/* unused
-static const uint16_t bark_tab_s16_64[] = {
-    1, 1, 2, 2, 3, 6, 11, 38
-}; */
-
 static const uint16_t bark_tab_l16s_1024[] = {
       9,   9,   8,   9,  10,   9,  10,  10,
      10,  12,  11,  13,  13,  14,  16,  17,
diff --git a/mythtv/external/FFmpeg/libavcodec/microdvddec.c b/mythtv/external/FFmpeg/libavcodec/microdvddec.c
index e8d271931f4..4a342677937 100644
--- a/mythtv/external/FFmpeg/libavcodec/microdvddec.c
+++ b/mythtv/external/FFmpeg/libavcodec/microdvddec.c
@@ -214,7 +214,7 @@ static void microdvd_open_tags(AVBPrint *new_line, struct microdvd_tag *tags)
             break;
 
         case 'c':
-            av_bprintf(new_line, "{\\c&H%06X&}", tags[i].data1);
+            av_bprintf(new_line, "{\\c&H%06"PRIX32"&}", tags[i].data1);
             break;
 
         case 'f':
@@ -223,7 +223,7 @@ static void microdvd_open_tags(AVBPrint *new_line, struct microdvd_tag *tags)
             break;
 
         case 's':
-            av_bprintf(new_line, "{\\fs%d}", tags[i].data1);
+            av_bprintf(new_line, "{\\fs%"PRId32"}", tags[i].data1);
             break;
 
         case 'p':
@@ -232,7 +232,7 @@ static void microdvd_open_tags(AVBPrint *new_line, struct microdvd_tag *tags)
             break;
 
         case 'o':
-            av_bprintf(new_line, "{\\pos(%d,%d)}",
+            av_bprintf(new_line, "{\\pos(%"PRId32",%"PRId32")}",
                        tags[i].data1, tags[i].data2);
             break;
         }
diff --git a/mythtv/external/FFmpeg/libavcodec/mimic.c b/mythtv/external/FFmpeg/libavcodec/mimic.c
index 06fb393b92d..1d463e9962c 100644
--- a/mythtv/external/FFmpeg/libavcodec/mimic.c
+++ b/mythtv/external/FFmpeg/libavcodec/mimic.c
@@ -49,7 +49,7 @@ typedef struct MimicContext {
 
     ThreadFrame     frames     [16];
 
-    DECLARE_ALIGNED(16, int16_t, dct_block)[64];
+    DECLARE_ALIGNED(32, int16_t, dct_block)[64];
 
     GetBitContext   gb;
     ScanTable       scantable;
@@ -260,9 +260,9 @@ static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
         /* FFmpeg's IDCT behaves somewhat different from the original code, so
          * a factor of 4 was added to the input */
 
-        coeff = vlcdec_lookup[num_bits][value];
+        coeff = ((int8_t*)vlcdec_lookup[num_bits])[value];
         if (pos < 3)
-            coeff <<= 4;
+            coeff *= 16;
         else /* TODO Use >> 10 instead of / 1001 */
             coeff = (coeff * qscale) / 1001;
 
@@ -390,9 +390,11 @@ static int mimic_decode_frame(AVCodecContext *avctx, void *data,
             return AVERROR_INVALIDDATA;
         }
 
+        res = ff_set_dimensions(avctx, width, height);
+        if (res < 0)
+            return res;
+
         ctx->avctx     = avctx;
-        avctx->width   = width;
-        avctx->height  = height;
         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
         for (i = 0; i < 3; i++) {
             ctx->num_vblocks[i] = AV_CEIL_RSHIFT(height,   3 + !!i);
@@ -446,9 +448,6 @@ static int mimic_decode_frame(AVCodecContext *avctx, void *data,
     ctx->prev_index = ctx->next_prev_index;
     ctx->cur_index  = ctx->next_cur_index;
 
-    /* Only release frames that aren't used for backreferences anymore */
-    ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
-
     return buf_size;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/Makefile b/mythtv/external/FFmpeg/libavcodec/mips/Makefile
index 3c436006597..1f659a0037e 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/Makefile
+++ b/mythtv/external/FFmpeg/libavcodec/mips/Makefile
@@ -36,6 +36,9 @@ OBJS-$(CONFIG_MPEGVIDEO)                  += mips/mpegvideo_init_mips.o
 OBJS-$(CONFIG_MPEGVIDEOENC)               += mips/mpegvideoencdsp_init_mips.o
 OBJS-$(CONFIG_ME_CMP)                     += mips/me_cmp_init_mips.o
 OBJS-$(CONFIG_MPEG4_DECODER)              += mips/xvididct_init_mips.o
+OBJS-$(CONFIG_VC1DSP)                     += mips/vc1dsp_init_mips.o
+OBJS-$(CONFIG_WMV2DSP)                    += mips/wmv2dsp_init_mips.o
+OBJS-$(CONFIG_VIDEODSP)                   += mips/videodsp_init.o
 MSA-OBJS-$(CONFIG_HEVC_DECODER)           += mips/hevcdsp_msa.o            \
                                              mips/hevc_mc_uni_msa.o        \
                                              mips/hevc_mc_uniw_msa.o       \
@@ -77,4 +80,7 @@ MMI-OBJS-$(CONFIG_MPEG4_DECODER)          += mips/xvid_idct_mmi.o
 MMI-OBJS-$(CONFIG_BLOCKDSP)               += mips/blockdsp_mmi.o
 MMI-OBJS-$(CONFIG_PIXBLOCKDSP)            += mips/pixblockdsp_mmi.o
 MMI-OBJS-$(CONFIG_H264QPEL)               += mips/h264qpel_mmi.o
+MMI-OBJS-$(CONFIG_VP8_DECODER)            += mips/vp8dsp_mmi.o
 MMI-OBJS-$(CONFIG_HPELDSP)                += mips/hpeldsp_mmi.o
+MMI-OBJS-$(CONFIG_VC1_DECODER)            += mips/vc1dsp_mmi.o
+MMI-OBJS-$(CONFIG_WMV2DSP)                += mips/wmv2dsp_mmi.o
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/ac3dsp_mips.c b/mythtv/external/FFmpeg/libavcodec/mips/ac3dsp_mips.c
index f9aaf15639a..e5cee160819 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/ac3dsp_mips.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/ac3dsp_mips.c
@@ -409,7 +409,7 @@ void ff_ac3dsp_init_mips(AC3DSPContext *c, int bit_exact) {
 #if HAVE_MIPSFPU
 #if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
     c->float_to_fixed24 = float_to_fixed24_mips;
-    c->downmix          = ac3_downmix_mips;
+    //c->downmix          = ac3_downmix_mips;
 #endif
 #endif
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_mips.h b/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_mips.h
index 9559d40eaa3..1742b123c3a 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_mips.h
+++ b/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_mips.h
@@ -24,13 +24,13 @@
 
 #include "../mpegvideo.h"
 
-void ff_fill_block16_msa(uint8_t *src, uint8_t val, int stride, int height);
-void ff_fill_block8_msa(uint8_t *src, uint8_t val, int stride, int height);
+void ff_fill_block16_msa(uint8_t *src, uint8_t val, ptrdiff_t stride, int height);
+void ff_fill_block8_msa(uint8_t *src, uint8_t val, ptrdiff_t stride, int height);
 void ff_clear_block_msa(int16_t *block);
 void ff_clear_blocks_msa(int16_t *block);
 
-void ff_fill_block16_mmi(uint8_t *block, uint8_t value, int line_size, int h);
-void ff_fill_block8_mmi(uint8_t *block, uint8_t value, int line_size, int h);
+void ff_fill_block16_mmi(uint8_t *block, uint8_t value, ptrdiff_t line_size, int h);
+void ff_fill_block8_mmi(uint8_t *block, uint8_t value, ptrdiff_t line_size, int h);
 void ff_clear_block_mmi(int16_t *block);
 void ff_clear_blocks_mmi(int16_t *block);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_mmi.c b/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_mmi.c
index 1035dbbc571..68641e25448 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_mmi.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_mmi.c
@@ -24,7 +24,7 @@
 #include "blockdsp_mips.h"
 #include "libavutil/mips/mmiutils.h"
 
-void ff_fill_block16_mmi(uint8_t *block, uint8_t value, int line_size, int h)
+void ff_fill_block16_mmi(uint8_t *block, uint8_t value, ptrdiff_t line_size, int h)
 {
     double ftmp[1];
     DECLARE_VAR_ALL64;
@@ -48,7 +48,7 @@ void ff_fill_block16_mmi(uint8_t *block, uint8_t value, int line_size, int h)
     );
 }
 
-void ff_fill_block8_mmi(uint8_t *block, uint8_t value, int line_size, int h)
+void ff_fill_block8_mmi(uint8_t *block, uint8_t value, ptrdiff_t line_size, int h)
 {
     double ftmp0;
     DECLARE_VAR_ALL64;
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_msa.c
index 32ac858e1dc..2b78c288f08 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/blockdsp_msa.c
@@ -65,12 +65,12 @@ static void memset_zero_16width_msa(uint8_t *src, int32_t stride,
     }
 }
 
-void ff_fill_block16_msa(uint8_t *src, uint8_t val, int stride, int height)
+void ff_fill_block16_msa(uint8_t *src, uint8_t val, ptrdiff_t stride, int height)
 {
     copy_8bit_value_width16_msa(src, val, stride, height);
 }
 
-void ff_fill_block8_msa(uint8_t *src, uint8_t val, int stride, int height)
+void ff_fill_block8_msa(uint8_t *src, uint8_t val, ptrdiff_t stride, int height)
 {
     copy_8bit_value_width8_msa(src, val, stride, height);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/constants.c b/mythtv/external/FFmpeg/libavcodec/mips/constants.c
index 3503fad37b8..a7c4a5ccf67 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/constants.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/constants.c
@@ -28,12 +28,17 @@ DECLARE_ALIGNED(8, const uint64_t, ff_pw_2) =       {0x0002000200020002ULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_3) =       {0x0003000300030003ULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_4) =       {0x0004000400040004ULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_5) =       {0x0005000500050005ULL};
+DECLARE_ALIGNED(8, const uint64_t, ff_pw_6) =       {0x0006000600060006ULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_8) =       {0x0008000800080008ULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_9) =       {0x0009000900090009ULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_10) =      {0x000A000A000A000AULL};
+DECLARE_ALIGNED(8, const uint64_t, ff_pw_12) =      {0x000C000C000C000CULL};
+DECLARE_ALIGNED(8, const uint64_t, ff_pw_15) =      {0x000F000F000F000FULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_16) =      {0x0010001000100010ULL};
+DECLARE_ALIGNED(8, const uint64_t, ff_pw_17) =      {0x0011001100110011ULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_18) =      {0x0012001200120012ULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_20) =      {0x0014001400140014ULL};
+DECLARE_ALIGNED(8, const uint64_t, ff_pw_22) =      {0x0016001600160016ULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_28) =      {0x001C001C001C001CULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_32) =      {0x0020002000200020ULL};
 DECLARE_ALIGNED(8, const uint64_t, ff_pw_53) =      {0x0035003500350035ULL};
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/constants.h b/mythtv/external/FFmpeg/libavcodec/mips/constants.h
index 19d2d73c297..26045599501 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/constants.h
+++ b/mythtv/external/FFmpeg/libavcodec/mips/constants.h
@@ -29,12 +29,17 @@ extern const uint64_t ff_pw_2;
 extern const uint64_t ff_pw_3;
 extern const uint64_t ff_pw_4;
 extern const uint64_t ff_pw_5;
+extern const uint64_t ff_pw_6;
 extern const uint64_t ff_pw_8;
 extern const uint64_t ff_pw_9;
 extern const uint64_t ff_pw_10;
+extern const uint64_t ff_pw_12;
+extern const uint64_t ff_pw_15;
 extern const uint64_t ff_pw_16;
+extern const uint64_t ff_pw_17;
 extern const uint64_t ff_pw_18;
 extern const uint64_t ff_pw_20;
+extern const uint64_t ff_pw_22;
 extern const uint64_t ff_pw_28;
 extern const uint64_t ff_pw_32;
 extern const uint64_t ff_pw_53;
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_mips.h b/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_mips.h
index 6e6127d8a70..996384d0055 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_mips.h
+++ b/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_mips.h
@@ -22,26 +22,26 @@
 #define AVCODEC_MIPS_H264CHROMA_MIPS_H
 
 #include "libavcodec/h264dec.h"
-void ff_put_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src, int stride,
+void ff_put_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                 int height, int x, int y);
-void ff_put_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src, int stride,
+void ff_put_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                 int height, int x, int y);
-void ff_put_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src, int stride,
+void ff_put_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                 int height, int x, int y);
-void ff_avg_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src, int stride,
+void ff_avg_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                 int height, int x, int y);
-void ff_avg_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src, int stride,
+void ff_avg_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                 int height, int x, int y);
-void ff_avg_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src, int stride,
+void ff_avg_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                                 int height, int x, int y);
 
-void ff_put_h264_chroma_mc8_mmi(uint8_t *dst, uint8_t *src, int stride,
+void ff_put_h264_chroma_mc8_mmi(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
         int h, int x, int y);
-void ff_avg_h264_chroma_mc8_mmi(uint8_t *dst, uint8_t *src, int stride,
+void ff_avg_h264_chroma_mc8_mmi(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
         int h, int x, int y);
-void ff_put_h264_chroma_mc4_mmi(uint8_t *dst, uint8_t *src, int stride,
+void ff_put_h264_chroma_mc4_mmi(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
         int h, int x, int y);
-void ff_avg_h264_chroma_mc4_mmi(uint8_t *dst, uint8_t *src, int stride,
+void ff_avg_h264_chroma_mc4_mmi(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
         int h, int x, int y);
 
 #endif /* AVCODEC_MIPS_H264CHROMA_MIPS_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_mmi.c b/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_mmi.c
index 417b4a2cfc2..bafe0f92ac6 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_mmi.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_mmi.c
@@ -26,7 +26,7 @@
 #include "constants.h"
 #include "libavutil/mips/mmiutils.h"
 
-void ff_put_h264_chroma_mc8_mmi(uint8_t *dst, uint8_t *src, int stride,
+void ff_put_h264_chroma_mc8_mmi(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
         int h, int x, int y)
 {
     const int A = (8 - x) * (8 - y);
@@ -207,7 +207,7 @@ void ff_put_h264_chroma_mc8_mmi(uint8_t *dst, uint8_t *src, int stride,
     }
 }
 
-void ff_avg_h264_chroma_mc8_mmi(uint8_t *dst, uint8_t *src, int stride,
+void ff_avg_h264_chroma_mc8_mmi(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
         int h, int x, int y)
 {
     const int A = (8 - x) * (8 - y);
@@ -396,7 +396,7 @@ void ff_avg_h264_chroma_mc8_mmi(uint8_t *dst, uint8_t *src, int stride,
     }
 }
 
-void ff_put_h264_chroma_mc4_mmi(uint8_t *dst, uint8_t *src, int stride,
+void ff_put_h264_chroma_mc4_mmi(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
         int h, int x, int y)
 {
     const int A = (8 - x) * (8 - y);
@@ -546,7 +546,7 @@ void ff_put_h264_chroma_mc4_mmi(uint8_t *dst, uint8_t *src, int stride,
     }
 }
 
-void ff_avg_h264_chroma_mc4_mmi(uint8_t *dst, uint8_t *src, int stride,
+void ff_avg_h264_chroma_mc4_mmi(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
         int h, int x, int y)
 {
     const int A = (8 - x) *(8 - y);
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_msa.c
index 67d0bc12abd..b8fcf6d012f 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/h264chroma_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Shivraj Patil (Shivraj.Patil@imgtec.com)
+ * Copyright (c) 2015 - 2017 Shivraj Patil (Shivraj.Patil@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -29,8 +29,7 @@ static const uint8_t chroma_mask_arr[16 * 5] = {
     0, 1, 1, 2, 16, 17, 17, 18, 16, 17, 17, 18, 18, 19, 19, 20
 };
 
-static void avc_chroma_hz_2x2_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_hz_2x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                   uint32_t coeff0, uint32_t coeff1)
 {
     uint16_t out0, out1;
@@ -44,7 +43,7 @@ static void avc_chroma_hz_2x2_msa(uint8_t *src, int32_t src_stride,
 
     mask = LD_SB(&chroma_mask_arr[0]);
 
-    LD_SB2(src, src_stride, src0, src1);
+    LD_SB2(src, stride, src0, src1);
 
     src0 = __msa_vshf_b(mask, src1, src0);
     res_r = __msa_dotp_u_h((v16u8) src0, coeff_vec);
@@ -57,12 +56,11 @@ static void avc_chroma_hz_2x2_msa(uint8_t *src, int32_t src_stride,
     out1 = __msa_copy_u_h(res, 2);
 
     SH(out0, dst);
-    dst += dst_stride;
+    dst += stride;
     SH(out1, dst);
 }
 
-static void avc_chroma_hz_2x4_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_hz_2x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                   uint32_t coeff0, uint32_t coeff1)
 {
     v16u8 src0, src1, src2, src3;
@@ -75,7 +73,7 @@ static void avc_chroma_hz_2x4_msa(uint8_t *src, int32_t src_stride,
 
     mask = LD_SB(&chroma_mask_arr[64]);
 
-    LD_UB4(src, src_stride, src0, src1, src2, src3);
+    LD_UB4(src, stride, src0, src1, src2, src3);
 
     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, src0, src2);
 
@@ -87,64 +85,21 @@ static void avc_chroma_hz_2x4_msa(uint8_t *src, int32_t src_stride,
     res_r = __msa_sat_u_h(res_r, 7);
     res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
 
-    ST2x4_UB(res, 0, dst, dst_stride);
+    ST2x4_UB(res, 0, dst, stride);
 }
 
-static void avc_chroma_hz_2x8_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
-                                  uint32_t coeff0, uint32_t coeff1)
-{
-    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
-    v8u16 res_r;
-    v8i16 res;
-    v16i8 mask;
-    v16i8 coeff_vec0 = __msa_fill_b(coeff0);
-    v16i8 coeff_vec1 = __msa_fill_b(coeff1);
-    v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
-
-    mask = LD_SB(&chroma_mask_arr[64]);
-
-    LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
-
-    VSHF_B2_UB(src0, src1, src2, src3, mask, mask, src0, src2);
-    VSHF_B2_UB(src4, src5, src6, src7, mask, mask, src4, src6);
-
-    ILVR_D2_UB(src2, src0, src6, src4, src0, src4);
-
-    res_r = __msa_dotp_u_h(src0, coeff_vec);
-    res_r <<= 3;
-    res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
-    res_r = __msa_sat_u_h(res_r, 7);
-    res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
-
-    ST2x4_UB(res, 0, dst, dst_stride);
-    dst += (4 * dst_stride);
-
-    res_r = __msa_dotp_u_h(src4, coeff_vec);
-    res_r <<= 3;
-    res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
-    res_r = __msa_sat_u_h(res_r, 7);
-    res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
-
-    ST2x4_UB(res, 0, dst, dst_stride);
-}
-
-static void avc_chroma_hz_2w_msa(uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_hz_2w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                  uint32_t coeff0, uint32_t coeff1,
                                  int32_t height)
 {
     if (2 == height) {
-        avc_chroma_hz_2x2_msa(src, src_stride, dst, dst_stride, coeff0, coeff1);
+        avc_chroma_hz_2x2_msa(src, dst, stride, coeff0, coeff1);
     } else if (4 == height) {
-        avc_chroma_hz_2x4_msa(src, src_stride, dst, dst_stride, coeff0, coeff1);
-    } else if (8 == height) {
-        avc_chroma_hz_2x8_msa(src, src_stride, dst, dst_stride, coeff0, coeff1);
+        avc_chroma_hz_2x4_msa(src, dst, stride, coeff0, coeff1);
     }
 }
 
-static void avc_chroma_hz_4x2_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_hz_4x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                   uint32_t coeff0, uint32_t coeff1)
 {
     v16i8 src0, src1;
@@ -157,7 +112,7 @@ static void avc_chroma_hz_4x2_msa(uint8_t *src, int32_t src_stride,
 
     mask = LD_SB(&chroma_mask_arr[0]);
 
-    LD_SB2(src, src_stride, src0, src1);
+    LD_SB2(src, stride, src0, src1);
 
     src0 = __msa_vshf_b(mask, src1, src0);
     res_r = __msa_dotp_u_h((v16u8) src0, coeff_vec);
@@ -166,18 +121,14 @@ static void avc_chroma_hz_4x2_msa(uint8_t *src, int32_t src_stride,
     res_r = __msa_sat_u_h(res_r, 7);
     res = (v4i32) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
 
-    ST4x2_UB(res, dst, dst_stride);
+    ST4x2_UB(res, dst, stride);
 }
 
-static void avc_chroma_hz_4x4multiple_msa(uint8_t *src, int32_t src_stride,
-                                          uint8_t *dst, int32_t dst_stride,
-                                          uint32_t coeff0, uint32_t coeff1,
-                                          int32_t height)
+static void avc_chroma_hz_4x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coeff0, uint32_t coeff1)
 {
-    uint32_t row;
-    v16u8 src0, src1, src2, src3;
+    v16u8 src0, src1, src2, src3, out;
     v8u16 res0_r, res1_r;
-    v4i32 res0, res1;
     v16i8 mask;
     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
@@ -185,42 +136,113 @@ static void avc_chroma_hz_4x4multiple_msa(uint8_t *src, int32_t src_stride,
 
     mask = LD_SB(&chroma_mask_arr[0]);
 
-    for (row = (height >> 2); row--;) {
-        LD_UB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
-
-        VSHF_B2_UB(src0, src1, src2, src3, mask, mask, src0, src2);
-        DOTP_UB2_UH(src0, src2, coeff_vec, coeff_vec, res0_r, res1_r);
+    LD_UB4(src, stride, src0, src1, src2, src3);
+    VSHF_B2_UB(src0, src1, src2, src3, mask, mask, src0, src2);
+    DOTP_UB2_UH(src0, src2, coeff_vec, coeff_vec, res0_r, res1_r);
+    res0_r <<= 3;
+    res1_r <<= 3;
+    SRARI_H2_UH(res0_r, res1_r, 6);
+    SAT_UH2_UH(res0_r, res1_r, 7);
+    out = (v16u8) __msa_pckev_b((v16i8) res1_r, (v16i8) res0_r);
+    ST4x4_UB(out, out, 0, 1, 2, 3, dst, stride);
+}
 
-        res0_r <<= 3;
-        res1_r <<= 3;
+static void avc_chroma_hz_4x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coeff0, uint32_t coeff1)
+{
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7, out0, out1;
+    v16i8 mask;
+    v8u16 res0, res1, res2, res3;
+    v16i8 coeff_vec0 = __msa_fill_b(coeff0);
+    v16i8 coeff_vec1 = __msa_fill_b(coeff1);
+    v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 
-        SRARI_H2_UH(res0_r, res1_r, 6);
-        SAT_UH2_UH(res0_r, res1_r, 7);
-        PCKEV_B2_SW(res0_r, res0_r, res1_r, res1_r, res0, res1);
+    mask = LD_SB(&chroma_mask_arr[0]);
 
-        ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
-        dst += (4 * dst_stride);
-    }
+    LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+    VSHF_B2_UB(src0, src1, src2, src3, mask, mask, src0, src2);
+    VSHF_B2_UB(src4, src5, src6, src7, mask, mask, src4, src6);
+    DOTP_UB2_UH(src0, src2, coeff_vec, coeff_vec, res0, res1);
+    DOTP_UB2_UH(src4, src6, coeff_vec, coeff_vec, res2, res3);
+    SLLI_4V(res0, res1, res2, res3, 3);
+    SRARI_H4_UH(res0, res1, res2, res3, 6);
+    SAT_UH4_UH(res0, res1, res2, res3, 7);
+    PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
+    ST4x8_UB(out0, out1, dst, stride);
 }
 
-static void avc_chroma_hz_4w_msa(uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_hz_4w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                  uint32_t coeff0, uint32_t coeff1,
                                  int32_t height)
 {
     if (2 == height) {
-        avc_chroma_hz_4x2_msa(src, src_stride, dst, dst_stride, coeff0, coeff1);
-    } else {
-        avc_chroma_hz_4x4multiple_msa(src, src_stride, dst, dst_stride, coeff0,
-                                      coeff1, height);
+        avc_chroma_hz_4x2_msa(src, dst, stride, coeff0, coeff1);
+    } else if (4 == height) {
+        avc_chroma_hz_4x4_msa(src, dst, stride, coeff0, coeff1);
+    } else if (8 == height) {
+        avc_chroma_hz_4x8_msa(src, dst, stride, coeff0, coeff1);
     }
 }
 
-static void avc_chroma_hz_8w_msa(uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
-                                 uint32_t coeff0, uint32_t coeff1,
-                                 int32_t height)
+static void avc_chroma_hz_8x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coeff0, uint32_t coeff1)
+{
+    v16u8 src0, src1, src2, src3, out0, out1;
+    v8u16 res0, res1, res2, res3;
+    v16i8 mask;
+    v16i8 coeff_vec0 = __msa_fill_b(coeff0);
+    v16i8 coeff_vec1 = __msa_fill_b(coeff1);
+    v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
+
+    mask = LD_SB(&chroma_mask_arr[32]);
+    LD_UB4(src, stride, src0, src1, src2, src3);
+    VSHF_B2_UB(src0, src0, src1, src1, mask, mask, src0, src1);
+    VSHF_B2_UB(src2, src2, src3, src3, mask, mask, src2, src3);
+    DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
+                coeff_vec, res0, res1, res2, res3);
+    SLLI_4V(res0, res1, res2, res3, 3);
+    SRARI_H4_UH(res0, res1, res2, res3, 6);
+    SAT_UH4_UH(res0, res1, res2, res3, 7);
+    PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
+    ST8x4_UB(out0, out1, dst, stride);
+}
+
+static void avc_chroma_hz_8x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coeff0, uint32_t coeff1)
+{
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16u8 out0, out1, out2, out3;
+    v8u16 res0, res1, res2, res3, res4, res5, res6, res7;
+    v16i8 mask;
+    v16i8 coeff_vec0 = __msa_fill_b(coeff0);
+    v16i8 coeff_vec1 = __msa_fill_b(coeff1);
+    v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
+
+    mask = LD_SB(&chroma_mask_arr[32]);
+
+    LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+    VSHF_B2_UB(src0, src0, src1, src1, mask, mask, src0, src1);
+    VSHF_B2_UB(src2, src2, src3, src3, mask, mask, src2, src3);
+    VSHF_B2_UB(src4, src4, src5, src5, mask, mask, src4, src5);
+    VSHF_B2_UB(src6, src6, src7, src7, mask, mask, src6, src7);
+    DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
+                coeff_vec, res0, res1, res2, res3);
+    DOTP_UB4_UH(src4, src5, src6, src7, coeff_vec, coeff_vec, coeff_vec,
+                coeff_vec, res4, res5, res6, res7);
+    SLLI_4V(res0, res1, res2, res3, 3);
+    SLLI_4V(res4, res5, res6, res7, 3);
+    SRARI_H4_UH(res0, res1, res2, res3, 6);
+    SRARI_H4_UH(res4, res5, res6, res7, 6);
+    SAT_UH4_UH(res0, res1, res2, res3, 7);
+    SAT_UH4_UH(res4, res5, res6, res7, 7);
+    PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
+    PCKEV_B2_UB(res5, res4, res7, res6, out2, out3);
+    ST8x8_UB(out0, out1, out2, out3, dst, stride);
+}
+
+static void avc_chroma_hz_nonmult_msa(uint8_t *src, uint8_t *dst,
+                                      int32_t stride, uint32_t coeff0,
+                                      uint32_t coeff1, int32_t height)
 {
     uint32_t row;
     v16u8 src0, src1, src2, src3, out0, out1;
@@ -233,8 +255,8 @@ static void avc_chroma_hz_8w_msa(uint8_t *src, int32_t src_stride,
     mask = LD_SB(&chroma_mask_arr[32]);
 
     for (row = height >> 2; row--;) {
-        LD_UB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
+        LD_UB4(src, stride, src0, src1, src2, src3);
+        src += (4 * stride);
 
         VSHF_B2_UB(src0, src0, src1, src1, mask, mask, src0, src1);
         VSHF_B2_UB(src2, src2, src3, src3, mask, mask, src2, src3);
@@ -244,14 +266,14 @@ static void avc_chroma_hz_8w_msa(uint8_t *src, int32_t src_stride,
         SRARI_H4_UH(res0, res1, res2, res3, 6);
         SAT_UH4_UH(res0, res1, res2, res3, 7);
         PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
-        ST8x4_UB(out0, out1, dst, dst_stride);
-        dst += (4 * dst_stride);
+        ST8x4_UB(out0, out1, dst, stride);
+        dst += (4 * stride);
     }
 
     if (0 != (height % 4)) {
         for (row = (height % 4); row--;) {
             src0 = LD_UB(src);
-            src += src_stride;
+            src += stride;
 
             src0 = (v16u8) __msa_vshf_b(mask, (v16i8) src0, (v16i8) src0);
 
@@ -262,13 +284,25 @@ static void avc_chroma_hz_8w_msa(uint8_t *src, int32_t src_stride,
             res0 = (v8u16) __msa_pckev_b((v16i8) res0, (v16i8) res0);
 
             ST8x1_UB(res0, dst);
-            dst += dst_stride;
+            dst += stride;
         }
     }
 }
 
-static void avc_chroma_vt_2x2_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_hz_8w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                 uint32_t coeff0, uint32_t coeff1,
+                                 int32_t height)
+{
+    if (4 == height) {
+        avc_chroma_hz_8x4_msa(src, dst, stride, coeff0, coeff1);
+    } else if (8 == height) {
+        avc_chroma_hz_8x8_msa(src, dst, stride, coeff0, coeff1);
+    } else {
+        avc_chroma_hz_nonmult_msa(src, dst, stride, coeff0, coeff1, height);
+    }
+}
+
+static void avc_chroma_vt_2x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                   uint32_t coeff0, uint32_t coeff1)
 {
     uint16_t out0, out1;
@@ -280,7 +314,7 @@ static void avc_chroma_vt_2x2_msa(uint8_t *src, int32_t src_stride,
     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 
-    LD_SB3(src, src_stride, src0, src1, src2);
+    LD_SB3(src, stride, src0, src1, src2);
 
     ILVR_B2_UB(src1, src0, src2, src1, tmp0, tmp1);
 
@@ -296,12 +330,11 @@ static void avc_chroma_vt_2x2_msa(uint8_t *src, int32_t src_stride,
     out1 = __msa_copy_u_h(res, 2);
 
     SH(out0, dst);
-    dst += dst_stride;
+    dst += stride;
     SH(out1, dst);
 }
 
-static void avc_chroma_vt_2x4_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_vt_2x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                   uint32_t coeff0, uint32_t coeff1)
 {
     v16u8 src0, src1, src2, src3, src4;
@@ -312,39 +345,7 @@ static void avc_chroma_vt_2x4_msa(uint8_t *src, int32_t src_stride,
     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 
-    LD_UB5(src, src_stride, src0, src1, src2, src3, src4);
-    ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3,
-               tmp0, tmp1, tmp2, tmp3);
-    ILVR_W2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
-
-    tmp0 = (v16u8) __msa_ilvr_d((v2i64) tmp2, (v2i64) tmp0);
-
-    res_r = __msa_dotp_u_h(tmp0, coeff_vec);
-    res_r <<= 3;
-    res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
-    res_r = __msa_sat_u_h(res_r, 7);
-
-    res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
-
-    ST2x4_UB(res, 0, dst, dst_stride);
-}
-
-static void avc_chroma_vt_2x8_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
-                                  uint32_t coeff0, uint32_t coeff1)
-{
-    v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
-    v16u8 tmp0, tmp1, tmp2, tmp3;
-    v8i16 res;
-    v8u16 res_r;
-    v16i8 coeff_vec0 = __msa_fill_b(coeff0);
-    v16i8 coeff_vec1 = __msa_fill_b(coeff1);
-    v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
-
-    LD_UB5(src, src_stride, src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-    LD_UB4(src, src_stride, src5, src6, src7, src8);
-
+    LD_UB5(src, stride, src0, src1, src2, src3, src4);
     ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3,
                tmp0, tmp1, tmp2, tmp3);
     ILVR_W2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
@@ -358,42 +359,21 @@ static void avc_chroma_vt_2x8_msa(uint8_t *src, int32_t src_stride,
 
     res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
 
-    ST2x4_UB(res, 0, dst, dst_stride);
-    dst += (4 * dst_stride);
-
-    ILVR_B4_UB(src5, src4, src6, src5, src7, src6, src8, src7,
-               tmp0, tmp1, tmp2, tmp3);
-    ILVR_W2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
-
-    tmp0 = (v16u8) __msa_ilvr_d((v2i64) tmp2, (v2i64) tmp0);
-
-    res_r = __msa_dotp_u_h(tmp0, coeff_vec);
-    res_r <<= 3;
-    res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
-    res_r = __msa_sat_u_h(res_r, 7);
-
-    res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
-
-    ST2x4_UB(res, 0, dst, dst_stride);
-    dst += (4 * dst_stride);
+    ST2x4_UB(res, 0, dst, stride);
 }
 
-static void avc_chroma_vt_2w_msa(uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_vt_2w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                  uint32_t coeff0, uint32_t coeff1,
                                  int32_t height)
 {
     if (2 == height) {
-        avc_chroma_vt_2x2_msa(src, src_stride, dst, dst_stride, coeff0, coeff1);
+        avc_chroma_vt_2x2_msa(src, dst, stride, coeff0, coeff1);
     } else if (4 == height) {
-        avc_chroma_vt_2x4_msa(src, src_stride, dst, dst_stride, coeff0, coeff1);
-    } else if (8 == height) {
-        avc_chroma_vt_2x8_msa(src, src_stride, dst, dst_stride, coeff0, coeff1);
+        avc_chroma_vt_2x4_msa(src, dst, stride, coeff0, coeff1);
     }
 }
 
-static void avc_chroma_vt_4x2_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_vt_4x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                   uint32_t coeff0, uint32_t coeff1)
 {
     v16u8 src0, src1, src2;
@@ -404,7 +384,7 @@ static void avc_chroma_vt_4x2_msa(uint8_t *src, int32_t src_stride,
     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 
-    LD_UB3(src, src_stride, src0, src1, src2);
+    LD_UB3(src, stride, src0, src1, src2);
     ILVR_B2_UB(src1, src0, src2, src1, tmp0, tmp1);
 
     tmp0 = (v16u8) __msa_ilvr_d((v2i64) tmp1, (v2i64) tmp0);
@@ -414,98 +394,139 @@ static void avc_chroma_vt_4x2_msa(uint8_t *src, int32_t src_stride,
     res_r = __msa_sat_u_h(res_r, 7);
     res = (v4i32) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
 
-    ST4x2_UB(res, dst, dst_stride);
+    ST4x2_UB(res, dst, stride);
 }
 
-static void avc_chroma_vt_4x4multiple_msa(uint8_t *src, int32_t src_stride,
-                                          uint8_t *dst, int32_t dst_stride,
-                                          uint32_t coeff0, uint32_t coeff1,
-                                          int32_t height)
+static void avc_chroma_vt_4x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coeff0, uint32_t coeff1)
 {
-    uint32_t row;
     v16u8 src0, src1, src2, src3, src4;
     v16u8 tmp0, tmp1, tmp2, tmp3;
+    v16u8 out;
     v8u16 res0_r, res1_r;
-    v4i32 res0, res1;
     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 
-    src0 = LD_UB(src);
-    src += src_stride;
-
-    for (row = (height >> 2); row--;) {
-        LD_UB4(src, src_stride, src1, src2, src3, src4);
-        src += (4 * src_stride);
-
-        ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3,
-                   tmp0, tmp1, tmp2, tmp3);
-        ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
-        DOTP_UB2_UH(tmp0, tmp2, coeff_vec, coeff_vec, res0_r, res1_r);
-
-        res0_r <<= 3;
-        res1_r <<= 3;
+    LD_UB5(src, stride, src0, src1, src2, src3, src4);
+    ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3, tmp0, tmp1, tmp2,
+               tmp3);
+    ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
+    DOTP_UB2_UH(tmp0, tmp2, coeff_vec, coeff_vec, res0_r, res1_r);
+    res0_r <<= 3;
+    res1_r <<= 3;
+    SRARI_H2_UH(res0_r, res1_r, 6);
+    SAT_UH2_UH(res0_r, res1_r, 7);
+    out = (v16u8) __msa_pckev_b((v16i8) res1_r, (v16i8) res0_r);
+    ST4x4_UB(out, out, 0, 1, 2, 3, dst, stride);
+}
 
-        SRARI_H2_UH(res0_r, res1_r, 6);
-        SAT_UH2_UH(res0_r, res1_r, 7);
-        PCKEV_B2_SW(res0_r, res0_r, res1_r, res1_r, res0, res1);
+static void avc_chroma_vt_4x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coeff0, uint32_t coeff1)
+{
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
+    v16u8 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, out0, out1;
+    v8u16 res0, res1, res2, res3;
+    v16i8 coeff_vec0 = __msa_fill_b(coeff0);
+    v16i8 coeff_vec1 = __msa_fill_b(coeff1);
+    v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 
-        ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
-        dst += (4 * dst_stride);
-        src0 = src4;
-    }
+    LD_UB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+    LD_UB4(src, stride, src5, src6, src7, src8);
+    ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3, tmp0, tmp1, tmp2,
+               tmp3);
+    ILVR_B4_UB(src5, src4, src6, src5, src7, src6, src8, src7, tmp4, tmp5, tmp6,
+               tmp7);
+    ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
+    ILVR_D2_UB(tmp5, tmp4, tmp7, tmp6, tmp4, tmp6);
+    DOTP_UB2_UH(tmp0, tmp2, coeff_vec, coeff_vec, res0, res1);
+    DOTP_UB2_UH(tmp4, tmp6, coeff_vec, coeff_vec, res2, res3);
+    SLLI_4V(res0, res1, res2, res3, 3);
+    SRARI_H4_UH(res0, res1, res2, res3, 6);
+    SAT_UH4_UH(res0, res1, res2, res3, 7);
+    PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
+    ST4x8_UB(out0, out1, dst, stride);
 }
 
-static void avc_chroma_vt_4w_msa(uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_vt_4w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                  uint32_t coeff0, uint32_t coeff1,
                                  int32_t height)
 {
     if (2 == height) {
-        avc_chroma_vt_4x2_msa(src, src_stride, dst, dst_stride, coeff0, coeff1);
-    } else {
-        avc_chroma_vt_4x4multiple_msa(src, src_stride, dst, dst_stride, coeff0,
-                                      coeff1, height);
+        avc_chroma_vt_4x2_msa(src, dst, stride, coeff0, coeff1);
+    } else if (4 == height) {
+        avc_chroma_vt_4x4_msa(src, dst, stride, coeff0, coeff1);
+    } else if (8 == height) {
+        avc_chroma_vt_4x8_msa(src, dst, stride, coeff0, coeff1);
     }
 }
 
-static void avc_chroma_vt_8w_msa(uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
-                                 uint32_t coeff0, uint32_t coeff1,
-                                 int32_t height)
+static void avc_chroma_vt_8x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coeff0, uint32_t coeff1)
 {
-    uint32_t row;
     v16u8 src0, src1, src2, src3, src4, out0, out1;
     v8u16 res0, res1, res2, res3;
     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 
-    src0 = LD_UB(src);
-    src += src_stride;
-
-    for (row = height >> 2; row--;) {
-        LD_UB4(src, src_stride, src1, src2, src3, src4);
-        src += (4 * src_stride);
+    LD_UB5(src, stride, src0, src1, src2, src3, src4);
+    ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3, src0, src1, src2,
+               src3);
+    DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
+                coeff_vec, res0, res1, res2, res3);
+    SLLI_4V(res0, res1, res2, res3, 3);
+    SRARI_H4_UH(res0, res1, res2, res3, 6);
+    SAT_UH4_UH(res0, res1, res2, res3, 7);
+    PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
+    ST8x4_UB(out0, out1, dst, stride);
+}
 
-        ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3,
-                   src0, src1, src2, src3);
-        DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
-                    coeff_vec, res0, res1, res2, res3);
-        SLLI_4V(res0, res1, res2, res3, 3);
-        SRARI_H4_UH(res0, res1, res2, res3, 6);
-        SAT_UH4_UH(res0, res1, res2, res3, 7);
-        PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
+static void avc_chroma_vt_8x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coeff0, uint32_t coeff1)
+{
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
+    v16u8 out0, out1, out2, out3;
+    v8u16 res0, res1, res2, res3, res4, res5, res6, res7;
+    v16i8 coeff_vec0 = __msa_fill_b(coeff0);
+    v16i8 coeff_vec1 = __msa_fill_b(coeff1);
+    v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 
-        ST8x4_UB(out0, out1, dst, dst_stride);
+    LD_UB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+    LD_UB4(src, stride, src5, src6, src7, src8);
+    ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3, src0, src1, src2,
+               src3);
+    ILVR_B4_UB(src5, src4, src6, src5, src7, src6, src8, src7, src4, src5, src6,
+               src7);
+    DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
+                coeff_vec, res0, res1, res2, res3);
+    DOTP_UB4_UH(src4, src5, src6, src7, coeff_vec, coeff_vec, coeff_vec,
+                coeff_vec, res4, res5, res6, res7);
+    SLLI_4V(res0, res1, res2, res3, 3);
+    SLLI_4V(res4, res5, res6, res7, 3);
+    SRARI_H4_UH(res0, res1, res2, res3, 6);
+    SRARI_H4_UH(res4, res5, res6, res7, 6);
+    SAT_UH4_UH(res0, res1, res2, res3, 7);
+    SAT_UH4_UH(res0, res1, res2, res3, 7);
+    PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
+    PCKEV_B2_UB(res5, res4, res7, res6, out2, out3);
+    ST8x8_UB(out0, out1, out2, out3, dst, stride);
+}
 
-        dst += (4 * dst_stride);
-        src0 = src4;
+static void avc_chroma_vt_8w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                 uint32_t coeff0, uint32_t coeff1,
+                                 int32_t height)
+{
+    if (4 == height) {
+        avc_chroma_vt_8x4_msa(src, dst, stride, coeff0, coeff1);
+    } else if (8 == height) {
+        avc_chroma_vt_8x8_msa(src, dst, stride, coeff0, coeff1);
     }
 }
 
-static void avc_chroma_hv_2x2_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_hv_2x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                   uint32_t coef_hor0, uint32_t coef_hor1,
                                   uint32_t coef_ver0, uint32_t coef_ver1)
 {
@@ -522,7 +543,7 @@ static void avc_chroma_hv_2x2_msa(uint8_t *src, int32_t src_stride,
 
     mask = LD_SB(&chroma_mask_arr[48]);
 
-    LD_UB3(src, src_stride, src0, src1, src2);
+    LD_UB3(src, stride, src0, src1, src2);
     VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
     DOTP_UB2_UH(src0, src1, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
     MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
@@ -536,12 +557,11 @@ static void avc_chroma_hv_2x2_msa(uint8_t *src, int32_t src_stride,
     out1 = __msa_copy_u_h(res_vert, 1);
 
     SH(out0, dst);
-    dst += dst_stride;
+    dst += stride;
     SH(out1, dst);
 }
 
-static void avc_chroma_hv_2x4_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_hv_2x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                   uint32_t coef_hor0, uint32_t coef_hor1,
                                   uint32_t coef_ver0, uint32_t coef_ver1)
 {
@@ -558,7 +578,7 @@ static void avc_chroma_hv_2x4_msa(uint8_t *src, int32_t src_stride,
 
     mask = LD_SB(&chroma_mask_arr[48]);
 
-    LD_UB5(src, src_stride, src0, src1, src2, src3, src4);
+    LD_UB5(src, stride, src0, src1, src2, src3, src4);
 
     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, tmp0, tmp1);
     VSHF_B2_UB(src1, src2, src3, src4, mask, mask, tmp2, tmp3);
@@ -566,86 +586,30 @@ static void avc_chroma_hv_2x4_msa(uint8_t *src, int32_t src_stride,
     DOTP_UB2_UH(src0, src1, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
     MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
 
-    res_vt0 += res_vt1;
-    res_vt0 = (v8u16) __msa_srari_h((v8i16) res_vt0, 6);
-    res_vt0 = __msa_sat_u_h(res_vt0, 7);
-    res = (v8i16) __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
-
-    ST2x4_UB(res, 0, dst, dst_stride);
-}
-
-static void avc_chroma_hv_2x8_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
-                                  uint32_t coef_hor0, uint32_t coef_hor1,
-                                  uint32_t coef_ver0, uint32_t coef_ver1)
-{
-    v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
-    v16u8 tmp0, tmp1, tmp2, tmp3;
-    v8u16 res_hz0, res_hz1, res_vt0, res_vt1;
-    v8i16 res;
-    v16i8 mask;
-    v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
-    v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
-    v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
-    v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
-    v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
-
-    mask = LD_SB(&chroma_mask_arr[48]);
-
-    LD_UB5(src, src_stride, src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-    LD_UB4(src, src_stride, src5, src6, src7, src8);
-
-    VSHF_B2_UB(src0, src1, src2, src3, mask, mask, tmp0, tmp1);
-    VSHF_B2_UB(src1, src2, src3, src4, mask, mask, tmp2, tmp3);
-    ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, src0, src1);
-    VSHF_B2_UB(src4, src5, src6, src7, mask, mask, tmp0, tmp1);
-    VSHF_B2_UB(src5, src6, src7, src8, mask, mask, tmp2, tmp3);
-    ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, src4, src5);
-    DOTP_UB2_UH(src0, src1, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
-    MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
-
-    res_vt0 += res_vt1;
-    res_vt0 = (v8u16) __msa_srari_h((v8i16) res_vt0, 6);
-    res_vt0 = __msa_sat_u_h(res_vt0, 7);
-
-    res = (v8i16) __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
-
-    ST2x4_UB(res, 0, dst, dst_stride);
-    dst += (4 * dst_stride);
-
-    DOTP_UB2_UH(src4, src5, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
-    MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
-
     res_vt0 += res_vt1;
     res_vt0 = (v8u16) __msa_srari_h((v8i16) res_vt0, 6);
     res_vt0 = __msa_sat_u_h(res_vt0, 7);
 
     res = (v8i16) __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
 
-    ST2x4_UB(res, 0, dst, dst_stride);
+    ST2x4_UB(res, 0, dst, stride);
 }
 
-static void avc_chroma_hv_2w_msa(uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_hv_2w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                  uint32_t coef_hor0, uint32_t coef_hor1,
                                  uint32_t coef_ver0, uint32_t coef_ver1,
                                  int32_t height)
 {
     if (2 == height) {
-        avc_chroma_hv_2x2_msa(src, src_stride, dst, dst_stride, coef_hor0,
-                              coef_hor1, coef_ver0, coef_ver1);
+        avc_chroma_hv_2x2_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
+                              coef_ver1);
     } else if (4 == height) {
-        avc_chroma_hv_2x4_msa(src, src_stride, dst, dst_stride, coef_hor0,
-                              coef_hor1, coef_ver0, coef_ver1);
-    } else if (8 == height) {
-        avc_chroma_hv_2x8_msa(src, src_stride, dst, dst_stride, coef_hor0,
-                              coef_hor1, coef_ver0, coef_ver1);
+        avc_chroma_hv_2x4_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
+                              coef_ver1);
     }
 }
 
-static void avc_chroma_hv_4x2_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_hv_4x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                   uint32_t coef_hor0, uint32_t coef_hor1,
                                   uint32_t coef_ver0, uint32_t coef_ver1)
 {
@@ -660,7 +624,7 @@ static void avc_chroma_hv_4x2_msa(uint8_t *src, int32_t src_stride,
     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
 
     mask = LD_SB(&chroma_mask_arr[0]);
-    LD_UB3(src, src_stride, src0, src1, src2);
+    LD_UB3(src, stride, src0, src1, src2);
     VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
     DOTP_UB2_UH(src0, src1, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
     MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
@@ -670,18 +634,13 @@ static void avc_chroma_hv_4x2_msa(uint8_t *src, int32_t src_stride,
     res_vt0 = __msa_sat_u_h(res_vt0, 7);
     res = (v4i32) __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
 
-    ST4x2_UB(res, dst, dst_stride);
+    ST4x2_UB(res, dst, stride);
 }
 
-static void avc_chroma_hv_4x4multiple_msa(uint8_t *src, int32_t src_stride,
-                                          uint8_t *dst, int32_t dst_stride,
-                                          uint32_t coef_hor0,
-                                          uint32_t coef_hor1,
-                                          uint32_t coef_ver0,
-                                          uint32_t coef_ver1,
-                                          int32_t height)
+static void avc_chroma_hv_4x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coef_hor0, uint32_t coef_hor1,
+                                  uint32_t coef_ver0, uint32_t coef_ver1)
 {
-    uint32_t row;
     v16u8 src0, src1, src2, src3, src4;
     v8u16 res_hz0, res_hz1, res_hz2, res_hz3;
     v8u16 res_vt0, res_vt1, res_vt2, res_vt3;
@@ -695,55 +654,82 @@ static void avc_chroma_hv_4x4multiple_msa(uint8_t *src, int32_t src_stride,
 
     mask = LD_SB(&chroma_mask_arr[0]);
 
-    src0 = LD_UB(src);
-    src += src_stride;
+    LD_UB5(src, stride, src0, src1, src2, src3, src4);
+    VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
+    VSHF_B2_UB(src2, src3, src3, src4, mask, mask, src2, src3);
+    DOTP_UB4_UH(src0, src1, src2, src3, coeff_hz_vec, coeff_hz_vec,
+                coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1, res_hz2,
+                res_hz3);
+    MUL4(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_hz2, coeff_vt_vec1,
+         res_hz3, coeff_vt_vec0, res_vt0, res_vt1, res_vt2, res_vt3);
+    ADD2(res_vt0, res_vt1, res_vt2, res_vt3, res_vt0, res_vt1);
+    SRARI_H2_UH(res_vt0, res_vt1, 6);
+    SAT_UH2_UH(res_vt0, res_vt1, 7);
+    PCKEV_B2_SW(res_vt0, res_vt0, res_vt1, res_vt1, res0, res1);
+    ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, stride);
+}
 
-    for (row = (height >> 2); row--;) {
-        LD_UB4(src, src_stride, src1, src2, src3, src4);
-        src += (4 * src_stride);
+static void avc_chroma_hv_4x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coef_hor0, uint32_t coef_hor1,
+                                  uint32_t coef_ver0, uint32_t coef_ver1)
+{
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, res0, res1;
+    v8u16 res_hz0, res_hz1, res_hz2, res_hz3, res_hz4, res_hz5, res_hz6, res_hz7;
+    v8u16 res_vt0, res_vt1, res_vt2, res_vt3, res_vt4, res_vt5, res_vt6, res_vt7;
+    v16i8 mask;
+    v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
+    v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
+    v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
+    v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
+    v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
 
-        VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
-        VSHF_B2_UB(src2, src3, src3, src4, mask, mask, src2, src3);
-        DOTP_UB4_UH(src0, src1, src2, src3, coeff_hz_vec, coeff_hz_vec,
-                    coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1, res_hz2,
-                    res_hz3);
-        MUL4(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_hz2,
-             coeff_vt_vec1, res_hz3, coeff_vt_vec0, res_vt0, res_vt1, res_vt2,
-             res_vt3);
-        ADD2(res_vt0, res_vt1, res_vt2, res_vt3, res_vt0, res_vt1);
-        SRARI_H2_UH(res_vt0, res_vt1, 6);
-        SAT_UH2_UH(res_vt0, res_vt1, 7);
-        PCKEV_B2_SW(res_vt0, res_vt0, res_vt1, res_vt1, res0, res1);
+    mask = LD_SB(&chroma_mask_arr[0]);
 
-        ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
-        dst += (4 * dst_stride);
-        src0 = src4;
-    }
+    LD_UB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+    LD_UB4(src, stride, src5, src6, src7, src8);
+
+    VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
+    VSHF_B2_UB(src2, src3, src3, src4, mask, mask, src2, src3);
+    VSHF_B2_UB(src4, src5, src5, src6, mask, mask, src4, src5);
+    VSHF_B2_UB(src6, src7, src7, src8, mask, mask, src6, src7);
+    DOTP_UB4_UH(src0, src1, src2, src3, coeff_hz_vec, coeff_hz_vec,
+                coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1, res_hz2, res_hz3);
+    DOTP_UB4_UH(src4, src5, src6, src7, coeff_hz_vec, coeff_hz_vec,
+                coeff_hz_vec, coeff_hz_vec, res_hz4, res_hz5, res_hz6, res_hz7);
+    MUL4(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_hz2, coeff_vt_vec1,
+         res_hz3, coeff_vt_vec0, res_vt0, res_vt1, res_vt2, res_vt3);
+    MUL4(res_hz4, coeff_vt_vec1, res_hz5, coeff_vt_vec0, res_hz6, coeff_vt_vec1,
+         res_hz7, coeff_vt_vec0, res_vt4, res_vt5, res_vt6, res_vt7);
+    ADD2(res_vt0, res_vt1, res_vt2, res_vt3, res_vt0, res_vt1);
+    ADD2(res_vt4, res_vt5, res_vt6, res_vt7, res_vt2, res_vt3);
+    SRARI_H4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 6);
+    SAT_UH4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 7);
+    PCKEV_B2_UB(res_vt1, res_vt0, res_vt3, res_vt2, res0, res1);
+    ST4x8_UB(res0, res1, dst, stride);
 }
 
-static void avc_chroma_hv_4w_msa(uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
+static void avc_chroma_hv_4w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                                  uint32_t coef_hor0, uint32_t coef_hor1,
                                  uint32_t coef_ver0, uint32_t coef_ver1,
                                  int32_t height)
 {
     if (2 == height) {
-        avc_chroma_hv_4x2_msa(src, src_stride, dst, dst_stride, coef_hor0,
-                              coef_hor1, coef_ver0, coef_ver1);
-    } else {
-        avc_chroma_hv_4x4multiple_msa(src, src_stride, dst, dst_stride,
-                                      coef_hor0, coef_hor1, coef_ver0,
-                                      coef_ver1, height);
+        avc_chroma_hv_4x2_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
+                              coef_ver1);
+    } else if (4 == height) {
+        avc_chroma_hv_4x4_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
+                              coef_ver1);
+    } else if (8 == height) {
+        avc_chroma_hv_4x8_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
+                              coef_ver1);
     }
 }
 
-static void avc_chroma_hv_8w_msa(uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
-                                 uint32_t coef_hor0, uint32_t coef_hor1,
-                                 uint32_t coef_ver0, uint32_t coef_ver1,
-                                 int32_t height)
+static void avc_chroma_hv_8x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coef_hor0, uint32_t coef_hor1,
+                                  uint32_t coef_ver0, uint32_t coef_ver1)
 {
-    uint32_t row;
     v16u8 src0, src1, src2, src3, src4, out0, out1;
     v8u16 res_hz0, res_hz1, res_hz2, res_hz3, res_hz4;
     v8u16 res_vt0, res_vt1, res_vt2, res_vt3;
@@ -757,37 +743,99 @@ static void avc_chroma_hv_8w_msa(uint8_t *src, int32_t src_stride,
     mask = LD_SB(&chroma_mask_arr[32]);
 
     src0 = LD_UB(src);
-    src += src_stride;
+    src += stride;
 
     src0 = (v16u8) __msa_vshf_b(mask, (v16i8) src0, (v16i8) src0);
     res_hz0 = __msa_dotp_u_h(src0, coeff_hz_vec);
 
-    for (row = (height >> 2); row--;) {
-        LD_UB4(src, src_stride, src1, src2, src3, src4);
-        src += (4 * src_stride);
-
-        VSHF_B2_UB(src1, src1, src2, src2, mask, mask, src1, src2);
-        VSHF_B2_UB(src3, src3, src4, src4, mask, mask, src3, src4);
-        DOTP_UB4_UH(src1, src2, src3, src4, coeff_hz_vec, coeff_hz_vec,
-                    coeff_hz_vec, coeff_hz_vec, res_hz1, res_hz2, res_hz3,
-                    res_hz4);
-        MUL4(res_hz1, coeff_vt_vec0, res_hz2, coeff_vt_vec0, res_hz3,
-             coeff_vt_vec0, res_hz4, coeff_vt_vec0, res_vt0, res_vt1, res_vt2,
-             res_vt3);
+    LD_UB4(src, stride, src1, src2, src3, src4);
+    src += (4 * stride);
+
+    VSHF_B2_UB(src1, src1, src2, src2, mask, mask, src1, src2);
+    VSHF_B2_UB(src3, src3, src4, src4, mask, mask, src3, src4);
+    DOTP_UB4_UH(src1, src2, src3, src4, coeff_hz_vec, coeff_hz_vec,
+                coeff_hz_vec, coeff_hz_vec, res_hz1, res_hz2, res_hz3, res_hz4);
+    MUL4(res_hz1, coeff_vt_vec0, res_hz2, coeff_vt_vec0, res_hz3, coeff_vt_vec0,
+         res_hz4, coeff_vt_vec0, res_vt0, res_vt1, res_vt2, res_vt3);
+
+    res_vt0 += (res_hz0 * coeff_vt_vec1);
+    res_vt1 += (res_hz1 * coeff_vt_vec1);
+    res_vt2 += (res_hz2 * coeff_vt_vec1);
+    res_vt3 += (res_hz3 * coeff_vt_vec1);
+
+    SRARI_H4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 6);
+    SAT_UH4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 7);
+    PCKEV_B2_UB(res_vt1, res_vt0, res_vt3, res_vt2, out0, out1);
+    ST8x4_UB(out0, out1, dst, stride);
+}
 
-        res_vt0 += (res_hz0 * coeff_vt_vec1);
-        res_vt1 += (res_hz1 * coeff_vt_vec1);
-        res_vt2 += (res_hz2 * coeff_vt_vec1);
-        res_vt3 += (res_hz3 * coeff_vt_vec1);
+static void avc_chroma_hv_8x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                  uint32_t coef_hor0, uint32_t coef_hor1,
+                                  uint32_t coef_ver0, uint32_t coef_ver1)
+{
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
+    v16u8 out0, out1, out2, out3;
+    v8u16 res_hz0, res_hz1, res_hz2, res_hz3, res_hz4;
+    v8u16 res_hz5, res_hz6, res_hz7, res_hz8;
+    v8u16 res_vt0, res_vt1, res_vt2, res_vt3;
+    v8u16 res_vt4, res_vt5, res_vt6, res_vt7;
+    v16i8 mask;
+    v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
+    v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
+    v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
+    v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
+    v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
 
-        SRARI_H4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 6);
-        SAT_UH4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 7);
-        PCKEV_B2_UB(res_vt1, res_vt0, res_vt3, res_vt2, out0, out1);
-        ST8x4_UB(out0, out1, dst, dst_stride);
+    mask = LD_SB(&chroma_mask_arr[32]);
 
-        dst += (4 * dst_stride);
+    LD_UB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+    LD_UB4(src, stride, src5, src6, src7, src8);
+    src0 = (v16u8) __msa_vshf_b(mask, (v16i8) src0, (v16i8) src0);
+    VSHF_B2_UB(src1, src1, src2, src2, mask, mask, src1, src2);
+    VSHF_B2_UB(src3, src3, src4, src4, mask, mask, src3, src4);
+    VSHF_B2_UB(src5, src5, src6, src6, mask, mask, src5, src6);
+    VSHF_B2_UB(src7, src7, src8, src8, mask, mask, src7, src8);
+    res_hz0 = __msa_dotp_u_h(src0, coeff_hz_vec);
+    DOTP_UB4_UH(src1, src2, src3, src4, coeff_hz_vec, coeff_hz_vec,
+                coeff_hz_vec, coeff_hz_vec, res_hz1, res_hz2, res_hz3,
+                res_hz4);
+    DOTP_UB4_UH(src5, src6, src7, src8, coeff_hz_vec, coeff_hz_vec,
+                coeff_hz_vec, coeff_hz_vec, res_hz5, res_hz6, res_hz7, res_hz8);
+    MUL4(res_hz1, coeff_vt_vec0, res_hz2, coeff_vt_vec0, res_hz3,
+         coeff_vt_vec0, res_hz4, coeff_vt_vec0, res_vt0, res_vt1, res_vt2,
+         res_vt3);
+    MUL4(res_hz5, coeff_vt_vec0, res_hz6, coeff_vt_vec0, res_hz7,
+         coeff_vt_vec0, res_hz8, coeff_vt_vec0, res_vt4, res_vt5, res_vt6,
+         res_vt7);
+    res_vt0 += (res_hz0 * coeff_vt_vec1);
+    res_vt1 += (res_hz1 * coeff_vt_vec1);
+    res_vt2 += (res_hz2 * coeff_vt_vec1);
+    res_vt3 += (res_hz3 * coeff_vt_vec1);
+    res_vt4 += (res_hz4 * coeff_vt_vec1);
+    res_vt5 += (res_hz5 * coeff_vt_vec1);
+    res_vt6 += (res_hz6 * coeff_vt_vec1);
+    res_vt7 += (res_hz7 * coeff_vt_vec1);
+    SRARI_H4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 6);
+    SRARI_H4_UH(res_vt4, res_vt5, res_vt6, res_vt7, 6);
+    SAT_UH4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 7);
+    SAT_UH4_UH(res_vt4, res_vt5, res_vt6, res_vt7, 7);
+    PCKEV_B2_UB(res_vt1, res_vt0, res_vt3, res_vt2, out0, out1);
+    PCKEV_B2_UB(res_vt5, res_vt4, res_vt7, res_vt6, out2, out3);
+    ST8x8_UB(out0, out1, out2, out3, dst, stride);
+}
 
-        res_hz0 = res_hz4;
+static void avc_chroma_hv_8w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                                 uint32_t coef_hor0, uint32_t coef_hor1,
+                                 uint32_t coef_ver0, uint32_t coef_ver1,
+                                 int32_t height)
+{
+    if (4 == height) {
+        avc_chroma_hv_8x4_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
+                              coef_ver1);
+    } else if (8 == height) {
+        avc_chroma_hv_8x8_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
+                              coef_ver1);
     }
 }
 
@@ -1869,36 +1917,34 @@ static void avg_width8_msa(uint8_t *src, int32_t src_stride,
 }
 
 void ff_put_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src,
-                                int stride, int height, int x, int y)
+                                ptrdiff_t stride, int height, int x, int y)
 {
     av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
 
     if (x && y) {
-        avc_chroma_hv_8w_msa(src, stride, dst,
-                             stride, x, (8 - x), y, (8 - y), height);
+        avc_chroma_hv_8w_msa(src, dst, stride, x, (8 - x), y, (8 - y), height);
     } else if (x) {
-        avc_chroma_hz_8w_msa(src, stride, dst, stride, x, (8 - x), height);
+        avc_chroma_hz_8w_msa(src, dst, stride, x, (8 - x), height);
     } else if (y) {
-        avc_chroma_vt_8w_msa(src, stride, dst, stride, y, (8 - y), height);
+        avc_chroma_vt_8w_msa(src, dst, stride, y, (8 - y), height);
     } else {
         copy_width8_msa(src, stride, dst, stride, height);
     }
 }
 
 void ff_put_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src,
-                                int stride, int height, int x, int y)
+                                ptrdiff_t stride, int height, int x, int y)
 {
     int32_t cnt;
 
     av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
 
     if (x && y) {
-        avc_chroma_hv_4w_msa(src, stride, dst,
-                             stride, x, (8 - x), y, (8 - y), height);
+        avc_chroma_hv_4w_msa(src, dst, stride, x, (8 - x), y, (8 - y), height);
     } else if (x) {
-        avc_chroma_hz_4w_msa(src, stride, dst, stride, x, (8 - x), height);
+        avc_chroma_hz_4w_msa(src, dst, stride, x, (8 - x), height);
     } else if (y) {
-        avc_chroma_vt_4w_msa(src, stride, dst, stride, y, (8 - y), height);
+        avc_chroma_vt_4w_msa(src, dst, stride, y, (8 - y), height);
     } else {
         for (cnt = height; cnt--;) {
             *((uint32_t *) dst) = *((uint32_t *) src);
@@ -1910,19 +1956,18 @@ void ff_put_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src,
 }
 
 void ff_put_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src,
-                                int stride, int height, int x, int y)
+                                ptrdiff_t stride, int height, int x, int y)
 {
     int32_t cnt;
 
     av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
 
     if (x && y) {
-        avc_chroma_hv_2w_msa(src, stride, dst,
-                             stride, x, (8 - x), y, (8 - y), height);
+        avc_chroma_hv_2w_msa(src, dst, stride, x, (8 - x), y, (8 - y), height);
     } else if (x) {
-        avc_chroma_hz_2w_msa(src, stride, dst, stride, x, (8 - x), height);
+        avc_chroma_hz_2w_msa(src, dst, stride, x, (8 - x), height);
     } else if (y) {
-        avc_chroma_vt_2w_msa(src, stride, dst, stride, y, (8 - y), height);
+        avc_chroma_vt_2w_msa(src, dst, stride, y, (8 - y), height);
     } else {
         for (cnt = height; cnt--;) {
             *((uint16_t *) dst) = *((uint16_t *) src);
@@ -1934,7 +1979,7 @@ void ff_put_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src,
 }
 
 void ff_avg_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src,
-                                int stride, int height, int x, int y)
+                                ptrdiff_t stride, int height, int x, int y)
 {
     av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
 
@@ -1955,7 +2000,7 @@ void ff_avg_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src,
 }
 
 void ff_avg_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src,
-                                int stride, int height, int x, int y)
+                                ptrdiff_t stride, int height, int x, int y)
 {
     av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
 
@@ -1975,7 +2020,7 @@ void ff_avg_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src,
 }
 
 void ff_avg_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src,
-                                int stride, int height, int x, int y)
+                                ptrdiff_t stride, int height, int x, int y)
 {
     int32_t cnt;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/h264dsp_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/h264dsp_msa.c
index 16e4858e6b5..e50f5ca0a4f 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/h264dsp_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/h264dsp_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Parag Salasakar (Parag.Salasakar@imgtec.com)
+ * Copyright (c) 2015 - 2017 Parag Salasakar (Parag.Salasakar@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -25,401 +25,440 @@ static void avc_wgt_4x2_msa(uint8_t *data, int32_t stride,
                             int32_t log2_denom, int32_t src_weight,
                             int32_t offset_in)
 {
-    uint32_t data0, data1;
+    uint32_t tp0, tp1, offset_val;
     v16u8 zero = { 0 };
-    v16u8 src0, src1;
-    v4i32 res0, res1;
-    v8i16 temp0, temp1, vec0, vec1, wgt, denom, offset;
-    v8u16 out0, out1;
+    v16u8 src0 = { 0 };
+    v8i16 src0_r, tmp0, wgt, denom, offset;
 
-    offset_in <<= (log2_denom);
-
-    if (log2_denom) {
-        offset_in += (1 << (log2_denom - 1));
-    }
+    offset_val = (unsigned) offset_in << log2_denom;
 
     wgt = __msa_fill_h(src_weight);
-    offset = __msa_fill_h(offset_in);
+    offset = __msa_fill_h(offset_val);
     denom = __msa_fill_h(log2_denom);
 
-    data0 = LW(data);
-    data1 = LW(data + stride);
-
-    src0 = (v16u8) __msa_fill_w(data0);
-    src1 = (v16u8) __msa_fill_w(data1);
+    LW2(data, stride, tp0, tp1);
+    INSERT_W2_UB(tp0, tp1, src0);
+    src0_r = (v8i16) __msa_ilvr_b((v16i8) zero, (v16i8) src0);
+    tmp0 = wgt * src0_r;
+    tmp0 = __msa_adds_s_h(tmp0, offset);
+    tmp0 = __msa_maxi_s_h(tmp0, 0);
+    tmp0 = __msa_srlr_h(tmp0, denom);
+    tmp0 = (v8i16) __msa_sat_u_h((v8u16) tmp0, 7);
+    src0 = (v16u8) __msa_pckev_b((v16i8) tmp0, (v16i8) tmp0);
+    ST4x2_UB(src0, data, stride);
+}
 
-    ILVR_B2_SH(zero, src0, zero, src1, vec0, vec1);
-    MUL2(wgt, vec0, wgt, vec1, temp0, temp1);
-    ADDS_SH2_SH(temp0, offset, temp1, offset, temp0, temp1);
-    MAXI_SH2_SH(temp0, temp1, 0);
+static void avc_wgt_4x4_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
+                            int32_t src_weight, int32_t offset_in)
+{
+    uint32_t tp0, tp1, tp2, tp3, offset_val;
+    v16u8 src0 = { 0 };
+    v8i16 src0_r, src1_r, tmp0, tmp1, wgt, denom, offset;
 
-    out0 = (v8u16) __msa_srl_h(temp0, denom);
-    out1 = (v8u16) __msa_srl_h(temp1, denom);
+    offset_val = (unsigned) offset_in << log2_denom;
 
-    SAT_UH2_UH(out0, out1, 7);
-    PCKEV_B2_SW(out0, out0, out1, out1, res0, res1);
+    wgt = __msa_fill_h(src_weight);
+    offset = __msa_fill_h(offset_val);
+    denom = __msa_fill_h(log2_denom);
 
-    data0 = __msa_copy_u_w(res0, 0);
-    data1 = __msa_copy_u_w(res1, 0);
-    SW(data0, data);
-    data += stride;
-    SW(data1, data);
+    LW4(data, stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
+    UNPCK_UB_SH(src0, src0_r, src1_r);
+    MUL2(wgt, src0_r, wgt, src1_r, tmp0, tmp1);
+    ADDS_SH2_SH(tmp0, offset, tmp1, offset, tmp0, tmp1);
+    MAXI_SH2_SH(tmp0, tmp1, 0);
+    tmp0 = __msa_srlr_h(tmp0, denom);
+    tmp1 = __msa_srlr_h(tmp1, denom);
+    SAT_UH2_SH(tmp0, tmp1, 7);
+    src0 = (v16u8) __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
+    ST4x4_UB(src0, src0, 0, 1, 2, 3, data, stride);
 }
 
-static void avc_wgt_4x4multiple_msa(uint8_t *data, int32_t stride,
-                                    int32_t height, int32_t log2_denom,
-                                    int32_t src_weight, int32_t offset_in)
+static void avc_wgt_4x8_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
+                            int32_t src_weight, int32_t offset_in)
 {
-    uint8_t cnt;
-    uint32_t data0, data1, data2, data3;
-    v16u8 zero = { 0 };
-    v16u8 src0, src1, src2, src3;
-    v8u16 temp0, temp1, temp2, temp3, wgt;
-    v8i16 denom, offset;
-
-    offset_in <<= (log2_denom);
+    uint32_t tp0, tp1, tp2, tp3, offset_val;
+    v16u8 src0 = { 0 }, src1 = { 0 };
+    v8i16 src0_r, src1_r, src2_r, src3_r, tmp0, tmp1, tmp2, tmp3;
+    v8i16 wgt, denom, offset;
 
-    if (log2_denom) {
-        offset_in += (1 << (log2_denom - 1));
-    }
+    offset_val = (unsigned) offset_in << log2_denom;
 
-    wgt = (v8u16) __msa_fill_h(src_weight);
-    offset = __msa_fill_h(offset_in);
+    wgt = __msa_fill_h(src_weight);
+    offset = __msa_fill_h(offset_val);
     denom = __msa_fill_h(log2_denom);
 
-    for (cnt = height / 4; cnt--;) {
-        LW4(data, stride, data0, data1, data2, data3);
-
-        src0 = (v16u8) __msa_fill_w(data0);
-        src1 = (v16u8) __msa_fill_w(data1);
-        src2 = (v16u8) __msa_fill_w(data2);
-        src3 = (v16u8) __msa_fill_w(data3);
-
-        ILVR_B4_UH(zero, src0, zero, src1, zero, src2, zero, src3,
-                   temp0, temp1, temp2, temp3);
-        MUL4(wgt, temp0, wgt, temp1, wgt, temp2, wgt, temp3,
-             temp0, temp1, temp2, temp3);
-        ADDS_SH4_UH(temp0, offset, temp1, offset, temp2, offset, temp3, offset,
-                    temp0, temp1, temp2, temp3);
-        MAXI_SH4_UH(temp0, temp1, temp2, temp3, 0);
-        SRL_H4_UH(temp0, temp1, temp2, temp3, denom);
-        SAT_UH4_UH(temp0, temp1, temp2, temp3, 7);
-        PCKEV_ST4x4_UB(temp0, temp1, temp2, temp3, data, stride);
-        data += (4 * stride);
-    }
+    LW4(data, stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
+    LW4(data + 4 * stride, stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, src1);
+    UNPCK_UB_SH(src0, src0_r, src1_r);
+    UNPCK_UB_SH(src1, src2_r, src3_r);
+    MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1, tmp2,
+         tmp3);
+    ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
+                tmp1, tmp2, tmp3);
+    MAXI_SH4_SH(tmp0, tmp1, tmp2, tmp3, 0);
+    SRLR_H4_SH(tmp0, tmp1, tmp2, tmp3, denom);
+    SAT_UH4_SH(tmp0, tmp1, tmp2, tmp3, 7);
+    PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, src0, src1);
+    ST4x8_UB(src0, src1, data, stride);
 }
 
-static void avc_wgt_4width_msa(uint8_t *data, int32_t stride,
-                               int32_t height, int32_t log2_denom,
-                               int32_t src_weight, int32_t offset_in)
+static void avc_wgt_8x4_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
+                            int32_t src_weight, int32_t offset_in)
 {
-    if (2 == height) {
-        avc_wgt_4x2_msa(data, stride, log2_denom, src_weight, offset_in);
-    } else {
-        avc_wgt_4x4multiple_msa(data, stride, height, log2_denom, src_weight,
-                                offset_in);
-    }
+    uint32_t offset_val;
+    uint64_t tp0, tp1, tp2, tp3;
+    v16u8 src0 = { 0 }, src1 = { 0 };
+    v8i16 src0_r, src1_r, src2_r, src3_r, tmp0, tmp1, tmp2, tmp3;
+    v8i16 wgt, denom, offset;
+
+    offset_val = (unsigned) offset_in << log2_denom;
+
+    wgt = __msa_fill_h(src_weight);
+    offset = __msa_fill_h(offset_val);
+    denom = __msa_fill_h(log2_denom);
+
+    LD4(data, stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, src0);
+    INSERT_D2_UB(tp2, tp3, src1);
+    UNPCK_UB_SH(src0, src0_r, src1_r);
+    UNPCK_UB_SH(src1, src2_r, src3_r);
+    MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1, tmp2,
+         tmp3);
+    ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
+                tmp1, tmp2, tmp3);
+    MAXI_SH4_SH(tmp0, tmp1, tmp2, tmp3, 0);
+    SRLR_H4_SH(tmp0, tmp1, tmp2, tmp3, denom);
+    SAT_UH4_SH(tmp0, tmp1, tmp2, tmp3, 7);
+    PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, src0, src1);
+    ST8x4_UB(src0, src1, data, stride);
 }
 
-static void avc_wgt_8width_msa(uint8_t *data, int32_t stride,
-                               int32_t height, int32_t log2_denom,
-                               int32_t src_weight, int32_t offset_in)
+static void avc_wgt_8x8_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
+                            int32_t src_weight, int32_t offset_in)
 {
-    uint8_t cnt;
-    v16u8 zero = { 0 };
-    v16u8 src0, src1, src2, src3;
-    v8u16 src0_r, src1_r, src2_r, src3_r;
-    v8u16 temp0, temp1, temp2, temp3;
-    v8u16 wgt, denom, offset;
-    v16i8 out0, out1;
+    uint32_t offset_val;
+    uint64_t tp0, tp1, tp2, tp3;
+    v16u8 src0 = { 0 }, src1 = { 0 }, src2 = { 0 }, src3 = { 0 };
+    v8i16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
+    v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+    v8i16 wgt, denom, offset;
 
-    offset_in <<= (log2_denom);
+    offset_val = (unsigned) offset_in << log2_denom;
 
-    if (log2_denom) {
-        offset_in += (1 << (log2_denom - 1));
-    }
+    wgt = __msa_fill_h(src_weight);
+    offset = __msa_fill_h(offset_val);
+    denom = __msa_fill_h(log2_denom);
 
-    wgt = (v8u16) __msa_fill_h(src_weight);
-    offset = (v8u16) __msa_fill_h(offset_in);
-    denom = (v8u16) __msa_fill_h(log2_denom);
-
-    for (cnt = height / 4; cnt--;) {
-        LD_UB4(data, stride, src0, src1, src2, src3);
-        ILVR_B4_UH(zero, src0, zero, src1, zero, src2, zero, src3,
-                   src0_r, src1_r, src2_r, src3_r);
-        MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r,
-             temp0, temp1, temp2, temp3);
-        ADDS_SH4_UH(temp0, offset, temp1, offset, temp2, offset, temp3, offset,
-                    temp0, temp1, temp2, temp3);
-        MAXI_SH4_UH(temp0, temp1, temp2, temp3, 0);
-        SRL_H4_UH(temp0, temp1, temp2, temp3, denom);
-        SAT_UH4_UH(temp0, temp1, temp2, temp3, 7);
-        PCKEV_B2_SB(temp1, temp0, temp3, temp2, out0, out1);
-        ST8x4_UB(out0, out1, data, stride);
-        data += (4 * stride);
-    }
+    LD4(data, stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, src0);
+    INSERT_D2_UB(tp2, tp3, src1);
+    LD4(data + 4 * stride, stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, src2);
+    INSERT_D2_UB(tp2, tp3, src3);
+    UNPCK_UB_SH(src0, src0_r, src1_r);
+    UNPCK_UB_SH(src1, src2_r, src3_r);
+    UNPCK_UB_SH(src2, src4_r, src5_r);
+    UNPCK_UB_SH(src3, src6_r, src7_r);
+    MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1, tmp2,
+         tmp3);
+    MUL4(wgt, src4_r, wgt, src5_r, wgt, src6_r, wgt, src7_r, tmp4, tmp5, tmp6,
+         tmp7);
+    ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
+                tmp1, tmp2, tmp3);
+    ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset, tmp4,
+                tmp5, tmp6, tmp7);
+    MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
+    SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
+    SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
+    PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, src0, src1,
+                src2, src3);
+    ST8x8_UB(src0, src1, src2, src3, data, stride);
 }
 
-static void avc_wgt_16width_msa(uint8_t *data, int32_t stride,
-                                int32_t height, int32_t log2_denom,
-                                int32_t src_weight, int32_t offset_in)
+static void avc_wgt_8x16_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
+                             int32_t src_weight, int32_t offset_in)
 {
-    uint8_t cnt;
-    v16i8 zero = { 0 };
-    v16u8 src0, src1, src2, src3;
-    v16u8 dst0, dst1, dst2, dst3;
-    v8u16 src0_l, src1_l, src2_l, src3_l, src0_r, src1_r, src2_r, src3_r;
-    v8u16 temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
-    v8u16 wgt, denom, offset;
+    uint32_t offset_val, cnt;
+    uint64_t tp0, tp1, tp2, tp3;
+    v16u8 src0 = { 0 }, src1 = { 0 }, src2 = { 0 }, src3 = { 0 };
+    v8i16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
+    v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+    v8i16 wgt, denom, offset;
 
-    offset_in <<= (log2_denom);
+    offset_val = (unsigned) offset_in << log2_denom;
 
-    if (log2_denom) {
-        offset_in += (1 << (log2_denom - 1));
-    }
+    wgt = __msa_fill_h(src_weight);
+    offset = __msa_fill_h(offset_val);
+    denom = __msa_fill_h(log2_denom);
 
-    wgt = (v8u16) __msa_fill_h(src_weight);
-    offset = (v8u16) __msa_fill_h(offset_in);
-    denom = (v8u16) __msa_fill_h(log2_denom);
-
-    for (cnt = height / 4; cnt--;) {
-        LD_UB4(data, stride, src0, src1, src2, src3);
-        ILVR_B4_UH(zero, src0, zero, src1, zero, src2, zero, src3,
-                   src0_r, src1_r, src2_r, src3_r);
-        ILVL_B4_UH(zero, src0, zero, src1, zero, src2, zero, src3,
-                   src0_l, src1_l, src2_l, src3_l);
-        MUL4(wgt, src0_r, wgt, src0_l, wgt, src1_r, wgt, src1_l,
-             temp0, temp1, temp2, temp3);
-        MUL4(wgt, src2_r, wgt, src2_l, wgt, src3_r, wgt, src3_l,
-             temp4, temp5, temp6, temp7);
-        ADDS_SH4_UH(temp0, offset, temp1, offset, temp2, offset, temp3, offset,
-                    temp0, temp1, temp2, temp3);
-        ADDS_SH4_UH(temp4, offset, temp5, offset, temp6, offset, temp7, offset,
-                    temp4, temp5, temp6, temp7);
-        MAXI_SH4_UH(temp0, temp1, temp2, temp3, 0);
-        MAXI_SH4_UH(temp4, temp5, temp6, temp7, 0);
-        SRL_H4_UH(temp0, temp1, temp2, temp3, denom);
-        SRL_H4_UH(temp4, temp5, temp6, temp7, denom);
-        SAT_UH4_UH(temp0, temp1, temp2, temp3, 7);
-        SAT_UH4_UH(temp4, temp5, temp6, temp7, 7);
-        PCKEV_B4_UB(temp1, temp0, temp3, temp2, temp5, temp4, temp7, temp6,
-                    dst0, dst1, dst2, dst3);
-        ST_UB4(dst0, dst1, dst2, dst3, data, stride);
-        data += 4 * stride;
+    for (cnt = 2; cnt--;) {
+        LD4(data, stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, src0);
+        INSERT_D2_UB(tp2, tp3, src1);
+        LD4(data + 4 * stride, stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, src2);
+        INSERT_D2_UB(tp2, tp3, src3);
+        UNPCK_UB_SH(src0, src0_r, src1_r);
+        UNPCK_UB_SH(src1, src2_r, src3_r);
+        UNPCK_UB_SH(src2, src4_r, src5_r);
+        UNPCK_UB_SH(src3, src6_r, src7_r);
+        MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1,
+             tmp2, tmp3);
+        MUL4(wgt, src4_r, wgt, src5_r, wgt, src6_r, wgt, src7_r, tmp4, tmp5,
+             tmp6, tmp7);
+        ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset,
+                    tmp0, tmp1, tmp2, tmp3);
+        ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset,
+                    tmp4, tmp5, tmp6, tmp7);
+        MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
+        SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
+        SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
+        PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, src0, src1,
+                    src2, src3);
+        ST8x8_UB(src0, src1, src2, src3, data, stride);
+        data += 8 * stride;
     }
 }
 
-static void avc_biwgt_4x2_msa(uint8_t *src, int32_t src_stride,
-                              uint8_t *dst, int32_t dst_stride,
+static void avc_biwgt_4x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
                               int32_t log2_denom, int32_t src_weight,
                               int32_t dst_weight, int32_t offset_in)
 {
-    uint32_t load0, load1, out0, out1;
-    v16i8 src_wgt, dst_wgt, wgt;
-    v16i8 src0, src1, dst0, dst1;
-    v8i16 temp0, temp1, denom, offset, add_val;
-    int32_t val = 128 * (src_weight + dst_weight);
+    uint32_t tp0, tp1;
+    v16i8 src_wgt, dst_wgt, wgt, vec0;
+    v16u8 src0 = { 0 }, dst0 = { 0 };
+    v8i16 tmp0, denom, offset, max255 = __msa_ldi_h(255);
 
-    offset_in = ((offset_in + 1) | 1) << log2_denom;
+    offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
+    offset_in += (128 * (src_weight + dst_weight));
 
     src_wgt = __msa_fill_b(src_weight);
     dst_wgt = __msa_fill_b(dst_weight);
     offset = __msa_fill_h(offset_in);
     denom = __msa_fill_h(log2_denom + 1);
-    add_val = __msa_fill_h(val);
-    offset += add_val;
 
     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
 
-    load0 = LW(src);
-    src += src_stride;
-    load1 = LW(src);
-
-    src0 = (v16i8) __msa_fill_w(load0);
-    src1 = (v16i8) __msa_fill_w(load1);
-
-    load0 = LW(dst);
-    load1 = LW(dst + dst_stride);
-
-    dst0 = (v16i8) __msa_fill_w(load0);
-    dst1 = (v16i8) __msa_fill_w(load1);
+    LW2(src, stride, tp0, tp1);
+    INSERT_W2_UB(tp0, tp1, src0);
+    LW2(dst, stride, tp0, tp1);
+    INSERT_W2_UB(tp0, tp1, dst0);
+    XORI_B2_128_UB(src0, dst0);
+    vec0 = (v16i8) __msa_ilvr_b((v16i8) dst0, (v16i8) src0);
+    tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
+    tmp0 >>= denom;
+    tmp0 = __msa_maxi_s_h(tmp0, 0);
+    tmp0 = __msa_min_s_h(max255, tmp0);
+    dst0 = (v16u8) __msa_pckev_b((v16i8) tmp0, (v16i8) tmp0);
+    ST4x2_UB(dst0, dst, stride);
+}
 
-    XORI_B4_128_SB(src0, src1, dst0, dst1);
-    ILVR_B2_SH(dst0, src0, dst1, src1, temp0, temp1);
+static void avc_biwgt_4x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                              int32_t log2_denom, int32_t src_weight,
+                              int32_t dst_weight, int32_t offset_in)
+{
+    uint32_t tp0, tp1, tp2, tp3;
+    v16i8 src_wgt, dst_wgt, wgt, vec0, vec1;
+    v16u8 src0, dst0;
+    v8i16 tmp0, tmp1, denom, offset;
 
-    temp0 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp0);
-    temp1 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp1);
+    offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
+    offset_in += (128 * (src_weight + dst_weight));
 
-    temp0 >>= denom;
-    temp1 >>= denom;
+    src_wgt = __msa_fill_b(src_weight);
+    dst_wgt = __msa_fill_b(dst_weight);
+    offset = __msa_fill_h(offset_in);
+    denom = __msa_fill_h(log2_denom + 1);
 
-    CLIP_SH2_0_255(temp0, temp1);
-    PCKEV_B2_SB(temp0, temp0, temp1, temp1, dst0, dst1);
+    wgt = __msa_ilvev_b(dst_wgt, src_wgt);
 
-    out0 = __msa_copy_u_w((v4i32) dst0, 0);
-    out1 = __msa_copy_u_w((v4i32) dst1, 0);
-    SW(out0, dst);
-    dst += dst_stride;
-    SW(out1, dst);
+    LW4(src, stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
+    LW4(dst, stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
+    XORI_B2_128_UB(src0, dst0);
+    ILVRL_B2_SB(dst0, src0, vec0, vec1);
+    tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
+    tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
+    tmp0 >>= denom;
+    tmp1 >>= denom;
+    CLIP_SH2_0_255(tmp0, tmp1);
+    dst0 = (v16u8) __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
+    ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, stride);
 }
 
-static void avc_biwgt_4x4multiple_msa(uint8_t *src, int32_t src_stride,
-                                      uint8_t *dst, int32_t dst_stride,
-                                      int32_t height, int32_t log2_denom,
-                                      int32_t src_weight, int32_t dst_weight,
-                                      int32_t offset_in)
+static void avc_biwgt_4x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                              int32_t log2_denom, int32_t src_weight,
+                              int32_t dst_weight, int32_t offset_in)
 {
-    uint8_t cnt;
-    uint32_t load0, load1, load2, load3;
-    v16i8 src_wgt, dst_wgt, wgt;
-    v16i8 src0, src1, src2, src3;
-    v16i8 dst0, dst1, dst2, dst3;
-    v8i16 temp0, temp1, temp2, temp3;
-    v8i16 denom, offset, add_val;
-    int32_t val = 128 * (src_weight + dst_weight);
+    uint32_t tp0, tp1, tp2, tp3;
+    v16i8 src_wgt, dst_wgt, wgt, vec0, vec1, vec2, vec3;
+    v16u8 src0, src1, dst0, dst1;
+    v8i16 tmp0, tmp1, tmp2, tmp3, denom, offset;
 
-    offset_in = ((offset_in + 1) | 1) << log2_denom;
+    offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
+    offset_in += (128 * (src_weight + dst_weight));
 
     src_wgt = __msa_fill_b(src_weight);
     dst_wgt = __msa_fill_b(dst_weight);
     offset = __msa_fill_h(offset_in);
     denom = __msa_fill_h(log2_denom + 1);
-    add_val = __msa_fill_h(val);
-    offset += add_val;
-
     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
 
-    for (cnt = height / 4; cnt--;) {
-        LW4(src, src_stride, load0, load1, load2, load3);
-        src += (4 * src_stride);
-
-        src0 = (v16i8) __msa_fill_w(load0);
-        src1 = (v16i8) __msa_fill_w(load1);
-        src2 = (v16i8) __msa_fill_w(load2);
-        src3 = (v16i8) __msa_fill_w(load3);
-
-        LW4(dst, dst_stride, load0, load1, load2, load3);
+    LW4(src, stride, tp0, tp1, tp2, tp3);
+    src += 4 * stride;
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
+    LW4(src, stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, src1);
+    LW4(dst, stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
+    LW4(dst + 4 * stride, stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst1);
+    XORI_B4_128_UB(src0, src1, dst0, dst1);
+    ILVRL_B2_SB(dst0, src0, vec0, vec1);
+    ILVRL_B2_SB(dst1, src1, vec2, vec3);
+    tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
+    tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
+    tmp2 = __msa_dpadd_s_h(offset, wgt, vec2);
+    tmp3 = __msa_dpadd_s_h(offset, wgt, vec3);
+    SRA_4V(tmp0, tmp1, tmp2, tmp3, denom);
+    CLIP_SH4_0_255(tmp0, tmp1, tmp2, tmp3);
+    PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, dst0, dst1);
+    ST4x8_UB(dst0, dst1, dst, stride);
+}
 
-        dst0 = (v16i8) __msa_fill_w(load0);
-        dst1 = (v16i8) __msa_fill_w(load1);
-        dst2 = (v16i8) __msa_fill_w(load2);
-        dst3 = (v16i8) __msa_fill_w(load3);
+static void avc_biwgt_8x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                              int32_t log2_denom, int32_t src_weight,
+                              int32_t dst_weight, int32_t offset_in)
+{
+    uint64_t tp0, tp1, tp2, tp3;
+    v16i8 src_wgt, dst_wgt, wgt, vec0, vec1, vec2, vec3;
+    v16u8 src0, src1, dst0, dst1;
+    v8i16 tmp0, tmp1, tmp2, tmp3, denom, offset;
 
-        XORI_B4_128_SB(src0, src1, src2, src3);
-        XORI_B4_128_SB(dst0, dst1, dst2, dst3);
-        ILVR_B4_SH(dst0, src0, dst1, src1, dst2, src2, dst3, src3,
-                   temp0, temp1, temp2, temp3);
+    offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
+    offset_in += (128 * (src_weight + dst_weight));
 
-        temp0 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp0);
-        temp1 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp1);
-        temp2 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp2);
-        temp3 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp3);
+    src_wgt = __msa_fill_b(src_weight);
+    dst_wgt = __msa_fill_b(dst_weight);
+    offset = __msa_fill_h(offset_in);
+    denom = __msa_fill_h(log2_denom + 1);
 
-        SRA_4V(temp0, temp1, temp2, temp3, denom);
-        CLIP_SH4_0_255(temp0, temp1, temp2, temp3);
-        PCKEV_ST4x4_UB(temp0, temp1, temp2, temp3, dst, dst_stride);
-        dst += (4 * dst_stride);
-    }
-}
+    wgt = __msa_ilvev_b(dst_wgt, src_wgt);
 
-static void avc_biwgt_4width_msa(uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
-                                 int32_t height, int32_t log2_denom,
-                                 int32_t src_weight, int32_t dst_weight,
-                                 int32_t offset_in)
-{
-    if (2 == height) {
-        avc_biwgt_4x2_msa(src, src_stride, dst, dst_stride, log2_denom,
-                          src_weight, dst_weight, offset_in);
-    } else {
-        avc_biwgt_4x4multiple_msa(src, src_stride, dst, dst_stride, height,
-                                  log2_denom, src_weight, dst_weight,
-                                  offset_in);
-    }
+    LD4(src, stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, src0);
+    INSERT_D2_UB(tp2, tp3, src1);
+    LD4(dst, stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, dst0);
+    INSERT_D2_UB(tp2, tp3, dst1);
+    XORI_B4_128_UB(src0, src1, dst0, dst1);
+    ILVRL_B2_SB(dst0, src0, vec0, vec1);
+    ILVRL_B2_SB(dst1, src1, vec2, vec3);
+    tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
+    tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
+    tmp2 = __msa_dpadd_s_h(offset, wgt, vec2);
+    tmp3 = __msa_dpadd_s_h(offset, wgt, vec3);
+    SRA_4V(tmp0, tmp1, tmp2, tmp3, denom);
+    CLIP_SH4_0_255(tmp0, tmp1, tmp2, tmp3);
+    PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, dst0, dst1);
+    ST8x4_UB(dst0, dst1, dst, stride);
 }
 
-static void avc_biwgt_8width_msa(uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
-                                 int32_t height, int32_t log2_denom,
-                                 int32_t src_weight, int32_t dst_weight,
-                                 int32_t offset_in)
+static void avc_biwgt_8x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                              int32_t log2_denom, int32_t src_weight,
+                              int32_t dst_weight, int32_t offset_in)
 {
-    uint8_t cnt;
-    v16i8 src_wgt, dst_wgt, wgt;
-    v16i8 src0, src1, src2, src3;
-    v16i8 dst0, dst1, dst2, dst3;
-    v16i8 out0, out1;
-    v8i16 temp0, temp1, temp2, temp3;
-    v8i16 denom, offset, add_val;
-    int32_t val = 128 * (src_weight + dst_weight);
+    uint64_t tp0, tp1, tp2, tp3;
+    v16i8 src_wgt, dst_wgt, wgt, vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+    v16u8 src0, src1, src2, src3, dst0, dst1, dst2, dst3;
+    v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom, offset;
 
-    offset_in = ((offset_in + 1) | 1) << log2_denom;
+    offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
+    offset_in += (128 * (src_weight + dst_weight));
 
     src_wgt = __msa_fill_b(src_weight);
     dst_wgt = __msa_fill_b(dst_weight);
     offset = __msa_fill_h(offset_in);
     denom = __msa_fill_h(log2_denom + 1);
-    add_val = __msa_fill_h(val);
-    offset += add_val;
-
     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
 
-    for (cnt = height / 4; cnt--;) {
-        LD_SB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
-
-        LD_SB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-        XORI_B4_128_SB(src0, src1, src2, src3);
-        XORI_B4_128_SB(dst0, dst1, dst2, dst3);
-        ILVR_B4_SH(dst0, src0, dst1, src1, dst2, src2, dst3, src3,
-                   temp0, temp1, temp2, temp3);
-
-        temp0 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp0);
-        temp1 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp1);
-        temp2 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp2);
-        temp3 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp3);
-
-        SRA_4V(temp0, temp1, temp2, temp3, denom);
-        CLIP_SH4_0_255(temp0, temp1, temp2, temp3);
-        PCKEV_B2_SB(temp1, temp0, temp3, temp2, out0, out1);
-        ST8x4_UB(out0, out1, dst, dst_stride);
-        dst += 4 * dst_stride;
-    }
+    LD4(src, stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, src0);
+    INSERT_D2_UB(tp2, tp3, src1);
+    LD4(src + 4 * stride, stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, src2);
+    INSERT_D2_UB(tp2, tp3, src3);
+    LD4(dst, stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, dst0);
+    INSERT_D2_UB(tp2, tp3, dst1);
+    LD4(dst + 4 * stride, stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, dst2);
+    INSERT_D2_UB(tp2, tp3, dst3);
+    XORI_B8_128_UB(src0, src1, src2, src3, dst0, dst1, dst2, dst3);
+    ILVRL_B2_SB(dst0, src0, vec0, vec1);
+    ILVRL_B2_SB(dst1, src1, vec2, vec3);
+    ILVRL_B2_SB(dst2, src2, vec4, vec5);
+    ILVRL_B2_SB(dst3, src3, vec6, vec7);
+    tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
+    tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
+    tmp2 = __msa_dpadd_s_h(offset, wgt, vec2);
+    tmp3 = __msa_dpadd_s_h(offset, wgt, vec3);
+    tmp4 = __msa_dpadd_s_h(offset, wgt, vec4);
+    tmp5 = __msa_dpadd_s_h(offset, wgt, vec5);
+    tmp6 = __msa_dpadd_s_h(offset, wgt, vec6);
+    tmp7 = __msa_dpadd_s_h(offset, wgt, vec7);
+    SRA_4V(tmp0, tmp1, tmp2, tmp3, denom);
+    SRA_4V(tmp4, tmp5, tmp6, tmp7, denom);
+    CLIP_SH4_0_255(tmp0, tmp1, tmp2, tmp3);
+    CLIP_SH4_0_255(tmp4, tmp5, tmp6, tmp7);
+    PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, dst0, dst1);
+    PCKEV_B2_UB(tmp5, tmp4, tmp7, tmp6, dst2, dst3);
+    ST8x8_UB(dst0, dst1, dst2, dst3, dst, stride);
 }
 
-static void avc_biwgt_16width_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
-                                  int32_t height, int32_t log2_denom,
-                                  int32_t src_weight, int32_t dst_weight,
-                                  int32_t offset_in)
+static void avc_biwgt_8x16_msa(uint8_t *src, uint8_t *dst, int32_t stride,
+                               int32_t log2_denom, int32_t src_weight,
+                               int32_t dst_weight, int32_t offset_in)
 {
     uint8_t cnt;
+    uint64_t tp0, tp1, tp2, tp3;
     v16i8 src_wgt, dst_wgt, wgt;
-    v16i8 src0, src1, src2, src3;
-    v16i8 dst0, dst1, dst2, dst3;
+    v16u8 src0, src1, src2, src3;
+    v16u8 dst0, dst1, dst2, dst3;
     v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
     v8i16 temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
-    v8i16 denom, offset, add_val;
-    int32_t val = 128 * (src_weight + dst_weight);
+    v8i16 denom, offset;
 
-    offset_in = ((offset_in + 1) | 1) << log2_denom;
+    offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
+    offset_in += (128 * (src_weight + dst_weight));
 
     src_wgt = __msa_fill_b(src_weight);
     dst_wgt = __msa_fill_b(dst_weight);
     offset = __msa_fill_h(offset_in);
     denom = __msa_fill_h(log2_denom + 1);
-    add_val = __msa_fill_h(val);
-    offset += add_val;
-
     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
 
-    for (cnt = height / 4; cnt--;) {
-        LD_SB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
-
-        LD_SB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-        XORI_B4_128_SB(src0, src1, src2, src3);
-        XORI_B4_128_SB(dst0, dst1, dst2, dst3);
+    for (cnt = 2; cnt--;) {
+        LD4(src, stride, tp0, tp1, tp2, tp3);
+        src += 4 * stride;
+        INSERT_D2_UB(tp0, tp1, src0);
+        INSERT_D2_UB(tp2, tp3, src1);
+        LD4(src, stride, tp0, tp1, tp2, tp3);
+        src += 4 * stride;
+        INSERT_D2_UB(tp0, tp1, src2);
+        INSERT_D2_UB(tp2, tp3, src3);
+        LD4(dst, stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, dst0);
+        INSERT_D2_UB(tp2, tp3, dst1);
+        LD4(dst + 4 * stride, stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, dst2);
+        INSERT_D2_UB(tp2, tp3, dst3);
+        XORI_B4_128_UB(src0, src1, src2, src3);
+        XORI_B4_128_UB(dst0, dst1, dst2, dst3);
         ILVR_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3,
                    vec0, vec2, vec4, vec6);
         ILVL_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3,
@@ -438,10 +477,10 @@ static void avc_biwgt_16width_msa(uint8_t *src, int32_t src_stride,
         SRA_4V(temp4, temp5, temp6, temp7, denom);
         CLIP_SH4_0_255(temp0, temp1, temp2, temp3);
         CLIP_SH4_0_255(temp4, temp5, temp6, temp7);
-        PCKEV_B4_SB(temp1, temp0, temp3, temp2, temp5, temp4, temp7, temp6,
+        PCKEV_B4_UB(temp1, temp0, temp3, temp2, temp5, temp4, temp7, temp6,
                     dst0, dst1, dst2, dst3);
-        ST_SB4(dst0, dst1, dst2, dst3, dst, dst_stride);
-        dst += 4 * dst_stride;
+        ST8x8_UB(dst0, dst1, dst2, dst3, dst, stride);
+        dst += 8 * stride;
     }
 }
 
@@ -644,96 +683,69 @@ static void avc_loopfilter_luma_intra_edge_hor_msa(uint8_t *data,
                                                    uint8_t beta_in,
                                                    uint32_t img_width)
 {
-    v16u8 p2_asub_p0, q2_asub_q0, p0_asub_q0;
-    v16u8 alpha, beta;
-    v16u8 is_less_than, is_less_than_beta, negate_is_less_than_beta;
-    v16u8 p2, p1, p0, q0, q1, q2;
-    v16u8 p3_org, p2_org, p1_org, p0_org, q0_org, q1_org, q2_org, q3_org;
-    v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
-    v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
-    v8i16 p2_r = { 0 };
-    v8i16 p1_r = { 0 };
-    v8i16 p0_r = { 0 };
-    v8i16 q0_r = { 0 };
-    v8i16 q1_r = { 0 };
-    v8i16 q2_r = { 0 };
-    v8i16 p2_l = { 0 };
-    v8i16 p1_l = { 0 };
-    v8i16 p0_l = { 0 };
-    v8i16 q0_l = { 0 };
-    v8i16 q1_l = { 0 };
-    v8i16 q2_l = { 0 };
-    v16u8 tmp_flag;
-    v16i8 zero = { 0 };
-
-    alpha = (v16u8) __msa_fill_b(alpha_in);
-    beta = (v16u8) __msa_fill_b(beta_in);
+    v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
+    v16u8 is_less_than, is_less_than_beta, is_less_than_alpha;
+    v16u8 p1_org, p0_org, q0_org, q1_org;
 
     LD_UB4(data - (img_width << 1), img_width, p1_org, p0_org, q0_org, q1_org);
 
-    {
-        v16u8 p1_asub_p0, q1_asub_q0, is_less_than_alpha;
+    p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
+    p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
+    q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
 
-        p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
-        p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
-        q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
-
-        is_less_than_alpha = (p0_asub_q0 < alpha);
-        is_less_than_beta = (p1_asub_p0 < beta);
-        is_less_than = is_less_than_beta & is_less_than_alpha;
-        is_less_than_beta = (q1_asub_q0 < beta);
-        is_less_than = is_less_than_beta & is_less_than;
-    }
+    is_less_than_alpha = (p0_asub_q0 < alpha_in);
+    is_less_than_beta = (p1_asub_p0 < beta_in);
+    is_less_than = is_less_than_beta & is_less_than_alpha;
+    is_less_than_beta = (q1_asub_q0 < beta_in);
+    is_less_than = is_less_than_beta & is_less_than;
 
     if (!__msa_test_bz_v(is_less_than)) {
-        q2_org = LD_UB(data + (2 * img_width));
-        p3_org = LD_UB(data - (img_width << 2));
-        p2_org = LD_UB(data - (3 * img_width));
+        v16u8 p2_asub_p0, q2_asub_q0, p0, q0, negate_is_less_than_beta;
+        v8i16 p0_r = { 0 };
+        v8i16 q0_r = { 0 };
+        v8i16 p0_l = { 0 };
+        v8i16 q0_l = { 0 };
+        v16i8 zero = { 0 };
+        v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
+        v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
+        v16u8 q2_org = LD_UB(data + (2 * img_width));
+        v16u8 p2_org = LD_UB(data - (3 * img_width));
+        v16u8 tmp_flag = (v16u8)__msa_fill_b((alpha_in >> 2) + 2);
 
         UNPCK_UB_SH(p1_org, p1_org_r, p1_org_l);
         UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
         UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
 
-        tmp_flag = alpha >> 2;
-        tmp_flag = tmp_flag + 2;
         tmp_flag = (p0_asub_q0 < tmp_flag);
 
         p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
-        is_less_than_beta = (p2_asub_p0 < beta);
+        is_less_than_beta = (p2_asub_p0 < beta_in);
         is_less_than_beta = is_less_than_beta & tmp_flag;
         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
         is_less_than_beta = is_less_than_beta & is_less_than;
         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
-        {
-            v8u16 is_less_than_beta_l, is_less_than_beta_r;
-
-            q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
-
-            is_less_than_beta_r =
-                (v8u16) __msa_sldi_b((v16i8) is_less_than_beta, zero, 8);
-            if (!__msa_test_bz_v((v16u8) is_less_than_beta_r)) {
-                v8i16 p3_org_r;
-
-                ILVR_B2_SH(zero, p3_org, zero, p2_org, p3_org_r, p2_r);
-                AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_r, p0_org_r, q0_org_r, p1_org_r,
-                                         p2_r, q1_org_r, p0_r, p1_r, p2_r);
-            }
-
-            q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
 
-            is_less_than_beta_l =
-                (v8u16) __msa_sldi_b(zero, (v16i8) is_less_than_beta, 8);
+        q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
+        q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
 
-            if (!__msa_test_bz_v((v16u8) is_less_than_beta_l)) {
-                v8i16 p3_org_l;
-
-                ILVL_B2_SH(zero, p3_org, zero, p2_org, p3_org_l, p2_l);
-                AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_l, p0_org_l, q0_org_l, p1_org_l,
-                                         p2_l, q1_org_l, p0_l, p1_l, p2_l);
-            }
-        }
         /* combine and store */
         if (!__msa_test_bz_v(is_less_than_beta)) {
+            v8i16 p3_org_l, p3_org_r;
+            v16u8 p3_org = LD_UB(data - (img_width << 2));
+            v16u8 p2, p1;
+            v8i16 p2_r = { 0 };
+            v8i16 p2_l = { 0 };
+            v8i16 p1_r = { 0 };
+            v8i16 p1_l = { 0 };
+
+            ILVR_B2_SH(zero, p3_org, zero, p2_org, p3_org_r, p2_r);
+            AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_r, p0_org_r, q0_org_r, p1_org_r,
+                                     p2_r, q1_org_r, p0_r, p1_r, p2_r);
+
+            ILVL_B2_SH(zero, p3_org, zero, p2_org, p3_org_l, p2_l);
+            AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_l, p0_org_l, q0_org_l, p1_org_l,
+                                     p2_l, q1_org_l, p0_l, p1_l, p2_l);
+
             PCKEV_B3_UB(p0_l, p0_r, p1_l, p1_r, p2_l, p2_r, p0, p1, p2);
 
             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than_beta);
@@ -743,62 +755,42 @@ static void avc_loopfilter_luma_intra_edge_hor_msa(uint8_t *data,
             ST_UB(p1_org, data - (2 * img_width));
             ST_UB(p2_org, data - (3 * img_width));
         }
-        {
-            v8u16 negate_is_less_than_beta_r, negate_is_less_than_beta_l;
 
-            negate_is_less_than_beta_r =
-                (v8u16) __msa_sldi_b((v16i8) negate_is_less_than_beta, zero, 8);
-            if (!__msa_test_bz_v((v16u8) negate_is_less_than_beta_r)) {
-                AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_r);
-            }
+        AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_r);
+        AVC_LPF_P0_OR_Q0(p0_org_l, q1_org_l, p1_org_l, p0_l);
 
-            negate_is_less_than_beta_l =
-                (v8u16) __msa_sldi_b(zero, (v16i8) negate_is_less_than_beta, 8);
-            if (!__msa_test_bz_v((v16u8) negate_is_less_than_beta_l)) {
-                AVC_LPF_P0_OR_Q0(p0_org_l, q1_org_l, p1_org_l, p0_l);
-            }
-        }
         /* combine */
-        if (!__msa_test_bz_v(negate_is_less_than_beta)) {
-            p0 = (v16u8) __msa_pckev_b((v16i8) p0_l, (v16i8) p0_r);
-            p0_org = __msa_bmnz_v(p0_org, p0, negate_is_less_than_beta);
-        }
+        p0 = (v16u8) __msa_pckev_b((v16i8) p0_l, (v16i8) p0_r);
+        p0_org = __msa_bmnz_v(p0_org, p0, negate_is_less_than_beta);
 
         ST_UB(p0_org, data - img_width);
 
         /* if (tmpFlag && (unsigned)ABS(q2-q0) < thresholds->beta_in) */
-        q3_org = LD_UB(data + (3 * img_width));
         q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
-        is_less_than_beta = (q2_asub_q0 < beta);
+        is_less_than_beta = (q2_asub_q0 < beta_in);
         is_less_than_beta = is_less_than_beta & tmp_flag;
         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
         is_less_than_beta = is_less_than_beta & is_less_than;
         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
 
-        {
-            v8u16 is_less_than_beta_l, is_less_than_beta_r;
-            is_less_than_beta_r =
-                (v8u16) __msa_sldi_b((v16i8) is_less_than_beta, zero, 8);
-            if (!__msa_test_bz_v((v16u8) is_less_than_beta_r)) {
-                v8i16 q3_org_r;
-
-                ILVR_B2_SH(zero, q3_org, zero, q2_org, q3_org_r, q2_r);
-                AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_r, q0_org_r, p0_org_r, q1_org_r,
-                                         q2_r, p1_org_r, q0_r, q1_r, q2_r);
-            }
-            is_less_than_beta_l =
-                (v8u16) __msa_sldi_b(zero, (v16i8) is_less_than_beta, 8);
-            if (!__msa_test_bz_v((v16u8) is_less_than_beta_l)) {
-                v8i16 q3_org_l;
-
-                ILVL_B2_SH(zero, q3_org, zero, q2_org, q3_org_l, q2_l);
-                AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_l, q0_org_l, p0_org_l, q1_org_l,
-                                         q2_l, p1_org_l, q0_l, q1_l, q2_l);
-            }
-        }
-
         /* combine and store */
         if (!__msa_test_bz_v(is_less_than_beta)) {
+            v8i16 q3_org_r, q3_org_l;
+            v16u8 q3_org = LD_UB(data + (3 * img_width));
+            v16u8 q1, q2;
+            v8i16 q2_r = { 0 };
+            v8i16 q2_l = { 0 };
+            v8i16 q1_r = { 0 };
+            v8i16 q1_l = { 0 };
+
+            ILVR_B2_SH(zero, q3_org, zero, q2_org, q3_org_r, q2_r);
+            AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_r, q0_org_r, p0_org_r, q1_org_r,
+                                     q2_r, p1_org_r, q0_r, q1_r, q2_r);
+
+            ILVL_B2_SH(zero, q3_org, zero, q2_org, q3_org_l, q2_l);
+            AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_l, q0_org_l, p0_org_l, q1_org_l,
+                                     q2_l, p1_org_l, q0_l, q1_l, q2_l);
+
             PCKEV_B3_UB(q0_l, q0_r, q1_l, q1_r, q2_l, q2_r, q0, q1, q2);
             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than_beta);
             q1_org = __msa_bmnz_v(q1_org, q1, is_less_than_beta);
@@ -807,25 +799,14 @@ static void avc_loopfilter_luma_intra_edge_hor_msa(uint8_t *data,
             ST_UB(q1_org, data + img_width);
             ST_UB(q2_org, data + 2 * img_width);
         }
-        {
-            v8u16 negate_is_less_than_beta_r, negate_is_less_than_beta_l;
-            negate_is_less_than_beta_r =
-                (v8u16) __msa_sldi_b((v16i8) negate_is_less_than_beta, zero, 8);
-            if (!__msa_test_bz_v((v16u8) negate_is_less_than_beta_r)) {
-                AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_r);
-            }
 
-            negate_is_less_than_beta_l =
-                (v8u16) __msa_sldi_b(zero, (v16i8) negate_is_less_than_beta, 8);
-            if (!__msa_test_bz_v((v16u8) negate_is_less_than_beta_l)) {
-                AVC_LPF_P0_OR_Q0(q0_org_l, p1_org_l, q1_org_l, q0_l);
-            }
-        }
+        AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_r);
+        AVC_LPF_P0_OR_Q0(q0_org_l, p1_org_l, q1_org_l, q0_l);
+
         /* combine */
-        if (!__msa_test_bz_v(negate_is_less_than_beta)) {
-            q0 = (v16u8) __msa_pckev_b((v16i8) q0_l, (v16i8) q0_r);
-            q0_org = __msa_bmnz_v(q0_org, q0, negate_is_less_than_beta);
-        }
+        q0 = (v16u8) __msa_pckev_b((v16i8) q0_l, (v16i8) q0_r);
+        q0_org = __msa_bmnz_v(q0_org, q0, negate_is_less_than_beta);
+
         ST_UB(q0_org, data);
     }
 }
@@ -835,29 +816,13 @@ static void avc_loopfilter_luma_intra_edge_ver_msa(uint8_t *data,
                                                    uint8_t beta_in,
                                                    uint32_t img_width)
 {
-    uint8_t *src;
+    uint8_t *src = data - 4;
     v16u8 alpha, beta, p0_asub_q0;
-    v16u8 is_less_than_alpha, is_less_than;
-    v16u8 is_less_than_beta, negate_is_less_than_beta;
+    v16u8 is_less_than_alpha, is_less_than, is_less_than_beta;
     v16u8 p3_org, p2_org, p1_org, p0_org, q0_org, q1_org, q2_org, q3_org;
-    v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
-    v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
-    v8i16 p2_r = { 0 };
-    v8i16 p1_r = { 0 };
-    v8i16 p0_r = { 0 };
-    v8i16 q0_r = { 0 };
-    v8i16 q1_r = { 0 };
-    v8i16 q2_r = { 0 };
-    v8i16 p2_l = { 0 };
-    v8i16 p1_l = { 0 };
-    v8i16 p0_l = { 0 };
-    v8i16 q0_l = { 0 };
-    v8i16 q1_l = { 0 };
-    v8i16 q2_l = { 0 };
-    v16i8 zero = { 0 };
-    v16u8 tmp_flag;
+    v16u8 p1_asub_p0, q1_asub_q0;
+
 
-    src = data - 4;
     {
         v16u8 row0, row1, row2, row3, row4, row5, row6, row7;
         v16u8 row8, row9, row10, row11, row12, row13, row14, row15;
@@ -873,119 +838,77 @@ static void avc_loopfilter_luma_intra_edge_ver_msa(uint8_t *data,
                             p3_org, p2_org, p1_org, p0_org,
                             q0_org, q1_org, q2_org, q3_org);
     }
-    UNPCK_UB_SH(p1_org, p1_org_r, p1_org_l);
-    UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
-    UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
-    UNPCK_UB_SH(q1_org, q1_org_r, q1_org_l);
-
-    /*  if ( ((unsigned)ABS(p0-q0) < thresholds->alpha_in) &&
-       ((unsigned)ABS(p1-p0) < thresholds->beta_in)  &&
-       ((unsigned)ABS(q1-q0) < thresholds->beta_in) )   */
-    {
-        v16u8 p1_asub_p0, q1_asub_q0;
 
-        p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
-        p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
-        q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
+    p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
+    p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
+    q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
 
-        alpha = (v16u8) __msa_fill_b(alpha_in);
-        beta = (v16u8) __msa_fill_b(beta_in);
+    alpha = (v16u8) __msa_fill_b(alpha_in);
+    beta = (v16u8) __msa_fill_b(beta_in);
 
-        is_less_than_alpha = (p0_asub_q0 < alpha);
-        is_less_than_beta = (p1_asub_p0 < beta);
-        is_less_than = is_less_than_beta & is_less_than_alpha;
-        is_less_than_beta = (q1_asub_q0 < beta);
-        is_less_than = is_less_than_beta & is_less_than;
-    }
+    is_less_than_alpha = (p0_asub_q0 < alpha);
+    is_less_than_beta = (p1_asub_p0 < beta);
+    is_less_than = is_less_than_beta & is_less_than_alpha;
+    is_less_than_beta = (q1_asub_q0 < beta);
+    is_less_than = is_less_than_beta & is_less_than;
 
     if (!__msa_test_bz_v(is_less_than)) {
+        v8i16 p0_r = { 0 };
+        v8i16 q0_r = { 0 };
+        v8i16 p0_l = { 0 };
+        v8i16 q0_l = { 0 };
+        v16i8 zero = { 0 };
+        v16u8 tmp_flag, p0, q0, p2_asub_p0, q2_asub_q0;
+        v16u8 negate_is_less_than_beta;
+        v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
+        v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
+
+        UNPCK_UB_SH(p1_org, p1_org_r, p1_org_l);
+        UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
+        UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
+        UNPCK_UB_SH(q1_org, q1_org_r, q1_org_l);
+
         tmp_flag = alpha >> 2;
         tmp_flag = tmp_flag + 2;
         tmp_flag = (p0_asub_q0 < tmp_flag);
 
-        {
-            v16u8 p2_asub_p0;
-
-            p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
-            is_less_than_beta = (p2_asub_p0 < beta);
-        }
+        p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
+        is_less_than_beta = (p2_asub_p0 < beta);
         is_less_than_beta = tmp_flag & is_less_than_beta;
         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
         is_less_than_beta = is_less_than_beta & is_less_than;
         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
 
-        /* right */
-        {
-            v16u8 is_less_than_beta_r;
-
-            is_less_than_beta_r =
-                (v16u8) __msa_sldi_b((v16i8) is_less_than_beta, zero, 8);
-            if (!__msa_test_bz_v(is_less_than_beta_r)) {
-                v8i16 p3_org_r;
-
-                ILVR_B2_SH(zero, p3_org, zero, p2_org, p3_org_r, p2_r);
-                AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_r, p0_org_r, q0_org_r, p1_org_r,
-                                         p2_r, q1_org_r, p0_r, p1_r, p2_r);
-            }
-        }
-        /* left */
-        {
-            v16u8 is_less_than_beta_l;
-
-            is_less_than_beta_l =
-                (v16u8) __msa_sldi_b(zero, (v16i8) is_less_than_beta, 8);
-            if (!__msa_test_bz_v(is_less_than_beta_l)) {
-                v8i16 p3_org_l;
-
-                ILVL_B2_SH(zero, p3_org, zero, p2_org, p3_org_l, p2_l);
-                AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_l, p0_org_l, q0_org_l, p1_org_l,
-                                         p2_l, q1_org_l, p0_l, p1_l, p2_l);
-            }
-        }
-        /* combine and store */
         if (!__msa_test_bz_v(is_less_than_beta)) {
-            v16u8 p0, p2, p1;
+            v16u8 p2, p1;
+            v8i16 p3_org_r, p3_org_l;
+            v8i16 p2_l = { 0 };
+            v8i16 p2_r = { 0 };
+            v8i16 p1_l = { 0 };
+            v8i16 p1_r = { 0 };
+
+            ILVR_B2_SH(zero, p3_org, zero, p2_org, p3_org_r, p2_r);
+            AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_r, p0_org_r, q0_org_r, p1_org_r,
+                                     p2_r, q1_org_r, p0_r, p1_r, p2_r);
+
+            ILVL_B2_SH(zero, p3_org, zero, p2_org, p3_org_l, p2_l);
+            AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_l, p0_org_l, q0_org_l, p1_org_l,
+                                         p2_l, q1_org_l, p0_l, p1_l, p2_l);
 
             PCKEV_B3_UB(p0_l, p0_r, p1_l, p1_r, p2_l, p2_r, p0, p1, p2);
             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than_beta);
             p1_org = __msa_bmnz_v(p1_org, p1, is_less_than_beta);
             p2_org = __msa_bmnz_v(p2_org, p2, is_less_than_beta);
         }
-        /* right */
-        {
-            v16u8 negate_is_less_than_beta_r;
-
-            negate_is_less_than_beta_r =
-                (v16u8) __msa_sldi_b((v16i8) negate_is_less_than_beta, zero, 8);
-
-            if (!__msa_test_bz_v(negate_is_less_than_beta_r)) {
-                AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_r);
-            }
-        }
-        /* left */
-        {
-            v16u8 negate_is_less_than_beta_l;
-
-            negate_is_less_than_beta_l =
-                (v16u8) __msa_sldi_b(zero, (v16i8) negate_is_less_than_beta, 8);
-            if (!__msa_test_bz_v(negate_is_less_than_beta_l)) {
-                AVC_LPF_P0_OR_Q0(p0_org_l, q1_org_l, p1_org_l, p0_l);
-            }
-        }
 
-        if (!__msa_test_bz_v(negate_is_less_than_beta)) {
-            v16u8 p0;
+        AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_r);
+        AVC_LPF_P0_OR_Q0(p0_org_l, q1_org_l, p1_org_l, p0_l);
 
-            p0 = (v16u8) __msa_pckev_b((v16i8) p0_l, (v16i8) p0_r);
-            p0_org = __msa_bmnz_v(p0_org, p0, negate_is_less_than_beta);
-        }
-
-        {
-            v16u8 q2_asub_q0;
+        p0 = (v16u8) __msa_pckev_b((v16i8) p0_l, (v16i8) p0_r);
+        p0_org = __msa_bmnz_v(p0_org, p0, negate_is_less_than_beta);
 
-            q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
-            is_less_than_beta = (q2_asub_q0 < beta);
-        }
+        q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
+        is_less_than_beta = (q2_asub_q0 < beta);
 
         is_less_than_beta = is_less_than_beta & tmp_flag;
         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
@@ -993,37 +916,21 @@ static void avc_loopfilter_luma_intra_edge_ver_msa(uint8_t *data,
         is_less_than_beta = is_less_than_beta & is_less_than;
         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
 
-        /* right */
-        {
-            v16u8 is_less_than_beta_r;
-
-            is_less_than_beta_r =
-                (v16u8) __msa_sldi_b((v16i8) is_less_than_beta, zero, 8);
-            if (!__msa_test_bz_v(is_less_than_beta_r)) {
-                v8i16 q3_org_r;
-
-                ILVR_B2_SH(zero, q3_org, zero, q2_org, q3_org_r, q2_r);
-                AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_r, q0_org_r, p0_org_r, q1_org_r,
-                                         q2_r, p1_org_r, q0_r, q1_r, q2_r);
-            }
-        }
-        /* left */
-        {
-            v16u8 is_less_than_beta_l;
+        if (!__msa_test_bz_v(is_less_than_beta)) {
+            v16u8 q1, q2;
+            v8i16 q3_org_r, q3_org_l;
+            v8i16 q1_l = { 0 };
+            v8i16 q1_r = { 0 };
+            v8i16 q2_l = { 0 };
+            v8i16 q2_r = { 0 };
 
-            is_less_than_beta_l =
-                (v16u8) __msa_sldi_b(zero, (v16i8) is_less_than_beta, 8);
-            if (!__msa_test_bz_v(is_less_than_beta_l)) {
-                v8i16 q3_org_l;
+            ILVR_B2_SH(zero, q3_org, zero, q2_org, q3_org_r, q2_r);
+            AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_r, q0_org_r, p0_org_r, q1_org_r,
+                                     q2_r, p1_org_r, q0_r, q1_r, q2_r);
 
-                ILVL_B2_SH(zero, q3_org, zero, q2_org, q3_org_l, q2_l);
-                AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_l, q0_org_l, p0_org_l, q1_org_l,
-                                         q2_l, p1_org_l, q0_l, q1_l, q2_l);
-            }
-        }
-        /* combine and store */
-        if (!__msa_test_bz_v(is_less_than_beta)) {
-            v16u8 q0, q1, q2;
+            ILVL_B2_SH(zero, q3_org, zero, q2_org, q3_org_l, q2_l);
+            AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_l, q0_org_l, p0_org_l, q1_org_l,
+                                     q2_l, p1_org_l, q0_l, q1_l, q2_l);
 
             PCKEV_B3_UB(q0_l, q0_r, q1_l, q1_r, q2_l, q2_r, q0, q1, q2);
             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than_beta);
@@ -1031,33 +938,12 @@ static void avc_loopfilter_luma_intra_edge_ver_msa(uint8_t *data,
             q2_org = __msa_bmnz_v(q2_org, q2, is_less_than_beta);
         }
 
-        /* right */
-        {
-            v16u8 negate_is_less_than_beta_r;
+        AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_r);
+        AVC_LPF_P0_OR_Q0(q0_org_l, p1_org_l, q1_org_l, q0_l);
 
-            negate_is_less_than_beta_r =
-                (v16u8) __msa_sldi_b((v16i8) negate_is_less_than_beta, zero, 8);
-            if (!__msa_test_bz_v(negate_is_less_than_beta_r)) {
-                AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_r);
-            }
-        }
-        /* left */
-        {
-            v16u8 negate_is_less_than_beta_l;
+        q0 = (v16u8) __msa_pckev_b((v16i8) q0_l, (v16i8) q0_r);
+        q0_org = __msa_bmnz_v(q0_org, q0, negate_is_less_than_beta);
 
-            negate_is_less_than_beta_l =
-                (v16u8) __msa_sldi_b(zero, (v16i8) negate_is_less_than_beta, 8);
-            if (!__msa_test_bz_v(negate_is_less_than_beta_l)) {
-                AVC_LPF_P0_OR_Q0(q0_org_l, p1_org_l, q1_org_l, q0_l);
-            }
-        }
-        if (!__msa_test_bz_v(negate_is_less_than_beta)) {
-            v16u8 q0;
-
-            q0 = (v16u8) __msa_pckev_b((v16i8) q0_l, (v16i8) q0_r);
-            q0_org = __msa_bmnz_v(q0_org, q0, negate_is_less_than_beta);
-        }
-    }
     {
         v8i16 tp0, tp1, tp2, tp3, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 
@@ -1082,6 +968,7 @@ static void avc_loopfilter_luma_intra_edge_ver_msa(uint8_t *data,
         ST4x4_UB(tmp7, tmp7, 0, 1, 2, 3, src, img_width);
         ST2x4_UB(tmp5, 4, src + 4, img_width);
     }
+    }
 }
 
 static void avc_h_loop_filter_luma_mbaff_intra_msa(uint8_t *src, int32_t stride,
@@ -1402,21 +1289,7 @@ static void avc_loopfilter_luma_inter_edge_ver_msa(uint8_t *data,
                                                    uint8_t beta_in,
                                                    uint32_t img_width)
 {
-    uint8_t *src;
-    v16u8 beta, tmp_vec, bs = { 0 };
-    v16u8 tc = { 0 };
-    v16u8 is_less_than, is_less_than_beta;
-    v16u8 p1, p0, q0, q1;
-    v8i16 p0_r, q0_r, p1_r = { 0 };
-    v8i16 q1_r = { 0 };
-    v8i16 p0_l, q0_l, p1_l = { 0 };
-    v8i16 q1_l = { 0 };
-    v16u8 p3_org, p2_org, p1_org, p0_org, q0_org, q1_org, q2_org, q3_org;
-    v8i16 p2_org_r, p1_org_r, p0_org_r, q0_org_r, q1_org_r, q2_org_r;
-    v8i16 p2_org_l, p1_org_l, p0_org_l, q0_org_l, q1_org_l, q2_org_l;
-    v8i16 tc_r, tc_l;
-    v16i8 zero = { 0 };
-    v16u8 is_bs_greater_than0;
+    v16u8 tmp_vec, bs = { 0 };
 
     tmp_vec = (v16u8) __msa_fill_b(bs0);
     bs = (v16u8) __msa_insve_w((v4i32) bs, 0, (v4i32) tmp_vec);
@@ -1428,6 +1301,14 @@ static void avc_loopfilter_luma_inter_edge_ver_msa(uint8_t *data,
     bs = (v16u8) __msa_insve_w((v4i32) bs, 3, (v4i32) tmp_vec);
 
     if (!__msa_test_bz_v(bs)) {
+        uint8_t *src = data - 4;
+        v16u8 p3_org, p2_org, p1_org, p0_org, q0_org, q1_org, q2_org, q3_org;
+        v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0, alpha, beta;
+        v16u8 is_less_than, is_less_than_beta, is_less_than_alpha;
+        v16u8 is_bs_greater_than0;
+        v16u8 tc = { 0 };
+        v16i8 zero = { 0 };
+
         tmp_vec = (v16u8) __msa_fill_b(tc0);
         tc = (v16u8) __msa_insve_w((v4i32) tc, 0, (v4i32) tmp_vec);
         tmp_vec = (v16u8) __msa_fill_b(tc1);
@@ -1443,9 +1324,6 @@ static void avc_loopfilter_luma_inter_edge_ver_msa(uint8_t *data,
             v16u8 row0, row1, row2, row3, row4, row5, row6, row7;
             v16u8 row8, row9, row10, row11, row12, row13, row14, row15;
 
-            src = data;
-            src -= 4;
-
             LD_UB8(src, img_width,
                    row0, row1, row2, row3, row4, row5, row6, row7);
             src += (8 * img_width);
@@ -1458,27 +1336,28 @@ static void avc_loopfilter_luma_inter_edge_ver_msa(uint8_t *data,
                                 p3_org, p2_org, p1_org, p0_org,
                                 q0_org, q1_org, q2_org, q3_org);
         }
-        {
-            v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0, alpha;
-            v16u8 is_less_than_alpha;
-
-            p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
-            p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
-            q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
-
-            alpha = (v16u8) __msa_fill_b(alpha_in);
-            beta = (v16u8) __msa_fill_b(beta_in);
-
-            is_less_than_alpha = (p0_asub_q0 < alpha);
-            is_less_than_beta = (p1_asub_p0 < beta);
-            is_less_than = is_less_than_beta & is_less_than_alpha;
-            is_less_than_beta = (q1_asub_q0 < beta);
-            is_less_than = is_less_than_beta & is_less_than;
-            is_less_than = is_less_than & is_bs_greater_than0;
-        }
+
+        p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
+        p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
+        q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
+
+        alpha = (v16u8) __msa_fill_b(alpha_in);
+        beta = (v16u8) __msa_fill_b(beta_in);
+
+        is_less_than_alpha = (p0_asub_q0 < alpha);
+        is_less_than_beta = (p1_asub_p0 < beta);
+        is_less_than = is_less_than_beta & is_less_than_alpha;
+        is_less_than_beta = (q1_asub_q0 < beta);
+        is_less_than = is_less_than_beta & is_less_than;
+        is_less_than = is_less_than & is_bs_greater_than0;
+
         if (!__msa_test_bz_v(is_less_than)) {
             v16i8 negate_tc, sign_negate_tc;
-            v8i16 negate_tc_r, i16_negatetc_l;
+            v16u8 p0, q0, p2_asub_p0, q2_asub_q0;
+            v8i16 tc_r, tc_l, negate_tc_r, i16_negatetc_l;
+            v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
+            v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
+            v8i16 p0_r, q0_r, p0_l, q0_l;
 
             negate_tc = zero - (v16i8) tc;
             sign_negate_tc = __msa_clti_s_b(negate_tc, 0);
@@ -1490,34 +1369,22 @@ static void avc_loopfilter_luma_inter_edge_ver_msa(uint8_t *data,
             UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
             UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
 
-            {
-                v16u8 p2_asub_p0;
-                v16u8 is_less_than_beta_r, is_less_than_beta_l;
-
-                p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
-                is_less_than_beta = (p2_asub_p0 < beta);
-                is_less_than_beta = is_less_than_beta & is_less_than;
-
-                is_less_than_beta_r =
-                    (v16u8) __msa_sldi_b((v16i8) is_less_than_beta, zero, 8);
-                if (!__msa_test_bz_v(is_less_than_beta_r)) {
-                    p2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) p2_org);
-
-                    AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, p1_org_r, p2_org_r,
-                                     negate_tc_r, tc_r, p1_r);
-                }
-
-                is_less_than_beta_l =
-                    (v16u8) __msa_sldi_b(zero, (v16i8) is_less_than_beta, 8);
-                if (!__msa_test_bz_v(is_less_than_beta_l)) {
-                    p2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) p2_org);
-
-                    AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, p1_org_l, p2_org_l,
-                                     i16_negatetc_l, tc_l, p1_l);
-                }
-            }
+            p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
+            is_less_than_beta = (p2_asub_p0 < beta);
+            is_less_than_beta = is_less_than_beta & is_less_than;
 
             if (!__msa_test_bz_v(is_less_than_beta)) {
+                v16u8 p1;
+                v8i16 p1_r = { 0 };
+                v8i16 p1_l = { 0 };
+                v8i16 p2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) p2_org);
+                v8i16 p2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) p2_org);
+
+                AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, p1_org_r, p2_org_r,
+                                 negate_tc_r, tc_r, p1_r);
+                AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, p1_org_l, p2_org_l,
+                                 i16_negatetc_l, tc_l, p1_l);
+
                 p1 = (v16u8) __msa_pckev_b((v16i8) p1_l, (v16i8) p1_r);
                 p1_org = __msa_bmnz_v(p1_org, p1, is_less_than_beta);
 
@@ -1525,36 +1392,25 @@ static void avc_loopfilter_luma_inter_edge_ver_msa(uint8_t *data,
                 tc = tc + is_less_than_beta;
             }
 
-            {
-                v16u8 u8_q2asub_q0;
-                v16u8 is_less_than_beta_l, is_less_than_beta_r;
-
-                u8_q2asub_q0 = __msa_asub_u_b(q2_org, q0_org);
-                is_less_than_beta = (u8_q2asub_q0 < beta);
-                is_less_than_beta = is_less_than_beta & is_less_than;
-
-                q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
-
-                is_less_than_beta_r =
-                    (v16u8) __msa_sldi_b((v16i8) is_less_than_beta, zero, 8);
-                if (!__msa_test_bz_v(is_less_than_beta_r)) {
-                    q2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q2_org);
-                    AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, q1_org_r, q2_org_r,
-                                     negate_tc_r, tc_r, q1_r);
-                }
-
-                q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
-
-                is_less_than_beta_l =
-                    (v16u8) __msa_sldi_b(zero, (v16i8) is_less_than_beta, 8);
-                if (!__msa_test_bz_v(is_less_than_beta_l)) {
-                    q2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q2_org);
-                    AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, q1_org_l, q2_org_l,
-                                     i16_negatetc_l, tc_l, q1_l);
-                }
-            }
+            q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
+            is_less_than_beta = (q2_asub_q0 < beta);
+            is_less_than_beta = is_less_than_beta & is_less_than;
+
+            q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
+            q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
 
             if (!__msa_test_bz_v(is_less_than_beta)) {
+                v16u8 q1;
+                v8i16 q1_r = { 0 };
+                v8i16 q1_l = { 0 };
+                v8i16 q2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q2_org);
+                v8i16 q2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q2_org);
+
+                AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, q1_org_r, q2_org_r,
+                                 negate_tc_r, tc_r, q1_r);
+                AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, q1_org_l, q2_org_l,
+                                 i16_negatetc_l, tc_l, q1_l);
+
                 q1 = (v16u8) __msa_pckev_b((v16i8) q1_l, (v16i8) q1_r);
                 q1_org = __msa_bmnz_v(q1_org, q1, is_less_than_beta);
 
@@ -1588,7 +1444,7 @@ static void avc_loopfilter_luma_inter_edge_ver_msa(uint8_t *data,
 
             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than);
             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than);
-        }
+
         {
             v16i8 tp0, tp1, tp2, tp3;
             v8i16 tmp2, tmp5;
@@ -1700,6 +1556,7 @@ static void avc_loopfilter_luma_inter_edge_ver_msa(uint8_t *data,
             SW(out2, src);
             SH(out3, (src + 4));
         }
+        }
     }
 }
 
@@ -1712,20 +1569,8 @@ static void avc_loopfilter_luma_inter_edge_hor_msa(uint8_t *data,
                                                    uint8_t beta_in,
                                                    uint32_t image_width)
 {
-    v16u8 p2_asub_p0, u8_q2asub_q0;
-    v16u8 alpha, beta, is_less_than, is_less_than_beta;
-    v16u8 p1, p0, q0, q1;
-    v8i16 p1_r = { 0 };
-    v8i16 p0_r, q0_r, q1_r = { 0 };
-    v8i16 p1_l = { 0 };
-    v8i16 p0_l, q0_l, q1_l = { 0 };
-    v16u8 p2_org, p1_org, p0_org, q0_org, q1_org, q2_org;
-    v8i16 p2_org_r, p1_org_r, p0_org_r, q0_org_r, q1_org_r, q2_org_r;
-    v8i16 p2_org_l, p1_org_l, p0_org_l, q0_org_l, q1_org_l, q2_org_l;
-    v16i8 zero = { 0 };
     v16u8 tmp_vec;
     v16u8 bs = { 0 };
-    v16i8 tc = { 0 };
 
     tmp_vec = (v16u8) __msa_fill_b(bs0);
     bs = (v16u8) __msa_insve_w((v4i32) bs, 0, (v4i32) tmp_vec);
@@ -1737,6 +1582,16 @@ static void avc_loopfilter_luma_inter_edge_hor_msa(uint8_t *data,
     bs = (v16u8) __msa_insve_w((v4i32) bs, 3, (v4i32) tmp_vec);
 
     if (!__msa_test_bz_v(bs)) {
+        v16u8 alpha, beta, is_less_than, is_less_than_beta;
+        v16u8 p0, q0, p2_org, p1_org, p0_org, q0_org, q1_org, q2_org;
+        v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
+        v16u8 is_less_than_alpha, is_bs_greater_than0;
+        v8i16 p0_r, q0_r, p0_l, q0_l;
+        v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
+        v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
+        v16i8 zero = { 0 };
+        v16i8 tc = { 0 };
+
         tmp_vec = (v16u8) __msa_fill_b(tc0);
         tc = (v16i8) __msa_insve_w((v4i32) tc, 0, (v4i32) tmp_vec);
         tmp_vec = (v16u8) __msa_fill_b(tc1);
@@ -1752,26 +1607,22 @@ static void avc_loopfilter_luma_inter_edge_hor_msa(uint8_t *data,
         LD_UB5(data - (3 * image_width), image_width,
                p2_org, p1_org, p0_org, q0_org, q1_org);
 
-        {
-            v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
-            v16u8 is_less_than_alpha, is_bs_greater_than0;
-
-            is_bs_greater_than0 = ((v16u8) zero < bs);
-            p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
-            p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
-            q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
-
-            is_less_than_alpha = (p0_asub_q0 < alpha);
-            is_less_than_beta = (p1_asub_p0 < beta);
-            is_less_than = is_less_than_beta & is_less_than_alpha;
-            is_less_than_beta = (q1_asub_q0 < beta);
-            is_less_than = is_less_than_beta & is_less_than;
-            is_less_than = is_less_than & is_bs_greater_than0;
-        }
+        is_bs_greater_than0 = ((v16u8) zero < bs);
+        p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
+        p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
+        q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
+
+        is_less_than_alpha = (p0_asub_q0 < alpha);
+        is_less_than_beta = (p1_asub_p0 < beta);
+        is_less_than = is_less_than_beta & is_less_than_alpha;
+        is_less_than_beta = (q1_asub_q0 < beta);
+        is_less_than = is_less_than_beta & is_less_than;
+        is_less_than = is_less_than & is_bs_greater_than0;
 
         if (!__msa_test_bz_v(is_less_than)) {
             v16i8 sign_negate_tc, negate_tc;
             v8i16 negate_tc_r, i16_negatetc_l, tc_l, tc_r;
+            v16u8 p2_asub_p0, q2_asub_q0;
 
             q2_org = LD_UB(data + (2 * image_width));
             negate_tc = zero - tc;
@@ -1787,28 +1638,19 @@ static void avc_loopfilter_luma_inter_edge_hor_msa(uint8_t *data,
             p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
             is_less_than_beta = (p2_asub_p0 < beta);
             is_less_than_beta = is_less_than_beta & is_less_than;
-            {
-                v8u16 is_less_than_beta_r, is_less_than_beta_l;
-
-                is_less_than_beta_r =
-                    (v8u16) __msa_sldi_b((v16i8) is_less_than_beta, zero, 8);
-                if (!__msa_test_bz_v((v16u8) is_less_than_beta_r)) {
-                    p2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) p2_org);
 
-                    AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, p1_org_r, p2_org_r,
-                                     negate_tc_r, tc_r, p1_r);
-                }
+            if (!__msa_test_bz_v(is_less_than_beta)) {
+                v16u8 p1;
+                v8i16 p1_r = { 0 };
+                v8i16 p1_l = { 0 };
+                v8i16 p2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) p2_org);
+                v8i16 p2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) p2_org);
 
-                is_less_than_beta_l =
-                    (v8u16) __msa_sldi_b(zero, (v16i8) is_less_than_beta, 8);
-                if (!__msa_test_bz_v((v16u8) is_less_than_beta_l)) {
-                    p2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) p2_org);
+                AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, p1_org_r, p2_org_r,
+                                 negate_tc_r, tc_r, p1_r);
+                AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, p1_org_l, p2_org_l,
+                                 i16_negatetc_l, tc_l, p1_l);
 
-                    AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, p1_org_l, p2_org_l,
-                                     i16_negatetc_l, tc_l, p1_l);
-                }
-            }
-            if (!__msa_test_bz_v(is_less_than_beta)) {
                 p1 = (v16u8) __msa_pckev_b((v16i8) p1_l, (v16i8) p1_r);
                 p1_org = __msa_bmnz_v(p1_org, p1, is_less_than_beta);
                 ST_UB(p1_org, data - (2 * image_width));
@@ -1817,34 +1659,25 @@ static void avc_loopfilter_luma_inter_edge_hor_msa(uint8_t *data,
                 tc = tc + (v16i8) is_less_than_beta;
             }
 
-            u8_q2asub_q0 = __msa_asub_u_b(q2_org, q0_org);
-            is_less_than_beta = (u8_q2asub_q0 < beta);
+            q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
+            is_less_than_beta = (q2_asub_q0 < beta);
             is_less_than_beta = is_less_than_beta & is_less_than;
 
-            {
-                v8u16 is_less_than_beta_r, is_less_than_beta_l;
-                is_less_than_beta_r =
-                    (v8u16) __msa_sldi_b((v16i8) is_less_than_beta, zero, 8);
-
-                q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
-                if (!__msa_test_bz_v((v16u8) is_less_than_beta_r)) {
-                    q2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q2_org);
-
-                    AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, q1_org_r, q2_org_r,
-                                     negate_tc_r, tc_r, q1_r);
-                }
-                is_less_than_beta_l =
-                    (v8u16) __msa_sldi_b(zero, (v16i8) is_less_than_beta, 8);
-
-                q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
-                if (!__msa_test_bz_v((v16u8) is_less_than_beta_l)) {
-                    q2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q2_org);
-
-                    AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, q1_org_l, q2_org_l,
-                                     i16_negatetc_l, tc_l, q1_l);
-                }
-            }
+            q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
+            q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
+
             if (!__msa_test_bz_v(is_less_than_beta)) {
+                v16u8 q1;
+                v8i16 q1_r = { 0 };
+                v8i16 q1_l = { 0 };
+                v8i16 q2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q2_org);
+                v8i16 q2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q2_org);
+
+                AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, q1_org_r, q2_org_r,
+                                 negate_tc_r, tc_r, q1_r);
+                AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, q1_org_l, q2_org_l,
+                                 i16_negatetc_l, tc_l, q1_l);
+
                 q1 = (v16u8) __msa_pckev_b((v16i8) q1_l, (v16i8) q1_r);
                 q1_org = __msa_bmnz_v(q1_org, q1, is_less_than_beta);
                 ST_UB(q1_org, data + image_width);
@@ -2497,32 +2330,239 @@ void ff_h264_h_loop_filter_luma_mbaff_intra_msa(uint8_t *src,
 
 void ff_weight_h264_pixels16_8_msa(uint8_t *src, ptrdiff_t stride,
                                    int height, int log2_denom,
-                                   int weight_src, int offset)
+                                   int weight_src, int offset_in)
 {
-    avc_wgt_16width_msa(src, stride, height, log2_denom, weight_src, offset);
+    uint32_t offset_val;
+    v16i8 zero = { 0 };
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
+    v8i16 src0_l, src1_l, src2_l, src3_l, src0_r, src1_r, src2_r, src3_r;
+    v8i16 src4_l, src5_l, src6_l, src7_l, src4_r, src5_r, src6_r, src7_r;
+    v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+    v8i16 tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
+    v8i16 wgt, denom, offset;
+
+    offset_val = (unsigned) offset_in << log2_denom;
+
+    wgt = __msa_fill_h(weight_src);
+    offset = __msa_fill_h(offset_val);
+    denom = __msa_fill_h(log2_denom);
+
+    LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+    ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_r, src1_r,
+               src2_r, src3_r);
+    ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_l, src1_l,
+               src2_l, src3_l);
+    ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_r, src5_r,
+               src6_r, src7_r);
+    ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_l, src5_l,
+               src6_l, src7_l);
+    MUL4(wgt, src0_r, wgt, src0_l, wgt, src1_r, wgt, src1_l, tmp0, tmp1, tmp2,
+         tmp3);
+    MUL4(wgt, src2_r, wgt, src2_l, wgt, src3_r, wgt, src3_l, tmp4, tmp5, tmp6,
+         tmp7);
+    MUL4(wgt, src4_r, wgt, src4_l, wgt, src5_r, wgt, src5_l, tmp8, tmp9, tmp10,
+         tmp11);
+    MUL4(wgt, src6_r, wgt, src6_l, wgt, src7_r, wgt, src7_l, tmp12, tmp13,
+         tmp14, tmp15);
+    ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
+                tmp1, tmp2, tmp3);
+    ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset, tmp4,
+                tmp5, tmp6, tmp7);
+    ADDS_SH4_SH(tmp8, offset, tmp9, offset, tmp10, offset, tmp11, offset, tmp8,
+                tmp9, tmp10, tmp11);
+    ADDS_SH4_SH(tmp12, offset, tmp13, offset, tmp14, offset, tmp15, offset,
+                tmp12, tmp13, tmp14, tmp15);
+    MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
+    MAXI_SH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 0);
+    SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
+    SRLR_H8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, denom);
+    SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
+    SAT_UH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 7);
+    PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, dst0, dst1,
+                dst2, dst3);
+    PCKEV_B4_UB(tmp9, tmp8, tmp11, tmp10, tmp13, tmp12, tmp15, tmp14, dst4,
+                dst5, dst6, dst7);
+    ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, src, stride);
+    src += 8 * stride;
+
+    if (16 == height) {
+        LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+        ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_r,
+                   src1_r, src2_r, src3_r);
+        ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_l,
+                   src1_l, src2_l, src3_l);
+        ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_r,
+                   src5_r, src6_r, src7_r);
+        ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_l,
+                   src5_l, src6_l, src7_l);
+        MUL4(wgt, src0_r, wgt, src0_l, wgt, src1_r, wgt, src1_l, tmp0, tmp1,
+             tmp2, tmp3);
+        MUL4(wgt, src2_r, wgt, src2_l, wgt, src3_r, wgt, src3_l, tmp4, tmp5,
+             tmp6, tmp7);
+        MUL4(wgt, src4_r, wgt, src4_l, wgt, src5_r, wgt, src5_l, tmp8, tmp9,
+             tmp10, tmp11);
+        MUL4(wgt, src6_r, wgt, src6_l, wgt, src7_r, wgt, src7_l, tmp12, tmp13,
+             tmp14, tmp15);
+        ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset,
+                    tmp0, tmp1, tmp2, tmp3);
+        ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset,
+                    tmp4, tmp5, tmp6, tmp7);
+        ADDS_SH4_SH(tmp8, offset, tmp9, offset, tmp10, offset, tmp11, offset,
+                    tmp8, tmp9, tmp10, tmp11);
+        ADDS_SH4_SH(tmp12, offset, tmp13, offset, tmp14, offset, tmp15, offset,
+                    tmp12, tmp13, tmp14, tmp15);
+        MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
+        MAXI_SH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 0);
+        SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
+        SRLR_H8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, denom);
+        SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
+        SAT_UH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 7);
+        PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, dst0, dst1,
+                    dst2, dst3);
+        PCKEV_B4_UB(tmp9, tmp8, tmp11, tmp10, tmp13, tmp12, tmp15, tmp14, dst4,
+                    dst5, dst6, dst7);
+        ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, src, stride);
+    }
 }
 
 void ff_weight_h264_pixels8_8_msa(uint8_t *src, ptrdiff_t stride,
                                   int height, int log2_denom,
                                   int weight_src, int offset)
 {
-    avc_wgt_8width_msa(src, stride, height, log2_denom, weight_src, offset);
+    if (4 == height) {
+        avc_wgt_8x4_msa(src, stride, log2_denom, weight_src, offset);
+    } else if (8 == height) {
+        avc_wgt_8x8_msa(src, stride, log2_denom, weight_src, offset);
+    } else {
+        avc_wgt_8x16_msa(src, stride, log2_denom, weight_src, offset);
+    }
 }
 
 void ff_weight_h264_pixels4_8_msa(uint8_t *src, ptrdiff_t stride,
                                   int height, int log2_denom,
                                   int weight_src, int offset)
 {
-    avc_wgt_4width_msa(src, stride, height, log2_denom, weight_src, offset);
+    if (2 == height) {
+        avc_wgt_4x2_msa(src, stride, log2_denom, weight_src, offset);
+    } else if (4 == height) {
+        avc_wgt_4x4_msa(src, stride, log2_denom, weight_src, offset);
+    } else {
+        avc_wgt_4x8_msa(src, stride, log2_denom, weight_src, offset);
+    }
 }
 
 void ff_biweight_h264_pixels16_8_msa(uint8_t *dst, uint8_t *src,
                                      ptrdiff_t stride, int height,
                                      int log2_denom, int weight_dst,
-                                     int weight_src, int offset)
+                                     int weight_src, int offset_in)
 {
-    avc_biwgt_16width_msa(src, stride, dst, stride, height, log2_denom,
-                          weight_src, weight_dst, offset);
+    v16i8 src_wgt, dst_wgt, wgt;
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+    v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
+    v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+    v8i16 tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
+    v8i16 denom, offset;
+
+    offset_in = (unsigned) ((offset_in + 1) | 1) << log2_denom;
+    offset_in += (128 * (weight_src + weight_dst));
+
+    src_wgt = __msa_fill_b(weight_src);
+    dst_wgt = __msa_fill_b(weight_dst);
+    offset = __msa_fill_h(offset_in);
+    denom = __msa_fill_h(log2_denom + 1);
+
+    wgt = __msa_ilvev_b(dst_wgt, src_wgt);
+
+    LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+    src += 8 * stride;
+    LD_UB8(dst, stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
+    XORI_B8_128_UB(src0, src1, src2, src3, src4, src5, src6, src7);
+    XORI_B8_128_UB(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
+    ILVR_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3, vec0, vec2, vec4,
+               vec6);
+    ILVL_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3, vec1, vec3, vec5,
+               vec7);
+    ILVR_B4_SB(dst4, src4, dst5, src5, dst6, src6, dst7, src7, vec8, vec10,
+               vec12, vec14);
+    ILVL_B4_SB(dst4, src4, dst5, src5, dst6, src6, dst7, src7, vec9, vec11,
+               vec13, vec15);
+    tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
+    tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
+    tmp2 = __msa_dpadd_s_h(offset, wgt, vec2);
+    tmp3 = __msa_dpadd_s_h(offset, wgt, vec3);
+    tmp4 = __msa_dpadd_s_h(offset, wgt, vec4);
+    tmp5 = __msa_dpadd_s_h(offset, wgt, vec5);
+    tmp6 = __msa_dpadd_s_h(offset, wgt, vec6);
+    tmp7 = __msa_dpadd_s_h(offset, wgt, vec7);
+    tmp8 = __msa_dpadd_s_h(offset, wgt, vec8);
+    tmp9 = __msa_dpadd_s_h(offset, wgt, vec9);
+    tmp10 = __msa_dpadd_s_h(offset, wgt, vec10);
+    tmp11 = __msa_dpadd_s_h(offset, wgt, vec11);
+    tmp12 = __msa_dpadd_s_h(offset, wgt, vec12);
+    tmp13 = __msa_dpadd_s_h(offset, wgt, vec13);
+    tmp14 = __msa_dpadd_s_h(offset, wgt, vec14);
+    tmp15 = __msa_dpadd_s_h(offset, wgt, vec15);
+    SRA_4V(tmp0, tmp1, tmp2, tmp3, denom);
+    SRA_4V(tmp4, tmp5, tmp6, tmp7, denom);
+    SRA_4V(tmp8, tmp9, tmp10, tmp11, denom);
+    SRA_4V(tmp12, tmp13, tmp14, tmp15, denom);
+    CLIP_SH4_0_255(tmp0, tmp1, tmp2, tmp3);
+    CLIP_SH4_0_255(tmp4, tmp5, tmp6, tmp7);
+    CLIP_SH4_0_255(tmp8, tmp9, tmp10, tmp11);
+    CLIP_SH4_0_255(tmp12, tmp13, tmp14, tmp15);
+    PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, dst0, dst1,
+                dst2, dst3);
+    PCKEV_B4_UB(tmp9, tmp8, tmp11, tmp10, tmp13, tmp12, tmp15, tmp14, dst4,
+                dst5, dst6, dst7);
+    ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, stride);
+    dst += 8 * stride;
+
+    if (16 == height) {
+        LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+        LD_UB8(dst, stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
+        XORI_B8_128_UB(src0, src1, src2, src3, src4, src5, src6, src7);
+        XORI_B8_128_UB(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
+        ILVR_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3, vec0, vec2,
+                   vec4, vec6);
+        ILVL_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3, vec1, vec3,
+                   vec5, vec7);
+        ILVR_B4_SB(dst4, src4, dst5, src5, dst6, src6, dst7, src7, vec8, vec10,
+                   vec12, vec14);
+        ILVL_B4_SB(dst4, src4, dst5, src5, dst6, src6, dst7, src7, vec9, vec11,
+                   vec13, vec15);
+        tmp0 = __msa_dpadd_s_h(offset, wgt, vec0);
+        tmp1 = __msa_dpadd_s_h(offset, wgt, vec1);
+        tmp2 = __msa_dpadd_s_h(offset, wgt, vec2);
+        tmp3 = __msa_dpadd_s_h(offset, wgt, vec3);
+        tmp4 = __msa_dpadd_s_h(offset, wgt, vec4);
+        tmp5 = __msa_dpadd_s_h(offset, wgt, vec5);
+        tmp6 = __msa_dpadd_s_h(offset, wgt, vec6);
+        tmp7 = __msa_dpadd_s_h(offset, wgt, vec7);
+        tmp8 = __msa_dpadd_s_h(offset, wgt, vec8);
+        tmp9 = __msa_dpadd_s_h(offset, wgt, vec9);
+        tmp10 = __msa_dpadd_s_h(offset, wgt, vec10);
+        tmp11 = __msa_dpadd_s_h(offset, wgt, vec11);
+        tmp12 = __msa_dpadd_s_h(offset, wgt, vec12);
+        tmp13 = __msa_dpadd_s_h(offset, wgt, vec13);
+        tmp14 = __msa_dpadd_s_h(offset, wgt, vec14);
+        tmp15 = __msa_dpadd_s_h(offset, wgt, vec15);
+        SRA_4V(tmp0, tmp1, tmp2, tmp3, denom);
+        SRA_4V(tmp4, tmp5, tmp6, tmp7, denom);
+        SRA_4V(tmp8, tmp9, tmp10, tmp11, denom);
+        SRA_4V(tmp12, tmp13, tmp14, tmp15, denom);
+        CLIP_SH4_0_255(tmp0, tmp1, tmp2, tmp3);
+        CLIP_SH4_0_255(tmp4, tmp5, tmp6, tmp7);
+        CLIP_SH4_0_255(tmp8, tmp9, tmp10, tmp11);
+        CLIP_SH4_0_255(tmp12, tmp13, tmp14, tmp15);
+        PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, dst0, dst1,
+                    dst2, dst3);
+        PCKEV_B4_UB(tmp9, tmp8, tmp11, tmp10, tmp13, tmp12, tmp15, tmp14, dst4,
+                    dst5, dst6, dst7);
+        ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, stride);
+    }
 }
 
 void ff_biweight_h264_pixels8_8_msa(uint8_t *dst, uint8_t *src,
@@ -2530,8 +2570,16 @@ void ff_biweight_h264_pixels8_8_msa(uint8_t *dst, uint8_t *src,
                                     int log2_denom, int weight_dst,
                                     int weight_src, int offset)
 {
-    avc_biwgt_8width_msa(src, stride, dst, stride, height, log2_denom,
-                         weight_src, weight_dst, offset);
+    if (4 == height) {
+        avc_biwgt_8x4_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
+                          offset);
+    } else if (8 == height) {
+        avc_biwgt_8x8_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
+                          offset);
+    } else {
+        avc_biwgt_8x16_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
+                           offset);
+    }
 }
 
 void ff_biweight_h264_pixels4_8_msa(uint8_t *dst, uint8_t *src,
@@ -2539,6 +2587,14 @@ void ff_biweight_h264_pixels4_8_msa(uint8_t *dst, uint8_t *src,
                                     int log2_denom, int weight_dst,
                                     int weight_src, int offset)
 {
-    avc_biwgt_4width_msa(src, stride, dst, stride, height, log2_denom,
-                         weight_src, weight_dst, offset);
+    if (2 == height) {
+        avc_biwgt_4x2_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
+                          offset);
+    } else if (4 == height) {
+        avc_biwgt_4x4_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
+                          offset);
+    } else {
+        avc_biwgt_4x8_msa(src, dst, stride, log2_denom, weight_src, weight_dst,
+                          offset);
+    }
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/h264idct_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/h264idct_msa.c
index fac1e7add41..1e1a5c8cb82 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/h264idct_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/h264idct_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
+ * Copyright (c) 2015 - 2017 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -36,63 +36,24 @@
     BUTTERFLY_4(tmp0_m, tmp1_m, tmp2_m, tmp3_m, out0, out1, out2, out3);  \
 }
 
-static void avc_idct4x4_addblk_msa(uint8_t *dst, int16_t *src,
-                                   int32_t dst_stride)
-{
-    v8i16 src0, src1, src2, src3;
-    v8i16 hres0, hres1, hres2, hres3;
-    v8i16 vres0, vres1, vres2, vres3;
-    v8i16 zeros = { 0 };
-
-    LD4x4_SH(src, src0, src1, src2, src3);
-    AVC_ITRANS_H(src0, src1, src2, src3, hres0, hres1, hres2, hres3);
-    TRANSPOSE4x4_SH_SH(hres0, hres1, hres2, hres3, hres0, hres1, hres2, hres3);
-    AVC_ITRANS_H(hres0, hres1, hres2, hres3, vres0, vres1, vres2, vres3);
-    SRARI_H4_SH(vres0, vres1, vres2, vres3, 6);
-    ADDBLK_ST4x4_UB(vres0, vres1, vres2, vres3, dst, dst_stride);
-    ST_SH2(zeros, zeros, src, 8);
-}
-
-static void avc_idct4x4_addblk_dc_msa(uint8_t *dst, int16_t *src,
-                                      int32_t dst_stride)
-{
-    int16_t dc;
-    uint32_t src0, src1, src2, src3;
-    v16u8 pred = { 0 };
-    v16i8 out;
-    v8i16 input_dc, pred_r, pred_l;
-
-    dc = (src[0] + 32) >> 6;
-    input_dc = __msa_fill_h(dc);
-    src[0] = 0;
-
-    LW4(dst, dst_stride, src0, src1, src2, src3);
-    INSERT_W4_UB(src0, src1, src2, src3, pred);
-    UNPCK_UB_SH(pred, pred_r, pred_l);
-
-    pred_r += input_dc;
-    pred_l += input_dc;
-
-    CLIP_SH2_0_255(pred_r, pred_l);
-    out = __msa_pckev_b((v16i8) pred_l, (v16i8) pred_r);
-    ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
-}
-
 static void avc_deq_idct_luma_dc_msa(int16_t *dst, int16_t *src,
                                      int32_t de_q_val)
 {
 #define DC_DEST_STRIDE 16
-    int16_t out0, out1, out2, out3;
-    v8i16 src0, src1, src2, src3;
+    int16_t out0, out1, out2, out3, out4, out5, out6, out7;
+    v8i16 src1, src3;
     v8i16 vec0, vec1, vec2, vec3;
+    v8i16 tmp0, tmp1, tmp2, tmp3;
     v8i16 hres0, hres1, hres2, hres3;
     v8i16 vres0, vres1, vres2, vres3;
     v4i32 vres0_r, vres1_r, vres2_r, vres3_r;
-    v4i32 de_q_vec = __msa_fill_w(de_q_val);
+    const v4i32 de_q_vec = __msa_fill_w(de_q_val);
+    const v8i16 src0 = LD_SH(src);
+    const v8i16 src2 = LD_SH(src + 8);
 
-    LD4x4_SH(src, src0, src1, src2, src3);
-    TRANSPOSE4x4_SH_SH(src0, src1, src2, src3, src0, src1, src2, src3);
-    BUTTERFLY_4(src0, src2, src3, src1, vec0, vec3, vec2, vec1);
+    ILVL_D2_SH(src0, src0, src2, src2, src1, src3);
+    TRANSPOSE4x4_SH_SH(src0, src1, src2, src3, tmp0, tmp1, tmp2, tmp3);
+    BUTTERFLY_4(tmp0, tmp2, tmp3, tmp1, vec0, vec3, vec2, vec1);
     BUTTERFLY_4(vec0, vec1, vec2, vec3, hres0, hres3, hres2, hres1);
     TRANSPOSE4x4_SH_SH(hres0, hres1, hres2, hres3, hres0, hres1, hres2, hres3);
     BUTTERFLY_4(hres0, hres1, hres3, hres2, vec0, vec3, vec2, vec1);
@@ -114,40 +75,35 @@ static void avc_deq_idct_luma_dc_msa(int16_t *dst, int16_t *src,
     out1 = __msa_copy_s_h(vec0, 1);
     out2 = __msa_copy_s_h(vec0, 2);
     out3 = __msa_copy_s_h(vec0, 3);
-    SH(out0, dst);
-    SH(out1, (dst + 2 * DC_DEST_STRIDE));
-    SH(out2, (dst + 8 * DC_DEST_STRIDE));
-    SH(out3, (dst + 10 * DC_DEST_STRIDE));
-    dst += DC_DEST_STRIDE;
-
-    out0 = __msa_copy_s_h(vec0, 4);
-    out1 = __msa_copy_s_h(vec0, 5);
-    out2 = __msa_copy_s_h(vec0, 6);
-    out3 = __msa_copy_s_h(vec0, 7);
-    SH(out0, dst);
-    SH(out1, (dst + 2 * DC_DEST_STRIDE));
-    SH(out2, (dst + 8 * DC_DEST_STRIDE));
+    out4 = __msa_copy_s_h(vec0, 4);
+    out5 = __msa_copy_s_h(vec0, 5);
+    out6 = __msa_copy_s_h(vec0, 6);
+    out7 = __msa_copy_s_h(vec0, 7);
+    SH(out0, (dst + 0  * DC_DEST_STRIDE));
+    SH(out1, (dst + 2  * DC_DEST_STRIDE));
+    SH(out2, (dst + 8  * DC_DEST_STRIDE));
     SH(out3, (dst + 10 * DC_DEST_STRIDE));
-    dst += (3 * DC_DEST_STRIDE);
+    SH(out4, (dst + 1  * DC_DEST_STRIDE));
+    SH(out5, (dst + 3  * DC_DEST_STRIDE));
+    SH(out6, (dst + 9  * DC_DEST_STRIDE));
+    SH(out7, (dst + 11 * DC_DEST_STRIDE));
 
     out0 = __msa_copy_s_h(vec1, 0);
     out1 = __msa_copy_s_h(vec1, 1);
     out2 = __msa_copy_s_h(vec1, 2);
     out3 = __msa_copy_s_h(vec1, 3);
-    SH(out0, dst);
-    SH(out1, (dst + 2 * DC_DEST_STRIDE));
-    SH(out2, (dst + 8 * DC_DEST_STRIDE));
-    SH(out3, (dst + 10 * DC_DEST_STRIDE));
-    dst += DC_DEST_STRIDE;
-
-    out0 = __msa_copy_s_h(vec1, 4);
-    out1 = __msa_copy_s_h(vec1, 5);
-    out2 = __msa_copy_s_h(vec1, 6);
-    out3 = __msa_copy_s_h(vec1, 7);
-    SH(out0, dst);
-    SH(out1, (dst + 2 * DC_DEST_STRIDE));
-    SH(out2, (dst + 8 * DC_DEST_STRIDE));
-    SH(out3, (dst + 10 * DC_DEST_STRIDE));
+    out4 = __msa_copy_s_h(vec1, 4);
+    out5 = __msa_copy_s_h(vec1, 5);
+    out6 = __msa_copy_s_h(vec1, 6);
+    out7 = __msa_copy_s_h(vec1, 7);
+    SH(out0, (dst + 4  * DC_DEST_STRIDE));
+    SH(out1, (dst + 6  * DC_DEST_STRIDE));
+    SH(out2, (dst + 12 * DC_DEST_STRIDE));
+    SH(out3, (dst + 14 * DC_DEST_STRIDE));
+    SH(out4, (dst + 5  * DC_DEST_STRIDE));
+    SH(out5, (dst + 7  * DC_DEST_STRIDE));
+    SH(out6, (dst + 13 * DC_DEST_STRIDE));
+    SH(out7, (dst + 15 * DC_DEST_STRIDE));
 
 #undef DC_DEST_STRIDE
 }
@@ -164,11 +120,12 @@ static void avc_idct8_addblk_msa(uint8_t *dst, int16_t *src, int32_t dst_stride)
     v4i32 res0_r, res1_r, res2_r, res3_r, res4_r, res5_r, res6_r, res7_r;
     v4i32 res0_l, res1_l, res2_l, res3_l, res4_l, res5_l, res6_l, res7_l;
     v16i8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
-    v16i8 zeros = { 0 };
+    v8i16 zeros = { 0 };
 
     src[0] += 32;
 
     LD_SH8(src, 8, src0, src1, src2, src3, src4, src5, src6, src7);
+    ST_SH8(zeros, zeros, zeros, zeros, zeros, zeros, zeros, zeros, src, 8);
 
     vec0 = src0 + src4;
     vec1 = src0 - src4;
@@ -317,24 +274,73 @@ static void avc_idct8_dc_addblk_msa(uint8_t *dst, int16_t *src,
     ST8x4_UB(dst2, dst3, dst, dst_stride);
 }
 
-void ff_h264_idct_add_msa(uint8_t *dst, int16_t *src,
-                          int32_t dst_stride)
+void ff_h264_idct_add_msa(uint8_t *dst, int16_t *src, int32_t dst_stride)
 {
-    avc_idct4x4_addblk_msa(dst, src, dst_stride);
-    memset(src, 0, 16 * sizeof(dctcoef));
+    uint32_t src0_m, src1_m, src2_m, src3_m, out0_m, out1_m, out2_m, out3_m;
+    v16i8 dst0_m = { 0 };
+    v16i8 dst1_m = { 0 };
+    v8i16 hres0, hres1, hres2, hres3, vres0, vres1, vres2, vres3;
+    v8i16 inp0_m, inp1_m, res0_m, res1_m, src1, src3;
+    const v8i16 src0 = LD_SH(src);
+    const v8i16 src2 = LD_SH(src + 8);
+    const v8i16 zero = { 0 };
+    const uint8_t *dst1 = dst + dst_stride;
+    const uint8_t *dst2 = dst + 2 * dst_stride;
+    const uint8_t *dst3 = dst + 3 * dst_stride;
+
+    ILVL_D2_SH(src0, src0, src2, src2, src1, src3);
+    ST_SH2(zero, zero, src, 8);
+    AVC_ITRANS_H(src0, src1, src2, src3, hres0, hres1, hres2, hres3);
+    TRANSPOSE4x4_SH_SH(hres0, hres1, hres2, hres3, hres0, hres1, hres2, hres3);
+    AVC_ITRANS_H(hres0, hres1, hres2, hres3, vres0, vres1, vres2, vres3);
+    src0_m = LW(dst);
+    src1_m = LW(dst1);
+    SRARI_H4_SH(vres0, vres1, vres2, vres3, 6);
+    src2_m = LW(dst2);
+    src3_m = LW(dst3);
+    ILVR_D2_SH(vres1, vres0, vres3, vres2, inp0_m, inp1_m);
+    INSERT_W2_SB(src0_m, src1_m, dst0_m);
+    INSERT_W2_SB(src2_m, src3_m, dst1_m);
+    ILVR_B2_SH(zero, dst0_m, zero, dst1_m, res0_m, res1_m);
+    ADD2(res0_m, inp0_m, res1_m, inp1_m, res0_m, res1_m);
+    CLIP_SH2_0_255(res0_m, res1_m);
+    PCKEV_B2_SB(res0_m, res0_m, res1_m, res1_m, dst0_m, dst1_m);
+    out0_m = __msa_copy_u_w((v4i32) dst0_m, 0);
+    out1_m = __msa_copy_u_w((v4i32) dst0_m, 1);
+    out2_m = __msa_copy_u_w((v4i32) dst1_m, 0);
+    out3_m = __msa_copy_u_w((v4i32) dst1_m, 1);
+    SW(out0_m, dst);
+    SW(out1_m, dst1);
+    SW(out2_m, dst2);
+    SW(out3_m, dst3);
 }
 
 void ff_h264_idct8_addblk_msa(uint8_t *dst, int16_t *src,
                               int32_t dst_stride)
 {
     avc_idct8_addblk_msa(dst, src, dst_stride);
-    memset(src, 0, 64 * sizeof(dctcoef));
 }
 
 void ff_h264_idct4x4_addblk_dc_msa(uint8_t *dst, int16_t *src,
                                    int32_t dst_stride)
 {
-    avc_idct4x4_addblk_dc_msa(dst, src, dst_stride);
+    v16u8 pred = { 0 };
+    v16i8 out;
+    v8i16 pred_r, pred_l;
+    const uint32_t src0 = LW(dst);
+    const uint32_t src1 = LW(dst + dst_stride);
+    const uint32_t src2 = LW(dst + 2 * dst_stride);
+    const uint32_t src3 = LW(dst + 3 * dst_stride);
+    const int16_t dc = (src[0] + 32) >> 6;
+    const v8i16 input_dc = __msa_fill_h(dc);
+
+    src[0] = 0;
+    INSERT_W4_UB(src0, src1, src2, src3, pred);
+    UNPCK_UB_SH(pred, pred_r, pred_l);
+    ADD2(pred_r, input_dc, pred_l, input_dc, pred_r, pred_l);
+    CLIP_SH2_0_255(pred_r, pred_l);
+    out = __msa_pckev_b((v16i8) pred_l, (v16i8) pred_r);
+    ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
 }
 
 void ff_h264_idct8_dc_addblk_msa(uint8_t *dst, int16_t *src,
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/h264pred_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/h264pred_msa.c
index cddcd2e8780..b9990c13f0b 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/h264pred_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/h264pred_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Shivraj Patil (Shivraj.Patil@imgtec.com)
+ * Copyright (c) 2015 - 2017 Shivraj Patil (Shivraj.Patil@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -24,31 +24,21 @@
 static void intra_predict_vert_8x8_msa(uint8_t *src, uint8_t *dst,
                                        int32_t dst_stride)
 {
-    uint32_t row;
-    uint32_t src_data1, src_data2;
+    uint64_t out = LD(src);
 
-    src_data1 = LW(src);
-    src_data2 = LW(src + 4);
-
-    for (row = 8; row--;) {
-        SW(src_data1, dst);
-        SW(src_data2, (dst + 4));
-        dst += dst_stride;
-    }
+    SD4(out, out, out, out, dst, dst_stride);
+    dst += (4 * dst_stride);
+    SD4(out, out, out, out, dst, dst_stride);
 }
 
 static void intra_predict_vert_16x16_msa(uint8_t *src, uint8_t *dst,
                                          int32_t dst_stride)
 {
-    uint32_t row;
-    v16u8 src0;
+    v16u8 out = LD_UB(src);
 
-    src0 = LD_UB(src);
-
-    for (row = 16; row--;) {
-        ST_UB(src0, dst);
-        dst += dst_stride;
-    }
+    ST_UB8(out, out, out, out, out, out, out, out, dst, dst_stride);
+    dst += (8 * dst_stride);
+    ST_UB8(out, out, out, out, out, out, out, out, dst, dst_stride);
 }
 
 static void intra_predict_horiz_8x8_msa(uint8_t *src, int32_t src_stride,
@@ -73,172 +63,72 @@ static void intra_predict_horiz_8x8_msa(uint8_t *src, int32_t src_stride,
 static void intra_predict_horiz_16x16_msa(uint8_t *src, int32_t src_stride,
                                           uint8_t *dst, int32_t dst_stride)
 {
-    uint32_t row;
     uint8_t inp0, inp1, inp2, inp3;
-    v16u8 src0, src1, src2, src3;
-
-    for (row = 4; row--;) {
-        inp0 = src[0];
-        src += src_stride;
-        inp1 = src[0];
-        src += src_stride;
-        inp2 = src[0];
-        src += src_stride;
-        inp3 = src[0];
-        src += src_stride;
-
-        src0 = (v16u8) __msa_fill_b(inp0);
-        src1 = (v16u8) __msa_fill_b(inp1);
-        src2 = (v16u8) __msa_fill_b(inp2);
-        src3 = (v16u8) __msa_fill_b(inp3);
-
-        ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-        dst += (4 * dst_stride);
-    }
-}
-
-static void intra_predict_dc_8x8_msa(uint8_t *src_top, uint8_t *src_left,
-                                     int32_t src_stride_left,
-                                     uint8_t *dst, int32_t dst_stride,
-                                     uint8_t is_above, uint8_t is_left)
-{
-    uint32_t row;
-    uint32_t out, addition = 0;
-    v16u8 src_above, store;
-    v8u16 sum_above;
-    v4u32 sum_top;
-    v2u64 sum;
-
-    if (is_left && is_above) {
-        src_above = LD_UB(src_top);
-
-        sum_above = __msa_hadd_u_h(src_above, src_above);
-        sum_top = __msa_hadd_u_w(sum_above, sum_above);
-        sum = __msa_hadd_u_d(sum_top, sum_top);
-        addition = __msa_copy_u_w((v4i32) sum, 0);
-
-        for (row = 0; row < 8; row++) {
-            addition += src_left[row * src_stride_left];
-        }
-
-        addition = (addition + 8) >> 4;
-        store = (v16u8) __msa_fill_b(addition);
-    } else if (is_left) {
-        for (row = 0; row < 8; row++) {
-            addition += src_left[row * src_stride_left];
-        }
-
-        addition = (addition + 4) >> 3;
-        store = (v16u8) __msa_fill_b(addition);
-    } else if (is_above) {
-        src_above = LD_UB(src_top);
-
-        sum_above = __msa_hadd_u_h(src_above, src_above);
-        sum_top = __msa_hadd_u_w(sum_above, sum_above);
-        sum = __msa_hadd_u_d(sum_top, sum_top);
-        sum = (v2u64) __msa_srari_d((v2i64) sum, 3);
-        store = (v16u8) __msa_splati_b((v16i8) sum, 0);
-    } else {
-        store = (v16u8) __msa_ldi_b(128);
-    }
-
-    out = __msa_copy_u_w((v4i32) store, 0);
-
-    for (row = 8; row--;) {
-        SW(out, dst);
-        SW(out, (dst + 4));
-        dst += dst_stride;
-    }
-}
-
-static void intra_predict_dc_16x16_msa(uint8_t *src_top, uint8_t *src_left,
-                                       int32_t src_stride_left,
-                                       uint8_t *dst, int32_t dst_stride,
-                                       uint8_t is_above, uint8_t is_left)
-{
-    uint32_t row;
-    uint32_t addition = 0;
-    v16u8 src_above, store;
-    v8u16 sum_above;
-    v4u32 sum_top;
-    v2u64 sum;
-
-    if (is_left && is_above) {
-        src_above = LD_UB(src_top);
-
-        sum_above = __msa_hadd_u_h(src_above, src_above);
-        sum_top = __msa_hadd_u_w(sum_above, sum_above);
-        sum = __msa_hadd_u_d(sum_top, sum_top);
-        sum_top = (v4u32) __msa_pckev_w((v4i32) sum, (v4i32) sum);
-        sum = __msa_hadd_u_d(sum_top, sum_top);
-        addition = __msa_copy_u_w((v4i32) sum, 0);
-
-        for (row = 0; row < 16; row++) {
-            addition += src_left[row * src_stride_left];
-        }
-
-        addition = (addition + 16) >> 5;
-        store = (v16u8) __msa_fill_b(addition);
-    } else if (is_left) {
-        for (row = 0; row < 16; row++) {
-            addition += src_left[row * src_stride_left];
-        }
-
-        addition = (addition + 8) >> 4;
-        store = (v16u8) __msa_fill_b(addition);
-    } else if (is_above) {
-        src_above = LD_UB(src_top);
-
-        sum_above = __msa_hadd_u_h(src_above, src_above);
-        sum_top = __msa_hadd_u_w(sum_above, sum_above);
-        sum = __msa_hadd_u_d(sum_top, sum_top);
-        sum_top = (v4u32) __msa_pckev_w((v4i32) sum, (v4i32) sum);
-        sum = __msa_hadd_u_d(sum_top, sum_top);
-        sum = (v2u64) __msa_srari_d((v2i64) sum, 4);
-        store = (v16u8) __msa_splati_b((v16i8) sum, 0);
-    } else {
-        store = (v16u8) __msa_ldi_b(128);
-    }
-
-    for (row = 16; row--;) {
-        ST_UB(store, dst);
-        dst += dst_stride;
-    }
-}
-
-#define INTRA_PREDICT_VALDC_8X8_MSA(val)                         \
-static void intra_predict_##val##dc_8x8_msa(uint8_t *dst,        \
-                                            int32_t dst_stride)  \
-{                                                                \
-    uint32_t row, out;                                           \
-    v16i8 store;                                                 \
-                                                                 \
-    store = __msa_ldi_b(val);                                    \
-    out = __msa_copy_u_w((v4i32) store, 0);                      \
-                                                                 \
-    for (row = 8; row--;) {                                      \
-        SW(out, dst);                                            \
-        SW(out, (dst + 4));                                      \
-        dst += dst_stride;                                       \
-    }                                                            \
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16u8 src8, src9, src10, src11, src12, src13, src14, src15;
+
+    inp0 = src[0 * src_stride];
+    inp1 = src[1 * src_stride];
+    inp2 = src[2 * src_stride];
+    inp3 = src[3 * src_stride];
+    src0 = (v16u8) __msa_fill_b(inp0);
+    src1 = (v16u8) __msa_fill_b(inp1);
+    src2 = (v16u8) __msa_fill_b(inp2);
+    src3 = (v16u8) __msa_fill_b(inp3);
+    inp0 = src[4 * src_stride];
+    inp1 = src[5 * src_stride];
+    inp2 = src[6 * src_stride];
+    inp3 = src[7 * src_stride];
+    src4 = (v16u8) __msa_fill_b(inp0);
+    src5 = (v16u8) __msa_fill_b(inp1);
+    src6 = (v16u8) __msa_fill_b(inp2);
+    src7 = (v16u8) __msa_fill_b(inp3);
+    inp0 = src[ 8 * src_stride];
+    inp1 = src[ 9 * src_stride];
+    inp2 = src[10 * src_stride];
+    inp3 = src[11 * src_stride];
+    src8 = (v16u8) __msa_fill_b(inp0);
+    src9 = (v16u8) __msa_fill_b(inp1);
+    src10 = (v16u8) __msa_fill_b(inp2);
+    src11 = (v16u8) __msa_fill_b(inp3);
+    inp0 = src[12 * src_stride];
+    inp1 = src[13 * src_stride];
+    inp2 = src[14 * src_stride];
+    inp3 = src[15 * src_stride];
+    src12 = (v16u8) __msa_fill_b(inp0);
+    src13 = (v16u8) __msa_fill_b(inp1);
+    src14 = (v16u8) __msa_fill_b(inp2);
+    src15 = (v16u8) __msa_fill_b(inp3);
+
+    ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
+    dst += (8 * dst_stride);
+    ST_UB8(src8, src9, src10, src11, src12, src13, src14, src15,
+           dst, dst_stride);
+}
+
+#define INTRA_PREDICT_VALDC_8X8_MSA(val)                                       \
+static void intra_predict_##val##dc_8x8_msa(uint8_t *dst, int32_t dst_stride)  \
+{                                                                              \
+    v16i8 store = __msa_fill_b(val);                                           \
+    uint64_t out = __msa_copy_u_d((v2i64) store, 0);                           \
+                                                                               \
+    SD4(out, out, out, out, dst, dst_stride);                                  \
+    dst += (4 * dst_stride);                                                   \
+    SD4(out, out, out, out, dst, dst_stride);                                  \
 }
 
 INTRA_PREDICT_VALDC_8X8_MSA(127);
 INTRA_PREDICT_VALDC_8X8_MSA(129);
 
-#define INTRA_PREDICT_VALDC_16X16_MSA(val)                         \
-static void intra_predict_##val##dc_16x16_msa(uint8_t *dst,        \
-                                              int32_t dst_stride)  \
-{                                                                  \
-    uint32_t row;                                                  \
-    v16u8 store;                                                   \
-                                                                   \
-    store = (v16u8) __msa_ldi_b(val);                              \
-                                                                   \
-    for (row = 16; row--;) {                                       \
-        ST_UB(store, dst);                                         \
-        dst += dst_stride;                                         \
-    }                                                              \
+#define INTRA_PREDICT_VALDC_16X16_MSA(val)                            \
+static void intra_predict_##val##dc_16x16_msa(uint8_t *dst,           \
+                                              int32_t dst_stride)     \
+{                                                                     \
+    v16u8 out = (v16u8) __msa_fill_b(val);                            \
+                                                                      \
+    ST_UB8(out, out, out, out, out, out, out, out, dst, dst_stride);  \
+    dst += (8 * dst_stride);                                          \
+    ST_UB8(out, out, out, out, out, out, out, out, dst, dst_stride);  \
 }
 
 INTRA_PREDICT_VALDC_16X16_MSA(127);
@@ -321,8 +211,10 @@ static void intra_predict_plane_16x16_msa(uint8_t *src, int32_t stride)
     v8i16 short_multiplier = { 1, 2, 3, 4, 5, 6, 7, 8 };
     v4i32 int_multiplier = { 0, 1, 2, 3 };
     v16u8 src_top = { 0 };
-    v8i16 vec9, vec10;
+    v16u8 store0, store1;
+    v8i16 vec9, vec10, vec11, vec12;
     v4i32 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, res_add;
+    v4i32 reg0, reg1, reg2, reg3;
 
     load0 = LD(src - (stride + 1));
     load1 = LD(src - (stride + 1) + 9);
@@ -362,18 +254,28 @@ static void intra_predict_plane_16x16_msa(uint8_t *src, int32_t stride)
     vec6 = vec8 * 4;
     vec7 = vec8 * int_multiplier;
 
-    for (lpcnt = 16; lpcnt--;) {
+    for (lpcnt = 8; lpcnt--;) {
         vec0 = vec7;
+        reg0 = vec7;
         vec0 += vec4;
+        vec4 += vec5;
+        reg0 += vec4;
         vec1 = vec0 + vec6;
+        reg1 = reg0 + vec6;
         vec2 = vec1 + vec6;
+        reg2 = reg1 + vec6;
         vec3 = vec2 + vec6;
+        reg3 = reg2 + vec6;
 
         SRA_4V(vec0, vec1, vec2, vec3, 5);
+        SRA_4V(reg0, reg1, reg2, reg3, 5);
         PCKEV_H2_SH(vec1, vec0, vec3, vec2, vec9, vec10);
+        PCKEV_H2_SH(reg1, reg0, reg3, reg2, vec11, vec12);
         CLIP_SH2_0_255(vec9, vec10);
-        PCKEV_ST_SB(vec9, vec10, src);
-        src += stride;
+        CLIP_SH2_0_255(vec11, vec12);
+        PCKEV_B2_UB(vec10, vec9, vec12, vec11, store0, store1);
+        ST_UB2(store0, store1, src, stride);
+        src += 2 * stride;
 
         vec4 += vec5;
     }
@@ -381,9 +283,9 @@ static void intra_predict_plane_16x16_msa(uint8_t *src, int32_t stride)
 
 static void intra_predict_dc_4blk_8x8_msa(uint8_t *src, int32_t stride)
 {
-    uint8_t lp_cnt;
-    uint32_t src0, src1, src3, src2 = 0;
+    uint32_t src0, src1, src3, src2;
     uint32_t out0, out1, out2, out3;
+    uint64_t store0, store1;
     v16u8 src_top;
     v8u16 add;
     v4u32 sum;
@@ -393,12 +295,14 @@ static void intra_predict_dc_4blk_8x8_msa(uint8_t *src, int32_t stride)
     sum = __msa_hadd_u_w(add, add);
     src0 = __msa_copy_u_w((v4i32) sum, 0);
     src1 = __msa_copy_u_w((v4i32) sum, 1);
-
-    for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
-        src0 += src[lp_cnt * stride - 1];
-        src2 += src[(4 + lp_cnt) * stride - 1];
-    }
-
+    src0 += src[0 * stride - 1];
+    src0 += src[1 * stride - 1];
+    src0 += src[2 * stride - 1];
+    src0 += src[3 * stride - 1];
+    src2  = src[4 * stride - 1];
+    src2 += src[5 * stride - 1];
+    src2 += src[6 * stride - 1];
+    src2 += src[7 * stride - 1];
     src0 = (src0 + 4) >> 3;
     src3 = (src1 + src2 + 4) >> 3;
     src1 = (src1 + 2) >> 2;
@@ -407,69 +311,62 @@ static void intra_predict_dc_4blk_8x8_msa(uint8_t *src, int32_t stride)
     out1 = src1 * 0x01010101;
     out2 = src2 * 0x01010101;
     out3 = src3 * 0x01010101;
+    store0 = ((uint64_t) out1 << 32) | out0;
+    store1 = ((uint64_t) out3 << 32) | out2;
 
-    for (lp_cnt = 4; lp_cnt--;) {
-        SW(out0, src);
-        SW(out1, (src + 4));
-        SW(out2, (src + 4 * stride));
-        SW(out3, (src + 4 * stride + 4));
-        src += stride;
-    }
+    SD4(store0, store0, store0, store0, src, stride);
+    src += (4 * stride);
+    SD4(store1, store1, store1, store1, src, stride);
 }
 
 static void intra_predict_hor_dc_8x8_msa(uint8_t *src, int32_t stride)
 {
-    uint8_t lp_cnt;
-    uint32_t src0 = 0, src1 = 0;
+    uint32_t src0, src1;
     uint64_t out0, out1;
 
-    for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
-        src0 += src[lp_cnt * stride - 1];
-        src1 += src[(4 + lp_cnt) * stride - 1];
-    }
-
+    src0  = src[0 * stride - 1];
+    src0 += src[1 * stride - 1];
+    src0 += src[2 * stride - 1];
+    src0 += src[3 * stride - 1];
+    src1  = src[4 * stride - 1];
+    src1 += src[5 * stride - 1];
+    src1 += src[6 * stride - 1];
+    src1 += src[7 * stride - 1];
     src0 = (src0 + 2) >> 2;
     src1 = (src1 + 2) >> 2;
     out0 = src0 * 0x0101010101010101;
     out1 = src1 * 0x0101010101010101;
 
-    for (lp_cnt = 4; lp_cnt--;) {
-        SD(out0, src);
-        SD(out1, (src + 4 * stride));
-        src += stride;
-    }
+    SD4(out0, out0, out0, out0, src, stride);
+    src += (4 * stride);
+    SD4(out1, out1, out1, out1, src, stride);
 }
 
 static void intra_predict_vert_dc_8x8_msa(uint8_t *src, int32_t stride)
 {
-    uint8_t lp_cnt;
-    uint32_t out0 = 0, out1 = 0;
-    v16u8 src_top;
+    uint64_t out0;
+    v16i8 mask = { 0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0 };
+    v16u8 src_top, res0;
     v8u16 add;
     v4u32 sum;
-    v4i32 res0, res1;
 
     src_top = LD_UB(src - stride);
     add = __msa_hadd_u_h(src_top, src_top);
     sum = __msa_hadd_u_w(add, add);
     sum = (v4u32) __msa_srari_w((v4i32) sum, 2);
-    res0 = (v4i32) __msa_splati_b((v16i8) sum, 0);
-    res1 = (v4i32) __msa_splati_b((v16i8) sum, 4);
-    out0 = __msa_copy_u_w(res0, 0);
-    out1 = __msa_copy_u_w(res1, 0);
-
-    for (lp_cnt = 8; lp_cnt--;) {
-        SW(out0, src);
-        SW(out1, src + 4);
-        src += stride;
-    }
+    res0 = (v16u8) __msa_vshf_b(mask, (v16i8) sum, (v16i8) sum);
+    out0 = __msa_copy_u_d((v2i64) res0, 0);
+
+    SD4(out0, out0, out0, out0, src, stride);
+    src += (4 * stride);
+    SD4(out0, out0, out0, out0, src, stride);
 }
 
 static void intra_predict_mad_cow_dc_l0t_8x8_msa(uint8_t *src, int32_t stride)
 {
-    uint8_t lp_cnt;
-    uint32_t src0, src1, src2 = 0;
+    uint32_t src0, src1, src2;
     uint32_t out0, out1, out2;
+    uint64_t store0, store1;
     v16u8 src_top;
     v8u16 add;
     v4u32 sum;
@@ -480,30 +377,30 @@ static void intra_predict_mad_cow_dc_l0t_8x8_msa(uint8_t *src, int32_t stride)
     src0 = __msa_copy_u_w((v4i32) sum, 0);
     src1 = __msa_copy_u_w((v4i32) sum, 1);
 
-    for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
-        src2 += src[lp_cnt * stride - 1];
-    }
+    src2  = src[0 * stride - 1];
+    src2 += src[1 * stride - 1];
+    src2 += src[2 * stride - 1];
+    src2 += src[3 * stride - 1];
     src2 = (src0 + src2 + 4) >> 3;
     src0 = (src0 + 2) >> 2;
     src1 = (src1 + 2) >> 2;
     out0 = src0 * 0x01010101;
     out1 = src1 * 0x01010101;
     out2 = src2 * 0x01010101;
+    store1 = ((uint64_t) out1 << 32);
+    store0 = store1 | ((uint64_t) out2);
+    store1 = store1 | ((uint64_t) out0);
 
-    for (lp_cnt = 4; lp_cnt--;) {
-        SW(out2, src);
-        SW(out1, src + 4);
-        SW(out0, src + stride * 4);
-        SW(out1, src + stride * 4 + 4);
-        src += stride;
-    }
+    SD4(store0, store0, store0, store0, src, stride);
+    src += (4 * stride);
+    SD4(store1, store1, store1, store1, src, stride);
 }
 
 static void intra_predict_mad_cow_dc_0lt_8x8_msa(uint8_t *src, int32_t stride)
 {
-    uint8_t lp_cnt;
-    uint32_t src0, src1, src2 = 0, src3;
+    uint32_t src0, src1, src2, src3;
     uint32_t out0, out1, out2, out3;
+    uint64_t store0, store1;
     v16u8 src_top;
     v8u16 add;
     v4u32 sum;
@@ -514,10 +411,10 @@ static void intra_predict_mad_cow_dc_0lt_8x8_msa(uint8_t *src, int32_t stride)
     src0 = __msa_copy_u_w((v4i32) sum, 0);
     src1 = __msa_copy_u_w((v4i32) sum, 1);
 
-    for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
-        src2 += src[(4 + lp_cnt) * stride - 1];
-    }
-
+    src2  = src[4 * stride - 1];
+    src2 += src[5 * stride - 1];
+    src2 += src[6 * stride - 1];
+    src2 += src[7 * stride - 1];
     src0 = (src0 + 2) >> 2;
     src3 = (src1 + src2 + 4) >> 3;
     src1 = (src1 + 2) >> 2;
@@ -527,57 +424,49 @@ static void intra_predict_mad_cow_dc_0lt_8x8_msa(uint8_t *src, int32_t stride)
     out1 = src1 * 0x01010101;
     out2 = src2 * 0x01010101;
     out3 = src3 * 0x01010101;
+    store0 = ((uint64_t) out1 << 32) | out0;
+    store1 = ((uint64_t) out3 << 32) | out2;
 
-    for (lp_cnt = 4; lp_cnt--;) {
-        SW(out0, src);
-        SW(out1, src + 4);
-        SW(out2, src + stride * 4);
-        SW(out3, src + stride * 4 + 4);
-        src += stride;
-    }
+    SD4(store0, store0, store0, store0, src, stride);
+    src += (4 * stride);
+    SD4(store1, store1, store1, store1, src, stride);
 }
 
 static void intra_predict_mad_cow_dc_l00_8x8_msa(uint8_t *src, int32_t stride)
 {
-    uint8_t lp_cnt;
-    uint32_t src0 = 0;
+    uint32_t src0;
     uint64_t out0, out1;
 
-    for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
-        src0 += src[lp_cnt * stride - 1];
-    }
-
+    src0  = src[0 * stride - 1];
+    src0 += src[1 * stride - 1];
+    src0 += src[2 * stride - 1];
+    src0 += src[3 * stride - 1];
     src0 = (src0 + 2) >> 2;
     out0 = src0 * 0x0101010101010101;
     out1 = 0x8080808080808080;
 
-    for (lp_cnt = 4; lp_cnt--;) {
-        SD(out0, src);
-        SD(out1, src + stride * 4);
-        src += stride;
-    }
+    SD4(out0, out0, out0, out0, src, stride);
+    src += (4 * stride);
+    SD4(out1, out1, out1, out1, src, stride);
 }
 
 static void intra_predict_mad_cow_dc_0l0_8x8_msa(uint8_t *src, int32_t stride)
 {
-    uint8_t lp_cnt;
-    uint32_t src0 = 0;
+    uint32_t src0;
     uint64_t out0, out1;
 
-    for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
-        src0 += src[(4 + lp_cnt) * stride - 1];
-    }
-
+    src0  = src[4 * stride - 1];
+    src0 += src[5 * stride - 1];
+    src0 += src[6 * stride - 1];
+    src0 += src[7 * stride - 1];
     src0 = (src0 + 2) >> 2;
 
     out0 = 0x8080808080808080;
     out1 = src0 * 0x0101010101010101;
 
-    for (lp_cnt = 4; lp_cnt--;) {
-        SD(out0, src);
-        SD(out1, src + stride * 4);
-        src += stride;
-    }
+    SD4(out0, out0, out0, out0, src, stride);
+    src += (4 * stride);
+    SD4(out1, out1, out1, out1, src, stride);
 }
 
 void ff_h264_intra_predict_plane_8x8_msa(uint8_t *src, ptrdiff_t stride)
@@ -648,8 +537,42 @@ void ff_h264_intra_pred_dc_16x16_msa(uint8_t *src, ptrdiff_t stride)
     uint8_t *src_top = src - stride;
     uint8_t *src_left = src - 1;
     uint8_t *dst = src;
+    uint32_t addition = 0;
+    v16u8 src_above, out;
+    v8u16 sum_above;
+    v4u32 sum_top;
+    v2u64 sum;
 
-    intra_predict_dc_16x16_msa(src_top, src_left, stride, dst, stride, 1, 1);
+    src_above = LD_UB(src_top);
+
+    sum_above = __msa_hadd_u_h(src_above, src_above);
+    sum_top = __msa_hadd_u_w(sum_above, sum_above);
+    sum = __msa_hadd_u_d(sum_top, sum_top);
+    sum_top = (v4u32) __msa_pckev_w((v4i32) sum, (v4i32) sum);
+    sum = __msa_hadd_u_d(sum_top, sum_top);
+    addition = __msa_copy_u_w((v4i32) sum, 0);
+    addition += src_left[ 0 * stride];
+    addition += src_left[ 1 * stride];
+    addition += src_left[ 2 * stride];
+    addition += src_left[ 3 * stride];
+    addition += src_left[ 4 * stride];
+    addition += src_left[ 5 * stride];
+    addition += src_left[ 6 * stride];
+    addition += src_left[ 7 * stride];
+    addition += src_left[ 8 * stride];
+    addition += src_left[ 9 * stride];
+    addition += src_left[10 * stride];
+    addition += src_left[11 * stride];
+    addition += src_left[12 * stride];
+    addition += src_left[13 * stride];
+    addition += src_left[14 * stride];
+    addition += src_left[15 * stride];
+    addition = (addition + 16) >> 5;
+    out = (v16u8) __msa_fill_b(addition);
+
+    ST_UB8(out, out, out, out, out, out, out, out, dst, stride);
+    dst += (8 * stride);
+    ST_UB8(out, out, out, out, out, out, out, out, dst, stride);
 }
 
 void ff_h264_intra_pred_vert_16x16_msa(uint8_t *src, ptrdiff_t stride)
@@ -668,38 +591,82 @@ void ff_h264_intra_pred_horiz_16x16_msa(uint8_t *src, ptrdiff_t stride)
 
 void ff_h264_intra_pred_dc_left_16x16_msa(uint8_t *src, ptrdiff_t stride)
 {
-    uint8_t *src_top = src - stride;
     uint8_t *src_left = src - 1;
     uint8_t *dst = src;
-
-    intra_predict_dc_16x16_msa(src_top, src_left, stride, dst, stride, 0, 1);
+    uint32_t addition;
+    v16u8 out;
+
+    addition  = src_left[ 0 * stride];
+    addition += src_left[ 1 * stride];
+    addition += src_left[ 2 * stride];
+    addition += src_left[ 3 * stride];
+    addition += src_left[ 4 * stride];
+    addition += src_left[ 5 * stride];
+    addition += src_left[ 6 * stride];
+    addition += src_left[ 7 * stride];
+    addition += src_left[ 8 * stride];
+    addition += src_left[ 9 * stride];
+    addition += src_left[10 * stride];
+    addition += src_left[11 * stride];
+    addition += src_left[12 * stride];
+    addition += src_left[13 * stride];
+    addition += src_left[14 * stride];
+    addition += src_left[15 * stride];
+
+    addition = (addition + 8) >> 4;
+    out = (v16u8) __msa_fill_b(addition);
+
+    ST_UB8(out, out, out, out, out, out, out, out, dst, stride);
+    dst += (8 * stride);
+    ST_UB8(out, out, out, out, out, out, out, out, dst, stride);
 }
 
 void ff_h264_intra_pred_dc_top_16x16_msa(uint8_t *src, ptrdiff_t stride)
 {
     uint8_t *src_top = src - stride;
-    uint8_t *src_left = src - 1;
     uint8_t *dst = src;
+    v16u8 src_above, out;
+    v8u16 sum_above;
+    v4u32 sum_top;
+    v2u64 sum;
 
-    intra_predict_dc_16x16_msa(src_top, src_left, stride, dst, stride, 1, 0);
+    src_above = LD_UB(src_top);
+
+    sum_above = __msa_hadd_u_h(src_above, src_above);
+    sum_top = __msa_hadd_u_w(sum_above, sum_above);
+    sum = __msa_hadd_u_d(sum_top, sum_top);
+    sum_top = (v4u32) __msa_pckev_w((v4i32) sum, (v4i32) sum);
+    sum = __msa_hadd_u_d(sum_top, sum_top);
+    sum = (v2u64) __msa_srari_d((v2i64) sum, 4);
+    out = (v16u8) __msa_splati_b((v16i8) sum, 0);
+
+    ST_UB8(out, out, out, out, out, out, out, out, dst, stride);
+    dst += (8 * stride);
+    ST_UB8(out, out, out, out, out, out, out, out, dst, stride);
 }
 
 void ff_h264_intra_pred_dc_128_8x8_msa(uint8_t *src, ptrdiff_t stride)
 {
-    uint8_t *src_top = src - stride;
-    uint8_t *src_left = src - 1;
-    uint8_t *dst = src;
+    uint64_t out;
+    v16u8 store;
 
-    intra_predict_dc_8x8_msa(src_top, src_left, stride, dst, stride, 0, 0);
+    store = (v16u8) __msa_fill_b(128);
+    out = __msa_copy_u_d((v2i64) store, 0);
+
+    SD4(out, out, out, out, src, stride);
+    src += (4 * stride);
+    SD4(out, out, out, out, src, stride);
 }
 
 void ff_h264_intra_pred_dc_128_16x16_msa(uint8_t *src, ptrdiff_t stride)
 {
-    uint8_t *src_top = src - stride;
-    uint8_t *src_left = src - 1;
-    uint8_t *dst = src;
+    v16u8 out;
+
+    out = (v16u8) __msa_fill_b(128);
 
-    intra_predict_dc_16x16_msa(src_top, src_left, stride, dst, stride, 0, 0);
+    ST_UB8(out, out, out, out, out, out, out, out, src, stride);
+    src += (8 * stride);
+    ST_UB8(out, out, out, out, out, out, out, out, src, stride);
 }
 
 void ff_vp8_pred8x8_127_dc_8_msa(uint8_t *src, ptrdiff_t stride)
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/h264qpel_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/h264qpel_msa.c
index c38f1f7a420..a22a4828c6b 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/h264qpel_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/h264qpel_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Parag Salasakar (Parag.Salasakar@imgtec.com)
+ * Copyright (c) 2015 -2017 Parag Salasakar (Parag.Salasakar@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -45,25 +45,6 @@
     out0_m;                                                              \
 } )
 
-#define AVC_HORZ_FILTER_SH(in, mask0, mask1, mask2)     \
-( {                                                     \
-    v8i16 out0_m, out1_m;                               \
-    v16i8 tmp0_m, tmp1_m;                               \
-    v16i8 minus5b = __msa_ldi_b(-5);                    \
-    v16i8 plus20b = __msa_ldi_b(20);                    \
-                                                        \
-    tmp0_m = __msa_vshf_b((v16i8) mask0, in, in);       \
-    out0_m = __msa_hadd_s_h(tmp0_m, tmp0_m);            \
-                                                        \
-    tmp0_m = __msa_vshf_b((v16i8) mask1, in, in);       \
-    out0_m = __msa_dpadd_s_h(out0_m, minus5b, tmp0_m);  \
-                                                        \
-    tmp1_m = __msa_vshf_b((v16i8) (mask2), in, in);     \
-    out1_m = __msa_dpadd_s_h(out0_m, plus20b, tmp1_m);  \
-                                                        \
-    out1_m;                                             \
-} )
-
 static const uint8_t luma_mask_arr[16 * 8] = {
     /* 8 width cases */
     0, 5, 1, 6, 2, 7, 3, 8, 4, 9, 5, 10, 6, 11, 7, 12,
@@ -148,861 +129,228 @@ static const uint8_t luma_mask_arr[16 * 8] = {
     hz_out_m;                                                                \
 } )
 
-static void avc_luma_hz_4w_msa(const uint8_t *src, int32_t src_stride,
-                               uint8_t *dst, int32_t dst_stride,
-                               int32_t height)
+#define AVC_HORZ_FILTER_SH(in0, in1, mask0, mask1, mask2)  \
+( {                                                        \
+    v8i16 out0_m;                                          \
+    v16i8 tmp0_m;                                          \
+    v16i8 minus5b = __msa_ldi_b(-5);                       \
+    v16i8 plus20b = __msa_ldi_b(20);                       \
+                                                           \
+    tmp0_m = __msa_vshf_b((v16i8) mask0, in1, in0);        \
+    out0_m = __msa_hadd_s_h(tmp0_m, tmp0_m);               \
+                                                           \
+    tmp0_m = __msa_vshf_b((v16i8) mask1, in1, in0);        \
+    out0_m = __msa_dpadd_s_h(out0_m, minus5b, tmp0_m);     \
+                                                           \
+    tmp0_m = __msa_vshf_b((v16i8) mask2, in1, in0);        \
+    out0_m = __msa_dpadd_s_h(out0_m, plus20b, tmp0_m);     \
+                                                           \
+    out0_m;                                                \
+} )
+
+#define AVC_DOT_SH3_SH(in0, in1, in2, coeff0, coeff1, coeff2)       \
+( {                                                                 \
+    v8i16 out0_m;                                                   \
+                                                                    \
+    out0_m = __msa_dotp_s_h((v16i8) in0, (v16i8) coeff0);           \
+    out0_m = __msa_dpadd_s_h(out0_m, (v16i8) in1, (v16i8) coeff1);  \
+    out0_m = __msa_dpadd_s_h(out0_m, (v16i8) in2, (v16i8) coeff2);  \
+                                                                    \
+    out0_m;                                                         \
+} )
+
+#define AVC_DOT_SW3_SW(in0, in1, in2, coeff0, coeff1, coeff2)       \
+( {                                                                 \
+    v4i32 out0_m;                                                   \
+                                                                    \
+    out0_m = __msa_dotp_s_w((v8i16) in0, (v8i16) coeff0);           \
+    out0_m = __msa_dpadd_s_w(out0_m, (v8i16) in1, (v8i16) coeff1);  \
+    out0_m = __msa_dpadd_s_w(out0_m, (v8i16) in2, (v8i16) coeff2);  \
+    out0_m = __msa_srari_w(out0_m, 10);                             \
+    out0_m = __msa_sat_s_w(out0_m, 7);                              \
+    out0_m;                                                         \
+} )
+
+static void avc_luma_mid_4w_msa(const uint8_t *src, int32_t src_stride,
+                                uint8_t *dst, int32_t dst_stride,
+                                int32_t height)
 {
     uint32_t loop_cnt;
-    v16i8 src0, src1, src2, src3;
-    v8i16 res0, res1;
-    v16u8 out;
+    v16i8 src0, src1, src2, src3, src4;
     v16i8 mask0, mask1, mask2;
-    v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
-    v16i8 minus5b = __msa_ldi_b(-5);
-    v16i8 plus20b = __msa_ldi_b(20);
+    v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
+    v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
+    v8i16 dst0, dst1, dst2, dst3;
 
     LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
+    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
+    src += (5 * src_stride);
 
-        XORI_B4_128_SB(src0, src1, src2, src3);
-        VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
-        HADD_SB2_SH(vec0, vec1, res0, res1);
-        VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec2, vec3);
-        DPADD_SB2_SH(vec2, vec3, minus5b, minus5b, res0, res1);
-        VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec4, vec5);
-        DPADD_SB2_SH(vec4, vec5, plus20b, plus20b, res0, res1);
-        SRARI_H2_SH(res0, res1, 5);
-        SAT_SH2_SH(res0, res1, 7);
-        out = PCKEV_XORI128_UB(res0, res1);
-        ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
-        dst += (4 * dst_stride);
-    }
-}
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
 
-static void avc_luma_hz_8w_msa(const uint8_t *src, int32_t src_stride,
-                               uint8_t *dst, int32_t dst_stride,
-                               int32_t height)
-{
-    uint32_t loop_cnt;
-    v16i8 src0, src1, src2, src3;
-    v8i16 res0, res1, res2, res3;
-    v16i8 mask0, mask1, mask2;
-    v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
-    v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
-    v16i8 minus5b = __msa_ldi_b(-5);
-    v16i8 plus20b = __msa_ldi_b(20);
-    v16u8 out0, out1;
+    hz_out0 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
+                                                          mask0, mask1, mask2);
+    hz_out2 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
+                                                          mask0, mask1, mask2);
 
-    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
+    PCKOD_D2_SH(hz_out0, hz_out0, hz_out2, hz_out2, hz_out1, hz_out3);
+
+    hz_out4 = AVC_HORZ_FILTER_SH(src4, src4, mask0, mask1, mask2);
 
     for (loop_cnt = (height >> 2); loop_cnt--;) {
         LD_SB4(src, src_stride, src0, src1, src2, src3);
         src += (4 * src_stride);
 
         XORI_B4_128_SB(src0, src1, src2, src3);
-        VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
-        VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
-        HADD_SB4_SH(vec0, vec1, vec2, vec3, res0, res1, res2, res3);
-        VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec4, vec5);
-        VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec6, vec7);
-        DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
-                     res0, res1, res2, res3);
-        VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec8, vec9);
-        VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec10, vec11);
-        DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b,
-                     plus20b, res0, res1, res2, res3);
-        SRARI_H4_SH(res0, res1, res2, res3, 5);
-        SAT_SH4_SH(res0, res1, res2, res3, 7);
-        out0 = PCKEV_XORI128_UB(res0, res1);
-        out1 = PCKEV_XORI128_UB(res2, res3);
-        ST8x4_UB(out0, out1, dst, dst_stride);
+
+        hz_out5 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
+                                                              mask0, mask1,
+                                                              mask2);
+        hz_out7 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
+                                                              mask0, mask1,
+                                                              mask2);
+
+        PCKOD_D2_SH(hz_out5, hz_out5, hz_out7, hz_out7, hz_out6, hz_out8);
+
+        dst0 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out0, hz_out1, hz_out2,
+                                                 hz_out3, hz_out4, hz_out5);
+        dst1 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out1, hz_out2, hz_out3,
+                                                 hz_out4, hz_out5, hz_out6);
+        dst2 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out2, hz_out3, hz_out4,
+                                                 hz_out5, hz_out6, hz_out7);
+        dst3 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out3, hz_out4, hz_out5,
+                                                 hz_out6, hz_out7, hz_out8);
+
+        PCKEV_B2_SB(dst1, dst0, dst3, dst2, src0, src1);
+        XORI_B2_128_SB(src0, src1);
+
+        ST4x4_UB(src0, src1, 0, 2, 0, 2, dst, dst_stride);
+
         dst += (4 * dst_stride);
+
+        hz_out0 = hz_out4;
+        hz_out1 = hz_out5;
+        hz_out2 = hz_out6;
+        hz_out3 = hz_out7;
+        hz_out4 = hz_out8;
     }
 }
 
-static void avc_luma_hz_16w_msa(const uint8_t *src, int32_t src_stride,
+static void avc_luma_mid_8w_msa(const uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
                                 int32_t height)
 {
     uint32_t loop_cnt;
-    v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
-    v8i16 res0, res1, res2, res3, res4, res5, res6, res7;
+    v16i8 src0, src1, src2, src3, src4;
     v16i8 mask0, mask1, mask2;
-    v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
-    v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
-    v16i8 minus5b = __msa_ldi_b(-5);
-    v16i8 plus20b = __msa_ldi_b(20);
+    v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
+    v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
+    v8i16 dst0, dst1, dst2, dst3;
+    v16u8 out0, out1;
 
     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
 
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB2(src, 8, src0, src1);
-        src += src_stride;
-        LD_SB2(src, 8, src2, src3);
-        src += src_stride;
+    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
+    src += (5 * src_stride);
 
-        XORI_B4_128_SB(src0, src1, src2, src3);
-        VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec3);
-        VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec6, vec9);
-        VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec1, vec4);
-        VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec7, vec10);
-        VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec2, vec5);
-        VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec8, vec11);
-        HADD_SB4_SH(vec0, vec3, vec6, vec9, res0, res1, res2, res3);
-        DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
-                     minus5b, res0, res1, res2, res3);
-        DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
-                     plus20b, res0, res1, res2, res3);
+    hz_out0 = AVC_HORZ_FILTER_SH(src0, src0, mask0, mask1, mask2);
+    hz_out1 = AVC_HORZ_FILTER_SH(src1, src1, mask0, mask1, mask2);
+    hz_out2 = AVC_HORZ_FILTER_SH(src2, src2, mask0, mask1, mask2);
+    hz_out3 = AVC_HORZ_FILTER_SH(src3, src3, mask0, mask1, mask2);
+    hz_out4 = AVC_HORZ_FILTER_SH(src4, src4, mask0, mask1, mask2);
 
-        LD_SB2(src, 8, src4, src5);
-        src += src_stride;
-        LD_SB2(src, 8, src6, src7);
-        src += src_stride;
+    for (loop_cnt = (height >> 2); loop_cnt--;) {
+        LD_SB4(src, src_stride, src0, src1, src2, src3);
+        XORI_B4_128_SB(src0, src1, src2, src3);
+        src += (4 * src_stride);
 
-        XORI_B4_128_SB(src4, src5, src6, src7);
-        VSHF_B2_SB(src4, src4, src5, src5, mask0, mask0, vec0, vec3);
-        VSHF_B2_SB(src6, src6, src7, src7, mask0, mask0, vec6, vec9);
-        VSHF_B2_SB(src4, src4, src5, src5, mask1, mask1, vec1, vec4);
-        VSHF_B2_SB(src6, src6, src7, src7, mask1, mask1, vec7, vec10);
-        VSHF_B2_SB(src4, src4, src5, src5, mask2, mask2, vec2, vec5);
-        VSHF_B2_SB(src6, src6, src7, src7, mask2, mask2, vec8, vec11);
-        HADD_SB4_SH(vec0, vec3, vec6, vec9, res4, res5, res6, res7);
-        DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
-                     minus5b, res4, res5, res6, res7);
-        DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
-                     plus20b, res4, res5, res6, res7);
-        SRARI_H4_SH(res0, res1, res2, res3, 5);
-        SRARI_H4_SH(res4, res5, res6, res7, 5);
-        SAT_SH4_SH(res0, res1, res2, res3, 7);
-        SAT_SH4_SH(res4, res5, res6, res7, 7);
-        PCKEV_B4_SB(res1, res0, res3, res2, res5, res4, res7, res6,
-                    vec0, vec1, vec2, vec3);
-        XORI_B4_128_SB(vec0, vec1, vec2, vec3);
+        hz_out5 = AVC_HORZ_FILTER_SH(src0, src0, mask0, mask1, mask2);
+        hz_out6 = AVC_HORZ_FILTER_SH(src1, src1, mask0, mask1, mask2);
+        hz_out7 = AVC_HORZ_FILTER_SH(src2, src2, mask0, mask1, mask2);
+        hz_out8 = AVC_HORZ_FILTER_SH(src3, src3, mask0, mask1, mask2);
+        dst0 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out0, hz_out1, hz_out2,
+                                               hz_out3, hz_out4, hz_out5);
+        dst1 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out1, hz_out2, hz_out3,
+                                               hz_out4, hz_out5, hz_out6);
+        dst2 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out2, hz_out3, hz_out4,
+                                               hz_out5, hz_out6, hz_out7);
+        dst3 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out3, hz_out4, hz_out5,
+                                               hz_out6, hz_out7, hz_out8);
+        out0 = PCKEV_XORI128_UB(dst0, dst1);
+        out1 = PCKEV_XORI128_UB(dst2, dst3);
+        ST8x4_UB(out0, out1, dst, dst_stride);
 
-        ST_SB4(vec0, vec1, vec2, vec3, dst, dst_stride);
         dst += (4 * dst_stride);
+        hz_out3 = hz_out7;
+        hz_out1 = hz_out5;
+        hz_out5 = hz_out4;
+        hz_out4 = hz_out8;
+        hz_out2 = hz_out6;
+        hz_out0 = hz_out5;
     }
 }
 
-static void avc_luma_hz_qrt_4w_msa(const uint8_t *src, int32_t src_stride,
-                                   uint8_t *dst, int32_t dst_stride,
-                                   int32_t height, uint8_t hor_offset)
+static void avc_luma_mid_16w_msa(const uint8_t *src, int32_t src_stride,
+                                 uint8_t *dst, int32_t dst_stride,
+                                 int32_t height)
 {
-    uint8_t slide;
-    uint32_t loop_cnt;
-    v16i8 src0, src1, src2, src3;
-    v8i16 res0, res1;
-    v16i8 res, mask0, mask1, mask2;
-    v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
-    v16i8 minus5b = __msa_ldi_b(-5);
-    v16i8 plus20b = __msa_ldi_b(20);
+    uint32_t multiple8_cnt;
 
-    LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
-    slide = 2 + hor_offset;
+    for (multiple8_cnt = 2; multiple8_cnt--;) {
+        avc_luma_mid_8w_msa(src, src_stride, dst, dst_stride, height);
+        src += 8;
+        dst += 8;
+    }
+}
 
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
+static void avc_luma_midh_qrt_4w_msa(const uint8_t *src, int32_t src_stride,
+                                     uint8_t *dst, int32_t dst_stride,
+                                     int32_t height, uint8_t horiz_offset)
+{
+    uint32_t row;
+    v16i8 src0, src1, src2, src3, src4, src5, src6;
+    v8i16 vt_res0, vt_res1, vt_res2, vt_res3;
+    v4i32 hz_res0, hz_res1;
+    v8i16 dst0, dst1;
+    v8i16 shf_vec0, shf_vec1, shf_vec2, shf_vec3, shf_vec4, shf_vec5;
+    v8i16 mask0 = { 0, 5, 1, 6, 2, 7, 3, 8 };
+    v8i16 mask1 = { 1, 4, 2, 5, 3, 6, 4, 7 };
+    v8i16 mask2 = { 2, 3, 3, 4, 4, 5, 5, 6 };
+    v8i16 minus5h = __msa_ldi_h(-5);
+    v8i16 plus20h = __msa_ldi_h(20);
+    v8i16 zeros = { 0 };
+    v16u8 out;
 
-        XORI_B4_128_SB(src0, src1, src2, src3);
-        VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
-        HADD_SB2_SH(vec0, vec1, res0, res1);
-        VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec2, vec3);
-        DPADD_SB2_SH(vec2, vec3, minus5b, minus5b, res0, res1);
-        VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec4, vec5);
-        DPADD_SB2_SH(vec4, vec5, plus20b, plus20b, res0, res1);
-        SRARI_H2_SH(res0, res1, 5);
-        SAT_SH2_SH(res0, res1, 7);
+    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
+    src += (5 * src_stride);
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
 
-        res = __msa_pckev_b((v16i8) res1, (v16i8) res0);
-        src0 = __msa_sld_b(src0, src0, slide);
-        src1 = __msa_sld_b(src1, src1, slide);
-        src2 = __msa_sld_b(src2, src2, slide);
-        src3 = __msa_sld_b(src3, src3, slide);
-        src0 = (v16i8) __msa_insve_w((v4i32) src0, 1, (v4i32) src1);
-        src1 = (v16i8) __msa_insve_w((v4i32) src2, 1, (v4i32) src3);
-        src0 = (v16i8) __msa_insve_d((v2i64) src0, 1, (v2i64) src1);
-        res = __msa_aver_s_b(res, src0);
-        res = (v16i8) __msa_xori_b((v16u8) res, 128);
+    for (row = (height >> 1); row--;) {
+        LD_SB2(src, src_stride, src5, src6);
+        src += (2 * src_stride);
 
-        ST4x4_UB(res, res, 0, 1, 2, 3, dst, dst_stride);
-        dst += (4 * dst_stride);
-    }
-}
+        XORI_B2_128_SB(src5, src6);
+        AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src0, src1, src2, src3, src4, src5,
+                                        vt_res0, vt_res1);
+        AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src1, src2, src3, src4, src5, src6,
+                                        vt_res2, vt_res3);
+        VSHF_H3_SH(vt_res0, vt_res1, vt_res0, vt_res1, vt_res0, vt_res1,
+                   mask0, mask1, mask2, shf_vec0, shf_vec1, shf_vec2);
+        VSHF_H3_SH(vt_res2, vt_res3, vt_res2, vt_res3, vt_res2, vt_res3,
+                   mask0, mask1, mask2, shf_vec3, shf_vec4, shf_vec5);
+        hz_res0 = __msa_hadd_s_w(shf_vec0, shf_vec0);
+        DPADD_SH2_SW(shf_vec1, shf_vec2, minus5h, plus20h, hz_res0, hz_res0);
+        hz_res1 = __msa_hadd_s_w(shf_vec3, shf_vec3);
+        DPADD_SH2_SW(shf_vec4, shf_vec5, minus5h, plus20h, hz_res1, hz_res1);
 
-static void avc_luma_hz_qrt_8w_msa(const uint8_t *src, int32_t src_stride,
-                                   uint8_t *dst, int32_t dst_stride,
-                                   int32_t height, uint8_t hor_offset)
-{
-    uint8_t slide;
-    uint32_t loop_cnt;
-    v16i8 src0, src1, src2, src3;
-    v16i8 tmp0, tmp1;
-    v8i16 res0, res1, res2, res3;
-    v16i8 mask0, mask1, mask2;
-    v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
-    v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
-    v16i8 minus5b = __msa_ldi_b(-5);
-    v16i8 plus20b = __msa_ldi_b(20);
+        SRARI_W2_SW(hz_res0, hz_res1, 10);
+        SAT_SW2_SW(hz_res0, hz_res1, 7);
 
-    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
-    slide = 2 + hor_offset;
+        dst0 = __msa_srari_h(shf_vec2, 5);
+        dst1 = __msa_srari_h(shf_vec5, 5);
 
-    for (loop_cnt = height >> 2; loop_cnt--;) {
-        LD_SB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
-
-        XORI_B4_128_SB(src0, src1, src2, src3);
-        VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
-        VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
-        HADD_SB4_SH(vec0, vec1, vec2, vec3, res0, res1, res2, res3);
-        VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec4, vec5);
-        VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec6, vec7);
-        DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
-                     res0, res1, res2, res3);
-        VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec8, vec9);
-        VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec10, vec11);
-        DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b,
-                     plus20b, res0, res1, res2, res3);
-
-        src0 = __msa_sld_b(src0, src0, slide);
-        src1 = __msa_sld_b(src1, src1, slide);
-        src2 = __msa_sld_b(src2, src2, slide);
-        src3 = __msa_sld_b(src3, src3, slide);
-
-        SRARI_H4_SH(res0, res1, res2, res3, 5);
-        SAT_SH4_SH(res0, res1, res2, res3, 7);
-        PCKEV_B2_SB(res1, res0, res3, res2, tmp0, tmp1);
-        PCKEV_D2_SB(src1, src0, src3, src2, src0, src1);
-
-        tmp0 = __msa_aver_s_b(tmp0, src0);
-        tmp1 = __msa_aver_s_b(tmp1, src1);
-
-        XORI_B2_128_SB(tmp0, tmp1);
-        ST8x4_UB(tmp0, tmp1, dst, dst_stride);
-
-        dst += (4 * dst_stride);
-    }
-}
-
-static void avc_luma_hz_qrt_16w_msa(const uint8_t *src, int32_t src_stride,
-                                    uint8_t *dst, int32_t dst_stride,
-                                    int32_t height, uint8_t hor_offset)
-{
-    uint32_t loop_cnt;
-    v16i8 dst0, dst1;
-    v16i8 src0, src1, src2, src3;
-    v16i8 mask0, mask1, mask2, vshf;
-    v8i16 res0, res1, res2, res3;
-    v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
-    v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
-    v16i8 minus5b = __msa_ldi_b(-5);
-    v16i8 plus20b = __msa_ldi_b(20);
-
-    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
-
-    if (hor_offset) {
-        vshf = LD_SB(&luma_mask_arr[16 + 96]);
-    } else {
-        vshf = LD_SB(&luma_mask_arr[96]);
-    }
-
-    for (loop_cnt = height >> 1; loop_cnt--;) {
-        LD_SB2(src, 8, src0, src1);
-        src += src_stride;
-        LD_SB2(src, 8, src2, src3);
-        src += src_stride;
-
-        XORI_B4_128_SB(src0, src1, src2, src3);
-        VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec3);
-        VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec6, vec9);
-        VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec1, vec4);
-        VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec7, vec10);
-        VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec2, vec5);
-        VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec8, vec11);
-        HADD_SB4_SH(vec0, vec3, vec6, vec9, res0, res1, res2, res3);
-        DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
-                     minus5b, res0, res1, res2, res3);
-        DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
-                     plus20b, res0, res1, res2, res3);
-        VSHF_B2_SB(src0, src1, src2, src3, vshf, vshf, src0, src2);
-        SRARI_H4_SH(res0, res1, res2, res3, 5);
-        SAT_SH4_SH(res0, res1, res2, res3, 7);
-        PCKEV_B2_SB(res1, res0, res3, res2, dst0, dst1);
-
-        dst0 = __msa_aver_s_b(dst0, src0);
-        dst1 = __msa_aver_s_b(dst1, src2);
-
-        XORI_B2_128_SB(dst0, dst1);
-
-        ST_SB2(dst0, dst1, dst, dst_stride);
-        dst += (2 * dst_stride);
-    }
-}
-
-static void avc_luma_vt_4w_msa(const uint8_t *src, int32_t src_stride,
-                               uint8_t *dst, int32_t dst_stride,
-                               int32_t height)
-{
-    int32_t loop_cnt;
-    int16_t filt_const0 = 0xfb01;
-    int16_t filt_const1 = 0x1414;
-    int16_t filt_const2 = 0x1fb;
-    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
-    v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
-    v16i8 src87_r, src2110, src4332, src6554, src8776;
-    v16i8 filt0, filt1, filt2;
-    v8i16 out10, out32;
-    v16u8 out;
-
-    filt0 = (v16i8) __msa_fill_h(filt_const0);
-    filt1 = (v16i8) __msa_fill_h(filt_const1);
-    filt2 = (v16i8) __msa_fill_h(filt_const2);
-
-    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-
-    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
-               src10_r, src21_r, src32_r, src43_r);
-    ILVR_D2_SB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
-    XORI_B2_128_SB(src2110, src4332);
-
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src5, src6, src7, src8);
-        src += (4 * src_stride);
-
-        ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
-                   src54_r, src65_r, src76_r, src87_r);
-        ILVR_D2_SB(src65_r, src54_r, src87_r, src76_r, src6554, src8776);
-        XORI_B2_128_SB(src6554, src8776);
-        out10 = DPADD_SH3_SH(src2110, src4332, src6554, filt0, filt1, filt2);
-        out32 = DPADD_SH3_SH(src4332, src6554, src8776, filt0, filt1, filt2);
-        SRARI_H2_SH(out10, out32, 5);
-        SAT_SH2_SH(out10, out32, 7);
-        out = PCKEV_XORI128_UB(out10, out32);
-        ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
-
-        dst += (4 * dst_stride);
-        src2110 = src6554;
-        src4332 = src8776;
-        src4 = src8;
-    }
-}
-
-static void avc_luma_vt_8w_msa(const uint8_t *src, int32_t src_stride,
-                               uint8_t *dst, int32_t dst_stride,
-                               int32_t height)
-{
-    int32_t loop_cnt;
-    int16_t filt_const0 = 0xfb01;
-    int16_t filt_const1 = 0x1414;
-    int16_t filt_const2 = 0x1fb;
-    v16i8 src0, src1, src2, src3, src4, src7, src8, src9, src10;
-    v16i8 src10_r, src32_r, src76_r, src98_r;
-    v16i8 src21_r, src43_r, src87_r, src109_r;
-    v8i16 out0_r, out1_r, out2_r, out3_r;
-    v16i8 filt0, filt1, filt2;
-    v16u8 out0, out1;
-
-    filt0 = (v16i8) __msa_fill_h(filt_const0);
-    filt1 = (v16i8) __msa_fill_h(filt_const1);
-    filt2 = (v16i8) __msa_fill_h(filt_const2);
-
-    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-
-    XORI_B5_128_SB(src0, src1, src2, src3, src4);
-    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
-               src10_r, src21_r, src32_r, src43_r);
-
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src7, src8, src9, src10);
-        src += (4 * src_stride);
-
-        XORI_B4_128_SB(src7, src8, src9, src10);
-        ILVR_B4_SB(src7, src4, src8, src7, src9, src8, src10, src9,
-                   src76_r, src87_r, src98_r, src109_r);
-        out0_r = DPADD_SH3_SH(src10_r, src32_r, src76_r, filt0, filt1, filt2);
-        out1_r = DPADD_SH3_SH(src21_r, src43_r, src87_r, filt0, filt1, filt2);
-        out2_r = DPADD_SH3_SH(src32_r, src76_r, src98_r, filt0, filt1, filt2);
-        out3_r = DPADD_SH3_SH(src43_r, src87_r, src109_r, filt0, filt1, filt2);
-        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
-        SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
-        out0 = PCKEV_XORI128_UB(out0_r, out1_r);
-        out1 = PCKEV_XORI128_UB(out2_r, out3_r);
-        ST8x4_UB(out0, out1, dst, dst_stride);
-        dst += (4 * dst_stride);
-
-        src10_r = src76_r;
-        src32_r = src98_r;
-        src21_r = src87_r;
-        src43_r = src109_r;
-        src4 = src10;
-    }
-}
-
-static void avc_luma_vt_16w_msa(const uint8_t *src, int32_t src_stride,
-                                uint8_t *dst, int32_t dst_stride,
-                                int32_t height)
-{
-    int32_t loop_cnt;
-    int16_t filt_const0 = 0xfb01;
-    int16_t filt_const1 = 0x1414;
-    int16_t filt_const2 = 0x1fb;
-    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
-    v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
-    v16i8 src87_r, src10_l, src32_l, src54_l, src76_l, src21_l, src43_l;
-    v16i8 src65_l, src87_l;
-    v8i16 out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
-    v16u8 res0, res1, res2, res3;
-    v16i8 filt0, filt1, filt2;
-
-    filt0 = (v16i8) __msa_fill_h(filt_const0);
-    filt1 = (v16i8) __msa_fill_h(filt_const1);
-    filt2 = (v16i8) __msa_fill_h(filt_const2);
-
-    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-
-    XORI_B5_128_SB(src0, src1, src2, src3, src4);
-    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
-               src10_r, src21_r, src32_r, src43_r);
-    ILVL_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
-               src10_l, src21_l, src32_l, src43_l);
-
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src5, src6, src7, src8);
-        src += (4 * src_stride);
-
-        XORI_B4_128_SB(src5, src6, src7, src8);
-        ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
-                   src54_r, src65_r, src76_r, src87_r);
-        ILVL_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
-                   src54_l, src65_l, src76_l, src87_l);
-        out0_r = DPADD_SH3_SH(src10_r, src32_r, src54_r, filt0, filt1, filt2);
-        out1_r = DPADD_SH3_SH(src21_r, src43_r, src65_r, filt0, filt1, filt2);
-        out2_r = DPADD_SH3_SH(src32_r, src54_r, src76_r, filt0, filt1, filt2);
-        out3_r = DPADD_SH3_SH(src43_r, src65_r, src87_r, filt0, filt1, filt2);
-        out0_l = DPADD_SH3_SH(src10_l, src32_l, src54_l, filt0, filt1, filt2);
-        out1_l = DPADD_SH3_SH(src21_l, src43_l, src65_l, filt0, filt1, filt2);
-        out2_l = DPADD_SH3_SH(src32_l, src54_l, src76_l, filt0, filt1, filt2);
-        out3_l = DPADD_SH3_SH(src43_l, src65_l, src87_l, filt0, filt1, filt2);
-        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
-        SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
-        SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 5);
-        SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
-        PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
-                    out3_r, res0, res1, res2, res3);
-        XORI_B4_128_UB(res0, res1, res2, res3);
-
-        ST_UB4(res0, res1, res2, res3, dst, dst_stride);
-        dst += (4 * dst_stride);
-
-        src10_r = src54_r;
-        src32_r = src76_r;
-        src21_r = src65_r;
-        src43_r = src87_r;
-        src10_l = src54_l;
-        src32_l = src76_l;
-        src21_l = src65_l;
-        src43_l = src87_l;
-        src4 = src8;
-    }
-}
-
-static void avc_luma_vt_qrt_4w_msa(const uint8_t *src, int32_t src_stride,
-                                   uint8_t *dst, int32_t dst_stride,
-                                   int32_t height, uint8_t ver_offset)
-{
-    int32_t loop_cnt;
-    int16_t filt_const0 = 0xfb01;
-    int16_t filt_const1 = 0x1414;
-    int16_t filt_const2 = 0x1fb;
-    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
-    v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
-    v16i8 src87_r, src2110, src4332, src6554, src8776;
-    v8i16 out10, out32;
-    v16i8 filt0, filt1, filt2;
-    v16u8 out;
-
-    filt0 = (v16i8) __msa_fill_h(filt_const0);
-    filt1 = (v16i8) __msa_fill_h(filt_const1);
-    filt2 = (v16i8) __msa_fill_h(filt_const2);
-
-    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-
-    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
-               src10_r, src21_r, src32_r, src43_r);
-    ILVR_D2_SB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
-    XORI_B2_128_SB(src2110, src4332);
-
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src5, src6, src7, src8);
-        src += (4 * src_stride);
-
-        ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
-                   src54_r, src65_r, src76_r, src87_r);
-        ILVR_D2_SB(src65_r, src54_r, src87_r, src76_r, src6554, src8776);
-        XORI_B2_128_SB(src6554, src8776);
-        out10 = DPADD_SH3_SH(src2110, src4332, src6554, filt0, filt1, filt2);
-        out32 = DPADD_SH3_SH(src4332, src6554, src8776, filt0, filt1, filt2);
-        SRARI_H2_SH(out10, out32, 5);
-        SAT_SH2_SH(out10, out32, 7);
-
-        out = PCKEV_XORI128_UB(out10, out32);
-
-        if (ver_offset) {
-            src32_r = (v16i8) __msa_insve_w((v4i32) src3, 1, (v4i32) src4);
-            src54_r = (v16i8) __msa_insve_w((v4i32) src5, 1, (v4i32) src6);
-        } else {
-            src32_r = (v16i8) __msa_insve_w((v4i32) src2, 1, (v4i32) src3);
-            src54_r = (v16i8) __msa_insve_w((v4i32) src4, 1, (v4i32) src5);
-        }
-
-        src32_r = (v16i8) __msa_insve_d((v2i64) src32_r, 1, (v2i64) src54_r);
-        out = __msa_aver_u_b(out, (v16u8) src32_r);
-
-        ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
-        dst += (4 * dst_stride);
-        src2110 = src6554;
-        src4332 = src8776;
-        src2 = src6;
-        src3 = src7;
-        src4 = src8;
-    }
-}
-
-static void avc_luma_vt_qrt_8w_msa(const uint8_t *src, int32_t src_stride,
-                                   uint8_t *dst, int32_t dst_stride,
-                                   int32_t height, uint8_t ver_offset)
-{
-    int32_t loop_cnt;
-    int16_t filt_const0 = 0xfb01;
-    int16_t filt_const1 = 0x1414;
-    int16_t filt_const2 = 0x1fb;
-    v16i8 src0, src1, src2, src3, src4, src7, src8, src9, src10;
-    v16i8 src10_r, src32_r, src76_r, src98_r;
-    v16i8 src21_r, src43_r, src87_r, src109_r;
-    v8i16 out0_r, out1_r, out2_r, out3_r;
-    v16i8 res0, res1;
-    v16i8 filt0, filt1, filt2;
-
-    filt0 = (v16i8) __msa_fill_h(filt_const0);
-    filt1 = (v16i8) __msa_fill_h(filt_const1);
-    filt2 = (v16i8) __msa_fill_h(filt_const2);
-
-    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-
-    XORI_B5_128_SB(src0, src1, src2, src3, src4);
-    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
-               src10_r, src21_r, src32_r, src43_r);
-
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src7, src8, src9, src10);
-        src += (4 * src_stride);
-
-        XORI_B4_128_SB(src7, src8, src9, src10);
-        ILVR_B4_SB(src7, src4, src8, src7, src9, src8, src10, src9,
-                   src76_r, src87_r, src98_r, src109_r);
-        out0_r = DPADD_SH3_SH(src10_r, src32_r, src76_r, filt0, filt1, filt2);
-        out1_r = DPADD_SH3_SH(src21_r, src43_r, src87_r, filt0, filt1, filt2);
-        out2_r = DPADD_SH3_SH(src32_r, src76_r, src98_r, filt0, filt1, filt2);
-        out3_r = DPADD_SH3_SH(src43_r, src87_r, src109_r, filt0, filt1, filt2);
-        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
-        SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
-        PCKEV_B2_SB(out1_r, out0_r, out3_r, out2_r, res0, res1);
-
-        if (ver_offset) {
-            PCKEV_D2_SB(src4, src3, src8, src7, src10_r, src32_r);
-        } else {
-            PCKEV_D2_SB(src3, src2, src7, src4, src10_r, src32_r);
-        }
-
-        res0 = __msa_aver_s_b(res0, (v16i8) src10_r);
-        res1 = __msa_aver_s_b(res1, (v16i8) src32_r);
-
-        XORI_B2_128_SB(res0, res1);
-        ST8x4_UB(res0, res1, dst, dst_stride);
-
-        dst += (4 * dst_stride);
-        src10_r = src76_r;
-        src32_r = src98_r;
-        src21_r = src87_r;
-        src43_r = src109_r;
-        src2 = src8;
-        src3 = src9;
-        src4 = src10;
-    }
-}
-
-static void avc_luma_vt_qrt_16w_msa(const uint8_t *src, int32_t src_stride,
-                                    uint8_t *dst, int32_t dst_stride,
-                                    int32_t height, uint8_t ver_offset)
-{
-    int32_t loop_cnt;
-    int16_t filt_const0 = 0xfb01;
-    int16_t filt_const1 = 0x1414;
-    int16_t filt_const2 = 0x1fb;
-    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
-    v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
-    v16i8 src87_r, src10_l, src32_l, src54_l, src76_l, src21_l, src43_l;
-    v16i8 src65_l, src87_l;
-    v8i16 out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
-    v16u8 res0, res1, res2, res3;
-    v16i8 filt0, filt1, filt2;
-
-    filt0 = (v16i8) __msa_fill_h(filt_const0);
-    filt1 = (v16i8) __msa_fill_h(filt_const1);
-    filt2 = (v16i8) __msa_fill_h(filt_const2);
-
-    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-
-    XORI_B5_128_SB(src0, src1, src2, src3, src4);
-    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
-               src10_r, src21_r, src32_r, src43_r);
-    ILVL_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
-               src10_l, src21_l, src32_l, src43_l);
-
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src5, src6, src7, src8);
-        src += (4 * src_stride);
-
-        XORI_B4_128_SB(src5, src6, src7, src8);
-        ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
-                   src54_r, src65_r, src76_r, src87_r);
-        ILVL_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
-                   src54_l, src65_l, src76_l, src87_l);
-        out0_r = DPADD_SH3_SH(src10_r, src32_r, src54_r, filt0, filt1, filt2);
-        out1_r = DPADD_SH3_SH(src21_r, src43_r, src65_r, filt0, filt1, filt2);
-        out2_r = DPADD_SH3_SH(src32_r, src54_r, src76_r, filt0, filt1, filt2);
-        out3_r = DPADD_SH3_SH(src43_r, src65_r, src87_r, filt0, filt1, filt2);
-        out0_l = DPADD_SH3_SH(src10_l, src32_l, src54_l, filt0, filt1, filt2);
-        out1_l = DPADD_SH3_SH(src21_l, src43_l, src65_l, filt0, filt1, filt2);
-        out2_l = DPADD_SH3_SH(src32_l, src54_l, src76_l, filt0, filt1, filt2);
-        out3_l = DPADD_SH3_SH(src43_l, src65_l, src87_l, filt0, filt1, filt2);
-        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
-        SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
-        SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 5);
-        SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
-        PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
-                    out3_r, res0, res1, res2, res3);
-
-        if (ver_offset) {
-            res0 = (v16u8) __msa_aver_s_b((v16i8) res0, src3);
-            res1 = (v16u8) __msa_aver_s_b((v16i8) res1, src4);
-            res2 = (v16u8) __msa_aver_s_b((v16i8) res2, src5);
-            res3 = (v16u8) __msa_aver_s_b((v16i8) res3, src6);
-        } else {
-            res0 = (v16u8) __msa_aver_s_b((v16i8) res0, src2);
-            res1 = (v16u8) __msa_aver_s_b((v16i8) res1, src3);
-            res2 = (v16u8) __msa_aver_s_b((v16i8) res2, src4);
-            res3 = (v16u8) __msa_aver_s_b((v16i8) res3, src5);
-        }
-
-        XORI_B4_128_UB(res0, res1, res2, res3);
-        ST_UB4(res0, res1, res2, res3, dst, dst_stride);
-
-        dst += (4 * dst_stride);
-
-        src10_r = src54_r;
-        src32_r = src76_r;
-        src21_r = src65_r;
-        src43_r = src87_r;
-        src10_l = src54_l;
-        src32_l = src76_l;
-        src21_l = src65_l;
-        src43_l = src87_l;
-        src2 = src6;
-        src3 = src7;
-        src4 = src8;
-    }
-}
-
-static void avc_luma_mid_4w_msa(const uint8_t *src, int32_t src_stride,
-                                uint8_t *dst, int32_t dst_stride,
-                                int32_t height)
-{
-    uint32_t loop_cnt;
-    v16i8 src0, src1, src2, src3, src4;
-    v16i8 mask0, mask1, mask2;
-    v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
-    v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
-    v8i16 dst0, dst1, dst2, dst3;
-
-    LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
-    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-
-    XORI_B5_128_SB(src0, src1, src2, src3, src4);
-
-    hz_out0 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
-                                                          mask0, mask1, mask2);
-    hz_out2 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
-                                                          mask0, mask1, mask2);
-
-    PCKOD_D2_SH(hz_out0, hz_out0, hz_out2, hz_out2, hz_out1, hz_out3);
-
-    hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
-
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
-
-        XORI_B4_128_SB(src0, src1, src2, src3);
-
-        hz_out5 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
-                                                              mask0, mask1,
-                                                              mask2);
-        hz_out7 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
-                                                              mask0, mask1,
-                                                              mask2);
-
-        PCKOD_D2_SH(hz_out5, hz_out5, hz_out7, hz_out7, hz_out6, hz_out8);
-
-        dst0 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out0, hz_out1, hz_out2,
-                                                 hz_out3, hz_out4, hz_out5);
-        dst1 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out1, hz_out2, hz_out3,
-                                                 hz_out4, hz_out5, hz_out6);
-        dst2 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out2, hz_out3, hz_out4,
-                                                 hz_out5, hz_out6, hz_out7);
-        dst3 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out3, hz_out4, hz_out5,
-                                                 hz_out6, hz_out7, hz_out8);
-
-        PCKEV_B2_SB(dst1, dst0, dst3, dst2, src0, src1);
-        XORI_B2_128_SB(src0, src1);
-
-        ST4x4_UB(src0, src1, 0, 2, 0, 2, dst, dst_stride);
-
-        dst += (4 * dst_stride);
-
-        hz_out0 = hz_out4;
-        hz_out1 = hz_out5;
-        hz_out2 = hz_out6;
-        hz_out3 = hz_out7;
-        hz_out4 = hz_out8;
-    }
-}
-
-static void avc_luma_mid_8w_msa(const uint8_t *src, int32_t src_stride,
-                                uint8_t *dst, int32_t dst_stride,
-                                int32_t height)
-{
-    uint32_t loop_cnt;
-    v16i8 src0, src1, src2, src3, src4;
-    v16i8 mask0, mask1, mask2;
-    v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
-    v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
-    v8i16 dst0, dst1, dst2, dst3;
-    v16u8 out0, out1;
-
-    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
-
-    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
-    XORI_B5_128_SB(src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-
-    hz_out0 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
-    hz_out1 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
-    hz_out2 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
-    hz_out3 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
-    hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
-
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src0, src1, src2, src3);
-        XORI_B4_128_SB(src0, src1, src2, src3);
-        src += (4 * src_stride);
-
-        hz_out5 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
-        hz_out6 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
-        hz_out7 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
-        hz_out8 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
-        dst0 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out0, hz_out1, hz_out2,
-                                               hz_out3, hz_out4, hz_out5);
-        dst1 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out1, hz_out2, hz_out3,
-                                               hz_out4, hz_out5, hz_out6);
-        dst2 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out2, hz_out3, hz_out4,
-                                               hz_out5, hz_out6, hz_out7);
-        dst3 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out3, hz_out4, hz_out5,
-                                               hz_out6, hz_out7, hz_out8);
-        out0 = PCKEV_XORI128_UB(dst0, dst1);
-        out1 = PCKEV_XORI128_UB(dst2, dst3);
-        ST8x4_UB(out0, out1, dst, dst_stride);
-
-        dst += (4 * dst_stride);
-        hz_out3 = hz_out7;
-        hz_out1 = hz_out5;
-        hz_out5 = hz_out4;
-        hz_out4 = hz_out8;
-        hz_out2 = hz_out6;
-        hz_out0 = hz_out5;
-    }
-}
-
-static void avc_luma_mid_16w_msa(const uint8_t *src, int32_t src_stride,
-                                 uint8_t *dst, int32_t dst_stride,
-                                 int32_t height)
-{
-    uint32_t multiple8_cnt;
-
-    for (multiple8_cnt = 2; multiple8_cnt--;) {
-        avc_luma_mid_8w_msa(src, src_stride, dst, dst_stride, height);
-        src += 8;
-        dst += 8;
-    }
-}
-
-static void avc_luma_midh_qrt_4w_msa(const uint8_t *src, int32_t src_stride,
-                                     uint8_t *dst, int32_t dst_stride,
-                                     int32_t height, uint8_t horiz_offset)
-{
-    uint32_t row;
-    v16i8 src0, src1, src2, src3, src4, src5, src6;
-    v8i16 vt_res0, vt_res1, vt_res2, vt_res3;
-    v4i32 hz_res0, hz_res1;
-    v8i16 dst0, dst1;
-    v8i16 shf_vec0, shf_vec1, shf_vec2, shf_vec3, shf_vec4, shf_vec5;
-    v8i16 mask0 = { 0, 5, 1, 6, 2, 7, 3, 8 };
-    v8i16 mask1 = { 1, 4, 2, 5, 3, 6, 4, 7 };
-    v8i16 mask2 = { 2, 3, 3, 4, 4, 5, 5, 6 };
-    v8i16 minus5h = __msa_ldi_h(-5);
-    v8i16 plus20h = __msa_ldi_h(20);
-    v8i16 zeros = { 0 };
-    v16u8 out;
-
-    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-    XORI_B5_128_SB(src0, src1, src2, src3, src4);
-
-    for (row = (height >> 1); row--;) {
-        LD_SB2(src, src_stride, src5, src6);
-        src += (2 * src_stride);
-
-        XORI_B2_128_SB(src5, src6);
-        AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src0, src1, src2, src3, src4, src5,
-                                        vt_res0, vt_res1);
-        AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src1, src2, src3, src4, src5, src6,
-                                        vt_res2, vt_res3);
-        VSHF_H3_SH(vt_res0, vt_res1, vt_res0, vt_res1, vt_res0, vt_res1,
-                   mask0, mask1, mask2, shf_vec0, shf_vec1, shf_vec2);
-        VSHF_H3_SH(vt_res2, vt_res3, vt_res2, vt_res3, vt_res2, vt_res3,
-                   mask0, mask1, mask2, shf_vec3, shf_vec4, shf_vec5);
-        hz_res0 = __msa_hadd_s_w(shf_vec0, shf_vec0);
-        DPADD_SH2_SW(shf_vec1, shf_vec2, minus5h, plus20h, hz_res0, hz_res0);
-        hz_res1 = __msa_hadd_s_w(shf_vec3, shf_vec3);
-        DPADD_SH2_SW(shf_vec4, shf_vec5, minus5h, plus20h, hz_res1, hz_res1);
-
-        SRARI_W2_SW(hz_res0, hz_res1, 10);
-        SAT_SW2_SW(hz_res0, hz_res1, 7);
-
-        dst0 = __msa_srari_h(shf_vec2, 5);
-        dst1 = __msa_srari_h(shf_vec5, 5);
-
-        SAT_SH2_SH(dst0, dst1, 7);
+        SAT_SH2_SH(dst0, dst1, 7);
 
         if (horiz_offset) {
             dst0 = __msa_ilvod_h(zeros, dst0);
@@ -1058,186 +406,6 @@ static void avc_luma_midh_qrt_16w_msa(const uint8_t *src, int32_t src_stride,
     }
 }
 
-static void avc_luma_midv_qrt_4w_msa(const uint8_t *src, int32_t src_stride,
-                                     uint8_t *dst, int32_t dst_stride,
-                                     int32_t height, uint8_t ver_offset)
-{
-    uint32_t loop_cnt;
-    v16i8 src0, src1, src2, src3, src4;
-    v16i8 mask0, mask1, mask2;
-    v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
-    v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
-    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
-
-    LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
-    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-
-    XORI_B5_128_SB(src0, src1, src2, src3, src4);
-
-    hz_out0 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
-                                                          mask0, mask1, mask2);
-    hz_out2 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
-                                                          mask0, mask1, mask2);
-
-    PCKOD_D2_SH(hz_out0, hz_out0, hz_out2, hz_out2, hz_out1, hz_out3);
-
-    hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
-
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
-        XORI_B4_128_SB(src0, src1, src2, src3);
-
-        hz_out5 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
-                                                              mask0, mask1,
-                                                              mask2);
-        hz_out7 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
-                                                              mask0, mask1,
-                                                              mask2);
-
-        PCKOD_D2_SH(hz_out5, hz_out5, hz_out7, hz_out7, hz_out6, hz_out8);
-
-        dst0 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out0, hz_out1, hz_out2,
-                                               hz_out3, hz_out4, hz_out5);
-        dst2 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out1, hz_out2, hz_out3,
-                                               hz_out4, hz_out5, hz_out6);
-        dst4 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out2, hz_out3, hz_out4,
-                                               hz_out5, hz_out6, hz_out7);
-        dst6 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out3, hz_out4, hz_out5,
-                                               hz_out6, hz_out7, hz_out8);
-
-        if (ver_offset) {
-            dst1 = __msa_srari_h(hz_out3, 5);
-            dst3 = __msa_srari_h(hz_out4, 5);
-            dst5 = __msa_srari_h(hz_out5, 5);
-            dst7 = __msa_srari_h(hz_out6, 5);
-        } else {
-            dst1 = __msa_srari_h(hz_out2, 5);
-            dst3 = __msa_srari_h(hz_out3, 5);
-            dst5 = __msa_srari_h(hz_out4, 5);
-            dst7 = __msa_srari_h(hz_out5, 5);
-        }
-
-        SAT_SH4_SH(dst1, dst3, dst5, dst7, 7);
-
-        dst0 = __msa_aver_s_h(dst0, dst1);
-        dst1 = __msa_aver_s_h(dst2, dst3);
-        dst2 = __msa_aver_s_h(dst4, dst5);
-        dst3 = __msa_aver_s_h(dst6, dst7);
-
-        PCKEV_B2_SB(dst1, dst0, dst3, dst2, src0, src1);
-        XORI_B2_128_SB(src0, src1);
-
-        ST4x4_UB(src0, src1, 0, 2, 0, 2, dst, dst_stride);
-
-        dst += (4 * dst_stride);
-        hz_out0 = hz_out4;
-        hz_out1 = hz_out5;
-        hz_out2 = hz_out6;
-        hz_out3 = hz_out7;
-        hz_out4 = hz_out8;
-    }
-}
-
-static void avc_luma_midv_qrt_8w_msa(const uint8_t *src, int32_t src_stride,
-                                     uint8_t *dst, int32_t dst_stride,
-                                     int32_t height, uint8_t ver_offset)
-{
-    uint32_t loop_cnt;
-    v16i8 src0, src1, src2, src3, src4;
-    v16i8 mask0, mask1, mask2;
-    v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
-    v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
-    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
-    v16u8 out;
-
-    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
-
-    LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
-    XORI_B5_128_SB(src0, src1, src2, src3, src4);
-    src += (5 * src_stride);
-
-    hz_out0 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
-    hz_out1 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
-    hz_out2 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
-    hz_out3 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
-    hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
-
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
-        LD_SB4(src, src_stride, src0, src1, src2, src3);
-        XORI_B4_128_SB(src0, src1, src2, src3);
-        src += (4 * src_stride);
-
-        hz_out5 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
-        hz_out6 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
-        hz_out7 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
-        hz_out8 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
-
-        dst0 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out0, hz_out1, hz_out2,
-                                               hz_out3, hz_out4, hz_out5);
-        dst2 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out1, hz_out2, hz_out3,
-                                               hz_out4, hz_out5, hz_out6);
-        dst4 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out2, hz_out3, hz_out4,
-                                               hz_out5, hz_out6, hz_out7);
-        dst6 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out3, hz_out4, hz_out5,
-                                               hz_out6, hz_out7, hz_out8);
-
-        if (ver_offset) {
-            dst1 = __msa_srari_h(hz_out3, 5);
-            dst3 = __msa_srari_h(hz_out4, 5);
-            dst5 = __msa_srari_h(hz_out5, 5);
-            dst7 = __msa_srari_h(hz_out6, 5);
-        } else {
-            dst1 = __msa_srari_h(hz_out2, 5);
-            dst3 = __msa_srari_h(hz_out3, 5);
-            dst5 = __msa_srari_h(hz_out4, 5);
-            dst7 = __msa_srari_h(hz_out5, 5);
-        }
-
-        SAT_SH4_SH(dst1, dst3, dst5, dst7, 7);
-
-        dst0 = __msa_aver_s_h(dst0, dst1);
-        dst1 = __msa_aver_s_h(dst2, dst3);
-        dst2 = __msa_aver_s_h(dst4, dst5);
-        dst3 = __msa_aver_s_h(dst6, dst7);
-
-        out = PCKEV_XORI128_UB(dst0, dst0);
-        ST8x1_UB(out, dst);
-        dst += dst_stride;
-        out = PCKEV_XORI128_UB(dst1, dst1);
-        ST8x1_UB(out, dst);
-        dst += dst_stride;
-        out = PCKEV_XORI128_UB(dst2, dst2);
-        ST8x1_UB(out, dst);
-        dst += dst_stride;
-        out = PCKEV_XORI128_UB(dst3, dst3);
-        ST8x1_UB(out, dst);
-        dst += dst_stride;
-
-        hz_out0 = hz_out4;
-        hz_out1 = hz_out5;
-        hz_out2 = hz_out6;
-        hz_out3 = hz_out7;
-        hz_out4 = hz_out8;
-    }
-}
-
-static void avc_luma_midv_qrt_16w_msa(const uint8_t *src, int32_t src_stride,
-                                      uint8_t *dst, int32_t dst_stride,
-                                      int32_t height, uint8_t vert_offset)
-{
-    uint32_t multiple8_cnt;
-
-    for (multiple8_cnt = 2; multiple8_cnt--;) {
-        avc_luma_midv_qrt_8w_msa(src, src_stride, dst, dst_stride, height,
-                                 vert_offset);
-
-        src += 8;
-        dst += 8;
-    }
-}
-
 static void avc_luma_hv_qrt_4w_msa(const uint8_t *src_x, const uint8_t *src_y,
                                    int32_t src_stride, uint8_t *dst,
                                    int32_t dst_stride, int32_t height)
@@ -1346,10 +514,10 @@ static void avc_luma_hv_qrt_8w_msa(const uint8_t *src_x, const uint8_t *src_y,
         XORI_B4_128_SB(src_hz0, src_hz1, src_hz2, src_hz3);
         src_x += (4 * src_stride);
 
-        hz_out0 = AVC_HORZ_FILTER_SH(src_hz0, mask0, mask1, mask2);
-        hz_out1 = AVC_HORZ_FILTER_SH(src_hz1, mask0, mask1, mask2);
-        hz_out2 = AVC_HORZ_FILTER_SH(src_hz2, mask0, mask1, mask2);
-        hz_out3 = AVC_HORZ_FILTER_SH(src_hz3, mask0, mask1, mask2);
+        hz_out0 = AVC_HORZ_FILTER_SH(src_hz0, src_hz0, mask0, mask1, mask2);
+        hz_out1 = AVC_HORZ_FILTER_SH(src_hz1, src_hz1, mask0, mask1, mask2);
+        hz_out2 = AVC_HORZ_FILTER_SH(src_hz2, src_hz2, mask0, mask1, mask2);
+        hz_out3 = AVC_HORZ_FILTER_SH(src_hz3, src_hz3, mask0, mask1, mask2);
 
         SRARI_H4_SH(hz_out0, hz_out1, hz_out2, hz_out3, 5);
         SAT_SH4_SH(hz_out0, hz_out1, hz_out2, hz_out3, 7);
@@ -1479,7 +647,8 @@ static void avc_luma_hz_and_aver_dst_8x8_msa(const uint8_t *src,
                      plus20b, res0, res1, res2, res3);
         SRARI_H4_SH(res0, res1, res2, res3, 5);
         SAT_SH4_SH(res0, res1, res2, res3, 7);
-        CONVERT_UB_AVG_ST8x4_UB(res0, res1, res2, res3, dst0, dst1, dst2, dst3,
+        ILVR_D2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
+        CONVERT_UB_AVG_ST8x4_UB(res0, res1, res2, res3, dst0, dst1,
                                 dst, dst_stride);
 
         dst += (4 * dst_stride);
@@ -1825,8 +994,8 @@ static void avc_luma_vt_and_aver_dst_8x8_msa(const uint8_t *src,
         SRARI_H4_SH(out0, out1, out2, out3, 5);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-
-        CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1, dst2, dst3,
+        ILVR_D2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
+        CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1,
                                 dst, dst_stride);
         dst += (4 * dst_stride);
 
@@ -2156,7 +1325,7 @@ static void avc_luma_mid_and_aver_dst_4x4_msa(const uint8_t *src,
 
     PCKOD_D2_SH(hz_out0, hz_out0, hz_out2, hz_out2, hz_out1, hz_out3);
 
-    hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
+    hz_out4 = AVC_HORZ_FILTER_SH(src4, src4, mask0, mask1, mask2);
 
     LD_SB4(src, src_stride, src0, src1, src2, src3);
     XORI_B4_128_SB(src0, src1, src2, src3);
@@ -2204,21 +1373,21 @@ static void avc_luma_mid_and_aver_dst_8w_msa(const uint8_t *src,
     XORI_B5_128_SB(src0, src1, src2, src3, src4);
     src += (5 * src_stride);
 
-    hz_out0 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
-    hz_out1 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
-    hz_out2 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
-    hz_out3 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
-    hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
+    hz_out0 = AVC_HORZ_FILTER_SH(src0, src0, mask0, mask1, mask2);
+    hz_out1 = AVC_HORZ_FILTER_SH(src1, src1, mask0, mask1, mask2);
+    hz_out2 = AVC_HORZ_FILTER_SH(src2, src2, mask0, mask1, mask2);
+    hz_out3 = AVC_HORZ_FILTER_SH(src3, src3, mask0, mask1, mask2);
+    hz_out4 = AVC_HORZ_FILTER_SH(src4, src4, mask0, mask1, mask2);
 
     for (loop_cnt = (height >> 2); loop_cnt--;) {
         LD_SB4(src, src_stride, src0, src1, src2, src3);
         XORI_B4_128_SB(src0, src1, src2, src3);
         src += (4 * src_stride);
 
-        hz_out5 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
-        hz_out6 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
-        hz_out7 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
-        hz_out8 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
+        hz_out5 = AVC_HORZ_FILTER_SH(src0, src0, mask0, mask1, mask2);
+        hz_out6 = AVC_HORZ_FILTER_SH(src1, src1, mask0, mask1, mask2);
+        hz_out7 = AVC_HORZ_FILTER_SH(src2, src2, mask0, mask1, mask2);
+        hz_out8 = AVC_HORZ_FILTER_SH(src3, src3, mask0, mask1, mask2);
 
         res0 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out0, hz_out1, hz_out2,
                                                hz_out3, hz_out4, hz_out5);
@@ -2229,7 +1398,8 @@ static void avc_luma_mid_and_aver_dst_8w_msa(const uint8_t *src,
         res3 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out3, hz_out4, hz_out5,
                                                hz_out6, hz_out7, hz_out8);
         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-        CONVERT_UB_AVG_ST8x4_UB(res0, res1, res2, res3, dst0, dst1, dst2, dst3,
+        ILVR_D2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
+        CONVERT_UB_AVG_ST8x4_UB(res0, res1, res2, res3, dst0, dst1,
                                 dst, dst_stride);
 
         dst += (4 * dst_stride);
@@ -2401,7 +1571,7 @@ static void avc_luma_midv_qrt_and_aver_dst_4w_msa(const uint8_t *src,
 
     PCKOD_D2_SH(hz_out0, hz_out0, hz_out2, hz_out2, hz_out1, hz_out3);
 
-    hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
+    hz_out4 = AVC_HORZ_FILTER_SH(src4, src4, mask0, mask1, mask2);
 
     for (loop_cnt = (height >> 1); loop_cnt--;) {
         LD_SB2(src, src_stride, src0, src1);
@@ -2473,11 +1643,11 @@ static void avc_luma_midv_qrt_and_aver_dst_8w_msa(const uint8_t *src,
     XORI_B5_128_SB(src0, src1, src2, src3, src4);
     src += (5 * src_stride);
 
-    hz_out0 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
-    hz_out1 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
-    hz_out2 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
-    hz_out3 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
-    hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
+    hz_out0 = AVC_HORZ_FILTER_SH(src0, src0, mask0, mask1, mask2);
+    hz_out1 = AVC_HORZ_FILTER_SH(src1, src1, mask0, mask1, mask2);
+    hz_out2 = AVC_HORZ_FILTER_SH(src2, src2, mask0, mask1, mask2);
+    hz_out3 = AVC_HORZ_FILTER_SH(src3, src3, mask0, mask1, mask2);
+    hz_out4 = AVC_HORZ_FILTER_SH(src4, src4, mask0, mask1, mask2);
 
     for (loop_cnt = (height >> 2); loop_cnt--;) {
         LD_SB4(src, src_stride, src0, src1, src2, src3);
@@ -2486,10 +1656,10 @@ static void avc_luma_midv_qrt_and_aver_dst_8w_msa(const uint8_t *src,
 
         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
 
-        hz_out5 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
-        hz_out6 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
-        hz_out7 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
-        hz_out8 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
+        hz_out5 = AVC_HORZ_FILTER_SH(src0, src0, mask0, mask1, mask2);
+        hz_out6 = AVC_HORZ_FILTER_SH(src1, src1, mask0, mask1, mask2);
+        hz_out7 = AVC_HORZ_FILTER_SH(src2, src2, mask0, mask1, mask2);
+        hz_out8 = AVC_HORZ_FILTER_SH(src3, src3, mask0, mask1, mask2);
 
         res0 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out0, hz_out1, hz_out2,
                                                hz_out3, hz_out4, hz_out5);
@@ -2518,8 +1688,8 @@ static void avc_luma_midv_qrt_and_aver_dst_8w_msa(const uint8_t *src,
         res1 = __msa_aver_s_h(res2, res3);
         res2 = __msa_aver_s_h(res4, res5);
         res3 = __msa_aver_s_h(res6, res7);
-
-        CONVERT_UB_AVG_ST8x4_UB(res0, res1, res2, res3, dst0, dst1, dst2, dst3,
+        ILVR_D2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
+        CONVERT_UB_AVG_ST8x4_UB(res0, res1, res2, res3, dst0, dst1,
                                 dst, dst_stride);
         dst += (4 * dst_stride);
 
@@ -2648,10 +1818,10 @@ static void avc_luma_hv_qrt_and_aver_dst_8x8_msa(const uint8_t *src_x,
         src_x += (4 * src_stride);
 
         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-        hz_out0 = AVC_HORZ_FILTER_SH(src_hz0, mask0, mask1, mask2);
-        hz_out1 = AVC_HORZ_FILTER_SH(src_hz1, mask0, mask1, mask2);
-        hz_out2 = AVC_HORZ_FILTER_SH(src_hz2, mask0, mask1, mask2);
-        hz_out3 = AVC_HORZ_FILTER_SH(src_hz3, mask0, mask1, mask2);
+        hz_out0 = AVC_HORZ_FILTER_SH(src_hz0, src_hz0, mask0, mask1, mask2);
+        hz_out1 = AVC_HORZ_FILTER_SH(src_hz1, src_hz1, mask0, mask1, mask2);
+        hz_out2 = AVC_HORZ_FILTER_SH(src_hz2, src_hz2, mask0, mask1, mask2);
+        hz_out3 = AVC_HORZ_FILTER_SH(src_hz3, src_hz3, mask0, mask1, mask2);
         SRARI_H4_SH(hz_out0, hz_out1, hz_out2, hz_out3, 5);
         SAT_SH4_SH(hz_out0, hz_out1, hz_out2, hz_out3, 7);
         LD_SB4(src_y, src_stride, src_vt5, src_vt6, src_vt7, src_vt8);
@@ -2676,7 +1846,8 @@ static void avc_luma_hv_qrt_and_aver_dst_8x8_msa(const uint8_t *src_x,
         out3 = __msa_srari_h((hz_out3 + vert_out3), 1);
 
         SAT_SH4_SH(out0, out1, out2, out3, 7);
-        CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1, dst2, dst3,
+        ILVR_D2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
+        CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1,
                                 dst, dst_stride);
         dst += (4 * dst_stride);
 
@@ -2719,365 +1890,877 @@ static void avc_luma_hv_qrt_and_aver_dst_16x16_msa(const uint8_t *src_x,
     }
 }
 
-static void copy_width8_msa(const uint8_t *src, int32_t src_stride,
-                            uint8_t *dst, int32_t dst_stride,
-                            int32_t height)
+void ff_put_h264_qpel16_mc00_msa(uint8_t *dst, const uint8_t *src,
+                                 ptrdiff_t stride)
+{
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16u8 src8, src9, src10, src11, src12, src13, src14, src15;
+
+    LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+    src += (8 * stride);
+    LD_UB8(src, stride, src8, src9, src10, src11, src12, src13, src14, src15);
+
+    ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, stride);
+    dst += (8 * stride);
+    ST_UB8(src8, src9, src10, src11, src12, src13, src14, src15, dst, stride);
+}
+
+void ff_put_h264_qpel8_mc00_msa(uint8_t *dst, const uint8_t *src,
+                                ptrdiff_t stride)
 {
-    int32_t cnt;
-    uint64_t out0, out1, out2, out3, out4, out5, out6, out7;
-    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+    uint64_t src0, src1, src2, src3, src4, src5, src6, src7;
 
-    if (0 == height % 12) {
-        for (cnt = (height / 12); cnt--;) {
-            LD_UB8(src, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src += (8 * src_stride);
-
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
-            out4 = __msa_copy_u_d((v2i64) src4, 0);
-            out5 = __msa_copy_u_d((v2i64) src5, 0);
-            out6 = __msa_copy_u_d((v2i64) src6, 0);
-            out7 = __msa_copy_u_d((v2i64) src7, 0);
-
-            SD4(out0, out1, out2, out3, dst, dst_stride);
-            dst += (4 * dst_stride);
-            SD4(out4, out5, out6, out7, dst, dst_stride);
-            dst += (4 * dst_stride);
-
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            src += (4 * src_stride);
-
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
-
-            SD4(out0, out1, out2, out3, dst, dst_stride);
-            dst += (4 * dst_stride);
-        }
-    } else if (0 == height % 8) {
-        for (cnt = height >> 3; cnt--;) {
-            LD_UB8(src, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src += (8 * src_stride);
-
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
-            out4 = __msa_copy_u_d((v2i64) src4, 0);
-            out5 = __msa_copy_u_d((v2i64) src5, 0);
-            out6 = __msa_copy_u_d((v2i64) src6, 0);
-            out7 = __msa_copy_u_d((v2i64) src7, 0);
-
-            SD4(out0, out1, out2, out3, dst, dst_stride);
-            dst += (4 * dst_stride);
-            SD4(out4, out5, out6, out7, dst, dst_stride);
-            dst += (4 * dst_stride);
-        }
-    } else if (0 == height % 4) {
-        for (cnt = (height / 4); cnt--;) {
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            src += (4 * src_stride);
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
-
-            SD4(out0, out1, out2, out3, dst, dst_stride);
-            dst += (4 * dst_stride);
-        }
-    } else if (0 == height % 2) {
-        for (cnt = (height / 2); cnt--;) {
-            LD_UB2(src, src_stride, src0, src1);
-            src += (2 * src_stride);
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-
-            SD(out0, dst);
-            dst += dst_stride;
-            SD(out1, dst);
-            dst += dst_stride;
-        }
-    }
+    LD4(src, stride, src0, src1, src2, src3);
+    src += 4 * stride;
+    LD4(src, stride, src4, src5, src6, src7);
+    SD4(src0, src1, src2, src3, dst, stride);
+    dst += 4 * stride;
+    SD4(src4, src5, src6, src7, dst, stride);
 }
 
-static void copy_16multx8mult_msa(const uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
-                                  int32_t height, int32_t width)
+void ff_avg_h264_qpel16_mc00_msa(uint8_t *dst, const uint8_t *src,
+                                 ptrdiff_t stride)
 {
-    int32_t cnt, loop_cnt;
-    const uint8_t *src_tmp;
-    uint8_t *dst_tmp;
     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
 
-    for (cnt = (width >> 4); cnt--;) {
-        src_tmp = src;
-        dst_tmp = dst;
+    LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+    src += (8 * stride);
+    LD_UB8(dst, stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
 
-        for (loop_cnt = (height >> 3); loop_cnt--;) {
-            LD_UB8(src_tmp, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src_tmp += (8 * src_stride);
+    AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3, dst0, dst1,
+                dst2, dst3);
+    AVER_UB4_UB(src4, dst4, src5, dst5, src6, dst6, src7, dst7, dst4, dst5,
+                dst6, dst7);
+    ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, stride);
+    dst += (8 * stride);
 
-            ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,
-                   dst_tmp, dst_stride);
-            dst_tmp += (8 * dst_stride);
-        }
+    LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+    LD_UB8(dst, stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
 
-        src += 16;
-        dst += 16;
-    }
+    AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3, dst0, dst1,
+                dst2, dst3);
+    AVER_UB4_UB(src4, dst4, src5, dst5, src6, dst6, src7, dst7, dst4, dst5,
+                dst6, dst7);
+    ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, stride);
 }
 
-static void copy_width16_msa(const uint8_t *src, int32_t src_stride,
-                             uint8_t *dst, int32_t dst_stride,
-                             int32_t height)
+void ff_avg_h264_qpel8_mc00_msa(uint8_t *dst, const uint8_t *src,
+                                ptrdiff_t stride)
 {
-    int32_t cnt;
-    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+    uint64_t tp0, tp1, tp2, tp3, tp4, tp5, tp6, tp7;
+    v16u8 src0 = { 0 }, src1 = { 0 }, src2 = { 0 }, src3 = { 0 };
+    v16u8 dst0 = { 0 }, dst1 = { 0 }, dst2 = { 0 }, dst3 = { 0 };
 
-    if (0 == height % 12) {
-        for (cnt = (height / 12); cnt--;) {
-            LD_UB8(src, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src += (8 * src_stride);
-            ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,
-                   dst, dst_stride);
-            dst += (8 * dst_stride);
-
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            src += (4 * src_stride);
-            ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-            dst += (4 * dst_stride);
-        }
-    } else if (0 == height % 8) {
-        copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 16);
-    } else if (0 == height % 4) {
-        for (cnt = (height >> 2); cnt--;) {
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            src += (4 * src_stride);
-
-            ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-            dst += (4 * dst_stride);
-        }
-    }
+    LD4(src, stride, tp0, tp1, tp2, tp3);
+    src += 4 * stride;
+    LD4(src, stride, tp4, tp5, tp6, tp7);
+    INSERT_D2_UB(tp0, tp1, src0);
+    INSERT_D2_UB(tp2, tp3, src1);
+    INSERT_D2_UB(tp4, tp5, src2);
+    INSERT_D2_UB(tp6, tp7, src3);
+
+    LD4(dst, stride, tp0, tp1, tp2, tp3);
+    LD4(dst + 4 * stride, stride, tp4, tp5, tp6, tp7);
+    INSERT_D2_UB(tp0, tp1, dst0);
+    INSERT_D2_UB(tp2, tp3, dst1);
+    INSERT_D2_UB(tp4, tp5, dst2);
+    INSERT_D2_UB(tp6, tp7, dst3);
+
+    AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3, dst0, dst1,
+                dst2, dst3);
+
+    ST8x8_UB(dst0, dst1, dst2, dst3, dst, stride);
 }
 
-static void avg_width4_msa(const uint8_t *src, int32_t src_stride,
-                           uint8_t *dst, int32_t dst_stride,
-                           int32_t height)
+void ff_avg_h264_qpel4_mc00_msa(uint8_t *dst, const uint8_t *src,
+                                ptrdiff_t stride)
 {
-    int32_t cnt;
-    uint32_t out0, out1, out2, out3;
-    v16u8 src0, src1, src2, src3;
-    v16u8 dst0, dst1, dst2, dst3;
+    uint32_t tp0, tp1, tp2, tp3;
+    v16u8 src0 = { 0 }, dst0 = { 0 };
 
-    if (0 == (height % 4)) {
-        for (cnt = (height / 4); cnt--;) {
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            src += (4 * src_stride);
+    LW4(src, stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
+    LW4(dst, stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
 
-            LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+    dst0 = __msa_aver_u_b(src0, dst0);
 
-            AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
-                        dst0, dst1, dst2, dst3);
-
-            out0 = __msa_copy_u_w((v4i32) dst0, 0);
-            out1 = __msa_copy_u_w((v4i32) dst1, 0);
-            out2 = __msa_copy_u_w((v4i32) dst2, 0);
-            out3 = __msa_copy_u_w((v4i32) dst3, 0);
-            SW4(out0, out1, out2, out3, dst, dst_stride);
-            dst += (4 * dst_stride);
-        }
-    } else if (0 == (height % 2)) {
-        for (cnt = (height / 2); cnt--;) {
-            LD_UB2(src, src_stride, src0, src1);
-            src += (2 * src_stride);
+    ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, stride);
+}
 
-            LD_UB2(dst, dst_stride, dst0, dst1);
+void ff_put_h264_qpel16_mc10_msa(uint8_t *dst, const uint8_t *src,
+                                 ptrdiff_t stride)
+{
+    uint32_t loop_cnt;
+    v16i8 dst0, dst1, dst2, dst3, src0, src1, src2, src3, src4, src5, src6;
+    v16i8 mask0, mask1, mask2, mask3, mask4, mask5, src7, vec11;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9, vec10;
+    v8i16 res0, res1, res2, res3, res4, res5, res6, res7;
+    v16i8 minus5b = __msa_ldi_b(-5);
+    v16i8 plus20b = __msa_ldi_b(20);
 
-            AVER_UB2_UB(src0, dst0, src1, dst1, dst0, dst1);
+    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
+    mask3 = mask0 + 8;
+    mask4 = mask1 + 8;
+    mask5 = mask2 + 8;
+    src -= 2;
 
-            out0 = __msa_copy_u_w((v4i32) dst0, 0);
-            out1 = __msa_copy_u_w((v4i32) dst1, 0);
-            SW(out0, dst);
-            dst += dst_stride;
-            SW(out1, dst);
-            dst += dst_stride;
-        }
+    for (loop_cnt = 4; loop_cnt--;) {
+        LD_SB2(src, 16, src0, src1);
+        src += stride;
+        LD_SB2(src, 16, src2, src3);
+        src += stride;
+        LD_SB2(src, 16, src4, src5);
+        src += stride;
+        LD_SB2(src, 16, src6, src7);
+        src += stride;
+
+        XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
+        VSHF_B2_SB(src0, src0, src0, src1, mask0, mask3, vec0, vec3);
+        VSHF_B2_SB(src2, src2, src2, src3, mask0, mask3, vec6, vec9);
+        VSHF_B2_SB(src0, src0, src0, src1, mask1, mask4, vec1, vec4);
+        VSHF_B2_SB(src2, src2, src2, src3, mask1, mask4, vec7, vec10);
+        VSHF_B2_SB(src0, src0, src0, src1, mask2, mask5, vec2, vec5);
+        VSHF_B2_SB(src2, src2, src2, src3, mask2, mask5, vec8, vec11);
+        HADD_SB4_SH(vec0, vec3, vec6, vec9, res0, res1, res2, res3);
+        DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
+                     minus5b, res0, res1, res2, res3);
+        DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
+                     plus20b, res0, res1, res2, res3);
+        VSHF_B2_SB(src4, src4, src4, src5, mask0, mask3, vec0, vec3);
+        VSHF_B2_SB(src6, src6, src6, src7, mask0, mask3, vec6, vec9);
+        VSHF_B2_SB(src4, src4, src4, src5, mask1, mask4, vec1, vec4);
+        VSHF_B2_SB(src6, src6, src6, src7, mask1, mask4, vec7, vec10);
+        VSHF_B2_SB(src4, src4, src4, src5, mask2, mask5, vec2, vec5);
+        VSHF_B2_SB(src6, src6, src6, src7, mask2, mask5, vec8, vec11);
+        HADD_SB4_SH(vec0, vec3, vec6, vec9, res4, res5, res6, res7);
+        DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
+                     minus5b, res4, res5, res6, res7);
+        DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
+                     plus20b, res4, res5, res6, res7);
+        SLDI_B2_SB(src1, src3, src0, src2, src0, src2, 2);
+        SLDI_B2_SB(src5, src7, src4, src6, src4, src6, 2);
+        SRARI_H4_SH(res0, res1, res2, res3, 5);
+        SRARI_H4_SH(res4, res5, res6, res7, 5);
+        SAT_SH4_SH(res0, res1, res2, res3, 7);
+        SAT_SH4_SH(res4, res5, res6, res7, 7);
+        PCKEV_B2_SB(res1, res0, res3, res2, dst0, dst1);
+        PCKEV_B2_SB(res5, res4, res7, res6, dst2, dst3);
+        dst0 = __msa_aver_s_b(dst0, src0);
+        dst1 = __msa_aver_s_b(dst1, src2);
+        dst2 = __msa_aver_s_b(dst2, src4);
+        dst3 = __msa_aver_s_b(dst3, src6);
+        XORI_B4_128_SB(dst0, dst1, dst2, dst3);
+        ST_SB4(dst0, dst1, dst2, dst3, dst, stride);
+        dst += (4 * stride);
     }
 }
 
-static void avg_width8_msa(const uint8_t *src, int32_t src_stride,
-                           uint8_t *dst, int32_t dst_stride,
-                           int32_t height)
+void ff_put_h264_qpel16_mc30_msa(uint8_t *dst, const uint8_t *src,
+                                 ptrdiff_t stride)
 {
-    int32_t cnt;
-    uint64_t out0, out1, out2, out3;
-    v16u8 src0, src1, src2, src3;
-    v16u8 dst0, dst1, dst2, dst3;
-
-    for (cnt = (height / 4); cnt--;) {
-        LD_UB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
-        LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+    uint32_t loop_cnt;
+    v16i8 dst0, dst1, dst2, dst3, src0, src1, src2, src3, src4, src5, src6;
+    v16i8 mask0, mask1, mask2, mask3, mask4, mask5, src7, vec11;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9, vec10;
+    v8i16 res0, res1, res2, res3, res4, res5, res6, res7;
+    v16i8 minus5b = __msa_ldi_b(-5);
+    v16i8 plus20b = __msa_ldi_b(20);
 
-        AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
-                    dst0, dst1, dst2, dst3);
+    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
+    mask3 = mask0 + 8;
+    mask4 = mask1 + 8;
+    mask5 = mask2 + 8;
+    src -= 2;
 
-        out0 = __msa_copy_u_d((v2i64) dst0, 0);
-        out1 = __msa_copy_u_d((v2i64) dst1, 0);
-        out2 = __msa_copy_u_d((v2i64) dst2, 0);
-        out3 = __msa_copy_u_d((v2i64) dst3, 0);
-        SD4(out0, out1, out2, out3, dst, dst_stride);
-        dst += (4 * dst_stride);
+    for (loop_cnt = 4; loop_cnt--;) {
+        LD_SB2(src, 16, src0, src1);
+        src += stride;
+        LD_SB2(src, 16, src2, src3);
+        src += stride;
+        LD_SB2(src, 16, src4, src5);
+        src += stride;
+        LD_SB2(src, 16, src6, src7);
+        src += stride;
+
+        XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
+        VSHF_B2_SB(src0, src0, src0, src1, mask0, mask3, vec0, vec3);
+        VSHF_B2_SB(src2, src2, src2, src3, mask0, mask3, vec6, vec9);
+        VSHF_B2_SB(src0, src0, src0, src1, mask1, mask4, vec1, vec4);
+        VSHF_B2_SB(src2, src2, src2, src3, mask1, mask4, vec7, vec10);
+        VSHF_B2_SB(src0, src0, src0, src1, mask2, mask5, vec2, vec5);
+        VSHF_B2_SB(src2, src2, src2, src3, mask2, mask5, vec8, vec11);
+        HADD_SB4_SH(vec0, vec3, vec6, vec9, res0, res1, res2, res3);
+        DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
+                     minus5b, res0, res1, res2, res3);
+        DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
+                     plus20b, res0, res1, res2, res3);
+        VSHF_B2_SB(src4, src4, src4, src5, mask0, mask3, vec0, vec3);
+        VSHF_B2_SB(src6, src6, src6, src7, mask0, mask3, vec6, vec9);
+        VSHF_B2_SB(src4, src4, src4, src5, mask1, mask4, vec1, vec4);
+        VSHF_B2_SB(src6, src6, src6, src7, mask1, mask4, vec7, vec10);
+        VSHF_B2_SB(src4, src4, src4, src5, mask2, mask5, vec2, vec5);
+        VSHF_B2_SB(src6, src6, src6, src7, mask2, mask5, vec8, vec11);
+        HADD_SB4_SH(vec0, vec3, vec6, vec9, res4, res5, res6, res7);
+        DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
+                     minus5b, res4, res5, res6, res7);
+        DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
+                     plus20b, res4, res5, res6, res7);
+        SLDI_B2_SB(src1, src3, src0, src2, src0, src2, 3);
+        SLDI_B2_SB(src5, src7, src4, src6, src4, src6, 3);
+        SRARI_H4_SH(res0, res1, res2, res3, 5);
+        SRARI_H4_SH(res4, res5, res6, res7, 5);
+        SAT_SH4_SH(res0, res1, res2, res3, 7);
+        SAT_SH4_SH(res4, res5, res6, res7, 7);
+        PCKEV_B2_SB(res1, res0, res3, res2, dst0, dst1);
+        PCKEV_B2_SB(res5, res4, res7, res6, dst2, dst3);
+        dst0 = __msa_aver_s_b(dst0, src0);
+        dst1 = __msa_aver_s_b(dst1, src2);
+        dst2 = __msa_aver_s_b(dst2, src4);
+        dst3 = __msa_aver_s_b(dst3, src6);
+        XORI_B4_128_SB(dst0, dst1, dst2, dst3);
+        ST_SB4(dst0, dst1, dst2, dst3, dst, stride);
+        dst += (4 * stride);
     }
 }
 
-static void avg_width16_msa(const uint8_t *src, int32_t src_stride,
-                            uint8_t *dst, int32_t dst_stride,
-                            int32_t height)
+void ff_put_h264_qpel8_mc10_msa(uint8_t *dst, const uint8_t *src,
+                                ptrdiff_t stride)
 {
-    int32_t cnt;
-    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
-    v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask0, mask1, mask2;
+    v16i8 tmp0, tmp1, tmp2, tmp3, vec11;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9, vec10;
+    v8i16 res0, res1, res2, res3, res4, res5, res6, res7;
+    v16i8 minus5b = __msa_ldi_b(-5);
+    v16i8 plus20b = __msa_ldi_b(20);
+
+    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
+    LD_SB8(src - 2, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+    XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
+    VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
+    VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
+    HADD_SB4_SH(vec0, vec1, vec2, vec3, res0, res1, res2, res3);
+    VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec4, vec5);
+    VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec6, vec7);
+    DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
+                 res0, res1, res2, res3);
+    VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec8, vec9);
+    VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec10, vec11);
+    DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b, plus20b,
+                 res0, res1, res2, res3);
+    VSHF_B2_SB(src4, src4, src5, src5, mask0, mask0, vec0, vec1);
+    VSHF_B2_SB(src6, src6, src7, src7, mask0, mask0, vec2, vec3);
+    HADD_SB4_SH(vec0, vec1, vec2, vec3, res4, res5, res6, res7);
+    VSHF_B2_SB(src4, src4, src5, src5, mask1, mask1, vec4, vec5);
+    VSHF_B2_SB(src6, src6, src7, src7, mask1, mask1, vec6, vec7);
+    DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
+                 res4, res5, res6, res7);
+    VSHF_B2_SB(src4, src4, src5, src5, mask2, mask2, vec8, vec9);
+    VSHF_B2_SB(src6, src6, src7, src7, mask2, mask2, vec10, vec11);
+    DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b, plus20b,
+                 res4, res5, res6, res7);
+    SLDI_B2_SB(src0, src1, src0, src1, src0, src1, 2);
+    SLDI_B2_SB(src2, src3, src2, src3, src2, src3, 2);
+    SLDI_B2_SB(src4, src5, src4, src5, src4, src5, 2);
+    SLDI_B2_SB(src6, src7, src6, src7, src6, src7, 2);
+    PCKEV_D2_SB(src1, src0, src3, src2, src0, src1);
+    PCKEV_D2_SB(src5, src4, src7, src6, src4, src5);
+    SRARI_H4_SH(res0, res1, res2, res3, 5);
+    SRARI_H4_SH(res4, res5, res6, res7, 5);
+    SAT_SH4_SH(res0, res1, res2, res3, 7);
+    SAT_SH4_SH(res4, res5, res6, res7, 7);
+    PCKEV_B2_SB(res1, res0, res3, res2, tmp0, tmp1);
+    PCKEV_B2_SB(res5, res4, res7, res6, tmp2, tmp3);
+    tmp0 = __msa_aver_s_b(tmp0, src0);
+    tmp1 = __msa_aver_s_b(tmp1, src1);
+    tmp2 = __msa_aver_s_b(tmp2, src4);
+    tmp3 = __msa_aver_s_b(tmp3, src5);
+    XORI_B4_128_SB(tmp0, tmp1, tmp2, tmp3);
+    ST8x8_UB(tmp0, tmp1, tmp2, tmp3, dst, stride);
+}
 
-    for (cnt = (height / 8); cnt--;) {
-        LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
-        src += (8 * src_stride);
-        LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
+void ff_put_h264_qpel8_mc30_msa(uint8_t *dst, const uint8_t *src,
+                                ptrdiff_t stride)
+{
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask0, mask1, mask2;
+    v16i8 tmp0, tmp1, tmp2, tmp3, vec11;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9, vec10;
+    v8i16 res0, res1, res2, res3, res4, res5, res6, res7;
+    v16i8 minus5b = __msa_ldi_b(-5);
+    v16i8 plus20b = __msa_ldi_b(20);
 
-        AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
-                    dst0, dst1, dst2, dst3);
-        AVER_UB4_UB(src4, dst4, src5, dst5, src6, dst6, src7, dst7,
-                    dst4, dst5, dst6, dst7);
-        ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, dst_stride);
-        dst += (8 * dst_stride);
-    }
+    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
+    LD_SB8(src - 2, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+    XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
+    VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
+    VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
+    HADD_SB4_SH(vec0, vec1, vec2, vec3, res0, res1, res2, res3);
+    VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec4, vec5);
+    VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec6, vec7);
+    DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
+                 res0, res1, res2, res3);
+    VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec8, vec9);
+    VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec10, vec11);
+    DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b, plus20b,
+                 res0, res1, res2, res3);
+    VSHF_B2_SB(src4, src4, src5, src5, mask0, mask0, vec0, vec1);
+    VSHF_B2_SB(src6, src6, src7, src7, mask0, mask0, vec2, vec3);
+    HADD_SB4_SH(vec0, vec1, vec2, vec3, res4, res5, res6, res7);
+    VSHF_B2_SB(src4, src4, src5, src5, mask1, mask1, vec4, vec5);
+    VSHF_B2_SB(src6, src6, src7, src7, mask1, mask1, vec6, vec7);
+    DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
+                 res4, res5, res6, res7);
+    VSHF_B2_SB(src4, src4, src5, src5, mask2, mask2, vec8, vec9);
+    VSHF_B2_SB(src6, src6, src7, src7, mask2, mask2, vec10, vec11);
+    DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b, plus20b,
+                 res4, res5, res6, res7);
+    SLDI_B2_SB(src0, src1, src0, src1, src0, src1, 3);
+    SLDI_B2_SB(src2, src3, src2, src3, src2, src3, 3);
+    SLDI_B2_SB(src4, src5, src4, src5, src4, src5, 3);
+    SLDI_B2_SB(src6, src7, src6, src7, src6, src7, 3);
+    PCKEV_D2_SB(src1, src0, src3, src2, src0, src1);
+    PCKEV_D2_SB(src5, src4, src7, src6, src4, src5);
+    SRARI_H4_SH(res0, res1, res2, res3, 5);
+    SRARI_H4_SH(res4, res5, res6, res7, 5);
+    SAT_SH4_SH(res0, res1, res2, res3, 7);
+    SAT_SH4_SH(res4, res5, res6, res7, 7);
+    PCKEV_B2_SB(res1, res0, res3, res2, tmp0, tmp1);
+    PCKEV_B2_SB(res5, res4, res7, res6, tmp2, tmp3);
+    tmp0 = __msa_aver_s_b(tmp0, src0);
+    tmp1 = __msa_aver_s_b(tmp1, src1);
+    tmp2 = __msa_aver_s_b(tmp2, src4);
+    tmp3 = __msa_aver_s_b(tmp3, src5);
+    XORI_B4_128_SB(tmp0, tmp1, tmp2, tmp3);
+    ST8x8_UB(tmp0, tmp1, tmp2, tmp3, dst, stride);
 }
 
-void ff_put_h264_qpel16_mc00_msa(uint8_t *dst, const uint8_t *src,
-                                 ptrdiff_t stride)
+void ff_put_h264_qpel4_mc10_msa(uint8_t *dst, const uint8_t *src,
+                                ptrdiff_t stride)
 {
-    copy_width16_msa(src, stride, dst, stride, 16);
+    v16i8 src0, src1, src2, src3, res, mask0, mask1, mask2;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
+    v8i16 res0, res1;
+    v16i8 minus5b = __msa_ldi_b(-5);
+    v16i8 plus20b = __msa_ldi_b(20);
+
+    LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
+    LD_SB4(src - 2, stride, src0, src1, src2, src3);
+    XORI_B4_128_SB(src0, src1, src2, src3);
+    VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
+    HADD_SB2_SH(vec0, vec1, res0, res1);
+    VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec2, vec3);
+    DPADD_SB2_SH(vec2, vec3, minus5b, minus5b, res0, res1);
+    VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec4, vec5);
+    DPADD_SB2_SH(vec4, vec5, plus20b, plus20b, res0, res1);
+    SRARI_H2_SH(res0, res1, 5);
+    SAT_SH2_SH(res0, res1, 7);
+    res = __msa_pckev_b((v16i8) res1, (v16i8) res0);
+    SLDI_B2_SB(src0, src1, src0, src1, src0, src1, 2);
+    SLDI_B2_SB(src2, src3, src2, src3, src2, src3, 2);
+    src0 = (v16i8) __msa_insve_w((v4i32) src0, 1, (v4i32) src1);
+    src1 = (v16i8) __msa_insve_w((v4i32) src2, 1, (v4i32) src3);
+    src0 = (v16i8) __msa_insve_d((v2i64) src0, 1, (v2i64) src1);
+    res = __msa_aver_s_b(res, src0);
+    res = (v16i8) __msa_xori_b((v16u8) res, 128);
+    ST4x4_UB(res, res, 0, 1, 2, 3, dst, stride);
 }
 
-void ff_put_h264_qpel8_mc00_msa(uint8_t *dst, const uint8_t *src,
+void ff_put_h264_qpel4_mc30_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    copy_width8_msa(src, stride, dst, stride, 8);
+    v16i8 src0, src1, src2, src3, res, mask0, mask1, mask2;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
+    v8i16 res0, res1;
+    v16i8 minus5b = __msa_ldi_b(-5);
+    v16i8 plus20b = __msa_ldi_b(20);
+
+    LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
+    LD_SB4(src - 2, stride, src0, src1, src2, src3);
+    XORI_B4_128_SB(src0, src1, src2, src3);
+    VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
+    HADD_SB2_SH(vec0, vec1, res0, res1);
+    VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec2, vec3);
+    DPADD_SB2_SH(vec2, vec3, minus5b, minus5b, res0, res1);
+    VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec4, vec5);
+    DPADD_SB2_SH(vec4, vec5, plus20b, plus20b, res0, res1);
+    SRARI_H2_SH(res0, res1, 5);
+    SAT_SH2_SH(res0, res1, 7);
+    res = __msa_pckev_b((v16i8) res1, (v16i8) res0);
+    SLDI_B2_SB(src0, src1, src0, src1, src0, src1, 3);
+    SLDI_B2_SB(src2, src3, src2, src3, src2, src3, 3);
+    src0 = (v16i8) __msa_insve_w((v4i32) src0, 1, (v4i32) src1);
+    src1 = (v16i8) __msa_insve_w((v4i32) src2, 1, (v4i32) src3);
+    src0 = (v16i8) __msa_insve_d((v2i64) src0, 1, (v2i64) src1);
+    res = __msa_aver_s_b(res, src0);
+    res = (v16i8) __msa_xori_b((v16u8) res, 128);
+    ST4x4_UB(res, res, 0, 1, 2, 3, dst, stride);
 }
 
-void ff_avg_h264_qpel16_mc00_msa(uint8_t *dst, const uint8_t *src,
+void ff_put_h264_qpel16_mc20_msa(uint8_t *dst, const uint8_t *src,
                                  ptrdiff_t stride)
 {
-    avg_width16_msa(src, stride, dst, stride, 16);
+    uint32_t loop_cnt;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask0, mask1, mask2;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9, vec10;
+    v16i8 vec11;
+    v8i16 res0, res1, res2, res3, res4, res5, res6, res7;
+    v16i8 minus5b = __msa_ldi_b(-5);
+    v16i8 plus20b = __msa_ldi_b(20);
+
+    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
+    src -= 2;
+
+    for (loop_cnt = 4; loop_cnt--;) {
+        LD_SB2(src, 8, src0, src1);
+        src += stride;
+        LD_SB2(src, 8, src2, src3);
+        src += stride;
+        LD_SB2(src, 8, src4, src5);
+        src += stride;
+        LD_SB2(src, 8, src6, src7);
+        src += stride;
+
+        XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
+        VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec3);
+        VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec6, vec9);
+        VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec1, vec4);
+        VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec7, vec10);
+        VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec2, vec5);
+        VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec8, vec11);
+        HADD_SB4_SH(vec0, vec3, vec6, vec9, res0, res1, res2, res3);
+        DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
+                     minus5b, res0, res1, res2, res3);
+        DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
+                     plus20b, res0, res1, res2, res3);
+        VSHF_B2_SB(src4, src4, src5, src5, mask0, mask0, vec0, vec3);
+        VSHF_B2_SB(src6, src6, src7, src7, mask0, mask0, vec6, vec9);
+        VSHF_B2_SB(src4, src4, src5, src5, mask1, mask1, vec1, vec4);
+        VSHF_B2_SB(src6, src6, src7, src7, mask1, mask1, vec7, vec10);
+        VSHF_B2_SB(src4, src4, src5, src5, mask2, mask2, vec2, vec5);
+        VSHF_B2_SB(src6, src6, src7, src7, mask2, mask2, vec8, vec11);
+        HADD_SB4_SH(vec0, vec3, vec6, vec9, res4, res5, res6, res7);
+        DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
+                     minus5b, res4, res5, res6, res7);
+        DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
+                     plus20b, res4, res5, res6, res7);
+        SRARI_H4_SH(res0, res1, res2, res3, 5);
+        SRARI_H4_SH(res4, res5, res6, res7, 5);
+        SAT_SH4_SH(res0, res1, res2, res3, 7);
+        SAT_SH4_SH(res4, res5, res6, res7, 7);
+        PCKEV_B4_SB(res1, res0, res3, res2, res5, res4, res7, res6, vec0, vec1,
+                    vec2, vec3);
+        XORI_B4_128_SB(vec0, vec1, vec2, vec3);
+        ST_SB4(vec0, vec1, vec2, vec3, dst, stride);
+        dst += (4 * stride);
+    }
 }
 
-void ff_avg_h264_qpel8_mc00_msa(uint8_t *dst, const uint8_t *src,
+void ff_put_h264_qpel8_mc20_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avg_width8_msa(src, stride, dst, stride, 8);
+    v16u8 out0, out1, out2, out3;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask0, mask1, mask2;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9, vec10;
+    v16i8 vec11;
+    v8i16 res0, res1, res2, res3, res4, res5, res6, res7;
+    v16i8 minus5b = __msa_ldi_b(-5);
+    v16i8 plus20b = __msa_ldi_b(20);
+
+    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
+    LD_SB8(src - 2, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+    XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
+    VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
+    VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
+    HADD_SB4_SH(vec0, vec1, vec2, vec3, res0, res1, res2, res3);
+    VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec4, vec5);
+    VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec6, vec7);
+    DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
+                 res0, res1, res2, res3);
+    VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec8, vec9);
+    VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec10, vec11);
+    DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b,
+                 plus20b, res0, res1, res2, res3);
+    VSHF_B2_SB(src4, src4, src5, src5, mask0, mask0, vec0, vec1);
+    VSHF_B2_SB(src6, src6, src7, src7, mask0, mask0, vec2, vec3);
+    HADD_SB4_SH(vec0, vec1, vec2, vec3, res4, res5, res6, res7);
+    VSHF_B2_SB(src4, src4, src5, src5, mask1, mask1, vec4, vec5);
+    VSHF_B2_SB(src6, src6, src7, src7, mask1, mask1, vec6, vec7);
+    DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
+                 res4, res5, res6, res7);
+    VSHF_B2_SB(src4, src4, src5, src5, mask2, mask2, vec8, vec9);
+    VSHF_B2_SB(src6, src6, src7, src7, mask2, mask2, vec10, vec11);
+    DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b,
+                 plus20b, res4, res5, res6, res7);
+    SRARI_H4_SH(res0, res1, res2, res3, 5);
+    SRARI_H4_SH(res4, res5, res6, res7, 5);
+    SAT_SH4_SH(res0, res1, res2, res3, 7);
+    SAT_SH4_SH(res4, res5, res6, res7, 7);
+    out0 = PCKEV_XORI128_UB(res0, res1);
+    out1 = PCKEV_XORI128_UB(res2, res3);
+    out2 = PCKEV_XORI128_UB(res4, res5);
+    out3 = PCKEV_XORI128_UB(res6, res7);
+    ST8x8_UB(out0, out1, out2, out3, dst, stride);
 }
 
-void ff_avg_h264_qpel4_mc00_msa(uint8_t *dst, const uint8_t *src,
+void ff_put_h264_qpel4_mc20_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avg_width4_msa(src, stride, dst, stride, 4);
+    v16u8 out;
+    v16i8 src0, src1, src2, src3, mask0, mask1, mask2;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
+    v8i16 res0, res1;
+    v16i8 minus5b = __msa_ldi_b(-5);
+    v16i8 plus20b = __msa_ldi_b(20);
+
+    LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
+    LD_SB4(src - 2, stride, src0, src1, src2, src3);
+    XORI_B4_128_SB(src0, src1, src2, src3);
+    VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
+    HADD_SB2_SH(vec0, vec1, res0, res1);
+    VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec2, vec3);
+    DPADD_SB2_SH(vec2, vec3, minus5b, minus5b, res0, res1);
+    VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec4, vec5);
+    DPADD_SB2_SH(vec4, vec5, plus20b, plus20b, res0, res1);
+    SRARI_H2_SH(res0, res1, 5);
+    SAT_SH2_SH(res0, res1, 7);
+    out = PCKEV_XORI128_UB(res0, res1);
+    ST4x4_UB(out, out, 0, 1, 2, 3, dst, stride);
 }
 
-void ff_put_h264_qpel16_mc10_msa(uint8_t *dst, const uint8_t *src,
+void ff_put_h264_qpel16_mc01_msa(uint8_t *dst, const uint8_t *src,
                                  ptrdiff_t stride)
 {
-    avc_luma_hz_qrt_16w_msa(src - 2, stride, dst, stride, 16, 0);
+    int32_t loop_cnt;
+    int16_t filt_const0 = 0xfb01;
+    int16_t filt_const1 = 0x1414;
+    int16_t filt_const2 = 0x1fb;
+    v16u8 res0, res1, res2, res3;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
+    v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
+    v16i8 src87_r, src10_l, src32_l, src54_l, src76_l, src21_l, src43_l;
+    v16i8 src65_l, src87_l, filt0, filt1, filt2;
+    v8i16 out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
+
+    filt0 = (v16i8) __msa_fill_h(filt_const0);
+    filt1 = (v16i8) __msa_fill_h(filt_const1);
+    filt2 = (v16i8) __msa_fill_h(filt_const2);
+
+    src -= (stride * 2);
+
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
+    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
+               src32_r, src43_r);
+    ILVL_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_l, src21_l,
+               src32_l, src43_l);
+
+    for (loop_cnt = 4; loop_cnt--;) {
+        LD_SB4(src, stride, src5, src6, src7, src8);
+        src += (4 * stride);
+
+        XORI_B4_128_SB(src5, src6, src7, src8);
+        ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_r,
+                   src65_r, src76_r, src87_r);
+        ILVL_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_l,
+                   src65_l, src76_l, src87_l);
+        out0_r = AVC_DOT_SH3_SH(src10_r, src32_r, src54_r, filt0, filt1, filt2);
+        out1_r = AVC_DOT_SH3_SH(src21_r, src43_r, src65_r, filt0, filt1, filt2);
+        out2_r = AVC_DOT_SH3_SH(src32_r, src54_r, src76_r, filt0, filt1, filt2);
+        out3_r = AVC_DOT_SH3_SH(src43_r, src65_r, src87_r, filt0, filt1, filt2);
+        out0_l = AVC_DOT_SH3_SH(src10_l, src32_l, src54_l, filt0, filt1, filt2);
+        out1_l = AVC_DOT_SH3_SH(src21_l, src43_l, src65_l, filt0, filt1, filt2);
+        out2_l = AVC_DOT_SH3_SH(src32_l, src54_l, src76_l, filt0, filt1, filt2);
+        out3_l = AVC_DOT_SH3_SH(src43_l, src65_l, src87_l, filt0, filt1, filt2);
+        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
+        SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
+        SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 5);
+        SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
+        PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
+                    out3_r, res0, res1, res2, res3);
+        res0 = (v16u8) __msa_aver_s_b((v16i8) res0, src2);
+        res1 = (v16u8) __msa_aver_s_b((v16i8) res1, src3);
+        res2 = (v16u8) __msa_aver_s_b((v16i8) res2, src4);
+        res3 = (v16u8) __msa_aver_s_b((v16i8) res3, src5);
+        XORI_B4_128_UB(res0, res1, res2, res3);
+        ST_UB4(res0, res1, res2, res3, dst, stride);
+        dst += (4 * stride);
+
+        src10_r = src54_r;
+        src32_r = src76_r;
+        src21_r = src65_r;
+        src43_r = src87_r;
+        src10_l = src54_l;
+        src32_l = src76_l;
+        src21_l = src65_l;
+        src43_l = src87_l;
+        src2 = src6;
+        src3 = src7;
+        src4 = src8;
+    }
 }
 
-void ff_put_h264_qpel16_mc30_msa(uint8_t *dst, const uint8_t *src,
+void ff_put_h264_qpel16_mc03_msa(uint8_t *dst, const uint8_t *src,
                                  ptrdiff_t stride)
 {
-    avc_luma_hz_qrt_16w_msa(src - 2, stride, dst, stride, 16, 1);
-}
+    int32_t loop_cnt;
+    int16_t filt_const0 = 0xfb01;
+    int16_t filt_const1 = 0x1414;
+    int16_t filt_const2 = 0x1fb;
+    v16u8 res0, res1, res2, res3;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
+    v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
+    v16i8 src87_r, src10_l, src32_l, src54_l, src76_l, src21_l, src43_l;
+    v16i8 src65_l, src87_l, filt0, filt1, filt2;
+    v8i16 out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
 
-void ff_put_h264_qpel8_mc10_msa(uint8_t *dst, const uint8_t *src,
-                                ptrdiff_t stride)
-{
-    avc_luma_hz_qrt_8w_msa(src - 2, stride, dst, stride, 8, 0);
-}
+    filt0 = (v16i8) __msa_fill_h(filt_const0);
+    filt1 = (v16i8) __msa_fill_h(filt_const1);
+    filt2 = (v16i8) __msa_fill_h(filt_const2);
 
-void ff_put_h264_qpel8_mc30_msa(uint8_t *dst, const uint8_t *src,
-                                ptrdiff_t stride)
-{
-    avc_luma_hz_qrt_8w_msa(src - 2, stride, dst, stride, 8, 1);
-}
+    src -= (stride * 2);
 
-void ff_put_h264_qpel4_mc10_msa(uint8_t *dst, const uint8_t *src,
-                                ptrdiff_t stride)
-{
-    avc_luma_hz_qrt_4w_msa(src - 2, stride, dst, stride, 4, 0);
-}
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
 
-void ff_put_h264_qpel4_mc30_msa(uint8_t *dst, const uint8_t *src,
-                                ptrdiff_t stride)
-{
-    avc_luma_hz_qrt_4w_msa(src - 2, stride, dst, stride, 4, 1);
-}
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
+    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
+               src32_r, src43_r);
+    ILVL_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_l, src21_l,
+               src32_l, src43_l);
 
-void ff_put_h264_qpel16_mc20_msa(uint8_t *dst, const uint8_t *src,
-                                 ptrdiff_t stride)
-{
-    avc_luma_hz_16w_msa(src - 2, stride, dst, stride, 16);
-}
+    for (loop_cnt = 4; loop_cnt--;) {
+        LD_SB4(src, stride, src5, src6, src7, src8);
+        src += (4 * stride);
 
-void ff_put_h264_qpel8_mc20_msa(uint8_t *dst, const uint8_t *src,
-                                ptrdiff_t stride)
-{
-    avc_luma_hz_8w_msa(src - 2, stride, dst, stride, 8);
+        XORI_B4_128_SB(src5, src6, src7, src8);
+        ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_r,
+                   src65_r, src76_r, src87_r);
+        ILVL_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_l,
+                   src65_l, src76_l, src87_l);
+        out0_r = AVC_DOT_SH3_SH(src10_r, src32_r, src54_r, filt0, filt1, filt2);
+        out1_r = AVC_DOT_SH3_SH(src21_r, src43_r, src65_r, filt0, filt1, filt2);
+        out2_r = AVC_DOT_SH3_SH(src32_r, src54_r, src76_r, filt0, filt1, filt2);
+        out3_r = AVC_DOT_SH3_SH(src43_r, src65_r, src87_r, filt0, filt1, filt2);
+        out0_l = AVC_DOT_SH3_SH(src10_l, src32_l, src54_l, filt0, filt1, filt2);
+        out1_l = AVC_DOT_SH3_SH(src21_l, src43_l, src65_l, filt0, filt1, filt2);
+        out2_l = AVC_DOT_SH3_SH(src32_l, src54_l, src76_l, filt0, filt1, filt2);
+        out3_l = AVC_DOT_SH3_SH(src43_l, src65_l, src87_l, filt0, filt1, filt2);
+        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
+        SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
+        SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 5);
+        SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
+        PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
+                    out3_r, res0, res1, res2, res3);
+        res0 = (v16u8) __msa_aver_s_b((v16i8) res0, src3);
+        res1 = (v16u8) __msa_aver_s_b((v16i8) res1, src4);
+        res2 = (v16u8) __msa_aver_s_b((v16i8) res2, src5);
+        res3 = (v16u8) __msa_aver_s_b((v16i8) res3, src6);
+        XORI_B4_128_UB(res0, res1, res2, res3);
+        ST_UB4(res0, res1, res2, res3, dst, stride);
+        dst += (4 * stride);
+
+        src10_r = src54_r;
+        src32_r = src76_r;
+        src21_r = src65_r;
+        src43_r = src87_r;
+        src10_l = src54_l;
+        src32_l = src76_l;
+        src21_l = src65_l;
+        src43_l = src87_l;
+        src3 = src7;
+        src4 = src8;
+    }
 }
 
-void ff_put_h264_qpel4_mc20_msa(uint8_t *dst, const uint8_t *src,
+void ff_put_h264_qpel8_mc01_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avc_luma_hz_4w_msa(src - 2, stride, dst, stride, 4);
-}
+    const int16_t filt_const0 = 0xfb01;
+    const int16_t filt_const1 = 0x1414;
+    const int16_t filt_const2 = 0x1fb;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
+    v16i8 src11, src12, src10_r, src32_r, src54_r, src65_r, src76_r, src98_r;
+    v16i8 src21_r, src43_r, src87_r, src109_r, src1211_r, src1110_r;
+    v16i8 tmp0, tmp1, tmp2, tmp3, filt0, filt1, filt2, out0, out1, out2, out3;
+    v8i16 out0_r, out1_r, out2_r, out3_r, out4_r, out5_r, out6_r, out7_r;
 
-void ff_put_h264_qpel16_mc01_msa(uint8_t *dst, const uint8_t *src,
-                                 ptrdiff_t stride)
-{
-    avc_luma_vt_qrt_16w_msa(src - (stride * 2), stride, dst, stride, 16, 0);
-}
+    filt0 = (v16i8) __msa_fill_h(filt_const0);
+    filt1 = (v16i8) __msa_fill_h(filt_const1);
+    filt2 = (v16i8) __msa_fill_h(filt_const2);
 
-void ff_put_h264_qpel16_mc03_msa(uint8_t *dst, const uint8_t *src,
-                                 ptrdiff_t stride)
-{
-    avc_luma_vt_qrt_16w_msa(src - (stride * 2), stride, dst, stride, 16, 1);
-}
+    src -= (stride * 2);
 
-void ff_put_h264_qpel8_mc01_msa(uint8_t *dst, const uint8_t *src,
-                                ptrdiff_t stride)
-{
-    avc_luma_vt_qrt_8w_msa(src - (stride * 2), stride, dst, stride, 8, 0);
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+    LD_SB8(src, stride, src5, src6, src7, src8, src9, src10, src11, src12);
+    XORI_B8_128_SB(src5, src6, src7, src8, src9, src10, src11, src12);
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
+    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
+               src32_r, src43_r);
+    ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_r, src65_r,
+               src76_r, src87_r);
+    ILVR_B4_SB(src9, src8, src10, src9, src11, src10, src12, src11, src98_r,
+               src109_r, src1110_r, src1211_r);
+    out0_r = AVC_DOT_SH3_SH(src10_r, src32_r, src54_r, filt0, filt1, filt2);
+    out1_r = AVC_DOT_SH3_SH(src21_r, src43_r, src65_r, filt0, filt1, filt2);
+    out2_r = AVC_DOT_SH3_SH(src32_r, src54_r, src76_r, filt0, filt1, filt2);
+    out3_r = AVC_DOT_SH3_SH(src43_r, src65_r, src87_r, filt0, filt1, filt2);
+    out4_r = AVC_DOT_SH3_SH(src54_r, src76_r, src98_r, filt0, filt1, filt2);
+    out5_r = AVC_DOT_SH3_SH(src65_r, src87_r, src109_r, filt0, filt1, filt2);
+    out6_r = AVC_DOT_SH3_SH(src76_r, src98_r, src1110_r, filt0, filt1, filt2);
+    out7_r = AVC_DOT_SH3_SH(src87_r, src109_r, src1211_r, filt0, filt1, filt2);
+    PCKEV_D2_SB(src3, src2, src5, src4, tmp0, tmp1);
+    PCKEV_D2_SB(src7, src6, src9, src8, tmp2, tmp3);
+    SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
+    SRARI_H4_SH(out4_r, out5_r, out6_r, out7_r, 5);
+    SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
+    SAT_SH4_SH(out4_r, out5_r, out6_r, out7_r, 7);
+    PCKEV_B2_SB(out1_r, out0_r, out3_r, out2_r, out0, out1);
+    PCKEV_B2_SB(out5_r, out4_r, out7_r, out6_r, out2, out3);
+    out0 = __msa_aver_s_b(out0, tmp0);
+    out1 = __msa_aver_s_b(out1, tmp1);
+    out2 = __msa_aver_s_b(out2, tmp2);
+    out3 = __msa_aver_s_b(out3, tmp3);
+    XORI_B4_128_SB(out0, out1, out2, out3);
+    ST8x8_UB(out0, out1, out2, out3, dst, stride);
 }
 
 void ff_put_h264_qpel8_mc03_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avc_luma_vt_qrt_8w_msa(src - (stride * 2), stride, dst, stride, 8, 1);
+    const int16_t filt_const0 = 0xfb01;
+    const int16_t filt_const1 = 0x1414;
+    const int16_t filt_const2 = 0x1fb;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
+    v16i8 src11, src12, src10_r, src32_r, src54_r, src65_r, src76_r, src98_r;
+    v16i8 src21_r, src43_r, src87_r, src109_r, src1211_r, src1110_r;
+    v16i8 filt0, filt1, filt2, out0, out1, out2, out3, tmp0, tmp1, tmp2, tmp3;
+    v8i16 out0_r, out1_r, out2_r, out3_r, out4_r, out5_r, out6_r, out7_r;
+
+    filt0 = (v16i8) __msa_fill_h(filt_const0);
+    filt1 = (v16i8) __msa_fill_h(filt_const1);
+    filt2 = (v16i8) __msa_fill_h(filt_const2);
+
+    src -= (stride * 2);
+
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+    LD_SB8(src, stride, src5, src6, src7, src8, src9, src10, src11, src12);
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
+    XORI_B8_128_SB(src5, src6, src7, src8, src9, src10, src11, src12);
+    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
+               src32_r, src43_r);
+    ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_r, src65_r,
+               src76_r, src87_r);
+    ILVR_B4_SB(src9, src8, src10, src9, src11, src10, src12, src11, src98_r,
+               src109_r, src1110_r, src1211_r);
+    out0_r = AVC_DOT_SH3_SH(src10_r, src32_r, src54_r, filt0, filt1, filt2);
+    out1_r = AVC_DOT_SH3_SH(src21_r, src43_r, src65_r, filt0, filt1, filt2);
+    out2_r = AVC_DOT_SH3_SH(src32_r, src54_r, src76_r, filt0, filt1, filt2);
+    out3_r = AVC_DOT_SH3_SH(src43_r, src65_r, src87_r, filt0, filt1, filt2);
+    out4_r = AVC_DOT_SH3_SH(src54_r, src76_r, src98_r, filt0, filt1, filt2);
+    out5_r = AVC_DOT_SH3_SH(src65_r, src87_r, src109_r, filt0, filt1, filt2);
+    out6_r = AVC_DOT_SH3_SH(src76_r, src98_r, src1110_r, filt0, filt1, filt2);
+    out7_r = AVC_DOT_SH3_SH(src87_r, src109_r, src1211_r, filt0, filt1, filt2);
+    PCKEV_D2_SB(src4, src3, src6, src5, tmp0, tmp1);
+    PCKEV_D2_SB(src8, src7, src10, src9, tmp2, tmp3);
+    SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
+    SRARI_H4_SH(out4_r, out5_r, out6_r, out7_r, 5);
+    SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
+    SAT_SH4_SH(out4_r, out5_r, out6_r, out7_r, 7);
+    PCKEV_B2_SB(out1_r, out0_r, out3_r, out2_r, out0, out1);
+    PCKEV_B2_SB(out5_r, out4_r, out7_r, out6_r, out2, out3);
+    out0 = __msa_aver_s_b(out0, tmp0);
+    out1 = __msa_aver_s_b(out1, tmp1);
+    out2 = __msa_aver_s_b(out2, tmp2);
+    out3 = __msa_aver_s_b(out3, tmp3);
+    XORI_B4_128_SB(out0, out1, out2, out3);
+    ST8x8_UB(out0, out1, out2, out3, dst, stride);
 }
 
 void ff_put_h264_qpel4_mc01_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avc_luma_vt_qrt_4w_msa(src - (stride * 2), stride, dst, stride, 4, 0);
+    int16_t filt_const0 = 0xfb01;
+    int16_t filt_const1 = 0x1414;
+    int16_t filt_const2 = 0x1fb;
+    v16u8 out;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
+    v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
+    v16i8 src87_r, src2110, src4332, src6554, src8776, filt0, filt1, filt2;
+    v8i16 out10, out32;
+
+    filt0 = (v16i8) __msa_fill_h(filt_const0);
+    filt1 = (v16i8) __msa_fill_h(filt_const1);
+    filt2 = (v16i8) __msa_fill_h(filt_const2);
+
+    src -= (stride * 2);
+
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
+               src32_r, src43_r);
+    ILVR_D2_SB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
+    XORI_B2_128_SB(src2110, src4332);
+    LD_SB4(src, stride, src5, src6, src7, src8);
+    ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_r, src65_r,
+               src76_r, src87_r);
+    ILVR_D2_SB(src65_r, src54_r, src87_r, src76_r, src6554, src8776);
+    XORI_B2_128_SB(src6554, src8776);
+    out10 = AVC_DOT_SH3_SH(src2110, src4332, src6554, filt0, filt1, filt2);
+    out32 = AVC_DOT_SH3_SH(src4332, src6554, src8776, filt0, filt1, filt2);
+    SRARI_H2_SH(out10, out32, 5);
+    SAT_SH2_SH(out10, out32, 7);
+    out = PCKEV_XORI128_UB(out10, out32);
+    src32_r = (v16i8) __msa_insve_w((v4i32) src2, 1, (v4i32) src3);
+    src54_r = (v16i8) __msa_insve_w((v4i32) src4, 1, (v4i32) src5);
+    src32_r = (v16i8) __msa_insve_d((v2i64) src32_r, 1, (v2i64) src54_r);
+    out = __msa_aver_u_b(out, (v16u8) src32_r);
+    ST4x4_UB(out, out, 0, 1, 2, 3, dst, stride);
 }
 
 void ff_put_h264_qpel4_mc03_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avc_luma_vt_qrt_4w_msa(src - (stride * 2), stride, dst, stride, 4, 1);
+    int16_t filt_const0 = 0xfb01;
+    int16_t filt_const1 = 0x1414;
+    int16_t filt_const2 = 0x1fb;
+    v16u8 out;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
+    v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
+    v16i8 src87_r, src2110, src4332, src6554, src8776, filt0, filt1, filt2;
+    v8i16 out10, out32;
+
+    filt0 = (v16i8) __msa_fill_h(filt_const0);
+    filt1 = (v16i8) __msa_fill_h(filt_const1);
+    filt2 = (v16i8) __msa_fill_h(filt_const2);
+
+    src -= (stride * 2);
+
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
+               src32_r, src43_r);
+    ILVR_D2_SB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
+    XORI_B2_128_SB(src2110, src4332);
+    LD_SB4(src, stride, src5, src6, src7, src8);
+    ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_r, src65_r,
+               src76_r, src87_r);
+    ILVR_D2_SB(src65_r, src54_r, src87_r, src76_r, src6554, src8776);
+    XORI_B2_128_SB(src6554, src8776);
+    out10 = AVC_DOT_SH3_SH(src2110, src4332, src6554, filt0, filt1, filt2);
+    out32 = AVC_DOT_SH3_SH(src4332, src6554, src8776, filt0, filt1, filt2);
+    SRARI_H2_SH(out10, out32, 5);
+    SAT_SH2_SH(out10, out32, 7);
+    out = PCKEV_XORI128_UB(out10, out32);
+    src32_r = (v16i8) __msa_insve_w((v4i32) src3, 1, (v4i32) src4);
+    src54_r = (v16i8) __msa_insve_w((v4i32) src5, 1, (v4i32) src6);
+    src32_r = (v16i8) __msa_insve_d((v2i64) src32_r, 1, (v2i64) src54_r);
+    out = __msa_aver_u_b(out, (v16u8) src32_r);
+    ST4x4_UB(out, out, 0, 1, 2, 3, dst, stride);
 }
 
 void ff_put_h264_qpel16_mc11_msa(uint8_t *dst, const uint8_t *src,
@@ -3172,57 +2855,780 @@ void ff_put_h264_qpel4_mc33_msa(uint8_t *dst, const uint8_t *src,
 void ff_put_h264_qpel16_mc21_msa(uint8_t *dst, const uint8_t *src,
                                  ptrdiff_t stride)
 {
-    avc_luma_midv_qrt_16w_msa(src - (2 * stride) - 2,
-                              stride, dst, stride, 16, 0);
+    uint8_t *dst_tmp = dst;
+    const uint8_t *src_tmp = src - (2 * stride) - 2;
+    uint32_t multiple8_cnt, loop_cnt;
+    const int32_t filt_const0 = 0xfffb0001;
+    const int32_t filt_const1 = 0x140014;
+    const int32_t filt_const2 = 0x1fffb;
+    v16u8 out0, out1;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, mask0, mask1;
+    v16i8 mask2;
+    v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
+    v8i16 hz_out7, hz_out8, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
+    v8i16 hz_out10_r, hz_out21_r, hz_out32_r, hz_out43_r, hz_out54_r;
+    v8i16 hz_out65_r, hz_out76_r, hz_out87_r, hz_out10_l, hz_out21_l;
+    v8i16 hz_out32_l, hz_out43_l, hz_out54_l, hz_out65_l, hz_out76_l;
+    v8i16 hz_out87_l, filt0, filt1, filt2;
+    v4i32 tmp0, tmp1;
+
+    filt0 = (v8i16) __msa_fill_w(filt_const0);
+    filt1 = (v8i16) __msa_fill_w(filt_const1);
+    filt2 = (v8i16) __msa_fill_w(filt_const2);
+
+    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
+
+    for (multiple8_cnt = 2; multiple8_cnt--;) {
+        dst = dst_tmp;
+        src = src_tmp;
+
+        LD_SB5(src, stride, src0, src1, src2, src3, src4);
+        XORI_B5_128_SB(src0, src1, src2, src3, src4);
+        src += (5 * stride);
+
+        hz_out0 = AVC_HORZ_FILTER_SH(src0, src0, mask0, mask1, mask2);
+        hz_out1 = AVC_HORZ_FILTER_SH(src1, src1, mask0, mask1, mask2);
+        hz_out2 = AVC_HORZ_FILTER_SH(src2, src2, mask0, mask1, mask2);
+        hz_out3 = AVC_HORZ_FILTER_SH(src3, src3, mask0, mask1, mask2);
+        hz_out4 = AVC_HORZ_FILTER_SH(src4, src4, mask0, mask1, mask2);
+
+        for (loop_cnt = 4; loop_cnt--;) {
+            LD_SB4(src, stride, src5, src6, src7, src8);
+            src += (4 * stride);
+
+            XORI_B4_128_SB(src5, src6, src7, src8);
+
+            hz_out5 = AVC_HORZ_FILTER_SH(src5, src5, mask0, mask1, mask2);
+            hz_out6 = AVC_HORZ_FILTER_SH(src6, src6, mask0, mask1, mask2);
+            hz_out7 = AVC_HORZ_FILTER_SH(src7, src7, mask0, mask1, mask2);
+            hz_out8 = AVC_HORZ_FILTER_SH(src8, src8, mask0, mask1, mask2);
+
+            ILVR_H4_SH(hz_out1, hz_out0, hz_out2, hz_out1, hz_out3, hz_out2,
+                       hz_out4, hz_out3, hz_out10_r, hz_out21_r, hz_out32_r,
+                       hz_out43_r);
+            ILVL_H4_SH(hz_out1, hz_out0, hz_out2, hz_out1, hz_out3, hz_out2,
+                       hz_out4, hz_out3, hz_out10_l, hz_out21_l, hz_out32_l,
+                       hz_out43_l);
+            ILVR_H4_SH(hz_out5, hz_out4, hz_out6, hz_out5, hz_out7, hz_out6,
+                       hz_out8, hz_out7, hz_out54_r, hz_out65_r, hz_out76_r,
+                       hz_out87_r);
+            ILVL_H4_SH(hz_out5, hz_out4, hz_out6, hz_out5, hz_out7, hz_out6,
+                       hz_out8, hz_out7, hz_out54_l, hz_out65_l, hz_out76_l,
+                       hz_out87_l);
+
+            tmp0 = AVC_DOT_SW3_SW(hz_out10_r, hz_out32_r, hz_out54_r, filt0,
+                                  filt1, filt2);
+            tmp1 = AVC_DOT_SW3_SW(hz_out10_l, hz_out32_l, hz_out54_l, filt0,
+                                  filt1, filt2);
+            dst0 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+            tmp0 = AVC_DOT_SW3_SW(hz_out21_r, hz_out43_r, hz_out65_r, filt0,
+                                  filt1, filt2);
+            tmp1 = AVC_DOT_SW3_SW(hz_out21_l, hz_out43_l, hz_out65_l, filt0,
+                                  filt1, filt2);
+            dst2 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+            tmp0 = AVC_DOT_SW3_SW(hz_out32_r, hz_out54_r, hz_out76_r, filt0,
+                                  filt1, filt2);
+            tmp1 = AVC_DOT_SW3_SW(hz_out32_l, hz_out54_l, hz_out76_l, filt0,
+                                  filt1, filt2);
+            dst4 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+            tmp0 = AVC_DOT_SW3_SW(hz_out43_r, hz_out65_r, hz_out87_r, filt0,
+                                  filt1, filt2);
+            tmp1 = AVC_DOT_SW3_SW(hz_out43_l, hz_out65_l, hz_out87_l, filt0,
+                                  filt1, filt2);
+            dst6 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+
+            dst1 = __msa_srari_h(hz_out2, 5);
+            dst3 = __msa_srari_h(hz_out3, 5);
+            dst5 = __msa_srari_h(hz_out4, 5);
+            dst7 = __msa_srari_h(hz_out5, 5);
+            SAT_SH4_SH(dst1, dst3, dst5, dst7, 7);
+
+            dst0 = __msa_aver_s_h(dst0, dst1);
+            dst1 = __msa_aver_s_h(dst2, dst3);
+            dst2 = __msa_aver_s_h(dst4, dst5);
+            dst3 = __msa_aver_s_h(dst6, dst7);
+
+            out0 = PCKEV_XORI128_UB(dst0, dst1);
+            out1 = PCKEV_XORI128_UB(dst2, dst3);
+            ST8x4_UB(out0, out1, dst, stride);
+            dst += (4 * stride);
+
+            hz_out0 = hz_out4;
+            hz_out1 = hz_out5;
+            hz_out2 = hz_out6;
+            hz_out3 = hz_out7;
+            hz_out4 = hz_out8;
+        }
+
+        src_tmp += 8;
+        dst_tmp += 8;
+    }
 }
 
 void ff_put_h264_qpel16_mc23_msa(uint8_t *dst, const uint8_t *src,
                                  ptrdiff_t stride)
 {
-    avc_luma_midv_qrt_16w_msa(src - (2 * stride) - 2,
-                              stride, dst, stride, 16, 1);
+    uint8_t *dst_tmp = dst;
+    const uint8_t *src_tmp = src - (2 * stride) - 2;
+    uint32_t multiple8_cnt, loop_cnt;
+    const int32_t filt_const0 = 0xfffb0001;
+    const int32_t filt_const1 = 0x140014;
+    const int32_t filt_const2 = 0x1fffb;
+    v16u8 out0, out1;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, mask0, mask1;
+    v16i8 mask2;
+    v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
+    v8i16 hz_out7, hz_out8, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
+    v8i16 hz_out10_r, hz_out21_r, hz_out32_r, hz_out43_r, hz_out54_r;
+    v8i16 hz_out65_r, hz_out76_r, hz_out87_r, hz_out10_l, hz_out21_l;
+    v8i16 hz_out32_l, hz_out43_l, hz_out54_l, hz_out65_l, hz_out76_l;
+    v8i16 hz_out87_l, filt0, filt1, filt2;
+    v4i32 tmp0, tmp1;
+
+    filt0 = (v8i16) __msa_fill_w(filt_const0);
+    filt1 = (v8i16) __msa_fill_w(filt_const1);
+    filt2 = (v8i16) __msa_fill_w(filt_const2);
+
+    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
+
+    for (multiple8_cnt = 2; multiple8_cnt--;) {
+        dst = dst_tmp;
+        src = src_tmp;
+
+        LD_SB5(src, stride, src0, src1, src2, src3, src4);
+        XORI_B5_128_SB(src0, src1, src2, src3, src4);
+        src += (5 * stride);
+
+        hz_out0 = AVC_HORZ_FILTER_SH(src0, src0, mask0, mask1, mask2);
+        hz_out1 = AVC_HORZ_FILTER_SH(src1, src1, mask0, mask1, mask2);
+        hz_out2 = AVC_HORZ_FILTER_SH(src2, src2, mask0, mask1, mask2);
+        hz_out3 = AVC_HORZ_FILTER_SH(src3, src3, mask0, mask1, mask2);
+        hz_out4 = AVC_HORZ_FILTER_SH(src4, src4, mask0, mask1, mask2);
+
+        for (loop_cnt = 4; loop_cnt--;) {
+            LD_SB4(src, stride, src5, src6, src7, src8);
+            src += (4 * stride);
+
+            XORI_B4_128_SB(src5, src6, src7, src8);
+
+            hz_out5 = AVC_HORZ_FILTER_SH(src5, src5, mask0, mask1, mask2);
+            hz_out6 = AVC_HORZ_FILTER_SH(src6, src6, mask0, mask1, mask2);
+            hz_out7 = AVC_HORZ_FILTER_SH(src7, src7, mask0, mask1, mask2);
+            hz_out8 = AVC_HORZ_FILTER_SH(src8, src8, mask0, mask1, mask2);
+
+            ILVR_H4_SH(hz_out1, hz_out0, hz_out2, hz_out1, hz_out3, hz_out2,
+                       hz_out4, hz_out3, hz_out10_r, hz_out21_r, hz_out32_r,
+                       hz_out43_r);
+            ILVL_H4_SH(hz_out1, hz_out0, hz_out2, hz_out1, hz_out3, hz_out2,
+                       hz_out4, hz_out3, hz_out10_l, hz_out21_l, hz_out32_l,
+                       hz_out43_l);
+            ILVR_H4_SH(hz_out5, hz_out4, hz_out6, hz_out5, hz_out7, hz_out6,
+                       hz_out8, hz_out7, hz_out54_r, hz_out65_r, hz_out76_r,
+                       hz_out87_r);
+            ILVL_H4_SH(hz_out5, hz_out4, hz_out6, hz_out5, hz_out7, hz_out6,
+                       hz_out8, hz_out7, hz_out54_l, hz_out65_l, hz_out76_l,
+                       hz_out87_l);
+
+            tmp0 = AVC_DOT_SW3_SW(hz_out10_r, hz_out32_r, hz_out54_r, filt0,
+                                  filt1, filt2);
+            tmp1 = AVC_DOT_SW3_SW(hz_out10_l, hz_out32_l, hz_out54_l, filt0,
+                                  filt1, filt2);
+            dst0 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+            tmp0 = AVC_DOT_SW3_SW(hz_out21_r, hz_out43_r, hz_out65_r, filt0,
+                                  filt1, filt2);
+            tmp1 = AVC_DOT_SW3_SW(hz_out21_l, hz_out43_l, hz_out65_l, filt0,
+                                  filt1, filt2);
+            dst2 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+            tmp0 = AVC_DOT_SW3_SW(hz_out32_r, hz_out54_r, hz_out76_r, filt0,
+                                  filt1, filt2);
+            tmp1 = AVC_DOT_SW3_SW(hz_out32_l, hz_out54_l, hz_out76_l, filt0,
+                                  filt1, filt2);
+            dst4 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+            tmp0 = AVC_DOT_SW3_SW(hz_out43_r, hz_out65_r, hz_out87_r, filt0,
+                                  filt1, filt2);
+            tmp1 = AVC_DOT_SW3_SW(hz_out43_l, hz_out65_l, hz_out87_l, filt0,
+                                  filt1, filt2);
+            dst6 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+
+            dst1 = __msa_srari_h(hz_out3, 5);
+            dst3 = __msa_srari_h(hz_out4, 5);
+            dst5 = __msa_srari_h(hz_out5, 5);
+            dst7 = __msa_srari_h(hz_out6, 5);
+            SAT_SH4_SH(dst1, dst3, dst5, dst7, 7);
+
+            dst0 = __msa_aver_s_h(dst0, dst1);
+            dst1 = __msa_aver_s_h(dst2, dst3);
+            dst2 = __msa_aver_s_h(dst4, dst5);
+            dst3 = __msa_aver_s_h(dst6, dst7);
+
+            out0 = PCKEV_XORI128_UB(dst0, dst1);
+            out1 = PCKEV_XORI128_UB(dst2, dst3);
+            ST8x4_UB(out0, out1, dst, stride);
+            dst += (4 * stride);
+
+            hz_out0 = hz_out4;
+            hz_out1 = hz_out5;
+            hz_out2 = hz_out6;
+            hz_out3 = hz_out7;
+            hz_out4 = hz_out8;
+        }
+
+        src_tmp += 8;
+        dst_tmp += 8;
+    }
 }
 
 void ff_put_h264_qpel8_mc21_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avc_luma_midv_qrt_8w_msa(src - (2 * stride) - 2, stride, dst, stride, 8, 0);
+    const int32_t filt_const0 = 0xfffb0001;
+    const int32_t filt_const1 = 0x140014;
+    const int32_t filt_const2 = 0x1fffb;
+    v16u8 out0, out1;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
+    v16i8 src11, src12, mask0, mask1, mask2;
+    v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
+    v8i16 hz_out7, hz_out8, hz_out9, hz_out10, hz_out11, hz_out12;
+    v8i16 hz_out10_r, hz_out21_r, hz_out32_r, hz_out43_r, hz_out54_r;
+    v8i16 hz_out65_r, hz_out76_r, hz_out87_r, hz_out89_r, hz_out910_r;
+    v8i16 hz_out1110_r, hz_out1211_r, dst0, dst1, dst2, dst3;
+    v8i16 hz_out10_l, hz_out21_l, hz_out32_l, hz_out43_l, hz_out54_l;
+    v8i16 hz_out65_l, hz_out76_l, hz_out87_l, hz_out89_l, hz_out910_l;
+    v8i16 hz_out1110_l, hz_out1211_l, filt0, filt1, filt2;
+    v4i32 tmp0, tmp1;
+
+    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
+
+    filt0 = (v8i16) __msa_fill_w(filt_const0);
+    filt1 = (v8i16) __msa_fill_w(filt_const1);
+    filt2 = (v8i16) __msa_fill_w(filt_const2);
+
+    src -= ((2 * stride) + 2);
+
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
+    src += (5 * stride);
+
+    hz_out0 = AVC_HORZ_FILTER_SH(src0, src0, mask0, mask1, mask2);
+    hz_out1 = AVC_HORZ_FILTER_SH(src1, src1, mask0, mask1, mask2);
+    hz_out2 = AVC_HORZ_FILTER_SH(src2, src2, mask0, mask1, mask2);
+    hz_out3 = AVC_HORZ_FILTER_SH(src3, src3, mask0, mask1, mask2);
+    hz_out4 = AVC_HORZ_FILTER_SH(src4, src4, mask0, mask1, mask2);
+
+    LD_SB4(src, stride, src5, src6, src7, src8);
+    src += (4 * stride);
+    XORI_B4_128_SB(src5, src6, src7, src8);
+
+    hz_out5 = AVC_HORZ_FILTER_SH(src5, src5, mask0, mask1, mask2);
+    hz_out6 = AVC_HORZ_FILTER_SH(src6, src6, mask0, mask1, mask2);
+    hz_out7 = AVC_HORZ_FILTER_SH(src7, src7, mask0, mask1, mask2);
+    hz_out8 = AVC_HORZ_FILTER_SH(src8, src8, mask0, mask1, mask2);
+
+    ILVR_H4_SH(hz_out1, hz_out0, hz_out2, hz_out1, hz_out3, hz_out2, hz_out4,
+               hz_out3, hz_out10_r, hz_out21_r, hz_out32_r, hz_out43_r);
+    ILVL_H4_SH(hz_out1, hz_out0, hz_out2, hz_out1, hz_out3, hz_out2, hz_out4,
+               hz_out3, hz_out10_l, hz_out21_l, hz_out32_l, hz_out43_l);
+    ILVR_H4_SH(hz_out5, hz_out4, hz_out6, hz_out5, hz_out7, hz_out6, hz_out8,
+               hz_out7, hz_out54_r, hz_out65_r, hz_out76_r, hz_out87_r);
+    ILVL_H4_SH(hz_out5, hz_out4, hz_out6, hz_out5, hz_out7, hz_out6, hz_out8,
+               hz_out7, hz_out54_l, hz_out65_l, hz_out76_l, hz_out87_l);
+
+    tmp0 = AVC_DOT_SW3_SW(hz_out10_r, hz_out32_r, hz_out54_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out10_l, hz_out32_l, hz_out54_l, filt0, filt1,
+                          filt2);
+    dst0 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out21_r, hz_out43_r, hz_out65_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out21_l, hz_out43_l, hz_out65_l, filt0, filt1,
+                          filt2);
+    dst1 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out32_r, hz_out54_r, hz_out76_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out32_l, hz_out54_l, hz_out76_l, filt0, filt1,
+                          filt2);
+    dst2 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out43_r, hz_out65_r, hz_out87_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out43_l, hz_out65_l, hz_out87_l, filt0, filt1,
+                          filt2);
+    dst3 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+
+    SRARI_H4_SH(hz_out2, hz_out3, hz_out4, hz_out5, 5);
+    SAT_SH4_SH(hz_out2, hz_out3, hz_out4, hz_out5, 7);
+
+    dst0 = __msa_aver_s_h(dst0, hz_out2);
+    dst1 = __msa_aver_s_h(dst1, hz_out3);
+    dst2 = __msa_aver_s_h(dst2, hz_out4);
+    dst3 = __msa_aver_s_h(dst3, hz_out5);
+
+    out0 = PCKEV_XORI128_UB(dst0, dst1);
+    out1 = PCKEV_XORI128_UB(dst2, dst3);
+    ST8x4_UB(out0, out1, dst, stride);
+    dst += (4 * stride);
+
+    LD_SB4(src, stride, src9, src10, src11, src12);
+    XORI_B4_128_SB(src9, src10, src11, src12);
+    hz_out9 = AVC_HORZ_FILTER_SH(src9, src9, mask0, mask1, mask2);
+    hz_out10 = AVC_HORZ_FILTER_SH(src10, src10, mask0, mask1, mask2);
+    hz_out11 = AVC_HORZ_FILTER_SH(src11, src11, mask0, mask1, mask2);
+    hz_out12 = AVC_HORZ_FILTER_SH(src12, src12, mask0, mask1, mask2);
+    ILVR_H4_SH(hz_out9, hz_out8, hz_out10, hz_out9, hz_out11, hz_out10,
+               hz_out12, hz_out11, hz_out89_r, hz_out910_r, hz_out1110_r,
+               hz_out1211_r);
+    ILVL_H4_SH(hz_out9, hz_out8, hz_out10, hz_out9, hz_out11, hz_out10,
+               hz_out12, hz_out11, hz_out89_l, hz_out910_l, hz_out1110_l,
+               hz_out1211_l);
+    tmp0 = AVC_DOT_SW3_SW(hz_out54_r, hz_out76_r, hz_out89_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out54_l, hz_out76_l, hz_out89_l, filt0, filt1,
+                          filt2);
+    dst0 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out65_r, hz_out87_r, hz_out910_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out65_l, hz_out87_l, hz_out910_l, filt0, filt1,
+                          filt2);
+    dst1 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out76_r, hz_out89_r, hz_out1110_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out76_l, hz_out89_l, hz_out1110_l, filt0, filt1,
+                          filt2);
+    dst2 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out87_r, hz_out910_r, hz_out1211_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out87_l, hz_out910_l, hz_out1211_l, filt0, filt1,
+                          filt2);
+    dst3 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+
+    SRARI_H4_SH(hz_out6, hz_out7, hz_out8, hz_out9, 5);
+    SAT_SH4_SH(hz_out6, hz_out7, hz_out8, hz_out9, 7);
+
+    dst0 = __msa_aver_s_h(dst0, hz_out6);
+    dst1 = __msa_aver_s_h(dst1, hz_out7);
+    dst2 = __msa_aver_s_h(dst2, hz_out8);
+    dst3 = __msa_aver_s_h(dst3, hz_out9);
+
+    out0 = PCKEV_XORI128_UB(dst0, dst1);
+    out1 = PCKEV_XORI128_UB(dst2, dst3);
+    ST8x4_UB(out0, out1, dst, stride);
 }
 
 void ff_put_h264_qpel8_mc23_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avc_luma_midv_qrt_8w_msa(src - (2 * stride) - 2, stride, dst, stride, 8, 1);
+    const int32_t filt_const0 = 0xfffb0001;
+    const int32_t filt_const1 = 0x140014;
+    const int32_t filt_const2 = 0x1fffb;
+    v16u8 out0, out1;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
+    v16i8 src11, src12, mask0, mask1, mask2;
+    v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
+    v8i16 hz_out7, hz_out8, hz_out9, hz_out10, hz_out11, hz_out12;
+    v8i16 hz_out10_r, hz_out21_r, hz_out32_r, hz_out43_r, hz_out54_r;
+    v8i16 hz_out65_r, hz_out76_r, hz_out87_r, hz_out89_r, hz_out910_r;
+    v8i16 hz_out1110_r, hz_out1211_r, dst0, dst1, dst2, dst3;
+    v8i16 hz_out10_l, hz_out21_l, hz_out32_l, hz_out43_l, hz_out54_l;
+    v8i16 hz_out65_l, hz_out76_l, hz_out87_l, hz_out89_l, hz_out910_l;
+    v8i16 hz_out1110_l, hz_out1211_l, filt0, filt1, filt2;
+    v4i32 tmp0, tmp1;
+
+    LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
+
+    filt0 = (v8i16) __msa_fill_w(filt_const0);
+    filt1 = (v8i16) __msa_fill_w(filt_const1);
+    filt2 = (v8i16) __msa_fill_w(filt_const2);
+
+    src -= ((2 * stride) + 2);
+
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
+    src += (5 * stride);
+
+    hz_out0 = AVC_HORZ_FILTER_SH(src0, src0, mask0, mask1, mask2);
+    hz_out1 = AVC_HORZ_FILTER_SH(src1, src1, mask0, mask1, mask2);
+    hz_out2 = AVC_HORZ_FILTER_SH(src2, src2, mask0, mask1, mask2);
+    hz_out3 = AVC_HORZ_FILTER_SH(src3, src3, mask0, mask1, mask2);
+    hz_out4 = AVC_HORZ_FILTER_SH(src4, src4, mask0, mask1, mask2);
+
+    LD_SB4(src, stride, src5, src6, src7, src8);
+    src += (4 * stride);
+    XORI_B4_128_SB(src5, src6, src7, src8);
+
+    hz_out5 = AVC_HORZ_FILTER_SH(src5, src5, mask0, mask1, mask2);
+    hz_out6 = AVC_HORZ_FILTER_SH(src6, src6, mask0, mask1, mask2);
+    hz_out7 = AVC_HORZ_FILTER_SH(src7, src7, mask0, mask1, mask2);
+    hz_out8 = AVC_HORZ_FILTER_SH(src8, src8, mask0, mask1, mask2);
+
+    ILVR_H4_SH(hz_out1, hz_out0, hz_out2, hz_out1, hz_out3, hz_out2, hz_out4,
+               hz_out3, hz_out10_r, hz_out21_r, hz_out32_r, hz_out43_r);
+    ILVL_H4_SH(hz_out1, hz_out0, hz_out2, hz_out1, hz_out3, hz_out2, hz_out4,
+               hz_out3, hz_out10_l, hz_out21_l, hz_out32_l, hz_out43_l);
+    ILVR_H4_SH(hz_out5, hz_out4, hz_out6, hz_out5, hz_out7, hz_out6, hz_out8,
+               hz_out7, hz_out54_r, hz_out65_r, hz_out76_r, hz_out87_r);
+    ILVL_H4_SH(hz_out5, hz_out4, hz_out6, hz_out5, hz_out7, hz_out6, hz_out8,
+               hz_out7, hz_out54_l, hz_out65_l, hz_out76_l, hz_out87_l);
+
+    tmp0 = AVC_DOT_SW3_SW(hz_out10_r, hz_out32_r, hz_out54_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out10_l, hz_out32_l, hz_out54_l, filt0, filt1,
+                          filt2);
+    dst0 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out21_r, hz_out43_r, hz_out65_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out21_l, hz_out43_l, hz_out65_l, filt0, filt1,
+                          filt2);
+    dst1 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out32_r, hz_out54_r, hz_out76_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out32_l, hz_out54_l, hz_out76_l, filt0, filt1,
+                          filt2);
+    dst2 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out43_r, hz_out65_r, hz_out87_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out43_l, hz_out65_l, hz_out87_l, filt0, filt1,
+                          filt2);
+    dst3 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+
+    SRARI_H4_SH(hz_out3, hz_out4, hz_out5, hz_out6, 5);
+    SAT_SH4_SH(hz_out3, hz_out4, hz_out5, hz_out6, 7);
+
+    dst0 = __msa_aver_s_h(dst0, hz_out3);
+    dst1 = __msa_aver_s_h(dst1, hz_out4);
+    dst2 = __msa_aver_s_h(dst2, hz_out5);
+    dst3 = __msa_aver_s_h(dst3, hz_out6);
+
+    out0 = PCKEV_XORI128_UB(dst0, dst1);
+    out1 = PCKEV_XORI128_UB(dst2, dst3);
+    ST8x4_UB(out0, out1, dst, stride);
+    dst += (4 * stride);
+
+    LD_SB4(src, stride, src9, src10, src11, src12);
+    XORI_B4_128_SB(src9, src10, src11, src12);
+    hz_out9 = AVC_HORZ_FILTER_SH(src9, src9, mask0, mask1, mask2);
+    hz_out10 = AVC_HORZ_FILTER_SH(src10, src10, mask0, mask1, mask2);
+    hz_out11 = AVC_HORZ_FILTER_SH(src11, src11, mask0, mask1, mask2);
+    hz_out12 = AVC_HORZ_FILTER_SH(src12, src12, mask0, mask1, mask2);
+    ILVR_H4_SH(hz_out9, hz_out8, hz_out10, hz_out9, hz_out11, hz_out10,
+               hz_out12, hz_out11, hz_out89_r, hz_out910_r, hz_out1110_r,
+               hz_out1211_r);
+    ILVL_H4_SH(hz_out9, hz_out8, hz_out10, hz_out9, hz_out11, hz_out10,
+               hz_out12, hz_out11, hz_out89_l, hz_out910_l, hz_out1110_l,
+               hz_out1211_l);
+    tmp0 = AVC_DOT_SW3_SW(hz_out54_r, hz_out76_r, hz_out89_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out54_l, hz_out76_l, hz_out89_l, filt0, filt1,
+                          filt2);
+    dst0 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out65_r, hz_out87_r, hz_out910_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out65_l, hz_out87_l, hz_out910_l, filt0, filt1,
+                          filt2);
+    dst1 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out76_r, hz_out89_r, hz_out1110_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out76_l, hz_out89_l, hz_out1110_l, filt0, filt1,
+                          filt2);
+    dst2 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out87_r, hz_out910_r, hz_out1211_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out87_l, hz_out910_l, hz_out1211_l, filt0, filt1,
+                          filt2);
+    dst3 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+
+    SRARI_H4_SH(hz_out7, hz_out8, hz_out9, hz_out10, 5);
+    SAT_SH4_SH(hz_out7, hz_out8, hz_out9, hz_out10, 7);
+
+    dst0 = __msa_aver_s_h(dst0, hz_out7);
+    dst1 = __msa_aver_s_h(dst1, hz_out8);
+    dst2 = __msa_aver_s_h(dst2, hz_out9);
+    dst3 = __msa_aver_s_h(dst3, hz_out10);
+
+    out0 = PCKEV_XORI128_UB(dst0, dst1);
+    out1 = PCKEV_XORI128_UB(dst2, dst3);
+    ST8x4_UB(out0, out1, dst, stride);
 }
 
 void ff_put_h264_qpel4_mc21_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avc_luma_midv_qrt_4w_msa(src - (2 * stride) - 2, stride, dst, stride, 4, 0);
+    const int32_t filt_const0 = 0xfffb0001;
+    const int32_t filt_const1 = 0x140014;
+    const int32_t filt_const2 = 0x1fffb;
+    v16u8 res;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
+    v16i8 mask0, mask1, mask2;
+    v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
+    v8i16 hz_out7, hz_out8, dst0, dst1, filt0, filt1, filt2;
+    v8i16 hz_out10_r, hz_out21_r, hz_out32_r, hz_out43_r, hz_out54_r;
+    v8i16 hz_out65_r, hz_out76_r, hz_out87_r;
+    v4i32 tmp0, tmp1;
+
+    LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
+
+    filt0 = (v8i16) __msa_fill_w(filt_const0);
+    filt1 = (v8i16) __msa_fill_w(filt_const1);
+    filt2 = (v8i16) __msa_fill_w(filt_const2);
+
+    src -= ((2 * stride) + 2);
+
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+    LD_SB4(src, stride, src5, src6, src7, src8);
+
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
+    XORI_B4_128_SB(src5, src6, src7, src8);
+
+    hz_out0 = AVC_HORZ_FILTER_SH(src0, src1, mask0, mask1, mask2);
+    hz_out2 = AVC_HORZ_FILTER_SH(src2, src3, mask0, mask1, mask2);
+    hz_out4 = AVC_HORZ_FILTER_SH(src4, src5, mask0, mask1, mask2);
+    hz_out6 = AVC_HORZ_FILTER_SH(src6, src7, mask0, mask1, mask2);
+    hz_out8 = AVC_HORZ_FILTER_SH(src8, src8, mask0, mask1, mask2);
+    PCKOD_D2_SH(hz_out0, hz_out0, hz_out2, hz_out2, hz_out1, hz_out3);
+    PCKOD_D2_SH(hz_out4, hz_out4, hz_out6, hz_out6, hz_out5, hz_out7);
+
+    ILVR_H4_SH(hz_out1, hz_out0, hz_out2, hz_out1, hz_out3, hz_out2, hz_out4,
+               hz_out3, hz_out10_r, hz_out21_r, hz_out32_r, hz_out43_r);
+    ILVR_H4_SH(hz_out5, hz_out4, hz_out6, hz_out5, hz_out7, hz_out6, hz_out8,
+               hz_out7, hz_out54_r, hz_out65_r, hz_out76_r, hz_out87_r);
+
+    tmp0 = AVC_DOT_SW3_SW(hz_out10_r, hz_out32_r, hz_out54_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out21_r, hz_out43_r, hz_out65_r, filt0, filt1,
+                          filt2);
+    dst0 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out32_r, hz_out54_r, hz_out76_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out43_r, hz_out65_r, hz_out87_r, filt0, filt1,
+                          filt2);
+    dst1 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+
+    SRARI_H2_SH(hz_out2, hz_out4, 5);
+    SAT_SH2_SH(hz_out2, hz_out4, 7);
+
+    dst0 = __msa_aver_s_h(dst0, hz_out2);
+    dst1 = __msa_aver_s_h(dst1, hz_out4);
+
+    res = PCKEV_XORI128_UB(dst0, dst1);
+    ST4x4_UB(res, res, 0, 1, 2, 3, dst, stride);
 }
 
 void ff_put_h264_qpel4_mc23_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avc_luma_midv_qrt_4w_msa(src - (2 * stride) - 2, stride, dst, stride, 4, 1);
+    const int32_t filt_const0 = 0xfffb0001;
+    const int32_t filt_const1 = 0x140014;
+    const int32_t filt_const2 = 0x1fffb;
+    v16u8 res;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
+    v16i8 mask0, mask1, mask2;
+    v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
+    v8i16 hz_out7, hz_out8, dst0, dst1, filt0, filt1, filt2;
+    v8i16 hz_out10_r, hz_out21_r, hz_out32_r, hz_out43_r, hz_out54_r;
+    v8i16 hz_out65_r, hz_out76_r, hz_out87_r;
+    v4i32 tmp0, tmp1;
+
+    LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
+
+    filt0 = (v8i16) __msa_fill_w(filt_const0);
+    filt1 = (v8i16) __msa_fill_w(filt_const1);
+    filt2 = (v8i16) __msa_fill_w(filt_const2);
+
+    src -= ((2 * stride) + 2);
+
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+    LD_SB4(src, stride, src5, src6, src7, src8);
+
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
+    XORI_B4_128_SB(src5, src6, src7, src8);
+
+    hz_out0 = AVC_HORZ_FILTER_SH(src0, src1, mask0, mask1, mask2);
+    hz_out2 = AVC_HORZ_FILTER_SH(src2, src3, mask0, mask1, mask2);
+    hz_out4 = AVC_HORZ_FILTER_SH(src4, src5, mask0, mask1, mask2);
+    hz_out6 = AVC_HORZ_FILTER_SH(src6, src7, mask0, mask1, mask2);
+    hz_out8 = AVC_HORZ_FILTER_SH(src8, src8, mask0, mask1, mask2);
+    PCKOD_D2_SH(hz_out0, hz_out0, hz_out2, hz_out2, hz_out1, hz_out3);
+    PCKOD_D2_SH(hz_out4, hz_out4, hz_out6, hz_out6, hz_out5, hz_out7);
+
+    ILVR_H4_SH(hz_out1, hz_out0, hz_out2, hz_out1, hz_out3, hz_out2, hz_out4,
+               hz_out3, hz_out10_r, hz_out21_r, hz_out32_r, hz_out43_r);
+    ILVR_H4_SH(hz_out5, hz_out4, hz_out6, hz_out5, hz_out7, hz_out6, hz_out8,
+               hz_out7, hz_out54_r, hz_out65_r, hz_out76_r, hz_out87_r);
+
+    tmp0 = AVC_DOT_SW3_SW(hz_out10_r, hz_out32_r, hz_out54_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out21_r, hz_out43_r, hz_out65_r, filt0, filt1,
+                          filt2);
+    dst0 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+    tmp0 = AVC_DOT_SW3_SW(hz_out32_r, hz_out54_r, hz_out76_r, filt0, filt1,
+                          filt2);
+    tmp1 = AVC_DOT_SW3_SW(hz_out43_r, hz_out65_r, hz_out87_r, filt0, filt1,
+                          filt2);
+    dst1 = __msa_pckev_h((v8i16) tmp1, (v8i16) tmp0);
+
+    PCKEV_D2_SH(hz_out4, hz_out3, hz_out6, hz_out5, hz_out0, hz_out1);
+    SRARI_H2_SH(hz_out0, hz_out1, 5);
+    SAT_SH2_SH(hz_out0, hz_out1, 7);
+
+    dst0 = __msa_aver_s_h(dst0, hz_out0);
+    dst1 = __msa_aver_s_h(dst1, hz_out1);
+
+    res = PCKEV_XORI128_UB(dst0, dst1);
+    ST4x4_UB(res, res, 0, 1, 2, 3, dst, stride);
 }
 
 void ff_put_h264_qpel16_mc02_msa(uint8_t *dst, const uint8_t *src,
                                  ptrdiff_t stride)
 {
-    avc_luma_vt_16w_msa(src - (stride * 2), stride, dst, stride, 16);
+    int32_t loop_cnt;
+    int16_t filt_const0 = 0xfb01;
+    int16_t filt_const1 = 0x1414;
+    int16_t filt_const2 = 0x1fb;
+    v16u8 res0, res1, res2, res3;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
+    v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
+    v16i8 src87_r, src10_l, src32_l, src54_l, src76_l, src21_l, src43_l;
+    v16i8 src65_l, src87_l, filt0, filt1, filt2;
+    v8i16 out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
+
+    filt0 = (v16i8) __msa_fill_h(filt_const0);
+    filt1 = (v16i8) __msa_fill_h(filt_const1);
+    filt2 = (v16i8) __msa_fill_h(filt_const2);
+    src -= (stride * 2);
+
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+
+    XORI_B5_128_SB(src0, src1, src2, src3, src4);
+    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
+               src32_r, src43_r);
+    ILVL_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_l, src21_l,
+               src32_l, src43_l);
+
+    for (loop_cnt = 4; loop_cnt--;) {
+        LD_SB4(src, stride, src5, src6, src7, src8);
+        src += (4 * stride);
+
+        XORI_B4_128_SB(src5, src6, src7, src8);
+        ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_r,
+                   src65_r, src76_r, src87_r);
+        ILVL_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_l,
+                   src65_l, src76_l, src87_l);
+        out0_r = AVC_DOT_SH3_SH(src10_r, src32_r, src54_r, filt0, filt1, filt2);
+        out1_r = AVC_DOT_SH3_SH(src21_r, src43_r, src65_r, filt0, filt1, filt2);
+        out2_r = AVC_DOT_SH3_SH(src32_r, src54_r, src76_r, filt0, filt1, filt2);
+        out3_r = AVC_DOT_SH3_SH(src43_r, src65_r, src87_r, filt0, filt1, filt2);
+        out0_l = AVC_DOT_SH3_SH(src10_l, src32_l, src54_l, filt0, filt1, filt2);
+        out1_l = AVC_DOT_SH3_SH(src21_l, src43_l, src65_l, filt0, filt1, filt2);
+        out2_l = AVC_DOT_SH3_SH(src32_l, src54_l, src76_l, filt0, filt1, filt2);
+        out3_l = AVC_DOT_SH3_SH(src43_l, src65_l, src87_l, filt0, filt1, filt2);
+        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
+        SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
+        SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 5);
+        SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
+        PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
+                    out3_r, res0, res1, res2, res3);
+        XORI_B4_128_UB(res0, res1, res2, res3);
+        ST_UB4(res0, res1, res2, res3, dst, stride);
+        dst += (4 * stride);
+
+        src10_r = src54_r;
+        src32_r = src76_r;
+        src21_r = src65_r;
+        src43_r = src87_r;
+        src10_l = src54_l;
+        src32_l = src76_l;
+        src21_l = src65_l;
+        src43_l = src87_l;
+        src4 = src8;
+    }
 }
 
 void ff_put_h264_qpel8_mc02_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avc_luma_vt_8w_msa(src - (stride * 2), stride, dst, stride, 8);
+    const int16_t filt_const0 = 0xfb01;
+    const int16_t filt_const1 = 0x1414;
+    const int16_t filt_const2 = 0x1fb;
+    v16u8 out0, out1, out2, out3;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
+    v16i8 src11, src12, src10_r, src21_r, src32_r, src43_r, src76_r, src87_r;
+    v16i8 src98_r, src109_r, src89_r, src910_r, src1110_r, src1211_r;
+    v16i8 filt0, filt1, filt2;
+    v8i16 out0_r, out1_r, out2_r, out3_r, out4_r, out5_r, out6_r, out7_r;
+
+    filt0 = (v16i8) __msa_fill_h(filt_const0);
+    filt1 = (v16i8) __msa_fill_h(filt_const1);
+    filt2 = (v16i8) __msa_fill_h(filt_const2);
+
+    src -= (stride * 2);
+
+    LD_SB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
+    src += (8 * stride);
+    LD_SB5(src, stride, src8, src9, src10, src11, src12);
+    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
+               src32_r, src43_r);
+    ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src76_r, src87_r,
+               src98_r, src109_r);
+    ILVR_B4_SB(src9, src8, src10, src9, src11, src10, src12, src11, src89_r,
+               src910_r, src1110_r, src1211_r);
+    XORI_B4_128_SB(src10_r, src21_r, src32_r, src43_r);
+    XORI_B4_128_SB(src76_r, src87_r, src98_r, src109_r);
+    XORI_B4_128_SB(src89_r, src910_r, src1110_r, src1211_r);
+    out0_r = AVC_DOT_SH3_SH(src10_r, src32_r, src76_r, filt0, filt1, filt2);
+    out1_r = AVC_DOT_SH3_SH(src21_r, src43_r, src87_r, filt0, filt1, filt2);
+    out2_r = AVC_DOT_SH3_SH(src32_r, src76_r, src98_r, filt0, filt1, filt2);
+    out3_r = AVC_DOT_SH3_SH(src43_r, src87_r, src109_r, filt0, filt1, filt2);
+    out4_r = AVC_DOT_SH3_SH(src76_r, src98_r, src89_r, filt0, filt1, filt2);
+    out5_r = AVC_DOT_SH3_SH(src87_r, src109_r, src910_r, filt0, filt1, filt2);
+    out6_r = AVC_DOT_SH3_SH(src98_r, src89_r, src1110_r, filt0, filt1, filt2);
+    out7_r = AVC_DOT_SH3_SH(src109_r, src910_r, src1211_r, filt0, filt1, filt2);
+    SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
+    SRARI_H4_SH(out4_r, out5_r, out6_r, out7_r, 5);
+    SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
+    SAT_SH4_SH(out4_r, out5_r, out6_r, out7_r, 7);
+    out0 = PCKEV_XORI128_UB(out0_r, out1_r);
+    out1 = PCKEV_XORI128_UB(out2_r, out3_r);
+    out2 = PCKEV_XORI128_UB(out4_r, out5_r);
+    out3 = PCKEV_XORI128_UB(out6_r, out7_r);
+    ST8x8_UB(out0, out1, out2, out3, dst, stride);
 }
 
 void ff_put_h264_qpel4_mc02_msa(uint8_t *dst, const uint8_t *src,
                                 ptrdiff_t stride)
 {
-    avc_luma_vt_4w_msa(src - (stride * 2), stride, dst, stride, 4);
+    const int16_t filt_const0 = 0xfb01;
+    const int16_t filt_const1 = 0x1414;
+    const int16_t filt_const2 = 0x1fb;
+    v16u8 out;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
+    v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
+    v16i8 src87_r, src2110, src4332, src6554, src8776, filt0, filt1, filt2;
+    v8i16 out10, out32;
+
+    filt0 = (v16i8) __msa_fill_h(filt_const0);
+    filt1 = (v16i8) __msa_fill_h(filt_const1);
+    filt2 = (v16i8) __msa_fill_h(filt_const2);
+
+    src -= (stride * 2);
+
+    LD_SB5(src, stride, src0, src1, src2, src3, src4);
+    src += (5 * stride);
+    LD_SB4(src, stride, src5, src6, src7, src8);
+
+    ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
+               src32_r, src43_r);
+    ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_r, src65_r,
+               src76_r, src87_r);
+    ILVR_D4_SB(src21_r, src10_r, src43_r, src32_r, src65_r, src54_r, src87_r,
+               src76_r, src2110, src4332, src6554, src8776);
+    XORI_B4_128_SB(src2110, src4332, src6554, src8776);
+    out10 = AVC_DOT_SH3_SH(src2110, src4332, src6554, filt0, filt1, filt2);
+    out32 = AVC_DOT_SH3_SH(src4332, src6554, src8776, filt0, filt1, filt2);
+    SRARI_H2_SH(out10, out32, 5);
+    SAT_SH2_SH(out10, out32, 7);
+    out = PCKEV_XORI128_UB(out10, out32);
+    ST4x4_UB(out, out, 0, 1, 2, 3, dst, stride);
 }
 
 void ff_put_h264_qpel16_mc12_msa(uint8_t *dst, const uint8_t *src,
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/hevc_idct_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/hevc_idct_msa.c
index 975d91f8be5..09431196bb9 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/hevc_idct_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/hevc_idct_msa.c
@@ -21,18 +21,18 @@
 #include "libavutil/mips/generic_macros_msa.h"
 #include "libavcodec/mips/hevcdsp_mips.h"
 
-static const int16_t gt8x8_cnst[16] = {
+static const int16_t gt8x8_cnst[16] __attribute__ ((aligned (64))) = {
     64, 64, 83, 36, 89, 50, 18, 75, 64, -64, 36, -83, 75, -89, -50, -18
 };
 
-static const int16_t gt16x16_cnst[64] = {
+static const int16_t gt16x16_cnst[64] __attribute__ ((aligned (64))) = {
     64, 83, 64, 36, 89, 75, 50, 18, 90, 80, 57, 25, 70, 87, 9, 43,
     64, 36, -64, -83, 75, -18, -89, -50, 87, 9, -80, -70, -43, 57, -25, -90,
     64, -36, -64, 83, 50, -89, 18, 75, 80, -70, -25, 90, -87, 9, 43, 57,
     64, -83, 64, -36, 18, -50, 75, -89, 70, -87, 90, -80, 9, -43, -57, 25
 };
 
-static const int16_t gt32x32_cnst0[256] = {
+static const int16_t gt32x32_cnst0[256] __attribute__ ((aligned (64))) = {
     90, 90, 88, 85, 82, 78, 73, 67, 61, 54, 46, 38, 31, 22, 13, 4,
     90, 82, 67, 46, 22, -4, -31, -54, -73, -85, -90, -88, -78, -61, -38, -13,
     88, 67, 31, -13, -54, -82, -90, -78, -46, -4, 38, 73, 90, 85, 61, 22,
@@ -51,21 +51,17 @@ static const int16_t gt32x32_cnst0[256] = {
     4, -13, 22, -31, 38, -46, 54, -61, 67, -73, 78, -82, 85, -88, 90, -90
 };
 
-static const int16_t gt32x32_cnst1[64] = {
+static const int16_t gt32x32_cnst1[64] __attribute__ ((aligned (64))) = {
     90, 87, 80, 70, 57, 43, 25, 9, 87, 57, 9, -43, -80, -90, -70, -25,
     80, 9, -70, -87, -25, 57, 90, 43, 70, -43, -87, 9, 90, 25, -80, -57,
     57, -80, -25, 90, -9, -87, 43, 70, 43, -90, 57, 25, -87, 70, 9, -80,
     25, -70, 90, -80, 43, 9, -57, 87, 9, -25, 43, -57, 70, -80, 87, -90
 };
 
-static const int16_t gt32x32_cnst2[16] = {
+static const int16_t gt32x32_cnst2[16] __attribute__ ((aligned (64))) = {
     89, 75, 50, 18, 75, -18, -89, -50, 50, -89, 18, 75, 18, -50, 75, -89
 };
 
-static const int16_t gt32x32_cnst3[16] = {
-    64, 64, 64, 64, 83, 36, -36, -83, 64, -64, -64, 64, 36, -83, 83, -36
-};
-
 #define HEVC_IDCT4x4_COL(in_r0, in_l0, in_r1, in_l1,          \
                          sum0, sum1, sum2, sum3, shift)       \
 {                                                             \
@@ -323,14 +319,18 @@ static void hevc_idct_4x4_msa(int16_t *coeffs)
     HEVC_IDCT4x4_COL(in_r0, in_l0, in_r1, in_l1, sum0, sum1, sum2, sum3, 7);
     TRANSPOSE4x4_SW_SW(sum0, sum1, sum2, sum3, in_r0, in_l0, in_r1, in_l1);
     HEVC_IDCT4x4_COL(in_r0, in_l0, in_r1, in_l1, sum0, sum1, sum2, sum3, 12);
-    TRANSPOSE4x4_SW_SW(sum0, sum1, sum2, sum3, sum0, sum1, sum2, sum3);
-    PCKEV_H2_SH(sum1, sum0, sum3, sum2, in0, in1);
+
+    /* Pack and transpose */
+    PCKEV_H2_SH(sum2, sum0, sum3, sum1, in0, in1);
+    ILVRL_H2_SW(in1, in0, sum0, sum1);
+    ILVRL_W2_SH(sum1, sum0, in0, in1);
+
     ST_SH2(in0, in1, coeffs, 8);
 }
 
 static void hevc_idct_8x8_msa(int16_t *coeffs)
 {
-    int16_t *filter = &gt8x8_cnst[0];
+    const int16_t *filter = &gt8x8_cnst[0];
     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
 
     LD_SH8(coeffs, 8, in0, in1, in2, in3, in4, in5, in6, in7);
@@ -349,7 +349,7 @@ static void hevc_idct_16x16_msa(int16_t *coeffs)
     int16_t buf[256];
     int16_t *buf_ptr = &buf[0];
     int16_t *src = coeffs;
-    int16_t *filter = &gt16x16_cnst[0];
+    const int16_t *filter = &gt16x16_cnst[0];
     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
     v8i16 in8, in9, in10, in11, in12, in13, in14, in15;
     v8i16 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
@@ -429,30 +429,38 @@ static void hevc_idct_8x32_column_msa(int16_t *coeffs, uint8_t buf_pitch,
                                       uint8_t round)
 {
     uint8_t i;
-    int16_t *filter_ptr0 = &gt32x32_cnst0[0];
-    int16_t *filter_ptr1 = &gt32x32_cnst1[0];
-    int16_t *filter_ptr2 = &gt32x32_cnst2[0];
-    int16_t *filter_ptr3 = &gt32x32_cnst3[0];
+    const int16_t *filter_ptr0 = &gt32x32_cnst0[0];
+    const int16_t *filter_ptr1 = &gt32x32_cnst1[0];
+    const int16_t *filter_ptr2 = &gt32x32_cnst2[0];
+    const int16_t *filter_ptr3 = &gt8x8_cnst[0];
     int16_t *src0 = (coeffs + buf_pitch);
     int16_t *src1 = (coeffs + 2 * buf_pitch);
     int16_t *src2 = (coeffs + 4 * buf_pitch);
     int16_t *src3 = (coeffs);
     int32_t cnst0, cnst1;
-    int32_t tmp_buf[8 * 32];
-    int32_t *tmp_buf_ptr = &tmp_buf[0];
+    int32_t tmp_buf[8 * 32 + 15];
+    int32_t *tmp_buf_ptr = tmp_buf + 15;
     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
     v8i16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
     v8i16 src0_l, src1_l, src2_l, src3_l, src4_l, src5_l, src6_l, src7_l;
     v8i16 filt0, filter0, filter1, filter2, filter3;
     v4i32 sum0_r, sum0_l, sum1_r, sum1_l, tmp0_r, tmp0_l, tmp1_r, tmp1_l;
 
+    /* Align pointer to 64 byte boundary */
+    tmp_buf_ptr = (int32_t *)(((uintptr_t) tmp_buf_ptr) & ~(uintptr_t) 63);
+
     /* process coeff 4, 12, 20, 28 */
     LD_SH4(src2, 8 * buf_pitch, in0, in1, in2, in3);
     ILVR_H2_SH(in1, in0, in3, in2, src0_r, src1_r);
     ILVL_H2_SH(in1, in0, in3, in2, src0_l, src1_l);
 
+    LD_SH2(src3, 16 * buf_pitch, in4, in6);
+    LD_SH2((src3 + 8 * buf_pitch), 16 * buf_pitch, in5, in7);
+    ILVR_H2_SH(in6, in4, in7, in5, src2_r, src3_r);
+    ILVL_H2_SH(in6, in4, in7, in5, src2_l, src3_l);
+
     /* loop for all columns of constants */
-    for (i = 0; i < 4; i++) {
+    for (i = 0; i < 2; i++) {
         /* processing single column of constants */
         cnst0 = LW(filter_ptr2);
         cnst1 = LW(filter_ptr2 + 2);
@@ -462,37 +470,39 @@ static void hevc_idct_8x32_column_msa(int16_t *coeffs, uint8_t buf_pitch,
 
         DOTP_SH2_SW(src0_r, src0_l, filter0, filter0, sum0_r, sum0_l);
         DPADD_SH2_SW(src1_r, src1_l, filter1, filter1, sum0_r, sum0_l);
-        ST_SW2(sum0_r, sum0_l, (tmp_buf_ptr + i * 8), 4);
+        ST_SW2(sum0_r, sum0_l, (tmp_buf_ptr + 2 * i * 8), 4);
 
-        filter_ptr2 += 4;
-    }
+        /* processing single column of constants */
+        cnst0 = LW(filter_ptr2 + 4);
+        cnst1 = LW(filter_ptr2 + 6);
 
-    /* process coeff 0, 8, 16, 24 */
-    LD_SH2(src3, 16 * buf_pitch, in0, in2);
-    LD_SH2((src3 + 8 * buf_pitch), 16 * buf_pitch, in1, in3);
+        filter0 = (v8i16) __msa_fill_w(cnst0);
+        filter1 = (v8i16) __msa_fill_w(cnst1);
+
+        DOTP_SH2_SW(src0_r, src0_l, filter0, filter0, sum0_r, sum0_l);
+        DPADD_SH2_SW(src1_r, src1_l, filter1, filter1, sum0_r, sum0_l);
+        ST_SW2(sum0_r, sum0_l, (tmp_buf_ptr + (2 * i + 1) * 8), 4);
 
-    ILVR_H2_SH(in2, in0, in3, in1, src0_r, src1_r);
-    ILVL_H2_SH(in2, in0, in3, in1, src0_l, src1_l);
+        filter_ptr2 += 8;
+    }
 
+    /* process coeff 0, 8, 16, 24 */
     /* loop for all columns of constants */
     for (i = 0; i < 2; i++) {
         /* processing first column of filter constants */
         cnst0 = LW(filter_ptr3);
-        cnst1 = LW(filter_ptr3 + 4);
+        cnst1 = LW(filter_ptr3 + 2);
 
         filter0 = (v8i16) __msa_fill_w(cnst0);
         filter1 = (v8i16) __msa_fill_w(cnst1);
 
-        DOTP_SH4_SW(src0_r, src0_l, src1_r, src1_l, filter0, filter0, filter1,
+        DOTP_SH4_SW(src2_r, src2_l, src3_r, src3_l, filter0, filter0, filter1,
                     filter1, sum0_r, sum0_l, tmp1_r, tmp1_l);
 
-        sum1_r = sum0_r;
-        sum1_l = sum0_l;
-        sum0_r += tmp1_r;
-        sum0_l += tmp1_l;
-
-        sum1_r -= tmp1_r;
-        sum1_l -= tmp1_l;
+        sum1_r = sum0_r - tmp1_r;
+        sum1_l = sum0_l - tmp1_l;
+        sum0_r = sum0_r + tmp1_r;
+        sum0_l = sum0_l + tmp1_l;
 
         HEVC_EVEN16_CALC(tmp_buf_ptr, sum0_r, sum0_l, i, (7 - i));
         HEVC_EVEN16_CALC(tmp_buf_ptr, sum1_r, sum1_l, (3 - i), (4 + i));
@@ -618,11 +628,14 @@ static void hevc_idct_32x32_msa(int16_t *coeffs)
 {
     uint8_t row_cnt, col_cnt;
     int16_t *src = coeffs;
-    int16_t tmp_buf[8 * 32];
-    int16_t *tmp_buf_ptr = &tmp_buf[0];
+    int16_t tmp_buf[8 * 32 + 31];
+    int16_t *tmp_buf_ptr = tmp_buf + 31;
     uint8_t round;
     uint8_t buf_pitch;
 
+    /* Align pointer to 64 byte boundary */
+    tmp_buf_ptr = (int16_t *)(((uintptr_t) tmp_buf_ptr) & ~(uintptr_t) 63);
+
     /* column transform */
     round = 7;
     buf_pitch = 32;
@@ -758,21 +771,22 @@ static void hevc_addblk_16x16_msa(int16_t *coeffs, uint8_t *dst, int32_t stride)
 {
     uint8_t loop_cnt;
     uint8_t *temp_dst = dst;
-    v16u8 dst0, dst1, dst2, dst3;
+    v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
     v8i16 dst_r0, dst_l0, dst_r1, dst_l1, dst_r2, dst_l2, dst_r3, dst_l3;
     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
 
-    for (loop_cnt = 4; loop_cnt--;) {
-        LD_SH4(coeffs, 16, in0, in2, in4, in6);
-        LD_SH4((coeffs + 8), 16, in1, in3, in5, in7);
-        coeffs += 64;
-        LD_UB4(temp_dst, stride, dst0, dst1, dst2, dst3);
-        temp_dst += (4 * stride);
+    /* Pre-load for next iteration */
+    LD_UB4(temp_dst, stride, dst4, dst5, dst6, dst7);
+    temp_dst += (4 * stride);
+    LD_SH4(coeffs, 16, in0, in2, in4, in6);
+    LD_SH4((coeffs + 8), 16, in1, in3, in5, in7);
+    coeffs += 64;
 
-        UNPCK_UB_SH(dst0, dst_r0, dst_l0);
-        UNPCK_UB_SH(dst1, dst_r1, dst_l1);
-        UNPCK_UB_SH(dst2, dst_r2, dst_l2);
-        UNPCK_UB_SH(dst3, dst_r3, dst_l3);
+    for (loop_cnt = 3; loop_cnt--;) {
+        UNPCK_UB_SH(dst4, dst_r0, dst_l0);
+        UNPCK_UB_SH(dst5, dst_r1, dst_l1);
+        UNPCK_UB_SH(dst6, dst_r2, dst_l2);
+        UNPCK_UB_SH(dst7, dst_r3, dst_l3);
 
         dst_r0 += in0;
         dst_l0 += in1;
@@ -783,6 +797,13 @@ static void hevc_addblk_16x16_msa(int16_t *coeffs, uint8_t *dst, int32_t stride)
         dst_r3 += in6;
         dst_l3 += in7;
 
+        /* Pre-load for next iteration */
+        LD_UB4(temp_dst, stride, dst4, dst5, dst6, dst7);
+        temp_dst += (4 * stride);
+        LD_SH4(coeffs, 16, in0, in2, in4, in6);
+        LD_SH4((coeffs + 8), 16, in1, in3, in5, in7);
+        coeffs += 64;
+
         CLIP_SH4_0_255(dst_r0, dst_l0, dst_r1, dst_l1);
         CLIP_SH4_0_255(dst_r2, dst_l2, dst_r3, dst_l3);
         PCKEV_B4_UB(dst_l0, dst_r0, dst_l1, dst_r1, dst_l2, dst_r2, dst_l3,
@@ -790,25 +811,50 @@ static void hevc_addblk_16x16_msa(int16_t *coeffs, uint8_t *dst, int32_t stride)
         ST_UB4(dst0, dst1, dst2, dst3, dst, stride);
         dst += (4 * stride);
     }
+
+    UNPCK_UB_SH(dst4, dst_r0, dst_l0);
+    UNPCK_UB_SH(dst5, dst_r1, dst_l1);
+    UNPCK_UB_SH(dst6, dst_r2, dst_l2);
+    UNPCK_UB_SH(dst7, dst_r3, dst_l3);
+
+    dst_r0 += in0;
+    dst_l0 += in1;
+    dst_r1 += in2;
+    dst_l1 += in3;
+    dst_r2 += in4;
+    dst_l2 += in5;
+    dst_r3 += in6;
+    dst_l3 += in7;
+
+    CLIP_SH4_0_255(dst_r0, dst_l0, dst_r1, dst_l1);
+    CLIP_SH4_0_255(dst_r2, dst_l2, dst_r3, dst_l3);
+    PCKEV_B4_UB(dst_l0, dst_r0, dst_l1, dst_r1, dst_l2, dst_r2, dst_l3,
+                dst_r3, dst0, dst1, dst2, dst3);
+    ST_UB4(dst0, dst1, dst2, dst3, dst, stride);
 }
 
 static void hevc_addblk_32x32_msa(int16_t *coeffs, uint8_t *dst, int32_t stride)
 {
     uint8_t loop_cnt;
     uint8_t *temp_dst = dst;
-    v16u8 dst0, dst1, dst2, dst3;
+    v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
     v8i16 dst_r0, dst_l0, dst_r1, dst_l1, dst_r2, dst_l2, dst_r3, dst_l3;
     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
 
-    for (loop_cnt = 8; loop_cnt--;) {
-        LD_SH4(coeffs, 32, in0, in2, in4, in6);
-        LD_SH4((coeffs + 8), 32, in1, in3, in5, in7);
-        LD_UB4(temp_dst, stride, dst0, dst1, dst2, dst3);
-
-        UNPCK_UB_SH(dst0, dst_r0, dst_l0);
-        UNPCK_UB_SH(dst1, dst_r1, dst_l1);
-        UNPCK_UB_SH(dst2, dst_r2, dst_l2);
-        UNPCK_UB_SH(dst3, dst_r3, dst_l3);
+    /* Pre-load for next iteration */
+    LD_UB2(temp_dst, 16, dst4, dst5);
+    temp_dst += stride;
+    LD_UB2(temp_dst, 16, dst6, dst7);
+    temp_dst += stride;
+    LD_SH4(coeffs, 16, in0, in2, in4, in6);
+    LD_SH4((coeffs + 8), 16, in1, in3, in5, in7);
+    coeffs += 64;
+
+    for (loop_cnt = 14; loop_cnt--;) {
+        UNPCK_UB_SH(dst4, dst_r0, dst_l0);
+        UNPCK_UB_SH(dst5, dst_r1, dst_l1);
+        UNPCK_UB_SH(dst6, dst_r2, dst_l2);
+        UNPCK_UB_SH(dst7, dst_r3, dst_l3);
 
         dst_r0 += in0;
         dst_l0 += in1;
@@ -819,40 +865,77 @@ static void hevc_addblk_32x32_msa(int16_t *coeffs, uint8_t *dst, int32_t stride)
         dst_r3 += in6;
         dst_l3 += in7;
 
+        /* Pre-load for next iteration */
+        LD_UB2(temp_dst, 16, dst4, dst5);
+        temp_dst += stride;
+        LD_UB2(temp_dst, 16, dst6, dst7);
+        temp_dst += stride;
+        LD_SH4(coeffs, 16, in0, in2, in4, in6);
+        LD_SH4((coeffs + 8), 16, in1, in3, in5, in7);
+        coeffs += 64;
+
         CLIP_SH4_0_255(dst_r0, dst_l0, dst_r1, dst_l1);
         CLIP_SH4_0_255(dst_r2, dst_l2, dst_r3, dst_l3);
         PCKEV_B4_UB(dst_l0, dst_r0, dst_l1, dst_r1, dst_l2, dst_r2, dst_l3,
                     dst_r3, dst0, dst1, dst2, dst3);
-        ST_UB4(dst0, dst1, dst2, dst3, dst, stride);
-
-        LD_SH4((coeffs + 16), 32, in0, in2, in4, in6);
-        LD_SH4((coeffs + 24), 32, in1, in3, in5, in7);
-        coeffs += 128;
-        LD_UB4((temp_dst + 16), stride, dst0, dst1, dst2, dst3);
-        temp_dst += (4 * stride);
-
-        UNPCK_UB_SH(dst0, dst_r0, dst_l0);
-        UNPCK_UB_SH(dst1, dst_r1, dst_l1);
-        UNPCK_UB_SH(dst2, dst_r2, dst_l2);
-        UNPCK_UB_SH(dst3, dst_r3, dst_l3);
+        ST_UB2(dst0, dst1, dst, 16);
+        dst += stride;
+        ST_UB2(dst2, dst3, dst, 16);
+        dst += stride;
+    }
 
-        dst_r0 += in0;
-        dst_l0 += in1;
-        dst_r1 += in2;
-        dst_l1 += in3;
-        dst_r2 += in4;
-        dst_l2 += in5;
-        dst_r3 += in6;
-        dst_l3 += in7;
+    UNPCK_UB_SH(dst4, dst_r0, dst_l0);
+    UNPCK_UB_SH(dst5, dst_r1, dst_l1);
+    UNPCK_UB_SH(dst6, dst_r2, dst_l2);
+    UNPCK_UB_SH(dst7, dst_r3, dst_l3);
+
+    dst_r0 += in0;
+    dst_l0 += in1;
+    dst_r1 += in2;
+    dst_l1 += in3;
+    dst_r2 += in4;
+    dst_l2 += in5;
+    dst_r3 += in6;
+    dst_l3 += in7;
+
+    /* Pre-load for next iteration */
+    LD_UB2(temp_dst, 16, dst4, dst5);
+    temp_dst += stride;
+    LD_UB2(temp_dst, 16, dst6, dst7);
+    temp_dst += stride;
+    LD_SH4(coeffs, 16, in0, in2, in4, in6);
+    LD_SH4((coeffs + 8), 16, in1, in3, in5, in7);
 
-        CLIP_SH4_0_255(dst_r0, dst_l0, dst_r1, dst_l1);
-        CLIP_SH4_0_255(dst_r2, dst_l2, dst_r3, dst_l3);
-        PCKEV_B4_UB(dst_l0, dst_r0, dst_l1, dst_r1, dst_l2, dst_r2, dst_l3,
-                    dst_r3, dst0, dst1, dst2, dst3);
+    CLIP_SH4_0_255(dst_r0, dst_l0, dst_r1, dst_l1);
+    CLIP_SH4_0_255(dst_r2, dst_l2, dst_r3, dst_l3);
+    PCKEV_B4_UB(dst_l0, dst_r0, dst_l1, dst_r1, dst_l2, dst_r2, dst_l3,
+                dst_r3, dst0, dst1, dst2, dst3);
+    ST_UB2(dst0, dst1, dst, 16);
+    dst += stride;
+    ST_UB2(dst2, dst3, dst, 16);
+    dst += stride;
+
+    UNPCK_UB_SH(dst4, dst_r0, dst_l0);
+    UNPCK_UB_SH(dst5, dst_r1, dst_l1);
+    UNPCK_UB_SH(dst6, dst_r2, dst_l2);
+    UNPCK_UB_SH(dst7, dst_r3, dst_l3);
+
+    dst_r0 += in0;
+    dst_l0 += in1;
+    dst_r1 += in2;
+    dst_l1 += in3;
+    dst_r2 += in4;
+    dst_l2 += in5;
+    dst_r3 += in6;
+    dst_l3 += in7;
 
-        ST_UB4(dst0, dst1, dst2, dst3, (dst + 16), stride);
-        dst += (4 * stride);
-    }
+    CLIP_SH4_0_255(dst_r0, dst_l0, dst_r1, dst_l1);
+    CLIP_SH4_0_255(dst_r2, dst_l2, dst_r3, dst_l3);
+    PCKEV_B4_UB(dst_l0, dst_r0, dst_l1, dst_r1, dst_l2, dst_r2, dst_l3,
+                dst_r3, dst0, dst1, dst2, dst3);
+    ST_UB2(dst0, dst1, dst, 16);
+    dst += stride;
+    ST_UB2(dst2, dst3, dst, 16);
 }
 
 static void hevc_idct_luma_4x4_msa(int16_t *coeffs)
@@ -868,8 +951,12 @@ static void hevc_idct_luma_4x4_msa(int16_t *coeffs)
     TRANSPOSE4x4_SW_SW(res0, res1, res2, res3, in_r0, in_l0, in_r1, in_l1);
     HEVC_IDCT_LUMA4x4_COL(in_r0, in_l0, in_r1, in_l1, res0, res1, res2, res3,
                           12);
-    TRANSPOSE4x4_SW_SW(res0, res1, res2, res3, res0, res1, res2, res3);
-    PCKEV_H2_SH(res1, res0, res3, res2, dst0, dst1);
+
+    /* Pack and transpose */
+    PCKEV_H2_SH(res2, res0, res3, res1, dst0, dst1);
+    ILVRL_H2_SW(dst1, dst0, res0, res1);
+    ILVRL_W2_SH(res1, res0, dst0, dst1);
+
     ST_SH2(dst0, dst1, coeffs, 8);
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/hevc_lpf_sao_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/hevc_lpf_sao_msa.c
index da1db51ef5f..5b5537a2645 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/hevc_lpf_sao_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/hevc_lpf_sao_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
+ * Copyright (c) 2015 -2017 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -35,12 +35,14 @@ static void hevc_loopfilter_luma_hor_msa(uint8_t *src, int32_t stride,
     uint8_t *q3 = src + (stride << 1) + stride;
     uint8_t flag0, flag1;
     int32_t dp00, dq00, dp30, dq30, d00, d30;
+    int32_t d0030, d0434;
     int32_t dp04, dq04, dp34, dq34, d04, d34;
     int32_t tc0, p_is_pcm0, q_is_pcm0, beta30, beta20, tc250;
     int32_t tc4, p_is_pcm4, q_is_pcm4, tc254, tmp;
     uint64_t dst_val0, dst_val1;
     v16u8 dst0, dst1, dst2, dst3, dst4, dst5;
     v2i64 cmp0, cmp1, cmp2, p_is_pcm_vec, q_is_pcm_vec;
+    v2i64 cmp3;
     v8u16 temp0, temp1;
     v8i16 temp2;
     v8i16 tc_pos, tc_neg;
@@ -54,62 +56,86 @@ static void hevc_loopfilter_luma_hor_msa(uint8_t *src, int32_t stride,
     dq30 = abs(q2[3] - (q1[3] << 1) + q0[3]);
     d00 = dp00 + dq00;
     d30 = dp30 + dq30;
-    p_is_pcm0 = p_is_pcm[0];
-    q_is_pcm0 = q_is_pcm[0];
     dp04 = abs(p2[4] - (p1[4] << 1) + p0[4]);
     dq04 = abs(q2[4] - (q1[4] << 1) + q0[4]);
     dp34 = abs(p2[7] - (p1[7] << 1) + p0[7]);
     dq34 = abs(q2[7] - (q1[7] << 1) + q0[7]);
     d04 = dp04 + dq04;
     d34 = dp34 + dq34;
+
+    p_is_pcm0 = p_is_pcm[0];
     p_is_pcm4 = p_is_pcm[1];
+    q_is_pcm0 = q_is_pcm[0];
     q_is_pcm4 = q_is_pcm[1];
 
-    if (!p_is_pcm0 || !p_is_pcm4 || !q_is_pcm0 || !q_is_pcm4) {
-        if (!(d00 + d30 >= beta) || !(d04 + d34 >= beta)) {
-            p3_src = LD_UH(p3);
-            p2_src = LD_UH(p2);
-            p1_src = LD_UH(p1);
-            p0_src = LD_UH(p0);
-            q0_src = LD_UH(q0);
-            q1_src = LD_UH(q1);
-            q2_src = LD_UH(q2);
-            q3_src = LD_UH(q3);
-
-            tc0 = tc[0];
-            beta30 = beta >> 3;
-            beta20 = beta >> 2;
-            tc250 = ((tc0 * 5 + 1) >> 1);
-            tc4 = tc[1];
-            tc254 = ((tc4 * 5 + 1) >> 1);
-
-            flag0 = (abs(p3[0] - p0[0]) + abs(q3[0] - q0[0]) < beta30 &&
-                     abs(p0[0] - q0[0]) < tc250 &&
-                     abs(p3[3] - p0[3]) + abs(q3[3] - q0[3]) < beta30 &&
-                     abs(p0[3] - q0[3]) < tc250 &&
-                     (d00 << 1) < beta20 && (d30 << 1) < beta20);
-            cmp0 = __msa_fill_d(flag0);
-
-            flag1 = (abs(p3[4] - p0[4]) + abs(q3[4] - q0[4]) < beta30 &&
-                     abs(p0[4] - q0[4]) < tc254 &&
-                     abs(p3[7] - p0[7]) + abs(q3[7] - q0[7]) < beta30 &&
-                     abs(p0[7] - q0[7]) < tc254 &&
-                     (d04 << 1) < beta20 && (d34 << 1) < beta20);
-            cmp1 = __msa_fill_d(flag1);
-            cmp2 = __msa_ilvev_d(cmp1, cmp0);
-            cmp2 = __msa_ceqi_d(cmp2, 0);
-
-            ILVR_B8_UH(zero, p3_src, zero, p2_src, zero, p1_src, zero, p0_src,
-                       zero, q0_src, zero, q1_src, zero, q2_src, zero, q3_src,
-                       p3_src, p2_src, p1_src, p0_src, q0_src, q1_src, q2_src,
-                       q3_src);
-
-            cmp0 = (v2i64) __msa_fill_h(tc0);
-            cmp1 = (v2i64) __msa_fill_h(tc4);
-            tc_pos = (v8i16) __msa_ilvev_d(cmp1, cmp0);
+    cmp0 = __msa_fill_d(p_is_pcm0);
+    cmp1 = __msa_fill_d(p_is_pcm4);
+    p_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
+    p_is_pcm_vec = __msa_ceqi_d(p_is_pcm_vec, 0);
+
+    d0030 = (d00 + d30) >= beta;
+    d0434 = (d04 + d34) >= beta;
+
+    cmp0 = (v2i64) __msa_fill_w(d0030);
+    cmp1 = (v2i64) __msa_fill_w(d0434);
+    cmp3 = (v2i64) __msa_ilvev_w((v4i32) cmp1, (v4i32) cmp0);
+    cmp3 = (v2i64) __msa_ceqi_w((v4i32) cmp3, 0);
+
+    if ((!p_is_pcm0 || !p_is_pcm4 || !q_is_pcm0 || !q_is_pcm4) &&
+        (!d0030 || !d0434)) {
+        p3_src = LD_UH(p3);
+        p2_src = LD_UH(p2);
+        p1_src = LD_UH(p1);
+        p0_src = LD_UH(p0);
+
+        cmp0 = __msa_fill_d(q_is_pcm0);
+        cmp1 = __msa_fill_d(q_is_pcm4);
+        q_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
+        q_is_pcm_vec = __msa_ceqi_d(q_is_pcm_vec, 0);
+
+        tc0 = tc[0];
+        beta30 = beta >> 3;
+        beta20 = beta >> 2;
+        tc250 = ((tc0 * 5 + 1) >> 1);
+        tc4 = tc[1];
+        tc254 = ((tc4 * 5 + 1) >> 1);
+
+        cmp0 = (v2i64) __msa_fill_h(tc0);
+        cmp1 = (v2i64) __msa_fill_h(tc4);
+
+        ILVR_B4_UH(zero, p3_src, zero, p2_src, zero, p1_src, zero, p0_src,
+                   p3_src, p2_src, p1_src, p0_src);
+        q0_src = LD_UH(q0);
+        q1_src = LD_UH(q1);
+        q2_src = LD_UH(q2);
+        q3_src = LD_UH(q3);
+
+        flag0 = abs(p3[0] - p0[0]) + abs(q3[0] - q0[0]) < beta30 &&
+                abs(p0[0] - q0[0]) < tc250;
+        flag0 = flag0 && (abs(p3[3] - p0[3]) + abs(q3[3] - q0[3]) < beta30 &&
+                abs(p0[3] - q0[3]) < tc250 && (d00 << 1) < beta20 &&
+                (d30 << 1) < beta20);
+
+        tc_pos = (v8i16) __msa_ilvev_d(cmp1, cmp0);
+        ILVR_B4_UH(zero, q0_src, zero, q1_src, zero, q2_src, zero, q3_src,
+                   q0_src, q1_src, q2_src, q3_src);
+        flag1 = abs(p3[4] - p0[4]) + abs(q3[4] - q0[4]) < beta30 &&
+                abs(p0[4] - q0[4]) < tc254;
+        flag1 = flag1 && (abs(p3[7] - p0[7]) + abs(q3[7] - q0[7]) < beta30 &&
+                abs(p0[7] - q0[7]) < tc254 && (d04 << 1) < beta20 &&
+                (d34 << 1) < beta20);
+
+        cmp0 = (v2i64) __msa_fill_w(flag0);
+        cmp1 = (v2i64) __msa_fill_w(flag1);
+        cmp2 = (v2i64) __msa_ilvev_w((v4i32) cmp1, (v4i32) cmp0);
+        cmp2 = (v2i64) __msa_ceqi_w((v4i32) cmp2, 0);
+
+        if (flag0 && flag1) { /* strong only */
+            /* strong filter */
             tc_pos <<= 1;
             tc_neg = -tc_pos;
 
+            /* p part */
             temp0 = (p1_src + p0_src + q0_src);
             temp1 = ((p3_src + p2_src) << 1) + p2_src + temp0;
             temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 3);
@@ -129,15 +155,11 @@ static void hevc_loopfilter_luma_hor_msa(uint8_t *src, int32_t stride,
             temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
             dst2 = (v16u8) (temp2 + (v8i16) p0_src);
 
-            cmp0 = __msa_fill_d(p_is_pcm0);
-            cmp1 = __msa_fill_d(p_is_pcm4);
-            p_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
-            p_is_pcm_vec = __msa_ceqi_d(p_is_pcm_vec, 0);
-
             dst0 = __msa_bmz_v(dst0, (v16u8) p2_src, (v16u8) p_is_pcm_vec);
             dst1 = __msa_bmz_v(dst1, (v16u8) p1_src, (v16u8) p_is_pcm_vec);
             dst2 = __msa_bmz_v(dst2, (v16u8) p0_src, (v16u8) p_is_pcm_vec);
 
+            /* q part */
             temp0 = (q1_src + p0_src + q0_src);
 
             temp1 = ((q3_src + q2_src) << 1) + q2_src + temp0;
@@ -158,15 +180,176 @@ static void hevc_loopfilter_luma_hor_msa(uint8_t *src, int32_t stride,
             temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
             dst3 = (v16u8) (temp2 + (v8i16) q0_src);
 
-            cmp0 = __msa_fill_d(q_is_pcm0);
-            cmp1 = __msa_fill_d(q_is_pcm4);
-            q_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
-            q_is_pcm_vec = __msa_ceqi_d(q_is_pcm_vec, 0);
+            dst3 = __msa_bmz_v(dst3, (v16u8) q0_src, (v16u8) q_is_pcm_vec);
+            dst4 = __msa_bmz_v(dst4, (v16u8) q1_src, (v16u8) q_is_pcm_vec);
+            dst5 = __msa_bmz_v(dst5, (v16u8) q2_src, (v16u8) q_is_pcm_vec);
+
+            /* pack results to 8 bit */
+            PCKEV_B2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
+            dst2 = (v16u8) __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
+
+            /* pack src to 8 bit */
+            PCKEV_B2_UB(p1_src, p2_src, q0_src, p0_src, dst3, dst4);
+            dst5 = (v16u8) __msa_pckev_b((v16i8) q2_src, (v16i8) q1_src);
+
+            dst0 = __msa_bmz_v(dst0, dst3, (v16u8) cmp3);
+            dst1 = __msa_bmz_v(dst1, dst4, (v16u8) cmp3);
+            dst2 = __msa_bmz_v(dst2, dst5, (v16u8) cmp3);
+
+            dst_val0 = __msa_copy_u_d((v2i64) dst2, 0);
+            dst_val1 = __msa_copy_u_d((v2i64) dst2, 1);
+
+            ST8x4_UB(dst0, dst1, p2, stride);
+            p2 += (4 * stride);
+            SD(dst_val0, p2);
+            p2 += stride;
+            SD(dst_val1, p2);
+            /* strong filter ends */
+        } else if (flag0 == flag1) { /* weak only */
+            /* weak filter */
+            tc_neg = -tc_pos;
+
+            diff0 = (v8i16) (q0_src - p0_src);
+            diff1 = (v8i16) (q1_src - p1_src);
+            diff0 = (diff0 << 3) + diff0;
+            diff1 = (diff1 << 1) + diff1;
+            delta0 = diff0 - diff1;
+            delta0 = __msa_srari_h(delta0, 4);
+
+            temp1 = (v8u16) ((tc_pos << 3) + (tc_pos << 1));
+            abs_delta0 = __msa_add_a_h(delta0, (v8i16) zero);
+            abs_delta0 = (v8u16) abs_delta0 < temp1;
+
+            delta0 = CLIP_SH(delta0, tc_neg, tc_pos);
+
+            temp0 = (v8u16) (delta0 + p0_src);
+            temp0 = (v8u16) CLIP_SH_0_255(temp0);
+            temp0 = (v8u16) __msa_bmz_v((v16u8) temp0, (v16u8) p0_src,
+                                        (v16u8) p_is_pcm_vec);
+
+            temp2 = (v8i16) (q0_src - delta0);
+            temp2 = CLIP_SH_0_255(temp2);
+            temp2 = (v8i16) __msa_bmz_v((v16u8) temp2, (v16u8) q0_src,
+                                        (v16u8) q_is_pcm_vec);
+
+            p_is_pcm_vec = ~p_is_pcm_vec;
+            q_is_pcm_vec = ~q_is_pcm_vec;
+            tmp = (beta + (beta >> 1)) >> 3;
+            cmp0 = __msa_fill_d(dp00 + dp30 < tmp);
+            cmp1 = __msa_fill_d(dp04 + dp34 < tmp);
+            cmp0 = __msa_ilvev_d(cmp1, cmp0);
+            cmp0 = __msa_ceqi_d(cmp0, 0);
+            p_is_pcm_vec = p_is_pcm_vec | cmp0;
+
+            cmp0 = __msa_fill_d(dq00 + dq30 < tmp);
+            cmp1 = __msa_fill_d(dq04 + dq34 < tmp);
+            cmp0 = __msa_ilvev_d(cmp1, cmp0);
+            cmp0 = __msa_ceqi_d(cmp0, 0);
+            q_is_pcm_vec = q_is_pcm_vec | cmp0;
+
+            tc_pos >>= 1;
+            tc_neg = -tc_pos;
+
+            delta1 = (v8i16) __msa_aver_u_h(p2_src, p0_src);
+            delta1 -= (v8i16) p1_src;
+            delta1 += delta0;
+            delta1 >>= 1;
+            delta1 = CLIP_SH(delta1, tc_neg, tc_pos);
+            delta1 = (v8i16) p1_src + (v8i16) delta1;
+            delta1 = CLIP_SH_0_255(delta1);
+            delta1 = (v8i16) __msa_bmnz_v((v16u8) delta1, (v16u8) p1_src,
+                                          (v16u8) p_is_pcm_vec);
+
+            delta2 = (v8i16) __msa_aver_u_h(q0_src, q2_src);
+            delta2 = delta2 - (v8i16) q1_src;
+            delta2 = delta2 - delta0;
+            delta2 = delta2 >> 1;
+            delta2 = CLIP_SH(delta2, tc_neg, tc_pos);
+            delta2 = (v8i16) q1_src + (v8i16) delta2;
+            delta2 = CLIP_SH_0_255(delta2);
+            delta2 = (v8i16) __msa_bmnz_v((v16u8) delta2, (v16u8) q1_src,
+                                          (v16u8) q_is_pcm_vec);
+
+            dst1 = (v16u8) __msa_bmz_v((v16u8) delta1, (v16u8) p1_src,
+                                       (v16u8) abs_delta0);
+            dst2 = (v16u8) __msa_bmz_v((v16u8) temp0, (v16u8) p0_src,
+                                       (v16u8) abs_delta0);
+            dst3 = (v16u8) __msa_bmz_v((v16u8) temp2, (v16u8) q0_src,
+                                       (v16u8) abs_delta0);
+            dst4 = (v16u8) __msa_bmz_v((v16u8) delta2, (v16u8) q1_src,
+                                       (v16u8) abs_delta0);
+            /* pack results to 8 bit */
+            PCKEV_B2_UB(dst2, dst1, dst4, dst3, dst0, dst1);
+
+            /* pack src to 8 bit */
+            PCKEV_B2_UB(p0_src, p1_src, q1_src, q0_src, dst2, dst3);
+
+            dst0 = __msa_bmz_v(dst0, dst2, (v16u8) cmp3);
+            dst1 = __msa_bmz_v(dst1, dst3, (v16u8) cmp3);
+
+            p2 += stride;
+            ST8x4_UB(dst0, dst1, p2, stride);
+            /* weak filter ends */
+        } else { /* strong + weak */
+            /* strong filter */
+            tc_pos <<= 1;
+            tc_neg = -tc_pos;
+
+            /* p part */
+            temp0 = (p1_src + p0_src + q0_src);
+            temp1 = ((p3_src + p2_src) << 1) + p2_src + temp0;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 3);
+            temp2 = (v8i16) (temp1 - p2_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst0 = (v16u8) (temp2 + (v8i16) p2_src);
+
+            temp1 = temp0 + p2_src;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 2);
+            temp2 = (v8i16) (temp1 - p1_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst1 = (v16u8) (temp2 + (v8i16) p1_src);
+
+            temp1 = (temp0 << 1) + p2_src + q1_src;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 3);
+            temp2 = (v8i16) (temp1 - p0_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst2 = (v16u8) (temp2 + (v8i16) p0_src);
+
+            dst0 = __msa_bmz_v(dst0, (v16u8) p2_src, (v16u8) p_is_pcm_vec);
+            dst1 = __msa_bmz_v(dst1, (v16u8) p1_src, (v16u8) p_is_pcm_vec);
+            dst2 = __msa_bmz_v(dst2, (v16u8) p0_src, (v16u8) p_is_pcm_vec);
+
+            /* q part */
+            temp0 = (q1_src + p0_src + q0_src);
+
+            temp1 = ((q3_src + q2_src) << 1) + q2_src + temp0;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 3);
+            temp2 = (v8i16) (temp1 - q2_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst5 = (v16u8) (temp2 + (v8i16) q2_src);
+
+            temp1 = temp0 + q2_src;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 2);
+            temp2 = (v8i16) (temp1 - q1_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst4 = (v16u8) (temp2 + (v8i16) q1_src);
+
+            temp1 = (temp0 << 1) + p1_src + q2_src;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 3);
+            temp2 = (v8i16) (temp1 - q0_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst3 = (v16u8) (temp2 + (v8i16) q0_src);
 
             dst3 = __msa_bmz_v(dst3, (v16u8) q0_src, (v16u8) q_is_pcm_vec);
             dst4 = __msa_bmz_v(dst4, (v16u8) q1_src, (v16u8) q_is_pcm_vec);
             dst5 = __msa_bmz_v(dst5, (v16u8) q2_src, (v16u8) q_is_pcm_vec);
 
+            /* pack strong results to 8 bit */
+            PCKEV_B2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
+            dst2 = (v16u8) __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
+            /* strong filter ends */
+
+            /* weak filter */
             tc_pos >>= 1;
             tc_neg = -tc_pos;
 
@@ -193,16 +376,18 @@ static void hevc_loopfilter_luma_hor_msa(uint8_t *src, int32_t stride,
             temp2 = (v8i16) __msa_bmz_v((v16u8) temp2, (v16u8) q0_src,
                                         (v16u8) q_is_pcm_vec);
 
+            p_is_pcm_vec = ~p_is_pcm_vec;
+            q_is_pcm_vec = ~q_is_pcm_vec;
             tmp = (beta + (beta >> 1)) >> 3;
-            cmp0 = __msa_fill_d(!p_is_pcm0 && ((dp00 + dp30) < tmp));
-            cmp1 = __msa_fill_d(!p_is_pcm4 && ((dp04 + dp34) < tmp));
-            p_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
-            p_is_pcm_vec = __msa_ceqi_d(p_is_pcm_vec, 0);
+            cmp0 = __msa_fill_d(dp00 + dp30 < tmp);
+            cmp1 = __msa_fill_d(dp04 + dp34 < tmp);
+            cmp0 = __msa_ilvev_d(cmp1, cmp0);
+            p_is_pcm_vec = p_is_pcm_vec | __msa_ceqi_d(cmp0, 0);
 
-            cmp0 = (v2i64) __msa_fill_h((!q_is_pcm0) && (dq00 + dq30 < tmp));
-            cmp1 = (v2i64) __msa_fill_h((!q_is_pcm4) && (dq04 + dq34 < tmp));
-            q_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
-            q_is_pcm_vec = __msa_ceqi_d(q_is_pcm_vec, 0);
+            cmp0 = __msa_fill_d(dq00 + dq30 < tmp);
+            cmp1 = __msa_fill_d(dq04 + dq34 < tmp);
+            cmp0 = __msa_ilvev_d(cmp1, cmp0);
+            q_is_pcm_vec = q_is_pcm_vec | __msa_ceqi_d(cmp0, 0);
 
             tc_pos >>= 1;
             tc_neg = -tc_pos;
@@ -235,28 +420,24 @@ static void hevc_loopfilter_luma_hor_msa(uint8_t *src, int32_t stride,
                                         (v16u8) abs_delta0);
             delta2 = (v8i16) __msa_bmz_v((v16u8) delta2, (v16u8) q1_src,
                                          (v16u8) abs_delta0);
+            /* weak filter ends */
 
-            dst2 = __msa_bmnz_v(dst2, (v16u8) temp0, (v16u8) cmp2);
-            dst3 = __msa_bmnz_v(dst3, (v16u8) temp2, (v16u8) cmp2);
-            dst1 = __msa_bmnz_v(dst1, (v16u8) delta1, (v16u8) cmp2);
-            dst4 = __msa_bmnz_v(dst4, (v16u8) delta2, (v16u8) cmp2);
-            dst0 = __msa_bmnz_v(dst0, (v16u8) p2_src, (v16u8) cmp2);
-            dst5 = __msa_bmnz_v(dst5, (v16u8) q2_src, (v16u8) cmp2);
+            /* pack weak results to 8 bit */
+            PCKEV_B2_UB(delta1, p2_src, temp2, temp0, dst3, dst4);
+            dst5 = (v16u8) __msa_pckev_b((v16i8) q2_src, (v16i8) delta2);
 
-            cmp0 = __msa_fill_d(d00 + d30 >= beta);
-            cmp1 = __msa_fill_d(d04 + d34 >= beta);
-            cmp0 = __msa_ilvev_d(cmp1, cmp0);
-            cmp0 = __msa_ceqi_d(cmp0, 0);
+            /* select between weak or strong */
+            dst0 = __msa_bmnz_v(dst0, dst3, (v16u8) cmp2);
+            dst1 = __msa_bmnz_v(dst1, dst4, (v16u8) cmp2);
+            dst2 = __msa_bmnz_v(dst2, dst5, (v16u8) cmp2);
 
-            dst0 = __msa_bmz_v(dst0, (v16u8) p2_src, (v16u8) cmp0);
-            dst1 = __msa_bmz_v(dst1, (v16u8) p1_src, (v16u8) cmp0);
-            dst2 = __msa_bmz_v(dst2, (v16u8) p0_src, (v16u8) cmp0);
-            dst3 = __msa_bmz_v(dst3, (v16u8) q0_src, (v16u8) cmp0);
-            dst4 = __msa_bmz_v(dst4, (v16u8) q1_src, (v16u8) cmp0);
-            dst5 = __msa_bmz_v(dst5, (v16u8) q2_src, (v16u8) cmp0);
+            /* pack src to 8 bit */
+            PCKEV_B2_UB(p1_src, p2_src, q0_src, p0_src, dst3, dst4);
+            dst5 = (v16u8) __msa_pckev_b((v16i8) q2_src, (v16i8) q1_src);
 
-            PCKEV_B2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
-            dst2 = (v16u8) __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
+            dst0 = __msa_bmz_v(dst0, dst3, (v16u8) cmp3);
+            dst1 = __msa_bmz_v(dst1, dst4, (v16u8) cmp3);
+            dst2 = __msa_bmz_v(dst2, dst5, (v16u8) cmp3);
 
             dst_val0 = __msa_copy_u_d((v2i64) dst2, 0);
             dst_val1 = __msa_copy_u_d((v2i64) dst2, 1);
@@ -282,11 +463,13 @@ static void hevc_loopfilter_luma_ver_msa(uint8_t *src, int32_t stride,
     uint16_t tmp0, tmp1;
     uint32_t tmp2, tmp3;
     int32_t dp00, dq00, dp30, dq30, d00, d30;
+    int32_t d0030, d0434;
     int32_t dp04, dq04, dp34, dq34, d04, d34;
     int32_t tc0, p_is_pcm0, q_is_pcm0, beta30, beta20, tc250;
     int32_t tc4, p_is_pcm4, q_is_pcm4, tc254, tmp;
     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
     v2i64 cmp0, cmp1, cmp2, p_is_pcm_vec, q_is_pcm_vec;
+    v2i64 cmp3;
     v8u16 temp0, temp1;
     v8i16 temp2;
     v8i16 tc_pos, tc_neg;
@@ -312,51 +495,71 @@ static void hevc_loopfilter_luma_ver_msa(uint8_t *src, int32_t stride,
     p_is_pcm4 = p_is_pcm[1];
     q_is_pcm4 = q_is_pcm[1];
 
-    if (!p_is_pcm0 || !p_is_pcm4 || !q_is_pcm0 || !q_is_pcm4) {
-        if (!(d00 + d30 >= beta) || !(d04 + d34 >= beta)) {
-            src -= 4;
-            LD_UH8(src, stride,
-                   p3_src, p2_src, p1_src, p0_src, q0_src, q1_src, q2_src,
-                   q3_src);
-
-            tc0 = tc[0];
-            beta30 = beta >> 3;
-            beta20 = beta >> 2;
-            tc250 = ((tc0 * 5 + 1) >> 1);
-
-            tc4 = tc[1];
-            tc254 = ((tc4 * 5 + 1) >> 1);
-
-            TRANSPOSE8x8_UB_UH(p3_src, p2_src, p1_src, p0_src, q0_src, q1_src,
-                               q2_src, q3_src, p3_src, p2_src, p1_src, p0_src,
-                               q0_src, q1_src, q2_src, q3_src);
-
-            flag0 = (abs(p3[-4] - p3[-1]) + abs(p3[3] - p3[0]) < beta30 &&
-                     abs(p3[-1] - p3[0]) < tc250 &&
-                     abs(p2[-4] - p2[-1]) + abs(p2[3] - p2[0]) < beta30 &&
-                     abs(p2[-1] - p2[0]) < tc250 &&
-                     (d00 << 1) < beta20 && (d30 << 1) < beta20);
-            cmp0 = __msa_fill_d(flag0);
-
-            flag1 = (abs(p1[-4] - p1[-1]) + abs(p1[3] - p1[0]) < beta30 &&
-                     abs(p1[-1] - p1[0]) < tc254 &&
-                     abs(p0[-4] - p0[-1]) + abs(p0[3] - p0[0]) < beta30 &&
-                     abs(p0[-1] - p0[0]) < tc254 &&
-                     (d04 << 1) < beta20 && (d34 << 1) < beta20);
-            cmp1 = __msa_fill_d(flag1);
-            cmp2 = __msa_ilvev_d(cmp1, cmp0);
-            cmp2 = __msa_ceqi_d(cmp2, 0);
-
-            ILVR_B8_UH(zero, p3_src, zero, p2_src, zero, p1_src, zero, p0_src,
-                       zero, q0_src, zero, q1_src, zero, q2_src, zero, q3_src,
-                       p3_src, p2_src, p1_src, p0_src, q0_src, q1_src, q2_src,
-                       q3_src);
-
-            cmp0 = (v2i64) __msa_fill_h(tc0 << 1);
-            cmp1 = (v2i64) __msa_fill_h(tc4 << 1);
-            tc_pos = (v8i16) __msa_ilvev_d(cmp1, cmp0);
+    cmp0 = __msa_fill_d(p_is_pcm0);
+    cmp1 = __msa_fill_d(p_is_pcm4);
+    p_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
+    p_is_pcm_vec = __msa_ceqi_d(p_is_pcm_vec, 0);
+
+    d0030 = (d00 + d30) >= beta;
+    d0434 = (d04 + d34) >= beta;
+
+    cmp0 = __msa_fill_d(d0030);
+    cmp1 = __msa_fill_d(d0434);
+    cmp3 = __msa_ilvev_d(cmp1, cmp0);
+    cmp3 = (v2i64) __msa_ceqi_d(cmp3, 0);
+
+    if ((!p_is_pcm0 || !p_is_pcm4 || !q_is_pcm0 || !q_is_pcm4) &&
+        (!d0030 || !d0434)) {
+        src -= 4;
+        LD_UH8(src, stride, p3_src, p2_src, p1_src, p0_src, q0_src, q1_src,
+               q2_src, q3_src);
+
+        cmp0 = __msa_fill_d(q_is_pcm0);
+        cmp1 = __msa_fill_d(q_is_pcm4);
+        q_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
+        q_is_pcm_vec = __msa_ceqi_d(q_is_pcm_vec, 0);
+
+        tc0 = tc[0];
+        beta30 = beta >> 3;
+        beta20 = beta >> 2;
+        tc250 = ((tc0 * 5 + 1) >> 1);
+
+        tc4 = tc[1];
+        tc254 = ((tc4 * 5 + 1) >> 1);
+        cmp0 = (v2i64) __msa_fill_h(tc0 << 1);
+        cmp1 = (v2i64) __msa_fill_h(tc4 << 1);
+        tc_pos = (v8i16) __msa_ilvev_d(cmp1, cmp0);
+
+        TRANSPOSE8x8_UB_UH(p3_src, p2_src, p1_src, p0_src, q0_src, q1_src,
+                           q2_src, q3_src, p3_src, p2_src, p1_src, p0_src,
+                           q0_src, q1_src, q2_src, q3_src);
+
+        flag0 = abs(p3[-4] - p3[-1]) + abs(p3[3] - p3[0]) < beta30 &&
+                abs(p3[-1] - p3[0]) < tc250;
+        flag0 = flag0 && (abs(p2[-4] - p2[-1]) + abs(p2[3] - p2[0]) < beta30 &&
+                abs(p2[-1] - p2[0]) < tc250 && (d00 << 1) < beta20 &&
+                (d30 << 1) < beta20);
+        cmp0 = __msa_fill_d(flag0);
+        ILVR_B4_UH(zero, p3_src, zero, p2_src, zero, p1_src, zero, p0_src,
+                   p3_src, p2_src, p1_src, p0_src);
+
+        flag1 = abs(p1[-4] - p1[-1]) + abs(p1[3] - p1[0]) < beta30 &&
+                abs(p1[-1] - p1[0]) < tc254;
+        flag1 = flag1 && (abs(p0[-4] - p0[-1]) + abs(p0[3] - p0[0]) < beta30 &&
+                abs(p0[-1] - p0[0]) < tc254 && (d04 << 1) < beta20 &&
+                (d34 << 1) < beta20);
+        ILVR_B4_UH(zero, q0_src, zero, q1_src, zero, q2_src, zero, q3_src,
+                   q0_src, q1_src, q2_src, q3_src);
+
+        cmp1 = __msa_fill_d(flag1);
+        cmp2 = __msa_ilvev_d(cmp1, cmp0);
+        cmp2 = __msa_ceqi_d(cmp2, 0);
+
+        if (flag0 && flag1) { /* strong only */
+            /* strong filter */
             tc_neg = -tc_pos;
 
+            /* p part */
             temp0 = (p1_src + p0_src + q0_src);
 
             temp1 = ((p3_src + p2_src) << 1) + p2_src + temp0;
@@ -377,15 +580,11 @@ static void hevc_loopfilter_luma_ver_msa(uint8_t *src, int32_t stride,
             temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
             dst2 = (v16u8) (temp2 + (v8i16) p0_src);
 
-            cmp0 = __msa_fill_d(p_is_pcm0);
-            cmp1 = __msa_fill_d(p_is_pcm4);
-            p_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
-            p_is_pcm_vec = __msa_ceqi_d(p_is_pcm_vec, 0);
-
             dst0 = __msa_bmz_v(dst0, (v16u8) p2_src, (v16u8) p_is_pcm_vec);
             dst1 = __msa_bmz_v(dst1, (v16u8) p1_src, (v16u8) p_is_pcm_vec);
             dst2 = __msa_bmz_v(dst2, (v16u8) p0_src, (v16u8) p_is_pcm_vec);
 
+            /* q part */
             temp0 = (q1_src + p0_src + q0_src);
             temp1 = ((q3_src + q2_src) << 1) + q2_src + temp0;
             temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 3);
@@ -405,22 +604,184 @@ static void hevc_loopfilter_luma_ver_msa(uint8_t *src, int32_t stride,
             temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
             dst3 = (v16u8) (temp2 + (v8i16) q0_src);
 
-            cmp0 = __msa_fill_d(q_is_pcm0);
-            cmp1 = __msa_fill_d(q_is_pcm4);
+            dst3 = __msa_bmz_v(dst3, (v16u8) q0_src, (v16u8) q_is_pcm_vec);
+            dst4 = __msa_bmz_v(dst4, (v16u8) q1_src, (v16u8) q_is_pcm_vec);
+            dst5 = __msa_bmz_v(dst5, (v16u8) q2_src, (v16u8) q_is_pcm_vec);
+            /* strong filter ends */
+        } else if (flag0 == flag1) { /* weak only */
+            /* weak filter */
+            tc_pos >>= 1;
+            tc_neg = -tc_pos;
+
+            diff0 = (v8i16) (q0_src - p0_src);
+            diff1 = (v8i16) (q1_src - p1_src);
+            diff0 = (diff0 << 3) + diff0;
+            diff1 = (diff1 << 1) + diff1;
+            delta0 = diff0 - diff1;
+            delta0 = __msa_srari_h(delta0, 4);
+
+            temp1 = (v8u16) ((tc_pos << 3) + (tc_pos << 1));
+            abs_delta0 = __msa_add_a_h(delta0, (v8i16) zero);
+            abs_delta0 = (v8u16) abs_delta0 < temp1;
+
+            delta0 = CLIP_SH(delta0, tc_neg, tc_pos);
+            temp0 = (v8u16) (delta0 + p0_src);
+            temp0 = (v8u16) CLIP_SH_0_255(temp0);
+            temp0 = (v8u16) __msa_bmz_v((v16u8) temp0, (v16u8) p0_src,
+                                        (v16u8) p_is_pcm_vec);
+
+            temp2 = (v8i16) (q0_src - delta0);
+            temp2 = CLIP_SH_0_255(temp2);
+            temp2 = (v8i16) __msa_bmz_v((v16u8) temp2, (v16u8) q0_src,
+                                        (v16u8) q_is_pcm_vec);
+
+            tmp = ((beta + (beta >> 1)) >> 3);
+            cmp0 = __msa_fill_d(!p_is_pcm0 && ((dp00 + dp30) < tmp));
+            cmp1 = __msa_fill_d(!p_is_pcm4 && ((dp04 + dp34) < tmp));
+            p_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
+            p_is_pcm_vec = __msa_ceqi_d(p_is_pcm_vec, 0);
+
+            cmp0 = (v2i64) __msa_fill_h((!q_is_pcm0) && (dq00 + dq30 < tmp));
+            cmp1 = (v2i64) __msa_fill_h((!q_is_pcm4) && (dq04 + dq34 < tmp));
             q_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
             q_is_pcm_vec = __msa_ceqi_d(q_is_pcm_vec, 0);
 
+            tc_pos >>= 1;
+            tc_neg = -tc_pos;
+
+            delta1 = (v8i16) __msa_aver_u_h(p2_src, p0_src);
+            delta1 -= (v8i16) p1_src;
+            delta1 += delta0;
+            delta1 >>= 1;
+            delta1 = CLIP_SH(delta1, tc_neg, tc_pos);
+            delta1 = (v8i16) p1_src + (v8i16) delta1;
+            delta1 = CLIP_SH_0_255(delta1);
+            delta1 = (v8i16) __msa_bmnz_v((v16u8) delta1, (v16u8) p1_src,
+                                          (v16u8) p_is_pcm_vec);
+
+            delta2 = (v8i16) __msa_aver_u_h(q0_src, q2_src);
+            delta2 = delta2 - (v8i16) q1_src;
+            delta2 = delta2 - delta0;
+            delta2 = delta2 >> 1;
+            delta2 = CLIP_SH(delta2, tc_neg, tc_pos);
+            delta2 = (v8i16) q1_src + (v8i16) delta2;
+            delta2 = CLIP_SH_0_255(delta2);
+            delta2 = (v8i16) __msa_bmnz_v((v16u8) delta2, (v16u8) q1_src,
+                                          (v16u8) q_is_pcm_vec);
+
+            dst0 = __msa_bmz_v((v16u8) delta1, (v16u8) p1_src,
+                               (v16u8) abs_delta0);
+            dst1 = __msa_bmz_v((v16u8) temp0, (v16u8) p0_src,
+                               (v16u8) abs_delta0);
+            dst2 = __msa_bmz_v((v16u8) temp2, (v16u8) q0_src,
+                               (v16u8) abs_delta0);
+            dst3 = __msa_bmz_v((v16u8) delta2, (v16u8) q1_src,
+                               (v16u8) abs_delta0);
+            /* weak filter ends */
+
+            dst0 = __msa_bmz_v(dst0, (v16u8) p1_src, (v16u8) cmp3);
+            dst1 = __msa_bmz_v(dst1, (v16u8) p0_src, (v16u8) cmp3);
+            dst2 = __msa_bmz_v(dst2, (v16u8) q0_src, (v16u8) cmp3);
+            dst3 = __msa_bmz_v(dst3, (v16u8) q1_src, (v16u8) cmp3);
+
+            PCKEV_B2_UB(dst2, dst0, dst3, dst1, dst0, dst1);
+
+            /* transpose */
+            ILVRL_B2_UB(dst1, dst0, dst4, dst5);
+            ILVRL_H2_UB(dst5, dst4, dst0, dst1);
+
+            src += 2;
+
+            tmp2 = __msa_copy_u_w((v4i32) dst0, 0);
+            tmp3 = __msa_copy_u_w((v4i32) dst0, 1);
+            SW(tmp2, src);
+            src += stride;
+            SW(tmp3, src);
+            src += stride;
+
+            tmp2 = __msa_copy_u_w((v4i32) dst0, 2);
+            tmp3 = __msa_copy_u_w((v4i32) dst0, 3);
+            SW(tmp2, src);
+            src += stride;
+            SW(tmp3, src);
+            src += stride;
+
+            tmp2 = __msa_copy_u_w((v4i32) dst1, 0);
+            tmp3 = __msa_copy_u_w((v4i32) dst1, 1);
+            SW(tmp2, src);
+            src += stride;
+            SW(tmp3, src);
+            src += stride;
+
+            tmp2 = __msa_copy_u_w((v4i32) dst1, 2);
+            tmp3 = __msa_copy_u_w((v4i32) dst1, 3);
+            SW(tmp2, src);
+            src += stride;
+            SW(tmp3, src);
+
+            return;
+        } else { /* strong + weak */
+            /* strong filter */
+            tc_neg = -tc_pos;
+
+            /* p part */
+            temp0 = (p1_src + p0_src + q0_src);
+
+            temp1 = ((p3_src + p2_src) << 1) + p2_src + temp0;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 3);
+            temp2 = (v8i16) (temp1 - p2_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst0 = (v16u8) (temp2 + (v8i16) p2_src);
+
+            temp1 = temp0 + p2_src;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 2);
+            temp2 = (v8i16) (temp1 - p1_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst1 = (v16u8) (temp2 + (v8i16) p1_src);
+
+            temp1 = (temp0 << 1) + p2_src + q1_src;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 3);
+            temp2 = (v8i16) (temp1 - p0_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst2 = (v16u8) (temp2 + (v8i16) p0_src);
+
+            dst0 = __msa_bmz_v(dst0, (v16u8) p2_src, (v16u8) p_is_pcm_vec);
+            dst1 = __msa_bmz_v(dst1, (v16u8) p1_src, (v16u8) p_is_pcm_vec);
+            dst2 = __msa_bmz_v(dst2, (v16u8) p0_src, (v16u8) p_is_pcm_vec);
+
+            /* q part */
+            temp0 = (q1_src + p0_src + q0_src);
+            temp1 = ((q3_src + q2_src) << 1) + q2_src + temp0;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 3);
+            temp2 = (v8i16) (temp1 - q2_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst5 = (v16u8) (temp2 + (v8i16) q2_src);
+
+            temp1 = temp0 + q2_src;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 2);
+            temp2 = (v8i16) (temp1 - q1_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst4 = (v16u8) (temp2 + (v8i16) q1_src);
+
+            temp1 = (temp0 << 1) + p1_src + q2_src;
+            temp1 = (v8u16) __msa_srari_h((v8i16) temp1, 3);
+            temp2 = (v8i16) (temp1 - q0_src);
+            temp2 = CLIP_SH(temp2, tc_neg, tc_pos);
+            dst3 = (v16u8) (temp2 + (v8i16) q0_src);
+
             dst3 = __msa_bmz_v(dst3, (v16u8) q0_src, (v16u8) q_is_pcm_vec);
             dst4 = __msa_bmz_v(dst4, (v16u8) q1_src, (v16u8) q_is_pcm_vec);
             dst5 = __msa_bmz_v(dst5, (v16u8) q2_src, (v16u8) q_is_pcm_vec);
+            /* strong filter ends */
 
+            /* weak filter */
             tc_pos >>= 1;
             tc_neg = -tc_pos;
 
             diff0 = (v8i16) (q0_src - p0_src);
             diff1 = (v8i16) (q1_src - p1_src);
-            diff0 = (v8i16) (diff0 << 3) + diff0;
-            diff1 = (v8i16) (diff1 << 1) + diff1;
+            diff0 = (diff0 << 3) + diff0;
+            diff1 = (diff1 << 1) + diff1;
             delta0 = diff0 - diff1;
             delta0 = __msa_srari_h(delta0, 4);
 
@@ -429,19 +790,20 @@ static void hevc_loopfilter_luma_ver_msa(uint8_t *src, int32_t stride,
             abs_delta0 = (v8u16) abs_delta0 < temp1;
 
             delta0 = CLIP_SH(delta0, tc_neg, tc_pos);
-            temp0 = (v8u16) delta0 + p0_src;
+
+            temp0 = (v8u16) (delta0 + p0_src);
             temp0 = (v8u16) CLIP_SH_0_255(temp0);
             temp0 = (v8u16) __msa_bmz_v((v16u8) temp0, (v16u8) p0_src,
                                         (v16u8) p_is_pcm_vec);
 
-            temp2 = (v8i16) q0_src - delta0;
+            temp2 = (v8i16) (q0_src - delta0);
             temp2 = CLIP_SH_0_255(temp2);
             temp2 = (v8i16) __msa_bmz_v((v16u8) temp2, (v16u8) q0_src,
                                         (v16u8) q_is_pcm_vec);
 
-            tmp = ((beta + (beta >> 1)) >> 3);
-            cmp0 = __msa_fill_d(!p_is_pcm0 && (dp00 + dp30 < tmp));
-            cmp1 = __msa_fill_d(!p_is_pcm4 && (dp04 + dp34 < tmp));
+            tmp = (beta + (beta >> 1)) >> 3;
+            cmp0 = __msa_fill_d(!p_is_pcm0 && ((dp00 + dp30) < tmp));
+            cmp1 = __msa_fill_d(!p_is_pcm4 && ((dp04 + dp34) < tmp));
             p_is_pcm_vec = __msa_ilvev_d(cmp1, cmp0);
             p_is_pcm_vec = __msa_ceqi_d(p_is_pcm_vec, 0);
 
@@ -480,78 +842,78 @@ static void hevc_loopfilter_luma_ver_msa(uint8_t *src, int32_t stride,
                                         (v16u8) abs_delta0);
             delta2 = (v8i16) __msa_bmz_v((v16u8) delta2, (v16u8) q1_src,
                                          (v16u8) abs_delta0);
+            /* weak filter ends*/
 
+            /* select between weak or strong */
             dst2 = __msa_bmnz_v(dst2, (v16u8) temp0, (v16u8) cmp2);
             dst3 = __msa_bmnz_v(dst3, (v16u8) temp2, (v16u8) cmp2);
             dst1 = __msa_bmnz_v(dst1, (v16u8) delta1, (v16u8) cmp2);
-            dst4 = __msa_bmnz_v(dst4, (v16u8) delta2, (v16u8) cmp2);
-            dst0 = __msa_bmnz_v(dst0, (v16u8) p2_src, (v16u8) cmp2);
-            dst5 = __msa_bmnz_v(dst5, (v16u8) q2_src, (v16u8) cmp2);
-
-            cmp0 = __msa_fill_d(d00 + d30 >= beta);
-            dst7 = (v16u8) __msa_fill_d(d04 + d34 >= beta);
-            cmp0 = __msa_ilvev_d((v2i64) dst7, cmp0);
-            dst6 = (v16u8) __msa_ceqi_d(cmp0, 0);
-
-            dst0 = __msa_bmz_v(dst0, (v16u8) p2_src, dst6);
-            dst1 = __msa_bmz_v(dst1, (v16u8) p1_src, dst6);
-            dst2 = __msa_bmz_v(dst2, (v16u8) p0_src, dst6);
-            dst3 = __msa_bmz_v(dst3, (v16u8) q0_src, dst6);
-            dst4 = __msa_bmz_v(dst4, (v16u8) q1_src, dst6);
-            dst5 = __msa_bmz_v(dst5, (v16u8) q2_src, dst6);
-
-            PCKEV_B4_UB(dst0, dst0, dst1, dst1, dst2, dst2, dst3, dst3,
-                        dst0, dst1, dst2, dst3);
-            PCKEV_B2_UB(dst4, dst4, dst5, dst5, dst4, dst5);
-
-            TRANSPOSE8x8_UB_UB(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7,
-                               dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
+            dst4 = __msa_bmnz_v(dst4, (v16u8) delta2, (v16u8) cmp2);
+            dst0 = __msa_bmnz_v(dst0, (v16u8) p2_src, (v16u8) cmp2);
+            dst5 = __msa_bmnz_v(dst5, (v16u8) q2_src, (v16u8) cmp2);
+        }
 
-            src += 1;
+        dst0 = __msa_bmz_v(dst0, (v16u8) p2_src, (v16u8) cmp3);
+        dst1 = __msa_bmz_v(dst1, (v16u8) p1_src, (v16u8) cmp3);
+        dst2 = __msa_bmz_v(dst2, (v16u8) p0_src, (v16u8) cmp3);
+        dst3 = __msa_bmz_v(dst3, (v16u8) q0_src, (v16u8) cmp3);
+        dst4 = __msa_bmz_v(dst4, (v16u8) q1_src, (v16u8) cmp3);
+        dst5 = __msa_bmz_v(dst5, (v16u8) q2_src, (v16u8) cmp3);
 
-            tmp2 = __msa_copy_u_w((v4i32) dst0, 0);
-            tmp0 = __msa_copy_u_h((v8i16) dst0, 2);
-            tmp3 = __msa_copy_u_w((v4i32) dst1, 0);
-            tmp1 = __msa_copy_u_h((v8i16) dst1, 2);
-            SW(tmp2, src);
-            SH(tmp0, src + 4);
-            src += stride;
-            SW(tmp3, src);
-            SH(tmp1, src + 4);
-            src += stride;
+        /* pack results to 8 bit */
+        PCKEV_B4_UB(dst2, dst0, dst3, dst1, dst4, dst4, dst5, dst5, dst0, dst1,
+                    dst2, dst3);
 
-            tmp2 = __msa_copy_u_w((v4i32) dst2, 0);
-            tmp0 = __msa_copy_u_h((v8i16) dst2, 2);
-            tmp3 = __msa_copy_u_w((v4i32) dst3, 0);
-            tmp1 = __msa_copy_u_h((v8i16) dst3, 2);
-            SW(tmp2, src);
-            SH(tmp0, src + 4);
-            src += stride;
-            SW(tmp3, src);
-            SH(tmp1, src + 4);
-            src += stride;
+        /* transpose */
+        ILVRL_B2_UB(dst1, dst0, dst4, dst5);
+        ILVRL_B2_UB(dst3, dst2, dst6, dst7);
+        ILVRL_H2_UB(dst5, dst4, dst0, dst1);
+        ILVRL_H2_UB(dst7, dst6, dst2, dst3);
 
-            tmp2 = __msa_copy_u_w((v4i32) dst4, 0);
-            tmp0 = __msa_copy_u_h((v8i16) dst4, 2);
-            tmp3 = __msa_copy_u_w((v4i32) dst5, 0);
-            tmp1 = __msa_copy_u_h((v8i16) dst5, 2);
-            SW(tmp2, src);
-            SH(tmp0, src + 4);
-            src += stride;
-            SW(tmp3, src);
-            SH(tmp1, src + 4);
-            src += stride;
+        src += 1;
 
-            tmp2 = __msa_copy_u_w((v4i32) dst6, 0);
-            tmp0 = __msa_copy_u_h((v8i16) dst6, 2);
-            tmp3 = __msa_copy_u_w((v4i32) dst7, 0);
-            tmp1 = __msa_copy_u_h((v8i16) dst7, 2);
-            SW(tmp2, src);
-            SH(tmp0, src + 4);
-            src += stride;
-            SW(tmp3, src);
-            SH(tmp1, src + 4);
-        }
+        tmp2 = __msa_copy_u_w((v4i32) dst0, 0);
+        tmp3 = __msa_copy_u_w((v4i32) dst0, 1);
+        tmp0 = __msa_copy_u_h((v8i16) dst2, 0);
+        tmp1 = __msa_copy_u_h((v8i16) dst2, 2);
+        SW(tmp2, src);
+        SH(tmp0, src + 4);
+        src += stride;
+        SW(tmp3, src);
+        SH(tmp1, src + 4);
+        src += stride;
+
+        tmp2 = __msa_copy_u_w((v4i32) dst0, 2);
+        tmp3 = __msa_copy_u_w((v4i32) dst0, 3);
+        tmp0 = __msa_copy_u_h((v8i16) dst2, 4);
+        tmp1 = __msa_copy_u_h((v8i16) dst2, 6);
+        SW(tmp2, src);
+        SH(tmp0, src + 4);
+        src += stride;
+        SW(tmp3, src);
+        SH(tmp1, src + 4);
+        src += stride;
+
+        tmp2 = __msa_copy_u_w((v4i32) dst1, 0);
+        tmp3 = __msa_copy_u_w((v4i32) dst1, 1);
+        tmp0 = __msa_copy_u_h((v8i16) dst3, 0);
+        tmp1 = __msa_copy_u_h((v8i16) dst3, 2);
+        SW(tmp2, src);
+        SH(tmp0, src + 4);
+        src += stride;
+        SW(tmp3, src);
+        SH(tmp1, src + 4);
+        src += stride;
+
+        tmp2 = __msa_copy_u_w((v4i32) dst1, 2);
+        tmp3 = __msa_copy_u_w((v4i32) dst1, 3);
+        tmp0 = __msa_copy_u_h((v8i16) dst3, 4);
+        tmp1 = __msa_copy_u_h((v8i16) dst3, 6);
+        SW(tmp2, src);
+        SH(tmp0, src + 4);
+        src += stride;
+        SW(tmp3, src);
+        SH(tmp1, src + 4);
     }
 }
 
@@ -687,29 +1049,28 @@ static void hevc_sao_band_filter_4width_msa(uint8_t *dst, int32_t dst_stride,
                                             int16_t *sao_offset_val,
                                             int32_t height)
 {
-    int32_t h_cnt;
     v16u8 src0, src1, src2, src3;
     v16i8 src0_r, src1_r;
     v16i8 offset, offset_val, mask;
-    v16i8 offset0 = { 0 };
-    v16i8 offset1 = { 0 };
+    v16i8 dst0, offset0, offset1;
     v16i8 zero = { 0 };
-    v8i16 temp0, temp1, dst0, dst1;
 
     offset_val = LD_SB(sao_offset_val + 1);
     offset_val = (v16i8) __msa_pckev_d((v2i64) offset_val, (v2i64) offset_val);
 
     offset_val = __msa_pckev_b(offset_val, offset_val);
-    offset1 = (v16i8) __msa_insve_w((v4i32) offset1, 3, (v4i32) offset_val);
-    offset0 = __msa_sld_b(offset1, offset0, 28 - ((sao_left_class) & 31));
+    offset1 = (v16i8) __msa_insve_w((v4i32) zero, 3, (v4i32) offset_val);
+    offset0 = __msa_sld_b(offset1, zero, 28 - ((sao_left_class) & 31));
     offset1 = __msa_sld_b(zero, offset1, 28 - ((sao_left_class) & 31));
 
+    /* load in advance. */
+    LD_UB4(src, src_stride, src0, src1, src2, src3);
+
     if (!((sao_left_class > 12) & (sao_left_class < 29))) {
         SWAP(offset0, offset1);
     }
 
-    for (h_cnt = height >> 2; h_cnt--;) {
-        LD_UB4(src, src_stride, src0, src1, src2, src3);
+    for (height -= 4; height; height -= 4) {
         src += (4 * src_stride);
 
         ILVEV_D2_SB(src0, src1, src2, src3, src0_r, src1_r);
@@ -718,14 +1079,30 @@ static void hevc_sao_band_filter_4width_msa(uint8_t *dst, int32_t dst_stride,
         mask = __msa_srli_b(src0_r, 3);
         offset = __msa_vshf_b(mask, offset1, offset0);
 
-        UNPCK_SB_SH(offset, temp0, temp1);
-        ILVRL_B2_SH(zero, src0_r, dst0, dst1);
-        ADD2(dst0, temp0, dst1, temp1, dst0, dst1);
-        CLIP_SH2_0_255(dst0, dst1);
-        dst0 = (v8i16) __msa_pckev_b((v16i8) dst1, (v16i8) dst0);
+        src0_r = (v16i8) __msa_xori_b((v16u8) src0_r, 128);
+        dst0 = __msa_adds_s_b(src0_r, offset);
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+
+        /* load in advance. */
+        LD_UB4(src, src_stride, src0, src1, src2, src3);
+
+        /* store results */
         ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, dst_stride);
         dst += (4 * dst_stride);
     }
+
+    ILVEV_D2_SB(src0, src1, src2, src3, src0_r, src1_r);
+
+    src0_r = (v16i8) __msa_pckev_w((v4i32) src1_r, (v4i32) src0_r);
+    mask = __msa_srli_b(src0_r, 3);
+    offset = __msa_vshf_b(mask, offset1, offset0);
+
+    src0_r = (v16i8) __msa_xori_b((v16u8) src0_r, 128);
+    dst0 = __msa_adds_s_b(src0_r, offset);
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+
+    /* store results */
+    ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, dst_stride);
 }
 
 static void hevc_sao_band_filter_8width_msa(uint8_t *dst, int32_t dst_stride,
@@ -734,51 +1111,69 @@ static void hevc_sao_band_filter_8width_msa(uint8_t *dst, int32_t dst_stride,
                                             int16_t *sao_offset_val,
                                             int32_t height)
 {
-    int32_t h_cnt;
     v16u8 src0, src1, src2, src3;
     v16i8 src0_r, src1_r, mask0, mask1;
-    v16i8 offset, offset_val;
-    v16i8 offset0 = { 0 };
-    v16i8 offset1 = { 0 };
+    v16i8 offset_mask0, offset_mask1, offset_val;
+    v16i8 offset0, offset1, dst0, dst1;
     v16i8 zero = { 0 };
-    v8i16 dst0, dst1, dst2, dst3;
-    v8i16 temp0, temp1, temp2, temp3;
 
     offset_val = LD_SB(sao_offset_val + 1);
     offset_val = (v16i8) __msa_pckev_d((v2i64) offset_val, (v2i64) offset_val);
     offset_val = __msa_pckev_b(offset_val, offset_val);
-    offset1 = (v16i8) __msa_insve_w((v4i32) offset1, 3, (v4i32) offset_val);
-    offset0 = __msa_sld_b(offset1, offset0, 28 - ((sao_left_class) & 31));
+    offset1 = (v16i8) __msa_insve_w((v4i32) zero, 3, (v4i32) offset_val);
+    offset0 = __msa_sld_b(offset1, zero, 28 - ((sao_left_class) & 31));
     offset1 = __msa_sld_b(zero, offset1, 28 - ((sao_left_class) & 31));
 
+    /* load in advance. */
+    LD_UB4(src, src_stride, src0, src1, src2, src3);
+
     if (!((sao_left_class > 12) & (sao_left_class < 29))) {
         SWAP(offset0, offset1);
     }
 
-    for (h_cnt = height >> 2; h_cnt--;) {
-        LD_UB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
+    for (height -= 4; height; height -= 4) {
+        src += src_stride << 2;
 
         ILVR_D2_SB(src1, src0, src3, src2, src0_r, src1_r);
 
         mask0 = __msa_srli_b(src0_r, 3);
         mask1 = __msa_srli_b(src1_r, 3);
 
-        offset = __msa_vshf_b(mask0, offset1, offset0);
-        UNPCK_SB_SH(offset, temp0, temp1);
+        offset_mask0 = __msa_vshf_b(mask0, offset1, offset0);
+        offset_mask1 = __msa_vshf_b(mask1, offset1, offset0);
+
+        /* load in advance. */
+        LD_UB4(src, src_stride, src0, src1, src2, src3);
 
-        offset = __msa_vshf_b(mask1, offset1, offset0);
-        UNPCK_SB_SH(offset, temp2, temp3);
+        XORI_B2_128_SB(src0_r, src1_r);
 
-        UNPCK_UB_SH(src0_r, dst0, dst1);
-        UNPCK_UB_SH(src1_r, dst2, dst3);
-        ADD4(dst0, temp0, dst1, temp1, dst2, temp2, dst3, temp3,
-             dst0, dst1, dst2, dst3);
-        CLIP_SH4_0_255(dst0, dst1, dst2, dst3);
-        PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst2);
-        ST8x4_UB(dst0, dst2, dst, dst_stride);
-        dst += (4 * dst_stride);
+        dst0 = __msa_adds_s_b(src0_r, offset_mask0);
+        dst1 = __msa_adds_s_b(src1_r, offset_mask1);
+
+        XORI_B2_128_SB(dst0, dst1);
+
+        /* store results */
+        ST8x4_UB(dst0, dst1, dst, dst_stride);
+        dst += dst_stride << 2;
     }
+
+    ILVR_D2_SB(src1, src0, src3, src2, src0_r, src1_r);
+
+    mask0 = __msa_srli_b(src0_r, 3);
+    mask1 = __msa_srli_b(src1_r, 3);
+
+    offset_mask0 = __msa_vshf_b(mask0, offset1, offset0);
+    offset_mask1 = __msa_vshf_b(mask1, offset1, offset0);
+
+    XORI_B2_128_SB(src0_r, src1_r);
+
+    dst0 = __msa_adds_s_b(src0_r, offset_mask0);
+    dst1 = __msa_adds_s_b(src1_r, offset_mask1);
+
+    XORI_B2_128_SB(dst0, dst1);
+
+    /* store results */
+    ST8x4_UB(dst0, dst1, dst, dst_stride);
 }
 
 static void hevc_sao_band_filter_16multiple_msa(uint8_t *dst,
@@ -789,32 +1184,30 @@ static void hevc_sao_band_filter_16multiple_msa(uint8_t *dst,
                                                 int16_t *sao_offset_val,
                                                 int32_t width, int32_t height)
 {
-    int32_t h_cnt, w_cnt;
+    int32_t w_cnt;
     v16u8 src0, src1, src2, src3;
-    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
     v16i8 out0, out1, out2, out3;
     v16i8 mask0, mask1, mask2, mask3;
     v16i8 tmp0, tmp1, tmp2, tmp3, offset_val;
-    v16i8 offset0 = { 0 };
-    v16i8 offset1 = { 0 };
+    v16i8 offset0, offset1;
     v16i8 zero = { 0 };
-    v8i16 temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
 
     offset_val = LD_SB(sao_offset_val + 1);
     offset_val = (v16i8) __msa_pckev_d((v2i64) offset_val, (v2i64) offset_val);
     offset_val = __msa_pckev_b(offset_val, offset_val);
-    offset1 = (v16i8) __msa_insve_w((v4i32) offset1, 3, (v4i32) offset_val);
-    offset0 = __msa_sld_b(offset1, offset0, 28 - ((sao_left_class) & 31));
+    offset1 = (v16i8) __msa_insve_w((v4i32) zero, 3, (v4i32) offset_val);
+    offset0 = __msa_sld_b(offset1, zero, 28 - ((sao_left_class) & 31));
     offset1 = __msa_sld_b(zero, offset1, 28 - ((sao_left_class) & 31));
 
     if (!((sao_left_class > 12) & (sao_left_class < 29))) {
         SWAP(offset0, offset1);
     }
 
-    for (h_cnt = height >> 2; h_cnt--;) {
-        for (w_cnt = 0; w_cnt < (width >> 4); w_cnt++) {
-            LD_UB4(src + w_cnt * 16, src_stride, src0, src1, src2, src3);
+    while (height > 0) {
+        /* load in advance */
+        LD_UB4(src, src_stride, src0, src1, src2, src3);
 
+        for (w_cnt = 16; w_cnt < width; w_cnt += 16) {
             mask0 = __msa_srli_b((v16i8) src0, 3);
             mask1 = __msa_srli_b((v16i8) src1, 3);
             mask2 = __msa_srli_b((v16i8) src2, 3);
@@ -824,27 +1217,44 @@ static void hevc_sao_band_filter_16multiple_msa(uint8_t *dst,
                        tmp0, tmp1);
             VSHF_B2_SB(offset0, offset1, offset0, offset1, mask2, mask3,
                        tmp2, tmp3);
-            UNPCK_SB_SH(tmp0, temp0, temp1);
-            UNPCK_SB_SH(tmp1, temp2, temp3);
-            UNPCK_SB_SH(tmp2, temp4, temp5);
-            UNPCK_SB_SH(tmp3, temp6, temp7);
-            ILVRL_B2_SH(zero, src0, dst0, dst1);
-            ILVRL_B2_SH(zero, src1, dst2, dst3);
-            ILVRL_B2_SH(zero, src2, dst4, dst5);
-            ILVRL_B2_SH(zero, src3, dst6, dst7);
-            ADD4(dst0, temp0, dst1, temp1, dst2, temp2, dst3, temp3,
-                 dst0, dst1, dst2, dst3);
-            ADD4(dst4, temp4, dst5, temp5, dst6, temp6, dst7, temp7,
-                 dst4, dst5, dst6, dst7);
-            CLIP_SH4_0_255(dst0, dst1, dst2, dst3);
-            CLIP_SH4_0_255(dst4, dst5, dst6, dst7);
-            PCKEV_B4_SB(dst1, dst0, dst3, dst2, dst5, dst4, dst7, dst6,
-                        out0, out1, out2, out3);
-            ST_SB4(out0, out1, out2, out3, dst + w_cnt * 16, dst_stride);
+            XORI_B4_128_UB(src0, src1, src2, src3);
+
+            out0 = __msa_adds_s_b((v16i8) src0, tmp0);
+            out1 = __msa_adds_s_b((v16i8) src1, tmp1);
+            out2 = __msa_adds_s_b((v16i8) src2, tmp2);
+            out3 = __msa_adds_s_b((v16i8) src3, tmp3);
+
+            /* load for next iteration */
+            LD_UB4(src + w_cnt, src_stride, src0, src1, src2, src3);
+
+            XORI_B4_128_SB(out0, out1, out2, out3);
+
+            ST_SB4(out0, out1, out2, out3, dst + w_cnt - 16, dst_stride);
         }
 
+        mask0 = __msa_srli_b((v16i8) src0, 3);
+        mask1 = __msa_srli_b((v16i8) src1, 3);
+        mask2 = __msa_srli_b((v16i8) src2, 3);
+        mask3 = __msa_srli_b((v16i8) src3, 3);
+
+        VSHF_B2_SB(offset0, offset1, offset0, offset1, mask0, mask1, tmp0,
+                   tmp1);
+        VSHF_B2_SB(offset0, offset1, offset0, offset1, mask2, mask3, tmp2,
+                   tmp3);
+        XORI_B4_128_UB(src0, src1, src2, src3);
+
+        out0 = __msa_adds_s_b((v16i8) src0, tmp0);
+        out1 = __msa_adds_s_b((v16i8) src1, tmp1);
+        out2 = __msa_adds_s_b((v16i8) src2, tmp2);
+        out3 = __msa_adds_s_b((v16i8) src3, tmp3);
+
+        XORI_B4_128_SB(out0, out1, out2, out3);
+
+        ST_SB4(out0, out1, out2, out3, dst + w_cnt - 16, dst_stride);
+
         src += src_stride << 2;
         dst += dst_stride << 2;
+        height -= 4;
     }
 }
 
@@ -855,54 +1265,51 @@ static void hevc_sao_edge_filter_0degree_4width_msa(uint8_t *dst,
                                                     int16_t *sao_offset_val,
                                                     int32_t height)
 {
-    int32_t h_cnt;
     uint32_t dst_val0, dst_val1;
-    v8i16 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0 };
+    v16u8 cmp_minus10, diff_minus10, diff_minus11, src_minus10, src_minus11;
+    v16i8 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+    v16i8 sao_offset = LD_SB(sao_offset_val);
+    v16i8 src_plus10, offset, src0, dst0;
     v16u8 const1 = (v16u8) __msa_ldi_b(1);
-    v16u8 cmp_minus10, diff_minus10, cmp_minus11, diff_minus11;
-    v16u8 src_minus10, src_minus11;
     v16i8 zero = { 0 };
-    v16i8 src_zero0, src_zero1, src_plus10, src_plus11, dst0;
-    v8i16 offset_mask0, offset_mask1;
-    v8i16 sao_offset, src00, src01;
 
-    sao_offset = LD_SH(sao_offset_val);
+    sao_offset = __msa_pckev_b(sao_offset, sao_offset);
     src -= 1;
 
-    for (h_cnt = (height >> 1); h_cnt--;) {
-        LD_UB2(src, src_stride, src_minus10, src_minus11);
+    /* load in advance */
+    LD_UB2(src, src_stride, src_minus10, src_minus11);
+
+    for (height -= 2; height; height -= 2) {
         src += (2 * src_stride);
 
-        SLDI_B2_0_SB(src_minus10, src_minus11, src_zero0, src_zero1, 1);
-        SLDI_B2_0_SB(src_minus10, src_minus11, src_plus10, src_plus11, 2);
-        ILVR_B2_UB(src_plus10, src_minus10, src_plus11, src_minus11,
-                   src_minus10, src_minus11);
-        ILVR_B2_SB(src_zero0, src_zero0, src_zero1, src_zero1, src_zero0,
-                   src_zero1);
+        src_minus10 = (v16u8) __msa_pckev_d((v2i64) src_minus11,
+                                            (v2i64) src_minus10);
 
-        cmp_minus10 = ((v16u8) src_zero0 == src_minus10);
+        src0 = (v16i8) __msa_sldi_b(zero, (v16i8) src_minus10, 1);
+        src_plus10 = (v16i8) __msa_sldi_b(zero, (v16i8) src_minus10, 2);
+
+        cmp_minus10 = ((v16u8) src0 == src_minus10);
         diff_minus10 = __msa_nor_v(cmp_minus10, cmp_minus10);
-        cmp_minus10 = (src_minus10 < (v16u8) src_zero0);
+        cmp_minus10 = (src_minus10 < (v16u8) src0);
         diff_minus10 = __msa_bmnz_v(diff_minus10, const1, cmp_minus10);
 
-        cmp_minus11 = ((v16u8) src_zero1 == src_minus11);
-        diff_minus11 = __msa_nor_v(cmp_minus11, cmp_minus11);
-        cmp_minus11 = (src_minus11 < (v16u8) src_zero1);
-        diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus11);
+        cmp_minus10 = ((v16u8) src0 == (v16u8) src_plus10);
+        diff_minus11 = __msa_nor_v(cmp_minus10, cmp_minus10);
+        cmp_minus10 = ((v16u8) src_plus10 < (v16u8) src0);
+        diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus10);
 
-        offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
-        offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
+        offset = (v16i8) diff_minus10 + (v16i8) diff_minus11 + 2;
+
+        /* load in advance */
+        LD_UB2(src, src_stride, src_minus10, src_minus11);
+
+        VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+                   offset, offset);
 
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask0,
-                   offset_mask0, offset_mask0, offset_mask0);
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask1,
-                   offset_mask1, offset_mask1, offset_mask1);
-        ILVEV_B2_SH(src_zero0, zero, src_zero1, zero, src00, src01);
-        ADD2(offset_mask0, src00, offset_mask1, src01, offset_mask0,
-             offset_mask1);
-        CLIP_SH2_0_255(offset_mask0, offset_mask1);
+        src0 = (v16i8) __msa_xori_b((v16u8) src0, 128);
+        dst0 = __msa_adds_s_b(src0, offset);
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
 
-        dst0 = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
         dst_val0 = __msa_copy_u_w((v4i32) dst0, 0);
         dst_val1 = __msa_copy_u_w((v4i32) dst0, 2);
         SW(dst_val0, dst);
@@ -910,6 +1317,37 @@ static void hevc_sao_edge_filter_0degree_4width_msa(uint8_t *dst,
         SW(dst_val1, dst);
         dst += dst_stride;
     }
+
+    src_minus10 = (v16u8) __msa_pckev_d((v2i64) src_minus11,
+                                        (v2i64) src_minus10);
+
+    src0 = (v16i8) __msa_sldi_b(zero, (v16i8) src_minus10, 1);
+    src_plus10 = (v16i8) __msa_sldi_b(zero, (v16i8) src_minus10, 2);
+
+    cmp_minus10 = ((v16u8) src0 == src_minus10);
+    diff_minus10 = __msa_nor_v(cmp_minus10, cmp_minus10);
+    cmp_minus10 = (src_minus10 < (v16u8) src0);
+    diff_minus10 = __msa_bmnz_v(diff_minus10, const1, cmp_minus10);
+
+    cmp_minus10 = ((v16u8) src0 == (v16u8) src_plus10);
+    diff_minus11 = __msa_nor_v(cmp_minus10, cmp_minus10);
+    cmp_minus10 = ((v16u8) src_plus10 < (v16u8) src0);
+    diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus10);
+
+    offset = (v16i8) diff_minus10 + (v16i8) diff_minus11 + 2;
+    VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+               offset, offset);
+
+    src0 = (v16i8) __msa_xori_b((v16u8) src0, 128);
+    dst0 = __msa_adds_s_b(src0, offset);
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+
+    dst_val0 = __msa_copy_u_w((v4i32) dst0, 0);
+    dst_val1 = __msa_copy_u_w((v4i32) dst0, 2);
+
+    SW(dst_val0, dst);
+    dst += dst_stride;
+    SW(dst_val1, dst);
 }
 
 static void hevc_sao_edge_filter_0degree_8width_msa(uint8_t *dst,
@@ -919,64 +1357,90 @@ static void hevc_sao_edge_filter_0degree_8width_msa(uint8_t *dst,
                                                     int16_t *sao_offset_val,
                                                     int32_t height)
 {
-    uint8_t *src_minus1;
-    int32_t h_cnt;
     uint64_t dst_val0, dst_val1;
-    v8i16 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0 };
+    v16i8 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     v16u8 const1 = (v16u8) __msa_ldi_b(1);
-    v16i8 dst0, dst1;
-    v16i8 zero = { 0 };
-    v16u8 cmp_minus10, diff_minus10, cmp_minus11, diff_minus11;
-    v16u8 src_minus10, src_minus11;
-    v16i8 src_zero0, src_plus10, src_zero1, src_plus11;
-    v8i16 sao_offset, src00, offset_mask0, src01, offset_mask1;
+    v16u8 cmp_minus10, diff_minus10, diff_minus11;
+    v16u8 src0, src1, dst0, src_minus10, src_minus11, src_plus10, src_plus11;
+    v16i8 offset, sao_offset = LD_SB(sao_offset_val);
 
-    sao_offset = LD_SH(sao_offset_val);
+    sao_offset = __msa_pckev_b(sao_offset, sao_offset);
+    src -= 1;
 
-    for (h_cnt = (height >> 1); h_cnt--;) {
-        src_minus1 = src - 1;
-        LD_UB2(src_minus1, src_stride, src_minus10, src_minus11);
+    /* load in advance */
+    LD_UB2(src, src_stride, src_minus10, src_minus11);
 
-        SLDI_B2_0_SB(src_minus10, src_minus11, src_zero0, src_zero1, 1);
-        SLDI_B2_0_SB(src_minus10, src_minus11, src_plus10, src_plus11, 2);
-        ILVR_B2_UB(src_plus10, src_minus10, src_plus11, src_minus11,
-                   src_minus10, src_minus11);
-        ILVR_B2_SB(src_zero0, src_zero0, src_zero1, src_zero1,
-                   src_zero0, src_zero1);
+    for (height -= 2; height; height -= 2) {
+        src += (src_stride << 1);
 
-        cmp_minus10 = ((v16u8) src_zero0 == src_minus10);
+        SLDI_B2_0_UB(src_minus10, src_minus11, src0, src1, 1);
+        SLDI_B2_0_UB(src_minus10, src_minus11, src_plus10, src_plus11, 2);
+
+        PCKEV_D2_UB(src_minus11, src_minus10, src_plus11, src_plus10,
+                    src_minus10, src_plus10);
+        src0 = (v16u8) __msa_pckev_d((v2i64) src1, (v2i64) src0);
+
+        cmp_minus10 = (src0 == src_minus10);
         diff_minus10 = __msa_nor_v(cmp_minus10, cmp_minus10);
-        cmp_minus10 = (src_minus10 < (v16u8) src_zero0);
+        cmp_minus10 = (src_minus10 < src0);
         diff_minus10 = __msa_bmnz_v(diff_minus10, const1, cmp_minus10);
 
-        cmp_minus11 = ((v16u8) src_zero1 == src_minus11);
-        diff_minus11 = __msa_nor_v(cmp_minus11, cmp_minus11);
-        cmp_minus11 = (src_minus11 < (v16u8) src_zero1);
-        diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus11);
+        cmp_minus10 = (src0 == src_plus10);
+        diff_minus11 = __msa_nor_v(cmp_minus10, cmp_minus10);
+        cmp_minus10 = (src_plus10 < src0);
+        diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus10);
 
-        offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
-        offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
+        offset = (v16i8) diff_minus10 + (v16i8) diff_minus11 + 2;
+
+        /* load in advance */
+        LD_UB2(src, src_stride, src_minus10, src_minus11);
 
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask0,
-                   offset_mask0, offset_mask0, offset_mask0);
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask1,
-                   offset_mask1, offset_mask1, offset_mask1);
-        ILVEV_B2_SH(src_zero0, zero, src_zero1, zero, src00, src01);
+        VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+                   offset, offset);
 
-        ADD2(offset_mask0, src00, offset_mask1, src01, offset_mask0,
-             offset_mask1);
-        CLIP_SH2_0_255(offset_mask0, offset_mask1);
-        PCKEV_B2_SB(offset_mask0, offset_mask0, offset_mask1, offset_mask1,
-                    dst0, dst1);
+        src0 = __msa_xori_b(src0, 128);
+        dst0 = (v16u8) __msa_adds_s_b((v16i8) src0, offset);
+        dst0 = __msa_xori_b(dst0, 128);
 
         dst_val0 = __msa_copy_u_d((v2i64) dst0, 0);
-        dst_val1 = __msa_copy_u_d((v2i64) dst1, 0);
+        dst_val1 = __msa_copy_u_d((v2i64) dst0, 1);
         SD(dst_val0, dst);
         dst += dst_stride;
         SD(dst_val1, dst);
         dst += dst_stride;
-        src += (src_stride << 1);
     }
+
+    SLDI_B2_0_UB(src_minus10, src_minus11, src0, src1, 1);
+    SLDI_B2_0_UB(src_minus10, src_minus11, src_plus10, src_plus11, 2);
+
+    PCKEV_D2_UB(src_minus11, src_minus10, src_plus11, src_plus10, src_minus10,
+                src_plus10);
+    src0 = (v16u8) __msa_pckev_d((v2i64) src1, (v2i64) src0);
+
+    cmp_minus10 = ((v16u8) src0 == src_minus10);
+    diff_minus10 = __msa_nor_v(cmp_minus10, cmp_minus10);
+    cmp_minus10 = (src_minus10 < (v16u8) src0);
+    diff_minus10 = __msa_bmnz_v(diff_minus10, const1, cmp_minus10);
+
+    cmp_minus10 = (src0 ==  src_plus10);
+    diff_minus11 = __msa_nor_v(cmp_minus10, cmp_minus10);
+    cmp_minus10 = (src_plus10 < src0);
+    diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus10);
+
+    offset = (v16i8) diff_minus10 + (v16i8) diff_minus11 + 2;
+
+    VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+               offset, offset);
+
+    src0 = __msa_xori_b(src0, 128);
+    dst0 = (v16u8) __msa_adds_s_b((v16i8) src0, offset);
+    dst0 = __msa_xori_b(dst0, 128);
+
+    dst_val0 = __msa_copy_u_d((v2i64) dst0, 0);
+    dst_val1 = __msa_copy_u_d((v2i64) dst0, 1);
+    SD(dst_val0, dst);
+    dst += dst_stride;
+    SD(dst_val1, dst);
 }
 
 static void hevc_sao_edge_filter_0degree_16multiple_msa(uint8_t *dst,
@@ -988,7 +1452,7 @@ static void hevc_sao_edge_filter_0degree_16multiple_msa(uint8_t *dst,
                                                         int32_t height)
 {
     uint8_t *dst_ptr, *src_minus1;
-    int32_t h_cnt, v_cnt;
+    int32_t v_cnt;
     v16i8 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     v16u8 const1 = (v16u8) __msa_ldi_b(1);
     v16i8 sao_offset;
@@ -1001,20 +1465,18 @@ static void hevc_sao_edge_filter_0degree_16multiple_msa(uint8_t *dst,
     v16i8 offset_mask0, offset_mask1, offset_mask2, offset_mask3;
     v16i8 src_zero0, src_zero1, src_zero2, src_zero3;
     v16i8 src_plus10, src_plus11, src_plus12, src_plus13;
-    v8i16 src0, src1, src2, src3, src4, src5, src6, src7;
-    v8i16 temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
 
     sao_offset = LD_SB(sao_offset_val);
     sao_offset = __msa_pckev_b(sao_offset, sao_offset);
 
-    for (h_cnt = (height >> 2); h_cnt--;) {
+    for (; height; height -= 4) {
         src_minus1 = src - 1;
         LD_UB4(src_minus1, src_stride,
                src_minus10, src_minus11, src_minus12, src_minus13);
 
-        for (v_cnt = 0; v_cnt < (width >> 4); v_cnt++) {
+        for (v_cnt = 0; v_cnt < width; v_cnt += 16) {
             src_minus1 += 16;
-            dst_ptr = dst + (v_cnt << 4);
+            dst_ptr = dst + v_cnt;
             LD_UB4(src_minus1, src_stride, src10, src11, src12, src13);
 
             SLDI_B2_SB(src10, src11, src_minus10, src_minus11, src_zero0,
@@ -1075,22 +1537,14 @@ static void hevc_sao_edge_filter_0degree_16multiple_msa(uint8_t *dst,
             VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask3,
                        offset_mask3, offset_mask3, offset_mask3);
 
-            UNPCK_UB_SH(src_zero0, src0, src1);
-            UNPCK_SB_SH(offset_mask0, temp0, temp1);
-            UNPCK_UB_SH(src_zero1, src2, src3);
-            UNPCK_SB_SH(offset_mask1, temp2, temp3);
-            UNPCK_UB_SH(src_zero2, src4, src5);
-            UNPCK_SB_SH(offset_mask2, temp4, temp5);
-            UNPCK_UB_SH(src_zero3, src6, src7);
-            UNPCK_SB_SH(offset_mask3, temp6, temp7);
-            ADD4(temp0, src0, temp1, src1, temp2, src2, temp3, src3, temp0,
-                 temp1, temp2, temp3);
-            ADD4(temp4, src4, temp5, src5, temp6, src6, temp7, src7, temp4,
-                 temp5, temp6, temp7);
-            CLIP_SH4_0_255(temp0, temp1, temp2, temp3);
-            CLIP_SH4_0_255(temp4, temp5, temp6, temp7);
-            PCKEV_B4_UB(temp1, temp0, temp3, temp2, temp5, temp4, temp7, temp6,
-                        dst0, dst1, dst2, dst3);
+            XORI_B4_128_SB(src_zero0, src_zero1, src_zero2, src_zero3);
+
+            dst0 = (v16u8) __msa_adds_s_b((v16i8) src_zero0, offset_mask0);
+            dst1 = (v16u8) __msa_adds_s_b((v16i8) src_zero1, offset_mask1);
+            dst2 = (v16u8) __msa_adds_s_b((v16i8) src_zero2, offset_mask2);
+            dst3 = (v16u8) __msa_adds_s_b((v16i8) src_zero3, offset_mask3);
+
+            XORI_B4_128_UB(dst0, dst1, dst2, dst3);
 
             src_minus10 = src10;
             ST_UB(dst0, dst_ptr);
@@ -1114,23 +1568,25 @@ static void hevc_sao_edge_filter_90degree_4width_msa(uint8_t *dst,
                                                      int16_t *sao_offset_val,
                                                      int32_t height)
 {
-    int32_t h_cnt;
     uint32_t dst_val0, dst_val1;
-    v8i16 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0 };
+    v16i8 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     v16u8 const1 = (v16u8) __msa_ldi_b(1);
     v16i8 dst0;
-    v16i8 zero = { 0 };
+    v16i8 sao_offset = LD_SB(sao_offset_val);
     v16u8 cmp_minus10, diff_minus10, cmp_minus11, diff_minus11;
     v16u8 src_minus10, src_minus11, src10, src11;
     v16i8 src_zero0, src_zero1;
-    v8i16 sao_offset, src00, src01, offset_mask0, offset_mask1;
+    v16i8 offset;
+    v8i16 offset_mask0, offset_mask1;
 
-    sao_offset = LD_SH(sao_offset_val);
+    sao_offset = __msa_pckev_b(sao_offset, sao_offset);
 
+    /* load in advance */
     LD_UB2(src - src_stride, src_stride, src_minus10, src_minus11);
+    LD_UB2(src + src_stride, src_stride, src10, src11);
 
-    for (h_cnt = (height >> 1); h_cnt--;) {
-        LD_UB2(src + src_stride, src_stride, src10, src11);
+    for (height -= 2; height; height -= 2) {
+        src += (src_stride << 1);
 
         src_minus10 = (v16u8) __msa_ilvr_b((v16i8) src10, (v16i8) src_minus10);
         src_zero0 = __msa_ilvr_b((v16i8) src_minus11, (v16i8) src_minus11);
@@ -1150,19 +1606,22 @@ static void hevc_sao_edge_filter_90degree_4width_msa(uint8_t *dst,
         offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
         offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
 
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask0,
-                   offset_mask0, offset_mask0, offset_mask0);
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask1,
-                   offset_mask1, offset_mask1, offset_mask1);
-        ILVEV_B2_SH(src_zero0, zero, src_zero1, zero, src00, src01);
-        ADD2(offset_mask0, src00, offset_mask1, src01, offset_mask0,
-             offset_mask1);
-        CLIP_SH2_0_255(offset_mask0, offset_mask1);
-        dst0 = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+        offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+        dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
+
+        VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+                   offset, offset);
+
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+        dst0 = __msa_adds_s_b(dst0, offset);
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
 
         src_minus10 = src10;
         src_minus11 = src11;
 
+        /* load in advance */
+        LD_UB2(src + src_stride, src_stride, src10, src11);
+
         dst_val0 = __msa_copy_u_w((v4i32) dst0, 0);
         dst_val1 = __msa_copy_u_w((v4i32) dst0, 2);
         SW(dst_val0, dst);
@@ -1170,8 +1629,41 @@ static void hevc_sao_edge_filter_90degree_4width_msa(uint8_t *dst,
         SW(dst_val1, dst);
 
         dst += dst_stride;
-        src += (src_stride << 1);
     }
+
+    src_minus10 = (v16u8) __msa_ilvr_b((v16i8) src10, (v16i8) src_minus10);
+    src_zero0 = __msa_ilvr_b((v16i8) src_minus11, (v16i8) src_minus11);
+    src_minus11 = (v16u8) __msa_ilvr_b((v16i8) src11, (v16i8) src_minus11);
+    src_zero1 = __msa_ilvr_b((v16i8) src10, (v16i8) src10);
+
+    cmp_minus10 = ((v16u8) src_zero0 == src_minus10);
+    diff_minus10 = __msa_nor_v(cmp_minus10, cmp_minus10);
+    cmp_minus10 = (src_minus10 < (v16u8) src_zero0);
+    diff_minus10 = __msa_bmnz_v(diff_minus10, const1, cmp_minus10);
+
+    cmp_minus11 = ((v16u8) src_zero1 == src_minus11);
+    diff_minus11 = __msa_nor_v(cmp_minus11, cmp_minus11);
+    cmp_minus11 = (src_minus11 < (v16u8) src_zero1);
+    diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus11);
+
+    offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
+    offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
+
+    offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+    dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
+
+    VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset,
+               offset, offset, offset);
+
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+    dst0 = __msa_adds_s_b(dst0, offset);
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+
+    dst_val0 = __msa_copy_u_w((v4i32) dst0, 0);
+    dst_val1 = __msa_copy_u_w((v4i32) dst0, 2);
+    SW(dst_val0, dst);
+    dst += dst_stride;
+    SW(dst_val1, dst);
 }
 
 static void hevc_sao_edge_filter_90degree_8width_msa(uint8_t *dst,
@@ -1181,22 +1673,23 @@ static void hevc_sao_edge_filter_90degree_8width_msa(uint8_t *dst,
                                                      int16_t *sao_offset_val,
                                                      int32_t height)
 {
-    int32_t h_cnt;
     uint64_t dst_val0, dst_val1;
-    v8i16 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0 };
+    v16i8 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     v16u8 const1 = (v16u8) __msa_ldi_b(1);
-    v16i8 zero = { 0 };
-    v16i8 src_zero0, src_zero1, dst0, dst1;
+    v16i8 offset, sao_offset = LD_SB(sao_offset_val);
+    v16i8 src_zero0, src_zero1, dst0;
     v16u8 cmp_minus10, diff_minus10, cmp_minus11, diff_minus11;
     v16u8 src_minus10, src_minus11, src10, src11;
-    v8i16 sao_offset, src00, offset_mask0, src01, offset_mask1;
+    v8i16 offset_mask0, offset_mask1;
 
-    sao_offset = LD_SH(sao_offset_val);
+    sao_offset = __msa_pckev_b(sao_offset, sao_offset);
 
+    /* load in advance */
     LD_UB2(src - src_stride, src_stride, src_minus10, src_minus11);
+    LD_UB2(src + src_stride, src_stride, src10, src11);
 
-    for (h_cnt = (height >> 1); h_cnt--;) {
-        LD_UB2(src + src_stride, src_stride, src10, src11);
+    for (height -= 2; height; height -= 2) {
+        src += (src_stride << 1);
 
         src_minus10 = (v16u8) __msa_ilvr_b((v16i8) src10, (v16i8) src_minus10);
         src_zero0 = __msa_ilvr_b((v16i8) src_minus11, (v16i8) src_minus11);
@@ -1216,28 +1709,63 @@ static void hevc_sao_edge_filter_90degree_8width_msa(uint8_t *dst,
         offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
         offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
 
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask0,
-                   offset_mask0, offset_mask0, offset_mask0);
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask1,
-                   offset_mask1, offset_mask1, offset_mask1);
-        ILVEV_B2_SH(src_zero0, zero, src_zero1, zero, src00, src01);
-        ADD2(offset_mask0, src00, offset_mask1, src01, offset_mask0,
-             offset_mask1);
-        CLIP_SH2_0_255(offset_mask0, offset_mask1);
-        PCKEV_B2_SB(offset_mask0, offset_mask0, offset_mask1, offset_mask1,
-                    dst0, dst1);
+        offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+        dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
+
+        VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset,
+                   offset, offset, offset);
+
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+        dst0 = __msa_adds_s_b(dst0, offset);
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
 
         src_minus10 = src10;
         src_minus11 = src11;
 
+        /* load in advance */
+        LD_UB2(src + src_stride, src_stride, src10, src11);
+
         dst_val0 = __msa_copy_u_d((v2i64) dst0, 0);
-        dst_val1 = __msa_copy_u_d((v2i64) dst1, 0);
+        dst_val1 = __msa_copy_u_d((v2i64) dst0, 1);
         SD(dst_val0, dst);
         dst += dst_stride;
         SD(dst_val1, dst);
         dst += dst_stride;
-        src += (src_stride << 1);
     }
+
+    src_minus10 = (v16u8) __msa_ilvr_b((v16i8) src10, (v16i8) src_minus10);
+    src_zero0 = __msa_ilvr_b((v16i8) src_minus11, (v16i8) src_minus11);
+    src_minus11 = (v16u8) __msa_ilvr_b((v16i8) src11, (v16i8) src_minus11);
+    src_zero1 = __msa_ilvr_b((v16i8) src10, (v16i8) src10);
+
+    cmp_minus10 = ((v16u8) src_zero0 == src_minus10);
+    diff_minus10 = __msa_nor_v(cmp_minus10, cmp_minus10);
+    cmp_minus10 = (src_minus10 < (v16u8) src_zero0);
+    diff_minus10 = __msa_bmnz_v(diff_minus10, const1, cmp_minus10);
+
+    cmp_minus11 = ((v16u8) src_zero1 == src_minus11);
+    diff_minus11 = __msa_nor_v(cmp_minus11, cmp_minus11);
+    cmp_minus11 = (src_minus11 < (v16u8) src_zero1);
+    diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus11);
+
+    offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
+    offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
+
+    offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+    dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
+
+    VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+               offset, offset);
+
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+    dst0 = __msa_adds_s_b(dst0, offset);
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+
+    dst_val0 = __msa_copy_u_d((v2i64) dst0, 0);
+    dst_val1 = __msa_copy_u_d((v2i64) dst0, 1);
+    SD(dst_val0, dst);
+    dst += dst_stride;
+    SD(dst_val1, dst);
 }
 
 static void hevc_sao_edge_filter_90degree_16multiple_msa(uint8_t *dst,
@@ -1261,15 +1789,13 @@ static void hevc_sao_edge_filter_90degree_16multiple_msa(uint8_t *dst,
     v16u8 src10, src_minus10, dst0, src11, src_minus11, dst1;
     v16u8 src12, dst2, src13, dst3;
     v16i8 offset_mask0, offset_mask1, offset_mask2, offset_mask3, sao_offset;
-    v8i16 src0, src1, src2, src3, src4, src5, src6, src7;
-    v8i16 temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
 
     sao_offset = LD_SB(sao_offset_val);
     sao_offset = __msa_pckev_b(sao_offset, sao_offset);
 
-    for (v_cnt = 0; v_cnt < (width >> 4); v_cnt++) {
-        src = src_orig + (v_cnt << 4);
-        dst = dst_orig + (v_cnt << 4);
+    for (v_cnt = 0; v_cnt < width; v_cnt += 16) {
+        src = src_orig + v_cnt;
+        dst = dst_orig + v_cnt;
 
         LD_UB2(src - src_stride, src_stride, src_minus10, src_minus11);
 
@@ -1325,24 +1851,15 @@ static void hevc_sao_edge_filter_90degree_16multiple_msa(uint8_t *dst,
             VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset,
                        offset_mask3, offset_mask3, offset_mask3, offset_mask3);
 
-            UNPCK_UB_SH(src_minus11, src0, src1);
-            UNPCK_SB_SH(offset_mask0, temp0, temp1);
-            UNPCK_UB_SH(src10, src2, src3);
-            UNPCK_SB_SH(offset_mask1, temp2, temp3);
-            UNPCK_UB_SH(src11, src4, src5);
-            UNPCK_SB_SH(offset_mask2, temp4, temp5);
-            UNPCK_UB_SH(src12, src6, src7);
-            UNPCK_SB_SH(offset_mask3, temp6, temp7);
-            ADD4(temp0, src0, temp1, src1, temp2, src2, temp3, src3, temp0,
-                 temp1, temp2, temp3);
-            ADD4(temp4, src4, temp5, src5, temp6, src6, temp7, src7, temp4,
-                 temp5, temp6, temp7);
-            CLIP_SH4_0_255(temp0, temp1, temp2, temp3);
-            CLIP_SH4_0_255(temp4, temp5, temp6, temp7);
-            PCKEV_B4_UB(temp1, temp0, temp3, temp2, temp5, temp4, temp7, temp6,
-                        dst0, dst1, dst2, dst3);
-
             src_minus10 = src12;
+            XORI_B4_128_UB(src_minus11, src10, src11, src12);
+
+            dst0 = (v16u8) __msa_adds_s_b((v16i8) src_minus11, offset_mask0);
+            dst1 = (v16u8) __msa_adds_s_b((v16i8) src10, offset_mask1);
+            dst2 = (v16u8) __msa_adds_s_b((v16i8) src11, offset_mask2);
+            dst3 = (v16u8) __msa_adds_s_b((v16i8) src12, offset_mask3);
+
+            XORI_B4_128_UB(dst0, dst1, dst2, dst3);
             src_minus11 = src13;
 
             ST_UB4(dst0, dst1, dst2, dst3, dst, dst_stride);
@@ -1361,23 +1878,25 @@ static void hevc_sao_edge_filter_45degree_4width_msa(uint8_t *dst,
                                                      int32_t height)
 {
     uint8_t *src_orig;
-    int32_t h_cnt;
     uint32_t dst_val0, dst_val1;
-    v8i16 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0 };
+    v16i8 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     v16u8 const1 = (v16u8) __msa_ldi_b(1);
-    v16i8 zero = { 0 };
+    v16i8 offset, sao_offset = LD_SB(sao_offset_val);
     v16u8 cmp_minus10, diff_minus10, src_minus10, cmp_minus11, diff_minus11;
     v16u8 src_minus11, src10, src11;
     v16i8 src_plus0, src_zero0, src_plus1, src_zero1, dst0;
-    v8i16 sao_offset, src00, src01, offset_mask0, offset_mask1;
+    v8i16 offset_mask0, offset_mask1;
 
-    sao_offset = LD_SH(sao_offset_val);
+    sao_offset = __msa_pckev_b(sao_offset, sao_offset);
 
     src_orig = src - 1;
+
+    /* load in advance */
     LD_UB2(src_orig - src_stride, src_stride, src_minus10, src_minus11);
+    LD_UB2(src_orig + src_stride, src_stride, src10, src11);
 
-    for (h_cnt = (height >> 1); h_cnt--;) {
-        LD_UB2(src_orig + src_stride, src_stride, src10, src11);
+    for (height -= 2; height; height -= 2) {
+        src_orig += (src_stride << 1);
 
         SLDI_B2_0_SB(src_minus11, src10, src_zero0, src_zero1, 1);
         SLDI_B2_0_SB(src10, src11, src_plus0, src_plus1, 2);
@@ -1400,20 +1919,22 @@ static void hevc_sao_edge_filter_45degree_4width_msa(uint8_t *dst,
         offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
         offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
 
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask0,
-                   offset_mask0, offset_mask0, offset_mask0);
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask1,
-                   offset_mask1, offset_mask1, offset_mask1);
-        ILVEV_B2_SH(src_zero0, zero, src_zero1, zero, src00, src01);
-        ADD2(offset_mask0, src00, offset_mask1, src01, offset_mask0,
-             offset_mask1);
-        CLIP_SH2_0_255(offset_mask0, offset_mask1);
+        offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+        dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
 
-        dst0 = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+        VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset,
+                   offset, offset, offset);
+
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+        dst0 = __msa_adds_s_b(dst0, offset);
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
 
         src_minus10 = src10;
         src_minus11 = src11;
 
+        /* load in advance */
+        LD_UB2(src_orig + src_stride, src_stride, src10, src11);
+
         dst_val0 = __msa_copy_u_w((v4i32) dst0, 0);
         dst_val1 = __msa_copy_u_w((v4i32) dst0, 2);
         SW(dst_val0, dst);
@@ -1421,8 +1942,44 @@ static void hevc_sao_edge_filter_45degree_4width_msa(uint8_t *dst,
         SW(dst_val1, dst);
 
         dst += dst_stride;
-        src_orig += (src_stride << 1);
     }
+
+    SLDI_B2_0_SB(src_minus11, src10, src_zero0, src_zero1, 1);
+    SLDI_B2_0_SB(src10, src11, src_plus0, src_plus1, 2);
+
+    ILVR_B2_UB(src_plus0, src_minus10, src_plus1, src_minus11, src_minus10,
+               src_minus11);
+    ILVR_B2_SB(src_zero0, src_zero0, src_zero1, src_zero1, src_zero0,
+               src_zero1);
+
+    cmp_minus10 = ((v16u8) src_zero0 == src_minus10);
+    diff_minus10 = __msa_nor_v(cmp_minus10, cmp_minus10);
+    cmp_minus10 = (src_minus10 < (v16u8) src_zero0);
+    diff_minus10 = __msa_bmnz_v(diff_minus10, const1, cmp_minus10);
+
+    cmp_minus11 = ((v16u8) src_zero1 == src_minus11);
+    diff_minus11 = __msa_nor_v(cmp_minus11, cmp_minus11);
+    cmp_minus11 = (src_minus11 < (v16u8) src_zero1);
+    diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus11);
+
+    offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
+    offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
+
+    offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+    dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
+
+    VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+               offset, offset);
+
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+    dst0 = __msa_adds_s_b(dst0, offset);
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+
+    dst_val0 = __msa_copy_u_w((v4i32) dst0, 0);
+    dst_val1 = __msa_copy_u_w((v4i32) dst0, 2);
+    SW(dst_val0, dst);
+    dst += dst_stride;
+    SW(dst_val1, dst);
 }
 
 static void hevc_sao_edge_filter_45degree_8width_msa(uint8_t *dst,
@@ -1433,23 +1990,24 @@ static void hevc_sao_edge_filter_45degree_8width_msa(uint8_t *dst,
                                                      int32_t height)
 {
     uint8_t *src_orig;
-    int32_t h_cnt;
     uint64_t dst_val0, dst_val1;
-    v8i16 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0 };
+    v16i8 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     v16u8 const1 = (v16u8) __msa_ldi_b(1);
-    v16i8 zero = { 0 };
+    v16i8 offset, sao_offset = LD_SB(sao_offset_val);
     v16u8 cmp_minus10, diff_minus10, cmp_minus11, diff_minus11;
     v16u8 src_minus10, src10, src_minus11, src11;
-    v16i8 src_zero0, src_plus10, src_zero1, src_plus11, dst0, dst1;
-    v8i16 sao_offset, src00, offset_mask0, src01, offset_mask1;
+    v16i8 src_zero0, src_plus10, src_zero1, src_plus11, dst0;
+    v8i16 offset_mask0, offset_mask1;
 
-    sao_offset = LD_SH(sao_offset_val);
+    sao_offset = __msa_pckev_b(sao_offset, sao_offset);
     src_orig = src - 1;
 
+    /* load in advance */
     LD_UB2(src_orig - src_stride, src_stride, src_minus10, src_minus11);
+    LD_UB2(src_orig + src_stride, src_stride, src10, src11);
 
-    for (h_cnt = (height >> 1); h_cnt--;) {
-        LD_UB2(src_orig + src_stride, src_stride, src10, src11);
+    for (height -= 2; height; height -= 2) {
+        src_orig += (src_stride << 1);
 
         SLDI_B2_0_SB(src_minus11, src10, src_zero0, src_zero1, 1);
         SLDI_B2_0_SB(src10, src11, src_plus10, src_plus11, 2);
@@ -1472,29 +2030,71 @@ static void hevc_sao_edge_filter_45degree_8width_msa(uint8_t *dst,
         offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
         offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
 
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask0,
-                   offset_mask0, offset_mask0, offset_mask0);
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask1,
-                   offset_mask1, offset_mask1, offset_mask1);
-        ILVEV_B2_SH(src_zero0, zero, src_zero1, zero, src00, src01);
-        ADD2(offset_mask0, src00, offset_mask1, src01, offset_mask0,
-             offset_mask1);
-        CLIP_SH2_0_255(offset_mask0, offset_mask1);
-        PCKEV_B2_SB(offset_mask0, offset_mask0, offset_mask1, offset_mask1,
-                    dst0, dst1);
+        offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+        dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
+
+        VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+                   offset, offset);
+
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+        dst0 = __msa_adds_s_b(dst0, offset);
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
 
         src_minus10 = src10;
         src_minus11 = src11;
 
+        /* load in advance */
+        LD_UB2(src_orig + src_stride, src_stride, src10, src11);
+
         dst_val0 = __msa_copy_u_d((v2i64) dst0, 0);
-        dst_val1 = __msa_copy_u_d((v2i64) dst1, 0);
+        dst_val1 = __msa_copy_u_d((v2i64) dst0, 1);
         SD(dst_val0, dst);
         dst += dst_stride;
         SD(dst_val1, dst);
-
         dst += dst_stride;
-        src_orig += (src_stride << 1);
     }
+
+    SLDI_B2_0_SB(src_minus11, src10, src_zero0, src_zero1, 1);
+    SLDI_B2_0_SB(src10, src11, src_plus10, src_plus11, 2);
+    ILVR_B2_UB(src_plus10, src_minus10, src_plus11, src_minus11, src_minus10,
+               src_minus11);
+    ILVR_B2_SB(src_zero0, src_zero0, src_zero1, src_zero1, src_zero0,
+               src_zero1);
+
+    cmp_minus10 = ((v16u8) src_zero0 == src_minus10);
+    diff_minus10 = __msa_nor_v(cmp_minus10, cmp_minus10);
+    cmp_minus10 = (src_minus10 < (v16u8) src_zero0);
+    diff_minus10 = __msa_bmnz_v(diff_minus10, const1, cmp_minus10);
+
+    cmp_minus11 = ((v16u8) src_zero1 == src_minus11);
+    diff_minus11 = __msa_nor_v(cmp_minus11, cmp_minus11);
+    cmp_minus11 = (src_minus11 < (v16u8) src_zero1);
+    diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus11);
+
+    offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
+    offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
+
+    offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+    dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
+
+    VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+               offset, offset);
+
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+    dst0 = __msa_adds_s_b(dst0, offset);
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+
+    src_minus10 = src10;
+    src_minus11 = src11;
+
+    /* load in advance */
+    LD_UB2(src_orig + src_stride, src_stride, src10, src11);
+
+    dst_val0 = __msa_copy_u_d((v2i64) dst0, 0);
+    dst_val1 = __msa_copy_u_d((v2i64) dst0, 1);
+    SD(dst_val0, dst);
+    dst += dst_stride;
+    SD(dst_val1, dst);
 }
 
 static void hevc_sao_edge_filter_45degree_16multiple_msa(uint8_t *dst,
@@ -1508,7 +2108,7 @@ static void hevc_sao_edge_filter_45degree_16multiple_msa(uint8_t *dst,
 {
     uint8_t *src_orig = src;
     uint8_t *dst_orig = dst;
-    int32_t h_cnt, v_cnt;
+    int32_t v_cnt;
     v16i8 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     v16u8 const1 = (v16u8) __msa_ldi_b(1);
     v16u8 cmp_minus10, cmp_plus10, diff_minus10, diff_plus10, cmp_minus11;
@@ -1520,22 +2120,20 @@ static void hevc_sao_edge_filter_45degree_16multiple_msa(uint8_t *dst,
     v16u8 src12, src_minus12, dst2, src13, src_minus13, dst3;
     v16i8 src_zero0, src_plus10, src_zero1, src_plus11, src_zero2, src_plus12;
     v16i8 src_zero3, sao_offset;
-    v8i16 src0, src1, src2, src3, src4, src5, src6, src7;
-    v8i16 temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
 
     sao_offset = LD_SB(sao_offset_val);
     sao_offset = __msa_pckev_b(sao_offset, sao_offset);
 
-    for (h_cnt = (height >> 2); h_cnt--;) {
+    for (; height; height -= 4) {
         src_orig = src - 1;
         dst_orig = dst;
-        LD_UB4(src_orig, src_stride,
-               src_minus11, src_minus12, src_minus13, src_minus14);
+        LD_UB4(src_orig, src_stride, src_minus11, src_minus12, src_minus13,
+               src_minus14);
 
-        for (v_cnt = 0; v_cnt < (width >> 4); v_cnt++) {
+        for (v_cnt = 0; v_cnt < width; v_cnt += 16) {
             src_minus10 = LD_UB(src_orig - src_stride);
             LD_UB4(src_orig + 16, src_stride, src10, src11, src12, src13);
-            src_plus13 = LD_UB(src + 1 + (v_cnt << 4) + (src_stride << 2));
+            src_plus13 = LD_UB(src + 1 + v_cnt + (src_stride << 2));
             src_orig += 16;
 
             SLDI_B2_SB(src10, src11, src_minus11, src_minus12, src_zero0,
@@ -1597,22 +2195,14 @@ static void hevc_sao_edge_filter_45degree_16multiple_msa(uint8_t *dst,
             VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset,
                        offset_mask3, offset_mask3, offset_mask3, offset_mask3);
 
-            UNPCK_UB_SH(src_zero0, src0, src1);
-            UNPCK_SB_SH(offset_mask0, temp0, temp1);
-            UNPCK_UB_SH(src_zero1, src2, src3);
-            UNPCK_SB_SH(offset_mask1, temp2, temp3);
-            UNPCK_UB_SH(src_zero2, src4, src5);
-            UNPCK_SB_SH(offset_mask2, temp4, temp5);
-            UNPCK_UB_SH(src_zero3, src6, src7);
-            UNPCK_SB_SH(offset_mask3, temp6, temp7);
-            ADD4(temp0, src0, temp1, src1, temp2, src2, temp3, src3, temp0,
-                 temp1, temp2, temp3);
-            ADD4(temp4, src4, temp5, src5, temp6, src6, temp7, src7, temp4,
-                 temp5, temp6, temp7);
-            CLIP_SH4_0_255(temp0, temp1, temp2, temp3);
-            CLIP_SH4_0_255(temp4, temp5, temp6, temp7);
-            PCKEV_B4_UB(temp1, temp0, temp3, temp2, temp5, temp4,
-                        temp7, temp6, dst0, dst1, dst2, dst3);
+            XORI_B4_128_SB(src_zero0, src_zero1, src_zero2, src_zero3);
+
+            dst0 = (v16u8) __msa_adds_s_b((v16i8) src_zero0, offset_mask0);
+            dst1 = (v16u8) __msa_adds_s_b((v16i8) src_zero1, offset_mask1);
+            dst2 = (v16u8) __msa_adds_s_b((v16i8) src_zero2, offset_mask2);
+            dst3 = (v16u8) __msa_adds_s_b((v16i8) src_zero3, offset_mask3);
+
+            XORI_B4_128_UB(dst0, dst1, dst2, dst3);
 
             src_minus11 = src10;
             src_minus12 = src11;
@@ -1636,23 +2226,24 @@ static void hevc_sao_edge_filter_135degree_4width_msa(uint8_t *dst,
                                                       int32_t height)
 {
     uint8_t *src_orig;
-    int32_t h_cnt;
     uint32_t dst_val0, dst_val1;
-    v8i16 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0 };
+    v16i8 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     v16u8 const1 = (v16u8) __msa_ldi_b(1);
-    v16i8 zero = { 0 };
+    v16i8 offset, sao_offset = LD_SB(sao_offset_val);
     v16i8 src_zero0, src_zero1, dst0;
     v16u8 cmp_minus10, diff_minus10, cmp_minus11, diff_minus11;
     v16u8 src_minus10, src10, src_minus11, src11;
-    v8i16 offset_mask0, offset_mask1, sao_offset, src00, src01;
+    v8i16 offset_mask0, offset_mask1;
 
-    sao_offset = LD_SH(sao_offset_val);
+    sao_offset = __msa_pckev_b(sao_offset, sao_offset);
     src_orig = src - 1;
 
+    /* load in advance */
     LD_UB2(src_orig - src_stride, src_stride, src_minus10, src_minus11);
+    LD_UB2(src_orig + src_stride, src_stride, src10, src11);
 
-    for (h_cnt = (height >> 1); h_cnt--;) {
-        LD_UB2(src_orig + src_stride, src_stride, src10, src11);
+    for (height -= 2; height; height -= 2) {
+        src_orig += (src_stride << 1);
 
         SLDI_B2_0_SB(src_minus11, src10, src_zero0, src_zero1, 1);
         SLDI_B2_0_UB(src_minus10, src_minus11, src_minus10, src_minus11, 2);
@@ -1675,19 +2266,22 @@ static void hevc_sao_edge_filter_135degree_4width_msa(uint8_t *dst,
         offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
         offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
 
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask0,
-                   offset_mask0, offset_mask0, offset_mask0);
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask1,
-                   offset_mask1, offset_mask1, offset_mask1);
-        ILVEV_B2_SH(src_zero0, zero, src_zero1, zero, src00, src01);
-        ADD2(offset_mask0, src00, offset_mask1, src01, offset_mask0,
-             offset_mask1);
-        CLIP_SH2_0_255(offset_mask0, offset_mask1);
-        dst0 = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+        offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+        dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
+
+        VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+                   offset, offset);
+
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+        dst0 = __msa_adds_s_b(dst0, offset);
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
 
         src_minus10 = src10;
         src_minus11 = src11;
 
+        /* load in advance */
+        LD_UB2(src_orig + src_stride, src_stride, src10, src11);
+
         dst_val0 = __msa_copy_u_w((v4i32) dst0, 0);
         dst_val1 = __msa_copy_u_w((v4i32) dst0, 2);
 
@@ -1696,8 +2290,46 @@ static void hevc_sao_edge_filter_135degree_4width_msa(uint8_t *dst,
         SW(dst_val1, dst);
 
         dst += dst_stride;
-        src_orig += (src_stride << 1);
     }
+
+    SLDI_B2_0_SB(src_minus11, src10, src_zero0, src_zero1, 1);
+    SLDI_B2_0_UB(src_minus10, src_minus11, src_minus10, src_minus11, 2);
+
+    ILVR_B2_UB(src10, src_minus10, src11, src_minus11, src_minus10,
+               src_minus11);
+    ILVR_B2_SB(src_zero0, src_zero0, src_zero1, src_zero1, src_zero0,
+               src_zero1);
+
+    cmp_minus10 = ((v16u8) src_zero0 == src_minus10);
+    diff_minus10 = __msa_nor_v(cmp_minus10, cmp_minus10);
+    cmp_minus10 = (src_minus10 < (v16u8) src_zero0);
+    diff_minus10 = __msa_bmnz_v(diff_minus10, const1, cmp_minus10);
+
+    cmp_minus11 = ((v16u8) src_zero1 == src_minus11);
+    diff_minus11 = __msa_nor_v(cmp_minus11, cmp_minus11);
+    cmp_minus11 = (src_minus11 < (v16u8) src_zero1);
+    diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus11);
+
+    offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
+    offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
+
+    offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+    dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
+
+    VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+               offset, offset);
+
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+    dst0 = __msa_adds_s_b(dst0, offset);
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+
+    dst_val0 = __msa_copy_u_w((v4i32) dst0, 0);
+    dst_val1 = __msa_copy_u_w((v4i32) dst0, 2);
+
+    SW(dst_val0, dst);
+    dst += dst_stride;
+    SW(dst_val1, dst);
+    dst += dst_stride;
 }
 
 static void hevc_sao_edge_filter_135degree_8width_msa(uint8_t *dst,
@@ -1708,23 +2340,24 @@ static void hevc_sao_edge_filter_135degree_8width_msa(uint8_t *dst,
                                                       int32_t height)
 {
     uint8_t *src_orig;
-    int32_t h_cnt;
     uint64_t dst_val0, dst_val1;
-    v8i16 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0 };
+    v16i8 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     v16u8 const1 = (v16u8) __msa_ldi_b(1);
-    v16i8 zero = { 0 };
-    v16i8 src_zero0, src_zero1, dst0, dst1;
+    v16i8 offset, sao_offset = LD_SB(sao_offset_val);
     v16u8 cmp_minus10, diff_minus10, cmp_minus11, diff_minus11;
     v16u8 src_minus10, src10, src_minus11, src11;
-    v8i16 sao_offset, src00, offset_mask0, src01, offset_mask1;
+    v16i8 src_zero0, src_zero1, dst0;
+    v8i16 offset_mask0, offset_mask1;
 
-    sao_offset = LD_SH(sao_offset_val);
+    sao_offset = __msa_pckev_b(sao_offset, sao_offset);
     src_orig = src - 1;
 
+    /* load in advance */
     LD_UB2(src_orig - src_stride, src_stride, src_minus10, src_minus11);
+    LD_UB2(src_orig + src_stride, src_stride, src10, src11);
 
-    for (h_cnt = (height >> 1); h_cnt--;) {
-        LD_UB2(src_orig + src_stride, src_stride, src10, src11);
+    for (height -= 2; height; height -= 2) {
+        src_orig += (src_stride << 1);
 
         SLDI_B2_0_SB(src_minus11, src10, src_zero0, src_zero1, 1);
         SLDI_B2_0_UB(src_minus10, src_minus11, src_minus10, src_minus11, 2);
@@ -1746,30 +2379,68 @@ static void hevc_sao_edge_filter_135degree_8width_msa(uint8_t *dst,
         offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
         offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
 
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask0,
-                   offset_mask0, offset_mask0, offset_mask0);
-        VSHF_H2_SH(edge_idx, edge_idx, sao_offset, sao_offset, offset_mask1,
-                   offset_mask1, offset_mask1, offset_mask1);
-        ILVEV_B2_SH(src_zero0, zero, src_zero1, zero, src00, src01);
-        ADD2(offset_mask0, src00, offset_mask1, src01, offset_mask0,
-             offset_mask1);
-        CLIP_SH2_0_255(offset_mask0, offset_mask1);
-        PCKEV_B2_SB(offset_mask0, offset_mask0, offset_mask1, offset_mask1,
-                    dst0, dst1);
+        offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+        dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
+
+        VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+                   offset, offset);
+
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+        dst0 = __msa_adds_s_b(dst0, offset);
+        dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
 
         src_minus10 = src10;
         src_minus11 = src11;
 
+        /* load in advance */
+        LD_UB2(src_orig + src_stride, src_stride, src10, src11);
+
         dst_val0 = __msa_copy_u_d((v2i64) dst0, 0);
-        dst_val1 = __msa_copy_u_d((v2i64) dst1, 0);
+        dst_val1 = __msa_copy_u_d((v2i64) dst0, 1);
 
         SD(dst_val0, dst);
         dst += dst_stride;
         SD(dst_val1, dst);
         dst += dst_stride;
-
-        src_orig += (src_stride << 1);
     }
+
+    SLDI_B2_0_SB(src_minus11, src10, src_zero0, src_zero1, 1);
+    SLDI_B2_0_UB(src_minus10, src_minus11, src_minus10, src_minus11, 2);
+    ILVR_B2_UB(src10, src_minus10, src11, src_minus11, src_minus10,
+               src_minus11);
+    ILVR_B2_SB(src_zero0, src_zero0, src_zero1, src_zero1, src_zero0,
+               src_zero1);
+
+    cmp_minus10 = ((v16u8) src_zero0 == src_minus10);
+    diff_minus10 = __msa_nor_v(cmp_minus10, cmp_minus10);
+    cmp_minus10 = (src_minus10 < (v16u8) src_zero0);
+    diff_minus10 = __msa_bmnz_v(diff_minus10, const1, cmp_minus10);
+
+    cmp_minus11 = ((v16u8) src_zero1 == src_minus11);
+    diff_minus11 = __msa_nor_v(cmp_minus11, cmp_minus11);
+    cmp_minus11 = (src_minus11 < (v16u8) src_zero1);
+    diff_minus11 = __msa_bmnz_v(diff_minus11, const1, cmp_minus11);
+
+    offset_mask0 = (v8i16) (__msa_hadd_u_h(diff_minus10, diff_minus10) + 2);
+    offset_mask1 = (v8i16) (__msa_hadd_u_h(diff_minus11, diff_minus11) + 2);
+
+    offset = __msa_pckev_b((v16i8) offset_mask1, (v16i8) offset_mask0);
+    dst0 = __msa_pckev_b((v16i8) src_zero1, (v16i8) src_zero0);
+
+    VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset, offset, offset,
+               offset, offset);
+
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+    dst0 = __msa_adds_s_b(dst0, offset);
+    dst0 = (v16i8) __msa_xori_b((v16u8) dst0, 128);
+
+    dst_val0 = __msa_copy_u_d((v2i64) dst0, 0);
+    dst_val1 = __msa_copy_u_d((v2i64) dst0, 1);
+
+    SD(dst_val0, dst);
+    dst += dst_stride;
+    SD(dst_val1, dst);
+    dst += dst_stride;
 }
 
 static void hevc_sao_edge_filter_135degree_16multiple_msa(uint8_t *dst,
@@ -1782,7 +2453,7 @@ static void hevc_sao_edge_filter_135degree_16multiple_msa(uint8_t *dst,
                                                           int32_t height)
 {
     uint8_t *src_orig, *dst_orig;
-    int32_t h_cnt, v_cnt;
+    int32_t v_cnt;
     v16i8 edge_idx = { 1, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     v16u8 const1 = (v16u8) __msa_ldi_b(1);
     v16u8 dst0, dst1, dst2, dst3;
@@ -1793,20 +2464,18 @@ static void hevc_sao_edge_filter_135degree_16multiple_msa(uint8_t *dst,
     v16u8 src_plus10, src_plus11, src_plus12, src_plus13;
     v16i8 src_minus12, src_minus13, src_zero0, src_zero1, src_zero2, src_zero3;
     v16i8 offset_mask0, offset_mask1, offset_mask2, offset_mask3, sao_offset;
-    v8i16 src0, src1, src2, src3, src4, src5, src6, src7;
-    v8i16 temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
 
     sao_offset = LD_SB(sao_offset_val);
     sao_offset = __msa_pckev_b(sao_offset, sao_offset);
 
-    for (h_cnt = (height >> 2); h_cnt--;) {
+    for (; height; height -= 4) {
         src_orig = src - 1;
         dst_orig = dst;
 
-        LD_UB4(src_orig, src_stride,
-               src_minus11, src_plus10, src_plus11, src_plus12);
+        LD_UB4(src_orig, src_stride, src_minus11, src_plus10, src_plus11,
+               src_plus12);
 
-        for (v_cnt = 0; v_cnt < (width >> 4); v_cnt++) {
+        for (v_cnt = 0; v_cnt < width; v_cnt += 16) {
             src_minus10 = LD_UB(src_orig + 2 - src_stride);
             LD_UB4(src_orig + 16, src_stride, src10, src11, src12, src13);
             src_plus13 = LD_UB(src_orig + (src_stride << 2));
@@ -1873,23 +2542,14 @@ static void hevc_sao_edge_filter_135degree_16multiple_msa(uint8_t *dst,
             VSHF_B2_SB(edge_idx, edge_idx, sao_offset, sao_offset,
                        offset_mask3, offset_mask3, offset_mask3, offset_mask3);
 
-            UNPCK_UB_SH(src_zero0, src0, src1);
-            UNPCK_SB_SH(offset_mask0, temp0, temp1);
-            UNPCK_UB_SH(src_zero1, src2, src3);
-            UNPCK_SB_SH(offset_mask1, temp2, temp3);
-            UNPCK_UB_SH(src_zero2, src4, src5);
-            UNPCK_SB_SH(offset_mask2, temp4, temp5);
-            UNPCK_UB_SH(src_zero3, src6, src7);
-            UNPCK_SB_SH(offset_mask3, temp6, temp7);
-
-            ADD4(temp0, src0, temp1, src1, temp2, src2, temp3, src3, temp0,
-                 temp1, temp2, temp3);
-            ADD4(temp4, src4, temp5, src5, temp6, src6, temp7, src7, temp4,
-                 temp5, temp6, temp7);
-            CLIP_SH4_0_255(temp0, temp1, temp2, temp3);
-            CLIP_SH4_0_255(temp4, temp5, temp6, temp7);
-            PCKEV_B4_UB(temp1, temp0, temp3, temp2, temp5, temp4, temp7, temp6,
-                        dst0, dst1, dst2, dst3);
+            XORI_B4_128_SB(src_zero0, src_zero1, src_zero2, src_zero3);
+
+            dst0 = (v16u8) __msa_adds_s_b((v16i8) src_zero0, offset_mask0);
+            dst1 = (v16u8) __msa_adds_s_b((v16i8) src_zero1, offset_mask1);
+            dst2 = (v16u8) __msa_adds_s_b((v16i8) src_zero2, offset_mask2);
+            dst3 = (v16u8) __msa_adds_s_b((v16i8) src_zero3, offset_mask3);
+
+            XORI_B4_128_UB(dst0, dst1, dst2, dst3);
 
             src_minus11 = src10;
             src_plus10 = src11;
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/hevc_macros_msa.h b/mythtv/external/FFmpeg/libavcodec/mips/hevc_macros_msa.h
index b06c5ad9b9d..7dcfea03b41 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/hevc_macros_msa.h
+++ b/mythtv/external/FFmpeg/libavcodec/mips/hevc_macros_msa.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
+ * Copyright (c) 2015 - 2017 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -58,6 +58,17 @@
     out2 = (v4i32) __msa_pckev_b((v16i8) tmp5_m, (v16i8) tmp4_m);  \
 }
 
+#define HEVC_FILT_8TAP_SH(in0, in1, in2, in3,                    \
+                          filt0, filt1, filt2, filt3)            \
+( {                                                              \
+    v8i16 out_m;                                                 \
+                                                                 \
+    out_m = __msa_dotp_s_h((v16i8) in0, (v16i8) filt0);          \
+    out_m = __msa_dpadd_s_h(out_m, (v16i8) in1, (v16i8) filt1);  \
+    DPADD_SB2_SH(in2, in3, filt2, filt3, out_m, out_m);          \
+    out_m;                                                       \
+} )
+
 #define HEVC_FILT_8TAP(in0, in1, in2, in3,                       \
                        filt0, filt1, filt2, filt3)               \
 ( {                                                              \
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/hevc_mc_uni_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/hevc_mc_uni_msa.c
index 754fbdbb413..eead591ff49 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/hevc_mc_uni_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/hevc_mc_uni_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
+ * Copyright (c) 2015 - 2017 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -28,83 +28,39 @@ static void copy_width8_msa(uint8_t *src, int32_t src_stride,
 {
     int32_t cnt;
     uint64_t out0, out1, out2, out3, out4, out5, out6, out7;
-    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
-
-    if (0 == height % 12) {
-        for (cnt = (height / 12); cnt--;) {
-            LD_UB8(src, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src += (8 * src_stride);
-
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
-            out4 = __msa_copy_u_d((v2i64) src4, 0);
-            out5 = __msa_copy_u_d((v2i64) src5, 0);
-            out6 = __msa_copy_u_d((v2i64) src6, 0);
-            out7 = __msa_copy_u_d((v2i64) src7, 0);
-
-            SD4(out0, out1, out2, out3, dst, dst_stride);
-            dst += (4 * dst_stride);
-            SD4(out4, out5, out6, out7, dst, dst_stride);
-            dst += (4 * dst_stride);
 
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
+    if (2 == height) {
+        LD2(src, src_stride, out0, out1);
+        SD(out0, dst);
+        dst += dst_stride;
+        SD(out1, dst);
+    } else if (6 == height) {
+        LD4(src, src_stride, out0, out1, out2, out3);
+        src += (4 * src_stride);
+        SD4(out0, out1, out2, out3, dst, dst_stride);
+        dst += (4 * dst_stride);
+        LD2(src, src_stride, out0, out1);
+        SD(out0, dst);
+        dst += dst_stride;
+        SD(out1, dst);
+    } else if (0 == (height % 8)) {
+        for (cnt = (height >> 3); cnt--;) {
+            LD4(src, src_stride, out0, out1, out2, out3);
+            src += (4 * src_stride);
+            LD4(src, src_stride, out4, out5, out6, out7);
             src += (4 * src_stride);
-
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
-
-            SD4(out0, out1, out2, out3, dst, dst_stride);
-            dst += (4 * dst_stride);
-        }
-    } else if (0 == height % 8) {
-        for (cnt = height >> 3; cnt--;) {
-            LD_UB8(src, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src += (8 * src_stride);
-
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
-            out4 = __msa_copy_u_d((v2i64) src4, 0);
-            out5 = __msa_copy_u_d((v2i64) src5, 0);
-            out6 = __msa_copy_u_d((v2i64) src6, 0);
-            out7 = __msa_copy_u_d((v2i64) src7, 0);
-
             SD4(out0, out1, out2, out3, dst, dst_stride);
             dst += (4 * dst_stride);
             SD4(out4, out5, out6, out7, dst, dst_stride);
             dst += (4 * dst_stride);
         }
-    } else if (0 == height % 4) {
-        for (cnt = (height / 4); cnt--;) {
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
+    } else if (0 == (height % 4)) {
+        for (cnt = (height >> 2); cnt--;) {
+            LD4(src, src_stride, out0, out1, out2, out3);
             src += (4 * src_stride);
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
-
             SD4(out0, out1, out2, out3, dst, dst_stride);
             dst += (4 * dst_stride);
         }
-    } else if (0 == height % 2) {
-        for (cnt = (height / 2); cnt--;) {
-            LD_UB2(src, src_stride, src0, src1);
-            src += (2 * src_stride);
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-
-            SD(out0, dst);
-            dst += dst_stride;
-            SD(out1, dst);
-            dst += dst_stride;
-        }
     }
 }
 
@@ -122,33 +78,6 @@ static void copy_width12_msa(uint8_t *src, int32_t src_stride,
     ST12x8_UB(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
 }
 
-static void copy_16multx8mult_msa(uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
-                                  int32_t height, int32_t width)
-{
-    int32_t cnt, loop_cnt;
-    uint8_t *src_tmp, *dst_tmp;
-    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
-
-    for (cnt = (width >> 4); cnt--;) {
-        src_tmp = src;
-        dst_tmp = dst;
-
-        for (loop_cnt = (height >> 3); loop_cnt--;) {
-            LD_UB8(src_tmp, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src_tmp += (8 * src_stride);
-
-            ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,
-                   dst_tmp, dst_stride);
-            dst_tmp += (8 * dst_stride);
-        }
-
-        src += 16;
-        dst += 16;
-    }
-}
-
 static void copy_width16_msa(uint8_t *src, int32_t src_stride,
                              uint8_t *dst, int32_t dst_stride,
                              int32_t height)
@@ -156,23 +85,25 @@ static void copy_width16_msa(uint8_t *src, int32_t src_stride,
     int32_t cnt;
     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
 
-    if (0 == height % 12) {
-        for (cnt = (height / 12); cnt--;) {
-            LD_UB8(src, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
+    if (12 == height) {
+        LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
+        src += (8 * src_stride);
+        ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
+        dst += (8 * dst_stride);
+        LD_UB4(src, src_stride, src0, src1, src2, src3);
+        src += (4 * src_stride);
+        ST_UB4(src0, src1, src2, src3, dst, dst_stride);
+        dst += (4 * dst_stride);
+    } else if (0 == (height % 8)) {
+        for (cnt = (height >> 3); cnt--;) {
+            LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6,
+                   src7);
             src += (8 * src_stride);
-            ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,
-                   dst, dst_stride);
+            ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst,
+                   dst_stride);
             dst += (8 * dst_stride);
-
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            src += (4 * src_stride);
-            ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-            dst += (4 * dst_stride);
         }
-    } else if (0 == height % 8) {
-        copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 16);
-    } else if (0 == height % 4) {
+    } else if (0 == (height % 4)) {
         for (cnt = (height >> 2); cnt--;) {
             LD_UB4(src, src_stride, src0, src1, src2, src3);
             src += (4 * src_stride);
@@ -187,8 +118,23 @@ static void copy_width24_msa(uint8_t *src, int32_t src_stride,
                              uint8_t *dst, int32_t dst_stride,
                              int32_t height)
 {
-    copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 16);
-    copy_width8_msa(src + 16, src_stride, dst + 16, dst_stride, height);
+    int32_t cnt;
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+    uint64_t out0, out1, out2, out3, out4, out5, out6, out7;
+
+    for (cnt = 4; cnt--;) {
+        LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
+        LD4(src + 16, src_stride, out0, out1, out2, out3);
+        src += (4 * src_stride);
+        LD4(src + 16, src_stride, out4, out5, out6, out7);
+        src += (4 * src_stride);
+
+        ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
+        SD4(out0, out1, out2, out3, dst + 16, dst_stride);
+        dst += (4 * dst_stride);
+        SD4(out4, out5, out6, out7, dst + 16, dst_stride);
+        dst += (4 * dst_stride);
+    }
 }
 
 static void copy_width32_msa(uint8_t *src, int32_t src_stride,
@@ -198,40 +144,13 @@ static void copy_width32_msa(uint8_t *src, int32_t src_stride,
     int32_t cnt;
     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
 
-    if (0 == height % 12) {
-        for (cnt = (height / 12); cnt--;) {
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            LD_UB4(src + 16, src_stride, src4, src5, src6, src7);
-            src += (4 * src_stride);
-            ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-            ST_UB4(src4, src5, src6, src7, dst + 16, dst_stride);
-            dst += (4 * dst_stride);
-
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            LD_UB4(src + 16, src_stride, src4, src5, src6, src7);
-            src += (4 * src_stride);
-            ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-            ST_UB4(src4, src5, src6, src7, dst + 16, dst_stride);
-            dst += (4 * dst_stride);
-
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            LD_UB4(src + 16, src_stride, src4, src5, src6, src7);
-            src += (4 * src_stride);
-            ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-            ST_UB4(src4, src5, src6, src7, dst + 16, dst_stride);
-            dst += (4 * dst_stride);
-        }
-    } else if (0 == height % 8) {
-        copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 32);
-    } else if (0 == height % 4) {
-        for (cnt = (height >> 2); cnt--;) {
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            LD_UB4(src + 16, src_stride, src4, src5, src6, src7);
-            src += (4 * src_stride);
-            ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-            ST_UB4(src4, src5, src6, src7, dst + 16, dst_stride);
-            dst += (4 * dst_stride);
-        }
+    for (cnt = (height >> 2); cnt--;) {
+        LD_UB4(src, src_stride, src0, src1, src2, src3);
+        LD_UB4(src + 16, src_stride, src4, src5, src6, src7);
+        src += (4 * src_stride);
+        ST_UB4(src0, src1, src2, src3, dst, dst_stride);
+        ST_UB4(src4, src5, src6, src7, dst + 16, dst_stride);
+        dst += (4 * dst_stride);
     }
 }
 
@@ -239,14 +158,50 @@ static void copy_width48_msa(uint8_t *src, int32_t src_stride,
                              uint8_t *dst, int32_t dst_stride,
                              int32_t height)
 {
-    copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 48);
+    int32_t cnt;
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
+    v16u8 src11;
+
+    for (cnt = (height >> 2); cnt--;) {
+        LD_UB4(src, src_stride, src0, src1, src2, src3);
+        LD_UB4(src + 16, src_stride, src4, src5, src6, src7);
+        LD_UB4(src + 32, src_stride, src8, src9, src10, src11);
+        src += (4 * src_stride);
+
+        ST_UB4(src0, src1, src2, src3, dst, dst_stride);
+        ST_UB4(src4, src5, src6, src7, dst + 16, dst_stride);
+        ST_UB4(src8, src9, src10, src11, dst + 32, dst_stride);
+        dst += (4 * dst_stride);
+    }
 }
 
 static void copy_width64_msa(uint8_t *src, int32_t src_stride,
                              uint8_t *dst, int32_t dst_stride,
                              int32_t height)
 {
-    copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 64);
+    int32_t cnt;
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16u8 src8, src9, src10, src11, src12, src13, src14, src15;
+
+    for (cnt = (height >> 2); cnt--;) {
+        LD_UB4(src, 16, src0, src1, src2, src3);
+        src += src_stride;
+        LD_UB4(src, 16, src4, src5, src6, src7);
+        src += src_stride;
+        LD_UB4(src, 16, src8, src9, src10, src11);
+        src += src_stride;
+        LD_UB4(src, 16, src12, src13, src14, src15);
+        src += src_stride;
+
+        ST_UB4(src0, src1, src2, src3, dst, 16);
+        dst += dst_stride;
+        ST_UB4(src4, src5, src6, src7, dst, 16);
+        dst += dst_stride;
+        ST_UB4(src8, src9, src10, src11, dst, 16);
+        dst += dst_stride;
+        ST_UB4(src12, src13, src14, src15, dst, 16);
+        dst += dst_stride;
+    }
 }
 
 static const uint8_t mc_filt_mask_arr[16 * 3] = {
@@ -359,16 +314,14 @@ static const uint8_t mc_filt_mask_arr[16 * 3] = {
 
 static void common_hz_8t_4x4_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, uint8_t rnd_val)
+                                 const int8_t *filter)
 {
     v16u8 mask0, mask1, mask2, mask3, out;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
     v8i16 filt, out0, out1;
-    v8i16 rnd_vec;
 
     mask0 = LD_UB(&mc_filt_mask_arr[16]);
     src -= 3;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -382,7 +335,7 @@ static void common_hz_8t_4x4_msa(uint8_t *src, int32_t src_stride,
     XORI_B4_128_SB(src0, src1, src2, src3);
     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                mask3, filt0, filt1, filt2, filt3, out0, out1);
-    SRAR_H2_SH(out0, out1, rnd_vec);
+    SRARI_H2_SH(out0, out1, 6);
     SAT_SH2_SH(out0, out1, 7);
     out = PCKEV_XORI128_UB(out0, out1);
     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
@@ -390,17 +343,15 @@ static void common_hz_8t_4x4_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_8t_4x8_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, uint8_t rnd_val)
+                                 const int8_t *filter)
 {
     v16i8 filt0, filt1, filt2, filt3;
     v16i8 src0, src1, src2, src3;
     v16u8 mask0, mask1, mask2, mask3, out;
     v8i16 filt, out0, out1, out2, out3;
-    v8i16 rnd_vec;
 
     mask0 = LD_UB(&mc_filt_mask_arr[16]);
     src -= 3;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -419,7 +370,7 @@ static void common_hz_8t_4x8_msa(uint8_t *src, int32_t src_stride,
     XORI_B4_128_SB(src0, src1, src2, src3);
     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                mask3, filt0, filt1, filt2, filt3, out2, out3);
-    SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+    SRARI_H4_SH(out0, out1, out2, out3, 6);
     SAT_SH4_SH(out0, out1, out2, out3, 7);
     out = PCKEV_XORI128_UB(out0, out1);
     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
@@ -430,16 +381,14 @@ static void common_hz_8t_4x8_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_8t_4x16_msa(uint8_t *src, int32_t src_stride,
                                   uint8_t *dst, int32_t dst_stride,
-                                  const int8_t *filter, uint8_t rnd_val)
+                                  const int8_t *filter)
 {
     v16u8 mask0, mask1, mask2, mask3, out;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
     v8i16 filt, out0, out1, out2, out3;
-    v8i16 rnd_vec;
 
     mask0 = LD_UB(&mc_filt_mask_arr[16]);
     src -= 3;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -459,7 +408,7 @@ static void common_hz_8t_4x16_msa(uint8_t *src, int32_t src_stride,
     src += (4 * src_stride);
     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                mask3, filt0, filt1, filt2, filt3, out2, out3);
-    SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+    SRARI_H4_SH(out0, out1, out2, out3, 6);
     SAT_SH4_SH(out0, out1, out2, out3, 7);
     out = PCKEV_XORI128_UB(out0, out1);
     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
@@ -479,7 +428,7 @@ static void common_hz_8t_4x16_msa(uint8_t *src, int32_t src_stride,
     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                mask3, filt0, filt1, filt2, filt3, out2, out3);
 
-    SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+    SRARI_H4_SH(out0, out1, out2, out3, 6);
     SAT_SH4_SH(out0, out1, out2, out3, 7);
     out = PCKEV_XORI128_UB(out0, out1);
     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
@@ -490,30 +439,27 @@ static void common_hz_8t_4x16_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_8t_4w_msa(uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
-                                const int8_t *filter, int32_t height, uint8_t rnd_val)
+                                const int8_t *filter, int32_t height)
 {
     if (4 == height) {
-        common_hz_8t_4x4_msa(src, src_stride, dst, dst_stride, filter, rnd_val);
+        common_hz_8t_4x4_msa(src, src_stride, dst, dst_stride, filter);
     } else if (8 == height) {
-        common_hz_8t_4x8_msa(src, src_stride, dst, dst_stride, filter, rnd_val);
+        common_hz_8t_4x8_msa(src, src_stride, dst, dst_stride, filter);
     } else if (16 == height) {
-        common_hz_8t_4x16_msa(src, src_stride, dst, dst_stride, filter,
-                              rnd_val);
+        common_hz_8t_4x16_msa(src, src_stride, dst, dst_stride, filter);
     }
 }
 
 static void common_hz_8t_8x4_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, uint8_t rnd_val)
+                                 const int8_t *filter)
 {
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
     v16u8 mask0, mask1, mask2, mask3, tmp0, tmp1;
     v8i16 filt, out0, out1, out2, out3;
-    v8i16 rnd_vec;
 
     mask0 = LD_UB(&mc_filt_mask_arr[0]);
     src -= 3;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -528,7 +474,7 @@ static void common_hz_8t_8x4_msa(uint8_t *src, int32_t src_stride,
     HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                mask3, filt0, filt1, filt2, filt3, out0, out1,
                                out2, out3);
-    SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+    SRARI_H4_SH(out0, out1, out2, out3, 6);
     SAT_SH4_SH(out0, out1, out2, out3, 7);
     tmp0 = PCKEV_XORI128_UB(out0, out1);
     tmp1 = PCKEV_XORI128_UB(out2, out3);
@@ -537,18 +483,15 @@ static void common_hz_8t_8x4_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_8t_8x8mult_msa(uint8_t *src, int32_t src_stride,
                                      uint8_t *dst, int32_t dst_stride,
-                                     const int8_t *filter, int32_t height,
-                                     uint8_t rnd_val)
+                                     const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
     v16u8 mask0, mask1, mask2, mask3, tmp0, tmp1;
     v8i16 filt, out0, out1, out2, out3;
-    v8i16 rnd_vec;
 
     mask0 = LD_UB(&mc_filt_mask_arr[0]);
     src -= 3;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -565,7 +508,7 @@ static void common_hz_8t_8x8mult_msa(uint8_t *src, int32_t src_stride,
         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                    mask3, filt0, filt1, filt2, filt3, out0,
                                    out1, out2, out3);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         tmp0 = PCKEV_XORI128_UB(out0, out1);
         tmp1 = PCKEV_XORI128_UB(out2, out3);
@@ -576,32 +519,28 @@ static void common_hz_8t_8x8mult_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_8t_8w_msa(uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
-                                const int8_t *filter, int32_t height,
-                                uint8_t rnd_val)
+                                const int8_t *filter, int32_t height)
 {
     if (4 == height) {
-        common_hz_8t_8x4_msa(src, src_stride, dst, dst_stride, filter, rnd_val);
+        common_hz_8t_8x4_msa(src, src_stride, dst, dst_stride, filter);
     } else {
         common_hz_8t_8x8mult_msa(src, src_stride, dst, dst_stride, filter,
-                                 height, rnd_val);
+                                 height);
     }
 }
 
 static void common_hz_8t_12w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint8_t *src1_ptr, *dst1;
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
     v8i16 filt, out0, out1, out2, out3;
     v16u8 mask0, mask1, mask2, mask3, mask4, mask5, mask6, mask00, tmp0, tmp1;
-    v8i16 rnd_vec;
 
     mask00 = LD_UB(&mc_filt_mask_arr[0]);
     mask0 = LD_UB(&mc_filt_mask_arr[16]);
-    rnd_vec = __msa_fill_h(rnd_val);
 
     src1_ptr = src - 3;
     dst1 = dst;
@@ -628,7 +567,7 @@ static void common_hz_8t_12w_msa(uint8_t *src, int32_t src_stride,
         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask00, mask1, mask2,
                                    mask3, filt0, filt1, filt2, filt3, out0,
                                    out1, out2, out3);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         tmp0 = PCKEV_XORI128_UB(out0, out1);
         tmp1 = PCKEV_XORI128_UB(out2, out3);
@@ -642,7 +581,7 @@ static void common_hz_8t_12w_msa(uint8_t *src, int32_t src_stride,
         HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask4, mask5,
                                    mask6, filt0, filt1, filt2, filt3, out0,
                                    out1);
-        SRAR_H2_SH(out0, out1, rnd_vec);
+        SRARI_H2_SH(out0, out1, 6);
         SAT_SH2_SH(out0, out1, 7);
         tmp0 = PCKEV_XORI128_UB(out0, out1);
         ST4x4_UB(tmp0, tmp0, 0, 1, 2, 3, dst, dst_stride);
@@ -652,18 +591,15 @@ static void common_hz_8t_12w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_8t_16w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
     v16u8 mask0, mask1, mask2, mask3, out;
     v8i16 filt, out0, out1, out2, out3;
-    v8i16 rnd_vec;
 
     mask0 = LD_UB(&mc_filt_mask_arr[0]);
     src -= 3;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -681,7 +617,7 @@ static void common_hz_8t_16w_msa(uint8_t *src, int32_t src_stride,
         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                    mask3, filt0, filt1, filt2, filt3, out0,
                                    out1, out2, out3);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         out = PCKEV_XORI128_UB(out0, out1);
         ST_UB(out, dst);
@@ -694,8 +630,7 @@ static void common_hz_8t_16w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_8t_24w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
@@ -704,11 +639,9 @@ static void common_hz_8t_24w_msa(uint8_t *src, int32_t src_stride,
     v16i8 vec11;
     v8i16 out0, out1, out2, out3, out4, out5, out6, out7, out8, out9, out10;
     v8i16 out11, filt;
-    v8i16 rnd_vec;
 
     mask0 = LD_UB(&mc_filt_mask_arr[0]);
     src -= 3;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -754,8 +687,8 @@ static void common_hz_8t_24w_msa(uint8_t *src, int32_t src_stride,
         ADDS_SH4_SH(out0, out4, out8, out10, out2, out6, out9, out11, out0,
                     out8, out2, out9);
         ADDS_SH2_SH(out1, out5, out3, out7, out1, out3);
-        SRAR_H4_SH(out0, out8, out2, out9, rnd_vec);
-        SRAR_H2_SH(out1, out3, rnd_vec);
+        SRARI_H4_SH(out0, out8, out2, out9, 6);
+        SRARI_H2_SH(out1, out3, 6);
         SAT_SH4_SH(out0, out8, out2, out9, 7);
         SAT_SH2_SH(out1, out3, 7);
         out = PCKEV_XORI128_UB(out8, out9);
@@ -771,18 +704,15 @@ static void common_hz_8t_24w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_8t_32w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
     v16u8 mask0, mask1, mask2, mask3, out;
     v8i16 filt, out0, out1, out2, out3;
-    v8i16 rnd_vec;
 
     mask0 = LD_UB(&mc_filt_mask_arr[0]);
     src -= 3;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -802,7 +732,7 @@ static void common_hz_8t_32w_msa(uint8_t *src, int32_t src_stride,
         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                    mask3, filt0, filt1, filt2, filt3, out0,
                                    out1, out2, out3);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
 
         src0 = LD_SB(src);
@@ -821,7 +751,7 @@ static void common_hz_8t_32w_msa(uint8_t *src, int32_t src_stride,
         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                    mask3, filt0, filt1, filt2, filt3, out0,
                                    out1, out2, out3);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         out = PCKEV_XORI128_UB(out0, out1);
         ST_UB(out, dst);
@@ -833,18 +763,15 @@ static void common_hz_8t_32w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_8t_48w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3, vec0, vec1, vec2;
     v16u8 mask0, mask1, mask2, mask3, mask4, mask5, mask6, mask7, out;
     v8i16 filt, out0, out1, out2, out3, out4, out5, out6;
-    v8i16 rnd_vec;
 
     mask0 = LD_UB(&mc_filt_mask_arr[0]);
     src -= 3;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -879,8 +806,8 @@ static void common_hz_8t_48w_msa(uint8_t *src, int32_t src_stride,
         out5 = __msa_dpadd_s_h(out5, vec2, filt3);
         ADDS_SH2_SH(out0, out3, out1, out4, out0, out1);
         out2 = __msa_adds_s_h(out2, out5);
-        SRAR_H2_SH(out0, out1, rnd_vec);
-        out6 = __msa_srar_h(out2, rnd_vec);
+        SRARI_H2_SH(out0, out1, 6);
+        out6 = __msa_srari_h(out2, 6);
         SAT_SH3_SH(out0, out1, out6, 7);
         out = PCKEV_XORI128_UB(out0, out1);
         ST_UB(out, dst);
@@ -905,7 +832,8 @@ static void common_hz_8t_48w_msa(uint8_t *src, int32_t src_stride,
         out5 = __msa_dpadd_s_h(out5, vec2, filt3);
         ADDS_SH2_SH(out0, out3, out1, out4, out3, out4);
         out5 = __msa_adds_s_h(out2, out5);
-        SRAR_H3_SH(out3, out4, out5, rnd_vec);
+        SRARI_H2_SH(out3, out4, 6);
+        out5 = __msa_srari_h(out5, 6);
         SAT_SH3_SH(out3, out4, out5, 7);
         out = PCKEV_XORI128_UB(out6, out3);
         ST_UB(out, dst + 16);
@@ -917,18 +845,15 @@ static void common_hz_8t_48w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_8t_64w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     int32_t loop_cnt;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
     v16u8 mask0, mask1, mask2, mask3, out;
     v8i16 filt, out0, out1, out2, out3;
-    v8i16 rnd_vec;
 
     mask0 = LD_UB(&mc_filt_mask_arr[0]);
     src -= 3;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -948,7 +873,7 @@ static void common_hz_8t_64w_msa(uint8_t *src, int32_t src_stride,
         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1,
                                    mask2, mask3, filt0, filt1, filt2, filt3,
                                    out0, out1, out2, out3);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         out = PCKEV_XORI128_UB(out0, out1);
         ST_UB(out, dst);
@@ -965,7 +890,7 @@ static void common_hz_8t_64w_msa(uint8_t *src, int32_t src_stride,
         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1,
                                    mask2, mask3, filt0, filt1, filt2, filt3,
                                    out0, out1, out2, out3);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         out = PCKEV_XORI128_UB(out0, out1);
         ST_UB(out, dst + 32);
@@ -977,8 +902,7 @@ static void common_hz_8t_64w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_8t_4w_msa(uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
-                                const int8_t *filter, int32_t height,
-                                uint8_t rnd_val)
+                                const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
@@ -987,10 +911,8 @@ static void common_vt_8t_4w_msa(uint8_t *src, int32_t src_stride,
     v16i8 src10998, filt0, filt1, filt2, filt3;
     v16u8 out;
     v8i16 filt, out10, out32;
-    v8i16 rnd_vec;
 
     src -= (3 * src_stride);
-    rnd_vec = __msa_fill_h(rnd_val);
 
     filt = LD_SH(filter);
     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
@@ -1017,7 +939,7 @@ static void common_vt_8t_4w_msa(uint8_t *src, int32_t src_stride,
                                     filt1, filt2, filt3);
         out32 = FILT_8TAP_DPADD_S_H(src4332, src6554, src8776, src10998, filt0,
                                     filt1, filt2, filt3);
-        SRAR_H2_SH(out10, out32, rnd_vec);
+        SRARI_H2_SH(out10, out32, 6);
         SAT_SH2_SH(out10, out32, 7);
         out = PCKEV_XORI128_UB(out10, out32);
         ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
@@ -1032,8 +954,7 @@ static void common_vt_8t_4w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_8t_8w_msa(uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
-                                const int8_t *filter, int32_t height,
-                                uint8_t rnd_val)
+                                const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
@@ -1041,10 +962,8 @@ static void common_vt_8t_8w_msa(uint8_t *src, int32_t src_stride,
     v16i8 src65_r, src87_r, src109_r, filt0, filt1, filt2, filt3;
     v16u8 tmp0, tmp1;
     v8i16 filt, out0_r, out1_r, out2_r, out3_r;
-    v8i16 rnd_vec;
 
     src -= (3 * src_stride);
-    rnd_vec = __msa_fill_h(rnd_val);
 
     filt = LD_SH(filter);
     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
@@ -1071,7 +990,7 @@ static void common_vt_8t_8w_msa(uint8_t *src, int32_t src_stride,
                                      filt1, filt2, filt3);
         out3_r = FILT_8TAP_DPADD_S_H(src43_r, src65_r, src87_r, src109_r, filt0,
                                      filt1, filt2, filt3);
-        SRAR_H4_SH(out0_r, out1_r, out2_r, out3_r, rnd_vec);
+        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 6);
         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
         tmp0 = PCKEV_XORI128_UB(out0_r, out1_r);
         tmp1 = PCKEV_XORI128_UB(out2_r, out3_r);
@@ -1090,8 +1009,7 @@ static void common_vt_8t_8w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_8t_12w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     int32_t loop_cnt;
     uint32_t out2, out3;
@@ -1100,11 +1018,9 @@ static void common_vt_8t_12w_msa(uint8_t *src, int32_t src_stride,
     v16i8 res2, vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
     v8i16 vec01, vec23, vec45, vec67, tmp0, tmp1, tmp2;
     v8i16 filt, filt0, filt1, filt2, filt3;
-    v8i16 rnd_vec;
     v4i32 mask = { 2, 6, 2, 6 };
 
     src -= (3 * src_stride);
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter_y */
     filt = LD_SH(filter);
@@ -1140,7 +1056,8 @@ static void common_vt_8t_12w_msa(uint8_t *src, int32_t src_stride,
                    vec45, vec67);
         tmp2 = FILT_8TAP_DPADD_S_H(vec01, vec23, vec45, vec67, filt0, filt1,
                                    filt2, filt3);
-        SRAR_H3_SH(tmp0, tmp1, tmp2, rnd_vec);
+        SRARI_H2_SH(tmp0, tmp1, 6);
+        tmp2 = __msa_srari_h(tmp2, 6);
         SAT_SH3_SH(tmp0, tmp1, tmp2, 7);
         PCKEV_B3_SB(tmp0, tmp0, tmp1, tmp1, tmp2, tmp2, res0, res1, res2);
         XORI_B3_128_SB(res0, res1, res2);
@@ -1174,8 +1091,7 @@ static void common_vt_8t_12w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_8t_16w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
@@ -1185,10 +1101,8 @@ static void common_vt_8t_16w_msa(uint8_t *src, int32_t src_stride,
     v16i8 src98_l, src21_l, src43_l, src65_l, src87_l, src109_l;
     v16u8 tmp0, tmp1, tmp2, tmp3;
     v8i16 filt, out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
-    v8i16 rnd_vec;
 
     src -= (3 * src_stride);
-    rnd_vec = __msa_fill_h(rnd_val);
 
     filt = LD_SH(filter);
     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
@@ -1228,8 +1142,8 @@ static void common_vt_8t_16w_msa(uint8_t *src, int32_t src_stride,
                                      filt1, filt2, filt3);
         out3_l = FILT_8TAP_DPADD_S_H(src43_l, src65_l, src87_l, src109_l, filt0,
                                      filt1, filt2, filt3);
-        SRAR_H4_SH(out0_r, out1_r, out2_r, out3_r, rnd_vec);
-        SRAR_H4_SH(out0_l, out1_l, out2_l, out3_l, rnd_vec);
+        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 6);
+        SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 6);
         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
         SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
         PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
@@ -1257,7 +1171,7 @@ static void common_vt_8t_16w_msa(uint8_t *src, int32_t src_stride,
 static void common_vt_8t_16w_mult_msa(uint8_t *src, int32_t src_stride,
                                       uint8_t *dst, int32_t dst_stride,
                                       const int8_t *filter, int32_t height,
-                                      uint8_t rnd_val, int32_t width)
+                                      int32_t width)
 {
     uint8_t *src_tmp;
     uint8_t *dst_tmp;
@@ -1269,10 +1183,8 @@ static void common_vt_8t_16w_mult_msa(uint8_t *src, int32_t src_stride,
     v16i8 src98_l, src21_l, src43_l, src65_l, src87_l, src109_l;
     v16u8 tmp0, tmp1, tmp2, tmp3;
     v8i16 filt, out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
-    v8i16 rnd_vec;
 
     src -= (3 * src_stride);
-    rnd_vec = __msa_fill_h(rnd_val);
 
     filt = LD_SH(filter);
     SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
@@ -1315,8 +1227,8 @@ static void common_vt_8t_16w_mult_msa(uint8_t *src, int32_t src_stride,
                                          filt0, filt1, filt2, filt3);
             out3_l = FILT_8TAP_DPADD_S_H(src43_l, src65_l, src87_l, src109_l,
                                          filt0, filt1, filt2, filt3);
-            SRAR_H4_SH(out0_r, out1_r, out2_r, out3_r, rnd_vec);
-            SRAR_H4_SH(out0_l, out1_l, out2_l, out3_l, rnd_vec);
+            SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 6);
+            SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 6);
             SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
             SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
             PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
@@ -1347,37 +1259,37 @@ static void common_vt_8t_16w_mult_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_8t_24w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height, uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     common_vt_8t_16w_mult_msa(src, src_stride, dst, dst_stride, filter, height,
-                              rnd_val, 16);
+                              16);
 
     common_vt_8t_8w_msa(src + 16, src_stride, dst + 16, dst_stride, filter,
-                        height, rnd_val);
+                        height);
 }
 
 static void common_vt_8t_32w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height, uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     common_vt_8t_16w_mult_msa(src, src_stride, dst, dst_stride, filter, height,
-                              rnd_val, 32);
+                              32);
 }
 
 static void common_vt_8t_48w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height, uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     common_vt_8t_16w_mult_msa(src, src_stride, dst, dst_stride, filter, height,
-                              rnd_val, 48);
+                              48);
 }
 
 static void common_vt_8t_64w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height, uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     common_vt_8t_16w_mult_msa(src, src_stride, dst, dst_stride, filter, height,
-                              rnd_val, 64);
+                              64);
 }
 
 static void hevc_hv_uni_8t_4w_msa(uint8_t *src,
@@ -1736,16 +1648,14 @@ static void hevc_hv_uni_8t_64w_msa(uint8_t *src,
 
 static void common_hz_4t_4x2_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, uint8_t rnd_val)
+                                 const int8_t *filter)
 {
     v16i8 filt0, filt1, src0, src1, mask0, mask1, vec0, vec1;
     v16u8 out;
     v8i16 filt, res0;
-    v8i16 rnd_vec;
 
     mask0 = LD_SB(&mc_filt_mask_arr[16]);
     src -= 1;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -1757,7 +1667,7 @@ static void common_hz_4t_4x2_msa(uint8_t *src, int32_t src_stride,
     XORI_B2_128_SB(src0, src1);
     VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
     res0 = FILT_4TAP_DPADD_S_H(vec0, vec1, filt0, filt1);
-    res0 = __msa_srar_h(res0, rnd_vec);
+    res0 = __msa_srari_h(res0, 6);
     res0 = __msa_sat_s_h(res0, 7);
     out = PCKEV_XORI128_UB(res0, res0);
     ST4x2_UB(out, dst, dst_stride);
@@ -1765,16 +1675,14 @@ static void common_hz_4t_4x2_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_4t_4x4_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, uint8_t rnd_val)
+                                 const int8_t *filter)
 {
     v16i8 src0, src1, src2, src3, filt0, filt1, mask0, mask1;
     v8i16 filt, out0, out1;
     v16u8 out;
-    v8i16 rnd_vec;
 
     mask0 = LD_SB(&mc_filt_mask_arr[16]);
     src -= 1;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -1786,7 +1694,7 @@ static void common_hz_4t_4x4_msa(uint8_t *src, int32_t src_stride,
     XORI_B4_128_SB(src0, src1, src2, src3);
     HORIZ_4TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1,
                                filt0, filt1, out0, out1);
-    SRAR_H2_SH(out0, out1, rnd_vec);
+    SRARI_H2_SH(out0, out1, 6);
     SAT_SH2_SH(out0, out1, 7);
     out = PCKEV_XORI128_UB(out0, out1);
     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
@@ -1794,16 +1702,14 @@ static void common_hz_4t_4x4_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_4t_4x8_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, uint8_t rnd_val)
+                                 const int8_t *filter)
 {
     v16i8 src0, src1, src2, src3, filt0, filt1, mask0, mask1;
     v16u8 out;
     v8i16 filt, out0, out1, out2, out3;
-    v8i16 rnd_vec;
 
     mask0 = LD_SB(&mc_filt_mask_arr[16]);
     src -= 1;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -1821,7 +1727,7 @@ static void common_hz_4t_4x8_msa(uint8_t *src, int32_t src_stride,
     XORI_B4_128_SB(src0, src1, src2, src3);
     HORIZ_4TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1,
                                filt0, filt1, out2, out3);
-    SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+    SRARI_H4_SH(out0, out1, out2, out3, 6);
     SAT_SH4_SH(out0, out1, out2, out3, 7);
     out = PCKEV_XORI128_UB(out0, out1);
     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
@@ -1832,17 +1738,15 @@ static void common_hz_4t_4x8_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_4t_4x16_msa(uint8_t *src, int32_t src_stride,
                                   uint8_t *dst, int32_t dst_stride,
-                                  const int8_t *filter, uint8_t rnd_val)
+                                  const int8_t *filter)
 {
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
     v16i8 filt0, filt1, mask0, mask1;
     v16u8 out;
     v8i16 filt, out0, out1, out2, out3;
-    v8i16 rnd_vec;
 
     mask0 = LD_SB(&mc_filt_mask_arr[16]);
     src -= 1;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -1857,7 +1761,7 @@ static void common_hz_4t_4x16_msa(uint8_t *src, int32_t src_stride,
                                filt0, filt1, out0, out1);
     HORIZ_4TAP_4WID_4VECS_FILT(src4, src5, src6, src7, mask0, mask1,
                                filt0, filt1, out2, out3);
-    SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+    SRARI_H4_SH(out0, out1, out2, out3, 6);
     SAT_SH4_SH(out0, out1, out2, out3, 7);
     out = PCKEV_XORI128_UB(out0, out1);
     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
@@ -1873,7 +1777,7 @@ static void common_hz_4t_4x16_msa(uint8_t *src, int32_t src_stride,
                                filt0, filt1, out0, out1);
     HORIZ_4TAP_4WID_4VECS_FILT(src4, src5, src6, src7, mask0, mask1,
                                filt0, filt1, out2, out3);
-    SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+    SRARI_H4_SH(out0, out1, out2, out3, 6);
     SAT_SH4_SH(out0, out1, out2, out3, 7);
     out = PCKEV_XORI128_UB(out0, out1);
     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
@@ -1884,35 +1788,30 @@ static void common_hz_4t_4x16_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_4t_4w_msa(uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
-                                const int8_t *filter, int32_t height,
-                                uint8_t rnd_val)
+                                const int8_t *filter, int32_t height)
 {
     if (2 == height) {
-        common_hz_4t_4x2_msa(src, src_stride, dst, dst_stride, filter, rnd_val);
+        common_hz_4t_4x2_msa(src, src_stride, dst, dst_stride, filter);
     } else if (4 == height) {
-        common_hz_4t_4x4_msa(src, src_stride, dst, dst_stride, filter, rnd_val);
+        common_hz_4t_4x4_msa(src, src_stride, dst, dst_stride, filter);
     } else if (8 == height) {
-        common_hz_4t_4x8_msa(src, src_stride, dst, dst_stride, filter, rnd_val);
+        common_hz_4t_4x8_msa(src, src_stride, dst, dst_stride, filter);
     } else if (16 == height) {
-        common_hz_4t_4x16_msa(src, src_stride, dst, dst_stride, filter,
-                              rnd_val);
+        common_hz_4t_4x16_msa(src, src_stride, dst, dst_stride, filter);
     }
 }
 
 static void common_hz_4t_6w_msa(uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
-                                const int8_t *filter, int32_t height,
-                                uint8_t rnd_val)
+                                const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, filt0, filt1, mask0, mask1;
     v16u8 out4, out5;
     v8i16 filt, out0, out1, out2, out3;
-    v8i16 rnd_vec;
 
     mask0 = LD_SB(&mc_filt_mask_arr[0]);
     src -= 1;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -1927,7 +1826,7 @@ static void common_hz_4t_6w_msa(uint8_t *src, int32_t src_stride,
         XORI_B4_128_SB(src0, src1, src2, src3);
         HORIZ_4TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, filt0,
                                    filt1, out0, out1, out2, out3);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
 
         out4 = PCKEV_XORI128_UB(out0, out1);
@@ -1939,18 +1838,15 @@ static void common_hz_4t_6w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_4t_8x2mult_msa(uint8_t *src, int32_t src_stride,
                                      uint8_t *dst, int32_t dst_stride,
-                                     const int8_t *filter, int32_t height,
-                                     uint8_t rnd_val)
+                                     const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, filt0, filt1, mask0, mask1;
     v16u8 out;
     v8i16 filt, vec0, vec1, vec2, vec3;
-    v8i16 rnd_vec;
 
     mask0 = LD_SB(&mc_filt_mask_arr[0]);
     src -= 1;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     filt = LD_SH(filter);
     SPLATI_H2_SB(filt, 0, 1, filt0, filt1);
@@ -1966,7 +1862,7 @@ static void common_hz_4t_8x2mult_msa(uint8_t *src, int32_t src_stride,
         DOTP_SB2_SH(vec0, vec1, filt0, filt0, vec0, vec1);
         VSHF_B2_SH(src0, src0, src1, src1, mask1, mask1, vec2, vec3);
         DPADD_SB2_SH(vec2, vec3, filt1, filt1, vec0, vec1);
-        SRAR_H2_SH(vec0, vec1, rnd_vec);
+        SRARI_H2_SH(vec0, vec1, 6);
         SAT_SH2_SH(vec0, vec1, 7);
         out = PCKEV_XORI128_UB(vec0, vec1);
         ST8x2_UB(out, dst, dst_stride);
@@ -1976,18 +1872,15 @@ static void common_hz_4t_8x2mult_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_4t_8x4mult_msa(uint8_t *src, int32_t src_stride,
                                      uint8_t *dst, int32_t dst_stride,
-                                     const int8_t *filter, int32_t height,
-                                     uint8_t rnd_val)
+                                     const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, filt0, filt1, mask0, mask1;
     v16u8 tmp0, tmp1;
     v8i16 filt, out0, out1, out2, out3;
-    v8i16 rnd_vec;
 
     mask0 = LD_SB(&mc_filt_mask_arr[0]);
     src -= 1;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -2002,7 +1895,7 @@ static void common_hz_4t_8x4mult_msa(uint8_t *src, int32_t src_stride,
         XORI_B4_128_SB(src0, src1, src2, src3);
         HORIZ_4TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, filt0,
                                    filt1, out0, out1, out2, out3);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         tmp0 = PCKEV_XORI128_UB(out0, out1);
         tmp1 = PCKEV_XORI128_UB(out2, out3);
@@ -2013,22 +1906,20 @@ static void common_hz_4t_8x4mult_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_4t_8w_msa(uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
-                                const int8_t *filter, int32_t height,
-                                uint8_t rnd_val)
+                                const int8_t *filter, int32_t height)
 {
     if ((2 == height) || (6 == height)) {
         common_hz_4t_8x2mult_msa(src, src_stride, dst, dst_stride, filter,
-                                 height, rnd_val);
+                                 height);
     } else {
         common_hz_4t_8x4mult_msa(src, src_stride, dst, dst_stride, filter,
-                                 height, rnd_val);
+                                 height);
     }
 }
 
 static void common_hz_4t_12w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, filt0, filt1, mask0, mask1, mask2, mask3;
@@ -2036,7 +1927,6 @@ static void common_hz_4t_12w_msa(uint8_t *src, int32_t src_stride,
     v16i8 vec10, vec11;
     v16u8 tmp0, tmp1;
     v8i16 filt, out0, out1, out2, out3, out4, out5;
-    v8i16 rnd_vec;
 
     mask0 = LD_SB(&mc_filt_mask_arr[0]);
     mask2 = LD_SB(&mc_filt_mask_arr[32]);
@@ -2050,8 +1940,6 @@ static void common_hz_4t_12w_msa(uint8_t *src, int32_t src_stride,
     mask1 = mask0 + 2;
     mask3 = mask2 + 2;
 
-    rnd_vec = __msa_fill_h(rnd_val);
-
     for (loop_cnt = (height >> 2); loop_cnt--;) {
         LD_SB4(src, src_stride, src0, src1, src2, src3);
         src += (4 * src_stride);
@@ -2069,8 +1957,8 @@ static void common_hz_4t_12w_msa(uint8_t *src, int32_t src_stride,
         DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt1, filt1, filt1, filt1,
                      out2, out3, out4, out5);
         DPADD_SB2_SH(vec2, vec3, filt1, filt1, out0, out1);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
-        SRAR_H2_SH(out4, out5, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
+        SRARI_H2_SH(out4, out5, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         SAT_SH2_SH(out4, out5, 7);
         tmp0 = PCKEV_XORI128_UB(out2, out3);
@@ -2084,19 +1972,16 @@ static void common_hz_4t_12w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_4t_16w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
     v16i8 filt0, filt1, mask0, mask1;
     v8i16 filt, out0, out1, out2, out3, out4, out5, out6, out7;
     v16u8 out;
-    v8i16 rnd_vec;
 
     mask0 = LD_SB(&mc_filt_mask_arr[0]);
     src -= 1;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -2114,8 +1999,8 @@ static void common_hz_4t_16w_msa(uint8_t *src, int32_t src_stride,
                                    filt1, out0, out1, out2, out3);
         HORIZ_4TAP_8WID_4VECS_FILT(src4, src5, src6, src7, mask0, mask1, filt0,
                                    filt1, out4, out5, out6, out7);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
-        SRAR_H4_SH(out4, out5, out6, out7, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
+        SRARI_H4_SH(out4, out5, out6, out7, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         SAT_SH4_SH(out4, out5, out6, out7, 7);
         out = PCKEV_XORI128_UB(out0, out1);
@@ -2135,8 +2020,7 @@ static void common_hz_4t_16w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_4t_24w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint8_t *dst1 = dst + 16;
     uint32_t loop_cnt;
@@ -2145,11 +2029,9 @@ static void common_hz_4t_24w_msa(uint8_t *src, int32_t src_stride,
     v16i8 filt0, filt1, mask0, mask1, mask00, mask11;
     v8i16 filt, out0, out1, out2, out3;
     v16u8 tmp0, tmp1;
-    v8i16 rnd_vec;
 
     mask0 = LD_SB(&mc_filt_mask_arr[0]);
     src -= 1;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -2173,7 +2055,7 @@ static void common_hz_4t_24w_msa(uint8_t *src, int32_t src_stride,
                     out0, out1, out2, out3);
         DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt1, filt1, filt1, filt1,
                      out0, out1, out2, out3);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         tmp0 = PCKEV_XORI128_UB(out0, out1);
         ST_UB(tmp0, dst);
@@ -2190,7 +2072,7 @@ static void common_hz_4t_24w_msa(uint8_t *src, int32_t src_stride,
                     out0, out1, out2, out3);
         DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt1, filt1, filt1, filt1,
                      out0, out1, out2, out3);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         tmp0 = PCKEV_XORI128_UB(out0, out1);
         ST_UB(tmp0, dst);
@@ -2210,7 +2092,7 @@ static void common_hz_4t_24w_msa(uint8_t *src, int32_t src_stride,
         DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt1, filt1, filt1, filt1,
                      out0, out1, out2, out3);
 
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         tmp0 = PCKEV_XORI128_UB(out0, out1);
         tmp1 = PCKEV_XORI128_UB(out2, out3);
@@ -2221,19 +2103,16 @@ static void common_hz_4t_24w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_hz_4t_32w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
     v16i8 filt0, filt1, mask0, mask1;
     v16u8 out;
     v8i16 filt, out0, out1, out2, out3, out4, out5, out6, out7;
-    v8i16 rnd_vec;
 
     mask0 = LD_SB(&mc_filt_mask_arr[0]);
     src -= 1;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter */
     filt = LD_SH(filter);
@@ -2257,8 +2136,8 @@ static void common_hz_4t_32w_msa(uint8_t *src, int32_t src_stride,
                                    filt0, filt1, out0, out1, out2, out3);
         HORIZ_4TAP_8WID_4VECS_FILT(src4, src5, src6, src7, mask0, mask1,
                                    filt0, filt1, out4, out5, out6, out7);
-        SRAR_H4_SH(out0, out1, out2, out3, rnd_vec);
-        SRAR_H4_SH(out4, out5, out6, out7, rnd_vec);
+        SRARI_H4_SH(out0, out1, out2, out3, 6);
+        SRARI_H4_SH(out4, out5, out6, out7, 6);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
         SAT_SH4_SH(out4, out5, out6, out7, 7);
         out = PCKEV_XORI128_UB(out0, out1);
@@ -2276,16 +2155,14 @@ static void common_hz_4t_32w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_4t_4x2_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, uint8_t rnd_val)
+                                 const int8_t *filter)
 {
     v16i8 src0, src1, src2, src3, src4, src10_r, src32_r, src21_r, src43_r;
     v16i8 src2110, src4332, filt0, filt1;
     v16u8 out;
     v8i16 filt, out10;
-    v8i16 rnd_vec;
 
     src -= src_stride;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     filt = LD_SH(filter);
     SPLATI_H2_SB(filt, 0, 1, filt0, filt1);
@@ -2301,7 +2178,7 @@ static void common_vt_4t_4x2_msa(uint8_t *src, int32_t src_stride,
     src4332 = (v16i8) __msa_ilvr_d((v2i64) src43_r, (v2i64) src32_r);
     src4332 = (v16i8) __msa_xori_b((v16u8) src4332, 128);
     out10 = FILT_4TAP_DPADD_S_H(src2110, src4332, filt0, filt1);
-    out10 = __msa_srar_h(out10, rnd_vec);
+    out10 = __msa_srari_h(out10, 6);
     out10 = __msa_sat_s_h(out10, 7);
     out = PCKEV_XORI128_UB(out10, out10);
     ST4x2_UB(out, dst, dst_stride);
@@ -2309,8 +2186,7 @@ static void common_vt_4t_4x2_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_4t_4x4multiple_msa(uint8_t *src, int32_t src_stride,
                                          uint8_t *dst, int32_t dst_stride,
-                                         const int8_t *filter, int32_t height,
-                                         uint8_t rnd_val)
+                                         const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, src4, src5;
@@ -2318,10 +2194,8 @@ static void common_vt_4t_4x4multiple_msa(uint8_t *src, int32_t src_stride,
     v16i8 src2110, src4332, filt0, filt1;
     v8i16 filt, out10, out32;
     v16u8 out;
-    v8i16 rnd_vec;
 
     src -= src_stride;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     filt = LD_SH(filter);
     SPLATI_H2_SB(filt, 0, 1, filt0, filt1);
@@ -2348,7 +2222,7 @@ static void common_vt_4t_4x4multiple_msa(uint8_t *src, int32_t src_stride,
         src2110 = (v16i8) __msa_ilvr_d((v2i64) src65_r, (v2i64) src54_r);
         src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
         out32 = FILT_4TAP_DPADD_S_H(src4332, src2110, filt0, filt1);
-        SRAR_H2_SH(out10, out32, rnd_vec);
+        SRARI_H2_SH(out10, out32, 6);
         SAT_SH2_SH(out10, out32, 7);
         out = PCKEV_XORI128_UB(out10, out32);
         ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
@@ -2358,30 +2232,26 @@ static void common_vt_4t_4x4multiple_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_4t_4w_msa(uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
-                                const int8_t *filter, int32_t height,
-                                uint8_t rnd_val)
+                                const int8_t *filter, int32_t height)
 {
     if (2 == height) {
-        common_vt_4t_4x2_msa(src, src_stride, dst, dst_stride, filter, rnd_val);
+        common_vt_4t_4x2_msa(src, src_stride, dst, dst_stride, filter);
     } else {
         common_vt_4t_4x4multiple_msa(src, src_stride, dst, dst_stride, filter,
-                                     height, rnd_val);
+                                     height);
     }
 }
 
 static void common_vt_4t_6w_msa(uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
-                                const int8_t *filter, int32_t height,
-                                uint8_t rnd_val)
+                                const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16u8 src0, src1, src2, src3, vec0, vec1, vec2, vec3, out0, out1;
     v8i16 vec01, vec12, vec23, vec30, tmp0, tmp1, tmp2, tmp3;
     v8i16 filt, filt0, filt1;
-    v8i16 rnd_vec;
 
     src -= src_stride;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter_y */
     filt = LD_SH(filter);
@@ -2414,7 +2284,7 @@ static void common_vt_4t_6w_msa(uint8_t *src, int32_t src_stride,
         vec12 = (v8i16) __msa_ilvr_b((v16i8) vec2, (v16i8) vec1);
         tmp3 = FILT_4TAP_DPADD_S_H(vec30, vec12, filt0, filt1);
 
-        SRAR_H4_SH(tmp0, tmp1, tmp2, tmp3, rnd_vec);
+        SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 6);
         SAT_SH4_SH(tmp0, tmp1, tmp2, tmp3, 7);
         out0 = PCKEV_XORI128_UB(tmp0, tmp1);
         out1 = PCKEV_XORI128_UB(tmp2, tmp3);
@@ -2425,15 +2295,13 @@ static void common_vt_4t_6w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_4t_8x2_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, uint8_t rnd_val)
+                                 const int8_t *filter)
 {
     v16i8 src0, src1, src2, src3, src4;
     v8i16 src01, src12, src23, src34, tmp0, tmp1, filt, filt0, filt1;
     v16u8 out;
-    v8i16 rnd_vec;
 
     src -= src_stride;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter_y */
     filt = LD_SH(filter);
@@ -2445,7 +2313,7 @@ static void common_vt_4t_8x2_msa(uint8_t *src, int32_t src_stride,
     tmp0 = FILT_4TAP_DPADD_S_H(src01, src23, filt0, filt1);
     ILVR_B2_SH(src2, src1, src4, src3, src12, src34);
     tmp1 = FILT_4TAP_DPADD_S_H(src12, src34, filt0, filt1);
-    SRAR_H2_SH(tmp0, tmp1, rnd_vec);
+    SRARI_H2_SH(tmp0, tmp1, 6);
     SAT_SH2_SH(tmp0, tmp1, 7);
     out = PCKEV_XORI128_UB(tmp0, tmp1);
     ST8x2_UB(out, dst, dst_stride);
@@ -2453,17 +2321,15 @@ static void common_vt_4t_8x2_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_4t_8x6_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, uint8_t rnd_val)
+                                 const int8_t *filter)
 {
     uint32_t loop_cnt;
     uint64_t out0, out1, out2;
     v16i8 src0, src1, src2, src3, src4, src5;
     v8i16 vec0, vec1, vec2, vec3, vec4, tmp0, tmp1, tmp2;
     v8i16 filt, filt0, filt1;
-    v8i16 rnd_vec;
 
     src -= src_stride;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     /* rearranging filter_y */
     filt = LD_SH(filter);
@@ -2484,7 +2350,8 @@ static void common_vt_4t_8x6_msa(uint8_t *src, int32_t src_stride,
         tmp0 = FILT_4TAP_DPADD_S_H(vec0, vec1, filt0, filt1);
         tmp1 = FILT_4TAP_DPADD_S_H(vec2, vec3, filt0, filt1);
         tmp2 = FILT_4TAP_DPADD_S_H(vec1, vec4, filt0, filt1);
-        SRAR_H3_SH(tmp0, tmp1, tmp2, rnd_vec);
+        SRARI_H2_SH(tmp0, tmp1, 6);
+        tmp2 = __msa_srari_h(tmp2, 6);
         SAT_SH3_SH(tmp0, tmp1, tmp2, 7);
         PCKEV_B2_SH(tmp1, tmp0, tmp2, tmp2, tmp0, tmp2);
         XORI_B2_128_SH(tmp0, tmp2);
@@ -2507,18 +2374,15 @@ static void common_vt_4t_8x6_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_4t_8x4mult_msa(uint8_t *src, int32_t src_stride,
                                      uint8_t *dst, int32_t dst_stride,
-                                     const int8_t *filter, int32_t height,
-                                     uint8_t rnd_val)
+                                     const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src7, src8, src9, src10;
     v16i8 src10_r, src72_r, src98_r, src21_r, src87_r, src109_r, filt0, filt1;
     v16u8 tmp0, tmp1;
     v8i16 filt, out0_r, out1_r, out2_r, out3_r;
-    v8i16 rnd_vec;
 
     src -= src_stride;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     filt = LD_SH(filter);
     SPLATI_H2_SB(filt, 0, 1, filt0, filt1);
@@ -2540,7 +2404,7 @@ static void common_vt_4t_8x4mult_msa(uint8_t *src, int32_t src_stride,
         out1_r = FILT_4TAP_DPADD_S_H(src21_r, src87_r, filt0, filt1);
         out2_r = FILT_4TAP_DPADD_S_H(src72_r, src98_r, filt0, filt1);
         out3_r = FILT_4TAP_DPADD_S_H(src87_r, src109_r, filt0, filt1);
-        SRAR_H4_SH(out0_r, out1_r, out2_r, out3_r, rnd_vec);
+        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 6);
         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
         tmp0 = PCKEV_XORI128_UB(out0_r, out1_r);
         tmp1 = PCKEV_XORI128_UB(out2_r, out3_r);
@@ -2555,23 +2419,21 @@ static void common_vt_4t_8x4mult_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_4t_8w_msa(uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
-                                const int8_t *filter, int32_t height,
-                                uint8_t rnd_val)
+                                const int8_t *filter, int32_t height)
 {
     if (2 == height) {
-        common_vt_4t_8x2_msa(src, src_stride, dst, dst_stride, filter, rnd_val);
+        common_vt_4t_8x2_msa(src, src_stride, dst, dst_stride, filter);
     } else if (6 == height) {
-        common_vt_4t_8x6_msa(src, src_stride, dst, dst_stride, filter, rnd_val);
+        common_vt_4t_8x6_msa(src, src_stride, dst, dst_stride, filter);
     } else {
         common_vt_4t_8x4mult_msa(src, src_stride, dst, dst_stride,
-                                 filter, height, rnd_val);
+                                 filter, height);
     }
 }
 
 static void common_vt_4t_12w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, src4, src5, src6;
@@ -2580,14 +2442,11 @@ static void common_vt_4t_12w_msa(uint8_t *src, int32_t src_stride,
     v8i16 src10, src21, src32, src43, src54, src65, src87, src109, src1211;
     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, filt, filt0, filt1;
     v4u32 mask = { 2, 6, 2, 6 };
-    v8i16 rnd_vec;
 
     /* rearranging filter_y */
     filt = LD_SH(filter);
     SPLATI_H2_SH(filt, 0, 1, filt0, filt1);
 
-    rnd_vec = __msa_fill_h(rnd_val);
-
     src -= src_stride;
 
     LD_SB3(src, src_stride, src0, src1, src2);
@@ -2613,8 +2472,8 @@ static void common_vt_4t_12w_msa(uint8_t *src, int32_t src_stride,
         ILVR_B3_SH(vec1, vec0, vec3, vec2, vec5, vec4, src87, src109, src1211);
         tmp4 = FILT_4TAP_DPADD_S_H(src87, src109, filt0, filt1);
         tmp5 = FILT_4TAP_DPADD_S_H(src109, src1211, filt0, filt1);
-        SRAR_H4_SH(tmp0, tmp1, tmp2, tmp3, rnd_vec);
-        SRAR_H2_SH(tmp4, tmp5, rnd_vec);
+        SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 6);
+        SRARI_H2_SH(tmp4, tmp5, 6);
         SAT_SH4_SH(tmp0, tmp1, tmp2, tmp3, 7);
         SAT_SH2_SH(tmp4, tmp5, 7);
         out0 = PCKEV_XORI128_UB(tmp0, tmp1);
@@ -2635,8 +2494,7 @@ static void common_vt_4t_12w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_4t_16w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     v16i8 src0, src1, src2, src3, src4, src5, src6;
@@ -2644,10 +2502,8 @@ static void common_vt_4t_16w_msa(uint8_t *src, int32_t src_stride,
     v16i8 src32_l, src54_l, src21_l, src43_l, src65_l, filt0, filt1;
     v16u8 tmp0, tmp1, tmp2, tmp3;
     v8i16 filt, out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
-    v8i16 rnd_vec;
 
     src -= src_stride;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     filt = LD_SH(filter);
     SPLATI_H2_SB(filt, 0, 1, filt0, filt1);
@@ -2676,8 +2532,8 @@ static void common_vt_4t_16w_msa(uint8_t *src, int32_t src_stride,
         out1_l = FILT_4TAP_DPADD_S_H(src21_l, src43_l, filt0, filt1);
         out2_l = FILT_4TAP_DPADD_S_H(src32_l, src54_l, filt0, filt1);
         out3_l = FILT_4TAP_DPADD_S_H(src43_l, src65_l, filt0, filt1);
-        SRAR_H4_SH(out0_r, out1_r, out2_r, out3_r, rnd_vec);
-        SRAR_H4_SH(out0_l, out1_l, out2_l, out3_l, rnd_vec);
+        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 6);
+        SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 6);
         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
         SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
         PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
@@ -2696,8 +2552,7 @@ static void common_vt_4t_16w_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_4t_24w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     uint32_t loop_cnt;
     uint64_t out0, out1;
@@ -2707,15 +2562,12 @@ static void common_vt_4t_24w_msa(uint8_t *src, int32_t src_stride,
     v16i8 src109_r, src10_l, src32_l, src21_l, src43_l;
     v16u8 out;
     v8i16 filt, out0_r, out1_r, out2_r, out3_r, out0_l, out1_l;
-    v8i16 rnd_vec;
 
     src -= src_stride;
 
     filt = LD_SH(filter);
     SPLATI_H2_SB(filt, 0, 1, filt0, filt1);
 
-    rnd_vec = __msa_fill_h(rnd_val);
-
     /* 16 width */
     LD_SB3(src, src_stride, src0, src1, src2);
     XORI_B3_128_SB(src0, src1, src2);
@@ -2752,8 +2604,8 @@ static void common_vt_4t_24w_msa(uint8_t *src, int32_t src_stride,
         out3_r = FILT_4TAP_DPADD_S_H(src87_r, src109_r, filt0, filt1);
 
         /* 16 + 8 width */
-        SRAR_H4_SH(out0_r, out1_r, out2_r, out3_r, rnd_vec);
-        SRAR_H2_SH(out0_l, out1_l, rnd_vec);
+        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 6);
+        SRARI_H2_SH(out0_l, out1_l, 6);
         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
         SAT_SH2_SH(out0_l, out1_l, 7);
         out = PCKEV_XORI128_UB(out0_r, out0_l);
@@ -2792,8 +2644,8 @@ static void common_vt_4t_24w_msa(uint8_t *src, int32_t src_stride,
         out3_r = FILT_4TAP_DPADD_S_H(src109_r, src87_r, filt0, filt1);
 
         /* 16 + 8 width */
-        SRAR_H4_SH(out0_r, out1_r, out2_r, out3_r, rnd_vec);
-        SRAR_H2_SH(out0_l, out1_l, rnd_vec);
+        SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 6);
+        SRARI_H2_SH(out0_l, out1_l, 6);
         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
         SAT_SH2_SH(out0_l, out1_l, 7);
         out = PCKEV_XORI128_UB(out0_r, out0_l);
@@ -2812,7 +2664,7 @@ static void common_vt_4t_24w_msa(uint8_t *src, int32_t src_stride,
 static void common_vt_4t_32w_mult_msa(uint8_t *src, int32_t src_stride,
                                       uint8_t *dst, int32_t dst_stride,
                                       const int8_t *filter, int32_t height,
-                                      uint8_t rnd_val, int32_t width)
+                                      int32_t width)
 {
     uint32_t loop_cnt, cnt;
     uint8_t *dst_tmp, *src_tmp;
@@ -2824,11 +2676,9 @@ static void common_vt_4t_32w_mult_msa(uint8_t *src, int32_t src_stride,
     v16i8 src21_l, src43_l, src87_l, src109_l;
     v8i16 filt;
     v16i8 filt0, filt1;
-    v8i16 rnd_vec;
     v16u8 out;
 
     src -= src_stride;
-    rnd_vec = __msa_fill_h(rnd_val);
 
     filt = LD_SH(filter);
     SPLATI_H2_SB(filt, 0, 1, filt0, filt1);
@@ -2866,7 +2716,7 @@ static void common_vt_4t_32w_mult_msa(uint8_t *src, int32_t src_stride,
             out1_l = FILT_4TAP_DPADD_S_H(src21_l, src43_l, filt0, filt1);
 
             /* 16 width */
-            SRAR_H4_SH(out0_r, out1_r, out0_l, out1_l, rnd_vec);
+            SRARI_H4_SH(out0_r, out1_r, out0_l, out1_l, 6);
             SAT_SH4_SH(out0_r, out1_r, out0_l, out1_l, 7);
             out = PCKEV_XORI128_UB(out0_r, out0_l);
             ST_UB(out, dst_tmp);
@@ -2893,7 +2743,7 @@ static void common_vt_4t_32w_mult_msa(uint8_t *src, int32_t src_stride,
             out3_l = FILT_4TAP_DPADD_S_H(src87_l, src109_l, filt0, filt1);
 
             /* next 16 width */
-            SRAR_H4_SH(out2_r, out3_r, out2_l, out3_l, rnd_vec);
+            SRARI_H4_SH(out2_r, out3_r, out2_l, out3_l, 6);
             SAT_SH4_SH(out2_r, out3_r, out2_l, out3_l, 7);
             out = PCKEV_XORI128_UB(out2_r, out2_l);
             ST_UB(out, dst_tmp + 16);
@@ -2916,11 +2766,10 @@ static void common_vt_4t_32w_mult_msa(uint8_t *src, int32_t src_stride,
 
 static void common_vt_4t_32w_msa(uint8_t *src, int32_t src_stride,
                                  uint8_t *dst, int32_t dst_stride,
-                                 const int8_t *filter, int32_t height,
-                                 uint8_t rnd_val)
+                                 const int8_t *filter, int32_t height)
 {
     common_vt_4t_32w_mult_msa(src, src_stride, dst, dst_stride,
-                              filter, height, rnd_val, 32);
+                              filter, height, 32);
 }
 
 static void hevc_hv_uni_4t_4x2_msa(uint8_t *src,
@@ -3885,7 +3734,7 @@ void ff_hevc_put_hevc_uni_##PEL##_##DIR##WIDTH##_8_msa(uint8_t *dst,           \
     const int8_t *filter = ff_hevc_##PEL##_filters[FILT_DIR - 1];              \
                                                                                \
     common_##DIR1##_##TAP##t_##WIDTH##w_msa(src, src_stride, dst, dst_stride,  \
-                                            filter, height, 6);                \
+                                            filter, height);                   \
 }
 
 UNI_MC(qpel, h, 4, 8, hz, mx);
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/hevc_mc_uniw_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/hevc_mc_uniw_msa.c
index ce10f413ed9..7c01c32d574 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/hevc_mc_uniw_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/hevc_mc_uniw_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
+ * Copyright (c) 2015 - 2017 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -22,6 +22,13 @@
 #include "libavcodec/mips/hevcdsp_mips.h"
 #include "libavcodec/mips/hevc_macros_msa.h"
 
+static const uint8_t ff_hevc_mask_arr[16 * 2] __attribute__((aligned(0x40))) = {
+    /* 8 width cases */
+    0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8,
+    /* 4 width cases */
+    0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20
+};
+
 #define HEVC_HV_UNIW_RND_CLIP4(in0, in1, in2, in3, wgt, offset, rnd,       \
                                out0, out1, out2, out3)                     \
 {                                                                          \
@@ -62,6 +69,31 @@
                         out2_r, out3_r, out2_l, out3_l);           \
 }
 
+#define HEVC_UNIW_RND_CLIP2_MAX_SATU_H(in0_h, in1_h, wgt_w, offset_h, rnd_w,  \
+                                       out0_h, out1_h)                        \
+{                                                                             \
+    v4i32 in0_r_m, in0_l_m, in1_r_m, in1_l_m;                                 \
+                                                                              \
+    ILVRL_H2_SW(in0_h, in0_h, in0_r_m, in0_l_m);                              \
+    ILVRL_H2_SW(in1_h, in1_h, in1_r_m, in1_l_m);                              \
+    DOTP_SH4_SW(in0_r_m, in1_r_m, in0_l_m, in1_l_m, wgt_w, wgt_w, wgt_w,      \
+                wgt_w, in0_r_m, in1_r_m, in0_l_m, in1_l_m);                   \
+    SRAR_W4_SW(in0_r_m, in1_r_m, in0_l_m, in1_l_m, rnd_w);                    \
+    PCKEV_H2_SH(in0_l_m, in0_r_m, in1_l_m, in1_r_m, out0_h, out1_h);          \
+    ADDS_SH2_SH(out0_h, offset_h, out1_h, offset_h, out0_h, out1_h);          \
+    CLIP_SH2_0_255_MAX_SATU(out0_h, out1_h);                                  \
+}
+
+#define HEVC_UNIW_RND_CLIP4_MAX_SATU_H(in0_h, in1_h, in2_h, in3_h, wgt_w,  \
+                                       offset_h, rnd_w, out0_h, out1_h,    \
+                                       out2_h, out3_h)                     \
+{                                                                          \
+    HEVC_UNIW_RND_CLIP2_MAX_SATU_H(in0_h, in1_h, wgt_w, offset_h, rnd_w,   \
+                                   out0_h, out1_h);                        \
+    HEVC_UNIW_RND_CLIP2_MAX_SATU_H(in2_h, in3_h, wgt_w, offset_h, rnd_w,   \
+                                   out2_h, out3_h);                        \
+}
+
 static void hevc_uniwgt_copy_4w_msa(uint8_t *src,
                                     int32_t src_stride,
                                     uint8_t *dst,
@@ -71,76 +103,60 @@ static void hevc_uniwgt_copy_4w_msa(uint8_t *src,
                                     int32_t offset,
                                     int32_t rnd_val)
 {
+    uint32_t loop_cnt, tp0, tp1, tp2, tp3;
     v16i8 zero = { 0 };
-    v4i32 weight_vec, offset_vec, rnd_vec;
+    v16u8 out0, out1;
+    v16i8 src0 = { 0 }, src1 = { 0 };
+    v8i16 dst0, dst1, dst2, dst3, offset_vec;
+    v4i32 weight_vec, rnd_vec;
 
     weight = weight & 0x0000FFFF;
     weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
+    offset_vec = __msa_fill_h(offset);
     rnd_vec = __msa_fill_w(rnd_val);
 
     if (2 == height) {
-        v16i8 src0, src1;
-        v8i16 dst0;
         v4i32 dst0_r, dst0_l;
 
-        LD_SB2(src, src_stride, src0, src1);
-        src0 = (v16i8) __msa_ilvr_w((v4i32) src1, (v4i32) src0);
+        LW2(src, src_stride, tp0, tp1);
+        INSERT_W2_SB(tp0, tp1, src0);
         dst0 = (v8i16) __msa_ilvr_b(zero, src0);
         dst0 <<= 6;
 
         ILVRL_H2_SW(dst0, dst0, dst0_r, dst0_l);
         DOTP_SH2_SW(dst0_r, dst0_l, weight_vec, weight_vec, dst0_r, dst0_l);
         SRAR_W2_SW(dst0_r, dst0_l, rnd_vec);
-        ADD2(dst0_r, offset_vec, dst0_l, offset_vec, dst0_r, dst0_l);
-        dst0_r = CLIP_SW_0_255(dst0_r);
-        dst0_l = CLIP_SW_0_255(dst0_l);
-
-        HEVC_PCK_SW_SB2(dst0_l, dst0_r, dst0_r);
-        ST4x2_UB(dst0_r, dst, dst_stride);
+        dst0 = __msa_pckev_h((v8i16) dst0_l, (v8i16) dst0_r);
+        dst0 += offset_vec;
+        dst0 = CLIP_SH_0_255_MAX_SATU(dst0);
+        out0 = (v16u8) __msa_pckev_b((v16i8) dst0, (v16i8) dst0);
+        ST4x2_UB(out0, dst, dst_stride);
     } else if (4 == height) {
-        v16i8 src0, src1, src2, src3;
-        v8i16 dst0, dst1;
-        v4i32 dst0_r, dst1_r;
-        v4i32 dst0_l, dst1_l;
-
-        LD_SB4(src, src_stride, src0, src1, src2, src3);
-        ILVR_W2_SB(src1, src0, src3, src2, src0, src1);
-        ILVR_B2_SH(zero, src0, zero, src1, dst0, dst1);
-        dst0 <<= 6;
-        dst1 <<= 6;
-
-        HEVC_UNIW_RND_CLIP2(dst0, dst1, weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst0_l, dst1_l);
-
-        HEVC_PCK_SW_SB4(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r);
-        ST4x4_UB(dst0_r, dst0_r, 0, 1, 2, 3, dst, dst_stride);
-    } else if (0 == height % 8) {
-        uint32_t loop_cnt;
-        v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
-        v8i16 dst0, dst1, dst2, dst3;
-        v4i32 dst0_r, dst1_r, dst2_r, dst3_r;
-        v4i32 dst0_l, dst1_l, dst2_l, dst3_l;
-
+        LW4(src, src_stride, tp0, tp1, tp2, tp3);
+        INSERT_W4_SB(tp0, tp1, tp2, tp3, src0);
+        ILVRL_B2_SH(zero, src0, dst0, dst1);
+        SLLI_2V(dst0, dst1, 6);
+        HEVC_UNIW_RND_CLIP2_MAX_SATU_H(dst0, dst1, weight_vec, offset_vec,
+                                       rnd_vec, dst0, dst1);
+        out0 = (v16u8) __msa_pckev_b((v16i8) dst1, (v16i8) dst0);
+        ST4x4_UB(out0, out0, 0, 1, 2, 3, dst, dst_stride);
+    } else if (0 == (height % 8)) {
         for (loop_cnt = (height >> 3); loop_cnt--;) {
-            LD_SB8(src, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src += (8 * src_stride);
-            ILVR_W4_SB(src1, src0, src3, src2, src5, src4, src7, src6,
-                       src0, src1, src2, src3);
-            ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
-                       dst0, dst1, dst2, dst3);
-
+            LW4(src, src_stride, tp0, tp1, tp2, tp3);
+            src += 4 * src_stride;
+            INSERT_W4_SB(tp0, tp1, tp2, tp3, src0);
+            LW4(src, src_stride, tp0, tp1, tp2, tp3);
+            src += 4 * src_stride;
+            INSERT_W4_SB(tp0, tp1, tp2, tp3, src1);
+            ILVRL_B2_SH(zero, src0, dst0, dst1);
+            ILVRL_B2_SH(zero, src1, dst2, dst3);
             SLLI_4V(dst0, dst1, dst2, dst3, 6);
-            HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                                weight_vec, offset_vec, rnd_vec,
-                                dst0_r, dst1_r, dst2_r, dst3_r,
-                                dst0_l, dst1_l, dst2_l, dst3_l);
-
-            HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
-                            dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
-            ST4x8_UB(dst0_r, dst1_r, dst, dst_stride);
-            dst += (8 * dst_stride);
+            HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                           offset_vec, rnd_vec, dst0, dst1,
+                                           dst2, dst3);
+            PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+            ST4x8_UB(out0, out1, dst, dst_stride);
+            dst += 8 * dst_stride;
         }
     }
 }
@@ -155,46 +171,48 @@ static void hevc_uniwgt_copy_6w_msa(uint8_t *src,
                                     int32_t rnd_val)
 {
     uint32_t loop_cnt;
+    uint64_t tp0, tp1, tp2, tp3;
     v16i8 zero = { 0 };
-    v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
-    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
-    v4i32 dst0_r, dst1_r, dst2_r, dst3_r;
-    v4i32 dst0_l, dst1_l, dst2_l, dst3_l;
-    v4i32 weight_vec, offset_vec, rnd_vec;
+    v16u8 out0, out1, out2, out3;
+    v16i8 src0, src1, src2, src3;
+    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, offset_vec;
+    v4i32 weight_vec, rnd_vec;
 
     weight = weight & 0x0000FFFF;
     weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
+    offset_vec = __msa_fill_h(offset);
     rnd_vec = __msa_fill_w(rnd_val);
 
     for (loop_cnt = (height >> 3); loop_cnt--;) {
-        LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
-        src += (8 * src_stride);
-        ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
-                   dst0, dst1, dst2, dst3);
-        ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
-                   dst4, dst5, dst6, dst7);
+        LD4(src, src_stride, tp0, tp1, tp2, tp3);
+        src += (4 * src_stride);
+        INSERT_D2_SB(tp0, tp1, src0);
+        INSERT_D2_SB(tp2, tp3, src1);
+        LD4(src, src_stride, tp0, tp1, tp2, tp3);
+        src += (4 * src_stride);
+        INSERT_D2_SB(tp0, tp1, src2);
+        INSERT_D2_SB(tp2, tp3, src3);
+
+        ILVRL_B2_SH(zero, src0, dst0, dst1);
+        ILVRL_B2_SH(zero, src1, dst2, dst3);
+        ILVRL_B2_SH(zero, src2, dst4, dst5);
+        ILVRL_B2_SH(zero, src3, dst6, dst7);
 
         SLLI_4V(dst0, dst1, dst2, dst3, 6);
         SLLI_4V(dst4, dst5, dst6, dst7, 6);
-        HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                            weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst2_r, dst3_r,
-                            dst0_l, dst1_l, dst2_l, dst3_l);
-
-        HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
-                        dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
-        ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
-        dst += (4 * dst_stride);
 
-        HEVC_UNIW_RND_CLIP4(dst4, dst5, dst6, dst7,
-                            weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst2_r, dst3_r,
-                            dst0_l, dst1_l, dst2_l, dst3_l);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst4, dst5, dst6, dst7, weight_vec,
+                                       offset_vec, rnd_vec, dst4, dst5, dst6,
+                                       dst7);
+        PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+        PCKEV_B2_UB(dst5, dst4, dst7, dst6, out2, out3);
 
-        HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
-                        dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
-        ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
+        ST6x4_UB(out0, out1, dst, dst_stride);
+        dst += (4 * dst_stride);
+        ST6x4_UB(out2, out3, dst, dst_stride);
         dst += (4 * dst_stride);
     }
 }
@@ -208,78 +226,89 @@ static void hevc_uniwgt_copy_8w_msa(uint8_t *src,
                                     int32_t offset,
                                     int32_t rnd_val)
 {
+    uint32_t loop_cnt;
+    uint64_t tp0, tp1, tp2, tp3;
+    v16i8 src0 = { 0 }, src1 = { 0 }, src2 = { 0 }, src3 = { 0 };
     v16i8 zero = { 0 };
-    v4i32 weight_vec, offset_vec, rnd_vec;
+    v16u8 out0, out1, out2, out3;
+    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, offset_vec;
+    v4i32 weight_vec, rnd_vec;
 
     weight = weight & 0x0000FFFF;
     weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
+    offset_vec = __msa_fill_h(offset);
     rnd_vec = __msa_fill_w(rnd_val);
 
     if (2 == height) {
-        v16i8 src0, src1;
-        v8i16 dst0, dst1;
-        v4i32 dst0_r, dst1_r, dst0_l, dst1_l;
-
-        LD_SB2(src, src_stride, src0, src1);
-        ILVR_B2_SH(zero, src0, zero, src1, dst0, dst1);
-
-        dst0 <<= 6;
-        dst1 <<= 6;
-        HEVC_UNIW_RND_CLIP2(dst0, dst1, weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst0_l, dst1_l);
-
-        HEVC_PCK_SW_SB4(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r);
-        ST8x2_UB(dst0_r, dst, dst_stride);
+        LD2(src, src_stride, tp0, tp1);
+        INSERT_D2_SB(tp0, tp1, src0);
+        ILVRL_B2_SH(zero, src0, dst0, dst1);
+        SLLI_2V(dst0, dst1, 6);
+        HEVC_UNIW_RND_CLIP2_MAX_SATU_H(dst0, dst1, weight_vec, offset_vec,
+                                       rnd_vec, dst0, dst1);
+        out0 = (v16u8) __msa_pckev_b((v16i8) dst1, (v16i8) dst0);
+        ST8x2_UB(out0, dst, dst_stride);
+    } else if (4 == height) {
+        LD4(src, src_stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_SB(tp0, tp1, src0);
+        INSERT_D2_SB(tp2, tp3, src1);
+        ILVRL_B2_SH(zero, src0, dst0, dst1);
+        ILVRL_B2_SH(zero, src1, dst2, dst3);
+        SLLI_4V(dst0, dst1, dst2, dst3, 6);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+        ST8x4_UB(out0, out1, dst, dst_stride);
     } else if (6 == height) {
-        v16i8 src0, src1, src2, src3, src4, src5;
-        v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
-        v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
-        v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
-
-        LD_SB6(src, src_stride, src0, src1, src2, src3, src4, src5);
-        ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
-                   dst0, dst1, dst2, dst3);
-        ILVR_B2_SH(zero, src4, zero, src5, dst4, dst5);
-
+        LD4(src, src_stride, tp0, tp1, tp2, tp3);
+        src += 4 * src_stride;
+        INSERT_D2_SB(tp0, tp1, src0);
+        INSERT_D2_SB(tp2, tp3, src1);
+        LD2(src, src_stride, tp0, tp1);
+        INSERT_D2_SB(tp0, tp1, src2);
+        ILVRL_B2_SH(zero, src0, dst0, dst1);
+        ILVRL_B2_SH(zero, src1, dst2, dst3);
+        ILVRL_B2_SH(zero, src2, dst4, dst5);
         SLLI_4V(dst0, dst1, dst2, dst3, 6);
-        dst4 <<= 6;
-        dst5 <<= 6;
-        HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                            weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst2_r, dst3_r,
-                            dst0_l, dst1_l, dst2_l, dst3_l);
-        HEVC_UNIW_RND_CLIP2(dst4, dst5, weight_vec, offset_vec, rnd_vec,
-                            dst4_r, dst5_r, dst4_l, dst5_l);
-
-        HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
-                         dst2_l, dst2_r, dst3_l, dst3_r,
-                         dst4_l, dst4_r, dst5_l, dst5_r,
-                         dst0_r, dst1_r, dst2_r);
-        ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
+        SLLI_2V(dst4, dst5, 6);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP2_MAX_SATU_H(dst4, dst5, weight_vec, offset_vec,
+                                       rnd_vec, dst4, dst5);
+        PCKEV_B3_UB(dst1, dst0, dst3, dst2, dst5, dst4, out0, out1, out2);
+        ST8x4_UB(out0, out1, dst, dst_stride);
         dst += (4 * dst_stride);
-        ST8x2_UB(dst2_r, dst, dst_stride);
-    } else if (0 == height % 4) {
-        uint32_t loop_cnt;
-        v16i8 src0, src1, src2, src3;
-        v8i16 dst0, dst1, dst2, dst3;
-        v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
-
-        for (loop_cnt = (height >> 2); loop_cnt--;) {
-            LD_SB4(src, src_stride, src0, src1, src2, src3);
-            src += (4 * src_stride);
-            ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
-                       dst0, dst1, dst2, dst3);
-
+        ST8x2_UB(out2, dst, dst_stride);
+    } else if (0 == height % 8) {
+        for (loop_cnt = (height >> 3); loop_cnt--;) {
+            LD4(src, src_stride, tp0, tp1, tp2, tp3);
+            src += 4 * src_stride;
+            INSERT_D2_SB(tp0, tp1, src0);
+            INSERT_D2_SB(tp2, tp3, src1);
+            LD4(src, src_stride, tp0, tp1, tp2, tp3);
+            src += 4 * src_stride;
+            INSERT_D2_SB(tp0, tp1, src2);
+            INSERT_D2_SB(tp2, tp3, src3);
+
+            ILVRL_B2_SH(zero, src0, dst0, dst1);
+            ILVRL_B2_SH(zero, src1, dst2, dst3);
+            ILVRL_B2_SH(zero, src2, dst4, dst5);
+            ILVRL_B2_SH(zero, src3, dst6, dst7);
             SLLI_4V(dst0, dst1, dst2, dst3, 6);
-            HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                                weight_vec, offset_vec, rnd_vec,
-                                dst0_r, dst1_r, dst2_r, dst3_r,
-                                dst0_l, dst1_l, dst2_l, dst3_l);
-
-            HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
-                            dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
-            ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
+            SLLI_4V(dst4, dst5, dst6, dst7, 6);
+            HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                           offset_vec, rnd_vec, dst0, dst1,
+                                           dst2, dst3);
+            HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst4, dst5, dst6, dst7, weight_vec,
+                                           offset_vec, rnd_vec, dst4, dst5,
+                                           dst6, dst7);
+            PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+            PCKEV_B2_UB(dst5, dst4, dst7, dst6, out2, out3);
+            ST8x4_UB(out0, out1, dst, dst_stride);
+            dst += (4 * dst_stride);
+            ST8x4_UB(out2, out3, dst, dst_stride);
             dst += (4 * dst_stride);
         }
     }
@@ -295,112 +324,40 @@ static void hevc_uniwgt_copy_12w_msa(uint8_t *src,
                                      int32_t rnd_val)
 {
     uint32_t loop_cnt;
+    v16u8 out0, out1, out2;
     v16i8 src0, src1, src2, src3;
     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
-    v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
-    v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
+    v8i16 offset_vec;
     v16i8 zero = { 0 };
-    v4i32 weight_vec, offset_vec, rnd_vec;
+    v4i32 weight_vec, rnd_vec;
 
     weight = weight & 0x0000FFFF;
     weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
+    offset_vec = __msa_fill_h(offset);
     rnd_vec = __msa_fill_w(rnd_val);
 
-    for (loop_cnt = (height >> 2); loop_cnt--;) {
+    for (loop_cnt = 4; loop_cnt--;) {
         LD_SB4(src, src_stride, src0, src1, src2, src3);
         src += (4 * src_stride);
         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
                    dst0, dst1, dst2, dst3);
 
-        SLLI_4V(dst0, dst1, dst2, dst3, 6);
         ILVL_W2_SB(src1, src0, src3, src2, src0, src1);
         ILVR_B2_SH(zero, src0, zero, src1, dst4, dst5);
-        dst4 <<= 6;
-        dst5 <<= 6;
-        HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                            weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst2_r, dst3_r,
-                            dst0_l, dst1_l, dst2_l, dst3_l);
-        HEVC_UNIW_RND_CLIP2(dst4, dst5, weight_vec, offset_vec, rnd_vec,
-                            dst4_r, dst5_r, dst4_l, dst5_l);
-
-        HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
-                         dst2_l, dst2_r, dst3_l, dst3_r,
-                         dst4_l, dst4_r, dst5_l, dst5_r,
-                         dst0_r, dst1_r, dst2_r);
-        ST12x4_UB(dst0_r, dst1_r, dst2_r, dst, dst_stride);
+        SLLI_4V(dst0, dst1, dst2, dst3, 6);
+        SLLI_2V(dst4, dst5, 6);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP2_MAX_SATU_H(dst4, dst5, weight_vec, offset_vec,
+                                       rnd_vec, dst4, dst5);
+
+        PCKEV_B3_UB(dst1, dst0, dst3, dst2, dst5, dst4, out0, out1, out2);
+        ST12x4_UB(out0, out1, out2, dst, dst_stride);
         dst += (4 * dst_stride);
     }
 }
 
-static void hevc_uniwgt_copy_16multx4mult_msa(uint8_t *src,
-                                              int32_t src_stride,
-                                              uint8_t *dst,
-                                              int32_t dst_stride,
-                                              int32_t height,
-                                              int32_t weight,
-                                              int32_t offset,
-                                              int32_t rnd_val,
-                                              int32_t width)
-{
-    uint32_t loop_cnt, cnt;
-    uint8_t *src_tmp;
-    uint8_t *dst_tmp;
-    v16i8 src0, src1, src2, src3;
-    v8i16 tmp0, tmp1, tmp2, tmp3;
-    v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
-    v16i8 zero = { 0 };
-    v4i32 weight_vec, offset_vec, rnd_vec;
-
-    weight = weight & 0x0000FFFF;
-    weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
-    rnd_vec = __msa_fill_w(rnd_val);
-
-    for (cnt = width >> 4; cnt--;) {
-        src_tmp = src;
-        dst_tmp = dst;
-
-        for (loop_cnt = height >> 2; loop_cnt--;) {
-            LD_SB4(src_tmp, src_stride, src0, src1, src2, src3);
-            src_tmp += (4 * src_stride);
-            ILVR_B2_SH(zero, src0, zero, src1, tmp0, tmp1);
-            ILVL_B2_SH(zero, src0, zero, src1, tmp2, tmp3);
-
-            SLLI_4V(tmp0, tmp1, tmp2, tmp3, 6);
-            HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
-                                weight_vec, offset_vec, rnd_vec,
-                                dst0_r, dst1_r, dst2_r, dst3_r,
-                                dst0_l, dst1_l, dst2_l, dst3_l);
-
-            HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst2_l, dst2_r,
-                            dst1_l, dst1_r, dst3_l, dst3_r, dst0_r, dst1_r);
-
-            ST_SW2(dst0_r, dst1_r, dst_tmp, dst_stride);
-            dst_tmp += (2 * dst_stride);
-
-            ILVR_B2_SH(zero, src2, zero, src3, tmp0, tmp1);
-            ILVL_B2_SH(zero, src2, zero, src3, tmp2, tmp3);
-
-            SLLI_4V(tmp0, tmp1, tmp2, tmp3, 6);
-            HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
-                                weight_vec, offset_vec, rnd_vec,
-                                dst0_r, dst1_r, dst2_r, dst3_r,
-                                dst0_l, dst1_l, dst2_l, dst3_l);
-
-            HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst2_l, dst2_r,
-                            dst1_l, dst1_r, dst3_l, dst3_r, dst0_r, dst1_r);
-
-            ST_SW2(dst0_r, dst1_r, dst_tmp, dst_stride);
-            dst_tmp += (2 * dst_stride);
-        }
-
-        src += 16;
-        dst += 16;
-    }
-}
-
 static void hevc_uniwgt_copy_16w_msa(uint8_t *src,
                                      int32_t src_stride,
                                      uint8_t *dst,
@@ -410,8 +367,38 @@ static void hevc_uniwgt_copy_16w_msa(uint8_t *src,
                                      int32_t offset,
                                      int32_t rnd_val)
 {
-    hevc_uniwgt_copy_16multx4mult_msa(src, src_stride, dst, dst_stride,
-                                      height, weight, offset, rnd_val, 16);
+    uint32_t loop_cnt;
+    v16u8 out0, out1, out2, out3;
+    v16i8 src0, src1, src2, src3;
+    v16i8 zero = { 0 };
+    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, offset_vec;
+    v4i32 weight_vec, rnd_vec;
+
+    weight = weight & 0x0000FFFF;
+    weight_vec = __msa_fill_w(weight);
+    offset_vec = __msa_fill_h(offset);
+    rnd_vec = __msa_fill_w(rnd_val);
+
+    for (loop_cnt = height >> 2; loop_cnt--;) {
+        LD_SB4(src, src_stride, src0, src1, src2, src3);
+        src += (4 * src_stride);
+        ILVRL_B2_SH(zero, src0, dst0, dst1);
+        ILVRL_B2_SH(zero, src1, dst2, dst3);
+        ILVRL_B2_SH(zero, src2, dst4, dst5);
+        ILVRL_B2_SH(zero, src3, dst6, dst7);
+        SLLI_4V(dst0, dst1, dst2, dst3, 6);
+        SLLI_4V(dst4, dst5, dst6, dst7, 6);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst4, dst5, dst6, dst7, weight_vec,
+                                       offset_vec, rnd_vec, dst4, dst5, dst6,
+                                       dst7);
+        PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+        PCKEV_B2_UB(dst5, dst4, dst7, dst6, out2, out3);
+        ST_UB4(out0, out1, out2, out3, dst, dst_stride);
+        dst += (4 * dst_stride);
+    }
 }
 
 static void hevc_uniwgt_copy_24w_msa(uint8_t *src,
@@ -423,11 +410,48 @@ static void hevc_uniwgt_copy_24w_msa(uint8_t *src,
                                      int32_t offset,
                                      int32_t rnd_val)
 {
-    hevc_uniwgt_copy_16multx4mult_msa(src, src_stride, dst, dst_stride,
-                                      height, weight, offset, rnd_val, 16);
+    uint32_t loop_cnt;
+    v16u8 out0, out1, out2, out3, out4, out5;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16i8 zero = { 0 };
+    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, offset_vec;
+    v8i16 dst8, dst9, dst10, dst11;
+    v4i32 weight_vec, rnd_vec;
 
-    hevc_uniwgt_copy_8w_msa(src + 16, src_stride, dst + 16, dst_stride,
-                            height, weight, offset, rnd_val);
+    weight = weight & 0x0000FFFF;
+    weight_vec = __msa_fill_w(weight);
+    offset_vec = __msa_fill_h(offset);
+    rnd_vec = __msa_fill_w(rnd_val);
+
+    for (loop_cnt = (height >> 2); loop_cnt--;) {
+        LD_SB4(src, src_stride, src0, src1, src4, src5);
+        LD_SB4(src + 16, src_stride, src2, src3, src6, src7);
+        src += (4 * src_stride);
+
+        ILVRL_B2_SH(zero, src0, dst0, dst1);
+        ILVRL_B2_SH(zero, src1, dst2, dst3);
+        ILVR_B2_SH(zero, src2, zero, src3, dst4, dst5);
+        ILVRL_B2_SH(zero, src4, dst6, dst7);
+        ILVRL_B2_SH(zero, src5, dst8, dst9);
+        ILVR_B2_SH(zero, src6, zero, src7, dst10, dst11);
+        SLLI_4V(dst0, dst1, dst2, dst3, 6);
+        SLLI_4V(dst4, dst5, dst6, dst7, 6);
+        SLLI_4V(dst8, dst9, dst10, dst11, 6);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst4, dst5, dst6, dst7, weight_vec,
+                                       offset_vec, rnd_vec, dst4, dst5, dst6,
+                                       dst7);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst8, dst9, dst10, dst11, weight_vec,
+                                       offset_vec, rnd_vec, dst8, dst9, dst10,
+                                       dst11);
+        PCKEV_B3_UB(dst1, dst0, dst3, dst2, dst5, dst4, out0, out1, out2);
+        PCKEV_B3_UB(dst7, dst6, dst9, dst8, dst11, dst10, out3, out4, out5);
+        ST_UB4(out0, out1, out3, out4, dst, dst_stride);
+        ST8x4_UB(out2, out5, dst + 16, dst_stride);
+        dst += (4 * dst_stride);
+    }
 }
 
 static void hevc_uniwgt_copy_32w_msa(uint8_t *src,
@@ -439,8 +463,41 @@ static void hevc_uniwgt_copy_32w_msa(uint8_t *src,
                                      int32_t offset,
                                      int32_t rnd_val)
 {
-    hevc_uniwgt_copy_16multx4mult_msa(src, src_stride, dst, dst_stride,
-                                      height, weight, offset, rnd_val, 32);
+    uint32_t loop_cnt;
+    v16u8 out0, out1, out2, out3;
+    v16i8 src0, src1, src2, src3;
+    v16i8 zero = { 0 };
+    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, offset_vec;
+    v4i32 weight_vec, rnd_vec;
+
+    weight = weight & 0x0000FFFF;
+    weight_vec = __msa_fill_w(weight);
+    offset_vec = __msa_fill_h(offset);
+    rnd_vec = __msa_fill_w(rnd_val);
+
+    for (loop_cnt = (height >> 1); loop_cnt--;) {
+        LD_SB2(src, src_stride, src0, src1);
+        LD_SB2(src + 16, src_stride, src2, src3);
+        src += (2 * src_stride);
+
+        ILVRL_B2_SH(zero, src0, dst0, dst1);
+        ILVRL_B2_SH(zero, src1, dst2, dst3);
+        ILVRL_B2_SH(zero, src2, dst4, dst5);
+        ILVRL_B2_SH(zero, src3, dst6, dst7);
+        SLLI_4V(dst0, dst1, dst2, dst3, 6);
+        SLLI_4V(dst4, dst5, dst6, dst7, 6);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst4, dst5, dst6, dst7, weight_vec,
+                                       offset_vec, rnd_vec, dst4, dst5, dst6,
+                                       dst7);
+        PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+        PCKEV_B2_UB(dst5, dst4, dst7, dst6, out2, out3);
+        ST_UB2(out0, out1, dst, dst_stride);
+        ST_UB2(out2, out3, dst + 16, dst_stride);
+        dst += (2 * dst_stride);
+    }
 }
 
 static void hevc_uniwgt_copy_48w_msa(uint8_t *src,
@@ -452,8 +509,52 @@ static void hevc_uniwgt_copy_48w_msa(uint8_t *src,
                                      int32_t offset,
                                      int32_t rnd_val)
 {
-    hevc_uniwgt_copy_16multx4mult_msa(src, src_stride, dst, dst_stride,
-                                      height, weight, offset, rnd_val, 48);
+    uint32_t loop_cnt;
+    v16u8 out0, out1, out2, out3, out4, out5;
+    v16i8 src0, src1, src2, src3, src4, src5;
+    v16i8 zero = { 0 };
+    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, offset_vec;
+    v8i16 dst6, dst7, dst8, dst9, dst10, dst11;
+    v4i32 weight_vec, rnd_vec;
+
+    weight = weight & 0x0000FFFF;
+    weight_vec = __msa_fill_w(weight);
+    offset_vec = __msa_fill_h(offset);
+    rnd_vec = __msa_fill_w(rnd_val);
+
+    for (loop_cnt = (height >> 1); loop_cnt--;) {
+        LD_SB3(src, 16, src0, src1, src2);
+        src += src_stride;
+        LD_SB3(src, 16, src3, src4, src5);
+        src += src_stride;
+
+        ILVRL_B2_SH(zero, src0, dst0, dst1);
+        ILVRL_B2_SH(zero, src1, dst2, dst3);
+        ILVRL_B2_SH(zero, src2, dst4, dst5);
+        ILVRL_B2_SH(zero, src3, dst6, dst7);
+        ILVRL_B2_SH(zero, src4, dst8, dst9);
+        ILVRL_B2_SH(zero, src5, dst10, dst11);
+        SLLI_4V(dst0, dst1, dst2, dst3, 6);
+        SLLI_4V(dst4, dst5, dst6, dst7, 6);
+        SLLI_4V(dst8, dst9, dst10, dst11, 6);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst4, dst5, dst6, dst7, weight_vec,
+                                       offset_vec, rnd_vec, dst4, dst5, dst6,
+                                       dst7);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst8, dst9, dst10, dst11, weight_vec,
+                                       offset_vec, rnd_vec, dst8, dst9, dst10,
+                                       dst11);
+        PCKEV_B3_UB(dst1, dst0, dst3, dst2, dst5, dst4, out0, out1, out2);
+        PCKEV_B3_UB(dst7, dst6, dst9, dst8, dst11, dst10, out3, out4, out5);
+        ST_UB2(out0, out1, dst, 16);
+        ST_UB(out2, dst + 32);
+        dst += dst_stride;
+        ST_UB2(out3, out4, dst, 16);
+        ST_UB(out5, dst + 32);
+        dst += dst_stride;
+    }
 }
 
 static void hevc_uniwgt_copy_64w_msa(uint8_t *src,
@@ -465,8 +566,58 @@ static void hevc_uniwgt_copy_64w_msa(uint8_t *src,
                                      int32_t offset,
                                      int32_t rnd_val)
 {
-    hevc_uniwgt_copy_16multx4mult_msa(src, src_stride, dst, dst_stride,
-                                      height, weight, offset, rnd_val, 64);
+    uint32_t loop_cnt;
+    v16u8 out0, out1, out2, out3, out4, out5, out6, out7;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16i8 zero = { 0 };
+    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, offset_vec;
+    v8i16 dst8, dst9, dst10, dst11, dst12, dst13, dst14, dst15;
+    v4i32 weight_vec, rnd_vec;
+
+    weight = weight & 0x0000FFFF;
+    weight_vec = __msa_fill_w(weight);
+    offset_vec = __msa_fill_h(offset);
+    rnd_vec = __msa_fill_w(rnd_val);
+
+    for (loop_cnt = (height >> 1); loop_cnt--;) {
+        LD_SB4(src, 16, src0, src1, src2, src3);
+        src += src_stride;
+        LD_SB4(src, 16, src4, src5, src6, src7);
+        src += src_stride;
+
+        ILVRL_B2_SH(zero, src0, dst0, dst1);
+        ILVRL_B2_SH(zero, src1, dst2, dst3);
+        ILVRL_B2_SH(zero, src2, dst4, dst5);
+        ILVRL_B2_SH(zero, src3, dst6, dst7);
+        ILVRL_B2_SH(zero, src4, dst8, dst9);
+        ILVRL_B2_SH(zero, src5, dst10, dst11);
+        ILVRL_B2_SH(zero, src6, dst12, dst13);
+        ILVRL_B2_SH(zero, src7, dst14, dst15);
+        SLLI_4V(dst0, dst1, dst2, dst3, 6);
+        SLLI_4V(dst4, dst5, dst6, dst7, 6);
+        SLLI_4V(dst8, dst9, dst10, dst11, 6);
+        SLLI_4V(dst12, dst13, dst14, dst15, 6);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst4, dst5, dst6, dst7, weight_vec,
+                                       offset_vec, rnd_vec, dst4, dst5, dst6,
+                                       dst7);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst8, dst9, dst10, dst11, weight_vec,
+                                       offset_vec, rnd_vec, dst8, dst9, dst10,
+                                       dst11);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst12, dst13, dst14, dst15, weight_vec,
+                                       offset_vec, rnd_vec, dst12, dst13, dst14,
+                                       dst15);
+        PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+        PCKEV_B2_UB(dst5, dst4, dst7, dst6, out2, out3);
+        PCKEV_B2_UB(dst9, dst8, dst11, dst10, out4, out5);
+        PCKEV_B2_UB(dst13, dst12, dst15, dst14, out6, out7);
+        ST_UB4(out0, out1, out2, out3, dst, 16);
+        dst += dst_stride;
+        ST_UB4(out4, out5, out6, out7, dst, 16);
+        dst += dst_stride;
+    }
 }
 
 static void hevc_hz_uniwgt_8t_4w_msa(uint8_t *src,
@@ -480,28 +631,35 @@ static void hevc_hz_uniwgt_8t_4w_msa(uint8_t *src,
                                      int32_t rnd_val)
 {
     uint32_t loop_cnt;
+    v16u8 out0, out1;
     v8i16 filt0, filt1, filt2, filt3;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
-    v16i8 mask1, mask2, mask3;
-    v8i16 filter_vec, const_vec;
-    v16i8 vec0, vec1, vec2, vec3;
-    v8i16 dst0, dst1, dst2, dst3;
-    v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
-    v4i32 weight_vec, offset_vec, rnd_vec;
-    v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9, vec10;
+    v16i8 mask0, mask1, mask2, mask3, vec11, vec12, vec13, vec14, vec15;
+    v8i16 filter_vec, dst01, dst23, dst45, dst67;
+    v8i16 dst0, dst1, dst2, dst3, weight_vec_h, offset_vec, denom_vec;
+    v4i32 weight_vec, rnd_vec;
 
     src -= 3;
     weight = weight & 0x0000FFFF;
-    const_vec = __msa_ldi_h(128);
-    const_vec <<= 6;
 
     weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
     rnd_vec = __msa_fill_w(rnd_val);
 
+    weight *= 128;
+    rnd_val -= 6;
+
+    weight_vec_h = __msa_fill_h(weight);
+    offset_vec = __msa_fill_h(offset);
+    denom_vec = __msa_fill_h(rnd_val);
+
+    weight_vec_h = __msa_srar_h(weight_vec_h, denom_vec);
+    offset_vec = __msa_adds_s_h(offset_vec, weight_vec_h);
+
     filter_vec = LD_SH(filter);
     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
 
+    mask0 = LD_SB(&ff_hevc_mask_arr[16]);
     mask1 = mask0 + 2;
     mask2 = mask0 + 4;
     mask3 = mask0 + 6;
@@ -513,34 +671,27 @@ static void hevc_hz_uniwgt_8t_4w_msa(uint8_t *src,
 
         VSHF_B4_SB(src0, src1, mask0, mask1, mask2, mask3,
                    vec0, vec1, vec2, vec3);
-
-        dst0 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst0, dst0, dst0, dst0);
         VSHF_B4_SB(src2, src3, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst1 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst1, dst1, dst1, dst1);
+                   vec4, vec5, vec6, vec7);
         VSHF_B4_SB(src4, src5, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst2 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst2, dst2, dst2, dst2);
+                   vec8, vec9, vec10, vec11);
         VSHF_B4_SB(src6, src7, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst3 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst3, dst3, dst3, dst3);
-
-        HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                            weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst2_r, dst3_r,
-                            dst0_l, dst1_l, dst2_l, dst3_l);
-
-        HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
-                        dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
-        ST4x8_UB(dst0_r, dst1_r, dst, dst_stride);
+                   vec12, vec13, vec14, vec15);
+        dst01 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
+                                  filt3);
+        dst23 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
+                                  filt3);
+        dst45 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
+                                  filt3);
+        dst67 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1,
+                                  filt2, filt3);
+
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst01, dst23, dst45, dst67, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+
+        PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+        ST4x8_UB(out0, out1, dst, dst_stride);
         dst += (8 * dst_stride);
     }
 }
@@ -556,28 +707,37 @@ static void hevc_hz_uniwgt_8t_8w_msa(uint8_t *src,
                                      int32_t rnd_val)
 {
     uint32_t loop_cnt;
+    v16u8 out0, out1;
     v16i8 src0, src1, src2, src3;
     v8i16 filt0, filt1, filt2, filt3;
-    v16i8 mask1, mask2, mask3;
-    v8i16 filter_vec, const_vec;
-    v16i8 vec0, vec1, vec2, vec3;
+    v16i8 mask0, mask1, mask2, mask3;
+    v8i16 filter_vec;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+    v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
     v8i16 dst0, dst1, dst2, dst3;
-    v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
-    v4i32 weight_vec, offset_vec, rnd_vec;
-    v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
+    v8i16 weight_vec_h, offset_vec, denom_vec;
+    v4i32 weight_vec, rnd_vec;
 
     src -= 3;
     weight = weight & 0x0000FFFF;
-    const_vec = __msa_ldi_h(128);
-    const_vec <<= 6;
 
     weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
     rnd_vec = __msa_fill_w(rnd_val);
 
+    weight *= 128;
+    rnd_val -= 6;
+
+    weight_vec_h = __msa_fill_h(weight);
+    offset_vec = __msa_fill_h(offset);
+    denom_vec = __msa_fill_h(rnd_val);
+
+    weight_vec_h = __msa_srar_h(weight_vec_h, denom_vec);
+    offset_vec = __msa_adds_s_h(offset_vec, weight_vec_h);
+
     filter_vec = LD_SH(filter);
     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
 
+    mask0 = LD_SB(&ff_hevc_mask_arr[0]);
     mask1 = mask0 + 2;
     mask2 = mask0 + 4;
     mask3 = mask0 + 6;
@@ -589,53 +749,125 @@ static void hevc_hz_uniwgt_8t_8w_msa(uint8_t *src,
 
         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
                    vec0, vec1, vec2, vec3);
-        dst0 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst0, dst0, dst0, dst0);
         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst1 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst1, dst1, dst1, dst1);
+                   vec4, vec5, vec6, vec7);
         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst2 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst2, dst2, dst2, dst2);
+                   vec8, vec9, vec10, vec11);
         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst3 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst3, dst3, dst3, dst3);
+                   vec12, vec13, vec14, vec15);
+        dst0 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
+                                 filt3);
+        dst1 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
+                                 filt3);
+        dst2 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
+                                 filt3);
+        dst3 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1,
+                                 filt2, filt3);
+
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+
+        PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+        ST8x4_UB(out0, out1, dst, dst_stride);
+        dst += (4 * dst_stride);
+    }
+}
 
-        HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                            weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst2_r, dst3_r,
-                            dst0_l, dst1_l, dst2_l, dst3_l);
+static void hevc_hz_uniwgt_8t_12w_msa(uint8_t *src,
+                                      int32_t src_stride,
+                                      uint8_t *dst,
+                                      int32_t dst_stride,
+                                      const int8_t *filter,
+                                      int32_t height,
+                                      int32_t weight,
+                                      int32_t offset,
+                                      int32_t rnd_val)
+{
+    uint32_t loop_cnt;
+    v16u8 out0, out1, out2;
+    v8i16 filt0, filt1, filt2, filt3;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16i8 mask0, mask1, mask2, mask3, mask4, mask5, mask6, mask7;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+    v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
+    v8i16 filter_vec;
+    v8i16 dst01, dst23, dst0, dst1, dst2, dst3, dst4, dst5;
+    v8i16 weight_vec_h, offset_vec, denom_vec;
+    v4i32 weight_vec, rnd_vec;
 
-        HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
-                        dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
-        ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
+    src -= 3;
+    weight = weight & 0x0000FFFF;
+
+    weight_vec = __msa_fill_w(weight);
+    rnd_vec = __msa_fill_w(rnd_val);
+
+    weight *= 128;
+    rnd_val -= 6;
+
+    weight_vec_h = __msa_fill_h(weight);
+    offset_vec = __msa_fill_h(offset);
+    denom_vec = __msa_fill_h(rnd_val);
+
+    weight_vec_h = __msa_srar_h(weight_vec_h, denom_vec);
+    offset_vec = __msa_adds_s_h(offset_vec, weight_vec_h);
+
+    filter_vec = LD_SH(filter);
+    SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
+
+    mask0 = LD_SB(&ff_hevc_mask_arr[0]);
+    mask1 = mask0 + 2;
+    mask2 = mask0 + 4;
+    mask3 = mask0 + 6;
+    mask4 = LD_SB(&ff_hevc_mask_arr[16]);
+    mask5 = mask4 + 2;
+    mask6 = mask4 + 4;
+    mask7 = mask4 + 6;
+
+    for (loop_cnt = (height >> 2); loop_cnt--;) {
+        LD_SB4(src, src_stride, src0, src1, src2, src3);
+        LD_SB4(src + 8, src_stride, src4, src5, src6, src7);
+        src += (4 * src_stride);
+        XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
+
+        VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
+                   vec0, vec1, vec2, vec3);
+        VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
+                   vec4, vec5, vec6, vec7);
+        VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
+                   vec8, vec9, vec10, vec11);
+        VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
+                   vec12, vec13, vec14, vec15);
+        dst0 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
+                                 filt3);
+        dst1 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
+                                 filt3);
+        dst2 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
+                                 filt3);
+        dst3 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1,
+                                 filt2, filt3);
+        VSHF_B4_SB(src4, src5, mask4, mask5, mask6, mask7,
+                   vec0, vec1, vec2, vec3);
+        VSHF_B4_SB(src6, src7, mask4, mask5, mask6, mask7,
+                   vec4, vec5, vec6, vec7);
+        dst01 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
+                                  filt3);
+        dst23 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
+                                  filt3);
+
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP2_MAX_SATU_H(dst01, dst23, weight_vec, offset_vec,
+                                       rnd_vec, dst4, dst5);
+
+        PCKEV_B3_UB(dst1, dst0, dst3, dst2, dst5, dst4, out0, out1, out2);
+        ST8x4_UB(out0, out1, dst, dst_stride);
+        ST4x4_UB(out2, out2, 0, 1, 2, 3, dst + 8, dst_stride);
         dst += (4 * dst_stride);
     }
 }
 
-static void hevc_hz_uniwgt_8t_12w_msa(uint8_t *src,
-                                      int32_t src_stride,
-                                      uint8_t *dst,
-                                      int32_t dst_stride,
-                                      const int8_t *filter,
-                                      int32_t height,
-                                      int32_t weight,
-                                      int32_t offset,
-                                      int32_t rnd_val)
-{
-    hevc_hz_uniwgt_8t_8w_msa(src, src_stride, dst, dst_stride,
-                             filter, height, weight, offset, rnd_val);
-    hevc_hz_uniwgt_8t_4w_msa(src + 8, src_stride, dst + 8, dst_stride,
-                             filter, height, weight, offset, rnd_val);
-}
-
 static void hevc_hz_uniwgt_8t_16w_msa(uint8_t *src,
                                       int32_t src_stride,
                                       uint8_t *dst,
@@ -647,28 +879,36 @@ static void hevc_hz_uniwgt_8t_16w_msa(uint8_t *src,
                                       int32_t rnd_val)
 {
     uint32_t loop_cnt;
+    v16u8 out0, out1;
     v16i8 src0, src1, src2, src3;
     v8i16 filt0, filt1, filt2, filt3;
-    v16i8 mask1, mask2, mask3;
-    v8i16 filter_vec, const_vec;
-    v16i8 vec0, vec1, vec2, vec3;
+    v16i8 mask0, mask1, mask2, mask3;
+    v8i16 filter_vec;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+    v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
     v8i16 dst0, dst1, dst2, dst3;
-    v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
-    v4i32 weight_vec, offset_vec, rnd_vec;
-    v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
+    v8i16 weight_vec_h, offset_vec, denom_vec;
+    v4i32 weight_vec, rnd_vec;
 
     src -= 3;
-    const_vec = __msa_ldi_h(128);
-    const_vec <<= 6;
 
-    weight = weight & 0x0000FFFF;
     weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
     rnd_vec = __msa_fill_w(rnd_val);
 
+    weight *= 128;
+    rnd_val -= 6;
+
+    weight_vec_h = __msa_fill_h(weight);
+    offset_vec = __msa_fill_h(offset);
+    denom_vec = __msa_fill_h(rnd_val);
+
+    weight_vec_h = __msa_srar_h(weight_vec_h, denom_vec);
+    offset_vec = __msa_adds_s_h(offset_vec, weight_vec_h);
+
     filter_vec = LD_SH(filter);
     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
 
+    mask0 = LD_SB(&ff_hevc_mask_arr[0]);
     mask1 = mask0 + 2;
     mask2 = mask0 + 4;
     mask3 = mask0 + 6;
@@ -681,33 +921,27 @@ static void hevc_hz_uniwgt_8t_16w_msa(uint8_t *src,
 
         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
                    vec0, vec1, vec2, vec3);
-        dst0 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst0, dst0, dst0, dst0);
         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst1 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst1, dst1, dst1, dst1);
+                   vec4, vec5, vec6, vec7);
         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst2 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst2, dst2, dst2, dst2);
+                   vec8, vec9, vec10, vec11);
         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst3 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst3, dst3, dst3, dst3);
-
-        HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                            weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst2_r, dst3_r,
-                            dst0_l, dst1_l, dst2_l, dst3_l);
-
-        HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
-                        dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
-        ST_SW2(dst0_r, dst1_r, dst, dst_stride);
+                   vec12, vec13, vec14, vec15);
+        dst0 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
+                                 filt3);
+        dst1 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
+                                 filt3);
+        dst2 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
+                                 filt3);
+        dst3 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1,
+                                 filt2, filt3);
+
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+
+        PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+        ST_UB2(out0, out1, dst, dst_stride);
         dst += (2 * dst_stride);
     }
 }
@@ -723,29 +957,35 @@ static void hevc_hz_uniwgt_8t_24w_msa(uint8_t *src,
                                       int32_t rnd_val)
 {
     uint32_t loop_cnt;
+    v16u8 out0, out1, out2;
     v16i8 src0, src1, src2, src3;
     v8i16 filt0, filt1, filt2, filt3;
-    v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
-    v16i8 vec0, vec1, vec2, vec3;
+    v16i8 mask0, mask1, mask2, mask3, mask4, mask5, mask6, mask7;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+    v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
-    v8i16 filter_vec, const_vec;
-    v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
-    v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
-    v4i32 weight_vec, offset_vec, rnd_vec;
-    v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
+    v8i16 filter_vec, weight_vec_h, offset_vec, denom_vec;
+    v4i32 weight_vec, rnd_vec;
 
     src -= 3;
-    const_vec = __msa_ldi_h(128);
-    const_vec <<= 6;
 
-    weight = weight & 0x0000FFFF;
     weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
     rnd_vec = __msa_fill_w(rnd_val);
 
+    weight *= 128;
+    rnd_val -= 6;
+
+    weight_vec_h = __msa_fill_h(weight);
+    offset_vec = __msa_fill_h(offset);
+    denom_vec = __msa_fill_h(rnd_val);
+
+    weight_vec_h = __msa_srar_h(weight_vec_h, denom_vec);
+    offset_vec = __msa_adds_s_h(offset_vec, weight_vec_h);
+
     filter_vec = LD_SH(filter);
     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
 
+    mask0 = LD_SB(&ff_hevc_mask_arr[0]);
     mask1 = mask0 + 2;
     mask2 = mask0 + 4;
     mask3 = mask0 + 6;
@@ -754,7 +994,7 @@ static void hevc_hz_uniwgt_8t_24w_msa(uint8_t *src,
     mask6 = mask0 + 12;
     mask7 = mask0 + 14;
 
-    for (loop_cnt = (height >> 1); loop_cnt--;) {
+    for (loop_cnt = 16; loop_cnt--;) {
         LD_SB2(src, 16, src0, src1);
         src += src_stride;
         LD_SB2(src, 16, src2, src3);
@@ -762,48 +1002,39 @@ static void hevc_hz_uniwgt_8t_24w_msa(uint8_t *src,
         XORI_B4_128_SB(src0, src1, src2, src3);
         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
                    vec0, vec1, vec2, vec3);
-
-        dst0 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst0, dst0, dst0, dst0);
         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
-                   vec0, vec1, vec2, vec3);
-        dst1 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst1, dst1, dst1, dst1);
+                   vec4, vec5, vec6, vec7);
         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst2 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst2, dst2, dst2, dst2);
+                   vec8, vec9, vec10, vec11);
         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst3 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst3, dst3, dst3, dst3);
+                   vec12, vec13, vec14, vec15);
+        dst0 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
+                                 filt3);
+        dst1 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
+                                 filt3);
+        dst2 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
+                                 filt3);
+        dst3 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1,
+                                 filt2, filt3);
+
         VSHF_B4_SB(src2, src3, mask4, mask5, mask6, mask7,
                    vec0, vec1, vec2, vec3);
-        dst4 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst4, dst4, dst4, dst4);
         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst5 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst5, dst5, dst5, dst5);
-
-        HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                            weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst2_r, dst3_r,
-                            dst0_l, dst1_l, dst2_l, dst3_l);
-        HEVC_UNIW_RND_CLIP2(dst4, dst5, weight_vec, offset_vec, rnd_vec,
-                            dst4_r, dst5_r, dst4_l, dst5_l);
-
-        HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
-                        dst3_l, dst3_r, dst4_l, dst4_r, dst0_r, dst1_r);
-        HEVC_PCK_SW_SB4(dst2_l, dst2_r, dst5_l, dst5_r, dst2_r);
-        ST_SW2(dst0_r, dst1_r, dst, dst_stride);
-        ST8x2_UB(dst2_r, dst + 16, dst_stride);
+                   vec4, vec5, vec6, vec7);
+        dst4 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
+                                 filt3);
+        dst5 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
+                                 filt3);
+
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP2_MAX_SATU_H(dst4, dst5, weight_vec, offset_vec,
+                                       rnd_vec, dst4, dst5);
+
+        PCKEV_B3_UB(dst1, dst0, dst4, dst3, dst5, dst2, out0, out1, out2);
+        ST_UB2(out0, out1, dst, dst_stride);
+        ST8x2_UB(out2, dst + 16, dst_stride);
         dst += (2 * dst_stride);
     }
 }
@@ -819,71 +1050,93 @@ static void hevc_hz_uniwgt_8t_32w_msa(uint8_t *src,
                                       int32_t rnd_val)
 {
     uint32_t loop_cnt;
-    v16i8 src0, src1, src2;
+    v16u8 out0, out1, out2, out3;
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
     v8i16 filt0, filt1, filt2, filt3;
-    v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
-    v16i8 vec0, vec1, vec2, vec3;
-    v8i16 dst0, dst1, dst2, dst3;
-    v8i16 filter_vec, const_vec;
-    v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
-    v4i32 weight_vec, offset_vec, rnd_vec;
-    v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
+    v16i8 mask0, mask1, mask2, mask3;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+    v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
+    v8i16 filter_vec;
+    v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
+    v8i16 weight_vec_h, offset_vec, denom_vec;
+    v4i32 weight_vec, rnd_vec;
 
     src -= 3;
-    const_vec = __msa_ldi_h(128);
-    const_vec <<= 6;
 
-    weight = weight & 0x0000FFFF;
     weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
     rnd_vec = __msa_fill_w(rnd_val);
 
+    weight *= 128;
+    rnd_val -= 6;
+
+    weight_vec_h = __msa_fill_h(weight);
+    offset_vec = __msa_fill_h(offset);
+    denom_vec = __msa_fill_h(rnd_val);
+
+    weight_vec_h = __msa_srar_h(weight_vec_h, denom_vec);
+    offset_vec = __msa_adds_s_h(offset_vec, weight_vec_h);
+
     filter_vec = LD_SH(filter);
     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
 
+    mask0 = LD_SB(&ff_hevc_mask_arr[0]);
     mask1 = mask0 + 2;
     mask2 = mask0 + 4;
     mask3 = mask0 + 6;
-    mask4 = mask0 + 8;
-    mask5 = mask0 + 10;
-    mask6 = mask0 + 12;
-    mask7 = mask0 + 14;
 
-    for (loop_cnt = height; loop_cnt--;) {
-        LD_SB2(src, 16, src0, src1);
-        src2 = LD_SB(src + 24);
+    for (loop_cnt = height >> 1; loop_cnt--;) {
+        LD_SB4(src, 8, src0, src1, src2, src3);
         src += src_stride;
-        XORI_B3_128_SB(src0, src1, src2);
+        LD_SB4(src, 8, src4, src5, src6, src7);
+        src += src_stride;
+        XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
 
         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
                    vec0, vec1, vec2, vec3);
-        dst0 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst0, dst0, dst0, dst0);
-        VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
-                   vec0, vec1, vec2, vec3);
-        dst1 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst1, dst1, dst1, dst1);
         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst2 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst2, dst2, dst2, dst2);
+                   vec4, vec5, vec6, vec7);
         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst3 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst3, dst3, dst3, dst3);
-
-        HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                            weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst2_r, dst3_r,
-                            dst0_l, dst1_l, dst2_l, dst3_l);
+                   vec8, vec9, vec10, vec11);
+        VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
+                   vec12, vec13, vec14, vec15);
+        dst0 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
+                                 filt3);
+        dst1 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
+                                 filt3);
+        dst2 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
+                                 filt3);
+        dst3 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1,
+                                 filt2, filt3);
 
-        HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
-                        dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
-        ST_SW2(dst0_r, dst1_r, dst, 16);
+        VSHF_B4_SB(src4, src4, mask0, mask1, mask2, mask3,
+                   vec0, vec1, vec2, vec3);
+        VSHF_B4_SB(src5, src5, mask0, mask1, mask2, mask3,
+                   vec4, vec5, vec6, vec7);
+        VSHF_B4_SB(src6, src6, mask0, mask1, mask2, mask3,
+                   vec8, vec9, vec10, vec11);
+        VSHF_B4_SB(src7, src7, mask0, mask1, mask2, mask3,
+                   vec12, vec13, vec14, vec15);
+        dst4 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
+                                 filt3);
+        dst5 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
+                                 filt3);
+        dst6 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
+                                 filt3);
+        dst7 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1,
+                                 filt2, filt3);
+
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst4, dst5, dst6, dst7, weight_vec,
+                                       offset_vec, rnd_vec, dst4, dst5, dst6,
+                                       dst7);
+
+        PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+        PCKEV_B2_UB(dst5, dst4, dst7, dst6, out2, out3);
+        ST_UB2(out0, out1, dst, 16);
+        dst += dst_stride;
+        ST_UB2(out2, out3, dst, 16);
         dst += dst_stride;
     }
 }
@@ -899,29 +1152,36 @@ static void hevc_hz_uniwgt_8t_48w_msa(uint8_t *src,
                                       int32_t rnd_val)
 {
     uint32_t loop_cnt;
+    v16u8 out0, out1, out2;
     v16i8 src0, src1, src2, src3;
     v8i16 filt0, filt1, filt2, filt3;
-    v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
-    v16i8 vec0, vec1, vec2, vec3;
+    v16i8 mask0, mask1, mask2, mask3, mask4, mask5, mask6, mask7;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+    v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
-    v8i16 filter_vec, const_vec;
-    v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
-    v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
-    v4i32 weight_vec, offset_vec, rnd_vec;
-    v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
+    v8i16 filter_vec, weight_vec_h, offset_vec, denom_vec;
+    v4i32 weight_vec, rnd_vec;
 
     src -= 3;
-    const_vec = __msa_ldi_h(128);
-    const_vec <<= 6;
 
     weight = weight & 0x0000FFFF;
     weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
     rnd_vec = __msa_fill_w(rnd_val);
 
+    weight *= 128;
+    rnd_val -= 6;
+
+    weight_vec_h = __msa_fill_h(weight);
+    offset_vec = __msa_fill_h(offset);
+    denom_vec = __msa_fill_h(rnd_val);
+
+    weight_vec_h = __msa_srar_h(weight_vec_h, denom_vec);
+    offset_vec = __msa_adds_s_h(offset_vec, weight_vec_h);
+
     filter_vec = LD_SH(filter);
     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
 
+    mask0 = LD_SB(&ff_hevc_mask_arr[0]);
     mask1 = mask0 + 2;
     mask2 = mask0 + 4;
     mask3 = mask0 + 6;
@@ -930,7 +1190,7 @@ static void hevc_hz_uniwgt_8t_48w_msa(uint8_t *src,
     mask6 = mask0 + 12;
     mask7 = mask0 + 14;
 
-    for (loop_cnt = height; loop_cnt--;) {
+    for (loop_cnt = 64; loop_cnt--;) {
         LD_SB3(src, 16, src0, src1, src2);
         src3 = LD_SB(src + 40);
         src += src_stride;
@@ -938,49 +1198,39 @@ static void hevc_hz_uniwgt_8t_48w_msa(uint8_t *src,
 
         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
                    vec0, vec1, vec2, vec3);
-        dst0 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst0, dst0, dst0, dst0);
         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
-                   vec0, vec1, vec2, vec3);
-        dst1 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst1, dst1, dst1, dst1);
+                   vec4, vec5, vec6, vec7);
         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst2 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst2, dst2, dst2, dst2);
+                   vec8, vec9, vec10, vec11);
         VSHF_B4_SB(src1, src2, mask4, mask5, mask6, mask7,
-                   vec0, vec1, vec2, vec3);
-        dst3 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst3, dst3, dst3, dst3);
+                   vec12, vec13, vec14, vec15);
+        dst0 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
+                                 filt3);
+        dst1 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
+                                 filt3);
+        dst2 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2,
+                                 filt3);
+        dst3 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1,
+                                 filt2, filt3);
+
         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
                    vec0, vec1, vec2, vec3);
-        dst4 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst4, dst4, dst4, dst4);
         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
-                   vec0, vec1, vec2, vec3);
-        dst5 = const_vec;
-        DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                     dst5, dst5, dst5, dst5);
-
-        HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                            weight_vec, offset_vec, rnd_vec,
-                            dst0_r, dst1_r, dst2_r, dst3_r,
-                            dst0_l, dst1_l, dst2_l, dst3_l);
-
-        HEVC_UNIW_RND_CLIP2(dst4, dst5, weight_vec, offset_vec, rnd_vec,
-                            dst4_r, dst5_r, dst4_l, dst5_l);
-
-        HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
-                         dst2_l, dst2_r, dst3_l, dst3_r,
-                         dst4_l, dst4_r, dst5_l, dst5_r,
-                         dst0_r, dst1_r, dst2_r);
-        ST_SW2(dst0_r, dst1_r, dst, 16);
-        ST_SW(dst2_r, dst + 32);
+                   vec4, vec5, vec6, vec7);
+        dst4 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2,
+                                 filt3);
+        dst5 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2,
+                                 filt3);
+
+        HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                       offset_vec, rnd_vec, dst0, dst1, dst2,
+                                       dst3);
+        HEVC_UNIW_RND_CLIP2_MAX_SATU_H(dst4, dst5, weight_vec, offset_vec,
+                                       rnd_vec, dst4, dst5);
+
+        PCKEV_B3_UB(dst1, dst0, dst3, dst2, dst5, dst4, out0, out1, out2);
+        ST_UB2(out0, out1, dst, 16);
+        ST_UB(out2, dst + 32);
         dst += dst_stride;
     }
 }
@@ -998,28 +1248,35 @@ static void hevc_hz_uniwgt_8t_64w_msa(uint8_t *src,
     uint8_t *src_tmp;
     uint8_t *dst_tmp;
     uint32_t loop_cnt, cnt;
+    v16u8 out0, out1;
     v16i8 src0, src1, src2;
     v8i16 filt0, filt1, filt2, filt3;
-    v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
-    v16i8 vec0, vec1, vec2, vec3;
+    v16i8 mask0, mask1, mask2, mask3, mask4, mask5, mask6, mask7;
+    v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
+    v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
     v8i16 dst0, dst1, dst2, dst3;
-    v8i16 filter_vec, const_vec;
-    v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
-    v4i32 weight_vec, offset_vec, rnd_vec;
-    v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
+    v8i16 filter_vec, weight_vec_h, offset_vec, denom_vec;
+    v4i32 weight_vec, rnd_vec;
 
     src -= 3;
-    const_vec = __msa_ldi_h(128);
-    const_vec <<= 6;
 
-    weight = weight & 0x0000FFFF;
     weight_vec = __msa_fill_w(weight);
-    offset_vec = __msa_fill_w(offset);
     rnd_vec = __msa_fill_w(rnd_val);
 
+    weight *= 128;
+    rnd_val -= 6;
+
+    weight_vec_h = __msa_fill_h(weight);
+    offset_vec = __msa_fill_h(offset);
+    denom_vec = __msa_fill_h(rnd_val);
+
+    weight_vec_h = __msa_srar_h(weight_vec_h, denom_vec);
+    offset_vec = __msa_adds_s_h(offset_vec, weight_vec_h);
+
     filter_vec = LD_SH(filter);
     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
 
+    mask0 = LD_SB(&ff_hevc_mask_arr[0]);
     mask1 = mask0 + 2;
     mask2 = mask0 + 4;
     mask3 = mask0 + 6;
@@ -1040,33 +1297,27 @@ static void hevc_hz_uniwgt_8t_64w_msa(uint8_t *src,
 
             VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
                        vec0, vec1, vec2, vec3);
-            dst0 = const_vec;
-            DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                         dst0, dst0, dst0, dst0);
             VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
-                       vec0, vec1, vec2, vec3);
-            dst1 = const_vec;
-            DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                         dst1, dst1, dst1, dst1);
+                       vec4, vec5, vec6, vec7);
             VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
-                       vec0, vec1, vec2, vec3);
-            dst2 = const_vec;
-            DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                         dst2, dst2, dst2, dst2);
+                       vec8, vec9, vec10, vec11);
             VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
-                       vec0, vec1, vec2, vec3);
-            dst3 = const_vec;
-            DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
-                         dst3, dst3, dst3, dst3);
-
-            HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
-                                weight_vec, offset_vec, rnd_vec,
-                                dst0_r, dst1_r, dst2_r, dst3_r,
-                                dst0_l, dst1_l, dst2_l, dst3_l);
-
-            HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
-                            dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
-            ST_SW2(dst0_r, dst1_r, dst_tmp, 16);
+                       vec12, vec13, vec14, vec15);
+            dst0 = HEVC_FILT_8TAP_SH(vec0, vec1, vec2, vec3, filt0, filt1,
+                                     filt2, filt3);
+            dst1 = HEVC_FILT_8TAP_SH(vec4, vec5, vec6, vec7, filt0, filt1,
+                                     filt2, filt3);
+            dst2 = HEVC_FILT_8TAP_SH(vec8, vec9, vec10, vec11, filt0, filt1,
+                                     filt2, filt3);
+            dst3 = HEVC_FILT_8TAP_SH(vec12, vec13, vec14, vec15, filt0, filt1,
+                                     filt2, filt3);
+
+            HEVC_UNIW_RND_CLIP4_MAX_SATU_H(dst0, dst1, dst2, dst3, weight_vec,
+                                           offset_vec, rnd_vec, dst0, dst1,
+                                           dst2, dst3);
+
+            PCKEV_B2_UB(dst1, dst0, dst3, dst2, out0, out1);
+            ST_UB2(out0, out1, dst_tmp, 16);
             dst_tmp += 32;
         }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/hevcdsp_init_mips.c b/mythtv/external/FFmpeg/libavcodec/mips/hevcdsp_init_mips.c
index 3675b931554..776d13e4d35 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/hevcdsp_init_mips.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/hevcdsp_init_mips.c
@@ -437,11 +437,11 @@ static av_cold void hevc_dsp_init_msa(HEVCDSPContext *c,
         c->idct_dc[1] = ff_hevc_idct_dc_8x8_msa;
         c->idct_dc[2] = ff_hevc_idct_dc_16x16_msa;
         c->idct_dc[3] = ff_hevc_idct_dc_32x32_msa;
-        c->transform_add[0] = ff_hevc_addblk_4x4_msa;
-        c->transform_add[1] = ff_hevc_addblk_8x8_msa;
-        c->transform_add[2] = ff_hevc_addblk_16x16_msa;
-        c->transform_add[3] = ff_hevc_addblk_32x32_msa;
-        c->idct_4x4_luma = ff_hevc_idct_luma_4x4_msa;
+        c->add_residual[0] = ff_hevc_addblk_4x4_msa;
+        c->add_residual[1] = ff_hevc_addblk_8x8_msa;
+        c->add_residual[2] = ff_hevc_addblk_16x16_msa;
+        c->add_residual[3] = ff_hevc_addblk_32x32_msa;
+        c->transform_4x4_luma = ff_hevc_idct_luma_4x4_msa;
     }
 }
 #endif  // #if HAVE_MSA
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/hevcdsp_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/hevcdsp_msa.c
index f2bc748e378..73cc3ea2130 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/hevcdsp_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/hevcdsp_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
+ * Copyright (c) 2015 - 2017 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -192,56 +192,6 @@ static void hevc_copy_12w_msa(uint8_t *src, int32_t src_stride,
     }
 }
 
-static void hevc_copy_16multx8mult_msa(uint8_t *src,
-                                       int32_t src_stride,
-                                       int16_t *dst,
-                                       int32_t dst_stride,
-                                       int32_t height,
-                                       int32_t width)
-{
-    uint8_t *src_tmp;
-    int16_t *dst_tmp;
-    uint32_t loop_cnt, cnt;
-    v16i8 zero = { 0 };
-    v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
-    v8i16 in0_r, in1_r, in2_r, in3_r;
-    v8i16 in0_l, in1_l, in2_l, in3_l;
-
-    for (cnt = (width >> 4); cnt--;) {
-        src_tmp = src;
-        dst_tmp = dst;
-
-        for (loop_cnt = (height >> 3); loop_cnt--;) {
-            LD_SB8(src_tmp, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src_tmp += (8 * src_stride);
-
-            ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
-                       in0_r, in1_r, in2_r, in3_r);
-            ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
-                       in0_l, in1_l, in2_l, in3_l);
-            SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
-            SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
-            ST_SH4(in0_r, in1_r, in2_r, in3_r, dst_tmp, dst_stride);
-            ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst_tmp + 8), dst_stride);
-            dst_tmp += (4 * dst_stride);
-
-            ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
-                       in0_r, in1_r, in2_r, in3_r);
-            ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
-                       in0_l, in1_l, in2_l, in3_l);
-            SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
-            SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
-            ST_SH4(in0_r, in1_r, in2_r, in3_r, dst_tmp, dst_stride);
-            ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst_tmp + 8), dst_stride);
-            dst_tmp += (4 * dst_stride);
-        }
-
-        src += 16;
-        dst += 16;
-    }
-}
-
 static void hevc_copy_16w_msa(uint8_t *src, int32_t src_stride,
                               int16_t *dst, int32_t dst_stride,
                               int32_t height)
@@ -302,8 +252,34 @@ static void hevc_copy_16w_msa(uint8_t *src, int32_t src_stride,
         ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
         ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
     } else if (0 == (height % 8)) {
-        hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride,
-                                   height, 16);
+        uint32_t loop_cnt;
+        v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
+        v8i16 in0_r, in1_r, in2_r, in3_r, in0_l, in1_l, in2_l, in3_l;
+
+        for (loop_cnt = (height >> 3); loop_cnt--;) {
+            LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6,
+                   src7);
+            src += (8 * src_stride);
+            ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, in0_r,
+                       in1_r, in2_r, in3_r);
+            ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, in0_l,
+                       in1_l, in2_l, in3_l);
+            SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
+            SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
+            ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
+            ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
+            dst += (4 * dst_stride);
+
+            ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, in0_r,
+                       in1_r, in2_r, in3_r);
+            ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, in0_l,
+                       in1_l, in2_l, in3_l);
+            SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
+            SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
+            ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
+            ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
+            dst += (4 * dst_stride);
+        }
     }
 }
 
@@ -311,29 +287,155 @@ static void hevc_copy_24w_msa(uint8_t *src, int32_t src_stride,
                               int16_t *dst, int32_t dst_stride,
                               int32_t height)
 {
-    hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 16);
-    hevc_copy_8w_msa(src + 16, src_stride, dst + 16, dst_stride, height);
+    uint32_t loop_cnt;
+    v16i8 zero = { 0 };
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v8i16 in0_r, in1_r, in2_r, in3_r, in0_l, in1_l, in2_l, in3_l;
+
+    for (loop_cnt = (height >> 2); loop_cnt--;) {
+        LD_SB4(src, src_stride, src0, src1, src2, src3);
+        LD_SB4((src + 16), src_stride, src4, src5, src6, src7);
+        src += (4 * src_stride);
+        ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, in0_r, in1_r,
+                   in2_r, in3_r);
+        ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, in0_l, in1_l,
+                   in2_l, in3_l);
+        SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
+        SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
+        ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
+        ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
+        ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, in0_r, in1_r,
+                   in2_r, in3_r);
+        SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
+        ST_SH4(in0_r, in1_r, in2_r, in3_r, (dst + 16), dst_stride);
+        dst += (4 * dst_stride);
+    }
 }
 
 static void hevc_copy_32w_msa(uint8_t *src, int32_t src_stride,
                               int16_t *dst, int32_t dst_stride,
                               int32_t height)
 {
-    hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 32);
+    uint32_t loop_cnt;
+    v16i8 zero = { 0 };
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v8i16 in0_r, in1_r, in2_r, in3_r, in0_l, in1_l, in2_l, in3_l;
+
+    for (loop_cnt = (height >> 2); loop_cnt--;) {
+        LD_SB4(src, src_stride, src0, src2, src4, src6);
+        LD_SB4((src + 16), src_stride, src1, src3, src5, src7);
+        src += (4 * src_stride);
+
+        ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, in0_r, in1_r,
+                   in2_r, in3_r);
+        ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, in0_l, in1_l,
+                   in2_l, in3_l);
+        SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
+        SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
+        ST_SH4(in0_r, in0_l, in1_r, in1_l, dst, 8);
+        dst += dst_stride;
+        ST_SH4(in2_r, in2_l, in3_r, in3_l, dst, 8);
+        dst += dst_stride;
+
+        ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, in0_r, in1_r,
+                   in2_r, in3_r);
+        ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, in0_l, in1_l,
+                   in2_l, in3_l);
+        SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
+        SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
+        ST_SH4(in0_r, in0_l, in1_r, in1_l, dst, 8);
+        dst += dst_stride;
+        ST_SH4(in2_r, in2_l, in3_r, in3_l, dst, 8);
+        dst += dst_stride;
+    }
 }
 
 static void hevc_copy_48w_msa(uint8_t *src, int32_t src_stride,
                               int16_t *dst, int32_t dst_stride,
                               int32_t height)
 {
-    hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 48);
+    uint32_t loop_cnt;
+    v16i8 zero = { 0 };
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16i8 src8, src9, src10, src11;
+    v8i16 in0_r, in1_r, in2_r, in3_r, in4_r, in5_r;
+    v8i16 in0_l, in1_l, in2_l, in3_l, in4_l, in5_l;
+
+    for (loop_cnt = (height >> 2); loop_cnt--;) {
+        LD_SB3(src, 16, src0, src1, src2);
+        src += src_stride;
+        LD_SB3(src, 16, src3, src4, src5);
+        src += src_stride;
+        LD_SB3(src, 16, src6, src7, src8);
+        src += src_stride;
+        LD_SB3(src, 16, src9, src10, src11);
+        src += src_stride;
+
+        ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
+                   in0_r, in1_r, in2_r, in3_r);
+        ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
+                   in0_l, in1_l, in2_l, in3_l);
+        ILVR_B2_SH(zero, src4, zero, src5, in4_r, in5_r);
+        ILVL_B2_SH(zero, src4, zero, src5, in4_l, in5_l);
+        SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
+        SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
+        SLLI_4V(in4_r, in5_r, in4_l, in5_l, 6);
+        ST_SH6(in0_r, in0_l, in1_r, in1_l, in2_r, in2_l, dst, 8);
+        dst += dst_stride;
+        ST_SH6(in3_r, in3_l, in4_r, in4_l, in5_r, in5_l, dst, 8);
+        dst += dst_stride;
+
+        ILVR_B4_SH(zero, src6, zero, src7, zero, src8, zero, src9,
+                   in0_r, in1_r, in2_r, in3_r);
+        ILVL_B4_SH(zero, src6, zero, src7, zero, src8, zero, src9,
+                   in0_l, in1_l, in2_l, in3_l);
+        ILVR_B2_SH(zero, src10, zero, src11, in4_r, in5_r);
+        ILVL_B2_SH(zero, src10, zero, src11, in4_l, in5_l);
+        SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
+        SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
+        SLLI_4V(in4_r, in5_r, in4_l, in5_l, 6);
+        ST_SH6(in0_r, in0_l, in1_r, in1_l, in2_r, in2_l, dst, 8);
+        dst += dst_stride;
+        ST_SH6(in3_r, in3_l, in4_r, in4_l, in5_r, in5_l, dst, 8);
+        dst += dst_stride;
+    }
 }
 
 static void hevc_copy_64w_msa(uint8_t *src, int32_t src_stride,
                               int16_t *dst, int32_t dst_stride,
                               int32_t height)
 {
-    hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 64);
+    uint32_t loop_cnt;
+    v16i8 zero = { 0 };
+    v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v8i16 in0_r, in1_r, in2_r, in3_r, in0_l, in1_l, in2_l, in3_l;
+
+    for (loop_cnt = (height >> 1); loop_cnt--;) {
+        LD_SB4(src, 16, src0, src1, src2, src3);
+        src += src_stride;
+        LD_SB4(src, 16, src4, src5, src6, src7);
+        src += src_stride;
+
+        ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
+                   in0_r, in1_r, in2_r, in3_r);
+        ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
+                   in0_l, in1_l, in2_l, in3_l);
+        SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
+        SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
+        ST_SH4(in0_r, in0_l, in1_r, in1_l, dst, 8);
+        ST_SH4(in2_r, in2_l, in3_r, in3_l, (dst + 32), 8);
+        dst += dst_stride;
+
+        ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
+                   in0_r, in1_r, in2_r, in3_r);
+        ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
+                   in0_l, in1_l, in2_l, in3_l);
+        SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
+        SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
+        ST_SH4(in0_r, in0_l, in1_r, in1_l, dst, 8);
+        ST_SH4(in2_r, in2_l, in3_r, in3_l, (dst + 32), 8);
+        dst += dst_stride;
+    }
 }
 
 static void hevc_hz_8t_4w_msa(uint8_t *src, int32_t src_stride,
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_init_mips.c b/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_init_mips.c
index 331cfac115c..e987698d667 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_init_mips.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_init_mips.c
@@ -18,7 +18,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "libavcodec/hevc.h"
+#include "config.h"
+#include "libavutil/attributes.h"
 #include "libavcodec/mips/hevcpred_mips.h"
 
 #if HAVE_MSA
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_mips.h b/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_mips.h
index 12f57a2a3c5..f22feff85e7 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_mips.h
+++ b/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_mips.h
@@ -21,7 +21,7 @@
 #ifndef AVCODEC_MIPS_HEVCPRED_MIPS_H
 #define AVCODEC_MIPS_HEVCPRED_MIPS_H
 
-#include "libavcodec/hevcdsp.h"
+#include "libavcodec/hevcpred.h"
 
 void ff_hevc_intra_pred_planar_0_msa(uint8_t *dst,
                                      const uint8_t *src_top,
@@ -67,7 +67,7 @@ void ff_pred_intra_pred_angular_3_msa(uint8_t *dst,
                                       const uint8_t *src_left,
                                       ptrdiff_t stride, int c_idx, int mode);
 
-void ff_intra_pred_8_16x16_msa(HEVCContext *s, int x0, int y0, int c_idx);
-void ff_intra_pred_8_32x32_msa(HEVCContext *s, int x0, int y0, int c_idx);
+void ff_intra_pred_8_16x16_msa(struct HEVCContext *s, int x0, int y0, int c_idx);
+void ff_intra_pred_8_32x32_msa(struct HEVCContext *s, int x0, int y0, int c_idx);
 
 #endif  // #ifndef AVCODEC_MIPS_HEVCPRED_MIPS_H
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_msa.c
index 6a3b2815fd9..963c64c8618 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/hevcpred_msa.c
@@ -18,7 +18,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "libavcodec/hevc.h"
+#include "libavcodec/hevcdec.h"
 #include "libavutil/mips/generic_macros_msa.h"
 #include "hevcpred_mips.h"
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/idctdsp_mips.h b/mythtv/external/FFmpeg/libavcodec/mips/idctdsp_mips.h
index 19267e67059..7ca7c1c93ff 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/idctdsp_mips.h
+++ b/mythtv/external/FFmpeg/libavcodec/mips/idctdsp_mips.h
@@ -34,11 +34,11 @@ void ff_add_pixels_clamped_msa(const int16_t *block,
                                uint8_t *av_restrict pixels,
                                ptrdiff_t line_size);
 void ff_j_rev_dct_msa(int16_t *data);
-void ff_jref_idct_put_msa(uint8_t *dest, int32_t stride, int16_t *block);
-void ff_jref_idct_add_msa(uint8_t *dest, int32_t stride, int16_t *block);
+void ff_jref_idct_put_msa(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+void ff_jref_idct_add_msa(uint8_t *dest, ptrdiff_t stride, int16_t *block);
 void ff_simple_idct_msa(int16_t *block);
-void ff_simple_idct_put_msa(uint8_t *dest, int32_t stride_dst, int16_t *block);
-void ff_simple_idct_add_msa(uint8_t *dest, int32_t stride_dst, int16_t *block);
+void ff_simple_idct_put_msa(uint8_t *dest, ptrdiff_t stride_dst, int16_t *block);
+void ff_simple_idct_add_msa(uint8_t *dest, ptrdiff_t stride_dst, int16_t *block);
 
 void ff_put_pixels_clamped_mmi(const int16_t *block,
         uint8_t *av_restrict pixels, ptrdiff_t line_size);
@@ -47,7 +47,7 @@ void ff_put_signed_pixels_clamped_mmi(const int16_t *block,
 void ff_add_pixels_clamped_mmi(const int16_t *block,
         uint8_t *av_restrict pixels, ptrdiff_t line_size);
 void ff_simple_idct_mmi(int16_t *block);
-void ff_simple_idct_put_mmi(uint8_t *dest, int32_t line_size, int16_t *block);
-void ff_simple_idct_add_mmi(uint8_t *dest, int32_t line_size, int16_t *block);
+void ff_simple_idct_put_mmi(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct_add_mmi(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 
 #endif  // #ifndef AVCODEC_MIPS_IDCTDSP_MIPS_H
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/iirfilter_mips.c b/mythtv/external/FFmpeg/libavcodec/mips/iirfilter_mips.c
index 87db9ffe55b..3a1352a7e43 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/iirfilter_mips.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/iirfilter_mips.c
@@ -52,6 +52,7 @@
  * Reference: libavcodec/iirfilter.c
  */
 
+#include "config.h"
 #include "libavcodec/iirfilter.h"
 
 #if HAVE_INLINE_ASM
@@ -67,9 +68,9 @@ typedef struct FFIIRFilterState {
     float x[1];
 } FFIIRFilterState;
 
-static void ff_iir_filter_flt_mips(const struct FFIIRFilterCoeffs *c,
-                                   struct FFIIRFilterState *s, int size,
-                                   const float *src, int sstep, float *dst, int dstep)
+static void iir_filter_flt_mips(const struct FFIIRFilterCoeffs *c,
+                                struct FFIIRFilterState *s, int size,
+                                const float *src, ptrdiff_t sstep, float *dst, ptrdiff_t dstep)
 {
     if (c->order == 2) {
         int i;
@@ -202,7 +203,7 @@ static void ff_iir_filter_flt_mips(const struct FFIIRFilterCoeffs *c,
 void ff_iir_filter_init_mips(FFIIRFilterContext *f) {
 #if HAVE_INLINE_ASM
 #if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
-    f->filter_flt = ff_iir_filter_flt_mips;
+    f->filter_flt = iir_filter_flt_mips;
 #endif /* !HAVE_MIPS32R6 && !HAVE_MIPS64R6 */
 #endif /* HAVE_INLINE_ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/mpegaudiodsp_mips_fixed.c b/mythtv/external/FFmpeg/libavcodec/mips/mpegaudiodsp_mips_fixed.c
index ed8c89089ec..1c9c68d23c0 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/mpegaudiodsp_mips_fixed.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/mpegaudiodsp_mips_fixed.c
@@ -61,7 +61,7 @@
 #if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 
 static void ff_mpadsp_apply_window_mips_fixed(int32_t *synth_buf, int32_t *window,
-                               int *dither_state, int16_t *samples, int incr)
+                               int *dither_state, int16_t *samples, ptrdiff_t incr)
 {
     register const int32_t *w, *w2, *p;
     int j;
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/mpegaudiodsp_mips_float.c b/mythtv/external/FFmpeg/libavcodec/mips/mpegaudiodsp_mips_float.c
index 270838ebf13..481b69c10e0 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/mpegaudiodsp_mips_float.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/mpegaudiodsp_mips_float.c
@@ -62,7 +62,7 @@
 #if !HAVE_MIPS32R6 && !HAVE_MIPS64R6
 
 static void ff_mpadsp_apply_window_mips_float(float *synth_buf, float *window,
-                               int *dither_state, float *samples, int incr)
+                               int *dither_state, float *samples, ptrdiff_t incr)
 {
     register const float *w, *w2, *p;
     int j;
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_mips.h b/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_mips.h
index 7f8cc96683d..a12b1a6949b 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_mips.h
+++ b/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_mips.h
@@ -25,15 +25,15 @@
 #include "../mpegvideo.h"
 
 void ff_diff_pixels_msa(int16_t *av_restrict block, const uint8_t *src1,
-                        const uint8_t *src2, int stride);
+                        const uint8_t *src2, ptrdiff_t stride);
 void ff_get_pixels_16_msa(int16_t *restrict dst, const uint8_t *src,
                           ptrdiff_t stride);
 void ff_get_pixels_8_msa(int16_t *restrict dst, const uint8_t *src,
                          ptrdiff_t stride);
 
 void ff_get_pixels_8_mmi(int16_t *av_restrict block, const uint8_t *pixels,
-        ptrdiff_t line_size);
+                         ptrdiff_t stride);
 void ff_diff_pixels_mmi(int16_t *av_restrict block, const uint8_t *src1,
-        const uint8_t *src2, int stride);
+                        const uint8_t *src2, ptrdiff_t stride);
 
 #endif  // #ifndef AVCODEC_MIPS_PIXBLOCKDSP_MIPS_H
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_mmi.c b/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_mmi.c
index 9f2eac36ec6..a915a3c28bc 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_mmi.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_mmi.c
@@ -26,7 +26,7 @@
 #include "libavutil/mips/mmiutils.h"
 
 void ff_get_pixels_8_mmi(int16_t *av_restrict block, const uint8_t *pixels,
-        ptrdiff_t line_size)
+                         ptrdiff_t stride)
 {
     double ftmp[7];
     DECLARE_VAR_ALL64;
@@ -36,7 +36,7 @@ void ff_get_pixels_8_mmi(int16_t *av_restrict block, const uint8_t *pixels,
         "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]                \n\t"
 
         MMI_LDC1(%[ftmp1], %[pixels], 0x00)
-        MMI_LDXC1(%[ftmp2], %[pixels], %[line_size], 0x00)
+        MMI_LDXC1(%[ftmp2], %[pixels], %[stride], 0x00)
         "punpcklbh  %[ftmp3],   %[ftmp1],       %[ftmp0]                \n\t"
         "punpckhbh  %[ftmp4],   %[ftmp1],       %[ftmp0]                \n\t"
         "punpcklbh  %[ftmp5],   %[ftmp2],       %[ftmp0]                \n\t"
@@ -45,10 +45,10 @@ void ff_get_pixels_8_mmi(int16_t *av_restrict block, const uint8_t *pixels,
         MMI_SDC1(%[ftmp4], %[block], 0x08)
         MMI_SDC1(%[ftmp5], %[block], 0x10)
         MMI_SDC1(%[ftmp6], %[block], 0x18)
-        PTR_ADDU   "%[pixels],  %[pixels],      %[line_size_x2]         \n\t"
+        PTR_ADDU   "%[pixels],  %[pixels],      %[stride_x2]            \n\t"
 
         MMI_LDC1(%[ftmp1], %[pixels], 0x00)
-        MMI_LDXC1(%[ftmp2], %[pixels], %[line_size], 0x00)
+        MMI_LDXC1(%[ftmp2], %[pixels], %[stride], 0x00)
         "punpcklbh  %[ftmp3],   %[ftmp1],       %[ftmp0]                \n\t"
         "punpckhbh  %[ftmp4],   %[ftmp1],       %[ftmp0]                \n\t"
         "punpcklbh  %[ftmp5],   %[ftmp2],       %[ftmp0]                \n\t"
@@ -57,10 +57,10 @@ void ff_get_pixels_8_mmi(int16_t *av_restrict block, const uint8_t *pixels,
         MMI_SDC1(%[ftmp4], %[block], 0x28)
         MMI_SDC1(%[ftmp5], %[block], 0x30)
         MMI_SDC1(%[ftmp6], %[block], 0x38)
-        PTR_ADDU   "%[pixels],  %[pixels],      %[line_size_x2]         \n\t"
+        PTR_ADDU   "%[pixels],  %[pixels],      %[stride_x2]            \n\t"
 
         MMI_LDC1(%[ftmp1], %[pixels], 0x00)
-        MMI_LDXC1(%[ftmp2], %[pixels], %[line_size], 0x00)
+        MMI_LDXC1(%[ftmp2], %[pixels], %[stride], 0x00)
         "punpcklbh  %[ftmp3],   %[ftmp1],       %[ftmp0]                \n\t"
         "punpckhbh  %[ftmp4],   %[ftmp1],       %[ftmp0]                \n\t"
         "punpcklbh  %[ftmp5],   %[ftmp2],       %[ftmp0]                \n\t"
@@ -69,10 +69,10 @@ void ff_get_pixels_8_mmi(int16_t *av_restrict block, const uint8_t *pixels,
         MMI_SDC1(%[ftmp4], %[block], 0x48)
         MMI_SDC1(%[ftmp5], %[block], 0x50)
         MMI_SDC1(%[ftmp6], %[block], 0x58)
-        PTR_ADDU   "%[pixels],  %[pixels],      %[line_size_x2]         \n\t"
+        PTR_ADDU   "%[pixels],  %[pixels],      %[stride_x2]            \n\t"
 
         MMI_LDC1(%[ftmp1], %[pixels], 0x00)
-        MMI_LDXC1(%[ftmp2], %[pixels], %[line_size], 0x00)
+        MMI_LDXC1(%[ftmp2], %[pixels], %[stride], 0x00)
         "punpcklbh  %[ftmp3],   %[ftmp1],       %[ftmp0]                \n\t"
         "punpckhbh  %[ftmp4],   %[ftmp1],       %[ftmp0]                \n\t"
         "punpcklbh  %[ftmp5],   %[ftmp2],       %[ftmp0]                \n\t"
@@ -88,14 +88,14 @@ void ff_get_pixels_8_mmi(int16_t *av_restrict block, const uint8_t *pixels,
           RESTRICT_ASM_ALL64
           RESTRICT_ASM_ADDRT
           [pixels]"+&r"(pixels)
-        : [block]"r"((mips_reg)block),      [line_size]"r"((mips_reg)line_size),
-          [line_size_x2]"r"((mips_reg)(line_size<<1))
+        : [block]"r"((mips_reg)block),      [stride]"r"((mips_reg)stride),
+          [stride_x2]"r"((mips_reg)(stride<<1))
         : "memory"
     );
 }
 
 void ff_diff_pixels_mmi(int16_t *av_restrict block, const uint8_t *src1,
-        const uint8_t *src2, int stride)
+        const uint8_t *src2, ptrdiff_t stride)
 {
     double ftmp[5];
     mips_reg tmp[1];
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_msa.c
index 966e11a7f58..86a4576c1dd 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/pixblockdsp_msa.c
@@ -137,7 +137,7 @@ void ff_get_pixels_8_msa(int16_t *av_restrict dest, const uint8_t *src,
 }
 
 void ff_diff_pixels_msa(int16_t *av_restrict block, const uint8_t *src1,
-                        const uint8_t *src2, int stride)
+                        const uint8_t *src2, ptrdiff_t stride)
 {
     diff_pixels_msa(block, src1, src2, stride);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/simple_idct_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/simple_idct_msa.c
index bd8b31012f7..8a7235927e2 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/simple_idct_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/simple_idct_msa.c
@@ -562,12 +562,12 @@ void ff_simple_idct_msa(int16_t *block)
     simple_idct_msa(block);
 }
 
-void ff_simple_idct_put_msa(uint8_t *dst, int32_t dst_stride, int16_t *block)
+void ff_simple_idct_put_msa(uint8_t *dst, ptrdiff_t dst_stride, int16_t *block)
 {
     simple_idct_put_msa(dst, dst_stride, block);
 }
 
-void ff_simple_idct_add_msa(uint8_t *dst, int32_t dst_stride, int16_t *block)
+void ff_simple_idct_add_msa(uint8_t *dst, ptrdiff_t dst_stride, int16_t *block)
 {
     simple_idct_add_msa(dst, dst_stride, block);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/vc1dsp_init_mips.c b/mythtv/external/FFmpeg/libavcodec/mips/vc1dsp_init_mips.c
new file mode 100644
index 00000000000..4adc9e1d4ea
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mips/vc1dsp_init_mips.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2016 Zhou Xiaoyong <zhouxiaoyong@loongson.cn>
+ *
+ * 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/vc1dsp.h"
+#include "vc1dsp_mips.h"
+#include "config.h"
+
+#if HAVE_MMI
+static av_cold void vc1dsp_init_mmi(VC1DSPContext *dsp)
+{
+#if _MIPS_SIM != _ABIO32
+    dsp->vc1_inv_trans_8x8    = ff_vc1_inv_trans_8x8_mmi;
+    dsp->vc1_inv_trans_4x8    = ff_vc1_inv_trans_4x8_mmi;
+    dsp->vc1_inv_trans_8x4    = ff_vc1_inv_trans_8x4_mmi;
+#endif
+    dsp->vc1_inv_trans_4x4    = ff_vc1_inv_trans_4x4_mmi;
+    dsp->vc1_inv_trans_8x8_dc = ff_vc1_inv_trans_8x8_dc_mmi;
+    dsp->vc1_inv_trans_4x8_dc = ff_vc1_inv_trans_4x8_dc_mmi;
+    dsp->vc1_inv_trans_8x4_dc = ff_vc1_inv_trans_8x4_dc_mmi;
+    dsp->vc1_inv_trans_4x4_dc = ff_vc1_inv_trans_4x4_dc_mmi;
+
+    dsp->vc1_h_overlap        = ff_vc1_h_overlap_mmi;
+    dsp->vc1_v_overlap        = ff_vc1_v_overlap_mmi;
+    dsp->vc1_h_s_overlap      = ff_vc1_h_s_overlap_mmi;
+    dsp->vc1_v_s_overlap      = ff_vc1_v_s_overlap_mmi;
+
+    dsp->vc1_v_loop_filter4  = ff_vc1_v_loop_filter4_mmi;
+    dsp->vc1_h_loop_filter4  = ff_vc1_h_loop_filter4_mmi;
+    dsp->vc1_v_loop_filter8  = ff_vc1_v_loop_filter8_mmi;
+    dsp->vc1_h_loop_filter8  = ff_vc1_h_loop_filter8_mmi;
+    dsp->vc1_v_loop_filter16 = ff_vc1_v_loop_filter16_mmi;
+    dsp->vc1_h_loop_filter16 = ff_vc1_h_loop_filter16_mmi;
+
+#define FN_ASSIGN(OP, X, Y, INSN) \
+    dsp->OP##vc1_mspel_pixels_tab[1][X+4*Y] = ff_##OP##vc1_mspel_mc##X##Y##INSN; \
+    dsp->OP##vc1_mspel_pixels_tab[0][X+4*Y] = ff_##OP##vc1_mspel_mc##X##Y##_16##INSN
+
+    FN_ASSIGN(put_, 0, 0, _mmi);
+    FN_ASSIGN(put_, 0, 1, _mmi);
+    FN_ASSIGN(put_, 0, 2, _mmi);
+    FN_ASSIGN(put_, 0, 3, _mmi);
+
+    FN_ASSIGN(put_, 1, 0, _mmi);
+    //FN_ASSIGN(put_, 1, 1, _mmi);//FIXME
+    //FN_ASSIGN(put_, 1, 2, _mmi);//FIXME
+    //FN_ASSIGN(put_, 1, 3, _mmi);//FIXME
+
+    FN_ASSIGN(put_, 2, 0, _mmi);
+    //FN_ASSIGN(put_, 2, 1, _mmi);//FIXME
+    //FN_ASSIGN(put_, 2, 2, _mmi);//FIXME
+    //FN_ASSIGN(put_, 2, 3, _mmi);//FIXME
+
+    FN_ASSIGN(put_, 3, 0, _mmi);
+    //FN_ASSIGN(put_, 3, 1, _mmi);//FIXME
+    //FN_ASSIGN(put_, 3, 2, _mmi);//FIXME
+    //FN_ASSIGN(put_, 3, 3, _mmi);//FIXME
+
+    FN_ASSIGN(avg_, 0, 0, _mmi);
+    FN_ASSIGN(avg_, 0, 1, _mmi);
+    FN_ASSIGN(avg_, 0, 2, _mmi);
+    FN_ASSIGN(avg_, 0, 3, _mmi);
+
+    FN_ASSIGN(avg_, 1, 0, _mmi);
+    //FN_ASSIGN(avg_, 1, 1, _mmi);//FIXME
+    //FN_ASSIGN(avg_, 1, 2, _mmi);//FIXME
+    //FN_ASSIGN(avg_, 1, 3, _mmi);//FIXME
+
+    FN_ASSIGN(avg_, 2, 0, _mmi);
+    //FN_ASSIGN(avg_, 2, 1, _mmi);//FIXME
+    //FN_ASSIGN(avg_, 2, 2, _mmi);//FIXME
+    //FN_ASSIGN(avg_, 2, 3, _mmi);//FIXME
+
+    FN_ASSIGN(avg_, 3, 0, _mmi);
+    //FN_ASSIGN(avg_, 3, 1, _mmi);//FIXME
+    //FN_ASSIGN(avg_, 3, 2, _mmi);//FIXME
+    //FN_ASSIGN(avg_, 3, 3, _mmi);//FIXME
+
+    dsp->put_no_rnd_vc1_chroma_pixels_tab[0] = ff_put_no_rnd_vc1_chroma_mc8_mmi;
+    dsp->avg_no_rnd_vc1_chroma_pixels_tab[0] = ff_avg_no_rnd_vc1_chroma_mc8_mmi;
+    dsp->put_no_rnd_vc1_chroma_pixels_tab[1] = ff_put_no_rnd_vc1_chroma_mc4_mmi;
+    dsp->avg_no_rnd_vc1_chroma_pixels_tab[1] = ff_avg_no_rnd_vc1_chroma_mc4_mmi;
+}
+#endif /* HAVE_MMI */
+
+av_cold void ff_vc1dsp_init_mips(VC1DSPContext *dsp)
+{
+#if HAVE_MMI
+    vc1dsp_init_mmi(dsp);
+#endif /* HAVE_MMI */
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/vc1dsp_mips.h b/mythtv/external/FFmpeg/libavcodec/mips/vc1dsp_mips.h
new file mode 100644
index 00000000000..b9b07e1ce37
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mips/vc1dsp_mips.h
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2016 Zhou Xiaoyong <zhouxiaoyong@loongson.cn>
+ *
+ * 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_MIPS_VC1DSP_MIPS_H
+#define AVCODEC_MIPS_VC1DSP_MIPS_H
+
+#include "libavcodec/vc1dsp.h"
+
+void ff_put_vc1_mspel_mc00_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc01_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc02_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc03_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc10_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc11_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc12_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc13_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc20_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc21_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc22_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc23_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc30_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc31_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc32_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc33_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+
+void ff_avg_vc1_mspel_mc00_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc01_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc02_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc03_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc10_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc11_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc12_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc13_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc20_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc21_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc22_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc23_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc30_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc31_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc32_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc33_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd);
+
+
+void ff_put_vc1_mspel_mc00_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc01_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc02_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc03_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc10_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc11_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc12_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc13_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc20_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc21_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc22_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc23_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc30_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc31_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc32_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_put_vc1_mspel_mc33_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+
+void ff_avg_vc1_mspel_mc00_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc01_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc02_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc03_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc10_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc11_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc12_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc13_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc20_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc21_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc22_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc23_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc30_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc31_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc32_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+void ff_avg_vc1_mspel_mc33_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd);
+
+void ff_vc1_inv_trans_8x8_mmi(int16_t block[64]);
+void ff_vc1_inv_trans_8x4_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block);
+void ff_vc1_inv_trans_4x8_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block);
+void ff_vc1_inv_trans_4x4_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block);
+
+void ff_vc1_inv_trans_4x4_dc_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block);
+void ff_vc1_inv_trans_4x8_dc_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block);
+void ff_vc1_inv_trans_8x4_dc_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block);
+void ff_vc1_inv_trans_8x8_dc_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block);
+
+void ff_vc1_v_overlap_mmi(uint8_t *src, int stride);
+void ff_vc1_h_overlap_mmi(uint8_t *src, int stride);
+void ff_vc1_v_s_overlap_mmi(int16_t *top, int16_t *bottom);
+void ff_vc1_h_s_overlap_mmi(int16_t *left, int16_t *right);
+
+void ff_vc1_v_loop_filter4_mmi(uint8_t *src, int stride, int pq);
+void ff_vc1_h_loop_filter4_mmi(uint8_t *src, int stride, int pq);
+void ff_vc1_v_loop_filter8_mmi(uint8_t *src, int stride, int pq);
+void ff_vc1_h_loop_filter8_mmi(uint8_t *src, int stride, int pq);
+void ff_vc1_v_loop_filter16_mmi(uint8_t *src, int stride, int pq);
+void ff_vc1_h_loop_filter16_mmi(uint8_t *src, int stride, int pq);
+
+void ff_put_no_rnd_vc1_chroma_mc8_mmi(uint8_t *dst /* align 8 */,
+                                      uint8_t *src /* align 1 */,
+                                      int stride, int h, int x, int y);
+void ff_put_no_rnd_vc1_chroma_mc4_mmi(uint8_t *dst /* align 8 */,
+                                      uint8_t *src /* align 1 */,
+                                      int stride, int h, int x, int y);
+void ff_avg_no_rnd_vc1_chroma_mc8_mmi(uint8_t *dst /* align 8 */,
+                                      uint8_t *src /* align 1 */,
+                                      int stride, int h, int x, int y);
+void ff_avg_no_rnd_vc1_chroma_mc4_mmi(uint8_t *dst /* align 8 */,
+                                      uint8_t *src /* align 1 */,
+                                      int stride, int h, int x, int y);
+
+#endif /* AVCODEC_MIPS_VC1DSP_MIPS_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/vc1dsp_mmi.c b/mythtv/external/FFmpeg/libavcodec/mips/vc1dsp_mmi.c
new file mode 100644
index 00000000000..01e7f9f32c2
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mips/vc1dsp_mmi.c
@@ -0,0 +1,2081 @@
+/*
+ * VC-1 and WMV3 - DSP functions Loongson MMI-optimized
+ *
+ * Copyright (c) 2016 Zhou Xiaoyong <zhouxiaoyong@loongson.cn>
+ *
+ * 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/avassert.h"
+#include "libavcodec/vc1dsp.h"
+#include "constants.h"
+#include "vc1dsp_mips.h"
+#include "hpeldsp_mips.h"
+#include "libavutil/mips/mmiutils.h"
+
+
+#define VC1_INV_TRANCS_8_STEP1_MMI(fp1,   fp2,   fp3,   fp4,                \
+                                   o1,    o2,    o3,    o4,                 \
+                                   t1,    t2,    t3,    t4,                 \
+                                   ff_p1, ff_p2, ff_p3, ff_p4)              \
+        "pmullh     "#t1"   ,   "#fp1"  ,   "#ff_p1"                \n\t"   \
+        "pmullh     "#t2"   ,   "#fp2"  ,   "#ff_p2"                \n\t"   \
+        "pmullh     "#t3"   ,   "#fp3"  ,   "#ff_p3"                \n\t"   \
+        "pmullh     "#t4"   ,   "#fp4"  ,   "#ff_p4"                \n\t"   \
+        "paddh      "#o1"   ,   "#t1"   ,   "#t2"                   \n\t"   \
+        "paddh      "#o1"   ,   "#o1"   ,   "#t3"                   \n\t"   \
+        "paddh      "#o1"   ,   "#o1"   ,   "#t4"                   \n\t"   \
+                                                                            \
+        "pmullh     "#t1"   ,   "#fp1"  ,   "#ff_p2"                \n\t"   \
+        "pmullh     "#t2"   ,   "#fp2"  ,   "#ff_p4"                \n\t"   \
+        "pmullh     "#t3"   ,   "#fp3"  ,   "#ff_p1"                \n\t"   \
+        "pmullh     "#t4"   ,   "#fp4"  ,   "#ff_p3"                \n\t"   \
+        "psubh      "#o2"   ,   "#t1"   ,   "#t2"                   \n\t"   \
+        "psubh      "#o2"   ,   "#o2"   ,   "#t3"                   \n\t"   \
+        "psubh      "#o2"   ,   "#o2"   ,   "#t4"                   \n\t"   \
+                                                                            \
+        "pmullh     "#t1"   ,   "#fp1"  ,   "#ff_p3"                \n\t"   \
+        "pmullh     "#t2"   ,   "#fp2"  ,   "#ff_p1"                \n\t"   \
+        "pmullh     "#t3"   ,   "#fp3"  ,   "#ff_p4"                \n\t"   \
+        "pmullh     "#t4"   ,   "#fp4"  ,   "#ff_p2"                \n\t"   \
+        "psubh      "#o3"   ,   "#t1"   ,   "#t2"                   \n\t"   \
+        "paddh      "#o3"   ,   "#o3"   ,   "#t3"                   \n\t"   \
+        "paddh      "#o3"   ,   "#o3"   ,   "#t4"                   \n\t"   \
+                                                                            \
+        "pmullh     "#t1"   ,   "#fp1"  ,   "#ff_p4"                \n\t"   \
+        "pmullh     "#t2"   ,   "#fp2"  ,   "#ff_p3"                \n\t"   \
+        "pmullh     "#t3"   ,   "#fp3"  ,   "#ff_p2"                \n\t"   \
+        "pmullh     "#t4"   ,   "#fp4"  ,   "#ff_p1"                \n\t"   \
+        "psubh      "#o4"   ,   "#t1"   ,   "#t2"                   \n\t"   \
+        "paddh      "#o4"   ,   "#o4"   ,   "#t3"                   \n\t"   \
+        "psubh      "#o4"   ,   "#o4"   ,   "#t4"                   \n\t"
+
+
+#define VC1_INV_TRANCS_8_STEP2_MMI(fp1,   fp2,   fp3,   fp4,                \
+                                   fp5,   fp6,   fp7,   fp8,                \
+                                   o1,    o2,    o3,    o4,                 \
+                                   ff_p1, ff_p2, ff_p3, ff_pw)              \
+        "paddh      "#fp5"  ,   "#fp1"  ,   "#fp2"                  \n\t"   \
+        "psubh      "#fp6"  ,   "#fp1"  ,   "#fp2"                  \n\t"   \
+        "pmullh     "#fp5"  ,   "#fp5"  ,   "#ff_p1"                \n\t"   \
+        "pmullh     "#fp6"  ,   "#fp6"  ,   "#ff_p1"                \n\t"   \
+        "paddh      "#fp5"  ,   "#fp5"  ,   "#ff_pw"                \n\t"   \
+        "paddh      "#fp6"  ,   "#fp6"  ,   "#ff_pw"                \n\t"   \
+                                                                            \
+        "pmullh     "#fp1"  ,   "#fp3"  ,   "#ff_p2"                \n\t"   \
+        "pmullh     "#fp2"  ,   "#fp4"  ,   "#ff_p3"                \n\t"   \
+        "pmullh     "#fp3"  ,   "#fp3"  ,   "#ff_p3"                \n\t"   \
+        "pmullh     "#fp4"  ,   "#fp4"  ,   "#ff_p2"                \n\t"   \
+        "paddh      "#fp7"  ,   "#fp1"  ,   "#fp2"                  \n\t"   \
+        "psubh      "#fp8"  ,   "#fp3"  ,   "#fp4"                  \n\t"   \
+                                                                            \
+        "paddh      "#fp1"  ,   "#fp5"  ,   "#fp7"                  \n\t"   \
+        "paddh      "#fp2"  ,   "#fp6"  ,   "#fp8"                  \n\t"   \
+        "psubh      "#fp3"  ,   "#fp6"  ,   "#fp8"                  \n\t"   \
+        "psubh      "#fp4"  ,   "#fp5"  ,   "#fp7"                  \n\t"   \
+                                                                            \
+        "paddh      "#fp5"  ,   "#fp1"  ,   "#o1"                   \n\t"   \
+        "paddh      "#fp6"  ,   "#fp2"  ,   "#o2"                   \n\t"   \
+        "paddh      "#fp7"  ,   "#fp3"  ,   "#o3"                   \n\t"   \
+        "paddh      "#fp8"  ,   "#fp4"  ,   "#o4"                   \n\t"   \
+                                                                            \
+        "psubh      "#fp4"  ,   "#fp4"  ,   "#o4"                   \n\t"   \
+        "psubh      "#fp3"  ,   "#fp3"  ,   "#o3"                   \n\t"   \
+        "psubh      "#fp2"  ,   "#fp2"  ,   "#o2"                   \n\t"   \
+        "psubh      "#fp1"  ,   "#fp1"  ,   "#o1"                   \n\t"
+
+
+#define VC1_INV_TRANCS_4_STEP1_MMI(fp1,   fp2,   fp3,   fp4,                \
+                                   fp5,   fp6,   fp7,   fp8,                \
+                                   ff_p1, ff_p2, ff_p3, ff_pw)              \
+        "paddh      "#fp5"  ,   "#fp1"  ,   "#fp2"                  \n\t"   \
+        "psubh      "#fp6"  ,   "#fp1"  ,   "#fp2"                  \n\t"   \
+        "pmullh     "#fp5"  ,   "#fp5"  ,   "#ff_p1"                \n\t"   \
+        "pmullh     "#fp6"  ,   "#fp6"  ,   "#ff_p1"                \n\t"   \
+        "paddh      "#fp5"  ,   "#fp5"  ,   "#ff_pw"                \n\t"   \
+        "paddh      "#fp6"  ,   "#fp6"  ,   "#ff_pw"                \n\t"   \
+                                                                            \
+        "pmullh     "#fp1"  ,   "#fp3"  ,   "#ff_p2"                \n\t"   \
+        "pmullh     "#fp2"  ,   "#fp4"  ,   "#ff_p3"                \n\t"   \
+        "pmullh     "#fp3"  ,   "#fp3"  ,   "#ff_p3"                \n\t"   \
+        "pmullh     "#fp4"  ,   "#fp4"  ,   "#ff_p2"                \n\t"   \
+        "paddh      "#fp7"  ,   "#fp1"  ,   "#fp2"                  \n\t"   \
+        "psubh      "#fp8"  ,   "#fp3"  ,   "#fp4"                  \n\t"   \
+                                                                            \
+        "paddh      "#fp1"  ,   "#fp5"  ,   "#fp7"                  \n\t"   \
+        "psubh      "#fp2"  ,   "#fp6"  ,   "#fp8"                  \n\t"   \
+        "paddh      "#fp3"  ,   "#fp6"  ,   "#fp8"                  \n\t"   \
+        "psubh      "#fp4"  ,   "#fp5"  ,   "#fp7"                  \n\t"
+
+
+#define VC1_INV_TRANCS_4_STEP2_MMI(fp1, fp2, fp3, fp4,                      \
+                                   fp5, fp6, fp7, fp8, zero)                \
+        "punpcklbh  "#fp5"  ,   "#fp5"  ,   "#zero"                 \n\t"   \
+        "punpcklbh  "#fp6"  ,   "#fp6"  ,   "#zero"                 \n\t"   \
+        "punpcklbh  "#fp7"  ,   "#fp7"  ,   "#zero"                 \n\t"   \
+        "punpcklbh  "#fp8"  ,   "#fp8"  ,   "#zero"                 \n\t"   \
+                                                                            \
+        "paddh      "#fp1"  ,   "#fp1"  ,   "#fp5"                  \n\t"   \
+        "paddh      "#fp2"  ,   "#fp2"  ,   "#fp6"                  \n\t"   \
+        "paddh      "#fp3"  ,   "#fp3"  ,   "#fp7"                  \n\t"   \
+        "paddh      "#fp4"  ,   "#fp4"  ,   "#fp8"                  \n\t"   \
+                                                                            \
+        "packushb   "#fp1"  ,   "#fp1"  ,   "#zero"                 \n\t"   \
+        "packushb   "#fp2"  ,   "#fp2"  ,   "#zero"                 \n\t"   \
+        "packushb   "#fp3"  ,   "#fp3"  ,   "#zero"                 \n\t"   \
+        "packushb   "#fp4"  ,   "#fp4"  ,   "#zero"                 \n\t"
+
+
+/* Do inverse transform on 8x8 block */
+void ff_vc1_inv_trans_8x8_dc_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
+{
+    int dc = block[0];
+    double ftmp[9];
+    mips_reg addr[1];
+    int count;
+
+    dc = (3 * dc +  1) >> 1;
+    dc = (3 * dc + 16) >> 5;
+
+    __asm__ volatile(
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]                \n\t"
+        "pshufh     %[dc],      %[dc],          %[ftmp0]                \n\t"
+        "li         %[count],   0x02                                    \n\t"
+
+        "1:                                                             \n\t"
+        MMI_LDC1(%[ftmp1], %[dest], 0x00)
+        PTR_ADDU   "%[addr0],   %[dest],        %[linesize]             \n\t"
+        MMI_LDC1(%[ftmp2], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],       %[linesize]             \n\t"
+        MMI_LDC1(%[ftmp3], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],       %[linesize]             \n\t"
+        MMI_LDC1(%[ftmp4], %[addr0], 0x00)
+
+        "punpckhbh  %[ftmp5],   %[ftmp1],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp1],   %[ftmp1],       %[ftmp0]                \n\t"
+        "punpckhbh  %[ftmp6],   %[ftmp2],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp2],   %[ftmp2],       %[ftmp0]                \n\t"
+        "punpckhbh  %[ftmp7],   %[ftmp3],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp3],   %[ftmp3],       %[ftmp0]                \n\t"
+        "punpckhbh  %[ftmp8],   %[ftmp4],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp4],   %[ftmp4],       %[ftmp0]                \n\t"
+
+        "paddsh     %[ftmp1],   %[ftmp1],       %[dc]                   \n\t"
+        "paddsh     %[ftmp2],   %[ftmp2],       %[dc]                   \n\t"
+        "paddsh     %[ftmp3],   %[ftmp3],       %[dc]                   \n\t"
+        "paddsh     %[ftmp4],   %[ftmp4],       %[dc]                   \n\t"
+        "paddsh     %[ftmp5],   %[ftmp5],       %[dc]                   \n\t"
+        "paddsh     %[ftmp6],   %[ftmp6],       %[dc]                   \n\t"
+        "paddsh     %[ftmp7],   %[ftmp7],       %[dc]                   \n\t"
+        "paddsh     %[ftmp8],   %[ftmp8],       %[dc]                   \n\t"
+
+        "packushb   %[ftmp1],   %[ftmp1],       %[ftmp5]                \n\t"
+        "packushb   %[ftmp2],   %[ftmp2],       %[ftmp6]                \n\t"
+        "packushb   %[ftmp3],   %[ftmp3],       %[ftmp7]                \n\t"
+        "packushb   %[ftmp4],   %[ftmp4],       %[ftmp8]                \n\t"
+
+        MMI_SDC1(%[ftmp1], %[dest], 0x00)
+        PTR_ADDU   "%[addr0],   %[dest],        %[linesize]             \n\t"
+        MMI_SDC1(%[ftmp2], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],       %[linesize]             \n\t"
+        MMI_SDC1(%[ftmp3], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],       %[linesize]             \n\t"
+        MMI_SDC1(%[ftmp4], %[addr0], 0x00)
+
+        "addiu      %[count],   %[count],       -0x01                   \n\t"
+        PTR_ADDU   "%[dest],    %[addr0],       %[linesize]             \n\t"
+        "bnez       %[count],   1b                                      \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),
+          [addr0]"=&r"(addr[0]),
+          [count]"=&r"(count),          [dest]"+&r"(dest)
+        : [linesize]"r"((mips_reg)linesize),
+          [dc]"f"(dc)
+        : "memory"
+    );
+}
+
+#if _MIPS_SIM != _ABIO32
+void ff_vc1_inv_trans_8x8_mmi(int16_t block[64])
+{
+    DECLARE_ALIGNED(16, int16_t, temp[64]);
+    int16_t *src = block;
+    int16_t *dst = temp;
+    double ftmp[16];
+    uint32_t count, tmp[1];
+
+    // 1st loop
+    __asm__ volatile (
+        "li         %[tmp0],    0x03                                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp0]                                \n\t"
+        "li         %[count],   0x02                                    \n\t"
+
+        "1:                                                             \n\t"
+        MMI_LDC1(%[ftmp5], %[src], 0x10)
+        MMI_LDC1(%[ftmp6], %[src], 0x30)
+        MMI_LDC1(%[ftmp7], %[src], 0x50)
+        MMI_LDC1(%[ftmp8], %[src], 0x70)
+
+        VC1_INV_TRANCS_8_STEP1_MMI(%[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                                   %[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ff_pw_16], %[ff_pw_15], %[ff_pw_9],
+                                   %[ff_pw_4])
+
+        MMI_LDC1(%[ftmp1], %[src], 0x00)
+        MMI_LDC1(%[ftmp2], %[src], 0x40)
+        MMI_LDC1(%[ftmp3], %[src], 0x20)
+        MMI_LDC1(%[ftmp4], %[src], 0x60)
+
+        VC1_INV_TRANCS_8_STEP2_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                                   %[ff_pw_12], %[ff_pw_16], %[ff_pw_6],
+                                   %[ff_pw_4])
+
+
+        PSRAH_8_MMI(%[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                    %[ftmp4], %[ftmp3], %[ftmp2], %[ftmp1], %[ftmp0])
+
+        TRANSPOSE_4H(%[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                     %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                     %[ftmp13], %[tmp0],  %[ftmp14], %[ftmp15])
+
+        MMI_SDC1(%[ftmp5], %[dst], 0x00)
+        MMI_SDC1(%[ftmp6], %[dst], 0x10)
+        MMI_SDC1(%[ftmp7], %[dst], 0x20)
+        MMI_SDC1(%[ftmp8], %[dst], 0x30)
+
+        TRANSPOSE_4H(%[ftmp4], %[ftmp3], %[ftmp2], %[ftmp1],
+                     %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                     %[ftmp13], %[tmp0],  %[ftmp14], %[ftmp15])
+
+        MMI_SDC1(%[ftmp4], %[dst], 0x08)
+        MMI_SDC1(%[ftmp3], %[dst], 0x18)
+        MMI_SDC1(%[ftmp2], %[dst], 0x28)
+        MMI_SDC1(%[ftmp1], %[dst], 0x38)
+
+        "addiu      %[count],   %[count],  -0x01                        \n\t"
+        PTR_ADDIU  "%[src],     %[src],     0x08                        \n\t"
+        PTR_ADDIU  "%[dst],     %[dst],     0x40                        \n\t"
+        "bnez       %[count],   1b                                      \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),        [ftmp9]"=&f"(ftmp[9]),
+          [ftmp10]"=&f"(ftmp[10]),      [ftmp11]"=&f"(ftmp[11]),
+          [ftmp12]"=&f"(ftmp[12]),      [ftmp13]"=&f"(ftmp[13]),
+          [ftmp14]"=&f"(ftmp[14]),      [ftmp15]"=&f"(ftmp[15]),
+          [tmp0]"=&r"(tmp[0]),
+          [count]"=&r"(count),
+          [src]"+&r"(src),              [dst]"+&r"(dst)
+        : [ff_pw_4]"f"(ff_pw_4),        [ff_pw_6]"f"(ff_pw_6),
+          [ff_pw_9]"f"(ff_pw_9),        [ff_pw_12]"f"(ff_pw_12),
+          [ff_pw_15]"f"(ff_pw_15),      [ff_pw_16]"f"(ff_pw_16)
+        : "memory"
+    );
+
+    src = temp;
+    dst = block;
+
+    // 2nd loop
+    __asm__ volatile (
+        "li         %[tmp0],    0x07                                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp0]                                \n\t"
+        "li         %[count],   0x02                                    \n\t"
+
+        "1:                                                             \n\t"
+        MMI_LDC1(%[ftmp5], %[src], 0x10)
+        MMI_LDC1(%[ftmp6], %[src], 0x30)
+        MMI_LDC1(%[ftmp7], %[src], 0x50)
+        MMI_LDC1(%[ftmp8], %[src], 0x70)
+
+        VC1_INV_TRANCS_8_STEP1_MMI(%[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                                   %[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ff_pw_16], %[ff_pw_15], %[ff_pw_9],
+                                   %[ff_pw_4])
+
+        MMI_LDC1(%[ftmp1], %[src], 0x00)
+        MMI_LDC1(%[ftmp2], %[src], 0x40)
+        MMI_LDC1(%[ftmp3], %[src], 0x20)
+        MMI_LDC1(%[ftmp4], %[src], 0x60)
+
+        VC1_INV_TRANCS_8_STEP2_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                                   %[ff_pw_12], %[ff_pw_16], %[ff_pw_6],
+                                   %[ff_pw_64])
+
+        "paddh      %[ftmp4],   %[ftmp4],   %[ff_pw_1]                  \n\t"
+        "paddh      %[ftmp3],   %[ftmp3],   %[ff_pw_1]                  \n\t"
+        "paddh      %[ftmp2],   %[ftmp2],   %[ff_pw_1]                  \n\t"
+        "paddh      %[ftmp1],   %[ftmp1],   %[ff_pw_1]                  \n\t"
+
+        PSRAH_8_MMI(%[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                    %[ftmp4], %[ftmp3], %[ftmp2], %[ftmp1], %[ftmp0])
+
+        MMI_SDC1(%[ftmp5], %[dst], 0x00)
+        MMI_SDC1(%[ftmp6], %[dst], 0x10)
+        MMI_SDC1(%[ftmp7], %[dst], 0x20)
+        MMI_SDC1(%[ftmp8], %[dst], 0x30)
+
+        MMI_SDC1(%[ftmp4], %[dst], 0x40)
+        MMI_SDC1(%[ftmp3], %[dst], 0x50)
+        MMI_SDC1(%[ftmp2], %[dst], 0x60)
+        MMI_SDC1(%[ftmp1], %[dst], 0x70)
+
+        "addiu      %[count],   %[count],  -0x01                        \n\t"
+        PTR_ADDIU  "%[src],     %[src],     0x08                        \n\t"
+        PTR_ADDIU  "%[dst],     %[dst],     0x08                        \n\t"
+        "bnez       %[count],   1b                                      \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),        [ftmp9]"=&f"(ftmp[9]),
+          [ftmp10]"=&f"(ftmp[10]),      [ftmp11]"=&f"(ftmp[11]),
+          [ftmp12]"=&f"(ftmp[12]),      [ftmp13]"=&f"(ftmp[13]),
+          [ftmp14]"=&f"(ftmp[14]),      [ftmp15]"=&f"(ftmp[15]),
+          [tmp0]"=&r"(tmp[0]),
+          [count]"=&r"(count),
+          [src]"+&r"(src),              [dst]"+&r"(dst)
+        : [ff_pw_1]"f"(ff_pw_1),        [ff_pw_4]"f"(ff_pw_4),
+          [ff_pw_6]"f"(ff_pw_6),        [ff_pw_9]"f"(ff_pw_9),
+          [ff_pw_12]"f"(ff_pw_12),      [ff_pw_15]"f"(ff_pw_15),
+          [ff_pw_16]"f"(ff_pw_16),      [ff_pw_64]"f"(ff_pw_64)
+        : "memory"
+    );
+}
+#endif
+
+/* Do inverse transform on 8x4 part of block */
+void ff_vc1_inv_trans_8x4_dc_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
+{
+    int dc = block[0];
+    double ftmp[9];
+
+    dc = ( 3 * dc +  1) >> 1;
+    dc = (17 * dc + 64) >> 7;
+
+    __asm__ volatile(
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]                \n\t"
+        "pshufh     %[dc],      %[dc],          %[ftmp0]                \n\t"
+
+        MMI_LDC1(%[ftmp1], %[dest0], 0x00)
+        MMI_LDC1(%[ftmp2], %[dest1], 0x00)
+        MMI_LDC1(%[ftmp3], %[dest2], 0x00)
+        MMI_LDC1(%[ftmp4], %[dest3], 0x00)
+
+        "punpckhbh  %[ftmp5],   %[ftmp1],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp1],   %[ftmp1],       %[ftmp0]                \n\t"
+        "punpckhbh  %[ftmp6],   %[ftmp2],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp2],   %[ftmp2],       %[ftmp0]                \n\t"
+        "punpckhbh  %[ftmp7],   %[ftmp3],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp3],   %[ftmp3],       %[ftmp0]                \n\t"
+        "punpckhbh  %[ftmp8],   %[ftmp4],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp4],   %[ftmp4],       %[ftmp0]                \n\t"
+
+        "paddsh     %[ftmp1],   %[ftmp1],       %[dc]                   \n\t"
+        "paddsh     %[ftmp2],   %[ftmp2],       %[dc]                   \n\t"
+        "paddsh     %[ftmp3],   %[ftmp3],       %[dc]                   \n\t"
+        "paddsh     %[ftmp4],   %[ftmp4],       %[dc]                   \n\t"
+        "paddsh     %[ftmp5],   %[ftmp5],       %[dc]                   \n\t"
+        "paddsh     %[ftmp6],   %[ftmp6],       %[dc]                   \n\t"
+        "paddsh     %[ftmp7],   %[ftmp7],       %[dc]                   \n\t"
+        "paddsh     %[ftmp8],   %[ftmp8],       %[dc]                   \n\t"
+
+        "packushb   %[ftmp1],   %[ftmp1],       %[ftmp5]                \n\t"
+        "packushb   %[ftmp2],   %[ftmp2],       %[ftmp6]                \n\t"
+        "packushb   %[ftmp3],   %[ftmp3],       %[ftmp7]                \n\t"
+        "packushb   %[ftmp4],   %[ftmp4],       %[ftmp8]                \n\t"
+
+        MMI_SDC1(%[ftmp1], %[dest0], 0x00)
+        MMI_SDC1(%[ftmp2], %[dest1], 0x00)
+        MMI_SDC1(%[ftmp3], %[dest2], 0x00)
+        MMI_SDC1(%[ftmp4], %[dest3], 0x00)
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8])
+        : [dest0]"r"(dest+0*linesize),  [dest1]"r"(dest+1*linesize),
+          [dest2]"r"(dest+2*linesize),  [dest3]"r"(dest+3*linesize),
+          [dc]"f"(dc)
+        : "memory"
+    );
+}
+
+#if _MIPS_SIM != _ABIO32
+void ff_vc1_inv_trans_8x4_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
+{
+    int16_t *src = block;
+    int16_t *dst = block;
+    double ftmp[16];
+    uint32_t tmp[1];
+    mips_reg addr[1];
+    DECLARE_VAR_LOW32;
+
+    // 1st loop
+    __asm__ volatile (
+        MMI_LDC1(%[ftmp1], %[src], 0x00)
+        MMI_LDC1(%[ftmp2], %[src], 0x08)
+        MMI_LDC1(%[ftmp3], %[src], 0x10)
+        MMI_LDC1(%[ftmp4], %[src], 0x18)
+        MMI_LDC1(%[ftmp5], %[src], 0x20)
+        MMI_LDC1(%[ftmp6], %[src], 0x28)
+        MMI_LDC1(%[ftmp7], %[src], 0x30)
+        MMI_LDC1(%[ftmp8], %[src], 0x38)
+
+        //             a1        b1        a3        b2
+        TRANSPOSE_4H(%[ftmp1], %[ftmp3], %[ftmp5], %[ftmp7],
+                     %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                     %[ftmp13], %[tmp0],  %[ftmp14], %[ftmp15])
+
+        //             a2        b3        a4        b4
+        TRANSPOSE_4H(%[ftmp2], %[ftmp4], %[ftmp6], %[ftmp8],
+                     %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                     %[ftmp13], %[tmp0],  %[ftmp14], %[ftmp15])
+
+        // input b1 b2 b3 b4
+        VC1_INV_TRANCS_8_STEP1_MMI(%[ftmp3], %[ftmp7], %[ftmp4], %[ftmp8],
+                                   %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                                   %[ftmp0], %[ftmp13], %[ftmp14], %[ftmp15],
+                                   %[ff_pw_16], %[ff_pw_15], %[ff_pw_9],
+                                   %[ff_pw_4])
+        // input a1 a2 a3 a4
+        VC1_INV_TRANCS_8_STEP2_MMI(%[ftmp1], %[ftmp2], %[ftmp5], %[ftmp6],
+                                   %[ftmp3], %[ftmp7], %[ftmp4], %[ftmp8],
+                                   %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                                   %[ff_pw_12], %[ff_pw_16], %[ff_pw_6],
+                                   %[ff_pw_4])
+
+        "li         %[tmp0],    0x03                                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp0]                                \n\t"
+
+        PSRAH_8_MMI(%[ftmp3], %[ftmp7], %[ftmp4], %[ftmp8],
+                    %[ftmp6], %[ftmp5], %[ftmp2], %[ftmp1], %[ftmp0])
+
+        TRANSPOSE_4H(%[ftmp3], %[ftmp7], %[ftmp4], %[ftmp8],
+                     %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                     %[ftmp13], %[tmp0],  %[ftmp14], %[ftmp15])
+
+        MMI_SDC1(%[ftmp3], %[dst], 0x00)
+        MMI_SDC1(%[ftmp7], %[dst], 0x10)
+        MMI_SDC1(%[ftmp4], %[dst], 0x20)
+        MMI_SDC1(%[ftmp8], %[dst], 0x30)
+
+        TRANSPOSE_4H(%[ftmp6], %[ftmp5], %[ftmp2], %[ftmp1],
+                     %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                     %[ftmp13], %[tmp0],  %[ftmp14], %[ftmp15])
+
+        MMI_SDC1(%[ftmp6], %[dst], 0x08)
+        MMI_SDC1(%[ftmp5], %[dst], 0x18)
+        MMI_SDC1(%[ftmp2], %[dst], 0x28)
+        MMI_SDC1(%[ftmp1], %[dst], 0x38)
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),        [ftmp9]"=&f"(ftmp[9]),
+          [ftmp10]"=&f"(ftmp[10]),      [ftmp11]"=&f"(ftmp[11]),
+          [ftmp12]"=&f"(ftmp[12]),      [ftmp13]"=&f"(ftmp[13]),
+          [ftmp14]"=&f"(ftmp[14]),      [ftmp15]"=&f"(ftmp[15]),
+          [tmp0]"=&r"(tmp[0])
+        : [src]"r"(src),                [dst]"r"(dst),
+          [ff_pw_4]"f"(ff_pw_4),        [ff_pw_6]"f"(ff_pw_6),
+          [ff_pw_9]"f"(ff_pw_9),        [ff_pw_12]"f"(ff_pw_12),
+          [ff_pw_15]"f"(ff_pw_15),      [ff_pw_16]"f"(ff_pw_16)
+        : "memory"
+    );
+
+    src = block;
+
+    // 2nd loop
+    __asm__ volatile (
+        "li         %[tmp0],    0x07                                    \n\t"
+        "xor        %[ftmp0],   %[ftmp0],   %[ftmp0]                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp9]                                \n\t"
+
+        // dest low 32bit
+        MMI_LDC1(%[ftmp1], %[src], 0x00)
+        MMI_LDC1(%[ftmp2], %[src], 0x20)
+        MMI_LDC1(%[ftmp3], %[src], 0x30)
+        MMI_LDC1(%[ftmp4], %[src], 0x10)
+
+        VC1_INV_TRANCS_4_STEP1_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ff_pw_17], %[ff_pw_10], %[ff_pw_22],
+                                   %[ff_pw_64])
+
+        PSRAH_4_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4], %[ftmp9])
+
+        MMI_LWC1(%[ftmp5], %[dest], 0x00)
+        PTR_ADDU   "%[addr0],   %[dest],    %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp6], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp7], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp8], %[addr0], 0x00)
+
+        VC1_INV_TRANCS_4_STEP2_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ftmp0])
+
+        MMI_SWC1(%[ftmp1], %[dest], 0x00)
+        PTR_ADDU   "%[addr0],   %[dest],    %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp2], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp3], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp4], %[addr0], 0x00)
+
+        // dest high 32bit
+        MMI_LDC1(%[ftmp1], %[src], 0x08)
+        MMI_LDC1(%[ftmp2], %[src], 0x28)
+        MMI_LDC1(%[ftmp3], %[src], 0x38)
+        MMI_LDC1(%[ftmp4], %[src], 0x18)
+
+        VC1_INV_TRANCS_4_STEP1_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ff_pw_17], %[ff_pw_10], %[ff_pw_22],
+                                   %[ff_pw_64])
+
+        PSRAH_4_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4], %[ftmp9])
+
+        MMI_LWC1(%[ftmp5], %[dest], 0x04)
+        PTR_ADDU   "%[addr0],   %[dest],    %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp6], %[addr0], 0x04)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp7], %[addr0], 0x04)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp8], %[addr0], 0x04)
+
+        VC1_INV_TRANCS_4_STEP2_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ftmp0])
+
+        MMI_SWC1(%[ftmp1], %[dest], 0x04)
+        PTR_ADDU   "%[addr0],   %[dest],    %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp2], %[addr0], 0x04)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp3], %[addr0], 0x04)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp4], %[addr0], 0x04)
+
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),        [ftmp9]"=&f"(ftmp[9]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          [addr0]"=&r"(addr[0])
+        : [src]"r"(src),                [dest]"r"(dest),
+          [linesize]"r"((mips_reg)linesize),
+          [ff_pw_17]"f"(ff_pw_17),      [ff_pw_22]"f"(ff_pw_22),
+          [ff_pw_10]"f"(ff_pw_10),      [ff_pw_64]"f"(ff_pw_64)
+        : "memory"
+    );
+}
+#endif
+
+/* Do inverse transform on 4x8 parts of block */
+void ff_vc1_inv_trans_4x8_dc_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
+{
+    int dc = block[0];
+    double ftmp[9];
+    DECLARE_VAR_LOW32;
+
+    dc = (17 * dc +  4) >> 3;
+    dc = (12 * dc + 64) >> 7;
+
+    __asm__ volatile(
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]                \n\t"
+        "pshufh     %[dc],      %[dc],          %[ftmp0]                \n\t"
+
+        MMI_LWC1(%[ftmp1], %[dest0], 0x00)
+        MMI_LWC1(%[ftmp2], %[dest1], 0x00)
+        MMI_LWC1(%[ftmp3], %[dest2], 0x00)
+        MMI_LWC1(%[ftmp4], %[dest3], 0x00)
+        MMI_LWC1(%[ftmp5], %[dest4], 0x00)
+        MMI_LWC1(%[ftmp6], %[dest5], 0x00)
+        MMI_LWC1(%[ftmp7], %[dest6], 0x00)
+        MMI_LWC1(%[ftmp8], %[dest7], 0x00)
+
+        "punpcklbh  %[ftmp1],   %[ftmp1],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp2],   %[ftmp2],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp3],   %[ftmp3],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp4],   %[ftmp4],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp5],   %[ftmp5],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp6],   %[ftmp6],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp7],   %[ftmp7],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp8],   %[ftmp8],       %[ftmp0]                \n\t"
+
+        "paddsh     %[ftmp1],   %[ftmp1],       %[dc]                   \n\t"
+        "paddsh     %[ftmp2],   %[ftmp2],       %[dc]                   \n\t"
+        "paddsh     %[ftmp3],   %[ftmp3],       %[dc]                   \n\t"
+        "paddsh     %[ftmp4],   %[ftmp4],       %[dc]                   \n\t"
+        "paddsh     %[ftmp5],   %[ftmp5],       %[dc]                   \n\t"
+        "paddsh     %[ftmp6],   %[ftmp6],       %[dc]                   \n\t"
+        "paddsh     %[ftmp7],   %[ftmp7],       %[dc]                   \n\t"
+        "paddsh     %[ftmp8],   %[ftmp8],       %[dc]                   \n\t"
+
+        "packushb   %[ftmp1],   %[ftmp1],       %[ftmp0]                \n\t"
+        "packushb   %[ftmp2],   %[ftmp2],       %[ftmp0]                \n\t"
+        "packushb   %[ftmp3],   %[ftmp3],       %[ftmp0]                \n\t"
+        "packushb   %[ftmp4],   %[ftmp4],       %[ftmp0]                \n\t"
+        "packushb   %[ftmp5],   %[ftmp5],       %[ftmp0]                \n\t"
+        "packushb   %[ftmp6],   %[ftmp6],       %[ftmp0]                \n\t"
+        "packushb   %[ftmp7],   %[ftmp7],       %[ftmp0]                \n\t"
+        "packushb   %[ftmp8],   %[ftmp8],       %[ftmp0]                \n\t"
+
+        MMI_SWC1(%[ftmp1], %[dest0], 0x00)
+        MMI_SWC1(%[ftmp2], %[dest1], 0x00)
+        MMI_SWC1(%[ftmp3], %[dest2], 0x00)
+        MMI_SWC1(%[ftmp4], %[dest3], 0x00)
+        MMI_SWC1(%[ftmp5], %[dest4], 0x00)
+        MMI_SWC1(%[ftmp6], %[dest5], 0x00)
+        MMI_SWC1(%[ftmp7], %[dest6], 0x00)
+        MMI_SWC1(%[ftmp8], %[dest7], 0x00)
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          RESTRICT_ASM_LOW32
+          [ftmp8]"=&f"(ftmp[8])
+        : [dest0]"r"(dest+0*linesize),  [dest1]"r"(dest+1*linesize),
+          [dest2]"r"(dest+2*linesize),  [dest3]"r"(dest+3*linesize),
+          [dest4]"r"(dest+4*linesize),  [dest5]"r"(dest+5*linesize),
+          [dest6]"r"(dest+6*linesize),  [dest7]"r"(dest+7*linesize),
+          [dc]"f"(dc)
+        : "memory"
+    );
+}
+
+#if _MIPS_SIM != _ABIO32
+void ff_vc1_inv_trans_4x8_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
+{
+    int16_t *src = block;
+    int16_t *dst = block;
+    double ftmp[16];
+    uint32_t count, tmp[1];
+    mips_reg addr[1];
+    DECLARE_VAR_LOW32;
+
+    // 1st loop
+    __asm__ volatile (
+        "li         %[count],   0x02                                    \n\t"
+        "li         %[tmp0],    0x03                                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp0]                                \n\t"
+
+        "1:                                                             \n\t"
+        MMI_LDC1(%[ftmp1], %[src], 0x00)
+        MMI_LDC1(%[ftmp2], %[src], 0x10)
+        MMI_LDC1(%[ftmp3], %[src], 0x20)
+        MMI_LDC1(%[ftmp4], %[src], 0x30)
+
+        TRANSPOSE_4H(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                     %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                     %[ftmp9], %[tmp0],  %[ftmp10], %[ftmp11])
+
+        //                              t1        t2        t3        t4
+        VC1_INV_TRANCS_4_STEP1_MMI(%[ftmp1], %[ftmp3], %[ftmp4], %[ftmp2],
+                                   %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ff_pw_17], %[ff_pw_10], %[ff_pw_22],
+                                   %[ff_pw_4])
+
+        PSRAH_4_MMI(%[ftmp1], %[ftmp3], %[ftmp4], %[ftmp2], %[ftmp0])
+
+        TRANSPOSE_4H(%[ftmp1], %[ftmp3], %[ftmp4], %[ftmp2],
+                     %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                     %[ftmp9], %[tmp0],  %[ftmp10], %[ftmp11])
+
+        MMI_SDC1(%[ftmp1], %[dst], 0x00)
+        MMI_SDC1(%[ftmp3], %[dst], 0x10)
+        MMI_SDC1(%[ftmp4], %[dst], 0x20)
+        MMI_SDC1(%[ftmp2], %[dst], 0x30)
+
+        "addiu      %[count],   %[count],  -0x01                        \n\t"
+        PTR_ADDIU  "%[src],     %[src],     0x40                        \n\t"
+        PTR_ADDIU  "%[dst],     %[dst],     0x40                        \n\t"
+        "bnez       %[count],   1b                                      \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),        [ftmp9]"=&f"(ftmp[9]),
+          [ftmp10]"=&f"(ftmp[10]),      [ftmp11]"=&f"(ftmp[11]),
+          [tmp0]"=&r"(tmp[0]),
+          [count]"=&r"(count),
+          [src]"+&r"(src),              [dst]"+&r"(dst)
+        : [ff_pw_17]"f"(ff_pw_17),      [ff_pw_10]"f"(ff_pw_10),
+          [ff_pw_22]"f"(ff_pw_22),      [ff_pw_4]"f"(ff_pw_4)
+        : "memory"
+    );
+
+    src = block;
+
+    // 2nd loop
+    __asm__ volatile (
+        "li         %[tmp0],    0x07                                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp0]                                \n\t"
+
+        MMI_LDC1(%[ftmp5], %[src], 0x10)
+        MMI_LDC1(%[ftmp6], %[src], 0x30)
+        MMI_LDC1(%[ftmp7], %[src], 0x50)
+        MMI_LDC1(%[ftmp8], %[src], 0x70)
+
+        VC1_INV_TRANCS_8_STEP1_MMI(%[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                                   %[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ff_pw_16], %[ff_pw_15], %[ff_pw_9],
+                                   %[ff_pw_4])
+
+        MMI_LDC1(%[ftmp1], %[src], 0x00)
+        MMI_LDC1(%[ftmp2], %[src], 0x40)
+        MMI_LDC1(%[ftmp3], %[src], 0x20)
+        MMI_LDC1(%[ftmp4], %[src], 0x60)
+
+        VC1_INV_TRANCS_8_STEP2_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                                   %[ff_pw_12], %[ff_pw_16], %[ff_pw_6],
+                                   %[ff_pw_64])
+
+        "paddh      %[ftmp4],   %[ftmp4],   %[ff_pw_1]                  \n\t"
+        "paddh      %[ftmp3],   %[ftmp3],   %[ff_pw_1]                  \n\t"
+        "paddh      %[ftmp2],   %[ftmp2],   %[ff_pw_1]                  \n\t"
+        "paddh      %[ftmp1],   %[ftmp1],   %[ff_pw_1]                  \n\t"
+
+        PSRAH_8_MMI(%[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                    %[ftmp4], %[ftmp3], %[ftmp2], %[ftmp1], %[ftmp0])
+
+        "xor        %[ftmp0],   %[ftmp0],   %[ftmp0]                    \n\t"
+
+        // dest low
+        MMI_LWC1(%[ftmp9], %[dest], 0x00)
+        PTR_ADDU   "%[addr0],   %[dest],    %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp10], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp11], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp12], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+
+        VC1_INV_TRANCS_4_STEP2_MMI(%[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                                   %[ftmp0])
+
+        // dest high
+        MMI_LWC1(%[ftmp9], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp10], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp11], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp12], %[addr0], 0x00)
+
+        VC1_INV_TRANCS_4_STEP2_MMI(%[ftmp4], %[ftmp3], %[ftmp2], %[ftmp1],
+                                   %[ftmp9], %[ftmp10], %[ftmp11], %[ftmp12],
+                                   %[ftmp0])
+
+        // dest low
+        MMI_SWC1(%[ftmp5], %[dest], 0x00)
+        PTR_ADDU   "%[addr0],   %[dest],    %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp6], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp7], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp8], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+
+        // dest high
+        MMI_SWC1(%[ftmp4], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp3], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp2], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp1], %[addr0], 0x00)
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),        [ftmp9]"=&f"(ftmp[9]),
+          [ftmp10]"=&f"(ftmp[10]),      [ftmp11]"=&f"(ftmp[11]),
+          [ftmp12]"=&f"(ftmp[12]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          [addr0]"=&r"(addr[0]),
+          [dest]"+&r"(dest)
+        : [src]"r"(src),                [linesize]"r"(linesize),
+          [ff_pw_1]"f"(ff_pw_1),        [ff_pw_4]"f"(ff_pw_4),
+          [ff_pw_6]"f"(ff_pw_6),        [ff_pw_9]"f"(ff_pw_9),
+          [ff_pw_12]"f"(ff_pw_12),      [ff_pw_15]"f"(ff_pw_15),
+          [ff_pw_16]"f"(ff_pw_16),      [ff_pw_64]"f"(ff_pw_64)
+        : "memory"
+    );
+}
+#endif
+
+/* Do inverse transform on 4x4 part of block */
+void ff_vc1_inv_trans_4x4_dc_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
+{
+    int dc = block[0];
+    double ftmp[5];
+    DECLARE_VAR_LOW32;
+
+    dc = (17 * dc +  4) >> 3;
+    dc = (17 * dc + 64) >> 7;
+
+    __asm__ volatile(
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]                \n\t"
+        "pshufh     %[dc],      %[dc],          %[ftmp0]                \n\t"
+
+        MMI_LWC1(%[ftmp1], %[dest0], 0x00)
+        MMI_LWC1(%[ftmp2], %[dest1], 0x00)
+        MMI_LWC1(%[ftmp3], %[dest2], 0x00)
+        MMI_LWC1(%[ftmp4], %[dest3], 0x00)
+
+        "punpcklbh  %[ftmp1],   %[ftmp1],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp2],   %[ftmp2],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp3],   %[ftmp3],       %[ftmp0]                \n\t"
+        "punpcklbh  %[ftmp4],   %[ftmp4],       %[ftmp0]                \n\t"
+
+        "paddsh     %[ftmp1],   %[ftmp1],       %[dc]                   \n\t"
+        "paddsh     %[ftmp2],   %[ftmp2],       %[dc]                   \n\t"
+        "paddsh     %[ftmp3],   %[ftmp3],       %[dc]                   \n\t"
+        "paddsh     %[ftmp4],   %[ftmp4],       %[dc]                   \n\t"
+
+        "packushb   %[ftmp1],   %[ftmp1],       %[ftmp0]                \n\t"
+        "packushb   %[ftmp2],   %[ftmp2],       %[ftmp0]                \n\t"
+        "packushb   %[ftmp3],   %[ftmp3],       %[ftmp0]                \n\t"
+        "packushb   %[ftmp4],   %[ftmp4],       %[ftmp0]                \n\t"
+
+        MMI_SWC1(%[ftmp1], %[dest0], 0x00)
+        MMI_SWC1(%[ftmp2], %[dest1], 0x00)
+        MMI_SWC1(%[ftmp3], %[dest2], 0x00)
+        MMI_SWC1(%[ftmp4], %[dest3], 0x00)
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          RESTRICT_ASM_LOW32
+          [ftmp4]"=&f"(ftmp[4])
+        : [dest0]"r"(dest+0*linesize),  [dest1]"r"(dest+1*linesize),
+          [dest2]"r"(dest+2*linesize),  [dest3]"r"(dest+3*linesize),
+          [dc]"f"(dc)
+        : "memory"
+    );
+}
+
+void ff_vc1_inv_trans_4x4_mmi(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
+{
+    int16_t *src = block;
+    int16_t *dst = block;
+    double ftmp[12];
+    uint32_t tmp[1];
+    mips_reg addr[1];
+    DECLARE_VAR_LOW32;
+
+    // 1st loop
+    __asm__ volatile (
+        "li         %[tmp0],    0x03                                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp0]                                \n\t"
+
+        MMI_LDC1(%[ftmp1], %[src], 0x00)
+        MMI_LDC1(%[ftmp2], %[src], 0x10)
+        MMI_LDC1(%[ftmp3], %[src], 0x20)
+        MMI_LDC1(%[ftmp4], %[src], 0x30)
+
+        TRANSPOSE_4H(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                     %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                     %[ftmp9], %[tmp0],  %[ftmp10], %[ftmp11])
+
+        //                              t1        t2        t3        t4
+        VC1_INV_TRANCS_4_STEP1_MMI(%[ftmp1], %[ftmp3], %[ftmp4], %[ftmp2],
+                                   %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ff_pw_17], %[ff_pw_10], %[ff_pw_22],
+                                   %[ff_pw_4])
+
+        PSRAH_4_MMI(%[ftmp1], %[ftmp3], %[ftmp4], %[ftmp2], %[ftmp0])
+
+        TRANSPOSE_4H(%[ftmp1], %[ftmp3], %[ftmp4], %[ftmp2],
+                     %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                     %[ftmp9], %[tmp0],  %[ftmp10], %[ftmp11])
+
+        MMI_SDC1(%[ftmp1], %[dst], 0x00)
+        MMI_SDC1(%[ftmp3], %[dst], 0x10)
+        MMI_SDC1(%[ftmp4], %[dst], 0x20)
+        MMI_SDC1(%[ftmp2], %[dst], 0x30)
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),        [ftmp9]"=&f"(ftmp[9]),
+          [ftmp10]"=&f"(ftmp[10]),      [ftmp11]"=&f"(ftmp[11]),
+          [tmp0]"=&r"(tmp[0]),
+          [src]"+&r"(src),              [dst]"+&r"(dst)
+        : [ff_pw_17]"f"(ff_pw_17),      [ff_pw_10]"f"(ff_pw_10),
+          [ff_pw_22]"f"(ff_pw_22),      [ff_pw_4]"f"(ff_pw_4)
+        : "memory"
+    );
+
+    src = block;
+
+    // 2nd loop
+    __asm__ volatile (
+        "li         %[tmp0],    0x07                                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp0]                                \n\t"
+
+        // dest low 32bit
+        MMI_LDC1(%[ftmp1], %[src], 0x00)
+        MMI_LDC1(%[ftmp2], %[src], 0x20)
+        MMI_LDC1(%[ftmp3], %[src], 0x30)
+        MMI_LDC1(%[ftmp4], %[src], 0x10)
+
+        VC1_INV_TRANCS_4_STEP1_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ff_pw_17], %[ff_pw_10], %[ff_pw_22],
+                                   %[ff_pw_64])
+
+        PSRAH_4_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4], %[ftmp0])
+
+        MMI_LWC1(%[ftmp5], %[dest], 0x00)
+        PTR_ADDU   "%[addr0],   %[dest],    %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp6], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp7], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_LWC1(%[ftmp8], %[addr0], 0x00)
+
+        "xor        %[ftmp9],   %[ftmp9],  %[ftmp9]                     \n\t"
+
+        VC1_INV_TRANCS_4_STEP2_MMI(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                                   %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                                   %[ftmp9])
+
+        MMI_SWC1(%[ftmp1], %[dest], 0x00)
+        PTR_ADDU   "%[addr0],   %[dest],    %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp2], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp3], %[addr0], 0x00)
+        PTR_ADDU   "%[addr0],   %[addr0],   %[linesize]                 \n\t"
+        MMI_SWC1(%[ftmp4], %[addr0], 0x00)
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),        [ftmp9]"=&f"(ftmp[9]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          [addr0]"=&r"(addr[0])
+        : [src]"r"(src),                [dest]"r"(dest),
+          [linesize]"r"((mips_reg)linesize),
+          [ff_pw_17]"f"(ff_pw_17),      [ff_pw_22]"f"(ff_pw_22),
+          [ff_pw_10]"f"(ff_pw_10),      [ff_pw_64]"f"(ff_pw_64)
+        : "memory"
+    );
+}
+
+/* Apply overlap transform to horizontal edge */
+void ff_vc1_h_overlap_mmi(uint8_t *src, int stride)
+{
+    int i;
+    int a, b, c, d;
+    int d1, d2;
+    int rnd = 1;
+    for (i = 0; i < 8; i++) {
+        a  = src[-2];
+        b  = src[-1];
+        c  = src[0];
+        d  = src[1];
+        d1 = (a - d + 3 + rnd) >> 3;
+        d2 = (a - d + b - c + 4 - rnd) >> 3;
+
+        src[-2] = a - d1;
+        src[-1] = av_clip_uint8(b - d2);
+        src[0]  = av_clip_uint8(c + d2);
+        src[1]  = d + d1;
+        src    += stride;
+        rnd     = !rnd;
+    }
+}
+
+void ff_vc1_h_s_overlap_mmi(int16_t *left, int16_t *right)
+{
+    int i;
+    int a, b, c, d;
+    int d1, d2;
+    int rnd1 = 4, rnd2 = 3;
+    for (i = 0; i < 8; i++) {
+        a  = left[6];
+        b  = left[7];
+        c  = right[0];
+        d  = right[1];
+        d1 = a - d;
+        d2 = a - d + b - c;
+
+        left[6]  = ((a << 3) - d1 + rnd1) >> 3;
+        left[7]  = ((b << 3) - d2 + rnd2) >> 3;
+        right[0] = ((c << 3) + d2 + rnd1) >> 3;
+        right[1] = ((d << 3) + d1 + rnd2) >> 3;
+
+        right += 8;
+        left  += 8;
+        rnd2   = 7 - rnd2;
+        rnd1   = 7 - rnd1;
+    }
+}
+
+/* Apply overlap transform to vertical edge */
+void ff_vc1_v_overlap_mmi(uint8_t *src, int stride)
+{
+    int i;
+    int a, b, c, d;
+    int d1, d2;
+    int rnd = 1;
+    for (i = 0; i < 8; i++) {
+        a  = src[-2 * stride];
+        b  = src[-stride];
+        c  = src[0];
+        d  = src[stride];
+        d1 = (a - d + 3 + rnd) >> 3;
+        d2 = (a - d + b - c + 4 - rnd) >> 3;
+
+        src[-2 * stride] = a - d1;
+        src[-stride]     = av_clip_uint8(b - d2);
+        src[0]           = av_clip_uint8(c + d2);
+        src[stride]      = d + d1;
+        src++;
+        rnd = !rnd;
+    }
+}
+
+void ff_vc1_v_s_overlap_mmi(int16_t *top, int16_t *bottom)
+{
+    int i;
+    int a, b, c, d;
+    int d1, d2;
+    int rnd1 = 4, rnd2 = 3;
+    for (i = 0; i < 8; i++) {
+        a  = top[48];
+        b  = top[56];
+        c  = bottom[0];
+        d  = bottom[8];
+        d1 = a - d;
+        d2 = a - d + b - c;
+
+        top[48]   = ((a << 3) - d1 + rnd1) >> 3;
+        top[56]   = ((b << 3) - d2 + rnd2) >> 3;
+        bottom[0] = ((c << 3) + d2 + rnd1) >> 3;
+        bottom[8] = ((d << 3) + d1 + rnd2) >> 3;
+
+        bottom++;
+        top++;
+        rnd2 = 7 - rnd2;
+        rnd1 = 7 - rnd1;
+    }
+}
+
+/**
+ * VC-1 in-loop deblocking filter for one line
+ * @param src source block type
+ * @param stride block stride
+ * @param pq block quantizer
+ * @return whether other 3 pairs should be filtered or not
+ * @see 8.6
+ */
+static av_always_inline int vc1_filter_line(uint8_t *src, int stride, int pq)
+{
+    int a0 = (2 * (src[-2 * stride] - src[1 * stride]) -
+              5 * (src[-1 * stride] - src[0 * stride]) + 4) >> 3;
+    int a0_sign = a0 >> 31;        /* Store sign */
+
+    a0 = (a0 ^ a0_sign) - a0_sign; /* a0 = FFABS(a0); */
+    if (a0 < pq) {
+        int a1 = FFABS((2 * (src[-4 * stride] - src[-1 * stride]) -
+                        5 * (src[-3 * stride] - src[-2 * stride]) + 4) >> 3);
+        int a2 = FFABS((2 * (src[ 0 * stride] - src[ 3 * stride]) -
+                        5 * (src[ 1 * stride] - src[ 2 * stride]) + 4) >> 3);
+        if (a1 < a0 || a2 < a0) {
+            int clip      = src[-1 * stride] - src[0 * stride];
+            int clip_sign = clip >> 31;
+
+            clip = ((clip ^ clip_sign) - clip_sign) >> 1;
+            if (clip) {
+                int a3     = FFMIN(a1, a2);
+                int d      = 5 * (a3 - a0);
+                int d_sign = (d >> 31);
+
+                d       = ((d ^ d_sign) - d_sign) >> 3;
+                d_sign ^= a0_sign;
+
+                if (d_sign ^ clip_sign)
+                    d = 0;
+                else {
+                    d = FFMIN(d, clip);
+                    d = (d ^ d_sign) - d_sign; /* Restore sign */
+                    src[-1 * stride] = av_clip_uint8(src[-1 * stride] - d);
+                    src[ 0 * stride] = av_clip_uint8(src[ 0 * stride] + d);
+                }
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+/**
+ * VC-1 in-loop deblocking filter
+ * @param src source block type
+ * @param step distance between horizontally adjacent elements
+ * @param stride distance between vertically adjacent elements
+ * @param len edge length to filter (4 or 8 pixels)
+ * @param pq block quantizer
+ * @see 8.6
+ */
+static inline void vc1_loop_filter(uint8_t *src, int step, int stride,
+                                   int len, int pq)
+{
+    int i;
+    int filt3;
+
+    for (i = 0; i < len; i += 4) {
+        filt3 = vc1_filter_line(src + 2 * step, stride, pq);
+        if (filt3) {
+            vc1_filter_line(src + 0 * step, stride, pq);
+            vc1_filter_line(src + 1 * step, stride, pq);
+            vc1_filter_line(src + 3 * step, stride, pq);
+        }
+        src += step * 4;
+    }
+}
+
+void ff_vc1_v_loop_filter4_mmi(uint8_t *src, int stride, int pq)
+{
+    vc1_loop_filter(src, 1, stride, 4, pq);
+}
+
+void ff_vc1_h_loop_filter4_mmi(uint8_t *src, int stride, int pq)
+{
+    vc1_loop_filter(src, stride, 1, 4, pq);
+}
+
+void ff_vc1_v_loop_filter8_mmi(uint8_t *src, int stride, int pq)
+{
+    vc1_loop_filter(src, 1, stride, 8, pq);
+}
+
+void ff_vc1_h_loop_filter8_mmi(uint8_t *src, int stride, int pq)
+{
+    vc1_loop_filter(src, stride, 1, 8, pq);
+}
+
+void ff_vc1_v_loop_filter16_mmi(uint8_t *src, int stride, int pq)
+{
+    vc1_loop_filter(src, 1, stride, 16, pq);
+}
+
+void ff_vc1_h_loop_filter16_mmi(uint8_t *src, int stride, int pq)
+{
+    vc1_loop_filter(src, stride, 1, 16, pq);
+}
+
+void ff_put_vc1_mspel_mc00_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd)
+{
+    ff_put_pixels8_8_mmi(dst, src, stride, 8);
+}
+void ff_put_vc1_mspel_mc00_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd)
+{
+    ff_put_pixels16_8_mmi(dst, src, stride, 16);
+}
+void ff_avg_vc1_mspel_mc00_mmi(uint8_t *dst, const uint8_t *src,
+                               ptrdiff_t stride, int rnd)
+{
+    ff_avg_pixels8_8_mmi(dst, src, stride, 8);
+}
+void ff_avg_vc1_mspel_mc00_16_mmi(uint8_t *dst, const uint8_t *src,
+                                  ptrdiff_t stride, int rnd)
+{
+    ff_avg_pixels16_8_mmi(dst, src, stride, 16);
+}
+
+#define OP_PUT(S, D)
+#define OP_AVG(S, D)                                                        \
+    "ldc1       $f16,   "#S"                        \n\t"                   \
+    "pavgb      "#D",   "#D",   $f16                \n\t"
+
+/** Add rounder from $f14 to $f6 and pack result at destination */
+#define NORMALIZE_MMI(SHIFT)                                                \
+    "paddh      $f6,    $f6,    $f14                \n\t" /* +bias-r */     \
+    "paddh      $f8,    $f8,    $f14                \n\t" /* +bias-r */     \
+    "psrah      $f6,    $f6,    "SHIFT"             \n\t"                   \
+    "psrah      $f8,    $f8,    "SHIFT"             \n\t"
+
+#define TRANSFER_DO_PACK(OP)                                                \
+    "packushb   $f6,    $f6,    $f8                 \n\t"                   \
+    OP((%[dst]), $f6)                                                       \
+    "sdc1       $f6,    0x00(%[dst])                \n\t"
+
+#define TRANSFER_DONT_PACK(OP)                                              \
+     OP(0(%[dst]), $f6)                                                     \
+     OP(8(%[dst]), $f8)                                                     \
+     "sdc1      $f6,    0x00(%[dst])                \n\t"                   \
+     "sdc1      $f8,    0x08(%[dst])                \n\t"
+
+/** @see MSPEL_FILTER13_CORE for use as UNPACK macro */
+#define DO_UNPACK(reg)                                                      \
+    "punpcklbh  "reg",  "reg",  $f0                 \n\t"
+#define DONT_UNPACK(reg)
+
+/** Compute the rounder 32-r or 8-r and unpacks it to $f14 */
+#define LOAD_ROUNDER_MMI(ROUND)                                             \
+    "lwc1       $f14,   "ROUND"                     \n\t"                   \
+    "punpcklhw  $f14,   $f14,   $f14                \n\t"                   \
+    "punpcklwd  $f14,   $f14,   $f14                \n\t"
+
+
+#define SHIFT2_LINE(OFF, R0, R1, R2, R3)                                    \
+    "paddh      "#R1",      "#R1",  "#R2"           \n\t"                   \
+    PTR_ADDU    "$9,        %[src], %[stride1]      \n\t"                   \
+    MMI_ULWC1(R0, $9, 0x00)                                                 \
+    "pmullh     "#R1",      "#R1",  $f6             \n\t"                   \
+    "punpcklbh  "#R0",      "#R0",  $f0             \n\t"                   \
+    PTR_ADDU    "$9,        %[src], %[stride]       \n\t"                   \
+    MMI_ULWC1(R3, $9, 0x00)                                                 \
+    "psubh      "#R1",      "#R1",  "#R0"           \n\t"                   \
+    "punpcklbh  "#R3",      "#R3",  $f0             \n\t"                   \
+    "paddh      "#R1",      "#R1",  $f14            \n\t"                   \
+    "psubh      "#R1",      "#R1",  "#R3"           \n\t"                   \
+    "psrah      "#R1",      "#R1",  %[shift]        \n\t"                   \
+    MMI_SDC1(R1, %[dst], OFF)                                               \
+    PTR_ADDU    "%[src],    %[src], %[stride]       \n\t"
+
+/** Sacrificing $f12 makes it possible to pipeline loads from src */
+static void vc1_put_ver_16b_shift2_mmi(int16_t *dst,
+                                       const uint8_t *src, mips_reg stride,
+                                       int rnd, int64_t shift)
+{
+    DECLARE_VAR_LOW32;
+    DECLARE_VAR_ADDRT;
+
+    __asm__ volatile(
+        "xor        $f0,    $f0,    $f0             \n\t"
+        "li         $8,     0x03                    \n\t"
+        LOAD_ROUNDER_MMI("%[rnd]")
+        "ldc1       $f12,   %[ff_pw_9]              \n\t"
+        "1:                                         \n\t"
+        MMI_ULWC1($f4, %[src], 0x00)
+        PTR_ADDU   "%[src], %[src], %[stride]       \n\t"
+        MMI_ULWC1($f6, %[src], 0x00)
+        "punpcklbh  $f4,    $f4,    $f0             \n\t"
+        "punpcklbh  $f6,    $f6,    $f0             \n\t"
+        SHIFT2_LINE(  0, $f2, $f4, $f6, $f8)
+        SHIFT2_LINE( 24, $f4, $f6, $f8, $f2)
+        SHIFT2_LINE( 48, $f6, $f8, $f2, $f4)
+        SHIFT2_LINE( 72, $f8, $f2, $f4, $f6)
+        SHIFT2_LINE( 96, $f2, $f4, $f6, $f8)
+        SHIFT2_LINE(120, $f4, $f6, $f8, $f2)
+        SHIFT2_LINE(144, $f6, $f8, $f2, $f4)
+        SHIFT2_LINE(168, $f8, $f2, $f4, $f6)
+        PTR_SUBU   "%[src], %[src], %[stride2]      \n\t"
+        PTR_ADDIU  "%[dst], %[dst], 0x08            \n\t"
+        "addiu      $8,     $8,    -0x01            \n\t"
+        "bnez       $8,     1b                      \n\t"
+        : RESTRICT_ASM_LOW32            RESTRICT_ASM_ADDRT
+          [src]"+r"(src),               [dst]"+r"(dst)
+        : [stride]"r"(stride),          [stride1]"r"(-2*stride),
+          [shift]"f"(shift),            [rnd]"m"(rnd),
+          [stride2]"r"(9*stride-4),     [ff_pw_9]"m"(ff_pw_9)
+        : "$8", "$9", "$f0", "$f2", "$f4", "$f6", "$f8", "$f10", "$f12",
+          "$f14", "$f16", "memory"
+    );
+}
+
+/**
+ * Data is already unpacked, so some operations can directly be made from
+ * memory.
+ */
+#define VC1_HOR_16B_SHIFT2(OP, OPNAME)                                      \
+static void OPNAME ## vc1_hor_16b_shift2_mmi(uint8_t *dst, mips_reg stride, \
+                                             const int16_t *src, int rnd)   \
+{                                                                           \
+    int h = 8;                                                              \
+    DECLARE_VAR_ALL64;                                                      \
+    DECLARE_VAR_ADDRT;                                                      \
+                                                                            \
+    src -= 1;                                                               \
+    rnd -= (-1+9+9-1)*1024; /* Add -1024 bias */                            \
+                                                                            \
+    __asm__ volatile(                                                       \
+        LOAD_ROUNDER_MMI("%[rnd]")                                          \
+        "ldc1       $f12,   %[ff_pw_128]            \n\t"                   \
+        "ldc1       $f10,   %[ff_pw_9]              \n\t"                   \
+        "1:                                         \n\t"                   \
+        MMI_ULDC1($f2, %[src], 0x00)                                        \
+        MMI_ULDC1($f4, %[src], 0x08)                                        \
+        MMI_ULDC1($f6, %[src], 0x02)                                        \
+        MMI_ULDC1($f8, %[src], 0x0a)                                        \
+        MMI_ULDC1($f0, %[src], 0x06)                                        \
+        "paddh      $f2,    $f2,    $f0             \n\t"                   \
+        MMI_ULDC1($f0, %[src], 0x0e)                                        \
+        "paddh      $f4,    $f4,    $f0             \n\t"                   \
+        MMI_ULDC1($f0, %[src], 0x04)                                        \
+        "paddh      $f6,    $f6,    $f0             \n\t"                   \
+        MMI_ULDC1($f0, %[src], 0x0b)                                        \
+        "paddh      $f8,    $f8,    $f0             \n\t"                   \
+        "pmullh     $f6,    $f6,    $f10            \n\t"                   \
+        "pmullh     $f8,    $f8,    $f10            \n\t"                   \
+        "psubh      $f6,    $f6,    $f2             \n\t"                   \
+        "psubh      $f8,    $f8,    $f4             \n\t"                   \
+        "li         $8,     0x07                    \n\t"                   \
+        "mtc1       $8,     $f16                    \n\t"                   \
+        NORMALIZE_MMI("$f16")                                               \
+        /* Remove bias */                                                   \
+        "paddh      $f6,    $f6,    $f12            \n\t"                   \
+        "paddh      $f8,    $f8,    $f12            \n\t"                   \
+        TRANSFER_DO_PACK(OP)                                                \
+        "addiu      %[h],   %[h],  -0x01            \n\t"                   \
+        PTR_ADDIU  "%[src], %[src], 0x18            \n\t"                   \
+        PTR_ADDU   "%[dst], %[dst], %[stride]       \n\t"                   \
+        "bnez       %[h],   1b                      \n\t"                   \
+        : RESTRICT_ASM_ALL64            RESTRICT_ASM_ADDRT                  \
+          [h]"+r"(h),                                                       \
+          [src]"+r"(src),               [dst]"+r"(dst)                      \
+        : [stride]"r"(stride),          [rnd]"m"(rnd),                      \
+          [ff_pw_9]"m"(ff_pw_9),        [ff_pw_128]"m"(ff_pw_128)           \
+        : "$8", "$f0", "$f2", "$f4", "$f6", "$f8", "$f10", "$f12", "$f14",  \
+          "$f16", "memory"                                                  \
+    );                                                                      \
+}
+
+VC1_HOR_16B_SHIFT2(OP_PUT, put_)
+VC1_HOR_16B_SHIFT2(OP_AVG, avg_)
+
+/**
+ * Purely vertical or horizontal 1/2 shift interpolation.
+ * Sacrify $f12 for *9 factor.
+ */
+#define VC1_SHIFT2(OP, OPNAME)\
+static void OPNAME ## vc1_shift2_mmi(uint8_t *dst, const uint8_t *src,      \
+                                     mips_reg stride, int rnd,              \
+                                     mips_reg offset)                       \
+{                                                                           \
+    DECLARE_VAR_LOW32;                                                      \
+    DECLARE_VAR_ADDRT;                                                      \
+                                                                            \
+    rnd = 8 - rnd;                                                          \
+                                                                            \
+    __asm__ volatile(                                                       \
+        "xor        $f0,    $f0,    $f0             \n\t"                   \
+        "li         $10,    0x08                    \n\t"                   \
+        LOAD_ROUNDER_MMI("%[rnd]")                                          \
+        "ldc1       $f12,   %[ff_pw_9]              \n\t"                   \
+        "1:                                         \n\t"                   \
+        MMI_ULWC1($f6, %[src], 0x00)                                        \
+        MMI_ULWC1($f8, %[src], 0x04)                                        \
+        PTR_ADDU   "$9,     %[src], %[offset]       \n\t"                   \
+        MMI_ULWC1($f2, $9, 0x00)                                            \
+        MMI_ULWC1($f4, $9, 0x04)                                            \
+        PTR_ADDU   "%[src], %[src], %[offset]       \n\t"                   \
+        "punpcklbh  $f6,    $f6,    $f0             \n\t"                   \
+        "punpcklbh  $f8,    $f8,    $f0             \n\t"                   \
+        "punpcklbh  $f2,    $f2,    $f0             \n\t"                   \
+        "punpcklbh  $f4,    $f4,    $f0             \n\t"                   \
+        "paddh      $f6,    $f6,    $f2             \n\t"                   \
+        "paddh      $f8,    $f8,    $f4             \n\t"                   \
+        PTR_ADDU   "$9,     %[src], %[offset_x2n]   \n\t"                   \
+        MMI_ULWC1($f2, $9, 0x00)                                            \
+        MMI_ULWC1($f4, $9, 0x04)                                            \
+        "pmullh     $f6,    $f6,    $f12            \n\t" /* 0,9,9,0*/      \
+        "pmullh     $f8,    $f8,    $f12            \n\t" /* 0,9,9,0*/      \
+        "punpcklbh  $f2,    $f2,    $f0             \n\t"                   \
+        "punpcklbh  $f4,    $f4,    $f0             \n\t"                   \
+        "psubh      $f6,    $f6,    $f2             \n\t" /*-1,9,9,0*/      \
+        "psubh      $f8,    $f8,    $f4             \n\t" /*-1,9,9,0*/      \
+        PTR_ADDU   "$9,     %[src], %[offset]       \n\t"                   \
+        MMI_ULWC1($f2, $9, 0x00)                                            \
+        MMI_ULWC1($f4, $9, 0x04)                                            \
+        "punpcklbh  $f2,    $f2,    $f0             \n\t"                   \
+        "punpcklbh  $f4,    $f4,    $f0             \n\t"                   \
+        "psubh      $f6,    $f6,    $f2             \n\t" /*-1,9,9,-1*/     \
+        "psubh      $f8,    $f8,    $f4             \n\t" /*-1,9,9,-1*/     \
+        "li         $8,     0x04                    \n\t"                   \
+        "mtc1       $8,     $f16                    \n\t"                   \
+        NORMALIZE_MMI("$f16")                                               \
+        "packushb   $f6,    $f6,    $f8             \n\t"                   \
+        OP((%[dst]), $f6)                                                   \
+        "sdc1       $f6,    0x00(%[dst])            \n\t"                   \
+        "addiu      $10,    $10,   -0x01            \n\t"                   \
+        PTR_ADDU   "%[src], %[src], %[stride1]      \n\t"                   \
+        PTR_ADDU   "%[dst], %[dst], %[stride]       \n\t"                   \
+        "bnez       $10,    1b                      \n\t"                   \
+        : RESTRICT_ASM_LOW32            RESTRICT_ASM_ADDRT                  \
+          [src]"+r"(src),               [dst]"+r"(dst)                      \
+        : [offset]"r"(offset),          [offset_x2n]"r"(-2*offset),         \
+          [stride]"g"(stride),          [rnd]"m"(rnd),                      \
+          [stride1]"g"(stride-offset),                                      \
+          [ff_pw_9]"m"(ff_pw_9)                                             \
+        : "$8", "$9", "$10", "$f0", "$f2", "$f4", "$f6", "$f8", "$f10",     \
+          "$f12", "$f14", "$f16", "memory"                                  \
+    );                                                                      \
+}
+
+VC1_SHIFT2(OP_PUT, put_)
+VC1_SHIFT2(OP_AVG, avg_)
+
+/**
+ * Core of the 1/4 and 3/4 shift bicubic interpolation.
+ *
+ * @param UNPACK  Macro unpacking arguments from 8 to 16bits (can be empty).
+ * @param LOAD    "MMI_ULWC1" or "MMI_ULDC1", if data read is already unpacked.
+ * @param M       "1" for MMI_ULWC1, "2" for MMI_ULDC1.
+ * @param A1      Stride address of 1st tap (beware of unpacked/packed).
+ * @param A2      Stride address of 2nd tap
+ * @param A3      Stride address of 3rd tap
+ * @param A4      Stride address of 4th tap
+ */
+#define MSPEL_FILTER13_CORE(UNPACK, LOAD, M, A1, A2, A3, A4)                \
+    PTR_ADDU   "$9,     %[src], "#A1"           \n\t"                       \
+    LOAD($f2, $9, M*0)                                                      \
+    LOAD($f4, $9, M*4)                                                      \
+    UNPACK("$f2")                                                           \
+    UNPACK("$f4")                                                           \
+    "pmullh     $f2,    $f2,    %[ff_pw_3]      \n\t"                       \
+    "pmullh     $f4,    $f4,    %[ff_pw_3]      \n\t"                       \
+    PTR_ADDU   "$9,     %[src], "#A2"           \n\t"                       \
+    LOAD($f6, $9, M*0)                                                      \
+    LOAD($f8, $9, M*4)                                                      \
+    UNPACK("$f6")                                                           \
+    UNPACK("$f8")                                                           \
+    "pmullh     $f6,    $f6,    $f12            \n\t" /* *18 */             \
+    "pmullh     $f8,    $f8,    $f12            \n\t" /* *18 */             \
+    "psubh      $f6,    $f6,    $f2             \n\t" /* *18, -3 */         \
+    "psubh      $f8,    $f8,    $f4             \n\t" /* *18, -3 */         \
+    PTR_ADDU   "$9,     %[src], "#A4"           \n\t"                       \
+    LOAD($f2, $9, M*0)                                                      \
+    LOAD($f4, $9, M*4)                                                      \
+    UNPACK("$f2")                                                           \
+    UNPACK("$f4")                                                           \
+    "li         $8,     0x02                    \n\t"                       \
+    "mtc1       $8,     $f16                    \n\t"                       \
+    "psllh      $f2,    $f2,    $f16            \n\t" /* 4* */              \
+    "psllh      $f4,    $f4,    $f16            \n\t" /* 4* */              \
+    "psubh      $f6,    $f6,    $f2             \n\t" /* -4,18,-3 */        \
+    "psubh      $f8,    $f8,    $f4             \n\t" /* -4,18,-3 */        \
+    PTR_ADDU   "$9,     %[src], "#A3"           \n\t"                       \
+    LOAD($f2, $9, M*0)                                                      \
+    LOAD($f4, $9, M*4)                                                      \
+    UNPACK("$f2")                                                           \
+    UNPACK("$f4")                                                           \
+    "pmullh     $f2,    $f2,    $f10            \n\t" /* *53 */             \
+    "pmullh     $f4,    $f4,    $f10            \n\t" /* *53 */             \
+    "paddh      $f6,    $f6,    $f2             \n\t" /* 4,53,18,-3 */      \
+    "paddh      $f8,    $f8,    $f4             \n\t" /* 4,53,18,-3 */
+
+/**
+ * Macro to build the vertical 16bits version of vc1_put_shift[13].
+ * Here, offset=src_stride. Parameters passed A1 to A4 must use
+ * %3 (src_stride), %4 (2*src_stride) and %5 (3*src_stride).
+ *
+ * @param  NAME   Either 1 or 3
+ * @see MSPEL_FILTER13_CORE for information on A1->A4
+ */
+#define MSPEL_FILTER13_VER_16B(NAME, A1, A2, A3, A4)                        \
+static void                                                                 \
+vc1_put_ver_16b_ ## NAME ## _mmi(int16_t *dst, const uint8_t *src,          \
+                                 mips_reg src_stride,                       \
+                                 int rnd, int64_t shift)                    \
+{                                                                           \
+    int h = 8;                                                              \
+    DECLARE_VAR_LOW32;                                                      \
+    DECLARE_VAR_ADDRT;                                                      \
+                                                                            \
+    src -= src_stride;                                                      \
+                                                                            \
+    __asm__ volatile(                                                       \
+        "xor        $f0,    $f0,    $f0             \n\t"                   \
+        LOAD_ROUNDER_MMI("%[rnd]")                                          \
+        "ldc1       $f10,   %[ff_pw_53]             \n\t"                   \
+        "ldc1       $f12,   %[ff_pw_18]             \n\t"                   \
+        ".p2align 3                                 \n\t"                   \
+        "1:                                         \n\t"                   \
+        MSPEL_FILTER13_CORE(DO_UNPACK, MMI_ULWC1, 1, A1, A2, A3, A4)        \
+        NORMALIZE_MMI("%[shift]")                                           \
+        TRANSFER_DONT_PACK(OP_PUT)                                          \
+        /* Last 3 (in fact 4) bytes on the line */                          \
+        PTR_ADDU   "$9,     %[src], "#A1"           \n\t"                   \
+        MMI_ULWC1($f2, $9, 0x08)                                            \
+        DO_UNPACK("$f2")                                                    \
+        "mov.d      $f6,    $f2                     \n\t"                   \
+        "paddh      $f2,    $f2,    $f2             \n\t"                   \
+        "paddh      $f2,    $f2,    $f6             \n\t" /* 3* */          \
+        PTR_ADDU   "$9,     %[src], "#A2"           \n\t"                   \
+        MMI_ULWC1($f6, $9, 0x08)                                            \
+        DO_UNPACK("$f6")                                                    \
+        "pmullh     $f6,    $f6,    $f12            \n\t" /* *18 */         \
+        "psubh      $f6,    $f6,    $f2             \n\t" /* *18,-3 */      \
+        PTR_ADDU   "$9,     %[src], "#A3"           \n\t"                   \
+        MMI_ULWC1($f2, $9, 0x08)                                            \
+        DO_UNPACK("$f2")                                                    \
+        "pmullh     $f2,    $f2,    $f10            \n\t" /* *53 */         \
+        "paddh      $f6,    $f6,    $f2             \n\t" /* *53,18,-3 */   \
+        PTR_ADDU   "$9,     %[src], "#A4"           \n\t"                   \
+        MMI_ULWC1($f2, $9, 0x08)                                            \
+        DO_UNPACK("$f2")                                                    \
+        "li         $8,     0x02                    \n\t"                   \
+        "mtc1       $8,     $f16                    \n\t"                   \
+        "psllh      $f2,    $f2,    $f16            \n\t" /* 4* */          \
+        "psubh      $f6,    $f6,    $f2             \n\t"                   \
+        "paddh      $f6,    $f6,    $f14            \n\t"                   \
+        "li         $8,     0x06                    \n\t"                   \
+        "mtc1       $8,     $f16                    \n\t"                   \
+        "psrah      $f6,    $f6,    $f16            \n\t"                   \
+        "sdc1       $f6,    0x10(%[dst])            \n\t"                   \
+        "addiu      %[h],   %[h],  -0x01            \n\t"                   \
+        PTR_ADDU   "%[src], %[src], %[stride_x1]    \n\t"                   \
+        PTR_ADDIU  "%[dst], %[dst], 0x18            \n\t"                   \
+        "bnez       %[h],   1b                      \n\t"                   \
+        : RESTRICT_ASM_LOW32            RESTRICT_ASM_ADDRT                  \
+          [h]"+r"(h),                                                       \
+          [src]"+r"(src),               [dst]"+r"(dst)                      \
+        : [stride_x1]"r"(src_stride),   [stride_x2]"r"(2*src_stride),       \
+          [stride_x3]"r"(3*src_stride),                                     \
+          [rnd]"m"(rnd),                [shift]"f"(shift),                  \
+          [ff_pw_53]"m"(ff_pw_53),      [ff_pw_18]"m"(ff_pw_18),            \
+          [ff_pw_3]"f"(ff_pw_3)                                             \
+        : "$8", "$9", "$f0", "$f2", "$f4", "$f6", "$f8", "$f10", "$f12",    \
+          "$f14", "$f16", "memory"                                          \
+    );                                                                      \
+}
+
+/**
+ * Macro to build the horizontal 16bits version of vc1_put_shift[13].
+ * Here, offset=16bits, so parameters passed A1 to A4 should be simple.
+ *
+ * @param  NAME   Either 1 or 3
+ * @see MSPEL_FILTER13_CORE for information on A1->A4
+ */
+#define MSPEL_FILTER13_HOR_16B(NAME, A1, A2, A3, A4, OP, OPNAME)            \
+static void                                                                 \
+OPNAME ## vc1_hor_16b_ ## NAME ## _mmi(uint8_t *dst, mips_reg stride,       \
+                                       const int16_t *src, int rnd)         \
+{                                                                           \
+    int h = 8;                                                              \
+    DECLARE_VAR_ALL64;                                                      \
+    DECLARE_VAR_ADDRT;                                                      \
+                                                                            \
+    src -= 1;                                                               \
+    rnd -= (-4+58+13-3)*256; /* Add -256 bias */                            \
+                                                                            \
+    __asm__ volatile(                                                       \
+        "xor        $f0,    $f0,    $f0             \n\t"                   \
+        LOAD_ROUNDER_MMI("%[rnd]")                                          \
+        "ldc1       $f10,   %[ff_pw_53]             \n\t"                   \
+        "ldc1       $f12,   %[ff_pw_18]             \n\t"                   \
+        ".p2align 3                                 \n\t"                   \
+        "1:                                         \n\t"                   \
+        MSPEL_FILTER13_CORE(DONT_UNPACK, MMI_ULDC1, 2, A1, A2, A3, A4)      \
+        "li         $8,     0x07                    \n\t"                   \
+        "mtc1       $8,     $f16                    \n\t"                   \
+        NORMALIZE_MMI("$f16")                                               \
+        /* Remove bias */                                                   \
+        "paddh      $f6,    $f6,    %[ff_pw_128]    \n\t"                   \
+        "paddh      $f8,    $f8,    %[ff_pw_128]    \n\t"                   \
+        TRANSFER_DO_PACK(OP)                                                \
+        "addiu      %[h],   %[h],  -0x01            \n\t"                   \
+        PTR_ADDU   "%[src], %[src], 0x18            \n\t"                   \
+        PTR_ADDU   "%[dst], %[dst], %[stride]       \n\t"                   \
+        "bnez       %[h],   1b                      \n\t"                   \
+        : RESTRICT_ASM_ALL64            RESTRICT_ASM_ADDRT                  \
+          [h]"+r"(h),                                                       \
+          [src]"+r"(src),               [dst]"+r"(dst)                      \
+        : [stride]"r"(stride),          [rnd]"m"(rnd),                      \
+          [ff_pw_53]"m"(ff_pw_53),      [ff_pw_18]"m"(ff_pw_18),            \
+          [ff_pw_3]"f"(ff_pw_3),        [ff_pw_128]"f"(ff_pw_128)           \
+        : "$8", "$9", "$f0", "$f2", "$f4", "$f6", "$f8", "$f10", "$f12",    \
+          "$f14", "$f16", "memory"                                          \
+    );                                                                      \
+}
+
+/**
+ * Macro to build the 8bits, any direction, version of vc1_put_shift[13].
+ * Here, offset=src_stride. Parameters passed A1 to A4 must use
+ * %3 (offset), %4 (2*offset) and %5 (3*offset).
+ *
+ * @param  NAME   Either 1 or 3
+ * @see MSPEL_FILTER13_CORE for information on A1->A4
+ */
+#define MSPEL_FILTER13_8B(NAME, A1, A2, A3, A4, OP, OPNAME)                 \
+static void                                                                 \
+OPNAME ## vc1_## NAME ## _mmi(uint8_t *dst, const uint8_t *src,             \
+                              mips_reg stride, int rnd, mips_reg offset)    \
+{                                                                           \
+    int h = 8;                                                              \
+    DECLARE_VAR_LOW32;                                                      \
+    DECLARE_VAR_ADDRT;                                                      \
+                                                                            \
+    src -= offset;                                                          \
+    rnd = 32-rnd;                                                           \
+                                                                            \
+    __asm__ volatile (                                                      \
+        "xor        $f0,    $f0,    $f0             \n\t"                   \
+        LOAD_ROUNDER_MMI("%[rnd]")                                          \
+        "ldc1       $f10,   %[ff_pw_53]             \n\t"                   \
+        "ldc1       $f12,   %[ff_pw_18]             \n\t"                   \
+        ".p2align 3                                 \n\t"                   \
+        "1:                                         \n\t"                   \
+        MSPEL_FILTER13_CORE(DO_UNPACK, MMI_ULWC1, 1, A1, A2, A3, A4)        \
+        "li         $8,     0x06                    \n\t"                   \
+        "mtc1       $8,     $f16                    \n\t"                   \
+        NORMALIZE_MMI("$f16")                                               \
+        TRANSFER_DO_PACK(OP)                                                \
+        "addiu      %[h],   %[h],      -0x01        \n\t"                   \
+        PTR_ADDU   "%[src], %[src],     %[stride]   \n\t"                   \
+        PTR_ADDU   "%[dst], %[dst],     %[stride]   \n\t"                   \
+        "bnez       %[h],   1b                      \n\t"                   \
+        : RESTRICT_ASM_LOW32            RESTRICT_ASM_ADDRT                  \
+          [h]"+r"(h),                                                       \
+          [src]"+r"(src),               [dst]"+r"(dst)                      \
+        : [offset_x1]"r"(offset),       [offset_x2]"r"(2*offset),           \
+          [offset_x3]"r"(3*offset),     [stride]"g"(stride),                \
+          [rnd]"m"(rnd),                                                    \
+          [ff_pw_53]"m"(ff_pw_53),      [ff_pw_18]"m"(ff_pw_18),            \
+          [ff_pw_3]"f"(ff_pw_3)                                             \
+        : "$8", "$9", "$f0", "$f2", "$f4", "$f6", "$f8", "$f10", "$f12",    \
+          "$f14", "$f16", "memory"                                          \
+    );                                                                      \
+}
+
+
+/** 1/4 shift bicubic interpolation */
+MSPEL_FILTER13_8B(shift1, %[offset_x3], %[offset_x2], %[offset_x1], $0, OP_PUT, put_)
+MSPEL_FILTER13_8B(shift1, %[offset_x3], %[offset_x2], %[offset_x1], $0, OP_AVG, avg_)
+MSPEL_FILTER13_VER_16B(shift1, %[stride_x3], %[stride_x2], %[stride_x1], $0)
+MSPEL_FILTER13_HOR_16B(shift1, 6, 4, 2, 0, OP_PUT, put_)
+MSPEL_FILTER13_HOR_16B(shift1, 6, 4, 2, 0, OP_AVG, avg_)
+
+/** 3/4 shift bicubic interpolation */
+MSPEL_FILTER13_8B(shift3, $0, %[offset_x1], %[offset_x2], %[offset_x3], OP_PUT, put_)
+MSPEL_FILTER13_8B(shift3, $0, %[offset_x1], %[offset_x2], %[offset_x3], OP_AVG, avg_)
+MSPEL_FILTER13_VER_16B(shift3, $0, %[stride_x1], %[stride_x2], %[stride_x3])
+MSPEL_FILTER13_HOR_16B(shift3, 0, 2, 4, 6, OP_PUT, put_)
+MSPEL_FILTER13_HOR_16B(shift3, 0, 2, 4, 6, OP_AVG, avg_)
+
+typedef void (*vc1_mspel_mc_filter_ver_16bits)
+             (int16_t *dst, const uint8_t *src, mips_reg src_stride, int rnd,
+              int64_t shift);
+typedef void (*vc1_mspel_mc_filter_hor_16bits)
+             (uint8_t *dst, mips_reg dst_stride, const int16_t *src, int rnd);
+typedef void (*vc1_mspel_mc_filter_8bits)
+             (uint8_t *dst, const uint8_t *src, mips_reg stride, int rnd,
+              mips_reg offset);
+
+/**
+ * Interpolate fractional pel values by applying proper vertical then
+ * horizontal filter.
+ *
+ * @param  dst     Destination buffer for interpolated pels.
+ * @param  src     Source buffer.
+ * @param  stride  Stride for both src and dst buffers.
+ * @param  hmode   Horizontal filter (expressed in quarter pixels shift).
+ * @param  hmode   Vertical filter.
+ * @param  rnd     Rounding bias.
+ */
+#define VC1_MSPEL_MC(OP)                                                    \
+static void OP ## vc1_mspel_mc(uint8_t *dst, const uint8_t *src, int stride,\
+                               int hmode, int vmode, int rnd)               \
+{                                                                           \
+    static const vc1_mspel_mc_filter_ver_16bits vc1_put_shift_ver_16bits[] =\
+         { NULL, vc1_put_ver_16b_shift1_mmi,                                \
+                 vc1_put_ver_16b_shift2_mmi,                                \
+                 vc1_put_ver_16b_shift3_mmi };                              \
+    static const vc1_mspel_mc_filter_hor_16bits vc1_put_shift_hor_16bits[] =\
+         { NULL, OP ## vc1_hor_16b_shift1_mmi,                              \
+                 OP ## vc1_hor_16b_shift2_mmi,                              \
+                 OP ## vc1_hor_16b_shift3_mmi };                            \
+    static const vc1_mspel_mc_filter_8bits vc1_put_shift_8bits[] =          \
+         { NULL, OP ## vc1_shift1_mmi,                                      \
+                 OP ## vc1_shift2_mmi,                                      \
+                 OP ## vc1_shift3_mmi };                                    \
+                                                                            \
+    if (vmode) { /* Vertical filter to apply */                             \
+        if (hmode) { /* Horizontal filter to apply, output to tmp */        \
+            static const int shift_value[] = { 0, 5, 1, 5 };                \
+            int    shift = (shift_value[hmode]+shift_value[vmode])>>1;      \
+            int    r;                                                       \
+            LOCAL_ALIGNED(16, int16_t, tmp, [12*8]);                        \
+                                                                            \
+            r = (1<<(shift-1)) + rnd-1;                                     \
+            vc1_put_shift_ver_16bits[vmode](tmp, src-1, stride, r, shift);  \
+                                                                            \
+            vc1_put_shift_hor_16bits[hmode](dst, stride, tmp+1, 64-rnd);    \
+            return;                                                         \
+        }                                                                   \
+        else { /* No horizontal filter, output 8 lines to dst */            \
+            vc1_put_shift_8bits[vmode](dst, src, stride, 1-rnd, stride);    \
+            return;                                                         \
+        }                                                                   \
+    }                                                                       \
+                                                                            \
+    /* Horizontal mode with no vertical mode */                             \
+    vc1_put_shift_8bits[hmode](dst, src, stride, rnd, 1);                   \
+}                                                                           \
+static void OP ## vc1_mspel_mc_16(uint8_t *dst, const uint8_t *src,         \
+                                  int stride, int hmode, int vmode, int rnd)\
+{                                                                           \
+    OP ## vc1_mspel_mc(dst + 0, src + 0, stride, hmode, vmode, rnd);        \
+    OP ## vc1_mspel_mc(dst + 8, src + 8, stride, hmode, vmode, rnd);        \
+    dst += 8*stride; src += 8*stride;                                       \
+    OP ## vc1_mspel_mc(dst + 0, src + 0, stride, hmode, vmode, rnd);        \
+    OP ## vc1_mspel_mc(dst + 8, src + 8, stride, hmode, vmode, rnd);        \
+}
+
+VC1_MSPEL_MC(put_)
+VC1_MSPEL_MC(avg_)
+
+/** Macro to ease bicubic filter interpolation functions declarations */
+#define DECLARE_FUNCTION(a, b)                                              \
+void ff_put_vc1_mspel_mc ## a ## b ## _mmi(uint8_t *dst,                    \
+                                           const uint8_t *src,              \
+                                           ptrdiff_t stride,                \
+                                           int rnd)                         \
+{                                                                           \
+     put_vc1_mspel_mc(dst, src, stride, a, b, rnd);                         \
+}                                                                           \
+void ff_avg_vc1_mspel_mc ## a ## b ## _mmi(uint8_t *dst,                    \
+                                           const uint8_t *src,              \
+                                           ptrdiff_t stride,                \
+                                           int rnd)                         \
+{                                                                           \
+     avg_vc1_mspel_mc(dst, src, stride, a, b, rnd);                         \
+}                                                                           \
+void ff_put_vc1_mspel_mc ## a ## b ## _16_mmi(uint8_t *dst,                 \
+                                              const uint8_t *src,           \
+                                              ptrdiff_t stride,             \
+                                              int rnd)                      \
+{                                                                           \
+     put_vc1_mspel_mc_16(dst, src, stride, a, b, rnd);                      \
+}                                                                           \
+void ff_avg_vc1_mspel_mc ## a ## b ## _16_mmi(uint8_t *dst,                 \
+                                              const uint8_t *src,           \
+                                              ptrdiff_t stride,             \
+                                              int rnd)                      \
+{                                                                           \
+     avg_vc1_mspel_mc_16(dst, src, stride, a, b, rnd);                      \
+}
+
+DECLARE_FUNCTION(0, 1)
+DECLARE_FUNCTION(0, 2)
+DECLARE_FUNCTION(0, 3)
+
+DECLARE_FUNCTION(1, 0)
+DECLARE_FUNCTION(1, 1)
+DECLARE_FUNCTION(1, 2)
+DECLARE_FUNCTION(1, 3)
+
+DECLARE_FUNCTION(2, 0)
+DECLARE_FUNCTION(2, 1)
+DECLARE_FUNCTION(2, 2)
+DECLARE_FUNCTION(2, 3)
+
+DECLARE_FUNCTION(3, 0)
+DECLARE_FUNCTION(3, 1)
+DECLARE_FUNCTION(3, 2)
+DECLARE_FUNCTION(3, 3)
+
+#define CHROMA_MC_8_MMI                                                     \
+        "punpckhbh  %[ftmp5],   %[ftmp1],   %[ftmp0]                \n\t"   \
+        "punpcklbh  %[ftmp1],   %[ftmp1],   %[ftmp0]                \n\t"   \
+        "punpckhbh  %[ftmp6],   %[ftmp2],   %[ftmp0]                \n\t"   \
+        "punpcklbh  %[ftmp2],   %[ftmp2],   %[ftmp0]                \n\t"   \
+        "punpckhbh  %[ftmp7],   %[ftmp3],   %[ftmp0]                \n\t"   \
+        "punpcklbh  %[ftmp3],   %[ftmp3],   %[ftmp0]                \n\t"   \
+        "punpckhbh  %[ftmp8],   %[ftmp4],   %[ftmp0]                \n\t"   \
+        "punpcklbh  %[ftmp4],   %[ftmp4],   %[ftmp0]                \n\t"   \
+                                                                            \
+        "pmullh     %[ftmp1],   %[ftmp1],   %[A]                    \n\t"   \
+        "pmullh     %[ftmp5],   %[ftmp5],   %[A]                    \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],   %[B]                    \n\t"   \
+        "pmullh     %[ftmp6],   %[ftmp6],   %[B]                    \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],   %[C]                    \n\t"   \
+        "pmullh     %[ftmp7],   %[ftmp7],   %[C]                    \n\t"   \
+        "pmullh     %[ftmp4],   %[ftmp4],   %[D]                    \n\t"   \
+        "pmullh     %[ftmp8],   %[ftmp8],   %[D]                    \n\t"   \
+                                                                            \
+        "paddh      %[ftmp1],   %[ftmp1],   %[ftmp2]                \n\t"   \
+        "paddh      %[ftmp3],   %[ftmp3],   %[ftmp4]                \n\t"   \
+        "paddh      %[ftmp1],   %[ftmp1],   %[ftmp3]                \n\t"   \
+        "paddh      %[ftmp1],   %[ftmp1],   %[ff_pw_28]             \n\t"   \
+                                                                            \
+        "paddh      %[ftmp5],   %[ftmp5],   %[ftmp6]                \n\t"   \
+        "paddh      %[ftmp7],   %[ftmp7],   %[ftmp8]                \n\t"   \
+        "paddh      %[ftmp5],   %[ftmp5],   %[ftmp7]                \n\t"   \
+        "paddh      %[ftmp5],   %[ftmp5],   %[ff_pw_28]             \n\t"   \
+                                                                            \
+        "psrlh      %[ftmp1],   %[ftmp1],   %[ftmp9]                \n\t"   \
+        "psrlh      %[ftmp5],   %[ftmp5],   %[ftmp9]                \n\t"   \
+        "packushb   %[ftmp1],   %[ftmp1],   %[ftmp5]                \n\t"
+
+
+#define CHROMA_MC_4_MMI                                                     \
+        "punpcklbh  %[ftmp1],   %[ftmp1],   %[ftmp0]                \n\t"   \
+        "punpcklbh  %[ftmp2],   %[ftmp2],   %[ftmp0]                \n\t"   \
+        "punpcklbh  %[ftmp3],   %[ftmp3],   %[ftmp0]                \n\t"   \
+        "punpcklbh  %[ftmp4],   %[ftmp4],   %[ftmp0]                \n\t"   \
+                                                                            \
+        "pmullh     %[ftmp1],   %[ftmp1],   %[A]                    \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],   %[B]                    \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],   %[C]                    \n\t"   \
+        "pmullh     %[ftmp4],   %[ftmp4],   %[D]                    \n\t"   \
+                                                                            \
+        "paddh      %[ftmp1],   %[ftmp1],   %[ftmp2]                \n\t"   \
+        "paddh      %[ftmp3],   %[ftmp3],   %[ftmp4]                \n\t"   \
+        "paddh      %[ftmp1],   %[ftmp1],   %[ftmp3]                \n\t"   \
+        "paddh      %[ftmp1],   %[ftmp1],   %[ff_pw_28]             \n\t"   \
+                                                                            \
+        "psrlh      %[ftmp1],   %[ftmp1],   %[ftmp5]                \n\t"   \
+        "packushb   %[ftmp1],   %[ftmp1],   %[ftmp0]                \n\t"
+
+
+void ff_put_no_rnd_vc1_chroma_mc8_mmi(uint8_t *dst /* align 8 */,
+                                      uint8_t *src /* align 1 */,
+                                      int stride, int h, int x, int y)
+{
+    const int A = (8 - x) * (8 - y);
+    const int B =     (x) * (8 - y);
+    const int C = (8 - x) *     (y);
+    const int D =     (x) *     (y);
+    double ftmp[10];
+    uint32_t tmp[1];
+    DECLARE_VAR_ALL64;
+    DECLARE_VAR_ADDRT;
+
+    av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+
+    __asm__ volatile(
+        "li         %[tmp0],    0x06                                    \n\t"
+        "xor        %[ftmp0],   %[ftmp0],   %[ftmp0]                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp9]                                \n\t"
+        "pshufh     %[A],       %[A],       %[ftmp0]                    \n\t"
+        "pshufh     %[B],       %[B],       %[ftmp0]                    \n\t"
+        "pshufh     %[C],       %[C],       %[ftmp0]                    \n\t"
+        "pshufh     %[D],       %[D],       %[ftmp0]                    \n\t"
+
+        "1:                                                             \n\t"
+        MMI_ULDC1(%[ftmp1], %[src], 0x00)
+        MMI_ULDC1(%[ftmp2], %[src], 0x01)
+        PTR_ADDU   "%[src],     %[src],     %[stride]                   \n\t"
+        MMI_ULDC1(%[ftmp3], %[src], 0x00)
+        MMI_ULDC1(%[ftmp4], %[src], 0x01)
+
+        CHROMA_MC_8_MMI
+
+        MMI_SDC1(%[ftmp1], %[dst], 0x00)
+        "addiu      %[h],       %[h],      -0x01                        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],     %[stride]                   \n\t"
+        "bnez       %[h],       1b                                      \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),        [ftmp9]"=&f"(ftmp[9]),
+          RESTRICT_ASM_ALL64
+          RESTRICT_ASM_ADDRT
+          [tmp0]"=&r"(tmp[0]),
+          [src]"+&r"(src),              [dst]"+&r"(dst),
+          [h]"+&r"(h)
+        : [stride]"r"((mips_reg)stride),
+          [A]"f"(A),                    [B]"f"(B),
+          [C]"f"(C),                    [D]"f"(D),
+          [ff_pw_28]"f"(ff_pw_28)
+        : "memory"
+    );
+}
+
+void ff_put_no_rnd_vc1_chroma_mc4_mmi(uint8_t *dst /* align 8 */,
+                                      uint8_t *src /* align 1 */,
+                                      int stride, int h, int x, int y)
+{
+    const int A = (8 - x) * (8 - y);
+    const int B =     (x) * (8 - y);
+    const int C = (8 - x) *     (y);
+    const int D =     (x) *     (y);
+    double ftmp[6];
+    uint32_t tmp[1];
+    DECLARE_VAR_LOW32;
+    DECLARE_VAR_ADDRT;
+
+    av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+
+    __asm__ volatile(
+        "li         %[tmp0],    0x06                                    \n\t"
+        "xor        %[ftmp0],   %[ftmp0],   %[ftmp0]                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp5]                                \n\t"
+        "pshufh     %[A],       %[A],       %[ftmp0]                    \n\t"
+        "pshufh     %[B],       %[B],       %[ftmp0]                    \n\t"
+        "pshufh     %[C],       %[C],       %[ftmp0]                    \n\t"
+        "pshufh     %[D],       %[D],       %[ftmp0]                    \n\t"
+
+        "1:                                                             \n\t"
+        MMI_ULWC1(%[ftmp1], %[src], 0x00)
+        MMI_ULWC1(%[ftmp2], %[src], 0x01)
+        PTR_ADDU   "%[src],     %[src],     %[stride]                   \n\t"
+        MMI_ULWC1(%[ftmp3], %[src], 0x00)
+        MMI_ULWC1(%[ftmp4], %[src], 0x01)
+
+        CHROMA_MC_4_MMI
+
+        MMI_SWC1(%[ftmp1], %[dst], 0x00)
+        "addiu      %[h],       %[h],      -0x01                        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],     %[stride]                   \n\t"
+        "bnez       %[h],       1b                                      \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          RESTRICT_ASM_ADDRT
+          [src]"+&r"(src),              [dst]"+&r"(dst),
+          [h]"+&r"(h)
+        : [stride]"r"((mips_reg)stride),
+          [A]"f"(A),                    [B]"f"(B),
+          [C]"f"(C),                    [D]"f"(D),
+          [ff_pw_28]"f"(ff_pw_28)
+        : "memory"
+    );
+}
+
+void ff_avg_no_rnd_vc1_chroma_mc8_mmi(uint8_t *dst /* align 8 */,
+                                      uint8_t *src /* align 1 */,
+                                      int stride, int h, int x, int y)
+{
+    const int A = (8 - x) * (8 - y);
+    const int B =     (x) * (8 - y);
+    const int C = (8 - x) *     (y);
+    const int D =     (x) *     (y);
+    double ftmp[10];
+    uint32_t tmp[1];
+    DECLARE_VAR_ALL64;
+    DECLARE_VAR_ADDRT;
+
+    av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+
+    __asm__ volatile(
+        "li         %[tmp0],    0x06                                    \n\t"
+        "xor        %[ftmp0],   %[ftmp0],   %[ftmp0]                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp9]                                \n\t"
+        "pshufh     %[A],       %[A],       %[ftmp0]                    \n\t"
+        "pshufh     %[B],       %[B],       %[ftmp0]                    \n\t"
+        "pshufh     %[C],       %[C],       %[ftmp0]                    \n\t"
+        "pshufh     %[D],       %[D],       %[ftmp0]                    \n\t"
+
+        "1:                                                             \n\t"
+        MMI_ULDC1(%[ftmp1], %[src], 0x00)
+        MMI_ULDC1(%[ftmp2], %[src], 0x01)
+        PTR_ADDU   "%[src],     %[src],     %[stride]                   \n\t"
+        MMI_ULDC1(%[ftmp3], %[src], 0x00)
+        MMI_ULDC1(%[ftmp4], %[src], 0x01)
+
+        CHROMA_MC_8_MMI
+
+        MMI_LDC1(%[ftmp2], %[dst], 0x00)
+        "pavgb      %[ftmp1],   %[ftmp1],   %[ftmp2]                    \n\t"
+
+        MMI_SDC1(%[ftmp1], %[dst], 0x00)
+        "addiu      %[h],       %[h],      -0x01                        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],     %[stride]                   \n\t"
+        "bnez       %[h],       1b                                      \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),        [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),        [ftmp9]"=&f"(ftmp[9]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          RESTRICT_ASM_ADDRT
+          [src]"+&r"(src),              [dst]"+&r"(dst),
+          [h]"+&r"(h)
+        : [stride]"r"((mips_reg)stride),
+          [A]"f"(A),                    [B]"f"(B),
+          [C]"f"(C),                    [D]"f"(D),
+          [ff_pw_28]"f"(ff_pw_28)
+        : "memory"
+    );
+}
+
+void ff_avg_no_rnd_vc1_chroma_mc4_mmi(uint8_t *dst /* align 8 */,
+                                      uint8_t *src /* align 1 */,
+                                      int stride, int h, int x, int y)
+{
+    const int A = (8 - x) * (8 - y);
+    const int B = (    x) * (8 - y);
+    const int C = (8 - x) * (    y);
+    const int D = (    x) * (    y);
+    double ftmp[6];
+    uint32_t tmp[1];
+    DECLARE_VAR_LOW32;
+    DECLARE_VAR_ADDRT;
+
+    av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
+
+    __asm__ volatile(
+        "li         %[tmp0],    0x06                                    \n\t"
+        "xor        %[ftmp0],   %[ftmp0],   %[ftmp0]                    \n\t"
+        "mtc1       %[tmp0],    %[ftmp5]                                \n\t"
+        "pshufh     %[A],       %[A],       %[ftmp0]                    \n\t"
+        "pshufh     %[B],       %[B],       %[ftmp0]                    \n\t"
+        "pshufh     %[C],       %[C],       %[ftmp0]                    \n\t"
+        "pshufh     %[D],       %[D],       %[ftmp0]                    \n\t"
+
+        "1:                                                             \n\t"
+        MMI_ULWC1(%[ftmp1], %[src], 0x00)
+        MMI_ULWC1(%[ftmp2], %[src], 0x01)
+        PTR_ADDU   "%[src],     %[src],     %[stride]                   \n\t"
+        MMI_ULWC1(%[ftmp3], %[src], 0x00)
+        MMI_ULWC1(%[ftmp4], %[src], 0x01)
+
+        CHROMA_MC_4_MMI
+
+        MMI_LWC1(%[ftmp2], %[dst], 0x00)
+        "pavgb      %[ftmp1],   %[ftmp1],   %[ftmp2]                    \n\t"
+
+        MMI_SWC1(%[ftmp1], %[dst], 0x00)
+        "addiu      %[h],       %[h],      -0x01                        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],     %[stride]                   \n\t"
+        "bnez       %[h],       1b                                      \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          RESTRICT_ASM_ADDRT
+          [src]"+&r"(src),              [dst]"+&r"(dst),
+          [h]"+&r"(h)
+        : [stride]"r"((mips_reg)stride),
+          [A]"f"(A),                    [B]"f"(B),
+          [C]"f"(C),                    [D]"f"(D),
+          [ff_pw_28]"f"(ff_pw_28)
+        : "memory"
+    );
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/videodsp_init.c b/mythtv/external/FFmpeg/libavcodec/mips/videodsp_init.c
new file mode 100644
index 00000000000..817040420b0
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mips/videodsp_init.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2017 Kaustubh Raste (kaustubh.raste@imgtec.com)
+ *
+ * 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/mips/asmdefs.h"
+#include "libavcodec/videodsp.h"
+
+#if HAVE_MSA
+static void prefetch_mips(uint8_t *mem, ptrdiff_t stride, int h)
+{
+    register const uint8_t *p = mem;
+
+    __asm__ volatile (
+        "1:                                     \n\t"
+        "pref          4,  0(%[p])              \n\t"
+        "pref          4,  32(%[p])             \n\t"
+        PTR_ADDIU"  %[h],  %[h],     -1         \n\t"
+        PTR_ADDU "  %[p],  %[p],     %[stride]  \n\t"
+
+        "bnez       %[h],  1b                   \n\t"
+
+        : [p] "+r" (p), [h] "+r" (h)
+        : [stride] "r" (stride)
+    );
+}
+#endif  // #if HAVE_MSA
+
+av_cold void ff_videodsp_init_mips(VideoDSPContext *ctx, int bpc)
+{
+#if HAVE_MSA
+    ctx->prefetch = prefetch_mips;
+#endif  // #if HAVE_MSA
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/vp8dsp_init_mips.c b/mythtv/external/FFmpeg/libavcodec/mips/vp8dsp_init_mips.c
index 58d1b6ce38e..3fc5f8e0af0 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/vp8dsp_init_mips.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/vp8dsp_init_mips.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
+ * Copyright (c) 2016 Zhou Xiaoyong <zhouxiaoyong@loongson.cn>
  *
  * This file is part of FFmpeg.
  *
@@ -105,9 +106,97 @@ static av_cold void vp8dsp_init_msa(VP8DSPContext *dsp)
 }
 #endif  // #if HAVE_MSA
 
+#if HAVE_MMI
+static av_cold void vp8dsp_init_mmi(VP8DSPContext *dsp)
+{
+    dsp->vp8_luma_dc_wht    = ff_vp8_luma_dc_wht_mmi;
+    dsp->vp8_luma_dc_wht_dc = ff_vp8_luma_dc_wht_dc_mmi;
+    dsp->vp8_idct_add       = ff_vp8_idct_add_mmi;
+    dsp->vp8_idct_dc_add    = ff_vp8_idct_dc_add_mmi;
+    dsp->vp8_idct_dc_add4y  = ff_vp8_idct_dc_add4y_mmi;
+    dsp->vp8_idct_dc_add4uv = ff_vp8_idct_dc_add4uv_mmi;
+
+    dsp->put_vp8_epel_pixels_tab[0][0][1] = ff_put_vp8_epel16_h4_mmi;
+    dsp->put_vp8_epel_pixels_tab[0][0][2] = ff_put_vp8_epel16_h6_mmi;
+    dsp->put_vp8_epel_pixels_tab[0][1][0] = ff_put_vp8_epel16_v4_mmi;
+    dsp->put_vp8_epel_pixels_tab[0][1][1] = ff_put_vp8_epel16_h4v4_mmi;
+    dsp->put_vp8_epel_pixels_tab[0][1][2] = ff_put_vp8_epel16_h6v4_mmi;
+    dsp->put_vp8_epel_pixels_tab[0][2][0] = ff_put_vp8_epel16_v6_mmi;
+    dsp->put_vp8_epel_pixels_tab[0][2][1] = ff_put_vp8_epel16_h4v6_mmi;
+    dsp->put_vp8_epel_pixels_tab[0][2][2] = ff_put_vp8_epel16_h6v6_mmi;
+
+    dsp->put_vp8_epel_pixels_tab[1][0][1] = ff_put_vp8_epel8_h4_mmi;
+    dsp->put_vp8_epel_pixels_tab[1][0][2] = ff_put_vp8_epel8_h6_mmi;
+    dsp->put_vp8_epel_pixels_tab[1][1][0] = ff_put_vp8_epel8_v4_mmi;
+    dsp->put_vp8_epel_pixels_tab[1][1][1] = ff_put_vp8_epel8_h4v4_mmi;
+    dsp->put_vp8_epel_pixels_tab[1][1][2] = ff_put_vp8_epel8_h6v4_mmi;
+    dsp->put_vp8_epel_pixels_tab[1][2][0] = ff_put_vp8_epel8_v6_mmi;
+    dsp->put_vp8_epel_pixels_tab[1][2][1] = ff_put_vp8_epel8_h4v6_mmi;
+    dsp->put_vp8_epel_pixels_tab[1][2][2] = ff_put_vp8_epel8_h6v6_mmi;
+
+    dsp->put_vp8_epel_pixels_tab[2][0][1] = ff_put_vp8_epel4_h4_mmi;
+    dsp->put_vp8_epel_pixels_tab[2][0][2] = ff_put_vp8_epel4_h6_mmi;
+    dsp->put_vp8_epel_pixels_tab[2][1][0] = ff_put_vp8_epel4_v4_mmi;
+    dsp->put_vp8_epel_pixels_tab[2][1][1] = ff_put_vp8_epel4_h4v4_mmi;
+    dsp->put_vp8_epel_pixels_tab[2][1][2] = ff_put_vp8_epel4_h6v4_mmi;
+    dsp->put_vp8_epel_pixels_tab[2][2][0] = ff_put_vp8_epel4_v6_mmi;
+    dsp->put_vp8_epel_pixels_tab[2][2][1] = ff_put_vp8_epel4_h4v6_mmi;
+    dsp->put_vp8_epel_pixels_tab[2][2][2] = ff_put_vp8_epel4_h6v6_mmi;
+
+    dsp->put_vp8_bilinear_pixels_tab[0][0][1] = ff_put_vp8_bilinear16_h_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[0][0][2] = ff_put_vp8_bilinear16_h_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[0][1][0] = ff_put_vp8_bilinear16_v_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[0][1][1] = ff_put_vp8_bilinear16_hv_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[0][1][2] = ff_put_vp8_bilinear16_hv_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[0][2][0] = ff_put_vp8_bilinear16_v_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[0][2][1] = ff_put_vp8_bilinear16_hv_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[0][2][2] = ff_put_vp8_bilinear16_hv_mmi;
+
+    dsp->put_vp8_bilinear_pixels_tab[1][0][1] = ff_put_vp8_bilinear8_h_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[1][0][2] = ff_put_vp8_bilinear8_h_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[1][1][0] = ff_put_vp8_bilinear8_v_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[1][1][1] = ff_put_vp8_bilinear8_hv_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[1][1][2] = ff_put_vp8_bilinear8_hv_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[1][2][0] = ff_put_vp8_bilinear8_v_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[1][2][1] = ff_put_vp8_bilinear8_hv_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[1][2][2] = ff_put_vp8_bilinear8_hv_mmi;
+
+    dsp->put_vp8_bilinear_pixels_tab[2][0][1] = ff_put_vp8_bilinear4_h_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[2][0][2] = ff_put_vp8_bilinear4_h_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[2][1][0] = ff_put_vp8_bilinear4_v_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[2][1][1] = ff_put_vp8_bilinear4_hv_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[2][1][2] = ff_put_vp8_bilinear4_hv_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[2][2][0] = ff_put_vp8_bilinear4_v_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[2][2][1] = ff_put_vp8_bilinear4_hv_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[2][2][2] = ff_put_vp8_bilinear4_hv_mmi;
+
+    dsp->put_vp8_epel_pixels_tab[0][0][0]     = ff_put_vp8_pixels16_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[0][0][0] = ff_put_vp8_pixels16_mmi;
+
+    dsp->put_vp8_epel_pixels_tab[1][0][0]     = ff_put_vp8_pixels8_mmi;
+    dsp->put_vp8_bilinear_pixels_tab[1][0][0] = ff_put_vp8_pixels8_mmi;
+
+    dsp->vp8_v_loop_filter16y = ff_vp8_v_loop_filter16_mmi;
+    dsp->vp8_h_loop_filter16y = ff_vp8_h_loop_filter16_mmi;
+    dsp->vp8_v_loop_filter8uv = ff_vp8_v_loop_filter8uv_mmi;
+    dsp->vp8_h_loop_filter8uv = ff_vp8_h_loop_filter8uv_mmi;
+
+    dsp->vp8_v_loop_filter16y_inner = ff_vp8_v_loop_filter16_inner_mmi;
+    dsp->vp8_h_loop_filter16y_inner = ff_vp8_h_loop_filter16_inner_mmi;
+    dsp->vp8_v_loop_filter8uv_inner = ff_vp8_v_loop_filter8uv_inner_mmi;
+    dsp->vp8_h_loop_filter8uv_inner = ff_vp8_h_loop_filter8uv_inner_mmi;
+
+    dsp->vp8_v_loop_filter_simple = ff_vp8_v_loop_filter_simple_mmi;
+    dsp->vp8_h_loop_filter_simple = ff_vp8_h_loop_filter_simple_mmi;
+}
+#endif /* HAVE_MMI */
+
 av_cold void ff_vp8dsp_init_mips(VP8DSPContext *dsp)
 {
 #if HAVE_MSA
     vp8dsp_init_msa(dsp);
 #endif  // #if HAVE_MSA
+#if HAVE_MMI
+    vp8dsp_init_mmi(dsp);
+#endif /* HAVE_MMI */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/vp8dsp_mips.h b/mythtv/external/FFmpeg/libavcodec/mips/vp8dsp_mips.h
index 8e715b58be8..07666ab7a0d 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/vp8dsp_mips.h
+++ b/mythtv/external/FFmpeg/libavcodec/mips/vp8dsp_mips.h
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@imgtec.com)
+ * Copyright (c) 2016 Zhou Xiaoyong <zhouxiaoyong@loongson.cn>
  *
  * This file is part of FFmpeg.
  *
@@ -21,6 +22,11 @@
 #ifndef AVCODEC_MIPS_VP8DSP_MIPS_H
 #define AVCODEC_MIPS_VP8DSP_MIPS_H
 
+#include "libavutil/mem.h"
+#include "libavcodec/vp8dsp.h"
+#include "libavcodec/mathops.h"
+#include "constants.h"
+
 void ff_put_vp8_pixels4_msa(uint8_t *dst, ptrdiff_t dststride,
                             uint8_t *src, ptrdiff_t srcstride,
                             int h, int x, int y);
@@ -169,4 +175,115 @@ void ff_vp8_idct_dc_add4uv_msa(uint8_t *dst, int16_t block[4][16],
 void ff_vp8_idct_dc_add4y_msa(uint8_t *dst, int16_t block[4][16],
                               ptrdiff_t stride);
 
+void ff_vp8_luma_dc_wht_mmi(int16_t block[4][4][16], int16_t dc[16]);
+void ff_vp8_luma_dc_wht_dc_mmi(int16_t block[4][4][16], int16_t dc[16]);
+void ff_vp8_idct_add_mmi(uint8_t *dst, int16_t block[16], ptrdiff_t stride);
+void ff_vp8_idct_dc_add_mmi(uint8_t *dst, int16_t block[16], ptrdiff_t stride);
+void ff_vp8_idct_dc_add4y_mmi(uint8_t *dst, int16_t block[4][16],
+        ptrdiff_t stride);
+void ff_vp8_idct_dc_add4uv_mmi(uint8_t *dst, int16_t block[4][16],
+        ptrdiff_t stride);
+
+void ff_put_vp8_pixels4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int x, int y);
+void ff_put_vp8_pixels8_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int x, int y);
+void ff_put_vp8_pixels16_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int x, int y);
+
+void ff_put_vp8_epel16_h4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel16_h6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel16_v4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel16_v6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel16_h4v4_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel16_h6v4_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel16_h4v6_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel16_h6v6_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+
+void ff_put_vp8_epel8_h4_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel8_h6_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel8_v4_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel8_v6_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel8_h4v4_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel8_h6v4_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel8_h4v6_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel8_h6v6_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+
+void ff_put_vp8_epel4_h4_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel4_h6_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel4_v4_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel4_v6_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel4_h4v4_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel4_h6v4_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel4_h4v6_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_epel4_h6v6_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+
+void ff_put_vp8_bilinear16_h_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_bilinear16_v_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_bilinear16_hv_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+
+void ff_put_vp8_bilinear8_h_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_bilinear8_v_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_bilinear8_hv_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+
+void ff_put_vp8_bilinear4_h_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_bilinear4_v_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+void ff_put_vp8_bilinear4_hv_mmi(uint8_t *dst, ptrdiff_t dststride,
+        uint8_t *src, ptrdiff_t srcstride, int h, int mx, int my);
+
+// loop filter applied to edges between macroblocks
+void ff_vp8_v_loop_filter16_mmi(uint8_t *dst, ptrdiff_t stride, int flim_E,
+        int flim_I, int hev_thresh);
+void ff_vp8_h_loop_filter16_mmi(uint8_t *dst, ptrdiff_t stride, int flim_E,
+        int flim_I, int hev_thresh);
+void ff_vp8_v_loop_filter8uv_mmi(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,
+        int flim_E, int flim_I, int hev_thresh);
+void ff_vp8_h_loop_filter8uv_mmi(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,
+        int flim_E, int flim_I, int hev_thresh);
+
+// loop filter applied to inner macroblock edges
+void ff_vp8_v_loop_filter16_inner_mmi(uint8_t *dst, ptrdiff_t stride,
+        int flim_E, int flim_I, int hev_thresh);
+void ff_vp8_h_loop_filter16_inner_mmi(uint8_t *dst, ptrdiff_t stride,
+        int flim_E, int flim_I, int hev_thresh);
+void ff_vp8_v_loop_filter8uv_inner_mmi(uint8_t *dstU, uint8_t *dstV,
+        ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh);
+void ff_vp8_h_loop_filter8uv_inner_mmi(uint8_t *dstU, uint8_t *dstV,
+        ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh);
+
+void ff_vp8_v_loop_filter_simple_mmi(uint8_t *dst, ptrdiff_t stride, int flim);
+void ff_vp8_h_loop_filter_simple_mmi(uint8_t *dst, ptrdiff_t stride, int flim);
+
 #endif  // #ifndef AVCODEC_MIPS_VP8DSP_MIPS_H
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/vp8dsp_mmi.c b/mythtv/external/FFmpeg/libavcodec/mips/vp8dsp_mmi.c
new file mode 100644
index 00000000000..f9726283988
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mips/vp8dsp_mmi.c
@@ -0,0 +1,3052 @@
+/*
+ * Loongson SIMD optimized vp8dsp
+ *
+ * Copyright (c) 2016 Loongson Technology Corporation Limited
+ * Copyright (c) 2016 Zhou Xiaoyong <zhouxiaoyong@loongson.cn>
+ *
+ * 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 "vp8dsp_mips.h"
+#include "constants.h"
+#include "libavutil/mips/mmiutils.h"
+
+#define PUT_VP8_EPEL4_H6_MMI(src, dst)                                      \
+        MMI_ULWC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp2],       %[filter2]          \n\t"   \
+                                                                            \
+        MMI_ULWC1(%[ftmp1], src, -0x01)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter1]          \n\t"   \
+        "psubsh     %[ftmp3],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        MMI_ULWC1(%[ftmp1], src, -0x02)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter0]          \n\t"   \
+        "paddsh     %[ftmp5],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        MMI_ULWC1(%[ftmp1], src, 0x01)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp2],       %[filter3]          \n\t"   \
+                                                                            \
+        MMI_ULWC1(%[ftmp1], src, 0x02)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter4]          \n\t"   \
+        "psubsh     %[ftmp3],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        MMI_ULWC1(%[ftmp1], src, 0x03)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter5]          \n\t"   \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ftmp5]            \n\t"   \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ff_pw_64]         \n\t"   \
+        "psrah      %[ftmp3],   %[ftmp3],       %[ftmp4]            \n\t"   \
+        "packushb   %[ftmp1],   %[ftmp3],       %[ftmp0]            \n\t"   \
+                                                                            \
+        MMI_SWC1(%[ftmp1], dst, 0x00)
+
+
+#define PUT_VP8_EPEL4_H4_MMI(src, dst)                                      \
+        MMI_ULWC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp2],       %[filter2]          \n\t"   \
+                                                                            \
+        MMI_ULWC1(%[ftmp1], src, -0x01)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter1]          \n\t"   \
+        "psubsh     %[ftmp5],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        MMI_ULWC1(%[ftmp1], src, 0x01)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp2],       %[filter3]          \n\t"   \
+                                                                            \
+        MMI_ULWC1(%[ftmp1], src, 0x02)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter4]          \n\t"   \
+        "psubh      %[ftmp3],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ftmp5]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ff_pw_64]         \n\t"   \
+        "psrah      %[ftmp3],   %[ftmp3],       %[ftmp4]            \n\t"   \
+                                                                            \
+        "packushb   %[ftmp1],   %[ftmp3],       %[ftmp0]            \n\t"   \
+        MMI_SWC1(%[ftmp1], dst, 0x00)
+
+
+#define PUT_VP8_EPEL4_V6_MMI(src, src1, dst, srcstride)                     \
+        MMI_ULWC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp2],       %[filter2]          \n\t"   \
+                                                                            \
+        PTR_SUBU   ""#src1",    "#src",         "#srcstride"        \n\t"   \
+        MMI_ULWC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter1]          \n\t"   \
+        "psubsh     %[ftmp3],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        PTR_SUBU   ""#src1",    "#src1",        "#srcstride"        \n\t"   \
+        MMI_ULWC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter0]          \n\t"   \
+        "paddsh     %[ftmp5],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src",         "#srcstride"        \n\t"   \
+        MMI_ULWC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp2],       %[filter3]          \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src1",        "#srcstride"        \n\t"   \
+        MMI_ULWC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter4]          \n\t"   \
+        "psubsh     %[ftmp3],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src1",        "#srcstride"        \n\t"   \
+        MMI_ULWC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter5]          \n\t"   \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ftmp5]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ff_pw_64]         \n\t"   \
+        "psrah      %[ftmp3],   %[ftmp3],       %[ftmp4]            \n\t"   \
+        "packushb   %[ftmp1],   %[ftmp3],       %[ftmp0]            \n\t"   \
+                                                                            \
+        MMI_SWC1(%[ftmp1], dst, 0x00)
+
+
+#define PUT_VP8_EPEL4_V4_MMI(src, src1, dst, srcstride)                     \
+        MMI_ULWC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp2],       %[filter2]          \n\t"   \
+                                                                            \
+        PTR_SUBU   ""#src1",    "#src",         "#srcstride"        \n\t"   \
+        MMI_ULWC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter1]          \n\t"   \
+        "psubsh     %[ftmp5],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src",         "#srcstride"        \n\t"   \
+        MMI_ULWC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp2],       %[filter3]          \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src1",        "#srcstride"        \n\t"   \
+        MMI_ULWC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter4]          \n\t"   \
+        "psubsh     %[ftmp3],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ftmp5]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ff_pw_64]         \n\t"   \
+        "psrah      %[ftmp3],   %[ftmp3],       %[ftmp4]            \n\t"   \
+        "packushb   %[ftmp1],   %[ftmp3],       %[ftmp0]            \n\t"   \
+                                                                            \
+        MMI_SWC1(%[ftmp1], dst, 0x00)
+
+
+#define PUT_VP8_EPEL8_H6_MMI(src, dst)                                      \
+        MMI_ULDC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp5],   %[ftmp2],       %[filter2]          \n\t"   \
+        "pmullh     %[ftmp6],   %[ftmp3],       %[filter2]          \n\t"   \
+                                                                            \
+        MMI_ULDC1(%[ftmp1], src, -0x01)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter1]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter1]          \n\t"   \
+        "psubsh     %[ftmp5],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "psubsh     %[ftmp6],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        MMI_ULDC1(%[ftmp1], src, -0x02)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter0]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter0]          \n\t"   \
+        "paddsh     %[ftmp7],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "paddsh     %[ftmp8],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        MMI_ULDC1(%[ftmp1], src, 0x01)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp5],   %[ftmp2],       %[filter3]          \n\t"   \
+        "pmullh     %[ftmp6],   %[ftmp3],       %[filter3]          \n\t"   \
+                                                                            \
+        MMI_ULDC1(%[ftmp1], src, 0x02)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter4]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter4]          \n\t"   \
+        "psubsh     %[ftmp5],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "psubsh     %[ftmp6],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        MMI_ULDC1(%[ftmp1], src, 0x03)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter5]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter5]          \n\t"   \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ftmp7]            \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ftmp8]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ff_pw_64]         \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ff_pw_64]         \n\t"   \
+        "psrah      %[ftmp5],   %[ftmp5],       %[ftmp4]            \n\t"   \
+        "psrah      %[ftmp6],   %[ftmp6],       %[ftmp4]            \n\t"   \
+        "packushb   %[ftmp1],   %[ftmp5],       %[ftmp6]            \n\t"   \
+                                                                            \
+        MMI_SDC1(%[ftmp1], dst, 0x00)
+
+
+#define PUT_VP8_EPEL8_H4_MMI(src, dst)                                      \
+        MMI_ULDC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp5],   %[ftmp2],       %[filter2]          \n\t"   \
+        "pmullh     %[ftmp6],   %[ftmp3],       %[filter2]          \n\t"   \
+                                                                            \
+        MMI_ULDC1(%[ftmp1], src, -0x01)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter1]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter1]          \n\t"   \
+        "psubsh     %[ftmp7],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "psubsh     %[ftmp8],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        MMI_ULDC1(%[ftmp1], src, 0x01)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp5],   %[ftmp2],       %[filter3]          \n\t"   \
+        "pmullh     %[ftmp6],   %[ftmp3],       %[filter3]          \n\t"   \
+                                                                            \
+        MMI_ULDC1(%[ftmp1], src, 0x02)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter4]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter4]          \n\t"   \
+        "psubsh     %[ftmp5],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "psubsh     %[ftmp6],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ftmp7]            \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ftmp8]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ff_pw_64]         \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ff_pw_64]         \n\t"   \
+        "psrah      %[ftmp5],   %[ftmp5],       %[ftmp4]            \n\t"   \
+        "psrah      %[ftmp6],   %[ftmp6],       %[ftmp4]            \n\t"   \
+                                                                            \
+        "packushb   %[ftmp1],   %[ftmp5],       %[ftmp6]            \n\t"   \
+        MMI_SDC1(%[ftmp1], dst, 0x00)
+
+
+#define PUT_VP8_EPEL8_V6_MMI(src, src1, dst, srcstride)                     \
+        MMI_ULDC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp5],   %[ftmp2],       %[filter2]          \n\t"   \
+        "pmullh     %[ftmp6],   %[ftmp3],       %[filter2]          \n\t"   \
+                                                                            \
+        PTR_SUBU   ""#src1",    "#src",         "#srcstride"        \n\t"   \
+        MMI_ULDC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter1]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter1]          \n\t"   \
+        "psubsh     %[ftmp5],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "psubsh     %[ftmp6],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        PTR_SUBU   ""#src1",    "#src1",        "#srcstride"        \n\t"   \
+        MMI_ULDC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter0]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter0]          \n\t"   \
+        "paddsh     %[ftmp7],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "paddsh     %[ftmp8],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src",         "#srcstride"        \n\t"   \
+        MMI_ULDC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp5],   %[ftmp2],       %[filter3]          \n\t"   \
+        "pmullh     %[ftmp6],   %[ftmp3],       %[filter3]          \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src1",        "#srcstride"        \n\t"   \
+        MMI_ULDC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter4]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter4]          \n\t"   \
+        "psubsh     %[ftmp5],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "psubsh     %[ftmp6],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src1",        "#srcstride"        \n\t"   \
+        MMI_ULDC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter5]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter5]          \n\t"   \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ftmp7]            \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ftmp8]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ff_pw_64]         \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ff_pw_64]         \n\t"   \
+        "psrah      %[ftmp5],   %[ftmp5],       %[ftmp4]            \n\t"   \
+        "psrah      %[ftmp6],   %[ftmp6],       %[ftmp4]            \n\t"   \
+        "packushb   %[ftmp1],   %[ftmp5],       %[ftmp6]            \n\t"   \
+                                                                            \
+        MMI_SDC1(%[ftmp1], dst, 0x00)
+
+
+#define PUT_VP8_EPEL8_V4_MMI(src, src1, dst, srcstride)                     \
+        MMI_ULDC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp5],   %[ftmp2],       %[filter2]          \n\t"   \
+        "pmullh     %[ftmp6],   %[ftmp3],       %[filter2]          \n\t"   \
+                                                                            \
+        PTR_SUBU   ""#src1",    "#src",         "#srcstride"        \n\t"   \
+        MMI_ULDC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter1]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter1]          \n\t"   \
+        "psubsh     %[ftmp7],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "psubsh     %[ftmp8],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src",         "#srcstride"        \n\t"   \
+        MMI_ULDC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp5],   %[ftmp2],       %[filter3]          \n\t"   \
+        "pmullh     %[ftmp6],   %[ftmp3],       %[filter3]          \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src1",        "#srcstride"        \n\t"   \
+        MMI_ULDC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[filter4]          \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[filter4]          \n\t"   \
+        "psubsh     %[ftmp5],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "psubsh     %[ftmp6],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ftmp7]            \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ftmp8]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ff_pw_64]         \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ff_pw_64]         \n\t"   \
+        "psrah      %[ftmp5],   %[ftmp5],       %[ftmp4]            \n\t"   \
+        "psrah      %[ftmp6],   %[ftmp6],       %[ftmp4]            \n\t"   \
+        "packushb   %[ftmp1],   %[ftmp5],       %[ftmp6]            \n\t"   \
+                                                                            \
+        MMI_SDC1(%[ftmp1], dst, 0x00)
+
+
+#define PUT_VP8_BILINEAR8_H_MMI(src, dst)                                   \
+        MMI_ULDC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp5],   %[ftmp2],       %[a]                \n\t"   \
+        "pmullh     %[ftmp6],   %[ftmp3],       %[a]                \n\t"   \
+                                                                            \
+        MMI_ULDC1(%[ftmp1], src, 0x01)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[b]                \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[b]                \n\t"   \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ff_pw_4]          \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ff_pw_4]          \n\t"   \
+        "psrah      %[ftmp5],   %[ftmp5],       %[ftmp4]            \n\t"   \
+        "psrah      %[ftmp6],   %[ftmp6],       %[ftmp4]            \n\t"   \
+                                                                            \
+        "packushb   %[ftmp1],   %[ftmp5],       %[ftmp6]            \n\t"   \
+        MMI_SDC1(%[ftmp1], dst, 0x00)
+
+
+#define PUT_VP8_BILINEAR4_H_MMI(src, dst)                                   \
+        MMI_ULWC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp2],       %[a]                \n\t"   \
+                                                                            \
+        MMI_ULWC1(%[ftmp1], src, 0x01)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[b]                \n\t"   \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ff_pw_4]          \n\t"   \
+        "psrah      %[ftmp3],   %[ftmp3],       %[ftmp4]            \n\t"   \
+                                                                            \
+        "packushb   %[ftmp1],   %[ftmp3],       %[ftmp0]            \n\t"   \
+        MMI_SWC1(%[ftmp1], dst, 0x00)
+
+
+#define PUT_VP8_BILINEAR8_V_MMI(src, src1, dst, sstride)                    \
+        MMI_ULDC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp5],   %[ftmp2],       %[c]                \n\t"   \
+        "pmullh     %[ftmp6],   %[ftmp3],       %[c]                \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src",         "#sstride"          \n\t"   \
+        MMI_ULDC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "punpckhbh  %[ftmp3],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[d]                \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp3],       %[d]                \n\t"   \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ftmp2]            \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ftmp3]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp5],   %[ftmp5],       %[ff_pw_4]          \n\t"   \
+        "paddsh     %[ftmp6],   %[ftmp6],       %[ff_pw_4]          \n\t"   \
+        "psrah      %[ftmp5],   %[ftmp5],       %[ftmp4]            \n\t"   \
+        "psrah      %[ftmp6],   %[ftmp6],       %[ftmp4]            \n\t"   \
+                                                                            \
+        "packushb   %[ftmp1],   %[ftmp5],       %[ftmp6]            \n\t"   \
+        MMI_SDC1(%[ftmp1], dst, 0x00)
+
+
+#define PUT_VP8_BILINEAR4_V_MMI(src, src1, dst, sstride)                    \
+        MMI_ULWC1(%[ftmp1], src, 0x00)                                      \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp3],   %[ftmp2],       %[c]                \n\t"   \
+                                                                            \
+        PTR_ADDU   ""#src1",    "#src",         "#sstride"          \n\t"   \
+        MMI_ULWC1(%[ftmp1], src1, 0x00)                                     \
+        "punpcklbh  %[ftmp2],   %[ftmp1],       %[ftmp0]            \n\t"   \
+        "pmullh     %[ftmp2],   %[ftmp2],       %[d]                \n\t"   \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ftmp2]            \n\t"   \
+                                                                            \
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ff_pw_4]          \n\t"   \
+        "psrah      %[ftmp3],   %[ftmp3],       %[ftmp4]            \n\t"   \
+                                                                            \
+        "packushb   %[ftmp1],   %[ftmp3],       %[ftmp0]            \n\t"   \
+        MMI_SWC1(%[ftmp1], dst, 0x00)
+
+
+DECLARE_ALIGNED(8, static const uint64_t, fourtap_subpel_filters[7][6]) = {
+   {0x0000000000000000, 0x0006000600060006, 0x007b007b007b007b,
+    0x000c000c000c000c, 0x0001000100010001, 0x0000000000000000},
+
+   {0x0002000200020002, 0x000b000b000b000b, 0x006c006c006c006c,
+    0x0024002400240024, 0x0008000800080008, 0x0001000100010001},
+
+   {0x0000000000000000, 0x0009000900090009, 0x005d005d005d005d,
+    0x0032003200320032, 0x0006000600060006, 0x0000000000000000},
+
+   {0x0003000300030003, 0x0010001000100010, 0x004d004d004d004d,
+    0x004d004d004d004d, 0x0010001000100010, 0x0003000300030003},
+
+   {0x0000000000000000, 0x0006000600060006, 0x0032003200320032,
+    0x005d005d005d005d, 0x0009000900090009, 0x0000000000000000},
+
+   {0x0001000100010001, 0x0008000800080008, 0x0024002400240024,
+    0x006c006c006c006c, 0x000b000b000b000b, 0x0002000200020002},
+
+   {0x0000000000000000, 0x0001000100010001, 0x000c000c000c000c,
+    0x007b007b007b007b, 0x0006000600060006, 0x0000000000000000}
+};
+
+#if 0
+#define FILTER_6TAP(src, F, stride)                                           \
+    cm[(F[2] * src[x + 0 * stride] - F[1] * src[x - 1 * stride] +             \
+        F[0] * src[x - 2 * stride] + F[3] * src[x + 1 * stride] -             \
+        F[4] * src[x + 2 * stride] + F[5] * src[x + 3 * stride] + 64) >> 7]
+
+#define FILTER_4TAP(src, F, stride)                                           \
+    cm[(F[2] * src[x + 0 * stride] - F[1] * src[x - 1 * stride] +             \
+        F[3] * src[x + 1 * stride] - F[4] * src[x + 2 * stride] + 64) >> 7]
+
+static const uint8_t subpel_filters[7][6] = {
+    { 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 MUL_20091(a) ((((a) * 20091) >> 16) + (a))
+#define MUL_35468(a)  (((a) * 35468) >> 16)
+#endif
+
+#define clip_int8(n) (cm[(n) + 0x80] - 0x80)
+static av_always_inline void vp8_filter_common_is4tap(uint8_t *p,
+        ptrdiff_t stride)
+{
+    int av_unused p1 = p[-2 * stride];
+    int av_unused p0 = p[-1 * stride];
+    int av_unused q0 = p[ 0 * stride];
+    int av_unused q1 = p[ 1 * stride];
+    int a, f1, f2;
+    const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
+
+    a = 3 * (q0 - p0);
+    a += clip_int8(p1 - q1);
+    a = clip_int8(a);
+
+    // We deviate from the spec here with c(a+3) >> 3
+    // since that's what libvpx does.
+    f1 = FFMIN(a + 4, 127) >> 3;
+    f2 = FFMIN(a + 3, 127) >> 3;
+
+    // Despite what the spec says, we do need to clamp here to
+    // be bitexact with libvpx.
+    p[-1 * stride] = cm[p0 + f2];
+    p[ 0 * stride] = cm[q0 - f1];
+}
+
+static av_always_inline void vp8_filter_common_isnot4tap(uint8_t *p,
+        ptrdiff_t stride)
+{
+    int av_unused p1 = p[-2 * stride];
+    int av_unused p0 = p[-1 * stride];
+    int av_unused q0 = p[ 0 * stride];
+    int av_unused q1 = p[ 1 * stride];
+    int a, f1, f2;
+    const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
+
+    a = 3 * (q0 - p0);
+    a = clip_int8(a);
+
+    // We deviate from the spec here with c(a+3) >> 3
+    // since that's what libvpx does.
+    f1 = FFMIN(a + 4, 127) >> 3;
+    f2 = FFMIN(a + 3, 127) >> 3;
+
+    // Despite what the spec says, we do need to clamp here to
+    // be bitexact with libvpx.
+    p[-1 * stride] = cm[p0 + f2];
+    p[ 0 * stride] = cm[q0 - f1];
+    a              = (f1 + 1) >> 1;
+    p[-2 * stride] = cm[p1 + a];
+    p[ 1 * stride] = cm[q1 - a];
+}
+
+static av_always_inline int vp8_simple_limit(uint8_t *p, ptrdiff_t stride,
+        int flim)
+{
+    int av_unused p1 = p[-2 * stride];
+    int av_unused p0 = p[-1 * stride];
+    int av_unused q0 = p[ 0 * stride];
+    int av_unused q1 = p[ 1 * stride];
+
+    return 2 * FFABS(p0 - q0) + (FFABS(p1 - q1) >> 1) <= flim;
+}
+
+static av_always_inline int hev(uint8_t *p, ptrdiff_t stride, int thresh)
+{
+    int av_unused p1 = p[-2 * stride];
+    int av_unused p0 = p[-1 * stride];
+    int av_unused q0 = p[ 0 * stride];
+    int av_unused q1 = p[ 1 * stride];
+
+    return FFABS(p1 - p0) > thresh || FFABS(q1 - q0) > thresh;
+}
+
+static av_always_inline void filter_mbedge(uint8_t *p, ptrdiff_t stride)
+{
+    int a0, a1, a2, w;
+    const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
+
+    int av_unused p2 = p[-3 * stride];
+    int av_unused p1 = p[-2 * stride];
+    int av_unused p0 = p[-1 * stride];
+    int av_unused q0 = p[ 0 * stride];
+    int av_unused q1 = p[ 1 * stride];
+    int av_unused q2 = p[ 2 * stride];
+
+    w = clip_int8(p1 - q1);
+    w = clip_int8(w + 3 * (q0 - p0));
+
+    a0 = (27 * w + 63) >> 7;
+    a1 = (18 * w + 63) >> 7;
+    a2 =  (9 * w + 63) >> 7;
+
+    p[-3 * stride] = cm[p2 + a2];
+    p[-2 * stride] = cm[p1 + a1];
+    p[-1 * stride] = cm[p0 + a0];
+    p[ 0 * stride] = cm[q0 - a0];
+    p[ 1 * stride] = cm[q1 - a1];
+    p[ 2 * stride] = cm[q2 - a2];
+}
+
+static av_always_inline int vp8_normal_limit(uint8_t *p, ptrdiff_t stride,
+        int E, int I)
+{
+    int av_unused p3 = p[-4 * stride];
+    int av_unused p2 = p[-3 * stride];
+    int av_unused p1 = p[-2 * stride];
+    int av_unused p0 = p[-1 * stride];
+    int av_unused q0 = p[ 0 * stride];
+    int av_unused q1 = p[ 1 * stride];
+    int av_unused q2 = p[ 2 * stride];
+    int av_unused q3 = p[ 3 * stride];
+
+    return vp8_simple_limit(p, stride, E) &&
+           FFABS(p3 - p2) <= I && FFABS(p2 - p1) <= I &&
+           FFABS(p1 - p0) <= I && FFABS(q3 - q2) <= I &&
+           FFABS(q2 - q1) <= I && FFABS(q1 - q0) <= I;
+}
+
+static av_always_inline void vp8_v_loop_filter8_mmi(uint8_t *dst,
+        ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
+{
+    int i;
+
+    for (i = 0; i < 8; i++)
+        if (vp8_normal_limit(dst + i * 1, stride, flim_E, flim_I)) {
+            if (hev(dst + i * 1, stride, hev_thresh))
+                vp8_filter_common_is4tap(dst + i * 1, stride);
+            else
+                filter_mbedge(dst + i * 1, stride);
+        }
+}
+
+static av_always_inline void vp8_v_loop_filter8_inner_mmi(uint8_t *dst,
+        ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
+{
+    int i;
+
+    for (i = 0; i < 8; i++)
+        if (vp8_normal_limit(dst + i * 1, stride, flim_E, flim_I)) {
+            int hv = hev(dst + i * 1, stride, hev_thresh);
+            if (hv)
+                vp8_filter_common_is4tap(dst + i * 1, stride);
+            else
+                vp8_filter_common_isnot4tap(dst + i * 1, stride);
+        }
+}
+
+static av_always_inline void vp8_h_loop_filter8_mmi(uint8_t *dst,
+        ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
+{
+    int i;
+
+    for (i = 0; i < 8; i++)
+        if (vp8_normal_limit(dst + i * stride, 1, flim_E, flim_I)) {
+            if (hev(dst + i * stride, 1, hev_thresh))
+                vp8_filter_common_is4tap(dst + i * stride, 1);
+            else
+                filter_mbedge(dst + i * stride, 1);
+        }
+}
+
+static av_always_inline void vp8_h_loop_filter8_inner_mmi(uint8_t *dst,
+        ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
+{
+    int i;
+
+    for (i = 0; i < 8; i++)
+        if (vp8_normal_limit(dst + i * stride, 1, flim_E, flim_I)) {
+            int hv = hev(dst + i * stride, 1, hev_thresh);
+            if (hv)
+                vp8_filter_common_is4tap(dst + i * stride, 1);
+            else
+                vp8_filter_common_isnot4tap(dst + i * stride, 1);
+        }
+}
+
+void ff_vp8_luma_dc_wht_mmi(int16_t block[4][4][16], int16_t dc[16])
+{
+#if 1
+    double ftmp[8];
+    DECLARE_VAR_ALL64;
+
+    __asm__ volatile (
+        MMI_LDC1(%[ftmp0], %[dc], 0x00)
+        MMI_LDC1(%[ftmp1], %[dc], 0x08)
+        MMI_LDC1(%[ftmp2], %[dc], 0x10)
+        MMI_LDC1(%[ftmp3], %[dc], 0x18)
+        "paddsh     %[ftmp4],   %[ftmp0],       %[ftmp3]            \n\t"
+        "psubsh     %[ftmp5],   %[ftmp0],       %[ftmp3]            \n\t"
+        "paddsh     %[ftmp6],   %[ftmp1],       %[ftmp2]            \n\t"
+        "psubsh     %[ftmp7],   %[ftmp1],       %[ftmp2]            \n\t"
+        "paddsh     %[ftmp0],   %[ftmp4],       %[ftmp6]            \n\t"
+        "paddsh     %[ftmp1],   %[ftmp5],       %[ftmp7]            \n\t"
+        "psubsh     %[ftmp2],   %[ftmp4],       %[ftmp6]            \n\t"
+        "psubsh     %[ftmp3],   %[ftmp5],       %[ftmp7]            \n\t"
+        MMI_SDC1(%[ftmp0], %[dc], 0x00)
+        MMI_SDC1(%[ftmp1], %[dc], 0x08)
+        MMI_SDC1(%[ftmp2], %[dc], 0x10)
+        MMI_SDC1(%[ftmp3], %[dc], 0x18)
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),
+          RESTRICT_ASM_ALL64
+          [ftmp7]"=&f"(ftmp[7])
+        : [dc]"r"((uint8_t*)dc)
+        : "memory"
+    );
+
+    block[0][0][0] = (dc[0] + dc[3] + 3 + dc[1] + dc[2]) >> 3;
+    block[0][1][0] = (dc[0] - dc[3] + 3 + dc[1] - dc[2]) >> 3;
+    block[0][2][0] = (dc[0] + dc[3] + 3 - dc[1] - dc[2]) >> 3;
+    block[0][3][0] = (dc[0] - dc[3] + 3 - dc[1] + dc[2]) >> 3;
+
+    block[1][0][0] = (dc[4] + dc[7] + 3 + dc[5] + dc[6]) >> 3;
+    block[1][1][0] = (dc[4] - dc[7] + 3 + dc[5] - dc[6]) >> 3;
+    block[1][2][0] = (dc[4] + dc[7] + 3 - dc[5] - dc[6]) >> 3;
+    block[1][3][0] = (dc[4] - dc[7] + 3 - dc[5] + dc[6]) >> 3;
+
+    block[2][0][0] = (dc[8] + dc[11] + 3 + dc[9] + dc[10]) >> 3;
+    block[2][1][0] = (dc[8] - dc[11] + 3 + dc[9] - dc[10]) >> 3;
+    block[2][2][0] = (dc[8] + dc[11] + 3 - dc[9] - dc[10]) >> 3;
+    block[2][3][0] = (dc[8] - dc[11] + 3 - dc[9] + dc[10]) >> 3;
+
+    block[3][0][0] = (dc[12] + dc[15] + 3 + dc[13] + dc[14]) >> 3;
+    block[3][1][0] = (dc[12] - dc[15] + 3 + dc[13] - dc[14]) >> 3;
+    block[3][2][0] = (dc[12] + dc[15] + 3 - dc[13] - dc[14]) >> 3;
+    block[3][3][0] = (dc[12] - dc[15] + 3 - dc[13] + dc[14]) >> 3;
+
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        MMI_SDC1(%[ftmp0], %[dc], 0x00)
+        MMI_SDC1(%[ftmp0], %[dc], 0x08)
+        MMI_SDC1(%[ftmp0], %[dc], 0x10)
+        MMI_SDC1(%[ftmp0], %[dc], 0x18)
+        : RESTRICT_ASM_ALL64
+          [ftmp0]"=&f"(ftmp[0])
+        : [dc]"r"((uint8_t *)dc)
+        : "memory"
+    );
+#else
+    int t00, t01, t02, t03, t10, t11, t12, t13, t20, t21, t22, t23, t30, t31, t32, t33;
+
+    t00 = dc[0] + dc[12];
+    t10 = dc[1] + dc[13];
+    t20 = dc[2] + dc[14];
+    t30 = dc[3] + dc[15];
+
+    t03 = dc[0] - dc[12];
+    t13 = dc[1] - dc[13];
+    t23 = dc[2] - dc[14];
+    t33 = dc[3] - dc[15];
+
+    t01 = dc[4] + dc[ 8];
+    t11 = dc[5] + dc[ 9];
+    t21 = dc[6] + dc[10];
+    t31 = dc[7] + dc[11];
+
+    t02 = dc[4] - dc[ 8];
+    t12 = dc[5] - dc[ 9];
+    t22 = dc[6] - dc[10];
+    t32 = dc[7] - dc[11];
+
+    dc[ 0] = t00 + t01;
+    dc[ 1] = t10 + t11;
+    dc[ 2] = t20 + t21;
+    dc[ 3] = t30 + t31;
+
+    dc[ 4] = t03 + t02;
+    dc[ 5] = t13 + t12;
+    dc[ 6] = t23 + t22;
+    dc[ 7] = t33 + t32;
+
+    dc[ 8] = t00 - t01;
+    dc[ 9] = t10 - t11;
+    dc[10] = t20 - t21;
+    dc[11] = t30 - t31;
+
+    dc[12] = t03 - t02;
+    dc[13] = t13 - t12;
+    dc[14] = t23 - t22;
+    dc[15] = t33 - t32;
+
+    block[0][0][0] = (dc[0] + dc[3] + 3 + dc[1] + dc[2]) >> 3;
+    block[0][1][0] = (dc[0] - dc[3] + 3 + dc[1] - dc[2]) >> 3;
+    block[0][2][0] = (dc[0] + dc[3] + 3 - dc[1] - dc[2]) >> 3;
+    block[0][3][0] = (dc[0] - dc[3] + 3 - dc[1] + dc[2]) >> 3;
+
+    block[1][0][0] = (dc[4] + dc[7] + 3 + dc[5] + dc[6]) >> 3;
+    block[1][1][0] = (dc[4] - dc[7] + 3 + dc[5] - dc[6]) >> 3;
+    block[1][2][0] = (dc[4] + dc[7] + 3 - dc[5] - dc[6]) >> 3;
+    block[1][3][0] = (dc[4] - dc[7] + 3 - dc[5] + dc[6]) >> 3;
+
+    block[2][0][0] = (dc[8] + dc[11] + 3 + dc[9] + dc[10]) >> 3;
+    block[2][1][0] = (dc[8] - dc[11] + 3 + dc[9] - dc[10]) >> 3;
+    block[2][2][0] = (dc[8] + dc[11] + 3 - dc[9] - dc[10]) >> 3;
+    block[2][3][0] = (dc[8] - dc[11] + 3 - dc[9] + dc[10]) >> 3;
+
+    block[3][0][0] = (dc[12] + dc[15] + 3 + dc[13] + dc[14]) >> 3;
+    block[3][1][0] = (dc[12] - dc[15] + 3 + dc[13] - dc[14]) >> 3;
+    block[3][2][0] = (dc[12] + dc[15] + 3 - dc[13] - dc[14]) >> 3;
+    block[3][3][0] = (dc[12] - dc[15] + 3 - dc[13] + dc[14]) >> 3;
+
+    AV_ZERO64(dc + 0);
+    AV_ZERO64(dc + 4);
+    AV_ZERO64(dc + 8);
+    AV_ZERO64(dc + 12);
+#endif
+}
+
+void ff_vp8_luma_dc_wht_dc_mmi(int16_t block[4][4][16], int16_t dc[16])
+{
+    int val = (dc[0] + 3) >> 3;
+
+    dc[0] = 0;
+
+    block[0][0][0] = val;
+    block[0][1][0] = val;
+    block[0][2][0] = val;
+    block[0][3][0] = val;
+    block[1][0][0] = val;
+    block[1][1][0] = val;
+    block[1][2][0] = val;
+    block[1][3][0] = val;
+    block[2][0][0] = val;
+    block[2][1][0] = val;
+    block[2][2][0] = val;
+    block[2][3][0] = val;
+    block[3][0][0] = val;
+    block[3][1][0] = val;
+    block[3][2][0] = val;
+    block[3][3][0] = val;
+}
+
+void ff_vp8_idct_add_mmi(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
+{
+#if 1
+    DECLARE_ALIGNED(8, const uint64_t, ff_ph_4e7b) = {0x4e7b4e7b4e7b4e7bULL};
+    DECLARE_ALIGNED(8, const uint64_t, ff_ph_22a3) = {0x22a322a322a322a3ULL};
+    double ftmp[12];
+    uint32_t tmp[1];
+    DECLARE_VAR_LOW32;
+    DECLARE_VAR_ALL64;
+
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        MMI_LDC1(%[ftmp1], %[block], 0x00)
+        MMI_LDC1(%[ftmp2], %[block], 0x08)
+        MMI_LDC1(%[ftmp3], %[block], 0x10)
+        MMI_LDC1(%[ftmp4], %[block], 0x18)
+
+        "li         %[tmp0],    0x02                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp11]                           \n\t"
+
+        // block[0...3] + block[8...11]
+        "paddh      %[ftmp5],   %[ftmp1],       %[ftmp3]            \n\t"
+        // block[0...3] - block[8...11]
+        "psubh      %[ftmp6],   %[ftmp1],       %[ftmp3]            \n\t"
+        // MUL_35468(block[12...15])
+        "psllh      %[ftmp9],   %[ftmp4],       %[ftmp11]           \n\t"
+        "pmulhh     %[ftmp7],   %[ftmp9],       %[ff_ph_22a3]       \n\t"
+        // MUL_35468(block[4...7])
+        "psllh      %[ftmp9],   %[ftmp2],       %[ftmp11]           \n\t"
+        "pmulhh     %[ftmp8],   %[ftmp9],       %[ff_ph_22a3]       \n\t"
+        // MUL_20091(block[4...7]
+        "pmulhh     %[ftmp9],   %[ftmp2],       %[ff_ph_4e7b]       \n\t"
+        "paddh      %[ftmp9],   %[ftmp9],       %[ftmp2]            \n\t"
+        // MUL_20091(block[12...15])
+        "pmulhh     %[ftmp10],  %[ftmp4],       %[ff_ph_4e7b]       \n\t"
+        "paddh      %[ftmp10],  %[ftmp10],      %[ftmp4]            \n\t"
+
+        // tmp[0 4  8 12]
+        "paddh      %[ftmp1],   %[ftmp5],       %[ftmp7]            \n\t"
+        "paddh      %[ftmp1],   %[ftmp1],       %[ftmp9]            \n\t"
+        // tmp[1 5  9 13]
+        "paddh      %[ftmp2],   %[ftmp6],       %[ftmp8]            \n\t"
+        "psubh      %[ftmp2],   %[ftmp2],       %[ftmp10]           \n\t"
+        // tmp[2 6 10 14]
+        "psubh      %[ftmp3],   %[ftmp6],       %[ftmp8]            \n\t"
+        "paddh      %[ftmp3],   %[ftmp3],       %[ftmp10]           \n\t"
+        // tmp[3 7 11 15]
+        "psubh      %[ftmp4],   %[ftmp5],       %[ftmp7]            \n\t"
+        "psubh      %[ftmp4],   %[ftmp4],       %[ftmp9]            \n\t"
+
+        MMI_SDC1(%[ftmp0], %[block], 0x00)
+        MMI_SDC1(%[ftmp0], %[block], 0x08)
+        MMI_SDC1(%[ftmp0], %[block], 0x10)
+        MMI_SDC1(%[ftmp0], %[block], 0x18)
+
+        TRANSPOSE_4H(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                     %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                     %[ftmp9], %[tmp0],  %[ftmp0], %[ftmp10])
+
+        // t[0 4  8 12]
+        "paddh      %[ftmp5],   %[ftmp1],       %[ftmp3]            \n\t"
+        // t[1 5  9 13]
+        "psubh      %[ftmp6],   %[ftmp1],       %[ftmp3]            \n\t"
+        // t[2 6 10 14]
+        "psllh      %[ftmp9],   %[ftmp2],       %[ftmp11]           \n\t"
+        "pmulhh     %[ftmp9],   %[ftmp9],       %[ff_ph_22a3]       \n\t"
+        "psubh      %[ftmp7],   %[ftmp9],       %[ftmp4]            \n\t"
+        "pmulhh     %[ftmp10],  %[ftmp4],       %[ff_ph_4e7b]       \n\t"
+        "psubh      %[ftmp7],   %[ftmp7],       %[ftmp10]           \n\t"
+        // t[3 7 11 15]
+        "psllh      %[ftmp9],   %[ftmp4],       %[ftmp11]           \n\t"
+        "pmulhh     %[ftmp9],   %[ftmp9],       %[ff_ph_22a3]       \n\t"
+        "paddh      %[ftmp8],   %[ftmp9],       %[ftmp2]            \n\t"
+        "pmulhh     %[ftmp10],  %[ftmp2],       %[ff_ph_4e7b]       \n\t"
+        "paddh      %[ftmp8],   %[ftmp8],       %[ftmp10]           \n\t"
+
+        "li         %[tmp0],    0x03                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp11]                           \n\t"
+        "paddh      %[ftmp1],   %[ftmp5],       %[ftmp8]            \n\t"
+        "paddh      %[ftmp1],   %[ftmp1],       %[ff_pw_4]          \n\t"
+        "psrah      %[ftmp1],   %[ftmp1],       %[ftmp11]           \n\t"
+        "paddh      %[ftmp2],   %[ftmp6],       %[ftmp7]            \n\t"
+        "paddh      %[ftmp2],   %[ftmp2],       %[ff_pw_4]          \n\t"
+        "psrah      %[ftmp2],   %[ftmp2],       %[ftmp11]           \n\t"
+        "psubh      %[ftmp3],   %[ftmp6],       %[ftmp7]            \n\t"
+        "paddh      %[ftmp3],   %[ftmp3],       %[ff_pw_4]          \n\t"
+        "psrah      %[ftmp3],   %[ftmp3],       %[ftmp11]           \n\t"
+        "psubh      %[ftmp4],   %[ftmp5],       %[ftmp8]            \n\t"
+        "paddh      %[ftmp4],   %[ftmp4],       %[ff_pw_4]          \n\t"
+        "psrah      %[ftmp4],   %[ftmp4],       %[ftmp11]           \n\t"
+
+        TRANSPOSE_4H(%[ftmp1], %[ftmp2], %[ftmp3], %[ftmp4],
+                     %[ftmp5], %[ftmp6], %[ftmp7], %[ftmp8],
+                     %[ftmp9], %[tmp0],  %[ftmp0], %[ftmp10])
+
+        MMI_LWC1(%[ftmp5], %[dst0], 0x00)
+        MMI_LWC1(%[ftmp6], %[dst1], 0x00)
+        MMI_LWC1(%[ftmp7], %[dst2], 0x00)
+        MMI_LWC1(%[ftmp8], %[dst3], 0x00)
+
+        "punpcklbh  %[ftmp5],   %[ftmp5],       %[ftmp0]            \n\t"
+        "punpcklbh  %[ftmp6],   %[ftmp6],       %[ftmp0]            \n\t"
+        "punpcklbh  %[ftmp7],   %[ftmp7],       %[ftmp0]            \n\t"
+        "punpcklbh  %[ftmp8],   %[ftmp8],       %[ftmp0]            \n\t"
+
+        "paddh      %[ftmp1],   %[ftmp1],       %[ftmp5]            \n\t"
+        "paddh      %[ftmp2],   %[ftmp2],       %[ftmp6]            \n\t"
+        "paddh      %[ftmp3],   %[ftmp3],       %[ftmp7]            \n\t"
+        "paddh      %[ftmp4],   %[ftmp4],       %[ftmp8]            \n\t"
+
+        "packushb   %[ftmp1],   %[ftmp1],       %[ftmp0]            \n\t"
+        "packushb   %[ftmp2],   %[ftmp2],       %[ftmp0]            \n\t"
+        "packushb   %[ftmp3],   %[ftmp3],       %[ftmp0]            \n\t"
+        "packushb   %[ftmp4],   %[ftmp4],       %[ftmp0]            \n\t"
+
+        MMI_SWC1(%[ftmp1], %[dst0], 0x00)
+        MMI_SWC1(%[ftmp2], %[dst1], 0x00)
+        MMI_SWC1(%[ftmp3], %[dst2], 0x00)
+        MMI_SWC1(%[ftmp4], %[dst3], 0x00)
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),            [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),            [ftmp9]"=&f"(ftmp[9]),
+          [ftmp10]"=&f"(ftmp[10]),          [ftmp11]"=&f"(ftmp[11]),
+          RESTRICT_ASM_LOW32
+          RESTRICT_ASM_ALL64
+          [tmp0]"=&r"(tmp[0])
+        : [dst0]"r"(dst),                   [dst1]"r"(dst+stride),
+          [dst2]"r"(dst+2*stride),          [dst3]"r"(dst+3*stride),
+          [block]"r"(block),                [ff_pw_4]"f"(ff_pw_4),
+          [ff_ph_4e7b]"f"(ff_ph_4e7b),      [ff_ph_22a3]"f"(ff_ph_22a3)
+        : "memory"
+    );
+#else
+    int i, t0, t1, t2, t3;
+    int16_t tmp[16];
+
+    for (i = 0; i < 4; i++) {
+        t0 = block[0 + i] + block[8 + i];
+        t1 = block[0 + i] - block[8 + i];
+        t2 = MUL_35468(block[4 + i]) - MUL_20091(block[12 + i]);
+        t3 = MUL_20091(block[4 + i]) + MUL_35468(block[12 + i]);
+        block[ 0 + i] = 0;
+        block[ 4 + i] = 0;
+        block[ 8 + i] = 0;
+        block[12 + i] = 0;
+
+        tmp[i * 4 + 0] = t0 + t3;
+        tmp[i * 4 + 1] = t1 + t2;
+        tmp[i * 4 + 2] = t1 - t2;
+        tmp[i * 4 + 3] = t0 - t3;
+    }
+
+    for (i = 0; i < 4; i++) {
+        t0 = tmp[0 + i] + tmp[8 + i];
+        t1 = tmp[0 + i] - tmp[8 + i];
+        t2 = MUL_35468(tmp[4 + i]) - MUL_20091(tmp[12 + i]);
+        t3 = MUL_20091(tmp[4 + i]) + MUL_35468(tmp[12 + i]);
+
+        dst[0] = av_clip_uint8(dst[0] + ((t0 + t3 + 4) >> 3));
+        dst[1] = av_clip_uint8(dst[1] + ((t1 + t2 + 4) >> 3));
+        dst[2] = av_clip_uint8(dst[2] + ((t1 - t2 + 4) >> 3));
+        dst[3] = av_clip_uint8(dst[3] + ((t0 - t3 + 4) >> 3));
+        dst   += stride;
+    }
+#endif
+}
+
+void ff_vp8_idct_dc_add_mmi(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
+{
+#if 1
+    int dc = (block[0] + 4) >> 3;
+    double ftmp[6];
+    DECLARE_VAR_LOW32;
+
+    block[0] = 0;
+
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "mtc1       %[dc],      %[ftmp5]                            \n\t"
+        MMI_LWC1(%[ftmp1], %[dst0], 0x00)
+        MMI_LWC1(%[ftmp2], %[dst1], 0x00)
+        MMI_LWC1(%[ftmp3], %[dst2], 0x00)
+        MMI_LWC1(%[ftmp4], %[dst3], 0x00)
+        "pshufh     %[ftmp5],   %[ftmp5],       %[ftmp0]            \n\t"
+        "punpcklbh  %[ftmp1],   %[ftmp1],       %[ftmp0]            \n\t"
+        "punpcklbh  %[ftmp2],   %[ftmp2],       %[ftmp0]            \n\t"
+        "punpcklbh  %[ftmp3],   %[ftmp3],       %[ftmp0]            \n\t"
+        "punpcklbh  %[ftmp4],   %[ftmp4],       %[ftmp0]            \n\t"
+        "paddsh     %[ftmp1],   %[ftmp1],       %[ftmp5]            \n\t"
+        "paddsh     %[ftmp2],   %[ftmp2],       %[ftmp5]            \n\t"
+        "paddsh     %[ftmp3],   %[ftmp3],       %[ftmp5]            \n\t"
+        "paddsh     %[ftmp4],   %[ftmp4],       %[ftmp5]            \n\t"
+        "packushb   %[ftmp1],   %[ftmp1],       %[ftmp0]            \n\t"
+        "packushb   %[ftmp2],   %[ftmp2],       %[ftmp0]            \n\t"
+        "packushb   %[ftmp3],   %[ftmp3],       %[ftmp0]            \n\t"
+        "packushb   %[ftmp4],   %[ftmp4],       %[ftmp0]            \n\t"
+        MMI_SWC1(%[ftmp1], %[dst0], 0x00)
+        MMI_SWC1(%[ftmp2], %[dst1], 0x00)
+        MMI_SWC1(%[ftmp3], %[dst2], 0x00)
+        MMI_SWC1(%[ftmp4], %[dst3], 0x00)
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),
+          RESTRICT_ASM_LOW32
+          [ftmp5]"=&f"(ftmp[5])
+        : [dst0]"r"(dst),                   [dst1]"r"(dst+stride),
+          [dst2]"r"(dst+2*stride),          [dst3]"r"(dst+3*stride),
+          [dc]"r"(dc)
+        : "memory"
+    );
+#else
+    int i, dc = (block[0] + 4) >> 3;
+
+    block[0] = 0;
+
+    for (i = 0; i < 4; i++) {
+        dst[0] = av_clip_uint8(dst[0] + dc);
+        dst[1] = av_clip_uint8(dst[1] + dc);
+        dst[2] = av_clip_uint8(dst[2] + dc);
+        dst[3] = av_clip_uint8(dst[3] + dc);
+        dst   += stride;
+    }
+#endif
+}
+
+void ff_vp8_idct_dc_add4y_mmi(uint8_t *dst, int16_t block[4][16],
+        ptrdiff_t stride)
+{
+    ff_vp8_idct_dc_add_mmi(dst +  0, block[0], stride);
+    ff_vp8_idct_dc_add_mmi(dst +  4, block[1], stride);
+    ff_vp8_idct_dc_add_mmi(dst +  8, block[2], stride);
+    ff_vp8_idct_dc_add_mmi(dst + 12, block[3], stride);
+}
+
+void ff_vp8_idct_dc_add4uv_mmi(uint8_t *dst, int16_t block[4][16],
+        ptrdiff_t stride)
+{
+    ff_vp8_idct_dc_add_mmi(dst + stride * 0 + 0, block[0], stride);
+    ff_vp8_idct_dc_add_mmi(dst + stride * 0 + 4, block[1], stride);
+    ff_vp8_idct_dc_add_mmi(dst + stride * 4 + 0, block[2], stride);
+    ff_vp8_idct_dc_add_mmi(dst + stride * 4 + 4, block[3], stride);
+}
+
+// loop filter applied to edges between macroblocks
+void ff_vp8_v_loop_filter16_mmi(uint8_t *dst, ptrdiff_t stride, int flim_E,
+        int flim_I, int hev_thresh)
+{
+    int i;
+
+    for (i = 0; i < 16; i++)
+        if (vp8_normal_limit(dst + i * 1, stride, flim_E, flim_I)) {
+            if (hev(dst + i * 1, stride, hev_thresh))
+                vp8_filter_common_is4tap(dst + i * 1, stride);
+            else
+                filter_mbedge(dst + i * 1, stride);
+        }
+}
+
+void ff_vp8_h_loop_filter16_mmi(uint8_t *dst, ptrdiff_t stride, int flim_E,
+        int flim_I, int hev_thresh)
+{
+    int i;
+
+    for (i = 0; i < 16; i++)
+        if (vp8_normal_limit(dst + i * stride, 1, flim_E, flim_I)) {
+            if (hev(dst + i * stride, 1, hev_thresh))
+                vp8_filter_common_is4tap(dst + i * stride, 1);
+            else
+                filter_mbedge(dst + i * stride, 1);
+        }
+}
+
+void ff_vp8_v_loop_filter8uv_mmi(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,
+        int flim_E, int flim_I, int hev_thresh)
+{
+    vp8_v_loop_filter8_mmi(dstU, stride, flim_E, flim_I, hev_thresh);
+    vp8_v_loop_filter8_mmi(dstV, stride, flim_E, flim_I, hev_thresh);
+}
+
+void ff_vp8_h_loop_filter8uv_mmi(uint8_t *dstU, uint8_t *dstV, ptrdiff_t stride,
+        int flim_E, int flim_I, int hev_thresh)
+{
+    vp8_h_loop_filter8_mmi(dstU, stride, flim_E, flim_I, hev_thresh);
+    vp8_h_loop_filter8_mmi(dstV, stride, flim_E, flim_I, hev_thresh);
+}
+
+// loop filter applied to inner macroblock edges
+void ff_vp8_v_loop_filter16_inner_mmi(uint8_t *dst, ptrdiff_t stride,
+        int flim_E, int flim_I, int hev_thresh)
+{
+    int i;
+
+    for (i = 0; i < 16; i++)
+        if (vp8_normal_limit(dst + i * 1, stride, flim_E, flim_I)) {
+            int hv = hev(dst + i * 1, stride, hev_thresh);
+            if (hv)
+                vp8_filter_common_is4tap(dst + i * 1, stride);
+            else
+                vp8_filter_common_isnot4tap(dst + i * 1, stride);
+        }
+}
+
+void ff_vp8_h_loop_filter16_inner_mmi(uint8_t *dst, ptrdiff_t stride,
+        int flim_E, int flim_I, int hev_thresh)
+{
+    int i;
+
+    for (i = 0; i < 16; i++)
+        if (vp8_normal_limit(dst + i * stride, 1, flim_E, flim_I)) {
+            int hv = hev(dst + i * stride, 1, hev_thresh);
+            if (hv)
+                vp8_filter_common_is4tap(dst + i * stride, 1);
+            else
+                vp8_filter_common_isnot4tap(dst + i * stride, 1);
+        }
+}
+
+void ff_vp8_v_loop_filter8uv_inner_mmi(uint8_t *dstU, uint8_t *dstV,
+        ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
+{
+    vp8_v_loop_filter8_inner_mmi(dstU, stride, flim_E, flim_I, hev_thresh);
+    vp8_v_loop_filter8_inner_mmi(dstV, stride, flim_E, flim_I, hev_thresh);
+}
+
+void ff_vp8_h_loop_filter8uv_inner_mmi(uint8_t *dstU, uint8_t *dstV,
+        ptrdiff_t stride, int flim_E, int flim_I, int hev_thresh)
+{
+    vp8_h_loop_filter8_inner_mmi(dstU, stride, flim_E, flim_I, hev_thresh);
+    vp8_h_loop_filter8_inner_mmi(dstV, stride, flim_E, flim_I, hev_thresh);
+}
+
+void ff_vp8_v_loop_filter_simple_mmi(uint8_t *dst, ptrdiff_t stride, int flim)
+{
+    int i;
+
+    for (i = 0; i < 16; i++)
+        if (vp8_simple_limit(dst + i, stride, flim))
+            vp8_filter_common_is4tap(dst + i, stride);
+}
+
+void ff_vp8_h_loop_filter_simple_mmi(uint8_t *dst, ptrdiff_t stride, int flim)
+{
+    int i;
+
+    for (i = 0; i < 16; i++)
+        if (vp8_simple_limit(dst + i * stride, 1, flim))
+            vp8_filter_common_is4tap(dst + i * stride, 1);
+}
+
+void ff_put_vp8_pixels16_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int x, int y)
+{
+#if 1
+    double ftmp[2];
+    uint64_t tmp[2];
+    mips_reg addr[2];
+    DECLARE_VAR_ALL64;
+
+    __asm__ volatile (
+        "1:                                                         \n\t"
+        PTR_ADDU   "%[addr0],   %[src],         %[srcstride]        \n\t"
+        MMI_ULDC1(%[ftmp0], %[src], 0x00)
+        "ldl        %[tmp0],    0x0f(%[src])                        \n\t"
+        "ldr        %[tmp0],    0x08(%[src])                        \n\t"
+        MMI_ULDC1(%[ftmp1], %[addr0], 0x00)
+        "ldl        %[tmp1],    0x0f(%[addr0])                      \n\t"
+        "ldr        %[tmp1],    0x08(%[addr0])                      \n\t"
+        PTR_ADDU   "%[addr1],   %[dst],         %[dststride]        \n\t"
+        MMI_SDC1(%[ftmp0], %[dst], 0x00)
+        "sdl        %[tmp0],    0x0f(%[dst])                        \n\t"
+        "sdr        %[tmp0],    0x08(%[dst])                        \n\t"
+        "addiu      %[h],       %[h],           -0x02               \n\t"
+        MMI_SDC1(%[ftmp1], %[addr1], 0x00)
+        PTR_ADDU   "%[src],     %[addr0],       %[srcstride]        \n\t"
+        "sdl        %[tmp1],    0x0f(%[addr1])                      \n\t"
+        "sdr        %[tmp1],    0x08(%[addr1])                      \n\t"
+        PTR_ADDU   "%[dst],     %[addr1],       %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [tmp0]"=&r"(tmp[0]),              [tmp1]"=&r"(tmp[1]),
+          RESTRICT_ASM_ALL64
+          [addr0]"=&r"(addr[0]),            [addr1]"=&r"(addr[1]),
+          [dst]"+&r"(dst),                  [src]"+&r"(src),
+          [h]"+&r"(h)
+        : [dststride]"r"((mips_reg)dststride),
+          [srcstride]"r"((mips_reg)srcstride)
+        : "memory"
+    );
+#else
+    int i;
+
+    for (i = 0; i < h; i++, dst += dststride, src += srcstride)
+        memcpy(dst, src, 16);
+#endif
+}
+
+void ff_put_vp8_pixels8_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int x, int y)
+{
+#if 1
+    double ftmp[1];
+    uint64_t tmp[1];
+    mips_reg addr[2];
+    DECLARE_VAR_ALL64;
+
+    __asm__ volatile (
+        "1:                                                         \n\t"
+        PTR_ADDU   "%[addr0],   %[src],         %[srcstride]        \n\t"
+        MMI_ULDC1(%[ftmp0], %[src], 0x00)
+        "ldl        %[tmp0],    0x07(%[addr0])                      \n\t"
+        "ldr        %[tmp0],    0x00(%[addr0])                      \n\t"
+        PTR_ADDU   "%[addr1],   %[dst],         %[dststride]        \n\t"
+        MMI_SDC1(%[ftmp0], %[dst], 0x00)
+        "addiu      %[h],       %[h],           -0x02               \n\t"
+        "sdl        %[tmp0],    0x07(%[addr1])                      \n\t"
+        "sdr        %[tmp0],    0x00(%[addr1])                      \n\t"
+        PTR_ADDU   "%[src],     %[addr0],       %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[addr1],       %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [addr0]"=&r"(addr[0]),            [addr1]"=&r"(addr[1]),
+          [dst]"+&r"(dst),                  [src]"+&r"(src),
+          [h]"+&r"(h)
+        : [dststride]"r"((mips_reg)dststride),
+          [srcstride]"r"((mips_reg)srcstride)
+        : "memory"
+    );
+#else
+    int i;
+
+    for (i = 0; i < h; i++, dst += dststride, src += srcstride)
+        memcpy(dst, src, 8);
+#endif
+}
+
+void ff_put_vp8_pixels4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int x, int y)
+{
+#if 1
+    double ftmp[1];
+    uint64_t tmp[1];
+    mips_reg addr[2];
+    DECLARE_VAR_LOW32;
+
+    __asm__ volatile (
+        "1:                                                         \n\t"
+        PTR_ADDU   "%[addr0],   %[src],         %[srcstride]        \n\t"
+        MMI_LWC1(%[ftmp0], %[src], 0x00)
+        "lwl        %[tmp0],    0x03(%[addr0])                      \n\t"
+        "lwr        %[tmp0],    0x00(%[addr0])                      \n\t"
+        PTR_ADDU   "%[addr1],   %[dst],         %[dststride]        \n\t"
+        MMI_SWC1(%[ftmp0], %[dst], 0x00)
+        "addiu      %[h],       %[h],           -0x02               \n\t"
+        "swl        %[tmp0],    0x03(%[addr1])                      \n\t"
+        "swr        %[tmp0],    0x00(%[addr1])                      \n\t"
+        PTR_ADDU   "%[src],     %[addr0],       %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[addr1],       %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          [addr0]"=&r"(addr[0]),            [addr1]"=&r"(addr[1]),
+          [dst]"+&r"(dst),                  [src]"+&r"(src),
+          [h]"+&r"(h)
+        : [dststride]"r"((mips_reg)dststride),
+          [srcstride]"r"((mips_reg)srcstride)
+        : "memory"
+    );
+#else
+    int i;
+
+    for (i = 0; i < h; i++, dst += dststride, src += srcstride)
+        memcpy(dst, src, 4);
+#endif
+}
+
+void ff_put_vp8_epel16_h4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[mx - 1];
+    double ftmp[9];
+    uint32_t tmp[1];
+    mips_reg src1, dst1;
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = cm[(filter[2] * src[0] - filter[1] * src[-1] + filter[3] * src[1] - filter[4] * src[2] + 64) >> 7];
+    dst[1] = cm[(filter[2] * src[1] - filter[1] * src[ 0] + filter[3] * src[2] - filter[4] * src[3] + 64) >> 7];
+    dst[2] = cm[(filter[2] * src[2] - filter[1] * src[ 1] + filter[3] * src[3] - filter[4] * src[4] + 64) >> 7];
+    dst[3] = cm[(filter[2] * src[3] - filter[1] * src[ 2] + filter[3] * src[4] - filter[4] * src[5] + 64) >> 7];
+    dst[4] = cm[(filter[2] * src[4] - filter[1] * src[ 3] + filter[3] * src[5] - filter[4] * src[6] + 64) >> 7];
+    dst[5] = cm[(filter[2] * src[5] - filter[1] * src[ 4] + filter[3] * src[6] - filter[4] * src[7] + 64) >> 7];
+    dst[6] = cm[(filter[2] * src[6] - filter[1] * src[ 5] + filter[3] * src[7] - filter[4] * src[8] + 64) >> 7];
+    dst[7] = cm[(filter[2] * src[7] - filter[1] * src[ 6] + filter[3] * src[8] - filter[4] * src[9] + 64) >> 7];
+
+    dst[ 8] = cm[(filter[2] * src[ 8] - filter[1] * src[ 7] + filter[3] * src[ 9] - filter[4] * src[10] + 64) >> 7];
+    dst[ 9] = cm[(filter[2] * src[ 9] - filter[1] * src[ 8] + filter[3] * src[10] - filter[4] * src[11] + 64) >> 7];
+    dst[10] = cm[(filter[2] * src[10] - filter[1] * src[ 9] + filter[3] * src[11] - filter[4] * src[12] + 64) >> 7];
+    dst[11] = cm[(filter[2] * src[11] - filter[1] * src[10] + filter[3] * src[12] - filter[4] * src[13] + 64) >> 7];
+    dst[12] = cm[(filter[2] * src[12] - filter[1] * src[11] + filter[3] * src[13] - filter[4] * src[14] + 64) >> 7];
+    dst[13] = cm[(filter[2] * src[13] - filter[1] * src[12] + filter[3] * src[14] - filter[4] * src[15] + 64) >> 7];
+    dst[14] = cm[(filter[2] * src[14] - filter[1] * src[13] + filter[3] * src[15] - filter[4] * src[16] + 64) >> 7];
+    dst[15] = cm[(filter[2] * src[15] - filter[1] * src[14] + filter[3] * src[16] - filter[4] * src[17] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        // 0 - 7
+        PUT_VP8_EPEL8_H4_MMI(%[src], %[dst])
+        PTR_ADDIU  "%[src1],    %[src],         0x08                \n\t"
+        PTR_ADDIU  "%[dst1],    %[dst],         0x08                \n\t"
+        // 8 - 15
+        PUT_VP8_EPEL8_H4_MMI(%[src1], %[dst1])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),            [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [dst1]"=&r"(dst1),                [src1]"=&r"(src1),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter1]"f"(filter[1]),          [filter2]"f"(filter[2]),
+          [filter3]"f"(filter[3]),          [filter4]"f"(filter[4])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 16; x++)
+            dst[x] = FILTER_4TAP(src, filter, 1);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel8_h4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[mx - 1];
+    double ftmp[9];
+    uint32_t tmp[1];
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = cm[(filter[2] * src[0] - filter[1] * src[-1] + filter[3] * src[1] - filter[4] * src[2] + 64) >> 7];
+    dst[1] = cm[(filter[2] * src[1] - filter[1] * src[ 0] + filter[3] * src[2] - filter[4] * src[3] + 64) >> 7];
+    dst[2] = cm[(filter[2] * src[2] - filter[1] * src[ 1] + filter[3] * src[3] - filter[4] * src[4] + 64) >> 7];
+    dst[3] = cm[(filter[2] * src[3] - filter[1] * src[ 2] + filter[3] * src[4] - filter[4] * src[5] + 64) >> 7];
+    dst[4] = cm[(filter[2] * src[4] - filter[1] * src[ 3] + filter[3] * src[5] - filter[4] * src[6] + 64) >> 7];
+    dst[5] = cm[(filter[2] * src[5] - filter[1] * src[ 4] + filter[3] * src[6] - filter[4] * src[7] + 64) >> 7];
+    dst[6] = cm[(filter[2] * src[6] - filter[1] * src[ 5] + filter[3] * src[7] - filter[4] * src[8] + 64) >> 7];
+    dst[7] = cm[(filter[2] * src[7] - filter[1] * src[ 6] + filter[3] * src[8] - filter[4] * src[9] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_EPEL8_H4_MMI(%[src], %[dst])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),            [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter1]"f"(filter[1]),          [filter2]"f"(filter[2]),
+          [filter3]"f"(filter[3]),          [filter4]"f"(filter[4])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 8; x++)
+            dst[x] = FILTER_4TAP(src, filter, 1);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel4_h4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[mx - 1];
+    double ftmp[6];
+    uint32_t tmp[1];
+    DECLARE_VAR_LOW32;
+
+    /*
+    dst[0] = cm[(filter[2] * src[0] - filter[1] * src[-1] + filter[3] * src[1] - filter[4] * src[2] + 64) >> 7];
+    dst[1] = cm[(filter[2] * src[1] - filter[1] * src[ 0] + filter[3] * src[2] - filter[4] * src[3] + 64) >> 7];
+    dst[2] = cm[(filter[2] * src[2] - filter[1] * src[ 1] + filter[3] * src[3] - filter[4] * src[4] + 64) >> 7];
+    dst[3] = cm[(filter[2] * src[3] - filter[1] * src[ 2] + filter[3] * src[4] - filter[4] * src[5] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_EPEL4_H4_MMI(%[src], %[dst])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter1]"f"(filter[1]),          [filter2]"f"(filter[2]),
+          [filter3]"f"(filter[3]),          [filter4]"f"(filter[4])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 4; x++)
+            dst[x] = FILTER_4TAP(src, filter, 1);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel16_h6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[mx - 1];
+    double ftmp[9];
+    uint32_t tmp[1];
+    mips_reg src1, dst1;
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[ 0] = cm[(filter[2]*src[ 0] - filter[1]*src[-1] + filter[0]*src[-2] + filter[3]*src[ 1] - filter[4]*src[ 2] + filter[5]*src[ 3] + 64) >> 7];
+    dst[ 1] = cm[(filter[2]*src[ 1] - filter[1]*src[ 0] + filter[0]*src[-1] + filter[3]*src[ 2] - filter[4]*src[ 3] + filter[5]*src[ 4] + 64) >> 7];
+    dst[ 2] = cm[(filter[2]*src[ 2] - filter[1]*src[ 1] + filter[0]*src[ 0] + filter[3]*src[ 3] - filter[4]*src[ 4] + filter[5]*src[ 5] + 64) >> 7];
+    dst[ 3] = cm[(filter[2]*src[ 3] - filter[1]*src[ 2] + filter[0]*src[ 1] + filter[3]*src[ 4] - filter[4]*src[ 5] + filter[5]*src[ 6] + 64) >> 7];
+    dst[ 4] = cm[(filter[2]*src[ 4] - filter[1]*src[ 3] + filter[0]*src[ 2] + filter[3]*src[ 5] - filter[4]*src[ 6] + filter[5]*src[ 7] + 64) >> 7];
+    dst[ 5] = cm[(filter[2]*src[ 5] - filter[1]*src[ 4] + filter[0]*src[ 3] + filter[3]*src[ 6] - filter[4]*src[ 7] + filter[5]*src[ 8] + 64) >> 7];
+    dst[ 6] = cm[(filter[2]*src[ 6] - filter[1]*src[ 5] + filter[0]*src[ 4] + filter[3]*src[ 7] - filter[4]*src[ 8] + filter[5]*src[ 9] + 64) >> 7];
+    dst[ 7] = cm[(filter[2]*src[ 7] - filter[1]*src[ 6] + filter[0]*src[ 5] + filter[3]*src[ 8] - filter[4]*src[ 9] + filter[5]*src[10] + 64) >> 7];
+
+    dst[ 8] = cm[(filter[2]*src[ 8] - filter[1]*src[ 7] + filter[0]*src[ 6] + filter[3]*src[ 9] - filter[4]*src[10] + filter[5]*src[11] + 64) >> 7];
+    dst[ 9] = cm[(filter[2]*src[ 9] - filter[1]*src[ 8] + filter[0]*src[ 7] + filter[3]*src[10] - filter[4]*src[11] + filter[5]*src[12] + 64) >> 7];
+    dst[10] = cm[(filter[2]*src[10] - filter[1]*src[ 9] + filter[0]*src[ 8] + filter[3]*src[11] - filter[4]*src[12] + filter[5]*src[13] + 64) >> 7];
+    dst[11] = cm[(filter[2]*src[11] - filter[1]*src[10] + filter[0]*src[ 9] + filter[3]*src[12] - filter[4]*src[13] + filter[5]*src[14] + 64) >> 7];
+    dst[12] = cm[(filter[2]*src[12] - filter[1]*src[11] + filter[0]*src[10] + filter[3]*src[13] - filter[4]*src[14] + filter[5]*src[15] + 64) >> 7];
+    dst[13] = cm[(filter[2]*src[13] - filter[1]*src[12] + filter[0]*src[11] + filter[3]*src[14] - filter[4]*src[15] + filter[5]*src[16] + 64) >> 7];
+    dst[14] = cm[(filter[2]*src[14] - filter[1]*src[13] + filter[0]*src[12] + filter[3]*src[15] - filter[4]*src[16] + filter[5]*src[17] + 64) >> 7];
+    dst[15] = cm[(filter[2]*src[15] - filter[1]*src[14] + filter[0]*src[13] + filter[3]*src[16] - filter[4]*src[17] + filter[5]*src[18] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        // 0 - 7
+        PUT_VP8_EPEL8_H6_MMI(%[src], %[dst])
+        PTR_ADDIU  "%[src1],    %[src],         0x08                \n\t"
+        PTR_ADDIU  "%[dst1],    %[dst],         0x08                \n\t"
+        // 8 - 15
+        PUT_VP8_EPEL8_H6_MMI(%[src1], %[dst1])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),            [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [dst1]"=&r"(dst1),                [src1]"=&r"(src1),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter0]"f"(filter[0]),          [filter1]"f"(filter[1]),
+          [filter2]"f"(filter[2]),          [filter3]"f"(filter[3]),
+          [filter4]"f"(filter[4]),          [filter5]"f"(filter[5])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 16; x++)
+            dst[x] = FILTER_6TAP(src, filter, 1);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel8_h6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[mx - 1];
+    double ftmp[9];
+    uint32_t tmp[1];
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = cm[(filter[2]*src[0] - filter[1]*src[-1] + filter[0]*src[-2] + filter[3]*src[1] - filter[4]*src[2] + filter[5]*src[ 3] + 64) >> 7];
+    dst[1] = cm[(filter[2]*src[1] - filter[1]*src[ 0] + filter[0]*src[-1] + filter[3]*src[2] - filter[4]*src[3] + filter[5]*src[ 4] + 64) >> 7];
+    dst[2] = cm[(filter[2]*src[2] - filter[1]*src[ 1] + filter[0]*src[ 0] + filter[3]*src[3] - filter[4]*src[4] + filter[5]*src[ 5] + 64) >> 7];
+    dst[3] = cm[(filter[2]*src[3] - filter[1]*src[ 2] + filter[0]*src[ 1] + filter[3]*src[4] - filter[4]*src[5] + filter[5]*src[ 6] + 64) >> 7];
+    dst[4] = cm[(filter[2]*src[4] - filter[1]*src[ 3] + filter[0]*src[ 2] + filter[3]*src[5] - filter[4]*src[6] + filter[5]*src[ 7] + 64) >> 7];
+    dst[5] = cm[(filter[2]*src[5] - filter[1]*src[ 4] + filter[0]*src[ 3] + filter[3]*src[6] - filter[4]*src[7] + filter[5]*src[ 8] + 64) >> 7];
+    dst[6] = cm[(filter[2]*src[6] - filter[1]*src[ 5] + filter[0]*src[ 4] + filter[3]*src[7] - filter[4]*src[8] + filter[5]*src[ 9] + 64) >> 7];
+    dst[7] = cm[(filter[2]*src[7] - filter[1]*src[ 6] + filter[0]*src[ 5] + filter[3]*src[8] - filter[4]*src[9] + filter[5]*src[10] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_EPEL8_H6_MMI(%[src], %[dst])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),            [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter0]"f"(filter[0]),          [filter1]"f"(filter[1]),
+          [filter2]"f"(filter[2]),          [filter3]"f"(filter[3]),
+          [filter4]"f"(filter[4]),          [filter5]"f"(filter[5])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 8; x++)
+            dst[x] = FILTER_6TAP(src, filter, 1);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel4_h6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[mx - 1];
+    double ftmp[6];
+    uint32_t tmp[1];
+    DECLARE_VAR_LOW32;
+
+    /*
+    dst[0] = cm[(filter[2]*src[0] - filter[1]*src[-1] + filter[0]*src[-2] + filter[3]*src[1] - filter[4]*src[2] + filter[5]*src[ 3] + 64) >> 7];
+    dst[1] = cm[(filter[2]*src[1] - filter[1]*src[ 0] + filter[0]*src[-1] + filter[3]*src[2] - filter[4]*src[3] + filter[5]*src[ 4] + 64) >> 7];
+    dst[2] = cm[(filter[2]*src[2] - filter[1]*src[ 1] + filter[0]*src[ 0] + filter[3]*src[3] - filter[4]*src[4] + filter[5]*src[ 5] + 64) >> 7];
+    dst[3] = cm[(filter[2]*src[3] - filter[1]*src[ 2] + filter[0]*src[ 1] + filter[3]*src[4] - filter[4]*src[5] + filter[5]*src[ 6] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_EPEL4_H6_MMI(%[src], %[dst])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter0]"f"(filter[0]),          [filter1]"f"(filter[1]),
+          [filter2]"f"(filter[2]),          [filter3]"f"(filter[3]),
+          [filter4]"f"(filter[4]),          [filter5]"f"(filter[5])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 4; x++)
+            dst[x] = FILTER_6TAP(src, filter, 1);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel16_v4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[my - 1];
+    double ftmp[9];
+    uint32_t tmp[1];
+    mips_reg src0, src1, dst0;
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = cm[(filter[2] * src[0] - filter[1] * src[ -srcstride] + filter[3] * src[  srcstride] - filter[4] * src[  2*srcstride] + 64) >> 7];
+    dst[1] = cm[(filter[2] * src[1] - filter[1] * src[1-srcstride] + filter[3] * src[1+srcstride] - filter[4] * src[1+2*srcstride] + 64) >> 7];
+    dst[2] = cm[(filter[2] * src[2] - filter[1] * src[2-srcstride] + filter[3] * src[2+srcstride] - filter[4] * src[2+2*srcstride] + 64) >> 7];
+    dst[3] = cm[(filter[2] * src[3] - filter[1] * src[3-srcstride] + filter[3] * src[3+srcstride] - filter[4] * src[3+2*srcstride] + 64) >> 7];
+    dst[4] = cm[(filter[2] * src[4] - filter[1] * src[4-srcstride] + filter[3] * src[4+srcstride] - filter[4] * src[4+2*srcstride] + 64) >> 7];
+    dst[5] = cm[(filter[2] * src[5] - filter[1] * src[5-srcstride] + filter[3] * src[5+srcstride] - filter[4] * src[5+2*srcstride] + 64) >> 7];
+    dst[6] = cm[(filter[2] * src[6] - filter[1] * src[6-srcstride] + filter[3] * src[6+srcstride] - filter[4] * src[6+2*srcstride] + 64) >> 7];
+    dst[7] = cm[(filter[2] * src[7] - filter[1] * src[7-srcstride] + filter[3] * src[7+srcstride] - filter[4] * src[7+2*srcstride] + 64) >> 7];
+
+    dst[ 8] = cm[(filter[2] * src[ 8] - filter[1] * src[ 8-srcstride] + filter[3] * src[ 8+srcstride] - filter[4] * src[ 8+2*srcstride] + 64) >> 7];
+    dst[ 9] = cm[(filter[2] * src[ 9] - filter[1] * src[ 9-srcstride] + filter[3] * src[ 9+srcstride] - filter[4] * src[ 9+2*srcstride] + 64) >> 7];
+    dst[10] = cm[(filter[2] * src[10] - filter[1] * src[10-srcstride] + filter[3] * src[10+srcstride] - filter[4] * src[10+2*srcstride] + 64) >> 7];
+    dst[11] = cm[(filter[2] * src[11] - filter[1] * src[11-srcstride] + filter[3] * src[11+srcstride] - filter[4] * src[11+2*srcstride] + 64) >> 7];
+    dst[12] = cm[(filter[2] * src[12] - filter[1] * src[12-srcstride] + filter[3] * src[12+srcstride] - filter[4] * src[12+2*srcstride] + 64) >> 7];
+    dst[13] = cm[(filter[2] * src[13] - filter[1] * src[13-srcstride] + filter[3] * src[13+srcstride] - filter[4] * src[13+2*srcstride] + 64) >> 7];
+    dst[14] = cm[(filter[2] * src[14] - filter[1] * src[14-srcstride] + filter[3] * src[14+srcstride] - filter[4] * src[14+2*srcstride] + 64) >> 7];
+    dst[15] = cm[(filter[2] * src[15] - filter[1] * src[15-srcstride] + filter[3] * src[15+srcstride] - filter[4] * src[15+2*srcstride] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        // 0 - 7
+        PUT_VP8_EPEL8_V4_MMI(%[src], %[src1], %[dst], %[srcstride])
+        PTR_ADDIU  "%[src0],    %[src],         0x08                \n\t"
+        PTR_ADDIU  "%[dst0],    %[dst],         0x08                \n\t"
+        // 8 - 15
+        PUT_VP8_EPEL8_V4_MMI(%[src0], %[src1], %[dst], %[srcstride])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),            [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [src0]"=&r"(src0),                [dst0]"=&r"(dst0),
+          [src1]"=&r"(src1),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter1]"f"(filter[1]),          [filter2]"f"(filter[2]),
+          [filter3]"f"(filter[3]),          [filter4]"f"(filter[4])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[my - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 16; x++)
+            dst[x] = FILTER_4TAP(src, filter, srcstride);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel8_v4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[my - 1];
+    double ftmp[9];
+    uint32_t tmp[1];
+    mips_reg src1;
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = cm[(filter[2] * src[0] - filter[1] * src[ -srcstride] + filter[3] * src[  srcstride] - filter[4] * src[  2*srcstride] + 64) >> 7];
+    dst[1] = cm[(filter[2] * src[1] - filter[1] * src[1-srcstride] + filter[3] * src[1+srcstride] - filter[4] * src[1+2*srcstride] + 64) >> 7];
+    dst[2] = cm[(filter[2] * src[2] - filter[1] * src[2-srcstride] + filter[3] * src[2+srcstride] - filter[4] * src[2+2*srcstride] + 64) >> 7];
+    dst[3] = cm[(filter[2] * src[3] - filter[1] * src[3-srcstride] + filter[3] * src[3+srcstride] - filter[4] * src[3+2*srcstride] + 64) >> 7];
+    dst[4] = cm[(filter[2] * src[4] - filter[1] * src[4-srcstride] + filter[3] * src[4+srcstride] - filter[4] * src[4+2*srcstride] + 64) >> 7];
+    dst[5] = cm[(filter[2] * src[5] - filter[1] * src[5-srcstride] + filter[3] * src[5+srcstride] - filter[4] * src[5+2*srcstride] + 64) >> 7];
+    dst[6] = cm[(filter[2] * src[6] - filter[1] * src[6-srcstride] + filter[3] * src[6+srcstride] - filter[4] * src[6+2*srcstride] + 64) >> 7];
+    dst[7] = cm[(filter[2] * src[7] - filter[1] * src[7-srcstride] + filter[3] * src[7+srcstride] - filter[4] * src[7+2*srcstride] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_EPEL8_V4_MMI(%[src], %[src1], %[dst], %[srcstride])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),            [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [src1]"=&r"(src1),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter1]"f"(filter[1]),          [filter2]"f"(filter[2]),
+          [filter3]"f"(filter[3]),          [filter4]"f"(filter[4])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[my - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 8; x++)
+            dst[x] = FILTER_4TAP(src, filter, srcstride);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel4_v4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[my - 1];
+    double ftmp[6];
+    uint32_t tmp[1];
+    mips_reg src1;
+    DECLARE_VAR_LOW32;
+
+    /*
+    dst[0] = cm[(filter[2] * src[0] - filter[1] * src[ -srcstride] + filter[3] * src[  srcstride] - filter[4] * src[  2*srcstride] + 64) >> 7];
+    dst[1] = cm[(filter[2] * src[1] - filter[1] * src[1-srcstride] + filter[3] * src[1+srcstride] - filter[4] * src[1+2*srcstride] + 64) >> 7];
+    dst[2] = cm[(filter[2] * src[2] - filter[1] * src[2-srcstride] + filter[3] * src[2+srcstride] - filter[4] * src[2+2*srcstride] + 64) >> 7];
+    dst[3] = cm[(filter[2] * src[3] - filter[1] * src[3-srcstride] + filter[3] * src[3+srcstride] - filter[4] * src[3+2*srcstride] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_EPEL4_V4_MMI(%[src], %[src1], %[dst], %[srcstride])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          [src1]"=&r"(src1),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter1]"f"(filter[1]),          [filter2]"f"(filter[2]),
+          [filter3]"f"(filter[3]),          [filter4]"f"(filter[4])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[my - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 4; x++)
+            dst[x] = FILTER_4TAP(src, filter, srcstride);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel16_v6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[my - 1];
+    double ftmp[9];
+    uint32_t tmp[1];
+    mips_reg src0, src1, dst0;
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = cm[(filter[2]*src[0] - filter[1]*src[0-srcstride] + filter[0]*src[0-2*srcstride] + filter[3]*src[0+srcstride] - filter[4]*src[0+2*srcstride] + filter[5]*src[0+3*srcstride] + 64) >> 7];
+    dst[1] = cm[(filter[2]*src[1] - filter[1]*src[1-srcstride] + filter[0]*src[1-2*srcstride] + filter[3]*src[1+srcstride] - filter[4]*src[1+2*srcstride] + filter[5]*src[1+3*srcstride] + 64) >> 7];
+    dst[2] = cm[(filter[2]*src[2] - filter[1]*src[2-srcstride] + filter[0]*src[2-2*srcstride] + filter[3]*src[2+srcstride] - filter[4]*src[2+2*srcstride] + filter[5]*src[2+3*srcstride] + 64) >> 7];
+    dst[3] = cm[(filter[2]*src[3] - filter[1]*src[3-srcstride] + filter[0]*src[3-2*srcstride] + filter[3]*src[3+srcstride] - filter[4]*src[3+2*srcstride] + filter[5]*src[3+3*srcstride] + 64) >> 7];
+    dst[4] = cm[(filter[2]*src[4] - filter[1]*src[4-srcstride] + filter[0]*src[4-2*srcstride] + filter[3]*src[4+srcstride] - filter[4]*src[4+2*srcstride] + filter[5]*src[4+3*srcstride] + 64) >> 7];
+    dst[5] = cm[(filter[2]*src[5] - filter[1]*src[5-srcstride] + filter[0]*src[5-2*srcstride] + filter[3]*src[5+srcstride] - filter[4]*src[5+2*srcstride] + filter[5]*src[5+3*srcstride] + 64) >> 7];
+    dst[6] = cm[(filter[2]*src[6] - filter[1]*src[6-srcstride] + filter[0]*src[6-2*srcstride] + filter[3]*src[6+srcstride] - filter[4]*src[6+2*srcstride] + filter[5]*src[6+3*srcstride] + 64) >> 7];
+    dst[7] = cm[(filter[2]*src[7] - filter[1]*src[7-srcstride] + filter[0]*src[7-2*srcstride] + filter[3]*src[7+srcstride] - filter[4]*src[7+2*srcstride] + filter[5]*src[7+3*srcstride] + 64) >> 7];
+
+    dst[ 8] = cm[(filter[2]*src[ 8] - filter[1]*src[ 8-srcstride] + filter[0]*src[ 8-2*srcstride] + filter[3]*src[ 8+srcstride] - filter[4]*src[ 8+2*srcstride] + filter[5]*src[ 8+3*srcstride] + 64) >> 7];
+    dst[ 9] = cm[(filter[2]*src[ 9] - filter[1]*src[ 9-srcstride] + filter[0]*src[ 9-2*srcstride] + filter[3]*src[ 9+srcstride] - filter[4]*src[ 9+2*srcstride] + filter[5]*src[ 9+3*srcstride] + 64) >> 7];
+    dst[10] = cm[(filter[2]*src[10] - filter[1]*src[10-srcstride] + filter[0]*src[10-2*srcstride] + filter[3]*src[10+srcstride] - filter[4]*src[10+2*srcstride] + filter[5]*src[10+3*srcstride] + 64) >> 7];
+    dst[11] = cm[(filter[2]*src[11] - filter[1]*src[11-srcstride] + filter[0]*src[11-2*srcstride] + filter[3]*src[11+srcstride] - filter[4]*src[11+2*srcstride] + filter[5]*src[11+3*srcstride] + 64) >> 7];
+    dst[12] = cm[(filter[2]*src[12] - filter[1]*src[12-srcstride] + filter[0]*src[12-2*srcstride] + filter[3]*src[12+srcstride] - filter[4]*src[12+2*srcstride] + filter[5]*src[12+3*srcstride] + 64) >> 7];
+    dst[13] = cm[(filter[2]*src[13] - filter[1]*src[13-srcstride] + filter[0]*src[13-2*srcstride] + filter[3]*src[13+srcstride] - filter[4]*src[13+2*srcstride] + filter[5]*src[13+3*srcstride] + 64) >> 7];
+    dst[14] = cm[(filter[2]*src[14] - filter[1]*src[14-srcstride] + filter[0]*src[14-2*srcstride] + filter[3]*src[14+srcstride] - filter[4]*src[14+2*srcstride] + filter[5]*src[14+3*srcstride] + 64) >> 7];
+    dst[15] = cm[(filter[2]*src[15] - filter[1]*src[15-srcstride] + filter[0]*src[15-2*srcstride] + filter[3]*src[15+srcstride] - filter[4]*src[15+2*srcstride] + filter[5]*src[15+3*srcstride] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        // 0 - 7
+        PUT_VP8_EPEL8_V6_MMI(%[src], %[src1], %[dst], %[srcstride])
+        PTR_ADDIU  "%[src0],    %[src],         0x08                \n\t"
+        PTR_ADDIU  "%[dst0],    %[dst],         0x08                \n\t"
+        // 8 - 15
+        PUT_VP8_EPEL8_V6_MMI(%[src0], %[src1], %[dst0], %[srcstride])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),            [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [src0]"=&r"(src0),                [dst0]"=&r"(dst0),
+          [src1]"=&r"(src1),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter0]"f"(filter[0]),          [filter1]"f"(filter[1]),
+          [filter2]"f"(filter[2]),          [filter3]"f"(filter[3]),
+          [filter4]"f"(filter[4]),          [filter5]"f"(filter[5])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[my - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 16; x++)
+            dst[x] = FILTER_6TAP(src, filter, srcstride);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel8_v6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[my - 1];
+    double ftmp[9];
+    uint32_t tmp[1];
+    mips_reg src1;
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = cm[(filter[2]*src[0] - filter[1]*src[0-srcstride] + filter[0]*src[0-2*srcstride] + filter[3]*src[0+srcstride] - filter[4]*src[0+2*srcstride] + filter[5]*src[0+3*srcstride] + 64) >> 7];
+    dst[1] = cm[(filter[2]*src[1] - filter[1]*src[1-srcstride] + filter[0]*src[1-2*srcstride] + filter[3]*src[1+srcstride] - filter[4]*src[1+2*srcstride] + filter[5]*src[1+3*srcstride] + 64) >> 7];
+    dst[2] = cm[(filter[2]*src[2] - filter[1]*src[2-srcstride] + filter[0]*src[2-2*srcstride] + filter[3]*src[2+srcstride] - filter[4]*src[2+2*srcstride] + filter[5]*src[2+3*srcstride] + 64) >> 7];
+    dst[3] = cm[(filter[2]*src[3] - filter[1]*src[3-srcstride] + filter[0]*src[3-2*srcstride] + filter[3]*src[3+srcstride] - filter[4]*src[3+2*srcstride] + filter[5]*src[3+3*srcstride] + 64) >> 7];
+    dst[4] = cm[(filter[2]*src[4] - filter[1]*src[4-srcstride] + filter[0]*src[4-2*srcstride] + filter[3]*src[4+srcstride] - filter[4]*src[4+2*srcstride] + filter[5]*src[4+3*srcstride] + 64) >> 7];
+    dst[5] = cm[(filter[2]*src[5] - filter[1]*src[5-srcstride] + filter[0]*src[5-2*srcstride] + filter[3]*src[5+srcstride] - filter[4]*src[5+2*srcstride] + filter[5]*src[5+3*srcstride] + 64) >> 7];
+    dst[6] = cm[(filter[2]*src[6] - filter[1]*src[6-srcstride] + filter[0]*src[6-2*srcstride] + filter[3]*src[6+srcstride] - filter[4]*src[6+2*srcstride] + filter[5]*src[6+3*srcstride] + 64) >> 7];
+    dst[7] = cm[(filter[2]*src[7] - filter[1]*src[7-srcstride] + filter[0]*src[7-2*srcstride] + filter[3]*src[7+srcstride] - filter[4]*src[7+2*srcstride] + filter[5]*src[7+3*srcstride] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_EPEL8_V6_MMI(%[src], %[src1], %[dst], %[srcstride])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),            [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [src1]"=&r"(src1),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter0]"f"(filter[0]),          [filter1]"f"(filter[1]),
+          [filter2]"f"(filter[2]),          [filter3]"f"(filter[3]),
+          [filter4]"f"(filter[4]),          [filter5]"f"(filter[5])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[my - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 8; x++)
+            dst[x] = FILTER_6TAP(src, filter, srcstride);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel4_v6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    const uint64_t *filter = fourtap_subpel_filters[my - 1];
+    double ftmp[6];
+    uint32_t tmp[1];
+    mips_reg src1;
+    DECLARE_VAR_LOW32;
+
+    /*
+    dst[0] = cm[(filter[2]*src[0] - filter[1]*src[0-srcstride] + filter[0]*src[0-2*srcstride] + filter[3]*src[0+srcstride] - filter[4]*src[0+2*srcstride] + filter[5]*src[0+3*srcstride] + 64) >> 7];
+    dst[1] = cm[(filter[2]*src[1] - filter[1]*src[1-srcstride] + filter[0]*src[1-2*srcstride] + filter[3]*src[1+srcstride] - filter[4]*src[1+2*srcstride] + filter[5]*src[1+3*srcstride] + 64) >> 7];
+    dst[2] = cm[(filter[2]*src[2] - filter[1]*src[2-srcstride] + filter[0]*src[2-2*srcstride] + filter[3]*src[2+srcstride] - filter[4]*src[2+2*srcstride] + filter[5]*src[2+3*srcstride] + 64) >> 7];
+    dst[3] = cm[(filter[2]*src[3] - filter[1]*src[3-srcstride] + filter[0]*src[3-2*srcstride] + filter[3]*src[3+srcstride] - filter[4]*src[3+2*srcstride] + filter[5]*src[3+3*srcstride] + 64) >> 7];
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x07                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_EPEL4_V6_MMI(%[src], %[src1], %[dst], %[srcstride])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[srcstride]        \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dststride]        \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          [src1]"=&r"(src1),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),                  [src]"+&r"(src)
+        : [ff_pw_64]"f"(ff_pw_64),
+          [srcstride]"r"((mips_reg)srcstride),
+          [dststride]"r"((mips_reg)dststride),
+          [filter0]"f"(filter[0]),          [filter1]"f"(filter[1]),
+          [filter2]"f"(filter[2]),          [filter3]"f"(filter[3]),
+          [filter4]"f"(filter[4]),          [filter5]"f"(filter[5])
+        : "memory"
+    );
+#else
+    const uint8_t *filter = subpel_filters[my - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 4; x++)
+            dst[x] = FILTER_6TAP(src, filter, srcstride);
+        dst += dststride;
+        src += srcstride;
+    }
+#endif
+}
+
+void ff_put_vp8_epel16_h4v4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(8, uint8_t, tmp_array[560]);
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+    ff_put_vp8_epel16_h4_mmi(tmp, 16, src, srcstride, h + 3, mx, my);
+    tmp = tmp_array + 16;
+    ff_put_vp8_epel16_v4_mmi(dst, dststride, tmp, 16, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[560];
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+
+    for (y = 0; y < h + 3; y++) {
+        for (x = 0; x < 16; x++)
+            tmp[x] = FILTER_4TAP(src, filter, 1);
+        tmp += 16;
+        src += srcstride;
+    }
+
+    tmp    = tmp_array + 16;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 16; x++)
+            dst[x] = FILTER_4TAP(tmp, filter, 16);
+        dst += dststride;
+        tmp += 16;
+    }
+#endif
+}
+
+void ff_put_vp8_epel8_h4v4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(8, uint8_t, tmp_array[152]);
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+    ff_put_vp8_epel8_h4_mmi(tmp, 8, src, srcstride, h + 3, mx, my);
+    tmp = tmp_array + 8;
+    ff_put_vp8_epel8_v4_mmi(dst, dststride, tmp, 8, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[152];
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+
+    for (y = 0; y < h + 3; y++) {
+        for (x = 0; x < 8; x++)
+            tmp[x] = FILTER_4TAP(src, filter, 1);
+        tmp += 8;
+        src += srcstride;
+    }
+
+    tmp    = tmp_array + 8;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 8; x++)
+            dst[x] = FILTER_4TAP(tmp, filter, 8);
+        dst += dststride;
+        tmp += 8;
+    }
+#endif
+}
+
+void ff_put_vp8_epel4_h4v4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(4, uint8_t, tmp_array[44]);
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+    ff_put_vp8_epel4_h4_mmi(tmp, 4, src, srcstride, h + 3, mx, my);
+    tmp = tmp_array + 4;
+    ff_put_vp8_epel4_v4_mmi(dst, dststride, tmp, 4, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[44];
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+
+    for (y = 0; y < h + 3; y++) {
+        for (x = 0; x < 4; x++)
+            tmp[x] = FILTER_4TAP(src, filter, 1);
+        tmp += 4;
+        src += srcstride;
+    }
+    tmp    = tmp_array + 4;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 4; x++)
+            dst[x] = FILTER_4TAP(tmp, filter, 4);
+        dst += dststride;
+        tmp += 4;
+    }
+#endif
+}
+
+void ff_put_vp8_epel16_h4v6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(8, uint8_t, tmp_array[592]);
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+    ff_put_vp8_epel16_h4_mmi(tmp, 16, src, srcstride, h + 5, mx, my);
+    tmp    = tmp_array + 32;
+    ff_put_vp8_epel16_v6_mmi(dst, dststride, tmp, 16, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[592];
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+
+    for (y = 0; y < h + 5; y++) {
+        for (x = 0; x < 16; x++)
+            tmp[x] = FILTER_4TAP(src, filter, 1);
+        tmp += 16;
+        src += srcstride;
+    }
+
+    tmp    = tmp_array + 32;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 16; x++)
+            dst[x] = FILTER_6TAP(tmp, filter, 16);
+        dst += dststride;
+        tmp += 16;
+    }
+#endif
+}
+
+void ff_put_vp8_epel8_h4v6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(8, uint8_t, tmp_array[168]);
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+    ff_put_vp8_epel8_h4_mmi(tmp, 8, src, srcstride, h + 5, mx, my);
+    tmp    = tmp_array + 16;
+    ff_put_vp8_epel8_v6_mmi(dst, dststride, tmp, 8, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[168];
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+
+    for (y = 0; y < h + 5; y++) {
+        for (x = 0; x < 8; x++)
+            tmp[x] = FILTER_4TAP(src, filter, 1);
+        tmp += 8;
+        src += srcstride;
+    }
+
+    tmp    = tmp_array + 16;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 8; x++)
+            dst[x] = FILTER_6TAP(tmp, filter, 8);
+        dst += dststride;
+        tmp += 8;
+    }
+#endif
+}
+
+void ff_put_vp8_epel4_h4v6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(4, uint8_t, tmp_array[52]);
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+    ff_put_vp8_epel4_h4_mmi(tmp, 4, src, srcstride, h + 5, mx, my);
+    tmp    = tmp_array + 8;
+    ff_put_vp8_epel4_v6_mmi(dst, dststride, tmp, 4, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[52];
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+
+    for (y = 0; y < h + 5; y++) {
+        for (x = 0; x < 4; x++)
+            tmp[x] = FILTER_4TAP(src, filter, 1);
+        tmp += 4;
+        src += srcstride;
+    }
+
+    tmp    = tmp_array + 8;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 4; x++)
+            dst[x] = FILTER_6TAP(tmp, filter, 4);
+        dst += dststride;
+        tmp += 4;
+    }
+#endif
+}
+
+void ff_put_vp8_epel16_h6v4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(8, uint8_t, tmp_array[560]);
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+    ff_put_vp8_epel16_h6_mmi(tmp, 16, src, srcstride, h + 3, mx, my);
+    tmp    = tmp_array + 16;
+    ff_put_vp8_epel16_v4_mmi(dst, dststride, tmp, 16, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[560];
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+
+    for (y = 0; y < h + 3; y++) {
+        for (x = 0; x < 16; x++)
+            tmp[x] = FILTER_6TAP(src, filter, 1);
+        tmp += 16;
+        src += srcstride;
+    }
+
+    tmp    = tmp_array + 16;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 16; x++)
+            dst[x] = FILTER_4TAP(tmp, filter, 16);
+        dst += dststride;
+        tmp += 16;
+    }
+#endif
+}
+
+void ff_put_vp8_epel8_h6v4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(8, uint8_t, tmp_array[152]);
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+    ff_put_vp8_epel8_h6_mmi(tmp, 8, src, srcstride, h + 3, mx, my);
+    tmp    = tmp_array + 8;
+    ff_put_vp8_epel8_v4_mmi(dst, dststride, tmp, 8, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[152];
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+
+    for (y = 0; y < h + 3; y++) {
+        for (x = 0; x < 8; x++)
+            tmp[x] = FILTER_6TAP(src, filter, 1);
+        tmp += 8;
+        src += srcstride;
+    }
+
+    tmp    = tmp_array + 8;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 8; x++)
+            dst[x] = FILTER_4TAP(tmp, filter, 8);
+        dst += dststride;
+        tmp += 8;
+    }
+#endif
+}
+
+void ff_put_vp8_epel4_h6v4_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(4, uint8_t, tmp_array[44]);
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+    ff_put_vp8_epel4_h6_mmi(tmp, 4, src, srcstride, h + 3, mx, my);
+    tmp    = tmp_array + 4;
+    ff_put_vp8_epel4_v4_mmi(dst, dststride, tmp, 4, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[44];
+    uint8_t *tmp = tmp_array;
+
+    src -= srcstride;
+
+    for (y = 0; y < h + 3; y++) {
+        for (x = 0; x < 4; x++)
+            tmp[x] = FILTER_6TAP(src, filter, 1);
+        tmp += 4;
+        src += srcstride;
+    }
+
+    tmp    = tmp_array + 4;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 4; x++)
+            dst[x] = FILTER_4TAP(tmp, filter, 4);
+        dst += dststride;
+        tmp += 4;
+    }
+#endif
+}
+
+void ff_put_vp8_epel16_h6v6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(8, uint8_t, tmp_array[592]);
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+    ff_put_vp8_epel16_h6_mmi(tmp, 16, src, srcstride, h + 5, mx, my);
+    tmp    = tmp_array + 32;
+    ff_put_vp8_epel16_v6_mmi(dst, dststride, tmp, 16, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[592];
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+
+    for (y = 0; y < h + 5; y++) {
+        for (x = 0; x < 16; x++)
+            tmp[x] = FILTER_6TAP(src, filter, 1);
+        tmp += 16;
+        src += srcstride;
+    }
+
+    tmp    = tmp_array + 32;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 16; x++)
+            dst[x] = FILTER_6TAP(tmp, filter, 16);
+        dst += dststride;
+        tmp += 16;
+    }
+#endif
+}
+
+void ff_put_vp8_epel8_h6v6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(8, uint8_t, tmp_array[168]);
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+    ff_put_vp8_epel8_h6_mmi(tmp, 8, src, srcstride, h + 5, mx, my);
+    tmp    = tmp_array + 16;
+    ff_put_vp8_epel8_v6_mmi(dst, dststride, tmp, 8, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[168];
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+
+    for (y = 0; y < h + 5; y++) {
+        for (x = 0; x < 8; x++)
+            tmp[x] = FILTER_6TAP(src, filter, 1);
+        tmp += 8;
+        src += srcstride;
+    }
+
+    tmp    = tmp_array + 16;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 8; x++)
+            dst[x] = FILTER_6TAP(tmp, filter, 8);
+        dst += dststride;
+        tmp += 8;
+    }
+#endif
+}
+
+void ff_put_vp8_epel4_h6v6_mmi(uint8_t *dst, ptrdiff_t dststride, uint8_t *src,
+        ptrdiff_t srcstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(4, uint8_t, tmp_array[52]);
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+    ff_put_vp8_epel4_h6_mmi(tmp, 4, src, srcstride, h + 5, mx, my);
+    tmp    = tmp_array + 8;
+    ff_put_vp8_epel4_v6_mmi(dst, dststride, tmp, 4, h, mx, my);
+#else
+    const uint8_t *filter = subpel_filters[mx - 1];
+    const uint8_t *cm     = ff_crop_tab + MAX_NEG_CROP;
+    int x, y;
+    uint8_t tmp_array[52];
+    uint8_t *tmp = tmp_array;
+
+    src -= 2 * srcstride;
+
+    for (y = 0; y < h + 5; y++) {
+        for (x = 0; x < 4; x++)
+            tmp[x] = FILTER_6TAP(src, filter, 1);
+        tmp += 4;
+        src += srcstride;
+    }
+
+    tmp    = tmp_array + 8;
+    filter = subpel_filters[my - 1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 4; x++)
+            dst[x] = FILTER_6TAP(tmp, filter, 4);
+        dst += dststride;
+        tmp += 4;
+    }
+#endif
+}
+
+void ff_put_vp8_bilinear16_h_mmi(uint8_t *dst, ptrdiff_t dstride, uint8_t *src,
+        ptrdiff_t sstride, int h, int mx, int my)
+{
+#if 1
+    int a = 8 - mx, b = mx;
+    double ftmp[7];
+    uint32_t tmp[1];
+    mips_reg dst0, src0;
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = (a * src[0] + b * src[1] + 4) >> 3;
+    dst[1] = (a * src[1] + b * src[2] + 4) >> 3;
+    dst[2] = (a * src[2] + b * src[3] + 4) >> 3;
+    dst[3] = (a * src[3] + b * src[4] + 4) >> 3;
+    dst[4] = (a * src[4] + b * src[5] + 4) >> 3;
+    dst[5] = (a * src[5] + b * src[6] + 4) >> 3;
+    dst[6] = (a * src[6] + b * src[7] + 4) >> 3;
+    dst[7] = (a * src[7] + b * src[8] + 4) >> 3;
+
+    dst[ 8] = (a * src[ 8] + b * src[ 9] + 4) >> 3;
+    dst[ 9] = (a * src[ 9] + b * src[10] + 4) >> 3;
+    dst[10] = (a * src[10] + b * src[11] + 4) >> 3;
+    dst[11] = (a * src[11] + b * src[12] + 4) >> 3;
+    dst[12] = (a * src[12] + b * src[13] + 4) >> 3;
+    dst[13] = (a * src[13] + b * src[14] + 4) >> 3;
+    dst[14] = (a * src[14] + b * src[15] + 4) >> 3;
+    dst[15] = (a * src[15] + b * src[16] + 4) >> 3;
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x03                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+        "pshufh     %[a],       %[a],           %[ftmp0]            \n\t"
+        "pshufh     %[b],       %[b],           %[ftmp0]            \n\t"
+
+        "1:                                                         \n\t"
+        // 0 - 7
+        PUT_VP8_BILINEAR8_H_MMI(%[src], %[dst])
+        PTR_ADDIU  "%[src0],    %[src],         0x08                \n\t"
+        PTR_ADDIU  "%[dst0],    %[dst],         0x08                \n\t"
+        // 8 - 15
+        PUT_VP8_BILINEAR8_H_MMI(%[src0], %[dst0])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[sstride]          \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dstride]          \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [dst0]"=&r"(dst0),            [src0]"=&r"(src0),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),              [src]"+&r"(src),
+          [a]"+&f"(a),                  [b]"+&f"(b)
+        : [sstride]"r"((mips_reg)sstride),
+          [dstride]"r"((mips_reg)dstride),
+          [ff_pw_4]"f"(ff_pw_4)
+        : "memory"
+    );
+#else
+    int a = 8 - mx, b = mx;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 16; x++)
+            dst[x] = (a * src[x] + b * src[x + 1] + 4) >> 3;
+        dst += dstride;
+        src += sstride;
+    }
+#endif
+}
+
+void ff_put_vp8_bilinear16_v_mmi(uint8_t *dst, ptrdiff_t dstride, uint8_t *src,
+        ptrdiff_t sstride, int h, int mx, int my)
+{
+#if 1
+    int c = 8 - my, d = my;
+    double ftmp[7];
+    uint32_t tmp[1];
+    mips_reg src0, src1, dst0;
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = (c * src[0] + d * src[    sstride] + 4) >> 3;
+    dst[1] = (c * src[1] + d * src[1 + sstride] + 4) >> 3;
+    dst[2] = (c * src[2] + d * src[2 + sstride] + 4) >> 3;
+    dst[3] = (c * src[3] + d * src[3 + sstride] + 4) >> 3;
+    dst[4] = (c * src[4] + d * src[4 + sstride] + 4) >> 3;
+    dst[5] = (c * src[5] + d * src[5 + sstride] + 4) >> 3;
+    dst[6] = (c * src[6] + d * src[6 + sstride] + 4) >> 3;
+    dst[7] = (c * src[7] + d * src[7 + sstride] + 4) >> 3;
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x03                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+        "pshufh     %[c],       %[c],           %[ftmp0]            \n\t"
+        "pshufh     %[d],       %[d],           %[ftmp0]            \n\t"
+
+        "1:                                                         \n\t"
+        // 0 - 7
+        PUT_VP8_BILINEAR8_V_MMI(%[src], %[src1], %[dst], %[sstride])
+        PTR_ADDIU  "%[src0],    %[src],         0x08                \n\t"
+        PTR_ADDIU  "%[dst0],    %[dst],         0x08                \n\t"
+        // 8 - 15
+        PUT_VP8_BILINEAR8_V_MMI(%[src0], %[src1], %[dst0], %[sstride])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[sstride]          \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dstride]          \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [src0]"=&r"(src0),            [dst0]"=&r"(dst0),
+          [src1]"=&r"(src1),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),              [src]"+&r"(src),
+          [c]"+&f"(c),                  [d]"+&f"(d)
+        : [sstride]"r"((mips_reg)sstride),
+          [dstride]"r"((mips_reg)dstride),
+          [ff_pw_4]"f"(ff_pw_4)
+        : "memory"
+    );
+#else
+    int c = 8 - my, d = my;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 16; x++)
+            dst[x] = (c * src[x] + d * src[x + sstride] + 4) >> 3;
+        dst += dstride;
+        src += sstride;
+    }
+#endif
+}
+
+void ff_put_vp8_bilinear16_hv_mmi(uint8_t *dst, ptrdiff_t dstride, uint8_t *src,
+        ptrdiff_t sstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(8, uint8_t, tmp_array[528]);
+    uint8_t *tmp = tmp_array;
+
+    ff_put_vp8_bilinear16_h_mmi(tmp, 16, src, sstride, h + 1, mx, my);
+    ff_put_vp8_bilinear16_v_mmi(dst, dstride, tmp, 16, h, mx, my);
+#else
+    int a = 8 - mx, b = mx;
+    int c = 8 - my, d = my;
+    int x, y;
+    uint8_t tmp_array[528];
+    uint8_t *tmp = tmp_array;
+
+    for (y = 0; y < h + 1; y++) {
+        for (x = 0; x < 16; x++)
+            tmp[x] = (a * src[x] + b * src[x + 1] + 4) >> 3;
+        tmp += 16;
+        src += sstride;
+    }
+
+    tmp = tmp_array;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 16; x++)
+            dst[x] = (c * tmp[x] + d * tmp[x + 16] + 4) >> 3;
+        dst += dstride;
+        tmp += 16;
+    }
+#endif
+}
+
+void ff_put_vp8_bilinear8_h_mmi(uint8_t *dst, ptrdiff_t dstride, uint8_t *src,
+        ptrdiff_t sstride, int h, int mx, int my)
+{
+#if 1
+    int a = 8 - mx, b = mx;
+    double ftmp[7];
+    uint32_t tmp[1];
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = (a * src[0] + b * src[1] + 4) >> 3;
+    dst[1] = (a * src[1] + b * src[2] + 4) >> 3;
+    dst[2] = (a * src[2] + b * src[3] + 4) >> 3;
+    dst[3] = (a * src[3] + b * src[4] + 4) >> 3;
+    dst[4] = (a * src[4] + b * src[5] + 4) >> 3;
+    dst[5] = (a * src[5] + b * src[6] + 4) >> 3;
+    dst[6] = (a * src[6] + b * src[7] + 4) >> 3;
+    dst[7] = (a * src[7] + b * src[8] + 4) >> 3;
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x03                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+        "pshufh     %[a],       %[a],           %[ftmp0]            \n\t"
+        "pshufh     %[b],       %[b],           %[ftmp0]            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_BILINEAR8_H_MMI(%[src], %[dst])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[sstride]          \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dstride]          \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),              [src]"+&r"(src),
+          [a]"+&f"(a),                  [b]"+&f"(b)
+        : [sstride]"r"((mips_reg)sstride),
+          [dstride]"r"((mips_reg)dstride),
+          [ff_pw_4]"f"(ff_pw_4)
+        : "memory"
+    );
+#else
+    int a = 8 - mx, b = mx;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 8; x++)
+            dst[x] = (a * src[x] + b * src[x + 1] + 4) >> 3;
+        dst += dstride;
+        src += sstride;
+    }
+#endif
+}
+
+void ff_put_vp8_bilinear8_v_mmi(uint8_t *dst, ptrdiff_t dstride, uint8_t *src,
+        ptrdiff_t sstride, int h, int mx, int my)
+{
+#if 1
+    int c = 8 - my, d = my;
+    double ftmp[7];
+    uint32_t tmp[1];
+    mips_reg src1;
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = (c * src[0] + d * src[    sstride] + 4) >> 3;
+    dst[1] = (c * src[1] + d * src[1 + sstride] + 4) >> 3;
+    dst[2] = (c * src[2] + d * src[2 + sstride] + 4) >> 3;
+    dst[3] = (c * src[3] + d * src[3 + sstride] + 4) >> 3;
+    dst[4] = (c * src[4] + d * src[4 + sstride] + 4) >> 3;
+    dst[5] = (c * src[5] + d * src[5 + sstride] + 4) >> 3;
+    dst[6] = (c * src[6] + d * src[6 + sstride] + 4) >> 3;
+    dst[7] = (c * src[7] + d * src[7 + sstride] + 4) >> 3;
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x03                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+        "pshufh     %[c],       %[c],           %[ftmp0]            \n\t"
+        "pshufh     %[d],       %[d],           %[ftmp0]            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_BILINEAR8_V_MMI(%[src], %[src1], %[dst], %[sstride])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[sstride]          \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dstride]          \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),        [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_ALL64
+          [src1]"=&r"(src1),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),              [src]"+&r"(src),
+          [c]"+&f"(c),                  [d]"+&f"(d)
+        : [sstride]"r"((mips_reg)sstride),
+          [dstride]"r"((mips_reg)dstride),
+          [ff_pw_4]"f"(ff_pw_4)
+        : "memory"
+    );
+#else
+    int c = 8 - my, d = my;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 8; x++)
+            dst[x] = (c * src[x] + d * src[x + sstride] + 4) >> 3;
+        dst += dstride;
+        src += sstride;
+    }
+#endif
+}
+
+void ff_put_vp8_bilinear8_hv_mmi(uint8_t *dst, ptrdiff_t dstride, uint8_t *src,
+        ptrdiff_t sstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(8, uint8_t, tmp_array[136]);
+    uint8_t *tmp = tmp_array;
+
+    ff_put_vp8_bilinear8_h_mmi(tmp, 8, src, sstride, h + 1, mx, my);
+    ff_put_vp8_bilinear8_v_mmi(dst, dstride, tmp, 8, h, mx, my);
+#else
+    int a = 8 - mx, b = mx;
+    int c = 8 - my, d = my;
+    int x, y;
+    uint8_t tmp_array[136];
+    uint8_t *tmp = tmp_array;
+
+    for (y = 0; y < h + 1; y++) {
+        for (x = 0; x < 8; x++)
+            tmp[x] = (a * src[x] + b * src[x + 1] + 4) >> 3;
+        tmp += 8;
+        src += sstride;
+    }
+
+    tmp = tmp_array;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 8; x++)
+            dst[x] = (c * tmp[x] + d * tmp[x + 8] + 4) >> 3;
+        dst += dstride;
+        tmp += 8;
+    }
+#endif
+}
+
+void ff_put_vp8_bilinear4_h_mmi(uint8_t *dst, ptrdiff_t dstride, uint8_t *src,
+        ptrdiff_t sstride, int h, int mx, int my)
+{
+#if 1
+    int a = 8 - mx, b = mx;
+    double ftmp[5];
+    uint32_t tmp[1];
+    DECLARE_VAR_LOW32;
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = (a * src[0] + b * src[1] + 4) >> 3;
+    dst[1] = (a * src[1] + b * src[2] + 4) >> 3;
+    dst[2] = (a * src[2] + b * src[3] + 4) >> 3;
+    dst[3] = (a * src[3] + b * src[4] + 4) >> 3;
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x03                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+        "pshufh     %[a],       %[a],           %[ftmp0]            \n\t"
+        "pshufh     %[b],       %[b],           %[ftmp0]            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_BILINEAR4_H_MMI(%[src], %[dst])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[sstride]          \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dstride]          \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          RESTRICT_ASM_ALL64
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),              [src]"+&r"(src),
+          [a]"+&f"(a),                  [b]"+&f"(b)
+        : [sstride]"r"((mips_reg)sstride),
+          [dstride]"r"((mips_reg)dstride),
+          [ff_pw_4]"f"(ff_pw_4)
+        : "memory"
+    );
+#else
+    int a = 8 - mx, b = mx;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 4; x++)
+            dst[x] = (a * src[x] + b * src[x + 1] + 4) >> 3;
+        dst += dstride;
+        src += sstride;
+    }
+#endif
+}
+
+void ff_put_vp8_bilinear4_v_mmi(uint8_t *dst, ptrdiff_t dstride, uint8_t *src,
+        ptrdiff_t sstride, int h, int mx, int my)
+{
+#if 1
+    int c = 8 - my, d = my;
+    double ftmp[7];
+    uint32_t tmp[1];
+    mips_reg src1;
+    DECLARE_VAR_LOW32;
+    DECLARE_VAR_ALL64;
+
+    /*
+    dst[0] = (c * src[0] + d * src[    sstride] + 4) >> 3;
+    dst[1] = (c * src[1] + d * src[1 + sstride] + 4) >> 3;
+    dst[2] = (c * src[2] + d * src[2 + sstride] + 4) >> 3;
+    dst[3] = (c * src[3] + d * src[3 + sstride] + 4) >> 3;
+    */
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],       %[ftmp0]            \n\t"
+        "li         %[tmp0],    0x03                                \n\t"
+        "mtc1       %[tmp0],    %[ftmp4]                            \n\t"
+        "pshufh     %[c],       %[c],           %[ftmp0]            \n\t"
+        "pshufh     %[d],       %[d],           %[ftmp0]            \n\t"
+
+        "1:                                                         \n\t"
+        PUT_VP8_BILINEAR4_V_MMI(%[src], %[src1], %[dst], %[sstride])
+
+        "addiu      %[h],       %[h],           -0x01               \n\t"
+        PTR_ADDU   "%[src],     %[src],         %[sstride]          \n\t"
+        PTR_ADDU   "%[dst],     %[dst],         %[dstride]          \n\t"
+        "bnez       %[h],       1b                                  \n\t"
+        : [ftmp0]"=&f"(ftmp[0]),        [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),        [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),
+          [tmp0]"=&r"(tmp[0]),
+          RESTRICT_ASM_LOW32
+          RESTRICT_ASM_ALL64
+          [src1]"=&r"(src1),
+          [h]"+&r"(h),
+          [dst]"+&r"(dst),              [src]"+&r"(src),
+          [c]"+&f"(c),                  [d]"+&f"(d)
+        : [sstride]"r"((mips_reg)sstride),
+          [dstride]"r"((mips_reg)dstride),
+          [ff_pw_4]"f"(ff_pw_4)
+        : "memory"
+    );
+#else
+    int c = 8 - my, d = my;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 4; x++)
+            dst[x] = (c * src[x] + d * src[x + sstride] + 4) >> 3;
+        dst += dstride;
+        src += sstride;
+    }
+#endif
+}
+
+void ff_put_vp8_bilinear4_hv_mmi(uint8_t *dst, ptrdiff_t dstride, uint8_t *src,
+        ptrdiff_t sstride, int h, int mx, int my)
+{
+#if 1
+    DECLARE_ALIGNED(4, uint8_t, tmp_array[36]);
+    uint8_t *tmp = tmp_array;
+
+    ff_put_vp8_bilinear4_h_mmi(tmp, 4, src, sstride, h + 1, mx, my);
+    ff_put_vp8_bilinear4_v_mmi(dst, dstride, tmp, 4, h, mx, my);
+#else
+    int a = 8 - mx, b = mx;
+    int c = 8 - my, d = my;
+    int x, y;
+    uint8_t tmp_array[36];
+    uint8_t *tmp = tmp_array;
+
+    for (y = 0; y < h + 1; y++) {
+        for (x = 0; x < 4; x++)
+            tmp[x] = (a * src[x] + b * src[x + 1] + 4) >> 3;
+        tmp += 4;
+        src += sstride;
+    }
+
+    tmp = tmp_array;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < 4; x++)
+            dst[x] = (c * tmp[x] + d * tmp[x + 4] + 4) >> 3;
+        dst += dstride;
+        tmp += 4;
+    }
+#endif
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/vp9_idct_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/vp9_idct_msa.c
index 25ea16c72a0..bd762f26966 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/vp9_idct_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/vp9_idct_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Shivraj Patil (Shivraj.Patil@imgtec.com)
+ * Copyright (c) 2015 - 2017 Shivraj Patil (Shivraj.Patil@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -352,6 +352,7 @@ static void vp9_idct4x4_1_add_msa(int16_t *input, uint8_t *dst,
     out = ROUND_POWER_OF_TWO((out * cospi_16_64), VP9_DCT_CONST_BITS);
     out = ROUND_POWER_OF_TWO(out, 4);
     vec = __msa_fill_h(out);
+    input[0] = 0;
 
     ADDBLK_ST4x4_UB(vec, vec, vec, vec, dst, dst_stride);
 }
@@ -360,9 +361,11 @@ static void vp9_idct4x4_colcol_addblk_msa(int16_t *input, uint8_t *dst,
                                           int32_t dst_stride)
 {
     v8i16 in0, in1, in2, in3;
+    v8i16 zero = { 0 };
 
     /* load vector elements of 4x4 block */
     LD4x4_SH(input, in0, in1, in2, in3);
+    ST_SH2(zero, zero, input, 8);
     /* rows */
     VP9_IDCT4x4(in0, in1, in2, in3, in0, in1, in2, in3);
     /* columns */
@@ -377,9 +380,11 @@ static void vp9_iadst4x4_colcol_addblk_msa(int16_t *input, uint8_t *dst,
                                            int32_t dst_stride)
 {
     v8i16 in0, in1, in2, in3;
+    v8i16 zero = { 0 };
 
     /* load vector elements of 4x4 block */
     LD4x4_SH(input, in0, in1, in2, in3);
+    ST_SH2(zero, zero, input, 8);
     /* rows */
     VP9_IADST4x4(in0, in1, in2, in3, in0, in1, in2, in3);
     /* columns */
@@ -394,9 +399,11 @@ static void vp9_iadst_idct_4x4_add_msa(int16_t *input, uint8_t *dst,
                                        int32_t dst_stride, int32_t eob)
 {
     v8i16 in0, in1, in2, in3;
+    v8i16 zero = { 0 };
 
     /* load vector elements of 4x4 block */
     LD4x4_SH(input, in0, in1, in2, in3);
+    ST_SH2(zero, zero, input, 8);
     /* cols */
     VP9_IADST4x4(in0, in1, in2, in3, in0, in1, in2, in3);
     /* columns */
@@ -411,9 +418,11 @@ static void vp9_idct_iadst_4x4_add_msa(int16_t *input, uint8_t *dst,
                                        int32_t dst_stride, int32_t eob)
 {
     v8i16 in0, in1, in2, in3;
+    v8i16 zero = { 0 };
 
     /* load vector elements of 4x4 block */
     LD4x4_SH(input, in0, in1, in2, in3);
+    ST_SH2(zero, zero, input, 8);
     /* cols */
     VP9_IDCT4x4(in0, in1, in2, in3, in0, in1, in2, in3);
     /* columns */
@@ -585,6 +594,7 @@ static void vp9_idct8x8_1_add_msa(int16_t *input, uint8_t *dst,
     out = ROUND_POWER_OF_TWO((out * cospi_16_64), VP9_DCT_CONST_BITS);
     val = ROUND_POWER_OF_TWO(out, 5);
     vec = __msa_fill_h(val);
+    input[0] = 0;
 
     VP9_ADDBLK_ST8x4_UB(dst, dst_stride, vec, vec, vec, vec);
     dst += (4 * dst_stride);
@@ -601,9 +611,9 @@ static void vp9_idct8x8_12_colcol_addblk_msa(int16_t *input, uint8_t *dst,
 
     /* load vector elements of 8x8 block */
     LD_SH8(input, 8, in0, in1, in2, in3, in4, in5, in6, in7);
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, input, 8);
     ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
     ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
-    //TRANSPOSE8X4_SH_SH(in0, in1, in2, in3, in0, in1, in2, in3);
 
     /* stage1 */
     ILVL_H2_SH(in3, in0, in2, in1, s0, s1);
@@ -659,9 +669,11 @@ static void vp9_idct8x8_colcol_addblk_msa(int16_t *input, uint8_t *dst,
                                           int32_t dst_stride)
 {
     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
+    v8i16 zero = { 0 };
 
     /* load vector elements of 8x8 block */
     LD_SH8(input, 8, in0, in1, in2, in3, in4, in5, in6, in7);
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, input, 8);
     /* 1D idct8x8 */
     VP9_IDCT8x8_1D(in0, in1, in2, in3, in4, in5, in6, in7,
                    in0, in1, in2, in3, in4, in5, in6, in7);
@@ -689,10 +701,11 @@ static void vp9_iadst8x8_colcol_addblk_msa(int16_t *input, uint8_t *dst,
     v8i16 out0, out1, out2, out3, out4, out5, out6, out7;
     v8i16 cnst0, cnst1, cnst2, cnst3, cnst4;
     v8i16 temp0, temp1, temp2, temp3, s0, s1;
-    v16i8 zero = { 0 };
+    v8i16 zero = { 0 };
 
     /* load vector elements of 8x8 block */
     LD_SH8(input, 8, in0, in1, in2, in3, in4, in5, in6, in7);
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, input, 8);
 
     /* 1D adst8x8 */
     VP9_ADST8(in0, in1, in2, in3, in4, in5, in6, in7,
@@ -736,13 +749,13 @@ static void vp9_iadst8x8_colcol_addblk_msa(int16_t *input, uint8_t *dst,
     dst0 = LD_UB(dst + 0 * dst_stride);
     dst7 = LD_UB(dst + 7 * dst_stride);
 
-    res0 = (v8i16) __msa_ilvr_b(zero, (v16i8) dst0);
+    res0 = (v8i16) __msa_ilvr_b((v16i8) zero, (v16i8) dst0);
     res0 += out0;
     res0 = CLIP_SH_0_255(res0);
     res0 = (v8i16) __msa_pckev_b((v16i8) res0, (v16i8) res0);
     ST8x1_UB(res0, dst);
 
-    res7 = (v8i16) __msa_ilvr_b(zero, (v16i8) dst7);
+    res7 = (v8i16) __msa_ilvr_b((v16i8) zero, (v16i8) dst7);
     res7 += out7;
     res7 = CLIP_SH_0_255(res7);
     res7 = (v8i16) __msa_pckev_b((v16i8) res7, (v16i8) res7);
@@ -809,9 +822,11 @@ static void vp9_iadst_idct_8x8_add_msa(int16_t *input, uint8_t *dst,
                                        int32_t dst_stride, int32_t eob)
 {
     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
+    v8i16 zero = { 0 };
 
     /* load vector elements of 8x8 block */
     LD_SH8(input, 8, in1, in6, in3, in4, in5, in2, in7, in0);
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, input, 8);
     /* 1D idct8x8 */
     VP9_IADST8x8_1D(in0, in1, in2, in3, in4, in5, in6, in7,
                     in0, in1, in2, in3, in4, in5, in6, in7);
@@ -834,9 +849,11 @@ static void vp9_idct_iadst_8x8_add_msa(int16_t *input, uint8_t *dst,
                                        int32_t dst_stride, int32_t eob)
 {
     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
+    v8i16 zero = { 0 };
 
     /* load vector elements of 8x8 block */
     LD_SH8(input, 8, in0, in1, in2, in3, in4, in5, in6, in7);
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, input, 8);
 
     /* 1D idct8x8 */
     VP9_IDCT8x8_1D(in0, in1, in2, in3, in4, in5, in6, in7,
@@ -937,12 +954,16 @@ static void vp9_idct16_1d_columns_addblk_msa(int16_t *input, uint8_t *dst,
     v8i16 reg0, reg2, reg4, reg6, reg8, reg10, reg12, reg14;
     v8i16 reg3, reg13, reg11, reg5, reg7, reg9, reg1, reg15;
     v8i16 tmp5, tmp6, tmp7;
+    v8i16 zero = { 0 };
+
+    /* load up 8x16 */
+    LD_SH16(input, 16,
+            reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7,
+            reg8, reg9, reg10, reg11, reg12, reg13, reg14, reg15);
 
-    /* load up 8x8 */
-    LD_SH8(input, 16, reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7);
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, input, 16);
     input += 8 * 16;
-    /* load bottom 8x8 */
-    LD_SH8(input, 16, reg8, reg9, reg10, reg11, reg12, reg13, reg14, reg15);
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, input, 16);
 
     VP9_DOTP_CONST_PAIR(reg2, reg14, cospi_28_64, cospi_4_64, reg2, reg14);
     VP9_DOTP_CONST_PAIR(reg10, reg6, cospi_12_64, cospi_20_64, reg10, reg6);
@@ -1036,12 +1057,16 @@ static void vp9_idct16_1d_columns_msa(int16_t *input, int16_t *output)
     v8i16 reg0, reg2, reg4, reg6, reg8, reg10, reg12, reg14;
     v8i16 reg3, reg13, reg11, reg5, reg7, reg9, reg1, reg15;
     v8i16 tmp5, tmp6, tmp7;
+    v8i16 zero = { 0 };
 
-    /* load up 8x8 */
-    LD_SH8(input, 16, reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7);
-    input += 8 * 16;
-    /* load bottom 8x8 */
-    LD_SH8(input, 16, reg8, reg9, reg10, reg11, reg12, reg13, reg14, reg15);
+    /* load up 8x16 */
+    LD_SH16(input, 16,
+            reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7,
+            reg8, reg9, reg10, reg11, reg12, reg13, reg14, reg15);
+
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, input, 16);
+    input += 16 * 8;
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, input, 16);
 
     VP9_DOTP_CONST_PAIR(reg2, reg14, cospi_28_64, cospi_4_64, reg2, reg14);
     VP9_DOTP_CONST_PAIR(reg10, reg6, cospi_12_64, cospi_20_64, reg10, reg6);
@@ -1141,11 +1166,11 @@ static void vp9_idct16x16_1_add_msa(int16_t *input, uint8_t *dst,
     out = ROUND_POWER_OF_TWO((input[0] * cospi_16_64), VP9_DCT_CONST_BITS);
     out = ROUND_POWER_OF_TWO((out * cospi_16_64), VP9_DCT_CONST_BITS);
     out = ROUND_POWER_OF_TWO(out, 6);
+    input[0] = 0;
 
     vec = __msa_fill_h(out);
 
-    for (i = 4; i--;)
-    {
+    for (i = 4; i--;) {
         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
         UNPCK_UB_SH(dst0, res0, res4);
         UNPCK_UB_SH(dst1, res1, res5);
@@ -1229,12 +1254,17 @@ static void vp9_iadst16_1d_columns_msa(int16_t *input, int16_t *output)
 {
     v8i16 r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15;
     v8i16 l0, l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15;
+    v8i16 zero = { 0 };
 
     /* load input data */
     LD_SH16(input, 16,
             l0, l1, l2, l3, l4, l5, l6, l7,
             l8, l9, l10, l11, l12, l13, l14, l15);
 
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, input, 16);
+    input += 16 * 8;
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, input, 16);
+
     /* ADST in horizontal */
     VP9_IADST8x16_1D(l0, l1, l2, l3, l4, l5, l6, l7,
                      l8, l9, l10, l11, l12, l13, l14, l15,
@@ -1591,9 +1621,11 @@ static void vp9_idct8x32_column_even_process_store(int16_t *tmp_buf,
     v8i16 vec0, vec1, vec2, vec3, loc0, loc1, loc2, loc3;
     v8i16 reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
     v8i16 stp0, stp1, stp2, stp3, stp4, stp5, stp6, stp7;
+    v8i16 zero = { 0 };
 
     /* Even stage 1 */
     LD_SH8(tmp_buf, (4 * 32), reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7);
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, tmp_buf, (4 * 32));
     tmp_buf += (2 * 32);
 
     VP9_DOTP_CONST_PAIR(reg1, reg7, cospi_28_64, cospi_4_64, reg1, reg7);
@@ -1613,6 +1645,7 @@ static void vp9_idct8x32_column_even_process_store(int16_t *tmp_buf,
     /* Even stage 2 */
     /* Load 8 */
     LD_SH8(tmp_buf, (4 * 32), reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7);
+    ST_SH8(zero, zero, zero, zero, zero, zero, zero, zero, tmp_buf, (4 * 32));
 
     VP9_DOTP_CONST_PAIR(reg0, reg7, cospi_30_64, cospi_2_64, reg0, reg7);
     VP9_DOTP_CONST_PAIR(reg4, reg3, cospi_14_64, cospi_18_64, reg4, reg3);
@@ -1671,6 +1704,7 @@ static void vp9_idct8x32_column_odd_process_store(int16_t *tmp_buf,
 {
     v8i16 vec0, vec1, vec2, vec3, loc0, loc1, loc2, loc3;
     v8i16 reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
+    v8i16 zero = { 0 };
 
     /* Odd stage 1 */
     reg0 = LD_SH(tmp_buf + 32);
@@ -1682,6 +1716,15 @@ static void vp9_idct8x32_column_odd_process_store(int16_t *tmp_buf,
     reg6 = LD_SH(tmp_buf + 25 * 32);
     reg7 = LD_SH(tmp_buf + 31 * 32);
 
+    ST_SH(zero, tmp_buf + 32);
+    ST_SH(zero, tmp_buf + 7 * 32);
+    ST_SH(zero, tmp_buf + 9 * 32);
+    ST_SH(zero, tmp_buf + 15 * 32);
+    ST_SH(zero, tmp_buf + 17 * 32);
+    ST_SH(zero, tmp_buf + 23 * 32);
+    ST_SH(zero, tmp_buf + 25 * 32);
+    ST_SH(zero, tmp_buf + 31 * 32);
+
     VP9_DOTP_CONST_PAIR(reg0, reg7, cospi_31_64, cospi_1_64, reg0, reg7);
     VP9_DOTP_CONST_PAIR(reg4, reg3, cospi_15_64, cospi_17_64, reg3, reg4);
     VP9_DOTP_CONST_PAIR(reg2, reg5, cospi_23_64, cospi_9_64, reg2, reg5);
@@ -1723,6 +1766,15 @@ static void vp9_idct8x32_column_odd_process_store(int16_t *tmp_buf,
     reg6 = LD_SH(tmp_buf + 27 * 32);
     reg7 = LD_SH(tmp_buf + 29 * 32);
 
+    ST_SH(zero, tmp_buf + 3 * 32);
+    ST_SH(zero, tmp_buf + 5 * 32);
+    ST_SH(zero, tmp_buf + 11 * 32);
+    ST_SH(zero, tmp_buf + 13 * 32);
+    ST_SH(zero, tmp_buf + 19 * 32);
+    ST_SH(zero, tmp_buf + 21 * 32);
+    ST_SH(zero, tmp_buf + 27 * 32);
+    ST_SH(zero, tmp_buf + 29 * 32);
+
     VP9_DOTP_CONST_PAIR(reg1, reg6, cospi_27_64, cospi_5_64, reg1, reg6);
     VP9_DOTP_CONST_PAIR(reg5, reg2, cospi_11_64, cospi_21_64, reg2, reg5);
     VP9_DOTP_CONST_PAIR(reg3, reg4, cospi_19_64, cospi_13_64, reg3, reg4);
@@ -1901,11 +1953,11 @@ static void vp9_idct32x32_1_add_msa(int16_t *input, uint8_t *dst,
     out = ROUND_POWER_OF_TWO((input[0] * cospi_16_64), VP9_DCT_CONST_BITS);
     out = ROUND_POWER_OF_TWO((out * cospi_16_64), VP9_DCT_CONST_BITS);
     out = ROUND_POWER_OF_TWO(out, 6);
+    input[0] = 0;
 
     vec = __msa_fill_h(out);
 
-    for (i = 16; i--;)
-    {
+    for (i = 16; i--;) {
         LD_UB2(dst, 16, dst0, dst1);
         LD_UB2(dst + dst_stride, 16, dst2, dst3);
 
@@ -2004,11 +2056,9 @@ void ff_idct_idct_4x4_add_msa(uint8_t *dst, ptrdiff_t stride,
 {
     if (eob > 1) {
         vp9_idct4x4_colcol_addblk_msa(block, dst, stride);
-        memset(block, 0, 4 * 4 * sizeof(*block));
     }
     else {
         vp9_idct4x4_1_add_msa(block, dst, stride);
-        block[0] = 0;
     }
 }
 
@@ -2017,60 +2067,41 @@ void ff_idct_idct_8x8_add_msa(uint8_t *dst, ptrdiff_t stride,
 {
     if (eob == 1) {
         vp9_idct8x8_1_add_msa(block, dst, stride);
-        block[0] = 0;
     }
     else if (eob <= 12) {
         vp9_idct8x8_12_colcol_addblk_msa(block, dst, stride);
-        memset(block, 0, 4 * 8 * sizeof(*block));
     }
     else {
         vp9_idct8x8_colcol_addblk_msa(block, dst, stride);
-        memset(block, 0, 8 * 8 * sizeof(*block));
     }
 }
 
 void ff_idct_idct_16x16_add_msa(uint8_t *dst, ptrdiff_t stride,
                                 int16_t *block, int eob)
 {
-    int i;
-
     if (eob == 1) {
         /* DC only DCT coefficient. */
         vp9_idct16x16_1_add_msa(block, dst, stride);
-        block[0] = 0;
     }
     else if (eob <= 10) {
         vp9_idct16x16_10_colcol_addblk_msa(block, dst, stride);
-        for (i = 0; i < 4; ++i) {
-            memset(block, 0, 4 * sizeof(*block));
-            block += 16;
-        }
     }
     else {
         vp9_idct16x16_colcol_addblk_msa(block, dst, stride);
-        memset(block, 0, 16 * 16 * sizeof(*block));
     }
 }
 
 void ff_idct_idct_32x32_add_msa(uint8_t *dst, ptrdiff_t stride,
                                 int16_t *block, int eob)
 {
-    int i;
-
     if (eob == 1) {
         vp9_idct32x32_1_add_msa(block, dst, stride);
-        block[0] = 0;
     }
     else if (eob <= 34) {
         vp9_idct32x32_34_colcol_addblk_msa(block, dst, stride);
-        for (i = 0; i < 8; ++i) {
-            memset(block, 0, 8 * sizeof(*block));
-            block += 32;
-        }
     }
     else {
         vp9_idct32x32_colcol_addblk_msa(block, dst, stride);
-        memset(block, 0, 32 * 32 * sizeof(*block));
     }
 }
 
@@ -2078,61 +2109,52 @@ void ff_iadst_iadst_4x4_add_msa(uint8_t *dst, ptrdiff_t stride,
                                 int16_t *block, int eob)
 {
     vp9_iadst4x4_colcol_addblk_msa(block, dst, stride);
-    memset(block, 0, 4 * 4 * sizeof(*block));
 }
 
 void ff_iadst_iadst_8x8_add_msa(uint8_t *dst, ptrdiff_t stride,
                                 int16_t *block, int eob)
 {
     vp9_iadst8x8_colcol_addblk_msa(block, dst, stride);
-    memset(block, 0, 8 * 8 * sizeof(*block));
 }
 
 void ff_iadst_iadst_16x16_add_msa(uint8_t *dst, ptrdiff_t stride,
                                   int16_t *block, int eob)
 {
     vp9_iadst16x16_colcol_addblk_msa(block, dst, stride);
-    memset(block, 0, 16 * 16 * sizeof(*block));
 }
 
 void ff_idct_iadst_4x4_add_msa(uint8_t *dst, ptrdiff_t stride,
                                int16_t *block, int eob)
 {
     vp9_idct_iadst_4x4_add_msa(block, dst, stride, eob);
-    memset(block, 0, 4 * 4 * sizeof(*block));
 }
 
 void ff_idct_iadst_8x8_add_msa(uint8_t *dst, ptrdiff_t stride,
                                int16_t *block, int eob)
 {
     vp9_idct_iadst_8x8_add_msa(block, dst, stride, eob);
-    memset(block, 0, 8 * 8 * sizeof(*block));
 }
 
 void ff_idct_iadst_16x16_add_msa(uint8_t *dst, ptrdiff_t stride,
                                  int16_t *block, int eob)
 {
     vp9_idct_iadst_16x16_add_msa(block, dst, stride, eob);
-    memset(block, 0, 16 * 16 * sizeof(*block));
 }
 
 void ff_iadst_idct_4x4_add_msa(uint8_t *dst, ptrdiff_t stride,
                                int16_t *block, int eob)
 {
     vp9_iadst_idct_4x4_add_msa(block, dst, stride, eob);
-    memset(block, 0, 4 * 4 * sizeof(*block));
 }
 
 void ff_iadst_idct_8x8_add_msa(uint8_t *dst, ptrdiff_t stride,
                                int16_t *block, int eob)
 {
     vp9_iadst_idct_8x8_add_msa(block, dst, stride, eob);
-    memset(block, 0, 8 * 8 * sizeof(*block));
 }
 
 void ff_iadst_idct_16x16_add_msa(uint8_t *dst, ptrdiff_t stride,
                                  int16_t *block, int eob)
 {
     vp9_iadst_idct_16x16_add_msa(block, dst, stride, eob);
-    memset(block, 0, 16 * 16 * sizeof(*block));
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/vp9_lpf_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/vp9_lpf_msa.c
index eef8afc4828..c82a9e98bc0 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/vp9_lpf_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/vp9_lpf_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Shivraj Patil (Shivraj.Patil@imgtec.com)
+ * Copyright (c) 2015 - 2017 Shivraj Patil (Shivraj.Patil@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -22,63 +22,12 @@
 #include "libavutil/mips/generic_macros_msa.h"
 #include "vp9dsp_mips.h"
 
-#define VP9_LPF_FILTER4_8W(p1_in, p0_in, q0_in, q1_in, mask_in, hev_in,  \
-                           p1_out, p0_out, q0_out, q1_out)               \
-{                                                                        \
-    v16i8 p1_m, p0_m, q0_m, q1_m, q0_sub_p0, filt_sign;                  \
-    v16i8 filt, filt1, filt2, cnst4b, cnst3b;                            \
-    v8i16 q0_sub_p0_r, filt_r, cnst3h;                                   \
-                                                                         \
-    p1_m = (v16i8) __msa_xori_b(p1_in, 0x80);                            \
-    p0_m = (v16i8) __msa_xori_b(p0_in, 0x80);                            \
-    q0_m = (v16i8) __msa_xori_b(q0_in, 0x80);                            \
-    q1_m = (v16i8) __msa_xori_b(q1_in, 0x80);                            \
-                                                                         \
-    filt = __msa_subs_s_b(p1_m, q1_m);                                   \
-    filt = filt & (v16i8) hev_in;                                        \
-    q0_sub_p0 = q0_m - p0_m;                                             \
-    filt_sign = __msa_clti_s_b(filt, 0);                                 \
-                                                                         \
-    cnst3h = __msa_ldi_h(3);                                             \
-    q0_sub_p0_r = (v8i16) __msa_ilvr_b(q0_sub_p0, q0_sub_p0);            \
-    q0_sub_p0_r = __msa_dotp_s_h((v16i8) q0_sub_p0_r, (v16i8) cnst3h);   \
-    filt_r = (v8i16) __msa_ilvr_b(filt_sign, filt);                      \
-    filt_r += q0_sub_p0_r;                                               \
-    filt_r = __msa_sat_s_h(filt_r, 7);                                   \
-                                                                         \
-    /* combine left and right part */                                    \
-    filt = __msa_pckev_b((v16i8) filt_r, (v16i8) filt_r);                \
-                                                                         \
-    filt = filt & (v16i8) mask_in;                                       \
-    cnst4b = __msa_ldi_b(4);                                             \
-    filt1 = __msa_adds_s_b(filt, cnst4b);                                \
-    filt1 >>= 3;                                                         \
-                                                                         \
-    cnst3b = __msa_ldi_b(3);                                             \
-    filt2 = __msa_adds_s_b(filt, cnst3b);                                \
-    filt2 >>= 3;                                                         \
-                                                                         \
-    q0_m = __msa_subs_s_b(q0_m, filt1);                                  \
-    q0_out = __msa_xori_b((v16u8) q0_m, 0x80);                           \
-    p0_m = __msa_adds_s_b(p0_m, filt2);                                  \
-    p0_out = __msa_xori_b((v16u8) p0_m, 0x80);                           \
-                                                                         \
-    filt = __msa_srari_b(filt1, 1);                                      \
-    hev_in = __msa_xori_b((v16u8) hev_in, 0xff);                         \
-    filt = filt & (v16i8) hev_in;                                        \
-                                                                         \
-    q1_m = __msa_subs_s_b(q1_m, filt);                                   \
-    q1_out = __msa_xori_b((v16u8) q1_m, 0x80);                           \
-    p1_m = __msa_adds_s_b(p1_m, filt);                                   \
-    p1_out = __msa_xori_b((v16u8) p1_m, 0x80);                           \
-}
-
 #define VP9_LPF_FILTER4_4W(p1_in, p0_in, q0_in, q1_in, mask_in, hev_in,  \
                            p1_out, p0_out, q0_out, q1_out)               \
 {                                                                        \
-    v16i8 p1_m, p0_m, q0_m, q1_m, q0_sub_p0, filt_sign;                  \
-    v16i8 filt, filt1, filt2, cnst4b, cnst3b;                            \
-    v8i16 q0_sub_p0_r, q0_sub_p0_l, filt_l, filt_r, cnst3h;              \
+    v16i8 p1_m, p0_m, q0_m, q1_m, q0_sub_p0, filt, filt1, filt2;         \
+    const v16i8 cnst4b = __msa_ldi_b(4);                                 \
+    const v16i8 cnst3b = __msa_ldi_b(3);                                 \
                                                                          \
     p1_m = (v16i8) __msa_xori_b(p1_in, 0x80);                            \
     p0_m = (v16i8) __msa_xori_b(p0_in, 0x80);                            \
@@ -89,30 +38,15 @@
                                                                          \
     filt = filt & (v16i8) hev_in;                                        \
                                                                          \
-    q0_sub_p0 = q0_m - p0_m;                                             \
-    filt_sign = __msa_clti_s_b(filt, 0);                                 \
-                                                                         \
-    cnst3h = __msa_ldi_h(3);                                             \
-    q0_sub_p0_r = (v8i16) __msa_ilvr_b(q0_sub_p0, q0_sub_p0);            \
-    q0_sub_p0_r = __msa_dotp_s_h((v16i8) q0_sub_p0_r, (v16i8) cnst3h);   \
-    filt_r = (v8i16) __msa_ilvr_b(filt_sign, filt);                      \
-    filt_r += q0_sub_p0_r;                                               \
-    filt_r = __msa_sat_s_h(filt_r, 7);                                   \
-                                                                         \
-    q0_sub_p0_l = (v8i16) __msa_ilvl_b(q0_sub_p0, q0_sub_p0);            \
-    q0_sub_p0_l = __msa_dotp_s_h((v16i8) q0_sub_p0_l, (v16i8) cnst3h);   \
-    filt_l = (v8i16) __msa_ilvl_b(filt_sign, filt);                      \
-    filt_l += q0_sub_p0_l;                                               \
-    filt_l = __msa_sat_s_h(filt_l, 7);                                   \
-                                                                         \
-    filt = __msa_pckev_b((v16i8) filt_l, (v16i8) filt_r);                \
+    q0_sub_p0 = __msa_subs_s_b(q0_m, p0_m);                              \
+    filt = __msa_adds_s_b(filt, q0_sub_p0);                              \
+    filt = __msa_adds_s_b(filt, q0_sub_p0);                              \
+    filt = __msa_adds_s_b(filt, q0_sub_p0);                              \
     filt = filt & (v16i8) mask_in;                                       \
                                                                          \
-    cnst4b = __msa_ldi_b(4);                                             \
     filt1 = __msa_adds_s_b(filt, cnst4b);                                \
     filt1 >>= 3;                                                         \
                                                                          \
-    cnst3b = __msa_ldi_b(3);                                             \
     filt2 = __msa_adds_s_b(filt, cnst3b);                                \
     filt2 >>= 3;                                                         \
                                                                          \
@@ -277,7 +211,7 @@ void ff_loop_filter_v_4_8_msa(uint8_t *src, ptrdiff_t pitch,
 
     LPF_MASK_HEV(p3, p2, p1, p0, q0, q1, q2, q3, limit, b_limit, thresh,
                  hev, mask, flat);
-    VP9_LPF_FILTER4_8W(p1, p0, q0, q1, mask, hev, p1_out, p0_out, q0_out,
+    VP9_LPF_FILTER4_4W(p1, p0, q0, q1, mask, hev, p1_out, p0_out, q0_out,
                        q1_out);
 
     p1_d = __msa_copy_u_d((v2i64) p1_out, 0);
@@ -342,7 +276,7 @@ void ff_loop_filter_v_8_8_msa(uint8_t *src, ptrdiff_t pitch,
     LPF_MASK_HEV(p3, p2, p1, p0, q0, q1, q2, q3, limit, b_limit, thresh,
                  hev, mask, flat);
     VP9_FLAT4(p3, p2, p0, q0, q2, q3, flat);
-    VP9_LPF_FILTER4_8W(p1, p0, q0, q1, mask, hev, p1_out, p0_out, q0_out,
+    VP9_LPF_FILTER4_4W(p1, p0, q0, q1, mask, hev, p1_out, p0_out, q0_out,
                        q1_out);
 
     flat = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) flat);
@@ -1065,7 +999,7 @@ void ff_loop_filter_v_16_8_msa(uint8_t *src, ptrdiff_t pitch,
     LPF_MASK_HEV(p3, p2, p1, p0, q0, q1, q2, q3, limit, b_limit, thresh,
                  hev, mask, flat);
     VP9_FLAT4(p3, p2, p0, q0, q2, q3, flat);
-    VP9_LPF_FILTER4_8W(p1, p0, q0, q1, mask, hev, p1_out, p0_out, q0_out,
+    VP9_LPF_FILTER4_4W(p1, p0, q0, q1, mask, hev, p1_out, p0_out, q0_out,
                        q1_out);
 
     flat = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) flat);
@@ -1280,7 +1214,7 @@ void ff_loop_filter_h_4_8_msa(uint8_t *src, ptrdiff_t pitch,
                        p3, p2, p1, p0, q0, q1, q2, q3);
     LPF_MASK_HEV(p3, p2, p1, p0, q0, q1, q2, q3, limit, b_limit, thresh,
                  hev, mask, flat);
-    VP9_LPF_FILTER4_8W(p1, p0, q0, q1, mask, hev, p1, p0, q0, q1);
+    VP9_LPF_FILTER4_4W(p1, p0, q0, q1, mask, hev, p1, p0, q0, q1);
     ILVR_B2_SH(p0, p1, q1, q0, vec0, vec1);
     ILVRL_H2_SH(vec1, vec0, vec2, vec3);
 
@@ -1367,7 +1301,7 @@ void ff_loop_filter_h_8_8_msa(uint8_t *src, ptrdiff_t pitch,
     /* flat4 */
     VP9_FLAT4(p3, p2, p0, q0, q2, q3, flat);
     /* filter4 */
-    VP9_LPF_FILTER4_8W(p1, p0, q0, q1, mask, hev, p1_out, p0_out, q0_out,
+    VP9_LPF_FILTER4_4W(p1, p0, q0, q1, mask, hev, p1_out, p0_out, q0_out,
                        q1_out);
 
     flat = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) flat);
@@ -1868,7 +1802,7 @@ static int32_t vp9_vt_lpf_t4_and_t8_8w(uint8_t *src, uint8_t *filter48,
     /* flat4 */
     VP9_FLAT4(p3, p2, p0, q0, q2, q3, flat);
     /* filter4 */
-    VP9_LPF_FILTER4_8W(p1, p0, q0, q1, mask, hev, p1_out, p0_out, q0_out,
+    VP9_LPF_FILTER4_4W(p1, p0, q0, q1, mask, hev, p1_out, p0_out, q0_out,
                        q1_out);
 
     flat = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) flat);
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/vp9_mc_msa.c b/mythtv/external/FFmpeg/libavcodec/mips/vp9_mc_msa.c
index 1671d973a4a..749e8cbe82c 100644
--- a/mythtv/external/FFmpeg/libavcodec/mips/vp9_mc_msa.c
+++ b/mythtv/external/FFmpeg/libavcodec/mips/vp9_mc_msa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Shivraj Patil (Shivraj.Patil@imgtec.com)
+ * Copyright (c) 2015 - 2017 Shivraj Patil (Shivraj.Patil@imgtec.com)
  *
  * This file is part of FFmpeg.
  *
@@ -145,16 +145,15 @@ static const int8_t vp9_bilinear_filters_msa[15][2] = {
     ST_UB(tmp_m, (pdst));                                     \
 }
 
-#define PCKEV_AVG_ST8x4_UB(in1, dst0, in2, dst1, in3, dst2, in4, dst3,  \
-                           pdst, stride)                                \
-{                                                                       \
-    v16u8 tmp0_m, tmp1_m, tmp2_m, tmp3_m;                               \
-    uint8_t *pdst_m = (uint8_t *) (pdst);                               \
-                                                                        \
-    PCKEV_B2_UB(in2, in1, in4, in3, tmp0_m, tmp1_m);                    \
-    PCKEV_D2_UB(dst1, dst0, dst3, dst2, tmp2_m, tmp3_m);                \
-    AVER_UB2_UB(tmp0_m, tmp2_m, tmp1_m, tmp3_m, tmp0_m, tmp1_m);        \
-    ST8x4_UB(tmp0_m, tmp1_m, pdst_m, stride);                           \
+#define PCKEV_AVG_ST8x4_UB(in0, in1, in2, in3,  dst0, dst1,   \
+                           pdst, stride)                      \
+{                                                             \
+    v16u8 tmp0_m, tmp1_m;                                     \
+    uint8_t *pdst_m = (uint8_t *) (pdst);                     \
+                                                              \
+    PCKEV_B2_UB(in1, in0, in3, in2, tmp0_m, tmp1_m);          \
+    AVER_UB2_UB(tmp0_m, dst0, tmp1_m, dst1, tmp0_m, tmp1_m);  \
+    ST8x4_UB(tmp0_m, tmp1_m, pdst_m, stride);                 \
 }
 
 static void common_hz_8t_4x4_msa(const uint8_t *src, int32_t src_stride,
@@ -224,64 +223,6 @@ static void common_hz_8t_4x8_msa(const uint8_t *src, int32_t src_stride,
     ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
 }
 
-static void common_hz_8t_4x16_msa(const uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
-                                  const int8_t *filter)
-{
-    v16u8 mask0, mask1, mask2, mask3, out;
-    v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
-    v8i16 filt, out0, out1, out2, out3;
-
-    mask0 = LD_UB(&mc_filt_mask_arr[16]);
-    src -= 3;
-
-    /* rearranging filter */
-    filt = LD_SH(filter);
-    SPLATI_H4_SB(filt, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
-
-    mask1 = mask0 + 2;
-    mask2 = mask0 + 4;
-    mask3 = mask0 + 6;
-
-    LD_SB4(src, src_stride, src0, src1, src2, src3);
-    XORI_B4_128_SB(src0, src1, src2, src3);
-    src += (4 * src_stride);
-    HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
-                               mask3, filt0, filt1, filt2, filt3, out0, out1);
-    LD_SB4(src, src_stride, src0, src1, src2, src3);
-    XORI_B4_128_SB(src0, src1, src2, src3);
-    src += (4 * src_stride);
-    HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
-                               mask3, filt0, filt1, filt2, filt3, out2, out3);
-    SRARI_H4_SH(out0, out1, out2, out3, 7);
-    SAT_SH4_SH(out0, out1, out2, out3, 7);
-    out = PCKEV_XORI128_UB(out0, out1);
-    ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
-    dst += (4 * dst_stride);
-    out = PCKEV_XORI128_UB(out2, out3);
-    ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
-    dst += (4 * dst_stride);
-
-    LD_SB4(src, src_stride, src0, src1, src2, src3);
-    XORI_B4_128_SB(src0, src1, src2, src3);
-    src += (4 * src_stride);
-    HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
-                               mask3, filt0, filt1, filt2, filt3, out0, out1);
-    LD_SB4(src, src_stride, src0, src1, src2, src3);
-    XORI_B4_128_SB(src0, src1, src2, src3);
-    src += (4 * src_stride);
-    HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
-                               mask3, filt0, filt1, filt2, filt3, out2, out3);
-
-    SRARI_H4_SH(out0, out1, out2, out3, 7);
-    SAT_SH4_SH(out0, out1, out2, out3, 7);
-    out = PCKEV_XORI128_UB(out0, out1);
-    ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
-    dst += (4 * dst_stride);
-    out = PCKEV_XORI128_UB(out2, out3);
-    ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
-}
-
 static void common_hz_8t_4w_msa(const uint8_t *src, int32_t src_stride,
                                 uint8_t *dst, int32_t dst_stride,
                                 const int8_t *filter, int32_t height)
@@ -290,8 +231,6 @@ static void common_hz_8t_4w_msa(const uint8_t *src, int32_t src_stride,
         common_hz_8t_4x4_msa(src, src_stride, dst, dst_stride, filter);
     } else if (8 == height) {
         common_hz_8t_4x8_msa(src, src_stride, dst, dst_stride, filter);
-    } else if (16 == height) {
-        common_hz_8t_4x16_msa(src, src_stride, dst, dst_stride, filter);
     }
 }
 
@@ -1050,8 +989,9 @@ static void common_hz_8t_and_aver_dst_4x4_msa(const uint8_t *src,
                                               uint8_t *dst, int32_t dst_stride,
                                               const int8_t *filter)
 {
+    uint32_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
-    v16u8 dst0, dst1, dst2, dst3, res2, res3;
+    v16u8 dst0, res;
     v16u8 mask0, mask1, mask2, mask3;
     v8i16 filt, res0, res1;
 
@@ -1070,14 +1010,13 @@ static void common_hz_8t_and_aver_dst_4x4_msa(const uint8_t *src,
     XORI_B4_128_SB(src0, src1, src2, src3);
     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                mask3, filt0, filt1, filt2, filt3, res0, res1);
-    LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+    LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
     SRARI_H2_SH(res0, res1, 7);
     SAT_SH2_SH(res0, res1, 7);
-    PCKEV_B2_UB(res0, res0, res1, res1, res2, res3);
-    ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst2);
-    XORI_B2_128_UB(res2, res3);
-    AVER_UB2_UB(res2, dst0, res3, dst2, res2, res3);
-    ST4x4_UB(res2, res3, 0, 1, 0, 1, dst, dst_stride);
+    res = PCKEV_XORI128_UB(res0, res1);
+    res = (v16u8) __msa_aver_u_b(res, dst0);
+    ST4x4_UB(res, res, 0, 1, 2, 3, dst, dst_stride);
 }
 
 static void common_hz_8t_and_aver_dst_4x8_msa(const uint8_t *src,
@@ -1085,9 +1024,10 @@ static void common_hz_8t_and_aver_dst_4x8_msa(const uint8_t *src,
                                               uint8_t *dst, int32_t dst_stride,
                                               const int8_t *filter)
 {
+    uint32_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
     v16u8 mask0, mask1, mask2, mask3, res0, res1, res2, res3;
-    v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
+    v16u8 dst0, dst1;
     v8i16 filt, vec0, vec1, vec2, vec3;
 
     mask0 = LD_UB(&mc_filt_mask_arr[16]);
@@ -1104,7 +1044,10 @@ static void common_hz_8t_and_aver_dst_4x8_msa(const uint8_t *src,
     LD_SB4(src, src_stride, src0, src1, src2, src3);
     XORI_B4_128_SB(src0, src1, src2, src3);
     src += (4 * src_stride);
-    LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
+    LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
+    LW4(dst + 4 * dst_stride, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst1);
     HORIZ_8TAP_4WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                mask3, filt0, filt1, filt2, filt3, vec0, vec1);
     LD_SB4(src, src_stride, src0, src1, src2, src3);
@@ -1117,10 +1060,7 @@ static void common_hz_8t_and_aver_dst_4x8_msa(const uint8_t *src,
                 res0, res1, res2, res3);
     ILVR_D2_UB(res1, res0, res3, res2, res0, res2);
     XORI_B2_128_UB(res0, res2);
-    ILVR_W4_UB(dst1, dst0, dst3, dst2, dst5, dst4, dst7, dst6,
-               dst0, dst2, dst4, dst6);
-    ILVR_D2_UB(dst2, dst0, dst6, dst4, dst0, dst4);
-    AVER_UB2_UB(res0, dst0, res2, dst4, res0, res2);
+    AVER_UB2_UB(res0, dst0, res2, dst1, res0, res2);
     ST4x8_UB(res0, res2, dst, dst_stride);
 }
 
@@ -1146,8 +1086,9 @@ static void common_hz_8t_and_aver_dst_8w_msa(const uint8_t *src,
                                              int32_t height)
 {
     int32_t loop_cnt;
+    int64_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, filt0, filt1, filt2, filt3;
-    v16u8 mask0, mask1, mask2, mask3, dst0, dst1, dst2, dst3;
+    v16u8 mask0, mask1, mask2, mask3, dst0, dst1;
     v8i16 filt, out0, out1, out2, out3;
 
     mask0 = LD_UB(&mc_filt_mask_arr[0]);
@@ -1168,10 +1109,12 @@ static void common_hz_8t_and_aver_dst_8w_msa(const uint8_t *src,
         HORIZ_8TAP_8WID_4VECS_FILT(src0, src1, src2, src3, mask0, mask1, mask2,
                                    mask3, filt0, filt1, filt2, filt3, out0,
                                    out1, out2, out3);
-        LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+        LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, dst0);
+        INSERT_D2_UB(tp2, tp3, dst1);
         SRARI_H4_SH(out0, out1, out2, out3, 7);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
-        CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1, dst2, dst3,
+        CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1,
                                 dst, dst_stride);
         dst += (4 * dst_stride);
     }
@@ -1363,8 +1306,9 @@ static void common_vt_8t_and_aver_dst_4w_msa(const uint8_t *src,
                                              int32_t height)
 {
     uint32_t loop_cnt;
+    uint32_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
-    v16u8 dst0, dst1, dst2, dst3, out;
+    v16u8 dst0, out;
     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r, src21_r, src43_r;
     v16i8 src65_r, src87_r, src109_r, src2110, src4332, src6554, src8776;
     v16i8 src10998, filt0, filt1, filt2, filt3;
@@ -1389,7 +1333,8 @@ static void common_vt_8t_and_aver_dst_4w_msa(const uint8_t *src,
         LD_SB4(src, src_stride, src7, src8, src9, src10);
         src += (4 * src_stride);
 
-        LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+        LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_r,
                    src87_r, src98_r, src109_r);
         ILVR_D2_SB(src87_r, src76_r, src109_r, src98_r, src8776, src10998);
@@ -1401,9 +1346,6 @@ static void common_vt_8t_and_aver_dst_4w_msa(const uint8_t *src,
         SRARI_H2_SH(out10, out32, 7);
         SAT_SH2_SH(out10, out32, 7);
         out = PCKEV_XORI128_UB(out10, out32);
-        ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst2);
-
-        dst0 = (v16u8) __msa_ilvr_d((v2i64) dst2, (v2i64) dst0);
         out = __msa_aver_u_b(out, dst0);
 
         ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
@@ -1423,8 +1365,9 @@ static void common_vt_8t_and_aver_dst_8w_msa(const uint8_t *src,
                                              int32_t height)
 {
     uint32_t loop_cnt;
+    uint64_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
-    v16u8 dst0, dst1, dst2, dst3;
+    v16u8 dst0, dst1;
     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r, src21_r, src43_r;
     v16i8 src65_r, src87_r, src109_r, filt0, filt1, filt2, filt3;
     v8i16 filt, out0, out1, out2, out3;
@@ -1446,7 +1389,9 @@ static void common_vt_8t_and_aver_dst_8w_msa(const uint8_t *src,
         LD_SB4(src, src_stride, src7, src8, src9, src10);
         src += (4 * src_stride);
 
-        LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+        LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, dst0);
+        INSERT_D2_UB(tp2, tp3, dst1);
         XORI_B4_128_SB(src7, src8, src9, src10);
         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9, src76_r,
                    src87_r, src98_r, src109_r);
@@ -1460,7 +1405,7 @@ static void common_vt_8t_and_aver_dst_8w_msa(const uint8_t *src,
                                    filt1, filt2, filt3);
         SRARI_H4_SH(out0, out1, out2, out3, 7);
         SAT_SH4_SH(out0, out1, out2, out3, 7);
-        CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1, dst2, dst3,
+        CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1,
                                 dst, dst_stride);
         dst += (4 * dst_stride);
 
@@ -1610,8 +1555,9 @@ static void common_hv_8ht_8vt_and_aver_dst_4w_msa(const uint8_t *src,
                                                   int32_t height)
 {
     uint32_t loop_cnt;
+    uint32_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
-    v16u8 dst0, dst1, dst2, dst3, mask0, mask1, mask2, mask3, tmp0, tmp1;
+    v16u8 dst0, res, mask0, mask1, mask2, mask3;
     v16i8 filt_hz0, filt_hz1, filt_hz2, filt_hz3;
     v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
     v8i16 hz_out7, hz_out8, hz_out9, res0, res1, vec0, vec1, vec2, vec3, vec4;
@@ -1653,7 +1599,8 @@ static void common_hv_8ht_8vt_and_aver_dst_4w_msa(const uint8_t *src,
         XORI_B4_128_SB(src7, src8, src9, src10);
         src += (4 * src_stride);
 
-        LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+        LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
         hz_out7 = HORIZ_8TAP_FILT(src7, src8, mask0, mask1, mask2, mask3,
                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
         hz_out6 = (v8i16) __msa_sldi_b((v16i8) hz_out7, (v16i8) hz_out5, 8);
@@ -1667,14 +1614,12 @@ static void common_hv_8ht_8vt_and_aver_dst_4w_msa(const uint8_t *src,
         vec4 = (v8i16) __msa_ilvev_b((v16i8) hz_out9, (v16i8) hz_out8);
         res1 = FILT_8TAP_DPADD_S_H(vec1, vec2, vec3, vec4, filt_vt0, filt_vt1,
                                    filt_vt2, filt_vt3);
-        ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst2);
 
         SRARI_H2_SH(res0, res1, 7);
         SAT_SH2_SH(res0, res1, 7);
-        PCKEV_B2_UB(res0, res0, res1, res1, tmp0, tmp1);
-        XORI_B2_128_UB(tmp0, tmp1);
-        AVER_UB2_UB(tmp0, dst0, tmp1, dst2, tmp0, tmp1);
-        ST4x4_UB(tmp0, tmp1, 0, 1, 0, 1, dst, dst_stride);
+        res = PCKEV_XORI128_UB(res0, res1);
+        res = (v16u8) __msa_aver_u_b(res, dst0);
+        ST4x4_UB(res, res, 0, 1, 2, 3, dst, dst_stride);
         dst += (4 * dst_stride);
 
         hz_out5 = hz_out9;
@@ -1693,10 +1638,11 @@ static void common_hv_8ht_8vt_and_aver_dst_8w_msa(const uint8_t *src,
                                                   int32_t height)
 {
     uint32_t loop_cnt;
+    uint64_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
     v16i8 filt_hz0, filt_hz1, filt_hz2, filt_hz3;
     v8i16 filt, filt_vt0, filt_vt1, filt_vt2, filt_vt3;
-    v16u8 dst0, dst1, dst2, dst3, mask0, mask1, mask2, mask3;
+    v16u8 dst0, dst1, mask0, mask1, mask2, mask3;
     v8i16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
     v8i16 hz_out7, hz_out8, hz_out9, hz_out10, tmp0, tmp1, tmp2, tmp3;
     v8i16 out0, out1, out2, out3, out4, out5, out6, out7, out8, out9;
@@ -1743,7 +1689,9 @@ static void common_hv_8ht_8vt_and_aver_dst_8w_msa(const uint8_t *src,
         XORI_B4_128_SB(src7, src8, src9, src10);
         src += (4 * src_stride);
 
-        LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+        LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, dst0);
+        INSERT_D2_UB(tp2, tp3, dst1);
 
         hz_out7 = HORIZ_8TAP_FILT(src7, src7, mask0, mask1, mask2, mask3,
                                   filt_hz0, filt_hz1, filt_hz2, filt_hz3);
@@ -1771,7 +1719,7 @@ static void common_hv_8ht_8vt_and_aver_dst_8w_msa(const uint8_t *src,
 
         SRARI_H4_SH(tmp0, tmp1, tmp2, tmp3, 7);
         SAT_SH4_SH(tmp0, tmp1, tmp2, tmp3, 7);
-        CONVERT_UB_AVG_ST8x4_UB(tmp0, tmp1, tmp2, tmp3, dst0, dst1, dst2, dst3,
+        CONVERT_UB_AVG_ST8x4_UB(tmp0, tmp1, tmp2, tmp3, dst0, dst1,
                                 dst, dst_stride);
         dst += (4 * dst_stride);
 
@@ -2873,8 +2821,9 @@ static void common_hz_2t_and_aver_dst_4x4_msa(const uint8_t *src,
                                               uint8_t *dst, int32_t dst_stride,
                                               const int8_t *filter)
 {
+    uint32_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, mask;
-    v16u8 filt0, dst0, dst1, dst2, dst3, vec0, vec1, res0, res1;
+    v16u8 filt0, dst0, vec0, vec1, res;
     v8u16 vec2, vec3, filt;
 
     mask = LD_SB(&mc_filt_mask_arr[16]);
@@ -2884,14 +2833,16 @@ static void common_hz_2t_and_aver_dst_4x4_msa(const uint8_t *src,
     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
 
     LD_SB4(src, src_stride, src0, src1, src2, src3);
-    LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+    LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, vec0, vec1);
     DOTP_UB2_UH(vec0, vec1, filt0, filt0, vec2, vec3);
     SRARI_H2_UH(vec2, vec3, 7);
-    PCKEV_B2_UB(vec2, vec2, vec3, vec3, res0, res1);
-    ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst2);
-    AVER_UB2_UB(res0, dst0, res1, dst2, res0, res1);
-    ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
+
+    res = (v16u8) __msa_pckev_b((v16i8) vec3, (v16i8) vec2);
+    res = (v16u8) __msa_aver_u_b(res, dst0);
+
+    ST4x4_UB(res, res, 0, 1, 2, 3, dst, dst_stride);
 }
 
 static void common_hz_2t_and_aver_dst_4x8_msa(const uint8_t *src,
@@ -2899,9 +2850,10 @@ static void common_hz_2t_and_aver_dst_4x8_msa(const uint8_t *src,
                                               uint8_t *dst, int32_t dst_stride,
                                               const int8_t *filter)
 {
+    uint32_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, mask;
     v16u8 filt0, vec0, vec1, vec2, vec3, res0, res1, res2, res3;
-    v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
+    v16u8 dst0, dst1;
     v8u16 vec4, vec5, vec6, vec7, filt;
 
     mask = LD_SB(&mc_filt_mask_arr[16]);
@@ -2911,7 +2863,10 @@ static void common_hz_2t_and_aver_dst_4x8_msa(const uint8_t *src,
     filt0 = (v16u8) __msa_splati_h((v8i16) filt, 0);
 
     LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
-    LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
+    LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
+    LW4(dst + 4 * dst_stride, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst1);
     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, vec0, vec1);
     VSHF_B2_UB(src4, src5, src6, src7, mask, mask, vec2, vec3);
     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec4, vec5,
@@ -2919,13 +2874,9 @@ static void common_hz_2t_and_aver_dst_4x8_msa(const uint8_t *src,
     SRARI_H4_UH(vec4, vec5, vec6, vec7, 7);
     PCKEV_B4_UB(vec4, vec4, vec5, vec5, vec6, vec6, vec7, vec7, res0, res1,
                 res2, res3);
-    ILVR_W4_UB(dst1, dst0, dst3, dst2, dst5, dst4, dst7, dst6, dst0, dst2,
-               dst4, dst6);
-    AVER_UB4_UB(res0, dst0, res1, dst2, res2, dst4, res3, dst6, res0, res1,
-                res2, res3);
-    ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
-    dst += (4 * dst_stride);
-    ST4x4_UB(res2, res3, 0, 1, 0, 1, dst, dst_stride);
+    ILVR_D2_UB(res1, res0, res3, res2, res0, res2);
+    AVER_UB2_UB(res0, dst0, res2, dst1, res0, res2);
+    ST4x8_UB(res0, res2, dst, dst_stride);
 }
 
 void ff_avg_bilin_4h_msa(uint8_t *dst, ptrdiff_t dst_stride,
@@ -2948,8 +2899,9 @@ static void common_hz_2t_and_aver_dst_8x4_msa(const uint8_t *src,
                                               uint8_t *dst, int32_t dst_stride,
                                               const int8_t *filter)
 {
+    int64_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, mask;
-    v16u8 filt0, dst0, dst1, dst2, dst3;
+    v16u8 filt0, dst0, dst1;
     v8u16 vec0, vec1, vec2, vec3, filt;
 
     mask = LD_SB(&mc_filt_mask_arr[0]);
@@ -2964,9 +2916,10 @@ static void common_hz_2t_and_aver_dst_8x4_msa(const uint8_t *src,
     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
                 vec0, vec1, vec2, vec3);
     SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
-    LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-    PCKEV_AVG_ST8x4_UB(vec0, dst0, vec1, dst1, vec2, dst2, vec3, dst3,
-                       dst, dst_stride);
+    LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, dst0);
+    INSERT_D2_UB(tp2, tp3, dst1);
+    PCKEV_AVG_ST8x4_UB(vec0, vec1, vec2, vec3, dst0, dst1, dst, dst_stride);
 }
 
 static void common_hz_2t_and_aver_dst_8x8mult_msa(const uint8_t *src,
@@ -2976,8 +2929,9 @@ static void common_hz_2t_and_aver_dst_8x8mult_msa(const uint8_t *src,
                                                   const int8_t *filter,
                                                   int32_t height)
 {
+    int64_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, mask;
-    v16u8 filt0, dst0, dst1, dst2, dst3;
+    v16u8 filt0, dst0, dst1;
     v8u16 vec0, vec1, vec2, vec3, filt;
 
     mask = LD_SB(&mc_filt_mask_arr[0]);
@@ -2993,11 +2947,12 @@ static void common_hz_2t_and_aver_dst_8x8mult_msa(const uint8_t *src,
     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec0, vec1,
                 vec2, vec3);
     SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
-    LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+    LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, dst0);
+    INSERT_D2_UB(tp2, tp3, dst1);
     LD_SB4(src, src_stride, src0, src1, src2, src3);
     src += (4 * src_stride);
-    PCKEV_AVG_ST8x4_UB(vec0, dst0, vec1, dst1, vec2, dst2, vec3, dst3,
-                       dst, dst_stride);
+    PCKEV_AVG_ST8x4_UB(vec0, vec1, vec2, vec3, dst0, dst1, dst, dst_stride);
     dst += (4 * dst_stride);
 
     VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
@@ -3005,9 +2960,10 @@ static void common_hz_2t_and_aver_dst_8x8mult_msa(const uint8_t *src,
     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec0, vec1,
                 vec2, vec3);
     SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
-    LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-    PCKEV_AVG_ST8x4_UB(vec0, dst0, vec1, dst1, vec2, dst2, vec3, dst3,
-                       dst, dst_stride);
+    LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, dst0);
+    INSERT_D2_UB(tp2, tp3, dst1);
+    PCKEV_AVG_ST8x4_UB(vec0, vec1, vec2, vec3, dst0, dst1, dst, dst_stride);
     dst += (4 * dst_stride);
 
     if (16 == height) {
@@ -3019,10 +2975,11 @@ static void common_hz_2t_and_aver_dst_8x8mult_msa(const uint8_t *src,
         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec0,
                     vec1, vec2, vec3);
         SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
-        LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+        LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, dst0);
+        INSERT_D2_UB(tp2, tp3, dst1);
         LD_SB4(src, src_stride, src0, src1, src2, src3);
-        PCKEV_AVG_ST8x4_UB(vec0, dst0, vec1, dst1, vec2, dst2, vec3, dst3,
-                           dst, dst_stride);
+        PCKEV_AVG_ST8x4_UB(vec0, vec1, vec2, vec3, dst0, dst1, dst, dst_stride);
         dst += (4 * dst_stride);
 
         VSHF_B2_UH(src0, src0, src1, src1, mask, mask, vec0, vec1);
@@ -3030,9 +2987,10 @@ static void common_hz_2t_and_aver_dst_8x8mult_msa(const uint8_t *src,
         DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0, vec0,
                     vec1, vec2, vec3);
         SRARI_H4_UH(vec0, vec1, vec2, vec3, 7);
-        LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-        PCKEV_AVG_ST8x4_UB(vec0, dst0, vec1, dst1, vec2, dst2, vec3, dst3,
-                           dst, dst_stride);
+        LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, dst0);
+        INSERT_D2_UB(tp2, tp3, dst1);
+        PCKEV_AVG_ST8x4_UB(vec0, vec1, vec2, vec3, dst0, dst1, dst, dst_stride);
     }
 }
 
@@ -3216,8 +3174,9 @@ static void common_vt_2t_and_aver_dst_4x4_msa(const uint8_t *src,
                                               uint8_t *dst, int32_t dst_stride,
                                               const int8_t *filter)
 {
+    uint32_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, src4;
-    v16u8 dst0, dst1, dst2, dst3, out, filt0, src2110, src4332;
+    v16u8 dst0, out, filt0, src2110, src4332;
     v16i8 src10_r, src32_r, src21_r, src43_r;
     v8i16 filt;
     v8u16 tmp0, tmp1;
@@ -3231,9 +3190,8 @@ static void common_vt_2t_and_aver_dst_4x4_msa(const uint8_t *src,
     src4 = LD_SB(src);
     src += src_stride;
 
-    LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-    ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
-    dst0 = (v16u8) __msa_ilvr_d((v2i64) dst1, (v2i64) dst0);
+    LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
                src10_r, src21_r, src32_r, src43_r);
     ILVR_D2_UB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
@@ -3252,7 +3210,8 @@ static void common_vt_2t_and_aver_dst_4x8_msa(const uint8_t *src,
                                               uint8_t *dst, int32_t dst_stride,
                                               const int8_t *filter)
 {
-    v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
+    uint32_t tp0, tp1, tp2, tp3;
+    v16u8 dst0, dst1;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src87_r;
     v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
     v16u8 src2110, src4332, src6554, src8776, filt0;
@@ -3266,10 +3225,10 @@ static void common_vt_2t_and_aver_dst_4x8_msa(const uint8_t *src,
     src += (8 * src_stride);
     src8 = LD_SB(src);
 
-    LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
-    ILVR_W4_UB(dst1, dst0, dst3, dst2, dst5, dst4, dst7, dst6, dst0, dst1,
-               dst2, dst3);
-    ILVR_D2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
+    LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
+    LW4(dst + 4 * dst_stride, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst1);
     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3, src10_r, src21_r,
                src32_r, src43_r);
     ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7, src54_r, src65_r,
@@ -3282,9 +3241,7 @@ static void common_vt_2t_and_aver_dst_4x8_msa(const uint8_t *src,
     SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);
     PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, src2110, src4332);
     AVER_UB2_UB(src2110, dst0, src4332, dst1, src2110, src4332);
-    ST4x4_UB(src2110, src2110, 0, 1, 2, 3, dst, dst_stride);
-    dst += (4 * dst_stride);
-    ST4x4_UB(src4332, src4332, 0, 1, 2, 3, dst, dst_stride);
+    ST4x8_UB(src2110, src4332, dst, dst_stride);
 }
 
 void ff_avg_bilin_4v_msa(uint8_t *dst, ptrdiff_t dst_stride,
@@ -3308,8 +3265,9 @@ static void common_vt_2t_and_aver_dst_8x4_msa(const uint8_t *src,
                                               int32_t dst_stride,
                                               const int8_t *filter)
 {
+    int64_t tp0, tp1, tp2, tp3;
     v16u8 src0, src1, src2, src3, src4;
-    v16u8 dst0, dst1, dst2, dst3, vec0, vec1, vec2, vec3, filt0;
+    v16u8 dst0, dst1, vec0, vec1, vec2, vec3, filt0;
     v8u16 tmp0, tmp1, tmp2, tmp3;
     v8i16 filt;
 
@@ -3318,15 +3276,16 @@ static void common_vt_2t_and_aver_dst_8x4_msa(const uint8_t *src,
     filt0 = (v16u8) __msa_splati_h(filt, 0);
 
     LD_UB5(src, src_stride, src0, src1, src2, src3, src4);
-    LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+    LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, dst0);
+    INSERT_D2_UB(tp2, tp3, dst1);
     ILVR_B2_UB(src1, src0, src2, src1, vec0, vec1);
     ILVR_B2_UB(src3, src2, src4, src3, vec2, vec3);
     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt0, filt0, filt0, filt0,
                 tmp0, tmp1, tmp2, tmp3);
     SRARI_H4_UH(tmp0, tmp1, tmp2, tmp3, 7);
     SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);
-    PCKEV_AVG_ST8x4_UB(tmp0, dst0, tmp1, dst1, tmp2, dst2, tmp3, dst3,
-                       dst, dst_stride);
+    PCKEV_AVG_ST8x4_UB(tmp0, tmp1, tmp2, tmp3, dst0, dst1, dst, dst_stride);
 }
 
 static void common_vt_2t_and_aver_dst_8x8mult_msa(const uint8_t *src,
@@ -3337,8 +3296,9 @@ static void common_vt_2t_and_aver_dst_8x8mult_msa(const uint8_t *src,
                                                   int32_t height)
 {
     uint32_t loop_cnt;
+    int64_t tp0, tp1, tp2, tp3;
     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
-    v16u8 dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8;
+    v16u8 dst0, dst1, dst2, dst3;
     v16u8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, filt0;
     v8u16 tmp0, tmp1, tmp2, tmp3;
     v8i16 filt;
@@ -3353,7 +3313,13 @@ static void common_vt_2t_and_aver_dst_8x8mult_msa(const uint8_t *src,
     for (loop_cnt = (height >> 3); loop_cnt--;) {
         LD_UB8(src, src_stride, src1, src2, src3, src4, src5, src6, src7, src8);
         src += (8 * src_stride);
-        LD_UB8(dst, dst_stride, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8);
+
+        LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, dst0);
+        INSERT_D2_UB(tp2, tp3, dst1);
+        LD4(dst + 4 * dst_stride, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, dst2);
+        INSERT_D2_UB(tp2, tp3, dst3);
 
         ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3,
                    vec0, vec1, vec2, vec3);
@@ -3363,16 +3329,14 @@ static void common_vt_2t_and_aver_dst_8x8mult_msa(const uint8_t *src,
                     tmp0, tmp1, tmp2, tmp3);
         SRARI_H4_UH(tmp0, tmp1, tmp2, tmp3, 7);
         SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);
-        PCKEV_AVG_ST8x4_UB(tmp0, dst1, tmp1, dst2, tmp2, dst3, tmp3,
-                           dst4, dst, dst_stride);
+        PCKEV_AVG_ST8x4_UB(tmp0, tmp1, tmp2, tmp3, dst0, dst1, dst, dst_stride);
         dst += (4 * dst_stride);
 
         DOTP_UB4_UH(vec4, vec5, vec6, vec7, filt0, filt0, filt0, filt0,
                     tmp0, tmp1, tmp2, tmp3);
         SRARI_H4_UH(tmp0, tmp1, tmp2, tmp3, 7);
         SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);
-        PCKEV_AVG_ST8x4_UB(tmp0, dst5, tmp1, dst6, tmp2, dst7, tmp3,
-                           dst8, dst, dst_stride);
+        PCKEV_AVG_ST8x4_UB(tmp0, tmp1, tmp2, tmp3, dst2, dst3, dst, dst_stride);
         dst += (4 * dst_stride);
 
         src0 = src8;
@@ -3622,9 +3586,10 @@ static void common_hv_2ht_2vt_and_aver_dst_4x4_msa(const uint8_t *src,
                                                    const int8_t *filter_horiz,
                                                    const int8_t *filter_vert)
 {
+    uint32_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, src4, mask;
     v16u8 filt_hz, filt_vt, vec0, vec1;
-    v16u8 dst0, dst1, dst2, dst3, res0, res1;
+    v16u8 dst0, out;
     v8u16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, tmp0, tmp1, filt;
 
     mask = LD_SB(&mc_filt_mask_arr[16]);
@@ -3645,14 +3610,17 @@ static void common_hv_2ht_2vt_and_aver_dst_4x4_msa(const uint8_t *src,
     hz_out3 = (v8u16) __msa_pckod_d((v2i64) hz_out4, (v2i64) hz_out2);
     ILVEV_B2_UB(hz_out0, hz_out1, hz_out2, hz_out3, vec0, vec1);
 
-    LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-    ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst2);
+    LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
+
     DOTP_UB2_UH(vec0, vec1, filt_vt, filt_vt, tmp0, tmp1);
     SRARI_H2_UH(tmp0, tmp1, 7);
     SAT_UH2_UH(tmp0, tmp1, 7);
-    PCKEV_B2_UB(tmp0, tmp0, tmp1, tmp1, res0, res1);
-    AVER_UB2_UB(res0, dst0, res1, dst2, res0, res1);
-    ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
+
+    out = (v16u8) __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
+    out = __msa_aver_u_b(out, dst0);
+
+    ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
 }
 
 static void common_hv_2ht_2vt_and_aver_dst_4x8_msa(const uint8_t *src,
@@ -3662,9 +3630,10 @@ static void common_hv_2ht_2vt_and_aver_dst_4x8_msa(const uint8_t *src,
                                                    const int8_t *filter_horiz,
                                                    const int8_t *filter_vert)
 {
+    uint32_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, mask;
-    v16u8 filt_hz, filt_vt, vec0, vec1, vec2, vec3, res0, res1, res2, res3;
-    v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
+    v16u8 filt_hz, filt_vt, vec0, vec1, vec2, vec3, res0, res1;
+    v16u8 dst0, dst1;
     v8u16 hz_out0, hz_out1, hz_out2, hz_out3, hz_out4, hz_out5, hz_out6;
     v8u16 hz_out7, hz_out8, tmp0, tmp1, tmp2, tmp3;
     v8i16 filt;
@@ -3691,22 +3660,19 @@ static void common_hv_2ht_2vt_and_aver_dst_4x8_msa(const uint8_t *src,
                hz_out3, hz_out5, 8);
     hz_out7 = (v8u16) __msa_pckod_d((v2i64) hz_out8, (v2i64) hz_out6);
 
-    LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
-    ILVR_W4_UB(dst1, dst0, dst3, dst2, dst5, dst4, dst7, dst6, dst0, dst2,
-               dst4, dst6);
+    LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
+    LW4(dst + 4 * dst_stride, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_W4_UB(tp0, tp1, tp2, tp3, dst1);
     ILVEV_B2_UB(hz_out0, hz_out1, hz_out2, hz_out3, vec0, vec1);
     ILVEV_B2_UB(hz_out4, hz_out5, hz_out6, hz_out7, vec2, vec3);
     DOTP_UB4_UH(vec0, vec1, vec2, vec3, filt_vt, filt_vt, filt_vt, filt_vt,
                 tmp0, tmp1, tmp2, tmp3);
     SRARI_H4_UH(tmp0, tmp1, tmp2, tmp3, 7);
     SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);
-    PCKEV_B4_UB(tmp0, tmp0, tmp1, tmp1, tmp2, tmp2, tmp3, tmp3, res0, res1,
-                res2, res3);
-    AVER_UB4_UB(res0, dst0, res1, dst2, res2, dst4, res3, dst6, res0, res1,
-                res2, res3);
-    ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
-    dst += (4 * dst_stride);
-    ST4x4_UB(res2, res3, 0, 1, 0, 1, dst, dst_stride);
+    PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, res0, res1);
+    AVER_UB2_UB(res0, dst0, res1, dst1, res0, res1);
+    ST4x8_UB(res0, res1, dst, dst_stride);
 }
 
 void ff_avg_bilin_4hv_msa(uint8_t *dst, ptrdiff_t dst_stride,
@@ -3732,8 +3698,9 @@ static void common_hv_2ht_2vt_and_aver_dst_8x4_msa(const uint8_t *src,
                                                    const int8_t *filter_horiz,
                                                    const int8_t *filter_vert)
 {
+    uint64_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, src4, mask;
-    v16u8 filt_hz, filt_vt, dst0, dst1, dst2, dst3, vec0, vec1, vec2, vec3;
+    v16u8 filt_hz, filt_vt, dst0, dst1, vec0, vec1, vec2, vec3;
     v8u16 hz_out0, hz_out1, tmp0, tmp1, tmp2, tmp3;
     v8i16 filt;
 
@@ -3749,7 +3716,9 @@ static void common_hv_2ht_2vt_and_aver_dst_8x4_msa(const uint8_t *src,
     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
     src += (5 * src_stride);
 
-    LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+    LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+    INSERT_D2_UB(tp0, tp1, dst0);
+    INSERT_D2_UB(tp2, tp3, dst1);
     hz_out0 = HORIZ_2TAP_FILT_UH(src0, src0, mask, filt_hz, 7);
     hz_out1 = HORIZ_2TAP_FILT_UH(src1, src1, mask, filt_hz, 7);
     vec0 = (v16u8) __msa_ilvev_b((v16i8) hz_out1, (v16i8) hz_out0);
@@ -3769,8 +3738,7 @@ static void common_hv_2ht_2vt_and_aver_dst_8x4_msa(const uint8_t *src,
 
     SRARI_H4_UH(tmp0, tmp1, tmp2, tmp3, 7);
     SAT_UH4_UH(tmp0, tmp1, tmp2, tmp3, 7);
-    PCKEV_AVG_ST8x4_UB(tmp0, dst0, tmp1, dst1, tmp2, dst2, tmp3, dst3,
-                       dst, dst_stride);
+    PCKEV_AVG_ST8x4_UB(tmp0, tmp1, tmp2, tmp3, dst0, dst1, dst, dst_stride);
 }
 
 static void common_hv_2ht_2vt_and_aver_dst_8x8mult_msa(const uint8_t *src,
@@ -3782,8 +3750,9 @@ static void common_hv_2ht_2vt_and_aver_dst_8x8mult_msa(const uint8_t *src,
                                                        int32_t height)
 {
     uint32_t loop_cnt;
+    uint64_t tp0, tp1, tp2, tp3;
     v16i8 src0, src1, src2, src3, src4, mask;
-    v16u8 filt_hz, filt_vt, vec0, dst0, dst1, dst2, dst3;
+    v16u8 filt_hz, filt_vt, vec0, dst0, dst1;
     v8u16 hz_out0, hz_out1, tmp0, tmp1, tmp2, tmp3;
     v8i16 filt;
 
@@ -3826,9 +3795,10 @@ static void common_hv_2ht_2vt_and_aver_dst_8x8mult_msa(const uint8_t *src,
 
         SRARI_H2_UH(tmp2, tmp3, 7);
         SAT_UH2_UH(tmp2, tmp3, 7);
-        LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-        PCKEV_AVG_ST8x4_UB(tmp0, dst0, tmp1, dst1, tmp2, dst2, tmp3,
-                           dst3, dst, dst_stride);
+        LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, dst0);
+        INSERT_D2_UB(tp2, tp3, dst1);
+        PCKEV_AVG_ST8x4_UB(tmp0, tmp1, tmp2, tmp3, dst0, dst1, dst, dst_stride);
         dst += (4 * dst_stride);
     }
 }
@@ -3956,53 +3926,13 @@ static void copy_width8_msa(const uint8_t *src, int32_t src_stride,
 {
     int32_t cnt;
     uint64_t out0, out1, out2, out3, out4, out5, out6, out7;
-    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
-
-    if (0 == height % 12) {
-        for (cnt = (height / 12); cnt--;) {
-            LD_UB8(src, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src += (8 * src_stride);
-
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
-            out4 = __msa_copy_u_d((v2i64) src4, 0);
-            out5 = __msa_copy_u_d((v2i64) src5, 0);
-            out6 = __msa_copy_u_d((v2i64) src6, 0);
-            out7 = __msa_copy_u_d((v2i64) src7, 0);
-
-            SD4(out0, out1, out2, out3, dst, dst_stride);
-            dst += (4 * dst_stride);
-            SD4(out4, out5, out6, out7, dst, dst_stride);
-            dst += (4 * dst_stride);
-
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            src += (4 * src_stride);
-
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
 
-            SD4(out0, out1, out2, out3, dst, dst_stride);
-            dst += (4 * dst_stride);
-        }
-    } else if (0 == height % 8) {
+    if (0 == height % 8) {
         for (cnt = height >> 3; cnt--;) {
-            LD_UB8(src, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src += (8 * src_stride);
-
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
-            out4 = __msa_copy_u_d((v2i64) src4, 0);
-            out5 = __msa_copy_u_d((v2i64) src5, 0);
-            out6 = __msa_copy_u_d((v2i64) src6, 0);
-            out7 = __msa_copy_u_d((v2i64) src7, 0);
+            LD4(src, src_stride, out0, out1, out2, out3);
+            src += (4 * src_stride);
+            LD4(src, src_stride, out4, out5, out6, out7);
+            src += (4 * src_stride);
 
             SD4(out0, out1, out2, out3, dst, dst_stride);
             dst += (4 * dst_stride);
@@ -4011,56 +3941,12 @@ static void copy_width8_msa(const uint8_t *src, int32_t src_stride,
         }
     } else if (0 == height % 4) {
         for (cnt = (height / 4); cnt--;) {
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
+            LD4(src, src_stride, out0, out1, out2, out3);
             src += (4 * src_stride);
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-            out2 = __msa_copy_u_d((v2i64) src2, 0);
-            out3 = __msa_copy_u_d((v2i64) src3, 0);
 
             SD4(out0, out1, out2, out3, dst, dst_stride);
             dst += (4 * dst_stride);
         }
-    } else if (0 == height % 2) {
-        for (cnt = (height / 2); cnt--;) {
-            LD_UB2(src, src_stride, src0, src1);
-            src += (2 * src_stride);
-            out0 = __msa_copy_u_d((v2i64) src0, 0);
-            out1 = __msa_copy_u_d((v2i64) src1, 0);
-
-            SD(out0, dst);
-            dst += dst_stride;
-            SD(out1, dst);
-            dst += dst_stride;
-        }
-    }
-}
-
-static void copy_16multx8mult_msa(const uint8_t *src, int32_t src_stride,
-                                  uint8_t *dst, int32_t dst_stride,
-                                  int32_t height, int32_t width)
-{
-    int32_t cnt, loop_cnt;
-    const uint8_t *src_tmp;
-    uint8_t *dst_tmp;
-    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
-
-    for (cnt = (width >> 4); cnt--;) {
-        src_tmp = src;
-        dst_tmp = dst;
-
-        for (loop_cnt = (height >> 3); loop_cnt--;) {
-            LD_UB8(src_tmp, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src_tmp += (8 * src_stride);
-
-            ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,
-                   dst_tmp, dst_stride);
-            dst_tmp += (8 * dst_stride);
-        }
-
-        src += 16;
-        dst += 16;
     }
 }
 
@@ -4071,27 +3957,37 @@ static void copy_width16_msa(const uint8_t *src, int32_t src_stride,
     int32_t cnt;
     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
 
-    if (0 == height % 12) {
-        for (cnt = (height / 12); cnt--;) {
-            LD_UB8(src, src_stride,
-                   src0, src1, src2, src3, src4, src5, src6, src7);
-            src += (8 * src_stride);
-            ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,
-                   dst, dst_stride);
-            dst += (8 * dst_stride);
-
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            src += (4 * src_stride);
-            ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-            dst += (4 * dst_stride);
-        }
-    } else if (0 == height % 8) {
-        copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 16);
+    if (8 == height) {
+        LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
+        ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
+    } else if (16 == height) {
+        LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
+        src += (8 * src_stride);
+        ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
+        dst += (8 * dst_stride);
+        LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
+        src += (8 * src_stride);
+        ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
+        dst += (8 * dst_stride);
+    } else if (32 == height) {
+        LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
+        src += (8 * src_stride);
+        ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
+        dst += (8 * dst_stride);
+        LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
+        src += (8 * src_stride);
+        ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
+        dst += (8 * dst_stride);
+        LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
+        src += (8 * src_stride);
+        ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
+        dst += (8 * dst_stride);
+        LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
+        ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
     } else if (0 == height % 4) {
         for (cnt = (height >> 2); cnt--;) {
             LD_UB4(src, src_stride, src0, src1, src2, src3);
             src += (4 * src_stride);
-
             ST_UB4(src0, src1, src2, src3, dst, dst_stride);
             dst += (4 * dst_stride);
         }
@@ -4105,31 +4001,17 @@ static void copy_width32_msa(const uint8_t *src, int32_t src_stride,
     int32_t cnt;
     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
 
-    if (0 == height % 12) {
-        for (cnt = (height / 12); cnt--;) {
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            LD_UB4(src + 16, src_stride, src4, src5, src6, src7);
-            src += (4 * src_stride);
-            ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-            ST_UB4(src4, src5, src6, src7, dst + 16, dst_stride);
-            dst += (4 * dst_stride);
-
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            LD_UB4(src + 16, src_stride, src4, src5, src6, src7);
-            src += (4 * src_stride);
-            ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-            ST_UB4(src4, src5, src6, src7, dst + 16, dst_stride);
-            dst += (4 * dst_stride);
-
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            LD_UB4(src + 16, src_stride, src4, src5, src6, src7);
-            src += (4 * src_stride);
-            ST_UB4(src0, src1, src2, src3, dst, dst_stride);
-            ST_UB4(src4, src5, src6, src7, dst + 16, dst_stride);
-            dst += (4 * dst_stride);
+    if (0 == height % 8) {
+        for (cnt = (height >> 3); cnt--;) {
+            LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
+            ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst, dst_stride);
+            LD_UB8(src + 16, src_stride, src0, src1, src2, src3, src4, src5, src6,
+                   src7);
+            src += (8 * src_stride);
+            ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7, dst + 16,
+                   dst_stride);
+            dst += (8 * dst_stride);
         }
-    } else if (0 == height % 8) {
-        copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 32);
     } else if (0 == height % 4) {
         for (cnt = (height >> 2); cnt--;) {
             LD_UB4(src, src_stride, src0, src1, src2, src3);
@@ -4146,51 +4028,57 @@ static void copy_width64_msa(const uint8_t *src, int32_t src_stride,
                              uint8_t *dst, int32_t dst_stride,
                              int32_t height)
 {
-    copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 64);
+    int32_t cnt;
+    v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
+    v16u8 src8, src9, src10, src11, src12, src13, src14, src15;
+
+    for (cnt = (height >> 2); cnt--;) {
+        LD_UB4(src, 16, src0, src1, src2, src3);
+        src += src_stride;
+        LD_UB4(src, 16, src4, src5, src6, src7);
+        src += src_stride;
+        LD_UB4(src, 16, src8, src9, src10, src11);
+        src += src_stride;
+        LD_UB4(src, 16, src12, src13, src14, src15);
+        src += src_stride;
+
+        ST_UB4(src0, src1, src2, src3, dst, 16);
+        dst += dst_stride;
+        ST_UB4(src4, src5, src6, src7, dst, 16);
+        dst += dst_stride;
+        ST_UB4(src8, src9, src10, src11, dst, 16);
+        dst += dst_stride;
+        ST_UB4(src12, src13, src14, src15, dst, 16);
+        dst += dst_stride;
+    }
 }
 
 static void avg_width4_msa(const uint8_t *src, int32_t src_stride,
                            uint8_t *dst, int32_t dst_stride,
                            int32_t height)
 {
-    int32_t cnt;
-    uint32_t out0, out1, out2, out3;
-    v16u8 src0, src1, src2, src3;
-    v16u8 dst0, dst1, dst2, dst3;
-
-    if (0 == (height % 4)) {
-        for (cnt = (height / 4); cnt--;) {
-            LD_UB4(src, src_stride, src0, src1, src2, src3);
-            src += (4 * src_stride);
-
-            LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-
-            AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
-                        dst0, dst1, dst2, dst3);
-
-            out0 = __msa_copy_u_w((v4i32) dst0, 0);
-            out1 = __msa_copy_u_w((v4i32) dst1, 0);
-            out2 = __msa_copy_u_w((v4i32) dst2, 0);
-            out3 = __msa_copy_u_w((v4i32) dst3, 0);
-            SW4(out0, out1, out2, out3, dst, dst_stride);
-            dst += (4 * dst_stride);
-        }
-    } else if (0 == (height % 2)) {
-        for (cnt = (height / 2); cnt--;) {
-            LD_UB2(src, src_stride, src0, src1);
-            src += (2 * src_stride);
-
-            LD_UB2(dst, dst_stride, dst0, dst1);
-
-            AVER_UB2_UB(src0, dst0, src1, dst1, dst0, dst1);
-
-            out0 = __msa_copy_u_w((v4i32) dst0, 0);
-            out1 = __msa_copy_u_w((v4i32) dst1, 0);
-            SW(out0, dst);
-            dst += dst_stride;
-            SW(out1, dst);
-            dst += dst_stride;
-        }
+    uint32_t tp0, tp1, tp2, tp3;
+    v16u8 src0 = { 0 }, src1 = { 0 }, dst0 = { 0 }, dst1 = { 0 };
+
+    if (8 == height) {
+        LW4(src, src_stride, tp0, tp1, tp2, tp3);
+        src += 4 * src_stride;
+        INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
+        LW4(src, src_stride, tp0, tp1, tp2, tp3);
+        INSERT_W4_UB(tp0, tp1, tp2, tp3, src1);
+        LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
+        LW4(dst + 4 * dst_stride, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_W4_UB(tp0, tp1, tp2, tp3, dst1);
+        AVER_UB2_UB(src0, dst0, src1, dst1, dst0, dst1);
+        ST4x8_UB(dst0, dst1, dst, dst_stride);
+    } else if (4 == height) {
+        LW4(src, src_stride, tp0, tp1, tp2, tp3);
+        INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
+        LW4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
+        dst0 = __msa_aver_u_b(src0, dst0);
+        ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, dst_stride);
     }
 }
 
@@ -4199,24 +4087,40 @@ static void avg_width8_msa(const uint8_t *src, int32_t src_stride,
                            int32_t height)
 {
     int32_t cnt;
-    uint64_t out0, out1, out2, out3;
+    uint64_t tp0, tp1, tp2, tp3, tp4, tp5, tp6, tp7;
     v16u8 src0, src1, src2, src3;
     v16u8 dst0, dst1, dst2, dst3;
 
-    for (cnt = (height / 4); cnt--;) {
-        LD_UB4(src, src_stride, src0, src1, src2, src3);
-        src += (4 * src_stride);
-        LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
-
-        AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
-                    dst0, dst1, dst2, dst3);
-
-        out0 = __msa_copy_u_d((v2i64) dst0, 0);
-        out1 = __msa_copy_u_d((v2i64) dst1, 0);
-        out2 = __msa_copy_u_d((v2i64) dst2, 0);
-        out3 = __msa_copy_u_d((v2i64) dst3, 0);
-        SD4(out0, out1, out2, out3, dst, dst_stride);
-        dst += (4 * dst_stride);
+    if (0 == (height % 8)) {
+        for (cnt = (height >> 3); cnt--;) {
+            LD4(src, src_stride, tp0, tp1, tp2, tp3);
+            src += 4 * src_stride;
+            LD4(src, src_stride, tp4, tp5, tp6, tp7);
+            src += 4 * src_stride;
+            INSERT_D2_UB(tp0, tp1, src0);
+            INSERT_D2_UB(tp2, tp3, src1);
+            INSERT_D2_UB(tp4, tp5, src2);
+            INSERT_D2_UB(tp6, tp7, src3);
+            LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+            LD4(dst + 4 * dst_stride, dst_stride, tp4, tp5, tp6, tp7);
+            INSERT_D2_UB(tp0, tp1, dst0);
+            INSERT_D2_UB(tp2, tp3, dst1);
+            INSERT_D2_UB(tp4, tp5, dst2);
+            INSERT_D2_UB(tp6, tp7, dst3);
+            AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3, dst0,
+                        dst1, dst2, dst3);
+            ST8x8_UB(dst0, dst1, dst2, dst3, dst, dst_stride);
+            dst += 8 * dst_stride;
+        }
+    } else if (4 == height) {
+        LD4(src, src_stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, src0);
+        INSERT_D2_UB(tp2, tp3, src1);
+        LD4(dst, dst_stride, tp0, tp1, tp2, tp3);
+        INSERT_D2_UB(tp0, tp1, dst0);
+        INSERT_D2_UB(tp2, tp3, dst1);
+        AVER_UB2_UB(src0, dst0, src1, dst1, dst0, dst1);
+        ST8x4_UB(dst0, dst1, dst, dst_stride);
     }
 }
 
@@ -4228,17 +4132,30 @@ static void avg_width16_msa(const uint8_t *src, int32_t src_stride,
     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
 
-    for (cnt = (height / 8); cnt--;) {
-        LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
-        src += (8 * src_stride);
-        LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
+    if (0 == (height % 8)) {
+        for (cnt = (height / 8); cnt--;) {
+            LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
+            src += (8 * src_stride);
+            LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
 
-        AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
-                    dst0, dst1, dst2, dst3);
-        AVER_UB4_UB(src4, dst4, src5, dst5, src6, dst6, src7, dst7,
-                    dst4, dst5, dst6, dst7);
-        ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, dst_stride);
-        dst += (8 * dst_stride);
+            AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
+                        dst0, dst1, dst2, dst3);
+            AVER_UB4_UB(src4, dst4, src5, dst5, src6, dst6, src7, dst7,
+                        dst4, dst5, dst6, dst7);
+            ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, dst_stride);
+            dst += (8 * dst_stride);
+        }
+    } else if (0 == (height % 4)) {
+        for (cnt = (height / 4); cnt--;) {
+            LD_UB4(src, src_stride, src0, src1, src2, src3);
+            src += (4 * src_stride);
+            LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
+
+            AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
+                        dst0, dst1, dst2, dst3);
+            ST_UB4(dst0, dst1, dst2, dst3, dst, dst_stride);
+            dst += (4 * dst_stride);
+        }
     }
 }
 
@@ -4253,35 +4170,55 @@ static void avg_width32_msa(const uint8_t *src, int32_t src_stride,
     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
     v16u8 dst8, dst9, dst10, dst11, dst12, dst13, dst14, dst15;
 
-    for (cnt = (height / 8); cnt--;) {
-        LD_UB4(src, src_stride, src0, src2, src4, src6);
-        LD_UB4(src + 16, src_stride, src1, src3, src5, src7);
-        src += (4 * src_stride);
-        LD_UB4(dst_dup, dst_stride, dst0, dst2, dst4, dst6);
-        LD_UB4(dst_dup + 16, dst_stride, dst1, dst3, dst5, dst7);
-        dst_dup += (4 * dst_stride);
-        LD_UB4(src, src_stride, src8, src10, src12, src14);
-        LD_UB4(src + 16, src_stride, src9, src11, src13, src15);
-        src += (4 * src_stride);
-        LD_UB4(dst_dup, dst_stride, dst8, dst10, dst12, dst14);
-        LD_UB4(dst_dup + 16, dst_stride, dst9, dst11, dst13, dst15);
-        dst_dup += (4 * dst_stride);
+    if (0 == (height % 8)) {
+        for (cnt = (height / 8); cnt--;) {
+            LD_UB4(src, src_stride, src0, src2, src4, src6);
+            LD_UB4(src + 16, src_stride, src1, src3, src5, src7);
+            src += (4 * src_stride);
+            LD_UB4(dst_dup, dst_stride, dst0, dst2, dst4, dst6);
+            LD_UB4(dst_dup + 16, dst_stride, dst1, dst3, dst5, dst7);
+            dst_dup += (4 * dst_stride);
+            LD_UB4(src, src_stride, src8, src10, src12, src14);
+            LD_UB4(src + 16, src_stride, src9, src11, src13, src15);
+            src += (4 * src_stride);
+            LD_UB4(dst_dup, dst_stride, dst8, dst10, dst12, dst14);
+            LD_UB4(dst_dup + 16, dst_stride, dst9, dst11, dst13, dst15);
+            dst_dup += (4 * dst_stride);
 
-        AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
-                    dst0, dst1, dst2, dst3);
-        AVER_UB4_UB(src4, dst4, src5, dst5, src6, dst6, src7, dst7,
-                    dst4, dst5, dst6, dst7);
-        AVER_UB4_UB(src8, dst8, src9, dst9, src10, dst10, src11, dst11,
-                    dst8, dst9, dst10, dst11);
-        AVER_UB4_UB(src12, dst12, src13, dst13, src14, dst14, src15, dst15,
-                    dst12, dst13, dst14, dst15);
+            AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
+                        dst0, dst1, dst2, dst3);
+            AVER_UB4_UB(src4, dst4, src5, dst5, src6, dst6, src7, dst7,
+                        dst4, dst5, dst6, dst7);
+            AVER_UB4_UB(src8, dst8, src9, dst9, src10, dst10, src11, dst11,
+                        dst8, dst9, dst10, dst11);
+            AVER_UB4_UB(src12, dst12, src13, dst13, src14, dst14, src15, dst15,
+                        dst12, dst13, dst14, dst15);
+
+            ST_UB4(dst0, dst2, dst4, dst6, dst, dst_stride);
+            ST_UB4(dst1, dst3, dst5, dst7, dst + 16, dst_stride);
+            dst += (4 * dst_stride);
+            ST_UB4(dst8, dst10, dst12, dst14, dst, dst_stride);
+            ST_UB4(dst9, dst11, dst13, dst15, dst + 16, dst_stride);
+            dst += (4 * dst_stride);
+        }
+    } else if (0 == (height % 4)) {
+        for (cnt = (height / 4); cnt--;) {
+            LD_UB4(src, src_stride, src0, src2, src4, src6);
+            LD_UB4(src + 16, src_stride, src1, src3, src5, src7);
+            src += (4 * src_stride);
+            LD_UB4(dst_dup, dst_stride, dst0, dst2, dst4, dst6);
+            LD_UB4(dst_dup + 16, dst_stride, dst1, dst3, dst5, dst7);
+            dst_dup += (4 * dst_stride);
 
-        ST_UB4(dst0, dst2, dst4, dst6, dst, dst_stride);
-        ST_UB4(dst1, dst3, dst5, dst7, dst + 16, dst_stride);
-        dst += (4 * dst_stride);
-        ST_UB4(dst8, dst10, dst12, dst14, dst, dst_stride);
-        ST_UB4(dst9, dst11, dst13, dst15, dst + 16, dst_stride);
-        dst += (4 * dst_stride);
+            AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
+                        dst0, dst1, dst2, dst3);
+            AVER_UB4_UB(src4, dst4, src5, dst5, src6, dst6, src7, dst7,
+                        dst4, dst5, dst6, dst7);
+
+            ST_UB4(dst0, dst2, dst4, dst6, dst, dst_stride);
+            ST_UB4(dst1, dst3, dst5, dst7, dst + 16, dst_stride);
+            dst += (4 * dst_stride);
+        }
     }
 }
 
@@ -4413,8 +4350,8 @@ void ff_put_8tap_##type##_##SIZE##hv_msa(uint8_t *dst, ptrdiff_t dststride,    \
                                          ptrdiff_t srcstride,                  \
                                          int h, int mx, int my)                \
 {                                                                              \
-    const uint8_t *hfilter = vp9_subpel_filters_msa[type_idx][mx-1];           \
-    const uint8_t *vfilter = vp9_subpel_filters_msa[type_idx][my-1];           \
+    const int8_t *hfilter = vp9_subpel_filters_msa[type_idx][mx-1];            \
+    const int8_t *vfilter = vp9_subpel_filters_msa[type_idx][my-1];            \
                                                                                \
     common_hv_8ht_8vt_##SIZE##w_msa(src, srcstride, dst, dststride, hfilter,   \
                                     vfilter, h);                               \
@@ -4447,8 +4384,8 @@ void ff_avg_8tap_##type##_##SIZE##hv_msa(uint8_t *dst, ptrdiff_t dststride,    \
                                          ptrdiff_t srcstride,                  \
                                          int h, int mx, int my)                \
 {                                                                              \
-    const uint8_t *hfilter = vp9_subpel_filters_msa[type_idx][mx-1];           \
-    const uint8_t *vfilter = vp9_subpel_filters_msa[type_idx][my-1];           \
+    const int8_t *hfilter = vp9_subpel_filters_msa[type_idx][mx-1];            \
+    const int8_t *vfilter = vp9_subpel_filters_msa[type_idx][my-1];            \
                                                                                \
     common_hv_8ht_8vt_and_aver_dst_##SIZE##w_msa(src, srcstride, dst,          \
                                                  dststride, hfilter,           \
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/wmv2dsp_init_mips.c b/mythtv/external/FFmpeg/libavcodec/mips/wmv2dsp_init_mips.c
new file mode 100644
index 00000000000..51dd2078d94
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mips/wmv2dsp_init_mips.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2016 Zhou Xiaoyong <zhouxiaoyong@loongson.cn>
+ *
+ * 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 "wmv2dsp_mips.h"
+
+#if HAVE_MMI
+static av_cold void wmv2dsp_init_mmi(WMV2DSPContext *c)
+{
+    c->idct_add  = ff_wmv2_idct_add_mmi;
+    c->idct_put  = ff_wmv2_idct_put_mmi;
+}
+#endif /* HAVE_MMI */
+
+av_cold void ff_wmv2dsp_init_mips(WMV2DSPContext *c)
+{
+#if HAVE_MMI
+    wmv2dsp_init_mmi(c);
+#endif /* HAVE_MMI */
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/wmv2dsp_mips.h b/mythtv/external/FFmpeg/libavcodec/mips/wmv2dsp_mips.h
new file mode 100644
index 00000000000..22894c505d4
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mips/wmv2dsp_mips.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2016 Zhou Xiaoyong <zhouxiaoyong@loongson.cn>
+ *
+ * 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_MIPS_WMV2DSP_MIPS_H
+#define AVCODEC_MIPS_WMV2DSP_MIPS_H
+
+#include "libavcodec/wmv2dsp.h"
+
+void ff_wmv2_idct_add_mmi(uint8_t *dest, int line_size, int16_t *block);
+void ff_wmv2_idct_put_mmi(uint8_t *dest, int line_size, int16_t *block);
+
+#endif /* AVCODEC_MIPS_WMV2DSP_MIPS_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/mips/wmv2dsp_mmi.c b/mythtv/external/FFmpeg/libavcodec/mips/wmv2dsp_mmi.c
new file mode 100644
index 00000000000..1f6ccb299bf
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mips/wmv2dsp_mmi.c
@@ -0,0 +1,278 @@
+/*
+ * WMV2 - DSP functions Loongson MMI-optimized
+ *
+ * Copyright (c) 2016 Zhou Xiaoyong <zhouxiaoyong@loongson.cn>
+ *
+ * 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/avassert.h"
+#include "constants.h"
+#include "wmv2dsp_mips.h"
+#include "libavutil/mips/mmiutils.h"
+
+#define W0 2048
+#define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */
+#define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */
+#define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */
+#define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */
+#define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */
+#define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */
+#define W7 565  /* 2048*sqrt (2)*cos (7*pi/16) */
+
+static void wmv2_idct_row_mmi(short * b)
+{
+    int s1, s2;
+    int a0, a1, a2, a3, a4, a5, a6, a7;
+
+    /* step 1 */
+    a0 = W0 * b[0] + W0 * b[4];
+    a1 = W1 * b[1] + W7 * b[7];
+    a2 = W2 * b[2] + W6 * b[6];
+    a3 = W3 * b[5] - W5 * b[3];
+    a4 = W0 * b[0] - W0 * b[4];
+    a5 = W5 * b[5] + W3 * b[3];
+    a6 = W6 * b[2] - W2 * b[6];
+    a7 = W7 * b[1] - W1 * b[7];
+
+    /* step 2 */
+    s1 = (181 * (a1 - a5 + a7 - a3) + 128) >> 8; // 1, 3, 5, 7
+    s2 = (181 * (a1 - a5 - a7 + a3) + 128) >> 8;
+
+    /* step 3 */
+    b[0] = (a0 + a2 + a1 + a5 + 128) >> 8;
+    b[1] = (a4 + a6 + s1      + 128) >> 8;
+    b[2] = (a4 - a6 + s2      + 128) >> 8;
+    b[3] = (a0 - a2 + a7 + a3 + 128) >> 8;
+    b[4] = (a0 - a2 - a7 - a3 + 128) >> 8;
+    b[5] = (a4 - a6 - s2      + 128) >> 8;
+    b[6] = (a4 + a6 - s1      + 128) >> 8;
+    b[7] = (a0 + a2 - a1 - a5 + 128) >> 8;
+}
+
+static void wmv2_idct_col_mmi(short * b)
+{
+    int s1, s2;
+    int a0, a1, a2, a3, a4, a5, a6, a7;
+
+    /* step 1, with extended precision */
+    a0 = (W0 * b[ 0] + W0 * b[32]    ) >> 3;
+    a1 = (W1 * b[ 8] + W7 * b[56] + 4) >> 3;
+    a2 = (W2 * b[16] + W6 * b[48] + 4) >> 3;
+    a3 = (W3 * b[40] - W5 * b[24] + 4) >> 3;
+    a4 = (W0 * b[ 0] - W0 * b[32]    ) >> 3;
+    a5 = (W5 * b[40] + W3 * b[24] + 4) >> 3;
+    a6 = (W6 * b[16] - W2 * b[48] + 4) >> 3;
+    a7 = (W7 * b[ 8] - W1 * b[56] + 4) >> 3;
+
+    /* step 2 */
+    s1 = (181 * (a1 - a5 + a7 - a3) + 128) >> 8;
+    s2 = (181 * (a1 - a5 - a7 + a3) + 128) >> 8;
+
+    /* step 3 */
+    b[ 0] = (a0 + a2 + a1 + a5 + 8192) >> 14;
+    b[ 8] = (a4 + a6 + s1      + 8192) >> 14;
+    b[16] = (a4 - a6 + s2      + 8192) >> 14;
+    b[24] = (a0 - a2 + a7 + a3 + 8192) >> 14;
+
+    b[32] = (a0 - a2 - a7 - a3 + 8192) >> 14;
+    b[40] = (a4 - a6 - s2      + 8192) >> 14;
+    b[48] = (a4 + a6 - s1      + 8192) >> 14;
+    b[56] = (a0 + a2 - a1 - a5 + 8192) >> 14;
+}
+
+void ff_wmv2_idct_add_mmi(uint8_t *dest, int line_size, int16_t *block)
+{
+    int i;
+    double ftmp[11];
+
+    for (i = 0; i < 64; i += 8)
+        wmv2_idct_row_mmi(block + i);
+    for (i = 0; i < 8; i++)
+        wmv2_idct_col_mmi(block + i);
+
+    __asm__ volatile (
+        "xor        %[ftmp0],   %[ftmp0],   %[ftmp0]                    \n\t"
+
+        // low 4 loop
+        MMI_LDC1(%[ftmp1], %[block], 0x00)
+        MMI_LDC1(%[ftmp2], %[block], 0x08)
+        MMI_LDC1(%[ftmp3], %[block], 0x10)
+        MMI_LDC1(%[ftmp4], %[block], 0x18)
+        MMI_LDC1(%[ftmp5], %[block], 0x20)
+        MMI_LDC1(%[ftmp6], %[block], 0x28)
+        MMI_LDC1(%[ftmp7], %[block], 0x30)
+        MMI_LDC1(%[ftmp8], %[block], 0x38)
+
+        MMI_LDC1(%[ftmp9], %[dest], 0x00)
+        "punpckhbh  %[ftmp10],  %[ftmp9],   %[ftmp0]                    \n\t"
+        "punpcklbh  %[ftmp9],   %[ftmp9],   %[ftmp0]                    \n\t"
+        "paddh      %[ftmp1],   %[ftmp1],   %[ftmp9]                    \n\t"
+        "paddh      %[ftmp2],   %[ftmp2],   %[ftmp10]                   \n\t"
+        "packushb   %[ftmp1],   %[ftmp1],   %[ftmp2]                    \n\t"
+        MMI_SDC1(%[ftmp1], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+
+        MMI_LDC1(%[ftmp9], %[dest], 0x00)
+        "punpckhbh  %[ftmp10],  %[ftmp9],   %[ftmp0]                    \n\t"
+        "punpcklbh  %[ftmp9],   %[ftmp9],   %[ftmp0]                    \n\t"
+        "paddh      %[ftmp3],   %[ftmp3],   %[ftmp9]                    \n\t"
+        "paddh      %[ftmp4],   %[ftmp4],   %[ftmp10]                   \n\t"
+        "packushb   %[ftmp3],   %[ftmp3],   %[ftmp4]                    \n\t"
+        MMI_SDC1(%[ftmp3], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+
+        MMI_LDC1(%[ftmp9], %[dest], 0x00)
+        "punpckhbh  %[ftmp10],  %[ftmp9],   %[ftmp0]                    \n\t"
+        "punpcklbh  %[ftmp9],   %[ftmp9],   %[ftmp0]                    \n\t"
+        "paddh      %[ftmp5],   %[ftmp5],   %[ftmp9]                    \n\t"
+        "paddh      %[ftmp6],   %[ftmp6],   %[ftmp10]                   \n\t"
+        "packushb   %[ftmp5],   %[ftmp5],   %[ftmp6]                    \n\t"
+        MMI_SDC1(%[ftmp5], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+
+        MMI_LDC1(%[ftmp9], %[dest], 0x00)
+        "punpckhbh  %[ftmp10],  %[ftmp9],   %[ftmp0]                    \n\t"
+        "punpcklbh  %[ftmp9],   %[ftmp9],   %[ftmp0]                    \n\t"
+        "paddh      %[ftmp7],   %[ftmp7],   %[ftmp9]                    \n\t"
+        "paddh      %[ftmp8],   %[ftmp8],   %[ftmp10]                   \n\t"
+        "packushb   %[ftmp7],   %[ftmp7],   %[ftmp8]                    \n\t"
+        MMI_SDC1(%[ftmp7], %[dest], 0x00)
+
+        PTR_ADDIU  "%[block],   %[block],   0x40                        \n\t"
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+
+        // high 4 loop
+        MMI_LDC1(%[ftmp1], %[block], 0x00)
+        MMI_LDC1(%[ftmp2], %[block], 0x08)
+        MMI_LDC1(%[ftmp3], %[block], 0x10)
+        MMI_LDC1(%[ftmp4], %[block], 0x18)
+        MMI_LDC1(%[ftmp5], %[block], 0x20)
+        MMI_LDC1(%[ftmp6], %[block], 0x28)
+        MMI_LDC1(%[ftmp7], %[block], 0x30)
+        MMI_LDC1(%[ftmp8], %[block], 0x38)
+
+        MMI_LDC1(%[ftmp9], %[dest], 0x00)
+        "punpckhbh  %[ftmp10],  %[ftmp9],   %[ftmp0]                    \n\t"
+        "punpcklbh  %[ftmp9],   %[ftmp9],   %[ftmp0]                    \n\t"
+        "paddh      %[ftmp1],   %[ftmp1],   %[ftmp9]                    \n\t"
+        "paddh      %[ftmp2],   %[ftmp2],   %[ftmp10]                   \n\t"
+        "packushb   %[ftmp1],   %[ftmp1],   %[ftmp2]                    \n\t"
+        MMI_SDC1(%[ftmp1], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+
+        MMI_LDC1(%[ftmp9], %[dest], 0x00)
+        "punpckhbh  %[ftmp10],  %[ftmp9],   %[ftmp0]                    \n\t"
+        "punpcklbh  %[ftmp9],   %[ftmp9],   %[ftmp0]                    \n\t"
+        "paddh      %[ftmp3],   %[ftmp3],   %[ftmp9]                    \n\t"
+        "paddh      %[ftmp4],   %[ftmp4],   %[ftmp10]                   \n\t"
+        "packushb   %[ftmp3],   %[ftmp3],   %[ftmp4]                    \n\t"
+        MMI_SDC1(%[ftmp3], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+
+        MMI_LDC1(%[ftmp9], %[dest], 0x00)
+        "punpckhbh  %[ftmp10],  %[ftmp9],   %[ftmp0]                    \n\t"
+        "punpcklbh  %[ftmp9],   %[ftmp9],   %[ftmp0]                    \n\t"
+        "paddh      %[ftmp5],   %[ftmp5],   %[ftmp9]                    \n\t"
+        "paddh      %[ftmp6],   %[ftmp6],   %[ftmp10]                   \n\t"
+        "packushb   %[ftmp5],   %[ftmp5],   %[ftmp6]                    \n\t"
+        MMI_SDC1(%[ftmp5], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+
+        MMI_LDC1(%[ftmp9], %[dest], 0x00)
+        "punpckhbh  %[ftmp10],  %[ftmp9],   %[ftmp0]                    \n\t"
+        "punpcklbh  %[ftmp9],   %[ftmp9],   %[ftmp0]                    \n\t"
+        "paddh      %[ftmp7],   %[ftmp7],   %[ftmp9]                    \n\t"
+        "paddh      %[ftmp8],   %[ftmp8],   %[ftmp10]                   \n\t"
+        "packushb   %[ftmp7],   %[ftmp7],   %[ftmp8]                    \n\t"
+        MMI_SDC1(%[ftmp7], %[dest], 0x00)
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),            [ftmp7]"=&f"(ftmp[7]),
+          [ftmp8]"=&f"(ftmp[8]),            [ftmp9]"=&f"(ftmp[9]),
+          [ftmp10]"=&f"(ftmp[10]),
+          [block]"+&r"(block),              [dest]"+&r"(dest)
+        : [line_size]"r"((mips_reg)line_size)
+        : "memory"
+    );
+}
+
+void ff_wmv2_idct_put_mmi(uint8_t *dest, int line_size, int16_t *block)
+{
+    int i;
+    double ftmp[8];
+
+    for (i = 0; i < 64; i += 8)
+        wmv2_idct_row_mmi(block + i);
+    for (i = 0; i < 8; i++)
+        wmv2_idct_col_mmi(block + i);
+
+    __asm__ volatile (
+        // low 4 loop
+        MMI_LDC1(%[ftmp0], %[block], 0x00)
+        MMI_LDC1(%[ftmp1], %[block], 0x08)
+        MMI_LDC1(%[ftmp2], %[block], 0x10)
+        MMI_LDC1(%[ftmp3], %[block], 0x18)
+        MMI_LDC1(%[ftmp4], %[block], 0x20)
+        MMI_LDC1(%[ftmp5], %[block], 0x28)
+        MMI_LDC1(%[ftmp6], %[block], 0x30)
+        MMI_LDC1(%[ftmp7], %[block], 0x38)
+        "packushb   %[ftmp0],   %[ftmp0],   %[ftmp1]                    \n\t"
+        "packushb   %[ftmp2],   %[ftmp2],   %[ftmp3]                    \n\t"
+        "packushb   %[ftmp4],   %[ftmp4],   %[ftmp5]                    \n\t"
+        "packushb   %[ftmp6],   %[ftmp6],   %[ftmp7]                    \n\t"
+        MMI_SDC1(%[ftmp0], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+        MMI_SDC1(%[ftmp2], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+        MMI_SDC1(%[ftmp4], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+        MMI_SDC1(%[ftmp6], %[dest], 0x00)
+
+        PTR_ADDIU  "%[block],   %[block],   0x40                        \n\t"
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+
+        // high 4 loop
+        MMI_LDC1(%[ftmp0], %[block], 0x00)
+        MMI_LDC1(%[ftmp1], %[block], 0x08)
+        MMI_LDC1(%[ftmp2], %[block], 0x10)
+        MMI_LDC1(%[ftmp3], %[block], 0x18)
+        MMI_LDC1(%[ftmp4], %[block], 0x20)
+        MMI_LDC1(%[ftmp5], %[block], 0x28)
+        MMI_LDC1(%[ftmp6], %[block], 0x30)
+        MMI_LDC1(%[ftmp7], %[block], 0x38)
+        "packushb   %[ftmp0],   %[ftmp0],   %[ftmp1]                    \n\t"
+        "packushb   %[ftmp2],   %[ftmp2],   %[ftmp3]                    \n\t"
+        "packushb   %[ftmp4],   %[ftmp4],   %[ftmp5]                    \n\t"
+        "packushb   %[ftmp6],   %[ftmp6],   %[ftmp7]                    \n\t"
+        MMI_SDC1(%[ftmp0], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+        MMI_SDC1(%[ftmp2], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+        MMI_SDC1(%[ftmp4], %[dest], 0x00)
+        PTR_ADDU   "%[dest],    %[dest],    %[line_size]                \n\t"
+        MMI_SDC1(%[ftmp6], %[dest], 0x00)
+        : [ftmp0]"=&f"(ftmp[0]),            [ftmp1]"=&f"(ftmp[1]),
+          [ftmp2]"=&f"(ftmp[2]),            [ftmp3]"=&f"(ftmp[3]),
+          [ftmp4]"=&f"(ftmp[4]),            [ftmp5]"=&f"(ftmp[5]),
+          [ftmp6]"=&f"(ftmp[6]),            [ftmp7]"=&f"(ftmp[7]),
+          [block]"+&r"(block),              [dest]"+&r"(dest)
+        : [line_size]"r"((mips_reg)line_size)
+        : "memory"
+    );
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/mjpegdec.c b/mythtv/external/FFmpeg/libavcodec/mjpegdec.c
index 742e07c8880..5b2409755cb 100644
--- a/mythtv/external/FFmpeg/libavcodec/mjpegdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/mjpegdec.c
@@ -71,20 +71,36 @@ static int build_vlc(VLC *vlc, const uint8_t *bits_table,
                               huff_code, 2, 2, huff_sym, 2, 2, use_static);
 }
 
-static void build_basic_mjpeg_vlc(MJpegDecodeContext *s)
+static int build_basic_mjpeg_vlc(MJpegDecodeContext *s)
 {
-    build_vlc(&s->vlcs[0][0], avpriv_mjpeg_bits_dc_luminance,
-              avpriv_mjpeg_val_dc, 12, 0, 0);
-    build_vlc(&s->vlcs[0][1], avpriv_mjpeg_bits_dc_chrominance,
-              avpriv_mjpeg_val_dc, 12, 0, 0);
-    build_vlc(&s->vlcs[1][0], avpriv_mjpeg_bits_ac_luminance,
-              avpriv_mjpeg_val_ac_luminance, 251, 0, 1);
-    build_vlc(&s->vlcs[1][1], avpriv_mjpeg_bits_ac_chrominance,
-              avpriv_mjpeg_val_ac_chrominance, 251, 0, 1);
-    build_vlc(&s->vlcs[2][0], avpriv_mjpeg_bits_ac_luminance,
-              avpriv_mjpeg_val_ac_luminance, 251, 0, 0);
-    build_vlc(&s->vlcs[2][1], avpriv_mjpeg_bits_ac_chrominance,
-              avpriv_mjpeg_val_ac_chrominance, 251, 0, 0);
+    int ret;
+
+    if ((ret = build_vlc(&s->vlcs[0][0], avpriv_mjpeg_bits_dc_luminance,
+                         avpriv_mjpeg_val_dc, 12, 0, 0)) < 0)
+        return ret;
+
+    if ((ret = build_vlc(&s->vlcs[0][1], avpriv_mjpeg_bits_dc_chrominance,
+                         avpriv_mjpeg_val_dc, 12, 0, 0)) < 0)
+        return ret;
+
+    if ((ret = build_vlc(&s->vlcs[1][0], avpriv_mjpeg_bits_ac_luminance,
+                         avpriv_mjpeg_val_ac_luminance, 251, 0, 1)) < 0)
+        return ret;
+
+    if ((ret = build_vlc(&s->vlcs[1][1], avpriv_mjpeg_bits_ac_chrominance,
+                         avpriv_mjpeg_val_ac_chrominance, 251, 0, 1)) < 0)
+        return ret;
+
+    if ((ret = build_vlc(&s->vlcs[2][0], avpriv_mjpeg_bits_ac_luminance,
+                         avpriv_mjpeg_val_ac_luminance, 251, 0, 0)) < 0)
+        return ret;
+
+    if ((ret = build_vlc(&s->vlcs[2][1], avpriv_mjpeg_bits_ac_chrominance,
+                         avpriv_mjpeg_val_ac_chrominance, 251, 0, 0)) < 0)
+        return ret;
+
+
+    return 0;
 }
 
 static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
@@ -110,6 +126,7 @@ static void init_idct(AVCodecContext *avctx)
 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
 {
     MJpegDecodeContext *s = avctx->priv_data;
+    int ret;
 
     if (!s->picture_ptr) {
         s->picture = av_frame_alloc();
@@ -131,11 +148,13 @@ av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
     avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
     avctx->colorspace = AVCOL_SPC_BT470BG;
 
-    build_basic_mjpeg_vlc(s);
+    if ((ret = build_basic_mjpeg_vlc(s)) < 0)
+        return ret;
 
     if (s->extern_huff) {
         av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
-        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
+        if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
+            return ret;
         if (ff_mjpeg_decode_dht(s)) {
             av_log(avctx, AV_LOG_ERROR,
                    "error using external huffman table, switching back to internal\n");
@@ -188,6 +207,10 @@ int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
         /* read quant table */
         for (i = 0; i < 64; i++) {
             s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
+            if (s->quant_matrixes[index][i] == 0) {
+                av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
+                return AVERROR_INVALIDDATA;
+            }
         }
 
         // XXX FIXME fine-tune, and perhaps add dc too
@@ -303,7 +326,7 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
         height= s->height;
 
     av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
-    if (av_image_check_size(width, height, 0, s->avctx))
+    if (av_image_check_size(width, height, 0, s->avctx) < 0)
         return AVERROR_INVALIDDATA;
 
     nb_components = get_bits(&s->gb, 8);
@@ -582,13 +605,13 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
         break;
     default:
 unk_pixfmt:
-        av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x bits:%d\n", pix_fmt_id, s->bits);
+        avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
         memset(s->upscale_h, 0, sizeof(s->upscale_h));
         memset(s->upscale_v, 0, sizeof(s->upscale_v));
         return AVERROR_PATCHWELCOME;
     }
     if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
-        av_log(s->avctx, AV_LOG_ERROR, "lowres not supported for weird subsampling\n");
+        avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
         return AVERROR_PATCHWELCOME;
     }
     if (s->ls) {
@@ -682,7 +705,7 @@ static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
 
 /* decode block and dequantize */
 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
-                        int dc_index, int ac_index, int16_t *quant_matrix)
+                        int dc_index, int ac_index, uint16_t *quant_matrix)
 {
     int code, i, j, level, val;
 
@@ -693,7 +716,7 @@ static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
         return AVERROR_INVALIDDATA;
     }
     val = val * quant_matrix[0] + s->last_dc[component];
-    val = FFMIN(val, 32767);
+    val = av_clip_int16(val);
     s->last_dc[component] = val;
     block[0] = val;
     /* AC coefs */
@@ -732,9 +755,9 @@ static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
 
 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
                                  int component, int dc_index,
-                                 int16_t *quant_matrix, int Al)
+                                 uint16_t *quant_matrix, int Al)
 {
-    int val;
+    unsigned val;
     s->bdsp.clear_block(block);
     val = mjpeg_decode_dc(s, dc_index);
     if (val == 0xfffff) {
@@ -750,10 +773,11 @@ static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
 /* decode block and dequantize - progressive JPEG version */
 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
                                     uint8_t *last_nnz, int ac_index,
-                                    int16_t *quant_matrix,
+                                    uint16_t *quant_matrix,
                                     int ss, int se, int Al, int *EOBRUN)
 {
-    int code, i, j, level, val, run;
+    int code, i, j, val, run;
+    unsigned level;
 
     if (*EOBRUN) {
         (*EOBRUN)--;
@@ -848,7 +872,7 @@ for (; ; i++) {                                                     \
 /* decode block and dequantize - progressive JPEG refinement pass */
 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
                                    uint8_t *last_nnz,
-                                   int ac_index, int16_t *quant_matrix,
+                                   int ac_index, uint16_t *quant_matrix,
                                    int ss, int se, int Al, int *EOBRUN)
 {
     int code, i = ss, j, sign, val, run;
@@ -965,6 +989,9 @@ static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int p
 
     av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size,
                    (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0]));
+    if (!s->ljpeg_buffer)
+        return AVERROR(ENOMEM);
+
     buffer = s->ljpeg_buffer;
 
     for (i = 0; i < 4; i++)
@@ -1082,6 +1109,10 @@ static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
 
     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
+            if (get_bits_left(&s->gb) < 1) {
+                av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
+                return AVERROR_INVALIDDATA;
+            }
             if (s->restart_interval && !s->restart_count){
                 s->restart_count = s->restart_interval;
                 resync_mb_x = mb_x;
@@ -1133,7 +1164,7 @@ static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
                         if (s->interlaced && s->bottom_field)
                             ptr += linesize >> 1;
                         pred &= mask;
-                        *ptr= pred + (dc << point_transform);
+                        *ptr= pred + ((unsigned)dc << point_transform);
                         }else{
                             ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
                             if(y==0 && toprow){
@@ -1153,7 +1184,7 @@ static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
                             if (s->interlaced && s->bottom_field)
                                 ptr16 += linesize >> 1;
                             pred &= mask;
-                            *ptr16= pred + (dc << point_transform);
+                            *ptr16= pred + ((unsigned)dc << point_transform);
                         }
                         if (++x == h) {
                             x = 0;
@@ -1192,13 +1223,13 @@ static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
                             PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
 
                             pred &= mask;
-                            *ptr = pred + (dc << point_transform);
+                            *ptr = pred + ((unsigned)dc << point_transform);
                         }else{
                             ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
                             PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
 
                             pred &= mask;
-                            *ptr16= pred + (dc << point_transform);
+                            *ptr16= pred + ((unsigned)dc << point_transform);
                         }
 
                         if (++x == h) {
@@ -1375,7 +1406,7 @@ static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
     int mb_x, mb_y;
     int EOBRUN = 0;
     int c = s->comp_index[0];
-    int16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
+    uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
 
     av_assert0(ss>=0 && Ah>=0 && Al>=0);
     if (se < ss || se > 63) {
@@ -1393,6 +1424,10 @@ static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
         int block_idx    = mb_y * s->block_stride[c];
         int16_t (*block)[64] = &s->blocks[c][block_idx];
         uint8_t *last_nnz    = &s->last_nnz[c][block_idx];
+        if (get_bits_left(&s->gb) <= 0) {
+            av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
+            return AVERROR_INVALIDDATA;
+        }
         for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
                 int ret;
                 if (s->restart_interval && !s->restart_count)
@@ -1466,13 +1501,23 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
         return -1;
     }
 
+    if (reference) {
+        if (reference->width  != s->picture_ptr->width  ||
+            reference->height != s->picture_ptr->height ||
+            reference->format != s->picture_ptr->format) {
+            av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
+            return AVERROR_INVALIDDATA;
+        }
+    }
+
     av_assert0(s->picture_ptr->data[0]);
     /* XXX: verify len field validity */
     len = get_bits(&s->gb, 16);
     nb_components = get_bits(&s->gb, 8);
     if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
-        av_log(s->avctx, AV_LOG_ERROR,
-               "decode_sos: nb_components (%d) unsupported\n", nb_components);
+        avpriv_report_missing_feature(s->avctx,
+                                      "decode_sos: nb_components (%d)",
+                                      nb_components);
         return AVERROR_PATCHWELCOME;
     }
     if (len != 6 + 2 * nb_components) {
@@ -1637,11 +1682,9 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
     id   = get_bits_long(&s->gb, 32);
     len -= 6;
 
-    if (s->avctx->debug & FF_DEBUG_STARTCODE) {
-        char id_str[32];
-        av_get_codec_tag_string(id_str, sizeof(id_str), av_bswap32(id));
-        av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n", id_str, id, len);
-    }
+    if (s->avctx->debug & FF_DEBUG_STARTCODE)
+        av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
+               av_fourcc2str(av_bswap32(id)), id, len);
 
     /* Buggy AVID, it puts EOI only at every 10th frame. */
     /* Also, this fourcc is used by non-avid files too, it holds some
@@ -1657,19 +1700,13 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
             s->buggy_avid = 1;
         i = get_bits(&s->gb, 8); len--;
         av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
-#if 0
-        skip_bits(&s->gb, 8);
-        skip_bits(&s->gb, 32);
-        skip_bits(&s->gb, 32);
-        len -= 10;
-#endif
         goto out;
     }
 
-//    len -= 2;
-
     if (id == AV_RB32("JFIF")) {
         int t_w, t_h, v1, v2;
+        if (len < 8)
+            goto out;
         skip_bits(&s->gb, 8); /* the trailing zero-byte */
         v1 = get_bits(&s->gb, 8);
         v2 = get_bits(&s->gb, 8);
@@ -1849,21 +1886,87 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
         len -= 4;
         /* Apple MJPEG-A */
         if (id == AV_RB32("mjpg")) {
-#if 0
-            skip_bits(&s->gb, 32); /* field size */
-            skip_bits(&s->gb, 32); /* pad field size */
-            skip_bits(&s->gb, 32); /* next off */
-            skip_bits(&s->gb, 32); /* quant off */
-            skip_bits(&s->gb, 32); /* huff off */
-            skip_bits(&s->gb, 32); /* image off */
-            skip_bits(&s->gb, 32); /* scan off */
-            skip_bits(&s->gb, 32); /* data off */
-#endif
+            /* structure:
+                4bytes      field size
+                4bytes      pad field size
+                4bytes      next off
+                4bytes      quant off
+                4bytes      huff off
+                4bytes      image off
+                4bytes      scan off
+                4bytes      data off
+            */
             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
         }
     }
 
+    if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
+        int id2;
+        unsigned seqno;
+        unsigned nummarkers;
+
+        id   = get_bits_long(&s->gb, 32);
+        id2  = get_bits_long(&s->gb, 24);
+        len -= 7;
+        if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
+            av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
+            goto out;
+        }
+
+        skip_bits(&s->gb, 8);
+        seqno  = get_bits(&s->gb, 8);
+        len   -= 2;
+        if (seqno == 0) {
+            av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
+            goto out;
+        }
+
+        nummarkers  = get_bits(&s->gb, 8);
+        len        -= 1;
+        if (nummarkers == 0) {
+            av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
+            goto out;
+        } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
+            av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
+            goto out;
+        } else if (seqno > nummarkers) {
+            av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
+            goto out;
+        }
+
+        /* Allocate if this is the first APP2 we've seen. */
+        if (s->iccnum == 0) {
+            s->iccdata     = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
+            s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
+            if (!s->iccdata || !s->iccdatalens) {
+                av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
+                return AVERROR(ENOMEM);
+            }
+            s->iccnum = nummarkers;
+        }
+
+        if (s->iccdata[seqno - 1]) {
+            av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
+            goto out;
+        }
+
+        s->iccdatalens[seqno - 1]  = len;
+        s->iccdata[seqno - 1]      = av_malloc(len);
+        if (!s->iccdata[seqno - 1]) {
+            av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
+            return AVERROR(ENOMEM);
+        }
+
+        memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
+        skip_bits(&s->gb, len << 3);
+        len = 0;
+        s->iccread++;
+
+        if (s->iccread > s->iccnum)
+            av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
+    }
+
 out:
     /* slow but needed for extreme adobe jpegs */
     if (len < 0)
@@ -2060,6 +2163,20 @@ int ff_mjpeg_find_marker(MJpegDecodeContext *s,
     return start_code;
 }
 
+static void reset_icc_profile(MJpegDecodeContext *s)
+{
+    int i;
+
+    if (s->iccdata)
+        for (i = 0; i < s->iccnum; i++)
+            av_freep(&s->iccdata[i]);
+    av_freep(&s->iccdata);
+    av_freep(&s->iccdatalens);
+
+    s->iccread = 0;
+    s->iccnum  = 0;
+}
+
 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                           AVPacket *avpkt)
 {
@@ -2080,6 +2197,9 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     av_freep(&s->stereo3d);
     s->adobe_transform = -1;
 
+    if (s->iccnum != 0)
+        reset_icc_profile(s);
+
     buf_ptr = buf;
     buf_end = buf + buf_size;
     while (buf_ptr < buf_end) {
@@ -2111,19 +2231,23 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
             av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
 
         /* process markers */
-        if (start_code >= 0xd0 && start_code <= 0xd7)
+        if (start_code >= 0xd0 && start_code <= 0xd7) {
             av_log(avctx, AV_LOG_DEBUG,
                    "restart marker: %d\n", start_code & 0x0f);
             /* APP fields */
-        else if (start_code >= APP0 && start_code <= APP15)
-            mjpeg_decode_app(s);
+        } else if (start_code >= APP0 && start_code <= APP15) {
+            if ((ret = mjpeg_decode_app(s)) < 0)
+                av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
+                       av_err2str(ret));
             /* Comment */
-        else if (start_code == COM) {
+        } else if (start_code == COM) {
             ret = mjpeg_decode_com(s);
             if (ret < 0)
                 return ret;
         } else if (start_code == DQT) {
-            ff_mjpeg_decode_dqt(s);
+            ret = ff_mjpeg_decode_dqt(s);
+            if (ret < 0)
+                return ret;
         }
 
         ret = -1;
@@ -2241,15 +2365,18 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
             goto the_end;
         case SOS:
             s->cur_scan++;
-            if (avctx->skip_frame == AVDISCARD_ALL)
+            if (avctx->skip_frame == AVDISCARD_ALL) {
+                skip_bits(&s->gb, get_bits_left(&s->gb));
                 break;
+            }
 
             if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
                 (avctx->err_recognition & AV_EF_EXPLODE))
                 goto fail;
             break;
         case DRI:
-            mjpeg_decode_dri(s);
+            if ((ret = mjpeg_decode_dri(s)) < 0)
+                return ret;
             break;
         case SOF5:
         case SOF6:
@@ -2386,7 +2513,7 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
             }
         }
     }
-    if (s->flipped) {
+    if (s->flipped && !s->rgb) {
         int j;
         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
         av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
@@ -2465,7 +2592,30 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
         av_freep(&s->stereo3d);
     }
 
-    av_dict_copy(avpriv_frame_get_metadatap(data), s->exif_metadata, 0);
+    if (s->iccnum != 0 && s->iccnum == s->iccread) {
+        AVFrameSideData *sd;
+        size_t offset = 0;
+        int total_size = 0;
+        int i;
+
+        /* Sum size of all parts. */
+        for (i = 0; i < s->iccnum; i++)
+            total_size += s->iccdatalens[i];
+
+        sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
+        if (!sd) {
+            av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
+            return AVERROR(ENOMEM);
+        }
+
+        /* Reassemble the parts, which are now in-order. */
+        for (i = 0; i < s->iccnum; i++) {
+            memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
+            offset += s->iccdatalens[i];
+        }
+    }
+
+    av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
     av_dict_free(&s->exif_metadata);
 
 the_end_no_picture:
@@ -2504,6 +2654,9 @@ av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
         av_freep(&s->last_nnz[i]);
     }
     av_dict_free(&s->exif_metadata);
+
+    reset_icc_profile(s);
+
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mjpegdec.h b/mythtv/external/FFmpeg/libavcodec/mjpegdec.h
index fb811294a14..c84a40aa6e6 100644
--- a/mythtv/external/FFmpeg/libavcodec/mjpegdec.h
+++ b/mythtv/external/FFmpeg/libavcodec/mjpegdec.h
@@ -50,7 +50,7 @@ typedef struct MJpegDecodeContext {
     int buffer_size;
     uint8_t *buffer;
 
-    int16_t quant_matrixes[4][64];
+    uint16_t quant_matrixes[4][64];
     VLC vlcs[3][4];
     int qscale[4];      ///< quantizer scale calculated from quant_matrixes
 
@@ -98,7 +98,7 @@ typedef struct MJpegDecodeContext {
     int got_picture;                                ///< we found a SOF and picture is valid, too.
     int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
     int8_t *qscale_table;
-    DECLARE_ALIGNED(16, int16_t, block)[64];
+    DECLARE_ALIGNED(32, int16_t, block)[64];
     int16_t (*blocks[MAX_COMPONENTS])[64]; ///< intermediate sums (progressive mode)
     uint8_t *last_nnz[MAX_COMPONENTS];
     uint64_t coefs_finished[MAX_COMPONENTS]; ///< bitmask of which coefs have been completely decoded (progressive mode)
@@ -130,6 +130,11 @@ typedef struct MJpegDecodeContext {
     AVStereo3D *stereo3d; ///!< stereoscopic information (cached, since it is read before frame allocation)
 
     const AVPixFmtDescriptor *pix_desc;
+
+    uint8_t **iccdata;
+    int *iccdatalens;
+    int iccnum;
+    int iccread;
 } MJpegDecodeContext;
 
 int ff_mjpeg_decode_init(AVCodecContext *avctx);
diff --git a/mythtv/external/FFmpeg/libavcodec/mjpegenc.c b/mythtv/external/FFmpeg/libavcodec/mjpegenc.c
index 3d113770df9..e6cdaf63760 100644
--- a/mythtv/external/FFmpeg/libavcodec/mjpegenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/mjpegenc.c
@@ -39,52 +39,55 @@
 #include "mjpeg.h"
 #include "mjpegenc.h"
 
-static uint8_t uni_ac_vlc_len[64 * 64 * 2];
-static uint8_t uni_chroma_ac_vlc_len[64 * 64 * 2];
-
-static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256], uint8_t *uni_ac_vlc_len)
+static int alloc_huffman(MpegEncContext *s)
 {
-    int i;
-
-    for (i = 0; i < 128; i++) {
-        int level = i - 64;
-        int run;
-        if (!level)
-            continue;
-        for (run = 0; run < 64; run++) {
-            int len, code, nbits;
-            int alevel = FFABS(level);
-
-            len = (run >> 4) * huff_size_ac[0xf0];
-
-            nbits= av_log2_16bit(alevel) + 1;
-            code = ((15&run) << 4) | nbits;
-
-            len += huff_size_ac[code] + nbits;
-
-            uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
-            // We ignore EOB as its just a constant which does not change generally
-        }
-    }
+    MJpegContext *m = s->mjpeg_ctx;
+    size_t num_mbs, num_blocks, num_codes;
+    int blocks_per_mb;
+
+    // We need to init this here as the mjpeg init is called before the common init,
+    s->mb_width  = (s->width  + 15) / 16;
+    s->mb_height = (s->height + 15) / 16;
+
+    switch (s->chroma_format) {
+    case CHROMA_420: blocks_per_mb =  6; break;
+    case CHROMA_422: blocks_per_mb =  8; break;
+    case CHROMA_444: blocks_per_mb = 12; break;
+    default: av_assert0(0);
+    };
+
+    // Make sure we have enough space to hold this frame.
+    num_mbs = s->mb_width * s->mb_height;
+    num_blocks = num_mbs * blocks_per_mb;
+    num_codes = num_blocks * 64;
+
+    m->huff_buffer = av_malloc_array(num_codes, sizeof(MJpegHuffmanCode));
+    if (!m->huff_buffer)
+        return AVERROR(ENOMEM);
+    return 0;
 }
 
 av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
 {
     MJpegContext *m;
 
+    av_assert0(s->slice_context_count == 1);
+
     if (s->width > 65500 || s->height > 65500) {
         av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
         return AVERROR(EINVAL);
     }
 
-    m = av_malloc(sizeof(MJpegContext));
+    m = av_mallocz(sizeof(MJpegContext));
     if (!m)
         return AVERROR(ENOMEM);
 
     s->min_qcoeff=-1023;
     s->max_qcoeff= 1023;
 
-    /* build all the huffman tables */
+    // Build default Huffman tables.
+    // These may be overwritten later with more optimal Huffman tables, but
+    // they are needed at least right now for some processes like trellis.
     ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance,
                                  m->huff_code_dc_luminance,
                                  avpriv_mjpeg_bits_dc_luminance,
@@ -102,22 +105,122 @@ av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
                                  avpriv_mjpeg_bits_ac_chrominance,
                                  avpriv_mjpeg_val_ac_chrominance);
 
-    init_uni_ac_vlc(m->huff_size_ac_luminance,   uni_ac_vlc_len);
-    init_uni_ac_vlc(m->huff_size_ac_chrominance, uni_chroma_ac_vlc_len);
+    ff_init_uni_ac_vlc(m->huff_size_ac_luminance,   m->uni_ac_vlc_len);
+    ff_init_uni_ac_vlc(m->huff_size_ac_chrominance, m->uni_chroma_ac_vlc_len);
     s->intra_ac_vlc_length      =
-    s->intra_ac_vlc_last_length = uni_ac_vlc_len;
+    s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
     s->intra_chroma_ac_vlc_length      =
-    s->intra_chroma_ac_vlc_last_length = uni_chroma_ac_vlc_len;
+    s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
 
+    // Buffers start out empty.
+    m->huff_ncode = 0;
     s->mjpeg_ctx = m;
+
+    if(s->huffman == HUFFMAN_TABLE_OPTIMAL)
+        return alloc_huffman(s);
+
     return 0;
 }
 
 av_cold void ff_mjpeg_encode_close(MpegEncContext *s)
 {
+    av_freep(&s->mjpeg_ctx->huff_buffer);
     av_freep(&s->mjpeg_ctx);
 }
 
+/**
+ * Add code and table_id to the JPEG buffer.
+ *
+ * @param s The MJpegContext which contains the JPEG buffer.
+ * @param table_id Which Huffman table the code belongs to.
+ * @param code The encoded exponent of the coefficients and the run-bits.
+ */
+static inline void ff_mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)
+{
+    MJpegHuffmanCode *c = &s->huff_buffer[s->huff_ncode++];
+    c->table_id = table_id;
+    c->code = code;
+}
+
+/**
+ * Add the coefficient's data to the JPEG buffer.
+ *
+ * @param s The MJpegContext which contains the JPEG buffer.
+ * @param table_id Which Huffman table the code belongs to.
+ * @param val The coefficient.
+ * @param run The run-bits.
+ */
+static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)
+{
+    int mant, code;
+
+    if (val == 0) {
+        av_assert0(run == 0);
+        ff_mjpeg_encode_code(s, table_id, 0);
+    } else {
+        mant = val;
+        if (val < 0) {
+            val = -val;
+            mant--;
+        }
+
+        code = (run << 4) | (av_log2_16bit(val) + 1);
+
+        s->huff_buffer[s->huff_ncode].mant = mant;
+        ff_mjpeg_encode_code(s, table_id, code);
+    }
+}
+
+/**
+ * Add the block's data into the JPEG buffer.
+ *
+ * @param s The MJpegEncContext that contains the JPEG buffer.
+ * @param block The block.
+ * @param n The block's index or number.
+ */
+static void record_block(MpegEncContext *s, int16_t *block, int n)
+{
+    int i, j, table_id;
+    int component, dc, last_index, val, run;
+    MJpegContext *m = s->mjpeg_ctx;
+
+    /* DC coef */
+    component = (n <= 3 ? 0 : (n&1) + 1);
+    table_id = (n <= 3 ? 0 : 1);
+    dc = block[0]; /* overflow is impossible */
+    val = dc - s->last_dc[component];
+
+    ff_mjpeg_encode_coef(m, table_id, val, 0);
+
+    s->last_dc[component] = dc;
+
+    /* AC coefs */
+
+    run = 0;
+    last_index = s->block_last_index[n];
+    table_id |= 2;
+
+    for(i=1;i<=last_index;i++) {
+        j = s->intra_scantable.permutated[i];
+        val = block[j];
+
+        if (val == 0) {
+            run++;
+        } else {
+            while (run >= 16) {
+                ff_mjpeg_encode_code(m, table_id, 0xf0);
+                run -= 16;
+            }
+            ff_mjpeg_encode_coef(m, table_id, val, run);
+            run = 0;
+        }
+    }
+
+    /* output EOB only if not already 64 values */
+    if (last_index < 63 || run != 0)
+        ff_mjpeg_encode_code(m, table_id, 0);
+}
+
 static void encode_block(MpegEncContext *s, int16_t *block, int n)
 {
     int mant, nbits, code, i, j;
@@ -179,43 +282,74 @@ static void encode_block(MpegEncContext *s, int16_t *block, int n)
 void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
 {
     int i;
-    if (s->chroma_format == CHROMA_444) {
-        encode_block(s, block[0], 0);
-        encode_block(s, block[2], 2);
-        encode_block(s, block[4], 4);
-        encode_block(s, block[8], 8);
-        encode_block(s, block[5], 5);
-        encode_block(s, block[9], 9);
-
-        if (16*s->mb_x+8 < s->width) {
-            encode_block(s, block[1], 1);
-            encode_block(s, block[3], 3);
-            encode_block(s, block[6], 6);
-            encode_block(s, block[10], 10);
-            encode_block(s, block[7], 7);
-            encode_block(s, block[11], 11);
+    if (s->huffman == HUFFMAN_TABLE_OPTIMAL) {
+        if (s->chroma_format == CHROMA_444) {
+            record_block(s, block[0], 0);
+            record_block(s, block[2], 2);
+            record_block(s, block[4], 4);
+            record_block(s, block[8], 8);
+            record_block(s, block[5], 5);
+            record_block(s, block[9], 9);
+
+            if (16*s->mb_x+8 < s->width) {
+                record_block(s, block[1], 1);
+                record_block(s, block[3], 3);
+                record_block(s, block[6], 6);
+                record_block(s, block[10], 10);
+                record_block(s, block[7], 7);
+                record_block(s, block[11], 11);
+            }
+        } else {
+            for(i=0;i<5;i++) {
+                record_block(s, block[i], i);
+            }
+            if (s->chroma_format == CHROMA_420) {
+                record_block(s, block[5], 5);
+            } else {
+                record_block(s, block[6], 6);
+                record_block(s, block[5], 5);
+                record_block(s, block[7], 7);
+            }
         }
     } else {
-        for(i=0;i<5;i++) {
-            encode_block(s, block[i], i);
-        }
-        if (s->chroma_format == CHROMA_420) {
+        if (s->chroma_format == CHROMA_444) {
+            encode_block(s, block[0], 0);
+            encode_block(s, block[2], 2);
+            encode_block(s, block[4], 4);
+            encode_block(s, block[8], 8);
             encode_block(s, block[5], 5);
+            encode_block(s, block[9], 9);
+
+            if (16*s->mb_x+8 < s->width) {
+                encode_block(s, block[1], 1);
+                encode_block(s, block[3], 3);
+                encode_block(s, block[6], 6);
+                encode_block(s, block[10], 10);
+                encode_block(s, block[7], 7);
+                encode_block(s, block[11], 11);
+            }
         } else {
-            encode_block(s, block[6], 6);
-            encode_block(s, block[5], 5);
-            encode_block(s, block[7], 7);
+            for(i=0;i<5;i++) {
+                encode_block(s, block[i], i);
+            }
+            if (s->chroma_format == CHROMA_420) {
+                encode_block(s, block[5], 5);
+            } else {
+                encode_block(s, block[6], 6);
+                encode_block(s, block[5], 5);
+                encode_block(s, block[7], 7);
+            }
         }
-    }
 
-    s->i_tex_bits += get_bits_diff(s);
+        s->i_tex_bits += get_bits_diff(s);
+    }
 }
 
+#if CONFIG_AMV_ENCODER
 // maximum over s->mjpeg_vsample[i]
 #define V_MAX 2
 static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
                               const AVFrame *pic_arg, int *got_packet)
-
 {
     MpegEncContext *s = avctx->priv_data;
     AVFrame *pic;
@@ -252,6 +386,7 @@ static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
     av_frame_free(&pic);
     return ret;
 }
+#endif
 
 #define OFFSET(x) offsetof(MpegEncContext, x)
 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
@@ -261,12 +396,13 @@ FF_MPV_COMMON_OPTS
     { "left",   NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
     { "plane",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" },
     { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "pred" },
-
+{ "huffman", "Huffman table strategy", OFFSET(huffman), AV_OPT_TYPE_INT, { .i64 = HUFFMAN_TABLE_OPTIMAL }, 0, NB_HUFFMAN_TABLE_OPTION - 1, VE, "huffman" },
+    { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_DEFAULT }, INT_MIN, INT_MAX, VE, "huffman" },
+    { "optimal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_OPTIMAL }, INT_MIN, INT_MAX, VE, "huffman" },
 { NULL},
 };
 
 #if CONFIG_MJPEG_ENCODER
-
 static const AVClass mjpeg_class = {
     .class_name = "mjpeg encoder",
     .item_name  = av_default_item_name,
@@ -284,12 +420,13 @@ AVCodec ff_mjpeg_encoder = {
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
     .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
-    .pix_fmts       = (const enum AVPixelFormat[]){
+    .pix_fmts       = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_NONE
     },
     .priv_class     = &mjpeg_class,
 };
 #endif
+
 #if CONFIG_AMV_ENCODER
 static const AVClass amv_class = {
     .class_name = "amv encoder",
@@ -307,7 +444,7 @@ AVCodec ff_amv_encoder = {
     .init           = ff_mpv_encode_init,
     .encode2        = amv_encode_picture,
     .close          = ff_mpv_encode_end,
-    .pix_fmts       = (const enum AVPixelFormat[]){
+    .pix_fmts       = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_NONE
     },
     .priv_class     = &amv_class,
diff --git a/mythtv/external/FFmpeg/libavcodec/mjpegenc.h b/mythtv/external/FFmpeg/libavcodec/mjpegenc.h
index 60cd56677f1..d7ddc35ef53 100644
--- a/mythtv/external/FFmpeg/libavcodec/mjpegenc.h
+++ b/mythtv/external/FFmpeg/libavcodec/mjpegenc.h
@@ -39,18 +39,65 @@
 #include "mpegvideo.h"
 #include "put_bits.h"
 
+/**
+ * Buffer of JPEG frame data.
+ *
+ * Optimal Huffman table generation requires the frame data to be loaded into
+ * a buffer so that the tables can be computed.
+ * There are at most mb_width*mb_height*12*64 of these per frame.
+ */
+typedef struct MJpegHuffmanCode {
+    // 0=DC lum, 1=DC chrom, 2=AC lum, 3=AC chrom
+    uint8_t table_id; ///< The Huffman table id associated with the data.
+    uint8_t code;     ///< The exponent.
+    uint16_t mant;    ///< The mantissa.
+} MJpegHuffmanCode;
+
+/**
+ * Holds JPEG frame data and Huffman table data.
+ */
 typedef struct MJpegContext {
-    uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chroma, for easier addressing
-    uint16_t huff_code_dc_luminance[12];
-    uint8_t huff_size_dc_chrominance[12];
-    uint16_t huff_code_dc_chrominance[12];
+    //FIXME use array [3] instead of lumi / chroma, for easier addressing
+    uint8_t huff_size_dc_luminance[12];     ///< DC luminance Huffman table size.
+    uint16_t huff_code_dc_luminance[12];    ///< DC luminance Huffman table codes.
+    uint8_t huff_size_dc_chrominance[12];   ///< DC chrominance Huffman table size.
+    uint16_t huff_code_dc_chrominance[12];  ///< DC chrominance Huffman table codes.
+
+    uint8_t huff_size_ac_luminance[256];    ///< AC luminance Huffman table size.
+    uint16_t huff_code_ac_luminance[256];   ///< AC luminance Huffman table codes.
+    uint8_t huff_size_ac_chrominance[256];  ///< AC chrominance Huffman table size.
+    uint16_t huff_code_ac_chrominance[256]; ///< AC chrominance Huffman table codes.
 
-    uint8_t huff_size_ac_luminance[256];
-    uint16_t huff_code_ac_luminance[256];
-    uint8_t huff_size_ac_chrominance[256];
-    uint16_t huff_code_ac_chrominance[256];
+    /** Storage for AC luminance VLC (in MpegEncContext) */
+    uint8_t uni_ac_vlc_len[64 * 64 * 2];
+    /** Storage for AC chrominance VLC (in MpegEncContext) */
+    uint8_t uni_chroma_ac_vlc_len[64 * 64 * 2];
+
+    // Default DC tables have exactly 12 values
+    uint8_t bits_dc_luminance[17];   ///< DC luminance Huffman bits.
+    uint8_t val_dc_luminance[12];    ///< DC luminance Huffman values.
+    uint8_t bits_dc_chrominance[17]; ///< DC chrominance Huffman bits.
+    uint8_t val_dc_chrominance[12];  ///< DC chrominance Huffman values.
+
+    // 8-bit JPEG has max 256 values
+    uint8_t bits_ac_luminance[17];   ///< AC luminance Huffman bits.
+    uint8_t val_ac_luminance[256];   ///< AC luminance Huffman values.
+    uint8_t bits_ac_chrominance[17]; ///< AC chrominance Huffman bits.
+    uint8_t val_ac_chrominance[256]; ///< AC chrominance Huffman values.
+
+    size_t huff_ncode;               ///< Number of current entries in the buffer.
+    MJpegHuffmanCode *huff_buffer;   ///< Buffer for Huffman code values.
 } MJpegContext;
 
+/**
+ * Enum for the Huffman encoding strategy.
+ */
+enum HuffmanTableOption {
+    HUFFMAN_TABLE_DEFAULT = 0, ///< Use the default Huffman tables.
+    HUFFMAN_TABLE_OPTIMAL = 1, ///< Compute and use optimal Huffman tables.
+    NB_HUFFMAN_TABLE_OPTION = 2
+};
+
 static inline void put_marker(PutBitContext *p, enum JpegMarker code)
 {
     put_bits(p, 8, 0xff);
diff --git a/mythtv/external/FFmpeg/libavcodec/mjpegenc_common.c b/mythtv/external/FFmpeg/libavcodec/mjpegenc_common.c
index 7a6fe7468fe..31868c9beda 100644
--- a/mythtv/external/FFmpeg/libavcodec/mjpegenc_common.c
+++ b/mythtv/external/FFmpeg/libavcodec/mjpegenc_common.c
@@ -33,8 +33,35 @@
 #include "put_bits.h"
 #include "mjpegenc.h"
 #include "mjpegenc_common.h"
+#include "mjpegenc_huffman.h"
 #include "mjpeg.h"
 
+av_cold void ff_init_uni_ac_vlc(const uint8_t huff_size_ac[256], uint8_t *uni_ac_vlc_len)
+{
+    int i;
+
+    for (i = 0; i < 128; i++) {
+        int level = i - 64;
+        int run;
+        if (!level)
+            continue;
+        for (run = 0; run < 64; run++) {
+            int len, code, nbits;
+            int alevel = FFABS(level);
+
+            len = (run >> 4) * huff_size_ac[0xf0];
+
+            nbits= av_log2_16bit(alevel) + 1;
+            code = ((15&run) << 4) | nbits;
+
+            len += huff_size_ac[code] + nbits;
+
+            uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
+            // We ignore EOB as its just a constant which does not change generally
+        }
+    }
+}
+
 /* table_class: 0 = DC coef, 1 = AC coefs */
 static int put_huffman_table(PutBitContext *p, int table_class, int table_id,
                              const uint8_t *bits_table, const uint8_t *value_table)
@@ -64,13 +91,17 @@ static void jpeg_table_header(AVCodecContext *avctx, PutBitContext *p,
 {
     int i, j, size;
     uint8_t *ptr;
-    MpegEncContext *s = avctx->priv_data;
+    MpegEncContext *s = NULL;
+
+    /* Since avctx->priv_data will point to LJpegEncContext in this case */
+    if (avctx->codec_id != AV_CODEC_ID_LJPEG)
+        s = avctx->priv_data;
 
     if (avctx->codec_id != AV_CODEC_ID_LJPEG) {
         int matrix_count = 1 + !!memcmp(luma_intra_matrix,
                                         chroma_intra_matrix,
                                         sizeof(luma_intra_matrix[0]) * 64);
-    if (s->force_duplicated_matrix)
+    if (s && s->force_duplicated_matrix)
         matrix_count = 2;
     /* quant matrixes */
     put_marker(p, DQT);
@@ -104,15 +135,30 @@ static void jpeg_table_header(AVCodecContext *avctx, PutBitContext *p,
     ptr = put_bits_ptr(p);
     put_bits(p, 16, 0); /* patched later */
     size = 2;
-    size += put_huffman_table(p, 0, 0, avpriv_mjpeg_bits_dc_luminance,
-                              avpriv_mjpeg_val_dc);
-    size += put_huffman_table(p, 0, 1, avpriv_mjpeg_bits_dc_chrominance,
-                              avpriv_mjpeg_val_dc);
-
-    size += put_huffman_table(p, 1, 0, avpriv_mjpeg_bits_ac_luminance,
-                              avpriv_mjpeg_val_ac_luminance);
-    size += put_huffman_table(p, 1, 1, avpriv_mjpeg_bits_ac_chrominance,
-                              avpriv_mjpeg_val_ac_chrominance);
+
+    // Only MJPEG can have a variable Huffman variable. All other
+    // formats use the default Huffman table.
+    if (s && s->huffman == HUFFMAN_TABLE_OPTIMAL) {
+        size += put_huffman_table(p, 0, 0, s->mjpeg_ctx->bits_dc_luminance,
+                                  s->mjpeg_ctx->val_dc_luminance);
+        size += put_huffman_table(p, 0, 1, s->mjpeg_ctx->bits_dc_chrominance,
+                                  s->mjpeg_ctx->val_dc_chrominance);
+
+        size += put_huffman_table(p, 1, 0, s->mjpeg_ctx->bits_ac_luminance,
+                                  s->mjpeg_ctx->val_ac_luminance);
+        size += put_huffman_table(p, 1, 1, s->mjpeg_ctx->bits_ac_chrominance,
+                                  s->mjpeg_ctx->val_ac_chrominance);
+    } else {
+        size += put_huffman_table(p, 0, 0, avpriv_mjpeg_bits_dc_luminance,
+                                  avpriv_mjpeg_val_dc);
+        size += put_huffman_table(p, 0, 1, avpriv_mjpeg_bits_dc_chrominance,
+                                  avpriv_mjpeg_val_dc);
+
+        size += put_huffman_table(p, 1, 0, avpriv_mjpeg_bits_ac_luminance,
+                                  avpriv_mjpeg_val_ac_luminance);
+        size += put_huffman_table(p, 1, 1, avpriv_mjpeg_bits_ac_chrominance,
+                                  avpriv_mjpeg_val_ac_chrominance);
+    }
     AV_WB16(ptr, size);
 }
 
@@ -313,6 +359,54 @@ void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb,
     }
 }
 
+/**
+ * Encodes and outputs the entire frame in the JPEG format.
+ *
+ * @param s The MpegEncContext.
+ */
+void ff_mjpeg_encode_picture_frame(MpegEncContext *s)
+{
+    int i, nbits, code, table_id;
+    MJpegContext *m = s->mjpeg_ctx;
+    uint8_t *huff_size[4] = {m->huff_size_dc_luminance,
+                             m->huff_size_dc_chrominance,
+                             m->huff_size_ac_luminance,
+                             m->huff_size_ac_chrominance};
+    uint16_t *huff_code[4] = {m->huff_code_dc_luminance,
+                              m->huff_code_dc_chrominance,
+                              m->huff_code_ac_luminance,
+                              m->huff_code_ac_chrominance};
+    size_t total_bits = 0;
+    size_t bytes_needed;
+
+    s->header_bits = get_bits_diff(s);
+    // Estimate the total size first
+    for (i = 0; i < m->huff_ncode; i++) {
+        table_id = m->huff_buffer[i].table_id;
+        code = m->huff_buffer[i].code;
+        nbits = code & 0xf;
+
+        total_bits += huff_size[table_id][code] + nbits;
+    }
+
+    bytes_needed = (total_bits + 7) / 8;
+    ff_mpv_reallocate_putbitbuffer(s, bytes_needed, bytes_needed);
+
+    for (i = 0; i < m->huff_ncode; i++) {
+        table_id = m->huff_buffer[i].table_id;
+        code = m->huff_buffer[i].code;
+        nbits = code & 0xf;
+
+        put_bits(&s->pb, huff_size[table_id][code], huff_code[table_id][code]);
+        if (nbits != 0) {
+            put_sbits(&s->pb, nbits, m->huff_buffer[i].mant);
+        }
+    }
+
+    m->huff_ncode = 0;
+    s->i_tex_bits = get_bits_diff(s);
+}
+
 void ff_mjpeg_escape_FF(PutBitContext *pb, int start)
 {
     int size;
@@ -372,14 +466,106 @@ void ff_mjpeg_escape_FF(PutBitContext *pb, int start)
     }
 }
 
+/**
+ * Builds all 4 optimal Huffman tables.
+ *
+ * Uses the data stored in the JPEG buffer to compute the tables.
+ * Stores the Huffman tables in the bits_* and val_* arrays in the MJpegContext.
+ *
+ * @param m MJpegContext containing the JPEG buffer.
+ */
+static void ff_mjpeg_build_optimal_huffman(MJpegContext *m)
+{
+    int i, table_id, code;
+
+    MJpegEncHuffmanContext dc_luminance_ctx;
+    MJpegEncHuffmanContext dc_chrominance_ctx;
+    MJpegEncHuffmanContext ac_luminance_ctx;
+    MJpegEncHuffmanContext ac_chrominance_ctx;
+    MJpegEncHuffmanContext *ctx[4] = {&dc_luminance_ctx,
+                                      &dc_chrominance_ctx,
+                                      &ac_luminance_ctx,
+                                      &ac_chrominance_ctx};
+    for (i = 0; i < 4; i++) {
+        ff_mjpeg_encode_huffman_init(ctx[i]);
+    }
+    for (i = 0; i < m->huff_ncode; i++) {
+        table_id = m->huff_buffer[i].table_id;
+        code = m->huff_buffer[i].code;
+
+        ff_mjpeg_encode_huffman_increment(ctx[table_id], code);
+    }
+
+    ff_mjpeg_encode_huffman_close(&dc_luminance_ctx,
+                                  m->bits_dc_luminance,
+                                  m->val_dc_luminance, 12);
+    ff_mjpeg_encode_huffman_close(&dc_chrominance_ctx,
+                                  m->bits_dc_chrominance,
+                                  m->val_dc_chrominance, 12);
+    ff_mjpeg_encode_huffman_close(&ac_luminance_ctx,
+                                  m->bits_ac_luminance,
+                                  m->val_ac_luminance, 256);
+    ff_mjpeg_encode_huffman_close(&ac_chrominance_ctx,
+                                  m->bits_ac_chrominance,
+                                  m->val_ac_chrominance, 256);
+
+    ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance,
+                                 m->huff_code_dc_luminance,
+                                 m->bits_dc_luminance,
+                                 m->val_dc_luminance);
+    ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance,
+                                 m->huff_code_dc_chrominance,
+                                 m->bits_dc_chrominance,
+                                 m->val_dc_chrominance);
+    ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance,
+                                 m->huff_code_ac_luminance,
+                                 m->bits_ac_luminance,
+                                 m->val_ac_luminance);
+    ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance,
+                                 m->huff_code_ac_chrominance,
+                                 m->bits_ac_chrominance,
+                                 m->val_ac_chrominance);
+}
+
+/**
+ * Writes the complete JPEG frame when optimal huffman tables are enabled,
+ * otherwise writes the stuffing.
+ *
+ * Header + values + stuffing.
+ *
+ * @param s The MpegEncContext.
+ * @return int Error code, 0 if successful.
+ */
 int ff_mjpeg_encode_stuffing(MpegEncContext *s)
 {
     int i;
     PutBitContext *pbc = &s->pb;
     int mb_y = s->mb_y - !s->mb_x;
+    int ret;
+    MJpegContext *m;
+
+    m = s->mjpeg_ctx;
+
+    if (s->huffman == HUFFMAN_TABLE_OPTIMAL) {
+        ff_mjpeg_build_optimal_huffman(m);
+
+        // Replace the VLCs with the optimal ones.
+        // The default ones may be used for trellis during quantization.
+        ff_init_uni_ac_vlc(m->huff_size_ac_luminance,   m->uni_ac_vlc_len);
+        ff_init_uni_ac_vlc(m->huff_size_ac_chrominance, m->uni_chroma_ac_vlc_len);
+        s->intra_ac_vlc_length      =
+        s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
+        s->intra_chroma_ac_vlc_length      =
+        s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
+
+        ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
+                                       s->pred, s->intra_matrix, s->chroma_intra_matrix);
+        ff_mjpeg_encode_picture_frame(s);
+    }
+
+    ret = ff_mpv_reallocate_putbitbuffer(s, put_bits_count(&s->pb) / 8 + 100,
+                                            put_bits_count(&s->pb) / 4 + 1000);
 
-    int ret = ff_mpv_reallocate_putbitbuffer(s, put_bits_count(&s->pb) / 8 + 100,
-                                                put_bits_count(&s->pb) / 4 + 1000);
     if (ret < 0) {
         av_log(s->avctx, AV_LOG_ERROR, "Buffer reallocation failed\n");
         goto fail;
diff --git a/mythtv/external/FFmpeg/libavcodec/mjpegenc_common.h b/mythtv/external/FFmpeg/libavcodec/mjpegenc_common.h
index 6e51ca04f89..e8698d18c66 100644
--- a/mythtv/external/FFmpeg/libavcodec/mjpegenc_common.h
+++ b/mythtv/external/FFmpeg/libavcodec/mjpegenc_common.h
@@ -32,6 +32,7 @@ void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb,
                                     ScanTable *intra_scantable, int pred,
                                     uint16_t luma_intra_matrix[64],
                                     uint16_t chroma_intra_matrix[64]);
+void ff_mjpeg_encode_picture_frame(MpegEncContext *s);
 void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits);
 void ff_mjpeg_escape_FF(PutBitContext *pb, int start);
 int ff_mjpeg_encode_stuffing(MpegEncContext *s);
@@ -40,4 +41,6 @@ void ff_mjpeg_init_hvsample(AVCodecContext *avctx, int hsample[4], int vsample[4
 void ff_mjpeg_encode_dc(PutBitContext *pb, int val,
                         uint8_t *huff_size, uint16_t *huff_code);
 
+av_cold void ff_init_uni_ac_vlc(const uint8_t huff_size_ac[256], uint8_t *uni_ac_vlc_len);
+
 #endif /* AVCODEC_MJPEGENC_COMMON_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/mjpegenc_huffman.c b/mythtv/external/FFmpeg/libavcodec/mjpegenc_huffman.c
new file mode 100644
index 00000000000..0e63f8066b5
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mjpegenc_huffman.c
@@ -0,0 +1,192 @@
+/*
+ * MJPEG encoder
+ * Copyright (c) 2016 William Ma, Ted Ying, Jerry Jiang
+ *
+ * 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 <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "libavutil/avassert.h"
+#include "libavutil/common.h"
+#include "libavutil/error.h"
+#include "libavutil/qsort.h"
+#include "mjpegenc_huffman.h"
+
+/**
+ * Comparison function for two PTables by prob
+ *
+ * @param a First PTable to compare
+ * @param b Second PTable to compare
+ * @return < 0 for less than, 0 for equals, > 0 for greater than
+ */
+static int compare_by_prob(const void *a, const void *b)
+{
+    PTable a_val = *(PTable *) a;
+    PTable b_val = *(PTable *) b;
+    return a_val.prob - b_val.prob;
+}
+
+/**
+ * Comparison function for two HuffTables by length
+ *
+ * @param a First HuffTable to compare
+ * @param b Second HuffTable to compare
+ * @return < 0 for less than, 0 for equals, > 0 for greater than
+ */
+static int compare_by_length(const void *a, const void *b)
+{
+    HuffTable a_val = *(HuffTable *) a;
+    HuffTable b_val = *(HuffTable *) b;
+    return a_val.length - b_val.length;
+}
+
+/**
+ * Computes the length of the Huffman encoding for each distinct input value.
+ * Uses package merge algorithm as follows:
+ * 1. start with an empty list, lets call it list(0), set i = 0
+ * 2. add 1 entry to list(i) for each symbol we have and give each a score equal to the probability of the respective symbol
+ * 3. merge the 2 symbols of least score and put them in list(i+1), and remove them from list(i). The new score will be the sum of the 2 scores
+ * 4. if there is more than 1 symbol left in the current list(i), then goto 3
+ * 5. i++
+ * 6. if i < 16 goto 2
+ * 7. select the n-1 elements in the last list with the lowest score (n = the number of symbols)
+ * 8. the length of the huffman code for symbol s will be equal to the number of times the symbol occurs in the select elements
+ * Go to guru.multimedia.cx/small-tasks-for-ffmpeg/ for more details
+ *
+ * All probabilities should be positive integers. The output is sorted by code,
+ * not by length.
+ *
+ * @param prob_table input array of a PTable for each distinct input value
+ * @param distincts  output array of a HuffTable that will be populated by this function
+ * @param size       size of the prob_table array
+ * @param max_length max length of an encoding
+ */
+void ff_mjpegenc_huffman_compute_bits(PTable *prob_table, HuffTable *distincts, int size, int max_length)
+{
+    PackageMergerList list_a, list_b, *to = &list_a, *from = &list_b, *temp;
+
+    int times, i, j, k;
+
+    int nbits[257] = {0};
+
+    int min;
+
+    av_assert0(max_length > 0);
+
+    to->nitems = 0;
+    from->nitems = 0;
+    to->item_idx[0] = 0;
+    from->item_idx[0] = 0;
+    AV_QSORT(prob_table, size, PTable, compare_by_prob);
+
+    for (times = 0; times <= max_length; times++) {
+        to->nitems = 0;
+        to->item_idx[0] = 0;
+
+        j = 0;
+        k = 0;
+
+        if (times < max_length) {
+            i = 0;
+        }
+        while (i < size || j + 1 < from->nitems) {
+            to->nitems++;
+            to->item_idx[to->nitems] = to->item_idx[to->nitems - 1];
+            if (i < size &&
+                (j + 1 >= from->nitems ||
+                 prob_table[i].prob <
+                     from->probability[j] + from->probability[j + 1])) {
+                to->items[to->item_idx[to->nitems]++] = prob_table[i].value;
+                to->probability[to->nitems - 1] = prob_table[i].prob;
+                i++;
+            } else {
+                for (k = from->item_idx[j]; k < from->item_idx[j + 2]; k++) {
+                    to->items[to->item_idx[to->nitems]++] = from->items[k];
+                }
+                to->probability[to->nitems - 1] =
+                    from->probability[j] + from->probability[j + 1];
+                j += 2;
+            }
+        }
+        temp = to;
+        to = from;
+        from = temp;
+    }
+
+    min = (size - 1 < from->nitems) ? size - 1 : from->nitems;
+    for (i = 0; i < from->item_idx[min]; i++) {
+        nbits[from->items[i]]++;
+    }
+    // we don't want to return the 256 bit count (it was just in here to prevent
+    // all 1s encoding)
+    j = 0;
+    for (i = 0; i < 256; i++) {
+        if (nbits[i] > 0) {
+            distincts[j].code = i;
+            distincts[j].length = nbits[i];
+            j++;
+        }
+    }
+}
+
+void ff_mjpeg_encode_huffman_init(MJpegEncHuffmanContext *s)
+{
+    memset(s->val_count, 0, sizeof(s->val_count));
+}
+
+/**
+ * Produces a Huffman encoding with a given input
+ *
+ * @param s         input to encode
+ * @param bits      output array where the ith character represents how many input values have i length encoding
+ * @param val       output array of input values sorted by their encoded length
+ * @param max_nval  maximum number of distinct input values
+ */
+void ff_mjpeg_encode_huffman_close(MJpegEncHuffmanContext *s, uint8_t bits[17],
+                                   uint8_t val[], int max_nval)
+{
+    int i, j;
+    int nval = 0;
+    PTable val_counts[257];
+    HuffTable distincts[256];
+
+    for (i = 0; i < 256; i++) {
+        if (s->val_count[i]) nval++;
+    }
+    av_assert0 (nval <= max_nval);
+
+    j = 0;
+    for (i = 0; i < 256; i++) {
+        if (s->val_count[i]) {
+            val_counts[j].value = i;
+            val_counts[j].prob = s->val_count[i];
+            j++;
+        }
+    }
+    val_counts[j].value = 256;
+    val_counts[j].prob = 0;
+    ff_mjpegenc_huffman_compute_bits(val_counts, distincts, nval + 1, 16);
+    AV_QSORT(distincts, nval, HuffTable, compare_by_length);
+
+    memset(bits, 0, sizeof(bits[0]) * 17);
+    for (i = 0; i < nval; i++) {
+        val[i] = distincts[i].code;
+        bits[distincts[i].length]++;
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/mjpegenc_huffman.h b/mythtv/external/FFmpeg/libavcodec/mjpegenc_huffman.h
new file mode 100644
index 00000000000..5fe65504e42
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mjpegenc_huffman.h
@@ -0,0 +1,76 @@
+/*
+ * MJPEG encoder
+ * Copyright (c) 2016 William Ma, Ted Ying, Jerry Jiang
+ *
+ * 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
+ * Huffman table generation for MJPEG encoder.
+ */
+
+#ifndef AVCODEC_MJPEGENC_HUFFMAN_H
+#define AVCODEC_MJPEGENC_HUFFMAN_H
+
+#include <stdint.h>
+
+typedef struct MJpegEncHuffmanContext {
+    int val_count[256];
+} MJpegEncHuffmanContext;
+
+// Uses the package merge algorithm to compute the Huffman table.
+void ff_mjpeg_encode_huffman_init(MJpegEncHuffmanContext *s);
+static inline void ff_mjpeg_encode_huffman_increment(MJpegEncHuffmanContext *s,
+                                                     uint8_t val)
+{
+    s->val_count[val]++;
+}
+void ff_mjpeg_encode_huffman_close(MJpegEncHuffmanContext *s,
+                                   uint8_t bits[17], uint8_t val[],
+                                   int max_nval);
+
+
+/**
+ * Used to assign a occurrence count or "probability" to an input value
+ */
+typedef struct PTable {
+    int value;  ///< input value
+    int prob;   ///< number of occurences of this value in input
+} PTable;
+
+/**
+ * Used to store intermediate lists in the package merge algorithm
+ */
+typedef struct PackageMergerList {
+    int nitems;             ///< number of items in the list and probability      ex. 4
+    int item_idx[515];      ///< index range for each item in items                   0, 2, 5, 9, 13
+    int probability[514];   ///< probability of each item                             3, 8, 18, 46
+    int items[257 * 16];    ///< chain of all individual values that make up items    A, B, A, B, C, A, B, C, D, C, D, D, E
+} PackageMergerList;
+
+/**
+ * Used to store optimal huffman encoding results
+ */
+typedef struct HuffTable {
+    int code;       ///< code is the input value
+    int length;     ///< length of the encoding
+} HuffTable;
+
+void ff_mjpegenc_huffman_compute_bits(PTable *prob_table, HuffTable *distincts,
+                                      int size, int max_length);
+#endif /* AVCODEC_MJPEGENC_HUFFMAN_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/mlpdec.c b/mythtv/external/FFmpeg/libavcodec/mlpdec.c
index c93b058dd7a..d5585d30807 100644
--- a/mythtv/external/FFmpeg/libavcodec/mlpdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/mlpdec.c
@@ -264,7 +264,7 @@ static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
             result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
 
         result  += cp->sign_huff_offset;
-        result <<= quant_step_size;
+        result *= 1 << quant_step_size;
 
         m->sample_buffer[pos + s->blockpos][channel] = result;
     }
@@ -684,7 +684,7 @@ static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
         }
 
         for (i = 0; i < order; i++)
-            fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;
+            fcoeff[i] = get_sbits(gbp, coeff_bits) * (1 << coeff_shift);
 
         if (get_bits1(gbp)) {
             int state_bits, state_shift;
@@ -701,7 +701,7 @@ static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
             /* TODO: Check validity of state data. */
 
             for (i = 0; i < order; i++)
-                fp->state[i] = state_bits ? get_sbits(gbp, state_bits) << state_shift : 0;
+                fp->state[i] = state_bits ? get_sbits(gbp, state_bits) * (1 << state_shift) : 0;
         }
     }
 
@@ -729,7 +729,7 @@ static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitCo
         av_log(m->avctx, AV_LOG_ERROR,
                "Number of primitive matrices cannot be greater than %d.\n",
                max_primitive_matrices);
-        return AVERROR_INVALIDDATA;
+        goto error;
     }
 
     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
@@ -742,12 +742,12 @@ static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitCo
             av_log(m->avctx, AV_LOG_ERROR,
                     "Invalid channel %d specified as output from matrix.\n",
                     s->matrix_out_ch[mat]);
-            return AVERROR_INVALIDDATA;
+            goto error;
         }
         if (frac_bits > 14) {
             av_log(m->avctx, AV_LOG_ERROR,
                     "Too many fractional bits specified.\n");
-            return AVERROR_INVALIDDATA;
+            goto error;
         }
 
         max_chan = s->max_matrix_channel;
@@ -759,7 +759,7 @@ static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitCo
             if (get_bits1(gbp))
                 coeff_val = get_sbits(gbp, frac_bits + 2);
 
-            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
+            s->matrix_coeff[mat][ch] = coeff_val * (1 << (14 - frac_bits));
         }
 
         if (s->noise_type)
@@ -769,6 +769,11 @@ static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitCo
     }
 
     return 0;
+error:
+    s->num_primitive_matrices = 0;
+    memset(s->matrix_out_ch, 0, sizeof(s->matrix_out_ch));
+
+    return AVERROR_INVALIDDATA;
 }
 
 /** Read channel parameters. */
@@ -824,8 +829,6 @@ static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
         return AVERROR_INVALIDDATA;
     }
 
-    cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
-
     return 0;
 }
 
@@ -837,7 +840,8 @@ static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
 {
     SubStream *s = &m->substream[substr];
     unsigned int ch;
-    int ret;
+    int ret = 0;
+    unsigned recompute_sho = 0;
 
     if (s->param_presence_flags & PARAM_PRESENCE)
         if (get_bits1(gbp))
@@ -860,8 +864,13 @@ static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
 
     if (s->param_presence_flags & PARAM_OUTSHIFT)
         if (get_bits1(gbp)) {
-            for (ch = 0; ch <= s->max_matrix_channel; ch++)
+            for (ch = 0; ch <= s->max_matrix_channel; ch++) {
                 s->output_shift[ch] = get_sbits(gbp, 4);
+                if (s->output_shift[ch] < 0) {
+                    avpriv_request_sample(m->avctx, "Negative output_shift");
+                    s->output_shift[ch] = 0;
+                }
+            }
             if (substr == m->max_decoded_substream)
                 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
                                                                        s->output_shift,
@@ -872,19 +881,36 @@ static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
     if (s->param_presence_flags & PARAM_QUANTSTEP)
         if (get_bits1(gbp))
             for (ch = 0; ch <= s->max_channel; ch++) {
-                ChannelParams *cp = &s->channel_params[ch];
-
                 s->quant_step_size[ch] = get_bits(gbp, 4);
 
-                cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
+                recompute_sho |= 1<<ch;
             }
 
     for (ch = s->min_channel; ch <= s->max_channel; ch++)
-        if (get_bits1(gbp))
+        if (get_bits1(gbp)) {
+            recompute_sho |= 1<<ch;
             if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
-                return ret;
+                goto fail;
+        }
 
-    return 0;
+
+fail:
+    for (ch = 0; ch <= s->max_channel; ch++) {
+        if (recompute_sho & (1<<ch)) {
+            ChannelParams *cp = &s->channel_params[ch];
+
+            if (cp->codebook > 0 && cp->huff_lsbs < s->quant_step_size[ch]) {
+                if (ret >= 0) {
+                    av_log(m->avctx, AV_LOG_ERROR, "quant_step_size larger than huff_lsbs\n");
+                    ret = AVERROR_INVALIDDATA;
+                }
+                s->quant_step_size[ch] = 0;
+            }
+
+            cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
+        }
+    }
+    return ret;
 }
 
 #define MSB_MASK(bits)  (-1u << (bits))
@@ -999,8 +1025,8 @@ static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
 
     for (i = 0; i < s->blockpos; i++) {
         uint16_t seed_shr7 = seed >> 7;
-        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
-        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
+        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) * (1 << s->noise_shift);
+        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   * (1 << s->noise_shift);
 
         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
     }
@@ -1162,6 +1188,11 @@ static int read_access_unit(AVCodecContext *avctx, void* data,
             substr_header_size += 2;
         }
 
+        if (length < header_size + substr_header_size) {
+            av_log(m->avctx, AV_LOG_ERROR, "Insuffient data for headers\n");
+            goto error;
+        }
+
         if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
             av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
             goto error;
diff --git a/mythtv/external/FFmpeg/libavcodec/mlpdsp.c b/mythtv/external/FFmpeg/libavcodec/mlpdsp.c
index 3ae8c377081..32a4503b64e 100644
--- a/mythtv/external/FFmpeg/libavcodec/mlpdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/mlpdsp.c
@@ -113,11 +113,11 @@ int32_t ff_mlp_pack_output(int32_t lossless_check_data,
     for (i = 0; i < blockpos; i++) {
         for (out_ch = 0; out_ch <= max_matrix_channel; out_ch++) {
             int mat_ch = ch_assign[out_ch];
-            int32_t sample = sample_buffer[i][mat_ch]
-                          << output_shift[mat_ch];
+            int32_t sample = sample_buffer[i][mat_ch] *
+                          (1U << output_shift[mat_ch]);
             lossless_check_data ^= (sample & 0xffffff) << mat_ch;
             if (is32)
-                *data_32++ = sample << 8;
+                *data_32++ = sample * 256U;
             else
                 *data_16++ = sample >> 8;
         }
diff --git a/mythtv/external/FFmpeg/libavcodec/mlz.c b/mythtv/external/FFmpeg/libavcodec/mlz.c
index a2d1b89cbca..ebce796ba52 100644
--- a/mythtv/external/FFmpeg/libavcodec/mlz.c
+++ b/mythtv/external/FFmpeg/libavcodec/mlz.c
@@ -166,6 +166,10 @@ int ff_mlz_decompression(MLZ* mlz, GetBitContext* gb, int size, unsigned char *b
                         }
                         output_chars += ret;
                         set_new_entry_dict(dict, mlz->next_code, last_string_code, char_code);
+                        if (mlz->next_code >= TABLE_SIZE - 1) {
+                            av_log(mlz->context, AV_LOG_ERROR, "Too many MLZ codes\n");
+                            return output_chars;
+                        }
                         mlz->next_code++;
                     } else {
                         int ret = decode_string(mlz, &buff[output_chars], string_code, &char_code, size - output_chars);
@@ -177,6 +181,10 @@ int ff_mlz_decompression(MLZ* mlz, GetBitContext* gb, int size, unsigned char *b
                         if (output_chars <= size && !mlz->freeze_flag) {
                             if (last_string_code != -1) {
                                 set_new_entry_dict(dict, mlz->next_code, last_string_code, char_code);
+                                if (mlz->next_code >= TABLE_SIZE - 1) {
+                                    av_log(mlz->context, AV_LOG_ERROR, "Too many MLZ codes\n");
+                                    return output_chars;
+                                }
                                 mlz->next_code++;
                             }
                         } else {
diff --git a/mythtv/external/FFmpeg/libavcodec/mmaldec.c b/mythtv/external/FFmpeg/libavcodec/mmaldec.c
index 3f92bf5ec9b..0b1195dc3e6 100644
--- a/mythtv/external/FFmpeg/libavcodec/mmaldec.c
+++ b/mythtv/external/FFmpeg/libavcodec/mmaldec.c
@@ -31,10 +31,10 @@
 #include <interface/mmal/util/mmal_util_params.h>
 #include <interface/mmal/util/mmal_default_components.h>
 #include <interface/mmal/vc/mmal_vc_api.h>
+#include <stdatomic.h>
 
 #include "avcodec.h"
 #include "internal.h"
-#include "libavutil/atomic.h"
 #include "libavutil/avassert.h"
 #include "libavutil/buffer.h"
 #include "libavutil/common.h"
@@ -55,7 +55,7 @@ typedef struct FFBufferEntry {
 // refcounting for AVFrames, we can free the MMAL_POOL_T only after all AVFrames
 // have been unreferenced.
 typedef struct FFPoolRef {
-    volatile int refcount;
+    atomic_int refcount;
     MMAL_POOL_T *pool;
 } FFPoolRef;
 
@@ -83,7 +83,7 @@ typedef struct MMALDecodeContext {
     FFBufferEntry *waiting_buffers, *waiting_buffers_tail;
 
     int64_t packets_sent;
-    volatile int packets_buffered;
+    atomic_int packets_buffered;
     int64_t frames_output;
     int eos_received;
     int eos_sent;
@@ -98,7 +98,8 @@ typedef struct MMALDecodeContext {
 
 static void ffmmal_poolref_unref(FFPoolRef *ref)
 {
-    if (ref && avpriv_atomic_int_add_and_fetch(&ref->refcount, -1) == 0) {
+    if (ref &&
+        atomic_fetch_add_explicit(&ref->refcount, -1, memory_order_acq_rel) == 1) {
         mmal_pool_destroy(ref->pool);
         av_free(ref);
     }
@@ -134,7 +135,7 @@ static int ffmmal_set_ref(AVFrame *frame, FFPoolRef *pool,
         return AVERROR(ENOMEM);
     }
 
-    avpriv_atomic_int_add_and_fetch(&ref->pool->refcount, 1);
+    atomic_fetch_add_explicit(&ref->pool->refcount, 1, memory_order_relaxed);
     mmal_buffer_header_acquire(buffer);
 
     frame->format = AV_PIX_FMT_MMAL;
@@ -165,14 +166,14 @@ static void ffmmal_stop_decoder(AVCodecContext *avctx)
         ctx->waiting_buffers = buffer->next;
 
         if (buffer->flags & MMAL_BUFFER_HEADER_FLAG_FRAME_END)
-            avpriv_atomic_int_add_and_fetch(&ctx->packets_buffered, -1);
+            atomic_fetch_add(&ctx->packets_buffered, -1);
 
         av_buffer_unref(&buffer->ref);
         av_free(buffer);
     }
     ctx->waiting_buffers_tail = NULL;
 
-    av_assert0(avpriv_atomic_int_get(&ctx->packets_buffered) == 0);
+    av_assert0(atomic_load(&ctx->packets_buffered) == 0);
 
     ctx->frames_output = ctx->eos_received = ctx->eos_sent = ctx->packets_sent = ctx->extradata_sent = 0;
 }
@@ -204,7 +205,7 @@ static void input_callback(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
         FFBufferEntry *entry = buffer->user_data;
         av_buffer_unref(&entry->ref);
         if (entry->flags & MMAL_BUFFER_HEADER_FLAG_FRAME_END)
-            avpriv_atomic_int_add_and_fetch(&ctx->packets_buffered, -1);
+            atomic_fetch_add(&ctx->packets_buffered, -1);
         av_free(entry);
     }
     mmal_buffer_header_release(buffer);
@@ -227,9 +228,8 @@ static void control_port_cb(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer)
         status = *(uint32_t *)buffer->data;
         av_log(avctx, AV_LOG_ERROR, "MMAL error %d on control port\n", (int)status);
     } else {
-        char s[20];
-        av_get_codec_tag_string(s, sizeof(s), buffer->cmd);
-        av_log(avctx, AV_LOG_WARNING, "Unknown MMAL event %s on control port\n", s);
+        av_log(avctx, AV_LOG_WARNING, "Unknown MMAL event %s on control port\n",
+               av_fourcc2str(buffer->cmd));
     }
 
     mmal_buffer_header_release(buffer);
@@ -283,7 +283,7 @@ static int ffmal_update_format(AVCodecContext *avctx)
         ret = AVERROR(ENOMEM);
         goto fail;
     }
-    ctx->pool_out->refcount = 1;
+    atomic_init(&ctx->pool_out->refcount, 1);
 
     if (!format_out)
         goto fail;
@@ -351,7 +351,6 @@ static av_cold int ffmmal_init_decoder(AVCodecContext *avctx)
     MMAL_STATUS_T status;
     MMAL_ES_FORMAT_T *format_in;
     MMAL_COMPONENT_T *decoder;
-    char tmp[32];
     int ret = 0;
 
     bcm_host_init();
@@ -398,8 +397,8 @@ static av_cold int ffmmal_init_decoder(AVCodecContext *avctx)
     format_in->es->video.par.den = avctx->sample_aspect_ratio.den;
     format_in->flags = MMAL_ES_FORMAT_FLAG_FRAMED;
 
-    av_get_codec_tag_string(tmp, sizeof(tmp), format_in->encoding);
-    av_log(avctx, AV_LOG_DEBUG, "Using MMAL %s encoding.\n", tmp);
+    av_log(avctx, AV_LOG_DEBUG, "Using MMAL %s encoding.\n",
+           av_fourcc2str(format_in->encoding));
 
 #if HAVE_MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS
     if (mmal_port_parameter_set_uint32(decoder->input[0], MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS,
@@ -542,7 +541,7 @@ static int ffmmal_add_packet(AVCodecContext *avctx, AVPacket *avpkt,
 
         if (!size) {
             buffer->flags |= MMAL_BUFFER_HEADER_FLAG_FRAME_END;
-            avpriv_atomic_int_add_and_fetch(&ctx->packets_buffered, 1);
+            atomic_fetch_add(&ctx->packets_buffered, 1);
         }
 
         if (!buffer->length) {
@@ -607,7 +606,7 @@ static int ffmmal_fill_input_port(AVCodecContext *avctx)
             mmal_buffer_header_release(mbuffer);
             av_buffer_unref(&buffer->ref);
             if (buffer->flags & MMAL_BUFFER_HEADER_FLAG_FRAME_END)
-                avpriv_atomic_int_add_and_fetch(&ctx->packets_buffered, -1);
+                atomic_fetch_add(&ctx->packets_buffered, -1);
             av_free(buffer);
         }
 
@@ -689,7 +688,7 @@ static int ffmmal_read_frame(AVCodecContext *avctx, AVFrame *frame, int *got_fra
         // excessive buffering.
         // We also wait if we sent eos, but didn't receive it yet (think of decoding
         // stream with a very low number of frames).
-        if (avpriv_atomic_int_get(&ctx->packets_buffered) > MAX_DELAYED_FRAMES ||
+        if (atomic_load(&ctx->packets_buffered) > MAX_DELAYED_FRAMES ||
             (ctx->packets_sent && ctx->eos_sent)) {
             // MMAL will ignore broken input packets, which means the frame we
             // expect here may never arrive. Dealing with this correctly is
@@ -741,9 +740,8 @@ static int ffmmal_read_frame(AVCodecContext *avctx, AVFrame *frame, int *got_fra
             mmal_buffer_header_release(buffer);
             continue;
         } else if (buffer->cmd) {
-            char s[20];
-            av_get_codec_tag_string(s, sizeof(s), buffer->cmd);
-            av_log(avctx, AV_LOG_WARNING, "Unknown MMAL event %s on output port\n", s);
+            av_log(avctx, AV_LOG_WARNING, "Unknown MMAL event %s on output port\n",
+                   av_fourcc2str(buffer->cmd));
             goto done;
         } else if (buffer->length == 0) {
             // Unused output buffer that got drained after format change.
diff --git a/mythtv/external/FFmpeg/libavcodec/motion_est.c b/mythtv/external/FFmpeg/libavcodec/motion_est.c
index 25b606f8195..316d16a77b8 100644
--- a/mythtv/external/FFmpeg/libavcodec/motion_est.c
+++ b/mythtv/external/FFmpeg/libavcodec/motion_est.c
@@ -956,10 +956,10 @@ void ff_estimate_p_frame_motion(MpegEncContext * s,
             P_TOPRIGHT[1] = s->current_picture.motion_val[0][mot_xy - mot_stride + 2][1];
             if (P_TOP[1] > (c->ymax << shift))
                 P_TOP[1] =  c->ymax << shift;
-            if (P_TOPRIGHT[0] < (c->xmin << shift))
-                P_TOPRIGHT[0] =  c->xmin << shift;
-            if (P_TOPRIGHT[1] > (c->ymax << shift))
-                P_TOPRIGHT[1] =  c->ymax << shift;
+            if (P_TOPRIGHT[0] < (c->xmin * (1 << shift)))
+                P_TOPRIGHT[0] =  c->xmin * (1 << shift);
+            if (P_TOPRIGHT[1] > (c->ymax * (1 << shift)))
+                P_TOPRIGHT[1] =  c->ymax * (1 << shift);
 
             P_MEDIAN[0] = mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
             P_MEDIAN[1] = mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
diff --git a/mythtv/external/FFmpeg/libavcodec/movtextdec.c b/mythtv/external/FFmpeg/libavcodec/movtextdec.c
index a33fff7518c..fb5085c3e82 100644
--- a/mythtv/external/FFmpeg/libavcodec/movtextdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/movtextdec.c
@@ -116,6 +116,8 @@ static void mov_text_cleanup(MovTextContext *m)
             av_freep(&m->s[i]);
         }
         av_freep(&m->s);
+        m->count_s = 0;
+        m->style_entries = 0;
     }
 }
 
@@ -279,12 +281,14 @@ static int decode_hclr(const uint8_t *tsmb, MovTextContext *m, AVPacket *avpkt)
 static int decode_styl(const uint8_t *tsmb, MovTextContext *m, AVPacket *avpkt)
 {
     int i;
-    m->style_entries = AV_RB16(tsmb);
+    int style_entries = AV_RB16(tsmb);
     tsmb += 2;
     // A single style record is of length 12 bytes.
-    if (m->tracksize + m->size_var + 2 + m->style_entries * 12 > avpkt->size)
+    if (m->tracksize + m->size_var + 2 + style_entries * 12 > avpkt->size)
         return -1;
 
+    m->style_entries = style_entries;
+
     m->box_flags |= STYL_BOX;
     for(i = 0; i < m->style_entries; i++) {
         m->s_temp = av_malloc(sizeof(*m->s_temp));
@@ -455,6 +459,8 @@ static int mov_text_decode_frame(AVCodecContext *avctx,
     end = ptr + FFMIN(2 + text_length, avpkt->size);
     ptr += 2;
 
+    mov_text_cleanup(m);
+
     tsmb_size = 0;
     m->tracksize = 2 + text_length;
     m->style_entries = 0;
@@ -471,10 +477,6 @@ static int mov_text_decode_frame(AVCodecContext *avctx,
             tsmb_type = AV_RB32(tsmb);
             tsmb += 4;
 
-            if (tsmb_size == 0) {
-              return AVERROR_INVALIDDATA;
-            }
-
             if (tsmb_size == 1) {
                 if (m->tracksize + 16 > avpkt->size)
                     break;
@@ -485,7 +487,12 @@ static int mov_text_decode_frame(AVCodecContext *avctx,
                 m->size_var = 8;
             //size_var is equal to 8 or 16 depending on the size of box
 
-            if (m->tracksize + tsmb_size > avpkt->size)
+            if (tsmb_size == 0) {
+                av_log(avctx, AV_LOG_ERROR, "tsmb_size is 0\n");
+                return AVERROR_INVALIDDATA;
+            }
+
+            if (tsmb_size > avpkt->size - m->tracksize)
                 break;
 
             for (size_t i = 0; i < box_count; i++) {
@@ -516,6 +523,7 @@ static int mov_text_decode_close(AVCodecContext *avctx)
 {
     MovTextContext *m = avctx->priv_data;
     mov_text_cleanup_ftab(m);
+    mov_text_cleanup(m);
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/movtextenc.c b/mythtv/external/FFmpeg/libavcodec/movtextenc.c
index 20e01e206e6..d795e317c3f 100644
--- a/mythtv/external/FFmpeg/libavcodec/movtextenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/movtextenc.c
@@ -57,6 +57,8 @@ typedef struct {
 } HilightcolorBox;
 
 typedef struct {
+    AVCodecContext *avctx;
+
     ASSSplitContext *ass_ctx;
     AVBPrint buffer;
     StyleBox **style_attributes;
@@ -187,6 +189,7 @@ static av_cold int mov_text_encode_init(AVCodecContext *avctx)
     };
 
     MovTextContext *s = avctx->priv_data;
+    s->avctx = avctx;
 
     avctx->extradata_size = sizeof text_sample_entry;
     avctx->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
@@ -247,6 +250,9 @@ static void mov_text_style_cb(void *priv, const char style, int close)
             s->style_attributes_temp->style_flag |= STYLE_FLAG_UNDERLINE;
             break;
         }
+    } else if (!s->style_attributes_temp) {
+        av_log(s->avctx, AV_LOG_WARNING, "Ignoring unmatched close tag\n");
+        return;
     } else {
         s->style_attributes_temp->style_end = AV_RB16(&s->text_pos);
         av_dynarray_add(&s->style_attributes, &s->count, s->style_attributes_temp);
diff --git a/mythtv/external/FFmpeg/libavcodec/mpc7.c b/mythtv/external/FFmpeg/libavcodec/mpc7.c
index d38b22a2b3c..e09f1b604f8 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpc7.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpc7.c
@@ -47,7 +47,7 @@ static const uint16_t quant_offsets[MPC7_QUANT_VLC_TABLES*2 + 1] =
 
 static av_cold int mpc7_decode_init(AVCodecContext * avctx)
 {
-    int i, j;
+    int i, j, ret;
     MPCContext *c = avctx->priv_data;
     GetBitContext gb;
     LOCAL_ALIGNED_16(uint8_t, buf, [16]);
@@ -66,7 +66,7 @@ static av_cold int mpc7_decode_init(AVCodecContext * avctx)
 
     if(avctx->extradata_size < 16){
         av_log(avctx, AV_LOG_ERROR, "Too small extradata size (%i)!\n", avctx->extradata_size);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
     memset(c->oldDSCF, 0, sizeof(c->oldDSCF));
     av_lfg_init(&c->rnd, 0xDEADBEEF);
@@ -81,7 +81,7 @@ static av_cold int mpc7_decode_init(AVCodecContext * avctx)
     c->maxbands = get_bits(&gb, 6);
     if(c->maxbands >= BANDS){
         av_log(avctx, AV_LOG_ERROR, "Too many bands: %i\n", c->maxbands);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
     skip_bits_long(&gb, 88);
     c->gapless = get_bits1(&gb);
@@ -97,37 +97,37 @@ static av_cold int mpc7_decode_init(AVCodecContext * avctx)
     av_log(avctx, AV_LOG_DEBUG, "Initing VLC\n");
     scfi_vlc.table = scfi_table;
     scfi_vlc.table_allocated = 1 << MPC7_SCFI_BITS;
-    if(init_vlc(&scfi_vlc, MPC7_SCFI_BITS, MPC7_SCFI_SIZE,
+    if ((ret = init_vlc(&scfi_vlc, MPC7_SCFI_BITS, MPC7_SCFI_SIZE,
                 &mpc7_scfi[1], 2, 1,
-                &mpc7_scfi[0], 2, 1, INIT_VLC_USE_NEW_STATIC)){
+                &mpc7_scfi[0], 2, 1, INIT_VLC_USE_NEW_STATIC))) {
         av_log(avctx, AV_LOG_ERROR, "Cannot init SCFI VLC\n");
-        return -1;
+        return ret;
     }
     dscf_vlc.table = dscf_table;
     dscf_vlc.table_allocated = 1 << MPC7_DSCF_BITS;
-    if(init_vlc(&dscf_vlc, MPC7_DSCF_BITS, MPC7_DSCF_SIZE,
+    if ((ret = init_vlc(&dscf_vlc, MPC7_DSCF_BITS, MPC7_DSCF_SIZE,
                 &mpc7_dscf[1], 2, 1,
-                &mpc7_dscf[0], 2, 1, INIT_VLC_USE_NEW_STATIC)){
+                &mpc7_dscf[0], 2, 1, INIT_VLC_USE_NEW_STATIC))) {
         av_log(avctx, AV_LOG_ERROR, "Cannot init DSCF VLC\n");
-        return -1;
+        return ret;
     }
     hdr_vlc.table = hdr_table;
     hdr_vlc.table_allocated = 1 << MPC7_HDR_BITS;
-    if(init_vlc(&hdr_vlc, MPC7_HDR_BITS, MPC7_HDR_SIZE,
+    if ((ret = init_vlc(&hdr_vlc, MPC7_HDR_BITS, MPC7_HDR_SIZE,
                 &mpc7_hdr[1], 2, 1,
-                &mpc7_hdr[0], 2, 1, INIT_VLC_USE_NEW_STATIC)){
+                &mpc7_hdr[0], 2, 1, INIT_VLC_USE_NEW_STATIC))) {
         av_log(avctx, AV_LOG_ERROR, "Cannot init HDR VLC\n");
-        return -1;
+        return ret;
     }
     for(i = 0; i < MPC7_QUANT_VLC_TABLES; i++){
         for(j = 0; j < 2; j++){
             quant_vlc[i][j].table = &quant_tables[quant_offsets[i*2 + j]];
             quant_vlc[i][j].table_allocated = quant_offsets[i*2 + j + 1] - quant_offsets[i*2 + j];
-            if(init_vlc(&quant_vlc[i][j], 9, mpc7_quant_vlc_sizes[i],
+            if ((ret = init_vlc(&quant_vlc[i][j], 9, mpc7_quant_vlc_sizes[i],
                         &mpc7_quant_vlc[i][j][1], 4, 2,
-                        &mpc7_quant_vlc[i][j][0], 4, 2, INIT_VLC_USE_NEW_STATIC)){
+                        &mpc7_quant_vlc[i][j][0], 4, 2, INIT_VLC_USE_NEW_STATIC))) {
                 av_log(avctx, AV_LOG_ERROR, "Cannot init QUANT VLC %i,%i\n",i,j);
-                return -1;
+                return ret;
             }
         }
     }
@@ -231,7 +231,8 @@ static int mpc7_decode_frame(AVCodecContext * avctx, void *data,
         return AVERROR(ENOMEM);
     c->bdsp.bswap_buf((uint32_t *) c->bits, (const uint32_t *) buf,
                       buf_size >> 2);
-    init_get_bits(&gb, c->bits, buf_size * 8);
+    if ((ret = init_get_bits8(&gb, c->bits, buf_size)) < 0)
+        return ret;
     skip_bits_long(&gb, skip);
 
     /* read subband indexes */
@@ -298,7 +299,7 @@ static int mpc7_decode_frame(AVCodecContext * avctx, void *data,
     bits_avail = buf_size * 8;
     if (!last_frame && ((bits_avail < bits_used) || (bits_used + 32 <= bits_avail))) {
         av_log(avctx, AV_LOG_ERROR, "Error decoding frame: used %i of %i bits\n", bits_used, bits_avail);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
     if(c->frames_to_skip){
         c->frames_to_skip--;
diff --git a/mythtv/external/FFmpeg/libavcodec/mpc8.c b/mythtv/external/FFmpeg/libavcodec/mpc8.c
index 8894457c7e7..80e0e9e68df 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpc8.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpc8.c
@@ -261,7 +261,9 @@ static int mpc8_decode_frame(AVCodecContext * avctx, void *data,
         memset(c->Q, 0, sizeof(c->Q));
         c->last_bits_used = 0;
     }
-    init_get_bits(gb, buf, buf_size * 8);
+    if ((res = init_get_bits8(gb, buf, buf_size)) < 0)
+        return res;
+
     skip_bits(gb, c->last_bits_used & 7);
 
     if(keyframe)
diff --git a/mythtv/external/FFmpeg/libavcodec/mpeg12.c b/mythtv/external/FFmpeg/libavcodec/mpeg12.c
index a61d45b39a9..ab6c19c6151 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpeg12.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpeg12.c
@@ -67,20 +67,13 @@ static const uint8_t table_mb_btype[11][2] = {
     { 2, 5 }, // 0x1E MB_QUANT|MB_FOR|MB_BACK|MB_PAT
 };
 
-#define INIT_2D_VLC_RL(rl, static_size)\
-{\
-    static RL_VLC_ELEM rl_vlc_table[static_size];\
-    rl.rl_vlc[0] = rl_vlc_table;\
-    init_2d_vlc_rl(&rl, static_size);\
-}
-
-static av_cold void init_2d_vlc_rl(RLTable *rl, unsigned static_size)
+av_cold void ff_init_2d_vlc_rl(RLTable *rl, unsigned static_size, int flags)
 {
     int i;
     VLC_TYPE table[680][2] = {{0}};
     VLC vlc = { .table = table, .table_allocated = static_size };
     av_assert0(static_size <= FF_ARRAY_ELEMS(table));
-    init_vlc(&vlc, TEX_VLC_BITS, rl->n + 2, &rl->table_vlc[0][1], 4, 2, &rl->table_vlc[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC);
+    init_vlc(&vlc, TEX_VLC_BITS, rl->n + 2, &rl->table_vlc[0][1], 4, 2, &rl->table_vlc[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC | flags);
 
     for (i = 0; i < vlc.table_size; i++) {
         int code = vlc.table[i][0];
@@ -173,8 +166,8 @@ av_cold void ff_mpeg12_init_vlcs(void)
         ff_rl_init(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]);
         ff_rl_init(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]);
 
-        INIT_2D_VLC_RL(ff_rl_mpeg1, 680);
-        INIT_2D_VLC_RL(ff_rl_mpeg2, 674);
+        INIT_2D_VLC_RL(ff_rl_mpeg1, 680, 0);
+        INIT_2D_VLC_RL(ff_rl_mpeg2, 674, 0);
     }
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mpeg12.h b/mythtv/external/FFmpeg/libavcodec/mpeg12.h
index ad9b00c08ba..f551504b8cc 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpeg12.h
+++ b/mythtv/external/FFmpeg/libavcodec/mpeg12.h
@@ -29,6 +29,15 @@ extern uint8_t ff_mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3];
 
 void ff_mpeg12_common_init(MpegEncContext *s);
 
+#define INIT_2D_VLC_RL(rl, static_size, flags)\
+{\
+    static RL_VLC_ELEM rl_vlc_table[static_size];\
+    rl.rl_vlc[0] = rl_vlc_table;\
+    ff_init_2d_vlc_rl(&rl, static_size, flags);\
+}
+
+void ff_init_2d_vlc_rl(RLTable *rl, unsigned static_size, int flags);
+
 static inline int decode_dc(GetBitContext *gb, int component)
 {
     int code, diff;
diff --git a/mythtv/external/FFmpeg/libavcodec/mpeg12data.c b/mythtv/external/FFmpeg/libavcodec/mpeg12data.c
index 416bbb8129b..4da96d7da3f 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpeg12data.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpeg12data.c
@@ -305,26 +305,6 @@ const uint8_t ff_mpeg12_mbMotionVectorTable[17][2] = {
 { 0xc, 10 },
 };
 
-const AVRational ff_mpeg12_frame_rate_tab[16] = {
-    {    0,    0},
-    {24000, 1001},
-    {   24,    1},
-    {   25,    1},
-    {30000, 1001},
-    {   30,    1},
-    {   50,    1},
-    {60000, 1001},
-    {   60,    1},
-  // Xing's 15fps: (9)
-    {   15,    1},
-  // libmpeg3's "Unofficial economy rates": (10-13)
-    {    5,    1},
-    {   10,    1},
-    {   12,    1},
-    {   15,    1},
-    {    0,    0},
-};
-
 const AVRational ff_mpeg2_frame_rate_tab[] = {
     {      1,     1},
     {      2,     1},
diff --git a/mythtv/external/FFmpeg/libavcodec/mpeg12dec.c b/mythtv/external/FFmpeg/libavcodec/mpeg12dec.c
index dc18083facc..d37859b13ab 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpeg12dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpeg12dec.c
@@ -497,7 +497,7 @@ static inline int mpeg2_decode_block_intra(MpegEncContext *s,
     dc  = s->last_dc[component];
     dc += diff;
     s->last_dc[component] = dc;
-    block[0] = dc << (3 - s->intra_dc_precision);
+    block[0] = dc * (1 << (3 - s->intra_dc_precision));
     ff_tlog(s->avctx, "dc=%d\n", block[0]);
     mismatch = block[0] ^ 1;
     i = 0;
@@ -865,8 +865,8 @@ static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
                                                    s->last_mv[i][0][1]);
                             /* full_pel: only for MPEG-1 */
                             if (s->full_pel[i]) {
-                                s->mv[i][0][0] <<= 1;
-                                s->mv[i][0][1] <<= 1;
+                                s->mv[i][0][0] *= 2;
+                                s->mv[i][0][1] *= 2;
                             }
                         }
                     }
@@ -948,8 +948,8 @@ static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
                         dmy = get_dmv(s);
 
 
-                        s->last_mv[i][0][1] = my << my_shift;
-                        s->last_mv[i][1][1] = my << my_shift;
+                        s->last_mv[i][0][1] = my * (1 << my_shift);
+                        s->last_mv[i][1][1] = my * (1 << my_shift);
 
                         s->mv[i][0][0] = mx;
                         s->mv[i][0][1] = my;
@@ -994,7 +994,7 @@ static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
 
             cbp = get_vlc2(&s->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
             if (mb_block_count > 6) {
-                cbp <<= mb_block_count - 6;
+                cbp *= 1 << mb_block_count - 6;
                 cbp  |= get_bits(&s->gb, mb_block_count - 6);
                 s->bdsp.clear_blocks(s->block[6]);
             }
@@ -1159,6 +1159,7 @@ static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = {
 #endif
 #if CONFIG_MPEG2_D3D11VA_HWACCEL
     AV_PIX_FMT_D3D11VA_VLD,
+    AV_PIX_FMT_D3D11,
 #endif
 #if CONFIG_MPEG2_VAAPI_HWACCEL
     AV_PIX_FMT_VAAPI,
@@ -1216,7 +1217,7 @@ static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
 #endif
         )
         if (avctx->idct_algo == FF_IDCT_AUTO)
-            avctx->idct_algo = FF_IDCT_SIMPLE;
+            avctx->idct_algo = FF_IDCT_NONE;
 
     if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
         Mpeg1Context *s1 = avctx->priv_data;
@@ -1242,7 +1243,8 @@ static int mpeg_decode_postinit(AVCodecContext *avctx)
 
     if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
         // MPEG-1 aspect
-        avctx->sample_aspect_ratio = av_d2q(1.0 / ff_mpeg1_aspect[s->aspect_ratio_info], 255);
+        AVRational aspect_inv = av_d2q(ff_mpeg1_aspect[s->aspect_ratio_info], 255);
+        avctx->sample_aspect_ratio = (AVRational) { aspect_inv.den, aspect_inv.num };
     } else { // MPEG-2
         // MPEG-2 aspect
         if (s->aspect_ratio_info > 1) {
@@ -1655,7 +1657,6 @@ static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
             if (sd)
                 memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
             av_freep(&s1->a53_caption);
-            avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
         }
 
         if (s1->has_stereo3d) {
@@ -1867,7 +1868,7 @@ static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
         s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
         s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
 
-        ff_mpv_decode_mb(s, s->block);
+        ff_mpv_reconstruct_mb(s, s->block);
 
         if (++s->mb_x >= s->mb_width) {
             const int mb_size = 16 >> s->avctx->lowres;
@@ -2258,6 +2259,7 @@ static int mpeg_decode_a53_cc(AVCodecContext *avctx,
             s1->a53_caption      = av_malloc(s1->a53_caption_size);
             if (s1->a53_caption)
                 memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
+            avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
         }
         return 1;
     } else if (buf_size >= 11 &&
@@ -2313,6 +2315,7 @@ static int mpeg_decode_a53_cc(AVCodecContext *avctx,
                     p += 6;
                 }
             }
+            avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
         }
         return 1;
     }
@@ -2847,6 +2850,8 @@ static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
                     if (s2->pict_type == AV_PICTURE_TYPE_B) {
                         if (!s2->closed_gop) {
                             skip_frame = 1;
+                            av_log(s2->avctx, AV_LOG_DEBUG,
+                                   "Skipping B slice due to open GOP\n");
                             break;
                         }
                     }
@@ -2858,6 +2863,8 @@ static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
                      * we have an invalid header. */
                     if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
                         skip_frame = 1;
+                        av_log(s2->avctx, AV_LOG_DEBUG,
+                               "Skipping P slice due to !sync\n");
                         break;
                     }
                 }
@@ -3056,6 +3063,7 @@ AVCodec ff_mpeg1video_decoder = {
     .capabilities          = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
                              AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
                              AV_CODEC_CAP_SLICE_THREADS,
+    .caps_internal         = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .flush                 = flush,
     .max_lowres            = 3,
     .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
@@ -3073,6 +3081,7 @@ AVCodec ff_mpeg2video_decoder = {
     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
                       AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
                       AV_CODEC_CAP_SLICE_THREADS,
+    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .flush          = flush,
     .max_lowres     = 3,
     .profiles       = NULL_IF_CONFIG_SMALL(ff_mpeg2_video_profiles),
@@ -3089,6 +3098,7 @@ AVCodec ff_mpegvideo_decoder = {
     .close          = mpeg_decode_end,
     .decode         = mpeg_decode_frame,
     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
+    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .flush          = flush,
     .max_lowres     = 3,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/mpeg12framerate.c b/mythtv/external/FFmpeg/libavcodec/mpeg12framerate.c
new file mode 100644
index 00000000000..094cd180a5f
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mpeg12framerate.c
@@ -0,0 +1,39 @@
+/*
+ * 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/rational.h"
+
+const AVRational ff_mpeg12_frame_rate_tab[16] = {
+    {    0,    0},
+    {24000, 1001},
+    {   24,    1},
+    {   25,    1},
+    {30000, 1001},
+    {   30,    1},
+    {   50,    1},
+    {60000, 1001},
+    {   60,    1},
+  // Xing's 15fps: (9)
+    {   15,    1},
+  // libmpeg3's "Unofficial economy rates": (10-13)
+    {    5,    1},
+    {   10,    1},
+    {   12,    1},
+    {   15,    1},
+    {    0,    0},
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/mpeg4audio.c b/mythtv/external/FFmpeg/libavcodec/mpeg4audio.c
index 188d843eee6..b6bb3234400 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpeg4audio.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpeg4audio.c
@@ -33,15 +33,20 @@
 static int parse_config_ALS(GetBitContext *gb, MPEG4AudioConfig *c)
 {
     if (get_bits_left(gb) < 112)
-        return -1;
+        return AVERROR_INVALIDDATA;
 
     if (get_bits_long(gb, 32) != MKBETAG('A','L','S','\0'))
-        return -1;
+        return AVERROR_INVALIDDATA;
 
     // override AudioSpecificConfig channel configuration and sample rate
     // which are buggy in old ALS conformance files
     c->sample_rate = get_bits_long(gb, 32);
 
+    if (c->sample_rate <= 0) {
+        av_log(NULL, AV_LOG_ERROR, "Invalid sample rate %d\n", c->sample_rate);
+        return AVERROR_INVALIDDATA;
+    }
+
     // skip number of samples
     skip_bits_long(gb, 32);
 
@@ -78,69 +83,62 @@ static inline int get_sample_rate(GetBitContext *gb, int *index)
         avpriv_mpeg4audio_sample_rates[*index];
 }
 
-int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf,
-                                 int bit_size, int sync_extension)
+int ff_mpeg4audio_get_config_gb(MPEG4AudioConfig *c, GetBitContext *gb,
+                                int sync_extension)
 {
-    GetBitContext gb;
     int specific_config_bitindex, ret;
-
-    if (bit_size <= 0)
-        return AVERROR_INVALIDDATA;
-
-    ret = init_get_bits(&gb, buf, bit_size);
-    if (ret < 0)
-        return ret;
-
-    c->object_type = get_object_type(&gb);
-    c->sample_rate = get_sample_rate(&gb, &c->sampling_index);
-    c->chan_config = get_bits(&gb, 4);
+    int start_bit_index = get_bits_count(gb);
+    c->object_type = get_object_type(gb);
+    c->sample_rate = get_sample_rate(gb, &c->sampling_index);
+    c->chan_config = get_bits(gb, 4);
     if (c->chan_config < FF_ARRAY_ELEMS(ff_mpeg4audio_channels))
         c->channels = ff_mpeg4audio_channels[c->chan_config];
     c->sbr = -1;
     c->ps  = -1;
     if (c->object_type == AOT_SBR || (c->object_type == AOT_PS &&
         // check for W6132 Annex YYYY draft MP3onMP4
-        !(show_bits(&gb, 3) & 0x03 && !(show_bits(&gb, 9) & 0x3F)))) {
+        !(show_bits(gb, 3) & 0x03 && !(show_bits(gb, 9) & 0x3F)))) {
         if (c->object_type == AOT_PS)
             c->ps = 1;
         c->ext_object_type = AOT_SBR;
         c->sbr = 1;
-        c->ext_sample_rate = get_sample_rate(&gb, &c->ext_sampling_index);
-        c->object_type = get_object_type(&gb);
+        c->ext_sample_rate = get_sample_rate(gb, &c->ext_sampling_index);
+        c->object_type = get_object_type(gb);
         if (c->object_type == AOT_ER_BSAC)
-            c->ext_chan_config = get_bits(&gb, 4);
+            c->ext_chan_config = get_bits(gb, 4);
     } else {
         c->ext_object_type = AOT_NULL;
         c->ext_sample_rate = 0;
     }
-    specific_config_bitindex = get_bits_count(&gb);
+    specific_config_bitindex = get_bits_count(gb);
 
     if (c->object_type == AOT_ALS) {
-        skip_bits(&gb, 5);
-        if (show_bits_long(&gb, 24) != MKBETAG('\0','A','L','S'))
-            skip_bits_long(&gb, 24);
+        skip_bits(gb, 5);
+        if (show_bits_long(gb, 24) != MKBETAG('\0','A','L','S'))
+            skip_bits_long(gb, 24);
 
-        specific_config_bitindex = get_bits_count(&gb);
+        specific_config_bitindex = get_bits_count(gb);
 
-        if (parse_config_ALS(&gb, c))
-            return -1;
+        ret = parse_config_ALS(gb, c);
+        if (ret < 0)
+            return ret;
     }
 
     if (c->ext_object_type != AOT_SBR && sync_extension) {
-        while (get_bits_left(&gb) > 15) {
-            if (show_bits(&gb, 11) == 0x2b7) { // sync extension
-                get_bits(&gb, 11);
-                c->ext_object_type = get_object_type(&gb);
-                if (c->ext_object_type == AOT_SBR && (c->sbr = get_bits1(&gb)) == 1) {
-                    c->ext_sample_rate = get_sample_rate(&gb, &c->ext_sampling_index);
+        while (get_bits_left(gb) > 15) {
+            if (show_bits(gb, 11) == 0x2b7) { // sync extension
+                get_bits(gb, 11);
+                c->ext_object_type = get_object_type(gb);
+                if (c->ext_object_type == AOT_SBR && (c->sbr = get_bits1(gb)) == 1) {
+                    c->ext_sample_rate = get_sample_rate(gb, &c->ext_sampling_index);
                     if (c->ext_sample_rate == c->sample_rate)
                         c->sbr = -1;
                 }
-                if (get_bits_left(&gb) > 11 && get_bits(&gb, 11) == 0x548)
-                    c->ps = get_bits1(&gb);
+                if (get_bits_left(gb) > 11 && get_bits(gb, 11) == 0x548)
+                    c->ps = get_bits1(gb);
                 break;
             } else
-                get_bits1(&gb); // skip 1 bit
+                get_bits1(gb); // skip 1 bit
         }
     }
 
@@ -151,7 +149,23 @@ int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf,
     if ((c->ps == -1 && c->object_type != AOT_AAC_LC) || c->channels & ~0x01)
         c->ps = 0;
 
-    return specific_config_bitindex;
+    return specific_config_bitindex - start_bit_index;
+}
+
+int avpriv_mpeg4audio_get_config(MPEG4AudioConfig *c, const uint8_t *buf,
+                                 int bit_size, int sync_extension)
+{
+    GetBitContext gb;
+    int ret;
+
+    if (bit_size <= 0)
+        return AVERROR_INVALIDDATA;
+
+    ret = init_get_bits(&gb, buf, bit_size);
+    if (ret < 0)
+        return ret;
+
+    return ff_mpeg4audio_get_config_gb(c, &gb, sync_extension);
 }
 
 static av_always_inline unsigned int copy_bits(PutBitContext *pb,
diff --git a/mythtv/external/FFmpeg/libavcodec/mpeg4audio.h b/mythtv/external/FFmpeg/libavcodec/mpeg4audio.h
index 82390817474..8fd32f96b3c 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpeg4audio.h
+++ b/mythtv/external/FFmpeg/libavcodec/mpeg4audio.h
@@ -45,7 +45,17 @@ extern av_export const int avpriv_mpeg4audio_sample_rates[16];
 extern const uint8_t ff_mpeg4audio_channels[8];
 
 /**
- * Parse MPEG-4 systems extradata to retrieve audio configuration.
+ * Parse MPEG-4 systems extradata from a potentially unaligned GetBitContext to retrieve audio configuration.
+ * @param[in] c        MPEG4AudioConfig structure to fill.
+ * @param[in] gb       Extradata from container.
+ * @param[in] sync_extension look for a sync extension after config if true.
+ * @return On error -1 is returned, on success AudioSpecificConfig bit index in extradata.
+ */
+int ff_mpeg4audio_get_config_gb(MPEG4AudioConfig *c, GetBitContext *gb,
+                                int sync_extension);
+
+/**
+ * Parse MPEG-4 systems extradata from a raw buffer to retrieve audio configuration.
  * @param[in] c        MPEG4AudioConfig structure to fill.
  * @param[in] buf      Extradata from container.
  * @param[in] bit_size Extradata size in bits.
diff --git a/mythtv/external/FFmpeg/libavcodec/mpeg4videodec.c b/mythtv/external/FFmpeg/libavcodec/mpeg4videodec.c
index e49a549a290..5c5948dfda5 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpeg4videodec.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpeg4videodec.c
@@ -174,13 +174,15 @@ static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *g
     int a     = 2 << s->sprite_warping_accuracy;
     int rho   = 3  - s->sprite_warping_accuracy;
     int r     = 16 / a;
-    int alpha = 0;
+    int alpha = 1;
     int beta  = 0;
     int w     = s->width;
     int h     = s->height;
     int min_ab, i, w2, h2, w3, h3;
     int sprite_ref[4][2];
     int virtual_ref[2][2];
+    int64_t sprite_offset[2][2];
+    int64_t sprite_delta[2][2];
 
     // only true for rectangle shapes
     const int vop_ref[4][2] = { { 0, 0 },         { s->width, 0 },
@@ -245,71 +247,71 @@ static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *g
      * from w&h based to w2&h2 based which are of the 2^x form. */
     virtual_ref[0][0] = 16 * (vop_ref[0][0] + w2) +
                          ROUNDED_DIV(((w - w2) *
-                                      (r * sprite_ref[0][0] - 16 * vop_ref[0][0]) +
-                                      w2 * (r * sprite_ref[1][0] - 16 * vop_ref[1][0])), w);
+                                           (r * sprite_ref[0][0] - 16LL * vop_ref[0][0]) +
+                                      w2 * (r * sprite_ref[1][0] - 16LL * vop_ref[1][0])), w);
     virtual_ref[0][1] = 16 * vop_ref[0][1] +
                         ROUNDED_DIV(((w - w2) *
-                                     (r * sprite_ref[0][1] - 16 * vop_ref[0][1]) +
-                                     w2 * (r * sprite_ref[1][1] - 16 * vop_ref[1][1])), w);
+                                          (r * sprite_ref[0][1] - 16LL * vop_ref[0][1]) +
+                                     w2 * (r * sprite_ref[1][1] - 16LL * vop_ref[1][1])), w);
     virtual_ref[1][0] = 16 * vop_ref[0][0] +
-                        ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][0] - 16 * vop_ref[0][0]) +
-                                     h2 * (r * sprite_ref[2][0] - 16 * vop_ref[2][0])), h);
+                        ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][0] - 16LL * vop_ref[0][0]) +
+                                           h2 * (r * sprite_ref[2][0] - 16LL * vop_ref[2][0])), h);
     virtual_ref[1][1] = 16 * (vop_ref[0][1] + h2) +
-                        ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][1] - 16 * vop_ref[0][1]) +
-                                     h2 * (r * sprite_ref[2][1] - 16 * vop_ref[2][1])), h);
+                        ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][1] - 16LL * vop_ref[0][1]) +
+                                           h2 * (r * sprite_ref[2][1] - 16LL * vop_ref[2][1])), h);
 
     switch (ctx->num_sprite_warping_points) {
     case 0:
-        s->sprite_offset[0][0] =
-        s->sprite_offset[0][1] =
-        s->sprite_offset[1][0] =
-        s->sprite_offset[1][1] = 0;
-        s->sprite_delta[0][0]  = a;
-        s->sprite_delta[0][1]  =
-        s->sprite_delta[1][0]  = 0;
-        s->sprite_delta[1][1]  = a;
+        sprite_offset[0][0]    =
+        sprite_offset[0][1]    =
+        sprite_offset[1][0]    =
+        sprite_offset[1][1]    = 0;
+        sprite_delta[0][0]     = a;
+        sprite_delta[0][1]     =
+        sprite_delta[1][0]     = 0;
+        sprite_delta[1][1]     = a;
         ctx->sprite_shift[0]   =
         ctx->sprite_shift[1]   = 0;
         break;
     case 1:     // GMC only
-        s->sprite_offset[0][0] = sprite_ref[0][0] - a * vop_ref[0][0];
-        s->sprite_offset[0][1] = sprite_ref[0][1] - a * vop_ref[0][1];
-        s->sprite_offset[1][0] = ((sprite_ref[0][0] >> 1) | (sprite_ref[0][0] & 1)) -
+        sprite_offset[0][0]    = sprite_ref[0][0] - a * vop_ref[0][0];
+        sprite_offset[0][1]    = sprite_ref[0][1] - a * vop_ref[0][1];
+        sprite_offset[1][0]    = ((sprite_ref[0][0] >> 1) | (sprite_ref[0][0] & 1)) -
                                  a * (vop_ref[0][0] / 2);
-        s->sprite_offset[1][1] = ((sprite_ref[0][1] >> 1) | (sprite_ref[0][1] & 1)) -
+        sprite_offset[1][1]    = ((sprite_ref[0][1] >> 1) | (sprite_ref[0][1] & 1)) -
                                  a * (vop_ref[0][1] / 2);
-        s->sprite_delta[0][0]  = a;
-        s->sprite_delta[0][1]  =
-        s->sprite_delta[1][0]  = 0;
-        s->sprite_delta[1][1]  = a;
+        sprite_delta[0][0]     = a;
+        sprite_delta[0][1]     =
+        sprite_delta[1][0]     = 0;
+        sprite_delta[1][1]     = a;
         ctx->sprite_shift[0]   =
         ctx->sprite_shift[1]   = 0;
         break;
     case 2:
-        s->sprite_offset[0][0] = (sprite_ref[0][0] << (alpha + rho)) +
-                                 (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
-                                 (-vop_ref[0][0]) +
-                                 (r * sprite_ref[0][1] - virtual_ref[0][1]) *
-                                 (-vop_ref[0][1]) + (1 << (alpha + rho - 1));
-        s->sprite_offset[0][1] = (sprite_ref[0][1] << (alpha + rho)) +
-                                 (-r * sprite_ref[0][1] + virtual_ref[0][1]) *
-                                 (-vop_ref[0][0]) +
-                                 (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
-                                 (-vop_ref[0][1]) + (1 << (alpha + rho - 1));
-        s->sprite_offset[1][0] = ((-r * sprite_ref[0][0] + virtual_ref[0][0]) *
-                                  (-2 * vop_ref[0][0] + 1) +
-                                  (r * sprite_ref[0][1] - virtual_ref[0][1]) *
-                                  (-2 * vop_ref[0][1] + 1) + 2 * w2 * r *
-                                  sprite_ref[0][0] - 16 * w2 + (1 << (alpha + rho + 1)));
-        s->sprite_offset[1][1] = ((-r * sprite_ref[0][1] + virtual_ref[0][1]) *
-                                  (-2 * vop_ref[0][0] + 1) +
-                                  (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
-                                  (-2 * vop_ref[0][1] + 1) + 2 * w2 * r *
-                                  sprite_ref[0][1] - 16 * w2 + (1 << (alpha + rho + 1)));
-        s->sprite_delta[0][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);
-        s->sprite_delta[0][1] = (+r * sprite_ref[0][1] - virtual_ref[0][1]);
-        s->sprite_delta[1][0] = (-r * sprite_ref[0][1] + virtual_ref[0][1]);
-        s->sprite_delta[1][1] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);
+        sprite_offset[0][0]    = ((int64_t)      sprite_ref[0][0] * (1 << alpha + rho)) +
+                                 ((int64_t) -r * sprite_ref[0][0] + virtual_ref[0][0]) *
+                                 ((int64_t)        -vop_ref[0][0]) +
+                                 ((int64_t)  r * sprite_ref[0][1] - virtual_ref[0][1]) *
+                                 ((int64_t)        -vop_ref[0][1]) + (1 << (alpha + rho - 1));
+        sprite_offset[0][1]    = ((int64_t)      sprite_ref[0][1] * (1 << alpha + rho)) +
+                                 ((int64_t) -r * sprite_ref[0][1] + virtual_ref[0][1]) *
+                                 ((int64_t)        -vop_ref[0][0]) +
+                                 ((int64_t) -r * sprite_ref[0][0] + virtual_ref[0][0]) *
+                                 ((int64_t)        -vop_ref[0][1]) + (1 << (alpha + rho - 1));
+        sprite_offset[1][0]    = (((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) *
+                                  ((int64_t)-2 *    vop_ref[0][0] + 1) +
+                                  ((int64_t) r * sprite_ref[0][1] - virtual_ref[0][1]) *
+                                  ((int64_t)-2 *    vop_ref[0][1] + 1) + 2 * w2 * r *
+                                   (int64_t)     sprite_ref[0][0] - 16 * w2 + (1 << (alpha + rho + 1)));
+        sprite_offset[1][1]    = (((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) *
+                                  ((int64_t)-2 *    vop_ref[0][0] + 1) +
+                                  ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) *
+                                  ((int64_t)-2 *    vop_ref[0][1] + 1) + 2 * w2 * r *
+                                  (int64_t)      sprite_ref[0][1] - 16 * w2 + (1 << (alpha + rho + 1)));
+        sprite_delta[0][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);
+        sprite_delta[0][1] = (+r * sprite_ref[0][1] - virtual_ref[0][1]);
+        sprite_delta[1][0] = (-r * sprite_ref[0][1] + virtual_ref[0][1]);
+        sprite_delta[1][1] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);
 
         ctx->sprite_shift[0]  = alpha + rho;
         ctx->sprite_shift[1]  = alpha + rho + 2;
@@ -318,69 +320,105 @@ static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *g
         min_ab = FFMIN(alpha, beta);
         w3     = w2 >> min_ab;
         h3     = h2 >> min_ab;
-        s->sprite_offset[0][0] = (sprite_ref[0][0] << (alpha + beta + rho - min_ab)) +
-                                 (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
-                                 h3 * (-vop_ref[0][0]) +
-                                 (-r * sprite_ref[0][0] + virtual_ref[1][0]) *
-                                 w3 * (-vop_ref[0][1]) +
-                                 (1 << (alpha + beta + rho - min_ab - 1));
-        s->sprite_offset[0][1] = (sprite_ref[0][1] << (alpha + beta + rho - min_ab)) +
-                                 (-r * sprite_ref[0][1] + virtual_ref[0][1]) *
-                                 h3 * (-vop_ref[0][0]) +
-                                 (-r * sprite_ref[0][1] + virtual_ref[1][1]) *
-                                 w3 * (-vop_ref[0][1]) +
-                                 (1 << (alpha + beta + rho - min_ab - 1));
-        s->sprite_offset[1][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]) *
-                                 h3 * (-2 * vop_ref[0][0] + 1) +
-                                 (-r * sprite_ref[0][0] + virtual_ref[1][0]) *
-                                 w3 * (-2 * vop_ref[0][1] + 1) + 2 * w2 * h3 *
-                                 r * sprite_ref[0][0] - 16 * w2 * h3 +
-                                 (1 << (alpha + beta + rho - min_ab + 1));
-        s->sprite_offset[1][1] = (-r * sprite_ref[0][1] + virtual_ref[0][1]) *
-                                 h3 * (-2 * vop_ref[0][0] + 1) +
-                                 (-r * sprite_ref[0][1] + virtual_ref[1][1]) *
-                                 w3 * (-2 * vop_ref[0][1] + 1) + 2 * w2 * h3 *
-                                 r * sprite_ref[0][1] - 16 * w2 * h3 +
-                                 (1 << (alpha + beta + rho - min_ab + 1));
-        s->sprite_delta[0][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]) * h3;
-        s->sprite_delta[0][1] = (-r * sprite_ref[0][0] + virtual_ref[1][0]) * w3;
-        s->sprite_delta[1][0] = (-r * sprite_ref[0][1] + virtual_ref[0][1]) * h3;
-        s->sprite_delta[1][1] = (-r * sprite_ref[0][1] + virtual_ref[1][1]) * w3;
+        sprite_offset[0][0]    = ((int64_t)sprite_ref[0][0] * (1 << (alpha + beta + rho - min_ab))) +
+                                 ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) * h3 * (-vop_ref[0][0]) +
+                                 ((int64_t)-r * sprite_ref[0][0] + virtual_ref[1][0]) * w3 * (-vop_ref[0][1]) +
+                                 ((int64_t)1 << (alpha + beta + rho - min_ab - 1));
+        sprite_offset[0][1]    = ((int64_t)sprite_ref[0][1] * (1 << (alpha + beta + rho - min_ab))) +
+                                 ((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) * h3 * (-vop_ref[0][0]) +
+                                 ((int64_t)-r * sprite_ref[0][1] + virtual_ref[1][1]) * w3 * (-vop_ref[0][1]) +
+                                 ((int64_t)1 << (alpha + beta + rho - min_ab - 1));
+        sprite_offset[1][0]    = ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) * h3 * (-2 * vop_ref[0][0] + 1) +
+                                 ((int64_t)-r * sprite_ref[0][0] + virtual_ref[1][0]) * w3 * (-2 * vop_ref[0][1] + 1) +
+                                  (int64_t)2 * w2 * h3 * r * sprite_ref[0][0] - 16 * w2 * h3 +
+                                 ((int64_t)1 << (alpha + beta + rho - min_ab + 1));
+        sprite_offset[1][1]    = ((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) * h3 * (-2 * vop_ref[0][0] + 1) +
+                                 ((int64_t)-r * sprite_ref[0][1] + virtual_ref[1][1]) * w3 * (-2 * vop_ref[0][1] + 1) +
+                                  (int64_t)2 * w2 * h3 * r * sprite_ref[0][1] - 16 * w2 * h3 +
+                                 ((int64_t)1 << (alpha + beta + rho - min_ab + 1));
+        sprite_delta[0][0] = (-r * (int64_t)sprite_ref[0][0] + virtual_ref[0][0]) * h3;
+        sprite_delta[0][1] = (-r * (int64_t)sprite_ref[0][0] + virtual_ref[1][0]) * w3;
+        sprite_delta[1][0] = (-r * (int64_t)sprite_ref[0][1] + virtual_ref[0][1]) * h3;
+        sprite_delta[1][1] = (-r * (int64_t)sprite_ref[0][1] + virtual_ref[1][1]) * w3;
 
         ctx->sprite_shift[0]  = alpha + beta + rho - min_ab;
         ctx->sprite_shift[1]  = alpha + beta + rho - min_ab + 2;
         break;
     }
     /* try to simplify the situation */
-    if (s->sprite_delta[0][0] == a << ctx->sprite_shift[0] &&
-        s->sprite_delta[0][1] == 0 &&
-        s->sprite_delta[1][0] == 0 &&
-        s->sprite_delta[1][1] == a << ctx->sprite_shift[0]) {
-        s->sprite_offset[0][0] >>= ctx->sprite_shift[0];
-        s->sprite_offset[0][1] >>= ctx->sprite_shift[0];
-        s->sprite_offset[1][0] >>= ctx->sprite_shift[1];
-        s->sprite_offset[1][1] >>= ctx->sprite_shift[1];
-        s->sprite_delta[0][0] = a;
-        s->sprite_delta[0][1] = 0;
-        s->sprite_delta[1][0] = 0;
-        s->sprite_delta[1][1] = a;
+    if (sprite_delta[0][0] == a << ctx->sprite_shift[0] &&
+        sprite_delta[0][1] == 0 &&
+        sprite_delta[1][0] == 0 &&
+        sprite_delta[1][1] == a << ctx->sprite_shift[0]) {
+        sprite_offset[0][0] >>= ctx->sprite_shift[0];
+        sprite_offset[0][1] >>= ctx->sprite_shift[0];
+        sprite_offset[1][0] >>= ctx->sprite_shift[1];
+        sprite_offset[1][1] >>= ctx->sprite_shift[1];
+        sprite_delta[0][0] = a;
+        sprite_delta[0][1] = 0;
+        sprite_delta[1][0] = 0;
+        sprite_delta[1][1] = a;
         ctx->sprite_shift[0] = 0;
         ctx->sprite_shift[1] = 0;
         s->real_sprite_warping_points = 1;
     } else {
         int shift_y = 16 - ctx->sprite_shift[0];
         int shift_c = 16 - ctx->sprite_shift[1];
+
         for (i = 0; i < 2; i++) {
-            s->sprite_offset[0][i] <<= shift_y;
-            s->sprite_offset[1][i] <<= shift_c;
-            s->sprite_delta[0][i]  <<= shift_y;
-            s->sprite_delta[1][i]  <<= shift_y;
+            if (shift_c < 0 || shift_y < 0 ||
+                FFABS(  sprite_offset[0][i]) >= INT_MAX >> shift_y  ||
+                FFABS(  sprite_offset[1][i]) >= INT_MAX >> shift_c  ||
+                FFABS(   sprite_delta[0][i]) >= INT_MAX >> shift_y  ||
+                FFABS(   sprite_delta[1][i]) >= INT_MAX >> shift_y
+            ) {
+                avpriv_request_sample(s->avctx, "Too large sprite shift, delta or offset");
+                goto overflow;
+            }
+        }
+
+        for (i = 0; i < 2; i++) {
+            sprite_offset[0][i]    *= 1 << shift_y;
+            sprite_offset[1][i]    *= 1 << shift_c;
+            sprite_delta[0][i]     *= 1 << shift_y;
+            sprite_delta[1][i]     *= 1 << shift_y;
             ctx->sprite_shift[i]     = 16;
+
+        }
+        for (i = 0; i < 2; i++) {
+            int64_t sd[2] = {
+                sprite_delta[i][0] - a * (1LL<<16),
+                sprite_delta[i][1] - a * (1LL<<16)
+            };
+
+            if (llabs(sprite_offset[0][i] + sprite_delta[i][0] * (w+16LL)) >= INT_MAX ||
+                llabs(sprite_offset[0][i] + sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
+                llabs(sprite_offset[0][i] + sprite_delta[i][0] * (w+16LL) + sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
+                llabs(sprite_delta[i][0] * (w+16LL)) >= INT_MAX ||
+                llabs(sprite_delta[i][1] * (w+16LL)) >= INT_MAX ||
+                llabs(sd[0]) >= INT_MAX ||
+                llabs(sd[1]) >= INT_MAX ||
+                llabs(sprite_offset[0][i] + sd[0] * (w+16LL)) >= INT_MAX ||
+                llabs(sprite_offset[0][i] + sd[1] * (h+16LL)) >= INT_MAX ||
+                llabs(sprite_offset[0][i] + sd[0] * (w+16LL) + sd[1] * (h+16LL)) >= INT_MAX
+            ) {
+                avpriv_request_sample(s->avctx, "Overflow on sprite points");
+                goto overflow;
+            }
         }
         s->real_sprite_warping_points = ctx->num_sprite_warping_points;
     }
 
+    for (i = 0; i < 4; i++) {
+        s->sprite_offset[i&1][i>>1] = sprite_offset[i&1][i>>1];
+        s->sprite_delta [i&1][i>>1] = sprite_delta [i&1][i>>1];
+    }
+
     return 0;
+overflow:
+    memset(s->sprite_offset, 0, sizeof(s->sprite_offset));
+    memset(s->sprite_delta, 0, sizeof(s->sprite_delta));
+    return AVERROR_PATCHWELCOME;
 }
 
 static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb) {
@@ -507,7 +545,7 @@ static inline int get_amv(Mpeg4DecContext *ctx, int n)
         if (ctx->divx_version == 500 && ctx->divx_build == 413)
             sum = s->sprite_offset[0][n] / (1 << (a - s->quarter_sample));
         else
-            sum = RSHIFT(s->sprite_offset[0][n] << s->quarter_sample, a);
+            sum = RSHIFT(s->sprite_offset[0][n] * (1 << s->quarter_sample), a);
     } else {
         dx    = s->sprite_delta[n][0];
         dy    = s->sprite_delta[n][1];
@@ -2116,8 +2154,15 @@ static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb)
         e = sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
     if (e != 4) {
         e = sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3) + 1;
-        if (e > 1)
-            build = (ver << 16) + (ver2 << 8) + ver3;
+        if (e > 1) {
+            if (ver > 0xFFU || ver2 > 0xFFU || ver3 > 0xFFU) {
+                av_log(s->avctx, AV_LOG_WARNING,
+                     "Unknown Lavc version string encountered, %d.%d.%d; "
+                     "clamping sub-version values to 8-bits.\n",
+                     ver, ver2, ver3);
+            }
+            build = ((ver & 0xFF) << 16) + ((ver2 & 0xFF) << 8) + (ver3 & 0xFF);
+        }
     }
     if (e != 4) {
         if (strcmp(buf, "ffmpeg") == 0)
@@ -2200,6 +2245,13 @@ int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
         if (ctx->lavc_build <= 4712U)
             s->workaround_bugs |= FF_BUG_DC_CLIP;
 
+        if ((ctx->lavc_build&0xFF) >= 100) {
+            if (ctx->lavc_build > 3621476 && ctx->lavc_build < 3752552 &&
+               (ctx->lavc_build < 3752037 || ctx->lavc_build > 3752191) // 3.2.1+
+            )
+                s->workaround_bugs |= FF_BUG_IEDGE;
+        }
+
         if (ctx->divx_version >= 0)
             s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE;
         if (ctx->divx_version == 501 && ctx->divx_build == 20020416)
@@ -2251,6 +2303,7 @@ static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
     int time_incr, time_increment;
     int64_t pts;
 
+    s->mcsel       = 0;
     s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I;        /* pict type: I = 0 , P = 1 */
     if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay &&
         ctx->vol_control_parameters == 0 && !(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)) {
@@ -2303,7 +2356,7 @@ static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
     if (s->pict_type != AV_PICTURE_TYPE_B) {
         s->last_time_base = s->time_base;
         s->time_base     += time_incr;
-        s->time = s->time_base * s->avctx->framerate.num + time_increment;
+        s->time = s->time_base * (int64_t)s->avctx->framerate.num + time_increment;
         if (s->workaround_bugs & FF_BUG_UMP4) {
             if (s->time < s->last_non_b_time) {
                 /* header is not mpeg-4-compatible, broken encoder,
@@ -2315,7 +2368,7 @@ static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
         s->pp_time         = s->time - s->last_non_b_time;
         s->last_non_b_time = s->time;
     } else {
-        s->time    = (s->last_time_base + time_incr) * s->avctx->framerate.num + time_increment;
+        s->time    = (s->last_time_base + time_incr) * (int64_t)s->avctx->framerate.num + time_increment;
         s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
         if (s->pp_time <= s->pb_time ||
             s->pp_time <= s->pp_time - s->pb_time ||
@@ -2418,16 +2471,20 @@ static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
         ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
     }
 
-    if (s->pict_type == AV_PICTURE_TYPE_S &&
-        (ctx->vol_sprite_usage == STATIC_SPRITE ||
-         ctx->vol_sprite_usage == GMC_SPRITE)) {
-        if (mpeg4_decode_sprite_trajectory(ctx, gb) < 0)
-            return AVERROR_INVALIDDATA;
-        if (ctx->sprite_brightness_change)
-            av_log(s->avctx, AV_LOG_ERROR,
-                   "sprite_brightness_change not supported\n");
-        if (ctx->vol_sprite_usage == STATIC_SPRITE)
-            av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
+    if (s->pict_type == AV_PICTURE_TYPE_S) {
+        if((ctx->vol_sprite_usage == STATIC_SPRITE ||
+            ctx->vol_sprite_usage == GMC_SPRITE)) {
+            if (mpeg4_decode_sprite_trajectory(ctx, gb) < 0)
+                return AVERROR_INVALIDDATA;
+            if (ctx->sprite_brightness_change)
+                av_log(s->avctx, AV_LOG_ERROR,
+                    "sprite_brightness_change not supported\n");
+            if (ctx->vol_sprite_usage == STATIC_SPRITE)
+                av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
+        } else {
+            memset(s->sprite_offset, 0, sizeof(s->sprite_offset));
+            memset(s->sprite_delta, 0, sizeof(s->sprite_delta));
+        }
     }
 
     if (ctx->shape != BIN_ONLY_SHAPE) {
@@ -2525,6 +2582,7 @@ int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb)
     MpegEncContext *s = &ctx->m;
     unsigned startcode, v;
     int ret;
+    int vol = 0;
 
     /* search next start code */
     align_get_bits(gb);
@@ -2613,6 +2671,11 @@ int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb)
         }
 
         if (startcode >= 0x120 && startcode <= 0x12F) {
+            if (vol) {
+                av_log(s->avctx, AV_LOG_ERROR, "Multiple VOL headers");
+                return AVERROR_INVALIDDATA;
+            }
+            vol++;
             if ((ret = decode_vol_header(ctx, gb)) < 0)
                 return ret;
         } else if (startcode == USER_DATA_STARTCODE) {
@@ -2786,6 +2849,7 @@ AVCodec ff_mpeg4_decoder = {
     .capabilities          = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
                              AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
                              AV_CODEC_CAP_FRAME_THREADS,
+    .caps_internal         = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .flush                 = ff_mpeg_flush,
     .max_lowres            = 3,
     .pix_fmts              = ff_h263_hwaccel_pixfmt_list_420,
diff --git a/mythtv/external/FFmpeg/libavcodec/mpeg4videoenc.c b/mythtv/external/FFmpeg/libavcodec/mpeg4videoenc.c
index 31493100a09..494452c9383 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpeg4videoenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpeg4videoenc.c
@@ -256,7 +256,6 @@ void ff_clean_mpeg4_qscales(MpegEncContext *s)
  */
 static inline void mpeg4_encode_dc(PutBitContext *s, int level, int n)
 {
-#if 1
     /* DC will overflow if level is outside the [-255,255] range. */
     level += 256;
     if (n < 4) {
@@ -266,33 +265,6 @@ static inline void mpeg4_encode_dc(PutBitContext *s, int level, int n)
         /* chrominance */
         put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]);
     }
-#else
-    int size, v;
-    /* find number of bits */
-    size = 0;
-    v    = abs(level);
-    while (v) {
-        v >>= 1;
-        size++;
-    }
-
-    if (n < 4) {
-        /* luminance */
-        put_bits(s, ff_mpeg4_DCtab_lum[size][1], ff_mpeg4_DCtab_lum[size][0]);
-    } else {
-        /* chrominance */
-        put_bits(s, ff_mpeg4_DCtab_chrom[size][1], ff_mpeg4_DCtab_chrom[size][0]);
-    }
-
-    /* encode remaining bits */
-    if (size > 0) {
-        if (level < 0)
-            level = (-level) ^ ((1 << size) - 1);
-        put_bits(s, size, level);
-        if (size > 8)
-            put_bits(s, 1, 1);
-    }
-#endif
 }
 
 static inline int mpeg4_get_dc_length(int level, int n)
diff --git a/mythtv/external/FFmpeg/libavcodec/mpeg_er.c b/mythtv/external/FFmpeg/libavcodec/mpeg_er.c
index dd87ae9cc9e..ada1a1692f3 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpeg_er.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpeg_er.c
@@ -71,6 +71,7 @@ static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
     s->mb_skipped = mb_skipped;
     s->mb_x       = mb_x;
     s->mb_y       = mb_y;
+    s->mcsel      = 0;
     memcpy(s->mv, mv, sizeof(*mv));
 
     ff_init_block_index(s);
@@ -91,7 +92,7 @@ static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
     if (ref)
         av_log(s->avctx, AV_LOG_DEBUG,
                "Interlaced error concealment is not fully implemented\n");
-    ff_mpv_decode_mb(s, s->block);
+    ff_mpv_reconstruct_mb(s, s->block);
 }
 
 int ff_mpeg_er_init(MpegEncContext *s)
@@ -109,7 +110,7 @@ int ff_mpeg_er_init(MpegEncContext *s)
     er->mb_stride   = s->mb_stride;
     er->b8_stride   = s->b8_stride;
 
-    er->er_temp_buffer     = av_malloc(s->mb_height * s->mb_stride);
+    er->er_temp_buffer     = av_malloc(s->mb_height * s->mb_stride * (4*sizeof(int) + 1));
     er->error_status_table = av_mallocz(mb_array_size);
     if (!er->er_temp_buffer || !er->error_status_table)
         goto fail;
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegaudio.h b/mythtv/external/FFmpeg/libavcodec/mpegaudio.h
index 1591a170d77..74590a8e8b7 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegaudio.h
+++ b/mythtv/external/FFmpeg/libavcodec/mpegaudio.h
@@ -31,6 +31,7 @@
 #endif
 
 #include <stdint.h>
+#include "libavutil/internal.h"
 
 /* max frame size, in samples */
 #define MPA_FRAME_SIZE 1152
@@ -60,14 +61,17 @@
 
 #if USE_FLOATS
 #   define INTFLOAT float
+#   define SUINTFLOAT float
 typedef float MPA_INT;
 typedef float OUT_INT;
 #elif FRAC_BITS <= 15
 #   define INTFLOAT int
+#   define SUINTFLOAT SUINT
 typedef int16_t MPA_INT;
 typedef int16_t OUT_INT;
 #else
 #   define INTFLOAT int
+#   define SUINTFLOAT SUINT
 typedef int32_t MPA_INT;
 typedef int16_t OUT_INT;
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegaudio_parser.c b/mythtv/external/FFmpeg/libavcodec/mpegaudio_parser.c
index 13c9d887d8c..3eda77fa884 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegaudio_parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegaudio_parser.c
@@ -98,7 +98,7 @@ static int mpegaudio_parse(AVCodecParserContext *s1,
                     } else if (codec_id == AV_CODEC_ID_MP3ADU) {
                         avpriv_report_missing_feature(avctx,
                             "MP3ADU full parser");
-                        return AVERROR_PATCHWELCOME;
+                        return 0; /* parsers must not return error codes */
                     }
 
                     break;
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegaudiodec_fixed.c b/mythtv/external/FFmpeg/libavcodec/mpegaudiodec_fixed.c
index 9421ffbe948..ad7ceb20b66 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegaudiodec_fixed.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegaudiodec_fixed.c
@@ -25,13 +25,13 @@
 
 #include "mpegaudio.h"
 
-#define SHR(a,b)       ((a)>>(b))
+#define SHR(a,b)       (((int)(a))>>(b))
 /* WARNING: only correct for positive numbers */
 #define FIXR_OLD(a)    ((int)((a) * FRAC_ONE + 0.5))
 #define FIXR(a)        ((int)((a) * FRAC_ONE + 0.5))
 #define FIXHR(a)       ((int)((a) * (1LL<<32) + 0.5))
 #define MULH3(x, y, s) MULH((s)*(x), y)
-#define MULLx(x, y, s) MULL(x,y,s)
+#define MULLx(x, y, s) MULL((int)(x),(y),s)
 #define RENAME(a)      a ## _fixed
 #define OUT_FMT   AV_SAMPLE_FMT_S16
 #define OUT_FMT_P AV_SAMPLE_FMT_S16P
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegaudiodec_template.c b/mythtv/external/FFmpeg/libavcodec/mpegaudiodec_template.c
index dd02a2a9d91..13b4760bfbf 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegaudiodec_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegaudiodec_template.c
@@ -251,9 +251,9 @@ static inline int l3_unscale(int value, int exponent)
     if(e < 1)
         av_log(NULL, AV_LOG_WARNING, "l3_unscale: e is %d\n", e);
 #endif
-    if (e > 31)
+    if (e > (SUINT)31)
         return 0;
-    m = (m + (1 << (e - 1))) >> e;
+    m = (m + ((1U << e)>>1)) >> e;
 
     return m;
 }
@@ -280,7 +280,8 @@ static av_cold void decode_init_static(void)
         scale_factor_mult[i][0] = MULLx(norm, FIXR(1.0          * 2.0), FRAC_BITS);
         scale_factor_mult[i][1] = MULLx(norm, FIXR(0.7937005259 * 2.0), FRAC_BITS);
         scale_factor_mult[i][2] = MULLx(norm, FIXR(0.6299605249 * 2.0), FRAC_BITS);
-        ff_dlog(NULL, "%d: norm=%x s=%x %x %x\n", i, norm,
+        ff_dlog(NULL, "%d: norm=%x s=%"PRIx32" %"PRIx32" %"PRIx32"\n", i,
+                (unsigned)norm,
                 scale_factor_mult[i][0],
                 scale_factor_mult[i][1],
                 scale_factor_mult[i][2]);
@@ -457,9 +458,9 @@ static av_cold int decode_init(AVCodecContext * avctx)
 
 /* 12 points IMDCT. We compute it "by hand" by factorizing obvious
    cases. */
-static void imdct12(INTFLOAT *out, INTFLOAT *in)
+static void imdct12(INTFLOAT *out, SUINTFLOAT *in)
 {
-    INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;
+    SUINTFLOAT in0, in1, in2, in3, in4, in5, t1, t2;
 
     in0  = in[0*3];
     in1  = in[1*3] + in[0*3];
@@ -898,8 +899,8 @@ static int huffman_decode(MPADecodeContext *s, GranuleDef *g,
 
             exponent= exponents[s_index];
 
-            ff_dlog(s->avctx, "region=%d n=%d x=%d y=%d exp=%d\n",
-                    i, g->region_size[i] - j, x, y, exponent);
+            ff_dlog(s->avctx, "region=%d n=%d y=%d exp=%d\n",
+                    i, g->region_size[i] - j, y, exponent);
             if (y & 16) {
                 x = y >> 5;
                 y = y & 0x0f;
@@ -1038,7 +1039,8 @@ static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
 {
     int i, j, k, l;
     int sf_max, sf, len, non_zero_found;
-    INTFLOAT (*is_tab)[16], *tab0, *tab1, tmp0, tmp1, v1, v2;
+    INTFLOAT (*is_tab)[16], *tab0, *tab1, v1, v2;
+    SUINTFLOAT tmp0, tmp1;
     int non_zero_found_short[3];
 
     /* intensity stereo */
@@ -1182,9 +1184,9 @@ static void compute_stereo(MPADecodeContext *s, GranuleDef *g0, GranuleDef *g1)
     } while (0)
 #else
 #define AA(j) do {                                              \
-        int tmp0 = ptr[-1-j];                                   \
-        int tmp1 = ptr[   j];                                   \
-        int tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]);          \
+        SUINT tmp0 = ptr[-1-j];                                   \
+        SUINT tmp1 = ptr[   j];                                   \
+        SUINT tmp2 = MULH(tmp0 + tmp1, csa_table[j][0]);          \
         ptr[-1-j] = 4 * (tmp2 - MULH(tmp1, csa_table[j][2]));   \
         ptr[   j] = 4 * (tmp2 + MULH(tmp0, csa_table[j][3]));   \
     } while (0)
@@ -1665,7 +1667,7 @@ static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
     header = AV_RB32(buf);
     if (header>>8 == AV_RB32("TAG")>>8) {
         av_log(avctx, AV_LOG_DEBUG, "discarding ID3 tag\n");
-        return buf_size;
+        return buf_size + skipped;
     }
     ret = avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header);
     if (ret < 0) {
@@ -1832,6 +1834,9 @@ static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
     MP3On4DecodeContext *s = avctx->priv_data;
     int i;
 
+    if (s->mp3decctx[0])
+        av_freep(&s->mp3decctx[0]->fdsp);
+
     for (i = 0; i < s->frames; i++)
         av_freep(&s->mp3decctx[i]);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp.c b/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp.c
index a5d20df6290..3cafca27bfd 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp.c
@@ -20,17 +20,21 @@
 
 #include "config.h"
 #include "libavutil/attributes.h"
+#include "libavutil/thread.h"
 #include "mpegaudiodsp.h"
 #include "dct.h"
 #include "dct32.h"
 
+static AVOnce mpadsp_float_table_init = AV_ONCE_INIT;
+static AVOnce mpadsp_fixed_table_init = AV_ONCE_INIT;
+
 av_cold void ff_mpadsp_init(MPADSPContext *s)
 {
     DCTContext dct;
 
     ff_dct_init(&dct, 5, DCT_II);
-    ff_init_mpadsp_tabs_float();
-    ff_init_mpadsp_tabs_fixed();
+    ff_thread_once(&mpadsp_float_table_init, &ff_init_mpadsp_tabs_float);
+    ff_thread_once(&mpadsp_fixed_table_init, &ff_init_mpadsp_tabs_fixed);
 
     s->apply_window_float = ff_mpadsp_apply_window_float;
     s->apply_window_fixed = ff_mpadsp_apply_window_fixed;
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp.h b/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp.h
index b827163d61c..0e4352deab3 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp.h
@@ -19,14 +19,18 @@
 #ifndef AVCODEC_MPEGAUDIODSP_H
 #define AVCODEC_MPEGAUDIODSP_H
 
+#include <stddef.h>
 #include <stdint.h>
+
 #include "libavutil/common.h"
 
 typedef struct MPADSPContext {
     void (*apply_window_float)(float *synth_buf, float *window,
-                               int *dither_state, float *samples, int incr);
+                               int *dither_state, float *samples,
+                               ptrdiff_t incr);
     void (*apply_window_fixed)(int32_t *synth_buf, int32_t *window,
-                               int *dither_state, int16_t *samples, int incr);
+                               int *dither_state, int16_t *samples,
+                               ptrdiff_t incr);
     void (*dct32_float)(float *dst, const float *src);
     void (*dct32_fixed)(int *dst, const int *src);
 
@@ -46,13 +50,13 @@ extern const int32_t ff_mpa_enwindow[257];
 void ff_mpa_synth_filter_fixed(MPADSPContext *s,
                                int32_t *synth_buf_ptr, int *synth_buf_offset,
                                int32_t *window, int *dither_state,
-                               int16_t *samples, int incr,
+                               int16_t *samples, ptrdiff_t incr,
                                int32_t *sb_samples);
 
 void ff_mpa_synth_filter_float(MPADSPContext *s,
                                float *synth_buf_ptr, int *synth_buf_offset,
                                float *window, int *dither_state,
-                               float *samples, int incr,
+                               float *samples, ptrdiff_t incr,
                                float *sb_samples);
 
 void ff_mpadsp_init_aarch64(MPADSPContext *s);
@@ -67,10 +71,10 @@ void ff_mpa_synth_init_fixed(int32_t *window);
 
 void ff_mpadsp_apply_window_float(float *synth_buf, float *window,
                                   int *dither_state, float *samples,
-                                  int incr);
+                                  ptrdiff_t incr);
 void ff_mpadsp_apply_window_fixed(int32_t *synth_buf, int32_t *window,
                                   int *dither_state, int16_t *samples,
-                                  int incr);
+                                  ptrdiff_t incr);
 
 void ff_imdct36_blocks_float(float *out, float *buf, float *in,
                              int count, int switch_point, int block_type);
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp_template.c b/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp_template.c
index 62454ca306a..e531f8a904b 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegaudiodsp_template.c
@@ -63,8 +63,8 @@ static inline int round_sample(int64_t *sum)
 #   define MACS(rt, ra, rb) MAC64(rt, ra, rb)
 #   define MLSS(rt, ra, rb) MLS64(rt, ra, rb)
 #   define MULH3(x, y, s) MULH((s)*(x), y)
-#   define MULLx(x, y, s) MULL(x,y,s)
-#   define SHR(a,b)       ((a)>>(b))
+#   define MULLx(x, y, s) MULL((int)(x),(y),s)
+#   define SHR(a,b)       (((int)(a))>>(b))
 #   define FIXR(a)        ((int)((a) * FRAC_ONE + 0.5))
 #   define FIXHR(a)       ((int)((a) * (1LL<<32) + 0.5))
 #endif
@@ -120,7 +120,7 @@ DECLARE_ALIGNED(16, MPA_INT, RENAME(ff_mpa_synth_window))[512+256];
 
 void RENAME(ff_mpadsp_apply_window)(MPA_INT *synth_buf, MPA_INT *window,
                                   int *dither_state, OUT_INT *samples,
-                                  int incr)
+                                  ptrdiff_t incr)
 {
     register const MPA_INT *w, *w2, *p;
     int j;
@@ -176,7 +176,7 @@ void RENAME(ff_mpadsp_apply_window)(MPA_INT *synth_buf, MPA_INT *window,
 void RENAME(ff_mpa_synth_filter)(MPADSPContext *s, MPA_INT *synth_buf_ptr,
                                  int *synth_buf_offset,
                                  MPA_INT *window, int *dither_state,
-                                 OUT_INT *samples, int incr,
+                                 OUT_INT *samples, ptrdiff_t incr,
                                  MPA_INT *sb_samples)
 {
     MPA_INT *synth_buf;
@@ -300,11 +300,11 @@ static const INTFLOAT icos36h[9] = {
 };
 
 /* using Lee like decomposition followed by hand coded 9 points DCT */
-static void imdct36(INTFLOAT *out, INTFLOAT *buf, INTFLOAT *in, INTFLOAT *win)
+static void imdct36(INTFLOAT *out, INTFLOAT *buf, SUINTFLOAT *in, INTFLOAT *win)
 {
     int i, j;
-    INTFLOAT t0, t1, t2, t3, s0, s1, s2, s3;
-    INTFLOAT tmp[18], *tmp1, *in1;
+    SUINTFLOAT t0, t1, t2, t3, s0, s1, s2, s3;
+    SUINTFLOAT tmp[18], *tmp1, *in1;
 
     for (i = 17; i >= 1; i--)
         in[i] += in[i-1];
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegpicture.c b/mythtv/external/FFmpeg/libavcodec/mpegpicture.c
index 6748fc2986a..53fb35b4bdb 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegpicture.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegpicture.c
@@ -76,7 +76,7 @@ int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me,
     // at uvlinesize. It supports only YUV420 so 24x24 is enough
     // linesize * interlaced * MBsize
     // we also use this buffer for encoding in encode_mb_internal() needig an additional 32 lines
-    FF_ALLOCZ_ARRAY_OR_GOTO(avctx, sc->edge_emu_buffer, alloc_size, 4 * 68,
+    FF_ALLOCZ_ARRAY_OR_GOTO(avctx, sc->edge_emu_buffer, alloc_size, 4 * 70,
                       fail);
 
     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, me->scratchpad, alloc_size, 4 * 16 * 2,
@@ -202,7 +202,10 @@ static int alloc_picture_tables(AVCodecContext *avctx, Picture *pic, int encodin
             return AVERROR(ENOMEM);
     }
 
-    if (out_format == FMT_H263 || encoding || avctx->debug_mv ||
+    if (out_format == FMT_H263 || encoding ||
+#if FF_API_DEBUG_MV
+        avctx->debug_mv ||
+#endif
         (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS)) {
         int mv_size        = 2 * (b8_array_size + 4) * sizeof(int16_t);
         int ref_index_size = 4 * mb_array_size;
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegvideo.c b/mythtv/external/FFmpeg/libavcodec/mpegvideo.c
index cb9d2cf415b..9577f514489 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegvideo.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegvideo.c
@@ -225,7 +225,7 @@ static void dct_unquantize_h263_intra_c(MpegEncContext *s,
     if(s->ac_pred)
         nCoeffs=63;
     else
-        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
+        nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
 
     for(i=1; i<=nCoeffs; i++) {
         level = block[i];
@@ -940,37 +940,37 @@ av_cold int ff_mpv_common_init(MpegEncContext *s)
     if (!s->new_picture.f)
         goto fail;
 
-        if (init_context_frame(s))
-            goto fail;
+    if (init_context_frame(s))
+        goto fail;
 
-        s->parse_context.state = -1;
+    s->parse_context.state = -1;
 
-        s->context_initialized = 1;
-        memset(s->thread_context, 0, sizeof(s->thread_context));
-        s->thread_context[0]   = s;
+    s->context_initialized = 1;
+    memset(s->thread_context, 0, sizeof(s->thread_context));
+    s->thread_context[0]   = s;
 
 //     if (s->width && s->height) {
-        if (nb_slices > 1) {
-            for (i = 0; i < nb_slices; i++) {
-                if (i) {
-                    s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
-                    if (!s->thread_context[i])
-                        goto fail;
-                }
-                if (init_duplicate_context(s->thread_context[i]) < 0)
+    if (nb_slices > 1) {
+        for (i = 0; i < nb_slices; i++) {
+            if (i) {
+                s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
+                if (!s->thread_context[i])
                     goto fail;
-                    s->thread_context[i]->start_mb_y =
-                        (s->mb_height * (i) + nb_slices / 2) / nb_slices;
-                    s->thread_context[i]->end_mb_y   =
-                        (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
             }
-        } else {
-            if (init_duplicate_context(s) < 0)
+            if (init_duplicate_context(s->thread_context[i]) < 0)
                 goto fail;
-            s->start_mb_y = 0;
-            s->end_mb_y   = s->mb_height;
+            s->thread_context[i]->start_mb_y =
+                (s->mb_height * (i) + nb_slices / 2) / nb_slices;
+            s->thread_context[i]->end_mb_y   =
+                (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
         }
-        s->slice_context_count = nb_slices;
+    } else {
+        if (init_duplicate_context(s) < 0)
+            goto fail;
+        s->start_mb_y = 0;
+        s->end_mb_y   = s->mb_height;
+    }
+    s->slice_context_count = nb_slices;
 //     }
 
     return 0;
@@ -1090,10 +1090,10 @@ int ff_mpv_common_frame_size_change(MpegEncContext *s)
                 }
                 if ((err = init_duplicate_context(s->thread_context[i])) < 0)
                     goto fail;
-                    s->thread_context[i]->start_mb_y =
-                        (s->mb_height * (i) + nb_slices / 2) / nb_slices;
-                    s->thread_context[i]->end_mb_y   =
-                        (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
+                s->thread_context[i]->start_mb_y =
+                    (s->mb_height * (i) + nb_slices / 2) / nb_slices;
+                s->thread_context[i]->end_mb_y   =
+                    (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
             }
         } else {
             err = init_duplicate_context(s);
@@ -1293,8 +1293,7 @@ int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
             s->pict_type, s->droppable);
 
     if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
-        (s->pict_type != AV_PICTURE_TYPE_I ||
-         s->picture_structure != PICT_FRAME)) {
+        (s->pict_type != AV_PICTURE_TYPE_I)) {
         int h_chroma_shift, v_chroma_shift;
         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
                                          &h_chroma_shift, &v_chroma_shift);
@@ -1304,9 +1303,6 @@ int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
         else if (s->pict_type != AV_PICTURE_TYPE_I)
             av_log(avctx, AV_LOG_ERROR,
                    "warning: first frame is no keyframe\n");
-        else if (s->picture_structure != PICT_FRAME)
-            av_log(avctx, AV_LOG_DEBUG,
-                   "allocate dummy last picture for field based first keyframe\n");
 
         /* Allocate a dummy frame */
         i = ff_find_unused_picture(s->avctx, s->picture, 0);
@@ -1753,6 +1749,7 @@ void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_
         }
     }
 
+#if FF_API_DEBUG_MV
     if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
         (avctx->debug_mv)) {
         int mb_y;
@@ -1966,6 +1963,7 @@ void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_
             }
         }
     }
+#endif
 }
 
 void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
@@ -2126,7 +2124,9 @@ static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
         ptr_y = s->sc.edge_emu_buffer;
         if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
             uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
-            uint8_t *vbuf =ubuf + 9 * s->uvlinesize;
+            uint8_t *vbuf =ubuf + 10 * s->uvlinesize;
+            if (s->workaround_bugs & FF_BUG_IEDGE)
+                vbuf -= s->uvlinesize;
             s->vdsp.emulated_edge_mc(ubuf,  ptr_cb,
                                      uvlinesize >> field_based, uvlinesize >> field_based,
                                      9, 9 + field_based,
@@ -2479,7 +2479,7 @@ void ff_clean_intra_table_entries(MpegEncContext *s)
    s->interlaced_dct : true if interlaced dct used (mpeg2)
  */
 static av_always_inline
-void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
+void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64],
                             int lowres_flag, int is_mpeg12)
 {
     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
@@ -2727,16 +2727,16 @@ void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
     }
 }
 
-void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
+void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
 {
 #if !CONFIG_SMALL
     if(s->out_format == FMT_MPEG1) {
-        if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 1);
-        else                 mpv_decode_mb_internal(s, block, 0, 1);
+        if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 1);
+        else                 mpv_reconstruct_mb_internal(s, block, 0, 1);
     } else
 #endif
-    if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 0);
-    else                  mpv_decode_mb_internal(s, block, 0, 0);
+    if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 0);
+    else                  mpv_reconstruct_mb_internal(s, block, 0, 0);
 }
 
 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegvideo.h b/mythtv/external/FFmpeg/libavcodec/mpegvideo.h
index 5806597dd05..b5412290791 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegvideo.h
+++ b/mythtv/external/FFmpeg/libavcodec/mpegvideo.h
@@ -422,6 +422,7 @@ typedef struct MpegEncContext {
     struct MJpegContext *mjpeg_ctx;
     int esc_pos;
     int pred;
+    int huffman;
 
     /* MSMPEG4 specific */
     int mv_table_index;
@@ -688,7 +689,7 @@ void ff_mpv_common_end(MpegEncContext *s);
 
 void ff_mpv_decode_defaults(MpegEncContext *s);
 void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx);
-void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64]);
+void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64]);
 void ff_mpv_report_decode_progress(MpegEncContext *s);
 
 int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx);
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegvideo_enc.c b/mythtv/external/FFmpeg/libavcodec/mpegvideo_enc.c
index 1540e5c11da..5765ef339f5 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegvideo_enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegvideo_enc.c
@@ -64,6 +64,7 @@
 #include "bytestream.h"
 #include "wmv2.h"
 #include "rv10.h"
+#include "libxvid.h"
 #include <limits.h>
 #include "sp5x.h"
 
@@ -265,7 +266,8 @@ static void mpv_encode_defaults(MpegEncContext *s)
     s->picture_in_gop_number = 0;
 }
 
-av_cold int ff_dct_encode_init(MpegEncContext *s) {
+av_cold int ff_dct_encode_init(MpegEncContext *s)
+{
     if (ARCH_X86)
         ff_dct_encode_init_x86(s);
 
@@ -397,6 +399,9 @@ FF_ENABLE_DEPRECATION_WARNINGS
         return AVERROR(EINVAL);
     }
 
+    if (avctx->codec_id == AV_CODEC_ID_AMV || (avctx->active_thread_type & FF_THREAD_SLICE))
+        s->huffman = 0;
+
     if (s->intra_dc_precision > (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 3 : 0)) {
         av_log(avctx, AV_LOG_ERROR, "intra dc precision too large\n");
         return AVERROR(EINVAL);
@@ -501,7 +506,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
         avctx->bit_rate * av_q2d(avctx->time_base) >
             avctx->bit_rate_tolerance) {
         av_log(avctx, AV_LOG_WARNING,
-               "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, (int64_t)avctx->bit_rate);
+               "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, avctx->bit_rate);
         avctx->bit_rate_tolerance = 5 * avctx->bit_rate * av_q2d(avctx->time_base);
     }
 
@@ -641,6 +646,15 @@ FF_ENABLE_DEPRECATION_WARNINGS
         return -1;
     }
 
+    if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
+            (s->codec_id == AV_CODEC_ID_AMV ||
+             s->codec_id == AV_CODEC_ID_MJPEG)) {
+        // Used to produce garbage with MJPEG.
+        av_log(avctx, AV_LOG_ERROR,
+               "QP RD is no longer compatible with MJPEG or AMV\n");
+        return -1;
+    }
+
 #if FF_API_PRIVATE_OPT
 FF_DISABLE_DEPRECATION_WARNINGS
     if (avctx->scenechange_threshold)
@@ -657,9 +671,11 @@ FF_ENABLE_DEPRECATION_WARNINGS
     }
 
     if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
-        if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
+        if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
+            s->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {
             av_log(avctx, AV_LOG_ERROR,
-                  "low delay forcing is only available for mpeg2\n");
+                   "low delay forcing is only available for mpeg2, "
+                   "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
             return -1;
         }
         if (s->max_b_frames != 0) {
@@ -1027,9 +1043,32 @@ FF_ENABLE_DEPRECATION_WARNINGS
                           31, 0);
     }
 
+#if FF_API_RC_STRATEGY
+FF_DISABLE_DEPRECATION_WARNINGS
+    if (!s->rc_strategy)
+        s->rc_strategy = s->avctx->rc_strategy;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
     if (ff_rate_control_init(s) < 0)
         return -1;
 
+#if FF_API_RC_STRATEGY
+    av_assert0(MPV_RC_STRATEGY_XVID == FF_RC_STRATEGY_XVID);
+#endif
+
+    if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID) {
+#if CONFIG_LIBXVID
+        ret = ff_xvid_rate_control_init(s);
+#else
+        ret = AVERROR(ENOSYS);
+        av_log(s->avctx, AV_LOG_ERROR,
+               "Xvid ratecontrol requires libavcodec compiled with Xvid support.\n");
+#endif
+        if (ret < 0)
+            return ret;
+    }
+
 #if FF_API_ERROR_RATE
     FF_DISABLE_DEPRECATION_WARNINGS
     if (avctx->error_rate)
@@ -1123,6 +1162,10 @@ av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
     int i;
 
     ff_rate_control_uninit(s);
+#if CONFIG_LIBXVID
+    if ((avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID)
+        ff_xvid_rate_control_uninit(s);
+#endif
 
     ff_mpv_common_end(s);
     if (CONFIG_MJPEG_ENCODER &&
@@ -1395,29 +1438,38 @@ static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
 static int encode_frame(AVCodecContext *c, AVFrame *frame)
 {
     AVPacket pkt = { 0 };
-    int ret, got_output;
+    int ret;
+    int size = 0;
 
     av_init_packet(&pkt);
-    ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
+
+    ret = avcodec_send_frame(c, frame);
     if (ret < 0)
         return ret;
 
-    ret = pkt.size;
-    av_packet_unref(&pkt);
-    return ret;
+    do {
+        ret = avcodec_receive_packet(c, &pkt);
+        if (ret >= 0) {
+            size += pkt.size;
+            av_packet_unref(&pkt);
+        } else if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
+            return ret;
+    } while (ret >= 0);
+
+    return size;
 }
 
 static int estimate_best_b_count(MpegEncContext *s)
 {
-    AVCodec *codec    = avcodec_find_encoder(s->avctx->codec_id);
-    AVCodecContext *c = avcodec_alloc_context3(NULL);
+    const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
     const int scale = s->brd_scale;
+    int width  = s->width  >> scale;
+    int height = s->height >> scale;
     int i, j, out_size, p_lambda, b_lambda, lambda2;
     int64_t best_rd  = INT64_MAX;
     int best_b_count = -1;
+    int ret = 0;
 
-    if (!c)
-        return AVERROR(ENOMEM);
     av_assert0(scale >= 0 && scale <= 3);
 
     //emms_c();
@@ -1430,21 +1482,6 @@ static int estimate_best_b_count(MpegEncContext *s)
     lambda2  = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
                FF_LAMBDA_SHIFT;
 
-    c->width        = s->width  >> scale;
-    c->height       = s->height >> scale;
-    c->flags        = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
-    c->flags       |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
-    c->mb_decision  = s->avctx->mb_decision;
-    c->me_cmp       = s->avctx->me_cmp;
-    c->mb_cmp       = s->avctx->mb_cmp;
-    c->me_sub_cmp   = s->avctx->me_sub_cmp;
-    c->pix_fmt      = AV_PIX_FMT_YUV420P;
-    c->time_base    = s->avctx->time_base;
-    c->max_b_frames = s->max_b_frames;
-
-    if (avcodec_open2(c, codec, NULL) < 0)
-        return -1;
-
     for (i = 0; i < s->max_b_frames + 2; i++) {
         Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
                                                 s->next_picture_ptr;
@@ -1464,32 +1501,55 @@ static int estimate_best_b_count(MpegEncContext *s)
                                        s->tmp_frames[i]->linesize[0],
                                        data[0],
                                        pre_input.f->linesize[0],
-                                       c->width, c->height);
+                                       width, height);
             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
                                        s->tmp_frames[i]->linesize[1],
                                        data[1],
                                        pre_input.f->linesize[1],
-                                       c->width >> 1, c->height >> 1);
+                                       width >> 1, height >> 1);
             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
                                        s->tmp_frames[i]->linesize[2],
                                        data[2],
                                        pre_input.f->linesize[2],
-                                       c->width >> 1, c->height >> 1);
+                                       width >> 1, height >> 1);
         }
     }
 
     for (j = 0; j < s->max_b_frames + 1; j++) {
+        AVCodecContext *c;
         int64_t rd = 0;
 
         if (!s->input_picture[j])
             break;
 
-        c->error[0] = c->error[1] = c->error[2] = 0;
+        c = avcodec_alloc_context3(NULL);
+        if (!c)
+            return AVERROR(ENOMEM);
+
+        c->width        = width;
+        c->height       = height;
+        c->flags        = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
+        c->flags       |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
+        c->mb_decision  = s->avctx->mb_decision;
+        c->me_cmp       = s->avctx->me_cmp;
+        c->mb_cmp       = s->avctx->mb_cmp;
+        c->me_sub_cmp   = s->avctx->me_sub_cmp;
+        c->pix_fmt      = AV_PIX_FMT_YUV420P;
+        c->time_base    = s->avctx->time_base;
+        c->max_b_frames = s->max_b_frames;
+
+        ret = avcodec_open2(c, codec, NULL);
+        if (ret < 0)
+            goto fail;
 
         s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
         s->tmp_frames[0]->quality   = 1 * FF_QP2LAMBDA;
 
         out_size = encode_frame(c, s->tmp_frames[0]);
+        if (out_size < 0) {
+            ret = out_size;
+            goto fail;
+        }
 
         //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
 
@@ -1501,15 +1561,21 @@ static int estimate_best_b_count(MpegEncContext *s)
             s->tmp_frames[i + 1]->quality   = is_p ? p_lambda : b_lambda;
 
             out_size = encode_frame(c, s->tmp_frames[i + 1]);
+            if (out_size < 0) {
+                ret = out_size;
+                goto fail;
+            }
 
             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
         }
 
         /* get the delayed frames */
-        while (out_size) {
-            out_size = encode_frame(c, NULL);
-            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
+        out_size = encode_frame(c, NULL);
+        if (out_size < 0) {
+            ret = out_size;
+            goto fail;
         }
+        rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
 
         rd += c->error[0] + c->error[1] + c->error[2];
 
@@ -1517,9 +1583,12 @@ static int estimate_best_b_count(MpegEncContext *s)
             best_rd = rd;
             best_b_count = j;
         }
-    }
 
-    avcodec_free_context(&c);
+fail:
+        avcodec_free_context(&c);
+        if (ret < 0)
+            return ret;
+    }
 
     return best_b_count;
 }
@@ -1602,6 +1671,8 @@ static int select_input_picture(MpegEncContext *s)
                 }
             } else if (s->b_frame_strategy == 2) {
                 b_frames = estimate_best_b_count(s);
+                if (b_frames < 0)
+                    return b_frames;
             }
 
             emms_c();
@@ -2276,7 +2347,7 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s,
              (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
 
     if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
-        uint8_t *ebuf = s->sc.edge_emu_buffer + 36 * wrap_y;
+        uint8_t *ebuf = s->sc.edge_emu_buffer + 38 * wrap_y;
         int cw = (s->width  + s->chroma_x_shift) >> s->chroma_x_shift;
         int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
         s->vdsp.emulated_edge_mc(ebuf, ptr_y,
@@ -2703,7 +2774,7 @@ static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegE
     }
 
     if(s->avctx->mb_decision == FF_MB_DECISION_RD){
-        ff_mpv_decode_mb(s, s->block);
+        ff_mpv_reconstruct_mb(s, s->block);
 
         score *= s->lambda2;
         score += sse_mb(s) << FF_LAMBDA_SHIFT;
@@ -3408,7 +3479,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
                 }
 
                 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
-                    ff_mpv_decode_mb(s, s->block);
+                    ff_mpv_reconstruct_mb(s, s->block);
             } else {
                 int motion_x = 0, motion_y = 0;
                 s->mv_type=MV_TYPE_16X16;
@@ -3527,7 +3598,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
                     s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
                     ff_h263_update_motion_val(s);
 
-                ff_mpv_decode_mb(s, s->block);
+                ff_mpv_reconstruct_mb(s, s->block);
             }
 
             /* clean the MV table in IPS frames for direct mode in B-frames */
@@ -3629,8 +3700,15 @@ static int estimate_qp(MpegEncContext *s, int dry_run){
         s->current_picture.f->quality = s->next_lambda;
         if(!dry_run) s->next_lambda= 0;
     } else if (!s->fixed_qscale) {
+        int quality;
+#if CONFIG_LIBXVID
+        if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID)
+            quality = ff_xvid_rate_estimate_qscale(s, dry_run);
+        else
+#endif
+        quality = ff_rate_estimate_qscale(s, dry_run);
         s->current_picture_ptr->f->quality =
-        s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
+        s->current_picture.f->quality = quality;
         if (s->current_picture.f->quality < 0)
             return -1;
     }
@@ -3897,7 +3975,7 @@ static int encode_picture(MpegEncContext *s, int picture_number)
     s->last_bits= put_bits_count(&s->pb);
     switch(s->out_format) {
     case FMT_MJPEG:
-        if (CONFIG_MJPEG_ENCODER)
+        if (CONFIG_MJPEG_ENCODER && s->huffman != HUFFMAN_TABLE_OPTIMAL)
             ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
                                            s->pred, s->intra_matrix, s->chroma_intra_matrix);
         break;
@@ -3978,8 +4056,8 @@ static int dct_quantize_trellis_c(MpegEncContext *s,
                                   int qscale, int *overflow){
     const int *qmat;
     const uint16_t *matrix;
-    const uint8_t *scantable= s->intra_scantable.scantable;
-    const uint8_t *perm_scantable= s->intra_scantable.permutated;
+    const uint8_t *scantable;
+    const uint8_t *perm_scantable;
     int max=0;
     unsigned int threshold1, threshold2;
     int bias=0;
@@ -4013,6 +4091,8 @@ static int dct_quantize_trellis_c(MpegEncContext *s,
 
     if (s->mb_intra) {
         int q;
+        scantable= s->intra_scantable.scantable;
+        perm_scantable= s->intra_scantable.permutated;
         if (!s->h263_aic) {
             if (n < 4)
                 q = s->y_dc_scale;
@@ -4042,6 +4122,8 @@ static int dct_quantize_trellis_c(MpegEncContext *s,
             last_length= s->intra_ac_vlc_last_length;
         }
     } else {
+        scantable= s->inter_scantable.scantable;
+        perm_scantable= s->inter_scantable.permutated;
         start_i = 0;
         last_non_zero = -1;
         qmat = s->q_inter_matrix[qscale];
@@ -4309,8 +4391,8 @@ static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
                         int n, int qscale){
     int16_t rem[64];
     LOCAL_ALIGNED_16(int16_t, d1, [64]);
-    const uint8_t *scantable= s->intra_scantable.scantable;
-    const uint8_t *perm_scantable= s->intra_scantable.permutated;
+    const uint8_t *scantable;
+    const uint8_t *perm_scantable;
 //    unsigned int threshold1, threshold2;
 //    int bias=0;
     int run_tab[65];
@@ -4337,6 +4419,8 @@ static int messed_sign=0;
     qmul= qscale*2;
     qadd= (qscale-1)|1;
     if (s->mb_intra) {
+        scantable= s->intra_scantable.scantable;
+        perm_scantable= s->intra_scantable.permutated;
         if (!s->h263_aic) {
             if (n < 4)
                 q = s->y_dc_scale;
@@ -4362,6 +4446,8 @@ static int messed_sign=0;
             last_length= s->intra_ac_vlc_last_length;
         }
     } else {
+        scantable= s->inter_scantable.scantable;
+        perm_scantable= s->inter_scantable.permutated;
         dc= 0;
         start_i = 0;
         length     = s->inter_ac_vlc_length;
@@ -4726,7 +4812,7 @@ int ff_dct_quantize_c(MpegEncContext *s,
 {
     int i, j, level, last_non_zero, q, start_i;
     const int *qmat;
-    const uint8_t *scantable= s->intra_scantable.scantable;
+    const uint8_t *scantable;
     int bias;
     int max=0;
     unsigned int threshold1, threshold2;
@@ -4737,6 +4823,7 @@ int ff_dct_quantize_c(MpegEncContext *s,
         s->denoise_dct(s, block);
 
     if (s->mb_intra) {
+        scantable= s->intra_scantable.scantable;
         if (!s->h263_aic) {
             if (n < 4)
                 q = s->y_dc_scale;
@@ -4754,6 +4841,7 @@ int ff_dct_quantize_c(MpegEncContext *s,
         qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
         bias= s->intra_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
     } else {
+        scantable= s->inter_scantable.scantable;
         start_i = 0;
         last_non_zero = -1;
         qmat = s->q_inter_matrix[qscale];
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegvideo_motion.c b/mythtv/external/FFmpeg/libavcodec/mpegvideo_motion.c
index c29810f5986..c913504a657 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegvideo_motion.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegvideo_motion.c
@@ -48,8 +48,8 @@ static void gmc1_motion(MpegEncContext *s,
     motion_y   = s->sprite_offset[0][1];
     src_x      = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy + 1));
     src_y      = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy + 1));
-    motion_x <<= (3 - s->sprite_warping_accuracy);
-    motion_y <<= (3 - s->sprite_warping_accuracy);
+    motion_x *= 1 << (3 - s->sprite_warping_accuracy);
+    motion_y *= 1 << (3 - s->sprite_warping_accuracy);
     src_x      = av_clip(src_x, -16, s->width);
     if (src_x == s->width)
         motion_x = 0;
@@ -95,8 +95,8 @@ static void gmc1_motion(MpegEncContext *s,
     motion_y   = s->sprite_offset[1][1];
     src_x      = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy + 1));
     src_y      = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy + 1));
-    motion_x <<= (3 - s->sprite_warping_accuracy);
-    motion_y <<= (3 - s->sprite_warping_accuracy);
+    motion_x  *= 1 << (3 - s->sprite_warping_accuracy);
+    motion_y  *= 1 << (3 - s->sprite_warping_accuracy);
     src_x      = av_clip(src_x, -8, s->width >> 1);
     if (src_x == s->width >> 1)
         motion_x = 0;
@@ -246,13 +246,6 @@ void mpeg_motion_internal(MpegEncContext *s,
         uvsrc_x, uvsrc_y, v_edge_pos;
     ptrdiff_t uvlinesize, linesize;
 
-#if 0
-    if (s->quarter_sample) {
-        motion_x >>= 1;
-        motion_y >>= 1;
-    }
-#endif
-
     v_edge_pos = s->v_edge_pos >> field_based;
     linesize   = s->current_picture.f->linesize[0] << field_based;
     uvlinesize = s->current_picture.f->linesize[1] << field_based;
@@ -326,7 +319,9 @@ void mpeg_motion_internal(MpegEncContext *s,
         ptr_y = s->sc.edge_emu_buffer;
         if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
             uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
-            uint8_t *vbuf = ubuf + 9 * s->uvlinesize;
+            uint8_t *vbuf = ubuf + 10 * s->uvlinesize;
+            if (s->workaround_bugs & FF_BUG_IEDGE)
+                vbuf -= s->uvlinesize;
             uvsrc_y = (unsigned)uvsrc_y << field_based;
             s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
                                      s->uvlinesize, s->uvlinesize,
@@ -549,7 +544,9 @@ static inline void qpel_motion(MpegEncContext *s,
         ptr_y = s->sc.edge_emu_buffer;
         if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
             uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
-            uint8_t *vbuf = ubuf + 9 * s->uvlinesize;
+            uint8_t *vbuf = ubuf + 10 * s->uvlinesize;
+            if (s->workaround_bugs & FF_BUG_IEDGE)
+                vbuf -= s->uvlinesize;
             s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
                                      s->uvlinesize, s->uvlinesize,
                                      9, 9 + field_based,
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegvideo_parser.c b/mythtv/external/FFmpeg/libavcodec/mpegvideo_parser.c
index 206f268a785..de70cd5632d 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegvideo_parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegvideo_parser.c
@@ -168,8 +168,10 @@ static void mpegvideo_extract_headers(AVCodecParserContext *s,
 
     if (pix_fmt != AV_PIX_FMT_NONE) {
         s->format = pix_fmt;
-        s->width  = s->coded_width  = pc->width;
-        s->height = s->coded_height = pc->height;
+        s->width  = pc->width;
+        s->height = pc->height;
+        s->coded_width  = FFALIGN(pc->width,  16);
+        s->coded_height = FFALIGN(pc->height, 16);
     }
 
 #if FF_API_AVCTX_TIMEBASE
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegvideo_xvmc.c b/mythtv/external/FFmpeg/libavcodec/mpegvideo_xvmc.c
index b469c4e26f2..519a4481614 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegvideo_xvmc.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegvideo_xvmc.c
@@ -182,7 +182,7 @@ static void ff_xvmc_decode_mb(struct MpegEncContext *s)
         return;
     }
 
-    // from ff_mpv_decode_mb(), update DC predictors for P macroblocks
+    // from ff_mpv_reconstruct_mb(), update DC predictors for P macroblocks
     if (!s->mb_intra) {
         s->last_dc[0] =
         s->last_dc[1] =
diff --git a/mythtv/external/FFmpeg/libavcodec/mpegvideoencdsp.c b/mythtv/external/FFmpeg/libavcodec/mpegvideoencdsp.c
index a7c6102c36e..0af3d8bef8b 100644
--- a/mythtv/external/FFmpeg/libavcodec/mpegvideoencdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/mpegvideoencdsp.c
@@ -85,16 +85,6 @@ static int pix_norm1_c(uint8_t *pix, int line_size)
 
     for (i = 0; i < 16; i++) {
         for (j = 0; j < 16; j += 8) {
-#if 0
-            s += sq[pix[0]];
-            s += sq[pix[1]];
-            s += sq[pix[2]];
-            s += sq[pix[3]];
-            s += sq[pix[4]];
-            s += sq[pix[5]];
-            s += sq[pix[6]];
-            s += sq[pix[7]];
-#else
 #if HAVE_FAST_64BIT
             register uint64_t x = *(uint64_t *) pix;
             s += sq[x         & 0xff];
@@ -116,7 +106,6 @@ static int pix_norm1_c(uint8_t *pix, int line_size)
             s += sq[(x >>  8) & 0xff];
             s += sq[(x >> 16) & 0xff];
             s += sq[(x >> 24) & 0xff];
-#endif
 #endif
             pix += 8;
         }
diff --git a/mythtv/external/FFmpeg/libavcodec/mscc.c b/mythtv/external/FFmpeg/libavcodec/mscc.c
new file mode 100644
index 00000000000..6e4dbb014da
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/mscc.c
@@ -0,0 +1,249 @@
+/*
+ * Mandsoft Screen Capture Codec decoder
+ *
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "avcodec.h"
+#include "bytestream.h"
+#include "internal.h"
+
+#include <zlib.h>
+
+typedef struct MSCCContext {
+    unsigned          bpp;
+    unsigned int      decomp_size;
+    uint8_t          *decomp_buf;
+    unsigned int      uncomp_size;
+    uint8_t          *uncomp_buf;
+    z_stream          zstream;
+} MSCCContext;
+
+static int rle_uncompress(AVCodecContext *avctx, GetByteContext *gb, PutByteContext *pb, int bpp)
+{
+    while (bytestream2_get_bytes_left(gb) > 0) {
+        uint32_t fill;
+        int j;
+        unsigned run = bytestream2_get_byte(gb);
+
+        if (run) {
+            switch (avctx->bits_per_coded_sample) {
+            case 8:
+                fill = bytestream2_get_byte(gb);
+                break;
+            case 16:
+                fill = bytestream2_get_le16(gb);
+                break;
+            case 24:
+                fill = bytestream2_get_le24(gb);
+                break;
+            case 32:
+                fill = bytestream2_get_le32(gb);
+                break;
+            }
+
+            for (j = 0; j < run; j++) {
+                switch (avctx->bits_per_coded_sample) {
+                case 8:
+                    bytestream2_put_byte(pb, fill);
+                    break;
+                case 16:
+                    bytestream2_put_le16(pb, fill);
+                    break;
+                case 24:
+                    bytestream2_put_le24(pb, fill);
+                    break;
+                case 32:
+                    bytestream2_put_le32(pb, fill);
+                    break;
+                }
+            }
+        } else {
+            unsigned copy = bytestream2_get_byte(gb);
+
+            if (copy == 1) {
+                return 0;
+            } else if (copy == 2) {
+                unsigned x, y;
+
+                x = bytestream2_get_byte(gb);
+                y = bytestream2_get_byte(gb);
+
+                bytestream2_skip_p(pb, x * bpp);
+                bytestream2_skip_p(pb, y * bpp * avctx->width);
+            } else {
+                for (j = 0; j < copy; j++) {
+                    switch (avctx->bits_per_coded_sample) {
+                    case 8:
+                        bytestream2_put_byte(pb, bytestream2_get_byte(gb));
+                        break;
+                    case 16:
+                        bytestream2_put_le16(pb, bytestream2_get_le16(gb));
+                        break;
+                    case 24:
+                        bytestream2_put_le24(pb, bytestream2_get_le24(gb));
+                        break;
+                    case 32:
+                        bytestream2_put_le32(pb, bytestream2_get_le32(gb));
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    return AVERROR_INVALIDDATA;
+}
+
+static int decode_frame(AVCodecContext *avctx,
+                        void *data, int *got_frame,
+                        AVPacket *avpkt)
+{
+    MSCCContext *s = avctx->priv_data;
+    AVFrame *frame = data;
+    uint8_t *buf = avpkt->data;
+    int buf_size = avpkt->size;
+    GetByteContext gb;
+    PutByteContext pb;
+    int ret, j;
+
+    if (avpkt->size < 3)
+        return AVERROR_INVALIDDATA;
+    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
+        return ret;
+
+    if (avctx->codec_id == AV_CODEC_ID_MSCC) {
+        avpkt->data[2] ^= avpkt->data[0];
+        buf += 2;
+        buf_size -= 2;
+    }
+
+    ret = inflateReset(&s->zstream);
+    if (ret != Z_OK) {
+        av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
+        return AVERROR_UNKNOWN;
+    }
+    s->zstream.next_in   = buf;
+    s->zstream.avail_in  = buf_size;
+    s->zstream.next_out  = s->decomp_buf;
+    s->zstream.avail_out = s->decomp_size;
+    ret = inflate(&s->zstream, Z_FINISH);
+    if (ret != Z_STREAM_END) {
+        av_log(avctx, AV_LOG_ERROR, "Inflate error: %d\n", ret);
+        return AVERROR_UNKNOWN;
+    }
+
+    bytestream2_init(&gb, s->decomp_buf, s->zstream.total_out);
+    bytestream2_init_writer(&pb, s->uncomp_buf, s->uncomp_size);
+
+    ret = rle_uncompress(avctx, &gb, &pb, s->bpp);
+    if (ret)
+        return ret;
+
+    for (j = 0; j < avctx->height; j++) {
+        memcpy(frame->data[0] + (avctx->height - j - 1) * frame->linesize[0],
+               s->uncomp_buf + s->bpp * j * avctx->width, s->bpp * avctx->width);
+    }
+
+    frame->key_frame = 1;
+    frame->pict_type = AV_PICTURE_TYPE_I;
+
+    *got_frame = 1;
+
+    return avpkt->size;
+}
+
+static av_cold int decode_init(AVCodecContext *avctx)
+{
+    MSCCContext *s = avctx->priv_data;
+    int zret;
+
+    switch (avctx->bits_per_coded_sample) {
+    case  8: avctx->pix_fmt = AV_PIX_FMT_GRAY8;  break;
+    case 16: avctx->pix_fmt = AV_PIX_FMT_RGB555; break;
+    case 24: avctx->pix_fmt = AV_PIX_FMT_BGR24;  break;
+    case 32: avctx->pix_fmt = AV_PIX_FMT_BGRA;   break;
+    default:
+        av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", avctx->bits_per_coded_sample);
+        return AVERROR_INVALIDDATA;
+    }
+
+    s->bpp = avctx->bits_per_coded_sample >> 3;
+    memset(&s->zstream, 0, sizeof(z_stream));
+
+    s->decomp_size = 4 * avctx->height * ((avctx->width * avctx->bits_per_coded_sample + 31) / 32);
+    if (!(s->decomp_buf = av_malloc(s->decomp_size)))
+        return AVERROR(ENOMEM);
+
+    s->uncomp_size = 4 * avctx->height * ((avctx->width * avctx->bits_per_coded_sample + 31) / 32);
+    if (!(s->uncomp_buf = av_malloc(s->uncomp_size)))
+        return AVERROR(ENOMEM);
+
+    s->zstream.zalloc = Z_NULL;
+    s->zstream.zfree = Z_NULL;
+    s->zstream.opaque = Z_NULL;
+    zret = inflateInit(&s->zstream);
+    if (zret != Z_OK) {
+        av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
+        return AVERROR_UNKNOWN;
+    }
+
+    return 0;
+}
+
+static av_cold int decode_close(AVCodecContext *avctx)
+{
+    MSCCContext *s = avctx->priv_data;
+
+    av_freep(&s->decomp_buf);
+    s->decomp_size = 0;
+    av_freep(&s->uncomp_buf);
+    s->uncomp_size = 0;
+    inflateEnd(&s->zstream);
+
+    return 0;
+}
+
+AVCodec ff_mscc_decoder = {
+    .name             = "mscc",
+    .long_name        = NULL_IF_CONFIG_SMALL("Mandsoft Screen Capture Codec"),
+    .type             = AVMEDIA_TYPE_VIDEO,
+    .id               = AV_CODEC_ID_MSCC,
+    .priv_data_size   = sizeof(MSCCContext),
+    .init             = decode_init,
+    .close            = decode_close,
+    .decode           = decode_frame,
+    .capabilities     = AV_CODEC_CAP_DR1,
+};
+
+AVCodec ff_srgc_decoder = {
+    .name             = "srgc",
+    .long_name        = NULL_IF_CONFIG_SMALL("Screen Recorder Gold Codec"),
+    .type             = AVMEDIA_TYPE_VIDEO,
+    .id               = AV_CODEC_ID_SRGC,
+    .priv_data_size   = sizeof(MSCCContext),
+    .init             = decode_init,
+    .close            = decode_close,
+    .decode           = decode_frame,
+    .capabilities     = AV_CODEC_CAP_DR1,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/msmpeg4dec.c b/mythtv/external/FFmpeg/libavcodec/msmpeg4dec.c
index 77e8509f9dc..4105d4ba7d0 100644
--- a/mythtv/external/FFmpeg/libavcodec/msmpeg4dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/msmpeg4dec.c
@@ -140,7 +140,7 @@ static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
         if(s->msmpeg4_version==2)
             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
         else
-            cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
+            cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
         if(cbp<0 || cbp>3){
             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
             return -1;
@@ -169,12 +169,23 @@ static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
         s->mv[0][0][1] = my;
         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
     } else {
+        int v;
         if(s->msmpeg4_version==2){
             s->ac_pred = get_bits1(&s->gb);
-            cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
+            v = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
+            if (v < 0) {
+                av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
+                return -1;
+            }
+            cbp|= v<<2;
         } else{
             s->ac_pred = 0;
-            cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
+            v = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
+            if (v < 0) {
+                av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n");
+                return -1;
+            }
+            cbp|= v<<2;
             if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
         }
         *mb_type_ptr = MB_TYPE_INTRA;
@@ -414,13 +425,6 @@ int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
         av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
         return -1;
     }
-#if 0
-{
-    static int had_i=0;
-    if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;
-    if(!had_i) return -1;
-}
-#endif
     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
     if(s->qscale==0){
         av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
@@ -873,6 +877,7 @@ AVCodec ff_msmpeg4v1_decoder = {
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .max_lowres     = 3,
     .pix_fmts       = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_YUV420P,
@@ -890,6 +895,7 @@ AVCodec ff_msmpeg4v2_decoder = {
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .max_lowres     = 3,
     .pix_fmts       = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_YUV420P,
@@ -907,6 +913,7 @@ AVCodec ff_msmpeg4v3_decoder = {
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .max_lowres     = 3,
     .pix_fmts       = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_YUV420P,
@@ -924,6 +931,7 @@ AVCodec ff_wmv1_decoder = {
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
     .max_lowres     = 3,
     .pix_fmts       = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_YUV420P,
diff --git a/mythtv/external/FFmpeg/libavcodec/msmpeg4enc.c b/mythtv/external/FFmpeg/libavcodec/msmpeg4enc.c
index 07241e89130..144468b24f1 100644
--- a/mythtv/external/FFmpeg/libavcodec/msmpeg4enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/msmpeg4enc.c
@@ -314,11 +314,6 @@ void ff_msmpeg4_encode_motion(MpegEncContext * s,
 
     mx += 32;
     my += 32;
-#if 0
-    if ((unsigned)mx >= 64 ||
-        (unsigned)my >= 64)
-        av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);
-#endif
     mv = &ff_mv_tables[s->mv_table_index];
 
     code = mv->table_mv_index[(mx << 6) | my];
diff --git a/mythtv/external/FFmpeg/libavcodec/msrle.c b/mythtv/external/FFmpeg/libavcodec/msrle.c
index c2f624283d3..adb55b1302c 100644
--- a/mythtv/external/FFmpeg/libavcodec/msrle.c
+++ b/mythtv/external/FFmpeg/libavcodec/msrle.c
@@ -99,11 +99,14 @@ static int msrle_decode_frame(AVCodecContext *avctx,
         return ret;
 
     if (avctx->bits_per_coded_sample > 1 && avctx->bits_per_coded_sample <= 8) {
-        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
+        int size;
+        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
 
-        if (pal) {
+        if (pal && size == AVPALETTE_SIZE) {
             s->frame->palette_has_changed = 1;
             memcpy(s->pal, pal, AVPALETTE_SIZE);
+        } else if (pal) {
+            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
         }
         /* make the palette available */
         memcpy(s->frame->data[1], s->pal, AVPALETTE_SIZE);
diff --git a/mythtv/external/FFmpeg/libavcodec/msrledec.c b/mythtv/external/FFmpeg/libavcodec/msrledec.c
index 805802ae181..f0cbde67ffc 100644
--- a/mythtv/external/FFmpeg/libavcodec/msrledec.c
+++ b/mythtv/external/FFmpeg/libavcodec/msrledec.c
@@ -63,7 +63,7 @@ static int msrle_decode_pal4(AVCodecContext *avctx, AVFrame *pic,
                 stream_byte = bytestream2_get_byte(gb);
                 pixel_ptr += stream_byte;
                 stream_byte = bytestream2_get_byte(gb);
-                avpriv_request_sample(avctx, "Unused stream byte %X", stream_byte);
+                line -= stream_byte;
             } else {
                 // copy pixels from encoded stream
                 odd_pixel =  stream_byte & 1;
diff --git a/mythtv/external/FFmpeg/libavcodec/mss12.c b/mythtv/external/FFmpeg/libavcodec/mss12.c
index d42093b0a30..3b1a3029e07 100644
--- a/mythtv/external/FFmpeg/libavcodec/mss12.c
+++ b/mythtv/external/FFmpeg/libavcodec/mss12.c
@@ -197,7 +197,7 @@ static av_always_inline int decode_pixel(ArithCoder *acoder, PixContext *pctx,
 }
 
 static int decode_pixel_in_context(ArithCoder *acoder, PixContext *pctx,
-                                   uint8_t *src, int stride, int x, int y,
+                                   uint8_t *src, ptrdiff_t stride, int x, int y,
                                    int has_right)
 {
     uint8_t neighbours[4];
@@ -290,8 +290,9 @@ static int decode_pixel_in_context(ArithCoder *acoder, PixContext *pctx,
 }
 
 static int decode_region(ArithCoder *acoder, uint8_t *dst, uint8_t *rgb_pic,
-                         int x, int y, int width, int height, int stride,
-                         int rgb_stride, PixContext *pctx, const uint32_t *pal)
+                         int x, int y, int width, int height, ptrdiff_t stride,
+                         ptrdiff_t rgb_stride, PixContext *pctx,
+                         const uint32_t *pal)
 {
     int i, j, p;
     uint8_t *rgb_dst = rgb_pic + x * 3 + y * rgb_stride;
@@ -368,8 +369,8 @@ static int motion_compensation(MSS12Context const *c,
 }
 
 static int decode_region_masked(MSS12Context const *c, ArithCoder *acoder,
-                                uint8_t *dst, int stride, uint8_t *mask,
-                                int mask_stride, int x, int y,
+                                uint8_t *dst, ptrdiff_t stride, uint8_t *mask,
+                                ptrdiff_t mask_stride, int x, int y,
                                 int width, int height,
                                 PixContext *pctx)
 {
@@ -466,8 +467,8 @@ static int decode_region_intra(SliceContext *sc, ArithCoder *acoder,
 
     if (!mode) {
         int i, j, pix, rgb_pix;
-        int stride       = c->pal_stride;
-        int rgb_stride   = c->rgb_stride;
+        ptrdiff_t stride     = c->pal_stride;
+        ptrdiff_t rgb_stride = c->rgb_stride;
         uint8_t *dst     = c->pal_pic + x     + y * stride;
         uint8_t *rgb_dst = c->rgb_pic + x * 3 + y * rgb_stride;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mss12.h b/mythtv/external/FFmpeg/libavcodec/mss12.h
index f9531673894..45c40746527 100644
--- a/mythtv/external/FFmpeg/libavcodec/mss12.h
+++ b/mythtv/external/FFmpeg/libavcodec/mss12.h
@@ -77,12 +77,12 @@ typedef struct MSS12Context {
     uint32_t       pal[256];
     uint8_t        *pal_pic;
     uint8_t        *last_pal_pic;
-    int            pal_stride;
+    ptrdiff_t      pal_stride;
     uint8_t        *mask;
-    int            mask_stride;
+    ptrdiff_t      mask_stride;
     uint8_t        *rgb_pic;
     uint8_t        *last_rgb_pic;
-    int            rgb_stride;
+    ptrdiff_t      rgb_stride;
     int            free_colours;
     int            keyframe;
     int            mvX, mvY;
diff --git a/mythtv/external/FFmpeg/libavcodec/mss2.c b/mythtv/external/FFmpeg/libavcodec/mss2.c
index 1e24568128b..9e7cc466dec 100644
--- a/mythtv/external/FFmpeg/libavcodec/mss2.c
+++ b/mythtv/external/FFmpeg/libavcodec/mss2.c
@@ -174,7 +174,7 @@ static int decode_pal_v2(MSS12Context *ctx, const uint8_t *buf, int buf_size)
     return 1 + ncol * 3;
 }
 
-static int decode_555(GetByteContext *gB, uint16_t *dst, int stride,
+static int decode_555(GetByteContext *gB, uint16_t *dst, ptrdiff_t stride,
                       int keyframe, int w, int h)
 {
     int last_symbol = 0, repeat = 0, prev_avail = 0;
@@ -237,8 +237,8 @@ static int decode_555(GetByteContext *gB, uint16_t *dst, int stride,
     return 0;
 }
 
-static int decode_rle(GetBitContext *gb, uint8_t *pal_dst, int pal_stride,
-                      uint8_t *rgb_dst, int rgb_stride, uint32_t *pal,
+static int decode_rle(GetBitContext *gb, uint8_t *pal_dst, ptrdiff_t pal_stride,
+                      uint8_t *rgb_dst, ptrdiff_t rgb_stride, uint32_t *pal,
                       int keyframe, int kf_slipt, int slice, int w, int h)
 {
     uint8_t bits[270] = { 0 };
@@ -422,7 +422,13 @@ static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,
 
     ff_vc1_decode_blocks(v);
 
-    ff_er_frame_end(&s->er);
+    if (v->end_mb_x == s->mb_width && s->end_mb_y == s->mb_height) {
+        ff_er_frame_end(&s->er);
+    } else {
+        av_log(v->s.avctx, AV_LOG_WARNING,
+               "disabling error correction due to block count mismatch %dx%d != %dx%d\n",
+               v->end_mb_x, s->end_mb_y, s->mb_width, s->mb_height);
+    }
 
     ff_mpv_frame_end(s);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/mss2dsp.c b/mythtv/external/FFmpeg/libavcodec/mss2dsp.c
index c5fc1f8dcf3..cc39dd637f2 100644
--- a/mythtv/external/FFmpeg/libavcodec/mss2dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/mss2dsp.c
@@ -27,17 +27,17 @@
 #include "libavutil/common.h"
 
 static av_always_inline void mss2_blit_wmv9_template(uint8_t *dst,
-                                                     int dst_stride,
+                                                     ptrdiff_t dst_stride,
                                                      int gray,
                                                      int use_mask,
                                                      int maskcolor,
                                                      const uint8_t *mask,
-                                                     int mask_stride,
+                                                     ptrdiff_t mask_stride,
                                                      const uint8_t *srcy,
-                                                     int srcy_stride,
+                                                     ptrdiff_t srcy_stride,
                                                      const uint8_t *srcu,
                                                      const uint8_t *srcv,
-                                                     int srcuv_stride,
+                                                     ptrdiff_t srcuv_stride,
                                                      int w, int h)
 {
     int i, j, k, r = -1;
@@ -64,10 +64,10 @@ static av_always_inline void mss2_blit_wmv9_template(uint8_t *dst,
     }
 }
 
-static void mss2_blit_wmv9_c(uint8_t *dst, int dst_stride,
-                             const uint8_t *srcy, int srcy_stride,
+static void mss2_blit_wmv9_c(uint8_t *dst, ptrdiff_t dst_stride,
+                             const uint8_t *srcy, ptrdiff_t srcy_stride,
                              const uint8_t *srcu, const uint8_t *srcv,
-                             int srcuv_stride, int w, int h)
+                             ptrdiff_t srcuv_stride, int w, int h)
 {
     mss2_blit_wmv9_template(dst, dst_stride, 0, 0,
                             0, NULL, 0,
@@ -76,12 +76,12 @@ static void mss2_blit_wmv9_c(uint8_t *dst, int dst_stride,
                             w, h);
 }
 
-static void mss2_blit_wmv9_masked_c(uint8_t *dst, int dst_stride,
+static void mss2_blit_wmv9_masked_c(uint8_t *dst, ptrdiff_t dst_stride,
                                     int maskcolor, const uint8_t *mask,
-                                    int mask_stride,
-                                    const uint8_t *srcy, int srcy_stride,
+                                    ptrdiff_t mask_stride,
+                                    const uint8_t *srcy, ptrdiff_t srcy_stride,
                                     const uint8_t *srcu, const uint8_t *srcv,
-                                    int srcuv_stride, int w, int h)
+                                    ptrdiff_t srcuv_stride, int w, int h)
 {
     mss2_blit_wmv9_template(dst, dst_stride, 0, 1,
                             maskcolor, mask, mask_stride,
@@ -90,9 +90,9 @@ static void mss2_blit_wmv9_masked_c(uint8_t *dst, int dst_stride,
                             w, h);
 }
 
-static void mss2_gray_fill_masked_c(uint8_t *dst, int dst_stride,
+static void mss2_gray_fill_masked_c(uint8_t *dst, ptrdiff_t dst_stride,
                                     int maskcolor, const uint8_t *mask,
-                                    int mask_stride, int w, int h)
+                                    ptrdiff_t mask_stride, int w, int h)
 {
     mss2_blit_wmv9_template(dst, dst_stride, 1, 1,
                             maskcolor, mask, mask_stride,
@@ -101,7 +101,7 @@ static void mss2_gray_fill_masked_c(uint8_t *dst, int dst_stride,
                             w, h);
 }
 
-static void upsample_plane_c(uint8_t *plane, int plane_stride, int w, int h)
+static void upsample_plane_c(uint8_t *plane, ptrdiff_t plane_stride, int w, int h)
 {
     uint8_t *src1, *src2, *dst1, *dst2, *p, a, b;
     int i, j;
diff --git a/mythtv/external/FFmpeg/libavcodec/mss2dsp.h b/mythtv/external/FFmpeg/libavcodec/mss2dsp.h
index 7368abb581a..e44c9ab5278 100644
--- a/mythtv/external/FFmpeg/libavcodec/mss2dsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/mss2dsp.h
@@ -26,23 +26,25 @@
 #ifndef AVCODEC_MSS2DSP_H
 #define AVCODEC_MSS2DSP_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 typedef struct MSS2DSPContext {
-    void (*mss2_blit_wmv9)(uint8_t *dst, int dst_stride,
-                           const uint8_t *srcy, int srcy_stride,
+    void (*mss2_blit_wmv9)(uint8_t *dst, ptrdiff_t dst_stride,
+                           const uint8_t *srcy, ptrdiff_t srcy_stride,
                            const uint8_t *srcu, const uint8_t *srcv,
-                           int srcuv_stride, int w, int h);
-    void (*mss2_blit_wmv9_masked)(uint8_t *dst, int dst_stride,
+                           ptrdiff_t srcuv_stride, int w, int h);
+    void (*mss2_blit_wmv9_masked)(uint8_t *dst, ptrdiff_t dst_stride,
                                   int maskcolor, const uint8_t *mask,
-                                  int mask_stride,
-                                  const uint8_t *srcy, int srcy_stride,
+                                  ptrdiff_t mask_stride,
+                                  const uint8_t *srcy, ptrdiff_t srcy_stride,
                                   const uint8_t *srcu, const uint8_t *srcv,
-                                  int srcuv_stride, int w, int h);
-    void (*mss2_gray_fill_masked)(uint8_t *dst, int dst_stride,
+                                  ptrdiff_t srcuv_stride, int w, int h);
+    void (*mss2_gray_fill_masked)(uint8_t *dst, ptrdiff_t dst_stride,
                                   int maskcolor, const uint8_t *mask,
-                                  int mask_stride, int w, int h);
-    void (*upsample_plane)(uint8_t *plane, int plane_stride, int w, int h);
+                                  ptrdiff_t mask_stride, int w, int h);
+    void (*upsample_plane)(uint8_t *plane, ptrdiff_t plane_stride,
+                           int w, int h);
 } MSS2DSPContext;
 
 void ff_mss2dsp_init(MSS2DSPContext *dsp);
diff --git a/mythtv/external/FFmpeg/libavcodec/mss3.c b/mythtv/external/FFmpeg/libavcodec/mss3.c
index 01941967a59..21226f90851 100644
--- a/mythtv/external/FFmpeg/libavcodec/mss3.c
+++ b/mythtv/external/FFmpeg/libavcodec/mss3.c
@@ -91,7 +91,7 @@ typedef struct ImageBlockCoder {
 
 typedef struct DCTBlockCoder {
     int      *prev_dc;
-    int      prev_dc_stride;
+    ptrdiff_t prev_dc_stride;
     int      prev_dc_height;
     int      quality;
     uint16_t qmat[64];
@@ -356,8 +356,9 @@ static int rac_get_model2_sym(RangeCoder *c, Model2 *m)
 
 static int rac_get_model_sym(RangeCoder *c, Model *m)
 {
-    int prob, prob2, helper, val;
+    int val;
     int end, end2;
+    unsigned prob, prob2, helper;
 
     prob       = 0;
     prob2      = c->range;
@@ -388,9 +389,10 @@ static int rac_get_model_sym(RangeCoder *c, Model *m)
 
 static int rac_get_model256_sym(RangeCoder *c, Model256 *m)
 {
-    int prob, prob2, helper, val;
+    int val;
     int start, end;
     int ssym;
+    unsigned prob, prob2, helper;
 
     prob2      = c->range;
     c->range >>= MODEL_SCALE;
@@ -450,7 +452,7 @@ static int decode_coeff(RangeCoder *c, Model *m)
 }
 
 static void decode_fill_block(RangeCoder *c, FillBlockCoder *fc,
-                              uint8_t *dst, int stride, int block_size)
+                              uint8_t *dst, ptrdiff_t stride, int block_size)
 {
     int i;
 
@@ -461,7 +463,7 @@ static void decode_fill_block(RangeCoder *c, FillBlockCoder *fc,
 }
 
 static void decode_image_block(RangeCoder *c, ImageBlockCoder *ic,
-                               uint8_t *dst, int stride, int block_size)
+                               uint8_t *dst, ptrdiff_t stride, int block_size)
 {
     int i, j;
     int vec_size;
@@ -557,7 +559,7 @@ static int decode_dct(RangeCoder *c, DCTBlockCoder *bc, int *block,
 }
 
 static void decode_dct_block(RangeCoder *c, DCTBlockCoder *bc,
-                             uint8_t *dst, int stride, int block_size,
+                             uint8_t *dst, ptrdiff_t stride, int block_size,
                              int *block, int mb_x, int mb_y)
 {
     int i, j;
@@ -580,8 +582,8 @@ static void decode_dct_block(RangeCoder *c, DCTBlockCoder *bc,
 }
 
 static void decode_haar_block(RangeCoder *c, HaarBlockCoder *hc,
-                              uint8_t *dst, int stride, int block_size,
-                              int *block)
+                              uint8_t *dst, ptrdiff_t stride,
+                              int block_size, int *block)
 {
     const int hsize = block_size >> 1;
     int A, B, C, D, t1, t2, t3, t4;
diff --git a/mythtv/external/FFmpeg/libavcodec/mss34dsp.c b/mythtv/external/FFmpeg/libavcodec/mss34dsp.c
index 0397add17d4..f3405658f7f 100644
--- a/mythtv/external/FFmpeg/libavcodec/mss34dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/mss34dsp.c
@@ -62,32 +62,32 @@ void ff_mss34_gen_quant_mat(uint16_t *qmat, int quality, int luma)
 }
 
 #define DCT_TEMPLATE(blk, step, SOP, shift)                         \
-    const int t0 = -39409 * blk[7 * step] -  58980 * blk[1 * step]; \
-    const int t1 =  39410 * blk[1 * step] -  58980 * blk[7 * step]; \
-    const int t2 = -33410 * blk[5 * step] - 167963 * blk[3 * step]; \
-    const int t3 =  33410 * blk[3 * step] - 167963 * blk[5 * step]; \
-    const int t4 =          blk[3 * step] +          blk[7 * step]; \
-    const int t5 =          blk[1 * step] +          blk[5 * step]; \
-    const int t6 =  77062 * t4            +  51491 * t5;            \
-    const int t7 =  77062 * t5            -  51491 * t4;            \
-    const int t8 =  35470 * blk[2 * step] -  85623 * blk[6 * step]; \
-    const int t9 =  35470 * blk[6 * step] +  85623 * blk[2 * step]; \
-    const int tA = SOP(blk[0 * step] - blk[4 * step]);              \
-    const int tB = SOP(blk[0 * step] + blk[4 * step]);              \
+    const unsigned t0 =-39409U * blk[7 * step] - 58980U * blk[1 * step]; \
+    const unsigned t1 = 39410U * blk[1 * step] - 58980U * blk[7 * step]; \
+    const unsigned t2 =-33410U * blk[5 * step] -167963U * blk[3 * step]; \
+    const unsigned t3 = 33410U * blk[3 * step] -167963U * blk[5 * step]; \
+    const unsigned t4 =          blk[3 * step] +          blk[7 * step]; \
+    const unsigned t5 =          blk[1 * step] +          blk[5 * step]; \
+    const unsigned t6 = 77062U * t4            + 51491U * t5;            \
+    const unsigned t7 = 77062U * t5            - 51491U * t4;            \
+    const unsigned t8 = 35470U * blk[2 * step] - 85623U * blk[6 * step]; \
+    const unsigned t9 = 35470U * blk[6 * step] + 85623U * blk[2 * step]; \
+    const unsigned tA = SOP(blk[0 * step] - blk[4 * step]);              \
+    const unsigned tB = SOP(blk[0 * step] + blk[4 * step]);              \
                                                                     \
-    blk[0 * step] = (  t1 + t6  + t9 + tB) >> shift;                \
-    blk[1 * step] = (  t3 + t7  + t8 + tA) >> shift;                \
-    blk[2 * step] = (  t2 + t6  - t8 + tA) >> shift;                \
-    blk[3 * step] = (  t0 + t7  - t9 + tB) >> shift;                \
-    blk[4 * step] = (-(t0 + t7) - t9 + tB) >> shift;                \
-    blk[5 * step] = (-(t2 + t6) - t8 + tA) >> shift;                \
-    blk[6 * step] = (-(t3 + t7) + t8 + tA) >> shift;                \
-    blk[7 * step] = (-(t1 + t6) + t9 + tB) >> shift;                \
+    blk[0 * step] = (int)(  t1 + t6  + t9 + tB) >> shift;                \
+    blk[1 * step] = (int)(  t3 + t7  + t8 + tA) >> shift;                \
+    blk[2 * step] = (int)(  t2 + t6  - t8 + tA) >> shift;                \
+    blk[3 * step] = (int)(  t0 + t7  - t9 + tB) >> shift;                \
+    blk[4 * step] = (int)(-(t0 + t7) - t9 + tB) >> shift;                \
+    blk[5 * step] = (int)(-(t2 + t6) - t8 + tA) >> shift;                \
+    blk[6 * step] = (int)(-(t3 + t7) + t8 + tA) >> shift;                \
+    blk[7 * step] = (int)(-(t1 + t6) + t9 + tB) >> shift;                \
 
-#define SOP_ROW(a) (((a) << 16) + 0x2000)
-#define SOP_COL(a) (((a) + 32) << 16)
+#define SOP_ROW(a) (((a) * (1U << 16)) + 0x2000)
+#define SOP_COL(a) (((a) + 32) * (1U << 16))
 
-void ff_mss34_dct_put(uint8_t *dst, int stride, int *block)
+void ff_mss34_dct_put(uint8_t *dst, ptrdiff_t stride, int *block)
 {
     int i, j;
     int *ptr;
diff --git a/mythtv/external/FFmpeg/libavcodec/mss34dsp.h b/mythtv/external/FFmpeg/libavcodec/mss34dsp.h
index 2f9827d3e57..29c61e34f37 100644
--- a/mythtv/external/FFmpeg/libavcodec/mss34dsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/mss34dsp.h
@@ -22,6 +22,7 @@
 #ifndef AVCODEC_MSS34DSP_H
 #define AVCODEC_MSS34DSP_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 /**
@@ -40,6 +41,6 @@ void ff_mss34_gen_quant_mat(uint16_t *qmat, int quality, int luma);
  * @param stride  output plane stride
  * @param block   block to transform and output
  */
-void ff_mss34_dct_put(uint8_t *dst, int stride, int *block);
+void ff_mss34_dct_put(uint8_t *dst, ptrdiff_t stride, int *block);
 
 #endif /* AVCODEC_MSS34DSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/mss4.c b/mythtv/external/FFmpeg/libavcodec/mss4.c
index 9639fc820e2..b58c21be938 100644
--- a/mythtv/external/FFmpeg/libavcodec/mss4.c
+++ b/mythtv/external/FFmpeg/libavcodec/mss4.c
@@ -136,7 +136,7 @@ typedef struct MSS4Context {
     uint16_t   quant_mat[2][64];
 
     int        *prev_dc[3];
-    int        dc_stride[3];
+    ptrdiff_t  dc_stride[3];
     int        dc_cache[4][4];
 
     int        prev_vec[3][4];
diff --git a/mythtv/external/FFmpeg/libavcodec/msvideo1.c b/mythtv/external/FFmpeg/libavcodec/msvideo1.c
index 1d141723f63..29700f54b66 100644
--- a/mythtv/external/FFmpeg/libavcodec/msvideo1.c
+++ b/mythtv/external/FFmpeg/libavcodec/msvideo1.c
@@ -301,15 +301,24 @@ static int msvideo1_decode_frame(AVCodecContext *avctx,
     s->buf = buf;
     s->size = buf_size;
 
+    // Discard frame if its smaller than the minimum frame size
+    if (buf_size < (avctx->width/4) * (avctx->height/4) / 512) {
+        av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
+        return AVERROR_INVALIDDATA;
+    }
+
     if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
         return ret;
 
     if (s->mode_8bit) {
-        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
+        int size;
+        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
 
-        if (pal) {
+        if (pal && size == AVPALETTE_SIZE) {
             memcpy(s->pal, pal, AVPALETTE_SIZE);
             s->frame->palette_has_changed = 1;
+        } else if (pal) {
+            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
         }
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/nellymoser.c b/mythtv/external/FFmpeg/libavcodec/nellymoser.c
index 027726e0ba6..5ff6583c5ea 100644
--- a/mythtv/external/FFmpeg/libavcodec/nellymoser.c
+++ b/mythtv/external/FFmpeg/libavcodec/nellymoser.c
@@ -84,7 +84,7 @@ const int16_t ff_nelly_delta_table[32] = {
 
 static inline int signed_shift(int i, int shift) {
     if (shift > 0)
-        return i << shift;
+        return (unsigned)i << shift;
     return i >> -shift;
 }
 
@@ -108,7 +108,7 @@ static int headroom(int *la)
         return 31;
     }
     l = 30 - av_log2(FFABS(*la));
-    *la <<= l;
+    *la *= 1<<l;
     return l;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/noise_bsf.c b/mythtv/external/FFmpeg/libavcodec/noise_bsf.c
index 0aebee1ad63..84b94032ad3 100644
--- a/mythtv/external/FFmpeg/libavcodec/noise_bsf.c
+++ b/mythtv/external/FFmpeg/libavcodec/noise_bsf.c
@@ -31,6 +31,7 @@
 typedef struct NoiseContext {
     const AVClass *class;
     int amount;
+    int dropamount;
     unsigned int state;
 } NoiseContext;
 
@@ -48,6 +49,12 @@ static int noise(AVBSFContext *ctx, AVPacket *out)
     if (ret < 0)
         return ret;
 
+    if (s->dropamount > 0 && s->state % s->dropamount == 0) {
+        s->state++;
+        av_packet_free(&in);
+        return AVERROR(EAGAIN);
+    }
+
     ret = av_new_packet(out, in->size);
     if (ret < 0)
         goto fail;
@@ -73,6 +80,7 @@ static int noise(AVBSFContext *ctx, AVPacket *out)
 #define OFFSET(x) offsetof(NoiseContext, x)
 static const AVOption options[] = {
     { "amount", NULL, OFFSET(amount), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX },
+    { "dropamount", NULL, OFFSET(dropamount), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX },
     { NULL },
 };
 
diff --git a/mythtv/external/FFmpeg/libavcodec/null_bsf.c b/mythtv/external/FFmpeg/libavcodec/null_bsf.c
new file mode 100644
index 00000000000..feb71248a97
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/null_bsf.c
@@ -0,0 +1,43 @@
+/*
+ * 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
+ * Null bitstream filter -- pass the input through unchanged.
+ */
+
+#include "avcodec.h"
+#include "bsf.h"
+
+static int null_filter(AVBSFContext *ctx, AVPacket *out)
+{
+    AVPacket *in;
+    int ret;
+
+    ret = ff_bsf_get_packet(ctx, &in);
+    if (ret < 0)
+        return ret;
+    av_packet_move_ref(out, in);
+    av_packet_free(&in);
+    return 0;
+}
+
+const AVBitStreamFilter ff_null_bsf = {
+    .name           = "null",
+    .filter         = null_filter,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/nvenc.c b/mythtv/external/FFmpeg/libavcodec/nvenc.c
index 2505c3d1e3f..e1d3316de39 100644
--- a/mythtv/external/FFmpeg/libavcodec/nvenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/nvenc.c
@@ -21,59 +21,20 @@
 
 #include "config.h"
 
-#if defined(_WIN32) || defined(__CYGWIN__)
-# define CUDA_LIBNAME "nvcuda.dll"
-# if ARCH_X86_64
-#  define NVENC_LIBNAME "nvEncodeAPI64.dll"
-# else
-#  define NVENC_LIBNAME "nvEncodeAPI.dll"
-# endif
-#else
-# define CUDA_LIBNAME "libcuda.so.1"
-# define NVENC_LIBNAME "libnvidia-encode.so.1"
-#endif
-
-#if defined(_WIN32)
-#include <windows.h>
-
-#define dlopen(filename, flags) LoadLibrary(TEXT(filename))
-#define dlsym(handle, symbol)   GetProcAddress(handle, symbol)
-#define dlclose(handle)         FreeLibrary(handle)
-#else
-#include <dlfcn.h>
-#endif
+#include "nvenc.h"
 
+#include "libavutil/hwcontext_cuda.h"
 #include "libavutil/hwcontext.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/avassert.h"
 #include "libavutil/mem.h"
+#include "libavutil/pixdesc.h"
 #include "internal.h"
-#include "nvenc.h"
 
 #define NVENC_CAP 0x30
-#define IS_CBR(rc) (rc == NV_ENC_PARAMS_RC_CBR ||               \
-                    rc == NV_ENC_PARAMS_RC_2_PASS_QUALITY ||    \
-                    rc == NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP)
-
-#define LOAD_LIBRARY(l, path)                   \
-    do {                                        \
-        if (!((l) = dlopen(path, RTLD_LAZY))) { \
-            av_log(avctx, AV_LOG_ERROR,         \
-                   "Cannot load %s\n",          \
-                   path);                       \
-            return AVERROR_UNKNOWN;             \
-        }                                       \
-    } while (0)
-
-#define LOAD_SYMBOL(fun, lib, symbol)        \
-    do {                                     \
-        if (!((fun) = dlsym(lib, symbol))) { \
-            av_log(avctx, AV_LOG_ERROR,      \
-                   "Cannot load %s\n",       \
-                   symbol);                  \
-            return AVERROR_UNKNOWN;          \
-        }                                    \
-    } while (0)
+#define IS_CBR(rc) (rc == NV_ENC_PARAMS_RC_CBR ||             \
+                    rc == NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ || \
+                    rc == NV_ENC_PARAMS_RC_CBR_HQ)
 
 const enum AVPixelFormat ff_nvenc_pix_fmts[] = {
     AV_PIX_FMT_YUV420P,
@@ -83,14 +44,12 @@ const enum AVPixelFormat ff_nvenc_pix_fmts[] = {
     AV_PIX_FMT_YUV444P16,
     AV_PIX_FMT_0RGB32,
     AV_PIX_FMT_0BGR32,
-#if CONFIG_CUDA
     AV_PIX_FMT_CUDA,
-#endif
     AV_PIX_FMT_NONE
 };
 
-#define IS_10BIT(pix_fmt) (pix_fmt == AV_PIX_FMT_P010 ||    \
-                           pix_fmt == AV_PIX_FMT_YUV444P16)
+#define IS_10BIT(pix_fmt)  (pix_fmt == AV_PIX_FMT_P010    || \
+                            pix_fmt == AV_PIX_FMT_YUV444P16)
 
 #define IS_YUV444(pix_fmt) (pix_fmt == AV_PIX_FMT_YUV444P || \
                             pix_fmt == AV_PIX_FMT_YUV444P16)
@@ -144,7 +103,7 @@ static int nvenc_map_error(NVENCSTATUS err, const char **desc)
 }
 
 static int nvenc_print_error(void *log_ctx, NVENCSTATUS err,
-                                     const char *error_string)
+                             const char *error_string)
 {
     const char *desc;
     int ret;
@@ -153,46 +112,35 @@ static int nvenc_print_error(void *log_ctx, NVENCSTATUS err,
     return ret;
 }
 
+static void nvenc_print_driver_requirement(AVCodecContext *avctx, int level)
+{
+#if defined(_WIN32) || defined(__CYGWIN__)
+    const char *minver = "378.66";
+#else
+    const char *minver = "378.13";
+#endif
+    av_log(avctx, level, "The minimum required Nvidia driver for nvenc is %s or newer\n", minver);
+}
+
 static av_cold int nvenc_load_libraries(AVCodecContext *avctx)
 {
-    NvencContext *ctx = avctx->priv_data;
+    NvencContext *ctx            = avctx->priv_data;
     NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs;
-    PNVENCODEAPIGETMAXSUPPORTEDVERSION nvenc_get_max_ver;
-    PNVENCODEAPICREATEINSTANCE nvenc_create_instance;
     NVENCSTATUS err;
     uint32_t nvenc_max_ver;
+    int ret;
 
-#if CONFIG_CUDA
-    dl_fn->cu_init                      = cuInit;
-    dl_fn->cu_device_get_count          = cuDeviceGetCount;
-    dl_fn->cu_device_get                = cuDeviceGet;
-    dl_fn->cu_device_get_name           = cuDeviceGetName;
-    dl_fn->cu_device_compute_capability = cuDeviceComputeCapability;
-    dl_fn->cu_ctx_create                = cuCtxCreate_v2;
-    dl_fn->cu_ctx_pop_current           = cuCtxPopCurrent_v2;
-    dl_fn->cu_ctx_destroy               = cuCtxDestroy_v2;
-#else
-    LOAD_LIBRARY(dl_fn->cuda, CUDA_LIBNAME);
-
-    LOAD_SYMBOL(dl_fn->cu_init, dl_fn->cuda, "cuInit");
-    LOAD_SYMBOL(dl_fn->cu_device_get_count, dl_fn->cuda, "cuDeviceGetCount");
-    LOAD_SYMBOL(dl_fn->cu_device_get, dl_fn->cuda, "cuDeviceGet");
-    LOAD_SYMBOL(dl_fn->cu_device_get_name, dl_fn->cuda, "cuDeviceGetName");
-    LOAD_SYMBOL(dl_fn->cu_device_compute_capability, dl_fn->cuda,
-                "cuDeviceComputeCapability");
-    LOAD_SYMBOL(dl_fn->cu_ctx_create, dl_fn->cuda, "cuCtxCreate_v2");
-    LOAD_SYMBOL(dl_fn->cu_ctx_pop_current, dl_fn->cuda, "cuCtxPopCurrent_v2");
-    LOAD_SYMBOL(dl_fn->cu_ctx_destroy, dl_fn->cuda, "cuCtxDestroy_v2");
-#endif
-
-    LOAD_LIBRARY(dl_fn->nvenc, NVENC_LIBNAME);
+    ret = cuda_load_functions(&dl_fn->cuda_dl);
+    if (ret < 0)
+        return ret;
 
-    LOAD_SYMBOL(nvenc_get_max_ver, dl_fn->nvenc,
-                "NvEncodeAPIGetMaxSupportedVersion");
-    LOAD_SYMBOL(nvenc_create_instance, dl_fn->nvenc,
-                "NvEncodeAPICreateInstance");
+    ret = nvenc_load_functions(&dl_fn->nvenc_dl);
+    if (ret < 0) {
+        nvenc_print_driver_requirement(avctx, AV_LOG_ERROR);
+        return ret;
+    }
 
-    err = nvenc_get_max_ver(&nvenc_max_ver);
+    err = dl_fn->nvenc_dl->NvEncodeAPIGetMaxSupportedVersion(&nvenc_max_ver);
     if (err != NV_ENC_SUCCESS)
         return nvenc_print_error(avctx, err, "Failed to query nvenc max version");
 
@@ -203,12 +151,13 @@ static av_cold int nvenc_load_libraries(AVCodecContext *avctx)
                "Required: %d.%d Found: %d.%d\n",
                NVENCAPI_MAJOR_VERSION, NVENCAPI_MINOR_VERSION,
                nvenc_max_ver >> 4, nvenc_max_ver & 0xf);
+        nvenc_print_driver_requirement(avctx, AV_LOG_ERROR);
         return AVERROR(ENOSYS);
     }
 
     dl_fn->nvenc_funcs.version = NV_ENCODE_API_FUNCTION_LIST_VER;
 
-    err = nvenc_create_instance(&dl_fn->nvenc_funcs);
+    err = dl_fn->nvenc_dl->NvEncodeAPICreateInstance(&dl_fn->nvenc_funcs);
     if (err != NV_ENC_SUCCESS)
         return nvenc_print_error(avctx, err, "Failed to create nvenc instance");
 
@@ -240,7 +189,7 @@ static av_cold int nvenc_open_session(AVCodecContext *avctx)
 
 static int nvenc_check_codec_support(AVCodecContext *avctx)
 {
-    NvencContext *ctx = avctx->priv_data;
+    NvencContext *ctx                    = avctx->priv_data;
     NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &ctx->nvenc_dload_funcs.nvenc_funcs;
     int i, ret, count = 0;
     GUID *guids = NULL;
@@ -362,6 +311,18 @@ static int nvenc_check_capabilities(AVCodecContext *avctx)
         return AVERROR(ENOSYS);
     }
 
+    ret = nvenc_check_cap(avctx, NV_ENC_CAPS_SUPPORT_WEIGHTED_PREDICTION);
+    if (ctx->weighted_pred > 0 && ret <= 0) {
+        av_log (avctx, AV_LOG_VERBOSE, "Weighted Prediction not supported\n");
+        return AVERROR(ENOSYS);
+    }
+
+    ret = nvenc_check_cap(avctx, NV_ENC_CAPS_SUPPORT_CABAC);
+    if (ctx->coder == NV_ENC_H264_ENTROPY_CODING_MODE_CABAC && ret <= 0) {
+        av_log(avctx, AV_LOG_VERBOSE, "CABAC entropy coding not supported\n");
+        return AVERROR(ENOSYS);
+    }
+
     return 0;
 }
 
@@ -380,7 +341,7 @@ static av_cold int nvenc_check_device(AVCodecContext *avctx, int idx)
     if (ctx->device == LIST_DEVICES)
         loglevel = AV_LOG_INFO;
 
-    cu_res = dl_fn->cu_device_get(&cu_device, idx);
+    cu_res = dl_fn->cuda_dl->cuDeviceGet(&cu_device, idx);
     if (cu_res != CUDA_SUCCESS) {
         av_log(avctx, AV_LOG_ERROR,
                "Cannot access the CUDA device %d\n",
@@ -388,13 +349,17 @@ static av_cold int nvenc_check_device(AVCodecContext *avctx, int idx)
         return -1;
     }
 
-    cu_res = dl_fn->cu_device_get_name(name, sizeof(name), cu_device);
-    if (cu_res != CUDA_SUCCESS)
+    cu_res = dl_fn->cuda_dl->cuDeviceGetName(name, sizeof(name), cu_device);
+    if (cu_res != CUDA_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "cuDeviceGetName failed on device %d\n", idx);
         return -1;
+    }
 
-    cu_res = dl_fn->cu_device_compute_capability(&major, &minor, cu_device);
-    if (cu_res != CUDA_SUCCESS)
+    cu_res = dl_fn->cuda_dl->cuDeviceComputeCapability(&major, &minor, cu_device);
+    if (cu_res != CUDA_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "cuDeviceComputeCapability failed on device %d\n", idx);
         return -1;
+    }
 
     av_log(avctx, loglevel, "[ GPU #%d - < %s > has Compute SM %d.%d ]\n", idx, name, major, minor);
     if (((major << 4) | minor) < NVENC_CAP) {
@@ -402,7 +367,10 @@ static av_cold int nvenc_check_device(AVCodecContext *avctx, int idx)
         goto fail;
     }
 
-    cu_res = dl_fn->cu_ctx_create(&ctx->cu_context_internal, 0, cu_device);
+    if (ctx->device != idx && ctx->device != ANY_DEVICE)
+        return -1;
+
+    cu_res = dl_fn->cuda_dl->cuCtxCreate(&ctx->cu_context_internal, 0, cu_device);
     if (cu_res != CUDA_SUCCESS) {
         av_log(avctx, AV_LOG_FATAL, "Failed creating CUDA context for NVENC: 0x%x\n", (int)cu_res);
         goto fail;
@@ -410,7 +378,7 @@ static av_cold int nvenc_check_device(AVCodecContext *avctx, int idx)
 
     ctx->cu_context = ctx->cu_context_internal;
 
-    cu_res = dl_fn->cu_ctx_pop_current(&dummy);
+    cu_res = dl_fn->cuda_dl->cuCtxPopCurrent(&dummy);
     if (cu_res != CUDA_SUCCESS) {
         av_log(avctx, AV_LOG_FATAL, "Failed popping CUDA context: 0x%x\n", (int)cu_res);
         goto fail2;
@@ -426,15 +394,27 @@ static av_cold int nvenc_check_device(AVCodecContext *avctx, int idx)
 
     dl_fn->nvenc_device_count++;
 
-    if (ctx->device == dl_fn->nvenc_device_count - 1 || ctx->device == ANY_DEVICE)
+    if (ctx->device == idx || ctx->device == ANY_DEVICE)
         return 0;
 
 fail3:
+    cu_res = dl_fn->cuda_dl->cuCtxPushCurrent(ctx->cu_context);
+    if (cu_res != CUDA_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "cuCtxPushCurrent failed\n");
+        return AVERROR_EXTERNAL;
+    }
+
     p_nvenc->nvEncDestroyEncoder(ctx->nvencoder);
     ctx->nvencoder = NULL;
 
+    cu_res = dl_fn->cuda_dl->cuCtxPopCurrent(&dummy);
+    if (cu_res != CUDA_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "cuCtxPopCurrent failed\n");
+        return AVERROR_EXTERNAL;
+    }
+
 fail2:
-    dl_fn->cu_ctx_destroy(ctx->cu_context_internal);
+    dl_fn->cuda_dl->cuCtxDestroy(ctx->cu_context_internal);
     ctx->cu_context_internal = NULL;
 
 fail:
@@ -443,7 +423,7 @@ static av_cold int nvenc_check_device(AVCodecContext *avctx, int idx)
 
 static av_cold int nvenc_setup_device(AVCodecContext *avctx)
 {
-    NvencContext *ctx = avctx->priv_data;
+    NvencContext *ctx            = avctx->priv_data;
     NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs;
 
     switch (avctx->codec->id) {
@@ -457,17 +437,21 @@ static av_cold int nvenc_setup_device(AVCodecContext *avctx)
         return AVERROR_BUG;
     }
 
-    if (avctx->pix_fmt == AV_PIX_FMT_CUDA) {
-#if CONFIG_CUDA
+    if (avctx->pix_fmt == AV_PIX_FMT_CUDA || avctx->hw_frames_ctx || avctx->hw_device_ctx) {
         AVHWFramesContext   *frames_ctx;
+        AVHWDeviceContext   *hwdev_ctx;
         AVCUDADeviceContext *device_hwctx;
         int ret;
 
-        if (!avctx->hw_frames_ctx)
+        if (avctx->hw_frames_ctx) {
+            frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+            device_hwctx = frames_ctx->device_ctx->hwctx;
+        } else if (avctx->hw_device_ctx) {
+            hwdev_ctx = (AVHWDeviceContext*)avctx->hw_device_ctx->data;
+            device_hwctx = hwdev_ctx->hwctx;
+        } else {
             return AVERROR(EINVAL);
-
-        frames_ctx   = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
-        device_hwctx = frames_ctx->device_ctx->hwctx;
+        }
 
         ctx->cu_context = device_hwctx->cuda_ctx;
 
@@ -480,19 +464,16 @@ static av_cold int nvenc_setup_device(AVCodecContext *avctx)
             av_log(avctx, AV_LOG_FATAL, "Provided device doesn't support required NVENC features\n");
             return ret;
         }
-#else
-        return AVERROR_BUG;
-#endif
     } else {
         int i, nb_devices = 0;
 
-        if ((dl_fn->cu_init(0)) != CUDA_SUCCESS) {
+        if ((dl_fn->cuda_dl->cuInit(0)) != CUDA_SUCCESS) {
             av_log(avctx, AV_LOG_ERROR,
                    "Cannot init CUDA\n");
             return AVERROR_UNKNOWN;
         }
 
-        if ((dl_fn->cu_device_get_count(&nb_devices)) != CUDA_SUCCESS) {
+        if ((dl_fn->cuda_dl->cuDeviceGetCount(&nb_devices)) != CUDA_SUCCESS) {
             av_log(avctx, AV_LOG_ERROR,
                    "Cannot enumerate the CUDA devices\n");
             return AVERROR_UNKNOWN;
@@ -519,7 +500,7 @@ static av_cold int nvenc_setup_device(AVCodecContext *avctx)
             return AVERROR_EXTERNAL;
         }
 
-        av_log(avctx, AV_LOG_FATAL, "Requested GPU %d, but only %d GPUs are available!\n", ctx->device, dl_fn->nvenc_device_count);
+        av_log(avctx, AV_LOG_FATAL, "Requested GPU %d, but only %d GPUs are available!\n", ctx->device, nb_devices);
         return AVERROR(EINVAL);
     }
 
@@ -568,9 +549,28 @@ static av_cold void set_constqp(AVCodecContext *avctx)
     NV_ENC_RC_PARAMS *rc = &ctx->encode_config.rcParams;
 
     rc->rateControlMode = NV_ENC_PARAMS_RC_CONSTQP;
-    rc->constQP.qpInterB = avctx->global_quality;
-    rc->constQP.qpInterP = avctx->global_quality;
-    rc->constQP.qpIntra = avctx->global_quality;
+
+    if (ctx->init_qp_p >= 0) {
+        rc->constQP.qpInterP = ctx->init_qp_p;
+        if (ctx->init_qp_i >= 0 && ctx->init_qp_b >= 0) {
+            rc->constQP.qpIntra = ctx->init_qp_i;
+            rc->constQP.qpInterB = ctx->init_qp_b;
+        } else if (avctx->i_quant_factor != 0.0 && avctx->b_quant_factor != 0.0) {
+            rc->constQP.qpIntra = av_clip(
+                rc->constQP.qpInterP * fabs(avctx->i_quant_factor) + avctx->i_quant_offset + 0.5, 0, 51);
+            rc->constQP.qpInterB = av_clip(
+                rc->constQP.qpInterP * fabs(avctx->b_quant_factor) + avctx->b_quant_offset + 0.5, 0, 51);
+        } else {
+            rc->constQP.qpIntra = rc->constQP.qpInterP;
+            rc->constQP.qpInterB = rc->constQP.qpInterP;
+        }
+    } else if (ctx->cqp >= 0) {
+        rc->constQP.qpInterP = rc->constQP.qpInterB = rc->constQP.qpIntra = ctx->cqp;
+        if (avctx->b_quant_factor != 0.0)
+            rc->constQP.qpInterB = av_clip(ctx->cqp * fabs(avctx->b_quant_factor) + avctx->b_quant_offset + 0.5, 0, 51);
+        if (avctx->i_quant_factor != 0.0)
+            rc->constQP.qpIntra = av_clip(ctx->cqp * fabs(avctx->i_quant_factor) + avctx->i_quant_offset + 0.5, 0, 51);
+    }
 
     avctx->qmin = -1;
     avctx->qmax = -1;
@@ -588,7 +588,7 @@ static av_cold void set_vbr(AVCodecContext *avctx)
 
         rc->minQP.qpInterB = avctx->qmin;
         rc->minQP.qpInterP = avctx->qmin;
-        rc->minQP.qpIntra = avctx->qmin;
+        rc->minQP.qpIntra  = avctx->qmin;
 
         rc->maxQP.qpInterB = avctx->qmax;
         rc->maxQP.qpInterP = avctx->qmax;
@@ -608,16 +608,33 @@ static av_cold void set_vbr(AVCodecContext *avctx)
     }
 
     rc->enableInitialRCQP = 1;
-    rc->initialRCQP.qpInterP  = qp_inter_p;
 
-    if (avctx->i_quant_factor != 0.0 && avctx->b_quant_factor != 0.0) {
-        rc->initialRCQP.qpIntra = av_clip(
-            qp_inter_p * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
-        rc->initialRCQP.qpInterB = av_clip(
-            qp_inter_p * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
+    if (ctx->init_qp_p < 0) {
+        rc->initialRCQP.qpInterP  = qp_inter_p;
+    } else {
+        rc->initialRCQP.qpInterP = ctx->init_qp_p;
+    }
+
+    if (ctx->init_qp_i < 0) {
+        if (avctx->i_quant_factor != 0.0 && avctx->b_quant_factor != 0.0) {
+            rc->initialRCQP.qpIntra = av_clip(
+                rc->initialRCQP.qpInterP * fabs(avctx->i_quant_factor) + avctx->i_quant_offset + 0.5, 0, 51);
+        } else {
+            rc->initialRCQP.qpIntra = rc->initialRCQP.qpInterP;
+        }
+    } else {
+        rc->initialRCQP.qpIntra = ctx->init_qp_i;
+    }
+
+    if (ctx->init_qp_b < 0) {
+        if (avctx->i_quant_factor != 0.0 && avctx->b_quant_factor != 0.0) {
+            rc->initialRCQP.qpInterB = av_clip(
+                rc->initialRCQP.qpInterP * fabs(avctx->b_quant_factor) + avctx->b_quant_offset + 0.5, 0, 51);
+        } else {
+            rc->initialRCQP.qpInterB = rc->initialRCQP.qpInterP;
+        }
     } else {
-        rc->initialRCQP.qpIntra = qp_inter_p;
-        rc->initialRCQP.qpInterB = qp_inter_p;
+        rc->initialRCQP.qpInterB = ctx->init_qp_b;
     }
 }
 
@@ -629,7 +646,7 @@ static av_cold void set_lossless(AVCodecContext *avctx)
     rc->rateControlMode = NV_ENC_PARAMS_RC_CONSTQP;
     rc->constQP.qpInterB = 0;
     rc->constQP.qpInterP = 0;
-    rc->constQP.qpIntra = 0;
+    rc->constQP.qpIntra  = 0;
 
     avctx->qmin = -1;
     avctx->qmax = -1;
@@ -642,23 +659,8 @@ static void nvenc_override_rate_control(AVCodecContext *avctx)
 
     switch (ctx->rc) {
     case NV_ENC_PARAMS_RC_CONSTQP:
-        if (avctx->global_quality <= 0) {
-            av_log(avctx, AV_LOG_WARNING,
-                   "The constant quality rate-control requires "
-                   "the 'global_quality' option set.\n");
-            return;
-        }
         set_constqp(avctx);
         return;
-    case NV_ENC_PARAMS_RC_2_PASS_VBR:
-    case NV_ENC_PARAMS_RC_VBR:
-        if (avctx->qmin < 0 && avctx->qmax < 0) {
-            av_log(avctx, AV_LOG_WARNING,
-                   "The variable bitrate rate-control requires "
-                   "the 'qmin' and/or 'qmax' option set.\n");
-            set_vbr(avctx);
-            return;
-        }
     case NV_ENC_PARAMS_RC_VBR_MINQP:
         if (avctx->qmin < 0) {
             av_log(avctx, AV_LOG_WARNING,
@@ -667,21 +669,69 @@ static void nvenc_override_rate_control(AVCodecContext *avctx)
             set_vbr(avctx);
             return;
         }
+        /* fall through */
+    case NV_ENC_PARAMS_RC_VBR_HQ:
+    case NV_ENC_PARAMS_RC_VBR:
         set_vbr(avctx);
         break;
     case NV_ENC_PARAMS_RC_CBR:
-    case NV_ENC_PARAMS_RC_2_PASS_QUALITY:
-    case NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP:
+    case NV_ENC_PARAMS_RC_CBR_HQ:
+    case NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ:
         break;
     }
 
     rc->rateControlMode = ctx->rc;
 }
 
+static av_cold int nvenc_recalc_surfaces(AVCodecContext *avctx)
+{
+    NvencContext *ctx = avctx->priv_data;
+    // default minimum of 4 surfaces
+    // multiply by 2 for number of NVENCs on gpu (hardcode to 2)
+    // another multiply by 2 to avoid blocking next PBB group
+    int nb_surfaces = FFMAX(4, ctx->encode_config.frameIntervalP * 2 * 2);
+
+    // lookahead enabled
+    if (ctx->rc_lookahead > 0) {
+        // +1 is to account for lkd_bound calculation later
+        // +4 is to allow sufficient pipelining with lookahead
+        nb_surfaces = FFMAX(1, FFMAX(nb_surfaces, ctx->rc_lookahead + ctx->encode_config.frameIntervalP + 1 + 4));
+        if (nb_surfaces > ctx->nb_surfaces && ctx->nb_surfaces > 0)
+        {
+            av_log(avctx, AV_LOG_WARNING,
+                   "Defined rc_lookahead requires more surfaces, "
+                   "increasing used surfaces %d -> %d\n", ctx->nb_surfaces, nb_surfaces);
+        }
+        ctx->nb_surfaces = FFMAX(nb_surfaces, ctx->nb_surfaces);
+    } else {
+        if (ctx->encode_config.frameIntervalP > 1 && ctx->nb_surfaces < nb_surfaces && ctx->nb_surfaces > 0)
+        {
+            av_log(avctx, AV_LOG_WARNING,
+                   "Defined b-frame requires more surfaces, "
+                   "increasing used surfaces %d -> %d\n", ctx->nb_surfaces, nb_surfaces);
+            ctx->nb_surfaces = FFMAX(ctx->nb_surfaces, nb_surfaces);
+        }
+        else if (ctx->nb_surfaces <= 0)
+            ctx->nb_surfaces = nb_surfaces;
+        // otherwise use user specified value
+    }
+
+    ctx->nb_surfaces = FFMAX(1, FFMIN(MAX_REGISTERED_FRAMES, ctx->nb_surfaces));
+    ctx->async_depth = FFMIN(ctx->async_depth, ctx->nb_surfaces - 1);
+
+    return 0;
+}
+
 static av_cold void nvenc_setup_rate_control(AVCodecContext *avctx)
 {
     NvencContext *ctx = avctx->priv_data;
 
+    if (avctx->global_quality > 0)
+        av_log(avctx, AV_LOG_WARNING, "Using global_quality with nvenc is deprecated. Use qp instead.\n");
+
+    if (ctx->cqp < 0 && avctx->global_quality > 0)
+        ctx->cqp = avctx->global_quality;
+
     if (avctx->bit_rate > 0) {
         ctx->encode_config.rcParams.averageBitRate = avctx->bit_rate;
     } else if (ctx->encode_config.rcParams.averageBitRate > 0) {
@@ -702,19 +752,29 @@ static av_cold void nvenc_setup_rate_control(AVCodecContext *avctx)
 
         if (ctx->cbr) {
             if (ctx->twopass) {
-                ctx->rc = NV_ENC_PARAMS_RC_2_PASS_QUALITY;
+                ctx->rc = NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ;
             } else {
                 ctx->rc = NV_ENC_PARAMS_RC_CBR;
             }
-        } else if (avctx->global_quality > 0) {
+        } else if (ctx->cqp >= 0) {
             ctx->rc = NV_ENC_PARAMS_RC_CONSTQP;
         } else if (ctx->twopass) {
-            ctx->rc = NV_ENC_PARAMS_RC_2_PASS_VBR;
+            ctx->rc = NV_ENC_PARAMS_RC_VBR_HQ;
         } else if (avctx->qmin >= 0 && avctx->qmax >= 0) {
             ctx->rc = NV_ENC_PARAMS_RC_VBR_MINQP;
         }
     }
 
+    if (ctx->rc >= 0 && ctx->rc & RC_MODE_DEPRECATED) {
+        av_log(avctx, AV_LOG_WARNING, "Specified rc mode is deprecated.\n");
+        av_log(avctx, AV_LOG_WARNING, "\tll_2pass_quality -> cbr_ld_hq\n");
+        av_log(avctx, AV_LOG_WARNING, "\tll_2pass_size -> cbr_hq\n");
+        av_log(avctx, AV_LOG_WARNING, "\tvbr_2pass -> vbr_hq\n");
+        av_log(avctx, AV_LOG_WARNING, "\tvbr_minqp -> (no replacement)\n");
+
+        ctx->rc &= ~RC_MODE_DEPRECATED;
+    }
+
     if (ctx->flags & NVENC_LOSSLESS) {
         set_lossless(avctx);
     } else if (ctx->rc >= 0) {
@@ -741,7 +801,7 @@ static av_cold void nvenc_setup_rate_control(AVCodecContext *avctx)
         av_log(avctx, AV_LOG_VERBOSE, "Temporal AQ enabled.\n");
     }
 
-    if (ctx->rc_lookahead) {
+    if (ctx->rc_lookahead > 0) {
         int lkd_bound = FFMIN(ctx->nb_surfaces, ctx->async_depth) -
                         ctx->encode_config.frameIntervalP - 4;
 
@@ -773,7 +833,12 @@ static av_cold void nvenc_setup_rate_control(AVCodecContext *avctx)
         ctx->encode_config.rcParams.zeroReorderDelay = 1;
 
     if (ctx->quality)
-        ctx->encode_config.rcParams.targetQuality = ctx->quality;
+    {
+        //convert from float to fixed point 8.8
+        int tmp_quality = (int)(ctx->quality * 256.0f);
+        ctx->encode_config.rcParams.targetQuality = (uint8_t)(tmp_quality >> 8);
+        ctx->encode_config.rcParams.targetQualityLSB = (uint8_t)(tmp_quality & 0xff);
+    }
 }
 
 static av_cold int nvenc_setup_h264_config(AVCodecContext *avctx)
@@ -802,7 +867,7 @@ static av_cold int nvenc_setup_h264_config(AVCodecContext *avctx)
 
     h264->disableSPSPPS = (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) ? 1 : 0;
     h264->repeatSPSPPS  = (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) ? 0 : 1;
-    h264->outputAUD     = 1;
+    h264->outputAUD     = ctx->aud;
 
     if (avctx->refs >= 0) {
         /* 0 means "let the hardware decide" */
@@ -814,12 +879,13 @@ static av_cold int nvenc_setup_h264_config(AVCodecContext *avctx)
 
     if (IS_CBR(cc->rcParams.rateControlMode)) {
         h264->outputBufferingPeriodSEI = 1;
-        h264->outputPictureTimingSEI   = 1;
     }
 
-    if (cc->rcParams.rateControlMode == NV_ENC_PARAMS_RC_2_PASS_QUALITY ||
-        cc->rcParams.rateControlMode == NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP ||
-        cc->rcParams.rateControlMode == NV_ENC_PARAMS_RC_2_PASS_VBR) {
+    h264->outputPictureTimingSEI = 1;
+
+    if (cc->rcParams.rateControlMode == NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ ||
+        cc->rcParams.rateControlMode == NV_ENC_PARAMS_RC_CBR_HQ ||
+        cc->rcParams.rateControlMode == NV_ENC_PARAMS_RC_VBR_HQ) {
         h264->adaptiveTransformMode = NV_ENC_H264_ADAPTIVE_TRANSFORM_ENABLE;
         h264->fmoMode = NV_ENC_H264_FMO_DISABLE;
     }
@@ -857,6 +923,9 @@ static av_cold int nvenc_setup_h264_config(AVCodecContext *avctx)
 
     h264->level = ctx->level;
 
+    if (ctx->coder >= 0)
+        h264->entropyCodingMode = ctx->coder;
+
     return 0;
 }
 
@@ -886,7 +955,7 @@ static av_cold int nvenc_setup_hevc_config(AVCodecContext *avctx)
 
     hevc->disableSPSPPS = (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) ? 1 : 0;
     hevc->repeatSPSPPS  = (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) ? 0 : 1;
-    hevc->outputAUD     = 1;
+    hevc->outputAUD     = ctx->aud;
 
     if (avctx->refs >= 0) {
         /* 0 means "let the hardware decide" */
@@ -898,21 +967,22 @@ static av_cold int nvenc_setup_hevc_config(AVCodecContext *avctx)
 
     if (IS_CBR(cc->rcParams.rateControlMode)) {
         hevc->outputBufferingPeriodSEI = 1;
-        hevc->outputPictureTimingSEI   = 1;
     }
 
-    switch(ctx->profile) {
+    hevc->outputPictureTimingSEI = 1;
+
+    switch (ctx->profile) {
     case NV_ENC_HEVC_PROFILE_MAIN:
         cc->profileGUID = NV_ENC_HEVC_PROFILE_MAIN_GUID;
-        avctx->profile = FF_PROFILE_HEVC_MAIN;
+        avctx->profile  = FF_PROFILE_HEVC_MAIN;
         break;
     case NV_ENC_HEVC_PROFILE_MAIN_10:
         cc->profileGUID = NV_ENC_HEVC_PROFILE_MAIN10_GUID;
-        avctx->profile = FF_PROFILE_HEVC_MAIN_10;
+        avctx->profile  = FF_PROFILE_HEVC_MAIN_10;
         break;
     case NV_ENC_HEVC_PROFILE_REXT:
         cc->profileGUID = NV_ENC_HEVC_PROFILE_FREXT_GUID;
-        avctx->profile = FF_PROFILE_HEVC_REXT;
+        avctx->profile  = FF_PROFILE_HEVC_REXT;
         break;
     }
 
@@ -961,6 +1031,8 @@ static av_cold int nvenc_setup_encoder(AVCodecContext *avctx)
     NV_ENC_PRESET_CONFIG preset_config = { 0 };
     NVENCSTATUS nv_status = NV_ENC_SUCCESS;
     AVCPBProperties *cpb_props;
+    CUresult cu_res;
+    CUcontext dummy;
     int res = 0;
     int dw, dh;
 
@@ -988,30 +1060,15 @@ static av_cold int nvenc_setup_encoder(AVCodecContext *avctx)
 
     ctx->encode_config.version = NV_ENC_CONFIG_VER;
 
-    if (avctx->sample_aspect_ratio.num && avctx->sample_aspect_ratio.den &&
-        (avctx->sample_aspect_ratio.num != 1 || avctx->sample_aspect_ratio.num != 1)) {
-        av_reduce(&dw, &dh,
-                  avctx->width * avctx->sample_aspect_ratio.num,
-                  avctx->height * avctx->sample_aspect_ratio.den,
-                  1024 * 1024);
-        ctx->init_encode_params.darHeight = dh;
-        ctx->init_encode_params.darWidth = dw;
-    } else {
-        ctx->init_encode_params.darHeight = avctx->height;
-        ctx->init_encode_params.darWidth = avctx->width;
-    }
-
-    // De-compensate for hardware, dubiously, trying to compensate for
-    // playback at 704 pixel width.
-    if (avctx->width == 720 &&
-        (avctx->height == 480 || avctx->height == 576)) {
-        av_reduce(&dw, &dh,
-                  ctx->init_encode_params.darWidth * 44,
-                  ctx->init_encode_params.darHeight * 45,
-                  1024 * 1024);
-        ctx->init_encode_params.darHeight = dh;
-        ctx->init_encode_params.darWidth = dw;
+    dw = avctx->width;
+    dh = avctx->height;
+    if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
+        dw*= avctx->sample_aspect_ratio.num;
+        dh*= avctx->sample_aspect_ratio.den;
     }
+    av_reduce(&dw, &dh, dw, dh, 1024 * 1024);
+    ctx->init_encode_params.darHeight = dh;
+    ctx->init_encode_params.darWidth = dw;
 
     ctx->init_encode_params.frameRateNum = avctx->time_base.den;
     ctx->init_encode_params.frameRateDen = avctx->time_base.num * avctx->ticks_per_frame;
@@ -1019,6 +1076,24 @@ static av_cold int nvenc_setup_encoder(AVCodecContext *avctx)
     ctx->init_encode_params.enableEncodeAsync = 0;
     ctx->init_encode_params.enablePTD = 1;
 
+    if (ctx->weighted_pred == 1)
+        ctx->init_encode_params.enableWeightedPrediction = 1;
+
+    if (ctx->bluray_compat) {
+        ctx->aud = 1;
+        avctx->refs = FFMIN(FFMAX(avctx->refs, 0), 6);
+        avctx->max_b_frames = FFMIN(avctx->max_b_frames, 3);
+        switch (avctx->codec->id) {
+        case AV_CODEC_ID_H264:
+            /* maximum level depends on used resolution */
+            break;
+        case AV_CODEC_ID_HEVC:
+            ctx->level = NV_ENC_LEVEL_HEVC_51;
+            ctx->tier = NV_ENC_TIER_HEVC_HIGH;
+            break;
+        }
+    }
+
     if (avctx->gop_size > 0) {
         if (avctx->max_b_frames >= 0) {
             /* 0 is intra-only, 1 is I/P only, 2 is one B-Frame, 3 two B-frames, and so on. */
@@ -1034,6 +1109,8 @@ static av_cold int nvenc_setup_encoder(AVCodecContext *avctx)
     ctx->initial_pts[0] = AV_NOPTS_VALUE;
     ctx->initial_pts[1] = AV_NOPTS_VALUE;
 
+    nvenc_recalc_surfaces(avctx);
+
     nvenc_setup_rate_control(avctx);
 
     if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
@@ -1046,7 +1123,20 @@ static av_cold int nvenc_setup_encoder(AVCodecContext *avctx)
     if (res)
         return res;
 
+    cu_res = dl_fn->cuda_dl->cuCtxPushCurrent(ctx->cu_context);
+    if (cu_res != CUDA_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "cuCtxPushCurrent failed\n");
+        return AVERROR_EXTERNAL;
+    }
+
     nv_status = p_nvenc->nvEncInitializeEncoder(ctx->nvencoder, &ctx->init_encode_params);
+
+    cu_res = dl_fn->cuda_dl->cuCtxPopCurrent(&dummy);
+    if (cu_res != CUDA_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "cuCtxPopCurrent failed\n");
+        return AVERROR_EXTERNAL;
+    }
+
     if (nv_status != NV_ENC_SUCCESS) {
         return nvenc_print_error(avctx, nv_status, "InitializeEncoder failed");
     }
@@ -1067,49 +1157,38 @@ static av_cold int nvenc_setup_encoder(AVCodecContext *avctx)
     return 0;
 }
 
-static av_cold int nvenc_alloc_surface(AVCodecContext *avctx, int idx)
+static NV_ENC_BUFFER_FORMAT nvenc_map_buffer_format(enum AVPixelFormat pix_fmt)
 {
-    NvencContext *ctx = avctx->priv_data;
-    NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs;
-    NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->nvenc_funcs;
-
-    NVENCSTATUS nv_status;
-    NV_ENC_CREATE_BITSTREAM_BUFFER allocOut = { 0 };
-    allocOut.version = NV_ENC_CREATE_BITSTREAM_BUFFER_VER;
-
-    switch (ctx->data_pix_fmt) {
+    switch (pix_fmt) {
     case AV_PIX_FMT_YUV420P:
-        ctx->surfaces[idx].format = NV_ENC_BUFFER_FORMAT_YV12_PL;
-        break;
-
+        return NV_ENC_BUFFER_FORMAT_YV12_PL;
     case AV_PIX_FMT_NV12:
-        ctx->surfaces[idx].format = NV_ENC_BUFFER_FORMAT_NV12_PL;
-        break;
-
+        return NV_ENC_BUFFER_FORMAT_NV12_PL;
     case AV_PIX_FMT_P010:
-        ctx->surfaces[idx].format = NV_ENC_BUFFER_FORMAT_YUV420_10BIT;
-        break;
-
+        return NV_ENC_BUFFER_FORMAT_YUV420_10BIT;
     case AV_PIX_FMT_YUV444P:
-        ctx->surfaces[idx].format = NV_ENC_BUFFER_FORMAT_YUV444_PL;
-        break;
-
+        return NV_ENC_BUFFER_FORMAT_YUV444_PL;
     case AV_PIX_FMT_YUV444P16:
-        ctx->surfaces[idx].format = NV_ENC_BUFFER_FORMAT_YUV444_10BIT;
-        break;
-
+        return NV_ENC_BUFFER_FORMAT_YUV444_10BIT;
     case AV_PIX_FMT_0RGB32:
-        ctx->surfaces[idx].format = NV_ENC_BUFFER_FORMAT_ARGB;
-        break;
-
+        return NV_ENC_BUFFER_FORMAT_ARGB;
     case AV_PIX_FMT_0BGR32:
-        ctx->surfaces[idx].format = NV_ENC_BUFFER_FORMAT_ABGR;
-        break;
-
+        return NV_ENC_BUFFER_FORMAT_ABGR;
     default:
-        av_log(avctx, AV_LOG_FATAL, "Invalid input pixel format\n");
-        return AVERROR(EINVAL);
+        return NV_ENC_BUFFER_FORMAT_UNDEFINED;
     }
+}
+
+static av_cold int nvenc_alloc_surface(AVCodecContext *avctx, int idx)
+{
+    NvencContext *ctx = avctx->priv_data;
+    NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs;
+    NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->nvenc_funcs;
+    NvencSurface* tmp_surface = &ctx->surfaces[idx];
+
+    NVENCSTATUS nv_status;
+    NV_ENC_CREATE_BITSTREAM_BUFFER allocOut = { 0 };
+    allocOut.version = NV_ENC_CREATE_BITSTREAM_BUFFER_VER;
 
     if (avctx->pix_fmt == AV_PIX_FMT_CUDA) {
         ctx->surfaces[idx].in_ref = av_frame_alloc();
@@ -1117,10 +1196,17 @@ static av_cold int nvenc_alloc_surface(AVCodecContext *avctx, int idx)
             return AVERROR(ENOMEM);
     } else {
         NV_ENC_CREATE_INPUT_BUFFER allocSurf = { 0 };
+
+        ctx->surfaces[idx].format = nvenc_map_buffer_format(ctx->data_pix_fmt);
+        if (ctx->surfaces[idx].format == NV_ENC_BUFFER_FORMAT_UNDEFINED) {
+            av_log(avctx, AV_LOG_FATAL, "Invalid input pixel format: %s\n",
+                   av_get_pix_fmt_name(ctx->data_pix_fmt));
+            return AVERROR(EINVAL);
+        }
+
         allocSurf.version = NV_ENC_CREATE_INPUT_BUFFER_VER;
-        allocSurf.width = (avctx->width + 31) & ~31;
-        allocSurf.height = (avctx->height + 31) & ~31;
-        allocSurf.memoryHeap = NV_ENC_MEMORY_HEAP_SYSMEM_CACHED;
+        allocSurf.width = avctx->width;
+        allocSurf.height = avctx->height;
         allocSurf.bufferFmt = ctx->surfaces[idx].format;
 
         nv_status = p_nvenc->nvEncCreateInputBuffer(ctx->nvencoder, &allocSurf);
@@ -1133,14 +1219,6 @@ static av_cold int nvenc_alloc_surface(AVCodecContext *avctx, int idx)
         ctx->surfaces[idx].height = allocSurf.height;
     }
 
-    ctx->surfaces[idx].lockCount = 0;
-
-    /* 1MB is large enough to hold most output frames.
-     * NVENC increases this automaticaly if it is not enough. */
-    allocOut.size = 1024 * 1024;
-
-    allocOut.memoryHeap = NV_ENC_MEMORY_HEAP_SYSMEM_CACHED;
-
     nv_status = p_nvenc->nvEncCreateBitstreamBuffer(ctx->nvencoder, &allocOut);
     if (nv_status != NV_ENC_SUCCESS) {
         int err = nvenc_print_error(avctx, nv_status, "CreateBitstreamBuffer failed");
@@ -1153,18 +1231,18 @@ static av_cold int nvenc_alloc_surface(AVCodecContext *avctx, int idx)
     ctx->surfaces[idx].output_surface = allocOut.bitstreamBuffer;
     ctx->surfaces[idx].size = allocOut.size;
 
+    av_fifo_generic_write(ctx->unused_surface_queue, &tmp_surface, sizeof(tmp_surface), NULL);
+
     return 0;
 }
 
 static av_cold int nvenc_setup_surfaces(AVCodecContext *avctx)
 {
     NvencContext *ctx = avctx->priv_data;
+    NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs;
+    CUresult cu_res;
+    CUcontext dummy;
     int i, res;
-    int num_mbs = ((avctx->width + 15) >> 4) * ((avctx->height + 15) >> 4);
-    ctx->nb_surfaces = FFMAX((num_mbs >= 8160) ? 32 : 48,
-                             ctx->nb_surfaces);
-    ctx->async_depth = FFMIN(ctx->async_depth, ctx->nb_surfaces - 1);
-
 
     ctx->surfaces = av_mallocz_array(ctx->nb_surfaces, sizeof(*ctx->surfaces));
     if (!ctx->surfaces)
@@ -1173,6 +1251,11 @@ static av_cold int nvenc_setup_surfaces(AVCodecContext *avctx)
     ctx->timestamp_list = av_fifo_alloc(ctx->nb_surfaces * sizeof(int64_t));
     if (!ctx->timestamp_list)
         return AVERROR(ENOMEM);
+
+    ctx->unused_surface_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(NvencSurface*));
+    if (!ctx->unused_surface_queue)
+        return AVERROR(ENOMEM);
+
     ctx->output_surface_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(NvencSurface*));
     if (!ctx->output_surface_queue)
         return AVERROR(ENOMEM);
@@ -1180,9 +1263,28 @@ static av_cold int nvenc_setup_surfaces(AVCodecContext *avctx)
     if (!ctx->output_surface_ready_queue)
         return AVERROR(ENOMEM);
 
+    cu_res = dl_fn->cuda_dl->cuCtxPushCurrent(ctx->cu_context);
+    if (cu_res != CUDA_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "cuCtxPushCurrent failed\n");
+        return AVERROR_EXTERNAL;
+    }
+
     for (i = 0; i < ctx->nb_surfaces; i++) {
         if ((res = nvenc_alloc_surface(avctx, i)) < 0)
+        {
+            cu_res = dl_fn->cuda_dl->cuCtxPopCurrent(&dummy);
+            if (cu_res != CUDA_SUCCESS) {
+                av_log(avctx, AV_LOG_ERROR, "cuCtxPopCurrent failed\n");
+                return AVERROR_EXTERNAL;
+            }
             return res;
+        }
+    }
+
+    cu_res = dl_fn->cuda_dl->cuCtxPopCurrent(&dummy);
+    if (cu_res != CUDA_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "cuCtxPopCurrent failed\n");
+        return AVERROR_EXTERNAL;
     }
 
     return 0;
@@ -1226,6 +1328,8 @@ av_cold int ff_nvenc_encode_close(AVCodecContext *avctx)
     NvencContext *ctx               = avctx->priv_data;
     NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs;
     NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->nvenc_funcs;
+    CUresult cu_res;
+    CUcontext dummy;
     int i;
 
     /* the encoder has to be flushed before it can be closed */
@@ -1233,12 +1337,19 @@ av_cold int ff_nvenc_encode_close(AVCodecContext *avctx)
         NV_ENC_PIC_PARAMS params        = { .version        = NV_ENC_PIC_PARAMS_VER,
                                             .encodePicFlags = NV_ENC_PIC_FLAG_EOS };
 
+        cu_res = dl_fn->cuda_dl->cuCtxPushCurrent(ctx->cu_context);
+        if (cu_res != CUDA_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "cuCtxPushCurrent failed\n");
+            return AVERROR_EXTERNAL;
+        }
+
         p_nvenc->nvEncEncodePicture(ctx->nvencoder, &params);
     }
 
     av_fifo_freep(&ctx->timestamp_list);
     av_fifo_freep(&ctx->output_surface_ready_queue);
     av_fifo_freep(&ctx->output_surface_queue);
+    av_fifo_freep(&ctx->unused_surface_queue);
 
     if (ctx->surfaces && avctx->pix_fmt == AV_PIX_FMT_CUDA) {
         for (i = 0; i < ctx->nb_surfaces; ++i) {
@@ -1264,35 +1375,26 @@ av_cold int ff_nvenc_encode_close(AVCodecContext *avctx)
     av_freep(&ctx->surfaces);
     ctx->nb_surfaces = 0;
 
-    if (ctx->nvencoder)
+    if (ctx->nvencoder) {
         p_nvenc->nvEncDestroyEncoder(ctx->nvencoder);
+
+        cu_res = dl_fn->cuda_dl->cuCtxPopCurrent(&dummy);
+        if (cu_res != CUDA_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "cuCtxPopCurrent failed\n");
+            return AVERROR_EXTERNAL;
+        }
+    }
     ctx->nvencoder = NULL;
 
     if (ctx->cu_context_internal)
-        dl_fn->cu_ctx_destroy(ctx->cu_context_internal);
+        dl_fn->cuda_dl->cuCtxDestroy(ctx->cu_context_internal);
     ctx->cu_context = ctx->cu_context_internal = NULL;
 
-    if (dl_fn->nvenc)
-        dlclose(dl_fn->nvenc);
-    dl_fn->nvenc = NULL;
+    nvenc_free_functions(&dl_fn->nvenc_dl);
+    cuda_free_functions(&dl_fn->cuda_dl);
 
     dl_fn->nvenc_device_count = 0;
 
-#if !CONFIG_CUDA
-    if (dl_fn->cuda)
-        dlclose(dl_fn->cuda);
-    dl_fn->cuda = NULL;
-#endif
-
-    dl_fn->cu_init = NULL;
-    dl_fn->cu_device_get_count = NULL;
-    dl_fn->cu_device_get = NULL;
-    dl_fn->cu_device_get_name = NULL;
-    dl_fn->cu_device_compute_capability = NULL;
-    dl_fn->cu_ctx_create = NULL;
-    dl_fn->cu_ctx_pop_current = NULL;
-    dl_fn->cu_ctx_destroy = NULL;
-
     av_log(avctx, AV_LOG_VERBOSE, "Nvenc unloaded\n");
 
     return 0;
@@ -1338,16 +1440,14 @@ av_cold int ff_nvenc_encode_init(AVCodecContext *avctx)
 
 static NvencSurface *get_free_frame(NvencContext *ctx)
 {
-    int i;
+    NvencSurface *tmp_surf;
 
-    for (i = 0; i < ctx->nb_surfaces; ++i) {
-        if (!ctx->surfaces[i].lockCount) {
-            ctx->surfaces[i].lockCount = 1;
-            return &ctx->surfaces[i];
-        }
-    }
+    if (!(av_fifo_size(ctx->unused_surface_queue) > 0))
+        // queue empty
+        return NULL;
 
-    return NULL;
+    av_fifo_generic_read(ctx->unused_surface_queue, &tmp_surf, sizeof(tmp_surf), NULL);
+    return tmp_surf;
 }
 
 static int nvenc_copy_frame(AVCodecContext *avctx, NvencSurface *nv_surface,
@@ -1413,7 +1513,7 @@ static int nvenc_register_frame(AVCodecContext *avctx, const AVFrame *frame)
     NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs;
     NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->nvenc_funcs;
 
-    AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+    AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frame->hw_frames_ctx->data;
     NV_ENC_REGISTER_RESOURCE reg;
     int i, idx, ret;
 
@@ -1430,10 +1530,16 @@ static int nvenc_register_frame(AVCodecContext *avctx, const AVFrame *frame)
     reg.resourceType       = NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR;
     reg.width              = frames_ctx->width;
     reg.height             = frames_ctx->height;
-    reg.bufferFormat       = ctx->surfaces[0].format;
     reg.pitch              = frame->linesize[0];
     reg.resourceToRegister = frame->data[0];
 
+    reg.bufferFormat       = nvenc_map_buffer_format(frames_ctx->sw_format);
+    if (reg.bufferFormat == NV_ENC_BUFFER_FORMAT_UNDEFINED) {
+        av_log(avctx, AV_LOG_FATAL, "Invalid input pixel format: %s\n",
+               av_get_pix_fmt_name(frames_ctx->sw_format));
+        return AVERROR(EINVAL);
+    }
+
     ret = p_nvenc->nvEncRegisterResource(ctx->nvencoder, &reg);
     if (ret != NV_ENC_SUCCESS) {
         nvenc_print_error(avctx, ret, "Error registering an input resource");
@@ -1477,6 +1583,7 @@ static int nvenc_upload_frame(AVCodecContext *avctx, const AVFrame *frame,
         ctx->registered_frames[reg_idx].mapped = 1;
         nvenc_frame->reg_idx                   = reg_idx;
         nvenc_frame->input_surface             = nvenc_frame->in_map.mappedResource;
+        nvenc_frame->format                    = nvenc_frame->in_map.mappedBufferFmt;
         nvenc_frame->pitch                     = frame->linesize[0];
         return 0;
     } else {
@@ -1700,11 +1807,12 @@ static int output_ready(AVCodecContext *avctx, int flush)
     return (nb_ready > 0) && (nb_ready + nb_pending >= ctx->async_depth);
 }
 
-int ff_nvenc_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
-                          const AVFrame *frame, int *got_packet)
+int ff_nvenc_send_frame(AVCodecContext *avctx, const AVFrame *frame)
 {
     NVENCSTATUS nv_status;
-    NvencSurface *tmpoutsurf, *inSurf;
+    CUresult cu_res;
+    CUcontext dummy;
+    NvencSurface *tmp_out_surf, *in_surf;
     int res;
 
     NvencContext *ctx = avctx->priv_data;
@@ -1714,25 +1822,40 @@ int ff_nvenc_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     NV_ENC_PIC_PARAMS pic_params = { 0 };
     pic_params.version = NV_ENC_PIC_PARAMS_VER;
 
+    if (!ctx->cu_context || !ctx->nvencoder)
+        return AVERROR(EINVAL);
+
+    if (ctx->encoder_flushing)
+        return AVERROR_EOF;
+
     if (frame) {
-        inSurf = get_free_frame(ctx);
-        if (!inSurf) {
-            av_log(avctx, AV_LOG_ERROR, "No free surfaces\n");
-            return AVERROR_BUG;
+        in_surf = get_free_frame(ctx);
+        if (!in_surf)
+            return AVERROR(EAGAIN);
+
+        cu_res = dl_fn->cuda_dl->cuCtxPushCurrent(ctx->cu_context);
+        if (cu_res != CUDA_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "cuCtxPushCurrent failed\n");
+            return AVERROR_EXTERNAL;
         }
 
-        res = nvenc_upload_frame(avctx, frame, inSurf);
-        if (res) {
-            inSurf->lockCount = 0;
-            return res;
+        res = nvenc_upload_frame(avctx, frame, in_surf);
+
+        cu_res = dl_fn->cuda_dl->cuCtxPopCurrent(&dummy);
+        if (cu_res != CUDA_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "cuCtxPopCurrent failed\n");
+            return AVERROR_EXTERNAL;
         }
 
-        pic_params.inputBuffer = inSurf->input_surface;
-        pic_params.bufferFmt = inSurf->format;
-        pic_params.inputWidth = avctx->width;
-        pic_params.inputHeight = avctx->height;
-        pic_params.inputPitch = inSurf->pitch;
-        pic_params.outputBitstream = inSurf->output_surface;
+        if (res)
+            return res;
+
+        pic_params.inputBuffer = in_surf->input_surface;
+        pic_params.bufferFmt = in_surf->format;
+        pic_params.inputWidth = in_surf->width;
+        pic_params.inputHeight = in_surf->height;
+        pic_params.inputPitch = in_surf->pitch;
+        pic_params.outputBitstream = in_surf->output_surface;
 
         if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
             if (frame->top_field_first)
@@ -1755,15 +1878,29 @@ int ff_nvenc_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
         nvenc_codec_specific_pic_params(avctx, &pic_params);
     } else {
         pic_params.encodePicFlags = NV_ENC_PIC_FLAG_EOS;
+        ctx->encoder_flushing = 1;
+    }
+
+    cu_res = dl_fn->cuda_dl->cuCtxPushCurrent(ctx->cu_context);
+    if (cu_res != CUDA_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "cuCtxPushCurrent failed\n");
+        return AVERROR_EXTERNAL;
     }
 
     nv_status = p_nvenc->nvEncEncodePicture(ctx->nvencoder, &pic_params);
+
+    cu_res = dl_fn->cuda_dl->cuCtxPopCurrent(&dummy);
+    if (cu_res != CUDA_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "cuCtxPopCurrent failed\n");
+        return AVERROR_EXTERNAL;
+    }
+
     if (nv_status != NV_ENC_SUCCESS &&
         nv_status != NV_ENC_ERR_NEED_MORE_INPUT)
         return nvenc_print_error(avctx, nv_status, "EncodePicture failed!");
 
     if (frame) {
-        av_fifo_generic_write(ctx->output_surface_queue, &inSurf, sizeof(inSurf), NULL);
+        av_fifo_generic_write(ctx->output_surface_queue, &in_surf, sizeof(in_surf), NULL);
         timestamp_queue_enqueue(ctx->timestamp_list, frame->pts);
 
         if (ctx->initial_pts[0] == AV_NOPTS_VALUE)
@@ -1775,25 +1912,76 @@ int ff_nvenc_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     /* all the pending buffers are now ready for output */
     if (nv_status == NV_ENC_SUCCESS) {
         while (av_fifo_size(ctx->output_surface_queue) > 0) {
-            av_fifo_generic_read(ctx->output_surface_queue, &tmpoutsurf, sizeof(tmpoutsurf), NULL);
-            av_fifo_generic_write(ctx->output_surface_ready_queue, &tmpoutsurf, sizeof(tmpoutsurf), NULL);
+            av_fifo_generic_read(ctx->output_surface_queue, &tmp_out_surf, sizeof(tmp_out_surf), NULL);
+            av_fifo_generic_write(ctx->output_surface_ready_queue, &tmp_out_surf, sizeof(tmp_out_surf), NULL);
         }
     }
 
-    if (output_ready(avctx, !frame)) {
-        av_fifo_generic_read(ctx->output_surface_ready_queue, &tmpoutsurf, sizeof(tmpoutsurf), NULL);
+    return 0;
+}
 
-        res = process_output_surface(avctx, pkt, tmpoutsurf);
+int ff_nvenc_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
+{
+    CUresult cu_res;
+    CUcontext dummy;
+    NvencSurface *tmp_out_surf;
+    int res;
+
+    NvencContext *ctx = avctx->priv_data;
+    NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs;
+
+    if (!ctx->cu_context || !ctx->nvencoder)
+        return AVERROR(EINVAL);
+
+    if (output_ready(avctx, ctx->encoder_flushing)) {
+        av_fifo_generic_read(ctx->output_surface_ready_queue, &tmp_out_surf, sizeof(tmp_out_surf), NULL);
+
+        cu_res = dl_fn->cuda_dl->cuCtxPushCurrent(ctx->cu_context);
+        if (cu_res != CUDA_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "cuCtxPushCurrent failed\n");
+            return AVERROR_EXTERNAL;
+        }
+
+        res = process_output_surface(avctx, pkt, tmp_out_surf);
+
+        cu_res = dl_fn->cuda_dl->cuCtxPopCurrent(&dummy);
+        if (cu_res != CUDA_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "cuCtxPopCurrent failed\n");
+            return AVERROR_EXTERNAL;
+        }
 
         if (res)
             return res;
 
-        av_assert0(tmpoutsurf->lockCount);
-        tmpoutsurf->lockCount--;
-
-        *got_packet = 1;
+        av_fifo_generic_write(ctx->unused_surface_queue, &tmp_out_surf, sizeof(tmp_out_surf), NULL);
+    } else if (ctx->encoder_flushing) {
+        return AVERROR_EOF;
     } else {
+        return AVERROR(EAGAIN);
+    }
+
+    return 0;
+}
+
+int ff_nvenc_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+                          const AVFrame *frame, int *got_packet)
+{
+    NvencContext *ctx = avctx->priv_data;
+    int res;
+
+    if (!ctx->encoder_flushing) {
+        res = ff_nvenc_send_frame(avctx, frame);
+        if (res < 0)
+            return res;
+    }
+
+    res = ff_nvenc_receive_packet(avctx, pkt);
+    if (res == AVERROR(EAGAIN) || res == AVERROR_EOF) {
         *got_packet = 0;
+    } else if (res < 0) {
+        return res;
+    } else {
+        *got_packet = 1;
     }
 
     return 0;
diff --git a/mythtv/external/FFmpeg/libavcodec/nvenc.h b/mythtv/external/FFmpeg/libavcodec/nvenc.h
index bad659aece1..afb93cc22ca 100644
--- a/mythtv/external/FFmpeg/libavcodec/nvenc.h
+++ b/mythtv/external/FFmpeg/libavcodec/nvenc.h
@@ -23,30 +23,15 @@
 
 #include "config.h"
 
+#include "compat/cuda/dynlink_loader.h"
 #include "libavutil/fifo.h"
 #include "libavutil/opt.h"
 
 #include "avcodec.h"
 
-#if CONFIG_CUDA
-#include "libavutil/hwcontext_cuda.h"
-#else
-
-#if defined(_WIN32)
-#define CUDAAPI __stdcall
-#else
-#define CUDAAPI
-#endif
-
-typedef enum cudaError_enum {
-    CUDA_SUCCESS = 0
-} CUresult;
-typedef int CUdevice;
-typedef void* CUcontext;
-typedef void* CUdeviceptr;
-#endif
-
 #define MAX_REGISTERED_FRAMES 64
+#define RC_MODE_DEPRECATED 0x800000
+#define RCD(rc_mode) ((rc_mode) | RC_MODE_DEPRECATED)
 
 typedef struct NvencSurface
 {
@@ -61,36 +46,12 @@ typedef struct NvencSurface
     NV_ENC_OUTPUT_PTR output_surface;
     NV_ENC_BUFFER_FORMAT format;
     int size;
-    int lockCount;
 } NvencSurface;
 
-typedef CUresult(CUDAAPI *PCUINIT)(unsigned int Flags);
-typedef CUresult(CUDAAPI *PCUDEVICEGETCOUNT)(int *count);
-typedef CUresult(CUDAAPI *PCUDEVICEGET)(CUdevice *device, int ordinal);
-typedef CUresult(CUDAAPI *PCUDEVICEGETNAME)(char *name, int len, CUdevice dev);
-typedef CUresult(CUDAAPI *PCUDEVICECOMPUTECAPABILITY)(int *major, int *minor, CUdevice dev);
-typedef CUresult(CUDAAPI *PCUCTXCREATE)(CUcontext *pctx, unsigned int flags, CUdevice dev);
-typedef CUresult(CUDAAPI *PCUCTXPOPCURRENT)(CUcontext *pctx);
-typedef CUresult(CUDAAPI *PCUCTXDESTROY)(CUcontext ctx);
-
-typedef NVENCSTATUS (NVENCAPI *PNVENCODEAPIGETMAXSUPPORTEDVERSION)(uint32_t* version);
-typedef NVENCSTATUS (NVENCAPI *PNVENCODEAPICREATEINSTANCE)(NV_ENCODE_API_FUNCTION_LIST *functionList);
-
 typedef struct NvencDynLoadFunctions
 {
-#if !CONFIG_CUDA
-    void *cuda;
-#endif
-    void *nvenc;
-
-    PCUINIT cu_init;
-    PCUDEVICEGETCOUNT cu_device_get_count;
-    PCUDEVICEGET cu_device_get;
-    PCUDEVICEGETNAME cu_device_get_name;
-    PCUDEVICECOMPUTECAPABILITY cu_device_compute_capability;
-    PCUCTXCREATE cu_ctx_create;
-    PCUCTXPOPCURRENT cu_ctx_pop_current;
-    PCUCTXDESTROY cu_ctx_destroy;
+    CudaFunctions *cuda_dl;
+    NvencFunctions *nvenc_dl;
 
     NV_ENCODE_API_FUNCTION_LIST nvenc_funcs;
     int nvenc_device_count;
@@ -150,10 +111,13 @@ typedef struct NvencContext
     int nb_surfaces;
     NvencSurface *surfaces;
 
+    AVFifoBuffer *unused_surface_queue;
     AVFifoBuffer *output_surface_queue;
     AVFifoBuffer *output_surface_ready_queue;
     AVFifoBuffer *timestamp_list;
 
+    int encoder_flushing;
+
     struct {
         CUdeviceptr ptr;
         NV_ENC_REGISTERED_PTR regptr;
@@ -192,13 +156,25 @@ typedef struct NvencContext
     int nonref_p;
     int strict_gop;
     int aq_strength;
-    int quality;
+    float quality;
+    int aud;
+    int bluray_compat;
+    int init_qp_p;
+    int init_qp_b;
+    int init_qp_i;
+    int cqp;
+    int weighted_pred;
+    int coder;
 } NvencContext;
 
 int ff_nvenc_encode_init(AVCodecContext *avctx);
 
 int ff_nvenc_encode_close(AVCodecContext *avctx);
 
+int ff_nvenc_send_frame(AVCodecContext *avctx, const AVFrame *frame);
+
+int ff_nvenc_receive_packet(AVCodecContext *avctx, AVPacket *pkt);
+
 int ff_nvenc_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                           const AVFrame *frame, int *got_packet);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/nvenc_h264.c b/mythtv/external/FFmpeg/libavcodec/nvenc_h264.c
index 6914046b8d3..c3b4bac7494 100644
--- a/mythtv/external/FFmpeg/libavcodec/nvenc_h264.c
+++ b/mythtv/external/FFmpeg/libavcodec/nvenc_h264.c
@@ -68,19 +68,22 @@ static const AVOption options[] = {
     { "5",            "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_LEVEL_H264_5 },        0, 0, VE, "level" },
     { "5.0",          "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_LEVEL_H264_5 },        0, 0, VE, "level" },
     { "5.1",          "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_LEVEL_H264_51 },       0, 0, VE, "level" },
-    { "rc",           "Override the preset rate-control",   OFFSET(rc),           AV_OPT_TYPE_INT,   { .i64 = -1 },                             -1, INT_MAX, VE, "rc" },
-    { "constqp",      "Constant QP mode",                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CONSTQP },              0, 0, VE, "rc" },
-    { "vbr",          "Variable bitrate mode",              0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_VBR },                  0, 0, VE, "rc" },
-    { "cbr",          "Constant bitrate mode",              0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CBR },                  0, 0, VE, "rc" },
-    { "vbr_minqp",    "Variable bitrate mode with MinQP",   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_VBR_MINQP },            0, 0, VE, "rc" },
-    { "ll_2pass_quality", "Multi-pass optimized for image quality (only for low-latency presets)",
-                                                            0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_2_PASS_QUALITY },       0, 0, VE, "rc" },
-    { "ll_2pass_size", "Multi-pass optimized for constant frame size (only for low-latency presets)",
-                                                            0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP }, 0, 0, VE, "rc" },
-    { "vbr_2pass",    "Multi-pass variable bitrate mode",   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_2_PASS_VBR },           0, 0, VE, "rc" },
+    { "rc",           "Override the preset rate-control",   OFFSET(rc),           AV_OPT_TYPE_INT,   { .i64 = -1 },                                  -1, INT_MAX, VE, "rc" },
+    { "constqp",      "Constant QP mode",                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CONSTQP },                   0, 0, VE, "rc" },
+    { "vbr",          "Variable bitrate mode",              0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_VBR },                       0, 0, VE, "rc" },
+    { "cbr",          "Constant bitrate mode",              0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CBR },                       0, 0, VE, "rc" },
+    { "vbr_minqp",    "Variable bitrate mode with MinQP (deprecated)", 0,         AV_OPT_TYPE_CONST, { .i64 = RCD(NV_ENC_PARAMS_RC_VBR_MINQP) },            0, 0, VE, "rc" },
+    { "ll_2pass_quality", "Multi-pass optimized for image quality (deprecated)",
+                                                            0,                    AV_OPT_TYPE_CONST, { .i64 = RCD(NV_ENC_PARAMS_RC_2_PASS_QUALITY) },       0, 0, VE, "rc" },
+    { "ll_2pass_size", "Multi-pass optimized for constant frame size (deprecated)",
+                                                            0,                    AV_OPT_TYPE_CONST, { .i64 = RCD(NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP) }, 0, 0, VE, "rc" },
+    { "vbr_2pass",    "Multi-pass variable bitrate mode (deprecated)", 0,         AV_OPT_TYPE_CONST, { .i64 = RCD(NV_ENC_PARAMS_RC_2_PASS_VBR) },           0, 0, VE, "rc" },
+    { "cbr_ld_hq",    "Constant bitrate low delay high quality mode", 0,          AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ },           0, 0, VE, "rc" },
+    { "cbr_hq",       "Constant bitrate high quality mode", 0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CBR_HQ },                    0, 0, VE, "rc" },
+    { "vbr_hq",       "Variable bitrate high quality mode", 0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_VBR_HQ },                    0, 0, VE, "rc" },
     { "rc-lookahead", "Number of frames to look ahead for rate-control",
-                                                            OFFSET(rc_lookahead), AV_OPT_TYPE_INT,   { .i64 = -1 }, -1, INT_MAX, VE },
-    { "surfaces",     "Number of concurrent surfaces",      OFFSET(nb_surfaces),  AV_OPT_TYPE_INT,   { .i64 = 32 },  0, INT_MAX, VE },
+                                                            OFFSET(rc_lookahead), AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, INT_MAX, VE },
+    { "surfaces",     "Number of concurrent surfaces",      OFFSET(nb_surfaces),  AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, MAX_REGISTERED_FRAMES, VE },
     { "cbr",          "Use cbr encoding mode",              OFFSET(cbr),          AV_OPT_TYPE_BOOL,  { .i64 = 0 },   0, 1, VE },
     { "2pass",        "Use 2pass encoding mode",            OFFSET(twopass),      AV_OPT_TYPE_BOOL,  { .i64 = -1 }, -1, 1, VE },
     { "gpu",          "Selects which NVENC capable GPU to use. First GPU is 0, second is 1, and so on.",
@@ -92,7 +95,7 @@ static const AVOption options[] = {
     { "no-scenecut",  "When lookahead is enabled, set this to 1 to disable adaptive I-frame insertion at scene cuts",
                                                             OFFSET(no_scenecut),  AV_OPT_TYPE_BOOL,  { .i64 = 0 }, 0,  1, VE },
     { "forced-idr",   "If forcing keyframes, force them as IDR frames.",
-                                                            OFFSET(forced_idr),   AV_OPT_TYPE_BOOL,  { .i64 = -1 }, -1, 1, VE },
+                                                            OFFSET(forced_idr),   AV_OPT_TYPE_BOOL,  { .i64 = 0 }, -1, 1, VE },
     { "b_adapt",      "When lookahead is enabled, set this to 0 to disable adaptive B-frame decision",
                                                             OFFSET(b_adapt),      AV_OPT_TYPE_BOOL,  { .i64 = 1 }, 0,  1, VE },
     { "spatial-aq",   "set to 1 to enable Spatial AQ",      OFFSET(aq),           AV_OPT_TYPE_BOOL,  { .i64 = 0 }, 0,  1, VE },
@@ -106,7 +109,23 @@ static const AVOption options[] = {
     { "aq-strength",  "When Spatial AQ is enabled, this field is used to specify AQ strength. AQ strength scale is from 1 (low) - 15 (aggressive)",
                                                             OFFSET(aq_strength),  AV_OPT_TYPE_INT,   { .i64 = 8 }, 1, 15, VE },
     { "cq",           "Set target quality level (0 to 51, 0 means automatic) for constant quality mode in VBR rate control",
-                                                            OFFSET(quality),      AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, 51, VE },
+                                                            OFFSET(quality),      AV_OPT_TYPE_FLOAT, { .dbl = 0.}, 0., 51., VE },
+    { "aud",          "Use access unit delimiters",         OFFSET(aud),          AV_OPT_TYPE_BOOL,  { .i64 = 0 }, 0, 1, VE },
+    { "bluray-compat", "Bluray compatibility workarounds",  OFFSET(bluray_compat),AV_OPT_TYPE_BOOL,  { .i64 = 0 }, 0, 1, VE },
+    { "init_qpP",     "Initial QP value for P frame",       OFFSET(init_qp_p),    AV_OPT_TYPE_INT,   { .i64 = -1 }, -1, 51, VE },
+    { "init_qpB",     "Initial QP value for B frame",       OFFSET(init_qp_b),    AV_OPT_TYPE_INT,   { .i64 = -1 }, -1, 51, VE },
+    { "init_qpI",     "Initial QP value for I frame",       OFFSET(init_qp_i),    AV_OPT_TYPE_INT,   { .i64 = -1 }, -1, 51, VE },
+    { "qp",           "Constant quantization parameter rate control method",
+                                                            OFFSET(cqp),          AV_OPT_TYPE_INT,   { .i64 = -1 }, -1, 51, VE },
+    { "weighted_pred","Set 1 to enable weighted prediction",
+                                                            OFFSET(weighted_pred),AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, 1, VE },
+    { "coder",        "Coder type",                         OFFSET(coder),        AV_OPT_TYPE_INT,   { .i64 = -1                                         },-1, 2, VE, "coder" },
+    { "default",      "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = -1                                         }, 0, 0, VE, "coder" },
+    { "auto",         "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_H264_ENTROPY_CODING_MODE_AUTOSELECT }, 0, 0, VE, "coder" },
+    { "cabac",        "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_H264_ENTROPY_CODING_MODE_CABAC      }, 0, 0, VE, "coder" },
+    { "cavlc",        "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_H264_ENTROPY_CODING_MODE_CAVLC      }, 0, 0, VE, "coder" },
+    { "ac",           "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_H264_ENTROPY_CODING_MODE_CABAC      }, 0, 0, VE, "coder" },
+    { "vlc",          "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_H264_ENTROPY_CODING_MODE_CAVLC      }, 0, 0, VE, "coder" },
     { NULL }
 };
 
@@ -119,6 +138,7 @@ static const AVCodecDefault defaults[] = {
     { "qcomp", "-1" },
     { "g", "250" },
     { "bf", "0" },
+    { "refs", "0" },
     { NULL },
 };
 
@@ -144,6 +164,8 @@ AVCodec ff_nvenc_encoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H264,
     .init           = nvenc_old_init,
+    .send_frame     = ff_nvenc_send_frame,
+    .receive_packet = ff_nvenc_receive_packet,
     .encode2        = ff_nvenc_encode_frame,
     .close          = ff_nvenc_encode_close,
     .priv_data_size = sizeof(NvencContext),
@@ -170,6 +192,8 @@ AVCodec ff_nvenc_h264_encoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H264,
     .init           = nvenc_old_init,
+    .send_frame     = ff_nvenc_send_frame,
+    .receive_packet = ff_nvenc_receive_packet,
     .encode2        = ff_nvenc_encode_frame,
     .close          = ff_nvenc_encode_close,
     .priv_data_size = sizeof(NvencContext),
@@ -196,6 +220,8 @@ AVCodec ff_h264_nvenc_encoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H264,
     .init           = ff_nvenc_encode_init,
+    .send_frame     = ff_nvenc_send_frame,
+    .receive_packet = ff_nvenc_receive_packet,
     .encode2        = ff_nvenc_encode_frame,
     .close          = ff_nvenc_encode_close,
     .priv_data_size = sizeof(NvencContext),
diff --git a/mythtv/external/FFmpeg/libavcodec/nvenc_hevc.c b/mythtv/external/FFmpeg/libavcodec/nvenc_hevc.c
index 0fec77a3bb7..89e8c3e53a4 100644
--- a/mythtv/external/FFmpeg/libavcodec/nvenc_hevc.c
+++ b/mythtv/external/FFmpeg/libavcodec/nvenc_hevc.c
@@ -67,19 +67,22 @@ static const AVOption options[] = {
     { "tier",         "Set the encoding tier",              OFFSET(tier),         AV_OPT_TYPE_INT,   { .i64 = NV_ENC_TIER_HEVC_MAIN }, NV_ENC_TIER_HEVC_MAIN, NV_ENC_TIER_HEVC_HIGH, VE, "tier"},
     { "main",         "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_TIER_HEVC_MAIN },    0, 0, VE,   "tier" },
     { "high",         "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_TIER_HEVC_HIGH },    0, 0, VE,   "tier" },
-    { "rc",           "Override the preset rate-control",   OFFSET(rc),           AV_OPT_TYPE_INT,   { .i64 = -1 },                             -1, INT_MAX, VE, "rc" },
-    { "constqp",      "Constant QP mode",                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CONSTQP },              0, 0, VE, "rc" },
-    { "vbr",          "Variable bitrate mode",              0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_VBR },                  0, 0, VE, "rc" },
-    { "cbr",          "Constant bitrate mode",              0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CBR },                  0, 0, VE, "rc" },
-    { "vbr_minqp",    "Variable bitrate mode with MinQP",   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_VBR_MINQP },            0, 0, VE, "rc" },
-    { "ll_2pass_quality", "Multi-pass optimized for image quality (only for low-latency presets)",
-                                                            0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_2_PASS_QUALITY },       0, 0, VE, "rc" },
-    { "ll_2pass_size", "Multi-pass optimized for constant frame size (only for low-latency presets)",
-                                                            0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP }, 0, 0, VE, "rc" },
-    { "vbr_2pass",    "Multi-pass variable bitrate mode",   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_2_PASS_VBR },           0, 0, VE, "rc" },
+    { "rc",           "Override the preset rate-control",   OFFSET(rc),           AV_OPT_TYPE_INT,   { .i64 = -1 },                                  -1, INT_MAX, VE, "rc" },
+    { "constqp",      "Constant QP mode",                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CONSTQP },                   0, 0, VE, "rc" },
+    { "vbr",          "Variable bitrate mode",              0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_VBR },                       0, 0, VE, "rc" },
+    { "cbr",          "Constant bitrate mode",              0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CBR },                       0, 0, VE, "rc" },
+    { "vbr_minqp",    "Variable bitrate mode with MinQP (deprecated)", 0,         AV_OPT_TYPE_CONST, { .i64 = RCD(NV_ENC_PARAMS_RC_VBR_MINQP) },            0, 0, VE, "rc" },
+    { "ll_2pass_quality", "Multi-pass optimized for image quality (deprecated)",
+                                                            0,                    AV_OPT_TYPE_CONST, { .i64 = RCD(NV_ENC_PARAMS_RC_2_PASS_QUALITY) },       0, 0, VE, "rc" },
+    { "ll_2pass_size", "Multi-pass optimized for constant frame size (deprecated)",
+                                                            0,                    AV_OPT_TYPE_CONST, { .i64 = RCD(NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP) }, 0, 0, VE, "rc" },
+    { "vbr_2pass",    "Multi-pass variable bitrate mode (deprecated)", 0,         AV_OPT_TYPE_CONST, { .i64 = RCD(NV_ENC_PARAMS_RC_2_PASS_VBR) },           0, 0, VE, "rc" },
+    { "cbr_ld_hq",    "Constant bitrate low delay high quality mode", 0,          AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ },           0, 0, VE, "rc" },
+    { "cbr_hq",       "Constant bitrate high quality mode", 0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_CBR_HQ },                    0, 0, VE, "rc" },
+    { "vbr_hq",       "Variable bitrate high quality mode", 0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_PARAMS_RC_VBR_HQ },                    0, 0, VE, "rc" },
     { "rc-lookahead", "Number of frames to look ahead for rate-control",
-                                                            OFFSET(rc_lookahead), AV_OPT_TYPE_INT,   { .i64 = -1 }, -1, INT_MAX, VE },
-    { "surfaces",     "Number of concurrent surfaces",      OFFSET(nb_surfaces),  AV_OPT_TYPE_INT,   { .i64 = 32 },  0, INT_MAX, VE },
+                                                            OFFSET(rc_lookahead), AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, INT_MAX, VE },
+    { "surfaces",     "Number of concurrent surfaces",      OFFSET(nb_surfaces),  AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, MAX_REGISTERED_FRAMES, VE },
     { "cbr",          "Use cbr encoding mode",              OFFSET(cbr),          AV_OPT_TYPE_BOOL,  { .i64 = 0 },   0, 1, VE },
     { "2pass",        "Use 2pass encoding mode",            OFFSET(twopass),      AV_OPT_TYPE_BOOL,  { .i64 = -1 }, -1, 1, VE },
     { "gpu",          "Selects which NVENC capable GPU to use. First GPU is 0, second is 1, and so on.",
@@ -91,7 +94,7 @@ static const AVOption options[] = {
     { "no-scenecut",  "When lookahead is enabled, set this to 1 to disable adaptive I-frame insertion at scene cuts",
                                                             OFFSET(no_scenecut),  AV_OPT_TYPE_BOOL,  { .i64 = 0 }, 0, 1, VE },
     { "forced-idr",   "If forcing keyframes, force them as IDR frames.",
-                                                            OFFSET(forced_idr),   AV_OPT_TYPE_BOOL,  { .i64 = -1 }, -1, 1, VE },
+                                                            OFFSET(forced_idr),   AV_OPT_TYPE_BOOL,  { .i64 = 0 }, -1, 1, VE },
     { "spatial_aq",   "set to 1 to enable Spatial AQ",      OFFSET(aq),           AV_OPT_TYPE_BOOL,  { .i64 = 0 }, 0, 1, VE },
     { "temporal_aq",  "set to 1 to enable Temporal AQ",     OFFSET(temporal_aq),  AV_OPT_TYPE_BOOL,  { .i64 = 0 }, 0, 1, VE },
     { "zerolatency",  "Set 1 to indicate zero latency operation (no reordering delay)",
@@ -103,7 +106,16 @@ static const AVOption options[] = {
     { "aq-strength",  "When Spatial AQ is enabled, this field is used to specify AQ strength. AQ strength scale is from 1 (low) - 15 (aggressive)",
                                                             OFFSET(aq_strength),  AV_OPT_TYPE_INT,   { .i64 = 8 }, 1, 15, VE },
     { "cq",           "Set target quality level (0 to 51, 0 means automatic) for constant quality mode in VBR rate control",
-                                                            OFFSET(quality),      AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, 51, VE },
+                                                            OFFSET(quality),      AV_OPT_TYPE_FLOAT, { .dbl = 0.}, 0., 51., VE },
+    { "aud",          "Use access unit delimiters",         OFFSET(aud),          AV_OPT_TYPE_BOOL,  { .i64 = 0 }, 0, 1, VE },
+    { "bluray-compat", "Bluray compatibility workarounds",  OFFSET(bluray_compat),AV_OPT_TYPE_BOOL,  { .i64 = 0 }, 0, 1, VE },
+    { "init_qpP",     "Initial QP value for P frame",       OFFSET(init_qp_p),    AV_OPT_TYPE_INT,   { .i64 = -1 }, -1, 51, VE },
+    { "init_qpB",     "Initial QP value for B frame",       OFFSET(init_qp_b),    AV_OPT_TYPE_INT,   { .i64 = -1 }, -1, 51, VE },
+    { "init_qpI",     "Initial QP value for I frame",       OFFSET(init_qp_i),    AV_OPT_TYPE_INT,   { .i64 = -1 }, -1, 51, VE },
+    { "qp",           "Constant quantization parameter rate control method",
+                                                            OFFSET(cqp),          AV_OPT_TYPE_INT,   { .i64 = -1 }, -1, 51, VE },
+    { "weighted_pred","Set 1 to enable weighted prediction",
+                                                            OFFSET(weighted_pred),AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, 1, VE },
     { NULL }
 };
 
@@ -116,6 +128,7 @@ static const AVCodecDefault defaults[] = {
     { "qcomp", "-1" },
     { "g", "250" },
     { "bf", "0" },
+    { "refs", "0" },
     { NULL },
 };
 
@@ -140,6 +153,8 @@ AVCodec ff_nvenc_hevc_encoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_HEVC,
     .init           = nvenc_old_init,
+    .send_frame     = ff_nvenc_send_frame,
+    .receive_packet = ff_nvenc_receive_packet,
     .encode2        = ff_nvenc_encode_frame,
     .close          = ff_nvenc_encode_close,
     .priv_data_size = sizeof(NvencContext),
@@ -165,6 +180,8 @@ AVCodec ff_hevc_nvenc_encoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_HEVC,
     .init           = ff_nvenc_encode_init,
+    .send_frame     = ff_nvenc_send_frame,
+    .receive_packet = ff_nvenc_receive_packet,
     .encode2        = ff_nvenc_encode_frame,
     .close          = ff_nvenc_encode_close,
     .priv_data_size = sizeof(NvencContext),
diff --git a/mythtv/external/FFmpeg/libavcodec/omx.c b/mythtv/external/FFmpeg/libavcodec/omx.c
index c1b6fb98473..466e0be9fe1 100644
--- a/mythtv/external/FFmpeg/libavcodec/omx.c
+++ b/mythtv/external/FFmpeg/libavcodec/omx.c
@@ -220,12 +220,13 @@ typedef struct OMXCodecContext {
 
     int mutex_cond_inited;
 
-    int num_in_frames, num_out_frames;
+    int eos_sent, got_eos;
 
     uint8_t *output_buf;
     int output_buf_size;
 
     int input_zerocopy;
+    int profile;
 } OMXCodecContext;
 
 static void append_buffer(pthread_mutex_t *mutex, pthread_cond_t *cond,
@@ -352,12 +353,12 @@ static av_cold int find_component(OMXContext *omx_context, void *logctx,
         av_log(logctx, AV_LOG_WARNING, "No component for role %s found\n", role);
         return AVERROR_ENCODER_NOT_FOUND;
     }
-    components = av_mallocz(sizeof(char*) * num);
+    components = av_mallocz_array(num, sizeof(*components));
     if (!components)
         return AVERROR(ENOMEM);
     for (i = 0; i < num; i++) {
         components[i] = av_mallocz(OMX_MAX_STRINGNAME_SIZE);
-        if (!components) {
+        if (!components[i]) {
             ret = AVERROR(ENOMEM);
             goto end;
         }
@@ -523,6 +524,19 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
         CHECK(err);
         avc.nBFrames = 0;
         avc.nPFrames = avctx->gop_size - 1;
+        switch (s->profile == FF_PROFILE_UNKNOWN ? avctx->profile : s->profile) {
+        case FF_PROFILE_H264_BASELINE:
+            avc.eProfile = OMX_VIDEO_AVCProfileBaseline;
+            break;
+        case FF_PROFILE_H264_MAIN:
+            avc.eProfile = OMX_VIDEO_AVCProfileMain;
+            break;
+        case FF_PROFILE_H264_HIGH:
+            avc.eProfile = OMX_VIDEO_AVCProfileHigh;
+            break;
+        default:
+            break;
+        }
         err = OMX_SetParameter(s->handle, OMX_IndexParamVideoAvc, &avc);
         CHECK(err);
     }
@@ -761,7 +775,10 @@ static int omx_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
             } else {
                 // If not, we need to allocate a new buffer with the right
                 // size and copy the input frame into it.
-                uint8_t *buf = av_malloc(av_image_get_buffer_size(avctx->pix_fmt, s->stride, s->plane_size, 1));
+                uint8_t *buf = NULL;
+                int image_buffer_size = av_image_get_buffer_size(avctx->pix_fmt, s->stride, s->plane_size, 1);
+                if (image_buffer_size >= 0)
+                    buf = av_malloc(image_buffer_size);
                 if (!buf) {
                     // Return the buffer to the queue so it's not lost
                     append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
@@ -791,17 +808,35 @@ static int omx_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
             av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
             return AVERROR_UNKNOWN;
         }
-        s->num_in_frames++;
+    } else if (!s->eos_sent) {
+        buffer = get_buffer(&s->input_mutex, &s->input_cond,
+                            &s->num_free_in_buffers, s->free_in_buffers, 1);
+
+        buffer->nFilledLen = 0;
+        buffer->nFlags = OMX_BUFFERFLAG_EOS;
+        buffer->pAppPrivate = buffer->pOutputPortPrivate = NULL;
+        err = OMX_EmptyThisBuffer(s->handle, buffer);
+        if (err != OMX_ErrorNone) {
+            append_buffer(&s->input_mutex, &s->input_cond, &s->num_free_in_buffers, s->free_in_buffers, buffer);
+            av_log(avctx, AV_LOG_ERROR, "OMX_EmptyThisBuffer failed: %x\n", err);
+            return AVERROR_UNKNOWN;
+        }
+        s->eos_sent = 1;
     }
 
-    while (!*got_packet && ret == 0) {
-        // Only wait for output if flushing and not all frames have been output
+    while (!*got_packet && ret == 0 && !s->got_eos) {
+        // If not flushing, just poll the queue if there's finished packets.
+        // If flushing, do a blocking wait until we either get a completed
+        // packet, or get EOS.
         buffer = get_buffer(&s->output_mutex, &s->output_cond,
                             &s->num_done_out_buffers, s->done_out_buffers,
-                            !frame && s->num_out_frames < s->num_in_frames);
+                            !frame);
         if (!buffer)
             break;
 
+        if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
+            s->got_eos = 1;
+
         if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG && avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
             if ((ret = av_reallocp(&avctx->extradata, avctx->extradata_size + buffer->nFilledLen + AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {
                 avctx->extradata_size = 0;
@@ -811,8 +846,6 @@ static int omx_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
             avctx->extradata_size += buffer->nFilledLen;
             memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
         } else {
-            if (buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME)
-                s->num_out_frames++;
             if (!(buffer->nFlags & OMX_BUFFERFLAG_ENDOFFRAME) || !pkt->data) {
                 // If the output packet isn't preallocated, just concatenate everything in our
                 // own buffer
@@ -881,6 +914,10 @@ static const AVOption options[] = {
     { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
     { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
+    { "profile",  "Set the encoding profile", OFFSET(profile), AV_OPT_TYPE_INT,   { .i64 = FF_PROFILE_UNKNOWN },       FF_PROFILE_UNKNOWN, FF_PROFILE_H264_HIGH, VE, "profile" },
+    { "baseline", "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_BASELINE }, 0, 0, VE, "profile" },
+    { "main",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_MAIN },     0, 0, VE, "profile" },
+    { "high",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_HIGH },     0, 0, VE, "profile" },
     { NULL }
 };
 
diff --git a/mythtv/external/FFmpeg/libavcodec/on2avcdata.c b/mythtv/external/FFmpeg/libavcodec/on2avcdata.c
index abe598350b1..ec983572e68 100644
--- a/mythtv/external/FFmpeg/libavcodec/on2avcdata.c
+++ b/mythtv/external/FFmpeg/libavcodec/on2avcdata.c
@@ -7724,12 +7724,12 @@ static const double tabs_9_20[9 * 2][20] = {
       0.22783, 0.058894795, -0.61350902, 0.69559873, -0.27013783, }
 };
 
-const double* const ff_on2avc_tabs_9_20_1[9] = {
+const double * const ff_on2avc_tabs_9_20_1[9] = {
     tabs_9_20[0], tabs_9_20[1], tabs_9_20[2], tabs_9_20[3], tabs_9_20[4],
     tabs_9_20[5], tabs_9_20[6], tabs_9_20[7], tabs_9_20[8]
 };
 
-const double* const ff_on2avc_tabs_9_20_2[9] = {
+const double * const ff_on2avc_tabs_9_20_2[9] = {
     tabs_9_20[ 9], tabs_9_20[10], tabs_9_20[11], tabs_9_20[12], tabs_9_20[13],
     tabs_9_20[14], tabs_9_20[15], tabs_9_20[16], tabs_9_20[17]
 };
@@ -7927,7 +7927,7 @@ static const double tabs_19_40[19 * 2][40] = {
       0.019871848, -0.11989559, 0.036659135, 0.26632201, -0.3057397, -0.23220335, 0.68741352, -0.54024027, }
 };
 
-const double* const ff_on2avc_tabs_19_40_1[19] = {
+const double * const ff_on2avc_tabs_19_40_1[19] = {
     tabs_19_40[ 0], tabs_19_40[ 1], tabs_19_40[ 2], tabs_19_40[ 3],
     tabs_19_40[ 4], tabs_19_40[ 5], tabs_19_40[ 6], tabs_19_40[ 7],
     tabs_19_40[ 8], tabs_19_40[ 9], tabs_19_40[10], tabs_19_40[11],
@@ -7935,7 +7935,7 @@ const double* const ff_on2avc_tabs_19_40_1[19] = {
     tabs_19_40[16], tabs_19_40[17], tabs_19_40[18],
 };
 
-const double* const ff_on2avc_tabs_19_40_2[19] = {
+const double * const ff_on2avc_tabs_19_40_2[19] = {
     tabs_19_40[19], tabs_19_40[20], tabs_19_40[21], tabs_19_40[22],
     tabs_19_40[23], tabs_19_40[24], tabs_19_40[25], tabs_19_40[26],
     tabs_19_40[27], tabs_19_40[28], tabs_19_40[29], tabs_19_40[30],
@@ -8826,7 +8826,7 @@ static const double tabs_20_84[20 * 4][84] = {
       0.51434408, -0.41486443, 0.27672635, -0.10432054, },
 };
 
-const double* const ff_on2avc_tabs_20_84_1[20] = {
+const double * const ff_on2avc_tabs_20_84_1[20] = {
     tabs_20_84[ 0], tabs_20_84[ 1], tabs_20_84[ 2], tabs_20_84[ 3],
     tabs_20_84[ 4], tabs_20_84[ 5], tabs_20_84[ 6], tabs_20_84[ 7],
     tabs_20_84[ 8], tabs_20_84[ 9], tabs_20_84[10], tabs_20_84[11],
@@ -8834,7 +8834,7 @@ const double* const ff_on2avc_tabs_20_84_1[20] = {
     tabs_20_84[16], tabs_20_84[17], tabs_20_84[18], tabs_20_84[19]
 };
 
-const double* const ff_on2avc_tabs_20_84_2[20] = {
+const double * const ff_on2avc_tabs_20_84_2[20] = {
     tabs_20_84[20], tabs_20_84[21], tabs_20_84[22], tabs_20_84[23],
     tabs_20_84[24], tabs_20_84[25], tabs_20_84[26], tabs_20_84[27],
     tabs_20_84[28], tabs_20_84[29], tabs_20_84[30], tabs_20_84[31],
@@ -8842,7 +8842,7 @@ const double* const ff_on2avc_tabs_20_84_2[20] = {
     tabs_20_84[36], tabs_20_84[37], tabs_20_84[38], tabs_20_84[39]
 };
 
-const double* const ff_on2avc_tabs_20_84_3[20] = {
+const double * const ff_on2avc_tabs_20_84_3[20] = {
     tabs_20_84[40], tabs_20_84[41], tabs_20_84[42], tabs_20_84[43],
     tabs_20_84[44], tabs_20_84[45], tabs_20_84[46], tabs_20_84[47],
     tabs_20_84[48], tabs_20_84[49], tabs_20_84[50], tabs_20_84[51],
@@ -8850,7 +8850,7 @@ const double* const ff_on2avc_tabs_20_84_3[20] = {
     tabs_20_84[56], tabs_20_84[57], tabs_20_84[58], tabs_20_84[59]
 };
 
-const double* const ff_on2avc_tabs_20_84_4[20] = {
+const double * const ff_on2avc_tabs_20_84_4[20] = {
     tabs_20_84[60], tabs_20_84[61], tabs_20_84[62], tabs_20_84[63],
     tabs_20_84[64], tabs_20_84[65], tabs_20_84[66], tabs_20_84[67],
     tabs_20_84[68], tabs_20_84[69], tabs_20_84[70], tabs_20_84[71],
diff --git a/mythtv/external/FFmpeg/libavcodec/on2avcdata.h b/mythtv/external/FFmpeg/libavcodec/on2avcdata.h
index 95d88e02524..dc7833feff6 100644
--- a/mythtv/external/FFmpeg/libavcodec/on2avcdata.h
+++ b/mythtv/external/FFmpeg/libavcodec/on2avcdata.h
@@ -64,16 +64,16 @@ extern const double ff_on2avc_tab_84_1[];
 extern const double ff_on2avc_tab_84_2[];
 extern const double ff_on2avc_tab_84_3[];
 extern const double ff_on2avc_tab_84_4[];
-extern const double* const ff_on2avc_tabs_4_10_1[4];
-extern const double* const ff_on2avc_tabs_4_10_2[4];
-extern const double* const ff_on2avc_tabs_9_20_1[9];
-extern const double* const ff_on2avc_tabs_9_20_2[9];
-extern const double* const ff_on2avc_tabs_19_40_1[19];
-extern const double* const ff_on2avc_tabs_19_40_2[19];
-extern const double* const ff_on2avc_tabs_20_84_1[20];
-extern const double* const ff_on2avc_tabs_20_84_2[20];
-extern const double* const ff_on2avc_tabs_20_84_3[20];
-extern const double* const ff_on2avc_tabs_20_84_4[20];
+extern const double * const ff_on2avc_tabs_4_10_1[4];
+extern const double * const ff_on2avc_tabs_4_10_2[4];
+extern const double * const ff_on2avc_tabs_9_20_1[9];
+extern const double * const ff_on2avc_tabs_9_20_2[9];
+extern const double * const ff_on2avc_tabs_19_40_1[19];
+extern const double * const ff_on2avc_tabs_19_40_2[19];
+extern const double * const ff_on2avc_tabs_20_84_1[20];
+extern const double * const ff_on2avc_tabs_20_84_2[20];
+extern const double * const ff_on2avc_tabs_20_84_3[20];
+extern const double * const ff_on2avc_tabs_20_84_4[20];
 extern const float ff_on2avc_ctab_1[2048];
 extern const float ff_on2avc_ctab_2[2048];
 extern const float ff_on2avc_ctab_3[2048];
diff --git a/mythtv/external/FFmpeg/libavcodec/options.c b/mythtv/external/FFmpeg/libavcodec/options.c
index d8e3dbfa33c..82e12179a6b 100644
--- a/mythtv/external/FFmpeg/libavcodec/options.c
+++ b/mythtv/external/FFmpeg/libavcodec/options.c
@@ -119,6 +119,7 @@ static int init_context_defaults(AVCodecContext *s, const AVCodec *codec)
     s->execute2            = avcodec_default_execute2;
     s->sample_aspect_ratio = (AVRational){0,1};
     s->pix_fmt             = AV_PIX_FMT_NONE;
+    s->sw_pix_fmt          = AV_PIX_FMT_NONE;
     s->sample_fmt          = AV_SAMPLE_FMT_NONE;
 
     s->reordered_opaque    = AV_NOPTS_VALUE;
@@ -187,6 +188,31 @@ void avcodec_free_context(AVCodecContext **pavctx)
 }
 
 #if FF_API_COPY_CONTEXT
+static void copy_context_reset(AVCodecContext *avctx)
+{
+    int i;
+
+    av_opt_free(avctx);
+#if FF_API_CODED_FRAME
+FF_DISABLE_DEPRECATION_WARNINGS
+    av_frame_free(&avctx->coded_frame);
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+    av_freep(&avctx->rc_override);
+    av_freep(&avctx->intra_matrix);
+    av_freep(&avctx->inter_matrix);
+    av_freep(&avctx->extradata);
+    av_freep(&avctx->subtitle_header);
+    av_buffer_unref(&avctx->hw_frames_ctx);
+    av_buffer_unref(&avctx->hw_device_ctx);
+    for (i = 0; i < avctx->nb_coded_side_data; i++)
+        av_freep(&avctx->coded_side_data[i].data);
+    av_freep(&avctx->coded_side_data);
+    avctx->subtitle_header_size = 0;
+    avctx->nb_coded_side_data = 0;
+    avctx->extradata_size = 0;
+}
+
 int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src)
 {
     const AVCodec *orig_codec = dest->codec;
@@ -199,12 +225,7 @@ int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src)
         return AVERROR(EINVAL);
     }
 
-    av_opt_free(dest);
-    av_freep(&dest->rc_override);
-    av_freep(&dest->intra_matrix);
-    av_freep(&dest->inter_matrix);
-    av_freep(&dest->extradata);
-    av_freep(&dest->subtitle_header);
+    copy_context_reset(dest);
 
     memcpy(dest, src, sizeof(*dest));
     av_opt_copy(dest, src);
@@ -229,11 +250,14 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
     /* reallocate values that should be allocated separately */
     dest->extradata       = NULL;
+    dest->coded_side_data = NULL;
     dest->intra_matrix    = NULL;
     dest->inter_matrix    = NULL;
     dest->rc_override     = NULL;
     dest->subtitle_header = NULL;
     dest->hw_frames_ctx   = NULL;
+    dest->hw_device_ctx   = NULL;
+    dest->nb_coded_side_data = 0;
 
 #define alloc_and_copy_or_fail(obj, size, pad) \
     if (src->obj && size > 0) { \
@@ -263,15 +287,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
     return 0;
 
 fail:
-    av_freep(&dest->subtitle_header);
-    av_freep(&dest->rc_override);
-    av_freep(&dest->intra_matrix);
-    av_freep(&dest->inter_matrix);
-    av_freep(&dest->extradata);
-    av_buffer_unref(&dest->hw_frames_ctx);
-    dest->subtitle_header_size = 0;
-    dest->extradata_size = 0;
-    av_opt_free(dest);
+    copy_context_reset(dest);
     return AVERROR(ENOMEM);
 }
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/options_table.h b/mythtv/external/FFmpeg/libavcodec/options_table.h
index 995906b977e..2ac37c3ff17 100644
--- a/mythtv/external/FFmpeg/libavcodec/options_table.h
+++ b/mythtv/external/FFmpeg/libavcodec/options_table.h
@@ -106,12 +106,12 @@ static const AVOption avcodec_options[] = {
 {"umh", "umh motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = ME_UMH }, INT_MIN, INT_MAX, V|E, "me_method" },
 {"iter", "iter motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = ME_ITER }, INT_MIN, INT_MAX, V|E, "me_method" },
 #endif
-{"time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, INT_MIN, INT_MAX},
+{"time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, 0, INT_MAX},
 {"g", "set the group of picture (GOP) size", OFFSET(gop_size), AV_OPT_TYPE_INT, {.i64 = 12 }, INT_MIN, INT_MAX, V|E},
 {"ar", "set audio sampling rate (in Hz)", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, A|D|E},
 {"ac", "set number of audio channels", OFFSET(channels), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, A|D|E},
 {"cutoff", "set cutoff bandwidth", OFFSET(cutoff), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, A|E},
-{"frame_size", NULL, OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, A|E},
+{"frame_size", NULL, OFFSET(frame_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, A|E},
 {"frame_number", NULL, OFFSET(frame_number), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
 {"delay", NULL, OFFSET(delay), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
 {"qcomp", "video quantizer scale compression (VBR). Constant of ratecontrol equation. "
@@ -163,6 +163,7 @@ static const AVOption avcodec_options[] = {
 {"dc_clip", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_DC_CLIP }, INT_MIN, INT_MAX, V|D, "bug"},
 {"ms", "work around various bugs in Microsoft's broken decoders", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_MS }, INT_MIN, INT_MAX, V|D, "bug"},
 {"trunc", "truncated frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_TRUNCATED}, INT_MIN, INT_MAX, V|D, "bug"},
+{"iedge", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_BUG_IEDGE }, INT_MIN, INT_MAX, V|D, "bug"},
 {"strict", "how strictly to follow the standards", OFFSET(strict_std_compliance), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, A|V|D|E, "strict"},
 {"very", "strictly conform to a older more strict version of the spec or reference software", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_VERY_STRICT }, INT_MIN, INT_MAX, A|V|D|E, "strict"},
 {"strict", "strictly conform to all the things in the spec no matter what the consequences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_STRICT }, INT_MIN, INT_MAX, A|V|D|E, "strict"},
@@ -179,8 +180,8 @@ static const AVOption avcodec_options[] = {
 {"careful",    "consider things that violate the spec, are fast to check and have not been seen in the wild as errors", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CAREFUL }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 {"compliant",  "consider all spec non compliancies as errors", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_COMPLIANT }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 {"aggressive", "consider things that a sane encoder should not do as an error", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_AGGRESSIVE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
-{"has_b_frames", NULL, OFFSET(has_b_frames), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"block_align", NULL, OFFSET(block_align), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
+{"has_b_frames", NULL, OFFSET(has_b_frames), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX},
+{"block_align", NULL, OFFSET(block_align), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX},
 #if FF_API_PRIVATE_OPT
 {"mpeg_quant", "use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E},
 #endif
@@ -246,7 +247,7 @@ static const AVOption avcodec_options[] = {
 {"guess_mvs", "iterative motion vector (MV) search (slow)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_EC_GUESS_MVS }, INT_MIN, INT_MAX, V|D, "ec"},
 {"deblock", "use strong deblock filter for damaged MBs", 0, AV_OPT_TYPE_CONST, {.i64 = FF_EC_DEBLOCK }, INT_MIN, INT_MAX, V|D, "ec"},
 {"favor_inter", "favor predicting from the previous frame", 0, AV_OPT_TYPE_CONST, {.i64 = FF_EC_FAVOR_INTER }, INT_MIN, INT_MAX, V|D, "ec"},
-{"bits_per_coded_sample", NULL, OFFSET(bits_per_coded_sample), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
+{"bits_per_coded_sample", NULL, OFFSET(bits_per_coded_sample), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX},
 #if FF_API_PRIVATE_OPT
 {"pred", "prediction method", OFFSET(prediction_method), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|E, "pred"},
 {"left", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PRED_LEFT }, INT_MIN, INT_MAX, V|E, "pred"},
@@ -274,8 +275,10 @@ static const AVOption avcodec_options[] = {
 {"er", "error recognition", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_ER }, INT_MIN, INT_MAX, V|D, "debug"},
 {"mmco", "memory management control operations (H.264)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_MMCO }, INT_MIN, INT_MAX, V|D, "debug"},
 {"bugs", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_BUGS }, INT_MIN, INT_MAX, V|D, "debug"},
+#if FF_API_DEBUG_MV
 {"vis_qp", "visualize quantization parameter (QP), lower QP are tinted greener", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_QP }, INT_MIN, INT_MAX, V|D, "debug"},
 {"vis_mb_type", "visualize block types", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MB_TYPE }, INT_MIN, INT_MAX, V|D, "debug"},
+#endif
 {"buffers", "picture buffer allocations", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_BUFFERS }, INT_MIN, INT_MAX, V|D, "debug"},
 {"thread_ops", "threading operations", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_THREADS }, INT_MIN, INT_MAX, V|A|D, "debug"},
 {"nomc", "skip motion compensation", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_NOMC }, INT_MIN, INT_MAX, V|A|D, "debug"},
@@ -394,6 +397,7 @@ static const AVOption avcodec_options[] = {
 {"mpeg4_core", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_MPEG4_CORE }, INT_MIN, INT_MAX, V|E, "profile"},
 {"mpeg4_main", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_MPEG4_MAIN }, INT_MIN, INT_MAX, V|E, "profile"},
 {"mpeg4_asp",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_MPEG4_ADVANCED_SIMPLE }, INT_MIN, INT_MAX, V|E, "profile"},
+{"main10",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_HEVC_MAIN_10 }, INT_MIN, INT_MAX, V|E, "profile"},
 {"level", NULL, OFFSET(level), AV_OPT_TYPE_INT, {.i64 = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "level"},
 {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "level"},
 {"lowres", "decode at 1= 1/2, 2=1/4, 3=1/8 resolutions", OFFSET(lowres), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, V|A|D},
@@ -444,32 +448,46 @@ static const AVOption avcodec_options[] = {
 {"max_prediction_order", NULL, OFFSET(max_prediction_order), AV_OPT_TYPE_INT, {.i64 = -1 }, INT_MIN, INT_MAX, A|E},
 {"timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, V|E},
 #endif
-{"bits_per_raw_sample", NULL, OFFSET(bits_per_raw_sample), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX},
-{"channel_layout", NULL, OFFSET(channel_layout), AV_OPT_TYPE_INT64, {.i64 = DEFAULT }, 0, INT64_MAX, A|E|D, "channel_layout"},
-{"request_channel_layout", NULL, OFFSET(request_channel_layout), AV_OPT_TYPE_INT64, {.i64 = DEFAULT }, 0, INT64_MAX, A|D, "request_channel_layout"},
+{"bits_per_raw_sample", NULL, OFFSET(bits_per_raw_sample), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX},
+{"channel_layout", NULL, OFFSET(channel_layout), AV_OPT_TYPE_UINT64, {.i64 = DEFAULT }, 0, UINT64_MAX, A|E|D, "channel_layout"},
+{"request_channel_layout", NULL, OFFSET(request_channel_layout), AV_OPT_TYPE_UINT64, {.i64 = DEFAULT }, 0, UINT64_MAX, A|D, "request_channel_layout"},
 {"rc_max_vbv_use", NULL, OFFSET(rc_max_available_vbv_use), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, 0.0, FLT_MAX, V|E},
 {"rc_min_vbv_use", NULL, OFFSET(rc_min_vbv_overflow_use),  AV_OPT_TYPE_FLOAT, {.dbl = 3 },     0.0, FLT_MAX, V|E},
 {"ticks_per_frame", NULL, OFFSET(ticks_per_frame), AV_OPT_TYPE_INT, {.i64 = 1 }, 1, INT_MAX, A|V|E|D},
-{"color_primaries", "color primaries", OFFSET(color_primaries), AV_OPT_TYPE_INT, {.i64 = AVCOL_PRI_UNSPECIFIED }, 1, AVCOL_PRI_NB-1, V|E|D, "color_primaries_type"},
+{"color_primaries", "color primaries", OFFSET(color_primaries), AV_OPT_TYPE_INT, {.i64 = AVCOL_PRI_UNSPECIFIED }, 1, INT_MAX, V|E|D, "color_primaries_type"},
 {"bt709",       "BT.709",         0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT709 },        INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
-{"unspecified", "Unspecified",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_UNSPECIFIED },  INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
+{"unknown",     "Unspecified",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_UNSPECIFIED },  INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 {"bt470m",      "BT.470 M",       0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT470M },       INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 {"bt470bg",     "BT.470 BG",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT470BG },      INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 {"smpte170m",   "SMPTE 170 M",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE170M },    INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 {"smpte240m",   "SMPTE 240 M",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE240M },    INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 {"film",        "Film",           0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_FILM },         INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 {"bt2020",      "BT.2020",        0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_BT2020 },       INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
-{"smpte428_1",  "SMPTE ST 428-1", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTEST428_1 }, INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
+{"smpte428",    "SMPTE 428-1",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE428 },     INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
+{"smpte428_1",  "SMPTE 428-1",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE428 },     INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 {"smpte431",    "SMPTE 431-2",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE431 },     INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
 {"smpte432",    "SMPTE 422-1",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_SMPTE432 },     INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
-{"color_trc", "color transfer characteristics", OFFSET(color_trc), AV_OPT_TYPE_INT, {.i64 = AVCOL_TRC_UNSPECIFIED }, 1, AVCOL_TRC_NB-1, V|E|D, "color_trc_type"},
+{"jedec-p22",   "JEDEC P22",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_JEDEC_P22 },    INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
+{"unspecified", "Unspecified",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_PRI_UNSPECIFIED },  INT_MIN, INT_MAX, V|E|D, "color_primaries_type"},
+{"color_trc", "color transfer characteristics", OFFSET(color_trc), AV_OPT_TYPE_INT, {.i64 = AVCOL_TRC_UNSPECIFIED }, 1, INT_MAX, V|E|D, "color_trc_type"},
 {"bt709",        "BT.709",           0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT709 },        INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"unspecified",  "Unspecified",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_UNSPECIFIED },  INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"unknown",      "Unspecified",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_UNSPECIFIED },  INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 {"gamma22",      "BT.470 M",         0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA22 },      INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 {"gamma28",      "BT.470 BG",        0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_GAMMA28 },      INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 {"smpte170m",    "SMPTE 170 M",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE170M },    INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 {"smpte240m",    "SMPTE 240 M",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE240M },    INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 {"linear",       "Linear",           0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LINEAR },       INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"log100",       "Log",              0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG },          INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"log316",       "Log square root",  0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG_SQRT },     INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"iec61966-2-4", "IEC 61966-2-4",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_4 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"bt1361e",      "BT.1361",          0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT1361_ECG },   INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"iec61966-2-1", "IEC 61966-2-1",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_1 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"bt2020-10",    "BT.2020 - 10 bit", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_10 },    INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"bt2020-12",    "BT.2020 - 12 bit", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_12 },    INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"smpte2084",    "SMPTE 2084",       0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE2084 },    INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"smpte428",     "SMPTE 428-1",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE428 },     INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"arib-std-b67", "ARIB STD-B67",     0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_ARIB_STD_B67 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"unspecified",  "Unspecified",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_UNSPECIFIED },  INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 {"log",          "Log",              0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG },          INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 {"log_sqrt",     "Log square root",  0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_LOG_SQRT },     INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 {"iec61966_2_4", "IEC 61966-2-4",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_4 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
@@ -477,33 +495,39 @@ static const AVOption avcodec_options[] = {
 {"iec61966_2_1", "IEC 61966-2-1",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_IEC61966_2_1 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 {"bt2020_10bit", "BT.2020 - 10 bit", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_10 },    INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
 {"bt2020_12bit", "BT.2020 - 12 bit", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_BT2020_12 },    INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"smpte2084",    "SMPTE ST 2084",    0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST2084 },  INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"smpte428_1",   "SMPTE ST 428-1",   0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTEST428_1 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"arib-std-b67", "ARIB STD-B67",     0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_ARIB_STD_B67 }, INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
-{"colorspace", "color space", OFFSET(colorspace), AV_OPT_TYPE_INT, {.i64 = AVCOL_SPC_UNSPECIFIED }, 0, AVCOL_SPC_NB-1, V|E|D, "colorspace_type"},
+{"smpte428_1",   "SMPTE 428-1",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_TRC_SMPTE428 },     INT_MIN, INT_MAX, V|E|D, "color_trc_type"},
+{"colorspace", "color space", OFFSET(colorspace), AV_OPT_TYPE_INT, {.i64 = AVCOL_SPC_UNSPECIFIED }, 0, INT_MAX, V|E|D, "colorspace_type"},
 {"rgb",         "RGB",         0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_RGB },         INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
 {"bt709",       "BT.709",      0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_BT709 },       INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
-{"unspecified", "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
+{"unknown",     "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
 {"fcc",         "FCC",         0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_FCC },         INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
 {"bt470bg",     "BT.470 BG",   0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_BT470BG },     INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
 {"smpte170m",   "SMPTE 170 M", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_SMPTE170M },   INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
 {"smpte240m",   "SMPTE 240 M", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_SMPTE240M },   INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
-{"ycocg",       "YCOCG",       0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_YCOCG },       INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
+{"ycgco",       "YCGCO",       0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_YCGCO },       INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
+{"bt2020nc",    "BT.2020 NCL", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_BT2020_NCL },  INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
+{"bt2020c",     "BT.2020 CL",  0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_BT2020_CL },   INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
+{"smpte2085",   "SMPTE 2085",  0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_SMPTE2085 },   INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
+{"unspecified", "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
+{"ycocg",       "YCGCO",       0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_YCGCO },       INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
 {"bt2020_ncl",  "BT.2020 NCL", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_BT2020_NCL },  INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
 {"bt2020_cl",   "BT.2020 CL",  0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_BT2020_CL },   INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
-{"smpte2085",   "SMPTE 2085",  0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_SPC_SMPTE2085 },   INT_MIN, INT_MAX, V|E|D, "colorspace_type"},
-{"color_range", "color range", OFFSET(color_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, AVCOL_RANGE_NB-1, V|E|D, "color_range_type"},
+{"color_range", "color range", OFFSET(color_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, INT_MAX, V|E|D, "color_range_type"},
+{"unknown", "Unspecified",     0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "color_range_type"},
+{"tv", "MPEG (219*2^(n-8))",   0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG },        INT_MIN, INT_MAX, V|E|D, "color_range_type"},
+{"pc", "JPEG (2^n-1)",         0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG },        INT_MIN, INT_MAX, V|E|D, "color_range_type"},
 {"unspecified", "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "color_range_type"},
 {"mpeg", "MPEG (219*2^(n-8))", 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG },        INT_MIN, INT_MAX, V|E|D, "color_range_type"},
 {"jpeg", "JPEG (2^n-1)",       0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG },        INT_MIN, INT_MAX, V|E|D, "color_range_type"},
-{"chroma_sample_location", "chroma sample location", OFFSET(chroma_sample_location), AV_OPT_TYPE_INT, {.i64 = AVCHROMA_LOC_UNSPECIFIED }, 0, AVCHROMA_LOC_NB-1, V|E|D, "chroma_sample_location_type"},
-{"unspecified", "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
+{"chroma_sample_location", "chroma sample location", OFFSET(chroma_sample_location), AV_OPT_TYPE_INT, {.i64 = AVCHROMA_LOC_UNSPECIFIED }, 0, INT_MAX, V|E|D, "chroma_sample_location_type"},
+{"unknown",     "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
 {"left",        "Left",        0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_LEFT },        INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
 {"center",      "Center",      0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_CENTER },      INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
 {"topleft",     "Top-left",    0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_TOPLEFT },     INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
 {"top",         "Top",         0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_TOP },         INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
 {"bottomleft",  "Bottom-left", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_BOTTOMLEFT },  INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
 {"bottom",      "Bottom",      0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_BOTTOM },      INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
+{"unspecified", "Unspecified", 0, AV_OPT_TYPE_CONST, {.i64 = AVCHROMA_LOC_UNSPECIFIED }, INT_MIN, INT_MAX, V|E|D, "chroma_sample_location_type"},
 {"log_level_offset", "set the log level offset", OFFSET(log_level_offset), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX },
 {"slices", "set the number of slices, used in parallelized encoding", OFFSET(slices), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, V|E},
 {"thread_type", "select multithreading type", OFFSET(thread_type), AV_OPT_TYPE_FLAGS, {.i64 = FF_THREAD_SLICE|FF_THREAD_FRAME }, 0, INT_MAX, V|A|E|D, "thread_type"},
@@ -539,6 +563,7 @@ static const AVOption avcodec_options[] = {
 #if FF_API_SIDEDATA_ONLY_PKT
 {"side_data_only_packets", NULL, OFFSET(side_data_only_packets), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, A|V|E },
 #endif
+{"apply_cropping", NULL, OFFSET(apply_cropping), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, V | D },
 {"skip_alpha", "Skip processing alpha", OFFSET(skip_alpha), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, V|D },
 {"field_order", "Field order", OFFSET(field_order), AV_OPT_TYPE_INT, {.i64 = AV_FIELD_UNKNOWN }, 0, 5, V|D|E, "field_order" },
 {"progressive", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AV_FIELD_PROGRESSIVE }, 0, 0, V|D|E, "field_order" },
@@ -550,6 +575,11 @@ static const AVOption avcodec_options[] = {
 {"codec_whitelist", "List of decoders that are allowed to be used", OFFSET(codec_whitelist), AV_OPT_TYPE_STRING, { .str = NULL },  CHAR_MIN, CHAR_MAX, A|V|S|D },
 {"pixel_format", "set pixel format", OFFSET(pix_fmt), AV_OPT_TYPE_PIXEL_FMT, {.i64=AV_PIX_FMT_NONE}, -1, INT_MAX, 0 },
 {"video_size", "set video size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str=NULL}, 0, INT_MAX, 0 },
+{"max_pixels", "Maximum number of pixels", OFFSET(max_pixels), AV_OPT_TYPE_INT64, {.i64 = INT_MAX }, 0, INT_MAX, A|V|S|D|E },
+{"hwaccel_flags", NULL, OFFSET(hwaccel_flags), AV_OPT_TYPE_FLAGS, {.i64 = AV_HWACCEL_FLAG_IGNORE_LEVEL }, 0, UINT_MAX, V|D, "hwaccel_flags"},
+{"ignore_level", "ignore level even if the codec level used is unknown or higher than the maximum supported level reported by the hardware driver", 0, AV_OPT_TYPE_CONST, { .i64 = AV_HWACCEL_FLAG_IGNORE_LEVEL }, INT_MIN, INT_MAX, V | D, "hwaccel_flags" },
+{"allow_high_depth", "allow to output YUV pixel formats with a different chroma sampling than 4:2:0 and/or other than 8 bits per component", 0, AV_OPT_TYPE_CONST, {.i64 = AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH }, INT_MIN, INT_MAX, V | D, "hwaccel_flags"},
+{"allow_profile_mismatch", "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream", 0, AV_OPT_TYPE_CONST, {.i64 = AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH }, INT_MIN, INT_MAX, V | D, "hwaccel_flags"},
 {NULL},
 };
 
diff --git a/mythtv/external/FFmpeg/libavcodec/opus.c b/mythtv/external/FFmpeg/libavcodec/opus.c
index 08d94b6cbac..5847e88e11d 100644
--- a/mythtv/external/FFmpeg/libavcodec/opus.c
+++ b/mythtv/external/FFmpeg/libavcodec/opus.c
@@ -373,10 +373,16 @@ av_cold int ff_opus_parse_extradata(AVCodecContext *avctx,
             channel_reorder = channel_reorder_vorbis;
         } else if (map_type == 2) {
             int ambisonic_order = ff_sqrt(channels) - 1;
-            if (channels != (ambisonic_order + 1) * (ambisonic_order + 1)) {
+            if (channels != ((ambisonic_order + 1) * (ambisonic_order + 1)) &&
+                channels != ((ambisonic_order + 1) * (ambisonic_order + 1) + 2)) {
                 av_log(avctx, AV_LOG_ERROR,
                        "Channel mapping 2 is only specified for channel counts"
-                       " which can be written as (n + 1)^2 for nonnegative integer n\n");
+                       " which can be written as (n + 1)^2 or (n + 1)^2 + 2"
+                       " for nonnegative integer n\n");
+                return AVERROR_INVALIDDATA;
+            }
+            if (channels > 227) {
+                av_log(avctx, AV_LOG_ERROR, "Too many channels\n");
                 return AVERROR_INVALIDDATA;
             }
             layout = 0;
@@ -403,6 +409,7 @@ av_cold int ff_opus_parse_extradata(AVCodecContext *avctx,
         } else if (idx >= streams + stereo_streams) {
             av_log(avctx, AV_LOG_ERROR,
                    "Invalid channel map for output channel %d: %d\n", i, idx);
+            av_freep(&s->channel_maps);
             return AVERROR_INVALIDDATA;
         }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/opus.h b/mythtv/external/FFmpeg/libavcodec/opus.h
index 3a7ea9f5048..c3cbaec35d6 100644
--- a/mythtv/external/FFmpeg/libavcodec/opus.h
+++ b/mythtv/external/FFmpeg/libavcodec/opus.h
@@ -32,7 +32,7 @@
 #include "libswresample/swresample.h"
 
 #include "avcodec.h"
-#include "get_bits.h"
+#include "opus_rc.h"
 
 #define MAX_FRAME_SIZE               1275
 #define MAX_FRAMES                   48
@@ -43,23 +43,12 @@
 #define CELT_MAX_LOG_BLOCKS          3
 #define CELT_MAX_FRAME_SIZE          (CELT_SHORT_BLOCKSIZE * (1 << CELT_MAX_LOG_BLOCKS))
 #define CELT_MAX_BANDS               21
-#define CELT_VECTORS                 11
-#define CELT_ALLOC_STEPS             6
-#define CELT_FINE_OFFSET             21
-#define CELT_MAX_FINE_BITS           8
-#define CELT_NORM_SCALE              16384
-#define CELT_QTHETA_OFFSET           4
-#define CELT_QTHETA_OFFSET_TWOPHASE  16
-#define CELT_DEEMPH_COEFF            0.85000610f
-#define CELT_POSTFILTER_MINPERIOD    15
-#define CELT_ENERGY_SILENCE          (-28.0f)
 
 #define SILK_HISTORY                 322
 #define SILK_MAX_LPC                 16
 
 #define ROUND_MULL(a,b,s) (((MUL64(a, b) >> ((s) - 1)) + 1) >> 1)
 #define ROUND_MUL16(a,b)  ((MUL16(a, b) + 16384) >> 15)
-#define opus_ilog(i) (av_log2(i) + !!(i))
 
 #define OPUS_TS_HEADER     0x7FE0        // 0x3ff (11 bits)
 #define OPUS_TS_MASK       0xFFE0        // top 11 bits
@@ -73,7 +62,9 @@ static const uint8_t opus_default_extradata[30] = {
 enum OpusMode {
     OPUS_MODE_SILK,
     OPUS_MODE_HYBRID,
-    OPUS_MODE_CELT
+    OPUS_MODE_CELT,
+
+    OPUS_MODE_NB
 };
 
 enum OpusBandwidth {
@@ -81,27 +72,14 @@ enum OpusBandwidth {
     OPUS_BANDWIDTH_MEDIUMBAND,
     OPUS_BANDWIDTH_WIDEBAND,
     OPUS_BANDWIDTH_SUPERWIDEBAND,
-    OPUS_BANDWIDTH_FULLBAND
-};
+    OPUS_BANDWIDTH_FULLBAND,
 
-typedef struct RawBitsContext {
-    const uint8_t *position;
-    unsigned int bytes;
-    unsigned int cachelen;
-    unsigned int cacheval;
-} RawBitsContext;
-
-typedef struct OpusRangeCoder {
-    GetBitContext gb;
-    RawBitsContext rb;
-    unsigned int range;
-    unsigned int value;
-    unsigned int total_read_bits;
-} OpusRangeCoder;
+    OPUS_BANDWITH_NB
+};
 
 typedef struct SilkContext SilkContext;
 
-typedef struct CeltContext CeltContext;
+typedef struct CeltFrame CeltFrame;
 
 typedef struct OpusPacket {
     int packet_size;                /**< packet size */
@@ -126,7 +104,7 @@ typedef struct OpusStreamContext {
     OpusRangeCoder rc;
     OpusRangeCoder redundancy_rc;
     SilkContext *silk;
-    CeltContext *celt;
+    CeltFrame *celt;
     AVFloatDSPContext *fdsp;
 
     float silk_buf[2][960];
@@ -193,210 +171,6 @@ typedef struct OpusContext {
     ChannelMap *channel_maps;
 } OpusContext;
 
-static av_always_inline void opus_rc_normalize(OpusRangeCoder *rc)
-{
-    while (rc->range <= 1<<23) {
-        rc->value = ((rc->value << 8) | (get_bits(&rc->gb, 8) ^ 0xFF)) & ((1u << 31) - 1);
-        rc->range          <<= 8;
-        rc->total_read_bits += 8;
-    }
-}
-
-static av_always_inline void opus_rc_update(OpusRangeCoder *rc, unsigned int scale,
-                                          unsigned int low, unsigned int high,
-                                          unsigned int total)
-{
-    rc->value -= scale * (total - high);
-    rc->range  = low ? scale * (high - low)
-                      : rc->range - scale * (total - high);
-    opus_rc_normalize(rc);
-}
-
-static av_always_inline unsigned int opus_rc_getsymbol(OpusRangeCoder *rc, const uint16_t *cdf)
-{
-    unsigned int k, scale, total, symbol, low, high;
-
-    total = *cdf++;
-
-    scale   = rc->range / total;
-    symbol = rc->value / scale + 1;
-    symbol = total - FFMIN(symbol, total);
-
-    for (k = 0; cdf[k] <= symbol; k++);
-    high = cdf[k];
-    low  = k ? cdf[k-1] : 0;
-
-    opus_rc_update(rc, scale, low, high, total);
-
-    return k;
-}
-
-static av_always_inline unsigned int opus_rc_p2model(OpusRangeCoder *rc, unsigned int bits)
-{
-    unsigned int k, scale;
-    scale = rc->range >> bits; // in this case, scale = symbol
-
-    if (rc->value >= scale) {
-        rc->value -= scale;
-        rc->range -= scale;
-        k = 0;
-    } else {
-        rc->range = scale;
-        k = 1;
-    }
-    opus_rc_normalize(rc);
-    return k;
-}
-
-/**
- * CELT: estimate bits of entropy that have thus far been consumed for the
- *       current CELT frame, to integer and fractional (1/8th bit) precision
- */
-static av_always_inline unsigned int opus_rc_tell(const OpusRangeCoder *rc)
-{
-    return rc->total_read_bits - av_log2(rc->range) - 1;
-}
-
-static av_always_inline unsigned int opus_rc_tell_frac(const OpusRangeCoder *rc)
-{
-    unsigned int i, total_bits, rcbuffer, range;
-
-    total_bits = rc->total_read_bits << 3;
-    rcbuffer   = av_log2(rc->range) + 1;
-    range      = rc->range >> (rcbuffer-16);
-
-    for (i = 0; i < 3; i++) {
-        int bit;
-        range = range * range >> 15;
-        bit = range >> 16;
-        rcbuffer = rcbuffer << 1 | bit;
-        range >>= bit;
-    }
-
-    return total_bits - rcbuffer;
-}
-
-/**
- * CELT: read 1-25 raw bits at the end of the frame, backwards byte-wise
- */
-static av_always_inline unsigned int opus_getrawbits(OpusRangeCoder *rc, unsigned int count)
-{
-    unsigned int value = 0;
-
-    while (rc->rb.bytes && rc->rb.cachelen < count) {
-        rc->rb.cacheval |= *--rc->rb.position << rc->rb.cachelen;
-        rc->rb.cachelen += 8;
-        rc->rb.bytes--;
-    }
-
-    value = av_mod_uintp2(rc->rb.cacheval, count);
-    rc->rb.cacheval    >>= count;
-    rc->rb.cachelen     -= count;
-    rc->total_read_bits += count;
-
-    return value;
-}
-
-/**
- * CELT: read a uniform distribution
- */
-static av_always_inline unsigned int opus_rc_unimodel(OpusRangeCoder *rc, unsigned int size)
-{
-    unsigned int bits, k, scale, total;
-
-    bits  = opus_ilog(size - 1);
-    total = (bits > 8) ? ((size - 1) >> (bits - 8)) + 1 : size;
-
-    scale  = rc->range / total;
-    k      = rc->value / scale + 1;
-    k      = total - FFMIN(k, total);
-    opus_rc_update(rc, scale, k, k + 1, total);
-
-    if (bits > 8) {
-        k = k << (bits - 8) | opus_getrawbits(rc, bits - 8);
-        return FFMIN(k, size - 1);
-    } else
-        return k;
-}
-
-static av_always_inline int opus_rc_laplace(OpusRangeCoder *rc, unsigned int symbol, int decay)
-{
-    /* extends the range coder to model a Laplace distribution */
-    int value = 0;
-    unsigned int scale, low = 0, center;
-
-    scale  = rc->range >> 15;
-    center = rc->value / scale + 1;
-    center = (1 << 15) - FFMIN(center, 1 << 15);
-
-    if (center >= symbol) {
-        value++;
-        low = symbol;
-        symbol = 1 + ((32768 - 32 - symbol) * (16384-decay) >> 15);
-
-        while (symbol > 1 && center >= low + 2 * symbol) {
-            value++;
-            symbol *= 2;
-            low    += symbol;
-            symbol  = (((symbol - 2) * decay) >> 15) + 1;
-        }
-
-        if (symbol <= 1) {
-            int distance = (center - low) >> 1;
-            value += distance;
-            low   += 2 * distance;
-        }
-
-        if (center < low + symbol)
-            value *= -1;
-        else
-            low += symbol;
-    }
-
-    opus_rc_update(rc, scale, low, FFMIN(low + symbol, 32768), 32768);
-
-    return value;
-}
-
-static av_always_inline unsigned int opus_rc_stepmodel(OpusRangeCoder *rc, int k0)
-{
-    /* Use a probability of 3 up to itheta=8192 and then use 1 after */
-    unsigned int k, scale, symbol, total = (k0+1)*3 + k0;
-    scale  = rc->range / total;
-    symbol = rc->value / scale + 1;
-    symbol = total - FFMIN(symbol, total);
-
-    k = (symbol < (k0+1)*3) ? symbol/3 : symbol - (k0+1)*2;
-
-    opus_rc_update(rc, scale, (k <= k0) ? 3*(k+0) : (k-1-k0) + 3*(k0+1),
-                   (k <= k0) ? 3*(k+1) : (k-0-k0) + 3*(k0+1), total);
-    return k;
-}
-
-static av_always_inline unsigned int opus_rc_trimodel(OpusRangeCoder *rc, int qn)
-{
-    unsigned int k, scale, symbol, total, low, center;
-
-    total = ((qn>>1) + 1) * ((qn>>1) + 1);
-    scale   = rc->range / total;
-    center = rc->value / scale + 1;
-    center = total - FFMIN(center, total);
-
-    if (center < total >> 1) {
-        k      = (ff_sqrt(8 * center + 1) - 1) >> 1;
-        low    = k * (k + 1) >> 1;
-        symbol = k + 1;
-    } else {
-        k      = (2*(qn + 1) - ff_sqrt(8*(total - center - 1) + 1)) >> 1;
-        low    = total - ((qn + 1 - k) * (qn + 2 - k) >> 1);
-        symbol = qn + 1 - k;
-    }
-
-    opus_rc_update(rc, scale, low, low + symbol, total);
-
-    return k;
-}
-
 int ff_opus_parse_packet(OpusPacket *pkt, const uint8_t *buf, int buf_size,
                          int self_delimited);
 
@@ -415,16 +189,4 @@ int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc,
                               enum OpusBandwidth bandwidth, int coded_channels,
                               int duration_ms);
 
-int ff_celt_init(AVCodecContext *avctx, CeltContext **s, int output_channels);
-
-void ff_celt_free(CeltContext **s);
-
-void ff_celt_flush(CeltContext *s);
-
-int ff_celt_decode_frame(CeltContext *s, OpusRangeCoder *rc,
-                         float **output, int coded_channels, int frame_size,
-                         int startband,  int endband);
-
-extern const float ff_celt_window2[120];
-
 #endif /* AVCODEC_OPUS_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/opus_celt.c b/mythtv/external/FFmpeg/libavcodec/opus_celt.c
index 61a9dc61d33..84d484753b3 100644
--- a/mythtv/external/FFmpeg/libavcodec/opus_celt.c
+++ b/mythtv/external/FFmpeg/libavcodec/opus_celt.c
@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2012 Andrew D'Addesio
  * Copyright (c) 2013-2014 Mozilla Corporation
+ * Copyright (c) 2016 Rostislav Pehlivanov <atomnuker@gmail.com>
  *
  * This file is part of FFmpeg.
  *
@@ -24,618 +25,125 @@
  * Opus CELT decoder
  */
 
-#include <stdint.h>
+#include "opus_celt.h"
+#include "opustab.h"
+#include "opus_pvq.h"
 
-#include "libavutil/float_dsp.h"
-#include "libavutil/libm.h"
-
-#include "imdct15.h"
-#include "opus.h"
-
-enum CeltSpread {
-    CELT_SPREAD_NONE,
-    CELT_SPREAD_LIGHT,
-    CELT_SPREAD_NORMAL,
-    CELT_SPREAD_AGGRESSIVE
-};
-
-typedef struct CeltFrame {
-    float energy[CELT_MAX_BANDS];
-    float prev_energy[2][CELT_MAX_BANDS];
-
-    uint8_t collapse_masks[CELT_MAX_BANDS];
-
-    /* buffer for mdct output + postfilter */
-    DECLARE_ALIGNED(32, float, buf)[2048];
-
-    /* postfilter parameters */
-    int pf_period_new;
-    float pf_gains_new[3];
-    int pf_period;
-    float pf_gains[3];
-    int pf_period_old;
-    float pf_gains_old[3];
-
-    float deemph_coeff;
-} CeltFrame;
-
-struct CeltContext {
-    // constant values that do not change during context lifetime
-    AVCodecContext    *avctx;
-    IMDCT15Context    *imdct[4];
-    AVFloatDSPContext  *dsp;
-    int output_channels;
-
-    // values that have inter-frame effect and must be reset on flush
-    CeltFrame frame[2];
-    uint32_t seed;
-    int flushed;
-
-    // values that only affect a single frame
-    int coded_channels;
-    int framebits;
-    int duration;
-
-    /* number of iMDCT blocks in the frame */
-    int blocks;
-    /* size of each block */
-    int blocksize;
-
-    int startband;
-    int endband;
-    int codedbands;
-
-    int anticollapse_bit;
-
-    int intensitystereo;
-    int dualstereo;
-    enum CeltSpread spread;
-
-    int remaining;
-    int remaining2;
-    int fine_bits    [CELT_MAX_BANDS];
-    int fine_priority[CELT_MAX_BANDS];
-    int pulses       [CELT_MAX_BANDS];
-    int tf_change    [CELT_MAX_BANDS];
-
-    DECLARE_ALIGNED(32, float, coeffs)[2][CELT_MAX_FRAME_SIZE];
-    DECLARE_ALIGNED(32, float, scratch)[22 * 8]; // MAX(celt_freq_range) * 1<<CELT_MAX_LOG_BLOCKS
-};
-
-static const uint16_t celt_model_tapset[] = { 4, 2, 3, 4 };
-
-static const uint16_t celt_model_spread[] = { 32, 7, 9, 30, 32 };
-
-static const uint16_t celt_model_alloc_trim[] = {
-    128,   2,   4,   9,  19,  41,  87, 109, 119, 124, 126, 128
-};
-
-static const uint16_t celt_model_energy_small[] = { 4, 2, 3, 4 };
-
-static const uint8_t celt_freq_bands[] = { /* in steps of 200Hz */
-    0,  1,  2,  3,  4,  5,  6,  7,  8, 10, 12, 14, 16, 20, 24, 28, 34, 40, 48, 60, 78, 100
-};
-
-static const uint8_t celt_freq_range[] = {
-    1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  4,  4,  4,  6,  6,  8, 12, 18, 22
-};
-
-static const uint8_t celt_log_freq_range[] = {
-    0,  0,  0,  0,  0,  0,  0,  0,  8,  8,  8,  8, 16, 16, 16, 21, 21, 24, 29, 34, 36
-};
-
-static const int8_t celt_tf_select[4][2][2][2] = {
-    { { { 0, -1 }, { 0, -1 } }, { { 0, -1 }, { 0, -1 } } },
-    { { { 0, -1 }, { 0, -2 } }, { { 1,  0 }, { 1, -1 } } },
-    { { { 0, -2 }, { 0, -3 } }, { { 2,  0 }, { 1, -1 } } },
-    { { { 0, -2 }, { 0, -3 } }, { { 3,  0 }, { 1, -1 } } }
-};
-
-static const float celt_mean_energy[] = {
-    6.437500f, 6.250000f, 5.750000f, 5.312500f, 5.062500f,
-    4.812500f, 4.500000f, 4.375000f, 4.875000f, 4.687500f,
-    4.562500f, 4.437500f, 4.875000f, 4.625000f, 4.312500f,
-    4.500000f, 4.375000f, 4.625000f, 4.750000f, 4.437500f,
-    3.750000f, 3.750000f, 3.750000f, 3.750000f, 3.750000f
-};
-
-static const float celt_alpha_coef[] = {
-    29440.0f/32768.0f,    26112.0f/32768.0f,    21248.0f/32768.0f,    16384.0f/32768.0f
-};
-
-static const float celt_beta_coef[] = { /* TODO: precompute 1 minus this if the code ends up neater */
-    30147.0f/32768.0f,    22282.0f/32768.0f,    12124.0f/32768.0f,     6554.0f/32768.0f
-};
-
-static const uint8_t celt_coarse_energy_dist[4][2][42] = {
-    {
-        {       // 120-sample inter
-             72, 127,  65, 129,  66, 128,  65, 128,  64, 128,  62, 128,  64, 128,
-             64, 128,  92,  78,  92,  79,  92,  78,  90,  79, 116,  41, 115,  40,
-            114,  40, 132,  26, 132,  26, 145,  17, 161,  12, 176,  10, 177,  11
-        }, {    // 120-sample intra
-             24, 179,  48, 138,  54, 135,  54, 132,  53, 134,  56, 133,  55, 132,
-             55, 132,  61, 114,  70,  96,  74,  88,  75,  88,  87,  74,  89,  66,
-             91,  67, 100,  59, 108,  50, 120,  40, 122,  37,  97,  43,  78,  50
-        }
-    }, {
-        {       // 240-sample inter
-             83,  78,  84,  81,  88,  75,  86,  74,  87,  71,  90,  73,  93,  74,
-             93,  74, 109,  40, 114,  36, 117,  34, 117,  34, 143,  17, 145,  18,
-            146,  19, 162,  12, 165,  10, 178,   7, 189,   6, 190,   8, 177,   9
-        }, {    // 240-sample intra
-             23, 178,  54, 115,  63, 102,  66,  98,  69,  99,  74,  89,  71,  91,
-             73,  91,  78,  89,  86,  80,  92,  66,  93,  64, 102,  59, 103,  60,
-            104,  60, 117,  52, 123,  44, 138,  35, 133,  31,  97,  38,  77,  45
-        }
-    }, {
-        {       // 480-sample inter
-             61,  90,  93,  60, 105,  42, 107,  41, 110,  45, 116,  38, 113,  38,
-            112,  38, 124,  26, 132,  27, 136,  19, 140,  20, 155,  14, 159,  16,
-            158,  18, 170,  13, 177,  10, 187,   8, 192,   6, 175,   9, 159,  10
-        }, {    // 480-sample intra
-             21, 178,  59, 110,  71,  86,  75,  85,  84,  83,  91,  66,  88,  73,
-             87,  72,  92,  75,  98,  72, 105,  58, 107,  54, 115,  52, 114,  55,
-            112,  56, 129,  51, 132,  40, 150,  33, 140,  29,  98,  35,  77,  42
-        }
-    }, {
-        {       // 960-sample inter
-             42, 121,  96,  66, 108,  43, 111,  40, 117,  44, 123,  32, 120,  36,
-            119,  33, 127,  33, 134,  34, 139,  21, 147,  23, 152,  20, 158,  25,
-            154,  26, 166,  21, 173,  16, 184,  13, 184,  10, 150,  13, 139,  15
-        }, {    // 960-sample intra
-             22, 178,  63, 114,  74,  82,  84,  83,  92,  82, 103,  62,  96,  72,
-             96,  67, 101,  73, 107,  72, 113,  55, 118,  52, 125,  52, 118,  52,
-            117,  55, 135,  49, 137,  39, 157,  32, 145,  29,  97,  33,  77,  40
-        }
-    }
-};
-
-static const uint8_t celt_static_alloc[11][21] = {  /* 1/32 bit/sample */
-    {   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0 },
-    {  90,  80,  75,  69,  63,  56,  49,  40,  34,  29,  20,  18,  10,   0,   0,   0,   0,   0,   0,   0,   0 },
-    { 110, 100,  90,  84,  78,  71,  65,  58,  51,  45,  39,  32,  26,  20,  12,   0,   0,   0,   0,   0,   0 },
-    { 118, 110, 103,  93,  86,  80,  75,  70,  65,  59,  53,  47,  40,  31,  23,  15,   4,   0,   0,   0,   0 },
-    { 126, 119, 112, 104,  95,  89,  83,  78,  72,  66,  60,  54,  47,  39,  32,  25,  17,  12,   1,   0,   0 },
-    { 134, 127, 120, 114, 103,  97,  91,  85,  78,  72,  66,  60,  54,  47,  41,  35,  29,  23,  16,  10,   1 },
-    { 144, 137, 130, 124, 113, 107, 101,  95,  88,  82,  76,  70,  64,  57,  51,  45,  39,  33,  26,  15,   1 },
-    { 152, 145, 138, 132, 123, 117, 111, 105,  98,  92,  86,  80,  74,  67,  61,  55,  49,  43,  36,  20,   1 },
-    { 162, 155, 148, 142, 133, 127, 121, 115, 108, 102,  96,  90,  84,  77,  71,  65,  59,  53,  46,  30,   1 },
-    { 172, 165, 158, 152, 143, 137, 131, 125, 118, 112, 106, 100,  94,  87,  81,  75,  69,  63,  56,  45,  20 },
-    { 200, 200, 200, 200, 200, 200, 200, 200, 198, 193, 188, 183, 178, 173, 168, 163, 158, 153, 148, 129, 104 }
-};
-
-static const uint8_t celt_static_caps[4][2][21] = {
-    {       // 120-sample
-        {224, 224, 224, 224, 224, 224, 224, 224, 160, 160,
-         160, 160, 185, 185, 185, 178, 178, 168, 134,  61,  37},
-        {224, 224, 224, 224, 224, 224, 224, 224, 240, 240,
-         240, 240, 207, 207, 207, 198, 198, 183, 144,  66,  40},
-    }, {    // 240-sample
-        {160, 160, 160, 160, 160, 160, 160, 160, 185, 185,
-         185, 185, 193, 193, 193, 183, 183, 172, 138,  64,  38},
-        {240, 240, 240, 240, 240, 240, 240, 240, 207, 207,
-         207, 207, 204, 204, 204, 193, 193, 180, 143,  66,  40},
-    }, {    // 480-sample
-        {185, 185, 185, 185, 185, 185, 185, 185, 193, 193,
-         193, 193, 193, 193, 193, 183, 183, 172, 138,  65,  39},
-        {207, 207, 207, 207, 207, 207, 207, 207, 204, 204,
-         204, 204, 201, 201, 201, 188, 188, 176, 141,  66,  40},
-    }, {    // 960-sample
-        {193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
-         193, 193, 194, 194, 194, 184, 184, 173, 139,  65,  39},
-        {204, 204, 204, 204, 204, 204, 204, 204, 201, 201,
-         201, 201, 198, 198, 198, 187, 187, 175, 140,  66,  40}
-    }
-};
-
-static const uint8_t celt_cache_bits[392] = {
-    40, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 40, 15, 23, 28,
-    31, 34, 36, 38, 39, 41, 42, 43, 44, 45, 46, 47, 47, 49, 50,
-    51, 52, 53, 54, 55, 55, 57, 58, 59, 60, 61, 62, 63, 63, 65,
-    66, 67, 68, 69, 70, 71, 71, 40, 20, 33, 41, 48, 53, 57, 61,
-    64, 66, 69, 71, 73, 75, 76, 78, 80, 82, 85, 87, 89, 91, 92,
-    94, 96, 98, 101, 103, 105, 107, 108, 110, 112, 114, 117, 119, 121, 123,
-    124, 126, 128, 40, 23, 39, 51, 60, 67, 73, 79, 83, 87, 91, 94,
-    97, 100, 102, 105, 107, 111, 115, 118, 121, 124, 126, 129, 131, 135, 139,
-    142, 145, 148, 150, 153, 155, 159, 163, 166, 169, 172, 174, 177, 179, 35,
-    28, 49, 65, 78, 89, 99, 107, 114, 120, 126, 132, 136, 141, 145, 149,
-    153, 159, 165, 171, 176, 180, 185, 189, 192, 199, 205, 211, 216, 220, 225,
-    229, 232, 239, 245, 251, 21, 33, 58, 79, 97, 112, 125, 137, 148, 157,
-    166, 174, 182, 189, 195, 201, 207, 217, 227, 235, 243, 251, 17, 35, 63,
-    86, 106, 123, 139, 152, 165, 177, 187, 197, 206, 214, 222, 230, 237, 250,
-    25, 31, 55, 75, 91, 105, 117, 128, 138, 146, 154, 161, 168, 174, 180,
-    185, 190, 200, 208, 215, 222, 229, 235, 240, 245, 255, 16, 36, 65, 89,
-    110, 128, 144, 159, 173, 185, 196, 207, 217, 226, 234, 242, 250, 11, 41,
-    74, 103, 128, 151, 172, 191, 209, 225, 241, 255, 9, 43, 79, 110, 138,
-    163, 186, 207, 227, 246, 12, 39, 71, 99, 123, 144, 164, 182, 198, 214,
-    228, 241, 253, 9, 44, 81, 113, 142, 168, 192, 214, 235, 255, 7, 49,
-    90, 127, 160, 191, 220, 247, 6, 51, 95, 134, 170, 203, 234, 7, 47,
-    87, 123, 155, 184, 212, 237, 6, 52, 97, 137, 174, 208, 240, 5, 57,
-    106, 151, 192, 231, 5, 59, 111, 158, 202, 243, 5, 55, 103, 147, 187,
-    224, 5, 60, 113, 161, 206, 248, 4, 65, 122, 175, 224, 4, 67, 127,
-    182, 234
-};
-
-static const int16_t celt_cache_index[105] = {
-    -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 41, 41, 41,
-    82, 82, 123, 164, 200, 222, 0, 0, 0, 0, 0, 0, 0, 0, 41,
-    41, 41, 41, 123, 123, 123, 164, 164, 240, 266, 283, 295, 41, 41, 41,
-    41, 41, 41, 41, 41, 123, 123, 123, 123, 240, 240, 240, 266, 266, 305,
-    318, 328, 336, 123, 123, 123, 123, 123, 123, 123, 123, 240, 240, 240, 240,
-    305, 305, 305, 318, 318, 343, 351, 358, 364, 240, 240, 240, 240, 240, 240,
-    240, 240, 305, 305, 305, 305, 343, 343, 343, 351, 351, 370, 376, 382, 387,
-};
-
-static const uint8_t celt_log2_frac[] = {
-    0, 8, 13, 16, 19, 21, 23, 24, 26, 27, 28, 29, 30, 31, 32, 32, 33, 34, 34, 35, 36, 36, 37, 37
-};
-
-static const uint8_t celt_bit_interleave[] = {
-    0, 1, 1, 1, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3
-};
-
-static const uint8_t celt_bit_deinterleave[] = {
-    0x00, 0x03, 0x0C, 0x0F, 0x30, 0x33, 0x3C, 0x3F,
-    0xC0, 0xC3, 0xCC, 0xCF, 0xF0, 0xF3, 0xFC, 0xFF
-};
-
-static const uint8_t celt_hadamard_ordery[] = {
-    1,   0,
-    3,   0,  2,  1,
-    7,   0,  4,  3,  6,  1,  5,  2,
-    15,  0,  8,  7, 12,  3, 11,  4, 14,  1,  9,  6, 13,  2, 10,  5
-};
-
-static const uint16_t celt_qn_exp2[] = {
-    16384, 17866, 19483, 21247, 23170, 25267, 27554, 30048
-};
-
-static const uint32_t celt_pvq_u[1272] = {
-    /* N = 0, K = 0...176 */
-    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    /* N = 1, K = 1...176 */
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    /* N = 2, K = 2...176 */
-    3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41,
-    43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79,
-    81, 83, 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113,
-    115, 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139, 141, 143,
-    145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171, 173,
-    175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203,
-    205, 207, 209, 211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233,
-    235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255, 257, 259, 261, 263,
-    265, 267, 269, 271, 273, 275, 277, 279, 281, 283, 285, 287, 289, 291, 293,
-    295, 297, 299, 301, 303, 305, 307, 309, 311, 313, 315, 317, 319, 321, 323,
-    325, 327, 329, 331, 333, 335, 337, 339, 341, 343, 345, 347, 349, 351,
-    /* N = 3, K = 3...176 */
-    13, 25, 41, 61, 85, 113, 145, 181, 221, 265, 313, 365, 421, 481, 545, 613,
-    685, 761, 841, 925, 1013, 1105, 1201, 1301, 1405, 1513, 1625, 1741, 1861,
-    1985, 2113, 2245, 2381, 2521, 2665, 2813, 2965, 3121, 3281, 3445, 3613, 3785,
-    3961, 4141, 4325, 4513, 4705, 4901, 5101, 5305, 5513, 5725, 5941, 6161, 6385,
-    6613, 6845, 7081, 7321, 7565, 7813, 8065, 8321, 8581, 8845, 9113, 9385, 9661,
-    9941, 10225, 10513, 10805, 11101, 11401, 11705, 12013, 12325, 12641, 12961,
-    13285, 13613, 13945, 14281, 14621, 14965, 15313, 15665, 16021, 16381, 16745,
-    17113, 17485, 17861, 18241, 18625, 19013, 19405, 19801, 20201, 20605, 21013,
-    21425, 21841, 22261, 22685, 23113, 23545, 23981, 24421, 24865, 25313, 25765,
-    26221, 26681, 27145, 27613, 28085, 28561, 29041, 29525, 30013, 30505, 31001,
-    31501, 32005, 32513, 33025, 33541, 34061, 34585, 35113, 35645, 36181, 36721,
-    37265, 37813, 38365, 38921, 39481, 40045, 40613, 41185, 41761, 42341, 42925,
-    43513, 44105, 44701, 45301, 45905, 46513, 47125, 47741, 48361, 48985, 49613,
-    50245, 50881, 51521, 52165, 52813, 53465, 54121, 54781, 55445, 56113, 56785,
-    57461, 58141, 58825, 59513, 60205, 60901, 61601,
-    /* N = 4, K = 4...176 */
-    63, 129, 231, 377, 575, 833, 1159, 1561, 2047, 2625, 3303, 4089, 4991, 6017,
-    7175, 8473, 9919, 11521, 13287, 15225, 17343, 19649, 22151, 24857, 27775,
-    30913, 34279, 37881, 41727, 45825, 50183, 54809, 59711, 64897, 70375, 76153,
-    82239, 88641, 95367, 102425, 109823, 117569, 125671, 134137, 142975, 152193,
-    161799, 171801, 182207, 193025, 204263, 215929, 228031, 240577, 253575,
-    267033, 280959, 295361, 310247, 325625, 341503, 357889, 374791, 392217,
-    410175, 428673, 447719, 467321, 487487, 508225, 529543, 551449, 573951,
-    597057, 620775, 645113, 670079, 695681, 721927, 748825, 776383, 804609,
-    833511, 863097, 893375, 924353, 956039, 988441, 1021567, 1055425, 1090023,
-    1125369, 1161471, 1198337, 1235975, 1274393, 1313599, 1353601, 1394407,
-    1436025, 1478463, 1521729, 1565831, 1610777, 1656575, 1703233, 1750759,
-    1799161, 1848447, 1898625, 1949703, 2001689, 2054591, 2108417, 2163175,
-    2218873, 2275519, 2333121, 2391687, 2451225, 2511743, 2573249, 2635751,
-    2699257, 2763775, 2829313, 2895879, 2963481, 3032127, 3101825, 3172583,
-    3244409, 3317311, 3391297, 3466375, 3542553, 3619839, 3698241, 3777767,
-    3858425, 3940223, 4023169, 4107271, 4192537, 4278975, 4366593, 4455399,
-    4545401, 4636607, 4729025, 4822663, 4917529, 5013631, 5110977, 5209575,
-    5309433, 5410559, 5512961, 5616647, 5721625, 5827903, 5935489, 6044391,
-    6154617, 6266175, 6379073, 6493319, 6608921, 6725887, 6844225, 6963943,
-    7085049, 7207551,
-    /* N = 5, K = 5...176 */
-    321, 681, 1289, 2241, 3649, 5641, 8361, 11969, 16641, 22569, 29961, 39041,
-    50049, 63241, 78889, 97281, 118721, 143529, 172041, 204609, 241601, 283401,
-    330409, 383041, 441729, 506921, 579081, 658689, 746241, 842249, 947241,
-    1061761, 1186369, 1321641, 1468169, 1626561, 1797441, 1981449, 2179241,
-    2391489, 2618881, 2862121, 3121929, 3399041, 3694209, 4008201, 4341801,
-    4695809, 5071041, 5468329, 5888521, 6332481, 6801089, 7295241, 7815849,
-    8363841, 8940161, 9545769, 10181641, 10848769, 11548161, 12280841, 13047849,
-    13850241, 14689089, 15565481, 16480521, 17435329, 18431041, 19468809,
-    20549801, 21675201, 22846209, 24064041, 25329929, 26645121, 28010881,
-    29428489, 30899241, 32424449, 34005441, 35643561, 37340169, 39096641,
-    40914369, 42794761, 44739241, 46749249, 48826241, 50971689, 53187081,
-    55473921, 57833729, 60268041, 62778409, 65366401, 68033601, 70781609,
-    73612041, 76526529, 79526721, 82614281, 85790889, 89058241, 92418049,
-    95872041, 99421961, 103069569, 106816641, 110664969, 114616361, 118672641,
-    122835649, 127107241, 131489289, 135983681, 140592321, 145317129, 150160041,
-    155123009, 160208001, 165417001, 170752009, 176215041, 181808129, 187533321,
-    193392681, 199388289, 205522241, 211796649, 218213641, 224775361, 231483969,
-    238341641, 245350569, 252512961, 259831041, 267307049, 274943241, 282741889,
-    290705281, 298835721, 307135529, 315607041, 324252609, 333074601, 342075401,
-    351257409, 360623041, 370174729, 379914921, 389846081, 399970689, 410291241,
-    420810249, 431530241, 442453761, 453583369, 464921641, 476471169, 488234561,
-    500214441, 512413449, 524834241, 537479489, 550351881, 563454121, 576788929,
-    590359041, 604167209, 618216201, 632508801,
-    /* N = 6, K = 6...96 (technically V(109,5) fits in 32 bits, but that can't be
-     achieved by splitting an Opus band) */
-    1683, 3653, 7183, 13073, 22363, 36365, 56695, 85305, 124515, 177045, 246047,
-    335137, 448427, 590557, 766727, 982729, 1244979, 1560549, 1937199, 2383409,
-    2908411, 3522221, 4235671, 5060441, 6009091, 7095093, 8332863, 9737793,
-    11326283, 13115773, 15124775, 17372905, 19880915, 22670725, 25765455,
-    29189457, 32968347, 37129037, 41699767, 46710137, 52191139, 58175189,
-    64696159, 71789409, 79491819, 87841821, 96879431, 106646281, 117185651,
-    128542501, 140763503, 153897073, 167993403, 183104493, 199284183, 216588185,
-    235074115, 254801525, 275831935, 298228865, 322057867, 347386557, 374284647,
-    402823977, 433078547, 465124549, 499040399, 534906769, 572806619, 612825229,
-    655050231, 699571641, 746481891, 795875861, 847850911, 902506913, 959946283,
-    1020274013, 1083597703, 1150027593, 1219676595, 1292660325, 1369097135,
-    1449108145, 1532817275, 1620351277, 1711839767, 1807415257, 1907213187,
-    2011371957, 2120032959,
-    /* N = 7, K = 7...54 (technically V(60,6) fits in 32 bits, but that can't be
-     achieved by splitting an Opus band) */
-    8989, 19825, 40081, 75517, 134245, 227305, 369305, 579125, 880685, 1303777,
-    1884961, 2668525, 3707509, 5064793, 6814249, 9041957, 11847485, 15345233,
-    19665841, 24957661, 31388293, 39146185, 48442297, 59511829, 72616013,
-    88043969, 106114625, 127178701, 151620757, 179861305, 212358985, 249612805,
-    292164445, 340600625, 395555537, 457713341, 527810725, 606639529, 695049433,
-    793950709, 904317037, 1027188385, 1163673953, 1314955181, 1482288821,
-    1667010073, 1870535785, 2094367717,
-    /* N = 8, K = 8...37 (technically V(40,7) fits in 32 bits, but that can't be
-     achieved by splitting an Opus band) */
-    48639, 108545, 224143, 433905, 795455, 1392065, 2340495, 3800305, 5984767,
-    9173505, 13726991, 20103025, 28875327, 40754369, 56610575, 77500017,
-    104692735, 139703809, 184327311, 240673265, 311207743, 398796225, 506750351,
-    638878193, 799538175, 993696769, 1226990095, 1505789553, 1837271615,
-    2229491905,
-    /* N = 9, K = 9...28 (technically V(29,8) fits in 32 bits, but that can't be
-     achieved by splitting an Opus band) */
-    265729, 598417, 1256465, 2485825, 4673345, 8405905, 14546705, 24331777,
-    39490049, 62390545, 96220561, 145198913, 214828609, 312193553, 446304145,
-    628496897, 872893441, 1196924561, 1621925137, 2173806145,
-    /* N = 10, K = 10...24 */
-    1462563, 3317445, 7059735, 14218905, 27298155, 50250765, 89129247, 152951073,
-    254831667, 413442773, 654862247, 1014889769, 1541911931, 2300409629,
-    3375210671,
-    /* N = 11, K = 11...19 (technically V(20,10) fits in 32 bits, but that can't be
-     achieved by splitting an Opus band) */
-    8097453, 18474633, 39753273, 81270333, 158819253, 298199265, 540279585,
-    948062325, 1616336765,
-    /* N = 12, K = 12...18 */
-    45046719, 103274625, 224298231, 464387817, 921406335, 1759885185,
-    3248227095,
-    /* N = 13, K = 13...16 */
-    251595969, 579168825, 1267854873, 2653649025,
-    /* N = 14, K = 14 */
-    1409933619
-};
-
-DECLARE_ALIGNED(32, static const float, celt_window)[120] = {
-    6.7286966e-05f, 0.00060551348f, 0.0016815970f, 0.0032947962f, 0.0054439943f,
-    0.0081276923f, 0.011344001f, 0.015090633f, 0.019364886f, 0.024163635f,
-    0.029483315f, 0.035319905f, 0.041668911f, 0.048525347f, 0.055883718f,
-    0.063737999f, 0.072081616f, 0.080907428f, 0.090207705f, 0.099974111f,
-    0.11019769f, 0.12086883f, 0.13197729f, 0.14351214f, 0.15546177f,
-    0.16781389f, 0.18055550f, 0.19367290f, 0.20715171f, 0.22097682f,
-    0.23513243f, 0.24960208f, 0.26436860f, 0.27941419f, 0.29472040f,
-    0.31026818f, 0.32603788f, 0.34200931f, 0.35816177f, 0.37447407f,
-    0.39092462f, 0.40749142f, 0.42415215f, 0.44088423f, 0.45766484f,
-    0.47447104f, 0.49127978f, 0.50806798f, 0.52481261f, 0.54149077f,
-    0.55807973f, 0.57455701f, 0.59090049f, 0.60708841f, 0.62309951f,
-    0.63891306f, 0.65450896f, 0.66986776f, 0.68497077f, 0.69980010f,
-    0.71433873f, 0.72857055f, 0.74248043f, 0.75605424f, 0.76927895f,
-    0.78214257f, 0.79463430f, 0.80674445f, 0.81846456f, 0.82978733f,
-    0.84070669f, 0.85121779f, 0.86131698f, 0.87100183f, 0.88027111f,
-    0.88912479f, 0.89756398f, 0.90559094f, 0.91320904f, 0.92042270f,
-    0.92723738f, 0.93365955f, 0.93969656f, 0.94535671f, 0.95064907f,
-    0.95558353f, 0.96017067f, 0.96442171f, 0.96834849f, 0.97196334f,
-    0.97527906f, 0.97830883f, 0.98106616f, 0.98356480f, 0.98581869f,
-    0.98784191f, 0.98964856f, 0.99125274f, 0.99266849f, 0.99390969f,
-    0.99499004f, 0.99592297f, 0.99672162f, 0.99739874f, 0.99796667f,
-    0.99843728f, 0.99882195f, 0.99913147f, 0.99937606f, 0.99956527f,
-    0.99970802f, 0.99981248f, 0.99988613f, 0.99993565f, 0.99996697f,
-    0.99998518f, 0.99999457f, 0.99999859f, 0.99999982f, 1.0000000f,
-};
-
-/* square of the window, used for the postfilter */
-const float ff_celt_window2[120] = {
-    4.5275357e-09f, 3.66647e-07f, 2.82777e-06f, 1.08557e-05f, 2.96371e-05f, 6.60594e-05f,
-    0.000128686f, 0.000227727f, 0.000374999f, 0.000583881f, 0.000869266f, 0.0012475f,
-    0.0017363f, 0.00235471f, 0.00312299f, 0.00406253f, 0.00519576f, 0.00654601f,
-    0.00813743f, 0.00999482f, 0.0121435f, 0.0146093f, 0.017418f, 0.0205957f, 0.0241684f,
-    0.0281615f, 0.0326003f, 0.0375092f, 0.0429118f, 0.0488308f, 0.0552873f, 0.0623012f,
-    0.0698908f, 0.0780723f, 0.0868601f, 0.0962664f, 0.106301f, 0.11697f, 0.12828f,
-    0.140231f, 0.152822f, 0.166049f, 0.179905f, 0.194379f, 0.209457f, 0.225123f, 0.241356f,
-    0.258133f, 0.275428f, 0.293212f, 0.311453f, 0.330116f, 0.349163f, 0.368556f, 0.388253f,
-    0.40821f, 0.428382f, 0.448723f, 0.469185f, 0.48972f, 0.51028f, 0.530815f, 0.551277f,
-    0.571618f, 0.59179f, 0.611747f, 0.631444f, 0.650837f, 0.669884f, 0.688547f, 0.706788f,
-    0.724572f, 0.741867f, 0.758644f, 0.774877f, 0.790543f, 0.805621f, 0.820095f, 0.833951f,
-    0.847178f, 0.859769f, 0.87172f, 0.88303f, 0.893699f, 0.903734f, 0.91314f, 0.921928f,
-    0.930109f, 0.937699f, 0.944713f, 0.951169f, 0.957088f, 0.962491f, 0.9674f, 0.971838f,
-    0.975832f, 0.979404f, 0.982582f, 0.985391f, 0.987857f, 0.990005f, 0.991863f, 0.993454f,
-    0.994804f, 0.995937f, 0.996877f, 0.997645f, 0.998264f, 0.998753f, 0.999131f, 0.999416f,
-    0.999625f, 0.999772f, 0.999871f, 0.999934f, 0.99997f, 0.999989f, 0.999997f, 0.99999964f, 1.0f,
-};
-
-static const uint32_t * const celt_pvq_u_row[15] = {
-    celt_pvq_u +    0, celt_pvq_u +  176, celt_pvq_u +  351,
-    celt_pvq_u +  525, celt_pvq_u +  698, celt_pvq_u +  870,
-    celt_pvq_u + 1041, celt_pvq_u + 1131, celt_pvq_u + 1178,
-    celt_pvq_u + 1207, celt_pvq_u + 1226, celt_pvq_u + 1240,
-    celt_pvq_u + 1248, celt_pvq_u + 1254, celt_pvq_u + 1257
-};
-
-static inline int16_t celt_cos(int16_t x)
-{
-    x = (MUL16(x, x) + 4096) >> 13;
-    x = (32767-x) + ROUND_MUL16(x, (-7651 + ROUND_MUL16(x, (8277 + ROUND_MUL16(-626, x)))));
-    return 1+x;
-}
-
-static inline int celt_log2tan(int isin, int icos)
-{
-    int lc, ls;
-    lc = opus_ilog(icos);
-    ls = opus_ilog(isin);
-    icos <<= 15 - lc;
-    isin <<= 15 - ls;
-    return (ls << 11) - (lc << 11) +
-           ROUND_MUL16(isin, ROUND_MUL16(isin, -2597) + 7932) -
-           ROUND_MUL16(icos, ROUND_MUL16(icos, -2597) + 7932);
-}
-
-static inline uint32_t celt_rng(CeltContext *s)
-{
-    s->seed = 1664525 * s->seed + 1013904223;
-    return s->seed;
-}
-
-static void celt_decode_coarse_energy(CeltContext *s, OpusRangeCoder *rc)
+/* Use the 2D z-transform to apply prediction in both the time domain (alpha)
+ * and the frequency domain (beta) */
+static void celt_decode_coarse_energy(CeltFrame *f, OpusRangeCoder *rc)
 {
     int i, j;
-    float prev[2] = {0};
-    float alpha, beta;
-    const uint8_t *model;
-
-    /* use the 2D z-transform to apply prediction in both */
-    /* the time domain (alpha) and the frequency domain (beta) */
-
-    if (opus_rc_tell(rc)+3 <= s->framebits && opus_rc_p2model(rc, 3)) {
-        /* intra frame */
-        alpha = 0;
-        beta  = 1.0f - 4915.0f/32768.0f;
-        model = celt_coarse_energy_dist[s->duration][1];
-    } else {
-        alpha = celt_alpha_coef[s->duration];
-        beta  = 1.0f - celt_beta_coef[s->duration];
-        model = celt_coarse_energy_dist[s->duration][0];
+    float prev[2] = { 0 };
+    float alpha = ff_celt_alpha_coef[f->size];
+    float beta  = ff_celt_beta_coef[f->size];
+    const uint8_t *model = ff_celt_coarse_energy_dist[f->size][0];
+
+    /* intra frame */
+    if (opus_rc_tell(rc) + 3 <= f->framebits && ff_opus_rc_dec_log(rc, 3)) {
+        alpha = 0.0f;
+        beta  = 1.0f - (4915.0f/32768.0f);
+        model = ff_celt_coarse_energy_dist[f->size][1];
     }
 
     for (i = 0; i < CELT_MAX_BANDS; i++) {
-        for (j = 0; j < s->coded_channels; j++) {
-            CeltFrame *frame = &s->frame[j];
+        for (j = 0; j < f->channels; j++) {
+            CeltBlock *block = &f->block[j];
             float value;
             int available;
 
-            if (i < s->startband || i >= s->endband) {
-                frame->energy[i] = 0.0;
+            if (i < f->start_band || i >= f->end_band) {
+                block->energy[i] = 0.0;
                 continue;
             }
 
-            available = s->framebits - opus_rc_tell(rc);
+            available = f->framebits - opus_rc_tell(rc);
             if (available >= 15) {
                 /* decode using a Laplace distribution */
                 int k = FFMIN(i, 20) << 1;
-                value = opus_rc_laplace(rc, model[k] << 7, model[k+1] << 6);
+                value = ff_opus_rc_dec_laplace(rc, model[k] << 7, model[k+1] << 6);
             } else if (available >= 2) {
-                int x = opus_rc_getsymbol(rc, celt_model_energy_small);
+                int x = ff_opus_rc_dec_cdf(rc, ff_celt_model_energy_small);
                 value = (x>>1) ^ -(x&1);
             } else if (available >= 1) {
-                value = -(float)opus_rc_p2model(rc, 1);
+                value = -(float)ff_opus_rc_dec_log(rc, 1);
             } else value = -1;
 
-            frame->energy[i] = FFMAX(-9.0f, frame->energy[i]) * alpha + prev[j] + value;
+            block->energy[i] = FFMAX(-9.0f, block->energy[i]) * alpha + prev[j] + value;
             prev[j] += beta * value;
         }
     }
 }
 
-static void celt_decode_fine_energy(CeltContext *s, OpusRangeCoder *rc)
+static void celt_decode_fine_energy(CeltFrame *f, OpusRangeCoder *rc)
 {
     int i;
-    for (i = s->startband; i < s->endband; i++) {
+    for (i = f->start_band; i < f->end_band; i++) {
         int j;
-        if (!s->fine_bits[i])
+        if (!f->fine_bits[i])
             continue;
 
-        for (j = 0; j < s->coded_channels; j++) {
-            CeltFrame *frame = &s->frame[j];
+        for (j = 0; j < f->channels; j++) {
+            CeltBlock *block = &f->block[j];
             int q2;
             float offset;
-            q2 = opus_getrawbits(rc, s->fine_bits[i]);
-            offset = (q2 + 0.5f) * (1 << (14 - s->fine_bits[i])) / 16384.0f - 0.5f;
-            frame->energy[i] += offset;
+            q2 = ff_opus_rc_get_raw(rc, f->fine_bits[i]);
+            offset = (q2 + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f - 0.5f;
+            block->energy[i] += offset;
         }
     }
 }
 
-static void celt_decode_final_energy(CeltContext *s, OpusRangeCoder *rc,
-                                     int bits_left)
+static void celt_decode_final_energy(CeltFrame *f, OpusRangeCoder *rc)
 {
     int priority, i, j;
+    int bits_left = f->framebits - opus_rc_tell(rc);
 
     for (priority = 0; priority < 2; priority++) {
-        for (i = s->startband; i < s->endband && bits_left >= s->coded_channels; i++) {
-            if (s->fine_priority[i] != priority || s->fine_bits[i] >= CELT_MAX_FINE_BITS)
+        for (i = f->start_band; i < f->end_band && bits_left >= f->channels; i++) {
+            if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
                 continue;
 
-            for (j = 0; j < s->coded_channels; j++) {
+            for (j = 0; j < f->channels; j++) {
                 int q2;
                 float offset;
-                q2 = opus_getrawbits(rc, 1);
-                offset = (q2 - 0.5f) * (1 << (14 - s->fine_bits[i] - 1)) / 16384.0f;
-                s->frame[j].energy[i] += offset;
+                q2 = ff_opus_rc_get_raw(rc, 1);
+                offset = (q2 - 0.5f) * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
+                f->block[j].energy[i] += offset;
                 bits_left--;
             }
         }
     }
 }
 
-static void celt_decode_tf_changes(CeltContext *s, OpusRangeCoder *rc,
-                                   int transient)
+static void celt_decode_tf_changes(CeltFrame *f, OpusRangeCoder *rc)
 {
     int i, diff = 0, tf_select = 0, tf_changed = 0, tf_select_bit;
-    int consumed, bits = transient ? 2 : 4;
+    int consumed, bits = f->transient ? 2 : 4;
 
     consumed = opus_rc_tell(rc);
-    tf_select_bit = (s->duration != 0 && consumed+bits+1 <= s->framebits);
+    tf_select_bit = (f->size != 0 && consumed+bits+1 <= f->framebits);
 
-    for (i = s->startband; i < s->endband; i++) {
-        if (consumed+bits+tf_select_bit <= s->framebits) {
-            diff ^= opus_rc_p2model(rc, bits);
+    for (i = f->start_band; i < f->end_band; i++) {
+        if (consumed+bits+tf_select_bit <= f->framebits) {
+            diff ^= ff_opus_rc_dec_log(rc, bits);
             consumed = opus_rc_tell(rc);
             tf_changed |= diff;
         }
-        s->tf_change[i] = diff;
-        bits = transient ? 4 : 5;
+        f->tf_change[i] = diff;
+        bits = f->transient ? 4 : 5;
     }
 
-    if (tf_select_bit && celt_tf_select[s->duration][transient][0][tf_changed] !=
-                         celt_tf_select[s->duration][transient][1][tf_changed])
-        tf_select = opus_rc_p2model(rc, 1);
+    if (tf_select_bit && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=
+                         ff_celt_tf_select[f->size][f->transient][1][tf_changed])
+        tf_select = ff_opus_rc_dec_log(rc, 1);
 
-    for (i = s->startband; i < s->endband; i++) {
-        s->tf_change[i] = celt_tf_select[s->duration][transient][tf_select][s->tf_change[i]];
+    for (i = f->start_band; i < f->end_band; i++) {
+        f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];
     }
 }
 
-static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
+static void celt_decode_allocation(CeltFrame *f, OpusRangeCoder *rc)
 {
     // approx. maximum bit allocation for each band before boost/trim
     int cap[CELT_MAX_BANDS];
@@ -645,14 +153,14 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
     int bits2[CELT_MAX_BANDS];
     int trim_offset[CELT_MAX_BANDS];
 
-    int skip_startband = s->startband;
+    int skip_start_band = f->start_band;
     int dynalloc       = 6;
     int alloctrim      = 5;
     int extrabits      = 0;
 
-    int skip_bit            = 0;
-    int intensitystereo_bit = 0;
-    int dualstereo_bit      = 0;
+    int skip_bit             = 0;
+    int intensity_stereo_bit = 0;
+    int dual_stereo_bit      = 0;
 
     int remaining, bandbits;
     int low, high, total, done;
@@ -663,29 +171,29 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
     consumed = opus_rc_tell(rc);
 
     /* obtain spread flag */
-    s->spread = CELT_SPREAD_NORMAL;
-    if (consumed + 4 <= s->framebits)
-        s->spread = opus_rc_getsymbol(rc, celt_model_spread);
+    f->spread = CELT_SPREAD_NORMAL;
+    if (consumed + 4 <= f->framebits)
+        f->spread = ff_opus_rc_dec_cdf(rc, ff_celt_model_spread);
 
     /* generate static allocation caps */
     for (i = 0; i < CELT_MAX_BANDS; i++) {
-        cap[i] = (celt_static_caps[s->duration][s->coded_channels - 1][i] + 64)
-                 * celt_freq_range[i] << (s->coded_channels - 1) << s->duration >> 2;
+        cap[i] = (ff_celt_static_caps[f->size][f->channels - 1][i] + 64)
+                 * ff_celt_freq_range[i] << (f->channels - 1) << f->size >> 2;
     }
 
     /* obtain band boost */
-    totalbits = s->framebits << 3; // convert to 1/8 bits
+    totalbits = f->framebits << 3; // convert to 1/8 bits
     consumed = opus_rc_tell_frac(rc);
-    for (i = s->startband; i < s->endband; i++) {
+    for (i = f->start_band; i < f->end_band; i++) {
         int quanta, band_dynalloc;
 
         boost[i] = 0;
 
-        quanta = celt_freq_range[i] << (s->coded_channels - 1) << s->duration;
+        quanta = ff_celt_freq_range[i] << (f->channels - 1) << f->size;
         quanta = FFMIN(quanta << 3, FFMAX(6 << 3, quanta));
         band_dynalloc = dynalloc;
         while (consumed + (band_dynalloc<<3) < totalbits && boost[i] < cap[i]) {
-            int add = opus_rc_p2model(rc, band_dynalloc);
+            int add = ff_opus_rc_dec_log(rc, band_dynalloc);
             consumed = opus_rc_tell_frac(rc);
             if (!add)
                 break;
@@ -701,15 +209,15 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
 
     /* obtain allocation trim */
     if (consumed + (6 << 3) <= totalbits)
-        alloctrim = opus_rc_getsymbol(rc, celt_model_alloc_trim);
+        alloctrim = ff_opus_rc_dec_cdf(rc, ff_celt_model_alloc_trim);
 
     /* anti-collapse bit reservation */
-    totalbits = (s->framebits << 3) - opus_rc_tell_frac(rc) - 1;
-    s->anticollapse_bit = 0;
-    if (s->blocks > 1 && s->duration >= 2 &&
-        totalbits >= ((s->duration + 2) << 3))
-        s->anticollapse_bit = 1 << 3;
-    totalbits -= s->anticollapse_bit;
+    totalbits = (f->framebits << 3) - opus_rc_tell_frac(rc) - 1;
+    f->anticollapse_needed = 0;
+    if (f->blocks > 1 && f->size >= 2 &&
+        totalbits >= ((f->size + 2) << 3))
+        f->anticollapse_needed = 1 << 3;
+    totalbits -= f->anticollapse_needed;
 
     /* band skip bit reservation */
     if (totalbits >= 1 << 3)
@@ -717,33 +225,33 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
     totalbits -= skip_bit;
 
     /* intensity/dual stereo bit reservation */
-    if (s->coded_channels == 2) {
-        intensitystereo_bit = celt_log2_frac[s->endband - s->startband];
-        if (intensitystereo_bit <= totalbits) {
-            totalbits -= intensitystereo_bit;
+    if (f->channels == 2) {
+        intensity_stereo_bit = ff_celt_log2_frac[f->end_band - f->start_band];
+        if (intensity_stereo_bit <= totalbits) {
+            totalbits -= intensity_stereo_bit;
             if (totalbits >= 1 << 3) {
-                dualstereo_bit = 1 << 3;
+                dual_stereo_bit = 1 << 3;
                 totalbits -= 1 << 3;
             }
         } else
-            intensitystereo_bit = 0;
+            intensity_stereo_bit = 0;
     }
 
-    for (i = s->startband; i < s->endband; i++) {
-        int trim     = alloctrim - 5 - s->duration;
-        int band     = celt_freq_range[i] * (s->endband - i - 1);
-        int duration = s->duration + 3;
-        int scale    = duration + s->coded_channels - 1;
+    for (i = f->start_band; i < f->end_band; i++) {
+        int trim     = alloctrim - 5 - f->size;
+        int band     = ff_celt_freq_range[i] * (f->end_band - i - 1);
+        int duration = f->size + 3;
+        int scale    = duration + f->channels - 1;
 
         /* PVQ minimum allocation threshold, below this value the band is
          * skipped */
-        threshold[i] = FFMAX(3 * celt_freq_range[i] << duration >> 4,
-                             s->coded_channels << 3);
+        threshold[i] = FFMAX(3 * ff_celt_freq_range[i] << duration >> 4,
+                             f->channels << 3);
 
         trim_offset[i] = trim * (band << scale) >> 6;
 
-        if (celt_freq_range[i] << s->duration == 1)
-            trim_offset[i] -= s->coded_channels << 3;
+        if (ff_celt_freq_range[i] << f->size == 1)
+            trim_offset[i] -= f->channels << 3;
     }
 
     /* bisection */
@@ -753,9 +261,9 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
         int center = (low + high) >> 1;
         done = total = 0;
 
-        for (i = s->endband - 1; i >= s->startband; i--) {
-            bandbits = celt_freq_range[i] * celt_static_alloc[center][i]
-                       << (s->coded_channels - 1) << s->duration >> 2;
+        for (i = f->end_band - 1; i >= f->start_band; i--) {
+            bandbits = ff_celt_freq_range[i] * ff_celt_static_alloc[center][i]
+                       << (f->channels - 1) << f->size >> 2;
 
             if (bandbits)
                 bandbits = FFMAX(0, bandbits + trim_offset[i]);
@@ -764,8 +272,8 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
             if (bandbits >= threshold[i] || done) {
                 done = 1;
                 total += FFMIN(bandbits, cap[i]);
-            } else if (bandbits >= s->coded_channels << 3)
-                total += s->coded_channels << 3;
+            } else if (bandbits >= f->channels << 3)
+                total += f->channels << 3;
         }
 
         if (total > totalbits)
@@ -775,12 +283,12 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
     }
     high = low--;
 
-    for (i = s->startband; i < s->endband; i++) {
-        bits1[i] = celt_freq_range[i] * celt_static_alloc[low][i]
-                   << (s->coded_channels - 1) << s->duration >> 2;
+    for (i = f->start_band; i < f->end_band; i++) {
+        bits1[i] = ff_celt_freq_range[i] * ff_celt_static_alloc[low][i]
+                   << (f->channels - 1) << f->size >> 2;
         bits2[i] = high >= CELT_VECTORS ? cap[i] :
-                   celt_freq_range[i] * celt_static_alloc[high][i]
-                   << (s->coded_channels - 1) << s->duration >> 2;
+                   ff_celt_freq_range[i] * ff_celt_static_alloc[high][i]
+                   << (f->channels - 1) << f->size >> 2;
 
         if (bits1[i])
             bits1[i] = FFMAX(0, bits1[i] + trim_offset[i]);
@@ -791,7 +299,7 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
         bits2[i] += boost[i];
 
         if (boost[i])
-            skip_startband = i;
+            skip_start_band = i;
         bits2[i] = FFMAX(0, bits2[i] - bits1[i]);
     }
 
@@ -802,14 +310,14 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
         int center = (low + high) >> 1;
         done = total = 0;
 
-        for (j = s->endband - 1; j >= s->startband; j--) {
+        for (j = f->end_band - 1; j >= f->start_band; j--) {
             bandbits = bits1[j] + (center * bits2[j] >> CELT_ALLOC_STEPS);
 
             if (bandbits >= threshold[j] || done) {
                 done = 1;
                 total += FFMIN(bandbits, cap[j]);
-            } else if (bandbits >= s->coded_channels << 3)
-                total += s->coded_channels << 3;
+            } else if (bandbits >= f->channels << 3)
+                total += f->channels << 3;
         }
         if (total > totalbits)
             high = center;
@@ -818,26 +326,26 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
     }
 
     done = total = 0;
-    for (i = s->endband - 1; i >= s->startband; i--) {
+    for (i = f->end_band - 1; i >= f->start_band; i--) {
         bandbits = bits1[i] + (low * bits2[i] >> CELT_ALLOC_STEPS);
 
         if (bandbits >= threshold[i] || done)
             done = 1;
         else
-            bandbits = (bandbits >= s->coded_channels << 3) ?
-                       s->coded_channels << 3 : 0;
+            bandbits = (bandbits >= f->channels << 3) ?
+                       f->channels << 3 : 0;
 
         bandbits     = FFMIN(bandbits, cap[i]);
-        s->pulses[i] = bandbits;
+        f->pulses[i] = bandbits;
         total      += bandbits;
     }
 
     /* band skipping */
-    for (s->codedbands = s->endband; ; s->codedbands--) {
+    for (f->coded_bands = f->end_band; ; f->coded_bands--) {
         int allocation;
-        j = s->codedbands - 1;
+        j = f->coded_bands - 1;
 
-        if (j == skip_startband) {
+        if (j == skip_start_band) {
             /* all remaining bands are not skipped */
             totalbits += skip_bit;
             break;
@@ -845,15 +353,15 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
 
         /* determine the number of bits available for coding "do not skip" markers */
         remaining   = totalbits - total;
-        bandbits    = remaining / (celt_freq_bands[j+1] - celt_freq_bands[s->startband]);
-        remaining  -= bandbits  * (celt_freq_bands[j+1] - celt_freq_bands[s->startband]);
-        allocation  = s->pulses[j] + bandbits * celt_freq_range[j]
-                      + FFMAX(0, remaining - (celt_freq_bands[j] - celt_freq_bands[s->startband]));
+        bandbits    = remaining / (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
+        remaining  -= bandbits  * (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
+        allocation  = f->pulses[j] + bandbits * ff_celt_freq_range[j]
+                      + FFMAX(0, remaining - (ff_celt_freq_bands[j] - ff_celt_freq_bands[f->start_band]));
 
         /* a "do not skip" marker is only coded if the allocation is
            above the chosen threshold */
-        if (allocation >= FFMAX(threshold[j], (s->coded_channels + 1) <<3 )) {
-            if (opus_rc_p2model(rc, 1))
+        if (allocation >= FFMAX(threshold[j], (f->channels + 1) <<3 )) {
+            if (ff_opus_rc_dec_log(rc, 1))
                 break;
 
             total      += 1 << 3;
@@ -861,43 +369,43 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
         }
 
         /* the band is skipped, so reclaim its bits */
-        total -= s->pulses[j];
-        if (intensitystereo_bit) {
-            total -= intensitystereo_bit;
-            intensitystereo_bit = celt_log2_frac[j - s->startband];
-            total += intensitystereo_bit;
+        total -= f->pulses[j];
+        if (intensity_stereo_bit) {
+            total -= intensity_stereo_bit;
+            intensity_stereo_bit = ff_celt_log2_frac[j - f->start_band];
+            total += intensity_stereo_bit;
         }
 
-        total += s->pulses[j] = (allocation >= s->coded_channels << 3) ?
-                              s->coded_channels << 3 : 0;
+        total += f->pulses[j] = (allocation >= f->channels << 3) ?
+                              f->channels << 3 : 0;
     }
 
     /* obtain stereo flags */
-    s->intensitystereo = 0;
-    s->dualstereo      = 0;
-    if (intensitystereo_bit)
-        s->intensitystereo = s->startband +
-                          opus_rc_unimodel(rc, s->codedbands + 1 - s->startband);
-    if (s->intensitystereo <= s->startband)
-        totalbits += dualstereo_bit; /* no intensity stereo means no dual stereo */
-    else if (dualstereo_bit)
-        s->dualstereo = opus_rc_p2model(rc, 1);
+    f->intensity_stereo = 0;
+    f->dual_stereo      = 0;
+    if (intensity_stereo_bit)
+        f->intensity_stereo = f->start_band +
+                          ff_opus_rc_dec_uint(rc, f->coded_bands + 1 - f->start_band);
+    if (f->intensity_stereo <= f->start_band)
+        totalbits += dual_stereo_bit; /* no intensity stereo means no dual stereo */
+    else if (dual_stereo_bit)
+        f->dual_stereo = ff_opus_rc_dec_log(rc, 1);
 
     /* supply the remaining bits in this frame to lower bands */
     remaining = totalbits - total;
-    bandbits  = remaining / (celt_freq_bands[s->codedbands] - celt_freq_bands[s->startband]);
-    remaining -= bandbits * (celt_freq_bands[s->codedbands] - celt_freq_bands[s->startband]);
-    for (i = s->startband; i < s->codedbands; i++) {
-        int bits = FFMIN(remaining, celt_freq_range[i]);
+    bandbits  = remaining / (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
+    remaining -= bandbits * (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
+    for (i = f->start_band; i < f->coded_bands; i++) {
+        int bits = FFMIN(remaining, ff_celt_freq_range[i]);
 
-        s->pulses[i] += bits + bandbits * celt_freq_range[i];
+        f->pulses[i] += bits + bandbits * ff_celt_freq_range[i];
         remaining    -= bits;
     }
 
-    for (i = s->startband; i < s->codedbands; i++) {
-        int N = celt_freq_range[i] << s->duration;
+    for (i = f->start_band; i < f->coded_bands; i++) {
+        int N = ff_celt_freq_range[i] << f->size;
         int prev_extra = extrabits;
-        s->pulses[i] += extrabits;
+        f->pulses[i] += extrabits;
 
         if (N > 1) {
             int dof;        // degrees of freedom
@@ -907,788 +415,83 @@ static void celt_decode_allocation(CeltContext *s, OpusRangeCoder *rc)
                             // totalbits/dof
             int fine_bits, max_bits;
 
-            extrabits = FFMAX(0, s->pulses[i] - cap[i]);
-            s->pulses[i] -= extrabits;
+            extrabits = FFMAX(0, f->pulses[i] - cap[i]);
+            f->pulses[i] -= extrabits;
 
             /* intensity stereo makes use of an extra degree of freedom */
-            dof = N * s->coded_channels
-                  + (s->coded_channels == 2 && N > 2 && !s->dualstereo && i < s->intensitystereo);
-            temp = dof * (celt_log_freq_range[i] + (s->duration<<3));
+            dof = N * f->channels
+                  + (f->channels == 2 && N > 2 && !f->dual_stereo && i < f->intensity_stereo);
+            temp = dof * (ff_celt_log_freq_range[i] + (f->size<<3));
             offset = (temp >> 1) - dof * CELT_FINE_OFFSET;
             if (N == 2) /* dof=2 is the only case that doesn't fit the model */
                 offset += dof<<1;
 
             /* grant an additional bias for the first and second pulses */
-            if (s->pulses[i] + offset < 2 * (dof << 3))
+            if (f->pulses[i] + offset < 2 * (dof << 3))
                 offset += temp >> 2;
-            else if (s->pulses[i] + offset < 3 * (dof << 3))
+            else if (f->pulses[i] + offset < 3 * (dof << 3))
                 offset += temp >> 3;
 
-            fine_bits = (s->pulses[i] + offset + (dof << 2)) / (dof << 3);
-            max_bits  = FFMIN((s->pulses[i]>>3) >> (s->coded_channels - 1),
+            fine_bits = (f->pulses[i] + offset + (dof << 2)) / (dof << 3);
+            max_bits  = FFMIN((f->pulses[i]>>3) >> (f->channels - 1),
                               CELT_MAX_FINE_BITS);
 
             max_bits  = FFMAX(max_bits, 0);
 
-            s->fine_bits[i] = av_clip(fine_bits, 0, max_bits);
+            f->fine_bits[i] = av_clip(fine_bits, 0, max_bits);
 
             /* if fine_bits was rounded down or capped,
                give priority for the final fine energy pass */
-            s->fine_priority[i] = (s->fine_bits[i] * (dof<<3) >= s->pulses[i] + offset);
+            f->fine_priority[i] = (f->fine_bits[i] * (dof<<3) >= f->pulses[i] + offset);
 
             /* the remaining bits are assigned to PVQ */
-            s->pulses[i] -= s->fine_bits[i] << (s->coded_channels - 1) << 3;
+            f->pulses[i] -= f->fine_bits[i] << (f->channels - 1) << 3;
         } else {
             /* all bits go to fine energy except for the sign bit */
-            extrabits = FFMAX(0, s->pulses[i] - (s->coded_channels << 3));
-            s->pulses[i] -= extrabits;
-            s->fine_bits[i] = 0;
-            s->fine_priority[i] = 1;
+            extrabits = FFMAX(0, f->pulses[i] - (f->channels << 3));
+            f->pulses[i] -= extrabits;
+            f->fine_bits[i] = 0;
+            f->fine_priority[i] = 1;
         }
 
         /* hand back a limited number of extra fine energy bits to this band */
         if (extrabits > 0) {
-            int fineextra = FFMIN(extrabits >> (s->coded_channels + 2),
-                                  CELT_MAX_FINE_BITS - s->fine_bits[i]);
-            s->fine_bits[i] += fineextra;
+            int fineextra = FFMIN(extrabits >> (f->channels + 2),
+                                  CELT_MAX_FINE_BITS - f->fine_bits[i]);
+            f->fine_bits[i] += fineextra;
 
-            fineextra <<= s->coded_channels + 2;
-            s->fine_priority[i] = (fineextra >= extrabits - prev_extra);
+            fineextra <<= f->channels + 2;
+            f->fine_priority[i] = (fineextra >= extrabits - prev_extra);
             extrabits -= fineextra;
         }
     }
-    s->remaining = extrabits;
+    f->remaining = extrabits;
 
     /* skipped bands dedicate all of their bits for fine energy */
-    for (; i < s->endband; i++) {
-        s->fine_bits[i]     = s->pulses[i] >> (s->coded_channels - 1) >> 3;
-        s->pulses[i]        = 0;
-        s->fine_priority[i] = s->fine_bits[i] < 1;
-    }
-}
-
-static inline int celt_bits2pulses(const uint8_t *cache, int bits)
-{
-    // TODO: Find the size of cache and make it into an array in the parameters list
-    int i, low = 0, high;
-
-    high = cache[0];
-    bits--;
-
-    for (i = 0; i < 6; i++) {
-        int center = (low + high + 1) >> 1;
-        if (cache[center] >= bits)
-            high = center;
-        else
-            low = center;
-    }
-
-    return (bits - (low == 0 ? -1 : cache[low]) <= cache[high] - bits) ? low : high;
-}
-
-static inline int celt_pulses2bits(const uint8_t *cache, int pulses)
-{
-    // TODO: Find the size of cache and make it into an array in the parameters list
-   return (pulses == 0) ? 0 : cache[pulses] + 1;
-}
-
-static inline void celt_normalize_residual(const int * av_restrict iy, float * av_restrict X,
-                                           int N, float g)
-{
-    int i;
-    for (i = 0; i < N; i++)
-        X[i] = g * iy[i];
-}
-
-static void celt_exp_rotation1(float *X, unsigned int len, unsigned int stride,
-                               float c, float s)
-{
-    float *Xptr;
-    int i;
-
-    Xptr = X;
-    for (i = 0; i < len - stride; i++) {
-        float x1, x2;
-        x1           = Xptr[0];
-        x2           = Xptr[stride];
-        Xptr[stride] = c * x2 + s * x1;
-        *Xptr++      = c * x1 - s * x2;
-    }
-
-    Xptr = &X[len - 2 * stride - 1];
-    for (i = len - 2 * stride - 1; i >= 0; i--) {
-        float x1, x2;
-        x1           = Xptr[0];
-        x2           = Xptr[stride];
-        Xptr[stride] = c * x2 + s * x1;
-        *Xptr--      = c * x1 - s * x2;
-    }
-}
-
-static inline void celt_exp_rotation(float *X, unsigned int len,
-                                     unsigned int stride, unsigned int K,
-                                     enum CeltSpread spread)
-{
-    unsigned int stride2 = 0;
-    float c, s;
-    float gain, theta;
-    int i;
-
-    if (2*K >= len || spread == CELT_SPREAD_NONE)
-        return;
-
-    gain = (float)len / (len + (20 - 5*spread) * K);
-    theta = M_PI * gain * gain / 4;
-
-    c = cos(theta);
-    s = sin(theta);
-
-    if (len >= stride << 3) {
-        stride2 = 1;
-        /* This is just a simple (equivalent) way of computing sqrt(len/stride) with rounding.
-        It's basically incrementing long as (stride2+0.5)^2 < len/stride. */
-        while ((stride2 * stride2 + stride2) * stride + (stride >> 2) < len)
-            stride2++;
-    }
-
-    /*NOTE: As a minor optimization, we could be passing around log2(B), not B, for both this and for
-    extract_collapse_mask().*/
-    len /= stride;
-    for (i = 0; i < stride; i++) {
-        if (stride2)
-            celt_exp_rotation1(X + i * len, len, stride2, s, c);
-        celt_exp_rotation1(X + i * len, len, 1, c, s);
-    }
-}
-
-static inline unsigned int celt_extract_collapse_mask(const int *iy,
-                                                      unsigned int N,
-                                                      unsigned int B)
-{
-    unsigned int collapse_mask;
-    int N0;
-    int i, j;
-
-    if (B <= 1)
-        return 1;
-
-    /*NOTE: As a minor optimization, we could be passing around log2(B), not B, for both this and for
-    exp_rotation().*/
-    N0 = N/B;
-    collapse_mask = 0;
-    for (i = 0; i < B; i++)
-        for (j = 0; j < N0; j++)
-            collapse_mask |= (iy[i*N0+j]!=0)<<i;
-    return collapse_mask;
-}
-
-static inline void celt_renormalize_vector(float *X, int N, float gain)
-{
-    int i;
-    float g = 1e-15f;
-    for (i = 0; i < N; i++)
-        g += X[i] * X[i];
-    g = gain / sqrtf(g);
-
-    for (i = 0; i < N; i++)
-        X[i] *= g;
-}
-
-static inline void celt_stereo_merge(float *X, float *Y, float mid, int N)
-{
-    int i;
-    float xp = 0, side = 0;
-    float E[2];
-    float mid2;
-    float t, gain[2];
-
-    /* Compute the norm of X+Y and X-Y as |X|^2 + |Y|^2 +/- sum(xy) */
-    for (i = 0; i < N; i++) {
-        xp   += X[i] * Y[i];
-        side += Y[i] * Y[i];
-    }
-
-    /* Compensating for the mid normalization */
-    xp *= mid;
-    mid2 = mid;
-    E[0] = mid2 * mid2 + side - 2 * xp;
-    E[1] = mid2 * mid2 + side + 2 * xp;
-    if (E[0] < 6e-4f || E[1] < 6e-4f) {
-        for (i = 0; i < N; i++)
-            Y[i] = X[i];
-        return;
-    }
-
-    t = E[0];
-    gain[0] = 1.0f / sqrtf(t);
-    t = E[1];
-    gain[1] = 1.0f / sqrtf(t);
-
-    for (i = 0; i < N; i++) {
-        float value[2];
-        /* Apply mid scaling (side is already scaled) */
-        value[0] = mid * X[i];
-        value[1] = Y[i];
-        X[i] = gain[0] * (value[0] - value[1]);
-        Y[i] = gain[1] * (value[0] + value[1]);
-    }
-}
-
-static void celt_interleave_hadamard(float *tmp, float *X, int N0,
-                                     int stride, int hadamard)
-{
-    int i, j;
-    int N = N0*stride;
-
-    if (hadamard) {
-        const uint8_t *ordery = celt_hadamard_ordery + stride - 2;
-        for (i = 0; i < stride; i++)
-            for (j = 0; j < N0; j++)
-                tmp[j*stride+i] = X[ordery[i]*N0+j];
-    } else {
-        for (i = 0; i < stride; i++)
-            for (j = 0; j < N0; j++)
-                tmp[j*stride+i] = X[i*N0+j];
-    }
-
-    for (i = 0; i < N; i++)
-        X[i] = tmp[i];
-}
-
-static void celt_deinterleave_hadamard(float *tmp, float *X, int N0,
-                                       int stride, int hadamard)
-{
-    int i, j;
-    int N = N0*stride;
-
-    if (hadamard) {
-        const uint8_t *ordery = celt_hadamard_ordery + stride - 2;
-        for (i = 0; i < stride; i++)
-            for (j = 0; j < N0; j++)
-                tmp[ordery[i]*N0+j] = X[j*stride+i];
-    } else {
-        for (i = 0; i < stride; i++)
-            for (j = 0; j < N0; j++)
-                tmp[i*N0+j] = X[j*stride+i];
+    for (; i < f->end_band; i++) {
+        f->fine_bits[i]     = f->pulses[i] >> (f->channels - 1) >> 3;
+        f->pulses[i]        = 0;
+        f->fine_priority[i] = f->fine_bits[i] < 1;
     }
-
-    for (i = 0; i < N; i++)
-        X[i] = tmp[i];
 }
 
-static void celt_haar1(float *X, int N0, int stride)
+static void celt_denormalize(CeltFrame *f, CeltBlock *block, float *data)
 {
     int i, j;
-    N0 >>= 1;
-    for (i = 0; i < stride; i++) {
-        for (j = 0; j < N0; j++) {
-            float x0 = X[stride * (2 * j + 0) + i];
-            float x1 = X[stride * (2 * j + 1) + i];
-            X[stride * (2 * j + 0) + i] = (x0 + x1) * M_SQRT1_2;
-            X[stride * (2 * j + 1) + i] = (x0 - x1) * M_SQRT1_2;
-        }
-    }
-}
-
-static inline int celt_compute_qn(int N, int b, int offset, int pulse_cap,
-                                  int dualstereo)
-{
-    int qn, qb;
-    int N2 = 2 * N - 1;
-    if (dualstereo && N == 2)
-        N2--;
-
-    /* The upper limit ensures that in a stereo split with itheta==16384, we'll
-     * always have enough bits left over to code at least one pulse in the
-     * side; otherwise it would collapse, since it doesn't get folded. */
-    qb = FFMIN3(b - pulse_cap - (4 << 3), (b + N2 * offset) / N2, 8 << 3);
-    qn = (qb < (1 << 3 >> 1)) ? 1 : ((celt_qn_exp2[qb & 0x7] >> (14 - (qb >> 3))) + 1) >> 1 << 1;
-    return qn;
-}
-
-// this code was adapted from libopus
-static inline uint64_t celt_cwrsi(unsigned int N, unsigned int K, unsigned int i, int *y)
-{
-    uint64_t norm = 0;
-    uint32_t p;
-    int s, val;
-    int k0;
-
-    while (N > 2) {
-        uint32_t q;
-
-        /*Lots of pulses case:*/
-        if (K >= N) {
-            const uint32_t *row = celt_pvq_u_row[N];
-
-            /* Are the pulses in this dimension negative? */
-            p  = row[K + 1];
-            s  = -(i >= p);
-            i -= p & s;
-
-            /*Count how many pulses were placed in this dimension.*/
-            k0 = K;
-            q = row[N];
-            if (q > i) {
-                K = N;
-                do {
-                    p = celt_pvq_u_row[--K][N];
-                } while (p > i);
-            } else
-                for (p = row[K]; p > i; p = row[K])
-                    K--;
-
-            i    -= p;
-            val   = (k0 - K + s) ^ s;
-            norm += val * val;
-            *y++  = val;
-        } else { /*Lots of dimensions case:*/
-            /*Are there any pulses in this dimension at all?*/
-            p = celt_pvq_u_row[K    ][N];
-            q = celt_pvq_u_row[K + 1][N];
-
-            if (p <= i && i < q) {
-                i -= p;
-                *y++ = 0;
-            } else {
-                /*Are the pulses in this dimension negative?*/
-                s  = -(i >= q);
-                i -= q & s;
-
-                /*Count how many pulses were placed in this dimension.*/
-                k0 = K;
-                do p = celt_pvq_u_row[--K][N];
-                while (p > i);
-
-                i    -= p;
-                val   = (k0 - K + s) ^ s;
-                norm += val * val;
-                *y++  = val;
-            }
-        }
-        N--;
-    }
-
-    /* N == 2 */
-    p  = 2 * K + 1;
-    s  = -(i >= p);
-    i -= p & s;
-    k0 = K;
-    K  = (i + 1) / 2;
-
-    if (K)
-        i -= 2 * K - 1;
-
-    val   = (k0 - K + s) ^ s;
-    norm += val * val;
-    *y++  = val;
-
-    /* N==1 */
-    s     = -i;
-    val   = (K + s) ^ s;
-    norm += val * val;
-    *y    = val;
-
-    return norm;
-}
-
-static inline float celt_decode_pulses(OpusRangeCoder *rc, int *y, unsigned int N, unsigned int K)
-{
-    unsigned int idx;
-#define CELT_PVQ_U(n, k) (celt_pvq_u_row[FFMIN(n, k)][FFMAX(n, k)])
-#define CELT_PVQ_V(n, k) (CELT_PVQ_U(n, k) + CELT_PVQ_U(n, (k) + 1))
-    idx = opus_rc_unimodel(rc, CELT_PVQ_V(N, K));
-    return celt_cwrsi(N, K, idx, y);
-}
-
-/** Decode pulse vector and combine the result with the pitch vector to produce
-    the final normalised signal in the current band. */
-static inline unsigned int celt_alg_unquant(OpusRangeCoder *rc, float *X,
-                                            unsigned int N, unsigned int K,
-                                            enum CeltSpread spread,
-                                            unsigned int blocks, float gain)
-{
-    int y[176];
 
-    gain /= sqrtf(celt_decode_pulses(rc, y, N, K));
-    celt_normalize_residual(y, X, N, gain);
-    celt_exp_rotation(X, N, blocks, K, spread);
-    return celt_extract_collapse_mask(y, N, blocks);
-}
+    for (i = f->start_band; i < f->end_band; i++) {
+        float *dst = data + (ff_celt_freq_bands[i] << f->size);
+        float norm = exp2f(block->energy[i] + ff_celt_mean_energy[i]);
 
-static unsigned int celt_decode_band(CeltContext *s, OpusRangeCoder *rc,
-                                     const int band, float *X, float *Y,
-                                     int N, int b, unsigned int blocks,
-                                     float *lowband, int duration,
-                                     float *lowband_out, int level,
-                                     float gain, float *lowband_scratch,
-                                     int fill)
-{
-    const uint8_t *cache;
-    int dualstereo, split;
-    int imid = 0, iside = 0;
-    unsigned int N0 = N;
-    int N_B;
-    int N_B0;
-    int B0 = blocks;
-    int time_divide = 0;
-    int recombine = 0;
-    int inv = 0;
-    float mid = 0, side = 0;
-    int longblocks = (B0 == 1);
-    unsigned int cm = 0;
-
-    N_B0 = N_B = N / blocks;
-    split = dualstereo = (Y != NULL);
-
-    if (N == 1) {
-        /* special case for one sample */
-        int i;
-        float *x = X;
-        for (i = 0; i <= dualstereo; i++) {
-            int sign = 0;
-            if (s->remaining2 >= 1<<3) {
-                sign           = opus_getrawbits(rc, 1);
-                s->remaining2 -= 1 << 3;
-                b             -= 1 << 3;
-            }
-            x[0] = sign ? -1.0f : 1.0f;
-            x = Y;
-        }
-        if (lowband_out)
-            lowband_out[0] = X[0];
-        return 1;
-    }
-
-    if (!dualstereo && level == 0) {
-        int tf_change = s->tf_change[band];
-        int k;
-        if (tf_change > 0)
-            recombine = tf_change;
-        /* Band recombining to increase frequency resolution */
-
-        if (lowband &&
-            (recombine || ((N_B & 1) == 0 && tf_change < 0) || B0 > 1)) {
-            int j;
-            for (j = 0; j < N; j++)
-                lowband_scratch[j] = lowband[j];
-            lowband = lowband_scratch;
-        }
-
-        for (k = 0; k < recombine; k++) {
-            if (lowband)
-                celt_haar1(lowband, N >> k, 1 << k);
-            fill = celt_bit_interleave[fill & 0xF] | celt_bit_interleave[fill >> 4] << 2;
-        }
-        blocks >>= recombine;
-        N_B <<= recombine;
-
-        /* Increasing the time resolution */
-        while ((N_B & 1) == 0 && tf_change < 0) {
-            if (lowband)
-                celt_haar1(lowband, N_B, blocks);
-            fill |= fill << blocks;
-            blocks <<= 1;
-            N_B >>= 1;
-            time_divide++;
-            tf_change++;
-        }
-        B0 = blocks;
-        N_B0 = N_B;
-
-        /* Reorganize the samples in time order instead of frequency order */
-        if (B0 > 1 && lowband)
-            celt_deinterleave_hadamard(s->scratch, lowband, N_B >> recombine,
-                                       B0 << recombine, longblocks);
-    }
-
-    /* If we need 1.5 more bit than we can produce, split the band in two. */
-    cache = celt_cache_bits +
-            celt_cache_index[(duration + 1) * CELT_MAX_BANDS + band];
-    if (!dualstereo && duration >= 0 && b > cache[cache[0]] + 12 && N > 2) {
-        N >>= 1;
-        Y = X + N;
-        split = 1;
-        duration -= 1;
-        if (blocks == 1)
-            fill = (fill & 1) | (fill << 1);
-        blocks = (blocks + 1) >> 1;
-    }
-
-    if (split) {
-        int qn;
-        int itheta = 0;
-        int mbits, sbits, delta;
-        int qalloc;
-        int pulse_cap;
-        int offset;
-        int orig_fill;
-        int tell;
-
-        /* Decide on the resolution to give to the split parameter theta */
-        pulse_cap = celt_log_freq_range[band] + duration * 8;
-        offset = (pulse_cap >> 1) - (dualstereo && N == 2 ? CELT_QTHETA_OFFSET_TWOPHASE :
-                                                          CELT_QTHETA_OFFSET);
-        qn = (dualstereo && band >= s->intensitystereo) ? 1 :
-             celt_compute_qn(N, b, offset, pulse_cap, dualstereo);
-        tell = opus_rc_tell_frac(rc);
-        if (qn != 1) {
-            /* Entropy coding of the angle. We use a uniform pdf for the
-            time split, a step for stereo, and a triangular one for the rest. */
-            if (dualstereo && N > 2)
-                itheta = opus_rc_stepmodel(rc, qn/2);
-            else if (dualstereo || B0 > 1)
-                itheta = opus_rc_unimodel(rc, qn+1);
-            else
-                itheta = opus_rc_trimodel(rc, qn);
-            itheta = itheta * 16384 / qn;
-            /* NOTE: Renormalising X and Y *may* help fixed-point a bit at very high rate.
-            Let's do that at higher complexity */
-        } else if (dualstereo) {
-            inv = (b > 2 << 3 && s->remaining2 > 2 << 3) ? opus_rc_p2model(rc, 2) : 0;
-            itheta = 0;
-        }
-        qalloc = opus_rc_tell_frac(rc) - tell;
-        b -= qalloc;
-
-        orig_fill = fill;
-        if (itheta == 0) {
-            imid = 32767;
-            iside = 0;
-            fill = av_mod_uintp2(fill, blocks);
-            delta = -16384;
-        } else if (itheta == 16384) {
-            imid = 0;
-            iside = 32767;
-            fill &= ((1 << blocks) - 1) << blocks;
-            delta = 16384;
-        } else {
-            imid = celt_cos(itheta);
-            iside = celt_cos(16384-itheta);
-            /* This is the mid vs side allocation that minimizes squared error
-            in that band. */
-            delta = ROUND_MUL16((N - 1) << 7, celt_log2tan(iside, imid));
-        }
-
-        mid  = imid  / 32768.0f;
-        side = iside / 32768.0f;
-
-        /* This is a special case for N=2 that only works for stereo and takes
-        advantage of the fact that mid and side are orthogonal to encode
-        the side with just one bit. */
-        if (N == 2 && dualstereo) {
-            int c;
-            int sign = 0;
-            float tmp;
-            float *x2, *y2;
-            mbits = b;
-            /* Only need one bit for the side */
-            sbits = (itheta != 0 && itheta != 16384) ? 1 << 3 : 0;
-            mbits -= sbits;
-            c = (itheta > 8192);
-            s->remaining2 -= qalloc+sbits;
-
-            x2 = c ? Y : X;
-            y2 = c ? X : Y;
-            if (sbits)
-                sign = opus_getrawbits(rc, 1);
-            sign = 1 - 2 * sign;
-            /* We use orig_fill here because we want to fold the side, but if
-            itheta==16384, we'll have cleared the low bits of fill. */
-            cm = celt_decode_band(s, rc, band, x2, NULL, N, mbits, blocks,
-                                  lowband, duration, lowband_out, level, gain,
-                                  lowband_scratch, orig_fill);
-            /* We don't split N=2 bands, so cm is either 1 or 0 (for a fold-collapse),
-            and there's no need to worry about mixing with the other channel. */
-            y2[0] = -sign * x2[1];
-            y2[1] =  sign * x2[0];
-            X[0] *= mid;
-            X[1] *= mid;
-            Y[0] *= side;
-            Y[1] *= side;
-            tmp = X[0];
-            X[0] = tmp - Y[0];
-            Y[0] = tmp + Y[0];
-            tmp = X[1];
-            X[1] = tmp - Y[1];
-            Y[1] = tmp + Y[1];
-        } else {
-            /* "Normal" split code */
-            float *next_lowband2     = NULL;
-            float *next_lowband_out1 = NULL;
-            int next_level = 0;
-            int rebalance;
-
-            /* Give more bits to low-energy MDCTs than they would
-             * otherwise deserve */
-            if (B0 > 1 && !dualstereo && (itheta & 0x3fff)) {
-                if (itheta > 8192)
-                    /* Rough approximation for pre-echo masking */
-                    delta -= delta >> (4 - duration);
-                else
-                    /* Corresponds to a forward-masking slope of
-                     * 1.5 dB per 10 ms */
-                    delta = FFMIN(0, delta + (N << 3 >> (5 - duration)));
-            }
-            mbits = av_clip((b - delta) / 2, 0, b);
-            sbits = b - mbits;
-            s->remaining2 -= qalloc;
-
-            if (lowband && !dualstereo)
-                next_lowband2 = lowband + N; /* >32-bit split case */
-
-            /* Only stereo needs to pass on lowband_out.
-             * Otherwise, it's handled at the end */
-            if (dualstereo)
-                next_lowband_out1 = lowband_out;
-            else
-                next_level = level + 1;
-
-            rebalance = s->remaining2;
-            if (mbits >= sbits) {
-                /* In stereo mode, we do not apply a scaling to the mid
-                 * because we need the normalized mid for folding later */
-                cm = celt_decode_band(s, rc, band, X, NULL, N, mbits, blocks,
-                                      lowband, duration, next_lowband_out1,
-                                      next_level, dualstereo ? 1.0f : (gain * mid),
-                                      lowband_scratch, fill);
-
-                rebalance = mbits - (rebalance - s->remaining2);
-                if (rebalance > 3 << 3 && itheta != 0)
-                    sbits += rebalance - (3 << 3);
-
-                /* For a stereo split, the high bits of fill are always zero,
-                 * so no folding will be done to the side. */
-                cm |= celt_decode_band(s, rc, band, Y, NULL, N, sbits, blocks,
-                                       next_lowband2, duration, NULL,
-                                       next_level, gain * side, NULL,
-                                       fill >> blocks) << ((B0 >> 1) & (dualstereo - 1));
-            } else {
-                /* For a stereo split, the high bits of fill are always zero,
-                 * so no folding will be done to the side. */
-                cm = celt_decode_band(s, rc, band, Y, NULL, N, sbits, blocks,
-                                      next_lowband2, duration, NULL,
-                                      next_level, gain * side, NULL,
-                                      fill >> blocks) << ((B0 >> 1) & (dualstereo - 1));
-
-                rebalance = sbits - (rebalance - s->remaining2);
-                if (rebalance > 3 << 3 && itheta != 16384)
-                    mbits += rebalance - (3 << 3);
-
-                /* In stereo mode, we do not apply a scaling to the mid because
-                 * we need the normalized mid for folding later */
-                cm |= celt_decode_band(s, rc, band, X, NULL, N, mbits, blocks,
-                                       lowband, duration, next_lowband_out1,
-                                       next_level, dualstereo ? 1.0f : (gain * mid),
-                                       lowband_scratch, fill);
-            }
-        }
-    } else {
-        /* This is the basic no-split case */
-        unsigned int q         = celt_bits2pulses(cache, b);
-        unsigned int curr_bits = celt_pulses2bits(cache, q);
-        s->remaining2 -= curr_bits;
-
-        /* Ensures we can never bust the budget */
-        while (s->remaining2 < 0 && q > 0) {
-            s->remaining2 += curr_bits;
-            curr_bits      = celt_pulses2bits(cache, --q);
-            s->remaining2 -= curr_bits;
-        }
-
-        if (q != 0) {
-            /* Finally do the actual quantization */
-            cm = celt_alg_unquant(rc, X, N, (q < 8) ? q : (8 + (q & 7)) << ((q >> 3) - 1),
-                                  s->spread, blocks, gain);
-        } else {
-            /* If there's no pulse, fill the band anyway */
-            int j;
-            unsigned int cm_mask = (1 << blocks) - 1;
-            fill &= cm_mask;
-            if (!fill) {
-                for (j = 0; j < N; j++)
-                    X[j] = 0.0f;
-            } else {
-                if (!lowband) {
-                    /* Noise */
-                    for (j = 0; j < N; j++)
-                        X[j] = (((int32_t)celt_rng(s)) >> 20);
-                    cm = cm_mask;
-                } else {
-                    /* Folded spectrum */
-                    for (j = 0; j < N; j++) {
-                        /* About 48 dB below the "normal" folding level */
-                        X[j] = lowband[j] + (((celt_rng(s)) & 0x8000) ? 1.0f / 256 : -1.0f / 256);
-                    }
-                    cm = fill;
-                }
-                celt_renormalize_vector(X, N, gain);
-            }
-        }
-    }
-
-    /* This code is used by the decoder and by the resynthesis-enabled encoder */
-    if (dualstereo) {
-        int j;
-        if (N != 2)
-            celt_stereo_merge(X, Y, mid, N);
-        if (inv) {
-            for (j = 0; j < N; j++)
-                Y[j] *= -1;
-        }
-    } else if (level == 0) {
-        int k;
-
-        /* Undo the sample reorganization going from time order to frequency order */
-        if (B0 > 1)
-            celt_interleave_hadamard(s->scratch, X, N_B>>recombine,
-                                     B0<<recombine, longblocks);
-
-        /* Undo time-freq changes that we did earlier */
-        N_B = N_B0;
-        blocks = B0;
-        for (k = 0; k < time_divide; k++) {
-            blocks >>= 1;
-            N_B <<= 1;
-            cm |= cm >> blocks;
-            celt_haar1(X, N_B, blocks);
-        }
-
-        for (k = 0; k < recombine; k++) {
-            cm = celt_bit_deinterleave[cm];
-            celt_haar1(X, N0>>k, 1<<k);
-        }
-        blocks <<= recombine;
-
-        /* Scale output for later folding */
-        if (lowband_out) {
-            int j;
-            float n = sqrtf(N0);
-            for (j = 0; j < N0; j++)
-                lowband_out[j] = n * X[j];
-        }
-        cm = av_mod_uintp2(cm, blocks);
-    }
-    return cm;
-}
-
-static void celt_denormalize(CeltContext *s, CeltFrame *frame, float *data)
-{
-    int i, j;
-
-    for (i = s->startband; i < s->endband; i++) {
-        float *dst = data + (celt_freq_bands[i] << s->duration);
-        float norm = exp2(frame->energy[i] + celt_mean_energy[i]);
-
-        for (j = 0; j < celt_freq_range[i] << s->duration; j++)
+        for (j = 0; j < ff_celt_freq_range[i] << f->size; j++)
             dst[j] *= norm;
     }
 }
 
-static void celt_postfilter_apply_transition(CeltFrame *frame, float *data)
+static void celt_postfilter_apply_transition(CeltBlock *block, float *data)
 {
-    const int T0 = frame->pf_period_old;
-    const int T1 = frame->pf_period;
+    const int T0 = block->pf_period_old;
+    const int T1 = block->pf_period;
 
     float g00, g01, g02;
     float g10, g11, g12;
@@ -1697,16 +500,16 @@ static void celt_postfilter_apply_transition(CeltFrame *frame, float *data)
 
     int i;
 
-    if (frame->pf_gains[0]     == 0.0 &&
-        frame->pf_gains_old[0] == 0.0)
+    if (block->pf_gains[0]     == 0.0 &&
+        block->pf_gains_old[0] == 0.0)
         return;
 
-    g00 = frame->pf_gains_old[0];
-    g01 = frame->pf_gains_old[1];
-    g02 = frame->pf_gains_old[2];
-    g10 = frame->pf_gains[0];
-    g11 = frame->pf_gains[1];
-    g12 = frame->pf_gains[2];
+    g00 = block->pf_gains_old[0];
+    g01 = block->pf_gains_old[1];
+    g02 = block->pf_gains_old[2];
+    g10 = block->pf_gains[0];
+    g11 = block->pf_gains[1];
+    g12 = block->pf_gains[2];
 
     x1 = data[-T1 + 1];
     x2 = data[-T1];
@@ -1730,20 +533,19 @@ static void celt_postfilter_apply_transition(CeltFrame *frame, float *data)
     }
 }
 
-static void celt_postfilter_apply(CeltFrame *frame,
-                                  float *data, int len)
+static void celt_postfilter_apply(CeltBlock *block, float *data, int len)
 {
-    const int T = frame->pf_period;
+    const int T = block->pf_period;
     float g0, g1, g2;
     float x0, x1, x2, x3, x4;
     int i;
 
-    if (frame->pf_gains[0] == 0.0 || len <= 0)
+    if (block->pf_gains[0] == 0.0 || len <= 0)
         return;
 
-    g0 = frame->pf_gains[0];
-    g1 = frame->pf_gains[1];
-    g2 = frame->pf_gains[2];
+    g0 = block->pf_gains[0];
+    g1 = block->pf_gains[1];
+    g2 = block->pf_gains[2];
 
     x4 = data[-T - 2];
     x3 = data[-T - 1];
@@ -1762,61 +564,56 @@ static void celt_postfilter_apply(CeltFrame *frame,
     }
 }
 
-static void celt_postfilter(CeltContext *s, CeltFrame *frame)
+static void celt_postfilter(CeltFrame *f, CeltBlock *block)
 {
-    int len = s->blocksize * s->blocks;
+    int len = f->blocksize * f->blocks;
 
-    celt_postfilter_apply_transition(frame, frame->buf + 1024);
+    celt_postfilter_apply_transition(block, block->buf + 1024);
 
-    frame->pf_period_old = frame->pf_period;
-    memcpy(frame->pf_gains_old, frame->pf_gains, sizeof(frame->pf_gains));
+    block->pf_period_old = block->pf_period;
+    memcpy(block->pf_gains_old, block->pf_gains, sizeof(block->pf_gains));
 
-    frame->pf_period = frame->pf_period_new;
-    memcpy(frame->pf_gains, frame->pf_gains_new, sizeof(frame->pf_gains));
+    block->pf_period = block->pf_period_new;
+    memcpy(block->pf_gains, block->pf_gains_new, sizeof(block->pf_gains));
 
     if (len > CELT_OVERLAP) {
-        celt_postfilter_apply_transition(frame, frame->buf + 1024 + CELT_OVERLAP);
-        celt_postfilter_apply(frame, frame->buf + 1024 + 2 * CELT_OVERLAP,
+        celt_postfilter_apply_transition(block, block->buf + 1024 + CELT_OVERLAP);
+        celt_postfilter_apply(block, block->buf + 1024 + 2 * CELT_OVERLAP,
                               len - 2 * CELT_OVERLAP);
 
-        frame->pf_period_old = frame->pf_period;
-        memcpy(frame->pf_gains_old, frame->pf_gains, sizeof(frame->pf_gains));
+        block->pf_period_old = block->pf_period;
+        memcpy(block->pf_gains_old, block->pf_gains, sizeof(block->pf_gains));
     }
 
-    memmove(frame->buf, frame->buf + len, (1024 + CELT_OVERLAP / 2) * sizeof(float));
+    memmove(block->buf, block->buf + len, (1024 + CELT_OVERLAP / 2) * sizeof(float));
 }
 
-static int parse_postfilter(CeltContext *s, OpusRangeCoder *rc, int consumed)
+static int parse_postfilter(CeltFrame *f, OpusRangeCoder *rc, int consumed)
 {
-    static const float postfilter_taps[3][3] = {
-        { 0.3066406250f, 0.2170410156f, 0.1296386719f },
-        { 0.4638671875f, 0.2680664062f, 0.0           },
-        { 0.7998046875f, 0.1000976562f, 0.0           }
-    };
     int i;
 
-    memset(s->frame[0].pf_gains_new, 0, sizeof(s->frame[0].pf_gains_new));
-    memset(s->frame[1].pf_gains_new, 0, sizeof(s->frame[1].pf_gains_new));
+    memset(f->block[0].pf_gains_new, 0, sizeof(f->block[0].pf_gains_new));
+    memset(f->block[1].pf_gains_new, 0, sizeof(f->block[1].pf_gains_new));
 
-    if (s->startband == 0 && consumed + 16 <= s->framebits) {
-        int has_postfilter = opus_rc_p2model(rc, 1);
+    if (f->start_band == 0 && consumed + 16 <= f->framebits) {
+        int has_postfilter = ff_opus_rc_dec_log(rc, 1);
         if (has_postfilter) {
             float gain;
             int tapset, octave, period;
 
-            octave = opus_rc_unimodel(rc, 6);
-            period = (16 << octave) + opus_getrawbits(rc, 4 + octave) - 1;
-            gain   = 0.09375f * (opus_getrawbits(rc, 3) + 1);
-            tapset = (opus_rc_tell(rc) + 2 <= s->framebits) ?
-                     opus_rc_getsymbol(rc, celt_model_tapset) : 0;
+            octave = ff_opus_rc_dec_uint(rc, 6);
+            period = (16 << octave) + ff_opus_rc_get_raw(rc, 4 + octave) - 1;
+            gain   = 0.09375f * (ff_opus_rc_get_raw(rc, 3) + 1);
+            tapset = (opus_rc_tell(rc) + 2 <= f->framebits) ?
+                     ff_opus_rc_dec_cdf(rc, ff_celt_model_tapset) : 0;
 
             for (i = 0; i < 2; i++) {
-                CeltFrame *frame = &s->frame[i];
+                CeltBlock *block = &f->block[i];
 
-                frame->pf_period_new = FFMAX(period, CELT_POSTFILTER_MINPERIOD);
-                frame->pf_gains_new[0] = gain * postfilter_taps[tapset][0];
-                frame->pf_gains_new[1] = gain * postfilter_taps[tapset][1];
-                frame->pf_gains_new[2] = gain * postfilter_taps[tapset][2];
+                block->pf_period_new = FFMAX(period, CELT_POSTFILTER_MINPERIOD);
+                block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
+                block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
+                block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
             }
         }
 
@@ -1826,11 +623,11 @@ static int parse_postfilter(CeltContext *s, OpusRangeCoder *rc, int consumed)
     return consumed;
 }
 
-static void process_anticollapse(CeltContext *s, CeltFrame *frame, float *X)
+static void process_anticollapse(CeltFrame *f, CeltBlock *block, float *X)
 {
     int i, j, k;
 
-    for (i = s->startband; i < s->endband; i++) {
+    for (i = f->start_band; i < f->end_band; i++) {
         int renormalize = 0;
         float *xptr;
         float prev[2];
@@ -1839,356 +636,357 @@ static void process_anticollapse(CeltContext *s, CeltFrame *frame, float *X)
         int depth;
 
         /* depth in 1/8 bits */
-        depth = (1 + s->pulses[i]) / (celt_freq_range[i] << s->duration);
+        depth = (1 + f->pulses[i]) / (ff_celt_freq_range[i] << f->size);
         thresh = exp2f(-1.0 - 0.125f * depth);
-        sqrt_1 = 1.0f / sqrtf(celt_freq_range[i] << s->duration);
+        sqrt_1 = 1.0f / sqrtf(ff_celt_freq_range[i] << f->size);
 
-        xptr = X + (celt_freq_bands[i] << s->duration);
+        xptr = X + (ff_celt_freq_bands[i] << f->size);
 
-        prev[0] = frame->prev_energy[0][i];
-        prev[1] = frame->prev_energy[1][i];
-        if (s->coded_channels == 1) {
-            CeltFrame *frame1 = &s->frame[1];
+        prev[0] = block->prev_energy[0][i];
+        prev[1] = block->prev_energy[1][i];
+        if (f->channels == 1) {
+            CeltBlock *block1 = &f->block[1];
 
-            prev[0] = FFMAX(prev[0], frame1->prev_energy[0][i]);
-            prev[1] = FFMAX(prev[1], frame1->prev_energy[1][i]);
+            prev[0] = FFMAX(prev[0], block1->prev_energy[0][i]);
+            prev[1] = FFMAX(prev[1], block1->prev_energy[1][i]);
         }
-        Ediff = frame->energy[i] - FFMIN(prev[0], prev[1]);
+        Ediff = block->energy[i] - FFMIN(prev[0], prev[1]);
         Ediff = FFMAX(0, Ediff);
 
         /* r needs to be multiplied by 2 or 2*sqrt(2) depending on LM because
         short blocks don't have the same energy as long */
-        r = exp2(1 - Ediff);
-        if (s->duration == 3)
+        r = exp2f(1 - Ediff);
+        if (f->size == 3)
             r *= M_SQRT2;
         r = FFMIN(thresh, r) * sqrt_1;
-        for (k = 0; k < 1 << s->duration; k++) {
+        for (k = 0; k < 1 << f->size; k++) {
             /* Detect collapse */
-            if (!(frame->collapse_masks[i] & 1 << k)) {
+            if (!(block->collapse_masks[i] & 1 << k)) {
                 /* Fill with noise */
-                for (j = 0; j < celt_freq_range[i]; j++)
-                    xptr[(j << s->duration) + k] = (celt_rng(s) & 0x8000) ? r : -r;
+                for (j = 0; j < ff_celt_freq_range[i]; j++)
+                    xptr[(j << f->size) + k] = (celt_rng(f) & 0x8000) ? r : -r;
                 renormalize = 1;
             }
         }
 
         /* We just added some energy, so we need to renormalize */
         if (renormalize)
-            celt_renormalize_vector(xptr, celt_freq_range[i] << s->duration, 1.0f);
+            celt_renormalize_vector(xptr, ff_celt_freq_range[i] << f->size, 1.0f);
     }
 }
 
-static void celt_decode_bands(CeltContext *s, OpusRangeCoder *rc)
+static void celt_decode_bands(CeltFrame *f, OpusRangeCoder *rc)
 {
     float lowband_scratch[8 * 22];
     float norm[2 * 8 * 100];
 
-    int totalbits = (s->framebits << 3) - s->anticollapse_bit;
+    int totalbits = (f->framebits << 3) - f->anticollapse_needed;
 
     int update_lowband = 1;
     int lowband_offset = 0;
 
     int i, j;
 
-    memset(s->coeffs, 0, sizeof(s->coeffs));
+    memset(f->block[0].coeffs, 0, sizeof(f->block[0].coeffs));
+    memset(f->block[1].coeffs, 0, sizeof(f->block[0].coeffs));
 
-    for (i = s->startband; i < s->endband; i++) {
-        int band_offset = celt_freq_bands[i] << s->duration;
-        int band_size   = celt_freq_range[i] << s->duration;
-        float *X = s->coeffs[0] + band_offset;
-        float *Y = (s->coded_channels == 2) ? s->coeffs[1] + band_offset : NULL;
+    for (i = f->start_band; i < f->end_band; i++) {
+        uint32_t cm[2] = { (1 << f->blocks) - 1, (1 << f->blocks) - 1 };
+        int band_offset = ff_celt_freq_bands[i] << f->size;
+        int band_size   = ff_celt_freq_range[i] << f->size;
+        float *X = f->block[0].coeffs + band_offset;
+        float *Y = (f->channels == 2) ? f->block[1].coeffs + band_offset : NULL;
 
         int consumed = opus_rc_tell_frac(rc);
         float *norm2 = norm + 8 * 100;
         int effective_lowband = -1;
-        unsigned int cm[2];
-        int b;
+        int b = 0;
 
         /* Compute how many bits we want to allocate to this band */
-        if (i != s->startband)
-            s->remaining -= consumed;
-        s->remaining2 = totalbits - consumed - 1;
-        if (i <= s->codedbands - 1) {
-            int curr_balance = s->remaining / FFMIN(3, s->codedbands-i);
-            b = av_clip_uintp2(FFMIN(s->remaining2 + 1, s->pulses[i] + curr_balance), 14);
-        } else
-            b = 0;
+        if (i != f->start_band)
+            f->remaining -= consumed;
+        f->remaining2 = totalbits - consumed - 1;
+        if (i <= f->coded_bands - 1) {
+            int curr_balance = f->remaining / FFMIN(3, f->coded_bands-i);
+            b = av_clip_uintp2(FFMIN(f->remaining2 + 1, f->pulses[i] + curr_balance), 14);
+        }
 
-        if (celt_freq_bands[i] - celt_freq_range[i] >= celt_freq_bands[s->startband] &&
+        if (ff_celt_freq_bands[i] - ff_celt_freq_range[i] >= ff_celt_freq_bands[f->start_band] &&
             (update_lowband || lowband_offset == 0))
             lowband_offset = i;
 
         /* Get a conservative estimate of the collapse_mask's for the bands we're
-        going to be folding from. */
-        if (lowband_offset != 0 && (s->spread != CELT_SPREAD_AGGRESSIVE ||
-                                    s->blocks > 1 || s->tf_change[i] < 0)) {
+           going to be folding from. */
+        if (lowband_offset != 0 && (f->spread != CELT_SPREAD_AGGRESSIVE ||
+                                    f->blocks > 1 || f->tf_change[i] < 0)) {
             int foldstart, foldend;
 
             /* This ensures we never repeat spectral content within one band */
-            effective_lowband = FFMAX(celt_freq_bands[s->startband],
-                                      celt_freq_bands[lowband_offset] - celt_freq_range[i]);
+            effective_lowband = FFMAX(ff_celt_freq_bands[f->start_band],
+                                      ff_celt_freq_bands[lowband_offset] - ff_celt_freq_range[i]);
             foldstart = lowband_offset;
-            while (celt_freq_bands[--foldstart] > effective_lowband);
+            while (ff_celt_freq_bands[--foldstart] > effective_lowband);
             foldend = lowband_offset - 1;
-            while (celt_freq_bands[++foldend] < effective_lowband + celt_freq_range[i]);
+            while (ff_celt_freq_bands[++foldend] < effective_lowband + ff_celt_freq_range[i]);
 
             cm[0] = cm[1] = 0;
             for (j = foldstart; j < foldend; j++) {
-                cm[0] |= s->frame[0].collapse_masks[j];
-                cm[1] |= s->frame[s->coded_channels - 1].collapse_masks[j];
+                cm[0] |= f->block[0].collapse_masks[j];
+                cm[1] |= f->block[f->channels - 1].collapse_masks[j];
             }
-        } else
-            /* Otherwise, we'll be using the LCG to fold, so all blocks will (almost
-            always) be non-zero.*/
-            cm[0] = cm[1] = (1 << s->blocks) - 1;
+        }
 
-        if (s->dualstereo && i == s->intensitystereo) {
+        if (f->dual_stereo && i == f->intensity_stereo) {
             /* Switch off dual stereo to do intensity */
-            s->dualstereo = 0;
-            for (j = celt_freq_bands[s->startband] << s->duration; j < band_offset; j++)
+            f->dual_stereo = 0;
+            for (j = ff_celt_freq_bands[f->start_band] << f->size; j < band_offset; j++)
                 norm[j] = (norm[j] + norm2[j]) / 2;
         }
 
-        if (s->dualstereo) {
-            cm[0] = celt_decode_band(s, rc, i, X, NULL, band_size, b / 2, s->blocks,
-                                     effective_lowband != -1 ? norm + (effective_lowband << s->duration) : NULL, s->duration,
-            norm + band_offset, 0, 1.0f, lowband_scratch, cm[0]);
+        if (f->dual_stereo) {
+            cm[0] = f->pvq->decode_band(f->pvq, f, rc, i, X, NULL, band_size, b / 2, f->blocks,
+                                        effective_lowband != -1 ? norm + (effective_lowband << f->size) : NULL, f->size,
+                                        norm + band_offset, 0, 1.0f, lowband_scratch, cm[0]);
 
-            cm[1] = celt_decode_band(s, rc, i, Y, NULL, band_size, b/2, s->blocks,
-                                     effective_lowband != -1 ? norm2 + (effective_lowband << s->duration) : NULL, s->duration,
-            norm2 + band_offset, 0, 1.0f, lowband_scratch, cm[1]);
+            cm[1] = f->pvq->decode_band(f->pvq, f, rc, i, Y, NULL, band_size, b/2, f->blocks,
+                                        effective_lowband != -1 ? norm2 + (effective_lowband << f->size) : NULL, f->size,
+                                        norm2 + band_offset, 0, 1.0f, lowband_scratch, cm[1]);
         } else {
-            cm[0] = celt_decode_band(s, rc, i, X, Y, band_size, b, s->blocks,
-            effective_lowband != -1 ? norm + (effective_lowband << s->duration) : NULL, s->duration,
-            norm + band_offset, 0, 1.0f, lowband_scratch, cm[0]|cm[1]);
-
+            cm[0] = f->pvq->decode_band(f->pvq, f, rc, i, X, Y, band_size, b, f->blocks,
+                                        effective_lowband != -1 ? norm + (effective_lowband << f->size) : NULL, f->size,
+                                        norm + band_offset, 0, 1.0f, lowband_scratch, cm[0]|cm[1]);
             cm[1] = cm[0];
         }
 
-        s->frame[0].collapse_masks[i]                     = (uint8_t)cm[0];
-        s->frame[s->coded_channels - 1].collapse_masks[i] = (uint8_t)cm[1];
-        s->remaining += s->pulses[i] + consumed;
+        f->block[0].collapse_masks[i]               = (uint8_t)cm[0];
+        f->block[f->channels - 1].collapse_masks[i] = (uint8_t)cm[1];
+        f->remaining += f->pulses[i] + consumed;
 
         /* Update the folding position only as long as we have 1 bit/sample depth */
         update_lowband = (b > band_size << 3);
     }
 }
 
-int ff_celt_decode_frame(CeltContext *s, OpusRangeCoder *rc,
-                         float **output, int coded_channels, int frame_size,
-                         int startband,  int endband)
+int ff_celt_decode_frame(CeltFrame *f, OpusRangeCoder *rc,
+                         float **output, int channels, int frame_size,
+                         int start_band,  int end_band)
 {
-    int i, j;
-
+    int i, j, downmix = 0;
     int consumed;           // bits of entropy consumed thus far for this frame
-    int silence = 0;
-    int transient = 0;
-    int anticollapse = 0;
-    IMDCT15Context *imdct;
-    float imdct_scale = 1.0;
-
-    if (coded_channels != 1 && coded_channels != 2) {
-        av_log(s->avctx, AV_LOG_ERROR, "Invalid number of coded channels: %d\n",
-               coded_channels);
+    MDCT15Context *imdct;
+
+    if (channels != 1 && channels != 2) {
+        av_log(f->avctx, AV_LOG_ERROR, "Invalid number of coded channels: %d\n",
+               channels);
         return AVERROR_INVALIDDATA;
     }
-    if (startband < 0 || startband > endband || endband > CELT_MAX_BANDS) {
-        av_log(s->avctx, AV_LOG_ERROR, "Invalid start/end band: %d %d\n",
-               startband, endband);
+    if (start_band < 0 || start_band > end_band || end_band > CELT_MAX_BANDS) {
+        av_log(f->avctx, AV_LOG_ERROR, "Invalid start/end band: %d %d\n",
+               start_band, end_band);
         return AVERROR_INVALIDDATA;
     }
 
-    s->flushed        = 0;
-    s->coded_channels = coded_channels;
-    s->startband      = startband;
-    s->endband        = endband;
-    s->framebits      = rc->rb.bytes * 8;
-
-    s->duration = av_log2(frame_size / CELT_SHORT_BLOCKSIZE);
-    if (s->duration > CELT_MAX_LOG_BLOCKS ||
-        frame_size != CELT_SHORT_BLOCKSIZE * (1 << s->duration)) {
-        av_log(s->avctx, AV_LOG_ERROR, "Invalid CELT frame size: %d\n",
+    f->silence        = 0;
+    f->transient      = 0;
+    f->anticollapse   = 0;
+    f->flushed        = 0;
+    f->channels       = channels;
+    f->start_band     = start_band;
+    f->end_band       = end_band;
+    f->framebits      = rc->rb.bytes * 8;
+
+    f->size = av_log2(frame_size / CELT_SHORT_BLOCKSIZE);
+    if (f->size > CELT_MAX_LOG_BLOCKS ||
+        frame_size != CELT_SHORT_BLOCKSIZE * (1 << f->size)) {
+        av_log(f->avctx, AV_LOG_ERROR, "Invalid CELT frame size: %d\n",
                frame_size);
         return AVERROR_INVALIDDATA;
     }
 
-    if (!s->output_channels)
-        s->output_channels = coded_channels;
+    if (!f->output_channels)
+        f->output_channels = channels;
 
-    memset(s->frame[0].collapse_masks, 0, sizeof(s->frame[0].collapse_masks));
-    memset(s->frame[1].collapse_masks, 0, sizeof(s->frame[1].collapse_masks));
+    memset(f->block[0].collapse_masks, 0, sizeof(f->block[0].collapse_masks));
+    memset(f->block[1].collapse_masks, 0, sizeof(f->block[1].collapse_masks));
 
     consumed = opus_rc_tell(rc);
 
     /* obtain silence flag */
-    if (consumed >= s->framebits)
-        silence = 1;
+    if (consumed >= f->framebits)
+        f->silence = 1;
     else if (consumed == 1)
-        silence = opus_rc_p2model(rc, 15);
+        f->silence = ff_opus_rc_dec_log(rc, 15);
 
 
-    if (silence) {
-        consumed = s->framebits;
-        rc->total_read_bits += s->framebits - opus_rc_tell(rc);
+    if (f->silence) {
+        consumed = f->framebits;
+        rc->total_bits += f->framebits - opus_rc_tell(rc);
     }
 
     /* obtain post-filter options */
-    consumed = parse_postfilter(s, rc, consumed);
+    consumed = parse_postfilter(f, rc, consumed);
 
     /* obtain transient flag */
-    if (s->duration != 0 && consumed+3 <= s->framebits)
-        transient = opus_rc_p2model(rc, 3);
+    if (f->size != 0 && consumed+3 <= f->framebits)
+        f->transient = ff_opus_rc_dec_log(rc, 3);
 
-    s->blocks    = transient ? 1 << s->duration : 1;
-    s->blocksize = frame_size / s->blocks;
+    f->blocks    = f->transient ? 1 << f->size : 1;
+    f->blocksize = frame_size / f->blocks;
 
-    imdct = s->imdct[transient ? 0 : s->duration];
+    imdct = f->imdct[f->transient ? 0 : f->size];
 
-    if (coded_channels == 1) {
+    if (channels == 1) {
         for (i = 0; i < CELT_MAX_BANDS; i++)
-            s->frame[0].energy[i] = FFMAX(s->frame[0].energy[i], s->frame[1].energy[i]);
+            f->block[0].energy[i] = FFMAX(f->block[0].energy[i], f->block[1].energy[i]);
     }
 
-    celt_decode_coarse_energy(s, rc);
-    celt_decode_tf_changes   (s, rc, transient);
-    celt_decode_allocation   (s, rc);
-    celt_decode_fine_energy  (s, rc);
-    celt_decode_bands        (s, rc);
+    celt_decode_coarse_energy(f, rc);
+    celt_decode_tf_changes   (f, rc);
+    celt_decode_allocation   (f, rc);
+    celt_decode_fine_energy  (f, rc);
+    celt_decode_bands        (f, rc);
 
-    if (s->anticollapse_bit)
-        anticollapse = opus_getrawbits(rc, 1);
+    if (f->anticollapse_needed)
+        f->anticollapse = ff_opus_rc_get_raw(rc, 1);
 
-    celt_decode_final_energy(s, rc, s->framebits - opus_rc_tell(rc));
+    celt_decode_final_energy(f, rc);
 
     /* apply anti-collapse processing and denormalization to
      * each coded channel */
-    for (i = 0; i < s->coded_channels; i++) {
-        CeltFrame *frame = &s->frame[i];
+    for (i = 0; i < f->channels; i++) {
+        CeltBlock *block = &f->block[i];
 
-        if (anticollapse)
-            process_anticollapse(s, frame, s->coeffs[i]);
+        if (f->anticollapse)
+            process_anticollapse(f, block, f->block[i].coeffs);
 
-        celt_denormalize(s, frame, s->coeffs[i]);
+        celt_denormalize(f, block, f->block[i].coeffs);
     }
 
     /* stereo -> mono downmix */
-    if (s->output_channels < s->coded_channels) {
-        s->dsp->vector_fmac_scalar(s->coeffs[0], s->coeffs[1], 1.0, FFALIGN(frame_size, 16));
-        imdct_scale = 0.5;
-    } else if (s->output_channels > s->coded_channels)
-        memcpy(s->coeffs[1], s->coeffs[0], frame_size * sizeof(float));
+    if (f->output_channels < f->channels) {
+        f->dsp->vector_fmac_scalar(f->block[0].coeffs, f->block[1].coeffs, 1.0, FFALIGN(frame_size, 16));
+        downmix = 1;
+    } else if (f->output_channels > f->channels)
+        memcpy(f->block[1].coeffs, f->block[0].coeffs, frame_size * sizeof(float));
 
-    if (silence) {
+    if (f->silence) {
         for (i = 0; i < 2; i++) {
-            CeltFrame *frame = &s->frame[i];
+            CeltBlock *block = &f->block[i];
 
-            for (j = 0; j < FF_ARRAY_ELEMS(frame->energy); j++)
-                frame->energy[j] = CELT_ENERGY_SILENCE;
+            for (j = 0; j < FF_ARRAY_ELEMS(block->energy); j++)
+                block->energy[j] = CELT_ENERGY_SILENCE;
         }
-        memset(s->coeffs, 0, sizeof(s->coeffs));
+        memset(f->block[0].coeffs, 0, sizeof(f->block[0].coeffs));
+        memset(f->block[1].coeffs, 0, sizeof(f->block[1].coeffs));
     }
 
     /* transform and output for each output channel */
-    for (i = 0; i < s->output_channels; i++) {
-        CeltFrame *frame = &s->frame[i];
-        float m = frame->deemph_coeff;
+    for (i = 0; i < f->output_channels; i++) {
+        CeltBlock *block = &f->block[i];
+        float m = block->emph_coeff;
 
         /* iMDCT and overlap-add */
-        for (j = 0; j < s->blocks; j++) {
-            float *dst  = frame->buf + 1024 + j * s->blocksize;
+        for (j = 0; j < f->blocks; j++) {
+            float *dst  = block->buf + 1024 + j * f->blocksize;
 
-            imdct->imdct_half(imdct, dst + CELT_OVERLAP / 2, s->coeffs[i] + j,
-                              s->blocks, imdct_scale);
-            s->dsp->vector_fmul_window(dst, dst, dst + CELT_OVERLAP / 2,
-                                      celt_window, CELT_OVERLAP / 2);
+            imdct->imdct_half(imdct, dst + CELT_OVERLAP / 2, f->block[i].coeffs + j,
+                              f->blocks);
+            f->dsp->vector_fmul_window(dst, dst, dst + CELT_OVERLAP / 2,
+                                       ff_celt_window, CELT_OVERLAP / 2);
         }
 
+        if (downmix)
+            f->dsp->vector_fmul_scalar(&block->buf[1024], &block->buf[1024], 0.5f, frame_size);
+
         /* postfilter */
-        celt_postfilter(s, frame);
+        celt_postfilter(f, block);
 
         /* deemphasis and output scaling */
         for (j = 0; j < frame_size; j++) {
-            float tmp = frame->buf[1024 - frame_size + j] + m;
-            m = tmp * CELT_DEEMPH_COEFF;
-            output[i][j] = tmp / 32768.;
+            const float tmp = block->buf[1024 - frame_size + j] + m;
+            m = tmp * CELT_EMPH_COEFF;
+            output[i][j] = tmp;
         }
-        frame->deemph_coeff = m;
+
+        block->emph_coeff = m;
     }
 
-    if (coded_channels == 1)
-        memcpy(s->frame[1].energy, s->frame[0].energy, sizeof(s->frame[0].energy));
+    if (channels == 1)
+        memcpy(f->block[1].energy, f->block[0].energy, sizeof(f->block[0].energy));
 
     for (i = 0; i < 2; i++ ) {
-        CeltFrame *frame = &s->frame[i];
+        CeltBlock *block = &f->block[i];
 
-        if (!transient) {
-            memcpy(frame->prev_energy[1], frame->prev_energy[0], sizeof(frame->prev_energy[0]));
-            memcpy(frame->prev_energy[0], frame->energy,         sizeof(frame->prev_energy[0]));
+        if (!f->transient) {
+            memcpy(block->prev_energy[1], block->prev_energy[0], sizeof(block->prev_energy[0]));
+            memcpy(block->prev_energy[0], block->energy,         sizeof(block->prev_energy[0]));
         } else {
             for (j = 0; j < CELT_MAX_BANDS; j++)
-                frame->prev_energy[0][j] = FFMIN(frame->prev_energy[0][j], frame->energy[j]);
+                block->prev_energy[0][j] = FFMIN(block->prev_energy[0][j], block->energy[j]);
         }
 
-        for (j = 0; j < s->startband; j++) {
-            frame->prev_energy[0][j] = CELT_ENERGY_SILENCE;
-            frame->energy[j]         = 0.0;
+        for (j = 0; j < f->start_band; j++) {
+            block->prev_energy[0][j] = CELT_ENERGY_SILENCE;
+            block->energy[j]         = 0.0;
         }
-        for (j = s->endband; j < CELT_MAX_BANDS; j++) {
-            frame->prev_energy[0][j] = CELT_ENERGY_SILENCE;
-            frame->energy[j]         = 0.0;
+        for (j = f->end_band; j < CELT_MAX_BANDS; j++) {
+            block->prev_energy[0][j] = CELT_ENERGY_SILENCE;
+            block->energy[j]         = 0.0;
         }
     }
 
-    s->seed = rc->range;
+    f->seed = rc->range;
 
     return 0;
 }
 
-void ff_celt_flush(CeltContext *s)
+void ff_celt_flush(CeltFrame *f)
 {
     int i, j;
 
-    if (s->flushed)
+    if (f->flushed)
         return;
 
     for (i = 0; i < 2; i++) {
-        CeltFrame *frame = &s->frame[i];
+        CeltBlock *block = &f->block[i];
 
         for (j = 0; j < CELT_MAX_BANDS; j++)
-            frame->prev_energy[0][j] = frame->prev_energy[1][j] = CELT_ENERGY_SILENCE;
+            block->prev_energy[0][j] = block->prev_energy[1][j] = CELT_ENERGY_SILENCE;
 
-        memset(frame->energy, 0, sizeof(frame->energy));
-        memset(frame->buf,    0, sizeof(frame->buf));
+        memset(block->energy, 0, sizeof(block->energy));
+        memset(block->buf,    0, sizeof(block->buf));
 
-        memset(frame->pf_gains,     0, sizeof(frame->pf_gains));
-        memset(frame->pf_gains_old, 0, sizeof(frame->pf_gains_old));
-        memset(frame->pf_gains_new, 0, sizeof(frame->pf_gains_new));
+        memset(block->pf_gains,     0, sizeof(block->pf_gains));
+        memset(block->pf_gains_old, 0, sizeof(block->pf_gains_old));
+        memset(block->pf_gains_new, 0, sizeof(block->pf_gains_new));
 
-        frame->deemph_coeff = 0.0;
+        block->emph_coeff = 0.0;
     }
-    s->seed = 0;
+    f->seed = 0;
 
-    s->flushed = 1;
+    f->flushed = 1;
 }
 
-void ff_celt_free(CeltContext **ps)
+void ff_celt_free(CeltFrame **f)
 {
-    CeltContext *s = *ps;
+    CeltFrame *frm = *f;
     int i;
 
-    if (!s)
+    if (!frm)
         return;
 
-    for (i = 0; i < FF_ARRAY_ELEMS(s->imdct); i++)
-        ff_imdct15_uninit(&s->imdct[i]);
+    for (i = 0; i < FF_ARRAY_ELEMS(frm->imdct); i++)
+        ff_mdct15_uninit(&frm->imdct[i]);
+
+    ff_celt_pvq_uninit(&frm->pvq);
 
-    av_freep(&s->dsp);
-    av_freep(ps);
+    av_freep(&frm->dsp);
+    av_freep(f);
 }
 
-int ff_celt_init(AVCodecContext *avctx, CeltContext **ps, int output_channels)
+int ff_celt_init(AVCodecContext *avctx, CeltFrame **f, int output_channels)
 {
-    CeltContext *s;
+    CeltFrame *frm;
     int i, ret;
 
     if (output_channels != 1 && output_channels != 2) {
@@ -2197,31 +995,32 @@ int ff_celt_init(AVCodecContext *avctx, CeltContext **ps, int output_channels)
         return AVERROR(EINVAL);
     }
 
-    s = av_mallocz(sizeof(*s));
-    if (!s)
+    frm = av_mallocz(sizeof(*frm));
+    if (!frm)
         return AVERROR(ENOMEM);
 
-    s->avctx           = avctx;
-    s->output_channels = output_channels;
+    frm->avctx           = avctx;
+    frm->output_channels = output_channels;
 
-    for (i = 0; i < FF_ARRAY_ELEMS(s->imdct); i++) {
-        ret = ff_imdct15_init(&s->imdct[i], i + 3);
-        if (ret < 0)
+    for (i = 0; i < FF_ARRAY_ELEMS(frm->imdct); i++)
+        if ((ret = ff_mdct15_init(&frm->imdct[i], 1, i + 3, -1.0f/32768)) < 0)
             goto fail;
-    }
 
-    s->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
-    if (!s->dsp) {
+    if ((ret = ff_celt_pvq_init(&frm->pvq)) < 0)
+        goto fail;
+
+    frm->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
+    if (!frm->dsp) {
         ret = AVERROR(ENOMEM);
         goto fail;
     }
 
-    ff_celt_flush(s);
+    ff_celt_flush(frm);
 
-    *ps = s;
+    *f = frm;
 
     return 0;
 fail:
-    ff_celt_free(&s);
+    ff_celt_free(&frm);
     return ret;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/opus_celt.h b/mythtv/external/FFmpeg/libavcodec/opus_celt.h
new file mode 100644
index 00000000000..45d50ab27b9
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opus_celt.h
@@ -0,0 +1,168 @@
+/*
+ * Opus decoder/demuxer common functions
+ * Copyright (c) 2012 Andrew D'Addesio
+ * Copyright (c) 2013-2014 Mozilla Corporation
+ * Copyright (c) 2016 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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_OPUS_CELT_H
+#define AVCODEC_OPUS_CELT_H
+
+#include <float.h>
+
+#include "opus.h"
+#include "opus_pvq.h"
+
+#include "mdct15.h"
+#include "libavutil/float_dsp.h"
+#include "libavutil/libm.h"
+
+#define CELT_VECTORS                 11
+#define CELT_ALLOC_STEPS             6
+#define CELT_FINE_OFFSET             21
+#define CELT_MAX_FINE_BITS           8
+#define CELT_NORM_SCALE              16384
+#define CELT_QTHETA_OFFSET           4
+#define CELT_QTHETA_OFFSET_TWOPHASE  16
+#define CELT_EMPH_COEFF              0.85000610f
+#define CELT_POSTFILTER_MINPERIOD    15
+#define CELT_ENERGY_SILENCE          (-28.0f)
+
+typedef struct CeltPVQ CeltPVQ;
+
+enum CeltSpread {
+    CELT_SPREAD_NONE,
+    CELT_SPREAD_LIGHT,
+    CELT_SPREAD_NORMAL,
+    CELT_SPREAD_AGGRESSIVE
+};
+
+enum CeltBlockSize {
+    CELT_BLOCK_120,
+    CELT_BLOCK_240,
+    CELT_BLOCK_480,
+    CELT_BLOCK_960,
+
+    CELT_BLOCK_NB
+};
+
+typedef struct CeltBlock {
+    float energy[CELT_MAX_BANDS];
+    float lin_energy[CELT_MAX_BANDS];
+    float error_energy[CELT_MAX_BANDS];
+    float prev_energy[2][CELT_MAX_BANDS];
+
+    uint8_t collapse_masks[CELT_MAX_BANDS];
+
+    /* buffer for mdct output + postfilter */
+    DECLARE_ALIGNED(32, float, buf)[2048];
+    DECLARE_ALIGNED(32, float, coeffs)[CELT_MAX_FRAME_SIZE];
+
+    /* Used by the encoder */
+    DECLARE_ALIGNED(32, float, overlap)[FFALIGN(CELT_OVERLAP, 16)];
+    DECLARE_ALIGNED(32, float, samples)[FFALIGN(CELT_MAX_FRAME_SIZE, 16)];
+
+    /* postfilter parameters */
+    int   pf_period_new;
+    float pf_gains_new[3];
+    int   pf_period;
+    float pf_gains[3];
+    int   pf_period_old;
+    float pf_gains_old[3];
+
+    float emph_coeff;
+} CeltBlock;
+
+struct CeltFrame {
+    // constant values that do not change during context lifetime
+    AVCodecContext      *avctx;
+    MDCT15Context       *imdct[4];
+    AVFloatDSPContext   *dsp;
+    CeltBlock           block[2];
+    CeltPVQ             *pvq;
+    int channels;
+    int output_channels;
+
+    enum CeltBlockSize size;
+    int start_band;
+    int end_band;
+    int coded_bands;
+    int transient;
+    int pfilter;
+    int skip_band_floor;
+    int tf_select;
+    int alloc_trim;
+    int alloc_boost[CELT_MAX_BANDS];
+    int blocks;        /* number of iMDCT blocks in the frame, depends on transient */
+    int blocksize;     /* size of each block */
+    int silence;       /* Frame is filled with silence */
+    int anticollapse_needed; /* Whether to expect an anticollapse bit */
+    int anticollapse;  /* Encoded anticollapse bit */
+    int intensity_stereo;
+    int dual_stereo;
+    int flushed;
+    uint32_t seed;
+    enum CeltSpread spread;
+
+    /* Encoder PF coeffs */
+    int pf_octave;
+    int pf_period;
+    int pf_tapset;
+    float pf_gain;
+
+    /* Bit allocation */
+    int framebits;
+    int remaining;
+    int remaining2;
+    int caps         [CELT_MAX_BANDS];
+    int fine_bits    [CELT_MAX_BANDS];
+    int fine_priority[CELT_MAX_BANDS];
+    int pulses       [CELT_MAX_BANDS];
+    int tf_change    [CELT_MAX_BANDS];
+};
+
+/* LCG for noise generation */
+static av_always_inline uint32_t celt_rng(CeltFrame *f)
+{
+    f->seed = 1664525 * f->seed + 1013904223;
+    return f->seed;
+}
+
+static av_always_inline void celt_renormalize_vector(float *X, int N, float gain)
+{
+    int i;
+    float g = 1e-15f;
+    for (i = 0; i < N; i++)
+        g += X[i] * X[i];
+    g = gain / sqrtf(g);
+
+    for (i = 0; i < N; i++)
+        X[i] *= g;
+}
+
+int ff_celt_init(AVCodecContext *avctx, CeltFrame **f, int output_channels);
+
+void ff_celt_free(CeltFrame **f);
+
+void ff_celt_flush(CeltFrame *f);
+
+int ff_celt_decode_frame(CeltFrame *f, OpusRangeCoder *rc, float **output,
+                         int coded_channels, int frame_size, int startband, int endband);
+
+#endif /* AVCODEC_OPUS_CELT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/opus_parser.c b/mythtv/external/FFmpeg/libavcodec/opus_parser.c
index c30fd7bbd4a..893573eb822 100644
--- a/mythtv/external/FFmpeg/libavcodec/opus_parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/opus_parser.c
@@ -31,10 +31,10 @@
 #include "parser.h"
 
 typedef struct OpusParseContext {
+    ParseContext pc;
     OpusContext ctx;
     OpusPacket pkt;
     int extradata_parsed;
-    ParseContext pc;
     int ts_framing;
 } OpusParseContext;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/opus_pvq.c b/mythtv/external/FFmpeg/libavcodec/opus_pvq.c
new file mode 100644
index 00000000000..f98b85d36fd
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opus_pvq.c
@@ -0,0 +1,962 @@
+/*
+ * Copyright (c) 2007-2008 CSIRO
+ * Copyright (c) 2007-2009 Xiph.Org Foundation
+ * Copyright (c) 2008-2009 Gregory Maxwell
+ * Copyright (c) 2012 Andrew D'Addesio
+ * Copyright (c) 2013-2014 Mozilla Corporation
+ * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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 "opustab.h"
+#include "opus_pvq.h"
+
+#define CELT_PVQ_U(n, k) (ff_celt_pvq_u_row[FFMIN(n, k)][FFMAX(n, k)])
+#define CELT_PVQ_V(n, k) (CELT_PVQ_U(n, k) + CELT_PVQ_U(n, (k) + 1))
+
+static inline int16_t celt_cos(int16_t x)
+{
+    x = (MUL16(x, x) + 4096) >> 13;
+    x = (32767-x) + ROUND_MUL16(x, (-7651 + ROUND_MUL16(x, (8277 + ROUND_MUL16(-626, x)))));
+    return x + 1;
+}
+
+static inline int celt_log2tan(int isin, int icos)
+{
+    int lc, ls;
+    lc = opus_ilog(icos);
+    ls = opus_ilog(isin);
+    icos <<= 15 - lc;
+    isin <<= 15 - ls;
+    return (ls << 11) - (lc << 11) +
+           ROUND_MUL16(isin, ROUND_MUL16(isin, -2597) + 7932) -
+           ROUND_MUL16(icos, ROUND_MUL16(icos, -2597) + 7932);
+}
+
+static inline int celt_bits2pulses(const uint8_t *cache, int bits)
+{
+    // TODO: Find the size of cache and make it into an array in the parameters list
+    int i, low = 0, high;
+
+    high = cache[0];
+    bits--;
+
+    for (i = 0; i < 6; i++) {
+        int center = (low + high + 1) >> 1;
+        if (cache[center] >= bits)
+            high = center;
+        else
+            low = center;
+    }
+
+    return (bits - (low == 0 ? -1 : cache[low]) <= cache[high] - bits) ? low : high;
+}
+
+static inline int celt_pulses2bits(const uint8_t *cache, int pulses)
+{
+    // TODO: Find the size of cache and make it into an array in the parameters list
+   return (pulses == 0) ? 0 : cache[pulses] + 1;
+}
+
+static inline void celt_normalize_residual(const int * av_restrict iy, float * av_restrict X,
+                                           int N, float g)
+{
+    int i;
+    for (i = 0; i < N; i++)
+        X[i] = g * iy[i];
+}
+
+static void celt_exp_rotation_impl(float *X, uint32_t len, uint32_t stride,
+                                   float c, float s)
+{
+    float *Xptr;
+    int i;
+
+    Xptr = X;
+    for (i = 0; i < len - stride; i++) {
+        float x1     = Xptr[0];
+        float x2     = Xptr[stride];
+        Xptr[stride] = c * x2 + s * x1;
+        *Xptr++      = c * x1 - s * x2;
+    }
+
+    Xptr = &X[len - 2 * stride - 1];
+    for (i = len - 2 * stride - 1; i >= 0; i--) {
+        float x1     = Xptr[0];
+        float x2     = Xptr[stride];
+        Xptr[stride] = c * x2 + s * x1;
+        *Xptr--      = c * x1 - s * x2;
+    }
+}
+
+static inline void celt_exp_rotation(float *X, uint32_t len,
+                                     uint32_t stride, uint32_t K,
+                                     enum CeltSpread spread, const int encode)
+{
+    uint32_t stride2 = 0;
+    float c, s;
+    float gain, theta;
+    int i;
+
+    if (2*K >= len || spread == CELT_SPREAD_NONE)
+        return;
+
+    gain = (float)len / (len + (20 - 5*spread) * K);
+    theta = M_PI * gain * gain / 4;
+
+    c = cosf(theta);
+    s = sinf(theta);
+
+    if (len >= stride << 3) {
+        stride2 = 1;
+        /* This is just a simple (equivalent) way of computing sqrt(len/stride) with rounding.
+        It's basically incrementing long as (stride2+0.5)^2 < len/stride. */
+        while ((stride2 * stride2 + stride2) * stride + (stride >> 2) < len)
+            stride2++;
+    }
+
+    len /= stride;
+    for (i = 0; i < stride; i++) {
+        if (encode) {
+            celt_exp_rotation_impl(X + i * len, len, 1, c, -s);
+            if (stride2)
+                celt_exp_rotation_impl(X + i * len, len, stride2, s, -c);
+        } else {
+            if (stride2)
+                celt_exp_rotation_impl(X + i * len, len, stride2, s, c);
+            celt_exp_rotation_impl(X + i * len, len, 1, c, s);
+        }
+    }
+}
+
+static inline uint32_t celt_extract_collapse_mask(const int *iy, uint32_t N, uint32_t B)
+{
+    int i, j, N0 = N / B;
+    uint32_t collapse_mask = 0;
+
+    if (B <= 1)
+        return 1;
+
+    for (i = 0; i < B; i++)
+        for (j = 0; j < N0; j++)
+            collapse_mask |= (!!iy[i*N0+j]) << i;
+    return collapse_mask;
+}
+
+static inline void celt_stereo_merge(float *X, float *Y, float mid, int N)
+{
+    int i;
+    float xp = 0, side = 0;
+    float E[2];
+    float mid2;
+    float gain[2];
+
+    /* Compute the norm of X+Y and X-Y as |X|^2 + |Y|^2 +/- sum(xy) */
+    for (i = 0; i < N; i++) {
+        xp   += X[i] * Y[i];
+        side += Y[i] * Y[i];
+    }
+
+    /* Compensating for the mid normalization */
+    xp *= mid;
+    mid2 = mid;
+    E[0] = mid2 * mid2 + side - 2 * xp;
+    E[1] = mid2 * mid2 + side + 2 * xp;
+    if (E[0] < 6e-4f || E[1] < 6e-4f) {
+        for (i = 0; i < N; i++)
+            Y[i] = X[i];
+        return;
+    }
+
+    gain[0] = 1.0f / sqrtf(E[0]);
+    gain[1] = 1.0f / sqrtf(E[1]);
+
+    for (i = 0; i < N; i++) {
+        float value[2];
+        /* Apply mid scaling (side is already scaled) */
+        value[0] = mid * X[i];
+        value[1] = Y[i];
+        X[i] = gain[0] * (value[0] - value[1]);
+        Y[i] = gain[1] * (value[0] + value[1]);
+    }
+}
+
+static void celt_interleave_hadamard(float *tmp, float *X, int N0,
+                                     int stride, int hadamard)
+{
+    int i, j, N = N0*stride;
+    const uint8_t *order = &ff_celt_hadamard_order[hadamard ? stride - 2 : 30];
+
+    for (i = 0; i < stride; i++)
+        for (j = 0; j < N0; j++)
+            tmp[j*stride+i] = X[order[i]*N0+j];
+
+    memcpy(X, tmp, N*sizeof(float));
+}
+
+static void celt_deinterleave_hadamard(float *tmp, float *X, int N0,
+                                       int stride, int hadamard)
+{
+    int i, j, N = N0*stride;
+    const uint8_t *order = &ff_celt_hadamard_order[hadamard ? stride - 2 : 30];
+
+    for (i = 0; i < stride; i++)
+        for (j = 0; j < N0; j++)
+            tmp[order[i]*N0+j] = X[j*stride+i];
+
+    memcpy(X, tmp, N*sizeof(float));
+}
+
+static void celt_haar1(float *X, int N0, int stride)
+{
+    int i, j;
+    N0 >>= 1;
+    for (i = 0; i < stride; i++) {
+        for (j = 0; j < N0; j++) {
+            float x0 = X[stride * (2 * j + 0) + i];
+            float x1 = X[stride * (2 * j + 1) + i];
+            X[stride * (2 * j + 0) + i] = (x0 + x1) * M_SQRT1_2;
+            X[stride * (2 * j + 1) + i] = (x0 - x1) * M_SQRT1_2;
+        }
+    }
+}
+
+static inline int celt_compute_qn(int N, int b, int offset, int pulse_cap,
+                                  int stereo)
+{
+    int qn, qb;
+    int N2 = 2 * N - 1;
+    if (stereo && N == 2)
+        N2--;
+
+    /* The upper limit ensures that in a stereo split with itheta==16384, we'll
+     * always have enough bits left over to code at least one pulse in the
+     * side; otherwise it would collapse, since it doesn't get folded. */
+    qb = FFMIN3(b - pulse_cap - (4 << 3), (b + N2 * offset) / N2, 8 << 3);
+    qn = (qb < (1 << 3 >> 1)) ? 1 : ((ff_celt_qn_exp2[qb & 0x7] >> (14 - (qb >> 3))) + 1) >> 1 << 1;
+    return qn;
+}
+
+/* Convert the quantized vector to an index */
+static inline uint32_t celt_icwrsi(uint32_t N, uint32_t K, const int *y)
+{
+    int i, idx = 0, sum = 0;
+    for (i = N - 1; i >= 0; i--) {
+        const uint32_t i_s = CELT_PVQ_U(N - i, sum + FFABS(y[i]) + 1);
+        idx += CELT_PVQ_U(N - i, sum) + (y[i] < 0)*i_s;
+        sum += FFABS(y[i]);
+    }
+    return idx;
+}
+
+// this code was adapted from libopus
+static inline uint64_t celt_cwrsi(uint32_t N, uint32_t K, uint32_t i, int *y)
+{
+    uint64_t norm = 0;
+    uint32_t q, p;
+    int s, val;
+    int k0;
+
+    while (N > 2) {
+        /*Lots of pulses case:*/
+        if (K >= N) {
+            const uint32_t *row = ff_celt_pvq_u_row[N];
+
+            /* Are the pulses in this dimension negative? */
+            p  = row[K + 1];
+            s  = -(i >= p);
+            i -= p & s;
+
+            /*Count how many pulses were placed in this dimension.*/
+            k0 = K;
+            q = row[N];
+            if (q > i) {
+                K = N;
+                do {
+                    p = ff_celt_pvq_u_row[--K][N];
+                } while (p > i);
+            } else
+                for (p = row[K]; p > i; p = row[K])
+                    K--;
+
+            i    -= p;
+            val   = (k0 - K + s) ^ s;
+            norm += val * val;
+            *y++  = val;
+        } else { /*Lots of dimensions case:*/
+            /*Are there any pulses in this dimension at all?*/
+            p = ff_celt_pvq_u_row[K    ][N];
+            q = ff_celt_pvq_u_row[K + 1][N];
+
+            if (p <= i && i < q) {
+                i -= p;
+                *y++ = 0;
+            } else {
+                /*Are the pulses in this dimension negative?*/
+                s  = -(i >= q);
+                i -= q & s;
+
+                /*Count how many pulses were placed in this dimension.*/
+                k0 = K;
+                do p = ff_celt_pvq_u_row[--K][N];
+                while (p > i);
+
+                i    -= p;
+                val   = (k0 - K + s) ^ s;
+                norm += val * val;
+                *y++  = val;
+            }
+        }
+        N--;
+    }
+
+    /* N == 2 */
+    p  = 2 * K + 1;
+    s  = -(i >= p);
+    i -= p & s;
+    k0 = K;
+    K  = (i + 1) / 2;
+
+    if (K)
+        i -= 2 * K - 1;
+
+    val   = (k0 - K + s) ^ s;
+    norm += val * val;
+    *y++  = val;
+
+    /* N==1 */
+    s     = -i;
+    val   = (K + s) ^ s;
+    norm += val * val;
+    *y    = val;
+
+    return norm;
+}
+
+static inline void celt_encode_pulses(OpusRangeCoder *rc, int *y, uint32_t N, uint32_t K)
+{
+    ff_opus_rc_enc_uint(rc, celt_icwrsi(N, K, y), CELT_PVQ_V(N, K));
+}
+
+static inline float celt_decode_pulses(OpusRangeCoder *rc, int *y, uint32_t N, uint32_t K)
+{
+    const uint32_t idx = ff_opus_rc_dec_uint(rc, CELT_PVQ_V(N, K));
+    return celt_cwrsi(N, K, idx, y);
+}
+
+/*
+ * Faster than libopus's search, operates entirely in the signed domain.
+ * Slightly worse/better depending on N, K and the input vector.
+ */
+static float ppp_pvq_search_c(float *X, int *y, int K, int N)
+{
+    int i, y_norm = 0;
+    float res = 0.0f, xy_norm = 0.0f;
+
+    for (i = 0; i < N; i++)
+        res += FFABS(X[i]);
+
+    res = K/(res + FLT_EPSILON);
+
+    for (i = 0; i < N; i++) {
+        y[i] = lrintf(res*X[i]);
+        y_norm  += y[i]*y[i];
+        xy_norm += y[i]*X[i];
+        K -= FFABS(y[i]);
+    }
+
+    while (K) {
+        int max_idx = 0, phase = FFSIGN(K);
+        float max_num = 0.0f;
+        float max_den = 1.0f;
+        y_norm += 1.0f;
+
+        for (i = 0; i < N; i++) {
+            /* If the sum has been overshot and the best place has 0 pulses allocated
+             * to it, attempting to decrease it further will actually increase the
+             * sum. Prevent this by disregarding any 0 positions when decrementing. */
+            const int ca = 1 ^ ((y[i] == 0) & (phase < 0));
+            const int y_new = y_norm  + 2*phase*FFABS(y[i]);
+            float xy_new = xy_norm + 1*phase*FFABS(X[i]);
+            xy_new = xy_new * xy_new;
+            if (ca && (max_den*xy_new) > (y_new*max_num)) {
+                max_den = y_new;
+                max_num = xy_new;
+                max_idx = i;
+            }
+        }
+
+        K -= phase;
+
+        phase *= FFSIGN(X[max_idx]);
+        xy_norm += 1*phase*X[max_idx];
+        y_norm  += 2*phase*y[max_idx];
+        y[max_idx] += phase;
+    }
+
+    return (float)y_norm;
+}
+
+static uint32_t celt_alg_quant(OpusRangeCoder *rc, float *X, uint32_t N, uint32_t K,
+                               enum CeltSpread spread, uint32_t blocks, float gain,
+                               CeltPVQ *pvq)
+{
+    int *y = pvq->qcoeff;
+
+    celt_exp_rotation(X, N, blocks, K, spread, 1);
+    gain /= sqrtf(pvq->pvq_search(X, y, K, N));
+    celt_encode_pulses(rc, y,  N, K);
+    celt_normalize_residual(y, X, N, gain);
+    celt_exp_rotation(X, N, blocks, K, spread, 0);
+    return celt_extract_collapse_mask(y, N, blocks);
+}
+
+/** Decode pulse vector and combine the result with the pitch vector to produce
+    the final normalised signal in the current band. */
+static uint32_t celt_alg_unquant(OpusRangeCoder *rc, float *X, uint32_t N, uint32_t K,
+                                 enum CeltSpread spread, uint32_t blocks, float gain,
+                                 CeltPVQ *pvq)
+{
+    int *y = pvq->qcoeff;
+
+    gain /= sqrtf(celt_decode_pulses(rc, y, N, K));
+    celt_normalize_residual(y, X, N, gain);
+    celt_exp_rotation(X, N, blocks, K, spread, 0);
+    return celt_extract_collapse_mask(y, N, blocks);
+}
+
+static int celt_calc_theta(const float *X, const float *Y, int coupling, int N)
+{
+    int i;
+    float e[2] = { 0.0f, 0.0f };
+    if (coupling) { /* Coupling case */
+        for (i = 0; i < N; i++) {
+            e[0] += (X[i] + Y[i])*(X[i] + Y[i]);
+            e[1] += (X[i] - Y[i])*(X[i] - Y[i]);
+        }
+    } else {
+        for (i = 0; i < N; i++) {
+            e[0] += X[i]*X[i];
+            e[1] += Y[i]*Y[i];
+        }
+    }
+    return lrintf(32768.0f*atan2f(sqrtf(e[1]), sqrtf(e[0]))/M_PI);
+}
+
+static void celt_stereo_is_decouple(float *X, float *Y, float e_l, float e_r, int N)
+{
+    int i;
+    const float energy_n = 1.0f/(sqrtf(e_l*e_l + e_r*e_r) + FLT_EPSILON);
+    e_l *= energy_n;
+    e_r *= energy_n;
+    for (i = 0; i < N; i++)
+        X[i] = e_l*X[i] + e_r*Y[i];
+}
+
+static void celt_stereo_ms_decouple(float *X, float *Y, int N)
+{
+    int i;
+    for (i = 0; i < N; i++) {
+        const float Xret = X[i];
+        X[i] = (X[i] + Y[i])*M_SQRT1_2;
+        Y[i] = (Y[i] - Xret)*M_SQRT1_2;
+    }
+}
+
+static av_always_inline uint32_t quant_band_template(CeltPVQ *pvq, CeltFrame *f,
+                                                     OpusRangeCoder *rc,
+                                                     const int band, float *X,
+                                                     float *Y, int N, int b,
+                                                     uint32_t blocks, float *lowband,
+                                                     int duration, float *lowband_out,
+                                                     int level, float gain,
+                                                     float *lowband_scratch,
+                                                     int fill, int quant,
+                                                     QUANT_FN(*rec))
+{
+    int i;
+    const uint8_t *cache;
+    int stereo = !!Y, split = stereo;
+    int imid = 0, iside = 0;
+    uint32_t N0 = N;
+    int N_B = N / blocks;
+    int N_B0 = N_B;
+    int B0 = blocks;
+    int time_divide = 0;
+    int recombine = 0;
+    int inv = 0;
+    float mid = 0, side = 0;
+    int longblocks = (B0 == 1);
+    uint32_t cm = 0;
+
+    if (N == 1) {
+        float *x = X;
+        for (i = 0; i <= stereo; i++) {
+            int sign = 0;
+            if (f->remaining2 >= 1 << 3) {
+                if (quant) {
+                    sign = x[0] < 0;
+                    ff_opus_rc_put_raw(rc, sign, 1);
+                } else {
+                    sign = ff_opus_rc_get_raw(rc, 1);
+                }
+                f->remaining2 -= 1 << 3;
+            }
+            x[0] = 1.0f - 2.0f*sign;
+            x = Y;
+        }
+        if (lowband_out)
+            lowband_out[0] = X[0];
+        return 1;
+    }
+
+    if (!stereo && level == 0) {
+        int tf_change = f->tf_change[band];
+        int k;
+        if (tf_change > 0)
+            recombine = tf_change;
+        /* Band recombining to increase frequency resolution */
+
+        if (lowband &&
+            (recombine || ((N_B & 1) == 0 && tf_change < 0) || B0 > 1)) {
+            for (i = 0; i < N; i++)
+                lowband_scratch[i] = lowband[i];
+            lowband = lowband_scratch;
+        }
+
+        for (k = 0; k < recombine; k++) {
+            if (quant || lowband)
+                celt_haar1(quant ? X : lowband, N >> k, 1 << k);
+            fill = ff_celt_bit_interleave[fill & 0xF] | ff_celt_bit_interleave[fill >> 4] << 2;
+        }
+        blocks >>= recombine;
+        N_B <<= recombine;
+
+        /* Increasing the time resolution */
+        while ((N_B & 1) == 0 && tf_change < 0) {
+            if (quant || lowband)
+                celt_haar1(quant ? X : lowband, N_B, blocks);
+            fill |= fill << blocks;
+            blocks <<= 1;
+            N_B >>= 1;
+            time_divide++;
+            tf_change++;
+        }
+        B0 = blocks;
+        N_B0 = N_B;
+
+        /* Reorganize the samples in time order instead of frequency order */
+        if (B0 > 1 && (quant || lowband))
+            celt_deinterleave_hadamard(pvq->hadamard_tmp, quant ? X : lowband,
+                                       N_B >> recombine, B0 << recombine,
+                                       longblocks);
+    }
+
+    /* If we need 1.5 more bit than we can produce, split the band in two. */
+    cache = ff_celt_cache_bits +
+            ff_celt_cache_index[(duration + 1) * CELT_MAX_BANDS + band];
+    if (!stereo && duration >= 0 && b > cache[cache[0]] + 12 && N > 2) {
+        N >>= 1;
+        Y = X + N;
+        split = 1;
+        duration -= 1;
+        if (blocks == 1)
+            fill = (fill & 1) | (fill << 1);
+        blocks = (blocks + 1) >> 1;
+    }
+
+    if (split) {
+        int qn;
+        int itheta = quant ? celt_calc_theta(X, Y, stereo, N) : 0;
+        int mbits, sbits, delta;
+        int qalloc;
+        int pulse_cap;
+        int offset;
+        int orig_fill;
+        int tell;
+
+        /* Decide on the resolution to give to the split parameter theta */
+        pulse_cap = ff_celt_log_freq_range[band] + duration * 8;
+        offset = (pulse_cap >> 1) - (stereo && N == 2 ? CELT_QTHETA_OFFSET_TWOPHASE :
+                                                          CELT_QTHETA_OFFSET);
+        qn = (stereo && band >= f->intensity_stereo) ? 1 :
+             celt_compute_qn(N, b, offset, pulse_cap, stereo);
+        tell = opus_rc_tell_frac(rc);
+        if (qn != 1) {
+            if (quant)
+                itheta = (itheta*qn + 8192) >> 14;
+            /* Entropy coding of the angle. We use a uniform pdf for the
+             * time split, a step for stereo, and a triangular one for the rest. */
+            if (quant) {
+                if (stereo && N > 2)
+                    ff_opus_rc_enc_uint_step(rc, itheta, qn / 2);
+                else if (stereo || B0 > 1)
+                    ff_opus_rc_enc_uint(rc, itheta, qn + 1);
+                else
+                    ff_opus_rc_enc_uint_tri(rc, itheta, qn);
+                itheta = itheta * 16384 / qn;
+                if (stereo) {
+                    if (itheta == 0)
+                        celt_stereo_is_decouple(X, Y, f->block[0].lin_energy[band],
+                                                f->block[1].lin_energy[band], N);
+                    else
+                        celt_stereo_ms_decouple(X, Y, N);
+                }
+            } else {
+                if (stereo && N > 2)
+                    itheta = ff_opus_rc_dec_uint_step(rc, qn / 2);
+                else if (stereo || B0 > 1)
+                    itheta = ff_opus_rc_dec_uint(rc, qn+1);
+                else
+                    itheta = ff_opus_rc_dec_uint_tri(rc, qn);
+                itheta = itheta * 16384 / qn;
+            }
+        } else if (stereo) {
+            if (quant) {
+                inv = itheta > 8192;
+                 if (inv) {
+                    for (i = 0; i < N; i++)
+                       Y[i] *= -1;
+                 }
+                 celt_stereo_is_decouple(X, Y, f->block[0].lin_energy[band],
+                                         f->block[1].lin_energy[band], N);
+
+                if (b > 2 << 3 && f->remaining2 > 2 << 3) {
+                    ff_opus_rc_enc_log(rc, inv, 2);
+                } else {
+                    inv = 0;
+                }
+            } else {
+                inv = (b > 2 << 3 && f->remaining2 > 2 << 3) ? ff_opus_rc_dec_log(rc, 2) : 0;
+            }
+            itheta = 0;
+        }
+        qalloc = opus_rc_tell_frac(rc) - tell;
+        b -= qalloc;
+
+        orig_fill = fill;
+        if (itheta == 0) {
+            imid = 32767;
+            iside = 0;
+            fill = av_mod_uintp2(fill, blocks);
+            delta = -16384;
+        } else if (itheta == 16384) {
+            imid = 0;
+            iside = 32767;
+            fill &= ((1 << blocks) - 1) << blocks;
+            delta = 16384;
+        } else {
+            imid = celt_cos(itheta);
+            iside = celt_cos(16384-itheta);
+            /* This is the mid vs side allocation that minimizes squared error
+            in that band. */
+            delta = ROUND_MUL16((N - 1) << 7, celt_log2tan(iside, imid));
+        }
+
+        mid  = imid  / 32768.0f;
+        side = iside / 32768.0f;
+
+        /* This is a special case for N=2 that only works for stereo and takes
+        advantage of the fact that mid and side are orthogonal to encode
+        the side with just one bit. */
+        if (N == 2 && stereo) {
+            int c;
+            int sign = 0;
+            float tmp;
+            float *x2, *y2;
+            mbits = b;
+            /* Only need one bit for the side */
+            sbits = (itheta != 0 && itheta != 16384) ? 1 << 3 : 0;
+            mbits -= sbits;
+            c = (itheta > 8192);
+            f->remaining2 -= qalloc+sbits;
+
+            x2 = c ? Y : X;
+            y2 = c ? X : Y;
+            if (sbits) {
+                if (quant) {
+                    sign = x2[0]*y2[1] - x2[1]*y2[0] < 0;
+                    ff_opus_rc_put_raw(rc, sign, 1);
+                } else {
+                    sign = ff_opus_rc_get_raw(rc, 1);
+                }
+            }
+            sign = 1 - 2 * sign;
+            /* We use orig_fill here because we want to fold the side, but if
+            itheta==16384, we'll have cleared the low bits of fill. */
+            cm = rec(pvq, f, rc, band, x2, NULL, N, mbits, blocks, lowband, duration,
+                     lowband_out, level, gain, lowband_scratch, orig_fill);
+            /* We don't split N=2 bands, so cm is either 1 or 0 (for a fold-collapse),
+            and there's no need to worry about mixing with the other channel. */
+            y2[0] = -sign * x2[1];
+            y2[1] =  sign * x2[0];
+            X[0] *= mid;
+            X[1] *= mid;
+            Y[0] *= side;
+            Y[1] *= side;
+            tmp = X[0];
+            X[0] = tmp - Y[0];
+            Y[0] = tmp + Y[0];
+            tmp = X[1];
+            X[1] = tmp - Y[1];
+            Y[1] = tmp + Y[1];
+        } else {
+            /* "Normal" split code */
+            float *next_lowband2     = NULL;
+            float *next_lowband_out1 = NULL;
+            int next_level = 0;
+            int rebalance;
+            uint32_t cmt;
+
+            /* Give more bits to low-energy MDCTs than they would
+             * otherwise deserve */
+            if (B0 > 1 && !stereo && (itheta & 0x3fff)) {
+                if (itheta > 8192)
+                    /* Rough approximation for pre-echo masking */
+                    delta -= delta >> (4 - duration);
+                else
+                    /* Corresponds to a forward-masking slope of
+                     * 1.5 dB per 10 ms */
+                    delta = FFMIN(0, delta + (N << 3 >> (5 - duration)));
+            }
+            mbits = av_clip((b - delta) / 2, 0, b);
+            sbits = b - mbits;
+            f->remaining2 -= qalloc;
+
+            if (lowband && !stereo)
+                next_lowband2 = lowband + N; /* >32-bit split case */
+
+            /* Only stereo needs to pass on lowband_out.
+             * Otherwise, it's handled at the end */
+            if (stereo)
+                next_lowband_out1 = lowband_out;
+            else
+                next_level = level + 1;
+
+            rebalance = f->remaining2;
+            if (mbits >= sbits) {
+                /* In stereo mode, we do not apply a scaling to the mid
+                 * because we need the normalized mid for folding later */
+                cm = rec(pvq, f, rc, band, X, NULL, N, mbits, blocks, lowband,
+                         duration, next_lowband_out1, next_level,
+                         stereo ? 1.0f : (gain * mid), lowband_scratch, fill);
+                rebalance = mbits - (rebalance - f->remaining2);
+                if (rebalance > 3 << 3 && itheta != 0)
+                    sbits += rebalance - (3 << 3);
+
+                /* For a stereo split, the high bits of fill are always zero,
+                 * so no folding will be done to the side. */
+                cmt = rec(pvq, f, rc, band, Y, NULL, N, sbits, blocks, next_lowband2,
+                          duration, NULL, next_level, gain * side, NULL,
+                          fill >> blocks);
+                cm |= cmt << ((B0 >> 1) & (stereo - 1));
+            } else {
+                /* For a stereo split, the high bits of fill are always zero,
+                 * so no folding will be done to the side. */
+                cm = rec(pvq, f, rc, band, Y, NULL, N, sbits, blocks, next_lowband2,
+                         duration, NULL, next_level, gain * side, NULL, fill >> blocks);
+                cm <<= ((B0 >> 1) & (stereo - 1));
+                rebalance = sbits - (rebalance - f->remaining2);
+                if (rebalance > 3 << 3 && itheta != 16384)
+                    mbits += rebalance - (3 << 3);
+
+                /* In stereo mode, we do not apply a scaling to the mid because
+                 * we need the normalized mid for folding later */
+                cm |= rec(pvq, f, rc, band, X, NULL, N, mbits, blocks, lowband, duration,
+                          next_lowband_out1, next_level, stereo ? 1.0f : (gain * mid),
+                          lowband_scratch, fill);
+            }
+        }
+    } else {
+        /* This is the basic no-split case */
+        uint32_t q         = celt_bits2pulses(cache, b);
+        uint32_t curr_bits = celt_pulses2bits(cache, q);
+        f->remaining2 -= curr_bits;
+
+        /* Ensures we can never bust the budget */
+        while (f->remaining2 < 0 && q > 0) {
+            f->remaining2 += curr_bits;
+            curr_bits      = celt_pulses2bits(cache, --q);
+            f->remaining2 -= curr_bits;
+        }
+
+        if (q != 0) {
+            /* Finally do the actual (de)quantization */
+            if (quant) {
+                cm = celt_alg_quant(rc, X, N, (q < 8) ? q : (8 + (q & 7)) << ((q >> 3) - 1),
+                                    f->spread, blocks, gain, pvq);
+            } else {
+                cm = celt_alg_unquant(rc, X, N, (q < 8) ? q : (8 + (q & 7)) << ((q >> 3) - 1),
+                                      f->spread, blocks, gain, pvq);
+            }
+        } else {
+            /* If there's no pulse, fill the band anyway */
+            uint32_t cm_mask = (1 << blocks) - 1;
+            fill &= cm_mask;
+            if (fill) {
+                if (!lowband) {
+                    /* Noise */
+                    for (i = 0; i < N; i++)
+                        X[i] = (((int32_t)celt_rng(f)) >> 20);
+                    cm = cm_mask;
+                } else {
+                    /* Folded spectrum */
+                    for (i = 0; i < N; i++) {
+                        /* About 48 dB below the "normal" folding level */
+                        X[i] = lowband[i] + (((celt_rng(f)) & 0x8000) ? 1.0f / 256 : -1.0f / 256);
+                    }
+                    cm = fill;
+                }
+                celt_renormalize_vector(X, N, gain);
+            } else {
+                memset(X, 0, N*sizeof(float));
+            }
+        }
+    }
+
+    /* This code is used by the decoder and by the resynthesis-enabled encoder */
+    if (stereo) {
+        if (N > 2)
+            celt_stereo_merge(X, Y, mid, N);
+        if (inv) {
+            for (i = 0; i < N; i++)
+                Y[i] *= -1;
+        }
+    } else if (level == 0) {
+        int k;
+
+        /* Undo the sample reorganization going from time order to frequency order */
+        if (B0 > 1)
+            celt_interleave_hadamard(pvq->hadamard_tmp, X, N_B >> recombine,
+                                     B0 << recombine, longblocks);
+
+        /* Undo time-freq changes that we did earlier */
+        N_B = N_B0;
+        blocks = B0;
+        for (k = 0; k < time_divide; k++) {
+            blocks >>= 1;
+            N_B <<= 1;
+            cm |= cm >> blocks;
+            celt_haar1(X, N_B, blocks);
+        }
+
+        for (k = 0; k < recombine; k++) {
+            cm = ff_celt_bit_deinterleave[cm];
+            celt_haar1(X, N0>>k, 1<<k);
+        }
+        blocks <<= recombine;
+
+        /* Scale output for later folding */
+        if (lowband_out) {
+            float n = sqrtf(N0);
+            for (i = 0; i < N0; i++)
+                lowband_out[i] = n * X[i];
+        }
+        cm = av_mod_uintp2(cm, blocks);
+    }
+
+    return cm;
+}
+
+
+static QUANT_FN(pvq_decode_band)
+{
+    return quant_band_template(pvq, f, rc, band, X, Y, N, b, blocks, lowband, duration,
+                               lowband_out, level, gain, lowband_scratch, fill, 0,
+                               pvq->decode_band);
+}
+
+static QUANT_FN(pvq_encode_band)
+{
+    return quant_band_template(pvq, f, rc, band, X, Y, N, b, blocks, lowband, duration,
+                               lowband_out, level, gain, lowband_scratch, fill, 1,
+                               pvq->encode_band);
+}
+
+static float pvq_band_cost(CeltPVQ *pvq, CeltFrame *f, OpusRangeCoder *rc, int band,
+                           float *bits, float lambda)
+{
+    int i, b = 0;
+    uint32_t cm[2] = { (1 << f->blocks) - 1, (1 << f->blocks) - 1 };
+    const int band_size = ff_celt_freq_range[band] << f->size;
+    float buf[176 * 2], lowband_scratch[176], norm1[176], norm2[176];
+    float dist, cost, err_x = 0.0f, err_y = 0.0f;
+    float *X = buf;
+    float *X_orig = f->block[0].coeffs + (ff_celt_freq_bands[band] << f->size);
+    float *Y = (f->channels == 2) ? &buf[176] : NULL;
+    float *Y_orig = f->block[1].coeffs + (ff_celt_freq_bands[band] << f->size);
+    OPUS_RC_CHECKPOINT_SPAWN(rc);
+
+    memcpy(X, X_orig, band_size*sizeof(float));
+    if (Y)
+        memcpy(Y, Y_orig, band_size*sizeof(float));
+
+    f->remaining2 = ((f->framebits << 3) - f->anticollapse_needed) - opus_rc_tell_frac(rc) - 1;
+    if (band <= f->coded_bands - 1) {
+        int curr_balance = f->remaining / FFMIN(3, f->coded_bands - band);
+        b = av_clip_uintp2(FFMIN(f->remaining2 + 1, f->pulses[band] + curr_balance), 14);
+    }
+
+    if (f->dual_stereo) {
+        pvq->encode_band(pvq, f, rc, band, X, NULL, band_size, b / 2, f->blocks, NULL,
+                         f->size, norm1, 0, 1.0f, lowband_scratch, cm[0]);
+
+        pvq->encode_band(pvq, f, rc, band, Y, NULL, band_size, b / 2, f->blocks, NULL,
+                         f->size, norm2, 0, 1.0f, lowband_scratch, cm[1]);
+    } else {
+        pvq->encode_band(pvq, f, rc, band, X, Y, band_size, b, f->blocks, NULL, f->size,
+                         norm1, 0, 1.0f, lowband_scratch, cm[0] | cm[1]);
+    }
+
+    for (i = 0; i < band_size; i++) {
+        err_x += (X[i] - X_orig[i])*(X[i] - X_orig[i]);
+        err_y += (Y[i] - Y_orig[i])*(Y[i] - Y_orig[i]);
+    }
+
+    dist = sqrtf(err_x) + sqrtf(err_y);
+    cost = OPUS_RC_CHECKPOINT_BITS(rc)/8.0f;
+    *bits += cost;
+
+    OPUS_RC_CHECKPOINT_ROLLBACK(rc);
+
+    return lambda*dist*cost;
+}
+
+int av_cold ff_celt_pvq_init(CeltPVQ **pvq)
+{
+    CeltPVQ *s = av_malloc(sizeof(CeltPVQ));
+    if (!s)
+        return AVERROR(ENOMEM);
+
+    s->pvq_search         = ppp_pvq_search_c;
+    s->decode_band        = pvq_decode_band;
+    s->encode_band        = pvq_encode_band;
+    s->band_cost          = pvq_band_cost;
+
+    if (ARCH_X86)
+        ff_opus_dsp_init_x86(s);
+
+    *pvq = s;
+
+    return 0;
+}
+
+void av_cold ff_celt_pvq_uninit(CeltPVQ **pvq)
+{
+    av_freep(pvq);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/opus_pvq.h b/mythtv/external/FFmpeg/libavcodec/opus_pvq.h
new file mode 100644
index 00000000000..92463373603
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opus_pvq.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2012 Andrew D'Addesio
+ * Copyright (c) 2013-2014 Mozilla Corporation
+ * Copyright (c) 2016 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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_OPUS_PVQ_H
+#define AVCODEC_OPUS_PVQ_H
+
+#include "opus_celt.h"
+
+#define QUANT_FN(name) uint32_t (name)(struct CeltPVQ *pvq, CeltFrame *f,            \
+                                       OpusRangeCoder *rc, const int band, float *X, \
+                                       float *Y, int N, int b, uint32_t blocks,      \
+                                       float *lowband, int duration,                 \
+                                       float *lowband_out, int level, float gain,    \
+                                       float *lowband_scratch, int fill)
+
+struct CeltPVQ {
+    DECLARE_ALIGNED(32, int,   qcoeff      )[256];
+    DECLARE_ALIGNED(32, float, hadamard_tmp)[256];
+
+    float (*pvq_search)(float *X, int *y, int K, int N);
+
+    QUANT_FN(*decode_band);
+    QUANT_FN(*encode_band);
+    float (*band_cost)(struct CeltPVQ *pvq, CeltFrame *f, OpusRangeCoder *rc,
+                       int band, float *bits, float lambda);
+};
+
+int  ff_celt_pvq_init  (struct CeltPVQ **pvq);
+void ff_opus_dsp_init_x86(struct CeltPVQ *s);
+void ff_celt_pvq_uninit(struct CeltPVQ **pvq);
+
+#endif /* AVCODEC_OPUS_PVQ_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/opus_rc.c b/mythtv/external/FFmpeg/libavcodec/opus_rc.c
new file mode 100644
index 00000000000..3972bb0b028
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opus_rc.c
@@ -0,0 +1,411 @@
+/*
+ * Copyright (c) 2012 Andrew D'Addesio
+ * Copyright (c) 2013-2014 Mozilla Corporation
+ * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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 "opus_rc.h"
+
+#define OPUS_RC_BITS 32
+#define OPUS_RC_SYM  8
+#define OPUS_RC_CEIL ((1 << OPUS_RC_SYM) - 1)
+#define OPUS_RC_TOP (1u << 31)
+#define OPUS_RC_BOT (OPUS_RC_TOP >> OPUS_RC_SYM)
+#define OPUS_RC_SHIFT (OPUS_RC_BITS - OPUS_RC_SYM - 1)
+
+static av_always_inline void opus_rc_enc_carryout(OpusRangeCoder *rc, int cbuf)
+{
+    const int cb = cbuf >> OPUS_RC_SYM, mb = (OPUS_RC_CEIL + cb) & OPUS_RC_CEIL;
+    if (cbuf == OPUS_RC_CEIL) {
+        rc->ext++;
+        return;
+    }
+    rc->rng_cur[0] = rc->rem + cb;
+    rc->rng_cur += (rc->rem >= 0);
+    for (; rc->ext > 0; rc->ext--)
+        *rc->rng_cur++ = mb;
+    av_assert0(rc->rng_cur < rc->rb.position);
+    rc->rem = cbuf & OPUS_RC_CEIL; /* Propagate */
+}
+
+static av_always_inline void opus_rc_dec_normalize(OpusRangeCoder *rc)
+{
+    while (rc->range <= OPUS_RC_BOT) {
+        rc->value = ((rc->value << OPUS_RC_SYM) | (get_bits(&rc->gb, OPUS_RC_SYM) ^ OPUS_RC_CEIL)) & (OPUS_RC_TOP - 1);
+        rc->range     <<= OPUS_RC_SYM;
+        rc->total_bits += OPUS_RC_SYM;
+    }
+}
+
+static av_always_inline void opus_rc_enc_normalize(OpusRangeCoder *rc)
+{
+    while (rc->range <= OPUS_RC_BOT) {
+        opus_rc_enc_carryout(rc, rc->value >> OPUS_RC_SHIFT);
+        rc->value = (rc->value << OPUS_RC_SYM) & (OPUS_RC_TOP - 1);
+        rc->range     <<= OPUS_RC_SYM;
+        rc->total_bits += OPUS_RC_SYM;
+    }
+}
+
+static av_always_inline void opus_rc_dec_update(OpusRangeCoder *rc, uint32_t scale,
+                                                uint32_t low, uint32_t high,
+                                                uint32_t total)
+{
+    rc->value -= scale * (total - high);
+    rc->range  = low ? scale * (high - low)
+                      : rc->range - scale * (total - high);
+    opus_rc_dec_normalize(rc);
+}
+
+/* Main encoding function, this needs to go fast */
+static av_always_inline void opus_rc_enc_update(OpusRangeCoder *rc, uint32_t b, uint32_t p,
+                                                uint32_t p_tot, const int ptwo)
+{
+    uint32_t rscaled, cnd = !!b;
+    if (ptwo) /* Whole function is inlined so hopefully branch is optimized out */
+        rscaled = rc->range >> ff_log2(p_tot);
+    else
+        rscaled = rc->range/p_tot;
+    rc->value +=    cnd*(rc->range - rscaled*(p_tot - b));
+    rc->range  = (!cnd)*(rc->range - rscaled*(p_tot - p)) + cnd*rscaled*(p - b);
+    opus_rc_enc_normalize(rc);
+}
+
+uint32_t ff_opus_rc_dec_cdf(OpusRangeCoder *rc, const uint16_t *cdf)
+{
+    unsigned int k, scale, total, symbol, low, high;
+
+    total = *cdf++;
+
+    scale   = rc->range / total;
+    symbol = rc->value / scale + 1;
+    symbol = total - FFMIN(symbol, total);
+
+    for (k = 0; cdf[k] <= symbol; k++);
+    high = cdf[k];
+    low  = k ? cdf[k-1] : 0;
+
+    opus_rc_dec_update(rc, scale, low, high, total);
+
+    return k;
+}
+
+void ff_opus_rc_enc_cdf(OpusRangeCoder *rc, int val, const uint16_t *cdf)
+{
+    opus_rc_enc_update(rc, (!!val)*cdf[val], cdf[val + 1], cdf[0], 1);
+}
+
+uint32_t ff_opus_rc_dec_log(OpusRangeCoder *rc, uint32_t bits)
+{
+    uint32_t k, scale;
+    scale = rc->range >> bits; // in this case, scale = symbol
+
+    if (rc->value >= scale) {
+        rc->value -= scale;
+        rc->range -= scale;
+        k = 0;
+    } else {
+        rc->range = scale;
+        k = 1;
+    }
+    opus_rc_dec_normalize(rc);
+    return k;
+}
+
+void ff_opus_rc_enc_log(OpusRangeCoder *rc, int val, uint32_t bits)
+{
+    bits = (1 << bits) - 1;
+    opus_rc_enc_update(rc, (!!val)*bits, bits + !!val, bits + 1, 1);
+}
+
+/**
+ * CELT: read 1-25 raw bits at the end of the frame, backwards byte-wise
+ */
+uint32_t ff_opus_rc_get_raw(OpusRangeCoder *rc, uint32_t count)
+{
+    uint32_t value = 0;
+
+    while (rc->rb.bytes && rc->rb.cachelen < count) {
+        rc->rb.cacheval |= *--rc->rb.position << rc->rb.cachelen;
+        rc->rb.cachelen += 8;
+        rc->rb.bytes--;
+    }
+
+    value = av_mod_uintp2(rc->rb.cacheval, count);
+    rc->rb.cacheval    >>= count;
+    rc->rb.cachelen     -= count;
+    rc->total_bits      += count;
+
+    return value;
+}
+
+/**
+ * CELT: write 0 - 31 bits to the rawbits buffer
+ */
+void ff_opus_rc_put_raw(OpusRangeCoder *rc, uint32_t val, uint32_t count)
+{
+    const int to_write = FFMIN(32 - rc->rb.cachelen, count);
+
+    rc->total_bits += count;
+    rc->rb.cacheval |= av_mod_uintp2(val, to_write) << rc->rb.cachelen;
+    rc->rb.cachelen = (rc->rb.cachelen + to_write) % 32;
+
+    if (!rc->rb.cachelen && count) {
+        AV_WB32(rc->rb.position, rc->rb.cacheval);
+        rc->rb.bytes    += 4;
+        rc->rb.position -= 4;
+        rc->rb.cachelen = count - to_write;
+        rc->rb.cacheval = av_mod_uintp2(val >> to_write, rc->rb.cachelen);
+        av_assert0(rc->rng_cur < rc->rb.position);
+    }
+}
+
+/**
+ * CELT: read a uniform distribution
+ */
+uint32_t ff_opus_rc_dec_uint(OpusRangeCoder *rc, uint32_t size)
+{
+    uint32_t bits, k, scale, total;
+
+    bits  = opus_ilog(size - 1);
+    total = (bits > 8) ? ((size - 1) >> (bits - 8)) + 1 : size;
+
+    scale  = rc->range / total;
+    k      = rc->value / scale + 1;
+    k      = total - FFMIN(k, total);
+    opus_rc_dec_update(rc, scale, k, k + 1, total);
+
+    if (bits > 8) {
+        k = k << (bits - 8) | ff_opus_rc_get_raw(rc, bits - 8);
+        return FFMIN(k, size - 1);
+    } else
+        return k;
+}
+
+/**
+ * CELT: write a uniformly distributed integer
+ */
+void ff_opus_rc_enc_uint(OpusRangeCoder *rc, uint32_t val, uint32_t size)
+{
+    const int ps = FFMAX(opus_ilog(size - 1) - 8, 0);
+    opus_rc_enc_update(rc, val >> ps, (val >> ps) + 1, ((size - 1) >> ps) + 1, 0);
+    ff_opus_rc_put_raw(rc, val, ps);
+}
+
+uint32_t ff_opus_rc_dec_uint_step(OpusRangeCoder *rc, int k0)
+{
+    /* Use a probability of 3 up to itheta=8192 and then use 1 after */
+    uint32_t k, scale, symbol, total = (k0+1)*3 + k0;
+    scale  = rc->range / total;
+    symbol = rc->value / scale + 1;
+    symbol = total - FFMIN(symbol, total);
+
+    k = (symbol < (k0+1)*3) ? symbol/3 : symbol - (k0+1)*2;
+
+    opus_rc_dec_update(rc, scale, (k <= k0) ? 3*(k+0) : (k-1-k0) + 3*(k0+1),
+                       (k <= k0) ? 3*(k+1) : (k-0-k0) + 3*(k0+1), total);
+    return k;
+}
+
+void ff_opus_rc_enc_uint_step(OpusRangeCoder *rc, uint32_t val, int k0)
+{
+    const uint32_t a = val <= k0, b = 2*a + 1;
+    k0 = (k0 + 1) << 1;
+    val = b*(val + k0) - 3*a*k0;
+    opus_rc_enc_update(rc, val, val + b, (k0 << 1) - 1, 0);
+}
+
+uint32_t ff_opus_rc_dec_uint_tri(OpusRangeCoder *rc, int qn)
+{
+    uint32_t k, scale, symbol, total, low, center;
+
+    total = ((qn>>1) + 1) * ((qn>>1) + 1);
+    scale   = rc->range / total;
+    center = rc->value / scale + 1;
+    center = total - FFMIN(center, total);
+
+    if (center < total >> 1) {
+        k      = (ff_sqrt(8 * center + 1) - 1) >> 1;
+        low    = k * (k + 1) >> 1;
+        symbol = k + 1;
+    } else {
+        k      = (2*(qn + 1) - ff_sqrt(8*(total - center - 1) + 1)) >> 1;
+        low    = total - ((qn + 1 - k) * (qn + 2 - k) >> 1);
+        symbol = qn + 1 - k;
+    }
+
+    opus_rc_dec_update(rc, scale, low, low + symbol, total);
+
+    return k;
+}
+
+void ff_opus_rc_enc_uint_tri(OpusRangeCoder *rc, uint32_t k, int qn)
+{
+    uint32_t symbol, low, total;
+
+    total = ((qn>>1) + 1) * ((qn>>1) + 1);
+
+    if (k <= qn >> 1) {
+        low    = k * (k + 1) >> 1;
+        symbol = k + 1;
+    } else {
+        low    = total - ((qn + 1 - k) * (qn + 2 - k) >> 1);
+        symbol = qn + 1 - k;
+    }
+
+    opus_rc_enc_update(rc, low, low + symbol, total, 0);
+}
+
+int ff_opus_rc_dec_laplace(OpusRangeCoder *rc, uint32_t symbol, int decay)
+{
+    /* extends the range coder to model a Laplace distribution */
+    int value = 0;
+    uint32_t scale, low = 0, center;
+
+    scale  = rc->range >> 15;
+    center = rc->value / scale + 1;
+    center = (1 << 15) - FFMIN(center, 1 << 15);
+
+    if (center >= symbol) {
+        value++;
+        low = symbol;
+        symbol = 1 + ((32768 - 32 - symbol) * (16384-decay) >> 15);
+
+        while (symbol > 1 && center >= low + 2 * symbol) {
+            value++;
+            symbol *= 2;
+            low    += symbol;
+            symbol  = (((symbol - 2) * decay) >> 15) + 1;
+        }
+
+        if (symbol <= 1) {
+            int distance = (center - low) >> 1;
+            value += distance;
+            low   += 2 * distance;
+        }
+
+        if (center < low + symbol)
+            value *= -1;
+        else
+            low += symbol;
+    }
+
+    opus_rc_dec_update(rc, scale, low, FFMIN(low + symbol, 32768), 32768);
+
+    return value;
+}
+
+void ff_opus_rc_enc_laplace(OpusRangeCoder *rc, int *value, uint32_t symbol, int decay)
+{
+    uint32_t low = symbol;
+    int i = 1, val = FFABS(*value), pos = *value > 0;
+    if (!val) {
+        opus_rc_enc_update(rc, 0, symbol, 1 << 15, 1);
+        return;
+    }
+    symbol = ((32768 - 32 - symbol)*(16384 - decay)) >> 15;
+    for (; i < val && symbol; i++) {
+        low   += (symbol << 1) + 2;
+        symbol = (symbol*decay) >> 14;
+    }
+    if (symbol) {
+        low += (++symbol)*pos;
+    } else {
+        const int distance = FFMIN(val - i, (((32768 - low) - !pos) >> 1) - 1);
+        low   += pos + (distance << 1);
+        symbol = FFMIN(1, 32768 - low);
+        *value = FFSIGN(*value)*(distance + i);
+    }
+    opus_rc_enc_update(rc, low, low + symbol, 1 << 15, 1);
+}
+
+int ff_opus_rc_dec_init(OpusRangeCoder *rc, const uint8_t *data, int size)
+{
+    int ret = init_get_bits8(&rc->gb, data, size);
+    if (ret < 0)
+        return ret;
+
+    rc->range = 128;
+    rc->value = 127 - get_bits(&rc->gb, 7);
+    rc->total_bits = 9;
+    opus_rc_dec_normalize(rc);
+
+    return 0;
+}
+
+void ff_opus_rc_dec_raw_init(OpusRangeCoder *rc, const uint8_t *rightend, uint32_t bytes)
+{
+    rc->rb.position = rightend;
+    rc->rb.bytes    = bytes;
+    rc->rb.cachelen = 0;
+    rc->rb.cacheval = 0;
+}
+
+void ff_opus_rc_enc_end(OpusRangeCoder *rc, uint8_t *dst, int size)
+{
+    int rng_bytes, bits = OPUS_RC_BITS - opus_ilog(rc->range);
+    uint32_t mask = (OPUS_RC_TOP - 1) >> bits;
+    uint32_t end = (rc->value + mask) & ~mask;
+
+    if ((end | mask) >= rc->value + rc->range) {
+        bits++;
+        mask >>= 1;
+        end = (rc->value + mask) & ~mask;
+    }
+
+    /* Finish what's left */
+    while (bits > 0) {
+        opus_rc_enc_carryout(rc, end >> OPUS_RC_SHIFT);
+        end = (end << OPUS_RC_SYM) & (OPUS_RC_TOP - 1);
+        bits -= OPUS_RC_SYM;
+    }
+
+    /* Flush out anything left or marked */
+    if (rc->rem >= 0 || rc->ext > 0)
+        opus_rc_enc_carryout(rc, 0);
+
+    rng_bytes = rc->rng_cur - rc->buf;
+    memcpy(dst, rc->buf, rng_bytes);
+
+    rc->waste = size*8 - (rc->rb.bytes*8 + rc->rb.cachelen) - rng_bytes*8;
+
+    /* Put the rawbits part, if any */
+    if (rc->rb.bytes || rc->rb.cachelen) {
+        int i, lap;
+        uint8_t *rb_src, *rb_dst;
+        ff_opus_rc_put_raw(rc, 0, 32 - rc->rb.cachelen);
+        rb_src = rc->buf + OPUS_MAX_PACKET_SIZE + 12 - rc->rb.bytes;
+        rb_dst = dst + FFMAX(size - rc->rb.bytes, 0);
+        lap = &dst[rng_bytes] - rb_dst;
+        for (i = 0; i < lap; i++)
+            rb_dst[i] |= rb_src[i];
+        memcpy(&rb_dst[lap], &rb_src[lap], FFMAX(rc->rb.bytes - lap, 0));
+    }
+}
+
+void ff_opus_rc_enc_init(OpusRangeCoder *rc)
+{
+    rc->value = 0;
+    rc->range = OPUS_RC_TOP;
+    rc->total_bits = OPUS_RC_BITS + 1;
+    rc->rem = -1;
+    rc->ext =  0;
+    rc->rng_cur = rc->buf;
+    ff_opus_rc_dec_raw_init(rc, rc->buf + OPUS_MAX_PACKET_SIZE + 8, 0);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/opus_rc.h b/mythtv/external/FFmpeg/libavcodec/opus_rc.h
new file mode 100644
index 00000000000..627f83229ed
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opus_rc.h
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2012 Andrew D'Addesio
+ * Copyright (c) 2013-2014 Mozilla Corporation
+ * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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_OPUS_RC_H
+#define AVCODEC_OPUS_RC_H
+
+#include <stdint.h>
+#include "get_bits.h"
+
+#define OPUS_MAX_PACKET_SIZE 1275
+
+#define opus_ilog(i) (av_log2(i) + !!(i))
+
+typedef struct RawBitsContext {
+    const uint8_t *position;
+    uint32_t bytes;
+    uint32_t cachelen;
+    uint32_t cacheval;
+} RawBitsContext;
+
+typedef struct OpusRangeCoder {
+    GetBitContext gb;
+    RawBitsContext rb;
+    uint32_t range;
+    uint32_t value;
+    uint32_t total_bits;
+
+    /* Encoder */
+    uint8_t buf[OPUS_MAX_PACKET_SIZE + 12]; /* memcpy vs (memmove + overreading) */
+    uint8_t *rng_cur;                      /* Current range coded byte */
+    int ext;                               /* Awaiting propagation */
+    int rem;                               /* Carryout flag */
+
+    /* Encoding stats */
+    int waste;
+} OpusRangeCoder;
+
+/**
+ * CELT: estimate bits of entropy that have thus far been consumed for the
+ *       current CELT frame, to integer and fractional (1/8th bit) precision
+ */
+static av_always_inline uint32_t opus_rc_tell(const OpusRangeCoder *rc)
+{
+    return rc->total_bits - av_log2(rc->range) - 1;
+}
+
+static av_always_inline uint32_t opus_rc_tell_frac(const OpusRangeCoder *rc)
+{
+    uint32_t i, total_bits, rcbuffer, range;
+
+    total_bits = rc->total_bits << 3;
+    rcbuffer   = av_log2(rc->range) + 1;
+    range      = rc->range >> (rcbuffer-16);
+
+    for (i = 0; i < 3; i++) {
+        int bit;
+        range = range * range >> 15;
+        bit = range >> 16;
+        rcbuffer = rcbuffer << 1 | bit;
+        range >>= bit;
+    }
+
+    return total_bits - rcbuffer;
+}
+
+uint32_t ff_opus_rc_dec_cdf(OpusRangeCoder *rc, const uint16_t *cdf);
+void     ff_opus_rc_enc_cdf(OpusRangeCoder *rc, int val, const uint16_t *cdf);
+
+uint32_t ff_opus_rc_dec_log(OpusRangeCoder *rc, uint32_t bits);
+void     ff_opus_rc_enc_log(OpusRangeCoder *rc, int val, uint32_t bits);
+
+uint32_t ff_opus_rc_dec_uint_step(OpusRangeCoder *rc, int k0);
+void     ff_opus_rc_enc_uint_step(OpusRangeCoder *rc, uint32_t val, int k0);
+
+uint32_t ff_opus_rc_dec_uint_tri(OpusRangeCoder *rc, int qn);
+void     ff_opus_rc_enc_uint_tri(OpusRangeCoder *rc, uint32_t k, int qn);
+
+uint32_t ff_opus_rc_dec_uint(OpusRangeCoder *rc, uint32_t size);
+void     ff_opus_rc_enc_uint(OpusRangeCoder *rc, uint32_t val, uint32_t size);
+
+uint32_t ff_opus_rc_get_raw(OpusRangeCoder *rc, uint32_t count);
+void     ff_opus_rc_put_raw(OpusRangeCoder *rc, uint32_t val, uint32_t count);
+
+int      ff_opus_rc_dec_laplace(OpusRangeCoder *rc, uint32_t symbol, int decay);
+void     ff_opus_rc_enc_laplace(OpusRangeCoder *rc, int *value, uint32_t symbol, int decay);
+
+int      ff_opus_rc_dec_init(OpusRangeCoder *rc, const uint8_t *data, int size);
+void     ff_opus_rc_dec_raw_init(OpusRangeCoder *rc, const uint8_t *rightend, uint32_t bytes);
+
+void     ff_opus_rc_enc_end(OpusRangeCoder *rc, uint8_t *dst, int size);
+void     ff_opus_rc_enc_init(OpusRangeCoder *rc);
+
+#define OPUS_RC_CHECKPOINT_UPDATE(rc) \
+    rc_rollback_bits = opus_rc_tell_frac(rc); \
+    rc_rollback_ctx  = *rc
+
+#define OPUS_RC_CHECKPOINT_SPAWN(rc) \
+    uint32_t rc_rollback_bits = opus_rc_tell_frac(rc); \
+    OpusRangeCoder rc_rollback_ctx = *rc \
+
+#define OPUS_RC_CHECKPOINT_BITS(rc) \
+    (opus_rc_tell_frac(rc) - rc_rollback_bits)
+
+#define OPUS_RC_CHECKPOINT_ROLLBACK(rc) \
+    memcpy(rc, &rc_rollback_ctx, sizeof(OpusRangeCoder)); \
+
+#endif /* AVCODEC_OPUS_RC_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/opus_silk.c b/mythtv/external/FFmpeg/libavcodec/opus_silk.c
index 9c30b122dc5..3c9c849c21d 100644
--- a/mythtv/external/FFmpeg/libavcodec/opus_silk.c
+++ b/mythtv/external/FFmpeg/libavcodec/opus_silk.c
@@ -27,6 +27,7 @@
 #include <stdint.h>
 
 #include "opus.h"
+#include "opustab.h"
 
 typedef struct SilkFrame {
     int coded;
@@ -61,730 +62,6 @@ struct SilkContext {
     int prev_coded_channels;
 };
 
-static const uint16_t silk_model_stereo_s1[] = {
-    256,   7,   9,  10,  11,  12,  22,  46,  54,  55,  56,  59,  82, 174, 197, 200,
-    201, 202, 210, 234, 244, 245, 246, 247, 249, 256
-};
-
-static const uint16_t silk_model_stereo_s2[] = {256, 85, 171, 256};
-
-static const uint16_t silk_model_stereo_s3[] = {256, 51, 102, 154, 205, 256};
-
-static const uint16_t silk_model_mid_only[] = {256, 192, 256};
-
-static const uint16_t silk_model_frame_type_inactive[] = {256, 26, 256};
-
-static const uint16_t silk_model_frame_type_active[] = {256, 24, 98, 246, 256};
-
-static const uint16_t silk_model_gain_highbits[3][9] = {
-    {256,  32, 144, 212, 241, 253, 254, 255, 256},
-    {256,   2,  19,  64, 124, 186, 233, 252, 256},
-    {256,   1,   4,  30, 101, 195, 245, 254, 256}
-};
-
-static const uint16_t silk_model_gain_lowbits[] = {256, 32, 64, 96, 128, 160, 192, 224, 256};
-
-static const uint16_t silk_model_gain_delta[] = {
-    256,   6,  11,  22,  53, 185, 206, 214, 218, 221, 223, 225, 227, 228, 229, 230,
-    231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
-    247, 248, 249, 250, 251, 252, 253, 254, 255, 256
-};
-static const uint16_t silk_model_lsf_s1[2][2][33] = {
-    {
-        {    // NB or MB, unvoiced
-            256,  44,  78, 108, 127, 148, 160, 171, 174, 177, 179, 195, 197, 199, 200, 205,
-            207, 208, 211, 214, 215, 216, 218, 220, 222, 225, 226, 235, 244, 246, 253, 255, 256
-        }, { // NB or MB, voiced
-            256,   1,  11,  12,  20,  23,  31,  39,  53,  66,  80,  81,  95, 107, 120, 131,
-            142, 154, 165, 175, 185, 196, 204, 213, 221, 228, 236, 237, 238, 244, 245, 251, 256
-        }
-    }, {
-        {    // WB, unvoiced
-            256,  31,  52,  55,  72,  73,  81,  98, 102, 103, 121, 137, 141, 143, 146, 147,
-            157, 158, 161, 177, 188, 204, 206, 208, 211, 213, 224, 225, 229, 238, 246, 253, 256
-        }, { // WB, voiced
-            256,   1,   5,  21,  26,  44,  55,  60,  74,  89,  90,  93, 105, 118, 132, 146,
-            152, 166, 178, 180, 186, 187, 199, 211, 222, 232, 235, 245, 250, 251, 252, 253, 256
-        }
-    }
-};
-
-static const uint16_t silk_model_lsf_s2[32][10] = {
-    // NB, MB
-    { 256,   1,   2,   3,  18, 242, 253, 254, 255, 256 },
-    { 256,   1,   2,   4,  38, 221, 253, 254, 255, 256 },
-    { 256,   1,   2,   6,  48, 197, 252, 254, 255, 256 },
-    { 256,   1,   2,  10,  62, 185, 246, 254, 255, 256 },
-    { 256,   1,   4,  20,  73, 174, 248, 254, 255, 256 },
-    { 256,   1,   4,  21,  76, 166, 239, 254, 255, 256 },
-    { 256,   1,   8,  32,  85, 159, 226, 252, 255, 256 },
-    { 256,   1,   2,  20,  83, 161, 219, 249, 255, 256 },
-
-    // WB
-    { 256,   1,   2,   3,  12, 244, 253, 254, 255, 256 },
-    { 256,   1,   2,   4,  32, 218, 253, 254, 255, 256 },
-    { 256,   1,   2,   5,  47, 199, 252, 254, 255, 256 },
-    { 256,   1,   2,  12,  61, 187, 252, 254, 255, 256 },
-    { 256,   1,   5,  24,  72, 172, 249, 254, 255, 256 },
-    { 256,   1,   2,  16,  70, 170, 242, 254, 255, 256 },
-    { 256,   1,   2,  17,  78, 165, 226, 251, 255, 256 },
-    { 256,   1,   8,  29,  79, 156, 237, 254, 255, 256 }
-};
-
-static const uint16_t silk_model_lsf_s2_ext[] = { 256, 156, 216, 240, 249, 253, 255, 256 };
-
-static const uint16_t silk_model_lsf_interpolation_offset[] = { 256, 13, 35, 64, 75, 256 };
-
-static const uint16_t silk_model_pitch_highbits[] = {
-    256,   3,   6,  12,  23,  44,  74, 106, 125, 136, 146, 158, 171, 184, 196, 207,
-    216, 224, 231, 237, 241, 243, 245, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256
-};
-
-static const uint16_t silk_model_pitch_lowbits_nb[]= { 256, 64, 128, 192, 256 };
-
-static const uint16_t silk_model_pitch_lowbits_mb[]= { 256, 43, 85, 128, 171, 213, 256 };
-
-static const uint16_t silk_model_pitch_lowbits_wb[]= { 256, 32, 64, 96, 128, 160, 192, 224, 256 };
-
-static const uint16_t silk_model_pitch_delta[] = {
-    256,  46,  48,  50,  53,  57,  63,  73,  88, 114, 152, 182, 204, 219, 229, 236,
-    242, 246, 250, 252, 254, 256
-};
-
-static const uint16_t silk_model_pitch_contour_nb10ms[] = { 256, 143, 193, 256 };
-
-static const uint16_t silk_model_pitch_contour_nb20ms[] = {
-    256,  68,  80, 101, 118, 137, 159, 189, 213, 230, 246, 256
-};
-
-static const uint16_t silk_model_pitch_contour_mbwb10ms[] = {
-    256,  91, 137, 176, 195, 209, 221, 229, 236, 242, 247, 252, 256
-};
-
-static const uint16_t silk_model_pitch_contour_mbwb20ms[] = {
-    256,  33,  55,  73,  89, 104, 118, 132, 145, 158, 168, 177, 186, 194, 200, 206,
-    212, 217, 221, 225, 229, 232, 235, 238, 240, 242, 244, 246, 248, 250, 252, 253,
-    254, 255, 256
-};
-
-static const uint16_t silk_model_ltp_filter[] = { 256, 77, 157, 256 };
-
-static const uint16_t silk_model_ltp_filter0_sel[] = {
-    256, 185, 200, 213, 226, 235, 244, 250, 256
-};
-
-static const uint16_t silk_model_ltp_filter1_sel[] = {
-    256,  57,  91, 112, 132, 147, 160, 172, 185, 195, 205, 214, 224, 233, 241, 248, 256
-};
-
-static const uint16_t silk_model_ltp_filter2_sel[] = {
-    256,  15,  31,  45,  57,  69,  81,  92, 103, 114, 124, 133, 142, 151, 160, 168,
-    176, 184, 192, 199, 206, 212, 218, 223, 227, 232, 236, 240, 244, 247, 251, 254, 256
-};
-
-static const uint16_t silk_model_ltp_scale_index[] = { 256, 128, 192, 256 };
-
-static const uint16_t silk_model_lcg_seed[] = { 256, 64, 128, 192, 256 };
-
-static const uint16_t silk_model_exc_rate[2][10] = {
-    { 256,  15,  66,  78, 124, 169, 182, 215, 242, 256 }, // unvoiced
-    { 256,  33,  63,  99, 116, 150, 199, 217, 238, 256 }  // voiced
-};
-
-static const uint16_t silk_model_pulse_count[11][19] = {
-    { 256, 131, 205, 230, 238, 241, 244, 245, 246,
-      247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },
-    { 256,  58, 151, 211, 234, 241, 244, 245, 246,
-      247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },
-    { 256,  43,  94, 140, 173, 197, 213, 224, 232,
-      238, 241, 244, 247, 249, 250, 251, 253, 254, 256 },
-    { 256,  17,  69, 140, 197, 228, 240, 245, 246,
-      247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },
-    { 256,   6,  27,  68, 121, 170, 205, 226, 237,
-      243, 246, 248, 250, 251, 252, 253, 254, 255, 256 },
-    { 256,   7,  21,  43,  71, 100, 128, 153, 173,
-      190, 203, 214, 223, 230, 235, 239, 243, 246, 256 },
-    { 256,   2,   7,  21,  50,  92, 138, 179, 210,
-      229, 240, 246, 249, 251, 252, 253, 254, 255, 256 },
-    { 256,   1,   3,   7,  17,  36,  65, 100, 137,
-      171, 199, 219, 233, 241, 246, 250, 252, 254, 256 },
-    { 256,   1,   3,   5,  10,  19,  33,  53,  77,
-      104, 132, 158, 181, 201, 216, 227, 235, 241, 256 },
-    { 256,   1,   2,   3,   9,  36,  94, 150, 189,
-      214, 228, 238, 244, 247, 250, 252, 253, 254, 256 },
-    { 256,   2,   3,   9,  36,  94, 150, 189, 214,
-      228, 238, 244, 247, 250, 252, 253, 254, 256, 256 }
-};
-
-static const uint16_t silk_model_pulse_location[4][168] = {
-    {
-        256, 126, 256,
-        256, 56, 198, 256,
-        256, 25, 126, 230, 256,
-        256, 12, 72, 180, 244, 256,
-        256, 7, 42, 126, 213, 250, 256,
-        256, 4, 24, 83, 169, 232, 253, 256,
-        256, 3, 15, 53, 125, 200, 242, 254, 256,
-        256, 2, 10, 35, 89, 162, 221, 248, 255, 256,
-        256, 2, 7, 24, 63, 126, 191, 233, 251, 255, 256,
-        256, 1, 5, 17, 45, 94, 157, 211, 241, 252, 255, 256,
-        256, 1, 5, 13, 33, 70, 125, 182, 223, 245, 253, 255, 256,
-        256, 1, 4, 11, 26, 54, 98, 151, 199, 232, 248, 254, 255, 256,
-        256, 1, 3, 9, 21, 42, 77, 124, 172, 212, 237, 249, 254, 255, 256,
-        256, 1, 2, 6, 16, 33, 60, 97, 144, 187, 220, 241, 250, 254, 255, 256,
-        256, 1, 2, 3, 11, 25, 47, 80, 120, 163, 201, 229, 245, 253, 254, 255, 256,
-        256, 1, 2, 3, 4, 17, 35, 62, 98, 139, 180, 214, 238, 252, 253, 254, 255, 256
-    },{
-        256, 127, 256,
-        256, 53, 202, 256,
-        256, 22, 127, 233, 256,
-        256, 11, 72, 183, 246, 256,
-        256, 6, 41, 127, 215, 251, 256,
-        256, 4, 24, 83, 170, 232, 253, 256,
-        256, 3, 16, 56, 127, 200, 241, 254, 256,
-        256, 3, 12, 39, 92, 162, 218, 246, 255, 256,
-        256, 3, 11, 30, 67, 124, 185, 229, 249, 255, 256,
-        256, 3, 10, 25, 53, 97, 151, 200, 233, 250, 255, 256,
-        256, 1, 8, 21, 43, 77, 123, 171, 209, 237, 251, 255, 256,
-        256, 1, 2, 13, 35, 62, 97, 139, 186, 219, 244, 254, 255, 256,
-        256, 1, 2, 8, 22, 48, 85, 128, 171, 208, 234, 248, 254, 255, 256,
-        256, 1, 2, 6, 16, 36, 67, 107, 149, 189, 220, 240, 250, 254, 255, 256,
-        256, 1, 2, 5, 13, 29, 55, 90, 128, 166, 201, 227, 243, 251, 254, 255, 256,
-        256, 1, 2, 4, 10, 22, 43, 73, 109, 147, 183, 213, 234, 246, 252, 254, 255, 256
-    },{
-        256, 127, 256,
-        256, 49, 206, 256,
-        256, 20, 127, 236, 256,
-        256, 11, 71, 184, 246, 256,
-        256, 7, 43, 127, 214, 250, 256,
-        256, 6, 30, 87, 169, 229, 252, 256,
-        256, 5, 23, 62, 126, 194, 236, 252, 256,
-        256, 6, 20, 49, 96, 157, 209, 239, 253, 256,
-        256, 1, 16, 39, 74, 125, 175, 215, 245, 255, 256,
-        256, 1, 2, 23, 55, 97, 149, 195, 236, 254, 255, 256,
-        256, 1, 7, 23, 50, 86, 128, 170, 206, 233, 249, 255, 256,
-        256, 1, 6, 18, 39, 70, 108, 148, 186, 217, 238, 250, 255, 256,
-        256, 1, 4, 13, 30, 56, 90, 128, 166, 200, 226, 243, 252, 255, 256,
-        256, 1, 4, 11, 25, 47, 76, 110, 146, 180, 209, 231, 245, 252, 255, 256,
-        256, 1, 3, 8, 19, 37, 62, 93, 128, 163, 194, 219, 237, 248, 253, 255, 256,
-        256, 1, 2, 6, 15, 30, 51, 79, 111, 145, 177, 205, 226, 241, 250, 254, 255, 256
-    },{
-        256, 128, 256,
-        256, 42, 214, 256,
-        256, 21, 128, 235, 256,
-        256, 12, 72, 184, 245, 256,
-        256, 8, 42, 128, 214, 249, 256,
-        256, 8, 31, 86, 176, 231, 251, 256,
-        256, 5, 20, 58, 130, 202, 238, 253, 256,
-        256, 6, 18, 45, 97, 174, 221, 241, 251, 256,
-        256, 6, 25, 53, 88, 128, 168, 203, 231, 250, 256,
-        256, 4, 18, 40, 71, 108, 148, 185, 216, 238, 252, 256,
-        256, 3, 13, 31, 57, 90, 128, 166, 199, 225, 243, 253, 256,
-        256, 2, 10, 23, 44, 73, 109, 147, 183, 212, 233, 246, 254, 256,
-        256, 1, 6, 16, 33, 58, 90, 128, 166, 198, 223, 240, 250, 255, 256,
-        256, 1, 5, 12, 25, 46, 75, 110, 146, 181, 210, 231, 244, 251, 255, 256,
-        256, 1, 3, 8, 18, 35, 60, 92, 128, 164, 196, 221, 238, 248, 253, 255, 256,
-        256, 1, 3, 7, 14, 27, 48, 76, 110, 146, 180, 208, 229, 242, 249, 253, 255, 256
-    }
-};
-
-static const uint16_t silk_model_excitation_lsb[] = {256, 136, 256};
-
-static const uint16_t silk_model_excitation_sign[3][2][7][3] = {
-    {    // Inactive
-        {    // Low offset
-            {256,   2, 256},
-            {256, 207, 256},
-            {256, 189, 256},
-            {256, 179, 256},
-            {256, 174, 256},
-            {256, 163, 256},
-            {256, 157, 256}
-        }, { // High offset
-            {256,  58, 256},
-            {256, 245, 256},
-            {256, 238, 256},
-            {256, 232, 256},
-            {256, 225, 256},
-            {256, 220, 256},
-            {256, 211, 256}
-        }
-    }, { // Unvoiced
-        {    // Low offset
-            {256,   1, 256},
-            {256, 210, 256},
-            {256, 190, 256},
-            {256, 178, 256},
-            {256, 169, 256},
-            {256, 162, 256},
-            {256, 152, 256}
-        }, { // High offset
-            {256,  48, 256},
-            {256, 242, 256},
-            {256, 235, 256},
-            {256, 224, 256},
-            {256, 214, 256},
-            {256, 205, 256},
-            {256, 190, 256}
-        }
-    }, { // Voiced
-        {    // Low offset
-            {256,   1, 256},
-            {256, 162, 256},
-            {256, 152, 256},
-            {256, 147, 256},
-            {256, 144, 256},
-            {256, 141, 256},
-            {256, 138, 256}
-        }, { // High offset
-            {256,   8, 256},
-            {256, 203, 256},
-            {256, 187, 256},
-            {256, 176, 256},
-            {256, 168, 256},
-            {256, 161, 256},
-            {256, 154, 256}
-        }
-    }
-};
-
-static const int16_t silk_stereo_weights[] = {
-    -13732, -10050,  -8266,  -7526,  -6500,  -5000,  -2950,   -820,
-       820,   2950,   5000,   6500,   7526,   8266,  10050,  13732
-};
-
-static const uint8_t silk_lsf_s2_model_sel_nbmb[32][10] = {
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-    { 1, 3, 1, 2, 2, 1, 2, 1, 1, 1 },
-    { 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
-    { 1, 2, 2, 2, 2, 1, 2, 1, 1, 1 },
-    { 2, 3, 3, 3, 3, 2, 2, 2, 2, 2 },
-    { 0, 5, 3, 3, 2, 2, 2, 2, 1, 1 },
-    { 0, 2, 2, 2, 2, 2, 2, 2, 2, 1 },
-    { 2, 3, 6, 4, 4, 4, 5, 4, 5, 5 },
-    { 2, 4, 5, 5, 4, 5, 4, 6, 4, 4 },
-    { 2, 4, 4, 7, 4, 5, 4, 5, 5, 4 },
-    { 4, 3, 3, 3, 2, 3, 2, 2, 2, 2 },
-    { 1, 5, 5, 6, 4, 5, 4, 5, 5, 5 },
-    { 2, 7, 4, 6, 5, 5, 5, 5, 5, 5 },
-    { 2, 7, 5, 5, 5, 5, 5, 6, 5, 4 },
-    { 3, 3, 5, 4, 4, 5, 4, 5, 4, 4 },
-    { 2, 3, 3, 5, 5, 4, 4, 4, 4, 4 },
-    { 2, 4, 4, 6, 4, 5, 4, 5, 5, 5 },
-    { 2, 5, 4, 6, 5, 5, 5, 4, 5, 4 },
-    { 2, 7, 4, 5, 4, 5, 4, 5, 5, 5 },
-    { 2, 5, 4, 6, 7, 6, 5, 6, 5, 4 },
-    { 3, 6, 7, 4, 6, 5, 5, 6, 4, 5 },
-    { 2, 7, 6, 4, 4, 4, 5, 4, 5, 5 },
-    { 4, 5, 5, 4, 6, 6, 5, 6, 5, 4 },
-    { 2, 5, 5, 6, 5, 6, 4, 6, 4, 4 },
-    { 4, 5, 5, 5, 3, 7, 4, 5, 5, 4 },
-    { 2, 3, 4, 5, 5, 6, 4, 5, 5, 4 },
-    { 2, 3, 2, 3, 3, 4, 2, 3, 3, 3 },
-    { 1, 1, 2, 2, 2, 2, 2, 3, 2, 2 },
-    { 4, 5, 5, 6, 6, 6, 5, 6, 4, 5 },
-    { 3, 5, 5, 4, 4, 4, 4, 3, 3, 2 },
-    { 2, 5, 3, 7, 5, 5, 4, 4, 5, 4 },
-    { 4, 4, 5, 4, 5, 6, 5, 6, 5, 4 }
-};
-
-static const uint8_t silk_lsf_s2_model_sel_wb[32][16] = {
-    {  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },
-    { 10, 11, 11, 11, 11, 11, 10, 10, 10, 10, 10,  9,  9,  9,  8, 11 },
-    { 10, 13, 13, 11, 15, 12, 12, 13, 10, 13, 12, 13, 13, 12, 11, 11 },
-    {  8, 10,  9, 10, 10,  9,  9,  9,  9,  9,  8,  8,  8,  8,  8,  9 },
-    {  8, 14, 13, 12, 14, 12, 15, 13, 12, 12, 12, 13, 13, 12, 12, 11 },
-    {  8, 11, 13, 13, 12, 11, 11, 13, 11, 11, 11, 11, 11, 11, 10, 12 },
-    {  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },
-    {  8, 10, 14, 11, 15, 10, 13, 11, 12, 13, 13, 12, 11, 11, 10, 11 },
-    {  8, 14, 10, 14, 14, 12, 13, 12, 14, 13, 12, 12, 13, 11, 11, 11 },
-    { 10,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },
-    {  8,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  9 },
-    { 10, 10, 11, 12, 13, 11, 11, 11, 11, 11, 11, 11, 10, 10,  9, 11 },
-    { 10, 10, 11, 11, 12, 11, 11, 11, 11, 11, 11, 11, 11, 10,  9, 11 },
-    { 11, 12, 12, 12, 14, 12, 12, 13, 11, 13, 12, 12, 13, 12, 11, 12 },
-    {  8, 14, 12, 13, 12, 15, 13, 10, 14, 13, 15, 12, 12, 11, 13, 11 },
-    {  8,  9,  8,  9,  9,  9,  9,  9,  9,  9,  8,  8,  8,  8,  9,  8 },
-    {  9, 14, 13, 15, 13, 12, 13, 11, 12, 13, 12, 12, 12, 11, 11, 12 },
-    {  9, 11, 11, 12, 12, 11, 11, 13, 10, 11, 11, 13, 13, 13, 11, 12 },
-    { 10, 11, 11, 10, 10, 10, 11, 10,  9, 10,  9, 10,  9,  9,  9, 12 },
-    {  8, 10, 11, 13, 11, 11, 10, 10, 10,  9,  9,  8,  8,  8,  8,  8 },
-    { 11, 12, 11, 13, 11, 11, 10, 10,  9,  9,  9,  9,  9, 10, 10, 12 },
-    { 10, 14, 11, 15, 15, 12, 13, 12, 13, 11, 13, 11, 11, 10, 11, 11 },
-    { 10, 11, 13, 14, 14, 11, 13, 11, 12, 12, 11, 11, 11, 11, 10, 12 },
-    {  9, 11, 11, 12, 12, 12, 12, 11, 13, 13, 13, 11,  9,  9,  9,  9 },
-    { 10, 13, 11, 14, 14, 12, 15, 12, 12, 13, 11, 12, 12, 11, 11, 11 },
-    {  8, 14,  9,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },
-    {  8, 14, 14, 11, 13, 10, 13, 13, 11, 12, 12, 15, 15, 12, 12, 12 },
-    { 11, 11, 15, 11, 13, 12, 11, 11, 11, 10, 10, 11, 11, 11, 10, 11 },
-    {  8,  8,  9,  8,  8,  8, 10,  9, 10,  9,  9, 10, 10, 10,  9,  9 },
-    {  8, 11, 10, 13, 11, 11, 10, 11, 10,  9,  8,  8,  9,  8,  8,  9 },
-    { 11, 13, 13, 12, 15, 13, 11, 11, 10, 11, 10, 10,  9,  8,  9,  8 },
-    { 10, 11, 13, 11, 12, 11, 11, 11, 10,  9, 10, 14, 12,  8,  8,  8 }
-};
-
-static const uint8_t silk_lsf_pred_weights_nbmb[2][9] = {
-    {179, 138, 140, 148, 151, 149, 153, 151, 163},
-    {116,  67,  82,  59,  92,  72, 100,  89,  92}
-};
-
-static const uint8_t silk_lsf_pred_weights_wb[2][15] = {
-    {175, 148, 160, 176, 178, 173, 174, 164, 177, 174, 196, 182, 198, 192, 182},
-    { 68,  62,  66,  60,  72, 117,  85,  90, 118, 136, 151, 142, 160, 142, 155}
-};
-
-static const uint8_t silk_lsf_weight_sel_nbmb[32][9] = {
-    { 0, 1, 0, 0, 0, 0, 0, 0, 0 },
-    { 1, 0, 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-    { 1, 1, 1, 0, 0, 0, 0, 1, 0 },
-    { 0, 1, 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 1, 0, 0, 0, 0, 0, 0, 0 },
-    { 1, 0, 1, 1, 0, 0, 0, 1, 0 },
-    { 0, 1, 1, 0, 0, 1, 1, 0, 0 },
-    { 0, 0, 1, 1, 0, 1, 0, 1, 1 },
-    { 0, 0, 1, 1, 0, 0, 1, 1, 1 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 1, 0, 1, 1, 1, 1, 1, 0 },
-    { 0, 1, 0, 1, 1, 1, 1, 1, 0 },
-    { 0, 1, 1, 1, 1, 1, 1, 1, 0 },
-    { 1, 0, 1, 1, 0, 1, 1, 1, 1 },
-    { 0, 1, 1, 1, 1, 1, 0, 1, 0 },
-    { 0, 0, 1, 1, 0, 1, 0, 1, 0 },
-    { 0, 0, 1, 1, 1, 0, 1, 1, 1 },
-    { 0, 1, 1, 0, 0, 1, 1, 1, 0 },
-    { 0, 0, 0, 1, 1, 1, 0, 1, 0 },
-    { 0, 1, 1, 0, 0, 1, 0, 1, 0 },
-    { 0, 1, 1, 0, 0, 0, 1, 1, 0 },
-    { 0, 0, 0, 0, 0, 1, 1, 1, 1 },
-    { 0, 0, 1, 1, 0, 0, 0, 1, 1 },
-    { 0, 0, 0, 1, 0, 1, 1, 1, 1 },
-    { 0, 1, 1, 1, 1, 1, 1, 1, 0 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 1, 0, 1, 1, 0, 1, 0 },
-    { 1, 0, 0, 1, 0, 0, 0, 0, 0 },
-    { 0, 0, 0, 1, 1, 0, 1, 0, 1 },
-    { 1, 0, 1, 1, 0, 1, 1, 1, 1 }
-};
-
-static const uint8_t silk_lsf_weight_sel_wb[32][15] = {
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
-    { 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0 },
-    { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 },
-    { 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1 },
-    { 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
-    { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0 },
-    { 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
-    { 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0 },
-    { 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1 },
-    { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0 },
-    { 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0 },
-    { 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0 },
-    { 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
-    { 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0 },
-    { 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
-    { 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1 },
-    { 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
-    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
-    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
-    { 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0 }
-};
-
-static const uint8_t silk_lsf_codebook_nbmb[32][10] = {
-    { 12,  35,  60,  83, 108, 132, 157, 180, 206, 228 },
-    { 15,  32,  55,  77, 101, 125, 151, 175, 201, 225 },
-    { 19,  42,  66,  89, 114, 137, 162, 184, 209, 230 },
-    { 12,  25,  50,  72,  97, 120, 147, 172, 200, 223 },
-    { 26,  44,  69,  90, 114, 135, 159, 180, 205, 225 },
-    { 13,  22,  53,  80, 106, 130, 156, 180, 205, 228 },
-    { 15,  25,  44,  64,  90, 115, 142, 168, 196, 222 },
-    { 19,  24,  62,  82, 100, 120, 145, 168, 190, 214 },
-    { 22,  31,  50,  79, 103, 120, 151, 170, 203, 227 },
-    { 21,  29,  45,  65, 106, 124, 150, 171, 196, 224 },
-    { 30,  49,  75,  97, 121, 142, 165, 186, 209, 229 },
-    { 19,  25,  52,  70,  93, 116, 143, 166, 192, 219 },
-    { 26,  34,  62,  75,  97, 118, 145, 167, 194, 217 },
-    { 25,  33,  56,  70,  91, 113, 143, 165, 196, 223 },
-    { 21,  34,  51,  72,  97, 117, 145, 171, 196, 222 },
-    { 20,  29,  50,  67,  90, 117, 144, 168, 197, 221 },
-    { 22,  31,  48,  66,  95, 117, 146, 168, 196, 222 },
-    { 24,  33,  51,  77, 116, 134, 158, 180, 200, 224 },
-    { 21,  28,  70,  87, 106, 124, 149, 170, 194, 217 },
-    { 26,  33,  53,  64,  83, 117, 152, 173, 204, 225 },
-    { 27,  34,  65,  95, 108, 129, 155, 174, 210, 225 },
-    { 20,  26,  72,  99, 113, 131, 154, 176, 200, 219 },
-    { 34,  43,  61,  78,  93, 114, 155, 177, 205, 229 },
-    { 23,  29,  54,  97, 124, 138, 163, 179, 209, 229 },
-    { 30,  38,  56,  89, 118, 129, 158, 178, 200, 231 },
-    { 21,  29,  49,  63,  85, 111, 142, 163, 193, 222 },
-    { 27,  48,  77, 103, 133, 158, 179, 196, 215, 232 },
-    { 29,  47,  74,  99, 124, 151, 176, 198, 220, 237 },
-    { 33,  42,  61,  76,  93, 121, 155, 174, 207, 225 },
-    { 29,  53,  87, 112, 136, 154, 170, 188, 208, 227 },
-    { 24,  30,  52,  84, 131, 150, 166, 186, 203, 229 },
-    { 37,  48,  64,  84, 104, 118, 156, 177, 201, 230 }
-};
-
-static const uint8_t silk_lsf_codebook_wb[32][16] = {
-    {  7,  23,  38,  54,  69,  85, 100, 116, 131, 147, 162, 178, 193, 208, 223, 239 },
-    { 13,  25,  41,  55,  69,  83,  98, 112, 127, 142, 157, 171, 187, 203, 220, 236 },
-    { 15,  21,  34,  51,  61,  78,  92, 106, 126, 136, 152, 167, 185, 205, 225, 240 },
-    { 10,  21,  36,  50,  63,  79,  95, 110, 126, 141, 157, 173, 189, 205, 221, 237 },
-    { 17,  20,  37,  51,  59,  78,  89, 107, 123, 134, 150, 164, 184, 205, 224, 240 },
-    { 10,  15,  32,  51,  67,  81,  96, 112, 129, 142, 158, 173, 189, 204, 220, 236 },
-    {  8,  21,  37,  51,  65,  79,  98, 113, 126, 138, 155, 168, 179, 192, 209, 218 },
-    { 12,  15,  34,  55,  63,  78,  87, 108, 118, 131, 148, 167, 185, 203, 219, 236 },
-    { 16,  19,  32,  36,  56,  79,  91, 108, 118, 136, 154, 171, 186, 204, 220, 237 },
-    { 11,  28,  43,  58,  74,  89, 105, 120, 135, 150, 165, 180, 196, 211, 226, 241 },
-    {  6,  16,  33,  46,  60,  75,  92, 107, 123, 137, 156, 169, 185, 199, 214, 225 },
-    { 11,  19,  30,  44,  57,  74,  89, 105, 121, 135, 152, 169, 186, 202, 218, 234 },
-    { 12,  19,  29,  46,  57,  71,  88, 100, 120, 132, 148, 165, 182, 199, 216, 233 },
-    { 17,  23,  35,  46,  56,  77,  92, 106, 123, 134, 152, 167, 185, 204, 222, 237 },
-    { 14,  17,  45,  53,  63,  75,  89, 107, 115, 132, 151, 171, 188, 206, 221, 240 },
-    {  9,  16,  29,  40,  56,  71,  88, 103, 119, 137, 154, 171, 189, 205, 222, 237 },
-    { 16,  19,  36,  48,  57,  76,  87, 105, 118, 132, 150, 167, 185, 202, 218, 236 },
-    { 12,  17,  29,  54,  71,  81,  94, 104, 126, 136, 149, 164, 182, 201, 221, 237 },
-    { 15,  28,  47,  62,  79,  97, 115, 129, 142, 155, 168, 180, 194, 208, 223, 238 },
-    {  8,  14,  30,  45,  62,  78,  94, 111, 127, 143, 159, 175, 192, 207, 223, 239 },
-    { 17,  30,  49,  62,  79,  92, 107, 119, 132, 145, 160, 174, 190, 204, 220, 235 },
-    { 14,  19,  36,  45,  61,  76,  91, 108, 121, 138, 154, 172, 189, 205, 222, 238 },
-    { 12,  18,  31,  45,  60,  76,  91, 107, 123, 138, 154, 171, 187, 204, 221, 236 },
-    { 13,  17,  31,  43,  53,  70,  83, 103, 114, 131, 149, 167, 185, 203, 220, 237 },
-    { 17,  22,  35,  42,  58,  78,  93, 110, 125, 139, 155, 170, 188, 206, 224, 240 },
-    {  8,  15,  34,  50,  67,  83,  99, 115, 131, 146, 162, 178, 193, 209, 224, 239 },
-    { 13,  16,  41,  66,  73,  86,  95, 111, 128, 137, 150, 163, 183, 206, 225, 241 },
-    { 17,  25,  37,  52,  63,  75,  92, 102, 119, 132, 144, 160, 175, 191, 212, 231 },
-    { 19,  31,  49,  65,  83, 100, 117, 133, 147, 161, 174, 187, 200, 213, 227, 242 },
-    { 18,  31,  52,  68,  88, 103, 117, 126, 138, 149, 163, 177, 192, 207, 223, 239 },
-    { 16,  29,  47,  61,  76,  90, 106, 119, 133, 147, 161, 176, 193, 209, 224, 240 },
-    { 15,  21,  35,  50,  61,  73,  86,  97, 110, 119, 129, 141, 175, 198, 218, 237 }
-};
-
-static const uint16_t silk_lsf_min_spacing_nbmb[] = {
-    250, 3, 6, 3, 3, 3, 4, 3, 3, 3, 461
-};
-
-static const uint16_t silk_lsf_min_spacing_wb[] = {
-    100, 3, 40, 3, 3, 3, 5, 14, 14, 10, 11, 3, 8, 9, 7, 3, 347
-};
-
-static const uint8_t silk_lsf_ordering_nbmb[] = {
-    0, 9, 6, 3, 4, 5, 8, 1, 2, 7
-};
-
-static const uint8_t silk_lsf_ordering_wb[] = {
-    0, 15, 8, 7, 4, 11, 12, 3, 2, 13, 10, 5, 6, 9, 14, 1
-};
-
-static const int16_t silk_cosine[] = { /* (0.12) */
-     4096,  4095,  4091,  4085,
-     4076,  4065,  4052,  4036,
-     4017,  3997,  3973,  3948,
-     3920,  3889,  3857,  3822,
-     3784,  3745,  3703,  3659,
-     3613,  3564,  3513,  3461,
-     3406,  3349,  3290,  3229,
-     3166,  3102,  3035,  2967,
-     2896,  2824,  2751,  2676,
-     2599,  2520,  2440,  2359,
-     2276,  2191,  2106,  2019,
-     1931,  1842,  1751,  1660,
-     1568,  1474,  1380,  1285,
-     1189,  1093,   995,   897,
-      799,   700,   601,   501,
-      401,   301,   201,   101,
-        0,  -101,  -201,  -301,
-     -401,  -501,  -601,  -700,
-     -799,  -897,  -995, -1093,
-    -1189, -1285, -1380, -1474,
-    -1568, -1660, -1751, -1842,
-    -1931, -2019, -2106, -2191,
-    -2276, -2359, -2440, -2520,
-    -2599, -2676, -2751, -2824,
-    -2896, -2967, -3035, -3102,
-    -3166, -3229, -3290, -3349,
-    -3406, -3461, -3513, -3564,
-    -3613, -3659, -3703, -3745,
-    -3784, -3822, -3857, -3889,
-    -3920, -3948, -3973, -3997,
-    -4017, -4036, -4052, -4065,
-    -4076, -4085, -4091, -4095,
-    -4096
-};
-
-static const uint16_t silk_pitch_scale[]   = {  4,   6,   8};
-
-static const uint16_t silk_pitch_min_lag[] = { 16,  24,  32};
-
-static const uint16_t silk_pitch_max_lag[] = {144, 216, 288};
-
-static const int8_t silk_pitch_offset_nb10ms[3][2] = {
-    { 0,  0},
-    { 1,  0},
-    { 0,  1}
-};
-
-static const int8_t silk_pitch_offset_nb20ms[11][4] = {
-    { 0,  0,  0,  0},
-    { 2,  1,  0, -1},
-    {-1,  0,  1,  2},
-    {-1,  0,  0,  1},
-    {-1,  0,  0,  0},
-    { 0,  0,  0,  1},
-    { 0,  0,  1,  1},
-    { 1,  1,  0,  0},
-    { 1,  0,  0,  0},
-    { 0,  0,  0, -1},
-    { 1,  0,  0, -1}
-};
-
-static const int8_t silk_pitch_offset_mbwb10ms[12][2] = {
-    { 0,  0},
-    { 0,  1},
-    { 1,  0},
-    {-1,  1},
-    { 1, -1},
-    {-1,  2},
-    { 2, -1},
-    {-2,  2},
-    { 2, -2},
-    {-2,  3},
-    { 3, -2},
-    {-3,  3}
-};
-
-static const int8_t silk_pitch_offset_mbwb20ms[34][4] = {
-    { 0,  0,  0,  0},
-    { 0,  0,  1,  1},
-    { 1,  1,  0,  0},
-    {-1,  0,  0,  0},
-    { 0,  0,  0,  1},
-    { 1,  0,  0,  0},
-    {-1,  0,  0,  1},
-    { 0,  0,  0, -1},
-    {-1,  0,  1,  2},
-    { 1,  0,  0, -1},
-    {-2, -1,  1,  2},
-    { 2,  1,  0, -1},
-    {-2,  0,  0,  2},
-    {-2,  0,  1,  3},
-    { 2,  1, -1, -2},
-    {-3, -1,  1,  3},
-    { 2,  0,  0, -2},
-    { 3,  1,  0, -2},
-    {-3, -1,  2,  4},
-    {-4, -1,  1,  4},
-    { 3,  1, -1, -3},
-    {-4, -1,  2,  5},
-    { 4,  2, -1, -3},
-    { 4,  1, -1, -4},
-    {-5, -1,  2,  6},
-    { 5,  2, -1, -4},
-    {-6, -2,  2,  6},
-    {-5, -2,  2,  5},
-    { 6,  2, -1, -5},
-    {-7, -2,  3,  8},
-    { 6,  2, -2, -6},
-    { 5,  2, -2, -5},
-    { 8,  3, -2, -7},
-    {-9, -3,  3,  9}
-};
-
-static const int8_t silk_ltp_filter0_taps[8][5] = {
-    {  4,   6,  24,   7,   5},
-    {  0,   0,   2,   0,   0},
-    { 12,  28,  41,  13,  -4},
-    { -9,  15,  42,  25,  14},
-    {  1,  -2,  62,  41,  -9},
-    {-10,  37,  65,  -4,   3},
-    { -6,   4,  66,   7,  -8},
-    { 16,  14,  38,  -3,  33}
-};
-
-static const int8_t silk_ltp_filter1_taps[16][5] = {
-    { 13,  22,  39,  23,  12},
-    { -1,  36,  64,  27,  -6},
-    { -7,  10,  55,  43,  17},
-    {  1,   1,   8,   1,   1},
-    {  6, -11,  74,  53,  -9},
-    {-12,  55,  76, -12,   8},
-    { -3,   3,  93,  27,  -4},
-    { 26,  39,  59,   3,  -8},
-    {  2,   0,  77,  11,   9},
-    { -8,  22,  44,  -6,   7},
-    { 40,   9,  26,   3,   9},
-    { -7,  20, 101,  -7,   4},
-    {  3,  -8,  42,  26,   0},
-    {-15,  33,  68,   2,  23},
-    { -2,  55,  46,  -2,  15},
-    {  3,  -1,  21,  16,  41}
-};
-
-static const int8_t silk_ltp_filter2_taps[32][5] = {
-    { -6,  27,  61,  39,   5},
-    {-11,  42,  88,   4,   1},
-    { -2,  60,  65,   6,  -4},
-    { -1,  -5,  73,  56,   1},
-    { -9,  19,  94,  29,  -9},
-    {  0,  12,  99,   6,   4},
-    {  8, -19, 102,  46, -13},
-    {  3,   2,  13,   3,   2},
-    {  9, -21,  84,  72, -18},
-    {-11,  46, 104, -22,   8},
-    { 18,  38,  48,  23,   0},
-    {-16,  70,  83, -21,  11},
-    {  5, -11, 117,  22,  -8},
-    { -6,  23, 117, -12,   3},
-    {  3,  -8,  95,  28,   4},
-    {-10,  15,  77,  60, -15},
-    { -1,   4, 124,   2,  -4},
-    {  3,  38,  84,  24, -25},
-    {  2,  13,  42,  13,  31},
-    { 21,  -4,  56,  46,  -1},
-    { -1,  35,  79, -13,  19},
-    { -7,  65,  88,  -9, -14},
-    { 20,   4,  81,  49, -29},
-    { 20,   0,  75,   3, -17},
-    {  5,  -9,  44,  92,  -8},
-    {  1,  -3,  22,  69,  31},
-    { -6,  95,  41, -12,   5},
-    { 39,  67,  16,  -4,   1},
-    {  0,  -6, 120,  55, -36},
-    {-13,  44, 122,   4, -24},
-    { 81,   5,  11,   3,   7},
-    {  2,   0,   9,  10,  88}
-};
-
-static const uint16_t silk_ltp_scale_factor[] = {15565, 12288, 8192};
-
-static const uint8_t silk_shell_blocks[3][2] = {
-    { 5, 10}, // NB
-    { 8, 15}, // MB
-    {10, 20}  // WB
-};
-
-static const uint8_t silk_quant_offset[2][2] = { /* (0.23) */
-    {25, 60}, // Inactive or Unvoiced
-    { 8, 25}  // Voiced
-};
-
-static const int silk_stereo_interp_len[3] = {
-    64, 96, 128
-};
-
 static inline void silk_stabilize_lsf(int16_t nlsf[16], int order, const uint16_t min_delta[17])
 {
     int pass, i;
@@ -851,8 +128,7 @@ static inline void silk_stabilize_lsf(int16_t nlsf[16], int order, const uint16_
     if (nlsf[0] < min_delta[0])
         nlsf[0] = min_delta[0];
     for (i = 1; i < order; i++)
-        if (nlsf[i] < nlsf[i - 1] + min_delta[i])
-            nlsf[i] = nlsf[i - 1] + min_delta[i];
+        nlsf[i] = FFMAX(nlsf[i], FFMIN(nlsf[i - 1] + min_delta[i], 32767));
 
     /* push backwards to increase distance */
     if (nlsf[order-1] > 32768 - min_delta[order])
@@ -943,11 +219,11 @@ static void silk_lsf2lpc(const int16_t nlsf[16], float lpcf[16], int order)
     for (k = 0; k < order; k++) {
         int index = nlsf[k] >> 8;
         int offset = nlsf[k] & 255;
-        int k2 = (order == 10) ? silk_lsf_ordering_nbmb[k] : silk_lsf_ordering_wb[k];
+        int k2 = (order == 10) ? ff_silk_lsf_ordering_nbmb[k] : ff_silk_lsf_ordering_wb[k];
 
         /* interpolate and round */
-        lsp[k2]  = silk_cosine[index] * 256;
-        lsp[k2] += (silk_cosine[index + 1] - silk_cosine[index]) * offset;
+        lsp[k2]  = ff_silk_cosine[index] * 256;
+        lsp[k2] += (ff_silk_cosine[index + 1] - ff_silk_cosine[index]) * offset;
         lsp[k2]  = (lsp[k2] + 4) >> 3;
     }
 
@@ -1030,15 +306,15 @@ static inline void silk_decode_lpc(SilkContext *s, SilkFrame *frame,
     *lpc_order = order = s->wb ? 16 : 10;
 
     /* obtain LSF stage-1 and stage-2 indices */
-    lsf_i1 = opus_rc_getsymbol(rc, silk_model_lsf_s1[s->wb][voiced]);
+    lsf_i1 = ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_s1[s->wb][voiced]);
     for (i = 0; i < order; i++) {
-        int index = s->wb ? silk_lsf_s2_model_sel_wb  [lsf_i1][i] :
-                            silk_lsf_s2_model_sel_nbmb[lsf_i1][i];
-        lsf_i2[i] = opus_rc_getsymbol(rc, silk_model_lsf_s2[index]) - 4;
+        int index = s->wb ? ff_silk_lsf_s2_model_sel_wb  [lsf_i1][i] :
+                            ff_silk_lsf_s2_model_sel_nbmb[lsf_i1][i];
+        lsf_i2[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_s2[index]) - 4;
         if (lsf_i2[i] == -4)
-            lsf_i2[i] -= opus_rc_getsymbol(rc, silk_model_lsf_s2_ext);
+            lsf_i2[i] -= ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_s2_ext);
         else if (lsf_i2[i] == 4)
-            lsf_i2[i] += opus_rc_getsymbol(rc, silk_model_lsf_s2_ext);
+            lsf_i2[i] += ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_s2_ext);
     }
 
     /* reverse the backwards-prediction step */
@@ -1051,16 +327,16 @@ static inline void silk_decode_lpc(SilkContext *s, SilkFrame *frame,
         lsf_res[i] = (lsf_res[i] * qstep) >> 16;
 
         if (i + 1 < order) {
-            int weight = s->wb ? silk_lsf_pred_weights_wb  [silk_lsf_weight_sel_wb  [lsf_i1][i]][i] :
-                                 silk_lsf_pred_weights_nbmb[silk_lsf_weight_sel_nbmb[lsf_i1][i]][i];
+            int weight = s->wb ? ff_silk_lsf_pred_weights_wb  [ff_silk_lsf_weight_sel_wb  [lsf_i1][i]][i] :
+                                 ff_silk_lsf_pred_weights_nbmb[ff_silk_lsf_weight_sel_nbmb[lsf_i1][i]][i];
             lsf_res[i] += (lsf_res[i+1] * weight) >> 8;
         }
     }
 
     /* reconstruct the NLSF coefficients from the supplied indices */
     for (i = 0; i < order; i++) {
-        const uint8_t * codebook = s->wb ? silk_lsf_codebook_wb  [lsf_i1] :
-                                           silk_lsf_codebook_nbmb[lsf_i1];
+        const uint8_t * codebook = s->wb ? ff_silk_lsf_codebook_wb  [lsf_i1] :
+                                           ff_silk_lsf_codebook_nbmb[lsf_i1];
         int cur, prev, next, weight_sq, weight, ipart, fpart, y, value;
 
         /* find the weight of the residual */
@@ -1081,14 +357,14 @@ static inline void silk_decode_lpc(SilkContext *s, SilkFrame *frame,
     }
 
     /* stabilize the NLSF coefficients */
-    silk_stabilize_lsf(nlsf, order, s->wb ? silk_lsf_min_spacing_wb :
-                                            silk_lsf_min_spacing_nbmb);
+    silk_stabilize_lsf(nlsf, order, s->wb ? ff_silk_lsf_min_spacing_wb :
+                                            ff_silk_lsf_min_spacing_nbmb);
 
     /* produce an interpolation for the first 2 subframes, */
     /* and then convert both sets of NLSFs to LPC coefficients */
     *has_lpc_leadin = 0;
     if (s->subframes == 4) {
-        int offset = opus_rc_getsymbol(rc, silk_model_lsf_interpolation_offset);
+        int offset = ff_opus_rc_dec_cdf(rc, ff_silk_model_lsf_interpolation_offset);
         if (offset != 4 && frame->coded) {
             *has_lpc_leadin = 1;
             if (offset != 0) {
@@ -1117,8 +393,8 @@ static inline void silk_count_children(OpusRangeCoder *rc, int model, int32_t to
                                        int32_t child[2])
 {
     if (total != 0) {
-        child[0] = opus_rc_getsymbol(rc,
-                       silk_model_pulse_location[model] + (((total - 1 + 5) * (total - 1)) >> 1));
+        child[0] = ff_opus_rc_dec_cdf(rc,
+                       ff_silk_model_pulse_location[model] + (((total - 1 + 5) * (total - 1)) >> 1));
         child[1] = total - child[0];
     } else {
         child[0] = 0;
@@ -1139,17 +415,17 @@ static inline void silk_decode_excitation(SilkContext *s, OpusRangeCoder *rc,
     int32_t excitation[320];    // Q23
 
     /* excitation parameters */
-    seed = opus_rc_getsymbol(rc, silk_model_lcg_seed);
-    shellblocks = silk_shell_blocks[s->bandwidth][s->subframes >> 2];
-    ratelevel = opus_rc_getsymbol(rc, silk_model_exc_rate[voiced]);
+    seed = ff_opus_rc_dec_cdf(rc, ff_silk_model_lcg_seed);
+    shellblocks = ff_silk_shell_blocks[s->bandwidth][s->subframes >> 2];
+    ratelevel = ff_opus_rc_dec_cdf(rc, ff_silk_model_exc_rate[voiced]);
 
     for (i = 0; i < shellblocks; i++) {
-        pulsecount[i] = opus_rc_getsymbol(rc, silk_model_pulse_count[ratelevel]);
+        pulsecount[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_pulse_count[ratelevel]);
         if (pulsecount[i] == 17) {
             while (pulsecount[i] == 17 && ++lsbcount[i] != 10)
-                pulsecount[i] = opus_rc_getsymbol(rc, silk_model_pulse_count[9]);
+                pulsecount[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_pulse_count[9]);
             if (lsbcount[i] == 10)
-                pulsecount[i] = opus_rc_getsymbol(rc, silk_model_pulse_count[10]);
+                pulsecount[i] = ff_opus_rc_dec_cdf(rc, ff_silk_model_pulse_count[10]);
         }
     }
 
@@ -1184,13 +460,13 @@ static inline void silk_decode_excitation(SilkContext *s, OpusRangeCoder *rc,
         int bit;
         for (bit = 0; bit < lsbcount[i >> 4]; bit++)
             excitation[i] = (excitation[i] << 1) |
-                            opus_rc_getsymbol(rc, silk_model_excitation_lsb);
+                            ff_opus_rc_dec_cdf(rc, ff_silk_model_excitation_lsb);
     }
 
     /* decode signs */
     for (i = 0; i < shellblocks << 4; i++) {
         if (excitation[i] != 0) {
-            int sign = opus_rc_getsymbol(rc, silk_model_excitation_sign[active +
+            int sign = ff_opus_rc_dec_cdf(rc, ff_silk_model_excitation_sign[active +
                                          voiced][qoffset_high][FFMIN(pulsecount[i >> 4], 6)]);
             if (sign == 0)
                 excitation[i] *= -1;
@@ -1200,7 +476,7 @@ static inline void silk_decode_excitation(SilkContext *s, OpusRangeCoder *rc,
     /* assemble the excitation */
     for (i = 0; i < shellblocks << 4; i++) {
         int value = excitation[i];
-        excitation[i] = value * 256 | silk_quant_offset[voiced][qoffset_high];
+        excitation[i] = value * 256 | ff_silk_quant_offset[voiced][qoffset_high];
         if (value < 0)      excitation[i] += 20;
         else if (value > 0) excitation[i] -= 20;
 
@@ -1245,30 +521,30 @@ static void silk_decode_frame(SilkContext *s, OpusRangeCoder *rc,
     /* obtain stereo weights */
     if (coded_channels == 2 && channel == 0) {
         int n, wi[2], ws[2], w[2];
-        n     = opus_rc_getsymbol(rc, silk_model_stereo_s1);
-        wi[0] = opus_rc_getsymbol(rc, silk_model_stereo_s2) + 3 * (n / 5);
-        ws[0] = opus_rc_getsymbol(rc, silk_model_stereo_s3);
-        wi[1] = opus_rc_getsymbol(rc, silk_model_stereo_s2) + 3 * (n % 5);
-        ws[1] = opus_rc_getsymbol(rc, silk_model_stereo_s3);
+        n     = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s1);
+        wi[0] = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s2) + 3 * (n / 5);
+        ws[0] = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s3);
+        wi[1] = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s2) + 3 * (n % 5);
+        ws[1] = ff_opus_rc_dec_cdf(rc, ff_silk_model_stereo_s3);
 
         for (i = 0; i < 2; i++)
-            w[i] = silk_stereo_weights[wi[i]] +
-                   (((silk_stereo_weights[wi[i] + 1] - silk_stereo_weights[wi[i]]) * 6554) >> 16)
+            w[i] = ff_silk_stereo_weights[wi[i]] +
+                   (((ff_silk_stereo_weights[wi[i] + 1] - ff_silk_stereo_weights[wi[i]]) * 6554) >> 16)
                     * (ws[i]*2 + 1);
 
         s->stereo_weights[0] = (w[0] - w[1]) / 8192.0;
         s->stereo_weights[1] = w[1]          / 8192.0;
 
         /* and read the mid-only flag */
-        s->midonly = active1 ? 0 : opus_rc_getsymbol(rc, silk_model_mid_only);
+        s->midonly = active1 ? 0 : ff_opus_rc_dec_cdf(rc, ff_silk_model_mid_only);
     }
 
     /* obtain frame type */
     if (!active) {
-        qoffset_high = opus_rc_getsymbol(rc, silk_model_frame_type_inactive);
+        qoffset_high = ff_opus_rc_dec_cdf(rc, ff_silk_model_frame_type_inactive);
         voiced = 0;
     } else {
-        int type = opus_rc_getsymbol(rc, silk_model_frame_type_active);
+        int type = ff_opus_rc_dec_cdf(rc, ff_silk_model_frame_type_active);
         qoffset_high = type & 1;
         voiced = type >> 1;
     }
@@ -1280,14 +556,14 @@ static void silk_decode_frame(SilkContext *s, OpusRangeCoder *rc,
 
         if (i == 0 && (frame_num == 0 || !frame->coded)) {
             /* gain is coded absolute */
-            int x = opus_rc_getsymbol(rc, silk_model_gain_highbits[active + voiced]);
-            log_gain = (x<<3) | opus_rc_getsymbol(rc, silk_model_gain_lowbits);
+            int x = ff_opus_rc_dec_cdf(rc, ff_silk_model_gain_highbits[active + voiced]);
+            log_gain = (x<<3) | ff_opus_rc_dec_cdf(rc, ff_silk_model_gain_lowbits);
 
             if (frame->coded)
                 log_gain = FFMAX(log_gain, frame->log_gain - 16);
         } else {
             /* gain is coded relative */
-            int delta_gain = opus_rc_getsymbol(rc, silk_model_gain_delta);
+            int delta_gain = ff_opus_rc_dec_cdf(rc, ff_silk_model_gain_delta);
             log_gain = av_clip_uintp2(FFMAX((delta_gain<<1) - 16,
                                      frame->log_gain + delta_gain - 4), 6);
         }
@@ -1313,7 +589,7 @@ static void silk_decode_frame(SilkContext *s, OpusRangeCoder *rc,
         const int8_t * offsets;
 
         if (!lag_absolute) {
-            int delta = opus_rc_getsymbol(rc, silk_model_pitch_delta);
+            int delta = ff_opus_rc_dec_cdf(rc, ff_silk_model_pitch_delta);
             if (delta)
                 primarylag = frame->primarylag + delta - 9;
             else
@@ -1323,48 +599,48 @@ static void silk_decode_frame(SilkContext *s, OpusRangeCoder *rc,
         if (lag_absolute) {
             /* primary lag is coded absolute */
             int highbits, lowbits;
-            static const uint16_t *model[] = {
-                silk_model_pitch_lowbits_nb, silk_model_pitch_lowbits_mb,
-                silk_model_pitch_lowbits_wb
+            static const uint16_t * const model[] = {
+                ff_silk_model_pitch_lowbits_nb, ff_silk_model_pitch_lowbits_mb,
+                ff_silk_model_pitch_lowbits_wb
             };
-            highbits = opus_rc_getsymbol(rc, silk_model_pitch_highbits);
-            lowbits  = opus_rc_getsymbol(rc, model[s->bandwidth]);
+            highbits = ff_opus_rc_dec_cdf(rc, ff_silk_model_pitch_highbits);
+            lowbits  = ff_opus_rc_dec_cdf(rc, model[s->bandwidth]);
 
-            primarylag = silk_pitch_min_lag[s->bandwidth] +
-                         highbits*silk_pitch_scale[s->bandwidth] + lowbits;
+            primarylag = ff_silk_pitch_min_lag[s->bandwidth] +
+                         highbits*ff_silk_pitch_scale[s->bandwidth] + lowbits;
         }
         frame->primarylag = primarylag;
 
         if (s->subframes == 2)
             offsets = (s->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
-                     ? silk_pitch_offset_nb10ms[opus_rc_getsymbol(rc,
-                                                silk_model_pitch_contour_nb10ms)]
-                     : silk_pitch_offset_mbwb10ms[opus_rc_getsymbol(rc,
-                                                silk_model_pitch_contour_mbwb10ms)];
+                     ? ff_silk_pitch_offset_nb10ms[ff_opus_rc_dec_cdf(rc,
+                                                ff_silk_model_pitch_contour_nb10ms)]
+                     : ff_silk_pitch_offset_mbwb10ms[ff_opus_rc_dec_cdf(rc,
+                                                ff_silk_model_pitch_contour_mbwb10ms)];
         else
             offsets = (s->bandwidth == OPUS_BANDWIDTH_NARROWBAND)
-                     ? silk_pitch_offset_nb20ms[opus_rc_getsymbol(rc,
-                                                silk_model_pitch_contour_nb20ms)]
-                     : silk_pitch_offset_mbwb20ms[opus_rc_getsymbol(rc,
-                                                silk_model_pitch_contour_mbwb20ms)];
+                     ? ff_silk_pitch_offset_nb20ms[ff_opus_rc_dec_cdf(rc,
+                                                ff_silk_model_pitch_contour_nb20ms)]
+                     : ff_silk_pitch_offset_mbwb20ms[ff_opus_rc_dec_cdf(rc,
+                                                ff_silk_model_pitch_contour_mbwb20ms)];
 
         for (i = 0; i < s->subframes; i++)
             sf[i].pitchlag = av_clip(primarylag + offsets[i],
-                                     silk_pitch_min_lag[s->bandwidth],
-                                     silk_pitch_max_lag[s->bandwidth]);
+                                     ff_silk_pitch_min_lag[s->bandwidth],
+                                     ff_silk_pitch_max_lag[s->bandwidth]);
 
         /* obtain LTP filter coefficients */
-        ltpfilter = opus_rc_getsymbol(rc, silk_model_ltp_filter);
+        ltpfilter = ff_opus_rc_dec_cdf(rc, ff_silk_model_ltp_filter);
         for (i = 0; i < s->subframes; i++) {
             int index, j;
-            static const uint16_t *filter_sel[] = {
-                silk_model_ltp_filter0_sel, silk_model_ltp_filter1_sel,
-                silk_model_ltp_filter2_sel
+            static const uint16_t * const filter_sel[] = {
+                ff_silk_model_ltp_filter0_sel, ff_silk_model_ltp_filter1_sel,
+                ff_silk_model_ltp_filter2_sel
             };
-            static const int8_t (*filter_taps[])[5] = {
-                silk_ltp_filter0_taps, silk_ltp_filter1_taps, silk_ltp_filter2_taps
+            static const int8_t (* const filter_taps[])[5] = {
+                ff_silk_ltp_filter0_taps, ff_silk_ltp_filter1_taps, ff_silk_ltp_filter2_taps
             };
-            index = opus_rc_getsymbol(rc, filter_sel[ltpfilter]);
+            index = ff_opus_rc_dec_cdf(rc, filter_sel[ltpfilter]);
             for (j = 0; j < 5; j++)
                 sf[i].ltptaps[j] = filter_taps[ltpfilter][index][j] / 128.0f;
         }
@@ -1372,8 +648,8 @@ static void silk_decode_frame(SilkContext *s, OpusRangeCoder *rc,
 
     /* obtain LTP scale factor */
     if (voiced && frame_num == 0)
-        ltpscale = silk_ltp_scale_factor[opus_rc_getsymbol(rc,
-                                         silk_model_ltp_scale_index)] / 16384.0f;
+        ltpscale = ff_silk_ltp_scale_factor[ff_opus_rc_dec_cdf(rc,
+                                         ff_silk_model_ltp_scale_index)] / 16384.0f;
     else ltpscale = 15565.0f/16384.0f;
 
     /* generate the excitation signal for the entire frame */
@@ -1455,7 +731,7 @@ static void silk_unmix_ms(SilkContext *s, float *l, float *r)
     float w1_prev = s->prev_stereo_weights[1];
     float w0      = s->stereo_weights[0];
     float w1      = s->stereo_weights[1];
-    int n1        = silk_stereo_interp_len[s->bandwidth];
+    int n1        = ff_silk_stereo_interp_len[s->bandwidth];
     int i;
 
     for (i = 0; i < n1; i++) {
@@ -1526,11 +802,11 @@ int ff_silk_decode_superframe(SilkContext *s, OpusRangeCoder *rc,
     /* read the LP-layer header bits */
     for (i = 0; i < coded_channels; i++) {
         for (j = 0; j < nb_frames; j++)
-            active[i][j] = opus_rc_p2model(rc, 1);
+            active[i][j] = ff_opus_rc_dec_log(rc, 1);
 
-        redundancy[i] = opus_rc_p2model(rc, 1);
+        redundancy[i] = ff_opus_rc_dec_log(rc, 1);
         if (redundancy[i]) {
-            av_log(s->avctx, AV_LOG_ERROR, "LBRR frames present; this is unsupported\n");
+            avpriv_report_missing_feature(s->avctx, "LBRR frames");
             return AVERROR_PATCHWELCOME;
         }
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/opusdec.c b/mythtv/external/FFmpeg/libavcodec/opusdec.c
index 95a2435e539..5a7ba9dbb43 100644
--- a/mythtv/external/FFmpeg/libavcodec/opusdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/opusdec.c
@@ -47,6 +47,8 @@
 #include "internal.h"
 #include "mathops.h"
 #include "opus.h"
+#include "opustab.h"
+#include "opus_celt.h"
 
 static const uint16_t silk_frame_duration_ms[16] = {
     10, 20, 40, 60,
@@ -62,8 +64,6 @@ static const int silk_resample_delay[] = {
     4, 8, 11, 11, 11
 };
 
-static const uint8_t celt_band_end[] = { 13, 17, 17, 19, 21 };
-
 static int get_silk_samplerate(int config)
 {
     if (config < 4)
@@ -73,32 +73,6 @@ static int get_silk_samplerate(int config)
     return 16000;
 }
 
-/**
- * Range decoder
- */
-static int opus_rc_init(OpusRangeCoder *rc, const uint8_t *data, int size)
-{
-    int ret = init_get_bits8(&rc->gb, data, size);
-    if (ret < 0)
-        return ret;
-
-    rc->range = 128;
-    rc->value = 127 - get_bits(&rc->gb, 7);
-    rc->total_read_bits = 9;
-    opus_rc_normalize(rc);
-
-    return 0;
-}
-
-static void opus_raw_init(OpusRangeCoder *rc, const uint8_t *rightend,
-                          unsigned int bytes)
-{
-    rc->rb.position = rightend;
-    rc->rb.bytes    = bytes;
-    rc->rb.cachelen = 0;
-    rc->rb.cacheval = 0;
-}
-
 static void opus_fade(float *out,
                       const float *in1, const float *in2,
                       const float *window, int len)
@@ -178,22 +152,15 @@ static int opus_init_resample(OpusStreamContext *s)
 
 static int opus_decode_redundancy(OpusStreamContext *s, const uint8_t *data, int size)
 {
-    int ret;
-    enum OpusBandwidth bw = s->packet.bandwidth;
-
-    if (s->packet.mode == OPUS_MODE_SILK &&
-        bw == OPUS_BANDWIDTH_MEDIUMBAND)
-        bw = OPUS_BANDWIDTH_WIDEBAND;
-
-    ret = opus_rc_init(&s->redundancy_rc, data, size);
+    int ret = ff_opus_rc_dec_init(&s->redundancy_rc, data, size);
     if (ret < 0)
         goto fail;
-    opus_raw_init(&s->redundancy_rc, data + size, size);
+    ff_opus_rc_dec_raw_init(&s->redundancy_rc, data + size, size);
 
     ret = ff_celt_decode_frame(s->celt, &s->redundancy_rc,
                                s->redundancy_output,
                                s->packet.stereo + 1, 240,
-                               0, celt_band_end[s->packet.bandwidth]);
+                               0, ff_celt_band_end[s->packet.bandwidth]);
     if (ret < 0)
         goto fail;
 
@@ -211,7 +178,7 @@ static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size
     int ret, i, consumed;
     int delayed_samples = s->delayed_samples;
 
-    ret = opus_rc_init(&s->rc, data, size);
+    ret = ff_opus_rc_dec_init(&s->rc, data, size);
     if (ret < 0)
         return ret;
 
@@ -246,15 +213,15 @@ static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size
     // decode redundancy information
     consumed = opus_rc_tell(&s->rc);
     if (s->packet.mode == OPUS_MODE_HYBRID && consumed + 37 <= size * 8)
-        redundancy = opus_rc_p2model(&s->rc, 12);
+        redundancy = ff_opus_rc_dec_log(&s->rc, 12);
     else if (s->packet.mode == OPUS_MODE_SILK && consumed + 17 <= size * 8)
         redundancy = 1;
 
     if (redundancy) {
-        redundancy_pos = opus_rc_p2model(&s->rc, 1);
+        redundancy_pos = ff_opus_rc_dec_log(&s->rc, 1);
 
         if (s->packet.mode == OPUS_MODE_HYBRID)
-            redundancy_size = opus_rc_unimodel(&s->rc, 256) + 2;
+            redundancy_size = ff_opus_rc_dec_uint(&s->rc, 256) + 2;
         else
             redundancy_size = size - (consumed + 7) / 8;
         size -= redundancy_size;
@@ -298,13 +265,13 @@ static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size
             }
         }
 
-        opus_raw_init(&s->rc, data + size, size);
+        ff_opus_rc_dec_raw_init(&s->rc, data + size, size);
 
         ret = ff_celt_decode_frame(s->celt, &s->rc, dst,
                                    s->packet.stereo + 1,
                                    s->packet.frame_duration,
                                    (s->packet.mode == OPUS_MODE_HYBRID) ? 17 : 0,
-                                   celt_band_end[s->packet.bandwidth]);
+                                   ff_celt_band_end[s->packet.bandwidth]);
         if (ret < 0)
             return ret;
 
@@ -672,7 +639,6 @@ static av_cold int opus_decode_init(AVCodecContext *avctx)
     /* find out the channel configuration */
     ret = ff_opus_parse_extradata(avctx, c);
     if (ret < 0) {
-        av_freep(&c->channel_maps);
         av_freep(&c->fdsp);
         return ret;
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/opusenc.c b/mythtv/external/FFmpeg/libavcodec/opusenc.c
new file mode 100644
index 00000000000..79d20dc6e69
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opusenc.c
@@ -0,0 +1,1163 @@
+/*
+ * Opus encoder
+ * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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 "opusenc.h"
+#include "opus_pvq.h"
+#include "opusenc_psy.h"
+#include "opustab.h"
+
+#include "libavutil/float_dsp.h"
+#include "libavutil/opt.h"
+#include "internal.h"
+#include "bytestream.h"
+#include "audio_frame_queue.h"
+
+typedef struct OpusEncContext {
+    AVClass *av_class;
+    OpusEncOptions options;
+    OpusPsyContext psyctx;
+    AVCodecContext *avctx;
+    AudioFrameQueue afq;
+    AVFloatDSPContext *dsp;
+    MDCT15Context *mdct[CELT_BLOCK_NB];
+    CeltPVQ *pvq;
+    struct FFBufQueue bufqueue;
+
+    uint8_t enc_id[64];
+    int enc_id_bits;
+
+    OpusPacketInfo packet;
+
+    int channels;
+
+    CeltFrame *frame;
+    OpusRangeCoder *rc;
+
+    /* Actual energy the decoder will have */
+    float last_quantized_energy[OPUS_MAX_CHANNELS][CELT_MAX_BANDS];
+
+    DECLARE_ALIGNED(32, float, scratch)[2048];
+} OpusEncContext;
+
+static void opus_write_extradata(AVCodecContext *avctx)
+{
+    uint8_t *bs = avctx->extradata;
+
+    bytestream_put_buffer(&bs, "OpusHead", 8);
+    bytestream_put_byte  (&bs, 0x1);
+    bytestream_put_byte  (&bs, avctx->channels);
+    bytestream_put_le16  (&bs, avctx->initial_padding);
+    bytestream_put_le32  (&bs, avctx->sample_rate);
+    bytestream_put_le16  (&bs, 0x0);
+    bytestream_put_byte  (&bs, 0x0); /* Default layout */
+}
+
+static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed)
+{
+    int i, tmp = 0x0, extended_toc = 0;
+    static const int toc_cfg[][OPUS_MODE_NB][OPUS_BANDWITH_NB] = {
+        /*  Silk                    Hybrid                  Celt                    Layer     */
+        /*  NB  MB  WB SWB  FB      NB  MB  WB SWB  FB      NB  MB  WB SWB  FB      Bandwidth */
+        { {  0,  0,  0,  0,  0 }, {  0,  0,  0,  0,  0 }, { 17,  0, 21, 25, 29 } }, /* 2.5 ms */
+        { {  0,  0,  0,  0,  0 }, {  0,  0,  0,  0,  0 }, { 18,  0, 22, 26, 30 } }, /*   5 ms */
+        { {  1,  5,  9,  0,  0 }, {  0,  0,  0, 13, 15 }, { 19,  0, 23, 27, 31 } }, /*  10 ms */
+        { {  2,  6, 10,  0,  0 }, {  0,  0,  0, 14, 16 }, { 20,  0, 24, 28, 32 } }, /*  20 ms */
+        { {  3,  7, 11,  0,  0 }, {  0,  0,  0,  0,  0 }, {  0,  0,  0,  0,  0 } }, /*  40 ms */
+        { {  4,  8, 12,  0,  0 }, {  0,  0,  0,  0,  0 }, {  0,  0,  0,  0,  0 } }, /*  60 ms */
+    };
+    int cfg = toc_cfg[s->packet.framesize][s->packet.mode][s->packet.bandwidth];
+    *fsize_needed = 0;
+    if (!cfg)
+        return 1;
+    if (s->packet.frames == 2) {                                       /* 2 packets */
+        if (s->frame[0].framebits == s->frame[1].framebits) {          /* same size */
+            tmp = 0x1;
+        } else {                                                  /* different size */
+            tmp = 0x2;
+            *fsize_needed = 1;                     /* put frame sizes in the packet */
+        }
+    } else if (s->packet.frames > 2) {
+        tmp = 0x3;
+        extended_toc = 1;
+    }
+    tmp |= (s->channels > 1) << 2;                                /* Stereo or mono */
+    tmp |= (cfg - 1)         << 3;                           /* codec configuration */
+    *toc++ = tmp;
+    if (extended_toc) {
+        for (i = 0; i < (s->packet.frames - 1); i++)
+            *fsize_needed |= (s->frame[i].framebits != s->frame[i + 1].framebits);
+        tmp = (*fsize_needed) << 7;                                /* vbr flag */
+        tmp |= (0) << 6;                                       /* padding flag */
+        tmp |= s->packet.frames;
+        *toc++ = tmp;
+    }
+    *size = 1 + extended_toc;
+    return 0;
+}
+
+static void celt_frame_setup_input(OpusEncContext *s, CeltFrame *f)
+{
+    int sf, ch;
+    AVFrame *cur = NULL;
+    const int subframesize = s->avctx->frame_size;
+    int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
+
+    cur = ff_bufqueue_get(&s->bufqueue);
+
+    for (ch = 0; ch < f->channels; ch++) {
+        CeltBlock *b = &f->block[ch];
+        const void *input = cur->extended_data[ch];
+        size_t bps = av_get_bytes_per_sample(cur->format);
+        memcpy(b->overlap, input, bps*cur->nb_samples);
+    }
+
+    av_frame_free(&cur);
+
+    for (sf = 0; sf < subframes; sf++) {
+        if (sf != (subframes - 1))
+            cur = ff_bufqueue_get(&s->bufqueue);
+        else
+            cur = ff_bufqueue_peek(&s->bufqueue, 0);
+
+        for (ch = 0; ch < f->channels; ch++) {
+            CeltBlock *b = &f->block[ch];
+            const void *input = cur->extended_data[ch];
+            const size_t bps  = av_get_bytes_per_sample(cur->format);
+            const size_t left = (subframesize - cur->nb_samples)*bps;
+            const size_t len  = FFMIN(subframesize, cur->nb_samples)*bps;
+            memcpy(&b->samples[sf*subframesize], input, len);
+            memset(&b->samples[cur->nb_samples], 0, left);
+        }
+
+        /* Last frame isn't popped off and freed yet - we need it for overlap */
+        if (sf != (subframes - 1))
+            av_frame_free(&cur);
+    }
+}
+
+/* Apply the pre emphasis filter */
+static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f)
+{
+    int i, sf, ch;
+    const int subframesize = s->avctx->frame_size;
+    const int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
+
+    /* Filter overlap */
+    for (ch = 0; ch < f->channels; ch++) {
+        CeltBlock *b = &f->block[ch];
+        float m = b->emph_coeff;
+        for (i = 0; i < CELT_OVERLAP; i++) {
+            float sample = b->overlap[i];
+            b->overlap[i] = sample - m;
+            m = sample * CELT_EMPH_COEFF;
+        }
+        b->emph_coeff = m;
+    }
+
+    /* Filter the samples but do not update the last subframe's coeff - overlap ^^^ */
+    for (sf = 0; sf < subframes; sf++) {
+        for (ch = 0; ch < f->channels; ch++) {
+            CeltBlock *b = &f->block[ch];
+            float m = b->emph_coeff;
+            for (i = 0; i < subframesize; i++) {
+                float sample = b->samples[sf*subframesize + i];
+                b->samples[sf*subframesize + i] = sample - m;
+                m = sample * CELT_EMPH_COEFF;
+            }
+            if (sf != (subframes - 1))
+                b->emph_coeff = m;
+        }
+    }
+}
+
+/* Create the window and do the mdct */
+static void celt_frame_mdct(OpusEncContext *s, CeltFrame *f)
+{
+    int i, j, t, ch;
+    float *win = s->scratch, *temp = s->scratch + 1920;
+
+    if (f->transient) {
+        for (ch = 0; ch < f->channels; ch++) {
+            CeltBlock *b = &f->block[ch];
+            float *src1 = b->overlap;
+            for (t = 0; t < f->blocks; t++) {
+                float *src2 = &b->samples[CELT_OVERLAP*t];
+                s->dsp->vector_fmul(win, src1, ff_celt_window, 128);
+                s->dsp->vector_fmul_reverse(&win[CELT_OVERLAP], src2,
+                                            ff_celt_window - 8, 128);
+                src1 = src2;
+                s->mdct[0]->mdct(s->mdct[0], b->coeffs + t, win, f->blocks);
+            }
+        }
+    } else {
+        int blk_len = OPUS_BLOCK_SIZE(f->size), wlen = OPUS_BLOCK_SIZE(f->size + 1);
+        int rwin = blk_len - CELT_OVERLAP, lap_dst = (wlen - blk_len - CELT_OVERLAP) >> 1;
+        memset(win, 0, wlen*sizeof(float));
+        for (ch = 0; ch < f->channels; ch++) {
+            CeltBlock *b = &f->block[ch];
+
+            /* Overlap */
+            s->dsp->vector_fmul(temp, b->overlap, ff_celt_window, 128);
+            memcpy(win + lap_dst, temp, CELT_OVERLAP*sizeof(float));
+
+            /* Samples, flat top window */
+            memcpy(&win[lap_dst + CELT_OVERLAP], b->samples, rwin*sizeof(float));
+
+            /* Samples, windowed */
+            s->dsp->vector_fmul_reverse(temp, b->samples + rwin,
+                                        ff_celt_window - 8, 128);
+            memcpy(win + lap_dst + blk_len, temp, CELT_OVERLAP*sizeof(float));
+
+            s->mdct[f->size]->mdct(s->mdct[f->size], b->coeffs, win, 1);
+        }
+    }
+
+    for (ch = 0; ch < f->channels; ch++) {
+        CeltBlock *block = &f->block[ch];
+        for (i = 0; i < CELT_MAX_BANDS; i++) {
+            float ener = 0.0f;
+            int band_offset = ff_celt_freq_bands[i] << f->size;
+            int band_size   = ff_celt_freq_range[i] << f->size;
+            float *coeffs   = &block->coeffs[band_offset];
+
+            for (j = 0; j < band_size; j++)
+                ener += coeffs[j]*coeffs[j];
+
+            block->lin_energy[i] = sqrtf(ener) + FLT_EPSILON;
+            ener = 1.0f/block->lin_energy[i];
+
+            for (j = 0; j < band_size; j++)
+                coeffs[j] *= ener;
+
+            block->energy[i] = log2f(block->lin_energy[i]) - ff_celt_mean_energy[i];
+
+            /* CELT_ENERGY_SILENCE is what the decoder uses and its not -infinity */
+            block->energy[i] = FFMAX(block->energy[i], CELT_ENERGY_SILENCE);
+        }
+    }
+}
+
+static void celt_enc_tf(OpusRangeCoder *rc, CeltFrame *f)
+{
+    int i, tf_select = 0, diff = 0, tf_changed = 0, tf_select_needed;
+    int bits = f->transient ? 2 : 4;
+
+    tf_select_needed = ((f->size && (opus_rc_tell(rc) + bits + 1) <= f->framebits));
+
+    for (i = f->start_band; i < f->end_band; i++) {
+        if ((opus_rc_tell(rc) + bits + tf_select_needed) <= f->framebits) {
+            const int tbit = (diff ^ 1) == f->tf_change[i];
+            ff_opus_rc_enc_log(rc, tbit, bits);
+            diff ^= tbit;
+            tf_changed |= diff;
+        }
+        bits = f->transient ? 4 : 5;
+    }
+
+    if (tf_select_needed && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=
+                            ff_celt_tf_select[f->size][f->transient][1][tf_changed]) {
+        ff_opus_rc_enc_log(rc, f->tf_select, 1);
+        tf_select = f->tf_select;
+    }
+
+    for (i = f->start_band; i < f->end_band; i++)
+        f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];
+}
+
+void ff_celt_enc_bitalloc(OpusRangeCoder *rc, CeltFrame *f)
+{
+    int i, j, low, high, total, done, bandbits, remaining, tbits_8ths;
+    int skip_startband      = f->start_band;
+    int skip_bit            = 0;
+    int intensitystereo_bit = 0;
+    int dualstereo_bit      = 0;
+    int dynalloc            = 6;
+    int extrabits           = 0;
+
+    int *cap = f->caps;
+    int boost[CELT_MAX_BANDS];
+    int trim_offset[CELT_MAX_BANDS];
+    int threshold[CELT_MAX_BANDS];
+    int bits1[CELT_MAX_BANDS];
+    int bits2[CELT_MAX_BANDS];
+
+    /* Tell the spread to the decoder */
+    if (opus_rc_tell(rc) + 4 <= f->framebits)
+        ff_opus_rc_enc_cdf(rc, f->spread, ff_celt_model_spread);
+    else
+        f->spread = CELT_SPREAD_NORMAL;
+
+    /* Generate static allocation caps */
+    for (i = 0; i < CELT_MAX_BANDS; i++) {
+        cap[i] = (ff_celt_static_caps[f->size][f->channels - 1][i] + 64)
+                 * ff_celt_freq_range[i] << (f->channels - 1) << f->size >> 2;
+    }
+
+    /* Band boosts */
+    tbits_8ths = f->framebits << 3;
+    for (i = f->start_band; i < f->end_band; i++) {
+        int quanta, b_dynalloc, boost_amount = f->alloc_boost[i];
+
+        boost[i] = 0;
+
+        quanta = ff_celt_freq_range[i] << (f->channels - 1) << f->size;
+        quanta = FFMIN(quanta << 3, FFMAX(6 << 3, quanta));
+        b_dynalloc = dynalloc;
+
+        while (opus_rc_tell_frac(rc) + (b_dynalloc << 3) < tbits_8ths && boost[i] < cap[i]) {
+            int is_boost = boost_amount--;
+
+            ff_opus_rc_enc_log(rc, is_boost, b_dynalloc);
+            if (!is_boost)
+                break;
+
+            boost[i]   += quanta;
+            tbits_8ths -= quanta;
+
+            b_dynalloc = 1;
+        }
+
+        if (boost[i])
+            dynalloc = FFMAX(2, dynalloc - 1);
+    }
+
+    /* Put allocation trim */
+    if (opus_rc_tell_frac(rc) + (6 << 3) <= tbits_8ths)
+        ff_opus_rc_enc_cdf(rc, f->alloc_trim, ff_celt_model_alloc_trim);
+
+    /* Anti-collapse bit reservation */
+    tbits_8ths = (f->framebits << 3) - opus_rc_tell_frac(rc) - 1;
+    f->anticollapse_needed = 0;
+    if (f->transient && f->size >= 2 && tbits_8ths >= ((f->size + 2) << 3))
+        f->anticollapse_needed = 1 << 3;
+    tbits_8ths -= f->anticollapse_needed;
+
+    /* Band skip bit reservation */
+    if (tbits_8ths >= 1 << 3)
+        skip_bit = 1 << 3;
+    tbits_8ths -= skip_bit;
+
+    /* Intensity/dual stereo bit reservation */
+    if (f->channels == 2) {
+        intensitystereo_bit = ff_celt_log2_frac[f->end_band - f->start_band];
+        if (intensitystereo_bit <= tbits_8ths) {
+            tbits_8ths -= intensitystereo_bit;
+            if (tbits_8ths >= 1 << 3) {
+                dualstereo_bit = 1 << 3;
+                tbits_8ths -= 1 << 3;
+            }
+        } else {
+            intensitystereo_bit = 0;
+        }
+    }
+
+    /* Trim offsets */
+    for (i = f->start_band; i < f->end_band; i++) {
+        int trim     = f->alloc_trim - 5 - f->size;
+        int band     = ff_celt_freq_range[i] * (f->end_band - i - 1);
+        int duration = f->size + 3;
+        int scale    = duration + f->channels - 1;
+
+        /* PVQ minimum allocation threshold, below this value the band is
+         * skipped */
+        threshold[i] = FFMAX(3 * ff_celt_freq_range[i] << duration >> 4,
+                             f->channels << 3);
+
+        trim_offset[i] = trim * (band << scale) >> 6;
+
+        if (ff_celt_freq_range[i] << f->size == 1)
+            trim_offset[i] -= f->channels << 3;
+    }
+
+    /* Bisection */
+    low  = 1;
+    high = CELT_VECTORS - 1;
+    while (low <= high) {
+        int center = (low + high) >> 1;
+        done = total = 0;
+
+        for (i = f->end_band - 1; i >= f->start_band; i--) {
+            bandbits = ff_celt_freq_range[i] * ff_celt_static_alloc[center][i]
+                       << (f->channels - 1) << f->size >> 2;
+
+            if (bandbits)
+                bandbits = FFMAX(0, bandbits + trim_offset[i]);
+            bandbits += boost[i];
+
+            if (bandbits >= threshold[i] || done) {
+                done = 1;
+                total += FFMIN(bandbits, cap[i]);
+            } else if (bandbits >= f->channels << 3)
+                total += f->channels << 3;
+        }
+
+        if (total > tbits_8ths)
+            high = center - 1;
+        else
+            low = center + 1;
+    }
+    high = low--;
+
+    /* Bisection */
+    for (i = f->start_band; i < f->end_band; i++) {
+        bits1[i] = ff_celt_freq_range[i] * ff_celt_static_alloc[low][i]
+                   << (f->channels - 1) << f->size >> 2;
+        bits2[i] = high >= CELT_VECTORS ? cap[i] :
+                   ff_celt_freq_range[i] * ff_celt_static_alloc[high][i]
+                   << (f->channels - 1) << f->size >> 2;
+
+        if (bits1[i])
+            bits1[i] = FFMAX(0, bits1[i] + trim_offset[i]);
+        if (bits2[i])
+            bits2[i] = FFMAX(0, bits2[i] + trim_offset[i]);
+        if (low)
+            bits1[i] += boost[i];
+        bits2[i] += boost[i];
+
+        if (boost[i])
+            skip_startband = i;
+        bits2[i] = FFMAX(0, bits2[i] - bits1[i]);
+    }
+
+    /* Bisection */
+    low  = 0;
+    high = 1 << CELT_ALLOC_STEPS;
+    for (i = 0; i < CELT_ALLOC_STEPS; i++) {
+        int center = (low + high) >> 1;
+        done = total = 0;
+
+        for (j = f->end_band - 1; j >= f->start_band; j--) {
+            bandbits = bits1[j] + (center * bits2[j] >> CELT_ALLOC_STEPS);
+
+            if (bandbits >= threshold[j] || done) {
+                done = 1;
+                total += FFMIN(bandbits, cap[j]);
+            } else if (bandbits >= f->channels << 3)
+                total += f->channels << 3;
+        }
+        if (total > tbits_8ths)
+            high = center;
+        else
+            low = center;
+    }
+
+    /* Bisection */
+    done = total = 0;
+    for (i = f->end_band - 1; i >= f->start_band; i--) {
+        bandbits = bits1[i] + (low * bits2[i] >> CELT_ALLOC_STEPS);
+
+        if (bandbits >= threshold[i] || done)
+            done = 1;
+        else
+            bandbits = (bandbits >= f->channels << 3) ?
+                       f->channels << 3 : 0;
+
+        bandbits     = FFMIN(bandbits, cap[i]);
+        f->pulses[i] = bandbits;
+        total      += bandbits;
+    }
+
+    /* Band skipping */
+    for (f->coded_bands = f->end_band; ; f->coded_bands--) {
+        int allocation;
+        j = f->coded_bands - 1;
+
+        if (j == skip_startband) {
+            /* all remaining bands are not skipped */
+            tbits_8ths += skip_bit;
+            break;
+        }
+
+        /* determine the number of bits available for coding "do not skip" markers */
+        remaining   = tbits_8ths - total;
+        bandbits    = remaining / (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
+        remaining  -= bandbits  * (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
+        allocation  = f->pulses[j] + bandbits * ff_celt_freq_range[j]
+                      + FFMAX(0, remaining - (ff_celt_freq_bands[j] - ff_celt_freq_bands[f->start_band]));
+
+        /* a "do not skip" marker is only coded if the allocation is
+           above the chosen threshold */
+        if (allocation >= FFMAX(threshold[j], (f->channels + 1) << 3)) {
+            const int do_not_skip = f->coded_bands <= f->skip_band_floor;
+            ff_opus_rc_enc_log(rc, do_not_skip, 1);
+            if (do_not_skip)
+                break;
+
+            total      += 1 << 3;
+            allocation -= 1 << 3;
+        }
+
+        /* the band is skipped, so reclaim its bits */
+        total -= f->pulses[j];
+        if (intensitystereo_bit) {
+            total -= intensitystereo_bit;
+            intensitystereo_bit = ff_celt_log2_frac[j - f->start_band];
+            total += intensitystereo_bit;
+        }
+
+        total += f->pulses[j] = (allocation >= f->channels << 3) ? f->channels << 3 : 0;
+    }
+
+    /* Encode stereo flags */
+    if (intensitystereo_bit) {
+        f->intensity_stereo = FFMIN(f->intensity_stereo, f->coded_bands);
+        ff_opus_rc_enc_uint(rc, f->intensity_stereo, f->coded_bands + 1 - f->start_band);
+    }
+    if (f->intensity_stereo <= f->start_band)
+        tbits_8ths += dualstereo_bit; /* no intensity stereo means no dual stereo */
+    else if (dualstereo_bit)
+        ff_opus_rc_enc_log(rc, f->dual_stereo, 1);
+
+    /* Supply the remaining bits in this frame to lower bands */
+    remaining = tbits_8ths - total;
+    bandbits  = remaining / (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
+    remaining -= bandbits * (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
+    for (i = f->start_band; i < f->coded_bands; i++) {
+        int bits = FFMIN(remaining, ff_celt_freq_range[i]);
+
+        f->pulses[i] += bits + bandbits * ff_celt_freq_range[i];
+        remaining    -= bits;
+    }
+
+    /* Finally determine the allocation */
+    for (i = f->start_band; i < f->coded_bands; i++) {
+        int N = ff_celt_freq_range[i] << f->size;
+        int prev_extra = extrabits;
+        f->pulses[i] += extrabits;
+
+        if (N > 1) {
+            int dof;        // degrees of freedom
+            int temp;       // dof * channels * log(dof)
+            int offset;     // fine energy quantization offset, i.e.
+                            // extra bits assigned over the standard
+                            // totalbits/dof
+            int fine_bits, max_bits;
+
+            extrabits = FFMAX(0, f->pulses[i] - cap[i]);
+            f->pulses[i] -= extrabits;
+
+            /* intensity stereo makes use of an extra degree of freedom */
+            dof = N * f->channels + (f->channels == 2 && N > 2 && !f->dual_stereo && i < f->intensity_stereo);
+            temp = dof * (ff_celt_log_freq_range[i] + (f->size << 3));
+            offset = (temp >> 1) - dof * CELT_FINE_OFFSET;
+            if (N == 2) /* dof=2 is the only case that doesn't fit the model */
+                offset += dof << 1;
+
+            /* grant an additional bias for the first and second pulses */
+            if (f->pulses[i] + offset < 2 * (dof << 3))
+                offset += temp >> 2;
+            else if (f->pulses[i] + offset < 3 * (dof << 3))
+                offset += temp >> 3;
+
+            fine_bits = (f->pulses[i] + offset + (dof << 2)) / (dof << 3);
+            max_bits  = FFMIN((f->pulses[i] >> 3) >> (f->channels - 1), CELT_MAX_FINE_BITS);
+
+            max_bits  = FFMAX(max_bits, 0);
+
+            f->fine_bits[i] = av_clip(fine_bits, 0, max_bits);
+
+            /* if fine_bits was rounded down or capped,
+               give priority for the final fine energy pass */
+            f->fine_priority[i] = (f->fine_bits[i] * (dof << 3) >= f->pulses[i] + offset);
+
+            /* the remaining bits are assigned to PVQ */
+            f->pulses[i] -= f->fine_bits[i] << (f->channels - 1) << 3;
+        } else {
+            /* all bits go to fine energy except for the sign bit */
+            extrabits = FFMAX(0, f->pulses[i] - (f->channels << 3));
+            f->pulses[i] -= extrabits;
+            f->fine_bits[i] = 0;
+            f->fine_priority[i] = 1;
+        }
+
+        /* hand back a limited number of extra fine energy bits to this band */
+        if (extrabits > 0) {
+            int fineextra = FFMIN(extrabits >> (f->channels + 2),
+                                  CELT_MAX_FINE_BITS - f->fine_bits[i]);
+            f->fine_bits[i] += fineextra;
+
+            fineextra <<= f->channels + 2;
+            f->fine_priority[i] = (fineextra >= extrabits - prev_extra);
+            extrabits -= fineextra;
+        }
+    }
+    f->remaining = extrabits;
+
+    /* skipped bands dedicate all of their bits for fine energy */
+    for (; i < f->end_band; i++) {
+        f->fine_bits[i]     = f->pulses[i] >> (f->channels - 1) >> 3;
+        f->pulses[i]        = 0;
+        f->fine_priority[i] = f->fine_bits[i] < 1;
+    }
+}
+
+static void celt_enc_quant_pfilter(OpusRangeCoder *rc, CeltFrame *f)
+{
+    float gain = f->pf_gain;
+    int i, txval, octave = f->pf_octave, period = f->pf_period, tapset = f->pf_tapset;
+
+    ff_opus_rc_enc_log(rc, f->pfilter, 1);
+    if (!f->pfilter)
+        return;
+
+    /* Octave */
+    txval = FFMIN(octave, 6);
+    ff_opus_rc_enc_uint(rc, txval, 6);
+    octave = txval;
+    /* Period */
+    txval = av_clip(period - (16 << octave) + 1, 0, (1 << (4 + octave)) - 1);
+    ff_opus_rc_put_raw(rc, period, 4 + octave);
+    period = txval + (16 << octave) - 1;
+    /* Gain */
+    txval = FFMIN(((int)(gain / 0.09375f)) - 1, 7);
+    ff_opus_rc_put_raw(rc, txval, 3);
+    gain   = 0.09375f * (txval + 1);
+    /* Tapset */
+    if ((opus_rc_tell(rc) + 2) <= f->framebits)
+        ff_opus_rc_enc_cdf(rc, tapset, ff_celt_model_tapset);
+    else
+        tapset = 0;
+    /* Finally create the coeffs */
+    for (i = 0; i < 2; i++) {
+        CeltBlock *block = &f->block[i];
+
+        block->pf_period_new = FFMAX(period, CELT_POSTFILTER_MINPERIOD);
+        block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
+        block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
+        block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
+    }
+}
+
+static void exp_quant_coarse(OpusRangeCoder *rc, CeltFrame *f,
+                             float last_energy[][CELT_MAX_BANDS], int intra)
+{
+    int i, ch;
+    float alpha, beta, prev[2] = { 0, 0 };
+    const uint8_t *pmod = ff_celt_coarse_energy_dist[f->size][intra];
+
+    /* Inter is really just differential coding */
+    if (opus_rc_tell(rc) + 3 <= f->framebits)
+        ff_opus_rc_enc_log(rc, intra, 3);
+    else
+        intra = 0;
+
+    if (intra) {
+        alpha = 0.0f;
+        beta  = 1.0f - (4915.0f/32768.0f);
+    } else {
+        alpha = ff_celt_alpha_coef[f->size];
+        beta  = ff_celt_beta_coef[f->size];
+    }
+
+    for (i = f->start_band; i < f->end_band; i++) {
+        for (ch = 0; ch < f->channels; ch++) {
+            CeltBlock *block = &f->block[ch];
+            const int left = f->framebits - opus_rc_tell(rc);
+            const float last = FFMAX(-9.0f, last_energy[ch][i]);
+            float diff = block->energy[i] - prev[ch] - last*alpha;
+            int q_en = lrintf(diff);
+            if (left >= 15) {
+                ff_opus_rc_enc_laplace(rc, &q_en, pmod[i << 1] << 7, pmod[(i << 1) + 1] << 6);
+            } else if (left >= 2) {
+                q_en = av_clip(q_en, -1, 1);
+                ff_opus_rc_enc_cdf(rc, 2*q_en + 3*(q_en < 0), ff_celt_model_energy_small);
+            } else if (left >= 1) {
+                q_en = av_clip(q_en, -1, 0);
+                ff_opus_rc_enc_log(rc, (q_en & 1), 1);
+            } else q_en = -1;
+
+            block->error_energy[i] = q_en - diff;
+            prev[ch] += beta * q_en;
+        }
+    }
+}
+
+static void celt_quant_coarse(OpusRangeCoder *rc, CeltFrame *f,
+                              float last_energy[][CELT_MAX_BANDS])
+{
+    uint32_t inter, intra;
+    OPUS_RC_CHECKPOINT_SPAWN(rc);
+
+    exp_quant_coarse(rc, f, last_energy, 1);
+    intra = OPUS_RC_CHECKPOINT_BITS(rc);
+
+    OPUS_RC_CHECKPOINT_ROLLBACK(rc);
+
+    exp_quant_coarse(rc, f, last_energy, 0);
+    inter = OPUS_RC_CHECKPOINT_BITS(rc);
+
+    if (inter > intra) { /* Unlikely */
+        OPUS_RC_CHECKPOINT_ROLLBACK(rc);
+        exp_quant_coarse(rc, f, last_energy, 1);
+    }
+}
+
+static void celt_quant_fine(OpusRangeCoder *rc, CeltFrame *f)
+{
+    int i, ch;
+    for (i = f->start_band; i < f->end_band; i++) {
+        if (!f->fine_bits[i])
+            continue;
+        for (ch = 0; ch < f->channels; ch++) {
+            CeltBlock *block = &f->block[ch];
+            int quant, lim = (1 << f->fine_bits[i]);
+            float offset, diff = 0.5f - block->error_energy[i];
+            quant = av_clip(floor(diff*lim), 0, lim - 1);
+            ff_opus_rc_put_raw(rc, quant, f->fine_bits[i]);
+            offset = 0.5f - ((quant + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f);
+            block->error_energy[i] -= offset;
+        }
+    }
+}
+
+static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)
+{
+    int i, ch, priority;
+    for (priority = 0; priority < 2; priority++) {
+        for (i = f->start_band; i < f->end_band && (f->framebits - opus_rc_tell(rc)) >= f->channels; i++) {
+            if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
+                continue;
+            for (ch = 0; ch < f->channels; ch++) {
+                CeltBlock *block = &f->block[ch];
+                const float err = block->error_energy[i];
+                const float offset = 0.5f * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
+                const int sign = FFABS(err + offset) < FFABS(err - offset);
+                ff_opus_rc_put_raw(rc, sign, 1);
+                block->error_energy[i] -= offset*(1 - 2*sign);
+            }
+        }
+    }
+}
+
+static void celt_quant_bands(OpusRangeCoder *rc, CeltFrame *f)
+{
+    float lowband_scratch[8 * 22];
+    float norm[2 * 8 * 100];
+
+    int totalbits = (f->framebits << 3) - f->anticollapse_needed;
+
+    int update_lowband = 1;
+    int lowband_offset = 0;
+
+    int i, j;
+
+    for (i = f->start_band; i < f->end_band; i++) {
+        uint32_t cm[2] = { (1 << f->blocks) - 1, (1 << f->blocks) - 1 };
+        int band_offset = ff_celt_freq_bands[i] << f->size;
+        int band_size   = ff_celt_freq_range[i] << f->size;
+        float *X = f->block[0].coeffs + band_offset;
+        float *Y = (f->channels == 2) ? f->block[1].coeffs + band_offset : NULL;
+
+        int consumed = opus_rc_tell_frac(rc);
+        float *norm2 = norm + 8 * 100;
+        int effective_lowband = -1;
+        int b = 0;
+
+        /* Compute how many bits we want to allocate to this band */
+        if (i != f->start_band)
+            f->remaining -= consumed;
+        f->remaining2 = totalbits - consumed - 1;
+        if (i <= f->coded_bands - 1) {
+            int curr_balance = f->remaining / FFMIN(3, f->coded_bands-i);
+            b = av_clip_uintp2(FFMIN(f->remaining2 + 1, f->pulses[i] + curr_balance), 14);
+        }
+
+        if (ff_celt_freq_bands[i] - ff_celt_freq_range[i] >= ff_celt_freq_bands[f->start_band] &&
+            (update_lowband || lowband_offset == 0))
+            lowband_offset = i;
+
+        /* Get a conservative estimate of the collapse_mask's for the bands we're
+        going to be folding from. */
+        if (lowband_offset != 0 && (f->spread != CELT_SPREAD_AGGRESSIVE ||
+                                    f->blocks > 1 || f->tf_change[i] < 0)) {
+            int foldstart, foldend;
+
+            /* This ensures we never repeat spectral content within one band */
+            effective_lowband = FFMAX(ff_celt_freq_bands[f->start_band],
+                                      ff_celt_freq_bands[lowband_offset] - ff_celt_freq_range[i]);
+            foldstart = lowband_offset;
+            while (ff_celt_freq_bands[--foldstart] > effective_lowband);
+            foldend = lowband_offset - 1;
+            while (ff_celt_freq_bands[++foldend] < effective_lowband + ff_celt_freq_range[i]);
+
+            cm[0] = cm[1] = 0;
+            for (j = foldstart; j < foldend; j++) {
+                cm[0] |= f->block[0].collapse_masks[j];
+                cm[1] |= f->block[f->channels - 1].collapse_masks[j];
+            }
+        }
+
+        if (f->dual_stereo && i == f->intensity_stereo) {
+            /* Switch off dual stereo to do intensity */
+            f->dual_stereo = 0;
+            for (j = ff_celt_freq_bands[f->start_band] << f->size; j < band_offset; j++)
+                norm[j] = (norm[j] + norm2[j]) / 2;
+        }
+
+        if (f->dual_stereo) {
+            cm[0] = f->pvq->encode_band(f->pvq, f, rc, i, X, NULL, band_size, b / 2, f->blocks,
+                                        effective_lowband != -1 ? norm + (effective_lowband << f->size) : NULL, f->size,
+                                        norm + band_offset, 0, 1.0f, lowband_scratch, cm[0]);
+
+            cm[1] = f->pvq->encode_band(f->pvq, f, rc, i, Y, NULL, band_size, b / 2, f->blocks,
+                                        effective_lowband != -1 ? norm2 + (effective_lowband << f->size) : NULL, f->size,
+                                        norm2 + band_offset, 0, 1.0f, lowband_scratch, cm[1]);
+        } else {
+            cm[0] = f->pvq->encode_band(f->pvq, f, rc, i, X, Y, band_size, b, f->blocks,
+                                        effective_lowband != -1 ? norm + (effective_lowband << f->size) : NULL, f->size,
+                                        norm + band_offset, 0, 1.0f, lowband_scratch, cm[0] | cm[1]);
+            cm[1] = cm[0];
+        }
+
+        f->block[0].collapse_masks[i]               = (uint8_t)cm[0];
+        f->block[f->channels - 1].collapse_masks[i] = (uint8_t)cm[1];
+        f->remaining += f->pulses[i] + consumed;
+
+        /* Update the folding position only as long as we have 1 bit/sample depth */
+        update_lowband = (b > band_size << 3);
+    }
+}
+
+static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc,
+                              CeltFrame *f, int index)
+{
+    int i, ch;
+
+    ff_opus_rc_enc_init(rc);
+
+    ff_opus_psy_celt_frame_init(&s->psyctx, f, index);
+
+    celt_frame_setup_input(s, f);
+
+    if (f->silence) {
+        if (f->framebits >= 16)
+            ff_opus_rc_enc_log(rc, 1, 15); /* Silence (if using explicit singalling) */
+        for (ch = 0; ch < s->channels; ch++)
+            memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
+        return;
+    }
+
+    /* Filters */
+    celt_apply_preemph_filter(s, f);
+    if (f->pfilter) {
+        ff_opus_rc_enc_log(rc, 0, 15);
+        celt_enc_quant_pfilter(rc, f);
+    }
+
+    /* Transform */
+    celt_frame_mdct(s, f);
+
+    /* Need to handle transient/non-transient switches at any point during analysis */
+    while (ff_opus_psy_celt_frame_process(&s->psyctx, f, index))
+        celt_frame_mdct(s, f);
+
+    ff_opus_rc_enc_init(rc);
+
+    /* Silence */
+    ff_opus_rc_enc_log(rc, 0, 15);
+
+    /* Pitch filter */
+    if (!f->start_band && opus_rc_tell(rc) + 16 <= f->framebits)
+        celt_enc_quant_pfilter(rc, f);
+
+    /* Transient flag */
+    if (f->size && opus_rc_tell(rc) + 3 <= f->framebits)
+        ff_opus_rc_enc_log(rc, f->transient, 3);
+
+    /* Main encoding */
+    celt_quant_coarse(rc, f, s->last_quantized_energy);
+    celt_enc_tf      (rc, f);
+    ff_celt_enc_bitalloc(rc, f);
+    celt_quant_fine  (rc, f);
+    celt_quant_bands (rc, f);
+
+    /* Anticollapse bit */
+    if (f->anticollapse_needed)
+        ff_opus_rc_put_raw(rc, f->anticollapse, 1);
+
+    /* Final per-band energy adjustments from leftover bits */
+    celt_quant_final(s, rc, f);
+
+    for (ch = 0; ch < f->channels; ch++) {
+        CeltBlock *block = &f->block[ch];
+        for (i = 0; i < CELT_MAX_BANDS; i++)
+            s->last_quantized_energy[ch][i] = block->energy[i] + block->error_energy[i];
+    }
+}
+
+static inline int write_opuslacing(uint8_t *dst, int v)
+{
+    dst[0] = FFMIN(v - FFALIGN(v - 255, 4), v);
+    dst[1] = v - dst[0] >> 2;
+    return 1 + (v >= 252);
+}
+
+static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)
+{
+    int i, offset, fsize_needed;
+
+    /* Write toc */
+    opus_gen_toc(s, avpkt->data, &offset, &fsize_needed);
+
+    /* Frame sizes if needed */
+    if (fsize_needed) {
+        for (i = 0; i < s->packet.frames - 1; i++) {
+            offset += write_opuslacing(avpkt->data + offset,
+                                       s->frame[i].framebits >> 3);
+        }
+    }
+
+    /* Packets */
+    for (i = 0; i < s->packet.frames; i++) {
+        ff_opus_rc_enc_end(&s->rc[i], avpkt->data + offset,
+                           s->frame[i].framebits >> 3);
+        offset += s->frame[i].framebits >> 3;
+    }
+
+    avpkt->size = offset;
+}
+
+/* Used as overlap for the first frame and padding for the last encoded packet */
+static AVFrame *spawn_empty_frame(OpusEncContext *s)
+{
+    int i;
+    AVFrame *f = av_frame_alloc();
+    if (!f)
+        return NULL;
+    f->format         = s->avctx->sample_fmt;
+    f->nb_samples     = s->avctx->frame_size;
+    f->channel_layout = s->avctx->channel_layout;
+    if (av_frame_get_buffer(f, 4)) {
+        av_frame_free(&f);
+        return NULL;
+    }
+    for (i = 0; i < s->channels; i++) {
+        size_t bps = av_get_bytes_per_sample(f->format);
+        memset(f->extended_data[i], 0, bps*f->nb_samples);
+    }
+    return f;
+}
+
+static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
+                             const AVFrame *frame, int *got_packet_ptr)
+{
+    OpusEncContext *s = avctx->priv_data;
+    int i, ret, frame_size, alloc_size = 0;
+
+    if (frame) { /* Add new frame to queue */
+        if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
+            return ret;
+        ff_bufqueue_add(avctx, &s->bufqueue, av_frame_clone(frame));
+    } else {
+        ff_opus_psy_signal_eof(&s->psyctx);
+        if (!s->afq.remaining_samples)
+            return 0; /* We've been flushed and there's nothing left to encode */
+    }
+
+    /* Run the psychoacoustic system */
+    if (ff_opus_psy_process(&s->psyctx, &s->packet))
+        return 0;
+
+    frame_size = OPUS_BLOCK_SIZE(s->packet.framesize);
+
+    if (!frame) {
+        /* This can go negative, that's not a problem, we only pad if positive */
+        int pad_empty = s->packet.frames*(frame_size/s->avctx->frame_size) - s->bufqueue.available + 1;
+        /* Pad with empty 2.5 ms frames to whatever framesize was decided,
+         * this should only happen at the very last flush frame. The frames
+         * allocated here will be freed (because they have no other references)
+         * after they get used by celt_frame_setup_input() */
+        for (i = 0; i < pad_empty; i++) {
+            AVFrame *empty = spawn_empty_frame(s);
+            if (!empty)
+                return AVERROR(ENOMEM);
+            ff_bufqueue_add(avctx, &s->bufqueue, empty);
+        }
+    }
+
+    for (i = 0; i < s->packet.frames; i++) {
+        celt_encode_frame(s, &s->rc[i], &s->frame[i], i);
+        alloc_size += s->frame[i].framebits >> 3;
+    }
+
+    /* Worst case toc + the frame lengths if needed */
+    alloc_size += 2 + s->packet.frames*2;
+
+    if ((ret = ff_alloc_packet2(avctx, avpkt, alloc_size, 0)) < 0)
+        return ret;
+
+    /* Assemble packet */
+    opus_packet_assembler(s, avpkt);
+
+    /* Update the psychoacoustic system */
+    ff_opus_psy_postencode_update(&s->psyctx, s->frame, s->rc);
+
+    /* Remove samples from queue and skip if needed */
+    ff_af_queue_remove(&s->afq, s->packet.frames*frame_size, &avpkt->pts, &avpkt->duration);
+    if (s->packet.frames*frame_size > avpkt->duration) {
+        uint8_t *side = av_packet_new_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
+        if (!side)
+            return AVERROR(ENOMEM);
+        AV_WL32(&side[4], s->packet.frames*frame_size - avpkt->duration + 120);
+    }
+
+    *got_packet_ptr = 1;
+
+    return 0;
+}
+
+static av_cold int opus_encode_end(AVCodecContext *avctx)
+{
+    int i;
+    OpusEncContext *s = avctx->priv_data;
+
+    for (i = 0; i < CELT_BLOCK_NB; i++)
+        ff_mdct15_uninit(&s->mdct[i]);
+
+    ff_celt_pvq_uninit(&s->pvq);
+    av_freep(&s->dsp);
+    av_freep(&s->frame);
+    av_freep(&s->rc);
+    ff_af_queue_close(&s->afq);
+    ff_opus_psy_end(&s->psyctx);
+    ff_bufqueue_discard_all(&s->bufqueue);
+    av_freep(&avctx->extradata);
+
+    return 0;
+}
+
+static av_cold int opus_encode_init(AVCodecContext *avctx)
+{
+    int i, ch, ret, max_frames;
+    OpusEncContext *s = avctx->priv_data;
+
+    s->avctx = avctx;
+    s->channels = avctx->channels;
+
+    /* Opus allows us to change the framesize on each packet (and each packet may
+     * have multiple frames in it) but we can't change the codec's frame size on
+     * runtime, so fix it to the lowest possible number of samples and use a queue
+     * to accumulate AVFrames until we have enough to encode whatever the encoder
+     * decides is the best */
+    avctx->frame_size = 120;
+    /* Initial padding will change if SILK is ever supported */
+    avctx->initial_padding = 120;
+
+    if (!avctx->bit_rate) {
+        int coupled = ff_opus_default_coupled_streams[s->channels - 1];
+        avctx->bit_rate = coupled*(96000) + (s->channels - coupled*2)*(48000);
+    } else if (avctx->bit_rate < 6000 || avctx->bit_rate > 255000 * s->channels) {
+        int64_t clipped_rate = av_clip(avctx->bit_rate, 6000, 255000 * s->channels);
+        av_log(avctx, AV_LOG_ERROR, "Unsupported bitrate %"PRId64" kbps, clipping to %"PRId64" kbps\n",
+               avctx->bit_rate/1000, clipped_rate/1000);
+        avctx->bit_rate = clipped_rate;
+    }
+
+    /* Extradata */
+    avctx->extradata_size = 19;
+    avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+    if (!avctx->extradata)
+        return AVERROR(ENOMEM);
+    opus_write_extradata(avctx);
+
+    ff_af_queue_init(avctx, &s->afq);
+
+    if ((ret = ff_celt_pvq_init(&s->pvq)) < 0)
+        return ret;
+
+    if (!(s->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT)))
+        return AVERROR(ENOMEM);
+
+    /* I have no idea why a base scaling factor of 68 works, could be the twiddles */
+    for (i = 0; i < CELT_BLOCK_NB; i++)
+        if ((ret = ff_mdct15_init(&s->mdct[i], 0, i + 3, 68 << (CELT_BLOCK_NB - 1 - i))))
+            return AVERROR(ENOMEM);
+
+    /* Zero out previous energy (matters for inter first frame) */
+    for (ch = 0; ch < s->channels; ch++)
+        memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
+
+    /* Allocate an empty frame to use as overlap for the first frame of audio */
+    ff_bufqueue_add(avctx, &s->bufqueue, spawn_empty_frame(s));
+    if (!ff_bufqueue_peek(&s->bufqueue, 0))
+        return AVERROR(ENOMEM);
+
+    if ((ret = ff_opus_psy_init(&s->psyctx, s->avctx, &s->bufqueue, &s->options)))
+        return ret;
+
+    /* Frame structs and range coder buffers */
+    max_frames = ceilf(FFMIN(s->options.max_delay_ms, 120.0f)/2.5f);
+    s->frame = av_malloc(max_frames*sizeof(CeltFrame));
+    if (!s->frame)
+        return AVERROR(ENOMEM);
+    s->rc = av_malloc(max_frames*sizeof(OpusRangeCoder));
+    if (!s->rc)
+        return AVERROR(ENOMEM);
+
+    for (i = 0; i < max_frames; i++) {
+        s->frame[i].dsp = s->dsp;
+        s->frame[i].avctx = s->avctx;
+        s->frame[i].seed = 0;
+        s->frame[i].pvq = s->pvq;
+        s->frame[i].block[0].emph_coeff = s->frame[i].block[1].emph_coeff = 0.0f;
+    }
+
+    return 0;
+}
+
+#define OPUSENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
+static const AVOption opusenc_options[] = {
+    { "opus_delay", "Maximum delay in milliseconds", offsetof(OpusEncContext, options.max_delay_ms), AV_OPT_TYPE_FLOAT, { .dbl = OPUS_MAX_LOOKAHEAD }, 2.5f, OPUS_MAX_LOOKAHEAD, OPUSENC_FLAGS, "max_delay_ms" },
+    { NULL },
+};
+
+static const AVClass opusenc_class = {
+    .class_name = "Opus encoder",
+    .item_name  = av_default_item_name,
+    .option     = opusenc_options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+static const AVCodecDefault opusenc_defaults[] = {
+    { "b", "0" },
+    { "compression_level", "10" },
+    { NULL },
+};
+
+AVCodec ff_opus_encoder = {
+    .name           = "opus",
+    .long_name      = NULL_IF_CONFIG_SMALL("Opus"),
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = AV_CODEC_ID_OPUS,
+    .defaults       = opusenc_defaults,
+    .priv_class     = &opusenc_class,
+    .priv_data_size = sizeof(OpusEncContext),
+    .init           = opus_encode_init,
+    .encode2        = opus_encode_frame,
+    .close          = opus_encode_end,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
+    .capabilities   = AV_CODEC_CAP_EXPERIMENTAL | AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY,
+    .supported_samplerates = (const int []){ 48000, 0 },
+    .channel_layouts = (const uint64_t []){ AV_CH_LAYOUT_MONO,
+                                            AV_CH_LAYOUT_STEREO, 0 },
+    .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
+                                                     AV_SAMPLE_FMT_NONE },
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/opusenc.h b/mythtv/external/FFmpeg/libavcodec/opusenc.h
new file mode 100644
index 00000000000..3273d0a9a2a
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opusenc.h
@@ -0,0 +1,56 @@
+/*
+ * Opus encoder
+ * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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_OPUSENC_H
+#define AVCODEC_OPUSENC_H
+
+#include "internal.h"
+#include "opus_celt.h"
+
+/* Determines the maximum delay the psychoacoustic system will use for lookahead */
+#define FF_BUFQUEUE_SIZE 145
+#include "libavfilter/bufferqueue.h"
+
+#define OPUS_MAX_LOOKAHEAD ((FF_BUFQUEUE_SIZE - 1)*2.5f)
+
+#define OPUS_MAX_CHANNELS 2
+
+/* 120 ms / 2.5 ms = 48 frames (extremely improbable, but the encoder'll work) */
+#define OPUS_MAX_FRAMES_PER_PACKET 48
+
+#define OPUS_BLOCK_SIZE(x) (2 * 15 * (1 << ((x) + 2)))
+
+#define OPUS_SAMPLES_TO_BLOCK_SIZE(x) (ff_log2((x) / (2 * 15)) - 2)
+
+typedef struct OpusEncOptions {
+    float max_delay_ms;
+} OpusEncOptions;
+
+typedef struct OpusPacketInfo {
+    enum OpusMode mode;
+    enum OpusBandwidth bandwidth;
+    int framesize;
+    int frames;
+} OpusPacketInfo;
+
+void ff_celt_enc_bitalloc(OpusRangeCoder *rc, CeltFrame *f);
+
+#endif /* AVCODEC_OPUSENC_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/opusenc_psy.c b/mythtv/external/FFmpeg/libavcodec/opusenc_psy.c
new file mode 100644
index 00000000000..b446d41f755
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opusenc_psy.c
@@ -0,0 +1,557 @@
+/*
+ * Opus encoder
+ * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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 "opusenc_psy.h"
+#include "opus_pvq.h"
+#include "opustab.h"
+#include "mdct15.h"
+#include "libavutil/qsort.h"
+
+/* Populate metrics without taking into consideration neighbouring steps */
+static void step_collect_psy_metrics(OpusPsyContext *s, int index)
+{
+    int silence = 0, ch, i, j;
+    OpusPsyStep *st = s->steps[index];
+
+    st->index = index;
+
+    for (ch = 0; ch < s->avctx->channels; ch++) {
+        const int lap_size = (1 << s->bsize_analysis);
+        for (i = 1; i <= FFMIN(lap_size, index); i++) {
+            const int offset = i*120;
+            AVFrame *cur = ff_bufqueue_peek(s->bufqueue, index - i);
+            memcpy(&s->scratch[offset], cur->extended_data[ch], cur->nb_samples*sizeof(float));
+        }
+        for (i = 0; i < lap_size; i++) {
+            const int offset = i*120 + lap_size;
+            AVFrame *cur = ff_bufqueue_peek(s->bufqueue, index + i);
+            memcpy(&s->scratch[offset], cur->extended_data[ch], cur->nb_samples*sizeof(float));
+        }
+
+        s->dsp->vector_fmul(s->scratch, s->scratch, s->window[s->bsize_analysis],
+                            (OPUS_BLOCK_SIZE(s->bsize_analysis) << 1));
+
+        s->mdct[s->bsize_analysis]->mdct(s->mdct[s->bsize_analysis], st->coeffs[ch], s->scratch, 1);
+
+        for (i = 0; i < CELT_MAX_BANDS; i++)
+            st->bands[ch][i] = &st->coeffs[ch][ff_celt_freq_bands[i] << s->bsize_analysis];
+    }
+
+    for (ch = 0; ch < s->avctx->channels; ch++) {
+        for (i = 0; i < CELT_MAX_BANDS; i++) {
+            float avg_c_s, energy = 0.0f, dist_dev = 0.0f;
+            const int range = ff_celt_freq_range[i] << s->bsize_analysis;
+            const float *coeffs = st->bands[ch][i];
+            for (j = 0; j < range; j++)
+                energy += coeffs[j]*coeffs[j];
+
+            st->energy[ch][i] += sqrtf(energy);
+            silence |= !!st->energy[ch][i];
+            avg_c_s = energy / range;
+
+            for (j = 0; j < range; j++) {
+                const float c_s = coeffs[j]*coeffs[j];
+                dist_dev = (avg_c_s - c_s)*(avg_c_s - c_s);
+            }
+
+            st->tone[ch][i] += sqrtf(dist_dev);
+        }
+    }
+
+    st->silence = !silence;
+
+    if (s->avctx->channels > 1) {
+        for (i = 0; i < CELT_MAX_BANDS; i++) {
+            float incompat = 0.0f;
+            const float *coeffs1 = st->bands[0][i];
+            const float *coeffs2 = st->bands[1][i];
+            const int range = ff_celt_freq_range[i] << s->bsize_analysis;
+            for (j = 0; j < range; j++)
+                incompat += (coeffs1[j] - coeffs2[j])*(coeffs1[j] - coeffs2[j]);
+            st->stereo[i] = sqrtf(incompat);
+        }
+    }
+
+    for (ch = 0; ch < s->avctx->channels; ch++) {
+        for (i = 0; i < CELT_MAX_BANDS; i++) {
+            OpusBandExcitation *ex = &s->ex[ch][i];
+            float bp_e = bessel_filter(&s->bfilter_lo[ch][i], st->energy[ch][i]);
+            bp_e = bessel_filter(&s->bfilter_hi[ch][i], bp_e);
+            bp_e *= bp_e;
+            if (bp_e > ex->excitation) {
+                st->change_amp[ch][i] = bp_e - ex->excitation;
+                st->total_change += st->change_amp[ch][i];
+                ex->excitation = ex->excitation_init = bp_e;
+                ex->excitation_dist = 0.0f;
+            }
+            if (ex->excitation > 0.0f) {
+                ex->excitation -= av_clipf((1/expf(ex->excitation_dist)), ex->excitation_init/20, ex->excitation_init/1.09);
+                ex->excitation = FFMAX(ex->excitation, 0.0f);
+                ex->excitation_dist += 1.0f;
+            }
+        }
+    }
+}
+
+static void search_for_change_points(OpusPsyContext *s, float tgt_change,
+                                     int offset_s, int offset_e, int resolution,
+                                     int level)
+{
+    int i;
+    float c_change = 0.0f;
+    if ((offset_e - offset_s) <= resolution)
+        return;
+    for (i = offset_s; i < offset_e; i++) {
+        c_change += s->steps[i]->total_change;
+        if (c_change > tgt_change)
+            break;
+    }
+    if (i == offset_e)
+        return;
+    search_for_change_points(s, tgt_change / 2.0f, offset_s, i + 0, resolution, level + 1);
+    s->inflection_points[s->inflection_points_count++] = i;
+    search_for_change_points(s, tgt_change / 2.0f, i + 1, offset_e, resolution, level + 1);
+}
+
+static int flush_silent_frames(OpusPsyContext *s)
+{
+    int fsize, silent_frames;
+
+    for (silent_frames = 0; silent_frames < s->buffered_steps; silent_frames++)
+        if (!s->steps[silent_frames]->silence)
+            break;
+    if (--silent_frames < 0)
+        return 0;
+
+    for (fsize = CELT_BLOCK_960; fsize > CELT_BLOCK_120; fsize--) {
+        if ((1 << fsize) > silent_frames)
+            continue;
+        s->p.frames = FFMIN(silent_frames / (1 << fsize), 48 >> fsize);
+        s->p.framesize = fsize;
+        return 1;
+    }
+
+    return 0;
+}
+
+/* Main function which decides frame size and frames per current packet */
+static void psy_output_groups(OpusPsyContext *s)
+{
+    int max_delay_samples = (s->options->max_delay_ms*s->avctx->sample_rate)/1000;
+    int max_bsize = FFMIN(OPUS_SAMPLES_TO_BLOCK_SIZE(max_delay_samples), CELT_BLOCK_960);
+
+    /* These don't change for now */
+    s->p.mode      = OPUS_MODE_CELT;
+    s->p.bandwidth = OPUS_BANDWIDTH_FULLBAND;
+
+    /* Flush silent frames ASAP */
+    if (s->steps[0]->silence && flush_silent_frames(s))
+        return;
+
+    s->p.framesize = FFMIN(max_bsize, CELT_BLOCK_960);
+    s->p.frames    = 1;
+}
+
+int ff_opus_psy_process(OpusPsyContext *s, OpusPacketInfo *p)
+{
+    int i;
+    float total_energy_change = 0.0f;
+
+    if (s->buffered_steps < s->max_steps && !s->eof) {
+        const int awin = (1 << s->bsize_analysis);
+        if (++s->steps_to_process >= awin) {
+            step_collect_psy_metrics(s, s->buffered_steps - awin + 1);
+            s->steps_to_process = 0;
+        }
+        if ((++s->buffered_steps) < s->max_steps)
+            return 1;
+    }
+
+    for (i = 0; i < s->buffered_steps; i++)
+        total_energy_change += s->steps[i]->total_change;
+
+    search_for_change_points(s, total_energy_change / 2.0f, 0,
+                             s->buffered_steps, 1, 0);
+
+    psy_output_groups(s);
+
+    p->frames    = s->p.frames;
+    p->framesize = s->p.framesize;
+    p->mode      = s->p.mode;
+    p->bandwidth = s->p.bandwidth;
+
+    return 0;
+}
+
+void ff_opus_psy_celt_frame_init(OpusPsyContext *s, CeltFrame *f, int index)
+{
+    int i, neighbouring_points = 0, start_offset = 0;
+    int radius = (1 << s->p.framesize), step_offset = radius*index;
+    int silence = 1;
+
+    f->start_band = (s->p.mode == OPUS_MODE_HYBRID) ? 17 : 0;
+    f->end_band   = ff_celt_band_end[s->p.bandwidth];
+    f->channels   = s->avctx->channels;
+    f->size       = s->p.framesize;
+
+    for (i = 0; i < (1 << f->size); i++)
+        silence &= s->steps[index*(1 << f->size) + i]->silence;
+
+    f->silence = silence;
+    if (f->silence) {
+        f->framebits = 0; /* Otherwise the silence flag eats up 16(!) bits */
+        return;
+    }
+
+    for (i = 0; i < s->inflection_points_count; i++) {
+        if (s->inflection_points[i] >= step_offset) {
+            start_offset = i;
+            break;
+        }
+    }
+
+    for (i = start_offset; i < FFMIN(radius, s->inflection_points_count - start_offset); i++) {
+        if (s->inflection_points[i] < (step_offset + radius)) {
+            neighbouring_points++;
+        }
+    }
+
+    /* Transient flagging */
+    f->transient = neighbouring_points > 0;
+    f->blocks = f->transient ? OPUS_BLOCK_SIZE(s->p.framesize)/CELT_OVERLAP : 1;
+
+    /* Some sane defaults */
+    f->pfilter   = 0;
+    f->pf_gain   = 0.5f;
+    f->pf_octave = 2;
+    f->pf_period = 1;
+    f->pf_tapset = 2;
+
+    /* More sane defaults */
+    f->tf_select = 0;
+    f->anticollapse = 1;
+    f->alloc_trim = 5;
+    f->skip_band_floor = f->end_band;
+    f->intensity_stereo = f->end_band;
+    f->dual_stereo = 0;
+    f->spread = CELT_SPREAD_NORMAL;
+    memset(f->tf_change, 0, sizeof(int)*CELT_MAX_BANDS);
+    memset(f->alloc_boost, 0, sizeof(int)*CELT_MAX_BANDS);
+}
+
+static void celt_gauge_psy_weight(OpusPsyContext *s, OpusPsyStep **start,
+                                  CeltFrame *f_out)
+{
+    int i, f, ch;
+    int frame_size = OPUS_BLOCK_SIZE(s->p.framesize);
+    float rate, frame_bits = 0;
+
+    /* Used for the global ROTATE flag */
+    float tonal = 0.0f;
+
+    /* Pseudo-weights */
+    float band_score[CELT_MAX_BANDS] = { 0 };
+    float max_score = 1.0f;
+
+    /* Pass one - one loop around each band, computing unquant stuff */
+    for (i = 0; i < CELT_MAX_BANDS; i++) {
+        float weight = 0.0f;
+        float tonal_contrib = 0.0f;
+        for (f = 0; f < (1 << s->p.framesize); f++) {
+            weight = start[f]->stereo[i];
+            for (ch = 0; ch < s->avctx->channels; ch++) {
+                weight += start[f]->change_amp[ch][i] + start[f]->tone[ch][i] + start[f]->energy[ch][i];
+                tonal_contrib += start[f]->tone[ch][i];
+            }
+        }
+        tonal += tonal_contrib;
+        band_score[i] = weight;
+    }
+
+    tonal /= (float)CELT_MAX_BANDS;
+
+    for (i = 0; i < CELT_MAX_BANDS; i++) {
+        if (band_score[i] > max_score)
+            max_score = band_score[i];
+    }
+
+    for (i = 0; i < CELT_MAX_BANDS; i++) {
+        f_out->alloc_boost[i] = (int)((band_score[i]/max_score)*3.0f);
+        frame_bits += band_score[i]*8.0f;
+    }
+
+    tonal /= 1333136.0f;
+    f_out->spread = av_clip_uintp2(lrintf(tonal), 2);
+
+    rate = ((float)s->avctx->bit_rate) + frame_bits*frame_size*16;
+    rate *= s->lambda;
+    rate /= s->avctx->sample_rate/frame_size;
+
+    f_out->framebits = lrintf(rate);
+    f_out->framebits = FFMIN(f_out->framebits, OPUS_MAX_PACKET_SIZE*8);
+    f_out->framebits = FFALIGN(f_out->framebits, 8);
+}
+
+static int bands_dist(OpusPsyContext *s, CeltFrame *f, float *total_dist)
+{
+    int i, tdist = 0.0f;
+    OpusRangeCoder dump;
+
+    ff_opus_rc_enc_init(&dump);
+    ff_celt_enc_bitalloc(&dump, f);
+
+    for (i = 0; i < CELT_MAX_BANDS; i++) {
+        float bits = 0.0f;
+        float dist = f->pvq->band_cost(f->pvq, f, &dump, i, &bits, s->lambda);
+        tdist += dist;
+    }
+
+    *total_dist = tdist;
+
+    return 0;
+}
+
+static void celt_search_for_dual_stereo(OpusPsyContext *s, CeltFrame *f)
+{
+    float td1, td2;
+    f->dual_stereo = 0;
+    bands_dist(s, f, &td1);
+    f->dual_stereo = 1;
+    bands_dist(s, f, &td2);
+
+    f->dual_stereo = td2 < td1;
+    s->dual_stereo_used += td2 < td1;
+}
+
+static void celt_search_for_intensity(OpusPsyContext *s, CeltFrame *f)
+{
+    int i, best_band = CELT_MAX_BANDS - 1;
+    float dist, best_dist = FLT_MAX;
+
+    /* TODO: fix, make some heuristic up here using the lambda value */
+    float end_band = 0;
+
+    for (i = f->end_band; i >= end_band; i--) {
+        f->intensity_stereo = i;
+        bands_dist(s, f, &dist);
+        if (best_dist > dist) {
+            best_dist = dist;
+            best_band = i;
+        }
+    }
+
+    f->intensity_stereo = best_band;
+    s->avg_is_band = (s->avg_is_band + f->intensity_stereo)/2.0f;
+}
+
+static int celt_search_for_tf(OpusPsyContext *s, OpusPsyStep **start, CeltFrame *f)
+{
+    int i, j, k, cway, config[2][CELT_MAX_BANDS] = { { 0 } };
+    float score[2] = { 0 };
+
+    for (cway = 0; cway < 2; cway++) {
+        int mag[2];
+        int base = f->transient ? 120 : 960;
+        int i;
+
+        for (i = 0; i < 2; i++) {
+            int c = ff_celt_tf_select[f->size][f->transient][cway][i];
+            mag[i] = c < 0 ? base >> FFABS(c) : base << FFABS(c);
+        }
+
+        for (i = 0; i < CELT_MAX_BANDS; i++) {
+            float iscore0 = 0.0f;
+            float iscore1 = 0.0f;
+            for (j = 0; j < (1 << f->size); j++) {
+                for (k = 0; k < s->avctx->channels; k++) {
+                    iscore0 += start[j]->tone[k][i]*start[j]->change_amp[k][i]/mag[0];
+                    iscore1 += start[j]->tone[k][i]*start[j]->change_amp[k][i]/mag[1];
+                }
+            }
+            config[cway][i] = FFABS(iscore0 - 1.0f) < FFABS(iscore1 - 1.0f);
+            score[cway] += config[cway][i] ? iscore1 : iscore0;
+        }
+    }
+
+    f->tf_select = score[0] < score[1];
+    memcpy(f->tf_change, config[f->tf_select], sizeof(int)*CELT_MAX_BANDS);
+
+    return 0;
+}
+
+int ff_opus_psy_celt_frame_process(OpusPsyContext *s, CeltFrame *f, int index)
+{
+    int start_transient_flag = f->transient;
+    OpusPsyStep **start = &s->steps[index * (1 << s->p.framesize)];
+
+    if (f->silence)
+        return 0;
+
+    celt_gauge_psy_weight(s, start, f);
+    celt_search_for_intensity(s, f);
+    celt_search_for_dual_stereo(s, f);
+    celt_search_for_tf(s, start, f);
+
+    if (f->transient != start_transient_flag) {
+        f->blocks = f->transient ? OPUS_BLOCK_SIZE(s->p.framesize)/CELT_OVERLAP : 1;
+        s->redo_analysis = 1;
+        return 1;
+    }
+
+    s->redo_analysis = 0;
+
+    return 0;
+}
+
+void ff_opus_psy_postencode_update(OpusPsyContext *s, CeltFrame *f, OpusRangeCoder *rc)
+{
+    int i, frame_size = OPUS_BLOCK_SIZE(s->p.framesize);
+    int steps_out = s->p.frames*(frame_size/120);
+    void *tmp[FF_BUFQUEUE_SIZE];
+    float ideal_fbits;
+
+    for (i = 0; i < steps_out; i++)
+        memset(s->steps[i], 0, sizeof(OpusPsyStep));
+
+    for (i = 0; i < s->max_steps; i++)
+        tmp[i] = s->steps[i];
+
+    for (i = 0; i < s->max_steps; i++) {
+        const int i_new = i - steps_out;
+        s->steps[i_new < 0 ? s->max_steps + i_new : i_new] = tmp[i];
+    }
+
+    for (i = steps_out; i < s->buffered_steps; i++)
+        s->steps[i]->index -= steps_out;
+
+    ideal_fbits = s->avctx->bit_rate/(s->avctx->sample_rate/frame_size);
+
+    for (i = 0; i < s->p.frames; i++) {
+        s->avg_is_band += f[i].intensity_stereo;
+        s->lambda *= ideal_fbits / f[i].framebits;
+    }
+
+    s->avg_is_band /= (s->p.frames + 1);
+
+    s->cs_num = 0;
+    s->steps_to_process = 0;
+    s->buffered_steps -= steps_out;
+    s->total_packets_out += s->p.frames;
+    s->inflection_points_count = 0;
+}
+
+av_cold int ff_opus_psy_init(OpusPsyContext *s, AVCodecContext *avctx,
+                             struct FFBufQueue *bufqueue, OpusEncOptions *options)
+{
+    int i, ch, ret;
+
+    s->redo_analysis = 0;
+    s->lambda = 1.0f;
+    s->options = options;
+    s->avctx = avctx;
+    s->bufqueue = bufqueue;
+    s->max_steps = ceilf(s->options->max_delay_ms/2.5f);
+    s->bsize_analysis = CELT_BLOCK_960;
+    s->avg_is_band = CELT_MAX_BANDS - 1;
+    s->inflection_points_count = 0;
+
+    s->inflection_points = av_mallocz(sizeof(*s->inflection_points)*s->max_steps);
+    if (!s->inflection_points) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    s->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
+    if (!s->dsp) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    for (ch = 0; ch < s->avctx->channels; ch++) {
+        for (i = 0; i < CELT_MAX_BANDS; i++) {
+            bessel_init(&s->bfilter_hi[ch][i], 1.0f, 19.0f, 100.0f, 1);
+            bessel_init(&s->bfilter_lo[ch][i], 1.0f, 20.0f, 100.0f, 0);
+        }
+    }
+
+    for (i = 0; i < s->max_steps; i++) {
+        s->steps[i] = av_mallocz(sizeof(OpusPsyStep));
+        if (!s->steps[i]) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+    }
+
+    for (i = 0; i < CELT_BLOCK_NB; i++) {
+        float tmp;
+        const int len = OPUS_BLOCK_SIZE(i);
+        s->window[i] = av_malloc(2*len*sizeof(float));
+        if (!s->window[i]) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+        generate_window_func(s->window[i], 2*len, WFUNC_SINE, &tmp);
+        if ((ret = ff_mdct15_init(&s->mdct[i], 0, i + 3, 68 << (CELT_BLOCK_NB - 1 - i))))
+            goto fail;
+    }
+
+    return 0;
+
+fail:
+    av_freep(&s->inflection_points);
+    av_freep(&s->dsp);
+
+    for (i = 0; i < CELT_BLOCK_NB; i++) {
+        ff_mdct15_uninit(&s->mdct[i]);
+        av_freep(&s->window[i]);
+    }
+
+    for (i = 0; i < s->max_steps; i++)
+        av_freep(&s->steps[i]);
+
+    return ret;
+}
+
+void ff_opus_psy_signal_eof(OpusPsyContext *s)
+{
+    s->eof = 1;
+}
+
+av_cold int ff_opus_psy_end(OpusPsyContext *s)
+{
+    int i;
+
+    av_freep(&s->inflection_points);
+    av_freep(&s->dsp);
+
+    for (i = 0; i < CELT_BLOCK_NB; i++) {
+        ff_mdct15_uninit(&s->mdct[i]);
+        av_freep(&s->window[i]);
+    }
+
+    for (i = 0; i < s->max_steps; i++)
+        av_freep(&s->steps[i]);
+
+    av_log(s->avctx, AV_LOG_INFO, "Average Intensity Stereo band: %0.1f\n", s->avg_is_band);
+    av_log(s->avctx, AV_LOG_INFO, "Dual Stereo used: %0.2f%%\n", ((float)s->dual_stereo_used/s->total_packets_out)*100.0f);
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/opusenc_psy.h b/mythtv/external/FFmpeg/libavcodec/opusenc_psy.h
new file mode 100644
index 00000000000..b91e4f1b8b9
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opusenc_psy.h
@@ -0,0 +1,104 @@
+/*
+ * Opus encoder
+ * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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_OPUSENC_PSY_H
+#define AVCODEC_OPUSENC_PSY_H
+
+#include "opusenc.h"
+#include "opusenc_utils.h"
+#include "libavfilter/window_func.h"
+
+/* Each step is 2.5ms */
+typedef struct OpusPsyStep {
+    int   index; /* Current index */
+    int   silence;
+    float energy[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]; /* Masking effects included */
+    float tone[OPUS_MAX_CHANNELS][CELT_MAX_BANDS];   /* Tonality */
+    float stereo[CELT_MAX_BANDS];                    /* IS/MS compatibility */
+    float change_amp[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]; /* Jump over last frame */
+    float total_change; /* Total change */
+
+    float *bands[OPUS_MAX_CHANNELS][CELT_MAX_BANDS];
+    float coeffs[OPUS_MAX_CHANNELS][OPUS_BLOCK_SIZE(CELT_BLOCK_960)];
+} OpusPsyStep;
+
+typedef struct OpusBandExcitation {
+    float excitation;
+    float excitation_dist;
+    float excitation_init;
+} OpusBandExcitation;
+
+typedef struct PsyChain {
+    int start;
+    int end;
+} PsyChain;
+
+typedef struct OpusPsyContext {
+    AVCodecContext *avctx;
+    AVFloatDSPContext *dsp;
+    struct FFBufQueue *bufqueue;
+    OpusEncOptions *options;
+
+    PsyChain cs[128];
+    int cs_num;
+
+    OpusBandExcitation ex[OPUS_MAX_CHANNELS][CELT_MAX_BANDS];
+    FFBesselFilter bfilter_lo[OPUS_MAX_CHANNELS][CELT_MAX_BANDS];
+    FFBesselFilter bfilter_hi[OPUS_MAX_CHANNELS][CELT_MAX_BANDS];
+
+    OpusPsyStep *steps[FF_BUFQUEUE_SIZE + 1];
+    int max_steps;
+
+    float *window[CELT_BLOCK_NB];
+    MDCT15Context *mdct[CELT_BLOCK_NB];
+    int bsize_analysis;
+
+    DECLARE_ALIGNED(32, float, scratch)[2048];
+
+    /* Stats */
+    float rc_waste;
+    float avg_is_band;
+    int64_t dual_stereo_used;
+    int64_t total_packets_out;
+
+    /* State */
+    FFBesselFilter lambda_lp;
+    OpusPacketInfo p;
+    int redo_analysis;
+    int buffered_steps;
+    int steps_to_process;
+    int eof;
+    float lambda;
+    int *inflection_points;
+    int inflection_points_count;
+} OpusPsyContext;
+
+int  ff_opus_psy_process           (OpusPsyContext *s, OpusPacketInfo *p);
+void ff_opus_psy_celt_frame_init   (OpusPsyContext *s, CeltFrame *f, int index);
+int  ff_opus_psy_celt_frame_process(OpusPsyContext *s, CeltFrame *f, int index);
+void ff_opus_psy_postencode_update (OpusPsyContext *s, CeltFrame *f, OpusRangeCoder *rc);
+
+int  ff_opus_psy_init(OpusPsyContext *s, AVCodecContext *avctx,
+                      struct FFBufQueue *bufqueue, OpusEncOptions *options);
+void ff_opus_psy_signal_eof(OpusPsyContext *s);
+int  ff_opus_psy_end(OpusPsyContext *s);
+
+#endif /* AVCODEC_OPUSENC_PSY_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/opusenc_utils.h b/mythtv/external/FFmpeg/libavcodec/opusenc_utils.h
new file mode 100644
index 00000000000..be82e137672
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opusenc_utils.h
@@ -0,0 +1,87 @@
+/*
+ * Opus encoder
+ * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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_OPUSENC_UTILS_H
+#define AVCODEC_OPUSENC_UTILS_H
+
+#include "opus.h"
+
+typedef struct FFBesselFilter {
+    float a[3];
+    float b[2];
+    float x[3];
+    float y[3];
+} FFBesselFilter;
+
+/* Fills the coefficients, returns 1 if filter will be unstable */
+static inline int bessel_reinit(FFBesselFilter *s, float n, float f0, float fs,
+                                int highpass)
+{
+    int unstable;
+    float c, cfreq, w0, k1, k2;
+
+    if (!highpass) {
+        c = (1.0f/sqrtf(sqrtf(pow(2.0f, 1.0f/n) - 3.0f/4.0f) - 0.5f))/sqrtf(3.0f);
+        cfreq = c*f0/fs;
+        unstable = (cfreq <= 0.0f || cfreq >= 1.0f/4.0f);
+    } else {
+        c = sqrtf(3.0f)*sqrtf(sqrtf(pow(2.0f, 1.0f/n) - 3.0f/4.0f) - 0.5f);
+        cfreq = 0.5f - c*f0/fs;
+        unstable = (cfreq <= 3.0f/8.0f || cfreq >= 1.0f/2.0f);
+    }
+
+    w0 = tanf(M_PI*cfreq);
+    k1 = 3.0f * w0;
+    k2 = 3.0f * w0;
+
+    s->a[0] = k2/(1.0f + k1 + k2);
+    s->a[1] = 2.0f * s->a[0];
+    s->a[2] = s->a[0];
+    s->b[0] = 2.0f * s->a[0] * (1.0f/k2 - 1.0f);
+    s->b[1] = 1.0f - (s->a[0] + s->a[1] + s->a[2] + s->b[0]);
+
+    if (highpass) {
+        s->a[1] *= -1;
+        s->b[0] *= -1;
+    }
+
+    return unstable;
+}
+
+static inline int bessel_init(FFBesselFilter *s, float n, float f0, float fs,
+                              int highpass)
+{
+    memset(s, 0, sizeof(FFBesselFilter));
+    return bessel_reinit(s, n, f0, fs, highpass);
+}
+
+static inline float bessel_filter(FFBesselFilter *s, float x)
+{
+    s->x[2] = s->x[1];
+    s->x[1] = s->x[0];
+    s->x[0] = x;
+    s->y[2] = s->y[1];
+    s->y[1] = s->y[0];
+    s->y[0] = s->a[0]*s->x[0] + s->a[1]*s->x[1] + s->a[2]*s->x[2] + s->b[0]*s->y[1] + s->b[1]*s->y[2];
+    return s->y[0];
+}
+
+#endif /* AVCODEC_OPUSENC_UTILS_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/opustab.c b/mythtv/external/FFmpeg/libavcodec/opustab.c
new file mode 100644
index 00000000000..fb340e07e8e
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opustab.c
@@ -0,0 +1,1158 @@
+/*
+ * Copyright (c) 2012 Andrew D'Addesio
+ * Copyright (c) 2013-2014 Mozilla Corporation
+ * Copyright (c) 2016 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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 "opustab.h"
+
+const uint8_t ff_opus_default_coupled_streams[] = { 0, 1, 1, 2, 2, 2, 2, 3 };
+
+const uint8_t ff_celt_band_end[] = { 13, 17, 17, 19, 21 };
+
+const uint16_t ff_silk_model_stereo_s1[] = {
+    256,   7,   9,  10,  11,  12,  22,  46,  54,  55,  56,  59,  82, 174, 197, 200,
+    201, 202, 210, 234, 244, 245, 246, 247, 249, 256
+};
+
+const uint16_t ff_silk_model_stereo_s2[] = {256, 85, 171, 256};
+
+const uint16_t ff_silk_model_stereo_s3[] = {256, 51, 102, 154, 205, 256};
+
+const uint16_t ff_silk_model_mid_only[] = {256, 192, 256};
+
+const uint16_t ff_silk_model_frame_type_inactive[] = {256, 26, 256};
+
+const uint16_t ff_silk_model_frame_type_active[] = {256, 24, 98, 246, 256};
+
+const uint16_t ff_silk_model_gain_highbits[3][9] = {
+    {256,  32, 144, 212, 241, 253, 254, 255, 256},
+    {256,   2,  19,  64, 124, 186, 233, 252, 256},
+    {256,   1,   4,  30, 101, 195, 245, 254, 256}
+};
+
+const uint16_t ff_silk_model_gain_lowbits[] = {256, 32, 64, 96, 128, 160, 192, 224, 256};
+
+const uint16_t ff_silk_model_gain_delta[] = {
+    256,   6,  11,  22,  53, 185, 206, 214, 218, 221, 223, 225, 227, 228, 229, 230,
+    231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,
+    247, 248, 249, 250, 251, 252, 253, 254, 255, 256
+};
+const uint16_t ff_silk_model_lsf_s1[2][2][33] = {
+    {
+        {    // NB or MB, unvoiced
+            256,  44,  78, 108, 127, 148, 160, 171, 174, 177, 179, 195, 197, 199, 200, 205,
+            207, 208, 211, 214, 215, 216, 218, 220, 222, 225, 226, 235, 244, 246, 253, 255, 256
+        }, { // NB or MB, voiced
+            256,   1,  11,  12,  20,  23,  31,  39,  53,  66,  80,  81,  95, 107, 120, 131,
+            142, 154, 165, 175, 185, 196, 204, 213, 221, 228, 236, 237, 238, 244, 245, 251, 256
+        }
+    }, {
+        {    // WB, unvoiced
+            256,  31,  52,  55,  72,  73,  81,  98, 102, 103, 121, 137, 141, 143, 146, 147,
+            157, 158, 161, 177, 188, 204, 206, 208, 211, 213, 224, 225, 229, 238, 246, 253, 256
+        }, { // WB, voiced
+            256,   1,   5,  21,  26,  44,  55,  60,  74,  89,  90,  93, 105, 118, 132, 146,
+            152, 166, 178, 180, 186, 187, 199, 211, 222, 232, 235, 245, 250, 251, 252, 253, 256
+        }
+    }
+};
+
+const uint16_t ff_silk_model_lsf_s2[32][10] = {
+    // NB, MB
+    { 256,   1,   2,   3,  18, 242, 253, 254, 255, 256 },
+    { 256,   1,   2,   4,  38, 221, 253, 254, 255, 256 },
+    { 256,   1,   2,   6,  48, 197, 252, 254, 255, 256 },
+    { 256,   1,   2,  10,  62, 185, 246, 254, 255, 256 },
+    { 256,   1,   4,  20,  73, 174, 248, 254, 255, 256 },
+    { 256,   1,   4,  21,  76, 166, 239, 254, 255, 256 },
+    { 256,   1,   8,  32,  85, 159, 226, 252, 255, 256 },
+    { 256,   1,   2,  20,  83, 161, 219, 249, 255, 256 },
+
+    // WB
+    { 256,   1,   2,   3,  12, 244, 253, 254, 255, 256 },
+    { 256,   1,   2,   4,  32, 218, 253, 254, 255, 256 },
+    { 256,   1,   2,   5,  47, 199, 252, 254, 255, 256 },
+    { 256,   1,   2,  12,  61, 187, 252, 254, 255, 256 },
+    { 256,   1,   5,  24,  72, 172, 249, 254, 255, 256 },
+    { 256,   1,   2,  16,  70, 170, 242, 254, 255, 256 },
+    { 256,   1,   2,  17,  78, 165, 226, 251, 255, 256 },
+    { 256,   1,   8,  29,  79, 156, 237, 254, 255, 256 }
+};
+
+const uint16_t ff_silk_model_lsf_s2_ext[] = { 256, 156, 216, 240, 249, 253, 255, 256 };
+
+const uint16_t ff_silk_model_lsf_interpolation_offset[] = { 256, 13, 35, 64, 75, 256 };
+
+const uint16_t ff_silk_model_pitch_highbits[] = {
+    256,   3,   6,  12,  23,  44,  74, 106, 125, 136, 146, 158, 171, 184, 196, 207,
+    216, 224, 231, 237, 241, 243, 245, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256
+};
+
+const uint16_t ff_silk_model_pitch_lowbits_nb[] = { 256, 64, 128, 192, 256 };
+
+const uint16_t ff_silk_model_pitch_lowbits_mb[] = { 256, 43, 85, 128, 171, 213, 256 };
+
+const uint16_t ff_silk_model_pitch_lowbits_wb[] = { 256, 32, 64, 96, 128, 160, 192, 224, 256 };
+
+const uint16_t ff_silk_model_pitch_delta[] = {
+    256,  46,  48,  50,  53,  57,  63,  73,  88, 114, 152, 182, 204, 219, 229, 236,
+    242, 246, 250, 252, 254, 256
+};
+
+const uint16_t ff_silk_model_pitch_contour_nb10ms[] = { 256, 143, 193, 256 };
+
+const uint16_t ff_silk_model_pitch_contour_nb20ms[] = {
+    256,  68,  80, 101, 118, 137, 159, 189, 213, 230, 246, 256
+};
+
+const uint16_t ff_silk_model_pitch_contour_mbwb10ms[] = {
+    256,  91, 137, 176, 195, 209, 221, 229, 236, 242, 247, 252, 256
+};
+
+const uint16_t ff_silk_model_pitch_contour_mbwb20ms[] = {
+    256,  33,  55,  73,  89, 104, 118, 132, 145, 158, 168, 177, 186, 194, 200, 206,
+    212, 217, 221, 225, 229, 232, 235, 238, 240, 242, 244, 246, 248, 250, 252, 253,
+    254, 255, 256
+};
+
+const uint16_t ff_silk_model_ltp_filter[] = { 256, 77, 157, 256 };
+
+const uint16_t ff_silk_model_ltp_filter0_sel[] = {
+    256, 185, 200, 213, 226, 235, 244, 250, 256
+};
+
+const uint16_t ff_silk_model_ltp_filter1_sel[] = {
+    256,  57,  91, 112, 132, 147, 160, 172, 185, 195, 205, 214, 224, 233, 241, 248, 256
+};
+
+const uint16_t ff_silk_model_ltp_filter2_sel[] = {
+    256,  15,  31,  45,  57,  69,  81,  92, 103, 114, 124, 133, 142, 151, 160, 168,
+    176, 184, 192, 199, 206, 212, 218, 223, 227, 232, 236, 240, 244, 247, 251, 254, 256
+};
+
+const uint16_t ff_silk_model_ltp_scale_index[] = { 256, 128, 192, 256 };
+
+const uint16_t ff_silk_model_lcg_seed[] = { 256, 64, 128, 192, 256 };
+
+const uint16_t ff_silk_model_exc_rate[2][10] = {
+    { 256,  15,  66,  78, 124, 169, 182, 215, 242, 256 }, // unvoiced
+    { 256,  33,  63,  99, 116, 150, 199, 217, 238, 256 }  // voiced
+};
+
+const uint16_t ff_silk_model_pulse_count[11][19] = {
+    { 256, 131, 205, 230, 238, 241, 244, 245, 246,
+      247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },
+    { 256,  58, 151, 211, 234, 241, 244, 245, 246,
+      247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },
+    { 256,  43,  94, 140, 173, 197, 213, 224, 232,
+      238, 241, 244, 247, 249, 250, 251, 253, 254, 256 },
+    { 256,  17,  69, 140, 197, 228, 240, 245, 246,
+      247, 248, 249, 250, 251, 252, 253, 254, 255, 256 },
+    { 256,   6,  27,  68, 121, 170, 205, 226, 237,
+      243, 246, 248, 250, 251, 252, 253, 254, 255, 256 },
+    { 256,   7,  21,  43,  71, 100, 128, 153, 173,
+      190, 203, 214, 223, 230, 235, 239, 243, 246, 256 },
+    { 256,   2,   7,  21,  50,  92, 138, 179, 210,
+      229, 240, 246, 249, 251, 252, 253, 254, 255, 256 },
+    { 256,   1,   3,   7,  17,  36,  65, 100, 137,
+      171, 199, 219, 233, 241, 246, 250, 252, 254, 256 },
+    { 256,   1,   3,   5,  10,  19,  33,  53,  77,
+      104, 132, 158, 181, 201, 216, 227, 235, 241, 256 },
+    { 256,   1,   2,   3,   9,  36,  94, 150, 189,
+      214, 228, 238, 244, 247, 250, 252, 253, 254, 256 },
+    { 256,   2,   3,   9,  36,  94, 150, 189, 214,
+      228, 238, 244, 247, 250, 252, 253, 254, 256, 256 }
+};
+
+const uint16_t ff_silk_model_pulse_location[4][168] = {
+    {
+        256, 126, 256,
+        256, 56, 198, 256,
+        256, 25, 126, 230, 256,
+        256, 12, 72, 180, 244, 256,
+        256, 7, 42, 126, 213, 250, 256,
+        256, 4, 24, 83, 169, 232, 253, 256,
+        256, 3, 15, 53, 125, 200, 242, 254, 256,
+        256, 2, 10, 35, 89, 162, 221, 248, 255, 256,
+        256, 2, 7, 24, 63, 126, 191, 233, 251, 255, 256,
+        256, 1, 5, 17, 45, 94, 157, 211, 241, 252, 255, 256,
+        256, 1, 5, 13, 33, 70, 125, 182, 223, 245, 253, 255, 256,
+        256, 1, 4, 11, 26, 54, 98, 151, 199, 232, 248, 254, 255, 256,
+        256, 1, 3, 9, 21, 42, 77, 124, 172, 212, 237, 249, 254, 255, 256,
+        256, 1, 2, 6, 16, 33, 60, 97, 144, 187, 220, 241, 250, 254, 255, 256,
+        256, 1, 2, 3, 11, 25, 47, 80, 120, 163, 201, 229, 245, 253, 254, 255, 256,
+        256, 1, 2, 3, 4, 17, 35, 62, 98, 139, 180, 214, 238, 252, 253, 254, 255, 256
+    },{
+        256, 127, 256,
+        256, 53, 202, 256,
+        256, 22, 127, 233, 256,
+        256, 11, 72, 183, 246, 256,
+        256, 6, 41, 127, 215, 251, 256,
+        256, 4, 24, 83, 170, 232, 253, 256,
+        256, 3, 16, 56, 127, 200, 241, 254, 256,
+        256, 3, 12, 39, 92, 162, 218, 246, 255, 256,
+        256, 3, 11, 30, 67, 124, 185, 229, 249, 255, 256,
+        256, 3, 10, 25, 53, 97, 151, 200, 233, 250, 255, 256,
+        256, 1, 8, 21, 43, 77, 123, 171, 209, 237, 251, 255, 256,
+        256, 1, 2, 13, 35, 62, 97, 139, 186, 219, 244, 254, 255, 256,
+        256, 1, 2, 8, 22, 48, 85, 128, 171, 208, 234, 248, 254, 255, 256,
+        256, 1, 2, 6, 16, 36, 67, 107, 149, 189, 220, 240, 250, 254, 255, 256,
+        256, 1, 2, 5, 13, 29, 55, 90, 128, 166, 201, 227, 243, 251, 254, 255, 256,
+        256, 1, 2, 4, 10, 22, 43, 73, 109, 147, 183, 213, 234, 246, 252, 254, 255, 256
+    },{
+        256, 127, 256,
+        256, 49, 206, 256,
+        256, 20, 127, 236, 256,
+        256, 11, 71, 184, 246, 256,
+        256, 7, 43, 127, 214, 250, 256,
+        256, 6, 30, 87, 169, 229, 252, 256,
+        256, 5, 23, 62, 126, 194, 236, 252, 256,
+        256, 6, 20, 49, 96, 157, 209, 239, 253, 256,
+        256, 1, 16, 39, 74, 125, 175, 215, 245, 255, 256,
+        256, 1, 2, 23, 55, 97, 149, 195, 236, 254, 255, 256,
+        256, 1, 7, 23, 50, 86, 128, 170, 206, 233, 249, 255, 256,
+        256, 1, 6, 18, 39, 70, 108, 148, 186, 217, 238, 250, 255, 256,
+        256, 1, 4, 13, 30, 56, 90, 128, 166, 200, 226, 243, 252, 255, 256,
+        256, 1, 4, 11, 25, 47, 76, 110, 146, 180, 209, 231, 245, 252, 255, 256,
+        256, 1, 3, 8, 19, 37, 62, 93, 128, 163, 194, 219, 237, 248, 253, 255, 256,
+        256, 1, 2, 6, 15, 30, 51, 79, 111, 145, 177, 205, 226, 241, 250, 254, 255, 256
+    },{
+        256, 128, 256,
+        256, 42, 214, 256,
+        256, 21, 128, 235, 256,
+        256, 12, 72, 184, 245, 256,
+        256, 8, 42, 128, 214, 249, 256,
+        256, 8, 31, 86, 176, 231, 251, 256,
+        256, 5, 20, 58, 130, 202, 238, 253, 256,
+        256, 6, 18, 45, 97, 174, 221, 241, 251, 256,
+        256, 6, 25, 53, 88, 128, 168, 203, 231, 250, 256,
+        256, 4, 18, 40, 71, 108, 148, 185, 216, 238, 252, 256,
+        256, 3, 13, 31, 57, 90, 128, 166, 199, 225, 243, 253, 256,
+        256, 2, 10, 23, 44, 73, 109, 147, 183, 212, 233, 246, 254, 256,
+        256, 1, 6, 16, 33, 58, 90, 128, 166, 198, 223, 240, 250, 255, 256,
+        256, 1, 5, 12, 25, 46, 75, 110, 146, 181, 210, 231, 244, 251, 255, 256,
+        256, 1, 3, 8, 18, 35, 60, 92, 128, 164, 196, 221, 238, 248, 253, 255, 256,
+        256, 1, 3, 7, 14, 27, 48, 76, 110, 146, 180, 208, 229, 242, 249, 253, 255, 256
+    }
+};
+
+const uint16_t ff_silk_model_excitation_lsb[] = {256, 136, 256};
+
+const uint16_t ff_silk_model_excitation_sign[3][2][7][3] = {
+    {    // Inactive
+        {    // Low offset
+            {256,   2, 256},
+            {256, 207, 256},
+            {256, 189, 256},
+            {256, 179, 256},
+            {256, 174, 256},
+            {256, 163, 256},
+            {256, 157, 256}
+        }, { // High offset
+            {256,  58, 256},
+            {256, 245, 256},
+            {256, 238, 256},
+            {256, 232, 256},
+            {256, 225, 256},
+            {256, 220, 256},
+            {256, 211, 256}
+        }
+    }, { // Unvoiced
+        {    // Low offset
+            {256,   1, 256},
+            {256, 210, 256},
+            {256, 190, 256},
+            {256, 178, 256},
+            {256, 169, 256},
+            {256, 162, 256},
+            {256, 152, 256}
+        }, { // High offset
+            {256,  48, 256},
+            {256, 242, 256},
+            {256, 235, 256},
+            {256, 224, 256},
+            {256, 214, 256},
+            {256, 205, 256},
+            {256, 190, 256}
+        }
+    }, { // Voiced
+        {    // Low offset
+            {256,   1, 256},
+            {256, 162, 256},
+            {256, 152, 256},
+            {256, 147, 256},
+            {256, 144, 256},
+            {256, 141, 256},
+            {256, 138, 256}
+        }, { // High offset
+            {256,   8, 256},
+            {256, 203, 256},
+            {256, 187, 256},
+            {256, 176, 256},
+            {256, 168, 256},
+            {256, 161, 256},
+            {256, 154, 256}
+        }
+    }
+};
+
+const int16_t ff_silk_stereo_weights[] = {
+    -13732, -10050,  -8266,  -7526,  -6500,  -5000,  -2950,   -820,
+       820,   2950,   5000,   6500,   7526,   8266,  10050,  13732
+};
+
+const uint8_t ff_silk_lsf_s2_model_sel_nbmb[32][10] = {
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { 1, 3, 1, 2, 2, 1, 2, 1, 1, 1 },
+    { 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
+    { 1, 2, 2, 2, 2, 1, 2, 1, 1, 1 },
+    { 2, 3, 3, 3, 3, 2, 2, 2, 2, 2 },
+    { 0, 5, 3, 3, 2, 2, 2, 2, 1, 1 },
+    { 0, 2, 2, 2, 2, 2, 2, 2, 2, 1 },
+    { 2, 3, 6, 4, 4, 4, 5, 4, 5, 5 },
+    { 2, 4, 5, 5, 4, 5, 4, 6, 4, 4 },
+    { 2, 4, 4, 7, 4, 5, 4, 5, 5, 4 },
+    { 4, 3, 3, 3, 2, 3, 2, 2, 2, 2 },
+    { 1, 5, 5, 6, 4, 5, 4, 5, 5, 5 },
+    { 2, 7, 4, 6, 5, 5, 5, 5, 5, 5 },
+    { 2, 7, 5, 5, 5, 5, 5, 6, 5, 4 },
+    { 3, 3, 5, 4, 4, 5, 4, 5, 4, 4 },
+    { 2, 3, 3, 5, 5, 4, 4, 4, 4, 4 },
+    { 2, 4, 4, 6, 4, 5, 4, 5, 5, 5 },
+    { 2, 5, 4, 6, 5, 5, 5, 4, 5, 4 },
+    { 2, 7, 4, 5, 4, 5, 4, 5, 5, 5 },
+    { 2, 5, 4, 6, 7, 6, 5, 6, 5, 4 },
+    { 3, 6, 7, 4, 6, 5, 5, 6, 4, 5 },
+    { 2, 7, 6, 4, 4, 4, 5, 4, 5, 5 },
+    { 4, 5, 5, 4, 6, 6, 5, 6, 5, 4 },
+    { 2, 5, 5, 6, 5, 6, 4, 6, 4, 4 },
+    { 4, 5, 5, 5, 3, 7, 4, 5, 5, 4 },
+    { 2, 3, 4, 5, 5, 6, 4, 5, 5, 4 },
+    { 2, 3, 2, 3, 3, 4, 2, 3, 3, 3 },
+    { 1, 1, 2, 2, 2, 2, 2, 3, 2, 2 },
+    { 4, 5, 5, 6, 6, 6, 5, 6, 4, 5 },
+    { 3, 5, 5, 4, 4, 4, 4, 3, 3, 2 },
+    { 2, 5, 3, 7, 5, 5, 4, 4, 5, 4 },
+    { 4, 4, 5, 4, 5, 6, 5, 6, 5, 4 }
+};
+
+const uint8_t ff_silk_lsf_s2_model_sel_wb[32][16] = {
+    {  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },
+    { 10, 11, 11, 11, 11, 11, 10, 10, 10, 10, 10,  9,  9,  9,  8, 11 },
+    { 10, 13, 13, 11, 15, 12, 12, 13, 10, 13, 12, 13, 13, 12, 11, 11 },
+    {  8, 10,  9, 10, 10,  9,  9,  9,  9,  9,  8,  8,  8,  8,  8,  9 },
+    {  8, 14, 13, 12, 14, 12, 15, 13, 12, 12, 12, 13, 13, 12, 12, 11 },
+    {  8, 11, 13, 13, 12, 11, 11, 13, 11, 11, 11, 11, 11, 11, 10, 12 },
+    {  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },
+    {  8, 10, 14, 11, 15, 10, 13, 11, 12, 13, 13, 12, 11, 11, 10, 11 },
+    {  8, 14, 10, 14, 14, 12, 13, 12, 14, 13, 12, 12, 13, 11, 11, 11 },
+    { 10,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },
+    {  8,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  9 },
+    { 10, 10, 11, 12, 13, 11, 11, 11, 11, 11, 11, 11, 10, 10,  9, 11 },
+    { 10, 10, 11, 11, 12, 11, 11, 11, 11, 11, 11, 11, 11, 10,  9, 11 },
+    { 11, 12, 12, 12, 14, 12, 12, 13, 11, 13, 12, 12, 13, 12, 11, 12 },
+    {  8, 14, 12, 13, 12, 15, 13, 10, 14, 13, 15, 12, 12, 11, 13, 11 },
+    {  8,  9,  8,  9,  9,  9,  9,  9,  9,  9,  8,  8,  8,  8,  9,  8 },
+    {  9, 14, 13, 15, 13, 12, 13, 11, 12, 13, 12, 12, 12, 11, 11, 12 },
+    {  9, 11, 11, 12, 12, 11, 11, 13, 10, 11, 11, 13, 13, 13, 11, 12 },
+    { 10, 11, 11, 10, 10, 10, 11, 10,  9, 10,  9, 10,  9,  9,  9, 12 },
+    {  8, 10, 11, 13, 11, 11, 10, 10, 10,  9,  9,  8,  8,  8,  8,  8 },
+    { 11, 12, 11, 13, 11, 11, 10, 10,  9,  9,  9,  9,  9, 10, 10, 12 },
+    { 10, 14, 11, 15, 15, 12, 13, 12, 13, 11, 13, 11, 11, 10, 11, 11 },
+    { 10, 11, 13, 14, 14, 11, 13, 11, 12, 12, 11, 11, 11, 11, 10, 12 },
+    {  9, 11, 11, 12, 12, 12, 12, 11, 13, 13, 13, 11,  9,  9,  9,  9 },
+    { 10, 13, 11, 14, 14, 12, 15, 12, 12, 13, 11, 12, 12, 11, 11, 11 },
+    {  8, 14,  9,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8 },
+    {  8, 14, 14, 11, 13, 10, 13, 13, 11, 12, 12, 15, 15, 12, 12, 12 },
+    { 11, 11, 15, 11, 13, 12, 11, 11, 11, 10, 10, 11, 11, 11, 10, 11 },
+    {  8,  8,  9,  8,  8,  8, 10,  9, 10,  9,  9, 10, 10, 10,  9,  9 },
+    {  8, 11, 10, 13, 11, 11, 10, 11, 10,  9,  8,  8,  9,  8,  8,  9 },
+    { 11, 13, 13, 12, 15, 13, 11, 11, 10, 11, 10, 10,  9,  8,  9,  8 },
+    { 10, 11, 13, 11, 12, 11, 11, 11, 10,  9, 10, 14, 12,  8,  8,  8 }
+};
+
+const uint8_t ff_silk_lsf_pred_weights_nbmb[2][9] = {
+    {179, 138, 140, 148, 151, 149, 153, 151, 163},
+    {116,  67,  82,  59,  92,  72, 100,  89,  92}
+};
+
+const uint8_t ff_silk_lsf_pred_weights_wb[2][15] = {
+    {175, 148, 160, 176, 178, 173, 174, 164, 177, 174, 196, 182, 198, 192, 182},
+    { 68,  62,  66,  60,  72, 117,  85,  90, 118, 136, 151, 142, 160, 142, 155}
+};
+
+const uint8_t ff_silk_lsf_weight_sel_nbmb[32][9] = {
+    { 0, 1, 0, 0, 0, 0, 0, 0, 0 },
+    { 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { 1, 1, 1, 0, 0, 0, 0, 1, 0 },
+    { 0, 1, 0, 0, 0, 0, 0, 0, 0 },
+    { 0, 1, 0, 0, 0, 0, 0, 0, 0 },
+    { 1, 0, 1, 1, 0, 0, 0, 1, 0 },
+    { 0, 1, 1, 0, 0, 1, 1, 0, 0 },
+    { 0, 0, 1, 1, 0, 1, 0, 1, 1 },
+    { 0, 0, 1, 1, 0, 0, 1, 1, 1 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { 0, 1, 0, 1, 1, 1, 1, 1, 0 },
+    { 0, 1, 0, 1, 1, 1, 1, 1, 0 },
+    { 0, 1, 1, 1, 1, 1, 1, 1, 0 },
+    { 1, 0, 1, 1, 0, 1, 1, 1, 1 },
+    { 0, 1, 1, 1, 1, 1, 0, 1, 0 },
+    { 0, 0, 1, 1, 0, 1, 0, 1, 0 },
+    { 0, 0, 1, 1, 1, 0, 1, 1, 1 },
+    { 0, 1, 1, 0, 0, 1, 1, 1, 0 },
+    { 0, 0, 0, 1, 1, 1, 0, 1, 0 },
+    { 0, 1, 1, 0, 0, 1, 0, 1, 0 },
+    { 0, 1, 1, 0, 0, 0, 1, 1, 0 },
+    { 0, 0, 0, 0, 0, 1, 1, 1, 1 },
+    { 0, 0, 1, 1, 0, 0, 0, 1, 1 },
+    { 0, 0, 0, 1, 0, 1, 1, 1, 1 },
+    { 0, 1, 1, 1, 1, 1, 1, 1, 0 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { 0, 0, 1, 0, 1, 1, 0, 1, 0 },
+    { 1, 0, 0, 1, 0, 0, 0, 0, 0 },
+    { 0, 0, 0, 1, 1, 0, 1, 0, 1 },
+    { 1, 0, 1, 1, 0, 1, 1, 1, 1 }
+};
+
+const uint8_t ff_silk_lsf_weight_sel_wb[32][15] = {
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
+    { 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0 },
+    { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0 },
+    { 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1 },
+    { 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
+    { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0 },
+    { 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
+    { 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0 },
+    { 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1 },
+    { 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0 },
+    { 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0 },
+    { 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+    { 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0 },
+    { 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0 },
+    { 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0 },
+    { 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
+    { 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1 },
+    { 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
+    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
+    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
+    { 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0 }
+};
+
+const uint8_t ff_silk_lsf_codebook_nbmb[32][10] = {
+    { 12,  35,  60,  83, 108, 132, 157, 180, 206, 228 },
+    { 15,  32,  55,  77, 101, 125, 151, 175, 201, 225 },
+    { 19,  42,  66,  89, 114, 137, 162, 184, 209, 230 },
+    { 12,  25,  50,  72,  97, 120, 147, 172, 200, 223 },
+    { 26,  44,  69,  90, 114, 135, 159, 180, 205, 225 },
+    { 13,  22,  53,  80, 106, 130, 156, 180, 205, 228 },
+    { 15,  25,  44,  64,  90, 115, 142, 168, 196, 222 },
+    { 19,  24,  62,  82, 100, 120, 145, 168, 190, 214 },
+    { 22,  31,  50,  79, 103, 120, 151, 170, 203, 227 },
+    { 21,  29,  45,  65, 106, 124, 150, 171, 196, 224 },
+    { 30,  49,  75,  97, 121, 142, 165, 186, 209, 229 },
+    { 19,  25,  52,  70,  93, 116, 143, 166, 192, 219 },
+    { 26,  34,  62,  75,  97, 118, 145, 167, 194, 217 },
+    { 25,  33,  56,  70,  91, 113, 143, 165, 196, 223 },
+    { 21,  34,  51,  72,  97, 117, 145, 171, 196, 222 },
+    { 20,  29,  50,  67,  90, 117, 144, 168, 197, 221 },
+    { 22,  31,  48,  66,  95, 117, 146, 168, 196, 222 },
+    { 24,  33,  51,  77, 116, 134, 158, 180, 200, 224 },
+    { 21,  28,  70,  87, 106, 124, 149, 170, 194, 217 },
+    { 26,  33,  53,  64,  83, 117, 152, 173, 204, 225 },
+    { 27,  34,  65,  95, 108, 129, 155, 174, 210, 225 },
+    { 20,  26,  72,  99, 113, 131, 154, 176, 200, 219 },
+    { 34,  43,  61,  78,  93, 114, 155, 177, 205, 229 },
+    { 23,  29,  54,  97, 124, 138, 163, 179, 209, 229 },
+    { 30,  38,  56,  89, 118, 129, 158, 178, 200, 231 },
+    { 21,  29,  49,  63,  85, 111, 142, 163, 193, 222 },
+    { 27,  48,  77, 103, 133, 158, 179, 196, 215, 232 },
+    { 29,  47,  74,  99, 124, 151, 176, 198, 220, 237 },
+    { 33,  42,  61,  76,  93, 121, 155, 174, 207, 225 },
+    { 29,  53,  87, 112, 136, 154, 170, 188, 208, 227 },
+    { 24,  30,  52,  84, 131, 150, 166, 186, 203, 229 },
+    { 37,  48,  64,  84, 104, 118, 156, 177, 201, 230 }
+};
+
+const uint8_t ff_silk_lsf_codebook_wb[32][16] = {
+    {  7,  23,  38,  54,  69,  85, 100, 116, 131, 147, 162, 178, 193, 208, 223, 239 },
+    { 13,  25,  41,  55,  69,  83,  98, 112, 127, 142, 157, 171, 187, 203, 220, 236 },
+    { 15,  21,  34,  51,  61,  78,  92, 106, 126, 136, 152, 167, 185, 205, 225, 240 },
+    { 10,  21,  36,  50,  63,  79,  95, 110, 126, 141, 157, 173, 189, 205, 221, 237 },
+    { 17,  20,  37,  51,  59,  78,  89, 107, 123, 134, 150, 164, 184, 205, 224, 240 },
+    { 10,  15,  32,  51,  67,  81,  96, 112, 129, 142, 158, 173, 189, 204, 220, 236 },
+    {  8,  21,  37,  51,  65,  79,  98, 113, 126, 138, 155, 168, 179, 192, 209, 218 },
+    { 12,  15,  34,  55,  63,  78,  87, 108, 118, 131, 148, 167, 185, 203, 219, 236 },
+    { 16,  19,  32,  36,  56,  79,  91, 108, 118, 136, 154, 171, 186, 204, 220, 237 },
+    { 11,  28,  43,  58,  74,  89, 105, 120, 135, 150, 165, 180, 196, 211, 226, 241 },
+    {  6,  16,  33,  46,  60,  75,  92, 107, 123, 137, 156, 169, 185, 199, 214, 225 },
+    { 11,  19,  30,  44,  57,  74,  89, 105, 121, 135, 152, 169, 186, 202, 218, 234 },
+    { 12,  19,  29,  46,  57,  71,  88, 100, 120, 132, 148, 165, 182, 199, 216, 233 },
+    { 17,  23,  35,  46,  56,  77,  92, 106, 123, 134, 152, 167, 185, 204, 222, 237 },
+    { 14,  17,  45,  53,  63,  75,  89, 107, 115, 132, 151, 171, 188, 206, 221, 240 },
+    {  9,  16,  29,  40,  56,  71,  88, 103, 119, 137, 154, 171, 189, 205, 222, 237 },
+    { 16,  19,  36,  48,  57,  76,  87, 105, 118, 132, 150, 167, 185, 202, 218, 236 },
+    { 12,  17,  29,  54,  71,  81,  94, 104, 126, 136, 149, 164, 182, 201, 221, 237 },
+    { 15,  28,  47,  62,  79,  97, 115, 129, 142, 155, 168, 180, 194, 208, 223, 238 },
+    {  8,  14,  30,  45,  62,  78,  94, 111, 127, 143, 159, 175, 192, 207, 223, 239 },
+    { 17,  30,  49,  62,  79,  92, 107, 119, 132, 145, 160, 174, 190, 204, 220, 235 },
+    { 14,  19,  36,  45,  61,  76,  91, 108, 121, 138, 154, 172, 189, 205, 222, 238 },
+    { 12,  18,  31,  45,  60,  76,  91, 107, 123, 138, 154, 171, 187, 204, 221, 236 },
+    { 13,  17,  31,  43,  53,  70,  83, 103, 114, 131, 149, 167, 185, 203, 220, 237 },
+    { 17,  22,  35,  42,  58,  78,  93, 110, 125, 139, 155, 170, 188, 206, 224, 240 },
+    {  8,  15,  34,  50,  67,  83,  99, 115, 131, 146, 162, 178, 193, 209, 224, 239 },
+    { 13,  16,  41,  66,  73,  86,  95, 111, 128, 137, 150, 163, 183, 206, 225, 241 },
+    { 17,  25,  37,  52,  63,  75,  92, 102, 119, 132, 144, 160, 175, 191, 212, 231 },
+    { 19,  31,  49,  65,  83, 100, 117, 133, 147, 161, 174, 187, 200, 213, 227, 242 },
+    { 18,  31,  52,  68,  88, 103, 117, 126, 138, 149, 163, 177, 192, 207, 223, 239 },
+    { 16,  29,  47,  61,  76,  90, 106, 119, 133, 147, 161, 176, 193, 209, 224, 240 },
+    { 15,  21,  35,  50,  61,  73,  86,  97, 110, 119, 129, 141, 175, 198, 218, 237 }
+};
+
+const uint16_t ff_silk_lsf_min_spacing_nbmb[] = {
+    250, 3, 6, 3, 3, 3, 4, 3, 3, 3, 461
+};
+
+const uint16_t ff_silk_lsf_min_spacing_wb[] = {
+    100, 3, 40, 3, 3, 3, 5, 14, 14, 10, 11, 3, 8, 9, 7, 3, 347
+};
+
+const uint8_t ff_silk_lsf_ordering_nbmb[] = {
+    0, 9, 6, 3, 4, 5, 8, 1, 2, 7
+};
+
+const uint8_t ff_silk_lsf_ordering_wb[] = {
+    0, 15, 8, 7, 4, 11, 12, 3, 2, 13, 10, 5, 6, 9, 14, 1
+};
+
+const int16_t ff_silk_cosine[] = { /* (0.12) */
+     4096,  4095,  4091,  4085,
+     4076,  4065,  4052,  4036,
+     4017,  3997,  3973,  3948,
+     3920,  3889,  3857,  3822,
+     3784,  3745,  3703,  3659,
+     3613,  3564,  3513,  3461,
+     3406,  3349,  3290,  3229,
+     3166,  3102,  3035,  2967,
+     2896,  2824,  2751,  2676,
+     2599,  2520,  2440,  2359,
+     2276,  2191,  2106,  2019,
+     1931,  1842,  1751,  1660,
+     1568,  1474,  1380,  1285,
+     1189,  1093,   995,   897,
+      799,   700,   601,   501,
+      401,   301,   201,   101,
+        0,  -101,  -201,  -301,
+     -401,  -501,  -601,  -700,
+     -799,  -897,  -995, -1093,
+    -1189, -1285, -1380, -1474,
+    -1568, -1660, -1751, -1842,
+    -1931, -2019, -2106, -2191,
+    -2276, -2359, -2440, -2520,
+    -2599, -2676, -2751, -2824,
+    -2896, -2967, -3035, -3102,
+    -3166, -3229, -3290, -3349,
+    -3406, -3461, -3513, -3564,
+    -3613, -3659, -3703, -3745,
+    -3784, -3822, -3857, -3889,
+    -3920, -3948, -3973, -3997,
+    -4017, -4036, -4052, -4065,
+    -4076, -4085, -4091, -4095,
+    -4096
+};
+
+const uint16_t ff_silk_pitch_scale[]   = {  4,   6,   8};
+
+const uint16_t ff_silk_pitch_min_lag[] = { 16,  24,  32};
+
+const uint16_t ff_silk_pitch_max_lag[] = {144, 216, 288};
+
+const int8_t ff_silk_pitch_offset_nb10ms[3][2] = {
+    { 0,  0},
+    { 1,  0},
+    { 0,  1}
+};
+
+const int8_t ff_silk_pitch_offset_nb20ms[11][4] = {
+    { 0,  0,  0,  0},
+    { 2,  1,  0, -1},
+    {-1,  0,  1,  2},
+    {-1,  0,  0,  1},
+    {-1,  0,  0,  0},
+    { 0,  0,  0,  1},
+    { 0,  0,  1,  1},
+    { 1,  1,  0,  0},
+    { 1,  0,  0,  0},
+    { 0,  0,  0, -1},
+    { 1,  0,  0, -1}
+};
+
+const int8_t ff_silk_pitch_offset_mbwb10ms[12][2] = {
+    { 0,  0},
+    { 0,  1},
+    { 1,  0},
+    {-1,  1},
+    { 1, -1},
+    {-1,  2},
+    { 2, -1},
+    {-2,  2},
+    { 2, -2},
+    {-2,  3},
+    { 3, -2},
+    {-3,  3}
+};
+
+const int8_t ff_silk_pitch_offset_mbwb20ms[34][4] = {
+    { 0,  0,  0,  0},
+    { 0,  0,  1,  1},
+    { 1,  1,  0,  0},
+    {-1,  0,  0,  0},
+    { 0,  0,  0,  1},
+    { 1,  0,  0,  0},
+    {-1,  0,  0,  1},
+    { 0,  0,  0, -1},
+    {-1,  0,  1,  2},
+    { 1,  0,  0, -1},
+    {-2, -1,  1,  2},
+    { 2,  1,  0, -1},
+    {-2,  0,  0,  2},
+    {-2,  0,  1,  3},
+    { 2,  1, -1, -2},
+    {-3, -1,  1,  3},
+    { 2,  0,  0, -2},
+    { 3,  1,  0, -2},
+    {-3, -1,  2,  4},
+    {-4, -1,  1,  4},
+    { 3,  1, -1, -3},
+    {-4, -1,  2,  5},
+    { 4,  2, -1, -3},
+    { 4,  1, -1, -4},
+    {-5, -1,  2,  6},
+    { 5,  2, -1, -4},
+    {-6, -2,  2,  6},
+    {-5, -2,  2,  5},
+    { 6,  2, -1, -5},
+    {-7, -2,  3,  8},
+    { 6,  2, -2, -6},
+    { 5,  2, -2, -5},
+    { 8,  3, -2, -7},
+    {-9, -3,  3,  9}
+};
+
+const int8_t ff_silk_ltp_filter0_taps[8][5] = {
+    {  4,   6,  24,   7,   5},
+    {  0,   0,   2,   0,   0},
+    { 12,  28,  41,  13,  -4},
+    { -9,  15,  42,  25,  14},
+    {  1,  -2,  62,  41,  -9},
+    {-10,  37,  65,  -4,   3},
+    { -6,   4,  66,   7,  -8},
+    { 16,  14,  38,  -3,  33}
+};
+
+const int8_t ff_silk_ltp_filter1_taps[16][5] = {
+    { 13,  22,  39,  23,  12},
+    { -1,  36,  64,  27,  -6},
+    { -7,  10,  55,  43,  17},
+    {  1,   1,   8,   1,   1},
+    {  6, -11,  74,  53,  -9},
+    {-12,  55,  76, -12,   8},
+    { -3,   3,  93,  27,  -4},
+    { 26,  39,  59,   3,  -8},
+    {  2,   0,  77,  11,   9},
+    { -8,  22,  44,  -6,   7},
+    { 40,   9,  26,   3,   9},
+    { -7,  20, 101,  -7,   4},
+    {  3,  -8,  42,  26,   0},
+    {-15,  33,  68,   2,  23},
+    { -2,  55,  46,  -2,  15},
+    {  3,  -1,  21,  16,  41}
+};
+
+const int8_t ff_silk_ltp_filter2_taps[32][5] = {
+    { -6,  27,  61,  39,   5},
+    {-11,  42,  88,   4,   1},
+    { -2,  60,  65,   6,  -4},
+    { -1,  -5,  73,  56,   1},
+    { -9,  19,  94,  29,  -9},
+    {  0,  12,  99,   6,   4},
+    {  8, -19, 102,  46, -13},
+    {  3,   2,  13,   3,   2},
+    {  9, -21,  84,  72, -18},
+    {-11,  46, 104, -22,   8},
+    { 18,  38,  48,  23,   0},
+    {-16,  70,  83, -21,  11},
+    {  5, -11, 117,  22,  -8},
+    { -6,  23, 117, -12,   3},
+    {  3,  -8,  95,  28,   4},
+    {-10,  15,  77,  60, -15},
+    { -1,   4, 124,   2,  -4},
+    {  3,  38,  84,  24, -25},
+    {  2,  13,  42,  13,  31},
+    { 21,  -4,  56,  46,  -1},
+    { -1,  35,  79, -13,  19},
+    { -7,  65,  88,  -9, -14},
+    { 20,   4,  81,  49, -29},
+    { 20,   0,  75,   3, -17},
+    {  5,  -9,  44,  92,  -8},
+    {  1,  -3,  22,  69,  31},
+    { -6,  95,  41, -12,   5},
+    { 39,  67,  16,  -4,   1},
+    {  0,  -6, 120,  55, -36},
+    {-13,  44, 122,   4, -24},
+    { 81,   5,  11,   3,   7},
+    {  2,   0,   9,  10,  88}
+};
+
+const uint16_t ff_silk_ltp_scale_factor[] = {15565, 12288, 8192};
+
+const uint8_t ff_silk_shell_blocks[3][2] = {
+    { 5, 10}, // NB
+    { 8, 15}, // MB
+    {10, 20}  // WB
+};
+
+const uint8_t ff_silk_quant_offset[2][2] = { /* (0.23) */
+    {25, 60}, // Inactive or Unvoiced
+    { 8, 25}  // Voiced
+};
+
+const int ff_silk_stereo_interp_len[3] = {
+    64, 96, 128
+};
+
+const uint16_t ff_celt_model_tapset[] = { 4, 2, 3, 4 };
+
+const uint16_t ff_celt_model_spread[] = { 32, 7, 9, 30, 32 };
+
+const uint16_t ff_celt_model_alloc_trim[] = {
+    128,   2,   4,   9,  19,  41,  87, 109, 119, 124, 126, 128
+};
+
+const uint16_t ff_celt_model_energy_small[] = { 4, 2, 3, 4 };
+
+const uint8_t ff_celt_freq_bands[] = { /* in steps of 200Hz */
+    0,  1,  2,  3,  4,  5,  6,  7,  8, 10, 12, 14, 16, 20, 24, 28, 34, 40, 48, 60, 78, 100
+};
+
+const uint8_t ff_celt_freq_range[] = {
+    1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  4,  4,  4,  6,  6,  8, 12, 18, 22
+};
+
+const uint8_t ff_celt_log_freq_range[] = {
+    0,  0,  0,  0,  0,  0,  0,  0,  8,  8,  8,  8, 16, 16, 16, 21, 21, 24, 29, 34, 36
+};
+
+/* Positive - increased freqeuency resolution (only possible on transients)
+ * Negative - increased time resolution */
+const int8_t ff_celt_tf_select[4][2][2][2] = {
+    /*          OFF                        ON                Transient frame */
+    /*     OFF        ON             OFF        ON           TF select flag  */
+    /*   OFF  ON    OFF  ON        OFF  ON    OFF  ON        TF change flag  */
+    { { { 0, -1 }, { 0, -1 } }, { { 0, -1 }, { 0, -1 } } }, /* 120 */
+    { { { 0, -1 }, { 0, -2 } }, { { 1,  0 }, { 1, -1 } } }, /* 240 */
+    { { { 0, -2 }, { 0, -3 } }, { { 2,  0 }, { 1, -1 } } }, /* 480 */
+    { { { 0, -2 }, { 0, -3 } }, { { 3,  0 }, { 1, -1 } } }  /* 960 */
+};
+
+const float ff_celt_mean_energy[] = {
+    6.437500f, 6.250000f, 5.750000f, 5.312500f, 5.062500f,
+    4.812500f, 4.500000f, 4.375000f, 4.875000f, 4.687500f,
+    4.562500f, 4.437500f, 4.875000f, 4.625000f, 4.312500f,
+    4.500000f, 4.375000f, 4.625000f, 4.750000f, 4.437500f,
+    3.750000f, 3.750000f, 3.750000f, 3.750000f, 3.750000f
+};
+
+const float ff_celt_alpha_coef[] = {
+    29440.0f/32768.0f,    26112.0f/32768.0f,    21248.0f/32768.0f,    16384.0f/32768.0f
+};
+
+const float ff_celt_beta_coef[] = {
+    1.0f - (30147.0f/32768.0f), 1.0f - (22282.0f/32768.0f), 1.0f - (12124.0f/32768.0f), 1.0f - (6554.0f/32768.0f),
+};
+
+const uint8_t ff_celt_coarse_energy_dist[4][2][42] = {
+    {
+        {       // 120-sample inter
+             72, 127,  65, 129,  66, 128,  65, 128,  64, 128,  62, 128,  64, 128,
+             64, 128,  92,  78,  92,  79,  92,  78,  90,  79, 116,  41, 115,  40,
+            114,  40, 132,  26, 132,  26, 145,  17, 161,  12, 176,  10, 177,  11
+        }, {    // 120-sample intra
+             24, 179,  48, 138,  54, 135,  54, 132,  53, 134,  56, 133,  55, 132,
+             55, 132,  61, 114,  70,  96,  74,  88,  75,  88,  87,  74,  89,  66,
+             91,  67, 100,  59, 108,  50, 120,  40, 122,  37,  97,  43,  78,  50
+        }
+    }, {
+        {       // 240-sample inter
+             83,  78,  84,  81,  88,  75,  86,  74,  87,  71,  90,  73,  93,  74,
+             93,  74, 109,  40, 114,  36, 117,  34, 117,  34, 143,  17, 145,  18,
+            146,  19, 162,  12, 165,  10, 178,   7, 189,   6, 190,   8, 177,   9
+        }, {    // 240-sample intra
+             23, 178,  54, 115,  63, 102,  66,  98,  69,  99,  74,  89,  71,  91,
+             73,  91,  78,  89,  86,  80,  92,  66,  93,  64, 102,  59, 103,  60,
+            104,  60, 117,  52, 123,  44, 138,  35, 133,  31,  97,  38,  77,  45
+        }
+    }, {
+        {       // 480-sample inter
+             61,  90,  93,  60, 105,  42, 107,  41, 110,  45, 116,  38, 113,  38,
+            112,  38, 124,  26, 132,  27, 136,  19, 140,  20, 155,  14, 159,  16,
+            158,  18, 170,  13, 177,  10, 187,   8, 192,   6, 175,   9, 159,  10
+        }, {    // 480-sample intra
+             21, 178,  59, 110,  71,  86,  75,  85,  84,  83,  91,  66,  88,  73,
+             87,  72,  92,  75,  98,  72, 105,  58, 107,  54, 115,  52, 114,  55,
+            112,  56, 129,  51, 132,  40, 150,  33, 140,  29,  98,  35,  77,  42
+        }
+    }, {
+        {       // 960-sample inter
+             42, 121,  96,  66, 108,  43, 111,  40, 117,  44, 123,  32, 120,  36,
+            119,  33, 127,  33, 134,  34, 139,  21, 147,  23, 152,  20, 158,  25,
+            154,  26, 166,  21, 173,  16, 184,  13, 184,  10, 150,  13, 139,  15
+        }, {    // 960-sample intra
+             22, 178,  63, 114,  74,  82,  84,  83,  92,  82, 103,  62,  96,  72,
+             96,  67, 101,  73, 107,  72, 113,  55, 118,  52, 125,  52, 118,  52,
+            117,  55, 135,  49, 137,  39, 157,  32, 145,  29,  97,  33,  77,  40
+        }
+    }
+};
+
+const uint8_t ff_celt_static_alloc[11][21] = {  /* 1/32 bit/sample */
+    {   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0 },
+    {  90,  80,  75,  69,  63,  56,  49,  40,  34,  29,  20,  18,  10,   0,   0,   0,   0,   0,   0,   0,   0 },
+    { 110, 100,  90,  84,  78,  71,  65,  58,  51,  45,  39,  32,  26,  20,  12,   0,   0,   0,   0,   0,   0 },
+    { 118, 110, 103,  93,  86,  80,  75,  70,  65,  59,  53,  47,  40,  31,  23,  15,   4,   0,   0,   0,   0 },
+    { 126, 119, 112, 104,  95,  89,  83,  78,  72,  66,  60,  54,  47,  39,  32,  25,  17,  12,   1,   0,   0 },
+    { 134, 127, 120, 114, 103,  97,  91,  85,  78,  72,  66,  60,  54,  47,  41,  35,  29,  23,  16,  10,   1 },
+    { 144, 137, 130, 124, 113, 107, 101,  95,  88,  82,  76,  70,  64,  57,  51,  45,  39,  33,  26,  15,   1 },
+    { 152, 145, 138, 132, 123, 117, 111, 105,  98,  92,  86,  80,  74,  67,  61,  55,  49,  43,  36,  20,   1 },
+    { 162, 155, 148, 142, 133, 127, 121, 115, 108, 102,  96,  90,  84,  77,  71,  65,  59,  53,  46,  30,   1 },
+    { 172, 165, 158, 152, 143, 137, 131, 125, 118, 112, 106, 100,  94,  87,  81,  75,  69,  63,  56,  45,  20 },
+    { 200, 200, 200, 200, 200, 200, 200, 200, 198, 193, 188, 183, 178, 173, 168, 163, 158, 153, 148, 129, 104 }
+};
+
+const uint8_t ff_celt_static_caps[4][2][21] = {
+    {       // 120-sample
+        {224, 224, 224, 224, 224, 224, 224, 224, 160, 160,
+         160, 160, 185, 185, 185, 178, 178, 168, 134,  61,  37},
+        {224, 224, 224, 224, 224, 224, 224, 224, 240, 240,
+         240, 240, 207, 207, 207, 198, 198, 183, 144,  66,  40},
+    }, {    // 240-sample
+        {160, 160, 160, 160, 160, 160, 160, 160, 185, 185,
+         185, 185, 193, 193, 193, 183, 183, 172, 138,  64,  38},
+        {240, 240, 240, 240, 240, 240, 240, 240, 207, 207,
+         207, 207, 204, 204, 204, 193, 193, 180, 143,  66,  40},
+    }, {    // 480-sample
+        {185, 185, 185, 185, 185, 185, 185, 185, 193, 193,
+         193, 193, 193, 193, 193, 183, 183, 172, 138,  65,  39},
+        {207, 207, 207, 207, 207, 207, 207, 207, 204, 204,
+         204, 204, 201, 201, 201, 188, 188, 176, 141,  66,  40},
+    }, {    // 960-sample
+        {193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
+         193, 193, 194, 194, 194, 184, 184, 173, 139,  65,  39},
+        {204, 204, 204, 204, 204, 204, 204, 204, 201, 201,
+         201, 201, 198, 198, 198, 187, 187, 175, 140,  66,  40}
+    }
+};
+
+const uint8_t ff_celt_cache_bits[392] = {
+    40, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 40, 15, 23, 28,
+    31, 34, 36, 38, 39, 41, 42, 43, 44, 45, 46, 47, 47, 49, 50,
+    51, 52, 53, 54, 55, 55, 57, 58, 59, 60, 61, 62, 63, 63, 65,
+    66, 67, 68, 69, 70, 71, 71, 40, 20, 33, 41, 48, 53, 57, 61,
+    64, 66, 69, 71, 73, 75, 76, 78, 80, 82, 85, 87, 89, 91, 92,
+    94, 96, 98, 101, 103, 105, 107, 108, 110, 112, 114, 117, 119, 121, 123,
+    124, 126, 128, 40, 23, 39, 51, 60, 67, 73, 79, 83, 87, 91, 94,
+    97, 100, 102, 105, 107, 111, 115, 118, 121, 124, 126, 129, 131, 135, 139,
+    142, 145, 148, 150, 153, 155, 159, 163, 166, 169, 172, 174, 177, 179, 35,
+    28, 49, 65, 78, 89, 99, 107, 114, 120, 126, 132, 136, 141, 145, 149,
+    153, 159, 165, 171, 176, 180, 185, 189, 192, 199, 205, 211, 216, 220, 225,
+    229, 232, 239, 245, 251, 21, 33, 58, 79, 97, 112, 125, 137, 148, 157,
+    166, 174, 182, 189, 195, 201, 207, 217, 227, 235, 243, 251, 17, 35, 63,
+    86, 106, 123, 139, 152, 165, 177, 187, 197, 206, 214, 222, 230, 237, 250,
+    25, 31, 55, 75, 91, 105, 117, 128, 138, 146, 154, 161, 168, 174, 180,
+    185, 190, 200, 208, 215, 222, 229, 235, 240, 245, 255, 16, 36, 65, 89,
+    110, 128, 144, 159, 173, 185, 196, 207, 217, 226, 234, 242, 250, 11, 41,
+    74, 103, 128, 151, 172, 191, 209, 225, 241, 255, 9, 43, 79, 110, 138,
+    163, 186, 207, 227, 246, 12, 39, 71, 99, 123, 144, 164, 182, 198, 214,
+    228, 241, 253, 9, 44, 81, 113, 142, 168, 192, 214, 235, 255, 7, 49,
+    90, 127, 160, 191, 220, 247, 6, 51, 95, 134, 170, 203, 234, 7, 47,
+    87, 123, 155, 184, 212, 237, 6, 52, 97, 137, 174, 208, 240, 5, 57,
+    106, 151, 192, 231, 5, 59, 111, 158, 202, 243, 5, 55, 103, 147, 187,
+    224, 5, 60, 113, 161, 206, 248, 4, 65, 122, 175, 224, 4, 67, 127,
+    182, 234
+};
+
+const int16_t ff_celt_cache_index[105] = {
+    -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 41, 41, 41,
+    82, 82, 123, 164, 200, 222, 0, 0, 0, 0, 0, 0, 0, 0, 41,
+    41, 41, 41, 123, 123, 123, 164, 164, 240, 266, 283, 295, 41, 41, 41,
+    41, 41, 41, 41, 41, 123, 123, 123, 123, 240, 240, 240, 266, 266, 305,
+    318, 328, 336, 123, 123, 123, 123, 123, 123, 123, 123, 240, 240, 240, 240,
+    305, 305, 305, 318, 318, 343, 351, 358, 364, 240, 240, 240, 240, 240, 240,
+    240, 240, 305, 305, 305, 305, 343, 343, 343, 351, 351, 370, 376, 382, 387,
+};
+
+const uint8_t ff_celt_log2_frac[] = {
+    0, 8, 13, 16, 19, 21, 23, 24, 26, 27, 28, 29, 30, 31, 32, 32, 33, 34, 34, 35, 36, 36, 37, 37
+};
+
+const uint8_t ff_celt_bit_interleave[] = {
+    0, 1, 1, 1, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 3, 3
+};
+
+const uint8_t ff_celt_bit_deinterleave[] = {
+    0x00, 0x03, 0x0C, 0x0F, 0x30, 0x33, 0x3C, 0x3F,
+    0xC0, 0xC3, 0xCC, 0xCF, 0xF0, 0xF3, 0xFC, 0xFF
+};
+
+const uint8_t ff_celt_hadamard_order[] = {
+    1,   0,
+    3,   0,  2,  1,
+    7,   0,  4,  3,  6,  1,  5,  2,
+    15,  0,  8,  7, 12,  3, 11,  4, 14,  1,  9,  6, 13,  2, 10,  5,
+    0,   1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15
+};
+
+const uint16_t ff_celt_qn_exp2[] = {
+    16384, 17866, 19483, 21247, 23170, 25267, 27554, 30048
+};
+
+const uint32_t ff_celt_pvq_u[1272] = {
+    /* N = 0, K = 0...176 */
+    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* N = 1, K = 1...176 */
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    /* N = 2, K = 2...176 */
+    3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41,
+    43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79,
+    81, 83, 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113,
+    115, 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139, 141, 143,
+    145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171, 173,
+    175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203,
+    205, 207, 209, 211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233,
+    235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255, 257, 259, 261, 263,
+    265, 267, 269, 271, 273, 275, 277, 279, 281, 283, 285, 287, 289, 291, 293,
+    295, 297, 299, 301, 303, 305, 307, 309, 311, 313, 315, 317, 319, 321, 323,
+    325, 327, 329, 331, 333, 335, 337, 339, 341, 343, 345, 347, 349, 351,
+    /* N = 3, K = 3...176 */
+    13, 25, 41, 61, 85, 113, 145, 181, 221, 265, 313, 365, 421, 481, 545, 613,
+    685, 761, 841, 925, 1013, 1105, 1201, 1301, 1405, 1513, 1625, 1741, 1861,
+    1985, 2113, 2245, 2381, 2521, 2665, 2813, 2965, 3121, 3281, 3445, 3613, 3785,
+    3961, 4141, 4325, 4513, 4705, 4901, 5101, 5305, 5513, 5725, 5941, 6161, 6385,
+    6613, 6845, 7081, 7321, 7565, 7813, 8065, 8321, 8581, 8845, 9113, 9385, 9661,
+    9941, 10225, 10513, 10805, 11101, 11401, 11705, 12013, 12325, 12641, 12961,
+    13285, 13613, 13945, 14281, 14621, 14965, 15313, 15665, 16021, 16381, 16745,
+    17113, 17485, 17861, 18241, 18625, 19013, 19405, 19801, 20201, 20605, 21013,
+    21425, 21841, 22261, 22685, 23113, 23545, 23981, 24421, 24865, 25313, 25765,
+    26221, 26681, 27145, 27613, 28085, 28561, 29041, 29525, 30013, 30505, 31001,
+    31501, 32005, 32513, 33025, 33541, 34061, 34585, 35113, 35645, 36181, 36721,
+    37265, 37813, 38365, 38921, 39481, 40045, 40613, 41185, 41761, 42341, 42925,
+    43513, 44105, 44701, 45301, 45905, 46513, 47125, 47741, 48361, 48985, 49613,
+    50245, 50881, 51521, 52165, 52813, 53465, 54121, 54781, 55445, 56113, 56785,
+    57461, 58141, 58825, 59513, 60205, 60901, 61601,
+    /* N = 4, K = 4...176 */
+    63, 129, 231, 377, 575, 833, 1159, 1561, 2047, 2625, 3303, 4089, 4991, 6017,
+    7175, 8473, 9919, 11521, 13287, 15225, 17343, 19649, 22151, 24857, 27775,
+    30913, 34279, 37881, 41727, 45825, 50183, 54809, 59711, 64897, 70375, 76153,
+    82239, 88641, 95367, 102425, 109823, 117569, 125671, 134137, 142975, 152193,
+    161799, 171801, 182207, 193025, 204263, 215929, 228031, 240577, 253575,
+    267033, 280959, 295361, 310247, 325625, 341503, 357889, 374791, 392217,
+    410175, 428673, 447719, 467321, 487487, 508225, 529543, 551449, 573951,
+    597057, 620775, 645113, 670079, 695681, 721927, 748825, 776383, 804609,
+    833511, 863097, 893375, 924353, 956039, 988441, 1021567, 1055425, 1090023,
+    1125369, 1161471, 1198337, 1235975, 1274393, 1313599, 1353601, 1394407,
+    1436025, 1478463, 1521729, 1565831, 1610777, 1656575, 1703233, 1750759,
+    1799161, 1848447, 1898625, 1949703, 2001689, 2054591, 2108417, 2163175,
+    2218873, 2275519, 2333121, 2391687, 2451225, 2511743, 2573249, 2635751,
+    2699257, 2763775, 2829313, 2895879, 2963481, 3032127, 3101825, 3172583,
+    3244409, 3317311, 3391297, 3466375, 3542553, 3619839, 3698241, 3777767,
+    3858425, 3940223, 4023169, 4107271, 4192537, 4278975, 4366593, 4455399,
+    4545401, 4636607, 4729025, 4822663, 4917529, 5013631, 5110977, 5209575,
+    5309433, 5410559, 5512961, 5616647, 5721625, 5827903, 5935489, 6044391,
+    6154617, 6266175, 6379073, 6493319, 6608921, 6725887, 6844225, 6963943,
+    7085049, 7207551,
+    /* N = 5, K = 5...176 */
+    321, 681, 1289, 2241, 3649, 5641, 8361, 11969, 16641, 22569, 29961, 39041,
+    50049, 63241, 78889, 97281, 118721, 143529, 172041, 204609, 241601, 283401,
+    330409, 383041, 441729, 506921, 579081, 658689, 746241, 842249, 947241,
+    1061761, 1186369, 1321641, 1468169, 1626561, 1797441, 1981449, 2179241,
+    2391489, 2618881, 2862121, 3121929, 3399041, 3694209, 4008201, 4341801,
+    4695809, 5071041, 5468329, 5888521, 6332481, 6801089, 7295241, 7815849,
+    8363841, 8940161, 9545769, 10181641, 10848769, 11548161, 12280841, 13047849,
+    13850241, 14689089, 15565481, 16480521, 17435329, 18431041, 19468809,
+    20549801, 21675201, 22846209, 24064041, 25329929, 26645121, 28010881,
+    29428489, 30899241, 32424449, 34005441, 35643561, 37340169, 39096641,
+    40914369, 42794761, 44739241, 46749249, 48826241, 50971689, 53187081,
+    55473921, 57833729, 60268041, 62778409, 65366401, 68033601, 70781609,
+    73612041, 76526529, 79526721, 82614281, 85790889, 89058241, 92418049,
+    95872041, 99421961, 103069569, 106816641, 110664969, 114616361, 118672641,
+    122835649, 127107241, 131489289, 135983681, 140592321, 145317129, 150160041,
+    155123009, 160208001, 165417001, 170752009, 176215041, 181808129, 187533321,
+    193392681, 199388289, 205522241, 211796649, 218213641, 224775361, 231483969,
+    238341641, 245350569, 252512961, 259831041, 267307049, 274943241, 282741889,
+    290705281, 298835721, 307135529, 315607041, 324252609, 333074601, 342075401,
+    351257409, 360623041, 370174729, 379914921, 389846081, 399970689, 410291241,
+    420810249, 431530241, 442453761, 453583369, 464921641, 476471169, 488234561,
+    500214441, 512413449, 524834241, 537479489, 550351881, 563454121, 576788929,
+    590359041, 604167209, 618216201, 632508801,
+    /* N = 6, K = 6...96 (technically V(109,5) fits in 32 bits, but that can't be
+     achieved by splitting an Opus band) */
+    1683, 3653, 7183, 13073, 22363, 36365, 56695, 85305, 124515, 177045, 246047,
+    335137, 448427, 590557, 766727, 982729, 1244979, 1560549, 1937199, 2383409,
+    2908411, 3522221, 4235671, 5060441, 6009091, 7095093, 8332863, 9737793,
+    11326283, 13115773, 15124775, 17372905, 19880915, 22670725, 25765455,
+    29189457, 32968347, 37129037, 41699767, 46710137, 52191139, 58175189,
+    64696159, 71789409, 79491819, 87841821, 96879431, 106646281, 117185651,
+    128542501, 140763503, 153897073, 167993403, 183104493, 199284183, 216588185,
+    235074115, 254801525, 275831935, 298228865, 322057867, 347386557, 374284647,
+    402823977, 433078547, 465124549, 499040399, 534906769, 572806619, 612825229,
+    655050231, 699571641, 746481891, 795875861, 847850911, 902506913, 959946283,
+    1020274013, 1083597703, 1150027593, 1219676595, 1292660325, 1369097135,
+    1449108145, 1532817275, 1620351277, 1711839767, 1807415257, 1907213187,
+    2011371957, 2120032959,
+    /* N = 7, K = 7...54 (technically V(60,6) fits in 32 bits, but that can't be
+     achieved by splitting an Opus band) */
+    8989, 19825, 40081, 75517, 134245, 227305, 369305, 579125, 880685, 1303777,
+    1884961, 2668525, 3707509, 5064793, 6814249, 9041957, 11847485, 15345233,
+    19665841, 24957661, 31388293, 39146185, 48442297, 59511829, 72616013,
+    88043969, 106114625, 127178701, 151620757, 179861305, 212358985, 249612805,
+    292164445, 340600625, 395555537, 457713341, 527810725, 606639529, 695049433,
+    793950709, 904317037, 1027188385, 1163673953, 1314955181, 1482288821,
+    1667010073, 1870535785, 2094367717,
+    /* N = 8, K = 8...37 (technically V(40,7) fits in 32 bits, but that can't be
+     achieved by splitting an Opus band) */
+    48639, 108545, 224143, 433905, 795455, 1392065, 2340495, 3800305, 5984767,
+    9173505, 13726991, 20103025, 28875327, 40754369, 56610575, 77500017,
+    104692735, 139703809, 184327311, 240673265, 311207743, 398796225, 506750351,
+    638878193, 799538175, 993696769, 1226990095, 1505789553, 1837271615,
+    2229491905,
+    /* N = 9, K = 9...28 (technically V(29,8) fits in 32 bits, but that can't be
+     achieved by splitting an Opus band) */
+    265729, 598417, 1256465, 2485825, 4673345, 8405905, 14546705, 24331777,
+    39490049, 62390545, 96220561, 145198913, 214828609, 312193553, 446304145,
+    628496897, 872893441, 1196924561, 1621925137, 2173806145,
+    /* N = 10, K = 10...24 */
+    1462563, 3317445, 7059735, 14218905, 27298155, 50250765, 89129247, 152951073,
+    254831667, 413442773, 654862247, 1014889769, 1541911931, 2300409629,
+    3375210671,
+    /* N = 11, K = 11...19 (technically V(20,10) fits in 32 bits, but that can't be
+     achieved by splitting an Opus band) */
+    8097453, 18474633, 39753273, 81270333, 158819253, 298199265, 540279585,
+    948062325, 1616336765,
+    /* N = 12, K = 12...18 */
+    45046719, 103274625, 224298231, 464387817, 921406335, 1759885185,
+    3248227095,
+    /* N = 13, K = 13...16 */
+    251595969, 579168825, 1267854873, 2653649025,
+    /* N = 14, K = 14 */
+    1409933619
+};
+
+const float ff_celt_postfilter_taps[3][3] = {
+    { 0.3066406250f, 0.2170410156f, 0.1296386719f },
+    { 0.4638671875f, 0.2680664062f, 0.0           },
+    { 0.7998046875f, 0.1000976562f, 0.0           }
+};
+
+DECLARE_ALIGNED(32, static const float, ff_celt_window_padded)[136] = {
+    0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f,
+    0.00000000f, 0.00000000f, 0.00000000f, 0.00000000f,
+    6.7286966e-05f, 0.00060551348f, 0.0016815970f, 0.0032947962f, 0.0054439943f,
+    0.0081276923f, 0.011344001f, 0.015090633f, 0.019364886f, 0.024163635f,
+    0.029483315f, 0.035319905f, 0.041668911f, 0.048525347f, 0.055883718f,
+    0.063737999f, 0.072081616f, 0.080907428f, 0.090207705f, 0.099974111f,
+    0.11019769f, 0.12086883f, 0.13197729f, 0.14351214f, 0.15546177f,
+    0.16781389f, 0.18055550f, 0.19367290f, 0.20715171f, 0.22097682f,
+    0.23513243f, 0.24960208f, 0.26436860f, 0.27941419f, 0.29472040f,
+    0.31026818f, 0.32603788f, 0.34200931f, 0.35816177f, 0.37447407f,
+    0.39092462f, 0.40749142f, 0.42415215f, 0.44088423f, 0.45766484f,
+    0.47447104f, 0.49127978f, 0.50806798f, 0.52481261f, 0.54149077f,
+    0.55807973f, 0.57455701f, 0.59090049f, 0.60708841f, 0.62309951f,
+    0.63891306f, 0.65450896f, 0.66986776f, 0.68497077f, 0.69980010f,
+    0.71433873f, 0.72857055f, 0.74248043f, 0.75605424f, 0.76927895f,
+    0.78214257f, 0.79463430f, 0.80674445f, 0.81846456f, 0.82978733f,
+    0.84070669f, 0.85121779f, 0.86131698f, 0.87100183f, 0.88027111f,
+    0.88912479f, 0.89756398f, 0.90559094f, 0.91320904f, 0.92042270f,
+    0.92723738f, 0.93365955f, 0.93969656f, 0.94535671f, 0.95064907f,
+    0.95558353f, 0.96017067f, 0.96442171f, 0.96834849f, 0.97196334f,
+    0.97527906f, 0.97830883f, 0.98106616f, 0.98356480f, 0.98581869f,
+    0.98784191f, 0.98964856f, 0.99125274f, 0.99266849f, 0.99390969f,
+    0.99499004f, 0.99592297f, 0.99672162f, 0.99739874f, 0.99796667f,
+    0.99843728f, 0.99882195f, 0.99913147f, 0.99937606f, 0.99956527f,
+    0.99970802f, 0.99981248f, 0.99988613f, 0.99993565f, 0.99996697f,
+    0.99998518f, 0.99999457f, 0.99999859f, 0.99999982f, 1.00000000f,
+    1.00000000f, 1.00000000f, 1.00000000f, 1.00000000f, 1.00000000f,
+    1.00000000f, 1.00000000f, 1.00000000f,
+};
+
+const float *ff_celt_window = &ff_celt_window_padded[8];
+
+/* square of the window, used for the postfilter */
+const float ff_celt_window2[120] = {
+    4.5275357e-09f, 3.66647e-07f, 2.82777e-06f, 1.08557e-05f, 2.96371e-05f, 6.60594e-05f,
+    0.000128686f, 0.000227727f, 0.000374999f, 0.000583881f, 0.000869266f, 0.0012475f,
+    0.0017363f, 0.00235471f, 0.00312299f, 0.00406253f, 0.00519576f, 0.00654601f,
+    0.00813743f, 0.00999482f, 0.0121435f, 0.0146093f, 0.017418f, 0.0205957f, 0.0241684f,
+    0.0281615f, 0.0326003f, 0.0375092f, 0.0429118f, 0.0488308f, 0.0552873f, 0.0623012f,
+    0.0698908f, 0.0780723f, 0.0868601f, 0.0962664f, 0.106301f, 0.11697f, 0.12828f,
+    0.140231f, 0.152822f, 0.166049f, 0.179905f, 0.194379f, 0.209457f, 0.225123f, 0.241356f,
+    0.258133f, 0.275428f, 0.293212f, 0.311453f, 0.330116f, 0.349163f, 0.368556f, 0.388253f,
+    0.40821f, 0.428382f, 0.448723f, 0.469185f, 0.48972f, 0.51028f, 0.530815f, 0.551277f,
+    0.571618f, 0.59179f, 0.611747f, 0.631444f, 0.650837f, 0.669884f, 0.688547f, 0.706788f,
+    0.724572f, 0.741867f, 0.758644f, 0.774877f, 0.790543f, 0.805621f, 0.820095f, 0.833951f,
+    0.847178f, 0.859769f, 0.87172f, 0.88303f, 0.893699f, 0.903734f, 0.91314f, 0.921928f,
+    0.930109f, 0.937699f, 0.944713f, 0.951169f, 0.957088f, 0.962491f, 0.9674f, 0.971838f,
+    0.975832f, 0.979404f, 0.982582f, 0.985391f, 0.987857f, 0.990005f, 0.991863f, 0.993454f,
+    0.994804f, 0.995937f, 0.996877f, 0.997645f, 0.998264f, 0.998753f, 0.999131f, 0.999416f,
+    0.999625f, 0.999772f, 0.999871f, 0.999934f, 0.99997f, 0.999989f, 0.999997f, 0.99999964f, 1.0f,
+};
+
+const uint32_t * const ff_celt_pvq_u_row[15] = {
+    ff_celt_pvq_u +    0, ff_celt_pvq_u +  176, ff_celt_pvq_u +  351,
+    ff_celt_pvq_u +  525, ff_celt_pvq_u +  698, ff_celt_pvq_u +  870,
+    ff_celt_pvq_u + 1041, ff_celt_pvq_u + 1131, ff_celt_pvq_u + 1178,
+    ff_celt_pvq_u + 1207, ff_celt_pvq_u + 1226, ff_celt_pvq_u + 1240,
+    ff_celt_pvq_u + 1248, ff_celt_pvq_u + 1254, ff_celt_pvq_u + 1257
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/opustab.h b/mythtv/external/FFmpeg/libavcodec/opustab.h
new file mode 100644
index 00000000000..bce5a428308
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/opustab.h
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2012 Andrew D'Addesio
+ * Copyright (c) 2013-2014 Mozilla Corporation
+ * Copyright (c) 2016 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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_OPUSTAB_H
+#define AVCODEC_OPUSTAB_H
+
+#include "libavutil/mem.h"
+
+#include <stdint.h>
+
+extern const uint8_t  ff_celt_band_end[];
+
+extern const uint8_t  ff_opus_default_coupled_streams[];
+
+extern const uint16_t ff_silk_model_stereo_s1[];
+extern const uint16_t ff_silk_model_stereo_s2[];
+extern const uint16_t ff_silk_model_stereo_s3[];
+extern const uint16_t ff_silk_model_mid_only[];
+
+extern const uint16_t ff_silk_model_frame_type_inactive[];
+extern const uint16_t ff_silk_model_frame_type_active[];
+
+extern const uint16_t ff_silk_model_gain_highbits[3][9];
+extern const uint16_t ff_silk_model_gain_lowbits[];
+extern const uint16_t ff_silk_model_gain_delta[];
+
+extern const uint16_t ff_silk_model_lsf_s1[2][2][33];
+extern const uint16_t ff_silk_model_lsf_s2[32][10];
+extern const uint16_t ff_silk_model_lsf_s2_ext[];
+extern const uint16_t ff_silk_model_lsf_interpolation_offset[];
+
+extern const uint16_t ff_silk_model_pitch_highbits[];
+extern const uint16_t ff_silk_model_pitch_lowbits_nb[];
+extern const uint16_t ff_silk_model_pitch_lowbits_mb[];
+extern const uint16_t ff_silk_model_pitch_lowbits_wb[];
+extern const uint16_t ff_silk_model_pitch_delta[];
+extern const uint16_t ff_silk_model_pitch_contour_nb10ms[];
+extern const uint16_t ff_silk_model_pitch_contour_nb20ms[];
+extern const uint16_t ff_silk_model_pitch_contour_mbwb10ms[];
+extern const uint16_t ff_silk_model_pitch_contour_mbwb20ms[];
+
+extern const uint16_t ff_silk_model_ltp_filter[];
+extern const uint16_t ff_silk_model_ltp_filter0_sel[];
+extern const uint16_t ff_silk_model_ltp_filter1_sel[];
+extern const uint16_t ff_silk_model_ltp_filter2_sel[];
+extern const uint16_t ff_silk_model_ltp_scale_index[];
+
+extern const uint16_t ff_silk_model_lcg_seed[];
+
+extern const uint16_t ff_silk_model_exc_rate[2][10];
+
+extern const uint16_t ff_silk_model_pulse_count[11][19];
+extern const uint16_t ff_silk_model_pulse_location[4][168];
+
+extern const uint16_t ff_silk_model_excitation_lsb[];
+extern const uint16_t ff_silk_model_excitation_sign[3][2][7][3];
+
+extern const int16_t  ff_silk_stereo_weights[];
+
+extern const uint8_t  ff_silk_lsf_s2_model_sel_nbmb[32][10];
+extern const uint8_t  ff_silk_lsf_s2_model_sel_wb[32][16];
+
+extern const uint8_t  ff_silk_lsf_pred_weights_nbmb[2][9];
+extern const uint8_t  ff_silk_lsf_pred_weights_wb[2][15];
+
+extern const uint8_t  ff_silk_lsf_weight_sel_nbmb[32][9];
+extern const uint8_t  ff_silk_lsf_weight_sel_wb[32][15];
+
+extern const uint8_t  ff_silk_lsf_codebook_nbmb[32][10];
+extern const uint8_t  ff_silk_lsf_codebook_wb[32][16];
+
+extern const uint16_t ff_silk_lsf_min_spacing_nbmb[];
+extern const uint16_t ff_silk_lsf_min_spacing_wb[];
+
+extern const uint8_t  ff_silk_lsf_ordering_nbmb[];
+extern const uint8_t  ff_silk_lsf_ordering_wb[];
+
+extern const int16_t  ff_silk_cosine[];
+
+extern const uint16_t ff_silk_pitch_scale[];
+extern const uint16_t ff_silk_pitch_min_lag[];
+extern const uint16_t ff_silk_pitch_max_lag[];
+
+extern const int8_t   ff_silk_pitch_offset_nb10ms[3][2];
+extern const int8_t   ff_silk_pitch_offset_nb20ms[11][4];
+extern const int8_t   ff_silk_pitch_offset_mbwb10ms[12][2];
+extern const int8_t   ff_silk_pitch_offset_mbwb20ms[34][4];
+
+extern const int8_t   ff_silk_ltp_filter0_taps[8][5];
+extern const int8_t   ff_silk_ltp_filter1_taps[16][5];
+extern const int8_t   ff_silk_ltp_filter2_taps[32][5];
+
+extern const uint16_t ff_silk_ltp_scale_factor[];
+
+extern const uint8_t  ff_silk_shell_blocks[3][2];
+
+extern const uint8_t  ff_silk_quant_offset[2][2];
+
+extern const int      ff_silk_stereo_interp_len[3];
+
+extern const uint16_t ff_celt_model_tapset[];
+extern const uint16_t ff_celt_model_spread[];
+extern const uint16_t ff_celt_model_alloc_trim[];
+extern const uint16_t ff_celt_model_energy_small[];
+
+extern const uint8_t  ff_celt_freq_bands[];
+extern const uint8_t  ff_celt_freq_range[];
+extern const uint8_t  ff_celt_log_freq_range[];
+
+extern const int8_t   ff_celt_tf_select[4][2][2][2];
+
+extern const float    ff_celt_mean_energy[];
+
+extern const float    ff_celt_alpha_coef[];
+extern const float    ff_celt_beta_coef[];
+
+extern const uint8_t  ff_celt_coarse_energy_dist[4][2][42];
+
+extern const uint8_t  ff_celt_static_alloc[11][21];
+extern const uint8_t  ff_celt_static_caps[4][2][21];
+
+extern const uint8_t  ff_celt_cache_bits[392];
+extern const int16_t  ff_celt_cache_index[105];
+
+extern const uint8_t  ff_celt_log2_frac[];
+
+extern const uint8_t  ff_celt_bit_interleave[];
+extern const uint8_t  ff_celt_bit_deinterleave[];
+
+extern const uint8_t  ff_celt_hadamard_order[];
+
+extern const uint16_t ff_celt_qn_exp2[];
+extern const uint32_t ff_celt_pvq_u[1272];
+
+extern const float    ff_celt_postfilter_taps[3][3];
+
+extern const float    ff_celt_window2[120];
+extern const float   *ff_celt_window;
+
+extern const uint32_t * const ff_celt_pvq_u_row[15];
+
+#endif /* AVCODEC_OPUSTAB_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/pafvideo.c b/mythtv/external/FFmpeg/libavcodec/pafvideo.c
index cab3129f8f3..6980ae1b352 100644
--- a/mythtv/external/FFmpeg/libavcodec/pafvideo.c
+++ b/mythtv/external/FFmpeg/libavcodec/pafvideo.c
@@ -181,6 +181,8 @@ static int decode_0(PAFVideoDecContext *c, uint8_t *pkt, uint8_t code)
             dend   = c->frame[page] + c->frame_size;
             offset = (x & 0x7F) * 2;
             j      = bytestream2_get_le16(&c->gb) + offset;
+            if (bytestream2_get_bytes_left(&c->gb) < (j - offset) * 16)
+                return AVERROR_INVALIDDATA;
             do {
                 offset++;
                 if (dst + 3 * c->width + 4 > dend)
@@ -198,7 +200,8 @@ static int decode_0(PAFVideoDecContext *c, uint8_t *pkt, uint8_t code)
     do {
         set_src_position(c, &src, &send);
         if ((src + 3 * c->width + 4 > send) ||
-            (dst + 3 * c->width + 4 > dend))
+            (dst + 3 * c->width + 4 > dend) ||
+            bytestream2_get_bytes_left(&c->gb) < 4)
             return AVERROR_INVALIDDATA;
         copy_block4(dst, src, c->width, c->width, 4);
         i++;
@@ -267,12 +270,20 @@ static int paf_video_decode(AVCodecContext *avctx, void *data,
     uint8_t code, *dst, *end;
     int i, frame, ret;
 
-    if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
-        return ret;
+    if (pkt->size < 2)
+        return AVERROR_INVALIDDATA;
 
     bytestream2_init(&c->gb, pkt->data, pkt->size);
 
     code = bytestream2_get_byte(&c->gb);
+    if ((code & 0xF) > 4 || (code & 0xF) == 3) {
+        avpriv_request_sample(avctx, "unknown/invalid code");
+        return AVERROR_INVALIDDATA;
+    }
+
+    if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
+        return ret;
+
     if (code & 0x20) {  // frame is keyframe
         for (i = 0; i < 4; i++)
             memset(c->frame[i], 0, c->frame_size);
@@ -367,8 +378,7 @@ static int paf_video_decode(AVCodecContext *avctx, void *data,
         }
         break;
     default:
-        avpriv_request_sample(avctx, "unknown/invalid code");
-        return AVERROR_INVALIDDATA;
+        av_assert0(0);
     }
 
     av_image_copy_plane(c->pic->data[0], c->pic->linesize[0],
diff --git a/mythtv/external/FFmpeg/libavcodec/parser.c b/mythtv/external/FFmpeg/libavcodec/parser.c
index 30cfc55cbcb..670680ea7c1 100644
--- a/mythtv/external/FFmpeg/libavcodec/parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/parser.c
@@ -20,6 +20,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <inttypes.h>
 #include <stdint.h>
 #include <string.h>
 
@@ -251,7 +252,7 @@ int ff_combine_frame(ParseContext *pc, int next,
                      const uint8_t **buf, int *buf_size)
 {
     if (pc->overread) {
-        ff_dlog(NULL, "overread %d, state:%X next:%d index:%d o_index:%d\n",
+        ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n",
                 pc->overread, pc->state, next, pc->index, pc->overread_index);
         ff_dlog(NULL, "%X %X %X %X\n",
                 (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]);
@@ -284,6 +285,8 @@ int ff_combine_frame(ParseContext *pc, int next,
         return -1;
     }
 
+    av_assert0(next >= 0 || pc->buffer);
+
     *buf_size          =
     pc->overread_index = pc->index + next;
 
@@ -314,7 +317,7 @@ int ff_combine_frame(ParseContext *pc, int next,
     }
 
     if (pc->overread) {
-        ff_dlog(NULL, "overread %d, state:%X next:%d index:%d o_index:%d\n",
+        ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n",
                 pc->overread, pc->state, next, pc->index, pc->overread_index);
         ff_dlog(NULL, "%X %X %X %X\n",
                 (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]);
diff --git a/mythtv/external/FFmpeg/libavcodec/pcm-bluray.c b/mythtv/external/FFmpeg/libavcodec/pcm-bluray.c
index 22c1c08bcf1..517d7b518c9 100644
--- a/mythtv/external/FFmpeg/libavcodec/pcm-bluray.c
+++ b/mythtv/external/FFmpeg/libavcodec/pcm-bluray.c
@@ -119,7 +119,7 @@ static int pcm_bluray_parse_header(AVCodecContext *avctx,
         ff_dlog(avctx,
                 "pcm_bluray_parse_header: %d channels, %d bits per sample, %d Hz, %"PRId64" bit/s\n",
                 avctx->channels, avctx->bits_per_coded_sample,
-                avctx->sample_rate, (int64_t)avctx->bit_rate);
+                avctx->sample_rate, avctx->bit_rate);
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/pcm-dvd.c b/mythtv/external/FFmpeg/libavcodec/pcm-dvd.c
index 04c321e677e..0a751a81916 100644
--- a/mythtv/external/FFmpeg/libavcodec/pcm-dvd.c
+++ b/mythtv/external/FFmpeg/libavcodec/pcm-dvd.c
@@ -142,7 +142,7 @@ static int pcm_dvd_parse_header(AVCodecContext *avctx, const uint8_t *header)
         ff_dlog(avctx,
                 "pcm_dvd_parse_header: %d channels, %d bits per sample, %d Hz, %"PRId64" bit/s\n",
                 avctx->channels, avctx->bits_per_coded_sample,
-                avctx->sample_rate, (int64_t)avctx->bit_rate);
+                avctx->sample_rate, avctx->bit_rate);
 
     s->last_header = header_int;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/pcm.c b/mythtv/external/FFmpeg/libavcodec/pcm.c
index 40c684b73f9..fc20a3148e1 100644
--- a/mythtv/external/FFmpeg/libavcodec/pcm.c
+++ b/mythtv/external/FFmpeg/libavcodec/pcm.c
@@ -25,6 +25,7 @@
  */
 
 #include "libavutil/attributes.h"
+#include "libavutil/float_dsp.h"
 #include "avcodec.h"
 #include "bytestream.h"
 #include "internal.h"
@@ -225,6 +226,8 @@ static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 
 typedef struct PCMDecode {
     short   table[256];
+    AVFloatDSPContext *fdsp;
+    float   scale;
 } PCMDecode;
 
 static av_cold int pcm_decode_init(AVCodecContext *avctx)
@@ -249,6 +252,13 @@ static av_cold int pcm_decode_init(AVCodecContext *avctx)
         for (i = 0; i < 256; i++)
             s->table[i] = ulaw2linear(i);
         break;
+    case AV_CODEC_ID_PCM_F16LE:
+    case AV_CODEC_ID_PCM_F24LE:
+        s->scale = 1. / (1 << (avctx->bits_per_coded_sample - 1));
+        s->fdsp = avpriv_float_dsp_alloc(0);
+        if (!s->fdsp)
+            return AVERROR(ENOMEM);
+        break;
     default:
         break;
     }
@@ -261,6 +271,15 @@ static av_cold int pcm_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
+static av_cold int pcm_decode_close(AVCodecContext *avctx)
+{
+    PCMDecode *s = avctx->priv_data;
+
+    av_freep(&s->fdsp);
+
+    return 0;
+}
+
 /**
  * Read PCM samples macro
  * @param size   Data size of native machine format
@@ -403,6 +422,8 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
         break;
     case AV_CODEC_ID_PCM_S32LE:
     case AV_CODEC_ID_PCM_F32LE:
+    case AV_CODEC_ID_PCM_F24LE:
+    case AV_CODEC_ID_PCM_F16LE:
         DECODE(32, le32, src, samples, n, 0, 0)
         break;
     case AV_CODEC_ID_PCM_S32LE_PLANAR:
@@ -436,6 +457,8 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
         break;
     case AV_CODEC_ID_PCM_F64LE:
     case AV_CODEC_ID_PCM_F32LE:
+    case AV_CODEC_ID_PCM_F24LE:
+    case AV_CODEC_ID_PCM_F16LE:
     case AV_CODEC_ID_PCM_S64LE:
     case AV_CODEC_ID_PCM_S32LE:
     case AV_CODEC_ID_PCM_S16LE:
@@ -498,6 +521,14 @@ static int pcm_decode_frame(AVCodecContext *avctx, void *data,
         return -1;
     }
 
+    if (avctx->codec_id == AV_CODEC_ID_PCM_F16LE ||
+        avctx->codec_id == AV_CODEC_ID_PCM_F24LE) {
+        s->fdsp->vector_fmul_scalar((float *)frame->extended_data[0],
+                                    (const float *)frame->extended_data[0],
+                                    s->scale, FFALIGN(frame->nb_samples * avctx->channels, 4));
+        emms_c();
+    }
+
     *got_frame_ptr = 1;
 
     return buf_size;
@@ -533,6 +564,7 @@ AVCodec ff_ ## name_ ## _decoder = {                                        \
     .id             = AV_CODEC_ID_ ## id_,                                  \
     .priv_data_size = sizeof(PCMDecode),                                    \
     .init           = pcm_decode_init,                                      \
+    .close          = pcm_decode_close,                                     \
     .decode         = pcm_decode_frame,                                     \
     .capabilities   = AV_CODEC_CAP_DR1,                                     \
     .sample_fmts    = (const enum AVSampleFormat[]){ sample_fmt_,           \
@@ -552,6 +584,8 @@ AVCodec ff_ ## name_ ## _decoder = {                                        \
 
 /* Note: Do not forget to add new entries to the Makefile as well. */
 PCM_CODEC  (PCM_ALAW,         AV_SAMPLE_FMT_S16, pcm_alaw,         "PCM A-law / G.711 A-law");
+PCM_DECODER(PCM_F16LE,        AV_SAMPLE_FMT_FLT, pcm_f16le,        "PCM 16.8 floating point little-endian");
+PCM_DECODER(PCM_F24LE,        AV_SAMPLE_FMT_FLT, pcm_f24le,        "PCM 24.0 floating point little-endian");
 PCM_CODEC  (PCM_F32BE,        AV_SAMPLE_FMT_FLT, pcm_f32be,        "PCM 32-bit floating point big-endian");
 PCM_CODEC  (PCM_F32LE,        AV_SAMPLE_FMT_FLT, pcm_f32le,        "PCM 32-bit floating point little-endian");
 PCM_CODEC  (PCM_F64BE,        AV_SAMPLE_FMT_DBL, pcm_f64be,        "PCM 64-bit floating point big-endian");
diff --git a/mythtv/external/FFmpeg/libavcodec/pcx.c b/mythtv/external/FFmpeg/libavcodec/pcx.c
index 1d3ee8d96a7..58a5e1e0682 100644
--- a/mythtv/external/FFmpeg/libavcodec/pcx.c
+++ b/mythtv/external/FFmpeg/libavcodec/pcx.c
@@ -28,6 +28,8 @@
 #include "get_bits.h"
 #include "internal.h"
 
+#define PCX_HEADER_SIZE 128
+
 static void pcx_rle_decode(GetByteContext *gb,
                            uint8_t *dst,
                            unsigned int bytes_per_scanline,
@@ -74,8 +76,10 @@ static int pcx_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                  bytes_per_scanline;
     uint8_t *ptr, *scanline;
 
-    if (avpkt->size < 128)
+    if (avpkt->size < PCX_HEADER_SIZE) {
+        av_log(avctx, AV_LOG_ERROR, "Packet too small\n");
         return AVERROR_INVALIDDATA;
+    }
 
     bytestream2_init(&gb, avpkt->data, avpkt->size);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/pgssubdec.c b/mythtv/external/FFmpeg/libavcodec/pgssubdec.c
index d201ffb37da..5275f9eb6a8 100644
--- a/mythtv/external/FFmpeg/libavcodec/pgssubdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/pgssubdec.c
@@ -301,8 +301,11 @@ static int parse_object_segment(AVCodecContext *avctx,
 
     av_fast_padded_malloc(&object->rle, &object->rle_buffer_size, rle_bitmap_len);
 
-    if (!object->rle)
+    if (!object->rle) {
+        object->rle_data_len = 0;
+        object->rle_remaining_len = 0;
         return AVERROR(ENOMEM);
+    }
 
     memcpy(object->rle, buf, buf_size);
     object->rle_data_len = buf_size;
@@ -560,12 +563,13 @@ static int display_end_segment(AVCodecContext *avctx, void *data,
 
         sub->rects[i]->x    = ctx->presentation.objects[i].x;
         sub->rects[i]->y    = ctx->presentation.objects[i].y;
-        sub->rects[i]->w    = object->w;
-        sub->rects[i]->h    = object->h;
-
-        sub->rects[i]->linesize[0] = object->w;
 
         if (object->rle) {
+            sub->rects[i]->w    = object->w;
+            sub->rects[i]->h    = object->h;
+
+            sub->rects[i]->linesize[0] = object->w;
+
             if (object->rle_remaining_len) {
                 av_log(avctx, AV_LOG_ERROR, "RLE data length %u is %u bytes shorter than expected\n",
                        object->rle_data_len, object->rle_remaining_len);
diff --git a/mythtv/external/FFmpeg/libavcodec/pictordec.c b/mythtv/external/FFmpeg/libavcodec/pictordec.c
index ff6eb7f4fc9..b29a4845341 100644
--- a/mythtv/external/FFmpeg/libavcodec/pictordec.c
+++ b/mythtv/external/FFmpeg/libavcodec/pictordec.c
@@ -57,12 +57,12 @@ static void picmemset_8bpp(PicContext *s, AVFrame *frame, int value, int run,
     }
 }
 
-static void picmemset(PicContext *s, AVFrame *frame, int value, int run,
+static void picmemset(PicContext *s, AVFrame *frame, unsigned value, int run,
                       int *x, int *y, int *plane, int bits_per_plane)
 {
     uint8_t *d;
     int shift = *plane * bits_per_plane;
-    int mask  = ((1 << bits_per_plane) - 1) << shift;
+    unsigned mask  = ((1U << bits_per_plane) - 1) << shift;
     value   <<= shift;
 
     while (run > 0) {
@@ -77,10 +77,10 @@ static void picmemset(PicContext *s, AVFrame *frame, int value, int run,
                 if (*y < 0) {
                    *y = s->height - 1;
                    *plane += 1;
+                   if (*plane >= s->nb_planes)
+                       return;
                    value <<= bits_per_plane;
                    mask  <<= bits_per_plane;
-                   if (*plane >= s->nb_planes)
-                       break;
                 }
             }
         }
@@ -142,7 +142,7 @@ static int decode_frame(AVCodecContext *avctx,
 
     if (av_image_check_size(s->width, s->height, 0, avctx) < 0)
         return -1;
-    if (s->width != avctx->width && s->height != avctx->height) {
+    if (s->width != avctx->width || s->height != avctx->height) {
         ret = ff_set_dimensions(avctx, s->width, s->height);
         if (ret < 0)
             return ret;
@@ -236,7 +236,7 @@ static int decode_frame(AVCodecContext *avctx,
             }
         }
 
-        if (x < avctx->width) {
+        if (plane < s->nb_planes && x < avctx->width) {
             int run = (y + 1) * avctx->width - x;
             if (bits_per_plane == 8)
                 picmemset_8bpp(s, frame, val, run, &x, &y);
diff --git a/mythtv/external/FFmpeg/libavcodec/pixblockdsp.c b/mythtv/external/FFmpeg/libavcodec/pixblockdsp.c
index f0883d3d084..50e1d1d735e 100644
--- a/mythtv/external/FFmpeg/libavcodec/pixblockdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/pixblockdsp.c
@@ -25,20 +25,20 @@
 #include "pixblockdsp.h"
 
 static void get_pixels_16_c(int16_t *av_restrict block, const uint8_t *pixels,
-                            ptrdiff_t line_size)
+                            ptrdiff_t stride)
 {
-    AV_COPY128U(block + 0 * 8, pixels + 0 * line_size);
-    AV_COPY128U(block + 1 * 8, pixels + 1 * line_size);
-    AV_COPY128U(block + 2 * 8, pixels + 2 * line_size);
-    AV_COPY128U(block + 3 * 8, pixels + 3 * line_size);
-    AV_COPY128U(block + 4 * 8, pixels + 4 * line_size);
-    AV_COPY128U(block + 5 * 8, pixels + 5 * line_size);
-    AV_COPY128U(block + 6 * 8, pixels + 6 * line_size);
-    AV_COPY128U(block + 7 * 8, pixels + 7 * line_size);
+    AV_COPY128U(block + 0 * 8, pixels + 0 * stride);
+    AV_COPY128U(block + 1 * 8, pixels + 1 * stride);
+    AV_COPY128U(block + 2 * 8, pixels + 2 * stride);
+    AV_COPY128U(block + 3 * 8, pixels + 3 * stride);
+    AV_COPY128U(block + 4 * 8, pixels + 4 * stride);
+    AV_COPY128U(block + 5 * 8, pixels + 5 * stride);
+    AV_COPY128U(block + 6 * 8, pixels + 6 * stride);
+    AV_COPY128U(block + 7 * 8, pixels + 7 * stride);
 }
 
 static void get_pixels_8_c(int16_t *av_restrict block, const uint8_t *pixels,
-                           ptrdiff_t line_size)
+                           ptrdiff_t stride)
 {
     int i;
 
@@ -52,13 +52,13 @@ static void get_pixels_8_c(int16_t *av_restrict block, const uint8_t *pixels,
         block[5] = pixels[5];
         block[6] = pixels[6];
         block[7] = pixels[7];
-        pixels  += line_size;
+        pixels  += stride;
         block   += 8;
     }
 }
 
 static void diff_pixels_c(int16_t *av_restrict block, const uint8_t *s1,
-                          const uint8_t *s2, int stride)
+                          const uint8_t *s2, ptrdiff_t stride)
 {
     int i;
 
@@ -82,6 +82,7 @@ av_cold void ff_pixblockdsp_init(PixblockDSPContext *c, AVCodecContext *avctx)
 {
     const unsigned high_bit_depth = avctx->bits_per_raw_sample > 8;
 
+    c->diff_pixels_unaligned =
     c->diff_pixels = diff_pixels_c;
 
     switch (avctx->bits_per_raw_sample) {
diff --git a/mythtv/external/FFmpeg/libavcodec/pixblockdsp.h b/mythtv/external/FFmpeg/libavcodec/pixblockdsp.h
index 79ed86c3a6c..e036700ff06 100644
--- a/mythtv/external/FFmpeg/libavcodec/pixblockdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/pixblockdsp.h
@@ -21,16 +21,23 @@
 
 #include <stdint.h>
 
+#include "config.h"
+
 #include "avcodec.h"
 
 typedef struct PixblockDSPContext {
-    void (*get_pixels)(int16_t *block /* align 16 */,
+    void (*get_pixels)(int16_t *av_restrict block /* align 16 */,
                        const uint8_t *pixels /* align 8 */,
-                       ptrdiff_t line_size);
-    void (*diff_pixels)(int16_t *block /* align 16 */,
+                       ptrdiff_t stride);
+    void (*diff_pixels)(int16_t *av_restrict block /* align 16 */,
                         const uint8_t *s1 /* align 8 */,
                         const uint8_t *s2 /* align 8 */,
-                        int stride);
+                        ptrdiff_t stride);
+    void (*diff_pixels_unaligned)(int16_t *av_restrict block /* align 16 */,
+                        const uint8_t *s1,
+                        const uint8_t *s2,
+                        ptrdiff_t stride);
+
 } PixblockDSPContext;
 
 void ff_pixblockdsp_init(PixblockDSPContext *c, AVCodecContext *avctx);
diff --git a/mythtv/external/FFmpeg/libavcodec/pixlet.c b/mythtv/external/FFmpeg/libavcodec/pixlet.c
new file mode 100644
index 00000000000..a9cfe085c92
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/pixlet.c
@@ -0,0 +1,690 @@
+/*
+ * Apple Pixlet decoder
+ * Copyright (c) 2016 Paul B Mahol
+ *
+ * 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 <stdint.h>
+
+#include "libavutil/imgutils.h"
+#include "libavutil/intmath.h"
+#include "libavutil/opt.h"
+
+#include "avcodec.h"
+#include "bytestream.h"
+#include "get_bits.h"
+#include "unary.h"
+#include "internal.h"
+#include "thread.h"
+
+#define NB_LEVELS 4
+
+#define H 0
+#define V 1
+
+typedef struct SubBand {
+    unsigned width, height;
+    unsigned size;
+    unsigned x, y;
+} SubBand;
+
+typedef struct PixletContext {
+    AVClass *class;
+
+    GetByteContext gb;
+    GetBitContext gbit;
+
+    int levels;
+    int depth;
+    int h, w;
+
+    int16_t *filter[2];
+    int16_t *prediction;
+    int64_t scaling[4][2][NB_LEVELS];
+    SubBand band[4][NB_LEVELS * 3 + 1];
+} PixletContext;
+
+static int init_decoder(AVCodecContext *avctx)
+{
+    PixletContext *ctx = avctx->priv_data;
+    int i, plane;
+
+    ctx->filter[0]  = av_malloc_array(ctx->h, sizeof(int16_t));
+    ctx->filter[1]  = av_malloc_array(FFMAX(ctx->h, ctx->w) + 16, sizeof(int16_t));
+    ctx->prediction = av_malloc_array((ctx->w >> NB_LEVELS), sizeof(int16_t));
+    if (!ctx->filter[0] || !ctx->filter[1] || !ctx->prediction)
+        return AVERROR(ENOMEM);
+
+    for (plane = 0; plane < 3; plane++) {
+        unsigned shift = plane > 0;
+        unsigned w = ctx->w >> shift;
+        unsigned h = ctx->h >> shift;
+
+        ctx->band[plane][0].width  = w >> NB_LEVELS;
+        ctx->band[plane][0].height = h >> NB_LEVELS;
+        ctx->band[plane][0].size = (w >> NB_LEVELS) * (h >> NB_LEVELS);
+
+        for (i = 0; i < NB_LEVELS * 3; i++) {
+            unsigned scale = ctx->levels - (i / 3);
+
+            ctx->band[plane][i + 1].width  = w >> scale;
+            ctx->band[plane][i + 1].height = h >> scale;
+            ctx->band[plane][i + 1].size = (w >> scale) * (h >> scale);
+
+            ctx->band[plane][i + 1].x = (w >> scale) * (((i + 1) % 3) != 2);
+            ctx->band[plane][i + 1].y = (h >> scale) * (((i + 1) % 3) != 1);
+        }
+    }
+
+    return 0;
+}
+
+static void free_buffers(AVCodecContext *avctx)
+{
+    PixletContext *ctx = avctx->priv_data;
+
+    av_freep(&ctx->filter[0]);
+    av_freep(&ctx->filter[1]);
+    av_freep(&ctx->prediction);
+}
+
+static av_cold int pixlet_close(AVCodecContext *avctx)
+{
+    PixletContext *ctx = avctx->priv_data;
+    free_buffers(avctx);
+    ctx->w = 0;
+    ctx->h = 0;
+    return 0;
+}
+
+static av_cold int pixlet_init(AVCodecContext *avctx)
+{
+    avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
+    avctx->color_range = AVCOL_RANGE_JPEG;
+    return 0;
+}
+
+static int read_low_coeffs(AVCodecContext *avctx, int16_t *dst, int size, int width, ptrdiff_t stride)
+{
+    PixletContext *ctx = avctx->priv_data;
+    GetBitContext *b = &ctx->gbit;
+    unsigned cnt1, nbits, k, j = 0, i = 0;
+    int64_t value, state = 3;
+    int rlen, escape, flag = 0;
+
+    while (i < size) {
+        nbits = FFMIN(ff_clz((state >> 8) + 3) ^ 0x1F, 14);
+
+        cnt1 = get_unary(b, 0, 8);
+        if (cnt1 < 8) {
+            value = show_bits(b, nbits);
+            if (value <= 1) {
+                skip_bits(b, nbits - 1);
+                escape = ((1 << nbits) - 1) * cnt1;
+            } else {
+                skip_bits(b, nbits);
+                escape = value + ((1 << nbits) - 1) * cnt1 - 1;
+            }
+        } else {
+            escape = get_bits(b, 16);
+        }
+
+        value = -((escape + flag) & 1) | 1;
+        dst[j++] = value * ((escape + flag + 1) >> 1);
+        i++;
+        if (j == width) {
+            j = 0;
+            dst += stride;
+        }
+        state = 120 * (escape + flag) + state - (120 * state >> 8);
+        flag = 0;
+
+        if (state * 4ULL > 0xFF || i >= size)
+            continue;
+
+        nbits = ((state + 8) >> 5) + (state ? ff_clz(state) : 32) - 24;
+        escape = av_mod_uintp2(16383, nbits);
+        cnt1 = get_unary(b, 0, 8);
+        if (cnt1 > 7) {
+            rlen = get_bits(b, 16);
+        } else {
+            value = show_bits(b, nbits);
+            if (value > 1) {
+                skip_bits(b, nbits);
+                rlen = value + escape * cnt1 - 1;
+            } else {
+                skip_bits(b, nbits - 1);
+                rlen = escape * cnt1;
+            }
+        }
+
+        if (rlen > size - i)
+            return AVERROR_INVALIDDATA;
+        i += rlen;
+
+        for (k = 0; k < rlen; k++) {
+            dst[j++] = 0;
+            if (j == width) {
+                j = 0;
+                dst += stride;
+            }
+        }
+
+        state = 0;
+        flag = rlen < 0xFFFF ? 1 : 0;
+    }
+
+    align_get_bits(b);
+    return get_bits_count(b) >> 3;
+}
+
+static int read_high_coeffs(AVCodecContext *avctx, uint8_t *src, int16_t *dst, int size,
+                            int c, int a, int d,
+                            int width, ptrdiff_t stride)
+{
+    PixletContext *ctx = avctx->priv_data;
+    GetBitContext *b = &ctx->gbit;
+    unsigned cnt1, shbits, rlen, nbits, length, i = 0, j = 0, k;
+    int ret, escape, pfx, value, yflag, xflag, flag = 0;
+    int64_t state = 3, tmp;
+
+    if ((ret = init_get_bits8(b, src, bytestream2_get_bytes_left(&ctx->gb))) < 0)
+      return ret;
+
+    if (a ^ (a >> 31)) {
+        nbits = 33 - ff_clz(a ^ (a >> 31));
+        if (nbits > 16)
+            return AVERROR_INVALIDDATA;
+    } else {
+        nbits = 1;
+    }
+
+    length = 25 - nbits;
+
+    while (i < size) {
+        if (state >> 8 != -3) {
+            value = ff_clz((state >> 8) + 3) ^ 0x1F;
+        } else {
+            value = -1;
+        }
+
+        cnt1 = get_unary(b, 0, length);
+
+        if (cnt1 >= length) {
+            cnt1 = get_bits(b, nbits);
+        } else {
+            pfx = 14 + ((((uint64_t)(value - 14)) >> 32) & (value - 14));
+            if (pfx < 1 || pfx > 25)
+                return AVERROR_INVALIDDATA;
+            cnt1 *= (1 << pfx) - 1;
+            shbits = show_bits(b, pfx);
+            if (shbits <= 1) {
+                skip_bits(b, pfx - 1);
+            } else {
+                skip_bits(b, pfx);
+                cnt1 += shbits - 1;
+            }
+        }
+
+        xflag = flag + cnt1;
+        yflag = xflag;
+
+        if (flag + cnt1 == 0) {
+            value = 0;
+        } else {
+            xflag &= 1u;
+            tmp = (int64_t)c * ((yflag + 1) >> 1) + (c >> 1);
+            value = xflag + (tmp ^ -xflag);
+        }
+
+        i++;
+        dst[j++] = value;
+        if (j == width) {
+            j = 0;
+            dst += stride;
+        }
+        state += (int64_t)d * (uint64_t)yflag - ((int64_t)(d * (uint64_t)state) >> 8);
+
+        flag = 0;
+
+        if ((uint64_t)state > 0xFF / 4 || i >= size)
+            continue;
+
+        pfx = ((state + 8) >> 5) + (state ? ff_clz(state): 32) - 24;
+        escape = av_mod_uintp2(16383, pfx);
+        cnt1 = get_unary(b, 0, 8);
+        if (cnt1 < 8) {
+            if (pfx < 1 || pfx > 25)
+                return AVERROR_INVALIDDATA;
+            value = show_bits(b, pfx);
+            if (value > 1) {
+                skip_bits(b, pfx);
+                rlen = value + escape * cnt1 - 1;
+            } else {
+                skip_bits(b, pfx - 1);
+                rlen = escape * cnt1;
+            }
+        } else {
+            if (get_bits1(b))
+                value = get_bits(b, 16);
+            else
+                value = get_bits(b, 8);
+
+            rlen = value + 8 * escape;
+        }
+
+        if (rlen > 0xFFFF || i + rlen > size)
+            return AVERROR_INVALIDDATA;
+        i += rlen;
+
+        for (k = 0; k < rlen; k++) {
+            dst[j++] = 0;
+            if (j == width) {
+                j = 0;
+                dst += stride;
+            }
+        }
+
+        state = 0;
+        flag = rlen < 0xFFFF ? 1 : 0;
+    }
+
+    align_get_bits(b);
+    return get_bits_count(b) >> 3;
+}
+
+static int read_highpass(AVCodecContext *avctx, uint8_t *ptr, int plane, AVFrame *frame)
+{
+    PixletContext *ctx = avctx->priv_data;
+    ptrdiff_t stride = frame->linesize[plane] / 2;
+    int i, ret;
+
+    for (i = 0; i < ctx->levels * 3; i++) {
+        int32_t a = bytestream2_get_be32(&ctx->gb);
+        int32_t b = bytestream2_get_be32(&ctx->gb);
+        int32_t c = bytestream2_get_be32(&ctx->gb);
+        int32_t d = bytestream2_get_be32(&ctx->gb);
+        int16_t *dest = (int16_t *)frame->data[plane] + ctx->band[plane][i + 1].x +
+                                               stride * ctx->band[plane][i + 1].y;
+        unsigned size = ctx->band[plane][i + 1].size;
+        uint32_t magic;
+
+        magic = bytestream2_get_be32(&ctx->gb);
+        if (magic != 0xDEADBEEF) {
+            av_log(avctx, AV_LOG_ERROR, "wrong magic number: 0x%08"PRIX32
+                   " for plane %d, band %d\n", magic, plane, i);
+            return AVERROR_INVALIDDATA;
+        }
+
+        if (a == INT32_MIN)
+            return AVERROR_INVALIDDATA;
+
+        ret = read_high_coeffs(avctx, ptr + bytestream2_tell(&ctx->gb), dest, size,
+                               c, (b >= FFABS(a)) ? b : a, d,
+                               ctx->band[plane][i + 1].width, stride);
+        if (ret < 0) {
+            av_log(avctx, AV_LOG_ERROR, "error in highpass coefficients for plane %d, band %d\n", plane, i);
+            return ret;
+        }
+        bytestream2_skip(&ctx->gb, ret);
+    }
+
+    return 0;
+}
+
+static void lowpass_prediction(int16_t *dst, int16_t *pred, int width, int height, ptrdiff_t stride)
+{
+    int16_t val;
+    int i, j;
+
+    memset(pred, 0, width * sizeof(*pred));
+
+    for (i = 0; i < height; i++) {
+        val    = pred[0] + dst[0];
+        dst[0] = pred[0] = val;
+        for (j = 1; j < width; j++) {
+            val     = pred[j] + dst[j];
+            dst[j]  = pred[j] = val;
+            dst[j] += dst[j-1];
+        }
+        dst += stride;
+    }
+}
+
+static void filterfn(int16_t *dest, int16_t *tmp, unsigned size, int64_t scale)
+{
+    int16_t *low, *high, *ll, *lh, *hl, *hh;
+    int hsize, i, j;
+    int64_t value;
+
+    hsize = size >> 1;
+    low = tmp + 4;
+    high = &low[hsize + 8];
+
+    memcpy(low, dest, size);
+    memcpy(high, dest + hsize, size);
+
+    ll = &low[hsize];
+    lh = &low[hsize];
+    hl = &high[hsize];
+    hh = hl;
+    for (i = 4, j = 2; i; i--, j++, ll--, hh++, lh++, hl--) {
+        low[i - 5]  = low[j - 1];
+        lh[0]       = ll[-1];
+        high[i - 5] = high[j - 2];
+        hh[0]       = hl[-2];
+    }
+
+    for (i = 0; i < hsize; i++) {
+        value = (int64_t) low [i + 1] * -INT64_C(325392907)  +
+                (int64_t) low [i + 0] *  INT64_C(3687786320) +
+                (int64_t) low [i - 1] * -INT64_C(325392907)  +
+                (int64_t) high[i + 0] *  INT64_C(1518500249) +
+                (int64_t) high[i - 1] *  INT64_C(1518500249);
+        dest[i * 2] = av_clip_int16(((value >> 32) * scale) >> 32);
+    }
+
+    for (i = 0; i < hsize; i++) {
+        value = (int64_t) low [i + 2] * -INT64_C(65078576)   +
+                (int64_t) low [i + 1] *  INT64_C(1583578880) +
+                (int64_t) low [i + 0] *  INT64_C(1583578880) +
+                (int64_t) low [i - 1] * -INT64_C(65078576)   +
+                (int64_t) high[i + 1] *  INT64_C(303700064)  +
+                (int64_t) high[i + 0] * -INT64_C(3644400640) +
+                (int64_t) high[i - 1] *  INT64_C(303700064);
+        dest[i * 2 + 1] = av_clip_int16(((value >> 32) * scale) >> 32);
+    }
+}
+
+static void reconstruction(AVCodecContext *avctx,
+                           int16_t *dest, unsigned width, unsigned height, ptrdiff_t stride, int nb_levels,
+                           int64_t *scaling_H, int64_t *scaling_V)
+{
+    PixletContext *ctx = avctx->priv_data;
+    unsigned scaled_width, scaled_height;
+    int64_t scale_H, scale_V;
+    int16_t *ptr, *tmp;
+    int i, j, k;
+
+    scaled_height = height >> nb_levels;
+    scaled_width  = width  >> nb_levels;
+    tmp = ctx->filter[0];
+
+    for (i = 0; i < nb_levels; i++) {
+        scaled_width  <<= 1;
+        scaled_height <<= 1;
+        scale_H = scaling_H[i];
+        scale_V = scaling_V[i];
+
+        ptr = dest;
+        for (j = 0; j < scaled_height; j++) {
+            filterfn(ptr, ctx->filter[1], scaled_width, scale_V);
+            ptr += stride;
+        }
+
+        for (j = 0; j < scaled_width; j++) {
+            ptr = dest + j;
+            for (k = 0; k < scaled_height; k++) {
+                tmp[k] = *ptr;
+                ptr += stride;
+            }
+
+            filterfn(tmp, ctx->filter[1], scaled_height, scale_H);
+
+            ptr = dest + j;
+            for (k = 0; k < scaled_height; k++) {
+                *ptr = tmp[k];
+                ptr += stride;
+            }
+        }
+    }
+}
+
+static void postprocess_luma(AVFrame *frame, int w, int h, int depth)
+{
+    uint16_t *dsty = (uint16_t *)frame->data[0];
+    int16_t *srcy  = (int16_t *)frame->data[0];
+    ptrdiff_t stridey = frame->linesize[0] / 2;
+    int i, j;
+
+    for (j = 0; j < h; j++) {
+        for (i = 0; i < w; i++) {
+            if (srcy[i] <= 0)
+                dsty[i] = 0;
+            else if (srcy[i] > ((1 << depth) - 1))
+                dsty[i] = 65535;
+            else
+                dsty[i] = ((int64_t) srcy[i] * srcy[i] * 65535) /
+                          ((1 << depth) - 1) / ((1 << depth) - 1);
+        }
+        dsty += stridey;
+        srcy += stridey;
+    }
+}
+
+static void postprocess_chroma(AVFrame *frame, int w, int h, int depth)
+{
+    uint16_t *dstu = (uint16_t *)frame->data[1];
+    uint16_t *dstv = (uint16_t *)frame->data[2];
+    int16_t *srcu  = (int16_t *)frame->data[1];
+    int16_t *srcv  = (int16_t *)frame->data[2];
+    ptrdiff_t strideu = frame->linesize[1] / 2;
+    ptrdiff_t stridev = frame->linesize[2] / 2;
+    const unsigned add = 1 << (depth - 1);
+    const unsigned shift = 16 - depth;
+    int i, j;
+
+    for (j = 0; j < h; j++) {
+        for (i = 0; i < w; i++) {
+            dstu[i] = av_clip_uintp2_c(add + srcu[i], depth) << shift;
+            dstv[i] = av_clip_uintp2_c(add + srcv[i], depth) << shift;
+        }
+        dstu += strideu;
+        dstv += stridev;
+        srcu += strideu;
+        srcv += stridev;
+    }
+}
+
+static int decode_plane(AVCodecContext *avctx, int plane, AVPacket *avpkt, AVFrame *frame)
+{
+    PixletContext *ctx = avctx->priv_data;
+    ptrdiff_t stride = frame->linesize[plane] / 2;
+    unsigned shift = plane > 0;
+    int16_t *dst;
+    int i, ret;
+
+    for (i = ctx->levels - 1; i >= 0; i--) {
+        int32_t h = sign_extend(bytestream2_get_be32(&ctx->gb), 32);
+        int32_t v = sign_extend(bytestream2_get_be32(&ctx->gb), 32);
+
+        if (!h || !v)
+            return AVERROR_INVALIDDATA;
+
+        ctx->scaling[plane][H][i] = (1000000ULL << 32) / h;
+        ctx->scaling[plane][V][i] = (1000000ULL << 32) / v;
+    }
+
+    bytestream2_skip(&ctx->gb, 4);
+
+    dst = (int16_t *)frame->data[plane];
+    dst[0] = sign_extend(bytestream2_get_be16(&ctx->gb), 16);
+
+    if ((ret = init_get_bits8(&ctx->gbit, avpkt->data + bytestream2_tell(&ctx->gb),
+                              bytestream2_get_bytes_left(&ctx->gb))) < 0)
+        return ret;
+
+    ret = read_low_coeffs(avctx, dst + 1, ctx->band[plane][0].width - 1, ctx->band[plane][0].width - 1, 0);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "error in lowpass coefficients for plane %d, top row\n", plane);
+        return ret;
+    }
+
+    ret = read_low_coeffs(avctx, dst + stride, ctx->band[plane][0].height - 1, 1, stride);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "error in lowpass coefficients for plane %d, left column\n", plane);
+        return ret;
+    }
+
+    ret = read_low_coeffs(avctx, dst + stride + 1,
+                          (ctx->band[plane][0].width - 1) * (ctx->band[plane][0].height - 1),
+                          ctx->band[plane][0].width - 1, stride);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "error in lowpass coefficients for plane %d, rest\n", plane);
+        return ret;
+    }
+
+    bytestream2_skip(&ctx->gb, ret);
+    if (bytestream2_get_bytes_left(&ctx->gb) <= 0) {
+        av_log(avctx, AV_LOG_ERROR, "no bytes left\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    ret = read_highpass(avctx, avpkt->data, plane, frame);
+    if (ret < 0)
+        return ret;
+
+    lowpass_prediction(dst, ctx->prediction,
+                       ctx->band[plane][0].width, ctx->band[plane][0].height, stride);
+
+    reconstruction(avctx, (int16_t *)frame->data[plane], ctx->w >> shift, ctx->h >> shift,
+                   stride, NB_LEVELS, ctx->scaling[plane][H], ctx->scaling[plane][V]);
+
+    return 0;
+}
+
+static int pixlet_decode_frame(AVCodecContext *avctx, void *data,
+                               int *got_frame, AVPacket *avpkt)
+{
+    PixletContext *ctx = avctx->priv_data;
+    int i, w, h, width, height, ret, version;
+    AVFrame *p = data;
+    ThreadFrame frame = { .f = data };
+    uint32_t pktsize;
+
+    bytestream2_init(&ctx->gb, avpkt->data, avpkt->size);
+
+    pktsize = bytestream2_get_be32(&ctx->gb);
+    if (pktsize <= 44 || pktsize - 4 > bytestream2_get_bytes_left(&ctx->gb)) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid packet size %"PRIu32"\n", pktsize);
+        return AVERROR_INVALIDDATA;
+    }
+
+    version = bytestream2_get_le32(&ctx->gb);
+    if (version != 1)
+        avpriv_request_sample(avctx, "Version %d", version);
+
+    bytestream2_skip(&ctx->gb, 4);
+    if (bytestream2_get_be32(&ctx->gb) != 1)
+        return AVERROR_INVALIDDATA;
+    bytestream2_skip(&ctx->gb, 4);
+
+    width  = bytestream2_get_be32(&ctx->gb);
+    height = bytestream2_get_be32(&ctx->gb);
+
+    if (    width > INT_MAX - (1U << (NB_LEVELS + 1))
+        || height > INT_MAX - (1U << (NB_LEVELS + 1)))
+        return AVERROR_INVALIDDATA;
+
+    w = FFALIGN(width,  1 << (NB_LEVELS + 1));
+    h = FFALIGN(height, 1 << (NB_LEVELS + 1));
+
+    ctx->levels = bytestream2_get_be32(&ctx->gb);
+    if (ctx->levels != NB_LEVELS)
+        return AVERROR_INVALIDDATA;
+    ctx->depth = bytestream2_get_be32(&ctx->gb);
+    if (ctx->depth < 8 || ctx->depth > 15) {
+        avpriv_request_sample(avctx, "Depth %d", ctx->depth);
+        return AVERROR_INVALIDDATA;
+    }
+
+    ret = ff_set_dimensions(avctx, w, h);
+    if (ret < 0)
+        return ret;
+    avctx->width  = width;
+    avctx->height = height;
+
+    if (ctx->w != w || ctx->h != h) {
+        free_buffers(avctx);
+        ctx->w = w;
+        ctx->h = h;
+
+        ret = init_decoder(avctx);
+        if (ret < 0) {
+            free_buffers(avctx);
+            ctx->w = 0;
+            ctx->h = 0;
+            return ret;
+        }
+    }
+
+    bytestream2_skip(&ctx->gb, 8);
+
+    p->pict_type = AV_PICTURE_TYPE_I;
+    p->key_frame = 1;
+    p->color_range = AVCOL_RANGE_JPEG;
+
+    ret = ff_thread_get_buffer(avctx, &frame, 0);
+    if (ret < 0)
+        return ret;
+
+    for (i = 0; i < 3; i++) {
+        ret = decode_plane(avctx, i, avpkt, frame.f);
+        if (ret < 0)
+            return ret;
+        if (avctx->flags & AV_CODEC_FLAG_GRAY)
+            break;
+    }
+
+    postprocess_luma(frame.f, ctx->w, ctx->h, ctx->depth);
+    postprocess_chroma(frame.f, ctx->w >> 1, ctx->h >> 1, ctx->depth);
+
+    *got_frame = 1;
+
+    return pktsize;
+}
+
+#if HAVE_THREADS
+static int pixlet_init_thread_copy(AVCodecContext *avctx)
+{
+    PixletContext *ctx = avctx->priv_data;
+
+    ctx->filter[0] = NULL;
+    ctx->filter[1] = NULL;
+    ctx->prediction = NULL;
+    ctx->w = ctx->h = 0;
+
+    return 0;
+}
+#endif
+
+AVCodec ff_pixlet_decoder = {
+    .name             = "pixlet",
+    .long_name        = NULL_IF_CONFIG_SMALL("Apple Pixlet"),
+    .type             = AVMEDIA_TYPE_VIDEO,
+    .id               = AV_CODEC_ID_PIXLET,
+    .init             = pixlet_init,
+    .init_thread_copy = ONLY_IF_THREADS_ENABLED(pixlet_init_thread_copy),
+    .close            = pixlet_close,
+    .decode           = pixlet_decode_frame,
+    .priv_data_size   = sizeof(PixletContext),
+    .capabilities     = AV_CODEC_CAP_DR1 |
+                        AV_CODEC_CAP_FRAME_THREADS,
+    .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
+                        FF_CODEC_CAP_INIT_CLEANUP,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/png.h b/mythtv/external/FFmpeg/libavcodec/png.h
index 948c2f714f3..e967fcf38fb 100644
--- a/mythtv/external/FFmpeg/libavcodec/png.h
+++ b/mythtv/external/FFmpeg/libavcodec/png.h
@@ -42,11 +42,6 @@
 #define PNG_FILTER_VALUE_PAETH 4
 #define PNG_FILTER_VALUE_MIXED 5
 
-#define PNG_IHDR      0x0001
-#define PNG_IDAT      0x0002
-#define PNG_ALLIMAGE  0x0004
-#define PNG_PLTE      0x0008
-
 #define NB_PASSES 7
 
 #define PNGSIG 0x89504e470d0a1a0a
diff --git a/mythtv/external/FFmpeg/libavcodec/pngdec.c b/mythtv/external/FFmpeg/libavcodec/pngdec.c
index 36275ae43f5..0d6612cccaf 100644
--- a/mythtv/external/FFmpeg/libavcodec/pngdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/pngdec.c
@@ -36,6 +36,16 @@
 
 #include <zlib.h>
 
+enum PNGHeaderState {
+    PNG_IHDR = 1 << 0,
+    PNG_PLTE = 1 << 1,
+};
+
+enum PNGImageState {
+    PNG_IDAT     = 1 << 0,
+    PNG_ALLIMAGE = 1 << 1,
+};
+
 typedef struct PNGDecContext {
     PNGDSPContext dsp;
     AVCodecContext *avctx;
@@ -45,7 +55,8 @@ typedef struct PNGDecContext {
     ThreadFrame last_picture;
     ThreadFrame picture;
 
-    int state;
+    enum PNGHeaderState hdr_state;
+    enum PNGImageState pic_state;
     int width, height;
     int cur_w, cur_h;
     int last_w, last_h;
@@ -334,7 +345,7 @@ static void png_handle_row(PNGDecContext *s)
         }
         s->y++;
         if (s->y == s->cur_h) {
-            s->state |= PNG_ALLIMAGE;
+            s->pic_state |= PNG_ALLIMAGE;
             if (s->filter_type == PNG_FILTER_TYPE_LOCO) {
                 if (s->bit_depth == 16) {
                     deloco_rgb16((uint16_t *)ptr, s->row_size / 2,
@@ -369,7 +380,7 @@ static void png_handle_row(PNGDecContext *s)
                 memset(s->last_row, 0, s->row_size);
                 for (;;) {
                     if (s->pass == NB_PASSES - 1) {
-                        s->state |= PNG_ALLIMAGE;
+                        s->pic_state |= PNG_ALLIMAGE;
                         goto the_end;
                     } else {
                         s->pass++;
@@ -404,7 +415,7 @@ static int png_decode_idat(PNGDecContext *s, int length)
             return AVERROR_EXTERNAL;
         }
         if (s->zstream.avail_out == 0) {
-            if (!(s->state & PNG_ALLIMAGE)) {
+            if (!(s->pic_state & PNG_ALLIMAGE)) {
                 png_handle_row(s);
             }
             s->zstream.avail_out = s->crow_size;
@@ -437,13 +448,13 @@ static int decode_zbuf(AVBPrint *bp, const uint8_t *data,
     av_bprint_init(bp, 0, -1);
 
     while (zstream.avail_in > 0) {
-        av_bprint_get_buffer(bp, 1, &buf, &buf_size);
-        if (!buf_size) {
+        av_bprint_get_buffer(bp, 2, &buf, &buf_size);
+        if (buf_size < 2) {
             ret = AVERROR(ENOMEM);
             goto fail;
         }
         zstream.next_out  = buf;
-        zstream.avail_out = buf_size;
+        zstream.avail_out = buf_size - 1;
         ret = inflate(&zstream, Z_PARTIAL_FLUSH);
         if (ret != Z_OK && ret != Z_STREAM_END) {
             ret = AVERROR_EXTERNAL;
@@ -541,12 +552,12 @@ static int decode_ihdr_chunk(AVCodecContext *avctx, PNGDecContext *s,
     if (length != 13)
         return AVERROR_INVALIDDATA;
 
-    if (s->state & PNG_IDAT) {
+    if (s->pic_state & PNG_IDAT) {
         av_log(avctx, AV_LOG_ERROR, "IHDR after IDAT\n");
         return AVERROR_INVALIDDATA;
     }
 
-    if (s->state & PNG_IHDR) {
+    if (s->hdr_state & PNG_IHDR) {
         av_log(avctx, AV_LOG_ERROR, "Multiple IHDR\n");
         return AVERROR_INVALIDDATA;
     }
@@ -559,12 +570,17 @@ static int decode_ihdr_chunk(AVCodecContext *avctx, PNGDecContext *s,
         return AVERROR_INVALIDDATA;
     }
     s->bit_depth        = bytestream2_get_byte(&s->gb);
+    if (s->bit_depth != 1 && s->bit_depth != 2 && s->bit_depth != 4 &&
+        s->bit_depth != 8 && s->bit_depth != 16) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid bit depth\n");
+        goto error;
+    }
     s->color_type       = bytestream2_get_byte(&s->gb);
     s->compression_type = bytestream2_get_byte(&s->gb);
     s->filter_type      = bytestream2_get_byte(&s->gb);
     s->interlace_type   = bytestream2_get_byte(&s->gb);
     bytestream2_skip(&s->gb, 4); /* crc */
-    s->state |= PNG_IHDR;
+    s->hdr_state |= PNG_IHDR;
     if (avctx->debug & FF_DEBUG_PICT_INFO)
         av_log(avctx, AV_LOG_DEBUG, "width=%d height=%d depth=%d color_type=%d "
                 "compression_type=%d filter_type=%d interlace_type=%d\n",
@@ -572,11 +588,15 @@ static int decode_ihdr_chunk(AVCodecContext *avctx, PNGDecContext *s,
                 s->compression_type, s->filter_type, s->interlace_type);
 
     return 0;
+error:
+    s->cur_w = s->cur_h = s->width = s->height = 0;
+    s->bit_depth = 8;
+    return AVERROR_INVALIDDATA;
 }
 
 static int decode_phys_chunk(AVCodecContext *avctx, PNGDecContext *s)
 {
-    if (s->state & PNG_IDAT) {
+    if (s->pic_state & PNG_IDAT) {
         av_log(avctx, AV_LOG_ERROR, "pHYs after IDAT\n");
         return AVERROR_INVALIDDATA;
     }
@@ -596,14 +616,15 @@ static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s,
     int ret;
     size_t byte_depth = s->bit_depth > 8 ? 2 : 1;
 
-    if (!(s->state & PNG_IHDR)) {
+    if (!(s->hdr_state & PNG_IHDR)) {
         av_log(avctx, AV_LOG_ERROR, "IDAT without IHDR\n");
         return AVERROR_INVALIDDATA;
     }
-    if (!(s->state & PNG_IDAT)) {
+    if (!(s->pic_state & PNG_IDAT)) {
         /* init image info */
-        avctx->width  = s->width;
-        avctx->height = s->height;
+        ret = ff_set_dimensions(avctx, s->width, s->height);
+        if (ret < 0)
+            return ret;
 
         s->channels       = ff_png_get_nb_channels(s->color_type);
         s->bits_per_pixel = s->bit_depth * s->channels;
@@ -681,12 +702,12 @@ static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s,
             if ((ret = ff_thread_get_buffer(avctx, &s->previous_picture, AV_GET_BUFFER_FLAG_REF)) < 0)
                 return ret;
         }
-        ff_thread_finish_setup(avctx);
-
         p->pict_type        = AV_PICTURE_TYPE_I;
         p->key_frame        = 1;
         p->interlaced_frame = !!s->interlace_type;
 
+        ff_thread_finish_setup(avctx);
+
         /* compute the compressed row size */
         if (!s->interlace_type) {
             s->crow_size = s->row_size + 1;
@@ -725,7 +746,7 @@ static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s,
         s->zstream.next_out  = s->crow_buf;
     }
 
-    s->state |= PNG_IDAT;
+    s->pic_state |= PNG_IDAT;
 
     /* set image to non-transparent bpp while decompressing */
     if (s->has_trns && s->color_type != PNG_COLOR_TYPE_PALETTE)
@@ -761,7 +782,7 @@ static int decode_plte_chunk(AVCodecContext *avctx, PNGDecContext *s,
     }
     for (; i < 256; i++)
         s->palette[i] = (0xFFU << 24);
-    s->state |= PNG_PLTE;
+    s->hdr_state |= PNG_PLTE;
     bytestream2_skip(&s->gb, 4);     /* crc */
 
     return 0;
@@ -772,17 +793,28 @@ static int decode_trns_chunk(AVCodecContext *avctx, PNGDecContext *s,
 {
     int v, i;
 
+    if (!(s->hdr_state & PNG_IHDR)) {
+        av_log(avctx, AV_LOG_ERROR, "trns before IHDR\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    if (s->pic_state & PNG_IDAT) {
+        av_log(avctx, AV_LOG_ERROR, "trns after IDAT\n");
+        return AVERROR_INVALIDDATA;
+    }
+
     if (s->color_type == PNG_COLOR_TYPE_PALETTE) {
-        if (length > 256 || !(s->state & PNG_PLTE))
+        if (length > 256 || !(s->hdr_state & PNG_PLTE))
             return AVERROR_INVALIDDATA;
 
         for (i = 0; i < length; i++) {
-            v = bytestream2_get_byte(&s->gb);
+            unsigned v = bytestream2_get_byte(&s->gb);
             s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24);
         }
     } else if (s->color_type == PNG_COLOR_TYPE_GRAY || s->color_type == PNG_COLOR_TYPE_RGB) {
         if ((s->color_type == PNG_COLOR_TYPE_GRAY && length != 2) ||
-            (s->color_type == PNG_COLOR_TYPE_RGB && length != 6))
+            (s->color_type == PNG_COLOR_TYPE_RGB && length != 6) ||
+            s->bit_depth == 1)
             return AVERROR_INVALIDDATA;
 
         for (i = 0; i < length / 2; i++) {
@@ -804,6 +836,49 @@ static int decode_trns_chunk(AVCodecContext *avctx, PNGDecContext *s,
     return 0;
 }
 
+static int decode_iccp_chunk(PNGDecContext *s, int length, AVFrame *f)
+{
+    int ret, cnt = 0;
+    uint8_t *data, profile_name[82];
+    AVBPrint bp;
+    AVFrameSideData *sd;
+
+    while ((profile_name[cnt++] = bytestream2_get_byte(&s->gb)) && cnt < 81);
+    if (cnt > 80) {
+        av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid name!\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    length = FFMAX(length - cnt, 0);
+
+    if (bytestream2_get_byte(&s->gb) != 0) {
+        av_log(s->avctx, AV_LOG_ERROR, "iCCP with invalid compression!\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    length = FFMAX(length - 1, 0);
+
+    if ((ret = decode_zbuf(&bp, s->gb.buffer, s->gb.buffer + length)) < 0)
+        return ret;
+
+    av_bprint_finalize(&bp, (char **)&data);
+
+    sd = av_frame_new_side_data(f, AV_FRAME_DATA_ICC_PROFILE, bp.len);
+    if (!sd) {
+        av_free(data);
+        return AVERROR(ENOMEM);
+    }
+
+    av_dict_set(&sd->metadata, "name", profile_name, 0);
+    memcpy(sd->data, data, bp.len);
+    av_free(data);
+
+    /* ICC compressed data and CRC */
+    bytestream2_skip(&s->gb, length + 4);
+
+    return 0;
+}
+
 static void handle_small_bpp(PNGDecContext *s, AVFrame *p)
 {
     if (s->bits_per_pixel == 1 && s->color_type == PNG_COLOR_TYPE_PALETTE) {
@@ -886,7 +961,7 @@ static int decode_fctl_chunk(AVCodecContext *avctx, PNGDecContext *s,
     if (length != 26)
         return AVERROR_INVALIDDATA;
 
-    if (!(s->state & PNG_IHDR)) {
+    if (!(s->hdr_state & PNG_IHDR)) {
         av_log(avctx, AV_LOG_ERROR, "fctl before IHDR\n");
         return AVERROR_INVALIDDATA;
     }
@@ -922,7 +997,8 @@ static int decode_fctl_chunk(AVCodecContext *avctx, PNGDecContext *s,
         return AVERROR_INVALIDDATA;
     }
 
-    if (sequence_number == 0 && dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
+    if ((sequence_number == 0 || !s->previous_picture.f->data[0]) &&
+        dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
         // No previous frame to revert to for the first frame
         // Spec says to just treat it as a APNG_DISPOSE_OP_BACKGROUND
         dispose_op = APNG_DISPOSE_OP_BACKGROUND;
@@ -1086,7 +1162,7 @@ static int handle_p_frame_apng(AVCodecContext *avctx, PNGDecContext *s,
 static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
                                AVFrame *p, AVPacket *avpkt)
 {
-    AVDictionary *metadata  = NULL;
+    AVDictionary **metadatap = NULL;
     uint32_t tag, length;
     int decode_next_dat = 0;
     int ret;
@@ -1097,18 +1173,17 @@ static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
 
             if (avctx->codec_id == AV_CODEC_ID_PNG &&
                 avctx->skip_frame == AVDISCARD_ALL) {
-                av_frame_set_metadata(p, metadata);
                 return 0;
             }
 
             if (CONFIG_APNG_DECODER && avctx->codec_id == AV_CODEC_ID_APNG && length == 0) {
-                if (!(s->state & PNG_IDAT))
+                if (!(s->pic_state & PNG_IDAT))
                     return 0;
                 else
                     goto exit_loop;
             }
             av_log(avctx, AV_LOG_ERROR, "%d bytes left\n", length);
-            if (   s->state & PNG_ALLIMAGE
+            if (   s->pic_state & PNG_ALLIMAGE
                 && avctx->strict_std_compliance <= FF_COMPLIANCE_NORMAL)
                 goto exit_loop;
             ret = AVERROR_INVALIDDATA;
@@ -1123,11 +1198,8 @@ static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
         }
         tag = bytestream2_get_le32(&s->gb);
         if (avctx->debug & FF_DEBUG_STARTCODE)
-            av_log(avctx, AV_LOG_DEBUG, "png: tag=%c%c%c%c length=%u\n",
-                (tag & 0xff),
-                ((tag >> 8) & 0xff),
-                ((tag >> 16) & 0xff),
-                ((tag >> 24) & 0xff), length);
+            av_log(avctx, AV_LOG_DEBUG, "png: tag=%s length=%u\n",
+                   av_fourcc2str(tag), length);
 
         if (avctx->codec_id == AV_CODEC_ID_PNG &&
             avctx->skip_frame == AVDISCARD_ALL) {
@@ -1143,6 +1215,7 @@ static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
             }
         }
 
+        metadatap = &p->metadata;
         switch (tag) {
         case MKTAG('I', 'H', 'D', 'R'):
             if ((ret = decode_ihdr_chunk(avctx, s, length)) < 0)
@@ -1184,12 +1257,12 @@ static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
                 goto skip_tag;
             break;
         case MKTAG('t', 'E', 'X', 't'):
-            if (decode_text_chunk(s, length, 0, &metadata) < 0)
+            if (decode_text_chunk(s, length, 0, metadatap) < 0)
                 av_log(avctx, AV_LOG_WARNING, "Broken tEXt chunk\n");
             bytestream2_skip(&s->gb, length + 4);
             break;
         case MKTAG('z', 'T', 'X', 't'):
-            if (decode_text_chunk(s, length, 1, &metadata) < 0)
+            if (decode_text_chunk(s, length, 1, metadatap) < 0)
                 av_log(avctx, AV_LOG_WARNING, "Broken zTXt chunk\n");
             bytestream2_skip(&s->gb, length + 4);
             break;
@@ -1209,10 +1282,15 @@ static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
             bytestream2_skip(&s->gb, 4); /* crc */
             break;
         }
+        case MKTAG('i', 'C', 'C', 'P'): {
+            if (decode_iccp_chunk(s, length, p) < 0)
+                goto fail;
+            break;
+        }
         case MKTAG('I', 'E', 'N', 'D'):
-            if (!(s->state & PNG_ALLIMAGE))
+            if (!(s->pic_state & PNG_ALLIMAGE))
                 av_log(avctx, AV_LOG_ERROR, "IEND without all image\n");
-            if (!(s->state & (PNG_ALLIMAGE|PNG_IDAT))) {
+            if (!(s->pic_state & (PNG_ALLIMAGE|PNG_IDAT))) {
                 ret = AVERROR_INVALIDDATA;
                 goto fail;
             }
@@ -1226,9 +1304,9 @@ static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
         }
     }
 exit_loop:
+
     if (avctx->codec_id == AV_CODEC_ID_PNG &&
         avctx->skip_frame == AVDISCARD_ALL) {
-        av_frame_set_metadata(p, metadata);
         return 0;
     }
 
@@ -1241,6 +1319,8 @@ static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
         size_t raw_bpp = s->bpp - byte_depth;
         unsigned x, y;
 
+        av_assert0(s->bit_depth > 1);
+
         for (y = 0; y < s->height; ++y) {
             uint8_t *row = &s->image_buf[s->image_linesize * y];
 
@@ -1276,12 +1356,9 @@ static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s,
     ff_thread_report_progress(&s->picture, INT_MAX, 0);
     ff_thread_report_progress(&s->previous_picture, INT_MAX, 0);
 
-    av_frame_set_metadata(p, metadata);
-    metadata   = NULL;
     return 0;
 
 fail:
-    av_dict_free(&metadata);
     ff_thread_report_progress(&s->picture, INT_MAX, 0);
     ff_thread_report_progress(&s->previous_picture, INT_MAX, 0);
     return ret;
@@ -1313,7 +1390,9 @@ static int decode_frame_png(AVCodecContext *avctx,
         return AVERROR_INVALIDDATA;
     }
 
-    s->y = s->state = s->has_trns = 0;
+    s->y = s->has_trns = 0;
+    s->hdr_state = 0;
+    s->pic_state = 0;
 
     /* init the zlib */
     s->zstream.zalloc = ff_png_zalloc;
@@ -1335,7 +1414,7 @@ static int decode_frame_png(AVCodecContext *avctx,
     }
 
     if ((ret = av_frame_ref(data, s->picture.f)) < 0)
-        return ret;
+        goto the_end;
 
     *got_frame = 1;
 
@@ -1360,7 +1439,7 @@ static int decode_frame_apng(AVCodecContext *avctx,
     FFSWAP(ThreadFrame, s->picture, s->last_picture);
     p = s->picture.f;
 
-    if (!(s->state & PNG_IHDR)) {
+    if (!(s->hdr_state & PNG_IHDR)) {
         if (!avctx->extradata_size)
             return AVERROR_INVALIDDATA;
 
@@ -1380,14 +1459,14 @@ static int decode_frame_apng(AVCodecContext *avctx,
         goto end;
     }
     s->y = 0;
-    s->state &= ~(PNG_IDAT | PNG_ALLIMAGE);
+    s->pic_state = 0;
     bytestream2_init(&s->gb, avpkt->data, avpkt->size);
     if ((ret = decode_frame_common(avctx, s, p, avpkt)) < 0)
         goto end;
 
-    if (!(s->state & PNG_ALLIMAGE))
+    if (!(s->pic_state & PNG_ALLIMAGE))
         av_log(avctx, AV_LOG_WARNING, "Frame did not contain a complete image\n");
-    if (!(s->state & (PNG_ALLIMAGE|PNG_IDAT))) {
+    if (!(s->pic_state & (PNG_ALLIMAGE|PNG_IDAT))) {
         ret = AVERROR_INVALIDDATA;
         goto end;
     }
@@ -1436,7 +1515,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
 
         memcpy(pdst->palette, psrc->palette, sizeof(pdst->palette));
 
-        pdst->state |= psrc->state & (PNG_IHDR | PNG_PLTE);
+        pdst->hdr_state |= psrc->hdr_state;
 
         ff_thread_release_buffer(dst, &pdst->last_picture);
         if (psrc->last_picture.f->data[0] &&
@@ -1511,6 +1590,7 @@ AVCodec ff_apng_decoder = {
     .init_thread_copy = ONLY_IF_THREADS_ENABLED(png_dec_init),
     .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
 #endif
 
@@ -1527,6 +1607,6 @@ AVCodec ff_png_decoder = {
     .init_thread_copy = ONLY_IF_THREADS_ENABLED(png_dec_init),
     .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/,
-    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+    .caps_internal  = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_INIT_THREADSAFE,
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/pngenc.c b/mythtv/external/FFmpeg/libavcodec/pngenc.c
index 00c830e6eb0..69b44954049 100644
--- a/mythtv/external/FFmpeg/libavcodec/pngenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/pngenc.c
@@ -22,7 +22,7 @@
 #include "avcodec.h"
 #include "internal.h"
 #include "bytestream.h"
-#include "huffyuvencdsp.h"
+#include "lossless_videoencdsp.h"
 #include "png.h"
 #include "apng.h"
 
@@ -47,7 +47,7 @@ typedef struct APNGFctlChunk {
 
 typedef struct PNGEncContext {
     AVClass *class;
-    HuffYUVEncDSPContext hdsp;
+    LLVidEncDSPContext llvidencdsp;
 
     uint8_t *bytestream;
     uint8_t *bytestream_start;
@@ -68,6 +68,9 @@ typedef struct PNGEncContext {
     // APNG
     uint32_t palette_checksum;   // Used to ensure a single unique palette
     uint32_t sequence_number;
+    int extra_data_updated;
+    uint8_t *extra_data;
+    int extra_data_size;
 
     AVFrame *prev_frame;
     AVFrame *last_frame;
@@ -156,7 +159,7 @@ static void sub_left_prediction(PNGEncContext *c, uint8_t *dst, const uint8_t *s
     for (x = 0; x < unaligned_w; x++)
         *dst++ = *src1++ - *src2++;
     size -= unaligned_w;
-    c->hdsp.diff_bytes(dst, src1, src2, size);
+    c->llvidencdsp.diff_bytes(dst, src1, src2, size);
 }
 
 static void png_filter_row(PNGEncContext *c, uint8_t *dst, int filter_type,
@@ -172,7 +175,7 @@ static void png_filter_row(PNGEncContext *c, uint8_t *dst, int filter_type,
         sub_left_prediction(c, dst, src, bpp, size);
         break;
     case PNG_FILTER_VALUE_UP:
-        c->hdsp.diff_bytes(dst, src, top, size);
+        c->llvidencdsp.diff_bytes(dst, src, top, size);
         break;
     case PNG_FILTER_VALUE_AVG:
         for (i = 0; i < bpp; i++)
@@ -870,15 +873,15 @@ static int encode_apng(AVCodecContext *avctx, AVPacket *pkt,
         if (!pict)
             return AVERROR(EINVAL);
 
-        s->bytestream = avctx->extradata = av_malloc(FF_MIN_BUFFER_SIZE);
-        if (!avctx->extradata)
+        s->bytestream = s->extra_data = av_malloc(AV_INPUT_BUFFER_MIN_SIZE);
+        if (!s->extra_data)
             return AVERROR(ENOMEM);
 
         ret = encode_headers(avctx, pict);
         if (ret < 0)
             return ret;
 
-        avctx->extradata_size = s->bytestream - avctx->extradata;
+        s->extra_data_size = s->bytestream - s->extra_data;
 
         s->last_frame_packet = av_malloc(max_packet_size);
         if (!s->last_frame_packet)
@@ -917,6 +920,13 @@ static int encode_apng(AVCodecContext *avctx, AVPacket *pkt,
     if (s->last_frame) {
         uint8_t* last_fctl_chunk_start = pkt->data;
         uint8_t buf[26];
+        if (!s->extra_data_updated) {
+            uint8_t *side_data = av_packet_new_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, s->extra_data_size);
+            if (!side_data)
+                return AVERROR(ENOMEM);
+            memcpy(side_data, s->extra_data, s->extra_data_size);
+            s->extra_data_updated = 1;
+        }
 
         AV_WB32(buf + 0, s->last_frame_fctl.sequence_number);
         AV_WB32(buf + 4, s->last_frame_fctl.width);
@@ -1005,7 +1015,7 @@ FF_DISABLE_DEPRECATION_WARNINGS
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
 
-    ff_huffyuvencdsp_init(&s->hdsp);
+    ff_llvidencdsp_init(&s->llvidencdsp);
 
 #if FF_API_PRIVATE_OPT
 FF_DISABLE_DEPRECATION_WARNINGS
@@ -1093,6 +1103,8 @@ static av_cold int png_enc_close(AVCodecContext *avctx)
     av_frame_free(&s->last_frame);
     av_frame_free(&s->prev_frame);
     av_freep(&s->last_frame_packet);
+    av_freep(&s->extra_data);
+    s->extra_data_size = 0;
     return 0;
 }
 
@@ -1155,7 +1167,7 @@ AVCodec ff_apng_encoder = {
     .init           = png_enc_init,
     .close          = png_enc_close,
     .encode2        = encode_apng,
-    .capabilities   = CODEC_CAP_DELAY,
+    .capabilities   = AV_CODEC_CAP_DELAY,
     .pix_fmts       = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,
         AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE,
diff --git a/mythtv/external/FFmpeg/libavcodec/pnm.c b/mythtv/external/FFmpeg/libavcodec/pnm.c
index 1675959fbfa..b06a6e81b51 100644
--- a/mythtv/external/FFmpeg/libavcodec/pnm.c
+++ b/mythtv/external/FFmpeg/libavcodec/pnm.c
@@ -24,6 +24,7 @@
 
 #include "libavutil/imgutils.h"
 #include "avcodec.h"
+#include "internal.h"
 #include "pnm.h"
 
 static inline int pnm_space(int c)
@@ -61,6 +62,7 @@ int ff_pnm_decode_header(AVCodecContext *avctx, PNMContext * const s)
 {
     char buf1[32], tuple_type[32];
     int h, w, depth, maxval;
+    int ret;
 
     pnm_get(s, buf1, sizeof(buf1));
     if(buf1[0] != 'P')
@@ -107,11 +109,13 @@ int ff_pnm_decode_header(AVCodecContext *avctx, PNMContext * const s)
             }
         }
         /* check that all tags are present */
-        if (w <= 0 || h <= 0 || maxval <= 0 || depth <= 0 || tuple_type[0] == '\0' || av_image_check_size(w, h, 0, avctx) || s->bytestream >= s->bytestream_end)
+        if (w <= 0 || h <= 0 || maxval <= 0 || maxval > UINT16_MAX || depth <= 0 || tuple_type[0] == '\0' ||
+            av_image_check_size(w, h, 0, avctx) || s->bytestream >= s->bytestream_end)
             return AVERROR_INVALIDDATA;
 
-        avctx->width  = w;
-        avctx->height = h;
+        ret = ff_set_dimensions(avctx, w, h);
+        if (ret < 0)
+            return ret;
         s->maxval     = maxval;
         if (depth == 1) {
             if (maxval == 1) {
@@ -153,13 +157,14 @@ int ff_pnm_decode_header(AVCodecContext *avctx, PNMContext * const s)
     if(w <= 0 || h <= 0 || av_image_check_size(w, h, 0, avctx) || s->bytestream >= s->bytestream_end)
         return AVERROR_INVALIDDATA;
 
-    avctx->width  = w;
-    avctx->height = h;
+    ret = ff_set_dimensions(avctx, w, h);
+    if (ret < 0)
+        return ret;
 
     if (avctx->pix_fmt != AV_PIX_FMT_MONOWHITE && avctx->pix_fmt != AV_PIX_FMT_MONOBLACK) {
         pnm_get(s, buf1, sizeof(buf1));
         s->maxval = atoi(buf1);
-        if (s->maxval <= 0) {
+        if (s->maxval <= 0 || s->maxval > UINT16_MAX) {
             av_log(avctx, AV_LOG_ERROR, "Invalid maxval: %d\n", s->maxval);
             s->maxval = 255;
         }
diff --git a/mythtv/external/FFmpeg/libavcodec/pnm_parser.c b/mythtv/external/FFmpeg/libavcodec/pnm_parser.c
index 43dbfc7f27e..bdd7f2b5059 100644
--- a/mythtv/external/FFmpeg/libavcodec/pnm_parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/pnm_parser.c
@@ -56,15 +56,6 @@ static int pnm_parse(AVCodecParserContext *s, AVCodecContext *avctx,
             }
             goto retry;
         }
-#if 0
-        if (pc->index && pc->index * 2 + AV_INPUT_BUFFER_PADDING_SIZE < pc->buffer_size && buf_size > pc->index) {
-            memcpy(pc->buffer + pc->index, buf, pc->index);
-            pc->index += pc->index;
-            buf       += pc->index;
-            buf_size  -= pc->index;
-            goto retry;
-        }
-#endif
         next = END_NOT_FOUND;
     } else if (pnmctx.type < 4) {
         next = END_NOT_FOUND;
diff --git a/mythtv/external/FFmpeg/libavcodec/pnmdec.c b/mythtv/external/FFmpeg/libavcodec/pnmdec.c
index ca97cc38c3a..958c5e43b07 100644
--- a/mythtv/external/FFmpeg/libavcodec/pnmdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/pnmdec.c
@@ -43,7 +43,7 @@ static int pnm_decode_frame(AVCodecContext *avctx, void *data,
     int buf_size         = avpkt->size;
     PNMContext * const s = avctx->priv_data;
     AVFrame * const p    = data;
-    int i, j, n, linesize, h, upgrade = 0, is_mono = 0;
+    int i, j, k, n, linesize, h, upgrade = 0, is_mono = 0;
     unsigned char *ptr;
     int components, sample_len, ret;
 
@@ -143,10 +143,14 @@ static int pnm_decode_frame(AVCodecContext *avctx, void *data,
                         v = (*s->bytestream++)&1;
                     } else {
                         /* read a sequence of digits */
-                        do {
+                        for (k = 0; k < 5 && c <= 9; k += 1) {
                             v = 10*v + c;
                             c = (*s->bytestream++) - '0';
-                        } while (c <= 9);
+                        }
+                        if (v > s->maxval) {
+                            av_log(avctx, AV_LOG_ERROR, "value %d larger than maxval %d\n", v, s->maxval);
+                            return AVERROR_INVALIDDATA;
+                        }
                     }
                     if (sample_len == 16) {
                         ((uint16_t*)ptr)[j] = (((1<<sample_len)-1)*v + (s->maxval>>1))/s->maxval;
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/Makefile b/mythtv/external/FFmpeg/libavcodec/ppc/Makefile
index 56a13981b53..03e5b42d339 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/Makefile
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/Makefile
@@ -10,8 +10,8 @@ OBJS-$(CONFIG_H264CHROMA)              += ppc/h264chroma_init.o
 OBJS-$(CONFIG_H264DSP)                 += ppc/h264dsp.o ppc/hpeldsp_altivec.o
 OBJS-$(CONFIG_H264QPEL)                += ppc/h264qpel.o
 OBJS-$(CONFIG_HPELDSP)                 += ppc/hpeldsp_altivec.o
-OBJS-$(CONFIG_HUFFYUVDSP)              += ppc/huffyuvdsp_altivec.o
 OBJS-$(CONFIG_IDCTDSP)                 += ppc/idctdsp.o
+OBJS-$(CONFIG_LLVIDDSP)                += ppc/lossless_videodsp_altivec.o
 OBJS-$(CONFIG_ME_CMP)                  += ppc/me_cmp.o
 OBJS-$(CONFIG_MPEGAUDIODSP)            += ppc/mpegaudiodsp_altivec.o
 OBJS-$(CONFIG_MPEGVIDEO)               += ppc/mpegvideo_altivec.o      \
@@ -19,11 +19,12 @@ OBJS-$(CONFIG_MPEGVIDEO)               += ppc/mpegvideo_altivec.o      \
 OBJS-$(CONFIG_MPEGVIDEOENC)            += ppc/mpegvideoencdsp.o
 OBJS-$(CONFIG_PIXBLOCKDSP)             += ppc/pixblockdsp.o
 OBJS-$(CONFIG_VC1DSP)                  += ppc/vc1dsp_altivec.o
-OBJS-$(CONFIG_VIDEODSP)                += ppc/videodsp_ppc.o
+OBJS-$(CONFIG_VIDEODSP)                += ppc/videodsp.o
 OBJS-$(CONFIG_VP3DSP)                  += ppc/vp3dsp_altivec.o
 OBJS-$(CONFIG_VP8DSP)                  += ppc/vp8dsp_altivec.o
 
 # decoders/encoders
+OBJS-$(CONFIG_HEVC_DECODER)            += ppc/hevcdsp.o
 OBJS-$(CONFIG_LLAUDDSP)                += ppc/lossless_audiodsp_altivec.o
 OBJS-$(CONFIG_SVQ1_ENCODER)            += ppc/svq1enc_altivec.o
 OBJS-$(CONFIG_VORBIS_DECODER)          += ppc/vorbisdsp_altivec.o
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/audiodsp.c b/mythtv/external/FFmpeg/libavcodec/ppc/audiodsp.c
index c88c3d91671..2e374737bd6 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/audiodsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/audiodsp.c
@@ -24,15 +24,12 @@
  */
 
 #include "config.h"
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
 
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/audiodsp.h"
 
 #if HAVE_ALTIVEC
@@ -61,6 +58,31 @@ static int32_t scalarproduct_int16_altivec(const int16_t *v1, const int16_t *v2,
 
 #endif /* HAVE_ALTIVEC */
 
+#if HAVE_VSX
+
+static int32_t scalarproduct_int16_vsx(const int16_t *v1, const int16_t *v2, int order)
+{
+    int i;
+    LOAD_ZERO;
+    register vec_s16 vec1;
+    register vec_s32 res = vec_splat_s32(0), t;
+    int32_t ires;
+
+    for (i = 0; i < order; i += 8) {
+        vec1 = vec_vsx_ld(0, v1);
+        t    = vec_msum(vec1, vec_ld(0, v2), zero_s32v);
+        res  = vec_sums(t, res);
+        v1  += 8;
+        v2  += 8;
+    }
+    res = vec_splat(res, 3);
+    vec_ste(res, 0, &ires);
+
+    return ires;
+}
+
+#endif /* HAVE_VSX */
+
 av_cold void ff_audiodsp_init_ppc(AudioDSPContext *c)
 {
 #if HAVE_ALTIVEC
@@ -69,4 +91,11 @@ av_cold void ff_audiodsp_init_ppc(AudioDSPContext *c)
 
     c->scalarproduct_int16 = scalarproduct_int16_altivec;
 #endif /* HAVE_ALTIVEC */
+
+#if HAVE_VSX
+    if (!PPC_VSX(av_get_cpu_flags()))
+        return;
+
+    c->scalarproduct_int16 = scalarproduct_int16_vsx;
+#endif /* HAVE_VSX */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/blockdsp.c b/mythtv/external/FFmpeg/libavcodec/ppc/blockdsp.c
index 45c492ab3bc..d89b77e0883 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/blockdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/blockdsp.c
@@ -21,16 +21,15 @@
  */
 
 #include "config.h"
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
+
 #include <string.h>
 
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/mem.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
+#include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/blockdsp.h"
 
 /* ***** WARNING ***** WARNING ***** WARNING ***** */
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/fdctdsp.c b/mythtv/external/FFmpeg/libavcodec/ppc/fdctdsp.c
index 6659046f98b..4ab516c6b35 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/fdctdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/fdctdsp.c
@@ -19,14 +19,14 @@
  */
 
 #include "config.h"
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
 
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
+#include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/fdctdsp.h"
+
 #include "fdct.h"
 
 #if HAVE_ALTIVEC
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/fft_init.c b/mythtv/external/FFmpeg/libavcodec/ppc/fft_init.c
index cbeaf989520..57d7c80ea4c 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/fft_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/fft_init.c
@@ -23,7 +23,6 @@
 #include "config.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
 #include "libavcodec/fft.h"
 
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/fft_vsx.c b/mythtv/external/FFmpeg/libavcodec/ppc/fft_vsx.c
index e92975f74e2..c365fa1380c 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/fft_vsx.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/fft_vsx.c
@@ -25,7 +25,6 @@
 
 #include "config.h"
 #include "libavutil/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
 #include "libavcodec/fft.h"
 #include "libavcodec/fft-internal.h"
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/fft_vsx.h b/mythtv/external/FFmpeg/libavcodec/ppc/fft_vsx.h
index a85475d160b..1e44031aa5e 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/fft_vsx.h
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/fft_vsx.h
@@ -27,7 +27,6 @@
 
 #include "config.h"
 #include "libavutil/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
 #include "libavcodec/fft.h"
 #include "libavcodec/fft-internal.h"
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/h264chroma_init.c b/mythtv/external/FFmpeg/libavcodec/ppc/h264chroma_init.c
index 876efeca093..bd0d213bdc1 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/h264chroma_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/h264chroma_init.c
@@ -19,12 +19,13 @@
  */
 
 #include "config.h"
+
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/h264chroma.h"
 
 #if HAVE_ALTIVEC
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/h264chroma_template.c b/mythtv/external/FFmpeg/libavcodec/ppc/h264chroma_template.c
index cb1e0957e1a..8f43e5dee14 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/h264chroma_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/h264chroma_template.c
@@ -19,7 +19,6 @@
  */
 
 #include "libavutil/mem.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
 
 /* this code assume that stride % 16 == 0 */
@@ -111,7 +110,9 @@
 
 #ifdef PREFIX_h264_chroma_mc8_altivec
 static void PREFIX_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src,
-                                    int stride, int h, int x, int y) {
+                                           ptrdiff_t stride, int h,
+                                           int x, int y)
+{
     DECLARE_ALIGNED(16, signed int, ABCD)[4] =
                         {((8 - x) * (8 - y)),
                          ((    x) * (8 - y)),
@@ -183,7 +184,10 @@ static void PREFIX_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src,
 
 /* this code assume that stride % 16 == 0 */
 #ifdef PREFIX_no_rnd_vc1_chroma_mc8_altivec
-static void PREFIX_no_rnd_vc1_chroma_mc8_altivec(uint8_t * dst, uint8_t * src, int stride, int h, int x, int y) {
+static void PREFIX_no_rnd_vc1_chroma_mc8_altivec(uint8_t *dst, uint8_t *src,
+                                                 ptrdiff_t stride, int h,
+                                                 int x, int y)
+{
    DECLARE_ALIGNED(16, signed int, ABCD)[4] =
                         {((8 - x) * (8 - y)),
                          ((    x) * (8 - y)),
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/h264dsp.c b/mythtv/external/FFmpeg/libavcodec/ppc/h264dsp.c
index 22a8d4117bb..e84a058d04e 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/h264dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/h264dsp.c
@@ -28,7 +28,6 @@
 #include "libavutil/intreadwrite.h"
 #include "libavutil/mem.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
 
 #include "libavcodec/h264dec.h"
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/h264qpel.c b/mythtv/external/FFmpeg/libavcodec/ppc/h264qpel.c
index 575f504d325..bef421fa4f7 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/h264qpel.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/h264qpel.c
@@ -19,13 +19,15 @@
  */
 
 #include "config.h"
+
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/h264qpel.h"
+
 #include "hpeldsp_altivec.h"
 
 #if HAVE_ALTIVEC
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/h264qpel_template.c b/mythtv/external/FFmpeg/libavcodec/ppc/h264qpel_template.c
index 5ff72e32f03..304604c63da 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/h264qpel_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/h264qpel_template.c
@@ -25,7 +25,6 @@
 
 #include "libavutil/avassert.h"
 #include "libavutil/mem.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
 
 #define ASSERT_ALIGNED(ptr) av_assert2(!((uintptr_t)ptr&0x0000000F));
@@ -189,7 +188,7 @@ static void PREFIX_h264_qpel16_h_lowpass_altivec(uint8_t *dst,
         dst += dstStride;
     }
 }
-#endif
+#endif /* PREFIX_h264_qpel16_h_lowpass_altivec */
 
 /* this code assume stride % 16 == 0 */
 #ifdef PREFIX_h264_qpel16_v_lowpass_altivec
@@ -291,7 +290,7 @@ static void PREFIX_h264_qpel16_v_lowpass_altivec(uint8_t *dst,
         dst += dstStride;
     }
 }
-#endif
+#endif /* PREFIX_h264_qpel16_v_lowpass_altivec */
 
 /* this code assume stride % 16 == 0 *and* tmp is properly aligned */
 #ifdef PREFIX_h264_qpel16_hv_lowpass_altivec
@@ -481,4 +480,4 @@ static void PREFIX_h264_qpel16_hv_lowpass_altivec(uint8_t *dst, int16_t *tmp,
         dst += dstStride;
     }
 }
-#endif
+#endif /* PREFIX_h264_qpel16_hv_lowpass_altivec */
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/hevcdsp.c b/mythtv/external/FFmpeg/libavcodec/ppc/hevcdsp.c
new file mode 100644
index 00000000000..4b1037d792d
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/hevcdsp.c
@@ -0,0 +1,106 @@
+/*
+ * SIMD-optimized IDCT functions for HEVC decoding
+ * Copyright (c) Alexandra Hajkova
+ *
+ * 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/hevcdsp.h"
+
+#if HAVE_ALTIVEC
+static const vec_s16 trans4[4] = {
+    { 64,  64, 64,  64, 64,  64, 64,  64 },
+    { 83,  36, 83,  36, 83,  36, 83,  36 },
+    { 64, -64, 64, -64, 64, -64, 64, -64 },
+    { 36, -83, 36, -83, 36, -83, 36, -83 },
+};
+
+static const vec_u8 mask[2] = {
+    { 0x00, 0x01, 0x08, 0x09, 0x10, 0x11, 0x18, 0x19, 0x02, 0x03, 0x0A, 0x0B, 0x12, 0x13, 0x1A, 0x1B },
+    { 0x04, 0x05, 0x0C, 0x0D, 0x14, 0x15, 0x1C, 0x1D, 0x06, 0x07, 0x0E, 0x0F, 0x16, 0x17, 0x1E, 0x1F },
+};
+
+static void transform4x4(vec_s16 src_01, vec_s16 src_23, vec_s32 res[4],
+                         const int shift, int16_t *coeffs)
+{
+    vec_s16 src_02, src_13;
+    vec_s32 zero = vec_splat_s32(0);
+    vec_s32 e0, o0, e1, o1;
+    vec_s32 add;
+
+    src_13 = vec_mergel(src_01, src_23);
+    src_02 = vec_mergeh(src_01, src_23);
+
+    e0 = vec_msums(src_02, trans4[0], zero);
+    o0 = vec_msums(src_13, trans4[1], zero);
+    e1 = vec_msums(src_02, trans4[2], zero);
+    o1 = vec_msums(src_13, trans4[3], zero);
+
+    add = vec_sl(vec_splat_s32(1), vec_splat_u32(shift - 1));
+    e0 = vec_add(e0, add);
+    e1 = vec_add(e1, add);
+
+    res[0] = vec_add(e0, o0);
+    res[1] = vec_add(e1, o1);
+    res[2] = vec_sub(e1, o1);
+    res[3] = vec_sub(e0, o0);
+}
+
+static void scale(vec_s32 res[4], vec_s16 res_packed[2], int shift)
+{
+    int i;
+    vec_u32 v_shift = vec_splat_u32(shift);
+
+    for (i = 0; i < 4; i++)
+        res[i] = vec_sra(res[i], v_shift);
+
+    // clip16
+    res_packed[0] = vec_packs(res[0], res[1]);
+    res_packed[1] = vec_packs(res[2], res[3]);
+}
+
+#define FUNCDECL(a, depth) a ## _ ## depth ## _altivec
+#define FUNC(a, b) FUNCDECL(a, b)
+
+#define BIT_DEPTH 8
+#include "hevcdsp_template.c"
+#undef BIT_DEPTH
+
+#define BIT_DEPTH 10
+#include "hevcdsp_template.c"
+#undef BIT_DEPTH
+#endif /* HAVE_ALTIVEC */
+
+av_cold void ff_hevc_dsp_init_ppc(HEVCDSPContext *c, const int bit_depth)
+{
+#if HAVE_ALTIVEC
+    if (!PPC_ALTIVEC(av_get_cpu_flags()))
+        return;
+
+    if (bit_depth == 8)
+        c->idct[0] = ff_hevc_idct_4x4_8_altivec;
+    if (bit_depth == 10)
+        c->idct[0] = ff_hevc_idct_4x4_10_altivec;
+#endif /* HAVE_ALTIVEC */
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/hevcdsp_template.c b/mythtv/external/FFmpeg/libavcodec/ppc/hevcdsp_template.c
new file mode 100644
index 00000000000..2b6411bae8e
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/hevcdsp_template.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Alexandra Hajkova
+ *
+ * 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
+ */
+
+static void FUNC(ff_hevc_idct_4x4, BIT_DEPTH)(int16_t *coeffs, int col_limit)
+{
+    const int shift = 7;
+    const int shift2 = 20 - BIT_DEPTH;
+    vec_s16 src_01, src_23;
+    vec_s32 res[4];
+    vec_s16 res_packed[2];
+
+    src_01 = vec_ld(0, coeffs);
+    src_23 = vec_ld(16, coeffs);
+
+    transform4x4(src_01, src_23, res, shift, coeffs);
+    src_01 = vec_packs(res[0], res[1]);
+    src_23 = vec_packs(res[2], res[3]);
+    scale(res, res_packed, shift);
+    // transpose
+    src_01 = vec_perm(res_packed[0], res_packed[1], mask[0]);
+    src_23 = vec_perm(res_packed[0], res_packed[1], mask[1]);
+
+    transform4x4(src_01, src_23, res, shift2, coeffs);
+    scale(res, res_packed, shift2);
+    // transpose
+    src_01 = vec_perm(res_packed[0], res_packed[1], mask[0]);
+    src_23 = vec_perm(res_packed[0], res_packed[1], mask[1]);
+
+    vec_st(src_01, 0, coeffs);
+    vec_st(src_23, 16, coeffs);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/hpeldsp_altivec.c b/mythtv/external/FFmpeg/libavcodec/ppc/hpeldsp_altivec.c
index 87a1f05b6a8..4f195218603 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/hpeldsp_altivec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/hpeldsp_altivec.c
@@ -22,16 +22,13 @@
 
 #include "config.h"
 
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
-
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/hpeldsp.h"
+
 #include "hpeldsp_altivec.h"
 
 #if HAVE_ALTIVEC
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/idctdsp.c b/mythtv/external/FFmpeg/libavcodec/ppc/idctdsp.c
index 80e71fdaf0e..29f625a01c7 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/idctdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/idctdsp.c
@@ -30,17 +30,16 @@
  * IDCT function itself was to factor out the partial transposition, and to
  * perform a full transpose at the end of the function. */
 
+#include "config.h"
+
 #include <stdlib.h>
 #include <string.h>
-#include "config.h"
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
 
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
+#include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/idctdsp.h"
 
 #if HAVE_ALTIVEC
@@ -169,7 +168,7 @@ static void idct_altivec(int16_t *blk)
     block[7] = vx7;
 }
 
-static void idct_put_altivec(uint8_t *dest, int stride, int16_t *blk)
+static void idct_put_altivec(uint8_t *dest, ptrdiff_t stride, int16_t *blk)
 {
     vec_s16 *block = (vec_s16 *) blk;
     vec_u8 tmp;
@@ -198,7 +197,7 @@ static void idct_put_altivec(uint8_t *dest, int stride, int16_t *blk)
     COPY(dest, vx7);
 }
 
-static void idct_add_altivec(uint8_t *dest, int stride, int16_t *blk)
+static void idct_add_altivec(uint8_t *dest, ptrdiff_t stride, int16_t *blk)
 {
     vec_s16 *block = (vec_s16 *) blk;
     vec_u8 tmp;
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/lossless_audiodsp_altivec.c b/mythtv/external/FFmpeg/libavcodec/ppc/lossless_audiodsp_altivec.c
index bdec25223df..298e6c38a00 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/lossless_audiodsp_altivec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/lossless_audiodsp_altivec.c
@@ -19,14 +19,12 @@
  */
 
 #include "config.h"
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
 
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
+#include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/lossless_audiodsp.h"
 
 #if HAVE_BIGENDIAN
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/huffyuvdsp_altivec.c b/mythtv/external/FFmpeg/libavcodec/ppc/lossless_videodsp_altivec.c
similarity index 87%
rename from mythtv/external/FFmpeg/libavcodec/ppc/huffyuvdsp_altivec.c
rename to mythtv/external/FFmpeg/libavcodec/ppc/lossless_videodsp_altivec.c
index 6701524e4a4..980f85b166c 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/huffyuvdsp_altivec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/lossless_videodsp_altivec.c
@@ -21,19 +21,16 @@
  */
 
 #include "config.h"
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
 
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
-#include "libavcodec/huffyuvdsp.h"
+
+#include "libavcodec/lossless_videodsp.h"
 
 #if HAVE_ALTIVEC
-static void add_bytes_altivec(uint8_t *dst, uint8_t *src, intptr_t w)
+static void add_bytes_altivec(uint8_t *dst, uint8_t *src, ptrdiff_t w)
 {
     register int i;
     register vector unsigned char vdst, vsrc;
@@ -51,7 +48,7 @@ static void add_bytes_altivec(uint8_t *dst, uint8_t *src, intptr_t w)
 }
 #endif /* HAVE_ALTIVEC */
 
-av_cold void ff_huffyuvdsp_init_ppc(HuffYUVDSPContext *c)
+av_cold void ff_llviddsp_init_ppc(LLVidDSPContext *c)
 {
 #if HAVE_ALTIVEC
     if (!PPC_ALTIVEC(av_get_cpu_flags()))
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/me_cmp.c b/mythtv/external/FFmpeg/libavcodec/ppc/me_cmp.c
index 9f75ed256aa..17f9a4f0166 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/me_cmp.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/me_cmp.c
@@ -21,15 +21,12 @@
  */
 
 #include "config.h"
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
 
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/avcodec.h"
 #include "libavcodec/mpegvideo.h"
 #include "libavcodec/me_cmp.h"
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/mpegaudiodsp_altivec.c b/mythtv/external/FFmpeg/libavcodec/ppc/mpegaudiodsp_altivec.c
index ddfe5dcbb70..efa9fd5fed3 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/mpegaudiodsp_altivec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/mpegaudiodsp_altivec.c
@@ -90,7 +90,7 @@ static void apply_window(const float *buf, const float *win1,
 }
 
 static void apply_window_mp3(float *in, float *win, int *unused, float *out,
-                             int incr)
+                             ptrdiff_t incr)
 {
     LOCAL_ALIGNED_16(float, suma, [17]);
     LOCAL_ALIGNED_16(float, sumb, [17]);
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideo_altivec.c b/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideo_altivec.c
index 1b6bda6c36c..2c6ff9165b2 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideo_altivec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideo_altivec.c
@@ -25,11 +25,12 @@
 #include <stdio.h>
 
 #include "config.h"
+
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/mpegvideo.h"
 
 #if HAVE_ALTIVEC
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideodsp.c b/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideodsp.c
index 76969543354..990a974a4e3 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideodsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideodsp.c
@@ -20,9 +20,11 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/cpu.h"
 #include "libavutil/mem.h"
-#include "libavutil/ppc/types_altivec.h"
+#include "libavutil/ppc/cpu.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/mpegvideodsp.h"
 
 #if HAVE_ALTIVEC
@@ -128,6 +130,9 @@ static void gmc1_altivec(uint8_t *dst /* align 8 */, uint8_t *src /* align1 */,
 av_cold void ff_mpegvideodsp_init_ppc(MpegVideoDSPContext *c)
 {
 #if HAVE_ALTIVEC
+    if (!PPC_ALTIVEC(av_get_cpu_flags()))
+        return;
+
     c->gmc1 = gmc1_altivec;
 #endif /* HAVE_ALTIVEC */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideoencdsp.c b/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideoencdsp.c
index 3e6765ce155..b96487bf81e 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideoencdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/mpegvideoencdsp.c
@@ -17,16 +17,14 @@
  */
 
 #include "config.h"
+
 #include <stdint.h>
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
 
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/mpegvideoencdsp.h"
 
 #if HAVE_ALTIVEC
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/pixblockdsp.c b/mythtv/external/FFmpeg/libavcodec/ppc/pixblockdsp.c
index 84aa562bb67..01d14b41241 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/pixblockdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/pixblockdsp.c
@@ -21,15 +21,12 @@
  */
 
 #include "config.h"
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
 
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/avcodec.h"
 #include "libavcodec/pixblockdsp.h"
 
@@ -37,7 +34,7 @@
 
 #if HAVE_VSX
 static void get_pixels_altivec(int16_t *restrict block, const uint8_t *pixels,
-                               ptrdiff_t line_size)
+                               ptrdiff_t stride)
 {
     int i;
     vector unsigned char perm =
@@ -59,18 +56,18 @@ static void get_pixels_altivec(int16_t *restrict block, const uint8_t *pixels,
         // Save the data to the block, we assume the block is 16-byte aligned.
         vec_vsx_st(shorts, i * 16, (vector signed short *) block);
 
-        pixels += line_size;
+        pixels += stride;
     }
 }
 #else
 static void get_pixels_altivec(int16_t *restrict block, const uint8_t *pixels,
-                               ptrdiff_t line_size)
+                               ptrdiff_t stride)
 {
     int i;
-    vec_u8 perm = vec_lvsl(0, pixels);
     const vec_u8 zero = (const vec_u8)vec_splat_u8(0);
 
     for (i = 0; i < 8; i++) {
+        vec_u8 perm = vec_lvsl(0, pixels);
         /* Read potentially unaligned pixels.
          * We're reading 16 pixels, and actually only want 8,
          * but we simply ignore the extras. */
@@ -84,7 +81,7 @@ static void get_pixels_altivec(int16_t *restrict block, const uint8_t *pixels,
         // Save the data to the block, we assume the block is 16-byte aligned.
         vec_st(shorts, i * 16, (vec_s16 *)block);
 
-        pixels += line_size;
+        pixels += stride;
     }
 }
 
@@ -92,7 +89,7 @@ static void get_pixels_altivec(int16_t *restrict block, const uint8_t *pixels,
 
 #if HAVE_VSX
 static void diff_pixels_altivec(int16_t *restrict block, const uint8_t *s1,
-                                const uint8_t *s2, int stride)
+                                const uint8_t *s2, ptrdiff_t stride)
 {
   int i;
   const vector unsigned char zero =
@@ -154,11 +151,10 @@ static void diff_pixels_altivec(int16_t *restrict block, const uint8_t *s1,
 }
 #else
 static void diff_pixels_altivec(int16_t *restrict block, const uint8_t *s1,
-                                const uint8_t *s2, int stride)
+                                const uint8_t *s2, ptrdiff_t stride)
 {
     int i;
-    vec_u8 perm1 = vec_lvsl(0, s1);
-    vec_u8 perm2 = vec_lvsl(0, s2);
+    vec_u8 perm;
     const vec_u8 zero = (const vec_u8)vec_splat_u8(0);
     vec_s16 shorts1, shorts2;
 
@@ -166,17 +162,19 @@ static void diff_pixels_altivec(int16_t *restrict block, const uint8_t *s1,
         /* Read potentially unaligned pixels.
          * We're reading 16 pixels, and actually only want 8,
          * but we simply ignore the extras. */
+        perm = vec_lvsl(0, s1);
         vec_u8 pixl  = vec_ld(0,  s1);
         vec_u8 pixr  = vec_ld(15, s1);
-        vec_u8 bytes = vec_perm(pixl, pixr, perm1);
+        vec_u8 bytes = vec_perm(pixl, pixr, perm);
 
         // Convert the bytes into shorts.
         shorts1 = (vec_s16)vec_mergeh(zero, bytes);
 
         // Do the same for the second block of pixels.
+        perm = vec_lvsl(0, s2);
         pixl  = vec_ld(0,  s2);
         pixr  = vec_ld(15, s2);
-        bytes = vec_perm(pixl, pixr, perm2);
+        bytes = vec_perm(pixl, pixr, perm);
 
         // Convert the bytes into shorts.
         shorts2 = (vec_s16)vec_mergeh(zero, bytes);
@@ -197,17 +195,19 @@ static void diff_pixels_altivec(int16_t *restrict block, const uint8_t *s1,
         /* Read potentially unaligned pixels.
          * We're reading 16 pixels, and actually only want 8,
          * but we simply ignore the extras. */
+        perm = vec_lvsl(0, s1);
         pixl  = vec_ld(0,  s1);
         pixr  = vec_ld(15, s1);
-        bytes = vec_perm(pixl, pixr, perm1);
+        bytes = vec_perm(pixl, pixr, perm);
 
         // Convert the bytes into shorts.
         shorts1 = (vec_s16)vec_mergeh(zero, bytes);
 
         // Do the same for the second block of pixels.
+        perm = vec_lvsl(0, s2);
         pixl  = vec_ld(0,  s2);
         pixr  = vec_ld(15, s2);
-        bytes = vec_perm(pixl, pixr, perm2);
+        bytes = vec_perm(pixl, pixr, perm);
 
         // Convert the bytes into shorts.
         shorts2 = (vec_s16)vec_mergeh(zero, bytes);
@@ -230,7 +230,7 @@ static void diff_pixels_altivec(int16_t *restrict block, const uint8_t *s1,
 
 #if HAVE_VSX
 static void get_pixels_vsx(int16_t *restrict block, const uint8_t *pixels,
-                           ptrdiff_t line_size)
+                           ptrdiff_t stride)
 {
     int i;
     for (i = 0; i < 8; i++) {
@@ -238,12 +238,12 @@ static void get_pixels_vsx(int16_t *restrict block, const uint8_t *pixels,
 
         vec_vsx_st(shorts, i * 16, block);
 
-        pixels += line_size;
+        pixels += stride;
     }
 }
 
 static void diff_pixels_vsx(int16_t *restrict block, const uint8_t *s1,
-                            const uint8_t *s2, int stride)
+                            const uint8_t *s2, ptrdiff_t stride)
 {
     int i;
     vec_s16 shorts1, shorts2;
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/svq1enc_altivec.c b/mythtv/external/FFmpeg/libavcodec/ppc/svq1enc_altivec.c
index 4e25e253f62..f63f0866024 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/svq1enc_altivec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/svq1enc_altivec.c
@@ -18,18 +18,15 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include <stdint.h>
-
 #include "config.h"
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
+
+#include <stdint.h>
 
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/svq1enc.h"
 
 #if HAVE_ALTIVEC
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/vc1dsp_altivec.c b/mythtv/external/FFmpeg/libavcodec/ppc/vc1dsp_altivec.c
index 35bb280842d..bbadb2aaeef 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/vc1dsp_altivec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/vc1dsp_altivec.c
@@ -20,11 +20,12 @@
  */
 
 #include "config.h"
+
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/vc1dsp.h"
 
 #if HAVE_ALTIVEC
@@ -229,7 +230,8 @@ static void vc1_inv_trans_8x8_altivec(int16_t block[64])
 
 /** Do inverse transform on 8x4 part of block
 */
-static void vc1_inv_trans_8x4_altivec(uint8_t *dest, int stride, int16_t *block)
+static void vc1_inv_trans_8x4_altivec(uint8_t *dest, ptrdiff_t stride,
+                                      int16_t *block)
 {
     vector signed short src0, src1, src2, src3, src4, src5, src6, src7;
     vector signed int s0, s1, s2, s3, s4, s5, s6, s7;
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/videodsp_ppc.c b/mythtv/external/FFmpeg/libavcodec/ppc/videodsp.c
similarity index 100%
rename from mythtv/external/FFmpeg/libavcodec/ppc/videodsp_ppc.c
rename to mythtv/external/FFmpeg/libavcodec/ppc/videodsp.c
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/vorbisdsp_altivec.c b/mythtv/external/FFmpeg/libavcodec/ppc/vorbisdsp_altivec.c
index d7557c815b8..4dabf2dc7d5 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/vorbisdsp_altivec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/vorbisdsp_altivec.c
@@ -19,12 +19,12 @@
  */
 
 #include "config.h"
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
+
 #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
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/vp3dsp_altivec.c b/mythtv/external/FFmpeg/libavcodec/ppc/vp3dsp_altivec.c
index 4a367b655eb..a9a48d145bd 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/vp3dsp_altivec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/vp3dsp_altivec.c
@@ -21,11 +21,12 @@
 #include <string.h>
 
 #include "config.h"
+
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/vp3dsp.h"
 
 #if HAVE_ALTIVEC
@@ -119,7 +120,7 @@ static inline vec_s16 M16(vec_s16 a, vec_s16 C)
 #define ADD8(a) vec_add(a, eight)
 #define SHIFT4(a) vec_sra(a, four)
 
-static void vp3_idct_put_altivec(uint8_t *dst, int stride, int16_t block[64])
+static void vp3_idct_put_altivec(uint8_t *dst, ptrdiff_t stride, int16_t block[64])
 {
     vec_u8 t;
     IDCT_START
@@ -148,7 +149,7 @@ static void vp3_idct_put_altivec(uint8_t *dst, int stride, int16_t block[64])
     memset(block, 0, sizeof(*block) * 64);
 }
 
-static void vp3_idct_add_altivec(uint8_t *dst, int stride, int16_t block[64])
+static void vp3_idct_add_altivec(uint8_t *dst, ptrdiff_t stride, int16_t block[64])
 {
     LOAD_ZERO;
     vec_u8 t, vdst;
diff --git a/mythtv/external/FFmpeg/libavcodec/ppc/vp8dsp_altivec.c b/mythtv/external/FFmpeg/libavcodec/ppc/vp8dsp_altivec.c
index 23e4ace7da5..31201ed2d85 100644
--- a/mythtv/external/FFmpeg/libavcodec/ppc/vp8dsp_altivec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ppc/vp8dsp_altivec.c
@@ -21,12 +21,14 @@
  */
 
 #include "config.h"
+
 #include "libavutil/cpu.h"
 #include "libavutil/mem.h"
 #include "libavutil/ppc/cpu.h"
-#include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
+
 #include "libavcodec/vp8dsp.h"
+
 #include "hpeldsp_altivec.h"
 
 #if HAVE_ALTIVEC
diff --git a/mythtv/external/FFmpeg/libavcodec/proresdec2.c b/mythtv/external/FFmpeg/libavcodec/proresdec2.c
index a3a1ebdecb9..2ebda78a7a9 100644
--- a/mythtv/external/FFmpeg/libavcodec/proresdec2.c
+++ b/mythtv/external/FFmpeg/libavcodec/proresdec2.c
@@ -250,7 +250,7 @@ static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, cons
     return pic_data_size;
 }
 
-#define DECODE_CODEWORD(val, codebook)                                  \
+#define DECODE_CODEWORD(val, codebook, SKIP)                            \
     do {                                                                \
         unsigned int rice_order, exp_order, switch_bits;                \
         unsigned int q, buf, bits;                                      \
@@ -267,16 +267,18 @@ static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, cons
                                                                         \
         if (q > switch_bits) { /* exp golomb */                         \
             bits = exp_order - switch_bits + (q<<1);                    \
+            if (bits > FFMIN(MIN_CACHE_BITS, 31))                       \
+                return AVERROR_INVALIDDATA;                             \
             val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) +         \
                 ((switch_bits + 1) << rice_order);                      \
-            SKIP_BITS(re, gb, bits);                                    \
+            SKIP(re, gb, bits);                                         \
         } else if (rice_order) {                                        \
             SKIP_BITS(re, gb, q+1);                                     \
             val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order);   \
-            SKIP_BITS(re, gb, rice_order);                              \
+            SKIP(re, gb, rice_order);                                   \
         } else {                                                        \
             val = q;                                                    \
-            SKIP_BITS(re, gb, q+1);                                     \
+            SKIP(re, gb, q+1);                                          \
         }                                                               \
     } while (0)
 
@@ -286,7 +288,7 @@ static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, cons
 
 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
 
-static av_always_inline void decode_dc_coeffs(GetBitContext *gb, int16_t *out,
+static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out,
                                               int blocks_per_slice)
 {
     int16_t prev_dc;
@@ -294,7 +296,7 @@ static av_always_inline void decode_dc_coeffs(GetBitContext *gb, int16_t *out,
 
     OPEN_READER(re, gb);
 
-    DECODE_CODEWORD(code, FIRST_DC_CB);
+    DECODE_CODEWORD(code, FIRST_DC_CB, LAST_SKIP_BITS);
     prev_dc = TOSIGNED(code);
     out[0] = prev_dc;
 
@@ -303,13 +305,14 @@ static av_always_inline void decode_dc_coeffs(GetBitContext *gb, int16_t *out,
     code = 5;
     sign = 0;
     for (i = 1; i < blocks_per_slice; i++, out += 64) {
-        DECODE_CODEWORD(code, dc_codebook[FFMIN(code, 6U)]);
+        DECODE_CODEWORD(code, dc_codebook[FFMIN(code, 6U)], LAST_SKIP_BITS);
         if(code) sign ^= -(code & 1);
         else     sign  = 0;
         prev_dc += (((code + 1) >> 1) ^ sign) - sign;
         out[0] = prev_dc;
     }
     CLOSE_READER(re, gb);
+    return 0;
 }
 
 // adaptive codebook switching lut according to previous run/level values
@@ -338,14 +341,14 @@ static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContex
         if (!bits_left || (bits_left < 32 && !SHOW_UBITS(re, gb, bits_left)))
             break;
 
-        DECODE_CODEWORD(run, run_to_cb[FFMIN(run,  15)]);
+        DECODE_CODEWORD(run, run_to_cb[FFMIN(run,  15)], LAST_SKIP_BITS);
         pos += run + 1;
         if (pos >= max_coeffs) {
             av_log(avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", pos, max_coeffs);
             return AVERROR_INVALIDDATA;
         }
 
-        DECODE_CODEWORD(level, lev_to_cb[FFMIN(level, 9)]);
+        DECODE_CODEWORD(level, lev_to_cb[FFMIN(level, 9)], SKIP_BITS);
         level += 1;
 
         i = pos >> log2_block_count;
@@ -365,7 +368,7 @@ static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice,
                              const int16_t *qmat)
 {
     ProresContext *ctx = avctx->priv_data;
-    LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
+    LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
     int16_t *block;
     GetBitContext gb;
     int i, blocks_per_slice = slice->mb_count<<2;
@@ -376,7 +379,8 @@ static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice,
 
     init_get_bits(&gb, buf, buf_size << 3);
 
-    decode_dc_coeffs(&gb, blocks, blocks_per_slice);
+    if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)
+        return ret;
     if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
         return ret;
 
@@ -398,7 +402,7 @@ static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice,
                                const int16_t *qmat, int log2_blocks_per_mb)
 {
     ProresContext *ctx = avctx->priv_data;
-    LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
+    LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
     int16_t *block;
     GetBitContext gb;
     int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb;
@@ -409,7 +413,8 @@ static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice,
 
     init_get_bits(&gb, buf, buf_size << 3);
 
-    decode_dc_coeffs(&gb, blocks, blocks_per_slice);
+    if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)
+        return ret;
     if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
         return ret;
 
@@ -480,7 +485,7 @@ static void decode_slice_alpha(ProresContext *ctx,
 {
     GetBitContext gb;
     int i;
-    LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
+    LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);
     int16_t *block;
 
     for (i = 0; i < blocks_per_slice<<2; i++)
@@ -512,8 +517,8 @@ static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int
     int luma_stride, chroma_stride;
     int y_data_size, u_data_size, v_data_size, a_data_size;
     uint8_t *dest_y, *dest_u, *dest_v, *dest_a;
-    int16_t qmat_luma_scaled[64];
-    int16_t qmat_chroma_scaled[64];
+    LOCAL_ALIGNED_16(int16_t, qmat_luma_scaled,  [64]);
+    LOCAL_ALIGNED_16(int16_t, qmat_chroma_scaled,[64]);
     int mb_x_shift;
     int ret;
 
@@ -614,14 +619,19 @@ static int decode_picture(AVCodecContext *avctx)
 {
     ProresContext *ctx = avctx->priv_data;
     int i;
+    int error = 0;
 
     avctx->execute2(avctx, decode_slice_thread, NULL, NULL, ctx->slice_count);
 
     for (i = 0; i < ctx->slice_count; i++)
-        if (ctx->slices[i].ret < 0)
-            return ctx->slices[i].ret;
+        error += ctx->slices[i].ret < 0;
 
-    return 0;
+    if (error)
+        ctx->frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
+    if (error < ctx->slice_count)
+        return 0;
+
+    return ctx->slices[0].ret;
 }
 
 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
diff --git a/mythtv/external/FFmpeg/libavcodec/proresdec_lgpl.c b/mythtv/external/FFmpeg/libavcodec/proresdec_lgpl.c
index 467a423f232..bc5bdb5a4d5 100644
--- a/mythtv/external/FFmpeg/libavcodec/proresdec_lgpl.c
+++ b/mythtv/external/FFmpeg/libavcodec/proresdec_lgpl.c
@@ -625,7 +625,7 @@ static int decode_slice(AVCodecContext *avctx, void *tdata)
 
     /* if V or alpha component size is negative that means that previous
        component sizes are too large */
-    if (v_data_size < 0 || a_data_size < 0 || hdr_size < 6) {
+    if (v_data_size < 0 || a_data_size < 0 || hdr_size < 6 || coff[3] > slice_data_size) {
         av_log(avctx, AV_LOG_ERROR, "invalid data size\n");
         return AVERROR_INVALIDDATA;
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/proresdsp.c b/mythtv/external/FFmpeg/libavcodec/proresdsp.c
index 82d6009b583..5b5ada21fe0 100644
--- a/mythtv/external/FFmpeg/libavcodec/proresdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/proresdsp.c
@@ -36,11 +36,11 @@
 /**
  * Add bias value, clamp and output pixels of a slice
  */
-static void put_pixels(uint16_t *dst, int stride, const int16_t *in)
+static void put_pixels(uint16_t *dst, ptrdiff_t linesize, const int16_t *in)
 {
     int x, y, src_offset, dst_offset;
 
-    for (y = 0, dst_offset = 0; y < 8; y++, dst_offset += stride) {
+    for (y = 0, dst_offset = 0; y < 8; y++, dst_offset += linesize) {
         for (x = 0; x < 8; x++) {
             src_offset = (y << 3) + x;
 
@@ -49,7 +49,7 @@ static void put_pixels(uint16_t *dst, int stride, const int16_t *in)
     }
 }
 
-static void prores_idct_put_c(uint16_t *out, int linesize, int16_t *block, const int16_t *qmat)
+static void prores_idct_put_c(uint16_t *out, ptrdiff_t linesize, int16_t *block, const int16_t *qmat)
 {
     ff_prores_idct(block, qmat);
     put_pixels(out, linesize >> 1, block);
diff --git a/mythtv/external/FFmpeg/libavcodec/proresdsp.h b/mythtv/external/FFmpeg/libavcodec/proresdsp.h
index 159862ec3da..558fae53bf1 100644
--- a/mythtv/external/FFmpeg/libavcodec/proresdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/proresdsp.h
@@ -23,6 +23,7 @@
 #ifndef AVCODEC_PRORESDSP_H
 #define AVCODEC_PRORESDSP_H
 
+#include <stddef.h>
 #include <stdint.h>
 #include "avcodec.h"
 
@@ -31,7 +32,7 @@
 typedef struct ProresDSPContext {
     int idct_permutation_type;
     uint8_t idct_permutation[64];
-    void (* idct_put) (uint16_t *out, int linesize, int16_t *block, const int16_t *qmat);
+    void (*idct_put)(uint16_t *out, ptrdiff_t linesize, int16_t *block, const int16_t *qmat);
 } ProresDSPContext;
 
 void ff_proresdsp_init(ProresDSPContext *dsp, AVCodecContext *avctx);
diff --git a/mythtv/external/FFmpeg/libavcodec/proresenc_kostya.c b/mythtv/external/FFmpeg/libavcodec/proresenc_kostya.c
index 3bc1d5d7722..149dc81b3c7 100644
--- a/mythtv/external/FFmpeg/libavcodec/proresenc_kostya.c
+++ b/mythtv/external/FFmpeg/libavcodec/proresenc_kostya.c
@@ -46,6 +46,7 @@ enum {
     PRORES_PROFILE_STANDARD,
     PRORES_PROFILE_HQ,
     PRORES_PROFILE_4444,
+    PRORES_PROFILE_4444XQ,
 };
 
 enum {
@@ -124,7 +125,7 @@ static const struct prores_profile {
     int         max_quant;
     int         br_tab[NUM_MB_LIMITS];
     int         quant;
-} prores_profile_info[5] = {
+} prores_profile_info[6] = {
     {
         .full_name = "proxy",
         .tag       = MKTAG('a', 'p', 'c', 'o'),
@@ -164,6 +165,14 @@ static const struct prores_profile {
         .max_quant = 6,
         .br_tab    = { 2350, 1828, 1600, 1425 },
         .quant     = QUANT_MAT_HQ,
+    },
+    {
+        .full_name = "4444XQ",
+        .tag       = MKTAG('a', 'p', '4', 'x'),
+        .min_quant = 1,
+        .max_quant = 6,
+        .br_tab    = { 3525, 2742, 2400, 2137 },
+        .quant     = QUANT_MAT_HQ,
     }
 };
 
@@ -196,7 +205,7 @@ typedef struct ProresContext {
     const uint8_t *scantable;
 
     void (*fdct)(FDCTDSPContext *fdsp, const uint16_t *src,
-                 int linesize, int16_t *block);
+                 ptrdiff_t linesize, int16_t *block);
     FDCTDSPContext fdsp;
 
     const AVFrame *pic;
@@ -227,13 +236,13 @@ typedef struct ProresContext {
 } ProresContext;
 
 static void get_slice_data(ProresContext *ctx, const uint16_t *src,
-                           int linesize, int x, int y, int w, int h,
+                           ptrdiff_t linesize, int x, int y, int w, int h,
                            int16_t *blocks, uint16_t *emu_buf,
                            int mbs_per_slice, int blocks_per_mb, int is_chroma)
 {
     const uint16_t *esrc;
     const int mb_width = 4 * blocks_per_mb;
-    int elinesize;
+    ptrdiff_t elinesize;
     int i, j, k;
 
     for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
@@ -298,7 +307,7 @@ static void get_slice_data(ProresContext *ctx, const uint16_t *src,
 }
 
 static void get_alpha_data(ProresContext *ctx, const uint16_t *src,
-                           int linesize, int x, int y, int w, int h,
+                           ptrdiff_t linesize, int x, int y, int w, int h,
                            int16_t *blocks, int mbs_per_slice, int abits)
 {
     const int slice_width = 16 * mbs_per_slice;
@@ -358,7 +367,7 @@ static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int
 }
 
 #define GET_SIGN(x)  ((x) >> 31)
-#define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))
+#define MAKE_CODE(x) ((((x)) * 2) ^ GET_SIGN(x))
 
 static void encode_dcs(PutBitContext *pb, int16_t *blocks,
                        int blocks_per_slice, int scale)
@@ -421,7 +430,7 @@ static void encode_acs(PutBitContext *pb, int16_t *blocks,
 }
 
 static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb,
-                              const uint16_t *src, int linesize,
+                              const uint16_t *src, ptrdiff_t linesize,
                               int mbs_per_slice, int16_t *blocks,
                               int blocks_per_mb, int plane_size_factor,
                               const int16_t *qmat)
@@ -514,7 +523,8 @@ static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
     int total_size = 0;
     const uint16_t *src;
     int slice_width_factor = av_log2(mbs_per_slice);
-    int num_cblocks, pwidth, linesize, line_add;
+    int num_cblocks, pwidth, line_add;
+    ptrdiff_t linesize;
     int plane_factor, is_chroma;
     uint16_t *qmat;
 
@@ -670,7 +680,7 @@ static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
 }
 
 static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
-                                const uint16_t *src, int linesize,
+                                const uint16_t *src, ptrdiff_t linesize,
                                 int mbs_per_slice,
                                 int blocks_per_mb, int plane_size_factor,
                                 const int16_t *qmat, ProresThreadData *td)
@@ -703,7 +713,7 @@ static int est_alpha_diff(int cur, int prev, int abits)
 }
 
 static int estimate_alpha_plane(ProresContext *ctx, int *error,
-                                const uint16_t *src, int linesize,
+                                const uint16_t *src, ptrdiff_t linesize,
                                 int mbs_per_slice, int quant,
                                 int16_t *blocks)
 {
@@ -968,9 +978,9 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     bytestream_put_byte  (&buf, frame_flags);
 
     bytestream_put_byte  (&buf, 0);             // reserved
-    bytestream_put_byte  (&buf, avctx->color_primaries);
-    bytestream_put_byte  (&buf, avctx->color_trc);
-    bytestream_put_byte  (&buf, avctx->colorspace);
+    bytestream_put_byte  (&buf, pic->color_primaries);
+    bytestream_put_byte  (&buf, pic->color_trc);
+    bytestream_put_byte  (&buf, pic->colorspace);
     bytestream_put_byte  (&buf, 0x40 | (ctx->alpha_bits >> 3));
     bytestream_put_byte  (&buf, 0);             // reserved
     if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
@@ -1103,7 +1113,7 @@ static av_cold int encode_close(AVCodecContext *avctx)
 }
 
 static void prores_fdct(FDCTDSPContext *fdsp, const uint16_t *src,
-                        int linesize, int16_t *block)
+                        ptrdiff_t linesize, int16_t *block)
 {
     int x, y;
     const uint16_t *tsrc = src;
@@ -1154,7 +1164,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
                : "HQ profile to keep best quality");
     }
     if (av_pix_fmt_desc_get(avctx->pix_fmt)->flags & AV_PIX_FMT_FLAG_ALPHA) {
-        if (ctx->profile != PRORES_PROFILE_4444) {
+        if (ctx->profile != PRORES_PROFILE_4444 &&
+            ctx->profile != PRORES_PROFILE_4444XQ) {
             // force alpha and warn
             av_log(avctx, AV_LOG_WARNING, "Profile selected will not "
                    "encode alpha. Override with -profile if needed.\n");
@@ -1205,6 +1216,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
                                            ctx->pictures_per_frame)
                     break;
             ctx->bits_per_mb   = ctx->profile_info->br_tab[i];
+            if (ctx->alpha_bits)
+                ctx->bits_per_mb *= 20;
         } else if (ctx->bits_per_mb < 128) {
             av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
             return AVERROR_INVALIDDATA;
@@ -1295,7 +1308,7 @@ static const AVOption options[] = {
         AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
     { "profile",       NULL, OFFSET(profile), AV_OPT_TYPE_INT,
         { .i64 = PRORES_PROFILE_AUTO },
-        PRORES_PROFILE_AUTO, PRORES_PROFILE_4444, VE, "profile" },
+        PRORES_PROFILE_AUTO, PRORES_PROFILE_4444XQ, VE, "profile" },
     { "auto",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_AUTO },
         0, 0, VE, "profile" },
     { "proxy",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
@@ -1308,6 +1321,8 @@ static const AVOption options[] = {
         0, 0, VE, "profile" },
     { "4444",          NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },
         0, 0, VE, "profile" },
+    { "4444xq",        NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444XQ },
+        0, 0, VE, "profile" },
     { "vendor", "vendor ID", OFFSET(vendor),
         AV_OPT_TYPE_STRING, { .str = "Lavc" }, CHAR_MIN, CHAR_MAX, VE },
     { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
@@ -1347,7 +1362,7 @@ AVCodec ff_prores_ks_encoder = {
     .init           = encode_init,
     .close          = encode_close,
     .encode2        = encode_frame,
-    .capabilities   = AV_CODEC_CAP_SLICE_THREADS,
+    .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
     .pix_fmts       = (const enum AVPixelFormat[]) {
                           AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
                           AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE
diff --git a/mythtv/external/FFmpeg/libavcodec/psd.c b/mythtv/external/FFmpeg/libavcodec/psd.c
new file mode 100644
index 00000000000..66f2ec28d7d
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/psd.c
@@ -0,0 +1,472 @@
+/*
+ * Photoshop (PSD) image decoder
+ * Copyright (c) 2016 Jokyo Images
+ *
+ * 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 "bytestream.h"
+#include "internal.h"
+
+enum PsdCompr {
+    PSD_RAW,
+    PSD_RLE,
+    PSD_ZIP_WITHOUT_P,
+    PSD_ZIP_WITH_P,
+};
+
+enum PsdColorMode {
+    PSD_BITMAP,
+    PSD_GRAYSCALE,
+    PSD_INDEXED,
+    PSD_RGB,
+    PSD_CMYK,
+    PSD_MULTICHANNEL,
+    PSD_DUOTONE,
+    PSD_LAB,
+};
+
+typedef struct PSDContext {
+    AVClass *class;
+    AVFrame *picture;
+    AVCodecContext *avctx;
+    GetByteContext gb;
+
+    uint8_t * tmp;
+
+    uint16_t channel_count;
+    uint16_t channel_depth;
+
+    uint64_t uncompressed_size;
+    unsigned int pixel_size;/* 1 for 8 bits, 2 for 16 bits */
+    uint64_t line_size;/* length of src data (even width) */
+
+    int width;
+    int height;
+
+    enum PsdCompr compression;
+    enum PsdColorMode color_mode;
+
+    uint8_t palette[AVPALETTE_SIZE];
+} PSDContext;
+
+static int decode_header(PSDContext * s)
+{
+    int signature, version, color_mode;
+    int64_t len_section;
+    int ret = 0;
+
+    if (bytestream2_get_bytes_left(&s->gb) < 30) {/* File header section + color map data section length */
+        av_log(s->avctx, AV_LOG_ERROR, "Header too short to parse.\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    signature = bytestream2_get_le32(&s->gb);
+    if (signature != MKTAG('8','B','P','S')) {
+        av_log(s->avctx, AV_LOG_ERROR, "Wrong signature %d.\n", signature);
+        return AVERROR_INVALIDDATA;
+    }
+
+    version = bytestream2_get_be16(&s->gb);
+    if (version != 1) {
+        av_log(s->avctx, AV_LOG_ERROR, "Wrong version %d.\n", version);
+        return AVERROR_INVALIDDATA;
+    }
+
+    bytestream2_skip(&s->gb, 6);/* reserved */
+
+    s->channel_count = bytestream2_get_be16(&s->gb);
+    if ((s->channel_count < 1) || (s->channel_count > 56)) {
+        av_log(s->avctx, AV_LOG_ERROR, "Invalid channel count %d.\n", s->channel_count);
+        return AVERROR_INVALIDDATA;
+    }
+
+    s->height = bytestream2_get_be32(&s->gb);
+
+    if ((s->height > 30000) && (s->avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
+        av_log(s->avctx, AV_LOG_ERROR,
+               "Height > 30000 is experimental, add "
+               "'-strict %d' if you want to try to decode the picture.\n",
+               FF_COMPLIANCE_EXPERIMENTAL);
+        return AVERROR_EXPERIMENTAL;
+    }
+
+    s->width = bytestream2_get_be32(&s->gb);
+    if ((s->width > 30000) && (s->avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {
+        av_log(s->avctx, AV_LOG_ERROR,
+               "Width > 30000 is experimental, add "
+               "'-strict %d' if you want to try to decode the picture.\n",
+               FF_COMPLIANCE_EXPERIMENTAL);
+        return AVERROR_EXPERIMENTAL;
+    }
+
+    if ((ret = ff_set_dimensions(s->avctx, s->width, s->height)) < 0)
+        return ret;
+
+    s->channel_depth = bytestream2_get_be16(&s->gb);
+
+    color_mode = bytestream2_get_be16(&s->gb);
+    switch (color_mode) {
+    case 0:
+        s->color_mode = PSD_BITMAP;
+        break;
+    case 1:
+        s->color_mode = PSD_GRAYSCALE;
+        break;
+    case 2:
+        s->color_mode = PSD_INDEXED;
+        break;
+    case 3:
+        s->color_mode = PSD_RGB;
+        break;
+    case 4:
+        s->color_mode = PSD_CMYK;
+        break;
+    case 7:
+        s->color_mode = PSD_MULTICHANNEL;
+        break;
+    case 8:
+        s->color_mode = PSD_DUOTONE;
+        break;
+    case 9:
+        s->color_mode = PSD_LAB;
+        break;
+    default:
+        av_log(s->avctx, AV_LOG_ERROR, "Unknown color mode %d.\n", color_mode);
+        return AVERROR_INVALIDDATA;
+    }
+
+    /* color map data */
+    len_section = bytestream2_get_be32(&s->gb);
+    if (len_section < 0) {
+        av_log(s->avctx, AV_LOG_ERROR, "Negative size for color map data section.\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    if (bytestream2_get_bytes_left(&s->gb) < (len_section + 4)) { /* section and len next section */
+        av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
+        return AVERROR_INVALIDDATA;
+    }
+    if (len_section) {
+        int i,j;
+        memset(s->palette, 0xff, AVPALETTE_SIZE);
+        for (j = HAVE_BIGENDIAN; j < 3 + HAVE_BIGENDIAN; j++)
+            for (i = 0; i < FFMIN(256, len_section / 3); i++)
+                s->palette[i * 4 + (HAVE_BIGENDIAN ? j : 2 - j)] = bytestream2_get_byteu(&s->gb);
+        len_section -= i * 3;
+    }
+    bytestream2_skip(&s->gb, len_section);
+
+    /* image ressources */
+    len_section = bytestream2_get_be32(&s->gb);
+    if (len_section < 0) {
+        av_log(s->avctx, AV_LOG_ERROR, "Negative size for image ressources section.\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    if (bytestream2_get_bytes_left(&s->gb) < (len_section + 4)) { /* section and len next section */
+        av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
+        return AVERROR_INVALIDDATA;
+    }
+    bytestream2_skip(&s->gb, len_section);
+
+    /* layers and masks */
+    len_section = bytestream2_get_be32(&s->gb);
+    if (len_section < 0) {
+        av_log(s->avctx, AV_LOG_ERROR, "Negative size for layers and masks data section.\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    if (bytestream2_get_bytes_left(&s->gb) < len_section) {
+        av_log(s->avctx, AV_LOG_ERROR, "Incomplete file.\n");
+        return AVERROR_INVALIDDATA;
+    }
+    bytestream2_skip(&s->gb, len_section);
+
+    /* image section */
+    if (bytestream2_get_bytes_left(&s->gb) < 2) {
+        av_log(s->avctx, AV_LOG_ERROR, "File without image data section.\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    s->compression = bytestream2_get_be16(&s->gb);
+    switch (s->compression) {
+    case 0:
+    case 1:
+        break;
+    case 2:
+        avpriv_request_sample(s->avctx, "ZIP without predictor compression");
+        return AVERROR_PATCHWELCOME;
+        break;
+    case 3:
+        avpriv_request_sample(s->avctx, "ZIP with predictor compression");
+        return AVERROR_PATCHWELCOME;
+        break;
+    default:
+        av_log(s->avctx, AV_LOG_ERROR, "Unknown compression %d.\n", s->compression);
+        return AVERROR_INVALIDDATA;
+    }
+
+    return ret;
+}
+
+static int decode_rle(PSDContext * s){
+    unsigned int scanline_count;
+    unsigned int sl, count;
+    unsigned long target_index = 0;
+    unsigned int p;
+    int8_t rle_char;
+    unsigned int repeat_count;
+    uint8_t v;
+
+    scanline_count = s->height * s->channel_count;
+
+    /* scanline table */
+    if (bytestream2_get_bytes_left(&s->gb) < scanline_count * 2) {
+        av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline table.\n");
+        return AVERROR_INVALIDDATA;
+    }
+    bytestream2_skip(&s->gb, scanline_count * 2);/* size of each scanline */
+
+    /* decode rle data scanline by scanline */
+    for (sl = 0; sl < scanline_count; sl++) {
+        count = 0;
+
+        while (count < s->line_size) {
+            rle_char = bytestream2_get_byte(&s->gb);
+
+            if (rle_char <= 0) {/* byte repeat */
+                repeat_count = rle_char * -1;
+
+                if (bytestream2_get_bytes_left(&s->gb) < 1) {
+                    av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n");
+                    return AVERROR_INVALIDDATA;
+                }
+
+                if (target_index + repeat_count >= s->uncompressed_size) {
+                    av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n");
+                    return AVERROR_INVALIDDATA;
+                }
+
+                v = bytestream2_get_byte(&s->gb);
+                for (p = 0; p <= repeat_count; p++) {
+                    s->tmp[target_index++] = v;
+                }
+                count += repeat_count + 1;
+            } else {
+                if (bytestream2_get_bytes_left(&s->gb) < rle_char) {
+                    av_log(s->avctx, AV_LOG_ERROR, "Not enough data for rle scanline.\n");
+                    return AVERROR_INVALIDDATA;
+                }
+
+                if (target_index + rle_char >= s->uncompressed_size) {
+                    av_log(s->avctx, AV_LOG_ERROR, "Invalid rle char.\n");
+                    return AVERROR_INVALIDDATA;
+                }
+
+                for (p = 0; p <= rle_char; p++) {
+                    v = bytestream2_get_byte(&s->gb);
+                    s->tmp[target_index++] = v;
+                }
+                count += rle_char + 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int decode_frame(AVCodecContext *avctx, void *data,
+                        int *got_frame, AVPacket *avpkt)
+{
+    int ret;
+    uint8_t *ptr;
+    const uint8_t *ptr_data;
+    int index_out, c, y, x, p;
+    uint8_t eq_channel[4] = {2,0,1,3};/* RGBA -> GBRA channel order */
+    uint8_t plane_number;
+
+    AVFrame *picture = data;
+
+    PSDContext *s = avctx->priv_data;
+    s->avctx     = avctx;
+    s->channel_count = 0;
+    s->channel_depth = 0;
+    s->tmp           = NULL;
+    s->line_size     = 0;
+
+    bytestream2_init(&s->gb, avpkt->data, avpkt->size);
+
+    if ((ret = decode_header(s)) < 0)
+        return ret;
+
+    s->pixel_size = s->channel_depth >> 3;/* in byte */
+    s->line_size = s->width * s->pixel_size;
+
+    switch (s->color_mode) {
+    case PSD_BITMAP:
+        if (s->channel_depth != 1 || s->channel_count != 1) {
+            av_log(s->avctx, AV_LOG_ERROR,
+                    "Invalid bitmap file (channel_depth %d, channel_count %d)\n",
+                    s->channel_depth, s->channel_count);
+            return AVERROR_INVALIDDATA;
+        }
+        s->line_size = s->width + 7 >> 3;
+        avctx->pix_fmt = AV_PIX_FMT_MONOWHITE;
+        break;
+    case PSD_INDEXED:
+        if (s->channel_depth != 8 || s->channel_count != 1) {
+            av_log(s->avctx, AV_LOG_ERROR,
+                   "Invalid indexed file (channel_depth %d, channel_count %d)\n",
+                   s->channel_depth, s->channel_count);
+            return AVERROR_INVALIDDATA;
+        }
+        avctx->pix_fmt = AV_PIX_FMT_PAL8;
+        break;
+    case PSD_RGB:
+        if (s->channel_count == 3) {
+            if (s->channel_depth == 8) {
+                avctx->pix_fmt = AV_PIX_FMT_GBRP;
+            } else if (s->channel_depth == 16) {
+                avctx->pix_fmt = AV_PIX_FMT_GBRP16BE;
+            } else {
+                avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
+                return AVERROR_PATCHWELCOME;
+            }
+        } else if (s->channel_count == 4) {
+            if (s->channel_depth == 8) {
+                avctx->pix_fmt = AV_PIX_FMT_GBRAP;
+            } else if (s->channel_depth == 16) {
+                avctx->pix_fmt = AV_PIX_FMT_GBRAP16BE;
+            } else {
+                avpriv_report_missing_feature(avctx, "channel depth %d for rgb", s->channel_depth);
+                return AVERROR_PATCHWELCOME;
+            }
+        } else {
+            avpriv_report_missing_feature(avctx, "channel count %d for rgb", s->channel_count);
+            return AVERROR_PATCHWELCOME;
+        }
+        break;
+    case PSD_DUOTONE:
+        av_log(avctx, AV_LOG_WARNING, "ignoring unknown duotone specification.\n");
+    case PSD_GRAYSCALE:
+        if (s->channel_count == 1) {
+            if (s->channel_depth == 8) {
+                avctx->pix_fmt = AV_PIX_FMT_GRAY8;
+            } else if (s->channel_depth == 16) {
+                avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
+            } else {
+                avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
+                return AVERROR_PATCHWELCOME;
+            }
+        } else if (s->channel_count == 2) {
+            if (s->channel_depth == 8) {
+                avctx->pix_fmt = AV_PIX_FMT_YA8;
+            } else if (s->channel_depth == 16) {
+                avctx->pix_fmt = AV_PIX_FMT_YA16BE;
+            } else {
+                avpriv_report_missing_feature(avctx, "channel depth %d for grayscale", s->channel_depth);
+                return AVERROR_PATCHWELCOME;
+            }
+        } else {
+            avpriv_report_missing_feature(avctx, "channel count %d for grayscale", s->channel_count);
+            return AVERROR_PATCHWELCOME;
+        }
+        break;
+    default:
+        avpriv_report_missing_feature(avctx, "color mode %d", s->color_mode);
+        return AVERROR_PATCHWELCOME;
+    }
+
+    s->uncompressed_size = s->line_size * s->height * s->channel_count;
+
+    if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
+        return ret;
+
+    /* decode picture if need */
+    if (s->compression == PSD_RLE) {
+        s->tmp = av_malloc(s->uncompressed_size);
+        if (!s->tmp)
+            return AVERROR(ENOMEM);
+
+        ret = decode_rle(s);
+
+        if (ret < 0) {
+            av_freep(&s->tmp);
+            return ret;
+        }
+
+        ptr_data = s->tmp;
+    } else {
+        if (bytestream2_get_bytes_left(&s->gb) < s->uncompressed_size) {
+            av_log(s->avctx, AV_LOG_ERROR, "Not enough data for raw image data section.\n");
+            return AVERROR_INVALIDDATA;
+        }
+        ptr_data = s->gb.buffer;
+    }
+
+    /* Store data */
+    if ((avctx->pix_fmt == AV_PIX_FMT_YA8)||(avctx->pix_fmt == AV_PIX_FMT_YA16BE)){/* Interleaved */
+        ptr = picture->data[0];
+        for (c = 0; c < s->channel_count; c++) {
+            for (y = 0; y < s->height; y++) {
+                for (x = 0; x < s->width; x++) {
+                    index_out = y * picture->linesize[0] + x * s->channel_count * s->pixel_size + c * s->pixel_size;
+                    for (p = 0; p < s->pixel_size; p++) {
+                        ptr[index_out + p] = *ptr_data;
+                        ptr_data ++;
+                    }
+                }
+            }
+        }
+    } else {/* Planar */
+        if (s->channel_count == 1)/* gray 8 or gray 16be */
+            eq_channel[0] = 0;/* assign first channel, to first plane */
+
+        for (c = 0; c < s->channel_count; c++) {
+            plane_number = eq_channel[c];
+            ptr = picture->data[plane_number];/* get the right plane */
+            for (y = 0; y < s->height; y++) {
+                memcpy(ptr, ptr_data, s->line_size);
+                ptr += picture->linesize[plane_number];
+                ptr_data += s->line_size;
+            }
+        }
+    }
+
+    if (s->color_mode == PSD_INDEXED) {
+        picture->palette_has_changed = 1;
+        memcpy(picture->data[1], s->palette, AVPALETTE_SIZE);
+    }
+
+    av_freep(&s->tmp);
+
+    picture->pict_type = AV_PICTURE_TYPE_I;
+    *got_frame = 1;
+
+    return avpkt->size;
+}
+
+AVCodec ff_psd_decoder = {
+    .name             = "psd",
+    .long_name        = NULL_IF_CONFIG_SMALL("Photoshop PSD file"),
+    .type             = AVMEDIA_TYPE_VIDEO,
+    .id               = AV_CODEC_ID_PSD,
+    .priv_data_size   = sizeof(PSDContext),
+    .decode           = decode_frame,
+    .capabilities     = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/psymodel.h b/mythtv/external/FFmpeg/libavcodec/psymodel.h
index 582f040c7a3..e5f917d495d 100644
--- a/mythtv/external/FFmpeg/libavcodec/psymodel.h
+++ b/mythtv/external/FFmpeg/libavcodec/psymodel.h
@@ -39,7 +39,7 @@
     22000, \
     sample_rate / 2): (sample_rate / 2))
 #define AAC_CUTOFF(s) ( \
-    (s->flags & CODEC_FLAG_QSCALE) \
+    (s->flags & AV_CODEC_FLAG_QSCALE) \
     ? s->sample_rate / 2 \
     : AAC_CUTOFF_FROM_BITRATE(s->bit_rate, s->channels, s->sample_rate) \
 )
diff --git a/mythtv/external/FFmpeg/libavcodec/pthread_frame.c b/mythtv/external/FFmpeg/libavcodec/pthread_frame.c
index 7ef5e9f6be9..2c702c73721 100644
--- a/mythtv/external/FFmpeg/libavcodec/pthread_frame.c
+++ b/mythtv/external/FFmpeg/libavcodec/pthread_frame.c
@@ -24,9 +24,11 @@
 
 #include "config.h"
 
+#include <stdatomic.h>
 #include <stdint.h>
 
 #include "avcodec.h"
+#include "hwaccel.h"
 #include "internal.h"
 #include "pthread_internal.h"
 #include "thread.h"
@@ -43,6 +45,25 @@
 #include "libavutil/opt.h"
 #include "libavutil/thread.h"
 
+enum {
+    ///< Set when the thread is awaiting a packet.
+    STATE_INPUT_READY,
+    ///< Set before the codec has called ff_thread_finish_setup().
+    STATE_SETTING_UP,
+    /**
+     * Set when the codec calls get_buffer().
+     * State is returned to STATE_SETTING_UP afterwards.
+     */
+    STATE_GET_BUFFER,
+     /**
+      * Set when the codec calls get_format().
+      * State is returned to STATE_SETTING_UP afterwards.
+      */
+    STATE_GET_FORMAT,
+    ///< Set after the codec has called ff_thread_finish_setup().
+    STATE_SETUP_FINISHED,
+};
+
 /**
  * Context used by codec threads and stored in their AVCodecInternal thread_ctx.
  */
@@ -66,19 +87,7 @@ typedef struct PerThreadContext {
     int     got_frame;              ///< The output of got_picture_ptr from the last avcodec_decode_video() call.
     int     result;                 ///< The result of the last codec decode/encode() call.
 
-    enum {
-        STATE_INPUT_READY,          ///< Set when the thread is awaiting a packet.
-        STATE_SETTING_UP,           ///< Set before the codec has called ff_thread_finish_setup().
-        STATE_GET_BUFFER,           /**<
-                                     * Set when the codec calls get_buffer().
-                                     * State is returned to STATE_SETTING_UP afterwards.
-                                     */
-        STATE_GET_FORMAT,           /**<
-                                     * Set when the codec calls get_format().
-                                     * State is returned to STATE_SETTING_UP afterwards.
-                                     */
-        STATE_SETUP_FINISHED        ///< Set after the codec has called ff_thread_finish_setup().
-    } state;
+    atomic_int state;
 
     /**
      * Array of frames passed to ff_thread_release_buffer().
@@ -95,6 +104,11 @@ typedef struct PerThreadContext {
     enum AVPixelFormat result_format;            ///< get_format() result
 
     int die;                        ///< Set when the thread should exit.
+
+    int hwaccel_serializing;
+    int async_serializing;
+
+    atomic_int debug_threads;       ///< Set if the FF_DEBUG_THREADS option is set.
 } PerThreadContext;
 
 /**
@@ -105,6 +119,14 @@ typedef struct FrameThreadContext {
     PerThreadContext *prev_thread; ///< The last thread submit_packet() was called on.
 
     pthread_mutex_t buffer_mutex;  ///< Mutex used to protect get/release_buffer().
+    /**
+     * This lock is used for ensuring threads run in serial when hwaccel
+     * is used.
+     */
+    pthread_mutex_t hwaccel_mutex;
+    pthread_mutex_t async_mutex;
+    pthread_cond_t async_cond;
+    int async_lock;
 
     int next_decoding;             ///< The next context to submit a packet to.
     int next_finished;             ///< The next context to return output from.
@@ -118,6 +140,24 @@ typedef struct FrameThreadContext {
 #define THREAD_SAFE_CALLBACKS(avctx) \
 ((avctx)->thread_safe_callbacks || (avctx)->get_buffer2 == avcodec_default_get_buffer2)
 
+static void async_lock(FrameThreadContext *fctx)
+{
+    pthread_mutex_lock(&fctx->async_mutex);
+    while (fctx->async_lock)
+        pthread_cond_wait(&fctx->async_cond, &fctx->async_mutex);
+    fctx->async_lock = 1;
+    pthread_mutex_unlock(&fctx->async_mutex);
+}
+
+static void async_unlock(FrameThreadContext *fctx)
+{
+    pthread_mutex_lock(&fctx->async_mutex);
+    av_assert0(fctx->async_lock);
+    fctx->async_lock = 0;
+    pthread_cond_broadcast(&fctx->async_cond);
+    pthread_mutex_unlock(&fctx->async_mutex);
+}
+
 /**
  * Codec worker thread.
  *
@@ -133,14 +173,29 @@ static attribute_align_arg void *frame_worker_thread(void *arg)
 
     pthread_mutex_lock(&p->mutex);
     while (1) {
-            while (p->state == STATE_INPUT_READY && !p->die)
-                pthread_cond_wait(&p->input_cond, &p->mutex);
+        while (atomic_load(&p->state) == STATE_INPUT_READY && !p->die)
+            pthread_cond_wait(&p->input_cond, &p->mutex);
 
         if (p->die) break;
 
         if (!codec->update_thread_context && THREAD_SAFE_CALLBACKS(avctx))
             ff_thread_finish_setup(avctx);
 
+        /* If a decoder supports hwaccel, then it must call ff_get_format().
+         * Since that call must happen before ff_thread_finish_setup(), the
+         * decoder is required to implement update_thread_context() and call
+         * ff_thread_finish_setup() manually. Therefore the above
+         * ff_thread_finish_setup() call did not happen and hwaccel_serializing
+         * cannot be true here. */
+        av_assert0(!p->hwaccel_serializing);
+
+        /* if the previous thread uses hwaccel then we take the lock to ensure
+         * the threads don't run concurrently */
+        if (avctx->hwaccel) {
+            pthread_mutex_lock(&p->parent->hwaccel_mutex);
+            p->hwaccel_serializing = 1;
+        }
+
         av_frame_unref(p->frame);
         p->got_frame = 0;
         p->result = codec->decode(avctx, p->frame, &p->got_frame, &p->avpkt);
@@ -152,17 +207,23 @@ static attribute_align_arg void *frame_worker_thread(void *arg)
             av_frame_unref(p->frame);
         }
 
-        if (p->state == STATE_SETTING_UP) ff_thread_finish_setup(avctx);
+        if (atomic_load(&p->state) == STATE_SETTING_UP)
+            ff_thread_finish_setup(avctx);
+
+        if (p->hwaccel_serializing) {
+            p->hwaccel_serializing = 0;
+            pthread_mutex_unlock(&p->parent->hwaccel_mutex);
+        }
+
+        if (p->async_serializing) {
+            p->async_serializing = 0;
+
+            async_unlock(p->parent);
+        }
 
         pthread_mutex_lock(&p->progress_mutex);
-#if 0 //BUFREF-FIXME
-        for (i = 0; i < MAX_BUFFERS; i++)
-            if (p->progress_used[i] && (p->got_frame || p->result<0 || avctx->codec_id != AV_CODEC_ID_H264)) {
-                p->progress[i][0] = INT_MAX;
-                p->progress[i][1] = INT_MAX;
-            }
-#endif
-        p->state = STATE_INPUT_READY;
+
+        atomic_store(&p->state, STATE_INPUT_READY);
 
         pthread_cond_broadcast(&p->progress_cond);
         pthread_cond_signal(&p->output_cond);
@@ -185,12 +246,13 @@ static int update_context_from_thread(AVCodecContext *dst, AVCodecContext *src,
 {
     int err = 0;
 
-    if (dst != src) {
+    if (dst != src && (for_user || !(av_codec_get_codec_descriptor(src)->props & AV_CODEC_PROP_INTRA_ONLY))) {
         dst->time_base = src->time_base;
         dst->framerate = src->framerate;
         dst->width     = src->width;
         dst->height    = src->height;
         dst->pix_fmt   = src->pix_fmt;
+        dst->sw_pix_fmt = src->sw_pix_fmt;
 
         dst->coded_width  = src->coded_width;
         dst->coded_height = src->coded_height;
@@ -226,6 +288,19 @@ FF_ENABLE_DEPRECATION_WARNINGS
         dst->sample_fmt     = src->sample_fmt;
         dst->channel_layout = src->channel_layout;
         dst->internal->hwaccel_priv_data = src->internal->hwaccel_priv_data;
+
+        if (!!dst->hw_frames_ctx != !!src->hw_frames_ctx ||
+            (dst->hw_frames_ctx && dst->hw_frames_ctx->data != src->hw_frames_ctx->data)) {
+            av_buffer_unref(&dst->hw_frames_ctx);
+
+            if (src->hw_frames_ctx) {
+                dst->hw_frames_ctx = av_buffer_ref(src->hw_frames_ctx);
+                if (!dst->hw_frames_ctx)
+                    return AVERROR(ENOMEM);
+            }
+        }
+
+        dst->hwaccel_flags = src->hwaccel_flags;
     }
 
     if (for_user) {
@@ -307,24 +382,35 @@ static void release_delayed_buffers(PerThreadContext *p)
     }
 }
 
-static int submit_packet(PerThreadContext *p, AVPacket *avpkt)
+static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx,
+                         AVPacket *avpkt)
 {
     FrameThreadContext *fctx = p->parent;
     PerThreadContext *prev_thread = fctx->prev_thread;
     const AVCodec *codec = p->avctx->codec;
+    int ret;
 
     if (!avpkt->size && !(codec->capabilities & AV_CODEC_CAP_DELAY))
         return 0;
 
     pthread_mutex_lock(&p->mutex);
 
+    ret = update_context_from_user(p->avctx, user_avctx);
+    if (ret) {
+        pthread_mutex_unlock(&p->mutex);
+        return ret;
+    }
+    atomic_store_explicit(&p->debug_threads,
+                          (p->avctx->debug & FF_DEBUG_THREADS) != 0,
+                          memory_order_relaxed);
+
     release_delayed_buffers(p);
 
     if (prev_thread) {
         int err;
-        if (prev_thread->state == STATE_SETTING_UP) {
+        if (atomic_load(&prev_thread->state) == STATE_SETTING_UP) {
             pthread_mutex_lock(&prev_thread->progress_mutex);
-            while (prev_thread->state == STATE_SETTING_UP)
+            while (atomic_load(&prev_thread->state) == STATE_SETTING_UP)
                 pthread_cond_wait(&prev_thread->progress_cond, &prev_thread->progress_mutex);
             pthread_mutex_unlock(&prev_thread->progress_mutex);
         }
@@ -337,9 +423,14 @@ static int submit_packet(PerThreadContext *p, AVPacket *avpkt)
     }
 
     av_packet_unref(&p->avpkt);
-    av_packet_ref(&p->avpkt, avpkt);
+    ret = av_packet_ref(&p->avpkt, avpkt);
+    if (ret < 0) {
+        pthread_mutex_unlock(&p->mutex);
+        av_log(p->avctx, AV_LOG_ERROR, "av_packet_ref() failed in submit_packet()\n");
+        return ret;
+    }
 
-    p->state = STATE_SETTING_UP;
+    atomic_store(&p->state, STATE_SETTING_UP);
     pthread_cond_signal(&p->input_cond);
     pthread_mutex_unlock(&p->mutex);
 
@@ -352,13 +443,13 @@ static int submit_packet(PerThreadContext *p, AVPacket *avpkt)
     if (!p->avctx->thread_safe_callbacks && (
          p->avctx->get_format != avcodec_default_get_format ||
          p->avctx->get_buffer2 != avcodec_default_get_buffer2)) {
-        while (p->state != STATE_SETUP_FINISHED && p->state != STATE_INPUT_READY) {
+        while (atomic_load(&p->state) != STATE_SETUP_FINISHED && atomic_load(&p->state) != STATE_INPUT_READY) {
             int call_done = 1;
             pthread_mutex_lock(&p->progress_mutex);
-            while (p->state == STATE_SETTING_UP)
+            while (atomic_load(&p->state) == STATE_SETTING_UP)
                 pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
 
-            switch (p->state) {
+            switch (atomic_load_explicit(&p->state, memory_order_acquire)) {
             case STATE_GET_BUFFER:
                 p->result = ff_get_buffer(p->avctx, p->requested_frame, p->requested_flags);
                 break;
@@ -370,7 +461,7 @@ static int submit_packet(PerThreadContext *p, AVPacket *avpkt)
                 break;
             }
             if (call_done) {
-                p->state  = STATE_SETTING_UP;
+                atomic_store(&p->state, STATE_SETTING_UP);
                 pthread_cond_signal(&p->progress_cond);
             }
             pthread_mutex_unlock(&p->progress_mutex);
@@ -392,15 +483,18 @@ int ff_thread_decode_frame(AVCodecContext *avctx,
     PerThreadContext *p;
     int err;
 
+    /* release the async lock, permitting blocked hwaccel threads to
+     * go forward while we are in this function */
+    async_unlock(fctx);
+
     /*
      * Submit a packet to the next decoding thread.
      */
 
     p = &fctx->threads[fctx->next_decoding];
-    err = update_context_from_user(p->avctx, avctx);
-    if (err) return err;
-    err = submit_packet(p, avpkt);
-    if (err) return err;
+    err = submit_packet(p, avctx, avpkt);
+    if (err)
+        goto finish;
 
     /*
      * If we're still receiving the initial packets, don't return a frame.
@@ -411,23 +505,25 @@ int ff_thread_decode_frame(AVCodecContext *avctx,
 
     if (fctx->delaying) {
         *got_picture_ptr=0;
-        if (avpkt->size)
-            return avpkt->size;
+        if (avpkt->size) {
+            err = avpkt->size;
+            goto finish;
+        }
     }
 
     /*
      * Return the next available frame from the oldest thread.
      * If we're at the end of the stream, then we have to skip threads that
-     * didn't output a frame, because we don't want to accidentally signal
-     * EOF (avpkt->size == 0 && *got_picture_ptr == 0).
+     * didn't output a frame/error, because we don't want to accidentally signal
+     * EOF (avpkt->size == 0 && *got_picture_ptr == 0 && err >= 0).
      */
 
     do {
         p = &fctx->threads[finished++];
 
-        if (p->state != STATE_INPUT_READY) {
+        if (atomic_load(&p->state) != STATE_INPUT_READY) {
             pthread_mutex_lock(&p->progress_mutex);
-            while (p->state != STATE_INPUT_READY)
+            while (atomic_load_explicit(&p->state, memory_order_relaxed) != STATE_INPUT_READY)
                 pthread_cond_wait(&p->output_cond, &p->progress_mutex);
             pthread_mutex_unlock(&p->progress_mutex);
         }
@@ -435,20 +531,19 @@ int ff_thread_decode_frame(AVCodecContext *avctx,
         av_frame_move_ref(picture, p->frame);
         *got_picture_ptr = p->got_frame;
         picture->pkt_dts = p->avpkt.dts;
-
-        if (p->result < 0)
-            err = p->result;
+        err = p->result;
 
         /*
          * A later call with avkpt->size == 0 may loop over all threads,
-         * including this one, searching for a frame to return before being
+         * including this one, searching for a frame/error to return before being
          * stopped by the "finished != fctx->next_finished" condition.
-         * Make sure we don't mistakenly return the same frame again.
+         * Make sure we don't mistakenly return the same frame/error again.
          */
         p->got_frame = 0;
+        p->result = 0;
 
         if (finished >= avctx->thread_count) finished = 0;
-    } while (!avpkt->size && !*got_picture_ptr && finished != fctx->next_finished);
+    } while (!avpkt->size && !*got_picture_ptr && err >= 0 && finished != fctx->next_finished);
 
     update_context_from_thread(avctx, p->avctx, 1);
 
@@ -456,32 +551,33 @@ int ff_thread_decode_frame(AVCodecContext *avctx,
 
     fctx->next_finished = finished;
 
-    /*
-     * When no frame was found while flushing, but an error occurred in
-     * any thread, return it instead of 0.
-     * Otherwise the error can get lost.
-     */
-    if (!avpkt->size && !*got_picture_ptr)
-        return err;
-
     /* return the size of the consumed packet if no error occurred */
-    return (p->result >= 0) ? avpkt->size : p->result;
+    if (err >= 0)
+        err = avpkt->size;
+finish:
+    async_lock(fctx);
+    return err;
 }
 
 void ff_thread_report_progress(ThreadFrame *f, int n, int field)
 {
     PerThreadContext *p;
-    volatile int *progress = f->progress ? (int*)f->progress->data : NULL;
+    atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
 
-    if (!progress || progress[field] >= n) return;
+    if (!progress ||
+        atomic_load_explicit(&progress[field], memory_order_relaxed) >= n)
+        return;
 
-    p = f->owner->internal->thread_ctx;
+    p = f->owner[field]->internal->thread_ctx;
 
-    if (f->owner->debug&FF_DEBUG_THREADS)
-        av_log(f->owner, AV_LOG_DEBUG, "%p finished %d field %d\n", progress, n, field);
+    if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
+        av_log(f->owner[field], AV_LOG_DEBUG,
+               "%p finished %d field %d\n", progress, n, field);
 
     pthread_mutex_lock(&p->progress_mutex);
-    progress[field] = n;
+
+    atomic_store_explicit(&progress[field], n, memory_order_release);
+
     pthread_cond_broadcast(&p->progress_cond);
     pthread_mutex_unlock(&p->progress_mutex);
 }
@@ -489,17 +585,20 @@ void ff_thread_report_progress(ThreadFrame *f, int n, int field)
 void ff_thread_await_progress(ThreadFrame *f, int n, int field)
 {
     PerThreadContext *p;
-    volatile int *progress = f->progress ? (int*)f->progress->data : NULL;
+    atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
 
-    if (!progress || progress[field] >= n) return;
+    if (!progress ||
+        atomic_load_explicit(&progress[field], memory_order_acquire) >= n)
+        return;
 
-    p = f->owner->internal->thread_ctx;
+    p = f->owner[field]->internal->thread_ctx;
 
-    if (f->owner->debug&FF_DEBUG_THREADS)
-        av_log(f->owner, AV_LOG_DEBUG, "thread awaiting %d field %d from %p\n", n, field, progress);
+    if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
+        av_log(f->owner[field], AV_LOG_DEBUG,
+               "thread awaiting %d field %d from %p\n", n, field, progress);
 
     pthread_mutex_lock(&p->progress_mutex);
-    while (progress[field] < n)
+    while (atomic_load_explicit(&progress[field], memory_order_relaxed) < n)
         pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
     pthread_mutex_unlock(&p->progress_mutex);
 }
@@ -509,12 +608,26 @@ void ff_thread_finish_setup(AVCodecContext *avctx) {
 
     if (!(avctx->active_thread_type&FF_THREAD_FRAME)) return;
 
-    if(p->state == STATE_SETUP_FINISHED){
-        av_log(avctx, AV_LOG_WARNING, "Multiple ff_thread_finish_setup() calls\n");
+    if (avctx->hwaccel && !p->hwaccel_serializing) {
+        pthread_mutex_lock(&p->parent->hwaccel_mutex);
+        p->hwaccel_serializing = 1;
+    }
+
+    /* this assumes that no hwaccel calls happen before ff_thread_finish_setup() */
+    if (avctx->hwaccel &&
+        !(avctx->hwaccel->caps_internal & HWACCEL_CAP_ASYNC_SAFE)) {
+        p->async_serializing = 1;
+
+        async_lock(p->parent);
     }
 
     pthread_mutex_lock(&p->progress_mutex);
-    p->state = STATE_SETUP_FINISHED;
+    if(atomic_load(&p->state) == STATE_SETUP_FINISHED){
+        av_log(avctx, AV_LOG_WARNING, "Multiple ff_thread_finish_setup() calls\n");
+    }
+
+    atomic_store(&p->state, STATE_SETUP_FINISHED);
+
     pthread_cond_broadcast(&p->progress_cond);
     pthread_mutex_unlock(&p->progress_mutex);
 }
@@ -524,17 +637,21 @@ static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count
 {
     int i;
 
+    async_unlock(fctx);
+
     for (i = 0; i < thread_count; i++) {
         PerThreadContext *p = &fctx->threads[i];
 
-        if (p->state != STATE_INPUT_READY) {
+        if (atomic_load(&p->state) != STATE_INPUT_READY) {
             pthread_mutex_lock(&p->progress_mutex);
-            while (p->state != STATE_INPUT_READY)
+            while (atomic_load(&p->state) != STATE_INPUT_READY)
                 pthread_cond_wait(&p->output_cond, &p->progress_mutex);
             pthread_mutex_unlock(&p->progress_mutex);
         }
         p->got_frame = 0;
     }
+
+    async_lock(fctx);
 }
 
 void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
@@ -587,13 +704,20 @@ void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
             av_freep(&p->avctx->slice_offset);
         }
 
-        if (p->avctx)
+        if (p->avctx) {
             av_freep(&p->avctx->internal);
+            av_buffer_unref(&p->avctx->hw_frames_ctx);
+        }
+
         av_freep(&p->avctx);
     }
 
     av_freep(&fctx->threads);
     pthread_mutex_destroy(&fctx->buffer_mutex);
+    pthread_mutex_destroy(&fctx->hwaccel_mutex);
+    pthread_mutex_destroy(&fctx->async_mutex);
+    pthread_cond_destroy(&fctx->async_cond);
+
     av_freep(&avctx->internal->thread_ctx);
 
     if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
@@ -615,8 +739,10 @@ int ff_frame_thread_init(AVCodecContext *avctx)
 
     if (!thread_count) {
         int nb_cpus = av_cpu_count();
+#if FF_API_DEBUG_MV
         if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) || avctx->debug_mv)
             nb_cpus = 1;
+#endif
         // use number of cores + 1 as thread count if there is more than one
         if (nb_cpus > 1)
             thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);
@@ -640,6 +766,11 @@ int ff_frame_thread_init(AVCodecContext *avctx)
     }
 
     pthread_mutex_init(&fctx->buffer_mutex, NULL);
+    pthread_mutex_init(&fctx->hwaccel_mutex, NULL);
+    pthread_mutex_init(&fctx->async_mutex, NULL);
+    pthread_cond_init(&fctx->async_cond, NULL);
+
+    fctx->async_lock = 1;
     fctx->delaying = 1;
 
     for (i = 0; i < thread_count; i++) {
@@ -677,7 +808,7 @@ int ff_frame_thread_init(AVCodecContext *avctx)
         }
         *copy->internal = *src->internal;
         copy->internal->thread_ctx = p;
-        copy->internal->pkt = &p->avpkt;
+        copy->internal->last_pkt_props = &p->avpkt;
 
         if (!i) {
             src = copy;
@@ -701,6 +832,8 @@ int ff_frame_thread_init(AVCodecContext *avctx)
 
         if (err) goto error;
 
+        atomic_init(&p->debug_threads, (copy->debug & FF_DEBUG_THREADS) != 0);
+
         err = AVERROR(pthread_create(&p->thread, NULL, frame_worker_thread, p));
         p->thread_init= !err;
         if(!p->thread_init)
@@ -736,6 +869,7 @@ void ff_thread_flush(AVCodecContext *avctx)
         // Make sure decode flush calls with size=0 won't return old frames
         p->got_frame = 0;
         av_frame_unref(p->frame);
+        p->result = 0;
 
         release_delayed_buffers(p);
 
@@ -747,7 +881,7 @@ void ff_thread_flush(AVCodecContext *avctx)
 int ff_thread_can_start_frame(AVCodecContext *avctx)
 {
     PerThreadContext *p = avctx->internal->thread_ctx;
-    if ((avctx->active_thread_type&FF_THREAD_FRAME) && p->state != STATE_SETTING_UP &&
+    if ((avctx->active_thread_type&FF_THREAD_FRAME) && atomic_load(&p->state) != STATE_SETTING_UP &&
         (avctx->codec->update_thread_context || !THREAD_SAFE_CALLBACKS(avctx))) {
         return 0;
     }
@@ -759,28 +893,29 @@ static int thread_get_buffer_internal(AVCodecContext *avctx, ThreadFrame *f, int
     PerThreadContext *p = avctx->internal->thread_ctx;
     int err;
 
-    f->owner = avctx;
+    f->owner[0] = f->owner[1] = avctx;
 
     ff_init_buffer_info(avctx, f->f);
 
     if (!(avctx->active_thread_type & FF_THREAD_FRAME))
         return ff_get_buffer(avctx, f->f, flags);
 
-    if (p->state != STATE_SETTING_UP &&
+    if (atomic_load(&p->state) != STATE_SETTING_UP &&
         (avctx->codec->update_thread_context || !THREAD_SAFE_CALLBACKS(avctx))) {
         av_log(avctx, AV_LOG_ERROR, "get_buffer() cannot be called after ff_thread_finish_setup()\n");
         return -1;
     }
 
     if (avctx->internal->allocate_progress) {
-        int *progress;
-        f->progress = av_buffer_alloc(2 * sizeof(int));
+        atomic_int *progress;
+        f->progress = av_buffer_alloc(2 * sizeof(*progress));
         if (!f->progress) {
             return AVERROR(ENOMEM);
         }
-        progress = (int*)f->progress->data;
+        progress = (atomic_int*)f->progress->data;
 
-        progress[0] = progress[1] = -1;
+        atomic_init(&progress[0], -1);
+        atomic_init(&progress[1], -1);
     }
 
     pthread_mutex_lock(&p->parent->buffer_mutex);
@@ -791,10 +926,10 @@ static int thread_get_buffer_internal(AVCodecContext *avctx, ThreadFrame *f, int
         pthread_mutex_lock(&p->progress_mutex);
         p->requested_frame = f->f;
         p->requested_flags = flags;
-        p->state = STATE_GET_BUFFER;
+        atomic_store_explicit(&p->state, STATE_GET_BUFFER, memory_order_release);
         pthread_cond_broadcast(&p->progress_cond);
 
-        while (p->state != STATE_SETTING_UP)
+        while (atomic_load(&p->state) != STATE_SETTING_UP)
             pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
 
         err = p->result;
@@ -819,16 +954,16 @@ enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixe
     if (!(avctx->active_thread_type & FF_THREAD_FRAME) || avctx->thread_safe_callbacks ||
         avctx->get_format == avcodec_default_get_format)
         return ff_get_format(avctx, fmt);
-    if (p->state != STATE_SETTING_UP) {
+    if (atomic_load(&p->state) != STATE_SETTING_UP) {
         av_log(avctx, AV_LOG_ERROR, "get_format() cannot be called after ff_thread_finish_setup()\n");
         return -1;
     }
     pthread_mutex_lock(&p->progress_mutex);
     p->available_formats = fmt;
-    p->state = STATE_GET_FORMAT;
+    atomic_store(&p->state, STATE_GET_FORMAT);
     pthread_cond_broadcast(&p->progress_cond);
 
-    while (p->state != STATE_SETTING_UP)
+    while (atomic_load(&p->state) != STATE_SETTING_UP)
         pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
 
     res = p->result_format;
@@ -862,7 +997,7 @@ void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
         av_log(avctx, AV_LOG_DEBUG, "thread_release_buffer called on pic %p\n", f);
 
     av_buffer_unref(&f->progress);
-    f->owner    = NULL;
+    f->owner[0] = f->owner[1] = NULL;
 
     if (can_direct_free) {
         av_frame_unref(f->f);
diff --git a/mythtv/external/FFmpeg/libavcodec/pthread_slice.c b/mythtv/external/FFmpeg/libavcodec/pthread_slice.c
index 96a7643f6a2..d659f9b0ba8 100644
--- a/mythtv/external/FFmpeg/libavcodec/pthread_slice.c
+++ b/mythtv/external/FFmpeg/libavcodec/pthread_slice.c
@@ -34,26 +34,21 @@
 #include "libavutil/cpu.h"
 #include "libavutil/mem.h"
 #include "libavutil/thread.h"
+#include "libavutil/slicethread.h"
 
 typedef int (action_func)(AVCodecContext *c, void *arg);
 typedef int (action_func2)(AVCodecContext *c, void *arg, int jobnr, int threadnr);
+typedef int (main_func)(AVCodecContext *c);
 
 typedef struct SliceThreadContext {
-    pthread_t *workers;
+    AVSliceThread *thread;
     action_func *func;
     action_func2 *func2;
+    main_func *mainfunc;
     void *args;
     int *rets;
-    int job_count;
     int job_size;
 
-    pthread_cond_t last_job_cond;
-    pthread_cond_t current_job_cond;
-    pthread_mutex_t current_job_lock;
-    unsigned current_execute;
-    int current_job;
-    int done;
-
     int *entries;
     int entries_count;
     int thread_count;
@@ -61,43 +56,22 @@ typedef struct SliceThreadContext {
     pthread_mutex_t *progress_mutex;
 } SliceThreadContext;
 
-static void* attribute_align_arg worker(void *v)
-{
-    AVCodecContext *avctx = v;
+static void main_function(void *priv) {
+    AVCodecContext *avctx = priv;
     SliceThreadContext *c = avctx->internal->thread_ctx;
-    unsigned last_execute = 0;
-    int our_job = c->job_count;
-    int thread_count = avctx->thread_count;
-    int self_id;
-
-    pthread_mutex_lock(&c->current_job_lock);
-    self_id = c->current_job++;
-    for (;;){
-        int ret;
-        while (our_job >= c->job_count) {
-            if (c->current_job == thread_count + c->job_count)
-                pthread_cond_signal(&c->last_job_cond);
-
-            while (last_execute == c->current_execute && !c->done)
-                pthread_cond_wait(&c->current_job_cond, &c->current_job_lock);
-            last_execute = c->current_execute;
-            our_job = self_id;
-
-            if (c->done) {
-                pthread_mutex_unlock(&c->current_job_lock);
-                return NULL;
-            }
-        }
-        pthread_mutex_unlock(&c->current_job_lock);
+    c->mainfunc(avctx);
+}
 
-        ret = c->func ? c->func(avctx, (char*)c->args + our_job*c->job_size):
-                                c->func2(avctx, c->args, our_job, self_id);
-        if (c->rets)
-            c->rets[our_job%c->job_count] = ret;
+static void worker_func(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
+{
+    AVCodecContext *avctx = priv;
+    SliceThreadContext *c = avctx->internal->thread_ctx;
+    int ret;
 
-        pthread_mutex_lock(&c->current_job_lock);
-        our_job = c->current_job++;
-    }
+    ret = c->func ? c->func(avctx, (char *)c->args + c->job_size * jobnr)
+                  : c->func2(avctx, c->args, jobnr, threadnr);
+    if (c->rets)
+        c->rets[jobnr] = ret;
 }
 
 void ff_slice_thread_free(AVCodecContext *avctx)
@@ -105,40 +79,19 @@ void ff_slice_thread_free(AVCodecContext *avctx)
     SliceThreadContext *c = avctx->internal->thread_ctx;
     int i;
 
-    pthread_mutex_lock(&c->current_job_lock);
-    c->done = 1;
-    pthread_cond_broadcast(&c->current_job_cond);
-    for (i = 0; i < c->thread_count; i++)
-        pthread_cond_broadcast(&c->progress_cond[i]);
-    pthread_mutex_unlock(&c->current_job_lock);
-
-    for (i=0; i<avctx->thread_count; i++)
-         pthread_join(c->workers[i], NULL);
+    avpriv_slicethread_free(&c->thread);
 
     for (i = 0; i < c->thread_count; i++) {
         pthread_mutex_destroy(&c->progress_mutex[i]);
         pthread_cond_destroy(&c->progress_cond[i]);
     }
 
-    pthread_mutex_destroy(&c->current_job_lock);
-    pthread_cond_destroy(&c->current_job_cond);
-    pthread_cond_destroy(&c->last_job_cond);
-
     av_freep(&c->entries);
     av_freep(&c->progress_mutex);
     av_freep(&c->progress_cond);
-
-    av_freep(&c->workers);
     av_freep(&avctx->internal->thread_ctx);
 }
 
-static av_always_inline void thread_park_workers(SliceThreadContext *c, int thread_count)
-{
-    while (c->current_job != thread_count + c->job_count)
-        pthread_cond_wait(&c->last_job_cond, &c->current_job_lock);
-    pthread_mutex_unlock(&c->current_job_lock);
-}
-
 static int thread_execute(AVCodecContext *avctx, action_func* func, void *arg, int *ret, int job_count, int job_size)
 {
     SliceThreadContext *c = avctx->internal->thread_ctx;
@@ -149,23 +102,12 @@ static int thread_execute(AVCodecContext *avctx, action_func* func, void *arg, i
     if (job_count <= 0)
         return 0;
 
-    pthread_mutex_lock(&c->current_job_lock);
-
-    c->current_job = avctx->thread_count;
-    c->job_count = job_count;
     c->job_size = job_size;
     c->args = arg;
     c->func = func;
-    if (ret) {
-        c->rets = ret;
-    } else {
-        c->rets = NULL;
-    }
-    c->current_execute++;
-    pthread_cond_broadcast(&c->current_job_cond);
-
-    thread_park_workers(c, avctx->thread_count);
+    c->rets = ret;
 
+    avpriv_slicethread_execute(c->thread, job_count, !!c->mainfunc  );
     return 0;
 }
 
@@ -176,11 +118,19 @@ static int thread_execute2(AVCodecContext *avctx, action_func2* func2, void *arg
     return thread_execute(avctx, NULL, arg, ret, job_count, 0);
 }
 
+int ff_slice_thread_execute_with_mainfunc(AVCodecContext *avctx, action_func2* func2, main_func *mainfunc, void *arg, int *ret, int job_count)
+{
+    SliceThreadContext *c = avctx->internal->thread_ctx;
+    c->func2 = func2;
+    c->mainfunc = mainfunc;
+    return thread_execute(avctx, NULL, arg, ret, job_count, 0);
+}
+
 int ff_slice_thread_init(AVCodecContext *avctx)
 {
-    int i;
     SliceThreadContext *c;
     int thread_count = avctx->thread_count;
+    static void (*mainfunc)(void *);
 
 #if HAVE_W32THREADS
     w32thread_init();
@@ -208,35 +158,17 @@ int ff_slice_thread_init(AVCodecContext *avctx)
         return 0;
     }
 
-    c = av_mallocz(sizeof(SliceThreadContext));
-    if (!c)
-        return -1;
-
-    c->workers = av_mallocz_array(thread_count, sizeof(pthread_t));
-    if (!c->workers) {
-        av_free(c);
-        return -1;
-    }
-
-    avctx->internal->thread_ctx = c;
-    c->current_job = 0;
-    c->job_count = 0;
-    c->job_size = 0;
-    c->done = 0;
-    pthread_cond_init(&c->current_job_cond, NULL);
-    pthread_cond_init(&c->last_job_cond, NULL);
-    pthread_mutex_init(&c->current_job_lock, NULL);
-    pthread_mutex_lock(&c->current_job_lock);
-    for (i=0; i<thread_count; i++) {
-        if(pthread_create(&c->workers[i], NULL, worker, avctx)) {
-           avctx->thread_count = i;
-           pthread_mutex_unlock(&c->current_job_lock);
-           ff_thread_free(avctx);
-           return -1;
-        }
+    avctx->internal->thread_ctx = c = av_mallocz(sizeof(*c));
+    mainfunc = avctx->codec->caps_internal & FF_CODEC_CAP_SLICE_THREAD_HAS_MF ? &main_function : NULL;
+    if (!c || (thread_count = avpriv_slicethread_create(&c->thread, avctx, worker_func, mainfunc, thread_count)) <= 1) {
+        if (c)
+            avpriv_slicethread_free(&c->thread);
+        av_freep(&avctx->internal->thread_ctx);
+        avctx->thread_count = 1;
+        avctx->active_thread_type = 0;
+        return 0;
     }
-
-    thread_park_workers(c, thread_count);
+    avctx->thread_count = thread_count;
 
     avctx->execute = thread_execute;
     avctx->execute2 = thread_execute2;
diff --git a/mythtv/external/FFmpeg/libavcodec/put_bits.h b/mythtv/external/FFmpeg/libavcodec/put_bits.h
index 68ed3911957..1ceb1cc7662 100644
--- a/mythtv/external/FFmpeg/libavcodec/put_bits.h
+++ b/mythtv/external/FFmpeg/libavcodec/put_bits.h
@@ -119,6 +119,18 @@ static inline void flush_put_bits(PutBitContext *s)
     s->bit_buf  = 0;
 }
 
+static inline void flush_put_bits_le(PutBitContext *s)
+{
+    while (s->bit_left < 32) {
+        av_assert0(s->buf_ptr < s->buf_end);
+        *s->buf_ptr++ = s->bit_buf;
+        s->bit_buf  >>= 8;
+        s->bit_left  += 8;
+    }
+    s->bit_left = 32;
+    s->bit_buf  = 0;
+}
+
 #ifdef BITSTREAM_WRITER_LE
 #define avpriv_align_put_bits align_put_bits_unsupported_here
 #define avpriv_put_string ff_put_string_unsupported_here
@@ -197,6 +209,34 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
     s->bit_left = bit_left;
 }
 
+static inline void put_bits_le(PutBitContext *s, int n, unsigned int value)
+{
+    unsigned int bit_buf;
+    int bit_left;
+
+    av_assert2(n <= 31 && value < (1U << n));
+
+    bit_buf  = s->bit_buf;
+    bit_left = s->bit_left;
+
+    bit_buf |= value << (32 - bit_left);
+    if (n >= bit_left) {
+        if (3 < s->buf_end - s->buf_ptr) {
+            AV_WL32(s->buf_ptr, bit_buf);
+            s->buf_ptr += 4;
+        } else {
+            av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
+            av_assert2(0);
+        }
+        bit_buf     = value >> bit_left;
+        bit_left   += 32;
+    }
+    bit_left -= n;
+
+    s->bit_buf  = bit_buf;
+    s->bit_left = bit_left;
+}
+
 static inline void put_sbits(PutBitContext *pb, int n, int32_t value)
 {
     av_assert2(n >= 0 && n <= 31);
@@ -209,15 +249,72 @@ static inline void put_sbits(PutBitContext *pb, int n, int32_t value)
  */
 static void av_unused put_bits32(PutBitContext *s, uint32_t value)
 {
-    int lo = value & 0xffff;
-    int hi = value >> 16;
+    unsigned int bit_buf;
+    int bit_left;
+
+    bit_buf  = s->bit_buf;
+    bit_left = s->bit_left;
+
 #ifdef BITSTREAM_WRITER_LE
-    put_bits(s, 16, lo);
-    put_bits(s, 16, hi);
+    bit_buf |= value << (32 - bit_left);
+    if (3 < s->buf_end - s->buf_ptr) {
+        AV_WL32(s->buf_ptr, bit_buf);
+        s->buf_ptr += 4;
+    } else {
+        av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
+        av_assert2(0);
+    }
+    bit_buf     = (uint64_t)value >> bit_left;
 #else
-    put_bits(s, 16, hi);
-    put_bits(s, 16, lo);
+    bit_buf     = (uint64_t)bit_buf << bit_left;
+    bit_buf    |= value >> (32 - bit_left);
+    if (3 < s->buf_end - s->buf_ptr) {
+        AV_WB32(s->buf_ptr, bit_buf);
+        s->buf_ptr += 4;
+    } else {
+        av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
+        av_assert2(0);
+    }
+    bit_buf     = value;
 #endif
+
+    s->bit_buf  = bit_buf;
+    s->bit_left = bit_left;
+}
+
+/**
+ * Write up to 64 bits into a bitstream.
+ */
+static inline void put_bits64(PutBitContext *s, int n, uint64_t value)
+{
+    av_assert2((n == 64) || (n < 64 && value < (UINT64_C(1) << n)));
+
+    if (n < 32)
+        put_bits(s, n, value);
+    else if (n == 32)
+        put_bits32(s, value);
+    else if (n < 64) {
+        uint32_t lo = value & 0xffffffff;
+        uint32_t hi = value >> 32;
+#ifdef BITSTREAM_WRITER_LE
+        put_bits32(s, lo);
+        put_bits(s, n - 32, hi);
+#else
+        put_bits(s, n - 32, hi);
+        put_bits32(s, lo);
+#endif
+    } else {
+        uint32_t lo = value & 0xffffffff;
+        uint32_t hi = value >> 32;
+#ifdef BITSTREAM_WRITER_LE
+        put_bits32(s, lo);
+        put_bits32(s, hi);
+#else
+        put_bits32(s, hi);
+        put_bits32(s, lo);
+#endif
+
+    }
 }
 
 /**
diff --git a/mythtv/external/FFmpeg/libavcodec/qdm2.c b/mythtv/external/FFmpeg/libavcodec/qdm2.c
index e3cc902f456..88b6b19d112 100644
--- a/mythtv/external/FFmpeg/libavcodec/qdm2.c
+++ b/mythtv/external/FFmpeg/libavcodec/qdm2.c
@@ -40,6 +40,7 @@
 #define BITSTREAM_READER_LE
 #include "avcodec.h"
 #include "get_bits.h"
+#include "bytestream.h"
 #include "internal.h"
 #include "mpegaudio.h"
 #include "mpegaudiodsp.h"
@@ -1605,9 +1606,8 @@ static av_cold void qdm2_init_static_data(void) {
 static av_cold int qdm2_decode_init(AVCodecContext *avctx)
 {
     QDM2Context *s = avctx->priv_data;
-    uint8_t *extradata;
-    int extradata_size;
     int tmp_val, tmp, size;
+    GetByteContext gb;
 
     qdm2_init_static_data();
 
@@ -1650,55 +1650,39 @@ static av_cold int qdm2_decode_init(AVCodecContext *avctx)
         return AVERROR_INVALIDDATA;
     }
 
-    extradata      = avctx->extradata;
-    extradata_size = avctx->extradata_size;
+    bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
 
-    while (extradata_size > 7) {
-        if (!memcmp(extradata, "frmaQDM", 7))
+    while (bytestream2_get_bytes_left(&gb) > 8) {
+        if (bytestream2_peek_be64(&gb) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |
+                                            (uint64_t)MKBETAG('Q','D','M','2')))
             break;
-        extradata++;
-        extradata_size--;
+        bytestream2_skip(&gb, 1);
     }
 
-    if (extradata_size < 12) {
+    if (bytestream2_get_bytes_left(&gb) < 12) {
         av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
-               extradata_size);
+               bytestream2_get_bytes_left(&gb));
         return AVERROR_INVALIDDATA;
     }
 
-    if (memcmp(extradata, "frmaQDM", 7)) {
-        av_log(avctx, AV_LOG_ERROR, "invalid headers, QDM? not found\n");
-        return AVERROR_INVALIDDATA;
-    }
-
-    if (extradata[7] == 'C') {
-//        s->is_qdmc = 1;
-        avpriv_report_missing_feature(avctx, "QDMC version 1");
-        return AVERROR_PATCHWELCOME;
-    }
-
-    extradata += 8;
-    extradata_size -= 8;
+    bytestream2_skip(&gb, 8);
+    size = bytestream2_get_be32(&gb);
 
-    size = AV_RB32(extradata);
-
-    if(size > extradata_size){
+    if (size > bytestream2_get_bytes_left(&gb)) {
         av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
-               extradata_size, size);
+               bytestream2_get_bytes_left(&gb), size);
         return AVERROR_INVALIDDATA;
     }
 
-    extradata += 4;
     av_log(avctx, AV_LOG_DEBUG, "size: %d\n", size);
-    if (AV_RB32(extradata) != MKBETAG('Q','D','C','A')) {
+    if (bytestream2_get_be32(&gb) != MKBETAG('Q','D','C','A')) {
         av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
         return AVERROR_INVALIDDATA;
     }
 
-    extradata += 8;
+    bytestream2_skip(&gb, 4);
 
-    avctx->channels = s->nb_channels = s->channels = AV_RB32(extradata);
-    extradata += 4;
+    avctx->channels = s->nb_channels = s->channels = bytestream2_get_be32(&gb);
     if (s->channels <= 0 || s->channels > MPA_MAX_CHANNELS) {
         av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
         return AVERROR_INVALIDDATA;
@@ -1706,19 +1690,11 @@ static av_cold int qdm2_decode_init(AVCodecContext *avctx)
     avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :
                                                    AV_CH_LAYOUT_MONO;
 
-    avctx->sample_rate = AV_RB32(extradata);
-    extradata += 4;
-
-    avctx->bit_rate = AV_RB32(extradata);
-    extradata += 4;
-
-    s->group_size = AV_RB32(extradata);
-    extradata += 4;
-
-    s->fft_size = AV_RB32(extradata);
-    extradata += 4;
-
-    s->checksum_size = AV_RB32(extradata);
+    avctx->sample_rate = bytestream2_get_be32(&gb);
+    avctx->bit_rate = bytestream2_get_be32(&gb);
+    s->group_size = bytestream2_get_be32(&gb);
+    s->fft_size = bytestream2_get_be32(&gb);
+    s->checksum_size = bytestream2_get_be32(&gb);
     if (s->checksum_size >= 1U << 28) {
         av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);
         return AVERROR_INVALIDDATA;
diff --git a/mythtv/external/FFmpeg/libavcodec/qdmc.c b/mythtv/external/FFmpeg/libavcodec/qdmc.c
new file mode 100644
index 00000000000..1c8952b97be
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/qdmc.c
@@ -0,0 +1,783 @@
+/*
+ * QDMC compatible decoder
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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 <math.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#define BITSTREAM_READER_LE
+
+#include "libavutil/channel_layout.h"
+
+#include "avcodec.h"
+#include "bytestream.h"
+#include "get_bits.h"
+#include "internal.h"
+#include "fft.h"
+
+typedef struct QDMCTone {
+    uint8_t mode;
+    uint8_t phase;
+    uint8_t offset;
+    int16_t freq;
+    int16_t amplitude;
+} QDMCTone;
+
+typedef struct QDMCContext {
+    AVCodecContext *avctx;
+
+    uint8_t frame_bits;
+    int band_index;
+    int frame_size;
+    int subframe_size;
+    int fft_offset;
+    int buffer_offset;
+    int nb_channels;
+    int checksum_size;
+
+    uint8_t noise[2][19][17];
+    QDMCTone tones[5][8192];
+    int nb_tones[5];
+    int cur_tone[5];
+    float alt_sin[5][31];
+    float fft_buffer[4][8192 * 2];
+    float noise2_buffer[4096 * 2];
+    float noise_buffer[4096 * 2];
+    float buffer[2 * 32768];
+    float *buffer_ptr;
+    int rndval;
+
+    DECLARE_ALIGNED(32, FFTComplex, cmplx)[2][512];
+    FFTContext fft_ctx;
+} QDMCContext;
+
+static float sin_table[512];
+static VLC vtable[6];
+
+static const unsigned code_prefix[] = {
+    0x0, 0x1, 0x2, 0x3, 0x4, 0x6, 0x8, 0xA,
+    0xC, 0x10, 0x14, 0x18, 0x1C, 0x24, 0x2C, 0x34,
+    0x3C, 0x4C, 0x5C, 0x6C, 0x7C, 0x9C, 0xBC, 0xDC,
+    0xFC, 0x13C, 0x17C, 0x1BC, 0x1FC, 0x27C, 0x2FC, 0x37C,
+    0x3FC, 0x4FC, 0x5FC, 0x6FC, 0x7FC, 0x9FC, 0xBFC, 0xDFC,
+    0xFFC, 0x13FC, 0x17FC, 0x1BFC, 0x1FFC, 0x27FC, 0x2FFC, 0x37FC,
+    0x3FFC, 0x4FFC, 0x5FFC, 0x6FFC, 0x7FFC, 0x9FFC, 0xBFFC, 0xDFFC,
+    0xFFFC, 0x13FFC, 0x17FFC, 0x1BFFC, 0x1FFFC, 0x27FFC, 0x2FFFC, 0x37FFC,
+    0x3FFFC
+};
+
+static const float amplitude_tab[64] = {
+    1.18750000f, 1.68359380f, 2.37500000f, 3.36718750f, 4.75000000f,
+    6.73437500f, 9.50000000f, 13.4687500f, 19.0000000f, 26.9375000f,
+    38.0000000f, 53.8750000f, 76.0000000f, 107.750000f, 152.000000f,
+    215.500000f, 304.000000f, 431.000000f, 608.000000f, 862.000000f,
+    1216.00000f, 1724.00000f, 2432.00000f, 3448.00000f, 4864.00000f,
+    6896.00000f, 9728.00000f, 13792.0000f, 19456.0000f, 27584.0000f,
+    38912.0000f, 55168.0000f, 77824.0000f, 110336.000f, 155648.000f,
+    220672.000f, 311296.000f, 441344.000f, 622592.000f, 882688.000f,
+    1245184.00f, 1765376.00f, 2490368.00f, 3530752.00f, 4980736.00f,
+    7061504.00f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static const uint16_t qdmc_nodes[112] = {
+    0, 1, 2, 4, 6, 8, 12, 16, 24, 32, 48, 56, 64,
+    80, 96, 120, 144, 176, 208, 240, 256,
+    0, 2, 4, 8, 16, 24, 32, 48, 56, 64, 80, 104,
+    128, 160, 208, 256, 0, 0, 0, 0, 0,
+    0, 2, 4, 8, 16, 32, 48, 64, 80, 112, 160, 208,
+    256, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 4, 8, 16, 32, 48, 64, 96, 144, 208, 256,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 4, 16, 32, 64, 256, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+static const uint8_t noise_bands_size[] = {
+    19, 14, 11, 9, 4, 2, 0
+};
+
+static const uint8_t noise_bands_selector[] = {
+    4, 3, 2, 1, 0, 0, 0,
+};
+
+static const uint8_t noise_value_bits[] = {
+    12, 7, 9, 7, 10, 9, 11, 9, 9, 2, 9, 9, 9, 9,
+    9, 3, 9, 10, 10, 12, 2, 3, 3, 5, 5, 6, 7,
+};
+
+static const uint8_t noise_value_symbols[] = {
+    0, 10, 11, 12, 13, 14, 15, 16, 18, 1, 20, 22, 24,
+    26, 28, 2, 30, 32, 34, 36, 3, 4, 5, 6, 7, 8, 9,
+};
+
+static const uint16_t noise_value_codes[] = {
+    0xC7A, 0x002, 0x0FA, 0x03A, 0x35A, 0x1C2, 0x07A, 0x1FA,
+    0x17A, 0x000, 0x0DA, 0x142, 0x0C2, 0x042, 0x1DA, 0x001,
+    0x05A, 0x15A, 0x27A, 0x47A, 0x003, 0x005, 0x006, 0x012,
+    0x00A, 0x022, 0x01A,
+};
+
+static const uint8_t noise_segment_length_bits[] = {
+    10, 8, 5, 1, 2, 4, 4, 4, 6, 7, 9, 10,
+};
+
+static const uint8_t noise_segment_length_symbols[] = {
+    0, 13, 17, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+};
+
+static const uint16_t noise_segment_length_codes[] = {
+    0x30B, 0x8B, 0x1B, 0x0, 0x1, 0x3, 0x7, 0xF, 0x2b, 0x4B, 0xB, 0x10B,
+};
+
+static const uint8_t freq_diff_bits[] = {
+    18, 2, 4, 4, 5, 4, 4, 5, 5, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 6,
+    7, 6, 6, 6, 7, 7, 7, 7, 7, 8, 9, 9, 8, 9, 11, 11, 12, 12, 13, 12,
+    14, 15, 18, 16, 17,
+};
+
+static const uint32_t freq_diff_codes[] = {
+    0x2AD46, 0x1, 0x0, 0x3, 0xC, 0xA, 0x7, 0x18, 0x12, 0xE, 0x4, 0x16,
+    0xF, 0x1C, 0x8, 0x22, 0x26, 0x2, 0x3B, 0x34, 0x74, 0x1F, 0x14, 0x2B,
+    0x1B, 0x3F, 0x28, 0x54, 0x6, 0x4B, 0xB, 0x68, 0xE8, 0x46, 0xC6, 0x1E8,
+    0x146, 0x346, 0x546, 0x746, 0x1D46, 0xF46, 0xD46, 0x6D46, 0xAD46, 0x2D46,
+    0x1AD46,
+};
+
+static const uint8_t amplitude_bits[] = {
+    13, 7, 8, 9, 10, 10, 10, 10, 10, 9, 8, 7, 6,
+    5, 4, 3, 3, 2, 3, 3, 4, 5, 7, 8, 9, 11, 12, 13,
+};
+
+static const uint16_t amplitude_codes[] = {
+    0x1EC6, 0x6, 0xC2, 0x142, 0x242, 0x246, 0xC6, 0x46, 0x42, 0x146, 0xA2,
+    0x62, 0x26, 0x16, 0xE, 0x5, 0x4, 0x3, 0x0, 0x1, 0xA, 0x12, 0x2, 0x22,
+    0x1C6, 0x2C6, 0x6C6, 0xEC6,
+};
+
+static const uint8_t amplitude_diff_bits[] = {
+    8, 2, 1, 3, 4, 5, 6, 7, 8,
+};
+
+static const uint8_t amplitude_diff_codes[] = {
+    0xFE, 0x0, 0x1, 0x2, 0x6, 0xE, 0x1E, 0x3E, 0x7E,
+};
+
+static const uint8_t phase_diff_bits[] = {
+    6, 2, 2, 4, 4, 6, 5, 4, 2,
+};
+
+static const uint8_t phase_diff_codes[] = {
+    0x35, 0x2, 0x0, 0x1, 0xD, 0x15, 0x5, 0x9, 0x3,
+};
+
+#define INIT_VLC_STATIC_LE(vlc, nb_bits, nb_codes,                 \
+                           bits, bits_wrap, bits_size,             \
+                           codes, codes_wrap, codes_size,          \
+                           symbols, symbols_wrap, symbols_size,    \
+                           static_size)                            \
+    do {                                                           \
+        static VLC_TYPE table[static_size][2];                     \
+        (vlc)->table           = table;                            \
+        (vlc)->table_allocated = static_size;                      \
+        ff_init_vlc_sparse(vlc, nb_bits, nb_codes,                 \
+                           bits, bits_wrap, bits_size,             \
+                           codes, codes_wrap, codes_size,          \
+                           symbols, symbols_wrap, symbols_size,    \
+                           INIT_VLC_LE | INIT_VLC_USE_NEW_STATIC); \
+    } while (0)
+
+static av_cold void qdmc_init_static_data(AVCodec *codec)
+{
+    int i;
+
+    INIT_VLC_STATIC_LE(&vtable[0], 12, FF_ARRAY_ELEMS(noise_value_bits),
+                       noise_value_bits, 1, 1, noise_value_codes, 2, 2, noise_value_symbols, 1, 1, 4096);
+    INIT_VLC_STATIC_LE(&vtable[1], 10, FF_ARRAY_ELEMS(noise_segment_length_bits),
+                       noise_segment_length_bits, 1, 1, noise_segment_length_codes, 2, 2,
+                       noise_segment_length_symbols, 1, 1, 1024);
+    INIT_VLC_STATIC_LE(&vtable[2], 13, FF_ARRAY_ELEMS(amplitude_bits),
+                       amplitude_bits, 1, 1, amplitude_codes, 2, 2, NULL, 0, 0, 8192);
+    INIT_VLC_STATIC_LE(&vtable[3], 18, FF_ARRAY_ELEMS(freq_diff_bits),
+                       freq_diff_bits, 1, 1, freq_diff_codes, 4, 4, NULL, 0, 0, 262144);
+    INIT_VLC_STATIC_LE(&vtable[4], 8, FF_ARRAY_ELEMS(amplitude_diff_bits),
+                       amplitude_diff_bits, 1, 1, amplitude_diff_codes, 1, 1, NULL, 0, 0, 256);
+    INIT_VLC_STATIC_LE(&vtable[5], 6, FF_ARRAY_ELEMS(phase_diff_bits),
+                       phase_diff_bits, 1, 1, phase_diff_codes, 1, 1, NULL, 0, 0, 64);
+
+    for (i = 0; i < 512; i++)
+        sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);
+}
+
+static void make_noises(QDMCContext *s)
+{
+    int i, j, n0, n1, n2, diff;
+    float *nptr;
+
+    for (j = 0; j < noise_bands_size[s->band_index]; j++) {
+        n0 = qdmc_nodes[j + 21 * s->band_index    ];
+        n1 = qdmc_nodes[j + 21 * s->band_index + 1];
+        n2 = qdmc_nodes[j + 21 * s->band_index + 2];
+        nptr = s->noise_buffer + 256 * j;
+
+        for (i = 0; i + n0 < n1; i++, nptr++)
+            nptr[0] = i / (float)(n1 - n0);
+
+        diff = n2 - n1;
+        nptr = s->noise_buffer + (j << 8) + n1 - n0;
+
+        for (i = n1; i < n2; i++, nptr++, diff--)
+            nptr[0] = diff / (float)(n2 - n1);
+    }
+}
+
+static av_cold int qdmc_decode_init(AVCodecContext *avctx)
+{
+    QDMCContext *s = avctx->priv_data;
+    int fft_size, fft_order, size, g, j, x;
+    GetByteContext b;
+
+    if (!avctx->extradata || (avctx->extradata_size < 48)) {
+        av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    bytestream2_init(&b, avctx->extradata, avctx->extradata_size);
+
+    while (bytestream2_get_bytes_left(&b) > 8) {
+        if (bytestream2_peek_be64(&b) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |
+                                           (uint64_t)MKBETAG('Q','D','M','C')))
+            break;
+        bytestream2_skipu(&b, 1);
+    }
+    bytestream2_skipu(&b, 8);
+
+    if (bytestream2_get_bytes_left(&b) < 36) {
+        av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
+               bytestream2_get_bytes_left(&b));
+        return AVERROR_INVALIDDATA;
+    }
+
+    size = bytestream2_get_be32u(&b);
+    if (size > bytestream2_get_bytes_left(&b)) {
+        av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
+               bytestream2_get_bytes_left(&b), size);
+        return AVERROR_INVALIDDATA;
+    }
+
+    if (bytestream2_get_be32u(&b) != MKBETAG('Q','D','C','A')) {
+        av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
+        return AVERROR_INVALIDDATA;
+    }
+    bytestream2_skipu(&b, 4);
+
+    avctx->channels = s->nb_channels = bytestream2_get_be32u(&b);
+    if (s->nb_channels <= 0 || s->nb_channels > 2) {
+        av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
+        return AVERROR_INVALIDDATA;
+    }
+    avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :
+                                                   AV_CH_LAYOUT_MONO;
+
+    avctx->sample_rate = bytestream2_get_be32u(&b);
+    avctx->bit_rate = bytestream2_get_be32u(&b);
+    bytestream2_skipu(&b, 4);
+    fft_size = bytestream2_get_be32u(&b);
+    fft_order = av_log2(fft_size) + 1;
+    s->checksum_size = bytestream2_get_be32u(&b);
+    if (s->checksum_size >= 1U << 28) {
+        av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);
+        return AVERROR_INVALIDDATA;
+    }
+
+    if (avctx->sample_rate >= 32000) {
+        x = 28000;
+        s->frame_bits = 13;
+    } else if (avctx->sample_rate >= 16000) {
+        x = 20000;
+        s->frame_bits = 12;
+    } else {
+        x = 16000;
+        s->frame_bits = 11;
+    }
+    s->frame_size = 1 << s->frame_bits;
+    s->subframe_size = s->frame_size >> 5;
+
+    if (avctx->channels == 2)
+        x = 3 * x / 2;
+    s->band_index = noise_bands_selector[FFMIN(6, llrint(floor(avctx->bit_rate * 3.0 / (double)x + 0.5)))];
+
+    if ((fft_order < 7) || (fft_order > 9)) {
+        avpriv_request_sample(avctx, "Unknown FFT order %d", fft_order);
+        return AVERROR_PATCHWELCOME;
+    }
+
+    if (fft_size != (1 << (fft_order - 1))) {
+        av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", fft_size);
+        return AVERROR_INVALIDDATA;
+    }
+
+    ff_fft_init(&s->fft_ctx, fft_order, 1);
+
+    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
+
+    for (g = 5; g > 0; g--) {
+        for (j = 0; j < (1 << g) - 1; j++)
+            s->alt_sin[5-g][j] = sin_table[(((j+1) << (8 - g)) & 0x1FF)];
+    }
+
+    make_noises(s);
+
+    return 0;
+}
+
+static av_cold int qdmc_decode_close(AVCodecContext *avctx)
+{
+    QDMCContext *s = avctx->priv_data;
+
+    ff_fft_end(&s->fft_ctx);
+
+    return 0;
+}
+
+static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
+{
+    int v;
+
+    v = get_vlc2(gb, table->table, table->bits, 1);
+    if (v < 0)
+        return AVERROR_INVALIDDATA;
+    if (v)
+        v = v - 1;
+    else
+        v = get_bits(gb, get_bits(gb, 3) + 1);
+
+    if (flag) {
+        if (v >= FF_ARRAY_ELEMS(code_prefix))
+            return AVERROR_INVALIDDATA;
+
+        v = code_prefix[v] + get_bitsz(gb, v >> 2);
+    }
+
+    return v;
+}
+
+static int skip_label(QDMCContext *s, GetBitContext *gb)
+{
+    uint32_t label = get_bits_long(gb, 32);
+    uint16_t sum = 226, checksum = get_bits(gb, 16);
+    const uint8_t *ptr = gb->buffer + 6;
+    int i;
+
+    if (label != MKTAG('Q', 'M', 'C', 1))
+        return AVERROR_INVALIDDATA;
+
+    for (i = 0; i < s->checksum_size - 6; i++)
+        sum += ptr[i];
+
+    return sum != checksum;
+}
+
+static int read_noise_data(QDMCContext *s, GetBitContext *gb)
+{
+    int ch, j, k, v, idx, band, lastval, newval, len;
+
+    for (ch = 0; ch < s->nb_channels; ch++) {
+        for (band = 0; band < noise_bands_size[s->band_index]; band++) {
+            v = qdmc_get_vlc(gb, &vtable[0], 0);
+            if (v < 0)
+                return AVERROR_INVALIDDATA;
+
+            if (v & 1)
+                v = v + 1;
+            else
+                v = -v;
+
+            lastval = v / 2;
+            s->noise[ch][band][0] = lastval - 1;
+            for (j = 0; j < 15;) {
+                len = qdmc_get_vlc(gb, &vtable[1], 1);
+                if (len < 0)
+                    return AVERROR_INVALIDDATA;
+                len += 1;
+
+                v = qdmc_get_vlc(gb, &vtable[0], 0);
+                if (v < 0)
+                    return AVERROR_INVALIDDATA;
+
+                if (v & 1)
+                    newval = lastval + (v + 1) / 2;
+                else
+                    newval = lastval - v / 2;
+
+                idx = j + 1;
+                if (len + idx > 16)
+                    return AVERROR_INVALIDDATA;
+
+                for (k = 1; idx <= j + len; k++, idx++)
+                    s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;
+
+                lastval = newval;
+                j += len;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
+{
+    const int index = s->nb_tones[group];
+
+    if (index >= FF_ARRAY_ELEMS(s->tones[group])) {
+        av_log(s->avctx, AV_LOG_WARNING, "Too many tones already in buffer, ignoring tone!\n");
+        return;
+    }
+
+    s->tones[group][index].offset    = offset;
+    s->tones[group][index].freq      = freq;
+    s->tones[group][index].mode      = stereo_mode;
+    s->tones[group][index].amplitude = amplitude;
+    s->tones[group][index].phase     = phase;
+    s->nb_tones[group]++;
+}
+
+static int read_wave_data(QDMCContext *s, GetBitContext *gb)
+{
+    int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;
+    int amp2, phase2, pos2, off;
+
+    for (group = 0; group < 5; group++) {
+        group_size = 1 << (s->frame_bits - group - 1);
+        group_bits = 4 - group;
+        pos2 = 0;
+        off  = 0;
+
+        for (i = 1; ; i = freq + 1) {
+            int v;
+
+            v = qdmc_get_vlc(gb, &vtable[3], 1);
+            if (v < 0)
+                return AVERROR_INVALIDDATA;
+
+            freq = i + v;
+            while (freq >= group_size - 1) {
+                freq += 2 - group_size;
+                pos2 += group_size;
+                off  += 1 << group_bits;
+            }
+
+            if (pos2 >= s->frame_size)
+                break;
+
+            if (s->nb_channels > 1)
+                stereo_mode = get_bits(gb, 2);
+
+            amp   = qdmc_get_vlc(gb, &vtable[2], 0);
+            if (amp < 0)
+                return AVERROR_INVALIDDATA;
+            phase = get_bits(gb, 3);
+
+            if (stereo_mode > 1) {
+                amp2   = qdmc_get_vlc(gb, &vtable[4], 0);
+                if (amp2 < 0)
+                    return AVERROR_INVALIDDATA;
+                amp2   = amp - amp2;
+
+                phase2 = qdmc_get_vlc(gb, &vtable[5], 0);
+                if (phase2 < 0)
+                    return AVERROR_INVALIDDATA;
+                phase2 = phase - phase2;
+
+                if (phase2 < 0)
+                    phase2 += 8;
+            }
+
+            if ((freq >> group_bits) + 1 < s->subframe_size) {
+                add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);
+                if (stereo_mode > 1)
+                    add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);
+            }
+        }
+    }
+
+    return 0;
+}
+
+static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
+{
+    int subframe_size, i, j, k, length;
+    float scale, *noise_ptr;
+
+    scale = 0.5 * amplitude;
+    subframe_size = s->subframe_size;
+    if (subframe_size >= node2)
+        subframe_size = node2;
+    length = (subframe_size - node1) & 0xFFFC;
+    j = node1;
+    noise_ptr = &s->noise_buffer[256 * index];
+
+    for (i = 0; i < length; i += 4, j+= 4, noise_ptr += 4) {
+        s->noise2_buffer[j    ] += scale * noise_ptr[0];
+        s->noise2_buffer[j + 1] += scale * noise_ptr[1];
+        s->noise2_buffer[j + 2] += scale * noise_ptr[2];
+        s->noise2_buffer[j + 3] += scale * noise_ptr[3];
+    }
+
+    k = length + node1;
+    noise_ptr = s->noise_buffer + length + (index << 8);
+    for (i = length; i < subframe_size - node1; i++, k++, noise_ptr++)
+        s->noise2_buffer[k] += scale * noise_ptr[0];
+}
+
+static void add_noise(QDMCContext *s, int ch, int current_subframe)
+{
+    int i, j, aindex;
+    float amplitude;
+    float *im = &s->fft_buffer[0 + ch][s->fft_offset + s->subframe_size * current_subframe];
+    float *re = &s->fft_buffer[2 + ch][s->fft_offset + s->subframe_size * current_subframe];
+
+    memset(s->noise2_buffer, 0, 4 * s->subframe_size);
+
+    for (i = 0; i < noise_bands_size[s->band_index]; i++) {
+        if (qdmc_nodes[i + 21 * s->band_index] > s->subframe_size - 1)
+            break;
+
+        aindex = s->noise[ch][i][current_subframe / 2];
+        amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;
+
+        lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],
+                 qdmc_nodes[21 * s->band_index + i + 2], i);
+    }
+
+    for (j = 2; j < s->subframe_size - 1; j++) {
+        float rnd_re, rnd_im;
+
+        s->rndval = 214013 * s->rndval + 2531011;
+        rnd_im = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
+        s->rndval = 214013 * s->rndval + 2531011;
+        rnd_re = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
+        im[j  ] += rnd_im;
+        re[j  ] += rnd_re;
+        im[j+1] -= rnd_im;
+        re[j+1] -= rnd_re;
+    }
+}
+
+static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
+{
+    int j, group_bits, pos, pindex;
+    float im, re, amplitude, level, *imptr, *reptr;
+
+    if (s->nb_channels == 1)
+        stereo_mode = 0;
+
+    group_bits = 4 - group;
+    pos = freqs >> (4 - group);
+    amplitude = amplitude_tab[amp & 0x3F];
+    imptr = &s->fft_buffer[    stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
+    reptr = &s->fft_buffer[2 + stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
+    pindex = (phase << 6) - ((2 * (freqs >> (4 - group)) + 1) << 7);
+    for (j = 0; j < (1 << (group_bits + 1)) - 1; j++) {
+        pindex += (2 * freqs + 1) << (7 - group_bits);
+        level = amplitude * s->alt_sin[group][j];
+        im = level * sin_table[ pindex        & 0x1FF];
+        re = level * sin_table[(pindex + 128) & 0x1FF];
+        imptr[0] += im;
+        imptr[1] -= im;
+        reptr[0] += re;
+        reptr[1] -= re;
+        imptr += s->subframe_size;
+        reptr += s->subframe_size;
+        if (imptr >= &s->fft_buffer[stereo_mode][2 * s->frame_size]) {
+            imptr = &s->fft_buffer[0 + stereo_mode][pos];
+            reptr = &s->fft_buffer[2 + stereo_mode][pos];
+        }
+    }
+}
+
+static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
+{
+    float level, im, re;
+    int pos;
+
+    if (s->nb_channels == 1)
+        stereo_mode = 0;
+
+    level = amplitude_tab[amp & 0x3F];
+    im = level * sin_table[ (phase << 6)        & 0x1FF];
+    re = level * sin_table[((phase << 6) + 128) & 0x1FF];
+    pos = s->fft_offset + freqs + s->subframe_size * offset;
+    s->fft_buffer[    stereo_mode][pos    ] += im;
+    s->fft_buffer[2 + stereo_mode][pos    ] += re;
+    s->fft_buffer[    stereo_mode][pos + 1] -= im;
+    s->fft_buffer[2 + stereo_mode][pos + 1] -= re;
+}
+
+static void add_waves(QDMCContext *s, int current_subframe)
+{
+    int w, g;
+
+    for (g = 0; g < 4; g++) {
+        for (w = s->cur_tone[g]; w < s->nb_tones[g]; w++) {
+            QDMCTone *t = &s->tones[g][w];
+
+            if (current_subframe < t->offset)
+                break;
+            add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);
+        }
+        s->cur_tone[g] = w;
+    }
+    for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {
+        QDMCTone *t = &s->tones[4][w];
+
+        if (current_subframe < t->offset)
+            break;
+        add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);
+    }
+    s->cur_tone[4] = w;
+}
+
+static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
+{
+    int ret, ch, i, n;
+
+    if (skip_label(s, gb))
+        return AVERROR_INVALIDDATA;
+
+    s->fft_offset = s->frame_size - s->fft_offset;
+    s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];
+
+    ret = read_noise_data(s, gb);
+    if (ret < 0)
+        return ret;
+
+    ret = read_wave_data(s, gb);
+    if (ret < 0)
+        return ret;
+
+    for (n = 0; n < 32; n++) {
+        float *r;
+
+        for (ch = 0; ch < s->nb_channels; ch++)
+            add_noise(s, ch, n);
+
+        add_waves(s, n);
+
+        for (ch = 0; ch < s->nb_channels; ch++) {
+            for (i = 0; i < s->subframe_size; i++) {
+                s->cmplx[ch][i].re = s->fft_buffer[ch + 2][s->fft_offset + n * s->subframe_size + i];
+                s->cmplx[ch][i].im = s->fft_buffer[ch + 0][s->fft_offset + n * s->subframe_size + i];
+                s->cmplx[ch][s->subframe_size + i].re = 0;
+                s->cmplx[ch][s->subframe_size + i].im = 0;
+            }
+        }
+
+        for (ch = 0; ch < s->nb_channels; ch++) {
+            s->fft_ctx.fft_permute(&s->fft_ctx, s->cmplx[ch]);
+            s->fft_ctx.fft_calc(&s->fft_ctx, s->cmplx[ch]);
+        }
+
+        r = &s->buffer_ptr[s->nb_channels * n * s->subframe_size];
+        for (i = 0; i < 2 * s->subframe_size; i++) {
+            for (ch = 0; ch < s->nb_channels; ch++) {
+                *r++ += s->cmplx[ch][i].re;
+            }
+        }
+
+        r = &s->buffer_ptr[n * s->subframe_size * s->nb_channels];
+        for (i = 0; i < s->nb_channels * s->subframe_size; i++) {
+            out[i] = av_clipf(r[i], INT16_MIN, INT16_MAX);
+        }
+        out += s->subframe_size * s->nb_channels;
+
+        for (ch = 0; ch < s->nb_channels; ch++) {
+            memset(s->fft_buffer[ch+0] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
+            memset(s->fft_buffer[ch+2] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
+        }
+        memset(s->buffer + s->nb_channels * (n * s->subframe_size + s->frame_size + s->buffer_offset), 0, 4 * s->subframe_size * s->nb_channels);
+    }
+
+    s->buffer_offset += s->frame_size;
+    if (s->buffer_offset >= 32768 - s->frame_size) {
+        memcpy(s->buffer, &s->buffer[s->nb_channels * s->buffer_offset], 4 * s->frame_size * s->nb_channels);
+        s->buffer_offset = 0;
+    }
+
+    return 0;
+}
+
+static av_cold void qdmc_flush(AVCodecContext *avctx)
+{
+    QDMCContext *s = avctx->priv_data;
+
+    memset(s->buffer, 0, sizeof(s->buffer));
+    memset(s->fft_buffer, 0, sizeof(s->fft_buffer));
+    s->fft_offset = 0;
+    s->buffer_offset = 0;
+}
+
+static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
+                             int *got_frame_ptr, AVPacket *avpkt)
+{
+    QDMCContext *s = avctx->priv_data;
+    AVFrame *frame = data;
+    GetBitContext gb;
+    int ret;
+
+    if (!avpkt->data)
+        return 0;
+    if (avpkt->size < s->checksum_size)
+        return AVERROR_INVALIDDATA;
+
+    s->avctx = avctx;
+    frame->nb_samples = s->frame_size;
+    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
+        return ret;
+
+    if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)
+        return ret;
+
+    memset(s->nb_tones, 0, sizeof(s->nb_tones));
+    memset(s->cur_tone, 0, sizeof(s->cur_tone));
+
+    ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);
+    if (ret >= 0) {
+        *got_frame_ptr = 1;
+        return s->checksum_size;
+    }
+    qdmc_flush(avctx);
+    return ret;
+}
+
+AVCodec ff_qdmc_decoder = {
+    .name             = "qdmc",
+    .long_name        = NULL_IF_CONFIG_SMALL("QDesign Music Codec 1"),
+    .type             = AVMEDIA_TYPE_AUDIO,
+    .id               = AV_CODEC_ID_QDMC,
+    .priv_data_size   = sizeof(QDMCContext),
+    .init             = qdmc_decode_init,
+    .init_static_data = qdmc_init_static_data,
+    .close            = qdmc_decode_close,
+    .decode           = qdmc_decode_frame,
+    .flush            = qdmc_flush,
+    .capabilities     = AV_CODEC_CAP_DR1,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/qdrw.c b/mythtv/external/FFmpeg/libavcodec/qdrw.c
index 828cfea3fd5..3a0bc6f760a 100644
--- a/mythtv/external/FFmpeg/libavcodec/qdrw.c
+++ b/mythtv/external/FFmpeg/libavcodec/qdrw.c
@@ -33,10 +33,13 @@
 #include "internal.h"
 
 enum QuickdrawOpcodes {
+    CLIP = 0x0001,
     PACKBITSRECT = 0x0098,
     PACKBITSRGN,
     DIRECTBITSRECT,
     DIRECTBITSRGN,
+    SHORTCOMMENT = 0x00A0,
+    LONGCOMMENT,
 
     EOP = 0x00FF,
 };
@@ -55,6 +58,8 @@ static int parse_palette(AVCodecContext *avctx, GetByteContext *gbc,
             bytestream2_skip(gbc, 6);
             continue;
         }
+        if (avctx->pix_fmt != AV_PIX_FMT_PAL8)
+            return AVERROR_INVALIDDATA;
         r = bytestream2_get_byte(gbc);
         bytestream2_skip(gbc, 1);
         g = bytestream2_get_byte(gbc);
@@ -66,6 +71,148 @@ static int parse_palette(AVCodecContext *avctx, GetByteContext *gbc,
     return 0;
 }
 
+static int decode_rle_bpp2(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc)
+{
+    int offset = avctx->width;
+    uint8_t *outdata = p->data[0];
+    int i, j;
+
+    for (i = 0; i < avctx->height; i++) {
+        int size, left, code, pix;
+        uint8_t *out = outdata;
+        int pos = 0;
+
+        /* size of packed line */
+        if (offset / 4 > 200)
+            size = left = bytestream2_get_be16(gbc);
+        else
+            size = left = bytestream2_get_byte(gbc);
+        if (bytestream2_get_bytes_left(gbc) < size)
+            return AVERROR_INVALIDDATA;
+
+        /* decode line */
+        while (left > 0) {
+            code = bytestream2_get_byte(gbc);
+            if (code & 0x80 ) { /* run */
+                pix = bytestream2_get_byte(gbc);
+                for (j = 0; j < 257 - code; j++) {
+                    if (pos < offset)
+                        out[pos++] = (pix & 0xC0) >> 6;
+                    if (pos < offset)
+                        out[pos++] = (pix & 0x30) >> 4;
+                    if (pos < offset)
+                        out[pos++] = (pix & 0x0C) >> 2;
+                    if (pos < offset)
+                        out[pos++] = (pix & 0x03);
+                }
+                left  -= 2;
+            } else { /* copy */
+                for (j = 0; j < code + 1; j++) {
+                    pix = bytestream2_get_byte(gbc);
+                    if (pos < offset)
+                        out[pos++] = (pix & 0xC0) >> 6;
+                    if (pos < offset)
+                        out[pos++] = (pix & 0x30) >> 4;
+                    if (pos < offset)
+                        out[pos++] = (pix & 0x0C) >> 2;
+                    if (pos < offset)
+                        out[pos++] = (pix & 0x03);
+                }
+                left  -= 1 + (code + 1);
+            }
+        }
+        outdata += p->linesize[0];
+    }
+    return 0;
+}
+
+static int decode_rle_bpp4(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc)
+{
+    int offset = avctx->width;
+    uint8_t *outdata = p->data[0];
+    int i, j;
+
+    for (i = 0; i < avctx->height; i++) {
+        int size, left, code, pix;
+        uint8_t *out = outdata;
+        int pos = 0;
+
+        /* size of packed line */
+        size = left = bytestream2_get_be16(gbc);
+        if (bytestream2_get_bytes_left(gbc) < size)
+            return AVERROR_INVALIDDATA;
+
+        /* decode line */
+        while (left > 0) {
+            code = bytestream2_get_byte(gbc);
+            if (code & 0x80 ) { /* run */
+                pix = bytestream2_get_byte(gbc);
+                for (j = 0; j < 257 - code; j++) {
+                    if (pos < offset)
+                        out[pos++] = (pix & 0xF0) >> 4;
+                    if (pos < offset)
+                        out[pos++] = pix & 0xF;
+                }
+                left  -= 2;
+            } else { /* copy */
+                for (j = 0; j < code + 1; j++) {
+                    pix = bytestream2_get_byte(gbc);
+                    if (pos < offset)
+                        out[pos++] = (pix & 0xF0) >> 4;
+                    if (pos < offset)
+                        out[pos++] = pix & 0xF;
+                }
+                left  -= 1 + (code + 1);
+            }
+        }
+        outdata += p->linesize[0];
+    }
+    return 0;
+}
+
+static int decode_rle16(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc)
+{
+    int offset = avctx->width;
+    uint8_t *outdata = p->data[0];
+    int i, j;
+
+    for (i = 0; i < avctx->height; i++) {
+        int size, left, code, pix;
+        uint16_t *out = (uint16_t *)outdata;
+        int pos = 0;
+
+        /* size of packed line */
+        size = left = bytestream2_get_be16(gbc);
+        if (bytestream2_get_bytes_left(gbc) < size)
+            return AVERROR_INVALIDDATA;
+
+        /* decode line */
+        while (left > 0) {
+            code = bytestream2_get_byte(gbc);
+            if (code & 0x80 ) { /* run */
+                pix = bytestream2_get_be16(gbc);
+                for (j = 0; j < 257 - code; j++) {
+                    if (pos < offset) {
+                        out[pos++] = pix;
+                    }
+                }
+                left  -= 3;
+            } else { /* copy */
+                for (j = 0; j < code + 1; j++) {
+                    if (pos < offset) {
+                        out[pos++] = bytestream2_get_be16(gbc);
+                    } else {
+                        bytestream2_skip(gbc, 2);
+                    }
+                }
+                left  -= 1 + (code + 1) * 2;
+            }
+        }
+        outdata += p->linesize[0];
+    }
+    return 0;
+}
+
 static int decode_rle(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc,
                       int step)
 {
@@ -89,26 +236,25 @@ static int decode_rle(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc,
             if (code & 0x80 ) { /* run */
                 pix = bytestream2_get_byte(gbc);
                 for (j = 0; j < 257 - code; j++) {
-                    out[pos] = pix;
+                    if (pos < offset)
+                        out[pos] = pix;
                     pos += step;
-                    if (pos >= offset) {
+                    if (pos >= offset && step > 1) {
                         pos -= offset;
                         pos++;
                     }
-                    if (pos >= offset)
-                        return AVERROR_INVALIDDATA;
                 }
                 left  -= 2;
             } else { /* copy */
                 for (j = 0; j < code + 1; j++) {
-                    out[pos] = bytestream2_get_byte(gbc);
+                    pix = bytestream2_get_byte(gbc);
+                    if (pos < offset)
+                        out[pos] = pix;
                     pos += step;
-                    if (pos >= offset) {
+                    if (pos >= offset && step > 1) {
                         pos -= offset;
                         pos++;
                     }
-                    if (pos >= offset)
-                        return AVERROR_INVALIDDATA;
                 }
                 left  -= 2 + code;
             }
@@ -192,6 +338,9 @@ static int decode_frame(AVCodecContext *avctx,
         int opcode = bytestream2_get_be16(&gbc);
 
         switch(opcode) {
+        case CLIP:
+            bytestream2_skip(&gbc, 10);
+            break;
         case PACKBITSRECT:
         case PACKBITSRGN:
             av_log(avctx, AV_LOG_DEBUG, "Parsing Packbit opcode\n");
@@ -203,6 +352,10 @@ static int decode_frame(AVCodecContext *avctx,
             av_log(avctx, AV_LOG_DEBUG, "bppcount %d bpp %d\n", bppcnt, bpp);
             if (bppcnt == 1 && bpp == 8) {
                 avctx->pix_fmt = AV_PIX_FMT_PAL8;
+            } else if (bppcnt == 1 && (bpp == 4 || bpp == 2)) {
+                avctx->pix_fmt = AV_PIX_FMT_PAL8;
+            } else if (bppcnt == 3 && bpp == 5) {
+                avctx->pix_fmt = AV_PIX_FMT_RGB555;
             } else {
                 av_log(avctx, AV_LOG_ERROR,
                        "Invalid pixel format (bppcnt %d bpp %d) in Packbit\n",
@@ -227,7 +380,9 @@ static int decode_frame(AVCodecContext *avctx,
             if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
                 return ret;
 
-            parse_palette(avctx, &gbc, (uint32_t *)p->data[1], colors);
+            ret = parse_palette(avctx, &gbc, (uint32_t *)p->data[1], colors);
+            if (ret < 0)
+                return ret;
             p->palette_has_changed = 1;
 
             /* jump to image data */
@@ -238,7 +393,14 @@ static int decode_frame(AVCodecContext *avctx,
                 avpriv_report_missing_feature(avctx, "Packbit mask region");
             }
 
-            ret = decode_rle(avctx, p, &gbc, bppcnt);
+            if (avctx->pix_fmt == AV_PIX_FMT_RGB555)
+                ret = decode_rle16(avctx, p, &gbc);
+            else if (bpp == 2)
+                ret = decode_rle_bpp2(avctx, p, &gbc);
+            else if (bpp == 4)
+                ret = decode_rle_bpp4(avctx, p, &gbc);
+            else
+                ret = decode_rle(avctx, p, &gbc, bppcnt);
             if (ret < 0)
                 return ret;
             *got_frame = 1;
@@ -254,7 +416,15 @@ static int decode_frame(AVCodecContext *avctx,
                 return AVERROR_PATCHWELCOME;
             }
 
-            bytestream2_skip(&gbc, 10);
+            bytestream2_skip(&gbc, 4);
+            h = bytestream2_get_be16(&gbc);
+            w = bytestream2_get_be16(&gbc);
+            bytestream2_skip(&gbc, 2);
+
+            ret = ff_set_dimensions(avctx, w, h);
+            if (ret < 0)
+                return ret;
+
             pack_type = bytestream2_get_be16(&gbc);
 
             bytestream2_skip(&gbc, 16);
@@ -264,6 +434,8 @@ static int decode_frame(AVCodecContext *avctx,
             av_log(avctx, AV_LOG_DEBUG, "bppcount %d bpp %d\n", bppcnt, bpp);
             if (bppcnt == 3 && bpp == 8) {
                 avctx->pix_fmt = AV_PIX_FMT_RGB24;
+            } else if (bppcnt == 3 && bpp == 5) {
+                avctx->pix_fmt = AV_PIX_FMT_RGB555;
             } else if (bppcnt == 4 && bpp == 8) {
                 avctx->pix_fmt = AV_PIX_FMT_ARGB;
             } else {
@@ -292,11 +464,18 @@ static int decode_frame(AVCodecContext *avctx,
                 avpriv_report_missing_feature(avctx, "DirectBit mask region");
             }
 
-            ret = decode_rle(avctx, p, &gbc, bppcnt);
+            if (avctx->pix_fmt == AV_PIX_FMT_RGB555)
+                ret = decode_rle16(avctx, p, &gbc);
+            else
+                ret = decode_rle(avctx, p, &gbc, bppcnt);
             if (ret < 0)
                 return ret;
             *got_frame = 1;
             break;
+        case LONGCOMMENT:
+            bytestream2_get_be16(&gbc);
+            bytestream2_skip(&gbc, bytestream2_get_be16(&gbc));
+            break;
         default:
             av_log(avctx, AV_LOG_TRACE, "Unknown 0x%04X opcode\n", opcode);
             break;
diff --git a/mythtv/external/FFmpeg/libavcodec/qpeg.c b/mythtv/external/FFmpeg/libavcodec/qpeg.c
index 9eaf9b8054b..e1210c19720 100644
--- a/mythtv/external/FFmpeg/libavcodec/qpeg.c
+++ b/mythtv/external/FFmpeg/libavcodec/qpeg.c
@@ -166,7 +166,7 @@ static void av_noinline qpeg_decode_inter(QpegContext *qctx, uint8_t *dst,
                     if ((me_x + filled < 0) || (me_x + me_w + filled > width) ||
                        (height - me_y - me_h < 0) || (height - me_y >= orig_height) ||
                        (filled + me_w > width) || (height - me_h < 0))
-                        av_log(NULL, AV_LOG_ERROR, "Bogus motion vector (%i,%i), block size %ix%i at %i,%i\n",
+                        av_log(qctx->avctx, AV_LOG_ERROR, "Bogus motion vector (%i,%i), block size %ix%i at %i,%i\n",
                                me_x, me_y, me_w, me_h, filled, height);
                     else {
                         /* do motion compensation */
@@ -260,7 +260,8 @@ static int decode_frame(AVCodecContext *avctx,
     AVFrame * const ref = a->ref;
     uint8_t* outdata;
     int delta, ret;
-    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
+    int pal_size;
+    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &pal_size);
 
     if (avpkt->size < 0x86) {
         av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
@@ -287,9 +288,11 @@ static int decode_frame(AVCodecContext *avctx,
     }
 
     /* make the palette available on the way out */
-    if (pal) {
+    if (pal && pal_size == AVPALETTE_SIZE) {
         p->palette_has_changed = 1;
         memcpy(a->pal, pal, AVPALETTE_SIZE);
+    } else if (pal) {
+        av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", pal_size);
     }
     memcpy(p->data[1], a->pal, AVPALETTE_SIZE);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/qsv.c b/mythtv/external/FFmpeg/libavcodec/qsv.c
index 11d453da85c..56ca9df262d 100644
--- a/mythtv/external/FFmpeg/libavcodec/qsv.c
+++ b/mythtv/external/FFmpeg/libavcodec/qsv.c
@@ -25,11 +25,19 @@
 #include <string.h>
 
 #include "libavutil/avstring.h"
+#include "libavutil/common.h"
 #include "libavutil/error.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_qsv.h"
+#include "libavutil/imgutils.h"
 
 #include "avcodec.h"
 #include "qsv_internal.h"
 
+#if QSV_VERSION_ATLEAST(1, 12)
+#include "mfx/mfxvp8.h"
+#endif
+
 int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
 {
     switch (codec_id) {
@@ -44,6 +52,10 @@ int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
         return MFX_CODEC_MPEG2;
     case AV_CODEC_ID_VC1:
         return MFX_CODEC_VC1;
+#if QSV_VERSION_ATLEAST(1, 12)
+    case AV_CODEC_ID_VP8:
+        return MFX_CODEC_VP8;
+#endif
     default:
         break;
     }
@@ -51,184 +63,207 @@ int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
     return AVERROR(ENOSYS);
 }
 
-int ff_qsv_error(int mfx_err)
+int ff_qsv_profile_to_mfx(enum AVCodecID codec_id, int profile)
 {
-    switch (mfx_err) {
-    case MFX_ERR_NONE:
-        return 0;
-    case MFX_ERR_MEMORY_ALLOC:
-    case MFX_ERR_NOT_ENOUGH_BUFFER:
-        return AVERROR(ENOMEM);
-    case MFX_ERR_INVALID_HANDLE:
-        return AVERROR(EINVAL);
-    case MFX_ERR_DEVICE_FAILED:
-    case MFX_ERR_DEVICE_LOST:
-    case MFX_ERR_LOCK_MEMORY:
-        return AVERROR(EIO);
-    case MFX_ERR_NULL_PTR:
-    case MFX_ERR_UNDEFINED_BEHAVIOR:
-    case MFX_ERR_NOT_INITIALIZED:
-        return AVERROR_BUG;
-    case MFX_ERR_UNSUPPORTED:
-    case MFX_ERR_NOT_FOUND:
-        return AVERROR(ENOSYS);
-    case MFX_ERR_MORE_DATA:
-    case MFX_ERR_MORE_SURFACE:
-    case MFX_ERR_MORE_BITSTREAM:
-        return AVERROR(EAGAIN);
-    case MFX_ERR_INCOMPATIBLE_VIDEO_PARAM:
-    case MFX_ERR_INVALID_VIDEO_PARAM:
-        return AVERROR(EINVAL);
-    case MFX_ERR_ABORTED:
-    case MFX_ERR_UNKNOWN:
-    default:
-        return AVERROR_UNKNOWN;
+    if (profile == FF_PROFILE_UNKNOWN)
+        return MFX_PROFILE_UNKNOWN;
+    switch (codec_id) {
+    case AV_CODEC_ID_H264:
+    case AV_CODEC_ID_HEVC:
+        return profile;
+    case AV_CODEC_ID_VC1:
+        return 4 * profile + 1;
+    case AV_CODEC_ID_MPEG2VIDEO:
+        return 0x10 * profile;
     }
+    return MFX_PROFILE_UNKNOWN;
 }
-static int ff_qsv_set_display_handle(AVCodecContext *avctx, QSVSession *qs)
-{
-    // this code is only required for Linux.  It searches for a valid
-    // display handle.  First in /dev/dri/renderD then in /dev/dri/card
-#ifdef AVCODEC_QSV_LINUX_SESSION_HANDLE
-    // VAAPI display handle
-    int ret = 0;
-    VADisplay va_dpy = NULL;
-    VAStatus va_res = VA_STATUS_SUCCESS;
-    int major_version = 0, minor_version = 0;
-    int fd = -1;
-    char adapterpath[256];
-    int adapter_num;
-
-    qs->fd_display = -1;
-    qs->va_display = NULL;
-
-    //search for valid graphics device
-    for (adapter_num = 0;adapter_num < 6;adapter_num++) {
-
-        if (adapter_num<3) {
-            snprintf(adapterpath,sizeof(adapterpath),
-                "/dev/dri/renderD%d", adapter_num+128);
-        } else {
-            snprintf(adapterpath,sizeof(adapterpath),
-                "/dev/dri/card%d", adapter_num-3);
-        }
 
-        fd = open(adapterpath, O_RDWR);
-        if (fd < 0) {
-            av_log(avctx, AV_LOG_ERROR,
-                "mfx init: %s fd open failed\n", adapterpath);
-            continue;
-        }
+static const struct {
+    mfxStatus   mfxerr;
+    int         averr;
+    const char *desc;
+} qsv_errors[] = {
+    { MFX_ERR_NONE,                     0,               "success"                              },
+    { MFX_ERR_UNKNOWN,                  AVERROR_UNKNOWN, "unknown error"                        },
+    { MFX_ERR_NULL_PTR,                 AVERROR(EINVAL), "NULL pointer"                         },
+    { MFX_ERR_UNSUPPORTED,              AVERROR(ENOSYS), "unsupported"                          },
+    { MFX_ERR_MEMORY_ALLOC,             AVERROR(ENOMEM), "failed to allocate memory"            },
+    { MFX_ERR_NOT_ENOUGH_BUFFER,        AVERROR(ENOMEM), "insufficient input/output buffer"     },
+    { MFX_ERR_INVALID_HANDLE,           AVERROR(EINVAL), "invalid handle"                       },
+    { MFX_ERR_LOCK_MEMORY,              AVERROR(EIO),    "failed to lock the memory block"      },
+    { MFX_ERR_NOT_INITIALIZED,          AVERROR_BUG,     "not initialized"                      },
+    { MFX_ERR_NOT_FOUND,                AVERROR(ENOSYS), "specified object was not found"       },
+    /* the following 3 errors should always be handled explicitly, so those "mappings"
+     * are for completeness only */
+    { MFX_ERR_MORE_DATA,                AVERROR_UNKNOWN, "expect more data at input"            },
+    { MFX_ERR_MORE_SURFACE,             AVERROR_UNKNOWN, "expect more surface at output"        },
+    { MFX_ERR_MORE_BITSTREAM,           AVERROR_UNKNOWN, "expect more bitstream at output"      },
+    { MFX_ERR_ABORTED,                  AVERROR_UNKNOWN, "operation aborted"                    },
+    { MFX_ERR_DEVICE_LOST,              AVERROR(EIO),    "device lost"                          },
+    { MFX_ERR_INCOMPATIBLE_VIDEO_PARAM, AVERROR(EINVAL), "incompatible video parameters"        },
+    { MFX_ERR_INVALID_VIDEO_PARAM,      AVERROR(EINVAL), "invalid video parameters"             },
+    { MFX_ERR_UNDEFINED_BEHAVIOR,       AVERROR_BUG,     "undefined behavior"                   },
+    { MFX_ERR_DEVICE_FAILED,            AVERROR(EIO),    "device failed"                        },
+    { MFX_ERR_INCOMPATIBLE_AUDIO_PARAM, AVERROR(EINVAL), "incompatible audio parameters"        },
+    { MFX_ERR_INVALID_AUDIO_PARAM,      AVERROR(EINVAL), "invalid audio parameters"             },
 
-        va_dpy = vaGetDisplayDRM(fd);
-        if (!va_dpy) {
-            av_log(avctx, AV_LOG_ERROR,
-                "mfx init: %s vaGetDisplayDRM failed\n", adapterpath);
-            close(fd);
-            continue;
-        }
+    { MFX_WRN_IN_EXECUTION,             0,               "operation in execution"               },
+    { MFX_WRN_DEVICE_BUSY,              0,               "device busy"                          },
+    { MFX_WRN_VIDEO_PARAM_CHANGED,      0,               "video parameters changed"             },
+    { MFX_WRN_PARTIAL_ACCELERATION,     0,               "partial acceleration"                 },
+    { MFX_WRN_INCOMPATIBLE_VIDEO_PARAM, 0,               "incompatible video parameters"        },
+    { MFX_WRN_VALUE_NOT_CHANGED,        0,               "value is saturated"                   },
+    { MFX_WRN_OUT_OF_RANGE,             0,               "value out of range"                   },
+    { MFX_WRN_FILTER_SKIPPED,           0,               "filter skipped"                       },
+    { MFX_WRN_INCOMPATIBLE_AUDIO_PARAM, 0,               "incompatible audio parameters"        },
+};
 
-        va_res = vaInitialize(va_dpy, &major_version, &minor_version);
-        if (VA_STATUS_SUCCESS != va_res) {
-            av_log(avctx, AV_LOG_ERROR,
-                "mfx init: %s vaInitialize failed\n", adapterpath);
-            close(fd);
-            fd = -1;
-            continue;
-        } else {
-            av_log(avctx, AV_LOG_VERBOSE,
-            "mfx initialization: %s vaInitialize successful\n",adapterpath);
-            qs->fd_display = fd;
-            qs->va_display = va_dpy;
-            ret = MFXVideoCORE_SetHandle(qs->session,
-                  (mfxHandleType)MFX_HANDLE_VA_DISPLAY, (mfxHDL)va_dpy);
-            if (ret < 0) {
-                av_log(avctx, AV_LOG_ERROR,
-                "Error %d during set display handle\n", ret);
-                return ff_qsv_error(ret);
-            }
-            break;
+int ff_qsv_map_error(mfxStatus mfx_err, const char **desc)
+{
+    int i;
+    for (i = 0; i < FF_ARRAY_ELEMS(qsv_errors); i++) {
+        if (qsv_errors[i].mfxerr == mfx_err) {
+            if (desc)
+                *desc = qsv_errors[i].desc;
+            return qsv_errors[i].averr;
         }
     }
-#endif //AVCODEC_QSV_LINUX_SESSION_HANDLE
-    return 0;
+    if (desc)
+        *desc = "unknown error";
+    return AVERROR_UNKNOWN;
 }
-/**
- * @brief Initialize a MSDK session
- *
- * Media SDK is based on sessions, so this is the prerequisite
- * initialization for HW acceleration.  For Windows the session is
- * complete and ready to use, for Linux a display handle is
- * required.  For releases of Media Server Studio >= 2015 R4 the
- * render nodes interface is preferred (/dev/dri/renderD).
- * Using Media Server Studio 2015 R4 or newer is recommended
- * but the older /dev/dri/card interface is also searched
- * for broader compatibility.
- *
- * @param avctx    ffmpeg metadata for this codec context
- * @param session  the MSDK session used
- */
-int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs,
-                                 const char *load_plugins)
+
+int ff_qsv_print_error(void *log_ctx, mfxStatus err,
+                       const char *error_string)
 {
-    mfxIMPL impl   = MFX_IMPL_AUTO_ANY;
-    mfxVersion ver = { { QSV_VERSION_MINOR, QSV_VERSION_MAJOR } };
+    const char *desc;
+    int ret;
+    ret = ff_qsv_map_error(err, &desc);
+    av_log(log_ctx, AV_LOG_ERROR, "%s: %s (%d)\n", error_string, desc, err);
+    return ret;
+}
 
+int ff_qsv_print_warning(void *log_ctx, mfxStatus err,
+                         const char *warning_string)
+{
     const char *desc;
     int ret;
+    ret = ff_qsv_map_error(err, &desc);
+    av_log(log_ctx, AV_LOG_WARNING, "%s: %s (%d)\n", warning_string, desc, err);
+    return ret;
+}
 
-    ret = MFXInit(impl, &ver, &qs->session);
-    if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Error initializing an internal MFX session\n");
-        return ff_qsv_error(ret);
+static enum AVPixelFormat qsv_map_fourcc(uint32_t fourcc)
+{
+    switch (fourcc) {
+    case MFX_FOURCC_NV12: return AV_PIX_FMT_NV12;
+    case MFX_FOURCC_P010: return AV_PIX_FMT_P010;
+    case MFX_FOURCC_P8:   return AV_PIX_FMT_PAL8;
     }
+    return AV_PIX_FMT_NONE;
+}
 
-    ret = ff_qsv_set_display_handle(avctx, qs);
-    if (ret < 0)
-        return ret;
+int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
+{
+    switch (format) {
+    case AV_PIX_FMT_YUV420P:
+    case AV_PIX_FMT_YUVJ420P:
+    case AV_PIX_FMT_NV12:
+        *fourcc = MFX_FOURCC_NV12;
+        return AV_PIX_FMT_NV12;
+    case AV_PIX_FMT_YUV420P10:
+    case AV_PIX_FMT_P010:
+        *fourcc = MFX_FOURCC_P010;
+        return AV_PIX_FMT_P010;
+    default:
+        return AVERROR(ENOSYS);
+    }
+}
 
-    if (load_plugins && *load_plugins) {
-        while (*load_plugins) {
-            mfxPluginUID uid;
-            int i, err = 0;
+int ff_qsv_find_surface_idx(QSVFramesContext *ctx, QSVFrame *frame)
+{
+    int i;
+    for (i = 0; i < ctx->nb_mids; i++) {
+        QSVMid *mid = &ctx->mids[i];
+        if (mid->handle == frame->surface.Data.MemId)
+            return i;
+    }
+    return AVERROR_BUG;
+}
 
-            char *plugin = av_get_token(&load_plugins, ":");
-            if (!plugin)
-                return AVERROR(ENOMEM);
-            if (strlen(plugin) != 2 * sizeof(uid.Data)) {
-                av_log(avctx, AV_LOG_ERROR, "Invalid plugin UID length\n");
-                err = AVERROR(EINVAL);
-                goto load_plugin_fail;
-            }
+static int qsv_load_plugins(mfxSession session, const char *load_plugins,
+                            void *logctx)
+{
+    if (!load_plugins || !*load_plugins)
+        return 0;
 
-            for (i = 0; i < sizeof(uid.Data); i++) {
-                err = sscanf(plugin + 2 * i, "%2hhx", uid.Data + i);
-                if (err != 1) {
-                    av_log(avctx, AV_LOG_ERROR, "Invalid plugin UID\n");
-                    err = AVERROR(EINVAL);
-                    goto load_plugin_fail;
-                }
+    while (*load_plugins) {
+        mfxPluginUID uid;
+        mfxStatus ret;
+        int i, err = 0;
 
-            }
+        char *plugin = av_get_token(&load_plugins, ":");
+        if (!plugin)
+            return AVERROR(ENOMEM);
+        if (strlen(plugin) != 2 * sizeof(uid.Data)) {
+            av_log(logctx, AV_LOG_ERROR, "Invalid plugin UID length\n");
+            err = AVERROR(EINVAL);
+            goto load_plugin_fail;
+        }
 
-            ret = MFXVideoUSER_Load(qs->session, &uid, 1);
-            if (ret < 0) {
-                av_log(avctx, AV_LOG_ERROR, "Could not load the requested plugin: %s\n",
-                       plugin);
-                err = ff_qsv_error(ret);
+        for (i = 0; i < sizeof(uid.Data); i++) {
+            err = sscanf(plugin + 2 * i, "%2hhx", uid.Data + i);
+            if (err != 1) {
+                av_log(logctx, AV_LOG_ERROR, "Invalid plugin UID\n");
+                err = AVERROR(EINVAL);
                 goto load_plugin_fail;
             }
 
-            if (*load_plugins)
-                load_plugins++;
-load_plugin_fail:
-            av_freep(&plugin);
-            if (err < 0)
-                return err;
         }
+
+        ret = MFXVideoUSER_Load(session, &uid, 1);
+        if (ret < 0) {
+            char errorbuf[128];
+            snprintf(errorbuf, sizeof(errorbuf),
+                     "Could not load the requested plugin '%s'", plugin);
+            err = ff_qsv_print_error(logctx, ret, errorbuf);
+            goto load_plugin_fail;
+        }
+
+        if (*load_plugins)
+            load_plugins++;
+load_plugin_fail:
+        av_freep(&plugin);
+        if (err < 0)
+            return err;
+    }
+
+    return 0;
+
+}
+
+int ff_qsv_init_internal_session(AVCodecContext *avctx, mfxSession *session,
+                                 const char *load_plugins)
+{
+    mfxIMPL impl   = MFX_IMPL_AUTO_ANY;
+    mfxVersion ver = { { QSV_VERSION_MINOR, QSV_VERSION_MAJOR } };
+
+    const char *desc;
+    int ret;
+
+    ret = MFXInit(impl, &ver, session);
+    if (ret < 0)
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error initializing an internal MFX session");
+
+    ret = qsv_load_plugins(*session, load_plugins, avctx);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error loading plugins\n");
+        return ret;
     }
 
-    MFXQueryIMPL(qs->session, &impl);
+    MFXQueryIMPL(*session, &impl);
 
     switch (MFX_IMPL_BASETYPE(impl)) {
     case MFX_IMPL_SOFTWARE:
@@ -251,21 +286,363 @@ int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs,
     return 0;
 }
 
-int ff_qsv_close_internal_session(QSVSession *qs)
+static void mids_buf_free(void *opaque, uint8_t *data)
+{
+    AVBufferRef *hw_frames_ref = opaque;
+    av_buffer_unref(&hw_frames_ref);
+    av_freep(&data);
+}
+
+static AVBufferRef *qsv_create_mids(AVBufferRef *hw_frames_ref)
 {
-    if (qs->session) {
-        MFXClose(qs->session);
-        qs->session = NULL;
+    AVHWFramesContext    *frames_ctx = (AVHWFramesContext*)hw_frames_ref->data;
+    AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
+    int                  nb_surfaces = frames_hwctx->nb_surfaces;
+
+    AVBufferRef *mids_buf, *hw_frames_ref1;
+    QSVMid *mids;
+    int i;
+
+    hw_frames_ref1 = av_buffer_ref(hw_frames_ref);
+    if (!hw_frames_ref1)
+        return NULL;
+
+    mids = av_mallocz_array(nb_surfaces, sizeof(*mids));
+    if (!mids) {
+        av_buffer_unref(&hw_frames_ref1);
+        return NULL;
     }
-#ifdef AVCODEC_QSV_LINUX_SESSION_HANDLE
-    if (qs->va_display) {
-        vaTerminate(qs->va_display);
-        qs->va_display = NULL;
+
+    mids_buf = av_buffer_create((uint8_t*)mids, nb_surfaces * sizeof(*mids),
+                                mids_buf_free, hw_frames_ref1, 0);
+    if (!mids_buf) {
+        av_buffer_unref(&hw_frames_ref1);
+        av_freep(&mids);
+        return NULL;
     }
-    if (qs->fd_display > 0) {
-        close(qs->fd_display);
-        qs->fd_display = -1;
+
+    for (i = 0; i < nb_surfaces; i++) {
+        QSVMid *mid = &mids[i];
+        mid->handle        = frames_hwctx->surfaces[i].Data.MemId;
+        mid->hw_frames_ref = hw_frames_ref1;
     }
-#endif
+
+    return mids_buf;
+}
+
+static int qsv_setup_mids(mfxFrameAllocResponse *resp, AVBufferRef *hw_frames_ref,
+                          AVBufferRef *mids_buf)
+{
+    AVHWFramesContext    *frames_ctx = (AVHWFramesContext*)hw_frames_ref->data;
+    AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
+    QSVMid                     *mids = (QSVMid*)mids_buf->data;
+    int                  nb_surfaces = frames_hwctx->nb_surfaces;
+    int i;
+
+    // the allocated size of the array is two larger than the number of
+    // surfaces, we store the references to the frames context and the
+    // QSVMid array there
+    resp->mids = av_mallocz_array(nb_surfaces + 2, sizeof(*resp->mids));
+    if (!resp->mids)
+        return AVERROR(ENOMEM);
+
+    for (i = 0; i < nb_surfaces; i++)
+        resp->mids[i] = &mids[i];
+    resp->NumFrameActual = nb_surfaces;
+
+    resp->mids[resp->NumFrameActual] = (mfxMemId)av_buffer_ref(hw_frames_ref);
+    if (!resp->mids[resp->NumFrameActual]) {
+        av_freep(&resp->mids);
+        return AVERROR(ENOMEM);
+    }
+
+    resp->mids[resp->NumFrameActual + 1] = av_buffer_ref(mids_buf);
+    if (!resp->mids[resp->NumFrameActual + 1]) {
+        av_buffer_unref((AVBufferRef**)&resp->mids[resp->NumFrameActual]);
+        av_freep(&resp->mids);
+        return AVERROR(ENOMEM);
+    }
+
+    return 0;
+}
+
+static mfxStatus qsv_frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
+                                 mfxFrameAllocResponse *resp)
+{
+    QSVFramesContext *ctx = pthis;
+    int ret;
+
+    /* this should only be called from an encoder or decoder and
+     * only allocates video memory frames */
+    if (!(req->Type & (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET |
+                       MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))         ||
+        !(req->Type & (MFX_MEMTYPE_FROM_DECODE | MFX_MEMTYPE_FROM_ENCODE)))
+        return MFX_ERR_UNSUPPORTED;
+
+    if (req->Type & MFX_MEMTYPE_EXTERNAL_FRAME) {
+        /* external frames -- fill from the caller-supplied frames context */
+        AVHWFramesContext *frames_ctx = (AVHWFramesContext*)ctx->hw_frames_ctx->data;
+        AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
+        mfxFrameInfo      *i  = &req->Info;
+        mfxFrameInfo      *i1 = &frames_hwctx->surfaces[0].Info;
+
+        if (i->Width  != i1->Width  || i->Height != i1->Height ||
+            i->FourCC != i1->FourCC || i->ChromaFormat != i1->ChromaFormat) {
+            av_log(ctx->logctx, AV_LOG_ERROR, "Mismatching surface properties in an "
+                   "allocation request: %dx%d %d %d vs %dx%d %d %d\n",
+                   i->Width,  i->Height,  i->FourCC,  i->ChromaFormat,
+                   i1->Width, i1->Height, i1->FourCC, i1->ChromaFormat);
+            return MFX_ERR_UNSUPPORTED;
+        }
+
+        ret = qsv_setup_mids(resp, ctx->hw_frames_ctx, ctx->mids_buf);
+        if (ret < 0) {
+            av_log(ctx->logctx, AV_LOG_ERROR,
+                   "Error filling an external frame allocation request\n");
+            return MFX_ERR_MEMORY_ALLOC;
+        }
+    } else if (req->Type & MFX_MEMTYPE_INTERNAL_FRAME) {
+        /* internal frames -- allocate a new hw frames context */
+        AVHWFramesContext *ext_frames_ctx = (AVHWFramesContext*)ctx->hw_frames_ctx->data;
+        mfxFrameInfo      *i  = &req->Info;
+
+        AVBufferRef *frames_ref, *mids_buf;
+        AVHWFramesContext *frames_ctx;
+        AVQSVFramesContext *frames_hwctx;
+
+        frames_ref = av_hwframe_ctx_alloc(ext_frames_ctx->device_ref);
+        if (!frames_ref)
+            return MFX_ERR_MEMORY_ALLOC;
+
+        frames_ctx   = (AVHWFramesContext*)frames_ref->data;
+        frames_hwctx = frames_ctx->hwctx;
+
+        frames_ctx->format            = AV_PIX_FMT_QSV;
+        frames_ctx->sw_format         = qsv_map_fourcc(i->FourCC);
+        frames_ctx->width             = i->Width;
+        frames_ctx->height            = i->Height;
+        frames_ctx->initial_pool_size = req->NumFrameSuggested;
+
+        frames_hwctx->frame_type      = req->Type;
+
+        ret = av_hwframe_ctx_init(frames_ref);
+        if (ret < 0) {
+            av_log(ctx->logctx, AV_LOG_ERROR,
+                   "Error initializing a frames context for an internal frame "
+                   "allocation request\n");
+            av_buffer_unref(&frames_ref);
+            return MFX_ERR_MEMORY_ALLOC;
+        }
+
+        mids_buf = qsv_create_mids(frames_ref);
+        if (!mids_buf) {
+            av_buffer_unref(&frames_ref);
+            return MFX_ERR_MEMORY_ALLOC;
+        }
+
+        ret = qsv_setup_mids(resp, frames_ref, mids_buf);
+        av_buffer_unref(&mids_buf);
+        av_buffer_unref(&frames_ref);
+        if (ret < 0) {
+            av_log(ctx->logctx, AV_LOG_ERROR,
+                   "Error filling an internal frame allocation request\n");
+            return MFX_ERR_MEMORY_ALLOC;
+        }
+    } else {
+        return MFX_ERR_UNSUPPORTED;
+    }
+
+    return MFX_ERR_NONE;
+}
+
+static mfxStatus qsv_frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
+{
+    av_buffer_unref((AVBufferRef**)&resp->mids[resp->NumFrameActual]);
+    av_buffer_unref((AVBufferRef**)&resp->mids[resp->NumFrameActual + 1]);
+    av_freep(&resp->mids);
+    return MFX_ERR_NONE;
+}
+
+static mfxStatus qsv_frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
+{
+    QSVMid *qsv_mid = mid;
+    AVHWFramesContext *hw_frames_ctx = (AVHWFramesContext*)qsv_mid->hw_frames_ref->data;
+    AVQSVFramesContext *hw_frames_hwctx = hw_frames_ctx->hwctx;
+    int ret;
+
+    if (qsv_mid->locked_frame)
+        return MFX_ERR_UNDEFINED_BEHAVIOR;
+
+    /* Allocate a system memory frame that will hold the mapped data. */
+    qsv_mid->locked_frame = av_frame_alloc();
+    if (!qsv_mid->locked_frame)
+        return MFX_ERR_MEMORY_ALLOC;
+    qsv_mid->locked_frame->format  = hw_frames_ctx->sw_format;
+
+    /* wrap the provided handle in a hwaccel AVFrame */
+    qsv_mid->hw_frame = av_frame_alloc();
+    if (!qsv_mid->hw_frame)
+        goto fail;
+
+    qsv_mid->hw_frame->data[3] = (uint8_t*)&qsv_mid->surf;
+    qsv_mid->hw_frame->format  = AV_PIX_FMT_QSV;
+
+    // doesn't really matter what buffer is used here
+    qsv_mid->hw_frame->buf[0]  = av_buffer_alloc(1);
+    if (!qsv_mid->hw_frame->buf[0])
+        goto fail;
+
+    qsv_mid->hw_frame->width   = hw_frames_ctx->width;
+    qsv_mid->hw_frame->height  = hw_frames_ctx->height;
+
+    qsv_mid->hw_frame->hw_frames_ctx = av_buffer_ref(qsv_mid->hw_frames_ref);
+    if (!qsv_mid->hw_frame->hw_frames_ctx)
+        goto fail;
+
+    qsv_mid->surf.Info = hw_frames_hwctx->surfaces[0].Info;
+    qsv_mid->surf.Data.MemId = qsv_mid->handle;
+
+    /* map the data to the system memory */
+    ret = av_hwframe_map(qsv_mid->locked_frame, qsv_mid->hw_frame,
+                         AV_HWFRAME_MAP_DIRECT);
+    if (ret < 0)
+        goto fail;
+
+    ptr->Pitch = qsv_mid->locked_frame->linesize[0];
+    ptr->Y     = qsv_mid->locked_frame->data[0];
+    ptr->U     = qsv_mid->locked_frame->data[1];
+    ptr->V     = qsv_mid->locked_frame->data[1] + 1;
+
+    return MFX_ERR_NONE;
+fail:
+    av_frame_free(&qsv_mid->hw_frame);
+    av_frame_free(&qsv_mid->locked_frame);
+    return MFX_ERR_MEMORY_ALLOC;
+}
+
+static mfxStatus qsv_frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
+{
+    QSVMid *qsv_mid = mid;
+
+    av_frame_free(&qsv_mid->locked_frame);
+    av_frame_free(&qsv_mid->hw_frame);
+
+    return MFX_ERR_NONE;
+}
+
+static mfxStatus qsv_frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
+{
+    QSVMid *qsv_mid = (QSVMid*)mid;
+    *hdl = qsv_mid->handle;
+    return MFX_ERR_NONE;
+}
+
+int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession,
+                               AVBufferRef *device_ref, const char *load_plugins)
+{
+    static const mfxHandleType handle_types[] = {
+        MFX_HANDLE_VA_DISPLAY,
+        MFX_HANDLE_D3D9_DEVICE_MANAGER,
+        MFX_HANDLE_D3D11_DEVICE,
+    };
+    AVHWDeviceContext    *device_ctx = (AVHWDeviceContext*)device_ref->data;
+    AVQSVDeviceContext *device_hwctx = device_ctx->hwctx;
+    mfxSession        parent_session = device_hwctx->session;
+
+    mfxSession    session;
+    mfxVersion    ver;
+    mfxIMPL       impl;
+    mfxHDL        handle = NULL;
+    mfxHandleType handle_type;
+    mfxStatus err;
+
+    int i, ret;
+
+    err = MFXQueryIMPL(parent_session, &impl);
+    if (err == MFX_ERR_NONE)
+        err = MFXQueryVersion(parent_session, &ver);
+    if (err != MFX_ERR_NONE)
+        return ff_qsv_print_error(avctx, err,
+                                  "Error querying the session attributes");
+
+    for (i = 0; i < FF_ARRAY_ELEMS(handle_types); i++) {
+        err = MFXVideoCORE_GetHandle(parent_session, handle_types[i], &handle);
+        if (err == MFX_ERR_NONE) {
+            handle_type = handle_types[i];
+            break;
+        }
+        handle = NULL;
+    }
+    if (!handle) {
+        av_log(avctx, AV_LOG_VERBOSE, "No supported hw handle could be retrieved "
+               "from the session\n");
+    }
+
+    err = MFXInit(impl, &ver, &session);
+    if (err != MFX_ERR_NONE)
+        return ff_qsv_print_error(avctx, err,
+                                  "Error initializing a child MFX session");
+
+    if (handle) {
+        err = MFXVideoCORE_SetHandle(session, handle_type, handle);
+        if (err != MFX_ERR_NONE)
+            return ff_qsv_print_error(avctx, err,
+                                      "Error setting a HW handle");
+    }
+
+    ret = qsv_load_plugins(session, load_plugins, avctx);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error loading plugins\n");
+        return ret;
+    }
+
+    *psession = session;
+    return 0;
+}
+
+int ff_qsv_init_session_frames(AVCodecContext *avctx, mfxSession *psession,
+                               QSVFramesContext *qsv_frames_ctx,
+                               const char *load_plugins, int opaque)
+{
+    mfxFrameAllocator frame_allocator = {
+        .pthis  = qsv_frames_ctx,
+        .Alloc  = qsv_frame_alloc,
+        .Lock   = qsv_frame_lock,
+        .Unlock = qsv_frame_unlock,
+        .GetHDL = qsv_frame_get_hdl,
+        .Free   = qsv_frame_free,
+    };
+
+    AVHWFramesContext    *frames_ctx = (AVHWFramesContext*)qsv_frames_ctx->hw_frames_ctx->data;
+    AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
+
+    mfxSession    session;
+    mfxStatus err;
+
+    int ret;
+
+    ret = ff_qsv_init_session_device(avctx, &session,
+                                     frames_ctx->device_ref, load_plugins);
+    if (ret < 0)
+        return ret;
+
+    if (!opaque) {
+        qsv_frames_ctx->logctx = avctx;
+
+        /* allocate the memory ids for the external frames */
+        av_buffer_unref(&qsv_frames_ctx->mids_buf);
+        qsv_frames_ctx->mids_buf = qsv_create_mids(qsv_frames_ctx->hw_frames_ctx);
+        if (!qsv_frames_ctx->mids_buf)
+            return AVERROR(ENOMEM);
+        qsv_frames_ctx->mids    = (QSVMid*)qsv_frames_ctx->mids_buf->data;
+        qsv_frames_ctx->nb_mids = frames_hwctx->nb_surfaces;
+
+        err = MFXVideoCORE_SetFrameAllocator(session, &frame_allocator);
+        if (err != MFX_ERR_NONE)
+            return ff_qsv_print_error(avctx, err,
+                                      "Error setting a frame allocator");
+    }
+
+    *psession = session;
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/qsv_internal.h b/mythtv/external/FFmpeg/libavcodec/qsv_internal.h
index f289a2b2fa3..c0305508dd5 100644
--- a/mythtv/external/FFmpeg/libavcodec/qsv_internal.h
+++ b/mythtv/external/FFmpeg/libavcodec/qsv_internal.h
@@ -21,21 +21,6 @@
 #ifndef AVCODEC_QSV_INTERNAL_H
 #define AVCODEC_QSV_INTERNAL_H
 
-#if CONFIG_VAAPI
-#define AVCODEC_QSV_LINUX_SESSION_HANDLE
-#endif //CONFIG_VAAPI
-
-#ifdef AVCODEC_QSV_LINUX_SESSION_HANDLE
-#include <stdio.h>
-#include <string.h>
-#if HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <fcntl.h>
-#include <va/va.h>
-#include <va/va_drm.h>
-#endif
-
 #include <mfx/mfxvideo.h>
 
 #include "libavutil/frame.h"
@@ -43,7 +28,7 @@
 #include "avcodec.h"
 
 #define QSV_VERSION_MAJOR 1
-#define QSV_VERSION_MINOR 9
+#define QSV_VERSION_MINOR 1
 
 #define ASYNC_DEPTH_DEFAULT 4       // internal parallelism
 
@@ -53,35 +38,65 @@
     (MFX_VERSION_MAJOR > (MAJOR) ||         \
      MFX_VERSION_MAJOR == (MAJOR) && MFX_VERSION_MINOR >= (MINOR))
 
+typedef struct QSVMid {
+    AVBufferRef *hw_frames_ref;
+    mfxHDL handle;
+
+    AVFrame *locked_frame;
+    AVFrame *hw_frame;
+    mfxFrameSurface1 surf;
+} QSVMid;
+
 typedef struct QSVFrame {
     AVFrame *frame;
-    mfxFrameSurface1 *surface;
+    mfxFrameSurface1 surface;
     mfxEncodeCtrl enc_ctrl;
 
-    mfxFrameSurface1 surface_internal;
-
     int queued;
+    int used;
 
     struct QSVFrame *next;
 } QSVFrame;
 
-typedef struct QSVSession {
-    mfxSession session;
-#ifdef AVCODEC_QSV_LINUX_SESSION_HANDLE
-    int        fd_display;
-    VADisplay  va_display;
-#endif
-} QSVSession;
+typedef struct QSVFramesContext {
+    AVBufferRef *hw_frames_ctx;
+    void *logctx;
+
+    /* The memory ids for the external frames.
+     * Refcounted, since we need one reference owned by the QSVFramesContext
+     * (i.e. by the encoder/decoder) and another one given to the MFX session
+     * from the frame allocator. */
+    AVBufferRef *mids_buf;
+    QSVMid *mids;
+    int  nb_mids;
+} QSVFramesContext;
 
 /**
- * Convert a libmfx error code into a ffmpeg error code.
+ * Convert a libmfx error code into an ffmpeg error code.
  */
-int ff_qsv_error(int mfx_err);
+int ff_qsv_map_error(mfxStatus mfx_err, const char **desc);
+
+int ff_qsv_print_error(void *log_ctx, mfxStatus err,
+                       const char *error_string);
+
+int ff_qsv_print_warning(void *log_ctx, mfxStatus err,
+                         const char *warning_string);
 
 int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id);
+int ff_qsv_profile_to_mfx(enum AVCodecID codec_id, int profile);
+
+int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc);
 
-int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs,
+int ff_qsv_init_internal_session(AVCodecContext *avctx, mfxSession *session,
                                  const char *load_plugins);
-int ff_qsv_close_internal_session(QSVSession *qs);
+
+int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession,
+                               AVBufferRef *device_ref, const char *load_plugins);
+
+int ff_qsv_init_session_frames(AVCodecContext *avctx, mfxSession *session,
+                               QSVFramesContext *qsv_frames_ctx,
+                               const char *load_plugins, int opaque);
+
+int ff_qsv_find_surface_idx(QSVFramesContext *ctx, QSVFrame *frame);
 
 #endif /* AVCODEC_QSV_INTERNAL_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/qsvdec.c b/mythtv/external/FFmpeg/libavcodec/qsvdec.c
index 6409312d31d..c00817f1d93 100644
--- a/mythtv/external/FFmpeg/libavcodec/qsvdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/qsvdec.c
@@ -27,8 +27,11 @@
 #include <mfx/mfxvideo.h>
 
 #include "libavutil/common.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_qsv.h"
 #include "libavutil/mem.h"
 #include "libavutil/log.h"
+#include "libavutil/pixdesc.h"
 #include "libavutil/pixfmt.h"
 #include "libavutil/time.h"
 
@@ -38,147 +41,163 @@
 #include "qsv_internal.h"
 #include "qsvdec.h"
 
-int ff_qsv_map_pixfmt(enum AVPixelFormat format)
+static int qsv_init_session(AVCodecContext *avctx, QSVContext *q, mfxSession session,
+                            AVBufferRef *hw_frames_ref, AVBufferRef *hw_device_ref)
 {
-    switch (format) {
-    case AV_PIX_FMT_YUV420P:
-    case AV_PIX_FMT_YUVJ420P:
-        return AV_PIX_FMT_NV12;
-    default:
-        return AVERROR(ENOSYS);
-    }
-}
+    int ret;
 
-static int qsv_init_session(AVCodecContext *avctx, QSVContext *q, mfxSession session)
-{
-    if (!session) {
-        if (!q->internal_qs.session) {
-           int ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
-                                                  q->load_plugins);
+    if (session) {
+        q->session = session;
+    } else if (hw_frames_ref) {
+        if (q->internal_session) {
+            MFXClose(q->internal_session);
+            q->internal_session = NULL;
+        }
+        av_buffer_unref(&q->frames_ctx.hw_frames_ctx);
+
+        q->frames_ctx.hw_frames_ctx = av_buffer_ref(hw_frames_ref);
+        if (!q->frames_ctx.hw_frames_ctx)
+            return AVERROR(ENOMEM);
+
+        ret = ff_qsv_init_session_frames(avctx, &q->internal_session,
+                                         &q->frames_ctx, q->load_plugins,
+                                         q->iopattern == MFX_IOPATTERN_OUT_OPAQUE_MEMORY);
+        if (ret < 0) {
+            av_buffer_unref(&q->frames_ctx.hw_frames_ctx);
+            return ret;
+        }
+
+        q->session = q->internal_session;
+    } else if (hw_device_ref) {
+        if (q->internal_session) {
+            MFXClose(q->internal_session);
+            q->internal_session = NULL;
+        }
+
+        ret = ff_qsv_init_session_device(avctx, &q->internal_session,
+                                         hw_device_ref, q->load_plugins);
+        if (ret < 0)
+            return ret;
+
+        q->session = q->internal_session;
+    } else {
+        if (!q->internal_session) {
+            ret = ff_qsv_init_internal_session(avctx, &q->internal_session,
+                                               q->load_plugins);
             if (ret < 0)
                 return ret;
         }
 
-        q->session = q->internal_qs.session;
-    } else {
-        q->session = session;
+        q->session = q->internal_session;
     }
 
-   return 0;
+    /* make sure the decoder is uninitialized */
+    MFXVideoDECODE_Close(q->session);
+
+    return 0;
 }
 
-static int qsv_decode_init(AVCodecContext *avctx, QSVContext *q, AVPacket *avpkt)
+static int qsv_decode_init(AVCodecContext *avctx, QSVContext *q)
 {
+    const AVPixFmtDescriptor *desc;
     mfxSession session = NULL;
-    mfxVideoParam param = { { 0 } };
-    mfxBitstream bs   = { { { 0 } } };
+    int iopattern = 0;
+    mfxVideoParam param = { 0 };
+    int frame_width  = avctx->coded_width;
+    int frame_height = avctx->coded_height;
     int ret;
-    enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_QSV,
-                                       AV_PIX_FMT_NV12,
-                                       AV_PIX_FMT_NONE };
 
-    ret = ff_get_format(avctx, pix_fmts);
-    if (ret < 0)
-        return ret;
+    desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
+    if (!desc)
+        return AVERROR_BUG;
+
+    if (!q->async_fifo) {
+        q->async_fifo = av_fifo_alloc((1 + q->async_depth) *
+                                      (sizeof(mfxSyncPoint*) + sizeof(QSVFrame*)));
+        if (!q->async_fifo)
+            return AVERROR(ENOMEM);
+    }
+
+    if (avctx->pix_fmt == AV_PIX_FMT_QSV && avctx->hwaccel_context) {
+        AVQSVContext *user_ctx = avctx->hwaccel_context;
+        session           = user_ctx->session;
+        iopattern         = user_ctx->iopattern;
+        q->ext_buffers    = user_ctx->ext_buffers;
+        q->nb_ext_buffers = user_ctx->nb_ext_buffers;
+    }
 
-    avctx->pix_fmt      = ret;
+    if (avctx->hw_frames_ctx) {
+        AVHWFramesContext    *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+        AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
 
-    q->iopattern  = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
-    if (avctx->hwaccel_context) {
-        AVQSVContext *qsv = avctx->hwaccel_context;
+        if (!iopattern) {
+            if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
+                iopattern = MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
+            else if (frames_hwctx->frame_type & MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET)
+                iopattern = MFX_IOPATTERN_OUT_VIDEO_MEMORY;
+        }
 
-        session           = qsv->session;
-        q->iopattern      = qsv->iopattern;
-        q->ext_buffers    = qsv->ext_buffers;
-        q->nb_ext_buffers = qsv->nb_ext_buffers;
+        frame_width  = frames_hwctx->surfaces[0].Info.Width;
+        frame_height = frames_hwctx->surfaces[0].Info.Height;
     }
 
-    ret = qsv_init_session(avctx, q, session);
+    if (!iopattern)
+        iopattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
+    q->iopattern = iopattern;
+
+    ret = qsv_init_session(avctx, q, session, avctx->hw_frames_ctx, avctx->hw_device_ctx);
     if (ret < 0) {
         av_log(avctx, AV_LOG_ERROR, "Error initializing an MFX session\n");
         return ret;
     }
 
-    if (avpkt->size) {
-        bs.Data       = avpkt->data;
-        bs.DataLength = avpkt->size;
-        bs.MaxLength  = bs.DataLength;
-        bs.TimeStamp  = avpkt->pts;
-    } else
-        return AVERROR_INVALIDDATA;
-
     ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
-    if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Unsupported codec_id %08x\n", avctx->codec_id);
+    if (ret < 0)
         return ret;
-    }
 
-    param.mfx.CodecId = ret;
-
-    ret = MFXVideoDECODE_DecodeHeader(q->session, &bs, &param);
-    if (MFX_ERR_MORE_DATA==ret) {
-        /* this code means that header not found so we return packet size to skip
-           a current packet
-         */
-        return avpkt->size;
-    } else if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Decode header error %d\n", ret);
-        return ff_qsv_error(ret);
+    param.mfx.CodecId      = ret;
+    param.mfx.CodecProfile = ff_qsv_profile_to_mfx(avctx->codec_id, avctx->profile);
+    param.mfx.CodecLevel   = avctx->level == FF_LEVEL_UNKNOWN ? MFX_LEVEL_UNKNOWN : avctx->level;
+
+    param.mfx.FrameInfo.BitDepthLuma   = desc->comp[0].depth;
+    param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
+    param.mfx.FrameInfo.Shift          = desc->comp[0].depth > 8;
+    param.mfx.FrameInfo.FourCC         = q->fourcc;
+    param.mfx.FrameInfo.Width          = frame_width;
+    param.mfx.FrameInfo.Height         = frame_height;
+    param.mfx.FrameInfo.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
+
+    switch (avctx->field_order) {
+    case AV_FIELD_PROGRESSIVE:
+        param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
+        break;
+    case AV_FIELD_TT:
+        param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
+        break;
+    case AV_FIELD_BB:
+        param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_BFF;
+        break;
+    default:
+        param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_UNKNOWN;
+        break;
     }
+
     param.IOPattern   = q->iopattern;
     param.AsyncDepth  = q->async_depth;
     param.ExtParam    = q->ext_buffers;
     param.NumExtParam = q->nb_ext_buffers;
-    param.mfx.FrameInfo.BitDepthLuma   = 8;
-    param.mfx.FrameInfo.BitDepthChroma = 8;
 
     ret = MFXVideoDECODE_Init(q->session, &param);
-    if (ret < 0) {
-        if (MFX_ERR_INVALID_VIDEO_PARAM==ret) {
-            av_log(avctx, AV_LOG_ERROR,
-                   "Error initializing the MFX video decoder, unsupported video\n");
-        } else {
-            av_log(avctx, AV_LOG_ERROR,
-                   "Error initializing the MFX video decoder %d\n", ret);
-        }
-        return ff_qsv_error(ret);
-    }
-
-    avctx->profile      = param.mfx.CodecProfile;
-    avctx->level        = param.mfx.CodecLevel;
-    avctx->coded_width  = param.mfx.FrameInfo.Width;
-    avctx->coded_height = param.mfx.FrameInfo.Height;
-    avctx->width        = param.mfx.FrameInfo.CropW - param.mfx.FrameInfo.CropX;
-    avctx->height       = param.mfx.FrameInfo.CropH - param.mfx.FrameInfo.CropY;
-
-    /* maximum decoder latency should be not exceed max DPB size for h.264 and
-       HEVC which is 16 for both cases.
-       So weare  pre-allocating fifo big enough for 17 elements:
-     */
-    if (!q->async_fifo) {
-        q->async_fifo = av_fifo_alloc((1 + 16) *
-                                      (sizeof(mfxSyncPoint) + sizeof(QSVFrame*)));
-        if (!q->async_fifo)
-            return AVERROR(ENOMEM);
-    }
+    if (ret < 0)
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error initializing the MFX video decoder");
 
-    if (!q->input_fifo) {
-        q->input_fifo = av_fifo_alloc(1024*16);
-        if (!q->input_fifo)
-            return AVERROR(ENOMEM);
-    }
-
-    if (!q->pkt_fifo) {
-        q->pkt_fifo = av_fifo_alloc( sizeof(AVPacket) * (1 + 16) );
-        if (!q->pkt_fifo)
-            return AVERROR(ENOMEM);
-    }
-    q->engine_ready = 1;
+    q->frame_info = param.mfx.FrameInfo;
 
     return 0;
 }
 
-static int alloc_frame(AVCodecContext *avctx, QSVFrame *frame)
+static int alloc_frame(AVCodecContext *avctx, QSVContext *q, QSVFrame *frame)
 {
     int ret;
 
@@ -187,22 +206,25 @@ static int alloc_frame(AVCodecContext *avctx, QSVFrame *frame)
         return ret;
 
     if (frame->frame->format == AV_PIX_FMT_QSV) {
-        frame->surface = (mfxFrameSurface1*)frame->frame->data[3];
+        frame->surface = *(mfxFrameSurface1*)frame->frame->data[3];
     } else {
-        frame->surface_internal.Info.BitDepthLuma   = 8;
-        frame->surface_internal.Info.BitDepthChroma = 8;
-        frame->surface_internal.Info.FourCC         = MFX_FOURCC_NV12;
-        frame->surface_internal.Info.Width          = avctx->coded_width;
-        frame->surface_internal.Info.Height         = avctx->coded_height;
-        frame->surface_internal.Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
-
-        frame->surface_internal.Data.PitchLow = frame->frame->linesize[0];
-        frame->surface_internal.Data.Y        = frame->frame->data[0];
-        frame->surface_internal.Data.UV       = frame->frame->data[1];
-
-        frame->surface = &frame->surface_internal;
+        frame->surface.Info = q->frame_info;
+
+        frame->surface.Data.PitchLow = frame->frame->linesize[0];
+        frame->surface.Data.Y        = frame->frame->data[0];
+        frame->surface.Data.UV       = frame->frame->data[1];
     }
 
+    if (q->frames_ctx.mids) {
+        ret = ff_qsv_find_surface_idx(&q->frames_ctx, frame);
+        if (ret < 0)
+            return ret;
+
+        frame->surface.Data.MemId = &q->frames_ctx.mids[ret];
+    }
+
+    frame->used = 1;
+
     return 0;
 }
 
@@ -210,8 +232,8 @@ static void qsv_clear_unused_frames(QSVContext *q)
 {
     QSVFrame *cur = q->work_frames;
     while (cur) {
-        if (cur->surface && !cur->surface->Data.Locked && !cur->queued) {
-            cur->surface = NULL;
+        if (cur->used && !cur->surface.Data.Locked && !cur->queued) {
+            cur->used = 0;
             av_frame_unref(cur->frame);
         }
         cur = cur->next;
@@ -228,11 +250,11 @@ static int get_surface(AVCodecContext *avctx, QSVContext *q, mfxFrameSurface1 **
     frame = q->work_frames;
     last  = &q->work_frames;
     while (frame) {
-        if (!frame->surface) {
-            ret = alloc_frame(avctx, frame);
+        if (!frame->used) {
+            ret = alloc_frame(avctx, q, frame);
             if (ret < 0)
                 return ret;
-            *surf = frame->surface;
+            *surf = &frame->surface;
             return 0;
         }
 
@@ -250,11 +272,11 @@ static int get_surface(AVCodecContext *avctx, QSVContext *q, mfxFrameSurface1 **
     }
     *last = frame;
 
-    ret = alloc_frame(avctx, frame);
+    ret = alloc_frame(avctx, q, frame);
     if (ret < 0)
         return ret;
 
-    *surf = frame->surface;
+    *surf = &frame->surface;
 
     return 0;
 }
@@ -263,177 +285,103 @@ static QSVFrame *find_frame(QSVContext *q, mfxFrameSurface1 *surf)
 {
     QSVFrame *cur = q->work_frames;
     while (cur) {
-        if (surf == cur->surface)
+        if (surf == &cur->surface)
             return cur;
         cur = cur->next;
     }
     return NULL;
 }
 
-/*  This function uses for 'smart' releasing of consumed data
-    from the input bitstream fifo.
-    Since the input fifo mapped to mfxBitstream which does not understand
-    a wrapping of data over fifo end, we should also to relocate a possible
-    data rest to fifo begin. If rest of data is absent then we just reset fifo's
-    pointers to initial positions.
-    NOTE the case when fifo does contain unconsumed data is rare and typical
-    amount of such data is 1..4 bytes.
-*/
-static void qsv_fifo_relocate(AVFifoBuffer *f, int bytes_to_free)
-{
-    int data_size;
-    int data_rest = 0;
-
-    av_fifo_drain(f, bytes_to_free);
-
-    data_size = av_fifo_size(f);
-    if (data_size > 0) {
-        if (f->buffer!=f->rptr) {
-            if ( (f->end - f->rptr) < data_size) {
-                data_rest = data_size - (f->end - f->rptr);
-                data_size-=data_rest;
-                memmove(f->buffer+data_size, f->buffer, data_rest);
-            }
-            memmove(f->buffer, f->rptr, data_size);
-            data_size+= data_rest;
-        }
-    }
-    f->rptr = f->buffer;
-    f->wptr = f->buffer + data_size;
-    f->wndx = data_size;
-    f->rndx = 0;
-}
-
-
-static void close_decoder(QSVContext *q)
-{
-    QSVFrame *cur;
-
-    if (q->session)
-        MFXVideoDECODE_Close(q->session);
-
-    cur = q->work_frames;
-    while (cur) {
-        q->work_frames = cur->next;
-        av_frame_free(&cur->frame);
-        av_freep(&cur);
-        cur = q->work_frames;
-    }
-
-    q->engine_ready   = 0;
-    q->reinit_pending = 0;
-}
-
-static int do_qsv_decode(AVCodecContext *avctx, QSVContext *q,
-                  AVFrame *frame, int *got_frame,
-                  AVPacket *avpkt)
+static int qsv_decode(AVCodecContext *avctx, QSVContext *q,
+                      AVFrame *frame, int *got_frame,
+                      AVPacket *avpkt)
 {
     QSVFrame *out_frame;
     mfxFrameSurface1 *insurf;
     mfxFrameSurface1 *outsurf;
-    mfxSyncPoint sync;
+    mfxSyncPoint *sync;
     mfxBitstream bs = { { { 0 } } };
     int ret;
-    int n_out_frames;
-    int buffered = 0;
-    int flush    = !avpkt->size || q->reinit_pending;
-
-    if (!q->engine_ready) {
-        ret = qsv_decode_init(avctx, q, avpkt);
-        if (ret)
-            return ret;
-    }
 
-    if (!flush) {
-        if (av_fifo_size(q->input_fifo)) {
-            /* we have got rest of previous packet into buffer */
-            if (av_fifo_space(q->input_fifo) < avpkt->size) {
-                ret = av_fifo_grow(q->input_fifo, avpkt->size);
-                if (ret < 0)
-                    return ret;
-            }
-            av_fifo_generic_write(q->input_fifo, avpkt->data, avpkt->size, NULL);
-            bs.Data       = q->input_fifo->rptr;
-            bs.DataLength = av_fifo_size(q->input_fifo);
-            buffered = 1;
-        } else {
-            bs.Data       = avpkt->data;
-            bs.DataLength = avpkt->size;
-        }
+    if (avpkt->size) {
+        bs.Data       = avpkt->data;
+        bs.DataLength = avpkt->size;
         bs.MaxLength  = bs.DataLength;
         bs.TimeStamp  = avpkt->pts;
     }
 
-    while (1) {
+    sync = av_mallocz(sizeof(*sync));
+    if (!sync) {
+        av_freep(&sync);
+        return AVERROR(ENOMEM);
+    }
+
+    do {
         ret = get_surface(avctx, q, &insurf);
-        if (ret < 0)
+        if (ret < 0) {
+            av_freep(&sync);
             return ret;
-        do {
-            ret = MFXVideoDECODE_DecodeFrameAsync(q->session, flush ? NULL : &bs,
-                                                  insurf, &outsurf, &sync);
-            if (ret != MFX_WRN_DEVICE_BUSY)
-                break;
-            av_usleep(500);
-        } while (1);
-
-        if (MFX_WRN_VIDEO_PARAM_CHANGED==ret) {
-            /* TODO: handle here minor sequence header changing */
-        } else if (MFX_ERR_INCOMPATIBLE_VIDEO_PARAM==ret) {
-            av_fifo_reset(q->input_fifo);
-            flush = q->reinit_pending = 1;
-            continue;
         }
 
-        if (sync) {
-            QSVFrame *out_frame = find_frame(q, outsurf);
-
-            if (!out_frame) {
-                av_log(avctx, AV_LOG_ERROR,
-                       "The returned surface does not correspond to any frame\n");
-                return AVERROR_BUG;
-            }
+        ret = MFXVideoDECODE_DecodeFrameAsync(q->session, avpkt->size ? &bs : NULL,
+                                              insurf, &outsurf, sync);
+        if (ret == MFX_WRN_DEVICE_BUSY)
+            av_usleep(500);
 
-            out_frame->queued = 1;
-            av_fifo_generic_write(q->async_fifo, &out_frame, sizeof(out_frame), NULL);
-            av_fifo_generic_write(q->async_fifo, &sync,      sizeof(sync),      NULL);
+    } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_ERR_MORE_SURFACE);
 
-            continue;
-        }
-        if (MFX_ERR_MORE_SURFACE != ret && ret < 0)
-            break;
+    if (ret != MFX_ERR_NONE &&
+        ret != MFX_ERR_MORE_DATA &&
+        ret != MFX_WRN_VIDEO_PARAM_CHANGED &&
+        ret != MFX_ERR_MORE_SURFACE) {
+        av_freep(&sync);
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error during QSV decoding.");
     }
 
     /* make sure we do not enter an infinite loop if the SDK
      * did not consume any data and did not return anything */
-    if (!sync && !bs.DataOffset && !flush) {
-        av_log(avctx, AV_LOG_WARNING, "A decode call did not consume any data\n");
+    if (!*sync && !bs.DataOffset) {
         bs.DataOffset = avpkt->size;
+        ++q->zero_consume_run;
+        if (q->zero_consume_run > 1)
+            ff_qsv_print_warning(avctx, ret, "A decode call did not consume any data");
+    } else {
+        q->zero_consume_run = 0;
     }
 
-    if (buffered) {
-        qsv_fifo_relocate(q->input_fifo, bs.DataOffset);
-    } else if (bs.DataOffset!=avpkt->size) {
-        /* some data of packet was not consumed. store it to local buffer */
-        av_fifo_generic_write(q->input_fifo, avpkt->data+bs.DataOffset,
-                              avpkt->size - bs.DataOffset, NULL);
-    }
+    if (*sync) {
+        QSVFrame *out_frame = find_frame(q, outsurf);
+
+        if (!out_frame) {
+            av_log(avctx, AV_LOG_ERROR,
+                   "The returned surface does not correspond to any frame\n");
+            av_freep(&sync);
+            return AVERROR_BUG;
+        }
 
-    if (MFX_ERR_MORE_DATA!=ret && ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Error %d during QSV decoding.\n", ret);
-        return ff_qsv_error(ret);
+        out_frame->queued = 1;
+        av_fifo_generic_write(q->async_fifo, &out_frame, sizeof(out_frame), NULL);
+        av_fifo_generic_write(q->async_fifo, &sync,      sizeof(sync),      NULL);
+    } else {
+        av_freep(&sync);
     }
-    n_out_frames = av_fifo_size(q->async_fifo) / (sizeof(out_frame)+sizeof(sync));
 
-    if (n_out_frames > q->async_depth || (flush && n_out_frames) ) {
+    if (!av_fifo_space(q->async_fifo) ||
+        (!avpkt->size && av_fifo_size(q->async_fifo))) {
         AVFrame *src_frame;
 
         av_fifo_generic_read(q->async_fifo, &out_frame, sizeof(out_frame), NULL);
         av_fifo_generic_read(q->async_fifo, &sync,      sizeof(sync),      NULL);
         out_frame->queued = 0;
 
-        do {
-            ret = MFXVideoCORE_SyncOperation(q->session, sync, 1000);
-        } while (ret == MFX_WRN_IN_EXECUTION);
+        if (avctx->pix_fmt != AV_PIX_FMT_QSV) {
+            do {
+                ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
+            } while (ret == MFX_WRN_IN_EXECUTION);
+        }
+
+        av_freep(&sync);
 
         src_frame = out_frame->frame;
 
@@ -441,7 +389,7 @@ static int do_qsv_decode(AVCodecContext *avctx, QSVContext *q,
         if (ret < 0)
             return ret;
 
-        outsurf = out_frame->surface;
+        outsurf = &out_frame->surface;
 
 #if FF_API_PKT_PTS
 FF_DISABLE_DEPRECATION_WARNINGS
@@ -459,152 +407,132 @@ FF_ENABLE_DEPRECATION_WARNINGS
         frame->interlaced_frame =
             !(outsurf->Info.PicStruct & MFX_PICSTRUCT_PROGRESSIVE);
 
+        /* update the surface properties */
+        if (avctx->pix_fmt == AV_PIX_FMT_QSV)
+            ((mfxFrameSurface1*)frame->data[3])->Info = outsurf->Info;
+
         *got_frame = 1;
     }
 
-    return avpkt->size;
+    return bs.DataOffset;
 }
-/*
- This function inserts a packet at fifo front.
-*/
-static void qsv_packet_push_front(QSVContext *q, AVPacket *avpkt)
-{
-    int fifo_size = av_fifo_size(q->pkt_fifo);
-    if (!fifo_size) {
-    /* easy case fifo is empty */
-        av_fifo_generic_write(q->pkt_fifo, avpkt, sizeof(*avpkt), NULL);
-    } else {
-    /* realloc necessary */
-        AVPacket pkt;
-        AVFifoBuffer *fifo = av_fifo_alloc(fifo_size+av_fifo_space(q->pkt_fifo));
-
-        av_fifo_generic_write(fifo, avpkt, sizeof(*avpkt), NULL);
 
-        while (av_fifo_size(q->pkt_fifo)) {
-            av_fifo_generic_read(q->pkt_fifo, &pkt, sizeof(pkt), NULL);
-            av_fifo_generic_write(fifo,       &pkt, sizeof(pkt), NULL);
-        }
-        av_fifo_free(q->pkt_fifo);
-        q->pkt_fifo = fifo;
-    }
-}
-int ff_qsv_decode(AVCodecContext *avctx, QSVContext *q,
-                  AVFrame *frame, int *got_frame,
-                  AVPacket *avpkt)
+int ff_qsv_decode_close(QSVContext *q)
 {
-    AVPacket pkt_ref = { 0 };
-    int ret = 0;
+    QSVFrame *cur = q->work_frames;
 
-    if (q->pkt_fifo && av_fifo_size(q->pkt_fifo) >= sizeof(AVPacket)) {
-        /* we already have got some buffered packets. so add new to tail */
-        ret = av_packet_ref(&pkt_ref, avpkt);
-        if (ret < 0)
-            return ret;
-        av_fifo_generic_write(q->pkt_fifo, &pkt_ref, sizeof(pkt_ref), NULL);
-    }
-    if (q->reinit_pending) {
-        ret = do_qsv_decode(avctx, q, frame, got_frame, avpkt);
+    if (q->session)
+        MFXVideoDECODE_Close(q->session);
 
-        if (!*got_frame) {
-            /* Flushing complete, no more frames  */
-            close_decoder(q);
-            //return ff_qsv_decode(avctx, q, frame, got_frame, avpkt);
-        }
-    }
-    if (!q->reinit_pending) {
-        if (q->pkt_fifo && av_fifo_size(q->pkt_fifo) >= sizeof(AVPacket)) {
-            /* process buffered packets */
-            while (!*got_frame && av_fifo_size(q->pkt_fifo) >= sizeof(AVPacket)) {
-                av_fifo_generic_read(q->pkt_fifo, &pkt_ref, sizeof(pkt_ref), NULL);
-                ret = do_qsv_decode(avctx, q, frame, got_frame, &pkt_ref);
-                if (q->reinit_pending) {
-                    /*
-                       A rare case: new reinit pending when buffering existing.
-                       We should to return the pkt_ref back to same place of fifo
-                    */
-                    qsv_packet_push_front(q, &pkt_ref);
-                } else {
-                    av_packet_unref(&pkt_ref);
-                }
-           }
-        } else {
-            /* general decoding */
-            ret = do_qsv_decode(avctx, q, frame, got_frame, avpkt);
-            if (q->reinit_pending) {
-                ret = av_packet_ref(&pkt_ref, avpkt);
-                if (ret < 0)
-                    return ret;
-                av_fifo_generic_write(q->pkt_fifo, &pkt_ref, sizeof(pkt_ref), NULL);
-            }
-        }
-    }
+    while (q->async_fifo && av_fifo_size(q->async_fifo)) {
+        QSVFrame *out_frame;
+        mfxSyncPoint *sync;
 
-    return ret;
-}
-/*
- This function resets decoder and corresponded buffers before seek operation
-*/
-void ff_qsv_decode_reset(AVCodecContext *avctx, QSVContext *q)
-{
-    QSVFrame *cur;
-    AVPacket pkt;
-    int ret = 0;
-    mfxVideoParam param = { { 0 } };
-
-    if (q->reinit_pending) {
-        close_decoder(q);
-    } else if (q->engine_ready) {
-        ret = MFXVideoDECODE_GetVideoParam(q->session, &param);
-        if (ret < 0) {
-            av_log(avctx, AV_LOG_ERROR, "MFX decode get param error %d\n", ret);
-        }
+        av_fifo_generic_read(q->async_fifo, &out_frame, sizeof(out_frame), NULL);
+        av_fifo_generic_read(q->async_fifo, &sync,      sizeof(sync),      NULL);
 
-        ret = MFXVideoDECODE_Reset(q->session, &param);
-        if (ret < 0) {
-            av_log(avctx, AV_LOG_ERROR, "MFX decode reset error %d\n", ret);
-        }
+        av_freep(&sync);
+    }
 
-        /* Free all frames*/
+    while (cur) {
+        q->work_frames = cur->next;
+        av_frame_free(&cur->frame);
+        av_freep(&cur);
         cur = q->work_frames;
-        while (cur) {
-            q->work_frames = cur->next;
-            av_frame_free(&cur->frame);
-            av_freep(&cur);
-            cur = q->work_frames;
-        }
     }
 
-    /* Reset output surfaces */
-    if (q->async_fifo)
-        av_fifo_reset(q->async_fifo);
+    av_fifo_free(q->async_fifo);
+    q->async_fifo = NULL;
 
-    /* Reset input packets fifo */
-    while (q->pkt_fifo && av_fifo_size(q->pkt_fifo)) {
-        av_fifo_generic_read(q->pkt_fifo, &pkt, sizeof(pkt), NULL);
-        av_packet_unref(&pkt);
-    }
+    av_parser_close(q->parser);
+    avcodec_free_context(&q->avctx_internal);
+
+    if (q->internal_session)
+        MFXClose(q->internal_session);
+
+    av_buffer_unref(&q->frames_ctx.hw_frames_ctx);
+    av_buffer_unref(&q->frames_ctx.mids_buf);
 
-    /* Reset input bitstream fifo */
-    if (q->input_fifo)
-        av_fifo_reset(q->input_fifo);
+    return 0;
 }
 
-int ff_qsv_decode_close(QSVContext *q)
+int ff_qsv_process_data(AVCodecContext *avctx, QSVContext *q,
+                        AVFrame *frame, int *got_frame, AVPacket *pkt)
 {
-    close_decoder(q);
+    uint8_t *dummy_data;
+    int dummy_size;
+    int ret;
 
-    q->session = NULL;
+    if (!q->avctx_internal) {
+        q->avctx_internal = avcodec_alloc_context3(NULL);
+        if (!q->avctx_internal)
+            return AVERROR(ENOMEM);
 
-    ff_qsv_close_internal_session(&q->internal_qs);
+        q->parser = av_parser_init(avctx->codec_id);
+        if (!q->parser)
+            return AVERROR(ENOMEM);
 
-    av_fifo_free(q->async_fifo);
-    q->async_fifo = NULL;
+        q->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
+        q->orig_pix_fmt   = AV_PIX_FMT_NONE;
+    }
 
-    av_fifo_free(q->input_fifo);
-    q->input_fifo = NULL;
+    if (!pkt->size)
+        return qsv_decode(avctx, q, frame, got_frame, pkt);
+
+    /* we assume the packets are already split properly and want
+     * just the codec parameters here */
+    av_parser_parse2(q->parser, q->avctx_internal,
+                     &dummy_data, &dummy_size,
+                     pkt->data, pkt->size, pkt->pts, pkt->dts,
+                     pkt->pos);
+
+    /* TODO: flush delayed frames on reinit */
+    if (q->parser->format       != q->orig_pix_fmt    ||
+        q->parser->coded_width  != avctx->coded_width ||
+        q->parser->coded_height != avctx->coded_height) {
+        enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_QSV,
+                                           AV_PIX_FMT_NONE,
+                                           AV_PIX_FMT_NONE };
+        enum AVPixelFormat qsv_format;
+
+        qsv_format = ff_qsv_map_pixfmt(q->parser->format, &q->fourcc);
+        if (qsv_format < 0) {
+            av_log(avctx, AV_LOG_ERROR,
+                   "Decoding pixel format '%s' is not supported\n",
+                   av_get_pix_fmt_name(q->parser->format));
+            ret = AVERROR(ENOSYS);
+            goto reinit_fail;
+        }
 
-    av_fifo_free(q->pkt_fifo);
-    q->pkt_fifo = NULL;
+        q->orig_pix_fmt     = q->parser->format;
+        avctx->pix_fmt      = pix_fmts[1] = qsv_format;
+        avctx->width        = q->parser->width;
+        avctx->height       = q->parser->height;
+        avctx->coded_width  = q->parser->coded_width;
+        avctx->coded_height = q->parser->coded_height;
+        avctx->field_order  = q->parser->field_order;
+        avctx->level        = q->avctx_internal->level;
+        avctx->profile      = q->avctx_internal->profile;
+
+        ret = ff_get_format(avctx, pix_fmts);
+        if (ret < 0)
+            goto reinit_fail;
 
-    return 0;
+        avctx->pix_fmt = ret;
+
+        ret = qsv_decode_init(avctx, q);
+        if (ret < 0)
+            goto reinit_fail;
+    }
+
+    return qsv_decode(avctx, q, frame, got_frame, pkt);
+
+reinit_fail:
+    q->orig_pix_fmt = q->parser->format = avctx->pix_fmt = AV_PIX_FMT_NONE;
+    return ret;
+}
+
+void ff_qsv_decode_flush(AVCodecContext *avctx, QSVContext *q)
+{
+    q->orig_pix_fmt = AV_PIX_FMT_NONE;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/qsvdec.h b/mythtv/external/FFmpeg/libavcodec/qsvdec.h
index 97a3315b75b..4e86e4b7f8f 100644
--- a/mythtv/external/FFmpeg/libavcodec/qsvdec.h
+++ b/mythtv/external/FFmpeg/libavcodec/qsvdec.h
@@ -41,7 +41,9 @@ typedef struct QSVContext {
 
     // the session we allocated internally, in case the caller did not provide
     // one
-    QSVSession internal_qs;
+    mfxSession internal_session;
+
+    QSVFramesContext frames_ctx;
 
     /**
      * a linked list of frames currently being used by QSV
@@ -49,22 +51,14 @@ typedef struct QSVContext {
     QSVFrame *work_frames;
 
     AVFifoBuffer *async_fifo;
-    AVFifoBuffer *input_fifo;
-
-    // we should to buffer input packets at some cases
-    // else it is not possible to handle dynamic stream changes correctly
-    // this fifo uses for input packets buffering
-    AVFifoBuffer *pkt_fifo;
+    int zero_consume_run;
 
-    // this flag indicates that header parsed,
-    // decoder instance created and ready to general decoding
-    int engine_ready;
-
-    // we can not just re-init decoder if different sequence header arrived
-    // we should to deliver all buffered frames but we can not decode new packets
-    // this time. So when reinit_pending is non-zero we flushing decoder and
-    // accumulate new arrived packets into pkt_fifo
-    int reinit_pending;
+    // the internal parser and codec context for parsing the data
+    AVCodecParserContext *parser;
+    AVCodecContext *avctx_internal;
+    enum AVPixelFormat orig_pix_fmt;
+    uint32_t fourcc;
+    mfxFrameInfo frame_info;
 
     // options set by the caller
     int async_depth;
@@ -76,13 +70,10 @@ typedef struct QSVContext {
     int         nb_ext_buffers;
 } QSVContext;
 
-int ff_qsv_map_pixfmt(enum AVPixelFormat format);
-
-int ff_qsv_decode(AVCodecContext *s, QSVContext *q,
-                  AVFrame *frame, int *got_frame,
-                  AVPacket *avpkt);
+int ff_qsv_process_data(AVCodecContext *avctx, QSVContext *q,
+                        AVFrame *frame, int *got_frame, AVPacket *pkt);
 
-void ff_qsv_decode_reset(AVCodecContext *avctx, QSVContext *q);
+void ff_qsv_decode_flush(AVCodecContext *avctx, QSVContext *q);
 
 int ff_qsv_decode_close(QSVContext *q);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/qsvdec_h2645.c b/mythtv/external/FFmpeg/libavcodec/qsvdec_h2645.c
index 98a19520b69..a6b53cce8db 100644
--- a/mythtv/external/FFmpeg/libavcodec/qsvdec_h2645.c
+++ b/mythtv/external/FFmpeg/libavcodec/qsvdec_h2645.c
@@ -33,11 +33,14 @@
 
 #include "avcodec.h"
 #include "internal.h"
+#include "qsv_internal.h"
 #include "qsvdec.h"
+#include "qsv.h"
 
 enum LoadPlugin {
     LOAD_PLUGIN_NONE,
     LOAD_PLUGIN_HEVC_SW,
+    LOAD_PLUGIN_HEVC_HW,
 };
 
 typedef struct QSVH2645Context {
@@ -46,12 +49,9 @@ typedef struct QSVH2645Context {
 
     int load_plugin;
 
-    // the filter for converting to Annex B
-    AVBSFContext *bsf;
-
     AVFifoBuffer *packet_fifo;
 
-    AVPacket pkt_filtered;
+    AVPacket buffer_pkt;
 } QSVH2645Context;
 
 static void qsv_clear_buffers(QSVH2645Context *s)
@@ -62,9 +62,7 @@ static void qsv_clear_buffers(QSVH2645Context *s)
         av_packet_unref(&pkt);
     }
 
-    av_bsf_free(&s->bsf);
-
-    av_packet_unref(&s->pkt_filtered);
+    av_packet_unref(&s->buffer_pkt);
 }
 
 static av_cold int qsv_decode_close(AVCodecContext *avctx)
@@ -86,7 +84,8 @@ static av_cold int qsv_decode_init(AVCodecContext *avctx)
     int ret;
 
     if (avctx->codec_id == AV_CODEC_ID_HEVC && s->load_plugin != LOAD_PLUGIN_NONE) {
-        static const char *uid_hevcenc_sw = "15dd936825ad475ea34e35f3f54217a6";
+        static const char * const uid_hevcdec_sw = "15dd936825ad475ea34e35f3f54217a6";
+        static const char * const uid_hevcdec_hw = "33a61c0b4c27454ca8d85dde757c6f8e";
 
         if (s->qsv.load_plugins[0]) {
             av_log(avctx, AV_LOG_WARNING,
@@ -94,59 +93,28 @@ static av_cold int qsv_decode_init(AVCodecContext *avctx)
                    "The load_plugin value will be ignored.\n");
         } else {
             av_freep(&s->qsv.load_plugins);
-            s->qsv.load_plugins = av_strdup(uid_hevcenc_sw);
+
+            if (s->load_plugin == LOAD_PLUGIN_HEVC_SW)
+                s->qsv.load_plugins = av_strdup(uid_hevcdec_sw);
+            else
+                s->qsv.load_plugins = av_strdup(uid_hevcdec_hw);
             if (!s->qsv.load_plugins)
                 return AVERROR(ENOMEM);
         }
     }
+
     s->packet_fifo = av_fifo_alloc(sizeof(AVPacket));
     if (!s->packet_fifo) {
         ret = AVERROR(ENOMEM);
         goto fail;
     }
 
-    if (avctx->codec_id == AV_CODEC_ID_H264) {
-        //regarding ticks_per_frame description, should be 2 for h.264:
-        avctx->ticks_per_frame = 2;
-    }
-
     return 0;
 fail:
     qsv_decode_close(avctx);
     return ret;
 }
 
-static int qsv_init_bsf(AVCodecContext *avctx, QSVH2645Context *s)
-{
-    const char *filter_name = avctx->codec_id == AV_CODEC_ID_HEVC ?
-                              "hevc_mp4toannexb" : "h264_mp4toannexb";
-    const AVBitStreamFilter *filter;
-    int ret;
-
-    if (s->bsf)
-        return 0;
-
-    filter = av_bsf_get_by_name(filter_name);
-    if (!filter)
-        return AVERROR_BUG;
-
-    ret = av_bsf_alloc(filter, &s->bsf);
-    if (ret < 0)
-        return ret;
-
-    ret = avcodec_parameters_from_context(s->bsf->par_in, avctx);
-    if (ret < 0)
-        return ret;
-
-    s->bsf->time_base_in = avctx->time_base;
-
-    ret = av_bsf_init(s->bsf);
-    if (ret < 0)
-        return ret;
-
-    return ret;
-}
-
 static int qsv_decode_frame(AVCodecContext *avctx, void *data,
                             int *got_frame, AVPacket *avpkt)
 {
@@ -154,11 +122,6 @@ static int qsv_decode_frame(AVCodecContext *avctx, void *data,
     AVFrame *frame    = data;
     int ret;
 
-    /* make sure the bitstream filter is initialized */
-    ret = qsv_init_bsf(avctx, s);
-    if (ret < 0)
-        return ret;
-
     /* buffer the input packet */
     if (avpkt->size) {
         AVPacket input_ref = { 0 };
@@ -178,36 +141,23 @@ static int qsv_decode_frame(AVCodecContext *avctx, void *data,
 
     /* process buffered data */
     while (!*got_frame) {
-        /* prepare the input data -- convert to Annex B if needed */
-        if (s->pkt_filtered.size <= 0) {
-            AVPacket input_ref;
-
+        /* prepare the input data */
+        if (s->buffer_pkt.size <= 0) {
             /* no more data */
             if (av_fifo_size(s->packet_fifo) < sizeof(AVPacket))
-                return avpkt->size ? avpkt->size : ff_qsv_decode(avctx, &s->qsv, frame, got_frame, avpkt);
+                return avpkt->size ? avpkt->size : ff_qsv_process_data(avctx, &s->qsv, frame, got_frame, avpkt);
 
-            av_packet_unref(&s->pkt_filtered);
+            av_packet_unref(&s->buffer_pkt);
 
-            av_fifo_generic_read(s->packet_fifo, &input_ref, sizeof(input_ref), NULL);
-            ret = av_bsf_send_packet(s->bsf, &input_ref);
-            if (ret < 0) {
-                av_packet_unref(&input_ref);
-                return ret;
-            }
-
-            ret = av_bsf_receive_packet(s->bsf, &s->pkt_filtered);
-            if (ret < 0)
-                av_packet_move_ref(&s->pkt_filtered, &input_ref);
-            else
-                av_packet_unref(&input_ref);
+            av_fifo_generic_read(s->packet_fifo, &s->buffer_pkt, sizeof(s->buffer_pkt), NULL);
         }
 
-        ret = ff_qsv_decode(avctx, &s->qsv, frame, got_frame, &s->pkt_filtered);
+        ret = ff_qsv_process_data(avctx, &s->qsv, frame, got_frame, &s->buffer_pkt);
         if (ret < 0)
             return ret;
 
-        s->pkt_filtered.size -= ret;
-        s->pkt_filtered.data += ret;
+        s->buffer_pkt.size -= ret;
+        s->buffer_pkt.data += ret;
     }
 
     return avpkt->size;
@@ -216,26 +166,31 @@ static int qsv_decode_frame(AVCodecContext *avctx, void *data,
 static void qsv_decode_flush(AVCodecContext *avctx)
 {
     QSVH2645Context *s = avctx->priv_data;
-    ff_qsv_decode_reset(avctx, &s->qsv);
+
+    qsv_clear_buffers(s);
+    ff_qsv_decode_flush(avctx, &s->qsv);
 }
 
 #define OFFSET(x) offsetof(QSVH2645Context, x)
 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
 
-#if CONFIG_HEVC_QSV_DECODER
+#if CONFIG_HEVC_QSV_HWACCEL
 AVHWAccel ff_hevc_qsv_hwaccel = {
     .name           = "hevc_qsv",
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_HEVC,
     .pix_fmt        = AV_PIX_FMT_QSV,
 };
+#endif
 
+#if CONFIG_HEVC_QSV_DECODER
 static const AVOption hevc_options[] = {
     { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(qsv.async_depth), AV_OPT_TYPE_INT, { .i64 = ASYNC_DEPTH_DEFAULT }, 0, INT_MAX, VD },
 
-    { "load_plugin", "A user plugin to load in an internal session", OFFSET(load_plugin), AV_OPT_TYPE_INT, { .i64 = LOAD_PLUGIN_HEVC_SW }, LOAD_PLUGIN_NONE, LOAD_PLUGIN_HEVC_SW, VD, "load_plugin" },
+    { "load_plugin", "A user plugin to load in an internal session", OFFSET(load_plugin), AV_OPT_TYPE_INT, { .i64 = LOAD_PLUGIN_HEVC_SW }, LOAD_PLUGIN_NONE, LOAD_PLUGIN_HEVC_HW, VD, "load_plugin" },
     { "none",     NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LOAD_PLUGIN_NONE },    0, 0, VD, "load_plugin" },
     { "hevc_sw",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LOAD_PLUGIN_HEVC_SW }, 0, 0, VD, "load_plugin" },
+    { "hevc_hw",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LOAD_PLUGIN_HEVC_HW }, 0, 0, VD, "load_plugin" },
 
     { "load_plugins", "A :-separate list of hexadecimal plugin UIDs to load in an internal session",
         OFFSET(qsv.load_plugins), AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VD },
@@ -259,22 +214,26 @@ AVCodec ff_hevc_qsv_decoder = {
     .decode         = qsv_decode_frame,
     .flush          = qsv_decode_flush,
     .close          = qsv_decode_close,
-    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_AVOID_PROBING,
     .priv_class     = &hevc_class,
     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+                                                    AV_PIX_FMT_P010,
                                                     AV_PIX_FMT_QSV,
                                                     AV_PIX_FMT_NONE },
+    .bsfs           = "hevc_mp4toannexb",
 };
 #endif
 
-#if CONFIG_H264_QSV_DECODER
+#if CONFIG_H264_QSV_HWACCEL
 AVHWAccel ff_h264_qsv_hwaccel = {
     .name           = "h264_qsv",
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H264,
     .pix_fmt        = AV_PIX_FMT_QSV,
 };
+#endif
 
+#if CONFIG_H264_QSV_DECODER
 static const AVOption options[] = {
     { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(qsv.async_depth), AV_OPT_TYPE_INT, { .i64 = ASYNC_DEPTH_DEFAULT }, 0, INT_MAX, VD },
     { NULL },
@@ -297,10 +256,12 @@ AVCodec ff_h264_qsv_decoder = {
     .decode         = qsv_decode_frame,
     .flush          = qsv_decode_flush,
     .close          = qsv_decode_close,
-    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_AVOID_PROBING,
     .priv_class     = &class,
     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+                                                    AV_PIX_FMT_P010,
                                                     AV_PIX_FMT_QSV,
                                                     AV_PIX_FMT_NONE },
+    .bsfs           = "h264_mp4toannexb",
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/qsvdec_mpeg2.c b/mythtv/external/FFmpeg/libavcodec/qsvdec_mpeg2.c
deleted file mode 100644
index 70ccbc5949d..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/qsvdec_mpeg2.c
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Intel MediaSDK QSV based MPEG-2 video decoder
- *
- * 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 <stdint.h>
-#include <string.h>
-
-#include "libavutil/common.h"
-#include "libavutil/opt.h"
-
-#include "avcodec.h"
-#include "qsvdec.h"
-
-typedef struct QSVMPEG2Context {
-    AVClass *class;
-    QSVContext qsv;
-} QSVMPEG2Context;
-
-static av_cold int qsv_decode_close(AVCodecContext *avctx)
-{
-    QSVMPEG2Context *s = avctx->priv_data;
-
-    ff_qsv_decode_close(&s->qsv);
-
-    return 0;
-}
-
-static av_cold int qsv_decode_init(AVCodecContext *avctx)
-{
-    return 0;
-}
-
-static int qsv_decode_frame(AVCodecContext *avctx, void *data,
-                            int *got_frame, AVPacket *avpkt)
-{
-    QSVMPEG2Context *s = avctx->priv_data;
-    AVFrame *frame    = data;
-
-    return ff_qsv_decode(avctx, &s->qsv, frame, got_frame, avpkt);
-}
-
-static void qsv_decode_flush(AVCodecContext *avctx)
-{
-    QSVMPEG2Context *s = avctx->priv_data;
-    ff_qsv_decode_reset(avctx, &s->qsv);
-}
-
-AVHWAccel ff_mpeg2_qsv_hwaccel = {
-    .name           = "mpeg2_qsv",
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_MPEG2VIDEO,
-    .pix_fmt        = AV_PIX_FMT_QSV,
-};
-
-#define OFFSET(x) offsetof(QSVMPEG2Context, x)
-#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
-static const AVOption options[] = {
-    { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(qsv.async_depth), AV_OPT_TYPE_INT, { .i64 = ASYNC_DEPTH_DEFAULT }, 0, INT_MAX, VD },
-    { NULL },
-};
-
-static const AVClass class = {
-    .class_name = "mpeg2_qsv",
-    .item_name  = av_default_item_name,
-    .option     = options,
-    .version    = LIBAVUTIL_VERSION_INT,
-};
-
-AVCodec ff_mpeg2_qsv_decoder = {
-    .name           = "mpeg2_qsv",
-    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 video (Intel Quick Sync Video acceleration)"),
-    .priv_data_size = sizeof(QSVMPEG2Context),
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_MPEG2VIDEO,
-    .init           = qsv_decode_init,
-    .decode         = qsv_decode_frame,
-    .flush          = qsv_decode_flush,
-    .close          = qsv_decode_close,
-    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1,
-    .priv_class     = &class,
-    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
-                                                    AV_PIX_FMT_QSV,
-                                                    AV_PIX_FMT_NONE },
-};
diff --git a/mythtv/external/FFmpeg/libavcodec/qsvdec_other.c b/mythtv/external/FFmpeg/libavcodec/qsvdec_other.c
new file mode 100644
index 00000000000..b94093d53c7
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/qsvdec_other.c
@@ -0,0 +1,264 @@
+/*
+ * Intel MediaSDK QSV based MPEG-2, VC-1 and VP8 decoders
+ *
+ * copyright (c) 2015 Anton Khirnov
+ *
+ * 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 <stdint.h>
+#include <string.h>
+
+#include <mfx/mfxvideo.h>
+
+#include "libavutil/common.h"
+#include "libavutil/fifo.h"
+#include "libavutil/opt.h"
+
+#include "avcodec.h"
+#include "internal.h"
+#include "qsv_internal.h"
+#include "qsvdec.h"
+#include "qsv.h"
+
+typedef struct QSVOtherContext {
+    AVClass *class;
+    QSVContext qsv;
+
+    AVFifoBuffer *packet_fifo;
+
+    AVPacket input_ref;
+} QSVOtherContext;
+
+static void qsv_clear_buffers(QSVOtherContext *s)
+{
+    AVPacket pkt;
+    while (av_fifo_size(s->packet_fifo) >= sizeof(pkt)) {
+        av_fifo_generic_read(s->packet_fifo, &pkt, sizeof(pkt), NULL);
+        av_packet_unref(&pkt);
+    }
+
+    av_packet_unref(&s->input_ref);
+}
+
+static av_cold int qsv_decode_close(AVCodecContext *avctx)
+{
+    QSVOtherContext *s = avctx->priv_data;
+
+    ff_qsv_decode_close(&s->qsv);
+
+    qsv_clear_buffers(s);
+
+    av_fifo_free(s->packet_fifo);
+
+    return 0;
+}
+
+static av_cold int qsv_decode_init(AVCodecContext *avctx)
+{
+    QSVOtherContext *s = avctx->priv_data;
+    int ret;
+
+#if CONFIG_VP8_QSV_DECODER
+    if (avctx->codec_id == AV_CODEC_ID_VP8) {
+        static const char *uid_vp8dec_hw = "f622394d8d87452f878c51f2fc9b4131";
+
+        av_freep(&s->qsv.load_plugins);
+        s->qsv.load_plugins = av_strdup(uid_vp8dec_hw);
+        if (!s->qsv.load_plugins)
+            return AVERROR(ENOMEM);
+    }
+#endif
+
+    s->packet_fifo = av_fifo_alloc(sizeof(AVPacket));
+    if (!s->packet_fifo) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    return 0;
+fail:
+    qsv_decode_close(avctx);
+    return ret;
+}
+
+static int qsv_decode_frame(AVCodecContext *avctx, void *data,
+                            int *got_frame, AVPacket *avpkt)
+{
+    QSVOtherContext *s = avctx->priv_data;
+    AVFrame *frame    = data;
+    int ret;
+
+    /* buffer the input packet */
+    if (avpkt->size) {
+        AVPacket input_ref = { 0 };
+
+        if (av_fifo_space(s->packet_fifo) < sizeof(input_ref)) {
+            ret = av_fifo_realloc2(s->packet_fifo,
+                                   av_fifo_size(s->packet_fifo) + sizeof(input_ref));
+            if (ret < 0)
+                return ret;
+        }
+
+        ret = av_packet_ref(&input_ref, avpkt);
+        if (ret < 0)
+            return ret;
+        av_fifo_generic_write(s->packet_fifo, &input_ref, sizeof(input_ref), NULL);
+    }
+
+    /* process buffered data */
+    while (!*got_frame) {
+        if (s->input_ref.size <= 0) {
+            /* no more data */
+            if (av_fifo_size(s->packet_fifo) < sizeof(AVPacket))
+                return avpkt->size ? avpkt->size : ff_qsv_process_data(avctx, &s->qsv, frame, got_frame, avpkt);
+
+            av_packet_unref(&s->input_ref);
+            av_fifo_generic_read(s->packet_fifo, &s->input_ref, sizeof(s->input_ref), NULL);
+        }
+
+        ret = ff_qsv_process_data(avctx, &s->qsv, frame, got_frame, &s->input_ref);
+        if (ret < 0)
+            return ret;
+
+        s->input_ref.size -= ret;
+        s->input_ref.data += ret;
+    }
+
+    return avpkt->size;
+}
+
+static void qsv_decode_flush(AVCodecContext *avctx)
+{
+    QSVOtherContext *s = avctx->priv_data;
+
+    qsv_clear_buffers(s);
+    ff_qsv_decode_flush(avctx, &s->qsv);
+}
+
+#define OFFSET(x) offsetof(QSVOtherContext, x)
+#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
+static const AVOption options[] = {
+    { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(qsv.async_depth), AV_OPT_TYPE_INT, { .i64 = ASYNC_DEPTH_DEFAULT }, 0, INT_MAX, VD },
+    { NULL },
+};
+
+#if CONFIG_MPEG2_QSV_HWACCEL
+AVHWAccel ff_mpeg2_qsv_hwaccel = {
+    .name           = "mpeg2_qsv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_MPEG2VIDEO,
+    .pix_fmt        = AV_PIX_FMT_QSV,
+};
+#endif
+
+#if CONFIG_MPEG2_QSV_DECODER
+static const AVClass mpeg2_qsv_class = {
+    .class_name = "mpeg2_qsv",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVCodec ff_mpeg2_qsv_decoder = {
+    .name           = "mpeg2_qsv",
+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 video (Intel Quick Sync Video acceleration)"),
+    .priv_data_size = sizeof(QSVOtherContext),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_MPEG2VIDEO,
+    .init           = qsv_decode_init,
+    .decode         = qsv_decode_frame,
+    .flush          = qsv_decode_flush,
+    .close          = qsv_decode_close,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_AVOID_PROBING,
+    .priv_class     = &mpeg2_qsv_class,
+    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+                                                    AV_PIX_FMT_QSV,
+                                                    AV_PIX_FMT_NONE },
+};
+#endif
+
+#if CONFIG_VC1_QSV_HWACCEL
+AVHWAccel ff_vc1_qsv_hwaccel = {
+    .name           = "vc1_qsv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_VC1,
+    .pix_fmt        = AV_PIX_FMT_QSV,
+};
+#endif
+
+#if CONFIG_VC1_QSV_DECODER
+static const AVClass vc1_qsv_class = {
+    .class_name = "vc1_qsv",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVCodec ff_vc1_qsv_decoder = {
+    .name           = "vc1_qsv",
+    .long_name      = NULL_IF_CONFIG_SMALL("VC-1 video (Intel Quick Sync Video acceleration)"),
+    .priv_data_size = sizeof(QSVOtherContext),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_VC1,
+    .init           = qsv_decode_init,
+    .decode         = qsv_decode_frame,
+    .flush          = qsv_decode_flush,
+    .close          = qsv_decode_close,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_AVOID_PROBING,
+    .priv_class     = &vc1_qsv_class,
+    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+                                                    AV_PIX_FMT_QSV,
+                                                    AV_PIX_FMT_NONE },
+};
+#endif
+
+#if CONFIG_VP8_QSV_HWACCEL
+AVHWAccel ff_vp8_qsv_hwaccel = {
+    .name           = "vp8_qsv",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_VP8,
+    .pix_fmt        = AV_PIX_FMT_QSV,
+};
+#endif
+
+#if CONFIG_VP8_QSV_DECODER
+static const AVClass vp8_qsv_class = {
+    .class_name = "vp8_qsv",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVCodec ff_vp8_qsv_decoder = {
+    .name           = "vp8_qsv",
+    .long_name      = NULL_IF_CONFIG_SMALL("VP8 video (Intel Quick Sync Video acceleration)"),
+    .priv_data_size = sizeof(QSVOtherContext),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_VP8,
+    .init           = qsv_decode_init,
+    .decode         = qsv_decode_frame,
+    .flush          = qsv_decode_flush,
+    .close          = qsv_decode_close,
+    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_AVOID_PROBING,
+    .priv_class     = &vp8_qsv_class,
+    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+                                                    AV_PIX_FMT_QSV,
+                                                    AV_PIX_FMT_NONE },
+};
+#endif
diff --git a/mythtv/external/FFmpeg/libavcodec/qsvdec_vc1.c b/mythtv/external/FFmpeg/libavcodec/qsvdec_vc1.c
deleted file mode 100644
index fcf101f7587..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/qsvdec_vc1.c
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Intel MediaSDK QSV based VC-1 video decoder
- *
- * 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 <stdint.h>
-#include <string.h>
-
-#include "libavutil/common.h"
-#include "libavutil/fifo.h"
-#include "libavutil/opt.h"
-
-#include "avcodec.h"
-#include "qsvdec.h"
-
-typedef struct QSVVC1Context {
-    AVClass *class;
-    QSVContext qsv;
-} QSVVC1Context;
-
-
-static av_cold int qsv_decode_close(AVCodecContext *avctx)
-{
-    QSVVC1Context *s = avctx->priv_data;
-
-    ff_qsv_decode_close(&s->qsv);
-
-    return 0;
-}
-
-static int qsv_decode_frame(AVCodecContext *avctx, void *data,
-                            int *got_frame, AVPacket *avpkt)
-{
-    QSVVC1Context *s = avctx->priv_data;
-    AVFrame *frame    = data;
-
-    return ff_qsv_decode(avctx, &s->qsv, frame, got_frame, avpkt);
-}
-
-static void qsv_decode_flush(AVCodecContext *avctx)
-{
-    QSVVC1Context *s = avctx->priv_data;
-    ff_qsv_decode_reset(avctx, &s->qsv);
-}
-
-AVHWAccel ff_vc1_qsv_hwaccel = {
-    .name           = "vc1_qsv",
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_VC1,
-    .pix_fmt        = AV_PIX_FMT_QSV,
-};
-
-#define OFFSET(x) offsetof(QSVVC1Context, x)
-#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
-static const AVOption options[] = {
-    { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(qsv.async_depth), AV_OPT_TYPE_INT, { .i64 = ASYNC_DEPTH_DEFAULT }, 0, INT_MAX, VD },
-    { NULL },
-};
-
-static const AVClass class = {
-    .class_name = "vc1_qsv",
-    .item_name  = av_default_item_name,
-    .option     = options,
-    .version    = LIBAVUTIL_VERSION_INT,
-};
-
-AVCodec ff_vc1_qsv_decoder = {
-    .name           = "vc1_qsv",
-    .long_name      = NULL_IF_CONFIG_SMALL("VC-1 video (Intel Quick Sync Video acceleration)"),
-    .priv_data_size = sizeof(QSVVC1Context),
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_VC1,
-    .init           = NULL,
-    .decode         = qsv_decode_frame,
-    .flush          = qsv_decode_flush,
-    .close          = qsv_decode_close,
-    .capabilities   = AV_CODEC_CAP_DELAY,
-    .priv_class     = &class,
-    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
-                                                    AV_PIX_FMT_QSV,
-                                                    AV_PIX_FMT_NONE },
-};
diff --git a/mythtv/external/FFmpeg/libavcodec/qsvenc.c b/mythtv/external/FFmpeg/libavcodec/qsvenc.c
index f56cb612b6f..5eb506fb762 100644
--- a/mythtv/external/FFmpeg/libavcodec/qsvenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/qsvenc.c
@@ -26,6 +26,8 @@
 #include <mfx/mfxvideo.h>
 
 #include "libavutil/common.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_qsv.h"
 #include "libavutil/mem.h"
 #include "libavutil/log.h"
 #include "libavutil/time.h"
@@ -132,9 +134,6 @@ static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q,
 #if QSV_HAVE_CO2
     mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[1];
 #endif
-#if QSV_HAVE_CO3
-    mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[2];
-#endif
 
     av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
            print_profile(info->CodecProfile), info->CodecLevel);
@@ -186,12 +185,6 @@ static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q,
                info->ICQQuality, co2->LookAheadDepth);
     }
 #endif
-#if QSV_HAVE_QVBR
-    else if (info->RateControlMethod == MFX_RATECONTROL_QVBR) {
-        av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n",
-               co3->QVBRQuality);
-    }
-#endif
 
     av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
            info->NumSlice, info->NumRefFrame);
@@ -354,6 +347,9 @@ static int rc_supported(QSVEncContext *q)
 
 static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
 {
+    enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
+                                   avctx->sw_pix_fmt : avctx->pix_fmt;
+    const AVPixFmtDescriptor *desc;
     float quant;
     int ret;
 
@@ -362,8 +358,6 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
         return AVERROR_BUG;
     q->param.mfx.CodecId = ret;
 
-    q->width_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
-
     if (avctx->level > 0)
         q->param.mfx.CodecLevel = avctx->level;
 
@@ -379,7 +373,12 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
     q->param.mfx.EncodedOrder       = 0;
     q->param.mfx.BufferSizeInKB     = 0;
 
-    q->param.mfx.FrameInfo.FourCC         = MFX_FOURCC_NV12;
+    desc = av_pix_fmt_desc_get(sw_format);
+    if (!desc)
+        return AVERROR_BUG;
+
+    ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
+
     q->param.mfx.FrameInfo.CropX          = 0;
     q->param.mfx.FrameInfo.CropY          = 0;
     q->param.mfx.FrameInfo.CropW          = avctx->width;
@@ -387,23 +386,38 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
     q->param.mfx.FrameInfo.AspectRatioW   = avctx->sample_aspect_ratio.num;
     q->param.mfx.FrameInfo.AspectRatioH   = avctx->sample_aspect_ratio.den;
     q->param.mfx.FrameInfo.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
-    q->param.mfx.FrameInfo.BitDepthLuma   = 8;
-    q->param.mfx.FrameInfo.BitDepthChroma = 8;
-    q->param.mfx.FrameInfo.Width          = FFALIGN(avctx->width, q->width_align);
+    q->param.mfx.FrameInfo.BitDepthLuma   = desc->comp[0].depth;
+    q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
+    q->param.mfx.FrameInfo.Shift          = desc->comp[0].depth > 8;
+
+    // TODO:  detect version of MFX--if the minor version is greater than
+    // or equal to 19, then can use the same alignment settings as H.264
+    // for HEVC
+    q->width_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
+    q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
 
     if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
-       /* A true field layout (TFF or BFF) is not important here,
-          it will specified later during frame encoding. But it is important
-          to specify is frame progressive or not because allowed heigh alignment
-          does depend by this.
-        */
+        // it is important that PicStruct be setup correctly from the
+        // start--otherwise, encoding doesn't work and results in a bunch
+        // of incompatible video parameter errors
         q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
+        // height alignment always must be 32 for interlaced video
         q->height_align = 32;
     } else {
         q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
-        q->height_align = 16;
+        // for progressive video, the height should be aligned to 16 for
+        // H.264.  For HEVC, depending on the version of MFX, it should be
+        // either 32 or 16.  The lower number is better if possible.
+        q->height_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
+    }
+    q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
+
+    if (avctx->hw_frames_ctx) {
+        AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+        AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
+        q->param.mfx.FrameInfo.Width  = frames_hwctx->surfaces[0].Info.Width;
+        q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
     }
-   q->param.mfx.FrameInfo.Height    = FFALIGN(avctx->height, q->height_align);
 
     if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
         q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
@@ -536,7 +550,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
             q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
 
-#if QSV_VERSION_ATLEAST(1,8)
+#if QSV_HAVE_LA_DS
             q->extco2.LookAheadDS           = q->look_ahead_downsampling;
 #endif
         }
@@ -577,21 +591,12 @@ static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
         .Header.BufferSz = sizeof(co2),
     };
 #endif
-#if QSV_HAVE_CO3
-    mfxExtCodingOption3 co3 = {
-        .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
-        .Header.BufferSz = sizeof(co3),
-    };
-#endif
 
     mfxExtBuffer *ext_buffers[] = {
         (mfxExtBuffer*)&extradata,
         (mfxExtBuffer*)&co,
 #if QSV_HAVE_CO2
         (mfxExtBuffer*)&co2,
-#endif
-#if QSV_HAVE_CO3
-        (mfxExtBuffer*)&co3,
 #endif
     };
 
@@ -603,7 +608,8 @@ static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
 
     ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
     if (ret < 0)
-        return ff_qsv_error(ret);
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error calling GetVideoParam");
 
     q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
 
@@ -673,12 +679,52 @@ static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
     return 0;
 }
 
+static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
+{
+    int ret;
+
+    if (avctx->hwaccel_context) {
+        AVQSVContext *qsv = avctx->hwaccel_context;
+        q->session = qsv->session;
+    } else if (avctx->hw_frames_ctx) {
+        q->frames_ctx.hw_frames_ctx = av_buffer_ref(avctx->hw_frames_ctx);
+        if (!q->frames_ctx.hw_frames_ctx)
+            return AVERROR(ENOMEM);
+
+        ret = ff_qsv_init_session_frames(avctx, &q->internal_session,
+                                         &q->frames_ctx, q->load_plugins,
+                                         q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY);
+        if (ret < 0) {
+            av_buffer_unref(&q->frames_ctx.hw_frames_ctx);
+            return ret;
+        }
+
+        q->session = q->internal_session;
+    } else if (avctx->hw_device_ctx) {
+        ret = ff_qsv_init_session_device(avctx, &q->internal_session,
+                                         avctx->hw_device_ctx, q->load_plugins);
+        if (ret < 0)
+            return ret;
+
+        q->session = q->internal_session;
+    } else {
+        ret = ff_qsv_init_internal_session(avctx, &q->internal_session,
+                                           q->load_plugins);
+        if (ret < 0)
+            return ret;
+
+        q->session = q->internal_session;
+    }
+
+    return 0;
+}
+
 int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
 {
+    int iopattern = 0;
     int opaque_alloc = 0;
     int ret;
 
-    q->param.IOPattern  = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
     q->param.AsyncDepth = q->async_depth;
 
     q->async_fifo = av_fifo_alloc((1 + q->async_depth) *
@@ -689,38 +735,47 @@ int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
     if (avctx->hwaccel_context) {
         AVQSVContext *qsv = avctx->hwaccel_context;
 
-        q->session         = qsv->session;
-        q->param.IOPattern = qsv->iopattern;
-
+        iopattern    = qsv->iopattern;
         opaque_alloc = qsv->opaque_alloc;
     }
 
-    if (!q->session) {
-        ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
-                                           q->load_plugins);
-        if (ret < 0)
-            return ret;
+    if (avctx->hw_frames_ctx) {
+        AVHWFramesContext    *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+        AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
 
-        q->session = q->internal_qs.session;
+        if (!iopattern) {
+            if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
+                iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
+            else if (frames_hwctx->frame_type &
+                     (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
+                iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
+        }
     }
 
+    if (!iopattern)
+        iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
+    q->param.IOPattern = iopattern;
+
+    ret = qsvenc_init_session(avctx, q);
+    if (ret < 0)
+        return ret;
+
     ret = init_video_param(avctx, q);
     if (ret < 0)
         return ret;
 
-    ret = MFXVideoENCODE_Query(q->session, &q->param,&q->param);
-    if (MFX_WRN_PARTIAL_ACCELERATION==ret) {
+    ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
+    if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
         av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
     } else if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Error %d querying encoder params\n", ret);
-        return ff_qsv_error(ret);
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error querying encoder params");
     }
 
     ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
-    if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Error querying the encoding parameters\n");
-        return ff_qsv_error(ret);
-    }
+    if (ret < 0)
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error querying (IOSurf) the encoding parameters");
 
     if (opaque_alloc) {
         ret = qsv_init_opaque_alloc(avctx, q);
@@ -758,12 +813,12 @@ int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
     }
 
     ret = MFXVideoENCODE_Init(q->session, &q->param);
-    if (MFX_WRN_PARTIAL_ACCELERATION==ret) {
-        av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
-    } else if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Error initializing the encoder\n");
-        return ff_qsv_error(ret);
-    }
+    if (ret < 0)
+        return ff_qsv_print_error(avctx, ret,
+                                  "Error initializing the encoder");
+    else if (ret > 0)
+        ff_qsv_print_warning(avctx, ret,
+                             "Warning in encoder initialization");
 
     ret = qsv_retrieve_enc_params(avctx, q);
     if (ret < 0) {
@@ -791,10 +846,10 @@ static void clear_unused_frames(QSVEncContext *q)
 {
     QSVFrame *cur = q->work_frames;
     while (cur) {
-        if (cur->surface && !cur->surface->Data.Locked) {
-            cur->surface = NULL;
+        if (cur->used && !cur->surface.Data.Locked) {
             free_encoder_ctrl_payloads(&cur->enc_ctrl);
             av_frame_unref(cur->frame);
+            cur->used = 0;
         }
         cur = cur->next;
     }
@@ -809,8 +864,9 @@ static int get_free_frame(QSVEncContext *q, QSVFrame **f)
     frame = q->work_frames;
     last  = &q->work_frames;
     while (frame) {
-        if (!frame->surface) {
+        if (!frame->used) {
             *f = frame;
+            frame->used = 1;
             return 0;
         }
 
@@ -834,6 +890,7 @@ static int get_free_frame(QSVEncContext *q, QSVFrame **f)
     *last = frame;
 
     *f = frame;
+    frame->used = 1;
 
     return 0;
 }
@@ -853,11 +910,18 @@ static int submit_frame(QSVEncContext *q, const AVFrame *frame,
         if (ret < 0)
             return ret;
 
-        qf->surface = (mfxFrameSurface1*)qf->frame->data[3];
+        qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
+
+        if (q->frames_ctx.mids) {
+            ret = ff_qsv_find_surface_idx(&q->frames_ctx, qf);
+            if (ret < 0)
+                return ret;
+
+            qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
+        }
     } else {
         /* make a copy if the input is not padded as libmfx requires */
-        if (     frame->height & (q->height_align - 1) ||
-            frame->linesize[0] & (q->width_align - 1)) {
+        if (frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) {
             qf->frame->height = FFALIGN(frame->height, q->height_align);
             qf->frame->width  = FFALIGN(frame->width, q->width_align);
 
@@ -878,27 +942,25 @@ static int submit_frame(QSVEncContext *q, const AVFrame *frame,
                 return ret;
         }
 
-        qf->surface_internal.Info = q->param.mfx.FrameInfo;
+        qf->surface.Info = q->param.mfx.FrameInfo;
 
-        qf->surface_internal.Info.PicStruct =
+        qf->surface.Info.PicStruct =
             !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
             frame->top_field_first   ? MFX_PICSTRUCT_FIELD_TFF :
                                        MFX_PICSTRUCT_FIELD_BFF;
         if (frame->repeat_pict == 1)
-            qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
+            qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
         else if (frame->repeat_pict == 2)
-            qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
+            qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
         else if (frame->repeat_pict == 4)
-            qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
-
-        qf->surface_internal.Data.PitchLow  = qf->frame->linesize[0];
-        qf->surface_internal.Data.Y         = qf->frame->data[0];
-        qf->surface_internal.Data.UV        = qf->frame->data[1];
+            qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
 
-        qf->surface = &qf->surface_internal;
+        qf->surface.Data.PitchLow  = qf->frame->linesize[0];
+        qf->surface.Data.Y         = qf->frame->data[0];
+        qf->surface.Data.UV        = qf->frame->data[1];
     }
 
-    qf->surface->Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
+    qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
 
     *new_frame = qf;
 
@@ -924,7 +986,7 @@ static int encode_frame(AVCodecContext *avctx, QSVEncContext *q,
     mfxBitstream *bs;
 
     mfxFrameSurface1 *surf = NULL;
-    mfxSyncPoint *sync      = NULL;
+    mfxSyncPoint *sync     = NULL;
     QSVFrame *qsv_frame = NULL;
     mfxEncodeCtrl* enc_ctrl = NULL;
     int ret;
@@ -937,7 +999,7 @@ static int encode_frame(AVCodecContext *avctx, QSVEncContext *q,
         }
     }
     if (qsv_frame) {
-        surf = qsv_frame->surface;
+        surf = &qsv_frame->surface;
         enc_ctrl = &qsv_frame->enc_ctrl;
     }
 
@@ -968,30 +1030,25 @@ static int encode_frame(AVCodecContext *avctx, QSVEncContext *q,
 
     do {
         ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
-        if (ret == MFX_WRN_DEVICE_BUSY) {
+        if (ret == MFX_WRN_DEVICE_BUSY)
             av_usleep(500);
-            continue;
-        }
-        break;
-    } while ( 1 );
+    } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
+
+    if (ret > 0)
+        ff_qsv_print_warning(avctx, ret, "Warning during encoding");
 
     if (ret < 0) {
         av_packet_unref(&new_pkt);
         av_freep(&bs);
-        if (ret == MFX_ERR_MORE_DATA)
-            return 0;
-        av_log(avctx, AV_LOG_ERROR, "EncodeFrameAsync returned %d\n", ret);
-        return ff_qsv_error(ret);
+        av_freep(&sync);
+        return (ret == MFX_ERR_MORE_DATA) ?
+               0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
     }
 
-    if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM) {
-        if (frame->interlaced_frame)
-            print_interlace_msg(avctx, q);
-        else
-            av_log(avctx, AV_LOG_WARNING,
-                   "EncodeFrameAsync returned 'incompatible param' code\n");
-    }
-    if (sync) {
+    if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)
+        print_interlace_msg(avctx, q);
+
+    if (*sync) {
         av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
         av_fifo_generic_write(q->async_fifo, &sync,    sizeof(sync),    NULL);
         av_fifo_generic_write(q->async_fifo, &bs,      sizeof(bs),    NULL);
@@ -1079,9 +1136,13 @@ int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
 
     if (q->session)
         MFXVideoENCODE_Close(q->session);
-    q->session = NULL;
+    if (q->internal_session)
+        MFXClose(q->internal_session);
+    q->session          = NULL;
+    q->internal_session = NULL;
 
-    ff_qsv_close_internal_session(&q->internal_qs);
+    av_buffer_unref(&q->frames_ctx.hw_frames_ctx);
+    av_buffer_unref(&q->frames_ctx.mids_buf);
 
     cur = q->work_frames;
     while (cur) {
diff --git a/mythtv/external/FFmpeg/libavcodec/qsvenc.h b/mythtv/external/FFmpeg/libavcodec/qsvenc.h
index 2d7bd326f33..12e3444b758 100644
--- a/mythtv/external/FFmpeg/libavcodec/qsvenc.h
+++ b/mythtv/external/FFmpeg/libavcodec/qsvenc.h
@@ -42,6 +42,7 @@
 #define QSV_HAVE_BREF_TYPE      QSV_VERSION_ATLEAST(1, 8)
 
 #define QSV_HAVE_LA     QSV_VERSION_ATLEAST(1, 7)
+#define QSV_HAVE_LA_DS  QSV_VERSION_ATLEAST(1, 8)
 #define QSV_HAVE_LA_HRD QSV_VERSION_ATLEAST(1, 11)
 #define QSV_HAVE_ICQ    QSV_VERSION_ATLEAST(1, 8)
 #define QSV_HAVE_VCM    QSV_VERSION_ATLEAST(1, 8)
@@ -79,7 +80,7 @@ typedef struct QSVEncContext {
     QSVFrame *work_frames;
 
     mfxSession session;
-    QSVSession internal_qs;
+    mfxSession internal_session;
 
     int packet_size;
     int width_align;
@@ -104,6 +105,8 @@ typedef struct QSVEncContext {
 
     AVFifoBuffer *async_fifo;
 
+    QSVFramesContext frames_ctx;
+
     // options set by the caller
     int async_depth;
     int idr_interval;
diff --git a/mythtv/external/FFmpeg/libavcodec/qsvenc_h264.c b/mythtv/external/FFmpeg/libavcodec/qsvenc_h264.c
index f5b01bb9925..389335f39d2 100644
--- a/mythtv/external/FFmpeg/libavcodec/qsvenc_h264.c
+++ b/mythtv/external/FFmpeg/libavcodec/qsvenc_h264.c
@@ -111,8 +111,7 @@ static const AVOption options[] = {
     { "look_ahead",       "Use VBR algorithm with look ahead",    OFFSET(qsv.look_ahead),       AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
     { "look_ahead_depth", "Depth of look ahead in number frames", OFFSET(qsv.look_ahead_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, VE },
 #endif
-
-#if QSV_VERSION_ATLEAST(1,8)
+#if QSV_HAVE_LA_DS
     { "look_ahead_downsampling", NULL, OFFSET(qsv.look_ahead_downsampling), AV_OPT_TYPE_INT, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, MFX_LOOKAHEAD_DS_UNKNOWN, MFX_LOOKAHEAD_DS_2x, VE, "look_ahead_downsampling" },
     { "unknown"                , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, INT_MIN, INT_MAX,     VE, "look_ahead_downsampling" },
     { "off"                    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_OFF     }, INT_MIN, INT_MAX,     VE, "look_ahead_downsampling" },
@@ -175,6 +174,7 @@ AVCodec ff_h264_qsv_encoder = {
     .close          = qsv_enc_close,
     .capabilities   = AV_CODEC_CAP_DELAY,
     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+                                                    AV_PIX_FMT_P010,
                                                     AV_PIX_FMT_QSV,
                                                     AV_PIX_FMT_NONE },
     .priv_class     = &class,
diff --git a/mythtv/external/FFmpeg/libavcodec/qsvenc_hevc.c b/mythtv/external/FFmpeg/libavcodec/qsvenc_hevc.c
index b775ef1ee6e..b0e5ace7c7d 100644
--- a/mythtv/external/FFmpeg/libavcodec/qsvenc_hevc.c
+++ b/mythtv/external/FFmpeg/libavcodec/qsvenc_hevc.c
@@ -31,6 +31,7 @@
 #include "bytestream.h"
 #include "get_bits.h"
 #include "hevc.h"
+#include "hevcdec.h"
 #include "h2645_parse.h"
 #include "internal.h"
 #include "qsv.h"
@@ -83,7 +84,7 @@ static int generate_fake_vps(QSVEncContext *q, AVCodecContext *avctx)
 
     get_bits(&gb, 1);
     type = get_bits(&gb, 6);
-    if (type != NAL_SPS) {
+    if (type != HEVC_NAL_SPS) {
         av_log(avctx, AV_LOG_ERROR, "Unexpected NAL type in the extradata: %d\n",
                type);
         av_freep(&sps_nal.rbsp_buffer);
@@ -103,7 +104,7 @@ static int generate_fake_vps(QSVEncContext *q, AVCodecContext *avctx)
     vps.vps_max_sub_layers = sps.max_sub_layers;
     memcpy(&vps.ptl, &sps.ptl, sizeof(vps.ptl));
     vps.vps_sub_layer_ordering_info_present_flag = 1;
-    for (i = 0; i < MAX_SUB_LAYERS; i++) {
+    for (i = 0; i < HEVC_MAX_SUB_LAYERS; i++) {
         vps.vps_max_dec_pic_buffering[i] = sps.temporal_layer[i].max_dec_pic_buffering;
         vps.vps_num_reorder_pics[i]      = sps.temporal_layer[i].num_reorder_pics;
         vps.vps_max_latency_increase[i]  = sps.temporal_layer[i].max_latency_increase;
@@ -127,9 +128,9 @@ static int generate_fake_vps(QSVEncContext *q, AVCodecContext *avctx)
     bytestream2_init(&gbc, vps_rbsp_buf, ret);
     bytestream2_init_writer(&pbc, vps_buf, sizeof(vps_buf));
 
-    bytestream2_put_be32(&pbc, 1);              // startcode
-    bytestream2_put_byte(&pbc, NAL_VPS << 1);   // NAL
-    bytestream2_put_byte(&pbc, 1);              // header
+    bytestream2_put_be32(&pbc, 1);                 // startcode
+    bytestream2_put_byte(&pbc, HEVC_NAL_VPS << 1); // NAL
+    bytestream2_put_byte(&pbc, 1);                 // header
 
     while (bytestream2_get_bytes_left(&gbc)) {
         uint32_t b = bytestream2_peek_be24(&gbc);
@@ -160,8 +161,8 @@ static av_cold int qsv_enc_init(AVCodecContext *avctx)
     int ret;
 
     if (q->load_plugin != LOAD_PLUGIN_NONE) {
-        static const char *uid_hevcenc_sw = "2fca99749fdb49aeb121a5b63ef568f7";
-        static const char *uid_hevcenc_hw = "6fadc791a0c2eb479ab6dcd5ea9da347";
+        static const char * const uid_hevcenc_sw = "2fca99749fdb49aeb121a5b63ef568f7";
+        static const char * const uid_hevcenc_hw = "6fadc791a0c2eb479ab6dcd5ea9da347";
 
         if (q->qsv.load_plugins[0]) {
             av_log(avctx, AV_LOG_WARNING,
@@ -262,6 +263,7 @@ AVCodec ff_hevc_qsv_encoder = {
     .close          = qsv_enc_close,
     .capabilities   = AV_CODEC_CAP_DELAY,
     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
+                                                    AV_PIX_FMT_P010,
                                                     AV_PIX_FMT_QSV,
                                                     AV_PIX_FMT_NONE },
     .priv_class     = &class,
diff --git a/mythtv/external/FFmpeg/libavcodec/qtrle.c b/mythtv/external/FFmpeg/libavcodec/qtrle.c
index d9d27f05064..1b0d2016b58 100644
--- a/mythtv/external/FFmpeg/libavcodec/qtrle.c
+++ b/mythtv/external/FFmpeg/libavcodec/qtrle.c
@@ -506,11 +506,14 @@ static int qtrle_decode_frame(AVCodecContext *avctx,
     }
 
     if(has_palette) {
-        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
+        int size;
+        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
 
-        if (pal) {
+        if (pal && size == AVPALETTE_SIZE) {
             s->frame->palette_has_changed = 1;
             memcpy(s->pal, pal, AVPALETTE_SIZE);
+        } else if (pal) {
+            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
         }
 
         /* make the palette available on the way out */
diff --git a/mythtv/external/FFmpeg/libavcodec/r210dec.c b/mythtv/external/FFmpeg/libavcodec/r210dec.c
index 9c868cd11cd..dbc94c76bd3 100644
--- a/mythtv/external/FFmpeg/libavcodec/r210dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/r210dec.c
@@ -104,6 +104,7 @@ AVCodec ff_r210_decoder = {
     .init           = decode_init,
     .decode         = decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
 #endif
 #if CONFIG_R10K_DECODER
@@ -115,6 +116,7 @@ AVCodec ff_r10k_decoder = {
     .init           = decode_init,
     .decode         = decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
 #endif
 #if CONFIG_AVRP_DECODER
@@ -126,5 +128,6 @@ AVCodec ff_avrp_decoder = {
     .init           = decode_init,
     .decode         = decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/r210enc.c b/mythtv/external/FFmpeg/libavcodec/r210enc.c
index 65b3c069fcb..a55e5434f31 100644
--- a/mythtv/external/FFmpeg/libavcodec/r210enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/r210enc.c
@@ -24,6 +24,18 @@
 #include "internal.h"
 #include "bytestream.h"
 
+static av_cold int encode_init(AVCodecContext *avctx)
+{
+    int aligned_width = FFALIGN(avctx->width,
+                                avctx->codec_id == AV_CODEC_ID_R10K ? 1 : 64);
+
+    avctx->bits_per_coded_sample = 32;
+    if (avctx->width > 0)
+        avctx->bit_rate = ff_guess_coded_bitrate(avctx) * aligned_width / avctx->width;
+
+    return 0;
+}
+
 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                         const AVFrame *pic, int *got_packet)
 {
@@ -73,6 +85,7 @@ AVCodec ff_r210_encoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed RGB 10-bit"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_R210,
+    .init           = encode_init,
     .encode2        = encode_frame,
     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB48, AV_PIX_FMT_NONE },
     .capabilities   = AV_CODEC_CAP_INTRA_ONLY,
@@ -84,6 +97,7 @@ AVCodec ff_r10k_encoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("AJA Kona 10-bit RGB Codec"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_R10K,
+    .init           = encode_init,
     .encode2        = encode_frame,
     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB48, AV_PIX_FMT_NONE },
     .capabilities   = AV_CODEC_CAP_INTRA_ONLY,
@@ -95,6 +109,7 @@ AVCodec ff_avrp_encoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_AVRP,
+    .init           = encode_init,
     .encode2        = encode_frame,
     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB48, AV_PIX_FMT_NONE },
     .capabilities   = AV_CODEC_CAP_INTRA_ONLY,
diff --git a/mythtv/external/FFmpeg/libavcodec/ra144.c b/mythtv/external/FFmpeg/libavcodec/ra144.c
index ceec32d79d2..c077b7b3279 100644
--- a/mythtv/external/FFmpeg/libavcodec/ra144.c
+++ b/mythtv/external/FFmpeg/libavcodec/ra144.c
@@ -1512,7 +1512,7 @@ static void add_wav(int16_t *dest, int n, int skip_first, int *m,
 
     v[0] = 0;
     for (i=!skip_first; i<3; i++)
-        v[i] = (ff_gain_val_tab[n][i] * m[i]) >> ff_gain_exp_tab[n];
+        v[i] = (ff_gain_val_tab[n][i] * (unsigned)m[i]) >> ff_gain_exp_tab[n];
 
     if (v[0]) {
         for (i=0; i < BLOCKSIZE; i++)
@@ -1573,7 +1573,7 @@ int ff_eval_refl(int *refl, const int16_t *coefs, AVCodecContext *avctx)
             if((int)(a*(unsigned)b) != a*(int64_t)b)
                 return 1;
 #endif
-            bp1[j] = ((bp2[j] - ((refl[i+1] * bp2[i-j]) >> 12)) * b) >> 12;
+            bp1[j] = (int)((bp2[j] - ((refl[i+1] * bp2[i-j]) >> 12)) * (unsigned)b) >> 12;
         }
 
         if ((unsigned) bp1[i] + 0x1000 > 0x1fff)
@@ -1598,10 +1598,10 @@ void ff_eval_coefs(int *coefs, const int *refl)
     int i, j;
 
     for (i=0; i < LPC_ORDER; i++) {
-        b1[i] = refl[i] << 4;
+        b1[i] = refl[i] * 16;
 
         for (j=0; j < i; j++)
-            b1[j] = ((refl[i] * b2[i-j-1]) >> 12) + b2[j];
+            b1[j] = ((int)(refl[i] * (unsigned)b2[i-j-1]) >> 12) + b2[j];
 
         FFSWAP(int *, b1, b2);
     }
@@ -1701,7 +1701,7 @@ void ff_subblock_synthesis(RA144Context *ractx, const int16_t *lpc_coefs,
     if (cba_idx) {
         cba_idx += BLOCKSIZE/2 - 1;
         ff_copy_and_dup(ractx->buffer_a, ractx->adapt_cb, cba_idx);
-        m[0] = (ff_irms(&ractx->adsp, ractx->buffer_a) * gval) >> 12;
+        m[0] = (ff_irms(&ractx->adsp, ractx->buffer_a) * (unsigned)gval) >> 12;
     } else {
         m[0] = 0;
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/ra144dec.c b/mythtv/external/FFmpeg/libavcodec/ra144dec.c
index 3eed17c0dae..c716c32e67f 100644
--- a/mythtv/external/FFmpeg/libavcodec/ra144dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/ra144dec.c
@@ -113,7 +113,7 @@ static int ra144_decode_frame(AVCodecContext * avctx, void *data,
         do_output_subblock(ractx, block_coefs[i], refl_rms[i], &gb);
 
         for (j=0; j < BLOCKSIZE; j++)
-            *samples++ = av_clip_int16(ractx->curr_sblock[j + 10] << 2);
+            *samples++ = av_clip_int16(ractx->curr_sblock[j + 10] * (1 << 2));
     }
 
     ractx->old_energy = energy;
diff --git a/mythtv/external/FFmpeg/libavcodec/rangecoder.c b/mythtv/external/FFmpeg/libavcodec/rangecoder.c
index 9c6ef75b69e..0d53bef0760 100644
--- a/mythtv/external/FFmpeg/libavcodec/rangecoder.c
+++ b/mythtv/external/FFmpeg/libavcodec/rangecoder.c
@@ -58,6 +58,11 @@ av_cold void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf,
 
     c->low         = AV_RB16(c->bytestream);
     c->bytestream += 2;
+    c->overread    = 0;
+    if (c->low >= 0xFF00) {
+        c->low = 0xFF00;
+        c->bytestream_end = c->bytestream;
+    }
 }
 
 void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
diff --git a/mythtv/external/FFmpeg/libavcodec/rangecoder.h b/mythtv/external/FFmpeg/libavcodec/rangecoder.h
index d36fbd7c545..44af88b8f57 100644
--- a/mythtv/external/FFmpeg/libavcodec/rangecoder.h
+++ b/mythtv/external/FFmpeg/libavcodec/rangecoder.h
@@ -42,6 +42,8 @@ typedef struct RangeCoder {
     uint8_t *bytestream_start;
     uint8_t *bytestream;
     uint8_t *bytestream_end;
+    int overread;
+#define MAX_OVERREAD 2
 } RangeCoder;
 
 void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size);
@@ -106,9 +108,11 @@ static inline void refill(RangeCoder *c)
     if (c->range < 0x100) {
         c->range <<= 8;
         c->low   <<= 8;
-        if (c->bytestream < c->bytestream_end)
+        if (c->bytestream < c->bytestream_end) {
             c->low += c->bytestream[0];
-        c->bytestream++;
+            c->bytestream++;
+        } else
+            c->overread ++;
     }
 }
 
@@ -117,7 +121,6 @@ static inline int get_rac(RangeCoder *c, uint8_t *const state)
     int range1 = (c->range * (*state)) >> 8;
 
     c->range -= range1;
-#if 1
     if (c->low < c->range) {
         *state = c->zero_state[*state];
         refill(c);
@@ -129,19 +132,6 @@ static inline int get_rac(RangeCoder *c, uint8_t *const state)
         refill(c);
         return 1;
     }
-#else
-    {
-        int one_mask one_mask = (c->range - c->low - 1) >> 31;
-
-        c->low   -=           c->range  & one_mask;
-        c->range += (range1 - c->range) & one_mask;
-
-        *state = c->zero_state[(*state) + (256 & one_mask)];
-    }
-    refill(c);
-
-    return one_mask & 1;
-#endif
 }
 
 #endif /* AVCODEC_RANGECODER_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/ratecontrol.c b/mythtv/external/FFmpeg/libavcodec/ratecontrol.c
index 3a8ac22ddda..49d169ba25c 100644
--- a/mythtv/external/FFmpeg/libavcodec/ratecontrol.c
+++ b/mythtv/external/FFmpeg/libavcodec/ratecontrol.c
@@ -35,10 +35,6 @@
 #include "mpegvideo.h"
 #include "libavutil/eval.h"
 
-static int init_pass2(MpegEncContext *s);
-static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
-                         double rate_factor, int frame_num);
-
 void ff_write_pass1_stats(MpegEncContext *s)
 {
     snprintf(s->avctx->stats_out, 256,
@@ -70,15 +66,407 @@ static inline double qp2bits(RateControlEntry *rce, double qp)
     if (qp <= 0.0) {
         av_log(NULL, AV_LOG_ERROR, "qp<=0.0\n");
     }
-    return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / qp;
-}
+    return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / qp;
+}
+
+static inline double bits2qp(RateControlEntry *rce, double bits)
+{
+    if (bits < 0.9) {
+        av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
+    }
+    return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
+}
+
+static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q)
+{
+    RateControlContext *rcc   = &s->rc_context;
+    AVCodecContext *a         = s->avctx;
+    const int pict_type       = rce->new_pict_type;
+    const double last_p_q     = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
+    const double last_non_b_q = rcc->last_qscale_for[rcc->last_non_b_pict_type];
+
+    if (pict_type == AV_PICTURE_TYPE_I &&
+        (a->i_quant_factor > 0.0 || rcc->last_non_b_pict_type == AV_PICTURE_TYPE_P))
+        q = last_p_q * FFABS(a->i_quant_factor) + a->i_quant_offset;
+    else if (pict_type == AV_PICTURE_TYPE_B &&
+             a->b_quant_factor > 0.0)
+        q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;
+    if (q < 1)
+        q = 1;
+
+    /* last qscale / qdiff stuff */
+    if (rcc->last_non_b_pict_type == pict_type || pict_type != AV_PICTURE_TYPE_I) {
+        double last_q     = rcc->last_qscale_for[pict_type];
+        const int maxdiff = FF_QP2LAMBDA * a->max_qdiff;
+
+        if (q > last_q + maxdiff)
+            q = last_q + maxdiff;
+        else if (q < last_q - maxdiff)
+            q = last_q - maxdiff;
+    }
+
+    rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
+
+    if (pict_type != AV_PICTURE_TYPE_B)
+        rcc->last_non_b_pict_type = pict_type;
+
+    return q;
+}
+
+/**
+ * Get the qmin & qmax for pict_type.
+ */
+static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
+{
+    int qmin = s->lmin;
+    int qmax = s->lmax;
+
+    av_assert0(qmin <= qmax);
+
+    switch (pict_type) {
+    case AV_PICTURE_TYPE_B:
+        qmin = (int)(qmin * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
+        qmax = (int)(qmax * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
+        break;
+    case AV_PICTURE_TYPE_I:
+        qmin = (int)(qmin * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
+        qmax = (int)(qmax * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
+        break;
+    }
+
+    qmin = av_clip(qmin, 1, FF_LAMBDA_MAX);
+    qmax = av_clip(qmax, 1, FF_LAMBDA_MAX);
+
+    if (qmax < qmin)
+        qmax = qmin;
+
+    *qmin_ret = qmin;
+    *qmax_ret = qmax;
+}
+
+static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,
+                            double q, int frame_num)
+{
+    RateControlContext *rcc  = &s->rc_context;
+    const double buffer_size = s->avctx->rc_buffer_size;
+    const double fps         = get_fps(s->avctx);
+    const double min_rate    = s->avctx->rc_min_rate / fps;
+    const double max_rate    = s->avctx->rc_max_rate / fps;
+    const int pict_type      = rce->new_pict_type;
+    int qmin, qmax;
+
+    get_qminmax(&qmin, &qmax, s, pict_type);
+
+    /* modulation */
+    if (s->rc_qmod_freq &&
+        frame_num % s->rc_qmod_freq == 0 &&
+        pict_type == AV_PICTURE_TYPE_P)
+        q *= s->rc_qmod_amp;
+
+    /* buffer overflow/underflow protection */
+    if (buffer_size) {
+        double expected_size = rcc->buffer_index;
+        double q_limit;
+
+        if (min_rate) {
+            double d = 2 * (buffer_size - expected_size) / buffer_size;
+            if (d > 1.0)
+                d = 1.0;
+            else if (d < 0.0001)
+                d = 0.0001;
+            q *= pow(d, 1.0 / s->rc_buffer_aggressivity);
+
+            q_limit = bits2qp(rce,
+                              FFMAX((min_rate - buffer_size + rcc->buffer_index) *
+                                    s->avctx->rc_min_vbv_overflow_use, 1));
+
+            if (q > q_limit) {
+                if (s->avctx->debug & FF_DEBUG_RC)
+                    av_log(s->avctx, AV_LOG_DEBUG,
+                           "limiting QP %f -> %f\n", q, q_limit);
+                q = q_limit;
+            }
+        }
+
+        if (max_rate) {
+            double d = 2 * expected_size / buffer_size;
+            if (d > 1.0)
+                d = 1.0;
+            else if (d < 0.0001)
+                d = 0.0001;
+            q /= pow(d, 1.0 / s->rc_buffer_aggressivity);
+
+            q_limit = bits2qp(rce,
+                              FFMAX(rcc->buffer_index *
+                                    s->avctx->rc_max_available_vbv_use,
+                                    1));
+            if (q < q_limit) {
+                if (s->avctx->debug & FF_DEBUG_RC)
+                    av_log(s->avctx, AV_LOG_DEBUG,
+                           "limiting QP %f -> %f\n", q, q_limit);
+                q = q_limit;
+            }
+        }
+    }
+    ff_dlog(s, "q:%f max:%f min:%f size:%f index:%f agr:%f\n",
+            q, max_rate, min_rate, buffer_size, rcc->buffer_index,
+            s->rc_buffer_aggressivity);
+    if (s->rc_qsquish == 0.0 || qmin == qmax) {
+        if (q < qmin)
+            q = qmin;
+        else if (q > qmax)
+            q = qmax;
+    } else {
+        double min2 = log(qmin);
+        double max2 = log(qmax);
+
+        q  = log(q);
+        q  = (q - min2) / (max2 - min2) - 0.5;
+        q *= -4.0;
+        q  = 1.0 / (1.0 + exp(q));
+        q  = q * (max2 - min2) + min2;
+
+        q = exp(q);
+    }
+
+    return q;
+}
+
+/**
+ * Modify the bitrate curve from pass1 for one frame.
+ */
+static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
+                         double rate_factor, int frame_num)
+{
+    RateControlContext *rcc = &s->rc_context;
+    AVCodecContext *a       = s->avctx;
+    const int pict_type     = rce->new_pict_type;
+    const double mb_num     = s->mb_num;
+    double q, bits;
+    int i;
+
+    double const_values[] = {
+        M_PI,
+        M_E,
+        rce->i_tex_bits * rce->qscale,
+        rce->p_tex_bits * rce->qscale,
+        (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,
+        rce->mv_bits / mb_num,
+        rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,
+        rce->i_count / mb_num,
+        rce->mc_mb_var_sum / mb_num,
+        rce->mb_var_sum / mb_num,
+        rce->pict_type == AV_PICTURE_TYPE_I,
+        rce->pict_type == AV_PICTURE_TYPE_P,
+        rce->pict_type == AV_PICTURE_TYPE_B,
+        rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
+        a->qcompress,
+        rcc->i_cplx_sum[AV_PICTURE_TYPE_I] / (double)rcc->frame_count[AV_PICTURE_TYPE_I],
+        rcc->i_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
+        rcc->p_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
+        rcc->p_cplx_sum[AV_PICTURE_TYPE_B] / (double)rcc->frame_count[AV_PICTURE_TYPE_B],
+        (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
+        0
+    };
+
+    bits = av_expr_eval(rcc->rc_eq_eval, const_values, rce);
+    if (isnan(bits)) {
+        av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->rc_eq);
+        return -1;
+    }
+
+    rcc->pass1_rc_eq_output_sum += bits;
+    bits *= rate_factor;
+    if (bits < 0.0)
+        bits = 0.0;
+    bits += 1.0; // avoid 1/0 issues
+
+    /* user override */
+    for (i = 0; i < s->avctx->rc_override_count; i++) {
+        RcOverride *rco = s->avctx->rc_override;
+        if (rco[i].start_frame > frame_num)
+            continue;
+        if (rco[i].end_frame < frame_num)
+            continue;
+
+        if (rco[i].qscale)
+            bits = qp2bits(rce, rco[i].qscale);  // FIXME move at end to really force it?
+        else
+            bits *= rco[i].quality_factor;
+    }
+
+    q = bits2qp(rce, bits);
+
+    /* I/B difference */
+    if (pict_type == AV_PICTURE_TYPE_I && s->avctx->i_quant_factor < 0.0)
+        q = -q * s->avctx->i_quant_factor + s->avctx->i_quant_offset;
+    else if (pict_type == AV_PICTURE_TYPE_B && s->avctx->b_quant_factor < 0.0)
+        q = -q * s->avctx->b_quant_factor + s->avctx->b_quant_offset;
+    if (q < 1)
+        q = 1;
+
+    return q;
+}
+
+static int init_pass2(MpegEncContext *s)
+{
+    RateControlContext *rcc = &s->rc_context;
+    AVCodecContext *a       = s->avctx;
+    int i, toobig;
+    double fps             = get_fps(s->avctx);
+    double complexity[5]   = { 0 }; // approximate bits at quant=1
+    uint64_t const_bits[5] = { 0 }; // quantizer independent bits
+    uint64_t all_const_bits;
+    uint64_t all_available_bits = (uint64_t)(s->bit_rate *
+                                             (double)rcc->num_entries / fps);
+    double rate_factor          = 0;
+    double step;
+    const int filter_size = (int)(a->qblur * 4) | 1;
+    double expected_bits = 0; // init to silence gcc warning
+    double *qscale, *blurred_qscale, qscale_sum;
+
+    /* find complexity & const_bits & decide the pict_types */
+    for (i = 0; i < rcc->num_entries; i++) {
+        RateControlEntry *rce = &rcc->entry[i];
+
+        rce->new_pict_type                = rce->pict_type;
+        rcc->i_cplx_sum[rce->pict_type]  += rce->i_tex_bits * rce->qscale;
+        rcc->p_cplx_sum[rce->pict_type]  += rce->p_tex_bits * rce->qscale;
+        rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
+        rcc->frame_count[rce->pict_type]++;
+
+        complexity[rce->new_pict_type] += (rce->i_tex_bits + rce->p_tex_bits) *
+                                          (double)rce->qscale;
+        const_bits[rce->new_pict_type] += rce->mv_bits + rce->misc_bits;
+    }
+
+    all_const_bits = const_bits[AV_PICTURE_TYPE_I] +
+                     const_bits[AV_PICTURE_TYPE_P] +
+                     const_bits[AV_PICTURE_TYPE_B];
+
+    if (all_available_bits < all_const_bits) {
+        av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
+        return -1;
+    }
+
+    qscale         = av_malloc_array(rcc->num_entries, sizeof(double));
+    blurred_qscale = av_malloc_array(rcc->num_entries, sizeof(double));
+    if (!qscale || !blurred_qscale) {
+        av_free(qscale);
+        av_free(blurred_qscale);
+        return AVERROR(ENOMEM);
+    }
+    toobig = 0;
+
+    for (step = 256 * 256; step > 0.0000001; step *= 0.5) {
+        expected_bits = 0;
+        rate_factor  += step;
+
+        rcc->buffer_index = s->avctx->rc_buffer_size / 2;
+
+        /* find qscale */
+        for (i = 0; i < rcc->num_entries; i++) {
+            RateControlEntry *rce = &rcc->entry[i];
+
+            qscale[i] = get_qscale(s, &rcc->entry[i], rate_factor, i);
+            rcc->last_qscale_for[rce->pict_type] = qscale[i];
+        }
+        av_assert0(filter_size % 2 == 1);
+
+        /* fixed I/B QP relative to P mode */
+        for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
+            RateControlEntry *rce = &rcc->entry[i];
+
+            qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
+        }
+
+        for (i = rcc->num_entries - 1; i >= 0; i--) {
+            RateControlEntry *rce = &rcc->entry[i];
+
+            qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
+        }
+
+        /* smooth curve */
+        for (i = 0; i < rcc->num_entries; i++) {
+            RateControlEntry *rce = &rcc->entry[i];
+            const int pict_type   = rce->new_pict_type;
+            int j;
+            double q = 0.0, sum = 0.0;
+
+            for (j = 0; j < filter_size; j++) {
+                int index    = i + j - filter_size / 2;
+                double d     = index - i;
+                double coeff = a->qblur == 0 ? 1.0 : exp(-d * d / (a->qblur * a->qblur));
+
+                if (index < 0 || index >= rcc->num_entries)
+                    continue;
+                if (pict_type != rcc->entry[index].new_pict_type)
+                    continue;
+                q   += qscale[index] * coeff;
+                sum += coeff;
+            }
+            blurred_qscale[i] = q / sum;
+        }
+
+        /* find expected bits */
+        for (i = 0; i < rcc->num_entries; i++) {
+            RateControlEntry *rce = &rcc->entry[i];
+            double bits;
+
+            rce->new_qscale = modify_qscale(s, rce, blurred_qscale[i], i);
+
+            bits  = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
+            bits += 8 * ff_vbv_update(s, bits);
+
+            rce->expected_bits = expected_bits;
+            expected_bits     += bits;
+        }
+
+        ff_dlog(s->avctx,
+                "expected_bits: %f all_available_bits: %d rate_factor: %f\n",
+                expected_bits, (int)all_available_bits, rate_factor);
+        if (expected_bits > all_available_bits) {
+            rate_factor -= step;
+            ++toobig;
+        }
+    }
+    av_free(qscale);
+    av_free(blurred_qscale);
 
-static inline double bits2qp(RateControlEntry *rce, double bits)
-{
-    if (bits < 0.9) {
-        av_log(NULL, AV_LOG_ERROR, "bits<0.9\n");
+    /* check bitrate calculations and print info */
+    qscale_sum = 0.0;
+    for (i = 0; i < rcc->num_entries; i++) {
+        ff_dlog(s, "[lavc rc] entry[%d].new_qscale = %.3f  qp = %.3f\n",
+                i,
+                rcc->entry[i].new_qscale,
+                rcc->entry[i].new_qscale / FF_QP2LAMBDA);
+        qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA,
+                              s->avctx->qmin, s->avctx->qmax);
     }
-    return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
+    av_assert0(toobig <= 40);
+    av_log(s->avctx, AV_LOG_DEBUG,
+           "[lavc rc] requested bitrate: %"PRId64" bps  expected bitrate: %"PRId64" bps\n",
+           s->bit_rate,
+           (int64_t)(expected_bits / ((double)all_available_bits / s->bit_rate)));
+    av_log(s->avctx, AV_LOG_DEBUG,
+           "[lavc rc] estimated target average qp: %.3f\n",
+           (float)qscale_sum / rcc->num_entries);
+    if (toobig == 0) {
+        av_log(s->avctx, AV_LOG_INFO,
+               "[lavc rc] Using all of requested bitrate is not "
+               "necessary for this video with these parameters.\n");
+    } else if (toobig == 40) {
+        av_log(s->avctx, AV_LOG_ERROR,
+               "[lavc rc] Error: bitrate too low for this video "
+               "with these parameters.\n");
+        return -1;
+    } else if (fabs(expected_bits / all_available_bits - 1.0) > 0.01) {
+        av_log(s->avctx, AV_LOG_ERROR,
+               "[lavc rc] Error: 2pass curve failed to converge\n");
+        return -1;
+    }
+
+    return 0;
 }
 
 av_cold int ff_rate_control_init(MpegEncContext *s)
@@ -101,12 +489,6 @@ av_cold int ff_rate_control_init(MpegEncContext *s)
         "isB",
         "avgQP",
         "qComp",
-#if 0
-        "lastIQP",
-        "lastPQP",
-        "lastBQP",
-        "nextNonBQP",
-#endif
         "avgIITex",
         "avgPITex",
         "avgPPTex",
@@ -115,8 +497,8 @@ av_cold int ff_rate_control_init(MpegEncContext *s)
         NULL
     };
     static double (* const func1[])(void *, double) = {
-        (void *)bits2qp,
-        (void *)qp2bits,
+        (double (*)(void *, double)) bits2qp,
+        (double (*)(void *, double)) qp2bits,
         NULL
     };
     static const char * const func1_names[] = {
@@ -142,13 +524,6 @@ av_cold int ff_rate_control_init(MpegEncContext *s)
         return res;
     }
 
-#if FF_API_RC_STRATEGY
-FF_DISABLE_DEPRECATION_WARNINGS
-    if (!s->rc_strategy)
-        s->rc_strategy = s->avctx->rc_strategy;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-
     for (i = 0; i < 5; i++) {
         rcc->pred[i].coeff = FF_QP2LAMBDA * 7.0;
         rcc->pred[i].count = 1.0;
@@ -232,21 +607,6 @@ FF_ENABLE_DEPRECATION_WARNINGS
             ff_rate_control_uninit(s);
             return -1;
         }
-
-#if FF_API_RC_STRATEGY
-        av_assert0(MPV_RC_STRATEGY_XVID == FF_RC_STRATEGY_XVID);
-#endif
-
-        // FIXME maybe move to end
-        if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID) {
-#if CONFIG_LIBXVID
-            return ff_xvid_rate_control_init(s);
-#else
-            av_log(s->avctx, AV_LOG_ERROR,
-                   "Xvid ratecontrol requires libavcodec compiled with Xvid support.\n");
-            return -1;
-#endif
-        }
     }
 
     if (!(s->avctx->flags & AV_CODEC_FLAG_PASS2)) {
@@ -312,299 +672,54 @@ FF_ENABLE_DEPRECATION_WARNINGS
 av_cold void ff_rate_control_uninit(MpegEncContext *s)
 {
     RateControlContext *rcc = &s->rc_context;
-    emms_c();
-
-    av_expr_free(rcc->rc_eq_eval);
-    av_freep(&rcc->entry);
-
-#if CONFIG_LIBXVID
-    if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID)
-        ff_xvid_rate_control_uninit(s);
-#endif
-}
-
-int ff_vbv_update(MpegEncContext *s, int frame_size)
-{
-    RateControlContext *rcc = &s->rc_context;
-    const double fps        = get_fps(s->avctx);
-    const int buffer_size   = s->avctx->rc_buffer_size;
-    const double min_rate   = s->avctx->rc_min_rate / fps;
-    const double max_rate   = s->avctx->rc_max_rate / fps;
-
-    ff_dlog(s, "%d %f %d %f %f\n",
-            buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
-
-    if (buffer_size) {
-        int left;
-
-        rcc->buffer_index -= frame_size;
-        if (rcc->buffer_index < 0) {
-            av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
-            if (frame_size > max_rate && s->qscale == s->avctx->qmax) {
-                av_log(s->avctx, AV_LOG_ERROR, "max bitrate possibly too small or try trellis with large lmax or increase qmax\n");
-            }
-            rcc->buffer_index = 0;
-        }
-
-        left = buffer_size - rcc->buffer_index - 1;
-        rcc->buffer_index += av_clip(left, min_rate, max_rate);
-
-        if (rcc->buffer_index > buffer_size) {
-            int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);
-
-            if (stuffing < 4 && s->codec_id == AV_CODEC_ID_MPEG4)
-                stuffing = 4;
-            rcc->buffer_index -= 8 * stuffing;
-
-            if (s->avctx->debug & FF_DEBUG_RC)
-                av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
-
-            return stuffing;
-        }
-    }
-    return 0;
-}
-
-/**
- * Modify the bitrate curve from pass1 for one frame.
- */
-static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
-                         double rate_factor, int frame_num)
-{
-    RateControlContext *rcc = &s->rc_context;
-    AVCodecContext *a       = s->avctx;
-    const int pict_type     = rce->new_pict_type;
-    const double mb_num     = s->mb_num;
-    double q, bits;
-    int i;
-
-    double const_values[] = {
-        M_PI,
-        M_E,
-        rce->i_tex_bits * rce->qscale,
-        rce->p_tex_bits * rce->qscale,
-        (rce->i_tex_bits + rce->p_tex_bits) * (double)rce->qscale,
-        rce->mv_bits / mb_num,
-        rce->pict_type == AV_PICTURE_TYPE_B ? (rce->f_code + rce->b_code) * 0.5 : rce->f_code,
-        rce->i_count / mb_num,
-        rce->mc_mb_var_sum / mb_num,
-        rce->mb_var_sum / mb_num,
-        rce->pict_type == AV_PICTURE_TYPE_I,
-        rce->pict_type == AV_PICTURE_TYPE_P,
-        rce->pict_type == AV_PICTURE_TYPE_B,
-        rcc->qscale_sum[pict_type] / (double)rcc->frame_count[pict_type],
-        a->qcompress,
-#if 0
-        rcc->last_qscale_for[AV_PICTURE_TYPE_I],
-        rcc->last_qscale_for[AV_PICTURE_TYPE_P],
-        rcc->last_qscale_for[AV_PICTURE_TYPE_B],
-        rcc->next_non_b_qscale,
-#endif
-        rcc->i_cplx_sum[AV_PICTURE_TYPE_I] / (double)rcc->frame_count[AV_PICTURE_TYPE_I],
-        rcc->i_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
-        rcc->p_cplx_sum[AV_PICTURE_TYPE_P] / (double)rcc->frame_count[AV_PICTURE_TYPE_P],
-        rcc->p_cplx_sum[AV_PICTURE_TYPE_B] / (double)rcc->frame_count[AV_PICTURE_TYPE_B],
-        (rcc->i_cplx_sum[pict_type] + rcc->p_cplx_sum[pict_type]) / (double)rcc->frame_count[pict_type],
-        0
-    };
-
-    bits = av_expr_eval(rcc->rc_eq_eval, const_values, rce);
-    if (isnan(bits)) {
-        av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->rc_eq);
-        return -1;
-    }
-
-    rcc->pass1_rc_eq_output_sum += bits;
-    bits *= rate_factor;
-    if (bits < 0.0)
-        bits = 0.0;
-    bits += 1.0; // avoid 1/0 issues
-
-    /* user override */
-    for (i = 0; i < s->avctx->rc_override_count; i++) {
-        RcOverride *rco = s->avctx->rc_override;
-        if (rco[i].start_frame > frame_num)
-            continue;
-        if (rco[i].end_frame < frame_num)
-            continue;
-
-        if (rco[i].qscale)
-            bits = qp2bits(rce, rco[i].qscale);  // FIXME move at end to really force it?
-        else
-            bits *= rco[i].quality_factor;
-    }
-
-    q = bits2qp(rce, bits);
-
-    /* I/B difference */
-    if (pict_type == AV_PICTURE_TYPE_I && s->avctx->i_quant_factor < 0.0)
-        q = -q * s->avctx->i_quant_factor + s->avctx->i_quant_offset;
-    else if (pict_type == AV_PICTURE_TYPE_B && s->avctx->b_quant_factor < 0.0)
-        q = -q * s->avctx->b_quant_factor + s->avctx->b_quant_offset;
-    if (q < 1)
-        q = 1;
-
-    return q;
-}
-
-static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, double q)
-{
-    RateControlContext *rcc   = &s->rc_context;
-    AVCodecContext *a         = s->avctx;
-    const int pict_type       = rce->new_pict_type;
-    const double last_p_q     = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
-    const double last_non_b_q = rcc->last_qscale_for[rcc->last_non_b_pict_type];
-
-    if (pict_type == AV_PICTURE_TYPE_I &&
-        (a->i_quant_factor > 0.0 || rcc->last_non_b_pict_type == AV_PICTURE_TYPE_P))
-        q = last_p_q * FFABS(a->i_quant_factor) + a->i_quant_offset;
-    else if (pict_type == AV_PICTURE_TYPE_B &&
-             a->b_quant_factor > 0.0)
-        q = last_non_b_q * a->b_quant_factor + a->b_quant_offset;
-    if (q < 1)
-        q = 1;
-
-    /* last qscale / qdiff stuff */
-    if (rcc->last_non_b_pict_type == pict_type || pict_type != AV_PICTURE_TYPE_I) {
-        double last_q     = rcc->last_qscale_for[pict_type];
-        const int maxdiff = FF_QP2LAMBDA * a->max_qdiff;
-
-        if (q > last_q + maxdiff)
-            q = last_q + maxdiff;
-        else if (q < last_q - maxdiff)
-            q = last_q - maxdiff;
-    }
-
-    rcc->last_qscale_for[pict_type] = q; // Note we cannot do that after blurring
-
-    if (pict_type != AV_PICTURE_TYPE_B)
-        rcc->last_non_b_pict_type = pict_type;
-
-    return q;
-}
-
-/**
- * Get the qmin & qmax for pict_type.
- */
-static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
-{
-    int qmin = s->lmin;
-    int qmax = s->lmax;
-
-    av_assert0(qmin <= qmax);
-
-    switch (pict_type) {
-    case AV_PICTURE_TYPE_B:
-        qmin = (int)(qmin * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
-        qmax = (int)(qmax * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset + 0.5);
-        break;
-    case AV_PICTURE_TYPE_I:
-        qmin = (int)(qmin * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
-        qmax = (int)(qmax * FFABS(s->avctx->i_quant_factor) + s->avctx->i_quant_offset + 0.5);
-        break;
-    }
-
-    qmin = av_clip(qmin, 1, FF_LAMBDA_MAX);
-    qmax = av_clip(qmax, 1, FF_LAMBDA_MAX);
-
-    if (qmax < qmin)
-        qmax = qmin;
-
-    *qmin_ret = qmin;
-    *qmax_ret = qmax;
-}
-
-static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,
-                            double q, int frame_num)
-{
-    RateControlContext *rcc  = &s->rc_context;
-    const double buffer_size = s->avctx->rc_buffer_size;
-    const double fps         = get_fps(s->avctx);
-    const double min_rate    = s->avctx->rc_min_rate / fps;
-    const double max_rate    = s->avctx->rc_max_rate / fps;
-    const int pict_type      = rce->new_pict_type;
-    int qmin, qmax;
-
-    get_qminmax(&qmin, &qmax, s, pict_type);
-
-    /* modulation */
-    if (s->rc_qmod_freq &&
-        frame_num % s->rc_qmod_freq == 0 &&
-        pict_type == AV_PICTURE_TYPE_P)
-        q *= s->rc_qmod_amp;
+    emms_c();
 
-    /* buffer overflow/underflow protection */
-    if (buffer_size) {
-        double expected_size = rcc->buffer_index;
-        double q_limit;
+    av_expr_free(rcc->rc_eq_eval);
+    av_freep(&rcc->entry);
+}
 
-        if (min_rate) {
-            double d = 2 * (buffer_size - expected_size) / buffer_size;
-            if (d > 1.0)
-                d = 1.0;
-            else if (d < 0.0001)
-                d = 0.0001;
-            q *= pow(d, 1.0 / s->rc_buffer_aggressivity);
+int ff_vbv_update(MpegEncContext *s, int frame_size)
+{
+    RateControlContext *rcc = &s->rc_context;
+    const double fps        = get_fps(s->avctx);
+    const int buffer_size   = s->avctx->rc_buffer_size;
+    const double min_rate   = s->avctx->rc_min_rate / fps;
+    const double max_rate   = s->avctx->rc_max_rate / fps;
 
-            q_limit = bits2qp(rce,
-                              FFMAX((min_rate - buffer_size + rcc->buffer_index) *
-                                    s->avctx->rc_min_vbv_overflow_use, 1));
+    ff_dlog(s, "%d %f %d %f %f\n",
+            buffer_size, rcc->buffer_index, frame_size, min_rate, max_rate);
 
-            if (q > q_limit) {
-                if (s->avctx->debug & FF_DEBUG_RC)
-                    av_log(s->avctx, AV_LOG_DEBUG,
-                           "limiting QP %f -> %f\n", q, q_limit);
-                q = q_limit;
+    if (buffer_size) {
+        int left;
+
+        rcc->buffer_index -= frame_size;
+        if (rcc->buffer_index < 0) {
+            av_log(s->avctx, AV_LOG_ERROR, "rc buffer underflow\n");
+            if (frame_size > max_rate && s->qscale == s->avctx->qmax) {
+                av_log(s->avctx, AV_LOG_ERROR, "max bitrate possibly too small or try trellis with large lmax or increase qmax\n");
             }
+            rcc->buffer_index = 0;
         }
 
-        if (max_rate) {
-            double d = 2 * expected_size / buffer_size;
-            if (d > 1.0)
-                d = 1.0;
-            else if (d < 0.0001)
-                d = 0.0001;
-            q /= pow(d, 1.0 / s->rc_buffer_aggressivity);
+        left = buffer_size - rcc->buffer_index - 1;
+        rcc->buffer_index += av_clip(left, min_rate, max_rate);
 
-            q_limit = bits2qp(rce,
-                              FFMAX(rcc->buffer_index *
-                                    s->avctx->rc_max_available_vbv_use,
-                                    1));
-            if (q < q_limit) {
-                if (s->avctx->debug & FF_DEBUG_RC)
-                    av_log(s->avctx, AV_LOG_DEBUG,
-                           "limiting QP %f -> %f\n", q, q_limit);
-                q = q_limit;
-            }
-        }
-    }
-    ff_dlog(s, "q:%f max:%f min:%f size:%f index:%f agr:%f\n",
-            q, max_rate, min_rate, buffer_size, rcc->buffer_index,
-            s->rc_buffer_aggressivity);
-    if (s->rc_qsquish == 0.0 || qmin == qmax) {
-        if (q < qmin)
-            q = qmin;
-        else if (q > qmax)
-            q = qmax;
-    } else {
-        double min2 = log(qmin);
-        double max2 = log(qmax);
+        if (rcc->buffer_index > buffer_size) {
+            int stuffing = ceil((rcc->buffer_index - buffer_size) / 8);
 
-        q  = log(q);
-        q  = (q - min2) / (max2 - min2) - 0.5;
-        q *= -4.0;
-        q  = 1.0 / (1.0 + exp(q));
-        q  = q * (max2 - min2) + min2;
+            if (stuffing < 4 && s->codec_id == AV_CODEC_ID_MPEG4)
+                stuffing = 4;
+            rcc->buffer_index -= 8 * stuffing;
 
-        q = exp(q);
-    }
+            if (s->avctx->debug & FF_DEBUG_RC)
+                av_log(s->avctx, AV_LOG_DEBUG, "stuffing %d bytes\n", stuffing);
 
-    return q;
+            return stuffing;
+        }
+    }
+    return 0;
 }
 
-// ----------------------------------
-// 1 Pass Code
-
 static double predict_size(Predictor *p, double q, double var)
 {
     return p->coeff * var / (q * p->count);
@@ -770,11 +885,6 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
     Picture * const pic = &s->current_picture;
     emms_c();
 
-#if CONFIG_LIBXVID
-    if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == MPV_RC_STRATEGY_XVID)
-        return ff_xvid_rate_estimate_qscale(s, dry_run);
-#endif
-
     get_qminmax(&qmin, &qmax, s, pict_type);
 
     fps = get_fps(s->avctx);
@@ -916,167 +1026,3 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
     }
     return q;
 }
-
-// ----------------------------------------------
-// 2-Pass code
-
-static int init_pass2(MpegEncContext *s)
-{
-    RateControlContext *rcc = &s->rc_context;
-    AVCodecContext *a       = s->avctx;
-    int i, toobig;
-    double fps             = get_fps(s->avctx);
-    double complexity[5]   = { 0 }; // approximate bits at quant=1
-    uint64_t const_bits[5] = { 0 }; // quantizer independent bits
-    uint64_t all_const_bits;
-    uint64_t all_available_bits = (uint64_t)(s->bit_rate *
-                                             (double)rcc->num_entries / fps);
-    double rate_factor          = 0;
-    double step;
-    const int filter_size = (int)(a->qblur * 4) | 1;
-    double expected_bits = 0; // init to silence gcc warning
-    double *qscale, *blurred_qscale, qscale_sum;
-
-    /* find complexity & const_bits & decide the pict_types */
-    for (i = 0; i < rcc->num_entries; i++) {
-        RateControlEntry *rce = &rcc->entry[i];
-
-        rce->new_pict_type                = rce->pict_type;
-        rcc->i_cplx_sum[rce->pict_type]  += rce->i_tex_bits * rce->qscale;
-        rcc->p_cplx_sum[rce->pict_type]  += rce->p_tex_bits * rce->qscale;
-        rcc->mv_bits_sum[rce->pict_type] += rce->mv_bits;
-        rcc->frame_count[rce->pict_type]++;
-
-        complexity[rce->new_pict_type] += (rce->i_tex_bits + rce->p_tex_bits) *
-                                          (double)rce->qscale;
-        const_bits[rce->new_pict_type] += rce->mv_bits + rce->misc_bits;
-    }
-
-    all_const_bits = const_bits[AV_PICTURE_TYPE_I] +
-                     const_bits[AV_PICTURE_TYPE_P] +
-                     const_bits[AV_PICTURE_TYPE_B];
-
-    if (all_available_bits < all_const_bits) {
-        av_log(s->avctx, AV_LOG_ERROR, "requested bitrate is too low\n");
-        return -1;
-    }
-
-    qscale         = av_malloc_array(rcc->num_entries, sizeof(double));
-    blurred_qscale = av_malloc_array(rcc->num_entries, sizeof(double));
-    if (!qscale || !blurred_qscale) {
-        av_free(qscale);
-        av_free(blurred_qscale);
-        return AVERROR(ENOMEM);
-    }
-    toobig = 0;
-
-    for (step = 256 * 256; step > 0.0000001; step *= 0.5) {
-        expected_bits = 0;
-        rate_factor  += step;
-
-        rcc->buffer_index = s->avctx->rc_buffer_size / 2;
-
-        /* find qscale */
-        for (i = 0; i < rcc->num_entries; i++) {
-            RateControlEntry *rce = &rcc->entry[i];
-
-            qscale[i] = get_qscale(s, &rcc->entry[i], rate_factor, i);
-            rcc->last_qscale_for[rce->pict_type] = qscale[i];
-        }
-        av_assert0(filter_size % 2 == 1);
-
-        /* fixed I/B QP relative to P mode */
-        for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
-            RateControlEntry *rce = &rcc->entry[i];
-
-            qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
-        }
-
-        for (i = rcc->num_entries - 1; i >= 0; i--) {
-            RateControlEntry *rce = &rcc->entry[i];
-
-            qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
-        }
-
-        /* smooth curve */
-        for (i = 0; i < rcc->num_entries; i++) {
-            RateControlEntry *rce = &rcc->entry[i];
-            const int pict_type   = rce->new_pict_type;
-            int j;
-            double q = 0.0, sum = 0.0;
-
-            for (j = 0; j < filter_size; j++) {
-                int index    = i + j - filter_size / 2;
-                double d     = index - i;
-                double coeff = a->qblur == 0 ? 1.0 : exp(-d * d / (a->qblur * a->qblur));
-
-                if (index < 0 || index >= rcc->num_entries)
-                    continue;
-                if (pict_type != rcc->entry[index].new_pict_type)
-                    continue;
-                q   += qscale[index] * coeff;
-                sum += coeff;
-            }
-            blurred_qscale[i] = q / sum;
-        }
-
-        /* find expected bits */
-        for (i = 0; i < rcc->num_entries; i++) {
-            RateControlEntry *rce = &rcc->entry[i];
-            double bits;
-
-            rce->new_qscale = modify_qscale(s, rce, blurred_qscale[i], i);
-
-            bits  = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
-            bits += 8 * ff_vbv_update(s, bits);
-
-            rce->expected_bits = expected_bits;
-            expected_bits     += bits;
-        }
-
-        ff_dlog(s->avctx,
-                "expected_bits: %f all_available_bits: %d rate_factor: %f\n",
-                expected_bits, (int)all_available_bits, rate_factor);
-        if (expected_bits > all_available_bits) {
-            rate_factor -= step;
-            ++toobig;
-        }
-    }
-    av_free(qscale);
-    av_free(blurred_qscale);
-
-    /* check bitrate calculations and print info */
-    qscale_sum = 0.0;
-    for (i = 0; i < rcc->num_entries; i++) {
-        ff_dlog(s, "[lavc rc] entry[%d].new_qscale = %.3f  qp = %.3f\n",
-                i,
-                rcc->entry[i].new_qscale,
-                rcc->entry[i].new_qscale / FF_QP2LAMBDA);
-        qscale_sum += av_clip(rcc->entry[i].new_qscale / FF_QP2LAMBDA,
-                              s->avctx->qmin, s->avctx->qmax);
-    }
-    av_assert0(toobig <= 40);
-    av_log(s->avctx, AV_LOG_DEBUG,
-           "[lavc rc] requested bitrate: %"PRId64" bps  expected bitrate: %"PRId64" bps\n",
-           s->bit_rate,
-           (int64_t)(expected_bits / ((double)all_available_bits / s->bit_rate)));
-    av_log(s->avctx, AV_LOG_DEBUG,
-           "[lavc rc] estimated target average qp: %.3f\n",
-           (float)qscale_sum / rcc->num_entries);
-    if (toobig == 0) {
-        av_log(s->avctx, AV_LOG_INFO,
-               "[lavc rc] Using all of requested bitrate is not "
-               "necessary for this video with these parameters.\n");
-    } else if (toobig == 40) {
-        av_log(s->avctx, AV_LOG_ERROR,
-               "[lavc rc] Error: bitrate too low for this video "
-               "with these parameters.\n");
-        return -1;
-    } else if (fabs(expected_bits / all_available_bits - 1.0) > 0.01) {
-        av_log(s->avctx, AV_LOG_ERROR,
-               "[lavc rc] Error: 2pass curve failed to converge\n");
-        return -1;
-    }
-
-    return 0;
-}
diff --git a/mythtv/external/FFmpeg/libavcodec/ratecontrol.h b/mythtv/external/FFmpeg/libavcodec/ratecontrol.h
index c15f9e258ed..2a7aaec644c 100644
--- a/mythtv/external/FFmpeg/libavcodec/ratecontrol.h
+++ b/mythtv/external/FFmpeg/libavcodec/ratecontrol.h
@@ -96,8 +96,4 @@ void ff_rate_control_uninit(struct MpegEncContext *s);
 int ff_vbv_update(struct MpegEncContext *s, int frame_size);
 void ff_get_2pass_fcode(struct MpegEncContext *s);
 
-int ff_xvid_rate_control_init(struct MpegEncContext *s);
-void ff_xvid_rate_control_uninit(struct MpegEncContext *s);
-float ff_xvid_rate_estimate_qscale(struct MpegEncContext *s, int dry_run);
-
 #endif /* AVCODEC_RATECONTROL_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/raw.c b/mythtv/external/FFmpeg/libavcodec/raw.c
index f73a134a992..8da2a9735e8 100644
--- a/mythtv/external/FFmpeg/libavcodec/raw.c
+++ b/mythtv/external/FFmpeg/libavcodec/raw.c
@@ -119,6 +119,12 @@ const PixelFormatTag ff_raw_pix_fmt_tags[] = {
     { AV_PIX_FMT_RGB48BE,  MKTAG( 48, 'R', 'G', 'B') },
     { AV_PIX_FMT_BGR48LE,  MKTAG('B', 'G', 'R', 48 ) },
     { AV_PIX_FMT_BGR48BE,  MKTAG( 48, 'B', 'G', 'R') },
+    { AV_PIX_FMT_GRAY9LE,     MKTAG('Y', '1',  0 ,  9 ) },
+    { AV_PIX_FMT_GRAY9BE,     MKTAG( 9 ,  0 , '1', 'Y') },
+    { AV_PIX_FMT_GRAY10LE,    MKTAG('Y', '1',  0 , 10 ) },
+    { AV_PIX_FMT_GRAY10BE,    MKTAG(10 ,  0 , '1', 'Y') },
+    { AV_PIX_FMT_GRAY12LE,    MKTAG('Y', '1',  0 , 12 ) },
+    { AV_PIX_FMT_GRAY12BE,    MKTAG(12 ,  0 , '1', 'Y') },
     { AV_PIX_FMT_GRAY16LE,    MKTAG('Y', '1',  0 , 16 ) },
     { AV_PIX_FMT_GRAY16BE,    MKTAG(16 ,  0 , '1', 'Y') },
     { AV_PIX_FMT_YUV420P9LE,  MKTAG('Y', '3', 11 ,  9 ) },
@@ -266,6 +272,14 @@ const PixelFormatTag ff_raw_pix_fmt_tags[] = {
     { AV_PIX_FMT_YUV422P10BE, MKTAG('I', '2', 'A', 'B') },
     { AV_PIX_FMT_YUV444P10LE, MKTAG('I', '4', 'A', 'L') },
     { AV_PIX_FMT_YUV444P10BE, MKTAG('I', '4', 'A', 'B') },
+    { AV_PIX_FMT_YUV420P12LE, MKTAG('I', '0', 'C', 'L') },
+    { AV_PIX_FMT_YUV420P12BE, MKTAG('I', '0', 'C', 'B') },
+    { AV_PIX_FMT_YUV422P12LE, MKTAG('I', '2', 'C', 'L') },
+    { AV_PIX_FMT_YUV422P12BE, MKTAG('I', '2', 'C', 'B') },
+    { AV_PIX_FMT_YUV444P12LE, MKTAG('I', '4', 'C', 'L') },
+    { AV_PIX_FMT_YUV444P12BE, MKTAG('I', '4', 'C', 'B') },
+    { AV_PIX_FMT_YUV420P16LE, MKTAG('I', '0', 'F', 'L') },
+    { AV_PIX_FMT_YUV420P16BE, MKTAG('I', '0', 'F', 'B') },
     { AV_PIX_FMT_YUV444P16LE, MKTAG('I', '4', 'F', 'L') },
     { AV_PIX_FMT_YUV444P16BE, MKTAG('I', '4', 'F', 'B') },
 
diff --git a/mythtv/external/FFmpeg/libavcodec/rawdec.c b/mythtv/external/FFmpeg/libavcodec/rawdec.c
index 12595773978..1893b264440 100644
--- a/mythtv/external/FFmpeg/libavcodec/rawdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/rawdec.c
@@ -237,8 +237,8 @@ static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame,
     if (res < 0)
         return res;
 
-    av_frame_set_pkt_pos     (frame, avctx->internal->pkt->pos);
-    av_frame_set_pkt_duration(frame, avctx->internal->pkt->duration);
+    frame->pkt_pos      = avctx->internal->last_pkt_props->pos;
+    frame->pkt_duration = avctx->internal->last_pkt_props->duration;
 
     if (context->tff >= 0) {
         frame->interlaced_frame = 1;
@@ -364,9 +364,16 @@ static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame,
     }
 
     if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
+        int pal_size;
         const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE,
-                                                     NULL);
+                                                     &pal_size);
         int ret;
+
+        if (pal && pal_size != AVPALETTE_SIZE) {
+            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", pal_size);
+            pal = NULL;
+        }
+
         if (!context->palette)
             context->palette = av_buffer_alloc(AVPALETTE_SIZE);
         if (!context->palette) {
diff --git a/mythtv/external/FFmpeg/libavcodec/rawenc.c b/mythtv/external/FFmpeg/libavcodec/rawenc.c
index a2d5ccc0a68..d181b74570d 100644
--- a/mythtv/external/FFmpeg/libavcodec/rawenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/rawenc.c
@@ -44,6 +44,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
     avctx->bits_per_coded_sample = av_get_bits_per_pixel(desc);
     if(!avctx->codec_tag)
         avctx->codec_tag = avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
+    avctx->bit_rate = ff_guess_coded_bitrate(avctx);
+
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/rdft.c b/mythtv/external/FFmpeg/libavcodec/rdft.c
index c318aa83949..6ba74842385 100644
--- a/mythtv/external/FFmpeg/libavcodec/rdft.c
+++ b/mythtv/external/FFmpeg/libavcodec/rdft.c
@@ -28,28 +28,6 @@
  * (Inverse) Real Discrete Fourier Transforms.
  */
 
-/* sin(2*pi*x/n) for 0<=x<n/4, followed by n/2<=x<3n/4 */
-#if !CONFIG_HARDCODED_TABLES
-SINTABLE(16);
-SINTABLE(32);
-SINTABLE(64);
-SINTABLE(128);
-SINTABLE(256);
-SINTABLE(512);
-SINTABLE(1024);
-SINTABLE(2048);
-SINTABLE(4096);
-SINTABLE(8192);
-SINTABLE(16384);
-SINTABLE(32768);
-SINTABLE(65536);
-#endif
-static SINTABLE_CONST FFTSample * const ff_sin_tabs[] = {
-    NULL, NULL, NULL, NULL,
-    ff_sin_16, ff_sin_32, ff_sin_64, ff_sin_128, ff_sin_256, ff_sin_512, ff_sin_1024,
-    ff_sin_2048, ff_sin_4096, ff_sin_8192, ff_sin_16384, ff_sin_32768, ff_sin_65536,
-};
-
 /** Map one real FFT into two parallel real even and odd FFTs. Then interleave
  * the two real FFTs into one complex FFT. Unmangle the results.
  * ref: http://www.engineeringproductivitytools.com/stuff/T0001/PT10.HTM
@@ -57,7 +35,7 @@ static SINTABLE_CONST FFTSample * const ff_sin_tabs[] = {
 static void rdft_calc_c(RDFTContext *s, FFTSample *data)
 {
     int i, i1, i2;
-    FFTComplex ev, od;
+    FFTComplex ev, od, odsum;
     const int n = 1 << s->nbits;
     const float k1 = 0.5;
     const float k2 = 0.5 - s->inverse;
@@ -73,20 +51,31 @@ static void rdft_calc_c(RDFTContext *s, FFTSample *data)
     ev.re = data[0];
     data[0] = ev.re+data[1];
     data[1] = ev.re-data[1];
-    for (i = 1; i < (n>>2); i++) {
-        i1 = 2*i;
-        i2 = n-i1;
-        /* Separate even and odd FFTs */
-        ev.re =  k1*(data[i1  ]+data[i2  ]);
-        od.im = -k2*(data[i1  ]-data[i2  ]);
-        ev.im =  k1*(data[i1+1]-data[i2+1]);
-        od.re =  k2*(data[i1+1]+data[i2+1]);
-        /* Apply twiddle factors to the odd FFT and add to the even FFT */
-        data[i1  ] =  ev.re + od.re*tcos[i] - od.im*tsin[i];
-        data[i1+1] =  ev.im + od.im*tcos[i] + od.re*tsin[i];
-        data[i2  ] =  ev.re - od.re*tcos[i] + od.im*tsin[i];
-        data[i2+1] = -ev.im + od.im*tcos[i] + od.re*tsin[i];
+
+#define RDFT_UNMANGLE(sign0, sign1)                                         \
+    for (i = 1; i < (n>>2); i++) {                                          \
+        i1 = 2*i;                                                           \
+        i2 = n-i1;                                                          \
+        /* Separate even and odd FFTs */                                    \
+        ev.re =  k1*(data[i1  ]+data[i2  ]);                                \
+        od.im =  k2*(data[i2  ]-data[i1  ]);                                \
+        ev.im =  k1*(data[i1+1]-data[i2+1]);                                \
+        od.re =  k2*(data[i1+1]+data[i2+1]);                                \
+        /* Apply twiddle factors to the odd FFT and add to the even FFT */  \
+        odsum.re = od.re*tcos[i] sign0 od.im*tsin[i];                       \
+        odsum.im = od.im*tcos[i] sign1 od.re*tsin[i];                       \
+        data[i1  ] =  ev.re + odsum.re;                                     \
+        data[i1+1] =  ev.im + odsum.im;                                     \
+        data[i2  ] =  ev.re - odsum.re;                                     \
+        data[i2+1] =  odsum.im - ev.im;                                     \
+    }
+
+    if (s->negative_sin) {
+        RDFT_UNMANGLE(+,-)
+    } else {
+        RDFT_UNMANGLE(-,+)
     }
+
     data[2*i+1]=s->sign_convention*data[2*i+1];
     if (s->inverse) {
         data[0] *= k1;
@@ -104,6 +93,7 @@ av_cold int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans)
     s->nbits           = nbits;
     s->inverse         = trans == IDFT_C2R || trans == DFT_C2R;
     s->sign_convention = trans == IDFT_R2C || trans == DFT_C2R ? 1 : -1;
+    s->negative_sin    = trans == DFT_C2R || trans == DFT_R2C;
 
     if (nbits < 4 || nbits > 16)
         return AVERROR(EINVAL);
@@ -113,15 +103,7 @@ av_cold int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans)
 
     ff_init_ff_cos_tabs(nbits);
     s->tcos = ff_cos_tabs[nbits];
-    s->tsin = ff_sin_tabs[nbits]+(trans == DFT_R2C || trans == DFT_C2R)*(n>>2);
-#if !CONFIG_HARDCODED_TABLES
-    {
-        int i;
-        const double theta = (trans == DFT_R2C || trans == DFT_C2R ? -1 : 1) * 2 * M_PI / n;
-        for (i = 0; i < (n >> 2); i++)
-            s->tsin[i] = sin(i * theta);
-    }
-#endif
+    s->tsin = ff_cos_tabs[nbits] + (n >> 2);
     s->rdft_calc   = rdft_calc_c;
 
     if (ARCH_ARM) ff_rdft_init_arm(s);
diff --git a/mythtv/external/FFmpeg/libavcodec/rdft.h b/mythtv/external/FFmpeg/libavcodec/rdft.h
index 37c40e7c80d..ffafca7f242 100644
--- a/mythtv/external/FFmpeg/libavcodec/rdft.h
+++ b/mythtv/external/FFmpeg/libavcodec/rdft.h
@@ -25,29 +25,6 @@
 #include "config.h"
 #include "fft.h"
 
-#if CONFIG_HARDCODED_TABLES
-#   define SINTABLE_CONST const
-#else
-#   define SINTABLE_CONST
-#endif
-
-#define SINTABLE(size) \
-    SINTABLE_CONST DECLARE_ALIGNED(16, FFTSample, ff_sin_##size)[size/2]
-
-extern SINTABLE(16);
-extern SINTABLE(32);
-extern SINTABLE(64);
-extern SINTABLE(128);
-extern SINTABLE(256);
-extern SINTABLE(512);
-extern SINTABLE(1024);
-extern SINTABLE(2048);
-extern SINTABLE(4096);
-extern SINTABLE(8192);
-extern SINTABLE(16384);
-extern SINTABLE(32768);
-extern SINTABLE(65536);
-
 struct RDFTContext {
     int nbits;
     int inverse;
@@ -55,7 +32,8 @@ struct RDFTContext {
 
     /* pre/post rotation tables */
     const FFTSample *tcos;
-    SINTABLE_CONST FFTSample *tsin;
+    const FFTSample *tsin;
+    int negative_sin;
     FFTContext fft;
     void (*rdft_calc)(struct RDFTContext *s, FFTSample *z);
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/rkmppdec.c b/mythtv/external/FFmpeg/libavcodec/rkmppdec.c
new file mode 100644
index 00000000000..bdf4dc4208c
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/rkmppdec.c
@@ -0,0 +1,596 @@
+/*
+ * RockChip MPP Video Decoder
+ * Copyright (c) 2017 Lionel CHAZALLON
+ *
+ * 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 <drm_fourcc.h>
+#include <pthread.h>
+#include <rockchip/mpp_buffer.h>
+#include <rockchip/rk_mpi.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "avcodec.h"
+#include "decode.h"
+#include "internal.h"
+#include "libavutil/buffer.h"
+#include "libavutil/common.h"
+#include "libavutil/frame.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_drm.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/log.h"
+
+#define RECEIVE_FRAME_TIMEOUT   100
+#define FRAMEGROUP_MAX_FRAMES   16
+
+typedef struct {
+    MppCtx ctx;
+    MppApi *mpi;
+    MppBufferGroup frame_group;
+
+    char first_frame;
+    char first_packet;
+    char eos_reached;
+
+    AVBufferRef *frames_ref;
+    AVBufferRef *device_ref;
+} RKMPPDecoder;
+
+typedef struct {
+    AVClass *av_class;
+    AVBufferRef *decoder_ref;
+} RKMPPDecodeContext;
+
+typedef struct {
+    MppFrame frame;
+    AVBufferRef *decoder_ref;
+} RKMPPFrameContext;
+
+static MppCodingType rkmpp_get_codingtype(AVCodecContext *avctx)
+{
+    switch (avctx->codec_id) {
+    case AV_CODEC_ID_H264:          return MPP_VIDEO_CodingAVC;
+    case AV_CODEC_ID_HEVC:          return MPP_VIDEO_CodingHEVC;
+    case AV_CODEC_ID_VP8:           return MPP_VIDEO_CodingVP8;
+    case AV_CODEC_ID_VP9:           return MPP_VIDEO_CodingVP9;
+    default:                        return MPP_VIDEO_CodingUnused;
+    }
+}
+
+static uint32_t rkmpp_get_frameformat(MppFrameFormat mppformat)
+{
+    switch (mppformat) {
+    case MPP_FMT_YUV420SP:          return DRM_FORMAT_NV12;
+#ifdef DRM_FORMAT_NV12_10
+    case MPP_FMT_YUV420SP_10BIT:    return DRM_FORMAT_NV12_10;
+#endif
+    default:                        return 0;
+    }
+}
+
+static int rkmpp_write_data(AVCodecContext *avctx, uint8_t *buffer, int size, int64_t pts)
+{
+    RKMPPDecodeContext *rk_context = avctx->priv_data;
+    RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data;
+    int ret;
+    MppPacket packet;
+
+    // create the MPP packet
+    ret = mpp_packet_init(&packet, buffer, size);
+    if (ret != MPP_OK) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to init MPP packet (code = %d)\n", ret);
+        return AVERROR_UNKNOWN;
+    }
+
+    mpp_packet_set_pts(packet, pts);
+
+    if (!buffer)
+        mpp_packet_set_eos(packet);
+
+    ret = decoder->mpi->decode_put_packet(decoder->ctx, packet);
+    if (ret != MPP_OK) {
+        if (ret == MPP_ERR_BUFFER_FULL) {
+            av_log(avctx, AV_LOG_DEBUG, "Buffer full writing %d bytes to decoder\n", size);
+            ret = AVERROR(EAGAIN);
+        } else
+            ret = AVERROR_UNKNOWN;
+    }
+    else
+        av_log(avctx, AV_LOG_DEBUG, "Wrote %d bytes to decoder\n", size);
+
+    mpp_packet_deinit(&packet);
+
+    return ret;
+}
+
+static int rkmpp_close_decoder(AVCodecContext *avctx)
+{
+    RKMPPDecodeContext *rk_context = avctx->priv_data;
+    av_buffer_unref(&rk_context->decoder_ref);
+    return 0;
+}
+
+static void rkmpp_release_decoder(void *opaque, uint8_t *data)
+{
+    RKMPPDecoder *decoder = (RKMPPDecoder *)data;
+
+    if (decoder->mpi) {
+        decoder->mpi->reset(decoder->ctx);
+        mpp_destroy(decoder->ctx);
+        decoder->ctx = NULL;
+    }
+
+    if (decoder->frame_group) {
+        mpp_buffer_group_put(decoder->frame_group);
+        decoder->frame_group = NULL;
+    }
+
+    av_buffer_unref(&decoder->frames_ref);
+    av_buffer_unref(&decoder->device_ref);
+
+    av_free(decoder);
+}
+
+static int rkmpp_init_decoder(AVCodecContext *avctx)
+{
+    RKMPPDecodeContext *rk_context = avctx->priv_data;
+    RKMPPDecoder *decoder = NULL;
+    MppCodingType codectype = MPP_VIDEO_CodingUnused;
+    int ret;
+    RK_S64 paramS64;
+    RK_S32 paramS32;
+
+    avctx->pix_fmt = AV_PIX_FMT_DRM_PRIME;
+
+    // create a decoder and a ref to it
+    decoder = av_mallocz(sizeof(RKMPPDecoder));
+    if (!decoder) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    rk_context->decoder_ref = av_buffer_create((uint8_t *)decoder, sizeof(*decoder), rkmpp_release_decoder,
+                                               NULL, AV_BUFFER_FLAG_READONLY);
+    if (!rk_context->decoder_ref) {
+        av_free(decoder);
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    av_log(avctx, AV_LOG_DEBUG, "Initializing RKMPP decoder.\n");
+
+    codectype = rkmpp_get_codingtype(avctx);
+    if (codectype == MPP_VIDEO_CodingUnused) {
+        av_log(avctx, AV_LOG_ERROR, "Unknown codec type (%d).\n", avctx->codec_id);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    ret = mpp_check_support_format(MPP_CTX_DEC, codectype);
+    if (ret != MPP_OK) {
+        av_log(avctx, AV_LOG_ERROR, "Codec type (%d) unsupported by MPP\n", avctx->codec_id);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    // Create the MPP context
+    ret = mpp_create(&decoder->ctx, &decoder->mpi);
+    if (ret != MPP_OK) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create MPP context (code = %d).\n", ret);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    // initialize mpp
+    ret = mpp_init(decoder->ctx, MPP_CTX_DEC, codectype);
+    if (ret != MPP_OK) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to initialize MPP context (code = %d).\n", ret);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    // make decode calls blocking with a timeout
+    paramS32 = MPP_POLL_BLOCK;
+    ret = decoder->mpi->control(decoder->ctx, MPP_SET_OUTPUT_BLOCK, &paramS32);
+    if (ret != MPP_OK) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to set blocking mode on MPI (code = %d).\n", ret);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    paramS64 = RECEIVE_FRAME_TIMEOUT;
+    ret = decoder->mpi->control(decoder->ctx, MPP_SET_OUTPUT_BLOCK_TIMEOUT, &paramS64);
+    if (ret != MPP_OK) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to set block timeout on MPI (code = %d).\n", ret);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    ret = mpp_buffer_group_get_internal(&decoder->frame_group, MPP_BUFFER_TYPE_ION);
+    if (ret) {
+       av_log(avctx, AV_LOG_ERROR, "Failed to retrieve buffer group (code = %d)\n", ret);
+       ret = AVERROR_UNKNOWN;
+       goto fail;
+    }
+
+    ret = decoder->mpi->control(decoder->ctx, MPP_DEC_SET_EXT_BUF_GROUP, decoder->frame_group);
+    if (ret) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to assign buffer group (code = %d)\n", ret);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    ret = mpp_buffer_group_limit_config(decoder->frame_group, 0, FRAMEGROUP_MAX_FRAMES);
+    if (ret) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to set buffer group limit (code = %d)\n", ret);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    decoder->first_packet = 1;
+
+    av_log(avctx, AV_LOG_DEBUG, "RKMPP decoder initialized successfully.\n");
+
+    decoder->device_ref = av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_DRM);
+    if (!decoder->device_ref) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+    ret = av_hwdevice_ctx_init(decoder->device_ref);
+    if (ret < 0)
+        goto fail;
+
+    return 0;
+
+fail:
+    av_log(avctx, AV_LOG_ERROR, "Failed to initialize RKMPP decoder.\n");
+    rkmpp_close_decoder(avctx);
+    return ret;
+}
+
+static int rkmpp_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
+{
+    RKMPPDecodeContext *rk_context = avctx->priv_data;
+    RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data;
+    int ret;
+
+    // handle EOF
+    if (!avpkt->size) {
+        av_log(avctx, AV_LOG_DEBUG, "End of stream.\n");
+        decoder->eos_reached = 1;
+        ret = rkmpp_write_data(avctx, NULL, 0, 0);
+        if (ret)
+            av_log(avctx, AV_LOG_ERROR, "Failed to send EOS to decoder (code = %d)\n", ret);
+        return ret;
+    }
+
+    // on first packet, send extradata
+    if (decoder->first_packet) {
+        if (avctx->extradata_size) {
+            ret = rkmpp_write_data(avctx, avctx->extradata,
+                                            avctx->extradata_size,
+                                            avpkt->pts);
+            if (ret) {
+                av_log(avctx, AV_LOG_ERROR, "Failed to write extradata to decoder (code = %d)\n", ret);
+                return ret;
+            }
+        }
+        decoder->first_packet = 0;
+    }
+
+    // now send packet
+    ret = rkmpp_write_data(avctx, avpkt->data, avpkt->size, avpkt->pts);
+    if (ret && ret!=AVERROR(EAGAIN))
+        av_log(avctx, AV_LOG_ERROR, "Failed to write data to decoder (code = %d)\n", ret);
+
+    return ret;
+}
+
+static void rkmpp_release_frame(void *opaque, uint8_t *data)
+{
+    AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor *)data;
+    AVBufferRef *framecontextref = (AVBufferRef *)opaque;
+    RKMPPFrameContext *framecontext = (RKMPPFrameContext *)framecontextref->data;
+
+    mpp_frame_deinit(&framecontext->frame);
+    av_buffer_unref(&framecontext->decoder_ref);
+    av_buffer_unref(&framecontextref);
+
+    av_free(desc);
+}
+
+static int rkmpp_retrieve_frame(AVCodecContext *avctx, AVFrame *frame)
+{
+    RKMPPDecodeContext *rk_context = avctx->priv_data;
+    RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data;
+    RKMPPFrameContext *framecontext = NULL;
+    AVBufferRef *framecontextref = NULL;
+    int ret;
+    MppFrame mppframe = NULL;
+    MppBuffer buffer = NULL;
+    AVDRMFrameDescriptor *desc = NULL;
+    AVDRMLayerDescriptor *layer = NULL;
+    int retrycount = 0;
+    int mode;
+    MppFrameFormat mppformat;
+    uint32_t drmformat;
+
+    // on start of decoding, MPP can return -1, which is supposed to be expected
+    // this is due to some internal MPP init which is not completed, that will
+    // only happen in the first few frames queries, but should not be interpreted
+    // as an error, Therefore we need to retry a couple times when we get -1
+    // in order to let it time to complete it's init, then we sleep a bit between retries.
+retry_get_frame:
+    ret = decoder->mpi->decode_get_frame(decoder->ctx, &mppframe);
+    if (ret != MPP_OK && ret != MPP_ERR_TIMEOUT && !decoder->first_frame) {
+        if (retrycount < 5) {
+            av_log(avctx, AV_LOG_DEBUG, "Failed to get a frame, retrying (code = %d, retrycount = %d)\n", ret, retrycount);
+            usleep(10000);
+            retrycount++;
+            goto retry_get_frame;
+        } else {
+            av_log(avctx, AV_LOG_ERROR, "Failed to get a frame from MPP (code = %d)\n", ret);
+            goto fail;
+        }
+    }
+
+    if (mppframe) {
+        // Check whether we have a special frame or not
+        if (mpp_frame_get_info_change(mppframe)) {
+            AVHWFramesContext *hwframes;
+
+            av_log(avctx, AV_LOG_INFO, "Decoder noticed an info change (%dx%d), format=%d\n",
+                                        (int)mpp_frame_get_width(mppframe), (int)mpp_frame_get_height(mppframe),
+                                        (int)mpp_frame_get_fmt(mppframe));
+
+            avctx->width = mpp_frame_get_width(mppframe);
+            avctx->height = mpp_frame_get_height(mppframe);
+
+            decoder->mpi->control(decoder->ctx, MPP_DEC_SET_INFO_CHANGE_READY, NULL);
+            decoder->first_frame = 1;
+
+            av_buffer_unref(&decoder->frames_ref);
+
+            decoder->frames_ref = av_hwframe_ctx_alloc(decoder->device_ref);
+            if (!decoder->frames_ref) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+
+            mppformat = mpp_frame_get_fmt(mppframe);
+            drmformat = rkmpp_get_frameformat(mppformat);
+
+            hwframes = (AVHWFramesContext*)decoder->frames_ref->data;
+            hwframes->format    = AV_PIX_FMT_DRM_PRIME;
+            hwframes->sw_format = drmformat == DRM_FORMAT_NV12 ? AV_PIX_FMT_NV12 : AV_PIX_FMT_NONE;
+            hwframes->width     = avctx->width;
+            hwframes->height    = avctx->height;
+            ret = av_hwframe_ctx_init(decoder->frames_ref);
+            if (ret < 0)
+                goto fail;
+
+            // here decoder is fully initialized, we need to feed it again with data
+            ret = AVERROR(EAGAIN);
+            goto fail;
+        } else if (mpp_frame_get_eos(mppframe)) {
+            av_log(avctx, AV_LOG_DEBUG, "Received a EOS frame.\n");
+            decoder->eos_reached = 1;
+            ret = AVERROR_EOF;
+            goto fail;
+        } else if (mpp_frame_get_discard(mppframe)) {
+            av_log(avctx, AV_LOG_DEBUG, "Received a discard frame.\n");
+            ret = AVERROR(EAGAIN);
+            goto fail;
+        } else if (mpp_frame_get_errinfo(mppframe)) {
+            av_log(avctx, AV_LOG_ERROR, "Received a errinfo frame.\n");
+            ret = AVERROR_UNKNOWN;
+            goto fail;
+        }
+
+        // here we should have a valid frame
+        av_log(avctx, AV_LOG_DEBUG, "Received a frame.\n");
+
+        // setup general frame fields
+        frame->format           = AV_PIX_FMT_DRM_PRIME;
+        frame->width            = mpp_frame_get_width(mppframe);
+        frame->height           = mpp_frame_get_height(mppframe);
+        frame->pts              = mpp_frame_get_pts(mppframe);
+        frame->color_range      = mpp_frame_get_color_range(mppframe);
+        frame->color_primaries  = mpp_frame_get_color_primaries(mppframe);
+        frame->color_trc        = mpp_frame_get_color_trc(mppframe);
+        frame->colorspace       = mpp_frame_get_colorspace(mppframe);
+
+        mode = mpp_frame_get_mode(mppframe);
+        frame->interlaced_frame = ((mode & MPP_FRAME_FLAG_FIELD_ORDER_MASK) == MPP_FRAME_FLAG_DEINTERLACED);
+        frame->top_field_first  = ((mode & MPP_FRAME_FLAG_FIELD_ORDER_MASK) == MPP_FRAME_FLAG_TOP_FIRST);
+
+        mppformat = mpp_frame_get_fmt(mppframe);
+        drmformat = rkmpp_get_frameformat(mppformat);
+
+        // now setup the frame buffer info
+        buffer = mpp_frame_get_buffer(mppframe);
+        if (buffer) {
+            desc = av_mallocz(sizeof(AVDRMFrameDescriptor));
+            if (!desc) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+
+            desc->nb_objects = 1;
+            desc->objects[0].fd = mpp_buffer_get_fd(buffer);
+            desc->objects[0].size = mpp_buffer_get_size(buffer);
+
+            desc->nb_layers = 1;
+            layer = &desc->layers[0];
+            layer->format = drmformat;
+            layer->nb_planes = 2;
+
+            layer->planes[0].object_index = 0;
+            layer->planes[0].offset = 0;
+            layer->planes[0].pitch = mpp_frame_get_hor_stride(mppframe);
+
+            layer->planes[1].object_index = 0;
+            layer->planes[1].offset = layer->planes[0].pitch * mpp_frame_get_ver_stride(mppframe);
+            layer->planes[1].pitch = layer->planes[0].pitch;
+
+            // we also allocate a struct in buf[0] that will allow to hold additionnal information
+            // for releasing properly MPP frames and decoder
+            framecontextref = av_buffer_allocz(sizeof(*framecontext));
+            if (!framecontextref) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+
+            // MPP decoder needs to be closed only when all frames have been released.
+            framecontext = (RKMPPFrameContext *)framecontextref->data;
+            framecontext->decoder_ref = av_buffer_ref(rk_context->decoder_ref);
+            framecontext->frame = mppframe;
+
+            frame->data[0]  = (uint8_t *)desc;
+            frame->buf[0]   = av_buffer_create((uint8_t *)desc, sizeof(*desc), rkmpp_release_frame,
+                                               framecontextref, AV_BUFFER_FLAG_READONLY);
+
+            if (!frame->buf[0]) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+
+            frame->hw_frames_ctx = av_buffer_ref(decoder->frames_ref);
+            if (!frame->hw_frames_ctx) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+
+            decoder->first_frame = 0;
+            return 0;
+        } else {
+            av_log(avctx, AV_LOG_ERROR, "Failed to retrieve the frame buffer, frame is dropped (code = %d)\n", ret);
+            mpp_frame_deinit(&mppframe);
+        }
+    } else if (decoder->eos_reached) {
+        return AVERROR_EOF;
+    } else if (ret == MPP_ERR_TIMEOUT) {
+        av_log(avctx, AV_LOG_DEBUG, "Timeout when trying to get a frame from MPP\n");
+    }
+
+    return AVERROR(EAGAIN);
+
+fail:
+    if (mppframe)
+        mpp_frame_deinit(&mppframe);
+
+    if (framecontext)
+        av_buffer_unref(&framecontext->decoder_ref);
+
+    if (framecontextref)
+        av_buffer_unref(&framecontextref);
+
+    if (desc)
+        av_free(desc);
+
+    return ret;
+}
+
+static int rkmpp_receive_frame(AVCodecContext *avctx, AVFrame *frame)
+{
+    RKMPPDecodeContext *rk_context = avctx->priv_data;
+    RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data;
+    int ret = MPP_NOK;
+    AVPacket pkt = {0};
+    RK_S32 freeslots;
+
+    if (!decoder->eos_reached) {
+        // we get the available slots in decoder
+        ret = decoder->mpi->control(decoder->ctx, MPP_DEC_GET_FREE_PACKET_SLOT_COUNT, &freeslots);
+        if (ret != MPP_OK) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to get decoder free slots (code = %d).\n", ret);
+            return ret;
+        }
+
+        if (freeslots > 0) {
+            ret = ff_decode_get_packet(avctx, &pkt);
+            if (ret < 0 && ret != AVERROR_EOF) {
+                return ret;
+            }
+
+            ret = rkmpp_send_packet(avctx, &pkt);
+            av_packet_unref(&pkt);
+
+            if (ret < 0) {
+                av_log(avctx, AV_LOG_ERROR, "Failed to send packet to decoder (code = %d)\n", ret);
+                return ret;
+            }
+        }
+
+        // make sure we keep decoder full
+        if (freeslots > 1 && decoder->first_frame)
+            return AVERROR(EAGAIN);
+    }
+
+    return rkmpp_retrieve_frame(avctx, frame);
+}
+
+static void rkmpp_flush(AVCodecContext *avctx)
+{
+    RKMPPDecodeContext *rk_context = avctx->priv_data;
+    RKMPPDecoder *decoder = (RKMPPDecoder *)rk_context->decoder_ref->data;
+    int ret = MPP_NOK;
+
+    av_log(avctx, AV_LOG_DEBUG, "Flush.\n");
+
+    ret = decoder->mpi->reset(decoder->ctx);
+    if (ret == MPP_OK) {
+        decoder->first_frame = 1;
+        decoder->first_packet = 1;
+    } else
+        av_log(avctx, AV_LOG_ERROR, "Failed to reset MPI (code = %d)\n", ret);
+}
+
+
+#define RKMPP_DEC_CLASS(NAME) \
+    static const AVClass rkmpp_##NAME##_dec_class = { \
+        .class_name = "rkmpp_" #NAME "_dec", \
+        .version    = LIBAVUTIL_VERSION_INT, \
+    };
+
+#define RKMPP_DEC(NAME, ID, BSFS) \
+    RKMPP_DEC_CLASS(NAME) \
+    AVCodec ff_##NAME##_rkmpp_decoder = { \
+        .name           = #NAME "_rkmpp", \
+        .long_name      = NULL_IF_CONFIG_SMALL(#NAME " (rkmpp)"), \
+        .type           = AVMEDIA_TYPE_VIDEO, \
+        .id             = ID, \
+        .priv_data_size = sizeof(RKMPPDecodeContext), \
+        .init           = rkmpp_init_decoder, \
+        .close          = rkmpp_close_decoder, \
+        .receive_frame  = rkmpp_receive_frame, \
+        .flush          = rkmpp_flush, \
+        .priv_class     = &rkmpp_##NAME##_dec_class, \
+        .capabilities   = AV_CODEC_CAP_DELAY, \
+        .caps_internal  = AV_CODEC_CAP_AVOID_PROBING, \
+        .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_DRM_PRIME, \
+                                                         AV_PIX_FMT_NONE}, \
+        .bsfs           = BSFS, \
+    };
+
+RKMPP_DEC(h264,  AV_CODEC_ID_H264,          "h264_mp4toannexb")
+RKMPP_DEC(hevc,  AV_CODEC_ID_HEVC,          "hevc_mp4toannexb")
+RKMPP_DEC(vp8,   AV_CODEC_ID_VP8,           NULL)
+RKMPP_DEC(vp9,   AV_CODEC_ID_VP9,           NULL)
diff --git a/mythtv/external/FFmpeg/libavcodec/rle.c b/mythtv/external/FFmpeg/libavcodec/rle.c
index 7924ea780f9..792bc05e5d0 100644
--- a/mythtv/external/FFmpeg/libavcodec/rle.c
+++ b/mythtv/external/FFmpeg/libavcodec/rle.c
@@ -18,26 +18,29 @@
  * 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/common.h"
+
 #include "avcodec.h"
 #include "rle.h"
-#include "libavutil/common.h"
 
 int ff_rle_count_pixels(const uint8_t *start, int len, int bpp, int same)
 {
     const uint8_t *pos;
     int count = 1;
 
-    for(pos = start + bpp; count < FFMIN(127, len); pos += bpp, count ++) {
-        if(same != !memcmp(pos-bpp, pos, bpp)) {
-            if(!same) {
-                /* if bpp == 1, then 0 1 1 0 is more efficiently encoded as a single
-                 * raw block of pixels.  for larger bpp, RLE is as good or better */
-                if(bpp == 1 && count + 1 < FFMIN(127, len) && *pos != *(pos+1))
+    for (pos = start + bpp; count < FFMIN(127, len); pos += bpp, count++) {
+        if (same != !memcmp(pos - bpp, pos, bpp)) {
+            if (!same) {
+                /* if bpp == 1, then 0 1 1 0 is more efficiently encoded as a
+                 * single raw block of pixels. For larger bpp, RLE is as good
+                 * or better */
+                if (bpp == 1 && count + 1 < FFMIN(127, len) && *pos != *(pos + 1))
                     continue;
 
                 /* if RLE can encode the next block better than as a raw block,
                  * back up and leave _all_ the identical pixels for RLE */
-                count --;
+                count--;
             }
             break;
         }
@@ -46,25 +49,28 @@ int ff_rle_count_pixels(const uint8_t *start, int len, int bpp, int same)
     return count;
 }
 
-int ff_rle_encode(uint8_t *outbuf, int out_size, const uint8_t *ptr , int bpp, int w,
-                  int add_rep, int xor_rep, int add_raw, int xor_raw)
+int ff_rle_encode(uint8_t *outbuf, int out_size, const uint8_t *ptr, int bpp,
+                  int w, int add_rep, int xor_rep, int add_raw, int xor_raw)
 {
     int count, x;
     uint8_t *out = outbuf;
 
-    for(x = 0; x < w; x += count) {
+    for (x = 0; x < w; x += count) {
         /* see if we can encode the next set of pixels with RLE */
         if ((count = ff_rle_count_pixels(ptr, w - x, bpp, 1)) > 1) {
-            if(out + bpp + 1 > outbuf + out_size) return -1;
+            if (out + bpp + 1 > outbuf + out_size)
+                return -1;
+
             *out++ = (count ^ xor_rep) + add_rep;
             memcpy(out, ptr, bpp);
             out += bpp;
         } else {
             /* fall back on uncompressed */
             count = ff_rle_count_pixels(ptr, w - x, bpp, 0);
-            if(out + bpp*count >= outbuf + out_size) return -1;
-            *out++ = (count ^ xor_raw) + add_raw;
+            if (out + bpp * count >= outbuf + out_size)
+                return -1;
 
+            *out++ = (count ^ xor_raw) + add_raw;
             memcpy(out, ptr, bpp * count);
             out += bpp * count;
         }
diff --git a/mythtv/external/FFmpeg/libavcodec/rle.h b/mythtv/external/FFmpeg/libavcodec/rle.h
index cb516249757..a92edf7a26b 100644
--- a/mythtv/external/FFmpeg/libavcodec/rle.h
+++ b/mythtv/external/FFmpeg/libavcodec/rle.h
@@ -35,8 +35,9 @@
 int ff_rle_count_pixels(const uint8_t *start, int len, int bpp, int same);
 
 /**
- * RLE compress the row, with maximum size of out_size. Value before repeated bytes is (count ^ xor_rep) + add_rep.
- *                                                      Value before raw bytes is      (count ^ xor_raw) + add_raw.
+ * RLE compress the row, with maximum size of out_size.
+ * Value before repeated bytes is (count ^ xor_rep) + add_rep.
+ * Value before raw bytes is (count ^ xor_raw) + add_raw.
  * @param outbuf Output buffer
  * @param out_size Maximum output size
  * @param inbuf Input buffer
@@ -44,7 +45,7 @@ int ff_rle_count_pixels(const uint8_t *start, int len, int bpp, int same);
  * @param w Image width
  * @return Size of output in bytes, or -1 if larger than out_size
  */
-int ff_rle_encode(uint8_t *outbuf, int out_size, const uint8_t *inbuf, int bpp, int w,
-                  int add_rep, int xor_rep, int add_raw, int xor_raw);
+int ff_rle_encode(uint8_t *outbuf, int out_size, const uint8_t *inbuf, int bpp,
+                  int w, int add_rep, int xor_rep, int add_raw, int xor_raw);
 
 #endif /* AVCODEC_RLE_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/roqvideodec.c b/mythtv/external/FFmpeg/libavcodec/roqvideodec.c
index 4c5dec52bc5..0ab7d399d67 100644
--- a/mythtv/external/FFmpeg/libavcodec/roqvideodec.c
+++ b/mythtv/external/FFmpeg/libavcodec/roqvideodec.c
@@ -175,8 +175,7 @@ static av_cold int roq_decode_init(AVCodecContext *avctx)
     s->avctx = avctx;
 
     if (avctx->width % 16 || avctx->height % 16) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Dimensions must be a multiple of 16\n");
+        avpriv_request_sample(avctx, "Dimensions not being a multiple of 16");
         return AVERROR_PATCHWELCOME;
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/roqvideoenc.c b/mythtv/external/FFmpeg/libavcodec/roqvideoenc.c
index 038a63d34de..ac05123dc66 100644
--- a/mythtv/external/FFmpeg/libavcodec/roqvideoenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/roqvideoenc.c
@@ -736,21 +736,6 @@ static void reconstruct_and_encode_image(RoqContext *enc, RoqTempdata *tempData,
     /* Flush the remainder of the argument/type spool */
     while (spool.typeSpoolLength)
         write_typecode(&spool, 0x0);
-
-#if 0
-    uint8_t *fdata[3] = {enc->frame_to_enc->data[0],
-                           enc->frame_to_enc->data[1],
-                           enc->frame_to_enc->data[2]};
-    uint8_t *cdata[3] = {enc->current_frame->data[0],
-                           enc->current_frame->data[1],
-                           enc->current_frame->data[2]};
-    av_log(enc->avctx, AV_LOG_ERROR, "Expected distortion: %i Actual: %i\n",
-           dist,
-           block_sse(fdata, cdata, 0, 0, 0, 0,
-                     enc->frame_to_enc->linesize,
-                     enc->current_frame->linesize,
-                     enc->width));  //WARNING: Square dimensions implied...
-#endif
 }
 
 
diff --git a/mythtv/external/FFmpeg/libavcodec/rscc.c b/mythtv/external/FFmpeg/libavcodec/rscc.c
index 7f280a9a973..f270cd53511 100644
--- a/mythtv/external/FFmpeg/libavcodec/rscc.c
+++ b/mythtv/external/FFmpeg/libavcodec/rscc.c
@@ -31,7 +31,7 @@
  * and it can be deflated or not. Similarly, pixel data comes after the header
  * and a variable size value, and it can be deflated or just raw.
  *
- * Supports: BGRA, BGR24, RGB555, PAL8
+ * Supports: PAL8, BGRA, BGR24, RGB555
  */
 
 #include <stdint.h>
@@ -58,7 +58,8 @@ typedef struct RsccContext {
     Tile *tiles;
     unsigned int tiles_size;
     int component_size;
-    uint32_t pal[AVPALETTE_COUNT];
+
+    uint8_t palette[AVPALETTE_SIZE];
 
     /* zlib interaction */
     uint8_t *inflated_buf;
@@ -210,6 +211,12 @@ static int rscc_decode_frame(AVCodecContext *avctx, void *data,
         ctx->tiles[i].y = bytestream2_get_le16(gbc);
         ctx->tiles[i].h = bytestream2_get_le16(gbc);
 
+        if (pixel_size + ctx->tiles[i].w * (int64_t)ctx->tiles[i].h * ctx->component_size > INT_MAX) {
+            av_log(avctx, AV_LOG_ERROR, "Invalid tile dimensions\n");
+            ret = AVERROR_INVALIDDATA;
+            goto end;
+        }
+
         pixel_size += ctx->tiles[i].w * ctx->tiles[i].h * ctx->component_size;
 
         ff_dlog(avctx, "tile %d orig(%d,%d) %dx%d.\n", i,
@@ -309,18 +316,25 @@ static int rscc_decode_frame(AVCodecContext *avctx, void *data,
     } else {
         frame->pict_type = AV_PICTURE_TYPE_P;
     }
+
+    /* Palette handling */
     if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
-        const uint8_t *pal = av_packet_get_side_data(avpkt,
-                                                     AV_PKT_DATA_PALETTE,
-                                                     NULL);
-        if (pal) {
+        int size;
+        const uint8_t *palette = av_packet_get_side_data(avpkt,
+                                                         AV_PKT_DATA_PALETTE,
+                                                         &size);
+        if (palette && size == AVPALETTE_SIZE) {
             frame->palette_has_changed = 1;
-            memcpy(ctx->pal, pal, AVPALETTE_SIZE);
+            memcpy(ctx->palette, palette, AVPALETTE_SIZE);
+        } else if (palette) {
+            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
         }
-        memcpy (frame->data[1], ctx->pal, AVPALETTE_SIZE);
+        memcpy (frame->data[1], ctx->palette, AVPALETTE_SIZE);
     }
+
     *got_frame = 1;
 
+    ret = avpkt->size;
 end:
     av_free(inflated_tiles);
     return ret;
diff --git a/mythtv/external/FFmpeg/libavcodec/rv10.c b/mythtv/external/FFmpeg/libavcodec/rv10.c
index 81aa9ae587f..595e2175190 100644
--- a/mythtv/external/FFmpeg/libavcodec/rv10.c
+++ b/mythtv/external/FFmpeg/libavcodec/rv10.c
@@ -670,7 +670,7 @@ static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
         }
         if (s->pict_type != AV_PICTURE_TYPE_B)
             ff_h263_update_motion_val(s);
-        ff_mpv_decode_mb(s, s->block);
+        ff_mpv_reconstruct_mb(s, s->block);
         if (s->loop_filter)
             ff_h263_loop_filter(s);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/rv34.c b/mythtv/external/FFmpeg/libavcodec/rv34.c
index aca8382f200..f1495fb5a8f 100644
--- a/mythtv/external/FFmpeg/libavcodec/rv34.c
+++ b/mythtv/external/FFmpeg/libavcodec/rv34.c
@@ -404,7 +404,8 @@ static int rv34_decode_inter_mb_header(RV34DecContext *r, int8_t *intra_types)
             r->mb_type[mb_pos] = RV34_MB_B_DIRECT;
     }
     r->is16 = !!IS_INTRA16x16(s->current_picture_ptr->mb_type[mb_pos]);
-    rv34_decode_mv(r, r->block_type);
+    if (rv34_decode_mv(r, r->block_type) < 0)
+        return -1;
     if(r->block_type == RV34_MB_SKIP){
         fill_rectangle(intra_types, 4, 4, r->intra_types_stride, 0, sizeof(intra_types[0]));
         return 0;
@@ -520,7 +521,7 @@ static int calc_add_mv(RV34DecContext *r, int dir, int val)
 {
     int mul = dir ? -r->mv_weight2 : r->mv_weight1;
 
-    return (val * mul + 0x2000) >> 14;
+    return (int)(val * (SUINT)mul + 0x2000) >> 14;
 }
 
 /**
@@ -866,6 +867,11 @@ static int rv34_decode_mv(RV34DecContext *r, int block_type)
     for(i = 0; i < num_mvs[block_type]; i++){
         r->dmv[i][0] = get_interleaved_se_golomb(gb);
         r->dmv[i][1] = get_interleaved_se_golomb(gb);
+        if (r->dmv[i][0] == INVALID_VLC ||
+            r->dmv[i][1] == INVALID_VLC) {
+            r->dmv[i][0] = r->dmv[i][1] = 0;
+            return AVERROR_INVALIDDATA;
+        }
     }
     switch(block_type){
     case RV34_MB_TYPE_INTRA:
@@ -1585,10 +1591,13 @@ int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecConte
     return ff_mpeg_update_thread_context(dst, src);
 }
 
-static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
+static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n, int slice_count, int buf_size)
 {
-    if(avctx->slice_count) return avctx->slice_offset[n];
-    else                   return AV_RL32(buf + n*8 - 4) == 1 ? AV_RL32(buf + n*8) :  AV_RB32(buf + n*8);
+    if (n < slice_count) {
+        if(avctx->slice_count) return avctx->slice_offset[n];
+        else                   return AV_RL32(buf + n*8 - 4) == 1 ? AV_RL32(buf + n*8) :  AV_RB32(buf + n*8);
+    } else
+        return buf_size;
 }
 
 static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
@@ -1627,7 +1636,7 @@ static AVRational update_sar(int old_w, int old_h, AVRational sar, int new_w, in
     if (!sar.num)
         sar = (AVRational){1, 1};
 
-    sar = av_mul_q(sar, (AVRational){new_h * old_w, new_w * old_h});
+    sar = av_mul_q(sar, av_mul_q((AVRational){new_h, new_w}, (AVRational){old_w, old_h}));
     return sar;
 }
 
@@ -1646,6 +1655,7 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
     const uint8_t *slices_hdr = NULL;
     int last = 0;
     int faulty_b = 0;
+    int offset;
 
     /* no supplementary picture */
     if (buf_size == 0) {
@@ -1668,13 +1678,13 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
     }else
         slice_count = avctx->slice_count;
 
+    offset = get_slice_offset(avctx, slices_hdr, 0, slice_count, buf_size);
     //parse first slice header to check whether this frame can be decoded
-    if(get_slice_offset(avctx, slices_hdr, 0) < 0 ||
-       get_slice_offset(avctx, slices_hdr, 0) > buf_size){
+    if(offset < 0 || offset > buf_size){
         av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
         return AVERROR_INVALIDDATA;
     }
-    init_get_bits(&s->gb, buf+get_slice_offset(avctx, slices_hdr, 0), (buf_size-get_slice_offset(avctx, slices_hdr, 0))*8);
+    init_get_bits(&s->gb, buf+offset, (buf_size-offset)*8);
     if(r->parse_slice_header(r, &r->s.gb, &si) < 0 || si.start){
         av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n");
         return AVERROR_INVALIDDATA;
@@ -1752,6 +1762,9 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
                 r->mv_weight1 = r->mv_weight2 = r->weight1 = r->weight2 = 8192;
                 r->scaled_weight = 0;
             }else{
+                if (FFMAX(dist0, dist1) > refdist)
+                    av_log(avctx, AV_LOG_TRACE, "distance overflow\n");
+
                 r->mv_weight1 = (dist0 << 14) / refdist;
                 r->mv_weight2 = (dist1 << 14) / refdist;
                 if((r->mv_weight1|r->mv_weight2) & 511){
@@ -1777,40 +1790,32 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
         return AVERROR_INVALIDDATA;
 
     for(i = 0; i < slice_count; i++){
-        int offset = get_slice_offset(avctx, slices_hdr, i);
+        int offset  = get_slice_offset(avctx, slices_hdr, i  , slice_count, buf_size);
+        int offset1 = get_slice_offset(avctx, slices_hdr, i+1, slice_count, buf_size);
         int size;
-        if(i+1 == slice_count)
-            size = buf_size - offset;
-        else
-            size = get_slice_offset(avctx, slices_hdr, i+1) - offset;
 
-        if(offset < 0 || offset > buf_size){
+        if(offset < 0 || offset > offset1 || offset1 > buf_size){
             av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
             break;
         }
+        size = offset1 - offset;
 
         r->si.end = s->mb_width * s->mb_height;
         s->mb_num_left = r->s.mb_x + r->s.mb_y*r->s.mb_width - r->si.start;
 
         if(i+1 < slice_count){
-            if (get_slice_offset(avctx, slices_hdr, i+1) < 0 ||
-                get_slice_offset(avctx, slices_hdr, i+1) > buf_size) {
+            int offset2 = get_slice_offset(avctx, slices_hdr, i+2, slice_count, buf_size);
+            if (offset2 < offset1 || offset2 > buf_size) {
                 av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
                 break;
             }
-            init_get_bits(&s->gb, buf+get_slice_offset(avctx, slices_hdr, i+1), (buf_size-get_slice_offset(avctx, slices_hdr, i+1))*8);
+            init_get_bits(&s->gb, buf+offset1, (buf_size-offset1)*8);
             if(r->parse_slice_header(r, &r->s.gb, &si) < 0){
-                if(i+2 < slice_count)
-                    size = get_slice_offset(avctx, slices_hdr, i+2) - offset;
-                else
-                    size = buf_size - offset;
+                size = offset2 - offset;
             }else
                 r->si.end = si.start;
         }
-        if (size < 0 || size > buf_size - offset) {
-            av_log(avctx, AV_LOG_ERROR, "Slice size is invalid\n");
-            break;
-        }
+        av_assert0 (size >= 0 && size <= buf_size - offset);
         last = rv34_decode_slice(r, r->si.end, buf + offset, size);
         if(last)
             break;
diff --git a/mythtv/external/FFmpeg/libavcodec/rv40.c b/mythtv/external/FFmpeg/libavcodec/rv40.c
index 465011a079c..dfeebda8381 100644
--- a/mythtv/external/FFmpeg/libavcodec/rv40.c
+++ b/mythtv/external/FFmpeg/libavcodec/rv40.c
@@ -109,6 +109,8 @@ static int get_dimension(GetBitContext *gb, const int *dim)
         val = dim[get_bits1(gb) - val];
     if(!val){
         do{
+            if (get_bits_left(gb) < 8)
+                return AVERROR_INVALIDDATA;
             t = get_bits(gb, 8);
             val += t << 2;
         }while(t == 0xFF);
@@ -187,7 +189,7 @@ static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t
             A = ptr[-r->intra_types_stride + 1]; // it won't be used for the last coefficient in a row
             B = ptr[-r->intra_types_stride];
             C = ptr[-1];
-            pattern = A + (B << 4) + (C << 8);
+            pattern = A + B * (1 << 4) + C * (1 << 8);
             for(k = 0; k < MODE2_PATTERNS_NUM; k++)
                 if(pattern == rv40_aic_table_index[k])
                     break;
diff --git a/mythtv/external/FFmpeg/libavcodec/rv40dsp.c b/mythtv/external/FFmpeg/libavcodec/rv40dsp.c
index 19b0e936963..5579bd9bedc 100644
--- a/mythtv/external/FFmpeg/libavcodec/rv40dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/rv40dsp.c
@@ -292,7 +292,10 @@ static const int rv40_bias[4][4] = {
 };
 
 #define RV40_CHROMA_MC(OPNAME, OP)\
-static void OPNAME ## rv40_chroma_mc4_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
+static void OPNAME ## rv40_chroma_mc4_c(uint8_t *dst /*align 8*/,\
+                                        uint8_t *src /*align 1*/,\
+                                        ptrdiff_t stride, int h, int x, int y)\
+{\
     const int A = (8-x) * (8-y);\
     const int B = (  x) * (8-y);\
     const int C = (8-x) * (  y);\
@@ -313,7 +316,7 @@ static void OPNAME ## rv40_chroma_mc4_c(uint8_t *dst/*align 8*/, uint8_t *src/*a
         }\
     }else{\
         const int E = B + C;\
-        const int step = C ? stride : 1;\
+        const ptrdiff_t step = C ? stride : 1;\
         for(i = 0; i < h; i++){\
             OP(dst[0], (A*src[0] + E*src[step+0] + bias));\
             OP(dst[1], (A*src[1] + E*src[step+1] + bias));\
@@ -325,7 +328,10 @@ static void OPNAME ## rv40_chroma_mc4_c(uint8_t *dst/*align 8*/, uint8_t *src/*a
     }\
 }\
 \
-static void OPNAME ## rv40_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
+static void OPNAME ## rv40_chroma_mc8_c(uint8_t *dst/*align 8*/,\
+                                        uint8_t *src/*align 1*/,\
+                                        ptrdiff_t stride, int h, int x, int y)\
+{\
     const int A = (8-x) * (8-y);\
     const int B = (  x) * (8-y);\
     const int C = (8-x) * (  y);\
@@ -350,7 +356,7 @@ static void OPNAME ## rv40_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*a
         }\
     }else{\
         const int E = B + C;\
-        const int step = C ? stride : 1;\
+        const ptrdiff_t step = C ? stride : 1;\
         for(i = 0; i < h; i++){\
             OP(dst[0], (A*src[0] + E*src[step+0] + bias));\
             OP(dst[1], (A*src[1] + E*src[step+1] + bias));\
@@ -449,7 +455,7 @@ static av_always_inline void rv40_weak_loop_filter(uint8_t *src,
         if (u > 3 - (filter_p1 && filter_q1))
             continue;
 
-        t <<= 2;
+        t *= 1 << 2;
         if (filter_p1 && filter_q1)
             t += src[-2*step] - src[1*step];
 
diff --git a/mythtv/external/FFmpeg/libavcodec/s302m.c b/mythtv/external/FFmpeg/libavcodec/s302m.c
index ccfb5913a00..4350d97f0a4 100644
--- a/mythtv/external/FFmpeg/libavcodec/s302m.c
+++ b/mythtv/external/FFmpeg/libavcodec/s302m.c
@@ -120,10 +120,10 @@ static int s302m_decode_frame(AVCodecContext *avctx, void *data,
     if (avctx->bits_per_raw_sample == 24) {
         uint32_t *o = (uint32_t *)frame->data[0];
         for (; buf_size > 6; buf_size -= 7) {
-            *o++ = (ff_reverse[buf[2]]        << 24) |
+            *o++ = ((unsigned)ff_reverse[buf[2]]        << 24) |
                    (ff_reverse[buf[1]]        << 16) |
                    (ff_reverse[buf[0]]        <<  8);
-            *o++ = (ff_reverse[buf[6] & 0xf0] << 28) |
+            *o++ = ((unsigned)ff_reverse[buf[6] & 0xf0] << 28) |
                    (ff_reverse[buf[5]]        << 20) |
                    (ff_reverse[buf[4]]        << 12) |
                    (ff_reverse[buf[3] & 0x0f] <<  4);
@@ -142,10 +142,10 @@ static int s302m_decode_frame(AVCodecContext *avctx, void *data,
     } else if (avctx->bits_per_raw_sample == 20) {
         uint32_t *o = (uint32_t *)frame->data[0];
         for (; buf_size > 5; buf_size -= 6) {
-            *o++ = (ff_reverse[buf[2] & 0xf0] << 28) |
+            *o++ = ((unsigned)ff_reverse[buf[2] & 0xf0] << 28) |
                    (ff_reverse[buf[1]]        << 20) |
                    (ff_reverse[buf[0]]        << 12);
-            *o++ = (ff_reverse[buf[5] & 0xf0] << 28) |
+            *o++ = ((unsigned)ff_reverse[buf[5] & 0xf0] << 28) |
                    (ff_reverse[buf[4]]        << 20) |
                    (ff_reverse[buf[3]]        << 12);
             buf += 6;
@@ -201,7 +201,7 @@ static int s302m_decode_frame(AVCodecContext *avctx, void *data,
     return avpkt->size;
 }
 
-#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_DECODING_PARAM
+#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_DECODING_PARAM
 static const AVOption s302m_options[] = {
     {"non_pcm_mode", "Chooses what to do with NON-PCM", offsetof(S302Context, non_pcm_mode), AV_OPT_TYPE_INT, {.i64 = 3}, 0, 3, FLAGS, "non_pcm_mode"},
     {"copy"        , "Pass NON-PCM through unchanged"     , 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 3, FLAGS, "non_pcm_mode"},
diff --git a/mythtv/external/FFmpeg/libavcodec/samidec.c b/mythtv/external/FFmpeg/libavcodec/samidec.c
index 16f3f58c1cf..26204247508 100644
--- a/mythtv/external/FFmpeg/libavcodec/samidec.c
+++ b/mythtv/external/FFmpeg/libavcodec/samidec.c
@@ -113,10 +113,14 @@ static int sami_paragraph_to_ass(AVCodecContext *avctx, const char *src)
 
     av_bprint_clear(&sami->full);
     if (sami->source.len) {
-        ff_htmlmarkup_to_ass(avctx, dst_source, sami->source.str);
+        ret = ff_htmlmarkup_to_ass(avctx, dst_source, sami->source.str);
+        if (ret < 0)
+            goto end;
         av_bprintf(&sami->full, "{\\i1}%s{\\i0}\\N", sami->encoded_source.str);
     }
-    ff_htmlmarkup_to_ass(avctx, dst_content, sami->content.str);
+    ret = ff_htmlmarkup_to_ass(avctx, dst_content, sami->content.str);
+    if (ret < 0)
+        goto end;
     av_bprintf(&sami->full, "%s", sami->encoded_content.str);
 
 end:
diff --git a/mythtv/external/FFmpeg/libavcodec/sanm.c b/mythtv/external/FFmpeg/libavcodec/sanm.c
index 1aa002b6a5c..811fd2188e2 100644
--- a/mythtv/external/FFmpeg/libavcodec/sanm.c
+++ b/mythtv/external/FFmpeg/libavcodec/sanm.c
@@ -268,7 +268,7 @@ typedef struct SANMVideoContext {
     uint32_t pal[PALETTE_SIZE];
     int16_t delta_pal[PALETTE_DELTA];
 
-    int pitch;
+    ptrdiff_t pitch;
     int width, height;
     int aligned_width, aligned_height;
     int prev_seq;
@@ -462,11 +462,11 @@ static void destroy_buffers(SANMVideoContext *ctx)
 
 static av_cold int init_buffers(SANMVideoContext *ctx)
 {
-    av_fast_padded_malloc(&ctx->frm0, &ctx->frm0_size, ctx->buf_size);
-    av_fast_padded_malloc(&ctx->frm1, &ctx->frm1_size, ctx->buf_size);
-    av_fast_padded_malloc(&ctx->frm2, &ctx->frm2_size, ctx->buf_size);
+    av_fast_padded_mallocz(&ctx->frm0, &ctx->frm0_size, ctx->buf_size);
+    av_fast_padded_mallocz(&ctx->frm1, &ctx->frm1_size, ctx->buf_size);
+    av_fast_padded_mallocz(&ctx->frm2, &ctx->frm2_size, ctx->buf_size);
     if (!ctx->version)
-        av_fast_padded_malloc(&ctx->stored_frame,
+        av_fast_padded_mallocz(&ctx->stored_frame,
                               &ctx->stored_frame_size, ctx->buf_size);
 
     if (!ctx->frm0 || !ctx->frm1 || !ctx->frm2 ||
@@ -623,7 +623,7 @@ static inline void codec37_mv(uint8_t *dst, const uint8_t *src,
 static int old_codec37(SANMVideoContext *ctx, int top,
                        int left, int width, int height)
 {
-    int stride = ctx->pitch;
+    ptrdiff_t stride = ctx->pitch;
     int i, j, k, t;
     uint8_t *dst, *prev;
     int skip_run = 0;
@@ -861,7 +861,7 @@ static int old_codec47(SANMVideoContext *ctx, int top,
 {
     uint32_t decoded_size;
     int i, j;
-    int stride     = ctx->pitch;
+    ptrdiff_t stride = ctx->pitch;
     uint8_t *dst   = (uint8_t *)ctx->frm0 + left + top * stride;
     uint8_t *prev1 = (uint8_t *)ctx->frm1;
     uint8_t *prev2 = (uint8_t *)ctx->frm2;
@@ -978,13 +978,10 @@ static int process_frame_obj(SANMVideoContext *ctx)
     case 1:
     case 3:
         return old_codec1(ctx, top, left, w, h);
-        break;
     case 37:
         return old_codec37(ctx, top, left, w, h);
-        break;
     case 47:
         return old_codec47(ctx, top, left, w, h);
-        break;
     default:
         avpriv_request_sample(ctx->avctx, "Subcodec %d", codec);
         return AVERROR_PATCHWELCOME;
@@ -1014,11 +1011,11 @@ static int decode_nop(SANMVideoContext *ctx)
     return AVERROR_PATCHWELCOME;
 }
 
-static void copy_block(uint16_t *pdest, uint16_t *psrc, int block_size, int pitch)
+static void copy_block(uint16_t *pdest, uint16_t *psrc, int block_size, ptrdiff_t pitch)
 {
     uint8_t *dst = (uint8_t *)pdest;
     uint8_t *src = (uint8_t *)psrc;
-    int stride = pitch * 2;
+    ptrdiff_t stride = pitch * 2;
 
     switch (block_size) {
     case 2:
@@ -1033,7 +1030,7 @@ static void copy_block(uint16_t *pdest, uint16_t *psrc, int block_size, int pitc
     }
 }
 
-static void fill_block(uint16_t *pdest, uint16_t color, int block_size, int pitch)
+static void fill_block(uint16_t *pdest, uint16_t color, int block_size, ptrdiff_t pitch)
 {
     int x, y;
 
@@ -1045,7 +1042,7 @@ static void fill_block(uint16_t *pdest, uint16_t color, int block_size, int pitc
 
 static int draw_glyph(SANMVideoContext *ctx, uint16_t *dst, int index,
                       uint16_t fg_color, uint16_t bg_color, int block_size,
-                      int pitch)
+                      ptrdiff_t pitch)
 {
     int8_t *pglyph;
     uint16_t colors[2] = { fg_color, bg_color };
@@ -1065,7 +1062,7 @@ static int draw_glyph(SANMVideoContext *ctx, uint16_t *dst, int index,
     return 0;
 }
 
-static int opcode_0xf7(SANMVideoContext *ctx, int cx, int cy, int block_size, int pitch)
+static int opcode_0xf7(SANMVideoContext *ctx, int cx, int cy, int block_size, ptrdiff_t pitch)
 {
     uint16_t *dst = ctx->frm0 + cx + cy * ctx->pitch;
 
@@ -1099,7 +1096,7 @@ static int opcode_0xf7(SANMVideoContext *ctx, int cx, int cy, int block_size, in
     return 0;
 }
 
-static int opcode_0xf8(SANMVideoContext *ctx, int cx, int cy, int block_size, int pitch)
+static int opcode_0xf8(SANMVideoContext *ctx, int cx, int cy, int block_size, ptrdiff_t pitch)
 {
     uint16_t *dst = ctx->frm0 + cx + cy * ctx->pitch;
 
@@ -1369,8 +1366,8 @@ static int copy_output(SANMVideoContext *ctx, SANMFrameHeader *hdr)
 {
     uint8_t *dst;
     const uint8_t *src = (uint8_t*) ctx->frm0;
-    int ret, dstpitch, height = ctx->height;
-    int srcpitch = ctx->pitch * (hdr ? sizeof(ctx->frm0[0]) : 1);
+    int ret, height = ctx->height;
+    ptrdiff_t dstpitch, srcpitch = ctx->pitch * (hdr ? sizeof(ctx->frm0[0]) : 1);
 
     if ((ret = ff_get_buffer(ctx->avctx, ctx->frame, 0)) < 0)
         return ret;
diff --git a/mythtv/external/FFmpeg/libavcodec/sbrdsp.c b/mythtv/external/FFmpeg/libavcodec/sbrdsp.c
index cc432b6534c..a93b5f9c134 100644
--- a/mythtv/external/FFmpeg/libavcodec/sbrdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/sbrdsp.c
@@ -153,8 +153,8 @@ static void sbr_autocorrelate_c(const float x[40][2], float phi[3][2][2])
     phi[2 - 1][1][1] = imag_sum1 + x[ 0][0] * x[ 1][1] - x[ 0][1] * x[ 1][0];
     phi[0    ][0][0] = real_sum1 + x[38][0] * x[39][0] + x[38][1] * x[39][1];
     phi[0    ][0][1] = imag_sum1 + x[38][0] * x[39][1] - x[38][1] * x[39][0];
-#endif
 }
+#endif
 
 static void sbr_hf_gen_c(float (*X_high)[2], const float (*X_low)[2],
                          const float alpha0[2], const float alpha1[2],
diff --git a/mythtv/external/FFmpeg/libavcodec/sbrdsp.h b/mythtv/external/FFmpeg/libavcodec/sbrdsp.h
index 66852de6182..e6fd76d8ed8 100644
--- a/mythtv/external/FFmpeg/libavcodec/sbrdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/sbrdsp.h
@@ -48,6 +48,7 @@ extern const INTFLOAT AAC_RENAME(ff_sbr_noise_table)[][2];
 
 void AAC_RENAME(ff_sbrdsp_init)(SBRDSPContext *s);
 void ff_sbrdsp_init_arm(SBRDSPContext *s);
+void ff_sbrdsp_init_aarch64(SBRDSPContext *s);
 void ff_sbrdsp_init_x86(SBRDSPContext *s);
 void ff_sbrdsp_init_mips(SBRDSPContext *s);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/sbrdsp_fixed.c b/mythtv/external/FFmpeg/libavcodec/sbrdsp_fixed.c
index f4e3de0c710..57d98da9799 100644
--- a/mythtv/external/FFmpeg/libavcodec/sbrdsp_fixed.c
+++ b/mythtv/external/FFmpeg/libavcodec/sbrdsp_fixed.c
@@ -34,37 +34,47 @@
 static SoftFloat sbr_sum_square_c(int (*x)[2], int n)
 {
     SoftFloat ret;
-    int64_t accu = 0;
-    int i, nz, round;
+    uint64_t accu, round;
+    uint64_t accu0 = 0, accu1 = 0, accu2 = 0, accu3 = 0;
+    int i, nz, nz0;
+    unsigned u;
 
     for (i = 0; i < n; i += 2) {
         // Larger values are inavlid and could cause overflows of accu.
-        av_assert2(FFABS(x[i + 0][0]) >> 29 == 0);
-        accu += (int64_t)x[i + 0][0] * x[i + 0][0];
-        av_assert2(FFABS(x[i + 0][1]) >> 29 == 0);
-        accu += (int64_t)x[i + 0][1] * x[i + 0][1];
-        av_assert2(FFABS(x[i + 1][0]) >> 29 == 0);
-        accu += (int64_t)x[i + 1][0] * x[i + 1][0];
-        av_assert2(FFABS(x[i + 1][1]) >> 29 == 0);
-        accu += (int64_t)x[i + 1][1] * x[i + 1][1];
+        av_assert2(FFABS(x[i + 0][0]) >> 30 == 0);
+        accu0 += (int64_t)x[i + 0][0] * x[i + 0][0];
+        av_assert2(FFABS(x[i + 0][1]) >> 30 == 0);
+        accu1 += (int64_t)x[i + 0][1] * x[i + 0][1];
+        av_assert2(FFABS(x[i + 1][0]) >> 30 == 0);
+        accu2 += (int64_t)x[i + 1][0] * x[i + 1][0];
+        av_assert2(FFABS(x[i + 1][1]) >> 30 == 0);
+        accu3 += (int64_t)x[i + 1][1] * x[i + 1][1];
     }
 
-    i = (int)(accu >> 32);
-    if (i == 0) {
-        nz = 1;
-    } else {
-        nz = 0;
-        while (FFABS(i) < 0x40000000) {
-            i <<= 1;
-            nz++;
-        }
-        nz = 32 - nz;
+    nz0 = 15;
+    while ((accu0|accu1|accu2|accu3) >> 62) {
+        accu0 >>= 1;
+        accu1 >>= 1;
+        accu2 >>= 1;
+        accu3 >>= 1;
+        nz0 --;
     }
+    accu = accu0 + accu1 + accu2 + accu3;
+
+    u = accu >> 32;
+    if (u) {
+        nz = 33;
+        while (u < 0x80000000U) {
+            u <<= 1;
+            nz--;
+        }
+    } else
+        nz = 1;
 
-    round = 1 << (nz-1);
-    i = (int)((accu + round) >> nz);
-    i >>= 1;
-    ret = av_int2sf(i, 15 - nz);
+    round = 1ULL << (nz-1);
+    u = ((accu + round) >> nz);
+    u >>= 1;
+    ret = av_int2sf(u, nz0 - nz);
 
     return ret;
 }
@@ -107,23 +117,24 @@ static void sbr_qmf_deint_neg_c(int *v, const int *src)
 
 static av_always_inline SoftFloat autocorr_calc(int64_t accu)
 {
-        int nz, mant, expo, round;
+        int nz, mant, expo;
+        unsigned round;
         int i = (int)(accu >> 32);
         if (i == 0) {
             nz = 1;
         } else {
             nz = 0;
             while (FFABS(i) < 0x40000000) {
-                i <<= 1;
+                i *= 2;
                 nz++;
             }
             nz = 32-nz;
         }
 
-        round = 1 << (nz-1);
+        round = 1U << (nz-1);
         mant = (int)((accu + round) >> nz);
-        mant = (mant + 0x40)>>7;
-        mant <<= 6;
+        mant = (mant + 0x40LL)>>7;
+        mant *= 64;
         expo = nz + 15;
         return av_int2sf(mant, 30 - expo);
 }
@@ -136,19 +147,19 @@ static av_always_inline void autocorrelate(const int x[40][2], SoftFloat phi[3][
 
     if (lag) {
         for (i = 1; i < 38; i++) {
-            accu_re += (int64_t)x[i][0] * x[i+lag][0];
-            accu_re += (int64_t)x[i][1] * x[i+lag][1];
-            accu_im += (int64_t)x[i][0] * x[i+lag][1];
-            accu_im -= (int64_t)x[i][1] * x[i+lag][0];
+            accu_re += (uint64_t)x[i][0] * x[i+lag][0];
+            accu_re += (uint64_t)x[i][1] * x[i+lag][1];
+            accu_im += (uint64_t)x[i][0] * x[i+lag][1];
+            accu_im -= (uint64_t)x[i][1] * x[i+lag][0];
         }
 
         real_sum = accu_re;
         imag_sum = accu_im;
 
-        accu_re += (int64_t)x[ 0][0] * x[lag][0];
-        accu_re += (int64_t)x[ 0][1] * x[lag][1];
-        accu_im += (int64_t)x[ 0][0] * x[lag][1];
-        accu_im -= (int64_t)x[ 0][1] * x[lag][0];
+        accu_re += (uint64_t)x[ 0][0] * x[lag][0];
+        accu_re += (uint64_t)x[ 0][1] * x[lag][1];
+        accu_im += (uint64_t)x[ 0][0] * x[lag][1];
+        accu_im -= (uint64_t)x[ 0][1] * x[lag][0];
 
         phi[2-lag][1][0] = autocorr_calc(accu_re);
         phi[2-lag][1][1] = autocorr_calc(accu_im);
@@ -156,28 +167,28 @@ static av_always_inline void autocorrelate(const int x[40][2], SoftFloat phi[3][
         if (lag == 1) {
             accu_re = real_sum;
             accu_im = imag_sum;
-            accu_re += (int64_t)x[38][0] * x[39][0];
-            accu_re += (int64_t)x[38][1] * x[39][1];
-            accu_im += (int64_t)x[38][0] * x[39][1];
-            accu_im -= (int64_t)x[38][1] * x[39][0];
+            accu_re += (uint64_t)x[38][0] * x[39][0];
+            accu_re += (uint64_t)x[38][1] * x[39][1];
+            accu_im += (uint64_t)x[38][0] * x[39][1];
+            accu_im -= (uint64_t)x[38][1] * x[39][0];
 
             phi[0][0][0] = autocorr_calc(accu_re);
             phi[0][0][1] = autocorr_calc(accu_im);
         }
     } else {
         for (i = 1; i < 38; i++) {
-            accu_re += (int64_t)x[i][0] * x[i][0];
-            accu_re += (int64_t)x[i][1] * x[i][1];
+            accu_re += (uint64_t)x[i][0] * x[i][0];
+            accu_re += (uint64_t)x[i][1] * x[i][1];
         }
         real_sum = accu_re;
-        accu_re += (int64_t)x[ 0][0] * x[ 0][0];
-        accu_re += (int64_t)x[ 0][1] * x[ 0][1];
+        accu_re += (uint64_t)x[ 0][0] * x[ 0][0];
+        accu_re += (uint64_t)x[ 0][1] * x[ 0][1];
 
         phi[2][1][0] = autocorr_calc(accu_re);
 
         accu_re = real_sum;
-        accu_re += (int64_t)x[38][0] * x[38][0];
-        accu_re += (int64_t)x[38][1] * x[38][1];
+        accu_re += (uint64_t)x[38][0] * x[38][0];
+        accu_re += (uint64_t)x[38][1] * x[38][1];
 
         phi[1][0][0] = autocorr_calc(accu_re);
     }
@@ -229,20 +240,22 @@ static void sbr_hf_gen_c(int (*X_high)[2], const int (*X_low)[2],
 static void sbr_hf_g_filt_c(int (*Y)[2], const int (*X_high)[40][2],
                           const SoftFloat *g_filt, int m_max, intptr_t ixh)
 {
-    int m, r;
+    int m;
     int64_t accu;
 
     for (m = 0; m < m_max; m++) {
-        r = 1 << (22-g_filt[m].exp);
-        accu = (int64_t)X_high[m][ixh][0] * ((g_filt[m].mant + 0x40)>>7);
-        Y[m][0] = (int)((accu + r) >> (23-g_filt[m].exp));
+        if (22 - g_filt[m].exp < 61) {
+            int64_t r = 1LL << (22-g_filt[m].exp);
+            accu = (int64_t)X_high[m][ixh][0] * ((g_filt[m].mant + 0x40)>>7);
+            Y[m][0] = (int)((accu + r) >> (23-g_filt[m].exp));
 
-        accu = (int64_t)X_high[m][ixh][1] * ((g_filt[m].mant + 0x40)>>7);
-        Y[m][1] = (int)((accu + r) >> (23-g_filt[m].exp));
+            accu = (int64_t)X_high[m][ixh][1] * ((g_filt[m].mant + 0x40)>>7);
+            Y[m][1] = (int)((accu + r) >> (23-g_filt[m].exp));
+        }
     }
 }
 
-static av_always_inline void sbr_hf_apply_noise(int (*Y)[2],
+static av_always_inline int sbr_hf_apply_noise(int (*Y)[2],
                                                 const SoftFloat *s_m,
                                                 const SoftFloat *q_filt,
                                                 int noise,
@@ -253,14 +266,17 @@ static av_always_inline void sbr_hf_apply_noise(int (*Y)[2],
     int m;
 
     for (m = 0; m < m_max; m++) {
-        int y0 = Y[m][0];
-        int y1 = Y[m][1];
+        unsigned y0 = Y[m][0];
+        unsigned y1 = Y[m][1];
         noise = (noise + 1) & 0x1ff;
         if (s_m[m].mant) {
             int shift, round;
 
             shift = 22 - s_m[m].exp;
-            if (shift < 30) {
+            if (shift < 1) {
+                av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_apply_noise, shift=%d\n", shift);
+                return AVERROR(ERANGE);
+            } else if (shift < 30) {
                 round = 1 << (shift-1);
                 y0 += (s_m[m].mant * phi_sign0 + round) >> shift;
                 y1 += (s_m[m].mant * phi_sign1 + round) >> shift;
@@ -270,7 +286,10 @@ static av_always_inline void sbr_hf_apply_noise(int (*Y)[2],
             int64_t accu;
 
             shift = 22 - q_filt[m].exp;
-            if (shift < 30) {
+            if (shift < 1) {
+                av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_apply_noise, shift=%d\n", shift);
+                return AVERROR(ERANGE);
+            } else if (shift < 30) {
                 round = 1 << (shift-1);
 
                 accu = (int64_t)q_filt[m].mant * ff_sbr_noise_table_fixed[noise][0];
@@ -286,6 +305,7 @@ static av_always_inline void sbr_hf_apply_noise(int (*Y)[2],
         Y[m][1] = y1;
         phi_sign1 = -phi_sign1;
     }
+    return 0;
 }
 
 #include "sbrdsp_template.c"
diff --git a/mythtv/external/FFmpeg/libavcodec/sbrdsp_template.c b/mythtv/external/FFmpeg/libavcodec/sbrdsp_template.c
index b649dfd7ee7..37a3365b973 100644
--- a/mythtv/external/FFmpeg/libavcodec/sbrdsp_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/sbrdsp_template.c
@@ -33,8 +33,13 @@ static void sbr_qmf_deint_bfly_c(INTFLOAT *v, const INTFLOAT *src0, const INTFLO
 {
     int i;
     for (i = 0; i < 64; i++) {
-        v[      i] = AAC_SRA_R((src0[i] - src1[63 - i]), 5);
-        v[127 - i] = AAC_SRA_R((src0[i] + src1[63 - i]), 5);
+#if USE_FIXED
+        v[      i] = (int)(0x10U + src0[i] - src1[63 - i]) >> 5;
+        v[127 - i] = (int)(0x10U + src0[i] + src1[63 - i]) >> 5;
+#else
+        v[      i] = src0[i] - src1[63 - i];
+        v[127 - i] = src0[i] + src1[63 - i];
+#endif
     }
 }
 
@@ -89,6 +94,8 @@ av_cold void AAC_RENAME(ff_sbrdsp_init)(SBRDSPContext *s)
 #if !USE_FIXED
     if (ARCH_ARM)
         ff_sbrdsp_init_arm(s);
+    if (ARCH_AARCH64)
+        ff_sbrdsp_init_aarch64(s);
     if (ARCH_X86)
         ff_sbrdsp_init_x86(s);
     if (ARCH_MIPS)
diff --git a/mythtv/external/FFmpeg/libavcodec/scpr.c b/mythtv/external/FFmpeg/libavcodec/scpr.c
new file mode 100644
index 00000000000..cbe1bc40d9c
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/scpr.c
@@ -0,0 +1,916 @@
+/*
+ * ScreenPressor decoder
+ *
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "avcodec.h"
+#include "bytestream.h"
+#include "internal.h"
+
+#define TOP  0x01000000
+#define BOT    0x010000
+
+typedef struct RangeCoder {
+    unsigned   code;
+    unsigned   range;
+    unsigned   code1;
+} RangeCoder;
+
+typedef struct PixelModel {
+    unsigned    freq[256];
+    unsigned    lookup[16];
+    unsigned    total_freq;
+} PixelModel;
+
+typedef struct SCPRContext {
+    AVFrame        *last_frame;
+    AVFrame        *current_frame;
+    GetByteContext  gb;
+    RangeCoder      rc;
+    PixelModel      pixel_model[3][4096];
+    unsigned        op_model[6][7];
+    unsigned        run_model[6][257];
+    unsigned        range_model[257];
+    unsigned        count_model[257];
+    unsigned        fill_model[6];
+    unsigned        sxy_model[4][17];
+    unsigned        mv_model[2][513];
+    unsigned        nbx, nby;
+    unsigned        nbcount;
+    unsigned       *blocks;
+    unsigned        cbits;
+    int             cxshift;
+
+    int           (*get_freq)(RangeCoder *rc, unsigned total_freq, unsigned *freq);
+    int           (*decode)(GetByteContext *gb, RangeCoder *rc, unsigned cumFreq, unsigned freq, unsigned total_freq);
+} SCPRContext;
+
+static void init_rangecoder(RangeCoder *rc, GetByteContext *gb)
+{
+    rc->code1 = 0;
+    rc->range = 0xFFFFFFFFU;
+    rc->code  = bytestream2_get_be32(gb);
+}
+
+static void reinit_tables(SCPRContext *s)
+{
+    int comp, i, j;
+
+    for (comp = 0; comp < 3; comp++) {
+        for (j = 0; j < 4096; j++) {
+            if (s->pixel_model[comp][j].total_freq != 256) {
+                for (i = 0; i < 256; i++)
+                    s->pixel_model[comp][j].freq[i] = 1;
+                for (i = 0; i < 16; i++)
+                    s->pixel_model[comp][j].lookup[i] = 16;
+                s->pixel_model[comp][j].total_freq = 256;
+            }
+        }
+    }
+
+    for (j = 0; j < 6; j++) {
+        unsigned *p = s->run_model[j];
+        for (i = 0; i < 256; i++)
+            p[i] = 1;
+        p[256] = 256;
+    }
+
+    for (j = 0; j < 6; j++) {
+        unsigned *op = s->op_model[j];
+        for (i = 0; i < 6; i++)
+            op[i] = 1;
+        op[6] = 6;
+    }
+
+    for (i = 0; i < 256; i++) {
+        s->range_model[i] = 1;
+        s->count_model[i] = 1;
+    }
+    s->range_model[256] = 256;
+    s->count_model[256] = 256;
+
+    for (i = 0; i < 5; i++) {
+        s->fill_model[i] = 1;
+    }
+    s->fill_model[5] = 5;
+
+    for (j = 0; j < 4; j++) {
+        for (i = 0; i < 16; i++) {
+            s->sxy_model[j][i] = 1;
+        }
+        s->sxy_model[j][16] = 16;
+    }
+
+    for (i = 0; i < 512; i++) {
+        s->mv_model[0][i] = 1;
+        s->mv_model[1][i] = 1;
+    }
+    s->mv_model[0][512] = 512;
+    s->mv_model[1][512] = 512;
+}
+
+static int decode(GetByteContext *gb, RangeCoder *rc, unsigned cumFreq, unsigned freq, unsigned total_freq)
+{
+    rc->code -= cumFreq * rc->range;
+    rc->range *= freq;
+
+    while (rc->range < TOP && bytestream2_get_bytes_left(gb) > 0) {
+        unsigned byte = bytestream2_get_byte(gb);
+        rc->code = (rc->code << 8) | byte;
+        rc->range <<= 8;
+    }
+
+    return 0;
+}
+
+static int get_freq(RangeCoder *rc, unsigned total_freq, unsigned *freq)
+{
+    if (total_freq == 0)
+        return AVERROR_INVALIDDATA;
+
+    rc->range = rc->range / total_freq;
+
+    if (rc->range == 0)
+        return AVERROR_INVALIDDATA;
+
+    *freq = rc->code / rc->range;
+
+    return 0;
+}
+
+static int decode0(GetByteContext *gb, RangeCoder *rc, unsigned cumFreq, unsigned freq, unsigned total_freq)
+{
+    unsigned t;
+
+    if (total_freq == 0)
+        return AVERROR_INVALIDDATA;
+
+    t = rc->range * (uint64_t)cumFreq / total_freq;
+
+    rc->code1 += t + 1;
+    rc->range = rc->range * (uint64_t)(freq + cumFreq) / total_freq - (t + 1);
+
+    while (rc->range < TOP && bytestream2_get_bytes_left(gb) > 0) {
+        unsigned byte = bytestream2_get_byte(gb);
+        rc->code = (rc->code << 8) | byte;
+        rc->code1 <<= 8;
+        rc->range <<= 8;
+    }
+
+    return 0;
+}
+
+static int get_freq0(RangeCoder *rc, unsigned total_freq, unsigned *freq)
+{
+    if (rc->range == 0)
+        return AVERROR_INVALIDDATA;
+
+    *freq = total_freq * (uint64_t)(rc->code - rc->code1) / rc->range;
+
+    return 0;
+}
+
+static int decode_value(SCPRContext *s, unsigned *cnt, unsigned maxc, unsigned step, unsigned *rval)
+{
+    GetByteContext *gb = &s->gb;
+    RangeCoder *rc = &s->rc;
+    unsigned totfr = cnt[maxc];
+    unsigned value;
+    unsigned c = 0, cumfr = 0, cnt_c = 0;
+    int i, ret;
+
+    if ((ret = s->get_freq(rc, totfr, &value)) < 0)
+        return ret;
+
+    while (c < maxc) {
+        cnt_c = cnt[c];
+        if (value >= cumfr + cnt_c)
+            cumfr += cnt_c;
+        else
+            break;
+        c++;
+    }
+    if ((ret = s->decode(gb, rc, cumfr, cnt_c, totfr)) < 0)
+        return ret;
+
+    cnt[c] = cnt_c + step;
+    totfr += step;
+    if (totfr > BOT) {
+        totfr = 0;
+        for (i = 0; i < maxc; i++) {
+            unsigned nc = (cnt[i] >> 1) + 1;
+            cnt[i] = nc;
+            totfr += nc;
+        }
+    }
+
+    cnt[maxc] = totfr;
+    *rval = c;
+
+    return 0;
+}
+
+static int decode_unit(SCPRContext *s, PixelModel *pixel, unsigned step, unsigned *rval)
+{
+    GetByteContext *gb = &s->gb;
+    RangeCoder *rc = &s->rc;
+    unsigned totfr = pixel->total_freq;
+    unsigned value, x = 0, cumfr = 0, cnt_x = 0;
+    int i, j, ret, c, cnt_c;
+
+    if ((ret = s->get_freq(rc, totfr, &value)) < 0)
+        return ret;
+
+    while (x < 16) {
+        cnt_x = pixel->lookup[x];
+        if (value >= cumfr + cnt_x)
+            cumfr += cnt_x;
+        else
+            break;
+        x++;
+    }
+
+    c = x * 16;
+    cnt_c = 0;
+    while (c < 256) {
+        cnt_c = pixel->freq[c];
+        if (value >= cumfr + cnt_c)
+            cumfr += cnt_c;
+        else
+            break;
+        c++;
+    }
+    if (x >= 16 || c >= 256) {
+        return AVERROR_INVALIDDATA;
+    }
+
+    if ((ret = s->decode(gb, rc, cumfr, cnt_c, totfr)) < 0)
+        return ret;
+
+    pixel->freq[c] = cnt_c + step;
+    pixel->lookup[x] = cnt_x + step;
+    totfr += step;
+    if (totfr > BOT) {
+        totfr = 0;
+        for (i = 0; i < 256; i++) {
+            unsigned nc = (pixel->freq[i] >> 1) + 1;
+            pixel->freq[i] = nc;
+            totfr += nc;
+        }
+        for (i = 0; i < 16; i++) {
+            unsigned sum = 0;
+            unsigned i16_17 = i << 4;
+            for (j = 0; j < 16; j++)
+                sum += pixel->freq[i16_17 + j];
+            pixel->lookup[i] = sum;
+        }
+    }
+    pixel->total_freq = totfr;
+
+    *rval = c & s->cbits;
+
+    return 0;
+}
+
+static int decompress_i(AVCodecContext *avctx, uint32_t *dst, int linesize)
+{
+    SCPRContext *s = avctx->priv_data;
+    GetByteContext *gb = &s->gb;
+    int cx = 0, cx1 = 0, k = 0, clr = 0;
+    int run, r, g, b, off, y = 0, x = 0, z, ret;
+    unsigned backstep = linesize - avctx->width;
+    const int cxshift = s->cxshift;
+    unsigned lx, ly, ptype;
+
+    reinit_tables(s);
+    bytestream2_skip(gb, 2);
+    init_rangecoder(&s->rc, gb);
+
+    while (k < avctx->width + 1) {
+        ret = decode_unit(s, &s->pixel_model[0][cx + cx1], 400, &r);
+        if (ret < 0)
+            return ret;
+
+        cx1 = (cx << 6) & 0xFC0;
+        cx = r >> cxshift;
+        ret = decode_unit(s, &s->pixel_model[1][cx + cx1], 400, &g);
+        if (ret < 0)
+            return ret;
+
+        cx1 = (cx << 6) & 0xFC0;
+        cx = g >> cxshift;
+        ret = decode_unit(s, &s->pixel_model[2][cx + cx1], 400, &b);
+        if (ret < 0)
+            return ret;
+
+        cx1 = (cx << 6) & 0xFC0;
+        cx = b >> cxshift;
+
+        ret = decode_value(s, s->run_model[0], 256, 400, &run);
+        if (ret < 0)
+            return ret;
+
+        clr = (b << 16) + (g << 8) + r;
+        k += run;
+        while (run-- > 0) {
+            if (y >= avctx->height)
+                return AVERROR_INVALIDDATA;
+
+            dst[y * linesize + x] = clr;
+            lx = x;
+            ly = y;
+            x++;
+            if (x >= avctx->width) {
+                x = 0;
+                y++;
+            }
+        }
+    }
+    off = -linesize - 1;
+    ptype = 0;
+
+    while (x < avctx->width && y < avctx->height) {
+        ret = decode_value(s, s->op_model[ptype], 6, 1000, &ptype);
+        if (ret < 0)
+            return ret;
+        if (ptype == 0) {
+            ret = decode_unit(s, &s->pixel_model[0][cx + cx1], 400, &r);
+            if (ret < 0)
+                return ret;
+
+            cx1 = (cx << 6) & 0xFC0;
+            cx = r >> cxshift;
+            ret = decode_unit(s, &s->pixel_model[1][cx + cx1], 400, &g);
+            if (ret < 0)
+                return ret;
+
+            cx1 = (cx << 6) & 0xFC0;
+            cx = g >> cxshift;
+            ret = decode_unit(s, &s->pixel_model[2][cx + cx1], 400, &b);
+            if (ret < 0)
+                return ret;
+
+            clr = (b << 16) + (g << 8) + r;
+        }
+        if (ptype > 5)
+            return AVERROR_INVALIDDATA;
+        ret = decode_value(s, s->run_model[ptype], 256, 400, &run);
+        if (ret < 0)
+            return ret;
+
+        switch (ptype) {
+        case 0:
+            while (run-- > 0) {
+                if (y >= avctx->height)
+                    return AVERROR_INVALIDDATA;
+
+                dst[y * linesize + x] = clr;
+                lx = x;
+                ly = y;
+                x++;
+                if (x >= avctx->width) {
+                    x = 0;
+                    y++;
+                }
+            }
+            break;
+        case 1:
+            while (run-- > 0) {
+                if (y >= avctx->height)
+                    return AVERROR_INVALIDDATA;
+
+                dst[y * linesize + x] = dst[ly * linesize + lx];
+                lx = x;
+                ly = y;
+                x++;
+                if (x >= avctx->width) {
+                    x = 0;
+                    y++;
+                }
+            }
+            clr = dst[ly * linesize + lx];
+            break;
+        case 2:
+            while (run-- > 0) {
+                if (y < 1 || y >= avctx->height)
+                    return AVERROR_INVALIDDATA;
+
+                clr = dst[y * linesize + x + off + 1];
+                dst[y * linesize + x] = clr;
+                lx = x;
+                ly = y;
+                x++;
+                if (x >= avctx->width) {
+                    x = 0;
+                    y++;
+                }
+            }
+            break;
+        case 4:
+            while (run-- > 0) {
+                uint8_t *odst = (uint8_t *)dst;
+
+                if (y < 1 || y >= avctx->height ||
+                    (y == 1 && x == 0))
+                    return AVERROR_INVALIDDATA;
+
+                if (x == 0) {
+                    z = backstep;
+                } else {
+                    z = 0;
+                }
+
+                r = odst[(ly * linesize + lx) * 4] +
+                    odst[((y * linesize + x) + off - z) * 4 + 4] -
+                    odst[((y * linesize + x) + off - z) * 4];
+                g = odst[(ly * linesize + lx) * 4 + 1] +
+                    odst[((y * linesize + x) + off - z) * 4 + 5] -
+                    odst[((y * linesize + x) + off - z) * 4 + 1];
+                b = odst[(ly * linesize + lx) * 4 + 2] +
+                    odst[((y * linesize + x) + off - z) * 4 + 6] -
+                    odst[((y * linesize + x) + off - z) * 4 + 2];
+                clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);
+                dst[y * linesize + x] = clr;
+                lx = x;
+                ly = y;
+                x++;
+                if (x >= avctx->width) {
+                    x = 0;
+                    y++;
+                }
+            }
+            break;
+        case 5:
+            while (run-- > 0) {
+                if (y < 1 || y >= avctx->height ||
+                    (y == 1 && x == 0))
+                    return AVERROR_INVALIDDATA;
+
+                if (x == 0) {
+                    z = backstep;
+                } else {
+                    z = 0;
+                }
+
+                clr = dst[y * linesize + x + off - z];
+                dst[y * linesize + x] = clr;
+                lx = x;
+                ly = y;
+                x++;
+                if (x >= avctx->width) {
+                    x = 0;
+                    y++;
+                }
+            }
+            break;
+        }
+
+        if (avctx->bits_per_coded_sample == 16) {
+            cx1 = (clr & 0x3F00) >> 2;
+            cx = (clr & 0x3FFFFF) >> 16;
+        } else {
+            cx1 = (clr & 0xFC00) >> 4;
+            cx = (clr & 0xFFFFFF) >> 18;
+        }
+    }
+
+    return 0;
+}
+
+static int decompress_p(AVCodecContext *avctx,
+                        uint32_t *dst, int linesize,
+                        uint32_t *prev, int plinesize)
+{
+    SCPRContext *s = avctx->priv_data;
+    GetByteContext *gb = &s->gb;
+    int ret, temp, min, max, x, y, cx = 0, cx1 = 0;
+    int backstep = linesize - avctx->width;
+    const int cxshift = s->cxshift;
+
+    if (bytestream2_get_byte(gb) == 0)
+        return 0;
+    bytestream2_skip(gb, 1);
+    init_rangecoder(&s->rc, gb);
+
+    ret  = decode_value(s, s->range_model, 256, 1, &min);
+    ret |= decode_value(s, s->range_model, 256, 1, &temp);
+    min += temp << 8;
+    ret |= decode_value(s, s->range_model, 256, 1, &max);
+    ret |= decode_value(s, s->range_model, 256, 1, &temp);
+    if (ret < 0)
+        return ret;
+
+    max += temp << 8;
+    memset(s->blocks, 0, sizeof(*s->blocks) * s->nbcount);
+
+    while (min <= max) {
+        int fill, count;
+
+        ret  = decode_value(s, s->fill_model,  5,   10, &fill);
+        ret |= decode_value(s, s->count_model, 256, 20, &count);
+        if (ret < 0)
+            return ret;
+
+        while (min < s->nbcount && count-- > 0) {
+            s->blocks[min++] = fill;
+        }
+    }
+
+    for (y = 0; y < s->nby; y++) {
+        for (x = 0; x < s->nbx; x++) {
+            int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
+
+            if (s->blocks[y * s->nbx + x] == 0)
+                continue;
+
+            if (((s->blocks[y * s->nbx + x] - 1) & 1) > 0) {
+                ret  = decode_value(s, s->sxy_model[0], 16, 100, &sx1);
+                ret |= decode_value(s, s->sxy_model[1], 16, 100, &sy1);
+                ret |= decode_value(s, s->sxy_model[2], 16, 100, &sx2);
+                ret |= decode_value(s, s->sxy_model[3], 16, 100, &sy2);
+                if (ret < 0)
+                    return ret;
+
+                sx2++;
+                sy2++;
+            }
+            if (((s->blocks[y * s->nbx + x] - 1) & 2) > 0) {
+                int i, j, by = y * 16, bx = x * 16;
+                int mvx, mvy;
+
+                ret  = decode_value(s, s->mv_model[0], 512, 100, &mvx);
+                ret |= decode_value(s, s->mv_model[1], 512, 100, &mvy);
+                if (ret < 0)
+                    return ret;
+
+                mvx -= 256;
+                mvy -= 256;
+
+                if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 ||
+                    by + mvy + sy1 >= avctx->height || bx + mvx + sx1 >= avctx->width)
+                    return AVERROR_INVALIDDATA;
+
+                for (i = 0; i < sy2 - sy1 && (by + sy1 + i) < avctx->height && (by + mvy + sy1 + i) < avctx->height; i++) {
+                    for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->width && (bx + mvx + sx1 + j) < avctx->width; j++) {
+                        dst[(by + i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 + i) * plinesize + bx + sx1 + mvx + j];
+                    }
+                }
+            } else {
+                int run, r, g, b, z, bx = x * 16 + sx1, by = y * 16 + sy1;
+                unsigned clr, ptype = 0;
+
+                for (; by < y * 16 + sy2 && by < avctx->height;) {
+                    ret = decode_value(s, s->op_model[ptype], 6, 1000, &ptype);
+                    if (ret < 0)
+                        return ret;
+                    if (ptype == 0) {
+                        ret = decode_unit(s, &s->pixel_model[0][cx + cx1], 400, &r);
+                        if (ret < 0)
+                            return ret;
+
+                        cx1 = (cx << 6) & 0xFC0;
+                        cx = r >> cxshift;
+                        ret = decode_unit(s, &s->pixel_model[1][cx + cx1], 400, &g);
+                        if (ret < 0)
+                            return ret;
+
+                        cx1 = (cx << 6) & 0xFC0;
+                        cx = g >> cxshift;
+                        ret = decode_unit(s, &s->pixel_model[2][cx + cx1], 400, &b);
+                        if (ret < 0)
+                            return ret;
+
+                        clr = (b << 16) + (g << 8) + r;
+                    }
+                    if (ptype > 5)
+                        return AVERROR_INVALIDDATA;
+                    ret = decode_value(s, s->run_model[ptype], 256, 400, &run);
+                    if (ret < 0)
+                        return ret;
+
+                    switch (ptype) {
+                    case 0:
+                        while (run-- > 0) {
+                            if (by >= avctx->height)
+                                return AVERROR_INVALIDDATA;
+
+                            dst[by * linesize + bx] = clr;
+                            bx++;
+                            if (bx >= x * 16 + sx2 || bx >= avctx->width) {
+                                bx = x * 16 + sx1;
+                                by++;
+                            }
+                        }
+                        break;
+                    case 1:
+                        while (run-- > 0) {
+                            if (bx == 0) {
+                                if (by < 1)
+                                    return AVERROR_INVALIDDATA;
+                                z = backstep;
+                            } else {
+                                z = 0;
+                            }
+
+                            if (by >= avctx->height)
+                                return AVERROR_INVALIDDATA;
+
+                            clr = dst[by * linesize + bx - 1 - z];
+                            dst[by * linesize + bx] = clr;
+                            bx++;
+                            if (bx >= x * 16 + sx2 || bx >= avctx->width) {
+                                bx = x * 16 + sx1;
+                                by++;
+                            }
+                        }
+                        break;
+                    case 2:
+                        while (run-- > 0) {
+                            if (by < 1 || by >= avctx->height)
+                                return AVERROR_INVALIDDATA;
+
+                            clr = dst[(by - 1) * linesize + bx];
+                            dst[by * linesize + bx] = clr;
+                            bx++;
+                            if (bx >= x * 16 + sx2 || bx >= avctx->width) {
+                                bx = x * 16 + sx1;
+                                by++;
+                            }
+                        }
+                        break;
+                    case 3:
+                        while (run-- > 0) {
+                            if (by >= avctx->height)
+                                return AVERROR_INVALIDDATA;
+
+                            clr = prev[by * plinesize + bx];
+                            dst[by * linesize + bx] = clr;
+                            bx++;
+                            if (bx >= x * 16 + sx2 || bx >= avctx->width) {
+                                bx = x * 16 + sx1;
+                                by++;
+                            }
+                        }
+                        break;
+                    case 4:
+                        while (run-- > 0) {
+                            uint8_t *odst = (uint8_t *)dst;
+
+                            if (by < 1 || by >= avctx->height)
+                                return AVERROR_INVALIDDATA;
+
+                            if (bx == 0) {
+                                z = backstep;
+                            } else {
+                                z = 0;
+                            }
+
+                            r = odst[((by - 1) * linesize + bx) * 4] +
+                                odst[(by * linesize + bx - 1 - z) * 4] -
+                                odst[((by - 1) * linesize + bx - 1 - z) * 4];
+                            g = odst[((by - 1) * linesize + bx) * 4 + 1] +
+                                odst[(by * linesize + bx - 1 - z) * 4 + 1] -
+                                odst[((by - 1) * linesize + bx - 1 - z) * 4 + 1];
+                            b = odst[((by - 1) * linesize + bx) * 4 + 2] +
+                                odst[(by * linesize + bx - 1 - z) * 4 + 2] -
+                                odst[((by - 1) * linesize + bx - 1 - z) * 4 + 2];
+                            clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);
+                            dst[by * linesize + bx] = clr;
+                            bx++;
+                            if (bx >= x * 16 + sx2 || bx >= avctx->width) {
+                                bx = x * 16 + sx1;
+                                by++;
+                            }
+                        }
+                        break;
+                    case 5:
+                        while (run-- > 0) {
+                            if (by < 1 || by >= avctx->height)
+                                return AVERROR_INVALIDDATA;
+
+                            if (bx == 0) {
+                                z = backstep;
+                            } else {
+                                z = 0;
+                            }
+
+                            clr = dst[(by - 1) * linesize + bx - 1 - z];
+                            dst[by * linesize + bx] = clr;
+                            bx++;
+                            if (bx >= x * 16 + sx2 || bx >= avctx->width) {
+                                bx = x * 16 + sx1;
+                                by++;
+                            }
+                        }
+                        break;
+                    }
+
+                    if (avctx->bits_per_coded_sample == 16) {
+                        cx1 = (clr & 0x3F00) >> 2;
+                        cx = (clr & 0x3FFFFF) >> 16;
+                    } else {
+                        cx1 = (clr & 0xFC00) >> 4;
+                        cx = (clr & 0xFFFFFF) >> 18;
+                    }
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
+                        AVPacket *avpkt)
+{
+    SCPRContext *s = avctx->priv_data;
+    GetByteContext *gb = &s->gb;
+    AVFrame *frame = data;
+    int ret, type;
+
+    if (avctx->bits_per_coded_sample == 16) {
+        if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
+            return ret;
+    }
+
+    if ((ret = ff_reget_buffer(avctx, s->current_frame)) < 0)
+        return ret;
+
+    bytestream2_init(gb, avpkt->data, avpkt->size);
+
+    type = bytestream2_peek_byte(gb);
+
+    if (type == 2) {
+        s->get_freq = get_freq0;
+        s->decode = decode0;
+        frame->key_frame = 1;
+        ret = decompress_i(avctx, (uint32_t *)s->current_frame->data[0],
+                           s->current_frame->linesize[0] / 4);
+    } else if (type == 18) {
+        s->get_freq = get_freq;
+        s->decode = decode;
+        frame->key_frame = 1;
+        ret = decompress_i(avctx, (uint32_t *)s->current_frame->data[0],
+                           s->current_frame->linesize[0] / 4);
+    } else if (type == 17) {
+        uint32_t clr, *dst = (uint32_t *)s->current_frame->data[0];
+        int x, y;
+
+        frame->key_frame = 1;
+        bytestream2_skip(gb, 1);
+        if (avctx->bits_per_coded_sample == 16) {
+            uint16_t value = bytestream2_get_le16(gb);
+            int r, g, b;
+
+            r = (value      ) & 31;
+            g = (value >>  5) & 31;
+            b = (value >> 10) & 31;
+            clr = (r << 16) + (g << 8) + b;
+        } else {
+            clr = bytestream2_get_le24(gb);
+        }
+        for (y = 0; y < avctx->height; y++) {
+            for (x = 0; x < avctx->width; x++) {
+                dst[x] = clr;
+            }
+            dst += s->current_frame->linesize[0] / 4;
+        }
+    } else if (type == 0 || type == 1) {
+        frame->key_frame = 0;
+
+        ret = av_frame_copy(s->current_frame, s->last_frame);
+        if (ret < 0)
+            return ret;
+
+        ret = decompress_p(avctx, (uint32_t *)s->current_frame->data[0],
+                           s->current_frame->linesize[0] / 4,
+                           (uint32_t *)s->last_frame->data[0],
+                           s->last_frame->linesize[0] / 4);
+    } else {
+        return AVERROR_PATCHWELCOME;
+    }
+
+    if (ret < 0)
+        return ret;
+
+    if (avctx->bits_per_coded_sample != 16) {
+        ret = av_frame_ref(data, s->current_frame);
+        if (ret < 0)
+            return ret;
+    } else {
+        uint8_t *dst = frame->data[0];
+        int x, y;
+
+        ret = av_frame_copy(frame, s->current_frame);
+        if (ret < 0)
+            return ret;
+
+        // scale up each sample by 8
+        for (y = 0; y < avctx->height; y++) {
+            // If the image is sufficiently aligned, compute 8 samples at once
+            if (!(((uintptr_t)dst) & 7)) {
+                uint64_t *dst64 = (uint64_t *)dst;
+                int w = avctx->width>>1;
+                for (x = 0; x < w; x++) {
+                    dst64[x] = (dst64[x] << 3) & 0xFCFCFCFCFCFCFCFCULL;
+                }
+                x *= 8;
+            } else
+                x = 0;
+            for (; x < avctx->width * 4; x++) {
+                dst[x] = dst[x] << 3;
+            }
+            dst += frame->linesize[0];
+        }
+    }
+
+    frame->pict_type = frame->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
+
+    FFSWAP(AVFrame *, s->current_frame, s->last_frame);
+
+    frame->data[0]     += frame->linesize[0] * (avctx->height - 1);
+    frame->linesize[0] *= -1;
+
+    *got_frame = 1;
+
+    return avpkt->size;
+}
+
+static av_cold int decode_init(AVCodecContext *avctx)
+{
+    SCPRContext *s = avctx->priv_data;
+
+    switch (avctx->bits_per_coded_sample) {
+    case 16: avctx->pix_fmt = AV_PIX_FMT_RGB0; break;
+    case 24:
+    case 32: avctx->pix_fmt = AV_PIX_FMT_BGR0; break;
+    default:
+        av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", avctx->bits_per_coded_sample);
+        return AVERROR_INVALIDDATA;
+    }
+
+    s->get_freq = get_freq0;
+    s->decode = decode0;
+
+    s->cxshift = avctx->bits_per_coded_sample == 16 ? 0 : 2;
+    s->cbits = avctx->bits_per_coded_sample == 16 ? 0x1F : 0xFF;
+    s->nbx = (avctx->width + 15) / 16;
+    s->nby = (avctx->height + 15) / 16;
+    s->nbcount = s->nbx * s->nby;
+    s->blocks = av_malloc_array(s->nbcount, sizeof(*s->blocks));
+    if (!s->blocks)
+        return AVERROR(ENOMEM);
+
+    s->last_frame = av_frame_alloc();
+    s->current_frame = av_frame_alloc();
+    if (!s->last_frame || !s->current_frame)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+static av_cold int decode_close(AVCodecContext *avctx)
+{
+    SCPRContext *s = avctx->priv_data;
+
+    av_freep(&s->blocks);
+    av_frame_free(&s->last_frame);
+    av_frame_free(&s->current_frame);
+
+    return 0;
+}
+
+AVCodec ff_scpr_decoder = {
+    .name             = "scpr",
+    .long_name        = NULL_IF_CONFIG_SMALL("ScreenPressor"),
+    .type             = AVMEDIA_TYPE_VIDEO,
+    .id               = AV_CODEC_ID_SCPR,
+    .priv_data_size   = sizeof(SCPRContext),
+    .init             = decode_init,
+    .close            = decode_close,
+    .decode           = decode_frame,
+    .capabilities     = AV_CODEC_CAP_DR1,
+    .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
+                        FF_CODEC_CAP_INIT_CLEANUP,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/screenpresso.c b/mythtv/external/FFmpeg/libavcodec/screenpresso.c
index 2fadca46b7e..fb8bfd4701b 100644
--- a/mythtv/external/FFmpeg/libavcodec/screenpresso.c
+++ b/mythtv/external/FFmpeg/libavcodec/screenpresso.c
@@ -179,7 +179,7 @@ static int screenpresso_decode_frame(AVCodecContext *avctx, void *data,
     }
     *got_frame = 1;
 
-    return 0;
+    return avpkt->size;
 }
 
 AVCodec ff_screenpresso_decoder = {
diff --git a/mythtv/external/FFmpeg/libavcodec/sheervideo.c b/mythtv/external/FFmpeg/libavcodec/sheervideo.c
index e8f008b7e4a..6f99b5c8693 100644
--- a/mythtv/external/FFmpeg/libavcodec/sheervideo.c
+++ b/mythtv/external/FFmpeg/libavcodec/sheervideo.c
@@ -2185,7 +2185,7 @@ static void decode_aybri(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
             dst_v[x] = get_bits(gb, 8);
         }
     } else {
-        int pred[4] = { 125, 125, -128, -128 };
+        int pred[4] = { 125, s->alt ? 125 : -146, -128, -128 };
 
         for (x = 0; x < avctx->width; x++) {
             int a, y, u, v;
@@ -2263,7 +2263,7 @@ static void decode_aybr(AVCodecContext *avctx, AVFrame *p, GetBitContext *gb)
             dst_v[x] = get_bits(gb, 8);
         }
     } else {
-        int pred[4] = { 125, 125, -128, -128 };
+        int pred[4] = { 125, s->alt ? 125 : -146, -128, -128 };
 
         for (x = 0; x < avctx->width; x++) {
             int a, y, u, v;
@@ -2879,7 +2879,6 @@ static int decode_frame(AVCodecContext *avctx,
     AVFrame *p = data;
     GetBitContext gb;
     unsigned format;
-    char format_str[32];
     int ret;
 
     if (avpkt->size <= 20)
@@ -2891,8 +2890,7 @@ static int decode_frame(AVCodecContext *avctx,
 
     s->alt = 0;
     format = AV_RL32(avpkt->data + 16);
-    av_get_codec_tag_string(format_str, sizeof(format_str), format);
-    av_log(avctx, AV_LOG_DEBUG, "format: %s\n", format_str);
+    av_log(avctx, AV_LOG_DEBUG, "format: %s\n", av_fourcc2str(format));
     switch (format) {
     case MKTAG(' ', 'R', 'G', 'B'):
         avctx->pix_fmt = AV_PIX_FMT_RGB0;
@@ -2959,6 +2957,7 @@ static int decode_frame(AVCodecContext *avctx,
         }
         break;
     case MKTAG('A', 'Y', 'B', 'R'):
+        s->alt = 1;
     case MKTAG('A', 'Y', 'b', 'R'):
         avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
         s->decode_frame = decode_aybr;
@@ -2968,6 +2967,7 @@ static int decode_frame(AVCodecContext *avctx,
         }
         break;
     case MKTAG('A', 'y', 'B', 'R'):
+        s->alt = 1;
     case MKTAG('A', 'y', 'b', 'R'):
         avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
         s->decode_frame = decode_aybri;
@@ -3105,6 +3105,11 @@ static int decode_frame(AVCodecContext *avctx,
         return AVERROR_PATCHWELCOME;
     }
 
+    if (avpkt->size < 20 + avctx->width * avctx->height / 16) {
+        av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
+        return AVERROR_INVALIDDATA;
+    }
+
     if (s->format != format) {
         if (ret < 0)
             return ret;
diff --git a/mythtv/external/FFmpeg/libavcodec/shorten.c b/mythtv/external/FFmpeg/libavcodec/shorten.c
index e4cef618113..49af6beec6a 100644
--- a/mythtv/external/FFmpeg/libavcodec/shorten.c
+++ b/mythtv/external/FFmpeg/libavcodec/shorten.c
@@ -27,6 +27,7 @@
 
 #include <limits.h>
 #include "avcodec.h"
+#include "bswapdsp.h"
 #include "bytestream.h"
 #include "get_bits.h"
 #include "golomb.h"
@@ -109,6 +110,8 @@ typedef struct ShortenContext {
     int32_t lpcqoffset;
     int got_header;
     int got_quit_command;
+    int swap;
+    BswapDSPContext bdsp;
 } ShortenContext;
 
 static av_cold int shorten_decode_init(AVCodecContext *avctx)
@@ -116,6 +119,8 @@ static av_cold int shorten_decode_init(AVCodecContext *avctx)
     ShortenContext *s = avctx->priv_data;
     s->avctx          = avctx;
 
+    ff_bswapdsp_init(&s->bdsp);
+
     return 0;
 }
 
@@ -155,8 +160,11 @@ static int allocate_buffers(ShortenContext *s)
 
 static inline unsigned int get_uint(ShortenContext *s, int k)
 {
-    if (s->version != 0)
+    if (s->version != 0) {
         k = get_ur_golomb_shorten(&s->gb, ULONGSIZE);
+        if (k > 31U)
+            return AVERROR_INVALIDDATA;
+    }
     return get_ur_golomb_shorten(&s->gb, k);
 }
 
@@ -202,6 +210,7 @@ static int init_offset(ShortenContext *s)
 static int decode_aiff_header(AVCodecContext *avctx, const uint8_t *header,
                               int header_size)
 {
+    ShortenContext *s = avctx->priv_data;
     int len, bps, exp;
     GetByteContext gb;
     uint64_t val;
@@ -217,7 +226,8 @@ static int decode_aiff_header(AVCodecContext *avctx, const uint8_t *header,
     bytestream2_skip(&gb, 4); /* chunk size */
 
     tag = bytestream2_get_le32(&gb);
-    if (tag != MKTAG('A', 'I', 'F', 'F')) {
+    if (tag != MKTAG('A', 'I', 'F', 'F') &&
+        tag != MKTAG('A', 'I', 'F', 'C')) {
         av_log(avctx, AV_LOG_ERROR, "missing AIFF tag\n");
         return AVERROR_INVALIDDATA;
     }
@@ -241,6 +251,8 @@ static int decode_aiff_header(AVCodecContext *avctx, const uint8_t *header,
     bps = bytestream2_get_be16(&gb);
     avctx->bits_per_coded_sample = bps;
 
+    s->swap = tag == MKTAG('A', 'I', 'F', 'C');
+
     if (bps != 16 && bps != 8) {
         av_log(avctx, AV_LOG_ERROR, "unsupported number of bits per sample: %d\n", bps);
         return AVERROR(ENOSYS);
@@ -433,6 +445,10 @@ static int read_header(ShortenContext *s)
         s->blocksize = blocksize;
 
         maxnlpc  = get_uint(s, LPCQSIZE);
+        if (maxnlpc > 1024U) {
+            av_log(s->avctx, AV_LOG_ERROR, "maxnlpc is: %d\n", maxnlpc);
+            return AVERROR_INVALIDDATA;
+        }
         s->nmean = get_uint(s, 0);
 
         skip_bytes = get_uint(s, NSKIPSIZE);
@@ -446,12 +462,6 @@ static int read_header(ShortenContext *s)
     }
     s->nwrap = FFMAX(NWRAP, maxnlpc);
 
-    if ((ret = allocate_buffers(s)) < 0)
-        return ret;
-
-    if ((ret = init_offset(s)) < 0)
-        return ret;
-
     if (s->version > 1)
         s->lpcqoffset = V2LPCQOFFSET;
 
@@ -482,11 +492,19 @@ static int read_header(ShortenContext *s)
         if ((ret = decode_aiff_header(s->avctx, s->header, s->header_size)) < 0)
             return ret;
     } else {
-        avpriv_report_missing_feature(s->avctx, "unsupported bit packing %X", AV_RL32(s->header));
+        avpriv_report_missing_feature(s->avctx, "unsupported bit packing %"
+                                      PRIX32, AV_RL32(s->header));
         return AVERROR_PATCHWELCOME;
     }
 
 end:
+
+    if ((ret = allocate_buffers(s)) < 0)
+        return ret;
+
+    if ((ret = init_offset(s)) < 0)
+        return ret;
+
     s->cur_chan = 0;
     s->bitshift = 0;
 
@@ -617,8 +635,8 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
             case FN_BLOCKSIZE: {
                 unsigned blocksize = get_uint(s, av_log2(s->blocksize));
                 if (blocksize > s->blocksize) {
-                    av_log(avctx, AV_LOG_ERROR,
-                           "Increasing block size is not supported\n");
+                    avpriv_report_missing_feature(avctx,
+                                                  "Increasing block size");
                     return AVERROR_PATCHWELCOME;
                 }
                 if (!blocksize || blocksize > MAX_BLOCKSIZE) {
@@ -648,6 +666,10 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
                  * of get_sr_golomb_shorten(). */
                 if (s->version == 0)
                     residual_size--;
+                if (residual_size > 30U) {
+                    av_log(avctx, AV_LOG_ERROR, "residual size unsupportd: %d\n", residual_size);
+                    return AVERROR_INVALIDDATA;
+                }
             }
 
             /* calculate sample offset using means from previous blocks */
@@ -721,6 +743,11 @@ static int shorten_decode_frame(AVCodecContext *avctx, void *data,
                             break;
                         }
                     }
+                    if (s->swap && s->internal_ftype != TYPE_U8)
+                        s->bdsp.bswap16_buf(((uint16_t **)frame->extended_data)[chan],
+                                            ((uint16_t **)frame->extended_data)[chan],
+                                            s->blocksize);
+
                 }
 
                 *got_frame_ptr = 1;
diff --git a/mythtv/external/FFmpeg/libavcodec/simple_idct.c b/mythtv/external/FFmpeg/libavcodec/simple_idct.c
index 0711e167a56..1d05b2fe08c 100644
--- a/mythtv/external/FFmpeg/libavcodec/simple_idct.c
+++ b/mythtv/external/FFmpeg/libavcodec/simple_idct.c
@@ -58,7 +58,7 @@
    and the butterfly must be multiplied by 0.5 * sqrt(2.0) */
 #define C_SHIFT (4+1+12)
 
-static inline void idct4col_put(uint8_t *dest, int line_size, const int16_t *col)
+static inline void idct4col_put(uint8_t *dest, ptrdiff_t line_size, const int16_t *col)
 {
     int c0, c1, c2, c3, a0, a1, a2, a3;
 
@@ -66,8 +66,8 @@ static inline void idct4col_put(uint8_t *dest, int line_size, const int16_t *col
     a1 = col[8*2];
     a2 = col[8*4];
     a3 = col[8*6];
-    c0 = ((a0 + a2) << (CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));
-    c2 = ((a0 - a2) << (CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));
+    c0 = ((a0 + a2) * (1 << CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));
+    c2 = ((a0 - a2) * (1 << CN_SHIFT - 1)) + (1 << (C_SHIFT - 1));
     c1 = a1 * C1 + a3 * C2;
     c3 = a1 * C2 - a3 * C1;
     dest[0] = av_clip_uint8((c0 + c1) >> C_SHIFT);
@@ -94,7 +94,7 @@ static inline void idct4col_put(uint8_t *dest, int line_size, const int16_t *col
 /* XXX: I think a 1.0/sqrt(2) normalization should be needed to
    compensate the extra butterfly stage - I don't have the full DV
    specification */
-void ff_simple_idct248_put(uint8_t *dest, int line_size, int16_t *block)
+void ff_simple_idct248_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     int i;
     int16_t *ptr;
@@ -137,7 +137,7 @@ void ff_simple_idct248_put(uint8_t *dest, int line_size, int16_t *block)
 #define C2 C_FIX(0.2705980501)
 #define C3 C_FIX(0.5)
 #define C_SHIFT (4+1+12)
-static inline void idct4col_add(uint8_t *dest, int line_size, const int16_t *col)
+static inline void idct4col_add(uint8_t *dest, ptrdiff_t line_size, const int16_t *col)
 {
     int c0, c1, c2, c3, a0, a1, a2, a3;
 
@@ -182,7 +182,7 @@ static inline void idct4row(int16_t *row)
     row[3]= (c0 - c1) >> R_SHIFT;
 }
 
-void ff_simple_idct84_add(uint8_t *dest, int line_size, int16_t *block)
+void ff_simple_idct84_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     int i;
 
@@ -197,7 +197,7 @@ void ff_simple_idct84_add(uint8_t *dest, int line_size, int16_t *block)
     }
 }
 
-void ff_simple_idct48_add(uint8_t *dest, int line_size, int16_t *block)
+void ff_simple_idct48_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     int i;
 
@@ -212,7 +212,7 @@ void ff_simple_idct48_add(uint8_t *dest, int line_size, int16_t *block)
     }
 }
 
-void ff_simple_idct44_add(uint8_t *dest, int line_size, int16_t *block)
+void ff_simple_idct44_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     int i;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/simple_idct.h b/mythtv/external/FFmpeg/libavcodec/simple_idct.h
index 154e2974701..2a5e1d7f6da 100644
--- a/mythtv/external/FFmpeg/libavcodec/simple_idct.h
+++ b/mythtv/external/FFmpeg/libavcodec/simple_idct.h
@@ -28,18 +28,19 @@
 #ifndef AVCODEC_SIMPLE_IDCT_H
 #define AVCODEC_SIMPLE_IDCT_H
 
+#include <stddef.h>
 #include <stdint.h>
 
-void ff_simple_idct_put_8(uint8_t *dest, int line_size, int16_t *block);
-void ff_simple_idct_add_8(uint8_t *dest, int line_size, int16_t *block);
+void ff_simple_idct_put_8(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct_add_8(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 void ff_simple_idct_8(int16_t *block);
 
-void ff_simple_idct_put_10(uint8_t *dest, int line_size, int16_t *block);
-void ff_simple_idct_add_10(uint8_t *dest, int line_size, int16_t *block);
+void ff_simple_idct_put_10(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct_add_10(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 void ff_simple_idct_10(int16_t *block);
 
-void ff_simple_idct_put_12(uint8_t *dest, int line_size, int16_t *block);
-void ff_simple_idct_add_12(uint8_t *dest, int line_size, int16_t *block);
+void ff_simple_idct_put_12(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct_add_12(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 void ff_simple_idct_12(int16_t *block);
 
 /**
@@ -49,10 +50,10 @@ void ff_simple_idct_12(int16_t *block);
  */
 void ff_prores_idct(int16_t *block, const int16_t *qmat);
 
-void ff_simple_idct248_put(uint8_t *dest, int line_size, int16_t *block);
+void ff_simple_idct248_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 
-void ff_simple_idct84_add(uint8_t *dest, int line_size, int16_t *block);
-void ff_simple_idct48_add(uint8_t *dest, int line_size, int16_t *block);
-void ff_simple_idct44_add(uint8_t *dest, int line_size, int16_t *block);
+void ff_simple_idct84_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct48_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct44_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 
 #endif /* AVCODEC_SIMPLE_IDCT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/simple_idct_template.c b/mythtv/external/FFmpeg/libavcodec/simple_idct_template.c
index f5744e0a394..f532313441c 100644
--- a/mythtv/external/FFmpeg/libavcodec/simple_idct_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/simple_idct_template.c
@@ -112,7 +112,7 @@ static inline void FUNC(idctRowCondDC_extrashift)(int16_t *row, int extra_shift)
 static inline void FUNC(idctRowCondDC)(int16_t *row, int extra_shift)
 #endif
 {
-    int a0, a1, a2, a3, b0, b1, b2, b3;
+    SUINT a0, a1, a2, a3, b0, b1, b2, b3;
 
 #if HAVE_FAST_64BIT
 #define ROW0_MASK (0xffffLL << 48 * HAVE_BIGENDIAN)
@@ -187,14 +187,14 @@ static inline void FUNC(idctRowCondDC)(int16_t *row, int extra_shift)
         MAC(b3, -W1, row[7]);
     }
 
-    row[0] = (a0 + b0) >> (ROW_SHIFT + extra_shift);
-    row[7] = (a0 - b0) >> (ROW_SHIFT + extra_shift);
-    row[1] = (a1 + b1) >> (ROW_SHIFT + extra_shift);
-    row[6] = (a1 - b1) >> (ROW_SHIFT + extra_shift);
-    row[2] = (a2 + b2) >> (ROW_SHIFT + extra_shift);
-    row[5] = (a2 - b2) >> (ROW_SHIFT + extra_shift);
-    row[3] = (a3 + b3) >> (ROW_SHIFT + extra_shift);
-    row[4] = (a3 - b3) >> (ROW_SHIFT + extra_shift);
+    row[0] = (int)(a0 + b0) >> (ROW_SHIFT + extra_shift);
+    row[7] = (int)(a0 - b0) >> (ROW_SHIFT + extra_shift);
+    row[1] = (int)(a1 + b1) >> (ROW_SHIFT + extra_shift);
+    row[6] = (int)(a1 - b1) >> (ROW_SHIFT + extra_shift);
+    row[2] = (int)(a2 + b2) >> (ROW_SHIFT + extra_shift);
+    row[5] = (int)(a2 - b2) >> (ROW_SHIFT + extra_shift);
+    row[3] = (int)(a3 + b3) >> (ROW_SHIFT + extra_shift);
+    row[4] = (int)(a3 - b3) >> (ROW_SHIFT + extra_shift);
 }
 
 #define IDCT_COLS do {                                  \
@@ -250,31 +250,31 @@ static inline void FUNC(idctRowCondDC)(int16_t *row, int extra_shift)
 #ifdef EXTRA_SHIFT
 static inline void FUNC(idctSparseCol_extrashift)(int16_t *col)
 #else
-static inline void FUNC(idctSparseColPut)(pixel *dest, int line_size,
+static inline void FUNC(idctSparseColPut)(pixel *dest, ptrdiff_t line_size,
                                           int16_t *col)
 {
-    int a0, a1, a2, a3, b0, b1, b2, b3;
+    SUINT a0, a1, a2, a3, b0, b1, b2, b3;
 
     IDCT_COLS;
 
-    dest[0] = av_clip_pixel((a0 + b0) >> COL_SHIFT);
+    dest[0] = av_clip_pixel((int)(a0 + b0) >> COL_SHIFT);
     dest += line_size;
-    dest[0] = av_clip_pixel((a1 + b1) >> COL_SHIFT);
+    dest[0] = av_clip_pixel((int)(a1 + b1) >> COL_SHIFT);
     dest += line_size;
-    dest[0] = av_clip_pixel((a2 + b2) >> COL_SHIFT);
+    dest[0] = av_clip_pixel((int)(a2 + b2) >> COL_SHIFT);
     dest += line_size;
-    dest[0] = av_clip_pixel((a3 + b3) >> COL_SHIFT);
+    dest[0] = av_clip_pixel((int)(a3 + b3) >> COL_SHIFT);
     dest += line_size;
-    dest[0] = av_clip_pixel((a3 - b3) >> COL_SHIFT);
+    dest[0] = av_clip_pixel((int)(a3 - b3) >> COL_SHIFT);
     dest += line_size;
-    dest[0] = av_clip_pixel((a2 - b2) >> COL_SHIFT);
+    dest[0] = av_clip_pixel((int)(a2 - b2) >> COL_SHIFT);
     dest += line_size;
-    dest[0] = av_clip_pixel((a1 - b1) >> COL_SHIFT);
+    dest[0] = av_clip_pixel((int)(a1 - b1) >> COL_SHIFT);
     dest += line_size;
-    dest[0] = av_clip_pixel((a0 - b0) >> COL_SHIFT);
+    dest[0] = av_clip_pixel((int)(a0 - b0) >> COL_SHIFT);
 }
 
-static inline void FUNC(idctSparseColAdd)(pixel *dest, int line_size,
+static inline void FUNC(idctSparseColAdd)(pixel *dest, ptrdiff_t line_size,
                                           int16_t *col)
 {
     int a0, a1, a2, a3, b0, b1, b2, b3;
@@ -316,7 +316,7 @@ static inline void FUNC(idctSparseCol)(int16_t *col)
 }
 
 #ifndef EXTRA_SHIFT
-void FUNC(ff_simple_idct_put)(uint8_t *dest_, int line_size, int16_t *block)
+void FUNC(ff_simple_idct_put)(uint8_t *dest_, ptrdiff_t line_size, int16_t *block)
 {
     pixel *dest = (pixel *)dest_;
     int i;
@@ -330,7 +330,7 @@ void FUNC(ff_simple_idct_put)(uint8_t *dest_, int line_size, int16_t *block)
         FUNC(idctSparseColPut)(dest + i, line_size, block + i);
 }
 
-void FUNC(ff_simple_idct_add)(uint8_t *dest_, int line_size, int16_t *block)
+void FUNC(ff_simple_idct_add)(uint8_t *dest_, ptrdiff_t line_size, int16_t *block)
 {
     pixel *dest = (pixel *)dest_;
     int i;
diff --git a/mythtv/external/FFmpeg/libavcodec/sinewin.h b/mythtv/external/FFmpeg/libavcodec/sinewin.h
index 27c107ce594..6b97a7185f5 100644
--- a/mythtv/external/FFmpeg/libavcodec/sinewin.h
+++ b/mythtv/external/FFmpeg/libavcodec/sinewin.h
@@ -52,14 +52,16 @@ void AAC_RENAME(ff_init_ff_sine_windows)(int index);
 
 extern SINETABLE(  32);
 extern SINETABLE(  64);
+extern SINETABLE( 120);
 extern SINETABLE( 128);
 extern SINETABLE( 256);
 extern SINETABLE( 512);
+extern SINETABLE( 960);
 extern SINETABLE(1024);
 extern SINETABLE(2048);
 extern SINETABLE(4096);
 extern SINETABLE(8192);
 
-extern SINETABLE_CONST INTFLOAT * const AAC_RENAME(ff_sine_windows)[14];
+extern SINETABLE_CONST INTFLOAT * const AAC_RENAME(ff_sine_windows)[16];
 
 #endif /* AVCODEC_SINEWIN_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/sinewin_tablegen.h b/mythtv/external/FFmpeg/libavcodec/sinewin_tablegen.h
index 4432135f19f..0fa3561abce 100644
--- a/mythtv/external/FFmpeg/libavcodec/sinewin_tablegen.h
+++ b/mythtv/external/FFmpeg/libavcodec/sinewin_tablegen.h
@@ -31,6 +31,10 @@
 #include "libavutil/attributes.h"
 #include "libavutil/common.h"
 
+#if !USE_FIXED
+SINETABLE( 120);
+SINETABLE( 960);
+#endif
 #if !CONFIG_HARDCODED_TABLES
 SINETABLE(  32);
 SINETABLE(  64);
@@ -59,7 +63,7 @@ SINETABLE_CONST INTFLOAT * const AAC_RENAME(ff_sine_windows)[] = {
     NULL, NULL, NULL, NULL, NULL, // unused
     AAC_RENAME(ff_sine_32) , AAC_RENAME(ff_sine_64), AAC_RENAME(ff_sine_128),
     AAC_RENAME(ff_sine_256), AAC_RENAME(ff_sine_512), AAC_RENAME(ff_sine_1024),
-    AAC_RENAME(ff_sine_2048), AAC_RENAME(ff_sine_4096), AAC_RENAME(ff_sine_8192)
+    AAC_RENAME(ff_sine_2048), AAC_RENAME(ff_sine_4096), AAC_RENAME(ff_sine_8192),
 };
 
 // Generate a sine window.
diff --git a/mythtv/external/FFmpeg/libavcodec/sipr.c b/mythtv/external/FFmpeg/libavcodec/sipr.c
index 70d460a678f..1b6de25ffff 100644
--- a/mythtv/external/FFmpeg/libavcodec/sipr.c
+++ b/mythtv/external/FFmpeg/libavcodec/sipr.c
@@ -494,7 +494,7 @@ static av_cold int sipr_decoder_init(AVCodecContext * avctx)
         else                              ctx->mode = MODE_5k0;
         av_log(avctx, AV_LOG_WARNING,
                "Invalid block_align: %d. Mode %s guessed based on bitrate: %"PRId64"\n",
-               avctx->block_align, modes[ctx->mode].mode_name, (int64_t)avctx->bit_rate);
+               avctx->block_align, modes[ctx->mode].mode_name, avctx->bit_rate);
     }
 
     av_log(avctx, AV_LOG_DEBUG, "Mode: %s\n", modes[ctx->mode].mode_name);
diff --git a/mythtv/external/FFmpeg/libavcodec/sipr_parser.c b/mythtv/external/FFmpeg/libavcodec/sipr_parser.c
new file mode 100644
index 00000000000..fba25e10286
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/sipr_parser.c
@@ -0,0 +1,74 @@
+/*
+ * 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
+ * Sipr audio parser
+ */
+
+#include "parser.h"
+
+typedef struct SiprParserContext{
+    ParseContext pc;
+} SiprParserContext;
+
+static int sipr_split(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
+{
+    int next;
+
+    switch (avctx->block_align) {
+    case 20:
+    case 19:
+    case 29:
+    case 37: next = avctx->block_align; break;
+    default:
+        if      (avctx->bit_rate > 12200) next = 20;
+        else if (avctx->bit_rate > 7500 ) next = 19;
+        else if (avctx->bit_rate > 5750 ) next = 29;
+        else                              next = 37;
+    }
+
+    return FFMIN(next, buf_size);
+}
+
+static int sipr_parse(AVCodecParserContext *s1, AVCodecContext *avctx,
+                      const uint8_t **poutbuf, int *poutbuf_size,
+                      const uint8_t *buf, int buf_size)
+{
+    SiprParserContext *s = s1->priv_data;
+    ParseContext *pc = &s->pc;
+    int next;
+
+    next = sipr_split(avctx, buf, buf_size);
+    if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
+        *poutbuf = NULL;
+        *poutbuf_size = 0;
+        return buf_size;
+    }
+
+    *poutbuf      = buf;
+    *poutbuf_size = buf_size;
+    return next;
+}
+
+AVCodecParser ff_sipr_parser = {
+    .codec_ids      = { AV_CODEC_ID_SIPR },
+    .priv_data_size = sizeof(SiprParserContext),
+    .parser_parse   = sipr_parse,
+    .parser_close   = ff_parse_close,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/smacker.c b/mythtv/external/FFmpeg/libavcodec/smacker.c
index b8a0c558a64..2d20be9c10e 100644
--- a/mythtv/external/FFmpeg/libavcodec/smacker.c
+++ b/mythtv/external/FFmpeg/libavcodec/smacker.c
@@ -129,8 +129,12 @@ static int smacker_decode_tree(GetBitContext *gb, HuffContext *hc, uint32_t pref
 /**
  * Decode header tree
  */
-static int smacker_decode_bigtree(GetBitContext *gb, HuffContext *hc, DBCtx *ctx)
+static int smacker_decode_bigtree(GetBitContext *gb, HuffContext *hc, DBCtx *ctx, int length)
 {
+    if(length > 500) { // Larger length can cause segmentation faults due to too deep recursion.
+        av_log(NULL, AV_LOG_ERROR, "length too long\n");
+        return AVERROR_INVALIDDATA;
+    }
     if (hc->current + 1 >= hc->length) {
         av_log(NULL, AV_LOG_ERROR, "Tree size exceeded!\n");
         return AVERROR_INVALIDDATA;
@@ -159,12 +163,12 @@ static int smacker_decode_bigtree(GetBitContext *gb, HuffContext *hc, DBCtx *ctx
         int r = 0, r_new, t;
 
         t = hc->current++;
-        r = smacker_decode_bigtree(gb, hc, ctx);
+        r = smacker_decode_bigtree(gb, hc, ctx, length + 1);
         if(r < 0)
             return r;
         hc->values[t] = SMK_NODE | r;
         r++;
-        r_new = smacker_decode_bigtree(gb, hc, ctx);
+        r_new = smacker_decode_bigtree(gb, hc, ctx, length + 1);
         if (r_new < 0)
             return r_new;
         return r + r_new;
@@ -275,7 +279,7 @@ static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int
         goto error;
     }
 
-    if (smacker_decode_bigtree(gb, &huff, &ctx) < 0)
+    if (smacker_decode_bigtree(gb, &huff, &ctx, 0) < 0)
         err = -1;
     skip_bits1(gb);
     if(ctx.last[0] == -1) ctx.last[0] = huff.current++;
diff --git a/mythtv/external/FFmpeg/libavcodec/smc.c b/mythtv/external/FFmpeg/libavcodec/smc.c
index 69d78ad1d1a..79f9a757a05 100644
--- a/mythtv/external/FFmpeg/libavcodec/smc.c
+++ b/mythtv/external/FFmpeg/libavcodec/smc.c
@@ -132,6 +132,10 @@ static void smc_decode_stream(SmcContext *s)
                 row_ptr, image_size);
             return;
         }
+        if (bytestream2_get_bytes_left(&s->gb) < 1) {
+            av_log(s->avctx, AV_LOG_ERROR, "input too small\n");
+            return;
+        }
 
         opcode = bytestream2_get_byte(&s->gb);
         switch (opcode & 0xF0) {
@@ -431,7 +435,8 @@ static int smc_decode_frame(AVCodecContext *avctx,
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     SmcContext *s = avctx->priv_data;
-    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
+    int pal_size;
+    const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &pal_size);
     int ret;
 
     bytestream2_init(&s->gb, buf, buf_size);
@@ -439,9 +444,11 @@ static int smc_decode_frame(AVCodecContext *avctx,
     if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
         return ret;
 
-    if (pal) {
+    if (pal && pal_size == AVPALETTE_SIZE) {
         s->frame->palette_has_changed = 1;
         memcpy(s->pal, pal, AVPALETTE_SIZE);
+    } else if (pal) {
+        av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", pal_size);
     }
 
     smc_decode_stream(s);
diff --git a/mythtv/external/FFmpeg/libavcodec/smvjpegdec.c b/mythtv/external/FFmpeg/libavcodec/smvjpegdec.c
index 9057e86161c..018e135b300 100644
--- a/mythtv/external/FFmpeg/libavcodec/smvjpegdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/smvjpegdec.c
@@ -152,6 +152,10 @@ static int smvjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_siz
 
     cur_frame = avpkt->pts % s->frames_per_jpeg;
 
+    /* cur_frame is later used to calculate the buffer offset, so it mustn't be negative */
+    if (cur_frame < 0)
+        cur_frame += s->frames_per_jpeg;
+
     /* Are we at the start of a block? */
     if (!cur_frame) {
         av_frame_unref(mjpeg_data);
@@ -196,9 +200,11 @@ static int smvjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_siz
             s->picture[1]->linesize[i] = mjpeg_data->linesize[i];
 
         ret = av_frame_ref(data, s->picture[1]);
+        if (ret < 0)
+            return ret;
     }
 
-    return ret;
+    return avpkt->size;
 }
 
 static const AVClass smvjpegdec_class = {
diff --git a/mythtv/external/FFmpeg/libavcodec/snow.h b/mythtv/external/FFmpeg/libavcodec/snow.h
index 59c710b5f9f..41a3bef4dec 100644
--- a/mythtv/external/FFmpeg/libavcodec/snow.h
+++ b/mythtv/external/FFmpeg/libavcodec/snow.h
@@ -32,10 +32,11 @@
 #include "rangecoder.h"
 #include "mathops.h"
 
-#define FF_MPV_OFFSET(x) (offsetof(MpegEncContext, x) + offsetof(SnowContext, m))
 #include "mpegvideo.h"
 #include "h264qpel.h"
 
+#define FF_ME_ITER 3
+
 #define MID_STATE 128
 
 #define MAX_PLANES 4
@@ -540,7 +541,8 @@ static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
     if(get_rac(c, state+0))
         return 0;
     else{
-        int i, e, a;
+        int i, e;
+        unsigned a;
         e= 0;
         while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
             e++;
diff --git a/mythtv/external/FFmpeg/libavcodec/snowdec.c b/mythtv/external/FFmpeg/libavcodec/snowdec.c
index 042aecbbeb8..a9bdb8da5ef 100644
--- a/mythtv/external/FFmpeg/libavcodec/snowdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/snowdec.c
@@ -140,7 +140,7 @@ static inline void decode_subband_slice_buffered(SnowContext *s, SubBand *b, sli
         v = b->x_coeff[new_index].coeff;
         x = b->x_coeff[new_index++].x;
         while(x < w){
-            register int t= ( (v>>1)*qmul + qadd)>>QEXPSHIFT;
+            register int t= (int)( (v>>1)*(unsigned)qmul + qadd)>>QEXPSHIFT;
             register int u= -(v&1);
             line[x] = (t^u) - u;
 
@@ -183,13 +183,22 @@ static int decode_q_branch(SnowContext *s, int level, int x, int y){
         int my_context= av_log2(2*FFABS(left->my - top->my)) + 0*av_log2(2*FFABS(tr->my - top->my));
 
         type= get_rac(&s->c, &s->block_state[1 + left->type + top->type]) ? BLOCK_INTRA : 0;
-
         if(type){
+            int ld, cbd, crd;
             pred_mv(s, &mx, &my, 0, left, top, tr);
-            l += get_symbol(&s->c, &s->block_state[32], 1);
+            ld = get_symbol(&s->c, &s->block_state[32], 1);
+            if (ld < -255 || ld > 255) {
+                return AVERROR_INVALIDDATA;
+            }
+            l += ld;
             if (s->nb_planes > 2) {
-                cb+= get_symbol(&s->c, &s->block_state[64], 1);
-                cr+= get_symbol(&s->c, &s->block_state[96], 1);
+                cbd = get_symbol(&s->c, &s->block_state[64], 1);
+                crd = get_symbol(&s->c, &s->block_state[96], 1);
+                if (cbd < -255 || cbd > 255 || crd < -255 || crd > 255) {
+                    return AVERROR_INVALIDDATA;
+                }
+                cb += cbd;
+                cr += crd;
             }
         }else{
             if(s->ref_frames > 1)
@@ -228,9 +237,9 @@ static void dequantize_slice_buffered(SnowContext *s, slice_buffer * sb, SubBand
         for(x=0; x<w; x++){
             int i= line[x];
             if(i<0){
-                line[x]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
+                line[x]= -((-i*(unsigned)qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
             }else if(i>0){
-                line[x]=  (( i*qmul + qadd)>>(QEXPSHIFT));
+                line[x]=  (( i*(unsigned)qmul + qadd)>>(QEXPSHIFT));
             }
         }
     }
@@ -355,7 +364,7 @@ static int decode_header(SnowContext *s){
                 Plane *p= &s->plane[plane_index];
                 p->diag_mc= get_rac(&s->c, s->header_state);
                 htaps= get_symbol(&s->c, s->header_state, 0)*2 + 2;
-                if((unsigned)htaps > HTAPS_MAX || htaps==0)
+                if((unsigned)htaps >= HTAPS_MAX || htaps==0)
                     return AVERROR_INVALIDDATA;
                 p->htaps= htaps;
                 for(i= htaps/2; i; i--){
@@ -374,7 +383,7 @@ static int decode_header(SnowContext *s){
         }
     }
 
-    s->spatial_decomposition_type+= get_symbol(&s->c, s->header_state, 1);
+    s->spatial_decomposition_type+= (unsigned)get_symbol(&s->c, s->header_state, 1);
     if(s->spatial_decomposition_type > 1U){
         av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_type %d not supported\n", s->spatial_decomposition_type);
         return AVERROR_INVALIDDATA;
@@ -384,15 +393,25 @@ static int decode_header(SnowContext *s){
         av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_count %d too large for size\n", s->spatial_decomposition_count);
         return AVERROR_INVALIDDATA;
     }
+    if (s->avctx->width > 65536-4) {
+        av_log(s->avctx, AV_LOG_ERROR, "Width %d is too large\n", s->avctx->width);
+        return AVERROR_INVALIDDATA;
+    }
 
 
-    s->qlog           += get_symbol(&s->c, s->header_state, 1);
-    s->mv_scale       += get_symbol(&s->c, s->header_state, 1);
-    s->qbias          += get_symbol(&s->c, s->header_state, 1);
-    s->block_max_depth+= get_symbol(&s->c, s->header_state, 1);
-    if(s->block_max_depth > 1 || s->block_max_depth < 0){
+    s->qlog           += (unsigned)get_symbol(&s->c, s->header_state, 1);
+    s->mv_scale       += (unsigned)get_symbol(&s->c, s->header_state, 1);
+    s->qbias          += (unsigned)get_symbol(&s->c, s->header_state, 1);
+    s->block_max_depth+= (unsigned)get_symbol(&s->c, s->header_state, 1);
+    if(s->block_max_depth > 1 || s->block_max_depth < 0 || s->mv_scale > 256U){
         av_log(s->avctx, AV_LOG_ERROR, "block_max_depth= %d is too large\n", s->block_max_depth);
         s->block_max_depth= 0;
+        s->mv_scale = 0;
+        return AVERROR_INVALIDDATA;
+    }
+    if (FFABS(s->qbias) > 127) {
+        av_log(s->avctx, AV_LOG_ERROR, "qbias %d is too large\n", s->qbias);
+        s->qbias = 0;
         return AVERROR_INVALIDDATA;
     }
 
@@ -418,6 +437,8 @@ static int decode_blocks(SnowContext *s){
 
     for(y=0; y<h; y++){
         for(x=0; x<w; x++){
+            if (s->c.bytestream >= s->c.bytestream_end)
+                return AVERROR_INVALIDDATA;
             if ((res = decode_q_branch(s, 0, x, y)) < 0)
                 return res;
         }
@@ -507,14 +528,12 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
             }
         }
 
-        {
         for(level=0; level<s->spatial_decomposition_count; level++){
             for(orientation=level ? 1 : 0; orientation<4; orientation++){
                 SubBand *b= &p->band[level][orientation];
                 unpack_coeffs(s, b, b->parent, orientation);
             }
         }
-        }
 
         {
         const int mb_h= s->b_height << s->block_max_depth;
@@ -577,7 +596,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                 for(; yq<slice_h && yq<h; yq++){
                     IDWTELEM * line = slice_buffer_get_line(&s->sb, yq);
                     for(x=0; x<w; x++){
-                        line[x] <<= FRAC_BITS;
+                        line[x] *= 1<<FRAC_BITS;
                     }
                 }
             }
diff --git a/mythtv/external/FFmpeg/libavcodec/snowenc.c b/mythtv/external/FFmpeg/libavcodec/snowenc.c
index 5cc7997f5c9..0d800b9f493 100644
--- a/mythtv/external/FFmpeg/libavcodec/snowenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/snowenc.c
@@ -33,8 +33,6 @@
 #include "mpegvideo.h"
 #include "h263.h"
 
-#define FF_ME_ITER 50
-
 static av_cold int encode_init(AVCodecContext *avctx)
 {
     SnowContext *s = avctx->priv_data;
@@ -52,7 +50,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
        && (avctx->flags & AV_CODEC_FLAG_QSCALE)
        && avctx->global_quality == 0){
         av_log(avctx, AV_LOG_ERROR, "The 9/7 wavelet is incompatible with lossless mode.\n");
-        return -1;
+        return AVERROR(EINVAL);
     }
 #if FF_API_MOTION_EST
 FF_DISABLE_DEPRECATION_WARNINGS
@@ -86,6 +84,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
     s->m.avctx   = avctx;
     s->m.bit_rate= avctx->bit_rate;
+    s->m.lmin    = avctx->mb_lmin;
+    s->m.lmax    = avctx->mb_lmax;
 
     s->m.me.temp      =
     s->m.me.scratchpad= av_mallocz_array((avctx->width+64), 2*16*2*sizeof(uint8_t));
@@ -106,11 +106,12 @@ FF_ENABLE_DEPRECATION_WARNINGS
         if (!avctx->stats_out)
             return AVERROR(ENOMEM);
     }
-    if((avctx->flags&AV_CODEC_FLAG_PASS2) || !(avctx->flags&CODEC_FLAG_QSCALE)){
-        if(ff_rate_control_init(&s->m) < 0)
-            return -1;
+    if((avctx->flags&AV_CODEC_FLAG_PASS2) || !(avctx->flags&AV_CODEC_FLAG_QSCALE)){
+        ret = ff_rate_control_init(&s->m);
+        if(ret < 0)
+            return ret;
     }
-    s->pass1_rc= !(avctx->flags & (AV_CODEC_FLAG_QSCALE|CODEC_FLAG_PASS2));
+    s->pass1_rc= !(avctx->flags & (AV_CODEC_FLAG_QSCALE|AV_CODEC_FLAG_PASS2));
 
     switch(avctx->pix_fmt){
     case AV_PIX_FMT_YUV444P:
@@ -130,7 +131,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
         break;*/
     default:
         av_log(avctx, AV_LOG_ERROR, "pixel format not supported\n");
-        return -1;
+        return AVERROR_PATCHWELCOME;
     }
     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 
@@ -833,7 +834,7 @@ static int encode_subband_c0run(SnowContext *s, SubBand *b, const IDWTELEM *src,
         for(y=0; y<h; y++){
             if(s->c.bytestream_end - s->c.bytestream < w*40){
                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
-                return -1;
+                return AVERROR(ENOMEM);
             }
             for(x=0; x<w; x++){
                 int v, p=0;
@@ -1644,8 +1645,12 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     }
 
     ff_snow_frame_start(s);
+#if FF_API_CODED_FRAME
+FF_DISABLE_DEPRECATION_WARNINGS
     av_frame_unref(avctx->coded_frame);
     ret = av_frame_ref(avctx->coded_frame, s->current_picture);
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
     if (ret < 0)
         return ret;
 
@@ -1675,7 +1680,9 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
         s->m.f_code=1;
         s->m.pict_type = pic->pict_type;
 #if FF_API_MOTION_EST
+FF_DISABLE_DEPRECATION_WARNINGS
         s->m.me_method= s->avctx->me_method;
+FF_ENABLE_DEPRECATION_WARNINGS
 #endif
         s->m.motion_est= s->motion_est;
         s->m.me.scene_change_score=0;
@@ -1878,10 +1885,14 @@ FF_ENABLE_DEPRECATION_WARNINGS
     if(avctx->flags&AV_CODEC_FLAG_PASS1)
         ff_write_pass1_stats(&s->m);
     s->m.last_pict_type = s->m.pict_type;
+#if FF_API_STAT_BITS
+FF_DISABLE_DEPRECATION_WARNINGS
     avctx->frame_bits = s->m.frame_bits;
     avctx->mv_bits = s->m.mv_bits;
     avctx->misc_bits = s->m.misc_bits;
     avctx->p_tex_bits = s->m.p_tex_bits;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
 
     emms_c();
 
@@ -1919,8 +1930,11 @@ static av_cold int encode_end(AVCodecContext *avctx)
 #define OFFSET(x) offsetof(SnowContext, x)
 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 static const AVOption options[] = {
-    FF_MPV_COMMON_OPTS
-    { "iter",           NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ITER }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" },
+    {"motion_est", "motion estimation algorithm", OFFSET(motion_est), AV_OPT_TYPE_INT, {.i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_ITER, VE, "motion_est" },
+    { "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, VE, "motion_est" },
+    { "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, VE, "motion_est" },
+    { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, VE, "motion_est" },
+    { "iter", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ITER }, 0, 0, VE, "motion_est" },
     { "memc_only",      "Only do ME/MC (I frames -> ref, P frame -> ME+MC).",   OFFSET(memc_only), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
     { "no_bitstream",   "Skip final bitstream writeout.",                    OFFSET(no_bitstream), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
     { "intra_penalty",  "Penalty for intra blocks in block decission",      OFFSET(intra_penalty), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
diff --git a/mythtv/external/FFmpeg/libavcodec/speedhq.c b/mythtv/external/FFmpeg/libavcodec/speedhq.c
new file mode 100644
index 00000000000..6d3487ca19b
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/speedhq.c
@@ -0,0 +1,690 @@
+/*
+ * NewTek SpeedHQ codec
+ * Copyright 2017 Steinar H. Gunderson
+ *
+ * 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
+ * NewTek SpeedHQ decoder.
+ */
+
+#define BITSTREAM_READER_LE
+
+#include "libavutil/attributes.h"
+
+#include "avcodec.h"
+#include "get_bits.h"
+#include "internal.h"
+#include "libavutil/thread.h"
+#include "mathops.h"
+#include "mpeg12.h"
+#include "mpeg12data.h"
+#include "mpeg12vlc.h"
+
+#define MAX_INDEX (64 - 1)
+
+/*
+ * 5 bits makes for very small tables, with no more than two lookups needed
+ * for the longest (10-bit) codes.
+ */
+#define ALPHA_VLC_BITS 5
+
+typedef struct SHQContext {
+    AVCodecContext *avctx;
+    BlockDSPContext bdsp;
+    IDCTDSPContext idsp;
+    ScanTable intra_scantable;
+    int quant_matrix[64];
+    enum { SHQ_SUBSAMPLING_420, SHQ_SUBSAMPLING_422, SHQ_SUBSAMPLING_444 }
+        subsampling;
+    enum { SHQ_NO_ALPHA, SHQ_RLE_ALPHA, SHQ_DCT_ALPHA } alpha_type;
+} SHQContext;
+
+
+/* AC codes: Very similar but not identical to MPEG-2. */
+static uint16_t speedhq_vlc[123][2] = {
+    {0x02, 2}, {0x06, 3}, {0x07, 4}, {0x1c, 5},
+    {0x1d, 5}, {0x05, 6}, {0x04, 6}, {0x7b, 7},
+    {0x7c, 7}, {0x23, 8}, {0x22, 8}, {0xfa, 8},
+    {0xfb, 8}, {0xfe, 8}, {0xff, 8}, {0x1f,14},
+    {0x1e,14}, {0x1d,14}, {0x1c,14}, {0x1b,14},
+    {0x1a,14}, {0x19,14}, {0x18,14}, {0x17,14},
+    {0x16,14}, {0x15,14}, {0x14,14}, {0x13,14},
+    {0x12,14}, {0x11,14}, {0x10,14}, {0x18,15},
+    {0x17,15}, {0x16,15}, {0x15,15}, {0x14,15},
+    {0x13,15}, {0x12,15}, {0x11,15}, {0x10,15},
+    {0x02, 3}, {0x06, 5}, {0x79, 7}, {0x27, 8},
+    {0x20, 8}, {0x16,13}, {0x15,13}, {0x1f,15},
+    {0x1e,15}, {0x1d,15}, {0x1c,15}, {0x1b,15},
+    {0x1a,15}, {0x19,15}, {0x13,16}, {0x12,16},
+    {0x11,16}, {0x10,16}, {0x18,13}, {0x17,13},
+    {0x05, 5}, {0x07, 7}, {0xfc, 8}, {0x0c,10},
+    {0x14,13}, {0x18,12}, {0x14,12}, {0x13,12},
+    {0x10,12}, {0x1a,13}, {0x19,13}, {0x07, 5},
+    {0x26, 8}, {0x1c,12}, {0x13,13}, {0x1b,12},
+    {0x06, 6}, {0xfd, 8}, {0x12,12}, {0x1d,12},
+    {0x07, 6}, {0x04, 9}, {0x12,13}, {0x06, 7},
+    {0x1e,12}, {0x14,16}, {0x04, 7}, {0x15,12},
+    {0x05, 7}, {0x11,12}, {0x78, 7}, {0x11,13},
+    {0x7a, 7}, {0x10,13}, {0x21, 8}, {0x1a,16},
+    {0x25, 8}, {0x19,16}, {0x24, 8}, {0x18,16},
+    {0x05, 9}, {0x17,16}, {0x07, 9}, {0x16,16},
+    {0x0d,10}, {0x15,16}, {0x1f,12}, {0x1a,12},
+    {0x19,12}, {0x17,12}, {0x16,12}, {0x1f,13},
+    {0x1e,13}, {0x1d,13}, {0x1c,13}, {0x1b,13},
+    {0x1f,16}, {0x1e,16}, {0x1d,16}, {0x1c,16},
+    {0x1b,16},
+    {0x01,6}, /* escape */
+    {0x06,4}, /* EOB */
+};
+
+static const uint8_t speedhq_level[121] = {
+     1,  2,  3,  4,  5,  6,  7,  8,
+     9, 10, 11, 12, 13, 14, 15, 16,
+    17, 18, 19, 20, 21, 22, 23, 24,
+    25, 26, 27, 28, 29, 30, 31, 32,
+    33, 34, 35, 36, 37, 38, 39, 40,
+     1,  2,  3,  4,  5,  6,  7,  8,
+     9, 10, 11, 12, 13, 14, 15, 16,
+    17, 18, 19, 20,  1,  2,  3,  4,
+     5,  6,  7,  8,  9, 10, 11,  1,
+     2,  3,  4,  5,  1,  2,  3,  4,
+     1,  2,  3,  1,  2,  3,  1,  2,
+     1,  2,  1,  2,  1,  2,  1,  2,
+     1,  2,  1,  2,  1,  2,  1,  2,
+     1,  2,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,
+};
+
+static const uint8_t speedhq_run[121] = {
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  1,  1,  1,  1,
+     1,  1,  1,  1,  2,  2,  2,  2,
+     2,  2,  2,  2,  2,  2,  2,  3,
+     3,  3,  3,  3,  4,  4,  4,  4,
+     5,  5,  5,  6,  6,  6,  7,  7,
+     8,  8,  9,  9, 10, 10, 11, 11,
+    12, 12, 13, 13, 14, 14, 15, 15,
+    16, 16, 17, 18, 19, 20, 21, 22,
+    23, 24, 25, 26, 27, 28, 29, 30,
+    31,
+};
+
+static RLTable ff_rl_speedhq = {
+    121,
+    121,
+    (const uint16_t (*)[])speedhq_vlc,
+    speedhq_run,
+    speedhq_level,
+};
+
+/* NOTE: The first element is always 16, unscaled. */
+static const uint8_t unscaled_quant_matrix[64] = {
+    16, 16, 19, 22, 26, 27, 29, 34,
+    16, 16, 22, 24, 27, 29, 34, 37,
+    19, 22, 26, 27, 29, 34, 34, 38,
+    22, 22, 26, 27, 29, 34, 37, 40,
+    22, 26, 27, 29, 32, 35, 40, 48,
+    26, 27, 29, 32, 35, 40, 48, 58,
+    26, 27, 29, 34, 38, 46, 56, 69,
+    27, 29, 35, 38, 46, 56, 69, 83
+};
+
+static uint8_t ff_speedhq_static_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
+
+static VLC ff_dc_lum_vlc_le;
+static VLC ff_dc_chroma_vlc_le;
+static VLC ff_dc_alpha_run_vlc_le;
+static VLC ff_dc_alpha_level_vlc_le;
+
+static inline int decode_dc_le(GetBitContext *gb, int component)
+{
+    int code, diff;
+
+    if (component == 0 || component == 3) {
+        code = get_vlc2(gb, ff_dc_lum_vlc_le.table, DC_VLC_BITS, 2);
+    } else {
+        code = get_vlc2(gb, ff_dc_chroma_vlc_le.table, DC_VLC_BITS, 2);
+    }
+    if (code < 0) {
+        av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
+        return 0xffff;
+    }
+    if (!code) {
+        diff = 0;
+    } else {
+        diff = get_xbits_le(gb, code);
+    }
+    return diff;
+}
+
+static inline int decode_alpha_block(const SHQContext *s, GetBitContext *gb, uint8_t last_alpha[16], uint8_t *dest, int linesize)
+{
+    uint8_t block[128];
+    int i = 0, x, y;
+
+    memset(block, 0, sizeof(block));
+
+    {
+        OPEN_READER(re, gb);
+
+        for ( ;; ) {
+            int run, level;
+
+            UPDATE_CACHE_LE(re, gb);
+            GET_VLC(run, re, gb, ff_dc_alpha_run_vlc_le.table, ALPHA_VLC_BITS, 2);
+
+            if (run < 0) break;
+            i += run;
+            if (i >= 128)
+                return AVERROR_INVALIDDATA;
+
+            UPDATE_CACHE_LE(re, gb);
+            GET_VLC(level, re, gb, ff_dc_alpha_level_vlc_le.table, ALPHA_VLC_BITS, 2);
+            block[i++] = level;
+        }
+
+        CLOSE_READER(re, gb);
+    }
+
+    for (y = 0; y < 8; y++) {
+        for (x = 0; x < 16; x++) {
+            last_alpha[x] -= block[y * 16 + x];
+        }
+        memcpy(dest, last_alpha, 16);
+        dest += linesize;
+    }
+
+    return 0;
+}
+
+static inline int decode_dct_block(const SHQContext *s, GetBitContext *gb, int last_dc[4], int component, uint8_t *dest, int linesize)
+{
+    const int *quant_matrix = s->quant_matrix;
+    const uint8_t *scantable = s->intra_scantable.permutated;
+    LOCAL_ALIGNED_32(int16_t, block, [64]);
+    int dc_offset;
+
+    s->bdsp.clear_block(block);
+
+    dc_offset = decode_dc_le(gb, component);
+    last_dc[component] -= dc_offset;  /* Note: Opposite of most codecs. */
+    block[scantable[0]] = last_dc[component];  /* quant_matrix[0] is always 16. */
+
+    /* Read AC coefficients. */
+    {
+        int i = 0;
+        OPEN_READER(re, gb);
+        for ( ;; ) {
+            int level, run;
+            UPDATE_CACHE_LE(re, gb);
+            GET_RL_VLC(level, run, re, gb, ff_rl_speedhq.rl_vlc[0],
+                       TEX_VLC_BITS, 2, 0);
+            if (level == 127) {
+                break;
+            } else if (level) {
+                i += run;
+                if (i > MAX_INDEX)
+                    return AVERROR_INVALIDDATA;
+                /* If next bit is 1, level = -level */
+                level = (level ^ SHOW_SBITS(re, gb, 1)) -
+                        SHOW_SBITS(re, gb, 1);
+                LAST_SKIP_BITS(re, gb, 1);
+            } else {
+                /* Escape. */
+#if MIN_CACHE_BITS < 6 + 6 + 12
+#error MIN_CACHE_BITS is too small for the escape code, add UPDATE_CACHE
+#endif
+                run = SHOW_UBITS(re, gb, 6) + 1;
+                SKIP_BITS(re, gb, 6);
+                level = SHOW_UBITS(re, gb, 12) - 2048;
+                LAST_SKIP_BITS(re, gb, 12);
+
+                i += run;
+                if (i > MAX_INDEX)
+                    return AVERROR_INVALIDDATA;
+            }
+
+            block[scantable[i]] = (level * quant_matrix[i]) >> 4;
+        }
+        CLOSE_READER(re, gb);
+    }
+
+    s->idsp.idct_put(dest, linesize, block);
+
+    return 0;
+}
+
+static int decode_speedhq_field(const SHQContext *s, const uint8_t *buf, int buf_size, AVFrame *frame, int field_number, int start, int end, int line_stride)
+{
+    int ret, slice_number, slice_offsets[5];
+    int linesize_y  = frame->linesize[0] * line_stride;
+    int linesize_cb = frame->linesize[1] * line_stride;
+    int linesize_cr = frame->linesize[2] * line_stride;
+    int linesize_a;
+
+    if (s->alpha_type != SHQ_NO_ALPHA)
+        linesize_a = frame->linesize[3] * line_stride;
+
+    if (end < start || end - start < 3 || end > buf_size)
+        return AVERROR_INVALIDDATA;
+
+    slice_offsets[0] = start;
+    slice_offsets[4] = end;
+    for (slice_number = 1; slice_number < 4; slice_number++) {
+        uint32_t last_offset, slice_len;
+
+        last_offset = slice_offsets[slice_number - 1];
+        slice_len = AV_RL24(buf + last_offset);
+        slice_offsets[slice_number] = last_offset + slice_len;
+
+        if (slice_len < 3 || slice_offsets[slice_number] > end - 3)
+            return AVERROR_INVALIDDATA;
+    }
+
+    for (slice_number = 0; slice_number < 4; slice_number++) {
+        GetBitContext gb;
+        uint32_t slice_begin, slice_end;
+        int x, y;
+
+        slice_begin = slice_offsets[slice_number];
+        slice_end = slice_offsets[slice_number + 1];
+
+        if ((ret = init_get_bits8(&gb, buf + slice_begin + 3, slice_end - slice_begin - 3)) < 0)
+            return ret;
+
+        for (y = slice_number * 16 * line_stride; y < frame->height; y += line_stride * 64) {
+            uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
+            int last_dc[4] = { 1024, 1024, 1024, 1024 };
+            uint8_t last_alpha[16];
+
+            memset(last_alpha, 255, sizeof(last_alpha));
+
+            dest_y = frame->data[0] + frame->linesize[0] * (y + field_number);
+            if (s->subsampling == SHQ_SUBSAMPLING_420) {
+                dest_cb = frame->data[1] + frame->linesize[1] * (y/2 + field_number);
+                dest_cr = frame->data[2] + frame->linesize[2] * (y/2 + field_number);
+            } else {
+                dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number);
+                dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number);
+            }
+            if (s->alpha_type != SHQ_NO_ALPHA) {
+                dest_a = frame->data[3] + frame->linesize[3] * (y + field_number);
+            }
+
+            for (x = 0; x < frame->width; x += 16) {
+                /* Decode the four luma blocks. */
+                if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y, linesize_y)) < 0)
+                    return ret;
+                if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
+                    return ret;
+                if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
+                    return ret;
+                if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
+                    return ret;
+
+                /*
+                 * Decode the first chroma block. For 4:2:0, this is the only one;
+                 * for 4:2:2, it's the top block; for 4:4:4, it's the top-left block.
+                 */
+                if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
+                    return ret;
+                if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
+                    return ret;
+
+                if (s->subsampling != SHQ_SUBSAMPLING_420) {
+                    /* For 4:2:2, this is the bottom block; for 4:4:4, it's the bottom-left block. */
+                    if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
+                        return ret;
+                    if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
+                        return ret;
+
+                    if (s->subsampling == SHQ_SUBSAMPLING_444) {
+                        /* Top-right and bottom-right blocks. */
+                        if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8, linesize_cb)) < 0)
+                            return ret;
+                        if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8, linesize_cr)) < 0)
+                            return ret;
+                        if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb + 8, linesize_cb)) < 0)
+                            return ret;
+                        if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr + 8, linesize_cr)) < 0)
+                            return ret;
+
+                        dest_cb += 8;
+                        dest_cr += 8;
+                    }
+                }
+                dest_y += 16;
+                dest_cb += 8;
+                dest_cr += 8;
+
+                if (s->alpha_type == SHQ_RLE_ALPHA) {
+                    /* Alpha coded using 16x8 RLE blocks. */
+                    if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a, linesize_a)) < 0)
+                        return ret;
+                    if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
+                        return ret;
+                    dest_a += 16;
+                } else if (s->alpha_type == SHQ_DCT_ALPHA) {
+                    /* Alpha encoded exactly like luma. */
+                    if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a, linesize_a)) < 0)
+                        return ret;
+                    if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8, linesize_a)) < 0)
+                        return ret;
+                    if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
+                        return ret;
+                    if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
+                        return ret;
+                    dest_a += 16;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static void compute_quant_matrix(int *output, int qscale)
+{
+    int i;
+    for (i = 0; i < 64; i++) output[i] = unscaled_quant_matrix[ff_zigzag_direct[i]] * qscale;
+}
+
+static int speedhq_decode_frame(AVCodecContext *avctx,
+                                void *data, int *got_frame,
+                                AVPacket *avpkt)
+{
+    SHQContext * const s = avctx->priv_data;
+    const uint8_t *buf   = avpkt->data;
+    int buf_size         = avpkt->size;
+    AVFrame *frame       = data;
+    uint8_t quality;
+    uint32_t second_field_offset;
+    int ret;
+
+    if (buf_size < 4)
+        return AVERROR_INVALIDDATA;
+
+    quality = buf[0];
+    if (quality >= 100) {
+        return AVERROR_INVALIDDATA;
+    }
+
+    compute_quant_matrix(s->quant_matrix, 100 - quality);
+
+    second_field_offset = AV_RL24(buf + 1);
+    if (second_field_offset >= buf_size - 3) {
+        return AVERROR_INVALIDDATA;
+    }
+
+    avctx->coded_width = FFALIGN(avctx->width, 16);
+    avctx->coded_height = FFALIGN(avctx->height, 16);
+
+    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
+        return ret;
+    }
+    frame->key_frame = 1;
+
+    if (second_field_offset == 4) {
+        /*
+         * Overlapping first and second fields is used to signal
+         * encoding only a single field. In this case, "height"
+         * is ambiguous; it could mean either the height of the
+         * frame as a whole, or of the field. The former would make
+         * more sense for compatibility with legacy decoders,
+         * but this matches the convention used in NDI, which is
+         * the primary user of this trick.
+         */
+        if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, buf_size, 1)) < 0)
+            return ret;
+    } else {
+        if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, second_field_offset, 2)) < 0)
+            return ret;
+        if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 1, second_field_offset, buf_size, 2)) < 0)
+            return ret;
+    }
+
+    *got_frame = 1;
+    return buf_size;
+}
+
+/*
+ * Alpha VLC. Run and level are independently coded, and would be
+ * outside the default limits for MAX_RUN/MAX_LEVEL, so we don't
+ * bother with combining them into one table.
+ */
+static av_cold void compute_alpha_vlcs(void)
+{
+    uint16_t run_code[134], level_code[266];
+    uint8_t run_bits[134], level_bits[266];
+    int16_t run_symbols[134], level_symbols[266];
+    int entry, i, sign;
+
+    /* Initialize VLC for alpha run. */
+    entry = 0;
+
+    /* 0 -> 0. */
+    run_code[entry] = 0;
+    run_bits[entry] = 1;
+    run_symbols[entry] = 0;
+    ++entry;
+
+    /* 10xx -> xx plus 1. */
+    for (i = 0; i < 4; ++i) {
+        run_code[entry] = (i << 2) | 1;
+        run_bits[entry] = 4;
+        run_symbols[entry] = i + 1;
+        ++entry;
+    }
+
+    /* 111xxxxxxx -> xxxxxxx. */
+    for (i = 0; i < 128; ++i) {
+        run_code[entry] = (i << 3) | 7;
+        run_bits[entry] = 10;
+        run_symbols[entry] = i;
+        ++entry;
+    }
+
+    /* 110 -> EOB. */
+    run_code[entry] = 3;
+    run_bits[entry] = 3;
+    run_symbols[entry] = -1;
+    ++entry;
+
+    av_assert0(entry == FF_ARRAY_ELEMS(run_code));
+
+    INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_run_vlc_le, ALPHA_VLC_BITS,
+                              FF_ARRAY_ELEMS(run_code),
+                              run_bits, 1, 1,
+                              run_code, 2, 2,
+                              run_symbols, 2, 2, 160);
+
+    /* Initialize VLC for alpha level. */
+    entry = 0;
+
+    for (sign = 0; sign <= 1; ++sign) {
+        /* 1s -> -1 or +1 (depending on sign bit). */
+        level_code[entry] = (sign << 1) | 1;
+        level_bits[entry] = 2;
+        level_symbols[entry] = sign ? -1 : 1;
+        ++entry;
+
+        /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
+        for (i = 0; i < 4; ++i) {
+            level_code[entry] = (i << 3) | (sign << 2) | 2;
+            level_bits[entry] = 5;
+            level_symbols[entry] = sign ? -(i + 2) : (i + 2);
+            ++entry;
+        }
+    }
+
+    /*
+     * 00xxxxxxxx -> xxxxxxxx, in two's complement. There are many codes
+     * here that would better be encoded in other ways (e.g. 0 would be
+     * encoded by increasing run, and +/- 1 would be encoded with a
+     * shorter code), but it doesn't hurt to allow everything.
+     */
+    for (i = 0; i < 256; ++i) {
+        level_code[entry] = i << 2;
+        level_bits[entry] = 10;
+        level_symbols[entry] = i;
+        ++entry;
+    }
+
+    av_assert0(entry == FF_ARRAY_ELEMS(level_code));
+
+    INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_level_vlc_le, ALPHA_VLC_BITS,
+                              FF_ARRAY_ELEMS(level_code),
+                              level_bits, 1, 1,
+                              level_code, 2, 2,
+                              level_symbols, 2, 2, 288);
+}
+
+static uint32_t reverse(uint32_t num, int bits)
+{
+    return bitswap_32(num) >> (32 - bits);
+}
+
+static void reverse_code(const uint16_t *code, const uint8_t *bits,
+                         uint16_t *reversed_code, int num_entries)
+{
+    int i;
+    for (i = 0; i < num_entries; i++) {
+        reversed_code[i] = reverse(code[i], bits[i]);
+    }
+}
+
+static av_cold void speedhq_static_init(void)
+{
+    uint16_t ff_mpeg12_vlc_dc_lum_code_reversed[12];
+    uint16_t ff_mpeg12_vlc_dc_chroma_code_reversed[12];
+    int i;
+
+    /* Exactly the same as MPEG-2, except little-endian. */
+    reverse_code(ff_mpeg12_vlc_dc_lum_code,
+                 ff_mpeg12_vlc_dc_lum_bits,
+                 ff_mpeg12_vlc_dc_lum_code_reversed,
+                 12);
+    INIT_LE_VLC_STATIC(&ff_dc_lum_vlc_le, DC_VLC_BITS, 12,
+                       ff_mpeg12_vlc_dc_lum_bits, 1, 1,
+                       ff_mpeg12_vlc_dc_lum_code_reversed, 2, 2, 512);
+    reverse_code(ff_mpeg12_vlc_dc_chroma_code,
+                 ff_mpeg12_vlc_dc_chroma_bits,
+                 ff_mpeg12_vlc_dc_chroma_code_reversed,
+                 12);
+    INIT_LE_VLC_STATIC(&ff_dc_chroma_vlc_le, DC_VLC_BITS, 12,
+                       ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
+                       ff_mpeg12_vlc_dc_chroma_code_reversed, 2, 2, 514);
+
+    /* Reverse the AC VLC, because INIT_VLC_LE wants it in that order. */
+    for (i = 0; i < FF_ARRAY_ELEMS(speedhq_vlc); ++i) {
+        speedhq_vlc[i][0] = reverse(speedhq_vlc[i][0], speedhq_vlc[i][1]);
+    }
+    ff_rl_init(&ff_rl_speedhq, ff_speedhq_static_rl_table_store);
+    INIT_2D_VLC_RL(ff_rl_speedhq, 674, INIT_VLC_LE);
+
+    compute_alpha_vlcs();
+}
+
+static av_cold int speedhq_decode_init(AVCodecContext *avctx)
+{
+    int ret;
+    static AVOnce init_once = AV_ONCE_INIT;
+    SHQContext * const s = avctx->priv_data;
+
+    s->avctx = avctx;
+
+    ret = ff_thread_once(&init_once, speedhq_static_init);
+    if (ret)
+        return AVERROR_UNKNOWN;
+
+    ff_blockdsp_init(&s->bdsp, avctx);
+    ff_idctdsp_init(&s->idsp, avctx);
+    ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
+
+    switch (avctx->codec_tag) {
+    case MKTAG('S', 'H', 'Q', '0'):
+        s->subsampling = SHQ_SUBSAMPLING_420;
+        s->alpha_type = SHQ_NO_ALPHA;
+        avctx->pix_fmt = AV_PIX_FMT_YUV420P;
+        break;
+    case MKTAG('S', 'H', 'Q', '1'):
+        s->subsampling = SHQ_SUBSAMPLING_420;
+        s->alpha_type = SHQ_RLE_ALPHA;
+        avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
+        break;
+    case MKTAG('S', 'H', 'Q', '2'):
+        s->subsampling = SHQ_SUBSAMPLING_422;
+        s->alpha_type = SHQ_NO_ALPHA;
+        avctx->pix_fmt = AV_PIX_FMT_YUV422P;
+        break;
+    case MKTAG('S', 'H', 'Q', '3'):
+        s->subsampling = SHQ_SUBSAMPLING_422;
+        s->alpha_type = SHQ_RLE_ALPHA;
+        avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
+        break;
+    case MKTAG('S', 'H', 'Q', '4'):
+        s->subsampling = SHQ_SUBSAMPLING_444;
+        s->alpha_type = SHQ_NO_ALPHA;
+        avctx->pix_fmt = AV_PIX_FMT_YUV444P;
+        break;
+    case MKTAG('S', 'H', 'Q', '5'):
+        s->subsampling = SHQ_SUBSAMPLING_444;
+        s->alpha_type = SHQ_RLE_ALPHA;
+        avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
+        break;
+    case MKTAG('S', 'H', 'Q', '7'):
+        s->subsampling = SHQ_SUBSAMPLING_422;
+        s->alpha_type = SHQ_DCT_ALPHA;
+        avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
+        break;
+    case MKTAG('S', 'H', 'Q', '9'):
+        s->subsampling = SHQ_SUBSAMPLING_444;
+        s->alpha_type = SHQ_DCT_ALPHA;
+        avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
+        break;
+    default:
+        av_log(avctx, AV_LOG_ERROR, "Unknown NewTek SpeedHQ FOURCC provided (%08X)\n",
+               avctx->codec_tag);
+        return AVERROR_INVALIDDATA;
+    }
+
+    /* This matches what NDI's RGB -> Y'CbCr 4:2:2 converter uses. */
+    avctx->colorspace = AVCOL_SPC_BT470BG;
+    avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
+
+    return 0;
+}
+
+AVCodec ff_speedhq_decoder = {
+    .name           = "speedhq",
+    .long_name      = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_SPEEDHQ,
+    .priv_data_size = sizeof(SHQContext),
+    .init           = speedhq_decode_init,
+    .decode         = speedhq_decode_frame,
+    .capabilities   = AV_CODEC_CAP_DR1,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/srtdec.c b/mythtv/external/FFmpeg/libavcodec/srtdec.c
index 30930c8e740..ecc08015954 100644
--- a/mythtv/external/FFmpeg/libavcodec/srtdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/srtdec.c
@@ -27,7 +27,7 @@
 #include "ass.h"
 #include "htmlsubtitles.h"
 
-static void srt_to_ass(AVCodecContext *avctx, AVBPrint *dst,
+static int srt_to_ass(AVCodecContext *avctx, AVBPrint *dst,
                        const char *in, int x1, int y1, int x2, int y2)
 {
     if (x1 >= 0 && y1 >= 0) {
@@ -38,18 +38,18 @@ static void srt_to_ass(AVCodecContext *avctx, AVBPrint *dst,
             /* text rectangle defined, write the text at the center of the rectangle */
             const int cx = x1 + (x2 - x1)/2;
             const int cy = y1 + (y2 - y1)/2;
-            const int scaled_x = cx * ASS_DEFAULT_PLAYRESX / 720;
-            const int scaled_y = cy * ASS_DEFAULT_PLAYRESY / 480;
+            const int scaled_x = cx * (int64_t)ASS_DEFAULT_PLAYRESX / 720;
+            const int scaled_y = cy * (int64_t)ASS_DEFAULT_PLAYRESY / 480;
             av_bprintf(dst, "{\\an5}{\\pos(%d,%d)}", scaled_x, scaled_y);
         } else {
             /* only the top left corner, assume the text starts in that corner */
-            const int scaled_x = x1 * ASS_DEFAULT_PLAYRESX / 720;
-            const int scaled_y = y1 * ASS_DEFAULT_PLAYRESY / 480;
+            const int scaled_x = x1 * (int64_t)ASS_DEFAULT_PLAYRESX / 720;
+            const int scaled_y = y1 * (int64_t)ASS_DEFAULT_PLAYRESY / 480;
             av_bprintf(dst, "{\\an1}{\\pos(%d,%d)}", scaled_x, scaled_y);
         }
     }
 
-    ff_htmlmarkup_to_ass(avctx, dst, in);
+    return ff_htmlmarkup_to_ass(avctx, dst, in);
 }
 
 static int srt_decode_frame(AVCodecContext *avctx,
@@ -74,8 +74,9 @@ static int srt_decode_frame(AVCodecContext *avctx,
 
     av_bprint_init(&buffer, 0, AV_BPRINT_SIZE_UNLIMITED);
 
-    srt_to_ass(avctx, &buffer, avpkt->data, x1, y1, x2, y2);
-    ret = ff_ass_add_rect(sub, buffer.str, s->readorder++, 0, NULL, NULL);
+    ret = srt_to_ass(avctx, &buffer, avpkt->data, x1, y1, x2, y2);
+    if (ret >= 0)
+        ret = ff_ass_add_rect(sub, buffer.str, s->readorder++, 0, NULL, NULL);
     av_bprint_finalize(&buffer, NULL);
     if (ret < 0)
         return ret;
diff --git a/mythtv/external/FFmpeg/libavcodec/sunrast.c b/mythtv/external/FFmpeg/libavcodec/sunrast.c
index 25e11f6cd21..0af5626e351 100644
--- a/mythtv/external/FFmpeg/libavcodec/sunrast.c
+++ b/mythtv/external/FFmpeg/libavcodec/sunrast.c
@@ -168,7 +168,7 @@ static int sunrast_decode_frame(AVCodecContext *avctx, void *data,
         }
     } else {
         for (y = 0; y < h; y++) {
-            if (buf_end - buf < len)
+            if (buf_end - buf < alen)
                 break;
             memcpy(ptr, buf, len);
             ptr += stride;
diff --git a/mythtv/external/FFmpeg/libavcodec/svq1dec.c b/mythtv/external/FFmpeg/libavcodec/svq1dec.c
index 2b72e08d3ab..d3e60c3a4ab 100644
--- a/mythtv/external/FFmpeg/libavcodec/svq1dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/svq1dec.c
@@ -154,7 +154,7 @@ static const uint8_t string_table[256] = {
     n4    = (mean << 16) + mean;
 
 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
-                                   int pitch)
+                                   ptrdiff_t pitch)
 {
     uint32_t bit_cache;
     uint8_t *list[63];
@@ -221,7 +221,7 @@ static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
 }
 
 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
-                                       int pitch)
+                                       ptrdiff_t pitch)
 {
     uint32_t bit_cache;
     uint8_t *list[63];
@@ -307,7 +307,7 @@ static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
 }
 
 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
-                            int pitch, int x, int y)
+                            ptrdiff_t pitch, int x, int y)
 {
     uint8_t *src;
     uint8_t *dst;
@@ -325,7 +325,7 @@ static void svq1_skip_block(uint8_t *current, uint8_t *previous,
 
 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
                                    uint8_t *current, uint8_t *previous,
-                                   int pitch, svq1_pmv *motion, int x, int y,
+                                   ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
                                    int width, int height)
 {
     uint8_t *src;
@@ -368,7 +368,7 @@ static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
 
 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
                                       uint8_t *current, uint8_t *previous,
-                                      int pitch, svq1_pmv *motion, int x, int y,
+                                      ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
                                       int width, int height)
 {
     uint8_t *src;
@@ -446,7 +446,7 @@ static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbu
 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
                                    GetBitContext *bitbuf,
                                    uint8_t *current, uint8_t *previous,
-                                   int pitch, svq1_pmv *motion, int x, int y,
+                                   ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
                                    int width, int height)
 {
     uint32_t block_type;
diff --git a/mythtv/external/FFmpeg/libavcodec/svq3.c b/mythtv/external/FFmpeg/libavcodec/svq3.c
index 5aedc1e6577..a937b2f9513 100644
--- a/mythtv/external/FFmpeg/libavcodec/svq3.c
+++ b/mythtv/external/FFmpeg/libavcodec/svq3.c
@@ -223,7 +223,7 @@ static int svq3_decode_end(AVCodecContext *avctx);
 
 static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
 {
-    const int qmul = svq3_dequant_coeff[qp];
+    const unsigned qmul = svq3_dequant_coeff[qp];
 #define stride 16
     int i;
     int temp[16];
@@ -248,10 +248,10 @@ static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
         const int z2     =  7 *  temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
         const int z3     = 17 *  temp[4 * 1 + i] +  7 * temp[4 * 3 + i];
 
-        output[stride *  0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
-        output[stride *  2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
-        output[stride *  8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
-        output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
+        output[stride *  0 + offset] = (int)((z0 + z3) * qmul + 0x80000) >> 20;
+        output[stride *  2 + offset] = (int)((z1 + z2) * qmul + 0x80000) >> 20;
+        output[stride *  8 + offset] = (int)((z1 - z2) * qmul + 0x80000) >> 20;
+        output[stride * 10 + offset] = (int)((z0 - z3) * qmul + 0x80000) >> 20;
     }
 }
 #undef stride
@@ -263,7 +263,7 @@ static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
     int i;
 
     if (dc) {
-        dc       = 13 * 13 * (dc == 1 ? 1538 * block[0]
+        dc       = 13 * 13 * (dc == 1 ? 1538U* block[0]
                                       : qmul * (block[0] >> 3) / 2);
         block[0] = 0;
     }
@@ -281,16 +281,16 @@ static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
     }
 
     for (i = 0; i < 4; i++) {
-        const int z0 = 13 * (block[i + 4 * 0] +      block[i + 4 * 2]);
-        const int z1 = 13 * (block[i + 4 * 0] -      block[i + 4 * 2]);
-        const int z2 =  7 *  block[i + 4 * 1] - 17 * block[i + 4 * 3];
-        const int z3 = 17 *  block[i + 4 * 1] +  7 * block[i + 4 * 3];
-        const int rr = (dc + 0x80000);
-
-        dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
-        dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
-        dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
-        dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
+        const unsigned z0 = 13 * (block[i + 4 * 0] +      block[i + 4 * 2]);
+        const unsigned z1 = 13 * (block[i + 4 * 0] -      block[i + 4 * 2]);
+        const unsigned z2 =  7 *  block[i + 4 * 1] - 17 * block[i + 4 * 3];
+        const unsigned z3 = 17 *  block[i + 4 * 1] +  7 * block[i + 4 * 3];
+        const int rr = (dc + 0x80000u);
+
+        dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((int)((z0 + z3) * qmul + rr) >> 20));
+        dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((int)((z1 + z2) * qmul + rr) >> 20));
+        dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((int)((z1 - z2) * qmul + rr) >> 20));
+        dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((int)((z0 - z3) * qmul + rr) >> 20));
     }
 
     memset(block, 0, 16 * sizeof(int16_t));
@@ -524,8 +524,8 @@ static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
             if (mode != PREDICT_MODE) {
                 svq3_pred_motion(s, k, part_width >> 2, dir, 1, &mx, &my);
             } else {
-                mx = s->next_pic->motion_val[0][b_xy][0] << 1;
-                my = s->next_pic->motion_val[0][b_xy][1] << 1;
+                mx = s->next_pic->motion_val[0][b_xy][0] * 2;
+                my = s->next_pic->motion_val[0][b_xy][1] * 2;
 
                 if (dir == 0) {
                     mx = mx * s->frame_num_offset /
@@ -551,7 +551,7 @@ static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
                 dy = get_interleaved_se_golomb(&s->gb_slice);
                 dx = get_interleaved_se_golomb(&s->gb_slice);
 
-                if (dx == INVALID_VLC || dy == INVALID_VLC) {
+                if (dx != (int16_t)dx || dy != (int16_t)dy) {
                     av_log(s->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
                     return -1;
                 }
@@ -562,8 +562,8 @@ static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
                 int fx, fy;
                 mx  = (mx + 1 >> 1) + dx;
                 my  = (my + 1 >> 1) + dy;
-                fx  = (unsigned)(mx + 0x3000) / 3 - 0x1000;
-                fy  = (unsigned)(my + 0x3000) / 3 - 0x1000;
+                fx  = (unsigned)(mx + 0x30000) / 3 - 0x10000;
+                fy  = (unsigned)(my + 0x30000) / 3 - 0x10000;
                 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
 
                 svq3_mc_dir_part(s, x, y, part_width, part_height,
@@ -571,8 +571,8 @@ static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
                 mx += mx;
                 my += my;
             } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
-                mx  = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
-                my  = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
+                mx  = (unsigned)(mx + 1 + 0x30000) / 3 + dx - 0x10000;
+                my  = (unsigned)(my + 1 + 0x30000) / 3 + dy - 0x10000;
                 dxy = (mx & 1) + 2 * (my & 1);
 
                 svq3_mc_dir_part(s, x, y, part_width, part_height,
@@ -580,8 +580,8 @@ static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
                 mx *= 3;
                 my *= 3;
             } else {
-                mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
-                my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
+                mx = (unsigned)(mx + 3 + 0x60000) / 6 + dx - 0x10000;
+                my = (unsigned)(my + 3 + 0x60000) / 6 + dy - 0x10000;
 
                 svq3_mc_dir_part(s, x, y, part_width, part_height,
                                  mx, my, 0, 0, dir, avg);
@@ -629,11 +629,6 @@ static av_always_inline void hl_decode_mb_idct_luma(SVQ3Context *s,
     }
 }
 
-static av_always_inline int dctcoef_get(int16_t *mb, int index)
-{
-    return AV_RN16A(mb + index);
-}
-
 static av_always_inline void hl_decode_mb_predict_luma(SVQ3Context *s,
                                                        int mb_type,
                                                        const int *block_offset,
@@ -1041,17 +1036,16 @@ static int svq3_decode_slice_header(AVCodecContext *avctx)
         slice_bits   = slice_length * 8;
         slice_bytes  = slice_length + length - 1;
 
-        if (8LL*slice_bytes > get_bits_left(&s->gb)) {
-            av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
-            return -1;
-        }
-
         skip_bits(&s->gb, 8);
 
         av_fast_malloc(&s->slice_buf, &s->slice_size, slice_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
         if (!s->slice_buf)
             return AVERROR(ENOMEM);
 
+        if (slice_bytes * 8LL > get_bits_left(&s->gb)) {
+            av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
+            return AVERROR_INVALIDDATA;
+        }
         memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
 
         init_get_bits(&s->gb_slice, s->slice_buf, slice_bits);
@@ -1070,14 +1064,16 @@ static int svq3_decode_slice_header(AVCodecContext *avctx)
         av_log(s->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
         return -1;
     }
+    if (get_bits1(&s->gb_slice)) {
+        avpriv_report_missing_feature(s->avctx, "Media key encryption");
+        return AVERROR_PATCHWELCOME;
+    }
 
     s->slice_type = ff_h264_golomb_to_pict_type[slice_id];
 
     if ((header & 0x9F) == 2) {
-        i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
+        i = (s->mb_num < 64) ? 5 : av_log2(s->mb_num - 1);
         get_bits(&s->gb_slice, i);
-    } else {
-        skip_bits1(&s->gb_slice);
     }
 
     s->slice_num      = get_bits(&s->gb_slice, 8);
@@ -1556,7 +1552,7 @@ static int svq3_decode_frame(AVCodecContext *avctx, void *data,
                         return -1;
                 }
                 if (s->slice_type != s->pict_type) {
-                    avpriv_request_sample(avctx, "non constant slice type\n");
+                    avpriv_request_sample(avctx, "non constant slice type");
                 }
                 /* TODO: support s->mb_skip_run */
             }
diff --git a/mythtv/external/FFmpeg/libavcodec/takdec.c b/mythtv/external/FFmpeg/libavcodec/takdec.c
index 97732813ec5..0439a3ac9b9 100644
--- a/mythtv/external/FFmpeg/libavcodec/takdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/takdec.c
@@ -203,24 +203,24 @@ static void decode_lpc(int32_t *coeffs, int mode, int length)
         return;
 
     if (mode == 1) {
-        int a1 = *coeffs++;
+        unsigned a1 = *coeffs++;
         for (i = 0; i < length - 1 >> 1; i++) {
             *coeffs   += a1;
-            coeffs[1] += *coeffs;
+            coeffs[1] += (unsigned)*coeffs;
             a1         = coeffs[1];
             coeffs    += 2;
         }
         if (length - 1 & 1)
             *coeffs += a1;
     } else if (mode == 2) {
-        int a1    = coeffs[1];
-        int a2    = a1 + *coeffs;
+        unsigned a1    = coeffs[1];
+        unsigned a2    = a1 + *coeffs;
         coeffs[1] = a2;
         if (length > 2) {
             coeffs += 2;
             for (i = 0; i < length - 2 >> 1; i++) {
-                int a3    = *coeffs + a1;
-                int a4    = a3 + a2;
+                unsigned a3    = *coeffs + a1;
+                unsigned a4    = a3 + a2;
                 *coeffs   = a4;
                 a1        = coeffs[1] + a3;
                 a2        = a1 + a4;
@@ -231,13 +231,13 @@ static void decode_lpc(int32_t *coeffs, int mode, int length)
                 *coeffs += a1 + a2;
         }
     } else if (mode == 3) {
-        int a1    = coeffs[1];
-        int a2    = a1 + *coeffs;
+        unsigned a1    = coeffs[1];
+        unsigned a2    = a1 + *coeffs;
         coeffs[1] = a2;
         if (length > 2) {
-            int a3  = coeffs[2];
-            int a4  = a3 + a1;
-            int a5  = a4 + a2;
+            unsigned a3  = coeffs[2];
+            unsigned a4  = a3 + a1;
+            unsigned a5  = a4 + a2;
             coeffs[2] = a5;
             coeffs += 3;
             for (i = 0; i < length - 3; i++) {
@@ -267,11 +267,11 @@ static int decode_segment(TAKDecContext *s, int8_t mode, int32_t *decoded, int l
     code = xcodes[mode - 1];
 
     for (i = 0; i < len; i++) {
-        int x = get_bits_long(gb, code.init);
+        unsigned x = get_bits_long(gb, code.init);
         if (x >= code.escape && get_bits1(gb)) {
             x |= 1 << code.init;
             if (x >= code.aescape) {
-                int scale = get_unary(gb, 1, 9);
+                unsigned scale = get_unary(gb, 1, 9);
                 if (scale == 9) {
                     int scale_bits = get_bits(gb, 3);
                     if (scale_bits > 0) {
@@ -433,31 +433,31 @@ static int decode_subframe(TAKDecContext *s, int32_t *decoded,
 
     s->predictors[0] = get_sbits(gb, 10);
     s->predictors[1] = get_sbits(gb, 10);
-    s->predictors[2] = get_sbits(gb, size) << (10 - size);
-    s->predictors[3] = get_sbits(gb, size) << (10 - size);
+    s->predictors[2] = get_sbits(gb, size) * (1 << (10 - size));
+    s->predictors[3] = get_sbits(gb, size) * (1 << (10 - size));
     if (filter_order > 4) {
         int tmp = size - get_bits1(gb);
 
         for (i = 4; i < filter_order; i++) {
             if (!(i & 3))
                 x = tmp - get_bits(gb, 2);
-            s->predictors[i] = get_sbits(gb, x) << (10 - size);
+            s->predictors[i] = get_sbits(gb, x) * (1 << (10 - size));
         }
     }
 
-    tfilter[0] = s->predictors[0] << 6;
+    tfilter[0] = s->predictors[0] * 64;
     for (i = 1; i < filter_order; i++) {
-        int32_t *p1 = &tfilter[0];
-        int32_t *p2 = &tfilter[i - 1];
+        uint32_t *p1 = &tfilter[0];
+        uint32_t *p2 = &tfilter[i - 1];
 
         for (j = 0; j < (i + 1) / 2; j++) {
-            x     = *p1 + (s->predictors[i] * *p2 + 256 >> 9);
-            *p2  += s->predictors[i] * *p1 + 256 >> 9;
+            x     = *p1 + ((int32_t)(s->predictors[i] * *p2 + 256) >> 9);
+            *p2  += (int32_t)(s->predictors[i] * *p1 + 256) >> 9;
             *p1++ = x;
             p2--;
         }
 
-        tfilter[i] = s->predictors[i] << 6;
+        tfilter[i] = s->predictors[i] * 64;
     }
 
     x = 1 << (32 - (15 - filter_quant));
@@ -483,15 +483,15 @@ static int decode_subframe(TAKDecContext *s, int32_t *decoded,
             int v = 1 << (filter_quant - 1);
 
             if (filter_order & -16)
-                v += s->adsp.scalarproduct_int16(&s->residues[i], s->filter,
+                v += (unsigned)s->adsp.scalarproduct_int16(&s->residues[i], s->filter,
                                                  filter_order & -16);
             for (j = filter_order & -16; j < filter_order; j += 4) {
-                v += s->residues[i + j + 3] * s->filter[j + 3] +
-                     s->residues[i + j + 2] * s->filter[j + 2] +
-                     s->residues[i + j + 1] * s->filter[j + 1] +
-                     s->residues[i + j    ] * s->filter[j    ];
+                v += s->residues[i + j + 3] * (unsigned)s->filter[j + 3] +
+                     s->residues[i + j + 2] * (unsigned)s->filter[j + 2] +
+                     s->residues[i + j + 1] * (unsigned)s->filter[j + 1] +
+                     s->residues[i + j    ] * (unsigned)s->filter[j    ];
             }
-            v = (av_clip_intp2(v >> filter_quant, 13) << dshift) - *decoded;
+            v = (av_clip_intp2(v >> filter_quant, 13) * (1 << dshift)) - (unsigned)*decoded;
             *decoded++ = v;
             s->residues[filter_order + i] = v >> dshift;
         }
@@ -653,7 +653,7 @@ static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
                          s->residues[i    ] * s->filter[0];
                 }
 
-                v = (av_clip_intp2(v >> 10, 13) << dshift) - *p1;
+                v = av_clip_intp2(v >> 10, 13) * (1 << dshift) - *p1;
                 *p1++ = v;
             }
 
@@ -702,7 +702,7 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
 
     if (s->ti.codec != TAK_CODEC_MONO_STEREO &&
         s->ti.codec != TAK_CODEC_MULTICHANNEL) {
-        av_log(avctx, AV_LOG_ERROR, "unsupported codec: %d\n", s->ti.codec);
+        avpriv_report_missing_feature(avctx, "TAK codec type %d", s->ti.codec);
         return AVERROR_PATCHWELCOME;
     }
     if (s->ti.data_type) {
@@ -862,7 +862,7 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
 
             if (s->sample_shift[chan] > 0)
                 for (i = 0; i < s->nb_samples; i++)
-                    decoded[i] <<= s->sample_shift[chan];
+                    decoded[i] *= 1U << s->sample_shift[chan];
         }
     }
 
@@ -889,7 +889,7 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
             uint8_t *samples = (uint8_t *)frame->extended_data[chan];
             int32_t *decoded = s->decoded[chan];
             for (i = 0; i < s->nb_samples; i++)
-                samples[i] = decoded[i] + 0x80;
+                samples[i] = decoded[i] + 0x80U;
         }
         break;
     case AV_SAMPLE_FMT_S16P:
@@ -904,7 +904,7 @@ static int tak_decode_frame(AVCodecContext *avctx, void *data,
         for (chan = 0; chan < avctx->channels; chan++) {
             int32_t *samples = (int32_t *)frame->extended_data[chan];
             for (i = 0; i < s->nb_samples; i++)
-                samples[i] <<= 8;
+                samples[i] *= 1U << 8;
         }
         break;
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/targa.c b/mythtv/external/FFmpeg/libavcodec/targa.c
index 215c0f51f66..93e0ef7905d 100644
--- a/mythtv/external/FFmpeg/libavcodec/targa.c
+++ b/mythtv/external/FFmpeg/libavcodec/targa.c
@@ -265,32 +265,33 @@ static int decode_frame(AVCodecContext *avctx,
                 line = advance_line(dst, line, stride, &y, h, interleave);
             } while (line);
         }
-    }
 
-    if (flags & TGA_RIGHTTOLEFT) { // right-to-left, needs horizontal flip
-        int x;
-        for (y = 0; y < h; y++) {
-            void *line = &p->data[0][y * p->linesize[0]];
-            for (x = 0; x < w >> 1; x++) {
-                switch (bpp) {
-                case 32:
-                    FFSWAP(uint32_t, ((uint32_t *)line)[x], ((uint32_t *)line)[w - x - 1]);
-                    break;
-                case 24:
-                    FFSWAP(uint8_t, ((uint8_t *)line)[3 * x    ], ((uint8_t *)line)[3 * w - 3 * x - 3]);
-                    FFSWAP(uint8_t, ((uint8_t *)line)[3 * x + 1], ((uint8_t *)line)[3 * w - 3 * x - 2]);
-                    FFSWAP(uint8_t, ((uint8_t *)line)[3 * x + 2], ((uint8_t *)line)[3 * w - 3 * x - 1]);
-                    break;
-                case 16:
-                    FFSWAP(uint16_t, ((uint16_t *)line)[x], ((uint16_t *)line)[w - x - 1]);
-                    break;
-                case 8:
-                    FFSWAP(uint8_t, ((uint8_t *)line)[x], ((uint8_t *)line)[w - x - 1]);
+        if (flags & TGA_RIGHTTOLEFT) { // right-to-left, needs horizontal flip
+            int x;
+            for (y = 0; y < h; y++) {
+                void *line = &p->data[0][y * p->linesize[0]];
+                for (x = 0; x < w >> 1; x++) {
+                    switch (bpp) {
+                    case 32:
+                        FFSWAP(uint32_t, ((uint32_t *)line)[x], ((uint32_t *)line)[w - x - 1]);
+                        break;
+                    case 24:
+                        FFSWAP(uint8_t, ((uint8_t *)line)[3 * x    ], ((uint8_t *)line)[3 * w - 3 * x - 3]);
+                        FFSWAP(uint8_t, ((uint8_t *)line)[3 * x + 1], ((uint8_t *)line)[3 * w - 3 * x - 2]);
+                        FFSWAP(uint8_t, ((uint8_t *)line)[3 * x + 2], ((uint8_t *)line)[3 * w - 3 * x - 1]);
+                        break;
+                    case 16:
+                        FFSWAP(uint16_t, ((uint16_t *)line)[x], ((uint16_t *)line)[w - x - 1]);
+                        break;
+                    case 8:
+                        FFSWAP(uint8_t, ((uint8_t *)line)[x], ((uint8_t *)line)[w - x - 1]);
+                    }
                 }
             }
         }
     }
 
+
     *got_frame = 1;
 
     return avpkt->size;
diff --git a/mythtv/external/FFmpeg/libavcodec/targa_y216dec.c b/mythtv/external/FFmpeg/libavcodec/targa_y216dec.c
index 21b3d35d672..443d48a92f2 100644
--- a/mythtv/external/FFmpeg/libavcodec/targa_y216dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/targa_y216dec.c
@@ -35,7 +35,8 @@ static int y216_decode_frame(AVCodecContext *avctx, void *data,
 {
     AVFrame *pic = data;
     const uint16_t *src = (uint16_t *)avpkt->data;
-    uint16_t *y, *u, *v, aligned_width = FFALIGN(avctx->width, 4);
+    uint16_t *y, *u, *v;
+    int aligned_width = FFALIGN(avctx->width, 4);
     int i, j, ret;
 
     if (avpkt->size < 4 * avctx->height * aligned_width) {
diff --git a/mythtv/external/FFmpeg/libavcodec/targaenc.c b/mythtv/external/FFmpeg/libavcodec/targaenc.c
index 66bc55c3974..79030a012b2 100644
--- a/mythtv/external/FFmpeg/libavcodec/targaenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/targaenc.c
@@ -89,10 +89,6 @@ static int targa_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     int bpp, picsize, datasize = -1, ret, i;
     uint8_t *out;
 
-    if(avctx->width > 0xffff || avctx->height > 0xffff) {
-        av_log(avctx, AV_LOG_ERROR, "image dimensions too large\n");
-        return AVERROR(EINVAL);
-    }
     picsize = av_image_get_buffer_size(avctx->pix_fmt,
                                        avctx->width, avctx->height, 1);
     if ((ret = ff_alloc_packet2(avctx, pkt, picsize + 45, 0)) < 0)
@@ -190,6 +186,11 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
 static av_cold int targa_encode_init(AVCodecContext *avctx)
 {
+    if (avctx->width > 0xffff || avctx->height > 0xffff) {
+        av_log(avctx, AV_LOG_ERROR, "image dimensions too large\n");
+        return AVERROR(EINVAL);
+    }
+
 #if FF_API_CODED_FRAME
 FF_DISABLE_DEPRECATION_WARNINGS
     avctx->coded_frame->key_frame = 1;
diff --git a/mythtv/external/FFmpeg/libavcodec/tdsc.c b/mythtv/external/FFmpeg/libavcodec/tdsc.c
index d1265a006d3..4182404cf01 100644
--- a/mythtv/external/FFmpeg/libavcodec/tdsc.c
+++ b/mythtv/external/FFmpeg/libavcodec/tdsc.c
@@ -343,7 +343,6 @@ static int tdsc_decode_jpeg_tile(AVCodecContext *avctx, int tile_size,
 {
     TDSCContext *ctx = avctx->priv_data;
     AVPacket jpkt;
-    int got_frame = 0;
     int ret;
 
     /* Prepare a packet and send to the MJPEG decoder */
@@ -351,12 +350,16 @@ static int tdsc_decode_jpeg_tile(AVCodecContext *avctx, int tile_size,
     jpkt.data = ctx->tilebuffer;
     jpkt.size = tile_size;
 
-    ret = avcodec_decode_video2(ctx->jpeg_avctx, ctx->jpgframe,
-                                &got_frame, &jpkt);
-    if (ret < 0 || !got_frame || ctx->jpgframe->format != AV_PIX_FMT_YUVJ420P) {
+    ret = avcodec_send_packet(ctx->jpeg_avctx, &jpkt);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Error submitting a packet for decoding\n");
+        return ret;
+    }
+
+    ret = avcodec_receive_frame(ctx->jpeg_avctx, ctx->jpgframe);
+    if (ret < 0 || ctx->jpgframe->format != AV_PIX_FMT_YUVJ420P) {
         av_log(avctx, AV_LOG_ERROR,
-               "JPEG decoding error (%d) for (%d) frame.\n",
-               ret, got_frame);
+               "JPEG decoding error (%d).\n", ret);
 
         /* Normally skip, error if explode */
         if (avctx->err_recognition & AV_EF_EXPLODE)
@@ -609,7 +612,7 @@ static int tdsc_decode_frame(AVCodecContext *avctx, void *data,
     }
     *got_frame = 1;
 
-    return 0;
+    return avpkt->size;
 }
 
 AVCodec ff_tdsc_decoder = {
diff --git a/mythtv/external/FFmpeg/libavcodec/tests/.gitignore b/mythtv/external/FFmpeg/libavcodec/tests/.gitignore
index d8ab947abe1..7f9e3825b61 100644
--- a/mythtv/external/FFmpeg/libavcodec/tests/.gitignore
+++ b/mythtv/external/FFmpeg/libavcodec/tests/.gitignore
@@ -1,14 +1,18 @@
 /avfft
+/avpacket
 /cabac
+/celp_math
 /dct
 /fft
 /fft-fixed
 /fft-fixed32
 /golomb
+/htmlsubtitles
 /iirfilter
 /imgconvert
 /jpeg2000dwt
 /mathops
+/mjpegenc_huffman
 /motion
 /options
 /rangecoder
diff --git a/mythtv/external/FFmpeg/libavcodec/tests/aarch64/dct.c b/mythtv/external/FFmpeg/libavcodec/tests/aarch64/dct.c
new file mode 100644
index 00000000000..032a9638f62
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/tests/aarch64/dct.c
@@ -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
+ */
+
+#include "config.h"
+
+#include "libavcodec/aarch64/idct.h"
+
+static const struct algo fdct_tab_arch[] = {
+    { 0 }
+};
+
+static const struct algo idct_tab_arch[] = {
+    { "SIMPLE-NEON", ff_simple_idct_neon, FF_IDCT_PERM_PARTTRANS, AV_CPU_FLAG_NEON },
+    { 0 }
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/tests/avpacket.c b/mythtv/external/FFmpeg/libavcodec/tests/avpacket.c
new file mode 100644
index 00000000000..90b72341f44
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/tests/avpacket.c
@@ -0,0 +1,128 @@
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <string.h>
+#include "libavcodec/avcodec.h"
+#include "libavutil/error.h"
+
+
+
+static int setup_side_data_entry(AVPacket* avpkt)
+{
+    const uint8_t *data_name = NULL;
+    int ret = 0, bytes;
+    uint8_t *extra_data = NULL;
+
+
+    /* get side_data_name string */
+    data_name = av_packet_side_data_name(AV_PKT_DATA_NEW_EXTRADATA);
+
+    /* Allocate a memory bloc */
+    bytes = strlen(data_name);
+
+    if(!(extra_data = av_malloc(bytes))){
+        ret = AVERROR(ENOMEM);
+        fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));
+        exit(1);
+    }
+    /* copy side_data_name to extra_data array */
+    memcpy(extra_data, data_name, bytes);
+
+    /* create side data for AVPacket */
+    ret = av_packet_add_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
+                                        extra_data, bytes);
+    if(ret < 0){
+        fprintf(stderr,
+                "Error occurred in av_packet_add_side_data: %s\n",
+                av_err2str(ret));
+    }
+
+    return ret;
+}
+
+static int initializations(AVPacket* avpkt)
+{
+    const static uint8_t* data = "selftest for av_packet_clone(...)";
+    int ret = 0;
+
+    /* initialize avpkt */
+    av_init_packet(avpkt);
+
+    /* set values for avpkt */
+    avpkt->pts = 17;
+    avpkt->dts = 2;
+    avpkt->data = (uint8_t*)data;
+    avpkt->size = strlen(data);
+    avpkt->flags = AV_PKT_FLAG_DISCARD;
+    avpkt->duration = 100;
+    avpkt->pos = 3;
+
+    ret = setup_side_data_entry(avpkt);
+
+    return ret;
+}
+
+int main(void)
+{
+    AVPacket avpkt;
+    AVPacket *avpkt_clone = NULL;
+    int ret = 0;
+
+    if(initializations(&avpkt) < 0){
+        printf("failed to initialize variables\n");
+        return 1;
+    }
+    /* test av_packet_clone*/
+    avpkt_clone = av_packet_clone(&avpkt);
+
+    if(!avpkt_clone) {
+        av_log(NULL, AV_LOG_ERROR,"av_packet_clone failed to clone AVPacket\n");
+        return 1;
+    }
+    /*test av_grow_packet*/
+    if(av_grow_packet(avpkt_clone, 20) < 0){
+        av_log(NULL, AV_LOG_ERROR, "av_grow_packet failed\n");
+        return 1;
+    }
+    if(av_grow_packet(avpkt_clone, INT_MAX) == 0){
+        printf( "av_grow_packet failed to return error "
+                "when \"grow_by\" parameter is too large.\n" );
+        ret = 1;
+    }
+    /* test size error check in av_new_packet*/
+    if(av_new_packet(avpkt_clone, INT_MAX) == 0){
+        printf( "av_new_packet failed to return error "
+                "when \"size\" parameter is too large.\n" );
+        ret = 1;
+    }
+    /*test size error check in av_packet_from_data*/
+    if(av_packet_from_data(avpkt_clone, avpkt_clone->data, INT_MAX) == 0){
+        printf("av_packet_from_data failed to return error "
+                "when \"size\" parameter is too large.\n" );
+        ret = 1;
+    }
+    /*clean up*/
+    av_packet_free(&avpkt_clone);
+    av_packet_unref(&avpkt);
+
+
+    return ret;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/tests/celp_math.c b/mythtv/external/FFmpeg/libavcodec/tests/celp_math.c
new file mode 100644
index 00000000000..669ea703621
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/tests/celp_math.c
@@ -0,0 +1,49 @@
+/*
+ * 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/libm.h"
+#include "libavcodec/celp_math.c"
+
+static inline void IsAlmostEqual(float A, float B, float epsilon)
+{
+    float diff = fabsf(A - B);
+    float absa = fabsf(A);
+    float absb = fabsf(B);
+    float largest = (absb > absa) ? absb : absa;
+    av_assert0(diff <= largest * epsilon);
+}
+
+int main(void)
+{
+    int i;
+    const float f1[3]   = {0.0,  1.1,  2.2};
+    const float f2[3]   = {3.3,  4.4,  5.5};
+    const int16_t i1[3] = {6,  7,  8};
+    const int16_t i2[3] = {9, 10, 11};
+
+    float   r = ff_dot_productf(f1, f2, FF_ARRAY_ELEMS(f1));
+    int64_t d = ff_dot_product(i1, i2, FF_ARRAY_ELEMS(i1));
+
+    IsAlmostEqual(16.94f, r, 0.000001f);
+    av_assert0(212 == d);
+
+    for (i = 1024; i >= 1; i/=2)
+        av_assert0(ff_log2_q15(i) == (1<<15)*((int)log2(i))+(1<<2));
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/tests/dct.c b/mythtv/external/FFmpeg/libavcodec/tests/dct.c
index 5303fdff8fd..b44c66f4274 100644
--- a/mythtv/external/FFmpeg/libavcodec/tests/dct.c
+++ b/mythtv/external/FFmpeg/libavcodec/tests/dct.c
@@ -94,7 +94,9 @@ static const struct algo idct_tab[] = {
 #endif /* CONFIG_MPEG4_DECODER */
 };
 
-#if ARCH_ARM
+#if ARCH_AARCH64
+#include "aarch64/dct.c"
+#elif ARCH_ARM
 #include "arm/dct.c"
 #elif ARCH_PPC
 #include "ppc/dct.c"
@@ -180,6 +182,7 @@ static int dct_error(const struct algo *dct, int test, int is_idct, int speed, c
     int err_inf, v;
     int64_t err2, ti, ti1, it1, err_sum = 0;
     int64_t sysErr[64], sysErrMax = 0;
+    int64_t err2_matrix[64], err2_max = 0;
     int maxout = 0;
     int blockSumErrMax = 0, blockSumErr;
     AVLFG prng;
@@ -192,7 +195,7 @@ static int dct_error(const struct algo *dct, int test, int is_idct, int speed, c
     err_inf = 0;
     err2 = 0;
     for (i = 0; i < 64; i++)
-        sysErr[i] = 0;
+        err2_matrix[i] = sysErr[i] = 0;
     for (it = 0; it < NB_ITS; it++) {
         init_block(block1, test, is_idct, &prng, vals);
         permute(block, block1, dct->perm_type);
@@ -219,6 +222,7 @@ static int dct_error(const struct algo *dct, int test, int is_idct, int speed, c
             v = abs(err);
             if (v > err_inf)
                 err_inf = v;
+            err2_matrix[i] += v * v;
             err2 += v * v;
             sysErr[i] += block[i] - block1[i];
             blockSumErr += v;
@@ -228,8 +232,10 @@ static int dct_error(const struct algo *dct, int test, int is_idct, int speed, c
         if (blockSumErrMax < blockSumErr)
             blockSumErrMax = blockSumErr;
     }
-    for (i = 0; i < 64; i++)
+    for (i = 0; i < 64; i++) {
         sysErrMax = FFMAX(sysErrMax, FFABS(sysErr[i]));
+        err2_max  = FFMAX(err2_max , FFABS(err2_matrix[i]));
+    }
 
     for (i = 0; i < 64; i++) {
         if (i % 8 == 0)
@@ -242,6 +248,8 @@ static int dct_error(const struct algo *dct, int test, int is_idct, int speed, c
     ome  = (double) err_sum / NB_ITS / 64;
 
     spec_err = is_idct && (err_inf > 1 || omse > 0.02 || fabs(ome) > 0.0015);
+    if (test < 2)
+        spec_err = is_idct && ((double) err2_max / NB_ITS > 0.06 || (double) sysErrMax / NB_ITS > 0.015);
 
     printf("%s %s: max_err=%d omse=%0.8f ome=%0.8f syserr=%0.8f maxout=%d blockSumErr=%d\n",
            is_idct ? "IDCT" : "DCT", dct->name, err_inf,
@@ -282,7 +290,7 @@ static int dct_error(const struct algo *dct, int test, int is_idct, int speed, c
 DECLARE_ALIGNED(8, static uint8_t, img_dest)[64];
 DECLARE_ALIGNED(8, static uint8_t, img_dest1)[64];
 
-static void idct248_ref(uint8_t *dest, int linesize, int16_t *block)
+static void idct248_ref(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
 {
     static int init;
     static double c8[8][8];
@@ -363,7 +371,8 @@ static void idct248_ref(uint8_t *dest, int linesize, int16_t *block)
 }
 
 static void idct248_error(const char *name,
-                          void (*idct248_put)(uint8_t *dest, int line_size,
+                          void (*idct248_put)(uint8_t *dest,
+                                              ptrdiff_t line_size,
                                               int16_t *block),
                           int speed)
 {
diff --git a/mythtv/external/FFmpeg/libavcodec/tests/fft.c b/mythtv/external/FFmpeg/libavcodec/tests/fft.c
index 4536091c77f..83f2ff2a082 100644
--- a/mythtv/external/FFmpeg/libavcodec/tests/fft.c
+++ b/mythtv/external/FFmpeg/libavcodec/tests/fft.c
@@ -490,7 +490,7 @@ int main(int argc, char **argv)
             av_log(NULL, AV_LOG_INFO, "DCT_III");
         else
             av_log(NULL, AV_LOG_INFO, "DCT_II");
-            dct_init(&d, fft_nbits, do_inverse ? DCT_III : DCT_II);
+        dct_init(&d, fft_nbits, do_inverse ? DCT_III : DCT_II);
         break;
 #    endif /* CONFIG_DCT */
 #endif /* FFT_FLOAT */
diff --git a/mythtv/external/FFmpeg/libavcodec/tests/golomb.c b/mythtv/external/FFmpeg/libavcodec/tests/golomb.c
index 965367b7be0..85b8a9390bb 100644
--- a/mythtv/external/FFmpeg/libavcodec/tests/golomb.c
+++ b/mythtv/external/FFmpeg/libavcodec/tests/golomb.c
@@ -21,6 +21,7 @@
 #include <stdint.h>
 #include <stdio.h>
 
+#include "libavutil/internal.h"
 #include "libavutil/mem.h"
 
 #include "libavcodec/get_bits.h"
@@ -76,6 +77,24 @@ int main(void)
         }
     }
 
+#define EXTEND_L(i) ((i) << 4 | (i) & 15)
+    init_put_bits(&pb, temp, SIZE);
+    for (i = 0; i < COUNT; i++)
+        set_ue_golomb_long(&pb, EXTEND_L(i));
+    flush_put_bits(&pb);
+
+    init_get_bits(&gb, temp, 8 * SIZE);
+    for (i = 0; i < COUNT; i++) {
+        int j, s = show_bits_long(&gb, 32);
+
+        j = get_ue_golomb_long(&gb);
+        if (j != EXTEND_L(i)) {
+            fprintf(stderr, "get_ue_golomb_long: expected %d, got %d. "
+                    "bits: %8x\n", EXTEND_L(i), j, s);
+            ret = 1;
+        }
+    }
+
     init_put_bits(&pb, temp, SIZE);
     for (i = 0; i < COUNT; i++)
         set_se_golomb(&pb, i - COUNT / 2);
diff --git a/mythtv/external/FFmpeg/libavcodec/tests/htmlsubtitles.c b/mythtv/external/FFmpeg/libavcodec/tests/htmlsubtitles.c
new file mode 100644
index 00000000000..7c89ee97af9
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/tests/htmlsubtitles.c
@@ -0,0 +1,51 @@
+/*
+ * 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/common.h"
+#include "libavcodec/htmlsubtitles.c"
+
+static const char * const test_cases[] = {
+    /* latin guillemets and other < > garbage */
+    "<<hello>>",                            // guillemets
+    "<<<b>hello</b>>>",                     // guillemets + tags
+    "< hello < 2000 > world >",             // unlikely tags due to spaces
+    "<h1>TITLE</h1>",                       // likely unhandled tags
+    "< font color=red >red</font>",         // invalid format of valid tag
+    "Foo <foo@bar.com>",                    // not a tag (not alnum)
+
+    "<b> foo <I> bar </B> bla </i>",        // broken nesting
+
+    "A<br>B<BR/>C<br  / >D<  Br >E<brk><brk/>", // misc line breaks
+};
+
+int main(void)
+{
+    int i;
+    AVBPrint dst;
+
+    av_bprint_init(&dst, 0, AV_BPRINT_SIZE_UNLIMITED);
+    for (i = 0; i < FF_ARRAY_ELEMS(test_cases); i++) {
+        int ret = ff_htmlmarkup_to_ass(NULL, &dst, test_cases[i]);
+        if (ret < 0)
+            return ret;
+        printf("%s --> %s\n", test_cases[i], dst.str);
+        av_bprint_clear(&dst);
+    }
+    av_bprint_finalize(&dst, NULL);
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/tests/mjpegenc_huffman.c b/mythtv/external/FFmpeg/libavcodec/tests/mjpegenc_huffman.c
new file mode 100644
index 00000000000..2ed92d07d58
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/tests/mjpegenc_huffman.c
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2016 William Ma, Sofia Kim, Dustin Woo
+ *
+ * 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
+ * Optimal Huffman Encoding tests.
+ */
+
+#include "libavcodec/avcodec.h"
+#include <stdlib.h>
+#include "libavcodec/mjpegenc.h"
+#include "libavcodec/mjpegenc_huffman.h"
+#include "libavcodec/mjpegenc_common.h"
+#include "libavcodec/mpegvideo.h"
+
+// Validate the computed lengths satisfy the JPEG restrictions and is optimal.
+static int check_lengths(int L, int expected_length,
+                         const int *probs, int nprobs)
+{
+    HuffTable lengths[256];
+    PTable val_counts[256];
+    int actual_length = 0, i, j, k, prob, length;
+    int ret = 0;
+    double cantor_measure = 0;
+    av_assert0(nprobs <= 256);
+
+    for (i = 0; i < nprobs; i++) {
+        val_counts[i] = (PTable){.value = i, .prob = probs[i]};
+    }
+
+    ff_mjpegenc_huffman_compute_bits(val_counts, lengths, nprobs, L);
+
+    for (i = 0; i < nprobs; i++) {
+        // Find the value's prob and length
+        for (j = 0; j < nprobs; j++)
+            if (val_counts[j].value == i) break;
+        for (k = 0; k < nprobs; k++)
+            if (lengths[k].code == i) break;
+        if (!(j < nprobs && k < nprobs)) return 1;
+        prob = val_counts[j].prob;
+        length = lengths[k].length;
+
+        if (prob) {
+            actual_length += prob * length;
+            cantor_measure += 1. / (1 << length);
+        }
+
+        if (length > L || length < 1) return 1;
+    }
+    // Check that the codes can be prefix-free.
+    if (cantor_measure > 1) ret = 1;
+    // Check that the total length is optimal
+    if (actual_length != expected_length) ret = 1;
+
+    if (ret == 1) {
+      fprintf(stderr,
+              "Cantor measure: %f\n"
+              "Actual length: %d\n"
+              "Expected length: %d\n",
+              cantor_measure, actual_length, expected_length);
+    }
+
+    return ret;
+}
+
+static const int probs_zeroes[] = {
+    6, 6, 0, 0, 0
+};
+
+static const int probs_skewed[] = {
+    2, 0, 0, 0, 0, 1, 0, 0, 20, 0, 2, 0, 10, 5, 1, 1, 9, 1, 1, 6, 0, 5, 0, 1, 0, 7, 6,
+    1, 1, 5, 0, 0, 0, 0, 11, 0, 0, 0, 51, 1, 0, 20, 0, 1, 0, 0, 0, 0, 6, 106, 1, 0, 1,
+    0, 2, 1, 16, 0, 0, 5, 0, 0, 0, 4, 3, 15, 4, 4, 0, 0, 0, 3, 0, 0, 1, 0, 3, 0, 3, 2,
+    2, 0, 0, 4, 3, 40, 1, 2, 0, 22, 0, 0, 0, 9, 0, 0, 0, 0, 1, 1, 0, 1, 6, 11, 4, 10,
+    28, 6, 1, 0, 0, 9, 9, 4, 0, 0, 0, 0, 8, 33844, 2, 0, 2, 1, 1, 5, 0, 0, 1, 9, 1, 0,
+    4, 14, 4, 0, 0, 3, 8, 0, 51, 9, 6, 1, 1, 2, 2, 3, 1, 5, 5, 29, 0, 0, 0, 0, 14, 29,
+    6, 4, 13, 12, 2, 3, 1, 0, 5, 4, 1, 1, 0, 0, 29, 1, 0, 0, 0, 0, 4, 0, 0, 1, 0, 1,
+    7, 0, 42, 0, 0, 0, 0, 0, 2, 0, 3, 9, 0, 0, 0, 2, 1, 0, 0, 6, 5, 6, 1, 2, 3, 0, 0,
+    0, 3, 0, 0, 28, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 23, 0, 0, 0, 0,
+    0, 21, 1, 0, 3, 24, 2, 0, 0, 7, 0, 0, 1, 5, 1, 2, 0, 5
+};
+
+static const int probs_sat[] = {
+    74, 8, 14, 7, 9345, 40, 0, 2014, 2, 1, 115, 0, 2, 1, 194, 388, 20, 0, 0, 2, 1, 121,
+    1, 1583, 0, 16, 21, 2, 132, 2, 15, 9, 13, 1, 0, 2293, 2, 8, 5, 2, 30, 0, 0, 4, 54,
+    783, 4, 1, 2, 4, 0, 22, 93, 1, 143, 19, 0, 36, 32, 4, 6, 33, 3, 45, 0, 8, 1, 0, 18,
+    17, 1, 0, 1, 0, 0, 1, 1004, 38, 3, 8, 90, 23, 0, 2819, 3, 0, 970, 158, 9, 6, 4, 48,
+    4, 0, 1, 0, 0, 60, 3, 62, 0, 2, 2, 2, 279, 66, 16, 1, 20, 0, 7, 9, 32, 1411, 6, 3,
+    27, 1, 5, 49, 0, 0, 0, 0, 0, 2, 10, 1, 1, 2, 3, 801, 3, 25, 5, 1, 1, 0, 632, 0, 14,
+    18, 5, 8, 200, 4, 4, 22, 12, 0, 4, 1, 0, 2, 4, 9, 3, 16, 7, 2, 2, 213, 0, 2, 620,
+    39303, 0, 1, 0, 2, 1, 183781, 1, 0, 0, 0, 94, 7, 3, 4, 0, 4, 306, 43, 352, 76, 34,
+    13, 11, 0, 51, 1, 13, 19, 0, 26, 0, 7276, 4, 207, 31, 1, 2, 4, 6, 19, 8, 17, 4, 6,
+    0, 1085, 0, 0, 0, 3, 489, 36, 1, 0, 1, 9420, 294, 28, 0, 57, 5, 0, 9, 2, 0, 1, 2,
+    2, 0, 0, 9, 2, 29, 2, 2, 7, 0, 5, 490, 0, 7, 5, 0, 1, 8, 0, 0, 23255, 0, 1
+};
+
+// Test the example given on @see
+// http://guru.multimedia.cx/small-tasks-for-ffmpeg/
+int main(int argc, char **argv)
+{
+    int i, ret = 0;
+    // Probabilities of symbols 0..4
+    PTable val_counts[] = {
+        {.value = 0, .prob = 1},
+        {.value = 1, .prob = 2},
+        {.value = 2, .prob = 5},
+        {.value = 3, .prob = 10},
+        {.value = 4, .prob = 21},
+    };
+    // Expected code lengths for each symbol
+    static const HuffTable expected[] = {
+        {.code = 0, .length = 3},
+        {.code = 1, .length = 3},
+        {.code = 2, .length = 3},
+        {.code = 3, .length = 3},
+        {.code = 4, .length = 1},
+    };
+    // Actual code lengths
+    HuffTable distincts[5];
+
+    // Build optimal huffman tree using an internal function, to allow for
+    // smaller-than-normal test cases. This mutates val_counts by sorting.
+    ff_mjpegenc_huffman_compute_bits(val_counts, distincts,
+                                     FF_ARRAY_ELEMS(distincts), 3);
+
+    for (i = 0; i < FF_ARRAY_ELEMS(distincts); i++) {
+        if (distincts[i].code != expected[i].code ||
+            distincts[i].length != expected[i].length) {
+            fprintf(stderr,
+                    "Built huffman does not equal expectations. "
+                    "Expected: code %d probability %d, "
+                    "Actual: code %d probability %d\n",
+                    expected[i].code, expected[i].length,
+                    distincts[i].code, distincts[i].length);
+            ret = 1;
+        }
+    }
+
+    // Check handling of zero probabilities
+    if (check_lengths(16, 18, probs_zeroes, FF_ARRAY_ELEMS(probs_zeroes)))
+        ret = 1;
+    // Check skewed distribution over 256 without saturated lengths
+    if (check_lengths(16, 41282, probs_skewed, FF_ARRAY_ELEMS(probs_skewed)))
+        ret = 1;
+    // Check skewed distribution over 256 with saturated lengths
+    if (check_lengths(16, 669904, probs_sat, FF_ARRAY_ELEMS(probs_sat)))
+        ret = 1;
+
+    return ret;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/tests/x86/dct.c b/mythtv/external/FFmpeg/libavcodec/tests/x86/dct.c
index b6cdfb346c2..afb03b194be 100644
--- a/mythtv/external/FFmpeg/libavcodec/tests/x86/dct.c
+++ b/mythtv/external/FFmpeg/libavcodec/tests/x86/dct.c
@@ -22,7 +22,7 @@
 #include "libavcodec/x86/xvididct.h"
 #include "libavcodec/x86/simple_idct.h"
 
-#if (CONFIG_PRORES_DECODER || CONFIG_PRORES_LGPL_DECODER) && ARCH_X86_64 && HAVE_YASM
+#if (CONFIG_PRORES_DECODER || CONFIG_PRORES_LGPL_DECODER) && ARCH_X86_64 && HAVE_X86ASM
 void ff_prores_idct_put_10_sse2(uint16_t *dst, int linesize,
                                 int16_t *block, int16_t *qmat);
 
@@ -67,10 +67,10 @@ static const struct algo fdct_tab_arch[] = {
 };
 
 static const struct algo idct_tab_arch[] = {
-#if HAVE_MMX_INLINE
+#if HAVE_MMX_EXTERNAL
     { "SIMPLE-MMX",  ff_simple_idct_mmx,  FF_IDCT_PERM_SIMPLE, AV_CPU_FLAG_MMX },
 #endif
-#if CONFIG_MPEG4_DECODER && HAVE_YASM
+#if CONFIG_MPEG4_DECODER && HAVE_X86ASM
 #if ARCH_X86_32
     { "XVID-MMX",    ff_xvid_idct_mmx,    FF_IDCT_PERM_NONE,   AV_CPU_FLAG_MMX,    1 },
     { "XVID-MMXEXT", ff_xvid_idct_mmxext, FF_IDCT_PERM_NONE,   AV_CPU_FLAG_MMXEXT, 1 },
@@ -78,20 +78,22 @@ static const struct algo idct_tab_arch[] = {
 #if HAVE_SSE2_EXTERNAL
     { "XVID-SSE2",   ff_xvid_idct_sse2,   FF_IDCT_PERM_SSE2,   AV_CPU_FLAG_SSE2,   1 },
 #endif
-#endif /* CONFIG_MPEG4_DECODER && HAVE_YASM */
-#if (CONFIG_PRORES_DECODER || CONFIG_PRORES_LGPL_DECODER) && ARCH_X86_64 && HAVE_YASM
+#endif /* CONFIG_MPEG4_DECODER && HAVE_X86ASM */
+#if (CONFIG_PRORES_DECODER || CONFIG_PRORES_LGPL_DECODER) && ARCH_X86_64 && HAVE_X86ASM
     { "PR-SSE2",     ff_prores_idct_put_10_sse2_wrap, FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_SSE2, 1 },
 # if HAVE_AVX_EXTERNAL
     { "PR-AVX",      ff_prores_idct_put_10_avx_wrap, FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_AVX, 1 },
 # endif
 #endif
-#if HAVE_YASM
+#if HAVE_X86ASM
 #if ARCH_X86_64
 #if HAVE_SSE2_EXTERNAL
+    { "SIMPLE8-SSE2",   ff_simple_idct8_sse2,  FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_SSE2},
     { "SIMPLE10-SSE2",  ff_simple_idct10_sse2, FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_SSE2},
     { "SIMPLE12-SSE2",  ff_simple_idct12_sse2, FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_SSE2, 1 },
 #endif
 #if HAVE_AVX_EXTERNAL
+    { "SIMPLE8-AVX",    ff_simple_idct8_avx,   FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_AVX},
     { "SIMPLE10-AVX",   ff_simple_idct10_avx,  FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_AVX},
     { "SIMPLE12-AVX",   ff_simple_idct12_avx,  FF_IDCT_PERM_TRANSPOSE, AV_CPU_FLAG_AVX,  1 },
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/texturedsp.c b/mythtv/external/FFmpeg/libavcodec/texturedsp.c
index 5012245a26e..90b1eb4f115 100644
--- a/mythtv/external/FFmpeg/libavcodec/texturedsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/texturedsp.c
@@ -35,7 +35,7 @@
 #define RGBA(r, g, b, a) (((uint8_t)(r) <<  0) | \
                           ((uint8_t)(g) <<  8) | \
                           ((uint8_t)(b) << 16) | \
-                          ((uint8_t)(a) << 24))
+                          ((unsigned)(uint8_t)(a) << 24))
 
 static av_always_inline void extract_color(uint32_t colors[4],
                                            uint16_t color0,
@@ -158,7 +158,7 @@ static inline void dxt3_block_internal(uint8_t *dst, ptrdiff_t stride,
 
         for (x = 0; x < 4; x++) {
             uint8_t alpha = alpha_values[x];
-            uint32_t pixel = colors[code & 3] | (alpha << 24);
+            uint32_t pixel = colors[code & 3] | ((unsigned)alpha << 24);
             code >>= 2;
 
             AV_WL32(dst + x * 4, pixel);
@@ -291,7 +291,7 @@ static inline void dxt5_block_internal(uint8_t *dst, ptrdiff_t stride,
                     }
                 }
             }
-            pixel = colors[code & 3] | (alpha << 24);
+            pixel = colors[code & 3] | ((unsigned)alpha << 24);
             code >>= 2;
             AV_WL32(dst + x * 4, pixel);
         }
diff --git a/mythtv/external/FFmpeg/libavcodec/thread.h b/mythtv/external/FFmpeg/libavcodec/thread.h
index c848d7ae8bd..318619316c9 100644
--- a/mythtv/external/FFmpeg/libavcodec/thread.h
+++ b/mythtv/external/FFmpeg/libavcodec/thread.h
@@ -34,7 +34,7 @@
 
 typedef struct ThreadFrame {
     AVFrame *f;
-    AVCodecContext *owner;
+    AVCodecContext *owner[2];
     // progress->data is an array of 2 ints holding progress for top/bottom
     // fields
     AVBufferRef *progress;
@@ -133,8 +133,10 @@ void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f);
 int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src);
 
 int ff_thread_init(AVCodecContext *s);
+int ff_slice_thread_execute_with_mainfunc(AVCodecContext *avctx,
+        int (*action_func2)(AVCodecContext *c, void *arg, int jobnr, int threadnr),
+        int (*main_func)(AVCodecContext *c), void *arg, int *ret, int job_count);
 void ff_thread_free(AVCodecContext *s);
-
 int ff_alloc_entries(AVCodecContext *avctx, int count);
 void ff_reset_entries(AVCodecContext *avctx);
 void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n);
diff --git a/mythtv/external/FFmpeg/libavcodec/tiertexseqv.c b/mythtv/external/FFmpeg/libavcodec/tiertexseqv.c
index 06c5fd6b09d..af39f74d7dd 100644
--- a/mythtv/external/FFmpeg/libavcodec/tiertexseqv.c
+++ b/mythtv/external/FFmpeg/libavcodec/tiertexseqv.c
@@ -213,10 +213,15 @@ static int seqvideo_decode(SeqVideoContext *seq, const unsigned char *data, int
 static av_cold int seqvideo_decode_init(AVCodecContext *avctx)
 {
     SeqVideoContext *seq = avctx->priv_data;
+    int ret;
 
     seq->avctx = avctx;
     avctx->pix_fmt = AV_PIX_FMT_PAL8;
 
+    ret = ff_set_dimensions(avctx, 256, 128);
+    if (ret < 0)
+        return ret;
+
     seq->frame = av_frame_alloc();
     if (!seq->frame)
         return AVERROR(ENOMEM);
diff --git a/mythtv/external/FFmpeg/libavcodec/tiff.c b/mythtv/external/FFmpeg/libavcodec/tiff.c
index 4721e944491..1b332a754dc 100644
--- a/mythtv/external/FFmpeg/libavcodec/tiff.c
+++ b/mythtv/external/FFmpeg/libavcodec/tiff.c
@@ -74,6 +74,8 @@ typedef struct TiffContext {
     int deinvert_buf_size;
     uint8_t *yuv_line;
     unsigned int yuv_line_size;
+    uint8_t *fax_buffer;
+    unsigned int fax_buffer_size;
 
     int geotag_count;
     TiffGeoTag *geotags;
@@ -227,9 +229,9 @@ static int add_metadata(int count, int type,
                         const char *name, const char *sep, TiffContext *s, AVFrame *frame)
 {
     switch(type) {
-    case TIFF_DOUBLE: return ff_tadd_doubles_metadata(count, name, sep, &s->gb, s->le, avpriv_frame_get_metadatap(frame));
-    case TIFF_SHORT : return ff_tadd_shorts_metadata(count, name, sep, &s->gb, s->le, 0, avpriv_frame_get_metadatap(frame));
-    case TIFF_STRING: return ff_tadd_string_metadata(count, name, &s->gb, s->le, avpriv_frame_get_metadatap(frame));
+    case TIFF_DOUBLE: return ff_tadd_doubles_metadata(count, name, sep, &s->gb, s->le, &frame->metadata);
+    case TIFF_SHORT : return ff_tadd_shorts_metadata(count, name, sep, &s->gb, s->le, 0, &frame->metadata);
+    case TIFF_STRING: return ff_tadd_string_metadata(count, name, &s->gb, s->le, &frame->metadata);
     default         : return AVERROR_INVALIDDATA;
     };
 }
@@ -408,7 +410,7 @@ static int tiff_unpack_lzma(TiffContext *s, AVFrame *p, uint8_t *dst, int stride
                             const uint8_t *src, int size, int width, int lines,
                             int strip_start, int is_yuv)
 {
-    uint64_t outlen = width * lines;
+    uint64_t outlen = width * (uint64_t)lines;
     int ret, line;
     uint8_t *buf = av_malloc(outlen);
     if (!buf)
@@ -452,8 +454,10 @@ static int tiff_unpack_fax(TiffContext *s, uint8_t *dst, int stride,
 {
     int i, ret = 0;
     int line;
-    uint8_t *src2 = av_malloc((unsigned)size +
-                              AV_INPUT_BUFFER_PADDING_SIZE);
+    uint8_t *src2;
+
+    av_fast_padded_malloc(&s->fax_buffer, &s->fax_buffer_size, size);
+    src2 = s->fax_buffer;
 
     if (!src2) {
         av_log(s->avctx, AV_LOG_ERROR,
@@ -475,7 +479,6 @@ static int tiff_unpack_fax(TiffContext *s, uint8_t *dst, int stride,
             horizontal_fill(s->bpp, dst, 1, dst, 0, width, 0);
             dst += stride;
         }
-    av_free(src2);
     return ret;
 }
 
@@ -772,9 +775,18 @@ static void set_sar(TiffContext *s, unsigned tag, unsigned num, unsigned den)
     int offset = tag == TIFF_YRES ? 2 : 0;
     s->res[offset++] = num;
     s->res[offset]   = den;
-    if (s->res[0] && s->res[1] && s->res[2] && s->res[3])
+    if (s->res[0] && s->res[1] && s->res[2] && s->res[3]) {
+        uint64_t num = s->res[2] * (uint64_t)s->res[1];
+        uint64_t den = s->res[0] * (uint64_t)s->res[3];
+        if (num > INT64_MAX || den > INT64_MAX) {
+            num = num >> 1;
+            den = den >> 1;
+        }
         av_reduce(&s->avctx->sample_aspect_ratio.num, &s->avctx->sample_aspect_ratio.den,
-                  s->res[2] * (uint64_t)s->res[1], s->res[0] * (uint64_t)s->res[3], INT32_MAX);
+                  num, den, INT32_MAX);
+        if (!s->avctx->sample_aspect_ratio.den)
+            s->avctx->sample_aspect_ratio = (AVRational) {0, 1};
+    }
 }
 
 static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
@@ -905,6 +917,11 @@ static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
         break;
     case TIFF_STRIP_OFFS:
         if (count == 1) {
+            if (value > INT_MAX) {
+                av_log(s->avctx, AV_LOG_ERROR,
+                    "strippos %u too large\n", value);
+                return AVERROR_INVALIDDATA;
+            }
             s->strippos = 0;
             s->stripoff = value;
         } else
@@ -916,6 +933,11 @@ static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
         break;
     case TIFF_STRIP_SIZE:
         if (count == 1) {
+            if (value > INT_MAX) {
+                av_log(s->avctx, AV_LOG_ERROR,
+                    "stripsize %u too large\n", value);
+                return AVERROR_INVALIDDATA;
+            }
             s->stripsizesoff = 0;
             s->stripsize     = value;
             s->strips        = 1;
@@ -987,6 +1009,11 @@ static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
         bytestream2_skip(&pal_gb[2], count / 3 * off * 2);
 
         off = (type_sizes[type] - 1) << 3;
+        if (off > 31U) {
+            av_log(s->avctx, AV_LOG_ERROR, "palette shift %d is out of range\n", off);
+            return AVERROR_INVALIDDATA;
+        }
+
         for (i = 0; i < count / 3; i++) {
             uint32_t p = 0xFF000000;
             p |= (ff_tget(&pal_gb[0], type, s->le) >> off) << 16;
@@ -1009,6 +1036,7 @@ static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
             s->subsampling[i] = ff_tget(&s->gb, type, s->le);
             if (s->subsampling[i] <= 0) {
                 av_log(s->avctx, AV_LOG_ERROR, "subsampling %d is invalid\n", s->subsampling[i]);
+                s->subsampling[i] = 1;
                 return AVERROR_INVALIDDATA;
             }
         }
@@ -1036,6 +1064,10 @@ static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
         ADD_METADATA(count, "ModelTiepointTag", NULL);
         break;
     case TIFF_GEO_KEY_DIRECTORY:
+        if (s->geotag_count) {
+            avpriv_request_sample(s->avctx, "Multiple geo key directories\n");
+            return AVERROR_INVALIDDATA;
+        }
         ADD_METADATA(1, "GeoTIFF_Version", NULL);
         ADD_METADATA(2, "GeoTIFF_Key_Revision", ".");
         s->geotag_count   = ff_tget_short(&s->gb, s->le);
@@ -1043,7 +1075,8 @@ static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
             s->geotag_count = count / 4 - 1;
             av_log(s->avctx, AV_LOG_WARNING, "GeoTIFF key directory buffer shorter than specified\n");
         }
-        if (bytestream2_get_bytes_left(&s->gb) < s->geotag_count * sizeof(int16_t) * 4) {
+        if (   bytestream2_get_bytes_left(&s->gb) < s->geotag_count * sizeof(int16_t) * 4
+            || s->geotag_count == 0) {
             s->geotag_count = 0;
             return -1;
         }
@@ -1081,6 +1114,8 @@ static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
                 if (s->geotags[i].count == 0
                     || s->geotags[i].offset + s->geotags[i].count > count) {
                     av_log(s->avctx, AV_LOG_WARNING, "Invalid GeoTIFF key %d\n", s->geotags[i].key);
+                } else if (s->geotags[i].val) {
+                    av_log(s->avctx, AV_LOG_WARNING, "Duplicate GeoTIFF key %d\n", s->geotags[i].key);
                 } else {
                     char *ap = doubles2str(&dp[s->geotags[i].offset], s->geotags[i].count, ", ");
                     if (!ap) {
@@ -1107,6 +1142,8 @@ static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
                     bytestream2_seek(&s->gb, pos + s->geotags[i].offset, SEEK_SET);
                     if (bytestream2_get_bytes_left(&s->gb) < s->geotags[i].count)
                         return AVERROR_INVALIDDATA;
+                    if (s->geotags[i].val)
+                        return AVERROR_INVALIDDATA;
                     ap = av_malloc(s->geotags[i].count);
                     if (!ap) {
                         av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
@@ -1226,7 +1263,7 @@ static int decode_frame(AVCodecContext *avctx,
             av_log(avctx, AV_LOG_WARNING, "Type of GeoTIFF key %d is wrong\n", s->geotags[i].key);
             continue;
         }
-        ret = av_dict_set(avpriv_frame_get_metadatap(p), keyname, s->geotags[i].val, 0);
+        ret = av_dict_set(&p->metadata, keyname, s->geotags[i].val, 0);
         if (ret<0) {
             av_log(avctx, AV_LOG_ERROR, "Writing metadata with key '%s' failed\n", keyname);
             return ret;
@@ -1269,6 +1306,8 @@ static int decode_frame(AVCodecContext *avctx,
         stride = p->linesize[plane];
         dst = p->data[plane];
         for (i = 0; i < s->height; i += s->rps) {
+            if (i)
+                dst += s->rps * stride;
             if (s->stripsizesoff)
                 ssize = ff_tget(&stripsizes, s->sstype, le);
             else
@@ -1289,7 +1328,6 @@ static int decode_frame(AVCodecContext *avctx,
                     return ret;
                 break;
             }
-            dst += s->rps * stride;
         }
         if (s->predictor == 2) {
             if (s->photometric == TIFF_PHOTOMETRIC_YCBCR) {
@@ -1333,10 +1371,11 @@ static int decode_frame(AVCodecContext *avctx,
         }
 
         if (s->photometric == TIFF_PHOTOMETRIC_WHITE_IS_ZERO) {
+            int c = (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 ? (1<<s->bpp) - 1 : 255);
             dst = p->data[plane];
             for (i = 0; i < s->height; i++) {
                 for (j = 0; j < stride; j++)
-                    dst[j] = (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 ? (1<<s->bpp) - 1 : 255) - dst[j];
+                    dst[j] = c - dst[j];
                 dst += stride;
             }
         }
@@ -1377,6 +1416,9 @@ static av_cold int tiff_end(AVCodecContext *avctx)
 
     ff_lzw_decode_close(&s->lzw);
     av_freep(&s->deinvert_buf);
+    s->deinvert_buf_size = 0;
+    av_freep(&s->fax_buffer);
+    s->fax_buffer_size = 0;
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/tiff_common.c b/mythtv/external/FFmpeg/libavcodec/tiff_common.c
index 35119af558b..0af62ee9621 100644
--- a/mythtv/external/FFmpeg/libavcodec/tiff_common.c
+++ b/mythtv/external/FFmpeg/libavcodec/tiff_common.c
@@ -97,7 +97,7 @@ int ff_tadd_rational_metadata(int count, const char *name, const char *sep,
     for (i = 0; i < count; i++) {
         nom   = ff_tget_long(gb, le);
         denom = ff_tget_long(gb, le);
-        av_bprintf(&bp, "%s%7i:%-7i", auto_sep(count, sep, i, 4), nom, denom);
+        av_bprintf(&bp, "%s%7"PRId32":%-7"PRId32, auto_sep(count, sep, i, 4), nom, denom);
     }
 
     if ((i = av_bprint_finalize(&bp, &ap))) {
diff --git a/mythtv/external/FFmpeg/libavcodec/tiffenc.c b/mythtv/external/FFmpeg/libavcodec/tiffenc.c
index 3d37d2e0849..f59816ec825 100644
--- a/mythtv/external/FFmpeg/libavcodec/tiffenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/tiffenc.c
@@ -265,6 +265,9 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     s->subsampling[0] = 1;
     s->subsampling[1] = 1;
 
+    if (!desc)
+        return AVERROR(EINVAL);
+
     avctx->bits_per_coded_sample =
     s->bpp          = av_get_bits_per_pixel(desc);
     s->bpp_tab_size = desc->nb_components;
@@ -521,6 +524,15 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 static av_cold int encode_init(AVCodecContext *avctx)
 {
     TiffEncoderContext *s = avctx->priv_data;
+
+#if !CONFIG_ZLIB
+    if (s->compr == TIFF_DEFLATE) {
+        av_log(avctx, AV_LOG_ERROR,
+               "Deflate compression needs zlib compiled in\n");
+        return AVERROR(ENOSYS);
+    }
+#endif
+
 #if FF_API_CODED_FRAME
 FF_DISABLE_DEPRECATION_WARNINGS
     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
@@ -551,9 +563,7 @@ static const AVOption options[] = {
     { "packbits",         NULL, 0,             AV_OPT_TYPE_CONST, { .i64 = TIFF_PACKBITS }, 0,        0,            VE, "compression_algo" },
     { "raw",              NULL, 0,             AV_OPT_TYPE_CONST, { .i64 = TIFF_RAW      }, 0,        0,            VE, "compression_algo" },
     { "lzw",              NULL, 0,             AV_OPT_TYPE_CONST, { .i64 = TIFF_LZW      }, 0,        0,            VE, "compression_algo" },
-#if CONFIG_ZLIB
     { "deflate",          NULL, 0,             AV_OPT_TYPE_CONST, { .i64 = TIFF_DEFLATE  }, 0,        0,            VE, "compression_algo" },
-#endif
     { NULL },
 };
 
diff --git a/mythtv/external/FFmpeg/libavcodec/truemotion1.c b/mythtv/external/FFmpeg/libavcodec/truemotion1.c
index da843c44400..e1824384c5e 100644
--- a/mythtv/external/FFmpeg/libavcodec/truemotion1.c
+++ b/mythtv/external/FFmpeg/libavcodec/truemotion1.c
@@ -177,10 +177,10 @@ static int make_ydt15_entry(int p1, int p2, int16_t *ydt)
     int lo, hi;
 
     lo = ydt[p1];
-    lo += (lo << 5) + (lo << 10);
+    lo += (lo * 32) + (lo * 1024);
     hi = ydt[p2];
-    hi += (hi << 5) + (hi << 10);
-    return (lo + (hi << 16)) << 1;
+    hi += (hi * 32) + (hi * 1024);
+    return (lo + (hi * (1U << 16))) * 2;
 }
 
 static int make_cdt15_entry(int p1, int p2, int16_t *cdt)
@@ -188,9 +188,9 @@ static int make_cdt15_entry(int p1, int p2, int16_t *cdt)
     int r, b, lo;
 
     b = cdt[p2];
-    r = cdt[p1] << 10;
+    r = cdt[p1] * 1024;
     lo = b + r;
-    return (lo + (lo << 16)) << 1;
+    return (lo + (lo * (1U << 16))) * 2;
 }
 
 #if HAVE_BIGENDIAN
@@ -489,8 +489,10 @@ static av_cold int truemotion1_decode_init(AVCodecContext *avctx)
     /* there is a vertical predictor for each pixel in a line; each vertical
      * predictor is 0 to start with */
     av_fast_malloc(&s->vert_pred, &s->vert_pred_size, s->avctx->width * sizeof(unsigned int));
-    if (!s->vert_pred)
+    if (!s->vert_pred) {
+        av_frame_free(&s->frame);
         return AVERROR(ENOMEM);
+    }
 
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/truemotion2.c b/mythtv/external/FFmpeg/libavcodec/truemotion2.c
index 245a32a8d76..f077f0e4bd9 100644
--- a/mythtv/external/FFmpeg/libavcodec/truemotion2.c
+++ b/mythtv/external/FFmpeg/libavcodec/truemotion2.c
@@ -272,7 +272,7 @@ static int tm2_read_deltas(TM2Context *ctx, int stream_id)
     for (i = 0; i < d; i++) {
         v = get_bits_long(&ctx->gb, mb);
         if (v & (1 << (mb - 1)))
-            ctx->deltas[stream_id][i] = v - (1 << mb);
+            ctx->deltas[stream_id][i] = v - (1U << mb);
         else
             ctx->deltas[stream_id][i] = v;
     }
@@ -298,15 +298,15 @@ static int tm2_read_stream(TM2Context *ctx, const uint8_t *buf, int stream_id, i
     /* get stream length in dwords */
     bytestream2_init(&gb, buf, buf_size);
     len  = bytestream2_get_be32(&gb);
-    skip = len * 4 + 4;
 
     if (len == 0)
         return 4;
 
-    if (len >= INT_MAX / 4 - 1 || len < 0 || skip > buf_size) {
+    if (len >= INT_MAX / 4 - 1 || len < 0 || len * 4 + 4 > buf_size) {
         av_log(ctx->avctx, AV_LOG_ERROR, "Error, invalid stream size.\n");
         return AVERROR_INVALIDDATA;
     }
+    skip = len * 4 + 4;
 
     toks = bytestream2_get_be32(&gb);
     if (toks & 1) {
@@ -465,7 +465,7 @@ static inline void tm2_apply_deltas(TM2Context *ctx, int* Y, int stride, int *de
     }
 }
 
-static inline void tm2_high_chroma(int *data, int stride, int *last, int *CD, int *deltas)
+static inline void tm2_high_chroma(int *data, int stride, int *last, unsigned *CD, int *deltas)
 {
     int i, j;
     for (j = 0; j < 2; j++) {
@@ -915,7 +915,8 @@ static int decode_frame(AVCodecContext *avctx,
                             buf_size - offset);
         if (t < 0) {
             int j = tm2_stream_order[i];
-            memset(l->tokens[j], 0, sizeof(**l->tokens) * l->tok_lens[j]);
+            if (l->tok_lens[j])
+                memset(l->tokens[j], 0, sizeof(**l->tokens) * l->tok_lens[j]);
             return t;
         }
         offset += t;
diff --git a/mythtv/external/FFmpeg/libavcodec/tscc.c b/mythtv/external/FFmpeg/libavcodec/tscc.c
index bd5fe035cf0..cb86b584c1d 100644
--- a/mythtv/external/FFmpeg/libavcodec/tscc.c
+++ b/mythtv/external/FFmpeg/libavcodec/tscc.c
@@ -98,11 +98,14 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 
     /* make the palette available on the way out */
     if (c->avctx->pix_fmt == AV_PIX_FMT_PAL8) {
-        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
+        int size;
+        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
 
-        if (pal) {
+        if (pal && size == AVPALETTE_SIZE) {
             frame->palette_has_changed = 1;
             memcpy(c->pal, pal, AVPALETTE_SIZE);
+        } else if (pal) {
+            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
         }
         memcpy(frame->data[1], c->pal, AVPALETTE_SIZE);
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/tscc2.c b/mythtv/external/FFmpeg/libavcodec/tscc2.c
index f64c76507ec..a8c7ee79961 100644
--- a/mythtv/external/FFmpeg/libavcodec/tscc2.c
+++ b/mythtv/external/FFmpeg/libavcodec/tscc2.c
@@ -235,18 +235,15 @@ static int tscc2_decode_frame(AVCodecContext *avctx, void *data,
         return AVERROR_INVALIDDATA;
     }
 
-    if ((ret = ff_reget_buffer(avctx, c->pic)) < 0) {
-        return ret;
-    }
-
     if (frame_type == 0) {
-        *got_frame      = 1;
-        if ((ret = av_frame_ref(data, c->pic)) < 0)
-            return ret;
-
+        // Skip duplicate frames
         return buf_size;
     }
 
+    if ((ret = ff_reget_buffer(avctx, c->pic)) < 0) {
+        return ret;
+    }
+
     if (bytestream2_get_bytes_left(&gb) < 4) {
         av_log(avctx, AV_LOG_ERROR, "Frame is too short\n");
         return AVERROR_INVALIDDATA;
diff --git a/mythtv/external/FFmpeg/libavcodec/tscc2data.h b/mythtv/external/FFmpeg/libavcodec/tscc2data.h
index 7cd6f5216ec..5e8d18b3f58 100644
--- a/mythtv/external/FFmpeg/libavcodec/tscc2data.h
+++ b/mythtv/external/FFmpeg/libavcodec/tscc2data.h
@@ -903,14 +903,14 @@ static const int tscc2_ac_vlc_sizes[NUM_VLC_SETS] = {
     172, 169, 165, 162, 131, 132, 130, 125, 121, 114, 110, 101, 96
 };
 
-static const uint16_t *tscc2_ac_vlc_syms[NUM_VLC_SETS] = {
+static const uint16_t * const tscc2_ac_vlc_syms[NUM_VLC_SETS] = {
     ac_vlc_desc0_syms, ac_vlc_desc1_syms, ac_vlc_desc2_syms, ac_vlc_desc3_syms,
     ac_vlc_desc4_syms, ac_vlc_desc5_syms, ac_vlc_desc6_syms, ac_vlc_desc7_syms,
     ac_vlc_desc8_syms, ac_vlc_desc9_syms, ac_vlc_descA_syms, ac_vlc_descB_syms,
     ac_vlc_descC_syms,
 };
 
-static const uint16_t *tscc2_ac_vlc_codes[NUM_VLC_SETS] = {
+static const uint16_t * const tscc2_ac_vlc_codes[NUM_VLC_SETS] = {
     ac_vlc_desc0_codes, ac_vlc_desc1_codes, ac_vlc_desc2_codes,
     ac_vlc_desc3_codes, ac_vlc_desc4_codes, ac_vlc_desc5_codes,
     ac_vlc_desc6_codes, ac_vlc_desc7_codes, ac_vlc_desc8_codes,
@@ -918,7 +918,7 @@ static const uint16_t *tscc2_ac_vlc_codes[NUM_VLC_SETS] = {
     ac_vlc_descC_codes,
 };
 
-static const uint8_t *tscc2_ac_vlc_bits[NUM_VLC_SETS] = {
+static const uint8_t * const tscc2_ac_vlc_bits[NUM_VLC_SETS] = {
     ac_vlc_desc0_bits, ac_vlc_desc1_bits, ac_vlc_desc2_bits, ac_vlc_desc3_bits,
     ac_vlc_desc4_bits, ac_vlc_desc5_bits, ac_vlc_desc6_bits, ac_vlc_desc7_bits,
     ac_vlc_desc8_bits, ac_vlc_desc9_bits, ac_vlc_descA_bits, ac_vlc_descB_bits,
diff --git a/mythtv/external/FFmpeg/libavcodec/tta.c b/mythtv/external/FFmpeg/libavcodec/tta.c
index c0162c5849e..8f097b3bcc7 100644
--- a/mythtv/external/FFmpeg/libavcodec/tta.c
+++ b/mythtv/external/FFmpeg/libavcodec/tta.c
@@ -285,7 +285,7 @@ static int tta_decode_frame(AVCodecContext *avctx, void *data,
         }
 
         if (k) {
-            if (k > MIN_CACHE_BITS) {
+            if (k > MIN_CACHE_BITS || unary > INT32_MAX >> k) {
                 ret = AVERROR_INVALIDDATA;
                 goto error;
             }
diff --git a/mythtv/external/FFmpeg/libavcodec/txd.c b/mythtv/external/FFmpeg/libavcodec/txd.c
index d7fdde0872c..8b20475d392 100644
--- a/mythtv/external/FFmpeg/libavcodec/txd.c
+++ b/mythtv/external/FFmpeg/libavcodec/txd.c
@@ -56,8 +56,7 @@ static int txd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     flags           = bytestream2_get_byte(&gb);
 
     if (version < 8 || version > 9) {
-        av_log(avctx, AV_LOG_ERROR, "texture data version %i is unsupported\n",
-                                                                    version);
+        avpriv_report_missing_feature(avctx, "Texture data version %u", version);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -66,7 +65,7 @@ static int txd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     } else if (depth == 16 || depth == 32) {
         avctx->pix_fmt = AV_PIX_FMT_RGBA;
     } else {
-        av_log(avctx, AV_LOG_ERROR, "depth of %i is unsupported\n", depth);
+        avpriv_report_missing_feature(avctx, "Color depth of %u", depth);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -149,7 +148,7 @@ static int txd_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     return avpkt->size;
 
 unsupported:
-    av_log(avctx, AV_LOG_ERROR, "unsupported d3d format (%08x)\n", d3d_format);
+    avpriv_report_missing_feature(avctx, "d3d format (%08x)", d3d_format);
     return AVERROR_PATCHWELCOME;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/utils.c b/mythtv/external/FFmpeg/libavcodec/utils.c
index 87de15fc620..9551f312e72 100644
--- a/mythtv/external/FFmpeg/libavcodec/utils.c
+++ b/mythtv/external/FFmpeg/libavcodec/utils.c
@@ -44,6 +44,7 @@
 #include "libavutil/dict.h"
 #include "libavutil/thread.h"
 #include "avcodec.h"
+#include "decode.h"
 #include "libavutil/opt.h"
 #include "me_cmp.h"
 #include "mpegvideo.h"
@@ -172,7 +173,7 @@ int av_codec_is_encoder(const AVCodec *codec)
 
 int av_codec_is_decoder(const AVCodec *codec)
 {
-    return codec && (codec->decode || codec->send_packet);
+    return codec && (codec->decode || codec->receive_frame);
 }
 
 av_cold void avcodec_register(AVCodec *codec)
@@ -209,7 +210,7 @@ void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
 
 int ff_set_dimensions(AVCodecContext *s, int width, int height)
 {
-    int ret = av_image_check_size(width, height, 0, s);
+    int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s);
 
     if (ret < 0)
         width = height = 0;
@@ -376,6 +377,10 @@ void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
             w_align = 4;
             h_align = 4;
         }
+        if (s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
+            w_align = 8;
+            h_align = 8;
+        }
         break;
     case AV_PIX_FMT_PAL8:
     case AV_PIX_FMT_BGR8:
@@ -385,7 +390,8 @@ void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
             w_align = 4;
             h_align = 4;
         }
-        if (s->codec_id == AV_CODEC_ID_JV) {
+        if (s->codec_id == AV_CODEC_ID_JV ||
+            s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
             w_align = 8;
             h_align = 8;
         }
@@ -503,200 +509,6 @@ int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
     return ret;
 }
 
-static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
-{
-    FramePool *pool = avctx->internal->pool;
-    int i, ret;
-
-    switch (avctx->codec_type) {
-    case AVMEDIA_TYPE_VIDEO: {
-        uint8_t *data[4];
-        int linesize[4];
-        int size[4] = { 0 };
-        int w = frame->width;
-        int h = frame->height;
-        int tmpsize, unaligned;
-
-        if (pool->format == frame->format &&
-            pool->width == frame->width && pool->height == frame->height)
-            return 0;
-
-        avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
-
-        do {
-            // NOTE: do not align linesizes individually, this breaks e.g. assumptions
-            // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
-            ret = av_image_fill_linesizes(linesize, avctx->pix_fmt, w);
-            if (ret < 0)
-                return ret;
-            // increase alignment of w for next try (rhs gives the lowest bit set in w)
-            w += w & ~(w - 1);
-
-            unaligned = 0;
-            for (i = 0; i < 4; i++)
-                unaligned |= linesize[i] % pool->stride_align[i];
-        } while (unaligned);
-
-        tmpsize = av_image_fill_pointers(data, avctx->pix_fmt, h,
-                                         NULL, linesize);
-        if (tmpsize < 0)
-            return -1;
-
-        for (i = 0; i < 3 && data[i + 1]; i++)
-            size[i] = data[i + 1] - data[i];
-        size[i] = tmpsize - (data[i] - data[0]);
-
-        for (i = 0; i < 4; i++) {
-            av_buffer_pool_uninit(&pool->pools[i]);
-            pool->linesize[i] = linesize[i];
-            if (size[i]) {
-                pool->pools[i] = av_buffer_pool_init(size[i] + 16 + STRIDE_ALIGN - 1,
-                                                     CONFIG_MEMORY_POISONING ?
-                                                        NULL :
-                                                        av_buffer_allocz);
-                if (!pool->pools[i]) {
-                    ret = AVERROR(ENOMEM);
-                    goto fail;
-                }
-            }
-        }
-        pool->format = frame->format;
-        pool->width  = frame->width;
-        pool->height = frame->height;
-
-        break;
-        }
-    case AVMEDIA_TYPE_AUDIO: {
-        int ch     = av_frame_get_channels(frame); //av_get_channel_layout_nb_channels(frame->channel_layout);
-        int planar = av_sample_fmt_is_planar(frame->format);
-        int planes = planar ? ch : 1;
-
-        if (pool->format == frame->format && pool->planes == planes &&
-            pool->channels == ch && frame->nb_samples == pool->samples)
-            return 0;
-
-        av_buffer_pool_uninit(&pool->pools[0]);
-        ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
-                                         frame->nb_samples, frame->format, 0);
-        if (ret < 0)
-            goto fail;
-
-        pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
-        if (!pool->pools[0]) {
-            ret = AVERROR(ENOMEM);
-            goto fail;
-        }
-
-        pool->format     = frame->format;
-        pool->planes     = planes;
-        pool->channels   = ch;
-        pool->samples = frame->nb_samples;
-        break;
-        }
-    default: av_assert0(0);
-    }
-    return 0;
-fail:
-    for (i = 0; i < 4; i++)
-        av_buffer_pool_uninit(&pool->pools[i]);
-    pool->format = -1;
-    pool->planes = pool->channels = pool->samples = 0;
-    pool->width  = pool->height = 0;
-    return ret;
-}
-
-static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
-{
-    FramePool *pool = avctx->internal->pool;
-    int planes = pool->planes;
-    int i;
-
-    frame->linesize[0] = pool->linesize[0];
-
-    if (planes > AV_NUM_DATA_POINTERS) {
-        frame->extended_data = av_mallocz_array(planes, sizeof(*frame->extended_data));
-        frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
-        frame->extended_buf  = av_mallocz_array(frame->nb_extended_buf,
-                                          sizeof(*frame->extended_buf));
-        if (!frame->extended_data || !frame->extended_buf) {
-            av_freep(&frame->extended_data);
-            av_freep(&frame->extended_buf);
-            return AVERROR(ENOMEM);
-        }
-    } else {
-        frame->extended_data = frame->data;
-        av_assert0(frame->nb_extended_buf == 0);
-    }
-
-    for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
-        frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
-        if (!frame->buf[i])
-            goto fail;
-        frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
-    }
-    for (i = 0; i < frame->nb_extended_buf; i++) {
-        frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
-        if (!frame->extended_buf[i])
-            goto fail;
-        frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
-    }
-
-    if (avctx->debug & FF_DEBUG_BUFFERS)
-        av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
-
-    return 0;
-fail:
-    av_frame_unref(frame);
-    return AVERROR(ENOMEM);
-}
-
-static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
-{
-    FramePool *pool = s->internal->pool;
-    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pic->format);
-    int i;
-
-    if (pic->data[0] || pic->data[1] || pic->data[2] || pic->data[3]) {
-        av_log(s, AV_LOG_ERROR, "pic->data[*]!=NULL in avcodec_default_get_buffer\n");
-        return -1;
-    }
-
-    if (!desc) {
-        av_log(s, AV_LOG_ERROR,
-            "Unable to get pixel format descriptor for format %s\n",
-            av_get_pix_fmt_name(pic->format));
-        return AVERROR(EINVAL);
-    }
-
-    memset(pic->data, 0, sizeof(pic->data));
-    pic->extended_data = pic->data;
-
-    for (i = 0; i < 4 && pool->pools[i]; i++) {
-        pic->linesize[i] = pool->linesize[i];
-
-        pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
-        if (!pic->buf[i])
-            goto fail;
-
-        pic->data[i] = pic->buf[i]->data;
-    }
-    for (; i < AV_NUM_DATA_POINTERS; i++) {
-        pic->data[i] = NULL;
-        pic->linesize[i] = 0;
-    }
-    if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
-        desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
-        avpriv_set_systematic_pal2((uint32_t *)pic->data[1], pic->format);
-
-    if (s->debug & FF_DEBUG_BUFFERS)
-        av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
-
-    return 0;
-fail:
-    av_frame_unref(pic);
-    return AVERROR(ENOMEM);
-}
-
 void ff_color_frame(AVFrame *frame, const int c[4])
 {
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
@@ -720,287 +532,6 @@ void ff_color_frame(AVFrame *frame, const int c[4])
     }
 }
 
-int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
-{
-    int ret;
-
-    if (avctx->hw_frames_ctx)
-        return av_hwframe_get_buffer(avctx->hw_frames_ctx, frame, 0);
-
-    if ((ret = update_frame_pool(avctx, frame)) < 0)
-        return ret;
-
-    switch (avctx->codec_type) {
-    case AVMEDIA_TYPE_VIDEO:
-        return video_get_buffer(avctx, frame);
-    case AVMEDIA_TYPE_AUDIO:
-        return audio_get_buffer(avctx, frame);
-    default:
-        return -1;
-    }
-}
-
-static int add_metadata_from_side_data(AVPacket *avpkt, AVFrame *frame)
-{
-    int size;
-    const uint8_t *side_metadata;
-
-    AVDictionary **frame_md = avpriv_frame_get_metadatap(frame);
-
-    side_metadata = av_packet_get_side_data(avpkt,
-                                            AV_PKT_DATA_STRINGS_METADATA, &size);
-    return av_packet_unpack_dictionary(side_metadata, size, frame_md);
-}
-
-int ff_init_buffer_info(AVCodecContext *avctx, AVFrame *frame)
-{
-    AVPacket *pkt = avctx->internal->pkt;
-    int i;
-    static const struct {
-        enum AVPacketSideDataType packet;
-        enum AVFrameSideDataType frame;
-    } sd[] = {
-        { AV_PKT_DATA_REPLAYGAIN ,                AV_FRAME_DATA_REPLAYGAIN },
-        { AV_PKT_DATA_DISPLAYMATRIX,              AV_FRAME_DATA_DISPLAYMATRIX },
-        { AV_PKT_DATA_STEREO3D,                   AV_FRAME_DATA_STEREO3D },
-        { AV_PKT_DATA_AUDIO_SERVICE_TYPE,         AV_FRAME_DATA_AUDIO_SERVICE_TYPE },
-        { AV_PKT_DATA_MASTERING_DISPLAY_METADATA, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA },
-    };
-
-    if (pkt) {
-        frame->pts = pkt->pts;
-#if FF_API_PKT_PTS
-FF_DISABLE_DEPRECATION_WARNINGS
-        frame->pkt_pts = pkt->pts;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-        av_frame_set_pkt_pos     (frame, pkt->pos);
-        av_frame_set_pkt_duration(frame, pkt->duration);
-        av_frame_set_pkt_size    (frame, pkt->size);
-
-        for (i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
-            int size;
-            uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
-            if (packet_sd) {
-                AVFrameSideData *frame_sd = av_frame_new_side_data(frame,
-                                                                   sd[i].frame,
-                                                                   size);
-                if (!frame_sd)
-                    return AVERROR(ENOMEM);
-
-                memcpy(frame_sd->data, packet_sd, size);
-            }
-        }
-        add_metadata_from_side_data(pkt, frame);
-
-        if (pkt->flags & AV_PKT_FLAG_DISCARD) {
-            frame->flags |= AV_FRAME_FLAG_DISCARD;
-        } else {
-            frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
-        }
-    } else {
-        frame->pts = AV_NOPTS_VALUE;
-#if FF_API_PKT_PTS
-FF_DISABLE_DEPRECATION_WARNINGS
-        frame->pkt_pts = AV_NOPTS_VALUE;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-        av_frame_set_pkt_pos     (frame, -1);
-        av_frame_set_pkt_duration(frame, 0);
-        av_frame_set_pkt_size    (frame, -1);
-    }
-    frame->reordered_opaque = avctx->reordered_opaque;
-
-    if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
-        frame->color_primaries = avctx->color_primaries;
-    if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
-        frame->color_trc = avctx->color_trc;
-    if (av_frame_get_colorspace(frame) == AVCOL_SPC_UNSPECIFIED)
-        av_frame_set_colorspace(frame, avctx->colorspace);
-    if (av_frame_get_color_range(frame) == AVCOL_RANGE_UNSPECIFIED)
-        av_frame_set_color_range(frame, avctx->color_range);
-    if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
-        frame->chroma_location = avctx->chroma_sample_location;
-
-    switch (avctx->codec->type) {
-    case AVMEDIA_TYPE_VIDEO:
-        frame->format              = avctx->pix_fmt;
-        if (!frame->sample_aspect_ratio.num)
-            frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
-
-        if (frame->width && frame->height &&
-            av_image_check_sar(frame->width, frame->height,
-                               frame->sample_aspect_ratio) < 0) {
-            av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
-                   frame->sample_aspect_ratio.num,
-                   frame->sample_aspect_ratio.den);
-            frame->sample_aspect_ratio = (AVRational){ 0, 1 };
-        }
-
-        break;
-    case AVMEDIA_TYPE_AUDIO:
-        if (!frame->sample_rate)
-            frame->sample_rate    = avctx->sample_rate;
-        if (frame->format < 0)
-            frame->format         = avctx->sample_fmt;
-        if (!frame->channel_layout) {
-            if (avctx->channel_layout) {
-                 if (av_get_channel_layout_nb_channels(avctx->channel_layout) !=
-                     avctx->channels) {
-                     av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
-                            "configuration.\n");
-                     return AVERROR(EINVAL);
-                 }
-
-                frame->channel_layout = avctx->channel_layout;
-            } else {
-                if (avctx->channels > FF_SANE_NB_CHANNELS) {
-                    av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
-                           avctx->channels);
-                    return AVERROR(ENOSYS);
-                }
-            }
-        }
-        av_frame_set_channels(frame, avctx->channels);
-        break;
-    }
-    return 0;
-}
-
-int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
-{
-    return ff_init_buffer_info(avctx, frame);
-}
-
-static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
-{
-    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
-        int i;
-        int num_planes = av_pix_fmt_count_planes(frame->format);
-        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
-        int flags = desc ? desc->flags : 0;
-        if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
-            num_planes = 2;
-        for (i = 0; i < num_planes; i++) {
-            av_assert0(frame->data[i]);
-        }
-        // For now do not enforce anything for palette of pseudopal formats
-        if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PSEUDOPAL))
-            num_planes = 2;
-        // For formats without data like hwaccel allow unused pointers to be non-NULL.
-        for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
-            if (frame->data[i])
-                av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
-            frame->data[i] = NULL;
-        }
-    }
-}
-
-static int get_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
-{
-    const AVHWAccel *hwaccel = avctx->hwaccel;
-    int override_dimensions = 1;
-    int ret;
-
-    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
-        if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0 || avctx->pix_fmt<0) {
-            av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
-            return AVERROR(EINVAL);
-        }
-
-        if (frame->width <= 0 || frame->height <= 0) {
-            frame->width  = FFMAX(avctx->width,  AV_CEIL_RSHIFT(avctx->coded_width,  avctx->lowres));
-            frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
-            override_dimensions = 0;
-        }
-
-        if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
-            av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
-            return AVERROR(EINVAL);
-        }
-    }
-    ret = ff_decode_frame_props(avctx, frame);
-    if (ret < 0)
-        return ret;
-
-    if (hwaccel) {
-        if (hwaccel->alloc_frame) {
-            ret = hwaccel->alloc_frame(avctx, frame);
-            goto end;
-        }
-    } else
-        avctx->sw_pix_fmt = avctx->pix_fmt;
-
-    ret = avctx->get_buffer2(avctx, frame, flags);
-    if (ret >= 0)
-        validate_avframe_allocation(avctx, frame);
-
-end:
-    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions) {
-        frame->width  = avctx->width;
-        frame->height = avctx->height;
-    }
-
-    return ret;
-}
-
-int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
-{
-    int ret = get_buffer_internal(avctx, frame, flags);
-    if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-        frame->width = frame->height = 0;
-    }
-    return ret;
-}
-
-static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame)
-{
-    AVFrame *tmp;
-    int ret;
-
-    av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO);
-
-    if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
-        av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
-               frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
-        av_frame_unref(frame);
-    }
-
-    ff_init_buffer_info(avctx, frame);
-
-    if (!frame->data[0])
-        return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
-
-    if (av_frame_is_writable(frame))
-        return ff_decode_frame_props(avctx, frame);
-
-    tmp = av_frame_alloc();
-    if (!tmp)
-        return AVERROR(ENOMEM);
-
-    av_frame_move_ref(tmp, frame);
-
-    ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
-    if (ret < 0) {
-        av_frame_free(&tmp);
-        return ret;
-    }
-
-    av_frame_copy(frame, tmp);
-    av_frame_free(&tmp);
-
-    return 0;
-}
-
-int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
-{
-    int ret = reget_buffer_internal(avctx, frame);
-    if (ret < 0)
-        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
-    return ret;
-}
-
 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
 {
     int i;
@@ -1038,145 +569,6 @@ enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags,
     return AV_PIX_FMT_NONE;
 }
 
-static int is_hwaccel_pix_fmt(enum AVPixelFormat pix_fmt)
-{
-    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
-    return desc->flags & AV_PIX_FMT_FLAG_HWACCEL;
-}
-
-enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
-{
-    while (*fmt != AV_PIX_FMT_NONE && is_hwaccel_pix_fmt(*fmt))
-        ++fmt;
-    return fmt[0];
-}
-
-static AVHWAccel *find_hwaccel(enum AVCodecID codec_id,
-                               enum AVPixelFormat pix_fmt)
-{
-    AVHWAccel *hwaccel = NULL;
-
-    while ((hwaccel = av_hwaccel_next(hwaccel)))
-        if (hwaccel->id == codec_id
-            && hwaccel->pix_fmt == pix_fmt)
-            return hwaccel;
-    return NULL;
-}
-
-static int setup_hwaccel(AVCodecContext *avctx,
-                         const enum AVPixelFormat fmt,
-                         const char *name)
-{
-    AVHWAccel *hwa = find_hwaccel(avctx->codec_id, fmt);
-    int ret        = 0;
-
-    if (avctx->active_thread_type & FF_THREAD_FRAME) {
-        av_log(avctx, AV_LOG_WARNING,
-               "Hardware accelerated decoding with frame threading is known to be unstable and its use is discouraged.\n");
-    }
-
-    if (!hwa) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Could not find an AVHWAccel for the pixel format: %s",
-               name);
-        return AVERROR(ENOENT);
-    }
-
-    if (hwa->capabilities & HWACCEL_CODEC_CAP_EXPERIMENTAL &&
-        avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
-        av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
-               hwa->name);
-        return AVERROR_PATCHWELCOME;
-    }
-
-    if (hwa->priv_data_size) {
-        avctx->internal->hwaccel_priv_data = av_mallocz(hwa->priv_data_size);
-        if (!avctx->internal->hwaccel_priv_data)
-            return AVERROR(ENOMEM);
-    }
-
-    if (hwa->init) {
-        ret = hwa->init(avctx);
-        if (ret < 0) {
-            av_freep(&avctx->internal->hwaccel_priv_data);
-            return ret;
-        }
-    }
-
-    avctx->hwaccel = hwa;
-
-    return 0;
-}
-
-int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
-{
-    const AVPixFmtDescriptor *desc;
-    enum AVPixelFormat *choices;
-    enum AVPixelFormat ret;
-    unsigned n = 0;
-
-    while (fmt[n] != AV_PIX_FMT_NONE)
-        ++n;
-
-    av_assert0(n >= 1);
-    avctx->sw_pix_fmt = fmt[n - 1];
-    av_assert2(!is_hwaccel_pix_fmt(avctx->sw_pix_fmt));
-
-    choices = av_malloc_array(n + 1, sizeof(*choices));
-    if (!choices)
-        return AV_PIX_FMT_NONE;
-
-    memcpy(choices, fmt, (n + 1) * sizeof(*choices));
-
-    for (;;) {
-        if (avctx->hwaccel && avctx->hwaccel->uninit)
-            avctx->hwaccel->uninit(avctx);
-        av_freep(&avctx->internal->hwaccel_priv_data);
-        avctx->hwaccel = NULL;
-
-        av_buffer_unref(&avctx->hw_frames_ctx);
-
-        ret = avctx->get_format(avctx, choices);
-
-        desc = av_pix_fmt_desc_get(ret);
-        if (!desc) {
-            ret = AV_PIX_FMT_NONE;
-            break;
-        }
-
-        if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
-            break;
-#if FF_API_CAP_VDPAU
-        if (avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU)
-            break;
-#endif
-
-        if (avctx->hw_frames_ctx) {
-            AVHWFramesContext *hw_frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
-            if (hw_frames_ctx->format != ret) {
-                av_log(avctx, AV_LOG_ERROR, "Format returned from get_buffer() "
-                       "does not match the format of provided AVHWFramesContext\n");
-                ret = AV_PIX_FMT_NONE;
-                break;
-            }
-        }
-
-        if (!setup_hwaccel(avctx, ret, desc->name))
-            break;
-
-        /* Remove failed hwaccel from choices */
-        for (n = 0; choices[n] != ret; n++)
-            av_assert0(choices[n] != AV_PIX_FMT_NONE);
-
-        do
-            choices[n] = choices[n + 1];
-        while (choices[n++] != AV_PIX_FMT_NONE);
-    }
-
-    av_freep(&choices);
-    return ret;
-}
-
 MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
 MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
 MAKE_ACCESSORS(AVCodecContext, codec, int, lowres)
@@ -1197,12 +589,6 @@ int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec){
     return !!(codec->caps_internal & FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM);
 }
 
-static void get_subtitle_defaults(AVSubtitle *sub)
-{
-    memset(sub, 0, sizeof(*sub));
-    sub->pts = AV_NOPTS_VALUE;
-}
-
 static int64_t get_bit_rate(AVCodecContext *ctx)
 {
     int64_t bit_rate;
@@ -1287,6 +673,12 @@ int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *code
         goto free_and_end;
     }
 
+    avctx->internal->compat_decode_frame = av_frame_alloc();
+    if (!avctx->internal->compat_decode_frame) {
+        ret = AVERROR(ENOMEM);
+        goto free_and_end;
+    }
+
     avctx->internal->buffer_frame = av_frame_alloc();
     if (!avctx->internal->buffer_frame) {
         ret = AVERROR(ENOMEM);
@@ -1299,6 +691,20 @@ int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *code
         goto free_and_end;
     }
 
+    avctx->internal->ds.in_pkt = av_packet_alloc();
+    if (!avctx->internal->ds.in_pkt) {
+        ret = AVERROR(ENOMEM);
+        goto free_and_end;
+    }
+
+    avctx->internal->last_pkt_props = av_packet_alloc();
+    if (!avctx->internal->last_pkt_props) {
+        ret = AVERROR(ENOMEM);
+        goto free_and_end;
+    }
+
+    avctx->internal->skip_samples_multiplier = 1;
+
     if (codec->priv_data_size > 0) {
         if (!avctx->priv_data) {
             avctx->priv_data = av_mallocz(codec->priv_data_size);
@@ -1337,8 +743,8 @@ int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *code
     }
 
     if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
-        && (  av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
-           || av_image_check_size(avctx->width,       avctx->height,       0, avctx) < 0)) {
+        && (  av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
+           || av_image_check_size2(avctx->width,       avctx->height,       avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
         av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
         ff_set_dimensions(avctx, 0, 0);
     }
@@ -1561,11 +967,11 @@ FF_ENABLE_DEPRECATION_WARNINGS
         }
         if (   (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
             && avctx->bit_rate>0 && avctx->bit_rate<1000) {
-            av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", (int64_t)avctx->bit_rate, (int64_t)avctx->bit_rate);
+            av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
         }
 
         if (!avctx->rc_initial_buffer_occupancy)
-            avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3 / 4;
+            avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
 
         if (avctx->ticks_per_frame && avctx->time_base.num &&
             avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
@@ -1585,1164 +991,154 @@ FF_ENABLE_DEPRECATION_WARNINGS
                 ret = AVERROR(EINVAL);
                 goto free_and_end;
             }
-        }
-    }
-
-    avctx->pts_correction_num_faulty_pts =
-    avctx->pts_correction_num_faulty_dts = 0;
-    avctx->pts_correction_last_pts =
-    avctx->pts_correction_last_dts = INT64_MIN;
-
-    if (   !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
-        && avctx->codec_descriptor->type == AVMEDIA_TYPE_VIDEO)
-        av_log(avctx, AV_LOG_WARNING,
-               "gray decoding requested but not enabled at configuration time\n");
-
-    if (   avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
-        || avctx->internal->frame_thread_encoder)) {
-        ret = avctx->codec->init(avctx);
-        if (ret < 0) {
-            goto free_and_end;
-        }
-    }
-
-    ret=0;
-
-#if FF_API_AUDIOENC_DELAY
-    if (av_codec_is_encoder(avctx->codec))
-        avctx->delay = avctx->initial_padding;
-#endif
-
-    if (av_codec_is_decoder(avctx->codec)) {
-        if (!avctx->bit_rate)
-            avctx->bit_rate = get_bit_rate(avctx);
-        /* validate channel layout from the decoder */
-        if (avctx->channel_layout) {
-            int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
-            if (!avctx->channels)
-                avctx->channels = channels;
-            else if (channels != avctx->channels) {
-                char buf[512];
-                av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
-                av_log(avctx, AV_LOG_WARNING,
-                       "Channel layout '%s' with %d channels does not match specified number of channels %d: "
-                       "ignoring specified channel layout\n",
-                       buf, channels, avctx->channels);
-                avctx->channel_layout = 0;
-            }
-        }
-        if (avctx->channels && avctx->channels < 0 ||
-            avctx->channels > FF_SANE_NB_CHANNELS) {
-            ret = AVERROR(EINVAL);
-            goto free_and_end;
-        }
-        if (avctx->sub_charenc) {
-            if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
-                av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
-                       "supported with subtitles codecs\n");
+            if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
+                avctx->sw_pix_fmt != frames_ctx->sw_format) {
+                av_log(avctx, AV_LOG_ERROR,
+                       "Mismatching AVCodecContext.sw_pix_fmt (%s) "
+                       "and AVHWFramesContext.sw_format (%s)\n",
+                       av_get_pix_fmt_name(avctx->sw_pix_fmt),
+                       av_get_pix_fmt_name(frames_ctx->sw_format));
                 ret = AVERROR(EINVAL);
                 goto free_and_end;
-            } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
-                av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
-                       "subtitles character encoding will be ignored\n",
-                       avctx->codec_descriptor->name);
-                avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
-            } else {
-                /* input character encoding is set for a text based subtitle
-                 * codec at this point */
-                if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
-                    avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
-
-                if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
-#if CONFIG_ICONV
-                    iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
-                    if (cd == (iconv_t)-1) {
-                        ret = AVERROR(errno);
-                        av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
-                               "with input character encoding \"%s\"\n", avctx->sub_charenc);
-                        goto free_and_end;
-                    }
-                    iconv_close(cd);
-#else
-                    av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
-                           "conversion needs a libavcodec built with iconv support "
-                           "for this codec\n");
-                    ret = AVERROR(ENOSYS);
-                    goto free_and_end;
-#endif
-                }
-            }
-        }
-
-#if FF_API_AVCTX_TIMEBASE
-        if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
-            avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
-#endif
-    }
-    if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
-        av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
-    }
-
-end:
-    ff_unlock_avcodec(codec);
-    if (options) {
-        av_dict_free(options);
-        *options = tmp;
-    }
-
-    return ret;
-free_and_end:
-    if (avctx->codec &&
-        (avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP))
-        avctx->codec->close(avctx);
-
-    if (codec->priv_class && codec->priv_data_size)
-        av_opt_free(avctx->priv_data);
-    av_opt_free(avctx);
-
-#if FF_API_CODED_FRAME
-FF_DISABLE_DEPRECATION_WARNINGS
-    av_frame_free(&avctx->coded_frame);
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-
-    av_dict_free(&tmp);
-    av_freep(&avctx->priv_data);
-    if (avctx->internal) {
-        av_packet_free(&avctx->internal->buffer_pkt);
-        av_frame_free(&avctx->internal->buffer_frame);
-        av_frame_free(&avctx->internal->to_free);
-        av_freep(&avctx->internal->pool);
-    }
-    av_freep(&avctx->internal);
-    avctx->codec = NULL;
-    goto end;
-}
-
-int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
-{
-    if (avpkt->size < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Invalid negative user packet size %d\n", avpkt->size);
-        return AVERROR(EINVAL);
-    }
-    if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
-        av_log(avctx, AV_LOG_ERROR, "Invalid minimum required packet size %"PRId64" (max allowed is %d)\n",
-               size, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
-        return AVERROR(EINVAL);
-    }
-
-    if (avctx && 2*min_size < size) { // FIXME The factor needs to be finetuned
-        av_assert0(!avpkt->data || avpkt->data != avctx->internal->byte_buffer);
-        if (!avpkt->data || avpkt->size < size) {
-            av_fast_padded_malloc(&avctx->internal->byte_buffer, &avctx->internal->byte_buffer_size, size);
-            avpkt->data = avctx->internal->byte_buffer;
-            avpkt->size = avctx->internal->byte_buffer_size;
-        }
-    }
-
-    if (avpkt->data) {
-        AVBufferRef *buf = avpkt->buf;
-
-        if (avpkt->size < size) {
-            av_log(avctx, AV_LOG_ERROR, "User packet is too small (%d < %"PRId64")\n", avpkt->size, size);
-            return AVERROR(EINVAL);
-        }
-
-        av_init_packet(avpkt);
-        avpkt->buf      = buf;
-        avpkt->size     = size;
-        return 0;
-    } else {
-        int ret = av_new_packet(avpkt, size);
-        if (ret < 0)
-            av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %"PRId64"\n", size);
-        return ret;
-    }
-}
-
-int ff_alloc_packet(AVPacket *avpkt, int size)
-{
-    return ff_alloc_packet2(NULL, avpkt, size, 0);
-}
-
-/**
- * Pad last frame with silence.
- */
-static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
-{
-    AVFrame *frame = NULL;
-    int ret;
-
-    if (!(frame = av_frame_alloc()))
-        return AVERROR(ENOMEM);
-
-    frame->format         = src->format;
-    frame->channel_layout = src->channel_layout;
-    av_frame_set_channels(frame, av_frame_get_channels(src));
-    frame->nb_samples     = s->frame_size;
-    ret = av_frame_get_buffer(frame, 32);
-    if (ret < 0)
-        goto fail;
-
-    ret = av_frame_copy_props(frame, src);
-    if (ret < 0)
-        goto fail;
-
-    if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
-                               src->nb_samples, s->channels, s->sample_fmt)) < 0)
-        goto fail;
-    if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
-                                      frame->nb_samples - src->nb_samples,
-                                      s->channels, s->sample_fmt)) < 0)
-        goto fail;
-
-    *dst = frame;
-
-    return 0;
-
-fail:
-    av_frame_free(&frame);
-    return ret;
-}
-
-int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
-                                              AVPacket *avpkt,
-                                              const AVFrame *frame,
-                                              int *got_packet_ptr)
-{
-    AVFrame *extended_frame = NULL;
-    AVFrame *padded_frame = NULL;
-    int ret;
-    AVPacket user_pkt = *avpkt;
-    int needs_realloc = !user_pkt.data;
-
-    *got_packet_ptr = 0;
-
-    if (!avctx->codec->encode2) {
-        av_log(avctx, AV_LOG_ERROR, "This encoder requires using the avcodec_send_frame() API.\n");
-        return AVERROR(ENOSYS);
-    }
-
-    if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
-        av_packet_unref(avpkt);
-        av_init_packet(avpkt);
-        return 0;
-    }
-
-    /* ensure that extended_data is properly set */
-    if (frame && !frame->extended_data) {
-        if (av_sample_fmt_is_planar(avctx->sample_fmt) &&
-            avctx->channels > AV_NUM_DATA_POINTERS) {
-            av_log(avctx, AV_LOG_ERROR, "Encoding to a planar sample format, "
-                                        "with more than %d channels, but extended_data is not set.\n",
-                   AV_NUM_DATA_POINTERS);
-            return AVERROR(EINVAL);
-        }
-        av_log(avctx, AV_LOG_WARNING, "extended_data is not set.\n");
-
-        extended_frame = av_frame_alloc();
-        if (!extended_frame)
-            return AVERROR(ENOMEM);
-
-        memcpy(extended_frame, frame, sizeof(AVFrame));
-        extended_frame->extended_data = extended_frame->data;
-        frame = extended_frame;
-    }
-
-    /* extract audio service type metadata */
-    if (frame) {
-        AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_AUDIO_SERVICE_TYPE);
-        if (sd && sd->size >= sizeof(enum AVAudioServiceType))
-            avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;
-    }
-
-    /* check for valid frame size */
-    if (frame) {
-        if (avctx->codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME) {
-            if (frame->nb_samples > avctx->frame_size) {
-                av_log(avctx, AV_LOG_ERROR, "more samples than frame size (avcodec_encode_audio2)\n");
-                ret = AVERROR(EINVAL);
-                goto end;
-            }
-        } else if (!(avctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)) {
-            if (frame->nb_samples < avctx->frame_size &&
-                !avctx->internal->last_audio_frame) {
-                ret = pad_last_frame(avctx, &padded_frame, frame);
-                if (ret < 0)
-                    goto end;
-
-                frame = padded_frame;
-                avctx->internal->last_audio_frame = 1;
-            }
-
-            if (frame->nb_samples != avctx->frame_size) {
-                av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) != frame_size (%d) (avcodec_encode_audio2)\n", frame->nb_samples, avctx->frame_size);
-                ret = AVERROR(EINVAL);
-                goto end;
-            }
-        }
-    }
-
-    av_assert0(avctx->codec->encode2);
-
-    ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
-    if (!ret) {
-        if (*got_packet_ptr) {
-            if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY)) {
-                if (avpkt->pts == AV_NOPTS_VALUE)
-                    avpkt->pts = frame->pts;
-                if (!avpkt->duration)
-                    avpkt->duration = ff_samples_to_time_base(avctx,
-                                                              frame->nb_samples);
-            }
-            avpkt->dts = avpkt->pts;
-        } else {
-            avpkt->size = 0;
-        }
-    }
-    if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
-        needs_realloc = 0;
-        if (user_pkt.data) {
-            if (user_pkt.size >= avpkt->size) {
-                memcpy(user_pkt.data, avpkt->data, avpkt->size);
-            } else {
-                av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
-                avpkt->size = user_pkt.size;
-                ret = -1;
-            }
-            avpkt->buf      = user_pkt.buf;
-            avpkt->data     = user_pkt.data;
-        } else {
-            if (av_dup_packet(avpkt) < 0) {
-                ret = AVERROR(ENOMEM);
-            }
-        }
-    }
-
-    if (!ret) {
-        if (needs_realloc && avpkt->data) {
-            ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
-            if (ret >= 0)
-                avpkt->data = avpkt->buf->data;
-        }
-
-        avctx->frame_number++;
-    }
-
-    if (ret < 0 || !*got_packet_ptr) {
-        av_packet_unref(avpkt);
-        av_init_packet(avpkt);
-        goto end;
-    }
-
-    /* NOTE: if we add any audio encoders which output non-keyframe packets,
-     *       this needs to be moved to the encoders, but for now we can do it
-     *       here to simplify things */
-    avpkt->flags |= AV_PKT_FLAG_KEY;
-
-end:
-    av_frame_free(&padded_frame);
-    av_free(extended_frame);
-
-#if FF_API_AUDIOENC_DELAY
-    avctx->delay = avctx->initial_padding;
-#endif
-
-    return ret;
-}
-
-int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
-                                              AVPacket *avpkt,
-                                              const AVFrame *frame,
-                                              int *got_packet_ptr)
-{
-    int ret;
-    AVPacket user_pkt = *avpkt;
-    int needs_realloc = !user_pkt.data;
-
-    *got_packet_ptr = 0;
-
-    if (!avctx->codec->encode2) {
-        av_log(avctx, AV_LOG_ERROR, "This encoder requires using the avcodec_send_frame() API.\n");
-        return AVERROR(ENOSYS);
-    }
-
-    if(CONFIG_FRAME_THREAD_ENCODER &&
-       avctx->internal->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))
-        return ff_thread_video_encode_frame(avctx, avpkt, frame, got_packet_ptr);
-
-    if ((avctx->flags&AV_CODEC_FLAG_PASS1) && avctx->stats_out)
-        avctx->stats_out[0] = '\0';
-
-    if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
-        av_packet_unref(avpkt);
-        av_init_packet(avpkt);
-        avpkt->size = 0;
-        return 0;
-    }
-
-    if (av_image_check_size(avctx->width, avctx->height, 0, avctx))
-        return AVERROR(EINVAL);
-
-    if (frame && frame->format == AV_PIX_FMT_NONE)
-        av_log(avctx, AV_LOG_WARNING, "AVFrame.format is not set\n");
-    if (frame && (frame->width == 0 || frame->height == 0))
-        av_log(avctx, AV_LOG_WARNING, "AVFrame.width or height is not set\n");
-
-    av_assert0(avctx->codec->encode2);
-
-    ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
-    av_assert0(ret <= 0);
-
-    emms_c();
-
-    if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
-        needs_realloc = 0;
-        if (user_pkt.data) {
-            if (user_pkt.size >= avpkt->size) {
-                memcpy(user_pkt.data, avpkt->data, avpkt->size);
-            } else {
-                av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
-                avpkt->size = user_pkt.size;
-                ret = -1;
-            }
-            avpkt->buf      = user_pkt.buf;
-            avpkt->data     = user_pkt.data;
-        } else {
-            if (av_dup_packet(avpkt) < 0) {
-                ret = AVERROR(ENOMEM);
-            }
-        }
-    }
-
-    if (!ret) {
-        if (!*got_packet_ptr)
-            avpkt->size = 0;
-        else if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
-            avpkt->pts = avpkt->dts = frame->pts;
-
-        if (needs_realloc && avpkt->data) {
-            ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
-            if (ret >= 0)
-                avpkt->data = avpkt->buf->data;
-        }
-
-        avctx->frame_number++;
-    }
-
-    if (ret < 0 || !*got_packet_ptr)
-        av_packet_unref(avpkt);
-
-    return ret;
-}
-
-int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
-                            const AVSubtitle *sub)
-{
-    int ret;
-    if (sub->start_display_time) {
-        av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
-        return -1;
-    }
-
-    ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
-    avctx->frame_number++;
-    return ret;
-}
-
-/**
- * Attempt to guess proper monotonic timestamps for decoded video frames
- * which might have incorrect times. Input timestamps may wrap around, in
- * which case the output will as well.
- *
- * @param pts the pts field of the decoded AVPacket, as passed through
- * AVFrame.pts
- * @param dts the dts field of the decoded AVPacket
- * @return one of the input values, may be AV_NOPTS_VALUE
- */
-static int64_t guess_correct_pts(AVCodecContext *ctx,
-                                 int64_t reordered_pts, int64_t dts)
-{
-    int64_t pts = AV_NOPTS_VALUE;
-
-    if (dts != AV_NOPTS_VALUE) {
-        ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
-        ctx->pts_correction_last_dts = dts;
-    } else if (reordered_pts != AV_NOPTS_VALUE)
-        ctx->pts_correction_last_dts = reordered_pts;
-
-    if (reordered_pts != AV_NOPTS_VALUE) {
-        ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
-        ctx->pts_correction_last_pts = reordered_pts;
-    } else if(dts != AV_NOPTS_VALUE)
-        ctx->pts_correction_last_pts = dts;
-
-    if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
-       && reordered_pts != AV_NOPTS_VALUE)
-        pts = reordered_pts;
-    else
-        pts = dts;
-
-    return pts;
-}
-
-static int apply_param_change(AVCodecContext *avctx, AVPacket *avpkt)
-{
-    int size = 0, ret;
-    const uint8_t *data;
-    uint32_t flags;
-    int64_t val;
-
-    data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
-    if (!data)
-        return 0;
-
-    if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
-        av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
-               "changes, but PARAM_CHANGE side data was sent to it.\n");
-        ret = AVERROR(EINVAL);
-        goto fail2;
-    }
-
-    if (size < 4)
-        goto fail;
-
-    flags = bytestream_get_le32(&data);
-    size -= 4;
-
-    if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
-        if (size < 4)
-            goto fail;
-        val = bytestream_get_le32(&data);
-        if (val <= 0 || val > INT_MAX) {
-            av_log(avctx, AV_LOG_ERROR, "Invalid channel count");
-            ret = AVERROR_INVALIDDATA;
-            goto fail2;
-        }
-        avctx->channels = val;
-        size -= 4;
-    }
-    if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
-        if (size < 8)
-            goto fail;
-        avctx->channel_layout = bytestream_get_le64(&data);
-        size -= 8;
-    }
-    if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
-        if (size < 4)
-            goto fail;
-        val = bytestream_get_le32(&data);
-        if (val <= 0 || val > INT_MAX) {
-            av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
-            ret = AVERROR_INVALIDDATA;
-            goto fail2;
-        }
-        avctx->sample_rate = val;
-        size -= 4;
-    }
-    if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
-        if (size < 8)
-            goto fail;
-        avctx->width  = bytestream_get_le32(&data);
-        avctx->height = bytestream_get_le32(&data);
-        size -= 8;
-        ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
-        if (ret < 0)
-            goto fail2;
-    }
-
-    return 0;
-fail:
-    av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
-    ret = AVERROR_INVALIDDATA;
-fail2:
-    if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
-        if (avctx->err_recognition & AV_EF_EXPLODE)
-            return ret;
-    }
-    return 0;
-}
-
-static int unrefcount_frame(AVCodecInternal *avci, AVFrame *frame)
-{
-    int ret;
-
-    /* move the original frame to our backup */
-    av_frame_unref(avci->to_free);
-    av_frame_move_ref(avci->to_free, frame);
-
-    /* now copy everything except the AVBufferRefs back
-     * note that we make a COPY of the side data, so calling av_frame_free() on
-     * the caller's frame will work properly */
-    ret = av_frame_copy_props(frame, avci->to_free);
-    if (ret < 0)
-        return ret;
-
-    memcpy(frame->data,     avci->to_free->data,     sizeof(frame->data));
-    memcpy(frame->linesize, avci->to_free->linesize, sizeof(frame->linesize));
-    if (avci->to_free->extended_data != avci->to_free->data) {
-        int planes = av_frame_get_channels(avci->to_free);
-        int size   = planes * sizeof(*frame->extended_data);
-
-        if (!size) {
-            av_frame_unref(frame);
-            return AVERROR_BUG;
-        }
-
-        frame->extended_data = av_malloc(size);
-        if (!frame->extended_data) {
-            av_frame_unref(frame);
-            return AVERROR(ENOMEM);
-        }
-        memcpy(frame->extended_data, avci->to_free->extended_data,
-               size);
-    } else
-        frame->extended_data = frame->data;
-
-    frame->format         = avci->to_free->format;
-    frame->width          = avci->to_free->width;
-    frame->height         = avci->to_free->height;
-    frame->channel_layout = avci->to_free->channel_layout;
-    frame->nb_samples     = avci->to_free->nb_samples;
-    av_frame_set_channels(frame, av_frame_get_channels(avci->to_free));
-
-    return 0;
-}
-
-int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
-                                              int *got_picture_ptr,
-                                              const AVPacket *avpkt)
-{
-    AVCodecInternal *avci = avctx->internal;
-    int ret;
-    // copy to ensure we do not change avpkt
-    AVPacket tmp = *avpkt;
-
-    if (!avctx->codec)
-        return AVERROR(EINVAL);
-    if (avctx->codec->type != AVMEDIA_TYPE_VIDEO) {
-        av_log(avctx, AV_LOG_ERROR, "Invalid media type for video\n");
-        return AVERROR(EINVAL);
-    }
-
-    if (!avctx->codec->decode) {
-        av_log(avctx, AV_LOG_ERROR, "This decoder requires using the avcodec_send_packet() API.\n");
-        return AVERROR(ENOSYS);
-    }
-
-    *got_picture_ptr = 0;
-    if ((avctx->coded_width || avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
-        return AVERROR(EINVAL);
-
-    avctx->internal->pkt = avpkt;
-    ret = apply_param_change(avctx, avpkt);
-    if (ret < 0)
-        return ret;
-
-    av_frame_unref(picture);
-
-    if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size ||
-        (avctx->active_thread_type & FF_THREAD_FRAME)) {
-        int did_split = av_packet_split_side_data(&tmp);
-        ret = apply_param_change(avctx, &tmp);
-        if (ret < 0)
-            goto fail;
-
-        avctx->internal->pkt = &tmp;
-        if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
-            ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
-                                         &tmp);
-        else {
-            ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
-                                       &tmp);
-            if (!(avctx->codec->caps_internal & FF_CODEC_CAP_SETS_PKT_DTS))
-                picture->pkt_dts = avpkt->dts;
-
-            if(!avctx->has_b_frames){
-                av_frame_set_pkt_pos(picture, avpkt->pos);
-            }
-            //FIXME these should be under if(!avctx->has_b_frames)
-            /* get_buffer is supposed to set frame parameters */
-            if (!(avctx->codec->capabilities & AV_CODEC_CAP_DR1)) {
-                if (!picture->sample_aspect_ratio.num)    picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
-                if (!picture->width)                      picture->width               = avctx->width;
-                if (!picture->height)                     picture->height              = avctx->height;
-                if (picture->format == AV_PIX_FMT_NONE)   picture->format              = avctx->pix_fmt;
-            }
-        }
-
-fail:
-        emms_c(); //needed to avoid an emms_c() call before every return;
-
-        avctx->internal->pkt = NULL;
-        if (did_split) {
-            av_packet_free_side_data(&tmp);
-            if(ret == tmp.size)
-                ret = avpkt->size;
-        }
-        if (picture->flags & AV_FRAME_FLAG_DISCARD) {
-            *got_picture_ptr = 0;
-        }
-        if (*got_picture_ptr) {
-            if (!avctx->refcounted_frames) {
-                int err = unrefcount_frame(avci, picture);
-                if (err < 0)
-                    return err;
-            }
-
-            avctx->frame_number++;
-            av_frame_set_best_effort_timestamp(picture,
-                                               guess_correct_pts(avctx,
-                                                                 picture->pts,
-                                                                 picture->pkt_dts));
-        } else
-            av_frame_unref(picture);
-    } else
-        ret = 0;
-
-    /* many decoders assign whole AVFrames, thus overwriting extended_data;
-     * make sure it's set correctly */
-    av_assert0(!picture->extended_data || picture->extended_data == picture->data);
-
-#if FF_API_AVCTX_TIMEBASE
-    if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
-        avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
-#endif
-
-    return ret;
-}
-
-int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
-                                              AVFrame *frame,
-                                              int *got_frame_ptr,
-                                              const AVPacket *avpkt)
-{
-    AVCodecInternal *avci = avctx->internal;
-    int ret = 0;
-
-    *got_frame_ptr = 0;
-
-    if (!avctx->codec)
-        return AVERROR(EINVAL);
-
-    if (!avctx->codec->decode) {
-        av_log(avctx, AV_LOG_ERROR, "This decoder requires using the avcodec_send_packet() API.\n");
-        return AVERROR(ENOSYS);
-    }
-
-    if (!avpkt->data && avpkt->size) {
-        av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
-        return AVERROR(EINVAL);
-    }
-    if (avctx->codec->type != AVMEDIA_TYPE_AUDIO) {
-        av_log(avctx, AV_LOG_ERROR, "Invalid media type for audio\n");
-        return AVERROR(EINVAL);
-    }
-
-    av_frame_unref(frame);
-
-    if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type & FF_THREAD_FRAME)) {
-        uint8_t *side;
-        int side_size;
-        uint32_t discard_padding = 0;
-        uint8_t skip_reason = 0;
-        uint8_t discard_reason = 0;
-        // copy to ensure we do not change avpkt
-        AVPacket tmp = *avpkt;
-        int did_split = av_packet_split_side_data(&tmp);
-        ret = apply_param_change(avctx, &tmp);
-        if (ret < 0)
-            goto fail;
-
-        avctx->internal->pkt = &tmp;
-        if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
-            ret = ff_thread_decode_frame(avctx, frame, got_frame_ptr, &tmp);
-        else {
-            ret = avctx->codec->decode(avctx, frame, got_frame_ptr, &tmp);
-            av_assert0(ret <= tmp.size);
-            frame->pkt_dts = avpkt->dts;
-        }
-        if (ret >= 0 && *got_frame_ptr) {
-            avctx->frame_number++;
-            av_frame_set_best_effort_timestamp(frame,
-                                               guess_correct_pts(avctx,
-                                                                 frame->pts,
-                                                                 frame->pkt_dts));
-            if (frame->format == AV_SAMPLE_FMT_NONE)
-                frame->format = avctx->sample_fmt;
-            if (!frame->channel_layout)
-                frame->channel_layout = avctx->channel_layout;
-            if (!av_frame_get_channels(frame))
-                av_frame_set_channels(frame, avctx->channels);
-            if (!frame->sample_rate)
-                frame->sample_rate = avctx->sample_rate;
-        }
-
-        side= av_packet_get_side_data(avctx->internal->pkt, AV_PKT_DATA_SKIP_SAMPLES, &side_size);
-        if(side && side_size>=10) {
-            avctx->internal->skip_samples = AV_RL32(side);
-            discard_padding = AV_RL32(side + 4);
-            av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
-                   avctx->internal->skip_samples, (int)discard_padding);
-            skip_reason = AV_RL8(side + 8);
-            discard_reason = AV_RL8(side + 9);
-        }
-
-        if ((frame->flags & AV_FRAME_FLAG_DISCARD) && *got_frame_ptr &&
-            !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
-            avctx->internal->skip_samples -= frame->nb_samples;
-            *got_frame_ptr = 0;
-        }
-
-        if (avctx->internal->skip_samples > 0 && *got_frame_ptr &&
-            !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
-            if(frame->nb_samples <= avctx->internal->skip_samples){
-                *got_frame_ptr = 0;
-                avctx->internal->skip_samples -= frame->nb_samples;
-                av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
-                       avctx->internal->skip_samples);
-            } else {
-                av_samples_copy(frame->extended_data, frame->extended_data, 0, avctx->internal->skip_samples,
-                                frame->nb_samples - avctx->internal->skip_samples, avctx->channels, frame->format);
-                if(avctx->pkt_timebase.num && avctx->sample_rate) {
-                    int64_t diff_ts = av_rescale_q(avctx->internal->skip_samples,
-                                                   (AVRational){1, avctx->sample_rate},
-                                                   avctx->pkt_timebase);
-                    if(frame->pts!=AV_NOPTS_VALUE)
-                        frame->pts += diff_ts;
-#if FF_API_PKT_PTS
-FF_DISABLE_DEPRECATION_WARNINGS
-                    if(frame->pkt_pts!=AV_NOPTS_VALUE)
-                        frame->pkt_pts += diff_ts;
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-                    if(frame->pkt_dts!=AV_NOPTS_VALUE)
-                        frame->pkt_dts += diff_ts;
-                    if (av_frame_get_pkt_duration(frame) >= diff_ts)
-                        av_frame_set_pkt_duration(frame, av_frame_get_pkt_duration(frame) - diff_ts);
-                } else {
-                    av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
-                }
-                av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
-                       avctx->internal->skip_samples, frame->nb_samples);
-                frame->nb_samples -= avctx->internal->skip_samples;
-                avctx->internal->skip_samples = 0;
-            }
-        }
-
-        if (discard_padding > 0 && discard_padding <= frame->nb_samples && *got_frame_ptr &&
-            !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
-            if (discard_padding == frame->nb_samples) {
-                *got_frame_ptr = 0;
-            } else {
-                if(avctx->pkt_timebase.num && avctx->sample_rate) {
-                    int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
-                                                   (AVRational){1, avctx->sample_rate},
-                                                   avctx->pkt_timebase);
-                    av_frame_set_pkt_duration(frame, diff_ts);
-                } else {
-                    av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
-                }
-                av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
-                       (int)discard_padding, frame->nb_samples);
-                frame->nb_samples -= discard_padding;
-            }
-        }
-
-        if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL) && *got_frame_ptr) {
-            AVFrameSideData *fside = av_frame_new_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES, 10);
-            if (fside) {
-                AV_WL32(fside->data, avctx->internal->skip_samples);
-                AV_WL32(fside->data + 4, discard_padding);
-                AV_WL8(fside->data + 8, skip_reason);
-                AV_WL8(fside->data + 9, discard_reason);
-                avctx->internal->skip_samples = 0;
-            }
-        }
-fail:
-        avctx->internal->pkt = NULL;
-        if (did_split) {
-            av_packet_free_side_data(&tmp);
-            if(ret == tmp.size)
-                ret = avpkt->size;
-        }
-
-        if (ret >= 0 && *got_frame_ptr) {
-            if (!avctx->refcounted_frames) {
-                int err = unrefcount_frame(avci, frame);
-                if (err < 0)
-                    return err;
-            }
-        } else
-            av_frame_unref(frame);
-    }
-
-    av_assert0(ret <= avpkt->size);
-
-    if (!avci->showed_multi_packet_warning &&
-        ret >= 0 && ret != avpkt->size && !(avctx->codec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
-            av_log(avctx, AV_LOG_WARNING, "Multiple frames in a packet.\n");
-        avci->showed_multi_packet_warning = 1;
-    }
-
-    return ret;
-}
-
-#define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
-static int recode_subtitle(AVCodecContext *avctx,
-                           AVPacket *outpkt, const AVPacket *inpkt)
-{
-#if CONFIG_ICONV
-    iconv_t cd = (iconv_t)-1;
-    int ret = 0;
-    char *inb, *outb;
-    size_t inl, outl;
-    AVPacket tmp;
-#endif
-
-    if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0)
-        return 0;
-
-#if CONFIG_ICONV
-    cd = iconv_open("UTF-8", avctx->sub_charenc);
-    av_assert0(cd != (iconv_t)-1);
-
-    inb = inpkt->data;
-    inl = inpkt->size;
-
-    if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
-        av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
-        ret = AVERROR(ENOMEM);
-        goto end;
-    }
-
-    ret = av_new_packet(&tmp, inl * UTF8_MAX_BYTES);
-    if (ret < 0)
-        goto end;
-    outpkt->buf  = tmp.buf;
-    outpkt->data = tmp.data;
-    outpkt->size = tmp.size;
-    outb = outpkt->data;
-    outl = outpkt->size;
-
-    if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
-        iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
-        outl >= outpkt->size || inl != 0) {
-        ret = FFMIN(AVERROR(errno), -1);
-        av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
-               "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
-        av_packet_unref(&tmp);
-        goto end;
-    }
-    outpkt->size -= outl;
-    memset(outpkt->data + outpkt->size, 0, outl);
-
-end:
-    if (cd != (iconv_t)-1)
-        iconv_close(cd);
-    return ret;
-#else
-    av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
-    return AVERROR(EINVAL);
-#endif
-}
-
-static int utf8_check(const uint8_t *str)
-{
-    const uint8_t *byte;
-    uint32_t codepoint, min;
-
-    while (*str) {
-        byte = str;
-        GET_UTF8(codepoint, *(byte++), return 0;);
-        min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
-              1 << (5 * (byte - str) - 4);
-        if (codepoint < min || codepoint >= 0x110000 ||
-            codepoint == 0xFFFE /* BOM */ ||
-            codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
-            return 0;
-        str = byte;
-    }
-    return 1;
-}
-
-#if FF_API_ASS_TIMING
-static void insert_ts(AVBPrint *buf, int ts)
-{
-    if (ts == -1) {
-        av_bprintf(buf, "9:59:59.99,");
-    } else {
-        int h, m, s;
-
-        h = ts/360000;  ts -= 360000*h;
-        m = ts/  6000;  ts -=   6000*m;
-        s = ts/   100;  ts -=    100*s;
-        av_bprintf(buf, "%d:%02d:%02d.%02d,", h, m, s, ts);
-    }
-}
-
-static int convert_sub_to_old_ass_form(AVSubtitle *sub, const AVPacket *pkt, AVRational tb)
-{
-    int i;
-    AVBPrint buf;
-
-    av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
-
-    for (i = 0; i < sub->num_rects; i++) {
-        char *final_dialog;
-        const char *dialog;
-        AVSubtitleRect *rect = sub->rects[i];
-        int ts_start, ts_duration = -1;
-        long int layer;
-
-        if (rect->type != SUBTITLE_ASS || !strncmp(rect->ass, "Dialogue: ", 10))
-            continue;
-
-        av_bprint_clear(&buf);
-
-        /* skip ReadOrder */
-        dialog = strchr(rect->ass, ',');
-        if (!dialog)
-            continue;
-        dialog++;
-
-        /* extract Layer or Marked */
-        layer = strtol(dialog, (char**)&dialog, 10);
-        if (*dialog != ',')
-            continue;
-        dialog++;
-
-        /* rescale timing to ASS time base (ms) */
-        ts_start = av_rescale_q(pkt->pts, tb, av_make_q(1, 100));
-        if (pkt->duration != -1)
-            ts_duration = av_rescale_q(pkt->duration, tb, av_make_q(1, 100));
-        sub->end_display_time = FFMAX(sub->end_display_time, 10 * ts_duration);
-
-        /* construct ASS (standalone file form with timestamps) string */
-        av_bprintf(&buf, "Dialogue: %ld,", layer);
-        insert_ts(&buf, ts_start);
-        insert_ts(&buf, ts_duration == -1 ? -1 : ts_start + ts_duration);
-        av_bprintf(&buf, "%s\r\n", dialog);
-
-        final_dialog = av_strdup(buf.str);
-        if (!av_bprint_is_complete(&buf) || !final_dialog) {
-            av_freep(&final_dialog);
-            av_bprint_finalize(&buf, NULL);
-            return AVERROR(ENOMEM);
+            }
+            avctx->sw_pix_fmt = frames_ctx->sw_format;
         }
-        av_freep(&rect->ass);
-        rect->ass = final_dialog;
     }
 
-    av_bprint_finalize(&buf, NULL);
-    return 0;
-}
-#endif
+    avctx->pts_correction_num_faulty_pts =
+    avctx->pts_correction_num_faulty_dts = 0;
+    avctx->pts_correction_last_pts =
+    avctx->pts_correction_last_dts = INT64_MIN;
 
-int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
-                             int *got_sub_ptr,
-                             AVPacket *avpkt)
-{
-    int i, ret = 0;
+    if (   !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
+        && avctx->codec_descriptor->type == AVMEDIA_TYPE_VIDEO)
+        av_log(avctx, AV_LOG_WARNING,
+               "gray decoding requested but not enabled at configuration time\n");
 
-    if (!avpkt->data && avpkt->size) {
-        av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
-        return AVERROR(EINVAL);
-    }
-    if (!avctx->codec)
-        return AVERROR(EINVAL);
-    if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
-        av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
-        return AVERROR(EINVAL);
+    if (   avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
+        || avctx->internal->frame_thread_encoder)) {
+        ret = avctx->codec->init(avctx);
+        if (ret < 0) {
+            goto free_and_end;
+        }
     }
 
-    *got_sub_ptr = 0;
-    get_subtitle_defaults(sub);
-
-    if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
-        AVPacket pkt_recoded;
-        AVPacket tmp = *avpkt;
-        int did_split = av_packet_split_side_data(&tmp);
-        //apply_param_change(avctx, &tmp);
-
-        if (did_split) {
-            /* FFMIN() prevents overflow in case the packet wasn't allocated with
-             * proper padding.
-             * If the side data is smaller than the buffer padding size, the
-             * remaining bytes should have already been filled with zeros by the
-             * original packet allocation anyway. */
-            memset(tmp.data + tmp.size, 0,
-                   FFMIN(avpkt->size - tmp.size, AV_INPUT_BUFFER_PADDING_SIZE));
-        }
+    ret=0;
 
-        pkt_recoded = tmp;
-        ret = recode_subtitle(avctx, &pkt_recoded, &tmp);
-        if (ret < 0) {
-            *got_sub_ptr = 0;
-        } else {
-            avctx->internal->pkt = &pkt_recoded;
-
-            if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
-                sub->pts = av_rescale_q(avpkt->pts,
-                                        avctx->pkt_timebase, AV_TIME_BASE_Q);
-            ret = avctx->codec->decode(avctx, sub, got_sub_ptr, &pkt_recoded);
-            av_assert1((ret >= 0) >= !!*got_sub_ptr &&
-                       !!*got_sub_ptr >= !!sub->num_rects);
-
-#if FF_API_ASS_TIMING
-            if (avctx->sub_text_format == FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS
-                && *got_sub_ptr && sub->num_rects) {
-                const AVRational tb = avctx->pkt_timebase.num ? avctx->pkt_timebase
-                                                              : avctx->time_base;
-                int err = convert_sub_to_old_ass_form(sub, avpkt, tb);
-                if (err < 0)
-                    ret = err;
-            }
+#if FF_API_AUDIOENC_DELAY
+    if (av_codec_is_encoder(avctx->codec))
+        avctx->delay = avctx->initial_padding;
 #endif
 
-            if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
-                avctx->pkt_timebase.num) {
-                AVRational ms = { 1, 1000 };
-                sub->end_display_time = av_rescale_q(avpkt->duration,
-                                                     avctx->pkt_timebase, ms);
+    if (av_codec_is_decoder(avctx->codec)) {
+        if (!avctx->bit_rate)
+            avctx->bit_rate = get_bit_rate(avctx);
+        /* validate channel layout from the decoder */
+        if (avctx->channel_layout) {
+            int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
+            if (!avctx->channels)
+                avctx->channels = channels;
+            else if (channels != avctx->channels) {
+                char buf[512];
+                av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
+                av_log(avctx, AV_LOG_WARNING,
+                       "Channel layout '%s' with %d channels does not match specified number of channels %d: "
+                       "ignoring specified channel layout\n",
+                       buf, channels, avctx->channels);
+                avctx->channel_layout = 0;
             }
+        }
+        if (avctx->channels && avctx->channels < 0 ||
+            avctx->channels > FF_SANE_NB_CHANNELS) {
+            ret = AVERROR(EINVAL);
+            goto free_and_end;
+        }
+        if (avctx->sub_charenc) {
+            if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
+                av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
+                       "supported with subtitles codecs\n");
+                ret = AVERROR(EINVAL);
+                goto free_and_end;
+            } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
+                av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
+                       "subtitles character encoding will be ignored\n",
+                       avctx->codec_descriptor->name);
+                avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
+            } else {
+                /* input character encoding is set for a text based subtitle
+                 * codec at this point */
+                if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
+                    avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
 
-            for (i = 0; i < sub->num_rects; i++) {
-                if (sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
-                    av_log(avctx, AV_LOG_ERROR,
-                           "Invalid UTF-8 in decoded subtitles text; "
-                           "maybe missing -sub_charenc option\n");
-                    avsubtitle_free(sub);
-                    return AVERROR_INVALIDDATA;
+                if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
+#if CONFIG_ICONV
+                    iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
+                    if (cd == (iconv_t)-1) {
+                        ret = AVERROR(errno);
+                        av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
+                               "with input character encoding \"%s\"\n", avctx->sub_charenc);
+                        goto free_and_end;
+                    }
+                    iconv_close(cd);
+#else
+                    av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
+                           "conversion needs a libavcodec built with iconv support "
+                           "for this codec\n");
+                    ret = AVERROR(ENOSYS);
+                    goto free_and_end;
+#endif
                 }
             }
-
-            if (tmp.data != pkt_recoded.data) { // did we recode?
-                /* prevent from destroying side data from original packet */
-                pkt_recoded.side_data = NULL;
-                pkt_recoded.side_data_elems = 0;
-
-                av_packet_unref(&pkt_recoded);
-            }
-            if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB)
-                sub->format = 0;
-            else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
-                sub->format = 1;
-            avctx->internal->pkt = NULL;
         }
 
-        if (did_split) {
-            av_packet_free_side_data(&tmp);
-            if(ret == tmp.size)
-                ret = avpkt->size;
-        }
+#if FF_API_AVCTX_TIMEBASE
+        if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
+            avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
+#endif
+    }
+    if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
+        av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
+    }
 
-        if (*got_sub_ptr)
-            avctx->frame_number++;
+end:
+    ff_unlock_avcodec(codec);
+    if (options) {
+        av_dict_free(options);
+        *options = tmp;
     }
 
     return ret;
+free_and_end:
+    if (avctx->codec &&
+        (avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP))
+        avctx->codec->close(avctx);
+
+    if (codec->priv_class && codec->priv_data_size)
+        av_opt_free(avctx->priv_data);
+    av_opt_free(avctx);
+
+#if FF_API_CODED_FRAME
+FF_DISABLE_DEPRECATION_WARNINGS
+    av_frame_free(&avctx->coded_frame);
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
+    av_dict_free(&tmp);
+    av_freep(&avctx->priv_data);
+    if (avctx->internal) {
+        av_frame_free(&avctx->internal->to_free);
+        av_frame_free(&avctx->internal->compat_decode_frame);
+        av_frame_free(&avctx->internal->buffer_frame);
+        av_packet_free(&avctx->internal->buffer_pkt);
+        av_packet_free(&avctx->internal->last_pkt_props);
+
+        av_packet_free(&avctx->internal->ds.in_pkt);
+
+        av_freep(&avctx->internal->pool);
+    }
+    av_freep(&avctx->internal);
+    avctx->codec = NULL;
+    goto end;
 }
 
 void avsubtitle_free(AVSubtitle *sub)
@@ -2764,262 +1160,6 @@ void avsubtitle_free(AVSubtitle *sub)
     memset(sub, 0, sizeof(AVSubtitle));
 }
 
-static int do_decode(AVCodecContext *avctx, AVPacket *pkt)
-{
-    int got_frame;
-    int ret;
-
-    av_assert0(!avctx->internal->buffer_frame->buf[0]);
-
-    if (!pkt)
-        pkt = avctx->internal->buffer_pkt;
-
-    // This is the lesser evil. The field is for compatibility with legacy users
-    // of the legacy API, and users using the new API should not be forced to
-    // even know about this field.
-    avctx->refcounted_frames = 1;
-
-    // Some codecs (at least wma lossless) will crash when feeding drain packets
-    // after EOF was signaled.
-    if (avctx->internal->draining_done)
-        return AVERROR_EOF;
-
-    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
-        ret = avcodec_decode_video2(avctx, avctx->internal->buffer_frame,
-                                    &got_frame, pkt);
-        if (ret >= 0)
-            ret = pkt->size;
-    } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
-        ret = avcodec_decode_audio4(avctx, avctx->internal->buffer_frame,
-                                    &got_frame, pkt);
-    } else {
-        ret = AVERROR(EINVAL);
-    }
-
-    if (ret == AVERROR(EAGAIN))
-        ret = pkt->size;
-
-    if (ret < 0)
-        return ret;
-
-    if (avctx->internal->draining && !got_frame)
-        avctx->internal->draining_done = 1;
-
-    if (ret >= pkt->size) {
-        av_packet_unref(avctx->internal->buffer_pkt);
-    } else {
-        int consumed = ret;
-
-        if (pkt != avctx->internal->buffer_pkt) {
-            av_packet_unref(avctx->internal->buffer_pkt);
-            if ((ret = av_packet_ref(avctx->internal->buffer_pkt, pkt)) < 0)
-                return ret;
-        }
-
-        avctx->internal->buffer_pkt->data += consumed;
-        avctx->internal->buffer_pkt->size -= consumed;
-        avctx->internal->buffer_pkt->pts   = AV_NOPTS_VALUE;
-        avctx->internal->buffer_pkt->dts   = AV_NOPTS_VALUE;
-    }
-
-    if (got_frame)
-        av_assert0(avctx->internal->buffer_frame->buf[0]);
-
-    return 0;
-}
-
-int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
-{
-    int ret;
-
-    if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
-        return AVERROR(EINVAL);
-
-    if (avctx->internal->draining)
-        return AVERROR_EOF;
-
-    if (avpkt && !avpkt->size && avpkt->data)
-        return AVERROR(EINVAL);
-
-    if (!avpkt || !avpkt->size) {
-        avctx->internal->draining = 1;
-        avpkt = NULL;
-
-        if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
-            return 0;
-    }
-
-    if (avctx->codec->send_packet) {
-        if (avpkt) {
-            AVPacket tmp = *avpkt;
-            int did_split = av_packet_split_side_data(&tmp);
-            ret = apply_param_change(avctx, &tmp);
-            if (ret >= 0)
-                ret = avctx->codec->send_packet(avctx, &tmp);
-            if (did_split)
-                av_packet_free_side_data(&tmp);
-            return ret;
-        } else {
-            return avctx->codec->send_packet(avctx, NULL);
-        }
-    }
-
-    // Emulation via old API. Assume avpkt is likely not refcounted, while
-    // decoder output is always refcounted, and avoid copying.
-
-    if (avctx->internal->buffer_pkt->size || avctx->internal->buffer_frame->buf[0])
-        return AVERROR(EAGAIN);
-
-    // The goal is decoding the first frame of the packet without using memcpy,
-    // because the common case is having only 1 frame per packet (especially
-    // with video, but audio too). In other cases, it can't be avoided, unless
-    // the user is feeding refcounted packets.
-    return do_decode(avctx, (AVPacket *)avpkt);
-}
-
-int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
-{
-    int ret;
-
-    av_frame_unref(frame);
-
-    if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
-        return AVERROR(EINVAL);
-
-    if (avctx->codec->receive_frame) {
-        if (avctx->internal->draining && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
-            return AVERROR_EOF;
-        ret = avctx->codec->receive_frame(avctx, frame);
-        if (ret >= 0) {
-            if (av_frame_get_best_effort_timestamp(frame) == AV_NOPTS_VALUE) {
-                av_frame_set_best_effort_timestamp(frame,
-                    guess_correct_pts(avctx, frame->pts, frame->pkt_dts));
-            }
-        }
-        return ret;
-    }
-
-    // Emulation via old API.
-
-    if (!avctx->internal->buffer_frame->buf[0]) {
-        if (!avctx->internal->buffer_pkt->size && !avctx->internal->draining)
-            return AVERROR(EAGAIN);
-
-        while (1) {
-            if ((ret = do_decode(avctx, avctx->internal->buffer_pkt)) < 0) {
-                av_packet_unref(avctx->internal->buffer_pkt);
-                return ret;
-            }
-            // Some audio decoders may consume partial data without returning
-            // a frame (fate-wmapro-2ch). There is no way to make the caller
-            // call avcodec_receive_frame() again without returning a frame,
-            // so try to decode more in these cases.
-            if (avctx->internal->buffer_frame->buf[0] ||
-                !avctx->internal->buffer_pkt->size)
-                break;
-        }
-    }
-
-    if (!avctx->internal->buffer_frame->buf[0])
-        return avctx->internal->draining ? AVERROR_EOF : AVERROR(EAGAIN);
-
-    av_frame_move_ref(frame, avctx->internal->buffer_frame);
-    return 0;
-}
-
-static int do_encode(AVCodecContext *avctx, const AVFrame *frame, int *got_packet)
-{
-    int ret;
-    *got_packet = 0;
-
-    av_packet_unref(avctx->internal->buffer_pkt);
-    avctx->internal->buffer_pkt_valid = 0;
-
-    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
-        ret = avcodec_encode_video2(avctx, avctx->internal->buffer_pkt,
-                                    frame, got_packet);
-    } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
-        ret = avcodec_encode_audio2(avctx, avctx->internal->buffer_pkt,
-                                    frame, got_packet);
-    } else {
-        ret = AVERROR(EINVAL);
-    }
-
-    if (ret >= 0 && *got_packet) {
-        // Encoders must always return ref-counted buffers.
-        // Side-data only packets have no data and can be not ref-counted.
-        av_assert0(!avctx->internal->buffer_pkt->data || avctx->internal->buffer_pkt->buf);
-        avctx->internal->buffer_pkt_valid = 1;
-        ret = 0;
-    } else {
-        av_packet_unref(avctx->internal->buffer_pkt);
-    }
-
-    return ret;
-}
-
-int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
-{
-    if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
-        return AVERROR(EINVAL);
-
-    if (avctx->internal->draining)
-        return AVERROR_EOF;
-
-    if (!frame) {
-        avctx->internal->draining = 1;
-
-        if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
-            return 0;
-    }
-
-    if (avctx->codec->send_frame)
-        return avctx->codec->send_frame(avctx, frame);
-
-    // Emulation via old API. Do it here instead of avcodec_receive_packet, because:
-    // 1. if the AVFrame is not refcounted, the copying will be much more
-    //    expensive than copying the packet data
-    // 2. assume few users use non-refcounted AVPackets, so usually no copy is
-    //    needed
-
-    if (avctx->internal->buffer_pkt_valid)
-        return AVERROR(EAGAIN);
-
-    return do_encode(avctx, frame, &(int){0});
-}
-
-int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
-{
-    av_packet_unref(avpkt);
-
-    if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
-        return AVERROR(EINVAL);
-
-    if (avctx->codec->receive_packet) {
-        if (avctx->internal->draining && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
-            return AVERROR_EOF;
-        return avctx->codec->receive_packet(avctx, avpkt);
-    }
-
-    // Emulation via old API.
-
-    if (!avctx->internal->buffer_pkt_valid) {
-        int got_packet;
-        int ret;
-        if (!avctx->internal->draining)
-            return AVERROR(EAGAIN);
-        ret = do_encode(avctx, NULL, &got_packet);
-        if (ret < 0)
-            return ret;
-        if (ret >= 0 && !got_packet)
-            return AVERROR_EOF;
-    }
-
-    av_packet_move_ref(avpkt, avctx->internal->buffer_pkt);
-    avctx->internal->buffer_pkt_valid = 0;
-    return 0;
-}
-
 av_cold int avcodec_close(AVCodecContext *avctx)
 {
     int i;
@@ -3040,8 +1180,13 @@ av_cold int avcodec_close(AVCodecContext *avctx)
         avctx->internal->byte_buffer_size = 0;
         av_freep(&avctx->internal->byte_buffer);
         av_frame_free(&avctx->internal->to_free);
+        av_frame_free(&avctx->internal->compat_decode_frame);
         av_frame_free(&avctx->internal->buffer_frame);
         av_packet_free(&avctx->internal->buffer_pkt);
+        av_packet_free(&avctx->internal->last_pkt_props);
+
+        av_packet_free(&avctx->internal->ds.in_pkt);
+
         for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
             av_buffer_pool_uninit(&pool->pools[i]);
         av_freep(&avctx->internal->pool);
@@ -3050,6 +1195,8 @@ av_cold int avcodec_close(AVCodecContext *avctx)
             avctx->hwaccel->uninit(avctx);
         av_freep(&avctx->internal->hwaccel_priv_data);
 
+        ff_decode_bsfs_uninit(avctx);
+
         av_freep(&avctx->internal);
     }
 
@@ -3059,6 +1206,7 @@ av_cold int avcodec_close(AVCodecContext *avctx)
     avctx->nb_coded_side_data = 0;
 
     av_buffer_unref(&avctx->hw_frames_ctx);
+    av_buffer_unref(&avctx->hw_device_ctx);
 
     if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
         av_opt_free(avctx->priv_data);
@@ -3215,12 +1363,9 @@ void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
                  ", %d reference frame%s",
                  enc->refs, enc->refs > 1 ? "s" : "");
 
-    if (enc->codec_tag) {
-        char tag_buf[32];
-        av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
-        snprintf(buf + strlen(buf), buf_size - strlen(buf),
-                 " (%s / 0x%04X)", tag_buf, enc->codec_tag);
-    }
+    if (enc->codec_tag)
+        snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
+                 av_fourcc2str(enc->codec_tag), enc->codec_tag);
 
     switch (enc->codec_type) {
     case AVMEDIA_TYPE_VIDEO:
@@ -3377,7 +1522,7 @@ void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
                  ", %"PRId64" kb/s", bitrate / 1000);
     } else if (enc->rc_max_rate > 0) {
         snprintf(buf + strlen(buf), buf_size - strlen(buf),
-                 ", max. %"PRId64" kb/s", (int64_t)enc->rc_max_rate / 1000);
+                 ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
     }
 }
 
@@ -3432,26 +1577,6 @@ const char *avcodec_license(void)
     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 }
 
-void avcodec_flush_buffers(AVCodecContext *avctx)
-{
-    avctx->internal->draining      = 0;
-    avctx->internal->draining_done = 0;
-    av_frame_unref(avctx->internal->buffer_frame);
-    av_packet_unref(avctx->internal->buffer_pkt);
-    avctx->internal->buffer_pkt_valid = 0;
-
-    if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
-        ff_thread_flush(avctx);
-    else if (avctx->codec->flush)
-        avctx->codec->flush(avctx);
-
-    avctx->pts_correction_last_pts =
-    avctx->pts_correction_last_dts = INT64_MIN;
-
-    if (!avctx->refcounted_frames)
-        av_frame_unref(avctx->internal->to_free);
-}
-
 int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
 {
     switch (codec_id) {
@@ -3499,6 +1624,8 @@ int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
     case AV_CODEC_ID_PCM_U32LE:
     case AV_CODEC_ID_PCM_F32BE:
     case AV_CODEC_ID_PCM_F32LE:
+    case AV_CODEC_ID_PCM_F24LE:
+    case AV_CODEC_ID_PCM_F16LE:
         return 32;
     case AV_CODEC_ID_PCM_F64BE:
     case AV_CODEC_ID_PCM_F64LE:
@@ -3595,6 +1722,9 @@ static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
             if (id == AV_CODEC_ID_BINKAUDIO_DCT)
                 return (480 << (sr / 22050)) / ch;
         }
+
+        if (id == AV_CODEC_ID_MP3)
+            return sr <= 24000 ? 576 : 1152;
     }
 
     if (ba > 0) {
@@ -3627,7 +1757,7 @@ static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
 
         if (bps > 0) {
             /* calc from frame_bytes and bits_per_coded_sample */
-            if (id == AV_CODEC_ID_ADPCM_G726)
+            if (id == AV_CODEC_ID_ADPCM_G726 || id == AV_CODEC_ID_ADPCM_G726LE)
                 return frame_bytes * 8 / bps;
         }
 
@@ -3931,7 +2061,8 @@ int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
 {
     int ret;
 
-    dst->owner = src->owner;
+    dst->owner[0] = src->owner[0];
+    dst->owner[1] = src->owner[1];
 
     ret = av_frame_ref(dst->f, src->f);
     if (ret < 0)
@@ -3941,7 +2072,7 @@ int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
 
     if (src->progress &&
         !(dst->progress = av_buffer_ref(src->progress))) {
-        ff_thread_release_buffer(dst->owner, dst);
+        ff_thread_release_buffer(dst->owner[0], dst);
         return AVERROR(ENOMEM);
     }
 
@@ -3957,7 +2088,7 @@ enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixe
 
 int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
 {
-    f->owner = avctx;
+    f->owner[0] = f->owner[1] = avctx;
     return ff_get_buffer(avctx, f->f, flags);
 }
 
@@ -4319,3 +2450,24 @@ int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len,
 
     return 0;
 }
+
+int64_t ff_guess_coded_bitrate(AVCodecContext *avctx)
+{
+    AVRational framerate = avctx->framerate;
+    int bits_per_coded_sample = avctx->bits_per_coded_sample;
+    int64_t bitrate;
+
+    if (!(framerate.num && framerate.den))
+        framerate = av_inv_q(avctx->time_base);
+    if (!(framerate.num && framerate.den))
+        return 0;
+
+    if (!bits_per_coded_sample) {
+        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
+        bits_per_coded_sample = av_get_bits_per_pixel(desc);
+    }
+    bitrate = (int64_t)bits_per_coded_sample * avctx->width * avctx->height *
+              framerate.num / framerate.den;
+
+    return bitrate;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/utvideo.h b/mythtv/external/FFmpeg/libavcodec/utvideo.h
index 49ddf49882b..a8117851a7c 100644
--- a/mythtv/external/FFmpeg/libavcodec/utvideo.h
+++ b/mythtv/external/FFmpeg/libavcodec/utvideo.h
@@ -30,7 +30,9 @@
 #include "libavutil/common.h"
 #include "avcodec.h"
 #include "bswapdsp.h"
-#include "huffyuvencdsp.h"
+#include "utvideodsp.h"
+#include "lossless_videodsp.h"
+#include "lossless_videoencdsp.h"
 
 enum {
     PRED_NONE = 0,
@@ -62,14 +64,13 @@ enum {
 /* Mapping of libavcodec prediction modes to Ut Video's */
 extern const int ff_ut_pred_order[5];
 
-/* Order of RGB(A) planes in Ut Video */
-extern const int ff_ut_rgb_order[4];
-
 typedef struct UtvideoContext {
     const AVClass *class;
     AVCodecContext *avctx;
+    UTVideoDSPContext utdsp;
     BswapDSPContext bdsp;
-    HuffYUVEncDSPContext hdsp;
+    LLVidDSPContext llviddsp;
+    LLVidEncDSPContext llvidencdsp;
 
     uint32_t frame_info_size, flags, frame_info;
     int      planes;
@@ -79,7 +80,7 @@ typedef struct UtvideoContext {
     int      frame_pred;
     int      pro;
 
-    int      slice_stride;
+    ptrdiff_t slice_stride;
     uint8_t *slice_bits, *slice_buffer[4];
     int      slice_bits_size;
 } UtvideoContext;
diff --git a/mythtv/external/FFmpeg/libavcodec/utvideodec.c b/mythtv/external/FFmpeg/libavcodec/utvideodec.c
index 650c0ec67db..40c12772b34 100644
--- a/mythtv/external/FFmpeg/libavcodec/utvideodec.c
+++ b/mythtv/external/FFmpeg/libavcodec/utvideodec.c
@@ -27,11 +27,14 @@
 #include <inttypes.h>
 #include <stdlib.h>
 
+#define UNCHECKED_BITSTREAM_READER 1
+
 #include "libavutil/intreadwrite.h"
 #include "avcodec.h"
 #include "bswapdsp.h"
 #include "bytestream.h"
 #include "get_bits.h"
+#include "internal.h"
 #include "thread.h"
 #include "utvideo.h"
 
@@ -72,8 +75,8 @@ static int build_huff10(const uint8_t *src, VLC *vlc, int *fsym)
         syms[i]  = he[i].sym;
         code += 0x80000000u >> (he[i].len - 1);
     }
-
-    return ff_init_vlc_sparse(vlc, FFMIN(he[last].len, 11), last + 1,
+#define VLC_BITS 11
+    return ff_init_vlc_sparse(vlc, VLC_BITS, last + 1,
                               bits,  sizeof(*bits),  sizeof(*bits),
                               codes, sizeof(*codes), sizeof(*codes),
                               syms,  sizeof(*syms),  sizeof(*syms), 0);
@@ -116,14 +119,14 @@ static int build_huff(const uint8_t *src, VLC *vlc, int *fsym)
         code += 0x80000000u >> (he[i].len - 1);
     }
 
-    return ff_init_vlc_sparse(vlc, FFMIN(he[last].len, 11), last + 1,
+    return ff_init_vlc_sparse(vlc, VLC_BITS, last + 1,
                               bits,  sizeof(*bits),  sizeof(*bits),
                               codes, sizeof(*codes), sizeof(*codes),
                               syms,  sizeof(*syms),  sizeof(*syms), 0);
 }
 
 static int decode_plane10(UtvideoContext *c, int plane_no,
-                          uint16_t *dst, int step, int stride,
+                          uint16_t *dst, int step, ptrdiff_t stride,
                           int width, int height,
                           const uint8_t *src, const uint8_t *huff,
                           int use_pred)
@@ -184,23 +187,17 @@ static int decode_plane10(UtvideoContext *c, int plane_no,
             goto fail;
         }
 
-        memcpy(c->slice_bits, src + slice_data_start + c->slices * 4,
-               slice_size);
         memset(c->slice_bits + slice_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
         c->bdsp.bswap_buf((uint32_t *) c->slice_bits,
-                          (uint32_t *) c->slice_bits,
+                          (uint32_t *)(src + slice_data_start + c->slices * 4),
                           (slice_data_end - slice_data_start + 3) >> 2);
         init_get_bits(&gb, c->slice_bits, slice_size * 8);
 
         prev = 0x200;
         for (j = sstart; j < send; j++) {
-            for (i = 0; i < width * step; i += step) {
-                if (get_bits_left(&gb) <= 0) {
-                    av_log(c->avctx, AV_LOG_ERROR,
-                           "Slice decoding ran out of bits\n");
-                    goto fail;
-                }
-                pix = get_vlc2(&gb, vlc.table, vlc.bits, 3);
+            int ws = width * step;
+            for (i = 0; i < ws; i += step) {
+                pix = get_vlc2(&gb, vlc.table, VLC_BITS, 3);
                 if (pix < 0) {
                     av_log(c->avctx, AV_LOG_ERROR, "Decoding error\n");
                     goto fail;
@@ -213,6 +210,11 @@ static int decode_plane10(UtvideoContext *c, int plane_no,
                 dest[i] = pix;
             }
             dest += stride;
+            if (get_bits_left(&gb) < 0) {
+                av_log(c->avctx, AV_LOG_ERROR,
+                        "Slice decoding ran out of bits\n");
+                goto fail;
+            }
         }
         if (get_bits_left(&gb) > 32)
             av_log(c->avctx, AV_LOG_WARNING,
@@ -228,7 +230,7 @@ static int decode_plane10(UtvideoContext *c, int plane_no,
 }
 
 static int decode_plane(UtvideoContext *c, int plane_no,
-                        uint8_t *dst, int step, int stride,
+                        uint8_t *dst, int step, ptrdiff_t stride,
                         int width, int height,
                         const uint8_t *src, int use_pred)
 {
@@ -237,7 +239,7 @@ static int decode_plane(UtvideoContext *c, int plane_no,
     VLC vlc;
     GetBitContext gb;
     int prev, fsym;
-    const int cmask = ~(!plane_no && c->avctx->pix_fmt == AV_PIX_FMT_YUV420P);
+    const int cmask = c->interlaced ? ~(1 + 2 * (!plane_no && c->avctx->pix_fmt == AV_PIX_FMT_YUV420P)) : ~(!plane_no && c->avctx->pix_fmt == AV_PIX_FMT_YUV420P);
 
     if (build_huff(src, &vlc, &fsym)) {
         av_log(c->avctx, AV_LOG_ERROR, "Cannot build Huffman codes\n");
@@ -290,23 +292,17 @@ static int decode_plane(UtvideoContext *c, int plane_no,
             goto fail;
         }
 
-        memcpy(c->slice_bits, src + slice_data_start + c->slices * 4,
-               slice_size);
         memset(c->slice_bits + slice_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
         c->bdsp.bswap_buf((uint32_t *) c->slice_bits,
-                          (uint32_t *) c->slice_bits,
+                          (uint32_t *)(src + slice_data_start + c->slices * 4),
                           (slice_data_end - slice_data_start + 3) >> 2);
         init_get_bits(&gb, c->slice_bits, slice_size * 8);
 
         prev = 0x80;
         for (j = sstart; j < send; j++) {
-            for (i = 0; i < width * step; i += step) {
-                if (get_bits_left(&gb) <= 0) {
-                    av_log(c->avctx, AV_LOG_ERROR,
-                           "Slice decoding ran out of bits\n");
-                    goto fail;
-                }
-                pix = get_vlc2(&gb, vlc.table, vlc.bits, 3);
+            int ws = width * step;
+            for (i = 0; i < ws; i += step) {
+                pix = get_vlc2(&gb, vlc.table, VLC_BITS, 3);
                 if (pix < 0) {
                     av_log(c->avctx, AV_LOG_ERROR, "Decoding error\n");
                     goto fail;
@@ -317,6 +313,11 @@ static int decode_plane(UtvideoContext *c, int plane_no,
                 }
                 dest[i] = pix;
             }
+            if (get_bits_left(&gb) < 0) {
+                av_log(c->avctx, AV_LOG_ERROR,
+                        "Slice decoding ran out of bits\n");
+                goto fail;
+            }
             dest += stride;
         }
         if (get_bits_left(&gb) > 32)
@@ -332,48 +333,12 @@ static int decode_plane(UtvideoContext *c, int plane_no,
     return AVERROR_INVALIDDATA;
 }
 
-static void restore_rgb_planes(uint8_t *src, int step, int stride, int width,
-                               int height)
-{
-    int i, j;
-    uint8_t r, g, b;
-
-    for (j = 0; j < height; j++) {
-        for (i = 0; i < width * step; i += step) {
-            r = src[i];
-            g = src[i + 1];
-            b = src[i + 2];
-            src[i]     = r + g - 0x80;
-            src[i + 2] = b + g - 0x80;
-        }
-        src += stride;
-    }
-}
-
-static void restore_rgb_planes10(AVFrame *frame, int width, int height)
-{
-    uint16_t *src_r = (uint16_t *)frame->data[2];
-    uint16_t *src_g = (uint16_t *)frame->data[0];
-    uint16_t *src_b = (uint16_t *)frame->data[1];
-    int r, g, b;
-    int i, j;
-
-    for (j = 0; j < height; j++) {
-        for (i = 0; i < width; i++) {
-            r = src_r[i];
-            g = src_g[i];
-            b = src_b[i];
-            src_r[i] = (r + g - 0x200) & 0x3FF;
-            src_b[i] = (b + g - 0x200) & 0x3FF;
-        }
-        src_r += frame->linesize[2] / 2;
-        src_g += frame->linesize[0] / 2;
-        src_b += frame->linesize[1] / 2;
-    }
-}
+#undef A
+#undef B
+#undef C
 
-static void restore_median(uint8_t *src, int step, int stride,
-                           int width, int height, int slices, int rmode)
+static void restore_median_planar(UtvideoContext *c, uint8_t *src, ptrdiff_t stride,
+                                  int width, int height, int slices, int rmode)
 {
     int i, j, slice;
     int A, B, C;
@@ -392,11 +357,7 @@ static void restore_median(uint8_t *src, int step, int stride,
 
         // first line - left neighbour prediction
         bsrc[0] += 0x80;
-        A = bsrc[0];
-        for (i = step; i < width * step; i += step) {
-            bsrc[i] += A;
-            A        = bsrc[i];
-        }
+        c->llviddsp.add_left_pred(bsrc, bsrc, width, 0);
         bsrc += stride;
         if (slice_height <= 1)
             continue;
@@ -404,7 +365,7 @@ static void restore_median(uint8_t *src, int step, int stride,
         C        = bsrc[-stride];
         bsrc[0] += C;
         A        = bsrc[0];
-        for (i = step; i < width * step; i += step) {
+        for (i = 1; i < width; i++) {
             B        = bsrc[i - stride];
             bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
             C        = B;
@@ -413,12 +374,8 @@ static void restore_median(uint8_t *src, int step, int stride,
         bsrc += stride;
         // the rest of lines use continuous median prediction
         for (j = 2; j < slice_height; j++) {
-            for (i = 0; i < width * step; i += step) {
-                B        = bsrc[i - stride];
-                bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
-                C        = B;
-                A        = bsrc[i];
-            }
+            c->llviddsp.add_median_pred(bsrc, bsrc - stride,
+                                            bsrc, width, &A, &B);
             bsrc += stride;
         }
     }
@@ -428,15 +385,15 @@ static void restore_median(uint8_t *src, int step, int stride,
  * so restoring function should take care of possible padding between
  * two parts of the same "line".
  */
-static void restore_median_il(uint8_t *src, int step, int stride,
-                              int width, int height, int slices, int rmode)
+static void restore_median_planar_il(UtvideoContext *c, uint8_t *src, ptrdiff_t stride,
+                                     int width, int height, int slices, int rmode)
 {
     int i, j, slice;
     int A, B, C;
     uint8_t *bsrc;
     int slice_start, slice_height;
     const int cmask   = ~(rmode ? 3 : 1);
-    const int stride2 = stride << 1;
+    const ptrdiff_t stride2 = stride << 1;
 
     for (slice = 0; slice < slices; slice++) {
         slice_start    = ((slice * height) / slices) & cmask;
@@ -450,15 +407,8 @@ static void restore_median_il(uint8_t *src, int step, int stride,
 
         // first line - left neighbour prediction
         bsrc[0] += 0x80;
-        A        = bsrc[0];
-        for (i = step; i < width * step; i += step) {
-            bsrc[i] += A;
-            A        = bsrc[i];
-        }
-        for (i = 0; i < width * step; i += step) {
-            bsrc[stride + i] += A;
-            A                 = bsrc[stride + i];
-        }
+        A = c->llviddsp.add_left_pred(bsrc, bsrc, width, 0);
+        c->llviddsp.add_left_pred(bsrc + stride, bsrc + stride, width, A);
         bsrc += stride2;
         if (slice_height <= 1)
             continue;
@@ -466,32 +416,109 @@ static void restore_median_il(uint8_t *src, int step, int stride,
         C        = bsrc[-stride2];
         bsrc[0] += C;
         A        = bsrc[0];
-        for (i = step; i < width * step; i += step) {
+        for (i = 1; i < width; i++) {
             B        = bsrc[i - stride2];
             bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
             C        = B;
             A        = bsrc[i];
         }
-        for (i = 0; i < width * step; i += step) {
-            B                 = bsrc[i - stride];
-            bsrc[stride + i] += mid_pred(A, B, (uint8_t)(A + B - C));
-            C                 = B;
-            A                 = bsrc[stride + i];
-        }
+        c->llviddsp.add_median_pred(bsrc + stride, bsrc - stride,
+                                        bsrc + stride, width, &A, &B);
         bsrc += stride2;
         // the rest of lines use continuous median prediction
         for (j = 2; j < slice_height; j++) {
-            for (i = 0; i < width * step; i += step) {
-                B        = bsrc[i - stride2];
-                bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
-                C        = B;
-                A        = bsrc[i];
+            c->llviddsp.add_median_pred(bsrc, bsrc - stride2,
+                                            bsrc, width, &A, &B);
+            c->llviddsp.add_median_pred(bsrc + stride, bsrc - stride,
+                                            bsrc + stride, width, &A, &B);
+            bsrc += stride2;
+        }
+    }
+}
+
+static void restore_gradient_planar(UtvideoContext *c, uint8_t *src, ptrdiff_t stride,
+                                    int width, int height, int slices, int rmode)
+{
+    int i, j, slice;
+    int A, B, C;
+    uint8_t *bsrc;
+    int slice_start, slice_height;
+    const int cmask = ~rmode;
+
+    for (slice = 0; slice < slices; slice++) {
+        slice_start  = ((slice * height) / slices) & cmask;
+        slice_height = ((((slice + 1) * height) / slices) & cmask) -
+                       slice_start;
+
+        if (!slice_height)
+            continue;
+        bsrc = src + slice_start * stride;
+
+        // first line - left neighbour prediction
+        bsrc[0] += 0x80;
+        c->llviddsp.add_left_pred(bsrc, bsrc, width, 0);
+        bsrc += stride;
+        if (slice_height <= 1)
+            continue;
+        for (j = 1; j < slice_height; j++) {
+            // second line - first element has top prediction, the rest uses gradient
+            bsrc[0] = (bsrc[0] + bsrc[-stride]) & 0xFF;
+            for (i = 1; i < width; i++) {
+                A = bsrc[i - stride];
+                B = bsrc[i - (stride + 1)];
+                C = bsrc[i - 1];
+                bsrc[i] = (A - B + C + bsrc[i]) & 0xFF;
             }
-            for (i = 0; i < width * step; i += step) {
-                B                 = bsrc[i - stride];
-                bsrc[i + stride] += mid_pred(A, B, (uint8_t)(A + B - C));
-                C                 = B;
-                A                 = bsrc[i + stride];
+            bsrc += stride;
+        }
+    }
+}
+
+static void restore_gradient_planar_il(UtvideoContext *c, uint8_t *src, ptrdiff_t stride,
+                                      int width, int height, int slices, int rmode)
+{
+    int i, j, slice;
+    int A, B, C;
+    uint8_t *bsrc;
+    int slice_start, slice_height;
+    const int cmask   = ~(rmode ? 3 : 1);
+    const ptrdiff_t stride2 = stride << 1;
+
+    for (slice = 0; slice < slices; slice++) {
+        slice_start    = ((slice * height) / slices) & cmask;
+        slice_height   = ((((slice + 1) * height) / slices) & cmask) -
+                         slice_start;
+        slice_height >>= 1;
+        if (!slice_height)
+            continue;
+
+        bsrc = src + slice_start * stride;
+
+        // first line - left neighbour prediction
+        bsrc[0] += 0x80;
+        A = c->llviddsp.add_left_pred(bsrc, bsrc, width, 0);
+        c->llviddsp.add_left_pred(bsrc + stride, bsrc + stride, width, A);
+        bsrc += stride2;
+        if (slice_height <= 1)
+            continue;
+        for (j = 1; j < slice_height; j++) {
+            // second line - first element has top prediction, the rest uses gradient
+            bsrc[0] = (bsrc[0] + bsrc[-stride2]) & 0xFF;
+            for (i = 1; i < width; i++) {
+                A = bsrc[i - stride2];
+                B = bsrc[i - (stride2 + 1)];
+                C = bsrc[i - 1];
+                bsrc[i] = (A - B + C + bsrc[i]) & 0xFF;
+            }
+            A = bsrc[-stride];
+            B = bsrc[-(1 + stride + stride - width)];
+            C = bsrc[width - 1];
+            bsrc[stride] = (A - B + C + bsrc[stride]) & 0xFF;
+            for (i = 1; i < width; i++) {
+                A = bsrc[i - stride];
+                B = bsrc[i - (1 + stride)];
+                C = bsrc[i - 1 + stride];
+                bsrc[i + stride] = (A - B + C + bsrc[i + stride]) & 0xFF;
             }
             bsrc += stride2;
         }
@@ -583,10 +610,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 
     c->frame_pred = (c->frame_info >> 8) & 3;
 
-    if (c->frame_pred == PRED_GRADIENT) {
-        avpriv_request_sample(avctx, "Frame with gradient prediction");
-        return AVERROR_PATCHWELCOME;
-    }
+    max_slice_size += 4*avctx->width;
 
     av_fast_malloc(&c->slice_bits, &c->slice_bits_size,
                    max_slice_size + AV_INPUT_BUFFER_PADDING_SIZE);
@@ -597,30 +621,42 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     }
 
     switch (c->avctx->pix_fmt) {
-    case AV_PIX_FMT_RGB24:
-    case AV_PIX_FMT_RGBA:
+    case AV_PIX_FMT_GBRP:
+    case AV_PIX_FMT_GBRAP:
         for (i = 0; i < c->planes; i++) {
-            ret = decode_plane(c, i, frame.f->data[0] + ff_ut_rgb_order[i],
-                               c->planes, frame.f->linesize[0], avctx->width,
+            ret = decode_plane(c, i, frame.f->data[i], 1,
+                               frame.f->linesize[i], avctx->width,
                                avctx->height, plane_start[i],
                                c->frame_pred == PRED_LEFT);
             if (ret)
                 return ret;
             if (c->frame_pred == PRED_MEDIAN) {
                 if (!c->interlaced) {
-                    restore_median(frame.f->data[0] + ff_ut_rgb_order[i],
-                                   c->planes, frame.f->linesize[0], avctx->width,
-                                   avctx->height, c->slices, 0);
+                    restore_median_planar(c, frame.f->data[i],
+                                          frame.f->linesize[i], avctx->width,
+                                          avctx->height, c->slices, 0);
                 } else {
-                    restore_median_il(frame.f->data[0] + ff_ut_rgb_order[i],
-                                      c->planes, frame.f->linesize[0],
-                                      avctx->width, avctx->height, c->slices,
-                                      0);
+                    restore_median_planar_il(c, frame.f->data[i],
+                                             frame.f->linesize[i],
+                                             avctx->width, avctx->height, c->slices,
+                                             0);
+                }
+            } else if (c->frame_pred == PRED_GRADIENT) {
+                if (!c->interlaced) {
+                    restore_gradient_planar(c, frame.f->data[i],
+                                            frame.f->linesize[i], avctx->width,
+                                            avctx->height, c->slices, 0);
+                } else {
+                    restore_gradient_planar_il(c, frame.f->data[i],
+                                               frame.f->linesize[i],
+                                               avctx->width, avctx->height, c->slices,
+                                               0);
                 }
             }
         }
-        restore_rgb_planes(frame.f->data[0], c->planes, frame.f->linesize[0],
-                           avctx->width, avctx->height);
+        c->utdsp.restore_rgb_planes(frame.f->data[2], frame.f->data[0], frame.f->data[1],
+                                    frame.f->linesize[2], frame.f->linesize[0], frame.f->linesize[1],
+                                    avctx->width, avctx->height);
         break;
     case AV_PIX_FMT_GBRAP10:
     case AV_PIX_FMT_GBRP10:
@@ -633,7 +669,9 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
             if (ret)
                 return ret;
         }
-        restore_rgb_planes10(frame.f, avctx->width, avctx->height);
+        c->utdsp.restore_rgb_planes10((uint16_t *)frame.f->data[2], (uint16_t *)frame.f->data[0], (uint16_t *)frame.f->data[1],
+                                      frame.f->linesize[2] / 2, frame.f->linesize[0] / 2, frame.f->linesize[1] / 2,
+                                      avctx->width, avctx->height);
         break;
     case AV_PIX_FMT_YUV420P:
         for (i = 0; i < 3; i++) {
@@ -644,14 +682,25 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                 return ret;
             if (c->frame_pred == PRED_MEDIAN) {
                 if (!c->interlaced) {
-                    restore_median(frame.f->data[i], 1, frame.f->linesize[i],
-                                   avctx->width >> !!i, avctx->height >> !!i,
-                                   c->slices, !i);
+                    restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
+                                          avctx->width >> !!i, avctx->height >> !!i,
+                                          c->slices, !i);
+                } else {
+                    restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
+                                             avctx->width  >> !!i,
+                                             avctx->height >> !!i,
+                                             c->slices, !i);
+                }
+            } else if (c->frame_pred == PRED_GRADIENT) {
+                if (!c->interlaced) {
+                    restore_gradient_planar(c, frame.f->data[i], frame.f->linesize[i],
+                                            avctx->width >> !!i, avctx->height >> !!i,
+                                            c->slices, !i);
                 } else {
-                    restore_median_il(frame.f->data[i], 1, frame.f->linesize[i],
-                                      avctx->width  >> !!i,
-                                      avctx->height >> !!i,
-                                      c->slices, !i);
+                    restore_gradient_planar_il(c, frame.f->data[i], frame.f->linesize[i],
+                                               avctx->width  >> !!i,
+                                               avctx->height >> !!i,
+                                               c->slices, !i);
                 }
             }
         }
@@ -665,13 +714,23 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                 return ret;
             if (c->frame_pred == PRED_MEDIAN) {
                 if (!c->interlaced) {
-                    restore_median(frame.f->data[i], 1, frame.f->linesize[i],
-                                   avctx->width >> !!i, avctx->height,
-                                   c->slices, 0);
+                    restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
+                                          avctx->width >> !!i, avctx->height,
+                                          c->slices, 0);
                 } else {
-                    restore_median_il(frame.f->data[i], 1, frame.f->linesize[i],
-                                      avctx->width >> !!i, avctx->height,
-                                      c->slices, 0);
+                    restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
+                                             avctx->width >> !!i, avctx->height,
+                                             c->slices, 0);
+                }
+            } else if (c->frame_pred == PRED_GRADIENT) {
+                if (!c->interlaced) {
+                    restore_gradient_planar(c, frame.f->data[i], frame.f->linesize[i],
+                                            avctx->width >> !!i, avctx->height,
+                                            c->slices, 0);
+                } else {
+                    restore_gradient_planar_il(c, frame.f->data[i], frame.f->linesize[i],
+                                               avctx->width  >> !!i, avctx->height,
+                                               c->slices, 0);
                 }
             }
         }
@@ -685,13 +744,23 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                 return ret;
             if (c->frame_pred == PRED_MEDIAN) {
                 if (!c->interlaced) {
-                    restore_median(frame.f->data[i], 1, frame.f->linesize[i],
-                                   avctx->width, avctx->height,
-                                   c->slices, 0);
+                    restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
+                                          avctx->width, avctx->height,
+                                          c->slices, 0);
+                } else {
+                    restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
+                                             avctx->width, avctx->height,
+                                             c->slices, 0);
+                }
+            } else if (c->frame_pred == PRED_GRADIENT) {
+                if (!c->interlaced) {
+                    restore_gradient_planar(c, frame.f->data[i], frame.f->linesize[i],
+                                            avctx->width, avctx->height,
+                                            c->slices, 0);
                 } else {
-                    restore_median_il(frame.f->data[i], 1, frame.f->linesize[i],
-                                      avctx->width, avctx->height,
-                                      c->slices, 0);
+                    restore_gradient_planar_il(c, frame.f->data[i], frame.f->linesize[i],
+                                               avctx->width, avctx->height,
+                                               c->slices, 0);
                 }
             }
         }
@@ -723,7 +792,9 @@ static av_cold int decode_init(AVCodecContext *avctx)
 
     c->avctx = avctx;
 
+    ff_utvideodsp_init(&c->utdsp);
     ff_bswapdsp_init(&c->bdsp);
+    ff_llviddsp_init(&c->llviddsp);
 
     if (avctx->extradata_size >= 16) {
         av_log(avctx, AV_LOG_DEBUG, "Encoder version %d.%d.%d.%d\n",
@@ -761,11 +832,11 @@ static av_cold int decode_init(AVCodecContext *avctx)
     switch (avctx->codec_tag) {
     case MKTAG('U', 'L', 'R', 'G'):
         c->planes      = 3;
-        avctx->pix_fmt = AV_PIX_FMT_RGB24;
+        avctx->pix_fmt = AV_PIX_FMT_GBRP;
         break;
     case MKTAG('U', 'L', 'R', 'A'):
         c->planes      = 4;
-        avctx->pix_fmt = AV_PIX_FMT_RGBA;
+        avctx->pix_fmt = AV_PIX_FMT_GBRAP;
         break;
     case MKTAG('U', 'L', 'Y', '0'):
         c->planes      = 3;
@@ -837,4 +908,5 @@ AVCodec ff_utvideo_decoder = {
     .close          = decode_end,
     .decode         = decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/utvideodsp.c b/mythtv/external/FFmpeg/libavcodec/utvideodsp.c
new file mode 100644
index 00000000000..0831a6b97b2
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/utvideodsp.c
@@ -0,0 +1,82 @@
+/*
+ * 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 <stdint.h>
+
+#include "config.h"
+#include "libavutil/attributes.h"
+#include "utvideodsp.h"
+
+static void restore_rgb_planes_c(uint8_t *src_r,
+                                 uint8_t *src_g,
+                                 uint8_t *src_b,
+                                 ptrdiff_t linesize_r,
+                                 ptrdiff_t linesize_g,
+                                 ptrdiff_t linesize_b,
+                                 int width, int height)
+{
+    uint8_t r, g, b;
+    int i, j;
+
+    for (j = 0; j < height; j++) {
+        for (i = 0; i < width; i++) {
+            r = src_r[i];
+            g = src_g[i];
+            b = src_b[i];
+            src_r[i] = r + g - 0x80;
+            src_b[i] = b + g - 0x80;
+        }
+        src_r += linesize_r;
+        src_g += linesize_g;
+        src_b += linesize_b;
+    }
+}
+
+static void restore_rgb_planes10_c(uint16_t *src_r,
+                                   uint16_t *src_g,
+                                   uint16_t *src_b,
+                                   ptrdiff_t linesize_r,
+                                   ptrdiff_t linesize_g,
+                                   ptrdiff_t linesize_b,
+                                   int width, int height)
+{
+    int r, g, b;
+    int i, j;
+
+    for (j = 0; j < height; j++) {
+        for (i = 0; i < width; i++) {
+            r = src_r[i];
+            g = src_g[i];
+            b = src_b[i];
+            src_r[i] = (r + g - 0x200) & 0x3FF;
+            src_b[i] = (b + g - 0x200) & 0x3FF;
+        }
+        src_r += linesize_r;
+        src_g += linesize_g;
+        src_b += linesize_b;
+    }
+}
+
+av_cold void ff_utvideodsp_init(UTVideoDSPContext *c)
+{
+    c->restore_rgb_planes   = restore_rgb_planes_c;
+    c->restore_rgb_planes10 = restore_rgb_planes10_c;
+
+    if (ARCH_X86)
+        ff_utvideodsp_init_x86(c);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/utvideodsp.h b/mythtv/external/FFmpeg/libavcodec/utvideodsp.h
new file mode 100644
index 00000000000..a3d2550dce4
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/utvideodsp.h
@@ -0,0 +1,39 @@
+/*
+ * 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_UTVIDEODSP_H
+#define AVCODEC_UTVIDEODSP_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "libavutil/pixfmt.h"
+#include "config.h"
+
+typedef struct UTVideoDSPContext {
+    void (*restore_rgb_planes)(uint8_t *src_r, uint8_t *src_g, uint8_t *src_b,
+                               ptrdiff_t linesize_r, ptrdiff_t linesize_g,
+                               ptrdiff_t linesize_b, int width, int height);
+    void (*restore_rgb_planes10)(uint16_t *src_r, uint16_t *src_g, uint16_t *src_b,
+                                 ptrdiff_t linesize_r, ptrdiff_t linesize_g,
+                                 ptrdiff_t linesize_b, int width, int height);
+} UTVideoDSPContext;
+
+void ff_utvideodsp_init(UTVideoDSPContext *c);
+void ff_utvideodsp_init_x86(UTVideoDSPContext *c);
+
+#endif /* AVCODEC_UTVIDEODSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/utvideoenc.c b/mythtv/external/FFmpeg/libavcodec/utvideoenc.c
index 6082943764d..840742caf71 100644
--- a/mythtv/external/FFmpeg/libavcodec/utvideoenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/utvideoenc.c
@@ -33,7 +33,6 @@
 #include "bswapdsp.h"
 #include "bytestream.h"
 #include "put_bits.h"
-#include "huffyuvencdsp.h"
 #include "mathops.h"
 #include "utvideo.h"
 #include "huffman.h"
@@ -120,7 +119,7 @@ static av_cold int utvideo_encode_init(AVCodecContext *avctx)
     }
 
     ff_bswapdsp_init(&c->bdsp);
-    ff_huffyuvencdsp_init(&c->hdsp);
+    ff_llvidencdsp_init(&c->llvidencdsp);
 
 #if FF_API_PRIVATE_OPT
 FF_DISABLE_DEPRECATION_WARNINGS
@@ -243,8 +242,9 @@ FF_ENABLE_DEPRECATION_WARNINGS
     return 0;
 }
 
-static void mangle_rgb_planes(uint8_t *dst[4], int dst_stride, uint8_t *src,
-                              int step, int stride, int width, int height)
+static void mangle_rgb_planes(uint8_t *dst[4], ptrdiff_t dst_stride,
+                              uint8_t *src, int step, ptrdiff_t stride,
+                              int width, int height)
 {
     int i, j;
     int k = 2 * dst_stride;
@@ -277,7 +277,7 @@ static void mangle_rgb_planes(uint8_t *dst[4], int dst_stride, uint8_t *src,
 }
 
 /* Write data to a plane with left prediction */
-static void left_predict(uint8_t *src, uint8_t *dst, int stride,
+static void left_predict(uint8_t *src, uint8_t *dst, ptrdiff_t stride,
                          int width, int height)
 {
     int i, j;
@@ -293,9 +293,12 @@ static void left_predict(uint8_t *src, uint8_t *dst, int stride,
     }
 }
 
+#undef A
+#undef B
+
 /* Write data to a plane with median prediction */
-static void median_predict(UtvideoContext *c, uint8_t *src, uint8_t *dst, int stride,
-                           int width, int height)
+static void median_predict(UtvideoContext *c, uint8_t *src, uint8_t *dst,
+                           ptrdiff_t stride, int width, int height)
 {
     int i, j;
     int A, B;
@@ -321,7 +324,7 @@ static void median_predict(UtvideoContext *c, uint8_t *src, uint8_t *dst, int st
 
     /* Rest of the coded part uses median prediction */
     for (j = 1; j < height; j++) {
-        c->hdsp.sub_hfyu_median_pred(dst, src - stride, src, width, &A, &B);
+        c->llvidencdsp.sub_median_pred(dst, src - stride, src, width, &A, &B);
         dst += width;
         src += stride;
     }
@@ -396,7 +399,7 @@ static int write_huff_codes(uint8_t *src, uint8_t *dst, int dst_size,
 }
 
 static int encode_plane(AVCodecContext *avctx, uint8_t *src,
-                        uint8_t *dst, int stride, int plane_no,
+                        uint8_t *dst, ptrdiff_t stride, int plane_no,
                         int width, int height, PutByteContext *pb)
 {
     UtvideoContext *c        = avctx->priv_data;
diff --git a/mythtv/external/FFmpeg/libavcodec/v210enc.c b/mythtv/external/FFmpeg/libavcodec/v210enc.c
index d3a8e26bc1b..a6afbbfc419 100644
--- a/mythtv/external/FFmpeg/libavcodec/v210enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/v210enc.c
@@ -110,6 +110,9 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
     ff_v210enc_init(s);
 
+    avctx->bits_per_coded_sample = 20;
+    avctx->bit_rate = ff_guess_coded_bitrate(avctx) * 16 / 15;
+
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/v308enc.c b/mythtv/external/FFmpeg/libavcodec/v308enc.c
index b60a72cee6a..e88f1f46481 100644
--- a/mythtv/external/FFmpeg/libavcodec/v308enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/v308enc.c
@@ -31,6 +31,9 @@ static av_cold int v308_encode_init(AVCodecContext *avctx)
         return AVERROR_INVALIDDATA;
     }
 
+    avctx->bits_per_coded_sample = 24;
+    avctx->bit_rate = ff_guess_coded_bitrate(avctx);
+
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/v408dec.c b/mythtv/external/FFmpeg/libavcodec/v408dec.c
index acff95d6bb9..196c575c097 100644
--- a/mythtv/external/FFmpeg/libavcodec/v408dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/v408dec.c
@@ -88,6 +88,7 @@ AVCodec ff_ayuv_decoder = {
     .init         = v408_decode_init,
     .decode       = v408_decode_frame,
     .capabilities = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
 #endif
 #if CONFIG_V408_DECODER
@@ -99,5 +100,6 @@ AVCodec ff_v408_decoder = {
     .init         = v408_decode_init,
     .decode       = v408_decode_frame,
     .capabilities = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/v408enc.c b/mythtv/external/FFmpeg/libavcodec/v408enc.c
index f37f360b73f..e12965b7ad6 100644
--- a/mythtv/external/FFmpeg/libavcodec/v408enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/v408enc.c
@@ -26,6 +26,8 @@
 
 static av_cold int v408_encode_init(AVCodecContext *avctx)
 {
+    avctx->bits_per_coded_sample = 32;
+    avctx->bit_rate = ff_guess_coded_bitrate(avctx);
 
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/v410enc.c b/mythtv/external/FFmpeg/libavcodec/v410enc.c
index f35ff759639..5e2450279fb 100644
--- a/mythtv/external/FFmpeg/libavcodec/v410enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/v410enc.c
@@ -32,6 +32,9 @@ static av_cold int v410_encode_init(AVCodecContext *avctx)
         return AVERROR_INVALIDDATA;
     }
 
+    avctx->bits_per_coded_sample = 32;
+    avctx->bit_rate = ff_guess_coded_bitrate(avctx);
+
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/v4l2_buffers.c b/mythtv/external/FFmpeg/libavcodec/v4l2_buffers.c
new file mode 100644
index 00000000000..ba70c5d14bc
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/v4l2_buffers.c
@@ -0,0 +1,463 @@
+/*
+ * V4L2 buffer helper functions.
+ *
+ * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
+ * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
+ *
+ * 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 <linux/videodev2.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <poll.h>
+#include "libavcodec/avcodec.h"
+#include "libavcodec/internal.h"
+#include "v4l2_context.h"
+#include "v4l2_buffers.h"
+#include "v4l2_m2m.h"
+
+#define USEC_PER_SEC 1000000
+
+static inline V4L2m2mContext *buf_to_m2mctx(V4L2Buffer *buf)
+{
+    return V4L2_TYPE_IS_OUTPUT(buf->context->type) ?
+        container_of(buf->context, V4L2m2mContext, output) :
+        container_of(buf->context, V4L2m2mContext, capture);
+}
+
+static inline AVCodecContext *logger(V4L2Buffer *buf)
+{
+    return buf_to_m2mctx(buf)->avctx;
+}
+
+static inline void v4l2_set_pts(V4L2Buffer *out, int64_t pts)
+{
+    V4L2m2mContext *s = buf_to_m2mctx(out);
+    AVRational v4l2_timebase = { 1, USEC_PER_SEC };
+    int64_t v4l2_pts;
+
+    if (pts == AV_NOPTS_VALUE)
+        pts = 0;
+
+    /* convert pts to v4l2 timebase */
+    v4l2_pts = av_rescale_q(pts, s->avctx->time_base, v4l2_timebase);
+    out->buf.timestamp.tv_usec = v4l2_pts % USEC_PER_SEC;
+    out->buf.timestamp.tv_sec = v4l2_pts / USEC_PER_SEC;
+}
+
+static inline uint64_t v4l2_get_pts(V4L2Buffer *avbuf)
+{
+    V4L2m2mContext *s = buf_to_m2mctx(avbuf);
+    AVRational v4l2_timebase = { 1, USEC_PER_SEC };
+    int64_t v4l2_pts;
+
+    /* convert pts back to encoder timebase */
+    v4l2_pts = avbuf->buf.timestamp.tv_sec * USEC_PER_SEC + avbuf->buf.timestamp.tv_usec;
+
+    return av_rescale_q(v4l2_pts, v4l2_timebase, s->avctx->time_base);
+}
+
+static enum AVColorPrimaries v4l2_get_color_primaries(V4L2Buffer *buf)
+{
+    enum v4l2_ycbcr_encoding ycbcr;
+    enum v4l2_colorspace cs;
+
+    cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
+        buf->context->format.fmt.pix_mp.colorspace :
+        buf->context->format.fmt.pix.colorspace;
+
+    ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
+        buf->context->format.fmt.pix_mp.ycbcr_enc:
+        buf->context->format.fmt.pix.ycbcr_enc;
+
+    switch(ycbcr) {
+    case V4L2_YCBCR_ENC_XV709:
+    case V4L2_YCBCR_ENC_709: return AVCOL_PRI_BT709;
+    case V4L2_YCBCR_ENC_XV601:
+    case V4L2_YCBCR_ENC_601:return AVCOL_PRI_BT470M;
+    default:
+        break;
+    }
+
+    switch(cs) {
+    case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_PRI_BT470BG;
+    case V4L2_COLORSPACE_SMPTE170M: return AVCOL_PRI_SMPTE170M;
+    case V4L2_COLORSPACE_SMPTE240M: return AVCOL_PRI_SMPTE240M;
+    case V4L2_COLORSPACE_BT2020: return AVCOL_PRI_BT2020;
+    default:
+        break;
+    }
+
+    return AVCOL_PRI_UNSPECIFIED;
+}
+
+static enum AVColorRange v4l2_get_color_range(V4L2Buffer *buf)
+{
+    enum v4l2_quantization qt;
+
+    qt = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
+        buf->context->format.fmt.pix_mp.quantization :
+        buf->context->format.fmt.pix.quantization;
+
+    switch (qt) {
+    case V4L2_QUANTIZATION_LIM_RANGE: return AVCOL_RANGE_MPEG;
+    case V4L2_QUANTIZATION_FULL_RANGE: return AVCOL_RANGE_JPEG;
+    default:
+        break;
+    }
+
+     return AVCOL_RANGE_UNSPECIFIED;
+}
+
+static enum AVColorSpace v4l2_get_color_space(V4L2Buffer *buf)
+{
+    enum v4l2_ycbcr_encoding ycbcr;
+    enum v4l2_colorspace cs;
+
+    cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
+        buf->context->format.fmt.pix_mp.colorspace :
+        buf->context->format.fmt.pix.colorspace;
+
+    ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
+        buf->context->format.fmt.pix_mp.ycbcr_enc:
+        buf->context->format.fmt.pix.ycbcr_enc;
+
+    switch(cs) {
+    case V4L2_COLORSPACE_SRGB: return AVCOL_SPC_RGB;
+    case V4L2_COLORSPACE_REC709: return AVCOL_SPC_BT709;
+    case V4L2_COLORSPACE_470_SYSTEM_M: return AVCOL_SPC_FCC;
+    case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_SPC_BT470BG;
+    case V4L2_COLORSPACE_SMPTE170M: return AVCOL_SPC_SMPTE170M;
+    case V4L2_COLORSPACE_SMPTE240M: return AVCOL_SPC_SMPTE240M;
+    case V4L2_COLORSPACE_BT2020:
+        if (ycbcr == V4L2_YCBCR_ENC_BT2020_CONST_LUM)
+            return AVCOL_SPC_BT2020_CL;
+        else
+             return AVCOL_SPC_BT2020_NCL;
+    default:
+        break;
+    }
+
+    return AVCOL_SPC_UNSPECIFIED;
+}
+
+static enum AVColorTransferCharacteristic v4l2_get_color_trc(V4L2Buffer *buf)
+{
+    enum v4l2_ycbcr_encoding ycbcr;
+    enum v4l2_xfer_func xfer;
+    enum v4l2_colorspace cs;
+
+    cs = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
+        buf->context->format.fmt.pix_mp.colorspace :
+        buf->context->format.fmt.pix.colorspace;
+
+    ycbcr = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
+        buf->context->format.fmt.pix_mp.ycbcr_enc:
+        buf->context->format.fmt.pix.ycbcr_enc;
+
+    xfer = V4L2_TYPE_IS_MULTIPLANAR(buf->buf.type) ?
+        buf->context->format.fmt.pix_mp.xfer_func:
+        buf->context->format.fmt.pix.xfer_func;
+
+    switch (xfer) {
+    case V4L2_XFER_FUNC_709: return AVCOL_TRC_BT709;
+    case V4L2_XFER_FUNC_SRGB: return AVCOL_TRC_IEC61966_2_1;
+    default:
+        break;
+    }
+
+    switch (cs) {
+    case V4L2_COLORSPACE_470_SYSTEM_M: return AVCOL_TRC_GAMMA22;
+    case V4L2_COLORSPACE_470_SYSTEM_BG: return AVCOL_TRC_GAMMA28;
+    case V4L2_COLORSPACE_SMPTE170M: return AVCOL_TRC_SMPTE170M;
+    case V4L2_COLORSPACE_SMPTE240M: return AVCOL_TRC_SMPTE240M;
+    default:
+        break;
+    }
+
+    switch (ycbcr) {
+    case V4L2_YCBCR_ENC_XV709:
+    case V4L2_YCBCR_ENC_XV601: return AVCOL_TRC_BT1361_ECG;
+    default:
+        break;
+    }
+
+    return AVCOL_TRC_UNSPECIFIED;
+}
+
+static void v4l2_free_buffer(void *opaque, uint8_t *unused)
+{
+    V4L2Buffer* avbuf = opaque;
+    V4L2m2mContext *s = buf_to_m2mctx(avbuf);
+
+    atomic_fetch_sub_explicit(&s->refcount, 1, memory_order_acq_rel);
+    if (s->reinit) {
+        if (!atomic_load(&s->refcount))
+            sem_post(&s->refsync);
+        return;
+    }
+
+    if (avbuf->context->streamon) {
+        ff_v4l2_buffer_enqueue(avbuf);
+        return;
+    }
+
+    if (!atomic_load(&s->refcount))
+        ff_v4l2_m2m_codec_end(s->avctx);
+}
+
+static int v4l2_buf_to_bufref(V4L2Buffer *in, int plane, AVBufferRef **buf)
+{
+    V4L2m2mContext *s = buf_to_m2mctx(in);
+
+    if (plane >= in->num_planes)
+        return AVERROR(EINVAL);
+
+    /* even though most encoders return 0 in data_offset encoding vp8 does require this value */
+    *buf = av_buffer_create((char *)in->plane_info[plane].mm_addr + in->planes[plane].data_offset,
+                            in->plane_info[plane].length, v4l2_free_buffer, in, 0);
+    if (!*buf)
+        return AVERROR(ENOMEM);
+
+    in->status = V4L2BUF_RET_USER;
+    atomic_fetch_add_explicit(&s->refcount, 1, memory_order_relaxed);
+
+    return 0;
+}
+
+static int v4l2_bufref_to_buf(V4L2Buffer *out, int plane, const uint8_t* data, int size, AVBufferRef* bref)
+{
+    unsigned int bytesused, length;
+
+    if (plane >= out->num_planes)
+        return AVERROR(EINVAL);
+
+    bytesused = FFMIN(size, out->plane_info[plane].length);
+    length = out->plane_info[plane].length;
+
+    memcpy(out->plane_info[plane].mm_addr, data, FFMIN(size, out->plane_info[plane].length));
+
+    if (V4L2_TYPE_IS_MULTIPLANAR(out->buf.type)) {
+        out->planes[plane].bytesused = bytesused;
+        out->planes[plane].length = length;
+    } else {
+        out->buf.bytesused = bytesused;
+        out->buf.length = length;
+    }
+
+    return 0;
+}
+
+/******************************************************************************
+ *
+ *              V4L2uffer interface
+ *
+ ******************************************************************************/
+
+int ff_v4l2_buffer_avframe_to_buf(const AVFrame *frame, V4L2Buffer* out)
+{
+    int i, ret;
+
+    for(i = 0; i < out->num_planes; i++) {
+        ret = v4l2_bufref_to_buf(out, i, frame->buf[i]->data, frame->buf[i]->size, frame->buf[i]);
+        if (ret)
+            return ret;
+    }
+
+    v4l2_set_pts(out, frame->pts);
+
+    return 0;
+}
+
+int ff_v4l2_buffer_buf_to_avframe(AVFrame *frame, V4L2Buffer *avbuf)
+{
+    V4L2m2mContext *s = buf_to_m2mctx(avbuf);
+    int i, ret;
+
+    av_frame_unref(frame);
+
+    /* 1. get references to the actual data */
+    for (i = 0; i < avbuf->num_planes; i++) {
+        ret = v4l2_buf_to_bufref(avbuf, i, &frame->buf[i]);
+        if (ret)
+            return ret;
+
+        frame->linesize[i] = avbuf->plane_info[i].bytesperline;
+        frame->data[i] = frame->buf[i]->data;
+    }
+
+    /* 1.1 fixup special cases */
+    switch (avbuf->context->av_pix_fmt) {
+    case AV_PIX_FMT_NV12:
+        if (avbuf->num_planes > 1)
+            break;
+        frame->linesize[1] = avbuf->plane_info[0].bytesperline;
+        frame->data[1] = frame->buf[0]->data + avbuf->plane_info[0].bytesperline * avbuf->context->format.fmt.pix_mp.height;
+        break;
+    default:
+        break;
+    }
+
+    /* 2. get frame information */
+    frame->key_frame = !!(avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME);
+    frame->format = avbuf->context->av_pix_fmt;
+    frame->color_primaries = v4l2_get_color_primaries(avbuf);
+    frame->colorspace = v4l2_get_color_space(avbuf);
+    frame->color_range = v4l2_get_color_range(avbuf);
+    frame->color_trc = v4l2_get_color_trc(avbuf);
+    frame->pts = v4l2_get_pts(avbuf);
+
+    /* these two values are updated also during re-init in v4l2_process_driver_event */
+    frame->height = s->output.height;
+    frame->width = s->output.width;
+
+    /* 3. report errors upstream */
+    if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {
+        av_log(logger(avbuf), AV_LOG_ERROR, "%s: driver decode error\n", avbuf->context->name);
+        frame->decode_error_flags |= FF_DECODE_ERROR_INVALID_BITSTREAM;
+    }
+
+    return 0;
+}
+
+int ff_v4l2_buffer_buf_to_avpkt(AVPacket *pkt, V4L2Buffer *avbuf)
+{
+    int ret;
+
+    av_packet_unref(pkt);
+    ret = v4l2_buf_to_bufref(avbuf, 0, &pkt->buf);
+    if (ret)
+        return ret;
+
+    pkt->size = V4L2_TYPE_IS_MULTIPLANAR(avbuf->buf.type) ? avbuf->buf.m.planes[0].bytesused : avbuf->buf.bytesused;
+    pkt->data = pkt->buf->data;
+
+    if (avbuf->buf.flags & V4L2_BUF_FLAG_KEYFRAME)
+        pkt->flags |= AV_PKT_FLAG_KEY;
+
+    if (avbuf->buf.flags & V4L2_BUF_FLAG_ERROR) {
+        av_log(logger(avbuf), AV_LOG_ERROR, "%s driver encode error\n", avbuf->context->name);
+        pkt->flags |= AV_PKT_FLAG_CORRUPT;
+    }
+
+    pkt->dts = pkt->pts = v4l2_get_pts(avbuf);
+
+    return 0;
+}
+
+int ff_v4l2_buffer_avpkt_to_buf(const AVPacket *pkt, V4L2Buffer *out)
+{
+    int ret;
+
+    ret = v4l2_bufref_to_buf(out, 0, pkt->data, pkt->size, pkt->buf);
+    if (ret)
+        return ret;
+
+    v4l2_set_pts(out, pkt->pts);
+
+    if (pkt->flags & AV_PKT_FLAG_KEY)
+        out->flags = V4L2_BUF_FLAG_KEYFRAME;
+
+    return 0;
+}
+
+int ff_v4l2_buffer_initialize(V4L2Buffer* avbuf, int index)
+{
+    V4L2Context *ctx = avbuf->context;
+    int ret, i;
+
+    avbuf->buf.memory = V4L2_MEMORY_MMAP;
+    avbuf->buf.type = ctx->type;
+    avbuf->buf.index = index;
+
+    if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
+        avbuf->buf.length = VIDEO_MAX_PLANES;
+        avbuf->buf.m.planes = avbuf->planes;
+    }
+
+    ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QUERYBUF, &avbuf->buf);
+    if (ret < 0)
+        return AVERROR(errno);
+
+    if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
+        avbuf->num_planes = 0;
+        for (;;) {
+            /* in MP, the V4L2 API states that buf.length means num_planes */
+            if (avbuf->num_planes >= avbuf->buf.length)
+                break;
+            if (avbuf->buf.m.planes[avbuf->num_planes].length)
+                avbuf->num_planes++;
+        }
+    } else
+        avbuf->num_planes = 1;
+
+    for (i = 0; i < avbuf->num_planes; i++) {
+
+        avbuf->plane_info[i].bytesperline = V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ?
+            ctx->format.fmt.pix_mp.plane_fmt[i].bytesperline :
+            ctx->format.fmt.pix.bytesperline;
+
+        if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
+            avbuf->plane_info[i].length = avbuf->buf.m.planes[i].length;
+            avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.m.planes[i].length,
+                                           PROT_READ | PROT_WRITE, MAP_SHARED,
+                                           buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.planes[i].m.mem_offset);
+        } else {
+            avbuf->plane_info[i].length = avbuf->buf.length;
+            avbuf->plane_info[i].mm_addr = mmap(NULL, avbuf->buf.length,
+                                          PROT_READ | PROT_WRITE, MAP_SHARED,
+                                          buf_to_m2mctx(avbuf)->fd, avbuf->buf.m.offset);
+        }
+
+        if (avbuf->plane_info[i].mm_addr == MAP_FAILED)
+            return AVERROR(ENOMEM);
+    }
+
+    avbuf->status = V4L2BUF_AVAILABLE;
+
+    if (V4L2_TYPE_IS_OUTPUT(ctx->type))
+        return 0;
+
+    if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
+        avbuf->buf.m.planes = avbuf->planes;
+        avbuf->buf.length   = avbuf->num_planes;
+
+    } else {
+        avbuf->buf.bytesused = avbuf->planes[0].bytesused;
+        avbuf->buf.length    = avbuf->planes[0].length;
+    }
+
+    return ff_v4l2_buffer_enqueue(avbuf);
+}
+
+int ff_v4l2_buffer_enqueue(V4L2Buffer* avbuf)
+{
+    int ret;
+
+    avbuf->buf.flags = avbuf->flags;
+
+    ret = ioctl(buf_to_m2mctx(avbuf)->fd, VIDIOC_QBUF, &avbuf->buf);
+    if (ret < 0)
+        return AVERROR(errno);
+
+    avbuf->status = V4L2BUF_IN_DRIVER;
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/v4l2_buffers.h b/mythtv/external/FFmpeg/libavcodec/v4l2_buffers.h
new file mode 100644
index 00000000000..e28a4a650d7
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/v4l2_buffers.h
@@ -0,0 +1,125 @@
+/*
+ * V4L2 buffer helper functions.
+ *
+ * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
+ * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
+ *
+ * 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_V4L2_BUFFERS_H
+#define AVCODEC_V4L2_BUFFERS_H
+
+#include <linux/videodev2.h>
+
+#include "avcodec.h"
+
+enum V4L2Buffer_status {
+    V4L2BUF_AVAILABLE,
+    V4L2BUF_IN_DRIVER,
+    V4L2BUF_RET_USER,
+};
+
+/**
+ * V4L2Buffer (wrapper for v4l2_buffer management)
+ */
+typedef struct V4L2Buffer {
+    /* each buffer needs to have a reference to its context */
+    struct V4L2Context *context;
+
+    /* keep track of the mmap address and mmap length */
+    struct V4L2Plane_info {
+        int bytesperline;
+        void * mm_addr;
+        size_t length;
+    } plane_info[VIDEO_MAX_PLANES];
+
+    int num_planes;
+
+    /* the v4l2_buffer buf.m.planes pointer uses the planes[] mem */
+    struct v4l2_buffer buf;
+    struct v4l2_plane planes[VIDEO_MAX_PLANES];
+
+    int flags;
+    enum V4L2Buffer_status status;
+
+} V4L2Buffer;
+
+/**
+ * Extracts the data from a V4L2Buffer to an AVFrame
+ *
+ * @param[in] frame The AVFRame to push the information to
+ * @param[in] buf The V4L2Buffer to get the information from
+ *
+ * @returns 0 in case of success, AVERROR(EINVAL) if the number of planes is incorrect,
+ * AVERROR(ENOMEM) if the AVBufferRef cant be created.
+ */
+int ff_v4l2_buffer_buf_to_avframe(AVFrame *frame, V4L2Buffer *buf);
+
+/**
+ * Extracts the data from a V4L2Buffer to an AVPacket
+ *
+ * @param[in] pkt The AVPacket to push the information to
+ * @param[in] buf The V4L2Buffer to get the information from
+ *
+ * @returns 0 in case of success, AVERROR(EINVAL) if the number of planes is incorrect,
+ * AVERROR(ENOMEM) if the AVBufferRef cant be created.
+ *
+ */
+int ff_v4l2_buffer_buf_to_avpkt(AVPacket *pkt, V4L2Buffer *buf);
+
+/**
+ * Extracts the data from an AVPacket to a V4L2Buffer
+ *
+ * @param[in]  frame AVPacket to get the data from
+ * @param[in]  avbuf V4L2Bfuffer to push the information to
+ *
+ * @returns 0 in case of success, a negative AVERROR code otherwise
+ */
+int ff_v4l2_buffer_avpkt_to_buf(const AVPacket *pkt, V4L2Buffer *out);
+
+/**
+ * Extracts the data from an AVFrame to a V4L2Buffer
+ *
+ * @param[in]  frame AVFrame to get the data from
+ * @param[in]  avbuf V4L2Bfuffer to push the information to
+ *
+ * @returns 0 in case of success, a negative AVERROR code otherwise
+ */
+int ff_v4l2_buffer_avframe_to_buf(const AVFrame *frame, V4L2Buffer* out);
+
+/**
+ * Initializes a V4L2Buffer
+ *
+ * @param[in]  avbuf V4L2Bfuffer to initialize
+ * @param[in]  index v4l2 buffer id
+ *
+ * @returns 0 in case of success, a negative AVERROR code otherwise
+ */
+int ff_v4l2_buffer_initialize(V4L2Buffer* avbuf, int index);
+
+/**
+ * Enqueues a V4L2Buffer
+ *
+ * @param[in] avbuf V4L2Bfuffer to push to the driver
+ *
+ * @returns 0 in case of success, a negative AVERROR code otherwise
+ */
+int ff_v4l2_buffer_enqueue(V4L2Buffer* avbuf);
+
+
+#endif // AVCODEC_V4L2_BUFFERS_H
diff --git a/mythtv/external/FFmpeg/libavcodec/v4l2_context.c b/mythtv/external/FFmpeg/libavcodec/v4l2_context.c
new file mode 100644
index 00000000000..9f3b56ddabf
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/v4l2_context.c
@@ -0,0 +1,691 @@
+/*
+ * V4L2 context helper functions.
+ *
+ * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
+ * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
+ *
+ * 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 <linux/videodev2.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <poll.h>
+#include "libavcodec/avcodec.h"
+#include "libavcodec/internal.h"
+#include "v4l2_buffers.h"
+#include "v4l2_fmt.h"
+#include "v4l2_m2m.h"
+
+struct v4l2_format_update {
+    uint32_t v4l2_fmt;
+    int update_v4l2;
+
+    enum AVPixelFormat av_fmt;
+    int update_avfmt;
+};
+
+static inline V4L2m2mContext *ctx_to_m2mctx(V4L2Context *ctx)
+{
+    return V4L2_TYPE_IS_OUTPUT(ctx->type) ?
+        container_of(ctx, V4L2m2mContext, output) :
+        container_of(ctx, V4L2m2mContext, capture);
+}
+
+static inline AVCodecContext *logger(V4L2Context *ctx)
+{
+    return ctx_to_m2mctx(ctx)->avctx;
+}
+
+static inline unsigned int v4l2_get_width(struct v4l2_format *fmt)
+{
+    return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.width : fmt->fmt.pix.width;
+}
+
+static inline unsigned int v4l2_get_height(struct v4l2_format *fmt)
+{
+    return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.height : fmt->fmt.pix.height;
+}
+
+static inline unsigned int v4l2_resolution_changed(V4L2Context *ctx, struct v4l2_format *fmt2)
+{
+    struct v4l2_format *fmt1 = &ctx->format;
+    int ret =  V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ?
+        fmt1->fmt.pix_mp.width != fmt2->fmt.pix_mp.width ||
+        fmt1->fmt.pix_mp.height != fmt2->fmt.pix_mp.height
+        :
+        fmt1->fmt.pix.width != fmt2->fmt.pix.width ||
+        fmt1->fmt.pix.height != fmt2->fmt.pix.height;
+
+    if (ret)
+        av_log(logger(ctx), AV_LOG_DEBUG, "%s changed (%dx%d) -> (%dx%d)\n",
+            ctx->name,
+            v4l2_get_width(fmt1), v4l2_get_height(fmt1),
+            v4l2_get_width(fmt2), v4l2_get_height(fmt2));
+
+    return ret;
+}
+
+static inline int v4l2_type_supported(V4L2Context *ctx)
+{
+    return ctx->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ||
+        ctx->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ||
+        ctx->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+        ctx->type == V4L2_BUF_TYPE_VIDEO_OUTPUT;
+}
+
+static inline int v4l2_get_framesize_compressed(V4L2Context* ctx, int width, int height)
+{
+    V4L2m2mContext *s = ctx_to_m2mctx(ctx);
+    const int SZ_4K = 0x1000;
+    int size;
+
+    if (av_codec_is_decoder(s->avctx->codec))
+        return ((width * height * 3 / 2) / 2) + 128;
+
+    /* encoder */
+    size = FFALIGN(height, 32) * FFALIGN(width, 32) * 3 / 2 / 2;
+    return FFALIGN(size, SZ_4K);
+}
+
+static inline void v4l2_save_to_context(V4L2Context* ctx, struct v4l2_format_update *fmt)
+{
+    ctx->format.type = ctx->type;
+
+    if (fmt->update_avfmt)
+        ctx->av_pix_fmt = fmt->av_fmt;
+
+    if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
+        /* update the sizes to handle the reconfiguration of the capture stream at runtime */
+        ctx->format.fmt.pix_mp.height = ctx->height;
+        ctx->format.fmt.pix_mp.width = ctx->width;
+        if (fmt->update_v4l2) {
+            ctx->format.fmt.pix_mp.pixelformat = fmt->v4l2_fmt;
+
+            /* s5p-mfc requires the user to specify a buffer size */
+            ctx->format.fmt.pix_mp.plane_fmt[0].sizeimage =
+                v4l2_get_framesize_compressed(ctx, ctx->width, ctx->height);
+        }
+    } else {
+        ctx->format.fmt.pix.height = ctx->height;
+        ctx->format.fmt.pix.width = ctx->width;
+        if (fmt->update_v4l2) {
+            ctx->format.fmt.pix.pixelformat = fmt->v4l2_fmt;
+
+            /* s5p-mfc requires the user to specify a buffer size */
+            ctx->format.fmt.pix.sizeimage =
+                v4l2_get_framesize_compressed(ctx, ctx->width, ctx->height);
+        }
+    }
+}
+
+/**
+ * returns 1 if reinit was successful, negative if it failed
+ * returns 0 if reinit was not executed
+ */
+static int v4l2_handle_event(V4L2Context *ctx)
+{
+    V4L2m2mContext *s = ctx_to_m2mctx(ctx);
+    struct v4l2_format cap_fmt = s->capture.format;
+    struct v4l2_format out_fmt = s->output.format;
+    struct v4l2_event evt = { 0 };
+    int full_reinit, reinit, ret;
+
+    ret = ioctl(s->fd, VIDIOC_DQEVENT, &evt);
+    if (ret < 0) {
+        av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_DQEVENT\n", ctx->name);
+        return 0;
+    }
+
+    if (evt.type != V4L2_EVENT_SOURCE_CHANGE)
+        return 0;
+
+    ret = ioctl(s->fd, VIDIOC_G_FMT, &out_fmt);
+    if (ret) {
+        av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT\n", s->output.name);
+        return 0;
+    }
+
+    ret = ioctl(s->fd, VIDIOC_G_FMT, &cap_fmt);
+    if (ret) {
+        av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT\n", s->capture.name);
+        return 0;
+    }
+
+    full_reinit = v4l2_resolution_changed(&s->output, &out_fmt);
+    if (full_reinit) {
+        s->output.height = v4l2_get_height(&out_fmt);
+        s->output.width = v4l2_get_width(&out_fmt);
+    }
+
+    reinit = v4l2_resolution_changed(&s->capture, &cap_fmt);
+    if (reinit) {
+        s->capture.height = v4l2_get_height(&cap_fmt);
+        s->capture.width = v4l2_get_width(&cap_fmt);
+    }
+
+    if (full_reinit || reinit)
+        s->reinit = 1;
+
+    if (full_reinit) {
+        ret = ff_v4l2_m2m_codec_full_reinit(s);
+        if (ret) {
+            av_log(logger(ctx), AV_LOG_ERROR, "v4l2_m2m_codec_full_reinit\n");
+            return -EINVAL;
+        }
+        goto reinit_run;
+    }
+
+    if (reinit) {
+        ret = ff_set_dimensions(s->avctx, s->capture.width, s->capture.height);
+        if (ret < 0)
+            av_log(logger(ctx), AV_LOG_WARNING, "update avcodec height and width\n");
+
+        ret = ff_v4l2_m2m_codec_reinit(s);
+        if (ret) {
+            av_log(logger(ctx), AV_LOG_ERROR, "v4l2_m2m_codec_reinit\n");
+            return -EINVAL;
+        }
+        goto reinit_run;
+    }
+
+    /* dummy event received */
+    return 0;
+
+    /* reinit executed */
+reinit_run:
+    return 1;
+}
+
+static int v4l2_stop_decode(V4L2Context *ctx)
+{
+    struct v4l2_decoder_cmd cmd = {
+        .cmd = V4L2_DEC_CMD_STOP,
+    };
+    int ret;
+
+    ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DECODER_CMD, &cmd);
+    if (ret) {
+        /* DECODER_CMD is optional */
+        if (errno == ENOTTY)
+            return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
+    }
+
+    return 0;
+}
+
+static int v4l2_stop_encode(V4L2Context *ctx)
+{
+    struct v4l2_encoder_cmd cmd = {
+        .cmd = V4L2_ENC_CMD_STOP,
+    };
+    int ret;
+
+    ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENCODER_CMD, &cmd);
+    if (ret) {
+        /* ENCODER_CMD is optional */
+        if (errno == ENOTTY)
+            return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
+    }
+
+    return 0;
+}
+
+static V4L2Buffer* v4l2_dequeue_v4l2buf(V4L2Context *ctx, int timeout)
+{
+    struct v4l2_plane planes[VIDEO_MAX_PLANES];
+    struct v4l2_buffer buf = { 0 };
+    V4L2Buffer* avbuf = NULL;
+    struct pollfd pfd = {
+        .events =  POLLIN | POLLRDNORM | POLLPRI | POLLOUT | POLLWRNORM, /* default blocking capture */
+        .fd = ctx_to_m2mctx(ctx)->fd,
+    };
+    int ret;
+
+    if (V4L2_TYPE_IS_OUTPUT(ctx->type))
+        pfd.events =  POLLOUT | POLLWRNORM;
+
+    for (;;) {
+        ret = poll(&pfd, 1, timeout);
+        if (ret > 0)
+            break;
+        if (errno == EINTR)
+            continue;
+
+        /* timeout is being used to indicate last valid bufer when draining */
+        if (ctx_to_m2mctx(ctx)->draining)
+            ctx->done = 1;
+
+        return NULL;
+    }
+
+    /* 0. handle errors */
+    if (pfd.revents & POLLERR) {
+        av_log(logger(ctx), AV_LOG_WARNING, "%s POLLERR\n", ctx->name);
+        return NULL;
+    }
+
+    /* 1. handle resolution changes */
+    if (pfd.revents & POLLPRI) {
+        ret = v4l2_handle_event(ctx);
+        if (ret < 0) {
+            /* if re-init failed, abort */
+            ctx->done = EINVAL;
+            return NULL;
+        }
+        if (ret) {
+            /* if re-init was successful drop the buffer (if there was one)
+             * since we had to reconfigure capture (unmap all buffers)
+             */
+            return NULL;
+        }
+    }
+
+    /* 2. dequeue the buffer */
+    if (pfd.revents & (POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM)) {
+
+        if (!V4L2_TYPE_IS_OUTPUT(ctx->type)) {
+            /* there is a capture buffer ready */
+            if (pfd.revents & (POLLIN | POLLRDNORM))
+                goto dequeue;
+
+            /* the driver is ready to accept more input; instead of waiting for the capture
+             * buffer to complete we return NULL so input can proceed (we are single threaded)
+             */
+            if (pfd.revents & (POLLOUT | POLLWRNORM))
+                return NULL;
+        }
+
+dequeue:
+        memset(&buf, 0, sizeof(buf));
+        buf.memory = V4L2_MEMORY_MMAP;
+        buf.type = ctx->type;
+        if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
+            memset(planes, 0, sizeof(planes));
+            buf.length = VIDEO_MAX_PLANES;
+            buf.m.planes = planes;
+        }
+
+        ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DQBUF, &buf);
+        if (ret) {
+            if (errno != EAGAIN) {
+                ctx->done = errno;
+                if (errno != EPIPE)
+                    av_log(logger(ctx), AV_LOG_DEBUG, "%s VIDIOC_DQBUF, errno (%s)\n",
+                        ctx->name, av_err2str(AVERROR(errno)));
+            }
+        } else {
+            avbuf = &ctx->buffers[buf.index];
+            avbuf->status = V4L2BUF_AVAILABLE;
+            avbuf->buf = buf;
+            if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
+                memcpy(avbuf->planes, planes, sizeof(planes));
+                avbuf->buf.m.planes = avbuf->planes;
+            }
+        }
+    }
+
+    return avbuf;
+}
+
+static V4L2Buffer* v4l2_getfree_v4l2buf(V4L2Context *ctx)
+{
+    int timeout = 0; /* return when no more buffers to dequeue */
+    int i;
+
+    /* get back as many output buffers as possible */
+    if (V4L2_TYPE_IS_OUTPUT(ctx->type)) {
+          do {
+          } while (v4l2_dequeue_v4l2buf(ctx, timeout));
+    }
+
+    for (i = 0; i < ctx->num_buffers; i++) {
+        if (ctx->buffers[i].status == V4L2BUF_AVAILABLE)
+            return &ctx->buffers[i];
+    }
+
+    return NULL;
+}
+
+static int v4l2_release_buffers(V4L2Context* ctx)
+{
+    struct v4l2_requestbuffers req = {
+        .memory = V4L2_MEMORY_MMAP,
+        .type = ctx->type,
+        .count = 0, /* 0 -> unmaps buffers from the driver */
+    };
+    int i, j;
+
+    for (i = 0; i < ctx->num_buffers; i++) {
+        V4L2Buffer *buffer = &ctx->buffers[i];
+
+        for (j = 0; j < buffer->num_planes; j++) {
+            struct V4L2Plane_info *p = &buffer->plane_info[j];
+            if (p->mm_addr && p->length)
+                if (munmap(p->mm_addr, p->length) < 0)
+                    av_log(logger(ctx), AV_LOG_ERROR, "%s unmap plane (%s))\n", ctx->name, av_err2str(AVERROR(errno)));
+        }
+    }
+
+    return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_REQBUFS, &req);
+}
+
+static inline int v4l2_try_raw_format(V4L2Context* ctx, enum AVPixelFormat pixfmt)
+{
+    struct v4l2_format *fmt = &ctx->format;
+    uint32_t v4l2_fmt;
+    int ret;
+
+    v4l2_fmt = ff_v4l2_format_avfmt_to_v4l2(pixfmt);
+    if (!v4l2_fmt)
+        return AVERROR(EINVAL);
+
+    if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type))
+        fmt->fmt.pix_mp.pixelformat = v4l2_fmt;
+    else
+        fmt->fmt.pix.pixelformat = v4l2_fmt;
+
+    fmt->type = ctx->type;
+
+    ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, fmt);
+    if (ret)
+        return AVERROR(EINVAL);
+
+    return 0;
+}
+
+static int v4l2_get_raw_format(V4L2Context* ctx, enum AVPixelFormat *p)
+{
+    enum AVPixelFormat pixfmt = ctx->av_pix_fmt;
+    struct v4l2_fmtdesc fdesc;
+    int ret;
+
+    memset(&fdesc, 0, sizeof(fdesc));
+    fdesc.type = ctx->type;
+
+    if (pixfmt != AV_PIX_FMT_NONE) {
+        ret = v4l2_try_raw_format(ctx, pixfmt);
+        if (ret)
+            pixfmt = AV_PIX_FMT_NONE;
+        else
+            return 0;
+    }
+
+    for (;;) {
+        ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
+        if (ret)
+            return AVERROR(EINVAL);
+
+        pixfmt = ff_v4l2_format_v4l2_to_avfmt(fdesc.pixelformat, AV_CODEC_ID_RAWVIDEO);
+        ret = v4l2_try_raw_format(ctx, pixfmt);
+        if (ret){
+            fdesc.index++;
+            continue;
+        }
+
+        *p = pixfmt;
+
+        return 0;
+    }
+
+    return AVERROR(EINVAL);
+}
+
+static int v4l2_get_coded_format(V4L2Context* ctx, uint32_t *p)
+{
+    struct v4l2_fmtdesc fdesc;
+    uint32_t v4l2_fmt;
+    int ret;
+
+    /* translate to a valid v4l2 format */
+    v4l2_fmt = ff_v4l2_format_avcodec_to_v4l2(ctx->av_codec_id);
+    if (!v4l2_fmt)
+        return AVERROR(EINVAL);
+
+    /* check if the driver supports this format */
+    memset(&fdesc, 0, sizeof(fdesc));
+    fdesc.type = ctx->type;
+
+    for (;;) {
+        ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
+        if (ret)
+            return AVERROR(EINVAL);
+
+        if (fdesc.pixelformat == v4l2_fmt)
+            break;
+
+        fdesc.index++;
+    }
+
+    *p = v4l2_fmt;
+
+    return 0;
+}
+
+ /*****************************************************************************
+  *
+  *             V4L2 Context Interface
+  *
+  *****************************************************************************/
+
+int ff_v4l2_context_set_status(V4L2Context* ctx, int cmd)
+{
+    int type = ctx->type;
+    int ret;
+
+    ret = ioctl(ctx_to_m2mctx(ctx)->fd, cmd, &type);
+    if (ret < 0)
+        return AVERROR(errno);
+
+    ctx->streamon = (cmd == VIDIOC_STREAMON);
+
+    return 0;
+}
+
+int ff_v4l2_context_enqueue_frame(V4L2Context* ctx, const AVFrame* frame)
+{
+    V4L2m2mContext *s = ctx_to_m2mctx(ctx);
+    V4L2Buffer* avbuf;
+    int ret;
+
+    if (!frame) {
+        ret = v4l2_stop_encode(ctx);
+        if (ret)
+            av_log(logger(ctx), AV_LOG_ERROR, "%s stop_encode\n", ctx->name);
+        s->draining= 1;
+        return 0;
+    }
+
+    avbuf = v4l2_getfree_v4l2buf(ctx);
+    if (!avbuf)
+        return AVERROR(ENOMEM);
+
+    ret = ff_v4l2_buffer_avframe_to_buf(frame, avbuf);
+    if (ret)
+        return ret;
+
+    return ff_v4l2_buffer_enqueue(avbuf);
+}
+
+int ff_v4l2_context_enqueue_packet(V4L2Context* ctx, const AVPacket* pkt)
+{
+    V4L2m2mContext *s = ctx_to_m2mctx(ctx);
+    V4L2Buffer* avbuf;
+    int ret;
+
+    if (!pkt->size) {
+        ret = v4l2_stop_decode(ctx);
+        if (ret)
+            av_log(logger(ctx), AV_LOG_ERROR, "%s stop_decode\n", ctx->name);
+        s->draining = 1;
+        return 0;
+    }
+
+    avbuf = v4l2_getfree_v4l2buf(ctx);
+    if (!avbuf)
+        return AVERROR(ENOMEM);
+
+    ret = ff_v4l2_buffer_avpkt_to_buf(pkt, avbuf);
+    if (ret)
+        return ret;
+
+    return ff_v4l2_buffer_enqueue(avbuf);
+}
+
+int ff_v4l2_context_dequeue_frame(V4L2Context* ctx, AVFrame* frame)
+{
+    V4L2Buffer* avbuf = NULL;
+
+    /* if we are draining, we are no longer inputing data, therefore enable a
+     * timeout so we can dequeue and flag the last valid buffer.
+     *
+     * blocks until:
+     *  1. decoded frame available
+     *  2. an input buffer is ready to be dequeued
+     */
+    avbuf = v4l2_dequeue_v4l2buf(ctx, ctx_to_m2mctx(ctx)->draining ? 200 : -1);
+    if (!avbuf) {
+        if (ctx->done)
+            return AVERROR_EOF;
+
+        return AVERROR(EAGAIN);
+    }
+
+    return ff_v4l2_buffer_buf_to_avframe(frame, avbuf);
+}
+
+int ff_v4l2_context_dequeue_packet(V4L2Context* ctx, AVPacket* pkt)
+{
+    V4L2Buffer* avbuf = NULL;
+
+    /* if we are draining, we are no longer inputing data, therefore enable a
+     * timeout so we can dequeue and flag the last valid buffer.
+     *
+     * blocks until:
+     *  1. encoded packet available
+     *  2. an input buffer ready to be dequeued
+     */
+    avbuf = v4l2_dequeue_v4l2buf(ctx, ctx_to_m2mctx(ctx)->draining ? 200 : -1);
+    if (!avbuf) {
+        if (ctx->done)
+            return AVERROR_EOF;
+
+        return AVERROR(EAGAIN);
+    }
+
+    return ff_v4l2_buffer_buf_to_avpkt(pkt, avbuf);
+}
+
+int ff_v4l2_context_get_format(V4L2Context* ctx)
+{
+    struct v4l2_format_update fmt = { 0 };
+    int ret;
+
+    if  (ctx->av_codec_id == AV_CODEC_ID_RAWVIDEO) {
+        ret = v4l2_get_raw_format(ctx, &fmt.av_fmt);
+        if (ret)
+            return ret;
+
+        fmt.update_avfmt = 1;
+        v4l2_save_to_context(ctx, &fmt);
+
+        /* format has been tried already */
+        return ret;
+    }
+
+    ret = v4l2_get_coded_format(ctx, &fmt.v4l2_fmt);
+    if (ret)
+        return ret;
+
+    fmt.update_v4l2 = 1;
+    v4l2_save_to_context(ctx, &fmt);
+
+    return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, &ctx->format);
+}
+
+int ff_v4l2_context_set_format(V4L2Context* ctx)
+{
+    return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_S_FMT, &ctx->format);
+}
+
+void ff_v4l2_context_release(V4L2Context* ctx)
+{
+    int ret;
+
+    if (!ctx->buffers)
+        return;
+
+    ret = v4l2_release_buffers(ctx);
+    if (ret)
+        av_log(logger(ctx), AV_LOG_WARNING, "V4L2 failed to unmap the %s buffers\n", ctx->name);
+
+    av_free(ctx->buffers);
+    ctx->buffers = NULL;
+}
+
+int ff_v4l2_context_init(V4L2Context* ctx)
+{
+    V4L2m2mContext *s = ctx_to_m2mctx(ctx);
+    struct v4l2_requestbuffers req;
+    int ret, i;
+
+    if (!v4l2_type_supported(ctx)) {
+        av_log(logger(ctx), AV_LOG_ERROR, "type %i not supported\n", ctx->type);
+        return AVERROR_PATCHWELCOME;
+    }
+
+    ret = ioctl(s->fd, VIDIOC_G_FMT, &ctx->format);
+    if (ret)
+        av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT failed\n", ctx->name);
+
+    memset(&req, 0, sizeof(req));
+    req.count = ctx->num_buffers;
+    req.memory = V4L2_MEMORY_MMAP;
+    req.type = ctx->type;
+    ret = ioctl(s->fd, VIDIOC_REQBUFS, &req);
+    if (ret < 0)
+        return AVERROR(errno);
+
+    ctx->num_buffers = req.count;
+    ctx->buffers = av_mallocz(ctx->num_buffers * sizeof(V4L2Buffer));
+    if (!ctx->buffers) {
+            av_log(logger(ctx), AV_LOG_ERROR, "%s malloc enomem\n", ctx->name);
+            return AVERROR(ENOMEM);
+    }
+
+    for (i = 0; i < req.count; i++) {
+        ctx->buffers[i].context = ctx;
+        ret = ff_v4l2_buffer_initialize(&ctx->buffers[i], i);
+        if (ret < 0) {
+            av_log(logger(ctx), AV_LOG_ERROR, "%s buffer initialization (%s)\n", ctx->name, av_err2str(ret));
+            av_free(ctx->buffers);
+            return ret;
+        }
+    }
+
+    av_log(logger(ctx), AV_LOG_DEBUG, "%s: %s %02d buffers initialized: %04ux%04u, sizeimage %08u, bytesperline %08u\n", ctx->name,
+        V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? av_fourcc2str(ctx->format.fmt.pix_mp.pixelformat) : av_fourcc2str(ctx->format.fmt.pix.pixelformat),
+        req.count,
+        v4l2_get_width(&ctx->format),
+        v4l2_get_height(&ctx->format),
+        V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].sizeimage : ctx->format.fmt.pix.sizeimage,
+        V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].bytesperline : ctx->format.fmt.pix.bytesperline);
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/v4l2_context.h b/mythtv/external/FFmpeg/libavcodec/v4l2_context.h
new file mode 100644
index 00000000000..503cc36dc4a
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/v4l2_context.h
@@ -0,0 +1,183 @@
+/*
+ * V4L2 context helper functions.
+ *
+ * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
+ * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
+ *
+ * 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_V4L2_CONTEXT_H
+#define AVCODEC_V4L2_CONTEXT_H
+
+#include <stdatomic.h>
+#include <linux/videodev2.h>
+
+#include "libavcodec/avcodec.h"
+#include "libavutil/pixfmt.h"
+#include "libavutil/frame.h"
+#include "libavutil/buffer.h"
+#include "v4l2_buffers.h"
+
+typedef struct V4L2Context {
+    /**
+     * context name.
+     */
+    const char* name;
+
+    /**
+     * Type of this buffer context.
+     * See V4L2_BUF_TYPE_VIDEO_* in videodev2.h
+     * Readonly after init.
+     */
+    enum v4l2_buf_type type;
+
+    /**
+     * AVPixelFormat corresponding to this buffer context.
+     * AV_PIX_FMT_NONE means this is an encoded stream.
+     */
+    enum AVPixelFormat av_pix_fmt;
+
+    /**
+     * AVCodecID corresponding to this buffer context.
+     * AV_CODEC_ID_RAWVIDEO means this is a raw stream and av_pix_fmt must be set to a valid value.
+     */
+    enum AVCodecID av_codec_id;
+
+    /**
+     * Format returned by the driver after initializing the buffer context.
+     * Readonly after init.
+     */
+    struct v4l2_format format;
+
+    /**
+     * Width and height of the frames it produces (in case of a capture context, e.g. when decoding)
+     * or accepts (in case of an output context, e.g. when encoding).
+     */
+    int width, height;
+
+    /**
+     * Indexed array of V4L2Buffers
+     */
+    V4L2Buffer *buffers;
+
+    /**
+     * Readonly after init.
+     */
+    int num_buffers;
+
+    /**
+     * Whether the stream has been started (VIDIOC_STREAMON has been sent).
+     */
+    int streamon;
+
+    /**
+     *  Either no more buffers available or an unrecoverable error was notified
+     *  by the V4L2 kernel driver: once set the context has to be exited.
+     */
+    int done;
+
+} V4L2Context;
+
+/**
+ * Initializes a V4L2Context.
+ *
+ * @param[in] ctx A pointer to a V4L2Context. See V4L2Context description for required variables.
+ * @return 0 in case of success, a negative value representing the error otherwise.
+ */
+int ff_v4l2_context_init(V4L2Context* ctx);
+
+/**
+ * Sets the V4L2Context format in the v4l2 driver.
+ *
+ * @param[in] ctx A pointer to a V4L2Context. See V4L2Context description for required variables.
+ * @return 0 in case of success, a negative value representing the error otherwise.
+ */
+int ff_v4l2_context_set_format(V4L2Context* ctx);
+
+/**
+ * Queries the driver for a valid v4l2 format and copies it to the context.
+ *
+ * @param[in] ctx A pointer to a V4L2Context. See V4L2Context description for required variables.
+ * @return 0 in case of success, a negative value representing the error otherwise.
+ */
+int ff_v4l2_context_get_format(V4L2Context* ctx);
+
+/**
+ * Releases a V4L2Context.
+ *
+ * @param[in] ctx A pointer to a V4L2Context.
+ *               The caller is reponsible for freeing it.
+ *               It must not be used after calling this function.
+ */
+void ff_v4l2_context_release(V4L2Context* ctx);
+
+/**
+ * Sets the status of a V4L2Context.
+ *
+ * @param[in] ctx A pointer to a V4L2Context.
+ * @param[in] cmd The status to set (VIDIOC_STREAMON or VIDIOC_STREAMOFF).
+ *                Warning: If VIDIOC_STREAMOFF is sent to a buffer context that still has some frames buffered,
+ *                those frames will be dropped.
+ * @return 0 in case of success, a negative value representing the error otherwise.
+ */
+int ff_v4l2_context_set_status(V4L2Context* ctx, int cmd);
+
+/**
+ * Dequeues a buffer from a V4L2Context to an AVPacket.
+ *
+ * The pkt must be non NULL.
+ * @param[in] ctx The V4L2Context to dequeue from.
+ * @param[inout] pkt The AVPacket to dequeue to.
+ * @return 0 in case of success, AVERROR(EAGAIN) if no buffer was ready, another negative error in case of error.
+ */
+int ff_v4l2_context_dequeue_packet(V4L2Context* ctx, AVPacket* pkt);
+
+/**
+ * Dequeues a buffer from a V4L2Context to an AVFrame.
+ *
+ * The frame must be non NULL.
+ * @param[in] ctx The V4L2Context to dequeue from.
+ * @param[inout] f The AVFrame to dequeue to.
+ * @return 0 in case of success, AVERROR(EAGAIN) if no buffer was ready, another negative error in case of error.
+ */
+int ff_v4l2_context_dequeue_frame(V4L2Context* ctx, AVFrame* f);
+
+/**
+ * Enqueues a buffer to a V4L2Context from an AVPacket
+ *
+ * The packet must be non NULL.
+ * When the size of the pkt is null, the buffer is not queued but a V4L2_DEC_CMD_STOP command is sent instead to the driver.
+ *
+ * @param[in] ctx The V4L2Context to enqueue to.
+ * @param[in] pkt A pointer to an AVPacket.
+ * @return 0 in case of success, a negative error otherwise.
+ */
+int ff_v4l2_context_enqueue_packet(V4L2Context* ctx, const AVPacket* pkt);
+
+/**
+ * Enqueues a buffer to a V4L2Context from an AVFrame
+ *
+ * The frame must be non NULL.
+ *
+ * @param[in] ctx The V4L2Context to enqueue to.
+ * @param[in] f A pointer to an AVFrame to enqueue.
+ * @return 0 in case of success, a negative error otherwise.
+ */
+int ff_v4l2_context_enqueue_frame(V4L2Context* ctx, const AVFrame* f);
+
+#endif // AVCODEC_V4L2_CONTEXT_H
diff --git a/mythtv/external/FFmpeg/libavcodec/v4l2_fmt.c b/mythtv/external/FFmpeg/libavcodec/v4l2_fmt.c
new file mode 100644
index 00000000000..6df47e3f5a3
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/v4l2_fmt.c
@@ -0,0 +1,141 @@
+/*
+ * V4L2 format helper functions
+ *
+ * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
+ * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
+ *
+ * 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 <linux/videodev2.h>
+#include <search.h>
+#include "v4l2_fmt.h"
+
+#define V4L2_FMT(x) V4L2_PIX_FMT_##x
+#define AV_CODEC(x) AV_CODEC_ID_##x
+#define AV_FMT(x)   AV_PIX_FMT_##x
+
+static const struct fmt_conversion {
+    enum AVPixelFormat avfmt;
+    enum AVCodecID avcodec;
+    uint32_t v4l2_fmt;
+} fmt_map[] = {
+    { AV_FMT(RGB555LE),    AV_CODEC(RAWVIDEO),    V4L2_FMT(RGB555) },
+    { AV_FMT(RGB555BE),    AV_CODEC(RAWVIDEO),    V4L2_FMT(RGB555X) },
+    { AV_FMT(RGB565LE),    AV_CODEC(RAWVIDEO),    V4L2_FMT(RGB565) },
+    { AV_FMT(RGB565BE),    AV_CODEC(RAWVIDEO),    V4L2_FMT(RGB565X) },
+    { AV_FMT(BGR24),       AV_CODEC(RAWVIDEO),    V4L2_FMT(BGR24) },
+    { AV_FMT(RGB24),       AV_CODEC(RAWVIDEO),    V4L2_FMT(RGB24) },
+    { AV_FMT(BGR0),        AV_CODEC(RAWVIDEO),    V4L2_FMT(BGR32) },
+    { AV_FMT(0RGB),        AV_CODEC(RAWVIDEO),    V4L2_FMT(RGB32) },
+    { AV_FMT(GRAY8),       AV_CODEC(RAWVIDEO),    V4L2_FMT(GREY) },
+    { AV_FMT(YUV420P),     AV_CODEC(RAWVIDEO),    V4L2_FMT(YUV420) },
+    { AV_FMT(YUYV422),     AV_CODEC(RAWVIDEO),    V4L2_FMT(YUYV) },
+    { AV_FMT(UYVY422),     AV_CODEC(RAWVIDEO),    V4L2_FMT(UYVY) },
+    { AV_FMT(YUV422P),     AV_CODEC(RAWVIDEO),    V4L2_FMT(YUV422P) },
+    { AV_FMT(YUV411P),     AV_CODEC(RAWVIDEO),    V4L2_FMT(YUV411P) },
+    { AV_FMT(YUV410P),     AV_CODEC(RAWVIDEO),    V4L2_FMT(YUV410) },
+    { AV_FMT(YUV410P),     AV_CODEC(RAWVIDEO),    V4L2_FMT(YVU410) },
+    { AV_FMT(NV12),        AV_CODEC(RAWVIDEO),    V4L2_FMT(NV12) },
+    { AV_FMT(NONE),        AV_CODEC(MJPEG),       V4L2_FMT(MJPEG) },
+    { AV_FMT(NONE),        AV_CODEC(MJPEG),       V4L2_FMT(JPEG) },
+#ifdef V4L2_PIX_FMT_SRGGB8
+    { AV_FMT(BAYER_BGGR8), AV_CODEC(RAWVIDEO),    V4L2_FMT(SBGGR8) },
+    { AV_FMT(BAYER_GBRG8), AV_CODEC(RAWVIDEO),    V4L2_FMT(SGBRG8) },
+    { AV_FMT(BAYER_GRBG8), AV_CODEC(RAWVIDEO),    V4L2_FMT(SGRBG8) },
+    { AV_FMT(BAYER_RGGB8), AV_CODEC(RAWVIDEO),    V4L2_FMT(SRGGB8) },
+#endif
+#ifdef V4L2_PIX_FMT_Y16
+    { AV_FMT(GRAY16LE),    AV_CODEC(RAWVIDEO),    V4L2_FMT(Y16) },
+#endif
+#ifdef V4L2_PIX_FMT_NV12M
+    { AV_FMT(NV12),        AV_CODEC(RAWVIDEO),    V4L2_FMT(NV12M) },
+#endif
+#ifdef V4L2_PIX_FMT_NV21M
+    { AV_FMT(NV21),        AV_CODEC(RAWVIDEO),    V4L2_FMT(NV21M) },
+#endif
+#ifdef V4L2_PIX_FMT_YUV420M
+    { AV_FMT(YUV420P),     AV_CODEC(RAWVIDEO),    V4L2_FMT(YUV420M) },
+#endif
+#ifdef V4L2_PIX_FMT_NV16M
+    { AV_FMT(NV16),        AV_CODEC(RAWVIDEO),    V4L2_FMT(NV16M) },
+#endif
+#ifdef V4L2_PIX_FMT_H263
+    { AV_FMT(NONE),        AV_CODEC(H263),        V4L2_FMT(H263) },
+#endif
+#ifdef V4L2_PIX_FMT_H264
+    { AV_FMT(NONE),        AV_CODEC(H264),        V4L2_FMT(H264) },
+#endif
+#ifdef V4L2_PIX_FMT_MPEG4
+    { AV_FMT(NONE),        AV_CODEC(MPEG4),       V4L2_FMT(MPEG4) },
+#endif
+#ifdef V4L2_PIX_FMT_CPIA1
+    { AV_FMT(NONE),        AV_CODEC(CPIA),        V4L2_FMT(CPIA1) },
+#endif
+#ifdef V4L2_PIX_FMT_DV
+    { AV_FMT(NONE),        AV_CODEC(DVVIDEO),     V4L2_FMT(DV) },
+#endif
+#ifdef V4L2_PIX_FMT_MPEG1
+    { AV_FMT(NONE),        AV_CODEC(MPEG1VIDEO),  V4L2_FMT(MPEG1) },
+#endif
+#ifdef V4L2_PIX_FMT_MPEG2
+    { AV_FMT(NONE),        AV_CODEC(MPEG2VIDEO),  V4L2_FMT(MPEG2) },
+#endif
+#ifdef V4L2_PIX_FMT_VP8
+    { AV_FMT(NONE),        AV_CODEC(VP8),         V4L2_FMT(VP8) },
+#endif
+#ifdef V4L2_PIX_FMT_VP9
+    { AV_FMT(NONE),        AV_CODEC(VP9),         V4L2_FMT(VP9) },
+#endif
+#ifdef V4L2_PIX_FMT_HEVC
+    { AV_FMT(NONE),        AV_CODEC(HEVC),        V4L2_FMT(HEVC) },
+#endif
+#ifdef V4L2_PIX_FMT_VC1_ANNEX_G
+    { AV_FMT(NONE),        AV_CODEC(VC1),         V4L2_FMT(VC1_ANNEX_G) },
+#endif
+};
+
+uint32_t ff_v4l2_format_avcodec_to_v4l2(enum AVCodecID avcodec)
+{
+    int i;
+    for (i = 0; i < FF_ARRAY_ELEMS(fmt_map); i++) {
+        if (fmt_map[i].avcodec == avcodec)
+            return fmt_map[i].v4l2_fmt;
+    }
+    return 0;
+}
+
+uint32_t ff_v4l2_format_avfmt_to_v4l2(enum AVPixelFormat avfmt)
+{
+    int i;
+    for (i = 0; i < FF_ARRAY_ELEMS(fmt_map); i++) {
+        if (fmt_map[i].avfmt == avfmt)
+            return fmt_map[i].v4l2_fmt;
+    }
+    return 0;
+}
+
+enum AVPixelFormat ff_v4l2_format_v4l2_to_avfmt(uint32_t v4l2_fmt, enum AVCodecID avcodec)
+{
+    int i;
+    for (i = 0; i < FF_ARRAY_ELEMS(fmt_map); i++) {
+        if (fmt_map[i].avcodec  == avcodec &&
+            fmt_map[i].v4l2_fmt == v4l2_fmt)
+            return fmt_map[i].avfmt;
+    }
+    return AV_PIX_FMT_NONE;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/v4l2_fmt.h b/mythtv/external/FFmpeg/libavcodec/v4l2_fmt.h
new file mode 100644
index 00000000000..01360029c83
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/v4l2_fmt.h
@@ -0,0 +1,34 @@
+/*
+ * V4L2 format helper functions
+ *
+ * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
+ * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
+ *
+ * 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_V4L2_FMT_H
+#define AVCODEC_V4L2_FMT_H
+
+#include "libavcodec/avcodec.h"
+#include "libavutil/pixfmt.h"
+
+enum AVPixelFormat ff_v4l2_format_v4l2_to_avfmt(uint32_t v4l2_fmt, enum AVCodecID avcodec);
+uint32_t ff_v4l2_format_avcodec_to_v4l2(enum AVCodecID avcodec);
+uint32_t ff_v4l2_format_avfmt_to_v4l2(enum AVPixelFormat avfmt);
+
+#endif /* AVCODEC_V4L2_FMT_H*/
diff --git a/mythtv/external/FFmpeg/libavcodec/v4l2_m2m.c b/mythtv/external/FFmpeg/libavcodec/v4l2_m2m.c
new file mode 100644
index 00000000000..1d7a8521d80
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/v4l2_m2m.c
@@ -0,0 +1,383 @@
+/*
+ * V4L mem2mem
+ *
+ * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
+ * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
+ *
+ * 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 <linux/videodev2.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include "libavcodec/avcodec.h"
+#include "libavcodec/internal.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/pixfmt.h"
+#include "v4l2_context.h"
+#include "v4l2_fmt.h"
+#include "v4l2_m2m.h"
+
+static inline int v4l2_splane_video(struct v4l2_capability *cap)
+{
+    if (cap->capabilities & (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT) &&
+        cap->capabilities & V4L2_CAP_STREAMING)
+        return 1;
+
+    if (cap->capabilities & V4L2_CAP_VIDEO_M2M)
+        return 1;
+
+    return 0;
+}
+
+static inline int v4l2_mplane_video(struct v4l2_capability *cap)
+{
+    if (cap->capabilities & (V4L2_CAP_VIDEO_CAPTURE_MPLANE | V4L2_CAP_VIDEO_OUTPUT_MPLANE) &&
+        cap->capabilities & V4L2_CAP_STREAMING)
+        return 1;
+
+    if (cap->capabilities & V4L2_CAP_VIDEO_M2M_MPLANE)
+        return 1;
+
+    return 0;
+}
+
+static int v4l2_prepare_contexts(V4L2m2mContext* s)
+{
+    struct v4l2_capability cap;
+    int ret;
+
+    s->capture.done = s->output.done = 0;
+    s->capture.name = "capture";
+    s->output.name = "output ";
+    atomic_init(&s->refcount, 0);
+    sem_init(&s->refsync, 0, 0);
+
+    memset(&cap, 0, sizeof(cap));
+    ret = ioctl(s->fd, VIDIOC_QUERYCAP, &cap);
+    if (ret < 0)
+        return ret;
+
+    av_log(s->avctx, AV_LOG_INFO, "driver '%s' on card '%s'\n", cap.driver, cap.card);
+
+    if (v4l2_mplane_video(&cap)) {
+        s->capture.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+        s->output.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+        return 0;
+    }
+
+    if (v4l2_splane_video(&cap)) {
+        s->capture.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        s->output.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+        return 0;
+    }
+
+    return AVERROR(EINVAL);
+}
+
+static int v4l2_probe_driver(V4L2m2mContext* s)
+{
+    int ret;
+
+    s->fd = open(s->devname, O_RDWR | O_NONBLOCK, 0);
+    if (s->fd < 0)
+        return AVERROR(errno);
+
+    ret = v4l2_prepare_contexts(s);
+    if (ret < 0)
+        goto done;
+
+    ret = ff_v4l2_context_get_format(&s->output);
+    if (ret) {
+        av_log(s->avctx, AV_LOG_DEBUG, "v4l2 output format not supported\n");
+        goto done;
+    }
+
+    ret = ff_v4l2_context_get_format(&s->capture);
+    if (ret) {
+        av_log(s->avctx, AV_LOG_DEBUG, "v4l2 capture format not supported\n");
+        goto done;
+    }
+
+done:
+    if (close(s->fd) < 0) {
+        ret = AVERROR(errno);
+        av_log(s->avctx, AV_LOG_ERROR, "failure closing %s (%s)\n", s->devname, av_err2str(AVERROR(errno)));
+    }
+
+    s->fd = -1;
+
+    return ret;
+}
+
+static int v4l2_configure_contexts(V4L2m2mContext* s)
+{
+    void *log_ctx = s->avctx;
+    int ret;
+
+    s->fd = open(s->devname, O_RDWR | O_NONBLOCK, 0);
+    if (s->fd < 0)
+        return AVERROR(errno);
+
+    ret = v4l2_prepare_contexts(s);
+    if (ret < 0)
+        goto error;
+
+    ret = ff_v4l2_context_set_format(&s->output);
+    if (ret) {
+        av_log(log_ctx, AV_LOG_ERROR, "can't set v4l2 output format\n");
+        goto error;
+    }
+
+    ret = ff_v4l2_context_set_format(&s->capture);
+    if (ret) {
+        av_log(log_ctx, AV_LOG_ERROR, "can't to set v4l2 capture format\n");
+        goto error;
+    }
+
+    ret = ff_v4l2_context_init(&s->output);
+    if (ret) {
+        av_log(log_ctx, AV_LOG_ERROR, "no v4l2 output context's buffers\n");
+        goto error;
+    }
+
+    /* decoder's buffers need to be updated at a later stage */
+    if (!av_codec_is_decoder(s->avctx->codec)) {
+        ret = ff_v4l2_context_init(&s->capture);
+        if (ret) {
+            av_log(log_ctx, AV_LOG_ERROR, "no v4l2 capture context's buffers\n");
+            goto error;
+        }
+    }
+
+    return 0;
+
+error:
+    if (close(s->fd) < 0) {
+        ret = AVERROR(errno);
+        av_log(log_ctx, AV_LOG_ERROR, "error closing %s (%s)\n",
+            s->devname, av_err2str(AVERROR(errno)));
+    }
+    s->fd = -1;
+
+    return ret;
+}
+
+/******************************************************************************
+ *
+ *                  V4L2 M2M Interface
+ *
+ ******************************************************************************/
+int ff_v4l2_m2m_codec_reinit(V4L2m2mContext* s)
+{
+    int ret;
+
+    av_log(s->avctx, AV_LOG_DEBUG, "reinit context\n");
+
+    /* 1. streamoff */
+    ret = ff_v4l2_context_set_status(&s->capture, VIDIOC_STREAMOFF);
+    if (ret)
+        av_log(s->avctx, AV_LOG_ERROR, "capture VIDIOC_STREAMOFF\n");
+
+    /* 2. unmap the capture buffers (v4l2 and ffmpeg):
+     *    we must wait for all references to be released before being allowed
+     *    to queue new buffers.
+     */
+    av_log(s->avctx, AV_LOG_DEBUG, "waiting for user to release AVBufferRefs\n");
+    if (atomic_load(&s->refcount))
+        while(sem_wait(&s->refsync) == -1 && errno == EINTR);
+
+    ff_v4l2_context_release(&s->capture);
+
+    /* 3. get the new capture format */
+    ret = ff_v4l2_context_get_format(&s->capture);
+    if (ret) {
+        av_log(s->avctx, AV_LOG_ERROR, "query the new capture format\n");
+        return ret;
+    }
+
+    /* 4. set the capture format */
+    ret = ff_v4l2_context_set_format(&s->capture);
+    if (ret) {
+        av_log(s->avctx, AV_LOG_ERROR, "setting capture format\n");
+        return ret;
+    }
+
+    /* 5. complete reinit */
+    sem_destroy(&s->refsync);
+    sem_init(&s->refsync, 0, 0);
+    s->draining = 0;
+    s->reinit = 0;
+
+    return 0;
+}
+
+int ff_v4l2_m2m_codec_full_reinit(V4L2m2mContext *s)
+{
+    void *log_ctx = s->avctx;
+    int ret;
+
+    av_log(log_ctx, AV_LOG_DEBUG, "%s full reinit\n", s->devname);
+
+    /* wait for pending buffer references */
+    if (atomic_load(&s->refcount))
+        while(sem_wait(&s->refsync) == -1 && errno == EINTR);
+
+    /* close the driver */
+    ff_v4l2_m2m_codec_end(s->avctx);
+
+    /* start again now that we know the stream dimensions */
+    s->draining = 0;
+    s->reinit = 0;
+
+    s->fd = open(s->devname, O_RDWR | O_NONBLOCK, 0);
+    if (s->fd < 0)
+        return AVERROR(errno);
+
+    ret = v4l2_prepare_contexts(s);
+    if (ret < 0)
+        goto error;
+
+    /* if a full re-init was requested - probe didn't run - we need to populate
+     * the format for each context
+     */
+    ret = ff_v4l2_context_get_format(&s->output);
+    if (ret) {
+        av_log(log_ctx, AV_LOG_DEBUG, "v4l2 output format not supported\n");
+        goto error;
+    }
+
+    ret = ff_v4l2_context_get_format(&s->capture);
+    if (ret) {
+        av_log(log_ctx, AV_LOG_DEBUG, "v4l2 capture format not supported\n");
+        goto error;
+    }
+
+    ret = ff_v4l2_context_set_format(&s->output);
+    if (ret) {
+        av_log(log_ctx, AV_LOG_ERROR, "can't set v4l2 output format\n");
+        goto error;
+    }
+
+    ret = ff_v4l2_context_set_format(&s->capture);
+    if (ret) {
+        av_log(log_ctx, AV_LOG_ERROR, "can't to set v4l2 capture format\n");
+        goto error;
+    }
+
+    ret = ff_v4l2_context_init(&s->output);
+    if (ret) {
+        av_log(log_ctx, AV_LOG_ERROR, "no v4l2 output context's buffers\n");
+        goto error;
+    }
+
+    /* decoder's buffers need to be updated at a later stage */
+    if (!av_codec_is_decoder(s->avctx->codec)) {
+        ret = ff_v4l2_context_init(&s->capture);
+        if (ret) {
+            av_log(log_ctx, AV_LOG_ERROR, "no v4l2 capture context's buffers\n");
+            goto error;
+        }
+    }
+
+    return 0;
+
+error:
+    if (close(s->fd) < 0) {
+        ret = AVERROR(errno);
+        av_log(log_ctx, AV_LOG_ERROR, "error closing %s (%s)\n",
+            s->devname, av_err2str(AVERROR(errno)));
+    }
+    s->fd = -1;
+
+    return ret;
+}
+
+int ff_v4l2_m2m_codec_end(AVCodecContext *avctx)
+{
+    V4L2m2mContext* s = avctx->priv_data;
+    int ret;
+
+    ret = ff_v4l2_context_set_status(&s->output, VIDIOC_STREAMOFF);
+    if (ret)
+            av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMOFF %s\n", s->output.name);
+
+    ret = ff_v4l2_context_set_status(&s->capture, VIDIOC_STREAMOFF);
+    if (ret)
+        av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMOFF %s\n", s->capture.name);
+
+    ff_v4l2_context_release(&s->output);
+
+    if (atomic_load(&s->refcount))
+        av_log(avctx, AV_LOG_ERROR, "ff_v4l2m2m_codec_end leaving pending buffers\n");
+
+    ff_v4l2_context_release(&s->capture);
+    sem_destroy(&s->refsync);
+
+    /* release the hardware */
+    if (close(s->fd) < 0 )
+        av_log(avctx, AV_LOG_ERROR, "failure closing %s (%s)\n", s->devname, av_err2str(AVERROR(errno)));
+
+    s->fd = -1;
+
+    return 0;
+}
+
+int ff_v4l2_m2m_codec_init(AVCodecContext *avctx)
+{
+    int ret = AVERROR(EINVAL);
+    struct dirent *entry;
+    char node[PATH_MAX];
+    DIR *dirp;
+
+    V4L2m2mContext *s = avctx->priv_data;
+    s->avctx = avctx;
+
+    dirp = opendir("/dev");
+    if (!dirp)
+        return AVERROR(errno);
+
+    for (entry = readdir(dirp); entry; entry = readdir(dirp)) {
+
+        if (strncmp(entry->d_name, "video", 5))
+            continue;
+
+        snprintf(node, sizeof(node), "/dev/%s", entry->d_name);
+        av_log(s->avctx, AV_LOG_DEBUG, "probing device %s\n", node);
+        strncpy(s->devname, node, strlen(node) + 1);
+        ret = v4l2_probe_driver(s);
+        if (!ret)
+                break;
+    }
+
+    closedir(dirp);
+
+    if (ret) {
+        av_log(s->avctx, AV_LOG_ERROR, "Could not find a valid device\n");
+        memset(s->devname, 0, sizeof(s->devname));
+
+        return ret;
+    }
+
+    av_log(s->avctx, AV_LOG_INFO, "Using device %s\n", node);
+
+    return v4l2_configure_contexts(s);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/v4l2_m2m.h b/mythtv/external/FFmpeg/libavcodec/v4l2_m2m.h
new file mode 100644
index 00000000000..afa3987c466
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/v4l2_m2m.h
@@ -0,0 +1,105 @@
+/*
+ * V4L2 mem2mem helper functions
+ *
+ * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
+ * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
+ *
+ * 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_V4L2_M2M_H
+#define AVCODEC_V4L2_M2M_H
+
+#include <semaphore.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <linux/videodev2.h>
+
+#include "libavcodec/avcodec.h"
+#include "v4l2_context.h"
+
+#define container_of(ptr, type, member) ({ \
+        const __typeof__(((type *)0)->member ) *__mptr = (ptr); \
+        (type *)((char *)__mptr - offsetof(type,member) );})
+
+#define V4L_M2M_DEFAULT_OPTS \
+    { "num_output_buffers", "Number of buffers in the output context",\
+        OFFSET(output.num_buffers), AV_OPT_TYPE_INT, { .i64 = 16 }, 6, INT_MAX, FLAGS }
+
+typedef struct V4L2m2mContext
+{
+    AVClass *class;
+    char devname[PATH_MAX];
+    int fd;
+
+    /* the codec context queues */
+    V4L2Context capture;
+    V4L2Context output;
+
+    /* refcount of buffers held by the user */
+    atomic_uint refcount;
+
+    /* dynamic stream reconfig */
+    AVCodecContext *avctx;
+    sem_t refsync;
+    int reinit;
+
+    /* null frame/packet received */
+    int draining;
+} V4L2m2mContext;
+
+/**
+ * Probes the video nodes looking for the required codec capabilities.
+ *
+ * @param[in] ctx The AVCodecContext instantiated by the encoder/decoder.
+ *
+ * @returns 0 if a driver is found, a negative number otherwise.
+ */
+int ff_v4l2_m2m_codec_init(AVCodecContext *avctx);
+
+/**
+ * Releases all the codec resources if all AVBufferRefs have been returned to the
+ * ctx. Otherwise keep the driver open.
+ *
+ * @param[in] The AVCodecContext instantiated by the encoder/decoder.
+ *
+ * @returns 0
+ *
+ */
+int ff_v4l2_m2m_codec_end(AVCodecContext *avctx);
+
+/**
+ * Reinitializes the V4L2m2mContext when the driver cant continue processing
+ * with the capture parameters.
+ *
+ * @param[in] ctx The V4L2m2mContext instantiated by the encoder/decoder.
+ *
+ * @returns 0 in case of success, negative number otherwise
+ */
+int ff_v4l2_m2m_codec_reinit(V4L2m2mContext *ctx);
+
+/**
+ * Reinitializes the V4L2m2mContext when the driver cant continue processing
+ * with the  any of the current V4L2Contexts (ie, changes in output and capture).
+ *
+ * @param[in] ctx The V4L2m2mContext instantiated by the encoder/decoder.
+ *
+ * @returns 0 in case of success, negative number otherwise
+ */
+int ff_v4l2_m2m_codec_full_reinit(V4L2m2mContext *ctx);
+
+#endif /* AVCODEC_V4L2_M2M_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/v4l2_m2m_dec.c b/mythtv/external/FFmpeg/libavcodec/v4l2_m2m_dec.c
new file mode 100644
index 00000000000..958cdc522b9
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/v4l2_m2m_dec.c
@@ -0,0 +1,228 @@
+/*
+ * V4L2 mem2mem decoders
+ *
+ * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
+ * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
+ *
+ * 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 <linux/videodev2.h>
+#include <sys/ioctl.h>
+#include "libavutil/pixfmt.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/opt.h"
+#include "libavcodec/avcodec.h"
+#include "libavcodec/decode.h"
+
+#include "v4l2_context.h"
+#include "v4l2_m2m.h"
+#include "v4l2_fmt.h"
+
+static int v4l2_try_start(AVCodecContext *avctx)
+{
+    V4L2m2mContext *s = avctx->priv_data;
+    V4L2Context *const capture = &s->capture;
+    V4L2Context *const output = &s->output;
+    struct v4l2_selection selection;
+    int ret;
+
+    /* 1. start the output process */
+    if (!output->streamon) {
+        ret = ff_v4l2_context_set_status(output, VIDIOC_STREAMON);
+        if (ret < 0) {
+            av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON on output context\n");
+            return ret;
+        }
+    }
+
+    if (capture->streamon)
+        return 0;
+
+    /* 2. get the capture format */
+    capture->format.type = capture->type;
+    ret = ioctl(s->fd, VIDIOC_G_FMT, &capture->format);
+    if (ret) {
+        av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_FMT ioctl\n");
+        return ret;
+    }
+
+    /* 2.1 update the AVCodecContext */
+    avctx->pix_fmt = ff_v4l2_format_v4l2_to_avfmt(capture->format.fmt.pix_mp.pixelformat, AV_CODEC_ID_RAWVIDEO);
+    capture->av_pix_fmt = avctx->pix_fmt;
+
+    /* 3. set the crop parameters */
+    selection.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    selection.r.height = avctx->coded_height;
+    selection.r.width = avctx->coded_width;
+    ret = ioctl(s->fd, VIDIOC_S_SELECTION, &selection);
+    if (!ret) {
+        ret = ioctl(s->fd, VIDIOC_G_SELECTION, &selection);
+        if (ret) {
+            av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_SELECTION ioctl\n");
+        } else {
+            av_log(avctx, AV_LOG_DEBUG, "crop output %dx%d\n", selection.r.width, selection.r.height);
+            /* update the size of the resulting frame */
+            capture->height = selection.r.height;
+            capture->width  = selection.r.width;
+        }
+    }
+
+    /* 4. init the capture context now that we have the capture format */
+    if (!capture->buffers) {
+        ret = ff_v4l2_context_init(capture);
+        if (ret) {
+            av_log(avctx, AV_LOG_DEBUG, "can't request output buffers\n");
+            return ret;
+        }
+    }
+
+    /* 5. start the capture process */
+    ret = ff_v4l2_context_set_status(capture, VIDIOC_STREAMON);
+    if (ret) {
+        av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON, on capture context\n");
+        return ret;
+    }
+
+    return 0;
+}
+
+static int v4l2_prepare_decoder(V4L2m2mContext *s)
+{
+    struct v4l2_event_subscription sub;
+    V4L2Context *output = &s->output;
+    int ret;
+
+    /**
+     * requirements
+     */
+    memset(&sub, 0, sizeof(sub));
+    sub.type = V4L2_EVENT_SOURCE_CHANGE;
+    ret = ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
+    if ( ret < 0) {
+        if (output->height == 0 || output->width == 0) {
+            av_log(s->avctx, AV_LOG_ERROR,
+                "the v4l2 driver does not support VIDIOC_SUBSCRIBE_EVENT\n"
+                "you must provide codec_height and codec_width on input\n");
+            return ret;
+        }
+    }
+
+    return 0;
+}
+
+static int v4l2_receive_frame(AVCodecContext *avctx, AVFrame *frame)
+{
+    V4L2m2mContext *s = avctx->priv_data;
+    V4L2Context *const capture = &s->capture;
+    V4L2Context *const output = &s->output;
+    AVPacket avpkt = {0};
+    int ret;
+
+    ret = ff_decode_get_packet(avctx, &avpkt);
+    if (ret < 0 && ret != AVERROR_EOF)
+        return ret;
+
+    if (s->draining)
+        goto dequeue;
+
+    ret = ff_v4l2_context_enqueue_packet(output, &avpkt);
+    if (ret < 0) {
+        if (ret != AVERROR(ENOMEM))
+           return ret;
+        /* no input buffers available, continue dequeing */
+    }
+
+    if (avpkt.size) {
+        ret = v4l2_try_start(avctx);
+        if (ret)
+            return 0;
+    }
+
+dequeue:
+    return ff_v4l2_context_dequeue_frame(capture, frame);
+}
+
+static av_cold int v4l2_decode_init(AVCodecContext *avctx)
+{
+    V4L2m2mContext *s = avctx->priv_data;
+    V4L2Context *capture = &s->capture;
+    V4L2Context *output = &s->output;
+    int ret;
+
+    /* if these dimensions are invalid (ie, 0 or too small) an event will be raised
+     * by the v4l2 driver; this event will trigger a full pipeline reconfig and
+     * the proper values will be retrieved from the kernel driver.
+     */
+    output->height = capture->height = avctx->coded_height;
+    output->width = capture->width = avctx->coded_width;
+
+    output->av_codec_id = avctx->codec_id;
+    output->av_pix_fmt  = AV_PIX_FMT_NONE;
+
+    capture->av_codec_id = AV_CODEC_ID_RAWVIDEO;
+    capture->av_pix_fmt = avctx->pix_fmt;
+
+    ret = ff_v4l2_m2m_codec_init(avctx);
+    if (ret) {
+        av_log(avctx, AV_LOG_ERROR, "can't configure decoder\n");
+        return ret;
+    }
+
+    return v4l2_prepare_decoder(s);
+}
+
+#define OFFSET(x) offsetof(V4L2m2mContext, x)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
+
+static const AVOption options[] = {
+    V4L_M2M_DEFAULT_OPTS,
+    { "num_capture_buffers", "Number of buffers in the capture context",
+        OFFSET(capture.num_buffers), AV_OPT_TYPE_INT, {.i64 = 20}, 20, INT_MAX, FLAGS },
+    { NULL},
+};
+
+#define M2MDEC(NAME, LONGNAME, CODEC, bsf_name) \
+static const AVClass v4l2_m2m_ ## NAME ## _dec_class = {\
+    .class_name = #NAME "_v4l2_m2m_decoder",\
+    .item_name  = av_default_item_name,\
+    .option     = options,\
+    .version    = LIBAVUTIL_VERSION_INT,\
+};\
+\
+AVCodec ff_ ## NAME ## _v4l2m2m_decoder = { \
+    .name           = #NAME "_v4l2m2m" ,\
+    .long_name      = NULL_IF_CONFIG_SMALL("V4L2 mem2mem " LONGNAME " decoder wrapper"),\
+    .type           = AVMEDIA_TYPE_VIDEO,\
+    .id             = CODEC ,\
+    .priv_data_size = sizeof(V4L2m2mContext),\
+    .priv_class     = &v4l2_m2m_ ## NAME ## _dec_class,\
+    .init           = v4l2_decode_init,\
+    .receive_frame  = v4l2_receive_frame,\
+    .close          = ff_v4l2_m2m_codec_end,\
+    .bsfs           = bsf_name, \
+};
+
+M2MDEC(h264,  "H.264", AV_CODEC_ID_H264,       "h264_mp4toannexb");
+M2MDEC(hevc,  "HEVC",  AV_CODEC_ID_HEVC,       "hevc_mp4toannexb");
+M2MDEC(mpeg1, "MPEG1", AV_CODEC_ID_MPEG1VIDEO, NULL);
+M2MDEC(mpeg2, "MPEG2", AV_CODEC_ID_MPEG2VIDEO, NULL);
+M2MDEC(mpeg4, "MPEG4", AV_CODEC_ID_MPEG4,      NULL);
+M2MDEC(h263,  "H.263", AV_CODEC_ID_H263,       NULL);
+M2MDEC(vc1 ,  "VC1",   AV_CODEC_ID_VC1,        NULL);
+M2MDEC(vp8,   "VP8",   AV_CODEC_ID_VP8,        NULL);
+M2MDEC(vp9,   "VP9",   AV_CODEC_ID_VP9,        NULL);
diff --git a/mythtv/external/FFmpeg/libavcodec/v4l2_m2m_enc.c b/mythtv/external/FFmpeg/libavcodec/v4l2_m2m_enc.c
new file mode 100644
index 00000000000..f71ce5fb74a
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/v4l2_m2m_enc.c
@@ -0,0 +1,344 @@
+/*
+ * V4L2 mem2mem encoders
+ *
+ * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
+ * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
+ *
+ * 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 <linux/videodev2.h>
+#include <sys/ioctl.h>
+#include <search.h>
+#include "libavcodec/avcodec.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/pixfmt.h"
+#include "libavutil/opt.h"
+#include "v4l2_context.h"
+#include "v4l2_m2m.h"
+
+#define MPEG_CID(x) V4L2_CID_MPEG_VIDEO_##x
+#define MPEG_VIDEO(x) V4L2_MPEG_VIDEO_##x
+
+static inline void v4l2_set_timeperframe(V4L2m2mContext *s, unsigned int num, unsigned int den)
+{
+    struct v4l2_streamparm parm = { 0 };
+
+    parm.type = V4L2_TYPE_IS_MULTIPLANAR(s->output.type) ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE : V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    parm.parm.output.timeperframe.denominator = den;
+    parm.parm.output.timeperframe.numerator = num;
+
+    if (ioctl(s->fd, VIDIOC_S_PARM, &parm) < 0)
+        av_log(s->avctx, AV_LOG_WARNING, "Failed to set timeperframe");
+}
+
+static inline void v4l2_set_ext_ctrl(V4L2m2mContext *s, unsigned int id, signed int value, const char *name)
+{
+    struct v4l2_ext_controls ctrls = { 0 };
+    struct v4l2_ext_control ctrl = { 0 };
+
+    /* set ctrls */
+    ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG;
+    ctrls.controls = &ctrl;
+    ctrls.count = 1;
+
+    /* set ctrl*/
+    ctrl.value = value;
+    ctrl.id = id ;
+
+    if (ioctl(s->fd, VIDIOC_S_EXT_CTRLS, &ctrls) < 0)
+        av_log(s->avctx, AV_LOG_WARNING, "Failed to set %s\n", name);
+    else
+        av_log(s->avctx, AV_LOG_DEBUG, "Encoder: %s = %d\n", name, value);
+}
+
+static inline int v4l2_get_ext_ctrl(V4L2m2mContext *s, unsigned int id, signed int *value, const char *name)
+{
+    struct v4l2_ext_controls ctrls = { 0 };
+    struct v4l2_ext_control ctrl = { 0 };
+    int ret;
+
+    /* set ctrls */
+    ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG;
+    ctrls.controls = &ctrl;
+    ctrls.count = 1;
+
+    /* set ctrl*/
+    ctrl.id = id ;
+
+    ret = ioctl(s->fd, VIDIOC_G_EXT_CTRLS, &ctrls);
+    if (ret < 0) {
+        av_log(s->avctx, AV_LOG_WARNING, "Failed to set %s\n", name);
+        return ret;
+    }
+
+    *value = ctrl.value;
+
+    return 0;
+}
+
+static inline unsigned int v4l2_h264_profile_from_ff(int p)
+{
+    static const struct h264_profile  {
+        unsigned int ffmpeg_val;
+        unsigned int v4l2_val;
+    } profile[] = {
+        { FF_PROFILE_H264_CONSTRAINED_BASELINE, MPEG_VIDEO(H264_PROFILE_CONSTRAINED_BASELINE) },
+        { FF_PROFILE_H264_HIGH_444_PREDICTIVE, MPEG_VIDEO(H264_PROFILE_HIGH_444_PREDICTIVE) },
+        { FF_PROFILE_H264_HIGH_422_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_422_INTRA) },
+        { FF_PROFILE_H264_HIGH_444_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_444_INTRA) },
+        { FF_PROFILE_H264_HIGH_10_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_10_INTRA) },
+        { FF_PROFILE_H264_HIGH_422, MPEG_VIDEO(H264_PROFILE_HIGH_422) },
+        { FF_PROFILE_H264_BASELINE, MPEG_VIDEO(H264_PROFILE_BASELINE) },
+        { FF_PROFILE_H264_EXTENDED, MPEG_VIDEO(H264_PROFILE_EXTENDED) },
+        { FF_PROFILE_H264_HIGH_10, MPEG_VIDEO(H264_PROFILE_HIGH_10) },
+        { FF_PROFILE_H264_MAIN, MPEG_VIDEO(H264_PROFILE_MAIN) },
+        { FF_PROFILE_H264_HIGH, MPEG_VIDEO(H264_PROFILE_HIGH) },
+    };
+    int i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(profile); i++) {
+        if (profile[i].ffmpeg_val == p)
+            return profile[i].v4l2_val;
+    }
+    return AVERROR(ENOENT);
+}
+
+static inline int v4l2_mpeg4_profile_from_ff(int p)
+{
+    static const struct mpeg4_profile {
+        unsigned int ffmpeg_val;
+        unsigned int v4l2_val;
+    } profile[] = {
+        { FF_PROFILE_MPEG4_ADVANCED_CODING, MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY) },
+        { FF_PROFILE_MPEG4_ADVANCED_SIMPLE, MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_SIMPLE) },
+        { FF_PROFILE_MPEG4_SIMPLE_SCALABLE, MPEG_VIDEO(MPEG4_PROFILE_SIMPLE_SCALABLE) },
+        { FF_PROFILE_MPEG4_SIMPLE, MPEG_VIDEO(MPEG4_PROFILE_SIMPLE) },
+        { FF_PROFILE_MPEG4_CORE, MPEG_VIDEO(MPEG4_PROFILE_CORE) },
+    };
+    int i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(profile); i++) {
+        if (profile[i].ffmpeg_val == p)
+            return profile[i].v4l2_val;
+    }
+    return AVERROR(ENOENT);
+}
+
+static int v4l2_check_b_frame_support(V4L2m2mContext *s)
+{
+    if (s->avctx->max_b_frames)
+        av_log(s->avctx, AV_LOG_WARNING, "Encoder does not support b-frames yet\n");
+
+    v4l2_set_ext_ctrl(s, MPEG_CID(B_FRAMES), 0, "number of B-frames");
+    v4l2_get_ext_ctrl(s, MPEG_CID(B_FRAMES), &s->avctx->max_b_frames, "number of B-frames");
+    if (s->avctx->max_b_frames == 0)
+        return 0;
+
+    avpriv_report_missing_feature(s->avctx, "DTS/PTS calculation for V4L2 encoding");
+
+    return AVERROR_PATCHWELCOME;
+}
+
+static int v4l2_prepare_encoder(V4L2m2mContext *s)
+{
+    AVCodecContext *avctx = s->avctx;
+    int qmin_cid, qmax_cid, qmin, qmax;
+    int ret, val;
+
+    /**
+     * requirements
+     */
+    ret = v4l2_check_b_frame_support(s);
+    if (ret)
+        return ret;
+
+    /**
+     * settingss
+     */
+    if (avctx->framerate.num || avctx->framerate.den)
+        v4l2_set_timeperframe(s, avctx->framerate.num, avctx->framerate.den);
+
+    /* set ext ctrls */
+    v4l2_set_ext_ctrl(s, MPEG_CID(HEADER_MODE), MPEG_VIDEO(HEADER_MODE_SEPARATE), "header mode");
+    v4l2_set_ext_ctrl(s, MPEG_CID(BITRATE) , avctx->bit_rate, "bit rate");
+    v4l2_set_ext_ctrl(s, MPEG_CID(GOP_SIZE), avctx->gop_size,"gop size");
+
+    av_log(avctx, AV_LOG_DEBUG,
+        "Encoder Context: id (%d), profile (%d), frame rate(%d/%d), number b-frames (%d), "
+        "gop size (%d), bit rate (%"PRId64"), qmin (%d), qmax (%d)\n",
+        avctx->codec_id, avctx->profile, avctx->framerate.num, avctx->framerate.den,
+        avctx->max_b_frames, avctx->gop_size, avctx->bit_rate, avctx->qmin, avctx->qmax);
+
+    switch (avctx->codec_id) {
+    case AV_CODEC_ID_H264:
+        val = v4l2_h264_profile_from_ff(avctx->profile);
+        if (val < 0)
+            av_log(avctx, AV_LOG_WARNING, "h264 profile not found\n");
+        else
+            v4l2_set_ext_ctrl(s, MPEG_CID(H264_PROFILE), val, "h264 profile");
+        qmin_cid = MPEG_CID(H264_MIN_QP);
+        qmax_cid = MPEG_CID(H264_MAX_QP);
+        qmin = 0;
+        qmax = 51;
+        break;
+    case AV_CODEC_ID_MPEG4:
+        val = v4l2_mpeg4_profile_from_ff(avctx->profile);
+        if (val < 0)
+            av_log(avctx, AV_LOG_WARNING, "mpeg4 profile not found\n");
+        else
+            v4l2_set_ext_ctrl(s, MPEG_CID(MPEG4_PROFILE), val, "mpeg4 profile");
+        qmin_cid = MPEG_CID(MPEG4_MIN_QP);
+        qmax_cid = MPEG_CID(MPEG4_MAX_QP);
+        if (avctx->flags & CODEC_FLAG_QPEL)
+            v4l2_set_ext_ctrl(s, MPEG_CID(MPEG4_QPEL), 1, "qpel");
+        qmin = 1;
+        qmax = 31;
+        break;
+    case AV_CODEC_ID_H263:
+        qmin_cid = MPEG_CID(H263_MIN_QP);
+        qmax_cid = MPEG_CID(H263_MAX_QP);
+        qmin = 1;
+        qmax = 31;
+        break;
+    case AV_CODEC_ID_VP8:
+        qmin_cid = MPEG_CID(VPX_MIN_QP);
+        qmax_cid = MPEG_CID(VPX_MAX_QP);
+        qmin = 0;
+        qmax = 127;
+        break;
+    case AV_CODEC_ID_VP9:
+        qmin_cid = MPEG_CID(VPX_MIN_QP);
+        qmax_cid = MPEG_CID(VPX_MAX_QP);
+        qmin = 0;
+        qmax = 255;
+        break;
+    default:
+        return 0;
+    }
+
+    if (qmin != avctx->qmin || qmax != avctx->qmax)
+        av_log(avctx, AV_LOG_WARNING, "Encoder adjusted: qmin (%d), qmax (%d)\n", qmin, qmax);
+
+    v4l2_set_ext_ctrl(s, qmin_cid, qmin, "minimum video quantizer scale");
+    v4l2_set_ext_ctrl(s, qmax_cid, qmax, "maximum video quantizer scale");
+
+    return 0;
+}
+
+static int v4l2_send_frame(AVCodecContext *avctx, const AVFrame *frame)
+{
+    V4L2m2mContext *s = avctx->priv_data;
+    V4L2Context *const output = &s->output;
+
+    return ff_v4l2_context_enqueue_frame(output, frame);
+}
+
+static int v4l2_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
+{
+    V4L2m2mContext *s = avctx->priv_data;
+    V4L2Context *const capture = &s->capture;
+    V4L2Context *const output = &s->output;
+    int ret;
+
+    if (s->draining)
+        goto dequeue;
+
+    if (!output->streamon) {
+        ret = ff_v4l2_context_set_status(output, VIDIOC_STREAMON);
+        if (ret) {
+            av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMOFF failed on output context\n");
+            return ret;
+        }
+    }
+
+    if (!capture->streamon) {
+        ret = ff_v4l2_context_set_status(capture, VIDIOC_STREAMON);
+        if (ret) {
+            av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMON failed on capture context\n");
+            return ret;
+        }
+    }
+
+dequeue:
+    return ff_v4l2_context_dequeue_packet(capture, avpkt);
+}
+
+static av_cold int v4l2_encode_init(AVCodecContext *avctx)
+{
+    V4L2m2mContext *s = avctx->priv_data;
+    V4L2Context *capture = &s->capture;
+    V4L2Context *output = &s->output;
+    int ret;
+
+    /* common settings output/capture */
+    output->height = capture->height = avctx->height;
+    output->width = capture->width = avctx->width;
+
+    /* output context */
+    output->av_codec_id = AV_CODEC_ID_RAWVIDEO;
+    output->av_pix_fmt = avctx->pix_fmt;
+
+    /* capture context */
+    capture->av_codec_id = avctx->codec_id;
+    capture->av_pix_fmt = AV_PIX_FMT_NONE;
+
+    ret = ff_v4l2_m2m_codec_init(avctx);
+    if (ret) {
+        av_log(avctx, AV_LOG_ERROR, "can't configure encoder\n");
+        return ret;
+    }
+
+    return v4l2_prepare_encoder(s);
+}
+
+#define OFFSET(x) offsetof(V4L2m2mContext, x)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+
+static const AVOption options[] = {
+    V4L_M2M_DEFAULT_OPTS,
+    { "num_capture_buffers", "Number of buffers in the capture context",
+        OFFSET(capture.num_buffers), AV_OPT_TYPE_INT, {.i64 = 4 }, 4, INT_MAX, FLAGS },
+    { NULL },
+};
+
+#define M2MENC(NAME, LONGNAME, CODEC) \
+static const AVClass v4l2_m2m_ ## NAME ## _enc_class = {\
+    .class_name = #NAME "_v4l2_m2m_encoder",\
+    .item_name  = av_default_item_name,\
+    .option     = options,\
+    .version    = LIBAVUTIL_VERSION_INT,\
+};\
+\
+AVCodec ff_ ## NAME ## _v4l2m2m_encoder = { \
+    .name           = #NAME "_v4l2m2m" ,\
+    .long_name      = NULL_IF_CONFIG_SMALL("V4L2 mem2mem " LONGNAME " encoder wrapper"),\
+    .type           = AVMEDIA_TYPE_VIDEO,\
+    .id             = CODEC ,\
+    .priv_data_size = sizeof(V4L2m2mContext),\
+    .priv_class     = &v4l2_m2m_ ## NAME ##_enc_class,\
+    .init           = v4l2_encode_init,\
+    .send_frame     = v4l2_send_frame,\
+    .receive_packet = v4l2_receive_packet,\
+    .close          = ff_v4l2_m2m_codec_end,\
+};
+
+M2MENC(mpeg4,"MPEG4", AV_CODEC_ID_MPEG4);
+M2MENC(h263, "H.263", AV_CODEC_ID_H263);
+M2MENC(h264, "H.264", AV_CODEC_ID_H264);
+M2MENC(hevc, "HEVC",  AV_CODEC_ID_HEVC);
+M2MENC(vp8,  "VP8",   AV_CODEC_ID_VP8);
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi.c b/mythtv/external/FFmpeg/libavcodec/vaapi.c
deleted file mode 100644
index 36db640f027..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/vaapi.c
+++ /dev/null
@@ -1,251 +0,0 @@
-/*
- * Video Acceleration API (video decoding)
- * HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1
- *
- * Copyright (C) 2008-2009 Splitted-Desktop Systems
- *
- * 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/log.h"
-#include "mpegvideo.h"
-#include "vaapi_internal.h"
-
-/**
- * @addtogroup VAAPI_Decoding
- *
- * @{
- */
-
-static void destroy_buffers(VADisplay display, VABufferID *buffers, unsigned int n_buffers)
-{
-    unsigned int i;
-    for (i = 0; i < n_buffers; i++) {
-        if (buffers[i] != VA_INVALID_ID) {
-            vaDestroyBuffer(display, buffers[i]);
-            buffers[i] = VA_INVALID_ID;
-        }
-    }
-}
-
-int ff_vaapi_context_init(AVCodecContext *avctx)
-{
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    const struct vaapi_context * const user_vactx = avctx->hwaccel_context;
-
-    if (!user_vactx) {
-        av_log(avctx, AV_LOG_ERROR, "Hardware acceleration context (hwaccel_context) does not exist.\n");
-        return AVERROR(ENOSYS);
-    }
-
-    vactx->display              = user_vactx->display;
-    vactx->config_id            = user_vactx->config_id;
-    vactx->context_id           = user_vactx->context_id;
-
-    vactx->pic_param_buf_id     = VA_INVALID_ID;
-    vactx->iq_matrix_buf_id     = VA_INVALID_ID;
-    vactx->bitplane_buf_id      = VA_INVALID_ID;
-
-    return 0;
-}
-
-int ff_vaapi_context_fini(AVCodecContext *avctx)
-{
-    return 0;
-}
-
-int ff_vaapi_render_picture(FFVAContext *vactx, VASurfaceID surface)
-{
-    VABufferID va_buffers[3];
-    unsigned int n_va_buffers = 0;
-
-    if (vactx->pic_param_buf_id == VA_INVALID_ID)
-        return 0;
-
-    vaUnmapBuffer(vactx->display, vactx->pic_param_buf_id);
-    va_buffers[n_va_buffers++] = vactx->pic_param_buf_id;
-
-    if (vactx->iq_matrix_buf_id != VA_INVALID_ID) {
-        vaUnmapBuffer(vactx->display, vactx->iq_matrix_buf_id);
-        va_buffers[n_va_buffers++] = vactx->iq_matrix_buf_id;
-    }
-
-    if (vactx->bitplane_buf_id != VA_INVALID_ID) {
-        vaUnmapBuffer(vactx->display, vactx->bitplane_buf_id);
-        va_buffers[n_va_buffers++] = vactx->bitplane_buf_id;
-    }
-
-    if (vaBeginPicture(vactx->display, vactx->context_id,
-                       surface) != VA_STATUS_SUCCESS)
-        return -1;
-
-    if (vaRenderPicture(vactx->display, vactx->context_id,
-                        va_buffers, n_va_buffers) != VA_STATUS_SUCCESS)
-        return -1;
-
-    if (vaRenderPicture(vactx->display, vactx->context_id,
-                        vactx->slice_buf_ids,
-                        vactx->n_slice_buf_ids) != VA_STATUS_SUCCESS)
-        return -1;
-
-    if (vaEndPicture(vactx->display, vactx->context_id) != VA_STATUS_SUCCESS)
-        return -1;
-
-    return 0;
-}
-
-int ff_vaapi_commit_slices(FFVAContext *vactx)
-{
-    VABufferID *slice_buf_ids;
-    VABufferID slice_param_buf_id, slice_data_buf_id;
-
-    if (vactx->slice_count == 0)
-        return 0;
-
-    slice_buf_ids =
-        av_fast_realloc(vactx->slice_buf_ids,
-                        &vactx->slice_buf_ids_alloc,
-                        (vactx->n_slice_buf_ids + 2) * sizeof(slice_buf_ids[0]));
-    if (!slice_buf_ids)
-        return -1;
-    vactx->slice_buf_ids = slice_buf_ids;
-
-    slice_param_buf_id = VA_INVALID_ID;
-    if (vaCreateBuffer(vactx->display, vactx->context_id,
-                       VASliceParameterBufferType,
-                       vactx->slice_param_size,
-                       vactx->slice_count, vactx->slice_params,
-                       &slice_param_buf_id) != VA_STATUS_SUCCESS)
-        return -1;
-    vactx->slice_count = 0;
-
-    slice_data_buf_id = VA_INVALID_ID;
-    if (vaCreateBuffer(vactx->display, vactx->context_id,
-                       VASliceDataBufferType,
-                       vactx->slice_data_size,
-                       1, (void *)vactx->slice_data,
-                       &slice_data_buf_id) != VA_STATUS_SUCCESS)
-        return -1;
-    vactx->slice_data = NULL;
-    vactx->slice_data_size = 0;
-
-    slice_buf_ids[vactx->n_slice_buf_ids++] = slice_param_buf_id;
-    slice_buf_ids[vactx->n_slice_buf_ids++] = slice_data_buf_id;
-    return 0;
-}
-
-static void *alloc_buffer(FFVAContext *vactx, int type, unsigned int size, uint32_t *buf_id)
-{
-    void *data = NULL;
-
-    *buf_id = VA_INVALID_ID;
-    if (vaCreateBuffer(vactx->display, vactx->context_id,
-                       type, size, 1, NULL, buf_id) == VA_STATUS_SUCCESS)
-        vaMapBuffer(vactx->display, *buf_id, &data);
-
-    return data;
-}
-
-void *ff_vaapi_alloc_pic_param(FFVAContext *vactx, unsigned int size)
-{
-    return alloc_buffer(vactx, VAPictureParameterBufferType, size, &vactx->pic_param_buf_id);
-}
-
-void *ff_vaapi_alloc_iq_matrix(FFVAContext *vactx, unsigned int size)
-{
-    return alloc_buffer(vactx, VAIQMatrixBufferType, size, &vactx->iq_matrix_buf_id);
-}
-
-uint8_t *ff_vaapi_alloc_bitplane(FFVAContext *vactx, uint32_t size)
-{
-    return alloc_buffer(vactx, VABitPlaneBufferType, size, &vactx->bitplane_buf_id);
-}
-
-VASliceParameterBufferBase *ff_vaapi_alloc_slice(FFVAContext *vactx, const uint8_t *buffer, uint32_t size)
-{
-    uint8_t *slice_params;
-    VASliceParameterBufferBase *slice_param;
-
-    if (!vactx->slice_data)
-        vactx->slice_data = buffer;
-    if (vactx->slice_data + vactx->slice_data_size != buffer) {
-        if (ff_vaapi_commit_slices(vactx) < 0)
-            return NULL;
-        vactx->slice_data = buffer;
-    }
-
-    slice_params =
-        av_fast_realloc(vactx->slice_params,
-                        &vactx->slice_params_alloc,
-                        (vactx->slice_count + 1) * vactx->slice_param_size);
-    if (!slice_params)
-        return NULL;
-    vactx->slice_params = slice_params;
-
-    slice_param = (VASliceParameterBufferBase *)(slice_params + vactx->slice_count * vactx->slice_param_size);
-    slice_param->slice_data_size   = size;
-    slice_param->slice_data_offset = vactx->slice_data_size;
-    slice_param->slice_data_flag   = VA_SLICE_DATA_FLAG_ALL;
-
-    vactx->slice_count++;
-    vactx->slice_data_size += size;
-    return slice_param;
-}
-
-void ff_vaapi_common_end_frame(AVCodecContext *avctx)
-{
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-
-    destroy_buffers(vactx->display, &vactx->pic_param_buf_id, 1);
-    destroy_buffers(vactx->display, &vactx->iq_matrix_buf_id, 1);
-    destroy_buffers(vactx->display, &vactx->bitplane_buf_id, 1);
-    destroy_buffers(vactx->display, vactx->slice_buf_ids, vactx->n_slice_buf_ids);
-    av_freep(&vactx->slice_buf_ids);
-    av_freep(&vactx->slice_params);
-    vactx->n_slice_buf_ids     = 0;
-    vactx->slice_buf_ids_alloc = 0;
-    vactx->slice_count         = 0;
-    vactx->slice_params_alloc  = 0;
-}
-
-#if CONFIG_H263_VAAPI_HWACCEL  || CONFIG_MPEG1_VAAPI_HWACCEL || \
-    CONFIG_MPEG2_VAAPI_HWACCEL || CONFIG_MPEG4_VAAPI_HWACCEL || \
-    CONFIG_VC1_VAAPI_HWACCEL   || CONFIG_WMV3_VAAPI_HWACCEL
-int ff_vaapi_mpeg_end_frame(AVCodecContext *avctx)
-{
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    MpegEncContext *s = avctx->priv_data;
-    int ret;
-
-    ret = ff_vaapi_commit_slices(vactx);
-    if (ret < 0)
-        goto finish;
-
-    ret = ff_vaapi_render_picture(vactx,
-                                  ff_vaapi_get_surface_id(s->current_picture_ptr->f));
-    if (ret < 0)
-        goto finish;
-
-    ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
-
-finish:
-    ff_vaapi_common_end_frame(avctx);
-    return ret;
-}
-#endif
-
-/* @} */
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi.h b/mythtv/external/FFmpeg/libavcodec/vaapi.h
index 7a29f6f8811..bb284553293 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi.h
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi.h
@@ -34,6 +34,8 @@
 #include "libavutil/attributes.h"
 #include "version.h"
 
+#if FF_API_STRUCT_VAAPI_CONTEXT
+
 /**
  * @defgroup lavc_codec_hwaccel_vaapi VA API Decoding
  * @ingroup lavc_codec_hwaccel
@@ -48,8 +50,10 @@
  * during initialization or through each AVCodecContext.get_buffer()
  * function call. In any case, they must be valid prior to calling
  * decoding functions.
+ *
+ * Deprecated: use AVCodecContext.hw_frames_ctx instead.
  */
-struct vaapi_context {
+struct attribute_deprecated vaapi_context {
     /**
      * Window system dependent data
      *
@@ -186,4 +190,6 @@ struct vaapi_context {
 
 /* @} */
 
+#endif /* FF_API_STRUCT_VAAPI_CONTEXT */
+
 #endif /* AVCODEC_VAAPI_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_decode.c b/mythtv/external/FFmpeg/libavcodec/vaapi_decode.c
new file mode 100644
index 00000000000..27ef33837c1
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_decode.c
@@ -0,0 +1,637 @@
+/*
+ * 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/avassert.h"
+#include "libavutil/common.h"
+#include "libavutil/pixdesc.h"
+
+#include "avcodec.h"
+#include "internal.h"
+#include "vaapi_decode.h"
+
+
+int ff_vaapi_decode_make_param_buffer(AVCodecContext *avctx,
+                                      VAAPIDecodePicture *pic,
+                                      int type,
+                                      const void *data,
+                                      size_t size)
+{
+    VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data;
+    VAStatus vas;
+    VABufferID buffer;
+
+    av_assert0(pic->nb_param_buffers + 1 <= MAX_PARAM_BUFFERS);
+
+    vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
+                         type, size, 1, (void*)data, &buffer);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create parameter "
+               "buffer (type %d): %d (%s).\n",
+               type, vas, vaErrorStr(vas));
+        return AVERROR(EIO);
+    }
+
+    pic->param_buffers[pic->nb_param_buffers++] = buffer;
+
+    av_log(avctx, AV_LOG_DEBUG, "Param buffer (type %d, %zu bytes) "
+           "is %#x.\n", type, size, buffer);
+    return 0;
+}
+
+
+int ff_vaapi_decode_make_slice_buffer(AVCodecContext *avctx,
+                                      VAAPIDecodePicture *pic,
+                                      const void *params_data,
+                                      size_t params_size,
+                                      const void *slice_data,
+                                      size_t slice_size)
+{
+    VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data;
+    VAStatus vas;
+    int index;
+
+    av_assert0(pic->nb_slices <= pic->slices_allocated);
+    if (pic->nb_slices == pic->slices_allocated) {
+        if (pic->slices_allocated > 0)
+            pic->slices_allocated *= 2;
+        else
+            pic->slices_allocated = 64;
+
+        pic->slice_buffers =
+            av_realloc_array(pic->slice_buffers,
+                             pic->slices_allocated,
+                             2 * sizeof(*pic->slice_buffers));
+        if (!pic->slice_buffers)
+            return AVERROR(ENOMEM);
+    }
+    av_assert0(pic->nb_slices + 1 <= pic->slices_allocated);
+
+    index = 2 * pic->nb_slices;
+
+    vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
+                         VASliceParameterBufferType,
+                         params_size, 1, (void*)params_data,
+                         &pic->slice_buffers[index]);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create slice "
+               "parameter buffer: %d (%s).\n", vas, vaErrorStr(vas));
+        return AVERROR(EIO);
+    }
+
+    av_log(avctx, AV_LOG_DEBUG, "Slice %d param buffer (%zu bytes) "
+           "is %#x.\n", pic->nb_slices, params_size,
+           pic->slice_buffers[index]);
+
+    vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
+                         VASliceDataBufferType,
+                         slice_size, 1, (void*)slice_data,
+                         &pic->slice_buffers[index + 1]);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create slice "
+               "data buffer (size %zu): %d (%s).\n",
+               slice_size, vas, vaErrorStr(vas));
+        vaDestroyBuffer(ctx->hwctx->display,
+                        pic->slice_buffers[index]);
+        return AVERROR(EIO);
+    }
+
+    av_log(avctx, AV_LOG_DEBUG, "Slice %d data buffer (%zu bytes) "
+           "is %#x.\n", pic->nb_slices, slice_size,
+           pic->slice_buffers[index + 1]);
+
+    ++pic->nb_slices;
+    return 0;
+}
+
+static void ff_vaapi_decode_destroy_buffers(AVCodecContext *avctx,
+                                            VAAPIDecodePicture *pic)
+{
+    VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data;
+    VAStatus vas;
+    int i;
+
+    for (i = 0; i < pic->nb_param_buffers; i++) {
+        vas = vaDestroyBuffer(ctx->hwctx->display,
+                              pic->param_buffers[i]);
+        if (vas != VA_STATUS_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to destroy "
+                   "parameter buffer %#x: %d (%s).\n",
+                   pic->param_buffers[i], vas, vaErrorStr(vas));
+        }
+    }
+
+    for (i = 0; i < 2 * pic->nb_slices; i++) {
+        vas = vaDestroyBuffer(ctx->hwctx->display,
+                              pic->slice_buffers[i]);
+        if (vas != VA_STATUS_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to destroy slice "
+                   "slice buffer %#x: %d (%s).\n",
+                   pic->slice_buffers[i], vas, vaErrorStr(vas));
+        }
+    }
+}
+
+int ff_vaapi_decode_issue(AVCodecContext *avctx,
+                          VAAPIDecodePicture *pic)
+{
+    VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data;
+    VAStatus vas;
+    int err;
+
+    av_log(avctx, AV_LOG_DEBUG, "Decode to surface %#x.\n",
+           pic->output_surface);
+
+    vas = vaBeginPicture(ctx->hwctx->display, ctx->va_context,
+                         pic->output_surface);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to begin picture decode "
+               "issue: %d (%s).\n", vas, vaErrorStr(vas));
+        err = AVERROR(EIO);
+        goto fail_with_picture;
+    }
+
+    vas = vaRenderPicture(ctx->hwctx->display, ctx->va_context,
+                          pic->param_buffers, pic->nb_param_buffers);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to upload decode "
+               "parameters: %d (%s).\n", vas, vaErrorStr(vas));
+        err = AVERROR(EIO);
+        goto fail_with_picture;
+    }
+
+    vas = vaRenderPicture(ctx->hwctx->display, ctx->va_context,
+                          pic->slice_buffers, 2 * pic->nb_slices);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to upload slices: "
+               "%d (%s).\n", vas, vaErrorStr(vas));
+        err = AVERROR(EIO);
+        goto fail_with_picture;
+    }
+
+    vas = vaEndPicture(ctx->hwctx->display, ctx->va_context);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to end picture decode "
+               "issue: %d (%s).\n", vas, vaErrorStr(vas));
+        err = AVERROR(EIO);
+        if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &
+            AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS)
+            goto fail;
+        else
+            goto fail_at_end;
+    }
+
+    if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &
+        AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS)
+        ff_vaapi_decode_destroy_buffers(avctx, pic);
+
+    pic->nb_param_buffers = 0;
+    pic->nb_slices        = 0;
+    pic->slices_allocated = 0;
+    av_freep(&pic->slice_buffers);
+
+    return 0;
+
+fail_with_picture:
+    vas = vaEndPicture(ctx->hwctx->display, ctx->va_context);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to end picture decode "
+               "after error: %d (%s).\n", vas, vaErrorStr(vas));
+    }
+fail:
+    ff_vaapi_decode_destroy_buffers(avctx, pic);
+fail_at_end:
+    return err;
+}
+
+int ff_vaapi_decode_cancel(AVCodecContext *avctx,
+                           VAAPIDecodePicture *pic)
+{
+    ff_vaapi_decode_destroy_buffers(avctx, pic);
+
+    pic->nb_param_buffers = 0;
+    pic->nb_slices        = 0;
+    pic->slices_allocated = 0;
+    av_freep(&pic->slice_buffers);
+
+    return 0;
+}
+
+static const struct {
+    enum AVCodecID codec_id;
+    int codec_profile;
+    VAProfile va_profile;
+} vaapi_profile_map[] = {
+#define MAP(c, p, v) { AV_CODEC_ID_ ## c, FF_PROFILE_ ## p, VAProfile ## v }
+    MAP(MPEG2VIDEO,  MPEG2_SIMPLE,    MPEG2Simple ),
+    MAP(MPEG2VIDEO,  MPEG2_MAIN,      MPEG2Main   ),
+    MAP(H263,        UNKNOWN,         H263Baseline),
+    MAP(MPEG4,       MPEG4_SIMPLE,    MPEG4Simple ),
+    MAP(MPEG4,       MPEG4_ADVANCED_SIMPLE,
+                               MPEG4AdvancedSimple),
+    MAP(MPEG4,       MPEG4_MAIN,      MPEG4Main   ),
+    MAP(H264,        H264_CONSTRAINED_BASELINE,
+                           H264ConstrainedBaseline),
+    MAP(H264,        H264_MAIN,       H264Main    ),
+    MAP(H264,        H264_HIGH,       H264High    ),
+#if VA_CHECK_VERSION(0, 37, 0)
+    MAP(HEVC,        HEVC_MAIN,       HEVCMain    ),
+    MAP(HEVC,        HEVC_MAIN_10,    HEVCMain10  ),
+#endif
+    MAP(WMV3,        VC1_SIMPLE,      VC1Simple   ),
+    MAP(WMV3,        VC1_MAIN,        VC1Main     ),
+    MAP(WMV3,        VC1_COMPLEX,     VC1Advanced ),
+    MAP(WMV3,        VC1_ADVANCED,    VC1Advanced ),
+    MAP(VC1,         VC1_SIMPLE,      VC1Simple   ),
+    MAP(VC1,         VC1_MAIN,        VC1Main     ),
+    MAP(VC1,         VC1_COMPLEX,     VC1Advanced ),
+    MAP(VC1,         VC1_ADVANCED,    VC1Advanced ),
+#if VA_CHECK_VERSION(0, 35, 0)
+    MAP(VP8,         UNKNOWN,       VP8Version0_3 ),
+#endif
+#if VA_CHECK_VERSION(0, 38, 0)
+    MAP(VP9,         VP9_0,           VP9Profile0 ),
+#endif
+#if VA_CHECK_VERSION(0, 39, 0)
+    MAP(VP9,         VP9_2,           VP9Profile2 ),
+#endif
+#undef MAP
+};
+
+static int vaapi_decode_make_config(AVCodecContext *avctx)
+{
+    VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data;
+
+    AVVAAPIHWConfig       *hwconfig    = NULL;
+    AVHWFramesConstraints *constraints = NULL;
+    VAStatus vas;
+    int err, i, j;
+    const AVCodecDescriptor *codec_desc;
+    VAProfile profile, va_profile, *profile_list = NULL;
+    int profile_count, exact_match, alt_profile;
+    const AVPixFmtDescriptor *sw_desc, *desc;
+
+    codec_desc = avcodec_descriptor_get(avctx->codec_id);
+    if (!codec_desc) {
+        err = AVERROR(EINVAL);
+        goto fail;
+    }
+
+    profile_count = vaMaxNumProfiles(ctx->hwctx->display);
+    profile_list  = av_malloc_array(profile_count,
+                                    sizeof(VAProfile));
+    if (!profile_list) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    vas = vaQueryConfigProfiles(ctx->hwctx->display,
+                                profile_list, &profile_count);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to query profiles: "
+               "%d (%s).\n", vas, vaErrorStr(vas));
+        err = AVERROR(ENOSYS);
+        goto fail;
+    }
+
+    profile = VAProfileNone;
+    exact_match = 0;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(vaapi_profile_map); i++) {
+        int profile_match = 0;
+        if (avctx->codec_id != vaapi_profile_map[i].codec_id)
+            continue;
+        if (avctx->profile == vaapi_profile_map[i].codec_profile)
+            profile_match = 1;
+        profile = vaapi_profile_map[i].va_profile;
+        for (j = 0; j < profile_count; j++) {
+            if (profile == profile_list[j]) {
+                exact_match = profile_match;
+                break;
+            }
+        }
+        if (j < profile_count) {
+            if (exact_match)
+                break;
+            alt_profile = vaapi_profile_map[i].codec_profile;
+            va_profile = vaapi_profile_map[i].va_profile;
+        }
+    }
+    av_freep(&profile_list);
+
+    if (profile == VAProfileNone) {
+        av_log(avctx, AV_LOG_ERROR, "No support for codec %s "
+               "profile %d.\n", codec_desc->name, avctx->profile);
+        err = AVERROR(ENOSYS);
+        goto fail;
+    }
+    if (!exact_match) {
+        if (avctx->hwaccel_flags &
+            AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH) {
+            av_log(avctx, AV_LOG_VERBOSE, "Codec %s profile %d not "
+                   "supported for hardware decode.\n",
+                   codec_desc->name, avctx->profile);
+            av_log(avctx, AV_LOG_WARNING, "Using possibly-"
+                   "incompatible profile %d instead.\n",
+                   alt_profile);
+            profile = va_profile;
+        } else {
+            av_log(avctx, AV_LOG_VERBOSE, "Codec %s profile %d not "
+                   "supported for hardware decode.\n",
+                   codec_desc->name, avctx->profile);
+            err = AVERROR(EINVAL);
+            goto fail;
+        }
+    }
+
+    ctx->va_profile    = profile;
+    ctx->va_entrypoint = VAEntrypointVLD;
+
+    vas = vaCreateConfig(ctx->hwctx->display, ctx->va_profile,
+                         ctx->va_entrypoint, NULL, 0,
+                         &ctx->va_config);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create decode "
+               "configuration: %d (%s).\n", vas, vaErrorStr(vas));
+        err = AVERROR(EIO);
+        goto fail;
+    }
+
+    hwconfig = av_hwdevice_hwconfig_alloc(avctx->hw_device_ctx ?
+                                          avctx->hw_device_ctx :
+                                          ctx->frames->device_ref);
+    if (!hwconfig) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+    hwconfig->config_id = ctx->va_config;
+
+    constraints =
+        av_hwdevice_get_hwframe_constraints(avctx->hw_device_ctx ?
+                                            avctx->hw_device_ctx :
+                                            ctx->frames->device_ref,
+                                            hwconfig);
+    if (!constraints) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    if (avctx->coded_width  < constraints->min_width  ||
+        avctx->coded_height < constraints->min_height ||
+        avctx->coded_width  > constraints->max_width  ||
+        avctx->coded_height > constraints->max_height) {
+        av_log(avctx, AV_LOG_ERROR, "Hardware does not support image "
+               "size %dx%d (constraints: width %d-%d height %d-%d).\n",
+               avctx->coded_width, avctx->coded_height,
+               constraints->min_width,  constraints->max_width,
+               constraints->min_height, constraints->max_height);
+        err = AVERROR(EINVAL);
+        goto fail;
+    }
+    if (!constraints->valid_sw_formats ||
+        constraints->valid_sw_formats[0] == AV_PIX_FMT_NONE) {
+        av_log(avctx, AV_LOG_ERROR, "Hardware does not offer any "
+               "usable surface formats.\n");
+        err = AVERROR(EINVAL);
+        goto fail;
+    }
+
+    // Find the first format in the list which matches the expected
+    // bit depth and subsampling.  If none are found (this can happen
+    // when 10-bit streams are decoded to 8-bit surfaces, for example)
+    // then just take the first format on the list.
+    ctx->surface_format = constraints->valid_sw_formats[0];
+    sw_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
+    for (i = 0; constraints->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {
+        desc = av_pix_fmt_desc_get(constraints->valid_sw_formats[i]);
+        if (desc->nb_components != sw_desc->nb_components ||
+            desc->log2_chroma_w != sw_desc->log2_chroma_w ||
+            desc->log2_chroma_h != sw_desc->log2_chroma_h)
+            continue;
+        for (j = 0; j < desc->nb_components; j++) {
+            if (desc->comp[j].depth != sw_desc->comp[j].depth)
+                break;
+        }
+        if (j < desc->nb_components)
+            continue;
+        ctx->surface_format = constraints->valid_sw_formats[i];
+        break;
+    }
+
+    // Start with at least four surfaces.
+    ctx->surface_count = 4;
+    // Add per-codec number of surfaces used for storing reference frames.
+    switch (avctx->codec_id) {
+    case AV_CODEC_ID_H264:
+    case AV_CODEC_ID_HEVC:
+        ctx->surface_count += 16;
+        break;
+    case AV_CODEC_ID_VP9:
+        ctx->surface_count += 8;
+        break;
+    case AV_CODEC_ID_VP8:
+        ctx->surface_count += 3;
+        break;
+    default:
+        ctx->surface_count += 2;
+    }
+    // Add an additional surface per thread is frame threading is enabled.
+    if (avctx->active_thread_type & FF_THREAD_FRAME)
+        ctx->surface_count += avctx->thread_count;
+
+    av_hwframe_constraints_free(&constraints);
+    av_freep(&hwconfig);
+
+    return 0;
+
+fail:
+    av_hwframe_constraints_free(&constraints);
+    av_freep(&hwconfig);
+    if (ctx->va_config != VA_INVALID_ID) {
+        vaDestroyConfig(ctx->hwctx->display, ctx->va_config);
+        ctx->va_config = VA_INVALID_ID;
+    }
+    av_freep(&profile_list);
+    return err;
+}
+
+int ff_vaapi_decode_init(AVCodecContext *avctx)
+{
+    VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data;
+    VAStatus vas;
+    int err;
+
+    ctx->va_config  = VA_INVALID_ID;
+    ctx->va_context = VA_INVALID_ID;
+
+#if FF_API_STRUCT_VAAPI_CONTEXT
+    if (avctx->hwaccel_context) {
+        av_log(avctx, AV_LOG_WARNING, "Using deprecated struct "
+               "vaapi_context in decode.\n");
+
+        ctx->have_old_context = 1;
+        ctx->old_context = avctx->hwaccel_context;
+
+        // Really we only want the VAAPI device context, but this
+        // allocates a whole generic device context because we don't
+        // have any other way to determine how big it should be.
+        ctx->device_ref =
+            av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_VAAPI);
+        if (!ctx->device_ref) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+        ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
+        ctx->hwctx  = ctx->device->hwctx;
+
+        ctx->hwctx->display = ctx->old_context->display;
+
+        // The old VAAPI decode setup assumed this quirk was always
+        // present, so set it here to avoid the behaviour changing.
+        ctx->hwctx->driver_quirks =
+            AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS;
+
+    } else
+#endif
+    if (avctx->hw_frames_ctx) {
+        // This structure has a shorter lifetime than the enclosing
+        // AVCodecContext, so we inherit the references from there
+        // and do not need to make separate ones.
+
+        ctx->frames = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+        ctx->hwfc   = ctx->frames->hwctx;
+        ctx->device = ctx->frames->device_ctx;
+        ctx->hwctx  = ctx->device->hwctx;
+
+    } else if (avctx->hw_device_ctx) {
+        ctx->device = (AVHWDeviceContext*)avctx->hw_device_ctx->data;
+        ctx->hwctx  = ctx->device->hwctx;
+
+        if (ctx->device->type != AV_HWDEVICE_TYPE_VAAPI) {
+            av_log(avctx, AV_LOG_ERROR, "Device supplied for VAAPI "
+                   "decoding must be a VAAPI device (not %d).\n",
+                   ctx->device->type);
+            err = AVERROR(EINVAL);
+            goto fail;
+        }
+
+    } else {
+        av_log(avctx, AV_LOG_ERROR, "A hardware device or frames context "
+               "is required for VAAPI decoding.\n");
+        err = AVERROR(EINVAL);
+        goto fail;
+    }
+
+#if FF_API_STRUCT_VAAPI_CONTEXT
+    if (ctx->have_old_context) {
+        ctx->va_config  = ctx->old_context->config_id;
+        ctx->va_context = ctx->old_context->context_id;
+
+        av_log(avctx, AV_LOG_DEBUG, "Using user-supplied decoder "
+               "context: %#x/%#x.\n", ctx->va_config, ctx->va_context);
+    } else {
+#endif
+
+    err = vaapi_decode_make_config(avctx);
+    if (err)
+        goto fail;
+
+    if (!avctx->hw_frames_ctx) {
+        avctx->hw_frames_ctx = av_hwframe_ctx_alloc(avctx->hw_device_ctx);
+        if (!avctx->hw_frames_ctx) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+        ctx->frames = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+
+        ctx->frames->format = AV_PIX_FMT_VAAPI;
+        ctx->frames->width  = avctx->coded_width;
+        ctx->frames->height = avctx->coded_height;
+
+        ctx->frames->sw_format         = ctx->surface_format;
+        ctx->frames->initial_pool_size = ctx->surface_count;
+
+        err = av_hwframe_ctx_init(avctx->hw_frames_ctx);
+        if (err < 0) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to initialise internal "
+                   "frames context: %d.\n", err);
+            goto fail;
+        }
+
+        ctx->hwfc = ctx->frames->hwctx;
+    }
+
+    vas = vaCreateContext(ctx->hwctx->display, ctx->va_config,
+                          avctx->coded_width, avctx->coded_height,
+                          VA_PROGRESSIVE,
+                          ctx->hwfc->surface_ids,
+                          ctx->hwfc->nb_surfaces,
+                          &ctx->va_context);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create decode "
+               "context: %d (%s).\n", vas, vaErrorStr(vas));
+        err = AVERROR(EIO);
+        goto fail;
+    }
+
+    av_log(avctx, AV_LOG_DEBUG, "Decode context initialised: "
+           "%#x/%#x.\n", ctx->va_config, ctx->va_context);
+#if FF_API_STRUCT_VAAPI_CONTEXT
+    }
+#endif
+
+    return 0;
+
+fail:
+    ff_vaapi_decode_uninit(avctx);
+    return err;
+}
+
+int ff_vaapi_decode_uninit(AVCodecContext *avctx)
+{
+    VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data;
+    VAStatus vas;
+
+#if FF_API_STRUCT_VAAPI_CONTEXT
+    if (ctx->have_old_context) {
+        av_buffer_unref(&ctx->device_ref);
+    } else {
+#endif
+
+    if (ctx->va_context != VA_INVALID_ID) {
+        vas = vaDestroyContext(ctx->hwctx->display, ctx->va_context);
+        if (vas != VA_STATUS_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to destroy decode "
+                   "context %#x: %d (%s).\n",
+                   ctx->va_context, vas, vaErrorStr(vas));
+        }
+    }
+    if (ctx->va_config != VA_INVALID_ID) {
+        vas = vaDestroyConfig(ctx->hwctx->display, ctx->va_config);
+        if (vas != VA_STATUS_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to destroy decode "
+                   "configuration %#x: %d (%s).\n",
+                   ctx->va_config, vas, vaErrorStr(vas));
+        }
+    }
+
+#if FF_API_STRUCT_VAAPI_CONTEXT
+    }
+#endif
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_decode.h b/mythtv/external/FFmpeg/libavcodec/vaapi_decode.h
new file mode 100644
index 00000000000..550ee054325
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_decode.h
@@ -0,0 +1,101 @@
+/*
+ * 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_VAAPI_DECODE_H
+#define AVCODEC_VAAPI_DECODE_H
+
+#include <va/va.h>
+
+#include "libavutil/frame.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_vaapi.h"
+
+#include "avcodec.h"
+
+#include "version.h"
+#if FF_API_STRUCT_VAAPI_CONTEXT
+#include "vaapi.h"
+#endif
+
+static inline VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic)
+{
+    return (uintptr_t)pic->data[3];
+}
+
+enum {
+    MAX_PARAM_BUFFERS = 16,
+};
+
+typedef struct VAAPIDecodePicture {
+    VASurfaceID           output_surface;
+
+    int                nb_param_buffers;
+    VABufferID            param_buffers[MAX_PARAM_BUFFERS];
+
+    int                nb_slices;
+    VABufferID           *slice_buffers;
+    int                   slices_allocated;
+} VAAPIDecodePicture;
+
+typedef struct VAAPIDecodeContext {
+    VAProfile             va_profile;
+    VAEntrypoint          va_entrypoint;
+    VAConfigID            va_config;
+    VAContextID           va_context;
+
+#if FF_API_STRUCT_VAAPI_CONTEXT
+FF_DISABLE_DEPRECATION_WARNINGS
+    int                   have_old_context;
+    struct vaapi_context *old_context;
+    AVBufferRef          *device_ref;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
+    AVHWDeviceContext    *device;
+    AVVAAPIDeviceContext *hwctx;
+
+    AVHWFramesContext    *frames;
+    AVVAAPIFramesContext *hwfc;
+
+    enum AVPixelFormat    surface_format;
+    int                   surface_count;
+} VAAPIDecodeContext;
+
+
+int ff_vaapi_decode_make_param_buffer(AVCodecContext *avctx,
+                                      VAAPIDecodePicture *pic,
+                                      int type,
+                                      const void *data,
+                                      size_t size);
+
+int ff_vaapi_decode_make_slice_buffer(AVCodecContext *avctx,
+                                      VAAPIDecodePicture *pic,
+                                      const void *params_data,
+                                      size_t params_size,
+                                      const void *slice_data,
+                                      size_t slice_size);
+
+int ff_vaapi_decode_issue(AVCodecContext *avctx,
+                          VAAPIDecodePicture *pic);
+int ff_vaapi_decode_cancel(AVCodecContext *avctx,
+                           VAAPIDecodePicture *pic);
+
+int ff_vaapi_decode_init(AVCodecContext *avctx);
+int ff_vaapi_decode_uninit(AVCodecContext *avctx);
+
+#endif /* AVCODEC_VAAPI_DECODE_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_encode.c b/mythtv/external/FFmpeg/libavcodec/vaapi_encode.c
index 21a86568fae..590f4be4ed0 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_encode.c
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_encode.c
@@ -27,7 +27,7 @@
 #include "vaapi_encode.h"
 #include "avcodec.h"
 
-static const char *picture_type_name[] = { "IDR", "I", "P", "B" };
+static const char * const picture_type_name[] = { "IDR", "I", "P", "B" };
 
 static int vaapi_encode_make_packed_header(AVCodecContext *avctx,
                                            VAAPIEncodePicture *pic,
@@ -36,13 +36,17 @@ static int vaapi_encode_make_packed_header(AVCodecContext *avctx,
     VAAPIEncodeContext *ctx = avctx->priv_data;
     VAStatus vas;
     VABufferID param_buffer, data_buffer;
+    VABufferID *tmp;
     VAEncPackedHeaderParameterBuffer params = {
         .type = type,
         .bit_length = bit_len,
         .has_emulation_bytes = 1,
     };
 
-    av_assert0(pic->nb_param_buffers + 2 <= MAX_PARAM_BUFFERS);
+    tmp = av_realloc_array(pic->param_buffers, sizeof(*tmp), pic->nb_param_buffers + 2);
+    if (!tmp)
+        return AVERROR(ENOMEM);
+    pic->param_buffers = tmp;
 
     vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
                          VAEncPackedHeaderParameterBufferType,
@@ -77,9 +81,13 @@ static int vaapi_encode_make_param_buffer(AVCodecContext *avctx,
 {
     VAAPIEncodeContext *ctx = avctx->priv_data;
     VAStatus vas;
+    VABufferID *tmp;
     VABufferID buffer;
 
-    av_assert0(pic->nb_param_buffers + 1 <= MAX_PARAM_BUFFERS);
+    tmp = av_realloc_array(pic->param_buffers, sizeof(*tmp), pic->nb_param_buffers + 1);
+    if (!tmp)
+        return AVERROR(ENOMEM);
+    pic->param_buffers = tmp;
 
     vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
                          type, len, 1, data, &buffer);
@@ -109,10 +117,10 @@ static int vaapi_encode_wait(AVCodecContext *avctx,
     }
 
     av_log(avctx, AV_LOG_DEBUG, "Sync to pic %"PRId64"/%"PRId64" "
-           "(recon surface %#x).\n", pic->display_order,
-           pic->encode_order, pic->recon_surface);
+           "(input surface %#x).\n", pic->display_order,
+           pic->encode_order, pic->input_surface);
 
-    vas = vaSyncSurface(ctx->hwctx->display, pic->recon_surface);
+    vas = vaSyncSurface(ctx->hwctx->display, pic->input_surface);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(avctx, AV_LOG_ERROR, "Failed to sync to picture completion: "
                "%d (%s).\n", vas, vaErrorStr(vas));
@@ -178,16 +186,12 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
     pic->recon_surface = (VASurfaceID)(uintptr_t)pic->recon_image->data[3];
     av_log(avctx, AV_LOG_DEBUG, "Recon surface is %#x.\n", pic->recon_surface);
 
-    vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
-                         VAEncCodedBufferType,
-                         MAX_OUTPUT_BUFFER_SIZE, 1, 0,
-                         &pic->output_buffer);
-    if (vas != VA_STATUS_SUCCESS) {
-        av_log(avctx, AV_LOG_ERROR, "Failed to create bitstream "
-               "output buffer: %d (%s).\n", vas, vaErrorStr(vas));
+    pic->output_buffer_ref = av_buffer_pool_get(ctx->output_buffer_pool);
+    if (!pic->output_buffer_ref) {
         err = AVERROR(ENOMEM);
         goto fail;
     }
+    pic->output_buffer = (VABufferID)(uintptr_t)pic->output_buffer_ref->data;
     av_log(avctx, AV_LOG_DEBUG, "Output buffer is %#x.\n",
            pic->output_buffer);
 
@@ -241,7 +245,8 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
     }
 
     if (pic->type == PICTURE_TYPE_IDR) {
-        if (ctx->codec->write_sequence_header) {
+        if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_SEQUENCE &&
+            ctx->codec->write_sequence_header) {
             bit_len = 8 * sizeof(data);
             err = ctx->codec->write_sequence_header(avctx, data, &bit_len);
             if (err < 0) {
@@ -257,7 +262,8 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
         }
     }
 
-    if (ctx->codec->write_picture_header) {
+    if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_PICTURE &&
+        ctx->codec->write_picture_header) {
         bit_len = 8 * sizeof(data);
         err = ctx->codec->write_picture_header(avctx, pic, data, &bit_len);
         if (err < 0) {
@@ -293,7 +299,8 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
         }
     }
 
-    if (ctx->codec->write_extra_header) {
+    if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_MISC &&
+        ctx->codec->write_extra_header) {
         for (i = 0;; i++) {
             int type;
             bit_len = 8 * sizeof(data);
@@ -314,14 +321,14 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
         }
     }
 
-    av_assert0(pic->nb_slices <= MAX_PICTURE_SLICES);
+    pic->slices = av_mallocz_array(pic->nb_slices, sizeof(*pic->slices));
+    if (!pic->slices) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
     for (i = 0; i < pic->nb_slices; i++) {
-        slice = av_mallocz(sizeof(*slice));
-        if (!slice) {
-            err = AVERROR(ENOMEM);
-            goto fail;
-        }
-        pic->slices[i] = slice;
+        slice = &pic->slices[i];
+        slice->index = i;
 
         if (ctx->codec->slice_params_size > 0) {
             slice->codec_slice_params = av_mallocz(ctx->codec->slice_params_size);
@@ -340,7 +347,8 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
             }
         }
 
-        if (ctx->codec->write_slice_header) {
+        if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_SLICE &&
+            ctx->codec->write_slice_header) {
             bit_len = 8 * sizeof(data);
             err = ctx->codec->write_slice_header(avctx, pic, slice,
                                                  data, &bit_len);
@@ -389,7 +397,27 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
         av_log(avctx, AV_LOG_ERROR, "Failed to end picture encode issue: "
                "%d (%s).\n", vas, vaErrorStr(vas));
         err = AVERROR(EIO);
-        goto fail_at_end;
+        // vaRenderPicture() has been called here, so we should not destroy
+        // the parameter buffers unless separate destruction is required.
+        if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &
+            AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS)
+            goto fail;
+        else
+            goto fail_at_end;
+    }
+
+    if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &
+        AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS) {
+        for (i = 0; i < pic->nb_param_buffers; i++) {
+            vas = vaDestroyBuffer(ctx->hwctx->display,
+                                  pic->param_buffers[i]);
+            if (vas != VA_STATUS_SUCCESS) {
+                av_log(avctx, AV_LOG_ERROR, "Failed to destroy "
+                       "param buffer %#x: %d (%s).\n",
+                       pic->param_buffers[i], vas, vaErrorStr(vas));
+                // And ignore.
+            }
+        }
     }
 
     pic->encode_issued = 1;
@@ -404,9 +432,19 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
 fail:
     for(i = 0; i < pic->nb_param_buffers; i++)
         vaDestroyBuffer(ctx->hwctx->display, pic->param_buffers[i]);
+    for (i = 0; i < pic->nb_slices; i++) {
+        if (pic->slices) {
+            av_freep(&pic->slices[i].priv_data);
+            av_freep(&pic->slices[i].codec_slice_params);
+        }
+    }
 fail_at_end:
     av_freep(&pic->codec_picture_params);
+    av_freep(&pic->param_buffers);
+    av_freep(&pic->slices);
     av_frame_free(&pic->recon_image);
+    av_buffer_unref(&pic->output_buffer_ref);
+    pic->output_buffer = VA_INVALID_ID;
     return err;
 }
 
@@ -438,7 +476,7 @@ static int vaapi_encode_output(AVCodecContext *avctx,
 
         err = av_new_packet(pkt, buf->size);
         if (err < 0)
-            goto fail;
+            goto fail_mapped;
 
         memcpy(pkt->data, buf->buf, buf->size);
     }
@@ -456,35 +494,32 @@ static int vaapi_encode_output(AVCodecContext *avctx,
         goto fail;
     }
 
-    vaDestroyBuffer(ctx->hwctx->display, pic->output_buffer);
+    av_buffer_unref(&pic->output_buffer_ref);
     pic->output_buffer = VA_INVALID_ID;
 
     av_log(avctx, AV_LOG_DEBUG, "Output read for pic %"PRId64"/%"PRId64".\n",
            pic->display_order, pic->encode_order);
     return 0;
 
+fail_mapped:
+    vaUnmapBuffer(ctx->hwctx->display, pic->output_buffer);
 fail:
-    if (pic->output_buffer != VA_INVALID_ID) {
-        vaUnmapBuffer(ctx->hwctx->display, pic->output_buffer);
-        vaDestroyBuffer(ctx->hwctx->display, pic->output_buffer);
-        pic->output_buffer = VA_INVALID_ID;
-    }
+    av_buffer_unref(&pic->output_buffer_ref);
+    pic->output_buffer = VA_INVALID_ID;
     return err;
 }
 
 static int vaapi_encode_discard(AVCodecContext *avctx,
                                 VAAPIEncodePicture *pic)
 {
-    VAAPIEncodeContext *ctx = avctx->priv_data;
-
     vaapi_encode_wait(avctx, pic);
 
-    if (pic->output_buffer != VA_INVALID_ID) {
+    if (pic->output_buffer_ref) {
         av_log(avctx, AV_LOG_DEBUG, "Discard output for pic "
                "%"PRId64"/%"PRId64".\n",
                pic->display_order, pic->encode_order);
 
-        vaDestroyBuffer(ctx->hwctx->display, pic->output_buffer);
+        av_buffer_unref(&pic->output_buffer_ref);
         pic->output_buffer = VA_INVALID_ID;
     }
 
@@ -515,15 +550,18 @@ static int vaapi_encode_free(AVCodecContext *avctx,
         vaapi_encode_discard(avctx, pic);
 
     for (i = 0; i < pic->nb_slices; i++) {
-        av_freep(&pic->slices[i]->priv_data);
-        av_freep(&pic->slices[i]->codec_slice_params);
-        av_freep(&pic->slices[i]);
+        if (pic->slices) {
+            av_freep(&pic->slices[i].priv_data);
+            av_freep(&pic->slices[i].codec_slice_params);
+        }
     }
     av_freep(&pic->codec_picture_params);
 
     av_frame_free(&pic->input_image);
     av_frame_free(&pic->recon_image);
 
+    av_freep(&pic->param_buffers);
+    av_freep(&pic->slices);
     // Output buffer should already be destroyed.
     av_assert0(pic->output_buffer == VA_INVALID_ID);
 
@@ -573,6 +611,10 @@ static int vaapi_encode_step(AVCodecContext *avctx,
     } else if (ctx->issue_mode == ISSUE_MODE_MAXIMISE_THROUGHPUT) {
         int activity;
 
+        // Run through the list of all available pictures repeatedly
+        // and issue the first one found which has all dependencies
+        // available (including previously-issued but not necessarily
+        // completed pictures).
         do {
             activity = 0;
             for (pic = ctx->pic_start; pic; pic = pic->next) {
@@ -588,9 +630,15 @@ static int vaapi_encode_step(AVCodecContext *avctx,
                 if (err < 0)
                     return err;
                 activity = 1;
+                // Start again from the beginning of the list,
+                // because issuing this picture may have satisfied
+                // forward dependencies of earlier ones.
+                break;
             }
         } while(activity);
 
+        // If we had a defined target for this step then it will
+        // always have been issued by now.
         if (target) {
             av_assert0(target->encode_issued && "broken dependencies?");
         }
@@ -618,50 +666,35 @@ static int vaapi_encode_get_next(AVCodecContext *avctx,
         }
     }
 
-    if (ctx->input_order == 0) {
-        // First frame is always an IDR frame.
-        av_assert0(!ctx->pic_start && !ctx->pic_end);
-
-        pic = vaapi_encode_alloc();
-        if (!pic)
-            return AVERROR(ENOMEM);
-
-        pic->type = PICTURE_TYPE_IDR;
-        pic->display_order = 0;
-        pic->encode_order  = 0;
-
-        ctx->pic_start = ctx->pic_end = pic;
-
-        *pic_out = pic;
-        return 0;
-    }
-
     pic = vaapi_encode_alloc();
     if (!pic)
         return AVERROR(ENOMEM);
 
-    if (ctx->p_per_i == 0 || ctx->p_counter == ctx->p_per_i) {
-        if (ctx->i_per_idr == 0 || ctx->i_counter == ctx->i_per_idr) {
-            pic->type = PICTURE_TYPE_IDR;
-            ctx->i_counter = 0;
-        } else {
-            pic->type = PICTURE_TYPE_I;
-            ++ctx->i_counter;
-        }
+    if (ctx->input_order == 0 || ctx->force_idr ||
+        ctx->gop_counter >= avctx->gop_size) {
+        pic->type = PICTURE_TYPE_IDR;
+        ctx->force_idr = 0;
+        ctx->gop_counter = 1;
+        ctx->p_counter = 0;
+    } else if (ctx->p_counter >= ctx->p_per_i) {
+        pic->type = PICTURE_TYPE_I;
+        ++ctx->gop_counter;
         ctx->p_counter = 0;
     } else {
         pic->type = PICTURE_TYPE_P;
         pic->refs[0] = ctx->pic_end;
         pic->nb_refs = 1;
+        ++ctx->gop_counter;
         ++ctx->p_counter;
     }
     start = end = pic;
 
     if (pic->type != PICTURE_TYPE_IDR) {
         // If that was not an IDR frame, add B-frames display-before and
-        // encode-after it.
+        // encode-after it, but not exceeding the GOP size.
 
-        for (i = 0; i < ctx->b_per_p; i++) {
+        for (i = 0; i < ctx->b_per_p &&
+             ctx->gop_counter < avctx->gop_size; i++) {
             pic = vaapi_encode_alloc();
             if (!pic)
                 goto fail;
@@ -675,23 +708,32 @@ static int vaapi_encode_get_next(AVCodecContext *avctx,
             pic->display_order = ctx->input_order + ctx->b_per_p - i - 1;
             pic->encode_order  = pic->display_order + 1;
             start = pic;
+
+            ++ctx->gop_counter;
         }
     }
 
-    for (i = 0, pic = start; pic; i++, pic = pic->next) {
-        pic->display_order = ctx->input_order + i;
-        if (end->type == PICTURE_TYPE_IDR)
-            pic->encode_order = ctx->input_order + i;
-        else if (pic == end)
-            pic->encode_order = ctx->input_order;
-        else
-            pic->encode_order = ctx->input_order + i + 1;
-    }
+    if (ctx->input_order == 0) {
+        pic->display_order = 0;
+        pic->encode_order  = 0;
 
-    av_assert0(ctx->pic_end);
-    ctx->pic_end->next = start;
-    ctx->pic_end = end;
+        ctx->pic_start = ctx->pic_end = pic;
 
+    } else {
+        for (i = 0, pic = start; pic; i++, pic = pic->next) {
+            pic->display_order = ctx->input_order + i;
+            if (end->type == PICTURE_TYPE_IDR)
+                pic->encode_order = ctx->input_order + i;
+            else if (pic == end)
+                pic->encode_order = ctx->input_order;
+            else
+                pic->encode_order = ctx->input_order + i + 1;
+        }
+
+        av_assert0(ctx->pic_end);
+        ctx->pic_end->next = start;
+        ctx->pic_end = end;
+    }
     *pic_out = start;
 
     av_log(avctx, AV_LOG_DEBUG, "Pictures:");
@@ -713,7 +755,7 @@ static int vaapi_encode_get_next(AVCodecContext *avctx,
     return AVERROR(ENOMEM);
 }
 
-static int vaapi_encode_mangle_end(AVCodecContext *avctx)
+static int vaapi_encode_truncate_gop(AVCodecContext *avctx)
 {
     VAAPIEncodeContext *ctx = avctx->priv_data;
     VAAPIEncodePicture *pic, *last_pic, *next;
@@ -763,7 +805,7 @@ static int vaapi_encode_mangle_end(AVCodecContext *avctx)
         // mangle anything.
     }
 
-    av_log(avctx, AV_LOG_DEBUG, "Pictures at end of stream:");
+    av_log(avctx, AV_LOG_DEBUG, "Pictures ending truncated GOP:");
     for (pic = ctx->pic_start; pic; pic = pic->next) {
         av_log(avctx, AV_LOG_DEBUG, " %s (%"PRId64"/%"PRId64")",
                picture_type_name[pic->type],
@@ -817,6 +859,13 @@ int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt,
         av_log(avctx, AV_LOG_DEBUG, "Encode frame: %ux%u (%"PRId64").\n",
                input_image->width, input_image->height, input_image->pts);
 
+        if (input_image->pict_type == AV_PICTURE_TYPE_I) {
+            err = vaapi_encode_truncate_gop(avctx);
+            if (err < 0)
+                goto fail;
+            ctx->force_idr = 1;
+        }
+
         err = vaapi_encode_get_next(avctx, &pic);
         if (err) {
             av_log(avctx, AV_LOG_ERROR, "Input setup failed: %d.\n", err);
@@ -845,7 +894,7 @@ int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt,
 
     } else {
         if (!ctx->end_of_stream) {
-            err = vaapi_encode_mangle_end(avctx);
+            err = vaapi_encode_truncate_gop(avctx);
             if (err < 0)
                 goto fail;
             ctx->end_of_stream = 1;
@@ -909,7 +958,7 @@ int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt,
     return err;
 }
 
-static av_cold int vaapi_encode_check_config(AVCodecContext *avctx)
+static av_cold int vaapi_encode_config_attributes(AVCodecContext *avctx)
 {
     VAAPIEncodeContext *ctx = avctx->priv_data;
     VAStatus vas;
@@ -917,8 +966,10 @@ static av_cold int vaapi_encode_check_config(AVCodecContext *avctx)
     VAProfile    *profiles    = NULL;
     VAEntrypoint *entrypoints = NULL;
     VAConfigAttrib attr[] = {
-        { VAConfigAttribRateControl     },
-        { VAConfigAttribEncMaxRefFrames },
+        { VAConfigAttribRTFormat         },
+        { VAConfigAttribRateControl      },
+        { VAConfigAttribEncMaxRefFrames  },
+        { VAConfigAttribEncPackedHeaders },
     };
 
     n = vaMaxNumProfiles(ctx->hwctx->display);
@@ -988,13 +1039,46 @@ static av_cold int vaapi_encode_check_config(AVCodecContext *avctx)
             continue;
         }
         switch (attr[i].type) {
+        case VAConfigAttribRTFormat:
+            if (!(ctx->va_rt_format & attr[i].value)) {
+                av_log(avctx, AV_LOG_ERROR, "Surface RT format %#x "
+                       "is not supported (mask %#x).\n",
+                       ctx->va_rt_format, attr[i].value);
+                err = AVERROR(EINVAL);
+                goto fail;
+            }
+            ctx->config_attributes[ctx->nb_config_attributes++] =
+                (VAConfigAttrib) {
+                .type  = VAConfigAttribRTFormat,
+                .value = ctx->va_rt_format,
+            };
+            break;
         case VAConfigAttribRateControl:
+            // Hack for backward compatibility: CBR was the only
+            // usable RC mode for a long time, so old drivers will
+            // only have it.  Normal default options may now choose
+            // VBR and then fail, however, so override it here with
+            // CBR if that is the only supported mode.
+            if (ctx->va_rc_mode == VA_RC_VBR &&
+                !(attr[i].value & VA_RC_VBR) &&
+                (attr[i].value & VA_RC_CBR)) {
+                av_log(avctx, AV_LOG_WARNING, "VBR rate control is "
+                       "not supported with this driver version; "
+                       "using CBR instead.\n");
+                ctx->va_rc_mode = VA_RC_CBR;
+            }
             if (!(ctx->va_rc_mode & attr[i].value)) {
-                av_log(avctx, AV_LOG_ERROR, "Rate control mode is not "
-                       "supported: %x\n", attr[i].value);
+                av_log(avctx, AV_LOG_ERROR, "Rate control mode %#x "
+                       "is not supported (mask: %#x).\n",
+                       ctx->va_rc_mode, attr[i].value);
                 err = AVERROR(EINVAL);
                 goto fail;
             }
+            ctx->config_attributes[ctx->nb_config_attributes++] =
+                (VAConfigAttrib) {
+                .type  = VAConfigAttribRateControl,
+                .value = ctx->va_rc_mode,
+            };
             break;
         case VAConfigAttribEncMaxRefFrames:
         {
@@ -1003,18 +1087,37 @@ static av_cold int vaapi_encode_check_config(AVCodecContext *avctx)
 
             if (avctx->gop_size > 1 && ref_l0 < 1) {
                 av_log(avctx, AV_LOG_ERROR, "P frames are not "
-                       "supported (%x).\n", attr[i].value);
+                       "supported (%#x).\n", attr[i].value);
                 err = AVERROR(EINVAL);
                 goto fail;
             }
             if (avctx->max_b_frames > 0 && ref_l1 < 1) {
                 av_log(avctx, AV_LOG_ERROR, "B frames are not "
-                       "supported (%x).\n", attr[i].value);
+                       "supported (%#x).\n", attr[i].value);
                 err = AVERROR(EINVAL);
                 goto fail;
             }
         }
         break;
+        case VAConfigAttribEncPackedHeaders:
+            if (ctx->va_packed_headers & ~attr[i].value) {
+                // This isn't fatal, but packed headers are always
+                // preferable because they are under our control.
+                // When absent, the driver is generating them and some
+                // features may not work (e.g. VUI or SEI in H.264).
+                av_log(avctx, AV_LOG_WARNING, "Warning: some packed "
+                       "headers are not supported (want %#x, got %#x).\n",
+                       ctx->va_packed_headers, attr[i].value);
+                ctx->va_packed_headers &= attr[i].value;
+            }
+            ctx->config_attributes[ctx->nb_config_attributes++] =
+                (VAConfigAttrib) {
+                .type  = VAConfigAttribEncPackedHeaders,
+                .value = ctx->va_packed_headers,
+            };
+            break;
+        default:
+            av_assert0(0 && "Unexpected config attribute.");
         }
     }
 
@@ -1025,69 +1128,150 @@ static av_cold int vaapi_encode_check_config(AVCodecContext *avctx)
     return err;
 }
 
-av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
-                                 const VAAPIEncodeType *type)
+static av_cold int vaapi_encode_init_rate_control(AVCodecContext *avctx)
 {
     VAAPIEncodeContext *ctx = avctx->priv_data;
-    AVVAAPIFramesContext *recon_hwctx = NULL;
-    AVVAAPIHWConfig *hwconfig = NULL;
-    AVHWFramesConstraints *constraints = NULL;
-    enum AVPixelFormat recon_format;
-    VAStatus vas;
-    int err, i;
-
-    if (!avctx->hw_frames_ctx) {
-        av_log(avctx, AV_LOG_ERROR, "A hardware frames reference is "
-               "required to associate the encoding device.\n");
+    int rc_bits_per_second;
+    int rc_target_percentage;
+    int rc_window_size;
+    int hrd_buffer_size;
+    int hrd_initial_buffer_fullness;
+    int fr_num, fr_den;
+
+    if (avctx->bit_rate > INT32_MAX) {
+        av_log(avctx, AV_LOG_ERROR, "Target bitrate of 2^31 bps or "
+               "higher is not supported.\n");
         return AVERROR(EINVAL);
     }
 
-    ctx->codec = type;
-    ctx->codec_options = ctx->codec_options_data;
-
-    ctx->va_config  = VA_INVALID_ID;
-    ctx->va_context = VA_INVALID_ID;
+    if (avctx->rc_buffer_size)
+        hrd_buffer_size = avctx->rc_buffer_size;
+    else
+        hrd_buffer_size = avctx->bit_rate;
+    if (avctx->rc_initial_buffer_occupancy)
+        hrd_initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
+    else
+        hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
 
-    ctx->priv_data = av_mallocz(type->priv_data_size);
-    if (!ctx->priv_data) {
-        err = AVERROR(ENOMEM);
-        goto fail;
+    if (ctx->va_rc_mode == VA_RC_CBR) {
+        rc_bits_per_second   = avctx->bit_rate;
+        rc_target_percentage = 100;
+        rc_window_size       = 1000;
+    } else {
+        if (avctx->rc_max_rate < avctx->bit_rate) {
+            // Max rate is unset or invalid, just use the normal bitrate.
+            rc_bits_per_second   = avctx->bit_rate;
+            rc_target_percentage = 100;
+        } else {
+            rc_bits_per_second   = avctx->rc_max_rate;
+            rc_target_percentage = (avctx->bit_rate * 100) / rc_bits_per_second;
+        }
+        rc_window_size = (hrd_buffer_size * 1000) / avctx->bit_rate;
     }
 
-    ctx->input_frames_ref = av_buffer_ref(avctx->hw_frames_ctx);
-    if (!ctx->input_frames_ref) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-    ctx->input_frames = (AVHWFramesContext*)ctx->input_frames_ref->data;
+    ctx->rc_params.misc.type = VAEncMiscParameterTypeRateControl;
+    ctx->rc_params.rc = (VAEncMiscParameterRateControl) {
+        .bits_per_second   = rc_bits_per_second,
+        .target_percentage = rc_target_percentage,
+        .window_size       = rc_window_size,
+        .initial_qp        = 0,
+        .min_qp            = (avctx->qmin > 0 ? avctx->qmin : 0),
+        .basic_unit_size   = 0,
+    };
+    ctx->global_params[ctx->nb_global_params] =
+        &ctx->rc_params.misc;
+    ctx->global_params_size[ctx->nb_global_params++] =
+        sizeof(ctx->rc_params);
+
+    ctx->hrd_params.misc.type = VAEncMiscParameterTypeHRD;
+    ctx->hrd_params.hrd = (VAEncMiscParameterHRD) {
+        .initial_buffer_fullness = hrd_initial_buffer_fullness,
+        .buffer_size             = hrd_buffer_size,
+    };
+    ctx->global_params[ctx->nb_global_params] =
+        &ctx->hrd_params.misc;
+    ctx->global_params_size[ctx->nb_global_params++] =
+        sizeof(ctx->hrd_params);
+
+    if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
+        av_reduce(&fr_num, &fr_den,
+                  avctx->framerate.num, avctx->framerate.den, 65535);
+    else
+        av_reduce(&fr_num, &fr_den,
+                  avctx->time_base.den, avctx->time_base.num, 65535);
 
-    ctx->device_ref = av_buffer_ref(ctx->input_frames->device_ref);
-    if (!ctx->device_ref) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-    ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
-    ctx->hwctx = ctx->device->hwctx;
+    ctx->fr_params.misc.type = VAEncMiscParameterTypeFrameRate;
+    ctx->fr_params.fr.framerate = (unsigned int)fr_den << 16 | fr_num;
 
-    err = ctx->codec->init(avctx);
-    if (err < 0)
-        goto fail;
+#if VA_CHECK_VERSION(0, 40, 0)
+    ctx->global_params[ctx->nb_global_params] =
+        &ctx->fr_params.misc;
+    ctx->global_params_size[ctx->nb_global_params++] =
+        sizeof(ctx->fr_params);
+#endif
 
-    err = vaapi_encode_check_config(avctx);
-    if (err < 0)
-        goto fail;
+    return 0;
+}
 
-    vas = vaCreateConfig(ctx->hwctx->display,
-                         ctx->va_profile, ctx->va_entrypoint,
-                         ctx->config_attributes, ctx->nb_config_attributes,
-                         &ctx->va_config);
+static void vaapi_encode_free_output_buffer(void *opaque,
+                                            uint8_t *data)
+{
+    AVCodecContext   *avctx = opaque;
+    VAAPIEncodeContext *ctx = avctx->priv_data;
+    VABufferID buffer_id;
+
+    buffer_id = (VABufferID)(uintptr_t)data;
+
+    vaDestroyBuffer(ctx->hwctx->display, buffer_id);
+
+    av_log(avctx, AV_LOG_DEBUG, "Freed output buffer %#x\n", buffer_id);
+}
+
+static AVBufferRef *vaapi_encode_alloc_output_buffer(void *opaque,
+                                                     int size)
+{
+    AVCodecContext   *avctx = opaque;
+    VAAPIEncodeContext *ctx = avctx->priv_data;
+    VABufferID buffer_id;
+    VAStatus vas;
+    AVBufferRef *ref;
+
+    // The output buffer size is fixed, so it needs to be large enough
+    // to hold the largest possible compressed frame.  We assume here
+    // that the uncompressed frame plus some header data is an upper
+    // bound on that.
+    vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
+                         VAEncCodedBufferType,
+                         3 * ctx->surface_width * ctx->surface_height +
+                         (1 << 16), 1, 0, &buffer_id);
     if (vas != VA_STATUS_SUCCESS) {
-        av_log(avctx, AV_LOG_ERROR, "Failed to create encode pipeline "
-               "configuration: %d (%s).\n", vas, vaErrorStr(vas));
-        err = AVERROR(EIO);
-        goto fail;
+        av_log(avctx, AV_LOG_ERROR, "Failed to create bitstream "
+               "output buffer: %d (%s).\n", vas, vaErrorStr(vas));
+        return NULL;
+    }
+
+    av_log(avctx, AV_LOG_DEBUG, "Allocated output buffer %#x\n", buffer_id);
+
+    ref = av_buffer_create((uint8_t*)(uintptr_t)buffer_id,
+                           sizeof(buffer_id),
+                           &vaapi_encode_free_output_buffer,
+                           avctx, AV_BUFFER_FLAG_READONLY);
+    if (!ref) {
+        vaDestroyBuffer(ctx->hwctx->display, buffer_id);
+        return NULL;
     }
 
+    return ref;
+}
+
+static av_cold int vaapi_encode_create_recon_frames(AVCodecContext *avctx)
+{
+    VAAPIEncodeContext *ctx = avctx->priv_data;
+    AVVAAPIHWConfig *hwconfig = NULL;
+    AVHWFramesConstraints *constraints = NULL;
+    enum AVPixelFormat recon_format;
+    int err, i;
+
     hwconfig = av_hwdevice_hwconfig_alloc(ctx->device_ref);
     if (!hwconfig) {
         err = AVERROR(ENOMEM);
@@ -1126,13 +1310,13 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
     av_log(avctx, AV_LOG_DEBUG, "Using %s as format of "
            "reconstructed frames.\n", av_get_pix_fmt_name(recon_format));
 
-    if (ctx->aligned_width  < constraints->min_width  ||
-        ctx->aligned_height < constraints->min_height ||
-        ctx->aligned_width  > constraints->max_width ||
-        ctx->aligned_height > constraints->max_height) {
+    if (ctx->surface_width  < constraints->min_width  ||
+        ctx->surface_height < constraints->min_height ||
+        ctx->surface_width  > constraints->max_width ||
+        ctx->surface_height > constraints->max_height) {
         av_log(avctx, AV_LOG_ERROR, "Hardware does not support encoding at "
                "size %dx%d (constraints: width %d-%d height %d-%d).\n",
-               ctx->aligned_width, ctx->aligned_height,
+               ctx->surface_width, ctx->surface_height,
                constraints->min_width,  constraints->max_width,
                constraints->min_height, constraints->max_height);
         err = AVERROR(EINVAL);
@@ -1151,9 +1335,11 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
 
     ctx->recon_frames->format    = AV_PIX_FMT_VAAPI;
     ctx->recon_frames->sw_format = recon_format;
-    ctx->recon_frames->width     = ctx->aligned_width;
-    ctx->recon_frames->height    = ctx->aligned_height;
-    ctx->recon_frames->initial_pool_size = ctx->nb_recon_frames;
+    ctx->recon_frames->width     = ctx->surface_width;
+    ctx->recon_frames->height    = ctx->surface_height;
+    // At most three IDR/I/P frames and two runs of B frames can be in
+    // flight at any one time.
+    ctx->recon_frames->initial_pool_size = 3 + 2 * avctx->max_b_frames;
 
     err = av_hwframe_ctx_init(ctx->recon_frames_ref);
     if (err < 0) {
@@ -1161,10 +1347,75 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
                "frame context: %d.\n", err);
         goto fail;
     }
-    recon_hwctx = ctx->recon_frames->hwctx;
 
+    err = 0;
+  fail:
+    av_freep(&hwconfig);
+    av_hwframe_constraints_free(&constraints);
+    return err;
+}
+
+av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
+{
+    VAAPIEncodeContext *ctx = avctx->priv_data;
+    AVVAAPIFramesContext *recon_hwctx = NULL;
+    VAStatus vas;
+    int err;
+
+    if (!avctx->hw_frames_ctx) {
+        av_log(avctx, AV_LOG_ERROR, "A hardware frames reference is "
+               "required to associate the encoding device.\n");
+        return AVERROR(EINVAL);
+    }
+
+    ctx->codec_options = ctx->codec_options_data;
+
+    ctx->va_config  = VA_INVALID_ID;
+    ctx->va_context = VA_INVALID_ID;
+
+    ctx->priv_data = av_mallocz(ctx->codec->priv_data_size);
+    if (!ctx->priv_data) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    ctx->input_frames_ref = av_buffer_ref(avctx->hw_frames_ctx);
+    if (!ctx->input_frames_ref) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+    ctx->input_frames = (AVHWFramesContext*)ctx->input_frames_ref->data;
+
+    ctx->device_ref = av_buffer_ref(ctx->input_frames->device_ref);
+    if (!ctx->device_ref) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+    ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
+    ctx->hwctx = ctx->device->hwctx;
+
+    err = vaapi_encode_config_attributes(avctx);
+    if (err < 0)
+        goto fail;
+
+    vas = vaCreateConfig(ctx->hwctx->display,
+                         ctx->va_profile, ctx->va_entrypoint,
+                         ctx->config_attributes, ctx->nb_config_attributes,
+                         &ctx->va_config);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create encode pipeline "
+               "configuration: %d (%s).\n", vas, vaErrorStr(vas));
+        err = AVERROR(EIO);
+        goto fail;
+    }
+
+    err = vaapi_encode_create_recon_frames(avctx);
+    if (err < 0)
+        goto fail;
+
+    recon_hwctx = ctx->recon_frames->hwctx;
     vas = vaCreateContext(ctx->hwctx->display, ctx->va_config,
-                          ctx->aligned_width, ctx->aligned_height,
+                          ctx->surface_width, ctx->surface_height,
                           VA_PROGRESSIVE,
                           recon_hwctx->surface_ids,
                           recon_hwctx->nb_surfaces,
@@ -1176,11 +1427,70 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
         goto fail;
     }
 
+    ctx->output_buffer_pool =
+        av_buffer_pool_init2(sizeof(VABufferID), avctx,
+                             &vaapi_encode_alloc_output_buffer, NULL);
+    if (!ctx->output_buffer_pool) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    if (ctx->va_rc_mode & ~VA_RC_CQP) {
+        err = vaapi_encode_init_rate_control(avctx);
+        if (err < 0)
+            goto fail;
+    }
+
+    if (ctx->codec->configure) {
+        err = ctx->codec->configure(avctx);
+        if (err < 0)
+            goto fail;
+    }
+
+    if (avctx->compression_level >= 0) {
+#if VA_CHECK_VERSION(0, 36, 0)
+        VAConfigAttrib attr = { VAConfigAttribEncQualityRange };
+
+        vas = vaGetConfigAttributes(ctx->hwctx->display,
+                                    ctx->va_profile,
+                                    ctx->va_entrypoint,
+                                    &attr, 1);
+        if (vas != VA_STATUS_SUCCESS) {
+            av_log(avctx, AV_LOG_WARNING, "Failed to query quality "
+                   "attribute: will use default compression level.\n");
+        } else {
+            if (avctx->compression_level > attr.value) {
+                av_log(avctx, AV_LOG_WARNING, "Invalid compression "
+                       "level: valid range is 0-%d, using %d.\n",
+                       attr.value, attr.value);
+                avctx->compression_level = attr.value;
+            }
+
+            ctx->quality_params.misc.type =
+                VAEncMiscParameterTypeQualityLevel;
+            ctx->quality_params.quality.quality_level =
+                avctx->compression_level;
+
+            ctx->global_params[ctx->nb_global_params] =
+                &ctx->quality_params.misc;
+            ctx->global_params_size[ctx->nb_global_params++] =
+                sizeof(ctx->quality_params);
+        }
+#else
+        av_log(avctx, AV_LOG_WARNING, "The encode compression level "
+               "option is not supported with this VAAPI version.\n");
+#endif
+    }
+
     ctx->input_order  = 0;
     ctx->output_delay = avctx->max_b_frames;
     ctx->decode_delay = 1;
     ctx->output_order = - ctx->output_delay - 1;
 
+    // Currently we never generate I frames, only IDR.
+    ctx->p_per_i = INT_MAX;
+    ctx->b_per_p = avctx->max_b_frames;
+
     if (ctx->codec->sequence_params_size > 0) {
         ctx->codec_sequence_params =
             av_mallocz(ctx->codec->sequence_params_size);
@@ -1207,21 +1517,35 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
         }
     }
 
-    // All I are IDR for now.
-    ctx->i_per_idr = 0;
-    ctx->p_per_i = ((avctx->gop_size + avctx->max_b_frames) /
-                    (avctx->max_b_frames + 1));
-    ctx->b_per_p = avctx->max_b_frames;
-
     // This should be configurable somehow.  (Needs testing on a machine
     // where it actually overlaps properly, though.)
     ctx->issue_mode = ISSUE_MODE_MAXIMISE_THROUGHPUT;
 
+    if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_SEQUENCE &&
+        ctx->codec->write_sequence_header) {
+        char data[MAX_PARAM_BUFFER_SIZE];
+        size_t bit_len = 8 * sizeof(data);
+
+        err = ctx->codec->write_sequence_header(avctx, data, &bit_len);
+        if (err < 0) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to write sequence header "
+                   "for extradata: %d.\n", err);
+            goto fail;
+        } else {
+            avctx->extradata_size = (bit_len + 7) / 8;
+            avctx->extradata = av_mallocz(avctx->extradata_size +
+                                          AV_INPUT_BUFFER_PADDING_SIZE);
+            if (!avctx->extradata) {
+                err = AVERROR(ENOMEM);
+                goto fail;
+            }
+            memcpy(avctx->extradata, data, avctx->extradata_size);
+        }
+    }
+
     return 0;
 
 fail:
-    av_freep(&hwconfig);
-    av_hwframe_constraints_free(&constraints);
     ff_vaapi_encode_close(avctx);
     return err;
 }
@@ -1246,8 +1570,7 @@ av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
         ctx->va_config = VA_INVALID_ID;
     }
 
-    if (ctx->codec->close)
-        ctx->codec->close(avctx);
+    av_buffer_pool_uninit(&ctx->output_buffer_pool);
 
     av_freep(&ctx->codec_sequence_params);
     av_freep(&ctx->codec_picture_params);
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_encode.h b/mythtv/external/FFmpeg/libavcodec/vaapi_encode.h
index 8f4f6538124..bcb9d57371a 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_encode.h
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_encode.h
@@ -35,11 +35,8 @@ enum {
     MAX_CONFIG_ATTRIBUTES  = 4,
     MAX_GLOBAL_PARAMS      = 4,
     MAX_PICTURE_REFERENCES = 2,
-    MAX_PICTURE_SLICES     = 1,
-    MAX_PARAM_BUFFERS      = 16,
     MAX_REORDER_DELAY      = 16,
     MAX_PARAM_BUFFER_SIZE  = 1024,
-    MAX_OUTPUT_BUFFER_SIZE = 1024 * 1024,
 };
 
 enum {
@@ -49,16 +46,8 @@ enum {
     PICTURE_TYPE_B   = 3,
 };
 
-enum {
-    // All encode operations are done independently.
-    ISSUE_MODE_SERIALISE_EVERYTHING = 0,
-    // Overlap as many operations as possible.
-    ISSUE_MODE_MAXIMISE_THROUGHPUT,
-    // Overlap operations only when satisfying parallel dependencies.
-    ISSUE_MODE_MINIMISE_LATENCY,
-};
-
 typedef struct VAAPIEncodeSlice {
+    int             index;
     void           *priv_data;
     void           *codec_slice_params;
 } VAAPIEncodeSlice;
@@ -82,8 +71,9 @@ typedef struct VAAPIEncodePicture {
     VASurfaceID     recon_surface;
 
     int          nb_param_buffers;
-    VABufferID      param_buffers[MAX_PARAM_BUFFERS];
+    VABufferID     *param_buffers;
 
+    AVBufferRef    *output_buffer_ref;
     VABufferID      output_buffer;
 
     void           *priv_data;
@@ -93,7 +83,7 @@ typedef struct VAAPIEncodePicture {
     struct VAAPIEncodePicture *refs[MAX_PICTURE_REFERENCES];
 
     int          nb_slices;
-    VAAPIEncodeSlice *slices[MAX_PICTURE_SLICES];
+    VAAPIEncodeSlice *slices;
 } VAAPIEncodePicture;
 
 typedef struct VAAPIEncodeContext {
@@ -102,41 +92,78 @@ typedef struct VAAPIEncodeContext {
     // Codec-specific hooks.
     const struct VAAPIEncodeType *codec;
 
+    // Encoding profile (VAProfileXXX).
+    VAProfile       va_profile;
+    // Encoding entrypoint (usually VAEntryointEncSlice).
+    VAEntrypoint    va_entrypoint;
+    // Surface colour/sampling format (usually VA_RT_FORMAT_YUV420).
+    unsigned int    va_rt_format;
+    // Rate control mode.
+    unsigned int    va_rc_mode;
+    // Supported packed headers (initially the desired set, modified
+    // later to what is actually supported).
+    unsigned int    va_packed_headers;
+
+    // The required size of surfaces.  This is probably the input
+    // size (AVCodecContext.width|height) aligned up to whatever
+    // block size is required by the codec.
+    int             surface_width;
+    int             surface_height;
+
+    // Everything above this point must be set before calling
+    // ff_vaapi_encode_init().
+
     // Codec-specific state.
     void *priv_data;
 
-    VAProfile       va_profile;
-    VAEntrypoint    va_entrypoint;
+    // Configuration attributes to use when creating va_config.
+    VAConfigAttrib  config_attributes[MAX_CONFIG_ATTRIBUTES];
+    int          nb_config_attributes;
+
     VAConfigID      va_config;
     VAContextID     va_context;
 
-    int             va_rc_mode;
-
     AVBufferRef    *device_ref;
     AVHWDeviceContext *device;
     AVVAAPIDeviceContext *hwctx;
 
+    // The hardware frame context containing the input frames.
     AVBufferRef    *input_frames_ref;
     AVHWFramesContext *input_frames;
 
-    // Input size, set from input frames.
-    int             input_width;
-    int             input_height;
-    // Aligned size, set by codec init, becomes hwframe size.
-    int             aligned_width;
-    int             aligned_height;
-
-    int          nb_recon_frames;
+    // The hardware frame context containing the reconstructed frames.
     AVBufferRef    *recon_frames_ref;
     AVHWFramesContext *recon_frames;
 
-    VAConfigAttrib  config_attributes[MAX_CONFIG_ATTRIBUTES];
-    int          nb_config_attributes;
+    // Pool of (reusable) bitstream output buffers.
+    AVBufferPool   *output_buffer_pool;
 
+    // Global parameters which will be applied at the start of the
+    // sequence (includes rate control parameters below).
     VAEncMiscParameterBuffer *global_params[MAX_GLOBAL_PARAMS];
     size_t          global_params_size[MAX_GLOBAL_PARAMS];
     int          nb_global_params;
 
+    // Rate control parameters.
+    struct {
+        VAEncMiscParameterBuffer misc;
+        VAEncMiscParameterRateControl rc;
+    } rc_params;
+    struct {
+        VAEncMiscParameterBuffer misc;
+        VAEncMiscParameterHRD hrd;
+    } hrd_params;
+    struct {
+        VAEncMiscParameterBuffer misc;
+        VAEncMiscParameterFrameRate fr;
+    } fr_params;
+#if VA_CHECK_VERSION(0, 36, 0)
+    struct {
+        VAEncMiscParameterBuffer misc;
+        VAEncMiscParameterBufferQualityLevel quality;
+    } quality_params;
+#endif
+
     // Per-sequence parameter structure (VAEncSequenceParameterBuffer*).
     void           *codec_sequence_params;
 
@@ -156,7 +183,15 @@ typedef struct VAAPIEncodeContext {
     // Next output order index (encode order).
     int64_t         output_order;
 
-    int             issue_mode;
+    enum {
+        // All encode operations are done independently (synchronise
+        // immediately after every operation).
+        ISSUE_MODE_SERIALISE_EVERYTHING = 0,
+        // Overlap as many operations as possible.
+        ISSUE_MODE_MAXIMISE_THROUGHPUT,
+        // Overlap operations only when satisfying parallel dependencies.
+        ISSUE_MODE_MINIMISE_LATENCY,
+    } issue_mode;
 
     // Timestamp handling.
     int64_t         first_pts;
@@ -164,11 +199,10 @@ typedef struct VAAPIEncodeContext {
     int64_t         ts_ring[MAX_REORDER_DELAY * 3];
 
     // Frame type decision.
-    int i_per_idr;
     int p_per_i;
     int b_per_p;
-    int idr_counter;
-    int i_counter;
+    int force_idr;
+    int gop_counter;
     int p_counter;
     int end_of_stream;
 
@@ -181,15 +215,20 @@ typedef struct VAAPIEncodeContext {
 
 
 typedef struct VAAPIEncodeType {
-    size_t    priv_data_size;
+    size_t priv_data_size;
 
-    int  (*init)(AVCodecContext *avctx);
-    int (*close)(AVCodecContext *avctx);
+    // Perform any extra codec-specific configuration after the
+    // codec context is initialised (set up the private data and
+    // add any necessary global parameters).
+    int (*configure)(AVCodecContext *avctx);
 
+    // The size of the parameter structures:
+    // sizeof(VAEnc{type}ParameterBuffer{codec}).
     size_t sequence_params_size;
     size_t picture_params_size;
     size_t slice_params_size;
 
+    // Fill the parameter structures.
     int  (*init_sequence_params)(AVCodecContext *avctx);
     int   (*init_picture_params)(AVCodecContext *avctx,
                                  VAAPIEncodePicture *pic);
@@ -197,10 +236,15 @@ typedef struct VAAPIEncodeType {
                                  VAAPIEncodePicture *pic,
                                  VAAPIEncodeSlice *slice);
 
+    // The type used by the packed header: this should look like
+    // VAEncPackedHeader{something}.
     int sequence_header_type;
     int picture_header_type;
     int slice_header_type;
 
+    // Write the packed header data to the provided buffer.
+    // The sequence header is also used to fill the codec extradata
+    // when the encoder is starting.
     int (*write_sequence_header)(AVCodecContext *avctx,
                                  char *data, size_t *data_len);
     int  (*write_picture_header)(AVCodecContext *avctx,
@@ -211,10 +255,18 @@ typedef struct VAAPIEncodeType {
                                  VAAPIEncodeSlice *slice,
                                  char *data, size_t *data_len);
 
+    // Fill an extra parameter structure, which will then be
+    // passed to vaRenderPicture().  Will be called repeatedly
+    // with increasing index argument until AVERROR_EOF is
+    // returned.
     int    (*write_extra_buffer)(AVCodecContext *avctx,
                                  VAAPIEncodePicture *pic,
                                  int index, int *type,
                                  char *data, size_t *data_len);
+
+    // Write an extra packed header.  Will be called repeatedly
+    // with increasing index argument until AVERROR_EOF is
+    // returned.
     int    (*write_extra_header)(AVCodecContext *avctx,
                                  VAAPIEncodePicture *pic,
                                  int index, int *type,
@@ -225,8 +277,7 @@ typedef struct VAAPIEncodeType {
 int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt,
                      const AVFrame *input_image, int *got_packet);
 
-int ff_vaapi_encode_init(AVCodecContext *avctx,
-                         const VAAPIEncodeType *type);
+int ff_vaapi_encode_init(AVCodecContext *avctx);
 int ff_vaapi_encode_close(AVCodecContext *avctx);
 
 #endif /* AVCODEC_VAAPI_ENCODE_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_encode_h264.c b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_h264.c
index 5bed4e493fa..efde80b08ee 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_encode_h264.c
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_h264.c
@@ -84,7 +84,12 @@ typedef struct VAAPIEncodeH264MiscSequenceParams {
     char vcl_hrd_parameters_present_flag;
     char low_delay_hrd_flag;
     char pic_struct_present_flag;
-    char bitstream_restriction_flag;
+
+    char motion_vectors_over_pic_boundaries_flag;
+    unsigned int max_bytes_per_pic_denom;
+    unsigned int max_bits_per_mb_denom;
+    unsigned int max_num_reorder_frames;
+    unsigned int max_dec_pic_buffering;
 
     unsigned int cpb_cnt_minus1;
     unsigned int bit_rate_scale;
@@ -141,6 +146,7 @@ typedef struct VAAPIEncodeH264Context {
     int fixed_qp_b;
 
     int next_frame_num;
+    int64_t last_idr_frame;
     int64_t idr_pic_count;
 
     int cpb_delay;
@@ -148,28 +154,14 @@ typedef struct VAAPIEncodeH264Context {
 
     // Rate control configuration.
     int send_timing_sei;
-    struct {
-        VAEncMiscParameterBuffer misc;
-        VAEncMiscParameterRateControl rc;
-    } rc_params;
-    struct {
-        VAEncMiscParameterBuffer misc;
-        VAEncMiscParameterHRD hrd;
-    } hrd_params;
-
-#if VA_CHECK_VERSION(0, 36, 0)
-    // Speed-quality tradeoff setting.
-    struct {
-        VAEncMiscParameterBuffer misc;
-        VAEncMiscParameterBufferQualityLevel quality;
-    } quality_params;
-#endif
 } VAAPIEncodeH264Context;
 
 typedef struct VAAPIEncodeH264Options {
     int qp;
     int quality;
     int low_power;
+    // Entropy encoder type.
+    int coder;
 } VAAPIEncodeH264Options;
 
 
@@ -271,7 +263,13 @@ static void vaapi_encode_h264_write_vui(PutBitContext *pbc,
 
     u(1, vvui_field(bitstream_restriction_flag));
     if (vseq->vui_fields.bits.bitstream_restriction_flag) {
-        av_assert0(0 && "bitstream restrictions not supported");
+        u(1, mseq_var(motion_vectors_over_pic_boundaries_flag));
+        ue(mseq_var(max_bytes_per_pic_denom));
+        ue(mseq_var(max_bits_per_mb_denom));
+        ue(vvui_field(log2_max_mv_length_horizontal));
+        ue(vvui_field(log2_max_mv_length_vertical));
+        ue(mseq_var(max_num_reorder_frames));
+        ue(mseq_var(max_dec_pic_buffering));
     }
 }
 
@@ -646,18 +644,18 @@ static void vaapi_encode_h264_write_sei(PutBitContext *pbc,
 
     for (payload_type = 0; payload_type < 64; payload_type++) {
         switch (payload_type) {
-        case SEI_TYPE_BUFFERING_PERIOD:
+        case H264_SEI_TYPE_BUFFERING_PERIOD:
             if (!priv->send_timing_sei ||
                 pic->type != PICTURE_TYPE_IDR)
                 continue;
             write_payload = &vaapi_encode_h264_write_buffering_period;
             break;
-        case SEI_TYPE_PIC_TIMING:
+        case H264_SEI_TYPE_PIC_TIMING:
             if (!priv->send_timing_sei)
                 continue;
             write_payload = &vaapi_encode_h264_write_pic_timing;
             break;
-        case SEI_TYPE_USER_DATA_UNREGISTERED:
+        case H264_SEI_TYPE_USER_DATA_UNREGISTERED:
             if (pic->encode_order != 0)
                 continue;
             write_payload = &vaapi_encode_h264_write_identifier;
@@ -779,6 +777,8 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
     VAEncPictureParameterBufferH264   *vpic = ctx->codec_picture_params;
     VAAPIEncodeH264Context            *priv = ctx->priv_data;
     VAAPIEncodeH264MiscSequenceParams *mseq = &priv->misc_sequence_params;
+    VAAPIEncodeH264Options             *opt =
+        (VAAPIEncodeH264Options*)ctx->codec_options_data;
     int i;
 
     {
@@ -786,7 +786,7 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
 
         vseq->level_idc = avctx->level;
 
-        vseq->max_num_ref_frames = 2;
+        vseq->max_num_ref_frames = 1 + (avctx->max_b_frames > 0);
 
         vseq->picture_width_in_mbs  = priv->mb_width;
         vseq->picture_height_in_mbs = priv->mb_height;
@@ -796,17 +796,19 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
         vseq->seq_fields.bits.direct_8x8_inference_flag = 1;
         vseq->seq_fields.bits.log2_max_frame_num_minus4 = 4;
         vseq->seq_fields.bits.pic_order_cnt_type = 0;
+        vseq->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 =
+            av_clip(av_log2(avctx->max_b_frames + 1) - 2, 0, 12);
 
-        if (ctx->input_width  != ctx->aligned_width ||
-            ctx->input_height != ctx->aligned_height) {
+        if (avctx->width  != ctx->surface_width ||
+            avctx->height != ctx->surface_height) {
             vseq->frame_cropping_flag = 1;
 
             vseq->frame_crop_left_offset   = 0;
             vseq->frame_crop_right_offset  =
-                (ctx->aligned_width - ctx->input_width) / 2;
+                (ctx->surface_width - avctx->width) / 2;
             vseq->frame_crop_top_offset    = 0;
             vseq->frame_crop_bottom_offset =
-                (ctx->aligned_height - ctx->input_height) / 2;
+                (ctx->surface_height - avctx->height) / 2;
         } else {
             vseq->frame_cropping_flag = 0;
         }
@@ -839,12 +841,22 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
             mseq->matrix_coefficients      = avctx->colorspace;
         }
 
+        vseq->vui_fields.bits.bitstream_restriction_flag = 1;
+        mseq->motion_vectors_over_pic_boundaries_flag = 1;
+        mseq->max_bytes_per_pic_denom = 0;
+        mseq->max_bits_per_mb_denom   = 0;
+        vseq->vui_fields.bits.log2_max_mv_length_horizontal = 16;
+        vseq->vui_fields.bits.log2_max_mv_length_vertical   = 16;
+
+        mseq->max_num_reorder_frames = (avctx->max_b_frames > 0);
+        mseq->max_dec_pic_buffering  = vseq->max_num_ref_frames;
+
         vseq->bits_per_second = avctx->bit_rate;
 
         vseq->vui_fields.bits.timing_info_present_flag = 1;
         if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
-            vseq->num_units_in_tick = avctx->framerate.num;
-            vseq->time_scale        = 2 * avctx->framerate.den;
+            vseq->num_units_in_tick = avctx->framerate.den;
+            vseq->time_scale        = 2 * avctx->framerate.num;
             mseq->fixed_frame_rate_flag = 1;
         } else {
             vseq->num_units_in_tick = avctx->time_base.num;
@@ -861,14 +873,14 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
             // Try to scale these to a sensible range so that the
             // golomb encode of the value is not overlong.
             mseq->bit_rate_scale =
-                av_clip_uintp2(av_log2(avctx->bit_rate) - 15, 4);
+                av_clip_uintp2(av_log2(avctx->bit_rate) - 15 - 6, 4);
             mseq->bit_rate_value_minus1[0] =
-                (avctx->bit_rate >> mseq->bit_rate_scale) - 1;
+                (avctx->bit_rate >> mseq->bit_rate_scale + 6) - 1;
 
             mseq->cpb_size_scale =
-                av_clip_uintp2(av_log2(priv->hrd_params.hrd.buffer_size) - 15, 4);
+                av_clip_uintp2(av_log2(ctx->hrd_params.hrd.buffer_size) - 15 - 4, 4);
             mseq->cpb_size_value_minus1[0] =
-                (priv->hrd_params.hrd.buffer_size >> mseq->cpb_size_scale) - 1;
+                (ctx->hrd_params.hrd.buffer_size >> mseq->cpb_size_scale + 4) - 1;
 
             // CBR mode isn't actually available here, despite naming.
             mseq->cbr_flag[0] = 0;
@@ -880,8 +892,8 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
 
             // This calculation can easily overflow 32 bits.
             mseq->initial_cpb_removal_delay = 90000 *
-                (uint64_t)priv->hrd_params.hrd.initial_buffer_fullness /
-                priv->hrd_params.hrd.buffer_size;
+                (uint64_t)ctx->hrd_params.hrd.initial_buffer_fullness /
+                ctx->hrd_params.hrd.buffer_size;
 
             mseq->initial_cpb_removal_delay_offset = 0;
         } else {
@@ -889,8 +901,8 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
             mseq->nal_hrd_parameters_present_flag = 0;
         }
 
-        vseq->intra_period     = ctx->p_per_i * (ctx->b_per_p + 1);
-        vseq->intra_idr_period = vseq->intra_period;
+        vseq->intra_period     = avctx->gop_size;
+        vseq->intra_idr_period = avctx->gop_size;
         vseq->ip_period        = ctx->b_per_p + 1;
     }
 
@@ -912,7 +924,7 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
         vpic->num_ref_idx_l1_active_minus1 = 0;
 
         vpic->pic_fields.bits.entropy_coding_mode_flag =
-            ((avctx->profile & 0xff) != 66);
+            opt->coder ? ((avctx->profile & 0xff) != 66) : 0;
         vpic->pic_fields.bits.weighted_pred_flag = 0;
         vpic->pic_fields.bits.weighted_bipred_idc = 0;
         vpic->pic_fields.bits.transform_8x8_mode_flag =
@@ -947,6 +959,7 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx,
         vpic->frame_num = 0;
         priv->next_frame_num = 1;
         priv->cpb_delay = 0;
+        priv->last_idr_frame = pic->display_order;
     } else {
         vpic->frame_num = priv->next_frame_num;
         if (pic->type != PICTURE_TYPE_B) {
@@ -963,8 +976,8 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx,
     vpic->CurrPic.picture_id          = pic->recon_surface;
     vpic->CurrPic.frame_idx           = vpic->frame_num;
     vpic->CurrPic.flags               = 0;
-    vpic->CurrPic.TopFieldOrderCnt    = pic->display_order;
-    vpic->CurrPic.BottomFieldOrderCnt = pic->display_order;
+    vpic->CurrPic.TopFieldOrderCnt    = pic->display_order - priv->last_idr_frame;
+    vpic->CurrPic.BottomFieldOrderCnt = pic->display_order - priv->last_idr_frame;
 
     for (i = 0; i < pic->nb_refs; i++) {
         VAAPIEncodePicture *ref = pic->refs[i];
@@ -972,8 +985,8 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx,
         vpic->ReferenceFrames[i].picture_id = ref->recon_surface;
         vpic->ReferenceFrames[i].frame_idx  = ref->encode_order;
         vpic->ReferenceFrames[i].flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE;
-        vpic->ReferenceFrames[i].TopFieldOrderCnt    = ref->display_order;
-        vpic->ReferenceFrames[i].BottomFieldOrderCnt = ref->display_order;
+        vpic->ReferenceFrames[i].TopFieldOrderCnt    = ref->display_order - priv->last_idr_frame;
+        vpic->ReferenceFrames[i].BottomFieldOrderCnt = ref->display_order - priv->last_idr_frame;
     }
     for (; i < FF_ARRAY_ELEMS(vpic->ReferenceFrames); i++) {
         vpic->ReferenceFrames[i].picture_id = VA_INVALID_ID;
@@ -1044,7 +1057,7 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx,
     vslice->pic_parameter_set_id = vpic->pic_parameter_set_id;
     vslice->idr_pic_id = priv->idr_pic_count++;
 
-    vslice->pic_order_cnt_lsb = pic->display_order &
+    vslice->pic_order_cnt_lsb = (pic->display_order - priv->last_idr_frame) &
         ((1 << (4 + vseq->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4)) - 1);
 
     for (i = 0; i < FF_ARRAY_ELEMS(vslice->RefPicList0); i++) {
@@ -1083,107 +1096,96 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx,
     return 0;
 }
 
-static av_cold int vaapi_encode_h264_init_constant_bitrate(AVCodecContext *avctx)
+static av_cold int vaapi_encode_h264_configure(AVCodecContext *avctx)
 {
     VAAPIEncodeContext      *ctx = avctx->priv_data;
     VAAPIEncodeH264Context *priv = ctx->priv_data;
-    int hrd_buffer_size;
-    int hrd_initial_buffer_fullness;
+    VAAPIEncodeH264Options  *opt = ctx->codec_options;
 
-    if (avctx->bit_rate > INT32_MAX) {
-        av_log(avctx, AV_LOG_ERROR, "Target bitrate of 2^31 bps or "
-               "higher is not supported.\n");
-        return AVERROR(EINVAL);
+    priv->mb_width  = FFALIGN(avctx->width,  16) / 16;
+    priv->mb_height = FFALIGN(avctx->height, 16) / 16;
+
+    if (ctx->va_rc_mode == VA_RC_CQP) {
+        priv->fixed_qp_p = opt->qp;
+        if (avctx->i_quant_factor > 0.0)
+            priv->fixed_qp_idr = (int)((priv->fixed_qp_p * avctx->i_quant_factor +
+                                        avctx->i_quant_offset) + 0.5);
+        else
+            priv->fixed_qp_idr = priv->fixed_qp_p;
+        if (avctx->b_quant_factor > 0.0)
+            priv->fixed_qp_b = (int)((priv->fixed_qp_p * avctx->b_quant_factor +
+                                      avctx->b_quant_offset) + 0.5);
+        else
+            priv->fixed_qp_b = priv->fixed_qp_p;
+
+        av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
+               "%d / %d / %d for IDR- / P- / B-frames.\n",
+               priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
+
+    } else if (ctx->va_rc_mode == VA_RC_CBR ||
+               ctx->va_rc_mode == VA_RC_VBR) {
+        // These still need to be  set for pic_init_qp/slice_qp_delta.
+        priv->fixed_qp_idr = 26;
+        priv->fixed_qp_p   = 26;
+        priv->fixed_qp_b   = 26;
+
+        av_log(avctx, AV_LOG_DEBUG, "Using %s-bitrate = %"PRId64" bps.\n",
+               ctx->va_rc_mode == VA_RC_CBR ? "constant" : "variable",
+               avctx->bit_rate);
+
+    } else {
+        av_assert0(0 && "Invalid RC mode.");
     }
 
-    if (avctx->rc_buffer_size)
-        hrd_buffer_size = avctx->rc_buffer_size;
-    else
-        hrd_buffer_size = avctx->bit_rate;
-    if (avctx->rc_initial_buffer_occupancy)
-        hrd_initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
-    else
-        hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
-
-    priv->rc_params.misc.type = VAEncMiscParameterTypeRateControl;
-    priv->rc_params.rc = (VAEncMiscParameterRateControl) {
-        .bits_per_second   = avctx->bit_rate,
-        .target_percentage = 66,
-        .window_size       = 1000,
-        .initial_qp        = (avctx->qmax >= 0 ? avctx->qmax : 40),
-        .min_qp            = (avctx->qmin >= 0 ? avctx->qmin : 18),
-        .basic_unit_size   = 0,
-    };
-    ctx->global_params[ctx->nb_global_params] =
-        &priv->rc_params.misc;
-    ctx->global_params_size[ctx->nb_global_params++] =
-        sizeof(priv->rc_params);
-
-    priv->hrd_params.misc.type = VAEncMiscParameterTypeHRD;
-    priv->hrd_params.hrd = (VAEncMiscParameterHRD) {
-        .initial_buffer_fullness = hrd_initial_buffer_fullness,
-        .buffer_size             = hrd_buffer_size,
-    };
-    ctx->global_params[ctx->nb_global_params] =
-        &priv->hrd_params.misc;
-    ctx->global_params_size[ctx->nb_global_params++] =
-        sizeof(priv->hrd_params);
-
-    // These still need to be  set for pic_init_qp/slice_qp_delta.
-    priv->fixed_qp_idr = 26;
-    priv->fixed_qp_p   = 26;
-    priv->fixed_qp_b   = 26;
-
-    av_log(avctx, AV_LOG_DEBUG, "Using constant-bitrate = %"PRId64" bps.\n",
-           avctx->bit_rate);
+    if (avctx->compression_level == FF_COMPRESSION_DEFAULT)
+        avctx->compression_level = opt->quality;
+
     return 0;
 }
 
-static av_cold int vaapi_encode_h264_init_fixed_qp(AVCodecContext *avctx)
-{
-    VAAPIEncodeContext      *ctx = avctx->priv_data;
-    VAAPIEncodeH264Context *priv = ctx->priv_data;
-    VAAPIEncodeH264Options  *opt = ctx->codec_options;
+static const VAAPIEncodeType vaapi_encode_type_h264 = {
+    .priv_data_size        = sizeof(VAAPIEncodeH264Context),
 
-    priv->fixed_qp_p = opt->qp;
-    if (avctx->i_quant_factor > 0.0)
-        priv->fixed_qp_idr = (int)((priv->fixed_qp_p * avctx->i_quant_factor +
-                                    avctx->i_quant_offset) + 0.5);
-    else
-        priv->fixed_qp_idr = priv->fixed_qp_p;
-    if (avctx->b_quant_factor > 0.0)
-        priv->fixed_qp_b = (int)((priv->fixed_qp_p * avctx->b_quant_factor +
-                                  avctx->b_quant_offset) + 0.5);
-    else
-        priv->fixed_qp_b = priv->fixed_qp_p;
+    .configure             = &vaapi_encode_h264_configure,
 
-    av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
-           "%d / %d / %d for IDR- / P- / B-frames.\n",
-           priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
-    return 0;
-}
+    .sequence_params_size  = sizeof(VAEncSequenceParameterBufferH264),
+    .init_sequence_params  = &vaapi_encode_h264_init_sequence_params,
+
+    .picture_params_size   = sizeof(VAEncPictureParameterBufferH264),
+    .init_picture_params   = &vaapi_encode_h264_init_picture_params,
+
+    .slice_params_size     = sizeof(VAEncSliceParameterBufferH264),
+    .init_slice_params     = &vaapi_encode_h264_init_slice_params,
+
+    .sequence_header_type  = VAEncPackedHeaderSequence,
+    .write_sequence_header = &vaapi_encode_h264_write_sequence_header,
 
-static av_cold int vaapi_encode_h264_init_internal(AVCodecContext *avctx)
+    .slice_header_type     = VAEncPackedHeaderH264_Slice,
+    .write_slice_header    = &vaapi_encode_h264_write_slice_header,
+
+    .write_extra_header    = &vaapi_encode_h264_write_extra_header,
+};
+
+static av_cold int vaapi_encode_h264_init(AVCodecContext *avctx)
 {
-    static const VAConfigAttrib default_config_attributes[] = {
-        { .type  = VAConfigAttribRTFormat,
-          .value = VA_RT_FORMAT_YUV420 },
-        { .type  = VAConfigAttribEncPackedHeaders,
-          .value = (VA_ENC_PACKED_HEADER_SEQUENCE |
-                    VA_ENC_PACKED_HEADER_SLICE) },
-    };
+    VAAPIEncodeContext     *ctx = avctx->priv_data;
+    VAAPIEncodeH264Options *opt =
+        (VAAPIEncodeH264Options*)ctx->codec_options_data;
 
-    VAAPIEncodeContext      *ctx = avctx->priv_data;
-    VAAPIEncodeH264Context *priv = ctx->priv_data;
-    VAAPIEncodeH264Options  *opt = ctx->codec_options;
-    int i, err;
+    ctx->codec = &vaapi_encode_type_h264;
 
     switch (avctx->profile) {
+    case FF_PROFILE_H264_BASELINE:
+        av_log(avctx, AV_LOG_WARNING, "H.264 baseline profile is not "
+               "supported, using constrained baseline profile instead.\n");
+        avctx->profile = FF_PROFILE_H264_CONSTRAINED_BASELINE;
     case FF_PROFILE_H264_CONSTRAINED_BASELINE:
         ctx->va_profile = VAProfileH264ConstrainedBaseline;
-        break;
-    case FF_PROFILE_H264_BASELINE:
-        ctx->va_profile = VAProfileH264Baseline;
+        if (avctx->max_b_frames != 0) {
+            avctx->max_b_frames = 0;
+            av_log(avctx, AV_LOG_WARNING, "H.264 constrained baseline profile "
+                   "doesn't support encoding with B frames, disabling them.\n");
+        }
         break;
     case FF_PROFILE_H264_MAIN:
         ctx->va_profile = VAProfileH264Main;
@@ -1216,7 +1218,7 @@ static av_cold int vaapi_encode_h264_init_internal(AVCodecContext *avctx)
         return AVERROR(EINVAL);
     }
     if (opt->low_power) {
-#if VA_CHECK_VERSION(0, 39, 1)
+#if VA_CHECK_VERSION(0, 39, 2)
         ctx->va_entrypoint = VAEntrypointEncSliceLP;
 #else
         av_log(avctx, AV_LOG_ERROR, "Low-power encoding is not "
@@ -1227,80 +1229,26 @@ static av_cold int vaapi_encode_h264_init_internal(AVCodecContext *avctx)
         ctx->va_entrypoint = VAEntrypointEncSlice;
     }
 
-    ctx->input_width    = avctx->width;
-    ctx->input_height   = avctx->height;
-    ctx->aligned_width  = FFALIGN(ctx->input_width,  16);
-    ctx->aligned_height = FFALIGN(ctx->input_height, 16);
-    priv->mb_width      = ctx->aligned_width  / 16;
-    priv->mb_height     = ctx->aligned_height / 16;
-
-    for (i = 0; i < FF_ARRAY_ELEMS(default_config_attributes); i++) {
-        ctx->config_attributes[ctx->nb_config_attributes++] =
-            default_config_attributes[i];
-    }
+    // Only 8-bit encode is supported.
+    ctx->va_rt_format = VA_RT_FORMAT_YUV420;
 
     if (avctx->bit_rate > 0) {
-        ctx->va_rc_mode = VA_RC_CBR;
-        err = vaapi_encode_h264_init_constant_bitrate(avctx);
-    } else {
+        if (avctx->rc_max_rate == avctx->bit_rate)
+            ctx->va_rc_mode = VA_RC_CBR;
+        else
+            ctx->va_rc_mode = VA_RC_VBR;
+    } else
         ctx->va_rc_mode = VA_RC_CQP;
-        err = vaapi_encode_h264_init_fixed_qp(avctx);
-    }
-    if (err < 0)
-        return err;
-
-    ctx->config_attributes[ctx->nb_config_attributes++] = (VAConfigAttrib) {
-        .type  = VAConfigAttribRateControl,
-        .value = ctx->va_rc_mode,
-    };
-
-    if (opt->quality > 0) {
-#if VA_CHECK_VERSION(0, 36, 0)
-        priv->quality_params.misc.type =
-            VAEncMiscParameterTypeQualityLevel;
-        priv->quality_params.quality.quality_level = opt->quality;
 
-        ctx->global_params[ctx->nb_global_params] =
-            &priv->quality_params.misc;
-        ctx->global_params_size[ctx->nb_global_params++] =
-            sizeof(priv->quality_params);
-#else
-        av_log(avctx, AV_LOG_WARNING, "The encode quality option is not "
-               "supported with this VAAPI version.\n");
-#endif
-    }
+    ctx->va_packed_headers =
+        VA_ENC_PACKED_HEADER_SEQUENCE | // SPS and PPS.
+        VA_ENC_PACKED_HEADER_SLICE    | // Slice headers.
+        VA_ENC_PACKED_HEADER_MISC;      // SEI.
 
-    ctx->nb_recon_frames = 20;
-
-    return 0;
-}
-
-static VAAPIEncodeType vaapi_encode_type_h264 = {
-    .priv_data_size        = sizeof(VAAPIEncodeH264Context),
+    ctx->surface_width  = FFALIGN(avctx->width,  16);
+    ctx->surface_height = FFALIGN(avctx->height, 16);
 
-    .init                  = &vaapi_encode_h264_init_internal,
-
-    .sequence_params_size  = sizeof(VAEncSequenceParameterBufferH264),
-    .init_sequence_params  = &vaapi_encode_h264_init_sequence_params,
-
-    .picture_params_size   = sizeof(VAEncPictureParameterBufferH264),
-    .init_picture_params   = &vaapi_encode_h264_init_picture_params,
-
-    .slice_params_size     = sizeof(VAEncSliceParameterBufferH264),
-    .init_slice_params     = &vaapi_encode_h264_init_slice_params,
-
-    .sequence_header_type  = VAEncPackedHeaderSequence,
-    .write_sequence_header = &vaapi_encode_h264_write_sequence_header,
-
-    .slice_header_type     = VAEncPackedHeaderH264_Slice,
-    .write_slice_header    = &vaapi_encode_h264_write_slice_header,
-
-    .write_extra_header    = &vaapi_encode_h264_write_extra_header,
-};
-
-static av_cold int vaapi_encode_h264_init(AVCodecContext *avctx)
-{
-    return ff_vaapi_encode_init(avctx, &vaapi_encode_type_h264);
+    return ff_vaapi_encode_init(avctx);
 }
 
 #define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \
@@ -1314,6 +1262,12 @@ static const AVOption vaapi_encode_h264_options[] = {
     { "low_power", "Use low-power encoding mode (experimental: only supported "
       "on some platforms, does not support all features)",
       OFFSET(low_power), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
+    { "coder", "Entropy coder type",
+      OFFSET(coder), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, FLAGS, "coder" },
+        { "cavlc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, FLAGS, "coder" },
+        { "cabac", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, FLAGS, "coder" },
+        { "vlc",   NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, FLAGS, "coder" },
+        { "ac",    NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, FLAGS, "coder" },
     { NULL },
 };
 
@@ -1327,6 +1281,7 @@ static const AVCodecDefault vaapi_encode_h264_defaults[] = {
     { "i_qoffset",      "0"   },
     { "b_qfactor",      "6/5" },
     { "b_qoffset",      "0"   },
+    { "qmin",           "0"   },
     { NULL },
 };
 
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_encode_h265.c b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_h265.c
index 45f6f6de29b..971458db875 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_encode_h265.c
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_h265.c
@@ -149,7 +149,6 @@ typedef struct VAAPIEncodeH265MiscSequenceParams {
 typedef struct VAAPIEncodeH265MiscSliceParams {
     // Slice segments.
     char first_slice_segment_in_pic_flag;
-    unsigned int slice_segment_address;
 
     // Short-term reference picture sets.
     char short_term_ref_pic_set_sps_flag;
@@ -275,7 +274,7 @@ static void vaapi_encode_h265_write_vps(PutBitContext *pbc,
     VAAPIEncodeH265MiscSequenceParams *mseq = &priv->misc_sequence_params;
     int i, j;
 
-    vaapi_encode_h265_write_nal_unit_header(pbc, NAL_VPS);
+    vaapi_encode_h265_write_nal_unit_header(pbc, HEVC_NAL_VPS);
 
     u(4, mseq->video_parameter_set_id, vps_video_parameter_set_id);
 
@@ -395,7 +394,7 @@ static void vaapi_encode_h265_write_sps(PutBitContext *pbc,
     VAAPIEncodeH265MiscSequenceParams *mseq = &priv->misc_sequence_params;
     int i;
 
-    vaapi_encode_h265_write_nal_unit_header(pbc, NAL_SPS);
+    vaapi_encode_h265_write_nal_unit_header(pbc, HEVC_NAL_SPS);
 
     u(4, mseq->video_parameter_set_id, sps_video_parameter_set_id);
 
@@ -491,7 +490,7 @@ static void vaapi_encode_h265_write_pps(PutBitContext *pbc,
     VAAPIEncodeH265MiscSequenceParams *mseq = &priv->misc_sequence_params;
     int i;
 
-    vaapi_encode_h265_write_nal_unit_header(pbc, NAL_PPS);
+    vaapi_encode_h265_write_nal_unit_header(pbc, HEVC_NAL_PPS);
 
     ue(vpic->slice_pic_parameter_set_id, pps_pic_parameter_set_id);
     ue(mseq->seq_parameter_set_id, pps_seq_parameter_set_id);
@@ -576,7 +575,7 @@ static void vaapi_encode_h265_write_slice_header2(PutBitContext *pbc,
     vaapi_encode_h265_write_nal_unit_header(pbc, vpic->nal_unit_type);
 
     u(1, mslice_var(first_slice_segment_in_pic_flag));
-    if (vpic->nal_unit_type >= NAL_BLA_W_LP &&
+    if (vpic->nal_unit_type >= HEVC_NAL_BLA_W_LP &&
        vpic->nal_unit_type <= 23)
         u(1, mslice_var(no_output_of_prior_pics_flag));
 
@@ -586,7 +585,7 @@ static void vaapi_encode_h265_write_slice_header2(PutBitContext *pbc,
         if (vpic->pic_fields.bits.dependent_slice_segments_enabled_flag)
             u(1, vslice_field(dependent_slice_segment_flag));
         u(av_log2((priv->ctu_width * priv->ctu_height) - 1) + 1,
-          mslice_var(slice_segment_address));
+          vslice_var(slice_segment_address));
     }
     if (!vslice->slice_fields.bits.dependent_slice_segment_flag) {
         for (i = 0; i < mseq->num_extra_slice_header_bits; i++)
@@ -597,8 +596,8 @@ static void vaapi_encode_h265_write_slice_header2(PutBitContext *pbc,
             u(1, 1, pic_output_flag);
         if (vseq->seq_fields.bits.separate_colour_plane_flag)
             u(2, vslice_field(colour_plane_id));
-        if (vpic->nal_unit_type != NAL_IDR_W_RADL &&
-           vpic->nal_unit_type != NAL_IDR_N_LP) {
+        if (vpic->nal_unit_type != HEVC_NAL_IDR_W_RADL &&
+           vpic->nal_unit_type != HEVC_NAL_IDR_N_LP) {
             u(4 + mseq->log2_max_pic_order_cnt_lsb_minus4,
               (pslice->pic_order_cnt &
                ((1 << (mseq->log2_max_pic_order_cnt_lsb_minus4 + 4)) - 1)),
@@ -616,77 +615,77 @@ static void vaapi_encode_h265_write_slice_header2(PutBitContext *pbc,
             if (mseq->long_term_ref_pics_present_flag) {
                 av_assert0(0);
             }
+        }
 
-            if (vseq->seq_fields.bits.sps_temporal_mvp_enabled_flag) {
-                u(1, vslice_field(slice_temporal_mvp_enabled_flag));
-            }
+        if (vseq->seq_fields.bits.sps_temporal_mvp_enabled_flag) {
+            u(1, vslice_field(slice_temporal_mvp_enabled_flag));
+        }
 
-            if (vseq->seq_fields.bits.sample_adaptive_offset_enabled_flag) {
-                u(1, vslice_field(slice_sao_luma_flag));
-                if (!vseq->seq_fields.bits.separate_colour_plane_flag &&
-                   vseq->seq_fields.bits.chroma_format_idc != 0) {
-                    u(1, vslice_field(slice_sao_chroma_flag));
-                }
+        if (vseq->seq_fields.bits.sample_adaptive_offset_enabled_flag) {
+            u(1, vslice_field(slice_sao_luma_flag));
+            if (!vseq->seq_fields.bits.separate_colour_plane_flag &&
+                vseq->seq_fields.bits.chroma_format_idc != 0) {
+                u(1, vslice_field(slice_sao_chroma_flag));
             }
+        }
 
-            if (vslice->slice_type == P_SLICE || vslice->slice_type == B_SLICE) {
-                u(1, vslice_field(num_ref_idx_active_override_flag));
-                if (vslice->slice_fields.bits.num_ref_idx_active_override_flag) {
-                    ue(vslice_var(num_ref_idx_l0_active_minus1));
-                    if (vslice->slice_type == B_SLICE) {
-                        ue(vslice_var(num_ref_idx_l1_active_minus1));
-                    }
-                }
-
-                if (mseq->lists_modification_present_flag) {
-                    av_assert0(0);
-                    // ref_pic_lists_modification()
-                }
-                if (vslice->slice_type == B_SLICE) {
-                    u(1, vslice_field(mvd_l1_zero_flag));
-                }
-                if (mseq->cabac_init_present_flag) {
-                    u(1, vslice_field(cabac_init_flag));
-                }
-                if (vslice->slice_fields.bits.slice_temporal_mvp_enabled_flag) {
-                    if (vslice->slice_type == B_SLICE)
-                        u(1, vslice_field(collocated_from_l0_flag));
-                    ue(vpic->collocated_ref_pic_index, collocated_ref_idx);
-                }
-                if ((vpic->pic_fields.bits.weighted_pred_flag &&
-                     vslice->slice_type == P_SLICE) ||
-                    (vpic->pic_fields.bits.weighted_bipred_flag &&
-                     vslice->slice_type == B_SLICE)) {
-                    av_assert0(0);
-                    // pred_weight_table()
+        if (vslice->slice_type == HEVC_SLICE_P || vslice->slice_type == HEVC_SLICE_B) {
+            u(1, vslice_field(num_ref_idx_active_override_flag));
+            if (vslice->slice_fields.bits.num_ref_idx_active_override_flag) {
+                ue(vslice_var(num_ref_idx_l0_active_minus1));
+                if (vslice->slice_type == HEVC_SLICE_B) {
+                    ue(vslice_var(num_ref_idx_l1_active_minus1));
                 }
-                ue(5 - vslice->max_num_merge_cand, five_minus_max_num_merge_cand);
             }
 
-            se(vslice_var(slice_qp_delta));
-            if (mseq->pps_slice_chroma_qp_offsets_present_flag) {
-                se(vslice_var(slice_cb_qp_offset));
-                se(vslice_var(slice_cr_qp_offset));
+            if (mseq->lists_modification_present_flag) {
+                av_assert0(0);
+                // ref_pic_lists_modification()
             }
-            if (mseq->pps_slice_chroma_offset_list_enabled_flag) {
-                u(1, 0, cu_chroma_qp_offset_enabled_flag);
+            if (vslice->slice_type == HEVC_SLICE_B) {
+                u(1, vslice_field(mvd_l1_zero_flag));
             }
-            if (mseq->deblocking_filter_override_enabled_flag) {
-                u(1, mslice_var(deblocking_filter_override_flag));
+            if (mseq->cabac_init_present_flag) {
+                u(1, vslice_field(cabac_init_flag));
             }
-            if (mslice->deblocking_filter_override_flag) {
-                u(1, vslice_field(slice_deblocking_filter_disabled_flag));
-                if (!vslice->slice_fields.bits.slice_deblocking_filter_disabled_flag) {
-                    se(vslice_var(slice_beta_offset_div2));
-                    se(vslice_var(slice_tc_offset_div2));
-                }
+            if (vslice->slice_fields.bits.slice_temporal_mvp_enabled_flag) {
+                if (vslice->slice_type == HEVC_SLICE_B)
+                    u(1, vslice_field(collocated_from_l0_flag));
+                ue(vpic->collocated_ref_pic_index, collocated_ref_idx);
             }
-            if (vpic->pic_fields.bits.pps_loop_filter_across_slices_enabled_flag &&
-                (vslice->slice_fields.bits.slice_sao_luma_flag ||
-                 vslice->slice_fields.bits.slice_sao_chroma_flag ||
-                 vslice->slice_fields.bits.slice_deblocking_filter_disabled_flag)) {
-                u(1, vslice_field(slice_loop_filter_across_slices_enabled_flag));
+            if ((vpic->pic_fields.bits.weighted_pred_flag &&
+                 vslice->slice_type == HEVC_SLICE_P) ||
+                (vpic->pic_fields.bits.weighted_bipred_flag &&
+                 vslice->slice_type == HEVC_SLICE_B)) {
+                av_assert0(0);
+                // pred_weight_table()
             }
+            ue(5 - vslice->max_num_merge_cand, five_minus_max_num_merge_cand);
+        }
+
+        se(vslice_var(slice_qp_delta));
+        if (mseq->pps_slice_chroma_qp_offsets_present_flag) {
+            se(vslice_var(slice_cb_qp_offset));
+            se(vslice_var(slice_cr_qp_offset));
+        }
+        if (mseq->pps_slice_chroma_offset_list_enabled_flag) {
+            u(1, 0, cu_chroma_qp_offset_enabled_flag);
+        }
+        if (mseq->deblocking_filter_override_enabled_flag) {
+            u(1, mslice_var(deblocking_filter_override_flag));
+        }
+        if (mslice->deblocking_filter_override_flag) {
+            u(1, vslice_field(slice_deblocking_filter_disabled_flag));
+            if (!vslice->slice_fields.bits.slice_deblocking_filter_disabled_flag) {
+                se(vslice_var(slice_beta_offset_div2));
+                se(vslice_var(slice_tc_offset_div2));
+            }
+        }
+        if (vpic->pic_fields.bits.pps_loop_filter_across_slices_enabled_flag &&
+            (vslice->slice_fields.bits.slice_sao_luma_flag ||
+             vslice->slice_fields.bits.slice_sao_chroma_flag ||
+             vslice->slice_fields.bits.slice_deblocking_filter_disabled_flag)) {
+            u(1, vslice_field(slice_loop_filter_across_slices_enabled_flag));
         }
 
         if (vpic->pic_fields.bits.tiles_enabled_flag ||
@@ -798,13 +797,15 @@ static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
         vseq->intra_idr_period = 0;
         vseq->ip_period = 0;
 
-        vseq->pic_width_in_luma_samples  = ctx->aligned_width;
-        vseq->pic_height_in_luma_samples = ctx->aligned_height;
+        vseq->pic_width_in_luma_samples  = ctx->surface_width;
+        vseq->pic_height_in_luma_samples = ctx->surface_height;
 
         vseq->seq_fields.bits.chroma_format_idc = 1; // 4:2:0.
         vseq->seq_fields.bits.separate_colour_plane_flag = 0;
-        vseq->seq_fields.bits.bit_depth_luma_minus8 = 0; // 8-bit luma.
-        vseq->seq_fields.bits.bit_depth_chroma_minus8 = 0; // 8-bit chroma.
+        vseq->seq_fields.bits.bit_depth_luma_minus8 =
+            avctx->profile == FF_PROFILE_HEVC_MAIN_10 ? 2 : 0;
+        vseq->seq_fields.bits.bit_depth_chroma_minus8 =
+            avctx->profile == FF_PROFILE_HEVC_MAIN_10 ? 2 : 0;
         // Other misc flags all zero.
 
         // These have to come from the capabilities of the encoder.  We have
@@ -823,15 +824,15 @@ static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
 
         vseq->bits_per_second = avctx->bit_rate;
         if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
-            vseq->vui_num_units_in_tick = avctx->framerate.num;
-            vseq->vui_time_scale        = avctx->framerate.den;
+            vseq->vui_num_units_in_tick = avctx->framerate.den;
+            vseq->vui_time_scale        = avctx->framerate.num;
         } else {
             vseq->vui_num_units_in_tick = avctx->time_base.num;
             vseq->vui_time_scale        = avctx->time_base.den;
         }
 
-        vseq->intra_period     = ctx->p_per_i * (ctx->b_per_p + 1);
-        vseq->intra_idr_period = vseq->intra_period;
+        vseq->intra_period     = avctx->gop_size;
+        vseq->intra_idr_period = avctx->gop_size;
         vseq->ip_period        = ctx->b_per_p + 1;
     }
 
@@ -897,12 +898,12 @@ static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
 
         mseq->log2_max_pic_order_cnt_lsb_minus4 = 8;
         mseq->vps_sub_layer_ordering_info_present_flag = 0;
-        mseq->vps_max_dec_pic_buffering_minus1[0] = 1;
-        mseq->vps_max_num_reorder_pics[0]         = ctx->b_per_p;
+        mseq->vps_max_dec_pic_buffering_minus1[0] = (avctx->max_b_frames > 0) + 1;
+        mseq->vps_max_num_reorder_pics[0]         = (avctx->max_b_frames > 0);
         mseq->vps_max_latency_increase_plus1[0]   = 0;
         mseq->sps_sub_layer_ordering_info_present_flag = 0;
-        mseq->sps_max_dec_pic_buffering_minus1[0] = 1;
-        mseq->sps_max_num_reorder_pics[0]         = ctx->b_per_p;
+        mseq->sps_max_dec_pic_buffering_minus1[0] = (avctx->max_b_frames > 0) + 1;
+        mseq->sps_max_num_reorder_pics[0]         = (avctx->max_b_frames > 0);
         mseq->sps_max_latency_increase_plus1[0]   = 0;
 
         mseq->vps_timing_info_present_flag = 1;
@@ -911,15 +912,15 @@ static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
         mseq->vps_poc_proportional_to_timing_flag = 1;
         mseq->vps_num_ticks_poc_diff_minus1 = 0;
 
-        if (ctx->input_width  != ctx->aligned_width ||
-            ctx->input_height != ctx->aligned_height) {
+        if (avctx->width  != ctx->surface_width ||
+            avctx->height != ctx->surface_height) {
             mseq->conformance_window_flag = 1;
             mseq->conf_win_left_offset   = 0;
             mseq->conf_win_right_offset  =
-                (ctx->aligned_width - ctx->input_width) / 2;
+                (ctx->surface_width - avctx->width) / 2;
             mseq->conf_win_top_offset    = 0;
             mseq->conf_win_bottom_offset =
-                (ctx->aligned_height - ctx->input_height) / 2;
+                (ctx->surface_height - avctx->height) / 2;
         } else {
             mseq->conformance_window_flag = 0;
         }
@@ -996,25 +997,25 @@ static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx,
 
     switch (pic->type) {
     case PICTURE_TYPE_IDR:
-        vpic->nal_unit_type = NAL_IDR_W_RADL;
+        vpic->nal_unit_type = HEVC_NAL_IDR_W_RADL;
         vpic->pic_fields.bits.idr_pic_flag = 1;
         vpic->pic_fields.bits.coding_type  = 1;
         vpic->pic_fields.bits.reference_pic_flag = 1;
         break;
     case PICTURE_TYPE_I:
-        vpic->nal_unit_type = NAL_TRAIL_R;
+        vpic->nal_unit_type = HEVC_NAL_TRAIL_R;
         vpic->pic_fields.bits.idr_pic_flag = 0;
         vpic->pic_fields.bits.coding_type  = 1;
         vpic->pic_fields.bits.reference_pic_flag = 1;
         break;
     case PICTURE_TYPE_P:
-        vpic->nal_unit_type = NAL_TRAIL_R;
+        vpic->nal_unit_type = HEVC_NAL_TRAIL_R;
         vpic->pic_fields.bits.idr_pic_flag = 0;
         vpic->pic_fields.bits.coding_type  = 2;
         vpic->pic_fields.bits.reference_pic_flag = 1;
         break;
     case PICTURE_TYPE_B:
-        vpic->nal_unit_type = NAL_TRAIL_R;
+        vpic->nal_unit_type = HEVC_NAL_TRAIL_R;
         vpic->pic_fields.bits.idr_pic_flag = 0;
         vpic->pic_fields.bits.coding_type  = 3;
         vpic->pic_fields.bits.reference_pic_flag = 0;
@@ -1053,13 +1054,13 @@ static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx,
     switch (pic->type) {
     case PICTURE_TYPE_IDR:
     case PICTURE_TYPE_I:
-        vslice->slice_type = I_SLICE;
+        vslice->slice_type = HEVC_SLICE_I;
         break;
     case PICTURE_TYPE_P:
-        vslice->slice_type = P_SLICE;
+        vslice->slice_type = HEVC_SLICE_P;
         break;
     case PICTURE_TYPE_B:
-        vslice->slice_type = B_SLICE;
+        vslice->slice_type = HEVC_SLICE_B;
         break;
     default:
         av_assert0(0 && "invalid picture type");
@@ -1154,156 +1155,58 @@ static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx,
     return 0;
 }
 
-static av_cold int vaapi_encode_h265_init_constant_bitrate(AVCodecContext *avctx)
-{
-    VAAPIEncodeContext      *ctx = avctx->priv_data;
-    VAAPIEncodeH265Context *priv = ctx->priv_data;
-    int hrd_buffer_size;
-    int hrd_initial_buffer_fullness;
-
-    if (avctx->bit_rate > INT32_MAX) {
-        av_log(avctx, AV_LOG_ERROR, "Target bitrate of 2^31 bps or "
-               "higher is not supported.\n");
-        return AVERROR(EINVAL);
-    }
-
-    if (avctx->rc_buffer_size)
-        hrd_buffer_size = avctx->rc_buffer_size;
-    else
-        hrd_buffer_size = avctx->bit_rate;
-    if (avctx->rc_initial_buffer_occupancy)
-        hrd_initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
-    else
-        hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
-
-    priv->rc_params.misc.type = VAEncMiscParameterTypeRateControl;
-    priv->rc_params.rc = (VAEncMiscParameterRateControl) {
-        .bits_per_second   = avctx->bit_rate,
-        .target_percentage = 66,
-        .window_size       = 1000,
-        .initial_qp        = (avctx->qmax >= 0 ? avctx->qmax : 40),
-        .min_qp            = (avctx->qmin >= 0 ? avctx->qmin : 20),
-        .basic_unit_size   = 0,
-    };
-    ctx->global_params[ctx->nb_global_params] =
-        &priv->rc_params.misc;
-    ctx->global_params_size[ctx->nb_global_params++] =
-        sizeof(priv->rc_params);
-
-    priv->hrd_params.misc.type = VAEncMiscParameterTypeHRD;
-    priv->hrd_params.hrd = (VAEncMiscParameterHRD) {
-        .initial_buffer_fullness = hrd_initial_buffer_fullness,
-        .buffer_size             = hrd_buffer_size,
-    };
-    ctx->global_params[ctx->nb_global_params] =
-        &priv->hrd_params.misc;
-    ctx->global_params_size[ctx->nb_global_params++] =
-        sizeof(priv->hrd_params);
-
-    // These still need to be  set for pic_init_qp/slice_qp_delta.
-    priv->fixed_qp_idr = 30;
-    priv->fixed_qp_p   = 30;
-    priv->fixed_qp_b   = 30;
-
-    av_log(avctx, AV_LOG_DEBUG, "Using constant-bitrate = %"PRId64" bps.\n",
-           avctx->bit_rate);
-    return 0;
-}
-
-static av_cold int vaapi_encode_h265_init_fixed_qp(AVCodecContext *avctx)
+static av_cold int vaapi_encode_h265_configure(AVCodecContext *avctx)
 {
     VAAPIEncodeContext      *ctx = avctx->priv_data;
     VAAPIEncodeH265Context *priv = ctx->priv_data;
     VAAPIEncodeH265Options  *opt = ctx->codec_options;
 
-    priv->fixed_qp_p = opt->qp;
-    if (avctx->i_quant_factor > 0.0)
-        priv->fixed_qp_idr = (int)((priv->fixed_qp_p * avctx->i_quant_factor +
-                                    avctx->i_quant_offset) + 0.5);
-    else
-        priv->fixed_qp_idr = priv->fixed_qp_p;
-    if (avctx->b_quant_factor > 0.0)
-        priv->fixed_qp_b = (int)((priv->fixed_qp_p * avctx->b_quant_factor +
-                                  avctx->b_quant_offset) + 0.5);
-    else
-        priv->fixed_qp_b = priv->fixed_qp_p;
-
-    av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
-           "%d / %d / %d for IDR- / P- / B-frames.\n",
-           priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
-    return 0;
-}
-
-static av_cold int vaapi_encode_h265_init_internal(AVCodecContext *avctx)
-{
-    static const VAConfigAttrib default_config_attributes[] = {
-        { .type  = VAConfigAttribRTFormat,
-          .value = VA_RT_FORMAT_YUV420 },
-        { .type  = VAConfigAttribEncPackedHeaders,
-          .value = (VA_ENC_PACKED_HEADER_SEQUENCE |
-                    VA_ENC_PACKED_HEADER_SLICE) },
-    };
-
-    VAAPIEncodeContext      *ctx = avctx->priv_data;
-    VAAPIEncodeH265Context *priv = ctx->priv_data;
-    int i, err;
-
-    switch (avctx->profile) {
-    case FF_PROFILE_HEVC_MAIN:
-    case FF_PROFILE_UNKNOWN:
-        ctx->va_profile = VAProfileHEVCMain;
-        break;
-    case FF_PROFILE_HEVC_MAIN_10:
-        av_log(avctx, AV_LOG_ERROR, "H.265 main 10-bit profile "
-               "is not supported.\n");
-        return AVERROR_PATCHWELCOME;
-    default:
-        av_log(avctx, AV_LOG_ERROR, "Unknown H.265 profile %d.\n",
-               avctx->profile);
-        return AVERROR(EINVAL);
-    }
-    ctx->va_entrypoint = VAEntrypointEncSlice;
-
-    ctx->input_width    = avctx->width;
-    ctx->input_height   = avctx->height;
-    ctx->aligned_width  = FFALIGN(ctx->input_width,  16);
-    ctx->aligned_height = FFALIGN(ctx->input_height, 16);
-    priv->ctu_width     = FFALIGN(ctx->aligned_width,  32) / 32;
-    priv->ctu_height    = FFALIGN(ctx->aligned_height, 32) / 32;
-
-    av_log(avctx, AV_LOG_VERBOSE, "Input %ux%u -> Aligned %ux%u -> CTU %ux%u.\n",
-           ctx->input_width, ctx->input_height, ctx->aligned_width,
-           ctx->aligned_height, priv->ctu_width, priv->ctu_height);
+    priv->ctu_width     = FFALIGN(ctx->surface_width,  32) / 32;
+    priv->ctu_height    = FFALIGN(ctx->surface_height, 32) / 32;
+
+    av_log(avctx, AV_LOG_VERBOSE, "Input %ux%u -> Surface %ux%u -> CTU %ux%u.\n",
+           avctx->width, avctx->height, ctx->surface_width,
+           ctx->surface_height, priv->ctu_width, priv->ctu_height);
+
+    if (ctx->va_rc_mode == VA_RC_CQP) {
+        priv->fixed_qp_p = opt->qp;
+        if (avctx->i_quant_factor > 0.0)
+            priv->fixed_qp_idr = (int)((priv->fixed_qp_p * avctx->i_quant_factor +
+                                        avctx->i_quant_offset) + 0.5);
+        else
+            priv->fixed_qp_idr = priv->fixed_qp_p;
+        if (avctx->b_quant_factor > 0.0)
+            priv->fixed_qp_b = (int)((priv->fixed_qp_p * avctx->b_quant_factor +
+                                      avctx->b_quant_offset) + 0.5);
+        else
+            priv->fixed_qp_b = priv->fixed_qp_p;
+
+        av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
+               "%d / %d / %d for IDR- / P- / B-frames.\n",
+               priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
+
+    } else if (ctx->va_rc_mode == VA_RC_CBR ||
+               ctx->va_rc_mode == VA_RC_VBR) {
+        // These still need to be  set for pic_init_qp/slice_qp_delta.
+        priv->fixed_qp_idr = 30;
+        priv->fixed_qp_p   = 30;
+        priv->fixed_qp_b   = 30;
+
+        av_log(avctx, AV_LOG_DEBUG, "Using %s-bitrate = %"PRId64" bps.\n",
+               ctx->va_rc_mode == VA_RC_CBR ? "constant" : "variable",
+               avctx->bit_rate);
 
-    for (i = 0; i < FF_ARRAY_ELEMS(default_config_attributes); i++) {
-        ctx->config_attributes[ctx->nb_config_attributes++] =
-            default_config_attributes[i];
-    }
-
-    if (avctx->bit_rate > 0) {
-        ctx->va_rc_mode = VA_RC_CBR;
-        err = vaapi_encode_h265_init_constant_bitrate(avctx);
     } else {
-        ctx->va_rc_mode = VA_RC_CQP;
-        err = vaapi_encode_h265_init_fixed_qp(avctx);
+        av_assert0(0 && "Invalid RC mode.");
     }
-    if (err < 0)
-        return err;
-
-    ctx->config_attributes[ctx->nb_config_attributes++] = (VAConfigAttrib) {
-        .type  = VAConfigAttribRateControl,
-        .value = ctx->va_rc_mode,
-    };
-
-    ctx->nb_recon_frames = 20;
 
     return 0;
 }
 
-static VAAPIEncodeType vaapi_encode_type_h265 = {
+static const VAAPIEncodeType vaapi_encode_type_h265 = {
     .priv_data_size        = sizeof(VAAPIEncodeH265Context),
 
-    .init                  = &vaapi_encode_h265_init_internal,
+    .configure             = &vaapi_encode_h265_configure,
 
     .sequence_params_size  = sizeof(VAEncSequenceParameterBufferHEVC),
     .init_sequence_params  = &vaapi_encode_h265_init_sequence_params,
@@ -1323,7 +1226,49 @@ static VAAPIEncodeType vaapi_encode_type_h265 = {
 
 static av_cold int vaapi_encode_h265_init(AVCodecContext *avctx)
 {
-    return ff_vaapi_encode_init(avctx, &vaapi_encode_type_h265);
+    VAAPIEncodeContext *ctx = avctx->priv_data;
+
+    ctx->codec = &vaapi_encode_type_h265;
+
+    switch (avctx->profile) {
+    case FF_PROFILE_HEVC_MAIN:
+    case FF_PROFILE_UNKNOWN:
+        ctx->va_profile = VAProfileHEVCMain;
+        ctx->va_rt_format = VA_RT_FORMAT_YUV420;
+        break;
+    case FF_PROFILE_HEVC_MAIN_10:
+#ifdef VA_RT_FORMAT_YUV420_10BPP
+        ctx->va_profile = VAProfileHEVCMain10;
+        ctx->va_rt_format = VA_RT_FORMAT_YUV420_10BPP;
+        break;
+#else
+        av_log(avctx, AV_LOG_ERROR, "10-bit encoding is not "
+               "supported with this VAAPI version.\n");
+        return AVERROR(ENOSYS);
+#endif
+    default:
+        av_log(avctx, AV_LOG_ERROR, "Unknown H.265 profile %d.\n",
+               avctx->profile);
+        return AVERROR(EINVAL);
+    }
+    ctx->va_entrypoint = VAEntrypointEncSlice;
+
+    if (avctx->bit_rate > 0) {
+        if (avctx->rc_max_rate == avctx->bit_rate)
+            ctx->va_rc_mode = VA_RC_CBR;
+        else
+            ctx->va_rc_mode = VA_RC_VBR;
+    } else
+        ctx->va_rc_mode = VA_RC_CQP;
+
+    ctx->va_packed_headers =
+        VA_ENC_PACKED_HEADER_SEQUENCE | // VPS, SPS and PPS.
+        VA_ENC_PACKED_HEADER_SLICE;     // Slice headers.
+
+    ctx->surface_width  = FFALIGN(avctx->width,  16);
+    ctx->surface_height = FFALIGN(avctx->height, 16);
+
+    return ff_vaapi_encode_init(avctx);
 }
 
 #define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_encode_mjpeg.c b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_mjpeg.c
index 316b3595c82..2cbf7925f24 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_encode_mjpeg.c
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_mjpeg.c
@@ -277,8 +277,8 @@ static int vaapi_encode_mjpeg_init_picture_params(AVCodecContext *avctx,
     vpic->reconstructed_picture = pic->recon_surface;
     vpic->coded_buf = pic->output_buffer;
 
-    vpic->picture_width  = ctx->input_width;
-    vpic->picture_height = ctx->input_height;
+    vpic->picture_width  = avctx->width;
+    vpic->picture_height = avctx->height;
 
     vpic->pic_flags.bits.profile      = 0;
     vpic->pic_flags.bits.progressive  = 0;
@@ -333,31 +333,10 @@ static int vaapi_encode_mjpeg_init_slice_params(AVCodecContext *avctx,
     return 0;
 }
 
-static av_cold int vaapi_encode_mjpeg_init_internal(AVCodecContext *avctx)
+static av_cold int vaapi_encode_mjpeg_configure(AVCodecContext *avctx)
 {
-    static const VAConfigAttrib default_config_attributes[] = {
-        { .type  = VAConfigAttribRTFormat,
-          .value = VA_RT_FORMAT_YUV420 },
-        { .type  = VAConfigAttribEncPackedHeaders,
-          .value = VA_ENC_PACKED_HEADER_SEQUENCE },
-    };
-
     VAAPIEncodeContext       *ctx = avctx->priv_data;
     VAAPIEncodeMJPEGContext *priv = ctx->priv_data;
-    int i;
-
-    ctx->va_profile    = VAProfileJPEGBaseline;
-    ctx->va_entrypoint = VAEntrypointEncPicture;
-
-    ctx->input_width    = avctx->width;
-    ctx->input_height   = avctx->height;
-    ctx->aligned_width  = FFALIGN(ctx->input_width,  8);
-    ctx->aligned_height = FFALIGN(ctx->input_height, 8);
-
-    for (i = 0; i < FF_ARRAY_ELEMS(default_config_attributes); i++) {
-        ctx->config_attributes[ctx->nb_config_attributes++] =
-            default_config_attributes[i];
-    }
 
     priv->quality = avctx->global_quality;
     if (priv->quality < 1 || priv->quality > 100) {
@@ -366,15 +345,26 @@ static av_cold int vaapi_encode_mjpeg_init_internal(AVCodecContext *avctx)
         return AVERROR(EINVAL);
     }
 
+    // Hack: the implementation calls the JPEG image header (which we
+    // will use in the same way as a slice header) generic "raw data".
+    // Therefore, if after the packed header capability check we have
+    // PACKED_HEADER_RAW_DATA available, rewrite it as
+    // PACKED_HEADER_SLICE so that the header-writing code can do the
+    // right thing.
+    if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_RAW_DATA) {
+        ctx->va_packed_headers &= ~VA_ENC_PACKED_HEADER_RAW_DATA;
+        ctx->va_packed_headers |=  VA_ENC_PACKED_HEADER_SLICE;
+    }
+
     vaapi_encode_mjpeg_init_tables(avctx);
 
     return 0;
 }
 
-static VAAPIEncodeType vaapi_encode_type_mjpeg = {
+static const VAAPIEncodeType vaapi_encode_type_mjpeg = {
     .priv_data_size        = sizeof(VAAPIEncodeMJPEGContext),
 
-    .init                  = &vaapi_encode_mjpeg_init_internal,
+    .configure             = &vaapi_encode_mjpeg_configure,
 
     .picture_params_size   = sizeof(VAEncPictureParameterBufferJPEG),
     .init_picture_params   = &vaapi_encode_mjpeg_init_picture_params,
@@ -390,7 +380,25 @@ static VAAPIEncodeType vaapi_encode_type_mjpeg = {
 
 static av_cold int vaapi_encode_mjpeg_init(AVCodecContext *avctx)
 {
-    return ff_vaapi_encode_init(avctx, &vaapi_encode_type_mjpeg);
+    VAAPIEncodeContext *ctx = avctx->priv_data;
+
+    ctx->codec = &vaapi_encode_type_mjpeg;
+
+    ctx->va_profile    = VAProfileJPEGBaseline;
+    ctx->va_entrypoint = VAEntrypointEncPicture;
+
+    ctx->va_rt_format = VA_RT_FORMAT_YUV420;
+
+    ctx->va_rc_mode = VA_RC_CQP;
+
+    // The JPEG image header - see note above.
+    ctx->va_packed_headers =
+        VA_ENC_PACKED_HEADER_RAW_DATA;
+
+    ctx->surface_width  = FFALIGN(avctx->width,  8);
+    ctx->surface_height = FFALIGN(avctx->height, 8);
+
+    return ff_vaapi_encode_init(avctx);
 }
 
 static const AVCodecDefault vaapi_encode_mjpeg_defaults[] = {
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_encode_mpeg2.c b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_mpeg2.c
new file mode 100644
index 00000000000..dc918884e89
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_mpeg2.c
@@ -0,0 +1,470 @@
+/*
+ * 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 <va/va.h>
+#include <va/va_enc_mpeg2.h>
+
+#include "libavutil/avassert.h"
+#include "libavutil/common.h"
+#include "libavutil/internal.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixfmt.h"
+
+#include "avcodec.h"
+#include "internal.h"
+#include "mpegvideo.h"
+#include "put_bits.h"
+#include "vaapi_encode.h"
+
+typedef struct VAAPIEncodeMPEG2Context {
+    int mb_width;
+    int mb_height;
+
+    int quant_i;
+    int quant_p;
+    int quant_b;
+
+    int64_t last_i_frame;
+
+    unsigned int bit_rate;
+    unsigned int vbv_buffer_size;
+} VAAPIEncodeMPEG2Context;
+
+
+#define vseq_var(name)      vseq->name, name
+#define vseqext_field(name) vseq->sequence_extension.bits.name, name
+#define vgop_field(name)    vseq->gop_header.bits.name, name
+#define vpic_var(name)      vpic->name, name
+#define vpcext_field(name)  vpic->picture_coding_extension.bits.name, name
+#define vcomp_field(name)   vpic->composite_display.bits.name, name
+
+#define u2(width, value, name) put_bits(&pbc, width, value)
+#define u(width, ...) u2(width, __VA_ARGS__)
+
+static int vaapi_encode_mpeg2_write_sequence_header(AVCodecContext *avctx,
+                                                    char *data, size_t *data_len)
+{
+    VAAPIEncodeContext                 *ctx = avctx->priv_data;
+    VAEncSequenceParameterBufferMPEG2 *vseq = ctx->codec_sequence_params;
+    VAAPIEncodeMPEG2Context           *priv = ctx->priv_data;
+    PutBitContext pbc;
+
+    init_put_bits(&pbc, data, 8 * *data_len);
+
+    u(32, SEQ_START_CODE, sequence_header_code);
+
+    u(12, vseq->picture_width,  horizontal_size_value);
+    u(12, vseq->picture_height, vertical_size_value);
+    u(4, vseq_var(aspect_ratio_information));
+    u(4, 8, frame_rate_code);
+    u(18, priv->bit_rate & 0x3fff, bit_rate_value);
+    u(1, 1, marker_bit);
+    u(10, priv->vbv_buffer_size & 0x3ff, vbv_buffer_size_value);
+    u(1, 0, constrained_parameters_flag);
+    u(1, 0, load_intra_quantiser_matrix);
+    // intra_quantiser_matrix[64]
+    u(1, 0, load_non_intra_quantiser_matrix);
+    // non_intra_quantiser_matrix[64]
+
+    while (put_bits_count(&pbc) % 8)
+        u(1, 0, zero_bit);
+
+    u(32, EXT_START_CODE, extension_start_code);
+    u(4, 1, extension_start_code_identifier);
+    u(8, vseqext_field(profile_and_level_indication));
+    u(1, vseqext_field(progressive_sequence));
+    u(2, vseqext_field(chroma_format));
+    u(2, 0, horizontal_size_extension);
+    u(2, 0, vertical_size_extension);
+    u(12, priv->bit_rate >> 18, bit_rate_extension);
+    u(1, 1, marker_bit);
+    u(8, priv->vbv_buffer_size >> 10, vbv_buffer_size_extension);
+    u(1, vseqext_field(low_delay));
+    u(2, vseqext_field(frame_rate_extension_n));
+    u(2, vseqext_field(frame_rate_extension_d));
+
+    while (put_bits_count(&pbc) % 8)
+        u(1, 0, zero_bit);
+
+    u(32, GOP_START_CODE, group_start_code);
+    u(25, vgop_field(time_code));
+    u(1, vgop_field(closed_gop));
+    u(1, vgop_field(broken_link));
+
+    while (put_bits_count(&pbc) % 8)
+        u(1, 0, zero_bit);
+
+    *data_len = put_bits_count(&pbc);
+    flush_put_bits(&pbc);
+
+    return 0;
+}
+
+static int vaapi_encode_mpeg2_write_picture_header(AVCodecContext *avctx,
+                                                   VAAPIEncodePicture *pic,
+                                                   char *data, size_t *data_len)
+{
+    VAEncPictureParameterBufferMPEG2 *vpic = pic->codec_picture_params;
+    int picture_coding_type;
+    PutBitContext pbc;
+
+    init_put_bits(&pbc, data, 8 * *data_len);
+
+    u(32, PICTURE_START_CODE, picture_start_code);
+    u(10, vpic_var(temporal_reference));
+
+    switch (vpic->picture_type) {
+    case VAEncPictureTypeIntra:
+        picture_coding_type = AV_PICTURE_TYPE_I;
+        break;
+    case VAEncPictureTypePredictive:
+        picture_coding_type = AV_PICTURE_TYPE_P;
+        break;
+    case VAEncPictureTypeBidirectional:
+        picture_coding_type = AV_PICTURE_TYPE_B;
+        break;
+    default:
+        av_assert0(0 && "invalid picture_coding_type");
+    }
+    u(3, picture_coding_type, picture_coding_type);
+    u(16, 0xffff, vbv_delay);
+    if (picture_coding_type == 2 || picture_coding_type == 3) {
+        u(1, 0, full_pel_forward_vector);
+        u(3, 7, forward_f_code);
+    }
+    if (picture_coding_type == 3) {
+        u(1, 0, full_pel_backward_vector);
+        u(3, 7, backward_f_code);
+    }
+    u(1, 0, extra_bit_picture);
+
+    while (put_bits_count(&pbc) % 8)
+        u(1, 0, zero_bit);
+
+    u(32, EXT_START_CODE, extension_start_code);
+    u(4, 8, extension_start_code_identifier);
+    u(4, vpic_var(f_code[0][0]));
+    u(4, vpic_var(f_code[0][1]));
+    u(4, vpic_var(f_code[1][0]));
+    u(4, vpic_var(f_code[1][1]));
+    u(2, vpcext_field(intra_dc_precision));
+    u(2, vpcext_field(picture_structure));
+    u(1, vpcext_field(top_field_first));
+    u(1, vpcext_field(frame_pred_frame_dct));
+    u(1, vpcext_field(concealment_motion_vectors));
+    u(1, vpcext_field(q_scale_type));
+    u(1, vpcext_field(intra_vlc_format));
+    u(1, vpcext_field(alternate_scan));
+    u(1, vpcext_field(repeat_first_field));
+    u(1, 1, chroma_420_type);
+    u(1, vpcext_field(progressive_frame));
+    u(1, vpcext_field(composite_display_flag));
+    if (vpic->picture_coding_extension.bits.composite_display_flag) {
+        u(1, vcomp_field(v_axis));
+        u(3, vcomp_field(field_sequence));
+        u(1, vcomp_field(sub_carrier));
+        u(7, vcomp_field(burst_amplitude));
+        u(8, vcomp_field(sub_carrier_phase));
+    }
+
+    while (put_bits_count(&pbc) % 8)
+        u(1, 0, zero_bit);
+
+    *data_len = put_bits_count(&pbc);
+    flush_put_bits(&pbc);
+
+    return 0;
+}
+
+static int vaapi_encode_mpeg2_init_sequence_params(AVCodecContext *avctx)
+{
+    VAAPIEncodeContext                 *ctx = avctx->priv_data;
+    VAEncSequenceParameterBufferMPEG2 *vseq = ctx->codec_sequence_params;
+    VAEncPictureParameterBufferMPEG2  *vpic = ctx->codec_picture_params;
+    VAAPIEncodeMPEG2Context           *priv = ctx->priv_data;
+
+    vseq->intra_period   = avctx->gop_size;
+    vseq->ip_period      = ctx->b_per_p + 1;
+
+    vseq->picture_width  = avctx->width;
+    vseq->picture_height = avctx->height;
+
+    vseq->bits_per_second = avctx->bit_rate;
+    if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
+        vseq->frame_rate = (float)avctx->framerate.num / avctx->framerate.den;
+    else
+        vseq->frame_rate = (float)avctx->time_base.den / avctx->time_base.num;
+
+    vseq->aspect_ratio_information = 1;
+    vseq->vbv_buffer_size = avctx->rc_buffer_size / (16 * 1024);
+
+    vseq->sequence_extension.bits.profile_and_level_indication =
+        avctx->profile << 4 | avctx->level;
+    vseq->sequence_extension.bits.progressive_sequence   = 1;
+    vseq->sequence_extension.bits.chroma_format          = 1;
+    vseq->sequence_extension.bits.low_delay              = 0;
+    vseq->sequence_extension.bits.frame_rate_extension_n = 0;
+    vseq->sequence_extension.bits.frame_rate_extension_d = 0;
+
+    vseq->new_gop_header              = 0;
+    vseq->gop_header.bits.time_code   = 0;
+    vseq->gop_header.bits.closed_gop  = 1;
+    vseq->gop_header.bits.broken_link = 0;
+
+    vpic->forward_reference_picture  = VA_INVALID_ID;
+    vpic->backward_reference_picture = VA_INVALID_ID;
+    vpic->reconstructed_picture      = VA_INVALID_ID;
+
+    vpic->coded_buf = VA_INVALID_ID;
+
+    vpic->temporal_reference = 0;
+    vpic->f_code[0][0] = 15;
+    vpic->f_code[0][1] = 15;
+    vpic->f_code[1][0] = 15;
+    vpic->f_code[1][1] = 15;
+
+    vpic->picture_coding_extension.bits.intra_dc_precision     = 0;
+    vpic->picture_coding_extension.bits.picture_structure      = 3;
+    vpic->picture_coding_extension.bits.top_field_first        = 0;
+    vpic->picture_coding_extension.bits.frame_pred_frame_dct   = 1;
+    vpic->picture_coding_extension.bits.concealment_motion_vectors = 0;
+    vpic->picture_coding_extension.bits.q_scale_type           = 0;
+    vpic->picture_coding_extension.bits.intra_vlc_format       = 0;
+    vpic->picture_coding_extension.bits.alternate_scan         = 0;
+    vpic->picture_coding_extension.bits.repeat_first_field     = 0;
+    vpic->picture_coding_extension.bits.progressive_frame      = 1;
+    vpic->picture_coding_extension.bits.composite_display_flag = 0;
+
+    priv->bit_rate = (avctx->bit_rate + 399) / 400;
+    priv->vbv_buffer_size = avctx->rc_buffer_size / (16 * 1024);
+
+    return 0;
+}
+
+static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx,
+                                                 VAAPIEncodePicture *pic)
+{
+    VAAPIEncodeContext                *ctx = avctx->priv_data;
+    VAEncPictureParameterBufferMPEG2 *vpic = pic->codec_picture_params;
+    VAAPIEncodeMPEG2Context          *priv = ctx->priv_data;
+    int fch, fcv;
+
+    switch (avctx->level) {
+    case 4: // High.
+    case 6: // High 1440.
+        fch = 9;
+        fcv = 5;
+        break;
+    case 8: // Main.
+        fch = 8;
+        fcv = 5;
+        break;
+    case 10: // Low.
+    default:
+        fch = 7;
+        fcv = 4;
+        break;
+    }
+
+    switch (pic->type) {
+    case PICTURE_TYPE_IDR:
+    case PICTURE_TYPE_I:
+        vpic->picture_type = VAEncPictureTypeIntra;
+        priv->last_i_frame = pic->display_order;
+        break;
+    case PICTURE_TYPE_P:
+        vpic->picture_type = VAEncPictureTypePredictive;
+        vpic->forward_reference_picture = pic->refs[0]->recon_surface;
+        vpic->f_code[0][0] = fch;
+        vpic->f_code[0][1] = fcv;
+        break;
+    case PICTURE_TYPE_B:
+        vpic->picture_type = VAEncPictureTypeBidirectional;
+        vpic->forward_reference_picture  = pic->refs[0]->recon_surface;
+        vpic->backward_reference_picture = pic->refs[1]->recon_surface;
+        vpic->f_code[0][0] = fch;
+        vpic->f_code[0][1] = fcv;
+        vpic->f_code[1][0] = fch;
+        vpic->f_code[1][1] = fcv;
+        break;
+    default:
+        av_assert0(0 && "invalid picture type");
+    }
+
+    vpic->reconstructed_picture = pic->recon_surface;
+    vpic->coded_buf = pic->output_buffer;
+
+    vpic->temporal_reference = pic->display_order - priv->last_i_frame;
+
+    pic->nb_slices = priv->mb_height;
+
+    return 0;
+}
+
+static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx,
+                                               VAAPIEncodePicture *pic,
+                                               VAAPIEncodeSlice *slice)
+{
+    VAAPIEncodeContext                  *ctx = avctx->priv_data;
+    VAEncSliceParameterBufferMPEG2   *vslice = slice->codec_slice_params;
+    VAAPIEncodeMPEG2Context            *priv = ctx->priv_data;
+    int qp;
+
+    vslice->macroblock_address = priv->mb_width * slice->index;
+    vslice->num_macroblocks    = priv->mb_width;
+
+    switch (pic->type) {
+    case PICTURE_TYPE_IDR:
+    case PICTURE_TYPE_I:
+        qp = priv->quant_i;
+        break;
+    case PICTURE_TYPE_P:
+        qp = priv->quant_p;
+        break;
+    case PICTURE_TYPE_B:
+        qp = priv->quant_b;
+        break;
+    default:
+        av_assert0(0 && "invalid picture type");
+    }
+
+    vslice->quantiser_scale_code = qp;
+    vslice->is_intra_slice = (pic->type == PICTURE_TYPE_IDR ||
+                              pic->type == PICTURE_TYPE_I);
+
+    return 0;
+}
+
+static av_cold int vaapi_encode_mpeg2_configure(AVCodecContext *avctx)
+{
+    VAAPIEncodeContext       *ctx = avctx->priv_data;
+    VAAPIEncodeMPEG2Context *priv = ctx->priv_data;
+
+    priv->mb_width  = FFALIGN(avctx->width,  16) / 16;
+    priv->mb_height = FFALIGN(avctx->height, 16) / 16;
+
+    if (ctx->va_rc_mode == VA_RC_CQP) {
+        priv->quant_p = av_clip(avctx->global_quality, 1, 31);
+        if (avctx->i_quant_factor > 0.0)
+            priv->quant_i = av_clip((avctx->global_quality *
+                                     avctx->i_quant_factor +
+                                     avctx->i_quant_offset) + 0.5,
+                                    1, 31);
+        else
+            priv->quant_i = priv->quant_p;
+        if (avctx->b_quant_factor > 0.0)
+            priv->quant_b = av_clip((avctx->global_quality *
+                                     avctx->b_quant_factor +
+                                     avctx->b_quant_offset) + 0.5,
+                                    1, 31);
+        else
+            priv->quant_b = priv->quant_p;
+
+        av_log(avctx, AV_LOG_DEBUG, "Using fixed quantiser "
+               "%d / %d / %d for I- / P- / B-frames.\n",
+               priv->quant_i, priv->quant_p, priv->quant_b);
+
+    } else {
+        av_assert0(0 && "Invalid RC mode.");
+    }
+
+    return 0;
+}
+
+static const VAAPIEncodeType vaapi_encode_type_mpeg2 = {
+    .priv_data_size        = sizeof(VAAPIEncodeMPEG2Context),
+
+    .configure             = &vaapi_encode_mpeg2_configure,
+
+    .sequence_params_size  = sizeof(VAEncSequenceParameterBufferMPEG2),
+    .init_sequence_params  = &vaapi_encode_mpeg2_init_sequence_params,
+
+    .picture_params_size   = sizeof(VAEncPictureParameterBufferMPEG2),
+    .init_picture_params   = &vaapi_encode_mpeg2_init_picture_params,
+
+    .slice_params_size     = sizeof(VAEncSliceParameterBufferMPEG2),
+    .init_slice_params     = &vaapi_encode_mpeg2_init_slice_params,
+
+    .sequence_header_type  = VAEncPackedHeaderSequence,
+    .write_sequence_header = &vaapi_encode_mpeg2_write_sequence_header,
+
+    .picture_header_type   = VAEncPackedHeaderPicture,
+    .write_picture_header  = &vaapi_encode_mpeg2_write_picture_header,
+};
+
+static av_cold int vaapi_encode_mpeg2_init(AVCodecContext *avctx)
+{
+    VAAPIEncodeContext *ctx = avctx->priv_data;
+
+    ctx->codec = &vaapi_encode_type_mpeg2;
+
+    switch (avctx->profile) {
+    case FF_PROFILE_MPEG2_SIMPLE:
+        ctx->va_profile = VAProfileMPEG2Simple;
+        break;
+    case FF_PROFILE_MPEG2_MAIN:
+        ctx->va_profile = VAProfileMPEG2Main;
+        break;
+    default:
+        av_log(avctx, AV_LOG_ERROR, "Unknown MPEG-2 profile %d.\n",
+               avctx->profile);
+        return AVERROR(EINVAL);
+    }
+
+    ctx->va_entrypoint = VAEntrypointEncSlice;
+    ctx->va_rt_format  = VA_RT_FORMAT_YUV420;
+    ctx->va_rc_mode    = VA_RC_CQP;
+
+    ctx->va_packed_headers = VA_ENC_PACKED_HEADER_SEQUENCE |
+                             VA_ENC_PACKED_HEADER_PICTURE;
+
+    ctx->surface_width  = FFALIGN(avctx->width,  16);
+    ctx->surface_height = FFALIGN(avctx->height, 16);
+
+    return ff_vaapi_encode_init(avctx);
+}
+
+static const AVCodecDefault vaapi_encode_mpeg2_defaults[] = {
+    { "profile",        "4"   },
+    { "level",          "4"   },
+    { "bf",             "1"   },
+    { "g",              "120" },
+    { "i_qfactor",      "1"   },
+    { "i_qoffset",      "0"   },
+    { "b_qfactor",      "6/5" },
+    { "b_qoffset",      "0"   },
+    { "global_quality", "10"  },
+    { NULL },
+};
+
+AVCodec ff_mpeg2_vaapi_encoder = {
+    .name           = "mpeg2_vaapi",
+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 (VAAPI)"),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_MPEG2VIDEO,
+    .priv_data_size = sizeof(VAAPIEncodeContext),
+    .init           = &vaapi_encode_mpeg2_init,
+    .encode2        = &ff_vaapi_encode2,
+    .close          = &ff_vaapi_encode_close,
+    .capabilities   = AV_CODEC_CAP_DELAY,
+    .defaults       = vaapi_encode_mpeg2_defaults,
+    .pix_fmts = (const enum AVPixelFormat[]) {
+        AV_PIX_FMT_VAAPI,
+        AV_PIX_FMT_NONE,
+    },
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_encode_vp8.c b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_vp8.c
new file mode 100644
index 00000000000..423f7483e88
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_vp8.c
@@ -0,0 +1,269 @@
+/*
+ * 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 <va/va.h>
+#include <va/va_enc_vp8.h>
+
+#include "libavutil/avassert.h"
+#include "libavutil/common.h"
+#include "libavutil/internal.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixfmt.h"
+
+#include "avcodec.h"
+#include "internal.h"
+#include "vaapi_encode.h"
+#include "vp8.h"
+
+
+typedef struct VAAPIEncodeVP8Context {
+    int q_index_i;
+    int q_index_p;
+} VAAPIEncodeVP8Context;
+
+typedef struct VAAPIEncodeVP8Options {
+    int loop_filter_level;
+    int loop_filter_sharpness;
+} VAAPIEncodeVP8Options;
+
+
+#define vseq_var(name)     vseq->name, name
+#define vseq_field(name)   vseq->seq_fields.bits.name, name
+#define vpic_var(name)     vpic->name, name
+#define vpic_field(name)   vpic->pic_fields.bits.name, name
+
+
+static int vaapi_encode_vp8_init_sequence_params(AVCodecContext *avctx)
+{
+    VAAPIEncodeContext               *ctx = avctx->priv_data;
+    VAEncSequenceParameterBufferVP8 *vseq = ctx->codec_sequence_params;
+
+    vseq->frame_width  = avctx->width;
+    vseq->frame_height = avctx->height;
+
+    vseq->frame_width_scale  = 0;
+    vseq->frame_height_scale = 0;
+
+    vseq->error_resilient = 0;
+    vseq->kf_auto = 0;
+
+    if (!(ctx->va_rc_mode & VA_RC_CQP)) {
+        vseq->bits_per_second = avctx->bit_rate;
+        vseq->intra_period    = avctx->gop_size;
+    }
+
+    return 0;
+}
+
+static int vaapi_encode_vp8_init_picture_params(AVCodecContext *avctx,
+                                                VAAPIEncodePicture *pic)
+{
+    VAAPIEncodeContext              *ctx = avctx->priv_data;
+    VAEncPictureParameterBufferVP8 *vpic = pic->codec_picture_params;
+    VAAPIEncodeVP8Options           *opt = ctx->codec_options;
+    int i;
+
+    vpic->reconstructed_frame = pic->recon_surface;
+
+    vpic->coded_buf = pic->output_buffer;
+
+    switch (pic->type) {
+    case PICTURE_TYPE_IDR:
+    case PICTURE_TYPE_I:
+        av_assert0(pic->nb_refs == 0);
+        vpic->ref_flags.bits.force_kf = 1;
+        vpic->ref_last_frame =
+        vpic->ref_gf_frame   =
+        vpic->ref_arf_frame  =
+            VA_INVALID_SURFACE;
+        break;
+    case PICTURE_TYPE_P:
+        av_assert0(pic->nb_refs == 1);
+        vpic->ref_flags.bits.no_ref_last = 0;
+        vpic->ref_flags.bits.no_ref_gf   = 1;
+        vpic->ref_flags.bits.no_ref_arf  = 1;
+        vpic->ref_last_frame =
+        vpic->ref_gf_frame   =
+        vpic->ref_arf_frame  =
+            pic->refs[0]->recon_surface;
+        break;
+    default:
+        av_assert0(0 && "invalid picture type");
+    }
+
+    vpic->pic_flags.bits.frame_type = (pic->type != PICTURE_TYPE_IDR);
+    vpic->pic_flags.bits.show_frame = 1;
+
+    vpic->pic_flags.bits.refresh_last            = 1;
+    vpic->pic_flags.bits.refresh_golden_frame    = 1;
+    vpic->pic_flags.bits.refresh_alternate_frame = 1;
+
+    vpic->pic_flags.bits.version = 0;
+    vpic->pic_flags.bits.loop_filter_type = 0;
+    for (i = 0; i < 4; i++)
+        vpic->loop_filter_level[i] = opt->loop_filter_level;
+    vpic->sharpness_level = opt->loop_filter_sharpness;
+
+    vpic->clamp_qindex_low  = 0;
+    vpic->clamp_qindex_high = 127;
+
+    return 0;
+}
+
+static int vaapi_encode_vp8_write_quant_table(AVCodecContext *avctx,
+                                              VAAPIEncodePicture *pic,
+                                              int index, int *type,
+                                              char *data, size_t *data_len)
+{
+    VAAPIEncodeContext     *ctx = avctx->priv_data;
+    VAAPIEncodeVP8Context *priv = ctx->priv_data;
+    VAQMatrixBufferVP8 quant;
+    int i, q;
+
+    if (index > 0)
+        return AVERROR_EOF;
+
+    if (*data_len < sizeof(quant))
+        return AVERROR(EINVAL);
+    *type     = VAQMatrixBufferType;
+    *data_len = sizeof(quant);
+
+    if (pic->type == PICTURE_TYPE_P)
+        q = priv->q_index_p;
+    else
+        q = priv->q_index_i;
+
+    for (i = 0; i < 4; i++)
+        quant.quantization_index[i] = q;
+    for (i = 0; i < 5; i++)
+        quant.quantization_index_delta[i] = 0;
+
+    memcpy(data, &quant, sizeof(quant));
+    return 0;
+}
+
+static av_cold int vaapi_encode_vp8_configure(AVCodecContext *avctx)
+{
+    VAAPIEncodeContext     *ctx = avctx->priv_data;
+    VAAPIEncodeVP8Context *priv = ctx->priv_data;
+
+    priv->q_index_p = av_clip(avctx->global_quality, 0, VP8_MAX_QUANT);
+    if (avctx->i_quant_factor > 0.0)
+        priv->q_index_i = av_clip((avctx->global_quality *
+                                   avctx->i_quant_factor +
+                                   avctx->i_quant_offset) + 0.5,
+                                  0, VP8_MAX_QUANT);
+    else
+        priv->q_index_i = priv->q_index_p;
+
+    return 0;
+}
+
+static const VAAPIEncodeType vaapi_encode_type_vp8 = {
+    .configure             = &vaapi_encode_vp8_configure,
+
+    .priv_data_size        = sizeof(VAAPIEncodeVP8Context),
+
+    .sequence_params_size  = sizeof(VAEncSequenceParameterBufferVP8),
+    .init_sequence_params  = &vaapi_encode_vp8_init_sequence_params,
+
+    .picture_params_size   = sizeof(VAEncPictureParameterBufferVP8),
+    .init_picture_params   = &vaapi_encode_vp8_init_picture_params,
+
+    .write_extra_buffer    = &vaapi_encode_vp8_write_quant_table,
+};
+
+static av_cold int vaapi_encode_vp8_init(AVCodecContext *avctx)
+{
+    VAAPIEncodeContext *ctx = avctx->priv_data;
+
+    if (avctx->max_b_frames > 0) {
+        av_log(avctx, AV_LOG_ERROR, "B-frames are not supported.\n");
+        return AVERROR_PATCHWELCOME;
+    }
+
+    ctx->codec = &vaapi_encode_type_vp8;
+
+    ctx->va_profile    = VAProfileVP8Version0_3;
+    ctx->va_entrypoint = VAEntrypointEncSlice;
+    ctx->va_rt_format  = VA_RT_FORMAT_YUV420;
+
+    if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
+        ctx->va_rc_mode = VA_RC_CQP;
+    } else if (avctx->bit_rate > 0) {
+        if (avctx->rc_max_rate == avctx->bit_rate)
+            ctx->va_rc_mode = VA_RC_CBR;
+        else
+            ctx->va_rc_mode = VA_RC_VBR;
+    } else {
+        ctx->va_rc_mode = VA_RC_CQP;
+    }
+
+    // Packed headers are not currently supported.
+    ctx->va_packed_headers = 0;
+
+    ctx->surface_width  = FFALIGN(avctx->width,  16);
+    ctx->surface_height = FFALIGN(avctx->height, 16);
+
+    return ff_vaapi_encode_init(avctx);
+}
+
+#define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \
+                   offsetof(VAAPIEncodeVP8Options, x))
+#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
+static const AVOption vaapi_encode_vp8_options[] = {
+    { "loop_filter_level", "Loop filter level",
+      OFFSET(loop_filter_level), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, 63, FLAGS },
+    { "loop_filter_sharpness", "Loop filter sharpness",
+      OFFSET(loop_filter_sharpness), AV_OPT_TYPE_INT, { .i64 = 4 }, 0, 15, FLAGS },
+    { NULL },
+};
+
+static const AVCodecDefault vaapi_encode_vp8_defaults[] = {
+    { "b",              "0"   },
+    { "bf",             "0"   },
+    { "g",              "120" },
+    { "global_quality", "40"  },
+    { NULL },
+};
+
+static const AVClass vaapi_encode_vp8_class = {
+    .class_name = "vp8_vaapi",
+    .item_name  = av_default_item_name,
+    .option     = vaapi_encode_vp8_options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVCodec ff_vp8_vaapi_encoder = {
+    .name           = "vp8_vaapi",
+    .long_name      = NULL_IF_CONFIG_SMALL("VP8 (VAAPI)"),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_VP8,
+    .priv_data_size = (sizeof(VAAPIEncodeContext) +
+                       sizeof(VAAPIEncodeVP8Options)),
+    .init           = &vaapi_encode_vp8_init,
+    .encode2        = &ff_vaapi_encode2,
+    .close          = &ff_vaapi_encode_close,
+    .priv_class     = &vaapi_encode_vp8_class,
+    .capabilities   = AV_CODEC_CAP_DELAY,
+    .defaults       = vaapi_encode_vp8_defaults,
+    .pix_fmts = (const enum AVPixelFormat[]) {
+        AV_PIX_FMT_VAAPI,
+        AV_PIX_FMT_NONE,
+    },
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_encode_vp9.c b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_vp9.c
new file mode 100644
index 00000000000..a987d1cd719
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_encode_vp9.c
@@ -0,0 +1,313 @@
+/*
+ * 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 <va/va.h>
+#include <va/va_enc_vp9.h>
+
+#include "libavutil/avassert.h"
+#include "libavutil/common.h"
+#include "libavutil/internal.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixfmt.h"
+
+#include "avcodec.h"
+#include "internal.h"
+#include "vaapi_encode.h"
+
+#define VP9_MAX_QUANT 255
+
+
+typedef struct VAAPIEncodeVP9Context {
+    int q_idx_idr;
+    int q_idx_p;
+    int q_idx_b;
+
+    // Reference direction for B-like frames:
+    // 0 - most recent P/IDR frame is last.
+    // 1 - most recent P frame is golden.
+    int last_ref_dir;
+} VAAPIEncodeVP9Context;
+
+typedef struct VAAPIEncodeVP9Options {
+    int loop_filter_level;
+    int loop_filter_sharpness;
+} VAAPIEncodeVP9Options;
+
+
+#define vseq_var(name)     vseq->name, name
+#define vseq_field(name)   vseq->seq_fields.bits.name, name
+#define vpic_var(name)     vpic->name, name
+#define vpic_field(name)   vpic->pic_fields.bits.name, name
+
+
+static int vaapi_encode_vp9_init_sequence_params(AVCodecContext *avctx)
+{
+    VAAPIEncodeContext               *ctx = avctx->priv_data;
+    VAEncSequenceParameterBufferVP9 *vseq = ctx->codec_sequence_params;
+    VAEncPictureParameterBufferVP9  *vpic = ctx->codec_picture_params;
+
+    vseq->max_frame_width  = avctx->width;
+    vseq->max_frame_height = avctx->height;
+
+    vseq->kf_auto = 0;
+
+    if (!(ctx->va_rc_mode & VA_RC_CQP)) {
+        vseq->bits_per_second = avctx->bit_rate;
+        vseq->intra_period    = avctx->gop_size;
+    }
+
+    vpic->frame_width_src  = avctx->width;
+    vpic->frame_height_src = avctx->height;
+    vpic->frame_width_dst  = avctx->width;
+    vpic->frame_height_dst = avctx->height;
+
+    return 0;
+}
+
+static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx,
+                                                VAAPIEncodePicture *pic)
+{
+    VAAPIEncodeContext              *ctx = avctx->priv_data;
+    VAEncPictureParameterBufferVP9 *vpic = pic->codec_picture_params;
+    VAAPIEncodeVP9Context          *priv = ctx->priv_data;
+    VAAPIEncodeVP9Options           *opt = ctx->codec_options;
+    int i;
+
+    vpic->reconstructed_frame = pic->recon_surface;
+    vpic->coded_buf = pic->output_buffer;
+
+    switch (pic->type) {
+    case PICTURE_TYPE_IDR:
+        av_assert0(pic->nb_refs == 0);
+        vpic->ref_flags.bits.force_kf = 1;
+        vpic->refresh_frame_flags = 0x01;
+        priv->last_ref_dir = 0;
+        break;
+    case PICTURE_TYPE_P:
+        av_assert0(pic->nb_refs == 1);
+        if (avctx->max_b_frames > 0) {
+            if (priv->last_ref_dir) {
+                vpic->ref_flags.bits.ref_frame_ctrl_l0  = 2;
+                vpic->ref_flags.bits.ref_gf_idx         = 1;
+                vpic->ref_flags.bits.ref_gf_sign_bias   = 1;
+                vpic->refresh_frame_flags = 0x01;
+            } else {
+                vpic->ref_flags.bits.ref_frame_ctrl_l0  = 1;
+                vpic->ref_flags.bits.ref_last_idx       = 0;
+                vpic->ref_flags.bits.ref_last_sign_bias = 1;
+                vpic->refresh_frame_flags = 0x02;
+            }
+        } else {
+            vpic->ref_flags.bits.ref_frame_ctrl_l0  = 1;
+            vpic->ref_flags.bits.ref_last_idx       = 0;
+            vpic->ref_flags.bits.ref_last_sign_bias = 1;
+            vpic->refresh_frame_flags = 0x01;
+        }
+        break;
+    case PICTURE_TYPE_B:
+        av_assert0(pic->nb_refs == 2);
+        if (priv->last_ref_dir) {
+            vpic->ref_flags.bits.ref_frame_ctrl_l0  = 1;
+            vpic->ref_flags.bits.ref_frame_ctrl_l1  = 2;
+            vpic->ref_flags.bits.ref_last_idx       = 0;
+            vpic->ref_flags.bits.ref_last_sign_bias = 1;
+            vpic->ref_flags.bits.ref_gf_idx         = 1;
+            vpic->ref_flags.bits.ref_gf_sign_bias   = 0;
+        } else {
+            vpic->ref_flags.bits.ref_frame_ctrl_l0  = 2;
+            vpic->ref_flags.bits.ref_frame_ctrl_l1  = 1;
+            vpic->ref_flags.bits.ref_last_idx       = 0;
+            vpic->ref_flags.bits.ref_last_sign_bias = 0;
+            vpic->ref_flags.bits.ref_gf_idx         = 1;
+            vpic->ref_flags.bits.ref_gf_sign_bias   = 1;
+        }
+        vpic->refresh_frame_flags = 0x00;
+        break;
+    default:
+        av_assert0(0 && "invalid picture type");
+    }
+
+    for (i = 0; i < FF_ARRAY_ELEMS(vpic->reference_frames); i++)
+        vpic->reference_frames[i] = VA_INVALID_SURFACE;
+    if (pic->type == PICTURE_TYPE_P) {
+        av_assert0(pic->refs[0]);
+        vpic->reference_frames[priv->last_ref_dir] =
+            pic->refs[0]->recon_surface;
+    } else if (pic->type == PICTURE_TYPE_B) {
+        av_assert0(pic->refs[0] && pic->refs[1]);
+        vpic->reference_frames[!priv->last_ref_dir] =
+            pic->refs[0]->recon_surface;
+        vpic->reference_frames[priv->last_ref_dir] =
+            pic->refs[1]->recon_surface;
+    }
+
+    vpic->pic_flags.bits.frame_type = (pic->type != PICTURE_TYPE_IDR);
+    vpic->pic_flags.bits.show_frame = pic->display_order <= pic->encode_order;
+
+    if (pic->type == PICTURE_TYPE_IDR)
+        vpic->luma_ac_qindex     = priv->q_idx_idr;
+    else if (pic->type == PICTURE_TYPE_P)
+        vpic->luma_ac_qindex     = priv->q_idx_p;
+    else
+        vpic->luma_ac_qindex     = priv->q_idx_b;
+    vpic->luma_dc_qindex_delta   = 0;
+    vpic->chroma_ac_qindex_delta = 0;
+    vpic->chroma_dc_qindex_delta = 0;
+
+    vpic->filter_level    = opt->loop_filter_level;
+    vpic->sharpness_level = opt->loop_filter_sharpness;
+
+    if (avctx->max_b_frames > 0 && pic->type == PICTURE_TYPE_P)
+        priv->last_ref_dir = !priv->last_ref_dir;
+
+    return 0;
+}
+
+static av_cold int vaapi_encode_vp9_configure(AVCodecContext *avctx)
+{
+    VAAPIEncodeContext     *ctx = avctx->priv_data;
+    VAAPIEncodeVP9Context *priv = ctx->priv_data;
+
+    priv->q_idx_p = av_clip(avctx->global_quality, 0, VP9_MAX_QUANT);
+    if (avctx->i_quant_factor > 0.0)
+        priv->q_idx_idr = av_clip((avctx->global_quality *
+                                   avctx->i_quant_factor +
+                                   avctx->i_quant_offset) + 0.5,
+                                  0, VP9_MAX_QUANT);
+    else
+        priv->q_idx_idr = priv->q_idx_p;
+    if (avctx->b_quant_factor > 0.0)
+        priv->q_idx_b = av_clip((avctx->global_quality *
+                                 avctx->b_quant_factor +
+                                 avctx->b_quant_offset) + 0.5,
+                                0, VP9_MAX_QUANT);
+    else
+        priv->q_idx_b = priv->q_idx_p;
+
+    return 0;
+}
+
+static const VAAPIEncodeType vaapi_encode_type_vp9 = {
+    .configure             = &vaapi_encode_vp9_configure,
+
+    .priv_data_size        = sizeof(VAAPIEncodeVP9Context),
+
+    .sequence_params_size  = sizeof(VAEncSequenceParameterBufferVP9),
+    .init_sequence_params  = &vaapi_encode_vp9_init_sequence_params,
+
+    .picture_params_size   = sizeof(VAEncPictureParameterBufferVP9),
+    .init_picture_params   = &vaapi_encode_vp9_init_picture_params,
+};
+
+static av_cold int vaapi_encode_vp9_init(AVCodecContext *avctx)
+{
+    VAAPIEncodeContext *ctx = avctx->priv_data;
+
+    ctx->codec = &vaapi_encode_type_vp9;
+
+    switch (avctx->profile) {
+    case FF_PROFILE_VP9_0:
+    case FF_PROFILE_UNKNOWN:
+        ctx->va_profile = VAProfileVP9Profile0;
+        ctx->va_rt_format = VA_RT_FORMAT_YUV420;
+        break;
+    case FF_PROFILE_VP9_1:
+        av_log(avctx, AV_LOG_ERROR, "VP9 profile 1 is not "
+               "supported.\n");
+        return AVERROR_PATCHWELCOME;
+    case FF_PROFILE_VP9_2:
+        ctx->va_profile = VAProfileVP9Profile2;
+        ctx->va_rt_format = VA_RT_FORMAT_YUV420_10BPP;
+        break;
+    case FF_PROFILE_VP9_3:
+        av_log(avctx, AV_LOG_ERROR, "VP9 profile 3 is not "
+               "supported.\n");
+        return AVERROR_PATCHWELCOME;
+    default:
+        av_log(avctx, AV_LOG_ERROR, "Unknown VP9 profile %d.\n",
+               avctx->profile);
+        return AVERROR(EINVAL);
+    }
+    ctx->va_entrypoint = VAEntrypointEncSlice;
+
+    if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
+        ctx->va_rc_mode = VA_RC_CQP;
+    } else if (avctx->bit_rate > 0) {
+        if (avctx->bit_rate == avctx->rc_max_rate)
+            ctx->va_rc_mode = VA_RC_CBR;
+        else
+            ctx->va_rc_mode = VA_RC_VBR;
+    } else {
+        ctx->va_rc_mode = VA_RC_CQP;
+    }
+
+    // Packed headers are not currently supported.
+    ctx->va_packed_headers = 0;
+
+    // Surfaces must be aligned to superblock boundaries.
+    ctx->surface_width  = FFALIGN(avctx->width,  64);
+    ctx->surface_height = FFALIGN(avctx->height, 64);
+
+    return ff_vaapi_encode_init(avctx);
+}
+
+#define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \
+                   offsetof(VAAPIEncodeVP9Options, x))
+#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
+static const AVOption vaapi_encode_vp9_options[] = {
+    { "loop_filter_level", "Loop filter level",
+      OFFSET(loop_filter_level), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, 63, FLAGS },
+    { "loop_filter_sharpness", "Loop filter sharpness",
+      OFFSET(loop_filter_sharpness), AV_OPT_TYPE_INT, { .i64 = 4 }, 0, 15, FLAGS },
+    { NULL },
+};
+
+static const AVCodecDefault vaapi_encode_vp9_defaults[] = {
+    { "profile",        "0"   },
+    { "b",              "0"   },
+    { "bf",             "0"   },
+    { "g",              "250" },
+    { "global_quality", "100" },
+    { NULL },
+};
+
+static const AVClass vaapi_encode_vp9_class = {
+    .class_name = "vp9_vaapi",
+    .item_name  = av_default_item_name,
+    .option     = vaapi_encode_vp9_options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVCodec ff_vp9_vaapi_encoder = {
+    .name           = "vp9_vaapi",
+    .long_name      = NULL_IF_CONFIG_SMALL("VP9 (VAAPI)"),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_VP9,
+    .priv_data_size = (sizeof(VAAPIEncodeContext) +
+                       sizeof(VAAPIEncodeVP9Options)),
+    .init           = &vaapi_encode_vp9_init,
+    .encode2        = &ff_vaapi_encode2,
+    .close          = &ff_vaapi_encode_close,
+    .priv_class     = &vaapi_encode_vp9_class,
+    .capabilities   = AV_CODEC_CAP_DELAY,
+    .defaults       = vaapi_encode_vp9_defaults,
+    .pix_fmts = (const enum AVPixelFormat[]) {
+        AV_PIX_FMT_VAAPI,
+        AV_PIX_FMT_NONE,
+    },
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_h264.c b/mythtv/external/FFmpeg/libavcodec/vaapi_h264.c
index bc12d77d6d5..30e7026ccf0 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_h264.c
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_h264.c
@@ -20,10 +20,10 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "vaapi_internal.h"
 #include "h264dec.h"
 #include "h264_ps.h"
-#include "mpegutils.h"
+#include "hwaccel.h"
+#include "vaapi_decode.h"
 
 /**
  * @file
@@ -53,7 +53,7 @@ static void init_vaapi_pic(VAPictureH264 *va_pic)
  *                             supersedes pic's field type if nonzero.
  */
 static void fill_vaapi_pic(VAPictureH264 *va_pic,
-                           H264Picture   *pic,
+                           const H264Picture *pic,
                            int            pic_structure)
 {
     if (pic_structure == 0)
@@ -91,7 +91,7 @@ typedef struct DPB {
  * available.  The decoded picture buffer's size must be large enough
  * to receive the new VA API picture object.
  */
-static int dpb_add(DPB *dpb, H264Picture *pic)
+static int dpb_add(DPB *dpb, const H264Picture *pic)
 {
     int i;
 
@@ -123,7 +123,7 @@ static int dpb_add(DPB *dpb, H264Picture *pic)
 
 /** Fill in VA API reference frames array. */
 static int fill_vaapi_ReferenceFrames(VAPictureParameterBufferH264 *pic_param,
-                                      H264Context                  *h)
+                                      const H264Context            *h)
 {
     DPB dpb;
     int i;
@@ -135,13 +135,13 @@ static int fill_vaapi_ReferenceFrames(VAPictureParameterBufferH264 *pic_param,
         init_vaapi_pic(&dpb.va_pics[i]);
 
     for (i = 0; i < h->short_ref_count; i++) {
-        H264Picture * const pic = h->short_ref[i];
+        const H264Picture *pic = h->short_ref[i];
         if (pic && pic->reference && dpb_add(&dpb, pic) < 0)
             return -1;
     }
 
     for (i = 0; i < 16; i++) {
-        H264Picture * const pic = h->long_ref[i];
+        const H264Picture *pic = h->long_ref[i];
         if (pic && pic->reference && dpb_add(&dpb, pic) < 0)
             return -1;
     }
@@ -157,7 +157,7 @@ static int fill_vaapi_ReferenceFrames(VAPictureParameterBufferH264 *pic_param,
  * @param[in]  ref_count   The number of reference pictures in ref_list
  */
 static void fill_vaapi_RefPicList(VAPictureH264 RefPicList[32],
-                                  H264Ref  *ref_list,
+                                  const H264Ref *ref_list,
                                   unsigned int  ref_count)
 {
     unsigned int i, n = 0;
@@ -185,7 +185,7 @@ static void fill_vaapi_RefPicList(VAPictureH264 RefPicList[32],
  * @param[out] chroma_weight       VA API plain chroma weight table
  * @param[out] chroma_offset       VA API plain chroma offset table
  */
-static void fill_vaapi_plain_pred_weight_table(H264Context   *h,
+static void fill_vaapi_plain_pred_weight_table(const H264Context *h,
                                                int            list,
                                                unsigned char *luma_weight_flag,
                                                short          luma_weight[32],
@@ -194,7 +194,7 @@ static void fill_vaapi_plain_pred_weight_table(H264Context   *h,
                                                short          chroma_weight[32][2],
                                                short          chroma_offset[32][2])
 {
-    H264SliceContext *sl = &h->slice_ctx[0];
+    const H264SliceContext *sl = &h->slice_ctx[0];
     unsigned int i, j;
 
     *luma_weight_flag    = sl->pwt.luma_weight_flag[list];
@@ -227,89 +227,103 @@ static int vaapi_h264_start_frame(AVCodecContext          *avctx,
                                   av_unused const uint8_t *buffer,
                                   av_unused uint32_t       size)
 {
-    H264Context * const h = avctx->priv_data;
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
+    const H264Context *h = avctx->priv_data;
+    VAAPIDecodePicture *pic = h->cur_pic_ptr->hwaccel_picture_private;
     const PPS *pps = h->ps.pps;
     const SPS *sps = h->ps.sps;
-    VAPictureParameterBufferH264 *pic_param;
-    VAIQMatrixBufferH264 *iq_matrix;
-
-    vactx->slice_param_size = sizeof(VASliceParameterBufferH264);
+    VAPictureParameterBufferH264 pic_param;
+    VAIQMatrixBufferH264 iq_matrix;
+    int err;
+
+    pic->output_surface = ff_vaapi_get_surface_id(h->cur_pic_ptr->f);
+
+    pic_param = (VAPictureParameterBufferH264) {
+        .picture_width_in_mbs_minus1                = h->mb_width - 1,
+        .picture_height_in_mbs_minus1               = h->mb_height - 1,
+        .bit_depth_luma_minus8                      = sps->bit_depth_luma - 8,
+        .bit_depth_chroma_minus8                    = sps->bit_depth_chroma - 8,
+        .num_ref_frames                             = sps->ref_frame_count,
+        .seq_fields.bits = {
+            .chroma_format_idc                      = sps->chroma_format_idc,
+            .residual_colour_transform_flag         = sps->residual_color_transform_flag,
+            .gaps_in_frame_num_value_allowed_flag   = sps->gaps_in_frame_num_allowed_flag,
+            .frame_mbs_only_flag                    = sps->frame_mbs_only_flag,
+            .mb_adaptive_frame_field_flag           = sps->mb_aff,
+            .direct_8x8_inference_flag              = sps->direct_8x8_inference_flag,
+            .MinLumaBiPredSize8x8                   = sps->level_idc >= 31, /* A.3.3.2 */
+            .log2_max_frame_num_minus4              = sps->log2_max_frame_num - 4,
+            .pic_order_cnt_type                     = sps->poc_type,
+            .log2_max_pic_order_cnt_lsb_minus4      = sps->log2_max_poc_lsb - 4,
+            .delta_pic_order_always_zero_flag       = sps->delta_pic_order_always_zero_flag,
+        },
+        .num_slice_groups_minus1                    = pps->slice_group_count - 1,
+        .slice_group_map_type                       = pps->mb_slice_group_map_type,
+        .slice_group_change_rate_minus1             = 0, /* FMO is not implemented */
+        .pic_init_qp_minus26                        = pps->init_qp - 26,
+        .pic_init_qs_minus26                        = pps->init_qs - 26,
+        .chroma_qp_index_offset                     = pps->chroma_qp_index_offset[0],
+        .second_chroma_qp_index_offset              = pps->chroma_qp_index_offset[1],
+        .pic_fields.bits = {
+            .entropy_coding_mode_flag               = pps->cabac,
+            .weighted_pred_flag                     = pps->weighted_pred,
+            .weighted_bipred_idc                    = pps->weighted_bipred_idc,
+            .transform_8x8_mode_flag                = pps->transform_8x8_mode,
+            .field_pic_flag                         = h->picture_structure != PICT_FRAME,
+            .constrained_intra_pred_flag            = pps->constrained_intra_pred,
+            .pic_order_present_flag                 = pps->pic_order_present,
+            .deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present,
+            .redundant_pic_cnt_present_flag         = pps->redundant_pic_cnt_present,
+            .reference_pic_flag                     = h->nal_ref_idc != 0,
+        },
+        .frame_num                                  = h->poc.frame_num,
+    };
+
+    fill_vaapi_pic(&pic_param.CurrPic, h->cur_pic_ptr, h->picture_structure);
+    err = fill_vaapi_ReferenceFrames(&pic_param, h);
+    if (err < 0)
+        goto fail;
+
+    err = ff_vaapi_decode_make_param_buffer(avctx, pic,
+                                            VAPictureParameterBufferType,
+                                            &pic_param, sizeof(pic_param));
+    if (err < 0)
+        goto fail;
+
+    memcpy(iq_matrix.ScalingList4x4,
+           pps->scaling_matrix4, sizeof(iq_matrix.ScalingList4x4));
+    memcpy(iq_matrix.ScalingList8x8[0],
+           pps->scaling_matrix8[0], sizeof(iq_matrix.ScalingList8x8[0]));
+    memcpy(iq_matrix.ScalingList8x8[1],
+           pps->scaling_matrix8[3], sizeof(iq_matrix.ScalingList8x8[0]));
+
+    err = ff_vaapi_decode_make_param_buffer(avctx, pic,
+                                            VAIQMatrixBufferType,
+                                            &iq_matrix, sizeof(iq_matrix));
+    if (err < 0)
+        goto fail;
 
-    /* Fill in VAPictureParameterBufferH264. */
-    pic_param = ff_vaapi_alloc_pic_param(vactx, sizeof(VAPictureParameterBufferH264));
-    if (!pic_param)
-        return -1;
-    fill_vaapi_pic(&pic_param->CurrPic, h->cur_pic_ptr, h->picture_structure);
-    if (fill_vaapi_ReferenceFrames(pic_param, h) < 0)
-        return -1;
-    pic_param->picture_width_in_mbs_minus1                      = h->mb_width - 1;
-    pic_param->picture_height_in_mbs_minus1                     = h->mb_height - 1;
-    pic_param->bit_depth_luma_minus8                            = sps->bit_depth_luma - 8;
-    pic_param->bit_depth_chroma_minus8                          = sps->bit_depth_chroma - 8;
-    pic_param->num_ref_frames                                   = sps->ref_frame_count;
-    pic_param->seq_fields.value                                 = 0; /* reset all bits */
-    pic_param->seq_fields.bits.chroma_format_idc                = sps->chroma_format_idc;
-    pic_param->seq_fields.bits.residual_colour_transform_flag   = sps->residual_color_transform_flag; /* XXX: only for 4:4:4 high profile? */
-    pic_param->seq_fields.bits.gaps_in_frame_num_value_allowed_flag = sps->gaps_in_frame_num_allowed_flag;
-    pic_param->seq_fields.bits.frame_mbs_only_flag              = sps->frame_mbs_only_flag;
-    pic_param->seq_fields.bits.mb_adaptive_frame_field_flag     = sps->mb_aff;
-    pic_param->seq_fields.bits.direct_8x8_inference_flag        = sps->direct_8x8_inference_flag;
-    pic_param->seq_fields.bits.MinLumaBiPredSize8x8             = sps->level_idc >= 31; /* A.3.3.2 */
-    pic_param->seq_fields.bits.log2_max_frame_num_minus4        = sps->log2_max_frame_num - 4;
-    pic_param->seq_fields.bits.pic_order_cnt_type               = sps->poc_type;
-    pic_param->seq_fields.bits.log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4;
-    pic_param->seq_fields.bits.delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag;
-    pic_param->num_slice_groups_minus1                          = pps->slice_group_count - 1;
-    pic_param->slice_group_map_type                             = pps->mb_slice_group_map_type;
-    pic_param->slice_group_change_rate_minus1                   = 0; /* XXX: unimplemented in FFmpeg */
-    pic_param->pic_init_qp_minus26                              = pps->init_qp - 26;
-    pic_param->pic_init_qs_minus26                              = pps->init_qs - 26;
-    pic_param->chroma_qp_index_offset                           = pps->chroma_qp_index_offset[0];
-    pic_param->second_chroma_qp_index_offset                    = pps->chroma_qp_index_offset[1];
-    pic_param->pic_fields.value                                 = 0; /* reset all bits */
-    pic_param->pic_fields.bits.entropy_coding_mode_flag         = pps->cabac;
-    pic_param->pic_fields.bits.weighted_pred_flag               = pps->weighted_pred;
-    pic_param->pic_fields.bits.weighted_bipred_idc              = pps->weighted_bipred_idc;
-    pic_param->pic_fields.bits.transform_8x8_mode_flag          = pps->transform_8x8_mode;
-    pic_param->pic_fields.bits.field_pic_flag                   = h->picture_structure != PICT_FRAME;
-    pic_param->pic_fields.bits.constrained_intra_pred_flag      = pps->constrained_intra_pred;
-    pic_param->pic_fields.bits.pic_order_present_flag           = pps->pic_order_present;
-    pic_param->pic_fields.bits.deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present;
-    pic_param->pic_fields.bits.redundant_pic_cnt_present_flag   = pps->redundant_pic_cnt_present;
-    pic_param->pic_fields.bits.reference_pic_flag               = h->nal_ref_idc != 0;
-    pic_param->frame_num                                        = h->poc.frame_num;
-
-    /* Fill in VAIQMatrixBufferH264. */
-    iq_matrix = ff_vaapi_alloc_iq_matrix(vactx, sizeof(VAIQMatrixBufferH264));
-    if (!iq_matrix)
-        return -1;
-    memcpy(iq_matrix->ScalingList4x4, pps->scaling_matrix4, sizeof(iq_matrix->ScalingList4x4));
-    memcpy(iq_matrix->ScalingList8x8[0], pps->scaling_matrix8[0], sizeof(iq_matrix->ScalingList8x8[0]));
-    memcpy(iq_matrix->ScalingList8x8[1], pps->scaling_matrix8[3], sizeof(iq_matrix->ScalingList8x8[0]));
     return 0;
+
+fail:
+    ff_vaapi_decode_cancel(avctx, pic);
+    return err;
 }
 
 /** End a hardware decoding based frame. */
 static int vaapi_h264_end_frame(AVCodecContext *avctx)
 {
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    H264Context * const h = avctx->priv_data;
+    const H264Context *h = avctx->priv_data;
+    VAAPIDecodePicture *pic = h->cur_pic_ptr->hwaccel_picture_private;
     H264SliceContext *sl = &h->slice_ctx[0];
     int ret;
 
-    ret = ff_vaapi_commit_slices(vactx);
-    if (ret < 0)
-        goto finish;
-
-    ret = ff_vaapi_render_picture(vactx, ff_vaapi_get_surface_id(h->cur_pic_ptr->f));
+    ret = ff_vaapi_decode_issue(avctx, pic);
     if (ret < 0)
         goto finish;
 
     ff_h264_draw_horiz_band(h, sl, 0, h->avctx->height);
 
 finish:
-    ff_vaapi_common_end_frame(avctx);
     return ret;
 }
 
@@ -318,50 +332,73 @@ static int vaapi_h264_decode_slice(AVCodecContext *avctx,
                                    const uint8_t  *buffer,
                                    uint32_t        size)
 {
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    H264Context * const h = avctx->priv_data;
-    H264SliceContext *sl  = &h->slice_ctx[0];
-    VASliceParameterBufferH264 *slice_param;
-
-    /* Fill in VASliceParameterBufferH264. */
-    slice_param = (VASliceParameterBufferH264 *)ff_vaapi_alloc_slice(vactx, buffer, size);
-    if (!slice_param)
-        return -1;
-    slice_param->slice_data_bit_offset          = get_bits_count(&sl->gb);
-    slice_param->first_mb_in_slice              = (sl->mb_y >> FIELD_OR_MBAFF_PICTURE(h)) * h->mb_width + sl->mb_x;
-    slice_param->slice_type                     = ff_h264_get_slice_type(sl);
-    slice_param->direct_spatial_mv_pred_flag    = sl->slice_type == AV_PICTURE_TYPE_B ? sl->direct_spatial_mv_pred : 0;
-    slice_param->num_ref_idx_l0_active_minus1   = sl->list_count > 0 ? sl->ref_count[0] - 1 : 0;
-    slice_param->num_ref_idx_l1_active_minus1   = sl->list_count > 1 ? sl->ref_count[1] - 1 : 0;
-    slice_param->cabac_init_idc                 = sl->cabac_init_idc;
-    slice_param->slice_qp_delta                 = sl->qscale - h->ps.pps->init_qp;
-    slice_param->disable_deblocking_filter_idc  = sl->deblocking_filter < 2 ? !sl->deblocking_filter : sl->deblocking_filter;
-    slice_param->slice_alpha_c0_offset_div2     = sl->slice_alpha_c0_offset / 2;
-    slice_param->slice_beta_offset_div2         = sl->slice_beta_offset     / 2;
-    slice_param->luma_log2_weight_denom         = sl->pwt.luma_log2_weight_denom;
-    slice_param->chroma_log2_weight_denom       = sl->pwt.chroma_log2_weight_denom;
-
-    fill_vaapi_RefPicList(slice_param->RefPicList0, sl->ref_list[0], sl->list_count > 0 ? sl->ref_count[0] : 0);
-    fill_vaapi_RefPicList(slice_param->RefPicList1, sl->ref_list[1], sl->list_count > 1 ? sl->ref_count[1] : 0);
+    const H264Context *h = avctx->priv_data;
+    VAAPIDecodePicture *pic = h->cur_pic_ptr->hwaccel_picture_private;
+    const H264SliceContext *sl  = &h->slice_ctx[0];
+    VASliceParameterBufferH264 slice_param;
+    int err;
+
+    slice_param = (VASliceParameterBufferH264) {
+        .slice_data_size               = size,
+        .slice_data_offset             = 0,
+        .slice_data_flag               = VA_SLICE_DATA_FLAG_ALL,
+        .slice_data_bit_offset         = get_bits_count(&sl->gb),
+        .first_mb_in_slice             = (sl->mb_y >> FIELD_OR_MBAFF_PICTURE(h)) * h->mb_width + sl->mb_x,
+        .slice_type                    = ff_h264_get_slice_type(sl),
+        .direct_spatial_mv_pred_flag   = sl->slice_type == AV_PICTURE_TYPE_B ? sl->direct_spatial_mv_pred : 0,
+        .num_ref_idx_l0_active_minus1  = sl->list_count > 0 ? sl->ref_count[0] - 1 : 0,
+        .num_ref_idx_l1_active_minus1  = sl->list_count > 1 ? sl->ref_count[1] - 1 : 0,
+        .cabac_init_idc                = sl->cabac_init_idc,
+        .slice_qp_delta                = sl->qscale - h->ps.pps->init_qp,
+        .disable_deblocking_filter_idc = sl->deblocking_filter < 2 ? !sl->deblocking_filter : sl->deblocking_filter,
+        .slice_alpha_c0_offset_div2    = sl->slice_alpha_c0_offset / 2,
+        .slice_beta_offset_div2        = sl->slice_beta_offset     / 2,
+        .luma_log2_weight_denom        = sl->pwt.luma_log2_weight_denom,
+        .chroma_log2_weight_denom      = sl->pwt.chroma_log2_weight_denom,
+    };
+
+    fill_vaapi_RefPicList(slice_param.RefPicList0, sl->ref_list[0],
+                          sl->list_count > 0 ? sl->ref_count[0] : 0);
+    fill_vaapi_RefPicList(slice_param.RefPicList1, sl->ref_list[1],
+                          sl->list_count > 1 ? sl->ref_count[1] : 0);
 
     fill_vaapi_plain_pred_weight_table(h, 0,
-                                       &slice_param->luma_weight_l0_flag,   slice_param->luma_weight_l0,   slice_param->luma_offset_l0,
-                                       &slice_param->chroma_weight_l0_flag, slice_param->chroma_weight_l0, slice_param->chroma_offset_l0);
+                                       &slice_param.luma_weight_l0_flag,
+                                       slice_param.luma_weight_l0,
+                                       slice_param.luma_offset_l0,
+                                       &slice_param.chroma_weight_l0_flag,
+                                       slice_param.chroma_weight_l0,
+                                       slice_param.chroma_offset_l0);
     fill_vaapi_plain_pred_weight_table(h, 1,
-                                       &slice_param->luma_weight_l1_flag,   slice_param->luma_weight_l1,   slice_param->luma_offset_l1,
-                                       &slice_param->chroma_weight_l1_flag, slice_param->chroma_weight_l1, slice_param->chroma_offset_l1);
+                                       &slice_param.luma_weight_l1_flag,
+                                       slice_param.luma_weight_l1,
+                                       slice_param.luma_offset_l1,
+                                       &slice_param.chroma_weight_l1_flag,
+                                       slice_param.chroma_weight_l1,
+                                       slice_param.chroma_offset_l1);
+
+    err = ff_vaapi_decode_make_slice_buffer(avctx, pic,
+                                            &slice_param, sizeof(slice_param),
+                                            buffer, size);
+    if (err) {
+        ff_vaapi_decode_cancel(avctx, pic);
+        return err;
+    }
+
     return 0;
 }
 
 AVHWAccel ff_h264_vaapi_hwaccel = {
-    .name           = "h264_vaapi",
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_H264,
-    .pix_fmt        = AV_PIX_FMT_VAAPI,
-    .start_frame    = vaapi_h264_start_frame,
-    .end_frame      = vaapi_h264_end_frame,
-    .decode_slice   = vaapi_h264_decode_slice,
-    .init           = ff_vaapi_context_init,
-    .uninit         = ff_vaapi_context_fini,
-    .priv_data_size = sizeof(FFVAContext),
+    .name                 = "h264_vaapi",
+    .type                 = AVMEDIA_TYPE_VIDEO,
+    .id                   = AV_CODEC_ID_H264,
+    .pix_fmt              = AV_PIX_FMT_VAAPI,
+    .start_frame          = &vaapi_h264_start_frame,
+    .end_frame            = &vaapi_h264_end_frame,
+    .decode_slice         = &vaapi_h264_decode_slice,
+    .frame_priv_data_size = sizeof(VAAPIDecodePicture),
+    .init                 = &ff_vaapi_decode_init,
+    .uninit               = &ff_vaapi_decode_uninit,
+    .priv_data_size       = sizeof(VAAPIDecodeContext),
+    .caps_internal        = HWACCEL_CAP_ASYNC_SAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_hevc.c b/mythtv/external/FFmpeg/libavcodec/vaapi_hevc.c
index 62f783e308b..69b8e478c61 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_hevc.c
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_hevc.c
@@ -20,38 +20,35 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "vaapi_internal.h"
-#include "hevc.h"
-#include "mpegutils.h"
-
-/**
- * @file
- * This file implements the glue code between FFmpeg's and VA API's
- * structures for HEVC decoding.
- */
+#include <va/va.h>
+#include <va/va_dec_hevc.h>
 
-typedef struct vaapi_hevc_frame_data {
-    VAPictureParameterBufferHEVC *pic_param;
-    VASliceParameterBufferHEVC *last_slice_param;
-} vaapi_hevc_frame_data;
+#include "avcodec.h"
+#include "hevcdec.h"
+#include "hwaccel.h"
+#include "vaapi_decode.h"
+
+typedef struct VAAPIDecodePictureHEVC {
+    VAPictureParameterBufferHEVC pic_param;
+    VASliceParameterBufferHEVC last_slice_param;
+    const uint8_t *last_buffer;
+    size_t         last_size;
+
+    VAAPIDecodePicture pic;
+} VAAPIDecodePictureHEVC;
 
-/**
- * Initialize an empty VA API picture.
- *
- * VA API requires a fixed-size reference picture array.
- */
 static void init_vaapi_pic(VAPictureHEVC *va_pic)
 {
-    va_pic->picture_id = VA_INVALID_ID;
-    va_pic->flags = VA_PICTURE_HEVC_INVALID;
+    va_pic->picture_id    = VA_INVALID_ID;
+    va_pic->flags         = VA_PICTURE_HEVC_INVALID;
     va_pic->pic_order_cnt = 0;
 }
 
 static void fill_vaapi_pic(VAPictureHEVC *va_pic, const HEVCFrame *pic, int rps_type)
 {
-    va_pic->picture_id = ff_vaapi_get_surface_id(pic->frame);
+    va_pic->picture_id    = ff_vaapi_get_surface_id(pic->frame);
     va_pic->pic_order_cnt = pic->poc;
-    va_pic->flags = rps_type;
+    va_pic->flags         = rps_type;
 
     if (pic->flags & HEVC_FRAME_FLAG_LONG_REF)
         va_pic->flags |= VA_PICTURE_HEVC_LONG_TERM_REFERENCE;
@@ -59,9 +56,8 @@ static void fill_vaapi_pic(VAPictureHEVC *va_pic, const HEVCFrame *pic, int rps_
     if (pic->frame->interlaced_frame) {
         va_pic->flags |= VA_PICTURE_HEVC_FIELD_PIC;
 
-        if (!pic->frame->top_field_first) {
+        if (!pic->frame->top_field_first)
             va_pic->flags |= VA_PICTURE_HEVC_BOTTOM_FIELD;
-        }
     }
 }
 
@@ -70,17 +66,17 @@ static int find_frame_rps_type(const HEVCContext *h, const HEVCFrame *pic)
     VASurfaceID pic_surf = ff_vaapi_get_surface_id(pic->frame);
     int i;
 
-    for (i = 0; i < h->rps[ST_CURR_BEF].nb_refs; ++i) {
+    for (i = 0; i < h->rps[ST_CURR_BEF].nb_refs; i++) {
         if (pic_surf == ff_vaapi_get_surface_id(h->rps[ST_CURR_BEF].ref[i]->frame))
             return VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE;
     }
 
-    for (i = 0; i < h->rps[ST_CURR_AFT].nb_refs; ++i) {
+    for (i = 0; i < h->rps[ST_CURR_AFT].nb_refs; i++) {
         if (pic_surf == ff_vaapi_get_surface_id(h->rps[ST_CURR_AFT].ref[i]->frame))
             return VA_PICTURE_HEVC_RPS_ST_CURR_AFTER;
     }
 
-    for (i = 0; i < h->rps[LT_CURR].nb_refs; ++i) {
+    for (i = 0; i < h->rps[LT_CURR].nb_refs; i++) {
         if (pic_surf == ff_vaapi_get_surface_id(h->rps[LT_CURR].ref[i]->frame))
             return VA_PICTURE_HEVC_RPS_LT_CURR;
     }
@@ -88,7 +84,7 @@ static int find_frame_rps_type(const HEVCContext *h, const HEVCFrame *pic)
     return 0;
 }
 
-static void fill_vaapi_ReferenceFrames(const HEVCContext *h, VAPictureParameterBufferHEVC *pp)
+static void fill_vaapi_reference_frames(const HEVCContext *h, VAPictureParameterBufferHEVC *pp)
 {
     const HEVCFrame *current_picture = h->ref;
     int i, j, rps_type;
@@ -111,256 +107,200 @@ static void fill_vaapi_ReferenceFrames(const HEVCContext *h, VAPictureParameterB
     }
 }
 
-static uint8_t get_ref_pic_index(const HEVCContext *h, const HEVCFrame *frame)
-{
-    vaapi_hevc_frame_data *frame_data = h->ref->hwaccel_picture_private;
-    VAPictureParameterBufferHEVC *pp = frame_data->pic_param;
-    uint8_t i;
-
-    if (!frame)
-        return 0xff;
-
-    for (i = 0; i < FF_ARRAY_ELEMS(pp->ReferenceFrames); ++i) {
-        VASurfaceID pid = pp->ReferenceFrames[i].picture_id;
-        int poc = pp->ReferenceFrames[i].pic_order_cnt;
-        if (pid != VA_INVALID_ID && pid == ff_vaapi_get_surface_id(frame->frame) && poc == frame->poc)
-            return i;
-    }
-
-    return 0xff;
-}
-
-static void fill_picture_parameters(const HEVCContext *h, VAPictureParameterBufferHEVC *pp)
-{
-    int i;
-
-    pp->pic_fields.value = 0;
-    pp->slice_parsing_fields.value = 0;
-
-    fill_vaapi_pic(&pp->CurrPic, h->ref, 0);
-    fill_vaapi_ReferenceFrames(h, pp);
-
-    pp->pic_width_in_luma_samples  = h->ps.sps->width;
-    pp->pic_height_in_luma_samples = h->ps.sps->height;
-
-    pp->log2_min_luma_coding_block_size_minus3 = h->ps.sps->log2_min_cb_size - 3;
-
-    pp->pic_fields.bits.chroma_format_idc = h->ps.sps->chroma_format_idc;
-
-    pp->sps_max_dec_pic_buffering_minus1 = h->ps.sps->temporal_layer[h->ps.sps->max_sub_layers - 1].max_dec_pic_buffering - 1;
-    pp->log2_diff_max_min_luma_coding_block_size = h->ps.sps->log2_diff_max_min_coding_block_size;
-    pp->log2_min_transform_block_size_minus2 = h->ps.sps->log2_min_tb_size - 2;
-    pp->log2_diff_max_min_transform_block_size = h->ps.sps->log2_max_trafo_size  - h->ps.sps->log2_min_tb_size;
-    pp->max_transform_hierarchy_depth_inter = h->ps.sps->max_transform_hierarchy_depth_inter;
-    pp->max_transform_hierarchy_depth_intra = h->ps.sps->max_transform_hierarchy_depth_intra;
-    pp->num_short_term_ref_pic_sets = h->ps.sps->nb_st_rps;
-    pp->num_long_term_ref_pic_sps = h->ps.sps->num_long_term_ref_pics_sps;
-
-    pp->num_ref_idx_l0_default_active_minus1 = h->ps.pps->num_ref_idx_l0_default_active - 1;
-    pp->num_ref_idx_l1_default_active_minus1 = h->ps.pps->num_ref_idx_l1_default_active - 1;
-    pp->init_qp_minus26 = h->ps.pps->pic_init_qp_minus26;
-
-    pp->pps_cb_qp_offset = h->ps.pps->cb_qp_offset;
-    pp->pps_cr_qp_offset = h->ps.pps->cr_qp_offset;
-
-    pp->pic_fields.bits.tiles_enabled_flag = h->ps.pps->tiles_enabled_flag;
-    pp->pic_fields.bits.separate_colour_plane_flag = h->ps.sps->separate_colour_plane_flag;
-    pp->pic_fields.bits.pcm_enabled_flag = h->ps.sps->pcm_enabled_flag;
-    pp->pic_fields.bits.scaling_list_enabled_flag = h->ps.sps->scaling_list_enable_flag;
-    pp->pic_fields.bits.transform_skip_enabled_flag = h->ps.pps->transform_skip_enabled_flag;
-    pp->pic_fields.bits.amp_enabled_flag = h->ps.sps->amp_enabled_flag;
-    pp->pic_fields.bits.strong_intra_smoothing_enabled_flag = h->ps.sps->sps_strong_intra_smoothing_enable_flag;
-    pp->pic_fields.bits.sign_data_hiding_enabled_flag = h->ps.pps->sign_data_hiding_flag;
-    pp->pic_fields.bits.constrained_intra_pred_flag = h->ps.pps->constrained_intra_pred_flag;
-    pp->pic_fields.bits.cu_qp_delta_enabled_flag = h->ps.pps->cu_qp_delta_enabled_flag;
-    pp->pic_fields.bits.weighted_pred_flag = h->ps.pps->weighted_pred_flag;
-    pp->pic_fields.bits.weighted_bipred_flag = h->ps.pps->weighted_bipred_flag;
-    pp->pic_fields.bits.transquant_bypass_enabled_flag = h->ps.pps->transquant_bypass_enable_flag;
-    pp->pic_fields.bits.entropy_coding_sync_enabled_flag = h->ps.pps->entropy_coding_sync_enabled_flag;
-    pp->pic_fields.bits.pps_loop_filter_across_slices_enabled_flag = h->ps.pps->seq_loop_filter_across_slices_enabled_flag;
-    pp->pic_fields.bits.loop_filter_across_tiles_enabled_flag = h->ps.pps->loop_filter_across_tiles_enabled_flag;
-
-    pp->pic_fields.bits.pcm_loop_filter_disabled_flag = h->ps.sps->pcm.loop_filter_disable_flag;
-    pp->pcm_sample_bit_depth_luma_minus1 = h->ps.sps->pcm.bit_depth - 1;
-    pp->pcm_sample_bit_depth_chroma_minus1 = h->ps.sps->pcm.bit_depth_chroma - 1;
-    pp->log2_min_pcm_luma_coding_block_size_minus3 = h->ps.sps->pcm.log2_min_pcm_cb_size - 3;
-    pp->log2_diff_max_min_pcm_luma_coding_block_size = h->ps.sps->pcm.log2_max_pcm_cb_size - h->ps.sps->pcm.log2_min_pcm_cb_size;
-
-    memset(pp->column_width_minus1, 0, sizeof(pp->column_width_minus1));
-    memset(pp->row_height_minus1, 0, sizeof(pp->row_height_minus1));
-
-    if (h->ps.pps->tiles_enabled_flag) {
-        pp->num_tile_columns_minus1 = h->ps.pps->num_tile_columns - 1;
-        pp->num_tile_rows_minus1 = h->ps.pps->num_tile_rows - 1;
-
-        for (i = 0; i < h->ps.pps->num_tile_columns; i++)
-            pp->column_width_minus1[i] = h->ps.pps->column_width[i] - 1;
-
-        for (i = 0; i < h->ps.pps->num_tile_rows; i++)
-            pp->row_height_minus1[i] = h->ps.pps->row_height[i] - 1;
-    }
-
-    pp->diff_cu_qp_delta_depth = h->ps.pps->diff_cu_qp_delta_depth;
-    pp->pps_beta_offset_div2 = h->ps.pps->beta_offset / 2;
-    pp->pps_tc_offset_div2 = h->ps.pps->tc_offset / 2;
-    pp->log2_parallel_merge_level_minus2 = h->ps.pps->log2_parallel_merge_level - 2;
-
-    /* Different chroma/luma bit depths are currently not supported by ffmpeg. */
-    pp->bit_depth_luma_minus8 = h->ps.sps->bit_depth - 8;
-    pp->bit_depth_chroma_minus8 = h->ps.sps->bit_depth - 8;
-
-    pp->slice_parsing_fields.bits.lists_modification_present_flag = h->ps.pps->lists_modification_present_flag;
-    pp->slice_parsing_fields.bits.long_term_ref_pics_present_flag = h->ps.sps->long_term_ref_pics_present_flag;
-    pp->slice_parsing_fields.bits.sps_temporal_mvp_enabled_flag = h->ps.sps->sps_temporal_mvp_enabled_flag;
-    pp->slice_parsing_fields.bits.cabac_init_present_flag = h->ps.pps->cabac_init_present_flag;
-    pp->slice_parsing_fields.bits.output_flag_present_flag = h->ps.pps->output_flag_present_flag;
-    pp->slice_parsing_fields.bits.dependent_slice_segments_enabled_flag = h->ps.pps->dependent_slice_segments_enabled_flag;
-    pp->slice_parsing_fields.bits.pps_slice_chroma_qp_offsets_present_flag = h->ps.pps->pic_slice_level_chroma_qp_offsets_present_flag;
-    pp->slice_parsing_fields.bits.sample_adaptive_offset_enabled_flag = h->ps.sps->sao_enabled;
-    pp->slice_parsing_fields.bits.deblocking_filter_override_enabled_flag = h->ps.pps->deblocking_filter_override_enabled_flag;
-    pp->slice_parsing_fields.bits.pps_disable_deblocking_filter_flag = h->ps.pps->disable_dbf;
-    pp->slice_parsing_fields.bits.slice_segment_header_extension_present_flag = h->ps.pps->slice_header_extension_present_flag;
-
-    pp->log2_max_pic_order_cnt_lsb_minus4 = h->ps.sps->log2_max_poc_lsb - 4;
-    pp->num_extra_slice_header_bits = h->ps.pps->num_extra_slice_header_bits;
-
-    if (h->nal_unit_type >= NAL_BLA_W_LP && h->nal_unit_type <= NAL_CRA_NUT) {
-        pp->slice_parsing_fields.bits.RapPicFlag = 1;
-    } else {
-        pp->slice_parsing_fields.bits.RapPicFlag = 0;
-    }
-
-    if (IS_IDR(h)) {
-        pp->slice_parsing_fields.bits.IdrPicFlag = 1;
-    } else {
-        pp->slice_parsing_fields.bits.IdrPicFlag = 0;
-    }
-
-    if (IS_IRAP(h)) {
-        pp->slice_parsing_fields.bits.IntraPicFlag = 1;
-    } else {
-        pp->slice_parsing_fields.bits.IntraPicFlag = 0;
-    }
-
-    if (h->sh.short_term_ref_pic_set_sps_flag == 0 && h->sh.short_term_rps) {
-        pp->st_rps_bits = h->sh.short_term_ref_pic_set_size;
-    } else {
-        pp->st_rps_bits = 0;
-    }
-
-    /* TODO */
-    pp->pic_fields.bits.NoPicReorderingFlag = 0;
-    pp->pic_fields.bits.NoBiPredFlag = 0;
-}
-
-
-/** Initialize and start decoding a frame with VA API. */
 static int vaapi_hevc_start_frame(AVCodecContext          *avctx,
                                   av_unused const uint8_t *buffer,
                                   av_unused uint32_t       size)
 {
-    HEVCContext * const h = avctx->priv_data;
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    vaapi_hevc_frame_data *frame_data = h->ref->hwaccel_picture_private;
-    VAPictureParameterBufferHEVC *pic_param;
-    VAIQMatrixBufferHEVC *iq_matrix;
-    ScalingList const * scaling_list;
-    int i, j, pos;
-
-    ff_dlog(avctx, "vaapi_hevc_start_frame()\n");
-
-    vactx->slice_param_size = sizeof(VASliceParameterBufferHEVC);
-
-    /* Fill in VAPictureParameterBufferHEVC. */
-    pic_param = ff_vaapi_alloc_pic_param(vactx, sizeof(VAPictureParameterBufferHEVC));
-    if (!pic_param)
-        return -1;
-    fill_picture_parameters(h, pic_param);
-    frame_data->pic_param = pic_param;
-
-    /* Fill in VAIQMatrixBufferHEVC. */
-    if (h->ps.pps->scaling_list_data_present_flag) {
-        scaling_list = &h->ps.pps->scaling_list;
-    } else if (h->ps.sps->scaling_list_enable_flag) {
-        scaling_list = &h->ps.sps->scaling_list;
-    } else {
-        return 0;
+    const HEVCContext        *h = avctx->priv_data;
+    VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;
+    const HEVCSPS          *sps = h->ps.sps;
+    const HEVCPPS          *pps = h->ps.pps;
+
+    const ScalingList *scaling_list = NULL;
+    int err, i;
+
+    pic->pic.output_surface = ff_vaapi_get_surface_id(h->ref->frame);
+
+    pic->pic_param = (VAPictureParameterBufferHEVC) {
+        .pic_fields.value                             = 0,
+        .slice_parsing_fields.value                   = 0,
+        .pic_width_in_luma_samples                    = sps->width,
+        .pic_height_in_luma_samples                   = sps->height,
+        .log2_min_luma_coding_block_size_minus3       = sps->log2_min_cb_size - 3,
+        .sps_max_dec_pic_buffering_minus1             = sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering - 1,
+        .log2_diff_max_min_luma_coding_block_size     = sps->log2_diff_max_min_coding_block_size,
+        .log2_min_transform_block_size_minus2         = sps->log2_min_tb_size - 2,
+        .log2_diff_max_min_transform_block_size       = sps->log2_max_trafo_size  - sps->log2_min_tb_size,
+        .max_transform_hierarchy_depth_inter          = sps->max_transform_hierarchy_depth_inter,
+        .max_transform_hierarchy_depth_intra          = sps->max_transform_hierarchy_depth_intra,
+        .num_short_term_ref_pic_sets                  = sps->nb_st_rps,
+        .num_long_term_ref_pic_sps                    = sps->num_long_term_ref_pics_sps,
+        .num_ref_idx_l0_default_active_minus1         = pps->num_ref_idx_l0_default_active - 1,
+        .num_ref_idx_l1_default_active_minus1         = pps->num_ref_idx_l1_default_active - 1,
+        .init_qp_minus26                              = pps->pic_init_qp_minus26,
+        .pps_cb_qp_offset                             = pps->cb_qp_offset,
+        .pps_cr_qp_offset                             = pps->cr_qp_offset,
+        .pcm_sample_bit_depth_luma_minus1             = sps->pcm.bit_depth - 1,
+        .pcm_sample_bit_depth_chroma_minus1           = sps->pcm.bit_depth_chroma - 1,
+        .log2_min_pcm_luma_coding_block_size_minus3   = sps->pcm.log2_min_pcm_cb_size - 3,
+        .log2_diff_max_min_pcm_luma_coding_block_size = sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size,
+        .diff_cu_qp_delta_depth                       = pps->diff_cu_qp_delta_depth,
+        .pps_beta_offset_div2                         = pps->beta_offset / 2,
+        .pps_tc_offset_div2                           = pps->tc_offset / 2,
+        .log2_parallel_merge_level_minus2             = pps->log2_parallel_merge_level - 2,
+        .bit_depth_luma_minus8                        = sps->bit_depth - 8,
+        .bit_depth_chroma_minus8                      = sps->bit_depth - 8,
+        .log2_max_pic_order_cnt_lsb_minus4            = sps->log2_max_poc_lsb - 4,
+        .num_extra_slice_header_bits                  = pps->num_extra_slice_header_bits,
+        .pic_fields.bits = {
+            .chroma_format_idc                          = sps->chroma_format_idc,
+            .tiles_enabled_flag                         = pps->tiles_enabled_flag,
+            .separate_colour_plane_flag                 = sps->separate_colour_plane_flag,
+            .pcm_enabled_flag                           = sps->pcm_enabled_flag,
+            .scaling_list_enabled_flag                  = sps->scaling_list_enable_flag,
+            .transform_skip_enabled_flag                = pps->transform_skip_enabled_flag,
+            .amp_enabled_flag                           = sps->amp_enabled_flag,
+            .strong_intra_smoothing_enabled_flag        = sps->sps_strong_intra_smoothing_enable_flag,
+            .sign_data_hiding_enabled_flag              = pps->sign_data_hiding_flag,
+            .constrained_intra_pred_flag                = pps->constrained_intra_pred_flag,
+            .cu_qp_delta_enabled_flag                   = pps->cu_qp_delta_enabled_flag,
+            .weighted_pred_flag                         = pps->weighted_pred_flag,
+            .weighted_bipred_flag                       = pps->weighted_bipred_flag,
+            .transquant_bypass_enabled_flag             = pps->transquant_bypass_enable_flag,
+            .entropy_coding_sync_enabled_flag           = pps->entropy_coding_sync_enabled_flag,
+            .pps_loop_filter_across_slices_enabled_flag = pps->seq_loop_filter_across_slices_enabled_flag,
+            .loop_filter_across_tiles_enabled_flag      = pps->loop_filter_across_tiles_enabled_flag,
+            .pcm_loop_filter_disabled_flag              = sps->pcm.loop_filter_disable_flag,
+        },
+        .slice_parsing_fields.bits = {
+            .lists_modification_present_flag             = pps->lists_modification_present_flag,
+            .long_term_ref_pics_present_flag             = sps->long_term_ref_pics_present_flag,
+            .sps_temporal_mvp_enabled_flag               = sps->sps_temporal_mvp_enabled_flag,
+            .cabac_init_present_flag                     = pps->cabac_init_present_flag,
+            .output_flag_present_flag                    = pps->output_flag_present_flag,
+            .dependent_slice_segments_enabled_flag       = pps->dependent_slice_segments_enabled_flag,
+            .pps_slice_chroma_qp_offsets_present_flag    = pps->pic_slice_level_chroma_qp_offsets_present_flag,
+            .sample_adaptive_offset_enabled_flag         = sps->sao_enabled,
+            .deblocking_filter_override_enabled_flag     = pps->deblocking_filter_override_enabled_flag,
+            .pps_disable_deblocking_filter_flag          = pps->disable_dbf,
+            .slice_segment_header_extension_present_flag = pps->slice_header_extension_present_flag,
+            .RapPicFlag                                  = IS_IRAP(h),
+            .IdrPicFlag                                  = IS_IDR(h),
+            .IntraPicFlag                                = IS_IRAP(h),
+        },
+    };
+
+    fill_vaapi_pic(&pic->pic_param.CurrPic, h->ref, 0);
+    fill_vaapi_reference_frames(h, &pic->pic_param);
+
+    if (pps->tiles_enabled_flag) {
+        pic->pic_param.num_tile_columns_minus1 = pps->num_tile_columns - 1;
+        pic->pic_param.num_tile_rows_minus1    = pps->num_tile_rows - 1;
+
+        for (i = 0; i < pps->num_tile_columns; i++)
+            pic->pic_param.column_width_minus1[i] = pps->column_width[i] - 1;
+
+        for (i = 0; i < pps->num_tile_rows; i++)
+            pic->pic_param.row_height_minus1[i] = pps->row_height[i] - 1;
     }
 
-    iq_matrix = ff_vaapi_alloc_iq_matrix(vactx, sizeof(VAIQMatrixBufferHEVC));
-    if (!iq_matrix)
-        return -1;
+    if (h->sh.short_term_ref_pic_set_sps_flag == 0 && h->sh.short_term_rps) {
+        pic->pic_param.st_rps_bits = h->sh.short_term_ref_pic_set_size;
+    } else {
+        pic->pic_param.st_rps_bits = 0;
+    }
 
-    for (i = 0; i < 6; ++i) {
-        for (j = 0; j < 16; ++j) {
-            pos = 4 * ff_hevc_diag_scan4x4_y[j] + ff_hevc_diag_scan4x4_x[j];
-            iq_matrix->ScalingList4x4[i][j] = scaling_list->sl[0][i][pos];
-        }
-        for (j = 0; j < 64; ++j) {
-            pos = 8 * ff_hevc_diag_scan8x8_y[j] + ff_hevc_diag_scan8x8_x[j];
-            iq_matrix->ScalingList8x8[i][j] = scaling_list->sl[1][i][pos];
-            iq_matrix->ScalingList16x16[i][j] = scaling_list->sl[2][i][pos];
-            if (i < 2) {
-                iq_matrix->ScalingList32x32[i][j] = scaling_list->sl[3][i * 3][pos];
+    err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic,
+                                            VAPictureParameterBufferType,
+                                            &pic->pic_param, sizeof(pic->pic_param));
+    if (err < 0)
+        goto fail;
+
+    if (pps->scaling_list_data_present_flag)
+        scaling_list = &pps->scaling_list;
+    else if (sps->scaling_list_enable_flag)
+        scaling_list = &sps->scaling_list;
+
+    if (scaling_list) {
+        VAIQMatrixBufferHEVC iq_matrix;
+        int j;
+
+        for (i = 0; i < 6; i++) {
+            for (j = 0; j < 16; j++)
+                iq_matrix.ScalingList4x4[i][j] = scaling_list->sl[0][i][j];
+            for (j = 0; j < 64; j++) {
+                iq_matrix.ScalingList8x8[i][j]   = scaling_list->sl[1][i][j];
+                iq_matrix.ScalingList16x16[i][j] = scaling_list->sl[2][i][j];
+                if (i < 2)
+                    iq_matrix.ScalingList32x32[i][j] = scaling_list->sl[3][i * 3][j];
             }
+            iq_matrix.ScalingListDC16x16[i] = scaling_list->sl_dc[0][i];
+            if (i < 2)
+                iq_matrix.ScalingListDC32x32[i] = scaling_list->sl_dc[1][i * 3];
         }
-        iq_matrix->ScalingListDC16x16[i] = scaling_list->sl_dc[0][i];
-        if (i < 2) {
-            iq_matrix->ScalingListDC32x32[i] = scaling_list->sl_dc[1][i * 3];
-        }
+
+        err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic,
+                                                VAIQMatrixBufferType,
+                                                &iq_matrix, sizeof(iq_matrix));
+        if (err < 0)
+            goto fail;
     }
 
     return 0;
+
+fail:
+    ff_vaapi_decode_cancel(avctx, &pic->pic);
+    return err;
 }
 
-/** End a hardware decoding based frame. */
 static int vaapi_hevc_end_frame(AVCodecContext *avctx)
 {
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    HEVCContext * const h = avctx->priv_data;
-    vaapi_hevc_frame_data *frame_data = h->ref->hwaccel_picture_private;
+    const HEVCContext        *h = avctx->priv_data;
+    VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;
     int ret;
 
-    ff_dlog(avctx, "vaapi_hevc_end_frame()\n");
-
-    frame_data->last_slice_param->LongSliceFlags.fields.LastSliceOfPic = 1;
+    if (pic->last_size) {
+        pic->last_slice_param.LongSliceFlags.fields.LastSliceOfPic = 1;
+        ret = ff_vaapi_decode_make_slice_buffer(avctx, &pic->pic,
+                                                &pic->last_slice_param, sizeof(pic->last_slice_param),
+                                                pic->last_buffer, pic->last_size);
+        if (ret < 0)
+            goto fail;
+    }
 
-    ret = ff_vaapi_commit_slices(vactx);
-    if (ret < 0)
-        goto finish;
 
-    ret = ff_vaapi_render_picture(vactx, ff_vaapi_get_surface_id(h->ref->frame));
+    ret = ff_vaapi_decode_issue(avctx, &pic->pic);
     if (ret < 0)
-        goto finish;
+        goto fail;
 
-finish:
-    ff_vaapi_common_end_frame(avctx);
+    return 0;
+fail:
+    ff_vaapi_decode_cancel(avctx, &pic->pic);
     return ret;
 }
 
-static int fill_pred_weight_table(HEVCContext * const h,
-                                  VASliceParameterBufferHEVC *slice_param,
-                                  SliceHeader * const sh)
+static void fill_pred_weight_table(const HEVCContext *h,
+                                   const SliceHeader *sh,
+                                   VASliceParameterBufferHEVC *slice_param)
 {
     int i;
 
-    memset(slice_param->delta_luma_weight_l0, 0, sizeof(slice_param->delta_luma_weight_l0));
-    memset(slice_param->delta_luma_weight_l1, 0, sizeof(slice_param->delta_luma_weight_l1));
-    memset(slice_param->luma_offset_l0, 0, sizeof(slice_param->luma_offset_l0));
-    memset(slice_param->luma_offset_l1, 0, sizeof(slice_param->luma_offset_l1));
+    memset(slice_param->delta_luma_weight_l0,   0, sizeof(slice_param->delta_luma_weight_l0));
+    memset(slice_param->delta_luma_weight_l1,   0, sizeof(slice_param->delta_luma_weight_l1));
+    memset(slice_param->luma_offset_l0,         0, sizeof(slice_param->luma_offset_l0));
+    memset(slice_param->luma_offset_l1,         0, sizeof(slice_param->luma_offset_l1));
     memset(slice_param->delta_chroma_weight_l0, 0, sizeof(slice_param->delta_chroma_weight_l0));
     memset(slice_param->delta_chroma_weight_l1, 0, sizeof(slice_param->delta_chroma_weight_l1));
-    memset(slice_param->ChromaOffsetL0, 0, sizeof(slice_param->ChromaOffsetL0));
-    memset(slice_param->ChromaOffsetL1, 0, sizeof(slice_param->ChromaOffsetL1));
+    memset(slice_param->ChromaOffsetL0,         0, sizeof(slice_param->ChromaOffsetL0));
+    memset(slice_param->ChromaOffsetL1,         0, sizeof(slice_param->ChromaOffsetL1));
 
     slice_param->delta_chroma_log2_weight_denom = 0;
-    slice_param->luma_log2_weight_denom = 0;
+    slice_param->luma_log2_weight_denom         = 0;
 
-    if (  sh->slice_type == I_SLICE
-      || (sh->slice_type == P_SLICE && !h->ps.pps->weighted_pred_flag)
-      || (sh->slice_type == B_SLICE && !h->ps.pps->weighted_bipred_flag)) {
-        return 0;
-    }
+    if (sh->slice_type == HEVC_SLICE_I ||
+        (sh->slice_type == HEVC_SLICE_P && !h->ps.pps->weighted_pred_flag) ||
+        (sh->slice_type == HEVC_SLICE_B && !h->ps.pps->weighted_bipred_flag))
+        return;
 
     slice_param->luma_log2_weight_denom = sh->luma_log2_weight_denom;
 
@@ -368,7 +308,7 @@ static int fill_pred_weight_table(HEVCContext * const h,
         slice_param->delta_chroma_log2_weight_denom = sh->chroma_log2_weight_denom - sh->luma_log2_weight_denom;
     }
 
-    for (i = 0; i < 15 && i < sh->nb_refs[L0]; ++i) {
+    for (i = 0; i < 15 && i < sh->nb_refs[L0]; i++) {
         slice_param->delta_luma_weight_l0[i] = sh->luma_weight_l0[i] - (1 << sh->luma_log2_weight_denom);
         slice_param->luma_offset_l0[i] = sh->luma_offset_l0[i];
         slice_param->delta_chroma_weight_l0[i][0] = sh->chroma_weight_l0[i][0] - (1 << sh->chroma_log2_weight_denom);
@@ -377,8 +317,8 @@ static int fill_pred_weight_table(HEVCContext * const h,
         slice_param->ChromaOffsetL0[i][1] = sh->chroma_offset_l0[i][1];
     }
 
-    if (sh->slice_type == B_SLICE) {
-        for (i = 0; i < 15 && i < sh->nb_refs[L1]; ++i) {
+    if (sh->slice_type == HEVC_SLICE_B) {
+        for (i = 0; i < 15 && i < sh->nb_refs[L1]; i++) {
             slice_param->delta_luma_weight_l1[i] = sh->luma_weight_l1[i] - (1 << sh->luma_log2_weight_denom);
             slice_param->luma_offset_l1[i] = sh->luma_offset_l1[i];
             slice_param->delta_chroma_weight_l1[i][0] = sh->chroma_weight_l1[i][0] - (1 << sh->chroma_log2_weight_denom);
@@ -387,92 +327,100 @@ static int fill_pred_weight_table(HEVCContext * const h,
             slice_param->ChromaOffsetL1[i][1] = sh->chroma_offset_l1[i][1];
         }
     }
+}
 
-    return 0;
+static uint8_t get_ref_pic_index(const HEVCContext *h, const HEVCFrame *frame)
+{
+    VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;
+    VAPictureParameterBufferHEVC *pp = &pic->pic_param;
+    uint8_t i;
+
+    if (!frame)
+        return 0xff;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(pp->ReferenceFrames); i++) {
+        VASurfaceID pid = pp->ReferenceFrames[i].picture_id;
+        int poc = pp->ReferenceFrames[i].pic_order_cnt;
+        if (pid != VA_INVALID_ID && pid == ff_vaapi_get_surface_id(frame->frame) && poc == frame->poc)
+            return i;
+    }
+
+    return 0xff;
 }
 
-/** Decode the given hevc slice with VA API. */
 static int vaapi_hevc_decode_slice(AVCodecContext *avctx,
                                    const uint8_t  *buffer,
                                    uint32_t        size)
 {
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    HEVCContext * const h = avctx->priv_data;
-    vaapi_hevc_frame_data *frame_data = h->ref->hwaccel_picture_private;
-    SliceHeader * const sh = &h->sh;
-    VASliceParameterBufferHEVC *slice_param;
-    int i, list_idx;
-    uint8_t nb_list = sh->slice_type == B_SLICE ? 2 : 1;
-
-    if (sh->slice_type == I_SLICE)
-        nb_list = 0;
-
-    ff_dlog(avctx, "vaapi_hevc_decode_slice(): buffer %p, size %d\n", buffer, size);
-
-    /* Fill in VASliceParameterBufferH264. */
-    slice_param = (VASliceParameterBufferHEVC *)ff_vaapi_alloc_slice(vactx, buffer, size);
-    if (!slice_param)
-        return -1;
-
-    frame_data->last_slice_param = slice_param;
-
-    /* The base structure changed, so this has to be re-set in order to be valid on every byte order. */
-    slice_param->slice_data_flag = VA_SLICE_DATA_FLAG_ALL;
-
-    /* Add 1 to the bits count here to account for the byte_alignment bit, which allways is at least one bit and not accounted for otherwise. */
-    slice_param->slice_data_byte_offset = (get_bits_count(&h->HEVClc->gb) + 1 + 7) / 8;
-
-    slice_param->slice_segment_address = sh->slice_segment_addr;
-
-    slice_param->LongSliceFlags.value = 0;
-    slice_param->LongSliceFlags.fields.dependent_slice_segment_flag = sh->dependent_slice_segment_flag;
-    slice_param->LongSliceFlags.fields.slice_type = sh->slice_type;
-    slice_param->LongSliceFlags.fields.color_plane_id = sh->colour_plane_id;
-    slice_param->LongSliceFlags.fields.mvd_l1_zero_flag = sh->mvd_l1_zero_flag;
-    slice_param->LongSliceFlags.fields.cabac_init_flag = sh->cabac_init_flag;
-    slice_param->LongSliceFlags.fields.slice_temporal_mvp_enabled_flag = sh->slice_temporal_mvp_enabled_flag;
-    slice_param->LongSliceFlags.fields.slice_deblocking_filter_disabled_flag = sh->disable_deblocking_filter_flag;
-    slice_param->LongSliceFlags.fields.collocated_from_l0_flag = sh->collocated_list == L0 ? 1 : 0;
-    slice_param->LongSliceFlags.fields.slice_loop_filter_across_slices_enabled_flag = sh->slice_loop_filter_across_slices_enabled_flag;
-
-    slice_param->LongSliceFlags.fields.slice_sao_luma_flag = sh->slice_sample_adaptive_offset_flag[0];
-    if (h->ps.sps->chroma_format_idc) {
-        slice_param->LongSliceFlags.fields.slice_sao_chroma_flag = sh->slice_sample_adaptive_offset_flag[1];
-    }
-
-    if (sh->slice_temporal_mvp_enabled_flag) {
-        slice_param->collocated_ref_idx = sh->collocated_ref_idx;
-    } else {
-        slice_param->collocated_ref_idx = 0xFF;
+    const HEVCContext        *h = avctx->priv_data;
+    const SliceHeader       *sh = &h->sh;
+    VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;
+
+    int nb_list = (sh->slice_type == HEVC_SLICE_B) ?
+                  2 : (sh->slice_type == HEVC_SLICE_I ? 0 : 1);
+
+    int err, i, list_idx;
+
+    if (!sh->first_slice_in_pic_flag) {
+        err = ff_vaapi_decode_make_slice_buffer(avctx, &pic->pic,
+                                                &pic->last_slice_param, sizeof(pic->last_slice_param),
+                                                pic->last_buffer, pic->last_size);
+        pic->last_buffer = NULL;
+        pic->last_size   = 0;
+        if (err) {
+            ff_vaapi_decode_cancel(avctx, &pic->pic);
+            return err;
+        }
     }
 
-    slice_param->slice_qp_delta = sh->slice_qp_delta;
-    slice_param->slice_cb_qp_offset = sh->slice_cb_qp_offset;
-    slice_param->slice_cr_qp_offset = sh->slice_cr_qp_offset;
-    slice_param->slice_beta_offset_div2 = sh->beta_offset / 2;
-    slice_param->slice_tc_offset_div2 = sh->tc_offset / 2;
+    pic->last_slice_param = (VASliceParameterBufferHEVC) {
+        .slice_data_size               = size,
+        .slice_data_offset             = 0,
+        .slice_data_flag               = VA_SLICE_DATA_FLAG_ALL,
+        /* Add 1 to the bits count here to account for the byte_alignment bit, which
+         * always is at least one bit and not accounted for otherwise. */
+        .slice_data_byte_offset        = (get_bits_count(&h->HEVClc->gb) + 1 + 7) / 8,
+        .slice_segment_address         = sh->slice_segment_addr,
+        .slice_qp_delta                = sh->slice_qp_delta,
+        .slice_cb_qp_offset            = sh->slice_cb_qp_offset,
+        .slice_cr_qp_offset            = sh->slice_cr_qp_offset,
+        .slice_beta_offset_div2        = sh->beta_offset / 2,
+        .slice_tc_offset_div2          = sh->tc_offset / 2,
+        .collocated_ref_idx            = sh->slice_temporal_mvp_enabled_flag ? sh->collocated_ref_idx : 0xFF,
+        .five_minus_max_num_merge_cand = sh->slice_type == HEVC_SLICE_I ? 0 : 5 - sh->max_num_merge_cand,
+        .num_ref_idx_l0_active_minus1  = sh->nb_refs[L0] ? sh->nb_refs[L0] - 1 : 0,
+        .num_ref_idx_l1_active_minus1  = sh->nb_refs[L1] ? sh->nb_refs[L1] - 1 : 0,
+
+        .LongSliceFlags.fields = {
+            .dependent_slice_segment_flag                 = sh->dependent_slice_segment_flag,
+            .slice_type                                   = sh->slice_type,
+            .color_plane_id                               = sh->colour_plane_id,
+            .mvd_l1_zero_flag                             = sh->mvd_l1_zero_flag,
+            .cabac_init_flag                              = sh->cabac_init_flag,
+            .slice_temporal_mvp_enabled_flag              = sh->slice_temporal_mvp_enabled_flag,
+            .slice_deblocking_filter_disabled_flag        = sh->disable_deblocking_filter_flag,
+            .collocated_from_l0_flag                      = sh->collocated_list == L0 ? 1 : 0,
+            .slice_loop_filter_across_slices_enabled_flag = sh->slice_loop_filter_across_slices_enabled_flag,
+            .slice_sao_luma_flag                          = sh->slice_sample_adaptive_offset_flag[0],
+            .slice_sao_chroma_flag                        = sh->slice_sample_adaptive_offset_flag[1],
+        },
+    };
+
+    memset(pic->last_slice_param.RefPicList, 0xFF, sizeof(pic->last_slice_param.RefPicList));
+
+    for (list_idx = 0; list_idx < nb_list; list_idx++) {
+        RefPicList *rpl = &h->ref->refPicList[list_idx];
 
-    if (sh->slice_type == I_SLICE) {
-        slice_param->five_minus_max_num_merge_cand = 0;
-    } else {
-        slice_param->five_minus_max_num_merge_cand = 5 - sh->max_num_merge_cand;
+        for (i = 0; i < rpl->nb_refs; i++)
+            pic->last_slice_param.RefPicList[list_idx][i] = get_ref_pic_index(h, rpl->ref[i]);
     }
 
-    slice_param->num_ref_idx_l0_active_minus1 = sh->nb_refs[L0] ? sh->nb_refs[L0] - 1 : 0;
-    slice_param->num_ref_idx_l1_active_minus1 = sh->nb_refs[L1] ? sh->nb_refs[L1] - 1 : 0;
-
-    memset(slice_param->RefPicList, 0xFF, sizeof(slice_param->RefPicList));
+    fill_pred_weight_table(h, sh, &pic->last_slice_param);
 
-    /* h->ref->refPicList is updated befor calling each slice */
-    for (list_idx = 0; list_idx < nb_list; ++list_idx) {
-        RefPicList *rpl = &h->ref->refPicList[list_idx];
+    pic->last_buffer = buffer;
+    pic->last_size   = size;
 
-        for (i = 0; i < rpl->nb_refs; ++i) {
-            slice_param->RefPicList[list_idx][i] = get_ref_pic_index(h, rpl->ref[i]);
-        }
-    }
-
-    return fill_pred_weight_table(h, slice_param, sh);
+    return 0;
 }
 
 AVHWAccel ff_hevc_vaapi_hwaccel = {
@@ -483,8 +431,9 @@ AVHWAccel ff_hevc_vaapi_hwaccel = {
     .start_frame          = vaapi_hevc_start_frame,
     .end_frame            = vaapi_hevc_end_frame,
     .decode_slice         = vaapi_hevc_decode_slice,
-    .init                 = ff_vaapi_context_init,
-    .uninit               = ff_vaapi_context_fini,
-    .priv_data_size       = sizeof(FFVAContext),
-    .frame_priv_data_size = sizeof(vaapi_hevc_frame_data),
+    .frame_priv_data_size = sizeof(VAAPIDecodePictureHEVC),
+    .init                 = ff_vaapi_decode_init,
+    .uninit               = ff_vaapi_decode_uninit,
+    .priv_data_size       = sizeof(VAAPIDecodeContext),
+    .caps_internal        = HWACCEL_CAP_ASYNC_SAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_internal.h b/mythtv/external/FFmpeg/libavcodec/vaapi_internal.h
deleted file mode 100644
index 306ae13b376..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_internal.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Video Acceleration API (video decoding)
- * HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1
- *
- * Copyright (C) 2008-2009 Splitted-Desktop Systems
- *
- * 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_VAAPI_INTERNAL_H
-#define AVCODEC_VAAPI_INTERNAL_H
-
-#include <va/va.h>
-#include "vaapi.h"
-#include "avcodec.h"
-#include "internal.h"
-
-/**
- * @addtogroup VAAPI_Decoding
- *
- * @{
- */
-
-typedef struct {
-    VADisplay display;                  ///< Windowing system dependent handle
-    VAConfigID config_id;               ///< Configuration ID
-    VAContextID context_id;             ///< Context ID (video decode pipeline)
-    VABufferID pic_param_buf_id;        ///< Picture parameter buffer
-    VABufferID iq_matrix_buf_id;        ///< Inverse quantiser matrix buffer
-    VABufferID bitplane_buf_id;         ///< Bitplane buffer (for VC-1 decoding)
-    VABufferID *slice_buf_ids;          ///< Slice parameter/data buffers
-    unsigned int n_slice_buf_ids;       ///< Number of effective slice buffers
-    unsigned int slice_buf_ids_alloc;   ///< Number of allocated slice buffers
-    void *slice_params;                 ///< Pointer to slice parameter buffers
-    unsigned int slice_param_size;      ///< Size of a slice parameter element
-    unsigned int slice_params_alloc;    ///< Number of allocated slice parameters
-    unsigned int slice_count;           ///< Number of slices currently filled in
-    const uint8_t *slice_data;          ///< Pointer to slice data buffer base
-    unsigned int slice_data_size;       ///< Current size of slice data
-} FFVAContext;
-
-/** Extract vaapi_context from an AVCodecContext */
-static inline FFVAContext *ff_vaapi_get_context(AVCodecContext *avctx)
-{
-    return avctx->internal->hwaccel_priv_data;
-}
-
-/** Extract VASurfaceID from an AVFrame */
-static inline VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic)
-{
-    return (uintptr_t)pic->data[3];
-}
-
-/** Common AVHWAccel.init() implementation */
-int ff_vaapi_context_init(AVCodecContext *avctx);
-
-/** Common AVHWAccel.uninit() implementation */
-int ff_vaapi_context_fini(AVCodecContext *avctx);
-
-/** Common AVHWAccel.end_frame() implementation */
-void ff_vaapi_common_end_frame(AVCodecContext *avctx);
-
-/** Allocate a new picture parameter buffer */
-void *ff_vaapi_alloc_pic_param(FFVAContext *vactx, unsigned int size);
-
-/** Allocate a new IQ matrix buffer */
-void *ff_vaapi_alloc_iq_matrix(FFVAContext *vactx, unsigned int size);
-
-/** Allocate a new bit-plane buffer */
-uint8_t *ff_vaapi_alloc_bitplane(FFVAContext *vactx, uint32_t size);
-
-/**
- * Allocate a new slice descriptor for the input slice.
- *
- * @param vactx the VA API context
- * @param buffer the slice data buffer base
- * @param size the size of the slice in bytes
- * @return the newly allocated slice parameter
- */
-VASliceParameterBufferBase *ff_vaapi_alloc_slice(FFVAContext *vactx, const uint8_t *buffer, uint32_t size);
-
-int ff_vaapi_mpeg_end_frame(AVCodecContext *avctx);
-int ff_vaapi_commit_slices(FFVAContext *vactx);
-int ff_vaapi_render_picture(FFVAContext *vactx, VASurfaceID surface);
-
-/* @} */
-
-#endif /* AVCODEC_VAAPI_INTERNAL_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_mpeg2.c b/mythtv/external/FFmpeg/libavcodec/vaapi_mpeg2.c
index 9329e5450ae..0d197c96928 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_mpeg2.c
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_mpeg2.c
@@ -20,92 +20,122 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "hwaccel.h"
 #include "mpegutils.h"
 #include "mpegvideo.h"
-#include "vaapi_internal.h"
 #include "internal.h"
+#include "vaapi_decode.h"
 
 /** Reconstruct bitstream f_code */
-static inline int mpeg2_get_f_code(MpegEncContext *s)
+static inline int mpeg2_get_f_code(const MpegEncContext *s)
 {
     return (s->mpeg_f_code[0][0] << 12) | (s->mpeg_f_code[0][1] << 8) |
            (s->mpeg_f_code[1][0] <<  4) |  s->mpeg_f_code[1][1];
 }
 
 /** Determine frame start: first field for field picture or frame picture */
-static inline int mpeg2_get_is_frame_start(MpegEncContext *s)
+static inline int mpeg2_get_is_frame_start(const MpegEncContext *s)
 {
     return s->first_field || s->picture_structure == PICT_FRAME;
 }
 
 static int vaapi_mpeg2_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
 {
-    struct MpegEncContext * const s = avctx->priv_data;
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    VAPictureParameterBufferMPEG2 *pic_param;
-    VAIQMatrixBufferMPEG2 *iq_matrix;
-    int i;
-
-    vactx->slice_param_size = sizeof(VASliceParameterBufferMPEG2);
-
-    /* Fill in VAPictureParameterBufferMPEG2 */
-    pic_param = ff_vaapi_alloc_pic_param(vactx, sizeof(VAPictureParameterBufferMPEG2));
-    if (!pic_param)
-        return -1;
-    pic_param->horizontal_size                                  = s->width;
-    pic_param->vertical_size                                    = s->height;
-    pic_param->forward_reference_picture                        = VA_INVALID_ID;
-    pic_param->backward_reference_picture                       = VA_INVALID_ID;
-    pic_param->picture_coding_type                              = s->pict_type;
-    pic_param->f_code                                           = mpeg2_get_f_code(s);
-    pic_param->picture_coding_extension.value                   = 0; /* reset all bits */
-    pic_param->picture_coding_extension.bits.intra_dc_precision = s->intra_dc_precision;
-    pic_param->picture_coding_extension.bits.picture_structure  = s->picture_structure;
-    pic_param->picture_coding_extension.bits.top_field_first    = s->top_field_first;
-    pic_param->picture_coding_extension.bits.frame_pred_frame_dct = s->frame_pred_frame_dct;
-    pic_param->picture_coding_extension.bits.concealment_motion_vectors = s->concealment_motion_vectors;
-    pic_param->picture_coding_extension.bits.q_scale_type       = s->q_scale_type;
-    pic_param->picture_coding_extension.bits.intra_vlc_format   = s->intra_vlc_format;
-    pic_param->picture_coding_extension.bits.alternate_scan     = s->alternate_scan;
-    pic_param->picture_coding_extension.bits.repeat_first_field = s->repeat_first_field;
-    pic_param->picture_coding_extension.bits.progressive_frame  = s->progressive_frame;
-    pic_param->picture_coding_extension.bits.is_first_field     = mpeg2_get_is_frame_start(s);
+    const MpegEncContext *s = avctx->priv_data;
+    VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
+    VAPictureParameterBufferMPEG2 pic_param;
+    VAIQMatrixBufferMPEG2 iq_matrix;
+    int i, err;
+
+    pic->output_surface = ff_vaapi_get_surface_id(s->current_picture_ptr->f);
+
+    pic_param = (VAPictureParameterBufferMPEG2) {
+        .horizontal_size                 = s->width,
+        .vertical_size                   = s->height,
+        .forward_reference_picture       = VA_INVALID_ID,
+        .backward_reference_picture      = VA_INVALID_ID,
+        .picture_coding_type             = s->pict_type,
+        .f_code                          = mpeg2_get_f_code(s),
+        .picture_coding_extension.bits = {
+            .intra_dc_precision          = s->intra_dc_precision,
+            .picture_structure           = s->picture_structure,
+            .top_field_first             = s->top_field_first,
+            .frame_pred_frame_dct        = s->frame_pred_frame_dct,
+            .concealment_motion_vectors  = s->concealment_motion_vectors,
+            .q_scale_type                = s->q_scale_type,
+            .intra_vlc_format            = s->intra_vlc_format,
+            .alternate_scan              = s->alternate_scan,
+            .repeat_first_field          = s->repeat_first_field,
+            .progressive_frame           = s->progressive_frame,
+            .is_first_field              = mpeg2_get_is_frame_start(s),
+        },
+    };
 
     switch (s->pict_type) {
     case AV_PICTURE_TYPE_B:
-        pic_param->backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);
+        pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);
         // fall-through
     case AV_PICTURE_TYPE_P:
-        pic_param->forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);
+        pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);
         break;
     }
 
-    /* Fill in VAIQMatrixBufferMPEG2 */
-    iq_matrix = ff_vaapi_alloc_iq_matrix(vactx, sizeof(VAIQMatrixBufferMPEG2));
-    if (!iq_matrix)
-        return -1;
-    iq_matrix->load_intra_quantiser_matrix              = 1;
-    iq_matrix->load_non_intra_quantiser_matrix          = 1;
-    iq_matrix->load_chroma_intra_quantiser_matrix       = 1;
-    iq_matrix->load_chroma_non_intra_quantiser_matrix   = 1;
+    err = ff_vaapi_decode_make_param_buffer(avctx, pic,
+                                            VAPictureParameterBufferType,
+                                            &pic_param, sizeof(pic_param));
+    if (err < 0)
+        goto fail;
+
+    iq_matrix.load_intra_quantiser_matrix              = 1;
+    iq_matrix.load_non_intra_quantiser_matrix          = 1;
+    iq_matrix.load_chroma_intra_quantiser_matrix       = 1;
+    iq_matrix.load_chroma_non_intra_quantiser_matrix   = 1;
 
     for (i = 0; i < 64; i++) {
         int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
-        iq_matrix->intra_quantiser_matrix[i]            = s->intra_matrix[n];
-        iq_matrix->non_intra_quantiser_matrix[i]        = s->inter_matrix[n];
-        iq_matrix->chroma_intra_quantiser_matrix[i]     = s->chroma_intra_matrix[n];
-        iq_matrix->chroma_non_intra_quantiser_matrix[i] = s->chroma_inter_matrix[n];
+        iq_matrix.intra_quantiser_matrix[i]            = s->intra_matrix[n];
+        iq_matrix.non_intra_quantiser_matrix[i]        = s->inter_matrix[n];
+        iq_matrix.chroma_intra_quantiser_matrix[i]     = s->chroma_intra_matrix[n];
+        iq_matrix.chroma_non_intra_quantiser_matrix[i] = s->chroma_inter_matrix[n];
     }
+
+    err = ff_vaapi_decode_make_param_buffer(avctx, pic,
+                                            VAIQMatrixBufferType,
+                                            &iq_matrix, sizeof(iq_matrix));
+    if (err < 0)
+        goto fail;
+
     return 0;
+
+fail:
+    ff_vaapi_decode_cancel(avctx, pic);
+    return err;
+}
+
+static int vaapi_mpeg2_end_frame(AVCodecContext *avctx)
+{
+    MpegEncContext     *s   = avctx->priv_data;
+    VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
+    int ret;
+
+    ret = ff_vaapi_decode_issue(avctx, pic);
+    if (ret < 0)
+        goto fail;
+
+    ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
+
+fail:
+    return ret;
 }
 
 static int vaapi_mpeg2_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
 {
-    MpegEncContext * const s = avctx->priv_data;
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    VASliceParameterBufferMPEG2 *slice_param;
+    const MpegEncContext *s = avctx->priv_data;
+    VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
+    VASliceParameterBufferMPEG2 slice_param;
     GetBitContext gb;
     uint32_t quantiser_scale_code, intra_slice_flag, macroblock_offset;
+    int err;
 
     /* Determine macroblock_offset */
     init_get_bits(&gb, buffer, 8 * size);
@@ -120,27 +150,39 @@ static int vaapi_mpeg2_decode_slice(AVCodecContext *avctx, const uint8_t *buffer
     }
     macroblock_offset = get_bits_count(&gb);
 
-    /* Fill in VASliceParameterBufferMPEG2 */
-    slice_param = (VASliceParameterBufferMPEG2 *)ff_vaapi_alloc_slice(vactx, buffer, size);
-    if (!slice_param)
-        return -1;
-    slice_param->macroblock_offset              = macroblock_offset;
-    slice_param->slice_horizontal_position      = s->mb_x;
-    slice_param->slice_vertical_position        = s->mb_y >> (s->picture_structure != PICT_FRAME);
-    slice_param->quantiser_scale_code           = quantiser_scale_code;
-    slice_param->intra_slice_flag               = intra_slice_flag;
+    slice_param = (VASliceParameterBufferMPEG2) {
+        .slice_data_size            = size,
+        .slice_data_offset          = 0,
+        .slice_data_flag            = VA_SLICE_DATA_FLAG_ALL,
+        .macroblock_offset          = macroblock_offset,
+        .slice_horizontal_position  = s->mb_x,
+        .slice_vertical_position    = s->mb_y >> (s->picture_structure != PICT_FRAME),
+        .quantiser_scale_code       = quantiser_scale_code,
+        .intra_slice_flag           = intra_slice_flag,
+    };
+
+    err = ff_vaapi_decode_make_slice_buffer(avctx, pic,
+                                            &slice_param, sizeof(slice_param),
+                                            buffer, size);
+    if (err < 0) {
+        ff_vaapi_decode_cancel(avctx, pic);
+        return err;
+    }
+
     return 0;
 }
 
 AVHWAccel ff_mpeg2_vaapi_hwaccel = {
-    .name           = "mpeg2_vaapi",
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_MPEG2VIDEO,
-    .pix_fmt        = AV_PIX_FMT_VAAPI,
-    .start_frame    = vaapi_mpeg2_start_frame,
-    .end_frame      = ff_vaapi_mpeg_end_frame,
-    .decode_slice   = vaapi_mpeg2_decode_slice,
-    .init           = ff_vaapi_context_init,
-    .uninit         = ff_vaapi_context_fini,
-    .priv_data_size = sizeof(FFVAContext),
+    .name                 = "mpeg2_vaapi",
+    .type                 = AVMEDIA_TYPE_VIDEO,
+    .id                   = AV_CODEC_ID_MPEG2VIDEO,
+    .pix_fmt              = AV_PIX_FMT_VAAPI,
+    .start_frame          = &vaapi_mpeg2_start_frame,
+    .end_frame            = &vaapi_mpeg2_end_frame,
+    .decode_slice         = &vaapi_mpeg2_decode_slice,
+    .frame_priv_data_size = sizeof(VAAPIDecodePicture),
+    .init                 = &ff_vaapi_decode_init,
+    .uninit               = &ff_vaapi_decode_uninit,
+    .priv_data_size       = sizeof(VAAPIDecodeContext),
+    .caps_internal        = HWACCEL_CAP_ASYNC_SAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_mpeg4.c b/mythtv/external/FFmpeg/libavcodec/vaapi_mpeg4.c
index 725f00b0a6b..f8c5ddf2095 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_mpeg4.c
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_mpeg4.c
@@ -20,11 +20,12 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "vaapi_internal.h"
-#include "internal.h"
 #include "h263.h"
+#include "hwaccel.h"
+#include "internal.h"
 #include "mpeg4video.h"
 #include "mpegvideo.h"
+#include "vaapi_decode.h"
 
 /** Reconstruct bitstream intra_dc_vlc_thr */
 static int mpeg4_get_intra_dc_vlc_thr(Mpeg4DecContext *s)
@@ -45,121 +46,167 @@ static int mpeg4_get_intra_dc_vlc_thr(Mpeg4DecContext *s)
 static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
 {
     Mpeg4DecContext *ctx = avctx->priv_data;
-    MpegEncContext * const s = &ctx->m;
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    VAPictureParameterBufferMPEG4 *pic_param;
-    VAIQMatrixBufferMPEG4 *iq_matrix;
-    int i;
-
-    vactx->slice_param_size = sizeof(VASliceParameterBufferMPEG4);
-
-    /* Fill in VAPictureParameterBufferMPEG4 */
-    pic_param = ff_vaapi_alloc_pic_param(vactx, sizeof(VAPictureParameterBufferMPEG4));
-    if (!pic_param)
-        return -1;
-    pic_param->vop_width                                = s->width;
-    pic_param->vop_height                               = s->height;
-    pic_param->forward_reference_picture                = VA_INVALID_ID;
-    pic_param->backward_reference_picture               = VA_INVALID_ID;
-    pic_param->vol_fields.value                         = 0; /* reset all bits */
-    pic_param->vol_fields.bits.short_video_header       = avctx->codec->id == AV_CODEC_ID_H263;
-    pic_param->vol_fields.bits.chroma_format            = CHROMA_420;
-    pic_param->vol_fields.bits.interlaced               = !s->progressive_sequence;
-    pic_param->vol_fields.bits.obmc_disable             = 1;
-    pic_param->vol_fields.bits.sprite_enable            = ctx->vol_sprite_usage;
-    pic_param->vol_fields.bits.sprite_warping_accuracy  = s->sprite_warping_accuracy;
-    pic_param->vol_fields.bits.quant_type               = s->mpeg_quant;
-    pic_param->vol_fields.bits.quarter_sample           = s->quarter_sample;
-    pic_param->vol_fields.bits.data_partitioned         = s->data_partitioning;
-    pic_param->vol_fields.bits.reversible_vlc           = ctx->rvlc;
-    pic_param->vol_fields.bits.resync_marker_disable    = !ctx->resync_marker;
-    pic_param->no_of_sprite_warping_points              = ctx->num_sprite_warping_points;
+    MpegEncContext *s = &ctx->m;
+    VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
+    VAPictureParameterBufferMPEG4 pic_param;
+    int i, err;
+
+    pic->output_surface = ff_vaapi_get_surface_id(s->current_picture_ptr->f);
+
+    pic_param = (VAPictureParameterBufferMPEG4) {
+        .vop_width                        = s->width,
+        .vop_height                       = s->height,
+        .forward_reference_picture        = VA_INVALID_ID,
+        .backward_reference_picture       = VA_INVALID_ID,
+        .vol_fields.bits = {
+            .short_video_header           = avctx->codec->id == AV_CODEC_ID_H263,
+            .chroma_format                = CHROMA_420,
+            .interlaced                   = !s->progressive_sequence,
+            .obmc_disable                 = 1,
+            .sprite_enable                = ctx->vol_sprite_usage,
+            .sprite_warping_accuracy      = s->sprite_warping_accuracy,
+            .quant_type                   = s->mpeg_quant,
+            .quarter_sample               = s->quarter_sample,
+            .data_partitioned             = s->data_partitioning,
+            .reversible_vlc               = ctx->rvlc,
+            .resync_marker_disable        = !ctx->resync_marker,
+        },
+        .no_of_sprite_warping_points      = ctx->num_sprite_warping_points,
+        .quant_precision                  = s->quant_precision,
+        .vop_fields.bits = {
+            .vop_coding_type              = s->pict_type - AV_PICTURE_TYPE_I,
+            .backward_reference_vop_coding_type =
+                s->pict_type == AV_PICTURE_TYPE_B ? s->next_picture.f->pict_type - AV_PICTURE_TYPE_I : 0,
+            .vop_rounding_type            = s->no_rounding,
+            .intra_dc_vlc_thr             = mpeg4_get_intra_dc_vlc_thr(ctx),
+            .top_field_first              = s->top_field_first,
+            .alternate_vertical_scan_flag = s->alternate_scan,
+        },
+        .vop_fcode_forward                = s->f_code,
+        .vop_fcode_backward               = s->b_code,
+        .vop_time_increment_resolution    = avctx->framerate.num,
+        .num_macroblocks_in_gob           = s->mb_width * H263_GOB_HEIGHT(s->height),
+        .num_gobs_in_vop                  =
+            (s->mb_width * s->mb_height) / (s->mb_width * H263_GOB_HEIGHT(s->height)),
+        .TRB                              = s->pb_time,
+        .TRD                              = s->pp_time,
+    };
+
     for (i = 0; i < ctx->num_sprite_warping_points && i < 3; i++) {
-        pic_param->sprite_trajectory_du[i]              = ctx->sprite_traj[i][0];
-        pic_param->sprite_trajectory_dv[i]              = ctx->sprite_traj[i][1];
+        pic_param.sprite_trajectory_du[i]              = ctx->sprite_traj[i][0];
+        pic_param.sprite_trajectory_dv[i]              = ctx->sprite_traj[i][1];
     }
-    pic_param->quant_precision                          = s->quant_precision;
-    pic_param->vop_fields.value                         = 0; /* reset all bits */
-    pic_param->vop_fields.bits.vop_coding_type          = s->pict_type - AV_PICTURE_TYPE_I;
-    pic_param->vop_fields.bits.backward_reference_vop_coding_type = s->pict_type == AV_PICTURE_TYPE_B ? s->next_picture.f->pict_type - AV_PICTURE_TYPE_I : 0;
-    pic_param->vop_fields.bits.vop_rounding_type        = s->no_rounding;
-    pic_param->vop_fields.bits.intra_dc_vlc_thr         = mpeg4_get_intra_dc_vlc_thr(ctx);
-    pic_param->vop_fields.bits.top_field_first          = s->top_field_first;
-    pic_param->vop_fields.bits.alternate_vertical_scan_flag = s->alternate_scan;
-    pic_param->vop_fcode_forward                        = s->f_code;
-    pic_param->vop_fcode_backward                       = s->b_code;
-    pic_param->vop_time_increment_resolution            = avctx->framerate.num;
-    pic_param->num_macroblocks_in_gob                   = s->mb_width * H263_GOB_HEIGHT(s->height);
-    pic_param->num_gobs_in_vop                          = (s->mb_width * s->mb_height) / pic_param->num_macroblocks_in_gob;
-    pic_param->TRB                                      = s->pb_time;
-    pic_param->TRD                                      = s->pp_time;
 
     if (s->pict_type == AV_PICTURE_TYPE_B)
-        pic_param->backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);
+        pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);
     if (s->pict_type != AV_PICTURE_TYPE_I)
-        pic_param->forward_reference_picture  = ff_vaapi_get_surface_id(s->last_picture.f);
+        pic_param.forward_reference_picture  = ff_vaapi_get_surface_id(s->last_picture.f);
+
+    err = ff_vaapi_decode_make_param_buffer(avctx, pic,
+                                            VAPictureParameterBufferType,
+                                            &pic_param, sizeof(pic_param));
+    if (err < 0)
+        goto fail;
 
-    /* Fill in VAIQMatrixBufferMPEG4 */
     /* Only the first inverse quantisation method uses the weighting matrices */
-    if (pic_param->vol_fields.bits.quant_type) {
-        iq_matrix = ff_vaapi_alloc_iq_matrix(vactx, sizeof(VAIQMatrixBufferMPEG4));
-        if (!iq_matrix)
-            return -1;
-        iq_matrix->load_intra_quant_mat         = 1;
-        iq_matrix->load_non_intra_quant_mat     = 1;
+    if (pic_param.vol_fields.bits.quant_type) {
+        VAIQMatrixBufferMPEG4 iq_matrix;
+
+        iq_matrix.load_intra_quant_mat     = 1;
+        iq_matrix.load_non_intra_quant_mat = 1;
 
         for (i = 0; i < 64; i++) {
             int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
-            iq_matrix->intra_quant_mat[i]       = s->intra_matrix[n];
-            iq_matrix->non_intra_quant_mat[i]   = s->inter_matrix[n];
+            iq_matrix.intra_quant_mat[i]     = s->intra_matrix[n];
+            iq_matrix.non_intra_quant_mat[i] = s->inter_matrix[n];
         }
+
+        err = ff_vaapi_decode_make_param_buffer(avctx, pic,
+                                                VAIQMatrixBufferType,
+                                                &iq_matrix, sizeof(iq_matrix));
+        if (err < 0)
+            goto fail;
     }
     return 0;
+
+fail:
+    ff_vaapi_decode_cancel(avctx, pic);
+    return err;
+}
+
+static int vaapi_mpeg4_end_frame(AVCodecContext *avctx)
+{
+    MpegEncContext *s = avctx->priv_data;
+    VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
+    int ret;
+
+    ret = ff_vaapi_decode_issue(avctx, pic);
+    if (ret < 0)
+        goto fail;
+
+    ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
+
+fail:
+    return ret;
 }
 
 static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
 {
-    MpegEncContext * const s = avctx->priv_data;
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    VASliceParameterBufferMPEG4 *slice_param;
-
-    /* Fill in VASliceParameterBufferMPEG4 */
-    slice_param = (VASliceParameterBufferMPEG4 *)ff_vaapi_alloc_slice(vactx, buffer, size);
-    if (!slice_param)
-        return -1;
-    slice_param->macroblock_offset      = get_bits_count(&s->gb) % 8;
-    slice_param->macroblock_number      = 0;
-    slice_param->quant_scale            = s->qscale;
+    MpegEncContext *s = avctx->priv_data;
+    VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
+    VASliceParameterBufferMPEG4 slice_param;
+    int err;
+
+    slice_param = (VASliceParameterBufferMPEG4) {
+        .slice_data_size   = size,
+        .slice_data_offset = 0,
+        .slice_data_flag   = VA_SLICE_DATA_FLAG_ALL,
+        .macroblock_offset = get_bits_count(&s->gb) % 8,
+        .macroblock_number = 0,
+        .quant_scale       = s->qscale,
+    };
+
+    err = ff_vaapi_decode_make_slice_buffer(avctx, pic,
+                                            &slice_param, sizeof(slice_param),
+                                            buffer, size);
+    if (err < 0) {
+        ff_vaapi_decode_cancel(avctx, pic);
+        return err;
+    }
 
     return 0;
 }
 
 #if CONFIG_MPEG4_VAAPI_HWACCEL
 AVHWAccel ff_mpeg4_vaapi_hwaccel = {
-    .name           = "mpeg4_vaapi",
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_MPEG4,
-    .pix_fmt        = AV_PIX_FMT_VAAPI,
-    .start_frame    = vaapi_mpeg4_start_frame,
-    .end_frame      = ff_vaapi_mpeg_end_frame,
-    .decode_slice   = vaapi_mpeg4_decode_slice,
-    .init           = ff_vaapi_context_init,
-    .uninit         = ff_vaapi_context_fini,
-    .priv_data_size = sizeof(FFVAContext),
+    .name                 = "mpeg4_vaapi",
+    .type                 = AVMEDIA_TYPE_VIDEO,
+    .id                   = AV_CODEC_ID_MPEG4,
+    .pix_fmt              = AV_PIX_FMT_VAAPI,
+    .start_frame          = &vaapi_mpeg4_start_frame,
+    .end_frame            = &vaapi_mpeg4_end_frame,
+    .decode_slice         = &vaapi_mpeg4_decode_slice,
+    .frame_priv_data_size = sizeof(VAAPIDecodePicture),
+    .init                 = &ff_vaapi_decode_init,
+    .uninit               = &ff_vaapi_decode_uninit,
+    .priv_data_size       = sizeof(VAAPIDecodeContext),
+    .caps_internal        = HWACCEL_CAP_ASYNC_SAFE,
 };
 #endif
 
 #if CONFIG_H263_VAAPI_HWACCEL
 AVHWAccel ff_h263_vaapi_hwaccel = {
-    .name           = "h263_vaapi",
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_H263,
-    .pix_fmt        = AV_PIX_FMT_VAAPI,
-    .start_frame    = vaapi_mpeg4_start_frame,
-    .end_frame      = ff_vaapi_mpeg_end_frame,
-    .decode_slice   = vaapi_mpeg4_decode_slice,
-    .init           = ff_vaapi_context_init,
-    .uninit         = ff_vaapi_context_fini,
-    .priv_data_size = sizeof(FFVAContext),
+    .name                 = "h263_vaapi",
+    .type                 = AVMEDIA_TYPE_VIDEO,
+    .id                   = AV_CODEC_ID_H263,
+    .pix_fmt              = AV_PIX_FMT_VAAPI,
+    .start_frame          = &vaapi_mpeg4_start_frame,
+    .end_frame            = &vaapi_mpeg4_end_frame,
+    .decode_slice         = &vaapi_mpeg4_decode_slice,
+    .frame_priv_data_size = sizeof(VAAPIDecodePicture),
+    .init                 = &ff_vaapi_decode_init,
+    .uninit               = &ff_vaapi_decode_uninit,
+    .priv_data_size       = sizeof(VAAPIDecodeContext),
+    .caps_internal        = HWACCEL_CAP_ASYNC_SAFE,
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_vc1.c b/mythtv/external/FFmpeg/libavcodec/vaapi_vc1.c
index 4e82be1ae1a..30c9ed3c8b5 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_vc1.c
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_vc1.c
@@ -20,8 +20,9 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "vaapi_internal.h"
+#include "hwaccel.h"
 #include "internal.h"
+#include "vaapi_decode.h"
 #include "vc1.h"
 #include "vc1data.h"
 
@@ -39,7 +40,7 @@ static int get_VAMvModeVC1(enum MVModes mv_mode)
 }
 
 /** Check whether the MVTYPEMB bitplane is present */
-static inline int vc1_has_MVTYPEMB_bitplane(VC1Context *v)
+static inline int vc1_has_MVTYPEMB_bitplane(const VC1Context *v)
 {
     if (v->mv_type_is_raw)
         return 0;
@@ -50,7 +51,7 @@ static inline int vc1_has_MVTYPEMB_bitplane(VC1Context *v)
 }
 
 /** Check whether the SKIPMB bitplane is present */
-static inline int vc1_has_SKIPMB_bitplane(VC1Context *v)
+static inline int vc1_has_SKIPMB_bitplane(const VC1Context *v)
 {
     if (v->skip_is_raw)
         return 0;
@@ -59,7 +60,7 @@ static inline int vc1_has_SKIPMB_bitplane(VC1Context *v)
 }
 
 /** Check whether the DIRECTMB bitplane is present */
-static inline int vc1_has_DIRECTMB_bitplane(VC1Context *v)
+static inline int vc1_has_DIRECTMB_bitplane(const VC1Context *v)
 {
     if (v->dmb_is_raw)
         return 0;
@@ -67,7 +68,7 @@ static inline int vc1_has_DIRECTMB_bitplane(VC1Context *v)
 }
 
 /** Check whether the ACPRED bitplane is present */
-static inline int vc1_has_ACPRED_bitplane(VC1Context *v)
+static inline int vc1_has_ACPRED_bitplane(const VC1Context *v)
 {
     if (v->acpred_is_raw)
         return 0;
@@ -77,7 +78,7 @@ static inline int vc1_has_ACPRED_bitplane(VC1Context *v)
 }
 
 /** Check whether the OVERFLAGS bitplane is present */
-static inline int vc1_has_OVERFLAGS_bitplane(VC1Context *v)
+static inline int vc1_has_OVERFLAGS_bitplane(const VC1Context *v)
 {
     if (v->overflg_is_raw)
         return 0;
@@ -89,9 +90,9 @@ static inline int vc1_has_OVERFLAGS_bitplane(VC1Context *v)
 }
 
 /** Reconstruct bitstream PTYPE (7.1.1.4, index into Table-35) */
-static int vc1_get_PTYPE(VC1Context *v)
+static int vc1_get_PTYPE(const VC1Context *v)
 {
-    MpegEncContext * const s = &v->s;
+    const MpegEncContext *s = &v->s;
     switch (s->pict_type) {
     case AV_PICTURE_TYPE_I: return 0;
     case AV_PICTURE_TYPE_P: return v->p_frame_skipped ? 4 : 1;
@@ -101,7 +102,7 @@ static int vc1_get_PTYPE(VC1Context *v)
 }
 
 /** Reconstruct bitstream MVMODE (7.1.1.32) */
-static inline VAMvModeVC1 vc1_get_MVMODE(VC1Context *v)
+static inline VAMvModeVC1 vc1_get_MVMODE(const VC1Context *v)
 {
     if (v->s.pict_type == AV_PICTURE_TYPE_P ||
         (v->s.pict_type == AV_PICTURE_TYPE_B && !v->bi_type))
@@ -110,7 +111,7 @@ static inline VAMvModeVC1 vc1_get_MVMODE(VC1Context *v)
 }
 
 /** Reconstruct bitstream MVMODE2 (7.1.1.33) */
-static inline VAMvModeVC1 vc1_get_MVMODE2(VC1Context *v)
+static inline VAMvModeVC1 vc1_get_MVMODE2(const VC1Context *v)
 {
     if (v->s.pict_type == AV_PICTURE_TYPE_P && v->mv_mode == MV_PMODE_INTENSITY_COMP)
         return get_VAMvModeVC1(v->mv_mode2);
@@ -118,7 +119,7 @@ static inline VAMvModeVC1 vc1_get_MVMODE2(VC1Context *v)
 }
 
 /** Reconstruct bitstream TTFRM (7.1.1.41, Table-53) */
-static inline int vc1_get_TTFRM(VC1Context *v)
+static inline int vc1_get_TTFRM(const VC1Context *v)
 {
     switch (v->ttfrm) {
     case TT_8X8: return 0;
@@ -146,147 +147,167 @@ static inline void vc1_pack_bitplanes(uint8_t *bitplane, int n, const uint8_t *f
 
 static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
 {
-    VC1Context * const v = avctx->priv_data;
-    MpegEncContext * const s = &v->s;
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    VAPictureParameterBufferVC1 *pic_param;
-
-    vactx->slice_param_size = sizeof(VASliceParameterBufferVC1);
-
-    /* Fill in VAPictureParameterBufferVC1 */
-    pic_param = ff_vaapi_alloc_pic_param(vactx, sizeof(VAPictureParameterBufferVC1));
-    if (!pic_param)
-        return -1;
-    pic_param->forward_reference_picture                            = VA_INVALID_ID;
-    pic_param->backward_reference_picture                           = VA_INVALID_ID;
-    pic_param->inloop_decoded_picture                               = VA_INVALID_ID;
-    pic_param->sequence_fields.value                                = 0; /* reset all bits */
-    pic_param->sequence_fields.bits.pulldown                        = v->broadcast;
-    pic_param->sequence_fields.bits.interlace                       = v->interlace;
-    pic_param->sequence_fields.bits.tfcntrflag                      = v->tfcntrflag;
-    pic_param->sequence_fields.bits.finterpflag                     = v->finterpflag;
-    pic_param->sequence_fields.bits.psf                             = v->psf;
-    pic_param->sequence_fields.bits.multires                        = v->multires;
-    pic_param->sequence_fields.bits.overlap                         = v->overlap;
-    pic_param->sequence_fields.bits.syncmarker                      = v->resync_marker;
-    pic_param->sequence_fields.bits.rangered                        = v->rangered;
-    pic_param->sequence_fields.bits.max_b_frames                    = s->avctx->max_b_frames;
-#if VA_CHECK_VERSION(0,32,0)
-    pic_param->sequence_fields.bits.profile                         = v->profile;
-#endif
-    pic_param->coded_width                                          = s->avctx->coded_width;
-    pic_param->coded_height                                         = s->avctx->coded_height;
-    pic_param->entrypoint_fields.value                              = 0; /* reset all bits */
-    pic_param->entrypoint_fields.bits.broken_link                   = v->broken_link;
-    pic_param->entrypoint_fields.bits.closed_entry                  = v->closed_entry;
-    pic_param->entrypoint_fields.bits.panscan_flag                  = v->panscanflag;
-    pic_param->entrypoint_fields.bits.loopfilter                    = s->loop_filter;
-    pic_param->conditional_overlap_flag                             = v->condover;
-    pic_param->fast_uvmc_flag                                       = v->fastuvmc;
-    pic_param->range_mapping_fields.value                           = 0; /* reset all bits */
-    pic_param->range_mapping_fields.bits.luma_flag                  = v->range_mapy_flag;
-    pic_param->range_mapping_fields.bits.luma                       = v->range_mapy;
-    pic_param->range_mapping_fields.bits.chroma_flag                = v->range_mapuv_flag;
-    pic_param->range_mapping_fields.bits.chroma                     = v->range_mapuv;
-    pic_param->b_picture_fraction                                   = v->bfraction_lut_index;
-    pic_param->cbp_table                                            = v->cbpcy_vlc ? v->cbpcy_vlc - ff_vc1_cbpcy_p_vlc : 0;
-    pic_param->mb_mode_table                                        = 0; /* XXX: interlaced frame */
-    pic_param->range_reduction_frame                                = v->rangeredfrm;
-    pic_param->rounding_control                                     = v->rnd;
-    pic_param->post_processing                                      = v->postproc;
-    pic_param->picture_resolution_index                             = v->respic;
-    pic_param->luma_scale                                           = v->lumscale;
-    pic_param->luma_shift                                           = v->lumshift;
-    pic_param->picture_fields.value                                 = 0; /* reset all bits */
-    pic_param->picture_fields.bits.picture_type                     = vc1_get_PTYPE(v);
-    pic_param->picture_fields.bits.frame_coding_mode                = v->fcm;
-    pic_param->picture_fields.bits.top_field_first                  = v->tff;
-    pic_param->picture_fields.bits.is_first_field                   = v->fcm == 0; /* XXX: interlaced frame */
-    pic_param->picture_fields.bits.intensity_compensation           = v->mv_mode == MV_PMODE_INTENSITY_COMP;
-    pic_param->raw_coding.value                                     = 0; /* reset all bits */
-    pic_param->raw_coding.flags.mv_type_mb                          = v->mv_type_is_raw;
-    pic_param->raw_coding.flags.direct_mb                           = v->dmb_is_raw;
-    pic_param->raw_coding.flags.skip_mb                             = v->skip_is_raw;
-    pic_param->raw_coding.flags.field_tx                            = 0; /* XXX: interlaced frame */
-    pic_param->raw_coding.flags.forward_mb                          = 0; /* XXX: interlaced frame */
-    pic_param->raw_coding.flags.ac_pred                             = v->acpred_is_raw;
-    pic_param->raw_coding.flags.overflags                           = v->overflg_is_raw;
-    pic_param->bitplane_present.value                               = 0; /* reset all bits */
-    pic_param->bitplane_present.flags.bp_mv_type_mb                 = vc1_has_MVTYPEMB_bitplane(v);
-    pic_param->bitplane_present.flags.bp_direct_mb                  = vc1_has_DIRECTMB_bitplane(v);
-    pic_param->bitplane_present.flags.bp_skip_mb                    = vc1_has_SKIPMB_bitplane(v);
-    pic_param->bitplane_present.flags.bp_field_tx                   = 0; /* XXX: interlaced frame */
-    pic_param->bitplane_present.flags.bp_forward_mb                 = 0; /* XXX: interlaced frame */
-    pic_param->bitplane_present.flags.bp_ac_pred                    = vc1_has_ACPRED_bitplane(v);
-    pic_param->bitplane_present.flags.bp_overflags                  = vc1_has_OVERFLAGS_bitplane(v);
-    pic_param->reference_fields.value                               = 0; /* reset all bits */
-    pic_param->reference_fields.bits.reference_distance_flag        = v->refdist_flag;
-    pic_param->reference_fields.bits.reference_distance             = 0; /* XXX: interlaced frame */
-    pic_param->reference_fields.bits.num_reference_pictures         = 0; /* XXX: interlaced frame */
-    pic_param->reference_fields.bits.reference_field_pic_indicator  = 0; /* XXX: interlaced frame */
-    pic_param->mv_fields.value                                      = 0; /* reset all bits */
-    pic_param->mv_fields.bits.mv_mode                               = vc1_get_MVMODE(v);
-    pic_param->mv_fields.bits.mv_mode2                              = vc1_get_MVMODE2(v);
-    pic_param->mv_fields.bits.mv_table                              = s->mv_table_index;
-    pic_param->mv_fields.bits.two_mv_block_pattern_table            = 0; /* XXX: interlaced frame */
-    pic_param->mv_fields.bits.four_mv_switch                        = 0; /* XXX: interlaced frame */
-    pic_param->mv_fields.bits.four_mv_block_pattern_table           = 0; /* XXX: interlaced frame */
-    pic_param->mv_fields.bits.extended_mv_flag                      = v->extended_mv;
-    pic_param->mv_fields.bits.extended_mv_range                     = v->mvrange;
-    pic_param->mv_fields.bits.extended_dmv_flag                     = v->extended_dmv;
-    pic_param->mv_fields.bits.extended_dmv_range                    = 0; /* XXX: interlaced frame */
-    pic_param->pic_quantizer_fields.value                           = 0; /* reset all bits */
-    pic_param->pic_quantizer_fields.bits.dquant                     = v->dquant;
-    pic_param->pic_quantizer_fields.bits.quantizer                  = v->quantizer_mode;
-    pic_param->pic_quantizer_fields.bits.half_qp                    = v->halfpq;
-    pic_param->pic_quantizer_fields.bits.pic_quantizer_scale        = v->pq;
-    pic_param->pic_quantizer_fields.bits.pic_quantizer_type         = v->pquantizer;
-    pic_param->pic_quantizer_fields.bits.dq_frame                   = v->dquantfrm;
-    pic_param->pic_quantizer_fields.bits.dq_profile                 = v->dqprofile;
-    pic_param->pic_quantizer_fields.bits.dq_sb_edge                 = v->dqprofile == DQPROFILE_SINGLE_EDGE  ? v->dqsbedge : 0;
-    pic_param->pic_quantizer_fields.bits.dq_db_edge                 = v->dqprofile == DQPROFILE_DOUBLE_EDGES ? v->dqsbedge : 0;
-    pic_param->pic_quantizer_fields.bits.dq_binary_level            = v->dqbilevel;
-    pic_param->pic_quantizer_fields.bits.alt_pic_quantizer          = v->altpq;
-    pic_param->transform_fields.value                               = 0; /* reset all bits */
-    pic_param->transform_fields.bits.variable_sized_transform_flag  = v->vstransform;
-    pic_param->transform_fields.bits.mb_level_transform_type_flag   = v->ttmbf;
-    pic_param->transform_fields.bits.frame_level_transform_type     = vc1_get_TTFRM(v);
-    pic_param->transform_fields.bits.transform_ac_codingset_idx1    = v->c_ac_table_index;
-    pic_param->transform_fields.bits.transform_ac_codingset_idx2    = v->y_ac_table_index;
-    pic_param->transform_fields.bits.intra_transform_dc_table       = v->s.dc_table_index;
+    const VC1Context *v = avctx->priv_data;
+    const MpegEncContext *s = &v->s;
+    VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
+    VAPictureParameterBufferVC1 pic_param;
+    int err;
+
+    pic->output_surface = ff_vaapi_get_surface_id(s->current_picture_ptr->f);
+
+    pic_param = (VAPictureParameterBufferVC1) {
+        .forward_reference_picture         = VA_INVALID_ID,
+        .backward_reference_picture        = VA_INVALID_ID,
+        .inloop_decoded_picture            = VA_INVALID_ID,
+        .sequence_fields.bits = {
+            .pulldown                      = v->broadcast,
+            .interlace                     = v->interlace,
+            .tfcntrflag                    = v->tfcntrflag,
+            .finterpflag                   = v->finterpflag,
+            .psf                           = v->psf,
+            .multires                      = v->multires,
+            .overlap                       = v->overlap,
+            .syncmarker                    = v->resync_marker,
+            .rangered                      = v->rangered,
+            .max_b_frames                  = s->avctx->max_b_frames,
+            .profile                       = v->profile,
+        },
+        .coded_width                       = s->avctx->coded_width,
+        .coded_height                      = s->avctx->coded_height,
+        .entrypoint_fields.bits = {
+            .broken_link                   = v->broken_link,
+            .closed_entry                  = v->closed_entry,
+            .panscan_flag                  = v->panscanflag,
+            .loopfilter                    = s->loop_filter,
+        },
+        .conditional_overlap_flag          = v->condover,
+        .fast_uvmc_flag                    = v->fastuvmc,
+        .range_mapping_fields.bits = {
+            .luma_flag                     = v->range_mapy_flag,
+            .luma                          = v->range_mapy,
+            .chroma_flag                   = v->range_mapuv_flag,
+            .chroma                        = v->range_mapuv,
+        },
+        .b_picture_fraction                = v->bfraction_lut_index,
+        .cbp_table                         = v->cbpcy_vlc ? v->cbpcy_vlc - ff_vc1_cbpcy_p_vlc : 0,
+        .mb_mode_table                     = 0, /* XXX: interlaced frame */
+        .range_reduction_frame             = v->rangeredfrm,
+        .rounding_control                  = v->rnd,
+        .post_processing                   = v->postproc,
+        .picture_resolution_index          = v->respic,
+        .luma_scale                        = v->lumscale,
+        .luma_shift                        = v->lumshift,
+        .picture_fields.bits = {
+            .picture_type                  = vc1_get_PTYPE(v),
+            .frame_coding_mode             = v->fcm,
+            .top_field_first               = v->tff,
+            .is_first_field                = v->fcm == 0, /* XXX: interlaced frame */
+            .intensity_compensation        = v->mv_mode == MV_PMODE_INTENSITY_COMP,
+        },
+        .raw_coding.flags = {
+            .mv_type_mb                    = v->mv_type_is_raw,
+            .direct_mb                     = v->dmb_is_raw,
+            .skip_mb                       = v->skip_is_raw,
+            .field_tx                      = 0, /* XXX: interlaced frame */
+            .forward_mb                    = 0, /* XXX: interlaced frame */
+            .ac_pred                       = v->acpred_is_raw,
+            .overflags                     = v->overflg_is_raw,
+        },
+        .bitplane_present.flags = {
+            .bp_mv_type_mb                 = vc1_has_MVTYPEMB_bitplane(v),
+            .bp_direct_mb                  = vc1_has_DIRECTMB_bitplane(v),
+            .bp_skip_mb                    = vc1_has_SKIPMB_bitplane(v),
+            .bp_field_tx                   = 0, /* XXX: interlaced frame */
+            .bp_forward_mb                 = 0, /* XXX: interlaced frame */
+            .bp_ac_pred                    = vc1_has_ACPRED_bitplane(v),
+            .bp_overflags                  = vc1_has_OVERFLAGS_bitplane(v),
+        },
+        .reference_fields.bits = {
+            .reference_distance_flag       = v->refdist_flag,
+            .reference_distance            = 0, /* XXX: interlaced frame */
+            .num_reference_pictures        = 0, /* XXX: interlaced frame */
+            .reference_field_pic_indicator = 0, /* XXX: interlaced frame */
+        },
+        .mv_fields.bits = {
+            .mv_mode                       = vc1_get_MVMODE(v),
+            .mv_mode2                      = vc1_get_MVMODE2(v),
+            .mv_table                      = s->mv_table_index,
+            .two_mv_block_pattern_table    = 0, /* XXX: interlaced frame */
+            .four_mv_switch                = 0, /* XXX: interlaced frame */
+            .four_mv_block_pattern_table   = 0, /* XXX: interlaced frame */
+            .extended_mv_flag              = v->extended_mv,
+            .extended_mv_range             = v->mvrange,
+            .extended_dmv_flag             = v->extended_dmv,
+            .extended_dmv_range            = 0, /* XXX: interlaced frame */
+        },
+        .pic_quantizer_fields.bits = {
+            .dquant                        = v->dquant,
+            .quantizer                     = v->quantizer_mode,
+            .half_qp                       = v->halfpq,
+            .pic_quantizer_scale           = v->pq,
+            .pic_quantizer_type            = v->pquantizer,
+            .dq_frame                      = v->dquantfrm,
+            .dq_profile                    = v->dqprofile,
+            .dq_sb_edge                    = v->dqprofile == DQPROFILE_SINGLE_EDGE  ? v->dqsbedge : 0,
+            .dq_db_edge                    = v->dqprofile == DQPROFILE_DOUBLE_EDGES ? v->dqsbedge : 0,
+            .dq_binary_level               = v->dqbilevel,
+            .alt_pic_quantizer             = v->altpq,
+        },
+        .transform_fields.bits = {
+            .variable_sized_transform_flag = v->vstransform,
+            .mb_level_transform_type_flag  = v->ttmbf,
+            .frame_level_transform_type    = vc1_get_TTFRM(v),
+            .transform_ac_codingset_idx1   = v->c_ac_table_index,
+            .transform_ac_codingset_idx2   = v->y_ac_table_index,
+            .intra_transform_dc_table      = v->s.dc_table_index,
+        },
+    };
 
     switch (s->pict_type) {
     case AV_PICTURE_TYPE_B:
-        pic_param->backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);
+        pic_param.backward_reference_picture = ff_vaapi_get_surface_id(s->next_picture.f);
         // fall-through
     case AV_PICTURE_TYPE_P:
-        pic_param->forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);
+        pic_param.forward_reference_picture = ff_vaapi_get_surface_id(s->last_picture.f);
         break;
     }
 
-    if (pic_param->bitplane_present.value) {
+    err = ff_vaapi_decode_make_param_buffer(avctx, pic,
+                                            VAPictureParameterBufferType,
+                                            &pic_param, sizeof(pic_param));
+    if (err)
+        goto fail;
+
+    if (pic_param.bitplane_present.value) {
         uint8_t *bitplane;
         const uint8_t *ff_bp[3];
         int x, y, n;
+        size_t size = (s->mb_width * s->mb_height + 1) / 2;
+
+        bitplane = av_mallocz(size);
+        if (!bitplane) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
 
         switch (s->pict_type) {
         case AV_PICTURE_TYPE_P:
-            ff_bp[0] = pic_param->bitplane_present.flags.bp_direct_mb  ? v->direct_mb_plane    : NULL;
-            ff_bp[1] = pic_param->bitplane_present.flags.bp_skip_mb    ? s->mbskip_table       : NULL;
-            ff_bp[2] = pic_param->bitplane_present.flags.bp_mv_type_mb ? v->mv_type_mb_plane   : NULL;
+            ff_bp[0] = pic_param.bitplane_present.flags.bp_direct_mb  ? v->direct_mb_plane    : NULL;
+            ff_bp[1] = pic_param.bitplane_present.flags.bp_skip_mb    ? s->mbskip_table       : NULL;
+            ff_bp[2] = pic_param.bitplane_present.flags.bp_mv_type_mb ? v->mv_type_mb_plane   : NULL;
             break;
         case AV_PICTURE_TYPE_B:
             if (!v->bi_type) {
-                ff_bp[0] = pic_param->bitplane_present.flags.bp_direct_mb ? v->direct_mb_plane : NULL;
-                ff_bp[1] = pic_param->bitplane_present.flags.bp_skip_mb   ? s->mbskip_table    : NULL;
+                ff_bp[0] = pic_param.bitplane_present.flags.bp_direct_mb ? v->direct_mb_plane : NULL;
+                ff_bp[1] = pic_param.bitplane_present.flags.bp_skip_mb   ? s->mbskip_table    : NULL;
                 ff_bp[2] = NULL; /* XXX: interlaced frame (FORWARD plane) */
                 break;
             }
             /* fall-through (BI-type) */
         case AV_PICTURE_TYPE_I:
             ff_bp[0] = NULL; /* XXX: interlaced frame (FIELDTX plane) */
-            ff_bp[1] = pic_param->bitplane_present.flags.bp_ac_pred    ? v->acpred_plane       : NULL;
-            ff_bp[2] = pic_param->bitplane_present.flags.bp_overflags  ? v->over_flags_plane   : NULL;
+            ff_bp[1] = pic_param.bitplane_present.flags.bp_ac_pred    ? v->acpred_plane       : NULL;
+            ff_bp[2] = pic_param.bitplane_present.flags.bp_overflags  ? v->over_flags_plane   : NULL;
             break;
         default:
             ff_bp[0] = NULL;
@@ -295,26 +316,51 @@ static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t
             break;
         }
 
-        bitplane = ff_vaapi_alloc_bitplane(vactx, (s->mb_width * s->mb_height + 1) / 2);
-        if (!bitplane)
-            return -1;
-
         n = 0;
         for (y = 0; y < s->mb_height; y++)
             for (x = 0; x < s->mb_width; x++, n++)
                 vc1_pack_bitplanes(bitplane, n, ff_bp, x, y, s->mb_stride);
         if (n & 1) /* move last nibble to the high order */
             bitplane[n/2] <<= 4;
+
+        err = ff_vaapi_decode_make_param_buffer(avctx, pic,
+                                                VABitPlaneBufferType,
+                                                bitplane, size);
+        av_free(bitplane);
+        if (err)
+            goto fail;
     }
     return 0;
+
+fail:
+    ff_vaapi_decode_cancel(avctx, pic);
+    return err;
+}
+
+static int vaapi_vc1_end_frame(AVCodecContext *avctx)
+{
+    VC1Context *v = avctx->priv_data;
+    MpegEncContext *s = &v->s;
+    VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
+    int ret;
+
+    ret = ff_vaapi_decode_issue(avctx, pic);
+    if (ret < 0)
+        goto fail;
+
+    ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
+
+fail:
+    return ret;
 }
 
 static int vaapi_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
 {
-    VC1Context * const v = avctx->priv_data;
-    MpegEncContext * const s = &v->s;
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    VASliceParameterBufferVC1 *slice_param;
+    const VC1Context *v = avctx->priv_data;
+    const MpegEncContext *s = &v->s;
+    VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
+    VASliceParameterBufferVC1 slice_param;
+    int err;
 
     /* Current bit buffer is beyond any marker for VC-1, so skip it */
     if (avctx->codec_id == AV_CODEC_ID_VC1 && IS_MARKER(AV_RB32(buffer))) {
@@ -322,39 +368,53 @@ static int vaapi_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer,
         size -= 4;
     }
 
-    /* Fill in VASliceParameterBufferVC1 */
-    slice_param = (VASliceParameterBufferVC1 *)ff_vaapi_alloc_slice(vactx, buffer, size);
-    if (!slice_param)
-        return -1;
-    slice_param->macroblock_offset       = get_bits_count(&s->gb);
-    slice_param->slice_vertical_position = s->mb_y;
+    slice_param = (VASliceParameterBufferVC1) {
+        .slice_data_size         = size,
+        .slice_data_offset       = 0,
+        .slice_data_flag         = VA_SLICE_DATA_FLAG_ALL,
+        .macroblock_offset       = get_bits_count(&s->gb),
+        .slice_vertical_position = s->mb_y,
+    };
+
+    err = ff_vaapi_decode_make_slice_buffer(avctx, pic,
+                                            &slice_param, sizeof(slice_param),
+                                            buffer, size);
+    if (err < 0) {
+        ff_vaapi_decode_cancel(avctx, pic);
+        return err;
+    }
+
     return 0;
 }
 
 #if CONFIG_WMV3_VAAPI_HWACCEL
 AVHWAccel ff_wmv3_vaapi_hwaccel = {
-    .name           = "wmv3_vaapi",
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_WMV3,
-    .pix_fmt        = AV_PIX_FMT_VAAPI,
-    .start_frame    = vaapi_vc1_start_frame,
-    .end_frame      = ff_vaapi_mpeg_end_frame,
-    .decode_slice   = vaapi_vc1_decode_slice,
-    .init           = ff_vaapi_context_init,
-    .uninit         = ff_vaapi_context_fini,
-    .priv_data_size = sizeof(FFVAContext),
+    .name                 = "wmv3_vaapi",
+    .type                 = AVMEDIA_TYPE_VIDEO,
+    .id                   = AV_CODEC_ID_WMV3,
+    .pix_fmt              = AV_PIX_FMT_VAAPI,
+    .start_frame          = &vaapi_vc1_start_frame,
+    .end_frame            = &vaapi_vc1_end_frame,
+    .decode_slice         = &vaapi_vc1_decode_slice,
+    .frame_priv_data_size = sizeof(VAAPIDecodePicture),
+    .init                 = &ff_vaapi_decode_init,
+    .uninit               = &ff_vaapi_decode_uninit,
+    .priv_data_size       = sizeof(VAAPIDecodeContext),
+    .caps_internal        = HWACCEL_CAP_ASYNC_SAFE,
 };
 #endif
 
 AVHWAccel ff_vc1_vaapi_hwaccel = {
-    .name           = "vc1_vaapi",
-    .type           = AVMEDIA_TYPE_VIDEO,
-    .id             = AV_CODEC_ID_VC1,
-    .pix_fmt        = AV_PIX_FMT_VAAPI,
-    .start_frame    = vaapi_vc1_start_frame,
-    .end_frame      = ff_vaapi_mpeg_end_frame,
-    .decode_slice   = vaapi_vc1_decode_slice,
-    .init           = ff_vaapi_context_init,
-    .uninit         = ff_vaapi_context_fini,
-    .priv_data_size = sizeof(FFVAContext),
+    .name                 = "vc1_vaapi",
+    .type                 = AVMEDIA_TYPE_VIDEO,
+    .id                   = AV_CODEC_ID_VC1,
+    .pix_fmt              = AV_PIX_FMT_VAAPI,
+    .start_frame          = &vaapi_vc1_start_frame,
+    .end_frame            = &vaapi_vc1_end_frame,
+    .decode_slice         = &vaapi_vc1_decode_slice,
+    .frame_priv_data_size = sizeof(VAAPIDecodePicture),
+    .init                 = &ff_vaapi_decode_init,
+    .uninit               = &ff_vaapi_decode_uninit,
+    .priv_data_size       = sizeof(VAAPIDecodeContext),
+    .caps_internal        = HWACCEL_CAP_ASYNC_SAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/vaapi_vp9.c b/mythtv/external/FFmpeg/libavcodec/vaapi_vp9.c
index b360dcb7117..d8ece75df4f 100644
--- a/mythtv/external/FFmpeg/libavcodec/vaapi_vp9.c
+++ b/mythtv/external/FFmpeg/libavcodec/vaapi_vp9.c
@@ -21,134 +21,148 @@
  */
 
 #include "libavutil/pixdesc.h"
-#include "vaapi_internal.h"
-#include "vp9.h"
 
-static void fill_picture_parameters(AVCodecContext                 *avctx,
-                                    const VP9SharedContext         *h,
-                                    VADecPictureParameterBufferVP9 *pp)
+#include "hwaccel.h"
+#include "vaapi_decode.h"
+#include "vp9shared.h"
+
+static VASurfaceID vaapi_vp9_surface_id(const VP9Frame *vf)
 {
+    if (vf)
+        return ff_vaapi_get_surface_id(vf->tf.f);
+    else
+        return VA_INVALID_SURFACE;
+}
+
+static int vaapi_vp9_start_frame(AVCodecContext          *avctx,
+                                 av_unused const uint8_t *buffer,
+                                 av_unused uint32_t       size)
+{
+    const VP9SharedContext *h = avctx->priv_data;
+    VAAPIDecodePicture *pic = h->frames[CUR_FRAME].hwaccel_picture_private;
+    VADecPictureParameterBufferVP9 pic_param;
     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
-    int i;
-
-    pp->frame_width = avctx->width;
-    pp->frame_height = avctx->height;
-
-    pp->frame_header_length_in_bytes = h->h.uncompressed_header_size;
-    pp->first_partition_size = h->h.compressed_header_size;
-
-    pp->profile = h->h.profile;
-
-    pp->filter_level = h->h.filter.level;
-    pp->sharpness_level = h->h.filter.sharpness;
-    pp->log2_tile_rows = h->h.tiling.log2_tile_rows;
-    pp->log2_tile_columns = h->h.tiling.log2_tile_cols;
-
-    pp->pic_fields.bits.subsampling_x = pixdesc->log2_chroma_w;
-    pp->pic_fields.bits.subsampling_y = pixdesc->log2_chroma_h;
-    pp->pic_fields.bits.frame_type = !h->h.keyframe;
-    pp->pic_fields.bits.show_frame = !h->h.invisible;
-    pp->pic_fields.bits.error_resilient_mode = h->h.errorres;
-    pp->pic_fields.bits.intra_only = h->h.intraonly;
-    pp->pic_fields.bits.allow_high_precision_mv = h->h.keyframe ? 0 : h->h.highprecisionmvs;
-    pp->pic_fields.bits.mcomp_filter_type = h->h.filtermode ^ (h->h.filtermode <= 1);
-    pp->pic_fields.bits.frame_parallel_decoding_mode = h->h.parallelmode;
-    pp->pic_fields.bits.reset_frame_context = h->h.resetctx;
-    pp->pic_fields.bits.refresh_frame_context = h->h.refreshctx;
-    pp->pic_fields.bits.frame_context_idx = h->h.framectxid;
-
-    pp->pic_fields.bits.segmentation_enabled = h->h.segmentation.enabled;
-    pp->pic_fields.bits.segmentation_temporal_update = h->h.segmentation.temporal;
-    pp->pic_fields.bits.segmentation_update_map = h->h.segmentation.update_map;
-
-    pp->pic_fields.bits.last_ref_frame = h->h.refidx[0];
-    pp->pic_fields.bits.last_ref_frame_sign_bias = h->h.signbias[0];
-    pp->pic_fields.bits.golden_ref_frame = h->h.refidx[1];
-    pp->pic_fields.bits.golden_ref_frame_sign_bias = h->h.signbias[1];
-    pp->pic_fields.bits.alt_ref_frame = h->h.refidx[2];
-    pp->pic_fields.bits.alt_ref_frame_sign_bias = h->h.signbias[2];
-    pp->pic_fields.bits.lossless_flag = h->h.lossless;
+    int err, i;
+
+    pic->output_surface = vaapi_vp9_surface_id(&h->frames[CUR_FRAME]);
+
+    pic_param = (VADecPictureParameterBufferVP9) {
+        .frame_width                      = avctx->width,
+        .frame_height                     = avctx->height,
+
+        .pic_fields.bits = {
+            .subsampling_x                = pixdesc->log2_chroma_w,
+            .subsampling_y                = pixdesc->log2_chroma_h,
+            .frame_type                   = !h->h.keyframe,
+            .show_frame                   = !h->h.invisible,
+            .error_resilient_mode         = h->h.errorres,
+            .intra_only                   = h->h.intraonly,
+            .allow_high_precision_mv      = h->h.keyframe ? 0 : h->h.highprecisionmvs,
+            .mcomp_filter_type            = h->h.filtermode ^ (h->h.filtermode <= 1),
+            .frame_parallel_decoding_mode = h->h.parallelmode,
+            .reset_frame_context          = h->h.resetctx,
+            .refresh_frame_context        = h->h.refreshctx,
+            .frame_context_idx            = h->h.framectxid,
+
+            .segmentation_enabled          = h->h.segmentation.enabled,
+            .segmentation_temporal_update  = h->h.segmentation.temporal,
+            .segmentation_update_map       = h->h.segmentation.update_map,
+
+            .last_ref_frame                = h->h.refidx[0],
+            .last_ref_frame_sign_bias      = h->h.signbias[0],
+            .golden_ref_frame              = h->h.refidx[1],
+            .golden_ref_frame_sign_bias    = h->h.signbias[1],
+            .alt_ref_frame                 = h->h.refidx[2],
+            .alt_ref_frame_sign_bias       = h->h.signbias[2],
+            .lossless_flag                 = h->h.lossless,
+        },
+
+        .filter_level                      = h->h.filter.level,
+        .sharpness_level                   = h->h.filter.sharpness,
+        .log2_tile_rows                    = h->h.tiling.log2_tile_rows,
+        .log2_tile_columns                 = h->h.tiling.log2_tile_cols,
+
+        .frame_header_length_in_bytes      = h->h.uncompressed_header_size,
+        .first_partition_size              = h->h.compressed_header_size,
+
+        .profile                           = h->h.profile,
+        .bit_depth                         = h->h.bpp,
+    };
 
     for (i = 0; i < 7; i++)
-        pp->mb_segment_tree_probs[i] = h->h.segmentation.prob[i];
+        pic_param.mb_segment_tree_probs[i] = h->h.segmentation.prob[i];
 
     if (h->h.segmentation.temporal) {
         for (i = 0; i < 3; i++)
-            pp->segment_pred_probs[i] = h->h.segmentation.pred_prob[i];
+            pic_param.segment_pred_probs[i] = h->h.segmentation.pred_prob[i];
     } else {
-        memset(pp->segment_pred_probs, 255, sizeof(pp->segment_pred_probs));
+        memset(pic_param.segment_pred_probs, 255, sizeof(pic_param.segment_pred_probs));
     }
 
     for (i = 0; i < 8; i++) {
-        if (h->refs[i].f->buf[0]) {
-            pp->reference_frames[i] = ff_vaapi_get_surface_id(h->refs[i].f);
-        } else {
-            pp->reference_frames[i] = VA_INVALID_ID;
-        }
+        if (h->refs[i].f->buf[0])
+            pic_param.reference_frames[i] = ff_vaapi_get_surface_id(h->refs[i].f);
+        else
+            pic_param.reference_frames[i] = VA_INVALID_ID;
     }
-}
 
-static int vaapi_vp9_start_frame(AVCodecContext          *avctx,
-                                 av_unused const uint8_t *buffer,
-                                 av_unused uint32_t       size)
-{
-    const VP9SharedContext *h = avctx->priv_data;
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
-    VADecPictureParameterBufferVP9 *pic_param;
-
-    vactx->slice_param_size = sizeof(VASliceParameterBufferVP9);
-
-    pic_param = ff_vaapi_alloc_pic_param(vactx, sizeof(VADecPictureParameterBufferVP9));
-    if (!pic_param)
-        return -1;
-    fill_picture_parameters(avctx, h, pic_param);
+    err = ff_vaapi_decode_make_param_buffer(avctx, pic,
+                                            VAPictureParameterBufferType,
+                                            &pic_param, sizeof(pic_param));
+    if (err < 0) {
+        ff_vaapi_decode_cancel(avctx, pic);
+        return err;
+    }
 
     return 0;
 }
 
 static int vaapi_vp9_end_frame(AVCodecContext *avctx)
 {
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
     const VP9SharedContext *h = avctx->priv_data;
-    int ret;
-
-    ret = ff_vaapi_commit_slices(vactx);
-    if (ret < 0)
-        goto finish;
-
-    ret = ff_vaapi_render_picture(vactx, ff_vaapi_get_surface_id(h->frames[CUR_FRAME].tf.f));
-    if (ret < 0)
-        goto finish;
+    VAAPIDecodePicture *pic = h->frames[CUR_FRAME].hwaccel_picture_private;
 
-finish:
-    ff_vaapi_common_end_frame(avctx);
-    return ret;
+    return ff_vaapi_decode_issue(avctx, pic);
 }
 
 static int vaapi_vp9_decode_slice(AVCodecContext *avctx,
                                   const uint8_t  *buffer,
                                   uint32_t        size)
 {
-    FFVAContext * const vactx = ff_vaapi_get_context(avctx);
     const VP9SharedContext *h = avctx->priv_data;
-    VASliceParameterBufferVP9 *slice_param;
-    int i;
+    VAAPIDecodePicture *pic = h->frames[CUR_FRAME].hwaccel_picture_private;
+    VASliceParameterBufferVP9 slice_param;
+    int err, i;
 
-    slice_param = (VASliceParameterBufferVP9*)ff_vaapi_alloc_slice(vactx, buffer, size);
-    if (!slice_param)
-        return -1;
+    slice_param = (VASliceParameterBufferVP9) {
+        .slice_data_size   = size,
+        .slice_data_offset = 0,
+        .slice_data_flag   = VA_SLICE_DATA_FLAG_ALL,
+    };
 
     for (i = 0; i < 8; i++) {
-        slice_param->seg_param[i].segment_flags.fields.segment_reference_enabled = h->h.segmentation.feat[i].ref_enabled;
-        slice_param->seg_param[i].segment_flags.fields.segment_reference = h->h.segmentation.feat[i].ref_val;
-        slice_param->seg_param[i].segment_flags.fields.segment_reference_skipped = h->h.segmentation.feat[i].skip_enabled;
-
-        memcpy(slice_param->seg_param[i].filter_level, h->h.segmentation.feat[i].lflvl, sizeof(slice_param->seg_param[i].filter_level));
+        slice_param.seg_param[i] = (VASegmentParameterVP9) {
+            .segment_flags.fields = {
+                .segment_reference_enabled = h->h.segmentation.feat[i].ref_enabled,
+                .segment_reference         = h->h.segmentation.feat[i].ref_val,
+                .segment_reference_skipped = h->h.segmentation.feat[i].skip_enabled,
+            },
+
+            .luma_dc_quant_scale           = h->h.segmentation.feat[i].qmul[0][0],
+            .luma_ac_quant_scale           = h->h.segmentation.feat[i].qmul[0][1],
+            .chroma_dc_quant_scale         = h->h.segmentation.feat[i].qmul[1][0],
+            .chroma_ac_quant_scale         = h->h.segmentation.feat[i].qmul[1][1],
+        };
+
+        memcpy(slice_param.seg_param[i].filter_level, h->h.segmentation.feat[i].lflvl, sizeof(slice_param.seg_param[i].filter_level));
+    }
 
-        slice_param->seg_param[i].luma_dc_quant_scale = h->h.segmentation.feat[i].qmul[0][0];
-        slice_param->seg_param[i].luma_ac_quant_scale = h->h.segmentation.feat[i].qmul[0][1];
-        slice_param->seg_param[i].chroma_dc_quant_scale = h->h.segmentation.feat[i].qmul[1][0];
-        slice_param->seg_param[i].chroma_ac_quant_scale = h->h.segmentation.feat[i].qmul[1][1];
+    err = ff_vaapi_decode_make_slice_buffer(avctx, pic,
+                                            &slice_param, sizeof(slice_param),
+                                            buffer, size);
+    if (err) {
+        ff_vaapi_decode_cancel(avctx, pic);
+        return err;
     }
 
     return 0;
@@ -162,7 +176,9 @@ AVHWAccel ff_vp9_vaapi_hwaccel = {
     .start_frame          = vaapi_vp9_start_frame,
     .end_frame            = vaapi_vp9_end_frame,
     .decode_slice         = vaapi_vp9_decode_slice,
-    .init                 = ff_vaapi_context_init,
-    .uninit               = ff_vaapi_context_fini,
-    .priv_data_size       = sizeof(FFVAContext),
+    .frame_priv_data_size = sizeof(VAAPIDecodePicture),
+    .init                 = ff_vaapi_decode_init,
+    .uninit               = ff_vaapi_decode_uninit,
+    .priv_data_size       = sizeof(VAAPIDecodeContext),
+    .caps_internal        = HWACCEL_CAP_ASYNC_SAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/vb.c b/mythtv/external/FFmpeg/libavcodec/vb.c
index 560165adc7d..021657f7d87 100644
--- a/mythtv/external/FFmpeg/libavcodec/vb.c
+++ b/mythtv/external/FFmpeg/libavcodec/vb.c
@@ -205,6 +205,10 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     if (flags & VB_HAS_GMC) {
         i = (int16_t)bytestream2_get_le16(&c->stream);
         j = (int16_t)bytestream2_get_le16(&c->stream);
+        if (FFABS(j) > avctx->height) {
+            av_log(avctx, AV_LOG_ERROR, "GMV out of range\n");
+            return AVERROR_INVALIDDATA;
+        }
         offset = i + j * avctx->width;
     }
     if (flags & VB_HAS_VIDEO) {
diff --git a/mythtv/external/FFmpeg/libavcodec/vble.c b/mythtv/external/FFmpeg/libavcodec/vble.c
index 032d9c21180..c25ee986972 100644
--- a/mythtv/external/FFmpeg/libavcodec/vble.c
+++ b/mythtv/external/FFmpeg/libavcodec/vble.c
@@ -29,14 +29,14 @@
 #define BITSTREAM_READER_LE
 #include "avcodec.h"
 #include "get_bits.h"
-#include "huffyuvdsp.h"
 #include "internal.h"
+#include "lossless_videodsp.h"
 #include "mathops.h"
 #include "thread.h"
 
 typedef struct VBLEContext {
     AVCodecContext *avctx;
-    HuffYUVDSPContext hdsp;
+    LLVidDSPContext llviddsp;
 
     int            size;
     uint8_t        *val; ///< This array first holds the lengths of vlc symbols and then their value.
@@ -102,8 +102,8 @@ static void vble_restore_plane(VBLEContext *ctx, AVFrame *pic,
         if (i) {
             left = 0;
             left_top = dst[-stride];
-            ctx->hdsp.add_hfyu_median_pred(dst, dst - stride, val,
-                                           width, &left, &left_top);
+            ctx->llviddsp.add_median_pred(dst, dst - stride, val,
+                                          width, &left, &left_top);
         } else {
             dst[0] = val[0];
             for (j = 1; j < width; j++)
@@ -185,7 +185,7 @@ static av_cold int vble_decode_init(AVCodecContext *avctx)
 
     /* Stash for later use */
     ctx->avctx = avctx;
-    ff_huffyuvdsp_init(&ctx->hdsp);
+    ff_llviddsp_init(&ctx->llviddsp);
 
     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
     avctx->bits_per_raw_sample = 8;
@@ -215,4 +215,5 @@ AVCodec ff_vble_decoder = {
     .decode         = vble_decode_frame,
     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
     .init_thread_copy = ONLY_IF_THREADS_ENABLED(vble_decode_init),
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/vc1_parser.c b/mythtv/external/FFmpeg/libavcodec/vc1_parser.c
index 9ca6154e71a..bb54947f559 100644
--- a/mythtv/external/FFmpeg/libavcodec/vc1_parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/vc1_parser.c
@@ -115,6 +115,14 @@ static void vc1_extract_header(AVCodecParserContext *s, AVCodecContext *avctx,
     }
     if (avctx->framerate.num)
         avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
+    s->format = vpc->v.chromaformat == 1 ? AV_PIX_FMT_YUV420P
+                                         : AV_PIX_FMT_NONE;
+    if (avctx->width && avctx->height) {
+        s->width        = avctx->width;
+        s->height       = avctx->height;
+        s->coded_width  = FFALIGN(avctx->coded_width,  16);
+        s->coded_height = FFALIGN(avctx->coded_height, 16);
+    }
 }
 
 static int vc1_parse(AVCodecParserContext *s,
diff --git a/mythtv/external/FFmpeg/libavcodec/vc1dec.c b/mythtv/external/FFmpeg/libavcodec/vc1dec.c
index 4f78aa8e330..16c601e7561 100644
--- a/mythtv/external/FFmpeg/libavcodec/vc1dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/vc1dec.c
@@ -634,6 +634,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
         uint8_t *buf;
         GetBitContext gb;
         int mby_start;
+        const uint8_t *rawbuf;
+        int raw_size;
     } *slices = NULL, *tmp;
 
     v->second_field = 0;
@@ -716,6 +718,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
                     /* assuming that the field marker is at the exact middle,
                        hope it's correct */
                     slices[n_slices].mby_start = s->mb_height + 1 >> 1;
+                    slices[n_slices].rawbuf = start;
+                    slices[n_slices].raw_size = size + 4;
                     n_slices1 = n_slices - 1; // index of the last slice of the first field
                     n_slices++;
                     break;
@@ -743,6 +747,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
                                   buf_size3 << 3);
                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
+                    slices[n_slices].rawbuf = start;
+                    slices[n_slices].raw_size = size + 4;
                     n_slices++;
                     break;
                 }
@@ -779,6 +785,8 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
                 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
                               buf_size3 << 3);
                 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
+                slices[n_slices].rawbuf = divider;
+                slices[n_slices].raw_size = buf + buf_size - divider;
                 n_slices1 = n_slices - 1;
                 n_slices++;
             }
@@ -921,6 +929,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
     } else
 #endif
     if (avctx->hwaccel) {
+        s->mb_y = 0;
         if (v->field_mode && buf_start_second_field) {
             // decode first field
             s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
@@ -953,8 +962,36 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
             s->picture_structure = PICT_FRAME;
             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
                 goto err;
-            if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
-                goto err;
+
+            if (n_slices == 0) {
+                // no slices, decode the frame as-is
+                if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
+                    goto err;
+            } else {
+                // decode the frame part as the first slice
+                if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, slices[0].rawbuf - buf_start)) < 0)
+                    goto err;
+
+                // and process the slices as additional slices afterwards
+                for (i = 0 ; i < n_slices; i++) {
+                    s->gb = slices[i].gb;
+                    s->mb_y = slices[i].mby_start;
+
+                    v->pic_header_flag = get_bits1(&s->gb);
+                    if (v->pic_header_flag) {
+                        if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
+                            av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
+                            ret = AVERROR_INVALIDDATA;
+                            if (avctx->err_recognition & AV_EF_EXPLODE)
+                                goto err;
+                            continue;
+                        }
+                    }
+
+                    if ((ret = avctx->hwaccel->decode_slice(avctx, slices[i].rawbuf, slices[i].raw_size)) < 0)
+                        goto err;
+                }
+            }
             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
                 goto err;
         }
@@ -1113,6 +1150,7 @@ static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
 #endif
 #if CONFIG_VC1_D3D11VA_HWACCEL
     AV_PIX_FMT_D3D11VA_VLD,
+    AV_PIX_FMT_D3D11,
 #endif
 #if CONFIG_VC1_VAAPI_HWACCEL
     AV_PIX_FMT_VAAPI,
diff --git a/mythtv/external/FFmpeg/libavcodec/vc1dsp.c b/mythtv/external/FFmpeg/libavcodec/vc1dsp.c
index 2d7e9b7900c..9239a4a1f5b 100644
--- a/mythtv/external/FFmpeg/libavcodec/vc1dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/vc1dsp.c
@@ -238,7 +238,7 @@ static void vc1_h_loop_filter16_c(uint8_t *src, int stride, int pq)
 }
 
 /* Do inverse transform on 8x8 block */
-static void vc1_inv_trans_8x8_dc_c(uint8_t *dest, int linesize, int16_t *block)
+static void vc1_inv_trans_8x8_dc_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
 {
     int i;
     int dc = block[0];
@@ -255,7 +255,7 @@ static void vc1_inv_trans_8x8_dc_c(uint8_t *dest, int linesize, int16_t *block)
         dest[5] = av_clip_uint8(dest[5] + dc);
         dest[6] = av_clip_uint8(dest[6] + dc);
         dest[7] = av_clip_uint8(dest[7] + dc);
-        dest += linesize;
+        dest += stride;
     }
 }
 
@@ -329,7 +329,7 @@ static void vc1_inv_trans_8x8_c(int16_t block[64])
 }
 
 /* Do inverse transform on 8x4 part of block */
-static void vc1_inv_trans_8x4_dc_c(uint8_t *dest, int linesize, int16_t *block)
+static void vc1_inv_trans_8x4_dc_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
 {
     int i;
     int dc = block[0];
@@ -346,11 +346,11 @@ static void vc1_inv_trans_8x4_dc_c(uint8_t *dest, int linesize, int16_t *block)
         dest[5] = av_clip_uint8(dest[5] + dc);
         dest[6] = av_clip_uint8(dest[6] + dc);
         dest[7] = av_clip_uint8(dest[7] + dc);
-        dest += linesize;
+        dest += stride;
     }
 }
 
-static void vc1_inv_trans_8x4_c(uint8_t *dest, int linesize, int16_t *block)
+static void vc1_inv_trans_8x4_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
 {
     int i;
     register int t1, t2, t3, t4, t5, t6, t7, t8;
@@ -395,10 +395,10 @@ static void vc1_inv_trans_8x4_c(uint8_t *dest, int linesize, int16_t *block)
         t3 = 22 * src[ 8] + 10 * src[24];
         t4 = 22 * src[24] - 10 * src[ 8];
 
-        dest[0 * linesize] = av_clip_uint8(dest[0 * linesize] + ((t1 + t3) >> 7));
-        dest[1 * linesize] = av_clip_uint8(dest[1 * linesize] + ((t2 - t4) >> 7));
-        dest[2 * linesize] = av_clip_uint8(dest[2 * linesize] + ((t2 + t4) >> 7));
-        dest[3 * linesize] = av_clip_uint8(dest[3 * linesize] + ((t1 - t3) >> 7));
+        dest[0 * stride] = av_clip_uint8(dest[0 * stride] + ((t1 + t3) >> 7));
+        dest[1 * stride] = av_clip_uint8(dest[1 * stride] + ((t2 - t4) >> 7));
+        dest[2 * stride] = av_clip_uint8(dest[2 * stride] + ((t2 + t4) >> 7));
+        dest[3 * stride] = av_clip_uint8(dest[3 * stride] + ((t1 - t3) >> 7));
 
         src++;
         dest++;
@@ -406,7 +406,7 @@ static void vc1_inv_trans_8x4_c(uint8_t *dest, int linesize, int16_t *block)
 }
 
 /* Do inverse transform on 4x8 parts of block */
-static void vc1_inv_trans_4x8_dc_c(uint8_t *dest, int linesize, int16_t *block)
+static void vc1_inv_trans_4x8_dc_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
 {
     int i;
     int dc = block[0];
@@ -419,11 +419,11 @@ static void vc1_inv_trans_4x8_dc_c(uint8_t *dest, int linesize, int16_t *block)
         dest[1] = av_clip_uint8(dest[1] + dc);
         dest[2] = av_clip_uint8(dest[2] + dc);
         dest[3] = av_clip_uint8(dest[3] + dc);
-        dest += linesize;
+        dest += stride;
     }
 }
 
-static void vc1_inv_trans_4x8_c(uint8_t *dest, int linesize, int16_t *block)
+static void vc1_inv_trans_4x8_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
 {
     int i;
     register int t1, t2, t3, t4, t5, t6, t7, t8;
@@ -464,14 +464,14 @@ static void vc1_inv_trans_4x8_c(uint8_t *dest, int linesize, int16_t *block)
         t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
         t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
 
-        dest[0 * linesize] = av_clip_uint8(dest[0 * linesize] + ((t5 + t1)     >> 7));
-        dest[1 * linesize] = av_clip_uint8(dest[1 * linesize] + ((t6 + t2)     >> 7));
-        dest[2 * linesize] = av_clip_uint8(dest[2 * linesize] + ((t7 + t3)     >> 7));
-        dest[3 * linesize] = av_clip_uint8(dest[3 * linesize] + ((t8 + t4)     >> 7));
-        dest[4 * linesize] = av_clip_uint8(dest[4 * linesize] + ((t8 - t4 + 1) >> 7));
-        dest[5 * linesize] = av_clip_uint8(dest[5 * linesize] + ((t7 - t3 + 1) >> 7));
-        dest[6 * linesize] = av_clip_uint8(dest[6 * linesize] + ((t6 - t2 + 1) >> 7));
-        dest[7 * linesize] = av_clip_uint8(dest[7 * linesize] + ((t5 - t1 + 1) >> 7));
+        dest[0 * stride] = av_clip_uint8(dest[0 * stride] + ((t5 + t1)     >> 7));
+        dest[1 * stride] = av_clip_uint8(dest[1 * stride] + ((t6 + t2)     >> 7));
+        dest[2 * stride] = av_clip_uint8(dest[2 * stride] + ((t7 + t3)     >> 7));
+        dest[3 * stride] = av_clip_uint8(dest[3 * stride] + ((t8 + t4)     >> 7));
+        dest[4 * stride] = av_clip_uint8(dest[4 * stride] + ((t8 - t4 + 1) >> 7));
+        dest[5 * stride] = av_clip_uint8(dest[5 * stride] + ((t7 - t3 + 1) >> 7));
+        dest[6 * stride] = av_clip_uint8(dest[6 * stride] + ((t6 - t2 + 1) >> 7));
+        dest[7 * stride] = av_clip_uint8(dest[7 * stride] + ((t5 - t1 + 1) >> 7));
 
         src++;
         dest++;
@@ -479,7 +479,7 @@ static void vc1_inv_trans_4x8_c(uint8_t *dest, int linesize, int16_t *block)
 }
 
 /* Do inverse transform on 4x4 part of block */
-static void vc1_inv_trans_4x4_dc_c(uint8_t *dest, int linesize, int16_t *block)
+static void vc1_inv_trans_4x4_dc_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
 {
     int i;
     int dc = block[0];
@@ -492,11 +492,11 @@ static void vc1_inv_trans_4x4_dc_c(uint8_t *dest, int linesize, int16_t *block)
         dest[1] = av_clip_uint8(dest[1] + dc);
         dest[2] = av_clip_uint8(dest[2] + dc);
         dest[3] = av_clip_uint8(dest[3] + dc);
-        dest += linesize;
+        dest += stride;
     }
 }
 
-static void vc1_inv_trans_4x4_c(uint8_t *dest, int linesize, int16_t *block)
+static void vc1_inv_trans_4x4_c(uint8_t *dest, ptrdiff_t stride, int16_t *block)
 {
     int i;
     register int t1, t2, t3, t4;
@@ -526,10 +526,10 @@ static void vc1_inv_trans_4x4_c(uint8_t *dest, int linesize, int16_t *block)
         t3 = 22 * src[8] + 10 * src[24];
         t4 = 22 * src[24] - 10 * src[8];
 
-        dest[0 * linesize] = av_clip_uint8(dest[0 * linesize] + ((t1 + t3) >> 7));
-        dest[1 * linesize] = av_clip_uint8(dest[1 * linesize] + ((t2 - t4) >> 7));
-        dest[2 * linesize] = av_clip_uint8(dest[2 * linesize] + ((t2 + t4) >> 7));
-        dest[3 * linesize] = av_clip_uint8(dest[3 * linesize] + ((t1 - t3) >> 7));
+        dest[0 * stride] = av_clip_uint8(dest[0 * stride] + ((t1 + t3) >> 7));
+        dest[1 * stride] = av_clip_uint8(dest[1 * stride] + ((t2 - t4) >> 7));
+        dest[2 * stride] = av_clip_uint8(dest[2 * stride] + ((t2 + t4) >> 7));
+        dest[3 * stride] = av_clip_uint8(dest[3 * stride] + ((t1 - t3) >> 7));
 
         src++;
         dest++;
@@ -782,7 +782,7 @@ PUT_VC1_MSPEL(3, 3)
       C * src[stride + a] + D * src[stride + a + 1] + 32 - 4) >> 6)
 static void put_no_rnd_vc1_chroma_mc8_c(uint8_t *dst /* align 8 */,
                                         uint8_t *src /* align 1 */,
-                                        int stride, int h, int x, int y)
+                                        ptrdiff_t stride, int h, int x, int y)
 {
     const int A = (8 - x) * (8 - y);
     const int B =     (x) * (8 - y);
@@ -807,7 +807,7 @@ static void put_no_rnd_vc1_chroma_mc8_c(uint8_t *dst /* align 8 */,
 }
 
 static void put_no_rnd_vc1_chroma_mc4_c(uint8_t *dst, uint8_t *src,
-                                        int stride, int h, int x, int y)
+                                        ptrdiff_t stride, int h, int x, int y)
 {
     const int A = (8 - x) * (8 - y);
     const int B =     (x) * (8 - y);
@@ -830,7 +830,7 @@ static void put_no_rnd_vc1_chroma_mc4_c(uint8_t *dst, uint8_t *src,
 #define avg2(a, b) (((a) + (b) + 1) >> 1)
 static void avg_no_rnd_vc1_chroma_mc8_c(uint8_t *dst /* align 8 */,
                                         uint8_t *src /* align 1 */,
-                                        int stride, int h, int x, int y)
+                                        ptrdiff_t stride, int h, int x, int y)
 {
     const int A = (8 - x) * (8 - y);
     const int B =     (x) * (8 - y);
@@ -856,7 +856,7 @@ static void avg_no_rnd_vc1_chroma_mc8_c(uint8_t *dst /* align 8 */,
 
 static void avg_no_rnd_vc1_chroma_mc4_c(uint8_t *dst /* align 8 */,
                                         uint8_t *src /* align 1 */,
-                                        int stride, int h, int x, int y)
+                                        ptrdiff_t stride, int h, int x, int y)
 {
     const int A = (8 - x) * (8 - y);
     const int B = (    x) * (8 - y);
@@ -1034,4 +1034,6 @@ av_cold void ff_vc1dsp_init(VC1DSPContext *dsp)
         ff_vc1dsp_init_ppc(dsp);
     if (ARCH_X86)
         ff_vc1dsp_init_x86(dsp);
+    if (ARCH_MIPS)
+        ff_vc1dsp_init_mips(dsp);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/vc1dsp.h b/mythtv/external/FFmpeg/libavcodec/vc1dsp.h
index 3d48f09d15f..16b3528a75c 100644
--- a/mythtv/external/FFmpeg/libavcodec/vc1dsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/vc1dsp.h
@@ -35,13 +35,13 @@ typedef void (*vc1op_pixels_func)(uint8_t *block/*align width (8 or 16)*/, const
 typedef struct VC1DSPContext {
     /* vc1 functions */
     void (*vc1_inv_trans_8x8)(int16_t *b);
-    void (*vc1_inv_trans_8x4)(uint8_t *dest, int line_size, int16_t *block);
-    void (*vc1_inv_trans_4x8)(uint8_t *dest, int line_size, int16_t *block);
-    void (*vc1_inv_trans_4x4)(uint8_t *dest, int line_size, int16_t *block);
-    void (*vc1_inv_trans_8x8_dc)(uint8_t *dest, int line_size, int16_t *block);
-    void (*vc1_inv_trans_8x4_dc)(uint8_t *dest, int line_size, int16_t *block);
-    void (*vc1_inv_trans_4x8_dc)(uint8_t *dest, int line_size, int16_t *block);
-    void (*vc1_inv_trans_4x4_dc)(uint8_t *dest, int line_size, int16_t *block);
+    void (*vc1_inv_trans_8x4)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+    void (*vc1_inv_trans_4x8)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+    void (*vc1_inv_trans_4x4)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+    void (*vc1_inv_trans_8x8_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+    void (*vc1_inv_trans_8x4_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+    void (*vc1_inv_trans_4x8_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+    void (*vc1_inv_trans_4x4_dc)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
     void (*vc1_v_overlap)(uint8_t *src, int stride);
     void (*vc1_h_overlap)(uint8_t *src, int stride);
     void (*vc1_v_s_overlap)(int16_t *top,  int16_t *bottom);
@@ -87,5 +87,6 @@ void ff_vc1dsp_init_aarch64(VC1DSPContext* dsp);
 void ff_vc1dsp_init_arm(VC1DSPContext* dsp);
 void ff_vc1dsp_init_ppc(VC1DSPContext *c);
 void ff_vc1dsp_init_x86(VC1DSPContext* dsp);
+void ff_vc1dsp_init_mips(VC1DSPContext* dsp);
 
 #endif /* AVCODEC_VC1DSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vc2enc.c b/mythtv/external/FFmpeg/libavcodec/vc2enc.c
index eda390163ff..cdc7d4250d1 100644
--- a/mythtv/external/FFmpeg/libavcodec/vc2enc.c
+++ b/mythtv/external/FFmpeg/libavcodec/vc2enc.c
@@ -1124,12 +1124,12 @@ static av_cold int vc2_encode_init(AVCodecContext *avctx)
     }
 
     if (s->base_vf <= 0) {
-        if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
+        if (avctx->strict_std_compliance < FF_COMPLIANCE_STRICT) {
             s->strict_compliance = s->base_vf = 0;
-            av_log(avctx, AV_LOG_WARNING, "Disabling strict compliance\n");
+            av_log(avctx, AV_LOG_WARNING, "Format does not strictly comply with VC2 specs\n");
         } else {
             av_log(avctx, AV_LOG_WARNING, "Given format does not strictly comply with "
-                   "the specifications, please add a -strict -1 flag to use it\n");
+                   "the specifications, decrease strictness to use it.\n");
             return AVERROR_UNKNOWN;
         }
     } else {
@@ -1171,7 +1171,7 @@ static av_cold int vc2_encode_init(AVCodecContext *avctx)
         p->dwt_width  = w = FFALIGN(p->width,  (1 << s->wavelet_depth));
         p->dwt_height = h = FFALIGN(p->height, (1 << s->wavelet_depth));
         p->coef_stride = FFALIGN(p->dwt_width, 32);
-        p->coef_buf = av_malloc(p->coef_stride*p->dwt_height*sizeof(dwtcoef));
+        p->coef_buf = av_mallocz(p->coef_stride*p->dwt_height*sizeof(dwtcoef));
         if (!p->coef_buf)
             goto alloc_fail;
         for (level = s->wavelet_depth-1; level >= 0; level--) {
@@ -1190,7 +1190,8 @@ static av_cold int vc2_encode_init(AVCodecContext *avctx)
         /* DWT init */
         if (ff_vc2enc_init_transforms(&s->transform_args[i].t,
                                       s->plane[i].coef_stride,
-                                      s->plane[i].dwt_height))
+                                      s->plane[i].dwt_height,
+                                      s->slice_width, s->slice_height))
             goto alloc_fail;
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/vc2enc_dwt.c b/mythtv/external/FFmpeg/libavcodec/vc2enc_dwt.c
index c60b003a313..d22af8a3138 100644
--- a/mythtv/external/FFmpeg/libavcodec/vc2enc_dwt.c
+++ b/mythtv/external/FFmpeg/libavcodec/vc2enc_dwt.c
@@ -255,21 +255,27 @@ static void vc2_subband_dwt_haar_shift(VC2TransformContext *t, dwtcoef *data,
     dwt_haar(t, data, stride, width, height, 1);
 }
 
-av_cold int ff_vc2enc_init_transforms(VC2TransformContext *s, int p_width, int p_height)
+av_cold int ff_vc2enc_init_transforms(VC2TransformContext *s, int p_stride,
+                                      int p_height, int slice_w, int slice_h)
 {
     s->vc2_subband_dwt[VC2_TRANSFORM_9_7]    = vc2_subband_dwt_97;
     s->vc2_subband_dwt[VC2_TRANSFORM_5_3]    = vc2_subband_dwt_53;
     s->vc2_subband_dwt[VC2_TRANSFORM_HAAR]   = vc2_subband_dwt_haar;
     s->vc2_subband_dwt[VC2_TRANSFORM_HAAR_S] = vc2_subband_dwt_haar_shift;
 
-    s->buffer = av_malloc(2*p_width*p_height*sizeof(dwtcoef));
+    /* Pad by the slice size, only matters for non-Haar wavelets */
+    s->buffer = av_calloc((p_stride + slice_w)*(p_height + slice_h), sizeof(dwtcoef));
     if (!s->buffer)
         return 1;
 
+    s->padding = (slice_h >> 1)*p_stride + (slice_w >> 1);
+    s->buffer += s->padding;
+
     return 0;
 }
 
 av_cold void ff_vc2enc_free_transforms(VC2TransformContext *s)
 {
-    av_freep(&s->buffer);
+    av_free(s->buffer - s->padding);
+    s->buffer = NULL;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/vc2enc_dwt.h b/mythtv/external/FFmpeg/libavcodec/vc2enc_dwt.h
index 7fbbfbe0ed9..a6932bcdaf0 100644
--- a/mythtv/external/FFmpeg/libavcodec/vc2enc_dwt.h
+++ b/mythtv/external/FFmpeg/libavcodec/vc2enc_dwt.h
@@ -41,12 +41,14 @@ enum VC2TransformType {
 
 typedef struct VC2TransformContext {
     dwtcoef *buffer;
+    int padding;
     void (*vc2_subband_dwt[VC2_TRANSFORMS_NB])(struct VC2TransformContext *t,
                                                dwtcoef *data, ptrdiff_t stride,
                                                int width, int height);
 } VC2TransformContext;
 
-int  ff_vc2enc_init_transforms(VC2TransformContext *t, int p_width, int p_height);
+int  ff_vc2enc_init_transforms(VC2TransformContext *t, int p_stride, int p_height,
+                               int slice_w, int slice_h);
 void ff_vc2enc_free_transforms(VC2TransformContext *t);
 
 #endif /* AVCODEC_VC2ENC_DWT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vda_h264_dec.c b/mythtv/external/FFmpeg/libavcodec/vda_h264_dec.c
index 92839e2d393..972bd6bbd64 100644
--- a/mythtv/external/FFmpeg/libavcodec/vda_h264_dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/vda_h264_dec.c
@@ -226,7 +226,7 @@ static av_cold int vdadec_init(AVCodecContext *avctx)
     ctx->h264_initialized = 1;
 
     for (i = 0; i < MAX_SPS_COUNT; i++) {
-        const SPS *sps = (const SPS*)ctx->h264ctx.ps.sps_list[i]->data;
+        const SPS *sps = ctx->h264ctx.ps.sps_list[i] ? (const SPS*)ctx->h264ctx.ps.sps_list[i]->data : NULL;
         if (sps && (sps->bit_depth_luma != 8 ||
                 sps->chroma_format_idc == 2 ||
                 sps->chroma_format_idc == 3)) {
diff --git a/mythtv/external/FFmpeg/libavcodec/vda_vt_internal.h b/mythtv/external/FFmpeg/libavcodec/vda_vt_internal.h
index 9ff63ccc52f..326a60a6956 100644
--- a/mythtv/external/FFmpeg/libavcodec/vda_vt_internal.h
+++ b/mythtv/external/FFmpeg/libavcodec/vda_vt_internal.h
@@ -40,6 +40,13 @@ typedef struct VTContext {
 
     // The core video buffer
     CVImageBufferRef            frame;
+
+    // Current dummy frames context (depends on exact CVImageBufferRef params).
+    struct AVBufferRef         *cached_hw_frames_ctx;
+
+    // Non-NULL if the new hwaccel API is used. This is only a separate struct
+    // to ease compatibility with the old API.
+    struct AVVideotoolboxContext *vt_ctx;
 } VTContext;
 
 int ff_videotoolbox_alloc_frame(AVCodecContext *avctx, AVFrame *frame);
@@ -52,4 +59,5 @@ int ff_videotoolbox_h264_decode_slice(AVCodecContext *avctx,
                                       const uint8_t *buffer,
                                       uint32_t size);
 CFDataRef ff_videotoolbox_avcc_extradata_create(AVCodecContext *avctx);
+CFDataRef ff_videotoolbox_hvcc_extradata_create(AVCodecContext *avctx);
 #endif /* AVCODEC_VDA_VT_INTERNAL_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vdpau.c b/mythtv/external/FFmpeg/libavcodec/vdpau.c
index bbb9913f8b0..4cc51cb79ed 100644
--- a/mythtv/external/FFmpeg/libavcodec/vdpau.c
+++ b/mythtv/external/FFmpeg/libavcodec/vdpau.c
@@ -127,6 +127,8 @@ int ff_vdpau_common_init(AVCodecContext *avctx, VdpDecoderProfile profile,
     VdpVideoSurfaceQueryCapabilities *surface_query_caps;
     VdpDecoderQueryCapabilities *decoder_query_caps;
     VdpDecoderCreate *create;
+    VdpGetInformationString *info;
+    const char *info_string;
     void *func;
     VdpStatus status;
     VdpBool supported;
@@ -138,34 +140,92 @@ int ff_vdpau_common_init(AVCodecContext *avctx, VdpDecoderProfile profile,
     vdctx->width            = UINT32_MAX;
     vdctx->height           = UINT32_MAX;
 
-    if (!hwctx) {
-        vdctx->device  = VDP_INVALID_HANDLE;
-        av_log(avctx, AV_LOG_WARNING, "hwaccel_context has not been setup by the user application, cannot initialize\n");
-        return 0;
-    }
+    if (av_vdpau_get_surface_parameters(avctx, &type, &width, &height))
+        return AVERROR(ENOSYS);
 
-    if (hwctx->context.decoder != VDP_INVALID_HANDLE) {
-        vdctx->decoder = hwctx->context.decoder;
-        vdctx->render  = hwctx->context.render;
-        vdctx->device  = VDP_INVALID_HANDLE;
-        return 0; /* Decoder created by user */
-    }
-    hwctx->reset            = 0;
+    if (hwctx) {
+        hwctx->reset            = 0;
+
+        if (hwctx->context.decoder != VDP_INVALID_HANDLE) {
+            vdctx->decoder = hwctx->context.decoder;
+            vdctx->render  = hwctx->context.render;
+            vdctx->device  = VDP_INVALID_HANDLE;
+            return 0; /* Decoder created by user */
+        }
+
+        vdctx->device           = hwctx->device;
+        vdctx->get_proc_address = hwctx->get_proc_address;
+
+        if (hwctx->flags & AV_HWACCEL_FLAG_IGNORE_LEVEL)
+            level = 0;
+
+        if (!(hwctx->flags & AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH) &&
+            type != VDP_CHROMA_TYPE_420)
+            return AVERROR(ENOSYS);
+    } else {
+        AVHWFramesContext *frames_ctx = NULL;
+        AVVDPAUDeviceContext *dev_ctx;
+
+        // We assume the hw_frames_ctx always survives until ff_vdpau_common_uninit
+        // is called. This holds true as the user is not allowed to touch
+        // hw_device_ctx, or hw_frames_ctx after get_format (and ff_get_format
+        // itself also uninits before unreffing hw_frames_ctx).
+        if (avctx->hw_frames_ctx) {
+            frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+        } else if (avctx->hw_device_ctx) {
+            int ret;
+
+            avctx->hw_frames_ctx = av_hwframe_ctx_alloc(avctx->hw_device_ctx);
+            if (!avctx->hw_frames_ctx)
+                return AVERROR(ENOMEM);
+
+            frames_ctx            = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+            frames_ctx->format    = AV_PIX_FMT_VDPAU;
+            frames_ctx->sw_format = avctx->sw_pix_fmt;
+            frames_ctx->width     = avctx->coded_width;
+            frames_ctx->height    = avctx->coded_height;
+
+            ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
+            if (ret < 0) {
+                av_buffer_unref(&avctx->hw_frames_ctx);
+                return ret;
+            }
+        }
+
+        if (!frames_ctx) {
+            av_log(avctx, AV_LOG_ERROR, "A hardware frames context is "
+                   "required for VDPAU decoding.\n");
+            return AVERROR(EINVAL);
+        }
+
+        dev_ctx = frames_ctx->device_ctx->hwctx;
+
+        vdctx->device           = dev_ctx->device;
+        vdctx->get_proc_address = dev_ctx->get_proc_address;
 
-    vdctx->device           = hwctx->device;
-    vdctx->get_proc_address = hwctx->get_proc_address;
+        if (avctx->hwaccel_flags & AV_HWACCEL_FLAG_IGNORE_LEVEL)
+            level = 0;
+    }
 
-    if (hwctx->flags & AV_HWACCEL_FLAG_IGNORE_LEVEL)
-        level = 0;
-    else if (level < 0)
+    if (level < 0)
         return AVERROR(ENOTSUP);
 
-    if (av_vdpau_get_surface_parameters(avctx, &type, &width, &height))
-        return AVERROR(ENOSYS);
+    status = vdctx->get_proc_address(vdctx->device,
+                                     VDP_FUNC_ID_GET_INFORMATION_STRING,
+                                     &func);
+    if (status != VDP_STATUS_OK)
+        return vdpau_error(status);
+    else
+        info = func;
 
-    if (!(hwctx->flags & AV_HWACCEL_FLAG_ALLOW_HIGH_DEPTH) &&
-        type != VDP_CHROMA_TYPE_420)
-        return AVERROR(ENOSYS);
+    status = info(&info_string);
+    if (status != VDP_STATUS_OK)
+        return vdpau_error(status);
+    if (avctx->codec_id == AV_CODEC_ID_HEVC && strncmp(info_string, "NVIDIA ", 7) == 0 &&
+        !(avctx->hwaccel_flags & AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH)) {
+        av_log(avctx, AV_LOG_VERBOSE, "HEVC with NVIDIA VDPAU drivers is buggy, skipping.\n");
+        return AVERROR(ENOTSUP);
+    }
 
     status = vdctx->get_proc_address(vdctx->device,
                                      VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES,
@@ -263,7 +323,7 @@ static int ff_vdpau_common_reinit(AVCodecContext *avctx)
     if (vdctx->device == VDP_INVALID_HANDLE)
         return 0; /* Decoder created by user */
     if (avctx->coded_width == vdctx->width &&
-        avctx->coded_height == vdctx->height && !hwctx->reset)
+        avctx->coded_height == vdctx->height && (!hwctx || !hwctx->reset))
         return 0;
 
     avctx->hwaccel->uninit(avctx);
@@ -295,19 +355,21 @@ int ff_vdpau_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
 
 #if FF_API_BUFS_VDPAU
 FF_DISABLE_DEPRECATION_WARNINGS
+    if (hwctx) {
     av_assert0(sizeof(hwctx->info) <= sizeof(pic_ctx->info));
     memcpy(&hwctx->info, &pic_ctx->info, sizeof(hwctx->info));
     hwctx->bitstream_buffers = pic_ctx->bitstream_buffers;
     hwctx->bitstream_buffers_used = pic_ctx->bitstream_buffers_used;
     hwctx->bitstream_buffers_allocated = pic_ctx->bitstream_buffers_allocated;
+    }
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
 
-    if (!hwctx->render && hwctx->render2) {
+    if (hwctx && !hwctx->render && hwctx->render2) {
         status = hwctx->render2(avctx, frame, (void *)&pic_ctx->info,
                                 pic_ctx->bitstream_buffers_used, pic_ctx->bitstream_buffers);
     } else
-    status = vdctx->render(vdctx->decoder, surf, (void *)&pic_ctx->info,
+    status = vdctx->render(vdctx->decoder, surf, &pic_ctx->info,
                            pic_ctx->bitstream_buffers_used,
                            pic_ctx->bitstream_buffers);
 
@@ -315,9 +377,11 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
 #if FF_API_BUFS_VDPAU
 FF_DISABLE_DEPRECATION_WARNINGS
+    if (hwctx) {
     hwctx->bitstream_buffers = NULL;
     hwctx->bitstream_buffers_used = 0;
     hwctx->bitstream_buffers_allocated = 0;
+    }
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
 
@@ -752,7 +816,7 @@ do {                                       \
 
 AVVDPAUContext *av_vdpau_alloc_context(void)
 {
-    return av_mallocz(sizeof(AVVDPAUContext));
+    return av_mallocz(sizeof(VDPAUHWContext));
 }
 
 int av_vdpau_bind_context(AVCodecContext *avctx, VdpDevice device,
diff --git a/mythtv/external/FFmpeg/libavcodec/vdpau.h b/mythtv/external/FFmpeg/libavcodec/vdpau.h
index e85e4d9e9a2..855d387d9a0 100644
--- a/mythtv/external/FFmpeg/libavcodec/vdpau.h
+++ b/mythtv/external/FFmpeg/libavcodec/vdpau.h
@@ -50,7 +50,7 @@
  */
 
 #include <vdpau/vdpau.h>
-#include <vdpau/vdpau_x11.h>
+
 #include "libavutil/avconfig.h"
 #include "libavutil/attributes.h"
 
diff --git a/mythtv/external/FFmpeg/libavcodec/vdpau_h264.c b/mythtv/external/FFmpeg/libavcodec/vdpau_h264.c
index 7265af2890e..be6ba714333 100644
--- a/mythtv/external/FFmpeg/libavcodec/vdpau_h264.c
+++ b/mythtv/external/FFmpeg/libavcodec/vdpau_h264.c
@@ -27,6 +27,7 @@
 #include "internal.h"
 #include "h264dec.h"
 #include "h264_ps.h"
+#include "hwaccel.h"
 #include "mpegutils.h"
 #include "vdpau.h"
 #include "vdpau_internal.h"
@@ -273,4 +274,5 @@ AVHWAccel ff_h264_vdpau_hwaccel = {
     .init           = vdpau_h264_init,
     .uninit         = ff_vdpau_common_uninit,
     .priv_data_size = sizeof(VDPAUContext),
+    .caps_internal  = HWACCEL_CAP_ASYNC_SAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/vdpau_hevc.c b/mythtv/external/FFmpeg/libavcodec/vdpau_hevc.c
index 03c61dc6cc6..fcdf4b2747f 100644
--- a/mythtv/external/FFmpeg/libavcodec/vdpau_hevc.c
+++ b/mythtv/external/FFmpeg/libavcodec/vdpau_hevc.c
@@ -24,7 +24,9 @@
 
 #include "avcodec.h"
 #include "internal.h"
-#include "hevc.h"
+#include "hevc_data.h"
+#include "hevcdec.h"
+#include "hwaccel.h"
 #include "vdpau.h"
 #include "vdpau_internal.h"
 
@@ -234,7 +236,7 @@ static int vdpau_hevc_start_frame(AVCodecContext *avctx,
         const HEVCFrame *frame = &h->DPB[i];
         if (frame != h->ref && (frame->flags & (HEVC_FRAME_FLAG_LONG_REF |
                                                 HEVC_FRAME_FLAG_SHORT_REF))) {
-            if (j > 16) {
+            if (j > 15) {
                 av_log(avctx, AV_LOG_WARNING,
                      "VDPAU only supports up to 16 references in the DPB. "
                      "This frame may not be decoded correctly.\n");
@@ -423,4 +425,5 @@ AVHWAccel ff_hevc_vdpau_hwaccel = {
     .init           = vdpau_hevc_init,
     .uninit         = ff_vdpau_common_uninit,
     .priv_data_size = sizeof(VDPAUContext),
+    .caps_internal  = HWACCEL_CAP_ASYNC_SAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/vdpau_internal.h b/mythtv/external/FFmpeg/libavcodec/vdpau_internal.h
index 77800af33fc..30d01af65d8 100644
--- a/mythtv/external/FFmpeg/libavcodec/vdpau_internal.h
+++ b/mythtv/external/FFmpeg/libavcodec/vdpau_internal.h
@@ -28,6 +28,8 @@
 #include <vdpau/vdpau.h>
 
 #include "libavutil/frame.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_vdpau.h"
 
 #include "avcodec.h"
 #include "vdpau.h"
diff --git a/mythtv/external/FFmpeg/libavcodec/vdpau_mpeg12.c b/mythtv/external/FFmpeg/libavcodec/vdpau_mpeg12.c
index 3ac2cb827de..b657007ee77 100644
--- a/mythtv/external/FFmpeg/libavcodec/vdpau_mpeg12.c
+++ b/mythtv/external/FFmpeg/libavcodec/vdpau_mpeg12.c
@@ -24,6 +24,7 @@
 #include <vdpau/vdpau.h>
 
 #include "avcodec.h"
+#include "hwaccel.h"
 #include "mpegvideo.h"
 #include "vdpau.h"
 #include "vdpau_internal.h"
@@ -114,6 +115,7 @@ AVHWAccel ff_mpeg1_vdpau_hwaccel = {
     .init           = vdpau_mpeg1_init,
     .uninit         = ff_vdpau_common_uninit,
     .priv_data_size = sizeof(VDPAUContext),
+    .caps_internal  = HWACCEL_CAP_ASYNC_SAFE,
 };
 #endif
 
@@ -148,5 +150,6 @@ AVHWAccel ff_mpeg2_vdpau_hwaccel = {
     .init           = vdpau_mpeg2_init,
     .uninit         = ff_vdpau_common_uninit,
     .priv_data_size = sizeof(VDPAUContext),
+    .caps_internal  = HWACCEL_CAP_ASYNC_SAFE,
 };
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/vdpau_mpeg4.c b/mythtv/external/FFmpeg/libavcodec/vdpau_mpeg4.c
index 46a00cb27cb..bbdd843a449 100644
--- a/mythtv/external/FFmpeg/libavcodec/vdpau_mpeg4.c
+++ b/mythtv/external/FFmpeg/libavcodec/vdpau_mpeg4.c
@@ -24,6 +24,7 @@
 #include <vdpau/vdpau.h>
 
 #include "avcodec.h"
+#include "hwaccel.h"
 #include "mpeg4video.h"
 #include "vdpau.h"
 #include "vdpau_internal.h"
@@ -121,4 +122,5 @@ AVHWAccel ff_mpeg4_vdpau_hwaccel = {
     .init           = vdpau_mpeg4_init,
     .uninit         = ff_vdpau_common_uninit,
     .priv_data_size = sizeof(VDPAUContext),
+    .caps_internal  = HWACCEL_CAP_ASYNC_SAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/vdpau_vc1.c b/mythtv/external/FFmpeg/libavcodec/vdpau_vc1.c
index ffd6505d13f..665a2333f45 100644
--- a/mythtv/external/FFmpeg/libavcodec/vdpau_vc1.c
+++ b/mythtv/external/FFmpeg/libavcodec/vdpau_vc1.c
@@ -24,6 +24,7 @@
 #include <vdpau/vdpau.h>
 
 #include "avcodec.h"
+#include "hwaccel.h"
 #include "vc1.h"
 #include "vdpau.h"
 #include "vdpau_internal.h"
@@ -147,6 +148,7 @@ AVHWAccel ff_wmv3_vdpau_hwaccel = {
     .init           = vdpau_vc1_init,
     .uninit         = ff_vdpau_common_uninit,
     .priv_data_size = sizeof(VDPAUContext),
+    .caps_internal  = HWACCEL_CAP_ASYNC_SAFE,
 };
 #endif
 
@@ -162,4 +164,5 @@ AVHWAccel ff_vc1_vdpau_hwaccel = {
     .init           = vdpau_vc1_init,
     .uninit         = ff_vdpau_common_uninit,
     .priv_data_size = sizeof(VDPAUContext),
+    .caps_internal  = HWACCEL_CAP_ASYNC_SAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/version.h b/mythtv/external/FFmpeg/libavcodec/version.h
index 2f7891ed590..10d9ac4eb3c 100644
--- a/mythtv/external/FFmpeg/libavcodec/version.h
+++ b/mythtv/external/FFmpeg/libavcodec/version.h
@@ -28,7 +28,7 @@
 #include "libavutil/version.h"
 
 #define LIBAVCODEC_VERSION_MAJOR  57
-#define LIBAVCODEC_VERSION_MINOR  64
+#define LIBAVCODEC_VERSION_MINOR 107
 #define LIBAVCODEC_VERSION_MICRO 100
 
 #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
@@ -60,9 +60,6 @@
 #ifndef FF_API_AVCODEC_RESAMPLE
 #define FF_API_AVCODEC_RESAMPLE  FF_API_AUDIO_CONVERT
 #endif
-#ifndef FF_API_GETCHROMA
-#define FF_API_GETCHROMA         (LIBAVCODEC_VERSION_MAJOR < 58)
-#endif
 #ifndef FF_API_MISSING_SAMPLE
 #define FF_API_MISSING_SAMPLE    (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
@@ -157,6 +154,9 @@
 #ifndef FF_API_VAAPI_CONTEXT
 #define FF_API_VAAPI_CONTEXT     (LIBAVCODEC_VERSION_MAJOR < 58)
 #endif
+#ifndef FF_API_MERGE_SD
+#define FF_API_MERGE_SD          (LIBAVCODEC_VERSION_MAJOR < 58)
+#endif
 #ifndef FF_API_AVCTX_TIMEBASE
 #define FF_API_AVCTX_TIMEBASE    (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
@@ -226,5 +226,18 @@
 #ifndef FF_API_NVENC_OLD_NAME
 #define FF_API_NVENC_OLD_NAME    (LIBAVCODEC_VERSION_MAJOR < 59)
 #endif
+#ifndef FF_API_STRUCT_VAAPI_CONTEXT
+#define FF_API_STRUCT_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_MERGE_SD_API
+#define FF_API_MERGE_SD_API      (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_TAG_STRING
+#define FF_API_TAG_STRING        (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_GETCHROMA
+#define FF_API_GETCHROMA         (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+
 
 #endif /* AVCODEC_VERSION_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/videodsp.c b/mythtv/external/FFmpeg/libavcodec/videodsp.c
index ba618a7bbc6..ce9e9eb1439 100644
--- a/mythtv/external/FFmpeg/libavcodec/videodsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/videodsp.c
@@ -52,4 +52,6 @@ av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
         ff_videodsp_init_ppc(ctx, bpc);
     if (ARCH_X86)
         ff_videodsp_init_x86(ctx, bpc);
+    if (ARCH_MIPS)
+        ff_videodsp_init_mips(ctx, bpc);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/videodsp.h b/mythtv/external/FFmpeg/libavcodec/videodsp.h
index fc01a31dcac..c0545f22b02 100644
--- a/mythtv/external/FFmpeg/libavcodec/videodsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/videodsp.h
@@ -83,5 +83,6 @@ void ff_videodsp_init_aarch64(VideoDSPContext *ctx, int bpc);
 void ff_videodsp_init_arm(VideoDSPContext *ctx, int bpc);
 void ff_videodsp_init_ppc(VideoDSPContext *ctx, int bpc);
 void ff_videodsp_init_x86(VideoDSPContext *ctx, int bpc);
+void ff_videodsp_init_mips(VideoDSPContext *ctx, int bpc);
 
 #endif /* AVCODEC_VIDEODSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/videotoolbox.c b/mythtv/external/FFmpeg/libavcodec/videotoolbox.c
index 1288aa50873..ec8b6d885c8 100644
--- a/mythtv/external/FFmpeg/libavcodec/videotoolbox.c
+++ b/mythtv/external/FFmpeg/libavcodec/videotoolbox.c
@@ -23,19 +23,27 @@
 #include "config.h"
 #if CONFIG_VIDEOTOOLBOX
 #  include "videotoolbox.h"
+#  include "libavutil/hwcontext_videotoolbox.h"
 #else
 #  include "vda.h"
 #endif
 #include "vda_vt_internal.h"
 #include "libavutil/avutil.h"
+#include "libavutil/hwcontext.h"
 #include "bytestream.h"
 #include "h264dec.h"
+#include "hevcdec.h"
 #include "mpegvideo.h"
+#include <TargetConditionals.h>
 
 #ifndef kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder
 #  define kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder CFSTR("RequireHardwareAcceleratedVideoDecoder")
 #endif
 
+#if !HAVE_KCMVIDEOCODECTYPE_HEVC
+enum { kCMVideoCodecType_HEVC = 'hvc1' };
+#endif
+
 #define VIDEOTOOLBOX_ESDS_EXTRADATA_PADDING  12
 
 static void videotoolbox_buffer_release(void *opaque, uint8_t *data)
@@ -112,6 +120,164 @@ CFDataRef ff_videotoolbox_avcc_extradata_create(AVCodecContext *avctx)
     return data;
 }
 
+CFDataRef ff_videotoolbox_hvcc_extradata_create(AVCodecContext *avctx)
+{
+    HEVCContext *h = avctx->priv_data;
+    const HEVCVPS *vps = (const HEVCVPS *)h->ps.vps_list[0]->data;
+    const HEVCSPS *sps = (const HEVCSPS *)h->ps.sps_list[0]->data;
+    int i, num_pps = 0;
+    const HEVCPPS *pps = h->ps.pps;
+    PTLCommon ptlc = vps->ptl.general_ptl;
+    VUI vui = sps->vui;
+    uint8_t parallelismType;
+    CFDataRef data = NULL;
+    uint8_t *p;
+    int vt_extradata_size = 23 + 5 + vps->data_size + 5 + sps->data_size + 3;
+    uint8_t *vt_extradata;
+
+    for (i = 0; i < MAX_PPS_COUNT; i++) {
+        if (h->ps.pps_list[i]) {
+            const HEVCPPS *pps = (const HEVCPPS *)h->ps.pps_list[i]->data;
+            vt_extradata_size += 2 + pps->data_size;
+            num_pps++;
+        }
+    }
+
+    vt_extradata = av_malloc(vt_extradata_size);
+    if (!vt_extradata)
+        return NULL;
+    p = vt_extradata;
+
+    /* unsigned int(8) configurationVersion = 1; */
+    AV_W8(p + 0, 1);
+
+    /*
+     * unsigned int(2) general_profile_space;
+     * unsigned int(1) general_tier_flag;
+     * unsigned int(5) general_profile_idc;
+     */
+    AV_W8(p + 1, ptlc.profile_space << 6 |
+                 ptlc.tier_flag     << 5 |
+                 ptlc.profile_idc);
+
+    /* unsigned int(32) general_profile_compatibility_flags; */
+    memcpy(p + 2, ptlc.profile_compatibility_flag, 4);
+
+    /* unsigned int(48) general_constraint_indicator_flags; */
+    AV_W8(p + 6, ptlc.progressive_source_flag    << 7 |
+                 ptlc.interlaced_source_flag     << 6 |
+                 ptlc.non_packed_constraint_flag << 5 |
+                 ptlc.frame_only_constraint_flag << 4);
+    AV_W8(p + 7, 0);
+    AV_WN32(p + 8, 0);
+
+    /* unsigned int(8) general_level_idc; */
+    AV_W8(p + 12, ptlc.level_idc);
+
+    /*
+     * bit(4) reserved = ‘1111’b;
+     * unsigned int(12) min_spatial_segmentation_idc;
+     */
+    AV_W8(p + 13, 0xf0 | (vui.min_spatial_segmentation_idc >> 4));
+    AV_W8(p + 14, vui.min_spatial_segmentation_idc & 0xff);
+
+    /*
+     * bit(6) reserved = ‘111111’b;
+     * unsigned int(2) parallelismType;
+     */
+    if (!vui.min_spatial_segmentation_idc)
+        parallelismType = 0;
+    else if (pps->entropy_coding_sync_enabled_flag && pps->tiles_enabled_flag)
+        parallelismType = 0;
+    else if (pps->entropy_coding_sync_enabled_flag)
+        parallelismType = 3;
+    else if (pps->tiles_enabled_flag)
+        parallelismType = 2;
+    else
+        parallelismType = 1;
+    AV_W8(p + 15, 0xfc | parallelismType);
+
+    /*
+     * bit(6) reserved = ‘111111’b;
+     * unsigned int(2) chromaFormat;
+     */
+    AV_W8(p + 16, sps->chroma_format_idc | 0xfc);
+
+    /*
+     * bit(5) reserved = ‘11111’b;
+     * unsigned int(3) bitDepthLumaMinus8;
+     */
+    AV_W8(p + 17, (sps->bit_depth - 8) | 0xfc);
+
+    /*
+     * bit(5) reserved = ‘11111’b;
+     * unsigned int(3) bitDepthChromaMinus8;
+     */
+    AV_W8(p + 18, (sps->bit_depth_chroma - 8) | 0xfc);
+
+    /* bit(16) avgFrameRate; */
+    AV_WB16(p + 19, 0);
+
+    /*
+     * bit(2) constantFrameRate;
+     * bit(3) numTemporalLayers;
+     * bit(1) temporalIdNested;
+     * unsigned int(2) lengthSizeMinusOne;
+     */
+    AV_W8(p + 21, 0                             << 6 |
+                  sps->max_sub_layers           << 3 |
+                  sps->temporal_id_nesting_flag << 2 |
+                  3);
+
+    /* unsigned int(8) numOfArrays; */
+    AV_W8(p + 22, 3);
+
+    p += 23;
+    /* vps */
+    /*
+     * bit(1) array_completeness;
+     * unsigned int(1) reserved = 0;
+     * unsigned int(6) NAL_unit_type;
+     */
+    AV_W8(p, 1 << 7 |
+             HEVC_NAL_VPS & 0x3f);
+    /* unsigned int(16) numNalus; */
+    AV_WB16(p + 1, 1);
+    /* unsigned int(16) nalUnitLength; */
+    AV_WB16(p + 3, vps->data_size);
+    /* bit(8*nalUnitLength) nalUnit; */
+    memcpy(p + 5, vps->data, vps->data_size);
+    p += 5 + vps->data_size;
+
+    /* sps */
+    AV_W8(p, 1 << 7 |
+             HEVC_NAL_SPS & 0x3f);
+    AV_WB16(p + 1, 1);
+    AV_WB16(p + 3, sps->data_size);
+    memcpy(p + 5, sps->data, sps->data_size);
+    p += 5 + sps->data_size;
+
+    /* pps */
+    AV_W8(p, 1 << 7 |
+             HEVC_NAL_PPS & 0x3f);
+    AV_WB16(p + 1, num_pps);
+    p += 3;
+    for (i = 0; i < MAX_PPS_COUNT; i++) {
+        if (h->ps.pps_list[i]) {
+            const HEVCPPS *pps = (const HEVCPPS *)h->ps.pps_list[i]->data;
+            AV_WB16(p, pps->data_size);
+            memcpy(p + 2, pps->data, pps->data_size);
+            p += 2 + pps->data_size;
+        }
+    }
+
+    av_assert0(p - vt_extradata == vt_extradata_size);
+
+    data = CFDataCreate(kCFAllocatorDefault, vt_extradata, vt_extradata_size);
+    av_free(vt_extradata);
+    return data;
+}
+
 int ff_videotoolbox_buffer_create(VTContext *vtctx, AVFrame *frame)
 {
     av_buffer_unref(&frame->buf[0]);
@@ -187,6 +353,73 @@ int ff_videotoolbox_uninit(AVCodecContext *avctx)
 }
 
 #if CONFIG_VIDEOTOOLBOX
+// Return the AVVideotoolboxContext that matters currently. Where it comes from
+// depends on the API used.
+static AVVideotoolboxContext *videotoolbox_get_context(AVCodecContext *avctx)
+{
+    // Somewhat tricky because the user can call av_videotoolbox_default_free()
+    // at any time, even when the codec is closed.
+    if (avctx->internal && avctx->internal->hwaccel_priv_data) {
+        VTContext *vtctx = avctx->internal->hwaccel_priv_data;
+        if (vtctx->vt_ctx)
+            return vtctx->vt_ctx;
+    }
+    return avctx->hwaccel_context;
+}
+
+static int videotoolbox_buffer_create(AVCodecContext *avctx, AVFrame *frame)
+{
+    VTContext *vtctx = avctx->internal->hwaccel_priv_data;
+    CVPixelBufferRef pixbuf = (CVPixelBufferRef)vtctx->frame;
+    OSType pixel_format = CVPixelBufferGetPixelFormatType(pixbuf);
+    enum AVPixelFormat sw_format = av_map_videotoolbox_format_to_pixfmt(pixel_format);
+    int width = CVPixelBufferGetWidth(pixbuf);
+    int height = CVPixelBufferGetHeight(pixbuf);
+    AVHWFramesContext *cached_frames;
+    int ret;
+
+    ret = ff_videotoolbox_buffer_create(vtctx, frame);
+    if (ret < 0)
+        return ret;
+
+    // Old API code path.
+    if (!vtctx->cached_hw_frames_ctx)
+        return 0;
+
+    cached_frames = (AVHWFramesContext*)vtctx->cached_hw_frames_ctx->data;
+
+    if (cached_frames->sw_format != sw_format ||
+        cached_frames->width != width ||
+        cached_frames->height != height) {
+        AVBufferRef *hw_frames_ctx = av_hwframe_ctx_alloc(cached_frames->device_ref);
+        AVHWFramesContext *hw_frames;
+        if (!hw_frames_ctx)
+            return AVERROR(ENOMEM);
+
+        hw_frames = (AVHWFramesContext*)hw_frames_ctx->data;
+        hw_frames->format = cached_frames->format;
+        hw_frames->sw_format = sw_format;
+        hw_frames->width = width;
+        hw_frames->height = height;
+
+        ret = av_hwframe_ctx_init(hw_frames_ctx);
+        if (ret < 0) {
+            av_buffer_unref(&hw_frames_ctx);
+            return ret;
+        }
+
+        av_buffer_unref(&vtctx->cached_hw_frames_ctx);
+        vtctx->cached_hw_frames_ctx = hw_frames_ctx;
+    }
+
+    av_buffer_unref(&frame->hw_frames_ctx);
+    frame->hw_frames_ctx = av_buffer_ref(vtctx->cached_hw_frames_ctx);
+    if (!frame->hw_frames_ctx)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
 static void videotoolbox_write_mp4_descr_length(PutByteContext *pb, int length)
 {
     int i;
@@ -322,7 +555,7 @@ static OSStatus videotoolbox_session_decode_frame(AVCodecContext *avctx)
 {
     OSStatus status;
     CMSampleBufferRef sample_buf;
-    AVVideotoolboxContext *videotoolbox = avctx->hwaccel_context;
+    AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);
     VTContext *vtctx = avctx->internal->hwaccel_priv_data;
 
     sample_buf = videotoolbox_sample_buffer_create(videotoolbox->cm_fmt_desc,
@@ -348,11 +581,9 @@ static OSStatus videotoolbox_session_decode_frame(AVCodecContext *avctx)
 static int videotoolbox_common_end_frame(AVCodecContext *avctx, AVFrame *frame)
 {
     int status;
-    AVVideotoolboxContext *videotoolbox = avctx->hwaccel_context;
+    AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);
     VTContext *vtctx = avctx->internal->hwaccel_priv_data;
 
-    av_buffer_unref(&frame->buf[0]);
-
     if (!videotoolbox->session || !vtctx->bitstream)
         return AVERROR_INVALIDDATA;
 
@@ -366,7 +597,7 @@ static int videotoolbox_common_end_frame(AVCodecContext *avctx, AVFrame *frame)
     if (!vtctx->frame)
         return AVERROR_UNKNOWN;
 
-    return ff_videotoolbox_buffer_create(vtctx, frame);
+    return videotoolbox_buffer_create(avctx, frame);
 }
 
 static int videotoolbox_h264_end_frame(AVCodecContext *avctx)
@@ -377,6 +608,18 @@ static int videotoolbox_h264_end_frame(AVCodecContext *avctx)
     return videotoolbox_common_end_frame(avctx, frame);
 }
 
+static int videotoolbox_hevc_end_frame(AVCodecContext *avctx)
+{
+    HEVCContext *h = avctx->priv_data;
+    AVFrame *frame = h->ref->frame;
+    VTContext *vtctx = avctx->internal->hwaccel_priv_data;
+    int ret;
+
+    ret = videotoolbox_common_end_frame(avctx, frame);
+    vtctx->bitstream_size = 0;
+    return ret;
+}
+
 static int videotoolbox_mpeg_start_frame(AVCodecContext *avctx,
                                          const uint8_t *buffer,
                                          uint32_t size)
@@ -433,6 +676,11 @@ static CFDictionaryRef videotoolbox_decoder_config_create(CMVideoCodecType codec
             if (data)
                 CFDictionarySetValue(avc_info, CFSTR("avcC"), data);
             break;
+        case kCMVideoCodecType_HEVC :
+            data = ff_videotoolbox_hvcc_extradata_create(avctx);
+            if (data)
+                CFDictionarySetValue(avc_info, CFSTR("hvcC"), data);
+            break;
         default:
             break;
         }
@@ -472,10 +720,16 @@ static CFDictionaryRef videotoolbox_buffer_attributes_create(int width,
                                                       &kCFTypeDictionaryKeyCallBacks,
                                                       &kCFTypeDictionaryValueCallBacks);
 
-    CFDictionarySetValue(buffer_attributes, kCVPixelBufferPixelFormatTypeKey, cv_pix_fmt);
+    if (pix_fmt)
+        CFDictionarySetValue(buffer_attributes, kCVPixelBufferPixelFormatTypeKey, cv_pix_fmt);
     CFDictionarySetValue(buffer_attributes, kCVPixelBufferIOSurfacePropertiesKey, io_surface_properties);
     CFDictionarySetValue(buffer_attributes, kCVPixelBufferWidthKey, w);
     CFDictionarySetValue(buffer_attributes, kCVPixelBufferHeightKey, h);
+#if TARGET_OS_IPHONE
+    CFDictionarySetValue(buffer_attributes, kCVPixelBufferOpenGLESCompatibilityKey, kCFBooleanTrue);
+#else
+    CFDictionarySetValue(buffer_attributes, kCVPixelBufferIOSurfaceOpenGLTextureCompatibilityKey, kCFBooleanTrue);
+#endif
 
     CFRelease(io_surface_properties);
     CFRelease(cv_pix_fmt);
@@ -508,7 +762,7 @@ static CMVideoFormatDescriptionRef videotoolbox_format_desc_create(CMVideoCodecT
 
 static int videotoolbox_default_init(AVCodecContext *avctx)
 {
-    AVVideotoolboxContext *videotoolbox = avctx->hwaccel_context;
+    AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);
     OSStatus status;
     VTDecompressionOutputCallbackRecord decoder_cb;
     CFDictionaryRef decoder_spec;
@@ -526,6 +780,9 @@ static int videotoolbox_default_init(AVCodecContext *avctx)
     case AV_CODEC_ID_H264 :
         videotoolbox->cm_codec_type = kCMVideoCodecType_H264;
         break;
+    case AV_CODEC_ID_HEVC :
+        videotoolbox->cm_codec_type = kCMVideoCodecType_HEVC;
+        break;
     case AV_CODEC_ID_MPEG1VIDEO :
         videotoolbox->cm_codec_type = kCMVideoCodecType_MPEG1Video;
         break;
@@ -574,22 +831,28 @@ static int videotoolbox_default_init(AVCodecContext *avctx)
 
     switch (status) {
     case kVTVideoDecoderNotAvailableNowErr:
+        av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox session not available.\n");
+        return AVERROR(ENOSYS);
     case kVTVideoDecoderUnsupportedDataFormatErr:
+        av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox does not support this format.\n");
         return AVERROR(ENOSYS);
     case kVTVideoDecoderMalfunctionErr:
+        av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox malfunction.\n");
         return AVERROR(EINVAL);
     case kVTVideoDecoderBadDataErr :
+        av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox reported invalid data.\n");
         return AVERROR_INVALIDDATA;
     case 0:
         return 0;
     default:
+        av_log(avctx, AV_LOG_VERBOSE, "Unknown VideoToolbox session creation error %u\n", (unsigned)status);
         return AVERROR_UNKNOWN;
     }
 }
 
 static void videotoolbox_default_free(AVCodecContext *avctx)
 {
-    AVVideotoolboxContext *videotoolbox = avctx->hwaccel_context;
+    AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);
 
     if (videotoolbox) {
         if (videotoolbox->cm_fmt_desc)
@@ -602,6 +865,92 @@ static void videotoolbox_default_free(AVCodecContext *avctx)
     }
 }
 
+static int videotoolbox_uninit(AVCodecContext *avctx)
+{
+    VTContext *vtctx = avctx->internal->hwaccel_priv_data;
+    if (!vtctx)
+        return 0;
+
+    ff_videotoolbox_uninit(avctx);
+
+    if (vtctx->vt_ctx)
+        videotoolbox_default_free(avctx);
+
+    av_buffer_unref(&vtctx->cached_hw_frames_ctx);
+    av_freep(&vtctx->vt_ctx);
+
+    return 0;
+}
+
+static int videotoolbox_common_init(AVCodecContext *avctx)
+{
+    VTContext *vtctx = avctx->internal->hwaccel_priv_data;
+    AVHWFramesContext *hw_frames;
+    int err;
+
+    // Old API - do nothing.
+    if (avctx->hwaccel_context)
+        return 0;
+
+    if (!avctx->hw_frames_ctx && !avctx->hw_device_ctx) {
+        av_log(avctx, AV_LOG_ERROR,
+               "Either hw_frames_ctx or hw_device_ctx must be set.\n");
+        return AVERROR(EINVAL);
+    }
+
+    vtctx->vt_ctx = av_videotoolbox_alloc_context();
+    if (!vtctx->vt_ctx) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    if (avctx->hw_frames_ctx) {
+        hw_frames = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+    } else {
+        avctx->hw_frames_ctx = av_hwframe_ctx_alloc(avctx->hw_device_ctx);
+        if (!avctx->hw_frames_ctx) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+
+        hw_frames = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
+        hw_frames->format = AV_PIX_FMT_VIDEOTOOLBOX;
+        hw_frames->sw_format = AV_PIX_FMT_NV12; // same as av_videotoolbox_alloc_context()
+        hw_frames->width = avctx->width;
+        hw_frames->height = avctx->height;
+
+        err = av_hwframe_ctx_init(avctx->hw_frames_ctx);
+        if (err < 0) {
+            av_buffer_unref(&avctx->hw_frames_ctx);
+            goto fail;
+        }
+    }
+
+    vtctx->cached_hw_frames_ctx = av_buffer_ref(avctx->hw_frames_ctx);
+    if (!vtctx->cached_hw_frames_ctx) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    vtctx->vt_ctx->cv_pix_fmt_type =
+        av_map_videotoolbox_format_from_pixfmt(hw_frames->sw_format);
+    if (!vtctx->vt_ctx->cv_pix_fmt_type) {
+        av_log(avctx, AV_LOG_ERROR, "Unknown sw_format.\n");
+        err = AVERROR(EINVAL);
+        goto fail;
+    }
+
+    err = videotoolbox_default_init(avctx);
+    if (err < 0)
+        goto fail;
+
+    return 0;
+
+fail:
+    videotoolbox_uninit(avctx);
+    return err;
+}
+
 AVHWAccel ff_h263_videotoolbox_hwaccel = {
     .name           = "h263_videotoolbox",
     .type           = AVMEDIA_TYPE_VIDEO,
@@ -611,6 +960,21 @@ AVHWAccel ff_h263_videotoolbox_hwaccel = {
     .start_frame    = videotoolbox_mpeg_start_frame,
     .decode_slice   = videotoolbox_mpeg_decode_slice,
     .end_frame      = videotoolbox_mpeg_end_frame,
+    .init           = videotoolbox_common_init,
+    .uninit         = videotoolbox_uninit,
+    .priv_data_size = sizeof(VTContext),
+};
+
+AVHWAccel ff_hevc_videotoolbox_hwaccel = {
+    .name           = "hevc_videotoolbox",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_HEVC,
+    .pix_fmt        = AV_PIX_FMT_VIDEOTOOLBOX,
+    .alloc_frame    = ff_videotoolbox_alloc_frame,
+    .start_frame    = ff_videotoolbox_h264_start_frame,
+    .decode_slice   = ff_videotoolbox_h264_decode_slice,
+    .end_frame      = videotoolbox_hevc_end_frame,
+    .init           = videotoolbox_common_init,
     .uninit         = ff_videotoolbox_uninit,
     .priv_data_size = sizeof(VTContext),
 };
@@ -624,7 +988,8 @@ AVHWAccel ff_h264_videotoolbox_hwaccel = {
     .start_frame    = ff_videotoolbox_h264_start_frame,
     .decode_slice   = ff_videotoolbox_h264_decode_slice,
     .end_frame      = videotoolbox_h264_end_frame,
-    .uninit         = ff_videotoolbox_uninit,
+    .init           = videotoolbox_common_init,
+    .uninit         = videotoolbox_uninit,
     .priv_data_size = sizeof(VTContext),
 };
 
@@ -637,7 +1002,8 @@ AVHWAccel ff_mpeg1_videotoolbox_hwaccel = {
     .start_frame    = videotoolbox_mpeg_start_frame,
     .decode_slice   = videotoolbox_mpeg_decode_slice,
     .end_frame      = videotoolbox_mpeg_end_frame,
-    .uninit         = ff_videotoolbox_uninit,
+    .init           = videotoolbox_common_init,
+    .uninit         = videotoolbox_uninit,
     .priv_data_size = sizeof(VTContext),
 };
 
@@ -650,7 +1016,8 @@ AVHWAccel ff_mpeg2_videotoolbox_hwaccel = {
     .start_frame    = videotoolbox_mpeg_start_frame,
     .decode_slice   = videotoolbox_mpeg_decode_slice,
     .end_frame      = videotoolbox_mpeg_end_frame,
-    .uninit         = ff_videotoolbox_uninit,
+    .init           = videotoolbox_common_init,
+    .uninit         = videotoolbox_uninit,
     .priv_data_size = sizeof(VTContext),
 };
 
@@ -663,7 +1030,8 @@ AVHWAccel ff_mpeg4_videotoolbox_hwaccel = {
     .start_frame    = videotoolbox_mpeg_start_frame,
     .decode_slice   = videotoolbox_mpeg_decode_slice,
     .end_frame      = videotoolbox_mpeg_end_frame,
-    .uninit         = ff_videotoolbox_uninit,
+    .init           = videotoolbox_common_init,
+    .uninit         = videotoolbox_uninit,
     .priv_data_size = sizeof(VTContext),
 };
 
diff --git a/mythtv/external/FFmpeg/libavcodec/videotoolbox.h b/mythtv/external/FFmpeg/libavcodec/videotoolbox.h
index a48638e2b22..af2db0d5809 100644
--- a/mythtv/external/FFmpeg/libavcodec/videotoolbox.h
+++ b/mythtv/external/FFmpeg/libavcodec/videotoolbox.h
@@ -58,7 +58,8 @@ typedef struct AVVideotoolboxContext {
 
     /**
      * CVPixelBuffer Format Type that Videotoolbox will use for decoded frames.
-     * set by the caller.
+     * set by the caller. If this is set to 0, then no specific format is
+     * requested from the decoder, and its native format is output.
      */
     OSType cv_pix_fmt_type;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/videotoolboxenc.c b/mythtv/external/FFmpeg/libavcodec/videotoolboxenc.c
index cb9e2fe6e8e..eba6cc672f8 100644
--- a/mythtv/external/FFmpeg/libavcodec/videotoolboxenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/videotoolboxenc.c
@@ -26,7 +26,6 @@
 #include "avcodec.h"
 #include "libavutil/opt.h"
 #include "libavutil/avassert.h"
-#include "libavutil/atomic.h"
 #include "libavutil/avstring.h"
 #include "libavcodec/avcodec.h"
 #include "libavutil/pixdesc.h"
@@ -34,12 +33,91 @@
 #include <pthread.h>
 #include "h264.h"
 #include "h264_sei.h"
-
-#if !CONFIG_VT_BT2020
-# define kCVImageBufferColorPrimaries_ITU_R_2020   CFSTR("ITU_R_2020")
-# define kCVImageBufferTransferFunction_ITU_R_2020 CFSTR("ITU_R_2020")
-# define kCVImageBufferYCbCrMatrix_ITU_R_2020      CFSTR("ITU_R_2020")
-#endif
+#include <dlfcn.h>
+
+//These symbols may not be present
+static struct{
+    CFStringRef kCVImageBufferColorPrimaries_ITU_R_2020;
+    CFStringRef kCVImageBufferTransferFunction_ITU_R_2020;
+    CFStringRef kCVImageBufferYCbCrMatrix_ITU_R_2020;
+
+    CFStringRef kVTCompressionPropertyKey_H264EntropyMode;
+    CFStringRef kVTH264EntropyMode_CAVLC;
+    CFStringRef kVTH264EntropyMode_CABAC;
+
+    CFStringRef kVTProfileLevel_H264_Baseline_4_0;
+    CFStringRef kVTProfileLevel_H264_Baseline_4_2;
+    CFStringRef kVTProfileLevel_H264_Baseline_5_0;
+    CFStringRef kVTProfileLevel_H264_Baseline_5_1;
+    CFStringRef kVTProfileLevel_H264_Baseline_5_2;
+    CFStringRef kVTProfileLevel_H264_Baseline_AutoLevel;
+    CFStringRef kVTProfileLevel_H264_Main_4_2;
+    CFStringRef kVTProfileLevel_H264_Main_5_1;
+    CFStringRef kVTProfileLevel_H264_Main_5_2;
+    CFStringRef kVTProfileLevel_H264_Main_AutoLevel;
+    CFStringRef kVTProfileLevel_H264_High_3_0;
+    CFStringRef kVTProfileLevel_H264_High_3_1;
+    CFStringRef kVTProfileLevel_H264_High_3_2;
+    CFStringRef kVTProfileLevel_H264_High_4_0;
+    CFStringRef kVTProfileLevel_H264_High_4_1;
+    CFStringRef kVTProfileLevel_H264_High_4_2;
+    CFStringRef kVTProfileLevel_H264_High_5_1;
+    CFStringRef kVTProfileLevel_H264_High_5_2;
+    CFStringRef kVTProfileLevel_H264_High_AutoLevel;
+
+    CFStringRef kVTCompressionPropertyKey_RealTime;
+
+    CFStringRef kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder;
+    CFStringRef kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder;
+} compat_keys;
+
+#define GET_SYM(symbol, defaultVal)                                     \
+do{                                                                     \
+    CFStringRef* handle = (CFStringRef*)dlsym(RTLD_DEFAULT, #symbol);   \
+    if(!handle)                                                         \
+        compat_keys.symbol = CFSTR(defaultVal);                         \
+    else                                                                \
+        compat_keys.symbol = *handle;                                   \
+}while(0)
+
+static pthread_once_t once_ctrl = PTHREAD_ONCE_INIT;
+
+static void loadVTEncSymbols(){
+    GET_SYM(kCVImageBufferColorPrimaries_ITU_R_2020,   "ITU_R_2020");
+    GET_SYM(kCVImageBufferTransferFunction_ITU_R_2020, "ITU_R_2020");
+    GET_SYM(kCVImageBufferYCbCrMatrix_ITU_R_2020,      "ITU_R_2020");
+
+    GET_SYM(kVTCompressionPropertyKey_H264EntropyMode, "H264EntropyMode");
+    GET_SYM(kVTH264EntropyMode_CAVLC, "CAVLC");
+    GET_SYM(kVTH264EntropyMode_CABAC, "CABAC");
+
+    GET_SYM(kVTProfileLevel_H264_Baseline_4_0,       "H264_Baseline_4_0");
+    GET_SYM(kVTProfileLevel_H264_Baseline_4_2,       "H264_Baseline_4_2");
+    GET_SYM(kVTProfileLevel_H264_Baseline_5_0,       "H264_Baseline_5_0");
+    GET_SYM(kVTProfileLevel_H264_Baseline_5_1,       "H264_Baseline_5_1");
+    GET_SYM(kVTProfileLevel_H264_Baseline_5_2,       "H264_Baseline_5_2");
+    GET_SYM(kVTProfileLevel_H264_Baseline_AutoLevel, "H264_Baseline_AutoLevel");
+    GET_SYM(kVTProfileLevel_H264_Main_4_2,           "H264_Main_4_2");
+    GET_SYM(kVTProfileLevel_H264_Main_5_1,           "H264_Main_5_1");
+    GET_SYM(kVTProfileLevel_H264_Main_5_2,           "H264_Main_5_2");
+    GET_SYM(kVTProfileLevel_H264_Main_AutoLevel,     "H264_Main_AutoLevel");
+    GET_SYM(kVTProfileLevel_H264_High_3_0,           "H264_High_3_0");
+    GET_SYM(kVTProfileLevel_H264_High_3_1,           "H264_High_3_1");
+    GET_SYM(kVTProfileLevel_H264_High_3_2,           "H264_High_3_2");
+    GET_SYM(kVTProfileLevel_H264_High_4_0,           "H264_High_4_0");
+    GET_SYM(kVTProfileLevel_H264_High_4_1,           "H264_High_4_1");
+    GET_SYM(kVTProfileLevel_H264_High_4_2,           "H264_High_4_2");
+    GET_SYM(kVTProfileLevel_H264_High_5_1,           "H264_High_5_1");
+    GET_SYM(kVTProfileLevel_H264_High_5_2,           "H264_High_5_2");
+    GET_SYM(kVTProfileLevel_H264_High_AutoLevel,     "H264_High_AutoLevel");
+
+    GET_SYM(kVTCompressionPropertyKey_RealTime, "RealTime");
+
+    GET_SYM(kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder,
+            "EnableHardwareAcceleratedVideoEncoder");
+    GET_SYM(kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder,
+            "RequireHardwareAcceleratedVideoEncoder");
+}
 
 typedef enum VT_H264Profile {
     H264_PROF_AUTO,
@@ -520,47 +598,66 @@ static bool get_vt_profile_level(AVCodecContext *avctx,
 
         case H264_PROF_BASELINE:
             switch (vtctx->level) {
-                case  0: *profile_level_val = kVTProfileLevel_H264_Baseline_AutoLevel; break;
+                case  0: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_Baseline_AutoLevel; break;
                 case 13: *profile_level_val = kVTProfileLevel_H264_Baseline_1_3;       break;
                 case 30: *profile_level_val = kVTProfileLevel_H264_Baseline_3_0;       break;
                 case 31: *profile_level_val = kVTProfileLevel_H264_Baseline_3_1;       break;
                 case 32: *profile_level_val = kVTProfileLevel_H264_Baseline_3_2;       break;
-                case 40: *profile_level_val = kVTProfileLevel_H264_Baseline_4_0;       break;
+                case 40: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_Baseline_4_0;       break;
                 case 41: *profile_level_val = kVTProfileLevel_H264_Baseline_4_1;       break;
-                case 42: *profile_level_val = kVTProfileLevel_H264_Baseline_4_2;       break;
-                case 50: *profile_level_val = kVTProfileLevel_H264_Baseline_5_0;       break;
-                case 51: *profile_level_val = kVTProfileLevel_H264_Baseline_5_1;       break;
-                case 52: *profile_level_val = kVTProfileLevel_H264_Baseline_5_2;       break;
+                case 42: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_Baseline_4_2;       break;
+                case 50: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_Baseline_5_0;       break;
+                case 51: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_Baseline_5_1;       break;
+                case 52: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_Baseline_5_2;       break;
             }
             break;
 
         case H264_PROF_MAIN:
             switch (vtctx->level) {
-                case  0: *profile_level_val = kVTProfileLevel_H264_Main_AutoLevel; break;
+                case  0: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_Main_AutoLevel; break;
                 case 30: *profile_level_val = kVTProfileLevel_H264_Main_3_0;       break;
                 case 31: *profile_level_val = kVTProfileLevel_H264_Main_3_1;       break;
                 case 32: *profile_level_val = kVTProfileLevel_H264_Main_3_2;       break;
                 case 40: *profile_level_val = kVTProfileLevel_H264_Main_4_0;       break;
                 case 41: *profile_level_val = kVTProfileLevel_H264_Main_4_1;       break;
-                case 42: *profile_level_val = kVTProfileLevel_H264_Main_4_2;       break;
+                case 42: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_Main_4_2;       break;
                 case 50: *profile_level_val = kVTProfileLevel_H264_Main_5_0;       break;
-                case 51: *profile_level_val = kVTProfileLevel_H264_Main_5_1;       break;
-                case 52: *profile_level_val = kVTProfileLevel_H264_Main_5_2;       break;
+                case 51: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_Main_5_1;       break;
+                case 52: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_Main_5_2;       break;
             }
             break;
 
         case H264_PROF_HIGH:
             switch (vtctx->level) {
-                case  0: *profile_level_val = kVTProfileLevel_H264_High_AutoLevel; break;
-                case 30: *profile_level_val = kVTProfileLevel_H264_High_3_0;       break;
-                case 31: *profile_level_val = kVTProfileLevel_H264_High_3_1;       break;
-                case 32: *profile_level_val = kVTProfileLevel_H264_High_3_2;       break;
-                case 40: *profile_level_val = kVTProfileLevel_H264_High_4_0;       break;
-                case 41: *profile_level_val = kVTProfileLevel_H264_High_4_1;       break;
-                case 42: *profile_level_val = kVTProfileLevel_H264_High_4_2;       break;
+                case  0: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_High_AutoLevel; break;
+                case 30: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_High_3_0;       break;
+                case 31: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_High_3_1;       break;
+                case 32: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_High_3_2;       break;
+                case 40: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_High_4_0;       break;
+                case 41: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_High_4_1;       break;
+                case 42: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_High_4_2;       break;
                 case 50: *profile_level_val = kVTProfileLevel_H264_High_5_0;       break;
-                case 51: *profile_level_val = kVTProfileLevel_H264_High_5_1;       break;
-                case 52: *profile_level_val = kVTProfileLevel_H264_High_5_2;       break;
+                case 51: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_High_5_1;       break;
+                case 52: *profile_level_val =
+                                  compat_keys.kVTProfileLevel_H264_High_5_2;       break;
             }
             break;
     }
@@ -701,7 +798,7 @@ static int get_cv_color_primaries(AVCodecContext *avctx,
             break;
 
         case AVCOL_PRI_BT2020:
-            *primaries = kCVImageBufferColorPrimaries_ITU_R_2020;
+            *primaries = compat_keys.kCVImageBufferColorPrimaries_ITU_R_2020;
             break;
 
         default:
@@ -748,7 +845,7 @@ static int get_cv_transfer_function(AVCodecContext *avctx,
 
         case AVCOL_TRC_BT2020_10:
         case AVCOL_TRC_BT2020_12:
-            *transfer_fnc = kCVImageBufferTransferFunction_ITU_R_2020;
+            *transfer_fnc = compat_keys.kCVImageBufferTransferFunction_ITU_R_2020;
             break;
 
         default:
@@ -779,7 +876,7 @@ static int get_cv_ycbcr_matrix(AVCodecContext *avctx, CFStringRef *matrix) {
             break;
 
         case AVCOL_SPC_BT2020_NCL:
-            *matrix = kCVImageBufferYCbCrMatrix_ITU_R_2020;
+            *matrix = compat_keys.kCVImageBufferYCbCrMatrix_ITU_R_2020;
             break;
 
         default:
@@ -800,7 +897,14 @@ static int vtenc_create_encoder(AVCodecContext   *avctx,
 {
     VTEncContext *vtctx = avctx->priv_data;
     SInt32       bit_rate = avctx->bit_rate;
+    SInt32       max_rate = avctx->rc_max_rate;
     CFNumberRef  bit_rate_num;
+    CFNumberRef  bytes_per_second;
+    CFNumberRef  one_second;
+    CFArrayRef   data_rate_limits;
+    int64_t      bytes_per_second_value = 0;
+    int64_t      one_second_value = 0;
+    void         *nums[2];
 
     int status = VTCompressionSessionCreate(kCFAllocatorDefault,
                                             avctx->width,
@@ -840,13 +944,52 @@ static int vtenc_create_encoder(AVCodecContext   *avctx,
         return AVERROR_EXTERNAL;
     }
 
+    bytes_per_second_value = max_rate >> 3;
+    bytes_per_second = CFNumberCreate(kCFAllocatorDefault,
+                                      kCFNumberSInt64Type,
+                                      &bytes_per_second_value);
+    if (!bytes_per_second) {
+        return AVERROR(ENOMEM);
+    }
+    one_second_value = 1;
+    one_second = CFNumberCreate(kCFAllocatorDefault,
+                                kCFNumberSInt64Type,
+                                &one_second_value);
+    if (!one_second) {
+        CFRelease(bytes_per_second);
+        return AVERROR(ENOMEM);
+    }
+    nums[0] = bytes_per_second;
+    nums[1] = one_second;
+    data_rate_limits = CFArrayCreate(kCFAllocatorDefault,
+                                     nums,
+                                     2,
+                                     &kCFTypeArrayCallBacks);
+
+    if (!data_rate_limits) {
+        CFRelease(bytes_per_second);
+        CFRelease(one_second);
+        return AVERROR(ENOMEM);
+    }
+    status = VTSessionSetProperty(vtctx->session,
+                                  kVTCompressionPropertyKey_DataRateLimits,
+                                  data_rate_limits);
+
+    CFRelease(bytes_per_second);
+    CFRelease(one_second);
+    CFRelease(data_rate_limits);
+
+    if (status) {
+        av_log(avctx, AV_LOG_ERROR, "Error setting max bitrate property: %d\n", status);
+        return AVERROR_EXTERNAL;
+    }
+
     if (profile_level) {
         status = VTSessionSetProperty(vtctx->session,
                                       kVTCompressionPropertyKey_ProfileLevel,
                                       profile_level);
         if (status) {
             av_log(avctx, AV_LOG_ERROR, "Error setting profile/level property: %d\n", status);
-            return AVERROR_EXTERNAL;
         }
     }
 
@@ -1012,22 +1155,21 @@ static int vtenc_create_encoder(AVCodecContext   *avctx,
 
     if (vtctx->entropy != VT_ENTROPY_NOT_SET) {
         CFStringRef entropy = vtctx->entropy == VT_CABAC ?
-                                kVTH264EntropyMode_CABAC:
-                                kVTH264EntropyMode_CAVLC;
+                                compat_keys.kVTH264EntropyMode_CABAC:
+                                compat_keys.kVTH264EntropyMode_CAVLC;
 
         status = VTSessionSetProperty(vtctx->session,
-                                      kVTCompressionPropertyKey_H264EntropyMode,
+                                      compat_keys.kVTCompressionPropertyKey_H264EntropyMode,
                                       entropy);
 
         if (status) {
             av_log(avctx, AV_LOG_ERROR, "Error setting entropy property: %d\n", status);
-            return AVERROR_EXTERNAL;
         }
     }
 
     if (vtctx->realtime) {
         status = VTSessionSetProperty(vtctx->session,
-                                      kVTCompressionPropertyKey_RealTime,
+                                      compat_keys.kVTCompressionPropertyKey_RealTime,
                                       kCFBooleanTrue);
 
         if (status) {
@@ -1055,6 +1197,8 @@ static av_cold int vtenc_init(AVCodecContext *avctx)
     CFNumberRef            gamma_level = NULL;
     int                    status;
 
+    pthread_once(&once_ctrl, loadVTEncSymbols);
+
     codec_type = get_cm_codec_type(avctx->codec_id);
     if (!codec_type) {
         av_log(avctx, AV_LOG_ERROR, "Error: no mapping for AVCodecID %d\n", avctx->codec_id);
@@ -1087,9 +1231,13 @@ static av_cold int vtenc_init(AVCodecContext *avctx)
 
 #if !TARGET_OS_IPHONE
     if (!vtctx->allow_sw) {
-        CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder, kCFBooleanTrue);
+        CFDictionarySetValue(enc_info,
+                             compat_keys.kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder,
+                             kCFBooleanTrue);
     } else {
-        CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder,  kCFBooleanTrue);
+        CFDictionarySetValue(enc_info,
+                             compat_keys.kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder,
+                             kCFBooleanTrue);
     }
 #endif
 
@@ -1137,7 +1285,7 @@ static av_cold int vtenc_init(AVCodecContext *avctx)
                                    kCFAllocatorDefault,
                                    &has_b_frames_cfbool);
 
-    if (!status) {
+    if (!status && has_b_frames_cfbool) {
         //Some devices don't output B-frames for main profile, even if requested.
         vtctx->has_b_frames = CFBooleanGetValue(has_b_frames_cfbool);
         CFRelease(has_b_frames_cfbool);
@@ -1451,7 +1599,7 @@ static int copy_replace_length_codes(
             remaining_dst_size--;
 
             wrote_bytes = write_sei(sei,
-                                    SEI_TYPE_USER_DATA_REGISTERED,
+                                    H264_SEI_TYPE_USER_DATA_REGISTERED,
                                     dst_data,
                                     remaining_dst_size);
 
@@ -1507,7 +1655,7 @@ static int copy_replace_length_codes(
                 return status;
 
             wrote_bytes = write_sei(sei,
-                                    SEI_TYPE_USER_DATA_REGISTERED,
+                                    H264_SEI_TYPE_USER_DATA_REGISTERED,
                                     new_sei,
                                     remaining_dst_size - old_sei_length);
             if (wrote_bytes < 0)
@@ -1603,7 +1751,7 @@ static int vtenc_cm_to_avpacket(
 
     if (sei) {
         size_t msg_size = get_sei_msg_bytes(sei,
-                                            SEI_TYPE_USER_DATA_REGISTERED);
+                                            H264_SEI_TYPE_USER_DATA_REGISTERED);
 
         sei_nalu_size = sizeof(start_code) + 1 + msg_size + 1;
     }
@@ -1678,7 +1826,7 @@ static int get_cv_pixel_info(
 {
     VTEncContext *vtctx = avctx->priv_data;
     int av_format       = frame->format;
-    int av_color_range  = av_frame_get_color_range(frame);
+    int av_color_range  = frame->color_range;
     int i;
     int range_guessed;
     int status;
@@ -1925,7 +2073,7 @@ static int create_cv_pixel_buffer(AVCodecContext   *avctx,
             AV_LOG_ERROR,
             "Error: Cannot convert format %d color_range %d: %d\n",
             frame->format,
-            av_frame_get_color_range(frame),
+            frame->color_range,
             status
         );
 
@@ -2193,8 +2341,8 @@ static int vtenc_populate_extradata(AVCodecContext   *avctx,
     frame->format          = avctx->pix_fmt;
     frame->width           = avctx->width;
     frame->height          = avctx->height;
-    av_frame_set_colorspace(frame, avctx->colorspace);
-    av_frame_set_color_range(frame, avctx->color_range);
+    frame->colorspace      = avctx->colorspace;
+    frame->color_range     = avctx->color_range;
     frame->color_trc       = avctx->color_trc;
     frame->color_primaries = avctx->color_primaries;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/vlc.h b/mythtv/external/FFmpeg/libavcodec/vlc.h
index 9e38f8c6b21..42ccddf3fc6 100644
--- a/mythtv/external/FFmpeg/libavcodec/vlc.h
+++ b/mythtv/external/FFmpeg/libavcodec/vlc.h
@@ -54,12 +54,28 @@ void ff_free_vlc(VLC *vlc);
 #define INIT_VLC_LE             2
 #define INIT_VLC_USE_NEW_STATIC 4
 
-#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)       \
+#define INIT_VLC_SPARSE_STATIC(vlc, bits, a, b, c, d, e, f, g, h, i, j, static_size) \
+    do {                                                                   \
+        static VLC_TYPE table[static_size][2];                             \
+        (vlc)->table           = table;                                    \
+        (vlc)->table_allocated = static_size;                              \
+        ff_init_vlc_sparse(vlc, bits, a, b, c, d, e, f, g, h, i, j,        \
+            INIT_VLC_USE_NEW_STATIC);                                      \
+    } while (0)
+
+#define INIT_LE_VLC_SPARSE_STATIC(vlc, bits, a, b, c, d, e, f, g, h, i, j, static_size) \
     do {                                                                   \
         static VLC_TYPE table[static_size][2];                             \
         (vlc)->table           = table;                                    \
         (vlc)->table_allocated = static_size;                              \
-        init_vlc(vlc, bits, a, b, c, d, e, f, g, INIT_VLC_USE_NEW_STATIC); \
+        ff_init_vlc_sparse(vlc, bits, a, b, c, d, e, f, g, h, i, j,        \
+            INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);                        \
     } while (0)
 
+#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)       \
+    INIT_VLC_SPARSE_STATIC(vlc, bits, a, b, c, d, e, f, g, NULL, 0, 0, static_size)
+
+#define INIT_LE_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size) \
+    INIT_LE_VLC_SPARSE_STATIC(vlc, bits, a, b, c, d, e, f, g, NULL, 0, 0, static_size)
+
 #endif /* AVCODEC_VLC_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vmnc.c b/mythtv/external/FFmpeg/libavcodec/vmnc.c
index 49abb776f2d..30b1414e494 100644
--- a/mythtv/external/FFmpeg/libavcodec/vmnc.c
+++ b/mythtv/external/FFmpeg/libavcodec/vmnc.c
@@ -287,17 +287,24 @@ static int decode_hextile(VmncContext *c, uint8_t* dst, GetByteContext *gb,
                     return AVERROR_INVALIDDATA;
                 }
                 for (k = 0; k < rects; k++) {
+                    int rect_x, rect_y, rect_w, rect_h;
                     if (color)
                         fg = vmnc_get_pixel(gb, bpp, c->bigendian);
                     xy = bytestream2_get_byte(gb);
                     wh = bytestream2_get_byte(gb);
-                    if (   (xy >> 4) + (wh >> 4) + 1 > w - i
-                        || (xy & 0xF) + (wh & 0xF)+1 > h - j) {
+
+                    rect_x = xy >> 4;
+                    rect_y = xy & 0xF;
+                    rect_w = (wh >> 4) + 1;
+                    rect_h = (wh & 0xF) + 1;
+
+                    if (rect_x + rect_w > w - i || rect_y + rect_h > h - j) {
                         av_log(c->avctx, AV_LOG_ERROR, "Rectangle outside picture\n");
                         return AVERROR_INVALIDDATA;
                     }
-                    paint_rect(dst2, xy >> 4, xy & 0xF,
-                               (wh>>4)+1, (wh & 0xF)+1, fg, bpp, stride);
+
+                    paint_rect(dst2, rect_x, rect_y,
+                               rect_w, rect_h, fg, bpp, stride);
                 }
             }
         }
@@ -374,6 +381,12 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
         w   = bytestream2_get_be16(gb);
         h   = bytestream2_get_be16(gb);
         enc = bytestream2_get_be32(gb);
+        if ((dx + w > c->width) || (dy + h > c->height)) {
+            av_log(avctx, AV_LOG_ERROR,
+                    "Incorrect frame size: %ix%i+%ix%i of %ix%i\n",
+                    w, h, dx, dy, c->width, c->height);
+            return AVERROR_INVALIDDATA;
+        }
         outptr = c->pic->data[0] + dx * c->bpp2 + dy * c->pic->linesize[0];
         size_left = bytestream2_get_bytes_left(gb);
         switch (enc) {
@@ -451,12 +464,6 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
             bytestream2_skip(gb, 2);
             break;
         case 0x00000000: // raw rectangle data
-            if ((dx + w > c->width) || (dy + h > c->height)) {
-                av_log(avctx, AV_LOG_ERROR,
-                       "Incorrect frame size: %ix%i+%ix%i of %ix%i\n",
-                       w, h, dx, dy, c->width, c->height);
-                return AVERROR_INVALIDDATA;
-            }
             if (size_left < w * h * c->bpp2) {
                 av_log(avctx, AV_LOG_ERROR,
                        "Premature end of data! (need %i got %i)\n",
@@ -467,12 +474,6 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                       c->pic->linesize[0]);
             break;
         case 0x00000005: // HexTile encoded rectangle
-            if ((dx + w > c->width) || (dy + h > c->height)) {
-                av_log(avctx, AV_LOG_ERROR,
-                       "Incorrect frame size: %ix%i+%ix%i of %ix%i\n",
-                       w, h, dx, dy, c->width, c->height);
-                return AVERROR_INVALIDDATA;
-            }
             res = decode_hextile(c, outptr, gb, w, h, c->pic->linesize[0]);
             if (res < 0)
                 return res;
diff --git a/mythtv/external/FFmpeg/libavcodec/vorbis.c b/mythtv/external/FFmpeg/libavcodec/vorbis.c
index 399020eec55..aabd9bbd19e 100644
--- a/mythtv/external/FFmpeg/libavcodec/vorbis.c
+++ b/mythtv/external/FFmpeg/libavcodec/vorbis.c
@@ -67,7 +67,7 @@ int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, unsigned num)
     if (bits[p] > 32)
         return AVERROR_INVALIDDATA;
     for (i = 0; i < bits[p]; ++i)
-        exit_at_level[i+1] = 1 << i;
+        exit_at_level[i+1] = 1u << i;
 
     ++p;
 
@@ -91,7 +91,7 @@ int ff_vorbis_len2vlc(uint8_t *bits, uint32_t *codes, unsigned num)
         exit_at_level[i] = 0;
         // construct code (append 0s to end) and introduce new exits
         for (j = i + 1 ;j <= bits[p]; ++j)
-            exit_at_level[j] = code + (1 << (j - 1));
+            exit_at_level[j] = code + (1u << (j - 1));
         codes[p] = code;
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/vorbis_parser.h b/mythtv/external/FFmpeg/libavcodec/vorbis_parser.h
index 92050277ed1..789932ac492 100644
--- a/mythtv/external/FFmpeg/libavcodec/vorbis_parser.h
+++ b/mythtv/external/FFmpeg/libavcodec/vorbis_parser.h
@@ -32,9 +32,6 @@ typedef struct AVVorbisParseContext AVVorbisParseContext;
 
 /**
  * Allocate and initialize the Vorbis parser using headers in the extradata.
- *
- * @param avctx codec context
- * @param s     Vorbis parser context
  */
 AVVorbisParseContext *av_vorbis_parse_init(const uint8_t *extradata,
                                            int extradata_size);
diff --git a/mythtv/external/FFmpeg/libavcodec/vorbisdec.c b/mythtv/external/FFmpeg/libavcodec/vorbisdec.c
index 0a5eaa68794..2a4f482031e 100644
--- a/mythtv/external/FFmpeg/libavcodec/vorbisdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/vorbisdec.c
@@ -731,7 +731,7 @@ static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)
         if (!res_setup->classifs)
             return AVERROR(ENOMEM);
 
-        ff_dlog(NULL, "    begin %d end %d part.size %d classif.s %d classbook %d \n",
+        ff_dlog(NULL, "    begin %"PRIu32" end %"PRIu32" part.size %u classif.s %"PRIu8" classbook %"PRIu8"\n",
                 res_setup->begin, res_setup->end, res_setup->partition_size,
                 res_setup->classifications, res_setup->classbook);
 
@@ -876,7 +876,7 @@ static int create_map(vorbis_context *vc, unsigned floor_number)
     }
 
     for (idx = 0; idx <= n; ++idx) {
-        ff_dlog(NULL, "floor0 map: map at pos %d is %d\n", idx, map[idx]);
+        ff_dlog(NULL, "floor0 map: map at pos %d is %"PRId32"\n", idx, map[idx]);
     }
 
     return 0;
@@ -1012,7 +1012,7 @@ static int vorbis_parse_id_hdr(vorbis_context *vc)
     if (!vc->fdsp)
         return AVERROR(ENOMEM);
 
-    ff_dlog(NULL, " vorbis version %d \n audio_channels %d \n audio_samplerate %d \n bitrate_max %d \n bitrate_nom %d \n bitrate_min %d \n blk_0 %d blk_1 %d \n ",
+    ff_dlog(NULL, " vorbis version %"PRIu32" \n audio_channels %"PRIu8" \n audio_samplerate %"PRIu32" \n bitrate_max %"PRIu32" \n bitrate_nom %"PRIu32" \n bitrate_min %"PRIu32" \n blk_0 %"PRIu32" blk_1 %"PRIu32" \n ",
             vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize[0], vc->blocksize[1]);
 
 /*
diff --git a/mythtv/external/FFmpeg/libavcodec/vorbisenc.c b/mythtv/external/FFmpeg/libavcodec/vorbisenc.c
index 2974ca2cf95..a4ecd8f7547 100644
--- a/mythtv/external/FFmpeg/libavcodec/vorbisenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/vorbisenc.c
@@ -25,6 +25,7 @@
  */
 
 #include <float.h>
+#include "libavutil/float_dsp.h"
 
 #include "avcodec.h"
 #include "internal.h"
@@ -33,6 +34,9 @@
 #include "vorbis.h"
 #include "vorbis_enc_data.h"
 
+#include "audio_frame_queue.h"
+#include "libavfilter/bufferqueue.h"
+
 #define BITSTREAM_WRITER_LE
 #include "put_bits.h"
 
@@ -108,8 +112,12 @@ typedef struct vorbis_enc_context {
     float *samples;
     float *floor;  // also used for tmp values for mdct
     float *coeffs; // also used for residue after floor
+    float *scratch; // used for tmp values for psy model
     float quality;
 
+    AudioFrameQueue afq;
+    struct FFBufQueue bufqueue;
+
     int ncodebooks;
     vorbis_enc_codebook *codebooks;
 
@@ -126,6 +134,8 @@ typedef struct vorbis_enc_context {
     vorbis_enc_mode *modes;
 
     int64_t next_pts;
+
+    AVFloatDSPContext *fdsp;
 } vorbis_enc_context;
 
 #define MAX_CHANNELS     2
@@ -236,6 +246,26 @@ static int ready_residue(vorbis_enc_residue *rc, vorbis_enc_context *venc)
     return 0;
 }
 
+static av_cold int dsp_init(AVCodecContext *avctx, vorbis_enc_context *venc)
+{
+    int ret = 0;
+
+    venc->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
+    if (!venc->fdsp)
+        return AVERROR(ENOMEM);
+
+    // init windows
+    venc->win[0] = ff_vorbis_vwin[venc->log2_blocksize[0] - 6];
+    venc->win[1] = ff_vorbis_vwin[venc->log2_blocksize[1] - 6];
+
+    if ((ret = ff_mdct_init(&venc->mdct[0], venc->log2_blocksize[0], 0, 1.0)) < 0)
+        return ret;
+    if ((ret = ff_mdct_init(&venc->mdct[1], venc->log2_blocksize[1], 0, 1.0)) < 0)
+        return ret;
+
+    return 0;
+}
+
 static int create_vorbis_context(vorbis_enc_context *venc,
                                  AVCodecContext *avctx)
 {
@@ -322,7 +352,7 @@ static int create_vorbis_context(vorbis_enc_context *venc,
             c->books[j] = floor_classes[i].nbooks[j];
     }
     fc->multiplier = 2;
-    fc->rangebits  = venc->log2_blocksize[0] - 1;
+    fc->rangebits  = venc->log2_blocksize[1] - 1;
 
     fc->values = 2;
     for (i = 0; i < fc->partitions; i++)
@@ -409,29 +439,29 @@ static int create_vorbis_context(vorbis_enc_context *venc,
         mc->angle[0]     = 1;
     }
 
-    venc->nmodes = 1;
+    venc->nmodes = 2;
     venc->modes  = av_malloc(sizeof(vorbis_enc_mode) * venc->nmodes);
     if (!venc->modes)
         return AVERROR(ENOMEM);
 
-    // single mode
+    // Short block
     venc->modes[0].blockflag = 0;
     venc->modes[0].mapping   = 0;
+    // Long block
+    venc->modes[1].blockflag = 1;
+    venc->modes[1].mapping   = 0;
 
     venc->have_saved = 0;
     venc->saved      = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2);
     venc->samples    = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]));
     venc->floor      = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2);
     venc->coeffs     = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]) / 2);
-    if (!venc->saved || !venc->samples || !venc->floor || !venc->coeffs)
-        return AVERROR(ENOMEM);
+    venc->scratch    = av_malloc_array(sizeof(float) * venc->channels, (1 << venc->log2_blocksize[1]));
 
-    venc->win[0] = ff_vorbis_vwin[venc->log2_blocksize[0] - 6];
-    venc->win[1] = ff_vorbis_vwin[venc->log2_blocksize[1] - 6];
+    if (!venc->saved || !venc->samples || !venc->floor || !venc->coeffs || !venc->scratch)
+        return AVERROR(ENOMEM);
 
-    if ((ret = ff_mdct_init(&venc->mdct[0], venc->log2_blocksize[0], 0, 1.0)) < 0)
-        return ret;
-    if ((ret = ff_mdct_init(&venc->mdct[1], venc->log2_blocksize[1], 0, 1.0)) < 0)
+    if ((ret = dsp_init(avctx, venc)) < 0)
         return ret;
 
     return 0;
@@ -967,71 +997,134 @@ static int residue_encode(vorbis_enc_context *venc, vorbis_enc_residue *rc,
     return 0;
 }
 
-static int apply_window_and_mdct(vorbis_enc_context *venc,
-                                 float **audio, int samples)
+static int apply_window_and_mdct(vorbis_enc_context *venc)
 {
-    int i, channel;
-    const float * win = venc->win[0];
-    int window_len = 1 << (venc->log2_blocksize[0] - 1);
-    float n = (float)(1 << venc->log2_blocksize[0]) / 4.0;
-    // FIXME use dsp
+    int channel;
+    const float * win = venc->win[1];
+    int window_len = 1 << (venc->log2_blocksize[1] - 1);
+    float n = (float)(1 << venc->log2_blocksize[1]) / 4.0;
+    AVFloatDSPContext *fdsp = venc->fdsp;
 
-    if (!venc->have_saved && !samples)
-        return 0;
+    for (channel = 0; channel < venc->channels; channel++) {
+        float *offset = venc->samples + channel * window_len * 2;
 
-    if (venc->have_saved) {
-        for (channel = 0; channel < venc->channels; channel++)
-            memcpy(venc->samples + channel * window_len * 2,
-                   venc->saved + channel * window_len, sizeof(float) * window_len);
-    } else {
-        for (channel = 0; channel < venc->channels; channel++)
-            memset(venc->samples + channel * window_len * 2, 0,
-                   sizeof(float) * window_len);
+        fdsp->vector_fmul(offset, offset, win, window_len);
+        fdsp->vector_fmul_scalar(offset, offset, 1/n, window_len);
+
+        offset += window_len;
+
+        fdsp->vector_fmul_reverse(offset, offset, win, window_len);
+        fdsp->vector_fmul_scalar(offset, offset, 1/n, window_len);
+
+        venc->mdct[1].mdct_calc(&venc->mdct[1], venc->coeffs + channel * window_len,
+                     venc->samples + channel * window_len * 2);
     }
+    return 1;
+}
 
-    if (samples) {
-        for (channel = 0; channel < venc->channels; channel++) {
-            float * offset = venc->samples + channel*window_len*2 + window_len;
-            for (i = 0; i < samples; i++)
-                offset[i] = audio[channel][i] / n * win[window_len - i - 1];
-        }
-    } else {
-        for (channel = 0; channel < venc->channels; channel++)
-            memset(venc->samples + channel * window_len * 2 + window_len,
-                   0, sizeof(float) * window_len);
+/* Used for padding the last encoded packet */
+static AVFrame *spawn_empty_frame(AVCodecContext *avctx, int channels)
+{
+    AVFrame *f = av_frame_alloc();
+    int ch;
+
+    if (!f)
+        return NULL;
+
+    f->format = avctx->sample_fmt;
+    f->nb_samples = avctx->frame_size;
+    f->channel_layout = avctx->channel_layout;
+
+    if (av_frame_get_buffer(f, 4)) {
+        av_frame_free(&f);
+        return NULL;
     }
 
-    for (channel = 0; channel < venc->channels; channel++)
-        venc->mdct[0].mdct_calc(&venc->mdct[0], venc->coeffs + channel * window_len,
-                     venc->samples + channel * window_len * 2);
+    for (ch = 0; ch < channels; ch++) {
+        size_t bps = av_get_bytes_per_sample(f->format);
+        memset(f->extended_data[ch], 0, bps * f->nb_samples);
+    }
+    return f;
+}
+
+/* Set up audio samples for psy analysis and window/mdct */
+static void move_audio(vorbis_enc_context *venc, int sf_size)
+{
+    AVFrame *cur = NULL;
+    int frame_size = 1 << (venc->log2_blocksize[1] - 1);
+    int subframes = frame_size / sf_size;
+    int sf, ch;
+
+    /* Copy samples from last frame into current frame */
+    if (venc->have_saved)
+        for (ch = 0; ch < venc->channels; ch++)
+            memcpy(venc->samples + 2 * ch * frame_size,
+                   venc->saved + ch * frame_size, sizeof(float) * frame_size);
+    else
+        for (ch = 0; ch < venc->channels; ch++)
+            memset(venc->samples + 2 * ch * frame_size, 0, sizeof(float) * frame_size);
 
-    if (samples) {
-        for (channel = 0; channel < venc->channels; channel++) {
-            float *offset = venc->saved + channel * window_len;
-            for (i = 0; i < samples; i++)
-                offset[i] = audio[channel][i] / n * win[i];
+    for (sf = 0; sf < subframes; sf++) {
+        cur = ff_bufqueue_get(&venc->bufqueue);
+
+        for (ch = 0; ch < venc->channels; ch++) {
+            float *offset = venc->samples + 2 * ch * frame_size + frame_size;
+            float *save = venc->saved + ch * frame_size;
+            const float *input = (float *) cur->extended_data[ch];
+            const size_t len  = cur->nb_samples * sizeof(float);
+
+            memcpy(offset + sf*sf_size, input, len);
+            memcpy(save + sf*sf_size, input, len);   // Move samples for next frame
         }
-        venc->have_saved = 1;
-    } else {
-        venc->have_saved = 0;
+        av_frame_free(&cur);
     }
-    return 1;
+    venc->have_saved = 1;
+    memcpy(venc->scratch, venc->samples, 2 * venc->channels * frame_size);
 }
 
 static int vorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
                                const AVFrame *frame, int *got_packet_ptr)
 {
     vorbis_enc_context *venc = avctx->priv_data;
-    float **audio = frame ? (float **)frame->extended_data : NULL;
-    int samples = frame ? frame->nb_samples : 0;
+    int i, ret, need_more;
+    int frame_size = 1 << (venc->log2_blocksize[1] - 1);
     vorbis_enc_mode *mode;
     vorbis_enc_mapping *mapping;
     PutBitContext pb;
-    int i, ret;
 
-    if (!apply_window_and_mdct(venc, audio, samples))
+    if (frame) {
+        if ((ret = ff_af_queue_add(&venc->afq, frame)) < 0)
+            return ret;
+        ff_bufqueue_add(avctx, &venc->bufqueue, av_frame_clone(frame));
+    } else
+        if (!venc->afq.remaining_samples)
+            return 0;
+
+    need_more = venc->bufqueue.available * avctx->frame_size < frame_size;
+    need_more = frame && need_more;
+    if (need_more)
+        return 0;
+
+    /* Pad the bufqueue with empty frames for encoding the last packet. */
+    if (!frame) {
+        if (venc->bufqueue.available * avctx->frame_size < frame_size) {
+            int frames_needed = (frame_size/avctx->frame_size) - venc->bufqueue.available;
+            int i;
+
+            for (i = 0; i < frames_needed; i++) {
+               AVFrame *empty = spawn_empty_frame(avctx, venc->channels);
+               if (!empty)
+                   return AVERROR(ENOMEM);
+
+               ff_bufqueue_add(avctx, &venc->bufqueue, empty);
+            }
+        }
+    }
+
+    move_audio(venc, avctx->frame_size);
+
+    if (!apply_window_and_mdct(venc))
         return 0;
-    samples = 1 << (venc->log2_blocksize[0] - 1);
 
     if ((ret = ff_alloc_packet2(avctx, avpkt, 8192, 0)) < 0)
         return ret;
@@ -1045,33 +1138,33 @@ static int vorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 
     put_bits(&pb, 1, 0); // magic bit
 
-    put_bits(&pb, ilog(venc->nmodes - 1), 0); // 0 bits, the mode
+    put_bits(&pb, ilog(venc->nmodes - 1), 1); // Mode for current frame
 
-    mode    = &venc->modes[0];
+    mode    = &venc->modes[1];
     mapping = &venc->mappings[mode->mapping];
     if (mode->blockflag) {
-        put_bits(&pb, 1, 0);
-        put_bits(&pb, 1, 0);
+        put_bits(&pb, 1, 1); // Previous windowflag
+        put_bits(&pb, 1, 1); // Next windowflag
     }
 
     for (i = 0; i < venc->channels; i++) {
         vorbis_enc_floor *fc = &venc->floors[mapping->floor[mapping->mux[i]]];
         uint16_t posts[MAX_FLOOR_VALUES];
-        floor_fit(venc, fc, &venc->coeffs[i * samples], posts, samples);
-        if (floor_encode(venc, fc, &pb, posts, &venc->floor[i * samples], samples)) {
+        floor_fit(venc, fc, &venc->coeffs[i * frame_size], posts, frame_size);
+        if (floor_encode(venc, fc, &pb, posts, &venc->floor[i * frame_size], frame_size)) {
             av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
             return AVERROR(EINVAL);
         }
     }
 
-    for (i = 0; i < venc->channels * samples; i++)
+    for (i = 0; i < venc->channels * frame_size; i++)
         venc->coeffs[i] /= venc->floor[i];
 
     for (i = 0; i < mapping->coupling_steps; i++) {
-        float *mag = venc->coeffs + mapping->magnitude[i] * samples;
-        float *ang = venc->coeffs + mapping->angle[i]     * samples;
+        float *mag = venc->coeffs + mapping->magnitude[i] * frame_size;
+        float *ang = venc->coeffs + mapping->angle[i]     * frame_size;
         int j;
-        for (j = 0; j < samples; j++) {
+        for (j = 0; j < frame_size; j++) {
             float a = ang[j];
             ang[j] -= mag[j];
             if (mag[j] > 0)
@@ -1082,7 +1175,7 @@ static int vorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     }
 
     if (residue_encode(venc, &venc->residues[mapping->residue[mapping->mux[0]]],
-                       &pb, venc->coeffs, samples, venc->channels)) {
+                       &pb, venc->coeffs, frame_size, venc->channels)) {
         av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
         return AVERROR(EINVAL);
     }
@@ -1090,15 +1183,14 @@ static int vorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     flush_put_bits(&pb);
     avpkt->size = put_bits_count(&pb) >> 3;
 
-    avpkt->duration = ff_samples_to_time_base(avctx, avctx->frame_size);
-    if (frame) {
-        if (frame->pts != AV_NOPTS_VALUE)
-            avpkt->pts = ff_samples_to_time_base(avctx, frame->pts);
-    } else {
-        avpkt->pts = venc->next_pts;
+    ff_af_queue_remove(&venc->afq, frame_size, &avpkt->pts, &avpkt->duration);
+
+    if (frame_size > avpkt->duration) {
+        uint8_t *side = av_packet_new_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
+        if (!side)
+            return AVERROR(ENOMEM);
+        AV_WL32(&side[4], frame_size - avpkt->duration);
     }
-    if (avpkt->pts != AV_NOPTS_VALUE)
-        venc->next_pts = avpkt->pts + avpkt->duration;
 
     *got_packet_ptr = 1;
     return 0;
@@ -1155,9 +1247,13 @@ static av_cold int vorbis_encode_close(AVCodecContext *avctx)
     av_freep(&venc->samples);
     av_freep(&venc->floor);
     av_freep(&venc->coeffs);
+    av_freep(&venc->scratch);
+    av_freep(&venc->fdsp);
 
     ff_mdct_end(&venc->mdct[0]);
     ff_mdct_end(&venc->mdct[1]);
+    ff_af_queue_close(&venc->afq);
+    ff_bufqueue_discard_all(&venc->bufqueue);
 
     av_freep(&avctx->extradata);
 
@@ -1188,7 +1284,9 @@ static av_cold int vorbis_encode_init(AVCodecContext *avctx)
         goto error;
     avctx->extradata_size = ret;
 
-    avctx->frame_size = 1 << (venc->log2_blocksize[0] - 1);
+    avctx->frame_size = 64;
+
+    ff_af_queue_init(avctx, &venc->afq);
 
     return 0;
 error:
diff --git a/mythtv/external/FFmpeg/libavcodec/vp3.c b/mythtv/external/FFmpeg/libavcodec/vp3.c
index fa749be0b75..f167acf4eef 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp3.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp3.c
@@ -1071,6 +1071,9 @@ static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
 
     s->dct_tokens[0][0] = s->dct_tokens_base;
 
+    if (get_bits_left(gb) < 16)
+        return AVERROR_INVALIDDATA;
+
     /* fetch the DC table indexes */
     dc_y_table = get_bits(gb, 4);
     dc_c_table = get_bits(gb, 4);
@@ -1080,6 +1083,8 @@ static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
                                    0, residual_eob_run);
     if (residual_eob_run < 0)
         return residual_eob_run;
+    if (get_bits_left(gb) < 8)
+        return AVERROR_INVALIDDATA;
 
     /* reverse prediction of the Y-plane DC coefficients */
     reverse_dc_prediction(s, 0, s->fragment_width[0], s->fragment_height[0]);
@@ -1102,6 +1107,8 @@ static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
                               s->fragment_width[1], s->fragment_height[1]);
     }
 
+    if (get_bits_left(gb) < 8)
+        return AVERROR_INVALIDDATA;
     /* fetch the AC table indexes */
     ac_y_table = get_bits(gb, 4);
     ac_c_table = get_bits(gb, 4);
@@ -1996,6 +2003,7 @@ static int vp3_decode_frame(AVCodecContext *avctx,
                             void *data, int *got_frame,
                             AVPacket *avpkt)
 {
+    AVFrame     *frame  = data;
     const uint8_t *buf  = avpkt->data;
     int buf_size        = avpkt->size;
     Vp3DecodeContext *s = avctx->priv_data;
@@ -2022,8 +2030,9 @@ static int vp3_decode_frame(AVCodecContext *avctx,
                 ret = vp3_decode_init(avctx);
             if (ret < 0) {
                 vp3_decode_end(avctx);
+                return ret;
             }
-            return ret;
+            return buf_size;
         } else if (type == 2) {
             vp3_decode_end(avctx);
             ret = theora_decode_tables(avctx, &gb);
@@ -2031,8 +2040,9 @@ static int vp3_decode_frame(AVCodecContext *avctx,
                 ret = vp3_decode_init(avctx);
             if (ret < 0) {
                 vp3_decode_end(avctx);
+                return ret;
             }
-            return ret;
+            return buf_size;
         }
 
         av_log(avctx, AV_LOG_ERROR,
@@ -2167,12 +2177,12 @@ static int vp3_decode_frame(AVCodecContext *avctx,
     /* output frame, offset as needed */
     if ((ret = av_frame_ref(data, s->current_frame.f)) < 0)
         return ret;
-    for (i = 0; i < 3; i++) {
-        AVFrame *dst = data;
-        int off = (s->offset_x >> (i && s->chroma_y_shift)) +
-                  (s->offset_y >> (i && s->chroma_y_shift)) * dst->linesize[i];
-        dst->data[i] += off;
-    }
+
+    frame->crop_left   = s->offset_x;
+    frame->crop_right  = avctx->coded_width - avctx->width - s->offset_x;
+    frame->crop_top    = s->offset_y;
+    frame->crop_bottom = avctx->coded_height - avctx->height - s->offset_y;
+
     *got_frame = 1;
 
     if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME)) {
@@ -2342,16 +2352,6 @@ static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
         // to normal axis ([0,0] upper left)
         s->offset_x = offset_x;
         s->offset_y = s->height - visible_height - offset_y;
-
-        if ((s->offset_x & 0x1F) && !(avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
-            s->offset_x &= ~0x1F;
-            if (!s->offset_x_warned) {
-                s->offset_x_warned = 1;
-                av_log(avctx, AV_LOG_WARNING, "Reducing offset_x from %d to %d"
-                    "chroma samples to preserve alignment.\n",
-                    offset_x, s->offset_x);
-            }
-        }
     }
 
     if (colorspace == 1)
@@ -2564,7 +2564,8 @@ AVCodec ff_theora_decoder = {
                              AV_CODEC_CAP_FRAME_THREADS,
     .flush                 = vp3_decode_flush,
     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp3_init_thread_copy),
-    .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context)
+    .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context),
+    .caps_internal         = FF_CODEC_CAP_EXPORTS_CROPPING,
 };
 #endif
 
diff --git a/mythtv/external/FFmpeg/libavcodec/vp3dsp.c b/mythtv/external/FFmpeg/libavcodec/vp3dsp.c
index 814c78e34a7..fdaa292d371 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp3dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp3dsp.c
@@ -41,9 +41,9 @@
 #define xC6S2 25080
 #define xC7S1 12785
 
-#define M(a, b) (((a) * (b)) >> 16)
+#define M(a, b) ((int)((SUINT)(a) * (b)) >> 16)
 
-static av_always_inline void idct(uint8_t *dst, int stride,
+static av_always_inline void idct(uint8_t *dst, ptrdiff_t stride,
                                   int16_t *input, int type)
 {
     int16_t *ip = input;
@@ -194,21 +194,21 @@ static av_always_inline void idct(uint8_t *dst, int stride,
     }
 }
 
-static void vp3_idct_put_c(uint8_t *dest /* align 8 */, int line_size,
+static void vp3_idct_put_c(uint8_t *dest /* align 8 */, ptrdiff_t stride,
                            int16_t *block /* align 16 */)
 {
-    idct(dest, line_size, block, 1);
+    idct(dest, stride, block, 1);
     memset(block, 0, sizeof(*block) * 64);
 }
 
-static void vp3_idct_add_c(uint8_t *dest /* align 8 */, int line_size,
+static void vp3_idct_add_c(uint8_t *dest /* align 8 */, ptrdiff_t stride,
                            int16_t *block /* align 16 */)
 {
-    idct(dest, line_size, block, 2);
+    idct(dest, stride, block, 2);
     memset(block, 0, sizeof(*block) * 64);
 }
 
-static void vp3_idct_dc_add_c(uint8_t *dest /* align 8 */, int line_size,
+static void vp3_idct_dc_add_c(uint8_t *dest /* align 8 */, ptrdiff_t stride,
                               int16_t *block /* align 16 */)
 {
     int i, dc = (block[0] + 15) >> 5;
@@ -222,17 +222,17 @@ static void vp3_idct_dc_add_c(uint8_t *dest /* align 8 */, int line_size,
         dest[5] = av_clip_uint8(dest[5] + dc);
         dest[6] = av_clip_uint8(dest[6] + dc);
         dest[7] = av_clip_uint8(dest[7] + dc);
-        dest   += line_size;
+        dest   += stride;
     }
     block[0] = 0;
 }
 
-static void vp3_v_loop_filter_c(uint8_t *first_pixel, int stride,
+static void vp3_v_loop_filter_c(uint8_t *first_pixel, ptrdiff_t stride,
                                 int *bounding_values)
 {
     unsigned char *end;
     int filter_value;
-    const int nstride = -stride;
+    const ptrdiff_t nstride = -stride;
 
     for (end = first_pixel + 8; first_pixel < end; first_pixel++) {
         filter_value = (first_pixel[2 * nstride] - first_pixel[stride]) +
@@ -244,7 +244,7 @@ static void vp3_v_loop_filter_c(uint8_t *first_pixel, int stride,
     }
 }
 
-static void vp3_h_loop_filter_c(uint8_t *first_pixel, int stride,
+static void vp3_h_loop_filter_c(uint8_t *first_pixel, ptrdiff_t stride,
                                 int *bounding_values)
 {
     unsigned char *end;
diff --git a/mythtv/external/FFmpeg/libavcodec/vp3dsp.h b/mythtv/external/FFmpeg/libavcodec/vp3dsp.h
index b95adae79e1..2fdad162caa 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp3dsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/vp3dsp.h
@@ -38,11 +38,11 @@ typedef struct VP3DSPContext {
                                  const uint8_t *b,
                                  ptrdiff_t stride, int h);
 
-    void (*idct_put)(uint8_t *dest, int line_size, int16_t *block);
-    void (*idct_add)(uint8_t *dest, int line_size, int16_t *block);
-    void (*idct_dc_add)(uint8_t *dest, int line_size, int16_t *block);
-    void (*v_loop_filter)(uint8_t *src, int stride, int *bounding_values);
-    void (*h_loop_filter)(uint8_t *src, int stride, int *bounding_values);
+    void (*idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+    void (*idct_add)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+    void (*idct_dc_add)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+    void (*v_loop_filter)(uint8_t *src, ptrdiff_t stride, int *bounding_values);
+    void (*h_loop_filter)(uint8_t *src, ptrdiff_t stride, int *bounding_values);
 } VP3DSPContext;
 
 void ff_vp3dsp_init(VP3DSPContext *c, int flags);
diff --git a/mythtv/external/FFmpeg/libavcodec/vp5.c b/mythtv/external/FFmpeg/libavcodec/vp5.c
index 6c664c66933..cb08cec33f5 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp5.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp5.c
@@ -38,8 +38,11 @@ static int vp5_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
 {
     VP56RangeCoder *c = &s->c;
     int rows, cols;
+    int ret;
 
-    ff_vp56_init_range_decoder(&s->c, buf, buf_size);
+    ret = ff_vp56_init_range_decoder(&s->c, buf, buf_size);
+    if (ret < 0)
+        return ret;
     s->frames[VP56_FRAME_CURRENT]->key_frame = !vp56_rac_get(c);
     vp56_rac_get(c);
     ff_vp56_init_dequant(s, vp56_rac_gets(c, 6));
@@ -50,7 +53,7 @@ static int vp5_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
             return AVERROR_INVALIDDATA;
         vp56_rac_gets(c, 2);
         if (vp56_rac_get(c)) {
-            av_log(s->avctx, AV_LOG_ERROR, "interlacing not supported\n");
+            avpriv_report_missing_feature(s->avctx, "Interlacing");
             return AVERROR_PATCHWELCOME;
         }
         rows = vp56_rac_gets(c, 8);  /* number of stored macroblock rows */
@@ -170,7 +173,7 @@ static int vp5_parse_coeff_models(VP56Context *s)
     return 0;
 }
 
-static void vp5_parse_coeff(VP56Context *s)
+static int vp5_parse_coeff(VP56Context *s)
 {
     VP56RangeCoder *c = &s->c;
     VP56Model *model = s->modelp;
@@ -180,6 +183,11 @@ static void vp5_parse_coeff(VP56Context *s)
     int b, i, cg, idx, ctx, ctx_last;
     int pt = 0;    /* plane type (0 for Y, 1 for U or V) */
 
+    if (c->end <= c->buffer && c->bits >= 0) {
+        av_log(s->avctx, AV_LOG_ERROR, "End of AC stream reached in vp5_parse_coeff\n");
+        return AVERROR_INVALIDDATA;
+    }
+
     for (b=0; b<6; b++) {
         int ct = 1;    /* code type */
 
@@ -245,6 +253,7 @@ static void vp5_parse_coeff(VP56Context *s)
                 s->coeff_ctx[ff_vp56_b6to4[b]][i] = 5;
         s->above_blocks[s->above_block_idx[b]].not_null_dc = s->coeff_ctx[ff_vp56_b6to4[b]][0];
     }
+    return 0;
 }
 
 static void vp5_default_models_init(VP56Context *s)
@@ -269,6 +278,7 @@ static av_cold int vp5_decode_init(AVCodecContext *avctx)
 
     if ((ret = ff_vp56_init(avctx, 1, 0)) < 0)
         return ret;
+    ff_vp5dsp_init(&s->vp56dsp);
     s->vp56_coord_div = vp5_coord_div;
     s->parse_vector_adjustment = vp5_parse_vector_adjustment;
     s->parse_coeff = vp5_parse_coeff;
diff --git a/mythtv/external/FFmpeg/libavcodec/vp56.c b/mythtv/external/FFmpeg/libavcodec/vp56.c
index 631924828d6..b69fe6c176d 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp56.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp56.c
@@ -261,6 +261,25 @@ static VP56mb vp56_decode_mv(VP56Context *s, int row, int col)
     return s->mb_type;
 }
 
+static VP56mb vp56_conceal_mv(VP56Context *s, int row, int col)
+{
+    VP56mv *mv, vect = {0,0};
+    int b;
+
+    s->mb_type = VP56_MB_INTER_NOVEC_PF;
+    s->macroblocks[row * s->mb_width + col].type = s->mb_type;
+
+    mv = &vect;
+
+    s->macroblocks[row*s->mb_width + col].mv = *mv;
+
+    /* same vector for all blocks */
+    for (b=0; b<6; b++)
+        s->mv[b] = *mv;
+
+    return s->mb_type;
+}
+
 static void vp56_add_predictors_dc(VP56Context *s, VP56Frame ref_frame)
 {
     int idx = s->idct_scantable[0];
@@ -381,20 +400,11 @@ static void vp56_mc(VP56Context *s, int b, int plane, uint8_t *src,
     }
 }
 
-static void vp56_decode_mb(VP56Context *s, int row, int col, int is_alpha)
+static av_always_inline void vp56_render_mb(VP56Context *s, int row, int col, int is_alpha, VP56mb mb_type)
 {
-    AVFrame *frame_current, *frame_ref;
-    VP56mb mb_type;
-    VP56Frame ref_frame;
     int b, ab, b_max, plane, off;
-
-    if (s->frames[VP56_FRAME_CURRENT]->key_frame)
-        mb_type = VP56_MB_INTRA;
-    else
-        mb_type = vp56_decode_mv(s, row, col);
-    ref_frame = ff_vp56_reference_frame[mb_type];
-
-    s->parse_coeff(s);
+    AVFrame *frame_current, *frame_ref;
+    VP56Frame ref_frame = ff_vp56_reference_frame[mb_type];
 
     vp56_add_predictors_dc(s, ref_frame);
 
@@ -453,6 +463,39 @@ static void vp56_decode_mb(VP56Context *s, int row, int col, int is_alpha)
     }
 }
 
+static int vp56_decode_mb(VP56Context *s, int row, int col, int is_alpha)
+{
+    VP56mb mb_type;
+    int ret;
+
+    if (s->frames[VP56_FRAME_CURRENT]->key_frame)
+        mb_type = VP56_MB_INTRA;
+    else
+        mb_type = vp56_decode_mv(s, row, col);
+
+    ret = s->parse_coeff(s);
+    if (ret < 0)
+        return ret;
+
+    vp56_render_mb(s, row, col, is_alpha, mb_type);
+
+    return 0;
+}
+
+static int vp56_conceal_mb(VP56Context *s, int row, int col, int is_alpha)
+{
+    VP56mb mb_type;
+
+    if (s->frames[VP56_FRAME_CURRENT]->key_frame)
+        mb_type = VP56_MB_INTRA;
+    else
+        mb_type = vp56_conceal_mv(s, row, col);
+
+    vp56_render_mb(s, row, col, is_alpha, mb_type);
+
+    return 0;
+}
+
 static int vp56_size_changed(VP56Context *s)
 {
     AVCodecContext *avctx = s->avctx;
@@ -464,6 +507,8 @@ static int vp56_size_changed(VP56Context *s)
     s->plane_height[0] = s->plane_height[3] = avctx->coded_height;
     s->plane_height[1] = s->plane_height[2] = avctx->coded_height/2;
 
+    s->have_undamaged_frame = 0;
+
     for (i=0; i<4; i++)
         s->stride[i] = s->flip * s->frames[VP56_FRAME_CURRENT]->linesize[i];
 
@@ -529,13 +574,18 @@ int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     }
 
     ret = ff_get_buffer(avctx, p, AV_GET_BUFFER_FLAG_REF);
-    if (ret < 0)
+    if (ret < 0) {
+        if (res == VP56_SIZE_CHANGE)
+            ff_set_dimensions(avctx, 0, 0);
         return ret;
+    }
 
     if (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) {
         av_frame_unref(s->alpha_context->frames[VP56_FRAME_CURRENT]);
         if ((ret = av_frame_ref(s->alpha_context->frames[VP56_FRAME_CURRENT], p)) < 0) {
             av_frame_unref(p);
+            if (res == VP56_SIZE_CHANGE)
+                ff_set_dimensions(avctx, 0, 0);
             return ret;
         }
     }
@@ -569,8 +619,12 @@ int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
         }
     }
 
+    s->discard_frame = 0;
     avctx->execute2(avctx, ff_vp56_decode_mbs, 0, 0, (avctx->pix_fmt == AV_PIX_FMT_YUVA420P) + 1);
 
+    if (s->discard_frame)
+        return AVERROR_INVALIDDATA;
+
     if ((res = av_frame_ref(data, p)) < 0)
         return res;
     *got_frame = 1;
@@ -589,6 +643,7 @@ static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *data,
     int block, y, uv;
     ptrdiff_t stride_y, stride_uv;
     int res;
+    int damaged = 0;
 
     if (p->key_frame) {
         p->pict_type = AV_PICTURE_TYPE_I;
@@ -653,7 +708,18 @@ static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *data,
         s->block_offset[5] = s->block_offset[4];
 
         for (mb_col=0; mb_col<s->mb_width; mb_col++) {
-            vp56_decode_mb(s, mb_row, mb_col, is_alpha);
+            if (!damaged) {
+                int ret = vp56_decode_mb(s, mb_row, mb_col, is_alpha);
+                if (ret < 0) {
+                    damaged = 1;
+                    if (!s->have_undamaged_frame || !avctx->error_concealment) {
+                        s->discard_frame = 1;
+                        return AVERROR_INVALIDDATA;
+                    }
+                }
+            }
+            if (damaged)
+                vp56_conceal_mb(s, mb_row, mb_col, is_alpha);
 
             for (y=0; y<4; y++) {
                 s->above_block_idx[y] += 2;
@@ -667,6 +733,9 @@ static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *data,
         }
     }
 
+    if (!damaged)
+        s->have_undamaged_frame = 1;
+
 next:
     if (p->key_frame || s->golden_frame) {
         av_frame_unref(s->frames[VP56_FRAME_GOLDEN]);
@@ -699,7 +768,6 @@ av_cold int ff_vp56_init_context(AVCodecContext *avctx, VP56Context *s,
     ff_hpeldsp_init(&s->hdsp, avctx->flags);
     ff_videodsp_init(&s->vdsp, 8);
     ff_vp3dsp_init(&s->vp3dsp, avctx->flags);
-    ff_vp56dsp_init(&s->vp56dsp, avctx->codec->id);
     for (i = 0; i < 64; i++) {
 #define TRANSPOSE(x) (((x) >> 3) | (((x) & 7) << 3))
         s->idct_scantable[i] = TRANSPOSE(ff_zigzag_direct[i]);
diff --git a/mythtv/external/FFmpeg/libavcodec/vp56.h b/mythtv/external/FFmpeg/libavcodec/vp56.h
index 56c30919b7d..b8dda9e73a5 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp56.h
+++ b/mythtv/external/FFmpeg/libavcodec/vp56.h
@@ -26,6 +26,7 @@
 #ifndef AVCODEC_VP56_H
 #define AVCODEC_VP56_H
 
+#include "avcodec.h"
 #include "get_bits.h"
 #include "hpeldsp.h"
 #include "bytestream.h"
@@ -72,9 +73,9 @@ typedef struct VP56mv {
 typedef void (*VP56ParseVectorAdjustment)(VP56Context *s,
                                           VP56mv *vect);
 typedef void (*VP56Filter)(VP56Context *s, uint8_t *dst, uint8_t *src,
-                           int offset1, int offset2, int stride,
+                           int offset1, int offset2, ptrdiff_t stride,
                            VP56mv mv, int mask, int select, int luma);
-typedef void (*VP56ParseCoeff)(VP56Context *s);
+typedef int  (*VP56ParseCoeff)(VP56Context *s);
 typedef void (*VP56DefaultModelsInit)(VP56Context *s);
 typedef void (*VP56ParseVectorModels)(VP56Context *s);
 typedef int  (*VP56ParseCoeffModels)(VP56Context *s);
@@ -179,7 +180,7 @@ struct vp56_context {
     int flip;  /* are we flipping ? */
     int frbi;  /* first row block index in MB */
     int srbi;  /* second row block index in MB */
-    int stride[4];  /* stride for each plan */
+    ptrdiff_t stride[4];  /* stride for each plan */
 
     const uint8_t *vp56_coord_div;
     VP56ParseVectorAdjustment parse_vector_adjustment;
@@ -203,6 +204,9 @@ struct vp56_context {
     VLC runv_vlc[2];
     VLC ract_vlc[2][3][6];
     unsigned int nb_null[2][2];       /* number of consecutive NULL DC/AC */
+
+    int have_undamaged_frame;
+    int discard_frame;
 };
 
 
@@ -221,7 +225,7 @@ int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
  */
 
 extern const uint8_t ff_vp56_norm_shift[256];
-void ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size);
+int ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size);
 
 static av_always_inline unsigned int vp56_rac_renorm(VP56RangeCoder *c)
 {
diff --git a/mythtv/external/FFmpeg/libavcodec/vp56dsp.c b/mythtv/external/FFmpeg/libavcodec/vp56dsp.c
index fa533ec5c90..9f299dc60f2 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp56dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp56dsp.c
@@ -26,6 +26,23 @@
 #include "vp56dsp.h"
 #include "libavutil/common.h"
 
+#define VP56_EDGE_FILTER(pfx, suf, pix_inc, line_inc)                   \
+static void pfx ## _edge_filter_ ## suf(uint8_t *yuv, ptrdiff_t stride, \
+                                        int t)                          \
+{                                                                       \
+    int pix2_inc = 2 * pix_inc;                                         \
+    int i, v;                                                           \
+                                                                        \
+    for (i=0; i<12; i++) {                                              \
+        v = (yuv[-pix2_inc] + 3*(yuv[0]-yuv[-pix_inc]) - yuv[pix_inc] + 4)>>3;\
+        v = pfx##_adjust(v, t);                                         \
+        yuv[-pix_inc] = av_clip_uint8(yuv[-pix_inc] + v);               \
+        yuv[0] = av_clip_uint8(yuv[0] - v);                             \
+        yuv += line_inc;                                                \
+    }                                                                   \
+}
+
+#if CONFIG_VP5_DECODER
 /* Gives very similar result than the vp6 version except in a few cases */
 static int vp5_adjust(int v, int t)
 {
@@ -43,6 +60,18 @@ static int vp5_adjust(int v, int t)
     return v;
 }
 
+
+VP56_EDGE_FILTER(vp5, hor, 1, stride)
+VP56_EDGE_FILTER(vp5, ver, stride, 1)
+
+av_cold void ff_vp5dsp_init(VP56DSPContext *s)
+{
+    s->edge_filter_hor = vp5_edge_filter_hor;
+    s->edge_filter_ver = vp5_edge_filter_ver;
+}
+#endif /* CONFIG_VP5_DECODER */
+
+#if CONFIG_VP6_DECODER
 static int vp6_adjust(int v, int t)
 {
     int V = v, s = v >> 31;
@@ -56,43 +85,19 @@ static int vp6_adjust(int v, int t)
     return V;
 }
 
-
-#define VP56_EDGE_FILTER(pfx, suf, pix_inc, line_inc)                   \
-static void pfx##_edge_filter_##suf(uint8_t *yuv, int stride, int t)    \
-{                                                                       \
-    int pix2_inc = 2 * pix_inc;                                         \
-    int i, v;                                                           \
-                                                                        \
-    for (i=0; i<12; i++) {                                              \
-        v = (yuv[-pix2_inc] + 3*(yuv[0]-yuv[-pix_inc]) - yuv[pix_inc] + 4)>>3;\
-        v = pfx##_adjust(v, t);                                         \
-        yuv[-pix_inc] = av_clip_uint8(yuv[-pix_inc] + v);               \
-        yuv[0] = av_clip_uint8(yuv[0] - v);                             \
-        yuv += line_inc;                                                \
-    }                                                                   \
-}
-
-VP56_EDGE_FILTER(vp5, hor, 1, stride)
-VP56_EDGE_FILTER(vp5, ver, stride, 1)
 VP56_EDGE_FILTER(vp6, hor, 1, stride)
 VP56_EDGE_FILTER(vp6, ver, stride, 1)
 
-av_cold void ff_vp56dsp_init(VP56DSPContext *s, enum AVCodecID codec)
+av_cold void ff_vp6dsp_init(VP56DSPContext *s)
 {
-    if (codec == AV_CODEC_ID_VP5) {
-        s->edge_filter_hor = vp5_edge_filter_hor;
-        s->edge_filter_ver = vp5_edge_filter_ver;
-    } else {
-        s->edge_filter_hor = vp6_edge_filter_hor;
-        s->edge_filter_ver = vp6_edge_filter_ver;
+    s->edge_filter_hor = vp6_edge_filter_hor;
+    s->edge_filter_ver = vp6_edge_filter_ver;
 
-        if (CONFIG_VP6_DECODER) {
-            s->vp6_filter_diag4 = ff_vp6_filter_diag4_c;
+    s->vp6_filter_diag4 = ff_vp6_filter_diag4_c;
 
-            if (ARCH_ARM)
-                ff_vp6dsp_init_arm(s, codec);
-            if (ARCH_X86)
-                ff_vp6dsp_init_x86(s, codec);
-        }
-    }
+    if (ARCH_ARM)
+        ff_vp6dsp_init_arm(s);
+    if (ARCH_X86)
+        ff_vp6dsp_init_x86(s);
 }
+#endif /* CONFIG_VP6_DECODER */
diff --git a/mythtv/external/FFmpeg/libavcodec/vp56dsp.h b/mythtv/external/FFmpeg/libavcodec/vp56dsp.h
index 7807baa4b17..e35e232ea35 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp56dsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/vp56dsp.h
@@ -21,22 +21,24 @@
 #ifndef AVCODEC_VP56DSP_H
 #define AVCODEC_VP56DSP_H
 
+#include <stddef.h>
 #include <stdint.h>
-#include "avcodec.h"
 
 typedef struct VP56DSPContext {
-    void (*edge_filter_hor)(uint8_t *yuv, int stride, int t);
-    void (*edge_filter_ver)(uint8_t *yuv, int stride, int t);
+    void (*edge_filter_hor)(uint8_t *yuv, ptrdiff_t stride, int t);
+    void (*edge_filter_ver)(uint8_t *yuv, ptrdiff_t stride, int t);
 
-    void (*vp6_filter_diag4)(uint8_t *dst, uint8_t *src, int stride,
+    void (*vp6_filter_diag4)(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                              const int16_t *h_weights,const int16_t *v_weights);
 } VP56DSPContext;
 
-void ff_vp6_filter_diag4_c(uint8_t *dst, uint8_t *src, int stride,
+void ff_vp6_filter_diag4_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                            const int16_t *h_weights, const int16_t *v_weights);
 
-void ff_vp56dsp_init(VP56DSPContext *s, enum AVCodecID codec);
-void ff_vp6dsp_init_arm(VP56DSPContext *s, enum AVCodecID codec);
-void ff_vp6dsp_init_x86(VP56DSPContext* c, enum AVCodecID codec);
+void ff_vp5dsp_init(VP56DSPContext *s);
+void ff_vp6dsp_init(VP56DSPContext *s);
+
+void ff_vp6dsp_init_arm(VP56DSPContext *s);
+void ff_vp6dsp_init_x86(VP56DSPContext *s);
 
 #endif /* AVCODEC_VP56DSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vp56rac.c b/mythtv/external/FFmpeg/libavcodec/vp56rac.c
index 6061b7ee72c..e70302bf856 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp56rac.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp56rac.c
@@ -37,11 +37,14 @@ const uint8_t ff_vp56_norm_shift[256]= {
  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 };
 
-void ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size)
+int ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size)
 {
     c->high = 255;
     c->bits = -16;
     c->buffer = buf;
     c->end = buf + buf_size;
+    if (buf_size < 1)
+        return AVERROR_INVALIDDATA;
     c->code_word = bytestream_get_be24(&c->buffer);
+    return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/vp6.c b/mythtv/external/FFmpeg/libavcodec/vp6.c
index a2bb4578d5f..645fc5c690e 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp6.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp6.c
@@ -40,8 +40,8 @@
 
 #define VP6_MAX_HUFF_SIZE 12
 
-static void vp6_parse_coeff(VP56Context *s);
-static void vp6_parse_coeff_huffman(VP56Context *s);
+static int vp6_parse_coeff(VP56Context *s);
+static int vp6_parse_coeff_huffman(VP56Context *s);
 
 static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
 {
@@ -52,6 +52,7 @@ static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
     int sub_version;
     int rows, cols;
     int res = 0;
+    int ret;
     int separated_coeff = buf[0] & 1;
 
     s->frames[VP56_FRAME_CURRENT]->key_frame = !(buf[0] & 0x80);
@@ -93,7 +94,7 @@ static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
                 s->avctx->coded_width  = 16 * cols;
                 s->avctx->coded_height = 16 * rows;
             } else {
-                int ret = ff_set_dimensions(s->avctx, 16 * cols, 16 * rows);
+                ret = ff_set_dimensions(s->avctx, 16 * cols, 16 * rows);
                 if (ret < 0)
                     return ret;
 
@@ -105,7 +106,9 @@ static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
             res = VP56_SIZE_CHANGE;
         }
 
-        ff_vp56_init_range_decoder(c, buf+6, buf_size-6);
+        ret = ff_vp56_init_range_decoder(c, buf+6, buf_size-6);
+        if (ret < 0)
+            goto fail;
         vp56_rac_gets(c, 2);
 
         parse_filter_info = s->filter_header;
@@ -122,7 +125,9 @@ static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
             buf += 2;
             buf_size -= 2;
         }
-        ff_vp56_init_range_decoder(c, buf+1, buf_size-1);
+        ret = ff_vp56_init_range_decoder(c, buf+1, buf_size-1);
+        if (ret < 0)
+            return ret;
 
         s->golden_frame = vp56_rac_get(c);
         if (s->filter_header) {
@@ -157,15 +162,16 @@ static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
         buf      += coeff_offset;
         buf_size -= coeff_offset;
         if (buf_size < 0) {
-            if (s->frames[VP56_FRAME_CURRENT]->key_frame)
-                ff_set_dimensions(s->avctx, 0, 0);
-            return AVERROR_INVALIDDATA;
+            ret = AVERROR_INVALIDDATA;
+            goto fail;
         }
         if (s->use_huffman) {
             s->parse_coeff = vp6_parse_coeff_huffman;
             init_get_bits(&s->gb, buf, buf_size<<3);
         } else {
-            ff_vp56_init_range_decoder(&s->cc, buf, buf_size);
+            ret = ff_vp56_init_range_decoder(&s->cc, buf, buf_size);
+            if (ret < 0)
+                goto fail;
             s->ccp = &s->cc;
         }
     } else {
@@ -173,6 +179,10 @@ static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
     }
 
     return res;
+fail:
+    if (res == VP56_SIZE_CHANGE)
+        ff_set_dimensions(s->avctx, 0, 0);
+    return ret;
 }
 
 static void vp6_coeff_order_table_init(VP56Context *s)
@@ -380,7 +390,7 @@ static unsigned vp6_get_nb_null(VP56Context *s)
     return val;
 }
 
-static void vp6_parse_coeff_huffman(VP56Context *s)
+static int vp6_parse_coeff_huffman(VP56Context *s)
 {
     VP56Model *model = s->modelp;
     uint8_t *permute = s->idct_scantable;
@@ -402,7 +412,7 @@ static void vp6_parse_coeff_huffman(VP56Context *s)
                     break;
             } else {
                 if (get_bits_left(&s->gb) <= 0)
-                    return;
+                    return AVERROR_INVALIDDATA;
                 coeff = get_vlc2(&s->gb, vlc_coeff->table, FF_HUFFMAN_BITS, 3);
                 if (coeff == 0) {
                     if (coeff_idx) {
@@ -437,9 +447,10 @@ static void vp6_parse_coeff_huffman(VP56Context *s)
             vlc_coeff = &s->ract_vlc[pt][ct][cg];
         }
     }
+    return 0;
 }
 
-static void vp6_parse_coeff(VP56Context *s)
+static int vp6_parse_coeff(VP56Context *s)
 {
     VP56RangeCoder *c = s->ccp;
     VP56Model *model = s->modelp;
@@ -449,6 +460,11 @@ static void vp6_parse_coeff(VP56Context *s)
     int b, i, cg, idx, ctx;
     int pt = 0;    /* plane type (0 for Y, 1 for U or V) */
 
+    if (c->end <= c->buffer && c->bits >= 0) {
+        av_log(s->avctx, AV_LOG_ERROR, "End of AC stream reached in vp6_parse_coeff\n");
+        return AVERROR_INVALIDDATA;
+    }
+
     for (b=0; b<6; b++) {
         int ct = 1;    /* code type */
         int run = 1;
@@ -512,9 +528,10 @@ static void vp6_parse_coeff(VP56Context *s)
         s->left_block[ff_vp56_b6to4[b]].not_null_dc =
         s->above_blocks[s->above_block_idx[b]].not_null_dc = !!s->block_coeff[b][0];
     }
+    return 0;
 }
 
-static int vp6_block_variance(uint8_t *src, int stride)
+static int vp6_block_variance(uint8_t *src, ptrdiff_t stride)
 {
     int sum = 0, square_sum = 0;
     int y, x;
@@ -529,7 +546,7 @@ static int vp6_block_variance(uint8_t *src, int stride)
     return (16*square_sum - sum*sum) >> 8;
 }
 
-static void vp6_filter_hv4(uint8_t *dst, uint8_t *src, int stride,
+static void vp6_filter_hv4(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                            int delta, const int16_t *weights)
 {
     int x, y;
@@ -547,7 +564,7 @@ static void vp6_filter_hv4(uint8_t *dst, uint8_t *src, int stride,
 }
 
 static void vp6_filter_diag2(VP56Context *s, uint8_t *dst, uint8_t *src,
-                             int stride, int h_weight, int v_weight)
+                             ptrdiff_t stride, int h_weight, int v_weight)
 {
     uint8_t *tmp = s->edge_emu_buffer+16;
     s->h264chroma.put_h264_chroma_pixels_tab[0](tmp, src, stride, 9, h_weight, 0);
@@ -555,7 +572,7 @@ static void vp6_filter_diag2(VP56Context *s, uint8_t *dst, uint8_t *src,
 }
 
 static void vp6_filter(VP56Context *s, uint8_t *dst, uint8_t *src,
-                       int offset1, int offset2, int stride,
+                       int offset1, int offset2, ptrdiff_t stride,
                        VP56mv mv, int mask, int select, int luma)
 {
     int filter4 = 0;
@@ -614,6 +631,7 @@ static av_cold int vp6_decode_init(AVCodecContext *avctx)
     if ((ret = ff_vp56_init(avctx, avctx->codec->id == AV_CODEC_ID_VP6,
                             avctx->codec->id == AV_CODEC_ID_VP6A)) < 0)
         return ret;
+    ff_vp6dsp_init(&s->vp56dsp);
 
     vp6_decode_init_context(s);
 
@@ -621,6 +639,7 @@ static av_cold int vp6_decode_init(AVCodecContext *avctx)
         s->alpha_context = av_mallocz(sizeof(VP56Context));
         ff_vp56_init_context(avctx, s->alpha_context,
                              s->flip == -1, s->has_alpha);
+        ff_vp6dsp_init(&s->alpha_context->vp56dsp);
         vp6_decode_init_context(s->alpha_context);
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/vp6dsp.c b/mythtv/external/FFmpeg/libavcodec/vp6dsp.c
index 67c6be07ded..f7f6856330c 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp6dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp6dsp.c
@@ -27,7 +27,7 @@
 #include "vp56dsp.h"
 
 
-void ff_vp6_filter_diag4_c(uint8_t *dst, uint8_t *src, int stride,
+void ff_vp6_filter_diag4_c(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                            const int16_t *h_weights, const int16_t *v_weights)
 {
     int x, y;
diff --git a/mythtv/external/FFmpeg/libavcodec/vp8.c b/mythtv/external/FFmpeg/libavcodec/vp8.c
index c1c3eb70724..7841a9d964e 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp8.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp8.c
@@ -261,6 +261,7 @@ static int setup_partitions(VP8Context *s, const uint8_t *buf, int buf_size)
 {
     const uint8_t *sizes = buf;
     int i;
+    int ret;
 
     s->num_coeff_partitions = 1 << vp8_rac_get_uint(&s->c, 2);
 
@@ -274,13 +275,13 @@ static int setup_partitions(VP8Context *s, const uint8_t *buf, int buf_size)
         if (buf_size - size < 0)
             return -1;
 
-        ff_vp56_init_range_decoder(&s->coeff_partition[i], buf, size);
+        ret = ff_vp56_init_range_decoder(&s->coeff_partition[i], buf, size);
+        if (ret < 0)
+            return ret;
         buf      += size;
         buf_size -= size;
     }
-    ff_vp56_init_range_decoder(&s->coeff_partition[i], buf, buf_size);
-
-    return 0;
+    return ff_vp56_init_range_decoder(&s->coeff_partition[i], buf, buf_size);
 }
 
 static void vp7_get_quants(VP8Context *s)
@@ -434,8 +435,8 @@ static void copy_chroma(AVFrame *dst, AVFrame *src, int width, int height)
     }
 }
 
-static void fade(uint8_t *dst, int dst_linesize,
-                 const uint8_t *src, int src_linesize,
+static void fade(uint8_t *dst, ptrdiff_t dst_linesize,
+                 const uint8_t *src, ptrdiff_t src_linesize,
                  int width, int height,
                  int alpha, int beta)
 {
@@ -518,7 +519,9 @@ static int vp7_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_si
 
     memcpy(s->put_pixels_tab, s->vp8dsp.put_vp8_epel_pixels_tab, sizeof(s->put_pixels_tab));
 
-    ff_vp56_init_range_decoder(c, buf, part1_size);
+    ret = ff_vp56_init_range_decoder(c, buf, part1_size);
+    if (ret < 0)
+        return ret;
     buf      += part1_size;
     buf_size -= part1_size;
 
@@ -570,7 +573,9 @@ static int vp7_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_si
     s->lf_delta.enabled        = 0;
 
     s->num_coeff_partitions = 1;
-    ff_vp56_init_range_decoder(&s->coeff_partition[0], buf, buf_size);
+    ret = ff_vp56_init_range_decoder(&s->coeff_partition[0], buf, buf_size);
+    if (ret < 0)
+        return ret;
 
     if (!s->macroblocks_base || /* first frame */
         width != s->avctx->width || height != s->avctx->height ||
@@ -699,7 +704,9 @@ static int vp8_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_si
         memset(&s->lf_delta, 0, sizeof(s->lf_delta));
     }
 
-    ff_vp56_init_range_decoder(c, buf, header_size);
+    ret = ff_vp56_init_range_decoder(c, buf, header_size);
+    if (ret < 0)
+        return ret;
     buf      += header_size;
     buf_size -= header_size;
 
@@ -765,7 +772,7 @@ static int vp8_decode_frame_header(VP8Context *s, const uint8_t *buf, int buf_si
 }
 
 static av_always_inline
-void clamp_mv(VP8Context *s, VP56mv *dst, const VP56mv *src)
+void clamp_mv(VP8mvbounds *s, VP56mv *dst, const VP56mv *src)
 {
     dst->x = av_clip(src->x, av_clip(s->mv_min.x, INT16_MIN, INT16_MAX),
                              av_clip(s->mv_max.x, INT16_MIN, INT16_MAX));
@@ -1024,7 +1031,7 @@ void vp7_decode_mvs(VP8Context *s, VP8Macroblock *mb,
 }
 
 static av_always_inline
-void vp8_decode_mvs(VP8Context *s, VP8Macroblock *mb,
+void vp8_decode_mvs(VP8Context *s, VP8mvbounds *mv_bounds, VP8Macroblock *mb,
                     int mb_x, int mb_y, int layout)
 {
     VP8Macroblock *mb_edge[3] = { 0      /* top */,
@@ -1095,7 +1102,7 @@ void vp8_decode_mvs(VP8Context *s, VP8Macroblock *mb,
         if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAREST]][1])) {
             if (vp56_rac_get_prob_branchy(c, vp8_mode_contexts[cnt[CNT_NEAR]][2])) {
                 /* Choose the best mv out of 0,0 and the nearest mv */
-                clamp_mv(s, &mb->mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])]);
+                clamp_mv(mv_bounds, &mb->mv, &near_mv[CNT_ZERO + (cnt[CNT_NEAREST] >= cnt[CNT_ZERO])]);
                 cnt[CNT_SPLITMV] = ((mb_edge[VP8_EDGE_LEFT]->mode    == VP8_MVMODE_SPLIT) +
                                     (mb_edge[VP8_EDGE_TOP]->mode     == VP8_MVMODE_SPLIT)) * 2 +
                                     (mb_edge[VP8_EDGE_TOPLEFT]->mode == VP8_MVMODE_SPLIT);
@@ -1109,11 +1116,11 @@ void vp8_decode_mvs(VP8Context *s, VP8Macroblock *mb,
                     mb->bmv[0] = mb->mv;
                 }
             } else {
-                clamp_mv(s, &mb->mv, &near_mv[CNT_NEAR]);
+                clamp_mv(mv_bounds, &mb->mv, &near_mv[CNT_NEAR]);
                 mb->bmv[0] = mb->mv;
             }
         } else {
-            clamp_mv(s, &mb->mv, &near_mv[CNT_NEAREST]);
+            clamp_mv(mv_bounds, &mb->mv, &near_mv[CNT_NEAREST]);
             mb->bmv[0] = mb->mv;
         }
     } else {
@@ -1159,14 +1166,15 @@ void decode_intra4x4_modes(VP8Context *s, VP56RangeCoder *c, VP8Macroblock *mb,
 }
 
 static av_always_inline
-void decode_mb_mode(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y,
+void decode_mb_mode(VP8Context *s, VP8mvbounds *mv_bounds,
+                    VP8Macroblock *mb, int mb_x, int mb_y,
                     uint8_t *segment, uint8_t *ref, int layout, int is_vp7)
 {
     VP56RangeCoder *c = &s->c;
-    static const char *vp7_feature_name[] = { "q-index",
-                                              "lf-delta",
-                                              "partial-golden-update",
-                                              "blit-pitch" };
+    static const char * const vp7_feature_name[] = { "q-index",
+                                                     "lf-delta",
+                                                     "partial-golden-update",
+                                                     "blit-pitch" };
     if (is_vp7) {
         int i;
         *segment = 0;
@@ -1223,7 +1231,7 @@ void decode_mb_mode(VP8Context *s, VP8Macroblock *mb, int mb_x, int mb_y,
         if (is_vp7)
             vp7_decode_mvs(s, mb, mb_x, mb_y, layout);
         else
-            vp8_decode_mvs(s, mb, mb_x, mb_y, layout);
+            vp8_decode_mvs(s, mv_bounds, mb, mb_x, mb_y, layout);
     } else {
         // intra MB, 16.1
         mb->mode = vp8_rac_get_tree(c, vp8_pred16x16_tree_inter, s->prob->pred16x16);
@@ -1461,7 +1469,7 @@ void decode_mb_coeffs(VP8Context *s, VP8ThreadData *td, VP56RangeCoder *c,
 static av_always_inline
 void backup_mb_border(uint8_t *top_border, uint8_t *src_y,
                       uint8_t *src_cb, uint8_t *src_cr,
-                      int linesize, int uvlinesize, int simple)
+                      ptrdiff_t linesize, ptrdiff_t uvlinesize, int simple)
 {
     AV_COPY128(top_border, src_y + 15 * linesize);
     if (!simple) {
@@ -1472,7 +1480,7 @@ void backup_mb_border(uint8_t *top_border, uint8_t *src_y,
 
 static av_always_inline
 void xchg_mb_border(uint8_t *top_border, uint8_t *src_y, uint8_t *src_cb,
-                    uint8_t *src_cr, int linesize, int uvlinesize, int mb_x,
+                    uint8_t *src_cr, ptrdiff_t linesize, ptrdiff_t uvlinesize, int mb_x,
                     int mb_y, int mb_width, int simple, int xchg)
 {
     uint8_t *top_border_m1 = top_border - 32;     // for TL prediction
@@ -1625,7 +1633,8 @@ void intra_predict(VP8Context *s, VP8ThreadData *td, uint8_t *dst[3],
         for (y = 0; y < 4; y++) {
             uint8_t *topright = ptr + 4 - s->linesize;
             for (x = 0; x < 4; x++) {
-                int copy = 0, linesize = s->linesize;
+                int copy = 0;
+                ptrdiff_t linesize = s->linesize;
                 uint8_t *dst = ptr + 4 * x;
                 LOCAL_ALIGNED(4, uint8_t, copy_dst, [5 * 8]);
 
@@ -1731,7 +1740,7 @@ void vp8_mc_luma(VP8Context *s, VP8ThreadData *td, uint8_t *dst,
     uint8_t *src = ref->f->data[0];
 
     if (AV_RN32A(mv)) {
-        int src_linesize = linesize;
+        ptrdiff_t src_linesize = linesize;
 
         int mx = (mv->x * 2) & 7, mx_idx = subpel_idx[0][mx];
         int my = (mv->y * 2) & 7, my_idx = subpel_idx[0][my];
@@ -2077,8 +2086,8 @@ void filter_mb(VP8Context *s, uint8_t *dst[3], VP8FilterStrength *f,
     int filter_level = f->filter_level;
     int inner_limit = f->inner_limit;
     int inner_filter = f->inner_filter;
-    int linesize = s->linesize;
-    int uvlinesize = s->uvlinesize;
+    ptrdiff_t linesize   = s->linesize;
+    ptrdiff_t uvlinesize = s->uvlinesize;
     static const uint8_t hev_thresh_lut[2][64] = {
         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@@ -2164,7 +2173,7 @@ void filter_mb_simple(VP8Context *s, uint8_t *dst, VP8FilterStrength *f,
     int filter_level = f->filter_level;
     int inner_limit  = f->inner_limit;
     int inner_filter = f->inner_filter;
-    int linesize     = s->linesize;
+    ptrdiff_t linesize = s->linesize;
 
     if (!filter_level)
         return;
@@ -2197,8 +2206,8 @@ void vp78_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *curframe,
     VP8Context *s = avctx->priv_data;
     int mb_x, mb_y;
 
-    s->mv_min.y = -MARGIN;
-    s->mv_max.y = ((s->mb_height - 1) << 6) + MARGIN;
+    s->mv_bounds.mv_min.y = -MARGIN;
+    s->mv_bounds.mv_max.y = ((s->mb_height - 1) << 6) + MARGIN;
     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
         VP8Macroblock *mb = s->macroblocks_base +
                             ((s->mb_width + 1) * (mb_y + 1) + 1);
@@ -2206,20 +2215,20 @@ void vp78_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *curframe,
 
         AV_WN32A(s->intra4x4_pred_mode_left, DC_PRED * 0x01010101);
 
-        s->mv_min.x = -MARGIN;
-        s->mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
+        s->mv_bounds.mv_min.x = -MARGIN;
+        s->mv_bounds.mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
         for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
             if (mb_y == 0)
                 AV_WN32A((mb - s->mb_width - 1)->intra4x4_pred_mode_top,
                          DC_PRED * 0x01010101);
-            decode_mb_mode(s, mb, mb_x, mb_y, curframe->seg_map->data + mb_xy,
+            decode_mb_mode(s, &s->mv_bounds, mb, mb_x, mb_y, curframe->seg_map->data + mb_xy,
                            prev_frame && prev_frame->seg_map ?
                            prev_frame->seg_map->data + mb_xy : NULL, 1, is_vp7);
-            s->mv_min.x -= 64;
-            s->mv_max.x -= 64;
+            s->mv_bounds.mv_min.x -= 64;
+            s->mv_bounds.mv_max.x -= 64;
         }
-        s->mv_min.y -= 64;
-        s->mv_max.y -= 64;
+        s->mv_bounds.mv_min.y -= 64;
+        s->mv_bounds.mv_max.y -= 64;
     }
 }
 
@@ -2239,15 +2248,15 @@ static void vp8_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *cur_frame,
 #define check_thread_pos(td, otd, mb_x_check, mb_y_check)                     \
     do {                                                                      \
         int tmp = (mb_y_check << 16) | (mb_x_check & 0xFFFF);                 \
-        if (otd->thread_mb_pos < tmp) {                                       \
+        if (atomic_load(&otd->thread_mb_pos) < tmp) {                         \
             pthread_mutex_lock(&otd->lock);                                   \
-            td->wait_mb_pos = tmp;                                            \
+            atomic_store(&td->wait_mb_pos, tmp);                              \
             do {                                                              \
-                if (otd->thread_mb_pos >= tmp)                                \
+                if (atomic_load(&otd->thread_mb_pos) >= tmp)                  \
                     break;                                                    \
                 pthread_cond_wait(&otd->cond, &otd->lock);                    \
             } while (1);                                                      \
-            td->wait_mb_pos = INT_MAX;                                        \
+            atomic_store(&td->wait_mb_pos, INT_MAX);                          \
             pthread_mutex_unlock(&otd->lock);                                 \
         }                                                                     \
     } while (0)
@@ -2258,12 +2267,10 @@ static void vp8_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *cur_frame,
         int sliced_threading = (avctx->active_thread_type == FF_THREAD_SLICE) && \
                                (num_jobs > 1);                                \
         int is_null          = !next_td || !prev_td;                          \
-        int pos_check        = (is_null) ? 1                                  \
-                                         : (next_td != td &&                  \
-                                            pos >= next_td->wait_mb_pos) ||   \
-                                           (prev_td != td &&                  \
-                                            pos >= prev_td->wait_mb_pos);     \
-        td->thread_mb_pos = pos;                                              \
+        int pos_check        = (is_null) ? 1 :                                \
+            (next_td != td && pos >= atomic_load(&next_td->wait_mb_pos)) ||   \
+            (prev_td != td && pos >= atomic_load(&prev_td->wait_mb_pos));     \
+        atomic_store(&td->thread_mb_pos, pos);                                \
         if (sliced_threading && pos_check) {                                  \
             pthread_mutex_lock(&td->lock);                                    \
             pthread_cond_broadcast(&td->cond);                                \
@@ -2275,12 +2282,12 @@ static void vp8_decode_mv_mb_modes(AVCodecContext *avctx, VP8Frame *cur_frame,
 #define update_pos(td, mb_y, mb_x) while(0)
 #endif
 
-static av_always_inline void decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
+static av_always_inline int decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
                                         int jobnr, int threadnr, int is_vp7)
 {
     VP8Context *s = avctx->priv_data;
     VP8ThreadData *prev_td, *next_td, *td = &s->thread_data[threadnr];
-    int mb_y = td->thread_mb_pos >> 16;
+    int mb_y = atomic_load(&td->thread_mb_pos) >> 16;
     int mb_x, mb_xy = mb_y * s->mb_width;
     int num_jobs = s->num_jobs;
     VP8Frame *curframe = s->curframe, *prev_frame = s->prev_frame;
@@ -2291,6 +2298,10 @@ static av_always_inline void decode_mb_row_no_filter(AVCodecContext *avctx, void
         curframe->tf.f->data[1] +  8 * mb_y * s->uvlinesize,
         curframe->tf.f->data[2] +  8 * mb_y * s->uvlinesize
     };
+
+    if (c->end <= c->buffer && c->bits >= 0)
+         return AVERROR_INVALIDDATA;
+
     if (mb_y == 0)
         prev_td = td;
     else
@@ -2315,10 +2326,12 @@ static av_always_inline void decode_mb_row_no_filter(AVCodecContext *avctx, void
     if (!is_vp7 || mb_y == 0)
         memset(td->left_nnz, 0, sizeof(td->left_nnz));
 
-    s->mv_min.x = -MARGIN;
-    s->mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
+    td->mv_bounds.mv_min.x = -MARGIN;
+    td->mv_bounds.mv_max.x = ((s->mb_width - 1) << 6) + MARGIN;
 
     for (mb_x = 0; mb_x < s->mb_width; mb_x++, mb_xy++, mb++) {
+        if (c->end <= c->buffer && c->bits >= 0)
+            return AVERROR_INVALIDDATA;
         // Wait for previous thread to read mb_x+2, and reach mb_y-1.
         if (prev_td != td) {
             if (threadnr != 0) {
@@ -2338,7 +2351,7 @@ static av_always_inline void decode_mb_row_no_filter(AVCodecContext *avctx, void
                          dst[2] - dst[1], 2);
 
         if (!s->mb_layout)
-            decode_mb_mode(s, mb, mb_x, mb_y, curframe->seg_map->data + mb_xy,
+            decode_mb_mode(s, &td->mv_bounds, mb, mb_x, mb_y, curframe->seg_map->data + mb_xy,
                            prev_frame && prev_frame->seg_map ?
                            prev_frame->seg_map->data + mb_xy : NULL, 0, is_vp7);
 
@@ -2385,8 +2398,8 @@ static av_always_inline void decode_mb_row_no_filter(AVCodecContext *avctx, void
         dst[0]      += 16;
         dst[1]      += 8;
         dst[2]      += 8;
-        s->mv_min.x -= 64;
-        s->mv_max.x -= 64;
+        td->mv_bounds.mv_min.x -= 64;
+        td->mv_bounds.mv_max.x -= 64;
 
         if (mb_x == s->mb_width + 1) {
             update_pos(td, mb_y, s->mb_width + 3);
@@ -2394,18 +2407,19 @@ static av_always_inline void decode_mb_row_no_filter(AVCodecContext *avctx, void
             update_pos(td, mb_y, mb_x);
         }
     }
+    return 0;
 }
 
-static void vp7_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
+static int vp7_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
                                         int jobnr, int threadnr)
 {
-    decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 1);
+    return decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 1);
 }
 
-static void vp8_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
+static int vp8_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
                                         int jobnr, int threadnr)
 {
-    decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 0);
+    return decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 0);
 }
 
 static av_always_inline void filter_mb_row(AVCodecContext *avctx, void *tdata,
@@ -2413,7 +2427,7 @@ static av_always_inline void filter_mb_row(AVCodecContext *avctx, void *tdata,
 {
     VP8Context *s = avctx->priv_data;
     VP8ThreadData *td = &s->thread_data[threadnr];
-    int mb_x, mb_y = td->thread_mb_pos >> 16, num_jobs = s->num_jobs;
+    int mb_x, mb_y = atomic_load(&td->thread_mb_pos) >> 16, num_jobs = s->num_jobs;
     AVFrame *curframe = s->curframe->tf.f;
     VP8Macroblock *mb;
     VP8ThreadData *prev_td, *next_td;
@@ -2488,19 +2502,24 @@ int vp78_decode_mb_row_sliced(AVCodecContext *avctx, void *tdata, int jobnr,
     VP8ThreadData *next_td = NULL, *prev_td = NULL;
     VP8Frame *curframe = s->curframe;
     int mb_y, num_jobs = s->num_jobs;
+    int ret;
 
     td->thread_nr = threadnr;
+    td->mv_bounds.mv_min.y   = -MARGIN - 64 * threadnr;
+    td->mv_bounds.mv_max.y   = ((s->mb_height - 1) << 6) + MARGIN - 64 * threadnr;
     for (mb_y = jobnr; mb_y < s->mb_height; mb_y += num_jobs) {
-        if (mb_y >= s->mb_height)
-            break;
-        td->thread_mb_pos = mb_y << 16;
-        s->decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr);
+        atomic_store(&td->thread_mb_pos, mb_y << 16);
+        ret = s->decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr);
+        if (ret < 0) {
+            update_pos(td, s->mb_height, INT_MAX & 0xFFFF);
+            return ret;
+        }
         if (s->deblock_filter)
             s->filter_mb_row(avctx, tdata, jobnr, threadnr);
         update_pos(td, mb_y, INT_MAX & 0xFFFF);
 
-        s->mv_min.y -= 64;
-        s->mv_max.y -= 64;
+        td->mv_bounds.mv_min.y -= 64 * num_jobs;
+        td->mv_bounds.mv_max.y -= 64 * num_jobs;
 
         if (avctx->active_thread_type == FF_THREAD_FRAME)
             ff_thread_report_progress(&curframe->tf, mb_y, 0);
@@ -2531,6 +2550,8 @@ int vp78_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     enum AVDiscard skip_thresh;
     VP8Frame *av_uninit(curframe), *prev_frame;
 
+    av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVA420P || avctx->pix_fmt == AV_PIX_FMT_YUV420P);
+
     if (is_vp7)
         ret = vp7_decode_frame_header(s, avpkt->data, avpkt->size);
     else
@@ -2646,11 +2667,12 @@ int vp78_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     s->num_jobs   = num_jobs;
     s->curframe   = curframe;
     s->prev_frame = prev_frame;
-    s->mv_min.y   = -MARGIN;
-    s->mv_max.y   = ((s->mb_height - 1) << 6) + MARGIN;
+    s->mv_bounds.mv_min.y   = -MARGIN;
+    s->mv_bounds.mv_max.y   = ((s->mb_height - 1) << 6) + MARGIN;
     for (i = 0; i < MAX_THREADS; i++) {
-        s->thread_data[i].thread_mb_pos = 0;
-        s->thread_data[i].wait_mb_pos   = INT_MAX;
+        VP8ThreadData *td = &s->thread_data[i];
+        atomic_init(&td->thread_mb_pos, 0);
+        atomic_init(&td->wait_mb_pos, INT_MAX);
     }
     if (is_vp7)
         avctx->execute2(avctx, vp7_decode_mb_row_sliced, s->thread_data, NULL,
diff --git a/mythtv/external/FFmpeg/libavcodec/vp8.h b/mythtv/external/FFmpeg/libavcodec/vp8.h
index 374e1388e21..8263997e3fc 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp8.h
+++ b/mythtv/external/FFmpeg/libavcodec/vp8.h
@@ -26,6 +26,8 @@
 #ifndef AVCODEC_VP8_H
 #define AVCODEC_VP8_H
 
+#include <stdatomic.h>
+
 #include "libavutil/buffer.h"
 #include "libavutil/thread.h"
 
@@ -91,6 +93,16 @@ typedef struct VP8Macroblock {
     VP56mv bmv[16];
 } VP8Macroblock;
 
+typedef struct VP8intmv {
+    int x;
+    int y;
+} VP8intmv;
+
+typedef struct VP8mvbounds {
+    VP8intmv mv_min;
+    VP8intmv mv_max;
+} VP8mvbounds;
+
 typedef struct VP8ThreadData {
     DECLARE_ALIGNED(16, int16_t, block)[6][4][16];
     DECLARE_ALIGNED(16, int16_t, block_dc)[16];
@@ -114,12 +126,13 @@ typedef struct VP8ThreadData {
     pthread_mutex_t lock;
     pthread_cond_t cond;
 #endif
-    int thread_mb_pos; // (mb_y << 16) | (mb_x & 0xFFFF)
-    int wait_mb_pos; // What the current thread is waiting on.
+    atomic_int thread_mb_pos; // (mb_y << 16) | (mb_x & 0xFFFF)
+    atomic_int wait_mb_pos; // What the current thread is waiting on.
 
 #define EDGE_EMU_LINESIZE 32
     DECLARE_ALIGNED(16, uint8_t, edge_emu_buffer)[21 * EDGE_EMU_LINESIZE];
     VP8FilterStrength *filter_strength;
+    VP8mvbounds mv_bounds;
 } VP8ThreadData;
 
 typedef struct VP8Frame {
@@ -127,11 +140,6 @@ typedef struct VP8Frame {
     AVBufferRef *seg_map;
 } VP8Frame;
 
-typedef struct VP8intmv {
-    int x;
-    int y;
-} VP8intmv;
-
 #define MAX_THREADS 8
 typedef struct VP8Context {
     VP8ThreadData *thread_data;
@@ -143,15 +151,14 @@ typedef struct VP8Context {
 
     uint16_t mb_width;   /* number of horizontal MB */
     uint16_t mb_height;  /* number of vertical MB */
-    int linesize;
-    int uvlinesize;
+    ptrdiff_t linesize;
+    ptrdiff_t uvlinesize;
 
     uint8_t keyframe;
     uint8_t deblock_filter;
     uint8_t mbskip_enabled;
     uint8_t profile;
-    VP8intmv mv_min;
-    VP8intmv mv_max;
+    VP8mvbounds mv_bounds;
 
     int8_t sign_bias[4]; ///< one state [0, 1] per ref frame type
     int ref_count[3];
@@ -275,7 +282,7 @@ typedef struct VP8Context {
      */
     int mb_layout;
 
-    void (*decode_mb_row_no_filter)(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr);
+    int (*decode_mb_row_no_filter)(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr);
     void (*filter_mb_row)(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr);
 
     int vp7;
diff --git a/mythtv/external/FFmpeg/libavcodec/vp8_parser.c b/mythtv/external/FFmpeg/libavcodec/vp8_parser.c
index afc7f991e64..609f5077d1a 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp8_parser.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp8_parser.c
@@ -1,6 +1,4 @@
 /*
- * Copyright (C) 2008 Michael Niedermayer
- *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
@@ -18,15 +16,56 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "parser.h"
+#include "libavutil/intreadwrite.h"
+
+#include "avcodec.h"
 
 static int parse(AVCodecParserContext *s,
                  AVCodecContext *avctx,
                  const uint8_t **poutbuf, int *poutbuf_size,
                  const uint8_t *buf, int buf_size)
 {
-    s->pict_type = (buf[0] & 0x01) ? AV_PICTURE_TYPE_P
-                                   : AV_PICTURE_TYPE_I;
+    unsigned int frame_type;
+    unsigned int profile;
+
+    if (buf_size < 3)
+        return buf_size;
+
+    frame_type = buf[0] & 1;
+    profile    = (buf[0] >> 1) & 7;
+    if (profile > 3) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid profile %u.\n", profile);
+        return buf_size;
+    }
+
+    avctx->profile = profile;
+    s->key_frame   = frame_type == 0;
+    s->pict_type   = frame_type ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
+    s->format      = AV_PIX_FMT_YUV420P;
+    s->field_order = AV_FIELD_PROGRESSIVE;
+    s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;
+
+    if (frame_type == 0) {
+        unsigned int sync_code;
+        unsigned int width, height;
+
+        if (buf_size < 10)
+            return buf_size;
+
+        sync_code = AV_RL24(buf + 3);
+        if (sync_code != 0x2a019d) {
+            av_log(avctx, AV_LOG_ERROR, "Invalid sync code %06x.\n", sync_code);
+            return buf_size;
+        }
+
+        width  = AV_RL16(buf + 6) & 0x3fff;
+        height = AV_RL16(buf + 8) & 0x3fff;
+
+        s->width        = width;
+        s->height       = height;
+        s->coded_width  = FFALIGN(width,  16);
+        s->coded_height = FFALIGN(height, 16);
+    }
 
     *poutbuf      = buf;
     *poutbuf_size = buf_size;
diff --git a/mythtv/external/FFmpeg/libavcodec/vp8dsp.c b/mythtv/external/FFmpeg/libavcodec/vp8dsp.c
index 07bea69c78c..fed5c67a90c 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp8dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp8dsp.c
@@ -53,7 +53,8 @@ static void name ## _idct_dc_add4y_c(uint8_t *dst, int16_t block[4][16],      \
 #if CONFIG_VP7_DECODER
 static void vp7_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16])
 {
-    int i, a1, b1, c1, d1;
+    int i;
+    unsigned a1, b1, c1, d1;
     int16_t tmp[16];
 
     for (i = 0; i < 4; i++) {
@@ -61,10 +62,10 @@ static void vp7_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16])
         b1 = (dc[i * 4 + 0] - dc[i * 4 + 2]) * 23170;
         c1 = dc[i * 4 + 1] * 12540 - dc[i * 4 + 3] * 30274;
         d1 = dc[i * 4 + 1] * 30274 + dc[i * 4 + 3] * 12540;
-        tmp[i * 4 + 0] = (a1 + d1) >> 14;
-        tmp[i * 4 + 3] = (a1 - d1) >> 14;
-        tmp[i * 4 + 1] = (b1 + c1) >> 14;
-        tmp[i * 4 + 2] = (b1 - c1) >> 14;
+        tmp[i * 4 + 0] = (int)(a1 + d1) >> 14;
+        tmp[i * 4 + 3] = (int)(a1 - d1) >> 14;
+        tmp[i * 4 + 1] = (int)(b1 + c1) >> 14;
+        tmp[i * 4 + 2] = (int)(b1 - c1) >> 14;
     }
 
     for (i = 0; i < 4; i++) {
@@ -73,10 +74,10 @@ static void vp7_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16])
         c1 = tmp[i + 4] * 12540 - tmp[i + 12] * 30274;
         d1 = tmp[i + 4] * 30274 + tmp[i + 12] * 12540;
         AV_ZERO64(dc + i * 4);
-        block[0][i][0] = (a1 + d1 + 0x20000) >> 18;
-        block[3][i][0] = (a1 - d1 + 0x20000) >> 18;
-        block[1][i][0] = (b1 + c1 + 0x20000) >> 18;
-        block[2][i][0] = (b1 - c1 + 0x20000) >> 18;
+        block[0][i][0] = (int)(a1 + d1 + 0x20000) >> 18;
+        block[3][i][0] = (int)(a1 - d1 + 0x20000) >> 18;
+        block[1][i][0] = (int)(b1 + c1 + 0x20000) >> 18;
+        block[2][i][0] = (int)(b1 - c1 + 0x20000) >> 18;
     }
 }
 
@@ -95,7 +96,8 @@ static void vp7_luma_dc_wht_dc_c(int16_t block[4][4][16], int16_t dc[16])
 
 static void vp7_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
 {
-    int i, a1, b1, c1, d1;
+    int i;
+    unsigned a1, b1, c1, d1;
     int16_t tmp[16];
 
     for (i = 0; i < 4; i++) {
@@ -104,10 +106,10 @@ static void vp7_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
         c1 = block[i * 4 + 1] * 12540 - block[i * 4 + 3] * 30274;
         d1 = block[i * 4 + 1] * 30274 + block[i * 4 + 3] * 12540;
         AV_ZERO64(block + i * 4);
-        tmp[i * 4 + 0] = (a1 + d1) >> 14;
-        tmp[i * 4 + 3] = (a1 - d1) >> 14;
-        tmp[i * 4 + 1] = (b1 + c1) >> 14;
-        tmp[i * 4 + 2] = (b1 - c1) >> 14;
+        tmp[i * 4 + 0] = (int)(a1 + d1) >> 14;
+        tmp[i * 4 + 3] = (int)(a1 - d1) >> 14;
+        tmp[i * 4 + 1] = (int)(b1 + c1) >> 14;
+        tmp[i * 4 + 2] = (int)(b1 - c1) >> 14;
     }
 
     for (i = 0; i < 4; i++) {
@@ -116,13 +118,13 @@ static void vp7_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
         c1 = tmp[i + 4] * 12540 - tmp[i + 12] * 30274;
         d1 = tmp[i + 4] * 30274 + tmp[i + 12] * 12540;
         dst[0 * stride + i] = av_clip_uint8(dst[0 * stride + i] +
-                                            ((a1 + d1 + 0x20000) >> 18));
+                                            ((int)(a1 + d1 + 0x20000) >> 18));
         dst[3 * stride + i] = av_clip_uint8(dst[3 * stride + i] +
-                                            ((a1 - d1 + 0x20000) >> 18));
+                                            ((int)(a1 - d1 + 0x20000) >> 18));
         dst[1 * stride + i] = av_clip_uint8(dst[1 * stride + i] +
-                                            ((b1 + c1 + 0x20000) >> 18));
+                                            ((int)(b1 + c1 + 0x20000) >> 18));
         dst[2 * stride + i] = av_clip_uint8(dst[2 * stride + i] +
-                                            ((b1 - c1 + 0x20000) >> 18));
+                                            ((int)(b1 - c1 + 0x20000) >> 18));
     }
 }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/vp8dsp.h b/mythtv/external/FFmpeg/libavcodec/vp8dsp.h
index 0401c9221b0..eaae4aed6d9 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp8dsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/vp8dsp.h
@@ -70,12 +70,12 @@ typedef struct VP8DSPContext {
     void (*vp8_h_loop_filter_simple)(uint8_t *dst, ptrdiff_t stride, int flim);
 
     /**
-     * first dimension: width>>3, height is assumed equal to width
+     * first dimension: 4-log2(width)
      * second dimension: 0 if no vertical interpolation is needed;
      *                   1 4-tap vertical interpolation filter (my & 1)
      *                   2 6-tap vertical interpolation filter (!(my & 1))
      * third dimension: same as second dimension, for horizontal interpolation
-     * so something like put_vp8_epel_pixels_tab[width>>3][2*!!my-(my&1)][2*!!mx-(mx&1)](..., mx, my)
+     * so something like put_vp8_epel_pixels_tab[4-log2(width)][2*!!my-(my&1)][2*!!mx-(mx&1)](..., mx, my)
      */
     vp8_mc_func put_vp8_epel_pixels_tab[3][3][3];
     vp8_mc_func put_vp8_bilinear_pixels_tab[3][3][3];
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9.c b/mythtv/external/FFmpeg/libavcodec/vp9.c
index 1aab6ba03c3..6b5de19266f 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp9.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp9.c
@@ -30,176 +30,97 @@
 #include "vp56.h"
 #include "vp9.h"
 #include "vp9data.h"
-#include "vp9dsp.h"
+#include "vp9dec.h"
 #include "libavutil/avassert.h"
 #include "libavutil/pixdesc.h"
 
 #define VP9_SYNCCODE 0x498342
 
-struct VP9Filter {
-    uint8_t level[8 * 8];
-    uint8_t /* bit=col */ mask[2 /* 0=y, 1=uv */][2 /* 0=col, 1=row */]
-                              [8 /* rows */][4 /* 0=16, 1=8, 2=4, 3=inner4 */];
-};
+#if HAVE_THREADS
+static void vp9_free_entries(AVCodecContext *avctx) {
+    VP9Context *s = avctx->priv_data;
 
-typedef struct VP9Block {
-    uint8_t seg_id, intra, comp, ref[2], mode[4], uvmode, skip;
-    enum FilterMode filter;
-    VP56mv mv[4 /* b_idx */][2 /* ref */];
-    enum BlockSize bs;
-    enum TxfmMode tx, uvtx;
-    enum BlockLevel bl;
-    enum BlockPartition bp;
-} VP9Block;
-
-typedef struct VP9Context {
-    VP9SharedContext s;
-
-    VP9DSPContext dsp;
-    VideoDSPContext vdsp;
-    GetBitContext gb;
-    VP56RangeCoder c;
-    VP56RangeCoder *c_b;
-    unsigned c_b_size;
-    VP9Block *b_base, *b;
-    int pass;
-    int row, row7, col, col7;
-    uint8_t *dst[3];
-    ptrdiff_t y_stride, uv_stride;
-
-    uint8_t ss_h, ss_v;
-    uint8_t last_bpp, bpp, bpp_index, bytesperpixel;
-    uint8_t last_keyframe;
-    // sb_cols/rows, rows/cols and last_fmt are used for allocating all internal
-    // arrays, and are thus per-thread. w/h and gf_fmt are synced between threads
-    // and are therefore per-stream. pix_fmt represents the value in the header
-    // of the currently processed frame.
-    int w, h;
-    enum AVPixelFormat pix_fmt, last_fmt, gf_fmt;
-    unsigned sb_cols, sb_rows, rows, cols;
-    ThreadFrame next_refs[8];
-
-    struct {
-        uint8_t lim_lut[64];
-        uint8_t mblim_lut[64];
-    } filter_lut;
-    unsigned tile_row_start, tile_row_end, tile_col_start, tile_col_end;
-    struct {
-        prob_context p;
-        uint8_t coef[4][2][2][6][6][3];
-    } prob_ctx[4];
-    struct {
-        prob_context p;
-        uint8_t coef[4][2][2][6][6][11];
-    } prob;
-    struct {
-        unsigned y_mode[4][10];
-        unsigned uv_mode[10][10];
-        unsigned filter[4][3];
-        unsigned mv_mode[7][4];
-        unsigned intra[4][2];
-        unsigned comp[5][2];
-        unsigned single_ref[5][2][2];
-        unsigned comp_ref[5][2];
-        unsigned tx32p[2][4];
-        unsigned tx16p[2][3];
-        unsigned tx8p[2][2];
-        unsigned skip[3][2];
-        unsigned mv_joint[4];
-        struct {
-            unsigned sign[2];
-            unsigned classes[11];
-            unsigned class0[2];
-            unsigned bits[10][2];
-            unsigned class0_fp[2][4];
-            unsigned fp[4];
-            unsigned class0_hp[2];
-            unsigned hp[2];
-        } mv_comp[2];
-        unsigned partition[4][4][4];
-        unsigned coef[4][2][2][6][6][3];
-        unsigned eob[4][2][2][6][6][2];
-    } counts;
-
-    // contextual (left/above) cache
-    DECLARE_ALIGNED(16, uint8_t, left_y_nnz_ctx)[16];
-    DECLARE_ALIGNED(16, uint8_t, left_mode_ctx)[16];
-    DECLARE_ALIGNED(16, VP56mv, left_mv_ctx)[16][2];
-    DECLARE_ALIGNED(16, uint8_t, left_uv_nnz_ctx)[2][16];
-    DECLARE_ALIGNED(8, uint8_t, left_partition_ctx)[8];
-    DECLARE_ALIGNED(8, uint8_t, left_skip_ctx)[8];
-    DECLARE_ALIGNED(8, uint8_t, left_txfm_ctx)[8];
-    DECLARE_ALIGNED(8, uint8_t, left_segpred_ctx)[8];
-    DECLARE_ALIGNED(8, uint8_t, left_intra_ctx)[8];
-    DECLARE_ALIGNED(8, uint8_t, left_comp_ctx)[8];
-    DECLARE_ALIGNED(8, uint8_t, left_ref_ctx)[8];
-    DECLARE_ALIGNED(8, uint8_t, left_filter_ctx)[8];
-    uint8_t *above_partition_ctx;
-    uint8_t *above_mode_ctx;
-    // FIXME maybe merge some of the below in a flags field?
-    uint8_t *above_y_nnz_ctx;
-    uint8_t *above_uv_nnz_ctx[2];
-    uint8_t *above_skip_ctx; // 1bit
-    uint8_t *above_txfm_ctx; // 2bit
-    uint8_t *above_segpred_ctx; // 1bit
-    uint8_t *above_intra_ctx; // 1bit
-    uint8_t *above_comp_ctx; // 1bit
-    uint8_t *above_ref_ctx; // 2bit
-    uint8_t *above_filter_ctx;
-    VP56mv (*above_mv_ctx)[2];
-
-    // whole-frame cache
-    uint8_t *intra_pred_data[3];
-    struct VP9Filter *lflvl;
-    DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer)[135 * 144 * 2];
-
-    // block reconstruction intermediates
-    int block_alloc_using_2pass;
-    int16_t *block_base, *block, *uvblock_base[2], *uvblock[2];
-    uint8_t *eob_base, *uveob_base[2], *eob, *uveob[2];
-    struct { int x, y; } min_mv, max_mv;
-    DECLARE_ALIGNED(32, uint8_t, tmp_y)[64 * 64 * 2];
-    DECLARE_ALIGNED(32, uint8_t, tmp_uv)[2][64 * 64 * 2];
-    uint16_t mvscale[3][2];
-    uint8_t mvstep[3][2];
-} VP9Context;
-
-static const uint8_t bwh_tab[2][N_BS_SIZES][2] = {
-    {
-        { 16, 16 }, { 16, 8 }, { 8, 16 }, { 8, 8 }, { 8, 4 }, { 4, 8 },
-        { 4, 4 }, { 4, 2 }, { 2, 4 }, { 2, 2 }, { 2, 1 }, { 1, 2 }, { 1, 1 },
-    }, {
-        { 8, 8 }, { 8, 4 }, { 4, 8 }, { 4, 4 }, { 4, 2 }, { 2, 4 },
-        { 2, 2 }, { 2, 1 }, { 1, 2 }, { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 },
+    if (avctx->active_thread_type & FF_THREAD_SLICE)  {
+        pthread_mutex_destroy(&s->progress_mutex);
+        pthread_cond_destroy(&s->progress_cond);
+        av_freep(&s->entries);
     }
-};
+}
+
+static int vp9_alloc_entries(AVCodecContext *avctx, int n) {
+    VP9Context *s = avctx->priv_data;
+    int i;
+
+    if (avctx->active_thread_type & FF_THREAD_SLICE)  {
+        if (s->entries)
+            av_freep(&s->entries);
+
+        s->entries = av_malloc_array(n, sizeof(atomic_int));
+
+        if (!s->entries) {
+            av_freep(&s->entries);
+            return AVERROR(ENOMEM);
+        }
+
+        for (i  = 0; i < n; i++)
+            atomic_init(&s->entries[i], 0);
+
+        pthread_mutex_init(&s->progress_mutex, NULL);
+        pthread_cond_init(&s->progress_cond, NULL);
+    }
+    return 0;
+}
+
+static void vp9_report_tile_progress(VP9Context *s, int field, int n) {
+    pthread_mutex_lock(&s->progress_mutex);
+    atomic_fetch_add_explicit(&s->entries[field], n, memory_order_release);
+    pthread_cond_signal(&s->progress_cond);
+    pthread_mutex_unlock(&s->progress_mutex);
+}
+
+static void vp9_await_tile_progress(VP9Context *s, int field, int n) {
+    if (atomic_load_explicit(&s->entries[field], memory_order_acquire) >= n)
+        return;
+
+    pthread_mutex_lock(&s->progress_mutex);
+    while (atomic_load_explicit(&s->entries[field], memory_order_relaxed) != n)
+        pthread_cond_wait(&s->progress_cond, &s->progress_mutex);
+    pthread_mutex_unlock(&s->progress_mutex);
+}
+#else
+static void vp9_free_entries(AVCodecContext *avctx) {}
+static int vp9_alloc_entries(AVCodecContext *avctx, int n) { return 0; }
+#endif
 
-static void vp9_unref_frame(AVCodecContext *ctx, VP9Frame *f)
+static void vp9_frame_unref(AVCodecContext *avctx, VP9Frame *f)
 {
-    ff_thread_release_buffer(ctx, &f->tf);
+    ff_thread_release_buffer(avctx, &f->tf);
     av_buffer_unref(&f->extradata);
     av_buffer_unref(&f->hwaccel_priv_buf);
     f->segmentation_map = NULL;
     f->hwaccel_picture_private = NULL;
 }
 
-static int vp9_alloc_frame(AVCodecContext *ctx, VP9Frame *f)
+static int vp9_frame_alloc(AVCodecContext *avctx, VP9Frame *f)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     int ret, sz;
 
-    if ((ret = ff_thread_get_buffer(ctx, &f->tf, AV_GET_BUFFER_FLAG_REF)) < 0)
+    ret = ff_thread_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF);
+    if (ret < 0)
         return ret;
+
     sz = 64 * s->sb_cols * s->sb_rows;
-    if (!(f->extradata = av_buffer_allocz(sz * (1 + sizeof(struct VP9mvrefPair))))) {
+    f->extradata = av_buffer_allocz(sz * (1 + sizeof(VP9mvrefPair)));
+    if (!f->extradata) {
         goto fail;
     }
 
     f->segmentation_map = f->extradata->data;
-    f->mv = (struct VP9mvrefPair *) (f->extradata->data + sz);
+    f->mv = (VP9mvrefPair *) (f->extradata->data + sz);
 
-    if (ctx->hwaccel) {
-        const AVHWAccel *hwaccel = ctx->hwaccel;
+    if (avctx->hwaccel) {
+        const AVHWAccel *hwaccel = avctx->hwaccel;
         av_assert0(!f->hwaccel_picture_private);
         if (hwaccel->frame_priv_data_size) {
             f->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
@@ -212,19 +133,21 @@ static int vp9_alloc_frame(AVCodecContext *ctx, VP9Frame *f)
     return 0;
 
 fail:
-    vp9_unref_frame(ctx, f);
+    vp9_frame_unref(avctx, f);
     return AVERROR(ENOMEM);
 }
 
-static int vp9_ref_frame(AVCodecContext *ctx, VP9Frame *dst, VP9Frame *src)
+static int vp9_frame_ref(AVCodecContext *avctx, VP9Frame *dst, VP9Frame *src)
 {
-    int res;
+    int ret;
+
+    ret = ff_thread_ref_frame(&dst->tf, &src->tf);
+    if (ret < 0)
+        return ret;
 
-    if ((res = ff_thread_ref_frame(&dst->tf, &src->tf)) < 0) {
-        return res;
-    } else if (!(dst->extradata = av_buffer_ref(src->extradata))) {
+    dst->extradata = av_buffer_ref(src->extradata);
+    if (!dst->extradata)
         goto fail;
-    }
 
     dst->segmentation_map = src->segmentation_map;
     dst->mv = src->mv;
@@ -240,44 +163,54 @@ static int vp9_ref_frame(AVCodecContext *ctx, VP9Frame *dst, VP9Frame *src)
     return 0;
 
 fail:
-    vp9_unref_frame(ctx, dst);
+    vp9_frame_unref(avctx, dst);
     return AVERROR(ENOMEM);
 }
 
-static int update_size(AVCodecContext *ctx, int w, int h)
+static int update_size(AVCodecContext *avctx, int w, int h)
 {
-#define HWACCEL_MAX (CONFIG_VP9_DXVA2_HWACCEL + CONFIG_VP9_D3D11VA_HWACCEL + CONFIG_VP9_VAAPI_HWACCEL)
+#define HWACCEL_MAX (CONFIG_VP9_DXVA2_HWACCEL + CONFIG_VP9_D3D11VA_HWACCEL * 2 + CONFIG_VP9_VAAPI_HWACCEL)
     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     uint8_t *p;
-    int bytesperpixel = s->bytesperpixel, res, cols, rows;
+    int bytesperpixel = s->bytesperpixel, ret, cols, rows;
+    int lflvl_len, i;
 
     av_assert0(w > 0 && h > 0);
 
     if (!(s->pix_fmt == s->gf_fmt && w == s->w && h == s->h)) {
-        if ((res = ff_set_dimensions(ctx, w, h)) < 0)
-            return res;
+        if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
+            return ret;
 
-        if (s->pix_fmt == AV_PIX_FMT_YUV420P) {
+        switch (s->pix_fmt) {
+        case AV_PIX_FMT_YUV420P:
 #if CONFIG_VP9_DXVA2_HWACCEL
             *fmtp++ = AV_PIX_FMT_DXVA2_VLD;
 #endif
 #if CONFIG_VP9_D3D11VA_HWACCEL
             *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;
+            *fmtp++ = AV_PIX_FMT_D3D11;
+#endif
+#if CONFIG_VP9_VAAPI_HWACCEL
+            *fmtp++ = AV_PIX_FMT_VAAPI;
 #endif
+            break;
+        case AV_PIX_FMT_YUV420P10:
+        case AV_PIX_FMT_YUV420P12:
 #if CONFIG_VP9_VAAPI_HWACCEL
             *fmtp++ = AV_PIX_FMT_VAAPI;
 #endif
+            break;
         }
 
         *fmtp++ = s->pix_fmt;
         *fmtp = AV_PIX_FMT_NONE;
 
-        res = ff_thread_get_format(ctx, pix_fmts);
-        if (res < 0)
-            return res;
+        ret = ff_thread_get_format(avctx, pix_fmts);
+        if (ret < 0)
+            return ret;
 
-        ctx->pix_fmt = res;
+        avctx->pix_fmt = ret;
         s->gf_fmt  = s->pix_fmt;
         s->w = w;
         s->h = h;
@@ -294,13 +227,14 @@ static int update_size(AVCodecContext *ctx, int w, int h)
     s->sb_rows   = (h + 63) >> 6;
     s->cols      = (w + 7) >> 3;
     s->rows      = (h + 7) >> 3;
+    lflvl_len    = avctx->active_thread_type == FF_THREAD_SLICE ? s->sb_rows : 1;
 
 #define assign(var, type, n) var = (type) p; p += s->sb_cols * (n) * sizeof(*var)
     av_freep(&s->intra_pred_data[0]);
     // FIXME we slightly over-allocate here for subsampled chroma, but a little
     // bit of padding shouldn't affect performance...
     p = av_malloc(s->sb_cols * (128 + 192 * bytesperpixel +
-                                sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx)));
+                                lflvl_len * sizeof(*s->lflvl) + 16 * sizeof(*s->above_mv_ctx)));
     if (!p)
         return AVERROR(ENOMEM);
     assign(s->intra_pred_data[0],  uint8_t *,             64 * bytesperpixel);
@@ -319,65 +253,78 @@ static int update_size(AVCodecContext *ctx, int w, int h)
     assign(s->above_comp_ctx,      uint8_t *,              8);
     assign(s->above_ref_ctx,       uint8_t *,              8);
     assign(s->above_filter_ctx,    uint8_t *,              8);
-    assign(s->lflvl,               struct VP9Filter *,     1);
+    assign(s->lflvl,               VP9Filter *,            lflvl_len);
 #undef assign
 
-    // these will be re-allocated a little later
-    av_freep(&s->b_base);
-    av_freep(&s->block_base);
+    if (s->td) {
+        for (i = 0; i < s->active_tile_cols; i++) {
+            av_freep(&s->td[i].b_base);
+            av_freep(&s->td[i].block_base);
+        }
+    }
 
-    if (s->bpp != s->last_bpp) {
-        ff_vp9dsp_init(&s->dsp, s->bpp, ctx->flags & AV_CODEC_FLAG_BITEXACT);
-        ff_videodsp_init(&s->vdsp, s->bpp);
-        s->last_bpp = s->bpp;
+    if (s->s.h.bpp != s->last_bpp) {
+        ff_vp9dsp_init(&s->dsp, s->s.h.bpp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
+        ff_videodsp_init(&s->vdsp, s->s.h.bpp);
+        s->last_bpp = s->s.h.bpp;
     }
 
     return 0;
 }
 
-static int update_block_buffers(AVCodecContext *ctx)
+static int update_block_buffers(AVCodecContext *avctx)
 {
-    VP9Context *s = ctx->priv_data;
+    int i;
+    VP9Context *s = avctx->priv_data;
     int chroma_blocks, chroma_eobs, bytesperpixel = s->bytesperpixel;
+    VP9TileData *td = &s->td[0];
 
-    if (s->b_base && s->block_base && s->block_alloc_using_2pass == s->s.frames[CUR_FRAME].uses_2pass)
+    if (td->b_base && td->block_base && s->block_alloc_using_2pass == s->s.frames[CUR_FRAME].uses_2pass)
         return 0;
 
-    av_free(s->b_base);
-    av_free(s->block_base);
+    av_free(td->b_base);
+    av_free(td->block_base);
     chroma_blocks = 64 * 64 >> (s->ss_h + s->ss_v);
     chroma_eobs   = 16 * 16 >> (s->ss_h + s->ss_v);
     if (s->s.frames[CUR_FRAME].uses_2pass) {
         int sbs = s->sb_cols * s->sb_rows;
 
-        s->b_base = av_malloc_array(s->cols * s->rows, sizeof(VP9Block));
-        s->block_base = av_mallocz(((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
+        td->b_base = av_malloc_array(s->cols * s->rows, sizeof(VP9Block));
+        td->block_base = av_mallocz(((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
                                     16 * 16 + 2 * chroma_eobs) * sbs);
-        if (!s->b_base || !s->block_base)
+        if (!td->b_base || !td->block_base)
             return AVERROR(ENOMEM);
-        s->uvblock_base[0] = s->block_base + sbs * 64 * 64 * bytesperpixel;
-        s->uvblock_base[1] = s->uvblock_base[0] + sbs * chroma_blocks * bytesperpixel;
-        s->eob_base = (uint8_t *) (s->uvblock_base[1] + sbs * chroma_blocks * bytesperpixel);
-        s->uveob_base[0] = s->eob_base + 16 * 16 * sbs;
-        s->uveob_base[1] = s->uveob_base[0] + chroma_eobs * sbs;
+        td->uvblock_base[0] = td->block_base + sbs * 64 * 64 * bytesperpixel;
+        td->uvblock_base[1] = td->uvblock_base[0] + sbs * chroma_blocks * bytesperpixel;
+        td->eob_base = (uint8_t *) (td->uvblock_base[1] + sbs * chroma_blocks * bytesperpixel);
+        td->uveob_base[0] = td->eob_base + 16 * 16 * sbs;
+        td->uveob_base[1] = td->uveob_base[0] + chroma_eobs * sbs;
     } else {
-        s->b_base = av_malloc(sizeof(VP9Block));
-        s->block_base = av_mallocz((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
-                                   16 * 16 + 2 * chroma_eobs);
-        if (!s->b_base || !s->block_base)
-            return AVERROR(ENOMEM);
-        s->uvblock_base[0] = s->block_base + 64 * 64 * bytesperpixel;
-        s->uvblock_base[1] = s->uvblock_base[0] + chroma_blocks * bytesperpixel;
-        s->eob_base = (uint8_t *) (s->uvblock_base[1] + chroma_blocks * bytesperpixel);
-        s->uveob_base[0] = s->eob_base + 16 * 16;
-        s->uveob_base[1] = s->uveob_base[0] + chroma_eobs;
+        for (i = 1; i < s->active_tile_cols; i++) {
+            if (s->td[i].b_base && s->td[i].block_base) {
+                av_free(s->td[i].b_base);
+                av_free(s->td[i].block_base);
+            }
+        }
+        for (i = 0; i < s->active_tile_cols; i++) {
+            s->td[i].b_base = av_malloc(sizeof(VP9Block));
+            s->td[i].block_base = av_mallocz((64 * 64 + 2 * chroma_blocks) * bytesperpixel * sizeof(int16_t) +
+                                       16 * 16 + 2 * chroma_eobs);
+            if (!s->td[i].b_base || !s->td[i].block_base)
+                return AVERROR(ENOMEM);
+            s->td[i].uvblock_base[0] = s->td[i].block_base + 64 * 64 * bytesperpixel;
+            s->td[i].uvblock_base[1] = s->td[i].uvblock_base[0] + chroma_blocks * bytesperpixel;
+            s->td[i].eob_base = (uint8_t *) (s->td[i].uvblock_base[1] + chroma_blocks * bytesperpixel);
+            s->td[i].uveob_base[0] = s->td[i].eob_base + 16 * 16;
+            s->td[i].uveob_base[1] = s->td[i].uveob_base[0] + chroma_eobs;
+        }
     }
     s->block_alloc_using_2pass = s->s.frames[CUR_FRAME].uses_2pass;
 
     return 0;
 }
 
-// for some reason the sign bit is at the end, not the start, of a bit sequence
+// The sign bit is at the end, not the start, of a bit sequence
 static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)
 {
     int v = get_bits(gb, n);
@@ -386,7 +333,11 @@ static av_always_inline int get_sbits_inv(GetBitContext *gb, int n)
 
 static av_always_inline int inv_recenter_nonneg(int v, int m)
 {
-    return v > 2 * m ? v : v & 1 ? m - ((v + 1) >> 1) : m + (v >> 1);
+    if (v > 2 * m)
+        return v;
+    if (v & 1)
+        return m - ((v + 1) >> 1);
+    return m + (v >> 1);
 }
 
 // differential forward probability updates
@@ -417,13 +368,13 @@ static int update_prob(VP56RangeCoder *c, int p)
 
     /* This code is trying to do a differential probability update. For a
      * current probability A in the range [1, 255], the difference to a new
-     * probability of any value can be expressed differentially as 1-A,255-A
+     * probability of any value can be expressed differentially as 1-A, 255-A
      * where some part of this (absolute range) exists both in positive as
      * well as the negative part, whereas another part only exists in one
      * half. We're trying to code this shared part differentially, i.e.
      * times two where the value of the lowest bit specifies the sign, and
      * the single part is then coded on top of this. This absolute difference
-     * then again has a value of [0,254], but a bigger value in this range
+     * then again has a value of [0, 254], but a bigger value in this range
      * indicates that we're further away from the original value A, so we
      * can code this as a VLC code, since higher values are increasingly
      * unlikely. The first 20 values in inv_map_table[] allow 'cheap, rough'
@@ -448,34 +399,34 @@ static int update_prob(VP56RangeCoder *c, int p)
                     255 - inv_recenter_nonneg(inv_map_table[d], 255 - p);
 }
 
-static int read_colorspace_details(AVCodecContext *ctx)
+static int read_colorspace_details(AVCodecContext *avctx)
 {
     static const enum AVColorSpace colorspaces[8] = {
         AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M,
         AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB,
     };
-    VP9Context *s = ctx->priv_data;
-    int bits = ctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
+    VP9Context *s = avctx->priv_data;
+    int bits = avctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
 
     s->bpp_index = bits;
-    s->bpp = 8 + bits * 2;
-    s->bytesperpixel = (7 + s->bpp) >> 3;
-    ctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
-    if (ctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
+    s->s.h.bpp = 8 + bits * 2;
+    s->bytesperpixel = (7 + s->s.h.bpp) >> 3;
+    avctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
+    if (avctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
         static const enum AVPixelFormat pix_fmt_rgb[3] = {
             AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12
         };
         s->ss_h = s->ss_v = 0;
-        ctx->color_range = AVCOL_RANGE_JPEG;
+        avctx->color_range = AVCOL_RANGE_JPEG;
         s->pix_fmt = pix_fmt_rgb[bits];
-        if (ctx->profile & 1) {
+        if (avctx->profile & 1) {
             if (get_bits1(&s->gb)) {
-                av_log(ctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");
+                av_log(avctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");
                 return AVERROR_INVALIDDATA;
             }
         } else {
-            av_log(ctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
-                   ctx->profile);
+            av_log(avctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
+                   avctx->profile);
             return AVERROR_INVALIDDATA;
         }
     } else {
@@ -487,18 +438,18 @@ static int read_colorspace_details(AVCodecContext *ctx)
             { { AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12 },
               { AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12 } }
         };
-        ctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
-        if (ctx->profile & 1) {
+        avctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
+        if (avctx->profile & 1) {
             s->ss_h = get_bits1(&s->gb);
             s->ss_v = get_bits1(&s->gb);
             s->pix_fmt = pix_fmt_for_ss[bits][s->ss_v][s->ss_h];
             if (s->pix_fmt == AV_PIX_FMT_YUV420P) {
-                av_log(ctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
-                       ctx->profile);
+                av_log(avctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
+                       avctx->profile);
                 return AVERROR_INVALIDDATA;
             } else if (get_bits1(&s->gb)) {
-                av_log(ctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
-                       ctx->profile);
+                av_log(avctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
+                       avctx->profile);
                 return AVERROR_INVALIDDATA;
             }
         } else {
@@ -510,48 +461,51 @@ static int read_colorspace_details(AVCodecContext *ctx)
     return 0;
 }
 
-static int decode_frame_header(AVCodecContext *ctx,
+static int decode_frame_header(AVCodecContext *avctx,
                                const uint8_t *data, int size, int *ref)
 {
-    VP9Context *s = ctx->priv_data;
-    int c, i, j, k, l, m, n, w, h, max, size2, res, sharp;
+    VP9Context *s = avctx->priv_data;
+    int c, i, j, k, l, m, n, w, h, max, size2, ret, sharp;
     int last_invisible;
     const uint8_t *data2;
 
     /* general header */
-    if ((res = init_get_bits8(&s->gb, data, size)) < 0) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
-        return res;
+    if ((ret = init_get_bits8(&s->gb, data, size)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
+        return ret;
     }
     if (get_bits(&s->gb, 2) != 0x2) { // frame marker
-        av_log(ctx, AV_LOG_ERROR, "Invalid frame marker\n");
+        av_log(avctx, AV_LOG_ERROR, "Invalid frame marker\n");
         return AVERROR_INVALIDDATA;
     }
-    ctx->profile  = get_bits1(&s->gb);
-    ctx->profile |= get_bits1(&s->gb) << 1;
-    if (ctx->profile == 3) ctx->profile += get_bits1(&s->gb);
-    if (ctx->profile > 3) {
-        av_log(ctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", ctx->profile);
+    avctx->profile  = get_bits1(&s->gb);
+    avctx->profile |= get_bits1(&s->gb) << 1;
+    if (avctx->profile == 3) avctx->profile += get_bits1(&s->gb);
+    if (avctx->profile > 3) {
+        av_log(avctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", avctx->profile);
         return AVERROR_INVALIDDATA;
     }
-    s->s.h.profile = ctx->profile;
+    s->s.h.profile = avctx->profile;
     if (get_bits1(&s->gb)) {
         *ref = get_bits(&s->gb, 3);
         return 0;
     }
+
     s->last_keyframe  = s->s.h.keyframe;
-    s->s.h.keyframe     = !get_bits1(&s->gb);
-    last_invisible    = s->s.h.invisible;
-    s->s.h.invisible    = !get_bits1(&s->gb);
-    s->s.h.errorres     = get_bits1(&s->gb);
+    s->s.h.keyframe   = !get_bits1(&s->gb);
+
+    last_invisible   = s->s.h.invisible;
+    s->s.h.invisible = !get_bits1(&s->gb);
+    s->s.h.errorres  = get_bits1(&s->gb);
     s->s.h.use_last_frame_mvs = !s->s.h.errorres && !last_invisible;
+
     if (s->s.h.keyframe) {
         if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
-            av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");
+            av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
             return AVERROR_INVALIDDATA;
         }
-        if ((res = read_colorspace_details(ctx)) < 0)
-            return res;
+        if ((ret = read_colorspace_details(avctx)) < 0)
+            return ret;
         // for profile 1, here follows the subsampling bits
         s->s.h.refreshrefmask = 0xff;
         w = get_bits(&s->gb, 16) + 1;
@@ -559,24 +513,24 @@ static int decode_frame_header(AVCodecContext *ctx,
         if (get_bits1(&s->gb)) // display size
             skip_bits(&s->gb, 32);
     } else {
-        s->s.h.intraonly  = s->s.h.invisible ? get_bits1(&s->gb) : 0;
-        s->s.h.resetctx   = s->s.h.errorres ? 0 : get_bits(&s->gb, 2);
+        s->s.h.intraonly = s->s.h.invisible ? get_bits1(&s->gb) : 0;
+        s->s.h.resetctx  = s->s.h.errorres ? 0 : get_bits(&s->gb, 2);
         if (s->s.h.intraonly) {
             if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
-                av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");
+                av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
                 return AVERROR_INVALIDDATA;
             }
-            if (ctx->profile >= 1) {
-                if ((res = read_colorspace_details(ctx)) < 0)
-                    return res;
+            if (avctx->profile >= 1) {
+                if ((ret = read_colorspace_details(avctx)) < 0)
+                    return ret;
             } else {
                 s->ss_h = s->ss_v = 1;
-                s->bpp = 8;
+                s->s.h.bpp = 8;
                 s->bpp_index = 0;
                 s->bytesperpixel = 1;
                 s->pix_fmt = AV_PIX_FMT_YUV420P;
-                ctx->colorspace = AVCOL_SPC_BT470BG;
-                ctx->color_range = AVCOL_RANGE_JPEG;
+                avctx->colorspace = AVCOL_SPC_BT470BG;
+                avctx->color_range = AVCOL_RANGE_MPEG;
             }
             s->s.h.refreshrefmask = get_bits(&s->gb, 8);
             w = get_bits(&s->gb, 16) + 1;
@@ -594,7 +548,7 @@ static int decode_frame_header(AVCodecContext *ctx,
             if (!s->s.refs[s->s.h.refidx[0]].f->buf[0] ||
                 !s->s.refs[s->s.h.refidx[1]].f->buf[0] ||
                 !s->s.refs[s->s.h.refidx[2]].f->buf[0]) {
-                av_log(ctx, AV_LOG_ERROR, "Not all references are available\n");
+                av_log(avctx, AV_LOG_ERROR, "Not all references are available\n");
                 return AVERROR_INVALIDDATA;
             }
             if (get_bits1(&s->gb)) {
@@ -660,8 +614,20 @@ static int decode_frame_header(AVCodecContext *ctx,
     sharp = get_bits(&s->gb, 3);
     // if sharpness changed, reinit lim/mblim LUTs. if it didn't change, keep
     // the old cache values since they are still valid
-    if (s->s.h.filter.sharpness != sharp)
-        memset(s->filter_lut.lim_lut, 0, sizeof(s->filter_lut.lim_lut));
+    if (s->s.h.filter.sharpness != sharp) {
+        for (i = 1; i <= 63; i++) {
+            int limit = i;
+
+            if (sharp > 0) {
+                limit >>= (sharp + 3) >> 2;
+                limit = FFMIN(limit, 9 - sharp);
+            }
+            limit = FFMAX(limit, 1);
+
+            s->filter_lut.lim_lut[i] = limit;
+            s->filter_lut.mblim_lut[i] = 2 * (i + 2) + limit;
+        }
+    }
     s->s.h.filter.sharpness = sharp;
     if ((s->s.h.lf_delta.enabled = get_bits1(&s->gb))) {
         if ((s->s.h.lf_delta.updated = get_bits1(&s->gb))) {
@@ -682,7 +648,7 @@ static int decode_frame_header(AVCodecContext *ctx,
     s->s.h.lossless    = s->s.h.yac_qi == 0 && s->s.h.ydc_qdelta == 0 &&
                        s->s.h.uvdc_qdelta == 0 && s->s.h.uvac_qdelta == 0;
     if (s->s.h.lossless)
-        ctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
+        avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
 
     /* segmentation header info */
     if ((s->s.h.segmentation.enabled = get_bits1(&s->gb))) {
@@ -690,11 +656,10 @@ static int decode_frame_header(AVCodecContext *ctx,
             for (i = 0; i < 7; i++)
                 s->s.h.segmentation.prob[i] = get_bits1(&s->gb) ?
                                  get_bits(&s->gb, 8) : 255;
-            if ((s->s.h.segmentation.temporal = get_bits1(&s->gb))) {
+            if ((s->s.h.segmentation.temporal = get_bits1(&s->gb)))
                 for (i = 0; i < 3; i++)
                     s->s.h.segmentation.pred_prob[i] = get_bits1(&s->gb) ?
                                          get_bits(&s->gb, 8) : 255;
-            }
         }
 
         if (get_bits1(&s->gb)) {
@@ -728,10 +693,10 @@ static int decode_frame_header(AVCodecContext *ctx,
         quvac = av_clip_uintp2(qyac + s->s.h.uvac_qdelta, 8);
         qyac  = av_clip_uintp2(qyac, 8);
 
-        s->s.h.segmentation.feat[i].qmul[0][0] = vp9_dc_qlookup[s->bpp_index][qydc];
-        s->s.h.segmentation.feat[i].qmul[0][1] = vp9_ac_qlookup[s->bpp_index][qyac];
-        s->s.h.segmentation.feat[i].qmul[1][0] = vp9_dc_qlookup[s->bpp_index][quvdc];
-        s->s.h.segmentation.feat[i].qmul[1][1] = vp9_ac_qlookup[s->bpp_index][quvac];
+        s->s.h.segmentation.feat[i].qmul[0][0] = ff_vp9_dc_qlookup[s->bpp_index][qydc];
+        s->s.h.segmentation.feat[i].qmul[0][1] = ff_vp9_ac_qlookup[s->bpp_index][qyac];
+        s->s.h.segmentation.feat[i].qmul[1][0] = ff_vp9_dc_qlookup[s->bpp_index][quvdc];
+        s->s.h.segmentation.feat[i].qmul[1][1] = ff_vp9_ac_qlookup[s->bpp_index][quvac];
 
         sh = s->s.h.filter.level >= 32;
         if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[i].lf_enabled) {
@@ -761,10 +726,10 @@ static int decode_frame_header(AVCodecContext *ctx,
     }
 
     /* tiling info */
-    if ((res = update_size(ctx, w, h)) < 0) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",
+    if ((ret = update_size(avctx, w, h)) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",
                w, h, s->pix_fmt);
-        return res;
+        return ret;
     }
     for (s->s.h.tiling.log2_tile_cols = 0;
          s->sb_cols > (64 << s->s.h.tiling.log2_tile_cols);
@@ -780,12 +745,36 @@ static int decode_frame_header(AVCodecContext *ctx,
     s->s.h.tiling.log2_tile_rows = decode012(&s->gb);
     s->s.h.tiling.tile_rows = 1 << s->s.h.tiling.log2_tile_rows;
     if (s->s.h.tiling.tile_cols != (1 << s->s.h.tiling.log2_tile_cols)) {
+        int n_range_coders;
+        VP56RangeCoder *rc;
+
+        if (s->td) {
+            for (i = 0; i < s->active_tile_cols; i++) {
+                av_free(s->td[i].b_base);
+                av_free(s->td[i].block_base);
+            }
+            av_free(s->td);
+        }
+
         s->s.h.tiling.tile_cols = 1 << s->s.h.tiling.log2_tile_cols;
-        s->c_b = av_fast_realloc(s->c_b, &s->c_b_size,
-                                 sizeof(VP56RangeCoder) * s->s.h.tiling.tile_cols);
-        if (!s->c_b) {
-            av_log(ctx, AV_LOG_ERROR, "Ran out of memory during range coder init\n");
+        vp9_free_entries(avctx);
+        s->active_tile_cols = avctx->active_thread_type == FF_THREAD_SLICE ?
+                              s->s.h.tiling.tile_cols : 1;
+        vp9_alloc_entries(avctx, s->sb_rows);
+        if (avctx->active_thread_type == FF_THREAD_SLICE) {
+            n_range_coders = 4; // max_tile_rows
+        } else {
+            n_range_coders = s->s.h.tiling.tile_cols;
+        }
+        s->td = av_mallocz_array(s->active_tile_cols, sizeof(VP9TileData) +
+                                 n_range_coders * sizeof(VP56RangeCoder));
+        if (!s->td)
             return AVERROR(ENOMEM);
+        rc = (VP56RangeCoder *) &s->td[s->active_tile_cols];
+        for (i = 0; i < s->active_tile_cols; i++) {
+            s->td[i].s = s;
+            s->td[i].c_b = rc;
+            rc += n_range_coders;
         }
     }
 
@@ -795,17 +784,17 @@ static int decode_frame_header(AVCodecContext *ctx,
             AVFrame *ref = s->s.refs[s->s.h.refidx[i]].f;
             int refw = ref->width, refh = ref->height;
 
-            if (ref->format != ctx->pix_fmt) {
-                av_log(ctx, AV_LOG_ERROR,
+            if (ref->format != avctx->pix_fmt) {
+                av_log(avctx, AV_LOG_ERROR,
                        "Ref pixfmt (%s) did not match current frame (%s)",
                        av_get_pix_fmt_name(ref->format),
-                       av_get_pix_fmt_name(ctx->pix_fmt));
+                       av_get_pix_fmt_name(avctx->pix_fmt));
                 return AVERROR_INVALIDDATA;
             } else if (refw == w && refh == h) {
                 s->mvscale[i][0] = s->mvscale[i][1] = 0;
             } else {
                 if (w * 2 < refw || h * 2 < refh || w > 16 * refw || h > 16 * refh) {
-                    av_log(ctx, AV_LOG_ERROR,
+                    av_log(avctx, AV_LOG_ERROR,
                            "Invalid ref frame dimensions %dx%d for frame size %dx%d\n",
                            refw, refh, w, h);
                     return AVERROR_INVALIDDATA;
@@ -820,19 +809,19 @@ static int decode_frame_header(AVCodecContext *ctx,
 
     if (s->s.h.keyframe || s->s.h.errorres || (s->s.h.intraonly && s->s.h.resetctx == 3)) {
         s->prob_ctx[0].p = s->prob_ctx[1].p = s->prob_ctx[2].p =
-                           s->prob_ctx[3].p = vp9_default_probs;
-        memcpy(s->prob_ctx[0].coef, vp9_default_coef_probs,
-               sizeof(vp9_default_coef_probs));
-        memcpy(s->prob_ctx[1].coef, vp9_default_coef_probs,
-               sizeof(vp9_default_coef_probs));
-        memcpy(s->prob_ctx[2].coef, vp9_default_coef_probs,
-               sizeof(vp9_default_coef_probs));
-        memcpy(s->prob_ctx[3].coef, vp9_default_coef_probs,
-               sizeof(vp9_default_coef_probs));
+                           s->prob_ctx[3].p = ff_vp9_default_probs;
+        memcpy(s->prob_ctx[0].coef, ff_vp9_default_coef_probs,
+               sizeof(ff_vp9_default_coef_probs));
+        memcpy(s->prob_ctx[1].coef, ff_vp9_default_coef_probs,
+               sizeof(ff_vp9_default_coef_probs));
+        memcpy(s->prob_ctx[2].coef, ff_vp9_default_coef_probs,
+               sizeof(ff_vp9_default_coef_probs));
+        memcpy(s->prob_ctx[3].coef, ff_vp9_default_coef_probs,
+               sizeof(ff_vp9_default_coef_probs));
     } else if (s->s.h.intraonly && s->s.h.resetctx == 2) {
-        s->prob_ctx[c].p = vp9_default_probs;
-        memcpy(s->prob_ctx[c].coef, vp9_default_coef_probs,
-               sizeof(vp9_default_coef_probs));
+        s->prob_ctx[c].p = ff_vp9_default_probs;
+        memcpy(s->prob_ctx[c].coef, ff_vp9_default_coef_probs,
+               sizeof(ff_vp9_default_coef_probs));
     }
 
     // next 16 bits is size of the rest of the header (arith-coded)
@@ -841,24 +830,30 @@ static int decode_frame_header(AVCodecContext *ctx,
 
     data2 = align_get_bits(&s->gb);
     if (size2 > size - (data2 - data)) {
-        av_log(ctx, AV_LOG_ERROR, "Invalid compressed header size\n");
+        av_log(avctx, AV_LOG_ERROR, "Invalid compressed header size\n");
         return AVERROR_INVALIDDATA;
     }
-    ff_vp56_init_range_decoder(&s->c, data2, size2);
+    ret = ff_vp56_init_range_decoder(&s->c, data2, size2);
+    if (ret < 0)
+        return ret;
+
     if (vp56_rac_get_prob_branchy(&s->c, 128)) { // marker bit
-        av_log(ctx, AV_LOG_ERROR, "Marker bit was set\n");
+        av_log(avctx, AV_LOG_ERROR, "Marker bit was set\n");
         return AVERROR_INVALIDDATA;
     }
 
-    if (s->s.h.keyframe || s->s.h.intraonly) {
-        memset(s->counts.coef, 0, sizeof(s->counts.coef));
-        memset(s->counts.eob,  0, sizeof(s->counts.eob));
-    } else {
-        memset(&s->counts, 0, sizeof(s->counts));
+    for (i = 0; i < s->active_tile_cols; i++) {
+        if (s->s.h.keyframe || s->s.h.intraonly) {
+            memset(s->td[i].counts.coef, 0, sizeof(s->td[0].counts.coef));
+            memset(s->td[i].counts.eob,  0, sizeof(s->td[0].counts.eob));
+        } else {
+            memset(&s->td[i].counts, 0, sizeof(s->td[0].counts));
+        }
     }
-    // FIXME is it faster to not copy here, but do it down in the fw updates
-    // as explicit copies if the fw update is missing (and skip the copy upon
-    // fw update)?
+
+    /* FIXME is it faster to not copy here, but do it down in the fw updates
+     * as explicit copies if the fw update is missing (and skip the copy upon
+     * fw update)? */
     s->prob.p = s->prob_ctx[c].p;
 
     // txfm updates
@@ -899,13 +894,12 @@ static int decode_frame_header(AVCodecContext *ctx,
                             if (m >= 3 && l == 0) // dc only has 3 pt
                                 break;
                             for (n = 0; n < 3; n++) {
-                                if (vp56_rac_get_prob_branchy(&s->c, 252)) {
+                                if (vp56_rac_get_prob_branchy(&s->c, 252))
                                     p[n] = update_prob(&s->c, r[n]);
-                                } else {
+                                else
                                     p[n] = r[n];
-                                }
                             }
-                            p[3] = 0;
+                            memcpy(&p[3], ff_vp9_model_pareto8[p[2]], 8);
                         }
         } else {
             for (j = 0; j < 2; j++)
@@ -917,7 +911,7 @@ static int decode_frame_header(AVCodecContext *ctx,
                             if (m > 3 && l == 0) // dc only has 3 pt
                                 break;
                             memcpy(p, r, 3);
-                            p[3] = 0;
+                            memcpy(&p[3], ff_vp9_model_pareto8[p[2]], 8);
                         }
         }
         if (s->s.h.txfmmode == i)
@@ -988,7 +982,8 @@ static int decode_frame_header(AVCodecContext *ctx,
                 for (k = 0; k < 3; k++)
                     if (vp56_rac_get_prob_branchy(&s->c, 252))
                         s->prob.p.partition[3 - i][j][k] =
-                            update_prob(&s->c, s->prob.p.partition[3 - i][j][k]);
+                            update_prob(&s->c,
+                                        s->prob.p.partition[3 - i][j][k]);
 
         // mv fields don't use the update_prob subexp model for some reason
         for (i = 0; i < 3; i++)
@@ -997,7 +992,8 @@ static int decode_frame_header(AVCodecContext *ctx,
 
         for (i = 0; i < 2; i++) {
             if (vp56_rac_get_prob_branchy(&s->c, 252))
-                s->prob.p.mv_comp[i].sign = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
+                s->prob.p.mv_comp[i].sign =
+                    (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
             for (j = 0; j < 10; j++)
                 if (vp56_rac_get_prob_branchy(&s->c, 252))
@@ -1005,7 +1001,8 @@ static int decode_frame_header(AVCodecContext *ctx,
                         (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
             if (vp56_rac_get_prob_branchy(&s->c, 252))
-                s->prob.p.mv_comp[i].class0 = (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
+                s->prob.p.mv_comp[i].class0 =
+                    (vp8_rac_get_uint(&s->c, 7) << 1) | 1;
 
             for (j = 0; j < 10; j++)
                 if (vp56_rac_get_prob_branchy(&s->c, 252))
@@ -1042,2955 +1039,438 @@ static int decode_frame_header(AVCodecContext *ctx,
     return (data2 - data) + size2;
 }
 
-static av_always_inline void clamp_mv(VP56mv *dst, const VP56mv *src,
-                                      VP9Context *s)
-{
-    dst->x = av_clip(src->x, s->min_mv.x, s->max_mv.x);
-    dst->y = av_clip(src->y, s->min_mv.y, s->max_mv.y);
-}
-
-static void find_ref_mvs(VP9Context *s,
-                         VP56mv *pmv, int ref, int z, int idx, int sb)
+static void decode_sb(VP9TileData *td, int row, int col, VP9Filter *lflvl,
+                      ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
 {
-    static const int8_t mv_ref_blk_off[N_BS_SIZES][8][2] = {
-        [BS_64x64] = {{  3, -1 }, { -1,  3 }, {  4, -1 }, { -1,  4 },
-                      { -1, -1 }, {  0, -1 }, { -1,  0 }, {  6, -1 }},
-        [BS_64x32] = {{  0, -1 }, { -1,  0 }, {  4, -1 }, { -1,  2 },
-                      { -1, -1 }, {  0, -3 }, { -3,  0 }, {  2, -1 }},
-        [BS_32x64] = {{ -1,  0 }, {  0, -1 }, { -1,  4 }, {  2, -1 },
-                      { -1, -1 }, { -3,  0 }, {  0, -3 }, { -1,  2 }},
-        [BS_32x32] = {{  1, -1 }, { -1,  1 }, {  2, -1 }, { -1,  2 },
-                      { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 }},
-        [BS_32x16] = {{  0, -1 }, { -1,  0 }, {  2, -1 }, { -1, -1 },
-                      { -1,  1 }, {  0, -3 }, { -3,  0 }, { -3, -3 }},
-        [BS_16x32] = {{ -1,  0 }, {  0, -1 }, { -1,  2 }, { -1, -1 },
-                      {  1, -1 }, { -3,  0 }, {  0, -3 }, { -3, -3 }},
-        [BS_16x16] = {{  0, -1 }, { -1,  0 }, {  1, -1 }, { -1,  1 },
-                      { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 }},
-        [BS_16x8]  = {{  0, -1 }, { -1,  0 }, {  1, -1 }, { -1, -1 },
-                      {  0, -2 }, { -2,  0 }, { -2, -1 }, { -1, -2 }},
-        [BS_8x16]  = {{ -1,  0 }, {  0, -1 }, { -1,  1 }, { -1, -1 },
-                      { -2,  0 }, {  0, -2 }, { -1, -2 }, { -2, -1 }},
-        [BS_8x8]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
-                      { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
-        [BS_8x4]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
-                      { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
-        [BS_4x8]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
-                      { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
-        [BS_4x4]   = {{  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
-                      { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 }},
-    };
-    VP9Block *b = s->b;
-    int row = s->row, col = s->col, row7 = s->row7;
-    const int8_t (*p)[2] = mv_ref_blk_off[b->bs];
-#define INVALID_MV 0x80008000U
-    uint32_t mem = INVALID_MV, mem_sub8x8 = INVALID_MV;
-    int i;
-
-#define RETURN_DIRECT_MV(mv) \
-    do { \
-        uint32_t m = AV_RN32A(&mv); \
-        if (!idx) { \
-            AV_WN32A(pmv, m); \
-            return; \
-        } else if (mem == INVALID_MV) { \
-            mem = m; \
-        } else if (m != mem) { \
-            AV_WN32A(pmv, m); \
-            return; \
-        } \
-    } while (0)
-
-    if (sb >= 0) {
-        if (sb == 2 || sb == 1) {
-            RETURN_DIRECT_MV(b->mv[0][z]);
-        } else if (sb == 3) {
-            RETURN_DIRECT_MV(b->mv[2][z]);
-            RETURN_DIRECT_MV(b->mv[1][z]);
-            RETURN_DIRECT_MV(b->mv[0][z]);
-        }
+    const VP9Context *s = td->s;
+    int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
+            (((td->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);
+    const uint8_t *p = s->s.h.keyframe || s->s.h.intraonly ? ff_vp9_default_kf_partition_probs[bl][c] :
+                                                     s->prob.p.partition[bl][c];
+    enum BlockPartition bp;
+    ptrdiff_t hbs = 4 >> bl;
+    AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
+    ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
+    int bytesperpixel = s->bytesperpixel;
 
-#define RETURN_MV(mv) \
-    do { \
-        if (sb > 0) { \
-            VP56mv tmp; \
-            uint32_t m; \
-            av_assert2(idx == 1); \
-            av_assert2(mem != INVALID_MV); \
-            if (mem_sub8x8 == INVALID_MV) { \
-                clamp_mv(&tmp, &mv, s); \
-                m = AV_RN32A(&tmp); \
-                if (m != mem) { \
-                    AV_WN32A(pmv, m); \
-                    return; \
-                } \
-                mem_sub8x8 = AV_RN32A(&mv); \
-            } else if (mem_sub8x8 != AV_RN32A(&mv)) { \
-                clamp_mv(&tmp, &mv, s); \
-                m = AV_RN32A(&tmp); \
-                if (m != mem) { \
-                    AV_WN32A(pmv, m); \
-                } else { \
-                    /* BUG I'm pretty sure this isn't the intention */ \
-                    AV_WN32A(pmv, 0); \
-                } \
-                return; \
-            } \
-        } else { \
-            uint32_t m = AV_RN32A(&mv); \
-            if (!idx) { \
-                clamp_mv(pmv, &mv, s); \
-                return; \
-            } else if (mem == INVALID_MV) { \
-                mem = m; \
-            } else if (m != mem) { \
-                clamp_mv(pmv, &mv, s); \
-                return; \
-            } \
-        } \
-    } while (0)
-
-        if (row > 0) {
-            struct VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[(row - 1) * s->sb_cols * 8 + col];
-            if (mv->ref[0] == ref) {
-                RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][0]);
-            } else if (mv->ref[1] == ref) {
-                RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][1]);
+    if (bl == BL_8X8) {
+        bp = vp8_rac_get_tree(td->c, ff_vp9_partition_tree, p);
+        ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
+    } else if (col + hbs < s->cols) { // FIXME why not <=?
+        if (row + hbs < s->rows) { // FIXME why not <=?
+            bp = vp8_rac_get_tree(td->c, ff_vp9_partition_tree, p);
+            switch (bp) {
+            case PARTITION_NONE:
+                ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
+                break;
+            case PARTITION_H:
+                ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
+                yoff  += hbs * 8 * y_stride;
+                uvoff += hbs * 8 * uv_stride >> s->ss_v;
+                ff_vp9_decode_block(td, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
+                break;
+            case PARTITION_V:
+                ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
+                yoff  += hbs * 8 * bytesperpixel;
+                uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
+                ff_vp9_decode_block(td, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
+                break;
+            case PARTITION_SPLIT:
+                decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
+                decode_sb(td, row, col + hbs, lflvl,
+                          yoff + 8 * hbs * bytesperpixel,
+                          uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
+                yoff  += hbs * 8 * y_stride;
+                uvoff += hbs * 8 * uv_stride >> s->ss_v;
+                decode_sb(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
+                decode_sb(td, row + hbs, col + hbs, lflvl,
+                          yoff + 8 * hbs * bytesperpixel,
+                          uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
+                break;
+            default:
+                av_assert0(0);
             }
+        } else if (vp56_rac_get_prob_branchy(td->c, p[1])) {
+            bp = PARTITION_SPLIT;
+            decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
+            decode_sb(td, row, col + hbs, lflvl,
+                      yoff + 8 * hbs * bytesperpixel,
+                      uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
+        } else {
+            bp = PARTITION_H;
+            ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
         }
-        if (col > s->tile_col_start) {
-            struct VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[row * s->sb_cols * 8 + col - 1];
-            if (mv->ref[0] == ref) {
-                RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][0]);
-            } else if (mv->ref[1] == ref) {
-                RETURN_MV(s->left_mv_ctx[2 * row7 + (sb >> 1)][1]);
-            }
+    } else if (row + hbs < s->rows) { // FIXME why not <=?
+        if (vp56_rac_get_prob_branchy(td->c, p[2])) {
+            bp = PARTITION_SPLIT;
+            decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
+            yoff  += hbs * 8 * y_stride;
+            uvoff += hbs * 8 * uv_stride >> s->ss_v;
+            decode_sb(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
+        } else {
+            bp = PARTITION_V;
+            ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, bl, bp);
         }
-        i = 2;
     } else {
-        i = 0;
+        bp = PARTITION_SPLIT;
+        decode_sb(td, row, col, lflvl, yoff, uvoff, bl + 1);
     }
+    td->counts.partition[bl][c][bp]++;
+}
 
-    // previously coded MVs in this neighbourhood, using same reference frame
-    for (; i < 8; i++) {
-        int c = p[i][0] + col, r = p[i][1] + row;
-
-        if (c >= s->tile_col_start && c < s->cols && r >= 0 && r < s->rows) {
-            struct VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
+static void decode_sb_mem(VP9TileData *td, int row, int col, VP9Filter *lflvl,
+                          ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
+{
+    const VP9Context *s = td->s;
+    VP9Block *b = td->b;
+    ptrdiff_t hbs = 4 >> bl;
+    AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
+    ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
+    int bytesperpixel = s->bytesperpixel;
 
-            if (mv->ref[0] == ref) {
-                RETURN_MV(mv->mv[0]);
-            } else if (mv->ref[1] == ref) {
-                RETURN_MV(mv->mv[1]);
-            }
+    if (bl == BL_8X8) {
+        av_assert2(b->bl == BL_8X8);
+        ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
+    } else if (td->b->bl == bl) {
+        ff_vp9_decode_block(td, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
+        if (b->bp == PARTITION_H && row + hbs < s->rows) {
+            yoff  += hbs * 8 * y_stride;
+            uvoff += hbs * 8 * uv_stride >> s->ss_v;
+            ff_vp9_decode_block(td, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
+        } else if (b->bp == PARTITION_V && col + hbs < s->cols) {
+            yoff  += hbs * 8 * bytesperpixel;
+            uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
+            ff_vp9_decode_block(td, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
         }
-    }
-
-    // MV at this position in previous frame, using same reference frame
-    if (s->s.h.use_last_frame_mvs) {
-        struct VP9mvrefPair *mv = &s->s.frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
-
-        if (!s->s.frames[REF_FRAME_MVPAIR].uses_2pass)
-            ff_thread_await_progress(&s->s.frames[REF_FRAME_MVPAIR].tf, row >> 3, 0);
-        if (mv->ref[0] == ref) {
-            RETURN_MV(mv->mv[0]);
-        } else if (mv->ref[1] == ref) {
-            RETURN_MV(mv->mv[1]);
+    } else {
+        decode_sb_mem(td, row, col, lflvl, yoff, uvoff, bl + 1);
+        if (col + hbs < s->cols) { // FIXME why not <=?
+            if (row + hbs < s->rows) {
+                decode_sb_mem(td, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
+                              uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
+                yoff  += hbs * 8 * y_stride;
+                uvoff += hbs * 8 * uv_stride >> s->ss_v;
+                decode_sb_mem(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
+                decode_sb_mem(td, row + hbs, col + hbs, lflvl,
+                              yoff + 8 * hbs * bytesperpixel,
+                              uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
+            } else {
+                yoff  += hbs * 8 * bytesperpixel;
+                uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
+                decode_sb_mem(td, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
+            }
+        } else if (row + hbs < s->rows) {
+            yoff  += hbs * 8 * y_stride;
+            uvoff += hbs * 8 * uv_stride >> s->ss_v;
+            decode_sb_mem(td, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
         }
     }
+}
 
-#define RETURN_SCALE_MV(mv, scale) \
-    do { \
-        if (scale) { \
-            VP56mv mv_temp = { -mv.x, -mv.y }; \
-            RETURN_MV(mv_temp); \
-        } else { \
-            RETURN_MV(mv); \
-        } \
-    } while (0)
-
-    // previously coded MVs in this neighbourhood, using different reference frame
-    for (i = 0; i < 8; i++) {
-        int c = p[i][0] + col, r = p[i][1] + row;
+static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
+{
+    int sb_start = ( idx      * n) >> log2_n;
+    int sb_end   = ((idx + 1) * n) >> log2_n;
+    *start = FFMIN(sb_start, n) << 3;
+    *end   = FFMIN(sb_end,   n) << 3;
+}
 
-        if (c >= s->tile_col_start && c < s->cols && r >= 0 && r < s->rows) {
-            struct VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
+static void free_buffers(VP9Context *s)
+{
+    int i;
 
-            if (mv->ref[0] != ref && mv->ref[0] >= 0) {
-                RETURN_SCALE_MV(mv->mv[0], s->s.h.signbias[mv->ref[0]] != s->s.h.signbias[ref]);
-            }
-            if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
-                // BUG - libvpx has this condition regardless of whether
-                // we used the first ref MV and pre-scaling
-                AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
-                RETURN_SCALE_MV(mv->mv[1], s->s.h.signbias[mv->ref[1]] != s->s.h.signbias[ref]);
-            }
-        }
+    av_freep(&s->intra_pred_data[0]);
+    for (i = 0; i < s->active_tile_cols; i++) {
+        av_freep(&s->td[i].b_base);
+        av_freep(&s->td[i].block_base);
     }
+}
 
-    // MV at this position in previous frame, using different reference frame
-    if (s->s.h.use_last_frame_mvs) {
-        struct VP9mvrefPair *mv = &s->s.frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
+static av_cold int vp9_decode_free(AVCodecContext *avctx)
+{
+    VP9Context *s = avctx->priv_data;
+    int i;
 
-        // no need to await_progress, because we already did that above
-        if (mv->ref[0] != ref && mv->ref[0] >= 0) {
-            RETURN_SCALE_MV(mv->mv[0], s->s.h.signbias[mv->ref[0]] != s->s.h.signbias[ref]);
-        }
-        if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
-            // BUG - libvpx has this condition regardless of whether
-            // we used the first ref MV and pre-scaling
-            AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
-            RETURN_SCALE_MV(mv->mv[1], s->s.h.signbias[mv->ref[1]] != s->s.h.signbias[ref]);
-        }
+    for (i = 0; i < 3; i++) {
+        if (s->s.frames[i].tf.f->buf[0])
+            vp9_frame_unref(avctx, &s->s.frames[i]);
+        av_frame_free(&s->s.frames[i].tf.f);
+    }
+    for (i = 0; i < 8; i++) {
+        if (s->s.refs[i].f->buf[0])
+            ff_thread_release_buffer(avctx, &s->s.refs[i]);
+        av_frame_free(&s->s.refs[i].f);
+        if (s->next_refs[i].f->buf[0])
+            ff_thread_release_buffer(avctx, &s->next_refs[i]);
+        av_frame_free(&s->next_refs[i].f);
     }
 
-    AV_ZERO32(pmv);
-    clamp_mv(pmv, pmv, s);
-#undef INVALID_MV
-#undef RETURN_MV
-#undef RETURN_SCALE_MV
+    free_buffers(s);
+    vp9_free_entries(avctx);
+    av_freep(&s->td);
+    return 0;
 }
 
-static av_always_inline int read_mv_component(VP9Context *s, int idx, int hp)
+static int decode_tiles(AVCodecContext *avctx,
+                        const uint8_t *data, int size)
 {
-    int bit, sign = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].sign);
-    int n, c = vp8_rac_get_tree(&s->c, vp9_mv_class_tree,
-                                s->prob.p.mv_comp[idx].classes);
-
-    s->counts.mv_comp[idx].sign[sign]++;
-    s->counts.mv_comp[idx].classes[c]++;
-    if (c) {
-        int m;
-
-        for (n = 0, m = 0; m < c; m++) {
-            bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].bits[m]);
-            n |= bit << m;
-            s->counts.mv_comp[idx].bits[m][bit]++;
-        }
-        n <<= 3;
-        bit = vp8_rac_get_tree(&s->c, vp9_mv_fp_tree, s->prob.p.mv_comp[idx].fp);
-        n |= bit << 1;
-        s->counts.mv_comp[idx].fp[bit]++;
-        if (hp) {
-            bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].hp);
-            s->counts.mv_comp[idx].hp[bit]++;
-            n |= bit;
-        } else {
-            n |= 1;
-            // bug in libvpx - we count for bw entropy purposes even if the
-            // bit wasn't coded
-            s->counts.mv_comp[idx].hp[1]++;
-        }
-        n += 8 << c;
-    } else {
-        n = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0);
-        s->counts.mv_comp[idx].class0[n]++;
-        bit = vp8_rac_get_tree(&s->c, vp9_mv_fp_tree,
-                               s->prob.p.mv_comp[idx].class0_fp[n]);
-        s->counts.mv_comp[idx].class0_fp[n][bit]++;
-        n = (n << 3) | (bit << 1);
-        if (hp) {
-            bit = vp56_rac_get_prob(&s->c, s->prob.p.mv_comp[idx].class0_hp);
-            s->counts.mv_comp[idx].class0_hp[bit]++;
-            n |= bit;
-        } else {
-            n |= 1;
-            // bug in libvpx - we count for bw entropy purposes even if the
-            // bit wasn't coded
-            s->counts.mv_comp[idx].class0_hp[1]++;
-        }
-    }
+    VP9Context *s = avctx->priv_data;
+    VP9TileData *td = &s->td[0];
+    int row, col, tile_row, tile_col, ret;
+    int bytesperpixel;
+    int tile_row_start, tile_row_end, tile_col_start, tile_col_end;
+    AVFrame *f;
+    ptrdiff_t yoff, uvoff, ls_y, ls_uv;
 
-    return sign ? -(n + 1) : (n + 1);
-}
+    f = s->s.frames[CUR_FRAME].tf.f;
+    ls_y = f->linesize[0];
+    ls_uv =f->linesize[1];
+    bytesperpixel = s->bytesperpixel;
 
-static void fill_mv(VP9Context *s,
-                    VP56mv *mv, int mode, int sb)
-{
-    VP9Block *b = s->b;
+    yoff = uvoff = 0;
+    for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
+        set_tile_offset(&tile_row_start, &tile_row_end,
+                        tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
 
-    if (mode == ZEROMV) {
-        AV_ZERO64(mv);
-    } else {
-        int hp;
-
-        // FIXME cache this value and reuse for other subblocks
-        find_ref_mvs(s, &mv[0], b->ref[0], 0, mode == NEARMV,
-                     mode == NEWMV ? -1 : sb);
-        // FIXME maybe move this code into find_ref_mvs()
-        if ((mode == NEWMV || sb == -1) &&
-            !(hp = s->s.h.highprecisionmvs && abs(mv[0].x) < 64 && abs(mv[0].y) < 64)) {
-            if (mv[0].y & 1) {
-                if (mv[0].y < 0)
-                    mv[0].y++;
-                else
-                    mv[0].y--;
+        for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
+            int64_t tile_size;
+
+            if (tile_col == s->s.h.tiling.tile_cols - 1 &&
+                tile_row == s->s.h.tiling.tile_rows - 1) {
+                tile_size = size;
+            } else {
+                tile_size = AV_RB32(data);
+                data += 4;
+                size -= 4;
+            }
+            if (tile_size > size) {
+                ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
+                return AVERROR_INVALIDDATA;
             }
-            if (mv[0].x & 1) {
-                if (mv[0].x < 0)
-                    mv[0].x++;
-                else
-                    mv[0].x--;
+            ret = ff_vp56_init_range_decoder(&td->c_b[tile_col], data, tile_size);
+            if (ret < 0)
+                return ret;
+            if (vp56_rac_get_prob_branchy(&td->c_b[tile_col], 128)) { // marker bit
+                ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
+                return AVERROR_INVALIDDATA;
             }
+            data += tile_size;
+            size -= tile_size;
         }
-        if (mode == NEWMV) {
-            enum MVJoint j = vp8_rac_get_tree(&s->c, vp9_mv_joint_tree,
-                                              s->prob.p.mv_joint);
-
-            s->counts.mv_joint[j]++;
-            if (j >= MV_JOINT_V)
-                mv[0].y += read_mv_component(s, 0, hp);
-            if (j & 1)
-                mv[0].x += read_mv_component(s, 1, hp);
-        }
 
-        if (b->comp) {
-            // FIXME cache this value and reuse for other subblocks
-            find_ref_mvs(s, &mv[1], b->ref[1], 1, mode == NEARMV,
-                         mode == NEWMV ? -1 : sb);
-            if ((mode == NEWMV || sb == -1) &&
-                !(hp = s->s.h.highprecisionmvs && abs(mv[1].x) < 64 && abs(mv[1].y) < 64)) {
-                if (mv[1].y & 1) {
-                    if (mv[1].y < 0)
-                        mv[1].y++;
-                    else
-                        mv[1].y--;
+        for (row = tile_row_start; row < tile_row_end;
+             row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
+            VP9Filter *lflvl_ptr = s->lflvl;
+            ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
+
+            for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
+                set_tile_offset(&tile_col_start, &tile_col_end,
+                                tile_col, s->s.h.tiling.log2_tile_cols, s->sb_cols);
+                td->tile_col_start = tile_col_start;
+                if (s->pass != 2) {
+                    memset(td->left_partition_ctx, 0, 8);
+                    memset(td->left_skip_ctx, 0, 8);
+                    if (s->s.h.keyframe || s->s.h.intraonly) {
+                        memset(td->left_mode_ctx, DC_PRED, 16);
+                    } else {
+                        memset(td->left_mode_ctx, NEARESTMV, 8);
+                    }
+                    memset(td->left_y_nnz_ctx, 0, 16);
+                    memset(td->left_uv_nnz_ctx, 0, 32);
+                    memset(td->left_segpred_ctx, 0, 8);
+
+                    td->c = &td->c_b[tile_col];
                 }
-                if (mv[1].x & 1) {
-                    if (mv[1].x < 0)
-                        mv[1].x++;
-                    else
-                        mv[1].x--;
+
+                for (col = tile_col_start;
+                     col < tile_col_end;
+                     col += 8, yoff2 += 64 * bytesperpixel,
+                     uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
+                    // FIXME integrate with lf code (i.e. zero after each
+                    // use, similar to invtxfm coefficients, or similar)
+                    if (s->pass != 1) {
+                        memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
+                    }
+
+                    if (s->pass == 2) {
+                        decode_sb_mem(td, row, col, lflvl_ptr,
+                                      yoff2, uvoff2, BL_64X64);
+                    } else {
+                        decode_sb(td, row, col, lflvl_ptr,
+                                  yoff2, uvoff2, BL_64X64);
+                    }
                 }
             }
-            if (mode == NEWMV) {
-                enum MVJoint j = vp8_rac_get_tree(&s->c, vp9_mv_joint_tree,
-                                                  s->prob.p.mv_joint);
-
-                s->counts.mv_joint[j]++;
-                if (j >= MV_JOINT_V)
-                    mv[1].y += read_mv_component(s, 0, hp);
-                if (j & 1)
-                    mv[1].x += read_mv_component(s, 1, hp);
+
+            if (s->pass == 1)
+                continue;
+
+            // backup pre-loopfilter reconstruction data for intra
+            // prediction of next row of sb64s
+            if (row + 8 < s->rows) {
+                memcpy(s->intra_pred_data[0],
+                       f->data[0] + yoff + 63 * ls_y,
+                       8 * s->cols * bytesperpixel);
+                memcpy(s->intra_pred_data[1],
+                       f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
+                       8 * s->cols * bytesperpixel >> s->ss_h);
+                memcpy(s->intra_pred_data[2],
+                       f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
+                       8 * s->cols * bytesperpixel >> s->ss_h);
+            }
+
+            // loopfilter one row
+            if (s->s.h.filter.level) {
+                yoff2 = yoff;
+                uvoff2 = uvoff;
+                lflvl_ptr = s->lflvl;
+                for (col = 0; col < s->cols;
+                     col += 8, yoff2 += 64 * bytesperpixel,
+                     uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
+                    ff_vp9_loopfilter_sb(avctx, lflvl_ptr, row, col,
+                                         yoff2, uvoff2);
+                }
             }
-        }
-    }
-}
 
-static av_always_inline void setctx_2d(uint8_t *ptr, int w, int h,
-                                       ptrdiff_t stride, int v)
-{
-    switch (w) {
-    case 1:
-        do {
-            *ptr = v;
-            ptr += stride;
-        } while (--h);
-        break;
-    case 2: {
-        int v16 = v * 0x0101;
-        do {
-            AV_WN16A(ptr, v16);
-            ptr += stride;
-        } while (--h);
-        break;
-    }
-    case 4: {
-        uint32_t v32 = v * 0x01010101;
-        do {
-            AV_WN32A(ptr, v32);
-            ptr += stride;
-        } while (--h);
-        break;
-    }
-    case 8: {
-#if HAVE_FAST_64BIT
-        uint64_t v64 = v * 0x0101010101010101ULL;
-        do {
-            AV_WN64A(ptr, v64);
-            ptr += stride;
-        } while (--h);
-#else
-        uint32_t v32 = v * 0x01010101;
-        do {
-            AV_WN32A(ptr,     v32);
-            AV_WN32A(ptr + 4, v32);
-            ptr += stride;
-        } while (--h);
-#endif
-        break;
-    }
+            // FIXME maybe we can make this more finegrained by running the
+            // loopfilter per-block instead of after each sbrow
+            // In fact that would also make intra pred left preparation easier?
+            ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, row >> 3, 0);
+        }
     }
+    return 0;
 }
 
-static void decode_mode(AVCodecContext *ctx)
+#if HAVE_THREADS
+static av_always_inline
+int decode_tiles_mt(AVCodecContext *avctx, void *tdata, int jobnr,
+                              int threadnr)
 {
-    static const uint8_t left_ctx[N_BS_SIZES] = {
-        0x0, 0x8, 0x0, 0x8, 0xc, 0x8, 0xc, 0xe, 0xc, 0xe, 0xf, 0xe, 0xf
-    };
-    static const uint8_t above_ctx[N_BS_SIZES] = {
-        0x0, 0x0, 0x8, 0x8, 0x8, 0xc, 0xc, 0xc, 0xe, 0xe, 0xe, 0xf, 0xf
-    };
-    static const uint8_t max_tx_for_bl_bp[N_BS_SIZES] = {
-        TX_32X32, TX_32X32, TX_32X32, TX_32X32, TX_16X16, TX_16X16,
-        TX_16X16, TX_8X8, TX_8X8, TX_8X8, TX_4X4, TX_4X4, TX_4X4
-    };
-    VP9Context *s = ctx->priv_data;
-    VP9Block *b = s->b;
-    int row = s->row, col = s->col, row7 = s->row7;
-    enum TxfmMode max_tx = max_tx_for_bl_bp[b->bs];
-    int bw4 = bwh_tab[1][b->bs][0], w4 = FFMIN(s->cols - col, bw4);
-    int bh4 = bwh_tab[1][b->bs][1], h4 = FFMIN(s->rows - row, bh4), y;
-    int have_a = row > 0, have_l = col > s->tile_col_start;
-    int vref, filter_id;
-
-    if (!s->s.h.segmentation.enabled) {
-        b->seg_id = 0;
-    } else if (s->s.h.keyframe || s->s.h.intraonly) {
-        b->seg_id = !s->s.h.segmentation.update_map ? 0 :
-                    vp8_rac_get_tree(&s->c, vp9_segmentation_tree, s->s.h.segmentation.prob);
-    } else if (!s->s.h.segmentation.update_map ||
-               (s->s.h.segmentation.temporal &&
-                vp56_rac_get_prob_branchy(&s->c,
-                    s->s.h.segmentation.pred_prob[s->above_segpred_ctx[col] +
-                                    s->left_segpred_ctx[row7]]))) {
-        if (!s->s.h.errorres && s->s.frames[REF_FRAME_SEGMAP].segmentation_map) {
-            int pred = 8, x;
-            uint8_t *refsegmap = s->s.frames[REF_FRAME_SEGMAP].segmentation_map;
-
-            if (!s->s.frames[REF_FRAME_SEGMAP].uses_2pass)
-                ff_thread_await_progress(&s->s.frames[REF_FRAME_SEGMAP].tf, row >> 3, 0);
-            for (y = 0; y < h4; y++) {
-                int idx_base = (y + row) * 8 * s->sb_cols + col;
-                for (x = 0; x < w4; x++)
-                    pred = FFMIN(pred, refsegmap[idx_base + x]);
-            }
-            av_assert1(pred < 8);
-            b->seg_id = pred;
-        } else {
-            b->seg_id = 0;
-        }
+    VP9Context *s = avctx->priv_data;
+    VP9TileData *td = &s->td[jobnr];
+    ptrdiff_t uvoff, yoff, ls_y, ls_uv;
+    int bytesperpixel = s->bytesperpixel, row, col, tile_row;
+    unsigned tile_cols_len;
+    int tile_row_start, tile_row_end, tile_col_start, tile_col_end;
+    VP9Filter *lflvl_ptr_base;
+    AVFrame *f;
 
-        memset(&s->above_segpred_ctx[col], 1, w4);
-        memset(&s->left_segpred_ctx[row7], 1, h4);
-    } else {
-        b->seg_id = vp8_rac_get_tree(&s->c, vp9_segmentation_tree,
-                                     s->s.h.segmentation.prob);
+    f = s->s.frames[CUR_FRAME].tf.f;
+    ls_y = f->linesize[0];
+    ls_uv =f->linesize[1];
 
-        memset(&s->above_segpred_ctx[col], 0, w4);
-        memset(&s->left_segpred_ctx[row7], 0, h4);
-    }
-    if (s->s.h.segmentation.enabled &&
-        (s->s.h.segmentation.update_map || s->s.h.keyframe || s->s.h.intraonly)) {
-        setctx_2d(&s->s.frames[CUR_FRAME].segmentation_map[row * 8 * s->sb_cols + col],
-                  bw4, bh4, 8 * s->sb_cols, b->seg_id);
-    }
+    set_tile_offset(&tile_col_start, &tile_col_end,
+                    jobnr, s->s.h.tiling.log2_tile_cols, s->sb_cols);
+    td->tile_col_start  = tile_col_start;
+    uvoff = (64 * bytesperpixel >> s->ss_h)*(tile_col_start >> 3);
+    yoff = (64 * bytesperpixel)*(tile_col_start >> 3);
+    lflvl_ptr_base = s->lflvl+(tile_col_start >> 3);
+
+    for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
+        set_tile_offset(&tile_row_start, &tile_row_end,
+                        tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
+
+        td->c = &td->c_b[tile_row];
+        for (row = tile_row_start; row < tile_row_end;
+             row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
+            ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
+            VP9Filter *lflvl_ptr = lflvl_ptr_base+s->sb_cols*(row >> 3);
+
+            memset(td->left_partition_ctx, 0, 8);
+            memset(td->left_skip_ctx, 0, 8);
+            if (s->s.h.keyframe || s->s.h.intraonly) {
+                memset(td->left_mode_ctx, DC_PRED, 16);
+            } else {
+                memset(td->left_mode_ctx, NEARESTMV, 8);
+            }
+            memset(td->left_y_nnz_ctx, 0, 16);
+            memset(td->left_uv_nnz_ctx, 0, 32);
+            memset(td->left_segpred_ctx, 0, 8);
 
-    b->skip = s->s.h.segmentation.enabled &&
-        s->s.h.segmentation.feat[b->seg_id].skip_enabled;
-    if (!b->skip) {
-        int c = s->left_skip_ctx[row7] + s->above_skip_ctx[col];
-        b->skip = vp56_rac_get_prob(&s->c, s->prob.p.skip[c]);
-        s->counts.skip[c][b->skip]++;
-    }
+            for (col = tile_col_start;
+                 col < tile_col_end;
+                 col += 8, yoff2 += 64 * bytesperpixel,
+                 uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
+                // FIXME integrate with lf code (i.e. zero after each
+                // use, similar to invtxfm coefficients, or similar)
+                memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
+                decode_sb(td, row, col, lflvl_ptr,
+                            yoff2, uvoff2, BL_64X64);
+            }
 
-    if (s->s.h.keyframe || s->s.h.intraonly) {
-        b->intra = 1;
-    } else if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].ref_enabled) {
-        b->intra = !s->s.h.segmentation.feat[b->seg_id].ref_val;
-    } else {
-        int c, bit;
+            // backup pre-loopfilter reconstruction data for intra
+            // prediction of next row of sb64s
+            tile_cols_len = tile_col_end - tile_col_start;
+            if (row + 8 < s->rows) {
+                memcpy(s->intra_pred_data[0] + (tile_col_start * 8 * bytesperpixel),
+                       f->data[0] + yoff + 63 * ls_y,
+                       8 * tile_cols_len * bytesperpixel);
+                memcpy(s->intra_pred_data[1] + (tile_col_start * 8 * bytesperpixel >> s->ss_h),
+                       f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
+                       8 * tile_cols_len * bytesperpixel >> s->ss_h);
+                memcpy(s->intra_pred_data[2] + (tile_col_start * 8 * bytesperpixel >> s->ss_h),
+                       f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
+                       8 * tile_cols_len * bytesperpixel >> s->ss_h);
+            }
 
-        if (have_a && have_l) {
-            c = s->above_intra_ctx[col] + s->left_intra_ctx[row7];
-            c += (c == 2);
-        } else {
-            c = have_a ? 2 * s->above_intra_ctx[col] :
-                have_l ? 2 * s->left_intra_ctx[row7] : 0;
-        }
-        bit = vp56_rac_get_prob(&s->c, s->prob.p.intra[c]);
-        s->counts.intra[c][bit]++;
-        b->intra = !bit;
-    }
-
-    if ((b->intra || !b->skip) && s->s.h.txfmmode == TX_SWITCHABLE) {
-        int c;
-        if (have_a) {
-            if (have_l) {
-                c = (s->above_skip_ctx[col] ? max_tx :
-                     s->above_txfm_ctx[col]) +
-                    (s->left_skip_ctx[row7] ? max_tx :
-                     s->left_txfm_ctx[row7]) > max_tx;
-            } else {
-                c = s->above_skip_ctx[col] ? 1 :
-                    (s->above_txfm_ctx[col] * 2 > max_tx);
-            }
-        } else if (have_l) {
-            c = s->left_skip_ctx[row7] ? 1 :
-                (s->left_txfm_ctx[row7] * 2 > max_tx);
-        } else {
-            c = 1;
-        }
-        switch (max_tx) {
-        case TX_32X32:
-            b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][0]);
-            if (b->tx) {
-                b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][1]);
-                if (b->tx == 2)
-                    b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx32p[c][2]);
-            }
-            s->counts.tx32p[c][b->tx]++;
-            break;
-        case TX_16X16:
-            b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx16p[c][0]);
-            if (b->tx)
-                b->tx += vp56_rac_get_prob(&s->c, s->prob.p.tx16p[c][1]);
-            s->counts.tx16p[c][b->tx]++;
-            break;
-        case TX_8X8:
-            b->tx = vp56_rac_get_prob(&s->c, s->prob.p.tx8p[c]);
-            s->counts.tx8p[c][b->tx]++;
-            break;
-        case TX_4X4:
-            b->tx = TX_4X4;
-            break;
-        }
-    } else {
-        b->tx = FFMIN(max_tx, s->s.h.txfmmode);
-    }
-
-    if (s->s.h.keyframe || s->s.h.intraonly) {
-        uint8_t *a = &s->above_mode_ctx[col * 2];
-        uint8_t *l = &s->left_mode_ctx[(row7) << 1];
-
-        b->comp = 0;
-        if (b->bs > BS_8x8) {
-            // FIXME the memory storage intermediates here aren't really
-            // necessary, they're just there to make the code slightly
-            // simpler for now
-            b->mode[0] = a[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                    vp9_default_kf_ymode_probs[a[0]][l[0]]);
-            if (b->bs != BS_8x4) {
-                b->mode[1] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                 vp9_default_kf_ymode_probs[a[1]][b->mode[0]]);
-                l[0] = a[1] = b->mode[1];
-            } else {
-                l[0] = a[1] = b->mode[1] = b->mode[0];
-            }
-            if (b->bs != BS_4x8) {
-                b->mode[2] = a[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                        vp9_default_kf_ymode_probs[a[0]][l[1]]);
-                if (b->bs != BS_8x4) {
-                    b->mode[3] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                  vp9_default_kf_ymode_probs[a[1]][b->mode[2]]);
-                    l[1] = a[1] = b->mode[3];
-                } else {
-                    l[1] = a[1] = b->mode[3] = b->mode[2];
-                }
-            } else {
-                b->mode[2] = b->mode[0];
-                l[1] = a[1] = b->mode[3] = b->mode[1];
-            }
-        } else {
-            b->mode[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                          vp9_default_kf_ymode_probs[*a][*l]);
-            b->mode[3] = b->mode[2] = b->mode[1] = b->mode[0];
-            // FIXME this can probably be optimized
-            memset(a, b->mode[0], bwh_tab[0][b->bs][0]);
-            memset(l, b->mode[0], bwh_tab[0][b->bs][1]);
-        }
-        b->uvmode = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                     vp9_default_kf_uvmode_probs[b->mode[3]]);
-    } else if (b->intra) {
-        b->comp = 0;
-        if (b->bs > BS_8x8) {
-            b->mode[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                          s->prob.p.y_mode[0]);
-            s->counts.y_mode[0][b->mode[0]]++;
-            if (b->bs != BS_8x4) {
-                b->mode[1] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                              s->prob.p.y_mode[0]);
-                s->counts.y_mode[0][b->mode[1]]++;
-            } else {
-                b->mode[1] = b->mode[0];
-            }
-            if (b->bs != BS_4x8) {
-                b->mode[2] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                              s->prob.p.y_mode[0]);
-                s->counts.y_mode[0][b->mode[2]]++;
-                if (b->bs != BS_8x4) {
-                    b->mode[3] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                                  s->prob.p.y_mode[0]);
-                    s->counts.y_mode[0][b->mode[3]]++;
-                } else {
-                    b->mode[3] = b->mode[2];
-                }
-            } else {
-                b->mode[2] = b->mode[0];
-                b->mode[3] = b->mode[1];
-            }
-        } else {
-            static const uint8_t size_group[10] = {
-                3, 3, 3, 3, 2, 2, 2, 1, 1, 1
-            };
-            int sz = size_group[b->bs];
-
-            b->mode[0] = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                          s->prob.p.y_mode[sz]);
-            b->mode[1] = b->mode[2] = b->mode[3] = b->mode[0];
-            s->counts.y_mode[sz][b->mode[3]]++;
-        }
-        b->uvmode = vp8_rac_get_tree(&s->c, vp9_intramode_tree,
-                                     s->prob.p.uv_mode[b->mode[3]]);
-        s->counts.uv_mode[b->mode[3]][b->uvmode]++;
-    } else {
-        static const uint8_t inter_mode_ctx_lut[14][14] = {
-            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
-            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
-            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
-            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
-            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
-            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
-            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
-            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
-            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
-            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
-            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 },
-            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 },
-            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 0, 3 },
-            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 3, 3, 4 },
-        };
-
-        if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].ref_enabled) {
-            av_assert2(s->s.h.segmentation.feat[b->seg_id].ref_val != 0);
-            b->comp = 0;
-            b->ref[0] = s->s.h.segmentation.feat[b->seg_id].ref_val - 1;
-        } else {
-            // read comp_pred flag
-            if (s->s.h.comppredmode != PRED_SWITCHABLE) {
-                b->comp = s->s.h.comppredmode == PRED_COMPREF;
-            } else {
-                int c;
-
-                // FIXME add intra as ref=0xff (or -1) to make these easier?
-                if (have_a) {
-                    if (have_l) {
-                        if (s->above_comp_ctx[col] && s->left_comp_ctx[row7]) {
-                            c = 4;
-                        } else if (s->above_comp_ctx[col]) {
-                            c = 2 + (s->left_intra_ctx[row7] ||
-                                     s->left_ref_ctx[row7] == s->s.h.fixcompref);
-                        } else if (s->left_comp_ctx[row7]) {
-                            c = 2 + (s->above_intra_ctx[col] ||
-                                     s->above_ref_ctx[col] == s->s.h.fixcompref);
-                        } else {
-                            c = (!s->above_intra_ctx[col] &&
-                                 s->above_ref_ctx[col] == s->s.h.fixcompref) ^
-                            (!s->left_intra_ctx[row7] &&
-                             s->left_ref_ctx[row & 7] == s->s.h.fixcompref);
-                        }
-                    } else {
-                        c = s->above_comp_ctx[col] ? 3 :
-                        (!s->above_intra_ctx[col] && s->above_ref_ctx[col] == s->s.h.fixcompref);
-                    }
-                } else if (have_l) {
-                    c = s->left_comp_ctx[row7] ? 3 :
-                    (!s->left_intra_ctx[row7] && s->left_ref_ctx[row7] == s->s.h.fixcompref);
-                } else {
-                    c = 1;
-                }
-                b->comp = vp56_rac_get_prob(&s->c, s->prob.p.comp[c]);
-                s->counts.comp[c][b->comp]++;
-            }
-
-            // read actual references
-            // FIXME probably cache a few variables here to prevent repetitive
-            // memory accesses below
-            if (b->comp) /* two references */ {
-                int fix_idx = s->s.h.signbias[s->s.h.fixcompref], var_idx = !fix_idx, c, bit;
-
-                b->ref[fix_idx] = s->s.h.fixcompref;
-                // FIXME can this codeblob be replaced by some sort of LUT?
-                if (have_a) {
-                    if (have_l) {
-                        if (s->above_intra_ctx[col]) {
-                            if (s->left_intra_ctx[row7]) {
-                                c = 2;
-                            } else {
-                                c = 1 + 2 * (s->left_ref_ctx[row7] != s->s.h.varcompref[1]);
-                            }
-                        } else if (s->left_intra_ctx[row7]) {
-                            c = 1 + 2 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]);
-                        } else {
-                            int refl = s->left_ref_ctx[row7], refa = s->above_ref_ctx[col];
-
-                            if (refl == refa && refa == s->s.h.varcompref[1]) {
-                                c = 0;
-                            } else if (!s->left_comp_ctx[row7] && !s->above_comp_ctx[col]) {
-                                if ((refa == s->s.h.fixcompref && refl == s->s.h.varcompref[0]) ||
-                                    (refl == s->s.h.fixcompref && refa == s->s.h.varcompref[0])) {
-                                    c = 4;
-                                } else {
-                                    c = (refa == refl) ? 3 : 1;
-                                }
-                            } else if (!s->left_comp_ctx[row7]) {
-                                if (refa == s->s.h.varcompref[1] && refl != s->s.h.varcompref[1]) {
-                                    c = 1;
-                                } else {
-                                    c = (refl == s->s.h.varcompref[1] &&
-                                         refa != s->s.h.varcompref[1]) ? 2 : 4;
-                                }
-                            } else if (!s->above_comp_ctx[col]) {
-                                if (refl == s->s.h.varcompref[1] && refa != s->s.h.varcompref[1]) {
-                                    c = 1;
-                                } else {
-                                    c = (refa == s->s.h.varcompref[1] &&
-                                         refl != s->s.h.varcompref[1]) ? 2 : 4;
-                                }
-                            } else {
-                                c = (refl == refa) ? 4 : 2;
-                            }
-                        }
-                    } else {
-                        if (s->above_intra_ctx[col]) {
-                            c = 2;
-                        } else if (s->above_comp_ctx[col]) {
-                            c = 4 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]);
-                        } else {
-                            c = 3 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]);
-                        }
-                    }
-                } else if (have_l) {
-                    if (s->left_intra_ctx[row7]) {
-                        c = 2;
-                    } else if (s->left_comp_ctx[row7]) {
-                        c = 4 * (s->left_ref_ctx[row7] != s->s.h.varcompref[1]);
-                    } else {
-                        c = 3 * (s->left_ref_ctx[row7] != s->s.h.varcompref[1]);
-                    }
-                } else {
-                    c = 2;
-                }
-                bit = vp56_rac_get_prob(&s->c, s->prob.p.comp_ref[c]);
-                b->ref[var_idx] = s->s.h.varcompref[bit];
-                s->counts.comp_ref[c][bit]++;
-            } else /* single reference */ {
-                int bit, c;
-
-                if (have_a && !s->above_intra_ctx[col]) {
-                    if (have_l && !s->left_intra_ctx[row7]) {
-                        if (s->left_comp_ctx[row7]) {
-                            if (s->above_comp_ctx[col]) {
-                                c = 1 + (!s->s.h.fixcompref || !s->left_ref_ctx[row7] ||
-                                         !s->above_ref_ctx[col]);
-                            } else {
-                                c = (3 * !s->above_ref_ctx[col]) +
-                                    (!s->s.h.fixcompref || !s->left_ref_ctx[row7]);
-                            }
-                        } else if (s->above_comp_ctx[col]) {
-                            c = (3 * !s->left_ref_ctx[row7]) +
-                                (!s->s.h.fixcompref || !s->above_ref_ctx[col]);
-                        } else {
-                            c = 2 * !s->left_ref_ctx[row7] + 2 * !s->above_ref_ctx[col];
-                        }
-                    } else if (s->above_intra_ctx[col]) {
-                        c = 2;
-                    } else if (s->above_comp_ctx[col]) {
-                        c = 1 + (!s->s.h.fixcompref || !s->above_ref_ctx[col]);
-                    } else {
-                        c = 4 * (!s->above_ref_ctx[col]);
-                    }
-                } else if (have_l && !s->left_intra_ctx[row7]) {
-                    if (s->left_intra_ctx[row7]) {
-                        c = 2;
-                    } else if (s->left_comp_ctx[row7]) {
-                        c = 1 + (!s->s.h.fixcompref || !s->left_ref_ctx[row7]);
-                    } else {
-                        c = 4 * (!s->left_ref_ctx[row7]);
-                    }
-                } else {
-                    c = 2;
-                }
-                bit = vp56_rac_get_prob(&s->c, s->prob.p.single_ref[c][0]);
-                s->counts.single_ref[c][0][bit]++;
-                if (!bit) {
-                    b->ref[0] = 0;
-                } else {
-                    // FIXME can this codeblob be replaced by some sort of LUT?
-                    if (have_a) {
-                        if (have_l) {
-                            if (s->left_intra_ctx[row7]) {
-                                if (s->above_intra_ctx[col]) {
-                                    c = 2;
-                                } else if (s->above_comp_ctx[col]) {
-                                    c = 1 + 2 * (s->s.h.fixcompref == 1 ||
-                                                 s->above_ref_ctx[col] == 1);
-                                } else if (!s->above_ref_ctx[col]) {
-                                    c = 3;
-                                } else {
-                                    c = 4 * (s->above_ref_ctx[col] == 1);
-                                }
-                            } else if (s->above_intra_ctx[col]) {
-                                if (s->left_intra_ctx[row7]) {
-                                    c = 2;
-                                } else if (s->left_comp_ctx[row7]) {
-                                    c = 1 + 2 * (s->s.h.fixcompref == 1 ||
-                                                 s->left_ref_ctx[row7] == 1);
-                                } else if (!s->left_ref_ctx[row7]) {
-                                    c = 3;
-                                } else {
-                                    c = 4 * (s->left_ref_ctx[row7] == 1);
-                                }
-                            } else if (s->above_comp_ctx[col]) {
-                                if (s->left_comp_ctx[row7]) {
-                                    if (s->left_ref_ctx[row7] == s->above_ref_ctx[col]) {
-                                        c = 3 * (s->s.h.fixcompref == 1 ||
-                                                 s->left_ref_ctx[row7] == 1);
-                                    } else {
-                                        c = 2;
-                                    }
-                                } else if (!s->left_ref_ctx[row7]) {
-                                    c = 1 + 2 * (s->s.h.fixcompref == 1 ||
-                                                 s->above_ref_ctx[col] == 1);
-                                } else {
-                                    c = 3 * (s->left_ref_ctx[row7] == 1) +
-                                    (s->s.h.fixcompref == 1 || s->above_ref_ctx[col] == 1);
-                                }
-                            } else if (s->left_comp_ctx[row7]) {
-                                if (!s->above_ref_ctx[col]) {
-                                    c = 1 + 2 * (s->s.h.fixcompref == 1 ||
-                                                 s->left_ref_ctx[row7] == 1);
-                                } else {
-                                    c = 3 * (s->above_ref_ctx[col] == 1) +
-                                    (s->s.h.fixcompref == 1 || s->left_ref_ctx[row7] == 1);
-                                }
-                            } else if (!s->above_ref_ctx[col]) {
-                                if (!s->left_ref_ctx[row7]) {
-                                    c = 3;
-                                } else {
-                                    c = 4 * (s->left_ref_ctx[row7] == 1);
-                                }
-                            } else if (!s->left_ref_ctx[row7]) {
-                                c = 4 * (s->above_ref_ctx[col] == 1);
-                            } else {
-                                c = 2 * (s->left_ref_ctx[row7] == 1) +
-                                2 * (s->above_ref_ctx[col] == 1);
-                            }
-                        } else {
-                            if (s->above_intra_ctx[col] ||
-                                (!s->above_comp_ctx[col] && !s->above_ref_ctx[col])) {
-                                c = 2;
-                            } else if (s->above_comp_ctx[col]) {
-                                c = 3 * (s->s.h.fixcompref == 1 || s->above_ref_ctx[col] == 1);
-                            } else {
-                                c = 4 * (s->above_ref_ctx[col] == 1);
-                            }
-                        }
-                    } else if (have_l) {
-                        if (s->left_intra_ctx[row7] ||
-                            (!s->left_comp_ctx[row7] && !s->left_ref_ctx[row7])) {
-                            c = 2;
-                        } else if (s->left_comp_ctx[row7]) {
-                            c = 3 * (s->s.h.fixcompref == 1 || s->left_ref_ctx[row7] == 1);
-                        } else {
-                            c = 4 * (s->left_ref_ctx[row7] == 1);
-                        }
-                    } else {
-                        c = 2;
-                    }
-                    bit = vp56_rac_get_prob(&s->c, s->prob.p.single_ref[c][1]);
-                    s->counts.single_ref[c][1][bit]++;
-                    b->ref[0] = 1 + bit;
-                }
-            }
-        }
-
-        if (b->bs <= BS_8x8) {
-            if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].skip_enabled) {
-                b->mode[0] = b->mode[1] = b->mode[2] = b->mode[3] = ZEROMV;
-            } else {
-                static const uint8_t off[10] = {
-                    3, 0, 0, 1, 0, 0, 0, 0, 0, 0
-                };
-
-                // FIXME this needs to use the LUT tables from find_ref_mvs
-                // because not all are -1,0/0,-1
-                int c = inter_mode_ctx_lut[s->above_mode_ctx[col + off[b->bs]]]
-                                          [s->left_mode_ctx[row7 + off[b->bs]]];
-
-                b->mode[0] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
-                                              s->prob.p.mv_mode[c]);
-                b->mode[1] = b->mode[2] = b->mode[3] = b->mode[0];
-                s->counts.mv_mode[c][b->mode[0] - 10]++;
-            }
-        }
-
-        if (s->s.h.filtermode == FILTER_SWITCHABLE) {
-            int c;
-
-            if (have_a && s->above_mode_ctx[col] >= NEARESTMV) {
-                if (have_l && s->left_mode_ctx[row7] >= NEARESTMV) {
-                    c = s->above_filter_ctx[col] == s->left_filter_ctx[row7] ?
-                        s->left_filter_ctx[row7] : 3;
-                } else {
-                    c = s->above_filter_ctx[col];
-                }
-            } else if (have_l && s->left_mode_ctx[row7] >= NEARESTMV) {
-                c = s->left_filter_ctx[row7];
-            } else {
-                c = 3;
-            }
-
-            filter_id = vp8_rac_get_tree(&s->c, vp9_filter_tree,
-                                         s->prob.p.filter[c]);
-            s->counts.filter[c][filter_id]++;
-            b->filter = vp9_filter_lut[filter_id];
-        } else {
-            b->filter = s->s.h.filtermode;
-        }
-
-        if (b->bs > BS_8x8) {
-            int c = inter_mode_ctx_lut[s->above_mode_ctx[col]][s->left_mode_ctx[row7]];
-
-            b->mode[0] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
-                                          s->prob.p.mv_mode[c]);
-            s->counts.mv_mode[c][b->mode[0] - 10]++;
-            fill_mv(s, b->mv[0], b->mode[0], 0);
-
-            if (b->bs != BS_8x4) {
-                b->mode[1] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
-                                              s->prob.p.mv_mode[c]);
-                s->counts.mv_mode[c][b->mode[1] - 10]++;
-                fill_mv(s, b->mv[1], b->mode[1], 1);
-            } else {
-                b->mode[1] = b->mode[0];
-                AV_COPY32(&b->mv[1][0], &b->mv[0][0]);
-                AV_COPY32(&b->mv[1][1], &b->mv[0][1]);
-            }
-
-            if (b->bs != BS_4x8) {
-                b->mode[2] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
-                                              s->prob.p.mv_mode[c]);
-                s->counts.mv_mode[c][b->mode[2] - 10]++;
-                fill_mv(s, b->mv[2], b->mode[2], 2);
-
-                if (b->bs != BS_8x4) {
-                    b->mode[3] = vp8_rac_get_tree(&s->c, vp9_inter_mode_tree,
-                                                  s->prob.p.mv_mode[c]);
-                    s->counts.mv_mode[c][b->mode[3] - 10]++;
-                    fill_mv(s, b->mv[3], b->mode[3], 3);
-                } else {
-                    b->mode[3] = b->mode[2];
-                    AV_COPY32(&b->mv[3][0], &b->mv[2][0]);
-                    AV_COPY32(&b->mv[3][1], &b->mv[2][1]);
-                }
-            } else {
-                b->mode[2] = b->mode[0];
-                AV_COPY32(&b->mv[2][0], &b->mv[0][0]);
-                AV_COPY32(&b->mv[2][1], &b->mv[0][1]);
-                b->mode[3] = b->mode[1];
-                AV_COPY32(&b->mv[3][0], &b->mv[1][0]);
-                AV_COPY32(&b->mv[3][1], &b->mv[1][1]);
-            }
-        } else {
-            fill_mv(s, b->mv[0], b->mode[0], -1);
-            AV_COPY32(&b->mv[1][0], &b->mv[0][0]);
-            AV_COPY32(&b->mv[2][0], &b->mv[0][0]);
-            AV_COPY32(&b->mv[3][0], &b->mv[0][0]);
-            AV_COPY32(&b->mv[1][1], &b->mv[0][1]);
-            AV_COPY32(&b->mv[2][1], &b->mv[0][1]);
-            AV_COPY32(&b->mv[3][1], &b->mv[0][1]);
-        }
-
-        vref = b->ref[b->comp ? s->s.h.signbias[s->s.h.varcompref[0]] : 0];
-    }
-
-#if HAVE_FAST_64BIT
-#define SPLAT_CTX(var, val, n) \
-    switch (n) { \
-    case 1:  var = val;                                    break; \
-    case 2:  AV_WN16A(&var, val *             0x0101);     break; \
-    case 4:  AV_WN32A(&var, val *         0x01010101);     break; \
-    case 8:  AV_WN64A(&var, val * 0x0101010101010101ULL);  break; \
-    case 16: { \
-        uint64_t v64 = val * 0x0101010101010101ULL; \
-        AV_WN64A(              &var,     v64); \
-        AV_WN64A(&((uint8_t *) &var)[8], v64); \
-        break; \
-    } \
-    }
-#else
-#define SPLAT_CTX(var, val, n) \
-    switch (n) { \
-    case 1:  var = val;                         break; \
-    case 2:  AV_WN16A(&var, val *     0x0101);  break; \
-    case 4:  AV_WN32A(&var, val * 0x01010101);  break; \
-    case 8: { \
-        uint32_t v32 = val * 0x01010101; \
-        AV_WN32A(              &var,     v32); \
-        AV_WN32A(&((uint8_t *) &var)[4], v32); \
-        break; \
-    } \
-    case 16: { \
-        uint32_t v32 = val * 0x01010101; \
-        AV_WN32A(              &var,      v32); \
-        AV_WN32A(&((uint8_t *) &var)[4],  v32); \
-        AV_WN32A(&((uint8_t *) &var)[8],  v32); \
-        AV_WN32A(&((uint8_t *) &var)[12], v32); \
-        break; \
-    } \
-    }
-#endif
-
-    switch (bwh_tab[1][b->bs][0]) {
-#define SET_CTXS(dir, off, n) \
-    do { \
-        SPLAT_CTX(s->dir##_skip_ctx[off],      b->skip,          n); \
-        SPLAT_CTX(s->dir##_txfm_ctx[off],      b->tx,            n); \
-        SPLAT_CTX(s->dir##_partition_ctx[off], dir##_ctx[b->bs], n); \
-        if (!s->s.h.keyframe && !s->s.h.intraonly) { \
-            SPLAT_CTX(s->dir##_intra_ctx[off], b->intra,   n); \
-            SPLAT_CTX(s->dir##_comp_ctx[off],  b->comp,    n); \
-            SPLAT_CTX(s->dir##_mode_ctx[off],  b->mode[3], n); \
-            if (!b->intra) { \
-                SPLAT_CTX(s->dir##_ref_ctx[off], vref, n); \
-                if (s->s.h.filtermode == FILTER_SWITCHABLE) { \
-                    SPLAT_CTX(s->dir##_filter_ctx[off], filter_id, n); \
-                } \
-            } \
-        } \
-    } while (0)
-    case 1: SET_CTXS(above, col, 1); break;
-    case 2: SET_CTXS(above, col, 2); break;
-    case 4: SET_CTXS(above, col, 4); break;
-    case 8: SET_CTXS(above, col, 8); break;
-    }
-    switch (bwh_tab[1][b->bs][1]) {
-    case 1: SET_CTXS(left, row7, 1); break;
-    case 2: SET_CTXS(left, row7, 2); break;
-    case 4: SET_CTXS(left, row7, 4); break;
-    case 8: SET_CTXS(left, row7, 8); break;
-    }
-#undef SPLAT_CTX
-#undef SET_CTXS
-
-    if (!s->s.h.keyframe && !s->s.h.intraonly) {
-        if (b->bs > BS_8x8) {
-            int mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]);
-
-            AV_COPY32(&s->left_mv_ctx[row7 * 2 + 0][0], &b->mv[1][0]);
-            AV_COPY32(&s->left_mv_ctx[row7 * 2 + 0][1], &b->mv[1][1]);
-            AV_WN32A(&s->left_mv_ctx[row7 * 2 + 1][0], mv0);
-            AV_WN32A(&s->left_mv_ctx[row7 * 2 + 1][1], mv1);
-            AV_COPY32(&s->above_mv_ctx[col * 2 + 0][0], &b->mv[2][0]);
-            AV_COPY32(&s->above_mv_ctx[col * 2 + 0][1], &b->mv[2][1]);
-            AV_WN32A(&s->above_mv_ctx[col * 2 + 1][0], mv0);
-            AV_WN32A(&s->above_mv_ctx[col * 2 + 1][1], mv1);
-        } else {
-            int n, mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]);
-
-            for (n = 0; n < w4 * 2; n++) {
-                AV_WN32A(&s->above_mv_ctx[col * 2 + n][0], mv0);
-                AV_WN32A(&s->above_mv_ctx[col * 2 + n][1], mv1);
-            }
-            for (n = 0; n < h4 * 2; n++) {
-                AV_WN32A(&s->left_mv_ctx[row7 * 2 + n][0], mv0);
-                AV_WN32A(&s->left_mv_ctx[row7 * 2 + n][1], mv1);
-            }
-        }
-    }
-
-    // FIXME kinda ugly
-    for (y = 0; y < h4; y++) {
-        int x, o = (row + y) * s->sb_cols * 8 + col;
-        struct VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[o];
-
-        if (b->intra) {
-            for (x = 0; x < w4; x++) {
-                mv[x].ref[0] =
-                mv[x].ref[1] = -1;
-            }
-        } else if (b->comp) {
-            for (x = 0; x < w4; x++) {
-                mv[x].ref[0] = b->ref[0];
-                mv[x].ref[1] = b->ref[1];
-                AV_COPY32(&mv[x].mv[0], &b->mv[3][0]);
-                AV_COPY32(&mv[x].mv[1], &b->mv[3][1]);
-            }
-        } else {
-            for (x = 0; x < w4; x++) {
-                mv[x].ref[0] = b->ref[0];
-                mv[x].ref[1] = -1;
-                AV_COPY32(&mv[x].mv[0], &b->mv[3][0]);
-            }
-        }
-    }
-}
-
-// FIXME merge cnt/eob arguments?
-static av_always_inline int
-decode_coeffs_b_generic(VP56RangeCoder *c, int16_t *coef, int n_coeffs,
-                        int is_tx32x32, int is8bitsperpixel, int bpp, unsigned (*cnt)[6][3],
-                        unsigned (*eob)[6][2], uint8_t (*p)[6][11],
-                        int nnz, const int16_t *scan, const int16_t (*nb)[2],
-                        const int16_t *band_counts, const int16_t *qmul)
-{
-    int i = 0, band = 0, band_left = band_counts[band];
-    uint8_t *tp = p[0][nnz];
-    uint8_t cache[1024];
-
-    do {
-        int val, rc;
-
-        val = vp56_rac_get_prob_branchy(c, tp[0]); // eob
-        eob[band][nnz][val]++;
-        if (!val)
-            break;
-
-    skip_eob:
-        if (!vp56_rac_get_prob_branchy(c, tp[1])) { // zero
-            cnt[band][nnz][0]++;
-            if (!--band_left)
-                band_left = band_counts[++band];
-            cache[scan[i]] = 0;
-            nnz = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1;
-            tp = p[band][nnz];
-            if (++i == n_coeffs)
-                break; //invalid input; blocks should end with EOB
-            goto skip_eob;
-        }
-
-        rc = scan[i];
-        if (!vp56_rac_get_prob_branchy(c, tp[2])) { // one
-            cnt[band][nnz][1]++;
-            val = 1;
-            cache[rc] = 1;
-        } else {
-            // fill in p[3-10] (model fill) - only once per frame for each pos
-            if (!tp[3])
-                memcpy(&tp[3], vp9_model_pareto8[tp[2]], 8);
-
-            cnt[band][nnz][2]++;
-            if (!vp56_rac_get_prob_branchy(c, tp[3])) { // 2, 3, 4
-                if (!vp56_rac_get_prob_branchy(c, tp[4])) {
-                    cache[rc] = val = 2;
-                } else {
-                    val = 3 + vp56_rac_get_prob(c, tp[5]);
-                    cache[rc] = 3;
-                }
-            } else if (!vp56_rac_get_prob_branchy(c, tp[6])) { // cat1/2
-                cache[rc] = 4;
-                if (!vp56_rac_get_prob_branchy(c, tp[7])) {
-                    val = 5 + vp56_rac_get_prob(c, 159);
-                } else {
-                    val  = 7 + (vp56_rac_get_prob(c, 165) << 1);
-                    val +=      vp56_rac_get_prob(c, 145);
-                }
-            } else { // cat 3-6
-                cache[rc] = 5;
-                if (!vp56_rac_get_prob_branchy(c, tp[8])) {
-                    if (!vp56_rac_get_prob_branchy(c, tp[9])) {
-                        val  = 11 + (vp56_rac_get_prob(c, 173) << 2);
-                        val +=      (vp56_rac_get_prob(c, 148) << 1);
-                        val +=       vp56_rac_get_prob(c, 140);
-                    } else {
-                        val  = 19 + (vp56_rac_get_prob(c, 176) << 3);
-                        val +=      (vp56_rac_get_prob(c, 155) << 2);
-                        val +=      (vp56_rac_get_prob(c, 140) << 1);
-                        val +=       vp56_rac_get_prob(c, 135);
-                    }
-                } else if (!vp56_rac_get_prob_branchy(c, tp[10])) {
-                    val  = 35 + (vp56_rac_get_prob(c, 180) << 4);
-                    val +=      (vp56_rac_get_prob(c, 157) << 3);
-                    val +=      (vp56_rac_get_prob(c, 141) << 2);
-                    val +=      (vp56_rac_get_prob(c, 134) << 1);
-                    val +=       vp56_rac_get_prob(c, 130);
-                } else {
-                    val = 67;
-                    if (!is8bitsperpixel) {
-                        if (bpp == 12) {
-                            val += vp56_rac_get_prob(c, 255) << 17;
-                            val += vp56_rac_get_prob(c, 255) << 16;
-                        }
-                        val +=  (vp56_rac_get_prob(c, 255) << 15);
-                        val +=  (vp56_rac_get_prob(c, 255) << 14);
-                    }
-                    val +=      (vp56_rac_get_prob(c, 254) << 13);
-                    val +=      (vp56_rac_get_prob(c, 254) << 12);
-                    val +=      (vp56_rac_get_prob(c, 254) << 11);
-                    val +=      (vp56_rac_get_prob(c, 252) << 10);
-                    val +=      (vp56_rac_get_prob(c, 249) << 9);
-                    val +=      (vp56_rac_get_prob(c, 243) << 8);
-                    val +=      (vp56_rac_get_prob(c, 230) << 7);
-                    val +=      (vp56_rac_get_prob(c, 196) << 6);
-                    val +=      (vp56_rac_get_prob(c, 177) << 5);
-                    val +=      (vp56_rac_get_prob(c, 153) << 4);
-                    val +=      (vp56_rac_get_prob(c, 140) << 3);
-                    val +=      (vp56_rac_get_prob(c, 133) << 2);
-                    val +=      (vp56_rac_get_prob(c, 130) << 1);
-                    val +=       vp56_rac_get_prob(c, 129);
-                }
-            }
-        }
-#define STORE_COEF(c, i, v) do { \
-    if (is8bitsperpixel) { \
-        c[i] = v; \
-    } else { \
-        AV_WN32A(&c[i * 2], v); \
-    } \
-} while (0)
-        if (!--band_left)
-            band_left = band_counts[++band];
-        if (is_tx32x32)
-            STORE_COEF(coef, rc, ((vp8_rac_get(c) ? -val : val) * qmul[!!i]) / 2);
-        else
-            STORE_COEF(coef, rc, (vp8_rac_get(c) ? -val : val) * qmul[!!i]);
-        nnz = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1;
-        tp = p[band][nnz];
-    } while (++i < n_coeffs);
-
-    return i;
-}
-
-static int decode_coeffs_b_8bpp(VP9Context *s, int16_t *coef, int n_coeffs,
-                                unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
-                                uint8_t (*p)[6][11], int nnz, const int16_t *scan,
-                                const int16_t (*nb)[2], const int16_t *band_counts,
-                                const int16_t *qmul)
-{
-    return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 0, 1, 8, cnt, eob, p,
-                                   nnz, scan, nb, band_counts, qmul);
-}
-
-static int decode_coeffs_b32_8bpp(VP9Context *s, int16_t *coef, int n_coeffs,
-                                  unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
-                                  uint8_t (*p)[6][11], int nnz, const int16_t *scan,
-                                  const int16_t (*nb)[2], const int16_t *band_counts,
-                                  const int16_t *qmul)
-{
-    return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 1, 1, 8, cnt, eob, p,
-                                   nnz, scan, nb, band_counts, qmul);
-}
-
-static int decode_coeffs_b_16bpp(VP9Context *s, int16_t *coef, int n_coeffs,
-                                 unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
-                                 uint8_t (*p)[6][11], int nnz, const int16_t *scan,
-                                 const int16_t (*nb)[2], const int16_t *band_counts,
-                                 const int16_t *qmul)
-{
-    return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 0, 0, s->bpp, cnt, eob, p,
-                                   nnz, scan, nb, band_counts, qmul);
-}
-
-static int decode_coeffs_b32_16bpp(VP9Context *s, int16_t *coef, int n_coeffs,
-                                   unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
-                                   uint8_t (*p)[6][11], int nnz, const int16_t *scan,
-                                   const int16_t (*nb)[2], const int16_t *band_counts,
-                                   const int16_t *qmul)
-{
-    return decode_coeffs_b_generic(&s->c, coef, n_coeffs, 1, 0, s->bpp, cnt, eob, p,
-                                   nnz, scan, nb, band_counts, qmul);
-}
-
-static av_always_inline int decode_coeffs(AVCodecContext *ctx, int is8bitsperpixel)
-{
-    VP9Context *s = ctx->priv_data;
-    VP9Block *b = s->b;
-    int row = s->row, col = s->col;
-    uint8_t (*p)[6][11] = s->prob.coef[b->tx][0 /* y */][!b->intra];
-    unsigned (*c)[6][3] = s->counts.coef[b->tx][0 /* y */][!b->intra];
-    unsigned (*e)[6][2] = s->counts.eob[b->tx][0 /* y */][!b->intra];
-    int w4 = bwh_tab[1][b->bs][0] << 1, h4 = bwh_tab[1][b->bs][1] << 1;
-    int end_x = FFMIN(2 * (s->cols - col), w4);
-    int end_y = FFMIN(2 * (s->rows - row), h4);
-    int n, pl, x, y, res;
-    int16_t (*qmul)[2] = s->s.h.segmentation.feat[b->seg_id].qmul;
-    int tx = 4 * s->s.h.lossless + b->tx;
-    const int16_t * const *yscans = vp9_scans[tx];
-    const int16_t (* const *ynbs)[2] = vp9_scans_nb[tx];
-    const int16_t *uvscan = vp9_scans[b->uvtx][DCT_DCT];
-    const int16_t (*uvnb)[2] = vp9_scans_nb[b->uvtx][DCT_DCT];
-    uint8_t *a = &s->above_y_nnz_ctx[col * 2];
-    uint8_t *l = &s->left_y_nnz_ctx[(row & 7) << 1];
-    static const int16_t band_counts[4][8] = {
-        { 1, 2, 3, 4,  3,   16 - 13 },
-        { 1, 2, 3, 4, 11,   64 - 21 },
-        { 1, 2, 3, 4, 11,  256 - 21 },
-        { 1, 2, 3, 4, 11, 1024 - 21 },
-    };
-    const int16_t *y_band_counts = band_counts[b->tx];
-    const int16_t *uv_band_counts = band_counts[b->uvtx];
-    int bytesperpixel = is8bitsperpixel ? 1 : 2;
-    int total_coeff = 0;
-
-#define MERGE(la, end, step, rd) \
-    for (n = 0; n < end; n += step) \
-        la[n] = !!rd(&la[n])
-#define MERGE_CTX(step, rd) \
-    do { \
-        MERGE(l, end_y, step, rd); \
-        MERGE(a, end_x, step, rd); \
-    } while (0)
-
-#define DECODE_Y_COEF_LOOP(step, mode_index, v) \
-    for (n = 0, y = 0; y < end_y; y += step) { \
-        for (x = 0; x < end_x; x += step, n += step * step) { \
-            enum TxfmType txtp = vp9_intra_txfm_type[b->mode[mode_index]]; \
-            res = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \
-                                    (s, s->block + 16 * n * bytesperpixel, 16 * step * step, \
-                                     c, e, p, a[x] + l[y], yscans[txtp], \
-                                     ynbs[txtp], y_band_counts, qmul[0]); \
-            a[x] = l[y] = !!res; \
-            total_coeff |= !!res; \
-            if (step >= 4) { \
-                AV_WN16A(&s->eob[n], res); \
-            } else { \
-                s->eob[n] = res; \
-            } \
-        } \
-    }
-
-#define SPLAT(la, end, step, cond) \
-    if (step == 2) { \
-        for (n = 1; n < end; n += step) \
-            la[n] = la[n - 1]; \
-    } else if (step == 4) { \
-        if (cond) { \
-            for (n = 0; n < end; n += step) \
-                AV_WN32A(&la[n], la[n] * 0x01010101); \
-        } else { \
-            for (n = 0; n < end; n += step) \
-                memset(&la[n + 1], la[n], FFMIN(end - n - 1, 3)); \
-        } \
-    } else /* step == 8 */ { \
-        if (cond) { \
-            if (HAVE_FAST_64BIT) { \
-                for (n = 0; n < end; n += step) \
-                    AV_WN64A(&la[n], la[n] * 0x0101010101010101ULL); \
-            } else { \
-                for (n = 0; n < end; n += step) { \
-                    uint32_t v32 = la[n] * 0x01010101; \
-                    AV_WN32A(&la[n],     v32); \
-                    AV_WN32A(&la[n + 4], v32); \
-                } \
-            } \
-        } else { \
-            for (n = 0; n < end; n += step) \
-                memset(&la[n + 1], la[n], FFMIN(end - n - 1, 7)); \
-        } \
-    }
-#define SPLAT_CTX(step) \
-    do { \
-        SPLAT(a, end_x, step, end_x == w4); \
-        SPLAT(l, end_y, step, end_y == h4); \
-    } while (0)
-
-    /* y tokens */
-    switch (b->tx) {
-    case TX_4X4:
-        DECODE_Y_COEF_LOOP(1, b->bs > BS_8x8 ? n : 0,);
-        break;
-    case TX_8X8:
-        MERGE_CTX(2, AV_RN16A);
-        DECODE_Y_COEF_LOOP(2, 0,);
-        SPLAT_CTX(2);
-        break;
-    case TX_16X16:
-        MERGE_CTX(4, AV_RN32A);
-        DECODE_Y_COEF_LOOP(4, 0,);
-        SPLAT_CTX(4);
-        break;
-    case TX_32X32:
-        MERGE_CTX(8, AV_RN64A);
-        DECODE_Y_COEF_LOOP(8, 0, 32);
-        SPLAT_CTX(8);
-        break;
-    }
-
-#define DECODE_UV_COEF_LOOP(step, v) \
-    for (n = 0, y = 0; y < end_y; y += step) { \
-        for (x = 0; x < end_x; x += step, n += step * step) { \
-            res = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \
-                                    (s, s->uvblock[pl] + 16 * n * bytesperpixel, \
-                                     16 * step * step, c, e, p, a[x] + l[y], \
-                                     uvscan, uvnb, uv_band_counts, qmul[1]); \
-            a[x] = l[y] = !!res; \
-            total_coeff |= !!res; \
-            if (step >= 4) { \
-                AV_WN16A(&s->uveob[pl][n], res); \
-            } else { \
-                s->uveob[pl][n] = res; \
-            } \
-        } \
-    }
-
-    p = s->prob.coef[b->uvtx][1 /* uv */][!b->intra];
-    c = s->counts.coef[b->uvtx][1 /* uv */][!b->intra];
-    e = s->counts.eob[b->uvtx][1 /* uv */][!b->intra];
-    w4 >>= s->ss_h;
-    end_x >>= s->ss_h;
-    h4 >>= s->ss_v;
-    end_y >>= s->ss_v;
-    for (pl = 0; pl < 2; pl++) {
-        a = &s->above_uv_nnz_ctx[pl][col << !s->ss_h];
-        l = &s->left_uv_nnz_ctx[pl][(row & 7) << !s->ss_v];
-        switch (b->uvtx) {
-        case TX_4X4:
-            DECODE_UV_COEF_LOOP(1,);
-            break;
-        case TX_8X8:
-            MERGE_CTX(2, AV_RN16A);
-            DECODE_UV_COEF_LOOP(2,);
-            SPLAT_CTX(2);
-            break;
-        case TX_16X16:
-            MERGE_CTX(4, AV_RN32A);
-            DECODE_UV_COEF_LOOP(4,);
-            SPLAT_CTX(4);
-            break;
-        case TX_32X32:
-            MERGE_CTX(8, AV_RN64A);
-            DECODE_UV_COEF_LOOP(8, 32);
-            SPLAT_CTX(8);
-            break;
-        }
-    }
-
-    return total_coeff;
-}
-
-static int decode_coeffs_8bpp(AVCodecContext *ctx)
-{
-    return decode_coeffs(ctx, 1);
-}
-
-static int decode_coeffs_16bpp(AVCodecContext *ctx)
-{
-    return decode_coeffs(ctx, 0);
-}
-
-static av_always_inline int check_intra_mode(VP9Context *s, int mode, uint8_t **a,
-                                             uint8_t *dst_edge, ptrdiff_t stride_edge,
-                                             uint8_t *dst_inner, ptrdiff_t stride_inner,
-                                             uint8_t *l, int col, int x, int w,
-                                             int row, int y, enum TxfmMode tx,
-                                             int p, int ss_h, int ss_v, int bytesperpixel)
-{
-    int have_top = row > 0 || y > 0;
-    int have_left = col > s->tile_col_start || x > 0;
-    int have_right = x < w - 1;
-    int bpp = s->bpp;
-    static const uint8_t mode_conv[10][2 /* have_left */][2 /* have_top */] = {
-        [VERT_PRED]            = { { DC_127_PRED,          VERT_PRED },
-                                   { DC_127_PRED,          VERT_PRED } },
-        [HOR_PRED]             = { { DC_129_PRED,          DC_129_PRED },
-                                   { HOR_PRED,             HOR_PRED } },
-        [DC_PRED]              = { { DC_128_PRED,          TOP_DC_PRED },
-                                   { LEFT_DC_PRED,         DC_PRED } },
-        [DIAG_DOWN_LEFT_PRED]  = { { DC_127_PRED,          DIAG_DOWN_LEFT_PRED },
-                                   { DC_127_PRED,          DIAG_DOWN_LEFT_PRED } },
-        [DIAG_DOWN_RIGHT_PRED] = { { DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_RIGHT_PRED },
-                                   { DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_RIGHT_PRED } },
-        [VERT_RIGHT_PRED]      = { { VERT_RIGHT_PRED,      VERT_RIGHT_PRED },
-                                   { VERT_RIGHT_PRED,      VERT_RIGHT_PRED } },
-        [HOR_DOWN_PRED]        = { { HOR_DOWN_PRED,        HOR_DOWN_PRED },
-                                   { HOR_DOWN_PRED,        HOR_DOWN_PRED } },
-        [VERT_LEFT_PRED]       = { { DC_127_PRED,          VERT_LEFT_PRED },
-                                   { DC_127_PRED,          VERT_LEFT_PRED } },
-        [HOR_UP_PRED]          = { { DC_129_PRED,          DC_129_PRED },
-                                   { HOR_UP_PRED,          HOR_UP_PRED } },
-        [TM_VP8_PRED]          = { { DC_129_PRED,          VERT_PRED },
-                                   { HOR_PRED,             TM_VP8_PRED } },
-    };
-    static const struct {
-        uint8_t needs_left:1;
-        uint8_t needs_top:1;
-        uint8_t needs_topleft:1;
-        uint8_t needs_topright:1;
-        uint8_t invert_left:1;
-    } edges[N_INTRA_PRED_MODES] = {
-        [VERT_PRED]            = { .needs_top  = 1 },
-        [HOR_PRED]             = { .needs_left = 1 },
-        [DC_PRED]              = { .needs_top  = 1, .needs_left = 1 },
-        [DIAG_DOWN_LEFT_PRED]  = { .needs_top  = 1, .needs_topright = 1 },
-        [DIAG_DOWN_RIGHT_PRED] = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
-        [VERT_RIGHT_PRED]      = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
-        [HOR_DOWN_PRED]        = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
-        [VERT_LEFT_PRED]       = { .needs_top  = 1, .needs_topright = 1 },
-        [HOR_UP_PRED]          = { .needs_left = 1, .invert_left = 1 },
-        [TM_VP8_PRED]          = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
-        [LEFT_DC_PRED]         = { .needs_left = 1 },
-        [TOP_DC_PRED]          = { .needs_top  = 1 },
-        [DC_128_PRED]          = { 0 },
-        [DC_127_PRED]          = { 0 },
-        [DC_129_PRED]          = { 0 }
-    };
-
-    av_assert2(mode >= 0 && mode < 10);
-    mode = mode_conv[mode][have_left][have_top];
-    if (edges[mode].needs_top) {
-        uint8_t *top, *topleft;
-        int n_px_need = 4 << tx, n_px_have = (((s->cols - col) << !ss_h) - x) * 4;
-        int n_px_need_tr = 0;
-
-        if (tx == TX_4X4 && edges[mode].needs_topright && have_right)
-            n_px_need_tr = 4;
-
-        // if top of sb64-row, use s->intra_pred_data[] instead of
-        // dst[-stride] for intra prediction (it contains pre- instead of
-        // post-loopfilter data)
-        if (have_top) {
-            top = !(row & 7) && !y ?
-                s->intra_pred_data[p] + (col * (8 >> ss_h) + x * 4) * bytesperpixel :
-                y == 0 ? &dst_edge[-stride_edge] : &dst_inner[-stride_inner];
-            if (have_left)
-                topleft = !(row & 7) && !y ?
-                    s->intra_pred_data[p] + (col * (8 >> ss_h) + x * 4) * bytesperpixel :
-                    y == 0 || x == 0 ? &dst_edge[-stride_edge] :
-                    &dst_inner[-stride_inner];
-        }
-
-        if (have_top &&
-            (!edges[mode].needs_topleft || (have_left && top == topleft)) &&
-            (tx != TX_4X4 || !edges[mode].needs_topright || have_right) &&
-            n_px_need + n_px_need_tr <= n_px_have) {
-            *a = top;
-        } else {
-            if (have_top) {
-                if (n_px_need <= n_px_have) {
-                    memcpy(*a, top, n_px_need * bytesperpixel);
-                } else {
-#define memset_bpp(c, i1, v, i2, num) do { \
-    if (bytesperpixel == 1) { \
-        memset(&(c)[(i1)], (v)[(i2)], (num)); \
-    } else { \
-        int n, val = AV_RN16A(&(v)[(i2) * 2]); \
-        for (n = 0; n < (num); n++) { \
-            AV_WN16A(&(c)[((i1) + n) * 2], val); \
-        } \
-    } \
-} while (0)
-                    memcpy(*a, top, n_px_have * bytesperpixel);
-                    memset_bpp(*a, n_px_have, (*a), n_px_have - 1, n_px_need - n_px_have);
-                }
-            } else {
-#define memset_val(c, val, num) do { \
-    if (bytesperpixel == 1) { \
-        memset((c), (val), (num)); \
-    } else { \
-        int n; \
-        for (n = 0; n < (num); n++) { \
-            AV_WN16A(&(c)[n * 2], (val)); \
-        } \
-    } \
-} while (0)
-                memset_val(*a, (128 << (bpp - 8)) - 1, n_px_need);
-            }
-            if (edges[mode].needs_topleft) {
-                if (have_left && have_top) {
-#define assign_bpp(c, i1, v, i2) do { \
-    if (bytesperpixel == 1) { \
-        (c)[(i1)] = (v)[(i2)]; \
-    } else { \
-        AV_COPY16(&(c)[(i1) * 2], &(v)[(i2) * 2]); \
-    } \
-} while (0)
-                    assign_bpp(*a, -1, topleft, -1);
-                } else {
-#define assign_val(c, i, v) do { \
-    if (bytesperpixel == 1) { \
-        (c)[(i)] = (v); \
-    } else { \
-        AV_WN16A(&(c)[(i) * 2], (v)); \
-    } \
-} while (0)
-                    assign_val((*a), -1, (128 << (bpp - 8)) + (have_top ? +1 : -1));
-                }
-            }
-            if (tx == TX_4X4 && edges[mode].needs_topright) {
-                if (have_top && have_right &&
-                    n_px_need + n_px_need_tr <= n_px_have) {
-                    memcpy(&(*a)[4 * bytesperpixel], &top[4 * bytesperpixel], 4 * bytesperpixel);
-                } else {
-                    memset_bpp(*a, 4, *a, 3, 4);
-                }
-            }
-        }
-    }
-    if (edges[mode].needs_left) {
-        if (have_left) {
-            int n_px_need = 4 << tx, i, n_px_have = (((s->rows - row) << !ss_v) - y) * 4;
-            uint8_t *dst = x == 0 ? dst_edge : dst_inner;
-            ptrdiff_t stride = x == 0 ? stride_edge : stride_inner;
-
-            if (edges[mode].invert_left) {
-                if (n_px_need <= n_px_have) {
-                    for (i = 0; i < n_px_need; i++)
-                        assign_bpp(l, i, &dst[i * stride], -1);
-                } else {
-                    for (i = 0; i < n_px_have; i++)
-                        assign_bpp(l, i, &dst[i * stride], -1);
-                    memset_bpp(l, n_px_have, l, n_px_have - 1, n_px_need - n_px_have);
-                }
-            } else {
-                if (n_px_need <= n_px_have) {
-                    for (i = 0; i < n_px_need; i++)
-                        assign_bpp(l, n_px_need - 1 - i, &dst[i * stride], -1);
-                } else {
-                    for (i = 0; i < n_px_have; i++)
-                        assign_bpp(l, n_px_need - 1 - i, &dst[i * stride], -1);
-                    memset_bpp(l, 0, l, n_px_need - n_px_have, n_px_need - n_px_have);
-                }
-            }
-        } else {
-            memset_val(l, (128 << (bpp - 8)) + 1, 4 << tx);
-        }
-    }
-
-    return mode;
-}
-
-static av_always_inline void intra_recon(AVCodecContext *ctx, ptrdiff_t y_off,
-                                         ptrdiff_t uv_off, int bytesperpixel)
-{
-    VP9Context *s = ctx->priv_data;
-    VP9Block *b = s->b;
-    int row = s->row, col = s->col;
-    int w4 = bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
-    int h4 = bwh_tab[1][b->bs][1] << 1, x, y, step = 1 << (b->tx * 2);
-    int end_x = FFMIN(2 * (s->cols - col), w4);
-    int end_y = FFMIN(2 * (s->rows - row), h4);
-    int tx = 4 * s->s.h.lossless + b->tx, uvtx = b->uvtx + 4 * s->s.h.lossless;
-    int uvstep1d = 1 << b->uvtx, p;
-    uint8_t *dst = s->dst[0], *dst_r = s->s.frames[CUR_FRAME].tf.f->data[0] + y_off;
-    LOCAL_ALIGNED_32(uint8_t, a_buf, [96]);
-    LOCAL_ALIGNED_32(uint8_t, l, [64]);
-
-    for (n = 0, y = 0; y < end_y; y += step1d) {
-        uint8_t *ptr = dst, *ptr_r = dst_r;
-        for (x = 0; x < end_x; x += step1d, ptr += 4 * step1d * bytesperpixel,
-                               ptr_r += 4 * step1d * bytesperpixel, n += step) {
-            int mode = b->mode[b->bs > BS_8x8 && b->tx == TX_4X4 ?
-                               y * 2 + x : 0];
-            uint8_t *a = &a_buf[32];
-            enum TxfmType txtp = vp9_intra_txfm_type[mode];
-            int eob = b->skip ? 0 : b->tx > TX_8X8 ? AV_RN16A(&s->eob[n]) : s->eob[n];
-
-            mode = check_intra_mode(s, mode, &a, ptr_r,
-                                    s->s.frames[CUR_FRAME].tf.f->linesize[0],
-                                    ptr, s->y_stride, l,
-                                    col, x, w4, row, y, b->tx, 0, 0, 0, bytesperpixel);
-            s->dsp.intra_pred[b->tx][mode](ptr, s->y_stride, l, a);
-            if (eob)
-                s->dsp.itxfm_add[tx][txtp](ptr, s->y_stride,
-                                           s->block + 16 * n * bytesperpixel, eob);
-        }
-        dst_r += 4 * step1d * s->s.frames[CUR_FRAME].tf.f->linesize[0];
-        dst   += 4 * step1d * s->y_stride;
-    }
-
-    // U/V
-    w4 >>= s->ss_h;
-    end_x >>= s->ss_h;
-    end_y >>= s->ss_v;
-    step = 1 << (b->uvtx * 2);
-    for (p = 0; p < 2; p++) {
-        dst   = s->dst[1 + p];
-        dst_r = s->s.frames[CUR_FRAME].tf.f->data[1 + p] + uv_off;
-        for (n = 0, y = 0; y < end_y; y += uvstep1d) {
-            uint8_t *ptr = dst, *ptr_r = dst_r;
-            for (x = 0; x < end_x; x += uvstep1d, ptr += 4 * uvstep1d * bytesperpixel,
-                                   ptr_r += 4 * uvstep1d * bytesperpixel, n += step) {
-                int mode = b->uvmode;
-                uint8_t *a = &a_buf[32];
-                int eob = b->skip ? 0 : b->uvtx > TX_8X8 ? AV_RN16A(&s->uveob[p][n]) : s->uveob[p][n];
-
-                mode = check_intra_mode(s, mode, &a, ptr_r,
-                                        s->s.frames[CUR_FRAME].tf.f->linesize[1],
-                                        ptr, s->uv_stride, l, col, x, w4, row, y,
-                                        b->uvtx, p + 1, s->ss_h, s->ss_v, bytesperpixel);
-                s->dsp.intra_pred[b->uvtx][mode](ptr, s->uv_stride, l, a);
-                if (eob)
-                    s->dsp.itxfm_add[uvtx][DCT_DCT](ptr, s->uv_stride,
-                                                    s->uvblock[p] + 16 * n * bytesperpixel, eob);
-            }
-            dst_r += 4 * uvstep1d * s->s.frames[CUR_FRAME].tf.f->linesize[1];
-            dst   += 4 * uvstep1d * s->uv_stride;
-        }
-    }
-}
-
-static void intra_recon_8bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
-{
-    intra_recon(ctx, y_off, uv_off, 1);
-}
-
-static void intra_recon_16bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
-{
-    intra_recon(ctx, y_off, uv_off, 2);
-}
-
-static av_always_inline void mc_luma_unscaled(VP9Context *s, vp9_mc_func (*mc)[2],
-                                              uint8_t *dst, ptrdiff_t dst_stride,
-                                              const uint8_t *ref, ptrdiff_t ref_stride,
-                                              ThreadFrame *ref_frame,
-                                              ptrdiff_t y, ptrdiff_t x, const VP56mv *mv,
-                                              int bw, int bh, int w, int h, int bytesperpixel)
-{
-    int mx = mv->x, my = mv->y, th;
-
-    y += my >> 3;
-    x += mx >> 3;
-    ref += y * ref_stride + x * bytesperpixel;
-    mx &= 7;
-    my &= 7;
-    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
-    // we use +7 because the last 7 pixels of each sbrow can be changed in
-    // the longest loopfilter of the next sbrow
-    th = (y + bh + 4 * !!my + 7) >> 6;
-    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
-    if (x < !!mx * 3 || y < !!my * 3 ||
-        x + !!mx * 4 > w - bw || y + !!my * 4 > h - bh) {
-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
-                                 ref - !!my * 3 * ref_stride - !!mx * 3 * bytesperpixel,
-                                 160, ref_stride,
-                                 bw + !!mx * 7, bh + !!my * 7,
-                                 x - !!mx * 3, y - !!my * 3, w, h);
-        ref = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
-        ref_stride = 160;
-    }
-    mc[!!mx][!!my](dst, dst_stride, ref, ref_stride, bh, mx << 1, my << 1);
-}
-
-static av_always_inline void mc_chroma_unscaled(VP9Context *s, vp9_mc_func (*mc)[2],
-                                                uint8_t *dst_u, uint8_t *dst_v,
-                                                ptrdiff_t dst_stride,
-                                                const uint8_t *ref_u, ptrdiff_t src_stride_u,
-                                                const uint8_t *ref_v, ptrdiff_t src_stride_v,
-                                                ThreadFrame *ref_frame,
-                                                ptrdiff_t y, ptrdiff_t x, const VP56mv *mv,
-                                                int bw, int bh, int w, int h, int bytesperpixel)
-{
-    int mx = mv->x * (1 << !s->ss_h), my = mv->y * (1 << !s->ss_v), th;
-
-    y += my >> 4;
-    x += mx >> 4;
-    ref_u += y * src_stride_u + x * bytesperpixel;
-    ref_v += y * src_stride_v + x * bytesperpixel;
-    mx &= 15;
-    my &= 15;
-    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
-    // we use +7 because the last 7 pixels of each sbrow can be changed in
-    // the longest loopfilter of the next sbrow
-    th = (y + bh + 4 * !!my + 7) >> (6 - s->ss_v);
-    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
-    if (x < !!mx * 3 || y < !!my * 3 ||
-        x + !!mx * 4 > w - bw || y + !!my * 4 > h - bh) {
-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
-                                 ref_u - !!my * 3 * src_stride_u - !!mx * 3 * bytesperpixel,
-                                 160, src_stride_u,
-                                 bw + !!mx * 7, bh + !!my * 7,
-                                 x - !!mx * 3, y - !!my * 3, w, h);
-        ref_u = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
-        mc[!!mx][!!my](dst_u, dst_stride, ref_u, 160, bh, mx, my);
-
-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
-                                 ref_v - !!my * 3 * src_stride_v - !!mx * 3 * bytesperpixel,
-                                 160, src_stride_v,
-                                 bw + !!mx * 7, bh + !!my * 7,
-                                 x - !!mx * 3, y - !!my * 3, w, h);
-        ref_v = s->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
-        mc[!!mx][!!my](dst_v, dst_stride, ref_v, 160, bh, mx, my);
-    } else {
-        mc[!!mx][!!my](dst_u, dst_stride, ref_u, src_stride_u, bh, mx, my);
-        mc[!!mx][!!my](dst_v, dst_stride, ref_v, src_stride_v, bh, mx, my);
-    }
-}
-
-#define mc_luma_dir(s, mc, dst, dst_ls, src, src_ls, tref, row, col, mv, \
-                    px, py, pw, ph, bw, bh, w, h, i) \
-    mc_luma_unscaled(s, s->dsp.mc, dst, dst_ls, src, src_ls, tref, row, col, \
-                     mv, bw, bh, w, h, bytesperpixel)
-#define mc_chroma_dir(s, mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
-                      row, col, mv, px, py, pw, ph, bw, bh, w, h, i) \
-    mc_chroma_unscaled(s, s->dsp.mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
-                       row, col, mv, bw, bh, w, h, bytesperpixel)
-#define SCALED 0
-#define FN(x) x##_8bpp
-#define BYTES_PER_PIXEL 1
-#include "vp9_mc_template.c"
-#undef FN
-#undef BYTES_PER_PIXEL
-#define FN(x) x##_16bpp
-#define BYTES_PER_PIXEL 2
-#include "vp9_mc_template.c"
-#undef mc_luma_dir
-#undef mc_chroma_dir
-#undef FN
-#undef BYTES_PER_PIXEL
-#undef SCALED
-
-static av_always_inline void mc_luma_scaled(VP9Context *s, vp9_scaled_mc_func smc,
-                                            vp9_mc_func (*mc)[2],
-                                            uint8_t *dst, ptrdiff_t dst_stride,
-                                            const uint8_t *ref, ptrdiff_t ref_stride,
-                                            ThreadFrame *ref_frame,
-                                            ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv,
-                                            int px, int py, int pw, int ph,
-                                            int bw, int bh, int w, int h, int bytesperpixel,
-                                            const uint16_t *scale, const uint8_t *step)
-{
-    if (s->s.frames[CUR_FRAME].tf.f->width == ref_frame->f->width &&
-        s->s.frames[CUR_FRAME].tf.f->height == ref_frame->f->height) {
-        mc_luma_unscaled(s, mc, dst, dst_stride, ref, ref_stride, ref_frame,
-                         y, x, in_mv, bw, bh, w, h, bytesperpixel);
-    } else {
-#define scale_mv(n, dim) (((int64_t)(n) * scale[dim]) >> 14)
-    int mx, my;
-    int refbw_m1, refbh_m1;
-    int th;
-    VP56mv mv;
-
-    mv.x = av_clip(in_mv->x, -(x + pw - px + 4) * 8, (s->cols * 8 - x + px + 3) * 8);
-    mv.y = av_clip(in_mv->y, -(y + ph - py + 4) * 8, (s->rows * 8 - y + py + 3) * 8);
-    // BUG libvpx seems to scale the two components separately. This introduces
-    // rounding errors but we have to reproduce them to be exactly compatible
-    // with the output from libvpx...
-    mx = scale_mv(mv.x * 2, 0) + scale_mv(x * 16, 0);
-    my = scale_mv(mv.y * 2, 1) + scale_mv(y * 16, 1);
-
-    y = my >> 4;
-    x = mx >> 4;
-    ref += y * ref_stride + x * bytesperpixel;
-    mx &= 15;
-    my &= 15;
-    refbw_m1 = ((bw - 1) * step[0] + mx) >> 4;
-    refbh_m1 = ((bh - 1) * step[1] + my) >> 4;
-    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
-    // we use +7 because the last 7 pixels of each sbrow can be changed in
-    // the longest loopfilter of the next sbrow
-    th = (y + refbh_m1 + 4 + 7) >> 6;
-    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
-    if (x < 3 || y < 3 || x + 4 >= w - refbw_m1 || y + 4 >= h - refbh_m1) {
-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
-                                 ref - 3 * ref_stride - 3 * bytesperpixel,
-                                 288, ref_stride,
-                                 refbw_m1 + 8, refbh_m1 + 8,
-                                 x - 3, y - 3, w, h);
-        ref = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
-        ref_stride = 288;
-    }
-    smc(dst, dst_stride, ref, ref_stride, bh, mx, my, step[0], step[1]);
-    }
-}
-
-static av_always_inline void mc_chroma_scaled(VP9Context *s, vp9_scaled_mc_func smc,
-                                              vp9_mc_func (*mc)[2],
-                                              uint8_t *dst_u, uint8_t *dst_v,
-                                              ptrdiff_t dst_stride,
-                                              const uint8_t *ref_u, ptrdiff_t src_stride_u,
-                                              const uint8_t *ref_v, ptrdiff_t src_stride_v,
-                                              ThreadFrame *ref_frame,
-                                              ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv,
-                                              int px, int py, int pw, int ph,
-                                              int bw, int bh, int w, int h, int bytesperpixel,
-                                              const uint16_t *scale, const uint8_t *step)
-{
-    if (s->s.frames[CUR_FRAME].tf.f->width == ref_frame->f->width &&
-        s->s.frames[CUR_FRAME].tf.f->height == ref_frame->f->height) {
-        mc_chroma_unscaled(s, mc, dst_u, dst_v, dst_stride, ref_u, src_stride_u,
-                           ref_v, src_stride_v, ref_frame,
-                           y, x, in_mv, bw, bh, w, h, bytesperpixel);
-    } else {
-    int mx, my;
-    int refbw_m1, refbh_m1;
-    int th;
-    VP56mv mv;
-
-    if (s->ss_h) {
-        // BUG https://code.google.com/p/webm/issues/detail?id=820
-        mv.x = av_clip(in_mv->x, -(x + pw - px + 4) * 16, (s->cols * 4 - x + px + 3) * 16);
-        mx = scale_mv(mv.x, 0) + (scale_mv(x * 16, 0) & ~15) + (scale_mv(x * 32, 0) & 15);
-    } else {
-        mv.x = av_clip(in_mv->x, -(x + pw - px + 4) * 8, (s->cols * 8 - x + px + 3) * 8);
-        mx = scale_mv(mv.x * 2, 0) + scale_mv(x * 16, 0);
-    }
-    if (s->ss_v) {
-        // BUG https://code.google.com/p/webm/issues/detail?id=820
-        mv.y = av_clip(in_mv->y, -(y + ph - py + 4) * 16, (s->rows * 4 - y + py + 3) * 16);
-        my = scale_mv(mv.y, 1) + (scale_mv(y * 16, 1) & ~15) + (scale_mv(y * 32, 1) & 15);
-    } else {
-        mv.y = av_clip(in_mv->y, -(y + ph - py + 4) * 8, (s->rows * 8 - y + py + 3) * 8);
-        my = scale_mv(mv.y * 2, 1) + scale_mv(y * 16, 1);
-    }
-#undef scale_mv
-    y = my >> 4;
-    x = mx >> 4;
-    ref_u += y * src_stride_u + x * bytesperpixel;
-    ref_v += y * src_stride_v + x * bytesperpixel;
-    mx &= 15;
-    my &= 15;
-    refbw_m1 = ((bw - 1) * step[0] + mx) >> 4;
-    refbh_m1 = ((bh - 1) * step[1] + my) >> 4;
-    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
-    // we use +7 because the last 7 pixels of each sbrow can be changed in
-    // the longest loopfilter of the next sbrow
-    th = (y + refbh_m1 + 4 + 7) >> (6 - s->ss_v);
-    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
-    if (x < 3 || y < 3 || x + 4 >= w - refbw_m1 || y + 4 >= h - refbh_m1) {
-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
-                                 ref_u - 3 * src_stride_u - 3 * bytesperpixel,
-                                 288, src_stride_u,
-                                 refbw_m1 + 8, refbh_m1 + 8,
-                                 x - 3, y - 3, w, h);
-        ref_u = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
-        smc(dst_u, dst_stride, ref_u, 288, bh, mx, my, step[0], step[1]);
-
-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
-                                 ref_v - 3 * src_stride_v - 3 * bytesperpixel,
-                                 288, src_stride_v,
-                                 refbw_m1 + 8, refbh_m1 + 8,
-                                 x - 3, y - 3, w, h);
-        ref_v = s->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
-        smc(dst_v, dst_stride, ref_v, 288, bh, mx, my, step[0], step[1]);
-    } else {
-        smc(dst_u, dst_stride, ref_u, src_stride_u, bh, mx, my, step[0], step[1]);
-        smc(dst_v, dst_stride, ref_v, src_stride_v, bh, mx, my, step[0], step[1]);
-    }
-    }
-}
-
-#define mc_luma_dir(s, mc, dst, dst_ls, src, src_ls, tref, row, col, mv, \
-                    px, py, pw, ph, bw, bh, w, h, i) \
-    mc_luma_scaled(s, s->dsp.s##mc, s->dsp.mc, dst, dst_ls, src, src_ls, tref, row, col, \
-                   mv, px, py, pw, ph, bw, bh, w, h, bytesperpixel, \
-                   s->mvscale[b->ref[i]], s->mvstep[b->ref[i]])
-#define mc_chroma_dir(s, mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
-                      row, col, mv, px, py, pw, ph, bw, bh, w, h, i) \
-    mc_chroma_scaled(s, s->dsp.s##mc, s->dsp.mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
-                     row, col, mv, px, py, pw, ph, bw, bh, w, h, bytesperpixel, \
-                     s->mvscale[b->ref[i]], s->mvstep[b->ref[i]])
-#define SCALED 1
-#define FN(x) x##_scaled_8bpp
-#define BYTES_PER_PIXEL 1
-#include "vp9_mc_template.c"
-#undef FN
-#undef BYTES_PER_PIXEL
-#define FN(x) x##_scaled_16bpp
-#define BYTES_PER_PIXEL 2
-#include "vp9_mc_template.c"
-#undef mc_luma_dir
-#undef mc_chroma_dir
-#undef FN
-#undef BYTES_PER_PIXEL
-#undef SCALED
-
-static av_always_inline void inter_recon(AVCodecContext *ctx, int bytesperpixel)
-{
-    VP9Context *s = ctx->priv_data;
-    VP9Block *b = s->b;
-    int row = s->row, col = s->col;
-
-    if (s->mvscale[b->ref[0]][0] || (b->comp && s->mvscale[b->ref[1]][0])) {
-        if (bytesperpixel == 1) {
-            inter_pred_scaled_8bpp(ctx);
-        } else {
-            inter_pred_scaled_16bpp(ctx);
-        }
-    } else {
-        if (bytesperpixel == 1) {
-            inter_pred_8bpp(ctx);
-        } else {
-            inter_pred_16bpp(ctx);
-        }
-    }
-    if (!b->skip) {
-        /* mostly copied intra_recon() */
-
-        int w4 = bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
-        int h4 = bwh_tab[1][b->bs][1] << 1, x, y, step = 1 << (b->tx * 2);
-        int end_x = FFMIN(2 * (s->cols - col), w4);
-        int end_y = FFMIN(2 * (s->rows - row), h4);
-        int tx = 4 * s->s.h.lossless + b->tx, uvtx = b->uvtx + 4 * s->s.h.lossless;
-        int uvstep1d = 1 << b->uvtx, p;
-        uint8_t *dst = s->dst[0];
-
-        // y itxfm add
-        for (n = 0, y = 0; y < end_y; y += step1d) {
-            uint8_t *ptr = dst;
-            for (x = 0; x < end_x; x += step1d,
-                 ptr += 4 * step1d * bytesperpixel, n += step) {
-                int eob = b->tx > TX_8X8 ? AV_RN16A(&s->eob[n]) : s->eob[n];
-
-                if (eob)
-                    s->dsp.itxfm_add[tx][DCT_DCT](ptr, s->y_stride,
-                                                  s->block + 16 * n * bytesperpixel, eob);
-            }
-            dst += 4 * s->y_stride * step1d;
-        }
-
-        // uv itxfm add
-        end_x >>= s->ss_h;
-        end_y >>= s->ss_v;
-        step = 1 << (b->uvtx * 2);
-        for (p = 0; p < 2; p++) {
-            dst = s->dst[p + 1];
-            for (n = 0, y = 0; y < end_y; y += uvstep1d) {
-                uint8_t *ptr = dst;
-                for (x = 0; x < end_x; x += uvstep1d,
-                     ptr += 4 * uvstep1d * bytesperpixel, n += step) {
-                    int eob = b->uvtx > TX_8X8 ? AV_RN16A(&s->uveob[p][n]) : s->uveob[p][n];
-
-                    if (eob)
-                        s->dsp.itxfm_add[uvtx][DCT_DCT](ptr, s->uv_stride,
-                                                        s->uvblock[p] + 16 * n * bytesperpixel, eob);
-                }
-                dst += 4 * uvstep1d * s->uv_stride;
-            }
-        }
-    }
-}
-
-static void inter_recon_8bpp(AVCodecContext *ctx)
-{
-    inter_recon(ctx, 1);
-}
-
-static void inter_recon_16bpp(AVCodecContext *ctx)
-{
-    inter_recon(ctx, 2);
-}
-
-static av_always_inline void mask_edges(uint8_t (*mask)[8][4], int ss_h, int ss_v,
-                                        int row_and_7, int col_and_7,
-                                        int w, int h, int col_end, int row_end,
-                                        enum TxfmMode tx, int skip_inter)
-{
-    static const unsigned wide_filter_col_mask[2] = { 0x11, 0x01 };
-    static const unsigned wide_filter_row_mask[2] = { 0x03, 0x07 };
-
-    // FIXME I'm pretty sure all loops can be replaced by a single LUT if
-    // we make VP9Filter.mask uint64_t (i.e. row/col all single variable)
-    // and make the LUT 5-indexed (bl, bp, is_uv, tx and row/col), and then
-    // use row_and_7/col_and_7 as shifts (1*col_and_7+8*row_and_7)
-
-    // the intended behaviour of the vp9 loopfilter is to work on 8-pixel
-    // edges. This means that for UV, we work on two subsampled blocks at
-    // a time, and we only use the topleft block's mode information to set
-    // things like block strength. Thus, for any block size smaller than
-    // 16x16, ignore the odd portion of the block.
-    if (tx == TX_4X4 && (ss_v | ss_h)) {
-        if (h == ss_v) {
-            if (row_and_7 & 1)
-                return;
-            if (!row_end)
-                h += 1;
-        }
-        if (w == ss_h) {
-            if (col_and_7 & 1)
-                return;
-            if (!col_end)
-                w += 1;
-        }
-    }
-
-    if (tx == TX_4X4 && !skip_inter) {
-        int t = 1 << col_and_7, m_col = (t << w) - t, y;
-        // on 32-px edges, use the 8-px wide loopfilter; else, use 4-px wide
-        int m_row_8 = m_col & wide_filter_col_mask[ss_h], m_row_4 = m_col - m_row_8;
-
-        for (y = row_and_7; y < h + row_and_7; y++) {
-            int col_mask_id = 2 - !(y & wide_filter_row_mask[ss_v]);
-
-            mask[0][y][1] |= m_row_8;
-            mask[0][y][2] |= m_row_4;
-            // for odd lines, if the odd col is not being filtered,
-            // skip odd row also:
-            // .---. <-- a
-            // |   |
-            // |___| <-- b
-            // ^   ^
-            // c   d
-            //
-            // if a/c are even row/col and b/d are odd, and d is skipped,
-            // e.g. right edge of size-66x66.webm, then skip b also (bug)
-            if ((ss_h & ss_v) && (col_end & 1) && (y & 1)) {
-                mask[1][y][col_mask_id] |= (t << (w - 1)) - t;
-            } else {
-                mask[1][y][col_mask_id] |= m_col;
-            }
-            if (!ss_h)
-                mask[0][y][3] |= m_col;
-            if (!ss_v) {
-                if (ss_h && (col_end & 1))
-                    mask[1][y][3] |= (t << (w - 1)) - t;
-                else
-                    mask[1][y][3] |= m_col;
-            }
-        }
-    } else {
-        int y, t = 1 << col_and_7, m_col = (t << w) - t;
-
-        if (!skip_inter) {
-            int mask_id = (tx == TX_8X8);
-            static const unsigned masks[4] = { 0xff, 0x55, 0x11, 0x01 };
-            int l2 = tx + ss_h - 1, step1d;
-            int m_row = m_col & masks[l2];
-
-            // at odd UV col/row edges tx16/tx32 loopfilter edges, force
-            // 8wd loopfilter to prevent going off the visible edge.
-            if (ss_h && tx > TX_8X8 && (w ^ (w - 1)) == 1) {
-                int m_row_16 = ((t << (w - 1)) - t) & masks[l2];
-                int m_row_8 = m_row - m_row_16;
-
-                for (y = row_and_7; y < h + row_and_7; y++) {
-                    mask[0][y][0] |= m_row_16;
-                    mask[0][y][1] |= m_row_8;
-                }
-            } else {
-                for (y = row_and_7; y < h + row_and_7; y++)
-                    mask[0][y][mask_id] |= m_row;
-            }
-
-            l2 = tx + ss_v - 1;
-            step1d = 1 << l2;
-            if (ss_v && tx > TX_8X8 && (h ^ (h - 1)) == 1) {
-                for (y = row_and_7; y < h + row_and_7 - 1; y += step1d)
-                    mask[1][y][0] |= m_col;
-                if (y - row_and_7 == h - 1)
-                    mask[1][y][1] |= m_col;
-            } else {
-                for (y = row_and_7; y < h + row_and_7; y += step1d)
-                    mask[1][y][mask_id] |= m_col;
-            }
-        } else if (tx != TX_4X4) {
-            int mask_id;
-
-            mask_id = (tx == TX_8X8) || (h == ss_v);
-            mask[1][row_and_7][mask_id] |= m_col;
-            mask_id = (tx == TX_8X8) || (w == ss_h);
-            for (y = row_and_7; y < h + row_and_7; y++)
-                mask[0][y][mask_id] |= t;
-        } else {
-            int t8 = t & wide_filter_col_mask[ss_h], t4 = t - t8;
-
-            for (y = row_and_7; y < h + row_and_7; y++) {
-                mask[0][y][2] |= t4;
-                mask[0][y][1] |= t8;
-            }
-            mask[1][row_and_7][2 - !(row_and_7 & wide_filter_row_mask[ss_v])] |= m_col;
-        }
-    }
-}
-
-static void decode_b(AVCodecContext *ctx, int row, int col,
-                     struct VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff,
-                     enum BlockLevel bl, enum BlockPartition bp)
-{
-    VP9Context *s = ctx->priv_data;
-    VP9Block *b = s->b;
-    enum BlockSize bs = bl * 3 + bp;
-    int bytesperpixel = s->bytesperpixel;
-    int w4 = bwh_tab[1][bs][0], h4 = bwh_tab[1][bs][1], lvl;
-    int emu[2];
-    AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
-
-    s->row = row;
-    s->row7 = row & 7;
-    s->col = col;
-    s->col7 = col & 7;
-    s->min_mv.x = -(128 + col * 64);
-    s->min_mv.y = -(128 + row * 64);
-    s->max_mv.x = 128 + (s->cols - col - w4) * 64;
-    s->max_mv.y = 128 + (s->rows - row - h4) * 64;
-    if (s->pass < 2) {
-        b->bs = bs;
-        b->bl = bl;
-        b->bp = bp;
-        decode_mode(ctx);
-        b->uvtx = b->tx - ((s->ss_h && w4 * 2 == (1 << b->tx)) ||
-                           (s->ss_v && h4 * 2 == (1 << b->tx)));
-
-        if (!b->skip) {
-            int has_coeffs;
-
-            if (bytesperpixel == 1) {
-                has_coeffs = decode_coeffs_8bpp(ctx);
-            } else {
-                has_coeffs = decode_coeffs_16bpp(ctx);
-            }
-            if (!has_coeffs && b->bs <= BS_8x8 && !b->intra) {
-                b->skip = 1;
-                memset(&s->above_skip_ctx[col], 1, w4);
-                memset(&s->left_skip_ctx[s->row7], 1, h4);
-            }
-        } else {
-            int row7 = s->row7;
-
-#define SPLAT_ZERO_CTX(v, n) \
-    switch (n) { \
-    case 1:  v = 0;          break; \
-    case 2:  AV_ZERO16(&v);  break; \
-    case 4:  AV_ZERO32(&v);  break; \
-    case 8:  AV_ZERO64(&v);  break; \
-    case 16: AV_ZERO128(&v); break; \
-    }
-#define SPLAT_ZERO_YUV(dir, var, off, n, dir2) \
-    do { \
-        SPLAT_ZERO_CTX(s->dir##_y_##var[off * 2], n * 2); \
-        if (s->ss_##dir2) { \
-            SPLAT_ZERO_CTX(s->dir##_uv_##var[0][off], n); \
-            SPLAT_ZERO_CTX(s->dir##_uv_##var[1][off], n); \
-        } else { \
-            SPLAT_ZERO_CTX(s->dir##_uv_##var[0][off * 2], n * 2); \
-            SPLAT_ZERO_CTX(s->dir##_uv_##var[1][off * 2], n * 2); \
-        } \
-    } while (0)
-
-            switch (w4) {
-            case 1: SPLAT_ZERO_YUV(above, nnz_ctx, col, 1, h); break;
-            case 2: SPLAT_ZERO_YUV(above, nnz_ctx, col, 2, h); break;
-            case 4: SPLAT_ZERO_YUV(above, nnz_ctx, col, 4, h); break;
-            case 8: SPLAT_ZERO_YUV(above, nnz_ctx, col, 8, h); break;
-            }
-            switch (h4) {
-            case 1: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 1, v); break;
-            case 2: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 2, v); break;
-            case 4: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 4, v); break;
-            case 8: SPLAT_ZERO_YUV(left, nnz_ctx, row7, 8, v); break;
-            }
-        }
-
-        if (s->pass == 1) {
-            s->b++;
-            s->block += w4 * h4 * 64 * bytesperpixel;
-            s->uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v);
-            s->uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v);
-            s->eob += 4 * w4 * h4;
-            s->uveob[0] += 4 * w4 * h4 >> (s->ss_h + s->ss_v);
-            s->uveob[1] += 4 * w4 * h4 >> (s->ss_h + s->ss_v);
-
-            return;
-        }
-    }
-
-    // emulated overhangs if the stride of the target buffer can't hold. This
-    // makes it possible to support emu-edge and so on even if we have large block
-    // overhangs
-    emu[0] = (col + w4) * 8 * bytesperpixel > f->linesize[0] ||
-             (row + h4) > s->rows;
-    emu[1] = ((col + w4) * 8 >> s->ss_h) * bytesperpixel > f->linesize[1] ||
-             (row + h4) > s->rows;
-    if (emu[0]) {
-        s->dst[0] = s->tmp_y;
-        s->y_stride = 128;
-    } else {
-        s->dst[0] = f->data[0] + yoff;
-        s->y_stride = f->linesize[0];
-    }
-    if (emu[1]) {
-        s->dst[1] = s->tmp_uv[0];
-        s->dst[2] = s->tmp_uv[1];
-        s->uv_stride = 128;
-    } else {
-        s->dst[1] = f->data[1] + uvoff;
-        s->dst[2] = f->data[2] + uvoff;
-        s->uv_stride = f->linesize[1];
-    }
-    if (b->intra) {
-        if (s->bpp > 8) {
-            intra_recon_16bpp(ctx, yoff, uvoff);
-        } else {
-            intra_recon_8bpp(ctx, yoff, uvoff);
-        }
-    } else {
-        if (s->bpp > 8) {
-            inter_recon_16bpp(ctx);
-        } else {
-            inter_recon_8bpp(ctx);
-        }
-    }
-    if (emu[0]) {
-        int w = FFMIN(s->cols - col, w4) * 8, h = FFMIN(s->rows - row, h4) * 8, n, o = 0;
-
-        for (n = 0; o < w; n++) {
-            int bw = 64 >> n;
-
-            av_assert2(n <= 4);
-            if (w & bw) {
-                s->dsp.mc[n][0][0][0][0](f->data[0] + yoff + o * bytesperpixel, f->linesize[0],
-                                         s->tmp_y + o * bytesperpixel, 128, h, 0, 0);
-                o += bw;
-            }
-        }
-    }
-    if (emu[1]) {
-        int w = FFMIN(s->cols - col, w4) * 8 >> s->ss_h;
-        int h = FFMIN(s->rows - row, h4) * 8 >> s->ss_v, n, o = 0;
-
-        for (n = s->ss_h; o < w; n++) {
-            int bw = 64 >> n;
-
-            av_assert2(n <= 4);
-            if (w & bw) {
-                s->dsp.mc[n][0][0][0][0](f->data[1] + uvoff + o * bytesperpixel, f->linesize[1],
-                                         s->tmp_uv[0] + o * bytesperpixel, 128, h, 0, 0);
-                s->dsp.mc[n][0][0][0][0](f->data[2] + uvoff + o * bytesperpixel, f->linesize[2],
-                                         s->tmp_uv[1] + o * bytesperpixel, 128, h, 0, 0);
-                o += bw;
-            }
-        }
-    }
-
-    // pick filter level and find edges to apply filter to
-    if (s->s.h.filter.level &&
-        (lvl = s->s.h.segmentation.feat[b->seg_id].lflvl[b->intra ? 0 : b->ref[0] + 1]
-                                                      [b->mode[3] != ZEROMV]) > 0) {
-        int x_end = FFMIN(s->cols - col, w4), y_end = FFMIN(s->rows - row, h4);
-        int skip_inter = !b->intra && b->skip, col7 = s->col7, row7 = s->row7;
-
-        setctx_2d(&lflvl->level[row7 * 8 + col7], w4, h4, 8, lvl);
-        mask_edges(lflvl->mask[0], 0, 0, row7, col7, x_end, y_end, 0, 0, b->tx, skip_inter);
-        if (s->ss_h || s->ss_v)
-            mask_edges(lflvl->mask[1], s->ss_h, s->ss_v, row7, col7, x_end, y_end,
-                       s->cols & 1 && col + w4 >= s->cols ? s->cols & 7 : 0,
-                       s->rows & 1 && row + h4 >= s->rows ? s->rows & 7 : 0,
-                       b->uvtx, skip_inter);
-
-        if (!s->filter_lut.lim_lut[lvl]) {
-            int sharp = s->s.h.filter.sharpness;
-            int limit = lvl;
-
-            if (sharp > 0) {
-                limit >>= (sharp + 3) >> 2;
-                limit = FFMIN(limit, 9 - sharp);
-            }
-            limit = FFMAX(limit, 1);
-
-            s->filter_lut.lim_lut[lvl] = limit;
-            s->filter_lut.mblim_lut[lvl] = 2 * (lvl + 2) + limit;
-        }
-    }
-
-    if (s->pass == 2) {
-        s->b++;
-        s->block += w4 * h4 * 64 * bytesperpixel;
-        s->uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h);
-        s->uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h);
-        s->eob += 4 * w4 * h4;
-        s->uveob[0] += 4 * w4 * h4 >> (s->ss_v + s->ss_h);
-        s->uveob[1] += 4 * w4 * h4 >> (s->ss_v + s->ss_h);
-    }
-}
-
-static void decode_sb(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl,
-                      ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
-{
-    VP9Context *s = ctx->priv_data;
-    int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
-            (((s->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);
-    const uint8_t *p = s->s.h.keyframe || s->s.h.intraonly ? vp9_default_kf_partition_probs[bl][c] :
-                                                     s->prob.p.partition[bl][c];
-    enum BlockPartition bp;
-    ptrdiff_t hbs = 4 >> bl;
-    AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
-    ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
-    int bytesperpixel = s->bytesperpixel;
-
-    if (bl == BL_8X8) {
-        bp = vp8_rac_get_tree(&s->c, vp9_partition_tree, p);
-        decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
-    } else if (col + hbs < s->cols) { // FIXME why not <=?
-        if (row + hbs < s->rows) { // FIXME why not <=?
-            bp = vp8_rac_get_tree(&s->c, vp9_partition_tree, p);
-            switch (bp) {
-            case PARTITION_NONE:
-                decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
-                break;
-            case PARTITION_H:
-                decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
-                yoff  += hbs * 8 * y_stride;
-                uvoff += hbs * 8 * uv_stride >> s->ss_v;
-                decode_b(ctx, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
-                break;
-            case PARTITION_V:
-                decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
-                yoff  += hbs * 8 * bytesperpixel;
-                uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
-                decode_b(ctx, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
-                break;
-            case PARTITION_SPLIT:
-                decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
-                decode_sb(ctx, row, col + hbs, lflvl,
-                          yoff + 8 * hbs * bytesperpixel,
-                          uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
-                yoff  += hbs * 8 * y_stride;
-                uvoff += hbs * 8 * uv_stride >> s->ss_v;
-                decode_sb(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
-                decode_sb(ctx, row + hbs, col + hbs, lflvl,
-                          yoff + 8 * hbs * bytesperpixel,
-                          uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
-                break;
-            default:
-                av_assert0(0);
-            }
-        } else if (vp56_rac_get_prob_branchy(&s->c, p[1])) {
-            bp = PARTITION_SPLIT;
-            decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
-            decode_sb(ctx, row, col + hbs, lflvl,
-                      yoff + 8 * hbs * bytesperpixel,
-                      uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
-        } else {
-            bp = PARTITION_H;
-            decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
-        }
-    } else if (row + hbs < s->rows) { // FIXME why not <=?
-        if (vp56_rac_get_prob_branchy(&s->c, p[2])) {
-            bp = PARTITION_SPLIT;
-            decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
-            yoff  += hbs * 8 * y_stride;
-            uvoff += hbs * 8 * uv_stride >> s->ss_v;
-            decode_sb(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
-        } else {
-            bp = PARTITION_V;
-            decode_b(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
-        }
-    } else {
-        bp = PARTITION_SPLIT;
-        decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
-    }
-    s->counts.partition[bl][c][bp]++;
-}
-
-static void decode_sb_mem(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl,
-                          ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
-{
-    VP9Context *s = ctx->priv_data;
-    VP9Block *b = s->b;
-    ptrdiff_t hbs = 4 >> bl;
-    AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
-    ptrdiff_t y_stride = f->linesize[0], uv_stride = f->linesize[1];
-    int bytesperpixel = s->bytesperpixel;
-
-    if (bl == BL_8X8) {
-        av_assert2(b->bl == BL_8X8);
-        decode_b(ctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
-    } else if (s->b->bl == bl) {
-        decode_b(ctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
-        if (b->bp == PARTITION_H && row + hbs < s->rows) {
-            yoff  += hbs * 8 * y_stride;
-            uvoff += hbs * 8 * uv_stride >> s->ss_v;
-            decode_b(ctx, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
-        } else if (b->bp == PARTITION_V && col + hbs < s->cols) {
-            yoff  += hbs * 8 * bytesperpixel;
-            uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
-            decode_b(ctx, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
-        }
-    } else {
-        decode_sb_mem(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
-        if (col + hbs < s->cols) { // FIXME why not <=?
-            if (row + hbs < s->rows) {
-                decode_sb_mem(ctx, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
-                              uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
-                yoff  += hbs * 8 * y_stride;
-                uvoff += hbs * 8 * uv_stride >> s->ss_v;
-                decode_sb_mem(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
-                decode_sb_mem(ctx, row + hbs, col + hbs, lflvl,
-                              yoff + 8 * hbs * bytesperpixel,
-                              uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
-            } else {
-                yoff  += hbs * 8 * bytesperpixel;
-                uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
-                decode_sb_mem(ctx, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
-            }
-        } else if (row + hbs < s->rows) {
-            yoff  += hbs * 8 * y_stride;
-            uvoff += hbs * 8 * uv_stride >> s->ss_v;
-            decode_sb_mem(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
+            vp9_report_tile_progress(s, row >> 3, 1);
         }
     }
+    return 0;
 }
 
-static av_always_inline void filter_plane_cols(VP9Context *s, int col, int ss_h, int ss_v,
-                                               uint8_t *lvl, uint8_t (*mask)[4],
-                                               uint8_t *dst, ptrdiff_t ls)
+static av_always_inline
+int loopfilter_proc(AVCodecContext *avctx)
 {
-    int y, x, bytesperpixel = s->bytesperpixel;
-
-    // filter edges between columns (e.g. block1 | block2)
-    for (y = 0; y < 8; y += 2 << ss_v, dst += 16 * ls, lvl += 16 << ss_v) {
-        uint8_t *ptr = dst, *l = lvl, *hmask1 = mask[y], *hmask2 = mask[y + 1 + ss_v];
-        unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2], hm13 = hmask1[3];
-        unsigned hm2 = hmask2[1] | hmask2[2], hm23 = hmask2[3];
-        unsigned hm = hm1 | hm2 | hm13 | hm23;
-
-        for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 8 * bytesperpixel >> ss_h) {
-            if (col || x > 1) {
-                if (hm1 & x) {
-                    int L = *l, H = L >> 4;
-                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
-
-                    if (hmask1[0] & x) {
-                        if (hmask2[0] & x) {
-                            av_assert2(l[8 << ss_v] == L);
-                            s->dsp.loop_filter_16[0](ptr, ls, E, I, H);
-                        } else {
-                            s->dsp.loop_filter_8[2][0](ptr, ls, E, I, H);
-                        }
-                    } else if (hm2 & x) {
-                        L = l[8 << ss_v];
-                        H |= (L >> 4) << 8;
-                        E |= s->filter_lut.mblim_lut[L] << 8;
-                        I |= s->filter_lut.lim_lut[L] << 8;
-                        s->dsp.loop_filter_mix2[!!(hmask1[1] & x)]
-                                               [!!(hmask2[1] & x)]
-                                               [0](ptr, ls, E, I, H);
-                    } else {
-                        s->dsp.loop_filter_8[!!(hmask1[1] & x)]
-                                            [0](ptr, ls, E, I, H);
-                    }
-                } else if (hm2 & x) {
-                    int L = l[8 << ss_v], H = L >> 4;
-                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
-
-                    s->dsp.loop_filter_8[!!(hmask2[1] & x)]
-                                        [0](ptr + 8 * ls, ls, E, I, H);
-                }
-            }
-            if (ss_h) {
-                if (x & 0xAA)
-                    l += 2;
-            } else {
-                if (hm13 & x) {
-                    int L = *l, H = L >> 4;
-                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
-
-                    if (hm23 & x) {
-                        L = l[8 << ss_v];
-                        H |= (L >> 4) << 8;
-                        E |= s->filter_lut.mblim_lut[L] << 8;
-                        I |= s->filter_lut.lim_lut[L] << 8;
-                        s->dsp.loop_filter_mix2[0][0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
-                    } else {
-                        s->dsp.loop_filter_8[0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
-                    }
-                } else if (hm23 & x) {
-                    int L = l[8 << ss_v], H = L >> 4;
-                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
-
-                    s->dsp.loop_filter_8[0][0](ptr + 8 * ls + 4 * bytesperpixel, ls, E, I, H);
-                }
-                l++;
-            }
-        }
-    }
-}
+    VP9Context *s = avctx->priv_data;
+    ptrdiff_t uvoff, yoff, ls_y, ls_uv;
+    VP9Filter *lflvl_ptr;
+    int bytesperpixel = s->bytesperpixel, col, i;
+    AVFrame *f;
 
-static av_always_inline void filter_plane_rows(VP9Context *s, int row, int ss_h, int ss_v,
-                                               uint8_t *lvl, uint8_t (*mask)[4],
-                                               uint8_t *dst, ptrdiff_t ls)
-{
-    int y, x, bytesperpixel = s->bytesperpixel;
-
-    //                                 block1
-    // filter edges between rows (e.g. ------)
-    //                                 block2
-    for (y = 0; y < 8; y++, dst += 8 * ls >> ss_v) {
-        uint8_t *ptr = dst, *l = lvl, *vmask = mask[y];
-        unsigned vm = vmask[0] | vmask[1] | vmask[2], vm3 = vmask[3];
-
-        for (x = 1; vm & ~(x - 1); x <<= (2 << ss_h), ptr += 16 * bytesperpixel, l += 2 << ss_h) {
-            if (row || y) {
-                if (vm & x) {
-                    int L = *l, H = L >> 4;
-                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
-
-                    if (vmask[0] & x) {
-                        if (vmask[0] & (x << (1 + ss_h))) {
-                            av_assert2(l[1 + ss_h] == L);
-                            s->dsp.loop_filter_16[1](ptr, ls, E, I, H);
-                        } else {
-                            s->dsp.loop_filter_8[2][1](ptr, ls, E, I, H);
-                        }
-                    } else if (vm & (x << (1 + ss_h))) {
-                        L = l[1 + ss_h];
-                        H |= (L >> 4) << 8;
-                        E |= s->filter_lut.mblim_lut[L] << 8;
-                        I |= s->filter_lut.lim_lut[L] << 8;
-                        s->dsp.loop_filter_mix2[!!(vmask[1] &  x)]
-                                               [!!(vmask[1] & (x << (1 + ss_h)))]
-                                               [1](ptr, ls, E, I, H);
-                    } else {
-                        s->dsp.loop_filter_8[!!(vmask[1] & x)]
-                                            [1](ptr, ls, E, I, H);
-                    }
-                } else if (vm & (x << (1 + ss_h))) {
-                    int L = l[1 + ss_h], H = L >> 4;
-                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
+    f = s->s.frames[CUR_FRAME].tf.f;
+    ls_y = f->linesize[0];
+    ls_uv =f->linesize[1];
 
-                    s->dsp.loop_filter_8[!!(vmask[1] & (x << (1 + ss_h)))]
-                                        [1](ptr + 8 * bytesperpixel, ls, E, I, H);
-                }
-            }
-            if (!ss_v) {
-                if (vm3 & x) {
-                    int L = *l, H = L >> 4;
-                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
-
-                    if (vm3 & (x << (1 + ss_h))) {
-                        L = l[1 + ss_h];
-                        H |= (L >> 4) << 8;
-                        E |= s->filter_lut.mblim_lut[L] << 8;
-                        I |= s->filter_lut.lim_lut[L] << 8;
-                        s->dsp.loop_filter_mix2[0][0][1](ptr + ls * 4, ls, E, I, H);
-                    } else {
-                        s->dsp.loop_filter_8[0][1](ptr + ls * 4, ls, E, I, H);
-                    }
-                } else if (vm3 & (x << (1 + ss_h))) {
-                    int L = l[1 + ss_h], H = L >> 4;
-                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
+    for (i = 0; i < s->sb_rows; i++) {
+        vp9_await_tile_progress(s, i, s->s.h.tiling.tile_cols);
 
-                    s->dsp.loop_filter_8[0][1](ptr + ls * 4 + 8 * bytesperpixel, ls, E, I, H);
-                }
+        if (s->s.h.filter.level) {
+            yoff = (ls_y * 64)*i;
+            uvoff =  (ls_uv * 64 >> s->ss_v)*i;
+            lflvl_ptr = s->lflvl+s->sb_cols*i;
+            for (col = 0; col < s->cols;
+                 col += 8, yoff += 64 * bytesperpixel,
+                 uvoff += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
+                ff_vp9_loopfilter_sb(avctx, lflvl_ptr, i << 3, col,
+                                     yoff, uvoff);
             }
         }
-        if (ss_v) {
-            if (y & 1)
-                lvl += 16;
-        } else {
-            lvl += 8;
-        }
-    }
-}
-
-static void loopfilter_sb(AVCodecContext *ctx, struct VP9Filter *lflvl,
-                          int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
-{
-    VP9Context *s = ctx->priv_data;
-    AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
-    uint8_t *dst = f->data[0] + yoff;
-    ptrdiff_t ls_y = f->linesize[0], ls_uv = f->linesize[1];
-    uint8_t (*uv_masks)[8][4] = lflvl->mask[s->ss_h | s->ss_v];
-    int p;
-
-    // FIXME in how far can we interleave the v/h loopfilter calls? E.g.
-    // if you think of them as acting on a 8x8 block max, we can interleave
-    // each v/h within the single x loop, but that only works if we work on
-    // 8 pixel blocks, and we won't always do that (we want at least 16px
-    // to use SSE2 optimizations, perhaps 32 for AVX2)
-
-    filter_plane_cols(s, col, 0, 0, lflvl->level, lflvl->mask[0][0], dst, ls_y);
-    filter_plane_rows(s, row, 0, 0, lflvl->level, lflvl->mask[0][1], dst, ls_y);
-
-    for (p = 0; p < 2; p++) {
-        dst = f->data[1 + p] + uvoff;
-        filter_plane_cols(s, col, s->ss_h, s->ss_v, lflvl->level, uv_masks[0], dst, ls_uv);
-        filter_plane_rows(s, row, s->ss_h, s->ss_v, lflvl->level, uv_masks[1], dst, ls_uv);
-    }
-}
-
-static void set_tile_offset(int *start, int *end, int idx, int log2_n, int n)
-{
-    int sb_start = ( idx      * n) >> log2_n;
-    int sb_end   = ((idx + 1) * n) >> log2_n;
-    *start = FFMIN(sb_start, n) << 3;
-    *end   = FFMIN(sb_end,   n) << 3;
-}
-
-static av_always_inline void adapt_prob(uint8_t *p, unsigned ct0, unsigned ct1,
-                                        int max_count, int update_factor)
-{
-    unsigned ct = ct0 + ct1, p2, p1;
-
-    if (!ct)
-        return;
-
-    update_factor = FASTDIV(update_factor * FFMIN(ct, max_count), max_count);
-    p1 = *p;
-    p2 = ((((int64_t) ct0) << 8) + (ct >> 1)) / ct;
-    p2 = av_clip(p2, 1, 255);
-
-    // (p1 * (256 - update_factor) + p2 * update_factor + 128) >> 8
-    *p = p1 + (((p2 - p1) * update_factor + 128) >> 8);
-}
-
-static void adapt_probs(VP9Context *s)
-{
-    int i, j, k, l, m;
-    prob_context *p = &s->prob_ctx[s->s.h.framectxid].p;
-    int uf = (s->s.h.keyframe || s->s.h.intraonly || !s->last_keyframe) ? 112 : 128;
-
-    // coefficients
-    for (i = 0; i < 4; i++)
-        for (j = 0; j < 2; j++)
-            for (k = 0; k < 2; k++)
-                for (l = 0; l < 6; l++)
-                    for (m = 0; m < 6; m++) {
-                        uint8_t *pp = s->prob_ctx[s->s.h.framectxid].coef[i][j][k][l][m];
-                        unsigned *e = s->counts.eob[i][j][k][l][m];
-                        unsigned *c = s->counts.coef[i][j][k][l][m];
-
-                        if (l == 0 && m >= 3) // dc only has 3 pt
-                            break;
-
-                        adapt_prob(&pp[0], e[0], e[1], 24, uf);
-                        adapt_prob(&pp[1], c[0], c[1] + c[2], 24, uf);
-                        adapt_prob(&pp[2], c[1], c[2], 24, uf);
-                    }
-
-    if (s->s.h.keyframe || s->s.h.intraonly) {
-        memcpy(p->skip,  s->prob.p.skip,  sizeof(p->skip));
-        memcpy(p->tx32p, s->prob.p.tx32p, sizeof(p->tx32p));
-        memcpy(p->tx16p, s->prob.p.tx16p, sizeof(p->tx16p));
-        memcpy(p->tx8p,  s->prob.p.tx8p,  sizeof(p->tx8p));
-        return;
-    }
-
-    // skip flag
-    for (i = 0; i < 3; i++)
-        adapt_prob(&p->skip[i], s->counts.skip[i][0], s->counts.skip[i][1], 20, 128);
-
-    // intra/inter flag
-    for (i = 0; i < 4; i++)
-        adapt_prob(&p->intra[i], s->counts.intra[i][0], s->counts.intra[i][1], 20, 128);
-
-    // comppred flag
-    if (s->s.h.comppredmode == PRED_SWITCHABLE) {
-      for (i = 0; i < 5; i++)
-          adapt_prob(&p->comp[i], s->counts.comp[i][0], s->counts.comp[i][1], 20, 128);
-    }
-
-    // reference frames
-    if (s->s.h.comppredmode != PRED_SINGLEREF) {
-      for (i = 0; i < 5; i++)
-          adapt_prob(&p->comp_ref[i], s->counts.comp_ref[i][0],
-                     s->counts.comp_ref[i][1], 20, 128);
-    }
-
-    if (s->s.h.comppredmode != PRED_COMPREF) {
-      for (i = 0; i < 5; i++) {
-          uint8_t *pp = p->single_ref[i];
-          unsigned (*c)[2] = s->counts.single_ref[i];
-
-          adapt_prob(&pp[0], c[0][0], c[0][1], 20, 128);
-          adapt_prob(&pp[1], c[1][0], c[1][1], 20, 128);
-      }
-    }
-
-    // block partitioning
-    for (i = 0; i < 4; i++)
-        for (j = 0; j < 4; j++) {
-            uint8_t *pp = p->partition[i][j];
-            unsigned *c = s->counts.partition[i][j];
-
-            adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
-            adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
-            adapt_prob(&pp[2], c[2], c[3], 20, 128);
-        }
-
-    // tx size
-    if (s->s.h.txfmmode == TX_SWITCHABLE) {
-      for (i = 0; i < 2; i++) {
-          unsigned *c16 = s->counts.tx16p[i], *c32 = s->counts.tx32p[i];
-
-          adapt_prob(&p->tx8p[i], s->counts.tx8p[i][0], s->counts.tx8p[i][1], 20, 128);
-          adapt_prob(&p->tx16p[i][0], c16[0], c16[1] + c16[2], 20, 128);
-          adapt_prob(&p->tx16p[i][1], c16[1], c16[2], 20, 128);
-          adapt_prob(&p->tx32p[i][0], c32[0], c32[1] + c32[2] + c32[3], 20, 128);
-          adapt_prob(&p->tx32p[i][1], c32[1], c32[2] + c32[3], 20, 128);
-          adapt_prob(&p->tx32p[i][2], c32[2], c32[3], 20, 128);
-      }
-    }
-
-    // interpolation filter
-    if (s->s.h.filtermode == FILTER_SWITCHABLE) {
-        for (i = 0; i < 4; i++) {
-            uint8_t *pp = p->filter[i];
-            unsigned *c = s->counts.filter[i];
-
-            adapt_prob(&pp[0], c[0], c[1] + c[2], 20, 128);
-            adapt_prob(&pp[1], c[1], c[2], 20, 128);
-        }
-    }
-
-    // inter modes
-    for (i = 0; i < 7; i++) {
-        uint8_t *pp = p->mv_mode[i];
-        unsigned *c = s->counts.mv_mode[i];
-
-        adapt_prob(&pp[0], c[2], c[1] + c[0] + c[3], 20, 128);
-        adapt_prob(&pp[1], c[0], c[1] + c[3], 20, 128);
-        adapt_prob(&pp[2], c[1], c[3], 20, 128);
-    }
-
-    // mv joints
-    {
-        uint8_t *pp = p->mv_joint;
-        unsigned *c = s->counts.mv_joint;
-
-        adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
-        adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
-        adapt_prob(&pp[2], c[2], c[3], 20, 128);
-    }
-
-    // mv components
-    for (i = 0; i < 2; i++) {
-        uint8_t *pp;
-        unsigned *c, (*c2)[2], sum;
-
-        adapt_prob(&p->mv_comp[i].sign, s->counts.mv_comp[i].sign[0],
-                   s->counts.mv_comp[i].sign[1], 20, 128);
-
-        pp = p->mv_comp[i].classes;
-        c = s->counts.mv_comp[i].classes;
-        sum = c[1] + c[2] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9] + c[10];
-        adapt_prob(&pp[0], c[0], sum, 20, 128);
-        sum -= c[1];
-        adapt_prob(&pp[1], c[1], sum, 20, 128);
-        sum -= c[2] + c[3];
-        adapt_prob(&pp[2], c[2] + c[3], sum, 20, 128);
-        adapt_prob(&pp[3], c[2], c[3], 20, 128);
-        sum -= c[4] + c[5];
-        adapt_prob(&pp[4], c[4] + c[5], sum, 20, 128);
-        adapt_prob(&pp[5], c[4], c[5], 20, 128);
-        sum -= c[6];
-        adapt_prob(&pp[6], c[6], sum, 20, 128);
-        adapt_prob(&pp[7], c[7] + c[8], c[9] + c[10], 20, 128);
-        adapt_prob(&pp[8], c[7], c[8], 20, 128);
-        adapt_prob(&pp[9], c[9], c[10], 20, 128);
-
-        adapt_prob(&p->mv_comp[i].class0, s->counts.mv_comp[i].class0[0],
-                   s->counts.mv_comp[i].class0[1], 20, 128);
-        pp = p->mv_comp[i].bits;
-        c2 = s->counts.mv_comp[i].bits;
-        for (j = 0; j < 10; j++)
-            adapt_prob(&pp[j], c2[j][0], c2[j][1], 20, 128);
-
-        for (j = 0; j < 2; j++) {
-            pp = p->mv_comp[i].class0_fp[j];
-            c = s->counts.mv_comp[i].class0_fp[j];
-            adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
-            adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
-            adapt_prob(&pp[2], c[2], c[3], 20, 128);
-        }
-        pp = p->mv_comp[i].fp;
-        c = s->counts.mv_comp[i].fp;
-        adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
-        adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
-        adapt_prob(&pp[2], c[2], c[3], 20, 128);
-
-        if (s->s.h.highprecisionmvs) {
-            adapt_prob(&p->mv_comp[i].class0_hp, s->counts.mv_comp[i].class0_hp[0],
-                       s->counts.mv_comp[i].class0_hp[1], 20, 128);
-            adapt_prob(&p->mv_comp[i].hp, s->counts.mv_comp[i].hp[0],
-                       s->counts.mv_comp[i].hp[1], 20, 128);
-        }
-    }
-
-    // y intra modes
-    for (i = 0; i < 4; i++) {
-        uint8_t *pp = p->y_mode[i];
-        unsigned *c = s->counts.y_mode[i], sum, s2;
-
-        sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
-        adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
-        sum -= c[TM_VP8_PRED];
-        adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
-        sum -= c[VERT_PRED];
-        adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
-        s2 = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
-        sum -= s2;
-        adapt_prob(&pp[3], s2, sum, 20, 128);
-        s2 -= c[HOR_PRED];
-        adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
-        adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED], 20, 128);
-        sum -= c[DIAG_DOWN_LEFT_PRED];
-        adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
-        sum -= c[VERT_LEFT_PRED];
-        adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
-        adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
-    }
-
-    // uv intra modes
-    for (i = 0; i < 10; i++) {
-        uint8_t *pp = p->uv_mode[i];
-        unsigned *c = s->counts.uv_mode[i], sum, s2;
-
-        sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
-        adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
-        sum -= c[TM_VP8_PRED];
-        adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
-        sum -= c[VERT_PRED];
-        adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
-        s2 = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
-        sum -= s2;
-        adapt_prob(&pp[3], s2, sum, 20, 128);
-        s2 -= c[HOR_PRED];
-        adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
-        adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED], 20, 128);
-        sum -= c[DIAG_DOWN_LEFT_PRED];
-        adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
-        sum -= c[VERT_LEFT_PRED];
-        adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
-        adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
-    }
-}
-
-static void free_buffers(VP9Context *s)
-{
-    av_freep(&s->intra_pred_data[0]);
-    av_freep(&s->b_base);
-    av_freep(&s->block_base);
-}
-
-static av_cold int vp9_decode_free(AVCodecContext *ctx)
-{
-    VP9Context *s = ctx->priv_data;
-    int i;
-
-    for (i = 0; i < 3; i++) {
-        if (s->s.frames[i].tf.f->buf[0])
-            vp9_unref_frame(ctx, &s->s.frames[i]);
-        av_frame_free(&s->s.frames[i].tf.f);
-    }
-    for (i = 0; i < 8; i++) {
-        if (s->s.refs[i].f->buf[0])
-            ff_thread_release_buffer(ctx, &s->s.refs[i]);
-        av_frame_free(&s->s.refs[i].f);
-        if (s->next_refs[i].f->buf[0])
-            ff_thread_release_buffer(ctx, &s->next_refs[i]);
-        av_frame_free(&s->next_refs[i].f);
     }
-    free_buffers(s);
-    av_freep(&s->c_b);
-    s->c_b_size = 0;
-
     return 0;
 }
+#endif
 
-
-static int vp9_decode_frame(AVCodecContext *ctx, void *frame,
+static int vp9_decode_frame(AVCodecContext *avctx, void *frame,
                             int *got_frame, AVPacket *pkt)
 {
     const uint8_t *data = pkt->data;
     int size = pkt->size;
-    VP9Context *s = ctx->priv_data;
-    int res, tile_row, tile_col, i, ref, row, col;
+    VP9Context *s = avctx->priv_data;
+    int ret, i, j, ref;
     int retain_segmap_ref = s->s.frames[REF_FRAME_SEGMAP].segmentation_map &&
                             (!s->s.h.segmentation.enabled || !s->s.h.segmentation.update_map);
-    ptrdiff_t yoff, uvoff, ls_y, ls_uv;
     AVFrame *f;
-    int bytesperpixel;
 
-    if ((res = decode_frame_header(ctx, data, size, &ref)) < 0) {
-        return res;
-    } else if (res == 0) {
+    if ((ret = decode_frame_header(avctx, data, size, &ref)) < 0) {
+        return ret;
+    } else if (ret == 0) {
         if (!s->s.refs[ref].f->buf[0]) {
-            av_log(ctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
+            av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
             return AVERROR_INVALIDDATA;
         }
-        if ((res = av_frame_ref(frame, s->s.refs[ref].f)) < 0)
-            return res;
+        if ((ret = av_frame_ref(frame, s->s.refs[ref].f)) < 0)
+            return ret;
         ((AVFrame *)frame)->pts = pkt->pts;
 #if FF_API_PKT_PTS
 FF_DISABLE_DEPRECATION_WARNINGS
@@ -4000,73 +1480,70 @@ FF_ENABLE_DEPRECATION_WARNINGS
         ((AVFrame *)frame)->pkt_dts = pkt->dts;
         for (i = 0; i < 8; i++) {
             if (s->next_refs[i].f->buf[0])
-                ff_thread_release_buffer(ctx, &s->next_refs[i]);
+                ff_thread_release_buffer(avctx, &s->next_refs[i]);
             if (s->s.refs[i].f->buf[0] &&
-                (res = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i])) < 0)
-                return res;
+                (ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i])) < 0)
+                return ret;
         }
         *got_frame = 1;
         return pkt->size;
     }
-    data += res;
-    size -= res;
+    data += ret;
+    size -= ret;
 
     if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly) {
         if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0])
-            vp9_unref_frame(ctx, &s->s.frames[REF_FRAME_SEGMAP]);
+            vp9_frame_unref(avctx, &s->s.frames[REF_FRAME_SEGMAP]);
         if (!s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
-            (res = vp9_ref_frame(ctx, &s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0)
-            return res;
+            (ret = vp9_frame_ref(avctx, &s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0)
+            return ret;
     }
     if (s->s.frames[REF_FRAME_MVPAIR].tf.f->buf[0])
-        vp9_unref_frame(ctx, &s->s.frames[REF_FRAME_MVPAIR]);
+        vp9_frame_unref(avctx, &s->s.frames[REF_FRAME_MVPAIR]);
     if (!s->s.h.intraonly && !s->s.h.keyframe && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
-        (res = vp9_ref_frame(ctx, &s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0)
-        return res;
+        (ret = vp9_frame_ref(avctx, &s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0)
+        return ret;
     if (s->s.frames[CUR_FRAME].tf.f->buf[0])
-        vp9_unref_frame(ctx, &s->s.frames[CUR_FRAME]);
-    if ((res = vp9_alloc_frame(ctx, &s->s.frames[CUR_FRAME])) < 0)
-        return res;
+        vp9_frame_unref(avctx, &s->s.frames[CUR_FRAME]);
+    if ((ret = vp9_frame_alloc(avctx, &s->s.frames[CUR_FRAME])) < 0)
+        return ret;
     f = s->s.frames[CUR_FRAME].tf.f;
     f->key_frame = s->s.h.keyframe;
     f->pict_type = (s->s.h.keyframe || s->s.h.intraonly) ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
-    ls_y = f->linesize[0];
-    ls_uv =f->linesize[1];
 
     if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0] &&
         (s->s.frames[REF_FRAME_MVPAIR].tf.f->width  != s->s.frames[CUR_FRAME].tf.f->width ||
          s->s.frames[REF_FRAME_MVPAIR].tf.f->height != s->s.frames[CUR_FRAME].tf.f->height)) {
-        vp9_unref_frame(ctx, &s->s.frames[REF_FRAME_SEGMAP]);
+        vp9_frame_unref(avctx, &s->s.frames[REF_FRAME_SEGMAP]);
     }
 
     // ref frame setup
     for (i = 0; i < 8; i++) {
         if (s->next_refs[i].f->buf[0])
-            ff_thread_release_buffer(ctx, &s->next_refs[i]);
+            ff_thread_release_buffer(avctx, &s->next_refs[i]);
         if (s->s.h.refreshrefmask & (1 << i)) {
-            res = ff_thread_ref_frame(&s->next_refs[i], &s->s.frames[CUR_FRAME].tf);
+            ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.frames[CUR_FRAME].tf);
         } else if (s->s.refs[i].f->buf[0]) {
-            res = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i]);
-        }
-        if (res < 0)
-            return res;
-    }
-
-    if (ctx->hwaccel) {
-        res = ctx->hwaccel->start_frame(ctx, NULL, 0);
-        if (res < 0)
-            return res;
-        res = ctx->hwaccel->decode_slice(ctx, pkt->data, pkt->size);
-        if (res < 0)
-            return res;
-        res = ctx->hwaccel->end_frame(ctx);
-        if (res < 0)
-            return res;
+            ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i]);
+        }
+        if (ret < 0)
+            return ret;
+    }
+
+    if (avctx->hwaccel) {
+        ret = avctx->hwaccel->start_frame(avctx, NULL, 0);
+        if (ret < 0)
+            return ret;
+        ret = avctx->hwaccel->decode_slice(avctx, pkt->data, pkt->size);
+        if (ret < 0)
+            return ret;
+        ret = avctx->hwaccel->end_frame(avctx);
+        if (ret < 0)
+            return ret;
         goto finish;
     }
 
     // main tile decode loop
-    bytesperpixel = s->bytesperpixel;
     memset(s->above_partition_ctx, 0, s->cols);
     memset(s->above_skip_ctx, 0, s->cols);
     if (s->s.h.keyframe || s->s.h.intraonly) {
@@ -4079,11 +1556,11 @@ FF_ENABLE_DEPRECATION_WARNINGS
     memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);
     memset(s->above_segpred_ctx, 0, s->cols);
     s->pass = s->s.frames[CUR_FRAME].uses_2pass =
-        ctx->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;
-    if ((res = update_block_buffers(ctx)) < 0) {
-        av_log(ctx, AV_LOG_ERROR,
+        avctx->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;
+    if ((ret = update_block_buffers(avctx)) < 0) {
+        av_log(avctx, AV_LOG_ERROR,
                "Failed to allocate block buffers\n");
-        return res;
+        return ret;
     }
     if (s->s.h.refreshctx && s->s.h.parallelmode) {
         int j, k, l, m;
@@ -4099,25 +1576,36 @@ FF_ENABLE_DEPRECATION_WARNINGS
                 break;
         }
         s->prob_ctx[s->s.h.framectxid].p = s->prob.p;
-        ff_thread_finish_setup(ctx);
+        ff_thread_finish_setup(avctx);
     } else if (!s->s.h.refreshctx) {
-        ff_thread_finish_setup(ctx);
+        ff_thread_finish_setup(avctx);
     }
 
+#if HAVE_THREADS
+    if (avctx->active_thread_type & FF_THREAD_SLICE) {
+        for (i = 0; i < s->sb_rows; i++)
+            atomic_store(&s->entries[i], 0);
+    }
+#endif
+
     do {
-        yoff = uvoff = 0;
-        s->b = s->b_base;
-        s->block = s->block_base;
-        s->uvblock[0] = s->uvblock_base[0];
-        s->uvblock[1] = s->uvblock_base[1];
-        s->eob = s->eob_base;
-        s->uveob[0] = s->uveob_base[0];
-        s->uveob[1] = s->uveob_base[1];
-
-        for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
-            set_tile_offset(&s->tile_row_start, &s->tile_row_end,
-                            tile_row, s->s.h.tiling.log2_tile_rows, s->sb_rows);
-            if (s->pass != 2) {
+        for (i = 0; i < s->active_tile_cols; i++) {
+            s->td[i].b = s->td[i].b_base;
+            s->td[i].block = s->td[i].block_base;
+            s->td[i].uvblock[0] = s->td[i].uvblock_base[0];
+            s->td[i].uvblock[1] = s->td[i].uvblock_base[1];
+            s->td[i].eob = s->td[i].eob_base;
+            s->td[i].uveob[0] = s->td[i].uveob_base[0];
+            s->td[i].uveob[1] = s->td[i].uveob_base[1];
+        }
+
+#if HAVE_THREADS
+        if (avctx->active_thread_type == FF_THREAD_SLICE) {
+            int tile_row, tile_col;
+
+            av_assert1(!s->pass);
+
+            for (tile_row = 0; tile_row < s->s.h.tiling.tile_rows; tile_row++) {
                 for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
                     int64_t tile_size;
 
@@ -4129,107 +1617,36 @@ FF_ENABLE_DEPRECATION_WARNINGS
                         data += 4;
                         size -= 4;
                     }
-                    if (tile_size > size) {
-                        ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
+                    if (tile_size > size)
                         return AVERROR_INVALIDDATA;
-                    }
-                    ff_vp56_init_range_decoder(&s->c_b[tile_col], data, tile_size);
-                    if (vp56_rac_get_prob_branchy(&s->c_b[tile_col], 128)) { // marker bit
-                        ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
+                    ret = ff_vp56_init_range_decoder(&s->td[tile_col].c_b[tile_row], data, tile_size);
+                    if (ret < 0)
+                        return ret;
+                    if (vp56_rac_get_prob_branchy(&s->td[tile_col].c_b[tile_row], 128)) // marker bit
                         return AVERROR_INVALIDDATA;
-                    }
                     data += tile_size;
                     size -= tile_size;
                 }
             }
 
-            for (row = s->tile_row_start; row < s->tile_row_end;
-                 row += 8, yoff += ls_y * 64, uvoff += ls_uv * 64 >> s->ss_v) {
-                struct VP9Filter *lflvl_ptr = s->lflvl;
-                ptrdiff_t yoff2 = yoff, uvoff2 = uvoff;
-
-                for (tile_col = 0; tile_col < s->s.h.tiling.tile_cols; tile_col++) {
-                    set_tile_offset(&s->tile_col_start, &s->tile_col_end,
-                                    tile_col, s->s.h.tiling.log2_tile_cols, s->sb_cols);
-
-                    if (s->pass != 2) {
-                        memset(s->left_partition_ctx, 0, 8);
-                        memset(s->left_skip_ctx, 0, 8);
-                        if (s->s.h.keyframe || s->s.h.intraonly) {
-                            memset(s->left_mode_ctx, DC_PRED, 16);
-                        } else {
-                            memset(s->left_mode_ctx, NEARESTMV, 8);
-                        }
-                        memset(s->left_y_nnz_ctx, 0, 16);
-                        memset(s->left_uv_nnz_ctx, 0, 32);
-                        memset(s->left_segpred_ctx, 0, 8);
-
-                        memcpy(&s->c, &s->c_b[tile_col], sizeof(s->c));
-                    }
-
-                    for (col = s->tile_col_start;
-                         col < s->tile_col_end;
-                         col += 8, yoff2 += 64 * bytesperpixel,
-                         uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
-                        // FIXME integrate with lf code (i.e. zero after each
-                        // use, similar to invtxfm coefficients, or similar)
-                        if (s->pass != 1) {
-                            memset(lflvl_ptr->mask, 0, sizeof(lflvl_ptr->mask));
-                        }
-
-                        if (s->pass == 2) {
-                            decode_sb_mem(ctx, row, col, lflvl_ptr,
-                                          yoff2, uvoff2, BL_64X64);
-                        } else {
-                            decode_sb(ctx, row, col, lflvl_ptr,
-                                      yoff2, uvoff2, BL_64X64);
-                        }
-                    }
-                    if (s->pass != 2) {
-                        memcpy(&s->c_b[tile_col], &s->c, sizeof(s->c));
-                    }
-                }
-
-                if (s->pass == 1) {
-                    continue;
-                }
-
-                // backup pre-loopfilter reconstruction data for intra
-                // prediction of next row of sb64s
-                if (row + 8 < s->rows) {
-                    memcpy(s->intra_pred_data[0],
-                           f->data[0] + yoff + 63 * ls_y,
-                           8 * s->cols * bytesperpixel);
-                    memcpy(s->intra_pred_data[1],
-                           f->data[1] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
-                           8 * s->cols * bytesperpixel >> s->ss_h);
-                    memcpy(s->intra_pred_data[2],
-                           f->data[2] + uvoff + ((64 >> s->ss_v) - 1) * ls_uv,
-                           8 * s->cols * bytesperpixel >> s->ss_h);
-                }
-
-                // loopfilter one row
-                if (s->s.h.filter.level) {
-                    yoff2 = yoff;
-                    uvoff2 = uvoff;
-                    lflvl_ptr = s->lflvl;
-                    for (col = 0; col < s->cols;
-                         col += 8, yoff2 += 64 * bytesperpixel,
-                         uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
-                        loopfilter_sb(ctx, lflvl_ptr, row, col, yoff2, uvoff2);
-                    }
-                }
-
-                // FIXME maybe we can make this more finegrained by running the
-                // loopfilter per-block instead of after each sbrow
-                // In fact that would also make intra pred left preparation easier?
-                ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, row >> 3, 0);
-            }
+            ff_slice_thread_execute_with_mainfunc(avctx, decode_tiles_mt, loopfilter_proc, s->td, NULL, s->s.h.tiling.tile_cols);
+        } else
+#endif
+        {
+            ret = decode_tiles(avctx, data, size);
+            if (ret < 0)
+                return ret;
         }
 
+        // Sum all counts fields into td[0].counts for tile threading
+        if (avctx->active_thread_type == FF_THREAD_SLICE)
+            for (i = 1; i < s->s.h.tiling.tile_cols; i++)
+                for (j = 0; j < sizeof(s->td[i].counts) / sizeof(unsigned); j++)
+                    ((unsigned *)&s->td[0].counts)[j] += ((unsigned *)&s->td[i].counts)[j];
+
         if (s->pass < 2 && s->s.h.refreshctx && !s->s.h.parallelmode) {
-            adapt_probs(s);
-            ff_thread_finish_setup(ctx);
+            ff_vp9_adapt_probs(s);
+            ff_thread_finish_setup(avctx);
         }
     } while (s->pass++ == 1);
     ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
@@ -4238,42 +1655,42 @@ FF_ENABLE_DEPRECATION_WARNINGS
     // ref frame setup
     for (i = 0; i < 8; i++) {
         if (s->s.refs[i].f->buf[0])
-            ff_thread_release_buffer(ctx, &s->s.refs[i]);
+            ff_thread_release_buffer(avctx, &s->s.refs[i]);
         if (s->next_refs[i].f->buf[0] &&
-            (res = ff_thread_ref_frame(&s->s.refs[i], &s->next_refs[i])) < 0)
-            return res;
+            (ret = ff_thread_ref_frame(&s->s.refs[i], &s->next_refs[i])) < 0)
+            return ret;
     }
 
     if (!s->s.h.invisible) {
-        if ((res = av_frame_ref(frame, s->s.frames[CUR_FRAME].tf.f)) < 0)
-            return res;
+        if ((ret = av_frame_ref(frame, s->s.frames[CUR_FRAME].tf.f)) < 0)
+            return ret;
         *got_frame = 1;
     }
 
     return pkt->size;
 }
 
-static void vp9_decode_flush(AVCodecContext *ctx)
+static void vp9_decode_flush(AVCodecContext *avctx)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     int i;
 
     for (i = 0; i < 3; i++)
-        vp9_unref_frame(ctx, &s->s.frames[i]);
+        vp9_frame_unref(avctx, &s->s.frames[i]);
     for (i = 0; i < 8; i++)
-        ff_thread_release_buffer(ctx, &s->s.refs[i]);
+        ff_thread_release_buffer(avctx, &s->s.refs[i]);
 }
 
-static int init_frames(AVCodecContext *ctx)
+static int init_frames(AVCodecContext *avctx)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
     int i;
 
     for (i = 0; i < 3; i++) {
         s->s.frames[i].tf.f = av_frame_alloc();
         if (!s->s.frames[i].tf.f) {
-            vp9_decode_free(ctx);
-            av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
+            vp9_decode_free(avctx);
+            av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
             return AVERROR(ENOMEM);
         }
     }
@@ -4281,8 +1698,8 @@ static int init_frames(AVCodecContext *ctx)
         s->s.refs[i].f = av_frame_alloc();
         s->next_refs[i].f = av_frame_alloc();
         if (!s->s.refs[i].f || !s->next_refs[i].f) {
-            vp9_decode_free(ctx);
-            av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
+            vp9_decode_free(avctx);
+            av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
             return AVERROR(ENOMEM);
         }
     }
@@ -4290,15 +1707,15 @@ static int init_frames(AVCodecContext *ctx)
     return 0;
 }
 
-static av_cold int vp9_decode_init(AVCodecContext *ctx)
+static av_cold int vp9_decode_init(AVCodecContext *avctx)
 {
-    VP9Context *s = ctx->priv_data;
+    VP9Context *s = avctx->priv_data;
 
-    ctx->internal->allocate_progress = 1;
+    avctx->internal->allocate_progress = 1;
     s->last_bpp = 0;
     s->s.h.filter.sharpness = -1;
 
-    return init_frames(ctx);
+    return init_frames(avctx);
 }
 
 #if HAVE_THREADS
@@ -4309,23 +1726,23 @@ static av_cold int vp9_decode_init_thread_copy(AVCodecContext *avctx)
 
 static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
 {
-    int i, res;
+    int i, ret;
     VP9Context *s = dst->priv_data, *ssrc = src->priv_data;
 
     for (i = 0; i < 3; i++) {
         if (s->s.frames[i].tf.f->buf[0])
-            vp9_unref_frame(dst, &s->s.frames[i]);
+            vp9_frame_unref(dst, &s->s.frames[i]);
         if (ssrc->s.frames[i].tf.f->buf[0]) {
-            if ((res = vp9_ref_frame(dst, &s->s.frames[i], &ssrc->s.frames[i])) < 0)
-                return res;
+            if ((ret = vp9_frame_ref(dst, &s->s.frames[i], &ssrc->s.frames[i])) < 0)
+                return ret;
         }
     }
     for (i = 0; i < 8; i++) {
         if (s->s.refs[i].f->buf[0])
             ff_thread_release_buffer(dst, &s->s.refs[i]);
         if (ssrc->next_refs[i].f->buf[0]) {
-            if ((res = ff_thread_ref_frame(&s->s.refs[i], &ssrc->next_refs[i])) < 0)
-                return res;
+            if ((ret = ff_thread_ref_frame(&s->s.refs[i], &ssrc->next_refs[i])) < 0)
+                return ret;
         }
     }
 
@@ -4341,7 +1758,7 @@ static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecCo
     s->gf_fmt = ssrc->gf_fmt;
     s->w = ssrc->w;
     s->h = ssrc->h;
-    s->bpp = ssrc->bpp;
+    s->s.h.bpp = ssrc->s.h.bpp;
     s->bpp_index = ssrc->bpp_index;
     s->pix_fmt = ssrc->pix_fmt;
     memcpy(&s->prob_ctx, &ssrc->prob_ctx, sizeof(s->prob_ctx));
@@ -4362,7 +1779,8 @@ AVCodec ff_vp9_decoder = {
     .init                  = vp9_decode_init,
     .close                 = vp9_decode_free,
     .decode                = vp9_decode_frame,
-    .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
+    .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
+    .caps_internal         = FF_CODEC_CAP_SLICE_THREAD_HAS_MF,
     .flush                 = vp9_decode_flush,
     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp9_decode_init_thread_copy),
     .update_thread_context = ONLY_IF_THREADS_ENABLED(vp9_decode_update_thread_context),
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9.h b/mythtv/external/FFmpeg/libavcodec/vp9.h
index df5bd4d85c5..c8d07ad9860 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp9.h
+++ b/mythtv/external/FFmpeg/libavcodec/vp9.h
@@ -24,42 +24,6 @@
 #ifndef AVCODEC_VP9_H
 #define AVCODEC_VP9_H
 
-#include <stdint.h>
-
-#include "thread.h"
-#include "vp56.h"
-
-enum BlockLevel {
-    BL_64X64,
-    BL_32X32,
-    BL_16X16,
-    BL_8X8,
-};
-
-enum BlockPartition {
-    PARTITION_NONE,    // [ ] <-.
-    PARTITION_H,       // [-]   |
-    PARTITION_V,       // [|]   |
-    PARTITION_SPLIT,   // [+] --'
-};
-
-enum BlockSize {
-    BS_64x64,
-    BS_64x32,
-    BS_32x64,
-    BS_32x32,
-    BS_32x16,
-    BS_16x32,
-    BS_16x16,
-    BS_16x8,
-    BS_8x16,
-    BS_8x8,
-    BS_8x4,
-    BS_4x8,
-    BS_4x4,
-    N_BS_SIZES,
-};
-
 enum TxfmMode {
     TX_4X4,
     TX_8X8,
@@ -97,115 +61,13 @@ enum IntraPredMode {
     N_INTRA_PRED_MODES
 };
 
-enum InterPredMode {
-    NEARESTMV = 10,
-    NEARMV = 11,
-    ZEROMV = 12,
-    NEWMV = 13,
-};
-
 enum FilterMode {
     FILTER_8TAP_SMOOTH,
     FILTER_8TAP_REGULAR,
     FILTER_8TAP_SHARP,
     FILTER_BILINEAR,
-    FILTER_SWITCHABLE,
+    N_FILTERS,
+    FILTER_SWITCHABLE = N_FILTERS,
 };
 
-enum CompPredMode {
-    PRED_SINGLEREF,
-    PRED_COMPREF,
-    PRED_SWITCHABLE,
-};
-
-struct VP9mvrefPair {
-    VP56mv mv[2];
-    int8_t ref[2];
-};
-
-typedef struct VP9Frame {
-    ThreadFrame tf;
-    AVBufferRef *extradata;
-    uint8_t *segmentation_map;
-    struct VP9mvrefPair *mv;
-    int uses_2pass;
-
-    AVBufferRef *hwaccel_priv_buf;
-    void *hwaccel_picture_private;
-} VP9Frame;
-
-typedef struct VP9BitstreamHeader {
-    // bitstream header
-    uint8_t profile;
-    uint8_t keyframe;
-    uint8_t invisible;
-    uint8_t errorres;
-    uint8_t intraonly;
-    uint8_t resetctx;
-    uint8_t refreshrefmask;
-    uint8_t highprecisionmvs;
-    enum FilterMode filtermode;
-    uint8_t allowcompinter;
-    uint8_t refreshctx;
-    uint8_t parallelmode;
-    uint8_t framectxid;
-    uint8_t use_last_frame_mvs;
-    uint8_t refidx[3];
-    uint8_t signbias[3];
-    uint8_t fixcompref;
-    uint8_t varcompref[2];
-    struct {
-        uint8_t level;
-        int8_t sharpness;
-    } filter;
-    struct {
-        uint8_t enabled;
-        uint8_t updated;
-        int8_t mode[2];
-        int8_t ref[4];
-    } lf_delta;
-    uint8_t yac_qi;
-    int8_t ydc_qdelta, uvdc_qdelta, uvac_qdelta;
-    uint8_t lossless;
-#define MAX_SEGMENT 8
-    struct {
-        uint8_t enabled;
-        uint8_t temporal;
-        uint8_t absolute_vals;
-        uint8_t update_map;
-        uint8_t prob[7];
-        uint8_t pred_prob[3];
-        struct {
-            uint8_t q_enabled;
-            uint8_t lf_enabled;
-            uint8_t ref_enabled;
-            uint8_t skip_enabled;
-            uint8_t ref_val;
-            int16_t q_val;
-            int8_t lf_val;
-            int16_t qmul[2][2];
-            uint8_t lflvl[4][2];
-        } feat[MAX_SEGMENT];
-    } segmentation;
-    enum TxfmMode txfmmode;
-    enum CompPredMode comppredmode;
-    struct {
-        unsigned log2_tile_cols, log2_tile_rows;
-        unsigned tile_cols, tile_rows;
-    } tiling;
-
-    int uncompressed_header_size;
-    int compressed_header_size;
-} VP9BitstreamHeader;
-
-typedef struct VP9SharedContext {
-    VP9BitstreamHeader h;
-
-    ThreadFrame refs[8];
-#define CUR_FRAME 0
-#define REF_FRAME_MVPAIR 1
-#define REF_FRAME_SEGMAP 2
-    VP9Frame frames[3];
-} VP9SharedContext;
-
 #endif /* AVCODEC_VP9_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9_mc_template.c b/mythtv/external/FFmpeg/libavcodec/vp9_mc_template.c
index 38d9a6da9fa..31e692f3625 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp9_mc_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp9_mc_template.c
@@ -27,19 +27,19 @@
     (VP56mv) { .x = ROUNDED_DIV(a.x + b.x + c.x + d.x, 4), \
                .y = ROUNDED_DIV(a.y + b.y + c.y + d.y, 4) }
 
-static void FN(inter_pred)(AVCodecContext *ctx)
+static void FN(inter_pred)(VP9TileData *td)
 {
     static const uint8_t bwlog_tab[2][N_BS_SIZES] = {
         { 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
         { 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4 },
     };
-    VP9Context *s = ctx->priv_data;
-    VP9Block *b = s->b;
-    int row = s->row, col = s->col;
+    VP9Context *s = td->s;
+    VP9Block *b = td->b;
+    int row = td->row, col = td->col;
     ThreadFrame *tref1 = &s->s.refs[s->s.h.refidx[b->ref[0]]], *tref2;
     AVFrame *ref1 = tref1->f, *ref2;
     int w1 = ref1->width, h1 = ref1->height, w2, h2;
-    ptrdiff_t ls_y = s->y_stride, ls_uv = s->uv_stride;
+    ptrdiff_t ls_y = td->y_stride, ls_uv = td->uv_stride;
     int bytesperpixel = BYTES_PER_PIXEL;
 
     if (b->comp) {
@@ -55,26 +55,26 @@ static void FN(inter_pred)(AVCodecContext *ctx)
 
 #if SCALED == 0
         if (b->bs == BS_8x4) {
-            mc_luma_dir(s, mc[3][b->filter][0], s->dst[0], ls_y,
+            mc_luma_dir(td, mc[3][b->filter][0], td->dst[0], ls_y,
                         ref1->data[0], ref1->linesize[0], tref1,
                         row << 3, col << 3, &b->mv[0][0],,,,, 8, 4, w1, h1, 0);
-            mc_luma_dir(s, mc[3][b->filter][0],
-                        s->dst[0] + 4 * ls_y, ls_y,
+            mc_luma_dir(td, mc[3][b->filter][0],
+                        td->dst[0] + 4 * ls_y, ls_y,
                         ref1->data[0], ref1->linesize[0], tref1,
                         (row << 3) + 4, col << 3, &b->mv[2][0],,,,, 8, 4, w1, h1, 0);
             w1 = (w1 + s->ss_h) >> s->ss_h;
             if (s->ss_v) {
                 h1 = (h1 + 1) >> 1;
                 uvmv = ROUNDED_DIV_MVx2(b->mv[0][0], b->mv[2][0]);
-                mc_chroma_dir(s, mc[3 + s->ss_h][b->filter][0],
-                              s->dst[1], s->dst[2], ls_uv,
+                mc_chroma_dir(td, mc[3 + s->ss_h][b->filter][0],
+                              td->dst[1], td->dst[2], ls_uv,
                               ref1->data[1], ref1->linesize[1],
                               ref1->data[2], ref1->linesize[2], tref1,
                               row << 2, col << (3 - s->ss_h),
                               &uvmv,,,,, 8 >> s->ss_h, 4, w1, h1, 0);
             } else {
-                mc_chroma_dir(s, mc[3 + s->ss_h][b->filter][0],
-                              s->dst[1], s->dst[2], ls_uv,
+                mc_chroma_dir(td, mc[3 + s->ss_h][b->filter][0],
+                              td->dst[1], td->dst[2], ls_uv,
                               ref1->data[1], ref1->linesize[1],
                               ref1->data[2], ref1->linesize[2], tref1,
                               row << 3, col << (3 - s->ss_h),
@@ -87,8 +87,8 @@ static void FN(inter_pred)(AVCodecContext *ctx)
                 } else {
                     uvmv = ROUNDED_DIV_MVx2(b->mv[0][0], b->mv[2][0]);
                 }
-                mc_chroma_dir(s, mc[3 + s->ss_h][b->filter][0],
-                              s->dst[1] + 4 * ls_uv, s->dst[2] + 4 * ls_uv, ls_uv,
+                mc_chroma_dir(td, mc[3 + s->ss_h][b->filter][0],
+                              td->dst[1] + 4 * ls_uv, td->dst[2] + 4 * ls_uv, ls_uv,
                               ref1->data[1], ref1->linesize[1],
                               ref1->data[2], ref1->linesize[2], tref1,
                               (row << 3) + 4, col << (3 - s->ss_h),
@@ -96,26 +96,26 @@ static void FN(inter_pred)(AVCodecContext *ctx)
             }
 
             if (b->comp) {
-                mc_luma_dir(s, mc[3][b->filter][1], s->dst[0], ls_y,
+                mc_luma_dir(td, mc[3][b->filter][1], td->dst[0], ls_y,
                             ref2->data[0], ref2->linesize[0], tref2,
                             row << 3, col << 3, &b->mv[0][1],,,,, 8, 4, w2, h2, 1);
-                mc_luma_dir(s, mc[3][b->filter][1],
-                            s->dst[0] + 4 * ls_y, ls_y,
+                mc_luma_dir(td, mc[3][b->filter][1],
+                            td->dst[0] + 4 * ls_y, ls_y,
                             ref2->data[0], ref2->linesize[0], tref2,
                             (row << 3) + 4, col << 3, &b->mv[2][1],,,,, 8, 4, w2, h2, 1);
                 w2 = (w2 + s->ss_h) >> s->ss_h;
                 if (s->ss_v) {
                     h2 = (h2 + 1) >> 1;
                     uvmv = ROUNDED_DIV_MVx2(b->mv[0][1], b->mv[2][1]);
-                    mc_chroma_dir(s, mc[3 + s->ss_h][b->filter][1],
-                                  s->dst[1], s->dst[2], ls_uv,
+                    mc_chroma_dir(td, mc[3 + s->ss_h][b->filter][1],
+                                  td->dst[1], td->dst[2], ls_uv,
                                   ref2->data[1], ref2->linesize[1],
                                   ref2->data[2], ref2->linesize[2], tref2,
                                   row << 2, col << (3 - s->ss_h),
                                   &uvmv,,,,, 8 >> s->ss_h, 4, w2, h2, 1);
                 } else {
-                    mc_chroma_dir(s, mc[3 + s->ss_h][b->filter][1],
-                                  s->dst[1], s->dst[2], ls_uv,
+                    mc_chroma_dir(td, mc[3 + s->ss_h][b->filter][1],
+                                  td->dst[1], td->dst[2], ls_uv,
                                   ref2->data[1], ref2->linesize[1],
                                   ref2->data[2], ref2->linesize[2], tref2,
                                   row << 3, col << (3 - s->ss_h),
@@ -128,8 +128,8 @@ static void FN(inter_pred)(AVCodecContext *ctx)
                     } else {
                         uvmv = ROUNDED_DIV_MVx2(b->mv[0][1], b->mv[2][1]);
                     }
-                    mc_chroma_dir(s, mc[3 + s->ss_h][b->filter][1],
-                                  s->dst[1] + 4 * ls_uv, s->dst[2] + 4 * ls_uv, ls_uv,
+                    mc_chroma_dir(td, mc[3 + s->ss_h][b->filter][1],
+                                  td->dst[1] + 4 * ls_uv, td->dst[2] + 4 * ls_uv, ls_uv,
                                   ref2->data[1], ref2->linesize[1],
                                   ref2->data[2], ref2->linesize[2], tref2,
                                   (row << 3) + 4, col << (3 - s->ss_h),
@@ -137,32 +137,32 @@ static void FN(inter_pred)(AVCodecContext *ctx)
                 }
             }
         } else if (b->bs == BS_4x8) {
-            mc_luma_dir(s, mc[4][b->filter][0], s->dst[0], ls_y,
+            mc_luma_dir(td, mc[4][b->filter][0], td->dst[0], ls_y,
                         ref1->data[0], ref1->linesize[0], tref1,
                         row << 3, col << 3, &b->mv[0][0],,,,, 4, 8, w1, h1, 0);
-            mc_luma_dir(s, mc[4][b->filter][0], s->dst[0] + 4 * bytesperpixel, ls_y,
+            mc_luma_dir(td, mc[4][b->filter][0], td->dst[0] + 4 * bytesperpixel, ls_y,
                         ref1->data[0], ref1->linesize[0], tref1,
                         row << 3, (col << 3) + 4, &b->mv[1][0],,,,, 4, 8, w1, h1, 0);
             h1 = (h1 + s->ss_v) >> s->ss_v;
             if (s->ss_h) {
                 w1 = (w1 + 1) >> 1;
                 uvmv = ROUNDED_DIV_MVx2(b->mv[0][0], b->mv[1][0]);
-                mc_chroma_dir(s, mc[4][b->filter][0],
-                              s->dst[1], s->dst[2], ls_uv,
+                mc_chroma_dir(td, mc[4][b->filter][0],
+                              td->dst[1], td->dst[2], ls_uv,
                               ref1->data[1], ref1->linesize[1],
                               ref1->data[2], ref1->linesize[2], tref1,
                               row << (3 - s->ss_v), col << 2,
                               &uvmv,,,,, 4, 8 >> s->ss_v, w1, h1, 0);
             } else {
-                mc_chroma_dir(s, mc[4][b->filter][0],
-                              s->dst[1], s->dst[2], ls_uv,
+                mc_chroma_dir(td, mc[4][b->filter][0],
+                              td->dst[1], td->dst[2], ls_uv,
                               ref1->data[1], ref1->linesize[1],
                               ref1->data[2], ref1->linesize[2], tref1,
                               row << (3 - s->ss_v), col << 3,
                               &b->mv[0][0],,,,, 4, 8 >> s->ss_v, w1, h1, 0);
-                mc_chroma_dir(s, mc[4][b->filter][0],
-                              s->dst[1] + 4 * bytesperpixel,
-                              s->dst[2] + 4 * bytesperpixel, ls_uv,
+                mc_chroma_dir(td, mc[4][b->filter][0],
+                              td->dst[1] + 4 * bytesperpixel,
+                              td->dst[2] + 4 * bytesperpixel, ls_uv,
                               ref1->data[1], ref1->linesize[1],
                               ref1->data[2], ref1->linesize[2], tref1,
                               row << (3 - s->ss_v), (col << 3) + 4,
@@ -170,32 +170,32 @@ static void FN(inter_pred)(AVCodecContext *ctx)
             }
 
             if (b->comp) {
-                mc_luma_dir(s, mc[4][b->filter][1], s->dst[0], ls_y,
+                mc_luma_dir(td, mc[4][b->filter][1], td->dst[0], ls_y,
                             ref2->data[0], ref2->linesize[0], tref2,
                             row << 3, col << 3, &b->mv[0][1],,,,, 4, 8, w2, h2, 1);
-                mc_luma_dir(s, mc[4][b->filter][1], s->dst[0] + 4 * bytesperpixel, ls_y,
+                mc_luma_dir(td, mc[4][b->filter][1], td->dst[0] + 4 * bytesperpixel, ls_y,
                             ref2->data[0], ref2->linesize[0], tref2,
                             row << 3, (col << 3) + 4, &b->mv[1][1],,,,, 4, 8, w2, h2, 1);
                 h2 = (h2 + s->ss_v) >> s->ss_v;
                 if (s->ss_h) {
                     w2 = (w2 + 1) >> 1;
                     uvmv = ROUNDED_DIV_MVx2(b->mv[0][1], b->mv[1][1]);
-                    mc_chroma_dir(s, mc[4][b->filter][1],
-                                  s->dst[1], s->dst[2], ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][1],
+                                  td->dst[1], td->dst[2], ls_uv,
                                   ref2->data[1], ref2->linesize[1],
                                   ref2->data[2], ref2->linesize[2], tref2,
                                   row << (3 - s->ss_v), col << 2,
                                   &uvmv,,,,, 4, 8 >> s->ss_v, w2, h2, 1);
                 } else {
-                    mc_chroma_dir(s, mc[4][b->filter][1],
-                                  s->dst[1], s->dst[2], ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][1],
+                                  td->dst[1], td->dst[2], ls_uv,
                                   ref2->data[1], ref2->linesize[1],
                                   ref2->data[2], ref2->linesize[2], tref2,
                                   row << (3 - s->ss_v), col << 3,
                                   &b->mv[0][1],,,,, 4, 8 >> s->ss_v, w2, h2, 1);
-                    mc_chroma_dir(s, mc[4][b->filter][1],
-                                  s->dst[1] + 4 * bytesperpixel,
-                                  s->dst[2] + 4 * bytesperpixel, ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][1],
+                                  td->dst[1] + 4 * bytesperpixel,
+                                  td->dst[2] + 4 * bytesperpixel, ls_uv,
                                   ref2->data[1], ref2->linesize[1],
                                   ref2->data[2], ref2->linesize[2], tref2,
                                   row << (3 - s->ss_v), (col << 3) + 4,
@@ -205,25 +205,27 @@ static void FN(inter_pred)(AVCodecContext *ctx)
         } else
 #endif
         {
+#if SCALED == 0
             av_assert2(b->bs == BS_4x4);
+#endif
 
             // FIXME if two horizontally adjacent blocks have the same MV,
             // do a w8 instead of a w4 call
-            mc_luma_dir(s, mc[4][b->filter][0], s->dst[0], ls_y,
+            mc_luma_dir(td, mc[4][b->filter][0], td->dst[0], ls_y,
                         ref1->data[0], ref1->linesize[0], tref1,
                         row << 3, col << 3, &b->mv[0][0],
                         0, 0, 8, 8, 4, 4, w1, h1, 0);
-            mc_luma_dir(s, mc[4][b->filter][0], s->dst[0] + 4 * bytesperpixel, ls_y,
+            mc_luma_dir(td, mc[4][b->filter][0], td->dst[0] + 4 * bytesperpixel, ls_y,
                         ref1->data[0], ref1->linesize[0], tref1,
                         row << 3, (col << 3) + 4, &b->mv[1][0],
                         4, 0, 8, 8, 4, 4, w1, h1, 0);
-            mc_luma_dir(s, mc[4][b->filter][0],
-                        s->dst[0] + 4 * ls_y, ls_y,
+            mc_luma_dir(td, mc[4][b->filter][0],
+                        td->dst[0] + 4 * ls_y, ls_y,
                         ref1->data[0], ref1->linesize[0], tref1,
                         (row << 3) + 4, col << 3, &b->mv[2][0],
                         0, 4, 8, 8, 4, 4, w1, h1, 0);
-            mc_luma_dir(s, mc[4][b->filter][0],
-                        s->dst[0] + 4 * ls_y + 4 * bytesperpixel, ls_y,
+            mc_luma_dir(td, mc[4][b->filter][0],
+                        td->dst[0] + 4 * ls_y + 4 * bytesperpixel, ls_y,
                         ref1->data[0], ref1->linesize[0], tref1,
                         (row << 3) + 4, (col << 3) + 4, &b->mv[3][0],
                         4, 4, 8, 8, 4, 4, w1, h1, 0);
@@ -233,24 +235,24 @@ static void FN(inter_pred)(AVCodecContext *ctx)
                     w1 = (w1 + 1) >> 1;
                     uvmv = ROUNDED_DIV_MVx4(b->mv[0][0], b->mv[1][0],
                                             b->mv[2][0], b->mv[3][0]);
-                    mc_chroma_dir(s, mc[4][b->filter][0],
-                                  s->dst[1], s->dst[2], ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][0],
+                                  td->dst[1], td->dst[2], ls_uv,
                                   ref1->data[1], ref1->linesize[1],
                                   ref1->data[2], ref1->linesize[2], tref1,
                                   row << 2, col << 2,
                                   &uvmv, 0, 0, 4, 4, 4, 4, w1, h1, 0);
                 } else {
                     uvmv = ROUNDED_DIV_MVx2(b->mv[0][0], b->mv[2][0]);
-                    mc_chroma_dir(s, mc[4][b->filter][0],
-                                  s->dst[1], s->dst[2], ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][0],
+                                  td->dst[1], td->dst[2], ls_uv,
                                   ref1->data[1], ref1->linesize[1],
                                   ref1->data[2], ref1->linesize[2], tref1,
                                   row << 2, col << 3,
                                   &uvmv, 0, 0, 8, 4, 4, 4, w1, h1, 0);
                     uvmv = ROUNDED_DIV_MVx2(b->mv[1][0], b->mv[3][0]);
-                    mc_chroma_dir(s, mc[4][b->filter][0],
-                                  s->dst[1] + 4 * bytesperpixel,
-                                  s->dst[2] + 4 * bytesperpixel, ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][0],
+                                  td->dst[1] + 4 * bytesperpixel,
+                                  td->dst[2] + 4 * bytesperpixel, ls_uv,
                                   ref1->data[1], ref1->linesize[1],
                                   ref1->data[2], ref1->linesize[2], tref1,
                                   row << 2, (col << 3) + 4,
@@ -260,8 +262,8 @@ static void FN(inter_pred)(AVCodecContext *ctx)
                 if (s->ss_h) {
                     w1 = (w1 + 1) >> 1;
                     uvmv = ROUNDED_DIV_MVx2(b->mv[0][0], b->mv[1][0]);
-                    mc_chroma_dir(s, mc[4][b->filter][0],
-                                  s->dst[1], s->dst[2], ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][0],
+                                  td->dst[1], td->dst[2], ls_uv,
                                   ref1->data[1], ref1->linesize[1],
                                   ref1->data[2], ref1->linesize[2], tref1,
                                   row << 3, col << 2,
@@ -270,35 +272,35 @@ static void FN(inter_pred)(AVCodecContext *ctx)
                     // bottom block
                     // https://code.google.com/p/webm/issues/detail?id=993
                     uvmv = ROUNDED_DIV_MVx2(b->mv[1][0], b->mv[2][0]);
-                    mc_chroma_dir(s, mc[4][b->filter][0],
-                                  s->dst[1] + 4 * ls_uv, s->dst[2] + 4 * ls_uv, ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][0],
+                                  td->dst[1] + 4 * ls_uv, td->dst[2] + 4 * ls_uv, ls_uv,
                                   ref1->data[1], ref1->linesize[1],
                                   ref1->data[2], ref1->linesize[2], tref1,
                                   (row << 3) + 4, col << 2,
                                   &uvmv, 0, 4, 4, 8, 4, 4, w1, h1, 0);
                 } else {
-                    mc_chroma_dir(s, mc[4][b->filter][0],
-                                  s->dst[1], s->dst[2], ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][0],
+                                  td->dst[1], td->dst[2], ls_uv,
                                   ref1->data[1], ref1->linesize[1],
                                   ref1->data[2], ref1->linesize[2], tref1,
                                   row << 3, col << 3,
                                   &b->mv[0][0], 0, 0, 8, 8, 4, 4, w1, h1, 0);
-                    mc_chroma_dir(s, mc[4][b->filter][0],
-                                  s->dst[1] + 4 * bytesperpixel,
-                                  s->dst[2] + 4 * bytesperpixel, ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][0],
+                                  td->dst[1] + 4 * bytesperpixel,
+                                  td->dst[2] + 4 * bytesperpixel, ls_uv,
                                   ref1->data[1], ref1->linesize[1],
                                   ref1->data[2], ref1->linesize[2], tref1,
                                   row << 3, (col << 3) + 4,
                                   &b->mv[1][0], 4, 0, 8, 8, 4, 4, w1, h1, 0);
-                    mc_chroma_dir(s, mc[4][b->filter][0],
-                                  s->dst[1] + 4 * ls_uv, s->dst[2] + 4 * ls_uv, ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][0],
+                                  td->dst[1] + 4 * ls_uv, td->dst[2] + 4 * ls_uv, ls_uv,
                                   ref1->data[1], ref1->linesize[1],
                                   ref1->data[2], ref1->linesize[2], tref1,
                                   (row << 3) + 4, col << 3,
                                   &b->mv[2][0], 0, 4, 8, 8, 4, 4, w1, h1, 0);
-                    mc_chroma_dir(s, mc[4][b->filter][0],
-                                  s->dst[1] + 4 * ls_uv + 4 * bytesperpixel,
-                                  s->dst[2] + 4 * ls_uv + 4 * bytesperpixel, ls_uv,
+                    mc_chroma_dir(td, mc[4][b->filter][0],
+                                  td->dst[1] + 4 * ls_uv + 4 * bytesperpixel,
+                                  td->dst[2] + 4 * ls_uv + 4 * bytesperpixel, ls_uv,
                                   ref1->data[1], ref1->linesize[1],
                                   ref1->data[2], ref1->linesize[2], tref1,
                                   (row << 3) + 4, (col << 3) + 4,
@@ -307,18 +309,18 @@ static void FN(inter_pred)(AVCodecContext *ctx)
             }
 
             if (b->comp) {
-                mc_luma_dir(s, mc[4][b->filter][1], s->dst[0], ls_y,
+                mc_luma_dir(td, mc[4][b->filter][1], td->dst[0], ls_y,
                             ref2->data[0], ref2->linesize[0], tref2,
                             row << 3, col << 3, &b->mv[0][1], 0, 0, 8, 8, 4, 4, w2, h2, 1);
-                mc_luma_dir(s, mc[4][b->filter][1], s->dst[0] + 4 * bytesperpixel, ls_y,
+                mc_luma_dir(td, mc[4][b->filter][1], td->dst[0] + 4 * bytesperpixel, ls_y,
                             ref2->data[0], ref2->linesize[0], tref2,
                             row << 3, (col << 3) + 4, &b->mv[1][1], 4, 0, 8, 8, 4, 4, w2, h2, 1);
-                mc_luma_dir(s, mc[4][b->filter][1],
-                            s->dst[0] + 4 * ls_y, ls_y,
+                mc_luma_dir(td, mc[4][b->filter][1],
+                            td->dst[0] + 4 * ls_y, ls_y,
                             ref2->data[0], ref2->linesize[0], tref2,
                             (row << 3) + 4, col << 3, &b->mv[2][1], 0, 4, 8, 8, 4, 4, w2, h2, 1);
-                mc_luma_dir(s, mc[4][b->filter][1],
-                            s->dst[0] + 4 * ls_y + 4 * bytesperpixel, ls_y,
+                mc_luma_dir(td, mc[4][b->filter][1],
+                            td->dst[0] + 4 * ls_y + 4 * bytesperpixel, ls_y,
                             ref2->data[0], ref2->linesize[0], tref2,
                             (row << 3) + 4, (col << 3) + 4, &b->mv[3][1], 4, 4, 8, 8, 4, 4, w2, h2, 1);
                 if (s->ss_v) {
@@ -327,24 +329,24 @@ static void FN(inter_pred)(AVCodecContext *ctx)
                         w2 = (w2 + 1) >> 1;
                         uvmv = ROUNDED_DIV_MVx4(b->mv[0][1], b->mv[1][1],
                                                 b->mv[2][1], b->mv[3][1]);
-                        mc_chroma_dir(s, mc[4][b->filter][1],
-                                      s->dst[1], s->dst[2], ls_uv,
+                        mc_chroma_dir(td, mc[4][b->filter][1],
+                                      td->dst[1], td->dst[2], ls_uv,
                                       ref2->data[1], ref2->linesize[1],
                                       ref2->data[2], ref2->linesize[2], tref2,
                                       row << 2, col << 2,
                                       &uvmv, 0, 0, 4, 4, 4, 4, w2, h2, 1);
                     } else {
                         uvmv = ROUNDED_DIV_MVx2(b->mv[0][1], b->mv[2][1]);
-                        mc_chroma_dir(s, mc[4][b->filter][1],
-                                      s->dst[1], s->dst[2], ls_uv,
+                        mc_chroma_dir(td, mc[4][b->filter][1],
+                                      td->dst[1], td->dst[2], ls_uv,
                                       ref2->data[1], ref2->linesize[1],
                                       ref2->data[2], ref2->linesize[2], tref2,
                                       row << 2, col << 3,
                                       &uvmv, 0, 0, 8, 4, 4, 4, w2, h2, 1);
                         uvmv = ROUNDED_DIV_MVx2(b->mv[1][1], b->mv[3][1]);
-                        mc_chroma_dir(s, mc[4][b->filter][1],
-                                      s->dst[1] + 4 * bytesperpixel,
-                                      s->dst[2] + 4 * bytesperpixel, ls_uv,
+                        mc_chroma_dir(td, mc[4][b->filter][1],
+                                      td->dst[1] + 4 * bytesperpixel,
+                                      td->dst[2] + 4 * bytesperpixel, ls_uv,
                                       ref2->data[1], ref2->linesize[1],
                                       ref2->data[2], ref2->linesize[2], tref2,
                                       row << 2, (col << 3) + 4,
@@ -354,8 +356,8 @@ static void FN(inter_pred)(AVCodecContext *ctx)
                     if (s->ss_h) {
                         w2 = (w2 + 1) >> 1;
                         uvmv = ROUNDED_DIV_MVx2(b->mv[0][1], b->mv[1][1]);
-                        mc_chroma_dir(s, mc[4][b->filter][1],
-                                      s->dst[1], s->dst[2], ls_uv,
+                        mc_chroma_dir(td, mc[4][b->filter][1],
+                                      td->dst[1], td->dst[2], ls_uv,
                                       ref2->data[1], ref2->linesize[1],
                                       ref2->data[2], ref2->linesize[2], tref2,
                                       row << 3, col << 2,
@@ -364,35 +366,35 @@ static void FN(inter_pred)(AVCodecContext *ctx)
                         // bottom block
                         // https://code.google.com/p/webm/issues/detail?id=993
                         uvmv = ROUNDED_DIV_MVx2(b->mv[1][1], b->mv[2][1]);
-                        mc_chroma_dir(s, mc[4][b->filter][1],
-                                      s->dst[1] + 4 * ls_uv, s->dst[2] + 4 * ls_uv, ls_uv,
+                        mc_chroma_dir(td, mc[4][b->filter][1],
+                                      td->dst[1] + 4 * ls_uv, td->dst[2] + 4 * ls_uv, ls_uv,
                                       ref2->data[1], ref2->linesize[1],
                                       ref2->data[2], ref2->linesize[2], tref2,
                                       (row << 3) + 4, col << 2,
                                       &uvmv, 0, 4, 4, 8, 4, 4, w2, h2, 1);
                     } else {
-                        mc_chroma_dir(s, mc[4][b->filter][1],
-                                      s->dst[1], s->dst[2], ls_uv,
+                        mc_chroma_dir(td, mc[4][b->filter][1],
+                                      td->dst[1], td->dst[2], ls_uv,
                                       ref2->data[1], ref2->linesize[1],
                                       ref2->data[2], ref2->linesize[2], tref2,
                                       row << 3, col << 3,
                                       &b->mv[0][1], 0, 0, 8, 8, 4, 4, w2, h2, 1);
-                        mc_chroma_dir(s, mc[4][b->filter][1],
-                                      s->dst[1] + 4 * bytesperpixel,
-                                      s->dst[2] + 4 * bytesperpixel, ls_uv,
+                        mc_chroma_dir(td, mc[4][b->filter][1],
+                                      td->dst[1] + 4 * bytesperpixel,
+                                      td->dst[2] + 4 * bytesperpixel, ls_uv,
                                       ref2->data[1], ref2->linesize[1],
                                       ref2->data[2], ref2->linesize[2], tref2,
                                       row << 3, (col << 3) + 4,
                                       &b->mv[1][1], 4, 0, 8, 8, 4, 4, w2, h2, 1);
-                        mc_chroma_dir(s, mc[4][b->filter][1],
-                                      s->dst[1] + 4 * ls_uv, s->dst[2] + 4 * ls_uv, ls_uv,
+                        mc_chroma_dir(td, mc[4][b->filter][1],
+                                      td->dst[1] + 4 * ls_uv, td->dst[2] + 4 * ls_uv, ls_uv,
                                       ref2->data[1], ref2->linesize[1],
                                       ref2->data[2], ref2->linesize[2], tref2,
                                       (row << 3) + 4, col << 3,
                                       &b->mv[2][1], 0, 4, 8, 8, 4, 4, w2, h2, 1);
-                        mc_chroma_dir(s, mc[4][b->filter][1],
-                                      s->dst[1] + 4 * ls_uv + 4 * bytesperpixel,
-                                      s->dst[2] + 4 * ls_uv + 4 * bytesperpixel, ls_uv,
+                        mc_chroma_dir(td, mc[4][b->filter][1],
+                                      td->dst[1] + 4 * ls_uv + 4 * bytesperpixel,
+                                      td->dst[2] + 4 * ls_uv + 4 * bytesperpixel, ls_uv,
                                       ref2->data[1], ref2->linesize[1],
                                       ref2->data[2], ref2->linesize[2], tref2,
                                       (row << 3) + 4, (col << 3) + 4,
@@ -403,29 +405,31 @@ static void FN(inter_pred)(AVCodecContext *ctx)
         }
     } else {
         int bwl = bwlog_tab[0][b->bs];
-        int bw = bwh_tab[0][b->bs][0] * 4, bh = bwh_tab[0][b->bs][1] * 4;
-        int uvbw = bwh_tab[s->ss_h][b->bs][0] * 4, uvbh = bwh_tab[s->ss_v][b->bs][1] * 4;
+        int bw = ff_vp9_bwh_tab[0][b->bs][0] * 4;
+        int bh = ff_vp9_bwh_tab[0][b->bs][1] * 4;
+        int uvbw = ff_vp9_bwh_tab[s->ss_h][b->bs][0] * 4;
+        int uvbh = ff_vp9_bwh_tab[s->ss_v][b->bs][1] * 4;
 
-        mc_luma_dir(s, mc[bwl][b->filter][0], s->dst[0], ls_y,
+        mc_luma_dir(td, mc[bwl][b->filter][0], td->dst[0], ls_y,
                     ref1->data[0], ref1->linesize[0], tref1,
                     row << 3, col << 3, &b->mv[0][0], 0, 0, bw, bh, bw, bh, w1, h1, 0);
         w1 = (w1 + s->ss_h) >> s->ss_h;
         h1 = (h1 + s->ss_v) >> s->ss_v;
-        mc_chroma_dir(s, mc[bwl + s->ss_h][b->filter][0],
-                      s->dst[1], s->dst[2], ls_uv,
+        mc_chroma_dir(td, mc[bwl + s->ss_h][b->filter][0],
+                      td->dst[1], td->dst[2], ls_uv,
                       ref1->data[1], ref1->linesize[1],
                       ref1->data[2], ref1->linesize[2], tref1,
                       row << (3 - s->ss_v), col << (3 - s->ss_h),
                       &b->mv[0][0], 0, 0, uvbw, uvbh, uvbw, uvbh, w1, h1, 0);
 
         if (b->comp) {
-            mc_luma_dir(s, mc[bwl][b->filter][1], s->dst[0], ls_y,
+            mc_luma_dir(td, mc[bwl][b->filter][1], td->dst[0], ls_y,
                         ref2->data[0], ref2->linesize[0], tref2,
                         row << 3, col << 3, &b->mv[0][1], 0, 0, bw, bh, bw, bh, w2, h2, 1);
             w2 = (w2 + s->ss_h) >> s->ss_h;
             h2 = (h2 + s->ss_v) >> s->ss_v;
-            mc_chroma_dir(s, mc[bwl + s->ss_h][b->filter][1],
-                          s->dst[1], s->dst[2], ls_uv,
+            mc_chroma_dir(td, mc[bwl + s->ss_h][b->filter][1],
+                          td->dst[1], td->dst[2], ls_uv,
                           ref2->data[1], ref2->linesize[1],
                           ref2->data[2], ref2->linesize[2], tref2,
                           row << (3 - s->ss_v), col << (3 - s->ss_h),
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9_raw_reorder_bsf.c b/mythtv/external/FFmpeg/libavcodec/vp9_raw_reorder_bsf.c
new file mode 100644
index 00000000000..01f3dad8982
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vp9_raw_reorder_bsf.c
@@ -0,0 +1,407 @@
+/*
+ * 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/avassert.h"
+#include "libavutil/intmath.h"
+#include "libavutil/log.h"
+#include "libavutil/mem.h"
+#include "libavutil/opt.h"
+
+#include "bsf.h"
+#include "get_bits.h"
+#include "put_bits.h"
+
+#define FRAME_SLOTS 8
+
+typedef struct VP9RawReorderFrame {
+    AVPacket    *packet;
+    int          needs_output;
+    int          needs_display;
+
+    int64_t      pts;
+    int64_t      sequence;
+    unsigned int slots;
+
+    unsigned int profile;
+
+    unsigned int show_existing_frame;
+    unsigned int frame_to_show;
+
+    unsigned int frame_type;
+    unsigned int show_frame;
+    unsigned int refresh_frame_flags;
+} VP9RawReorderFrame;
+
+typedef struct VP9RawReorderContext {
+    int64_t sequence;
+    VP9RawReorderFrame *slot[FRAME_SLOTS];
+    VP9RawReorderFrame *next_frame;
+} VP9RawReorderContext;
+
+static void vp9_raw_reorder_frame_free(VP9RawReorderFrame **frame)
+{
+    if (*frame)
+        av_packet_free(&(*frame)->packet);
+    av_freep(frame);
+}
+
+static void vp9_raw_reorder_clear_slot(VP9RawReorderContext *ctx, int s)
+{
+    if (ctx->slot[s]) {
+        ctx->slot[s]->slots &= ~(1 << s);
+        if (ctx->slot[s]->slots == 0)
+            vp9_raw_reorder_frame_free(&ctx->slot[s]);
+        else
+            ctx->slot[s] = NULL;
+    }
+}
+
+static int vp9_raw_reorder_frame_parse(AVBSFContext *bsf, VP9RawReorderFrame *frame)
+{
+    GetBitContext bc;
+    int err;
+
+    unsigned int frame_marker;
+    unsigned int profile_low_bit, profile_high_bit, reserved_zero;
+    unsigned int error_resilient_mode;
+    unsigned int frame_sync_code;
+
+    err = init_get_bits(&bc, frame->packet->data, 8 * frame->packet->size);
+    if (err)
+        return err;
+
+    frame_marker = get_bits(&bc, 2);
+    if (frame_marker != 2) {
+        av_log(bsf, AV_LOG_ERROR, "Invalid frame marker: %u.\n",
+               frame_marker);
+        return AVERROR_INVALIDDATA;
+    }
+
+    profile_low_bit  = get_bits1(&bc);
+    profile_high_bit = get_bits1(&bc);
+    frame->profile = (profile_high_bit << 1) | profile_low_bit;
+    if (frame->profile == 3) {
+        reserved_zero = get_bits1(&bc);
+        if (reserved_zero != 0) {
+            av_log(bsf, AV_LOG_ERROR, "Profile reserved_zero bit set: "
+                   "unsupported profile or invalid bitstream.\n");
+            return AVERROR_INVALIDDATA;
+        }
+    }
+
+    frame->show_existing_frame = get_bits1(&bc);
+    if (frame->show_existing_frame) {
+        frame->frame_to_show = get_bits(&bc, 3);
+        return 0;
+    }
+
+    frame->frame_type = get_bits1(&bc);
+    frame->show_frame = get_bits1(&bc);
+    error_resilient_mode = get_bits1(&bc);
+
+    if (frame->frame_type == 0) {
+        frame_sync_code = get_bits(&bc, 24);
+        if (frame_sync_code != 0x498342) {
+            av_log(bsf, AV_LOG_ERROR, "Invalid frame sync code: %06x.\n",
+                   frame_sync_code);
+            return AVERROR_INVALIDDATA;
+        }
+        frame->refresh_frame_flags = 0xff;
+    } else {
+        unsigned int intra_only;
+
+        if (frame->show_frame == 0)
+            intra_only = get_bits1(&bc);
+        else
+            intra_only = 0;
+        if (error_resilient_mode == 0) {
+            // reset_frame_context
+            skip_bits(&bc, 2);
+        }
+        if (intra_only) {
+            frame_sync_code = get_bits(&bc, 24);
+            if (frame_sync_code != 0x498342) {
+                av_log(bsf, AV_LOG_ERROR, "Invalid frame sync code: "
+                       "%06x.\n", frame_sync_code);
+                return AVERROR_INVALIDDATA;
+            }
+            if (frame->profile > 0) {
+                unsigned int color_space;
+                if (frame->profile >= 2) {
+                    // ten_or_twelve_bit
+                    skip_bits(&bc, 1);
+                }
+                color_space = get_bits(&bc, 3);
+                if (color_space != 7 /* CS_RGB */) {
+                    // color_range
+                    skip_bits(&bc, 1);
+                    if (frame->profile == 1 || frame->profile == 3) {
+                        // subsampling
+                        skip_bits(&bc, 3);
+                    }
+                } else {
+                    if (frame->profile == 1 || frame->profile == 3)
+                        skip_bits(&bc, 1);
+                }
+            }
+            frame->refresh_frame_flags = get_bits(&bc, 8);
+        } else {
+            frame->refresh_frame_flags = get_bits(&bc, 8);
+        }
+    }
+
+    return 0;
+}
+
+static int vp9_raw_reorder_make_output(AVBSFContext *bsf,
+                                   AVPacket *out,
+                                   VP9RawReorderFrame *last_frame)
+{
+    VP9RawReorderContext *ctx = bsf->priv_data;
+    VP9RawReorderFrame *next_output = last_frame,
+                      *next_display = last_frame, *frame;
+    int s, err;
+
+    for (s = 0; s < FRAME_SLOTS; s++) {
+        frame = ctx->slot[s];
+        if (!frame)
+            continue;
+        if (frame->needs_output && (!next_output ||
+            frame->sequence < next_output->sequence))
+            next_output = frame;
+        if (frame->needs_display && (!next_display ||
+            frame->pts < next_display->pts))
+            next_display = frame;
+    }
+
+    if (!next_output && !next_display)
+        return AVERROR_EOF;
+
+    if (!next_display || (next_output &&
+        next_output->sequence < next_display->sequence))
+        frame = next_output;
+    else
+        frame = next_display;
+
+    if (frame->needs_output && frame->needs_display &&
+        next_output == next_display) {
+        av_log(bsf, AV_LOG_DEBUG, "Output and display frame "
+               "%"PRId64" (%"PRId64") in order.\n",
+               frame->sequence, frame->pts);
+
+        av_packet_move_ref(out, frame->packet);
+
+        frame->needs_output = frame->needs_display = 0;
+    } else if (frame->needs_output) {
+        if (frame->needs_display) {
+            av_log(bsf, AV_LOG_DEBUG, "Output frame %"PRId64" "
+                   "(%"PRId64") for later display.\n",
+                   frame->sequence, frame->pts);
+        } else {
+            av_log(bsf, AV_LOG_DEBUG, "Output unshown frame "
+                   "%"PRId64" (%"PRId64") to keep order.\n",
+                   frame->sequence, frame->pts);
+        }
+
+        av_packet_move_ref(out, frame->packet);
+        out->pts = out->dts;
+
+        frame->needs_output = 0;
+    } else {
+        PutBitContext pb;
+
+        av_assert0(!frame->needs_output && frame->needs_display);
+
+        if (frame->slots == 0) {
+            av_log(bsf, AV_LOG_ERROR, "Attempting to display frame "
+                   "which is no longer available?\n");
+            frame->needs_display = 0;
+            return AVERROR_INVALIDDATA;
+        }
+
+        s = ff_ctz(frame->slots);
+        av_assert0(s < FRAME_SLOTS);
+
+        av_log(bsf, AV_LOG_DEBUG, "Display frame %"PRId64" "
+               "(%"PRId64") from slot %d.\n",
+               frame->sequence, frame->pts, s);
+
+        err = av_new_packet(out, 2);
+        if (err < 0)
+            return err;
+
+        init_put_bits(&pb, out->data, 2);
+
+        // frame_marker
+        put_bits(&pb, 2, 2);
+        // profile_low_bit
+        put_bits(&pb, 1, frame->profile & 1);
+        // profile_high_bit
+        put_bits(&pb, 1, (frame->profile >> 1) & 1);
+        if (frame->profile == 3) {
+            // reserved_zero
+            put_bits(&pb, 1, 0);
+        }
+        // show_existing_frame
+        put_bits(&pb, 1, 1);
+        // frame_to_show_map_idx
+        put_bits(&pb, 3, s);
+
+        while (put_bits_count(&pb) < 16)
+            put_bits(&pb, 1, 0);
+
+        flush_put_bits(&pb);
+        out->pts = out->dts = frame->pts;
+
+        frame->needs_display = 0;
+    }
+
+    return 0;
+}
+
+static int vp9_raw_reorder_filter(AVBSFContext *bsf, AVPacket *out)
+{
+    VP9RawReorderContext *ctx = bsf->priv_data;
+    VP9RawReorderFrame *frame;
+    AVPacket *in;
+    int err, s;
+
+    if (ctx->next_frame) {
+        frame = ctx->next_frame;
+
+    } else {
+        err = ff_bsf_get_packet(bsf, &in);
+        if (err < 0) {
+            if (err == AVERROR_EOF)
+                return vp9_raw_reorder_make_output(bsf, out, NULL);
+            return err;
+        }
+
+        if (in->data[in->size - 1] & 0xe0 == 0xc0) {
+            av_log(bsf, AV_LOG_ERROR, "Input in superframes is not "
+                   "supported.\n");
+            av_packet_free(&in);
+            return AVERROR(ENOSYS);
+        }
+
+        frame = av_mallocz(sizeof(*frame));
+        if (!frame) {
+            av_packet_free(&in);
+            return AVERROR(ENOMEM);
+        }
+
+        frame->packet   = in;
+        frame->pts      = in->pts;
+        frame->sequence = ++ctx->sequence;
+        err = vp9_raw_reorder_frame_parse(bsf, frame);
+        if (err) {
+            av_log(bsf, AV_LOG_ERROR, "Failed to parse input "
+                   "frame: %d.\n", err);
+            goto fail;
+        }
+
+        frame->needs_output  = 1;
+        frame->needs_display = frame->pts != AV_NOPTS_VALUE;
+
+        if (frame->show_existing_frame)
+            av_log(bsf, AV_LOG_DEBUG, "Show frame %"PRId64" "
+                   "(%"PRId64"): show %u.\n", frame->sequence,
+                   frame->pts, frame->frame_to_show);
+        else
+            av_log(bsf, AV_LOG_DEBUG, "New frame %"PRId64" "
+                   "(%"PRId64"): type %u show %u refresh %02x.\n",
+                   frame->sequence, frame->pts, frame->frame_type,
+                   frame->show_frame, frame->refresh_frame_flags);
+
+        ctx->next_frame = frame;
+    }
+
+    for (s = 0; s < FRAME_SLOTS; s++) {
+        if (!(frame->refresh_frame_flags & (1 << s)))
+            continue;
+        if (ctx->slot[s] && ctx->slot[s]->needs_display &&
+            ctx->slot[s]->slots == (1 << s)) {
+            // We are overwriting this slot, which is last reference
+            // to the frame previously present in it.  In order to be
+            // a valid stream, that frame must already have been
+            // displayed before the pts of the current frame.
+            err = vp9_raw_reorder_make_output(bsf, out, ctx->slot[s]);
+            if (err < 0) {
+                av_log(bsf, AV_LOG_ERROR, "Failed to create "
+                       "output overwriting slot %d: %d.\n",
+                       s, err);
+                // Clear the slot anyway, so we don't end up
+                // in an infinite loop.
+                vp9_raw_reorder_clear_slot(ctx, s);
+                return AVERROR_INVALIDDATA;
+            }
+            return 0;
+        }
+        vp9_raw_reorder_clear_slot(ctx, s);
+    }
+
+    for (s = 0; s < FRAME_SLOTS; s++) {
+        if (!(frame->refresh_frame_flags & (1 << s)))
+            continue;
+        ctx->slot[s] = frame;
+    }
+    frame->slots = frame->refresh_frame_flags;
+
+    if (!frame->refresh_frame_flags) {
+        err = vp9_raw_reorder_make_output(bsf, out, frame);
+        if (err < 0) {
+            av_log(bsf, AV_LOG_ERROR, "Failed to create output "
+                   "for transient frame.\n");
+            ctx->next_frame = NULL;
+            return AVERROR_INVALIDDATA;
+        }
+        if (!frame->needs_display) {
+            vp9_raw_reorder_frame_free(&frame);
+            ctx->next_frame = NULL;
+        }
+        return 0;
+    }
+
+    ctx->next_frame = NULL;
+    return AVERROR(EAGAIN);
+
+fail:
+    vp9_raw_reorder_frame_free(&frame);
+    return err;
+}
+
+static void vp9_raw_reorder_close(AVBSFContext *bsf)
+{
+    VP9RawReorderContext *ctx = bsf->priv_data;
+    int s;
+
+    for (s = 0; s < FRAME_SLOTS; s++)
+        vp9_raw_reorder_clear_slot(ctx, s);
+}
+
+static const enum AVCodecID vp9_raw_reorder_codec_ids[] = {
+    AV_CODEC_ID_VP9, AV_CODEC_ID_NONE,
+};
+
+const AVBitStreamFilter ff_vp9_raw_reorder_bsf = {
+    .name           = "vp9_raw_reorder",
+    .priv_data_size = sizeof(VP9RawReorderContext),
+    .close          = &vp9_raw_reorder_close,
+    .filter         = &vp9_raw_reorder_filter,
+    .codec_ids      = vp9_raw_reorder_codec_ids,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9_superframe_split_bsf.c b/mythtv/external/FFmpeg/libavcodec/vp9_superframe_split_bsf.c
new file mode 100644
index 00000000000..0d2523ebf75
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vp9_superframe_split_bsf.c
@@ -0,0 +1,146 @@
+/*
+ * 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
+ * This bitstream filter splits VP9 superframes into packets containing
+ * just one frame.
+ */
+
+#include <stddef.h>
+
+#include "avcodec.h"
+#include "bsf.h"
+#include "bytestream.h"
+#include "get_bits.h"
+
+typedef struct VP9SFSplitContext {
+    AVPacket *buffer_pkt;
+
+    int nb_frames;
+    int next_frame;
+    size_t next_frame_offset;
+    int sizes[8];
+} VP9SFSplitContext;
+
+static int vp9_superframe_split_filter(AVBSFContext *ctx, AVPacket *out)
+{
+    VP9SFSplitContext *s = ctx->priv_data;
+    AVPacket *in;
+    int i, j, ret, marker;
+    int is_superframe = !!s->buffer_pkt;
+
+    if (!s->buffer_pkt) {
+        ret = ff_bsf_get_packet(ctx, &s->buffer_pkt);
+        if (ret < 0)
+            return ret;
+        in = s->buffer_pkt;
+
+        marker = in->data[in->size - 1];
+        if ((marker & 0xe0) == 0xc0) {
+            int length_size = 1 + ((marker >> 3) & 0x3);
+            int   nb_frames = 1 + (marker & 0x7);
+            int    idx_size = 2 + nb_frames * length_size;
+
+            if (in->size >= idx_size && in->data[in->size - idx_size] == marker) {
+                GetByteContext bc;
+                int64_t total_size = 0;
+
+                bytestream2_init(&bc, in->data + in->size + 1 - idx_size,
+                                 nb_frames * length_size);
+
+                for (i = 0; i < nb_frames; i++) {
+                    int frame_size = 0;
+                    for (j = 0; j < length_size; j++)
+                        frame_size |= bytestream2_get_byte(&bc) << (j * 8);
+
+                    total_size += frame_size;
+                    if (frame_size < 0 || total_size > in->size - idx_size) {
+                        av_log(ctx, AV_LOG_ERROR,
+                               "Invalid frame size in a superframe: %d\n", frame_size);
+                        ret = AVERROR(EINVAL);
+                        goto fail;
+                    }
+                    s->sizes[i] = frame_size;
+                }
+                s->nb_frames         = nb_frames;
+                s->next_frame        = 0;
+                s->next_frame_offset = 0;
+                is_superframe        = 1;
+            }
+        }
+    }
+
+    if (is_superframe) {
+        GetBitContext gb;
+        int profile, invisible = 0;
+
+        ret = av_packet_ref(out, s->buffer_pkt);
+        if (ret < 0)
+            goto fail;
+
+        out->data += s->next_frame_offset;
+        out->size  = s->sizes[s->next_frame];
+
+        s->next_frame_offset += out->size;
+        s->next_frame++;
+
+        if (s->next_frame >= s->nb_frames)
+            av_packet_free(&s->buffer_pkt);
+
+        ret = init_get_bits8(&gb, out->data, out->size);
+        if (ret < 0)
+            goto fail;
+
+        get_bits(&gb, 2); // frame_marker
+        profile  = get_bits1(&gb);
+        profile |= get_bits1(&gb) << 1;
+        if (profile == 3)
+            get_bits1(&gb);
+        if (!get_bits1(&gb)) {
+            get_bits1(&gb);
+            invisible = !get_bits1(&gb);
+        }
+
+        if (invisible)
+            out->pts = AV_NOPTS_VALUE;
+
+    } else {
+        av_packet_move_ref(out, s->buffer_pkt);
+        av_packet_free(&s->buffer_pkt);
+    }
+
+    return 0;
+fail:
+    av_packet_free(&s->buffer_pkt);
+    return ret;
+}
+
+static void vp9_superframe_split_uninit(AVBSFContext *ctx)
+{
+    VP9SFSplitContext *s = ctx->priv_data;
+    av_packet_free(&s->buffer_pkt);
+}
+
+const AVBitStreamFilter ff_vp9_superframe_split_bsf = {
+    .name = "vp9_superframe_split",
+    .priv_data_size = sizeof(VP9SFSplitContext),
+    .close          = vp9_superframe_split_uninit,
+    .filter         = vp9_superframe_split_filter,
+    .codec_ids      = (const enum AVCodecID []){ AV_CODEC_ID_VP9, AV_CODEC_ID_NONE },
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9block.c b/mythtv/external/FFmpeg/libavcodec/vp9block.c
new file mode 100644
index 00000000000..1c3f7a72253
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vp9block.c
@@ -0,0 +1,1449 @@
+/*
+ * VP9 compatible video decoder
+ *
+ * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
+ * Copyright (C) 2013 Clément Bœsch <u pkh me>
+ *
+ * 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/avassert.h"
+
+#include "avcodec.h"
+#include "internal.h"
+#include "videodsp.h"
+#include "vp56.h"
+#include "vp9.h"
+#include "vp9data.h"
+#include "vp9dec.h"
+
+static av_always_inline void setctx_2d(uint8_t *ptr, int w, int h,
+                                       ptrdiff_t stride, int v)
+{
+    switch (w) {
+    case 1:
+        do {
+            *ptr = v;
+            ptr += stride;
+        } while (--h);
+        break;
+    case 2: {
+        int v16 = v * 0x0101;
+        do {
+            AV_WN16A(ptr, v16);
+            ptr += stride;
+        } while (--h);
+        break;
+    }
+    case 4: {
+        uint32_t v32 = v * 0x01010101;
+        do {
+            AV_WN32A(ptr, v32);
+            ptr += stride;
+        } while (--h);
+        break;
+    }
+    case 8: {
+#if HAVE_FAST_64BIT
+        uint64_t v64 = v * 0x0101010101010101ULL;
+        do {
+            AV_WN64A(ptr, v64);
+            ptr += stride;
+        } while (--h);
+#else
+        uint32_t v32 = v * 0x01010101;
+        do {
+            AV_WN32A(ptr,     v32);
+            AV_WN32A(ptr + 4, v32);
+            ptr += stride;
+        } while (--h);
+#endif
+        break;
+    }
+    }
+}
+
+static void decode_mode(VP9TileData *td)
+{
+    static const uint8_t left_ctx[N_BS_SIZES] = {
+        0x0, 0x8, 0x0, 0x8, 0xc, 0x8, 0xc, 0xe, 0xc, 0xe, 0xf, 0xe, 0xf
+    };
+    static const uint8_t above_ctx[N_BS_SIZES] = {
+        0x0, 0x0, 0x8, 0x8, 0x8, 0xc, 0xc, 0xc, 0xe, 0xe, 0xe, 0xf, 0xf
+    };
+    static const uint8_t max_tx_for_bl_bp[N_BS_SIZES] = {
+        TX_32X32, TX_32X32, TX_32X32, TX_32X32, TX_16X16, TX_16X16,
+        TX_16X16, TX_8X8,   TX_8X8,   TX_8X8,   TX_4X4,   TX_4X4,  TX_4X4
+    };
+    VP9Context *s = td->s;
+    VP9Block *b = td->b;
+    int row = td->row, col = td->col, row7 = td->row7;
+    enum TxfmMode max_tx = max_tx_for_bl_bp[b->bs];
+    int bw4 = ff_vp9_bwh_tab[1][b->bs][0], w4 = FFMIN(s->cols - col, bw4);
+    int bh4 = ff_vp9_bwh_tab[1][b->bs][1], h4 = FFMIN(s->rows - row, bh4), y;
+    int have_a = row > 0, have_l = col > td->tile_col_start;
+    int vref, filter_id;
+
+    if (!s->s.h.segmentation.enabled) {
+        b->seg_id = 0;
+    } else if (s->s.h.keyframe || s->s.h.intraonly) {
+        b->seg_id = !s->s.h.segmentation.update_map ? 0 :
+                    vp8_rac_get_tree(td->c, ff_vp9_segmentation_tree, s->s.h.segmentation.prob);
+    } else if (!s->s.h.segmentation.update_map ||
+               (s->s.h.segmentation.temporal &&
+                vp56_rac_get_prob_branchy(td->c,
+                    s->s.h.segmentation.pred_prob[s->above_segpred_ctx[col] +
+                                    td->left_segpred_ctx[row7]]))) {
+        if (!s->s.h.errorres && s->s.frames[REF_FRAME_SEGMAP].segmentation_map) {
+            int pred = 8, x;
+            uint8_t *refsegmap = s->s.frames[REF_FRAME_SEGMAP].segmentation_map;
+
+            if (!s->s.frames[REF_FRAME_SEGMAP].uses_2pass)
+                ff_thread_await_progress(&s->s.frames[REF_FRAME_SEGMAP].tf, row >> 3, 0);
+            for (y = 0; y < h4; y++) {
+                int idx_base = (y + row) * 8 * s->sb_cols + col;
+                for (x = 0; x < w4; x++)
+                    pred = FFMIN(pred, refsegmap[idx_base + x]);
+            }
+            av_assert1(pred < 8);
+            b->seg_id = pred;
+        } else {
+            b->seg_id = 0;
+        }
+
+        memset(&s->above_segpred_ctx[col], 1, w4);
+        memset(&td->left_segpred_ctx[row7], 1, h4);
+    } else {
+        b->seg_id = vp8_rac_get_tree(td->c, ff_vp9_segmentation_tree,
+                                     s->s.h.segmentation.prob);
+
+        memset(&s->above_segpred_ctx[col], 0, w4);
+        memset(&td->left_segpred_ctx[row7], 0, h4);
+    }
+    if (s->s.h.segmentation.enabled &&
+        (s->s.h.segmentation.update_map || s->s.h.keyframe || s->s.h.intraonly)) {
+        setctx_2d(&s->s.frames[CUR_FRAME].segmentation_map[row * 8 * s->sb_cols + col],
+                  bw4, bh4, 8 * s->sb_cols, b->seg_id);
+    }
+
+    b->skip = s->s.h.segmentation.enabled &&
+        s->s.h.segmentation.feat[b->seg_id].skip_enabled;
+    if (!b->skip) {
+        int c = td->left_skip_ctx[row7] + s->above_skip_ctx[col];
+        b->skip = vp56_rac_get_prob(td->c, s->prob.p.skip[c]);
+        td->counts.skip[c][b->skip]++;
+    }
+
+    if (s->s.h.keyframe || s->s.h.intraonly) {
+        b->intra = 1;
+    } else if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].ref_enabled) {
+        b->intra = !s->s.h.segmentation.feat[b->seg_id].ref_val;
+    } else {
+        int c, bit;
+
+        if (have_a && have_l) {
+            c = s->above_intra_ctx[col] + td->left_intra_ctx[row7];
+            c += (c == 2);
+        } else {
+            c = have_a ? 2 * s->above_intra_ctx[col] :
+                have_l ? 2 * td->left_intra_ctx[row7] : 0;
+        }
+        bit = vp56_rac_get_prob(td->c, s->prob.p.intra[c]);
+        td->counts.intra[c][bit]++;
+        b->intra = !bit;
+    }
+
+    if ((b->intra || !b->skip) && s->s.h.txfmmode == TX_SWITCHABLE) {
+        int c;
+        if (have_a) {
+            if (have_l) {
+                c = (s->above_skip_ctx[col] ? max_tx :
+                     s->above_txfm_ctx[col]) +
+                    (td->left_skip_ctx[row7] ? max_tx :
+                     td->left_txfm_ctx[row7]) > max_tx;
+            } else {
+                c = s->above_skip_ctx[col] ? 1 :
+                    (s->above_txfm_ctx[col] * 2 > max_tx);
+            }
+        } else if (have_l) {
+            c = td->left_skip_ctx[row7] ? 1 :
+                (td->left_txfm_ctx[row7] * 2 > max_tx);
+        } else {
+            c = 1;
+        }
+        switch (max_tx) {
+        case TX_32X32:
+            b->tx = vp56_rac_get_prob(td->c, s->prob.p.tx32p[c][0]);
+            if (b->tx) {
+                b->tx += vp56_rac_get_prob(td->c, s->prob.p.tx32p[c][1]);
+                if (b->tx == 2)
+                    b->tx += vp56_rac_get_prob(td->c, s->prob.p.tx32p[c][2]);
+            }
+            td->counts.tx32p[c][b->tx]++;
+            break;
+        case TX_16X16:
+            b->tx = vp56_rac_get_prob(td->c, s->prob.p.tx16p[c][0]);
+            if (b->tx)
+                b->tx += vp56_rac_get_prob(td->c, s->prob.p.tx16p[c][1]);
+            td->counts.tx16p[c][b->tx]++;
+            break;
+        case TX_8X8:
+            b->tx = vp56_rac_get_prob(td->c, s->prob.p.tx8p[c]);
+            td->counts.tx8p[c][b->tx]++;
+            break;
+        case TX_4X4:
+            b->tx = TX_4X4;
+            break;
+        }
+    } else {
+        b->tx = FFMIN(max_tx, s->s.h.txfmmode);
+    }
+
+    if (s->s.h.keyframe || s->s.h.intraonly) {
+        uint8_t *a = &s->above_mode_ctx[col * 2];
+        uint8_t *l = &td->left_mode_ctx[(row7) << 1];
+
+        b->comp = 0;
+        if (b->bs > BS_8x8) {
+            // FIXME the memory storage intermediates here aren't really
+            // necessary, they're just there to make the code slightly
+            // simpler for now
+            b->mode[0] =
+            a[0]       = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                          ff_vp9_default_kf_ymode_probs[a[0]][l[0]]);
+            if (b->bs != BS_8x4) {
+                b->mode[1] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                              ff_vp9_default_kf_ymode_probs[a[1]][b->mode[0]]);
+                l[0]       =
+                a[1]       = b->mode[1];
+            } else {
+                l[0]       =
+                a[1]       =
+                b->mode[1] = b->mode[0];
+            }
+            if (b->bs != BS_4x8) {
+                b->mode[2] =
+                a[0]       = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                              ff_vp9_default_kf_ymode_probs[a[0]][l[1]]);
+                if (b->bs != BS_8x4) {
+                    b->mode[3] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                                  ff_vp9_default_kf_ymode_probs[a[1]][b->mode[2]]);
+                    l[1]       =
+                    a[1]       = b->mode[3];
+                } else {
+                    l[1]       =
+                    a[1]       =
+                    b->mode[3] = b->mode[2];
+                }
+            } else {
+                b->mode[2] = b->mode[0];
+                l[1]       =
+                a[1]       =
+                b->mode[3] = b->mode[1];
+            }
+        } else {
+            b->mode[0] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                          ff_vp9_default_kf_ymode_probs[*a][*l]);
+            b->mode[3] =
+            b->mode[2] =
+            b->mode[1] = b->mode[0];
+            // FIXME this can probably be optimized
+            memset(a, b->mode[0], ff_vp9_bwh_tab[0][b->bs][0]);
+            memset(l, b->mode[0], ff_vp9_bwh_tab[0][b->bs][1]);
+        }
+        b->uvmode = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                     ff_vp9_default_kf_uvmode_probs[b->mode[3]]);
+    } else if (b->intra) {
+        b->comp = 0;
+        if (b->bs > BS_8x8) {
+            b->mode[0] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                          s->prob.p.y_mode[0]);
+            td->counts.y_mode[0][b->mode[0]]++;
+            if (b->bs != BS_8x4) {
+                b->mode[1] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                              s->prob.p.y_mode[0]);
+                td->counts.y_mode[0][b->mode[1]]++;
+            } else {
+                b->mode[1] = b->mode[0];
+            }
+            if (b->bs != BS_4x8) {
+                b->mode[2] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                              s->prob.p.y_mode[0]);
+                td->counts.y_mode[0][b->mode[2]]++;
+                if (b->bs != BS_8x4) {
+                    b->mode[3] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                                  s->prob.p.y_mode[0]);
+                    td->counts.y_mode[0][b->mode[3]]++;
+                } else {
+                    b->mode[3] = b->mode[2];
+                }
+            } else {
+                b->mode[2] = b->mode[0];
+                b->mode[3] = b->mode[1];
+            }
+        } else {
+            static const uint8_t size_group[10] = {
+                3, 3, 3, 3, 2, 2, 2, 1, 1, 1
+            };
+            int sz = size_group[b->bs];
+
+            b->mode[0] = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                          s->prob.p.y_mode[sz]);
+            b->mode[1] =
+            b->mode[2] =
+            b->mode[3] = b->mode[0];
+            td->counts.y_mode[sz][b->mode[3]]++;
+        }
+        b->uvmode = vp8_rac_get_tree(td->c, ff_vp9_intramode_tree,
+                                     s->prob.p.uv_mode[b->mode[3]]);
+        td->counts.uv_mode[b->mode[3]][b->uvmode]++;
+    } else {
+        static const uint8_t inter_mode_ctx_lut[14][14] = {
+            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
+            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
+            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
+            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
+            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
+            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
+            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
+            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
+            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
+            { 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5 },
+            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 },
+            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 2, 1, 3 },
+            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, 0, 3 },
+            { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 3, 3, 4 },
+        };
+
+        if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].ref_enabled) {
+            av_assert2(s->s.h.segmentation.feat[b->seg_id].ref_val != 0);
+            b->comp = 0;
+            b->ref[0] = s->s.h.segmentation.feat[b->seg_id].ref_val - 1;
+        } else {
+            // read comp_pred flag
+            if (s->s.h.comppredmode != PRED_SWITCHABLE) {
+                b->comp = s->s.h.comppredmode == PRED_COMPREF;
+            } else {
+                int c;
+
+                // FIXME add intra as ref=0xff (or -1) to make these easier?
+                if (have_a) {
+                    if (have_l) {
+                        if (s->above_comp_ctx[col] && td->left_comp_ctx[row7]) {
+                            c = 4;
+                        } else if (s->above_comp_ctx[col]) {
+                            c = 2 + (td->left_intra_ctx[row7] ||
+                                     td->left_ref_ctx[row7] == s->s.h.fixcompref);
+                        } else if (td->left_comp_ctx[row7]) {
+                            c = 2 + (s->above_intra_ctx[col] ||
+                                     s->above_ref_ctx[col] == s->s.h.fixcompref);
+                        } else {
+                            c = (!s->above_intra_ctx[col] &&
+                                 s->above_ref_ctx[col] == s->s.h.fixcompref) ^
+                                (!td->left_intra_ctx[row7] &&
+                                 td->left_ref_ctx[row & 7] == s->s.h.fixcompref);
+                        }
+                    } else {
+                        c = s->above_comp_ctx[col] ? 3 :
+                        (!s->above_intra_ctx[col] && s->above_ref_ctx[col] == s->s.h.fixcompref);
+                    }
+                } else if (have_l) {
+                    c = td->left_comp_ctx[row7] ? 3 :
+                    (!td->left_intra_ctx[row7] && td->left_ref_ctx[row7] == s->s.h.fixcompref);
+                } else {
+                    c = 1;
+                }
+                b->comp = vp56_rac_get_prob(td->c, s->prob.p.comp[c]);
+                td->counts.comp[c][b->comp]++;
+            }
+
+            // read actual references
+            // FIXME probably cache a few variables here to prevent repetitive
+            // memory accesses below
+            if (b->comp) { /* two references */
+                int fix_idx = s->s.h.signbias[s->s.h.fixcompref], var_idx = !fix_idx, c, bit;
+
+                b->ref[fix_idx] = s->s.h.fixcompref;
+                // FIXME can this codeblob be replaced by some sort of LUT?
+                if (have_a) {
+                    if (have_l) {
+                        if (s->above_intra_ctx[col]) {
+                            if (td->left_intra_ctx[row7]) {
+                                c = 2;
+                            } else {
+                                c = 1 + 2 * (td->left_ref_ctx[row7] != s->s.h.varcompref[1]);
+                            }
+                        } else if (td->left_intra_ctx[row7]) {
+                            c = 1 + 2 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]);
+                        } else {
+                            int refl = td->left_ref_ctx[row7], refa = s->above_ref_ctx[col];
+
+                            if (refl == refa && refa == s->s.h.varcompref[1]) {
+                                c = 0;
+                            } else if (!td->left_comp_ctx[row7] && !s->above_comp_ctx[col]) {
+                                if ((refa == s->s.h.fixcompref && refl == s->s.h.varcompref[0]) ||
+                                    (refl == s->s.h.fixcompref && refa == s->s.h.varcompref[0])) {
+                                    c = 4;
+                                } else {
+                                    c = (refa == refl) ? 3 : 1;
+                                }
+                            } else if (!td->left_comp_ctx[row7]) {
+                                if (refa == s->s.h.varcompref[1] && refl != s->s.h.varcompref[1]) {
+                                    c = 1;
+                                } else {
+                                    c = (refl == s->s.h.varcompref[1] &&
+                                         refa != s->s.h.varcompref[1]) ? 2 : 4;
+                                }
+                            } else if (!s->above_comp_ctx[col]) {
+                                if (refl == s->s.h.varcompref[1] && refa != s->s.h.varcompref[1]) {
+                                    c = 1;
+                                } else {
+                                    c = (refa == s->s.h.varcompref[1] &&
+                                         refl != s->s.h.varcompref[1]) ? 2 : 4;
+                                }
+                            } else {
+                                c = (refl == refa) ? 4 : 2;
+                            }
+                        }
+                    } else {
+                        if (s->above_intra_ctx[col]) {
+                            c = 2;
+                        } else if (s->above_comp_ctx[col]) {
+                            c = 4 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]);
+                        } else {
+                            c = 3 * (s->above_ref_ctx[col] != s->s.h.varcompref[1]);
+                        }
+                    }
+                } else if (have_l) {
+                    if (td->left_intra_ctx[row7]) {
+                        c = 2;
+                    } else if (td->left_comp_ctx[row7]) {
+                        c = 4 * (td->left_ref_ctx[row7] != s->s.h.varcompref[1]);
+                    } else {
+                        c = 3 * (td->left_ref_ctx[row7] != s->s.h.varcompref[1]);
+                    }
+                } else {
+                    c = 2;
+                }
+                bit = vp56_rac_get_prob(td->c, s->prob.p.comp_ref[c]);
+                b->ref[var_idx] = s->s.h.varcompref[bit];
+                td->counts.comp_ref[c][bit]++;
+            } else /* single reference */ {
+                int bit, c;
+
+                if (have_a && !s->above_intra_ctx[col]) {
+                    if (have_l && !td->left_intra_ctx[row7]) {
+                        if (td->left_comp_ctx[row7]) {
+                            if (s->above_comp_ctx[col]) {
+                                c = 1 + (!s->s.h.fixcompref || !td->left_ref_ctx[row7] ||
+                                         !s->above_ref_ctx[col]);
+                            } else {
+                                c = (3 * !s->above_ref_ctx[col]) +
+                                    (!s->s.h.fixcompref || !td->left_ref_ctx[row7]);
+                            }
+                        } else if (s->above_comp_ctx[col]) {
+                            c = (3 * !td->left_ref_ctx[row7]) +
+                                (!s->s.h.fixcompref || !s->above_ref_ctx[col]);
+                        } else {
+                            c = 2 * !td->left_ref_ctx[row7] + 2 * !s->above_ref_ctx[col];
+                        }
+                    } else if (s->above_intra_ctx[col]) {
+                        c = 2;
+                    } else if (s->above_comp_ctx[col]) {
+                        c = 1 + (!s->s.h.fixcompref || !s->above_ref_ctx[col]);
+                    } else {
+                        c = 4 * (!s->above_ref_ctx[col]);
+                    }
+                } else if (have_l && !td->left_intra_ctx[row7]) {
+                    if (td->left_intra_ctx[row7]) {
+                        c = 2;
+                    } else if (td->left_comp_ctx[row7]) {
+                        c = 1 + (!s->s.h.fixcompref || !td->left_ref_ctx[row7]);
+                    } else {
+                        c = 4 * (!td->left_ref_ctx[row7]);
+                    }
+                } else {
+                    c = 2;
+                }
+                bit = vp56_rac_get_prob(td->c, s->prob.p.single_ref[c][0]);
+                td->counts.single_ref[c][0][bit]++;
+                if (!bit) {
+                    b->ref[0] = 0;
+                } else {
+                    // FIXME can this codeblob be replaced by some sort of LUT?
+                    if (have_a) {
+                        if (have_l) {
+                            if (td->left_intra_ctx[row7]) {
+                                if (s->above_intra_ctx[col]) {
+                                    c = 2;
+                                } else if (s->above_comp_ctx[col]) {
+                                    c = 1 + 2 * (s->s.h.fixcompref == 1 ||
+                                                 s->above_ref_ctx[col] == 1);
+                                } else if (!s->above_ref_ctx[col]) {
+                                    c = 3;
+                                } else {
+                                    c = 4 * (s->above_ref_ctx[col] == 1);
+                                }
+                            } else if (s->above_intra_ctx[col]) {
+                                if (td->left_intra_ctx[row7]) {
+                                    c = 2;
+                                } else if (td->left_comp_ctx[row7]) {
+                                    c = 1 + 2 * (s->s.h.fixcompref == 1 ||
+                                                 td->left_ref_ctx[row7] == 1);
+                                } else if (!td->left_ref_ctx[row7]) {
+                                    c = 3;
+                                } else {
+                                    c = 4 * (td->left_ref_ctx[row7] == 1);
+                                }
+                            } else if (s->above_comp_ctx[col]) {
+                                if (td->left_comp_ctx[row7]) {
+                                    if (td->left_ref_ctx[row7] == s->above_ref_ctx[col]) {
+                                        c = 3 * (s->s.h.fixcompref == 1 ||
+                                                 td->left_ref_ctx[row7] == 1);
+                                    } else {
+                                        c = 2;
+                                    }
+                                } else if (!td->left_ref_ctx[row7]) {
+                                    c = 1 + 2 * (s->s.h.fixcompref == 1 ||
+                                                 s->above_ref_ctx[col] == 1);
+                                } else {
+                                    c = 3 * (td->left_ref_ctx[row7] == 1) +
+                                    (s->s.h.fixcompref == 1 || s->above_ref_ctx[col] == 1);
+                                }
+                            } else if (td->left_comp_ctx[row7]) {
+                                if (!s->above_ref_ctx[col]) {
+                                    c = 1 + 2 * (s->s.h.fixcompref == 1 ||
+                                                 td->left_ref_ctx[row7] == 1);
+                                } else {
+                                    c = 3 * (s->above_ref_ctx[col] == 1) +
+                                    (s->s.h.fixcompref == 1 || td->left_ref_ctx[row7] == 1);
+                                }
+                            } else if (!s->above_ref_ctx[col]) {
+                                if (!td->left_ref_ctx[row7]) {
+                                    c = 3;
+                                } else {
+                                    c = 4 * (td->left_ref_ctx[row7] == 1);
+                                }
+                            } else if (!td->left_ref_ctx[row7]) {
+                                c = 4 * (s->above_ref_ctx[col] == 1);
+                            } else {
+                                c = 2 * (td->left_ref_ctx[row7] == 1) +
+                                    2 * (s->above_ref_ctx[col] == 1);
+                            }
+                        } else {
+                            if (s->above_intra_ctx[col] ||
+                                (!s->above_comp_ctx[col] && !s->above_ref_ctx[col])) {
+                                c = 2;
+                            } else if (s->above_comp_ctx[col]) {
+                                c = 3 * (s->s.h.fixcompref == 1 || s->above_ref_ctx[col] == 1);
+                            } else {
+                                c = 4 * (s->above_ref_ctx[col] == 1);
+                            }
+                        }
+                    } else if (have_l) {
+                        if (td->left_intra_ctx[row7] ||
+                            (!td->left_comp_ctx[row7] && !td->left_ref_ctx[row7])) {
+                            c = 2;
+                        } else if (td->left_comp_ctx[row7]) {
+                            c = 3 * (s->s.h.fixcompref == 1 || td->left_ref_ctx[row7] == 1);
+                        } else {
+                            c = 4 * (td->left_ref_ctx[row7] == 1);
+                        }
+                    } else {
+                        c = 2;
+                    }
+                    bit = vp56_rac_get_prob(td->c, s->prob.p.single_ref[c][1]);
+                    td->counts.single_ref[c][1][bit]++;
+                    b->ref[0] = 1 + bit;
+                }
+            }
+        }
+
+        if (b->bs <= BS_8x8) {
+            if (s->s.h.segmentation.enabled && s->s.h.segmentation.feat[b->seg_id].skip_enabled) {
+                b->mode[0] =
+                b->mode[1] =
+                b->mode[2] =
+                b->mode[3] = ZEROMV;
+            } else {
+                static const uint8_t off[10] = {
+                    3, 0, 0, 1, 0, 0, 0, 0, 0, 0
+                };
+
+                // FIXME this needs to use the LUT tables from find_ref_mvs
+                // because not all are -1,0/0,-1
+                int c = inter_mode_ctx_lut[s->above_mode_ctx[col + off[b->bs]]]
+                                          [td->left_mode_ctx[row7 + off[b->bs]]];
+
+                b->mode[0] = vp8_rac_get_tree(td->c, ff_vp9_inter_mode_tree,
+                                              s->prob.p.mv_mode[c]);
+                b->mode[1] =
+                b->mode[2] =
+                b->mode[3] = b->mode[0];
+                td->counts.mv_mode[c][b->mode[0] - 10]++;
+            }
+        }
+
+        if (s->s.h.filtermode == FILTER_SWITCHABLE) {
+            int c;
+
+            if (have_a && s->above_mode_ctx[col] >= NEARESTMV) {
+                if (have_l && td->left_mode_ctx[row7] >= NEARESTMV) {
+                    c = s->above_filter_ctx[col] == td->left_filter_ctx[row7] ?
+                        td->left_filter_ctx[row7] : 3;
+                } else {
+                    c = s->above_filter_ctx[col];
+                }
+            } else if (have_l && td->left_mode_ctx[row7] >= NEARESTMV) {
+                c = td->left_filter_ctx[row7];
+            } else {
+                c = 3;
+            }
+
+            filter_id = vp8_rac_get_tree(td->c, ff_vp9_filter_tree,
+                                         s->prob.p.filter[c]);
+            td->counts.filter[c][filter_id]++;
+            b->filter = ff_vp9_filter_lut[filter_id];
+        } else {
+            b->filter = s->s.h.filtermode;
+        }
+
+        if (b->bs > BS_8x8) {
+            int c = inter_mode_ctx_lut[s->above_mode_ctx[col]][td->left_mode_ctx[row7]];
+
+            b->mode[0] = vp8_rac_get_tree(td->c, ff_vp9_inter_mode_tree,
+                                          s->prob.p.mv_mode[c]);
+            td->counts.mv_mode[c][b->mode[0] - 10]++;
+            ff_vp9_fill_mv(td, b->mv[0], b->mode[0], 0);
+
+            if (b->bs != BS_8x4) {
+                b->mode[1] = vp8_rac_get_tree(td->c, ff_vp9_inter_mode_tree,
+                                              s->prob.p.mv_mode[c]);
+                td->counts.mv_mode[c][b->mode[1] - 10]++;
+                ff_vp9_fill_mv(td, b->mv[1], b->mode[1], 1);
+            } else {
+                b->mode[1] = b->mode[0];
+                AV_COPY32(&b->mv[1][0], &b->mv[0][0]);
+                AV_COPY32(&b->mv[1][1], &b->mv[0][1]);
+            }
+
+            if (b->bs != BS_4x8) {
+                b->mode[2] = vp8_rac_get_tree(td->c, ff_vp9_inter_mode_tree,
+                                              s->prob.p.mv_mode[c]);
+                td->counts.mv_mode[c][b->mode[2] - 10]++;
+                ff_vp9_fill_mv(td, b->mv[2], b->mode[2], 2);
+
+                if (b->bs != BS_8x4) {
+                    b->mode[3] = vp8_rac_get_tree(td->c, ff_vp9_inter_mode_tree,
+                                                  s->prob.p.mv_mode[c]);
+                    td->counts.mv_mode[c][b->mode[3] - 10]++;
+                    ff_vp9_fill_mv(td, b->mv[3], b->mode[3], 3);
+                } else {
+                    b->mode[3] = b->mode[2];
+                    AV_COPY32(&b->mv[3][0], &b->mv[2][0]);
+                    AV_COPY32(&b->mv[3][1], &b->mv[2][1]);
+                }
+            } else {
+                b->mode[2] = b->mode[0];
+                AV_COPY32(&b->mv[2][0], &b->mv[0][0]);
+                AV_COPY32(&b->mv[2][1], &b->mv[0][1]);
+                b->mode[3] = b->mode[1];
+                AV_COPY32(&b->mv[3][0], &b->mv[1][0]);
+                AV_COPY32(&b->mv[3][1], &b->mv[1][1]);
+            }
+        } else {
+            ff_vp9_fill_mv(td, b->mv[0], b->mode[0], -1);
+            AV_COPY32(&b->mv[1][0], &b->mv[0][0]);
+            AV_COPY32(&b->mv[2][0], &b->mv[0][0]);
+            AV_COPY32(&b->mv[3][0], &b->mv[0][0]);
+            AV_COPY32(&b->mv[1][1], &b->mv[0][1]);
+            AV_COPY32(&b->mv[2][1], &b->mv[0][1]);
+            AV_COPY32(&b->mv[3][1], &b->mv[0][1]);
+        }
+
+        vref = b->ref[b->comp ? s->s.h.signbias[s->s.h.varcompref[0]] : 0];
+    }
+
+#if HAVE_FAST_64BIT
+#define SPLAT_CTX(var, val, n) \
+    switch (n) { \
+    case 1:  var = val;                                    break; \
+    case 2:  AV_WN16A(&var, val *             0x0101);     break; \
+    case 4:  AV_WN32A(&var, val *         0x01010101);     break; \
+    case 8:  AV_WN64A(&var, val * 0x0101010101010101ULL);  break; \
+    case 16: { \
+        uint64_t v64 = val * 0x0101010101010101ULL; \
+        AV_WN64A(              &var,     v64); \
+        AV_WN64A(&((uint8_t *) &var)[8], v64); \
+        break; \
+    } \
+    }
+#else
+#define SPLAT_CTX(var, val, n) \
+    switch (n) { \
+    case 1:  var = val;                         break; \
+    case 2:  AV_WN16A(&var, val *     0x0101);  break; \
+    case 4:  AV_WN32A(&var, val * 0x01010101);  break; \
+    case 8: { \
+        uint32_t v32 = val * 0x01010101; \
+        AV_WN32A(              &var,     v32); \
+        AV_WN32A(&((uint8_t *) &var)[4], v32); \
+        break; \
+    } \
+    case 16: { \
+        uint32_t v32 = val * 0x01010101; \
+        AV_WN32A(              &var,      v32); \
+        AV_WN32A(&((uint8_t *) &var)[4],  v32); \
+        AV_WN32A(&((uint8_t *) &var)[8],  v32); \
+        AV_WN32A(&((uint8_t *) &var)[12], v32); \
+        break; \
+    } \
+    }
+#endif
+
+    switch (ff_vp9_bwh_tab[1][b->bs][0]) {
+#define SET_CTXS(perf, dir, off, n) \
+    do { \
+        SPLAT_CTX(perf->dir##_skip_ctx[off],      b->skip,          n); \
+        SPLAT_CTX(perf->dir##_txfm_ctx[off],      b->tx,            n); \
+        SPLAT_CTX(perf->dir##_partition_ctx[off], dir##_ctx[b->bs], n); \
+        if (!s->s.h.keyframe && !s->s.h.intraonly) { \
+            SPLAT_CTX(perf->dir##_intra_ctx[off], b->intra,   n); \
+            SPLAT_CTX(perf->dir##_comp_ctx[off],  b->comp,    n); \
+            SPLAT_CTX(perf->dir##_mode_ctx[off],  b->mode[3], n); \
+            if (!b->intra) { \
+                SPLAT_CTX(perf->dir##_ref_ctx[off], vref, n); \
+                if (s->s.h.filtermode == FILTER_SWITCHABLE) { \
+                    SPLAT_CTX(perf->dir##_filter_ctx[off], filter_id, n); \
+                } \
+            } \
+        } \
+    } while (0)
+    case 1: SET_CTXS(s, above, col, 1); break;
+    case 2: SET_CTXS(s, above, col, 2); break;
+    case 4: SET_CTXS(s, above, col, 4); break;
+    case 8: SET_CTXS(s, above, col, 8); break;
+    }
+    switch (ff_vp9_bwh_tab[1][b->bs][1]) {
+    case 1: SET_CTXS(td, left, row7, 1); break;
+    case 2: SET_CTXS(td, left, row7, 2); break;
+    case 4: SET_CTXS(td, left, row7, 4); break;
+    case 8: SET_CTXS(td, left, row7, 8); break;
+    }
+#undef SPLAT_CTX
+#undef SET_CTXS
+
+    if (!s->s.h.keyframe && !s->s.h.intraonly) {
+        if (b->bs > BS_8x8) {
+            int mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]);
+
+            AV_COPY32(&td->left_mv_ctx[row7 * 2 + 0][0], &b->mv[1][0]);
+            AV_COPY32(&td->left_mv_ctx[row7 * 2 + 0][1], &b->mv[1][1]);
+            AV_WN32A(&td->left_mv_ctx[row7 * 2 + 1][0], mv0);
+            AV_WN32A(&td->left_mv_ctx[row7 * 2 + 1][1], mv1);
+            AV_COPY32(&s->above_mv_ctx[col * 2 + 0][0], &b->mv[2][0]);
+            AV_COPY32(&s->above_mv_ctx[col * 2 + 0][1], &b->mv[2][1]);
+            AV_WN32A(&s->above_mv_ctx[col * 2 + 1][0], mv0);
+            AV_WN32A(&s->above_mv_ctx[col * 2 + 1][1], mv1);
+        } else {
+            int n, mv0 = AV_RN32A(&b->mv[3][0]), mv1 = AV_RN32A(&b->mv[3][1]);
+
+            for (n = 0; n < w4 * 2; n++) {
+                AV_WN32A(&s->above_mv_ctx[col * 2 + n][0], mv0);
+                AV_WN32A(&s->above_mv_ctx[col * 2 + n][1], mv1);
+            }
+            for (n = 0; n < h4 * 2; n++) {
+                AV_WN32A(&td->left_mv_ctx[row7 * 2 + n][0], mv0);
+                AV_WN32A(&td->left_mv_ctx[row7 * 2 + n][1], mv1);
+            }
+        }
+    }
+
+    // FIXME kinda ugly
+    for (y = 0; y < h4; y++) {
+        int x, o = (row + y) * s->sb_cols * 8 + col;
+        VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[o];
+
+        if (b->intra) {
+            for (x = 0; x < w4; x++) {
+                mv[x].ref[0] =
+                mv[x].ref[1] = -1;
+            }
+        } else if (b->comp) {
+            for (x = 0; x < w4; x++) {
+                mv[x].ref[0] = b->ref[0];
+                mv[x].ref[1] = b->ref[1];
+                AV_COPY32(&mv[x].mv[0], &b->mv[3][0]);
+                AV_COPY32(&mv[x].mv[1], &b->mv[3][1]);
+            }
+        } else {
+            for (x = 0; x < w4; x++) {
+                mv[x].ref[0] = b->ref[0];
+                mv[x].ref[1] = -1;
+                AV_COPY32(&mv[x].mv[0], &b->mv[3][0]);
+            }
+        }
+    }
+}
+
+// FIXME merge cnt/eob arguments?
+static av_always_inline int
+decode_coeffs_b_generic(VP56RangeCoder *c, int16_t *coef, int n_coeffs,
+                        int is_tx32x32, int is8bitsperpixel, int bpp, unsigned (*cnt)[6][3],
+                        unsigned (*eob)[6][2], uint8_t (*p)[6][11],
+                        int nnz, const int16_t *scan, const int16_t (*nb)[2],
+                        const int16_t *band_counts, int16_t *qmul)
+{
+    int i = 0, band = 0, band_left = band_counts[band];
+    const uint8_t *tp = p[0][nnz];
+    uint8_t cache[1024];
+
+    do {
+        int val, rc;
+
+        val = vp56_rac_get_prob_branchy(c, tp[0]); // eob
+        eob[band][nnz][val]++;
+        if (!val)
+            break;
+
+skip_eob:
+        if (!vp56_rac_get_prob_branchy(c, tp[1])) { // zero
+            cnt[band][nnz][0]++;
+            if (!--band_left)
+                band_left = band_counts[++band];
+            cache[scan[i]] = 0;
+            nnz            = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1;
+            tp             = p[band][nnz];
+            if (++i == n_coeffs)
+                break;  //invalid input; blocks should end with EOB
+            goto skip_eob;
+        }
+
+        rc = scan[i];
+        if (!vp56_rac_get_prob_branchy(c, tp[2])) { // one
+            cnt[band][nnz][1]++;
+            val       = 1;
+            cache[rc] = 1;
+        } else {
+            cnt[band][nnz][2]++;
+            if (!vp56_rac_get_prob_branchy(c, tp[3])) { // 2, 3, 4
+                if (!vp56_rac_get_prob_branchy(c, tp[4])) {
+                    cache[rc] = val = 2;
+                } else {
+                    val       = 3 + vp56_rac_get_prob(c, tp[5]);
+                    cache[rc] = 3;
+                }
+            } else if (!vp56_rac_get_prob_branchy(c, tp[6])) { // cat1/2
+                cache[rc] = 4;
+                if (!vp56_rac_get_prob_branchy(c, tp[7])) {
+                    val  =  vp56_rac_get_prob(c, 159) + 5;
+                } else {
+                    val  = (vp56_rac_get_prob(c, 165) << 1) + 7;
+                    val +=  vp56_rac_get_prob(c, 145);
+                }
+            } else { // cat 3-6
+                cache[rc] = 5;
+                if (!vp56_rac_get_prob_branchy(c, tp[8])) {
+                    if (!vp56_rac_get_prob_branchy(c, tp[9])) {
+                        val  = 11 + (vp56_rac_get_prob(c, 173) << 2);
+                        val +=      (vp56_rac_get_prob(c, 148) << 1);
+                        val +=       vp56_rac_get_prob(c, 140);
+                    } else {
+                        val  = 19 + (vp56_rac_get_prob(c, 176) << 3);
+                        val +=      (vp56_rac_get_prob(c, 155) << 2);
+                        val +=      (vp56_rac_get_prob(c, 140) << 1);
+                        val +=       vp56_rac_get_prob(c, 135);
+                    }
+                } else if (!vp56_rac_get_prob_branchy(c, tp[10])) {
+                    val  = (vp56_rac_get_prob(c, 180) << 4) + 35;
+                    val += (vp56_rac_get_prob(c, 157) << 3);
+                    val += (vp56_rac_get_prob(c, 141) << 2);
+                    val += (vp56_rac_get_prob(c, 134) << 1);
+                    val +=  vp56_rac_get_prob(c, 130);
+                } else {
+                    val = 67;
+                    if (!is8bitsperpixel) {
+                        if (bpp == 12) {
+                            val += vp56_rac_get_prob(c, 255) << 17;
+                            val += vp56_rac_get_prob(c, 255) << 16;
+                        }
+                        val +=  (vp56_rac_get_prob(c, 255) << 15);
+                        val +=  (vp56_rac_get_prob(c, 255) << 14);
+                    }
+                    val += (vp56_rac_get_prob(c, 254) << 13);
+                    val += (vp56_rac_get_prob(c, 254) << 12);
+                    val += (vp56_rac_get_prob(c, 254) << 11);
+                    val += (vp56_rac_get_prob(c, 252) << 10);
+                    val += (vp56_rac_get_prob(c, 249) << 9);
+                    val += (vp56_rac_get_prob(c, 243) << 8);
+                    val += (vp56_rac_get_prob(c, 230) << 7);
+                    val += (vp56_rac_get_prob(c, 196) << 6);
+                    val += (vp56_rac_get_prob(c, 177) << 5);
+                    val += (vp56_rac_get_prob(c, 153) << 4);
+                    val += (vp56_rac_get_prob(c, 140) << 3);
+                    val += (vp56_rac_get_prob(c, 133) << 2);
+                    val += (vp56_rac_get_prob(c, 130) << 1);
+                    val +=  vp56_rac_get_prob(c, 129);
+                }
+            }
+        }
+#define STORE_COEF(c, i, v) do { \
+    if (is8bitsperpixel) { \
+        c[i] = v; \
+    } else { \
+        AV_WN32A(&c[i * 2], v); \
+    } \
+} while (0)
+        if (!--band_left)
+            band_left = band_counts[++band];
+        if (is_tx32x32)
+            STORE_COEF(coef, rc, (int)((vp8_rac_get(c) ? -val : val) * (unsigned)qmul[!!i]) / 2);
+        else
+            STORE_COEF(coef, rc, (vp8_rac_get(c) ? -val : val) * (unsigned)qmul[!!i]);
+        nnz = (1 + cache[nb[i][0]] + cache[nb[i][1]]) >> 1;
+        tp = p[band][nnz];
+    } while (++i < n_coeffs);
+
+    return i;
+}
+
+static int decode_coeffs_b_8bpp(VP9TileData *td, int16_t *coef, int n_coeffs,
+                                unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
+                                uint8_t (*p)[6][11], int nnz, const int16_t *scan,
+                                const int16_t (*nb)[2], const int16_t *band_counts,
+                                int16_t *qmul)
+{
+    return decode_coeffs_b_generic(td->c, coef, n_coeffs, 0, 1, 8, cnt, eob, p,
+                                   nnz, scan, nb, band_counts, qmul);
+}
+
+static int decode_coeffs_b32_8bpp(VP9TileData *td, int16_t *coef, int n_coeffs,
+                                  unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
+                                  uint8_t (*p)[6][11], int nnz, const int16_t *scan,
+                                  const int16_t (*nb)[2], const int16_t *band_counts,
+                                  int16_t *qmul)
+{
+    return decode_coeffs_b_generic(td->c, coef, n_coeffs, 1, 1, 8, cnt, eob, p,
+                                   nnz, scan, nb, band_counts, qmul);
+}
+
+static int decode_coeffs_b_16bpp(VP9TileData *td, int16_t *coef, int n_coeffs,
+                                 unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
+                                 uint8_t (*p)[6][11], int nnz, const int16_t *scan,
+                                 const int16_t (*nb)[2], const int16_t *band_counts,
+                                 int16_t *qmul)
+{
+    return decode_coeffs_b_generic(td->c, coef, n_coeffs, 0, 0, td->s->s.h.bpp, cnt, eob, p,
+                                   nnz, scan, nb, band_counts, qmul);
+}
+
+static int decode_coeffs_b32_16bpp(VP9TileData *td, int16_t *coef, int n_coeffs,
+                                   unsigned (*cnt)[6][3], unsigned (*eob)[6][2],
+                                   uint8_t (*p)[6][11], int nnz, const int16_t *scan,
+                                   const int16_t (*nb)[2], const int16_t *band_counts,
+                                   int16_t *qmul)
+{
+    return decode_coeffs_b_generic(td->c, coef, n_coeffs, 1, 0, td->s->s.h.bpp, cnt, eob, p,
+                                   nnz, scan, nb, band_counts, qmul);
+}
+
+static av_always_inline int decode_coeffs(VP9TileData *td, int is8bitsperpixel)
+{
+    VP9Context *s = td->s;
+    VP9Block *b = td->b;
+    int row = td->row, col = td->col;
+    uint8_t (*p)[6][11] = s->prob.coef[b->tx][0 /* y */][!b->intra];
+    unsigned (*c)[6][3] = td->counts.coef[b->tx][0 /* y */][!b->intra];
+    unsigned (*e)[6][2] = td->counts.eob[b->tx][0 /* y */][!b->intra];
+    int w4 = ff_vp9_bwh_tab[1][b->bs][0] << 1, h4 = ff_vp9_bwh_tab[1][b->bs][1] << 1;
+    int end_x = FFMIN(2 * (s->cols - col), w4);
+    int end_y = FFMIN(2 * (s->rows - row), h4);
+    int n, pl, x, y, ret;
+    int16_t (*qmul)[2] = s->s.h.segmentation.feat[b->seg_id].qmul;
+    int tx = 4 * s->s.h.lossless + b->tx;
+    const int16_t * const *yscans = ff_vp9_scans[tx];
+    const int16_t (* const * ynbs)[2] = ff_vp9_scans_nb[tx];
+    const int16_t *uvscan = ff_vp9_scans[b->uvtx][DCT_DCT];
+    const int16_t (*uvnb)[2] = ff_vp9_scans_nb[b->uvtx][DCT_DCT];
+    uint8_t *a = &s->above_y_nnz_ctx[col * 2];
+    uint8_t *l = &td->left_y_nnz_ctx[(row & 7) << 1];
+    static const int16_t band_counts[4][8] = {
+        { 1, 2, 3, 4,  3,   16 - 13 },
+        { 1, 2, 3, 4, 11,   64 - 21 },
+        { 1, 2, 3, 4, 11,  256 - 21 },
+        { 1, 2, 3, 4, 11, 1024 - 21 },
+    };
+    const int16_t *y_band_counts = band_counts[b->tx];
+    const int16_t *uv_band_counts = band_counts[b->uvtx];
+    int bytesperpixel = is8bitsperpixel ? 1 : 2;
+    int total_coeff = 0;
+
+#define MERGE(la, end, step, rd) \
+    for (n = 0; n < end; n += step) \
+        la[n] = !!rd(&la[n])
+#define MERGE_CTX(step, rd) \
+    do { \
+        MERGE(l, end_y, step, rd); \
+        MERGE(a, end_x, step, rd); \
+    } while (0)
+
+#define DECODE_Y_COEF_LOOP(step, mode_index, v) \
+    for (n = 0, y = 0; y < end_y; y += step) { \
+        for (x = 0; x < end_x; x += step, n += step * step) { \
+            enum TxfmType txtp = ff_vp9_intra_txfm_type[b->mode[mode_index]]; \
+            ret = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \
+                                    (td, td->block + 16 * n * bytesperpixel, 16 * step * step, \
+                                     c, e, p, a[x] + l[y], yscans[txtp], \
+                                     ynbs[txtp], y_band_counts, qmul[0]); \
+            a[x] = l[y] = !!ret; \
+            total_coeff |= !!ret; \
+            if (step >= 4) { \
+                AV_WN16A(&td->eob[n], ret); \
+            } else { \
+                td->eob[n] = ret; \
+            } \
+        } \
+    }
+
+#define SPLAT(la, end, step, cond) \
+    if (step == 2) { \
+        for (n = 1; n < end; n += step) \
+            la[n] = la[n - 1]; \
+    } else if (step == 4) { \
+        if (cond) { \
+            for (n = 0; n < end; n += step) \
+                AV_WN32A(&la[n], la[n] * 0x01010101); \
+        } else { \
+            for (n = 0; n < end; n += step) \
+                memset(&la[n + 1], la[n], FFMIN(end - n - 1, 3)); \
+        } \
+    } else /* step == 8 */ { \
+        if (cond) { \
+            if (HAVE_FAST_64BIT) { \
+                for (n = 0; n < end; n += step) \
+                    AV_WN64A(&la[n], la[n] * 0x0101010101010101ULL); \
+            } else { \
+                for (n = 0; n < end; n += step) { \
+                    uint32_t v32 = la[n] * 0x01010101; \
+                    AV_WN32A(&la[n],     v32); \
+                    AV_WN32A(&la[n + 4], v32); \
+                } \
+            } \
+        } else { \
+            for (n = 0; n < end; n += step) \
+                memset(&la[n + 1], la[n], FFMIN(end - n - 1, 7)); \
+        } \
+    }
+#define SPLAT_CTX(step) \
+    do { \
+        SPLAT(a, end_x, step, end_x == w4); \
+        SPLAT(l, end_y, step, end_y == h4); \
+    } while (0)
+
+    /* y tokens */
+    switch (b->tx) {
+    case TX_4X4:
+        DECODE_Y_COEF_LOOP(1, b->bs > BS_8x8 ? n : 0,);
+        break;
+    case TX_8X8:
+        MERGE_CTX(2, AV_RN16A);
+        DECODE_Y_COEF_LOOP(2, 0,);
+        SPLAT_CTX(2);
+        break;
+    case TX_16X16:
+        MERGE_CTX(4, AV_RN32A);
+        DECODE_Y_COEF_LOOP(4, 0,);
+        SPLAT_CTX(4);
+        break;
+    case TX_32X32:
+        MERGE_CTX(8, AV_RN64A);
+        DECODE_Y_COEF_LOOP(8, 0, 32);
+        SPLAT_CTX(8);
+        break;
+    }
+
+#define DECODE_UV_COEF_LOOP(step, v) \
+    for (n = 0, y = 0; y < end_y; y += step) { \
+        for (x = 0; x < end_x; x += step, n += step * step) { \
+            ret = (is8bitsperpixel ? decode_coeffs_b##v##_8bpp : decode_coeffs_b##v##_16bpp) \
+                                    (td, td->uvblock[pl] + 16 * n * bytesperpixel, \
+                                     16 * step * step, c, e, p, a[x] + l[y], \
+                                     uvscan, uvnb, uv_band_counts, qmul[1]); \
+            a[x] = l[y] = !!ret; \
+            total_coeff |= !!ret; \
+            if (step >= 4) { \
+                AV_WN16A(&td->uveob[pl][n], ret); \
+            } else { \
+                td->uveob[pl][n] = ret; \
+            } \
+        } \
+    }
+
+    p = s->prob.coef[b->uvtx][1 /* uv */][!b->intra];
+    c = td->counts.coef[b->uvtx][1 /* uv */][!b->intra];
+    e = td->counts.eob[b->uvtx][1 /* uv */][!b->intra];
+    w4 >>= s->ss_h;
+    end_x >>= s->ss_h;
+    h4 >>= s->ss_v;
+    end_y >>= s->ss_v;
+    for (pl = 0; pl < 2; pl++) {
+        a = &s->above_uv_nnz_ctx[pl][col << !s->ss_h];
+        l = &td->left_uv_nnz_ctx[pl][(row & 7) << !s->ss_v];
+        switch (b->uvtx) {
+        case TX_4X4:
+            DECODE_UV_COEF_LOOP(1,);
+            break;
+        case TX_8X8:
+            MERGE_CTX(2, AV_RN16A);
+            DECODE_UV_COEF_LOOP(2,);
+            SPLAT_CTX(2);
+            break;
+        case TX_16X16:
+            MERGE_CTX(4, AV_RN32A);
+            DECODE_UV_COEF_LOOP(4,);
+            SPLAT_CTX(4);
+            break;
+        case TX_32X32:
+            MERGE_CTX(8, AV_RN64A);
+            DECODE_UV_COEF_LOOP(8, 32);
+            SPLAT_CTX(8);
+            break;
+        }
+    }
+
+    return total_coeff;
+}
+
+static int decode_coeffs_8bpp(VP9TileData *td)
+{
+    return decode_coeffs(td, 1);
+}
+
+static int decode_coeffs_16bpp(VP9TileData *td)
+{
+    return decode_coeffs(td, 0);
+}
+
+static av_always_inline void mask_edges(uint8_t (*mask)[8][4], int ss_h, int ss_v,
+                                        int row_and_7, int col_and_7,
+                                        int w, int h, int col_end, int row_end,
+                                        enum TxfmMode tx, int skip_inter)
+{
+    static const unsigned wide_filter_col_mask[2] = { 0x11, 0x01 };
+    static const unsigned wide_filter_row_mask[2] = { 0x03, 0x07 };
+
+    // FIXME I'm pretty sure all loops can be replaced by a single LUT if
+    // we make VP9Filter.mask uint64_t (i.e. row/col all single variable)
+    // and make the LUT 5-indexed (bl, bp, is_uv, tx and row/col), and then
+    // use row_and_7/col_and_7 as shifts (1*col_and_7+8*row_and_7)
+
+    // the intended behaviour of the vp9 loopfilter is to work on 8-pixel
+    // edges. This means that for UV, we work on two subsampled blocks at
+    // a time, and we only use the topleft block's mode information to set
+    // things like block strength. Thus, for any block size smaller than
+    // 16x16, ignore the odd portion of the block.
+    if (tx == TX_4X4 && (ss_v | ss_h)) {
+        if (h == ss_v) {
+            if (row_and_7 & 1)
+                return;
+            if (!row_end)
+                h += 1;
+        }
+        if (w == ss_h) {
+            if (col_and_7 & 1)
+                return;
+            if (!col_end)
+                w += 1;
+        }
+    }
+
+    if (tx == TX_4X4 && !skip_inter) {
+        int t = 1 << col_and_7, m_col = (t << w) - t, y;
+        // on 32-px edges, use the 8-px wide loopfilter; else, use 4-px wide
+        int m_row_8 = m_col & wide_filter_col_mask[ss_h], m_row_4 = m_col - m_row_8;
+
+        for (y = row_and_7; y < h + row_and_7; y++) {
+            int col_mask_id = 2 - !(y & wide_filter_row_mask[ss_v]);
+
+            mask[0][y][1] |= m_row_8;
+            mask[0][y][2] |= m_row_4;
+            // for odd lines, if the odd col is not being filtered,
+            // skip odd row also:
+            // .---. <-- a
+            // |   |
+            // |___| <-- b
+            // ^   ^
+            // c   d
+            //
+            // if a/c are even row/col and b/d are odd, and d is skipped,
+            // e.g. right edge of size-66x66.webm, then skip b also (bug)
+            if ((ss_h & ss_v) && (col_end & 1) && (y & 1)) {
+                mask[1][y][col_mask_id] |= (t << (w - 1)) - t;
+            } else {
+                mask[1][y][col_mask_id] |= m_col;
+            }
+            if (!ss_h)
+                mask[0][y][3] |= m_col;
+            if (!ss_v) {
+                if (ss_h && (col_end & 1))
+                    mask[1][y][3] |= (t << (w - 1)) - t;
+                else
+                    mask[1][y][3] |= m_col;
+            }
+        }
+    } else {
+        int y, t = 1 << col_and_7, m_col = (t << w) - t;
+
+        if (!skip_inter) {
+            int mask_id = (tx == TX_8X8);
+            int l2 = tx + ss_h - 1, step1d;
+            static const unsigned masks[4] = { 0xff, 0x55, 0x11, 0x01 };
+            int m_row = m_col & masks[l2];
+
+            // at odd UV col/row edges tx16/tx32 loopfilter edges, force
+            // 8wd loopfilter to prevent going off the visible edge.
+            if (ss_h && tx > TX_8X8 && (w ^ (w - 1)) == 1) {
+                int m_row_16 = ((t << (w - 1)) - t) & masks[l2];
+                int m_row_8 = m_row - m_row_16;
+
+                for (y = row_and_7; y < h + row_and_7; y++) {
+                    mask[0][y][0] |= m_row_16;
+                    mask[0][y][1] |= m_row_8;
+                }
+            } else {
+                for (y = row_and_7; y < h + row_and_7; y++)
+                    mask[0][y][mask_id] |= m_row;
+            }
+
+            l2 = tx + ss_v - 1;
+            step1d = 1 << l2;
+            if (ss_v && tx > TX_8X8 && (h ^ (h - 1)) == 1) {
+                for (y = row_and_7; y < h + row_and_7 - 1; y += step1d)
+                    mask[1][y][0] |= m_col;
+                if (y - row_and_7 == h - 1)
+                    mask[1][y][1] |= m_col;
+            } else {
+                for (y = row_and_7; y < h + row_and_7; y += step1d)
+                    mask[1][y][mask_id] |= m_col;
+            }
+        } else if (tx != TX_4X4) {
+            int mask_id;
+
+            mask_id = (tx == TX_8X8) || (h == ss_v);
+            mask[1][row_and_7][mask_id] |= m_col;
+            mask_id = (tx == TX_8X8) || (w == ss_h);
+            for (y = row_and_7; y < h + row_and_7; y++)
+                mask[0][y][mask_id] |= t;
+        } else {
+            int t8 = t & wide_filter_col_mask[ss_h], t4 = t - t8;
+
+            for (y = row_and_7; y < h + row_and_7; y++) {
+                mask[0][y][2] |= t4;
+                mask[0][y][1] |= t8;
+            }
+            mask[1][row_and_7][2 - !(row_and_7 & wide_filter_row_mask[ss_v])] |= m_col;
+        }
+    }
+}
+
+void ff_vp9_decode_block(VP9TileData *td, int row, int col,
+                         VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff,
+                         enum BlockLevel bl, enum BlockPartition bp)
+{
+    VP9Context *s = td->s;
+    VP9Block *b = td->b;
+    enum BlockSize bs = bl * 3 + bp;
+    int bytesperpixel = s->bytesperpixel;
+    int w4 = ff_vp9_bwh_tab[1][bs][0], h4 = ff_vp9_bwh_tab[1][bs][1], lvl;
+    int emu[2];
+    AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
+
+    td->row = row;
+    td->row7 = row & 7;
+    td->col = col;
+    td->col7 = col & 7;
+
+    td->min_mv.x = -(128 + col * 64);
+    td->min_mv.y = -(128 + row * 64);
+    td->max_mv.x = 128 + (s->cols - col - w4) * 64;
+    td->max_mv.y = 128 + (s->rows - row - h4) * 64;
+
+    if (s->pass < 2) {
+        b->bs = bs;
+        b->bl = bl;
+        b->bp = bp;
+        decode_mode(td);
+        b->uvtx = b->tx - ((s->ss_h && w4 * 2 == (1 << b->tx)) ||
+                           (s->ss_v && h4 * 2 == (1 << b->tx)));
+
+        if (!b->skip) {
+            int has_coeffs;
+
+            if (bytesperpixel == 1) {
+                has_coeffs = decode_coeffs_8bpp(td);
+            } else {
+                has_coeffs = decode_coeffs_16bpp(td);
+            }
+            if (!has_coeffs && b->bs <= BS_8x8 && !b->intra) {
+                b->skip = 1;
+                memset(&s->above_skip_ctx[col], 1, w4);
+                memset(&td->left_skip_ctx[td->row7], 1, h4);
+            }
+        } else {
+            int row7 = td->row7;
+
+#define SPLAT_ZERO_CTX(v, n) \
+    switch (n) { \
+    case 1:  v = 0;          break; \
+    case 2:  AV_ZERO16(&v);  break; \
+    case 4:  AV_ZERO32(&v);  break; \
+    case 8:  AV_ZERO64(&v);  break; \
+    case 16: AV_ZERO128(&v); break; \
+    }
+#define SPLAT_ZERO_YUV(dir, var, off, n, dir2) \
+    do { \
+        SPLAT_ZERO_CTX(dir##_y_##var[off * 2], n * 2); \
+        if (s->ss_##dir2) { \
+            SPLAT_ZERO_CTX(dir##_uv_##var[0][off], n); \
+            SPLAT_ZERO_CTX(dir##_uv_##var[1][off], n); \
+        } else { \
+            SPLAT_ZERO_CTX(dir##_uv_##var[0][off * 2], n * 2); \
+            SPLAT_ZERO_CTX(dir##_uv_##var[1][off * 2], n * 2); \
+        } \
+    } while (0)
+
+            switch (w4) {
+            case 1: SPLAT_ZERO_YUV(s->above, nnz_ctx, col, 1, h); break;
+            case 2: SPLAT_ZERO_YUV(s->above, nnz_ctx, col, 2, h); break;
+            case 4: SPLAT_ZERO_YUV(s->above, nnz_ctx, col, 4, h); break;
+            case 8: SPLAT_ZERO_YUV(s->above, nnz_ctx, col, 8, h); break;
+            }
+            switch (h4) {
+            case 1: SPLAT_ZERO_YUV(td->left, nnz_ctx, row7, 1, v); break;
+            case 2: SPLAT_ZERO_YUV(td->left, nnz_ctx, row7, 2, v); break;
+            case 4: SPLAT_ZERO_YUV(td->left, nnz_ctx, row7, 4, v); break;
+            case 8: SPLAT_ZERO_YUV(td->left, nnz_ctx, row7, 8, v); break;
+            }
+        }
+
+        if (s->pass == 1) {
+            s->td[0].b++;
+            s->td[0].block += w4 * h4 * 64 * bytesperpixel;
+            s->td[0].uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v);
+            s->td[0].uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_h + s->ss_v);
+            s->td[0].eob += 4 * w4 * h4;
+            s->td[0].uveob[0] += 4 * w4 * h4 >> (s->ss_h + s->ss_v);
+            s->td[0].uveob[1] += 4 * w4 * h4 >> (s->ss_h + s->ss_v);
+
+            return;
+        }
+    }
+
+    // emulated overhangs if the stride of the target buffer can't hold. This
+    // makes it possible to support emu-edge and so on even if we have large block
+    // overhangs
+    emu[0] = (col + w4) * 8 * bytesperpixel > f->linesize[0] ||
+             (row + h4) > s->rows;
+    emu[1] = ((col + w4) * 8 >> s->ss_h) * bytesperpixel > f->linesize[1] ||
+             (row + h4) > s->rows;
+    if (emu[0]) {
+        td->dst[0] = td->tmp_y;
+        td->y_stride = 128;
+    } else {
+        td->dst[0] = f->data[0] + yoff;
+        td->y_stride = f->linesize[0];
+    }
+    if (emu[1]) {
+        td->dst[1] = td->tmp_uv[0];
+        td->dst[2] = td->tmp_uv[1];
+        td->uv_stride = 128;
+    } else {
+        td->dst[1] = f->data[1] + uvoff;
+        td->dst[2] = f->data[2] + uvoff;
+        td->uv_stride = f->linesize[1];
+    }
+    if (b->intra) {
+        if (s->s.h.bpp > 8) {
+            ff_vp9_intra_recon_16bpp(td, yoff, uvoff);
+        } else {
+            ff_vp9_intra_recon_8bpp(td, yoff, uvoff);
+        }
+    } else {
+        if (s->s.h.bpp > 8) {
+            ff_vp9_inter_recon_16bpp(td);
+        } else {
+            ff_vp9_inter_recon_8bpp(td);
+        }
+    }
+    if (emu[0]) {
+        int w = FFMIN(s->cols - col, w4) * 8, h = FFMIN(s->rows - row, h4) * 8, n, o = 0;
+
+        for (n = 0; o < w; n++) {
+            int bw = 64 >> n;
+
+            av_assert2(n <= 4);
+            if (w & bw) {
+                s->dsp.mc[n][0][0][0][0](f->data[0] + yoff + o * bytesperpixel, f->linesize[0],
+                                         td->tmp_y + o * bytesperpixel, 128, h, 0, 0);
+                o += bw;
+            }
+        }
+    }
+    if (emu[1]) {
+        int w = FFMIN(s->cols - col, w4) * 8 >> s->ss_h;
+        int h = FFMIN(s->rows - row, h4) * 8 >> s->ss_v, n, o = 0;
+
+        for (n = s->ss_h; o < w; n++) {
+            int bw = 64 >> n;
+
+            av_assert2(n <= 4);
+            if (w & bw) {
+                s->dsp.mc[n][0][0][0][0](f->data[1] + uvoff + o * bytesperpixel, f->linesize[1],
+                                         td->tmp_uv[0] + o * bytesperpixel, 128, h, 0, 0);
+                s->dsp.mc[n][0][0][0][0](f->data[2] + uvoff + o * bytesperpixel, f->linesize[2],
+                                         td->tmp_uv[1] + o * bytesperpixel, 128, h, 0, 0);
+                o += bw;
+            }
+        }
+    }
+
+    // pick filter level and find edges to apply filter to
+    if (s->s.h.filter.level &&
+        (lvl = s->s.h.segmentation.feat[b->seg_id].lflvl[b->intra ? 0 : b->ref[0] + 1]
+                                                      [b->mode[3] != ZEROMV]) > 0) {
+        int x_end = FFMIN(s->cols - col, w4), y_end = FFMIN(s->rows - row, h4);
+        int skip_inter = !b->intra && b->skip, col7 = td->col7, row7 = td->row7;
+
+        setctx_2d(&lflvl->level[row7 * 8 + col7], w4, h4, 8, lvl);
+        mask_edges(lflvl->mask[0], 0, 0, row7, col7, x_end, y_end, 0, 0, b->tx, skip_inter);
+        if (s->ss_h || s->ss_v)
+            mask_edges(lflvl->mask[1], s->ss_h, s->ss_v, row7, col7, x_end, y_end,
+                       s->cols & 1 && col + w4 >= s->cols ? s->cols & 7 : 0,
+                       s->rows & 1 && row + h4 >= s->rows ? s->rows & 7 : 0,
+                       b->uvtx, skip_inter);
+    }
+
+    if (s->pass == 2) {
+        s->td[0].b++;
+        s->td[0].block += w4 * h4 * 64 * bytesperpixel;
+        s->td[0].uvblock[0] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h);
+        s->td[0].uvblock[1] += w4 * h4 * 64 * bytesperpixel >> (s->ss_v + s->ss_h);
+        s->td[0].eob += 4 * w4 * h4;
+        s->td[0].uveob[0] += 4 * w4 * h4 >> (s->ss_v + s->ss_h);
+        s->td[0].uveob[1] += 4 * w4 * h4 >> (s->ss_v + s->ss_h);
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9data.c b/mythtv/external/FFmpeg/libavcodec/vp9data.c
new file mode 100644
index 00000000000..7af8a97b1e4
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vp9data.c
@@ -0,0 +1,2247 @@
+/*
+ * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
+ * Copyright (C) 2013 Clément Bœsch <u pkh me>
+ *
+ * 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 "vp9.h"
+#include "vp9data.h"
+
+const uint8_t ff_vp9_bwh_tab[2][N_BS_SIZES][2] = {
+    {
+        { 16, 16 }, { 16, 8 }, { 8, 16 }, { 8, 8 }, { 8, 4 }, { 4, 8 },
+        {  4,  4 }, {  4, 2 }, { 2,  4 }, { 2, 2 }, { 2, 1 }, { 1, 2 }, { 1, 1 },
+    }, {
+        {  8,  8 }, {  8, 4 }, { 4,  8 }, { 4, 4 }, { 4, 2 }, { 2, 4 },
+        {  2,  2 }, {  2, 1 }, { 1,  2 }, { 1, 1 }, { 1, 1 }, { 1, 1 }, { 1, 1 },
+    }
+};
+
+const int8_t ff_vp9_partition_tree[3][2] = {
+    { -PARTITION_NONE, 1 },                      // '0'
+        { -PARTITION_H, 2 },                     // '10'
+            { -PARTITION_V, -PARTITION_SPLIT },  // '110', '111'
+};
+
+const uint8_t ff_vp9_default_kf_partition_probs[4][4][3] = {
+    { /* 64x64 -> 32x32 */
+        { 174,  35,  49 } /* a/l both not split */,
+        {  68,  11,  27 } /* a split, l not split */,
+        {  57,  15,   9 } /* l split, a not split */,
+        {  12,   3,   3 } /* a/l both split */
+    }, { /* 32x32 -> 16x16 */
+        { 150,  40,  39 } /* a/l both not split */,
+        {  78,  12,  26 } /* a split, l not split */,
+        {  67,  33,  11 } /* l split, a not split */,
+        {  24,   7,   5 } /* a/l both split */,
+    }, { /* 16x16 -> 8x8 */
+        { 149,  53,  53 } /* a/l both not split */,
+        {  94,  20,  48 } /* a split, l not split */,
+        {  83,  53,  24 } /* l split, a not split */,
+        {  52,  18,  18 } /* a/l both split */,
+    }, { /* 8x8 -> 4x4 */
+        { 158,  97,  94 } /* a/l both not split */,
+        {  93,  24,  99 } /* a split, l not split */,
+        {  85, 119,  44 } /* l split, a not split */,
+        {  62,  59,  67 } /* a/l both split */,
+    },
+};
+
+const int8_t ff_vp9_segmentation_tree[7][2] = {
+    { 1, 2 },
+        { 3, 4 },
+        { 5, 6 },
+            { -0, -1 },  // '00x'
+            { -2, -3 },  // '01x'
+            { -4, -5 },  // '10x'
+            { -6, -7 },  // '11x'
+};
+
+const int8_t ff_vp9_intramode_tree[9][2] = {
+    { -DC_PRED, 1 },                                                  // '0'
+        { -TM_VP8_PRED, 2 },                                          // '10'
+            { -VERT_PRED, 3 },                                        // '110'
+                { 4, 6 },
+                    { -HOR_PRED, 5 },                                 // '11100'
+                        { -DIAG_DOWN_RIGHT_PRED, -VERT_RIGHT_PRED },  // '11101x'
+                    { -DIAG_DOWN_LEFT_PRED, 7 },                      // '11110'
+                        { -VERT_LEFT_PRED, 8 },                       // '111110'
+                            { -HOR_DOWN_PRED, -HOR_UP_PRED },         // '111111x'
+};
+
+const uint8_t ff_vp9_default_kf_ymode_probs[10][10][9] = {
+    { /* above = v */
+        {  43,  46, 168, 134, 107, 128,  69, 142,  92 } /* left = v */,
+        {  44,  29,  68, 159, 201, 177,  50,  57,  77 } /* left = h */,
+        {  63,  36, 126, 146, 123, 158,  60,  90,  96 } /* left = dc */,
+        {  58,  38,  76, 114,  97, 172,  78, 133,  92 } /* left = d45 */,
+        {  46,  41,  76, 140,  63, 184,  69, 112,  57 } /* left = d135 */,
+        {  38,  32,  85, 140,  46, 112,  54, 151, 133 } /* left = d117 */,
+        {  39,  27,  61, 131, 110, 175,  44,  75, 136 } /* left = d153 */,
+        {  47,  35,  80, 100,  74, 143,  64, 163,  74 } /* left = d63 */,
+        {  52,  30,  74, 113, 130, 175,  51,  64,  58 } /* left = d27 */,
+        {  36,  61, 116, 114, 128, 162,  80, 125,  82 } /* left = tm */
+    }, { /* above = h */
+        {  55,  44,  68, 166, 179, 192,  57,  57, 108 } /* left = v */,
+        {  42,  26,  11, 199, 241, 228,  23,  15,  85 } /* left = h */,
+        {  82,  26,  26, 171, 208, 204,  44,  32, 105 } /* left = dc */,
+        {  68,  42,  19, 131, 160, 199,  55,  52,  83 } /* left = d45 */,
+        {  58,  50,  25, 139, 115, 232,  39,  52, 118 } /* left = d135 */,
+        {  50,  35,  33, 153, 104, 162,  64,  59, 131 } /* left = d117 */,
+        {  44,  24,  16, 150, 177, 202,  33,  19, 156 } /* left = d153 */,
+        {  53,  49,  21, 110, 116, 168,  59,  80,  76 } /* left = d63 */,
+        {  55,  27,  12, 153, 203, 218,  26,  27,  49 } /* left = d27 */,
+        {  38,  72,  19, 168, 203, 212,  50,  50, 107 } /* left = tm */
+    }, { /* above = dc */
+        {  92,  45, 102, 136, 116, 180,  74,  90, 100 } /* left = v */,
+        {  73,  32,  19, 187, 222, 215,  46,  34, 100 } /* left = h */,
+        { 137,  30,  42, 148, 151, 207,  70,  52,  91 } /* left = dc */,
+        {  91,  30,  32, 116, 121, 186,  93,  86,  94 } /* left = d45 */,
+        {  72,  35,  36, 149,  68, 206,  68,  63, 105 } /* left = d135 */,
+        {  73,  31,  28, 138,  57, 124,  55, 122, 151 } /* left = d117 */,
+        {  67,  23,  21, 140, 126, 197,  40,  37, 171 } /* left = d153 */,
+        {  74,  32,  27, 107,  86, 160,  63, 134, 102 } /* left = d63 */,
+        {  86,  27,  28, 128, 154, 212,  45,  43,  53 } /* left = d27 */,
+        {  59,  67,  44, 140, 161, 202,  78,  67, 119 } /* left = tm */
+    }, { /* above = d45 */
+        {  59,  38,  83, 112, 103, 162,  98, 136,  90 } /* left = v */,
+        {  62,  30,  23, 158, 200, 207,  59,  57,  50 } /* left = h */,
+        { 103,  26,  36, 129, 132, 201,  83,  80,  93 } /* left = dc */,
+        {  67,  30,  29,  84,  86, 191, 102,  91,  59 } /* left = d45 */,
+        {  60,  32,  33, 112,  71, 220,  64,  89, 104 } /* left = d135 */,
+        {  53,  26,  34, 130,  56, 149,  84, 120, 103 } /* left = d117 */,
+        {  53,  21,  23, 133, 109, 210,  56,  77, 172 } /* left = d153 */,
+        {  61,  29,  29,  93,  97, 165,  83, 175, 162 } /* left = d63 */,
+        {  77,  19,  29, 112, 142, 228,  55,  66,  36 } /* left = d27 */,
+        {  47,  47,  43, 114, 137, 181, 100,  99,  95 } /* left = tm */
+    }, { /* above = d135 */
+        {  53,  40,  55, 139,  69, 183,  61,  80, 110 } /* left = v */,
+        {  40,  29,  19, 161, 180, 207,  43,  24,  91 } /* left = h */,
+        {  69,  23,  29, 128,  83, 199,  46,  44, 101 } /* left = dc */,
+        {  60,  34,  19, 105,  61, 198,  53,  64,  89 } /* left = d45 */,
+        {  52,  31,  22, 158,  40, 209,  58,  62,  89 } /* left = d135 */,
+        {  44,  31,  29, 147,  46, 158,  56, 102, 198 } /* left = d117 */,
+        {  35,  19,  12, 135,  87, 209,  41,  45, 167 } /* left = d153 */,
+        {  51,  38,  25, 113,  58, 164,  70,  93,  97 } /* left = d63 */,
+        {  55,  25,  21, 118,  95, 215,  38,  39,  66 } /* left = d27 */,
+        {  47,  54,  34, 146, 108, 203,  72, 103, 151 } /* left = tm */
+    }, { /* above = d117 */
+        {  46,  27,  80, 150,  55, 124,  55, 121, 135 } /* left = v */,
+        {  36,  23,  27, 165, 149, 166,  54,  64, 118 } /* left = h */,
+        {  64,  19,  37, 156,  66, 138,  49,  95, 133 } /* left = dc */,
+        {  53,  21,  36, 131,  63, 163,  60, 109,  81 } /* left = d45 */,
+        {  40,  26,  35, 154,  40, 185,  51,  97, 123 } /* left = d135 */,
+        {  35,  19,  34, 179,  19,  97,  48, 129, 124 } /* left = d117 */,
+        {  36,  20,  26, 136,  62, 164,  33,  77, 154 } /* left = d153 */,
+        {  45,  26,  28, 129,  45, 129,  49, 147, 123 } /* left = d63 */,
+        {  45,  18,  32, 130,  90, 157,  40,  79,  91 } /* left = d27 */,
+        {  38,  44,  51, 136,  74, 162,  57,  97, 121 } /* left = tm */
+    }, { /* above = d153 */
+        {  56,  39,  58, 133, 117, 173,  48,  53, 187 } /* left = v */,
+        {  35,  21,  12, 161, 212, 207,  20,  23, 145 } /* left = h */,
+        {  75,  17,  22, 136, 138, 185,  32,  34, 166 } /* left = dc */,
+        {  56,  29,  19, 117, 109, 181,  55,  68, 112 } /* left = d45 */,
+        {  47,  29,  17, 153,  64, 220,  59,  51, 114 } /* left = d135 */,
+        {  46,  16,  24, 136,  76, 147,  41,  64, 172 } /* left = d117 */,
+        {  34,  17,  11, 108, 152, 187,  13,  15, 209 } /* left = d153 */,
+        {  55,  30,  18, 122,  79, 179,  44,  88, 116 } /* left = d63 */,
+        {  51,  24,  14, 115, 133, 209,  32,  26, 104 } /* left = d27 */,
+        {  37,  49,  25, 129, 168, 164,  41,  54, 148 } /* left = tm */
+    }, { /* above = d63 */
+        {  48,  34,  86, 101,  92, 146,  78, 179, 134 } /* left = v */,
+        {  47,  22,  24, 138, 187, 178,  68,  69,  59 } /* left = h */,
+        {  78,  23,  39, 111, 117, 170,  74, 124,  94 } /* left = dc */,
+        {  56,  25,  33, 105, 112, 187,  95, 177, 129 } /* left = d45 */,
+        {  48,  31,  27, 114,  63, 183,  82, 116,  56 } /* left = d135 */,
+        {  43,  28,  37, 121,  63, 123,  61, 192, 169 } /* left = d117 */,
+        {  42,  17,  24, 109,  97, 177,  56,  76, 122 } /* left = d153 */,
+        {  46,  23,  32,  74,  86, 150,  67, 183,  88 } /* left = d63 */,
+        {  58,  18,  28, 105, 139, 182,  70,  92,  63 } /* left = d27 */,
+        {  36,  38,  48,  92, 122, 165,  88, 137,  91 } /* left = tm */
+    }, { /* above = d27 */
+        {  62,  44,  61, 123, 105, 189,  48,  57,  64 } /* left = v */,
+        {  47,  25,  17, 175, 222, 220,  24,  30,  86 } /* left = h */,
+        {  82,  22,  32, 127, 143, 213,  39,  41,  70 } /* left = dc */,
+        {  68,  36,  17, 106, 102, 206,  59,  74,  74 } /* left = d45 */,
+        {  57,  39,  23, 151,  68, 216,  55,  63,  58 } /* left = d135 */,
+        {  49,  30,  35, 141,  70, 168,  82,  40, 115 } /* left = d117 */,
+        {  51,  25,  15, 136, 129, 202,  38,  35, 139 } /* left = d153 */,
+        {  59,  39,  19, 114,  75, 180,  77, 104,  42 } /* left = d63 */,
+        {  68,  26,  16, 111, 141, 215,  29,  28,  28 } /* left = d27 */,
+        {  40,  61,  26, 126, 152, 206,  61,  59,  93 } /* left = tm */
+    }, { /* above = tm */
+        {  44,  78, 115, 132, 119, 173,  71, 112,  93 } /* left = v */,
+        {  39,  38,  21, 184, 227, 206,  42,  32,  64 } /* left = h */,
+        {  65,  70,  60, 155, 159, 199,  61,  60,  81 } /* left = dc */,
+        {  58,  47,  36, 124, 137, 193,  80,  82,  78 } /* left = d45 */,
+        {  49,  50,  35, 144,  95, 205,  63,  78,  59 } /* left = d135 */,
+        {  41,  53,  52, 148,  71, 142,  65, 128,  51 } /* left = d117 */,
+        {  40,  36,  28, 143, 143, 202,  40,  55, 137 } /* left = d153 */,
+        {  42,  44,  44, 104, 105, 164,  64, 130,  80 } /* left = d63 */,
+        {  52,  34,  29, 129, 183, 227,  42,  35,  43 } /* left = d27 */,
+        {  43,  81,  53, 140, 169, 204,  68,  84,  72 } /* left = tm */
+    }
+};
+
+const uint8_t ff_vp9_default_kf_uvmode_probs[10][9] = {
+    { 118,  15, 123, 148, 131, 101,  44,  93, 131 } /* y = v */,
+    { 113,  12,  23, 188, 226, 142,  26,  32, 125 } /* y = h */,
+    { 144,  11,  54, 157, 195, 130,  46,  58, 108 } /* y = dc */,
+    { 120,  11,  50, 123, 163, 135,  64,  77, 103 } /* y = d45 */,
+    { 113,   9,  36, 155, 111, 157,  32,  44, 161 } /* y = d135 */,
+    { 116,   9,  55, 176,  76,  96,  37,  61, 149 } /* y = d117 */,
+    { 115,   9,  28, 141, 161, 167,  21,  25, 193 } /* y = d153 */,
+    { 116,  12,  64, 120, 140, 125,  49, 115, 121 } /* y = d63 */,
+    { 120,  12,  32, 145, 195, 142,  32,  38,  86 } /* y = d27 */,
+    { 102,  19,  66, 162, 182, 122,  35,  59, 128 } /* y = tm */
+};
+
+const int8_t ff_vp9_inter_mode_tree[3][2] = {
+    { -ZEROMV, 1 },               // '0'
+        { -NEARESTMV, 2 },        // '10'
+            { -NEARMV, -NEWMV },  // '11x'
+};
+
+const int8_t ff_vp9_filter_tree[2][2] = {
+    { -0,  1 },     // '0'
+        { -1, -2 }, // '1x'
+};
+
+const enum FilterMode ff_vp9_filter_lut[3] = {
+    FILTER_8TAP_REGULAR,
+    FILTER_8TAP_SMOOTH,
+    FILTER_8TAP_SHARP,
+};
+
+const int16_t ff_vp9_dc_qlookup[3][256] = {
+    {
+            4,     8,     8,     9,    10,    11,    12,    12,
+           13,    14,    15,    16,    17,    18,    19,    19,
+           20,    21,    22,    23,    24,    25,    26,    26,
+           27,    28,    29,    30,    31,    32,    32,    33,
+           34,    35,    36,    37,    38,    38,    39,    40,
+           41,    42,    43,    43,    44,    45,    46,    47,
+           48,    48,    49,    50,    51,    52,    53,    53,
+           54,    55,    56,    57,    57,    58,    59,    60,
+           61,    62,    62,    63,    64,    65,    66,    66,
+           67,    68,    69,    70,    70,    71,    72,    73,
+           74,    74,    75,    76,    77,    78,    78,    79,
+           80,    81,    81,    82,    83,    84,    85,    85,
+           87,    88,    90,    92,    93,    95,    96,    98,
+           99,   101,   102,   104,   105,   107,   108,   110,
+          111,   113,   114,   116,   117,   118,   120,   121,
+          123,   125,   127,   129,   131,   134,   136,   138,
+          140,   142,   144,   146,   148,   150,   152,   154,
+          156,   158,   161,   164,   166,   169,   172,   174,
+          177,   180,   182,   185,   187,   190,   192,   195,
+          199,   202,   205,   208,   211,   214,   217,   220,
+          223,   226,   230,   233,   237,   240,   243,   247,
+          250,   253,   257,   261,   265,   269,   272,   276,
+          280,   284,   288,   292,   296,   300,   304,   309,
+          313,   317,   322,   326,   330,   335,   340,   344,
+          349,   354,   359,   364,   369,   374,   379,   384,
+          389,   395,   400,   406,   411,   417,   423,   429,
+          435,   441,   447,   454,   461,   467,   475,   482,
+          489,   497,   505,   513,   522,   530,   539,   549,
+          559,   569,   579,   590,   602,   614,   626,   640,
+          654,   668,   684,   700,   717,   736,   755,   775,
+          796,   819,   843,   869,   896,   925,   955,   988,
+         1022,  1058,  1098,  1139,  1184,  1232,  1282,  1336,
+    }, {
+            4,     9,    10,    13,    15,    17,    20,    22,
+           25,    28,    31,    34,    37,    40,    43,    47,
+           50,    53,    57,    60,    64,    68,    71,    75,
+           78,    82,    86,    90,    93,    97,   101,   105,
+          109,   113,   116,   120,   124,   128,   132,   136,
+          140,   143,   147,   151,   155,   159,   163,   166,
+          170,   174,   178,   182,   185,   189,   193,   197,
+          200,   204,   208,   212,   215,   219,   223,   226,
+          230,   233,   237,   241,   244,   248,   251,   255,
+          259,   262,   266,   269,   273,   276,   280,   283,
+          287,   290,   293,   297,   300,   304,   307,   310,
+          314,   317,   321,   324,   327,   331,   334,   337,
+          343,   350,   356,   362,   369,   375,   381,   387,
+          394,   400,   406,   412,   418,   424,   430,   436,
+          442,   448,   454,   460,   466,   472,   478,   484,
+          490,   499,   507,   516,   525,   533,   542,   550,
+          559,   567,   576,   584,   592,   601,   609,   617,
+          625,   634,   644,   655,   666,   676,   687,   698,
+          708,   718,   729,   739,   749,   759,   770,   782,
+          795,   807,   819,   831,   844,   856,   868,   880,
+          891,   906,   920,   933,   947,   961,   975,   988,
+         1001,  1015,  1030,  1045,  1061,  1076,  1090,  1105,
+         1120,  1137,  1153,  1170,  1186,  1202,  1218,  1236,
+         1253,  1271,  1288,  1306,  1323,  1342,  1361,  1379,
+         1398,  1416,  1436,  1456,  1476,  1496,  1516,  1537,
+         1559,  1580,  1601,  1624,  1647,  1670,  1692,  1717,
+         1741,  1766,  1791,  1817,  1844,  1871,  1900,  1929,
+         1958,  1990,  2021,  2054,  2088,  2123,  2159,  2197,
+         2236,  2276,  2319,  2363,  2410,  2458,  2508,  2561,
+         2616,  2675,  2737,  2802,  2871,  2944,  3020,  3102,
+         3188,  3280,  3375,  3478,  3586,  3702,  3823,  3953,
+         4089,  4236,  4394,  4559,  4737,  4929,  5130,  5347,
+    }, {
+            4,    12,    18,    25,    33,    41,    50,    60,
+           70,    80,    91,   103,   115,   127,   140,   153,
+          166,   180,   194,   208,   222,   237,   251,   266,
+          281,   296,   312,   327,   343,   358,   374,   390,
+          405,   421,   437,   453,   469,   484,   500,   516,
+          532,   548,   564,   580,   596,   611,   627,   643,
+          659,   674,   690,   706,   721,   737,   752,   768,
+          783,   798,   814,   829,   844,   859,   874,   889,
+          904,   919,   934,   949,   964,   978,   993,  1008,
+         1022,  1037,  1051,  1065,  1080,  1094,  1108,  1122,
+         1136,  1151,  1165,  1179,  1192,  1206,  1220,  1234,
+         1248,  1261,  1275,  1288,  1302,  1315,  1329,  1342,
+         1368,  1393,  1419,  1444,  1469,  1494,  1519,  1544,
+         1569,  1594,  1618,  1643,  1668,  1692,  1717,  1741,
+         1765,  1789,  1814,  1838,  1862,  1885,  1909,  1933,
+         1957,  1992,  2027,  2061,  2096,  2130,  2165,  2199,
+         2233,  2267,  2300,  2334,  2367,  2400,  2434,  2467,
+         2499,  2532,  2575,  2618,  2661,  2704,  2746,  2788,
+         2830,  2872,  2913,  2954,  2995,  3036,  3076,  3127,
+         3177,  3226,  3275,  3324,  3373,  3421,  3469,  3517,
+         3565,  3621,  3677,  3733,  3788,  3843,  3897,  3951,
+         4005,  4058,  4119,  4181,  4241,  4301,  4361,  4420,
+         4479,  4546,  4612,  4677,  4742,  4807,  4871,  4942,
+         5013,  5083,  5153,  5222,  5291,  5367,  5442,  5517,
+         5591,  5665,  5745,  5825,  5905,  5984,  6063,  6149,
+         6234,  6319,  6404,  6495,  6587,  6678,  6769,  6867,
+         6966,  7064,  7163,  7269,  7376,  7483,  7599,  7715,
+         7832,  7958,  8085,  8214,  8352,  8492,  8635,  8788,
+         8945,  9104,  9275,  9450,  9639,  9832, 10031, 10245,
+        10465, 10702, 10946, 11210, 11482, 11776, 12081, 12409,
+        12750, 13118, 13501, 13913, 14343, 14807, 15290, 15812,
+        16356, 16943, 17575, 18237, 18949, 19718, 20521, 21387,
+    }
+};
+
+const int16_t ff_vp9_ac_qlookup[3][256] = {
+    {
+            4,     8,     9,    10,    11,    12,    13,    14,
+           15,    16,    17,    18,    19,    20,    21,    22,
+           23,    24,    25,    26,    27,    28,    29,    30,
+           31,    32,    33,    34,    35,    36,    37,    38,
+           39,    40,    41,    42,    43,    44,    45,    46,
+           47,    48,    49,    50,    51,    52,    53,    54,
+           55,    56,    57,    58,    59,    60,    61,    62,
+           63,    64,    65,    66,    67,    68,    69,    70,
+           71,    72,    73,    74,    75,    76,    77,    78,
+           79,    80,    81,    82,    83,    84,    85,    86,
+           87,    88,    89,    90,    91,    92,    93,    94,
+           95,    96,    97,    98,    99,   100,   101,   102,
+          104,   106,   108,   110,   112,   114,   116,   118,
+          120,   122,   124,   126,   128,   130,   132,   134,
+          136,   138,   140,   142,   144,   146,   148,   150,
+          152,   155,   158,   161,   164,   167,   170,   173,
+          176,   179,   182,   185,   188,   191,   194,   197,
+          200,   203,   207,   211,   215,   219,   223,   227,
+          231,   235,   239,   243,   247,   251,   255,   260,
+          265,   270,   275,   280,   285,   290,   295,   300,
+          305,   311,   317,   323,   329,   335,   341,   347,
+          353,   359,   366,   373,   380,   387,   394,   401,
+          408,   416,   424,   432,   440,   448,   456,   465,
+          474,   483,   492,   501,   510,   520,   530,   540,
+          550,   560,   571,   582,   593,   604,   615,   627,
+          639,   651,   663,   676,   689,   702,   715,   729,
+          743,   757,   771,   786,   801,   816,   832,   848,
+          864,   881,   898,   915,   933,   951,   969,   988,
+         1007,  1026,  1046,  1066,  1087,  1108,  1129,  1151,
+         1173,  1196,  1219,  1243,  1267,  1292,  1317,  1343,
+         1369,  1396,  1423,  1451,  1479,  1508,  1537,  1567,
+         1597,  1628,  1660,  1692,  1725,  1759,  1793,  1828,
+    }, {
+            4,     9,    11,    13,    16,    18,    21,    24,
+           27,    30,    33,    37,    40,    44,    48,    51,
+           55,    59,    63,    67,    71,    75,    79,    83,
+           88,    92,    96,   100,   105,   109,   114,   118,
+          122,   127,   131,   136,   140,   145,   149,   154,
+          158,   163,   168,   172,   177,   181,   186,   190,
+          195,   199,   204,   208,   213,   217,   222,   226,
+          231,   235,   240,   244,   249,   253,   258,   262,
+          267,   271,   275,   280,   284,   289,   293,   297,
+          302,   306,   311,   315,   319,   324,   328,   332,
+          337,   341,   345,   349,   354,   358,   362,   367,
+          371,   375,   379,   384,   388,   392,   396,   401,
+          409,   417,   425,   433,   441,   449,   458,   466,
+          474,   482,   490,   498,   506,   514,   523,   531,
+          539,   547,   555,   563,   571,   579,   588,   596,
+          604,   616,   628,   640,   652,   664,   676,   688,
+          700,   713,   725,   737,   749,   761,   773,   785,
+          797,   809,   825,   841,   857,   873,   889,   905,
+          922,   938,   954,   970,   986,  1002,  1018,  1038,
+         1058,  1078,  1098,  1118,  1138,  1158,  1178,  1198,
+         1218,  1242,  1266,  1290,  1314,  1338,  1362,  1386,
+         1411,  1435,  1463,  1491,  1519,  1547,  1575,  1603,
+         1631,  1663,  1695,  1727,  1759,  1791,  1823,  1859,
+         1895,  1931,  1967,  2003,  2039,  2079,  2119,  2159,
+         2199,  2239,  2283,  2327,  2371,  2415,  2459,  2507,
+         2555,  2603,  2651,  2703,  2755,  2807,  2859,  2915,
+         2971,  3027,  3083,  3143,  3203,  3263,  3327,  3391,
+         3455,  3523,  3591,  3659,  3731,  3803,  3876,  3952,
+         4028,  4104,  4184,  4264,  4348,  4432,  4516,  4604,
+         4692,  4784,  4876,  4972,  5068,  5168,  5268,  5372,
+         5476,  5584,  5692,  5804,  5916,  6032,  6148,  6268,
+         6388,  6512,  6640,  6768,  6900,  7036,  7172,  7312,
+    }, {
+            4,    13,    19,    27,    35,    44,    54,    64,
+           75,    87,    99,   112,   126,   139,   154,   168,
+          183,   199,   214,   230,   247,   263,   280,   297,
+          314,   331,   349,   366,   384,   402,   420,   438,
+          456,   475,   493,   511,   530,   548,   567,   586,
+          604,   623,   642,   660,   679,   698,   716,   735,
+          753,   772,   791,   809,   828,   846,   865,   884,
+          902,   920,   939,   957,   976,   994,  1012,  1030,
+         1049,  1067,  1085,  1103,  1121,  1139,  1157,  1175,
+         1193,  1211,  1229,  1246,  1264,  1282,  1299,  1317,
+         1335,  1352,  1370,  1387,  1405,  1422,  1440,  1457,
+         1474,  1491,  1509,  1526,  1543,  1560,  1577,  1595,
+         1627,  1660,  1693,  1725,  1758,  1791,  1824,  1856,
+         1889,  1922,  1954,  1987,  2020,  2052,  2085,  2118,
+         2150,  2183,  2216,  2248,  2281,  2313,  2346,  2378,
+         2411,  2459,  2508,  2556,  2605,  2653,  2701,  2750,
+         2798,  2847,  2895,  2943,  2992,  3040,  3088,  3137,
+         3185,  3234,  3298,  3362,  3426,  3491,  3555,  3619,
+         3684,  3748,  3812,  3876,  3941,  4005,  4069,  4149,
+         4230,  4310,  4390,  4470,  4550,  4631,  4711,  4791,
+         4871,  4967,  5064,  5160,  5256,  5352,  5448,  5544,
+         5641,  5737,  5849,  5961,  6073,  6185,  6297,  6410,
+         6522,  6650,  6778,  6906,  7034,  7162,  7290,  7435,
+         7579,  7723,  7867,  8011,  8155,  8315,  8475,  8635,
+         8795,  8956,  9132,  9308,  9484,  9660,  9836, 10028,
+        10220, 10412, 10604, 10812, 11020, 11228, 11437, 11661,
+        11885, 12109, 12333, 12573, 12813, 13053, 13309, 13565,
+        13821, 14093, 14365, 14637, 14925, 15213, 15502, 15806,
+        16110, 16414, 16734, 17054, 17390, 17726, 18062, 18414,
+        18766, 19134, 19502, 19886, 20270, 20670, 21070, 21486,
+        21902, 22334, 22766, 23214, 23662, 24126, 24590, 25070,
+        25551, 26047, 26559, 27071, 27599, 28143, 28687, 29247,
+    }
+};
+
+const enum TxfmType ff_vp9_intra_txfm_type[14] = {
+    [VERT_PRED]            = ADST_DCT,
+    [HOR_PRED]             = DCT_ADST,
+    [DC_PRED]              = DCT_DCT,
+    [DIAG_DOWN_LEFT_PRED]  = DCT_DCT,
+    [DIAG_DOWN_RIGHT_PRED] = ADST_ADST,
+    [VERT_RIGHT_PRED]      = ADST_DCT,
+    [HOR_DOWN_PRED]        = DCT_ADST,
+    [VERT_LEFT_PRED]       = ADST_DCT,
+    [HOR_UP_PRED]          = DCT_ADST,
+    [TM_VP8_PRED]          = ADST_ADST,
+    [NEARESTMV]            = DCT_DCT,
+    [NEARMV]               = DCT_DCT,
+    [ZEROMV]               = DCT_DCT,
+    [NEWMV]                = DCT_DCT,
+};
+
+const int16_t ff_vp9_default_scan_4x4[16] = {
+     0,  1,  4,  5,
+     2,  8,  3,  6,
+    12,  9,  7, 10,
+    13, 11, 14, 15,
+};
+
+const int16_t ff_vp9_col_scan_4x4[16] = {
+     0,  1,  2,  4,
+     3,  5,  6,  8,
+     7,  9, 10, 12,
+    13, 11, 14, 15,
+};
+
+const int16_t ff_vp9_row_scan_4x4[16] = {
+     0,  4,  1,  8,
+     5, 12,  9,  2,
+     6, 13,  3, 10,
+     7, 14, 11, 15,
+};
+
+const int16_t ff_vp9_default_scan_8x8[64] = {
+     0,  1,  8,  2,  9, 16, 10,  3,
+    17, 24, 18, 11,  4, 25, 32, 19,
+    12, 26,  5, 33, 20, 27, 40, 13,
+    34,  6, 41, 28, 21, 35, 42, 48,
+    14,  7, 36, 29, 43, 56, 49, 22,
+    15, 37, 50, 44, 57, 30, 23, 51,
+    45, 58, 38, 31, 52, 59, 39, 46,
+    53, 60, 47, 54, 61, 55, 62, 63,
+};
+
+const int16_t ff_vp9_col_scan_8x8[64] = {
+     0,  1,  2,  8,  3,  9,  4, 10,
+    16,  5, 11, 17, 12, 18,  6, 24,
+    19, 13, 25,  7, 26, 20, 32, 14,
+    27, 21, 33, 28, 34, 15, 22, 35,
+    40, 29, 41, 36, 23, 30, 42, 37,
+    48, 43, 31, 44, 49, 38, 50, 56,
+    45, 39, 51, 57, 52, 46, 58, 53,
+    59, 47, 60, 54, 61, 55, 62, 63,
+};
+
+const int16_t ff_vp9_row_scan_8x8[64] = {
+     0,  8, 16,  1,  9, 24,  2, 17,
+    32, 10, 25,  3, 40, 18, 11, 33,
+    26, 19,  4, 48, 41, 34, 12, 27,
+    56, 20,  5, 42, 35, 13, 49, 28,
+     6, 21, 43, 36, 14, 50, 29, 57,
+     7, 44, 22, 37, 51, 15, 58, 30,
+    23, 45, 52, 38, 59, 31, 46, 53,
+    39, 60, 47, 61, 54, 62, 55, 63,
+};
+
+const int16_t ff_vp9_default_scan_16x16[256] = {
+      0,   1,  16,   2,  17,  32,   3,  18,  33,  48,   4,  34,  19,  49,  20,   5,
+     35,  64,  50,  36,  65,  21,   6,  51,  80,  66,  37,  22,  52,   7,  81,  67,
+     38,  82,  53,  23,  96,  68,   8,  83,  97,  54,  39,  69, 112,  24,  98,  84,
+     70,  55,   9,  40,  85,  99, 113, 128,  25, 114, 100,  71,  86,  56,  10,  41,
+    115, 101, 129, 116,  72,  87,  26, 130, 144, 102,  57,  11,  42, 117, 131, 145,
+     88, 103,  27,  73, 132, 118, 146,  58, 160,  12,  43, 133, 147, 104,  89, 119,
+    161,  74, 148, 134,  28, 162,  59,  13, 176, 120, 149,  90, 135, 105, 163,  44,
+     75, 177, 164,  29, 150, 121, 136, 178, 165,  14, 106,  60,  91, 151,  45, 179,
+    192, 137, 166, 122,  76, 180, 152,  30,  61,  15, 107, 167, 181, 193,  92, 208,
+     46, 138, 123, 153, 194,  77, 168, 182,  31, 195, 209, 183, 108, 139,  62, 154,
+     47, 196,  93, 169, 210, 197, 224, 124, 184, 211,  78, 109, 170, 155,  63, 198,
+    212, 185, 225, 240, 140,  94, 199, 125,  79, 213, 226, 171, 186, 156, 214, 200,
+    110, 227, 141,  95, 241, 215, 228, 201, 126, 242, 187, 172, 157, 229, 111, 216,
+    243, 142, 202, 230, 127, 217, 244, 173, 188, 231, 158, 203, 143, 245, 218, 232,
+    189, 246, 159, 174, 233, 247, 219, 204, 175, 190, 248, 234, 205, 220, 249, 191,
+    235, 221, 250, 206, 222, 251, 236, 207, 237, 223, 252, 238, 253, 239, 254, 255,
+};
+
+const int16_t ff_vp9_col_scan_16x16[256] = {
+      0,   1,   2,   3,  16,   4,  17,   5,  18,   6,  19,  32,  20,   7,  33,  21,
+     34,   8,  35,  22,  48,  36,   9,  49,  23,  50,  37,  10,  38,  51,  24,  64,
+     52,  11,  65,  39,  25,  53,  66,  54,  40,  67,  12,  80,  26,  68,  55,  81,
+     41,  69,  13,  27,  82,  56,  70,  83,  42,  14,  84,  96,  71,  28,  57,  85,
+     97,  15,  72,  98,  43,  86,  58,  99,  29,  87, 100, 112,  73,  44, 101,  59,
+     30, 113,  88, 114,  74, 128, 102,  45,  31, 115,  60, 103,  89, 116,  75, 129,
+    117,  46, 104,  90,  61, 130, 118, 131, 132, 105,  76,  47, 119, 144,  91,  62,
+    133, 106, 145, 120, 146, 134,  77, 147, 121,  92, 135, 148,  63, 107, 136, 122,
+     93, 149, 160,  78, 150, 137, 108, 161, 162, 151, 123,  79, 138, 163, 152,  94,
+    164, 109, 165, 153, 124, 139, 176, 166,  95, 177, 167, 110, 154, 178, 125, 179,
+    140, 168, 155, 111, 180, 192, 181, 169, 141, 126, 182, 193, 194, 156, 183, 170,
+    195, 127, 142, 196, 184, 208, 197, 157, 171, 143, 185, 198, 209, 199, 210, 172,
+    158, 186, 211, 224, 212, 200, 240, 159, 213, 225, 187, 201, 173, 226, 214, 215,
+    227, 202, 228, 188, 241, 216, 174, 229, 242, 203, 243, 217, 230, 175, 189, 244,
+    231, 204, 218, 232, 245, 219, 246, 190, 233, 205, 191, 247, 234, 248, 220, 206,
+    249, 235, 221, 207, 250, 236, 222, 251, 223, 237, 238, 252, 239, 253, 254, 255,
+};
+
+const int16_t ff_vp9_row_scan_16x16[256] = {
+      0,  16,  32,   1,  48,  17,  64,  33,   2,  80,  18,  49,  96,  34,   3,  65,
+     19, 112,  50,  81,  35,   4, 128,  66,  20,  97,  51,  82,   5, 144,  36,  67,
+    113,  98,  21,  52, 160,  83, 129,  37,  68,   6, 114, 176,  99,  53,  22,  84,
+    145,  38,  69, 130,   7, 115, 192, 100,  54,  23,  85, 161, 146, 131,  39,  70,
+    208, 116,   8, 101, 177,  55,  86,  24, 162, 147, 132,  71, 224, 117,  40, 102,
+      9, 148,  56,  87, 193, 163, 240, 133, 178,  25, 118,  72,  41, 103, 164,  10,
+    149,  88, 134, 209, 179,  57, 119, 194,  26,  73, 165, 150, 104,  42, 135,  11,
+    180, 120,  89, 225, 195,  58,  27, 210, 151, 181, 166,  74,  43, 105,  12, 136,
+     90,  59, 241, 121,  28, 196, 167, 211, 152,  44, 182, 137,  75,  13, 226, 106,
+    122,  60, 197,  91, 168,  29, 183, 153,  14,  76, 212, 138,  45, 107,  15, 198,
+     92, 227, 169,  30, 123, 154,  61, 242, 184, 213, 139,  46,  77,  31, 108, 170,
+    199, 185, 124, 228,  93, 155, 214,  62, 140, 243,  78,  47, 200, 109, 186, 171,
+    201,  94,  63, 215, 229, 156,  79, 125, 141, 110, 216, 187, 172, 244, 202, 230,
+    217,  95, 157, 126, 245, 111, 142, 231, 188, 127, 158, 218, 173, 232, 246, 233,
+    203, 143, 247, 174, 189, 159, 219, 204, 248, 234, 249, 175, 190, 220, 205, 250,
+    235, 191, 221, 251, 236, 206, 252, 222, 207, 237, 223, 253, 238, 254, 239, 255,
+};
+
+const int16_t ff_vp9_default_scan_32x32[1024] = {
+       0,    1,   32,    2,   33,   64,    3,   34,   65,    4,   96,   35,   66,    5,   36,   97,   67,  128,   98,   68,   37,    6,  129,   99,    7,  160,   69,   38,  130,  100,  161,  131,
+      39,   70,    8,  101,  162,  132,  192,   71,   40,    9,  102,  163,  133,  193,   72,  224,  103,   41,  164,   10,  194,  134,  165,   73,  104,  135,  225,   42,  195,   11,  256,  166,
+     226,  196,   74,  105,  136,   43,   12,  167,  197,  227,  257,   75,  106,  137,  228,   44,  198,  168,  258,  288,   13,  229,   76,  107,  199,  138,  259,  169,  289,   45,  230,  260,
+     200,  108,   14,  170,  139,  320,  290,   77,  231,  261,   46,  201,  140,  291,  109,  232,  321,  262,  171,   78,  292,   15,  322,  202,  263,  352,  172,  293,  233,  141,  323,  110,
+      47,  203,  264,  234,  294,  353,  324,   16,   79,  204,  265,  295,  325,  173,  354,  142,  235,  384,   48,  296,  111,  266,  355,  326,   80,   17,  205,  236,  174,  356,  385,  327,
+     143,  297,  267,  357,  386,  112,   49,  328,  298,  206,  416,  237,  358,  387,   81,  175,   18,  329,  359,  388,  299,  330,  389,  113,  417,  238,  360,   50,  207,  418,  390,  331,
+      19,  448,  361,   82,  419,  391,  239,   51,  362,  420,  114,  449,  480,  421,   83,  363,  450,  422,  512,  451,  423,  115,  452,  481,  453,  482,  454,  544,  483,  455,  513,  484,
+     514,  485,  515,  486,  545,  576,  487,  546,  547,  608,  577,  578,  579,  609,  610,  611,   20,  144,  268,  392,  516,  640,   21,   52,  145,  176,  269,  300,  393,  424,  517,  548,
+     641,  672,   22,   53,   84,  146,  177,  208,  270,  301,  332,  394,  425,  456,  518,  549,  580,  642,  673,  704,   23,   54,   85,  116,  147,  178,  209,  240,  271,  302,  333,  364,
+     395,  426,  457,  488,  519,  550,  581,  612,  643,  674,  705,  736,   55,   86,  117,  179,  210,  241,  303,  334,  365,  427,  458,  489,  551,  582,  613,  675,  706,  737,   87,  118,
+     211,  242,  335,  366,  459,  490,  583,  614,  707,  738,  119,  243,  367,  491,  615,  739,   24,  148,  272,  396,  520,  644,  768,   25,   56,  149,  180,  273,  304,  397,  428,  521,
+     552,  645,  676,  769,  800,   26,   57,   88,  150,  181,  212,  274,  305,  336,  398,  429,  460,  522,  553,  584,  646,  677,  708,  770,  801,  832,   27,   58,   89,  120,  151,  182,
+     213,  244,  275,  306,  337,  368,  399,  430,  461,  492,  523,  554,  585,  616,  647,  678,  709,  740,  771,  802,  833,  864,   59,   90,  121,  183,  214,  245,  307,  338,  369,  431,
+     462,  493,  555,  586,  617,  679,  710,  741,  803,  834,  865,   91,  122,  215,  246,  339,  370,  463,  494,  587,  618,  711,  742,  835,  866,  123,  247,  371,  495,  619,  743,  867,
+      28,  152,  276,  400,  524,  648,  772,  896,   29,   60,  153,  184,  277,  308,  401,  432,  525,  556,  649,  680,  773,  804,  897,  928,   30,   61,   92,  154,  185,  216,  278,  309,
+     340,  402,  433,  464,  526,  557,  588,  650,  681,  712,  774,  805,  836,  898,  929,  960,   31,   62,   93,  124,  155,  186,  217,  248,  279,  310,  341,  372,  403,  434,  465,  496,
+     527,  558,  589,  620,  651,  682,  713,  744,  775,  806,  837,  868,  899,  930,  961,  992,   63,   94,  125,  187,  218,  249,  311,  342,  373,  435,  466,  497,  559,  590,  621,  683,
+     714,  745,  807,  838,  869,  931,  962,  993,   95,  126,  219,  250,  343,  374,  467,  498,  591,  622,  715,  746,  839,  870,  963,  994,  127,  251,  375,  499,  623,  747,  871,  995,
+     156,  280,  404,  528,  652,  776,  900,  157,  188,  281,  312,  405,  436,  529,  560,  653,  684,  777,  808,  901,  932,  158,  189,  220,  282,  313,  344,  406,  437,  468,  530,  561,
+     592,  654,  685,  716,  778,  809,  840,  902,  933,  964,  159,  190,  221,  252,  283,  314,  345,  376,  407,  438,  469,  500,  531,  562,  593,  624,  655,  686,  717,  748,  779,  810,
+     841,  872,  903,  934,  965,  996,  191,  222,  253,  315,  346,  377,  439,  470,  501,  563,  594,  625,  687,  718,  749,  811,  842,  873,  935,  966,  997,  223,  254,  347,  378,  471,
+     502,  595,  626,  719,  750,  843,  874,  967,  998,  255,  379,  503,  627,  751,  875,  999,  284,  408,  532,  656,  780,  904,  285,  316,  409,  440,  533,  564,  657,  688,  781,  812,
+     905,  936,  286,  317,  348,  410,  441,  472,  534,  565,  596,  658,  689,  720,  782,  813,  844,  906,  937,  968,  287,  318,  349,  380,  411,  442,  473,  504,  535,  566,  597,  628,
+     659,  690,  721,  752,  783,  814,  845,  876,  907,  938,  969, 1000,  319,  350,  381,  443,  474,  505,  567,  598,  629,  691,  722,  753,  815,  846,  877,  939,  970, 1001,  351,  382,
+     475,  506,  599,  630,  723,  754,  847,  878,  971, 1002,  383,  507,  631,  755,  879, 1003,  412,  536,  660,  784,  908,  413,  444,  537,  568,  661,  692,  785,  816,  909,  940,  414,
+     445,  476,  538,  569,  600,  662,  693,  724,  786,  817,  848,  910,  941,  972,  415,  446,  477,  508,  539,  570,  601,  632,  663,  694,  725,  756,  787,  818,  849,  880,  911,  942,
+     973, 1004,  447,  478,  509,  571,  602,  633,  695,  726,  757,  819,  850,  881,  943,  974, 1005,  479,  510,  603,  634,  727,  758,  851,  882,  975, 1006,  511,  635,  759,  883, 1007,
+     540,  664,  788,  912,  541,  572,  665,  696,  789,  820,  913,  944,  542,  573,  604,  666,  697,  728,  790,  821,  852,  914,  945,  976,  543,  574,  605,  636,  667,  698,  729,  760,
+     791,  822,  853,  884,  915,  946,  977, 1008,  575,  606,  637,  699,  730,  761,  823,  854,  885,  947,  978, 1009,  607,  638,  731,  762,  855,  886,  979, 1010,  639,  763,  887, 1011,
+     668,  792,  916,  669,  700,  793,  824,  917,  948,  670,  701,  732,  794,  825,  856,  918,  949,  980,  671,  702,  733,  764,  795,  826,  857,  888,  919,  950,  981, 1012,  703,  734,
+     765,  827,  858,  889,  951,  982, 1013,  735,  766,  859,  890,  983, 1014,  767,  891, 1015,  796,  920,  797,  828,  921,  952,  798,  829,  860,  922,  953,  984,  799,  830,  861,  892,
+     923,  954,  985, 1016,  831,  862,  893,  955,  986, 1017,  863,  894,  987, 1018,  895, 1019,  924,  925,  956,  926,  957,  988,  927,  958,  989, 1020,  959,  990, 1021,  991, 1022, 1023,
+};
+
+const int16_t * const ff_vp9_scans[5][4] = {
+    {
+        ff_vp9_default_scan_4x4, ff_vp9_col_scan_4x4,
+        ff_vp9_row_scan_4x4, ff_vp9_default_scan_4x4
+    }, {
+        ff_vp9_default_scan_8x8, ff_vp9_col_scan_8x8,
+        ff_vp9_row_scan_8x8, ff_vp9_default_scan_8x8
+    }, {
+        ff_vp9_default_scan_16x16, ff_vp9_col_scan_16x16,
+        ff_vp9_row_scan_16x16, ff_vp9_default_scan_16x16
+    }, {
+        ff_vp9_default_scan_32x32, ff_vp9_default_scan_32x32,
+        ff_vp9_default_scan_32x32, ff_vp9_default_scan_32x32
+    }, { // lossless
+        ff_vp9_default_scan_4x4, ff_vp9_default_scan_4x4,
+        ff_vp9_default_scan_4x4, ff_vp9_default_scan_4x4
+    }
+};
+
+const int16_t ff_vp9_default_scan_4x4_nb[16][2] = {
+    {  0,  0 }, {  0,  0 }, {  4,  1 }, {  1,  1 },
+    {  4,  4 }, {  2,  2 }, {  5,  2 }, {  8,  8 },
+    {  8,  5 }, {  6,  3 }, {  9,  6 }, { 12,  9 },
+    { 10,  7 }, { 13, 10 }, { 14, 11 }, {  0,  0 },
+};
+
+const int16_t ff_vp9_col_scan_4x4_nb[16][2] = {
+    {  0,  0 }, {  1,  1 }, {  0,  0 }, {  2,  2 },
+    {  4,  4 }, {  5,  5 }, {  4,  4 }, {  6,  6 },
+    {  8,  8 }, {  9,  9 }, {  8,  8 }, { 12, 12 },
+    { 10, 10 }, { 13, 13 }, { 14, 14 }, {  0,  0 },
+};
+
+const int16_t ff_vp9_row_scan_4x4_nb[16][2] = {
+    {  0,  0 }, {  0,  0 }, {  4,  4 }, {  1,  1 },
+    {  8,  8 }, {  5,  5 }, {  1,  1 }, {  2,  2 },
+    {  9,  9 }, {  2,  2 }, {  6,  6 }, {  3,  3 },
+    { 10, 10 }, {  7,  7 }, { 11, 11 }, {  0,  0 },
+};
+
+const int16_t ff_vp9_default_scan_8x8_nb[64][2] = {
+    {  0,  0 }, {  0,  0 }, {  1,  1 }, {  8,  1 },
+    {  8,  8 }, {  9,  2 }, {  2,  2 }, { 16,  9 },
+    { 16, 16 }, { 17, 10 }, { 10,  3 }, {  3,  3 },
+    { 24, 17 }, { 24, 24 }, { 18, 11 }, { 11,  4 },
+    { 25, 18 }, {  4,  4 }, { 32, 25 }, { 19, 12 },
+    { 26, 19 }, { 32, 32 }, { 12,  5 }, { 33, 26 },
+    {  5,  5 }, { 40, 33 }, { 27, 20 }, { 20, 13 },
+    { 34, 27 }, { 41, 34 }, { 40, 40 }, { 13,  6 },
+    {  6,  6 }, { 35, 28 }, { 28, 21 }, { 42, 35 },
+    { 48, 48 }, { 48, 41 }, { 21, 14 }, { 14,  7 },
+    { 36, 29 }, { 49, 42 }, { 43, 36 }, { 56, 49 },
+    { 29, 22 }, { 22, 15 }, { 50, 43 }, { 44, 37 },
+    { 57, 50 }, { 37, 30 }, { 30, 23 }, { 51, 44 },
+    { 58, 51 }, { 38, 31 }, { 45, 38 }, { 52, 45 },
+    { 59, 52 }, { 46, 39 }, { 53, 46 }, { 60, 53 },
+    { 54, 47 }, { 61, 54 }, { 62, 55 }, {  0,  0 },
+};
+
+const int16_t ff_vp9_col_scan_8x8_nb[64][2] = {
+    {  0,  0 }, {  1,  1 }, {  0,  0 }, {  2,  2 },
+    {  8,  8 }, {  3,  3 }, {  9,  9 }, {  8,  8 },
+    {  4,  4 }, { 10, 10 }, { 16, 16 }, { 11, 11 },
+    { 17, 17 }, {  5,  5 }, { 16, 16 }, { 18, 18 },
+    { 12, 12 }, { 24, 24 }, {  6,  6 }, { 25, 25 },
+    { 19, 19 }, { 24, 24 }, { 13, 13 }, { 26, 26 },
+    { 20, 20 }, { 32, 32 }, { 27, 27 }, { 33, 33 },
+    { 14, 14 }, { 21, 21 }, { 34, 34 }, { 32, 32 },
+    { 28, 28 }, { 40, 40 }, { 35, 35 }, { 22, 22 },
+    { 29, 29 }, { 41, 41 }, { 36, 36 }, { 40, 40 },
+    { 42, 42 }, { 30, 30 }, { 43, 43 }, { 48, 48 },
+    { 37, 37 }, { 49, 49 }, { 48, 48 }, { 44, 44 },
+    { 38, 38 }, { 50, 50 }, { 56, 56 }, { 51, 51 },
+    { 45, 45 }, { 57, 57 }, { 52, 52 }, { 58, 58 },
+    { 46, 46 }, { 59, 59 }, { 53, 53 }, { 60, 60 },
+    { 54, 54 }, { 61, 61 }, { 62, 62 }, {  0,  0 },
+};
+
+const int16_t ff_vp9_row_scan_8x8_nb[64][2] = {
+    {  0,  0 }, {  8,  8 }, {  0,  0 }, {  1,  1 },
+    { 16, 16 }, {  1,  1 }, {  9,  9 }, { 24, 24 },
+    {  2,  2 }, { 17, 17 }, {  2,  2 }, { 32, 32 },
+    { 10, 10 }, {  3,  3 }, { 25, 25 }, { 18, 18 },
+    { 11, 11 }, {  3,  3 }, { 40, 40 }, { 33, 33 },
+    { 26, 26 }, {  4,  4 }, { 19, 19 }, { 48, 48 },
+    { 12, 12 }, {  4,  4 }, { 34, 34 }, { 27, 27 },
+    {  5,  5 }, { 41, 41 }, { 20, 20 }, {  5,  5 },
+    { 13, 13 }, { 35, 35 }, { 28, 28 }, {  6,  6 },
+    { 42, 42 }, { 21, 21 }, { 49, 49 }, {  6,  6 },
+    { 36, 36 }, { 14, 14 }, { 29, 29 }, { 43, 43 },
+    {  7,  7 }, { 50, 50 }, { 22, 22 }, { 15, 15 },
+    { 37, 37 }, { 44, 44 }, { 30, 30 }, { 51, 51 },
+    { 23, 23 }, { 38, 38 }, { 45, 45 }, { 31, 31 },
+    { 52, 52 }, { 39, 39 }, { 53, 53 }, { 46, 46 },
+    { 54, 54 }, { 47, 47 }, { 55, 55 }, {  0,  0 },
+};
+
+const int16_t ff_vp9_default_scan_16x16_nb[256][2] = {
+    {   0,   0 }, {   0,   0 }, {   1,   1 }, {  16,   1 },
+    {  16,  16 }, {   2,   2 }, {  17,   2 }, {  32,  17 },
+    {  32,  32 }, {   3,   3 }, {  33,  18 }, {  18,   3 },
+    {  48,  33 }, {  19,   4 }, {   4,   4 }, {  34,  19 },
+    {  48,  48 }, {  49,  34 }, {  35,  20 }, {  64,  49 },
+    {  20,   5 }, {   5,   5 }, {  50,  35 }, {  64,  64 },
+    {  65,  50 }, {  36,  21 }, {  21,   6 }, {  51,  36 },
+    {   6,   6 }, {  80,  65 }, {  66,  51 }, {  37,  22 },
+    {  81,  66 }, {  52,  37 }, {  22,   7 }, {  80,  80 },
+    {  67,  52 }, {   7,   7 }, {  82,  67 }, {  96,  81 },
+    {  53,  38 }, {  38,  23 }, {  68,  53 }, {  96,  96 },
+    {  23,   8 }, {  97,  82 }, {  83,  68 }, {  69,  54 },
+    {  54,  39 }, {   8,   8 }, {  39,  24 }, {  84,  69 },
+    {  98,  83 }, { 112,  97 }, { 112, 112 }, {  24,   9 },
+    { 113,  98 }, {  99,  84 }, {  70,  55 }, {  85,  70 },
+    {  55,  40 }, {   9,   9 }, {  40,  25 }, { 114,  99 },
+    { 100,  85 }, { 128, 113 }, { 115, 100 }, {  71,  56 },
+    {  86,  71 }, {  25,  10 }, { 129, 114 }, { 128, 128 },
+    { 101,  86 }, {  56,  41 }, {  10,  10 }, {  41,  26 },
+    { 116, 101 }, { 130, 115 }, { 144, 129 }, {  87,  72 },
+    { 102,  87 }, {  26,  11 }, {  72,  57 }, { 131, 116 },
+    { 117, 102 }, { 145, 130 }, {  57,  42 }, { 144, 144 },
+    {  11,  11 }, {  42,  27 }, { 132, 117 }, { 146, 131 },
+    { 103,  88 }, {  88,  73 }, { 118, 103 }, { 160, 145 },
+    {  73,  58 }, { 147, 132 }, { 133, 118 }, {  27,  12 },
+    { 161, 146 }, {  58,  43 }, {  12,  12 }, { 160, 160 },
+    { 119, 104 }, { 148, 133 }, {  89,  74 }, { 134, 119 },
+    { 104,  89 }, { 162, 147 }, {  43,  28 }, {  74,  59 },
+    { 176, 161 }, { 163, 148 }, {  28,  13 }, { 149, 134 },
+    { 120, 105 }, { 135, 120 }, { 177, 162 }, { 164, 149 },
+    {  13,  13 }, { 105,  90 }, {  59,  44 }, {  90,  75 },
+    { 150, 135 }, {  44,  29 }, { 178, 163 }, { 176, 176 },
+    { 136, 121 }, { 165, 150 }, { 121, 106 }, {  75,  60 },
+    { 179, 164 }, { 151, 136 }, {  29,  14 }, {  60,  45 },
+    {  14,  14 }, { 106,  91 }, { 166, 151 }, { 180, 165 },
+    { 192, 177 }, {  91,  76 }, { 192, 192 }, {  45,  30 },
+    { 137, 122 }, { 122, 107 }, { 152, 137 }, { 193, 178 },
+    {  76,  61 }, { 167, 152 }, { 181, 166 }, {  30,  15 },
+    { 194, 179 }, { 208, 193 }, { 182, 167 }, { 107,  92 },
+    { 138, 123 }, {  61,  46 }, { 153, 138 }, {  46,  31 },
+    { 195, 180 }, {  92,  77 }, { 168, 153 }, { 209, 194 },
+    { 196, 181 }, { 208, 208 }, { 123, 108 }, { 183, 168 },
+    { 210, 195 }, {  77,  62 }, { 108,  93 }, { 169, 154 },
+    { 154, 139 }, {  62,  47 }, { 197, 182 }, { 211, 196 },
+    { 184, 169 }, { 224, 209 }, { 224, 224 }, { 139, 124 },
+    {  93,  78 }, { 198, 183 }, { 124, 109 }, {  78,  63 },
+    { 212, 197 }, { 225, 210 }, { 170, 155 }, { 185, 170 },
+    { 155, 140 }, { 213, 198 }, { 199, 184 }, { 109,  94 },
+    { 226, 211 }, { 140, 125 }, {  94,  79 }, { 240, 225 },
+    { 214, 199 }, { 227, 212 }, { 200, 185 }, { 125, 110 },
+    { 241, 226 }, { 186, 171 }, { 171, 156 }, { 156, 141 },
+    { 228, 213 }, { 110,  95 }, { 215, 200 }, { 242, 227 },
+    { 141, 126 }, { 201, 186 }, { 229, 214 }, { 126, 111 },
+    { 216, 201 }, { 243, 228 }, { 172, 157 }, { 187, 172 },
+    { 230, 215 }, { 157, 142 }, { 202, 187 }, { 142, 127 },
+    { 244, 229 }, { 217, 202 }, { 231, 216 }, { 188, 173 },
+    { 245, 230 }, { 158, 143 }, { 173, 158 }, { 232, 217 },
+    { 246, 231 }, { 218, 203 }, { 203, 188 }, { 174, 159 },
+    { 189, 174 }, { 247, 232 }, { 233, 218 }, { 204, 189 },
+    { 219, 204 }, { 248, 233 }, { 190, 175 }, { 234, 219 },
+    { 220, 205 }, { 249, 234 }, { 205, 190 }, { 221, 206 },
+    { 250, 235 }, { 235, 220 }, { 206, 191 }, { 236, 221 },
+    { 222, 207 }, { 251, 236 }, { 237, 222 }, { 252, 237 },
+    { 238, 223 }, { 253, 238 }, { 254, 239 }, {   0,   0 },
+};
+
+const int16_t ff_vp9_col_scan_16x16_nb[256][2] = {
+    {   0,   0 }, {   1,   1 }, {   2,   2 }, {   0,   0 },
+    {   3,   3 }, {  16,  16 }, {   4,   4 }, {  17,  17 },
+    {   5,   5 }, {  18,  18 }, {  16,  16 }, {  19,  19 },
+    {   6,   6 }, {  32,  32 }, {  20,  20 }, {  33,  33 },
+    {   7,   7 }, {  34,  34 }, {  21,  21 }, {  32,  32 },
+    {  35,  35 }, {   8,   8 }, {  48,  48 }, {  22,  22 },
+    {  49,  49 }, {  36,  36 }, {   9,   9 }, {  37,  37 },
+    {  50,  50 }, {  23,  23 }, {  48,  48 }, {  51,  51 },
+    {  10,  10 }, {  64,  64 }, {  38,  38 }, {  24,  24 },
+    {  52,  52 }, {  65,  65 }, {  53,  53 }, {  39,  39 },
+    {  66,  66 }, {  11,  11 }, {  64,  64 }, {  25,  25 },
+    {  67,  67 }, {  54,  54 }, {  80,  80 }, {  40,  40 },
+    {  68,  68 }, {  12,  12 }, {  26,  26 }, {  81,  81 },
+    {  55,  55 }, {  69,  69 }, {  82,  82 }, {  41,  41 },
+    {  13,  13 }, {  83,  83 }, {  80,  80 }, {  70,  70 },
+    {  27,  27 }, {  56,  56 }, {  84,  84 }, {  96,  96 },
+    {  14,  14 }, {  71,  71 }, {  97,  97 }, {  42,  42 },
+    {  85,  85 }, {  57,  57 }, {  98,  98 }, {  28,  28 },
+    {  86,  86 }, {  99,  99 }, {  96,  96 }, {  72,  72 },
+    {  43,  43 }, { 100, 100 }, {  58,  58 }, {  29,  29 },
+    { 112, 112 }, {  87,  87 }, { 113, 113 }, {  73,  73 },
+    { 112, 112 }, { 101, 101 }, {  44,  44 }, {  30,  30 },
+    { 114, 114 }, {  59,  59 }, { 102, 102 }, {  88,  88 },
+    { 115, 115 }, {  74,  74 }, { 128, 128 }, { 116, 116 },
+    {  45,  45 }, { 103, 103 }, {  89,  89 }, {  60,  60 },
+    { 129, 129 }, { 117, 117 }, { 130, 130 }, { 131, 131 },
+    { 104, 104 }, {  75,  75 }, {  46,  46 }, { 118, 118 },
+    { 128, 128 }, {  90,  90 }, {  61,  61 }, { 132, 132 },
+    { 105, 105 }, { 144, 144 }, { 119, 119 }, { 145, 145 },
+    { 133, 133 }, {  76,  76 }, { 146, 146 }, { 120, 120 },
+    {  91,  91 }, { 134, 134 }, { 147, 147 }, {  62,  62 },
+    { 106, 106 }, { 135, 135 }, { 121, 121 }, {  92,  92 },
+    { 148, 148 }, { 144, 144 }, {  77,  77 }, { 149, 149 },
+    { 136, 136 }, { 107, 107 }, { 160, 160 }, { 161, 161 },
+    { 150, 150 }, { 122, 122 }, {  78,  78 }, { 137, 137 },
+    { 162, 162 }, { 151, 151 }, {  93,  93 }, { 163, 163 },
+    { 108, 108 }, { 164, 164 }, { 152, 152 }, { 123, 123 },
+    { 138, 138 }, { 160, 160 }, { 165, 165 }, {  94,  94 },
+    { 176, 176 }, { 166, 166 }, { 109, 109 }, { 153, 153 },
+    { 177, 177 }, { 124, 124 }, { 178, 178 }, { 139, 139 },
+    { 167, 167 }, { 154, 154 }, { 110, 110 }, { 179, 179 },
+    { 176, 176 }, { 180, 180 }, { 168, 168 }, { 140, 140 },
+    { 125, 125 }, { 181, 181 }, { 192, 192 }, { 193, 193 },
+    { 155, 155 }, { 182, 182 }, { 169, 169 }, { 194, 194 },
+    { 126, 126 }, { 141, 141 }, { 195, 195 }, { 183, 183 },
+    { 192, 192 }, { 196, 196 }, { 156, 156 }, { 170, 170 },
+    { 142, 142 }, { 184, 184 }, { 197, 197 }, { 208, 208 },
+    { 198, 198 }, { 209, 209 }, { 171, 171 }, { 157, 157 },
+    { 185, 185 }, { 210, 210 }, { 208, 208 }, { 211, 211 },
+    { 199, 199 }, { 224, 224 }, { 158, 158 }, { 212, 212 },
+    { 224, 224 }, { 186, 186 }, { 200, 200 }, { 172, 172 },
+    { 225, 225 }, { 213, 213 }, { 214, 214 }, { 226, 226 },
+    { 201, 201 }, { 227, 227 }, { 187, 187 }, { 240, 240 },
+    { 215, 215 }, { 173, 173 }, { 228, 228 }, { 241, 241 },
+    { 202, 202 }, { 242, 242 }, { 216, 216 }, { 229, 229 },
+    { 174, 174 }, { 188, 188 }, { 243, 243 }, { 230, 230 },
+    { 203, 203 }, { 217, 217 }, { 231, 231 }, { 244, 244 },
+    { 218, 218 }, { 245, 245 }, { 189, 189 }, { 232, 232 },
+    { 204, 204 }, { 190, 190 }, { 246, 246 }, { 233, 233 },
+    { 247, 247 }, { 219, 219 }, { 205, 205 }, { 248, 248 },
+    { 234, 234 }, { 220, 220 }, { 206, 206 }, { 249, 249 },
+    { 235, 235 }, { 221, 221 }, { 250, 250 }, { 222, 222 },
+    { 236, 236 }, { 237, 237 }, { 251, 251 }, { 238, 238 },
+    { 252, 252 }, { 253, 253 }, { 254, 254 }, {   0,   0 },
+};
+
+const int16_t ff_vp9_row_scan_16x16_nb[256][2] = {
+    {   0,   0 }, {  16,  16 }, {   0,   0 }, {  32,  32 },
+    {   1,   1 }, {  48,  48 }, {  17,  17 }, {   1,   1 },
+    {  64,  64 }, {   2,   2 }, {  33,  33 }, {  80,  80 },
+    {  18,  18 }, {   2,   2 }, {  49,  49 }, {   3,   3 },
+    {  96,  96 }, {  34,  34 }, {  65,  65 }, {  19,  19 },
+    {   3,   3 }, { 112, 112 }, {  50,  50 }, {   4,   4 },
+    {  81,  81 }, {  35,  35 }, {  66,  66 }, {   4,   4 },
+    { 128, 128 }, {  20,  20 }, {  51,  51 }, {  97,  97 },
+    {  82,  82 }, {   5,   5 }, {  36,  36 }, { 144, 144 },
+    {  67,  67 }, { 113, 113 }, {  21,  21 }, {  52,  52 },
+    {   5,   5 }, {  98,  98 }, { 160, 160 }, {  83,  83 },
+    {  37,  37 }, {   6,   6 }, {  68,  68 }, { 129, 129 },
+    {  22,  22 }, {  53,  53 }, { 114, 114 }, {   6,   6 },
+    {  99,  99 }, { 176, 176 }, {  84,  84 }, {  38,  38 },
+    {   7,   7 }, {  69,  69 }, { 145, 145 }, { 130, 130 },
+    { 115, 115 }, {  23,  23 }, {  54,  54 }, { 192, 192 },
+    { 100, 100 }, {   7,   7 }, {  85,  85 }, { 161, 161 },
+    {  39,  39 }, {  70,  70 }, {   8,   8 }, { 146, 146 },
+    { 131, 131 }, { 116, 116 }, {  55,  55 }, { 208, 208 },
+    { 101, 101 }, {  24,  24 }, {  86,  86 }, {   8,   8 },
+    { 132, 132 }, {  40,  40 }, {  71,  71 }, { 177, 177 },
+    { 147, 147 }, { 224, 224 }, { 117, 117 }, { 162, 162 },
+    {   9,   9 }, { 102, 102 }, {  56,  56 }, {  25,  25 },
+    {  87,  87 }, { 148, 148 }, {   9,   9 }, { 133, 133 },
+    {  72,  72 }, { 118, 118 }, { 193, 193 }, { 163, 163 },
+    {  41,  41 }, { 103, 103 }, { 178, 178 }, {  10,  10 },
+    {  57,  57 }, { 149, 149 }, { 134, 134 }, {  88,  88 },
+    {  26,  26 }, { 119, 119 }, {  10,  10 }, { 164, 164 },
+    { 104, 104 }, {  73,  73 }, { 209, 209 }, { 179, 179 },
+    {  42,  42 }, {  11,  11 }, { 194, 194 }, { 135, 135 },
+    { 165, 165 }, { 150, 150 }, {  58,  58 }, {  27,  27 },
+    {  89,  89 }, {  11,  11 }, { 120, 120 }, {  74,  74 },
+    {  43,  43 }, { 225, 225 }, { 105, 105 }, {  12,  12 },
+    { 180, 180 }, { 151, 151 }, { 195, 195 }, { 136, 136 },
+    {  28,  28 }, { 166, 166 }, { 121, 121 }, {  59,  59 },
+    {  12,  12 }, { 210, 210 }, {  90,  90 }, { 106, 106 },
+    {  44,  44 }, { 181, 181 }, {  75,  75 }, { 152, 152 },
+    {  13,  13 }, { 167, 167 }, { 137, 137 }, {  13,  13 },
+    {  60,  60 }, { 196, 196 }, { 122, 122 }, {  29,  29 },
+    {  91,  91 }, {  14,  14 }, { 182, 182 }, {  76,  76 },
+    { 211, 211 }, { 153, 153 }, {  14,  14 }, { 107, 107 },
+    { 138, 138 }, {  45,  45 }, { 226, 226 }, { 168, 168 },
+    { 197, 197 }, { 123, 123 }, {  30,  30 }, {  61,  61 },
+    {  15,  15 }, {  92,  92 }, { 154, 154 }, { 183, 183 },
+    { 169, 169 }, { 108, 108 }, { 212, 212 }, {  77,  77 },
+    { 139, 139 }, { 198, 198 }, {  46,  46 }, { 124, 124 },
+    { 227, 227 }, {  62,  62 }, {  31,  31 }, { 184, 184 },
+    {  93,  93 }, { 170, 170 }, { 155, 155 }, { 185, 185 },
+    {  78,  78 }, {  47,  47 }, { 199, 199 }, { 213, 213 },
+    { 140, 140 }, {  63,  63 }, { 109, 109 }, { 125, 125 },
+    {  94,  94 }, { 200, 200 }, { 171, 171 }, { 156, 156 },
+    { 228, 228 }, { 186, 186 }, { 214, 214 }, { 201, 201 },
+    {  79,  79 }, { 141, 141 }, { 110, 110 }, { 229, 229 },
+    {  95,  95 }, { 126, 126 }, { 215, 215 }, { 172, 172 },
+    { 111, 111 }, { 142, 142 }, { 202, 202 }, { 157, 157 },
+    { 216, 216 }, { 230, 230 }, { 217, 217 }, { 187, 187 },
+    { 127, 127 }, { 231, 231 }, { 158, 158 }, { 173, 173 },
+    { 143, 143 }, { 203, 203 }, { 188, 188 }, { 232, 232 },
+    { 218, 218 }, { 233, 233 }, { 159, 159 }, { 174, 174 },
+    { 204, 204 }, { 189, 189 }, { 234, 234 }, { 219, 219 },
+    { 175, 175 }, { 205, 205 }, { 235, 235 }, { 220, 220 },
+    { 190, 190 }, { 236, 236 }, { 206, 206 }, { 191, 191 },
+    { 221, 221 }, { 207, 207 }, { 237, 237 }, { 222, 222 },
+    { 238, 238 }, { 223, 223 }, { 239, 239 }, {   0,   0 },
+};
+
+const int16_t ff_vp9_default_scan_32x32_nb[1024][2] = {
+    {    0,    0 }, {    0,    0 }, {    1,    1 }, {   32,    1 },
+    {   32,   32 }, {    2,    2 }, {   33,    2 }, {   64,   33 },
+    {    3,    3 }, {   64,   64 }, {   34,    3 }, {   65,   34 },
+    {    4,    4 }, {   35,    4 }, {   96,   65 }, {   66,   35 },
+    {   96,   96 }, {   97,   66 }, {   67,   36 }, {   36,    5 },
+    {    5,    5 }, {  128,   97 }, {   98,   67 }, {    6,    6 },
+    {  128,  128 }, {   68,   37 }, {   37,    6 }, {  129,   98 },
+    {   99,   68 }, {  160,  129 }, {  130,   99 }, {   38,    7 },
+    {   69,   38 }, {    7,    7 }, {  100,   69 }, {  161,  130 },
+    {  131,  100 }, {  160,  160 }, {   70,   39 }, {   39,    8 },
+    {    8,    8 }, {  101,   70 }, {  162,  131 }, {  132,  101 },
+    {  192,  161 }, {   71,   40 }, {  192,  192 }, {  102,   71 },
+    {   40,    9 }, {  163,  132 }, {    9,    9 }, {  193,  162 },
+    {  133,  102 }, {  164,  133 }, {   72,   41 }, {  103,   72 },
+    {  134,  103 }, {  224,  193 }, {   41,   10 }, {  194,  163 },
+    {   10,   10 }, {  224,  224 }, {  165,  134 }, {  225,  194 },
+    {  195,  164 }, {   73,   42 }, {  104,   73 }, {  135,  104 },
+    {   42,   11 }, {   11,   11 }, {  166,  135 }, {  196,  165 },
+    {  226,  195 }, {  256,  225 }, {   74,   43 }, {  105,   74 },
+    {  136,  105 }, {  227,  196 }, {   43,   12 }, {  197,  166 },
+    {  167,  136 }, {  257,  226 }, {  256,  256 }, {   12,   12 },
+    {  228,  197 }, {   75,   44 }, {  106,   75 }, {  198,  167 },
+    {  137,  106 }, {  258,  227 }, {  168,  137 }, {  288,  257 },
+    {   44,   13 }, {  229,  198 }, {  259,  228 }, {  199,  168 },
+    {  107,   76 }, {   13,   13 }, {  169,  138 }, {  138,  107 },
+    {  288,  288 }, {  289,  258 }, {   76,   45 }, {  230,  199 },
+    {  260,  229 }, {   45,   14 }, {  200,  169 }, {  139,  108 },
+    {  290,  259 }, {  108,   77 }, {  231,  200 }, {  320,  289 },
+    {  261,  230 }, {  170,  139 }, {   77,   46 }, {  291,  260 },
+    {   14,   14 }, {  321,  290 }, {  201,  170 }, {  262,  231 },
+    {  320,  320 }, {  171,  140 }, {  292,  261 }, {  232,  201 },
+    {  140,  109 }, {  322,  291 }, {  109,   78 }, {   46,   15 },
+    {  202,  171 }, {  263,  232 }, {  233,  202 }, {  293,  262 },
+    {  352,  321 }, {  323,  292 }, {   15,   15 }, {   78,   47 },
+    {  203,  172 }, {  264,  233 }, {  294,  263 }, {  324,  293 },
+    {  172,  141 }, {  353,  322 }, {  141,  110 }, {  234,  203 },
+    {  352,  352 }, {   47,   16 }, {  295,  264 }, {  110,   79 },
+    {  265,  234 }, {  354,  323 }, {  325,  294 }, {   79,   48 },
+    {   16,   16 }, {  204,  173 }, {  235,  204 }, {  173,  142 },
+    {  355,  324 }, {  384,  353 }, {  326,  295 }, {  142,  111 },
+    {  296,  265 }, {  266,  235 }, {  356,  325 }, {  385,  354 },
+    {  111,   80 }, {   48,   17 }, {  327,  296 }, {  297,  266 },
+    {  205,  174 }, {  384,  384 }, {  236,  205 }, {  357,  326 },
+    {  386,  355 }, {   80,   49 }, {  174,  143 }, {   17,   17 },
+    {  328,  297 }, {  358,  327 }, {  387,  356 }, {  298,  267 },
+    {  329,  298 }, {  388,  357 }, {  112,   81 }, {  416,  385 },
+    {  237,  206 }, {  359,  328 }, {   49,   18 }, {  206,  175 },
+    {  417,  386 }, {  389,  358 }, {  330,  299 }, {   18,   18 },
+    {  416,  416 }, {  360,  329 }, {   81,   50 }, {  418,  387 },
+    {  390,  359 }, {  238,  207 }, {   50,   19 }, {  361,  330 },
+    {  419,  388 }, {  113,   82 }, {  448,  417 }, {  448,  448 },
+    {  420,  389 }, {   82,   51 }, {  362,  331 }, {  449,  418 },
+    {  421,  390 }, {  480,  480 }, {  450,  419 }, {  422,  391 },
+    {  114,   83 }, {  451,  420 }, {  480,  449 }, {  452,  421 },
+    {  481,  450 }, {  453,  422 }, {  512,  512 }, {  482,  451 },
+    {  454,  423 }, {  512,  481 }, {  483,  452 }, {  513,  482 },
+    {  484,  453 }, {  514,  483 }, {  485,  454 }, {  544,  513 },
+    {  544,  544 }, {  486,  455 }, {  545,  514 }, {  546,  515 },
+    {  576,  576 }, {  576,  545 }, {  577,  546 }, {  578,  547 },
+    {  608,  577 }, {  609,  578 }, {  610,  579 }, {   19,   19 },
+    {  143,  112 }, {  267,  236 }, {  391,  360 }, {  515,  484 },
+    {  608,  608 }, {   20,   20 }, {   51,   20 }, {  144,  113 },
+    {  175,  144 }, {  268,  237 }, {  299,  268 }, {  392,  361 },
+    {  423,  392 }, {  516,  485 }, {  547,  516 }, {  640,  609 },
+    {  640,  640 }, {   21,   21 }, {   52,   21 }, {   83,   52 },
+    {  145,  114 }, {  176,  145 }, {  207,  176 }, {  269,  238 },
+    {  300,  269 }, {  331,  300 }, {  393,  362 }, {  424,  393 },
+    {  455,  424 }, {  517,  486 }, {  548,  517 }, {  579,  548 },
+    {  641,  610 }, {  672,  641 }, {  672,  672 }, {   22,   22 },
+    {   53,   22 }, {   84,   53 }, {  115,   84 }, {  146,  115 },
+    {  177,  146 }, {  208,  177 }, {  239,  208 }, {  270,  239 },
+    {  301,  270 }, {  332,  301 }, {  363,  332 }, {  394,  363 },
+    {  425,  394 }, {  456,  425 }, {  487,  456 }, {  518,  487 },
+    {  549,  518 }, {  580,  549 }, {  611,  580 }, {  642,  611 },
+    {  673,  642 }, {  704,  673 }, {  704,  704 }, {   54,   23 },
+    {   85,   54 }, {  116,   85 }, {  178,  147 }, {  209,  178 },
+    {  240,  209 }, {  302,  271 }, {  333,  302 }, {  364,  333 },
+    {  426,  395 }, {  457,  426 }, {  488,  457 }, {  550,  519 },
+    {  581,  550 }, {  612,  581 }, {  674,  643 }, {  705,  674 },
+    {  736,  705 }, {   86,   55 }, {  117,   86 }, {  210,  179 },
+    {  241,  210 }, {  334,  303 }, {  365,  334 }, {  458,  427 },
+    {  489,  458 }, {  582,  551 }, {  613,  582 }, {  706,  675 },
+    {  737,  706 }, {  118,   87 }, {  242,  211 }, {  366,  335 },
+    {  490,  459 }, {  614,  583 }, {  738,  707 }, {   23,   23 },
+    {  147,  116 }, {  271,  240 }, {  395,  364 }, {  519,  488 },
+    {  643,  612 }, {  736,  736 }, {   24,   24 }, {   55,   24 },
+    {  148,  117 }, {  179,  148 }, {  272,  241 }, {  303,  272 },
+    {  396,  365 }, {  427,  396 }, {  520,  489 }, {  551,  520 },
+    {  644,  613 }, {  675,  644 }, {  768,  737 }, {  768,  768 },
+    {   25,   25 }, {   56,   25 }, {   87,   56 }, {  149,  118 },
+    {  180,  149 }, {  211,  180 }, {  273,  242 }, {  304,  273 },
+    {  335,  304 }, {  397,  366 }, {  428,  397 }, {  459,  428 },
+    {  521,  490 }, {  552,  521 }, {  583,  552 }, {  645,  614 },
+    {  676,  645 }, {  707,  676 }, {  769,  738 }, {  800,  769 },
+    {  800,  800 }, {   26,   26 }, {   57,   26 }, {   88,   57 },
+    {  119,   88 }, {  150,  119 }, {  181,  150 }, {  212,  181 },
+    {  243,  212 }, {  274,  243 }, {  305,  274 }, {  336,  305 },
+    {  367,  336 }, {  398,  367 }, {  429,  398 }, {  460,  429 },
+    {  491,  460 }, {  522,  491 }, {  553,  522 }, {  584,  553 },
+    {  615,  584 }, {  646,  615 }, {  677,  646 }, {  708,  677 },
+    {  739,  708 }, {  770,  739 }, {  801,  770 }, {  832,  801 },
+    {  832,  832 }, {   58,   27 }, {   89,   58 }, {  120,   89 },
+    {  182,  151 }, {  213,  182 }, {  244,  213 }, {  306,  275 },
+    {  337,  306 }, {  368,  337 }, {  430,  399 }, {  461,  430 },
+    {  492,  461 }, {  554,  523 }, {  585,  554 }, {  616,  585 },
+    {  678,  647 }, {  709,  678 }, {  740,  709 }, {  802,  771 },
+    {  833,  802 }, {  864,  833 }, {   90,   59 }, {  121,   90 },
+    {  214,  183 }, {  245,  214 }, {  338,  307 }, {  369,  338 },
+    {  462,  431 }, {  493,  462 }, {  586,  555 }, {  617,  586 },
+    {  710,  679 }, {  741,  710 }, {  834,  803 }, {  865,  834 },
+    {  122,   91 }, {  246,  215 }, {  370,  339 }, {  494,  463 },
+    {  618,  587 }, {  742,  711 }, {  866,  835 }, {   27,   27 },
+    {  151,  120 }, {  275,  244 }, {  399,  368 }, {  523,  492 },
+    {  647,  616 }, {  771,  740 }, {  864,  864 }, {   28,   28 },
+    {   59,   28 }, {  152,  121 }, {  183,  152 }, {  276,  245 },
+    {  307,  276 }, {  400,  369 }, {  431,  400 }, {  524,  493 },
+    {  555,  524 }, {  648,  617 }, {  679,  648 }, {  772,  741 },
+    {  803,  772 }, {  896,  865 }, {  896,  896 }, {   29,   29 },
+    {   60,   29 }, {   91,   60 }, {  153,  122 }, {  184,  153 },
+    {  215,  184 }, {  277,  246 }, {  308,  277 }, {  339,  308 },
+    {  401,  370 }, {  432,  401 }, {  463,  432 }, {  525,  494 },
+    {  556,  525 }, {  587,  556 }, {  649,  618 }, {  680,  649 },
+    {  711,  680 }, {  773,  742 }, {  804,  773 }, {  835,  804 },
+    {  897,  866 }, {  928,  897 }, {  928,  928 }, {   30,   30 },
+    {   61,   30 }, {   92,   61 }, {  123,   92 }, {  154,  123 },
+    {  185,  154 }, {  216,  185 }, {  247,  216 }, {  278,  247 },
+    {  309,  278 }, {  340,  309 }, {  371,  340 }, {  402,  371 },
+    {  433,  402 }, {  464,  433 }, {  495,  464 }, {  526,  495 },
+    {  557,  526 }, {  588,  557 }, {  619,  588 }, {  650,  619 },
+    {  681,  650 }, {  712,  681 }, {  743,  712 }, {  774,  743 },
+    {  805,  774 }, {  836,  805 }, {  867,  836 }, {  898,  867 },
+    {  929,  898 }, {  960,  929 }, {  960,  960 }, {   62,   31 },
+    {   93,   62 }, {  124,   93 }, {  186,  155 }, {  217,  186 },
+    {  248,  217 }, {  310,  279 }, {  341,  310 }, {  372,  341 },
+    {  434,  403 }, {  465,  434 }, {  496,  465 }, {  558,  527 },
+    {  589,  558 }, {  620,  589 }, {  682,  651 }, {  713,  682 },
+    {  744,  713 }, {  806,  775 }, {  837,  806 }, {  868,  837 },
+    {  930,  899 }, {  961,  930 }, {  992,  961 }, {   94,   63 },
+    {  125,   94 }, {  218,  187 }, {  249,  218 }, {  342,  311 },
+    {  373,  342 }, {  466,  435 }, {  497,  466 }, {  590,  559 },
+    {  621,  590 }, {  714,  683 }, {  745,  714 }, {  838,  807 },
+    {  869,  838 }, {  962,  931 }, {  993,  962 }, {  126,   95 },
+    {  250,  219 }, {  374,  343 }, {  498,  467 }, {  622,  591 },
+    {  746,  715 }, {  870,  839 }, {  994,  963 }, {  155,  124 },
+    {  279,  248 }, {  403,  372 }, {  527,  496 }, {  651,  620 },
+    {  775,  744 }, {  899,  868 }, {  156,  125 }, {  187,  156 },
+    {  280,  249 }, {  311,  280 }, {  404,  373 }, {  435,  404 },
+    {  528,  497 }, {  559,  528 }, {  652,  621 }, {  683,  652 },
+    {  776,  745 }, {  807,  776 }, {  900,  869 }, {  931,  900 },
+    {  157,  126 }, {  188,  157 }, {  219,  188 }, {  281,  250 },
+    {  312,  281 }, {  343,  312 }, {  405,  374 }, {  436,  405 },
+    {  467,  436 }, {  529,  498 }, {  560,  529 }, {  591,  560 },
+    {  653,  622 }, {  684,  653 }, {  715,  684 }, {  777,  746 },
+    {  808,  777 }, {  839,  808 }, {  901,  870 }, {  932,  901 },
+    {  963,  932 }, {  158,  127 }, {  189,  158 }, {  220,  189 },
+    {  251,  220 }, {  282,  251 }, {  313,  282 }, {  344,  313 },
+    {  375,  344 }, {  406,  375 }, {  437,  406 }, {  468,  437 },
+    {  499,  468 }, {  530,  499 }, {  561,  530 }, {  592,  561 },
+    {  623,  592 }, {  654,  623 }, {  685,  654 }, {  716,  685 },
+    {  747,  716 }, {  778,  747 }, {  809,  778 }, {  840,  809 },
+    {  871,  840 }, {  902,  871 }, {  933,  902 }, {  964,  933 },
+    {  995,  964 }, {  190,  159 }, {  221,  190 }, {  252,  221 },
+    {  314,  283 }, {  345,  314 }, {  376,  345 }, {  438,  407 },
+    {  469,  438 }, {  500,  469 }, {  562,  531 }, {  593,  562 },
+    {  624,  593 }, {  686,  655 }, {  717,  686 }, {  748,  717 },
+    {  810,  779 }, {  841,  810 }, {  872,  841 }, {  934,  903 },
+    {  965,  934 }, {  996,  965 }, {  222,  191 }, {  253,  222 },
+    {  346,  315 }, {  377,  346 }, {  470,  439 }, {  501,  470 },
+    {  594,  563 }, {  625,  594 }, {  718,  687 }, {  749,  718 },
+    {  842,  811 }, {  873,  842 }, {  966,  935 }, {  997,  966 },
+    {  254,  223 }, {  378,  347 }, {  502,  471 }, {  626,  595 },
+    {  750,  719 }, {  874,  843 }, {  998,  967 }, {  283,  252 },
+    {  407,  376 }, {  531,  500 }, {  655,  624 }, {  779,  748 },
+    {  903,  872 }, {  284,  253 }, {  315,  284 }, {  408,  377 },
+    {  439,  408 }, {  532,  501 }, {  563,  532 }, {  656,  625 },
+    {  687,  656 }, {  780,  749 }, {  811,  780 }, {  904,  873 },
+    {  935,  904 }, {  285,  254 }, {  316,  285 }, {  347,  316 },
+    {  409,  378 }, {  440,  409 }, {  471,  440 }, {  533,  502 },
+    {  564,  533 }, {  595,  564 }, {  657,  626 }, {  688,  657 },
+    {  719,  688 }, {  781,  750 }, {  812,  781 }, {  843,  812 },
+    {  905,  874 }, {  936,  905 }, {  967,  936 }, {  286,  255 },
+    {  317,  286 }, {  348,  317 }, {  379,  348 }, {  410,  379 },
+    {  441,  410 }, {  472,  441 }, {  503,  472 }, {  534,  503 },
+    {  565,  534 }, {  596,  565 }, {  627,  596 }, {  658,  627 },
+    {  689,  658 }, {  720,  689 }, {  751,  720 }, {  782,  751 },
+    {  813,  782 }, {  844,  813 }, {  875,  844 }, {  906,  875 },
+    {  937,  906 }, {  968,  937 }, {  999,  968 }, {  318,  287 },
+    {  349,  318 }, {  380,  349 }, {  442,  411 }, {  473,  442 },
+    {  504,  473 }, {  566,  535 }, {  597,  566 }, {  628,  597 },
+    {  690,  659 }, {  721,  690 }, {  752,  721 }, {  814,  783 },
+    {  845,  814 }, {  876,  845 }, {  938,  907 }, {  969,  938 },
+    { 1000,  969 }, {  350,  319 }, {  381,  350 }, {  474,  443 },
+    {  505,  474 }, {  598,  567 }, {  629,  598 }, {  722,  691 },
+    {  753,  722 }, {  846,  815 }, {  877,  846 }, {  970,  939 },
+    { 1001,  970 }, {  382,  351 }, {  506,  475 }, {  630,  599 },
+    {  754,  723 }, {  878,  847 }, { 1002,  971 }, {  411,  380 },
+    {  535,  504 }, {  659,  628 }, {  783,  752 }, {  907,  876 },
+    {  412,  381 }, {  443,  412 }, {  536,  505 }, {  567,  536 },
+    {  660,  629 }, {  691,  660 }, {  784,  753 }, {  815,  784 },
+    {  908,  877 }, {  939,  908 }, {  413,  382 }, {  444,  413 },
+    {  475,  444 }, {  537,  506 }, {  568,  537 }, {  599,  568 },
+    {  661,  630 }, {  692,  661 }, {  723,  692 }, {  785,  754 },
+    {  816,  785 }, {  847,  816 }, {  909,  878 }, {  940,  909 },
+    {  971,  940 }, {  414,  383 }, {  445,  414 }, {  476,  445 },
+    {  507,  476 }, {  538,  507 }, {  569,  538 }, {  600,  569 },
+    {  631,  600 }, {  662,  631 }, {  693,  662 }, {  724,  693 },
+    {  755,  724 }, {  786,  755 }, {  817,  786 }, {  848,  817 },
+    {  879,  848 }, {  910,  879 }, {  941,  910 }, {  972,  941 },
+    { 1003,  972 }, {  446,  415 }, {  477,  446 }, {  508,  477 },
+    {  570,  539 }, {  601,  570 }, {  632,  601 }, {  694,  663 },
+    {  725,  694 }, {  756,  725 }, {  818,  787 }, {  849,  818 },
+    {  880,  849 }, {  942,  911 }, {  973,  942 }, { 1004,  973 },
+    {  478,  447 }, {  509,  478 }, {  602,  571 }, {  633,  602 },
+    {  726,  695 }, {  757,  726 }, {  850,  819 }, {  881,  850 },
+    {  974,  943 }, { 1005,  974 }, {  510,  479 }, {  634,  603 },
+    {  758,  727 }, {  882,  851 }, { 1006,  975 }, {  539,  508 },
+    {  663,  632 }, {  787,  756 }, {  911,  880 }, {  540,  509 },
+    {  571,  540 }, {  664,  633 }, {  695,  664 }, {  788,  757 },
+    {  819,  788 }, {  912,  881 }, {  943,  912 }, {  541,  510 },
+    {  572,  541 }, {  603,  572 }, {  665,  634 }, {  696,  665 },
+    {  727,  696 }, {  789,  758 }, {  820,  789 }, {  851,  820 },
+    {  913,  882 }, {  944,  913 }, {  975,  944 }, {  542,  511 },
+    {  573,  542 }, {  604,  573 }, {  635,  604 }, {  666,  635 },
+    {  697,  666 }, {  728,  697 }, {  759,  728 }, {  790,  759 },
+    {  821,  790 }, {  852,  821 }, {  883,  852 }, {  914,  883 },
+    {  945,  914 }, {  976,  945 }, { 1007,  976 }, {  574,  543 },
+    {  605,  574 }, {  636,  605 }, {  698,  667 }, {  729,  698 },
+    {  760,  729 }, {  822,  791 }, {  853,  822 }, {  884,  853 },
+    {  946,  915 }, {  977,  946 }, { 1008,  977 }, {  606,  575 },
+    {  637,  606 }, {  730,  699 }, {  761,  730 }, {  854,  823 },
+    {  885,  854 }, {  978,  947 }, { 1009,  978 }, {  638,  607 },
+    {  762,  731 }, {  886,  855 }, { 1010,  979 }, {  667,  636 },
+    {  791,  760 }, {  915,  884 }, {  668,  637 }, {  699,  668 },
+    {  792,  761 }, {  823,  792 }, {  916,  885 }, {  947,  916 },
+    {  669,  638 }, {  700,  669 }, {  731,  700 }, {  793,  762 },
+    {  824,  793 }, {  855,  824 }, {  917,  886 }, {  948,  917 },
+    {  979,  948 }, {  670,  639 }, {  701,  670 }, {  732,  701 },
+    {  763,  732 }, {  794,  763 }, {  825,  794 }, {  856,  825 },
+    {  887,  856 }, {  918,  887 }, {  949,  918 }, {  980,  949 },
+    { 1011,  980 }, {  702,  671 }, {  733,  702 }, {  764,  733 },
+    {  826,  795 }, {  857,  826 }, {  888,  857 }, {  950,  919 },
+    {  981,  950 }, { 1012,  981 }, {  734,  703 }, {  765,  734 },
+    {  858,  827 }, {  889,  858 }, {  982,  951 }, { 1013,  982 },
+    {  766,  735 }, {  890,  859 }, { 1014,  983 }, {  795,  764 },
+    {  919,  888 }, {  796,  765 }, {  827,  796 }, {  920,  889 },
+    {  951,  920 }, {  797,  766 }, {  828,  797 }, {  859,  828 },
+    {  921,  890 }, {  952,  921 }, {  983,  952 }, {  798,  767 },
+    {  829,  798 }, {  860,  829 }, {  891,  860 }, {  922,  891 },
+    {  953,  922 }, {  984,  953 }, { 1015,  984 }, {  830,  799 },
+    {  861,  830 }, {  892,  861 }, {  954,  923 }, {  985,  954 },
+    { 1016,  985 }, {  862,  831 }, {  893,  862 }, {  986,  955 },
+    { 1017,  986 }, {  894,  863 }, { 1018,  987 }, {  923,  892 },
+    {  924,  893 }, {  955,  924 }, {  925,  894 }, {  956,  925 },
+    {  987,  956 }, {  926,  895 }, {  957,  926 }, {  988,  957 },
+    { 1019,  988 }, {  958,  927 }, {  989,  958 }, { 1020,  989 },
+    {  990,  959 }, { 1021,  990 }, { 1022,  991 }, {    0,    0 },
+};
+
+const int16_t (* const ff_vp9_scans_nb[5][4])[2] = {
+    {
+        ff_vp9_default_scan_4x4_nb, ff_vp9_col_scan_4x4_nb,
+        ff_vp9_row_scan_4x4_nb, ff_vp9_default_scan_4x4_nb
+    }, {
+        ff_vp9_default_scan_8x8_nb, ff_vp9_col_scan_8x8_nb,
+        ff_vp9_row_scan_8x8_nb, ff_vp9_default_scan_8x8_nb
+    }, {
+        ff_vp9_default_scan_16x16_nb, ff_vp9_col_scan_16x16_nb,
+        ff_vp9_row_scan_16x16_nb, ff_vp9_default_scan_16x16_nb
+    }, {
+        ff_vp9_default_scan_32x32_nb, ff_vp9_default_scan_32x32_nb,
+        ff_vp9_default_scan_32x32_nb, ff_vp9_default_scan_32x32_nb
+    }, { // lossless
+        ff_vp9_default_scan_4x4_nb, ff_vp9_default_scan_4x4_nb,
+        ff_vp9_default_scan_4x4_nb, ff_vp9_default_scan_4x4_nb
+    }
+};
+
+const uint8_t ff_vp9_model_pareto8[256][8] = {
+    {   6,  86, 128,  11,  87,  42,  91,  52 },
+    {   3,  86, 128,   6,  86,  23,  88,  29 },
+    {   6,  86, 128,  11,  87,  42,  91,  52 },
+    {   9,  86, 129,  17,  88,  61,  94,  76 },
+    {  12,  86, 129,  22,  88,  77,  97,  93 },
+    {  15,  87, 129,  28,  89,  93, 100, 110 },
+    {  17,  87, 129,  33,  90, 105, 103, 123 },
+    {  20,  88, 130,  38,  91, 118, 106, 136 },
+    {  23,  88, 130,  43,  91, 128, 108, 146 },
+    {  26,  89, 131,  48,  92, 139, 111, 156 },
+    {  28,  89, 131,  53,  93, 147, 114, 163 },
+    {  31,  90, 131,  58,  94, 156, 117, 171 },
+    {  34,  90, 131,  62,  94, 163, 119, 177 },
+    {  37,  90, 132,  66,  95, 171, 122, 184 },
+    {  39,  90, 132,  70,  96, 177, 124, 189 },
+    {  42,  91, 132,  75,  97, 183, 127, 194 },
+    {  44,  91, 132,  79,  97, 188, 129, 198 },
+    {  47,  92, 133,  83,  98, 193, 132, 202 },
+    {  49,  92, 133,  86,  99, 197, 134, 205 },
+    {  52,  93, 133,  90, 100, 201, 137, 208 },
+    {  54,  93, 133,  94, 100, 204, 139, 211 },
+    {  57,  94, 134,  98, 101, 208, 142, 214 },
+    {  59,  94, 134, 101, 102, 211, 144, 216 },
+    {  62,  94, 135, 105, 103, 214, 146, 218 },
+    {  64,  94, 135, 108, 103, 216, 148, 220 },
+    {  66,  95, 135, 111, 104, 219, 151, 222 },
+    {  68,  95, 135, 114, 105, 221, 153, 223 },
+    {  71,  96, 136, 117, 106, 224, 155, 225 },
+    {  73,  96, 136, 120, 106, 225, 157, 226 },
+    {  76,  97, 136, 123, 107, 227, 159, 228 },
+    {  78,  97, 136, 126, 108, 229, 160, 229 },
+    {  80,  98, 137, 129, 109, 231, 162, 231 },
+    {  82,  98, 137, 131, 109, 232, 164, 232 },
+    {  84,  98, 138, 134, 110, 234, 166, 233 },
+    {  86,  98, 138, 137, 111, 235, 168, 234 },
+    {  89,  99, 138, 140, 112, 236, 170, 235 },
+    {  91,  99, 138, 142, 112, 237, 171, 235 },
+    {  93, 100, 139, 145, 113, 238, 173, 236 },
+    {  95, 100, 139, 147, 114, 239, 174, 237 },
+    {  97, 101, 140, 149, 115, 240, 176, 238 },
+    {  99, 101, 140, 151, 115, 241, 177, 238 },
+    { 101, 102, 140, 154, 116, 242, 179, 239 },
+    { 103, 102, 140, 156, 117, 242, 180, 239 },
+    { 105, 103, 141, 158, 118, 243, 182, 240 },
+    { 107, 103, 141, 160, 118, 243, 183, 240 },
+    { 109, 104, 141, 162, 119, 244, 185, 241 },
+    { 111, 104, 141, 164, 119, 244, 186, 241 },
+    { 113, 104, 142, 166, 120, 245, 187, 242 },
+    { 114, 104, 142, 168, 121, 245, 188, 242 },
+    { 116, 105, 143, 170, 122, 246, 190, 243 },
+    { 118, 105, 143, 171, 122, 246, 191, 243 },
+    { 120, 106, 143, 173, 123, 247, 192, 244 },
+    { 121, 106, 143, 175, 124, 247, 193, 244 },
+    { 123, 107, 144, 177, 125, 248, 195, 244 },
+    { 125, 107, 144, 178, 125, 248, 196, 244 },
+    { 127, 108, 145, 180, 126, 249, 197, 245 },
+    { 128, 108, 145, 181, 127, 249, 198, 245 },
+    { 130, 109, 145, 183, 128, 249, 199, 245 },
+    { 132, 109, 145, 184, 128, 249, 200, 245 },
+    { 134, 110, 146, 186, 129, 250, 201, 246 },
+    { 135, 110, 146, 187, 130, 250, 202, 246 },
+    { 137, 111, 147, 189, 131, 251, 203, 246 },
+    { 138, 111, 147, 190, 131, 251, 204, 246 },
+    { 140, 112, 147, 192, 132, 251, 205, 247 },
+    { 141, 112, 147, 193, 132, 251, 206, 247 },
+    { 143, 113, 148, 194, 133, 251, 207, 247 },
+    { 144, 113, 148, 195, 134, 251, 207, 247 },
+    { 146, 114, 149, 197, 135, 252, 208, 248 },
+    { 147, 114, 149, 198, 135, 252, 209, 248 },
+    { 149, 115, 149, 199, 136, 252, 210, 248 },
+    { 150, 115, 149, 200, 137, 252, 210, 248 },
+    { 152, 115, 150, 201, 138, 252, 211, 248 },
+    { 153, 115, 150, 202, 138, 252, 212, 248 },
+    { 155, 116, 151, 204, 139, 253, 213, 249 },
+    { 156, 116, 151, 205, 139, 253, 213, 249 },
+    { 158, 117, 151, 206, 140, 253, 214, 249 },
+    { 159, 117, 151, 207, 141, 253, 215, 249 },
+    { 161, 118, 152, 208, 142, 253, 216, 249 },
+    { 162, 118, 152, 209, 142, 253, 216, 249 },
+    { 163, 119, 153, 210, 143, 253, 217, 249 },
+    { 164, 119, 153, 211, 143, 253, 217, 249 },
+    { 166, 120, 153, 212, 144, 254, 218, 250 },
+    { 167, 120, 153, 212, 145, 254, 219, 250 },
+    { 168, 121, 154, 213, 146, 254, 220, 250 },
+    { 169, 121, 154, 214, 146, 254, 220, 250 },
+    { 171, 122, 155, 215, 147, 254, 221, 250 },
+    { 172, 122, 155, 216, 147, 254, 221, 250 },
+    { 173, 123, 155, 217, 148, 254, 222, 250 },
+    { 174, 123, 155, 217, 149, 254, 222, 250 },
+    { 176, 124, 156, 218, 150, 254, 223, 250 },
+    { 177, 124, 156, 219, 150, 254, 223, 250 },
+    { 178, 125, 157, 220, 151, 254, 224, 251 },
+    { 179, 125, 157, 220, 151, 254, 224, 251 },
+    { 180, 126, 157, 221, 152, 254, 225, 251 },
+    { 181, 126, 157, 221, 152, 254, 225, 251 },
+    { 183, 127, 158, 222, 153, 254, 226, 251 },
+    { 184, 127, 158, 223, 154, 254, 226, 251 },
+    { 185, 128, 159, 224, 155, 255, 227, 251 },
+    { 186, 128, 159, 224, 155, 255, 227, 251 },
+    { 187, 129, 160, 225, 156, 255, 228, 251 },
+    { 188, 130, 160, 225, 156, 255, 228, 251 },
+    { 189, 131, 160, 226, 157, 255, 228, 251 },
+    { 190, 131, 160, 226, 158, 255, 228, 251 },
+    { 191, 132, 161, 227, 159, 255, 229, 251 },
+    { 192, 132, 161, 227, 159, 255, 229, 251 },
+    { 193, 133, 162, 228, 160, 255, 230, 252 },
+    { 194, 133, 162, 229, 160, 255, 230, 252 },
+    { 195, 134, 163, 230, 161, 255, 231, 252 },
+    { 196, 134, 163, 230, 161, 255, 231, 252 },
+    { 197, 135, 163, 231, 162, 255, 231, 252 },
+    { 198, 135, 163, 231, 162, 255, 231, 252 },
+    { 199, 136, 164, 232, 163, 255, 232, 252 },
+    { 200, 136, 164, 232, 164, 255, 232, 252 },
+    { 201, 137, 165, 233, 165, 255, 233, 252 },
+    { 201, 137, 165, 233, 165, 255, 233, 252 },
+    { 202, 138, 166, 233, 166, 255, 233, 252 },
+    { 203, 138, 166, 233, 166, 255, 233, 252 },
+    { 204, 139, 166, 234, 167, 255, 234, 252 },
+    { 205, 139, 166, 234, 167, 255, 234, 252 },
+    { 206, 140, 167, 235, 168, 255, 235, 252 },
+    { 206, 140, 167, 235, 168, 255, 235, 252 },
+    { 207, 141, 168, 236, 169, 255, 235, 252 },
+    { 208, 141, 168, 236, 170, 255, 235, 252 },
+    { 209, 142, 169, 237, 171, 255, 236, 252 },
+    { 209, 143, 169, 237, 171, 255, 236, 252 },
+    { 210, 144, 169, 237, 172, 255, 236, 252 },
+    { 211, 144, 169, 237, 172, 255, 236, 252 },
+    { 212, 145, 170, 238, 173, 255, 237, 252 },
+    { 213, 145, 170, 238, 173, 255, 237, 252 },
+    { 214, 146, 171, 239, 174, 255, 237, 253 },
+    { 214, 146, 171, 239, 174, 255, 237, 253 },
+    { 215, 147, 172, 240, 175, 255, 238, 253 },
+    { 215, 147, 172, 240, 175, 255, 238, 253 },
+    { 216, 148, 173, 240, 176, 255, 238, 253 },
+    { 217, 148, 173, 240, 176, 255, 238, 253 },
+    { 218, 149, 173, 241, 177, 255, 239, 253 },
+    { 218, 149, 173, 241, 178, 255, 239, 253 },
+    { 219, 150, 174, 241, 179, 255, 239, 253 },
+    { 219, 151, 174, 241, 179, 255, 239, 253 },
+    { 220, 152, 175, 242, 180, 255, 240, 253 },
+    { 221, 152, 175, 242, 180, 255, 240, 253 },
+    { 222, 153, 176, 242, 181, 255, 240, 253 },
+    { 222, 153, 176, 242, 181, 255, 240, 253 },
+    { 223, 154, 177, 243, 182, 255, 240, 253 },
+    { 223, 154, 177, 243, 182, 255, 240, 253 },
+    { 224, 155, 178, 244, 183, 255, 241, 253 },
+    { 224, 155, 178, 244, 183, 255, 241, 253 },
+    { 225, 156, 178, 244, 184, 255, 241, 253 },
+    { 225, 157, 178, 244, 184, 255, 241, 253 },
+    { 226, 158, 179, 244, 185, 255, 242, 253 },
+    { 227, 158, 179, 244, 185, 255, 242, 253 },
+    { 228, 159, 180, 245, 186, 255, 242, 253 },
+    { 228, 159, 180, 245, 186, 255, 242, 253 },
+    { 229, 160, 181, 245, 187, 255, 242, 253 },
+    { 229, 160, 181, 245, 187, 255, 242, 253 },
+    { 230, 161, 182, 246, 188, 255, 243, 253 },
+    { 230, 162, 182, 246, 188, 255, 243, 253 },
+    { 231, 163, 183, 246, 189, 255, 243, 253 },
+    { 231, 163, 183, 246, 189, 255, 243, 253 },
+    { 232, 164, 184, 247, 190, 255, 243, 253 },
+    { 232, 164, 184, 247, 190, 255, 243, 253 },
+    { 233, 165, 185, 247, 191, 255, 244, 253 },
+    { 233, 165, 185, 247, 191, 255, 244, 253 },
+    { 234, 166, 185, 247, 192, 255, 244, 253 },
+    { 234, 167, 185, 247, 192, 255, 244, 253 },
+    { 235, 168, 186, 248, 193, 255, 244, 253 },
+    { 235, 168, 186, 248, 193, 255, 244, 253 },
+    { 236, 169, 187, 248, 194, 255, 244, 253 },
+    { 236, 169, 187, 248, 194, 255, 244, 253 },
+    { 236, 170, 188, 248, 195, 255, 245, 253 },
+    { 236, 170, 188, 248, 195, 255, 245, 253 },
+    { 237, 171, 189, 249, 196, 255, 245, 254 },
+    { 237, 172, 189, 249, 196, 255, 245, 254 },
+    { 238, 173, 190, 249, 197, 255, 245, 254 },
+    { 238, 173, 190, 249, 197, 255, 245, 254 },
+    { 239, 174, 191, 249, 198, 255, 245, 254 },
+    { 239, 174, 191, 249, 198, 255, 245, 254 },
+    { 240, 175, 192, 249, 199, 255, 246, 254 },
+    { 240, 176, 192, 249, 199, 255, 246, 254 },
+    { 240, 177, 193, 250, 200, 255, 246, 254 },
+    { 240, 177, 193, 250, 200, 255, 246, 254 },
+    { 241, 178, 194, 250, 201, 255, 246, 254 },
+    { 241, 178, 194, 250, 201, 255, 246, 254 },
+    { 242, 179, 195, 250, 202, 255, 246, 254 },
+    { 242, 180, 195, 250, 202, 255, 246, 254 },
+    { 242, 181, 196, 250, 203, 255, 247, 254 },
+    { 242, 181, 196, 250, 203, 255, 247, 254 },
+    { 243, 182, 197, 251, 204, 255, 247, 254 },
+    { 243, 183, 197, 251, 204, 255, 247, 254 },
+    { 244, 184, 198, 251, 205, 255, 247, 254 },
+    { 244, 184, 198, 251, 205, 255, 247, 254 },
+    { 244, 185, 199, 251, 206, 255, 247, 254 },
+    { 244, 185, 199, 251, 206, 255, 247, 254 },
+    { 245, 186, 200, 251, 207, 255, 247, 254 },
+    { 245, 187, 200, 251, 207, 255, 247, 254 },
+    { 246, 188, 201, 252, 207, 255, 248, 254 },
+    { 246, 188, 201, 252, 207, 255, 248, 254 },
+    { 246, 189, 202, 252, 208, 255, 248, 254 },
+    { 246, 190, 202, 252, 208, 255, 248, 254 },
+    { 247, 191, 203, 252, 209, 255, 248, 254 },
+    { 247, 191, 203, 252, 209, 255, 248, 254 },
+    { 247, 192, 204, 252, 210, 255, 248, 254 },
+    { 247, 193, 204, 252, 210, 255, 248, 254 },
+    { 248, 194, 205, 252, 211, 255, 248, 254 },
+    { 248, 194, 205, 252, 211, 255, 248, 254 },
+    { 248, 195, 206, 252, 212, 255, 249, 254 },
+    { 248, 196, 206, 252, 212, 255, 249, 254 },
+    { 249, 197, 207, 253, 213, 255, 249, 254 },
+    { 249, 197, 207, 253, 213, 255, 249, 254 },
+    { 249, 198, 208, 253, 214, 255, 249, 254 },
+    { 249, 199, 209, 253, 214, 255, 249, 254 },
+    { 250, 200, 210, 253, 215, 255, 249, 254 },
+    { 250, 200, 210, 253, 215, 255, 249, 254 },
+    { 250, 201, 211, 253, 215, 255, 249, 254 },
+    { 250, 202, 211, 253, 215, 255, 249, 254 },
+    { 250, 203, 212, 253, 216, 255, 249, 254 },
+    { 250, 203, 212, 253, 216, 255, 249, 254 },
+    { 251, 204, 213, 253, 217, 255, 250, 254 },
+    { 251, 205, 213, 253, 217, 255, 250, 254 },
+    { 251, 206, 214, 254, 218, 255, 250, 254 },
+    { 251, 206, 215, 254, 218, 255, 250, 254 },
+    { 252, 207, 216, 254, 219, 255, 250, 254 },
+    { 252, 208, 216, 254, 219, 255, 250, 254 },
+    { 252, 209, 217, 254, 220, 255, 250, 254 },
+    { 252, 210, 217, 254, 220, 255, 250, 254 },
+    { 252, 211, 218, 254, 221, 255, 250, 254 },
+    { 252, 212, 218, 254, 221, 255, 250, 254 },
+    { 253, 213, 219, 254, 222, 255, 250, 254 },
+    { 253, 213, 220, 254, 222, 255, 250, 254 },
+    { 253, 214, 221, 254, 223, 255, 250, 254 },
+    { 253, 215, 221, 254, 223, 255, 250, 254 },
+    { 253, 216, 222, 254, 224, 255, 251, 254 },
+    { 253, 217, 223, 254, 224, 255, 251, 254 },
+    { 253, 218, 224, 254, 225, 255, 251, 254 },
+    { 253, 219, 224, 254, 225, 255, 251, 254 },
+    { 254, 220, 225, 254, 225, 255, 251, 254 },
+    { 254, 221, 226, 254, 225, 255, 251, 254 },
+    { 254, 222, 227, 255, 226, 255, 251, 254 },
+    { 254, 223, 227, 255, 226, 255, 251, 254 },
+    { 254, 224, 228, 255, 227, 255, 251, 254 },
+    { 254, 225, 229, 255, 227, 255, 251, 254 },
+    { 254, 226, 230, 255, 228, 255, 251, 254 },
+    { 254, 227, 230, 255, 229, 255, 251, 254 },
+    { 255, 228, 231, 255, 230, 255, 251, 254 },
+    { 255, 229, 232, 255, 230, 255, 251, 254 },
+    { 255, 230, 233, 255, 231, 255, 252, 254 },
+    { 255, 231, 234, 255, 231, 255, 252, 254 },
+    { 255, 232, 235, 255, 232, 255, 252, 254 },
+    { 255, 233, 236, 255, 232, 255, 252, 254 },
+    { 255, 235, 237, 255, 233, 255, 252, 254 },
+    { 255, 236, 238, 255, 234, 255, 252, 254 },
+    { 255, 238, 240, 255, 235, 255, 252, 255 },
+    { 255, 239, 241, 255, 235, 255, 252, 254 },
+    { 255, 241, 243, 255, 236, 255, 252, 254 },
+    { 255, 243, 245, 255, 237, 255, 252, 254 },
+    { 255, 246, 247, 255, 239, 255, 253, 255 },
+};
+
+const ProbContext ff_vp9_default_probs = {
+    { /* y_mode */
+        {  65,  32,  18, 144, 162, 194,  41,  51,  98 } /* bsize < 8x8 */,
+        { 132,  68,  18, 165, 217, 196,  45,  40,  78 } /* bsize < 16x16 */,
+        { 173,  80,  19, 176, 240, 193,  64,  35,  46 } /* bsize < 32x32 */,
+        { 221, 135,  38, 194, 248, 121,  96,  85,  29 } /* bsize >= 32x32 */
+    }, { /* uv_mode */
+        {  48,  12, 154, 155, 139,  90,  34, 117, 119 } /* y = v */,
+        {  67,   6,  25, 204, 243, 158,  13,  21,  96 } /* y = h */,
+        { 120,   7,  76, 176, 208, 126,  28,  54, 103 } /* y = dc */,
+        {  97,   5,  44, 131, 176, 139,  48,  68,  97 } /* y = d45 */,
+        {  83,   5,  42, 156, 111, 152,  26,  49, 152 } /* y = d135 */,
+        {  80,   5,  58, 178,  74,  83,  33,  62, 145 } /* y = d117 */,
+        {  86,   5,  32, 154, 192, 168,  14,  22, 163 } /* y = d153 */,
+        {  77,   7,  64, 116, 132, 122,  37, 126, 120 } /* y = d63 */,
+        {  85,   5,  32, 156, 216, 148,  19,  29,  73 } /* y = d27 */,
+        { 101,  21, 107, 181, 192, 103,  19,  67, 125 } /* y = tm */
+    }, { /* filter */
+        { 235, 162, },
+        {  36, 255, },
+        {  34,   3, },
+        { 149, 144, },
+    }, { /* mv_mode */
+        {  2, 173,  34 },  // 0 = both zero mv
+        {  7, 145,  85 },  // 1 = one zero mv + one a predicted mv
+        {  7, 166,  63 },  // 2 = two predicted mvs
+        {  7,  94,  66 },  // 3 = one predicted/zero and one new mv
+        {  8,  64,  46 },  // 4 = two new mvs
+        { 17,  81,  31 },  // 5 = one intra neighbor + x
+        { 25,  29,  30 },  // 6 = two intra neighbors
+    }, { /* intra */
+        9, 102, 187, 225
+    }, { /* comp */
+        239, 183, 119,  96,  41
+    }, { /* single_ref */
+        {  33,  16 },
+        {  77,  74 },
+        { 142, 142 },
+        { 172, 170 },
+        { 238, 247 }
+    }, { /* comp_ref */
+        50, 126, 123, 221, 226
+    }, { /* tx32p */
+        { 3, 136, 37, },
+        { 5,  52, 13, },
+    }, { /* tx16p */
+        { 20, 152, },
+        { 15, 101, },
+    }, { /* tx8p */
+        100, 66
+    }, { /* skip */
+        192, 128, 64
+    }, { /* mv_joint */
+        32, 64, 96
+    }, {
+        { /* mv vertical component */
+            128, /* sign */
+            { 224, 144, 192, 168, 192, 176, 192, 198, 198, 245 }, /* class */
+            216, /* class0 */
+            { 136, 140, 148, 160, 176, 192, 224, 234, 234, 240 }, /* bits */
+            { /* class0_fp */
+                { 128, 128, 64 },
+                {  96, 112, 64 }
+            },
+            { 64, 96, 64 }, /* fp */
+            160, /* class0_hp bit */
+            128, /* hp */
+        }, { /* mv horizontal component */
+            128, /* sign */
+            { 216, 128, 176, 160, 176, 176, 192, 198, 198, 208 }, /* class */
+            208, /* class0 */
+            { 136, 140, 148, 160, 176, 192, 224, 234, 234, 240 }, /* bits */
+            { /* class0_fp */
+                { 128, 128, 64 },
+                {  96, 112, 64 }
+            },
+            { 64, 96, 64 }, /* fp */
+            160, /* class0_hp bit */
+            128, /* hp */
+        }
+    }, { /* partition */
+        { /* 64x64 -> 32x32 */
+            { 222,  34,  30 } /* a/l both not split */,
+            {  72,  16,  44 } /* a split, l not split */,
+            {  58,  32,  12 } /* l split, a not split */,
+            {  10,   7,   6 } /* a/l both split */,
+        }, { /* 32x32 -> 16x16 */
+            { 177,  58,  59 } /* a/l both not split */,
+            {  68,  26,  63 } /* a split, l not split */,
+            {  52,  79,  25 } /* l split, a not split */,
+            {  17,  14,  12 } /* a/l both split */,
+        }, { /* 16x16 -> 8x8 */
+            { 174,  73,  87 } /* a/l both not split */,
+            {  92,  41,  83 } /* a split, l not split */,
+            {  82,  99,  50 } /* l split, a not split */,
+            {  53,  39,  39 } /* a/l both split */,
+        }, { /* 8x8 -> 4x4 */
+            { 199, 122, 141 } /* a/l both not split */,
+            { 147,  63, 159 } /* a split, l not split */,
+            { 148, 133, 118 } /* l split, a not split */,
+            { 121, 104, 114 } /* a/l both split */,
+        }
+    },
+};
+
+const uint8_t ff_vp9_default_coef_probs[4][2][2][6][6][3] = {
+    { /* tx = 4x4 */
+        { /* block Type 0 */
+            { /* Intra */
+                { /* Coeff Band 0 */
+                    { 195,  29, 183 },
+                    {  84,  49, 136 },
+                    {   8,  42,  71 }
+                }, { /* Coeff Band 1 */
+                    {  31, 107, 169 },
+                    {  35,  99, 159 },
+                    {  17,  82, 140 },
+                    {   8,  66, 114 },
+                    {   2,  44,  76 },
+                    {   1,  19,  32 }
+                }, { /* Coeff Band 2 */
+                    {  40, 132, 201 },
+                    {  29, 114, 187 },
+                    {  13,  91, 157 },
+                    {   7,  75, 127 },
+                    {   3,  58,  95 },
+                    {   1,  28,  47 }
+                }, { /* Coeff Band 3 */
+                    {  69, 142, 221 },
+                    {  42, 122, 201 },
+                    {  15,  91, 159 },
+                    {   6,  67, 121 },
+                    {   1,  42,  77 },
+                    {   1,  17,  31 }
+                }, { /* Coeff Band 4 */
+                    { 102, 148, 228 },
+                    {  67, 117, 204 },
+                    {  17,  82, 154 },
+                    {   6,  59, 114 },
+                    {   2,  39,  75 },
+                    {   1,  15,  29 }
+                }, { /* Coeff Band 5 */
+                    { 156,  57, 233 },
+                    { 119,  57, 212 },
+                    {  58,  48, 163 },
+                    {  29,  40, 124 },
+                    {  12,  30,  81 },
+                    {   3,  12,  31 }
+                }
+            }, { /* Inter */
+                { /* Coeff Band 0 */
+                    { 191, 107, 226 },
+                    { 124, 117, 204 },
+                    {  25,  99, 155 }
+                }, { /* Coeff Band 1 */
+                    {  29, 148, 210 },
+                    {  37, 126, 194 },
+                    {   8,  93, 157 },
+                    {   2,  68, 118 },
+                    {   1,  39,  69 },
+                    {   1,  17,  33 }
+                }, { /* Coeff Band 2 */
+                    {  41, 151, 213 },
+                    {  27, 123, 193 },
+                    {   3,  82, 144 },
+                    {   1,  58, 105 },
+                    {   1,  32,  60 },
+                    {   1,  13,  26 }
+                }, { /* Coeff Band 3 */
+                    {  59, 159, 220 },
+                    {  23, 126, 198 },
+                    {   4,  88, 151 },
+                    {   1,  66, 114 },
+                    {   1,  38,  71 },
+                    {   1,  18,  34 }
+                }, { /* Coeff Band 4 */
+                    { 114, 136, 232 },
+                    {  51, 114, 207 },
+                    {  11,  83, 155 },
+                    {   3,  56, 105 },
+                    {   1,  33,  65 },
+                    {   1,  17,  34 }
+                }, { /* Coeff Band 5 */
+                    { 149,  65, 234 },
+                    { 121,  57, 215 },
+                    {  61,  49, 166 },
+                    {  28,  36, 114 },
+                    {  12,  25,  76 },
+                    {   3,  16,  42 }
+                }
+            }
+        }, { /* block Type 1 */
+            { /* Intra */
+                { /* Coeff Band 0 */
+                    { 214,  49, 220 },
+                    { 132,  63, 188 },
+                    {  42,  65, 137 }
+                }, { /* Coeff Band 1 */
+                    {  85, 137, 221 },
+                    { 104, 131, 216 },
+                    {  49, 111, 192 },
+                    {  21,  87, 155 },
+                    {   2,  49,  87 },
+                    {   1,  16,  28 }
+                }, { /* Coeff Band 2 */
+                    {  89, 163, 230 },
+                    {  90, 137, 220 },
+                    {  29, 100, 183 },
+                    {  10,  70, 135 },
+                    {   2,  42,  81 },
+                    {   1,  17,  33 }
+                }, { /* Coeff Band 3 */
+                    { 108, 167, 237 },
+                    {  55, 133, 222 },
+                    {  15,  97, 179 },
+                    {   4,  72, 135 },
+                    {   1,  45,  85 },
+                    {   1,  19,  38 }
+                }, { /* Coeff Band 4 */
+                    { 124, 146, 240 },
+                    {  66, 124, 224 },
+                    {  17,  88, 175 },
+                    {   4,  58, 122 },
+                    {   1,  36,  75 },
+                    {   1,  18,  37 }
+                }, { /* Coeff Band 5 */
+                    { 141,  79, 241 },
+                    { 126,  70, 227 },
+                    {  66,  58, 182 },
+                    {  30,  44, 136 },
+                    {  12,  34,  96 },
+                    {   2,  20,  47 }
+                }
+            }, { /* Inter */
+                { /* Coeff Band 0 */
+                    { 229,  99, 249 },
+                    { 143, 111, 235 },
+                    {  46, 109, 192 }
+                }, { /* Coeff Band 1 */
+                    {  82, 158, 236 },
+                    {  94, 146, 224 },
+                    {  25, 117, 191 },
+                    {   9,  87, 149 },
+                    {   3,  56,  99 },
+                    {   1,  33,  57 }
+                }, { /* Coeff Band 2 */
+                    {  83, 167, 237 },
+                    {  68, 145, 222 },
+                    {  10, 103, 177 },
+                    {   2,  72, 131 },
+                    {   1,  41,  79 },
+                    {   1,  20,  39 }
+                }, { /* Coeff Band 3 */
+                    {  99, 167, 239 },
+                    {  47, 141, 224 },
+                    {  10, 104, 178 },
+                    {   2,  73, 133 },
+                    {   1,  44,  85 },
+                    {   1,  22,  47 }
+                }, { /* Coeff Band 4 */
+                    { 127, 145, 243 },
+                    {  71, 129, 228 },
+                    {  17,  93, 177 },
+                    {   3,  61, 124 },
+                    {   1,  41,  84 },
+                    {   1,  21,  52 }
+                }, { /* Coeff Band 5 */
+                    { 157,  78, 244 },
+                    { 140,  72, 231 },
+                    {  69,  58, 184 },
+                    {  31,  44, 137 },
+                    {  14,  38, 105 },
+                    {   8,  23,  61 }
+                }
+            }
+        }
+    }, { /* tx = 8x8 */
+        { /* block Type 0 */
+            { /* Intra */
+                { /* Coeff Band 0 */
+                    { 125,  34, 187 },
+                    {  52,  41, 133 },
+                    {   6,  31,  56 }
+                }, { /* Coeff Band 1 */
+                    {  37, 109, 153 },
+                    {  51, 102, 147 },
+                    {  23,  87, 128 },
+                    {   8,  67, 101 },
+                    {   1,  41,  63 },
+                    {   1,  19,  29 }
+                }, { /* Coeff Band 2 */
+                    {  31, 154, 185 },
+                    {  17, 127, 175 },
+                    {   6,  96, 145 },
+                    {   2,  73, 114 },
+                    {   1,  51,  82 },
+                    {   1,  28,  45 }
+                }, { /* Coeff Band 3 */
+                    {  23, 163, 200 },
+                    {  10, 131, 185 },
+                    {   2,  93, 148 },
+                    {   1,  67, 111 },
+                    {   1,  41,  69 },
+                    {   1,  14,  24 }
+                }, { /* Coeff Band 4 */
+                    {  29, 176, 217 },
+                    {  12, 145, 201 },
+                    {   3, 101, 156 },
+                    {   1,  69, 111 },
+                    {   1,  39,  63 },
+                    {   1,  14,  23 }
+                }, { /* Coeff Band 5 */
+                    {  57, 192, 233 },
+                    {  25, 154, 215 },
+                    {   6, 109, 167 },
+                    {   3,  78, 118 },
+                    {   1,  48,  69 },
+                    {   1,  21,  29 }
+                }
+            }, { /* Inter */
+                { /* Coeff Band 0 */
+                    { 202, 105, 245 },
+                    { 108, 106, 216 },
+                    {  18,  90, 144 }
+                }, { /* Coeff Band 1 */
+                    {  33, 172, 219 },
+                    {  64, 149, 206 },
+                    {  14, 117, 177 },
+                    {   5,  90, 141 },
+                    {   2,  61,  95 },
+                    {   1,  37,  57 }
+                }, { /* Coeff Band 2 */
+                    {  33, 179, 220 },
+                    {  11, 140, 198 },
+                    {   1,  89, 148 },
+                    {   1,  60, 104 },
+                    {   1,  33,  57 },
+                    {   1,  12,  21 }
+                }, { /* Coeff Band 3 */
+                    {  30, 181, 221 },
+                    {   8, 141, 198 },
+                    {   1,  87, 145 },
+                    {   1,  58, 100 },
+                    {   1,  31,  55 },
+                    {   1,  12,  20 }
+                }, { /* Coeff Band 4 */
+                    {  32, 186, 224 },
+                    {   7, 142, 198 },
+                    {   1,  86, 143 },
+                    {   1,  58, 100 },
+                    {   1,  31,  55 },
+                    {   1,  12,  22 }
+                }, { /* Coeff Band 5 */
+                    {  57, 192, 227 },
+                    {  20, 143, 204 },
+                    {   3,  96, 154 },
+                    {   1,  68, 112 },
+                    {   1,  42,  69 },
+                    {   1,  19,  32 }
+                }
+            }
+        }, { /* block Type 1 */
+            { /* Intra */
+                { /* Coeff Band 0 */
+                    { 212,  35, 215 },
+                    { 113,  47, 169 },
+                    {  29,  48, 105 }
+                }, { /* Coeff Band 1 */
+                    {  74, 129, 203 },
+                    { 106, 120, 203 },
+                    {  49, 107, 178 },
+                    {  19,  84, 144 },
+                    {   4,  50,  84 },
+                    {   1,  15,  25 }
+                }, { /* Coeff Band 2 */
+                    {  71, 172, 217 },
+                    {  44, 141, 209 },
+                    {  15, 102, 173 },
+                    {   6,  76, 133 },
+                    {   2,  51,  89 },
+                    {   1,  24,  42 }
+                }, { /* Coeff Band 3 */
+                    {  64, 185, 231 },
+                    {  31, 148, 216 },
+                    {   8, 103, 175 },
+                    {   3,  74, 131 },
+                    {   1,  46,  81 },
+                    {   1,  18,  30 }
+                }, { /* Coeff Band 4 */
+                    {  65, 196, 235 },
+                    {  25, 157, 221 },
+                    {   5, 105, 174 },
+                    {   1,  67, 120 },
+                    {   1,  38,  69 },
+                    {   1,  15,  30 }
+                }, { /* Coeff Band 5 */
+                    {  65, 204, 238 },
+                    {  30, 156, 224 },
+                    {   7, 107, 177 },
+                    {   2,  70, 124 },
+                    {   1,  42,  73 },
+                    {   1,  18,  34 }
+                }
+            }, { /* Inter */
+                { /* Coeff Band 0 */
+                    { 225,  86, 251 },
+                    { 144, 104, 235 },
+                    {  42,  99, 181 }
+                }, { /* Coeff Band 1 */
+                    {  85, 175, 239 },
+                    { 112, 165, 229 },
+                    {  29, 136, 200 },
+                    {  12, 103, 162 },
+                    {   6,  77, 123 },
+                    {   2,  53,  84 }
+                }, { /* Coeff Band 2 */
+                    {  75, 183, 239 },
+                    {  30, 155, 221 },
+                    {   3, 106, 171 },
+                    {   1,  74, 128 },
+                    {   1,  44,  76 },
+                    {   1,  17,  28 }
+                }, { /* Coeff Band 3 */
+                    {  73, 185, 240 },
+                    {  27, 159, 222 },
+                    {   2, 107, 172 },
+                    {   1,  75, 127 },
+                    {   1,  42,  73 },
+                    {   1,  17,  29 }
+                }, { /* Coeff Band 4 */
+                    {  62, 190, 238 },
+                    {  21, 159, 222 },
+                    {   2, 107, 172 },
+                    {   1,  72, 122 },
+                    {   1,  40,  71 },
+                    {   1,  18,  32 }
+                }, { /* Coeff Band 5 */
+                    {  61, 199, 240 },
+                    {  27, 161, 226 },
+                    {   4, 113, 180 },
+                    {   1,  76, 129 },
+                    {   1,  46,  80 },
+                    {   1,  23,  41 }
+                }
+            }
+        }
+    }, { /* tx = 16x16 */
+        { /* block Type 0 */
+            { /* Intra */
+                { /* Coeff Band 0 */
+                    {   7,  27, 153 },
+                    {   5,  30,  95 },
+                    {   1,  16,  30 }
+                }, { /* Coeff Band 1 */
+                    {  50,  75, 127 },
+                    {  57,  75, 124 },
+                    {  27,  67, 108 },
+                    {  10,  54,  86 },
+                    {   1,  33,  52 },
+                    {   1,  12,  18 }
+                }, { /* Coeff Band 2 */
+                    {  43, 125, 151 },
+                    {  26, 108, 148 },
+                    {   7,  83, 122 },
+                    {   2,  59,  89 },
+                    {   1,  38,  60 },
+                    {   1,  17,  27 }
+                }, { /* Coeff Band 3 */
+                    {  23, 144, 163 },
+                    {  13, 112, 154 },
+                    {   2,  75, 117 },
+                    {   1,  50,  81 },
+                    {   1,  31,  51 },
+                    {   1,  14,  23 }
+                }, { /* Coeff Band 4 */
+                    {  18, 162, 185 },
+                    {   6, 123, 171 },
+                    {   1,  78, 125 },
+                    {   1,  51,  86 },
+                    {   1,  31,  54 },
+                    {   1,  14,  23 }
+                }, { /* Coeff Band 5 */
+                    {  15, 199, 227 },
+                    {   3, 150, 204 },
+                    {   1,  91, 146 },
+                    {   1,  55,  95 },
+                    {   1,  30,  53 },
+                    {   1,  11,  20 }
+                }
+            }, { /* Inter */
+                { /* Coeff Band 0 */
+                    {  19,  55, 240 },
+                    {  19,  59, 196 },
+                    {   3,  52, 105 }
+                }, { /* Coeff Band 1 */
+                    {  41, 166, 207 },
+                    { 104, 153, 199 },
+                    {  31, 123, 181 },
+                    {  14, 101, 152 },
+                    {   5,  72, 106 },
+                    {   1,  36,  52 }
+                }, { /* Coeff Band 2 */
+                    {  35, 176, 211 },
+                    {  12, 131, 190 },
+                    {   2,  88, 144 },
+                    {   1,  60, 101 },
+                    {   1,  36,  60 },
+                    {   1,  16,  28 }
+                }, { /* Coeff Band 3 */
+                    {  28, 183, 213 },
+                    {   8, 134, 191 },
+                    {   1,  86, 142 },
+                    {   1,  56,  96 },
+                    {   1,  30,  53 },
+                    {   1,  12,  20 }
+                }, { /* Coeff Band 4 */
+                    {  20, 190, 215 },
+                    {   4, 135, 192 },
+                    {   1,  84, 139 },
+                    {   1,  53,  91 },
+                    {   1,  28,  49 },
+                    {   1,  11,  20 }
+                }, { /* Coeff Band 5 */
+                    {  13, 196, 216 },
+                    {   2, 137, 192 },
+                    {   1,  86, 143 },
+                    {   1,  57,  99 },
+                    {   1,  32,  56 },
+                    {   1,  13,  24 }
+                }
+            }
+        }, { /* block Type 1 */
+            { /* Intra */
+                { /* Coeff Band 0 */
+                    { 211,  29, 217 },
+                    {  96,  47, 156 },
+                    {  22,  43,  87 }
+                }, { /* Coeff Band 1 */
+                    {  78, 120, 193 },
+                    { 111, 116, 186 },
+                    {  46, 102, 164 },
+                    {  15,  80, 128 },
+                    {   2,  49,  76 },
+                    {   1,  18,  28 }
+                }, { /* Coeff Band 2 */
+                    {  71, 161, 203 },
+                    {  42, 132, 192 },
+                    {  10,  98, 150 },
+                    {   3,  69, 109 },
+                    {   1,  44,  70 },
+                    {   1,  18,  29 }
+                }, { /* Coeff Band 3 */
+                    {  57, 186, 211 },
+                    {  30, 140, 196 },
+                    {   4,  93, 146 },
+                    {   1,  62, 102 },
+                    {   1,  38,  65 },
+                    {   1,  16,  27 }
+                }, { /* Coeff Band 4 */
+                    {  47, 199, 217 },
+                    {  14, 145, 196 },
+                    {   1,  88, 142 },
+                    {   1,  57,  98 },
+                    {   1,  36,  62 },
+                    {   1,  15,  26 }
+                }, { /* Coeff Band 5 */
+                    {  26, 219, 229 },
+                    {   5, 155, 207 },
+                    {   1,  94, 151 },
+                    {   1,  60, 104 },
+                    {   1,  36,  62 },
+                    {   1,  16,  28 }
+                }
+            }, { /* Inter */
+                { /* Coeff Band 0 */
+                    { 233,  29, 248 },
+                    { 146,  47, 220 },
+                    {  43,  52, 140 }
+                }, { /* Coeff Band 1 */
+                    { 100, 163, 232 },
+                    { 179, 161, 222 },
+                    {  63, 142, 204 },
+                    {  37, 113, 174 },
+                    {  26,  89, 137 },
+                    {  18,  68,  97 }
+                }, { /* Coeff Band 2 */
+                    {  85, 181, 230 },
+                    {  32, 146, 209 },
+                    {   7, 100, 164 },
+                    {   3,  71, 121 },
+                    {   1,  45,  77 },
+                    {   1,  18,  30 }
+                }, { /* Coeff Band 3 */
+                    {  65, 187, 230 },
+                    {  20, 148, 207 },
+                    {   2,  97, 159 },
+                    {   1,  68, 116 },
+                    {   1,  40,  70 },
+                    {   1,  14,  29 }
+                }, { /* Coeff Band 4 */
+                    {  40, 194, 227 },
+                    {   8, 147, 204 },
+                    {   1,  94, 155 },
+                    {   1,  65, 112 },
+                    {   1,  39,  66 },
+                    {   1,  14,  26 }
+                }, { /* Coeff Band 5 */
+                    {  16, 208, 228 },
+                    {   3, 151, 207 },
+                    {   1,  98, 160 },
+                    {   1,  67, 117 },
+                    {   1,  41,  74 },
+                    {   1,  17,  31 }
+                }
+            }
+        }
+    }, { /* tx = 32x32 */
+        { /* block Type 0 */
+            { /* Intra */
+                { /* Coeff Band 0 */
+                    {  17,  38, 140 },
+                    {   7,  34,  80 },
+                    {   1,  17,  29 }
+                }, { /* Coeff Band 1 */
+                    {  37,  75, 128 },
+                    {  41,  76, 128 },
+                    {  26,  66, 116 },
+                    {  12,  52,  94 },
+                    {   2,  32,  55 },
+                    {   1,  10,  16 }
+                }, { /* Coeff Band 2 */
+                    {  50, 127, 154 },
+                    {  37, 109, 152 },
+                    {  16,  82, 121 },
+                    {   5,  59,  85 },
+                    {   1,  35,  54 },
+                    {   1,  13,  20 }
+                }, { /* Coeff Band 3 */
+                    {  40, 142, 167 },
+                    {  17, 110, 157 },
+                    {   2,  71, 112 },
+                    {   1,  44,  72 },
+                    {   1,  27,  45 },
+                    {   1,  11,  17 }
+                }, { /* Coeff Band 4 */
+                    {  30, 175, 188 },
+                    {   9, 124, 169 },
+                    {   1,  74, 116 },
+                    {   1,  48,  78 },
+                    {   1,  30,  49 },
+                    {   1,  11,  18 }
+                }, { /* Coeff Band 5 */
+                    {  10, 222, 223 },
+                    {   2, 150, 194 },
+                    {   1,  83, 128 },
+                    {   1,  48,  79 },
+                    {   1,  27,  45 },
+                    {   1,  11,  17 }
+                }
+            }, { /* Inter */
+                { /* Coeff Band 0 */
+                    {  36,  41, 235 },
+                    {  29,  36, 193 },
+                    {  10,  27, 111 }
+                }, { /* Coeff Band 1 */
+                    {  85, 165, 222 },
+                    { 177, 162, 215 },
+                    { 110, 135, 195 },
+                    {  57, 113, 168 },
+                    {  23,  83, 120 },
+                    {  10,  49,  61 }
+                }, { /* Coeff Band 2 */
+                    {  85, 190, 223 },
+                    {  36, 139, 200 },
+                    {   5,  90, 146 },
+                    {   1,  60, 103 },
+                    {   1,  38,  65 },
+                    {   1,  18,  30 }
+                }, { /* Coeff Band 3 */
+                    {  72, 202, 223 },
+                    {  23, 141, 199 },
+                    {   2,  86, 140 },
+                    {   1,  56,  97 },
+                    {   1,  36,  61 },
+                    {   1,  16,  27 }
+                }, { /* Coeff Band 4 */
+                    {  55, 218, 225 },
+                    {  13, 145, 200 },
+                    {   1,  86, 141 },
+                    {   1,  57,  99 },
+                    {   1,  35,  61 },
+                    {   1,  13,  22 }
+                }, { /* Coeff Band 5 */
+                    {  15, 235, 212 },
+                    {   1, 132, 184 },
+                    {   1,  84, 139 },
+                    {   1,  57,  97 },
+                    {   1,  34,  56 },
+                    {   1,  14,  23 }
+                }
+            }
+        }, { /* block Type 1 */
+            { /* Intra */
+                { /* Coeff Band 0 */
+                    { 181,  21, 201 },
+                    {  61,  37, 123 },
+                    {  10,  38,  71 }
+                }, { /* Coeff Band 1 */
+                    {  47, 106, 172 },
+                    {  95, 104, 173 },
+                    {  42,  93, 159 },
+                    {  18,  77, 131 },
+                    {   4,  50,  81 },
+                    {   1,  17,  23 }
+                }, { /* Coeff Band 2 */
+                    {  62, 147, 199 },
+                    {  44, 130, 189 },
+                    {  28, 102, 154 },
+                    {  18,  75, 115 },
+                    {   2,  44,  65 },
+                    {   1,  12,  19 }
+                }, { /* Coeff Band 3 */
+                    {  55, 153, 210 },
+                    {  24, 130, 194 },
+                    {   3,  93, 146 },
+                    {   1,  61,  97 },
+                    {   1,  31,  50 },
+                    {   1,  10,  16 }
+                }, { /* Coeff Band 4 */
+                    {  49, 186, 223 },
+                    {  17, 148, 204 },
+                    {   1,  96, 142 },
+                    {   1,  53,  83 },
+                    {   1,  26,  44 },
+                    {   1,  11,  17 }
+                }, { /* Coeff Band 5 */
+                    {  13, 217, 212 },
+                    {   2, 136, 180 },
+                    {   1,  78, 124 },
+                    {   1,  50,  83 },
+                    {   1,  29,  49 },
+                    {   1,  14,  23 }
+                }
+            }, { /* Inter */
+                { /* Coeff Band 0 */
+                    { 197,  13, 247 },
+                    {  82,  17, 222 },
+                    {  25,  17, 162 }
+                }, { /* Coeff Band 1 */
+                    { 126, 186, 247 },
+                    { 234, 191, 243 },
+                    { 176, 177, 234 },
+                    { 104, 158, 220 },
+                    {  66, 128, 186 },
+                    {  55,  90, 137 }
+                }, { /* Coeff Band 2 */
+                    { 111, 197, 242 },
+                    {  46, 158, 219 },
+                    {   9, 104, 171 },
+                    {   2,  65, 125 },
+                    {   1,  44,  80 },
+                    {   1,  17,  91 }
+                }, { /* Coeff Band 3 */
+                    { 104, 208, 245 },
+                    {  39, 168, 224 },
+                    {   3, 109, 162 },
+                    {   1,  79, 124 },
+                    {   1,  50, 102 },
+                    {   1,  43, 102 }
+                }, { /* Coeff Band 4 */
+                    {  84, 220, 246 },
+                    {  31, 177, 231 },
+                    {   2, 115, 180 },
+                    {   1,  79, 134 },
+                    {   1,  55,  77 },
+                    {   1,  60,  79 }
+                }, { /* Coeff Band 5 */
+                    {  43, 243, 240 },
+                    {   8, 180, 217 },
+                    {   1, 115, 166 },
+                    {   1,  84, 121 },
+                    {   1,  51,  67 },
+                    {   1,  16,   6 }
+                }
+            }
+        }
+    }
+};
+
+const int8_t ff_vp9_mv_joint_tree[3][2] = {
+    { -MV_JOINT_ZERO, 1 },                  // '0'
+        { -MV_JOINT_H, 2 },                 // '10'
+            { -MV_JOINT_V, -MV_JOINT_HV },  // '11x'
+};
+
+const int8_t ff_vp9_mv_class_tree[10][2] = {
+    { -0,   1 },                          // '0'
+        { -1,   2 },                      // '10'
+            {  3,   4 },
+                { -2,  -3 },              // '110x'
+                {  5,   6 },
+                    { -4,  -5 },          // '1110x'
+                    { -6,   7 },          // '11110'
+                        {  8,   9 },
+                            { -7,  -8 },  // '111110x'
+                            { -9, -10 },  // '111111x'
+};
+
+const int8_t ff_vp9_mv_fp_tree[3][2] = {
+    { -0,  1 },          // '0'
+        { -1,  2 },      // '10'
+            { -2, -3 },  // '11x'
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9data.h b/mythtv/external/FFmpeg/libavcodec/vp9data.h
index cb12e7e9467..086dbdec06d 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp9data.h
+++ b/mythtv/external/FFmpeg/libavcodec/vp9data.h
@@ -24,2254 +24,48 @@
 
 #include <stdint.h>
 
-#include "vp9.h"
-
-static const int8_t vp9_partition_tree[3][2] = {
-    { -PARTITION_NONE, 1 },               // '0'
-     { -PARTITION_H, 2 },                 // '10'
-      { -PARTITION_V, -PARTITION_SPLIT }, // '110', '111'
-};
-
-static const uint8_t vp9_default_kf_partition_probs[4][4][3] = {
-    { /* 64x64 -> 32x32 */
-        { 174,  35,  49 } /* a/l both not split */,
-        {  68,  11,  27 } /* a split, l not split */,
-        {  57,  15,   9 } /* l split, a not split */,
-        {  12,   3,   3 } /* a/l both split */
-    }, { /* 32x32 -> 16x16 */
-        { 150,  40,  39 } /* a/l both not split */,
-        {  78,  12,  26 } /* a split, l not split */,
-        {  67,  33,  11 } /* l split, a not split */,
-        {  24,   7,   5 } /* a/l both split */,
-    }, { /* 16x16 -> 8x8 */
-        { 149,  53,  53 } /* a/l both not split */,
-        {  94,  20,  48 } /* a split, l not split */,
-        {  83,  53,  24 } /* l split, a not split */,
-        {  52,  18,  18 } /* a/l both split */,
-    }, { /* 8x8 -> 4x4 */
-        { 158,  97,  94 } /* a/l both not split */,
-        {  93,  24,  99 } /* a split, l not split */,
-        {  85, 119,  44 } /* l split, a not split */,
-        {  62,  59,  67 } /* a/l both split */,
-    },
-};
-
-static const int8_t vp9_segmentation_tree[7][2] = {
-    { 1, 2 },
-     { 3, 4 },
-     { 5, 6 },
-      { -0, -1 }, // '00x'
-      { -2, -3 }, // '01x'
-      { -4, -5 }, // '10x'
-      { -6, -7 }, // '11x'
-};
-
-static const int8_t vp9_intramode_tree[9][2] = {
-    { -DC_PRED, 1 },                                  // '0'
-     { -TM_VP8_PRED, 2 },                             // '10'
-      { -VERT_PRED, 3 },                              // '110'
-       { 4, 6 },
-        { -HOR_PRED, 5 },                             // '11100'
-         { -DIAG_DOWN_RIGHT_PRED, -VERT_RIGHT_PRED }, // '11101x'
-        { -DIAG_DOWN_LEFT_PRED, 7 },                  // '11110'
-         { -VERT_LEFT_PRED, 8 },                      // '111110'
-          { -HOR_DOWN_PRED, -HOR_UP_PRED },           // '111111x'
-};
-
-static const uint8_t vp9_default_kf_ymode_probs[10][10][9] = {
-    { /* above = v */
-        {  43,  46, 168, 134, 107, 128,  69, 142,  92 } /* left = v */,
-        {  44,  29,  68, 159, 201, 177,  50,  57,  77 } /* left = h */,
-        {  63,  36, 126, 146, 123, 158,  60,  90,  96 } /* left = dc */,
-        {  58,  38,  76, 114,  97, 172,  78, 133,  92 } /* left = d45 */,
-        {  46,  41,  76, 140,  63, 184,  69, 112,  57 } /* left = d135 */,
-        {  38,  32,  85, 140,  46, 112,  54, 151, 133 } /* left = d117 */,
-        {  39,  27,  61, 131, 110, 175,  44,  75, 136 } /* left = d153 */,
-        {  47,  35,  80, 100,  74, 143,  64, 163,  74 } /* left = d63 */,
-        {  52,  30,  74, 113, 130, 175,  51,  64,  58 } /* left = d27 */,
-        {  36,  61, 116, 114, 128, 162,  80, 125,  82 } /* left = tm */
-    }, { /* above = h */
-        {  55,  44,  68, 166, 179, 192,  57,  57, 108 } /* left = v */,
-        {  42,  26,  11, 199, 241, 228,  23,  15,  85 } /* left = h */,
-        {  82,  26,  26, 171, 208, 204,  44,  32, 105 } /* left = dc */,
-        {  68,  42,  19, 131, 160, 199,  55,  52,  83 } /* left = d45 */,
-        {  58,  50,  25, 139, 115, 232,  39,  52, 118 } /* left = d135 */,
-        {  50,  35,  33, 153, 104, 162,  64,  59, 131 } /* left = d117 */,
-        {  44,  24,  16, 150, 177, 202,  33,  19, 156 } /* left = d153 */,
-        {  53,  49,  21, 110, 116, 168,  59,  80,  76 } /* left = d63 */,
-        {  55,  27,  12, 153, 203, 218,  26,  27,  49 } /* left = d27 */,
-        {  38,  72,  19, 168, 203, 212,  50,  50, 107 } /* left = tm */
-    }, { /* above = dc */
-        {  92,  45, 102, 136, 116, 180,  74,  90, 100 } /* left = v */,
-        {  73,  32,  19, 187, 222, 215,  46,  34, 100 } /* left = h */,
-        { 137,  30,  42, 148, 151, 207,  70,  52,  91 } /* left = dc */,
-        {  91,  30,  32, 116, 121, 186,  93,  86,  94 } /* left = d45 */,
-        {  72,  35,  36, 149,  68, 206,  68,  63, 105 } /* left = d135 */,
-        {  73,  31,  28, 138,  57, 124,  55, 122, 151 } /* left = d117 */,
-        {  67,  23,  21, 140, 126, 197,  40,  37, 171 } /* left = d153 */,
-        {  74,  32,  27, 107,  86, 160,  63, 134, 102 } /* left = d63 */,
-        {  86,  27,  28, 128, 154, 212,  45,  43,  53 } /* left = d27 */,
-        {  59,  67,  44, 140, 161, 202,  78,  67, 119 } /* left = tm */
-    }, { /* above = d45 */
-        {  59,  38,  83, 112, 103, 162,  98, 136,  90 } /* left = v */,
-        {  62,  30,  23, 158, 200, 207,  59,  57,  50 } /* left = h */,
-        { 103,  26,  36, 129, 132, 201,  83,  80,  93 } /* left = dc */,
-        {  67,  30,  29,  84,  86, 191, 102,  91,  59 } /* left = d45 */,
-        {  60,  32,  33, 112,  71, 220,  64,  89, 104 } /* left = d135 */,
-        {  53,  26,  34, 130,  56, 149,  84, 120, 103 } /* left = d117 */,
-        {  53,  21,  23, 133, 109, 210,  56,  77, 172 } /* left = d153 */,
-        {  61,  29,  29,  93,  97, 165,  83, 175, 162 } /* left = d63 */,
-        {  77,  19,  29, 112, 142, 228,  55,  66,  36 } /* left = d27 */,
-        {  47,  47,  43, 114, 137, 181, 100,  99,  95 } /* left = tm */
-    }, { /* above = d135 */
-        {  53,  40,  55, 139,  69, 183,  61,  80, 110 } /* left = v */,
-        {  40,  29,  19, 161, 180, 207,  43,  24,  91 } /* left = h */,
-        {  69,  23,  29, 128,  83, 199,  46,  44, 101 } /* left = dc */,
-        {  60,  34,  19, 105,  61, 198,  53,  64,  89 } /* left = d45 */,
-        {  52,  31,  22, 158,  40, 209,  58,  62,  89 } /* left = d135 */,
-        {  44,  31,  29, 147,  46, 158,  56, 102, 198 } /* left = d117 */,
-        {  35,  19,  12, 135,  87, 209,  41,  45, 167 } /* left = d153 */,
-        {  51,  38,  25, 113,  58, 164,  70,  93,  97 } /* left = d63 */,
-        {  55,  25,  21, 118,  95, 215,  38,  39,  66 } /* left = d27 */,
-        {  47,  54,  34, 146, 108, 203,  72, 103, 151 } /* left = tm */
-    }, { /* above = d117 */
-        {  46,  27,  80, 150,  55, 124,  55, 121, 135 } /* left = v */,
-        {  36,  23,  27, 165, 149, 166,  54,  64, 118 } /* left = h */,
-        {  64,  19,  37, 156,  66, 138,  49,  95, 133 } /* left = dc */,
-        {  53,  21,  36, 131,  63, 163,  60, 109,  81 } /* left = d45 */,
-        {  40,  26,  35, 154,  40, 185,  51,  97, 123 } /* left = d135 */,
-        {  35,  19,  34, 179,  19,  97,  48, 129, 124 } /* left = d117 */,
-        {  36,  20,  26, 136,  62, 164,  33,  77, 154 } /* left = d153 */,
-        {  45,  26,  28, 129,  45, 129,  49, 147, 123 } /* left = d63 */,
-        {  45,  18,  32, 130,  90, 157,  40,  79,  91 } /* left = d27 */,
-        {  38,  44,  51, 136,  74, 162,  57,  97, 121 } /* left = tm */
-    }, { /* above = d153 */
-        {  56,  39,  58, 133, 117, 173,  48,  53, 187 } /* left = v */,
-        {  35,  21,  12, 161, 212, 207,  20,  23, 145 } /* left = h */,
-        {  75,  17,  22, 136, 138, 185,  32,  34, 166 } /* left = dc */,
-        {  56,  29,  19, 117, 109, 181,  55,  68, 112 } /* left = d45 */,
-        {  47,  29,  17, 153,  64, 220,  59,  51, 114 } /* left = d135 */,
-        {  46,  16,  24, 136,  76, 147,  41,  64, 172 } /* left = d117 */,
-        {  34,  17,  11, 108, 152, 187,  13,  15, 209 } /* left = d153 */,
-        {  55,  30,  18, 122,  79, 179,  44,  88, 116 } /* left = d63 */,
-        {  51,  24,  14, 115, 133, 209,  32,  26, 104 } /* left = d27 */,
-        {  37,  49,  25, 129, 168, 164,  41,  54, 148 } /* left = tm */
-    }, { /* above = d63 */
-        {  48,  34,  86, 101,  92, 146,  78, 179, 134 } /* left = v */,
-        {  47,  22,  24, 138, 187, 178,  68,  69,  59 } /* left = h */,
-        {  78,  23,  39, 111, 117, 170,  74, 124,  94 } /* left = dc */,
-        {  56,  25,  33, 105, 112, 187,  95, 177, 129 } /* left = d45 */,
-        {  48,  31,  27, 114,  63, 183,  82, 116,  56 } /* left = d135 */,
-        {  43,  28,  37, 121,  63, 123,  61, 192, 169 } /* left = d117 */,
-        {  42,  17,  24, 109,  97, 177,  56,  76, 122 } /* left = d153 */,
-        {  46,  23,  32,  74,  86, 150,  67, 183,  88 } /* left = d63 */,
-        {  58,  18,  28, 105, 139, 182,  70,  92,  63 } /* left = d27 */,
-        {  36,  38,  48,  92, 122, 165,  88, 137,  91 } /* left = tm */
-    }, { /* above = d27 */
-        {  62,  44,  61, 123, 105, 189,  48,  57,  64 } /* left = v */,
-        {  47,  25,  17, 175, 222, 220,  24,  30,  86 } /* left = h */,
-        {  82,  22,  32, 127, 143, 213,  39,  41,  70 } /* left = dc */,
-        {  68,  36,  17, 106, 102, 206,  59,  74,  74 } /* left = d45 */,
-        {  57,  39,  23, 151,  68, 216,  55,  63,  58 } /* left = d135 */,
-        {  49,  30,  35, 141,  70, 168,  82,  40, 115 } /* left = d117 */,
-        {  51,  25,  15, 136, 129, 202,  38,  35, 139 } /* left = d153 */,
-        {  59,  39,  19, 114,  75, 180,  77, 104,  42 } /* left = d63 */,
-        {  68,  26,  16, 111, 141, 215,  29,  28,  28 } /* left = d27 */,
-        {  40,  61,  26, 126, 152, 206,  61,  59,  93 } /* left = tm */
-    }, { /* above = tm */
-        {  44,  78, 115, 132, 119, 173,  71, 112,  93 } /* left = v */,
-        {  39,  38,  21, 184, 227, 206,  42,  32,  64 } /* left = h */,
-        {  65,  70,  60, 155, 159, 199,  61,  60,  81 } /* left = dc */,
-        {  58,  47,  36, 124, 137, 193,  80,  82,  78 } /* left = d45 */,
-        {  49,  50,  35, 144,  95, 205,  63,  78,  59 } /* left = d135 */,
-        {  41,  53,  52, 148,  71, 142,  65, 128,  51 } /* left = d117 */,
-        {  40,  36,  28, 143, 143, 202,  40,  55, 137 } /* left = d153 */,
-        {  42,  44,  44, 104, 105, 164,  64, 130,  80 } /* left = d63 */,
-        {  52,  34,  29, 129, 183, 227,  42,  35,  43 } /* left = d27 */,
-        {  43,  81,  53, 140, 169, 204,  68,  84,  72 } /* left = tm */
-    }
-};
-
-static const uint8_t vp9_default_kf_uvmode_probs[10][9] = {
-    { 118,  15, 123, 148, 131, 101,  44,  93, 131 } /* y = v */,
-    { 113,  12,  23, 188, 226, 142,  26,  32, 125 } /* y = h */,
-    { 144,  11,  54, 157, 195, 130,  46,  58, 108 } /* y = dc */,
-    { 120,  11,  50, 123, 163, 135,  64,  77, 103 } /* y = d45 */,
-    { 113,   9,  36, 155, 111, 157,  32,  44, 161 } /* y = d135 */,
-    { 116,   9,  55, 176,  76,  96,  37,  61, 149 } /* y = d117 */,
-    { 115,   9,  28, 141, 161, 167,  21,  25, 193 } /* y = d153 */,
-    { 116,  12,  64, 120, 140, 125,  49, 115, 121 } /* y = d63 */,
-    { 120,  12,  32, 145, 195, 142,  32,  38,  86 } /* y = d27 */,
-    { 102,  19,  66, 162, 182, 122,  35,  59, 128 } /* y = tm */
-};
-
-static const int8_t vp9_inter_mode_tree[3][2] = {
-    { -ZEROMV, 1 },        // '0'
-     { -NEARESTMV, 2 },    // '10'
-      { -NEARMV, -NEWMV }, // '11x'
-};
-
-static const int8_t vp9_filter_tree[2][2] = {
-    { -0, 1 },   // '0'
-     { -1, -2 }, // '1x'
-};
-
-static const enum FilterMode vp9_filter_lut[3] = {
-    FILTER_8TAP_REGULAR,
-    FILTER_8TAP_SMOOTH,
-    FILTER_8TAP_SHARP,
-};
-
-static const int16_t vp9_dc_qlookup[3][256] = {
-    {
-            4,     8,     8,     9,    10,    11,    12,    12,
-           13,    14,    15,    16,    17,    18,    19,    19,
-           20,    21,    22,    23,    24,    25,    26,    26,
-           27,    28,    29,    30,    31,    32,    32,    33,
-           34,    35,    36,    37,    38,    38,    39,    40,
-           41,    42,    43,    43,    44,    45,    46,    47,
-           48,    48,    49,    50,    51,    52,    53,    53,
-           54,    55,    56,    57,    57,    58,    59,    60,
-           61,    62,    62,    63,    64,    65,    66,    66,
-           67,    68,    69,    70,    70,    71,    72,    73,
-           74,    74,    75,    76,    77,    78,    78,    79,
-           80,    81,    81,    82,    83,    84,    85,    85,
-           87,    88,    90,    92,    93,    95,    96,    98,
-           99,   101,   102,   104,   105,   107,   108,   110,
-          111,   113,   114,   116,   117,   118,   120,   121,
-          123,   125,   127,   129,   131,   134,   136,   138,
-          140,   142,   144,   146,   148,   150,   152,   154,
-          156,   158,   161,   164,   166,   169,   172,   174,
-          177,   180,   182,   185,   187,   190,   192,   195,
-          199,   202,   205,   208,   211,   214,   217,   220,
-          223,   226,   230,   233,   237,   240,   243,   247,
-          250,   253,   257,   261,   265,   269,   272,   276,
-          280,   284,   288,   292,   296,   300,   304,   309,
-          313,   317,   322,   326,   330,   335,   340,   344,
-          349,   354,   359,   364,   369,   374,   379,   384,
-          389,   395,   400,   406,   411,   417,   423,   429,
-          435,   441,   447,   454,   461,   467,   475,   482,
-          489,   497,   505,   513,   522,   530,   539,   549,
-          559,   569,   579,   590,   602,   614,   626,   640,
-          654,   668,   684,   700,   717,   736,   755,   775,
-          796,   819,   843,   869,   896,   925,   955,   988,
-         1022,  1058,  1098,  1139,  1184,  1232,  1282,  1336,
-    }, {
-            4,     9,    10,    13,    15,    17,    20,    22,
-           25,    28,    31,    34,    37,    40,    43,    47,
-           50,    53,    57,    60,    64,    68,    71,    75,
-           78,    82,    86,    90,    93,    97,   101,   105,
-          109,   113,   116,   120,   124,   128,   132,   136,
-          140,   143,   147,   151,   155,   159,   163,   166,
-          170,   174,   178,   182,   185,   189,   193,   197,
-          200,   204,   208,   212,   215,   219,   223,   226,
-          230,   233,   237,   241,   244,   248,   251,   255,
-          259,   262,   266,   269,   273,   276,   280,   283,
-          287,   290,   293,   297,   300,   304,   307,   310,
-          314,   317,   321,   324,   327,   331,   334,   337,
-          343,   350,   356,   362,   369,   375,   381,   387,
-          394,   400,   406,   412,   418,   424,   430,   436,
-          442,   448,   454,   460,   466,   472,   478,   484,
-          490,   499,   507,   516,   525,   533,   542,   550,
-          559,   567,   576,   584,   592,   601,   609,   617,
-          625,   634,   644,   655,   666,   676,   687,   698,
-          708,   718,   729,   739,   749,   759,   770,   782,
-          795,   807,   819,   831,   844,   856,   868,   880,
-          891,   906,   920,   933,   947,   961,   975,   988,
-         1001,  1015,  1030,  1045,  1061,  1076,  1090,  1105,
-         1120,  1137,  1153,  1170,  1186,  1202,  1218,  1236,
-         1253,  1271,  1288,  1306,  1323,  1342,  1361,  1379,
-         1398,  1416,  1436,  1456,  1476,  1496,  1516,  1537,
-         1559,  1580,  1601,  1624,  1647,  1670,  1692,  1717,
-         1741,  1766,  1791,  1817,  1844,  1871,  1900,  1929,
-         1958,  1990,  2021,  2054,  2088,  2123,  2159,  2197,
-         2236,  2276,  2319,  2363,  2410,  2458,  2508,  2561,
-         2616,  2675,  2737,  2802,  2871,  2944,  3020,  3102,
-         3188,  3280,  3375,  3478,  3586,  3702,  3823,  3953,
-         4089,  4236,  4394,  4559,  4737,  4929,  5130,  5347,
-    }, {
-            4,    12,    18,    25,    33,    41,    50,    60,
-           70,    80,    91,   103,   115,   127,   140,   153,
-          166,   180,   194,   208,   222,   237,   251,   266,
-          281,   296,   312,   327,   343,   358,   374,   390,
-          405,   421,   437,   453,   469,   484,   500,   516,
-          532,   548,   564,   580,   596,   611,   627,   643,
-          659,   674,   690,   706,   721,   737,   752,   768,
-          783,   798,   814,   829,   844,   859,   874,   889,
-          904,   919,   934,   949,   964,   978,   993,  1008,
-         1022,  1037,  1051,  1065,  1080,  1094,  1108,  1122,
-         1136,  1151,  1165,  1179,  1192,  1206,  1220,  1234,
-         1248,  1261,  1275,  1288,  1302,  1315,  1329,  1342,
-         1368,  1393,  1419,  1444,  1469,  1494,  1519,  1544,
-         1569,  1594,  1618,  1643,  1668,  1692,  1717,  1741,
-         1765,  1789,  1814,  1838,  1862,  1885,  1909,  1933,
-         1957,  1992,  2027,  2061,  2096,  2130,  2165,  2199,
-         2233,  2267,  2300,  2334,  2367,  2400,  2434,  2467,
-         2499,  2532,  2575,  2618,  2661,  2704,  2746,  2788,
-         2830,  2872,  2913,  2954,  2995,  3036,  3076,  3127,
-         3177,  3226,  3275,  3324,  3373,  3421,  3469,  3517,
-         3565,  3621,  3677,  3733,  3788,  3843,  3897,  3951,
-         4005,  4058,  4119,  4181,  4241,  4301,  4361,  4420,
-         4479,  4546,  4612,  4677,  4742,  4807,  4871,  4942,
-         5013,  5083,  5153,  5222,  5291,  5367,  5442,  5517,
-         5591,  5665,  5745,  5825,  5905,  5984,  6063,  6149,
-         6234,  6319,  6404,  6495,  6587,  6678,  6769,  6867,
-         6966,  7064,  7163,  7269,  7376,  7483,  7599,  7715,
-         7832,  7958,  8085,  8214,  8352,  8492,  8635,  8788,
-         8945,  9104,  9275,  9450,  9639,  9832, 10031, 10245,
-        10465, 10702, 10946, 11210, 11482, 11776, 12081, 12409,
-        12750, 13118, 13501, 13913, 14343, 14807, 15290, 15812,
-        16356, 16943, 17575, 18237, 18949, 19718, 20521, 21387,
-    }
-};
-
-static const int16_t vp9_ac_qlookup[3][256] = {
-    {
-            4,     8,     9,    10,    11,    12,    13,    14,
-           15,    16,    17,    18,    19,    20,    21,    22,
-           23,    24,    25,    26,    27,    28,    29,    30,
-           31,    32,    33,    34,    35,    36,    37,    38,
-           39,    40,    41,    42,    43,    44,    45,    46,
-           47,    48,    49,    50,    51,    52,    53,    54,
-           55,    56,    57,    58,    59,    60,    61,    62,
-           63,    64,    65,    66,    67,    68,    69,    70,
-           71,    72,    73,    74,    75,    76,    77,    78,
-           79,    80,    81,    82,    83,    84,    85,    86,
-           87,    88,    89,    90,    91,    92,    93,    94,
-           95,    96,    97,    98,    99,   100,   101,   102,
-          104,   106,   108,   110,   112,   114,   116,   118,
-          120,   122,   124,   126,   128,   130,   132,   134,
-          136,   138,   140,   142,   144,   146,   148,   150,
-          152,   155,   158,   161,   164,   167,   170,   173,
-          176,   179,   182,   185,   188,   191,   194,   197,
-          200,   203,   207,   211,   215,   219,   223,   227,
-          231,   235,   239,   243,   247,   251,   255,   260,
-          265,   270,   275,   280,   285,   290,   295,   300,
-          305,   311,   317,   323,   329,   335,   341,   347,
-          353,   359,   366,   373,   380,   387,   394,   401,
-          408,   416,   424,   432,   440,   448,   456,   465,
-          474,   483,   492,   501,   510,   520,   530,   540,
-          550,   560,   571,   582,   593,   604,   615,   627,
-          639,   651,   663,   676,   689,   702,   715,   729,
-          743,   757,   771,   786,   801,   816,   832,   848,
-          864,   881,   898,   915,   933,   951,   969,   988,
-         1007,  1026,  1046,  1066,  1087,  1108,  1129,  1151,
-         1173,  1196,  1219,  1243,  1267,  1292,  1317,  1343,
-         1369,  1396,  1423,  1451,  1479,  1508,  1537,  1567,
-         1597,  1628,  1660,  1692,  1725,  1759,  1793,  1828,
-    }, {
-            4,     9,    11,    13,    16,    18,    21,    24,
-           27,    30,    33,    37,    40,    44,    48,    51,
-           55,    59,    63,    67,    71,    75,    79,    83,
-           88,    92,    96,   100,   105,   109,   114,   118,
-          122,   127,   131,   136,   140,   145,   149,   154,
-          158,   163,   168,   172,   177,   181,   186,   190,
-          195,   199,   204,   208,   213,   217,   222,   226,
-          231,   235,   240,   244,   249,   253,   258,   262,
-          267,   271,   275,   280,   284,   289,   293,   297,
-          302,   306,   311,   315,   319,   324,   328,   332,
-          337,   341,   345,   349,   354,   358,   362,   367,
-          371,   375,   379,   384,   388,   392,   396,   401,
-          409,   417,   425,   433,   441,   449,   458,   466,
-          474,   482,   490,   498,   506,   514,   523,   531,
-          539,   547,   555,   563,   571,   579,   588,   596,
-          604,   616,   628,   640,   652,   664,   676,   688,
-          700,   713,   725,   737,   749,   761,   773,   785,
-          797,   809,   825,   841,   857,   873,   889,   905,
-          922,   938,   954,   970,   986,  1002,  1018,  1038,
-         1058,  1078,  1098,  1118,  1138,  1158,  1178,  1198,
-         1218,  1242,  1266,  1290,  1314,  1338,  1362,  1386,
-         1411,  1435,  1463,  1491,  1519,  1547,  1575,  1603,
-         1631,  1663,  1695,  1727,  1759,  1791,  1823,  1859,
-         1895,  1931,  1967,  2003,  2039,  2079,  2119,  2159,
-         2199,  2239,  2283,  2327,  2371,  2415,  2459,  2507,
-         2555,  2603,  2651,  2703,  2755,  2807,  2859,  2915,
-         2971,  3027,  3083,  3143,  3203,  3263,  3327,  3391,
-         3455,  3523,  3591,  3659,  3731,  3803,  3876,  3952,
-         4028,  4104,  4184,  4264,  4348,  4432,  4516,  4604,
-         4692,  4784,  4876,  4972,  5068,  5168,  5268,  5372,
-         5476,  5584,  5692,  5804,  5916,  6032,  6148,  6268,
-         6388,  6512,  6640,  6768,  6900,  7036,  7172,  7312,
-    }, {
-            4,    13,    19,    27,    35,    44,    54,    64,
-           75,    87,    99,   112,   126,   139,   154,   168,
-          183,   199,   214,   230,   247,   263,   280,   297,
-          314,   331,   349,   366,   384,   402,   420,   438,
-          456,   475,   493,   511,   530,   548,   567,   586,
-          604,   623,   642,   660,   679,   698,   716,   735,
-          753,   772,   791,   809,   828,   846,   865,   884,
-          902,   920,   939,   957,   976,   994,  1012,  1030,
-         1049,  1067,  1085,  1103,  1121,  1139,  1157,  1175,
-         1193,  1211,  1229,  1246,  1264,  1282,  1299,  1317,
-         1335,  1352,  1370,  1387,  1405,  1422,  1440,  1457,
-         1474,  1491,  1509,  1526,  1543,  1560,  1577,  1595,
-         1627,  1660,  1693,  1725,  1758,  1791,  1824,  1856,
-         1889,  1922,  1954,  1987,  2020,  2052,  2085,  2118,
-         2150,  2183,  2216,  2248,  2281,  2313,  2346,  2378,
-         2411,  2459,  2508,  2556,  2605,  2653,  2701,  2750,
-         2798,  2847,  2895,  2943,  2992,  3040,  3088,  3137,
-         3185,  3234,  3298,  3362,  3426,  3491,  3555,  3619,
-         3684,  3748,  3812,  3876,  3941,  4005,  4069,  4149,
-         4230,  4310,  4390,  4470,  4550,  4631,  4711,  4791,
-         4871,  4967,  5064,  5160,  5256,  5352,  5448,  5544,
-         5641,  5737,  5849,  5961,  6073,  6185,  6297,  6410,
-         6522,  6650,  6778,  6906,  7034,  7162,  7290,  7435,
-         7579,  7723,  7867,  8011,  8155,  8315,  8475,  8635,
-         8795,  8956,  9132,  9308,  9484,  9660,  9836, 10028,
-        10220, 10412, 10604, 10812, 11020, 11228, 11437, 11661,
-        11885, 12109, 12333, 12573, 12813, 13053, 13309, 13565,
-        13821, 14093, 14365, 14637, 14925, 15213, 15502, 15806,
-        16110, 16414, 16734, 17054, 17390, 17726, 18062, 18414,
-        18766, 19134, 19502, 19886, 20270, 20670, 21070, 21486,
-        21902, 22334, 22766, 23214, 23662, 24126, 24590, 25070,
-        25551, 26047, 26559, 27071, 27599, 28143, 28687, 29247,
-    }
-};
-
-static const enum TxfmType vp9_intra_txfm_type[14] = {
-    [VERT_PRED]            = ADST_DCT,
-    [HOR_PRED]             = DCT_ADST,
-    [DC_PRED]              = DCT_DCT,
-    [DIAG_DOWN_LEFT_PRED]  = DCT_DCT,
-    [DIAG_DOWN_RIGHT_PRED] = ADST_ADST,
-    [VERT_RIGHT_PRED]      = ADST_DCT,
-    [HOR_DOWN_PRED]        = DCT_ADST,
-    [VERT_LEFT_PRED]       = ADST_DCT,
-    [HOR_UP_PRED]          = DCT_ADST,
-    [TM_VP8_PRED]          = ADST_ADST,
-    [NEARESTMV]            = DCT_DCT,
-    [NEARMV]               = DCT_DCT,
-    [ZEROMV]               = DCT_DCT,
-    [NEWMV]                = DCT_DCT,
-};
-
-static const int16_t vp9_default_scan_4x4[16] = {
-     0,  1,  4,  5,
-     2,  8,  3,  6,
-    12,  9,  7, 10,
-    13, 11, 14, 15,
-};
-
-static const int16_t vp9_col_scan_4x4[16] = {
-     0,  1,  2,  4,
-     3,  5,  6,  8,
-     7,  9, 10, 12,
-    13, 11, 14, 15,
-};
-
-static const int16_t vp9_row_scan_4x4[16] = {
-     0,  4,  1,  8,
-     5, 12,  9,  2,
-     6, 13,  3, 10,
-     7, 14, 11, 15,
-};
-
-static const int16_t vp9_default_scan_8x8[64] = {
-     0,  1,  8,  2,  9, 16, 10,  3,
-    17, 24, 18, 11,  4, 25, 32, 19,
-    12, 26,  5, 33, 20, 27, 40, 13,
-    34,  6, 41, 28, 21, 35, 42, 48,
-    14,  7, 36, 29, 43, 56, 49, 22,
-    15, 37, 50, 44, 57, 30, 23, 51,
-    45, 58, 38, 31, 52, 59, 39, 46,
-    53, 60, 47, 54, 61, 55, 62, 63,
-};
-
-static const int16_t vp9_col_scan_8x8[64] = {
-     0,  1,  2,  8,  3,  9,  4, 10,
-    16,  5, 11, 17, 12, 18,  6, 24,
-    19, 13, 25,  7, 26, 20, 32, 14,
-    27, 21, 33, 28, 34, 15, 22, 35,
-    40, 29, 41, 36, 23, 30, 42, 37,
-    48, 43, 31, 44, 49, 38, 50, 56,
-    45, 39, 51, 57, 52, 46, 58, 53,
-    59, 47, 60, 54, 61, 55, 62, 63,
-};
-
-static const int16_t vp9_row_scan_8x8[64] = {
-     0,  8, 16,  1,  9, 24,  2, 17,
-    32, 10, 25,  3, 40, 18, 11, 33,
-    26, 19,  4, 48, 41, 34, 12, 27,
-    56, 20,  5, 42, 35, 13, 49, 28,
-     6, 21, 43, 36, 14, 50, 29, 57,
-     7, 44, 22, 37, 51, 15, 58, 30,
-    23, 45, 52, 38, 59, 31, 46, 53,
-    39, 60, 47, 61, 54, 62, 55, 63,
-};
-
-static const int16_t vp9_default_scan_16x16[256] = {
-      0,   1,  16,   2,  17,  32,   3,  18,  33,  48,   4,  34,  19,  49,  20,   5,
-     35,  64,  50,  36,  65,  21,   6,  51,  80,  66,  37,  22,  52,   7,  81,  67,
-     38,  82,  53,  23,  96,  68,   8,  83,  97,  54,  39,  69, 112,  24,  98,  84,
-     70,  55,   9,  40,  85,  99, 113, 128,  25, 114, 100,  71,  86,  56,  10,  41,
-    115, 101, 129, 116,  72,  87,  26, 130, 144, 102,  57,  11,  42, 117, 131, 145,
-     88, 103,  27,  73, 132, 118, 146,  58, 160,  12,  43, 133, 147, 104,  89, 119,
-    161,  74, 148, 134,  28, 162,  59,  13, 176, 120, 149,  90, 135, 105, 163,  44,
-     75, 177, 164,  29, 150, 121, 136, 178, 165,  14, 106,  60,  91, 151,  45, 179,
-    192, 137, 166, 122,  76, 180, 152,  30,  61,  15, 107, 167, 181, 193,  92, 208,
-     46, 138, 123, 153, 194,  77, 168, 182,  31, 195, 209, 183, 108, 139,  62, 154,
-     47, 196,  93, 169, 210, 197, 224, 124, 184, 211,  78, 109, 170, 155,  63, 198,
-    212, 185, 225, 240, 140,  94, 199, 125,  79, 213, 226, 171, 186, 156, 214, 200,
-    110, 227, 141,  95, 241, 215, 228, 201, 126, 242, 187, 172, 157, 229, 111, 216,
-    243, 142, 202, 230, 127, 217, 244, 173, 188, 231, 158, 203, 143, 245, 218, 232,
-    189, 246, 159, 174, 233, 247, 219, 204, 175, 190, 248, 234, 205, 220, 249, 191,
-    235, 221, 250, 206, 222, 251, 236, 207, 237, 223, 252, 238, 253, 239, 254, 255,
-};
-
-static const int16_t vp9_col_scan_16x16[256] = {
-      0,   1,   2,   3,  16,   4,  17,   5,  18,   6,  19,  32,  20,   7,  33,  21,
-     34,   8,  35,  22,  48,  36,   9,  49,  23,  50,  37,  10,  38,  51,  24,  64,
-     52,  11,  65,  39,  25,  53,  66,  54,  40,  67,  12,  80,  26,  68,  55,  81,
-     41,  69,  13,  27,  82,  56,  70,  83,  42,  14,  84,  96,  71,  28,  57,  85,
-     97,  15,  72,  98,  43,  86,  58,  99,  29,  87, 100, 112,  73,  44, 101,  59,
-     30, 113,  88, 114,  74, 128, 102,  45,  31, 115,  60, 103,  89, 116,  75, 129,
-    117,  46, 104,  90,  61, 130, 118, 131, 132, 105,  76,  47, 119, 144,  91,  62,
-    133, 106, 145, 120, 146, 134,  77, 147, 121,  92, 135, 148,  63, 107, 136, 122,
-     93, 149, 160,  78, 150, 137, 108, 161, 162, 151, 123,  79, 138, 163, 152,  94,
-    164, 109, 165, 153, 124, 139, 176, 166,  95, 177, 167, 110, 154, 178, 125, 179,
-    140, 168, 155, 111, 180, 192, 181, 169, 141, 126, 182, 193, 194, 156, 183, 170,
-    195, 127, 142, 196, 184, 208, 197, 157, 171, 143, 185, 198, 209, 199, 210, 172,
-    158, 186, 211, 224, 212, 200, 240, 159, 213, 225, 187, 201, 173, 226, 214, 215,
-    227, 202, 228, 188, 241, 216, 174, 229, 242, 203, 243, 217, 230, 175, 189, 244,
-    231, 204, 218, 232, 245, 219, 246, 190, 233, 205, 191, 247, 234, 248, 220, 206,
-    249, 235, 221, 207, 250, 236, 222, 251, 223, 237, 238, 252, 239, 253, 254, 255,
-};
-
-static const int16_t vp9_row_scan_16x16[256] = {
-      0,  16,  32,   1,  48,  17,  64,  33,   2,  80,  18,  49,  96,  34,   3,  65,
-     19, 112,  50,  81,  35,   4, 128,  66,  20,  97,  51,  82,   5, 144,  36,  67,
-    113,  98,  21,  52, 160,  83, 129,  37,  68,   6, 114, 176,  99,  53,  22,  84,
-    145,  38,  69, 130,   7, 115, 192, 100,  54,  23,  85, 161, 146, 131,  39,  70,
-    208, 116,   8, 101, 177,  55,  86,  24, 162, 147, 132,  71, 224, 117,  40, 102,
-      9, 148,  56,  87, 193, 163, 240, 133, 178,  25, 118,  72,  41, 103, 164,  10,
-    149,  88, 134, 209, 179,  57, 119, 194,  26,  73, 165, 150, 104,  42, 135,  11,
-    180, 120,  89, 225, 195,  58,  27, 210, 151, 181, 166,  74,  43, 105,  12, 136,
-     90,  59, 241, 121,  28, 196, 167, 211, 152,  44, 182, 137,  75,  13, 226, 106,
-    122,  60, 197,  91, 168,  29, 183, 153,  14,  76, 212, 138,  45, 107,  15, 198,
-     92, 227, 169,  30, 123, 154,  61, 242, 184, 213, 139,  46,  77,  31, 108, 170,
-    199, 185, 124, 228,  93, 155, 214,  62, 140, 243,  78,  47, 200, 109, 186, 171,
-    201,  94,  63, 215, 229, 156,  79, 125, 141, 110, 216, 187, 172, 244, 202, 230,
-    217,  95, 157, 126, 245, 111, 142, 231, 188, 127, 158, 218, 173, 232, 246, 233,
-    203, 143, 247, 174, 189, 159, 219, 204, 248, 234, 249, 175, 190, 220, 205, 250,
-    235, 191, 221, 251, 236, 206, 252, 222, 207, 237, 223, 253, 238, 254, 239, 255,
-};
-
-static const int16_t vp9_default_scan_32x32[1024] = {
-       0,    1,   32,    2,   33,   64,    3,   34,   65,    4,   96,   35,   66,    5,   36,   97,   67,  128,   98,   68,   37,    6,  129,   99,    7,  160,   69,   38,  130,  100,  161,  131,
-      39,   70,    8,  101,  162,  132,  192,   71,   40,    9,  102,  163,  133,  193,   72,  224,  103,   41,  164,   10,  194,  134,  165,   73,  104,  135,  225,   42,  195,   11,  256,  166,
-     226,  196,   74,  105,  136,   43,   12,  167,  197,  227,  257,   75,  106,  137,  228,   44,  198,  168,  258,  288,   13,  229,   76,  107,  199,  138,  259,  169,  289,   45,  230,  260,
-     200,  108,   14,  170,  139,  320,  290,   77,  231,  261,   46,  201,  140,  291,  109,  232,  321,  262,  171,   78,  292,   15,  322,  202,  263,  352,  172,  293,  233,  141,  323,  110,
-      47,  203,  264,  234,  294,  353,  324,   16,   79,  204,  265,  295,  325,  173,  354,  142,  235,  384,   48,  296,  111,  266,  355,  326,   80,   17,  205,  236,  174,  356,  385,  327,
-     143,  297,  267,  357,  386,  112,   49,  328,  298,  206,  416,  237,  358,  387,   81,  175,   18,  329,  359,  388,  299,  330,  389,  113,  417,  238,  360,   50,  207,  418,  390,  331,
-      19,  448,  361,   82,  419,  391,  239,   51,  362,  420,  114,  449,  480,  421,   83,  363,  450,  422,  512,  451,  423,  115,  452,  481,  453,  482,  454,  544,  483,  455,  513,  484,
-     514,  485,  515,  486,  545,  576,  487,  546,  547,  608,  577,  578,  579,  609,  610,  611,   20,  144,  268,  392,  516,  640,   21,   52,  145,  176,  269,  300,  393,  424,  517,  548,
-     641,  672,   22,   53,   84,  146,  177,  208,  270,  301,  332,  394,  425,  456,  518,  549,  580,  642,  673,  704,   23,   54,   85,  116,  147,  178,  209,  240,  271,  302,  333,  364,
-     395,  426,  457,  488,  519,  550,  581,  612,  643,  674,  705,  736,   55,   86,  117,  179,  210,  241,  303,  334,  365,  427,  458,  489,  551,  582,  613,  675,  706,  737,   87,  118,
-     211,  242,  335,  366,  459,  490,  583,  614,  707,  738,  119,  243,  367,  491,  615,  739,   24,  148,  272,  396,  520,  644,  768,   25,   56,  149,  180,  273,  304,  397,  428,  521,
-     552,  645,  676,  769,  800,   26,   57,   88,  150,  181,  212,  274,  305,  336,  398,  429,  460,  522,  553,  584,  646,  677,  708,  770,  801,  832,   27,   58,   89,  120,  151,  182,
-     213,  244,  275,  306,  337,  368,  399,  430,  461,  492,  523,  554,  585,  616,  647,  678,  709,  740,  771,  802,  833,  864,   59,   90,  121,  183,  214,  245,  307,  338,  369,  431,
-     462,  493,  555,  586,  617,  679,  710,  741,  803,  834,  865,   91,  122,  215,  246,  339,  370,  463,  494,  587,  618,  711,  742,  835,  866,  123,  247,  371,  495,  619,  743,  867,
-      28,  152,  276,  400,  524,  648,  772,  896,   29,   60,  153,  184,  277,  308,  401,  432,  525,  556,  649,  680,  773,  804,  897,  928,   30,   61,   92,  154,  185,  216,  278,  309,
-     340,  402,  433,  464,  526,  557,  588,  650,  681,  712,  774,  805,  836,  898,  929,  960,   31,   62,   93,  124,  155,  186,  217,  248,  279,  310,  341,  372,  403,  434,  465,  496,
-     527,  558,  589,  620,  651,  682,  713,  744,  775,  806,  837,  868,  899,  930,  961,  992,   63,   94,  125,  187,  218,  249,  311,  342,  373,  435,  466,  497,  559,  590,  621,  683,
-     714,  745,  807,  838,  869,  931,  962,  993,   95,  126,  219,  250,  343,  374,  467,  498,  591,  622,  715,  746,  839,  870,  963,  994,  127,  251,  375,  499,  623,  747,  871,  995,
-     156,  280,  404,  528,  652,  776,  900,  157,  188,  281,  312,  405,  436,  529,  560,  653,  684,  777,  808,  901,  932,  158,  189,  220,  282,  313,  344,  406,  437,  468,  530,  561,
-     592,  654,  685,  716,  778,  809,  840,  902,  933,  964,  159,  190,  221,  252,  283,  314,  345,  376,  407,  438,  469,  500,  531,  562,  593,  624,  655,  686,  717,  748,  779,  810,
-     841,  872,  903,  934,  965,  996,  191,  222,  253,  315,  346,  377,  439,  470,  501,  563,  594,  625,  687,  718,  749,  811,  842,  873,  935,  966,  997,  223,  254,  347,  378,  471,
-     502,  595,  626,  719,  750,  843,  874,  967,  998,  255,  379,  503,  627,  751,  875,  999,  284,  408,  532,  656,  780,  904,  285,  316,  409,  440,  533,  564,  657,  688,  781,  812,
-     905,  936,  286,  317,  348,  410,  441,  472,  534,  565,  596,  658,  689,  720,  782,  813,  844,  906,  937,  968,  287,  318,  349,  380,  411,  442,  473,  504,  535,  566,  597,  628,
-     659,  690,  721,  752,  783,  814,  845,  876,  907,  938,  969, 1000,  319,  350,  381,  443,  474,  505,  567,  598,  629,  691,  722,  753,  815,  846,  877,  939,  970, 1001,  351,  382,
-     475,  506,  599,  630,  723,  754,  847,  878,  971, 1002,  383,  507,  631,  755,  879, 1003,  412,  536,  660,  784,  908,  413,  444,  537,  568,  661,  692,  785,  816,  909,  940,  414,
-     445,  476,  538,  569,  600,  662,  693,  724,  786,  817,  848,  910,  941,  972,  415,  446,  477,  508,  539,  570,  601,  632,  663,  694,  725,  756,  787,  818,  849,  880,  911,  942,
-     973, 1004,  447,  478,  509,  571,  602,  633,  695,  726,  757,  819,  850,  881,  943,  974, 1005,  479,  510,  603,  634,  727,  758,  851,  882,  975, 1006,  511,  635,  759,  883, 1007,
-     540,  664,  788,  912,  541,  572,  665,  696,  789,  820,  913,  944,  542,  573,  604,  666,  697,  728,  790,  821,  852,  914,  945,  976,  543,  574,  605,  636,  667,  698,  729,  760,
-     791,  822,  853,  884,  915,  946,  977, 1008,  575,  606,  637,  699,  730,  761,  823,  854,  885,  947,  978, 1009,  607,  638,  731,  762,  855,  886,  979, 1010,  639,  763,  887, 1011,
-     668,  792,  916,  669,  700,  793,  824,  917,  948,  670,  701,  732,  794,  825,  856,  918,  949,  980,  671,  702,  733,  764,  795,  826,  857,  888,  919,  950,  981, 1012,  703,  734,
-     765,  827,  858,  889,  951,  982, 1013,  735,  766,  859,  890,  983, 1014,  767,  891, 1015,  796,  920,  797,  828,  921,  952,  798,  829,  860,  922,  953,  984,  799,  830,  861,  892,
-     923,  954,  985, 1016,  831,  862,  893,  955,  986, 1017,  863,  894,  987, 1018,  895, 1019,  924,  925,  956,  926,  957,  988,  927,  958,  989, 1020,  959,  990, 1021,  991, 1022, 1023,
-};
-
-static const int16_t * const vp9_scans[5][4] = {
-    {
-        vp9_default_scan_4x4, vp9_col_scan_4x4,
-        vp9_row_scan_4x4, vp9_default_scan_4x4
-    }, {
-        vp9_default_scan_8x8, vp9_col_scan_8x8,
-        vp9_row_scan_8x8, vp9_default_scan_8x8
-    }, {
-        vp9_default_scan_16x16, vp9_col_scan_16x16,
-        vp9_row_scan_16x16, vp9_default_scan_16x16
-    }, {
-        vp9_default_scan_32x32, vp9_default_scan_32x32,
-        vp9_default_scan_32x32, vp9_default_scan_32x32
-    }, { // lossless
-        vp9_default_scan_4x4, vp9_default_scan_4x4,
-        vp9_default_scan_4x4, vp9_default_scan_4x4
-    }
-};
-
-static const int16_t vp9_default_scan_4x4_nb[16][2] = {
-    {  0,  0 }, {  0,  0 }, {  4,  1 }, {  1,  1 },
-    {  4,  4 }, {  2,  2 }, {  5,  2 }, {  8,  8 },
-    {  8,  5 }, {  6,  3 }, {  9,  6 }, { 12,  9 },
-    { 10,  7 }, { 13, 10 }, { 14, 11 }, {  0,  0 },
-};
-
-static const int16_t vp9_col_scan_4x4_nb[16][2] = {
-    {  0,  0 }, {  1,  1 }, {  0,  0 }, {  2,  2 },
-    {  4,  4 }, {  5,  5 }, {  4,  4 }, {  6,  6 },
-    {  8,  8 }, {  9,  9 }, {  8,  8 }, { 12, 12 },
-    { 10, 10 }, { 13, 13 }, { 14, 14 }, {  0,  0 },
-};
-
-static const int16_t vp9_row_scan_4x4_nb[16][2] = {
-    {  0,  0 }, {  0,  0 }, {  4,  4 }, {  1,  1 },
-    {  8,  8 }, {  5,  5 }, {  1,  1 }, {  2,  2 },
-    {  9,  9 }, {  2,  2 }, {  6,  6 }, {  3,  3 },
-    { 10, 10 }, {  7,  7 }, { 11, 11 }, {  0,  0 },
-};
-
-static const int16_t vp9_default_scan_8x8_nb[64][2] = {
-    {  0,  0 }, {  0,  0 }, {  1,  1 }, {  8,  1 },
-    {  8,  8 }, {  9,  2 }, {  2,  2 }, { 16,  9 },
-    { 16, 16 }, { 17, 10 }, { 10,  3 }, {  3,  3 },
-    { 24, 17 }, { 24, 24 }, { 18, 11 }, { 11,  4 },
-    { 25, 18 }, {  4,  4 }, { 32, 25 }, { 19, 12 },
-    { 26, 19 }, { 32, 32 }, { 12,  5 }, { 33, 26 },
-    {  5,  5 }, { 40, 33 }, { 27, 20 }, { 20, 13 },
-    { 34, 27 }, { 41, 34 }, { 40, 40 }, { 13,  6 },
-    {  6,  6 }, { 35, 28 }, { 28, 21 }, { 42, 35 },
-    { 48, 48 }, { 48, 41 }, { 21, 14 }, { 14,  7 },
-    { 36, 29 }, { 49, 42 }, { 43, 36 }, { 56, 49 },
-    { 29, 22 }, { 22, 15 }, { 50, 43 }, { 44, 37 },
-    { 57, 50 }, { 37, 30 }, { 30, 23 }, { 51, 44 },
-    { 58, 51 }, { 38, 31 }, { 45, 38 }, { 52, 45 },
-    { 59, 52 }, { 46, 39 }, { 53, 46 }, { 60, 53 },
-    { 54, 47 }, { 61, 54 }, { 62, 55 }, {  0,  0 },
-};
-
-static const int16_t vp9_col_scan_8x8_nb[64][2] = {
-    {  0,  0 }, {  1,  1 }, {  0,  0 }, {  2,  2 },
-    {  8,  8 }, {  3,  3 }, {  9,  9 }, {  8,  8 },
-    {  4,  4 }, { 10, 10 }, { 16, 16 }, { 11, 11 },
-    { 17, 17 }, {  5,  5 }, { 16, 16 }, { 18, 18 },
-    { 12, 12 }, { 24, 24 }, {  6,  6 }, { 25, 25 },
-    { 19, 19 }, { 24, 24 }, { 13, 13 }, { 26, 26 },
-    { 20, 20 }, { 32, 32 }, { 27, 27 }, { 33, 33 },
-    { 14, 14 }, { 21, 21 }, { 34, 34 }, { 32, 32 },
-    { 28, 28 }, { 40, 40 }, { 35, 35 }, { 22, 22 },
-    { 29, 29 }, { 41, 41 }, { 36, 36 }, { 40, 40 },
-    { 42, 42 }, { 30, 30 }, { 43, 43 }, { 48, 48 },
-    { 37, 37 }, { 49, 49 }, { 48, 48 }, { 44, 44 },
-    { 38, 38 }, { 50, 50 }, { 56, 56 }, { 51, 51 },
-    { 45, 45 }, { 57, 57 }, { 52, 52 }, { 58, 58 },
-    { 46, 46 }, { 59, 59 }, { 53, 53 }, { 60, 60 },
-    { 54, 54 }, { 61, 61 }, { 62, 62 }, {  0,  0 },
-};
-
-static const int16_t vp9_row_scan_8x8_nb[64][2] = {
-    {  0,  0 }, {  8,  8 }, {  0,  0 }, {  1,  1 },
-    { 16, 16 }, {  1,  1 }, {  9,  9 }, { 24, 24 },
-    {  2,  2 }, { 17, 17 }, {  2,  2 }, { 32, 32 },
-    { 10, 10 }, {  3,  3 }, { 25, 25 }, { 18, 18 },
-    { 11, 11 }, {  3,  3 }, { 40, 40 }, { 33, 33 },
-    { 26, 26 }, {  4,  4 }, { 19, 19 }, { 48, 48 },
-    { 12, 12 }, {  4,  4 }, { 34, 34 }, { 27, 27 },
-    {  5,  5 }, { 41, 41 }, { 20, 20 }, {  5,  5 },
-    { 13, 13 }, { 35, 35 }, { 28, 28 }, {  6,  6 },
-    { 42, 42 }, { 21, 21 }, { 49, 49 }, {  6,  6 },
-    { 36, 36 }, { 14, 14 }, { 29, 29 }, { 43, 43 },
-    {  7,  7 }, { 50, 50 }, { 22, 22 }, { 15, 15 },
-    { 37, 37 }, { 44, 44 }, { 30, 30 }, { 51, 51 },
-    { 23, 23 }, { 38, 38 }, { 45, 45 }, { 31, 31 },
-    { 52, 52 }, { 39, 39 }, { 53, 53 }, { 46, 46 },
-    { 54, 54 }, { 47, 47 }, { 55, 55 }, {  0,  0 },
-};
-
-static const int16_t vp9_default_scan_16x16_nb[256][2] = {
-    {   0,   0 }, {   0,   0 }, {   1,   1 }, {  16,   1 },
-    {  16,  16 }, {   2,   2 }, {  17,   2 }, {  32,  17 },
-    {  32,  32 }, {   3,   3 }, {  33,  18 }, {  18,   3 },
-    {  48,  33 }, {  19,   4 }, {   4,   4 }, {  34,  19 },
-    {  48,  48 }, {  49,  34 }, {  35,  20 }, {  64,  49 },
-    {  20,   5 }, {   5,   5 }, {  50,  35 }, {  64,  64 },
-    {  65,  50 }, {  36,  21 }, {  21,   6 }, {  51,  36 },
-    {   6,   6 }, {  80,  65 }, {  66,  51 }, {  37,  22 },
-    {  81,  66 }, {  52,  37 }, {  22,   7 }, {  80,  80 },
-    {  67,  52 }, {   7,   7 }, {  82,  67 }, {  96,  81 },
-    {  53,  38 }, {  38,  23 }, {  68,  53 }, {  96,  96 },
-    {  23,   8 }, {  97,  82 }, {  83,  68 }, {  69,  54 },
-    {  54,  39 }, {   8,   8 }, {  39,  24 }, {  84,  69 },
-    {  98,  83 }, { 112,  97 }, { 112, 112 }, {  24,   9 },
-    { 113,  98 }, {  99,  84 }, {  70,  55 }, {  85,  70 },
-    {  55,  40 }, {   9,   9 }, {  40,  25 }, { 114,  99 },
-    { 100,  85 }, { 128, 113 }, { 115, 100 }, {  71,  56 },
-    {  86,  71 }, {  25,  10 }, { 129, 114 }, { 128, 128 },
-    { 101,  86 }, {  56,  41 }, {  10,  10 }, {  41,  26 },
-    { 116, 101 }, { 130, 115 }, { 144, 129 }, {  87,  72 },
-    { 102,  87 }, {  26,  11 }, {  72,  57 }, { 131, 116 },
-    { 117, 102 }, { 145, 130 }, {  57,  42 }, { 144, 144 },
-    {  11,  11 }, {  42,  27 }, { 132, 117 }, { 146, 131 },
-    { 103,  88 }, {  88,  73 }, { 118, 103 }, { 160, 145 },
-    {  73,  58 }, { 147, 132 }, { 133, 118 }, {  27,  12 },
-    { 161, 146 }, {  58,  43 }, {  12,  12 }, { 160, 160 },
-    { 119, 104 }, { 148, 133 }, {  89,  74 }, { 134, 119 },
-    { 104,  89 }, { 162, 147 }, {  43,  28 }, {  74,  59 },
-    { 176, 161 }, { 163, 148 }, {  28,  13 }, { 149, 134 },
-    { 120, 105 }, { 135, 120 }, { 177, 162 }, { 164, 149 },
-    {  13,  13 }, { 105,  90 }, {  59,  44 }, {  90,  75 },
-    { 150, 135 }, {  44,  29 }, { 178, 163 }, { 176, 176 },
-    { 136, 121 }, { 165, 150 }, { 121, 106 }, {  75,  60 },
-    { 179, 164 }, { 151, 136 }, {  29,  14 }, {  60,  45 },
-    {  14,  14 }, { 106,  91 }, { 166, 151 }, { 180, 165 },
-    { 192, 177 }, {  91,  76 }, { 192, 192 }, {  45,  30 },
-    { 137, 122 }, { 122, 107 }, { 152, 137 }, { 193, 178 },
-    {  76,  61 }, { 167, 152 }, { 181, 166 }, {  30,  15 },
-    { 194, 179 }, { 208, 193 }, { 182, 167 }, { 107,  92 },
-    { 138, 123 }, {  61,  46 }, { 153, 138 }, {  46,  31 },
-    { 195, 180 }, {  92,  77 }, { 168, 153 }, { 209, 194 },
-    { 196, 181 }, { 208, 208 }, { 123, 108 }, { 183, 168 },
-    { 210, 195 }, {  77,  62 }, { 108,  93 }, { 169, 154 },
-    { 154, 139 }, {  62,  47 }, { 197, 182 }, { 211, 196 },
-    { 184, 169 }, { 224, 209 }, { 224, 224 }, { 139, 124 },
-    {  93,  78 }, { 198, 183 }, { 124, 109 }, {  78,  63 },
-    { 212, 197 }, { 225, 210 }, { 170, 155 }, { 185, 170 },
-    { 155, 140 }, { 213, 198 }, { 199, 184 }, { 109,  94 },
-    { 226, 211 }, { 140, 125 }, {  94,  79 }, { 240, 225 },
-    { 214, 199 }, { 227, 212 }, { 200, 185 }, { 125, 110 },
-    { 241, 226 }, { 186, 171 }, { 171, 156 }, { 156, 141 },
-    { 228, 213 }, { 110,  95 }, { 215, 200 }, { 242, 227 },
-    { 141, 126 }, { 201, 186 }, { 229, 214 }, { 126, 111 },
-    { 216, 201 }, { 243, 228 }, { 172, 157 }, { 187, 172 },
-    { 230, 215 }, { 157, 142 }, { 202, 187 }, { 142, 127 },
-    { 244, 229 }, { 217, 202 }, { 231, 216 }, { 188, 173 },
-    { 245, 230 }, { 158, 143 }, { 173, 158 }, { 232, 217 },
-    { 246, 231 }, { 218, 203 }, { 203, 188 }, { 174, 159 },
-    { 189, 174 }, { 247, 232 }, { 233, 218 }, { 204, 189 },
-    { 219, 204 }, { 248, 233 }, { 190, 175 }, { 234, 219 },
-    { 220, 205 }, { 249, 234 }, { 205, 190 }, { 221, 206 },
-    { 250, 235 }, { 235, 220 }, { 206, 191 }, { 236, 221 },
-    { 222, 207 }, { 251, 236 }, { 237, 222 }, { 252, 237 },
-    { 238, 223 }, { 253, 238 }, { 254, 239 }, {   0,   0 },
-};
-
-static const int16_t vp9_col_scan_16x16_nb[256][2] = {
-    {   0,   0 }, {   1,   1 }, {   2,   2 }, {   0,   0 },
-    {   3,   3 }, {  16,  16 }, {   4,   4 }, {  17,  17 },
-    {   5,   5 }, {  18,  18 }, {  16,  16 }, {  19,  19 },
-    {   6,   6 }, {  32,  32 }, {  20,  20 }, {  33,  33 },
-    {   7,   7 }, {  34,  34 }, {  21,  21 }, {  32,  32 },
-    {  35,  35 }, {   8,   8 }, {  48,  48 }, {  22,  22 },
-    {  49,  49 }, {  36,  36 }, {   9,   9 }, {  37,  37 },
-    {  50,  50 }, {  23,  23 }, {  48,  48 }, {  51,  51 },
-    {  10,  10 }, {  64,  64 }, {  38,  38 }, {  24,  24 },
-    {  52,  52 }, {  65,  65 }, {  53,  53 }, {  39,  39 },
-    {  66,  66 }, {  11,  11 }, {  64,  64 }, {  25,  25 },
-    {  67,  67 }, {  54,  54 }, {  80,  80 }, {  40,  40 },
-    {  68,  68 }, {  12,  12 }, {  26,  26 }, {  81,  81 },
-    {  55,  55 }, {  69,  69 }, {  82,  82 }, {  41,  41 },
-    {  13,  13 }, {  83,  83 }, {  80,  80 }, {  70,  70 },
-    {  27,  27 }, {  56,  56 }, {  84,  84 }, {  96,  96 },
-    {  14,  14 }, {  71,  71 }, {  97,  97 }, {  42,  42 },
-    {  85,  85 }, {  57,  57 }, {  98,  98 }, {  28,  28 },
-    {  86,  86 }, {  99,  99 }, {  96,  96 }, {  72,  72 },
-    {  43,  43 }, { 100, 100 }, {  58,  58 }, {  29,  29 },
-    { 112, 112 }, {  87,  87 }, { 113, 113 }, {  73,  73 },
-    { 112, 112 }, { 101, 101 }, {  44,  44 }, {  30,  30 },
-    { 114, 114 }, {  59,  59 }, { 102, 102 }, {  88,  88 },
-    { 115, 115 }, {  74,  74 }, { 128, 128 }, { 116, 116 },
-    {  45,  45 }, { 103, 103 }, {  89,  89 }, {  60,  60 },
-    { 129, 129 }, { 117, 117 }, { 130, 130 }, { 131, 131 },
-    { 104, 104 }, {  75,  75 }, {  46,  46 }, { 118, 118 },
-    { 128, 128 }, {  90,  90 }, {  61,  61 }, { 132, 132 },
-    { 105, 105 }, { 144, 144 }, { 119, 119 }, { 145, 145 },
-    { 133, 133 }, {  76,  76 }, { 146, 146 }, { 120, 120 },
-    {  91,  91 }, { 134, 134 }, { 147, 147 }, {  62,  62 },
-    { 106, 106 }, { 135, 135 }, { 121, 121 }, {  92,  92 },
-    { 148, 148 }, { 144, 144 }, {  77,  77 }, { 149, 149 },
-    { 136, 136 }, { 107, 107 }, { 160, 160 }, { 161, 161 },
-    { 150, 150 }, { 122, 122 }, {  78,  78 }, { 137, 137 },
-    { 162, 162 }, { 151, 151 }, {  93,  93 }, { 163, 163 },
-    { 108, 108 }, { 164, 164 }, { 152, 152 }, { 123, 123 },
-    { 138, 138 }, { 160, 160 }, { 165, 165 }, {  94,  94 },
-    { 176, 176 }, { 166, 166 }, { 109, 109 }, { 153, 153 },
-    { 177, 177 }, { 124, 124 }, { 178, 178 }, { 139, 139 },
-    { 167, 167 }, { 154, 154 }, { 110, 110 }, { 179, 179 },
-    { 176, 176 }, { 180, 180 }, { 168, 168 }, { 140, 140 },
-    { 125, 125 }, { 181, 181 }, { 192, 192 }, { 193, 193 },
-    { 155, 155 }, { 182, 182 }, { 169, 169 }, { 194, 194 },
-    { 126, 126 }, { 141, 141 }, { 195, 195 }, { 183, 183 },
-    { 192, 192 }, { 196, 196 }, { 156, 156 }, { 170, 170 },
-    { 142, 142 }, { 184, 184 }, { 197, 197 }, { 208, 208 },
-    { 198, 198 }, { 209, 209 }, { 171, 171 }, { 157, 157 },
-    { 185, 185 }, { 210, 210 }, { 208, 208 }, { 211, 211 },
-    { 199, 199 }, { 224, 224 }, { 158, 158 }, { 212, 212 },
-    { 224, 224 }, { 186, 186 }, { 200, 200 }, { 172, 172 },
-    { 225, 225 }, { 213, 213 }, { 214, 214 }, { 226, 226 },
-    { 201, 201 }, { 227, 227 }, { 187, 187 }, { 240, 240 },
-    { 215, 215 }, { 173, 173 }, { 228, 228 }, { 241, 241 },
-    { 202, 202 }, { 242, 242 }, { 216, 216 }, { 229, 229 },
-    { 174, 174 }, { 188, 188 }, { 243, 243 }, { 230, 230 },
-    { 203, 203 }, { 217, 217 }, { 231, 231 }, { 244, 244 },
-    { 218, 218 }, { 245, 245 }, { 189, 189 }, { 232, 232 },
-    { 204, 204 }, { 190, 190 }, { 246, 246 }, { 233, 233 },
-    { 247, 247 }, { 219, 219 }, { 205, 205 }, { 248, 248 },
-    { 234, 234 }, { 220, 220 }, { 206, 206 }, { 249, 249 },
-    { 235, 235 }, { 221, 221 }, { 250, 250 }, { 222, 222 },
-    { 236, 236 }, { 237, 237 }, { 251, 251 }, { 238, 238 },
-    { 252, 252 }, { 253, 253 }, { 254, 254 }, {   0,   0 },
-};
-
-static const int16_t vp9_row_scan_16x16_nb[256][2] = {
-    {   0,   0 }, {  16,  16 }, {   0,   0 }, {  32,  32 },
-    {   1,   1 }, {  48,  48 }, {  17,  17 }, {   1,   1 },
-    {  64,  64 }, {   2,   2 }, {  33,  33 }, {  80,  80 },
-    {  18,  18 }, {   2,   2 }, {  49,  49 }, {   3,   3 },
-    {  96,  96 }, {  34,  34 }, {  65,  65 }, {  19,  19 },
-    {   3,   3 }, { 112, 112 }, {  50,  50 }, {   4,   4 },
-    {  81,  81 }, {  35,  35 }, {  66,  66 }, {   4,   4 },
-    { 128, 128 }, {  20,  20 }, {  51,  51 }, {  97,  97 },
-    {  82,  82 }, {   5,   5 }, {  36,  36 }, { 144, 144 },
-    {  67,  67 }, { 113, 113 }, {  21,  21 }, {  52,  52 },
-    {   5,   5 }, {  98,  98 }, { 160, 160 }, {  83,  83 },
-    {  37,  37 }, {   6,   6 }, {  68,  68 }, { 129, 129 },
-    {  22,  22 }, {  53,  53 }, { 114, 114 }, {   6,   6 },
-    {  99,  99 }, { 176, 176 }, {  84,  84 }, {  38,  38 },
-    {   7,   7 }, {  69,  69 }, { 145, 145 }, { 130, 130 },
-    { 115, 115 }, {  23,  23 }, {  54,  54 }, { 192, 192 },
-    { 100, 100 }, {   7,   7 }, {  85,  85 }, { 161, 161 },
-    {  39,  39 }, {  70,  70 }, {   8,   8 }, { 146, 146 },
-    { 131, 131 }, { 116, 116 }, {  55,  55 }, { 208, 208 },
-    { 101, 101 }, {  24,  24 }, {  86,  86 }, {   8,   8 },
-    { 132, 132 }, {  40,  40 }, {  71,  71 }, { 177, 177 },
-    { 147, 147 }, { 224, 224 }, { 117, 117 }, { 162, 162 },
-    {   9,   9 }, { 102, 102 }, {  56,  56 }, {  25,  25 },
-    {  87,  87 }, { 148, 148 }, {   9,   9 }, { 133, 133 },
-    {  72,  72 }, { 118, 118 }, { 193, 193 }, { 163, 163 },
-    {  41,  41 }, { 103, 103 }, { 178, 178 }, {  10,  10 },
-    {  57,  57 }, { 149, 149 }, { 134, 134 }, {  88,  88 },
-    {  26,  26 }, { 119, 119 }, {  10,  10 }, { 164, 164 },
-    { 104, 104 }, {  73,  73 }, { 209, 209 }, { 179, 179 },
-    {  42,  42 }, {  11,  11 }, { 194, 194 }, { 135, 135 },
-    { 165, 165 }, { 150, 150 }, {  58,  58 }, {  27,  27 },
-    {  89,  89 }, {  11,  11 }, { 120, 120 }, {  74,  74 },
-    {  43,  43 }, { 225, 225 }, { 105, 105 }, {  12,  12 },
-    { 180, 180 }, { 151, 151 }, { 195, 195 }, { 136, 136 },
-    {  28,  28 }, { 166, 166 }, { 121, 121 }, {  59,  59 },
-    {  12,  12 }, { 210, 210 }, {  90,  90 }, { 106, 106 },
-    {  44,  44 }, { 181, 181 }, {  75,  75 }, { 152, 152 },
-    {  13,  13 }, { 167, 167 }, { 137, 137 }, {  13,  13 },
-    {  60,  60 }, { 196, 196 }, { 122, 122 }, {  29,  29 },
-    {  91,  91 }, {  14,  14 }, { 182, 182 }, {  76,  76 },
-    { 211, 211 }, { 153, 153 }, {  14,  14 }, { 107, 107 },
-    { 138, 138 }, {  45,  45 }, { 226, 226 }, { 168, 168 },
-    { 197, 197 }, { 123, 123 }, {  30,  30 }, {  61,  61 },
-    {  15,  15 }, {  92,  92 }, { 154, 154 }, { 183, 183 },
-    { 169, 169 }, { 108, 108 }, { 212, 212 }, {  77,  77 },
-    { 139, 139 }, { 198, 198 }, {  46,  46 }, { 124, 124 },
-    { 227, 227 }, {  62,  62 }, {  31,  31 }, { 184, 184 },
-    {  93,  93 }, { 170, 170 }, { 155, 155 }, { 185, 185 },
-    {  78,  78 }, {  47,  47 }, { 199, 199 }, { 213, 213 },
-    { 140, 140 }, {  63,  63 }, { 109, 109 }, { 125, 125 },
-    {  94,  94 }, { 200, 200 }, { 171, 171 }, { 156, 156 },
-    { 228, 228 }, { 186, 186 }, { 214, 214 }, { 201, 201 },
-    {  79,  79 }, { 141, 141 }, { 110, 110 }, { 229, 229 },
-    {  95,  95 }, { 126, 126 }, { 215, 215 }, { 172, 172 },
-    { 111, 111 }, { 142, 142 }, { 202, 202 }, { 157, 157 },
-    { 216, 216 }, { 230, 230 }, { 217, 217 }, { 187, 187 },
-    { 127, 127 }, { 231, 231 }, { 158, 158 }, { 173, 173 },
-    { 143, 143 }, { 203, 203 }, { 188, 188 }, { 232, 232 },
-    { 218, 218 }, { 233, 233 }, { 159, 159 }, { 174, 174 },
-    { 204, 204 }, { 189, 189 }, { 234, 234 }, { 219, 219 },
-    { 175, 175 }, { 205, 205 }, { 235, 235 }, { 220, 220 },
-    { 190, 190 }, { 236, 236 }, { 206, 206 }, { 191, 191 },
-    { 221, 221 }, { 207, 207 }, { 237, 237 }, { 222, 222 },
-    { 238, 238 }, { 223, 223 }, { 239, 239 }, {   0,   0 },
-};
-
-static const int16_t vp9_default_scan_32x32_nb[1024][2] = {
-    {    0,    0 }, {    0,    0 }, {    1,    1 }, {   32,    1 },
-    {   32,   32 }, {    2,    2 }, {   33,    2 }, {   64,   33 },
-    {    3,    3 }, {   64,   64 }, {   34,    3 }, {   65,   34 },
-    {    4,    4 }, {   35,    4 }, {   96,   65 }, {   66,   35 },
-    {   96,   96 }, {   97,   66 }, {   67,   36 }, {   36,    5 },
-    {    5,    5 }, {  128,   97 }, {   98,   67 }, {    6,    6 },
-    {  128,  128 }, {   68,   37 }, {   37,    6 }, {  129,   98 },
-    {   99,   68 }, {  160,  129 }, {  130,   99 }, {   38,    7 },
-    {   69,   38 }, {    7,    7 }, {  100,   69 }, {  161,  130 },
-    {  131,  100 }, {  160,  160 }, {   70,   39 }, {   39,    8 },
-    {    8,    8 }, {  101,   70 }, {  162,  131 }, {  132,  101 },
-    {  192,  161 }, {   71,   40 }, {  192,  192 }, {  102,   71 },
-    {   40,    9 }, {  163,  132 }, {    9,    9 }, {  193,  162 },
-    {  133,  102 }, {  164,  133 }, {   72,   41 }, {  103,   72 },
-    {  134,  103 }, {  224,  193 }, {   41,   10 }, {  194,  163 },
-    {   10,   10 }, {  224,  224 }, {  165,  134 }, {  225,  194 },
-    {  195,  164 }, {   73,   42 }, {  104,   73 }, {  135,  104 },
-    {   42,   11 }, {   11,   11 }, {  166,  135 }, {  196,  165 },
-    {  226,  195 }, {  256,  225 }, {   74,   43 }, {  105,   74 },
-    {  136,  105 }, {  227,  196 }, {   43,   12 }, {  197,  166 },
-    {  167,  136 }, {  257,  226 }, {  256,  256 }, {   12,   12 },
-    {  228,  197 }, {   75,   44 }, {  106,   75 }, {  198,  167 },
-    {  137,  106 }, {  258,  227 }, {  168,  137 }, {  288,  257 },
-    {   44,   13 }, {  229,  198 }, {  259,  228 }, {  199,  168 },
-    {  107,   76 }, {   13,   13 }, {  169,  138 }, {  138,  107 },
-    {  288,  288 }, {  289,  258 }, {   76,   45 }, {  230,  199 },
-    {  260,  229 }, {   45,   14 }, {  200,  169 }, {  139,  108 },
-    {  290,  259 }, {  108,   77 }, {  231,  200 }, {  320,  289 },
-    {  261,  230 }, {  170,  139 }, {   77,   46 }, {  291,  260 },
-    {   14,   14 }, {  321,  290 }, {  201,  170 }, {  262,  231 },
-    {  320,  320 }, {  171,  140 }, {  292,  261 }, {  232,  201 },
-    {  140,  109 }, {  322,  291 }, {  109,   78 }, {   46,   15 },
-    {  202,  171 }, {  263,  232 }, {  233,  202 }, {  293,  262 },
-    {  352,  321 }, {  323,  292 }, {   15,   15 }, {   78,   47 },
-    {  203,  172 }, {  264,  233 }, {  294,  263 }, {  324,  293 },
-    {  172,  141 }, {  353,  322 }, {  141,  110 }, {  234,  203 },
-    {  352,  352 }, {   47,   16 }, {  295,  264 }, {  110,   79 },
-    {  265,  234 }, {  354,  323 }, {  325,  294 }, {   79,   48 },
-    {   16,   16 }, {  204,  173 }, {  235,  204 }, {  173,  142 },
-    {  355,  324 }, {  384,  353 }, {  326,  295 }, {  142,  111 },
-    {  296,  265 }, {  266,  235 }, {  356,  325 }, {  385,  354 },
-    {  111,   80 }, {   48,   17 }, {  327,  296 }, {  297,  266 },
-    {  205,  174 }, {  384,  384 }, {  236,  205 }, {  357,  326 },
-    {  386,  355 }, {   80,   49 }, {  174,  143 }, {   17,   17 },
-    {  328,  297 }, {  358,  327 }, {  387,  356 }, {  298,  267 },
-    {  329,  298 }, {  388,  357 }, {  112,   81 }, {  416,  385 },
-    {  237,  206 }, {  359,  328 }, {   49,   18 }, {  206,  175 },
-    {  417,  386 }, {  389,  358 }, {  330,  299 }, {   18,   18 },
-    {  416,  416 }, {  360,  329 }, {   81,   50 }, {  418,  387 },
-    {  390,  359 }, {  238,  207 }, {   50,   19 }, {  361,  330 },
-    {  419,  388 }, {  113,   82 }, {  448,  417 }, {  448,  448 },
-    {  420,  389 }, {   82,   51 }, {  362,  331 }, {  449,  418 },
-    {  421,  390 }, {  480,  480 }, {  450,  419 }, {  422,  391 },
-    {  114,   83 }, {  451,  420 }, {  480,  449 }, {  452,  421 },
-    {  481,  450 }, {  453,  422 }, {  512,  512 }, {  482,  451 },
-    {  454,  423 }, {  512,  481 }, {  483,  452 }, {  513,  482 },
-    {  484,  453 }, {  514,  483 }, {  485,  454 }, {  544,  513 },
-    {  544,  544 }, {  486,  455 }, {  545,  514 }, {  546,  515 },
-    {  576,  576 }, {  576,  545 }, {  577,  546 }, {  578,  547 },
-    {  608,  577 }, {  609,  578 }, {  610,  579 }, {   19,   19 },
-    {  143,  112 }, {  267,  236 }, {  391,  360 }, {  515,  484 },
-    {  608,  608 }, {   20,   20 }, {   51,   20 }, {  144,  113 },
-    {  175,  144 }, {  268,  237 }, {  299,  268 }, {  392,  361 },
-    {  423,  392 }, {  516,  485 }, {  547,  516 }, {  640,  609 },
-    {  640,  640 }, {   21,   21 }, {   52,   21 }, {   83,   52 },
-    {  145,  114 }, {  176,  145 }, {  207,  176 }, {  269,  238 },
-    {  300,  269 }, {  331,  300 }, {  393,  362 }, {  424,  393 },
-    {  455,  424 }, {  517,  486 }, {  548,  517 }, {  579,  548 },
-    {  641,  610 }, {  672,  641 }, {  672,  672 }, {   22,   22 },
-    {   53,   22 }, {   84,   53 }, {  115,   84 }, {  146,  115 },
-    {  177,  146 }, {  208,  177 }, {  239,  208 }, {  270,  239 },
-    {  301,  270 }, {  332,  301 }, {  363,  332 }, {  394,  363 },
-    {  425,  394 }, {  456,  425 }, {  487,  456 }, {  518,  487 },
-    {  549,  518 }, {  580,  549 }, {  611,  580 }, {  642,  611 },
-    {  673,  642 }, {  704,  673 }, {  704,  704 }, {   54,   23 },
-    {   85,   54 }, {  116,   85 }, {  178,  147 }, {  209,  178 },
-    {  240,  209 }, {  302,  271 }, {  333,  302 }, {  364,  333 },
-    {  426,  395 }, {  457,  426 }, {  488,  457 }, {  550,  519 },
-    {  581,  550 }, {  612,  581 }, {  674,  643 }, {  705,  674 },
-    {  736,  705 }, {   86,   55 }, {  117,   86 }, {  210,  179 },
-    {  241,  210 }, {  334,  303 }, {  365,  334 }, {  458,  427 },
-    {  489,  458 }, {  582,  551 }, {  613,  582 }, {  706,  675 },
-    {  737,  706 }, {  118,   87 }, {  242,  211 }, {  366,  335 },
-    {  490,  459 }, {  614,  583 }, {  738,  707 }, {   23,   23 },
-    {  147,  116 }, {  271,  240 }, {  395,  364 }, {  519,  488 },
-    {  643,  612 }, {  736,  736 }, {   24,   24 }, {   55,   24 },
-    {  148,  117 }, {  179,  148 }, {  272,  241 }, {  303,  272 },
-    {  396,  365 }, {  427,  396 }, {  520,  489 }, {  551,  520 },
-    {  644,  613 }, {  675,  644 }, {  768,  737 }, {  768,  768 },
-    {   25,   25 }, {   56,   25 }, {   87,   56 }, {  149,  118 },
-    {  180,  149 }, {  211,  180 }, {  273,  242 }, {  304,  273 },
-    {  335,  304 }, {  397,  366 }, {  428,  397 }, {  459,  428 },
-    {  521,  490 }, {  552,  521 }, {  583,  552 }, {  645,  614 },
-    {  676,  645 }, {  707,  676 }, {  769,  738 }, {  800,  769 },
-    {  800,  800 }, {   26,   26 }, {   57,   26 }, {   88,   57 },
-    {  119,   88 }, {  150,  119 }, {  181,  150 }, {  212,  181 },
-    {  243,  212 }, {  274,  243 }, {  305,  274 }, {  336,  305 },
-    {  367,  336 }, {  398,  367 }, {  429,  398 }, {  460,  429 },
-    {  491,  460 }, {  522,  491 }, {  553,  522 }, {  584,  553 },
-    {  615,  584 }, {  646,  615 }, {  677,  646 }, {  708,  677 },
-    {  739,  708 }, {  770,  739 }, {  801,  770 }, {  832,  801 },
-    {  832,  832 }, {   58,   27 }, {   89,   58 }, {  120,   89 },
-    {  182,  151 }, {  213,  182 }, {  244,  213 }, {  306,  275 },
-    {  337,  306 }, {  368,  337 }, {  430,  399 }, {  461,  430 },
-    {  492,  461 }, {  554,  523 }, {  585,  554 }, {  616,  585 },
-    {  678,  647 }, {  709,  678 }, {  740,  709 }, {  802,  771 },
-    {  833,  802 }, {  864,  833 }, {   90,   59 }, {  121,   90 },
-    {  214,  183 }, {  245,  214 }, {  338,  307 }, {  369,  338 },
-    {  462,  431 }, {  493,  462 }, {  586,  555 }, {  617,  586 },
-    {  710,  679 }, {  741,  710 }, {  834,  803 }, {  865,  834 },
-    {  122,   91 }, {  246,  215 }, {  370,  339 }, {  494,  463 },
-    {  618,  587 }, {  742,  711 }, {  866,  835 }, {   27,   27 },
-    {  151,  120 }, {  275,  244 }, {  399,  368 }, {  523,  492 },
-    {  647,  616 }, {  771,  740 }, {  864,  864 }, {   28,   28 },
-    {   59,   28 }, {  152,  121 }, {  183,  152 }, {  276,  245 },
-    {  307,  276 }, {  400,  369 }, {  431,  400 }, {  524,  493 },
-    {  555,  524 }, {  648,  617 }, {  679,  648 }, {  772,  741 },
-    {  803,  772 }, {  896,  865 }, {  896,  896 }, {   29,   29 },
-    {   60,   29 }, {   91,   60 }, {  153,  122 }, {  184,  153 },
-    {  215,  184 }, {  277,  246 }, {  308,  277 }, {  339,  308 },
-    {  401,  370 }, {  432,  401 }, {  463,  432 }, {  525,  494 },
-    {  556,  525 }, {  587,  556 }, {  649,  618 }, {  680,  649 },
-    {  711,  680 }, {  773,  742 }, {  804,  773 }, {  835,  804 },
-    {  897,  866 }, {  928,  897 }, {  928,  928 }, {   30,   30 },
-    {   61,   30 }, {   92,   61 }, {  123,   92 }, {  154,  123 },
-    {  185,  154 }, {  216,  185 }, {  247,  216 }, {  278,  247 },
-    {  309,  278 }, {  340,  309 }, {  371,  340 }, {  402,  371 },
-    {  433,  402 }, {  464,  433 }, {  495,  464 }, {  526,  495 },
-    {  557,  526 }, {  588,  557 }, {  619,  588 }, {  650,  619 },
-    {  681,  650 }, {  712,  681 }, {  743,  712 }, {  774,  743 },
-    {  805,  774 }, {  836,  805 }, {  867,  836 }, {  898,  867 },
-    {  929,  898 }, {  960,  929 }, {  960,  960 }, {   62,   31 },
-    {   93,   62 }, {  124,   93 }, {  186,  155 }, {  217,  186 },
-    {  248,  217 }, {  310,  279 }, {  341,  310 }, {  372,  341 },
-    {  434,  403 }, {  465,  434 }, {  496,  465 }, {  558,  527 },
-    {  589,  558 }, {  620,  589 }, {  682,  651 }, {  713,  682 },
-    {  744,  713 }, {  806,  775 }, {  837,  806 }, {  868,  837 },
-    {  930,  899 }, {  961,  930 }, {  992,  961 }, {   94,   63 },
-    {  125,   94 }, {  218,  187 }, {  249,  218 }, {  342,  311 },
-    {  373,  342 }, {  466,  435 }, {  497,  466 }, {  590,  559 },
-    {  621,  590 }, {  714,  683 }, {  745,  714 }, {  838,  807 },
-    {  869,  838 }, {  962,  931 }, {  993,  962 }, {  126,   95 },
-    {  250,  219 }, {  374,  343 }, {  498,  467 }, {  622,  591 },
-    {  746,  715 }, {  870,  839 }, {  994,  963 }, {  155,  124 },
-    {  279,  248 }, {  403,  372 }, {  527,  496 }, {  651,  620 },
-    {  775,  744 }, {  899,  868 }, {  156,  125 }, {  187,  156 },
-    {  280,  249 }, {  311,  280 }, {  404,  373 }, {  435,  404 },
-    {  528,  497 }, {  559,  528 }, {  652,  621 }, {  683,  652 },
-    {  776,  745 }, {  807,  776 }, {  900,  869 }, {  931,  900 },
-    {  157,  126 }, {  188,  157 }, {  219,  188 }, {  281,  250 },
-    {  312,  281 }, {  343,  312 }, {  405,  374 }, {  436,  405 },
-    {  467,  436 }, {  529,  498 }, {  560,  529 }, {  591,  560 },
-    {  653,  622 }, {  684,  653 }, {  715,  684 }, {  777,  746 },
-    {  808,  777 }, {  839,  808 }, {  901,  870 }, {  932,  901 },
-    {  963,  932 }, {  158,  127 }, {  189,  158 }, {  220,  189 },
-    {  251,  220 }, {  282,  251 }, {  313,  282 }, {  344,  313 },
-    {  375,  344 }, {  406,  375 }, {  437,  406 }, {  468,  437 },
-    {  499,  468 }, {  530,  499 }, {  561,  530 }, {  592,  561 },
-    {  623,  592 }, {  654,  623 }, {  685,  654 }, {  716,  685 },
-    {  747,  716 }, {  778,  747 }, {  809,  778 }, {  840,  809 },
-    {  871,  840 }, {  902,  871 }, {  933,  902 }, {  964,  933 },
-    {  995,  964 }, {  190,  159 }, {  221,  190 }, {  252,  221 },
-    {  314,  283 }, {  345,  314 }, {  376,  345 }, {  438,  407 },
-    {  469,  438 }, {  500,  469 }, {  562,  531 }, {  593,  562 },
-    {  624,  593 }, {  686,  655 }, {  717,  686 }, {  748,  717 },
-    {  810,  779 }, {  841,  810 }, {  872,  841 }, {  934,  903 },
-    {  965,  934 }, {  996,  965 }, {  222,  191 }, {  253,  222 },
-    {  346,  315 }, {  377,  346 }, {  470,  439 }, {  501,  470 },
-    {  594,  563 }, {  625,  594 }, {  718,  687 }, {  749,  718 },
-    {  842,  811 }, {  873,  842 }, {  966,  935 }, {  997,  966 },
-    {  254,  223 }, {  378,  347 }, {  502,  471 }, {  626,  595 },
-    {  750,  719 }, {  874,  843 }, {  998,  967 }, {  283,  252 },
-    {  407,  376 }, {  531,  500 }, {  655,  624 }, {  779,  748 },
-    {  903,  872 }, {  284,  253 }, {  315,  284 }, {  408,  377 },
-    {  439,  408 }, {  532,  501 }, {  563,  532 }, {  656,  625 },
-    {  687,  656 }, {  780,  749 }, {  811,  780 }, {  904,  873 },
-    {  935,  904 }, {  285,  254 }, {  316,  285 }, {  347,  316 },
-    {  409,  378 }, {  440,  409 }, {  471,  440 }, {  533,  502 },
-    {  564,  533 }, {  595,  564 }, {  657,  626 }, {  688,  657 },
-    {  719,  688 }, {  781,  750 }, {  812,  781 }, {  843,  812 },
-    {  905,  874 }, {  936,  905 }, {  967,  936 }, {  286,  255 },
-    {  317,  286 }, {  348,  317 }, {  379,  348 }, {  410,  379 },
-    {  441,  410 }, {  472,  441 }, {  503,  472 }, {  534,  503 },
-    {  565,  534 }, {  596,  565 }, {  627,  596 }, {  658,  627 },
-    {  689,  658 }, {  720,  689 }, {  751,  720 }, {  782,  751 },
-    {  813,  782 }, {  844,  813 }, {  875,  844 }, {  906,  875 },
-    {  937,  906 }, {  968,  937 }, {  999,  968 }, {  318,  287 },
-    {  349,  318 }, {  380,  349 }, {  442,  411 }, {  473,  442 },
-    {  504,  473 }, {  566,  535 }, {  597,  566 }, {  628,  597 },
-    {  690,  659 }, {  721,  690 }, {  752,  721 }, {  814,  783 },
-    {  845,  814 }, {  876,  845 }, {  938,  907 }, {  969,  938 },
-    { 1000,  969 }, {  350,  319 }, {  381,  350 }, {  474,  443 },
-    {  505,  474 }, {  598,  567 }, {  629,  598 }, {  722,  691 },
-    {  753,  722 }, {  846,  815 }, {  877,  846 }, {  970,  939 },
-    { 1001,  970 }, {  382,  351 }, {  506,  475 }, {  630,  599 },
-    {  754,  723 }, {  878,  847 }, { 1002,  971 }, {  411,  380 },
-    {  535,  504 }, {  659,  628 }, {  783,  752 }, {  907,  876 },
-    {  412,  381 }, {  443,  412 }, {  536,  505 }, {  567,  536 },
-    {  660,  629 }, {  691,  660 }, {  784,  753 }, {  815,  784 },
-    {  908,  877 }, {  939,  908 }, {  413,  382 }, {  444,  413 },
-    {  475,  444 }, {  537,  506 }, {  568,  537 }, {  599,  568 },
-    {  661,  630 }, {  692,  661 }, {  723,  692 }, {  785,  754 },
-    {  816,  785 }, {  847,  816 }, {  909,  878 }, {  940,  909 },
-    {  971,  940 }, {  414,  383 }, {  445,  414 }, {  476,  445 },
-    {  507,  476 }, {  538,  507 }, {  569,  538 }, {  600,  569 },
-    {  631,  600 }, {  662,  631 }, {  693,  662 }, {  724,  693 },
-    {  755,  724 }, {  786,  755 }, {  817,  786 }, {  848,  817 },
-    {  879,  848 }, {  910,  879 }, {  941,  910 }, {  972,  941 },
-    { 1003,  972 }, {  446,  415 }, {  477,  446 }, {  508,  477 },
-    {  570,  539 }, {  601,  570 }, {  632,  601 }, {  694,  663 },
-    {  725,  694 }, {  756,  725 }, {  818,  787 }, {  849,  818 },
-    {  880,  849 }, {  942,  911 }, {  973,  942 }, { 1004,  973 },
-    {  478,  447 }, {  509,  478 }, {  602,  571 }, {  633,  602 },
-    {  726,  695 }, {  757,  726 }, {  850,  819 }, {  881,  850 },
-    {  974,  943 }, { 1005,  974 }, {  510,  479 }, {  634,  603 },
-    {  758,  727 }, {  882,  851 }, { 1006,  975 }, {  539,  508 },
-    {  663,  632 }, {  787,  756 }, {  911,  880 }, {  540,  509 },
-    {  571,  540 }, {  664,  633 }, {  695,  664 }, {  788,  757 },
-    {  819,  788 }, {  912,  881 }, {  943,  912 }, {  541,  510 },
-    {  572,  541 }, {  603,  572 }, {  665,  634 }, {  696,  665 },
-    {  727,  696 }, {  789,  758 }, {  820,  789 }, {  851,  820 },
-    {  913,  882 }, {  944,  913 }, {  975,  944 }, {  542,  511 },
-    {  573,  542 }, {  604,  573 }, {  635,  604 }, {  666,  635 },
-    {  697,  666 }, {  728,  697 }, {  759,  728 }, {  790,  759 },
-    {  821,  790 }, {  852,  821 }, {  883,  852 }, {  914,  883 },
-    {  945,  914 }, {  976,  945 }, { 1007,  976 }, {  574,  543 },
-    {  605,  574 }, {  636,  605 }, {  698,  667 }, {  729,  698 },
-    {  760,  729 }, {  822,  791 }, {  853,  822 }, {  884,  853 },
-    {  946,  915 }, {  977,  946 }, { 1008,  977 }, {  606,  575 },
-    {  637,  606 }, {  730,  699 }, {  761,  730 }, {  854,  823 },
-    {  885,  854 }, {  978,  947 }, { 1009,  978 }, {  638,  607 },
-    {  762,  731 }, {  886,  855 }, { 1010,  979 }, {  667,  636 },
-    {  791,  760 }, {  915,  884 }, {  668,  637 }, {  699,  668 },
-    {  792,  761 }, {  823,  792 }, {  916,  885 }, {  947,  916 },
-    {  669,  638 }, {  700,  669 }, {  731,  700 }, {  793,  762 },
-    {  824,  793 }, {  855,  824 }, {  917,  886 }, {  948,  917 },
-    {  979,  948 }, {  670,  639 }, {  701,  670 }, {  732,  701 },
-    {  763,  732 }, {  794,  763 }, {  825,  794 }, {  856,  825 },
-    {  887,  856 }, {  918,  887 }, {  949,  918 }, {  980,  949 },
-    { 1011,  980 }, {  702,  671 }, {  733,  702 }, {  764,  733 },
-    {  826,  795 }, {  857,  826 }, {  888,  857 }, {  950,  919 },
-    {  981,  950 }, { 1012,  981 }, {  734,  703 }, {  765,  734 },
-    {  858,  827 }, {  889,  858 }, {  982,  951 }, { 1013,  982 },
-    {  766,  735 }, {  890,  859 }, { 1014,  983 }, {  795,  764 },
-    {  919,  888 }, {  796,  765 }, {  827,  796 }, {  920,  889 },
-    {  951,  920 }, {  797,  766 }, {  828,  797 }, {  859,  828 },
-    {  921,  890 }, {  952,  921 }, {  983,  952 }, {  798,  767 },
-    {  829,  798 }, {  860,  829 }, {  891,  860 }, {  922,  891 },
-    {  953,  922 }, {  984,  953 }, { 1015,  984 }, {  830,  799 },
-    {  861,  830 }, {  892,  861 }, {  954,  923 }, {  985,  954 },
-    { 1016,  985 }, {  862,  831 }, {  893,  862 }, {  986,  955 },
-    { 1017,  986 }, {  894,  863 }, { 1018,  987 }, {  923,  892 },
-    {  924,  893 }, {  955,  924 }, {  925,  894 }, {  956,  925 },
-    {  987,  956 }, {  926,  895 }, {  957,  926 }, {  988,  957 },
-    { 1019,  988 }, {  958,  927 }, {  989,  958 }, { 1020,  989 },
-    {  990,  959 }, { 1021,  990 }, { 1022,  991 }, {    0,    0 },
-};
-
-static const int16_t (* const vp9_scans_nb[5][4])[2] = {
-    {
-        vp9_default_scan_4x4_nb, vp9_col_scan_4x4_nb,
-        vp9_row_scan_4x4_nb, vp9_default_scan_4x4_nb
-    }, {
-        vp9_default_scan_8x8_nb, vp9_col_scan_8x8_nb,
-        vp9_row_scan_8x8_nb, vp9_default_scan_8x8_nb
-    }, {
-        vp9_default_scan_16x16_nb, vp9_col_scan_16x16_nb,
-        vp9_row_scan_16x16_nb, vp9_default_scan_16x16_nb
-    }, {
-        vp9_default_scan_32x32_nb, vp9_default_scan_32x32_nb,
-        vp9_default_scan_32x32_nb, vp9_default_scan_32x32_nb
-    }, { // lossless
-        vp9_default_scan_4x4_nb, vp9_default_scan_4x4_nb,
-        vp9_default_scan_4x4_nb, vp9_default_scan_4x4_nb
-    }
-};
-
-static const uint8_t vp9_model_pareto8[256][8] = {
-    {   6,  86, 128,  11,  87,  42,  91,  52 },
-    {   3,  86, 128,   6,  86,  23,  88,  29 },
-    {   6,  86, 128,  11,  87,  42,  91,  52 },
-    {   9,  86, 129,  17,  88,  61,  94,  76 },
-    {  12,  86, 129,  22,  88,  77,  97,  93 },
-    {  15,  87, 129,  28,  89,  93, 100, 110 },
-    {  17,  87, 129,  33,  90, 105, 103, 123 },
-    {  20,  88, 130,  38,  91, 118, 106, 136 },
-    {  23,  88, 130,  43,  91, 128, 108, 146 },
-    {  26,  89, 131,  48,  92, 139, 111, 156 },
-    {  28,  89, 131,  53,  93, 147, 114, 163 },
-    {  31,  90, 131,  58,  94, 156, 117, 171 },
-    {  34,  90, 131,  62,  94, 163, 119, 177 },
-    {  37,  90, 132,  66,  95, 171, 122, 184 },
-    {  39,  90, 132,  70,  96, 177, 124, 189 },
-    {  42,  91, 132,  75,  97, 183, 127, 194 },
-    {  44,  91, 132,  79,  97, 188, 129, 198 },
-    {  47,  92, 133,  83,  98, 193, 132, 202 },
-    {  49,  92, 133,  86,  99, 197, 134, 205 },
-    {  52,  93, 133,  90, 100, 201, 137, 208 },
-    {  54,  93, 133,  94, 100, 204, 139, 211 },
-    {  57,  94, 134,  98, 101, 208, 142, 214 },
-    {  59,  94, 134, 101, 102, 211, 144, 216 },
-    {  62,  94, 135, 105, 103, 214, 146, 218 },
-    {  64,  94, 135, 108, 103, 216, 148, 220 },
-    {  66,  95, 135, 111, 104, 219, 151, 222 },
-    {  68,  95, 135, 114, 105, 221, 153, 223 },
-    {  71,  96, 136, 117, 106, 224, 155, 225 },
-    {  73,  96, 136, 120, 106, 225, 157, 226 },
-    {  76,  97, 136, 123, 107, 227, 159, 228 },
-    {  78,  97, 136, 126, 108, 229, 160, 229 },
-    {  80,  98, 137, 129, 109, 231, 162, 231 },
-    {  82,  98, 137, 131, 109, 232, 164, 232 },
-    {  84,  98, 138, 134, 110, 234, 166, 233 },
-    {  86,  98, 138, 137, 111, 235, 168, 234 },
-    {  89,  99, 138, 140, 112, 236, 170, 235 },
-    {  91,  99, 138, 142, 112, 237, 171, 235 },
-    {  93, 100, 139, 145, 113, 238, 173, 236 },
-    {  95, 100, 139, 147, 114, 239, 174, 237 },
-    {  97, 101, 140, 149, 115, 240, 176, 238 },
-    {  99, 101, 140, 151, 115, 241, 177, 238 },
-    { 101, 102, 140, 154, 116, 242, 179, 239 },
-    { 103, 102, 140, 156, 117, 242, 180, 239 },
-    { 105, 103, 141, 158, 118, 243, 182, 240 },
-    { 107, 103, 141, 160, 118, 243, 183, 240 },
-    { 109, 104, 141, 162, 119, 244, 185, 241 },
-    { 111, 104, 141, 164, 119, 244, 186, 241 },
-    { 113, 104, 142, 166, 120, 245, 187, 242 },
-    { 114, 104, 142, 168, 121, 245, 188, 242 },
-    { 116, 105, 143, 170, 122, 246, 190, 243 },
-    { 118, 105, 143, 171, 122, 246, 191, 243 },
-    { 120, 106, 143, 173, 123, 247, 192, 244 },
-    { 121, 106, 143, 175, 124, 247, 193, 244 },
-    { 123, 107, 144, 177, 125, 248, 195, 244 },
-    { 125, 107, 144, 178, 125, 248, 196, 244 },
-    { 127, 108, 145, 180, 126, 249, 197, 245 },
-    { 128, 108, 145, 181, 127, 249, 198, 245 },
-    { 130, 109, 145, 183, 128, 249, 199, 245 },
-    { 132, 109, 145, 184, 128, 249, 200, 245 },
-    { 134, 110, 146, 186, 129, 250, 201, 246 },
-    { 135, 110, 146, 187, 130, 250, 202, 246 },
-    { 137, 111, 147, 189, 131, 251, 203, 246 },
-    { 138, 111, 147, 190, 131, 251, 204, 246 },
-    { 140, 112, 147, 192, 132, 251, 205, 247 },
-    { 141, 112, 147, 193, 132, 251, 206, 247 },
-    { 143, 113, 148, 194, 133, 251, 207, 247 },
-    { 144, 113, 148, 195, 134, 251, 207, 247 },
-    { 146, 114, 149, 197, 135, 252, 208, 248 },
-    { 147, 114, 149, 198, 135, 252, 209, 248 },
-    { 149, 115, 149, 199, 136, 252, 210, 248 },
-    { 150, 115, 149, 200, 137, 252, 210, 248 },
-    { 152, 115, 150, 201, 138, 252, 211, 248 },
-    { 153, 115, 150, 202, 138, 252, 212, 248 },
-    { 155, 116, 151, 204, 139, 253, 213, 249 },
-    { 156, 116, 151, 205, 139, 253, 213, 249 },
-    { 158, 117, 151, 206, 140, 253, 214, 249 },
-    { 159, 117, 151, 207, 141, 253, 215, 249 },
-    { 161, 118, 152, 208, 142, 253, 216, 249 },
-    { 162, 118, 152, 209, 142, 253, 216, 249 },
-    { 163, 119, 153, 210, 143, 253, 217, 249 },
-    { 164, 119, 153, 211, 143, 253, 217, 249 },
-    { 166, 120, 153, 212, 144, 254, 218, 250 },
-    { 167, 120, 153, 212, 145, 254, 219, 250 },
-    { 168, 121, 154, 213, 146, 254, 220, 250 },
-    { 169, 121, 154, 214, 146, 254, 220, 250 },
-    { 171, 122, 155, 215, 147, 254, 221, 250 },
-    { 172, 122, 155, 216, 147, 254, 221, 250 },
-    { 173, 123, 155, 217, 148, 254, 222, 250 },
-    { 174, 123, 155, 217, 149, 254, 222, 250 },
-    { 176, 124, 156, 218, 150, 254, 223, 250 },
-    { 177, 124, 156, 219, 150, 254, 223, 250 },
-    { 178, 125, 157, 220, 151, 254, 224, 251 },
-    { 179, 125, 157, 220, 151, 254, 224, 251 },
-    { 180, 126, 157, 221, 152, 254, 225, 251 },
-    { 181, 126, 157, 221, 152, 254, 225, 251 },
-    { 183, 127, 158, 222, 153, 254, 226, 251 },
-    { 184, 127, 158, 223, 154, 254, 226, 251 },
-    { 185, 128, 159, 224, 155, 255, 227, 251 },
-    { 186, 128, 159, 224, 155, 255, 227, 251 },
-    { 187, 129, 160, 225, 156, 255, 228, 251 },
-    { 188, 130, 160, 225, 156, 255, 228, 251 },
-    { 189, 131, 160, 226, 157, 255, 228, 251 },
-    { 190, 131, 160, 226, 158, 255, 228, 251 },
-    { 191, 132, 161, 227, 159, 255, 229, 251 },
-    { 192, 132, 161, 227, 159, 255, 229, 251 },
-    { 193, 133, 162, 228, 160, 255, 230, 252 },
-    { 194, 133, 162, 229, 160, 255, 230, 252 },
-    { 195, 134, 163, 230, 161, 255, 231, 252 },
-    { 196, 134, 163, 230, 161, 255, 231, 252 },
-    { 197, 135, 163, 231, 162, 255, 231, 252 },
-    { 198, 135, 163, 231, 162, 255, 231, 252 },
-    { 199, 136, 164, 232, 163, 255, 232, 252 },
-    { 200, 136, 164, 232, 164, 255, 232, 252 },
-    { 201, 137, 165, 233, 165, 255, 233, 252 },
-    { 201, 137, 165, 233, 165, 255, 233, 252 },
-    { 202, 138, 166, 233, 166, 255, 233, 252 },
-    { 203, 138, 166, 233, 166, 255, 233, 252 },
-    { 204, 139, 166, 234, 167, 255, 234, 252 },
-    { 205, 139, 166, 234, 167, 255, 234, 252 },
-    { 206, 140, 167, 235, 168, 255, 235, 252 },
-    { 206, 140, 167, 235, 168, 255, 235, 252 },
-    { 207, 141, 168, 236, 169, 255, 235, 252 },
-    { 208, 141, 168, 236, 170, 255, 235, 252 },
-    { 209, 142, 169, 237, 171, 255, 236, 252 },
-    { 209, 143, 169, 237, 171, 255, 236, 252 },
-    { 210, 144, 169, 237, 172, 255, 236, 252 },
-    { 211, 144, 169, 237, 172, 255, 236, 252 },
-    { 212, 145, 170, 238, 173, 255, 237, 252 },
-    { 213, 145, 170, 238, 173, 255, 237, 252 },
-    { 214, 146, 171, 239, 174, 255, 237, 253 },
-    { 214, 146, 171, 239, 174, 255, 237, 253 },
-    { 215, 147, 172, 240, 175, 255, 238, 253 },
-    { 215, 147, 172, 240, 175, 255, 238, 253 },
-    { 216, 148, 173, 240, 176, 255, 238, 253 },
-    { 217, 148, 173, 240, 176, 255, 238, 253 },
-    { 218, 149, 173, 241, 177, 255, 239, 253 },
-    { 218, 149, 173, 241, 178, 255, 239, 253 },
-    { 219, 150, 174, 241, 179, 255, 239, 253 },
-    { 219, 151, 174, 241, 179, 255, 239, 253 },
-    { 220, 152, 175, 242, 180, 255, 240, 253 },
-    { 221, 152, 175, 242, 180, 255, 240, 253 },
-    { 222, 153, 176, 242, 181, 255, 240, 253 },
-    { 222, 153, 176, 242, 181, 255, 240, 253 },
-    { 223, 154, 177, 243, 182, 255, 240, 253 },
-    { 223, 154, 177, 243, 182, 255, 240, 253 },
-    { 224, 155, 178, 244, 183, 255, 241, 253 },
-    { 224, 155, 178, 244, 183, 255, 241, 253 },
-    { 225, 156, 178, 244, 184, 255, 241, 253 },
-    { 225, 157, 178, 244, 184, 255, 241, 253 },
-    { 226, 158, 179, 244, 185, 255, 242, 253 },
-    { 227, 158, 179, 244, 185, 255, 242, 253 },
-    { 228, 159, 180, 245, 186, 255, 242, 253 },
-    { 228, 159, 180, 245, 186, 255, 242, 253 },
-    { 229, 160, 181, 245, 187, 255, 242, 253 },
-    { 229, 160, 181, 245, 187, 255, 242, 253 },
-    { 230, 161, 182, 246, 188, 255, 243, 253 },
-    { 230, 162, 182, 246, 188, 255, 243, 253 },
-    { 231, 163, 183, 246, 189, 255, 243, 253 },
-    { 231, 163, 183, 246, 189, 255, 243, 253 },
-    { 232, 164, 184, 247, 190, 255, 243, 253 },
-    { 232, 164, 184, 247, 190, 255, 243, 253 },
-    { 233, 165, 185, 247, 191, 255, 244, 253 },
-    { 233, 165, 185, 247, 191, 255, 244, 253 },
-    { 234, 166, 185, 247, 192, 255, 244, 253 },
-    { 234, 167, 185, 247, 192, 255, 244, 253 },
-    { 235, 168, 186, 248, 193, 255, 244, 253 },
-    { 235, 168, 186, 248, 193, 255, 244, 253 },
-    { 236, 169, 187, 248, 194, 255, 244, 253 },
-    { 236, 169, 187, 248, 194, 255, 244, 253 },
-    { 236, 170, 188, 248, 195, 255, 245, 253 },
-    { 236, 170, 188, 248, 195, 255, 245, 253 },
-    { 237, 171, 189, 249, 196, 255, 245, 254 },
-    { 237, 172, 189, 249, 196, 255, 245, 254 },
-    { 238, 173, 190, 249, 197, 255, 245, 254 },
-    { 238, 173, 190, 249, 197, 255, 245, 254 },
-    { 239, 174, 191, 249, 198, 255, 245, 254 },
-    { 239, 174, 191, 249, 198, 255, 245, 254 },
-    { 240, 175, 192, 249, 199, 255, 246, 254 },
-    { 240, 176, 192, 249, 199, 255, 246, 254 },
-    { 240, 177, 193, 250, 200, 255, 246, 254 },
-    { 240, 177, 193, 250, 200, 255, 246, 254 },
-    { 241, 178, 194, 250, 201, 255, 246, 254 },
-    { 241, 178, 194, 250, 201, 255, 246, 254 },
-    { 242, 179, 195, 250, 202, 255, 246, 254 },
-    { 242, 180, 195, 250, 202, 255, 246, 254 },
-    { 242, 181, 196, 250, 203, 255, 247, 254 },
-    { 242, 181, 196, 250, 203, 255, 247, 254 },
-    { 243, 182, 197, 251, 204, 255, 247, 254 },
-    { 243, 183, 197, 251, 204, 255, 247, 254 },
-    { 244, 184, 198, 251, 205, 255, 247, 254 },
-    { 244, 184, 198, 251, 205, 255, 247, 254 },
-    { 244, 185, 199, 251, 206, 255, 247, 254 },
-    { 244, 185, 199, 251, 206, 255, 247, 254 },
-    { 245, 186, 200, 251, 207, 255, 247, 254 },
-    { 245, 187, 200, 251, 207, 255, 247, 254 },
-    { 246, 188, 201, 252, 207, 255, 248, 254 },
-    { 246, 188, 201, 252, 207, 255, 248, 254 },
-    { 246, 189, 202, 252, 208, 255, 248, 254 },
-    { 246, 190, 202, 252, 208, 255, 248, 254 },
-    { 247, 191, 203, 252, 209, 255, 248, 254 },
-    { 247, 191, 203, 252, 209, 255, 248, 254 },
-    { 247, 192, 204, 252, 210, 255, 248, 254 },
-    { 247, 193, 204, 252, 210, 255, 248, 254 },
-    { 248, 194, 205, 252, 211, 255, 248, 254 },
-    { 248, 194, 205, 252, 211, 255, 248, 254 },
-    { 248, 195, 206, 252, 212, 255, 249, 254 },
-    { 248, 196, 206, 252, 212, 255, 249, 254 },
-    { 249, 197, 207, 253, 213, 255, 249, 254 },
-    { 249, 197, 207, 253, 213, 255, 249, 254 },
-    { 249, 198, 208, 253, 214, 255, 249, 254 },
-    { 249, 199, 209, 253, 214, 255, 249, 254 },
-    { 250, 200, 210, 253, 215, 255, 249, 254 },
-    { 250, 200, 210, 253, 215, 255, 249, 254 },
-    { 250, 201, 211, 253, 215, 255, 249, 254 },
-    { 250, 202, 211, 253, 215, 255, 249, 254 },
-    { 250, 203, 212, 253, 216, 255, 249, 254 },
-    { 250, 203, 212, 253, 216, 255, 249, 254 },
-    { 251, 204, 213, 253, 217, 255, 250, 254 },
-    { 251, 205, 213, 253, 217, 255, 250, 254 },
-    { 251, 206, 214, 254, 218, 255, 250, 254 },
-    { 251, 206, 215, 254, 218, 255, 250, 254 },
-    { 252, 207, 216, 254, 219, 255, 250, 254 },
-    { 252, 208, 216, 254, 219, 255, 250, 254 },
-    { 252, 209, 217, 254, 220, 255, 250, 254 },
-    { 252, 210, 217, 254, 220, 255, 250, 254 },
-    { 252, 211, 218, 254, 221, 255, 250, 254 },
-    { 252, 212, 218, 254, 221, 255, 250, 254 },
-    { 253, 213, 219, 254, 222, 255, 250, 254 },
-    { 253, 213, 220, 254, 222, 255, 250, 254 },
-    { 253, 214, 221, 254, 223, 255, 250, 254 },
-    { 253, 215, 221, 254, 223, 255, 250, 254 },
-    { 253, 216, 222, 254, 224, 255, 251, 254 },
-    { 253, 217, 223, 254, 224, 255, 251, 254 },
-    { 253, 218, 224, 254, 225, 255, 251, 254 },
-    { 253, 219, 224, 254, 225, 255, 251, 254 },
-    { 254, 220, 225, 254, 225, 255, 251, 254 },
-    { 254, 221, 226, 254, 225, 255, 251, 254 },
-    { 254, 222, 227, 255, 226, 255, 251, 254 },
-    { 254, 223, 227, 255, 226, 255, 251, 254 },
-    { 254, 224, 228, 255, 227, 255, 251, 254 },
-    { 254, 225, 229, 255, 227, 255, 251, 254 },
-    { 254, 226, 230, 255, 228, 255, 251, 254 },
-    { 254, 227, 230, 255, 229, 255, 251, 254 },
-    { 255, 228, 231, 255, 230, 255, 251, 254 },
-    { 255, 229, 232, 255, 230, 255, 251, 254 },
-    { 255, 230, 233, 255, 231, 255, 252, 254 },
-    { 255, 231, 234, 255, 231, 255, 252, 254 },
-    { 255, 232, 235, 255, 232, 255, 252, 254 },
-    { 255, 233, 236, 255, 232, 255, 252, 254 },
-    { 255, 235, 237, 255, 233, 255, 252, 254 },
-    { 255, 236, 238, 255, 234, 255, 252, 254 },
-    { 255, 238, 240, 255, 235, 255, 252, 255 },
-    { 255, 239, 241, 255, 235, 255, 252, 254 },
-    { 255, 241, 243, 255, 236, 255, 252, 254 },
-    { 255, 243, 245, 255, 237, 255, 252, 254 },
-    { 255, 246, 247, 255, 239, 255, 253, 255 },
-};
-
-typedef struct {
-    uint8_t y_mode[4][9];
-    uint8_t uv_mode[10][9];
-    uint8_t filter[4][2];
-    uint8_t mv_mode[7][3];
-    uint8_t intra[4];
-    uint8_t comp[5];
-    uint8_t single_ref[5][2];
-    uint8_t comp_ref[5];
-    uint8_t tx32p[2][3];
-    uint8_t tx16p[2][2];
-    uint8_t tx8p[2];
-    uint8_t skip[3];
-    uint8_t mv_joint[3];
-    struct {
-        uint8_t sign;
-        uint8_t classes[10];
-        uint8_t class0;
-        uint8_t bits[10];
-        uint8_t class0_fp[2][3];
-        uint8_t fp[3];
-        uint8_t class0_hp;
-        uint8_t hp;
-    } mv_comp[2];
-    uint8_t partition[4][4][3];
-} prob_context;
-
-static const prob_context vp9_default_probs = {
-    { /* y_mode */
-        {  65,  32,  18, 144, 162, 194,  41,  51,  98 } /* bsize < 8x8 */,
-        { 132,  68,  18, 165, 217, 196,  45,  40,  78 } /* bsize < 16x16 */,
-        { 173,  80,  19, 176, 240, 193,  64,  35,  46 } /* bsize < 32x32 */,
-        { 221, 135,  38, 194, 248, 121,  96,  85,  29 } /* bsize >= 32x32 */
-    }, { /* uv_mode */
-        {  48,  12, 154, 155, 139,  90,  34, 117, 119 } /* y = v */,
-        {  67,   6,  25, 204, 243, 158,  13,  21,  96 } /* y = h */,
-        { 120,   7,  76, 176, 208, 126,  28,  54, 103 } /* y = dc */,
-        {  97,   5,  44, 131, 176, 139,  48,  68,  97 } /* y = d45 */,
-        {  83,   5,  42, 156, 111, 152,  26,  49, 152 } /* y = d135 */,
-        {  80,   5,  58, 178,  74,  83,  33,  62, 145 } /* y = d117 */,
-        {  86,   5,  32, 154, 192, 168,  14,  22, 163 } /* y = d153 */,
-        {  77,   7,  64, 116, 132, 122,  37, 126, 120 } /* y = d63 */,
-        {  85,   5,  32, 156, 216, 148,  19,  29,  73 } /* y = d27 */,
-        { 101,  21, 107, 181, 192, 103,  19,  67, 125 } /* y = tm */
-    }, { /* filter */
-        { 235, 162, },
-        {  36, 255, },
-        {  34,   3, },
-        { 149, 144, },
-    }, { /* mv_mode */
-        {  2, 173,  34},  // 0 = both zero mv
-        {  7, 145,  85},  // 1 = one zero mv + one a predicted mv
-        {  7, 166,  63},  // 2 = two predicted mvs
-        {  7,  94,  66},  // 3 = one predicted/zero and one new mv
-        {  8,  64,  46},  // 4 = two new mvs
-        { 17,  81,  31},  // 5 = one intra neighbour + x
-        { 25,  29,  30},  // 6 = two intra neighbours
-    }, { /* intra */
-        9, 102, 187, 225
-    }, { /* comp */
-        239, 183, 119,  96,  41
-    }, { /* single_ref */
-        {  33,  16 },
-        {  77,  74 },
-        { 142, 142 },
-        { 172, 170 },
-        { 238, 247 }
-    }, { /* comp_ref */
-        50, 126, 123, 221, 226
-    }, { /* tx32p */
-        { 3, 136, 37, },
-        { 5,  52, 13, },
-    }, { /* tx16p */
-        { 20, 152, },
-        { 15, 101, },
-    }, { /* tx8p */
-        100, 66
-    }, { /* skip */
-        192, 128, 64
-    }, { /* mv_joint */
-        32, 64, 96
-    }, {
-        { /* mv vertical component */
-            128, /* sign */
-            { 224, 144, 192, 168, 192, 176, 192, 198, 198, 245 }, /* class */
-            216, /* class0 */
-            { 136, 140, 148, 160, 176, 192, 224, 234, 234, 240}, /* bits */
-            { /* class0_fp */
-                { 128, 128, 64 },
-                {  96, 112, 64 }
-            },
-            { 64, 96, 64 }, /* fp */
-            160, /* class0_hp bit */
-            128, /* hp */
-        }, { /* mv horizontal component */
-            128, /* sign */
-            { 216, 128, 176, 160, 176, 176, 192, 198, 198, 208 }, /* class */
-            208, /* class0 */
-            { 136, 140, 148, 160, 176, 192, 224, 234, 234, 240 }, /* bits */
-            { /* class0_fp */
-                { 128, 128, 64 },
-                {  96, 112, 64 }
-            },
-            { 64, 96, 64 }, /* fp */
-            160, /* class0_hp bit */
-            128, /* hp */
-        }
-    }, { /* partition */
-        { /* 64x64 -> 32x32 */
-            { 222,  34,  30 } /* a/l both not split */,
-            {  72,  16,  44 } /* a split, l not split */,
-            {  58,  32,  12 } /* l split, a not split */,
-            {  10,   7,   6 } /* a/l both split */,
-        }, { /* 32x32 -> 16x16 */
-            { 177,  58,  59 } /* a/l both not split */,
-            {  68,  26,  63 } /* a split, l not split */,
-            {  52,  79,  25 } /* l split, a not split */,
-            {  17,  14,  12 } /* a/l both split */,
-        }, { /* 16x16 -> 8x8 */
-            { 174,  73,  87 } /* a/l both not split */,
-            {  92,  41,  83 } /* a split, l not split */,
-            {  82,  99,  50 } /* l split, a not split */,
-            {  53,  39,  39 } /* a/l both split */,
-        }, { /* 8x8 -> 4x4 */
-            { 199, 122, 141 } /* a/l both not split */,
-            { 147,  63, 159 } /* a split, l not split */,
-            { 148, 133, 118 } /* l split, a not split */,
-            { 121, 104, 114 } /* a/l both split */,
-        }
-    },
-};
-
-static const uint8_t vp9_default_coef_probs[4][2][2][6][6][3] = {
-    { /* tx = 4x4 */
-        { /* block Type 0 */
-            { /* Intra */
-                { /* Coeff Band 0 */
-                    { 195,  29, 183 },
-                    {  84,  49, 136 },
-                    {   8,  42,  71 }
-                }, { /* Coeff Band 1 */
-                    {  31, 107, 169 },
-                    {  35,  99, 159 },
-                    {  17,  82, 140 },
-                    {   8,  66, 114 },
-                    {   2,  44,  76 },
-                    {   1,  19,  32 }
-                }, { /* Coeff Band 2 */
-                    {  40, 132, 201 },
-                    {  29, 114, 187 },
-                    {  13,  91, 157 },
-                    {   7,  75, 127 },
-                    {   3,  58,  95 },
-                    {   1,  28,  47 }
-                }, { /* Coeff Band 3 */
-                    {  69, 142, 221 },
-                    {  42, 122, 201 },
-                    {  15,  91, 159 },
-                    {   6,  67, 121 },
-                    {   1,  42,  77 },
-                    {   1,  17,  31 }
-                }, { /* Coeff Band 4 */
-                    { 102, 148, 228 },
-                    {  67, 117, 204 },
-                    {  17,  82, 154 },
-                    {   6,  59, 114 },
-                    {   2,  39,  75 },
-                    {   1,  15,  29 }
-                }, { /* Coeff Band 5 */
-                    { 156,  57, 233 },
-                    { 119,  57, 212 },
-                    {  58,  48, 163 },
-                    {  29,  40, 124 },
-                    {  12,  30,  81 },
-                    {   3,  12,  31 }
-                }
-            }, { /* Inter */
-                { /* Coeff Band 0 */
-                    { 191, 107, 226 },
-                    { 124, 117, 204 },
-                    {  25,  99, 155 }
-                }, { /* Coeff Band 1 */
-                    {  29, 148, 210 },
-                    {  37, 126, 194 },
-                    {   8,  93, 157 },
-                    {   2,  68, 118 },
-                    {   1,  39,  69 },
-                    {   1,  17,  33 }
-                }, { /* Coeff Band 2 */
-                    {  41, 151, 213 },
-                    {  27, 123, 193 },
-                    {   3,  82, 144 },
-                    {   1,  58, 105 },
-                    {   1,  32,  60 },
-                    {   1,  13,  26 }
-                }, { /* Coeff Band 3 */
-                    {  59, 159, 220 },
-                    {  23, 126, 198 },
-                    {   4,  88, 151 },
-                    {   1,  66, 114 },
-                    {   1,  38,  71 },
-                    {   1,  18,  34 }
-                }, { /* Coeff Band 4 */
-                    { 114, 136, 232 },
-                    {  51, 114, 207 },
-                    {  11,  83, 155 },
-                    {   3,  56, 105 },
-                    {   1,  33,  65 },
-                    {   1,  17,  34 }
-                }, { /* Coeff Band 5 */
-                    { 149,  65, 234 },
-                    { 121,  57, 215 },
-                    {  61,  49, 166 },
-                    {  28,  36, 114 },
-                    {  12,  25,  76 },
-                    {   3,  16,  42 }
-                }
-            }
-        }, { /* block Type 1 */
-            { /* Intra */
-                { /* Coeff Band 0 */
-                    { 214,  49, 220 },
-                    { 132,  63, 188 },
-                    {  42,  65, 137 }
-                }, { /* Coeff Band 1 */
-                    {  85, 137, 221 },
-                    { 104, 131, 216 },
-                    {  49, 111, 192 },
-                    {  21,  87, 155 },
-                    {   2,  49,  87 },
-                    {   1,  16,  28 }
-                }, { /* Coeff Band 2 */
-                    {  89, 163, 230 },
-                    {  90, 137, 220 },
-                    {  29, 100, 183 },
-                    {  10,  70, 135 },
-                    {   2,  42,  81 },
-                    {   1,  17,  33 }
-                }, { /* Coeff Band 3 */
-                    { 108, 167, 237 },
-                    {  55, 133, 222 },
-                    {  15,  97, 179 },
-                    {   4,  72, 135 },
-                    {   1,  45,  85 },
-                    {   1,  19,  38 }
-                }, { /* Coeff Band 4 */
-                    { 124, 146, 240 },
-                    {  66, 124, 224 },
-                    {  17,  88, 175 },
-                    {   4,  58, 122 },
-                    {   1,  36,  75 },
-                    {   1,  18,  37 }
-                }, { /* Coeff Band 5 */
-                    { 141,  79, 241 },
-                    { 126,  70, 227 },
-                    {  66,  58, 182 },
-                    {  30,  44, 136 },
-                    {  12,  34,  96 },
-                    {   2,  20,  47 }
-                }
-            }, { /* Inter */
-                { /* Coeff Band 0 */
-                    { 229,  99, 249 },
-                    { 143, 111, 235 },
-                    {  46, 109, 192 }
-                }, { /* Coeff Band 1 */
-                    {  82, 158, 236 },
-                    {  94, 146, 224 },
-                    {  25, 117, 191 },
-                    {   9,  87, 149 },
-                    {   3,  56,  99 },
-                    {   1,  33,  57 }
-                }, { /* Coeff Band 2 */
-                    {  83, 167, 237 },
-                    {  68, 145, 222 },
-                    {  10, 103, 177 },
-                    {   2,  72, 131 },
-                    {   1,  41,  79 },
-                    {   1,  20,  39 }
-                }, { /* Coeff Band 3 */
-                    {  99, 167, 239 },
-                    {  47, 141, 224 },
-                    {  10, 104, 178 },
-                    {   2,  73, 133 },
-                    {   1,  44,  85 },
-                    {   1,  22,  47 }
-                }, { /* Coeff Band 4 */
-                    { 127, 145, 243 },
-                    {  71, 129, 228 },
-                    {  17,  93, 177 },
-                    {   3,  61, 124 },
-                    {   1,  41,  84 },
-                    {   1,  21,  52 }
-                }, { /* Coeff Band 5 */
-                    { 157,  78, 244 },
-                    { 140,  72, 231 },
-                    {  69,  58, 184 },
-                    {  31,  44, 137 },
-                    {  14,  38, 105 },
-                    {   8,  23,  61 }
-                }
-            }
-        }
-    }, { /* tx = 8x8 */
-        { /* block Type 0 */
-            { /* Intra */
-                { /* Coeff Band 0 */
-                    { 125,  34, 187 },
-                    {  52,  41, 133 },
-                    {   6,  31,  56 }
-                }, { /* Coeff Band 1 */
-                    {  37, 109, 153 },
-                    {  51, 102, 147 },
-                    {  23,  87, 128 },
-                    {   8,  67, 101 },
-                    {   1,  41,  63 },
-                    {   1,  19,  29 }
-                }, { /* Coeff Band 2 */
-                    {  31, 154, 185 },
-                    {  17, 127, 175 },
-                    {   6,  96, 145 },
-                    {   2,  73, 114 },
-                    {   1,  51,  82 },
-                    {   1,  28,  45 }
-                }, { /* Coeff Band 3 */
-                    {  23, 163, 200 },
-                    {  10, 131, 185 },
-                    {   2,  93, 148 },
-                    {   1,  67, 111 },
-                    {   1,  41,  69 },
-                    {   1,  14,  24 }
-                }, { /* Coeff Band 4 */
-                    {  29, 176, 217 },
-                    {  12, 145, 201 },
-                    {   3, 101, 156 },
-                    {   1,  69, 111 },
-                    {   1,  39,  63 },
-                    {   1,  14,  23 }
-                }, { /* Coeff Band 5 */
-                    {  57, 192, 233 },
-                    {  25, 154, 215 },
-                    {   6, 109, 167 },
-                    {   3,  78, 118 },
-                    {   1,  48,  69 },
-                    {   1,  21,  29 }
-                }
-            }, { /* Inter */
-                { /* Coeff Band 0 */
-                    { 202, 105, 245 },
-                    { 108, 106, 216 },
-                    {  18,  90, 144 }
-                }, { /* Coeff Band 1 */
-                    {  33, 172, 219 },
-                    {  64, 149, 206 },
-                    {  14, 117, 177 },
-                    {   5,  90, 141 },
-                    {   2,  61,  95 },
-                    {   1,  37,  57 }
-                }, { /* Coeff Band 2 */
-                    {  33, 179, 220 },
-                    {  11, 140, 198 },
-                    {   1,  89, 148 },
-                    {   1,  60, 104 },
-                    {   1,  33,  57 },
-                    {   1,  12,  21 }
-                }, { /* Coeff Band 3 */
-                    {  30, 181, 221 },
-                    {   8, 141, 198 },
-                    {   1,  87, 145 },
-                    {   1,  58, 100 },
-                    {   1,  31,  55 },
-                    {   1,  12,  20 }
-                }, { /* Coeff Band 4 */
-                    {  32, 186, 224 },
-                    {   7, 142, 198 },
-                    {   1,  86, 143 },
-                    {   1,  58, 100 },
-                    {   1,  31,  55 },
-                    {   1,  12,  22 }
-                }, { /* Coeff Band 5 */
-                    {  57, 192, 227 },
-                    {  20, 143, 204 },
-                    {   3,  96, 154 },
-                    {   1,  68, 112 },
-                    {   1,  42,  69 },
-                    {   1,  19,  32 }
-                }
-            }
-        }, { /* block Type 1 */
-            { /* Intra */
-                { /* Coeff Band 0 */
-                    { 212,  35, 215 },
-                    { 113,  47, 169 },
-                    {  29,  48, 105 }
-                }, { /* Coeff Band 1 */
-                    {  74, 129, 203 },
-                    { 106, 120, 203 },
-                    {  49, 107, 178 },
-                    {  19,  84, 144 },
-                    {   4,  50,  84 },
-                    {   1,  15,  25 }
-                }, { /* Coeff Band 2 */
-                    {  71, 172, 217 },
-                    {  44, 141, 209 },
-                    {  15, 102, 173 },
-                    {   6,  76, 133 },
-                    {   2,  51,  89 },
-                    {   1,  24,  42 }
-                }, { /* Coeff Band 3 */
-                    {  64, 185, 231 },
-                    {  31, 148, 216 },
-                    {   8, 103, 175 },
-                    {   3,  74, 131 },
-                    {   1,  46,  81 },
-                    {   1,  18,  30 }
-                }, { /* Coeff Band 4 */
-                    {  65, 196, 235 },
-                    {  25, 157, 221 },
-                    {   5, 105, 174 },
-                    {   1,  67, 120 },
-                    {   1,  38,  69 },
-                    {   1,  15,  30 }
-                }, { /* Coeff Band 5 */
-                    {  65, 204, 238 },
-                    {  30, 156, 224 },
-                    {   7, 107, 177 },
-                    {   2,  70, 124 },
-                    {   1,  42,  73 },
-                    {   1,  18,  34 }
-                }
-            }, { /* Inter */
-                { /* Coeff Band 0 */
-                    { 225,  86, 251 },
-                    { 144, 104, 235 },
-                    {  42,  99, 181 }
-                }, { /* Coeff Band 1 */
-                    {  85, 175, 239 },
-                    { 112, 165, 229 },
-                    {  29, 136, 200 },
-                    {  12, 103, 162 },
-                    {   6,  77, 123 },
-                    {   2,  53,  84 }
-                }, { /* Coeff Band 2 */
-                    {  75, 183, 239 },
-                    {  30, 155, 221 },
-                    {   3, 106, 171 },
-                    {   1,  74, 128 },
-                    {   1,  44,  76 },
-                    {   1,  17,  28 }
-                }, { /* Coeff Band 3 */
-                    {  73, 185, 240 },
-                    {  27, 159, 222 },
-                    {   2, 107, 172 },
-                    {   1,  75, 127 },
-                    {   1,  42,  73 },
-                    {   1,  17,  29 }
-                }, { /* Coeff Band 4 */
-                    {  62, 190, 238 },
-                    {  21, 159, 222 },
-                    {   2, 107, 172 },
-                    {   1,  72, 122 },
-                    {   1,  40,  71 },
-                    {   1,  18,  32 }
-                }, { /* Coeff Band 5 */
-                    {  61, 199, 240 },
-                    {  27, 161, 226 },
-                    {   4, 113, 180 },
-                    {   1,  76, 129 },
-                    {   1,  46,  80 },
-                    {   1,  23,  41 }
-                }
-            }
-        }
-    }, { /* tx = 16x16 */
-        { /* block Type 0 */
-            { /* Intra */
-                { /* Coeff Band 0 */
-                    {   7,  27, 153 },
-                    {   5,  30,  95 },
-                    {   1,  16,  30 }
-                }, { /* Coeff Band 1 */
-                    {  50,  75, 127 },
-                    {  57,  75, 124 },
-                    {  27,  67, 108 },
-                    {  10,  54,  86 },
-                    {   1,  33,  52 },
-                    {   1,  12,  18 }
-                }, { /* Coeff Band 2 */
-                    {  43, 125, 151 },
-                    {  26, 108, 148 },
-                    {   7,  83, 122 },
-                    {   2,  59,  89 },
-                    {   1,  38,  60 },
-                    {   1,  17,  27 }
-                }, { /* Coeff Band 3 */
-                    {  23, 144, 163 },
-                    {  13, 112, 154 },
-                    {   2,  75, 117 },
-                    {   1,  50,  81 },
-                    {   1,  31,  51 },
-                    {   1,  14,  23 }
-                }, { /* Coeff Band 4 */
-                    {  18, 162, 185 },
-                    {   6, 123, 171 },
-                    {   1,  78, 125 },
-                    {   1,  51,  86 },
-                    {   1,  31,  54 },
-                    {   1,  14,  23 }
-                }, { /* Coeff Band 5 */
-                    {  15, 199, 227 },
-                    {   3, 150, 204 },
-                    {   1,  91, 146 },
-                    {   1,  55,  95 },
-                    {   1,  30,  53 },
-                    {   1,  11,  20 }
-                }
-            }, { /* Inter */
-                { /* Coeff Band 0 */
-                    {  19,  55, 240 },
-                    {  19,  59, 196 },
-                    {   3,  52, 105 }
-                }, { /* Coeff Band 1 */
-                    {  41, 166, 207 },
-                    { 104, 153, 199 },
-                    {  31, 123, 181 },
-                    {  14, 101, 152 },
-                    {   5,  72, 106 },
-                    {   1,  36,  52 }
-                }, { /* Coeff Band 2 */
-                    {  35, 176, 211 },
-                    {  12, 131, 190 },
-                    {   2,  88, 144 },
-                    {   1,  60, 101 },
-                    {   1,  36,  60 },
-                    {   1,  16,  28 }
-                }, { /* Coeff Band 3 */
-                    {  28, 183, 213 },
-                    {   8, 134, 191 },
-                    {   1,  86, 142 },
-                    {   1,  56,  96 },
-                    {   1,  30,  53 },
-                    {   1,  12,  20 }
-                }, { /* Coeff Band 4 */
-                    {  20, 190, 215 },
-                    {   4, 135, 192 },
-                    {   1,  84, 139 },
-                    {   1,  53,  91 },
-                    {   1,  28,  49 },
-                    {   1,  11,  20 }
-                }, { /* Coeff Band 5 */
-                    {  13, 196, 216 },
-                    {   2, 137, 192 },
-                    {   1,  86, 143 },
-                    {   1,  57,  99 },
-                    {   1,  32,  56 },
-                    {   1,  13,  24 }
-                }
-            }
-        }, { /* block Type 1 */
-            { /* Intra */
-                { /* Coeff Band 0 */
-                    { 211,  29, 217 },
-                    {  96,  47, 156 },
-                    {  22,  43,  87 }
-                }, { /* Coeff Band 1 */
-                    {  78, 120, 193 },
-                    { 111, 116, 186 },
-                    {  46, 102, 164 },
-                    {  15,  80, 128 },
-                    {   2,  49,  76 },
-                    {   1,  18,  28 }
-                }, { /* Coeff Band 2 */
-                    {  71, 161, 203 },
-                    {  42, 132, 192 },
-                    {  10,  98, 150 },
-                    {   3,  69, 109 },
-                    {   1,  44,  70 },
-                    {   1,  18,  29 }
-                }, { /* Coeff Band 3 */
-                    {  57, 186, 211 },
-                    {  30, 140, 196 },
-                    {   4,  93, 146 },
-                    {   1,  62, 102 },
-                    {   1,  38,  65 },
-                    {   1,  16,  27 }
-                }, { /* Coeff Band 4 */
-                    {  47, 199, 217 },
-                    {  14, 145, 196 },
-                    {   1,  88, 142 },
-                    {   1,  57,  98 },
-                    {   1,  36,  62 },
-                    {   1,  15,  26 }
-                }, { /* Coeff Band 5 */
-                    {  26, 219, 229 },
-                    {   5, 155, 207 },
-                    {   1,  94, 151 },
-                    {   1,  60, 104 },
-                    {   1,  36,  62 },
-                    {   1,  16,  28 }
-                }
-            }, { /* Inter */
-                { /* Coeff Band 0 */
-                    { 233,  29, 248 },
-                    { 146,  47, 220 },
-                    {  43,  52, 140 }
-                }, { /* Coeff Band 1 */
-                    { 100, 163, 232 },
-                    { 179, 161, 222 },
-                    {  63, 142, 204 },
-                    {  37, 113, 174 },
-                    {  26,  89, 137 },
-                    {  18,  68,  97 }
-                }, { /* Coeff Band 2 */
-                    {  85, 181, 230 },
-                    {  32, 146, 209 },
-                    {   7, 100, 164 },
-                    {   3,  71, 121 },
-                    {   1,  45,  77 },
-                    {   1,  18,  30 }
-                }, { /* Coeff Band 3 */
-                    {  65, 187, 230 },
-                    {  20, 148, 207 },
-                    {   2,  97, 159 },
-                    {   1,  68, 116 },
-                    {   1,  40,  70 },
-                    {   1,  14,  29 }
-                }, { /* Coeff Band 4 */
-                    {  40, 194, 227 },
-                    {   8, 147, 204 },
-                    {   1,  94, 155 },
-                    {   1,  65, 112 },
-                    {   1,  39,  66 },
-                    {   1,  14,  26 }
-                }, { /* Coeff Band 5 */
-                    {  16, 208, 228 },
-                    {   3, 151, 207 },
-                    {   1,  98, 160 },
-                    {   1,  67, 117 },
-                    {   1,  41,  74 },
-                    {   1,  17,  31 }
-                }
-            }
-        }
-    }, { /* tx = 32x32 */
-        { /* block Type 0 */
-            { /* Intra */
-                { /* Coeff Band 0 */
-                    {  17,  38, 140 },
-                    {   7,  34,  80 },
-                    {   1,  17,  29 }
-                }, { /* Coeff Band 1 */
-                    {  37,  75, 128 },
-                    {  41,  76, 128 },
-                    {  26,  66, 116 },
-                    {  12,  52,  94 },
-                    {   2,  32,  55 },
-                    {   1,  10,  16 }
-                }, { /* Coeff Band 2 */
-                    {  50, 127, 154 },
-                    {  37, 109, 152 },
-                    {  16,  82, 121 },
-                    {   5,  59,  85 },
-                    {   1,  35,  54 },
-                    {   1,  13,  20 }
-                }, { /* Coeff Band 3 */
-                    {  40, 142, 167 },
-                    {  17, 110, 157 },
-                    {   2,  71, 112 },
-                    {   1,  44,  72 },
-                    {   1,  27,  45 },
-                    {   1,  11,  17 }
-                }, { /* Coeff Band 4 */
-                    {  30, 175, 188 },
-                    {   9, 124, 169 },
-                    {   1,  74, 116 },
-                    {   1,  48,  78 },
-                    {   1,  30,  49 },
-                    {   1,  11,  18 }
-                }, { /* Coeff Band 5 */
-                    {  10, 222, 223 },
-                    {   2, 150, 194 },
-                    {   1,  83, 128 },
-                    {   1,  48,  79 },
-                    {   1,  27,  45 },
-                    {   1,  11,  17 }
-                }
-            }, { /* Inter */
-                { /* Coeff Band 0 */
-                    {  36,  41, 235 },
-                    {  29,  36, 193 },
-                    {  10,  27, 111 }
-                }, { /* Coeff Band 1 */
-                    {  85, 165, 222 },
-                    { 177, 162, 215 },
-                    { 110, 135, 195 },
-                    {  57, 113, 168 },
-                    {  23,  83, 120 },
-                    {  10,  49,  61 }
-                }, { /* Coeff Band 2 */
-                    {  85, 190, 223 },
-                    {  36, 139, 200 },
-                    {   5,  90, 146 },
-                    {   1,  60, 103 },
-                    {   1,  38,  65 },
-                    {   1,  18,  30 }
-                }, { /* Coeff Band 3 */
-                    {  72, 202, 223 },
-                    {  23, 141, 199 },
-                    {   2,  86, 140 },
-                    {   1,  56,  97 },
-                    {   1,  36,  61 },
-                    {   1,  16,  27 }
-                }, { /* Coeff Band 4 */
-                    {  55, 218, 225 },
-                    {  13, 145, 200 },
-                    {   1,  86, 141 },
-                    {   1,  57,  99 },
-                    {   1,  35,  61 },
-                    {   1,  13,  22 }
-                }, { /* Coeff Band 5 */
-                    {  15, 235, 212 },
-                    {   1, 132, 184 },
-                    {   1,  84, 139 },
-                    {   1,  57,  97 },
-                    {   1,  34,  56 },
-                    {   1,  14,  23 }
-                }
-            }
-        }, { /* block Type 1 */
-            { /* Intra */
-                { /* Coeff Band 0 */
-                    { 181,  21, 201 },
-                    {  61,  37, 123 },
-                    {  10,  38,  71 }
-                }, { /* Coeff Band 1 */
-                    {  47, 106, 172 },
-                    {  95, 104, 173 },
-                    {  42,  93, 159 },
-                    {  18,  77, 131 },
-                    {   4,  50,  81 },
-                    {   1,  17,  23 }
-                }, { /* Coeff Band 2 */
-                    {  62, 147, 199 },
-                    {  44, 130, 189 },
-                    {  28, 102, 154 },
-                    {  18,  75, 115 },
-                    {   2,  44,  65 },
-                    {   1,  12,  19 }
-                }, { /* Coeff Band 3 */
-                    {  55, 153, 210 },
-                    {  24, 130, 194 },
-                    {   3,  93, 146 },
-                    {   1,  61,  97 },
-                    {   1,  31,  50 },
-                    {   1,  10,  16 }
-                }, { /* Coeff Band 4 */
-                    {  49, 186, 223 },
-                    {  17, 148, 204 },
-                    {   1,  96, 142 },
-                    {   1,  53,  83 },
-                    {   1,  26,  44 },
-                    {   1,  11,  17 }
-                }, { /* Coeff Band 5 */
-                    {  13, 217, 212 },
-                    {   2, 136, 180 },
-                    {   1,  78, 124 },
-                    {   1,  50,  83 },
-                    {   1,  29,  49 },
-                    {   1,  14,  23 }
-                }
-            }, { /* Inter */
-                { /* Coeff Band 0 */
-                    { 197,  13, 247 },
-                    {  82,  17, 222 },
-                    {  25,  17, 162 }
-                }, { /* Coeff Band 1 */
-                    { 126, 186, 247 },
-                    { 234, 191, 243 },
-                    { 176, 177, 234 },
-                    { 104, 158, 220 },
-                    {  66, 128, 186 },
-                    {  55,  90, 137 }
-                }, { /* Coeff Band 2 */
-                    { 111, 197, 242 },
-                    {  46, 158, 219 },
-                    {   9, 104, 171 },
-                    {   2,  65, 125 },
-                    {   1,  44,  80 },
-                    {   1,  17,  91 }
-                }, { /* Coeff Band 3 */
-                    { 104, 208, 245 },
-                    {  39, 168, 224 },
-                    {   3, 109, 162 },
-                    {   1,  79, 124 },
-                    {   1,  50, 102 },
-                    {   1,  43, 102 }
-                }, { /* Coeff Band 4 */
-                    {  84, 220, 246 },
-                    {  31, 177, 231 },
-                    {   2, 115, 180 },
-                    {   1,  79, 134 },
-                    {   1,  55,  77 },
-                    {   1,  60,  79 }
-                }, { /* Coeff Band 5 */
-                    {  43, 243, 240 },
-                    {   8, 180, 217 },
-                    {   1, 115, 166 },
-                    {   1,  84, 121 },
-                    {   1,  51,  67 },
-                    {   1,  16,   6 }
-                }
-            }
-        }
-    }
-};
-
-enum MVJoint {
-    MV_JOINT_ZERO,
-    MV_JOINT_H,
-    MV_JOINT_V,
-    MV_JOINT_HV,
-};
-
-static const int8_t vp9_mv_joint_tree[3][2] = {
-    { -MV_JOINT_ZERO, 1 },           // '0'
-     { -MV_JOINT_H, 2 },             // '10'
-      { -MV_JOINT_V, -MV_JOINT_HV }, // '11x'
-};
-
-static const int8_t vp9_mv_class_tree[10][2] = {
-    { -0, 1 },         // '0'
-     { -1, 2 },        // '10'
-      { 3, 4 },
-       { -2, -3 },     // '110x'
-       { 5, 6 },
-        { -4, -5 },    // '1110x'
-        { -6, 7 },     // '11110'
-         { 8, 9 },
-          { -7, -8 },  // '111110x'
-          { -9, -10 }, // '111111x'
-};
-
-static const int8_t vp9_mv_fp_tree[3][2] = {
-    { -0, 1 },    // '0'
-     { -1, 2 },   // '10'
-      { -2, -3 }, // '11x'
-};
+#include "vp9dec.h"
+
+extern const uint8_t ff_vp9_bwh_tab[2][N_BS_SIZES][2];
+extern const int8_t ff_vp9_partition_tree[3][2];
+extern const uint8_t ff_vp9_default_kf_partition_probs[4][4][3];
+extern const int8_t ff_vp9_segmentation_tree[7][2];
+extern const int8_t ff_vp9_intramode_tree[9][2];
+extern const uint8_t ff_vp9_default_kf_ymode_probs[10][10][9];
+extern const uint8_t ff_vp9_default_kf_uvmode_probs[10][9];
+extern const int8_t ff_vp9_inter_mode_tree[3][2];
+extern const int8_t ff_vp9_filter_tree[2][2];
+extern const enum FilterMode ff_vp9_filter_lut[3];
+extern const int16_t ff_vp9_dc_qlookup[3][256];
+extern const int16_t ff_vp9_ac_qlookup[3][256];
+extern const enum TxfmType ff_vp9_intra_txfm_type[14];
+extern const int16_t ff_vp9_default_scan_4x4[16];
+extern const int16_t ff_vp9_col_scan_4x4[16];
+extern const int16_t ff_vp9_row_scan_4x4[16];
+extern const int16_t ff_vp9_default_scan_8x8[64];
+extern const int16_t ff_vp9_col_scan_8x8[64];
+extern const int16_t ff_vp9_row_scan_8x8[64];
+extern const int16_t ff_vp9_default_scan_16x16[256];
+extern const int16_t ff_vp9_col_scan_16x16[256];
+extern const int16_t ff_vp9_row_scan_16x16[256];
+extern const int16_t ff_vp9_default_scan_32x32[1024];
+extern const int16_t * const ff_vp9_scans[5][4];
+extern const int16_t ff_vp9_default_scan_4x4_nb[16][2];
+extern const int16_t ff_vp9_col_scan_4x4_nb[16][2];
+extern const int16_t ff_vp9_row_scan_4x4_nb[16][2];
+extern const int16_t ff_vp9_default_scan_8x8_nb[64][2];
+extern const int16_t ff_vp9_col_scan_8x8_nb[64][2];
+extern const int16_t ff_vp9_row_scan_8x8_nb[64][2];
+extern const int16_t ff_vp9_default_scan_16x16_nb[256][2];
+extern const int16_t ff_vp9_col_scan_16x16_nb[256][2];
+extern const int16_t ff_vp9_row_scan_16x16_nb[256][2];
+extern const int16_t ff_vp9_default_scan_32x32_nb[1024][2];
+extern const int16_t (* const ff_vp9_scans_nb[5][4])[2];
+extern const uint8_t ff_vp9_model_pareto8[256][8];
+extern const ProbContext ff_vp9_default_probs;
+extern const uint8_t ff_vp9_default_coef_probs[4][2][2][6][6][3];
+extern const int8_t ff_vp9_mv_joint_tree[3][2];
+extern const int8_t ff_vp9_mv_class_tree[10][2];
+extern const int8_t ff_vp9_mv_fp_tree[3][2];
 
 #endif /* AVCODEC_VP9DATA_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9dec.h b/mythtv/external/FFmpeg/libavcodec/vp9dec.h
new file mode 100644
index 00000000000..66573edc791
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vp9dec.h
@@ -0,0 +1,240 @@
+/*
+ * VP9 compatible video decoder
+ *
+ * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
+ * Copyright (C) 2013 Clément Bœsch <u pkh me>
+ *
+ * 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_VP9DEC_H
+#define AVCODEC_VP9DEC_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdatomic.h>
+
+#include "libavutil/buffer.h"
+#include "libavutil/thread.h"
+#include "libavutil/internal.h"
+
+#include "vp9.h"
+#include "vp9dsp.h"
+#include "vp9shared.h"
+
+enum MVJoint {
+    MV_JOINT_ZERO,
+    MV_JOINT_H,
+    MV_JOINT_V,
+    MV_JOINT_HV,
+};
+
+typedef struct ProbContext {
+    uint8_t y_mode[4][9];
+    uint8_t uv_mode[10][9];
+    uint8_t filter[4][2];
+    uint8_t mv_mode[7][3];
+    uint8_t intra[4];
+    uint8_t comp[5];
+    uint8_t single_ref[5][2];
+    uint8_t comp_ref[5];
+    uint8_t tx32p[2][3];
+    uint8_t tx16p[2][2];
+    uint8_t tx8p[2];
+    uint8_t skip[3];
+    uint8_t mv_joint[3];
+    struct {
+        uint8_t sign;
+        uint8_t classes[10];
+        uint8_t class0;
+        uint8_t bits[10];
+        uint8_t class0_fp[2][3];
+        uint8_t fp[3];
+        uint8_t class0_hp;
+        uint8_t hp;
+    } mv_comp[2];
+    uint8_t partition[4][4][3];
+} ProbContext;
+
+typedef struct VP9Filter {
+    uint8_t level[8 * 8];
+    uint8_t /* bit=col */ mask[2 /* 0=y, 1=uv */][2 /* 0=col, 1=row */]
+                              [8 /* rows */][4 /* 0=16, 1=8, 2=4, 3=inner4 */];
+} VP9Filter;
+
+typedef struct VP9Block {
+    uint8_t seg_id, intra, comp, ref[2], mode[4], uvmode, skip;
+    enum FilterMode filter;
+    VP56mv mv[4 /* b_idx */][2 /* ref */];
+    enum BlockSize bs;
+    enum TxfmMode tx, uvtx;
+    enum BlockLevel bl;
+    enum BlockPartition bp;
+} VP9Block;
+
+typedef struct VP9TileData VP9TileData;
+
+typedef struct VP9Context {
+    VP9SharedContext s;
+    VP9TileData *td;
+
+    VP9DSPContext dsp;
+    VideoDSPContext vdsp;
+    GetBitContext gb;
+    VP56RangeCoder c;
+    int pass, active_tile_cols;
+
+#if HAVE_THREADS
+    pthread_mutex_t progress_mutex;
+    pthread_cond_t progress_cond;
+    atomic_int *entries;
+#endif
+
+    uint8_t ss_h, ss_v;
+    uint8_t last_bpp, bpp_index, bytesperpixel;
+    uint8_t last_keyframe;
+    // sb_cols/rows, rows/cols and last_fmt are used for allocating all internal
+    // arrays, and are thus per-thread. w/h and gf_fmt are synced between threads
+    // and are therefore per-stream. pix_fmt represents the value in the header
+    // of the currently processed frame.
+    int w, h;
+    enum AVPixelFormat pix_fmt, last_fmt, gf_fmt;
+    unsigned sb_cols, sb_rows, rows, cols;
+    ThreadFrame next_refs[8];
+
+    struct {
+        uint8_t lim_lut[64];
+        uint8_t mblim_lut[64];
+    } filter_lut;
+    struct {
+        ProbContext p;
+        uint8_t coef[4][2][2][6][6][3];
+    } prob_ctx[4];
+    struct {
+        ProbContext p;
+        uint8_t coef[4][2][2][6][6][11];
+    } prob;
+
+    // contextual (above) cache
+    uint8_t *above_partition_ctx;
+    uint8_t *above_mode_ctx;
+    // FIXME maybe merge some of the below in a flags field?
+    uint8_t *above_y_nnz_ctx;
+    uint8_t *above_uv_nnz_ctx[2];
+    uint8_t *above_skip_ctx; // 1bit
+    uint8_t *above_txfm_ctx; // 2bit
+    uint8_t *above_segpred_ctx; // 1bit
+    uint8_t *above_intra_ctx; // 1bit
+    uint8_t *above_comp_ctx; // 1bit
+    uint8_t *above_ref_ctx; // 2bit
+    uint8_t *above_filter_ctx;
+    VP56mv (*above_mv_ctx)[2];
+
+    // whole-frame cache
+    uint8_t *intra_pred_data[3];
+    VP9Filter *lflvl;
+
+    // block reconstruction intermediates
+    int block_alloc_using_2pass;
+    uint16_t mvscale[3][2];
+    uint8_t mvstep[3][2];
+} VP9Context;
+
+struct VP9TileData {
+    //VP9Context should be const, but because of the threading API(generates
+    //a lot of warnings) it's not.
+    VP9Context *s;
+    VP56RangeCoder *c_b;
+    VP56RangeCoder *c;
+    int row, row7, col, col7;
+    uint8_t *dst[3];
+    ptrdiff_t y_stride, uv_stride;
+    VP9Block *b_base, *b;
+    unsigned tile_col_start;
+
+    struct {
+        unsigned y_mode[4][10];
+        unsigned uv_mode[10][10];
+        unsigned filter[4][3];
+        unsigned mv_mode[7][4];
+        unsigned intra[4][2];
+        unsigned comp[5][2];
+        unsigned single_ref[5][2][2];
+        unsigned comp_ref[5][2];
+        unsigned tx32p[2][4];
+        unsigned tx16p[2][3];
+        unsigned tx8p[2][2];
+        unsigned skip[3][2];
+        unsigned mv_joint[4];
+        struct {
+            unsigned sign[2];
+            unsigned classes[11];
+            unsigned class0[2];
+            unsigned bits[10][2];
+            unsigned class0_fp[2][4];
+            unsigned fp[4];
+            unsigned class0_hp[2];
+            unsigned hp[2];
+        } mv_comp[2];
+        unsigned partition[4][4][4];
+        unsigned coef[4][2][2][6][6][3];
+        unsigned eob[4][2][2][6][6][2];
+    } counts;
+
+    // whole-frame cache
+    DECLARE_ALIGNED(32, uint8_t, edge_emu_buffer)[135 * 144 * 2];
+
+    // contextual (left) cache
+    DECLARE_ALIGNED(16, uint8_t, left_y_nnz_ctx)[16];
+    DECLARE_ALIGNED(16, uint8_t, left_mode_ctx)[16];
+    DECLARE_ALIGNED(16, VP56mv, left_mv_ctx)[16][2];
+    DECLARE_ALIGNED(16, uint8_t, left_uv_nnz_ctx)[2][16];
+    DECLARE_ALIGNED(8, uint8_t, left_partition_ctx)[8];
+    DECLARE_ALIGNED(8, uint8_t, left_skip_ctx)[8];
+    DECLARE_ALIGNED(8, uint8_t, left_txfm_ctx)[8];
+    DECLARE_ALIGNED(8, uint8_t, left_segpred_ctx)[8];
+    DECLARE_ALIGNED(8, uint8_t, left_intra_ctx)[8];
+    DECLARE_ALIGNED(8, uint8_t, left_comp_ctx)[8];
+    DECLARE_ALIGNED(8, uint8_t, left_ref_ctx)[8];
+    DECLARE_ALIGNED(8, uint8_t, left_filter_ctx)[8];
+    // block reconstruction intermediates
+    DECLARE_ALIGNED(32, uint8_t, tmp_y)[64 * 64 * 2];
+    DECLARE_ALIGNED(32, uint8_t, tmp_uv)[2][64 * 64 * 2];
+    struct { int x, y; } min_mv, max_mv;
+    int16_t *block_base, *block, *uvblock_base[2], *uvblock[2];
+    uint8_t *eob_base, *uveob_base[2], *eob, *uveob[2];
+};
+
+void ff_vp9_fill_mv(VP9TileData *td, VP56mv *mv, int mode, int sb);
+
+void ff_vp9_adapt_probs(VP9Context *s);
+
+void ff_vp9_decode_block(VP9TileData *td, int row, int col,
+                         VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff,
+                         enum BlockLevel bl, enum BlockPartition bp);
+
+void ff_vp9_loopfilter_sb(AVCodecContext *avctx, VP9Filter *lflvl,
+                          int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff);
+
+void ff_vp9_intra_recon_8bpp(VP9TileData *td,
+                             ptrdiff_t y_off, ptrdiff_t uv_off);
+void ff_vp9_intra_recon_16bpp(VP9TileData *td,
+                              ptrdiff_t y_off, ptrdiff_t uv_off);
+void ff_vp9_inter_recon_8bpp(VP9TileData *td);
+void ff_vp9_inter_recon_16bpp(VP9TileData *td);
+
+#endif /* AVCODEC_VP9DEC_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9dsp.c b/mythtv/external/FFmpeg/libavcodec/vp9dsp.c
index 54e77e267b4..f6d73f73cd4 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp9dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp9dsp.c
@@ -25,6 +25,62 @@
 #include "libavutil/common.h"
 #include "vp9dsp.h"
 
+const DECLARE_ALIGNED(16, int16_t, ff_vp9_subpel_filters)[3][16][8] = {
+    [FILTER_8TAP_REGULAR] = {
+        {  0,  0,   0, 128,   0,   0,  0,  0 },
+        {  0,  1,  -5, 126,   8,  -3,  1,  0 },
+        { -1,  3, -10, 122,  18,  -6,  2,  0 },
+        { -1,  4, -13, 118,  27,  -9,  3, -1 },
+        { -1,  4, -16, 112,  37, -11,  4, -1 },
+        { -1,  5, -18, 105,  48, -14,  4, -1 },
+        { -1,  5, -19,  97,  58, -16,  5, -1 },
+        { -1,  6, -19,  88,  68, -18,  5, -1 },
+        { -1,  6, -19,  78,  78, -19,  6, -1 },
+        { -1,  5, -18,  68,  88, -19,  6, -1 },
+        { -1,  5, -16,  58,  97, -19,  5, -1 },
+        { -1,  4, -14,  48, 105, -18,  5, -1 },
+        { -1,  4, -11,  37, 112, -16,  4, -1 },
+        { -1,  3,  -9,  27, 118, -13,  4, -1 },
+        {  0,  2,  -6,  18, 122, -10,  3, -1 },
+        {  0,  1,  -3,   8, 126,  -5,  1,  0 },
+    }, [FILTER_8TAP_SHARP] = {
+        {  0,  0,   0, 128,   0,   0,  0,  0 },
+        { -1,  3,  -7, 127,   8,  -3,  1,  0 },
+        { -2,  5, -13, 125,  17,  -6,  3, -1 },
+        { -3,  7, -17, 121,  27, -10,  5, -2 },
+        { -4,  9, -20, 115,  37, -13,  6, -2 },
+        { -4, 10, -23, 108,  48, -16,  8, -3 },
+        { -4, 10, -24, 100,  59, -19,  9, -3 },
+        { -4, 11, -24,  90,  70, -21, 10, -4 },
+        { -4, 11, -23,  80,  80, -23, 11, -4 },
+        { -4, 10, -21,  70,  90, -24, 11, -4 },
+        { -3,  9, -19,  59, 100, -24, 10, -4 },
+        { -3,  8, -16,  48, 108, -23, 10, -4 },
+        { -2,  6, -13,  37, 115, -20,  9, -4 },
+        { -2,  5, -10,  27, 121, -17,  7, -3 },
+        { -1,  3,  -6,  17, 125, -13,  5, -2 },
+        {  0,  1,  -3,   8, 127,  -7,  3, -1 },
+    }, [FILTER_8TAP_SMOOTH] = {
+        {  0,  0,   0, 128,   0,   0,  0,  0 },
+        { -3, -1,  32,  64,  38,   1, -3,  0 },
+        { -2, -2,  29,  63,  41,   2, -3,  0 },
+        { -2, -2,  26,  63,  43,   4, -4,  0 },
+        { -2, -3,  24,  62,  46,   5, -4,  0 },
+        { -2, -3,  21,  60,  49,   7, -4,  0 },
+        { -1, -4,  18,  59,  51,   9, -4,  0 },
+        { -1, -4,  16,  57,  53,  12, -4, -1 },
+        { -1, -4,  14,  55,  55,  14, -4, -1 },
+        { -1, -4,  12,  53,  57,  16, -4, -1 },
+        {  0, -4,   9,  51,  59,  18, -4, -1 },
+        {  0, -4,   7,  49,  60,  21, -3, -2 },
+        {  0, -4,   5,  46,  62,  24, -3, -2 },
+        {  0, -4,   4,  43,  63,  26, -2, -2 },
+        {  0, -3,   2,  41,  63,  29, -2, -2 },
+        {  0, -3,   1,  38,  64,  32, -1, -3 },
+    }
+};
+
+
 av_cold void ff_vp9dsp_init(VP9DSPContext *dsp, int bpp, int bitexact)
 {
     if (bpp == 8) {
@@ -36,6 +92,8 @@ av_cold void ff_vp9dsp_init(VP9DSPContext *dsp, int bpp, int bitexact)
         ff_vp9dsp_init_12(dsp);
     }
 
+    if (ARCH_AARCH64) ff_vp9dsp_init_aarch64(dsp, bpp);
+    if (ARCH_ARM) ff_vp9dsp_init_arm(dsp, bpp);
     if (ARCH_X86) ff_vp9dsp_init_x86(dsp, bpp, bitexact);
     if (ARCH_MIPS) ff_vp9dsp_init_mips(dsp, bpp);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9dsp.h b/mythtv/external/FFmpeg/libavcodec/vp9dsp.h
index 733f5bfc4da..e2256316a8f 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp9dsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/vp9dsp.h
@@ -27,7 +27,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include "vp9.h"
+#include "libavcodec/vp9.h"
 
 typedef void (*vp9_mc_func)(uint8_t *dst, ptrdiff_t dst_stride,
                             const uint8_t *ref, ptrdiff_t ref_stride,
@@ -111,21 +111,25 @@ typedef struct VP9DSPContext {
      *
      * dst/stride are aligned by hsize
      */
-    vp9_mc_func mc[5][4][2][2][2];
+    vp9_mc_func mc[5][N_FILTERS][2][2][2];
 
     /*
      * for scalable MC, first 3 dimensions identical to above, the other two
      * don't exist since it changes per stepsize.
      */
-    vp9_scaled_mc_func smc[5][4][2];
+    vp9_scaled_mc_func smc[5][N_FILTERS][2];
 } VP9DSPContext;
 
+extern const int16_t ff_vp9_subpel_filters[3][16][8];
+
 void ff_vp9dsp_init(VP9DSPContext *dsp, int bpp, int bitexact);
 
 void ff_vp9dsp_init_8(VP9DSPContext *dsp);
 void ff_vp9dsp_init_10(VP9DSPContext *dsp);
 void ff_vp9dsp_init_12(VP9DSPContext *dsp);
 
+void ff_vp9dsp_init_aarch64(VP9DSPContext *dsp, int bpp);
+void ff_vp9dsp_init_arm(VP9DSPContext *dsp, int bpp);
 void ff_vp9dsp_init_x86(VP9DSPContext *dsp, int bpp, int bitexact);
 void ff_vp9dsp_init_mips(VP9DSPContext *dsp, int bpp);
 
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9dsp_template.c b/mythtv/external/FFmpeg/libavcodec/vp9dsp_template.c
index 4d810fec3a9..bb54561a60b 100644
--- a/mythtv/external/FFmpeg/libavcodec/vp9dsp_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/vp9dsp_template.c
@@ -1991,61 +1991,6 @@ copy_avg_fn(4)
 
 #endif /* BIT_DEPTH != 12 */
 
-static const int16_t vp9_subpel_filters[3][16][8] = {
-    [FILTER_8TAP_REGULAR] = {
-        {  0,  0,   0, 128,   0,   0,  0,  0 },
-        {  0,  1,  -5, 126,   8,  -3,  1,  0 },
-        { -1,  3, -10, 122,  18,  -6,  2,  0 },
-        { -1,  4, -13, 118,  27,  -9,  3, -1 },
-        { -1,  4, -16, 112,  37, -11,  4, -1 },
-        { -1,  5, -18, 105,  48, -14,  4, -1 },
-        { -1,  5, -19,  97,  58, -16,  5, -1 },
-        { -1,  6, -19,  88,  68, -18,  5, -1 },
-        { -1,  6, -19,  78,  78, -19,  6, -1 },
-        { -1,  5, -18,  68,  88, -19,  6, -1 },
-        { -1,  5, -16,  58,  97, -19,  5, -1 },
-        { -1,  4, -14,  48, 105, -18,  5, -1 },
-        { -1,  4, -11,  37, 112, -16,  4, -1 },
-        { -1,  3,  -9,  27, 118, -13,  4, -1 },
-        {  0,  2,  -6,  18, 122, -10,  3, -1 },
-        {  0,  1,  -3,   8, 126,  -5,  1,  0 },
-    }, [FILTER_8TAP_SHARP] = {
-        {  0,  0,   0, 128,   0,   0,  0,  0 },
-        { -1,  3,  -7, 127,   8,  -3,  1,  0 },
-        { -2,  5, -13, 125,  17,  -6,  3, -1 },
-        { -3,  7, -17, 121,  27, -10,  5, -2 },
-        { -4,  9, -20, 115,  37, -13,  6, -2 },
-        { -4, 10, -23, 108,  48, -16,  8, -3 },
-        { -4, 10, -24, 100,  59, -19,  9, -3 },
-        { -4, 11, -24,  90,  70, -21, 10, -4 },
-        { -4, 11, -23,  80,  80, -23, 11, -4 },
-        { -4, 10, -21,  70,  90, -24, 11, -4 },
-        { -3,  9, -19,  59, 100, -24, 10, -4 },
-        { -3,  8, -16,  48, 108, -23, 10, -4 },
-        { -2,  6, -13,  37, 115, -20,  9, -4 },
-        { -2,  5, -10,  27, 121, -17,  7, -3 },
-        { -1,  3,  -6,  17, 125, -13,  5, -2 },
-        {  0,  1,  -3,   8, 127,  -7,  3, -1 },
-    }, [FILTER_8TAP_SMOOTH] = {
-        {  0,  0,   0, 128,   0,   0,  0,  0 },
-        { -3, -1,  32,  64,  38,   1, -3,  0 },
-        { -2, -2,  29,  63,  41,   2, -3,  0 },
-        { -2, -2,  26,  63,  43,   4, -4,  0 },
-        { -2, -3,  24,  62,  46,   5, -4,  0 },
-        { -2, -3,  21,  60,  49,   7, -4,  0 },
-        { -1, -4,  18,  59,  51,   9, -4,  0 },
-        { -1, -4,  16,  57,  53,  12, -4, -1 },
-        { -1, -4,  14,  55,  55,  14, -4, -1 },
-        { -1, -4,  12,  53,  57,  16, -4, -1 },
-        {  0, -4,   9,  51,  59,  18, -4, -1 },
-        {  0, -4,   7,  49,  60,  21, -3, -2 },
-        {  0, -4,   5,  46,  62,  24, -3, -2 },
-        {  0, -4,   4,  43,  63,  26, -2, -2 },
-        {  0, -3,   2,  41,  63,  29, -2, -2 },
-        {  0, -3,   1,  38,  64,  32, -1, -3 },
-    }
-};
-
 #define FILTER_8TAP(src, x, F, stride) \
     av_clip_pixel((F[0] * src[x + -3 * stride] + \
                    F[1] * src[x + -2 * stride] + \
@@ -2155,7 +2100,7 @@ static void avg##_8tap_##type##_##sz##dir##_c(uint8_t *dst, ptrdiff_t dst_stride
                                               int h, int mx, int my) \
 { \
     avg##_8tap_1d_##dir##_c(dst, dst_stride, src, src_stride, sz, h, \
-                            vp9_subpel_filters[type_idx][dir_m]); \
+                            ff_vp9_subpel_filters[type_idx][dir_m]); \
 }
 
 #define filter_fn_2d(sz, type, type_idx, avg) \
@@ -2164,8 +2109,8 @@ static void avg##_8tap_##type##_##sz##hv_c(uint8_t *dst, ptrdiff_t dst_stride, \
                                            int h, int mx, int my) \
 { \
     avg##_8tap_2d_hv_c(dst, dst_stride, src, src_stride, sz, h, \
-                       vp9_subpel_filters[type_idx][mx], \
-                       vp9_subpel_filters[type_idx][my]); \
+                       ff_vp9_subpel_filters[type_idx][mx], \
+                       ff_vp9_subpel_filters[type_idx][my]); \
 }
 
 #if BIT_DEPTH != 12
@@ -2454,7 +2399,7 @@ static void avg##_scaled_##type##_##sz##_c(uint8_t *dst, ptrdiff_t dst_stride, \
                                            int h, int mx, int my, int dx, int dy) \
 { \
     avg##_scaled_8tap_c(dst, dst_stride, src, src_stride, sz, h, mx, my, dx, dy, \
-                        vp9_subpel_filters[type_idx]); \
+                        ff_vp9_subpel_filters[type_idx]); \
 }
 
 #if BIT_DEPTH != 12
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9lpf.c b/mythtv/external/FFmpeg/libavcodec/vp9lpf.c
new file mode 100644
index 00000000000..414cede8520
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vp9lpf.c
@@ -0,0 +1,202 @@
+/*
+ * VP9 compatible video decoder
+ *
+ * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
+ * Copyright (C) 2013 Clément Bœsch <u pkh me>
+ *
+ * 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 "vp9dec.h"
+
+static av_always_inline void filter_plane_cols(VP9Context *s, int col, int ss_h, int ss_v,
+                                               uint8_t *lvl, uint8_t (*mask)[4],
+                                               uint8_t *dst, ptrdiff_t ls)
+{
+    int y, x, bytesperpixel = s->bytesperpixel;
+
+    // filter edges between columns (e.g. block1 | block2)
+    for (y = 0; y < 8; y += 2 << ss_v, dst += 16 * ls, lvl += 16 << ss_v) {
+        uint8_t *ptr = dst, *l = lvl, *hmask1 = mask[y], *hmask2 = mask[y + 1 + ss_v];
+        unsigned hm1 = hmask1[0] | hmask1[1] | hmask1[2], hm13 = hmask1[3];
+        unsigned hm2 = hmask2[1] | hmask2[2], hm23 = hmask2[3];
+        unsigned hm = hm1 | hm2 | hm13 | hm23;
+
+        for (x = 1; hm & ~(x - 1); x <<= 1, ptr += 8 * bytesperpixel >> ss_h) {
+            if (col || x > 1) {
+                if (hm1 & x) {
+                    int L = *l, H = L >> 4;
+                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
+
+                    if (hmask1[0] & x) {
+                        if (hmask2[0] & x) {
+                            av_assert2(l[8 << ss_v] == L);
+                            s->dsp.loop_filter_16[0](ptr, ls, E, I, H);
+                        } else {
+                            s->dsp.loop_filter_8[2][0](ptr, ls, E, I, H);
+                        }
+                    } else if (hm2 & x) {
+                        L = l[8 << ss_v];
+                        H |= (L >> 4) << 8;
+                        E |= s->filter_lut.mblim_lut[L] << 8;
+                        I |= s->filter_lut.lim_lut[L] << 8;
+                        s->dsp.loop_filter_mix2[!!(hmask1[1] & x)]
+                                               [!!(hmask2[1] & x)]
+                                               [0](ptr, ls, E, I, H);
+                    } else {
+                        s->dsp.loop_filter_8[!!(hmask1[1] & x)]
+                                            [0](ptr, ls, E, I, H);
+                    }
+                } else if (hm2 & x) {
+                    int L = l[8 << ss_v], H = L >> 4;
+                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
+
+                    s->dsp.loop_filter_8[!!(hmask2[1] & x)]
+                                        [0](ptr + 8 * ls, ls, E, I, H);
+                }
+            }
+            if (ss_h) {
+                if (x & 0xAA)
+                    l += 2;
+            } else {
+                if (hm13 & x) {
+                    int L = *l, H = L >> 4;
+                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
+
+                    if (hm23 & x) {
+                        L = l[8 << ss_v];
+                        H |= (L >> 4) << 8;
+                        E |= s->filter_lut.mblim_lut[L] << 8;
+                        I |= s->filter_lut.lim_lut[L] << 8;
+                        s->dsp.loop_filter_mix2[0][0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
+                    } else {
+                        s->dsp.loop_filter_8[0][0](ptr + 4 * bytesperpixel, ls, E, I, H);
+                    }
+                } else if (hm23 & x) {
+                    int L = l[8 << ss_v], H = L >> 4;
+                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
+
+                    s->dsp.loop_filter_8[0][0](ptr + 8 * ls + 4 * bytesperpixel, ls, E, I, H);
+                }
+                l++;
+            }
+        }
+    }
+}
+
+static av_always_inline void filter_plane_rows(VP9Context *s, int row, int ss_h, int ss_v,
+                                               uint8_t *lvl, uint8_t (*mask)[4],
+                                               uint8_t *dst, ptrdiff_t ls)
+{
+    int y, x, bytesperpixel = s->bytesperpixel;
+
+    //                                 block1
+    // filter edges between rows (e.g. ------)
+    //                                 block2
+    for (y = 0; y < 8; y++, dst += 8 * ls >> ss_v) {
+        uint8_t *ptr = dst, *l = lvl, *vmask = mask[y];
+        unsigned vm = vmask[0] | vmask[1] | vmask[2], vm3 = vmask[3];
+
+        for (x = 1; vm & ~(x - 1); x <<= (2 << ss_h), ptr += 16 * bytesperpixel, l += 2 << ss_h) {
+            if (row || y) {
+                if (vm & x) {
+                    int L = *l, H = L >> 4;
+                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
+
+                    if (vmask[0] & x) {
+                        if (vmask[0] & (x << (1 + ss_h))) {
+                            av_assert2(l[1 + ss_h] == L);
+                            s->dsp.loop_filter_16[1](ptr, ls, E, I, H);
+                        } else {
+                            s->dsp.loop_filter_8[2][1](ptr, ls, E, I, H);
+                        }
+                    } else if (vm & (x << (1 + ss_h))) {
+                        L = l[1 + ss_h];
+                        H |= (L >> 4) << 8;
+                        E |= s->filter_lut.mblim_lut[L] << 8;
+                        I |= s->filter_lut.lim_lut[L] << 8;
+                        s->dsp.loop_filter_mix2[!!(vmask[1] &  x)]
+                                               [!!(vmask[1] & (x << (1 + ss_h)))]
+                                               [1](ptr, ls, E, I, H);
+                    } else {
+                        s->dsp.loop_filter_8[!!(vmask[1] & x)]
+                                            [1](ptr, ls, E, I, H);
+                    }
+                } else if (vm & (x << (1 + ss_h))) {
+                    int L = l[1 + ss_h], H = L >> 4;
+                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
+
+                    s->dsp.loop_filter_8[!!(vmask[1] & (x << (1 + ss_h)))]
+                                        [1](ptr + 8 * bytesperpixel, ls, E, I, H);
+                }
+            }
+            if (!ss_v) {
+                if (vm3 & x) {
+                    int L = *l, H = L >> 4;
+                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
+
+                    if (vm3 & (x << (1 + ss_h))) {
+                        L = l[1 + ss_h];
+                        H |= (L >> 4) << 8;
+                        E |= s->filter_lut.mblim_lut[L] << 8;
+                        I |= s->filter_lut.lim_lut[L] << 8;
+                        s->dsp.loop_filter_mix2[0][0][1](ptr + ls * 4, ls, E, I, H);
+                    } else {
+                        s->dsp.loop_filter_8[0][1](ptr + ls * 4, ls, E, I, H);
+                    }
+                } else if (vm3 & (x << (1 + ss_h))) {
+                    int L = l[1 + ss_h], H = L >> 4;
+                    int E = s->filter_lut.mblim_lut[L], I = s->filter_lut.lim_lut[L];
+
+                    s->dsp.loop_filter_8[0][1](ptr + ls * 4 + 8 * bytesperpixel, ls, E, I, H);
+                }
+            }
+        }
+        if (ss_v) {
+            if (y & 1)
+                lvl += 16;
+        } else {
+            lvl += 8;
+        }
+    }
+}
+
+void ff_vp9_loopfilter_sb(AVCodecContext *avctx, VP9Filter *lflvl,
+                          int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
+{
+    VP9Context *s = avctx->priv_data;
+    AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
+    uint8_t *dst = f->data[0] + yoff;
+    ptrdiff_t ls_y = f->linesize[0], ls_uv = f->linesize[1];
+    uint8_t (*uv_masks)[8][4] = lflvl->mask[s->ss_h | s->ss_v];
+    int p;
+
+    /* FIXME: In how far can we interleave the v/h loopfilter calls? E.g.
+     * if you think of them as acting on a 8x8 block max, we can interleave
+     * each v/h within the single x loop, but that only works if we work on
+     * 8 pixel blocks, and we won't always do that (we want at least 16px
+     * to use SSE2 optimizations, perhaps 32 for AVX2) */
+
+    filter_plane_cols(s, col, 0, 0, lflvl->level, lflvl->mask[0][0], dst, ls_y);
+    filter_plane_rows(s, row, 0, 0, lflvl->level, lflvl->mask[0][1], dst, ls_y);
+
+    for (p = 0; p < 2; p++) {
+        dst = f->data[1 + p] + uvoff;
+        filter_plane_cols(s, col, s->ss_h, s->ss_v, lflvl->level, uv_masks[0], dst, ls_uv);
+        filter_plane_rows(s, row, s->ss_h, s->ss_v, lflvl->level, uv_masks[1], dst, ls_uv);
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9mvs.c b/mythtv/external/FFmpeg/libavcodec/vp9mvs.c
new file mode 100644
index 00000000000..88db1c341c1
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vp9mvs.c
@@ -0,0 +1,364 @@
+/*
+ * VP9 compatible video decoder
+ *
+ * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
+ * Copyright (C) 2013 Clément Bœsch <u pkh me>
+ *
+ * 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 "internal.h"
+#include "vp56.h"
+#include "vp9.h"
+#include "vp9data.h"
+#include "vp9dec.h"
+
+static av_always_inline void clamp_mv(VP56mv *dst, const VP56mv *src,
+                                      VP9TileData *td)
+{
+    dst->x = av_clip(src->x, td->min_mv.x, td->max_mv.x);
+    dst->y = av_clip(src->y, td->min_mv.y, td->max_mv.y);
+}
+
+static void find_ref_mvs(VP9TileData *td,
+                         VP56mv *pmv, int ref, int z, int idx, int sb)
+{
+    static const int8_t mv_ref_blk_off[N_BS_SIZES][8][2] = {
+        [BS_64x64] = { {  3, -1 }, { -1,  3 }, {  4, -1 }, { -1,  4 },
+                       { -1, -1 }, {  0, -1 }, { -1,  0 }, {  6, -1 } },
+        [BS_64x32] = { {  0, -1 }, { -1,  0 }, {  4, -1 }, { -1,  2 },
+                       { -1, -1 }, {  0, -3 }, { -3,  0 }, {  2, -1 } },
+        [BS_32x64] = { { -1,  0 }, {  0, -1 }, { -1,  4 }, {  2, -1 },
+                       { -1, -1 }, { -3,  0 }, {  0, -3 }, { -1,  2 } },
+        [BS_32x32] = { {  1, -1 }, { -1,  1 }, {  2, -1 }, { -1,  2 },
+                       { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 } },
+        [BS_32x16] = { {  0, -1 }, { -1,  0 }, {  2, -1 }, { -1, -1 },
+                       { -1,  1 }, {  0, -3 }, { -3,  0 }, { -3, -3 } },
+        [BS_16x32] = { { -1,  0 }, {  0, -1 }, { -1,  2 }, { -1, -1 },
+                       {  1, -1 }, { -3,  0 }, {  0, -3 }, { -3, -3 } },
+        [BS_16x16] = { {  0, -1 }, { -1,  0 }, {  1, -1 }, { -1,  1 },
+                       { -1, -1 }, {  0, -3 }, { -3,  0 }, { -3, -3 } },
+        [BS_16x8]  = { {  0, -1 }, { -1,  0 }, {  1, -1 }, { -1, -1 },
+                       {  0, -2 }, { -2,  0 }, { -2, -1 }, { -1, -2 } },
+        [BS_8x16]  = { { -1,  0 }, {  0, -1 }, { -1,  1 }, { -1, -1 },
+                       { -2,  0 }, {  0, -2 }, { -1, -2 }, { -2, -1 } },
+        [BS_8x8]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
+                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
+        [BS_8x4]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
+                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
+        [BS_4x8]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
+                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
+        [BS_4x4]   = { {  0, -1 }, { -1,  0 }, { -1, -1 }, {  0, -2 },
+                       { -2,  0 }, { -1, -2 }, { -2, -1 }, { -2, -2 } },
+    };
+    VP9Context *s = td->s;
+    VP9Block *b = td->b;
+    int row = td->row, col = td->col, row7 = td->row7;
+    const int8_t (*p)[2] = mv_ref_blk_off[b->bs];
+#define INVALID_MV 0x80008000U
+    uint32_t mem = INVALID_MV, mem_sub8x8 = INVALID_MV;
+    int i;
+
+#define RETURN_DIRECT_MV(mv)                    \
+    do {                                        \
+        uint32_t m = AV_RN32A(&mv);             \
+        if (!idx) {                             \
+            AV_WN32A(pmv, m);                   \
+            return;                             \
+        } else if (mem == INVALID_MV) {         \
+            mem = m;                            \
+        } else if (m != mem) {                  \
+            AV_WN32A(pmv, m);                   \
+            return;                             \
+        }                                       \
+    } while (0)
+
+    if (sb >= 0) {
+        if (sb == 2 || sb == 1) {
+            RETURN_DIRECT_MV(b->mv[0][z]);
+        } else if (sb == 3) {
+            RETURN_DIRECT_MV(b->mv[2][z]);
+            RETURN_DIRECT_MV(b->mv[1][z]);
+            RETURN_DIRECT_MV(b->mv[0][z]);
+        }
+
+#define RETURN_MV(mv)                                                  \
+    do {                                                               \
+        if (sb > 0) {                                                  \
+            VP56mv tmp;                                                \
+            uint32_t m;                                                \
+            av_assert2(idx == 1);                                      \
+            av_assert2(mem != INVALID_MV);                             \
+            if (mem_sub8x8 == INVALID_MV) {                            \
+                clamp_mv(&tmp, &mv, td);                               \
+                m = AV_RN32A(&tmp);                                    \
+                if (m != mem) {                                        \
+                    AV_WN32A(pmv, m);                                  \
+                    return;                                            \
+                }                                                      \
+                mem_sub8x8 = AV_RN32A(&mv);                            \
+            } else if (mem_sub8x8 != AV_RN32A(&mv)) {                  \
+                clamp_mv(&tmp, &mv, td);                               \
+                m = AV_RN32A(&tmp);                                    \
+                if (m != mem) {                                        \
+                    AV_WN32A(pmv, m);                                  \
+                } else {                                               \
+                    /* BUG I'm pretty sure this isn't the intention */ \
+                    AV_WN32A(pmv, 0);                                  \
+                }                                                      \
+                return;                                                \
+            }                                                          \
+        } else {                                                       \
+            uint32_t m = AV_RN32A(&mv);                                \
+            if (!idx) {                                                \
+                clamp_mv(pmv, &mv, td);                                \
+                return;                                                \
+            } else if (mem == INVALID_MV) {                            \
+                mem = m;                                               \
+            } else if (m != mem) {                                     \
+                clamp_mv(pmv, &mv, td);                                \
+                return;                                                \
+            }                                                          \
+        }                                                              \
+    } while (0)
+
+        if (row > 0) {
+            VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[(row - 1) * s->sb_cols * 8 + col];
+            if (mv->ref[0] == ref)
+                RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][0]);
+            else if (mv->ref[1] == ref)
+                RETURN_MV(s->above_mv_ctx[2 * col + (sb & 1)][1]);
+        }
+        if (col > td->tile_col_start) {
+            VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[row * s->sb_cols * 8 + col - 1];
+            if (mv->ref[0] == ref)
+                RETURN_MV(td->left_mv_ctx[2 * row7 + (sb >> 1)][0]);
+            else if (mv->ref[1] == ref)
+                RETURN_MV(td->left_mv_ctx[2 * row7 + (sb >> 1)][1]);
+        }
+        i = 2;
+    } else {
+        i = 0;
+    }
+
+    // previously coded MVs in this neighborhood, using same reference frame
+    for (; i < 8; i++) {
+        int c = p[i][0] + col, r = p[i][1] + row;
+
+        if (c >= td->tile_col_start && c < s->cols &&
+            r >= 0 && r < s->rows) {
+            VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
+
+            if (mv->ref[0] == ref)
+                RETURN_MV(mv->mv[0]);
+            else if (mv->ref[1] == ref)
+                RETURN_MV(mv->mv[1]);
+        }
+    }
+
+    // MV at this position in previous frame, using same reference frame
+    if (s->s.h.use_last_frame_mvs) {
+        VP9mvrefPair *mv = &s->s.frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
+
+        if (!s->s.frames[REF_FRAME_MVPAIR].uses_2pass)
+            ff_thread_await_progress(&s->s.frames[REF_FRAME_MVPAIR].tf, row >> 3, 0);
+        if (mv->ref[0] == ref)
+            RETURN_MV(mv->mv[0]);
+        else if (mv->ref[1] == ref)
+            RETURN_MV(mv->mv[1]);
+    }
+
+#define RETURN_SCALE_MV(mv, scale)              \
+    do {                                        \
+        if (scale) {                            \
+            VP56mv mv_temp = { -mv.x, -mv.y };  \
+            RETURN_MV(mv_temp);                 \
+        } else {                                \
+            RETURN_MV(mv);                      \
+        }                                       \
+    } while (0)
+
+    // previously coded MVs in this neighborhood, using different reference frame
+    for (i = 0; i < 8; i++) {
+        int c = p[i][0] + col, r = p[i][1] + row;
+
+        if (c >= td->tile_col_start && c < s->cols && r >= 0 && r < s->rows) {
+            VP9mvrefPair *mv = &s->s.frames[CUR_FRAME].mv[r * s->sb_cols * 8 + c];
+
+            if (mv->ref[0] != ref && mv->ref[0] >= 0)
+                RETURN_SCALE_MV(mv->mv[0],
+                                s->s.h.signbias[mv->ref[0]] != s->s.h.signbias[ref]);
+            if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
+                // BUG - libvpx has this condition regardless of whether
+                // we used the first ref MV and pre-scaling
+                AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
+                RETURN_SCALE_MV(mv->mv[1], s->s.h.signbias[mv->ref[1]] != s->s.h.signbias[ref]);
+            }
+        }
+    }
+
+    // MV at this position in previous frame, using different reference frame
+    if (s->s.h.use_last_frame_mvs) {
+        VP9mvrefPair *mv = &s->s.frames[REF_FRAME_MVPAIR].mv[row * s->sb_cols * 8 + col];
+
+        // no need to await_progress, because we already did that above
+        if (mv->ref[0] != ref && mv->ref[0] >= 0)
+            RETURN_SCALE_MV(mv->mv[0], s->s.h.signbias[mv->ref[0]] != s->s.h.signbias[ref]);
+        if (mv->ref[1] != ref && mv->ref[1] >= 0 &&
+            // BUG - libvpx has this condition regardless of whether
+            // we used the first ref MV and pre-scaling
+            AV_RN32A(&mv->mv[0]) != AV_RN32A(&mv->mv[1])) {
+            RETURN_SCALE_MV(mv->mv[1], s->s.h.signbias[mv->ref[1]] != s->s.h.signbias[ref]);
+        }
+    }
+
+    AV_ZERO32(pmv);
+    clamp_mv(pmv, pmv, td);
+#undef INVALID_MV
+#undef RETURN_MV
+#undef RETURN_SCALE_MV
+}
+
+static av_always_inline int read_mv_component(VP9TileData *td, int idx, int hp)
+{
+    VP9Context *s = td->s;
+    int bit, sign = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].sign);
+    int n, c = vp8_rac_get_tree(td->c, ff_vp9_mv_class_tree,
+                                s->prob.p.mv_comp[idx].classes);
+
+    td->counts.mv_comp[idx].sign[sign]++;
+    td->counts.mv_comp[idx].classes[c]++;
+    if (c) {
+        int m;
+
+        for (n = 0, m = 0; m < c; m++) {
+            bit = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].bits[m]);
+            n |= bit << m;
+            td->counts.mv_comp[idx].bits[m][bit]++;
+        }
+        n <<= 3;
+        bit = vp8_rac_get_tree(td->c, ff_vp9_mv_fp_tree,
+                               s->prob.p.mv_comp[idx].fp);
+        n  |= bit << 1;
+        td->counts.mv_comp[idx].fp[bit]++;
+        if (hp) {
+            bit = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].hp);
+            td->counts.mv_comp[idx].hp[bit]++;
+            n |= bit;
+        } else {
+            n |= 1;
+            // bug in libvpx - we count for bw entropy purposes even if the
+            // bit wasn't coded
+            td->counts.mv_comp[idx].hp[1]++;
+        }
+        n += 8 << c;
+    } else {
+        n = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].class0);
+        td->counts.mv_comp[idx].class0[n]++;
+        bit = vp8_rac_get_tree(td->c, ff_vp9_mv_fp_tree,
+                               s->prob.p.mv_comp[idx].class0_fp[n]);
+        td->counts.mv_comp[idx].class0_fp[n][bit]++;
+        n = (n << 3) | (bit << 1);
+        if (hp) {
+            bit = vp56_rac_get_prob(td->c, s->prob.p.mv_comp[idx].class0_hp);
+            td->counts.mv_comp[idx].class0_hp[bit]++;
+            n |= bit;
+        } else {
+            n |= 1;
+            // bug in libvpx - we count for bw entropy purposes even if the
+            // bit wasn't coded
+            td->counts.mv_comp[idx].class0_hp[1]++;
+        }
+    }
+
+    return sign ? -(n + 1) : (n + 1);
+}
+
+void ff_vp9_fill_mv(VP9TileData *td, VP56mv *mv, int mode, int sb)
+{
+    VP9Context *s = td->s;
+    VP9Block *b = td->b;
+
+    if (mode == ZEROMV) {
+        AV_ZERO64(mv);
+    } else {
+        int hp;
+
+        // FIXME cache this value and reuse for other subblocks
+        find_ref_mvs(td, &mv[0], b->ref[0], 0, mode == NEARMV,
+                     mode == NEWMV ? -1 : sb);
+        // FIXME maybe move this code into find_ref_mvs()
+        if ((mode == NEWMV || sb == -1) &&
+            !(hp = s->s.h.highprecisionmvs &&
+              abs(mv[0].x) < 64 && abs(mv[0].y) < 64)) {
+            if (mv[0].y & 1) {
+                if (mv[0].y < 0)
+                    mv[0].y++;
+                else
+                    mv[0].y--;
+            }
+            if (mv[0].x & 1) {
+                if (mv[0].x < 0)
+                    mv[0].x++;
+                else
+                    mv[0].x--;
+            }
+        }
+        if (mode == NEWMV) {
+            enum MVJoint j = vp8_rac_get_tree(td->c, ff_vp9_mv_joint_tree,
+                                              s->prob.p.mv_joint);
+
+            td->counts.mv_joint[j]++;
+            if (j >= MV_JOINT_V)
+                mv[0].y += read_mv_component(td, 0, hp);
+            if (j & 1)
+                mv[0].x += read_mv_component(td, 1, hp);
+        }
+
+        if (b->comp) {
+            // FIXME cache this value and reuse for other subblocks
+            find_ref_mvs(td, &mv[1], b->ref[1], 1, mode == NEARMV,
+                         mode == NEWMV ? -1 : sb);
+            if ((mode == NEWMV || sb == -1) &&
+                !(hp = s->s.h.highprecisionmvs &&
+                  abs(mv[1].x) < 64 && abs(mv[1].y) < 64)) {
+                if (mv[1].y & 1) {
+                    if (mv[1].y < 0)
+                        mv[1].y++;
+                    else
+                        mv[1].y--;
+                }
+                if (mv[1].x & 1) {
+                    if (mv[1].x < 0)
+                        mv[1].x++;
+                    else
+                        mv[1].x--;
+                }
+            }
+            if (mode == NEWMV) {
+                enum MVJoint j = vp8_rac_get_tree(td->c, ff_vp9_mv_joint_tree,
+                                                  s->prob.p.mv_joint);
+
+                td->counts.mv_joint[j]++;
+                if (j >= MV_JOINT_V)
+                    mv[1].y += read_mv_component(td, 0, hp);
+                if (j & 1)
+                    mv[1].x += read_mv_component(td, 1, hp);
+            }
+        }
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9prob.c b/mythtv/external/FFmpeg/libavcodec/vp9prob.c
new file mode 100644
index 00000000000..fb295b482d0
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vp9prob.c
@@ -0,0 +1,274 @@
+/*
+ * VP9 compatible video decoder
+ *
+ * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
+ * Copyright (C) 2013 Clément Bœsch <u pkh me>
+ *
+ * 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 "vp56.h"
+#include "vp9.h"
+#include "vp9data.h"
+#include "vp9dec.h"
+
+static av_always_inline void adapt_prob(uint8_t *p, unsigned ct0, unsigned ct1,
+                                        int max_count, int update_factor)
+{
+    unsigned ct = ct0 + ct1, p2, p1;
+
+    if (!ct)
+        return;
+
+    update_factor = FASTDIV(update_factor * FFMIN(ct, max_count), max_count);
+    p1 = *p;
+    p2 = ((((int64_t) ct0) << 8) + (ct >> 1)) / ct;
+    p2 = av_clip(p2, 1, 255);
+
+    // (p1 * (256 - update_factor) + p2 * update_factor + 128) >> 8
+    *p = p1 + (((p2 - p1) * update_factor + 128) >> 8);
+}
+
+void ff_vp9_adapt_probs(VP9Context *s)
+{
+    int i, j, k, l, m;
+    ProbContext *p = &s->prob_ctx[s->s.h.framectxid].p;
+    int uf = (s->s.h.keyframe || s->s.h.intraonly || !s->last_keyframe) ? 112 : 128;
+
+    // coefficients
+    for (i = 0; i < 4; i++)
+        for (j = 0; j < 2; j++)
+            for (k = 0; k < 2; k++)
+                for (l = 0; l < 6; l++)
+                    for (m = 0; m < 6; m++) {
+                        uint8_t *pp = s->prob_ctx[s->s.h.framectxid].coef[i][j][k][l][m];
+                        unsigned *e = s->td[0].counts.eob[i][j][k][l][m];
+                        unsigned *c = s->td[0].counts.coef[i][j][k][l][m];
+
+                        if (l == 0 && m >= 3) // dc only has 3 pt
+                            break;
+
+                        adapt_prob(&pp[0], e[0], e[1], 24, uf);
+                        adapt_prob(&pp[1], c[0], c[1] + c[2], 24, uf);
+                        adapt_prob(&pp[2], c[1], c[2], 24, uf);
+                    }
+
+    if (s->s.h.keyframe || s->s.h.intraonly) {
+        memcpy(p->skip,  s->prob.p.skip,  sizeof(p->skip));
+        memcpy(p->tx32p, s->prob.p.tx32p, sizeof(p->tx32p));
+        memcpy(p->tx16p, s->prob.p.tx16p, sizeof(p->tx16p));
+        memcpy(p->tx8p,  s->prob.p.tx8p,  sizeof(p->tx8p));
+        return;
+    }
+
+    // skip flag
+    for (i = 0; i < 3; i++)
+        adapt_prob(&p->skip[i], s->td[0].counts.skip[i][0],
+                   s->td[0].counts.skip[i][1], 20, 128);
+
+    // intra/inter flag
+    for (i = 0; i < 4; i++)
+        adapt_prob(&p->intra[i], s->td[0].counts.intra[i][0],
+                   s->td[0].counts.intra[i][1], 20, 128);
+
+    // comppred flag
+    if (s->s.h.comppredmode == PRED_SWITCHABLE) {
+        for (i = 0; i < 5; i++)
+            adapt_prob(&p->comp[i], s->td[0].counts.comp[i][0],
+                       s->td[0].counts.comp[i][1], 20, 128);
+    }
+
+    // reference frames
+    if (s->s.h.comppredmode != PRED_SINGLEREF) {
+        for (i = 0; i < 5; i++)
+            adapt_prob(&p->comp_ref[i], s->td[0].counts.comp_ref[i][0],
+                       s->td[0].counts.comp_ref[i][1], 20, 128);
+    }
+
+    if (s->s.h.comppredmode != PRED_COMPREF) {
+        for (i = 0; i < 5; i++) {
+            uint8_t *pp = p->single_ref[i];
+            unsigned (*c)[2] = s->td[0].counts.single_ref[i];
+
+            adapt_prob(&pp[0], c[0][0], c[0][1], 20, 128);
+            adapt_prob(&pp[1], c[1][0], c[1][1], 20, 128);
+        }
+    }
+
+    // block partitioning
+    for (i = 0; i < 4; i++)
+        for (j = 0; j < 4; j++) {
+            uint8_t *pp = p->partition[i][j];
+            unsigned *c = s->td[0].counts.partition[i][j];
+
+            adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
+            adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
+            adapt_prob(&pp[2], c[2], c[3], 20, 128);
+        }
+
+    // tx size
+    if (s->s.h.txfmmode == TX_SWITCHABLE) {
+        for (i = 0; i < 2; i++) {
+            unsigned *c16 = s->td[0].counts.tx16p[i], *c32 = s->td[0].counts.tx32p[i];
+
+            adapt_prob(&p->tx8p[i], s->td[0].counts.tx8p[i][0],
+                       s->td[0].counts.tx8p[i][1], 20, 128);
+            adapt_prob(&p->tx16p[i][0], c16[0], c16[1] + c16[2], 20, 128);
+            adapt_prob(&p->tx16p[i][1], c16[1], c16[2], 20, 128);
+            adapt_prob(&p->tx32p[i][0], c32[0], c32[1] + c32[2] + c32[3], 20, 128);
+            adapt_prob(&p->tx32p[i][1], c32[1], c32[2] + c32[3], 20, 128);
+            adapt_prob(&p->tx32p[i][2], c32[2], c32[3], 20, 128);
+        }
+    }
+
+    // interpolation filter
+    if (s->s.h.filtermode == FILTER_SWITCHABLE) {
+        for (i = 0; i < 4; i++) {
+            uint8_t *pp = p->filter[i];
+            unsigned *c = s->td[0].counts.filter[i];
+
+            adapt_prob(&pp[0], c[0], c[1] + c[2], 20, 128);
+            adapt_prob(&pp[1], c[1], c[2], 20, 128);
+        }
+    }
+
+    // inter modes
+    for (i = 0; i < 7; i++) {
+        uint8_t *pp = p->mv_mode[i];
+        unsigned *c = s->td[0].counts.mv_mode[i];
+
+        adapt_prob(&pp[0], c[2], c[1] + c[0] + c[3], 20, 128);
+        adapt_prob(&pp[1], c[0], c[1] + c[3], 20, 128);
+        adapt_prob(&pp[2], c[1], c[3], 20, 128);
+    }
+
+    // mv joints
+    {
+        uint8_t *pp = p->mv_joint;
+        unsigned *c = s->td[0].counts.mv_joint;
+
+        adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
+        adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
+        adapt_prob(&pp[2], c[2], c[3], 20, 128);
+    }
+
+    // mv components
+    for (i = 0; i < 2; i++) {
+        uint8_t *pp;
+        unsigned *c, (*c2)[2], sum;
+
+        adapt_prob(&p->mv_comp[i].sign, s->td[0].counts.mv_comp[i].sign[0],
+                   s->td[0].counts.mv_comp[i].sign[1], 20, 128);
+
+        pp  = p->mv_comp[i].classes;
+        c   = s->td[0].counts.mv_comp[i].classes;
+        sum = c[1] + c[2] + c[3] + c[4] + c[5] +
+              c[6] + c[7] + c[8] + c[9] + c[10];
+        adapt_prob(&pp[0], c[0], sum, 20, 128);
+        sum -= c[1];
+        adapt_prob(&pp[1], c[1], sum, 20, 128);
+        sum -= c[2] + c[3];
+        adapt_prob(&pp[2], c[2] + c[3], sum, 20, 128);
+        adapt_prob(&pp[3], c[2], c[3], 20, 128);
+        sum -= c[4] + c[5];
+        adapt_prob(&pp[4], c[4] + c[5], sum, 20, 128);
+        adapt_prob(&pp[5], c[4], c[5], 20, 128);
+        sum -= c[6];
+        adapt_prob(&pp[6], c[6], sum, 20, 128);
+        adapt_prob(&pp[7], c[7] + c[8], c[9] + c[10], 20, 128);
+        adapt_prob(&pp[8], c[7], c[8], 20, 128);
+        adapt_prob(&pp[9], c[9], c[10], 20, 128);
+
+        adapt_prob(&p->mv_comp[i].class0, s->td[0].counts.mv_comp[i].class0[0],
+                   s->td[0].counts.mv_comp[i].class0[1], 20, 128);
+        pp = p->mv_comp[i].bits;
+        c2 = s->td[0].counts.mv_comp[i].bits;
+        for (j = 0; j < 10; j++)
+            adapt_prob(&pp[j], c2[j][0], c2[j][1], 20, 128);
+
+        for (j = 0; j < 2; j++) {
+            pp = p->mv_comp[i].class0_fp[j];
+            c  = s->td[0].counts.mv_comp[i].class0_fp[j];
+            adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
+            adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
+            adapt_prob(&pp[2], c[2], c[3], 20, 128);
+        }
+        pp = p->mv_comp[i].fp;
+        c  = s->td[0].counts.mv_comp[i].fp;
+        adapt_prob(&pp[0], c[0], c[1] + c[2] + c[3], 20, 128);
+        adapt_prob(&pp[1], c[1], c[2] + c[3], 20, 128);
+        adapt_prob(&pp[2], c[2], c[3], 20, 128);
+
+        if (s->s.h.highprecisionmvs) {
+            adapt_prob(&p->mv_comp[i].class0_hp,
+                       s->td[0].counts.mv_comp[i].class0_hp[0],
+                       s->td[0].counts.mv_comp[i].class0_hp[1], 20, 128);
+            adapt_prob(&p->mv_comp[i].hp, s->td[0].counts.mv_comp[i].hp[0],
+                       s->td[0].counts.mv_comp[i].hp[1], 20, 128);
+        }
+    }
+
+    // y intra modes
+    for (i = 0; i < 4; i++) {
+        uint8_t *pp = p->y_mode[i];
+        unsigned *c = s->td[0].counts.y_mode[i], sum, s2;
+
+        sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
+        adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
+        sum -= c[TM_VP8_PRED];
+        adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
+        sum -= c[VERT_PRED];
+        adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
+        s2   = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
+        sum -= s2;
+        adapt_prob(&pp[3], s2, sum, 20, 128);
+        s2 -= c[HOR_PRED];
+        adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
+        adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED],
+                   20, 128);
+        sum -= c[DIAG_DOWN_LEFT_PRED];
+        adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
+        sum -= c[VERT_LEFT_PRED];
+        adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
+        adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
+    }
+
+    // uv intra modes
+    for (i = 0; i < 10; i++) {
+        uint8_t *pp = p->uv_mode[i];
+        unsigned *c = s->td[0].counts.uv_mode[i], sum, s2;
+
+        sum = c[0] + c[1] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8] + c[9];
+        adapt_prob(&pp[0], c[DC_PRED], sum, 20, 128);
+        sum -= c[TM_VP8_PRED];
+        adapt_prob(&pp[1], c[TM_VP8_PRED], sum, 20, 128);
+        sum -= c[VERT_PRED];
+        adapt_prob(&pp[2], c[VERT_PRED], sum, 20, 128);
+        s2   = c[HOR_PRED] + c[DIAG_DOWN_RIGHT_PRED] + c[VERT_RIGHT_PRED];
+        sum -= s2;
+        adapt_prob(&pp[3], s2, sum, 20, 128);
+        s2 -= c[HOR_PRED];
+        adapt_prob(&pp[4], c[HOR_PRED], s2, 20, 128);
+        adapt_prob(&pp[5], c[DIAG_DOWN_RIGHT_PRED], c[VERT_RIGHT_PRED],
+                   20, 128);
+        sum -= c[DIAG_DOWN_LEFT_PRED];
+        adapt_prob(&pp[6], c[DIAG_DOWN_LEFT_PRED], sum, 20, 128);
+        sum -= c[VERT_LEFT_PRED];
+        adapt_prob(&pp[7], c[VERT_LEFT_PRED], sum, 20, 128);
+        adapt_prob(&pp[8], c[HOR_DOWN_PRED], c[HOR_UP_PRED], 20, 128);
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9recon.c b/mythtv/external/FFmpeg/libavcodec/vp9recon.c
new file mode 100644
index 00000000000..49bb04e1f40
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vp9recon.c
@@ -0,0 +1,644 @@
+/*
+ * VP9 compatible video decoder
+ *
+ * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
+ * Copyright (C) 2013 Clément Bœsch <u pkh me>
+ *
+ * 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/avassert.h"
+
+#include "avcodec.h"
+#include "internal.h"
+#include "videodsp.h"
+#include "vp9data.h"
+#include "vp9dec.h"
+
+static av_always_inline int check_intra_mode(VP9TileData *td, int mode, uint8_t **a,
+                                             uint8_t *dst_edge, ptrdiff_t stride_edge,
+                                             uint8_t *dst_inner, ptrdiff_t stride_inner,
+                                             uint8_t *l, int col, int x, int w,
+                                             int row, int y, enum TxfmMode tx,
+                                             int p, int ss_h, int ss_v, int bytesperpixel)
+{
+    VP9Context *s = td->s;
+    int have_top = row > 0 || y > 0;
+    int have_left = col > td->tile_col_start || x > 0;
+    int have_right = x < w - 1;
+    int bpp = s->s.h.bpp;
+    static const uint8_t mode_conv[10][2 /* have_left */][2 /* have_top */] = {
+        [VERT_PRED]            = { { DC_127_PRED,          VERT_PRED            },
+                                   { DC_127_PRED,          VERT_PRED            } },
+        [HOR_PRED]             = { { DC_129_PRED,          DC_129_PRED          },
+                                   { HOR_PRED,             HOR_PRED             } },
+        [DC_PRED]              = { { DC_128_PRED,          TOP_DC_PRED          },
+                                   { LEFT_DC_PRED,         DC_PRED              } },
+        [DIAG_DOWN_LEFT_PRED]  = { { DC_127_PRED,          DIAG_DOWN_LEFT_PRED  },
+                                   { DC_127_PRED,          DIAG_DOWN_LEFT_PRED  } },
+        [DIAG_DOWN_RIGHT_PRED] = { { DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_RIGHT_PRED },
+                                   { DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_RIGHT_PRED } },
+        [VERT_RIGHT_PRED]      = { { VERT_RIGHT_PRED,      VERT_RIGHT_PRED      },
+                                   { VERT_RIGHT_PRED,      VERT_RIGHT_PRED      } },
+        [HOR_DOWN_PRED]        = { { HOR_DOWN_PRED,        HOR_DOWN_PRED        },
+                                   { HOR_DOWN_PRED,        HOR_DOWN_PRED        } },
+        [VERT_LEFT_PRED]       = { { DC_127_PRED,          VERT_LEFT_PRED       },
+                                   { DC_127_PRED,          VERT_LEFT_PRED       } },
+        [HOR_UP_PRED]          = { { DC_129_PRED,          DC_129_PRED          },
+                                   { HOR_UP_PRED,          HOR_UP_PRED          } },
+        [TM_VP8_PRED]          = { { DC_129_PRED,          VERT_PRED            },
+                                   { HOR_PRED,             TM_VP8_PRED          } },
+    };
+    static const struct {
+        uint8_t needs_left:1;
+        uint8_t needs_top:1;
+        uint8_t needs_topleft:1;
+        uint8_t needs_topright:1;
+        uint8_t invert_left:1;
+    } edges[N_INTRA_PRED_MODES] = {
+        [VERT_PRED]            = { .needs_top  = 1 },
+        [HOR_PRED]             = { .needs_left = 1 },
+        [DC_PRED]              = { .needs_top  = 1, .needs_left = 1 },
+        [DIAG_DOWN_LEFT_PRED]  = { .needs_top  = 1, .needs_topright = 1 },
+        [DIAG_DOWN_RIGHT_PRED] = { .needs_left = 1, .needs_top = 1,
+                                   .needs_topleft = 1 },
+        [VERT_RIGHT_PRED]      = { .needs_left = 1, .needs_top = 1,
+                                   .needs_topleft = 1 },
+        [HOR_DOWN_PRED]        = { .needs_left = 1, .needs_top = 1,
+                                   .needs_topleft = 1 },
+        [VERT_LEFT_PRED]       = { .needs_top  = 1, .needs_topright = 1 },
+        [HOR_UP_PRED]          = { .needs_left = 1, .invert_left = 1 },
+        [TM_VP8_PRED]          = { .needs_left = 1, .needs_top = 1,
+                                   .needs_topleft = 1 },
+        [LEFT_DC_PRED]         = { .needs_left = 1 },
+        [TOP_DC_PRED]          = { .needs_top  = 1 },
+        [DC_128_PRED]          = { 0 },
+        [DC_127_PRED]          = { 0 },
+        [DC_129_PRED]          = { 0 }
+    };
+
+    av_assert2(mode >= 0 && mode < 10);
+    mode = mode_conv[mode][have_left][have_top];
+    if (edges[mode].needs_top) {
+        uint8_t *top, *topleft;
+        int n_px_need = 4 << tx, n_px_have = (((s->cols - col) << !ss_h) - x) * 4;
+        int n_px_need_tr = 0;
+
+        if (tx == TX_4X4 && edges[mode].needs_topright && have_right)
+            n_px_need_tr = 4;
+
+        // if top of sb64-row, use s->intra_pred_data[] instead of
+        // dst[-stride] for intra prediction (it contains pre- instead of
+        // post-loopfilter data)
+        if (have_top) {
+            top = !(row & 7) && !y ?
+                s->intra_pred_data[p] + (col * (8 >> ss_h) + x * 4) * bytesperpixel :
+                y == 0 ? &dst_edge[-stride_edge] : &dst_inner[-stride_inner];
+            if (have_left)
+                topleft = !(row & 7) && !y ?
+                    s->intra_pred_data[p] + (col * (8 >> ss_h) + x * 4) * bytesperpixel :
+                    y == 0 || x == 0 ? &dst_edge[-stride_edge] :
+                    &dst_inner[-stride_inner];
+        }
+
+        if (have_top &&
+            (!edges[mode].needs_topleft || (have_left && top == topleft)) &&
+            (tx != TX_4X4 || !edges[mode].needs_topright || have_right) &&
+            n_px_need + n_px_need_tr <= n_px_have) {
+            *a = top;
+        } else {
+            if (have_top) {
+                if (n_px_need <= n_px_have) {
+                    memcpy(*a, top, n_px_need * bytesperpixel);
+                } else {
+#define memset_bpp(c, i1, v, i2, num) do { \
+    if (bytesperpixel == 1) { \
+        memset(&(c)[(i1)], (v)[(i2)], (num)); \
+    } else { \
+        int n, val = AV_RN16A(&(v)[(i2) * 2]); \
+        for (n = 0; n < (num); n++) { \
+            AV_WN16A(&(c)[((i1) + n) * 2], val); \
+        } \
+    } \
+} while (0)
+                    memcpy(*a, top, n_px_have * bytesperpixel);
+                    memset_bpp(*a, n_px_have, (*a), n_px_have - 1, n_px_need - n_px_have);
+                }
+            } else {
+#define memset_val(c, val, num) do { \
+    if (bytesperpixel == 1) { \
+        memset((c), (val), (num)); \
+    } else { \
+        int n; \
+        for (n = 0; n < (num); n++) { \
+            AV_WN16A(&(c)[n * 2], (val)); \
+        } \
+    } \
+} while (0)
+                memset_val(*a, (128 << (bpp - 8)) - 1, n_px_need);
+            }
+            if (edges[mode].needs_topleft) {
+                if (have_left && have_top) {
+#define assign_bpp(c, i1, v, i2) do { \
+    if (bytesperpixel == 1) { \
+        (c)[(i1)] = (v)[(i2)]; \
+    } else { \
+        AV_COPY16(&(c)[(i1) * 2], &(v)[(i2) * 2]); \
+    } \
+} while (0)
+                    assign_bpp(*a, -1, topleft, -1);
+                } else {
+#define assign_val(c, i, v) do { \
+    if (bytesperpixel == 1) { \
+        (c)[(i)] = (v); \
+    } else { \
+        AV_WN16A(&(c)[(i) * 2], (v)); \
+    } \
+} while (0)
+                    assign_val((*a), -1, (128 << (bpp - 8)) + (have_top ? +1 : -1));
+                }
+            }
+            if (tx == TX_4X4 && edges[mode].needs_topright) {
+                if (have_top && have_right &&
+                    n_px_need + n_px_need_tr <= n_px_have) {
+                    memcpy(&(*a)[4 * bytesperpixel], &top[4 * bytesperpixel], 4 * bytesperpixel);
+                } else {
+                    memset_bpp(*a, 4, *a, 3, 4);
+                }
+            }
+        }
+    }
+    if (edges[mode].needs_left) {
+        if (have_left) {
+            int n_px_need = 4 << tx, i, n_px_have = (((s->rows - row) << !ss_v) - y) * 4;
+            uint8_t *dst = x == 0 ? dst_edge : dst_inner;
+            ptrdiff_t stride = x == 0 ? stride_edge : stride_inner;
+
+            if (edges[mode].invert_left) {
+                if (n_px_need <= n_px_have) {
+                    for (i = 0; i < n_px_need; i++)
+                        assign_bpp(l, i, &dst[i * stride], -1);
+                } else {
+                    for (i = 0; i < n_px_have; i++)
+                        assign_bpp(l, i, &dst[i * stride], -1);
+                    memset_bpp(l, n_px_have, l, n_px_have - 1, n_px_need - n_px_have);
+                }
+            } else {
+                if (n_px_need <= n_px_have) {
+                    for (i = 0; i < n_px_need; i++)
+                        assign_bpp(l, n_px_need - 1 - i, &dst[i * stride], -1);
+                } else {
+                    for (i = 0; i < n_px_have; i++)
+                        assign_bpp(l, n_px_need - 1 - i, &dst[i * stride], -1);
+                    memset_bpp(l, 0, l, n_px_need - n_px_have, n_px_need - n_px_have);
+                }
+            }
+        } else {
+            memset_val(l, (128 << (bpp - 8)) + 1, 4 << tx);
+        }
+    }
+
+    return mode;
+}
+
+static av_always_inline void intra_recon(VP9TileData *td, ptrdiff_t y_off,
+                                         ptrdiff_t uv_off, int bytesperpixel)
+{
+    VP9Context *s = td->s;
+    VP9Block *b = td->b;
+    int row = td->row, col = td->col;
+    int w4 = ff_vp9_bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
+    int h4 = ff_vp9_bwh_tab[1][b->bs][1] << 1, x, y, step = 1 << (b->tx * 2);
+    int end_x = FFMIN(2 * (s->cols - col), w4);
+    int end_y = FFMIN(2 * (s->rows - row), h4);
+    int tx = 4 * s->s.h.lossless + b->tx, uvtx = b->uvtx + 4 * s->s.h.lossless;
+    int uvstep1d = 1 << b->uvtx, p;
+    uint8_t *dst = td->dst[0], *dst_r = s->s.frames[CUR_FRAME].tf.f->data[0] + y_off;
+    LOCAL_ALIGNED_32(uint8_t, a_buf, [96]);
+    LOCAL_ALIGNED_32(uint8_t, l, [64]);
+
+    for (n = 0, y = 0; y < end_y; y += step1d) {
+        uint8_t *ptr = dst, *ptr_r = dst_r;
+        for (x = 0; x < end_x; x += step1d, ptr += 4 * step1d * bytesperpixel,
+                               ptr_r += 4 * step1d * bytesperpixel, n += step) {
+            int mode = b->mode[b->bs > BS_8x8 && b->tx == TX_4X4 ?
+                               y * 2 + x : 0];
+            uint8_t *a = &a_buf[32];
+            enum TxfmType txtp = ff_vp9_intra_txfm_type[mode];
+            int eob = b->skip ? 0 : b->tx > TX_8X8 ? AV_RN16A(&td->eob[n]) : td->eob[n];
+
+            mode = check_intra_mode(td, mode, &a, ptr_r,
+                                    s->s.frames[CUR_FRAME].tf.f->linesize[0],
+                                    ptr, td->y_stride, l,
+                                    col, x, w4, row, y, b->tx, 0, 0, 0, bytesperpixel);
+            s->dsp.intra_pred[b->tx][mode](ptr, td->y_stride, l, a);
+            if (eob)
+                s->dsp.itxfm_add[tx][txtp](ptr, td->y_stride,
+                                           td->block + 16 * n * bytesperpixel, eob);
+        }
+        dst_r += 4 * step1d * s->s.frames[CUR_FRAME].tf.f->linesize[0];
+        dst   += 4 * step1d * td->y_stride;
+    }
+
+    // U/V
+    w4    >>= s->ss_h;
+    end_x >>= s->ss_h;
+    end_y >>= s->ss_v;
+    step = 1 << (b->uvtx * 2);
+    for (p = 0; p < 2; p++) {
+        dst   = td->dst[1 + p];
+        dst_r = s->s.frames[CUR_FRAME].tf.f->data[1 + p] + uv_off;
+        for (n = 0, y = 0; y < end_y; y += uvstep1d) {
+            uint8_t *ptr = dst, *ptr_r = dst_r;
+            for (x = 0; x < end_x; x += uvstep1d, ptr += 4 * uvstep1d * bytesperpixel,
+                                   ptr_r += 4 * uvstep1d * bytesperpixel, n += step) {
+                int mode = b->uvmode;
+                uint8_t *a = &a_buf[32];
+                int eob = b->skip ? 0 : b->uvtx > TX_8X8 ? AV_RN16A(&td->uveob[p][n]) : td->uveob[p][n];
+
+                mode = check_intra_mode(td, mode, &a, ptr_r,
+                                        s->s.frames[CUR_FRAME].tf.f->linesize[1],
+                                        ptr, td->uv_stride, l, col, x, w4, row, y,
+                                        b->uvtx, p + 1, s->ss_h, s->ss_v, bytesperpixel);
+                s->dsp.intra_pred[b->uvtx][mode](ptr, td->uv_stride, l, a);
+                if (eob)
+                    s->dsp.itxfm_add[uvtx][DCT_DCT](ptr, td->uv_stride,
+                                                    td->uvblock[p] + 16 * n * bytesperpixel, eob);
+            }
+            dst_r += 4 * uvstep1d * s->s.frames[CUR_FRAME].tf.f->linesize[1];
+            dst   += 4 * uvstep1d * td->uv_stride;
+        }
+    }
+}
+
+void ff_vp9_intra_recon_8bpp(VP9TileData *td, ptrdiff_t y_off, ptrdiff_t uv_off)
+{
+    intra_recon(td, y_off, uv_off, 1);
+}
+
+void ff_vp9_intra_recon_16bpp(VP9TileData *td, ptrdiff_t y_off, ptrdiff_t uv_off)
+{
+    intra_recon(td, y_off, uv_off, 2);
+}
+
+static av_always_inline void mc_luma_unscaled(VP9TileData *td, vp9_mc_func (*mc)[2],
+                                              uint8_t *dst, ptrdiff_t dst_stride,
+                                              const uint8_t *ref, ptrdiff_t ref_stride,
+                                              ThreadFrame *ref_frame,
+                                              ptrdiff_t y, ptrdiff_t x, const VP56mv *mv,
+                                              int bw, int bh, int w, int h, int bytesperpixel)
+{
+    VP9Context *s = td->s;
+    int mx = mv->x, my = mv->y, th;
+
+    y += my >> 3;
+    x += mx >> 3;
+    ref += y * ref_stride + x * bytesperpixel;
+    mx &= 7;
+    my &= 7;
+    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
+    // we use +7 because the last 7 pixels of each sbrow can be changed in
+    // the longest loopfilter of the next sbrow
+    th = (y + bh + 4 * !!my + 7) >> 6;
+    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
+    // The arm/aarch64 _hv filters read one more row than what actually is
+    // needed, so switch to emulated edge one pixel sooner vertically
+    // (!!my * 5) than horizontally (!!mx * 4).
+    if (x < !!mx * 3 || y < !!my * 3 ||
+        x + !!mx * 4 > w - bw || y + !!my * 5 > h - bh) {
+        s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
+                                 ref - !!my * 3 * ref_stride - !!mx * 3 * bytesperpixel,
+                                 160, ref_stride,
+                                 bw + !!mx * 7, bh + !!my * 7,
+                                 x - !!mx * 3, y - !!my * 3, w, h);
+        ref = td->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
+        ref_stride = 160;
+    }
+    mc[!!mx][!!my](dst, dst_stride, ref, ref_stride, bh, mx << 1, my << 1);
+}
+
+static av_always_inline void mc_chroma_unscaled(VP9TileData *td, vp9_mc_func (*mc)[2],
+                                                uint8_t *dst_u, uint8_t *dst_v,
+                                                ptrdiff_t dst_stride,
+                                                const uint8_t *ref_u, ptrdiff_t src_stride_u,
+                                                const uint8_t *ref_v, ptrdiff_t src_stride_v,
+                                                ThreadFrame *ref_frame,
+                                                ptrdiff_t y, ptrdiff_t x, const VP56mv *mv,
+                                                int bw, int bh, int w, int h, int bytesperpixel)
+{
+    VP9Context *s = td->s;
+    int mx = mv->x * (1 << !s->ss_h), my = mv->y * (1 << !s->ss_v), th;
+
+    y += my >> 4;
+    x += mx >> 4;
+    ref_u += y * src_stride_u + x * bytesperpixel;
+    ref_v += y * src_stride_v + x * bytesperpixel;
+    mx &= 15;
+    my &= 15;
+    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
+    // we use +7 because the last 7 pixels of each sbrow can be changed in
+    // the longest loopfilter of the next sbrow
+    th = (y + bh + 4 * !!my + 7) >> (6 - s->ss_v);
+    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
+    // The arm/aarch64 _hv filters read one more row than what actually is
+    // needed, so switch to emulated edge one pixel sooner vertically
+    // (!!my * 5) than horizontally (!!mx * 4).
+    if (x < !!mx * 3 || y < !!my * 3 ||
+        x + !!mx * 4 > w - bw || y + !!my * 5 > h - bh) {
+        s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
+                                 ref_u - !!my * 3 * src_stride_u - !!mx * 3 * bytesperpixel,
+                                 160, src_stride_u,
+                                 bw + !!mx * 7, bh + !!my * 7,
+                                 x - !!mx * 3, y - !!my * 3, w, h);
+        ref_u = td->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
+        mc[!!mx][!!my](dst_u, dst_stride, ref_u, 160, bh, mx, my);
+
+        s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
+                                 ref_v - !!my * 3 * src_stride_v - !!mx * 3 * bytesperpixel,
+                                 160, src_stride_v,
+                                 bw + !!mx * 7, bh + !!my * 7,
+                                 x - !!mx * 3, y - !!my * 3, w, h);
+        ref_v = td->edge_emu_buffer + !!my * 3 * 160 + !!mx * 3 * bytesperpixel;
+        mc[!!mx][!!my](dst_v, dst_stride, ref_v, 160, bh, mx, my);
+    } else {
+        mc[!!mx][!!my](dst_u, dst_stride, ref_u, src_stride_u, bh, mx, my);
+        mc[!!mx][!!my](dst_v, dst_stride, ref_v, src_stride_v, bh, mx, my);
+    }
+}
+
+#define mc_luma_dir(td, mc, dst, dst_ls, src, src_ls, tref, row, col, mv, \
+                    px, py, pw, ph, bw, bh, w, h, i) \
+    mc_luma_unscaled(td, s->dsp.mc, dst, dst_ls, src, src_ls, tref, row, col, \
+                     mv, bw, bh, w, h, bytesperpixel)
+#define mc_chroma_dir(td, mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
+                      row, col, mv, px, py, pw, ph, bw, bh, w, h, i) \
+    mc_chroma_unscaled(td, s->dsp.mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
+                       row, col, mv, bw, bh, w, h, bytesperpixel)
+#define SCALED 0
+#define FN(x) x##_8bpp
+#define BYTES_PER_PIXEL 1
+#include "vp9_mc_template.c"
+#undef FN
+#undef BYTES_PER_PIXEL
+#define FN(x) x##_16bpp
+#define BYTES_PER_PIXEL 2
+#include "vp9_mc_template.c"
+#undef mc_luma_dir
+#undef mc_chroma_dir
+#undef FN
+#undef BYTES_PER_PIXEL
+#undef SCALED
+
+static av_always_inline void mc_luma_scaled(VP9TileData *td, vp9_scaled_mc_func smc,
+                                            vp9_mc_func (*mc)[2],
+                                            uint8_t *dst, ptrdiff_t dst_stride,
+                                            const uint8_t *ref, ptrdiff_t ref_stride,
+                                            ThreadFrame *ref_frame,
+                                            ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv,
+                                            int px, int py, int pw, int ph,
+                                            int bw, int bh, int w, int h, int bytesperpixel,
+                                            const uint16_t *scale, const uint8_t *step)
+{
+    VP9Context *s = td->s;
+    if (s->s.frames[CUR_FRAME].tf.f->width == ref_frame->f->width &&
+        s->s.frames[CUR_FRAME].tf.f->height == ref_frame->f->height) {
+        mc_luma_unscaled(td, mc, dst, dst_stride, ref, ref_stride, ref_frame,
+                         y, x, in_mv, bw, bh, w, h, bytesperpixel);
+    } else {
+#define scale_mv(n, dim) (((int64_t)(n) * scale[dim]) >> 14)
+    int mx, my;
+    int refbw_m1, refbh_m1;
+    int th;
+    VP56mv mv;
+
+    mv.x = av_clip(in_mv->x, -(x + pw - px + 4) * 8, (s->cols * 8 - x + px + 3) * 8);
+    mv.y = av_clip(in_mv->y, -(y + ph - py + 4) * 8, (s->rows * 8 - y + py + 3) * 8);
+    // BUG libvpx seems to scale the two components separately. This introduces
+    // rounding errors but we have to reproduce them to be exactly compatible
+    // with the output from libvpx...
+    mx = scale_mv(mv.x * 2, 0) + scale_mv(x * 16, 0);
+    my = scale_mv(mv.y * 2, 1) + scale_mv(y * 16, 1);
+
+    y = my >> 4;
+    x = mx >> 4;
+    ref += y * ref_stride + x * bytesperpixel;
+    mx &= 15;
+    my &= 15;
+    refbw_m1 = ((bw - 1) * step[0] + mx) >> 4;
+    refbh_m1 = ((bh - 1) * step[1] + my) >> 4;
+    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
+    // we use +7 because the last 7 pixels of each sbrow can be changed in
+    // the longest loopfilter of the next sbrow
+    th = (y + refbh_m1 + 4 + 7) >> 6;
+    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
+    // The arm/aarch64 _hv filters read one more row than what actually is
+    // needed, so switch to emulated edge one pixel sooner vertically
+    // (y + 5 >= h - refbh_m1) than horizontally (x + 4 >= w - refbw_m1).
+    if (x < 3 || y < 3 || x + 4 >= w - refbw_m1 || y + 5 >= h - refbh_m1) {
+        s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
+                                 ref - 3 * ref_stride - 3 * bytesperpixel,
+                                 288, ref_stride,
+                                 refbw_m1 + 8, refbh_m1 + 8,
+                                 x - 3, y - 3, w, h);
+        ref = td->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
+        ref_stride = 288;
+    }
+    smc(dst, dst_stride, ref, ref_stride, bh, mx, my, step[0], step[1]);
+    }
+}
+
+static av_always_inline void mc_chroma_scaled(VP9TileData *td, vp9_scaled_mc_func smc,
+                                              vp9_mc_func (*mc)[2],
+                                              uint8_t *dst_u, uint8_t *dst_v,
+                                              ptrdiff_t dst_stride,
+                                              const uint8_t *ref_u, ptrdiff_t src_stride_u,
+                                              const uint8_t *ref_v, ptrdiff_t src_stride_v,
+                                              ThreadFrame *ref_frame,
+                                              ptrdiff_t y, ptrdiff_t x, const VP56mv *in_mv,
+                                              int px, int py, int pw, int ph,
+                                              int bw, int bh, int w, int h, int bytesperpixel,
+                                              const uint16_t *scale, const uint8_t *step)
+{
+    VP9Context *s = td->s;
+    if (s->s.frames[CUR_FRAME].tf.f->width == ref_frame->f->width &&
+        s->s.frames[CUR_FRAME].tf.f->height == ref_frame->f->height) {
+        mc_chroma_unscaled(td, mc, dst_u, dst_v, dst_stride, ref_u, src_stride_u,
+                           ref_v, src_stride_v, ref_frame,
+                           y, x, in_mv, bw, bh, w, h, bytesperpixel);
+    } else {
+    int mx, my;
+    int refbw_m1, refbh_m1;
+    int th;
+    VP56mv mv;
+
+    if (s->ss_h) {
+        // BUG https://code.google.com/p/webm/issues/detail?id=820
+        mv.x = av_clip(in_mv->x, -(x + pw - px + 4) * 16, (s->cols * 4 - x + px + 3) * 16);
+        mx = scale_mv(mv.x, 0) + (scale_mv(x * 16, 0) & ~15) + (scale_mv(x * 32, 0) & 15);
+    } else {
+        mv.x = av_clip(in_mv->x, -(x + pw - px + 4) * 8, (s->cols * 8 - x + px + 3) * 8);
+        mx = scale_mv(mv.x * 2, 0) + scale_mv(x * 16, 0);
+    }
+    if (s->ss_v) {
+        // BUG https://code.google.com/p/webm/issues/detail?id=820
+        mv.y = av_clip(in_mv->y, -(y + ph - py + 4) * 16, (s->rows * 4 - y + py + 3) * 16);
+        my = scale_mv(mv.y, 1) + (scale_mv(y * 16, 1) & ~15) + (scale_mv(y * 32, 1) & 15);
+    } else {
+        mv.y = av_clip(in_mv->y, -(y + ph - py + 4) * 8, (s->rows * 8 - y + py + 3) * 8);
+        my = scale_mv(mv.y * 2, 1) + scale_mv(y * 16, 1);
+    }
+#undef scale_mv
+    y = my >> 4;
+    x = mx >> 4;
+    ref_u += y * src_stride_u + x * bytesperpixel;
+    ref_v += y * src_stride_v + x * bytesperpixel;
+    mx &= 15;
+    my &= 15;
+    refbw_m1 = ((bw - 1) * step[0] + mx) >> 4;
+    refbh_m1 = ((bh - 1) * step[1] + my) >> 4;
+    // FIXME bilinear filter only needs 0/1 pixels, not 3/4
+    // we use +7 because the last 7 pixels of each sbrow can be changed in
+    // the longest loopfilter of the next sbrow
+    th = (y + refbh_m1 + 4 + 7) >> (6 - s->ss_v);
+    ff_thread_await_progress(ref_frame, FFMAX(th, 0), 0);
+    // The arm/aarch64 _hv filters read one more row than what actually is
+    // needed, so switch to emulated edge one pixel sooner vertically
+    // (y + 5 >= h - refbh_m1) than horizontally (x + 4 >= w - refbw_m1).
+    if (x < 3 || y < 3 || x + 4 >= w - refbw_m1 || y + 5 >= h - refbh_m1) {
+        s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
+                                 ref_u - 3 * src_stride_u - 3 * bytesperpixel,
+                                 288, src_stride_u,
+                                 refbw_m1 + 8, refbh_m1 + 8,
+                                 x - 3, y - 3, w, h);
+        ref_u = td->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
+        smc(dst_u, dst_stride, ref_u, 288, bh, mx, my, step[0], step[1]);
+
+        s->vdsp.emulated_edge_mc(td->edge_emu_buffer,
+                                 ref_v - 3 * src_stride_v - 3 * bytesperpixel,
+                                 288, src_stride_v,
+                                 refbw_m1 + 8, refbh_m1 + 8,
+                                 x - 3, y - 3, w, h);
+        ref_v = td->edge_emu_buffer + 3 * 288 + 3 * bytesperpixel;
+        smc(dst_v, dst_stride, ref_v, 288, bh, mx, my, step[0], step[1]);
+    } else {
+        smc(dst_u, dst_stride, ref_u, src_stride_u, bh, mx, my, step[0], step[1]);
+        smc(dst_v, dst_stride, ref_v, src_stride_v, bh, mx, my, step[0], step[1]);
+    }
+    }
+}
+
+#define mc_luma_dir(td, mc, dst, dst_ls, src, src_ls, tref, row, col, mv, \
+                    px, py, pw, ph, bw, bh, w, h, i) \
+    mc_luma_scaled(td, s->dsp.s##mc, s->dsp.mc, dst, dst_ls, src, src_ls, tref, row, col, \
+                   mv, px, py, pw, ph, bw, bh, w, h, bytesperpixel, \
+                   s->mvscale[b->ref[i]], s->mvstep[b->ref[i]])
+#define mc_chroma_dir(td, mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
+                      row, col, mv, px, py, pw, ph, bw, bh, w, h, i) \
+    mc_chroma_scaled(td, s->dsp.s##mc, s->dsp.mc, dstu, dstv, dst_ls, srcu, srcu_ls, srcv, srcv_ls, tref, \
+                     row, col, mv, px, py, pw, ph, bw, bh, w, h, bytesperpixel, \
+                     s->mvscale[b->ref[i]], s->mvstep[b->ref[i]])
+#define SCALED 1
+#define FN(x) x##_scaled_8bpp
+#define BYTES_PER_PIXEL 1
+#include "vp9_mc_template.c"
+#undef FN
+#undef BYTES_PER_PIXEL
+#define FN(x) x##_scaled_16bpp
+#define BYTES_PER_PIXEL 2
+#include "vp9_mc_template.c"
+#undef mc_luma_dir
+#undef mc_chroma_dir
+#undef FN
+#undef BYTES_PER_PIXEL
+#undef SCALED
+
+static av_always_inline void inter_recon(VP9TileData *td, int bytesperpixel)
+{
+    VP9Context *s = td->s;
+    VP9Block *b = td->b;
+    int row = td->row, col = td->col;
+
+    if (s->mvscale[b->ref[0]][0] || (b->comp && s->mvscale[b->ref[1]][0])) {
+        if (bytesperpixel == 1) {
+            inter_pred_scaled_8bpp(td);
+        } else {
+            inter_pred_scaled_16bpp(td);
+        }
+    } else {
+        if (bytesperpixel == 1) {
+            inter_pred_8bpp(td);
+        } else {
+            inter_pred_16bpp(td);
+        }
+    }
+
+    if (!b->skip) {
+        /* mostly copied intra_recon() */
+
+        int w4 = ff_vp9_bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
+        int h4 = ff_vp9_bwh_tab[1][b->bs][1] << 1, x, y, step = 1 << (b->tx * 2);
+        int end_x = FFMIN(2 * (s->cols - col), w4);
+        int end_y = FFMIN(2 * (s->rows - row), h4);
+        int tx = 4 * s->s.h.lossless + b->tx, uvtx = b->uvtx + 4 * s->s.h.lossless;
+        int uvstep1d = 1 << b->uvtx, p;
+        uint8_t *dst = td->dst[0];
+
+        // y itxfm add
+        for (n = 0, y = 0; y < end_y; y += step1d) {
+            uint8_t *ptr = dst;
+            for (x = 0; x < end_x; x += step1d,
+                 ptr += 4 * step1d * bytesperpixel, n += step) {
+                int eob = b->tx > TX_8X8 ? AV_RN16A(&td->eob[n]) : td->eob[n];
+
+                if (eob)
+                    s->dsp.itxfm_add[tx][DCT_DCT](ptr, td->y_stride,
+                                                  td->block + 16 * n * bytesperpixel, eob);
+            }
+            dst += 4 * td->y_stride * step1d;
+        }
+
+        // uv itxfm add
+        end_x >>= s->ss_h;
+        end_y >>= s->ss_v;
+        step = 1 << (b->uvtx * 2);
+        for (p = 0; p < 2; p++) {
+            dst = td->dst[p + 1];
+            for (n = 0, y = 0; y < end_y; y += uvstep1d) {
+                uint8_t *ptr = dst;
+                for (x = 0; x < end_x; x += uvstep1d,
+                     ptr += 4 * uvstep1d * bytesperpixel, n += step) {
+                    int eob = b->uvtx > TX_8X8 ? AV_RN16A(&td->uveob[p][n]) : td->uveob[p][n];
+
+                    if (eob)
+                        s->dsp.itxfm_add[uvtx][DCT_DCT](ptr, td->uv_stride,
+                                                        td->uvblock[p] + 16 * n * bytesperpixel, eob);
+                }
+                dst += 4 * uvstep1d * td->uv_stride;
+            }
+        }
+    }
+}
+
+void ff_vp9_inter_recon_8bpp(VP9TileData *td)
+{
+    inter_recon(td, 1);
+}
+
+void ff_vp9_inter_recon_16bpp(VP9TileData *td)
+{
+    inter_recon(td, 2);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/vp9shared.h b/mythtv/external/FFmpeg/libavcodec/vp9shared.h
new file mode 100644
index 00000000000..54726df742f
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/vp9shared.h
@@ -0,0 +1,169 @@
+/*
+ * VP9 compatible video decoder
+ *
+ * Copyright (C) 2013 Ronald S. Bultje <rsbultje gmail com>
+ * Copyright (C) 2013 Clément Bœsch <u pkh me>
+ *
+ * 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_VP9SHARED_H
+#define AVCODEC_VP9SHARED_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "vp9.h"
+#include "thread.h"
+#include "vp56.h"
+
+enum BlockPartition {
+    PARTITION_NONE,    // [ ] <-.
+    PARTITION_H,       // [-]   |
+    PARTITION_V,       // [|]   |
+    PARTITION_SPLIT,   // [+] --'
+};
+
+enum InterPredMode {
+    NEARESTMV = 10,
+    NEARMV    = 11,
+    ZEROMV    = 12,
+    NEWMV     = 13,
+};
+
+enum CompPredMode {
+    PRED_SINGLEREF,
+    PRED_COMPREF,
+    PRED_SWITCHABLE,
+};
+
+typedef struct VP9mvrefPair {
+    VP56mv mv[2];
+    int8_t ref[2];
+} VP9mvrefPair;
+
+typedef struct VP9Frame {
+    ThreadFrame tf;
+    AVBufferRef *extradata;
+    uint8_t *segmentation_map;
+    VP9mvrefPair *mv;
+    int uses_2pass;
+
+    AVBufferRef *hwaccel_priv_buf;
+    void *hwaccel_picture_private;
+} VP9Frame;
+
+enum BlockLevel {
+    BL_64X64,
+    BL_32X32,
+    BL_16X16,
+    BL_8X8,
+};
+
+enum BlockSize {
+    BS_64x64,
+    BS_64x32,
+    BS_32x64,
+    BS_32x32,
+    BS_32x16,
+    BS_16x32,
+    BS_16x16,
+    BS_16x8,
+    BS_8x16,
+    BS_8x8,
+    BS_8x4,
+    BS_4x8,
+    BS_4x4,
+    N_BS_SIZES,
+};
+
+typedef struct VP9BitstreamHeader {
+    // bitstream header
+    uint8_t profile;
+    uint8_t bpp;
+    uint8_t keyframe;
+    uint8_t invisible;
+    uint8_t errorres;
+    uint8_t intraonly;
+    uint8_t resetctx;
+    uint8_t refreshrefmask;
+    uint8_t highprecisionmvs;
+    enum FilterMode filtermode;
+    uint8_t allowcompinter;
+    uint8_t refreshctx;
+    uint8_t parallelmode;
+    uint8_t framectxid;
+    uint8_t use_last_frame_mvs;
+    uint8_t refidx[3];
+    uint8_t signbias[3];
+    uint8_t fixcompref;
+    uint8_t varcompref[2];
+    struct {
+        uint8_t level;
+        int8_t sharpness;
+    } filter;
+    struct {
+        uint8_t enabled;
+        uint8_t updated;
+        int8_t mode[2];
+        int8_t ref[4];
+    } lf_delta;
+    uint8_t yac_qi;
+    int8_t ydc_qdelta, uvdc_qdelta, uvac_qdelta;
+    uint8_t lossless;
+#define MAX_SEGMENT 8
+    struct {
+        uint8_t enabled;
+        uint8_t temporal;
+        uint8_t absolute_vals;
+        uint8_t update_map;
+        uint8_t prob[7];
+        uint8_t pred_prob[3];
+        struct {
+            uint8_t q_enabled;
+            uint8_t lf_enabled;
+            uint8_t ref_enabled;
+            uint8_t skip_enabled;
+            uint8_t ref_val;
+            int16_t q_val;
+            int8_t lf_val;
+            int16_t qmul[2][2];
+            uint8_t lflvl[4][2];
+        } feat[MAX_SEGMENT];
+    } segmentation;
+    enum TxfmMode txfmmode;
+    enum CompPredMode comppredmode;
+    struct {
+        unsigned log2_tile_cols, log2_tile_rows;
+        unsigned tile_cols, tile_rows;
+    } tiling;
+
+    int uncompressed_header_size;
+    int compressed_header_size;
+} VP9BitstreamHeader;
+
+typedef struct VP9SharedContext {
+    VP9BitstreamHeader h;
+
+    ThreadFrame refs[8];
+#define CUR_FRAME 0
+#define REF_FRAME_MVPAIR 1
+#define REF_FRAME_SEGMAP 2
+    VP9Frame frames[3];
+} VP9SharedContext;
+
+#endif /* AVCODEC_VP9SHARED_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/vqavideo.c b/mythtv/external/FFmpeg/libavcodec/vqavideo.c
index 81d50bb5a4f..0e70be1000a 100644
--- a/mythtv/external/FFmpeg/libavcodec/vqavideo.c
+++ b/mythtv/external/FFmpeg/libavcodec/vqavideo.c
@@ -384,12 +384,8 @@ static int vqa_decode_chunk(VqaContext *s, AVFrame *frame)
             break;
 
         default:
-            av_log(s->avctx, AV_LOG_ERROR, "Found unknown chunk type: %c%c%c%c (%08X)\n",
-            (chunk_type >> 24) & 0xFF,
-            (chunk_type >> 16) & 0xFF,
-            (chunk_type >>  8) & 0xFF,
-            (chunk_type >>  0) & 0xFF,
-            chunk_type);
+            av_log(s->avctx, AV_LOG_ERROR, "Found unknown chunk type: %s (%08X)\n",
+                   av_fourcc2str(av_bswap32(chunk_type)), chunk_type);
             break;
         }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/wavpack.c b/mythtv/external/FFmpeg/libavcodec/wavpack.c
index 071e2be72c5..a117e8aa81b 100644
--- a/mythtv/external/FFmpeg/libavcodec/wavpack.c
+++ b/mythtv/external/FFmpeg/libavcodec/wavpack.c
@@ -99,11 +99,13 @@ static av_always_inline int get_tail(GetBitContext *gb, int k)
     return res;
 }
 
-static void update_error_limit(WavpackFrameContext *ctx)
+static int update_error_limit(WavpackFrameContext *ctx)
 {
     int i, br[2], sl[2];
 
     for (i = 0; i <= ctx->stereo_in; i++) {
+        if (ctx->ch[i].bitrate_acc > UINT_MAX - ctx->ch[i].bitrate_delta)
+            return AVERROR_INVALIDDATA;
         ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
         br[i]                   = ctx->ch[i].bitrate_acc >> 16;
         sl[i]                   = LEVEL_DECAY(ctx->ch[i].slow_level);
@@ -111,10 +113,10 @@ static void update_error_limit(WavpackFrameContext *ctx)
     if (ctx->stereo_in && ctx->hybrid_bitrate) {
         int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
         if (balance > br[0]) {
-            br[1] = br[0] << 1;
+            br[1] = br[0] * 2;
             br[0] = 0;
         } else if (-balance > br[0]) {
-            br[0] <<= 1;
+            br[0]  *= 2;
             br[1]   = 0;
         } else {
             br[1] = br[0] + balance;
@@ -131,6 +133,8 @@ static void update_error_limit(WavpackFrameContext *ctx)
             ctx->ch[i].error_limit = wp_exp2(br[i]);
         }
     }
+
+    return 0;
 }
 
 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
@@ -153,7 +157,7 @@ static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
         } else {
             t = get_unary_0_33(gb);
             if (t >= 2) {
-                if (get_bits_left(gb) < t - 1)
+                if (t >= 32 || get_bits_left(gb) < t - 1)
                     goto error;
                 t = get_bits_long(gb, t - 1) | (1 << (t - 1));
             } else {
@@ -184,7 +188,7 @@ static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
                     goto error;
                 t += t2;
             } else {
-                if (get_bits_left(gb) < t2 - 1)
+                if (t2 >= 32 || get_bits_left(gb) < t2 - 1)
                     goto error;
                 t += get_bits_long(gb, t2 - 1) | (1 << (t2 - 1));
             }
@@ -200,8 +204,10 @@ static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
         ctx->zero = !ctx->one;
     }
 
-    if (ctx->hybrid && !channel)
-        update_error_limit(ctx);
+    if (ctx->hybrid && !channel) {
+        if (update_error_limit(ctx) < 0)
+            goto error;
+    }
 
     if (!t) {
         base = 0;
@@ -219,7 +225,7 @@ static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
         INC_MED(1);
         DEC_MED(2);
     } else {
-        base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
+        base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2U);
         add  = GET_MED(2) - 1;
         INC_MED(0);
         INC_MED(1);
@@ -234,16 +240,16 @@ static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
         if (get_bits_left(gb) <= 0)
             goto error;
     } else {
-        int mid = (base * 2 + add + 1) >> 1;
+        int mid = (base * 2U + add + 1) >> 1;
         while (add > c->error_limit) {
             if (get_bits_left(gb) <= 0)
                 goto error;
             if (get_bits1(gb)) {
-                add -= (mid - base);
+                add -= (mid - (unsigned)base);
                 base = mid;
             } else
-                add = mid - base - 1;
-            mid = (base * 2 + add + 1) >> 1;
+                add = mid - (unsigned)base - 1;
+            mid = (base * 2U + add + 1) >> 1;
         }
         ret = mid;
     }
@@ -262,12 +268,12 @@ static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb,
 }
 
 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
-                                       int S)
+                                       unsigned S)
 {
-    int bit;
+    unsigned bit;
 
     if (s->extra_bits) {
-        S <<= s->extra_bits;
+        S *= 1 << s->extra_bits;
 
         if (s->got_extra_bits &&
             get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
@@ -304,11 +310,11 @@ static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
     }
 
     if (S) {
-        S  <<= s->float_shift;
+        S  *= 1U << s->float_shift;
         sign = S < 0;
         if (sign)
-            S = -S;
-        if (S >= 0x1000000) {
+            S = -(unsigned)S;
+        if (S >= 0x1000000U) {
             if (s->got_extra_bits && get_bits1(&s->gb_extra_bits))
                 S = get_bits(&s->gb_extra_bits, 23);
             else
@@ -409,11 +415,11 @@ static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
             if (t > 0) {
                 if (t > 8) {
                     if (t & 1) {
-                        A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
-                        B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
+                        A = 2U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
+                        B = 2U * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
                     } else {
-                        A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
-                        B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
+                        A = (int)(3U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
+                        B = (int)(3U * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
                     }
                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
@@ -427,8 +433,8 @@ static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
                 } else {
-                    L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
-                    R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
+                    L2 = L + ((int)(s->decorr[i].weightA * (unsigned)A + 512) >> 10);
+                    R2 = R + ((int)(s->decorr[i].weightB * (unsigned)B + 512) >> 10);
                 }
                 if (A && L)
                     s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
@@ -440,13 +446,13 @@ static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
                 if (type != AV_SAMPLE_FMT_S16P)
                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
                 else
-                    L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
+                    L2 = L + ((int)(s->decorr[i].weightA * (unsigned)s->decorr[i].samplesA[0] + 512) >> 10);
                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
                 L = L2;
                 if (type != AV_SAMPLE_FMT_S16P)
                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
                 else
-                    R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
+                    R2 = R + ((int)(s->decorr[i].weightB * (unsigned)L2 + 512) >> 10);
                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
                 R                        = R2;
                 s->decorr[i].samplesA[0] = R;
@@ -454,7 +460,7 @@ static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
                 if (type != AV_SAMPLE_FMT_S16P)
                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
                 else
-                    R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
+                    R2 = R + ((int)(s->decorr[i].weightB * (unsigned)s->decorr[i].samplesB[0] + 512) >> 10);
                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
                 R = R2;
 
@@ -466,7 +472,7 @@ static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
                 if (type != AV_SAMPLE_FMT_S16P)
                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
                 else
-                    L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
+                    L2 = L + ((int)(s->decorr[i].weightA * (unsigned)R2 + 512) >> 10);
                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
                 L                        = L2;
                 s->decorr[i].samplesB[0] = L;
@@ -474,7 +480,7 @@ static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
         }
 
         if (type == AV_SAMPLE_FMT_S16P) {
-            if (FFABS(L) + FFABS(R) > (1<<19)) {
+            if (FFABS(L) + (unsigned)FFABS(R) > (1<<19)) {
                 av_log(s->avctx, AV_LOG_ERROR, "sample %d %d too large\n", L, R);
                 return AVERROR_INVALIDDATA;
             }
@@ -482,7 +488,7 @@ static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb,
 
         pos = (pos + 1) & 7;
         if (s->joint)
-            L += (R -= (L >> 1));
+            L += (unsigned)(R -= (unsigned)(L >> 1));
         crc = (crc * 3 + L) * 3 + R;
 
         if (type == AV_SAMPLE_FMT_FLTP) {
@@ -536,9 +542,9 @@ static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
             t = s->decorr[i].value;
             if (t > 8) {
                 if (t & 1)
-                    A =  2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
+                    A =  2U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
                 else
-                    A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
+                    A = (int)(3U * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
                 j                        = 0;
             } else {
@@ -548,7 +554,7 @@ static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb,
             if (type != AV_SAMPLE_FMT_S16P)
                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
             else
-                S = T + ((s->decorr[i].weightA * A + 512) >> 10);
+                S = T + ((int)(s->decorr[i].weightA * (unsigned)A + 512) >> 10);
             if (A && T)
                 s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
             s->decorr[i].samplesA[j] = T = S;
@@ -681,8 +687,11 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
     s->hybrid         =   s->frame_flags & WV_HYBRID_MODE;
     s->hybrid_bitrate =   s->frame_flags & WV_HYBRID_BITRATE;
     s->post_shift     = bpp * 8 - orig_bpp + ((s->frame_flags >> 13) & 0x1f);
+    if (s->post_shift < 0 || s->post_shift > 31) {
+        return AVERROR_INVALIDDATA;
+    }
     s->hybrid_maxclip =  ((1LL << (orig_bpp - 1)) - 1);
-    s->hybrid_minclip = ((-1LL << (orig_bpp - 1)));
+    s->hybrid_minclip = ((-1UL << (orig_bpp - 1)));
     s->CRC            = bytestream2_get_le32(&gb);
 
     // parse metadata blocks
@@ -736,13 +745,13 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
             }
             for (i = 0; i < weights; i++) {
                 t = (int8_t)bytestream2_get_byte(&gb);
-                s->decorr[s->terms - i - 1].weightA = t << 3;
+                s->decorr[s->terms - i - 1].weightA = t * (1 << 3);
                 if (s->decorr[s->terms - i - 1].weightA > 0)
                     s->decorr[s->terms - i - 1].weightA +=
                         (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
                 if (s->stereo_in) {
                     t = (int8_t)bytestream2_get_byte(&gb);
-                    s->decorr[s->terms - i - 1].weightB = t << 3;
+                    s->decorr[s->terms - i - 1].weightB = t * (1 << 3);
                     if (s->decorr[s->terms - i - 1].weightB > 0)
                         s->decorr[s->terms - i - 1].weightB +=
                             (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
@@ -837,9 +846,9 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
                 continue;
             }
             bytestream2_get_buffer(&gb, val, 4);
-            if (val[0] > 32) {
+            if (val[0] > 30) {
                 av_log(avctx, AV_LOG_ERROR,
-                       "Invalid INT32INFO, extra_bits = %d (> 32)\n", val[0]);
+                       "Invalid INT32INFO, extra_bits = %d (> 30)\n", val[0]);
                 continue;
             } else if (val[0]) {
                 s->extra_bits = val[0];
@@ -852,6 +861,12 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
                 s->and   = 1;
                 s->shift = val[3];
             }
+            if (s->shift > 31) {
+                av_log(avctx, AV_LOG_ERROR,
+                       "Invalid INT32INFO, shift = %d (> 31)\n", s->shift);
+                s->and = s->or = s->shift = 0;
+                continue;
+            }
             /* original WavPack decoder forces 32-bit lossy sound to be treated
              * as 24-bit one in order to have proper clipping */
             if (s->hybrid && bpp == 4 && s->post_shift < 8 && s->shift > 8) {
@@ -872,6 +887,12 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
             s->float_flag    = bytestream2_get_byte(&gb);
             s->float_shift   = bytestream2_get_byte(&gb);
             s->float_max_exp = bytestream2_get_byte(&gb);
+            if (s->float_shift > 31) {
+                av_log(avctx, AV_LOG_ERROR,
+                       "Invalid FLOATINFO, shift = %d (> 31)\n", s->float_shift);
+                s->float_shift = 0;
+                continue;
+            }
             got_float        = 1;
             bytestream2_skip(&gb, 1);
             break;
@@ -1016,7 +1037,7 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
 
     if (wc->ch_offset + s->stereo >= avctx->channels) {
         av_log(avctx, AV_LOG_WARNING, "Too many channels coded in a packet.\n");
-        return (avctx->err_recognition & AV_EF_EXPLODE) ? AVERROR_INVALIDDATA : 0;
+        return ((avctx->err_recognition & AV_EF_EXPLODE) || !wc->ch_offset) ? AVERROR_INVALIDDATA : 0;
     }
 
     samples_l = frame->extended_data[wc->ch_offset];
diff --git a/mythtv/external/FFmpeg/libavcodec/wavpack.h b/mythtv/external/FFmpeg/libavcodec/wavpack.h
index a1b46d5bd74..3ae601f9143 100644
--- a/mythtv/external/FFmpeg/libavcodec/wavpack.h
+++ b/mythtv/external/FFmpeg/libavcodec/wavpack.h
@@ -94,13 +94,13 @@ typedef struct Decorr {
 typedef struct WvChannel {
     int median[3];
     int slow_level, error_limit;
-    int bitrate_acc, bitrate_delta;
+    unsigned bitrate_acc, bitrate_delta;
 } WvChannel;
 
 // macros for manipulating median values
 #define GET_MED(n) ((c->median[n] >> 4) + 1)
-#define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> (n)) - 2) / (128 >> (n))) * 2
-#define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> (n))    ) / (128 >> (n))) * 5
+#define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> (n)) - 2) / (128 >> (n))) * 2U
+#define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> (n))    ) / (128 >> (n))) * 5U
 
 // macros for applying weight
 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
@@ -171,11 +171,13 @@ static av_always_inline int wp_exp2(int16_t val)
 
     res   = wp_exp2_table[val & 0xFF] | 0x100;
     val >>= 8;
+    if (val > 31U)
+        return INT_MIN;
     res   = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
     return neg ? -res : res;
 }
 
-static av_always_inline int wp_log2(int32_t val)
+static av_always_inline int wp_log2(uint32_t val)
 {
     int bits;
 
diff --git a/mythtv/external/FFmpeg/libavcodec/webp.c b/mythtv/external/FFmpeg/libavcodec/webp.c
index 45abfdc3ca2..efa864a6f14 100644
--- a/mythtv/external/FFmpeg/libavcodec/webp.c
+++ b/mythtv/external/FFmpeg/libavcodec/webp.c
@@ -33,10 +33,10 @@
  *
  * @author James Almer <jamrial@gmail.com>
  * Exif metadata
+ * ICC profile
  *
  * Unimplemented:
  *   - Animation
- *   - ICC profile
  *   - XMP metadata
  */
 
@@ -197,6 +197,7 @@ typedef struct WebPContext {
     uint8_t *alpha_data;                /* alpha chunk data */
     int alpha_data_size;                /* alpha chunk data size */
     int has_exif;                       /* set after an EXIF chunk has been processed */
+    int has_iccp;                       /* set after an ICCP chunk has been processed */
     int width;                          /* image width */
     int height;                         /* image height */
     int lossless;                       /* indicates lossless or lossy */
@@ -694,7 +695,7 @@ static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role,
                 length = offset + get_bits(&s->gb, extra_bits) + 1;
             }
             prefix_code = huff_reader_get_symbol(&hg[HUFF_IDX_DIST], &s->gb);
-            if (prefix_code > 39) {
+            if (prefix_code > 39U) {
                 av_log(s->avctx, AV_LOG_ERROR,
                        "distance prefix code too large: %d\n", prefix_code);
                 return AVERROR_INVALIDDATA;
@@ -1043,7 +1044,7 @@ static int apply_color_indexing_transform(WebPContext *s)
         uint8_t *line;
         int pixel_bits = 8 >> pal->size_reduction;
 
-        line = av_malloc(img->frame->linesize[0]);
+        line = av_malloc(img->frame->linesize[0] + AV_INPUT_BUFFER_PADDING_SIZE);
         if (!line)
             return AVERROR(ENOMEM);
 
@@ -1099,6 +1100,21 @@ static int apply_color_indexing_transform(WebPContext *s)
     return 0;
 }
 
+static void update_canvas_size(AVCodecContext *avctx, int w, int h)
+{
+    WebPContext *s = avctx->priv_data;
+    if (s->width && s->width != w) {
+        av_log(avctx, AV_LOG_WARNING, "Width mismatch. %d != %d\n",
+               s->width, w);
+    }
+    s->width = w;
+    if (s->height && s->height != h) {
+        av_log(avctx, AV_LOG_WARNING, "Height mismatch. %d != %d\n",
+               s->height, h);
+    }
+    s->height = h;
+}
+
 static int vp8_lossless_decode_frame(AVCodecContext *avctx, AVFrame *p,
                                      int *got_frame, uint8_t *data_start,
                                      unsigned int data_size, int is_alpha_chunk)
@@ -1123,16 +1139,8 @@ static int vp8_lossless_decode_frame(AVCodecContext *avctx, AVFrame *p,
 
         w = get_bits(&s->gb, 14) + 1;
         h = get_bits(&s->gb, 14) + 1;
-        if (s->width && s->width != w) {
-            av_log(avctx, AV_LOG_WARNING, "Width mismatch. %d != %d\n",
-                   s->width, w);
-        }
-        s->width = w;
-        if (s->height && s->height != h) {
-            av_log(avctx, AV_LOG_WARNING, "Height mismatch. %d != %d\n",
-                   s->width, w);
-        }
-        s->height = h;
+
+        update_canvas_size(avctx, w, h);
 
         ret = ff_set_dimensions(avctx, s->width, s->height);
         if (ret < 0)
@@ -1327,9 +1335,8 @@ static int vp8_lossy_decode_frame(AVCodecContext *avctx, AVFrame *p,
     if (!s->initialized) {
         ff_vp8_decode_init(avctx);
         s->initialized = 1;
-        if (s->has_alpha)
-            avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
     }
+    avctx->pix_fmt = s->has_alpha ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
     s->lossless = 0;
 
     if (data_size > INT_MAX) {
@@ -1342,6 +1349,14 @@ static int vp8_lossy_decode_frame(AVCodecContext *avctx, AVFrame *p,
     pkt.size = data_size;
 
     ret = ff_vp8_decode_frame(avctx, p, got_frame, &pkt);
+    if (ret < 0)
+        return ret;
+
+    if (!*got_frame)
+        return AVERROR_INVALIDDATA;
+
+    update_canvas_size(avctx, avctx->width, avctx->height);
+
     if (s->has_alpha) {
         ret = vp8_lossy_decode_alpha(avctx, p, s->alpha_data,
                                      s->alpha_data_size);
@@ -1367,6 +1382,7 @@ static int webp_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     *got_frame   = 0;
     s->has_alpha = 0;
     s->has_exif  = 0;
+    s->has_iccp  = 0;
     bytestream2_init(&gb, avpkt->data, avpkt->size);
 
     if (bytestream2_get_bytes_left(&gb) < 12)
@@ -1421,6 +1437,10 @@ static int webp_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
             bytestream2_skip(&gb, chunk_size);
             break;
         case MKTAG('V', 'P', '8', 'X'):
+            if (s->width || s->height || *got_frame) {
+                av_log(avctx, AV_LOG_ERROR, "Canvas dimensions are already set\n");
+                return AVERROR_INVALIDDATA;
+            }
             vp8x_flags = bytestream2_get_byte(&gb);
             bytestream2_skip(&gb, 3);
             s->width  = bytestream2_get_le24(&gb) + 1;
@@ -1489,14 +1509,34 @@ static int webp_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                 goto exif_end;
             }
 
-            av_dict_copy(avpriv_frame_get_metadatap(data), exif_metadata, 0);
+            av_dict_copy(&((AVFrame *) data)->metadata, exif_metadata, 0);
 
 exif_end:
             av_dict_free(&exif_metadata);
             bytestream2_skip(&gb, chunk_size);
             break;
         }
-        case MKTAG('I', 'C', 'C', 'P'):
+        case MKTAG('I', 'C', 'C', 'P'): {
+            AVFrameSideData *sd;
+
+            if (s->has_iccp) {
+                av_log(avctx, AV_LOG_VERBOSE, "Ignoring extra ICCP chunk\n");
+                bytestream2_skip(&gb, chunk_size);
+                break;
+            }
+            if (!(vp8x_flags & VP8X_FLAG_ICC))
+                av_log(avctx, AV_LOG_WARNING,
+                       "ICCP chunk present, but ICC Profile bit not set in the "
+                       "VP8X header\n");
+
+            s->has_iccp = 1;
+            sd = av_frame_new_side_data(p, AV_FRAME_DATA_ICC_PROFILE, chunk_size);
+            if (!sd)
+                return AVERROR(ENOMEM);
+
+            bytestream2_get_buffer(&gb, sd->data, chunk_size);
+            break;
+        }
         case MKTAG('A', 'N', 'I', 'M'):
         case MKTAG('A', 'N', 'M', 'F'):
         case MKTAG('X', 'M', 'P', ' '):
diff --git a/mythtv/external/FFmpeg/libavcodec/wma.c b/mythtv/external/FFmpeg/libavcodec/wma.c
index bc8e2d19242..b4992095ecd 100644
--- a/mythtv/external/FFmpeg/libavcodec/wma.c
+++ b/mythtv/external/FFmpeg/libavcodec/wma.c
@@ -186,7 +186,7 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
     }
     ff_dlog(s->avctx, "flags2=0x%x\n", flags2);
     ff_dlog(s->avctx, "version=%d channels=%d sample_rate=%d bitrate=%"PRId64" block_align=%d\n",
-            s->version, avctx->channels, avctx->sample_rate, (int64_t)avctx->bit_rate,
+            s->version, avctx->channels, avctx->sample_rate, avctx->bit_rate,
             avctx->block_align);
     ff_dlog(s->avctx, "bps=%f bps1=%f high_freq=%f bitoffset=%d\n",
             bps, bps1, high_freq, s->byte_offset_bits);
@@ -279,16 +279,6 @@ av_cold int ff_wma_init(AVCodecContext *avctx, int flags2)
                     s->exponent_high_bands[k][j++] = end - start;
             }
             s->exponent_high_sizes[k] = j;
-#if 0
-            ff_tlog(s->avctx, "%5d: coefs_end=%d high_band_start=%d nb_high_bands=%d: ",
-                    s->frame_len >> k,
-                    s->coefs_end[k],
-                    s->high_band_start[k],
-                    s->exponent_high_sizes[k]);
-            for (j = 0; j < s->exponent_high_sizes[k]; j++)
-                ff_tlog(s->avctx, " %d", s->exponent_high_bands[k][j]);
-            ff_tlog(s->avctx, "\n");
-#endif /* 0 */
         }
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/wmaenc.c b/mythtv/external/FFmpeg/libavcodec/wmaenc.c
index c68babd5493..091bc2ac3b9 100644
--- a/mythtv/external/FFmpeg/libavcodec/wmaenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/wmaenc.c
@@ -53,7 +53,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
     if (avctx->bit_rate < 24 * 1000) {
         av_log(avctx, AV_LOG_ERROR,
                "bitrate too low: got %"PRId64", need 24000 or higher\n",
-               (int64_t)avctx->bit_rate);
+               avctx->bit_rate);
         return AVERROR(EINVAL);
     }
 
diff --git a/mythtv/external/FFmpeg/libavcodec/wmalosslessdec.c b/mythtv/external/FFmpeg/libavcodec/wmalosslessdec.c
index 7eb7b4cd30c..133a3e92d1a 100644
--- a/mythtv/external/FFmpeg/libavcodec/wmalosslessdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/wmalosslessdec.c
@@ -205,7 +205,6 @@ static av_cold int decode_init(AVCodecContext *avctx)
         if (s->bits_per_sample == 16)
             avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
         else if (s->bits_per_sample == 24) {
-            av_log(avctx, AV_LOG_WARNING, "Decoding audio at 24 bit-depth\n");
             avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
             avctx->bits_per_raw_sample = 24;
         } else {
diff --git a/mythtv/external/FFmpeg/libavcodec/wmaprodec.c b/mythtv/external/FFmpeg/libavcodec/wmaprodec.c
index 2cc1b093fbf..77a49c9db8c 100644
--- a/mythtv/external/FFmpeg/libavcodec/wmaprodec.c
+++ b/mythtv/external/FFmpeg/libavcodec/wmaprodec.c
@@ -106,6 +106,9 @@
 #define MAX_SUBFRAMES  32                                    ///< max number of subframes per channel
 #define MAX_BANDS      29                                    ///< max number of scale factor bands
 #define MAX_FRAMESIZE  32768                                 ///< maximum compressed frame size
+#define XMA_MAX_STREAMS         8
+#define XMA_MAX_CHANNELS        8
+#define XMA_MAX_CHANNELS_STREAM 2
 
 #define WMAPRO_BLOCK_MIN_BITS  6                                           ///< log2 of min block size
 #define WMAPRO_BLOCK_MAX_BITS 13                                           ///< log2 of max block size
@@ -207,19 +210,19 @@ typedef struct WMAProDecodeCtx {
     int              subframe_offset;               ///< subframe offset in the bit reservoir
     uint8_t          packet_loss;                   ///< set in case of bitstream error
     uint8_t          packet_done;                   ///< set when a packet is fully decoded
-    uint8_t          skip_packets;
 
     /* frame decode state */
     uint32_t         frame_num;                     ///< current frame number (not used for decoding)
-    int              num_frames;
     GetBitContext    gb;                            ///< bitstream reader context
     int              buf_bit_size;                  ///< buffer size in bits
     uint8_t          drc_gain;                      ///< gain for the DRC tool
     int8_t           skip_frame;                    ///< skip output step
     int8_t           parsed_all_subframes;          ///< all subframes decoded?
+    uint8_t          skip_packets;                  ///< packets to skip to find next packet in a stream (XMA1/2)
 
     /* subframe/block decode state */
     int16_t          subframe_len;                  ///< current subframe length
+    int8_t           nb_channels;                   ///< number of channels in stream (XMA1/2)
     int8_t           channels_for_cur_subframe;     ///< number of channels that contain the subframe
     int8_t           channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS];
     int8_t           num_bands;                     ///< number of scale factor bands
@@ -234,6 +237,15 @@ typedef struct WMAProDecodeCtx {
     WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS];  ///< per channel data
 } WMAProDecodeCtx;
 
+typedef struct XMADecodeCtx {
+    WMAProDecodeCtx xma[XMA_MAX_STREAMS];
+    AVFrame *frames[XMA_MAX_STREAMS];
+    int current_stream;
+    int num_streams;
+    float samples[XMA_MAX_CHANNELS][512 * 64];
+    int offset[XMA_MAX_STREAMS];
+    int start_channel[XMA_MAX_STREAMS];
+} XMADecodeCtx;
 
 /**
  *@brief helper function to print the most important members of the context
@@ -250,7 +262,7 @@ static av_cold void dump_context(WMAProDecodeCtx *s)
     PRINT("log2 frame size",     s->log2_frame_size);
     PRINT("max num subframes",   s->max_num_subframes);
     PRINT("len prefix",          s->len_prefix);
-    PRINT("num channels",        s->avctx->channels);
+    PRINT("num channels",        s->nb_channels);
 }
 
 /**
@@ -258,9 +270,8 @@ static av_cold void dump_context(WMAProDecodeCtx *s)
  *@param avctx codec context
  *@return 0 on success, < 0 otherwise
  */
-static av_cold int decode_end(AVCodecContext *avctx)
+static av_cold int decode_end(WMAProDecodeCtx *s)
 {
-    WMAProDecodeCtx *s = avctx->priv_data;
     int i;
 
     av_freep(&s->fdsp);
@@ -271,6 +282,15 @@ static av_cold int decode_end(AVCodecContext *avctx)
     return 0;
 }
 
+static av_cold int wmapro_decode_end(AVCodecContext *avctx)
+{
+    WMAProDecodeCtx *s = avctx->priv_data;
+
+    decode_end(s);
+
+    return 0;
+}
+
 static av_cold int get_rate(AVCodecContext *avctx)
 {
     if (avctx->codec_id != AV_CODEC_ID_WMAPRO) { // XXX: is this really only for XMA?
@@ -291,9 +311,8 @@ static av_cold int get_rate(AVCodecContext *avctx)
  *@param avctx codec context
  *@return 0 on success, -1 otherwise
  */
-static av_cold int decode_init(AVCodecContext *avctx)
+static av_cold int decode_init(WMAProDecodeCtx *s, AVCodecContext *avctx, int num_stream)
 {
-    WMAProDecodeCtx *s = avctx->priv_data;
     uint8_t *edata_ptr = avctx->extradata;
     unsigned int channel_mask;
     int i, bits;
@@ -309,57 +328,50 @@ static av_cold int decode_init(AVCodecContext *avctx)
     }
 
     s->avctx = avctx;
-    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
-    if (!s->fdsp)
-        return AVERROR(ENOMEM);
 
     init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
 
     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
 
-    if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size >= 34) {
+    /** dump the extradata */
+    av_log(avctx, AV_LOG_DEBUG, "extradata:\n");
+    for (i = 0; i < avctx->extradata_size; i++)
+        av_log(avctx, AV_LOG_DEBUG, "[%x] ", avctx->extradata[i]);
+    av_log(avctx, AV_LOG_DEBUG, "\n");
+
+    if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size == 34) { /* XMA2WAVEFORMATEX */
         s->decode_flags    = 0x10d6;
-        channel_mask       = AV_RL32(edata_ptr+2);
         s->bits_per_sample = 16;
-        /** dump the extradata */
-        for (i = 0; i < avctx->extradata_size; i++)
-            ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
-        ff_dlog(avctx, "\n");
-
-     } else if (avctx->codec_id == AV_CODEC_ID_XMA1 && avctx->extradata_size >= 28) {
+        channel_mask       = 0; //AV_RL32(edata_ptr+2); /* not always in expected order */
+        if ((num_stream+1) * XMA_MAX_CHANNELS_STREAM > avctx->channels) /* stream config is 2ch + 2ch + ... + 1/2ch */
+            s->nb_channels = 1;
+        else
+            s->nb_channels = 2;
+    } else if (avctx->codec_id == AV_CODEC_ID_XMA2) { /* XMA2WAVEFORMAT */
         s->decode_flags    = 0x10d6;
         s->bits_per_sample = 16;
-        channel_mask       = 0;
-        /** dump the extradata */
-        for (i = 0; i < avctx->extradata_size; i++)
-            ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
-        ff_dlog(avctx, "\n");
-
-     } else if (avctx->extradata_size >= 18) {
+        channel_mask       = 0; /* would need to aggregate from all streams */
+        s->nb_channels = edata_ptr[32 + ((edata_ptr[0]==3)?0:8) + 4*num_stream + 0]; /* nth stream config */
+    } else if (avctx->codec_id == AV_CODEC_ID_XMA1) { /* XMAWAVEFORMAT */
+        s->decode_flags    = 0x10d6;
+        s->bits_per_sample = 16;
+        channel_mask       = 0; /* would need to aggregate from all streams */
+        s->nb_channels     = edata_ptr[8 + 20*num_stream + 17]; /* nth stream config */
+    } else if (avctx->codec_id == AV_CODEC_ID_WMAPRO && avctx->extradata_size >= 18) {
         s->decode_flags    = AV_RL16(edata_ptr+14);
         channel_mask       = AV_RL32(edata_ptr+2);
         s->bits_per_sample = AV_RL16(edata_ptr);
+        s->nb_channels     = avctx->channels;
 
         if (s->bits_per_sample > 32 || s->bits_per_sample < 1) {
             avpriv_request_sample(avctx, "bits per sample is %d", s->bits_per_sample);
             return AVERROR_PATCHWELCOME;
         }
-
-        /** dump the extradata */
-        for (i = 0; i < avctx->extradata_size; i++)
-            ff_dlog(avctx, "[%x] ", avctx->extradata[i]);
-        ff_dlog(avctx, "\n");
-
     } else {
         avpriv_request_sample(avctx, "Unknown extradata size");
         return AVERROR_PATCHWELCOME;
     }
 
-    if (avctx->codec_id != AV_CODEC_ID_WMAPRO && avctx->channels > 2) {
-        avpriv_report_missing_feature(avctx, ">2 channels support");
-        return AVERROR_PATCHWELCOME;
-    }
-
     /** generic init */
     s->log2_frame_size = av_log2(avctx->block_align) + 4;
     if (s->log2_frame_size > 25) {
@@ -416,18 +428,22 @@ static av_cold int decode_init(AVCodecContext *avctx)
         return AVERROR_INVALIDDATA;
     }
 
-    if (avctx->channels < 0) {
+    if (s->nb_channels <= 0) {
         av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n",
-               avctx->channels);
+               s->nb_channels);
         return AVERROR_INVALIDDATA;
-    } else if (avctx->channels > WMAPRO_MAX_CHANNELS) {
+    } else if (avctx->codec_id != AV_CODEC_ID_WMAPRO && s->nb_channels > XMA_MAX_CHANNELS_STREAM) {
+        av_log(avctx, AV_LOG_ERROR, "invalid number of channels per XMA stream %d\n",
+               s->nb_channels);
+        return AVERROR_INVALIDDATA;
+    } else if (s->nb_channels > WMAPRO_MAX_CHANNELS) {
         avpriv_request_sample(avctx,
                               "More than %d channels", WMAPRO_MAX_CHANNELS);
         return AVERROR_PATCHWELCOME;
     }
 
     /** init previous block len */
-    for (i = 0; i < avctx->channels; i++)
+    for (i = 0; i < s->nb_channels; i++)
         s->channel[i].prev_block_len = s->samples_per_frame;
 
     /** extract lfe channel position */
@@ -519,6 +535,10 @@ static av_cold int decode_init(AVCodecContext *avctx)
         }
     }
 
+    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
+    if (!s->fdsp)
+        return AVERROR(ENOMEM);
+
     /** init MDCT, FIXME: only init needed sizes */
     for (i = 0; i < WMAPRO_BLOCK_SIZES; i++)
         ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1,
@@ -552,6 +572,18 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
+/**
+ *@brief Initialize the decoder.
+ *@param avctx codec context
+ *@return 0 on success, -1 otherwise
+ */
+static av_cold int wmapro_decode_init(AVCodecContext *avctx)
+{
+    WMAProDecodeCtx *s = avctx->priv_data;
+
+    return decode_init(s, avctx, 0);
+}
+
 /**
  *@brief Decode the subframe length.
  *@param s context
@@ -613,7 +645,7 @@ static int decode_tilehdr(WMAProDecodeCtx *s)
 {
     uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */
     uint8_t  contains_subframe[WMAPRO_MAX_CHANNELS];  /**< flag indicating if a channel contains the current subframe */
-    int channels_for_cur_subframe = s->avctx->channels; /**< number of channels that contain the current subframe */
+    int channels_for_cur_subframe = s->nb_channels;   /**< number of channels that contain the current subframe */
     int fixed_channel_layout = 0;                     /**< flag indicating that all channels use the same subframe offsets and sizes */
     int min_channel_len = 0;                          /**< smallest sum of samples (channels with this length will be processed first) */
     int c;
@@ -625,7 +657,7 @@ static int decode_tilehdr(WMAProDecodeCtx *s)
      */
 
     /** reset tiling information */
-    for (c = 0; c < s->avctx->channels; c++)
+    for (c = 0; c < s->nb_channels; c++)
         s->channel[c].num_subframes = 0;
 
     if (s->max_num_subframes == 1 || get_bits1(&s->gb))
@@ -636,7 +668,7 @@ static int decode_tilehdr(WMAProDecodeCtx *s)
         int subframe_len;
 
         /** check which channels contain the subframe */
-        for (c = 0; c < s->avctx->channels; c++) {
+        for (c = 0; c < s->nb_channels; c++) {
             if (num_samples[c] == min_channel_len) {
                 if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
                    (min_channel_len == s->samples_per_frame - s->min_samples_per_subframe))
@@ -653,7 +685,7 @@ static int decode_tilehdr(WMAProDecodeCtx *s)
 
         /** add subframes to the individual channels and find new min_channel_len */
         min_channel_len += subframe_len;
-        for (c = 0; c < s->avctx->channels; c++) {
+        for (c = 0; c < s->nb_channels; c++) {
             WMAProChannelCtx* chan = &s->channel[c];
 
             if (contains_subframe[c]) {
@@ -680,11 +712,11 @@ static int decode_tilehdr(WMAProDecodeCtx *s)
         }
     } while (min_channel_len < s->samples_per_frame);
 
-    for (c = 0; c < s->avctx->channels; c++) {
+    for (c = 0; c < s->nb_channels; c++) {
         int i;
         int offset = 0;
         for (i = 0; i < s->channel[c].num_subframes; i++) {
-            ff_dlog(s->avctx, "frame[%i] channel[%i] subframe[%i]"
+            ff_dlog(s->avctx, "frame[%"PRIu32"] channel[%i] subframe[%i]"
                     " len %i\n", s->frame_num, c, i,
                     s->channel[c].subframe_len[i]);
             s->channel[c].subframe_offset[i] = offset;
@@ -706,8 +738,8 @@ static void decode_decorrelation_matrix(WMAProDecodeCtx *s,
     int i;
     int offset = 0;
     int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS];
-    memset(chgroup->decorrelation_matrix, 0, s->avctx->channels *
-           s->avctx->channels * sizeof(*chgroup->decorrelation_matrix));
+    memset(chgroup->decorrelation_matrix, 0, s->nb_channels *
+           s->nb_channels * sizeof(*chgroup->decorrelation_matrix));
 
     for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++)
         rotation_offset[i] = get_bits(&s->gb, 6);
@@ -760,7 +792,7 @@ static int decode_channel_transform(WMAProDecodeCtx* s)
 
     /** in the one channel case channel transforms are pointless */
     s->num_chgroups = 0;
-    if (s->avctx->channels > 1) {
+    if (s->nb_channels > 1) {
         int remaining_channels = s->channels_for_cur_subframe;
 
         if (get_bits1(&s->gb)) {
@@ -807,7 +839,7 @@ static int decode_channel_transform(WMAProDecodeCtx* s)
                     }
                 } else {
                     chgroup->transform = 1;
-                    if (s->avctx->channels == 2) {
+                    if (s->nb_channels == 2) {
                         chgroup->decorrelation_matrix[0] =  1.0;
                         chgroup->decorrelation_matrix[1] = -1.0;
                         chgroup->decorrelation_matrix[2] =  1.0;
@@ -1097,7 +1129,7 @@ static void inverse_channel_transform(WMAProDecodeCtx *s)
                             (*ch)[y] = sum;
                         }
                     }
-                } else if (s->avctx->channels == 2) {
+                } else if (s->nb_channels == 2) {
                     int len = FFMIN(sfb[1], s->subframe_len) - sfb[0];
                     s->fdsp->vector_fmul_scalar(ch_data[0] + sfb[0],
                                                ch_data[0] + sfb[0],
@@ -1150,7 +1182,7 @@ static int decode_subframe(WMAProDecodeCtx *s)
     int offset = s->samples_per_frame;
     int subframe_len = s->samples_per_frame;
     int i;
-    int total_samples   = s->samples_per_frame * s->avctx->channels;
+    int total_samples   = s->samples_per_frame * s->nb_channels;
     int transmit_coeffs = 0;
     int cur_subwoofer_cutoff;
 
@@ -1160,7 +1192,7 @@ static int decode_subframe(WMAProDecodeCtx *s)
         == the next block of the channel with the smallest number of
         decoded samples
     */
-    for (i = 0; i < s->avctx->channels; i++) {
+    for (i = 0; i < s->nb_channels; i++) {
         s->channel[i].grouped = 0;
         if (offset > s->channel[i].decoded_samples) {
             offset = s->channel[i].decoded_samples;
@@ -1174,7 +1206,7 @@ static int decode_subframe(WMAProDecodeCtx *s)
 
     /** get a list of all channels that contain the estimated block */
     s->channels_for_cur_subframe = 0;
-    for (i = 0; i < s->avctx->channels; i++) {
+    for (i = 0; i < s->nb_channels; i++) {
         const int cur_subframe = s->channel[i].cur_subframe;
         /** subtract already processed samples */
         total_samples -= s->channel[i].decoded_samples;
@@ -1387,11 +1419,10 @@ static int decode_subframe(WMAProDecodeCtx *s)
  */
 static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
 {
-    AVCodecContext *avctx = s->avctx;
     GetBitContext* gb = &s->gb;
     int more_frames = 0;
     int len = 0;
-    int i, ret;
+    int i;
 
     /** get frame length */
     if (s->len_prefix)
@@ -1406,9 +1437,9 @@ static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
     }
 
     /** read postproc transform */
-    if (s->avctx->channels > 1 && get_bits1(gb)) {
+    if (s->nb_channels > 1 && get_bits1(gb)) {
         if (get_bits1(gb)) {
-            for (i = 0; i < avctx->channels * avctx->channels; i++)
+            for (i = 0; i < s->nb_channels * s->nb_channels; i++)
                 skip_bits(gb, 4);
         }
     }
@@ -1443,7 +1474,7 @@ static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
 
     /** reset subframe states */
     s->parsed_all_subframes = 0;
-    for (i = 0; i < avctx->channels; i++) {
+    for (i = 0; i < s->nb_channels; i++) {
         s->channel[i].decoded_samples = 0;
         s->channel[i].cur_subframe    = 0;
         s->channel[i].reuse_sf        = 0;
@@ -1457,19 +1488,12 @@ static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr)
         }
     }
 
-    /* get output buffer */
-    frame->nb_samples = s->samples_per_frame;
-    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
-        s->packet_loss = 1;
-        return 0;
-    }
-
     /** copy samples to the output buffer */
-    for (i = 0; i < avctx->channels; i++)
+    for (i = 0; i < s->nb_channels; i++)
         memcpy(frame->extended_data[i], s->channel[i].out,
                s->samples_per_frame * sizeof(*s->channel[i].out));
 
-    for (i = 0; i < avctx->channels; i++) {
+    for (i = 0; i < s->nb_channels; i++) {
         /** reuse second half of the IMDCT output for the next frame */
         memcpy(&s->channel[i].out[0],
                &s->channel[i].out[s->samples_per_frame],
@@ -1574,17 +1598,9 @@ static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
     skip_bits(&s->gb, s->frame_offset);
 }
 
-/**
- *@brief Decode a single WMA packet.
- *@param avctx codec context
- *@param data the output buffer
- *@param avpkt input packet
- *@return number of bytes that were read from the input buffer
- */
-static int decode_packet(AVCodecContext *avctx, void *data,
-                         int *got_frame_ptr, AVPacket* avpkt)
+static int decode_packet(AVCodecContext *avctx, WMAProDecodeCtx *s,
+                         void *data, int *got_frame_ptr, AVPacket *avpkt)
 {
-    WMAProDecodeCtx *s = avctx->priv_data;
     GetBitContext* gb  = &s->pgb;
     const uint8_t* buf = avpkt->data;
     int buf_size       = avpkt->size;
@@ -1593,11 +1609,6 @@ static int decode_packet(AVCodecContext *avctx, void *data,
 
     *got_frame_ptr = 0;
 
-    if (s->skip_packets > 0) {
-        s->skip_packets--;
-        return FFMIN(avpkt->size, avctx->block_align);
-    }
-
     if (s->packet_done || s->packet_loss) {
         s->packet_done = 0;
 
@@ -1623,7 +1634,8 @@ static int decode_packet(AVCodecContext *avctx, void *data,
             packet_sequence_number = get_bits(gb, 4);
             skip_bits(gb, 2);
         } else {
-            s->num_frames = get_bits(gb, 6);
+            int num_frames = get_bits(gb, 6);
+            ff_dlog(avctx, "packet[%d]: number of frames %d\n", avctx->frame_number, num_frames);
             packet_sequence_number = 0;
         }
 
@@ -1632,13 +1644,14 @@ static int decode_packet(AVCodecContext *avctx, void *data,
         if (avctx->codec_id != AV_CODEC_ID_WMAPRO) {
             skip_bits(gb, 3);
             s->skip_packets = get_bits(gb, 8);
+            ff_dlog(avctx, "packet[%d]: skip packets %d\n", avctx->frame_number, s->skip_packets);
         }
 
         ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
                 num_bits_prev_frame);
 
         /** check for packet loss */
-        if (avctx->codec_id != AV_CODEC_ID_XMA2 && !s->packet_loss &&
+        if (avctx->codec_id == AV_CODEC_ID_WMAPRO && !s->packet_loss &&
             ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
             s->packet_loss = 1;
             av_log(avctx, AV_LOG_ERROR,
@@ -1675,7 +1688,6 @@ static int decode_packet(AVCodecContext *avctx, void *data,
             s->num_saved_bits = 0;
             s->packet_loss = 0;
         }
-
     } else {
         int frame_size;
         s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3;
@@ -1697,8 +1709,9 @@ static int decode_packet(AVCodecContext *avctx, void *data,
                 the "previous frame" data from the next packet so that
                 we get a buffer that only contains full frames */
             s->packet_done = !decode_frame(s, data, got_frame_ptr);
-        } else
+        } else {
             s->packet_done = 1;
+        }
     }
 
     if (remaining_bits(s, gb) < 0) {
@@ -1721,19 +1734,218 @@ static int decode_packet(AVCodecContext *avctx, void *data,
 }
 
 /**
- *@brief Clear decoder buffers (for seeking).
+ *@brief Decode a single WMA packet.
  *@param avctx codec context
+ *@param data the output buffer
+ *@param avpkt input packet
+ *@return number of bytes that were read from the input buffer
  */
-static void flush(AVCodecContext *avctx)
+static int wmapro_decode_packet(AVCodecContext *avctx, void *data,
+                                int *got_frame_ptr, AVPacket *avpkt)
 {
     WMAProDecodeCtx *s = avctx->priv_data;
+    AVFrame *frame = data;
+    int ret;
+
+    /* get output buffer */
+    frame->nb_samples = s->samples_per_frame;
+    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
+        s->packet_loss = 1;
+        return 0;
+    }
+
+    return decode_packet(avctx, s, data, got_frame_ptr, avpkt);
+}
+
+static int xma_decode_packet(AVCodecContext *avctx, void *data,
+                             int *got_frame_ptr, AVPacket *avpkt)
+{
+    XMADecodeCtx *s = avctx->priv_data;
+    int got_stream_frame_ptr = 0;
+    AVFrame *frame = data;
+    int i, ret, offset = INT_MAX;
+
+    /* decode current stream packet */
+    ret = decode_packet(avctx, &s->xma[s->current_stream], s->frames[s->current_stream],
+                        &got_stream_frame_ptr, avpkt);
+
+    /* copy stream samples (1/2ch) to sample buffer (Nch) */
+    if (got_stream_frame_ptr) {
+        int start_ch = s->start_channel[s->current_stream];
+        memcpy(&s->samples[start_ch + 0][s->offset[s->current_stream] * 512],
+               s->frames[s->current_stream]->extended_data[0], 512 * 4);
+        if (s->xma[s->current_stream].nb_channels > 1)
+            memcpy(&s->samples[start_ch + 1][s->offset[s->current_stream] * 512],
+                   s->frames[s->current_stream]->extended_data[1], 512 * 4);
+        s->offset[s->current_stream]++;
+    } else if (ret < 0) {
+        memset(s->offset, 0, sizeof(s->offset));
+        s->current_stream = 0;
+        return ret;
+    }
+
+    /* find next XMA packet's owner stream, and update.
+     * XMA streams find their packets following packet_skips
+     * (at start there is one packet per stream, then interleave non-linearly). */
+    if (s->xma[s->current_stream].packet_done ||
+        s->xma[s->current_stream].packet_loss) {
+
+        /* select stream with 0 skip_packets (= uses next packet) */
+        if (s->xma[s->current_stream].skip_packets != 0) {
+            int min[2];
+
+            min[0] = s->xma[0].skip_packets;
+            min[1] = i = 0;
+
+            for (i = 1; i < s->num_streams; i++) {
+                if (s->xma[i].skip_packets < min[0]) {
+                    min[0] = s->xma[i].skip_packets;
+                    min[1] = i;
+                }
+            }
+
+            s->current_stream = min[1];
+        }
+
+        /* all other streams skip next packet */
+        for (i = 0; i < s->num_streams; i++) {
+            s->xma[i].skip_packets = FFMAX(0, s->xma[i].skip_packets - 1);
+        }
+
+        /* copy samples from buffer to output if possible */
+        for (i = 0; i < s->num_streams; i++) {
+            offset = FFMIN(offset, s->offset[i]);
+        }
+        if (offset > 0) {
+            int bret;
+
+            frame->nb_samples = 512 * offset;
+            if ((bret = ff_get_buffer(avctx, frame, 0)) < 0)
+                return bret;
+
+            /* copy samples buffer (Nch) to frame samples (Nch), move unconsumed samples */
+            for (i = 0; i < s->num_streams; i++) {
+                int start_ch = s->start_channel[i];
+                memcpy(frame->extended_data[start_ch + 0], s->samples[start_ch + 0], frame->nb_samples * 4);
+                if (s->xma[i].nb_channels > 1)
+                    memcpy(frame->extended_data[start_ch + 1], s->samples[start_ch + 1], frame->nb_samples * 4);
+
+                s->offset[i] -= offset;
+                if (s->offset[i]) {
+                    memmove(s->samples[start_ch + 0], s->samples[start_ch + 0] + frame->nb_samples, s->offset[i] * 4 * 512);
+                    if (s->xma[i].nb_channels > 1)
+                        memmove(s->samples[start_ch + 1], s->samples[start_ch + 1] + frame->nb_samples, s->offset[i] * 4 * 512);
+                }
+            }
+
+            *got_frame_ptr = 1;
+        }
+    }
+
+    return ret;
+}
+
+static av_cold int xma_decode_init(AVCodecContext *avctx)
+{
+    XMADecodeCtx *s = avctx->priv_data;
+    int i, ret, start_channels = 0;
+
+    if (avctx->channels <= 0 || avctx->extradata_size == 0)
+        return AVERROR_INVALIDDATA;
+
+    /* get stream config */
+    if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size == 34) { /* XMA2WAVEFORMATEX */
+        s->num_streams = (avctx->channels + 1) / 2;
+    } else if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size >= 2) { /* XMA2WAVEFORMAT */
+        s->num_streams = avctx->extradata[1];
+        if (avctx->extradata_size != (32 + ((avctx->extradata[0]==3)?0:8) + 4*s->num_streams)) {
+            av_log(avctx, AV_LOG_ERROR, "Incorrect XMA2 extradata size\n");
+            return AVERROR(EINVAL);
+        }
+    } else if (avctx->codec_id == AV_CODEC_ID_XMA1 && avctx->extradata_size >= 4) { /* XMAWAVEFORMAT */
+        s->num_streams = avctx->extradata[4];
+        if (avctx->extradata_size != (8 + 20*s->num_streams)) {
+            av_log(avctx, AV_LOG_ERROR, "Incorrect XMA1 extradata size\n");
+            return AVERROR(EINVAL);
+        }
+    } else {
+        av_log(avctx, AV_LOG_ERROR, "Incorrect XMA config\n");
+        return AVERROR(EINVAL);
+    }
+
+    /* encoder supports up to 64 streams / 64*2 channels (would have to alloc arrays) */
+    if (avctx->channels > XMA_MAX_CHANNELS || s->num_streams > XMA_MAX_STREAMS) {
+        avpriv_request_sample(avctx, "More than %d channels in %d streams", XMA_MAX_CHANNELS, s->num_streams);
+        return AVERROR_PATCHWELCOME;
+    }
+
+    /* init all streams (several streams of 1/2ch make Nch files) */
+    for (i = 0; i < s->num_streams; i++) {
+        ret = decode_init(&s->xma[i], avctx, i);
+        if (ret < 0)
+            return ret;
+        s->frames[i] = av_frame_alloc();
+        if (!s->frames[i])
+            return AVERROR(ENOMEM);
+        s->frames[i]->nb_samples = 512;
+        if ((ret = ff_get_buffer(avctx, s->frames[i], 0)) < 0) {
+            return AVERROR(ENOMEM);
+        }
+
+        s->start_channel[i] = start_channels;
+        start_channels += s->xma[i].nb_channels;
+    }
+
+    return ret;
+}
+
+static av_cold int xma_decode_end(AVCodecContext *avctx)
+{
+    XMADecodeCtx *s = avctx->priv_data;
+    int i;
+
+    for (i = 0; i < s->num_streams; i++) {
+        decode_end(&s->xma[i]);
+        av_frame_free(&s->frames[i]);
+    }
+
+    return 0;
+}
+
+static void flush(WMAProDecodeCtx *s)
+{
     int i;
     /** reset output buffer as a part of it is used during the windowing of a
         new frame */
-    for (i = 0; i < avctx->channels; i++)
+    for (i = 0; i < s->nb_channels; i++)
         memset(s->channel[i].out, 0, s->samples_per_frame *
                sizeof(*s->channel[i].out));
     s->packet_loss = 1;
+    s->skip_packets = 0;
+}
+
+
+/**
+ *@brief Clear decoder buffers (for seeking).
+ *@param avctx codec context
+ */
+static void wmapro_flush(AVCodecContext *avctx)
+{
+    WMAProDecodeCtx *s = avctx->priv_data;
+
+    flush(s);
+}
+
+static void xma_flush(AVCodecContext *avctx)
+{
+    XMADecodeCtx *s = avctx->priv_data;
+    int i;
+
+    for (i = 0; i < s->num_streams; i++)
+        flush(&s->xma[i]);
+
+    memset(s->offset, 0, sizeof(s->offset));
+    s->current_stream = 0;
 }
 
 
@@ -1746,11 +1958,11 @@ AVCodec ff_wmapro_decoder = {
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = AV_CODEC_ID_WMAPRO,
     .priv_data_size = sizeof(WMAProDecodeCtx),
-    .init           = decode_init,
-    .close          = decode_end,
-    .decode         = decode_packet,
+    .init           = wmapro_decode_init,
+    .close          = wmapro_decode_end,
+    .decode         = wmapro_decode_packet,
     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
-    .flush          = flush,
+    .flush          = wmapro_flush,
     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
                                                       AV_SAMPLE_FMT_NONE },
 };
@@ -1760,12 +1972,11 @@ AVCodec ff_xma1_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("Xbox Media Audio 1"),
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = AV_CODEC_ID_XMA1,
-    .priv_data_size = sizeof(WMAProDecodeCtx),
-    .init           = decode_init,
-    .close          = decode_end,
-    .decode         = decode_packet,
+    .priv_data_size = sizeof(XMADecodeCtx),
+    .init           = xma_decode_init,
+    .close          = xma_decode_end,
+    .decode         = xma_decode_packet,
     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
-    .flush          = flush,
     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
                                                       AV_SAMPLE_FMT_NONE },
 };
@@ -1775,12 +1986,12 @@ AVCodec ff_xma2_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("Xbox Media Audio 2"),
     .type           = AVMEDIA_TYPE_AUDIO,
     .id             = AV_CODEC_ID_XMA2,
-    .priv_data_size = sizeof(WMAProDecodeCtx),
-    .init           = decode_init,
-    .close          = decode_end,
-    .decode         = decode_packet,
+    .priv_data_size = sizeof(XMADecodeCtx),
+    .init           = xma_decode_init,
+    .close          = xma_decode_end,
+    .decode         = xma_decode_packet,
+    .flush          = xma_flush,
     .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
-    .flush          = flush,
     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
                                                       AV_SAMPLE_FMT_NONE },
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/wmavoice.c b/mythtv/external/FFmpeg/libavcodec/wmavoice.c
index ceac61f6bd0..2ec4499981f 100644
--- a/mythtv/external/FFmpeg/libavcodec/wmavoice.c
+++ b/mythtv/external/FFmpeg/libavcodec/wmavoice.c
@@ -104,26 +104,24 @@ static const struct frame_type_desc {
     uint8_t dbl_pulses;   ///< how many pulse vectors have pulse pairs
                           ///< (rather than just one single pulse)
                           ///< only if #fcb_type == #FCB_TYPE_EXC_PULSES
-    uint16_t frame_size;  ///< the amount of bits that make up the block
-                          ///< data (per frame)
 } frame_descs[17] = {
-    { 1, 0, ACB_TYPE_NONE,       FCB_TYPE_SILENCE,    0,   0 },
-    { 2, 1, ACB_TYPE_NONE,       FCB_TYPE_HARDCODED,  0,  28 },
-    { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_AW_PULSES,  0,  46 },
-    { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 2,  80 },
-    { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 5, 104 },
-    { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 0, 108 },
-    { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 2, 132 },
-    { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 5, 168 },
-    { 2, 1, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 0,  64 },
-    { 2, 1, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 2,  80 },
-    { 2, 1, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 5, 104 },
-    { 4, 2, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 0, 108 },
-    { 4, 2, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 2, 132 },
-    { 4, 2, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 5, 168 },
-    { 8, 3, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 0, 176 },
-    { 8, 3, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 2, 208 },
-    { 8, 3, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 5, 256 }
+    { 1, 0, ACB_TYPE_NONE,       FCB_TYPE_SILENCE,    0 },
+    { 2, 1, ACB_TYPE_NONE,       FCB_TYPE_HARDCODED,  0 },
+    { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_AW_PULSES,  0 },
+    { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 2 },
+    { 2, 1, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 5 },
+    { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 0 },
+    { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 2 },
+    { 4, 2, ACB_TYPE_ASYMMETRIC, FCB_TYPE_EXC_PULSES, 5 },
+    { 2, 1, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 0 },
+    { 2, 1, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 2 },
+    { 2, 1, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 5 },
+    { 4, 2, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 0 },
+    { 4, 2, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 2 },
+    { 4, 2, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 5 },
+    { 8, 3, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 0 },
+    { 8, 3, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 2 },
+    { 8, 3, ACB_TYPE_HAMMING,    FCB_TYPE_EXC_PULSES, 5 }
 };
 
 /**
@@ -160,10 +158,6 @@ typedef struct WMAVoiceContext {
     int lsp_q_mode;               ///< defines quantizer defaults [0, 1]
     int lsp_def_mode;             ///< defines different sets of LSP defaults
                                   ///< [0, 1]
-    int frame_lsp_bitsize;        ///< size (in bits) of LSPs, when encoded
-                                  ///< per-frame (independent coding)
-    int sframe_lsp_bitsize;       ///< size (in bits) of LSPs, when encoded
-                                  ///< per superframe (residual coding)
 
     int min_pitch_val;            ///< base value for pitch parsing code
     int max_pitch_val;            ///< max value + 1 for pitch parsing
@@ -251,6 +245,7 @@ typedef struct WMAVoiceContext {
 
     int frame_cntr;               ///< current frame index [0 - 0xFFFE]; is
                                   ///< only used for comfort noise in #pRNG()
+    int nb_superframes;           ///< number of superframes in current packet
     float gain_pred_err[6];       ///< cache for gain prediction
     float excitation_history[MAX_SIGNAL_HISTORY];
                                   ///< cache of the signal of previous
@@ -337,6 +332,34 @@ static av_cold void wmavoice_init_static_data(AVCodec *codec)
                     bits, 1, 1, codes, 2, 2, 132);
 }
 
+static av_cold void wmavoice_flush(AVCodecContext *ctx)
+{
+    WMAVoiceContext *s = ctx->priv_data;
+    int n;
+
+    s->postfilter_agc    = 0;
+    s->sframe_cache_size = 0;
+    s->skip_bits_next    = 0;
+    for (n = 0; n < s->lsps; n++)
+        s->prev_lsps[n] = M_PI * (n + 1.0) / (s->lsps + 1.0);
+    memset(s->excitation_history, 0,
+           sizeof(*s->excitation_history) * MAX_SIGNAL_HISTORY);
+    memset(s->synth_history,      0,
+           sizeof(*s->synth_history)      * MAX_LSPS);
+    memset(s->gain_pred_err,      0,
+           sizeof(s->gain_pred_err));
+
+    if (s->do_apf) {
+        memset(&s->synth_filter_out_buf[MAX_LSPS_ALIGN16 - s->lsps], 0,
+               sizeof(*s->synth_filter_out_buf) * s->lsps);
+        memset(s->dcf_mem,              0,
+               sizeof(*s->dcf_mem)              * 2);
+        memset(s->zero_exc_pf,          0,
+               sizeof(*s->zero_exc_pf)          * s->history_nsamples);
+        memset(s->denoise_filter_cache, 0, sizeof(s->denoise_filter_cache));
+    }
+}
+
 /**
  * Set up decoder with parameters from demuxer (extradata etc.).
  */
@@ -359,6 +382,11 @@ static av_cold int wmavoice_decode_init(AVCodecContext *ctx)
                ctx->extradata_size);
         return AVERROR_INVALIDDATA;
     }
+    if (ctx->block_align <= 0) {
+        av_log(ctx, AV_LOG_ERROR, "Invalid block alignment %d.\n", ctx->block_align);
+        return AVERROR_INVALIDDATA;
+    }
+
     flags                = AV_RL32(ctx->extradata + 18);
     s->spillover_bitsize = 3 + av_ceil_log2(ctx->block_align);
     s->do_apf            =    flags & 0x1;
@@ -389,12 +417,8 @@ static av_cold int wmavoice_decode_init(AVCodecContext *ctx)
     lsp16_flag           =    flags & 0x1000;
     if (lsp16_flag) {
         s->lsps               = 16;
-        s->frame_lsp_bitsize  = 34;
-        s->sframe_lsp_bitsize = 60;
     } else {
         s->lsps               = 10;
-        s->frame_lsp_bitsize  = 24;
-        s->sframe_lsp_bitsize = 48;
     }
     for (n = 0; n < s->lsps; n++)
         s->prev_lsps[n] = M_PI * (n + 1.0) / (s->lsps + 1.0);
@@ -483,7 +507,8 @@ static void adaptive_gain_control(float *out, const float *in,
         speech_energy     += fabsf(speech_synth[i]);
         postfilter_energy += fabsf(in[i]);
     }
-    gain_scale_factor = (1.0 - alpha) * speech_energy / postfilter_energy;
+    gain_scale_factor = postfilter_energy == 0.0 ? 0.0 :
+                        (1.0 - alpha) * speech_energy / postfilter_energy;
 
     for (i = 0; i < size; i++) {
         mem = alpha * mem + gain_scale_factor;
@@ -847,7 +872,6 @@ static void dequant_lsps(double *lsps, int num,
 /**
  * @name LSP dequantization routines
  * LSP dequantization routines, for 10/16LSPs and independent/residual coding.
- * @note we assume enough bits are available, caller should check.
  * lsp10i() consumes 24 bits; lsp10r() consumes an additional 24 bits;
  * lsp16i() consumes 34 bits; lsp16r() consumes an additional 26 bits.
  * @{
@@ -1391,7 +1415,6 @@ static void synth_block_fcb_acb(WMAVoiceContext *s, GetBitContext *gb,
 
 /**
  * Parse data in a single block.
- * @note we assume enough bits are available, caller should check.
  *
  * @param s WMA Voice decoding context private data
  * @param gb bit I/O context
@@ -1435,7 +1458,6 @@ static void synth_block(WMAVoiceContext *s, GetBitContext *gb,
 
 /**
  * Synthesize output samples for a single frame.
- * @note we assume enough bits are available, caller should check.
  *
  * @param ctx WMA Voice decoder context
  * @param gb bit I/O context (s->gb or one for cross-packet superframes)
@@ -1653,83 +1675,6 @@ static void stabilize_lsps(double *lsps, int num)
     }
 }
 
-/**
- * Test if there's enough bits to read 1 superframe.
- *
- * @param orig_gb bit I/O context used for reading. This function
- *                does not modify the state of the bitreader; it
- *                only uses it to copy the current stream position
- * @param s WMA Voice decoding context private data
- * @return < 0 on error, 1 on not enough bits or 0 if OK.
- */
-static int check_bits_for_superframe(GetBitContext *orig_gb,
-                                     WMAVoiceContext *s)
-{
-    GetBitContext s_gb, *gb = &s_gb;
-    int n, need_bits, bd_idx;
-    const struct frame_type_desc *frame_desc;
-
-    /* initialize a copy */
-    init_get_bits(gb, orig_gb->buffer, orig_gb->size_in_bits);
-    skip_bits_long(gb, get_bits_count(orig_gb));
-    av_assert1(get_bits_left(gb) == get_bits_left(orig_gb));
-
-    /* superframe header */
-    if (get_bits_left(gb) < 14)
-        return 1;
-    if (!get_bits1(gb))
-        return AVERROR(ENOSYS);           // WMAPro-in-WMAVoice superframe
-    if (get_bits1(gb)) skip_bits(gb, 12); // number of  samples in superframe
-    if (s->has_residual_lsps) {           // residual LSPs (for all frames)
-        if (get_bits_left(gb) < s->sframe_lsp_bitsize)
-            return 1;
-        skip_bits_long(gb, s->sframe_lsp_bitsize);
-    }
-
-    /* frames */
-    for (n = 0; n < MAX_FRAMES; n++) {
-        int aw_idx_is_ext = 0;
-
-        if (!s->has_residual_lsps) {     // independent LSPs (per-frame)
-           if (get_bits_left(gb) < s->frame_lsp_bitsize) return 1;
-           skip_bits_long(gb, s->frame_lsp_bitsize);
-        }
-        bd_idx = s->vbm_tree[get_vlc2(gb, frame_type_vlc.table, 6, 3)];
-        if (bd_idx < 0)
-            return AVERROR_INVALIDDATA; // invalid frame type VLC code
-        frame_desc = &frame_descs[bd_idx];
-        if (frame_desc->acb_type == ACB_TYPE_ASYMMETRIC) {
-            if (get_bits_left(gb) < s->pitch_nbits)
-                return 1;
-            skip_bits_long(gb, s->pitch_nbits);
-        }
-        if (frame_desc->fcb_type == FCB_TYPE_SILENCE) {
-            skip_bits(gb, 8);
-        } else if (frame_desc->fcb_type == FCB_TYPE_AW_PULSES) {
-            int tmp = get_bits(gb, 6);
-            if (tmp >= 0x36) {
-                skip_bits(gb, 2);
-                aw_idx_is_ext = 1;
-            }
-        }
-
-        /* blocks */
-        if (frame_desc->acb_type == ACB_TYPE_HAMMING) {
-            need_bits = s->block_pitch_nbits +
-                (frame_desc->n_blocks - 1) * s->block_delta_pitch_nbits;
-        } else if (frame_desc->fcb_type == FCB_TYPE_AW_PULSES) {
-            need_bits = 2 * !aw_idx_is_ext;
-        } else
-            need_bits = 0;
-        need_bits += frame_desc->frame_size;
-        if (get_bits_left(gb) < need_bits)
-            return 1;
-        skip_bits_long(gb, need_bits);
-    }
-
-    return 0;
-}
-
 /**
  * Synthesize output samples for a single superframe. If we have any data
  * cached in s->sframe_cache, that will be used instead of whatever is loaded
@@ -1752,7 +1697,7 @@ static int synth_superframe(AVCodecContext *ctx, AVFrame *frame,
 {
     WMAVoiceContext *s = ctx->priv_data;
     GetBitContext *gb = &s->gb, s_gb;
-    int n, res, n_samples = 480;
+    int n, res, n_samples = MAX_SFRAMESIZE;
     double lsps[MAX_FRAMES][MAX_LSPS];
     const double *mean_lsf = s->lsps == 16 ?
         wmavoice_mean_lsf16[s->lsp_def_mode] : wmavoice_mean_lsf10[s->lsp_def_mode];
@@ -1771,12 +1716,6 @@ static int synth_superframe(AVCodecContext *ctx, AVFrame *frame,
         s->sframe_cache_size = 0;
     }
 
-    if ((res = check_bits_for_superframe(gb, s)) == 1) {
-        *got_frame_ptr = 0;
-        return 1;
-    } else if (res < 0)
-        return res;
-
     /* First bit is speech/music bit, it differentiates between WMAVoice
      * speech samples (the actual codec) and WMAVoice music samples, which
      * are really WMAPro-in-WMAVoice-superframes. I've never seen those in
@@ -1788,13 +1727,14 @@ static int synth_superframe(AVCodecContext *ctx, AVFrame *frame,
 
     /* (optional) nr. of samples in superframe; always <= 480 and >= 0 */
     if (get_bits1(gb)) {
-        if ((n_samples = get_bits(gb, 12)) > 480) {
+        if ((n_samples = get_bits(gb, 12)) > MAX_SFRAMESIZE) {
             av_log(ctx, AV_LOG_ERROR,
-                   "Superframe encodes >480 samples (%d), not allowed\n",
-                   n_samples);
+                   "Superframe encodes > %d samples (%d), not allowed\n",
+                   MAX_SFRAMESIZE, n_samples);
             return AVERROR_INVALIDDATA;
         }
     }
+
     /* Parse LSPs, if global for the superframe (can also be per-frame). */
     if (s->has_residual_lsps) {
         double prev_lsps[MAX_LSPS], a1[MAX_LSPS * 2], a2[MAX_LSPS * 2];
@@ -1817,7 +1757,7 @@ static int synth_superframe(AVCodecContext *ctx, AVFrame *frame,
     }
 
     /* get output buffer */
-    frame->nb_samples = 480;
+    frame->nb_samples = MAX_SFRAMESIZE;
     if ((res = ff_get_buffer(ctx, frame, 0)) < 0)
         return res;
     frame->nb_samples = n_samples;
@@ -1856,6 +1796,11 @@ static int synth_superframe(AVCodecContext *ctx, AVFrame *frame,
         skip_bits(gb, 10 * (res + 1));
     }
 
+    if (get_bits_left(gb) < 0) {
+        wmavoice_flush(ctx);
+        return AVERROR_INVALIDDATA;
+    }
+
     *got_frame_ptr = 1;
 
     /* Update history */
@@ -1877,26 +1822,23 @@ static int synth_superframe(AVCodecContext *ctx, AVFrame *frame,
  * decoder).
  *
  * @param s WMA Voice decoding context private data
- * @return 1 if not enough bits were available, or 0 on success.
+ * @return <0 on error, nb_superframes on success.
  */
 static int parse_packet_header(WMAVoiceContext *s)
 {
     GetBitContext *gb = &s->gb;
-    unsigned int res;
+    unsigned int res, n_superframes = 0;
 
-    if (get_bits_left(gb) < 11)
-        return 1;
     skip_bits(gb, 4);          // packet sequence number
     s->has_residual_lsps = get_bits1(gb);
     do {
         res = get_bits(gb, 6); // number of superframes per packet
                                // (minus first one if there is spillover)
-        if (get_bits_left(gb) < 6 * (res == 0x3F) + s->spillover_bitsize)
-            return 1;
+        n_superframes += res;
     } while (res == 0x3F);
     s->spillover_nbits   = get_bits(gb, s->spillover_bitsize);
 
-    return 0;
+    return get_bits_left(gb) >= 0 ? n_superframes : AVERROR_INVALIDDATA;
 }
 
 /**
@@ -1956,45 +1898,43 @@ static int wmavoice_decode_packet(AVCodecContext *ctx, void *data,
      * in a single "muxer" packet, so we artificially emulate that by
      * capping the packet size at ctx->block_align. */
     for (size = avpkt->size; size > ctx->block_align; size -= ctx->block_align);
-    if (!size) {
-        *got_frame_ptr = 0;
-        return 0;
-    }
     init_get_bits(&s->gb, avpkt->data, size << 3);
 
     /* size == ctx->block_align is used to indicate whether we are dealing with
      * a new packet or a packet of which we already read the packet header
      * previously. */
-    if (size == ctx->block_align) { // new packet header
-        if ((res = parse_packet_header(s)) < 0)
-            return res;
+    if (!(size % ctx->block_align)) { // new packet header
+        if (!size) {
+            s->spillover_nbits = 0;
+            s->nb_superframes = 0;
+        } else {
+            if ((res = parse_packet_header(s)) < 0)
+                return res;
+            s->nb_superframes = res;
+        }
 
         /* If the packet header specifies a s->spillover_nbits, then we want
          * to push out all data of the previous packet (+ spillover) before
          * continuing to parse new superframes in the current packet. */
-        if (s->spillover_nbits > 0) {
-            if (s->sframe_cache_size > 0) {
-                int cnt = get_bits_count(gb);
-                copy_bits(&s->pb, avpkt->data, size, gb, s->spillover_nbits);
-                flush_put_bits(&s->pb);
-                s->sframe_cache_size += s->spillover_nbits;
-                if ((res = synth_superframe(ctx, data, got_frame_ptr)) == 0 &&
-                    *got_frame_ptr) {
-                    cnt += s->spillover_nbits;
-                    s->skip_bits_next = cnt & 7;
-                    res = cnt >> 3;
-                    if (res > avpkt->size) {
-                        av_log(ctx, AV_LOG_ERROR,
-                               "Trying to skip %d bytes in packet of size %d\n",
-                               res, avpkt->size);
-                        return AVERROR_INVALIDDATA;
-                    }
-                    return res;
-                } else
-                    skip_bits_long (gb, s->spillover_nbits - cnt +
-                                    get_bits_count(gb)); // resync
+        if (s->sframe_cache_size > 0) {
+            int cnt = get_bits_count(gb);
+            if (cnt + s->spillover_nbits > avpkt->size * 8) {
+                s->spillover_nbits = avpkt->size * 8 - cnt;
+            }
+            copy_bits(&s->pb, avpkt->data, size, gb, s->spillover_nbits);
+            flush_put_bits(&s->pb);
+            s->sframe_cache_size += s->spillover_nbits;
+            if ((res = synth_superframe(ctx, data, got_frame_ptr)) == 0 &&
+                *got_frame_ptr) {
+                cnt += s->spillover_nbits;
+                s->skip_bits_next = cnt & 7;
+                res = cnt >> 3;
+                return res;
             } else
-                skip_bits_long(gb, s->spillover_nbits);  // resync
+                skip_bits_long (gb, s->spillover_nbits - cnt +
+                                get_bits_count(gb)); // resync
+        } else if (s->spillover_nbits) {
+            skip_bits_long(gb, s->spillover_nbits);  // resync
         }
     } else if (s->skip_bits_next)
         skip_bits(gb, s->skip_bits_next);
@@ -2003,26 +1943,20 @@ static int wmavoice_decode_packet(AVCodecContext *ctx, void *data,
     s->sframe_cache_size = 0;
     s->skip_bits_next = 0;
     pos = get_bits_left(gb);
-    if ((res = synth_superframe(ctx, data, got_frame_ptr)) < 0) {
-        return res;
-    } else if (*got_frame_ptr) {
-        int cnt = get_bits_count(gb);
-        s->skip_bits_next = cnt & 7;
-        res = cnt >> 3;
-        if (res > avpkt->size) {
-            av_log(ctx, AV_LOG_ERROR,
-                   "Trying to skip %d bytes in packet of size %d\n",
-                   res, avpkt->size);
-            return AVERROR_INVALIDDATA;
+    if (s->nb_superframes-- == 0) {
+        *got_frame_ptr = 0;
+        return size;
+    } else if (s->nb_superframes > 0) {
+        if ((res = synth_superframe(ctx, data, got_frame_ptr)) < 0) {
+            return res;
+        } else if (*got_frame_ptr) {
+            int cnt = get_bits_count(gb);
+            s->skip_bits_next = cnt & 7;
+            res = cnt >> 3;
+            return res;
         }
-        return res;
     } else if ((s->sframe_cache_size = pos) > 0) {
-        /* rewind bit reader to start of last (incomplete) superframe... */
-        init_get_bits(gb, avpkt->data, size << 3);
-        skip_bits_long(gb, (size << 3) - pos);
-        av_assert1(get_bits_left(gb) == pos);
-
-        /* ...and cache it for spillover in next packet */
+        /* ... cache it for spillover in next packet */
         init_put_bits(&s->pb, s->sframe_cache, SFRAME_CACHE_MAXSIZE);
         copy_bits(&s->pb, avpkt->data, size, gb, s->sframe_cache_size);
         // FIXME bad - just copy bytes as whole and add use the
@@ -2046,34 +1980,6 @@ static av_cold int wmavoice_decode_end(AVCodecContext *ctx)
     return 0;
 }
 
-static av_cold void wmavoice_flush(AVCodecContext *ctx)
-{
-    WMAVoiceContext *s = ctx->priv_data;
-    int n;
-
-    s->postfilter_agc    = 0;
-    s->sframe_cache_size = 0;
-    s->skip_bits_next    = 0;
-    for (n = 0; n < s->lsps; n++)
-        s->prev_lsps[n] = M_PI * (n + 1.0) / (s->lsps + 1.0);
-    memset(s->excitation_history, 0,
-           sizeof(*s->excitation_history) * MAX_SIGNAL_HISTORY);
-    memset(s->synth_history,      0,
-           sizeof(*s->synth_history)      * MAX_LSPS);
-    memset(s->gain_pred_err,      0,
-           sizeof(s->gain_pred_err));
-
-    if (s->do_apf) {
-        memset(&s->synth_filter_out_buf[MAX_LSPS_ALIGN16 - s->lsps], 0,
-               sizeof(*s->synth_filter_out_buf) * s->lsps);
-        memset(s->dcf_mem,              0,
-               sizeof(*s->dcf_mem)              * 2);
-        memset(s->zero_exc_pf,          0,
-               sizeof(*s->zero_exc_pf)          * s->history_nsamples);
-        memset(s->denoise_filter_cache, 0, sizeof(s->denoise_filter_cache));
-    }
-}
-
 AVCodec ff_wmavoice_decoder = {
     .name             = "wmavoice",
     .long_name        = NULL_IF_CONFIG_SMALL("Windows Media Audio Voice"),
@@ -2084,6 +1990,6 @@ AVCodec ff_wmavoice_decoder = {
     .init_static_data = wmavoice_init_static_data,
     .close            = wmavoice_decode_end,
     .decode           = wmavoice_decode_packet,
-    .capabilities     = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,
+    .capabilities     = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
     .flush            = wmavoice_flush,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/wmv2.h b/mythtv/external/FFmpeg/libavcodec/wmv2.h
index 31593b8c38d..0f459ae5ae4 100644
--- a/mythtv/external/FFmpeg/libavcodec/wmv2.h
+++ b/mythtv/external/FFmpeg/libavcodec/wmv2.h
@@ -51,7 +51,7 @@ typedef struct Wmv2Context {
     int hshift;
 
     ScanTable abt_scantable[2];
-    DECLARE_ALIGNED(16, int16_t, abt_block2)[6][64];
+    DECLARE_ALIGNED(32, int16_t, abt_block2)[6][64];
 } Wmv2Context;
 
 void ff_wmv2_common_init(Wmv2Context *w);
diff --git a/mythtv/external/FFmpeg/libavcodec/wmv2dec.c b/mythtv/external/FFmpeg/libavcodec/wmv2dec.c
index 20dbee57032..225e30ab5a6 100644
--- a/mythtv/external/FFmpeg/libavcodec/wmv2dec.c
+++ b/mythtv/external/FFmpeg/libavcodec/wmv2dec.c
@@ -30,7 +30,7 @@
 #include "wmv2.h"
 
 
-static void parse_mb_skip(Wmv2Context *w)
+static int parse_mb_skip(Wmv2Context *w)
 {
     int mb_x, mb_y;
     MpegEncContext *const s = &w->s;
@@ -45,6 +45,8 @@ static void parse_mb_skip(Wmv2Context *w)
                     MB_TYPE_16x16 | MB_TYPE_L0;
         break;
     case SKIP_TYPE_MPEG:
+        if (get_bits_left(&s->gb) < s->mb_height * s->mb_width)
+            return AVERROR_INVALIDDATA;
         for (mb_y = 0; mb_y < s->mb_height; mb_y++)
             for (mb_x = 0; mb_x < s->mb_width; mb_x++)
                 mb_type[mb_y * s->mb_stride + mb_x] =
@@ -52,6 +54,8 @@ static void parse_mb_skip(Wmv2Context *w)
         break;
     case SKIP_TYPE_ROW:
         for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
+            if (get_bits_left(&s->gb) < 1)
+                return AVERROR_INVALIDDATA;
             if (get_bits1(&s->gb)) {
                 for (mb_x = 0; mb_x < s->mb_width; mb_x++)
                     mb_type[mb_y * s->mb_stride + mb_x] =
@@ -65,6 +69,8 @@ static void parse_mb_skip(Wmv2Context *w)
         break;
     case SKIP_TYPE_COL:
         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
+            if (get_bits_left(&s->gb) < 1)
+                return AVERROR_INVALIDDATA;
             if (get_bits1(&s->gb)) {
                 for (mb_y = 0; mb_y < s->mb_height; mb_y++)
                     mb_type[mb_y * s->mb_stride + mb_x] =
@@ -77,6 +83,7 @@ static void parse_mb_skip(Wmv2Context *w)
         }
         break;
     }
+    return 0;
 }
 
 static int decode_ext_header(Wmv2Context *w)
@@ -170,9 +177,12 @@ int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
         }
     } else {
         int cbp_index;
+        int ret;
         w->j_type = 0;
 
-        parse_mb_skip(w);
+        ret = parse_mb_skip(w);
+        if (ret < 0)
+            return ret;
         cbp_index = decode012(&s->gb);
         w->cbp_table_index = wmv2_get_cbp_table_index(s, cbp_index);
 
@@ -359,6 +369,8 @@ int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
             w->hshift      = 0;
             return 0;
         }
+        if (get_bits_left(&s->gb) <= 0)
+            return AVERROR_INVALIDDATA;
 
         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[w->cbp_table_index].table,
                         MB_NON_INTRA_VLC_BITS, 3);
@@ -369,6 +381,8 @@ int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
         cbp = code & 0x3f;
     } else {
         s->mb_intra = 1;
+        if (get_bits_left(&s->gb) <= 0)
+            return AVERROR_INVALIDDATA;
         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
         if (code < 0) {
             av_log(s->avctx, AV_LOG_ERROR,
diff --git a/mythtv/external/FFmpeg/libavcodec/wmv2dsp.c b/mythtv/external/FFmpeg/libavcodec/wmv2dsp.c
index 40e0bef0da4..543f01b852a 100644
--- a/mythtv/external/FFmpeg/libavcodec/wmv2dsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/wmv2dsp.c
@@ -48,8 +48,8 @@ static void wmv2_idct_row(short * b)
     a4 = W0 * b[0] - W0 * b[4];
 
     /* step 2 */
-    s1 = (181 * (a1 - a5 + a7 - a3) + 128) >> 8; // 1, 3, 5, 7
-    s2 = (181 * (a1 - a5 - a7 + a3) + 128) >> 8;
+    s1 = (int)(181U * (a1 - a5 + a7 - a3) + 128) >> 8; // 1, 3, 5, 7
+    s2 = (int)(181U * (a1 - a5 - a7 + a3) + 128) >> 8;
 
     /* step 3 */
     b[0] = (a0 + a2 + a1 + a5 + (1 << 7)) >> 8;
@@ -78,8 +78,8 @@ static void wmv2_idct_col(short * b)
     a4 = (W0 * b[8 * 0] - W0 * b[8 * 4]    ) >> 3;
 
     /* step 2 */
-    s1 = (181 * (a1 - a5 + a7 - a3) + 128) >> 8;
-    s2 = (181 * (a1 - a5 - a7 + a3) + 128) >> 8;
+    s1 = (int)(181U * (a1 - a5 + a7 - a3) + 128) >> 8;
+    s2 = (int)(181U * (a1 - a5 - a7 + a3) + 128) >> 8;
 
     /* step 3 */
     b[8 * 0] = (a0 + a2 + a1 + a5 + (1 << 13)) >> 14;
@@ -93,7 +93,7 @@ static void wmv2_idct_col(short * b)
     b[8 * 7] = (a0 + a2 - a1 - a5 + (1 << 13)) >> 14;
 }
 
-static void wmv2_idct_add_c(uint8_t *dest, int line_size, int16_t *block)
+static void wmv2_idct_add_c(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     int i;
 
@@ -116,7 +116,7 @@ static void wmv2_idct_add_c(uint8_t *dest, int line_size, int16_t *block)
     }
 }
 
-static void wmv2_idct_put_c(uint8_t *dest, int line_size, int16_t *block)
+static void wmv2_idct_put_c(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     int i;
 
@@ -262,4 +262,7 @@ av_cold void ff_wmv2dsp_init(WMV2DSPContext *c)
     c->put_mspel_pixels_tab[5] = put_mspel8_mc12_c;
     c->put_mspel_pixels_tab[6] = put_mspel8_mc22_c;
     c->put_mspel_pixels_tab[7] = put_mspel8_mc32_c;
+
+    if (ARCH_MIPS)
+        ff_wmv2dsp_init_mips(c);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/wmv2dsp.h b/mythtv/external/FFmpeg/libavcodec/wmv2dsp.h
index 0bf9489b07c..5e40b30a208 100644
--- a/mythtv/external/FFmpeg/libavcodec/wmv2dsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/wmv2dsp.h
@@ -24,8 +24,8 @@
 #include "qpeldsp.h"
 
 typedef struct WMV2DSPContext {
-    void (*idct_add)(uint8_t *dest, int line_size, int16_t *block);
-    void (*idct_put)(uint8_t *dest, int line_size, int16_t *block);
+    void (*idct_add)(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+    void (*idct_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 
     qpel_mc_func put_mspel_pixels_tab[8];
 
@@ -33,5 +33,6 @@ typedef struct WMV2DSPContext {
 } WMV2DSPContext;
 
 void ff_wmv2dsp_init(WMV2DSPContext *c);
+void ff_wmv2dsp_init_mips(WMV2DSPContext *c);
 
 #endif /* AVCODEC_WMV2DSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/wnv1.c b/mythtv/external/FFmpeg/libavcodec/wnv1.c
index 9ff99b2f98d..915e9c7dc9e 100644
--- a/mythtv/external/FFmpeg/libavcodec/wnv1.c
+++ b/mythtv/external/FFmpeg/libavcodec/wnv1.c
@@ -52,7 +52,7 @@ static inline int wnv1_get_code(WNV1Context *w, int base_value)
     if (v == 15)
         return ff_reverse[get_bits(&w->gb, 8 - w->shift)];
     else
-        return base_value + ((v - 7) << w->shift);
+        return base_value + ((v - 7U) << w->shift);
 }
 
 static int decode_frame(AVCodecContext *avctx,
@@ -68,7 +68,7 @@ static int decode_frame(AVCodecContext *avctx,
     int prev_y = 0, prev_u = 0, prev_v = 0;
     uint8_t *rbuf;
 
-    if (buf_size <= 8) {
+    if (buf_size < 8 + avctx->height * (avctx->width/2)/8) {
         av_log(avctx, AV_LOG_ERROR, "Packet size %d is too small\n", buf_size);
         return AVERROR_INVALIDDATA;
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/wrapped_avframe.c b/mythtv/external/FFmpeg/libavcodec/wrapped_avframe.c
index 13c8d8a2398..5f88a668b92 100644
--- a/mythtv/external/FFmpeg/libavcodec/wrapped_avframe.c
+++ b/mythtv/external/FFmpeg/libavcodec/wrapped_avframe.c
@@ -43,19 +43,31 @@ static int wrapped_avframe_encode(AVCodecContext *avctx, AVPacket *pkt,
                      const AVFrame *frame, int *got_packet)
 {
     AVFrame *wrapped = av_frame_clone(frame);
+    uint8_t *data;
+    int size = sizeof(*wrapped) + AV_INPUT_BUFFER_PADDING_SIZE;
 
     if (!wrapped)
         return AVERROR(ENOMEM);
 
-    pkt->buf = av_buffer_create((uint8_t *)wrapped, sizeof(*wrapped),
+    data = av_mallocz(size);
+    if (!data) {
+        av_frame_free(&wrapped);
+        return AVERROR(ENOMEM);
+    }
+
+    pkt->buf = av_buffer_create(data, size,
                                 wrapped_avframe_release_buffer, NULL,
                                 AV_BUFFER_FLAG_READONLY);
     if (!pkt->buf) {
         av_frame_free(&wrapped);
+        av_freep(&data);
         return AVERROR(ENOMEM);
     }
 
-    pkt->data = (uint8_t *)wrapped;
+    av_frame_move_ref((AVFrame*)data, wrapped);
+    av_frame_free(&wrapped);
+
+    pkt->data = data;
     pkt->size = sizeof(*wrapped);
 
     pkt->flags |= AV_PKT_FLAG_KEY;
@@ -63,6 +75,33 @@ static int wrapped_avframe_encode(AVCodecContext *avctx, AVPacket *pkt,
     return 0;
 }
 
+static int wrapped_avframe_decode(AVCodecContext *avctx, void *data,
+                                  int *got_frame, AVPacket *pkt)
+{
+    AVFrame *in, *out;
+    int err;
+
+    if (!(pkt->flags & AV_PKT_FLAG_TRUSTED)) {
+        // This decoder is not usable with untrusted input.
+        return AVERROR(EPERM);
+    }
+
+    if (pkt->size < sizeof(AVFrame))
+        return AVERROR(EINVAL);
+
+    in  = (AVFrame*)pkt->data;
+    out = data;
+
+    err = ff_decode_frame_props(avctx, out);
+    if (err < 0)
+        return err;
+
+    av_frame_move_ref(out, in);
+
+    *got_frame = 1;
+    return 0;
+}
+
 AVCodec ff_wrapped_avframe_encoder = {
     .name           = "wrapped_avframe",
     .long_name      = NULL_IF_CONFIG_SMALL("AVFrame to AVPacket passthrough"),
@@ -71,3 +110,12 @@ AVCodec ff_wrapped_avframe_encoder = {
     .encode2        = wrapped_avframe_encode,
     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
+
+AVCodec ff_wrapped_avframe_decoder = {
+    .name           = "wrapped_avframe",
+    .long_name      = NULL_IF_CONFIG_SMALL("AVPacket to AVFrame passthrough"),
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_WRAPPED_AVFRAME,
+    .decode         = wrapped_avframe_decode,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/Makefile b/mythtv/external/FFmpeg/libavcodec/x86/Makefile
index 1db1137392b..a805cd37b48 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/Makefile
+++ b/mythtv/external/FFmpeg/libavcodec/x86/Makefile
@@ -20,10 +20,12 @@ OBJS-$(CONFIG_H264QPEL)                += x86/h264_qpel.o
 OBJS-$(CONFIG_HPELDSP)                 += x86/hpeldsp_init.o
 OBJS-$(CONFIG_LLAUDDSP)                += x86/lossless_audiodsp_init.o
 OBJS-$(CONFIG_LLVIDDSP)                += x86/lossless_videodsp_init.o
+OBJS-$(CONFIG_LLVIDENCDSP)             += x86/lossless_videoencdsp_init.o
 OBJS-$(CONFIG_HUFFYUVDSP)              += x86/huffyuvdsp_init.o
-OBJS-$(CONFIG_HUFFYUVENCDSP)           += x86/huffyuvencdsp_mmx.o
+OBJS-$(CONFIG_HUFFYUVENCDSP)           += x86/huffyuvencdsp_init.o
 OBJS-$(CONFIG_IDCTDSP)                 += x86/idctdsp_init.o
 OBJS-$(CONFIG_LPC)                     += x86/lpc.o
+OBJS-$(CONFIG_MDCT15)                  += x86/mdct15_init.o
 OBJS-$(CONFIG_ME_CMP)                  += x86/me_cmp_init.o
 OBJS-$(CONFIG_MPEGAUDIODSP)            += x86/mpegaudiodsp.o
 OBJS-$(CONFIG_MPEGVIDEO)               += x86/mpegvideo.o              \
@@ -50,6 +52,9 @@ OBJS-$(CONFIG_APNG_DECODER)            += x86/pngdsp_init.o
 OBJS-$(CONFIG_CAVS_DECODER)            += x86/cavsdsp.o
 OBJS-$(CONFIG_DCA_DECODER)             += x86/dcadsp_init.o x86/synth_filter_init.o
 OBJS-$(CONFIG_DNXHD_ENCODER)           += x86/dnxhdenc_init.o
+OBJS-$(CONFIG_EXR_DECODER)             += x86/exrdsp_init.o
+OBJS-$(CONFIG_OPUS_DECODER)            += x86/opus_dsp_init.o
+OBJS-$(CONFIG_OPUS_ENCODER)            += x86/opus_dsp_init.o
 OBJS-$(CONFIG_HEVC_DECODER)            += x86/hevcdsp_init.o
 OBJS-$(CONFIG_JPEG2000_DECODER)        += x86/jpeg2000dsp_init.o
 OBJS-$(CONFIG_MLP_DECODER)             += x86/mlpdsp_init.o
@@ -63,9 +68,11 @@ OBJS-$(CONFIG_TAK_DECODER)             += x86/takdsp_init.o
 OBJS-$(CONFIG_TRUEHD_DECODER)          += x86/mlpdsp_init.o
 OBJS-$(CONFIG_TTA_DECODER)             += x86/ttadsp_init.o
 OBJS-$(CONFIG_TTA_ENCODER)             += x86/ttaencdsp_init.o
+OBJS-$(CONFIG_UTVIDEO_DECODER)         += x86/utvideodsp_init.o
 OBJS-$(CONFIG_V210_DECODER)            += x86/v210-init.o
 OBJS-$(CONFIG_V210_ENCODER)            += x86/v210enc_init.o
 OBJS-$(CONFIG_VORBIS_DECODER)          += x86/vorbisdsp_init.o
+OBJS-$(CONFIG_VP3_DECODER)             += x86/hpeldsp_vp3_init.o
 OBJS-$(CONFIG_VP6_DECODER)             += x86/vp6dsp_init.o
 OBJS-$(CONFIG_VP9_DECODER)             += x86/vp9dsp_init.o            \
                                           x86/vp9dsp_init_10bpp.o      \
@@ -77,7 +84,6 @@ OBJS-$(CONFIG_WEBP_DECODER)            += x86/vp8dsp_init.o
 # GCC inline assembly optimizations
 # subsystems
 MMX-OBJS-$(CONFIG_FDCTDSP)             += x86/fdct.o
-MMX-OBJS-$(CONFIG_IDCTDSP)             += x86/simple_idct.o
 MMX-OBJS-$(CONFIG_VC1DSP)              += x86/vc1dsp_mmx.o
 
 # decoders/encoders
@@ -85,90 +91,99 @@ MMX-OBJS-$(CONFIG_SNOW_DECODER)        += x86/snowdsp.o
 MMX-OBJS-$(CONFIG_SNOW_ENCODER)        += x86/snowdsp.o
 
 # subsystems
-YASM-OBJS-$(CONFIG_AC3DSP)             += x86/ac3dsp.o
-YASM-OBJS-$(CONFIG_AUDIODSP)           += x86/audiodsp.o
-YASM-OBJS-$(CONFIG_BLOCKDSP)           += x86/blockdsp.o
-YASM-OBJS-$(CONFIG_BSWAPDSP)           += x86/bswapdsp.o
-YASM-OBJS-$(CONFIG_DCT)                += x86/dct32.o
-YASM-OBJS-$(CONFIG_FFT)                += x86/fft.o
-YASM-OBJS-$(CONFIG_FMTCONVERT)         += x86/fmtconvert.o
-YASM-OBJS-$(CONFIG_H263DSP)            += x86/h263_loopfilter.o
-YASM-OBJS-$(CONFIG_H264CHROMA)         += x86/h264_chromamc.o           \
+X86ASM-OBJS-$(CONFIG_AC3DSP)           += x86/ac3dsp.o                  \
+                                          x86/ac3dsp_downmix.o
+X86ASM-OBJS-$(CONFIG_AUDIODSP)         += x86/audiodsp.o
+X86ASM-OBJS-$(CONFIG_BLOCKDSP)         += x86/blockdsp.o
+X86ASM-OBJS-$(CONFIG_BSWAPDSP)         += x86/bswapdsp.o
+X86ASM-OBJS-$(CONFIG_DCT)              += x86/dct32.o
+X86ASM-OBJS-$(CONFIG_FFT)              += x86/fft.o
+X86ASM-OBJS-$(CONFIG_FMTCONVERT)       += x86/fmtconvert.o
+X86ASM-OBJS-$(CONFIG_H263DSP)          += x86/h263_loopfilter.o
+X86ASM-OBJS-$(CONFIG_H264CHROMA)       += x86/h264_chromamc.o           \
                                           x86/h264_chromamc_10bit.o
-YASM-OBJS-$(CONFIG_H264DSP)            += x86/h264_deblock.o            \
+X86ASM-OBJS-$(CONFIG_H264DSP)          += x86/h264_deblock.o            \
                                           x86/h264_deblock_10bit.o      \
                                           x86/h264_idct.o               \
                                           x86/h264_idct_10bit.o         \
                                           x86/h264_weight.o             \
                                           x86/h264_weight_10bit.o
-YASM-OBJS-$(CONFIG_H264PRED)           += x86/h264_intrapred.o          \
+X86ASM-OBJS-$(CONFIG_H264PRED)         += x86/h264_intrapred.o          \
                                           x86/h264_intrapred_10bit.o
-YASM-OBJS-$(CONFIG_H264QPEL)           += x86/h264_qpel_8bit.o          \
+X86ASM-OBJS-$(CONFIG_H264QPEL)         += x86/h264_qpel_8bit.o          \
                                           x86/h264_qpel_10bit.o         \
                                           x86/fpel.o                    \
                                           x86/qpel.o
-YASM-OBJS-$(CONFIG_HPELDSP)            += x86/fpel.o                    \
+X86ASM-OBJS-$(CONFIG_HPELDSP)          += x86/fpel.o                    \
                                           x86/hpeldsp.o
-YASM-OBJS-$(CONFIG_HUFFYUVDSP)         += x86/huffyuvdsp.o
-YASM-OBJS-$(CONFIG_HUFFYUVENCDSP)      += x86/huffyuvencdsp.o
-YASM-OBJS-$(CONFIG_IDCTDSP)            += x86/idctdsp.o
-YASM-OBJS-$(CONFIG_LLAUDDSP)           += x86/lossless_audiodsp.o
-YASM-OBJS-$(CONFIG_LLVIDDSP)           += x86/lossless_videodsp.o
-YASM-OBJS-$(CONFIG_ME_CMP)             += x86/me_cmp.o
-YASM-OBJS-$(CONFIG_MPEGAUDIODSP)       += x86/imdct36.o
-YASM-OBJS-$(CONFIG_MPEGVIDEOENC)       += x86/mpegvideoencdsp.o
-YASM-OBJS-$(CONFIG_PIXBLOCKDSP)        += x86/pixblockdsp.o
-YASM-OBJS-$(CONFIG_QPELDSP)            += x86/qpeldsp.o                 \
+X86ASM-OBJS-$(CONFIG_HUFFYUVDSP)       += x86/huffyuvdsp.o
+X86ASM-OBJS-$(CONFIG_HUFFYUVENCDSP)    += x86/huffyuvencdsp.o
+X86ASM-OBJS-$(CONFIG_IDCTDSP)          += x86/idctdsp.o
+X86ASM-OBJS-$(CONFIG_LLAUDDSP)         += x86/lossless_audiodsp.o
+X86ASM-OBJS-$(CONFIG_LLVIDDSP)         += x86/lossless_videodsp.o
+X86ASM-OBJS-$(CONFIG_LLVIDENCDSP)      += x86/lossless_videoencdsp.o
+X86ASM-OBJS-$(CONFIG_MDCT15)           += x86/mdct15.o
+X86ASM-OBJS-$(CONFIG_ME_CMP)           += x86/me_cmp.o
+X86ASM-OBJS-$(CONFIG_MPEGAUDIODSP)     += x86/imdct36.o
+X86ASM-OBJS-$(CONFIG_MPEGVIDEOENC)     += x86/mpegvideoencdsp.o
+X86ASM-OBJS-$(CONFIG_OPUS_ENCODER)     += x86/opus_pvq_search.o
+X86ASM-OBJS-$(CONFIG_PIXBLOCKDSP)      += x86/pixblockdsp.o
+X86ASM-OBJS-$(CONFIG_QPELDSP)          += x86/qpeldsp.o                 \
                                           x86/fpel.o                    \
                                           x86/qpel.o
-YASM-OBJS-$(CONFIG_RV34DSP)            += x86/rv34dsp.o
-YASM-OBJS-$(CONFIG_VC1DSP)             += x86/vc1dsp_loopfilter.o       \
+X86ASM-OBJS-$(CONFIG_RV34DSP)          += x86/rv34dsp.o
+X86ASM-OBJS-$(CONFIG_VC1DSP)           += x86/vc1dsp_loopfilter.o       \
                                           x86/vc1dsp_mc.o
-YASM-OBJS-$(CONFIG_IDCTDSP)            += x86/simple_idct10.o
-YASM-OBJS-$(CONFIG_VIDEODSP)           += x86/videodsp.o
-YASM-OBJS-$(CONFIG_VP3DSP)             += x86/vp3dsp.o
-YASM-OBJS-$(CONFIG_VP8DSP)             += x86/vp8dsp.o                  \
+X86ASM-OBJS-$(CONFIG_IDCTDSP)          += x86/simple_idct10.o           \
+                                          x86/simple_idct.o
+X86ASM-OBJS-$(CONFIG_VIDEODSP)         += x86/videodsp.o
+X86ASM-OBJS-$(CONFIG_VP3DSP)           += x86/vp3dsp.o
+X86ASM-OBJS-$(CONFIG_VP8DSP)           += x86/vp8dsp.o                  \
                                           x86/vp8dsp_loopfilter.o
 
 # decoders/encoders
-YASM-OBJS-$(CONFIG_AAC_DECODER)        += x86/aacpsdsp.o                \
+X86ASM-OBJS-$(CONFIG_AAC_DECODER)      += x86/aacpsdsp.o                \
                                           x86/sbrdsp.o
-YASM-OBJS-$(CONFIG_AAC_ENCODER)        += x86/aacencdsp.o
-YASM-OBJS-$(CONFIG_ADPCM_G722_DECODER) += x86/g722dsp.o
-YASM-OBJS-$(CONFIG_ADPCM_G722_ENCODER) += x86/g722dsp.o
-YASM-OBJS-$(CONFIG_ALAC_DECODER)       += x86/alacdsp.o
-YASM-OBJS-$(CONFIG_APNG_DECODER)       += x86/pngdsp.o
-YASM-OBJS-$(CONFIG_DCA_DECODER)        += x86/dcadsp.o x86/synth_filter.o
-YASM-OBJS-$(CONFIG_DIRAC_DECODER)      += x86/diracdsp.o                \
+X86ASM-OBJS-$(CONFIG_AAC_ENCODER)      += x86/aacencdsp.o
+X86ASM-OBJS-$(CONFIG_ADPCM_G722_DECODER) += x86/g722dsp.o
+X86ASM-OBJS-$(CONFIG_ADPCM_G722_ENCODER) += x86/g722dsp.o
+X86ASM-OBJS-$(CONFIG_ALAC_DECODER)     += x86/alacdsp.o
+X86ASM-OBJS-$(CONFIG_APNG_DECODER)     += x86/pngdsp.o
+X86ASM-OBJS-$(CONFIG_CAVS_DECODER)     += x86/cavsidct.o
+X86ASM-OBJS-$(CONFIG_DCA_DECODER)      += x86/dcadsp.o x86/synth_filter.o
+X86ASM-OBJS-$(CONFIG_DIRAC_DECODER)    += x86/diracdsp.o                \
                                           x86/dirac_dwt.o
-YASM-OBJS-$(CONFIG_DNXHD_ENCODER)      += x86/dnxhdenc.o
-YASM-OBJS-$(CONFIG_FLAC_DECODER)       += x86/flacdsp.o
+X86ASM-OBJS-$(CONFIG_DNXHD_ENCODER)    += x86/dnxhdenc.o
+X86ASM-OBJS-$(CONFIG_EXR_DECODER)      += x86/exrdsp.o
+X86ASM-OBJS-$(CONFIG_FLAC_DECODER)     += x86/flacdsp.o
 ifdef CONFIG_GPL
-YASM-OBJS-$(CONFIG_FLAC_ENCODER)       += x86/flac_dsp_gpl.o
+X86ASM-OBJS-$(CONFIG_FLAC_ENCODER)     += x86/flac_dsp_gpl.o
 endif
-YASM-OBJS-$(CONFIG_HEVC_DECODER)       += x86/hevc_mc.o                 \
+X86ASM-OBJS-$(CONFIG_HEVC_DECODER)     += x86/hevc_add_res.o            \
                                           x86/hevc_deblock.o            \
                                           x86/hevc_idct.o               \
-                                          x86/hevc_res_add.o            \
+                                          x86/hevc_mc.o                 \
                                           x86/hevc_sao.o                \
                                           x86/hevc_sao_10bit.o
-YASM-OBJS-$(CONFIG_JPEG2000_DECODER)   += x86/jpeg2000dsp.o
-YASM-OBJS-$(CONFIG_MLP_DECODER)        += x86/mlpdsp.o
-YASM-OBJS-$(CONFIG_MPEG4_DECODER)      += x86/xvididct.o
-YASM-OBJS-$(CONFIG_PNG_DECODER)        += x86/pngdsp.o
-YASM-OBJS-$(CONFIG_PRORES_DECODER)     += x86/proresdsp.o
-YASM-OBJS-$(CONFIG_PRORES_LGPL_DECODER) += x86/proresdsp.o
-YASM-OBJS-$(CONFIG_RV40_DECODER)       += x86/rv40dsp.o
-YASM-OBJS-$(CONFIG_SVQ1_ENCODER)       += x86/svq1enc.o
-YASM-OBJS-$(CONFIG_TAK_DECODER)        += x86/takdsp.o
-YASM-OBJS-$(CONFIG_TRUEHD_DECODER)     += x86/mlpdsp.o
-YASM-OBJS-$(CONFIG_TTA_DECODER)        += x86/ttadsp.o
-YASM-OBJS-$(CONFIG_TTA_ENCODER)        += x86/ttaencdsp.o
-YASM-OBJS-$(CONFIG_V210_ENCODER)       += x86/v210enc.o
-YASM-OBJS-$(CONFIG_V210_DECODER)       += x86/v210.o
-YASM-OBJS-$(CONFIG_VORBIS_DECODER)     += x86/vorbisdsp.o
-YASM-OBJS-$(CONFIG_VP6_DECODER)        += x86/vp6dsp.o
-YASM-OBJS-$(CONFIG_VP9_DECODER)        += x86/vp9intrapred.o            \
+X86ASM-OBJS-$(CONFIG_JPEG2000_DECODER) += x86/jpeg2000dsp.o
+X86ASM-OBJS-$(CONFIG_MLP_DECODER)      += x86/mlpdsp.o
+X86ASM-OBJS-$(CONFIG_MPEG4_DECODER)    += x86/xvididct.o
+X86ASM-OBJS-$(CONFIG_PNG_DECODER)      += x86/pngdsp.o
+X86ASM-OBJS-$(CONFIG_PRORES_DECODER)   += x86/proresdsp.o
+X86ASM-OBJS-$(CONFIG_PRORES_LGPL_DECODER) += x86/proresdsp.o
+X86ASM-OBJS-$(CONFIG_RV40_DECODER)     += x86/rv40dsp.o
+X86ASM-OBJS-$(CONFIG_SVQ1_ENCODER)     += x86/svq1enc.o
+X86ASM-OBJS-$(CONFIG_TAK_DECODER)      += x86/takdsp.o
+X86ASM-OBJS-$(CONFIG_TRUEHD_DECODER)   += x86/mlpdsp.o
+X86ASM-OBJS-$(CONFIG_TTA_DECODER)      += x86/ttadsp.o
+X86ASM-OBJS-$(CONFIG_TTA_ENCODER)      += x86/ttaencdsp.o
+X86ASM-OBJS-$(CONFIG_UTVIDEO_DECODER)  += x86/utvideodsp.o
+X86ASM-OBJS-$(CONFIG_V210_ENCODER)     += x86/v210enc.o
+X86ASM-OBJS-$(CONFIG_V210_DECODER)     += x86/v210.o
+X86ASM-OBJS-$(CONFIG_VORBIS_DECODER)   += x86/vorbisdsp.o
+X86ASM-OBJS-$(CONFIG_VP3_DECODER)      += x86/hpeldsp_vp3.o
+X86ASM-OBJS-$(CONFIG_VP6_DECODER)      += x86/vp6dsp.o
+X86ASM-OBJS-$(CONFIG_VP9_DECODER)      += x86/vp9intrapred.o            \
                                           x86/vp9intrapred_16bpp.o      \
                                           x86/vp9itxfm.o                \
                                           x86/vp9itxfm_16bpp.o          \
@@ -176,4 +191,4 @@ YASM-OBJS-$(CONFIG_VP9_DECODER)        += x86/vp9intrapred.o            \
                                           x86/vp9lpf_16bpp.o            \
                                           x86/vp9mc.o                   \
                                           x86/vp9mc_16bpp.o
-YASM-OBJS-$(CONFIG_WEBP_DECODER)       += x86/vp8dsp.o
+X86ASM-OBJS-$(CONFIG_WEBP_DECODER)     += x86/vp8dsp.o
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/aacpsdsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/aacpsdsp.asm
index e92cbbce086..4acd087c853 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/aacpsdsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/aacpsdsp.asm
@@ -62,24 +62,27 @@ PS_ADD_SQUARES 3
 ;                                   float *src1, int n);
 ;*******************************************************************
 INIT_XMM sse
-cglobal ps_mul_pair_single, 4, 5, 4, dst, src1, src2, n
-    xor r4q, r4q
+cglobal ps_mul_pair_single, 4, 4, 4, dst, src1, src2, n
+    shl      nd, 3
+    add   src1q, nq
+    add    dstq, nq
+    neg      nq
 
+align 16
 .loop:
-    movu     m0, [src1q+r4q]
-    movu     m1, [src1q+r4q+mmsize]
+    movu     m0, [src1q+nq]
+    movu     m1, [src1q+nq+mmsize]
     mova     m2, [src2q]
     mova     m3, m2
     unpcklps m2, m2
     unpckhps m3, m3
     mulps    m0, m2
     mulps    m1, m3
-    mova [dstq+r4q], m0
-    mova [dstq+r4q+mmsize], m1
+    mova [dstq+nq], m0
+    mova [dstq+nq+mmsize], m1
     add   src2q, mmsize
-    add     r4q, mmsize*2
-    sub      nd, mmsize/4
-    jg .loop
+    add      nq, mmsize*2
+    jl .loop
     REP_RET
 
 ;***********************************************************************
@@ -91,8 +94,10 @@ INIT_XMM sse3
 cglobal ps_stereo_interpolate, 5, 5, 6, l, r, h, h_step, n
     movaps   m0, [hq]
     movaps   m1, [h_stepq]
-    cmp      nd, 0
-    jle .ret
+    unpcklps m4, m0, m0
+    unpckhps m0, m0
+    unpcklps m5, m1, m1
+    unpckhps m1, m1
     shl      nd, 3
     add      lq, nq
     add      rq, nq
@@ -100,27 +105,300 @@ cglobal ps_stereo_interpolate, 5, 5, 6, l, r, h, h_step, n
 
 align 16
 .loop:
+    addps    m4, m5
     addps    m0, m1
     movddup  m2, [lq+nq]
     movddup  m3, [rq+nq]
-    movaps   m4, m0
-    movaps   m5, m0
-    unpcklps m4, m4
-    unpckhps m5, m5
     mulps    m2, m4
-    mulps    m3, m5
+    mulps    m3, m0
+    addps    m2, m3
+    movsd  [lq+nq], m2
+    movhps [rq+nq], m2
+    add      nq, 8
+    jl .loop
+    REP_RET
+
+;***************************************************************************
+;void ps_stereo_interpolate_ipdopd_sse3(float (*l)[2], float (*r)[2],
+;                                       float h[2][4], float h_step[2][4],
+;                                       int len);
+;***************************************************************************
+INIT_XMM sse3
+cglobal ps_stereo_interpolate_ipdopd, 5, 5, 10, l, r, h, h_step, n
+    movaps   m0, [hq]
+    movaps   m1, [hq+mmsize]
+%if ARCH_X86_64
+    movaps   m8, [h_stepq]
+    movaps   m9, [h_stepq+mmsize]
+    %define  H_STEP0 m8
+    %define  H_STEP1 m9
+%else
+    %define  H_STEP0 [h_stepq]
+    %define  H_STEP1 [h_stepq+mmsize]
+%endif
+    shl      nd, 3
+    add      lq, nq
+    add      rq, nq
+    neg      nq
+
+align 16
+.loop:
+    addps    m0, H_STEP0
+    addps    m1, H_STEP1
+    movddup  m2, [lq+nq]
+    movddup  m3, [rq+nq]
+    shufps   m4, m2, m2, q2301
+    shufps   m5, m3, m3, q2301
+    unpcklps m6, m0, m0
+    unpckhps m7, m0, m0
+    mulps    m2, m6
+    mulps    m3, m7
+    unpcklps m6, m1, m1
+    unpckhps m7, m1, m1
+    mulps    m4, m6
+    mulps    m5, m7
     addps    m2, m3
+    addsubps m2, m4
+    addsubps m2, m5
     movsd  [lq+nq], m2
     movhps [rq+nq], m2
     add      nq, 8
     jl .loop
-.ret:
     REP_RET
 
+;**********************************************************
+;void ps_hybrid_analysis_ileave_sse(float out[2][38][64],
+;                                   float (*in)[32][2],
+;                                   int i, int len)
+;**********************************************************
+INIT_XMM sse
+cglobal ps_hybrid_analysis_ileave, 3, 7, 5, out, in, i, len, in0, in1, tmp
+    movsxdifnidn        iq, id
+    mov               lend, 32 << 3
+    lea                inq, [inq+iq*4]
+    mov               tmpd, id
+    shl               tmpd, 8
+    add               outq, tmpq
+    mov               tmpd, 64
+    sub               tmpd, id
+    mov                 id, tmpd
+
+    test                id, 1
+    jne .loop4
+    test                id, 2
+    jne .loop8
+
+align 16
+.loop16:
+    mov               in0q, inq
+    mov               in1q, 38*64*4
+    add               in1q, in0q
+    mov               tmpd, lend
+
+.inner_loop16:
+    movaps              m0, [in0q]
+    movaps              m1, [in1q]
+    movaps              m2, [in0q+lenq]
+    movaps              m3, [in1q+lenq]
+    TRANSPOSE4x4PS 0, 1, 2, 3, 4
+    movaps          [outq], m0
+    movaps     [outq+lenq], m1
+    movaps   [outq+lenq*2], m2
+    movaps [outq+3*32*2*4], m3
+    lea               in0q, [in0q+lenq*2]
+    lea               in1q, [in1q+lenq*2]
+    add               outq, mmsize
+    sub               tmpd, mmsize
+    jg .inner_loop16
+    add                inq, 16
+    add               outq, 3*32*2*4
+    sub                 id, 4
+    jg .loop16
+    RET
+
+align 16
+.loop8:
+    mov               in0q, inq
+    mov               in1q, 38*64*4
+    add               in1q, in0q
+    mov               tmpd, lend
+
+.inner_loop8:
+    movlps              m0, [in0q]
+    movlps              m1, [in1q]
+    movhps              m0, [in0q+lenq]
+    movhps              m1, [in1q+lenq]
+    SBUTTERFLYPS 0, 1, 2
+    SBUTTERFLYPD 0, 1, 2
+    movaps          [outq], m0
+    movaps     [outq+lenq], m1
+    lea               in0q, [in0q+lenq*2]
+    lea               in1q, [in1q+lenq*2]
+    add               outq, mmsize
+    sub               tmpd, mmsize
+    jg .inner_loop8
+    add                inq, 8
+    add               outq, lenq
+    sub                 id, 2
+    jg .loop16
+    RET
+
+align 16
+.loop4:
+    mov               in0q, inq
+    mov               in1q, 38*64*4
+    add               in1q, in0q
+    mov               tmpd, lend
+
+.inner_loop4:
+    movss               m0, [in0q]
+    movss               m1, [in1q]
+    movss               m2, [in0q+lenq]
+    movss               m3, [in1q+lenq]
+    movlhps             m0, m1
+    movlhps             m2, m3
+    shufps              m0, m2, q2020
+    movaps          [outq], m0
+    lea               in0q, [in0q+lenq*2]
+    lea               in1q, [in1q+lenq*2]
+    add               outq, mmsize
+    sub               tmpd, mmsize
+    jg .inner_loop4
+    add                inq, 4
+    sub                 id, 1
+    test                id, 2
+    jne .loop8
+    cmp                 id, 4
+    jge .loop16
+    RET
+
+;***********************************************************
+;void ps_hybrid_synthesis_deint_sse4(float out[2][38][64],
+;                                    float (*in)[32][2],
+;                                    int i, int len)
+;***********************************************************
+%macro HYBRID_SYNTHESIS_DEINT 0
+cglobal ps_hybrid_synthesis_deint, 3, 7, 5, out, in, i, len, out0, out1, tmp
+%if cpuflag(sse4)
+%define MOVH movsd
+%else
+%define MOVH movlps
+%endif
+    movsxdifnidn        iq, id
+    mov               lend, 32 << 3
+    lea               outq, [outq+iq*4]
+    mov               tmpd, id
+    shl               tmpd, 8
+    add                inq, tmpq
+    mov               tmpd, 64
+    sub               tmpd, id
+    mov                 id, tmpd
+
+    test                id, 1
+    jne .loop4
+    test                id, 2
+    jne .loop8
+
+align 16
+.loop16:
+    mov              out0q, outq
+    mov              out1q, 38*64*4
+    add              out1q, out0q
+    mov               tmpd, lend
+
+.inner_loop16:
+    movaps              m0, [inq]
+    movaps              m1, [inq+lenq]
+    movaps              m2, [inq+lenq*2]
+    movaps              m3, [inq+3*32*2*4]
+    TRANSPOSE4x4PS 0, 1, 2, 3, 4
+    movaps         [out0q], m0
+    movaps         [out1q], m1
+    movaps    [out0q+lenq], m2
+    movaps    [out1q+lenq], m3
+    lea              out0q, [out0q+lenq*2]
+    lea              out1q, [out1q+lenq*2]
+    add                inq, mmsize
+    sub               tmpd, mmsize
+    jg .inner_loop16
+    add               outq, 16
+    add                inq, 3*32*2*4
+    sub                 id, 4
+    jg .loop16
+    RET
+
+align 16
+.loop8:
+    mov              out0q, outq
+    mov              out1q, 38*64*4
+    add              out1q, out0q
+    mov               tmpd, lend
+
+.inner_loop8:
+    movaps              m0, [inq]
+    movaps              m1, [inq+lenq]
+    SBUTTERFLYPS 0, 1, 2
+    SBUTTERFLYPD 0, 1, 2
+    MOVH           [out0q], m0
+    MOVH           [out1q], m1
+    movhps    [out0q+lenq], m0
+    movhps    [out1q+lenq], m1
+    lea              out0q, [out0q+lenq*2]
+    lea              out1q, [out1q+lenq*2]
+    add                inq, mmsize
+    sub               tmpd, mmsize
+    jg .inner_loop8
+    add               outq, 8
+    add                inq, lenq
+    sub                 id, 2
+    jg .loop16
+    RET
+
+align 16
+.loop4:
+    mov              out0q, outq
+    mov              out1q, 38*64*4
+    add              out1q, out0q
+    mov               tmpd, lend
+
+.inner_loop4:
+    movaps              m0, [inq]
+    movss          [out0q], m0
+%if cpuflag(sse4)
+    extractps      [out1q], m0, 1
+    extractps [out0q+lenq], m0, 2
+    extractps [out1q+lenq], m0, 3
+%else
+    movhlps             m1, m0
+    movss     [out0q+lenq], m1
+    shufps              m0, m0, 0xb1
+    movss          [out1q], m0
+    movhlps             m1, m0
+    movss     [out1q+lenq], m1
+%endif
+    lea              out0q, [out0q+lenq*2]
+    lea              out1q, [out1q+lenq*2]
+    add                inq, mmsize
+    sub               tmpd, mmsize
+    jg .inner_loop4
+    add               outq, 4
+    sub                 id, 1
+    test                id, 2
+    jne .loop8
+    cmp                 id, 4
+    jge .loop16
+    RET
+%endmacro
+
+INIT_XMM sse
+HYBRID_SYNTHESIS_DEINT
+INIT_XMM sse4
+HYBRID_SYNTHESIS_DEINT
+
 ;*******************************************************************
 ;void ff_ps_hybrid_analysis_<opt>(float (*out)[2], float (*in)[2],
 ;                                 const float (*filter)[8][2],
-;                                 int stride, int n);
+;                                 ptrdiff_t stride, int n);
 ;*******************************************************************
 %macro PS_HYBRID_ANALYSIS_LOOP 3
     movu     %1, [inq+mmsize*%3]
@@ -160,7 +438,7 @@ cglobal ps_hybrid_analysis, 5, 5, 8, out, in, filter, stride, n
 %else
 %define MOVH movlps
 %endif
-    shl strided, 3
+    shl strideq, 3
     shl nd, 6
     add filterq, nq
     neg nq
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/aacpsdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/aacpsdsp_init.c
index f6d6c039c3f..21f00efa24e 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/aacpsdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/aacpsdsp_init.c
@@ -18,6 +18,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <stddef.h>
+
 #include "config.h"
 
 #include "libavutil/x86/cpu.h"
@@ -30,13 +32,22 @@ void ff_ps_mul_pair_single_sse (float (*dst)[2], float (*src0)[2],
                                 float *src1, int n);
 void ff_ps_hybrid_analysis_sse (float (*out)[2], float (*in)[2],
                                 const float (*filter)[8][2],
-                                int stride, int n);
+                                ptrdiff_t stride, int n);
 void ff_ps_hybrid_analysis_sse3(float (*out)[2], float (*in)[2],
                                 const float (*filter)[8][2],
-                                int stride, int n);
+                                ptrdiff_t stride, int n);
 void ff_ps_stereo_interpolate_sse3(float (*l)[2], float (*r)[2],
                                    float h[2][4], float h_step[2][4],
                                    int len);
+void ff_ps_stereo_interpolate_ipdopd_sse3(float (*l)[2], float (*r)[2],
+                                          float h[2][4], float h_step[2][4],
+                                          int len);
+void ff_ps_hybrid_synthesis_deint_sse(float out[2][38][64], float (*in)[32][2],
+                                      int i, int len);
+void ff_ps_hybrid_synthesis_deint_sse4(float out[2][38][64], float (*in)[32][2],
+                                       int i, int len);
+void ff_ps_hybrid_analysis_ileave_sse(float (*out)[32][2], float L[2][38][64],
+                                      int i, int len);
 
 av_cold void ff_psdsp_init_x86(PSDSPContext *s)
 {
@@ -45,11 +56,17 @@ av_cold void ff_psdsp_init_x86(PSDSPContext *s)
     if (EXTERNAL_SSE(cpu_flags)) {
         s->add_squares            = ff_ps_add_squares_sse;
         s->mul_pair_single        = ff_ps_mul_pair_single_sse;
+        s->hybrid_analysis_ileave = ff_ps_hybrid_analysis_ileave_sse;
+        s->hybrid_synthesis_deint = ff_ps_hybrid_synthesis_deint_sse;
         s->hybrid_analysis        = ff_ps_hybrid_analysis_sse;
     }
     if (EXTERNAL_SSE3(cpu_flags)) {
         s->add_squares            = ff_ps_add_squares_sse3;
         s->stereo_interpolate[0]  = ff_ps_stereo_interpolate_sse3;
+        s->stereo_interpolate[1]  = ff_ps_stereo_interpolate_ipdopd_sse3;
         s->hybrid_analysis        = ff_ps_hybrid_analysis_sse3;
     }
+    if (EXTERNAL_SSE4(cpu_flags)) {
+        s->hybrid_synthesis_deint = ff_ps_hybrid_synthesis_deint_sse4;
+    }
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/ac3dsp_downmix.asm b/mythtv/external/FFmpeg/libavcodec/x86/ac3dsp_downmix.asm
new file mode 100644
index 00000000000..057cc6061c8
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/ac3dsp_downmix.asm
@@ -0,0 +1,187 @@
+;*****************************************************************************
+;* x86-optimized AC-3 downmixing
+;* Copyright (c) 2012 Justin Ruggles
+;*
+;* 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
+;******************************************************************************
+
+;******************************************************************************
+;* This is based on the channel mixing asm in libavresample, but it is
+;* simplified for only float coefficients and only 3 to 6 channels.
+;******************************************************************************
+
+%include "libavutil/x86/x86util.asm"
+
+SECTION .text
+
+;-----------------------------------------------------------------------------
+; functions to downmix from 3 to 6 channels to mono or stereo
+; void ff_ac3_downmix_*(float **samples, float **matrix, int len);
+;-----------------------------------------------------------------------------
+
+%macro AC3_DOWNMIX 2 ; %1 = in channels, %2 = out channels
+; define some names to make the code clearer
+%assign  in_channels %1
+%assign out_channels %2
+%assign stereo out_channels - 1
+
+; determine how many matrix elements must go on the stack vs. mmregs
+%assign matrix_elements in_channels * out_channels
+%if stereo
+    %assign needed_mmregs 4
+%else
+    %assign needed_mmregs 3
+%endif
+%assign matrix_elements_mm num_mmregs - needed_mmregs
+%if matrix_elements < matrix_elements_mm
+    %assign matrix_elements_mm matrix_elements
+%endif
+%assign total_mmregs needed_mmregs+matrix_elements_mm
+%if matrix_elements_mm < matrix_elements
+    %assign matrix_elements_stack matrix_elements - matrix_elements_mm
+%else
+    %assign matrix_elements_stack 0
+%endif
+
+cglobal ac3_downmix_%1_to_%2, 3,in_channels+1,total_mmregs,0-matrix_elements_stack*mmsize, src0, src1, len, src2, src3, src4, src5
+
+; load matrix pointers
+%define matrix0q r1q
+%define matrix1q r3q
+%if stereo
+    mov      matrix1q, [matrix0q+gprsize]
+%endif
+    mov      matrix0q, [matrix0q]
+
+; define matrix coeff names
+%assign %%i 0
+%assign %%j needed_mmregs
+%rep in_channels
+    %if %%i >= matrix_elements_mm
+        CAT_XDEFINE mx_stack_0_, %%i, 1
+        CAT_XDEFINE mx_0_, %%i, [rsp+(%%i-matrix_elements_mm)*mmsize]
+    %else
+        CAT_XDEFINE mx_stack_0_, %%i, 0
+        CAT_XDEFINE mx_0_, %%i, m %+ %%j
+        %assign %%j %%j+1
+    %endif
+    %assign %%i %%i+1
+%endrep
+%if stereo
+%assign %%i 0
+%rep in_channels
+    %if in_channels + %%i >= matrix_elements_mm
+        CAT_XDEFINE mx_stack_1_, %%i, 1
+        CAT_XDEFINE mx_1_, %%i, [rsp+(in_channels+%%i-matrix_elements_mm)*mmsize]
+    %else
+        CAT_XDEFINE mx_stack_1_, %%i, 0
+        CAT_XDEFINE mx_1_, %%i, m %+ %%j
+        %assign %%j %%j+1
+    %endif
+    %assign %%i %%i+1
+%endrep
+%endif
+
+; load/splat matrix coeffs
+%assign %%i 0
+%rep in_channels
+    %if mx_stack_0_ %+ %%i
+        VBROADCASTSS m0, [matrix0q+4*%%i]
+        mova  mx_0_ %+ %%i, m0
+    %else
+        VBROADCASTSS mx_0_ %+ %%i, [matrix0q+4*%%i]
+    %endif
+    %if stereo
+    %if mx_stack_1_ %+ %%i
+        VBROADCASTSS m0, [matrix1q+4*%%i]
+        mova  mx_1_ %+ %%i, m0
+    %else
+        VBROADCASTSS mx_1_ %+ %%i, [matrix1q+4*%%i]
+    %endif
+    %endif
+    %assign %%i %%i+1
+%endrep
+
+    lea          lenq, [4*r2d]
+    ; load channel pointers to registers
+%assign %%i 1
+%rep (in_channels - 1)
+    mov         src %+ %%i %+ q, [src0q+%%i*gprsize]
+    add         src %+ %%i %+ q, lenq
+    %assign %%i %%i+1
+%endrep
+    mov         src0q, [src0q]
+    add         src0q, lenq
+    neg          lenq
+.loop:
+    %if stereo || mx_stack_0_0
+    mova           m0, [src0q+lenq]
+    %endif
+    %if stereo
+    mulps          m1, m0, mx_1_0
+    %endif
+    %if stereo || mx_stack_0_0
+    mulps          m0, m0, mx_0_0
+    %else
+    mulps          m0, mx_0_0, [src0q+lenq]
+    %endif
+%assign %%i 1
+%rep (in_channels - 1)
+    %define src_ptr src %+ %%i %+ q
+    ; avoid extra load for mono if matrix is in a mm register
+    %if stereo || mx_stack_0_ %+ %%i
+    mova           m2, [src_ptr+lenq]
+    %endif
+    %if stereo
+    FMULADD_PS     m1, m2, mx_1_ %+ %%i, m1, m3
+    %endif
+    %if stereo || mx_stack_0_ %+ %%i
+    FMULADD_PS     m0, m2, mx_0_ %+ %%i, m0, m2
+    %else
+    FMULADD_PS     m0, mx_0_ %+ %%i, [src_ptr+lenq], m0, m1
+    %endif
+    %assign %%i %%i+1
+%endrep
+    mova [src0q+lenq], m0
+    %if stereo
+    mova [src1q+lenq], m1
+    %endif
+
+    add          lenq, mmsize
+    jl .loop
+    RET
+%endmacro
+
+%macro AC3_DOWNMIX_FUNCS 0
+%assign %%i 3
+%rep 4
+    INIT_XMM sse
+    AC3_DOWNMIX %%i, 1
+    AC3_DOWNMIX %%i, 2
+    INIT_YMM avx
+    AC3_DOWNMIX %%i, 1
+    AC3_DOWNMIX %%i, 2
+    %if HAVE_FMA3_EXTERNAL
+    INIT_YMM fma3
+    AC3_DOWNMIX %%i, 1
+    AC3_DOWNMIX %%i, 2
+    %endif
+    %assign %%i %%i+1
+%endrep
+%endmacro
+
+AC3_DOWNMIX_FUNCS
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/ac3dsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/ac3dsp_init.c
index 07f0d256815..2e7e2fb6dab 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/ac3dsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/ac3dsp_init.c
@@ -63,138 +63,6 @@ void ff_apply_window_int16_ssse3(int16_t *output, const int16_t *input,
 void ff_apply_window_int16_ssse3_atom(int16_t *output, const int16_t *input,
                                       const int16_t *window, unsigned int len);
 
-#if ARCH_X86_32 && defined(__INTEL_COMPILER)
-#       undef HAVE_7REGS
-#       define HAVE_7REGS 0
-#endif
-
-#if HAVE_SSE_INLINE && HAVE_7REGS
-
-#define IF1(x) x
-#define IF0(x)
-
-#define MIX5(mono, stereo)                                      \
-    __asm__ volatile (                                          \
-        "movss           0(%1), %%xmm5          \n"             \
-        "movss           8(%1), %%xmm6          \n"             \
-        "movss          24(%1), %%xmm7          \n"             \
-        "shufps     $0, %%xmm5, %%xmm5          \n"             \
-        "shufps     $0, %%xmm6, %%xmm6          \n"             \
-        "shufps     $0, %%xmm7, %%xmm7          \n"             \
-        "1:                                     \n"             \
-        "movaps       (%0, %2), %%xmm0          \n"             \
-        "movaps       (%0, %3), %%xmm1          \n"             \
-        "movaps       (%0, %4), %%xmm2          \n"             \
-        "movaps       (%0, %5), %%xmm3          \n"             \
-        "movaps       (%0, %6), %%xmm4          \n"             \
-        "mulps          %%xmm5, %%xmm0          \n"             \
-        "mulps          %%xmm6, %%xmm1          \n"             \
-        "mulps          %%xmm5, %%xmm2          \n"             \
-        "mulps          %%xmm7, %%xmm3          \n"             \
-        "mulps          %%xmm7, %%xmm4          \n"             \
- stereo("addps          %%xmm1, %%xmm0          \n")            \
-        "addps          %%xmm1, %%xmm2          \n"             \
-        "addps          %%xmm3, %%xmm0          \n"             \
-        "addps          %%xmm4, %%xmm2          \n"             \
-   mono("addps          %%xmm2, %%xmm0          \n")            \
-        "movaps         %%xmm0, (%0, %2)        \n"             \
- stereo("movaps         %%xmm2, (%0, %3)        \n")            \
-        "add               $16, %0              \n"             \
-        "jl                 1b                  \n"             \
-        : "+&r"(i)                                              \
-        : "r"(matrix),                                          \
-          "r"(samples[0] + len),                                \
-          "r"(samples[1] + len),                                \
-          "r"(samples[2] + len),                                \
-          "r"(samples[3] + len),                                \
-          "r"(samples[4] + len)                                 \
-        : XMM_CLOBBERS("%xmm0", "%xmm1", "%xmm2", "%xmm3",      \
-                      "%xmm4", "%xmm5", "%xmm6", "%xmm7",)      \
-         "memory"                                               \
-    );
-
-#define MIX_MISC(stereo)                                        \
-    __asm__ volatile (                                          \
-        "mov              %5, %2            \n"                 \
-        "1:                                 \n"                 \
-        "mov -%c7(%6, %2, %c8), %3          \n"                 \
-        "movaps     (%3, %0), %%xmm0        \n"                 \
- stereo("movaps       %%xmm0, %%xmm1        \n")                \
-        "mulps        %%xmm4, %%xmm0        \n"                 \
- stereo("mulps        %%xmm5, %%xmm1        \n")                \
-        "2:                                 \n"                 \
-        "mov   (%6, %2, %c8), %1            \n"                 \
-        "movaps     (%1, %0), %%xmm2        \n"                 \
- stereo("movaps       %%xmm2, %%xmm3        \n")                \
-        "mulps   (%4, %2, 8), %%xmm2        \n"                 \
- stereo("mulps 16(%4, %2, 8), %%xmm3        \n")                \
-        "addps        %%xmm2, %%xmm0        \n"                 \
- stereo("addps        %%xmm3, %%xmm1        \n")                \
-        "add              $4, %2            \n"                 \
-        "jl               2b                \n"                 \
-        "mov              %5, %2            \n"                 \
- stereo("mov   (%6, %2, %c8), %1            \n")                \
-        "movaps       %%xmm0, (%3, %0)      \n"                 \
- stereo("movaps       %%xmm1, (%1, %0)      \n")                \
-        "add             $16, %0            \n"                 \
-        "jl               1b                \n"                 \
-        : "+&r"(i), "=&r"(j), "=&r"(k), "=&r"(m)                \
-        : "r"(matrix_simd + in_ch),                             \
-          "g"((intptr_t) - 4 * (in_ch - 1)),                    \
-          "r"(samp + in_ch),                                    \
-          "i"(sizeof(float *)), "i"(sizeof(float *)/4)          \
-        : "memory"                                              \
-    );
-
-static void ac3_downmix_sse(float **samples, float (*matrix)[2],
-                            int out_ch, int in_ch, int len)
-{
-    int (*matrix_cmp)[2] = (int(*)[2])matrix;
-    intptr_t i, j, k, m;
-
-    i = -len * sizeof(float);
-    if (in_ch == 5 && out_ch == 2 &&
-        !(matrix_cmp[0][1] | matrix_cmp[2][0]   |
-          matrix_cmp[3][1] | matrix_cmp[4][0]   |
-          (matrix_cmp[1][0] ^ matrix_cmp[1][1]) |
-          (matrix_cmp[0][0] ^ matrix_cmp[2][1]))) {
-        MIX5(IF0, IF1);
-    } else if (in_ch == 5 && out_ch == 1 &&
-               matrix_cmp[0][0] == matrix_cmp[2][0] &&
-               matrix_cmp[3][0] == matrix_cmp[4][0]) {
-        MIX5(IF1, IF0);
-    } else {
-        LOCAL_ALIGNED(16, float, matrix_simd, [AC3_MAX_CHANNELS], [2][4]);
-        float *samp[AC3_MAX_CHANNELS];
-
-        for (j = 0; j < in_ch; j++)
-            samp[j] = samples[j] + len;
-
-        j = 2 * in_ch * sizeof(float);
-        __asm__ volatile (
-            "1:                                 \n"
-            "sub             $8, %0             \n"
-            "movss     (%2, %0), %%xmm4         \n"
-            "movss    4(%2, %0), %%xmm5         \n"
-            "shufps          $0, %%xmm4, %%xmm4 \n"
-            "shufps          $0, %%xmm5, %%xmm5 \n"
-            "movaps      %%xmm4,   (%1, %0, 4)  \n"
-            "movaps      %%xmm5, 16(%1, %0, 4)  \n"
-            "jg              1b                 \n"
-            : "+&r"(j)
-            : "r"(matrix_simd), "r"(matrix)
-            : "memory"
-        );
-        if (out_ch == 2) {
-            MIX_MISC(IF1);
-        } else {
-            MIX_MISC(IF0);
-        }
-    }
-}
-
-#endif /* HAVE_SSE_INLINE && HAVE_7REGS */
-
 av_cold void ff_ac3dsp_init_x86(AC3DSPContext *c, int bit_exact)
 {
     int cpu_flags = av_get_cpu_flags();
@@ -228,16 +96,19 @@ av_cold void ff_ac3dsp_init_x86(AC3DSPContext *c, int bit_exact)
         c->float_to_fixed24 = ff_float_to_fixed24_sse2;
         c->compute_mantissa_size = ff_ac3_compute_mantissa_size_sse2;
         c->extract_exponents = ff_ac3_extract_exponents_sse2;
-        if (!(cpu_flags & AV_CPU_FLAG_SSE2SLOW)) {
-            c->ac3_lshift_int16 = ff_ac3_lshift_int16_sse2;
-            c->ac3_rshift_int32 = ff_ac3_rshift_int32_sse2;
-        }
         if (bit_exact) {
             c->apply_window_int16 = ff_apply_window_int16_sse2;
-        } else if (!(cpu_flags & AV_CPU_FLAG_SSE2SLOW)) {
+        }
+    }
+
+    if (EXTERNAL_SSE2_FAST(cpu_flags)) {
+        c->ac3_lshift_int16 = ff_ac3_lshift_int16_sse2;
+        c->ac3_rshift_int32 = ff_ac3_rshift_int32_sse2;
+        if (!bit_exact) {
             c->apply_window_int16 = ff_apply_window_int16_round_sse2;
         }
     }
+
     if (EXTERNAL_SSSE3(cpu_flags)) {
         c->ac3_max_msb_abs_int16 = ff_ac3_max_msb_abs_int16_ssse3;
         if (cpu_flags & AV_CPU_FLAG_ATOM) {
@@ -247,10 +118,47 @@ av_cold void ff_ac3dsp_init_x86(AC3DSPContext *c, int bit_exact)
             c->apply_window_int16 = ff_apply_window_int16_ssse3;
         }
     }
+}
+
+#define DOWNMIX_FUNC_OPT(ch, opt)                                       \
+void ff_ac3_downmix_ ## ch ## _to_1_ ## opt(float **samples,            \
+                                            float **matrix, int len);   \
+void ff_ac3_downmix_ ## ch ## _to_2_ ## opt(float **samples,            \
+                                            float **matrix, int len);
+
+#define DOWNMIX_FUNCS(opt)   \
+    DOWNMIX_FUNC_OPT(3, opt) \
+    DOWNMIX_FUNC_OPT(4, opt) \
+    DOWNMIX_FUNC_OPT(5, opt) \
+    DOWNMIX_FUNC_OPT(6, opt)
+
+DOWNMIX_FUNCS(sse)
+DOWNMIX_FUNCS(avx)
+DOWNMIX_FUNCS(fma3)
+
+void ff_ac3dsp_set_downmix_x86(AC3DSPContext *c)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+#define SET_DOWNMIX(ch, suf, SUF)                                       \
+    if (ch == c->in_channels) {                                         \
+        if (EXTERNAL_ ## SUF (cpu_flags)) {                             \
+            if (c->out_channels == 1)                                   \
+                c->downmix = ff_ac3_downmix_ ## ch ## _to_1_ ## suf;    \
+            else                                                        \
+                c->downmix = ff_ac3_downmix_ ## ch ## _to_2_ ## suf;    \
+        }                                                               \
+    }
+
+#define SET_DOWNMIX_ALL(suf, SUF)                   \
+    SET_DOWNMIX(3, suf, SUF)                        \
+    SET_DOWNMIX(4, suf, SUF)                        \
+    SET_DOWNMIX(5, suf, SUF)                        \
+    SET_DOWNMIX(6, suf, SUF)
 
-#if HAVE_SSE_INLINE && HAVE_7REGS
-    if (INLINE_SSE(cpu_flags)) {
-        c->downmix = ac3_downmix_sse;
+    SET_DOWNMIX_ALL(sse,  SSE)
+    if (!(cpu_flags & AV_CPU_FLAG_AVXSLOW)) {
+        SET_DOWNMIX_ALL(avx,  AVX)
+        SET_DOWNMIX_ALL(fma3, FMA3)
     }
-#endif
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/alacdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/alacdsp_init.c
index de5dae6c773..18f7308a12b 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/alacdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/alacdsp_init.c
@@ -30,7 +30,7 @@ void ff_alac_append_extra_bits_mono_sse2(int32_t *buffer[2], int32_t *extra_bits
 
 av_cold void ff_alacdsp_init_x86(ALACDSPContext *c)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_SSE2(cpu_flags)) {
@@ -40,5 +40,5 @@ av_cold void ff_alacdsp_init_x86(ALACDSPContext *c)
     if (EXTERNAL_SSE4(cpu_flags)) {
         c->decorrelate_stereo   = ff_alac_decorrelate_stereo_sse4;
     }
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/audiodsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/audiodsp.asm
index 3ffb27fcf93..3973808ca51 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/audiodsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/audiodsp.asm
@@ -26,7 +26,7 @@ SECTION .text
 %macro SCALARPRODUCT 0
 ; int ff_scalarproduct_int16(int16_t *v1, int16_t *v2, int order)
 cglobal scalarproduct_int16, 3,3,3, v1, v2, order
-    shl orderq, 1
+    add orderd, orderd
     add v1q, orderq
     add v2q, orderq
     neg orderq
@@ -78,15 +78,15 @@ cglobal vector_clip_int32%5, 5,5,%1, dst, src, min, max, len
 .loop:
 %assign %%i 0
 %rep %2
-    mova      m0,  [srcq+mmsize*(0+%%i)]
-    mova      m1,  [srcq+mmsize*(1+%%i)]
-    mova      m2,  [srcq+mmsize*(2+%%i)]
-    mova      m3,  [srcq+mmsize*(3+%%i)]
+    mova      m0,  [srcq + mmsize * (0 + %%i)]
+    mova      m1,  [srcq + mmsize * (1 + %%i)]
+    mova      m2,  [srcq + mmsize * (2 + %%i)]
+    mova      m3,  [srcq + mmsize * (3 + %%i)]
 %if %3
-    mova      m7,  [srcq+mmsize*(4+%%i)]
-    mova      m8,  [srcq+mmsize*(5+%%i)]
-    mova      m9,  [srcq+mmsize*(6+%%i)]
-    mova      m10, [srcq+mmsize*(7+%%i)]
+    mova      m7,  [srcq + mmsize * (4 + %%i)]
+    mova      m8,  [srcq + mmsize * (5 + %%i)]
+    mova      m9,  [srcq + mmsize * (6 + %%i)]
+    mova      m10, [srcq + mmsize * (7 + %%i)]
 %endif
     CLIPD  m0,  m4, m5, m6
     CLIPD  m1,  m4, m5, m6
@@ -98,17 +98,17 @@ cglobal vector_clip_int32%5, 5,5,%1, dst, src, min, max, len
     CLIPD  m9,  m4, m5, m6
     CLIPD  m10, m4, m5, m6
 %endif
-    mova  [dstq+mmsize*(0+%%i)], m0
-    mova  [dstq+mmsize*(1+%%i)], m1
-    mova  [dstq+mmsize*(2+%%i)], m2
-    mova  [dstq+mmsize*(3+%%i)], m3
+    mova  [dstq + mmsize * (0 + %%i)], m0
+    mova  [dstq + mmsize * (1 + %%i)], m1
+    mova  [dstq + mmsize * (2 + %%i)], m2
+    mova  [dstq + mmsize * (3 + %%i)], m3
 %if %3
-    mova  [dstq+mmsize*(4+%%i)], m7
-    mova  [dstq+mmsize*(5+%%i)], m8
-    mova  [dstq+mmsize*(6+%%i)], m9
-    mova  [dstq+mmsize*(7+%%i)], m10
+    mova  [dstq + mmsize * (4 + %%i)], m7
+    mova  [dstq + mmsize * (5 + %%i)], m8
+    mova  [dstq + mmsize * (6 + %%i)], m9
+    mova  [dstq + mmsize * (7 + %%i)], m10
 %endif
-%assign %%i %%i+4*(%3+1)
+%assign %%i (%%i + 4 * (1 + %3))
 %endrep
     add     srcq, mmsize*4*(%2+%3)
     add     dstq, mmsize*4*(%2+%3)
@@ -132,46 +132,46 @@ VECTOR_CLIP_INT32 11, 1, 1, 0
 VECTOR_CLIP_INT32 6, 1, 0, 0
 %endif
 
-;-----------------------------------------------------
-;void ff_vector_clipf(float *dst, const float *src,
-;                     float min, float max, int len)
-;-----------------------------------------------------
+; void ff_vector_clipf_sse(float *dst, const float *src,
+;                          int len, float min, float max)
 INIT_XMM sse
-%if UNIX64
-cglobal vector_clipf, 3,3,6, dst, src, len
-%else
-cglobal vector_clipf, 5,5,6, dst, src, min, max, len
-%endif
-%if WIN64
-    SWAP 0, 2
-    SWAP 1, 3
-%elif ARCH_X86_32
-    movss   m0, minm
-    movss   m1, maxm
+cglobal vector_clipf, 3, 3, 6, dst, src, len, min, max
+%if ARCH_X86_32
+    VBROADCASTSS m0, minm
+    VBROADCASTSS m1, maxm
+%elif WIN64
+    SWAP 0, 3
+    VBROADCASTSS m0, m0
+    VBROADCASTSS m1, maxm
+%else ; 64bit sysv
+    VBROADCASTSS m0, m0
+    VBROADCASTSS m1, m1
 %endif
-    SPLATD  m0
-    SPLATD  m1
-        shl lend, 2
-        add srcq, lenq
-        add dstq, lenq
-        neg lenq
+
+    movsxdifnidn lenq, lend
+
 .loop:
-    mova    m2,  [srcq+lenq+mmsize*0]
-    mova    m3,  [srcq+lenq+mmsize*1]
-    mova    m4,  [srcq+lenq+mmsize*2]
-    mova    m5,  [srcq+lenq+mmsize*3]
-    maxps   m2, m0
-    maxps   m3, m0
-    maxps   m4, m0
-    maxps   m5, m0
-    minps   m2, m1
-    minps   m3, m1
-    minps   m4, m1
-    minps   m5, m1
-    mova    [dstq+lenq+mmsize*0], m2
-    mova    [dstq+lenq+mmsize*1], m3
-    mova    [dstq+lenq+mmsize*2], m4
-    mova    [dstq+lenq+mmsize*3], m5
-    add     lenq, mmsize*4
-    jl .loop
-    REP_RET
+    mova m2, [srcq + 4 * lenq - 4 * mmsize]
+    mova m3, [srcq + 4 * lenq - 3 * mmsize]
+    mova m4, [srcq + 4 * lenq - 2 * mmsize]
+    mova m5, [srcq + 4 * lenq - 1 * mmsize]
+
+    maxps m2, m0
+    maxps m3, m0
+    maxps m4, m0
+    maxps m5, m0
+
+    minps m2, m1
+    minps m3, m1
+    minps m4, m1
+    minps m5, m1
+
+    mova [dstq + 4 * lenq - 4 * mmsize], m2
+    mova [dstq + 4 * lenq - 3 * mmsize], m3
+    mova [dstq + 4 * lenq - 2 * mmsize], m4
+    mova [dstq + 4 * lenq - 1 * mmsize], m5
+
+    sub lenq, mmsize
+    jg .loop
+
+    RET
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/audiodsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/audiodsp_init.c
index 8f9e604bb24..98e296c264e 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/audiodsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/audiodsp_init.c
@@ -38,7 +38,7 @@ void ff_vector_clip_int32_int_sse2(int32_t *dst, const int32_t *src,
 void ff_vector_clip_int32_sse4(int32_t *dst, const int32_t *src,
                                int32_t min, int32_t max, unsigned int len);
 void ff_vector_clipf_sse(float *dst, const float *src,
-                         float min, float max, int len);
+                         int len, float min, float max);
 
 av_cold void ff_audiodsp_init_x86(AudioDSPContext *c)
 {
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/blockdsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/blockdsp.asm
index 7cbfa3a843b..9d203df8f52 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/blockdsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/blockdsp.asm
@@ -4,6 +4,8 @@
 ;* Copyright (c) 2008 Loren Merritt
 ;* Copyright (c) 2009 Fiona Glaser
 ;*
+;* AVX version by Jokyo Images
+;*
 ;* This file is part of FFmpeg.
 ;*
 ;* FFmpeg is free software; you can redistribute it and/or
@@ -32,27 +34,25 @@ SECTION .text
 ; %2 = number of inline store loops
 %macro CLEAR_BLOCK 2
 cglobal clear_block, 1, 1, %1, blocks
-    ZERO  m0, m0
+    ZERO  m0, m0, m0
 %assign %%i 0
 %rep %2
     mova  [blocksq+mmsize*(0+%%i)], m0
     mova  [blocksq+mmsize*(1+%%i)], m0
     mova  [blocksq+mmsize*(2+%%i)], m0
     mova  [blocksq+mmsize*(3+%%i)], m0
-    mova  [blocksq+mmsize*(4+%%i)], m0
-    mova  [blocksq+mmsize*(5+%%i)], m0
-    mova  [blocksq+mmsize*(6+%%i)], m0
-    mova  [blocksq+mmsize*(7+%%i)], m0
-%assign %%i %%i+8
+%assign %%i %%i+4
 %endrep
     RET
 %endmacro
 
 INIT_MMX mmx
 %define ZERO pxor
-CLEAR_BLOCK 0, 2
+CLEAR_BLOCK 0, 4
 INIT_XMM sse
 %define ZERO xorps
+CLEAR_BLOCK 1, 2
+INIT_YMM avx
 CLEAR_BLOCK 1, 1
 
 ;-----------------------------------------
@@ -63,7 +63,7 @@ CLEAR_BLOCK 1, 1
 cglobal clear_blocks, 1, 2, %1, blocks, len
     add   blocksq, 768
     mov      lenq, -768
-    ZERO       m0, m0
+    ZERO       m0, m0, m0
 .loop:
     mova  [blocksq+lenq+mmsize*0], m0
     mova  [blocksq+lenq+mmsize*1], m0
@@ -84,3 +84,5 @@ CLEAR_BLOCKS 0
 INIT_XMM sse
 %define ZERO xorps
 CLEAR_BLOCKS 1
+INIT_YMM avx
+CLEAR_BLOCKS 1
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/blockdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/blockdsp_init.c
index 21599934ff8..8b01a447cd4 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/blockdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/blockdsp_init.c
@@ -28,13 +28,15 @@
 
 void ff_clear_block_mmx(int16_t *block);
 void ff_clear_block_sse(int16_t *block);
+void ff_clear_block_avx(int16_t *block);
 void ff_clear_blocks_mmx(int16_t *blocks);
 void ff_clear_blocks_sse(int16_t *blocks);
+void ff_clear_blocks_avx(int16_t *blocks);
 
 av_cold void ff_blockdsp_init_x86(BlockDSPContext *c,
                                   AVCodecContext *avctx)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_MMX(cpu_flags)) {
@@ -50,5 +52,9 @@ av_cold void ff_blockdsp_init_x86(BlockDSPContext *c,
         c->clear_block  = ff_clear_block_sse;
         c->clear_blocks = ff_clear_blocks_sse;
     }
-#endif /* HAVE_YASM */
+    if (EXTERNAL_AVX_FAST(cpu_flags)) {
+        c->clear_block  = ff_clear_block_avx;
+        c->clear_blocks = ff_clear_blocks_avx;
+    }
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/cavsdsp.c b/mythtv/external/FFmpeg/libavcodec/x86/cavsdsp.c
index 4b20e655a75..becb3a4808f 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/cavsdsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/cavsdsp.c
@@ -34,172 +34,28 @@
 #include "idctdsp.h"
 #include "config.h"
 
-#if HAVE_MMX_INLINE
 
-/* in/out: mma=mma+mmb, mmb=mmb-mma */
-#define SUMSUB_BA( a, b ) \
-    "paddw "#b", "#a" \n\t"\
-    "paddw "#b", "#b" \n\t"\
-    "psubw "#a", "#b" \n\t"
+#if HAVE_MMX_EXTERNAL
 
-/*****************************************************************************
- *
- * inverse transform
- *
- ****************************************************************************/
+void ff_cavs_idct8_mmx(int16_t *out, const int16_t *in);
 
-static inline void cavs_idct8_1d(int16_t *block, uint64_t bias)
+static void cavs_idct8_add_mmx(uint8_t *dst, int16_t *block, ptrdiff_t stride)
 {
-    __asm__ volatile(
-        "movq 112(%0), %%mm4  \n\t" /* mm4 = src7 */
-        "movq  16(%0), %%mm5  \n\t" /* mm5 = src1 */
-        "movq  80(%0), %%mm2  \n\t" /* mm2 = src5 */
-        "movq  48(%0), %%mm7  \n\t" /* mm7 = src3 */
-        "movq   %%mm4, %%mm0  \n\t"
-        "movq   %%mm5, %%mm3  \n\t"
-        "movq   %%mm2, %%mm6  \n\t"
-        "movq   %%mm7, %%mm1  \n\t"
-
-        "paddw  %%mm4, %%mm4  \n\t" /* mm4 = 2*src7 */
-        "paddw  %%mm3, %%mm3  \n\t" /* mm3 = 2*src1 */
-        "paddw  %%mm6, %%mm6  \n\t" /* mm6 = 2*src5 */
-        "paddw  %%mm1, %%mm1  \n\t" /* mm1 = 2*src3 */
-        "paddw  %%mm4, %%mm0  \n\t" /* mm0 = 3*src7 */
-        "paddw  %%mm3, %%mm5  \n\t" /* mm5 = 3*src1 */
-        "paddw  %%mm6, %%mm2  \n\t" /* mm2 = 3*src5 */
-        "paddw  %%mm1, %%mm7  \n\t" /* mm7 = 3*src3 */
-        "psubw  %%mm4, %%mm5  \n\t" /* mm5 = 3*src1 - 2*src7 = a0 */
-        "paddw  %%mm6, %%mm7  \n\t" /* mm7 = 3*src3 + 2*src5 = a1 */
-        "psubw  %%mm2, %%mm1  \n\t" /* mm1 = 2*src3 - 3*src5 = a2 */
-        "paddw  %%mm0, %%mm3  \n\t" /* mm3 = 2*src1 + 3*src7 = a3 */
-
-        "movq   %%mm5, %%mm4  \n\t"
-        "movq   %%mm7, %%mm6  \n\t"
-        "movq   %%mm3, %%mm0  \n\t"
-        "movq   %%mm1, %%mm2  \n\t"
-        SUMSUB_BA( %%mm7, %%mm5 )   /* mm7 = a0 + a1  mm5 = a0 - a1 */
-        "paddw  %%mm3, %%mm7  \n\t" /* mm7 = a0 + a1 + a3 */
-        "paddw  %%mm1, %%mm5  \n\t" /* mm5 = a0 - a1 + a2 */
-        "paddw  %%mm7, %%mm7  \n\t"
-        "paddw  %%mm5, %%mm5  \n\t"
-        "paddw  %%mm6, %%mm7  \n\t" /* mm7 = b4 */
-        "paddw  %%mm4, %%mm5  \n\t" /* mm5 = b5 */
-
-        SUMSUB_BA( %%mm1, %%mm3 )   /* mm1 = a3 + a2  mm3 = a3 - a2 */
-        "psubw  %%mm1, %%mm4  \n\t" /* mm4 = a0 - a2 - a3 */
-        "movq   %%mm4, %%mm1  \n\t" /* mm1 = a0 - a2 - a3 */
-        "psubw  %%mm6, %%mm3  \n\t" /* mm3 = a3 - a2 - a1 */
-        "paddw  %%mm1, %%mm1  \n\t"
-        "paddw  %%mm3, %%mm3  \n\t"
-        "psubw  %%mm2, %%mm1  \n\t" /* mm1 = b7 */
-        "paddw  %%mm0, %%mm3  \n\t" /* mm3 = b6 */
-
-        "movq  32(%0), %%mm2  \n\t" /* mm2 = src2 */
-        "movq  96(%0), %%mm6  \n\t" /* mm6 = src6 */
-        "movq   %%mm2, %%mm4  \n\t"
-        "movq   %%mm6, %%mm0  \n\t"
-        "psllw  $2,    %%mm4  \n\t" /* mm4 = 4*src2 */
-        "psllw  $2,    %%mm6  \n\t" /* mm6 = 4*src6 */
-        "paddw  %%mm4, %%mm2  \n\t" /* mm2 = 5*src2 */
-        "paddw  %%mm6, %%mm0  \n\t" /* mm0 = 5*src6 */
-        "paddw  %%mm2, %%mm2  \n\t"
-        "paddw  %%mm0, %%mm0  \n\t"
-        "psubw  %%mm0, %%mm4  \n\t" /* mm4 = 4*src2 - 10*src6 = a7 */
-        "paddw  %%mm2, %%mm6  \n\t" /* mm6 = 4*src6 + 10*src2 = a6 */
-
-        "movq    (%0), %%mm2  \n\t" /* mm2 = src0 */
-        "movq  64(%0), %%mm0  \n\t" /* mm0 = src4 */
-        SUMSUB_BA( %%mm0, %%mm2 )   /* mm0 = src0+src4  mm2 = src0-src4 */
-        "psllw  $3,    %%mm0  \n\t"
-        "psllw  $3,    %%mm2  \n\t"
-        "paddw  %1,    %%mm0  \n\t" /* add rounding bias */
-        "paddw  %1,    %%mm2  \n\t" /* add rounding bias */
-
-        SUMSUB_BA( %%mm6, %%mm0 )   /* mm6 = a4 + a6  mm0 = a4 - a6 */
-        SUMSUB_BA( %%mm4, %%mm2 )   /* mm4 = a5 + a7  mm2 = a5 - a7 */
-        SUMSUB_BA( %%mm7, %%mm6 )   /* mm7 = dst0  mm6 = dst7 */
-        SUMSUB_BA( %%mm5, %%mm4 )   /* mm5 = dst1  mm4 = dst6 */
-        SUMSUB_BA( %%mm3, %%mm2 )   /* mm3 = dst2  mm2 = dst5 */
-        SUMSUB_BA( %%mm1, %%mm0 )   /* mm1 = dst3  mm0 = dst4 */
-        :: "r"(block), "m"(bias)
-    );
+    LOCAL_ALIGNED(16, int16_t, b2, [64]);
+    ff_cavs_idct8_mmx(b2, block);
+    ff_add_pixels_clamped_mmx(b2, dst, stride);
 }
 
-#define SBUTTERFLY(a,b,t,n,m)\
-    "mov" #m " " #a ", " #t "         \n\t" /* abcd */\
-    "punpckl" #n " " #b ", " #a "     \n\t" /* aebf */\
-    "punpckh" #n " " #b ", " #t "     \n\t" /* cgdh */\
+void ff_cavs_idct8_sse2(int16_t *out, const int16_t *in);
 
-#define TRANSPOSE4(a,b,c,d,t)\
-    SBUTTERFLY(a,b,t,wd,q) /* a=aebf t=cgdh */\
-    SBUTTERFLY(c,d,b,wd,q) /* c=imjn b=kolp */\
-    SBUTTERFLY(a,c,d,dq,q) /* a=aeim d=bfjn */\
-    SBUTTERFLY(t,b,c,dq,q) /* t=cgko c=dhlp */
-
-static void cavs_idct8_add_mmx(uint8_t *dst, int16_t *block, int stride)
+static void cavs_idct8_add_sse2(uint8_t *dst, int16_t *block, ptrdiff_t stride)
 {
-    int i;
     LOCAL_ALIGNED(16, int16_t, b2, [64]);
-
-    for(i=0; i<2; i++){
-        cavs_idct8_1d(block + 4 * i, ff_pw_4.a);
-
-        __asm__ volatile(
-            "psraw     $3, %%mm7  \n\t"
-            "psraw     $3, %%mm6  \n\t"
-            "psraw     $3, %%mm5  \n\t"
-            "psraw     $3, %%mm4  \n\t"
-            "psraw     $3, %%mm3  \n\t"
-            "psraw     $3, %%mm2  \n\t"
-            "psraw     $3, %%mm1  \n\t"
-            "psraw     $3, %%mm0  \n\t"
-            "movq   %%mm7,  (%0)  \n\t"
-            TRANSPOSE4( %%mm0, %%mm2, %%mm4, %%mm6, %%mm7 )
-            "movq   %%mm0,  8(%0)  \n\t"
-            "movq   %%mm6, 24(%0)  \n\t"
-            "movq   %%mm7, 40(%0)  \n\t"
-            "movq   %%mm4, 56(%0)  \n\t"
-            "movq    (%0),  %%mm7  \n\t"
-            TRANSPOSE4( %%mm7, %%mm5, %%mm3, %%mm1, %%mm0 )
-            "movq   %%mm7,   (%0)  \n\t"
-            "movq   %%mm1, 16(%0)  \n\t"
-            "movq   %%mm0, 32(%0)  \n\t"
-            "movq   %%mm3, 48(%0)  \n\t"
-            :
-            : "r"(b2 + 32 * i)
-            : "memory"
-        );
-    }
-
-    for(i=0; i<2; i++){
-        cavs_idct8_1d(b2+4*i, ff_pw_64.a);
-
-        __asm__ volatile(
-            "psraw     $7, %%mm7  \n\t"
-            "psraw     $7, %%mm6  \n\t"
-            "psraw     $7, %%mm5  \n\t"
-            "psraw     $7, %%mm4  \n\t"
-            "psraw     $7, %%mm3  \n\t"
-            "psraw     $7, %%mm2  \n\t"
-            "psraw     $7, %%mm1  \n\t"
-            "psraw     $7, %%mm0  \n\t"
-            "movq   %%mm7,    (%0)  \n\t"
-            "movq   %%mm5,  16(%0)  \n\t"
-            "movq   %%mm3,  32(%0)  \n\t"
-            "movq   %%mm1,  48(%0)  \n\t"
-            "movq   %%mm0,  64(%0)  \n\t"
-            "movq   %%mm2,  80(%0)  \n\t"
-            "movq   %%mm4,  96(%0)  \n\t"
-            "movq   %%mm6, 112(%0)  \n\t"
-            :: "r"(b2+4*i)
-            : "memory"
-        );
-    }
-
-    ff_add_pixels_clamped(b2, dst, stride);
+    ff_cavs_idct8_sse2(b2, block);
+    ff_add_pixels_clamped_sse2(b2, dst, stride);
 }
 
-#endif /* HAVE_MMX_INLINE */
+#endif /* HAVE_MMX_EXTERNAL */
 
 #if (HAVE_MMXEXT_INLINE || HAVE_AMD3DNOW_INLINE)
 
@@ -334,7 +190,8 @@ static void cavs_idct8_add_mmx(uint8_t *dst, int16_t *block, int stride)
    }
 
 #define QPEL_CAVS(OPNAME, OP, MMX)\
-static void OPNAME ## cavs_qpel8_h_ ## MMX(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_qpel8_h_ ## MMX(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{\
     int h=8;\
     __asm__ volatile(\
         "pxor %%mm7, %%mm7          \n\t"\
@@ -382,43 +239,53 @@ static void OPNAME ## cavs_qpel8_h_ ## MMX(uint8_t *dst, const uint8_t *src, int
     );\
 }\
 \
-static inline void OPNAME ## cavs_qpel8or16_v1_ ## MMX(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h){\
+static inline void OPNAME ## cavs_qpel8or16_v1_ ## MMX(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)\
+{                                                                       \
   QPEL_CAVSVNUM(QPEL_CAVSV1,OP,ff_pw_64,ff_pw_96,ff_pw_42)      \
 }\
 \
-static inline void OPNAME ## cavs_qpel8or16_v2_ ## MMX(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h){\
+static inline void OPNAME ## cavs_qpel8or16_v2_ ## MMX(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)\
+{                                                                       \
   QPEL_CAVSVNUM(QPEL_CAVSV2,OP,ff_pw_4,ff_pw_5,ff_pw_42)        \
 }\
 \
-static inline void OPNAME ## cavs_qpel8or16_v3_ ## MMX(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h){\
+static inline void OPNAME ## cavs_qpel8or16_v3_ ## MMX(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)\
+{                                                                       \
   QPEL_CAVSVNUM(QPEL_CAVSV3,OP,ff_pw_64,ff_pw_96,ff_pw_42)      \
 }\
 \
-static void OPNAME ## cavs_qpel8_v1_ ## MMX(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_qpel8_v1_ ## MMX(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     OPNAME ## cavs_qpel8or16_v1_ ## MMX(dst  , src  , dstStride, srcStride, 8);\
 }\
-static void OPNAME ## cavs_qpel16_v1_ ## MMX(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_qpel16_v1_ ## MMX(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     OPNAME ## cavs_qpel8or16_v1_ ## MMX(dst  , src  , dstStride, srcStride, 16);\
     OPNAME ## cavs_qpel8or16_v1_ ## MMX(dst+8, src+8, dstStride, srcStride, 16);\
 }\
 \
-static void OPNAME ## cavs_qpel8_v2_ ## MMX(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_qpel8_v2_ ## MMX(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     OPNAME ## cavs_qpel8or16_v2_ ## MMX(dst  , src  , dstStride, srcStride, 8);\
 }\
-static void OPNAME ## cavs_qpel16_v2_ ## MMX(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_qpel16_v2_ ## MMX(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     OPNAME ## cavs_qpel8or16_v2_ ## MMX(dst  , src  , dstStride, srcStride, 16);\
     OPNAME ## cavs_qpel8or16_v2_ ## MMX(dst+8, src+8, dstStride, srcStride, 16);\
 }\
 \
-static void OPNAME ## cavs_qpel8_v3_ ## MMX(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_qpel8_v3_ ## MMX(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     OPNAME ## cavs_qpel8or16_v3_ ## MMX(dst  , src  , dstStride, srcStride, 8);\
 }\
-static void OPNAME ## cavs_qpel16_v3_ ## MMX(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_qpel16_v3_ ## MMX(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     OPNAME ## cavs_qpel8or16_v3_ ## MMX(dst  , src  , dstStride, srcStride, 16);\
     OPNAME ## cavs_qpel8or16_v3_ ## MMX(dst+8, src+8, dstStride, srcStride, 16);\
 }\
 \
-static void OPNAME ## cavs_qpel16_h_ ## MMX(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride){\
+static void OPNAME ## cavs_qpel16_h_ ## MMX(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride)\
+{                                                                       \
     OPNAME ## cavs_qpel8_h_ ## MMX(dst  , src  , dstStride, srcStride);\
     OPNAME ## cavs_qpel8_h_ ## MMX(dst+8, src+8, dstStride, srcStride);\
     src += 8*srcStride;\
@@ -518,12 +385,10 @@ static av_cold void cavsdsp_init_mmx(CAVSDSPContext *c,
     c->put_cavs_qpel_pixels_tab[1][0] = put_cavs_qpel8_mc00_mmx;
     c->avg_cavs_qpel_pixels_tab[0][0] = avg_cavs_qpel16_mc00_mmx;
     c->avg_cavs_qpel_pixels_tab[1][0] = avg_cavs_qpel8_mc00_mmx;
-#endif
 
-#if HAVE_MMX_INLINE
     c->cavs_idct8_add = cavs_idct8_add_mmx;
     c->idct_perm      = FF_IDCT_PERM_TRANSPOSE;
-#endif /* HAVE_MMX_INLINE */
+#endif /* HAVE_MMX_EXTERNAL */
 }
 
 #define DSPFUNC(PFX, IDX, NUM, EXT)                                                       \
@@ -565,7 +430,9 @@ av_cold void ff_cavsdsp_init_x86(CAVSDSPContext *c, AVCodecContext *avctx)
 {
     av_unused int cpu_flags = av_get_cpu_flags();
 
-    cavsdsp_init_mmx(c, avctx);
+    if (X86_MMX(cpu_flags))
+        cavsdsp_init_mmx(c, avctx);
+
 #if HAVE_AMD3DNOW_INLINE
     if (INLINE_AMD3DNOW(cpu_flags))
         cavsdsp_init_3dnow(c, avctx);
@@ -588,6 +455,9 @@ av_cold void ff_cavsdsp_init_x86(CAVSDSPContext *c, AVCodecContext *avctx)
     if (EXTERNAL_SSE2(cpu_flags)) {
         c->put_cavs_qpel_pixels_tab[0][0] = put_cavs_qpel16_mc00_sse2;
         c->avg_cavs_qpel_pixels_tab[0][0] = avg_cavs_qpel16_mc00_sse2;
+
+        c->cavs_idct8_add = cavs_idct8_add_sse2;
+        c->idct_perm      = FF_IDCT_PERM_TRANSPOSE;
     }
 #endif
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/cavsidct.asm b/mythtv/external/FFmpeg/libavcodec/x86/cavsidct.asm
new file mode 100644
index 00000000000..6c768c26468
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/cavsidct.asm
@@ -0,0 +1,211 @@
+; Chinese AVS video (AVS1-P2, JiZhun profile) decoder
+; Copyright (c) 2006  Stefan Gehrer <stefan.gehrer@gmx.de>
+;
+; MMX-optimized DSP functions, based on H.264 optimizations by
+; Michael Niedermayer and Loren Merritt
+; Conversion from gcc syntax to x264asm syntax with modifications
+; by Ronald S. Bultje <rsbultje@gmail.com>
+;
+; 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/x86/x86util.asm"
+
+cextern pw_4
+cextern pw_64
+
+SECTION .text
+
+%macro CAVS_IDCT8_1D 2-3 1 ; source, round, init_load
+%if %3 == 1
+    mova            m4, [%1+7*16]       ; m4 = src7
+    mova            m5, [%1+1*16]       ; m5 = src1
+    mova            m2, [%1+5*16]       ; m2 = src5
+    mova            m7, [%1+3*16]       ; m7 = src3
+%else
+    SWAP             1, 7
+    SWAP             4, 6
+%endif
+    mova            m0, m4
+    mova            m3, m5
+    mova            m6, m2
+    mova            m1, m7
+
+    paddw           m4, m4              ; m4 = 2*src7
+    paddw           m3, m3              ; m3 = 2*src1
+    paddw           m6, m6              ; m6 = 2*src5
+    paddw           m1, m1              ; m1 = 2*src3
+    paddw           m0, m4              ; m0 = 3*src7
+    paddw           m5, m3              ; m5 = 3*src1
+    paddw           m2, m6              ; m2 = 3*src5
+    paddw           m7, m1              ; m7 = 3*src3
+    psubw           m5, m4              ; m5 = 3*src1 - 2*src7 = a0
+    paddw           m7, m6              ; m7 = 3*src3 - 2*src5 = a1
+    psubw           m1, m2              ; m1 = 2*src3 - 3*src5 = a2
+    paddw           m3, m0              ; m3 = 2*src1 - 3*src7 = a3
+
+    mova            m4, m5
+    mova            m6, m7
+    mova            m0, m3
+    mova            m2, m1
+    SUMSUB_BA     w, 7, 5               ; m7 = a0 + a1, m5 = a0 - a1
+    paddw           m7, m3              ; m7 = a0 + a1 + a3
+    paddw           m5, m1              ; m5 = a0 - a1 + a2
+    paddw           m7, m7
+    paddw           m5, m5
+    paddw           m7, m6              ; m7 = b4
+    paddw           m5, m4              ; m5 = b5
+
+    SUMSUB_BA     w, 1, 3               ; m1 = a3 + a2, m3 = a3 - a2
+    psubw           m4, m1              ; m4 = a0 - a2 - a3
+    mova            m1, m4              ; m1 = a0 - a2 - a3
+    psubw           m3, m6              ; m3 = a3 - a2 - a1
+    paddw           m1, m1
+    paddw           m3, m3
+    psubw           m1, m2              ; m1 = b7
+    paddw           m3, m0              ; m3 = b6
+
+    mova            m2, [%1+2*16]       ; m2 = src2
+    mova            m6, [%1+6*16]       ; m6 = src6
+    mova            m4, m2
+    mova            m0, m6
+    psllw           m4, 2               ; m4 = 4*src2
+    psllw           m6, 2               ; m6 = 4*src6
+    paddw           m2, m4              ; m2 = 5*src2
+    paddw           m0, m6              ; m0 = 5*src6
+    paddw           m2, m2
+    paddw           m0, m0
+    psubw           m4, m0              ; m4 = 4*src2 - 10*src6 = a7
+    paddw           m6, m2              ; m6 = 4*src6 + 10*src2 = a6
+
+    mova            m2, [%1+0*16]       ; m2 = src0
+    mova            m0, [%1+4*16]       ; m0 = src4
+    SUMSUB_BA     w, 0, 2               ; m0 = src0 + src4, m2 = src0 - src4
+    psllw           m0, 3
+    psllw           m2, 3
+    paddw           m0, %2              ; add rounding bias
+    paddw           m2, %2              ; add rounding bias
+
+    SUMSUB_BA     w, 6, 0               ; m6 = a4 + a6, m0 = a4 - a6
+    SUMSUB_BA     w, 4, 2               ; m4 = a5 + a7, m2 = a5 - a7
+    SUMSUB_BA     w, 7, 6               ; m7 = dst0, m6 = dst7
+    SUMSUB_BA     w, 5, 4               ; m5 = dst1, m4 = dst6
+    SUMSUB_BA     w, 3, 2               ; m3 = dst2, m2 = dst5
+    SUMSUB_BA     w, 1, 0               ; m1 = dst3, m0 = dst4
+%endmacro
+
+INIT_MMX mmx
+cglobal cavs_idct8, 2, 4, 8, 8 * 16, out, in, cnt, tmp
+    mov           cntd, 2
+    mov           tmpq, rsp
+
+.loop_1:
+    CAVS_IDCT8_1D  inq, [pw_4]
+    psraw           m7, 3
+    psraw           m6, 3
+    psraw           m5, 3
+    psraw           m4, 3
+    psraw           m3, 3
+    psraw           m2, 3
+    psraw           m1, 3
+    psraw           m0, 3
+    mova        [tmpq], m7
+    TRANSPOSE4x4W    0, 2, 4, 6, 7
+    mova    [tmpq+1*8], m0
+    mova    [tmpq+3*8], m2
+    mova    [tmpq+5*8], m4
+    mova    [tmpq+7*8], m6
+    mova            m7, [tmpq]
+    TRANSPOSE4x4W    7, 5, 3, 1, 0
+    mova    [tmpq+0*8], m7
+    mova    [tmpq+2*8], m5
+    mova    [tmpq+4*8], m3
+    mova    [tmpq+6*8], m1
+
+    add            inq, mmsize
+    add           tmpq, 64
+    dec           cntd
+    jg .loop_1
+
+    mov           cntd, 2
+    mov           tmpq, rsp
+.loop_2:
+    CAVS_IDCT8_1D tmpq, [pw_64]
+    psraw           m7, 7
+    psraw           m6, 7
+    psraw           m5, 7
+    psraw           m4, 7
+    psraw           m3, 7
+    psraw           m2, 7
+    psraw           m1, 7
+    psraw           m0, 7
+
+    mova   [outq+0*16], m7
+    mova   [outq+1*16], m5
+    mova   [outq+2*16], m3
+    mova   [outq+3*16], m1
+    mova   [outq+4*16], m0
+    mova   [outq+5*16], m2
+    mova   [outq+6*16], m4
+    mova   [outq+7*16], m6
+
+    add           outq, mmsize
+    add           tmpq, mmsize
+    dec           cntd
+    jg .loop_2
+
+    RET
+
+INIT_XMM sse2
+cglobal cavs_idct8, 2, 2, 8 + ARCH_X86_64, 0 - 8 * 16, out, in
+    CAVS_IDCT8_1D  inq, [pw_4]
+    psraw           m7, 3
+    psraw           m6, 3
+    psraw           m5, 3
+    psraw           m4, 3
+    psraw           m3, 3
+    psraw           m2, 3
+    psraw           m1, 3
+    psraw           m0, 3
+%if ARCH_X86_64
+    TRANSPOSE8x8W    7, 5, 3, 1, 0, 2, 4, 6, 8
+    mova    [rsp+4*16], m0
+%else
+    mova    [rsp+0*16], m4
+    TRANSPOSE8x8W    7, 5, 3, 1, 0, 2, 4, 6, [rsp+0*16], [rsp+4*16], 1
+%endif
+    mova    [rsp+0*16], m7
+    mova    [rsp+2*16], m3
+    mova    [rsp+6*16], m4
+    CAVS_IDCT8_1D  rsp, [pw_64], 0
+    psraw           m7, 7
+    psraw           m6, 7
+    psraw           m5, 7
+    psraw           m4, 7
+    psraw           m3, 7
+    psraw           m2, 7
+    psraw           m1, 7
+    psraw           m0, 7
+
+    mova   [outq+0*16], m7
+    mova   [outq+1*16], m5
+    mova   [outq+2*16], m3
+    mova   [outq+3*16], m1
+    mova   [outq+4*16], m0
+    mova   [outq+5*16], m2
+    mova   [outq+6*16], m4
+    mova   [outq+7*16], m6
+    RET
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/constants.h b/mythtv/external/FFmpeg/libavcodec/x86/constants.h
index b82aef9a47d..bbb0ef844aa 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/constants.h
+++ b/mythtv/external/FFmpeg/libavcodec/x86/constants.h
@@ -43,6 +43,7 @@ extern const xmm_reg  ff_pw_64;
 extern const uint64_t ff_pw_96;
 extern const uint64_t ff_pw_128;
 extern const ymm_reg  ff_pw_255;
+extern const ymm_reg  ff_pw_256;
 extern const ymm_reg  ff_pw_512;
 extern const ymm_reg  ff_pw_1023;
 extern const ymm_reg  ff_pw_1024;
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/dirac_dwt.asm b/mythtv/external/FFmpeg/libavcodec/x86/dirac_dwt.asm
index 89806899a29..22a5c2bbbb4 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/dirac_dwt.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/dirac_dwt.asm
@@ -29,7 +29,7 @@ cextern pw_2
 cextern pw_8
 cextern pw_16
 
-section .text
+SECTION .text
 
 ; %1 -= (%2 + %3 + 2)>>2     %4 is pw_2
 %macro COMPOSE_53iL0 4
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/dirac_dwt_init.c b/mythtv/external/FFmpeg/libavcodec/x86/dirac_dwt_init.c
index afdf0a14155..49a6380add2 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/dirac_dwt_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/dirac_dwt_init.c
@@ -133,7 +133,7 @@ static void horizontal_compose_haar1i##ext(uint8_t *_b, uint8_t *_tmp, int w)\
 }\
 \
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 #if !ARCH_X86_64
 COMPOSE_VERTICAL(_mmx, 4)
 #endif
@@ -160,7 +160,7 @@ static void horizontal_compose_dd97i_ssse3(uint8_t *_b, uint8_t *_tmp, int w)
 
 void ff_spatial_idwt_init_x86(DWTContext *d, enum dwt_type type)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
   int mm_flags = av_get_cpu_flags();
 
 #if !ARCH_X86_64
@@ -225,5 +225,5 @@ void ff_spatial_idwt_init_x86(DWTContext *d, enum dwt_type type)
         d->horizontal_compose = horizontal_compose_dd97i_ssse3;
         break;
     }
-#endif // HAVE_YASM
+#endif // HAVE_X86ASM
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/diracdsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/diracdsp.asm
index 6b3f780e412..cc8a26fca5f 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/diracdsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/diracdsp.asm
@@ -30,7 +30,7 @@ cextern pw_16
 cextern pw_32
 cextern pb_80
 
-section .text
+SECTION .text
 
 %macro UNPACK_ADD 6
     mov%5   %1, %3
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/diracdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/diracdsp_init.c
index b1951137891..8cb84eb74c1 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/diracdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/diracdsp_init.c
@@ -49,7 +49,7 @@ void ff_put_signed_rect_clamped_10_sse4(uint8_t *dst, int dst_stride, const uint
 
 void ff_dequant_subband_32_sse4(uint8_t *src, uint8_t *dst, ptrdiff_t stride, const int qf, const int qs, int tot_v, int tot_h);
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 
 #define HPEL_FILTER(MMSIZE, EXT)                                                             \
     void ff_dirac_hpel_filter_v_ ## EXT(uint8_t *, const uint8_t *, int, int);               \
@@ -138,7 +138,7 @@ void ff_avg_dirac_pixels32_sse2(uint8_t *dst, const uint8_t *src[5], int stride,
     }
 }
 
-#else // HAVE_YASM
+#else // HAVE_X86ASM
 
 #define HPEL_FILTER(MMSIZE, EXT)                                                     \
     void dirac_hpel_filter_ ## EXT(uint8_t *dsth, uint8_t *dstv, uint8_t *dstc,              \
@@ -146,7 +146,7 @@ void ff_avg_dirac_pixels32_sse2(uint8_t *dst, const uint8_t *src[5], int stride,
 
 #define PIXFUNC(PFX, IDX, EXT) do {} while (0)
 
-#endif // HAVE_YASM
+#endif // HAVE_X86ASM
 
 #if !ARCH_X86_64
 HPEL_FILTER(8, mmx)
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/dnxhdenc.asm b/mythtv/external/FFmpeg/libavcodec/x86/dnxhdenc.asm
index 9dd6d51ee65..b4f759552e4 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/dnxhdenc.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/dnxhdenc.asm
@@ -22,7 +22,7 @@
 
 %include "libavutil/x86/x86util.asm"
 
-section .text
+SECTION .text
 
 ; void get_pixels_8x4_sym_sse2(int16_t *block, const uint8_t *pixels,
 ;                              ptrdiff_t line_size)
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/exrdsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/exrdsp.asm
new file mode 100644
index 00000000000..23c9397ef8f
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/exrdsp.asm
@@ -0,0 +1,122 @@
+;******************************************************************************
+;* X86 Optimized functions for Open Exr Decoder
+;* Copyright (c) 2006 Industrial Light & Magic, a division of Lucas Digital Ltd. LLC
+;*
+;* reorder_pixels, predictor based on patch by John Loy
+;* port to ASM by Jokyo Images support by CNC - French National Center for Cinema
+;*
+;* predictor AVX/AVX2 by Henrik Gramner
+;*
+;* 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/x86/x86util.asm"
+
+cextern pb_15
+cextern pb_80
+
+SECTION .text
+
+;------------------------------------------------------------------------------
+; void ff_reorder_pixels(uint8_t *dst, const uint8_t *src, ptrdiff_t size);
+;------------------------------------------------------------------------------
+
+%macro REORDER_PIXELS 0
+cglobal reorder_pixels, 3,4,3, dst, src1, size, src2
+    lea                              src2q, [src1q+sizeq] ; src2 = src + 2 * half_size
+    add                               dstq, sizeq         ; dst offset by size
+    shr                              sizeq, 1             ; half_size
+    add                              src1q, sizeq         ; offset src by half_size
+    neg                              sizeq                ; size = offset for dst, src1, src2
+.loop:
+
+    mova                                m0, [src1q+sizeq]        ; load first part
+    movu                                m1, [src2q+sizeq]        ; load second part
+    SBUTTERFLY bw, 0, 1, 2                                       ; interleaved
+    mova                 [dstq+2*sizeq   ], xm0                  ; copy to dst
+    mova                 [dstq+2*sizeq+16], xm1
+%if cpuflag(avx2)
+    vperm2i128                          m0, m0, m1, q0301
+    mova                 [dstq+2*sizeq+32], m0
+%endif
+    add     sizeq, mmsize
+    jl .loop
+    RET
+%endmacro
+
+INIT_XMM sse2
+REORDER_PIXELS
+
+%if HAVE_AVX2_EXTERNAL
+INIT_YMM avx2
+REORDER_PIXELS
+%endif
+
+
+;------------------------------------------------------------------------------
+; void ff_predictor(uint8_t *src, ptrdiff_t size);
+;------------------------------------------------------------------------------
+
+%macro PREDICTOR 0
+cglobal predictor, 2,2,5, src, size
+%if mmsize == 32
+    vbroadcasti128   m0, [pb_80]
+%else
+    mova            xm0, [pb_80]
+%endif
+    mova            xm1, [pb_15]
+    mova            xm2, xm0
+    add            srcq, sizeq
+    neg           sizeq
+.loop:
+    pxor             m3, m0, [srcq + sizeq]
+    pslldq           m4, m3, 1
+    paddb            m3, m4
+    pslldq           m4, m3, 2
+    paddb            m3, m4
+    pslldq           m4, m3, 4
+    paddb            m3, m4
+    pslldq           m4, m3, 8
+%if mmsize == 32
+    paddb            m3, m4
+    paddb           xm2, xm3
+    vextracti128    xm4, m3, 1
+    mova [srcq + sizeq], xm2
+    pshufb          xm2, xm1
+    paddb           xm2, xm4
+    mova [srcq + sizeq + 16], xm2
+%else
+    paddb            m2, m3
+    paddb            m2, m4
+    mova [srcq + sizeq], m2
+%endif
+    pshufb          xm2, xm1
+    add           sizeq, mmsize
+    jl .loop
+    RET
+%endmacro
+
+INIT_XMM ssse3
+PREDICTOR
+
+INIT_XMM avx
+PREDICTOR
+
+%if HAVE_AVX2_EXTERNAL
+INIT_YMM avx2
+PREDICTOR
+%endif
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/exrdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/exrdsp_init.c
new file mode 100644
index 00000000000..63b3480d8ff
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/exrdsp_init.c
@@ -0,0 +1,52 @@
+/*
+ * OpenEXR (.exr) image decoder
+ *
+ * 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 "libavutil/x86/cpu.h"
+#include "libavcodec/exrdsp.h"
+
+void ff_reorder_pixels_sse2(uint8_t *dst, const uint8_t *src, ptrdiff_t size);
+
+void ff_reorder_pixels_avx2(uint8_t *dst, const uint8_t *src, ptrdiff_t size);
+
+void ff_predictor_ssse3(uint8_t *src, ptrdiff_t size);
+
+void ff_predictor_avx(uint8_t *src, ptrdiff_t size);
+
+void ff_predictor_avx2(uint8_t *src, ptrdiff_t size);
+
+av_cold void ff_exrdsp_init_x86(ExrDSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (EXTERNAL_SSE2(cpu_flags)) {
+        dsp->reorder_pixels = ff_reorder_pixels_sse2;
+    }
+    if (EXTERNAL_SSSE3(cpu_flags)) {
+        dsp->predictor = ff_predictor_ssse3;
+    }
+    if (EXTERNAL_AVX(cpu_flags)) {
+        dsp->predictor = ff_predictor_avx;
+    }
+    if (EXTERNAL_AVX2_FAST(cpu_flags)) {
+        dsp->reorder_pixels = ff_reorder_pixels_avx2;
+        dsp->predictor      = ff_predictor_avx2;
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/flacdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/flacdsp_init.c
index e28c5c93228..1971f81b8de 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/flacdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/flacdsp_init.c
@@ -53,7 +53,7 @@ DECORRELATE_FUNCS(32,  avx);
 av_cold void ff_flacdsp_init_x86(FLACDSPContext *c, enum AVSampleFormat fmt, int channels,
                                  int bps)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
 #if CONFIG_FLAC_DECODER
@@ -111,5 +111,5 @@ av_cold void ff_flacdsp_init_x86(FLACDSPContext *c, enum AVSampleFormat fmt, int
             c->lpc16_encode = ff_flac_enc_lpc_16_sse4;
     }
 #endif
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/fmtconvert_init.c b/mythtv/external/FFmpeg/libavcodec/x86/fmtconvert_init.c
index 6d35377a774..df097054e40 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/fmtconvert_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/fmtconvert_init.c
@@ -27,7 +27,7 @@
 #include "libavutil/x86/cpu.h"
 #include "libavcodec/fmtconvert.h"
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 
 void ff_int32_to_float_fmul_scalar_sse (float *dst, const int32_t *src, float mul, int len);
 void ff_int32_to_float_fmul_scalar_sse2(float *dst, const int32_t *src, float mul, int len);
@@ -36,11 +36,11 @@ void ff_int32_to_float_fmul_array8_sse (FmtConvertContext *c, float *dst, const
 void ff_int32_to_float_fmul_array8_sse2(FmtConvertContext *c, float *dst, const int32_t *src,
                                         const float *mul, int len);
 
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 av_cold void ff_fmt_convert_init_x86(FmtConvertContext *c, AVCodecContext *avctx)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_SSE(cpu_flags)) {
@@ -51,5 +51,5 @@ av_cold void ff_fmt_convert_init_x86(FmtConvertContext *c, AVCodecContext *avctx
         c->int32_to_float_fmul_scalar = ff_int32_to_float_fmul_scalar_sse2;
         c->int32_to_float_fmul_array8 = ff_int32_to_float_fmul_array8_sse2;
     }
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/fpel.asm b/mythtv/external/FFmpeg/libavcodec/x86/fpel.asm
index 0e3b444e2af..961a1587a75 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/fpel.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/fpel.asm
@@ -48,7 +48,6 @@ SECTION .text
 %define LEN  %2
 %endif
 cglobal %1_pixels%2, 4,5,4
-    movsxdifnidn r2, r2d
     lea          r4, [r2*3]
 %ifidn %1, avg
 %if notcpuflag(mmxext)
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264_i386.h b/mythtv/external/FFmpeg/libavcodec/x86/h264_cabac.c
similarity index 98%
rename from mythtv/external/FFmpeg/libavcodec/x86/h264_i386.h
rename to mythtv/external/FFmpeg/libavcodec/x86/h264_cabac.c
index 19cd1283813..2edc6d7e744 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264_i386.h
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264_cabac.c
@@ -22,13 +22,10 @@
 /**
  * @file
  * H.264 / AVC / MPEG-4 part10 codec.
- * non-MMX i386-specific optimizations for H.264
+ * non-SIMD x86-specific optimizations for H.264
  * @author Michael Niedermayer <michaelni@gmx.at>
  */
 
-#ifndef AVCODEC_X86_H264_I386_H
-#define AVCODEC_X86_H264_I386_H
-
 #include <stddef.h>
 
 #include "libavcodec/cabac.h"
@@ -209,4 +206,3 @@ static int decode_significance_8x8_x86(CABACContext *c,
 #endif /* HAVE_7REGS && BROKEN_COMPILER */
 
 #endif /* HAVE_INLINE_ASM */
-#endif /* AVCODEC_X86_H264_I386_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264_chromamc.asm b/mythtv/external/FFmpeg/libavcodec/x86/h264_chromamc.asm
index fa698e561fb..b5a78b537d1 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264_chromamc.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264_chromamc.asm
@@ -105,11 +105,8 @@ SECTION .text
 %endif ; rv40
 ; void ff_put/avg_h264_chroma_mc8_*(uint8_t *dst /* align 8 */,
 ;                                   uint8_t *src /* align 1 */,
-;                                   int stride, int h, int mx, int my)
+;                                   ptrdiff_t stride, int h, int mx, int my)
 cglobal %1_%2_chroma_mc8%3, 6, 7 + extra_regs, 0
-%if ARCH_X86_64
-    movsxd        r2, r2d
-%endif
     mov          r6d, r5d
     or           r6d, r4d
     jne .at_least_one_non_zero
@@ -291,9 +288,6 @@ cglobal %1_%2_chroma_mc8%3, 6, 7 + extra_regs, 0
 %endif ; PIC
 %endif ; rv40
 cglobal %1_%2_chroma_mc4, 6, 6 + extra_regs, 0
-%if ARCH_X86_64
-    movsxd        r2, r2d
-%endif
     pxor          m7, m7
     movd          m2, r4d         ; x
     movd          m3, r5d         ; y
@@ -376,10 +370,6 @@ cglobal %1_%2_chroma_mc4, 6, 6 + extra_regs, 0
 
 %macro chroma_mc2_mmx_func 2
 cglobal %1_%2_chroma_mc2, 6, 7, 0
-%if ARCH_X86_64
-    movsxd        r2, r2d
-%endif
-
     mov          r6d, r4d
     shl          r4d, 16
     sub          r4d, r6d
@@ -465,9 +455,6 @@ chroma_mc4_mmx_func avg, rv40
 
 %macro chroma_mc8_ssse3_func 2-3
 cglobal %1_%2_chroma_mc8%3, 6, 7, 8
-%if ARCH_X86_64
-    movsxd        r2, r2d
-%endif
     mov          r6d, r5d
     or           r6d, r4d
     jne .at_least_one_non_zero
@@ -613,9 +600,6 @@ cglobal %1_%2_chroma_mc8%3, 6, 7, 8
 
 %macro chroma_mc4_ssse3_func 2
 cglobal %1_%2_chroma_mc4, 6, 7, 0
-%if ARCH_X86_64
-    movsxd        r2, r2d
-%endif
     mov           r6, r4
     shl          r4d, 8
     sub          r4d, r6d
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264_chromamc_10bit.asm b/mythtv/external/FFmpeg/libavcodec/x86/h264_chromamc_10bit.asm
index c3584820923..34bc41969b9 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264_chromamc_10bit.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264_chromamc_10bit.asm
@@ -57,12 +57,11 @@ SECTION .text
 %endmacro
 
 ;-----------------------------------------------------------------------------
-; void ff_put/avg_h264_chroma_mc8(pixel *dst, pixel *src, int stride, int h,
-;                                 int mx, int my)
+; void ff_put/avg_h264_chroma_mc8(pixel *dst, pixel *src, ptrdiff_t stride,
+;                                 int h, int mx, int my)
 ;-----------------------------------------------------------------------------
 %macro CHROMA_MC8 1
 cglobal %1_h264_chroma_mc8_10, 6,7,8
-    movsxdifnidn  r2, r2d
     mov          r6d, r5d
     or           r6d, r4d
     jne .at_least_one_non_zero
@@ -149,8 +148,8 @@ cglobal %1_h264_chroma_mc8_10, 6,7,8
 %endmacro
 
 ;-----------------------------------------------------------------------------
-; void ff_put/avg_h264_chroma_mc4(pixel *dst, pixel *src, int stride, int h,
-;                                 int mx, int my)
+; void ff_put/avg_h264_chroma_mc4(pixel *dst, pixel *src, ptrdiff_t stride,
+;                                 int h, int mx, int my)
 ;-----------------------------------------------------------------------------
 ;TODO: xmm mc4
 %macro MC4_OP 2
@@ -174,7 +173,6 @@ cglobal %1_h264_chroma_mc8_10, 6,7,8
 
 %macro CHROMA_MC4 1
 cglobal %1_h264_chroma_mc4_10, 6,6,7
-    movsxdifnidn  r2, r2d
     movd          m2, r4m         ; x
     movd          m3, r5m         ; y
     mova          m4, [pw_8]
@@ -200,12 +198,11 @@ cglobal %1_h264_chroma_mc4_10, 6,6,7
 %endmacro
 
 ;-----------------------------------------------------------------------------
-; void ff_put/avg_h264_chroma_mc2(pixel *dst, pixel *src, int stride, int h,
-;                                 int mx, int my)
+; void ff_put/avg_h264_chroma_mc2(pixel *dst, pixel *src, ptrdiff_t stride,
+;                                 int h, int mx, int my)
 ;-----------------------------------------------------------------------------
 %macro CHROMA_MC2 1
 cglobal %1_h264_chroma_mc2_10, 6,7
-    movsxdifnidn  r2, r2d
     mov          r6d, r4d
     shl          r4d, 16
     sub          r4d, r6d
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264_deblock.asm b/mythtv/external/FFmpeg/libavcodec/x86/h264_deblock.asm
index 4aabbc0832f..6702ae98d4c 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264_deblock.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264_deblock.asm
@@ -37,11 +37,6 @@ cextern pb_0
 cextern pb_1
 cextern pb_3
 
-; expands to [base],...,[base+7*stride]
-%define PASS8ROWS(base, base3, stride, stride3) \
-    [base], [base+stride], [base+stride*2], [base3], \
-    [base3+stride], [base3+stride*2], [base3+stride3], [base3+stride*4]
-
 %define PASS8ROWS(base, base3, stride, stride3, offset) \
     PASS8ROWS(base+offset, base3+offset, stride, stride3)
 
@@ -287,18 +282,18 @@ cextern pb_3
 ;                        int8_t *tc0)
 ;-----------------------------------------------------------------------------
 %macro DEBLOCK_LUMA 0
-cglobal deblock_v_luma_8, 5,5,10
+cglobal deblock_v_luma_8, 5,5,10, pix_, stride_, alpha_, beta_, base3_
     movd    m8, [r4] ; tc0
-    lea     r4, [r1*3]
-    dec     r2d        ; alpha-1
+    lea     r4, [stride_q*3]
+    dec     alpha_d        ; alpha-1
     neg     r4
-    dec     r3d        ; beta-1
-    add     r4, r0     ; pix-3*stride
+    dec     beta_d        ; beta-1
+    add     base3_q, pix_q     ; pix-3*stride
 
-    mova    m0, [r4+r1]   ; p1
-    mova    m1, [r4+2*r1] ; p0
-    mova    m2, [r0]      ; q0
-    mova    m3, [r0+r1]   ; q1
+    mova    m0, [base3_q + stride_q]   ; p1
+    mova    m1, [base3_q + 2*stride_q] ; p0
+    mova    m2, [pix_q]      ; q0
+    mova    m3, [pix_q + stride_q]   ; q1
     LOAD_MASK r2d, r3d
 
     punpcklbw m8, m8
@@ -308,24 +303,24 @@ cglobal deblock_v_luma_8, 5,5,10
     pandn   m9, m7
     pand    m8, m9
 
-    movdqa  m3, [r4] ; p2
+    movdqa  m3, [base3_q] ; p2
     DIFF_GT2 m1, m3, m5, m6, m7 ; |p2-p0| > beta-1
     pand    m6, m9
     psubb   m7, m8, m6
     pand    m6, m8
-    LUMA_Q1 m0, m3, [r4], [r4+r1], m6, m4
+    LUMA_Q1 m0, m3, [base3_q], [base3_q + stride_q], m6, m4
 
-    movdqa  m4, [r0+2*r1] ; q2
+    movdqa  m4, [pix_q + 2*stride_q] ; q2
     DIFF_GT2 m2, m4, m5, m6, m3 ; |q2-q0| > beta-1
     pand    m6, m9
     pand    m8, m6
     psubb   m7, m6
-    mova    m3, [r0+r1]
-    LUMA_Q1 m3, m4, [r0+2*r1], [r0+r1], m8, m6
+    mova    m3, [pix_q + stride_q]
+    LUMA_Q1 m3, m4, [pix_q + 2*stride_q], [pix_q + stride_q], m8, m6
 
     DEBLOCK_P0_Q0
-    mova    [r4+2*r1], m1
-    mova    [r0], m2
+    mova    [base3_q + 2*stride_q], m1
+    mova    [pix_q], m2
     RET
 
 ;-----------------------------------------------------------------------------
@@ -382,10 +377,99 @@ cglobal deblock_h_luma_8, 5,9,0,0x60+16*WIN64
     RET
 %endmacro
 
+%macro DEBLOCK_H_LUMA_MBAFF 0
+
+cglobal deblock_h_luma_mbaff_8, 5, 9, 10, 8*16, pix_, stride_, alpha_, beta_, tc0_, base3_, stride3_
+    movsxd stride_q,   stride_d
+    dec    alpha_d
+    dec    beta_d
+    mov    base3_q,    pix_q
+    lea    stride3_q, [3*stride_q]
+    add    base3_q,    stride3_q
+
+    movq m0, [pix_q - 4]
+    movq m1, [pix_q + stride_q - 4]
+    movq m2, [pix_q + 2*stride_q - 4]
+    movq m3, [base3_q - 4]
+    movq m4, [base3_q + stride_q - 4]
+    movq m5, [base3_q + 2*stride_q - 4]
+    movq m6, [base3_q + stride3_q - 4]
+    movq m7, [base3_q + 4*stride_q - 4]
+
+    TRANSPOSE_8X8B 0,1,2,3,4,5,6,7
+
+    %assign i 0
+    %rep 8
+        movq [rsp + 16*i], m %+ i
+        %assign i i+1
+    %endrep
+
+    ; p2 = m1 [rsp + 16]
+    ; p1 = m2 [rsp + 32]
+    ; p0 = m3 [rsp + 48]
+    ; q0 = m4 [rsp + 64]
+    ; q1 = m5 [rsp + 80]
+    ; q2 = m6 [rsp + 96]
+
+    SWAP 0, 2
+    SWAP 1, 3
+    SWAP 2, 4
+    SWAP 3, 5
+
+    LOAD_MASK alpha_d, beta_d
+    movd m8, [tc0_q]
+    punpcklbw m8, m8
+    pcmpeqb m9, m9
+    pcmpeqb m9, m8
+    pandn   m9, m7
+    pand    m8, m9
+
+    movdqa  m3, [rsp + 16] ; p2
+    DIFF_GT2 m1, m3, m5, m6, m7 ; |p2-p0| > beta-1
+    pand    m6, m9
+    psubb   m7, m8, m6
+    pand    m6, m8
+    LUMA_Q1 m0, m3, [rsp + 16], [rsp + 32], m6, m4
+
+    movdqa  m4, [rsp + 96] ; q2
+    DIFF_GT2 m2, m4, m5, m6, m3 ; |q2-q0| > beta-1
+    pand    m6, m9
+    pand    m8, m6
+    psubb   m7, m6
+    mova    m3, [rsp + 80]
+    LUMA_Q1 m3, m4, [rsp + 96], [rsp + 80], m8, m6
+
+    DEBLOCK_P0_Q0
+    SWAP 1, 3
+    SWAP 2, 4
+    movq m0, [rsp]
+    movq m1, [rsp + 16]
+    movq m2, [rsp + 32]
+    movq m5, [rsp + 80]
+    movq m6, [rsp + 96]
+    movq m7, [rsp + 112]
+
+    TRANSPOSE_8X8B 0,1,2,3,4,5,6,7
+    movq [pix_q - 4], m0
+    movq [pix_q + stride_q - 4], m1
+    movq [pix_q + 2*stride_q - 4], m2
+    movq [base3_q - 4], m3
+    movq [base3_q + stride_q - 4], m4
+    movq [base3_q + 2*stride_q - 4], m5
+    movq [base3_q + stride3_q - 4], m6
+    movq [base3_q + 4*stride_q - 4], m7
+
+RET
+
+%endmacro
+
 INIT_XMM sse2
+DEBLOCK_H_LUMA_MBAFF
 DEBLOCK_LUMA
+
 %if HAVE_AVX_EXTERNAL
 INIT_XMM avx
+DEBLOCK_H_LUMA_MBAFF
 DEBLOCK_LUMA
 %endif
 
@@ -946,6 +1030,20 @@ cglobal deblock_h_chroma_intra_8, 4,6
     TRANSPOSE8x4B_STORE PASS8ROWS(t5, r0, r1, t6)
     RET
 
+cglobal deblock_h_chroma422_intra_8, 4, 6
+    CHROMA_H_START
+    TRANSPOSE4x8_LOAD  bw, wd, dq, PASS8ROWS(t5, r0, r1, t6)
+    call ff_chroma_intra_body_mmxext
+    TRANSPOSE8x4B_STORE PASS8ROWS(t5, r0, r1, t6)
+
+    lea r0, [r0+r1*8]
+    lea t5, [t5+r1*8]
+
+    TRANSPOSE4x8_LOAD  bw, wd, dq, PASS8ROWS(t5, r0, r1, t6)
+    call ff_chroma_intra_body_mmxext
+    TRANSPOSE8x4B_STORE PASS8ROWS(t5, r0, r1, t6)
+RET
+
 ALIGN 16
 ff_chroma_intra_body_mmxext:
     LOAD_MASK r2d, r3d
@@ -961,6 +1059,202 @@ ff_chroma_intra_body_mmxext:
     paddb  m2, m6
     ret
 
+%macro LOAD_8_ROWS 8
+    movd m0, %1
+    movd m1, %2
+    movd m2, %3
+    movd m3, %4
+    movd m4, %5
+    movd m5, %6
+    movd m6, %7
+    movd m7, %8
+%endmacro
+
+%macro STORE_8_ROWS 8
+    movd %1, m0
+    movd %2, m1
+    movd %3, m2
+    movd %4, m3
+    movd %5, m4
+    movd %6, m5
+    movd %7, m6
+    movd %8, m7
+%endmacro
+
+%macro TRANSPOSE_8x4B_XMM 0
+    punpcklbw m0, m1
+    punpcklbw m2, m3
+    punpcklbw m4, m5
+    punpcklbw m6, m7
+    punpcklwd m0, m2
+    punpcklwd m4, m6
+    punpckhdq m2, m0, m4
+    punpckldq m0, m4
+    MOVHL m1, m0
+    MOVHL m3, m2
+%endmacro
+
+%macro TRANSPOSE_4x8B_XMM 0
+    punpcklbw m0, m1
+    punpcklbw m2, m3
+    punpckhwd m4, m0, m2
+    punpcklwd m0, m2
+    MOVHL m6, m4
+    MOVHL m2, m0
+    pshufd m1, m0, 1
+    pshufd m3, m2, 1
+    pshufd m5, m4, 1
+    pshufd m7, m6, 1
+%endmacro
+
+%macro CHROMA_INTER_BODY_XMM 1
+    LOAD_MASK alpha_d, beta_d
+    movd m6, [tc0_q]
+    %rep %1
+        punpcklbw m6, m6
+    %endrep
+    pand m7, m6
+    DEBLOCK_P0_Q0
+%endmacro
+
+%macro CHROMA_INTRA_BODY_XMM 0
+    LOAD_MASK alpha_d, beta_d
+    mova    m5,  m1
+    mova    m6,  m2
+    pxor    m4,  m1, m3
+    pand    m4, [pb_1]
+    pavgb   m1,  m3
+    psubusb m1,  m4
+    pavgb   m1,  m0
+    pxor    m4,  m2, m0
+    pand    m4, [pb_1]
+    pavgb   m2,  m0
+    psubusb m2,  m4
+    pavgb   m2,  m3
+    psubb   m1,  m5
+    psubb   m2,  m6
+    pand    m1,  m7
+    pand    m2,  m7
+    paddb   m1,  m5
+    paddb   m2,  m6
+%endmacro
+
+%macro CHROMA_V_START_XMM 1
+    movsxdifnidn stride_q, stride_d
+    dec alpha_d
+    dec beta_d
+    mov %1, pix_q
+    sub %1, stride_q
+    sub %1, stride_q
+%endmacro
+
+%macro CHROMA_H_START_XMM 2
+    movsxdifnidn stride_q, stride_d
+    dec alpha_d
+    dec beta_d
+    lea %2, [3*stride_q]
+    mov %1,  pix_q
+    add %1,  %2
+%endmacro
+
+%macro DEBLOCK_CHROMA_XMM 1
+
+INIT_XMM %1
+
+cglobal deblock_v_chroma_8, 5, 6, 8, pix_, stride_, alpha_, beta_, tc0_
+    CHROMA_V_START_XMM r5
+    movq m0, [r5]
+    movq m1, [r5 + stride_q]
+    movq m2, [pix_q]
+    movq m3, [pix_q + stride_q]
+    CHROMA_INTER_BODY_XMM 1
+    movq [r5 + stride_q], m1
+    movq [pix_q], m2
+RET
+
+cglobal deblock_h_chroma_8, 5, 7, 8, 0-16, pix_, stride_, alpha_, beta_, tc0_
+    CHROMA_H_START_XMM r5, r6
+    LOAD_8_ROWS PASS8ROWS(pix_q - 2, r5 - 2, stride_q, r6)
+    TRANSPOSE_8x4B_XMM
+    movq [rsp], m0
+    movq [rsp + 8], m3
+    CHROMA_INTER_BODY_XMM 1
+    movq m0, [rsp]
+    movq m3, [rsp + 8]
+    TRANSPOSE_4x8B_XMM
+    STORE_8_ROWS PASS8ROWS(pix_q - 2, r5 - 2, stride_q, r6)
+RET
+
+cglobal deblock_h_chroma422_8, 5, 7, 8, 0-16, pix_, stride_, alpha_, beta_, tc0_,
+    CHROMA_H_START_XMM r5, r6
+    LOAD_8_ROWS PASS8ROWS(pix_q - 2, r5 - 2, stride_q, r6)
+    TRANSPOSE_8x4B_XMM
+    movq [rsp], m0
+    movq [rsp + 8], m3
+    CHROMA_INTER_BODY_XMM 2
+    movq m0, [rsp]
+    movq m3, [rsp + 8]
+    TRANSPOSE_4x8B_XMM
+    STORE_8_ROWS PASS8ROWS(pix_q - 2, r5 - 2, stride_q, r6)
+
+    lea pix_q, [pix_q + 8*stride_q]
+    lea r5,    [r5    + 8*stride_q]
+    add tc0_q,  2
+
+    LOAD_8_ROWS PASS8ROWS(pix_q - 2, r5 - 2, stride_q, r6)
+    TRANSPOSE_8x4B_XMM
+    movq [rsp], m0
+    movq [rsp + 8], m3
+    CHROMA_INTER_BODY_XMM 2
+    movq m0, [rsp]
+    movq m3, [rsp + 8]
+    TRANSPOSE_4x8B_XMM
+    STORE_8_ROWS PASS8ROWS(pix_q - 2, r5 - 2, stride_q, r6)
+RET
+
+cglobal deblock_v_chroma_intra_8, 4, 5, 8, pix_, stride_, alpha_, beta_
+    CHROMA_V_START_XMM r4
+    movq m0, [r4]
+    movq m1, [r4 + stride_q]
+    movq m2, [pix_q]
+    movq m3, [pix_q + stride_q]
+    CHROMA_INTRA_BODY_XMM
+    movq [r4 + stride_q], m1
+    movq [pix_q], m2
+RET
+
+cglobal deblock_h_chroma_intra_8, 4, 6, 8, pix_, stride_, alpha_, beta_
+    CHROMA_H_START_XMM r4, r5
+    LOAD_8_ROWS PASS8ROWS(pix_q - 2, r4 - 2, stride_q, r5)
+    TRANSPOSE_8x4B_XMM
+    CHROMA_INTRA_BODY_XMM
+    TRANSPOSE_4x8B_XMM
+    STORE_8_ROWS PASS8ROWS(pix_q - 2, r4 - 2, stride_q, r5)
+RET
+
+cglobal deblock_h_chroma422_intra_8, 4, 6, 8, pix_, stride_, alpha_, beta_
+    CHROMA_H_START_XMM r4, r5
+    LOAD_8_ROWS PASS8ROWS(pix_q - 2, r4 - 2, stride_q, r5)
+    TRANSPOSE_8x4B_XMM
+    CHROMA_INTRA_BODY_XMM
+    TRANSPOSE_4x8B_XMM
+    STORE_8_ROWS PASS8ROWS(pix_q - 2, r4 - 2, stride_q, r5)
+
+    lea pix_q, [pix_q + 8*stride_q]
+    lea r4,    [r4    + 8*stride_q]
+
+    LOAD_8_ROWS PASS8ROWS(pix_q - 2, r4 - 2, stride_q, r5)
+    TRANSPOSE_8x4B_XMM
+    CHROMA_INTRA_BODY_XMM
+    TRANSPOSE_4x8B_XMM
+    STORE_8_ROWS PASS8ROWS(pix_q - 2, r4 - 2, stride_q, r5)
+RET
+
+%endmacro ; DEBLOCK_CHROMA_XMM
+
+DEBLOCK_CHROMA_XMM sse2
+DEBLOCK_CHROMA_XMM avx
+
 ;-----------------------------------------------------------------------------
 ; void ff_h264_loop_filter_strength(int16_t bs[2][4][4], uint8_t nnz[40],
 ;                                   int8_t ref[2][40], int16_t mv[2][40][2],
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264_deblock_10bit.asm b/mythtv/external/FFmpeg/libavcodec/x86/h264_deblock_10bit.asm
index ebf8a3f1095..1af3257a67a 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264_deblock_10bit.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264_deblock_10bit.asm
@@ -843,6 +843,83 @@ DEBLOCK_LUMA_INTRA
     mova [r0+2*r1], m2
 %endmacro
 
+; in: 8 rows of 4 words in %4..%11
+; out: 4 rows of 8 words in m0..m3
+%macro TRANSPOSE4x8W_LOAD 8
+    movq             m0, %1
+    movq             m2, %2
+    movq             m1, %3
+    movq             m3, %4
+
+    punpcklwd        m0, m2
+    punpcklwd        m1, m3
+    punpckhdq        m2, m0, m1
+    punpckldq        m0, m1
+
+    movq             m4, %5
+    movq             m6, %6
+    movq             m5, %7
+    movq             m3, %8
+
+    punpcklwd        m4, m6
+    punpcklwd        m5, m3
+    punpckhdq        m6, m4, m5
+    punpckldq        m4, m5
+
+    punpckhqdq       m1, m0, m4
+    punpcklqdq       m0, m4
+    punpckhqdq       m3, m2, m6
+    punpcklqdq       m2, m6
+%endmacro
+
+; in: 4 rows of 8 words in m0..m3
+; out: 8 rows of 4 words in %1..%8
+%macro TRANSPOSE8x4W_STORE 8
+    TRANSPOSE4x4W     0, 1, 2, 3, 4
+    movq             %1, m0
+    movhps           %2, m0
+    movq             %3, m1
+    movhps           %4, m1
+    movq             %5, m2
+    movhps           %6, m2
+    movq             %7, m3
+    movhps           %8, m3
+%endmacro
+
+; %1 = base + 3*stride
+; %2 = 3*stride (unused on mmx)
+; %3, %4 = place to store p1 and q1 values
+%macro CHROMA_H_LOAD 4
+    %if mmsize == 8
+        movq m0, [pix_q - 4]
+        movq m1, [pix_q +   stride_q - 4]
+        movq m2, [pix_q + 2*stride_q - 4]
+        movq m3, [%1 - 4]
+        TRANSPOSE4x4W 0, 1, 2, 3, 4
+    %else
+        TRANSPOSE4x8W_LOAD PASS8ROWS(pix_q-4, %1-4, stride_q, %2)
+    %endif
+    mova %3, m0
+    mova %4, m3
+%endmacro
+
+; %1 = base + 3*stride
+; %2 = 3*stride (unused on mmx)
+; %3, %4 = place to load p1 and q1 values
+%macro CHROMA_H_STORE 4
+    mova m0, %3
+    mova m3, %4
+    %if mmsize == 8
+        TRANSPOSE4x4W 0, 1, 2, 3, 4
+        movq [pix_q - 4],              m0
+        movq [pix_q +   stride_q - 4], m1
+        movq [pix_q + 2*stride_q - 4], m2
+        movq [%1 - 4],                 m3
+    %else
+        TRANSPOSE8x4W_STORE PASS8ROWS(pix_q-4, %1-4, stride_q, %2)
+    %endif
+%endmacro
+
 %macro CHROMA_V_LOAD_TC 2
     movd        %1, [%2]
     punpcklbw   %1, %1
@@ -914,6 +991,81 @@ cglobal deblock_v_chroma_intra_10, 4,6-(mmsize/16),8*(mmsize/16)
 %else
     RET
 %endif
+
+;-----------------------------------------------------------------------------
+; void ff_deblock_h_chroma_10(uint16_t *pix, int stride, int alpha, int beta,
+;                             int8_t *tc0)
+;-----------------------------------------------------------------------------
+cglobal deblock_h_chroma_10, 5, 7, 8, 0-2*mmsize, pix_, stride_, alpha_, beta_, tc0_
+    shl alpha_d,  2
+    shl beta_d,   2
+    mov r5,       pix_q
+    lea r6,      [3*stride_q]
+    add r5,       r6
+%if mmsize == 8
+    mov r6d,      2
+    .loop:
+%endif
+
+        CHROMA_H_LOAD r5, r6, [rsp], [rsp + mmsize]
+        LOAD_AB          m4,  m5, alpha_d, beta_d
+        LOAD_MASK        m0,  m1, m2, m3, m4, m5, m7, m6, m4
+        pxor             m4,  m4
+        CHROMA_V_LOAD_TC m6,  tc0_q
+        psubw            m6, [pw_3]
+        pmaxsw           m6,  m4
+        pand             m7,  m6
+        DEBLOCK_P0_Q0    m1,  m2, m0, m3, m7, m5, m6
+        CHROMA_H_STORE r5, r6, [rsp], [rsp + mmsize]
+
+%if mmsize == 8
+        lea pix_q, [pix_q + 4*stride_q]
+        lea r5,    [r5 + 4*stride_q]
+        add tc0_q,  2
+        dec r6d
+    jg .loop
+%endif
+RET
+
+;-----------------------------------------------------------------------------
+; void ff_deblock_h_chroma422_10(uint16_t *pix, int stride, int alpha, int beta,
+;                                int8_t *tc0)
+;-----------------------------------------------------------------------------
+cglobal deblock_h_chroma422_10, 5, 7, 8, 0-3*mmsize, pix_, stride_, alpha_, beta_, tc0_
+    shl alpha_d,  2
+    shl beta_d,   2
+
+    movd m0, [tc0_q]
+    punpcklbw m0, m0
+    psraw m0, 6
+    movq [rsp], m0
+
+    mov r5,       pix_q
+    lea r6,      [3*stride_q]
+    add r5,       r6
+
+    mov r4, -8
+    .loop:
+
+        CHROMA_H_LOAD r5, r6, [rsp + 1*mmsize], [rsp + 2*mmsize]
+        LOAD_AB          m4,  m5, alpha_d, beta_d
+        LOAD_MASK        m0,  m1, m2, m3, m4, m5, m7, m6, m4
+        pxor             m4,  m4
+        movd             m6, [rsp + r4 + 8]
+        punpcklwd        m6,  m6
+        punpcklwd        m6,  m6
+        psubw            m6, [pw_3]
+        pmaxsw           m6,  m4
+        pand             m7,  m6
+        DEBLOCK_P0_Q0    m1,  m2, m0, m3, m7, m5, m6
+        CHROMA_H_STORE r5, r6, [rsp + 1*mmsize], [rsp + 2*mmsize]
+
+        lea pix_q, [pix_q + (mmsize/2)*stride_q]
+        lea r5,    [r5 +    (mmsize/2)*stride_q]
+        add r4, (mmsize/4)
+    jl .loop
+RET
+
 %endmacro
 
 %if ARCH_X86_64 == 0
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264_idct.asm b/mythtv/external/FFmpeg/libavcodec/x86/h264_idct.asm
index 27222cbc3ca..ea91e1ac4d9 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264_idct.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264_idct.asm
@@ -65,7 +65,15 @@ SECTION .text
 
     IDCT4_1D      w, 0, 1, 2, 3, 4, 5
     mova         m6, [pw_32]
-    TRANSPOSE4x4W 0, 1, 2, 3, 4
+    %if mmsize == 8
+        TRANSPOSE4x4W 0, 1, 2, 3, 4
+    %else
+        punpcklwd m0, m1
+        punpcklwd m2, m3
+        SBUTTERFLY dq, 0, 2, 4
+        MOVHL m1, m0
+        MOVHL m3, m2
+    %endif
     paddw        m0, m6
     IDCT4_1D      w, 0, 1, 2, 3, 4, 5
     pxor         m7, m7
@@ -87,10 +95,9 @@ cglobal h264_idct_add_8, 3, 3, 0
     RET
 
 %macro IDCT8_1D 2
-    mova         m0, m1
-    psraw        m1, 1
-    mova         m4, m5
-    psraw        m4, 1
+    psraw        m0, m1, 1
+    SWAP 0, 1
+    psraw        m4, m5, 1
     paddw        m4, m5
     paddw        m1, m0
     paddw        m4, m7
@@ -107,10 +114,9 @@ cglobal h264_idct_add_8, 3, 3, 0
     psubw        m0, m3
     psubw        m5, m7
 
-    mova         m7, m1
-    psraw        m1, 2
-    mova         m3, m4
-    psraw        m3, 2
+    psraw        m7, m1, 2
+    SWAP 7,1
+    psraw        m3, m4, 2
     paddw        m3, m0
     psraw        m0, 2
     paddw        m1, m5
@@ -118,10 +124,9 @@ cglobal h264_idct_add_8, 3, 3, 0
     psubw        m0, m4
     psubw        m7, m5
 
-    mova         m5, m6
-    psraw        m6, 1
-    mova         m4, m2
-    psraw        m4, 1
+    psraw        m5, m6, 1
+    SWAP 5,6
+    psraw        m4, m2, 1
     paddw        m6, m2
     psubw        m4, m5
 
@@ -695,7 +700,39 @@ cglobal h264_idct_add8_8, 5, 8 + npicregs, 0, dst1, block_offset, block, stride,
     add        r0mp, gprsize
 %endif
     call         h264_idct_add8_mmx_plane
-    RET
+    RET ; TODO: check rep ret after a function call
+
+cglobal h264_idct_add8_422_8, 5, 8 + npicregs, 0, dst1, block_offset, block, stride, nnzc, cntr, coeff, dst2, picreg
+; dst1, block_offset, block, stride, nnzc, cntr, coeff, dst2, picreg
+    movsxdifnidn r3, r3d
+%ifdef PIC
+    lea     picregq, [scan8_mem]
+%endif
+%if ARCH_X86_64
+    mov       dst2q, r0
+%endif
+
+    mov          r5, 16  ; i
+    add          r2, 512 ; i * 16 * sizeof(dctcoef) ; #define dctcoef int16_t
+
+    call         h264_idct_add8_mmx_plane
+    add r5, 4
+    call         h264_idct_add8_mmx_plane
+
+%if ARCH_X86_64
+    add       dst2q, gprsize ; dest[1]
+%else
+    add        r0mp, gprsize
+%endif
+
+    add r5, 4   ; set to 32
+    add r2, 256 ; set to i * 16 * sizeof(dctcoef)
+
+    call         h264_idct_add8_mmx_plane
+    add r5, 4
+    call         h264_idct_add8_mmx_plane
+
+    RET ; TODO: check rep ret after a function call
 
 h264_idct_add8_mmxext_plane:
     movsxdifnidn r3, r3d
@@ -763,7 +800,7 @@ cglobal h264_idct_add8_8, 5, 8 + npicregs, 0, dst1, block_offset, block, stride,
     add        r0mp, gprsize
 %endif
     call h264_idct_add8_mmxext_plane
-    RET
+    RET ; TODO: check rep ret after a function call
 
 ; r0 = uint8_t *dst, r2 = int16_t *block, r3 = int stride, r6=clobbered
 h264_idct_dc_add8_mmxext:
@@ -846,7 +883,7 @@ cglobal h264_idct_add16_8, 5, 5 + ARCH_X86_64, 8
     add16_sse2_cycle 5, 0x24
     add16_sse2_cycle 6, 0x1e
     add16_sse2_cycle 7, 0x26
-    RET
+REP_RET
 
 %macro add16intra_sse2_cycle 2
     movzx       r0, word [r4+%2]
@@ -893,7 +930,7 @@ cglobal h264_idct_add16intra_8, 5, 7 + ARCH_X86_64, 8
     add16intra_sse2_cycle 5, 0x24
     add16intra_sse2_cycle 6, 0x1e
     add16intra_sse2_cycle 7, 0x26
-    RET
+REP_RET
 
 %macro add8_sse2_cycle 2
     movzx       r0, word [r4+%2]
@@ -948,7 +985,7 @@ cglobal h264_idct_add8_8, 5, 7 + ARCH_X86_64, 8
 %endif
     add8_sse2_cycle 2, 0x5c
     add8_sse2_cycle 3, 0x64
-    RET
+REP_RET
 
 ;void ff_h264_luma_dc_dequant_idct_mmx(int16_t *output, int16_t *input, int qmul)
 
@@ -1102,3 +1139,53 @@ INIT_MMX mmx
 IDCT_DC_DEQUANT 0
 INIT_MMX sse2
 IDCT_DC_DEQUANT 7
+
+; %unmacro STORE_DIFFx2 8 ; remove macro from x86util.asm but yasm doesn't have this yet
+%macro STORE_DIFFx2 8 ; add1, add2, reg1, reg2, zero, shift, source, stride
+    movd       %3, [%7]
+    movd       %4, [%7+%8]
+    psraw      %1, %6
+    psraw      %2, %6
+    punpcklbw  %3, %5
+    punpcklbw  %4, %5
+    paddw      %3, %1
+    paddw      %4, %2
+    packuswb   %3, %5
+    packuswb   %4, %5
+    movd     [%7], %3
+    movd  [%7+%8], %4
+%endmacro
+
+%macro DC_ADD_INIT 1
+    add      %1d, 32
+    sar      %1d, 6
+    movd     m0, %1d
+    pshuflw  m0, m0, 0
+    lea      %1, [3*stride_q]
+    pxor     m1, m1
+    psubw    m1, m0
+    packuswb m0, m0
+    packuswb m1, m1
+%endmacro
+
+%macro IDCT_XMM 1
+
+INIT_XMM %1
+
+cglobal h264_idct_add_8, 3, 3, 8, dst_, block_, stride_
+    movsxdifnidn stride_q, stride_d
+    IDCT4_ADD    dst_q, block_q, stride_q
+RET
+
+cglobal h264_idct_dc_add_8, 3, 4, 6, dst_, block_, stride_
+    movsxdifnidn stride_q, stride_d
+    movsx             r3d, word [block_q]
+    mov   dword [block_q], 0
+    DC_ADD_INIT r3
+    DC_ADD_MMXEXT_OP movd, dst_q, stride_q, r3
+RET
+
+%endmacro
+
+IDCT_XMM sse2
+IDCT_XMM avx
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264_idct_10bit.asm b/mythtv/external/FFmpeg/libavcodec/x86/h264_idct_10bit.asm
index 4f7491dbf5d..9fd05abb2b7 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264_idct_10bit.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264_idct_10bit.asm
@@ -350,6 +350,59 @@ INIT_XMM avx
 IDCT_ADD8
 %endif
 
+;-----------------------------------------------------------------------------
+; void ff_h264_idct_add8_422_10(pixel **dst, const int *block_offset,
+;                               int16_t *block, int stride,
+;                               const uint8_t nnzc[6*8])
+;-----------------------------------------------------------------------------
+%assign last_block 44
+
+%macro IDCT_ADD8_422 0
+
+cglobal h264_idct_add8_422_10, 5, 8, 7
+    movsxdifnidn r3, r3d
+%if ARCH_X86_64
+    mov      r7, r0
+%endif
+
+    add      r2, 1024
+    mov      r0, [r0]
+    ADD16_OP_INTRA 16, 4+ 6*8
+    ADD16_OP_INTRA 18, 4+ 7*8
+    ADD16_OP_INTRA 24, 4+ 8*8 ; i+4
+    ADD16_OP_INTRA 26, 4+ 9*8 ; i+4
+    add      r2, 1024-128*4
+
+%if ARCH_X86_64
+    mov      r0, [r7+gprsize]
+%else
+    mov      r0, r0m
+    mov      r0, [r0+gprsize]
+%endif
+
+    ADD16_OP_INTRA 32, 4+11*8
+    ADD16_OP_INTRA 34, 4+12*8
+    ADD16_OP_INTRA 40, 4+13*8 ; i+4
+    ADD16_OP_INTRA 42, 4+14*8 ; i+4
+REP_RET
+    AC 16
+    AC 18
+    AC 24 ; i+4
+    AC 26 ; i+4
+    AC 32
+    AC 34
+    AC 40 ; i+4
+    AC 42 ; i+4
+
+%endmacro
+
+INIT_XMM sse2
+IDCT_ADD8_422
+%if HAVE_AVX_EXTERNAL
+INIT_XMM avx
+IDCT_ADD8_422
+%endif
+
 ;-----------------------------------------------------------------------------
 ; void ff_h264_idct8_add_10(pixel *dst, int16_t *block, int stride)
 ;-----------------------------------------------------------------------------
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred.asm b/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred.asm
index c88d91b49e5..f3aa3172f05 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred.asm
@@ -49,7 +49,7 @@ cextern pw_17
 cextern pw_32
 
 ;-----------------------------------------------------------------------------
-; void ff_pred16x16_vertical_8(uint8_t *src, int stride)
+; void ff_pred16x16_vertical_8(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmx
@@ -85,7 +85,7 @@ cglobal pred16x16_vertical_8, 2,3
     REP_RET
 
 ;-----------------------------------------------------------------------------
-; void ff_pred16x16_horizontal_8(uint8_t *src, int stride)
+; void ff_pred16x16_horizontal_8(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro PRED16x16_H 0
@@ -126,7 +126,7 @@ INIT_XMM ssse3
 PRED16x16_H
 
 ;-----------------------------------------------------------------------------
-; void ff_pred16x16_dc_8(uint8_t *src, int stride)
+; void ff_pred16x16_dc_8(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro PRED16x16_DC 0
@@ -188,7 +188,7 @@ INIT_XMM ssse3
 PRED16x16_DC
 
 ;-----------------------------------------------------------------------------
-; void ff_pred16x16_tm_vp8_8(uint8_t *src, int stride)
+; void ff_pred16x16_tm_vp8_8(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro PRED16x16_TM 0
@@ -268,8 +268,45 @@ cglobal pred16x16_tm_vp8_8, 2,6,6
     jg .loop
     REP_RET
 
+%if HAVE_AVX2_EXTERNAL
+INIT_YMM avx2
+cglobal pred16x16_tm_vp8_8, 2, 4, 5, dst, stride, stride3, iteration
+    sub                       dstq, strideq
+    pmovzxbw                    m0, [dstq]
+    vpbroadcastb               xm1, [r0-1]
+    pmovzxbw                    m1, xm1
+    psubw                       m0, m1
+    mov                 iterationd, 4
+    lea                   stride3q, [strideq*3]
+.loop:
+    vpbroadcastb               xm1, [dstq+strideq*1-1]
+    vpbroadcastb               xm2, [dstq+strideq*2-1]
+    vpbroadcastb               xm3, [dstq+stride3q-1]
+    vpbroadcastb               xm4, [dstq+strideq*4-1]
+    pmovzxbw                    m1, xm1
+    pmovzxbw                    m2, xm2
+    pmovzxbw                    m3, xm3
+    pmovzxbw                    m4, xm4
+    paddw                       m1, m0
+    paddw                       m2, m0
+    paddw                       m3, m0
+    paddw                       m4, m0
+    vpackuswb                   m1, m1, m2
+    vpackuswb                   m3, m3, m4
+    vpermq                      m1, m1, q3120
+    vpermq                      m3, m3, q3120
+    movdqa        [dstq+strideq*1], xm1
+    vextracti128  [dstq+strideq*2], m1, 1
+    movdqa       [dstq+stride3q*1], xm3
+    vextracti128  [dstq+strideq*4], m3, 1
+    lea                       dstq, [dstq+strideq*4]
+    dec                 iterationd
+    jg .loop
+    REP_RET
+%endif
+
 ;-----------------------------------------------------------------------------
-; void ff_pred16x16_plane_*_8(uint8_t *src, int stride)
+; void ff_pred16x16_plane_*_8(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro H264_PRED16x16_PLANE 1
@@ -550,7 +587,7 @@ H264_PRED16x16_PLANE rv40
 H264_PRED16x16_PLANE svq3
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8_plane_8(uint8_t *src, int stride)
+; void ff_pred8x8_plane_8(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro H264_PRED8x8_PLANE 0
@@ -724,7 +761,7 @@ INIT_XMM ssse3
 H264_PRED8x8_PLANE
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8_vertical_8(uint8_t *src, int stride)
+; void ff_pred8x8_vertical_8(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmx
@@ -741,7 +778,7 @@ cglobal pred8x8_vertical_8, 2,2
     RET
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8_horizontal_8(uint8_t *src, int stride)
+; void ff_pred8x8_horizontal_8(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro PRED8x8_H 0
@@ -769,7 +806,7 @@ INIT_MMX ssse3
 PRED8x8_H
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8_top_dc_8_mmxext(uint8_t *src, int stride)
+; void ff_pred8x8_top_dc_8_mmxext(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 INIT_MMX mmxext
 cglobal pred8x8_top_dc_8, 2,5
@@ -803,7 +840,7 @@ cglobal pred8x8_top_dc_8, 2,5
     RET
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8_dc_8_mmxext(uint8_t *src, int stride)
+; void ff_pred8x8_dc_8_mmxext(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -864,7 +901,7 @@ cglobal pred8x8_dc_8, 2,5
     RET
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8_dc_rv40_8(uint8_t *src, int stride)
+; void ff_pred8x8_dc_rv40_8(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -901,7 +938,7 @@ cglobal pred8x8_dc_rv40_8, 2,7
     REP_RET
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8_tm_vp8_8(uint8_t *src, int stride)
+; void ff_pred8x8_tm_vp8_8(uint8_t *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro PRED8x8_TM 0
@@ -1014,7 +1051,7 @@ cglobal pred8x8_tm_vp8_8, 2,3,6
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred8x8l_top_dc_8(uint8_t *src, int has_topleft, int has_topright,
-;                           int stride)
+;                           ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED8x8L_TOP_DC 0
 cglobal pred8x8l_top_dc_8, 4,4
@@ -1070,7 +1107,7 @@ PRED8x8L_TOP_DC
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred8x8l_dc_8(uint8_t *src, int has_topleft, int has_topright,
-;                       int stride)
+;                       ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro PRED8x8L_DC 0
@@ -1174,7 +1211,7 @@ PRED8x8L_DC
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred8x8l_horizontal_8(uint8_t *src, int has_topleft,
-;                               int has_topright, int stride)
+;                               int has_topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro PRED8x8L_HORIZONTAL 0
@@ -1246,7 +1283,7 @@ PRED8x8L_HORIZONTAL
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred8x8l_vertical_8(uint8_t *src, int has_topleft, int has_topright,
-;                             int stride)
+;                             ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro PRED8x8L_VERTICAL 0
@@ -1297,7 +1334,7 @@ PRED8x8L_VERTICAL
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred8x8l_down_left_8(uint8_t *src, int has_topleft,
-;                              int has_topright, int stride)
+;                              int has_topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -1498,7 +1535,7 @@ PRED8x8L_DOWN_LEFT
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred8x8l_down_right_8_mmxext(uint8_t *src, int has_topleft,
-;                                      int has_topright, int stride)
+;                                      int has_topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -1750,7 +1787,7 @@ PRED8x8L_DOWN_RIGHT
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred8x8l_vertical_right_8(uint8_t *src, int has_topleft,
-;                                   int has_topright, int stride)
+;                                   int has_topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -1978,7 +2015,7 @@ PRED8x8L_VERTICAL_RIGHT
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred8x8l_vertical_left_8(uint8_t *src, int has_topleft,
-;                                  int has_topright, int stride)
+;                                  int has_topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro PRED8x8L_VERTICAL_LEFT 0
@@ -2068,7 +2105,7 @@ PRED8x8L_VERTICAL_LEFT
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred8x8l_horizontal_up_8(uint8_t *src, int has_topleft,
-;                                  int has_topright, int stride)
+;                                  int has_topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro PRED8x8L_HORIZONTAL_UP 0
@@ -2156,7 +2193,7 @@ PRED8x8L_HORIZONTAL_UP
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred8x8l_horizontal_down_8(uint8_t *src, int has_topleft,
-;                                    int has_topright, int stride)
+;                                    int has_topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -2404,7 +2441,8 @@ INIT_MMX ssse3
 PRED8x8L_HORIZONTAL_DOWN
 
 ;-------------------------------------------------------------------------------
-; void ff_pred4x4_dc_8_mmxext(uint8_t *src, const uint8_t *topright, int stride)
+; void ff_pred4x4_dc_8_mmxext(uint8_t *src, const uint8_t *topright,
+;                             ptrdiff_t stride)
 ;-------------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -2435,7 +2473,7 @@ cglobal pred4x4_dc_8, 3,5
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred4x4_tm_vp8_8_mmxext(uint8_t *src, const uint8_t *topright,
-;                                 int stride)
+;                                 ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 %macro PRED4x4_TM 0
@@ -2514,7 +2552,7 @@ cglobal pred4x4_tm_vp8_8, 3,3
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred4x4_vertical_vp8_8_mmxext(uint8_t *src, const uint8_t *topright,
-;                                       int stride)
+;                                       ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -2535,7 +2573,7 @@ cglobal pred4x4_vertical_vp8_8, 3,3
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred4x4_down_left_8_mmxext(uint8_t *src, const uint8_t *topright,
-;                                    int stride)
+;                                    ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 INIT_MMX mmxext
 cglobal pred4x4_down_left_8, 3,3
@@ -2562,7 +2600,7 @@ cglobal pred4x4_down_left_8, 3,3
 
 ;------------------------------------------------------------------------------
 ; void ff_pred4x4_vertical_left_8_mmxext(uint8_t *src, const uint8_t *topright,
-;                                        int stride)
+;                                        ptrdiff_t stride)
 ;------------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -2588,7 +2626,7 @@ cglobal pred4x4_vertical_left_8, 3,3
 
 ;------------------------------------------------------------------------------
 ; void ff_pred4x4_horizontal_up_8_mmxext(uint8_t *src, const uint8_t *topright,
-;                                        int stride)
+;                                        ptrdiff_t stride)
 ;------------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -2622,7 +2660,8 @@ cglobal pred4x4_horizontal_up_8, 3,3
 
 ;------------------------------------------------------------------------------
 ; void ff_pred4x4_horizontal_down_8_mmxext(uint8_t *src,
-;                                          const uint8_t *topright, int stride)
+;                                          const uint8_t *topright,
+;                                          ptrdiff_t stride)
 ;------------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -2658,7 +2697,8 @@ cglobal pred4x4_horizontal_down_8, 3,3
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred4x4_vertical_right_8_mmxext(uint8_t *src,
-;                                         const uint8_t *topright, int stride)
+;                                         const uint8_t *topright,
+;                                         ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -2689,7 +2729,7 @@ cglobal pred4x4_vertical_right_8, 3,3
 
 ;-----------------------------------------------------------------------------
 ; void ff_pred4x4_down_right_8_mmxext(uint8_t *src, const uint8_t *topright,
-;                                     int stride)
+;                                     ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmxext
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred_10bit.asm b/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred_10bit.asm
index 9e40cfe24b9..629e0a72e3a 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred_10bit.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred_10bit.asm
@@ -51,7 +51,8 @@ SECTION .text
 %endmacro
 
 ;-----------------------------------------------------------------------------
-; void ff_pred4x4_down_right(pixel *src, const pixel *topright, int stride)
+; void ff_pred4x4_down_right_10(pixel *src, const pixel *topright,
+;                               ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED4x4_DR 0
 cglobal pred4x4_down_right_10, 3, 3
@@ -89,7 +90,8 @@ PRED4x4_DR
 %endif
 
 ;------------------------------------------------------------------------------
-; void ff_pred4x4_vertical_right(pixel *src, const pixel *topright, int stride)
+; void ff_pred4x4_vertical_right_10(pixel *src, const pixel *topright,
+;                                   ptrdiff_t stride)
 ;------------------------------------------------------------------------------
 %macro PRED4x4_VR 0
 cglobal pred4x4_vertical_right_10, 3, 3, 6
@@ -128,7 +130,8 @@ PRED4x4_VR
 %endif
 
 ;-------------------------------------------------------------------------------
-; void ff_pred4x4_horizontal_down(pixel *src, const pixel *topright, int stride)
+; void ff_pred4x4_horizontal_down_10(pixel *src, const pixel *topright,
+;                                    ptrdiff_t stride)
 ;-------------------------------------------------------------------------------
 %macro PRED4x4_HD 0
 cglobal pred4x4_horizontal_down_10, 3, 3
@@ -170,7 +173,7 @@ PRED4x4_HD
 %endif
 
 ;-----------------------------------------------------------------------------
-; void ff_pred4x4_dc(pixel *src, const pixel *topright, int stride)
+; void ff_pred4x4_dc_10(pixel *src, const pixel *topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmxext
@@ -195,7 +198,8 @@ cglobal pred4x4_dc_10, 3, 3
     RET
 
 ;-----------------------------------------------------------------------------
-; void ff_pred4x4_down_left(pixel *src, const pixel *topright, int stride)
+; void ff_pred4x4_down_left_10(pixel *src, const pixel *topright,
+;                              ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED4x4_DL 0
 cglobal pred4x4_down_left_10, 3, 3
@@ -225,7 +229,8 @@ PRED4x4_DL
 %endif
 
 ;-----------------------------------------------------------------------------
-; void ff_pred4x4_vertical_left(pixel *src, const pixel *topright, int stride)
+; void ff_pred4x4_vertical_left_10(pixel *src, const pixel *topright,
+;                                  ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED4x4_VL 0
 cglobal pred4x4_vertical_left_10, 3, 3
@@ -254,7 +259,8 @@ PRED4x4_VL
 %endif
 
 ;-----------------------------------------------------------------------------
-; void ff_pred4x4_horizontal_up(pixel *src, const pixel *topright, int stride)
+; void ff_pred4x4_horizontal_up_10(pixel *src, const pixel *topright,
+;                                  ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 INIT_MMX mmxext
 cglobal pred4x4_horizontal_up_10, 3, 3
@@ -288,7 +294,7 @@ cglobal pred4x4_horizontal_up_10, 3, 3
 
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8_vertical(pixel *src, int stride)
+; void ff_pred8x8_vertical_10(pixel *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 INIT_XMM sse2
 cglobal pred8x8_vertical_10, 2, 2
@@ -304,7 +310,7 @@ cglobal pred8x8_vertical_10, 2, 2
     RET
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8_horizontal(pixel *src, int stride)
+; void ff_pred8x8_horizontal_10(pixel *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 INIT_XMM sse2
 cglobal pred8x8_horizontal_10, 2, 3
@@ -324,7 +330,7 @@ cglobal pred8x8_horizontal_10, 2, 3
     REP_RET
 
 ;-----------------------------------------------------------------------------
-; void ff_predict_8x8_dc(pixel *src, int stride)
+; void ff_predict_8x8_dc_10(pixel *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro MOV8 2-3
 ; sort of a hack, but it works
@@ -411,7 +417,7 @@ INIT_XMM sse2
 PRED8x8_DC pshuflw
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8_top_dc(pixel *src, int stride)
+; void ff_pred8x8_top_dc_10(pixel *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 INIT_XMM sse2
 cglobal pred8x8_top_dc_10, 2, 4
@@ -438,7 +444,7 @@ cglobal pred8x8_top_dc_10, 2, 4
     RET
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8_plane(pixel *src, int stride)
+; void ff_pred8x8_plane_10(pixel *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 INIT_XMM sse2
 cglobal pred8x8_plane_10, 2, 7, 7
@@ -501,8 +507,8 @@ cglobal pred8x8_plane_10, 2, 7, 7
 
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8l_128_dc(pixel *src, int has_topleft, int has_topright,
-;                         int stride)
+; void ff_pred8x8l_128_dc_10(pixel *src, int has_topleft, int has_topright,
+;                            ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED8x8L_128_DC 0
 cglobal pred8x8l_128_dc_10, 4, 4
@@ -526,8 +532,8 @@ INIT_XMM sse2
 PRED8x8L_128_DC
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8l_top_dc(pixel *src, int has_topleft, int has_topright,
-;                         int stride)
+; void ff_pred8x8l_top_dc_10(pixel *src, int has_topleft, int has_topright,
+;                            ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED8x8L_TOP_DC 0
 cglobal pred8x8l_top_dc_10, 4, 4, 6
@@ -566,7 +572,8 @@ PRED8x8L_TOP_DC
 %endif
 
 ;-------------------------------------------------------------------------------
-; void ff_pred8x8l_dc(pixel *src, int has_topleft, int has_topright, int stride)
+; void ff_pred8x8l_dc_10(pixel *src, int has_topleft, int has_topright,
+;                        ptrdiff_t stride)
 ;-------------------------------------------------------------------------------
 ;TODO: see if scalar is faster
 %macro PRED8x8L_DC 0
@@ -625,8 +632,8 @@ PRED8x8L_DC
 %endif
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8l_vertical(pixel *src, int has_topleft, int has_topright,
-;                           int stride)
+; void ff_pred8x8l_vertical_10(pixel *src, int has_topleft, int has_topright,
+;                              ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED8x8L_VERTICAL 0
 cglobal pred8x8l_vertical_10, 4, 4, 6
@@ -661,8 +668,8 @@ PRED8x8L_VERTICAL
 %endif
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8l_horizontal(uint8_t *src, int has_topleft, int has_topright,
-;                             int stride)
+; void ff_pred8x8l_horizontal_10(uint8_t *src, int has_topleft,
+;                                int has_topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED8x8L_HORIZONTAL 0
 cglobal pred8x8l_horizontal_10, 4, 4, 5
@@ -718,8 +725,8 @@ PRED8x8L_HORIZONTAL
 %endif
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8l_down_left(pixel *src, int has_topleft, int has_topright,
-;                            int stride)
+; void ff_pred8x8l_down_left_10(pixel *src, int has_topleft, int has_topright,
+;                               ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED8x8L_DOWN_LEFT 0
 cglobal pred8x8l_down_left_10, 4, 4, 7
@@ -787,8 +794,8 @@ PRED8x8L_DOWN_LEFT
 %endif
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8l_down_right(pixel *src, int has_topleft, int has_topright,
-;                             int stride)
+; void ff_pred8x8l_down_right_10(pixel *src, int has_topleft,
+;                                int has_topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED8x8L_DOWN_RIGHT 0
 ; standard forbids this when has_topleft is false
@@ -862,8 +869,8 @@ PRED8x8L_DOWN_RIGHT
 %endif
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8l_vertical_right(pixel *src, int has_topleft,
-;                                 int has_topright, int stride)
+; void ff_pred8x8l_vertical_right_10(pixel *src, int has_topleft,
+;                                    int has_topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED8x8L_VERTICAL_RIGHT 0
 ; likewise with 8x8l_down_right
@@ -933,8 +940,8 @@ PRED8x8L_VERTICAL_RIGHT
 %endif
 
 ;-----------------------------------------------------------------------------
-; void ff_pred8x8l_horizontal_up(pixel *src, int has_topleft,
-;                                int has_topright, int stride)
+; void ff_pred8x8l_horizontal_up_10(pixel *src, int has_topleft,
+;                                   int has_topright, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED8x8L_HORIZONTAL_UP 0
 cglobal pred8x8l_horizontal_up_10, 4, 4, 6
@@ -996,7 +1003,7 @@ PRED8x8L_HORIZONTAL_UP
 
 
 ;-----------------------------------------------------------------------------
-; void ff_pred16x16_vertical(pixel *src, int stride)
+; void ff_pred16x16_vertical_10(pixel *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro MOV16 3-5
     mova [%1+     0], %2
@@ -1032,7 +1039,7 @@ INIT_XMM sse2
 PRED16x16_VERTICAL
 
 ;-----------------------------------------------------------------------------
-; void ff_pred16x16_horizontal(pixel *src, int stride)
+; void ff_pred16x16_horizontal_10(pixel *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED16x16_HORIZONTAL 0
 cglobal pred16x16_horizontal_10, 2, 3
@@ -1056,7 +1063,7 @@ INIT_XMM sse2
 PRED16x16_HORIZONTAL
 
 ;-----------------------------------------------------------------------------
-; void ff_pred16x16_dc(pixel *src, int stride)
+; void ff_pred16x16_dc_10(pixel *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED16x16_DC 0
 cglobal pred16x16_dc_10, 2, 6
@@ -1102,7 +1109,7 @@ INIT_XMM sse2
 PRED16x16_DC
 
 ;-----------------------------------------------------------------------------
-; void ff_pred16x16_top_dc(pixel *src, int stride)
+; void ff_pred16x16_top_dc_10(pixel *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED16x16_TOP_DC 0
 cglobal pred16x16_top_dc_10, 2, 3
@@ -1134,7 +1141,7 @@ INIT_XMM sse2
 PRED16x16_TOP_DC
 
 ;-----------------------------------------------------------------------------
-; void ff_pred16x16_left_dc(pixel *src, int stride)
+; void ff_pred16x16_left_dc_10(pixel *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED16x16_LEFT_DC 0
 cglobal pred16x16_left_dc_10, 2, 6
@@ -1171,7 +1178,7 @@ INIT_XMM sse2
 PRED16x16_LEFT_DC
 
 ;-----------------------------------------------------------------------------
-; void ff_pred16x16_128_dc(pixel *src, int stride)
+; void ff_pred16x16_128_dc_10(pixel *src, ptrdiff_t stride)
 ;-----------------------------------------------------------------------------
 %macro PRED16x16_128_DC 0
 cglobal pred16x16_128_dc_10, 2,3
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred_init.c b/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred_init.c
index 528b92e4978..bdd5125d688 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264_intrapred_init.c
@@ -127,6 +127,7 @@ PRED16x16(plane_svq3, 8, ssse3)
 PRED16x16(tm_vp8, 8, mmx)
 PRED16x16(tm_vp8, 8, mmxext)
 PRED16x16(tm_vp8, 8, sse2)
+PRED16x16(tm_vp8, 8, avx2)
 
 PRED8x8(top_dc, 8, mmxext)
 PRED8x8(dc_rv40, 8, mmxext)
@@ -323,6 +324,12 @@ av_cold void ff_h264_pred_init_x86(H264PredContext *h, int codec_id,
                 }
             }
         }
+
+        if(EXTERNAL_AVX2(cpu_flags)){
+            if (codec_id == AV_CODEC_ID_VP8) {
+                h->pred16x16[PLANE_PRED8x8    ] = ff_pred16x16_tm_vp8_8_avx2;
+            }
+        }
     } else if (bit_depth == 10) {
         if (EXTERNAL_MMXEXT(cpu_flags)) {
             h->pred4x4[DC_PRED             ] = ff_pred4x4_dc_10_mmxext;
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264_qpel.c b/mythtv/external/FFmpeg/libavcodec/x86/h264_qpel.c
index 8c4b1e1288e..0d3dbbadb0b 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264_qpel.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264_qpel.c
@@ -28,7 +28,7 @@
 #include "libavcodec/pixels.h"
 #include "fpel.h"
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 void ff_put_pixels4_l2_mmxext(uint8_t *dst, const uint8_t *src1, const uint8_t *src2,
                               int dstStride, int src1Stride, int h);
 void ff_avg_pixels4_l2_mmxext(uint8_t *dst, const uint8_t *src1, const uint8_t *src2,
@@ -71,6 +71,17 @@ void ff_ ## OPNAME ## _pixels8_l2_shift5_mmxext(uint8_t *dst, const int16_t *src
 DEF_QPEL(avg)
 DEF_QPEL(put)
 
+static av_always_inline void ff_put_h264_qpel8or16_hv1_lowpass_mmxext(int16_t *tmp, const uint8_t *src, int tmpStride, int srcStride, int size)
+{
+    int w = (size + 8) >> 2;
+    src -= 2 * srcStride + 2;
+    while (w--) {
+        ff_put_h264_qpel8or16_hv1_lowpass_op_mmxext(src, tmp, srcStride, size);
+        tmp += 4;
+        src += 4;
+    }
+}
+
 #define QPEL_H264(OPNAME, OP, MMX)\
 static av_always_inline void ff_ ## OPNAME ## h264_qpel4_hv_lowpass_ ## MMX(uint8_t *dst, int16_t *tmp, const uint8_t *src, int dstStride, int tmpStride, int srcStride){\
     int w=3;\
@@ -91,15 +102,6 @@ static av_always_inline void ff_ ## OPNAME ## h264_qpel8or16_v_lowpass_ ## MMX(u
     dst += 4;\
     ff_ ## OPNAME ## h264_qpel8or16_v_lowpass_op_mmxext(dst, src, dstStride, srcStride, h);\
 }\
-static av_always_inline void ff_ ## OPNAME ## h264_qpel8or16_hv1_lowpass_ ## MMX(int16_t *tmp, const uint8_t *src, int tmpStride, int srcStride, int size){\
-    int w = (size+8)>>2;\
-    src -= 2*srcStride+2;\
-    while(w--){\
-        ff_ ## OPNAME ## h264_qpel8or16_hv1_lowpass_op_mmxext(src, tmp, srcStride, size);\
-        tmp += 4;\
-        src += 4;\
-    }\
-}\
 static av_always_inline void ff_ ## OPNAME ## h264_qpel8or16_hv2_lowpass_ ## MMX(uint8_t *dst, int16_t *tmp, int dstStride, int tmpStride, int size){\
     int w = size>>4;\
     do{\
@@ -497,7 +499,7 @@ QPEL16_OP(mc33, MMX)
 QPEL16(mmxext)
 #endif
 
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 #define SET_QPEL_FUNCS(PFX, IDX, SIZE, CPU, PREFIX)                          \
     do {                                                                     \
@@ -537,7 +539,7 @@ QPEL16(mmxext)
 
 av_cold void ff_h264qpel_init_x86(H264QpelContext *c, int bit_depth)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int high_bit_depth = bit_depth > 8;
     int cpu_flags = av_get_cpu_flags();
 
@@ -562,11 +564,6 @@ av_cold void ff_h264qpel_init_x86(H264QpelContext *c, int bit_depth)
     }
 
     if (EXTERNAL_SSE2(cpu_flags)) {
-        if (!(cpu_flags & AV_CPU_FLAG_SSE2SLOW) && !high_bit_depth) {
-            // these functions are slower than mmx on AMD, but faster on Intel
-            H264_QPEL_FUNCS(0, 0, sse2);
-        }
-
         if (!high_bit_depth) {
             H264_QPEL_FUNCS(0, 1, sse2);
             H264_QPEL_FUNCS(0, 2, sse2);
@@ -593,6 +590,12 @@ av_cold void ff_h264qpel_init_x86(H264QpelContext *c, int bit_depth)
         }
     }
 
+    if (EXTERNAL_SSE2_FAST(cpu_flags)) {
+        if (!high_bit_depth) {
+            H264_QPEL_FUNCS(0, 0, sse2);
+        }
+    }
+
     if (EXTERNAL_SSSE3(cpu_flags)) {
         if (!high_bit_depth) {
             H264_QPEL_FUNCS(1, 0, ssse3);
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264chroma_init.c b/mythtv/external/FFmpeg/libavcodec/x86/h264chroma_init.c
index e08af2759e2..36bf29df020 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264chroma_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264chroma_init.c
@@ -25,38 +25,38 @@
 #include "libavcodec/h264chroma.h"
 
 void ff_put_h264_chroma_mc8_rnd_mmx  (uint8_t *dst, uint8_t *src,
-                                      int stride, int h, int x, int y);
+                                      ptrdiff_t stride, int h, int x, int y);
 void ff_avg_h264_chroma_mc8_rnd_mmxext(uint8_t *dst, uint8_t *src,
-                                       int stride, int h, int x, int y);
+                                       ptrdiff_t stride, int h, int x, int y);
 void ff_avg_h264_chroma_mc8_rnd_3dnow(uint8_t *dst, uint8_t *src,
-                                      int stride, int h, int x, int y);
+                                      ptrdiff_t stride, int h, int x, int y);
 
 void ff_put_h264_chroma_mc4_mmx      (uint8_t *dst, uint8_t *src,
-                                      int stride, int h, int x, int y);
+                                      ptrdiff_t stride, int h, int x, int y);
 void ff_avg_h264_chroma_mc4_mmxext   (uint8_t *dst, uint8_t *src,
-                                      int stride, int h, int x, int y);
+                                      ptrdiff_t stride, int h, int x, int y);
 void ff_avg_h264_chroma_mc4_3dnow    (uint8_t *dst, uint8_t *src,
-                                      int stride, int h, int x, int y);
+                                      ptrdiff_t stride, int h, int x, int y);
 
 void ff_put_h264_chroma_mc2_mmxext   (uint8_t *dst, uint8_t *src,
-                                      int stride, int h, int x, int y);
+                                      ptrdiff_t stride, int h, int x, int y);
 void ff_avg_h264_chroma_mc2_mmxext   (uint8_t *dst, uint8_t *src,
-                                      int stride, int h, int x, int y);
+                                      ptrdiff_t stride, int h, int x, int y);
 
 void ff_put_h264_chroma_mc8_rnd_ssse3(uint8_t *dst, uint8_t *src,
-                                      int stride, int h, int x, int y);
+                                      ptrdiff_t stride, int h, int x, int y);
 void ff_put_h264_chroma_mc4_ssse3    (uint8_t *dst, uint8_t *src,
-                                      int stride, int h, int x, int y);
+                                      ptrdiff_t stride, int h, int x, int y);
 
 void ff_avg_h264_chroma_mc8_rnd_ssse3(uint8_t *dst, uint8_t *src,
-                                      int stride, int h, int x, int y);
+                                      ptrdiff_t stride, int h, int x, int y);
 void ff_avg_h264_chroma_mc4_ssse3    (uint8_t *dst, uint8_t *src,
-                                      int stride, int h, int x, int y);
+                                      ptrdiff_t stride, int h, int x, int y);
 
 #define CHROMA_MC(OP, NUM, DEPTH, OPT)                                  \
 void ff_ ## OP ## _h264_chroma_mc ## NUM ## _ ## DEPTH ## _ ## OPT      \
                                       (uint8_t *dst, uint8_t *src,      \
-                                       int stride, int h, int x, int y);
+                                       ptrdiff_t stride, int h, int x, int y);
 
 CHROMA_MC(put, 2, 10, mmxext)
 CHROMA_MC(avg, 2, 10, mmxext)
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/h264dsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/h264dsp_init.c
index d2452c71316..39f65c151f7 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/h264dsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/h264dsp_init.c
@@ -32,8 +32,12 @@ void ff_h264_idct ## NUM ## _add_ ## DEPTH ## _ ## OPT(uint8_t *dst,    \
                                                        int stride);
 
 IDCT_ADD_FUNC(, 8, mmx)
+IDCT_ADD_FUNC(, 8, sse2)
+IDCT_ADD_FUNC(, 8, avx)
 IDCT_ADD_FUNC(, 10, sse2)
 IDCT_ADD_FUNC(_dc, 8, mmxext)
+IDCT_ADD_FUNC(_dc, 8, sse2)
+IDCT_ADD_FUNC(_dc, 8, avx)
 IDCT_ADD_FUNC(_dc, 10, mmxext)
 IDCT_ADD_FUNC(8_dc, 8, mmxext)
 IDCT_ADD_FUNC(8_dc, 10, sse2)
@@ -78,6 +82,11 @@ IDCT_ADD_REP_FUNC2(, 8, 8, sse2)
 IDCT_ADD_REP_FUNC2(, 8, 10, sse2)
 IDCT_ADD_REP_FUNC2(, 8, 10, avx)
 
+IDCT_ADD_REP_FUNC2(, 8_422, 8, mmx)
+
+IDCT_ADD_REP_FUNC2(, 8_422, 10, sse2)
+IDCT_ADD_REP_FUNC2(, 8_422, 10, avx)
+
 void ff_h264_luma_dc_dequant_idct_mmx(int16_t *output, int16_t *input, int qmul);
 void ff_h264_luma_dc_dequant_idct_sse2(int16_t *output, int16_t *input, int qmul);
 
@@ -103,34 +112,41 @@ void ff_deblock_ ## DIR ## _ ## TYPE ## _ ## DEPTH ## _ ## OPT(uint8_t *pix,  \
                                                                int beta);
 
 #define LF_FUNCS(type, depth)                   \
-LF_FUNC(h,  chroma,       depth, mmxext)        \
-LF_IFUNC(h, chroma_intra, depth, mmxext)        \
-LF_FUNC(v,  chroma,       depth, mmxext)        \
-LF_IFUNC(v, chroma_intra, depth, mmxext)        \
-LF_FUNC(h,  luma,         depth, mmxext)        \
-LF_IFUNC(h, luma_intra,   depth, mmxext)        \
-LF_FUNC(h,  luma,         depth, sse2)          \
-LF_IFUNC(h, luma_intra,   depth, sse2)          \
-LF_FUNC(v,  luma,         depth, sse2)          \
-LF_IFUNC(v, luma_intra,   depth, sse2)          \
-LF_FUNC(h,  chroma,       depth, sse2)          \
-LF_IFUNC(h, chroma_intra, depth, sse2)          \
-LF_FUNC(v,  chroma,       depth, sse2)          \
-LF_IFUNC(v, chroma_intra, depth, sse2)          \
-LF_FUNC(h,  luma,         depth, avx)           \
-LF_IFUNC(h, luma_intra,   depth, avx)           \
-LF_FUNC(v,  luma,         depth, avx)           \
-LF_IFUNC(v, luma_intra,   depth, avx)           \
-LF_FUNC(h,  chroma,       depth, avx)           \
-LF_IFUNC(h, chroma_intra, depth, avx)           \
-LF_FUNC(v,  chroma,       depth, avx)           \
-LF_IFUNC(v, chroma_intra, depth, avx)
+LF_FUNC(h,  chroma,          depth, mmxext)     \
+LF_IFUNC(h, chroma_intra,    depth, mmxext)     \
+LF_FUNC(h,  chroma422,       depth, mmxext)     \
+LF_IFUNC(h, chroma422_intra, depth, mmxext)     \
+LF_FUNC(v,  chroma,          depth, mmxext)     \
+LF_IFUNC(v, chroma_intra,    depth, mmxext)     \
+LF_FUNC(h,  luma,            depth, mmxext)     \
+LF_IFUNC(h, luma_intra,      depth, mmxext)     \
+LF_FUNC(h,  luma,            depth, sse2)       \
+LF_IFUNC(h, luma_intra,      depth, sse2)       \
+LF_FUNC(v,  luma,            depth, sse2)       \
+LF_IFUNC(v, luma_intra,      depth, sse2)       \
+LF_FUNC(h,  chroma,          depth, sse2)       \
+LF_IFUNC(h, chroma_intra,    depth, sse2)       \
+LF_FUNC(h,  chroma422,       depth, sse2)       \
+LF_IFUNC(h, chroma422_intra, depth, sse2)       \
+LF_FUNC(v,  chroma,          depth, sse2)       \
+LF_IFUNC(v, chroma_intra,    depth, sse2)       \
+LF_FUNC(h,  luma,            depth, avx)        \
+LF_IFUNC(h, luma_intra,      depth, avx)        \
+LF_FUNC(v,  luma,            depth, avx)        \
+LF_IFUNC(v, luma_intra,      depth, avx)        \
+LF_FUNC(h,  chroma,          depth, avx)        \
+LF_IFUNC(h, chroma_intra,    depth, avx)        \
+LF_FUNC(h,  chroma422,       depth, avx)        \
+LF_IFUNC(h, chroma422_intra, depth, avx)        \
+LF_FUNC(v,  chroma,          depth, avx)        \
+LF_IFUNC(v, chroma_intra,    depth, avx)
+
+LF_FUNC(h, luma_mbaff, 8, sse2)
+LF_FUNC(h, luma_mbaff, 8, avx)
 
 LF_FUNCS(uint8_t,   8)
 LF_FUNCS(uint16_t, 10)
 
-void ff_deblock_h_chroma422_8_mmxext(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0);
-
 #if ARCH_X86_32 && HAVE_MMXEXT_EXTERNAL
 LF_FUNC(v8, luma, 8, mmxext)
 static void deblock_v_luma_8_mmxext(uint8_t *pix, int stride, int alpha,
@@ -212,7 +228,7 @@ H264_BIWEIGHT_10_SSE(4,  10)
 av_cold void ff_h264dsp_init_x86(H264DSPContext *c, const int bit_depth,
                                  const int chroma_format_idc)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_MMXEXT(cpu_flags) && chroma_format_idc <= 1)
@@ -227,8 +243,11 @@ av_cold void ff_h264dsp_init_x86(H264DSPContext *c, const int bit_depth,
 
             c->h264_idct_add16 = ff_h264_idct_add16_8_mmx;
             c->h264_idct8_add4 = ff_h264_idct8_add4_8_mmx;
-            if (chroma_format_idc <= 1)
+            if (chroma_format_idc <= 1) {
                 c->h264_idct_add8 = ff_h264_idct_add8_8_mmx;
+            } else {
+                c->h264_idct_add8 = ff_h264_idct_add8_422_8_mmx;
+            }
             c->h264_idct_add16intra = ff_h264_idct_add16intra_8_mmx;
             if (cpu_flags & AV_CPU_FLAG_CMOV)
                 c->h264_luma_dc_dequant_idct = ff_h264_luma_dc_dequant_idct_mmx;
@@ -249,6 +268,7 @@ av_cold void ff_h264dsp_init_x86(H264DSPContext *c, const int bit_depth,
                 c->h264_h_loop_filter_chroma_intra = ff_deblock_h_chroma_intra_8_mmxext;
             } else {
                 c->h264_h_loop_filter_chroma = ff_deblock_h_chroma422_8_mmxext;
+                c->h264_h_loop_filter_chroma_intra = ff_deblock_h_chroma422_intra_8_mmxext;
             }
 #if ARCH_X86_32 && HAVE_MMXEXT_EXTERNAL
             c->h264_v_loop_filter_luma       = deblock_v_luma_8_mmxext;
@@ -284,6 +304,23 @@ av_cold void ff_h264dsp_init_x86(H264DSPContext *c, const int bit_depth,
             c->h264_h_loop_filter_luma       = ff_deblock_h_luma_8_sse2;
             c->h264_v_loop_filter_luma_intra = ff_deblock_v_luma_intra_8_sse2;
             c->h264_h_loop_filter_luma_intra = ff_deblock_h_luma_intra_8_sse2;
+
+#if ARCH_X86_64
+            c->h264_h_loop_filter_luma_mbaff = ff_deblock_h_luma_mbaff_8_sse2;
+#endif
+
+            c->h264_v_loop_filter_chroma       = ff_deblock_v_chroma_8_sse2;
+            c->h264_v_loop_filter_chroma_intra = ff_deblock_v_chroma_intra_8_sse2;
+            if (chroma_format_idc <= 1) {
+                c->h264_h_loop_filter_chroma       = ff_deblock_h_chroma_8_sse2;
+                c->h264_h_loop_filter_chroma_intra = ff_deblock_h_chroma_intra_8_sse2;
+            } else {
+                c->h264_h_loop_filter_chroma       = ff_deblock_h_chroma422_8_sse2;
+                c->h264_h_loop_filter_chroma_intra = ff_deblock_h_chroma422_intra_8_sse2;
+            }
+
+            c->h264_idct_add        = ff_h264_idct_add_8_sse2;
+            c->h264_idct_dc_add     = ff_h264_idct_dc_add_8_sse2;
         }
         if (EXTERNAL_SSSE3(cpu_flags)) {
             c->biweight_h264_pixels_tab[0] = ff_h264_biweight_16_ssse3;
@@ -294,12 +331,33 @@ av_cold void ff_h264dsp_init_x86(H264DSPContext *c, const int bit_depth,
             c->h264_h_loop_filter_luma       = ff_deblock_h_luma_8_avx;
             c->h264_v_loop_filter_luma_intra = ff_deblock_v_luma_intra_8_avx;
             c->h264_h_loop_filter_luma_intra = ff_deblock_h_luma_intra_8_avx;
+#if ARCH_X86_64
+            c->h264_h_loop_filter_luma_mbaff = ff_deblock_h_luma_mbaff_8_avx;
+#endif
+
+            c->h264_v_loop_filter_chroma       = ff_deblock_v_chroma_8_avx;
+            c->h264_v_loop_filter_chroma_intra = ff_deblock_v_chroma_intra_8_avx;
+            if (chroma_format_idc <= 1) {
+                c->h264_h_loop_filter_chroma       = ff_deblock_h_chroma_8_avx;
+                c->h264_h_loop_filter_chroma_intra = ff_deblock_h_chroma_intra_8_avx;
+            } else {
+                c->h264_h_loop_filter_chroma       = ff_deblock_h_chroma422_8_avx;
+                c->h264_h_loop_filter_chroma_intra = ff_deblock_h_chroma422_intra_8_avx;
+            }
+
+            c->h264_idct_add        = ff_h264_idct_add_8_avx;
+            c->h264_idct_dc_add     = ff_h264_idct_dc_add_8_avx;
         }
     } else if (bit_depth == 10) {
         if (EXTERNAL_MMXEXT(cpu_flags)) {
 #if ARCH_X86_32
             c->h264_v_loop_filter_chroma       = ff_deblock_v_chroma_10_mmxext;
             c->h264_v_loop_filter_chroma_intra = ff_deblock_v_chroma_intra_10_mmxext;
+            if (chroma_format_idc <= 1) {
+                c->h264_h_loop_filter_chroma = ff_deblock_h_chroma_10_mmxext;
+            } else {
+                c->h264_h_loop_filter_chroma = ff_deblock_h_chroma422_10_mmxext;
+            }
             c->h264_v_loop_filter_luma         = ff_deblock_v_luma_10_mmxext;
             c->h264_h_loop_filter_luma         = ff_deblock_h_luma_10_mmxext;
             c->h264_v_loop_filter_luma_intra   = ff_deblock_v_luma_intra_10_mmxext;
@@ -312,8 +370,11 @@ av_cold void ff_h264dsp_init_x86(H264DSPContext *c, const int bit_depth,
             c->h264_idct8_dc_add = ff_h264_idct8_dc_add_10_sse2;
 
             c->h264_idct_add16 = ff_h264_idct_add16_10_sse2;
-            if (chroma_format_idc <= 1)
+            if (chroma_format_idc <= 1) {
                 c->h264_idct_add8 = ff_h264_idct_add8_10_sse2;
+            } else {
+                c->h264_idct_add8 = ff_h264_idct_add8_422_10_sse2;
+            }
             c->h264_idct_add16intra = ff_h264_idct_add16intra_10_sse2;
 #if HAVE_ALIGNED_STACK
             c->h264_idct8_add  = ff_h264_idct8_add_10_sse2;
@@ -330,6 +391,11 @@ av_cold void ff_h264dsp_init_x86(H264DSPContext *c, const int bit_depth,
 
             c->h264_v_loop_filter_chroma       = ff_deblock_v_chroma_10_sse2;
             c->h264_v_loop_filter_chroma_intra = ff_deblock_v_chroma_intra_10_sse2;
+            if (chroma_format_idc <= 1) {
+                c->h264_h_loop_filter_chroma = ff_deblock_h_chroma_10_sse2;
+            } else {
+                c->h264_h_loop_filter_chroma = ff_deblock_h_chroma422_10_sse2;
+            }
 #if HAVE_ALIGNED_STACK
             c->h264_v_loop_filter_luma       = ff_deblock_v_luma_10_sse2;
             c->h264_h_loop_filter_luma       = ff_deblock_h_luma_10_sse2;
@@ -352,8 +418,11 @@ av_cold void ff_h264dsp_init_x86(H264DSPContext *c, const int bit_depth,
             c->h264_idct8_dc_add = ff_h264_idct8_dc_add_10_avx;
 
             c->h264_idct_add16 = ff_h264_idct_add16_10_avx;
-            if (chroma_format_idc <= 1)
+            if (chroma_format_idc <= 1) {
                 c->h264_idct_add8 = ff_h264_idct_add8_10_avx;
+            } else {
+                c->h264_idct_add8 = ff_h264_idct_add8_422_10_avx;
+            }
             c->h264_idct_add16intra = ff_h264_idct_add16intra_10_avx;
 #if HAVE_ALIGNED_STACK
             c->h264_idct8_add  = ff_h264_idct8_add_10_avx;
@@ -362,6 +431,11 @@ av_cold void ff_h264dsp_init_x86(H264DSPContext *c, const int bit_depth,
 
             c->h264_v_loop_filter_chroma       = ff_deblock_v_chroma_10_avx;
             c->h264_v_loop_filter_chroma_intra = ff_deblock_v_chroma_intra_10_avx;
+            if (chroma_format_idc <= 1) {
+                c->h264_h_loop_filter_chroma = ff_deblock_h_chroma_10_avx;
+            } else {
+                c->h264_h_loop_filter_chroma = ff_deblock_h_chroma422_10_avx;
+            }
 #if HAVE_ALIGNED_STACK
             c->h264_v_loop_filter_luma         = ff_deblock_v_luma_10_avx;
             c->h264_h_loop_filter_luma         = ff_deblock_h_luma_10_avx;
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/hevc_add_res.asm b/mythtv/external/FFmpeg/libavcodec/x86/hevc_add_res.asm
new file mode 100644
index 00000000000..36d4d8e2e2e
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/hevc_add_res.asm
@@ -0,0 +1,369 @@
+; *****************************************************************************
+; * Provide SIMD optimizations for add_residual functions for HEVC decoding
+; * Copyright (c) 2014 Pierre-Edouard LEPERE
+; *
+; * 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/x86/x86util.asm"
+
+SECTION .text
+
+cextern pw_1023
+%define max_pixels_10 pw_1023
+
+; the add_res macros and functions were largely inspired by h264_idct.asm from the x264 project
+%macro ADD_RES_MMX_4_8 0
+    mova              m0, [r1]
+    mova              m2, [r1+8]
+    pxor              m1, m1
+    pxor              m3, m3
+    psubw             m1, m0
+    psubw             m3, m2
+    packuswb          m0, m2
+    packuswb          m1, m3
+
+    movd              m2, [r0]
+    movd              m3, [r0+r2]
+    punpckldq         m2, m3
+    paddusb           m0, m2
+    psubusb           m0, m1
+    movd            [r0], m0
+    psrlq             m0, 32
+    movd         [r0+r2], m0
+%endmacro
+
+
+INIT_MMX mmxext
+; void ff_hevc_add_residual_4_8_mmxext(uint8_t *dst, int16_t *res, ptrdiff_t stride)
+cglobal hevc_add_residual_4_8, 3, 3, 6
+    ADD_RES_MMX_4_8
+    add               r1, 16
+    lea               r0, [r0+r2*2]
+    ADD_RES_MMX_4_8
+    RET
+
+%macro ADD_RES_SSE_8_8 0
+    pxor              m3, m3
+    mova              m4, [r1]
+    mova              m6, [r1+16]
+    mova              m0, [r1+32]
+    mova              m2, [r1+48]
+    psubw             m5, m3, m4
+    psubw             m7, m3, m6
+    psubw             m1, m3, m0
+    packuswb          m4, m0
+    packuswb          m5, m1
+    psubw             m3, m2
+    packuswb          m6, m2
+    packuswb          m7, m3
+
+    movq              m0, [r0]
+    movq              m1, [r0+r2]
+    movhps            m0, [r0+r2*2]
+    movhps            m1, [r0+r3]
+    paddusb           m0, m4
+    paddusb           m1, m6
+    psubusb           m0, m5
+    psubusb           m1, m7
+    movq            [r0], m0
+    movq         [r0+r2], m1
+    movhps     [r0+2*r2], m0
+    movhps       [r0+r3], m1
+%endmacro
+
+%macro ADD_RES_SSE_16_32_8 3
+    mova             xm2, [r1+%1]
+    mova             xm6, [r1+%1+16]
+%if cpuflag(avx2)
+    vinserti128       m2, m2, [r1+%1+32], 1
+    vinserti128       m6, m6, [r1+%1+48], 1
+%endif
+    psubw             m1, m0, m2
+    psubw             m5, m0, m6
+    packuswb          m2, m6
+    packuswb          m1, m5
+
+    mova             xm4, [r1+%1+mmsize*2]
+    mova             xm6, [r1+%1+mmsize*2+16]
+%if cpuflag(avx2)
+    vinserti128       m4, m4, [r1+%1+96 ], 1
+    vinserti128       m6, m6, [r1+%1+112], 1
+%endif
+    psubw             m3, m0, m4
+    psubw             m5, m0, m6
+    packuswb          m4, m6
+    packuswb          m3, m5
+
+    paddusb           m2, [%2]
+    paddusb           m4, [%3]
+    psubusb           m2, m1
+    psubusb           m4, m3
+    mova            [%2], m2
+    mova            [%3], m4
+%endmacro
+
+
+%macro TRANSFORM_ADD_8 0
+; void ff_hevc_add_residual_8_8_<opt>(uint8_t *dst, int16_t *res, ptrdiff_t stride)
+cglobal hevc_add_residual_8_8, 3, 4, 8
+    lea               r3, [r2*3]
+    ADD_RES_SSE_8_8
+    add               r1, 64
+    lea               r0, [r0+r2*4]
+    ADD_RES_SSE_8_8
+    RET
+
+; void ff_hevc_add_residual_16_8_<opt>(uint8_t *dst, int16_t *res, ptrdiff_t stride)
+cglobal hevc_add_residual_16_8, 3, 5, 7
+    pxor                m0, m0
+    lea                 r3, [r2*3]
+    mov                r4d, 4
+.loop:
+    ADD_RES_SSE_16_32_8  0, r0,      r0+r2
+    ADD_RES_SSE_16_32_8 64, r0+r2*2, r0+r3
+    add                 r1, 128
+    lea                 r0, [r0+r2*4]
+    dec                r4d
+    jg .loop
+    RET
+
+; void ff_hevc_add_residual_32_8_<opt>(uint8_t *dst, int16_t *res, ptrdiff_t stride)
+cglobal hevc_add_residual_32_8, 3, 5, 7
+    pxor                m0, m0
+    mov                r4d, 16
+.loop:
+    ADD_RES_SSE_16_32_8  0, r0,    r0+16
+    ADD_RES_SSE_16_32_8 64, r0+r2, r0+r2+16
+    add                 r1, 128
+    lea                 r0, [r0+r2*2]
+    dec                r4d
+    jg .loop
+    RET
+%endmacro
+
+INIT_XMM sse2
+TRANSFORM_ADD_8
+INIT_XMM avx
+TRANSFORM_ADD_8
+
+%if HAVE_AVX2_EXTERNAL
+INIT_YMM avx2
+; void ff_hevc_add_residual_32_8_avx2(uint8_t *dst, int16_t *res, ptrdiff_t stride)
+cglobal hevc_add_residual_32_8, 3, 5, 7
+    pxor                 m0, m0
+    lea                  r3, [r2*3]
+    mov                 r4d, 8
+.loop:
+    ADD_RES_SSE_16_32_8   0, r0,      r0+r2
+    ADD_RES_SSE_16_32_8 128, r0+r2*2, r0+r3
+    add                  r1, 256
+    lea                  r0, [r0+r2*4]
+    dec                 r4d
+    jg .loop
+    RET
+%endif ;HAVE_AVX2_EXTERNAL
+
+%macro ADD_RES_SSE_8_10 4
+    mova              m0, [%4]
+    mova              m1, [%4+16]
+    mova              m2, [%4+32]
+    mova              m3, [%4+48]
+    paddw             m0, [%1+0]
+    paddw             m1, [%1+%2]
+    paddw             m2, [%1+%2*2]
+    paddw             m3, [%1+%3]
+    CLIPW             m0, m4, m5
+    CLIPW             m1, m4, m5
+    CLIPW             m2, m4, m5
+    CLIPW             m3, m4, m5
+    mova          [%1+0], m0
+    mova         [%1+%2], m1
+    mova       [%1+%2*2], m2
+    mova         [%1+%3], m3
+%endmacro
+
+%macro ADD_RES_MMX_4_10 3
+    mova              m0, [%1+0]
+    mova              m1, [%1+%2]
+    paddw             m0, [%3]
+    paddw             m1, [%3+8]
+    CLIPW             m0, m2, m3
+    CLIPW             m1, m2, m3
+    mova          [%1+0], m0
+    mova         [%1+%2], m1
+%endmacro
+
+%macro ADD_RES_SSE_16_10 3
+    mova              m0, [%3]
+    mova              m1, [%3+16]
+    mova              m2, [%3+32]
+    mova              m3, [%3+48]
+    paddw             m0, [%1]
+    paddw             m1, [%1+16]
+    paddw             m2, [%1+%2]
+    paddw             m3, [%1+%2+16]
+    CLIPW             m0, m4, m5
+    CLIPW             m1, m4, m5
+    CLIPW             m2, m4, m5
+    CLIPW             m3, m4, m5
+    mova            [%1], m0
+    mova         [%1+16], m1
+    mova         [%1+%2], m2
+    mova      [%1+%2+16], m3
+%endmacro
+
+%macro ADD_RES_SSE_32_10 2
+    mova              m0, [%2]
+    mova              m1, [%2+16]
+    mova              m2, [%2+32]
+    mova              m3, [%2+48]
+
+    paddw             m0, [%1]
+    paddw             m1, [%1+16]
+    paddw             m2, [%1+32]
+    paddw             m3, [%1+48]
+    CLIPW             m0, m4, m5
+    CLIPW             m1, m4, m5
+    CLIPW             m2, m4, m5
+    CLIPW             m3, m4, m5
+    mova            [%1], m0
+    mova         [%1+16], m1
+    mova         [%1+32], m2
+    mova         [%1+48], m3
+%endmacro
+
+%macro ADD_RES_AVX2_16_10 4
+    mova              m0, [%4]
+    mova              m1, [%4+32]
+    mova              m2, [%4+64]
+    mova              m3, [%4+96]
+
+    paddw             m0, [%1+0]
+    paddw             m1, [%1+%2]
+    paddw             m2, [%1+%2*2]
+    paddw             m3, [%1+%3]
+
+    CLIPW             m0, m4, m5
+    CLIPW             m1, m4, m5
+    CLIPW             m2, m4, m5
+    CLIPW             m3, m4, m5
+    mova          [%1+0], m0
+    mova         [%1+%2], m1
+    mova       [%1+%2*2], m2
+    mova         [%1+%3], m3
+%endmacro
+
+%macro ADD_RES_AVX2_32_10 3
+    mova              m0, [%3]
+    mova              m1, [%3+32]
+    mova              m2, [%3+64]
+    mova              m3, [%3+96]
+
+    paddw             m0, [%1]
+    paddw             m1, [%1+32]
+    paddw             m2, [%1+%2]
+    paddw             m3, [%1+%2+32]
+
+    CLIPW             m0, m4, m5
+    CLIPW             m1, m4, m5
+    CLIPW             m2, m4, m5
+    CLIPW             m3, m4, m5
+    mova            [%1], m0
+    mova         [%1+32], m1
+    mova         [%1+%2], m2
+    mova      [%1+%2+32], m3
+%endmacro
+
+; void ff_hevc_add_residual_<4|8|16|32>_10(pixel *dst, int16_t *block, ptrdiff_t stride)
+INIT_MMX mmxext
+cglobal hevc_add_residual_4_10, 3, 3, 6
+    pxor              m2, m2
+    mova              m3, [max_pixels_10]
+    ADD_RES_MMX_4_10  r0, r2, r1
+    add               r1, 16
+    lea               r0, [r0+2*r2]
+    ADD_RES_MMX_4_10  r0, r2, r1
+    RET
+
+INIT_XMM sse2
+cglobal hevc_add_residual_8_10, 3, 4, 6
+    pxor              m4, m4
+    mova              m5, [max_pixels_10]
+    lea               r3, [r2*3]
+
+    ADD_RES_SSE_8_10  r0, r2, r3, r1
+    lea               r0, [r0+r2*4]
+    add               r1, 64
+    ADD_RES_SSE_8_10  r0, r2, r3, r1
+    RET
+
+cglobal hevc_add_residual_16_10, 3, 5, 6
+    pxor              m4, m4
+    mova              m5, [max_pixels_10]
+
+    mov              r4d, 8
+.loop:
+    ADD_RES_SSE_16_10 r0, r2, r1
+    lea               r0, [r0+r2*2]
+    add               r1, 64
+    dec              r4d
+    jg .loop
+    RET
+
+cglobal hevc_add_residual_32_10, 3, 5, 6
+    pxor              m4, m4
+    mova              m5, [max_pixels_10]
+
+    mov              r4d, 32
+.loop:
+    ADD_RES_SSE_32_10 r0, r1
+    lea               r0, [r0+r2]
+    add               r1, 64
+    dec              r4d
+    jg .loop
+    RET
+
+%if HAVE_AVX2_EXTERNAL
+INIT_YMM avx2
+cglobal hevc_add_residual_16_10, 3, 5, 6
+    pxor               m4, m4
+    mova               m5, [max_pixels_10]
+    lea                r3, [r2*3]
+
+    mov               r4d, 4
+.loop:
+    ADD_RES_AVX2_16_10 r0, r2, r3, r1
+    lea                r0, [r0+r2*4]
+    add                r1, 128
+    dec               r4d
+    jg .loop
+    RET
+
+cglobal hevc_add_residual_32_10, 3, 5, 6
+    pxor               m4, m4
+    mova               m5, [max_pixels_10]
+
+    mov               r4d, 16
+.loop:
+    ADD_RES_AVX2_32_10 r0, r2, r1
+    lea                r0, [r0+r2*2]
+    add                r1, 128
+    dec               r4d
+    jg .loop
+    RET
+%endif ;HAVE_AVX2_EXTERNAL
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/hevc_deblock.asm b/mythtv/external/FFmpeg/libavcodec/x86/hevc_deblock.asm
index 48a597530b2..85ee4800bb0 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/hevc_deblock.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/hevc_deblock.asm
@@ -39,11 +39,6 @@ cextern pw_m1
 SECTION .text
 INIT_XMM sse2
 
-; expands to [base],...,[base+7*stride]
-%define PASS8ROWS(base, base3, stride, stride3) \
-    [base], [base+stride], [base+stride*2], [base3], \
-    [base3+stride], [base3+stride*2], [base3+stride3], [base3+stride*4]
-
 ; in: 8 rows of 4 bytes in %4..%11
 ; out: 4 rows of 8 words in m0..m3
 %macro TRANSPOSE4x8B_LOAD 8
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/hevc_idct.asm b/mythtv/external/FFmpeg/libavcodec/x86/hevc_idct.asm
index 2edaf9aef15..1eb1973f275 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/hevc_idct.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/hevc_idct.asm
@@ -1,37 +1,250 @@
-; /*
-; * SIMD optimized idct functions for HEVC decoding
-; * Copyright (c) 2014 Pierre-Edouard LEPERE
-; * Copyright (c) 2014 James Almer
-; *
-; * 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
-; */
+;*******************************************************************************
+;* SIMD-optimized IDCT functions for HEVC decoding
+;* Copyright (c) 2014 Pierre-Edouard LEPERE
+;* Copyright (c) 2014 James Almer
+;* Copyright (c) 2016 Alexandra Hájková
+;*
+;* 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/x86/x86util.asm"
 
+SECTION_RODATA
+
+pd_64: times 4 dd 64
+pd_2048: times 4 dd 2048
+pd_512: times 4 dd 512
+
+; 4x4 transform coeffs
+cextern pw_64
+pw_64_m64: times 4 dw 64, -64
+pw_83_36: times 4 dw 83, 36
+pw_36_m83: times 4 dw 36, -83
+
+; 8x8 transform coeffs
+pw_89_75: times 4 dw 89, 75
+pw_50_18: times 4 dw 50, 18
+
+pw_75_m18: times 4 dw 75, -18
+pw_m89_m50: times 4 dw -89, -50
+
+pw_50_m89: times 4 dw 50, -89
+pw_18_75: times 4 dw 18, 75
+
+pw_18_m50: times 4 dw 18, -50
+pw_75_m89: times 4 dw 75, -89
+
+; 16x16 transformation coeffs
+trans_coeffs16: times 4 dw 90, 87
+times 4 dw 80, 70
+times 4 dw 57, 43
+times 4 dw 25, 9
+
+times 4 dw 87, 57
+times 4 dw 9, -43
+times 4 dw -80, -90
+times 4 dw -70, -25
+
+times 4 dw 80, 9
+times 4 dw -70, -87
+times 4 dw -25, 57
+times 4 dw 90, 43
+
+times 4 dw 70, -43
+times 4 dw -87, 9
+times 4 dw 90, 25
+times 4 dw -80, -57
+
+times 4 dw 57, -80
+times 4 dw -25, 90
+times 4 dw -9, -87
+times 4 dw 43, 70
+
+times 4 dw 43, -90
+times 4 dw 57, 25
+times 4 dw -87, 70
+times 4 dw 9, -80
+
+times 4 dw 25, -70
+times 4 dw 90, -80
+times 4 dw 43, 9
+times 4 dw -57, 87
+
+times 4 dw 9, -25
+times 4 dw 43, -57
+times 4 dw 70, -80
+times 4 dw 87, -90
+
+; 32x32 transform coeffs
+trans_coeff32: times 8 dw 90
+times 4 dw 88, 85
+times 4 dw 82, 78
+times 4 dw 73, 67
+times 4 dw 61, 54
+times 4 dw 46, 38
+times 4 dw 31, 22
+times 4 dw 13, 4
+
+times 4 dw 90, 82
+times 4 dw 67, 46
+times 4 dw 22, -4
+times 4 dw -31, -54
+times 4 dw -73, -85
+times 4 dw -90, -88
+times 4 dw -78, -61
+times 4 dw -38, -13
+
+times 4 dw 88, 67
+times 4 dw 31, -13
+times 4 dw -54, -82
+times 4 dw -90, -78
+times 4 dw -46, -4
+times 4 dw 38, 73
+times 4 dw 90, 85
+times 4 dw 61, 22
+
+times 4 dw 85, 46
+times 4 dw -13, -67
+times 4 dw -90, -73
+times 4 dw -22, 38
+times 4 dw 82, 88
+times 4 dw 54, -4
+times 4 dw -61, -90
+times 4 dw -78, -31
+
+times 4 dw 82, 22
+times 4 dw -54, -90
+times 4 dw -61, 13
+times 4 dw 78, 85
+times 4 dw 31, -46
+times 4 dw -90, -67
+times 4 dw 4, 73
+times 4 dw 88, 38
+
+times 4 dw 78, -4
+times 4 dw -82, -73
+times 4 dw 13, 85
+times 4 dw 67, -22
+times 4 dw -88, -61
+times 4 dw 31, 90
+times 4 dw 54, -38
+times 4 dw -90, -46
+
+times 4 dw 73, -31
+times 4 dw -90, -22
+times 4 dw 78, 67
+times 4 dw -38, -90
+times 4 dw -13, 82
+times 4 dw 61, -46
+times 4 dw -88, -4
+times 4 dw 85, 54
+
+times 4 dw 67, -54
+times 4 dw -78, 38
+times 4 dw 85, -22
+times 4 dw -90, 4
+times 4 dw 90, 13
+times 4 dw -88, -31
+times 4 dw 82, 46
+times 4 dw -73, -61
+
+times 4 dw 61, -73
+times 4 dw -46, 82
+times 4 dw 31, -88
+times 4 dw -13, 90
+times 4 dw -4, -90
+times 4 dw 22, 85
+times 4 dw -38, -78
+times 4 dw 54, 67
+
+times 4 dw 54, -85
+times 4 dw -4, 88
+times 4 dw -46, -61
+times 4 dw 82, 13
+times 4 dw -90, 38
+times 4 dw 67, -78
+times 4 dw -22, 90
+times 4 dw -31, -73
+
+times 4 dw 46, -90
+times 4 dw 38, 54
+times 4 dw -90, 31
+times 4 dw 61, -88
+times 4 dw 22, 67
+times 4 dw -85, 13
+times 4 dw 73, -82
+times 4 dw 4, 78
+
+times 4 dw 38, -88
+times 4 dw 73, -4
+times 4 dw -67, 90
+times 4 dw -46, -31
+times 4 dw 85, -78
+times 4 dw 13, 61
+times 4 dw -90, 54
+times 4 dw 22, -82
+
+times 4 dw 31, -78
+times 4 dw 90, -61
+times 4 dw 4, 54
+times 4 dw -88, 82
+times 4 dw -38, -22
+times 4 dw 73, -90
+times 4 dw 67, -13
+times 4 dw -46, 85
+
+times 4 dw 22, -61
+times 4 dw 85, -90
+times 4 dw 73, -38
+times 4 dw -4, 46
+times 4 dw -78, 90
+times 4 dw -82, 54
+times 4 dw -13, -31
+times 4 dw 67, -88
+
+times 4 dw 13, -38
+times 4 dw 61, -78
+times 4 dw 88, -90
+times 4 dw 85, -73
+times 4 dw 54, -31
+times 4 dw 4, 22
+times 4 dw -46, 67
+times 4 dw -82, 90
+
+times 4 dw 4, -13
+times 4 dw 22, -31
+times 4 dw 38, -46
+times 4 dw 54, -61
+times 4 dw 67, -73
+times 4 dw 78, -82
+times 4 dw 85, -88
+times 4 dw 90, -90
+
 SECTION .text
 
-; void ff_hevc_idctHxW_dc_{8,10}_<opt>(int16_t *coeffs)
+; void ff_hevc_idct_HxW_dc_{8,10}_<opt>(int16_t *coeffs)
 ; %1 = HxW
 ; %2 = number of loops
 ; %3 = bitdepth
 %macro IDCT_DC 3
-cglobal hevc_idct%1x%1_dc_%3, 1, 2, 1, coeff, tmp
-    movsx             tmpq, word [coeffq]
-    add               tmpw, ((1 << 14-%3) + 1)
-    sar               tmpw, (15-%3)
+cglobal hevc_idct_%1x%1_dc_%3, 1, 2, 1, coeff, tmp
+    movsx             tmpd, word [coeffq]
+    add               tmpd, (1 << (14 - %3)) + 1
+    sar               tmpd, (15 - %3)
     movd               xm0, tmpd
     SPLATW              m0, xm0
     DEFINE_ARGS coeff, cnt
@@ -41,11 +254,11 @@ cglobal hevc_idct%1x%1_dc_%3, 1, 2, 1, coeff, tmp
     mova [coeffq+mmsize*1], m0
     mova [coeffq+mmsize*2], m0
     mova [coeffq+mmsize*3], m0
-    mova [coeffq+mmsize*4], m0
-    mova [coeffq+mmsize*5], m0
-    mova [coeffq+mmsize*6], m0
-    mova [coeffq+mmsize*7], m0
     add  coeffq, mmsize*8
+    mova [coeffq+mmsize*-4], m0
+    mova [coeffq+mmsize*-3], m0
+    mova [coeffq+mmsize*-2], m0
+    mova [coeffq+mmsize*-1], m0
     dec  cntd
     jg  .loop
     RET
@@ -54,10 +267,10 @@ cglobal hevc_idct%1x%1_dc_%3, 1, 2, 1, coeff, tmp
 ; %1 = HxW
 ; %2 = bitdepth
 %macro IDCT_DC_NL 2 ; No loop
-cglobal hevc_idct%1x%1_dc_%2, 1, 2, 1, coeff, tmp
-    movsx             tmpq, word [coeffq]
-    add               tmpw, ((1 << 14-%2) + 1)
-    sar               tmpw, (15-%2)
+cglobal hevc_idct_%1x%1_dc_%2, 1, 2, 1, coeff, tmp
+    movsx             tmpd, word [coeffq]
+    add               tmpd, (1 << (14 - %2)) + 1
+    sar               tmpd, (15 - %2)
     movd                m0, tmpd
     SPLATW              m0, xm0
     mova [coeffq+mmsize*0], m0
@@ -73,50 +286,568 @@ cglobal hevc_idct%1x%1_dc_%2, 1, 2, 1, coeff, tmp
     RET
 %endmacro
 
-; 8-bit
-INIT_MMX mmxext
-IDCT_DC_NL  4,      8
-IDCT_DC     8,  2,  8
+; IDCT 4x4, expects input in m0, m1
+; %1 - shift
+; %2 - 1/0 - SCALE and Transpose or not
+; %3 - 1/0 add constant or not
+%macro TR_4x4 3
+    ; interleaves src0 with src2 to m0
+    ;         and src1 with scr3 to m2
+    ; src0: 00 01 02 03     m0: 00 20 01 21 02 22 03 23
+    ; src1: 10 11 12 13 -->
+    ; src2: 20 21 22 23     m1: 10 30 11 31 12 32 13 33
+    ; src3: 30 31 32 33
 
-INIT_XMM sse2
-IDCT_DC_NL  8,      8
-IDCT_DC    16,  4,  8
-IDCT_DC    32, 16,  8
+    SBUTTERFLY wd, 0, 1, 2
 
-%if HAVE_AVX2_EXTERNAL
-INIT_YMM avx2
-IDCT_DC    16,  2,  8
-IDCT_DC    32,  8,  8
-%endif ;HAVE_AVX2_EXTERNAL
+    pmaddwd m2, m0, [pw_64]    ; e0
+    pmaddwd m3, m1, [pw_83_36] ; o0
+    pmaddwd m0, [pw_64_m64]    ; e1
+    pmaddwd m1, [pw_36_m83]    ; o1
 
-; 10-bit
-INIT_MMX mmxext
-IDCT_DC_NL  4,     10
-IDCT_DC     8,  2, 10
+%if %3 == 1
+    %assign %%add 1 << (%1 - 1)
+    mova  m4, [pd_ %+ %%add]
+    paddd m2, m4
+    paddd m0, m4
+%endif
 
-INIT_XMM sse2
-IDCT_DC_NL  8,     10
-IDCT_DC    16,  4, 10
-IDCT_DC    32, 16, 10
+    SUMSUB_BADC d, 3, 2, 1, 0, 4
 
-%if HAVE_AVX2_EXTERNAL
-INIT_YMM avx2
-IDCT_DC    16,  2, 10
-IDCT_DC    32,  8, 10
-%endif ;HAVE_AVX2_EXTERNAL
+%if %2 == 1
+    psrad m3, %1 ; e0 + o0
+    psrad m1, %1 ; e1 + o1
+    psrad m2, %1 ; e0 - o0
+    psrad m0, %1 ; e1 - o1
+    ;clip16
+    packssdw m3, m1
+    packssdw m0, m2
+    ; Transpose
+    SBUTTERFLY wd, 3, 0, 1
+    SBUTTERFLY wd, 3, 0, 1
+    SWAP 3, 1, 0
+%else
+    SWAP 3, 2, 0
+%endif
+%endmacro
+
+%macro DEFINE_BIAS 1
+    %assign shift (20 - %1)
+    %assign c_add (1 << (shift - 1))
+    %define arr_add pd_ %+ c_add
+%endmacro
+
+; %1 - bit_depth
+; %2 - register add constant
+; is loaded to
+; shift = 20 - bit_depth
+%macro LOAD_BIAS 2
+    DEFINE_BIAS %1
+    mova %2, [arr_add]
+%endmacro
+
+; %1, %2 - registers to load packed 16 bit values to
+; %3, %4, %5, %6 - vertical offsets
+; %7 - horizontal offset
+%macro LOAD_BLOCK 7
+    movq   %1, [r0 + %3 + %7]
+    movhps %1, [r0 + %5 + %7]
+    movq   %2, [r0 + %4 + %7]
+    movhps %2, [r0 + %6 + %7]
+%endmacro
+
+; void ff_hevc_idct_4x4__{8,10}_<opt>(int16_t *coeffs, int col_limit)
+; %1 = bitdepth
+%macro IDCT_4x4 1
+cglobal hevc_idct_4x4_%1, 1, 1, 5, coeffs
+    mova m0, [coeffsq]
+    mova m1, [coeffsq + 16]
+
+    TR_4x4 7, 1, 1
+    TR_4x4 20 - %1, 1, 1
+
+    mova [coeffsq],      m0
+    mova [coeffsq + 16], m1
+    RET
+%endmacro
+
+; scale, pack (clip16) and store the residuals     0 e8[0] + o8[0] --> + %1
+; 4 at one time (4 columns)                        1 e8[1] + o8[1]
+; from %5: e8/16 + o8/16, with %1 offset                  ...
+; and  %3: e8/16 - o8/16, with %2 offset           6 e8[1] - o8[1]
+; %4 - shift                                       7 e8[0] - o8[0] --> + %2
+%macro STORE_8 7
+    psrad    %5, %4
+    psrad    %3, %4
+    packssdw %5, %3
+    movq     [coeffsq + %1], %5
+    movhps   [coeffsq + %2], %5
+%endmacro
 
-; 12-bit
+; %1 - horizontal offset
+; %2 - shift
+; %3, %4 - transform coeffs
+; %5 - vertical offset for e8 + o8
+; %6 - vertical offset for e8 - o8
+; %7 - register with e8 inside
+; %8 - block_size
+; %9 - register to store e8 +o8
+; %10 - register to store e8 - o8
+%macro E8_O8 10
+    pmaddwd m6, m4, %3
+    pmaddwd m7, m5, %4
+
+    paddd m6, m7
+    paddd m7, m6, %7 ; o8 + e8
+    psubd %7, m6     ; e8 - o8
+%if %8 == 8
+    STORE_8 %5 + %1, %6 + %1, %7, %2, m7, 0, 0
+%else
+    SWAP m7, %9
+    SWAP %7, %10
+%endif
+%endmacro
+
+; 8x4 residuals are processed and stored
+; %1 - horizontal offset
+; %2 - shift
+; %3 - offset of the even row
+; %4 - step: 1 for 8x8, 2 for 16x16, 4 for 32x32
+; %5 - offset of the odd row
+; %6 - block size
+; %7 - 1/0 add a constant in TR_4x4 or not
+; I want to add a constant for 8x8 transform but not for 16x16 and 32x32
+%macro TR_8x4 7
+    ; load 4 columns of even rows
+    LOAD_BLOCK  m0, m1, 0, 2 * %4 * %3, %4 * %3, 3 * %4 * %3, %1
+
+    TR_4x4 %2, 0, %7 ; e8: m0, m1, m2, m3, for 4 columns only
+
+    ; load 4 columns of odd rows
+    LOAD_BLOCK m4, m5, %4 * %5, 3 * %4 * %5, 5 * %4 * %5, 7 * %4 * %5, %1
+
+    ; 00 01 02 03
+    ; 10 11 12 13      m4: 10 30 11 31 12 32 13 33
+
+    ; ...        -- >
+    ;                  m5: 50 70 51 71 52 72 53 73
+    ; 70 71 72 73
+    SBUTTERFLY wd, 4, 5, 6
+
+    E8_O8 %1, %2, [pw_89_75],  [pw_50_18],   0,      %5 * 7, m0, %6, m8, m15
+    E8_O8 %1, %2, [pw_75_m18], [pw_m89_m50], %5,     %5 * 6, m1, %6, m9, m14
+    E8_O8 %1, %2, [pw_50_m89], [pw_18_75],   %5 * 2, %5 * 5, m2, %6, m10, m13
+    E8_O8 %1, %2, [pw_18_m50], [pw_75_m89],  %5 * 3, %5 * 4, m3, %6, m11, m12
+%endmacro
+
+%macro STORE_PACKED 7
+    movq   [r0 + %3 + %7], %1
+    movhps [r0 + %4 + %7], %1
+    movq   [r0 + %5 + %7], %2
+    movhps [r0 + %6 + %7], %2
+%endmacro
+
+; transpose 4x4 block packed
+; in %1 and %2 registers
+; %3 - temporary register
+%macro TRANSPOSE_4x4 3
+    SBUTTERFLY wd, %1, %2, %3
+    SBUTTERFLY dq, %1, %2, %3
+%endmacro
+
+; %1 - horizontal offset of the block i
+; %2 - vertical offset of the block i
+; %3 - width in bytes
+; %4 - vertical offset for the block j
+; %5 - horizontal offset for the block j
+%macro SWAP_BLOCKS 5
+    ; M_j
+    LOAD_BLOCK m4, m5, %4, %4 + %3, %4 + 2 * %3, %4 + 3 * %3, %5
+    TRANSPOSE_4x4 4, 5, 6
+
+    ; M_i
+    LOAD_BLOCK m6, m7, %2, %2 + %3, %2 + 2 * %3, %2 + 3 * %3, %1
+
+    STORE_PACKED m4, m5, %2, %2 + %3, %2 + 2 * %3, %2 + 3 * %3, %1
+
+    ; transpose and store M_i
+    SWAP m6, m4
+    SWAP m7, m5
+    TRANSPOSE_4x4 4, 5, 6
+    STORE_PACKED m4, m5, %4, %4 + %3, %4 + 2 * %3, %4 + 3 * %3, %5
+%endmacro
+
+; %1 - horizontal offset
+; %2 - vertical offset of the block
+; %3 - width in bytes
+%macro TRANSPOSE_BLOCK 3
+    LOAD_BLOCK m4, m5, %2, %2 + %3, %2 + 2 * %3, %2 + 3 * %3, %1
+    TRANSPOSE_4x4 4, 5, 6
+    STORE_PACKED m4, m5, %2, %2 + %3, %2 + 2 * %3, %2 + 3 * %3, %1
+%endmacro
+
+%macro TRANSPOSE_8x8 0
+cglobal hevc_idct_transpose_8x8, 0, 0, 0
+    ; M1 M2 ^T = M1^t M3^t
+    ; M3 M4      M2^t M4^t
+
+    ; M1 4x4 block
+    TRANSPOSE_BLOCK 0, 0, 16
+
+    ; M2 and M3
+    SWAP_BLOCKS 0, 64, 16, 0, 8
+
+    ; M4
+    TRANSPOSE_BLOCK 8, 64, 16
+
+    ret
+%endmacro
+
+; void ff_hevc_idct_8x8_{8,10}_<opt>(int16_t *coeffs, int col_limit)
+; %1 = bitdepth
+%macro IDCT_8x8 1
+cglobal hevc_idct_8x8_%1, 1, 1, 8, coeffs
+    TR_8x4 0, 7, 32, 1, 16, 8, 1
+    TR_8x4 8, 7, 32, 1, 16, 8, 1
+
+    call hevc_idct_transpose_8x8_ %+ cpuname
+
+    DEFINE_BIAS %1
+    TR_8x4 0, shift, 32, 1, 16, 8, 1
+    TR_8x4 8, shift, 32, 1, 16, 8, 1
+
+    TAIL_CALL hevc_idct_transpose_8x8_ %+ cpuname, 1
+%endmacro
+
+; store intermedite e32 coeffs on stack
+; as 16x4 matrix
+; from m10: e8 + o8, with %6 offset
+; and  %3:  e8 - o8, with %7 offset
+; %4 - shift, unused here
+%macro STORE_16 7
+    mova [rsp + %6], %5
+    mova [rsp + %7], %3
+%endmacro
+
+; %1, %2 - transform constants
+; %3, %4 - regs with interleaved coeffs
+; %5 - 1/0 SWAP or add
+; %6, %7 - registers for intermidiate sums
+; %8 - accumulator register
+%macro ADD_ROWS 8
+    pmaddwd %6, %3, %1
+    pmaddwd %7, %4, %2
+    paddd   %6, %7
+%if %5 == 1
+    SWAP %6, %8
+%else
+    paddd %8, %6
+%endif
+%endmacro
+
+; %1 - transform coeffs
+; %2, %3 offsets for storing e+o/e-o back to coeffsq
+; %4 - shift
+; %5 - add
+; %6 - block_size
+; %7 - register with e16
+; %8, %9 - stack offsets for storing e+o/e-o
+%macro E16_O16 9
+    ADD_ROWS [%1],          [%1 +     16], m0, m1, 1, m5, m6, m7
+    ADD_ROWS [%1 + 2 * 16], [%1 + 3 * 16], m2, m3, 0, m5, m6, m7
+
+%if %6 == 8
+    paddd %7, %5
+%endif
+
+    paddd m4, m7, %7 ; o16 + e16
+    psubd %7, m7     ; e16 - o16
+    STORE_%6 %2, %3, %7, %4, m4, %8, %9
+%endmacro
+
+%macro TR_16x4 10
+    ; produce 8x4 matrix of e16 coeffs
+    ; for 4 first rows and store it on stack (128 bytes)
+    TR_8x4 %1, 7, %4, %5, %6, %8, 0
+
+    ; load 8 even rows
+    LOAD_BLOCK m0, m1, %9 * %6, %9 * 3 * %6, %9 * 5 * %6, %9 * 7 * %6, %1
+    LOAD_BLOCK m2, m3, %9 * 9 * %6, %9 * 11 * %6, %9 * 13 * %6, %9 * 15 * %6, %1
+
+    SBUTTERFLY wd, 0, 1, 4
+    SBUTTERFLY wd, 2, 3, 4
+
+    E16_O16 trans_coeffs16,               0 + %1, 15 * %6 + %1, %2, %3, %7, m8,       0, 15 * 16
+    mova m8, %3
+    E16_O16 trans_coeffs16 +     64,     %6 + %1, 14 * %6 + %1, %2, m8, %7, m9,      16, 14 * 16
+    E16_O16 trans_coeffs16 + 2 * 64, 2 * %6 + %1, 13 * %6 + %1, %2, m8, %7, m10, 2 * 16, 13 * 16
+    E16_O16 trans_coeffs16 + 3 * 64, 3 * %6 + %1, 12 * %6 + %1, %2, m8, %7, m11, 3 * 16, 12 * 16
+    E16_O16 trans_coeffs16 + 4 * 64, 4 * %6 + %1, 11 * %6 + %1, %2, m8, %7, m12, 4 * 16, 11 * 16
+    E16_O16 trans_coeffs16 + 5 * 64, 5 * %6 + %1, 10 * %6 + %1, %2, m8, %7, m13, 5 * 16, 10 * 16
+    E16_O16 trans_coeffs16 + 6 * 64, 6 * %6 + %1,  9 * %6 + %1, %2, m8, %7, m14, 6 * 16,  9 * 16
+    E16_O16 trans_coeffs16 + 7 * 64, 7 * %6 + %1,  8 * %6 + %1, %2, m8, %7, m15, 7 * 16,  8 * 16
+%endmacro
+
+%macro TRANSPOSE_16x16 0
+cglobal hevc_idct_transpose_16x16, 0, 0, 0
+; M1  M2  M3  M4 ^T      m1 m5 m9  m13   M_i^T = m_i
+; M5  M6  M7  M8    -->  m2 m6 m10 m14
+; M9  M10 M11 M12        m3 m7 m11 m15
+; M13 M14 M15 M16        m4 m8 m12 m16
+
+    ; M1 4x4 block
+    TRANSPOSE_BLOCK 0, 0, 32
+
+    ; M5, M2
+    SWAP_BLOCKS 0, 128, 32, 0, 8
+    ; M9, M3
+    SWAP_BLOCKS 0, 256, 32, 0, 16
+    ; M13, M4
+    SWAP_BLOCKS 0, 384, 32, 0, 24
+
+    ;M6
+    TRANSPOSE_BLOCK 8, 128, 32
+
+    ; M10, M7
+    SWAP_BLOCKS 8, 256, 32, 128, 16
+    ; M14, M8
+    SWAP_BLOCKS 8, 384, 32, 128, 24
+
+    ;M11
+    TRANSPOSE_BLOCK 16, 256, 32
+
+    ; M15, M12
+    SWAP_BLOCKS 16, 384, 32, 256, 24
+
+    ;M16
+    TRANSPOSE_BLOCK 24, 384, 32
+
+    ret
+%endmacro
+
+; void ff_hevc_idct_16x16_{8,10}_<opt>(int16_t *coeffs, int col_limit)
+; %1 = bitdepth
+%macro IDCT_16x16 1
+cglobal hevc_idct_16x16_%1, 1, 2, 16, coeffs
+    mov r1d, 3
+.loop16:
+    TR_16x4 8 * r1, 7, [pd_64], 64, 2, 32, 8, 16, 1, 0
+    dec r1d
+    jge .loop16
+
+    call hevc_idct_transpose_16x16_ %+ cpuname
+
+    DEFINE_BIAS %1
+    mov r1d, 3
+.loop16_2:
+    TR_16x4 8 * r1, shift, [arr_add], 64, 2, 32, 8, 16, 1, 1
+    dec r1d
+    jge .loop16_2
+
+    TAIL_CALL hevc_idct_transpose_16x16_ %+ cpuname, 1
+%endmacro
+
+; scale, pack (clip16) and store the residuals     0 e32[0] + o32[0] --> %1
+; 4 at one time (4 columns)                        1 e32[1] + o32[1]
+; %1 - address to store e32 + o32
+; %2 - address to store e32 - e32
+; %5 - reg with e32 + o32                                  ...
+; %3 - reg with e32 - o32                          30 e32[1] - o32[1]
+; %4 - shift                                       31 e32[0] - o32[0] --> %2
+%macro STORE_32 5
+    psrad    %5, %4
+    psrad    %3, %4
+    packssdw %5, %3
+    movq     [%1], %5
+    movhps   [%2], %5
+%endmacro
+
+; %1 - transform coeffs
+; %2 - stack offset for e32
+; %2, %3 offsets for storing e+o/e-o back to coeffsq
+; %4 - shift
+; %5 - stack offset of e32
+%macro E32_O32 5
+    ADD_ROWS [%1],          [%1 +     16], m0, m1, 1, m8, m9, m10
+    ADD_ROWS [%1 + 2 * 16], [%1 + 3 * 16], m2, m3, 0, m8, m9, m10
+    ADD_ROWS [%1 + 4 * 16], [%1 + 5 * 16], m4, m5, 0, m8, m9, m10
+    ADD_ROWS [%1 + 6 * 16], [%1 + 7 * 16], m6, m7, 0, m8, m9, m10
+
+    paddd m11, m14, [rsp + %5]
+    paddd m12, m10, m11 ; o32 + e32
+    psubd m11, m10      ; e32 - o32
+    STORE_32 %2, %3, m11, %4, m12
+%endmacro
+
+; %1 - horizontal offset
+; %2 - bitdepth
+%macro TR_32x4 3
+    TR_16x4 %1, 7, [pd_64], 128, 4, 64, 16, 16, 2, 0
+
+    LOAD_BLOCK m0, m1,      64,  3 * 64,  5 * 64,  7 * 64, %1
+    LOAD_BLOCK m2, m3,  9 * 64, 11 * 64, 13 * 64, 15 * 64, %1
+    LOAD_BLOCK m4, m5, 17 * 64, 19 * 64, 21 * 64, 23 * 64, %1
+    LOAD_BLOCK m6, m7, 25 * 64, 27 * 64, 29 * 64, 31 * 64, %1
+
+    SBUTTERFLY wd, 0, 1, 8
+    SBUTTERFLY wd, 2, 3, 8
+    SBUTTERFLY wd, 4, 5, 8
+    SBUTTERFLY wd, 6, 7, 8
+
+%if %3 == 1
+    %assign shift 7
+    mova m14, [pd_64]
+%else
+    LOAD_BIAS %2, m14
+%endif
+
+    lea r2, [trans_coeff32 + 15 * 128]
+    lea r3, [coeffsq + %1]
+    lea r4, [r3 + 16 * 64]
+    mov r5d, 15 * 16
+%%loop:
+    E32_O32 r2, r3 + r5 * 4, r4, shift, r5
+    sub r2, 128
+    add r4, 64
+    sub r5d, 16
+    jge %%loop
+%endmacro
+
+%macro TRANSPOSE_32x32 0
+cglobal hevc_idct_transpose_32x32, 0, 0, 0
+    ; M0  M1 ... M7
+    ; M8         M15
+    ;
+    ; ...
+    ;
+    ; M56        M63
+
+    TRANSPOSE_BLOCK 0, 0, 64 ; M1
+    mov r1d, 7
+    mov r2d, 7 * 256
+.loop_transpose:
+    SWAP_BLOCKS 0, r2, 64, 0, r1 * 8
+    sub r2d, 256
+    dec r1d
+    jg .loop_transpose
+
+    TRANSPOSE_BLOCK 8, 256, 64 ; M9
+    mov r1d, 6
+    mov r2d, 512
+    mov r3d, 16
+.loop_transpose2:
+    SWAP_BLOCKS 8, r2, 64, 256, r3
+    add r3d, 8
+    add r2d, 256
+    dec r1d
+    jg .loop_transpose2
+
+    TRANSPOSE_BLOCK 2 * 8, 2 * 256, 64 ; M9
+    mov r1d, 5
+    mov r2d, 768
+    mov r3d, 24
+.loop_transpose3:
+    SWAP_BLOCKS 2 * 8, r2, 64, 2 * 256, r3
+    add r3d, 8
+    add r2d, 256
+    dec r1d
+    jg .loop_transpose3
+
+    TRANSPOSE_BLOCK 3 * 8, 3 * 256, 64 ; M27
+    mov r1d, 4
+    mov r2d, 1024
+    mov r3d, 32
+.loop_transpose4:
+    SWAP_BLOCKS 3 * 8, r2, 64, 3 * 256, r3
+    add r3d, 8
+    add r2d, 256
+    dec r1d
+    jg .loop_transpose4
+
+    TRANSPOSE_BLOCK 4 * 8, 4 * 256, 64 ; M36
+    mov r1d, 3
+    mov r2d, 1280
+    mov r3d, 40
+.loop_transpose5:
+    SWAP_BLOCKS 4 * 8, r2, 64, 4 * 256, r3
+    add r3d, 8
+    add r2d, 256
+    dec r1d
+    jg .loop_transpose5
+
+    TRANSPOSE_BLOCK 5 * 8, 5 * 256, 64 ; M45
+    SWAP_BLOCKS 5 * 8, 6 * 256, 64, 5 * 256, 6 * 8
+    SWAP_BLOCKS 5 * 8, 7 * 256, 64, 5 * 256, 7 * 8
+
+    TRANSPOSE_BLOCK 6 * 8, 6 * 256, 64 ; M54
+    SWAP_BLOCKS 6 * 8, 7 * 256, 64, 6 * 256, 7 * 8
+
+    TRANSPOSE_BLOCK 7 * 8, 7 * 256, 64 ; M63
+
+    ret
+%endmacro
+
+; void ff_hevc_idct_32x32_{8,10}_<opt>(int16_t *coeffs, int col_limit)
+; %1 = bitdepth
+%macro IDCT_32x32 1
+cglobal hevc_idct_32x32_%1, 1, 6, 16, 256, coeffs
+    mov r1d, 7
+.loop32:
+    TR_32x4 8 * r1, %1, 1
+    dec r1d
+    jge .loop32
+
+    call hevc_idct_transpose_32x32_ %+ cpuname
+
+    mov r1d, 7
+.loop32_2:
+    TR_32x4 8 * r1, %1, 0
+    dec r1d
+    jge .loop32_2
+
+    TAIL_CALL hevc_idct_transpose_32x32_ %+ cpuname, 1
+%endmacro
+
+%macro INIT_IDCT_DC 1
 INIT_MMX mmxext
-IDCT_DC_NL  4,     12
-IDCT_DC     8,  2, 12
+IDCT_DC_NL  4,      %1
+IDCT_DC     8,  2,  %1
 
 INIT_XMM sse2
-IDCT_DC_NL  8,     12
-IDCT_DC    16,  4, 12
-IDCT_DC    32, 16, 12
+IDCT_DC_NL  8,      %1
+IDCT_DC    16,  4,  %1
+IDCT_DC    32, 16,  %1
 
 %if HAVE_AVX2_EXTERNAL
-INIT_YMM avx2
-IDCT_DC    16,  2, 12
-IDCT_DC    32,  8, 12
+    INIT_YMM avx2
+    IDCT_DC    16,  2,  %1
+    IDCT_DC    32,  8,  %1
 %endif ;HAVE_AVX2_EXTERNAL
+%endmacro
+
+%macro INIT_IDCT 2
+INIT_XMM %2
+%if %1 == 8
+    TRANSPOSE_8x8
+    %if ARCH_X86_64
+        TRANSPOSE_16x16
+        TRANSPOSE_32x32
+    %endif
+%endif
+%if ARCH_X86_64
+    IDCT_32x32 %1
+    IDCT_16x16 %1
+%endif
+IDCT_8x8 %1
+IDCT_4x4 %1
+%endmacro
+
+INIT_IDCT_DC 8
+INIT_IDCT_DC 10
+INIT_IDCT_DC 12
+INIT_IDCT 8, sse2
+INIT_IDCT 8, avx
+INIT_IDCT 10, sse2
+INIT_IDCT 10, avx
+;INIT_IDCT 12, sse2
+;INIT_IDCT 12, avx
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/hevc_res_add.asm b/mythtv/external/FFmpeg/libavcodec/x86/hevc_res_add.asm
deleted file mode 100644
index dc3e88a373d..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/x86/hevc_res_add.asm
+++ /dev/null
@@ -1,388 +0,0 @@
-; /*
-; * Provide SIMD optimizations for transform_add functions for HEVC decoding
-; * Copyright (c) 2014 Pierre-Edouard LEPERE
-; *
-; * 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/x86/x86util.asm"
-
-SECTION .text
-
-cextern pw_1023
-%define max_pixels_10 pw_1023
-
-
-;the tr_add macros and functions were largely inspired by x264 project's code in the h264_idct.asm file
-%macro TR_ADD_MMX_4_8 0
-    mova              m2, [r1]
-    mova              m4, [r1+8]
-    pxor              m3, m3
-    psubw             m3, m2
-    packuswb          m2, m2
-    packuswb          m3, m3
-    pxor              m5, m5
-    psubw             m5, m4
-    packuswb          m4, m4
-    packuswb          m5, m5
-
-    movh              m0, [r0     ]
-    movh              m1, [r0+r2  ]
-    paddusb           m0, m2
-    paddusb           m1, m4
-    psubusb           m0, m3
-    psubusb           m1, m5
-    movh       [r0     ], m0
-    movh       [r0+r2  ], m1
-%endmacro
-
-
-INIT_MMX mmxext
-; void ff_hevc_tranform_add_8_mmxext(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
-cglobal hevc_transform_add4_8, 3, 4, 6
-    TR_ADD_MMX_4_8
-    add               r1, 16
-    lea               r0, [r0+r2*2]
-    TR_ADD_MMX_4_8
-    RET
-
-%macro TR_ADD_SSE_8_8 0
-    pxor              m3, m3
-    mova              m4, [r1]
-    mova              m6, [r1+16]
-    mova              m0, [r1+32]
-    mova              m2, [r1+48]
-    psubw             m5, m3, m4
-    psubw             m7, m3, m6
-    psubw             m1, m3, m0
-    packuswb          m4, m0
-    packuswb          m5, m1
-    psubw             m3, m2
-    packuswb          m6, m2
-    packuswb          m7, m3
-
-    movq                m0, [r0     ]
-    movq                m1, [r0+r2  ]
-    movhps              m0, [r0+r2*2]
-    movhps              m1, [r0+r3  ]
-    paddusb             m0, m4
-    paddusb             m1, m6
-    psubusb             m0, m5
-    psubusb             m1, m7
-    movq         [r0     ], m0
-    movq         [r0+r2  ], m1
-    movhps       [r0+2*r2], m0
-    movhps       [r0+r3  ], m1
-%endmacro
-
-%macro TR_ADD_SSE_16_32_8 3
-    mova             xm2, [r1+%1   ]
-    mova             xm6, [r1+%1+16]
-%if cpuflag(avx2)
-    vinserti128       m2, m2, [r1+%1+32], 1
-    vinserti128       m6, m6, [r1+%1+48], 1
-%endif
-%if cpuflag(avx)
-    psubw             m1, m0, m2
-    psubw             m5, m0, m6
-%else
-    mova              m1, m0
-    mova              m5, m0
-    psubw             m1, m2
-    psubw             m5, m6
-%endif
-    packuswb          m2, m6
-    packuswb          m1, m5
-
-    mova             xm4, [r1+%1+mmsize*2   ]
-    mova             xm6, [r1+%1+mmsize*2+16]
-%if cpuflag(avx2)
-    vinserti128       m4, m4, [r1+%1+96 ], 1
-    vinserti128       m6, m6, [r1+%1+112], 1
-%endif
-%if cpuflag(avx)
-    psubw             m3, m0, m4
-    psubw             m5, m0, m6
-%else
-    mova              m3, m0
-    mova              m5, m0
-    psubw             m3, m4
-    psubw             m5, m6
-%endif
-    packuswb          m4, m6
-    packuswb          m3, m5
-
-    paddusb           m2, [%2]
-    paddusb           m4, [%3]
-    psubusb           m2, m1
-    psubusb           m4, m3
-    mova            [%2], m2
-    mova            [%3], m4
-%endmacro
-
-
-%macro TRANSFORM_ADD_8 0
-; void ff_hevc_transform_add8_8_<opt>(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
-cglobal hevc_transform_add8_8, 3, 4, 8
-    lea               r3, [r2*3]
-    TR_ADD_SSE_8_8
-    add               r1, 64
-    lea               r0, [r0+r2*4]
-    TR_ADD_SSE_8_8
-    RET
-
-; void ff_hevc_transform_add16_8_<opt>(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
-cglobal hevc_transform_add16_8, 3, 4, 7
-    pxor              m0, m0
-    lea               r3, [r2*3]
-    TR_ADD_SSE_16_32_8  0, r0,      r0+r2
-    TR_ADD_SSE_16_32_8 64, r0+r2*2, r0+r3
-%rep 3
-    add                r1, 128
-    lea                r0, [r0+r2*4]
-    TR_ADD_SSE_16_32_8  0, r0,      r0+r2
-    TR_ADD_SSE_16_32_8 64, r0+r2*2, r0+r3
-%endrep
-    RET
-
-; void ff_hevc_transform_add32_8_<opt>(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
-cglobal hevc_transform_add32_8, 3, 4, 7
-    pxor               m0, m0
-    TR_ADD_SSE_16_32_8  0, r0,    r0+16
-    TR_ADD_SSE_16_32_8 64, r0+r2, r0+r2+16
-%rep 15
-    add                r1, 128
-    lea                r0, [r0+r2*2]
-    TR_ADD_SSE_16_32_8  0, r0,    r0+16
-    TR_ADD_SSE_16_32_8 64, r0+r2, r0+r2+16
-%endrep
-    RET
-%endmacro
-
-INIT_XMM sse2
-TRANSFORM_ADD_8
-INIT_XMM avx
-TRANSFORM_ADD_8
-
-%if HAVE_AVX2_EXTERNAL
-INIT_YMM avx2
-; void ff_hevc_transform_add32_8_avx2(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
-cglobal hevc_transform_add32_8, 3, 4, 7
-    pxor              m0, m0
-    lea               r3, [r2*3]
-    TR_ADD_SSE_16_32_8   0, r0,      r0+r2
-    TR_ADD_SSE_16_32_8 128, r0+r2*2, r0+r3
-%rep 7
-    add                r1, 256
-    lea                r0, [r0+r2*4]
-    TR_ADD_SSE_16_32_8   0, r0,      r0+r2
-    TR_ADD_SSE_16_32_8 128, r0+r2*2, r0+r3
-%endrep
-    RET
-%endif
-
-;-----------------------------------------------------------------------------
-; void ff_hevc_transform_add_10(pixel *dst, int16_t *block, int stride)
-;-----------------------------------------------------------------------------
-%macro TR_ADD_SSE_8_10 4
-    mova              m0, [%4]
-    mova              m1, [%4+16]
-    mova              m2, [%4+32]
-    mova              m3, [%4+48]
-    paddw             m0, [%1+0   ]
-    paddw             m1, [%1+%2  ]
-    paddw             m2, [%1+%2*2]
-    paddw             m3, [%1+%3  ]
-    CLIPW             m0, m4, m5
-    CLIPW             m1, m4, m5
-    CLIPW             m2, m4, m5
-    CLIPW             m3, m4, m5
-    mova       [%1+0   ], m0
-    mova       [%1+%2  ], m1
-    mova       [%1+%2*2], m2
-    mova       [%1+%3  ], m3
-%endmacro
-
-%macro TR_ADD_MMX4_10 3
-    mova              m0, [%1+0   ]
-    mova              m1, [%1+%2  ]
-    paddw             m0, [%3]
-    paddw             m1, [%3+8]
-    CLIPW             m0, m2, m3
-    CLIPW             m1, m2, m3
-    mova       [%1+0   ], m0
-    mova       [%1+%2  ], m1
-%endmacro
-
-%macro TRANS_ADD_SSE_16_10 3
-    mova              m0, [%3]
-    mova              m1, [%3+16]
-    mova              m2, [%3+32]
-    mova              m3, [%3+48]
-    paddw             m0, [%1      ]
-    paddw             m1, [%1+16   ]
-    paddw             m2, [%1+%2   ]
-    paddw             m3, [%1+%2+16]
-    CLIPW             m0, m4, m5
-    CLIPW             m1, m4, m5
-    CLIPW             m2, m4, m5
-    CLIPW             m3, m4, m5
-    mova      [%1      ], m0
-    mova      [%1+16   ], m1
-    mova      [%1+%2   ], m2
-    mova      [%1+%2+16], m3
-%endmacro
-
-%macro TRANS_ADD_SSE_32_10 2
-    mova              m0, [%2]
-    mova              m1, [%2+16]
-    mova              m2, [%2+32]
-    mova              m3, [%2+48]
-
-    paddw             m0, [%1   ]
-    paddw             m1, [%1+16]
-    paddw             m2, [%1+32]
-    paddw             m3, [%1+48]
-    CLIPW             m0, m4, m5
-    CLIPW             m1, m4, m5
-    CLIPW             m2, m4, m5
-    CLIPW             m3, m4, m5
-    mova         [%1   ], m0
-    mova         [%1+16], m1
-    mova         [%1+32], m2
-    mova         [%1+48], m3
-%endmacro
-
-%macro TRANS_ADD16_AVX2 4
-    mova              m0, [%4]
-    mova              m1, [%4+32]
-    mova              m2, [%4+64]
-    mova              m3, [%4+96]
-
-    paddw             m0, [%1+0   ]
-    paddw             m1, [%1+%2  ]
-    paddw             m2, [%1+%2*2]
-    paddw             m3, [%1+%3  ]
-
-    CLIPW             m0, m4, m5
-    CLIPW             m1, m4, m5
-    CLIPW             m2, m4, m5
-    CLIPW             m3, m4, m5
-    mova       [%1+0   ], m0
-    mova       [%1+%2  ], m1
-    mova       [%1+%2*2], m2
-    mova       [%1+%3  ], m3
-%endmacro
-
-%macro TRANS_ADD32_AVX2 3
-    mova              m0, [%3]
-    mova              m1, [%3+32]
-    mova              m2, [%3+64]
-    mova              m3, [%3+96]
-
-    paddw             m0, [%1      ]
-    paddw             m1, [%1+32   ]
-    paddw             m2, [%1+%2   ]
-    paddw             m3, [%1+%2+32]
-
-    CLIPW             m0, m4, m5
-    CLIPW             m1, m4, m5
-    CLIPW             m2, m4, m5
-    CLIPW             m3, m4, m5
-    mova      [%1      ], m0
-    mova      [%1+32   ], m1
-    mova      [%1+%2   ], m2
-    mova      [%1+%2+32], m3
-%endmacro
-
-
-INIT_MMX mmxext
-cglobal hevc_transform_add4_10,3,4, 6
-    pxor              m2, m2
-    mova              m3, [max_pixels_10]
-    TR_ADD_MMX4_10     r0, r2, r1
-    add               r1, 16
-    lea               r0, [r0+2*r2]
-    TR_ADD_MMX4_10     r0, r2, r1
-    RET
-
-;-----------------------------------------------------------------------------
-; void ff_hevc_transform_add_10(pixel *dst, int16_t *block, int stride)
-;-----------------------------------------------------------------------------
-INIT_XMM sse2
-cglobal hevc_transform_add8_10,3,4,6
-    pxor              m4, m4
-    mova              m5, [max_pixels_10]
-    lea               r3, [r2*3]
-
-    TR_ADD_SSE_8_10      r0, r2, r3, r1
-    lea               r0, [r0+r2*4]
-    add               r1, 64
-    TR_ADD_SSE_8_10      r0, r2, r3, r1
-    RET
-
-cglobal hevc_transform_add16_10,3,4,6
-    pxor              m4, m4
-    mova              m5, [max_pixels_10]
-
-    TRANS_ADD_SSE_16_10 r0, r2, r1
-%rep 7
-    lea                 r0, [r0+r2*2]
-    add                 r1, 64
-    TRANS_ADD_SSE_16_10 r0, r2, r1
-%endrep
-    RET
-
-cglobal hevc_transform_add32_10,3,4,6
-    pxor              m4, m4
-    mova              m5, [max_pixels_10]
-
-    TRANS_ADD_SSE_32_10 r0, r1
-%rep 31
-    lea                 r0, [r0+r2]
-    add                 r1, 64
-    TRANS_ADD_SSE_32_10 r0, r1
-%endrep
-    RET
-
-%if HAVE_AVX2_EXTERNAL
-INIT_YMM avx2
-
-cglobal hevc_transform_add16_10,3,4,6
-    pxor              m4, m4
-    mova              m5, [max_pixels_10]
-    lea               r3, [r2*3]
-
-    TRANS_ADD16_AVX2  r0, r2, r3, r1
-%rep 3
-    lea               r0, [r0+r2*4]
-    add               r1, 128
-    TRANS_ADD16_AVX2  r0, r2, r3, r1
-%endrep
-    RET
-
-cglobal hevc_transform_add32_10,3,4,6
-    pxor              m4, m4
-    mova              m5, [max_pixels_10]
-
-    TRANS_ADD32_AVX2  r0, r2, r1
-%rep 15
-    lea               r0, [r0+r2*2]
-    add               r1, 128
-    TRANS_ADD32_AVX2  r0, r2, r1
-%endrep
-    RET
-%endif ;HAVE_AVX_EXTERNAL
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/hevcdsp.h b/mythtv/external/FFmpeg/libavcodec/x86/hevcdsp.h
index ad8168fb5bd..67be0a9059f 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/hevcdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/x86/hevcdsp.h
@@ -29,9 +29,6 @@
 #include <stdint.h>
 
 
-#define idct_dc_proto(size, bitd, opt) \
-                void ff_hevc_idct##size##_dc_add_##bitd##_##opt(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
-
 #define PEL_LINK(dst, idx1, idx2, idx3, name, D, opt) \
 dst[idx1][idx2][idx3] = ff_hevc_put_hevc_ ## name ## _ ## D ## _##opt; \
 dst ## _bi[idx1][idx2][idx3] = ff_hevc_put_hevc_bi_ ## name ## _ ## D ## _##opt; \
@@ -239,23 +236,24 @@ WEIGHTING_PROTOTYPES(12, sse4);
 ///////////////////////////////////////////////////////////////////////////////
 // TRANSFORM_ADD
 ///////////////////////////////////////////////////////////////////////////////
-void ff_hevc_transform_add4_8_mmxext(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
-void ff_hevc_transform_add8_8_sse2(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
-void ff_hevc_transform_add16_8_sse2(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
-void ff_hevc_transform_add32_8_sse2(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
 
-void ff_hevc_transform_add8_8_avx(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
-void ff_hevc_transform_add16_8_avx(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
-void ff_hevc_transform_add32_8_avx(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
+void ff_hevc_add_residual_4_8_mmxext(uint8_t *dst, int16_t *res, ptrdiff_t stride);
+void ff_hevc_add_residual_8_8_sse2(uint8_t *dst, int16_t *res, ptrdiff_t stride);
+void ff_hevc_add_residual_16_8_sse2(uint8_t *dst, int16_t *res, ptrdiff_t stride);
+void ff_hevc_add_residual_32_8_sse2(uint8_t *dst, int16_t *res, ptrdiff_t stride);
+
+void ff_hevc_add_residual_8_8_avx(uint8_t *dst, int16_t *res, ptrdiff_t stride);
+void ff_hevc_add_residual_16_8_avx(uint8_t *dst, int16_t *res, ptrdiff_t stride);
+void ff_hevc_add_residual_32_8_avx(uint8_t *dst, int16_t *res, ptrdiff_t stride);
 
-void ff_hevc_transform_add32_8_avx2(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
+void ff_hevc_add_residual_32_8_avx2(uint8_t *dst, int16_t *res, ptrdiff_t stride);
 
-void ff_hevc_transform_add4_10_mmxext(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
-void ff_hevc_transform_add8_10_sse2(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
-void ff_hevc_transform_add16_10_sse2(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
-void ff_hevc_transform_add32_10_sse2(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
+void ff_hevc_add_residual_4_10_mmxext(uint8_t *dst, int16_t *res, ptrdiff_t stride);
+void ff_hevc_add_residual_8_10_sse2(uint8_t *dst, int16_t *res, ptrdiff_t stride);
+void ff_hevc_add_residual_16_10_sse2(uint8_t *dst, int16_t *res, ptrdiff_t stride);
+void ff_hevc_add_residual_32_10_sse2(uint8_t *dst, int16_t *res, ptrdiff_t stride);
 
-void ff_hevc_transform_add16_10_avx2(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
-void ff_hevc_transform_add32_10_avx2(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride);
+void ff_hevc_add_residual_16_10_avx2(uint8_t *dst, int16_t *res, ptrdiff_t stride);
+void ff_hevc_add_residual_32_10_avx2(uint8_t *dst, int16_t *res, ptrdiff_t stride);
 
 #endif // AVCODEC_X86_HEVCDSP_H
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/hevcdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/hevcdsp_init.c
index 09eb06d0c9d..17cd2332aa0 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/hevcdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/hevcdsp_init.c
@@ -2,7 +2,6 @@
  * Copyright (c) 2013 Seppo Tomperi
  * Copyright (c) 2013 - 2014 Pierre-Edouard Lepere
  *
- *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
@@ -21,6 +20,7 @@
  */
 
 #include "config.h"
+
 #include "libavutil/cpu.h"
 #include "libavutil/x86/asm.h"
 #include "libavutil/x86/cpu.h"
@@ -58,18 +58,31 @@ LFL_FUNCS(uint8_t,   8, avx)
 LFL_FUNCS(uint8_t,  10, avx)
 LFL_FUNCS(uint8_t,  12, avx)
 
-#define IDCT_FUNCS(W, opt) \
-void ff_hevc_idct##W##_dc_8_##opt(int16_t *coeffs); \
-void ff_hevc_idct##W##_dc_10_##opt(int16_t *coeffs); \
-void ff_hevc_idct##W##_dc_12_##opt(int16_t *coeffs)
-
-IDCT_FUNCS(4x4,   mmxext);
-IDCT_FUNCS(8x8,   mmxext);
-IDCT_FUNCS(8x8,   sse2);
-IDCT_FUNCS(16x16, sse2);
-IDCT_FUNCS(32x32, sse2);
-IDCT_FUNCS(16x16, avx2);
-IDCT_FUNCS(32x32, avx2);
+#define IDCT_DC_FUNCS(W, opt) \
+void ff_hevc_idct_ ## W ## _dc_8_ ## opt(int16_t *coeffs); \
+void ff_hevc_idct_ ## W ## _dc_10_ ## opt(int16_t *coeffs); \
+void ff_hevc_idct_ ## W ## _dc_12_ ## opt(int16_t *coeffs)
+
+IDCT_DC_FUNCS(4x4,   mmxext);
+IDCT_DC_FUNCS(8x8,   mmxext);
+IDCT_DC_FUNCS(8x8,   sse2);
+IDCT_DC_FUNCS(16x16, sse2);
+IDCT_DC_FUNCS(32x32, sse2);
+IDCT_DC_FUNCS(16x16, avx2);
+IDCT_DC_FUNCS(32x32, avx2);
+
+#define IDCT_FUNCS(opt)                                             \
+void ff_hevc_idct_4x4_8_    ## opt(int16_t *coeffs, int col_limit); \
+void ff_hevc_idct_4x4_10_   ## opt(int16_t *coeffs, int col_limit); \
+void ff_hevc_idct_8x8_8_    ## opt(int16_t *coeffs, int col_limit); \
+void ff_hevc_idct_8x8_10_   ## opt(int16_t *coeffs, int col_limit); \
+void ff_hevc_idct_16x16_8_  ## opt(int16_t *coeffs, int col_limit); \
+void ff_hevc_idct_16x16_10_ ## opt(int16_t *coeffs, int col_limit); \
+void ff_hevc_idct_32x32_8_  ## opt(int16_t *coeffs, int col_limit); \
+void ff_hevc_idct_32x32_10_ ## opt(int16_t *coeffs, int col_limit);
+
+IDCT_FUNCS(sse2)
+IDCT_FUNCS(avx)
 
 #define mc_rep_func(name, bitd, step, W, opt) \
 void ff_hevc_put_hevc_##name##W##_##bitd##_##opt(int16_t *_dst,                                                 \
@@ -698,9 +711,10 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
 
     if (bit_depth == 8) {
         if (EXTERNAL_MMXEXT(cpu_flags)) {
-            c->idct_dc[0] = ff_hevc_idct4x4_dc_8_mmxext;
-            c->idct_dc[1] = ff_hevc_idct8x8_dc_8_mmxext;
-            c->transform_add[0]    =  ff_hevc_transform_add4_8_mmxext;
+            c->idct_dc[0] = ff_hevc_idct_4x4_dc_8_mmxext;
+            c->idct_dc[1] = ff_hevc_idct_8x8_dc_8_mmxext;
+
+            c->add_residual[0] = ff_hevc_add_residual_4_8_mmxext;
         }
         if (EXTERNAL_SSE2(cpu_flags)) {
             c->hevc_v_loop_filter_chroma = ff_hevc_v_loop_filter_chroma_8_sse2;
@@ -709,16 +723,21 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
                 c->hevc_v_loop_filter_luma = ff_hevc_v_loop_filter_luma_8_sse2;
                 c->hevc_h_loop_filter_luma = ff_hevc_h_loop_filter_luma_8_sse2;
 
+                c->idct[2] = ff_hevc_idct_16x16_8_sse2;
+                c->idct[3] = ff_hevc_idct_32x32_8_sse2;
             }
             SAO_BAND_INIT(8, sse2);
 
-            c->idct_dc[1] = ff_hevc_idct8x8_dc_8_sse2;
-            c->idct_dc[2] = ff_hevc_idct16x16_dc_8_sse2;
-            c->idct_dc[3] = ff_hevc_idct32x32_dc_8_sse2;
+            c->idct_dc[1] = ff_hevc_idct_8x8_dc_8_sse2;
+            c->idct_dc[2] = ff_hevc_idct_16x16_dc_8_sse2;
+            c->idct_dc[3] = ff_hevc_idct_32x32_dc_8_sse2;
 
-            c->transform_add[1]    = ff_hevc_transform_add8_8_sse2;
-            c->transform_add[2]    = ff_hevc_transform_add16_8_sse2;
-            c->transform_add[3]    = ff_hevc_transform_add32_8_sse2;
+            c->idct[0]    = ff_hevc_idct_4x4_8_sse2;
+            c->idct[1]    = ff_hevc_idct_8x8_8_sse2;
+
+            c->add_residual[1] = ff_hevc_add_residual_8_8_sse2;
+            c->add_residual[2] = ff_hevc_add_residual_16_8_sse2;
+            c->add_residual[3] = ff_hevc_add_residual_32_8_sse2;
         }
         if (EXTERNAL_SSSE3(cpu_flags)) {
             if(ARCH_X86_64) {
@@ -745,20 +764,26 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
             if (ARCH_X86_64) {
                 c->hevc_v_loop_filter_luma = ff_hevc_v_loop_filter_luma_8_avx;
                 c->hevc_h_loop_filter_luma = ff_hevc_h_loop_filter_luma_8_avx;
+
+                c->idct[2] = ff_hevc_idct_16x16_8_avx;
+                c->idct[3] = ff_hevc_idct_32x32_8_avx;
             }
             SAO_BAND_INIT(8, avx);
 
-            c->transform_add[1]    = ff_hevc_transform_add8_8_avx;
-            c->transform_add[2]    = ff_hevc_transform_add16_8_avx;
-            c->transform_add[3]    = ff_hevc_transform_add32_8_avx;
+            c->idct[0] = ff_hevc_idct_4x4_8_avx;
+            c->idct[1] = ff_hevc_idct_8x8_8_avx;
+
+            c->add_residual[1] = ff_hevc_add_residual_8_8_avx;
+            c->add_residual[2] = ff_hevc_add_residual_16_8_avx;
+            c->add_residual[3] = ff_hevc_add_residual_32_8_avx;
         }
         if (EXTERNAL_AVX2(cpu_flags)) {
             c->sao_band_filter[0] = ff_hevc_sao_band_filter_8_8_avx2;
             c->sao_band_filter[1] = ff_hevc_sao_band_filter_16_8_avx2;
         }
         if (EXTERNAL_AVX2_FAST(cpu_flags)) {
-            c->idct_dc[2] = ff_hevc_idct16x16_dc_8_avx2;
-            c->idct_dc[3] = ff_hevc_idct32x32_dc_8_avx2;
+            c->idct_dc[2] = ff_hevc_idct_16x16_dc_8_avx2;
+            c->idct_dc[3] = ff_hevc_idct_32x32_dc_8_avx2;
             if (ARCH_X86_64) {
                 c->put_hevc_epel[7][0][0] = ff_hevc_put_hevc_pel_pixels32_8_avx2;
                 c->put_hevc_epel[8][0][0] = ff_hevc_put_hevc_pel_pixels48_8_avx2;
@@ -850,13 +875,13 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
             c->sao_edge_filter[3] = ff_hevc_sao_edge_filter_48_8_avx2;
             c->sao_edge_filter[4] = ff_hevc_sao_edge_filter_64_8_avx2;
 
-            c->transform_add[3]    = ff_hevc_transform_add32_8_avx2;
+            c->add_residual[3] = ff_hevc_add_residual_32_8_avx2;
         }
     } else if (bit_depth == 10) {
         if (EXTERNAL_MMXEXT(cpu_flags)) {
-            c->transform_add[0] = ff_hevc_transform_add4_10_mmxext;
-            c->idct_dc[0] = ff_hevc_idct4x4_dc_10_mmxext;
-            c->idct_dc[1] = ff_hevc_idct8x8_dc_10_mmxext;
+            c->add_residual[0] = ff_hevc_add_residual_4_10_mmxext;
+            c->idct_dc[0] = ff_hevc_idct_4x4_dc_10_mmxext;
+            c->idct_dc[1] = ff_hevc_idct_8x8_dc_10_mmxext;
         }
         if (EXTERNAL_SSE2(cpu_flags)) {
             c->hevc_v_loop_filter_chroma = ff_hevc_v_loop_filter_chroma_10_sse2;
@@ -864,17 +889,23 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
             if (ARCH_X86_64) {
                 c->hevc_v_loop_filter_luma = ff_hevc_v_loop_filter_luma_10_sse2;
                 c->hevc_h_loop_filter_luma = ff_hevc_h_loop_filter_luma_10_sse2;
+
+                c->idct[2] = ff_hevc_idct_16x16_10_sse2;
+                c->idct[3] = ff_hevc_idct_32x32_10_sse2;
             }
             SAO_BAND_INIT(10, sse2);
             SAO_EDGE_INIT(10, sse2);
 
-            c->idct_dc[1] = ff_hevc_idct8x8_dc_10_sse2;
-            c->idct_dc[2] = ff_hevc_idct16x16_dc_10_sse2;
-            c->idct_dc[3] = ff_hevc_idct32x32_dc_10_sse2;
+            c->idct_dc[1] = ff_hevc_idct_8x8_dc_10_sse2;
+            c->idct_dc[2] = ff_hevc_idct_16x16_dc_10_sse2;
+            c->idct_dc[3] = ff_hevc_idct_32x32_dc_10_sse2;
+
+            c->idct[0]    = ff_hevc_idct_4x4_10_sse2;
+            c->idct[1]    = ff_hevc_idct_8x8_10_sse2;
 
-            c->transform_add[1]    = ff_hevc_transform_add8_10_sse2;
-            c->transform_add[2]    = ff_hevc_transform_add16_10_sse2;
-            c->transform_add[3]    = ff_hevc_transform_add32_10_sse2;
+            c->add_residual[1] = ff_hevc_add_residual_8_10_sse2;
+            c->add_residual[2] = ff_hevc_add_residual_16_10_sse2;
+            c->add_residual[3] = ff_hevc_add_residual_32_10_sse2;
         }
         if (EXTERNAL_SSSE3(cpu_flags) && ARCH_X86_64) {
             c->hevc_v_loop_filter_luma = ff_hevc_v_loop_filter_luma_10_ssse3;
@@ -897,15 +928,22 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
             if (ARCH_X86_64) {
                 c->hevc_v_loop_filter_luma = ff_hevc_v_loop_filter_luma_10_avx;
                 c->hevc_h_loop_filter_luma = ff_hevc_h_loop_filter_luma_10_avx;
+
+                c->idct[2] = ff_hevc_idct_16x16_10_avx;
+                c->idct[3] = ff_hevc_idct_32x32_10_avx;
             }
+
+            c->idct[0] = ff_hevc_idct_4x4_10_avx;
+            c->idct[1] = ff_hevc_idct_8x8_10_avx;
+
             SAO_BAND_INIT(10, avx);
         }
         if (EXTERNAL_AVX2(cpu_flags)) {
             c->sao_band_filter[0] = ff_hevc_sao_band_filter_8_10_avx2;
         }
         if (EXTERNAL_AVX2_FAST(cpu_flags)) {
-            c->idct_dc[2] = ff_hevc_idct16x16_dc_10_avx2;
-            c->idct_dc[3] = ff_hevc_idct32x32_dc_10_avx2;
+            c->idct_dc[2] = ff_hevc_idct_16x16_dc_10_avx2;
+            c->idct_dc[3] = ff_hevc_idct_32x32_dc_10_avx2;
             if (ARCH_X86_64) {
                 c->put_hevc_epel[5][0][0] = ff_hevc_put_hevc_pel_pixels16_10_avx2;
                 c->put_hevc_epel[6][0][0] = ff_hevc_put_hevc_pel_pixels24_10_avx2;
@@ -1053,14 +1091,13 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
             SAO_BAND_INIT(10, avx2);
             SAO_EDGE_INIT(10, avx2);
 
-            c->transform_add[2] = ff_hevc_transform_add16_10_avx2;
-            c->transform_add[3] = ff_hevc_transform_add32_10_avx2;
-
+            c->add_residual[2] = ff_hevc_add_residual_16_10_avx2;
+            c->add_residual[3] = ff_hevc_add_residual_32_10_avx2;
         }
     } else if (bit_depth == 12) {
         if (EXTERNAL_MMXEXT(cpu_flags)) {
-            c->idct_dc[0] = ff_hevc_idct4x4_dc_12_mmxext;
-            c->idct_dc[1] = ff_hevc_idct8x8_dc_12_mmxext;
+            c->idct_dc[0] = ff_hevc_idct_4x4_dc_12_mmxext;
+            c->idct_dc[1] = ff_hevc_idct_8x8_dc_12_mmxext;
         }
         if (EXTERNAL_SSE2(cpu_flags)) {
             c->hevc_v_loop_filter_chroma = ff_hevc_v_loop_filter_chroma_12_sse2;
@@ -1072,9 +1109,9 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
             SAO_BAND_INIT(12, sse2);
             SAO_EDGE_INIT(12, sse2);
 
-            c->idct_dc[1] = ff_hevc_idct8x8_dc_12_sse2;
-            c->idct_dc[2] = ff_hevc_idct16x16_dc_12_sse2;
-            c->idct_dc[3] = ff_hevc_idct32x32_dc_12_sse2;
+            c->idct_dc[1] = ff_hevc_idct_8x8_dc_12_sse2;
+            c->idct_dc[2] = ff_hevc_idct_16x16_dc_12_sse2;
+            c->idct_dc[3] = ff_hevc_idct_32x32_dc_12_sse2;
         }
         if (EXTERNAL_SSSE3(cpu_flags) && ARCH_X86_64) {
             c->hevc_v_loop_filter_luma = ff_hevc_v_loop_filter_luma_12_ssse3;
@@ -1104,8 +1141,8 @@ void ff_hevc_dsp_init_x86(HEVCDSPContext *c, const int bit_depth)
             c->sao_band_filter[0] = ff_hevc_sao_band_filter_8_12_avx2;
         }
         if (EXTERNAL_AVX2_FAST(cpu_flags)) {
-            c->idct_dc[2] = ff_hevc_idct16x16_dc_12_avx2;
-            c->idct_dc[3] = ff_hevc_idct32x32_dc_12_avx2;
+            c->idct_dc[2] = ff_hevc_idct_16x16_dc_12_avx2;
+            c->idct_dc[3] = ff_hevc_idct_32x32_dc_12_avx2;
 
             SAO_BAND_INIT(12, avx2);
             SAO_EDGE_INIT(12, avx2);
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp.asm
index 82fb8934af2..ce5d7a4e28c 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp.asm
@@ -175,53 +175,6 @@ INIT_MMX 3dnow
 PUT_NO_RND_PIXELS8_X2
 
 
-; void ff_put_no_rnd_pixels8_x2_exact(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
-%macro PUT_NO_RND_PIXELS8_X2_EXACT 0
-cglobal put_no_rnd_pixels8_x2_exact, 4,5
-    lea          r4, [r2*3]
-    pcmpeqb      m6, m6
-.loop:
-    mova         m0, [r1]
-    mova         m2, [r1+r2]
-    mova         m1, [r1+1]
-    mova         m3, [r1+r2+1]
-    pxor         m0, m6
-    pxor         m2, m6
-    pxor         m1, m6
-    pxor         m3, m6
-    PAVGB        m0, m1
-    PAVGB        m2, m3
-    pxor         m0, m6
-    pxor         m2, m6
-    mova       [r0], m0
-    mova    [r0+r2], m2
-    mova         m0, [r1+r2*2]
-    mova         m1, [r1+r2*2+1]
-    mova         m2, [r1+r4]
-    mova         m3, [r1+r4+1]
-    pxor         m0, m6
-    pxor         m1, m6
-    pxor         m2, m6
-    pxor         m3, m6
-    PAVGB        m0, m1
-    PAVGB        m2, m3
-    pxor         m0, m6
-    pxor         m2, m6
-    mova  [r0+r2*2], m0
-    mova    [r0+r4], m2
-    lea          r1, [r1+r2*4]
-    lea          r0, [r0+r2*4]
-    sub         r3d, 4
-    jg .loop
-    REP_RET
-%endmacro
-
-INIT_MMX mmxext
-PUT_NO_RND_PIXELS8_X2_EXACT
-INIT_MMX 3dnow
-PUT_NO_RND_PIXELS8_X2_EXACT
-
-
 ; void ff_put_pixels8_y2(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
 %macro PUT_PIXELS8_Y2 0
 %if cpuflag(sse2)
@@ -300,48 +253,6 @@ INIT_MMX 3dnow
 PUT_NO_RND_PIXELS8_Y2
 
 
-; void ff_put_no_rnd_pixels8_y2_exact(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
-%macro PUT_NO_RND_PIXELS8_Y2_EXACT 0
-cglobal put_no_rnd_pixels8_y2_exact, 4,5
-    lea          r4, [r2*3]
-    mova         m0, [r1]
-    pcmpeqb      m6, m6
-    add          r1, r2
-    pxor         m0, m6
-.loop:
-    mova         m1, [r1]
-    mova         m2, [r1+r2]
-    pxor         m1, m6
-    pxor         m2, m6
-    PAVGB        m0, m1
-    PAVGB        m1, m2
-    pxor         m0, m6
-    pxor         m1, m6
-    mova       [r0], m0
-    mova    [r0+r2], m1
-    mova         m1, [r1+r2*2]
-    mova         m0, [r1+r4]
-    pxor         m1, m6
-    pxor         m0, m6
-    PAVGB        m2, m1
-    PAVGB        m1, m0
-    pxor         m2, m6
-    pxor         m1, m6
-    mova  [r0+r2*2], m2
-    mova    [r0+r4], m1
-    lea          r1, [r1+r2*4]
-    lea          r0, [r0+r2*4]
-    sub         r3d, 4
-    jg .loop
-    REP_RET
-%endmacro
-
-INIT_MMX mmxext
-PUT_NO_RND_PIXELS8_Y2_EXACT
-INIT_MMX 3dnow
-PUT_NO_RND_PIXELS8_Y2_EXACT
-
-
 ; void ff_avg_pixels8(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
 %macro AVG_PIXELS8 0
 cglobal avg_pixels8, 4,5
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp.h b/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp.h
index 5fae990a4fa..bf97029b57d 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp.h
@@ -22,6 +22,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include "libavcodec/hpeldsp.h"
+
 void ff_avg_pixels8_x2_mmx(uint8_t *block, const uint8_t *pixels,
                            ptrdiff_t line_size, int h);
 
@@ -50,4 +52,6 @@ void ff_put_pixels16_xy2_sse2(uint8_t *block, const uint8_t *pixels,
 void ff_put_pixels16_xy2_ssse3(uint8_t *block, const uint8_t *pixels,
                                ptrdiff_t line_size, int h);
 
+void ff_hpeldsp_vp3_init_x86(HpelDSPContext *c, int cpu_flags, int flags);
+
 #endif /* AVCODEC_X86_HPELDSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp_init.c
index f1ba4be6a2c..d89928cec69 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp_init.c
@@ -51,12 +51,6 @@ void ff_put_no_rnd_pixels8_x2_mmxext(uint8_t *block, const uint8_t *pixels,
                                      ptrdiff_t line_size, int h);
 void ff_put_no_rnd_pixels8_x2_3dnow(uint8_t *block, const uint8_t *pixels,
                                     ptrdiff_t line_size, int h);
-void ff_put_no_rnd_pixels8_x2_exact_mmxext(uint8_t *block,
-                                           const uint8_t *pixels,
-                                           ptrdiff_t line_size, int h);
-void ff_put_no_rnd_pixels8_x2_exact_3dnow(uint8_t *block,
-                                          const uint8_t *pixels,
-                                          ptrdiff_t line_size, int h);
 void ff_put_pixels8_y2_mmxext(uint8_t *block, const uint8_t *pixels,
                               ptrdiff_t line_size, int h);
 void ff_put_pixels8_y2_3dnow(uint8_t *block, const uint8_t *pixels,
@@ -65,12 +59,6 @@ void ff_put_no_rnd_pixels8_y2_mmxext(uint8_t *block, const uint8_t *pixels,
                                      ptrdiff_t line_size, int h);
 void ff_put_no_rnd_pixels8_y2_3dnow(uint8_t *block, const uint8_t *pixels,
                                     ptrdiff_t line_size, int h);
-void ff_put_no_rnd_pixels8_y2_exact_mmxext(uint8_t *block,
-                                           const uint8_t *pixels,
-                                           ptrdiff_t line_size, int h);
-void ff_put_no_rnd_pixels8_y2_exact_3dnow(uint8_t *block,
-                                          const uint8_t *pixels,
-                                          ptrdiff_t line_size, int h);
 void ff_avg_pixels8_3dnow(uint8_t *block, const uint8_t *pixels,
                           ptrdiff_t line_size, int h);
 void ff_avg_pixels8_x2_mmxext(uint8_t *block, const uint8_t *pixels,
@@ -160,7 +148,7 @@ CALL_2X_PIXELS_EXPORT(ff_put_pixels16_xy2_mmx, ff_put_pixels8_xy2_mmx, 8)
 #endif /* HAVE_INLINE_ASM */
 
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 
 #define HPELDSP_AVG_PIXELS16(CPUEXT)                      \
     CALL_2X_PIXELS(put_no_rnd_pixels16_x2 ## CPUEXT, ff_put_no_rnd_pixels8_x2 ## CPUEXT, 8) \
@@ -175,7 +163,7 @@ CALL_2X_PIXELS_EXPORT(ff_put_pixels16_xy2_mmx, ff_put_pixels8_xy2_mmx, 8)
 HPELDSP_AVG_PIXELS16(_3dnow)
 HPELDSP_AVG_PIXELS16(_mmxext)
 
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 #define SET_HPEL_FUNCS_EXT(PFX, IDX, SIZE, CPU)                             \
     if (HAVE_MMX_EXTERNAL)                                                  \
@@ -196,7 +184,7 @@ HPELDSP_AVG_PIXELS16(_mmxext)
     } while (0)
 #endif
 
-static void hpeldsp_init_mmx(HpelDSPContext *c, int flags, int cpu_flags)
+static void hpeldsp_init_mmx(HpelDSPContext *c, int flags)
 {
     SET_HPEL_FUNCS(put,        [0], 16, mmx);
     SET_HPEL_FUNCS(put_no_rnd, [0], 16, mmx);
@@ -214,7 +202,7 @@ static void hpeldsp_init_mmx(HpelDSPContext *c, int flags, int cpu_flags)
 #endif
 }
 
-static void hpeldsp_init_mmxext(HpelDSPContext *c, int flags, int cpu_flags)
+static void hpeldsp_init_mmxext(HpelDSPContext *c, int flags)
 {
 #if HAVE_MMXEXT_EXTERNAL
     c->put_pixels_tab[0][1] = ff_put_pixels16_x2_mmxext;
@@ -242,15 +230,10 @@ static void hpeldsp_init_mmxext(HpelDSPContext *c, int flags, int cpu_flags)
         c->avg_pixels_tab[0][3] = avg_approx_pixels16_xy2_mmxext;
         c->avg_pixels_tab[1][3] = ff_avg_approx_pixels8_xy2_mmxext;
     }
-
-    if (CONFIG_VP3_DECODER && flags & AV_CODEC_FLAG_BITEXACT) {
-        c->put_no_rnd_pixels_tab[1][1] = ff_put_no_rnd_pixels8_x2_exact_mmxext;
-        c->put_no_rnd_pixels_tab[1][2] = ff_put_no_rnd_pixels8_y2_exact_mmxext;
-    }
 #endif /* HAVE_MMXEXT_EXTERNAL */
 }
 
-static void hpeldsp_init_3dnow(HpelDSPContext *c, int flags, int cpu_flags)
+static void hpeldsp_init_3dnow(HpelDSPContext *c, int flags)
 {
 #if HAVE_AMD3DNOW_EXTERNAL
     c->put_pixels_tab[0][1] = ff_put_pixels16_x2_3dnow;
@@ -278,33 +261,25 @@ static void hpeldsp_init_3dnow(HpelDSPContext *c, int flags, int cpu_flags)
         c->avg_pixels_tab[0][3] = avg_approx_pixels16_xy2_3dnow;
         c->avg_pixels_tab[1][3] = ff_avg_approx_pixels8_xy2_3dnow;
     }
-
-    if (CONFIG_VP3_DECODER && flags & AV_CODEC_FLAG_BITEXACT) {
-        c->put_no_rnd_pixels_tab[1][1] = ff_put_no_rnd_pixels8_x2_exact_3dnow;
-        c->put_no_rnd_pixels_tab[1][2] = ff_put_no_rnd_pixels8_y2_exact_3dnow;
-    }
 #endif /* HAVE_AMD3DNOW_EXTERNAL */
 }
 
-static void hpeldsp_init_sse2(HpelDSPContext *c, int flags, int cpu_flags)
+static void hpeldsp_init_sse2_fast(HpelDSPContext *c, int flags)
 {
 #if HAVE_SSE2_EXTERNAL
-    if (!(cpu_flags & AV_CPU_FLAG_SSE2SLOW)) {
-        // these functions are slower than mmx on AMD, but faster on Intel
-        c->put_pixels_tab[0][0]        = ff_put_pixels16_sse2;
-        c->put_no_rnd_pixels_tab[0][0] = ff_put_pixels16_sse2;
-        c->put_pixels_tab[0][1]        = ff_put_pixels16_x2_sse2;
-        c->put_pixels_tab[0][2]        = ff_put_pixels16_y2_sse2;
-        c->put_pixels_tab[0][3]        = ff_put_pixels16_xy2_sse2;
-        c->avg_pixels_tab[0][0]        = ff_avg_pixels16_sse2;
-        c->avg_pixels_tab[0][1]        = ff_avg_pixels16_x2_sse2;
-        c->avg_pixels_tab[0][2]        = ff_avg_pixels16_y2_sse2;
-        c->avg_pixels_tab[0][3]        = ff_avg_pixels16_xy2_sse2;
-    }
+    c->put_pixels_tab[0][0]        = ff_put_pixels16_sse2;
+    c->put_no_rnd_pixels_tab[0][0] = ff_put_pixels16_sse2;
+    c->put_pixels_tab[0][1]        = ff_put_pixels16_x2_sse2;
+    c->put_pixels_tab[0][2]        = ff_put_pixels16_y2_sse2;
+    c->put_pixels_tab[0][3]        = ff_put_pixels16_xy2_sse2;
+    c->avg_pixels_tab[0][0]        = ff_avg_pixels16_sse2;
+    c->avg_pixels_tab[0][1]        = ff_avg_pixels16_x2_sse2;
+    c->avg_pixels_tab[0][2]        = ff_avg_pixels16_y2_sse2;
+    c->avg_pixels_tab[0][3]        = ff_avg_pixels16_xy2_sse2;
 #endif /* HAVE_SSE2_EXTERNAL */
 }
 
-static void hpeldsp_init_ssse3(HpelDSPContext *c, int flags, int cpu_flags)
+static void hpeldsp_init_ssse3(HpelDSPContext *c, int flags)
 {
 #if HAVE_SSSE3_EXTERNAL
     c->put_pixels_tab[0][3]            = ff_put_pixels16_xy2_ssse3;
@@ -319,17 +294,20 @@ av_cold void ff_hpeldsp_init_x86(HpelDSPContext *c, int flags)
     int cpu_flags = av_get_cpu_flags();
 
     if (INLINE_MMX(cpu_flags))
-        hpeldsp_init_mmx(c, flags, cpu_flags);
+        hpeldsp_init_mmx(c, flags);
 
     if (EXTERNAL_AMD3DNOW(cpu_flags))
-        hpeldsp_init_3dnow(c, flags, cpu_flags);
+        hpeldsp_init_3dnow(c, flags);
 
     if (EXTERNAL_MMXEXT(cpu_flags))
-        hpeldsp_init_mmxext(c, flags, cpu_flags);
+        hpeldsp_init_mmxext(c, flags);
 
-    if (EXTERNAL_SSE2(cpu_flags))
-        hpeldsp_init_sse2(c, flags, cpu_flags);
+    if (EXTERNAL_SSE2_FAST(cpu_flags))
+        hpeldsp_init_sse2_fast(c, flags);
 
     if (EXTERNAL_SSSE3(cpu_flags))
-        hpeldsp_init_ssse3(c, flags, cpu_flags);
+        hpeldsp_init_ssse3(c, flags);
+
+    if (CONFIG_VP3_DECODER)
+        ff_hpeldsp_vp3_init_x86(c, cpu_flags, flags);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp_vp3.asm b/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp_vp3.asm
new file mode 100644
index 00000000000..cba96d06cb7
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp_vp3.asm
@@ -0,0 +1,111 @@
+;******************************************************************************
+;* SIMD-optimized halfpel functions for VP3
+;*
+;* 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/x86/x86util.asm"
+
+SECTION .text
+
+; void ff_put_no_rnd_pixels8_x2_exact(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
+%macro PUT_NO_RND_PIXELS8_X2_EXACT 0
+cglobal put_no_rnd_pixels8_x2_exact, 4,5
+    lea          r4, [r2*3]
+    pcmpeqb      m6, m6
+.loop:
+    mova         m0, [r1]
+    mova         m2, [r1+r2]
+    mova         m1, [r1+1]
+    mova         m3, [r1+r2+1]
+    pxor         m0, m6
+    pxor         m2, m6
+    pxor         m1, m6
+    pxor         m3, m6
+    PAVGB        m0, m1
+    PAVGB        m2, m3
+    pxor         m0, m6
+    pxor         m2, m6
+    mova       [r0], m0
+    mova    [r0+r2], m2
+    mova         m0, [r1+r2*2]
+    mova         m1, [r1+r2*2+1]
+    mova         m2, [r1+r4]
+    mova         m3, [r1+r4+1]
+    pxor         m0, m6
+    pxor         m1, m6
+    pxor         m2, m6
+    pxor         m3, m6
+    PAVGB        m0, m1
+    PAVGB        m2, m3
+    pxor         m0, m6
+    pxor         m2, m6
+    mova  [r0+r2*2], m0
+    mova    [r0+r4], m2
+    lea          r1, [r1+r2*4]
+    lea          r0, [r0+r2*4]
+    sub         r3d, 4
+    jg .loop
+    REP_RET
+%endmacro
+
+INIT_MMX mmxext
+PUT_NO_RND_PIXELS8_X2_EXACT
+INIT_MMX 3dnow
+PUT_NO_RND_PIXELS8_X2_EXACT
+
+
+; void ff_put_no_rnd_pixels8_y2_exact(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
+%macro PUT_NO_RND_PIXELS8_Y2_EXACT 0
+cglobal put_no_rnd_pixels8_y2_exact, 4,5
+    lea          r4, [r2*3]
+    mova         m0, [r1]
+    pcmpeqb      m6, m6
+    add          r1, r2
+    pxor         m0, m6
+.loop:
+    mova         m1, [r1]
+    mova         m2, [r1+r2]
+    pxor         m1, m6
+    pxor         m2, m6
+    PAVGB        m0, m1
+    PAVGB        m1, m2
+    pxor         m0, m6
+    pxor         m1, m6
+    mova       [r0], m0
+    mova    [r0+r2], m1
+    mova         m1, [r1+r2*2]
+    mova         m0, [r1+r4]
+    pxor         m1, m6
+    pxor         m0, m6
+    PAVGB        m2, m1
+    PAVGB        m1, m0
+    pxor         m2, m6
+    pxor         m1, m6
+    mova  [r0+r2*2], m2
+    mova    [r0+r4], m1
+    lea          r1, [r1+r2*4]
+    lea          r0, [r0+r2*4]
+    sub         r3d, 4
+    jg .loop
+    REP_RET
+%endmacro
+
+INIT_MMX mmxext
+PUT_NO_RND_PIXELS8_Y2_EXACT
+INIT_MMX 3dnow
+PUT_NO_RND_PIXELS8_Y2_EXACT
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp_vp3_init.c b/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp_vp3_init.c
new file mode 100644
index 00000000000..5979f4123ce
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/hpeldsp_vp3_init.c
@@ -0,0 +1,56 @@
+/*
+ * 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 "libavutil/cpu.h"
+#include "libavutil/x86/cpu.h"
+
+#include "libavcodec/avcodec.h"
+#include "libavcodec/hpeldsp.h"
+
+#include "hpeldsp.h"
+
+void ff_put_no_rnd_pixels8_x2_exact_mmxext(uint8_t *block,
+                                           const uint8_t *pixels,
+                                           ptrdiff_t line_size, int h);
+void ff_put_no_rnd_pixels8_x2_exact_3dnow(uint8_t *block,
+                                          const uint8_t *pixels,
+                                          ptrdiff_t line_size, int h);
+void ff_put_no_rnd_pixels8_y2_exact_mmxext(uint8_t *block,
+                                           const uint8_t *pixels,
+                                           ptrdiff_t line_size, int h);
+void ff_put_no_rnd_pixels8_y2_exact_3dnow(uint8_t *block,
+                                          const uint8_t *pixels,
+                                          ptrdiff_t line_size, int h);
+
+av_cold void ff_hpeldsp_vp3_init_x86(HpelDSPContext *c, int cpu_flags, int flags)
+{
+    if (EXTERNAL_AMD3DNOW(cpu_flags)) {
+        if (flags & AV_CODEC_FLAG_BITEXACT) {
+            c->put_no_rnd_pixels_tab[1][1] = ff_put_no_rnd_pixels8_x2_exact_3dnow;
+            c->put_no_rnd_pixels_tab[1][2] = ff_put_no_rnd_pixels8_y2_exact_3dnow;
+        }
+    }
+
+    if (EXTERNAL_MMXEXT(cpu_flags)) {
+        if (flags & AV_CODEC_FLAG_BITEXACT) {
+            c->put_no_rnd_pixels_tab[1][1] = ff_put_no_rnd_pixels8_x2_exact_mmxext;
+            c->put_no_rnd_pixels_tab[1][2] = ff_put_no_rnd_pixels8_y2_exact_mmxext;
+        }
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/huffyuvdsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/huffyuvdsp.asm
index 0dbe5984218..0d8cae354a5 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/huffyuvdsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/huffyuvdsp.asm
@@ -22,195 +22,79 @@
 
 %include "libavutil/x86/x86util.asm"
 
-SECTION_RODATA
-cextern pb_15
-pb_zzzzzzzz77777777: times 8 db -1
-pb_7: times 8 db 7
-pb_zzzz3333zzzzbbbb: db -1,-1,-1,-1,3,3,3,3,-1,-1,-1,-1,11,11,11,11
-pb_zz11zz55zz99zzdd: db -1,-1,1,1,-1,-1,5,5,-1,-1,9,9,-1,-1,13,13
-
 SECTION .text
 
-; void ff_add_hfyu_median_pred_mmxext(uint8_t *dst, const uint8_t *top,
-;                                     const uint8_t *diff, int w,
-;                                     int *left, int *left_top)
-%macro HFYU_MEDIAN 0
-cglobal add_hfyu_median_pred, 6,6,8, dst, top, diff, w, left, left_top
-    movu    m0, [topq]
-    mova    m2, m0
-    movd    m4, [left_topq]
-    LSHIFT  m2, 1
-    mova    m1, m0
-    por     m4, m2
-    movd    m3, [leftq]
-    psubb   m0, m4 ; t-tl
-    add    dstq, wq
-    add    topq, wq
-    add   diffq, wq
-    neg      wq
-    jmp .skip
-.loop:
-    movu    m4, [topq+wq]
-    mova    m0, m4
-    LSHIFT  m4, 1
-    por     m4, m1
-    mova    m1, m0 ; t
-    psubb   m0, m4 ; t-tl
-.skip:
-    movu    m2, [diffq+wq]
-%assign i 0
-%rep mmsize
-    mova    m4, m0
-    paddb   m4, m3 ; t-tl+l
-    mova    m5, m3
-    pmaxub  m3, m1
-    pminub  m5, m1
-    pminub  m3, m4
-    pmaxub  m3, m5 ; median
-    paddb   m3, m2 ; +residual
-%if i==0
-    mova    m7, m3
-    LSHIFT  m7, mmsize-1
-%else
-    mova    m6, m3
-    RSHIFT  m7, 1
-    LSHIFT  m6, mmsize-1
-    por     m7, m6
-%endif
-%if i<mmsize-1
-    RSHIFT  m0, 1
-    RSHIFT  m1, 1
-    RSHIFT  m2, 1
-%endif
-%assign i i+1
-%endrep
-    movu [dstq+wq], m7
-    add      wq, mmsize
-    jl .loop
-    movzx   r2d, byte [dstq-1]
-    mov [leftq], r2d
-    movzx   r2d, byte [topq-1]
-    mov [left_topq], r2d
-    RET
-%endmacro
 
-%if ARCH_X86_32
-INIT_MMX mmxext
-HFYU_MEDIAN
+%macro INT16_LOOP 2 ; %1 = a/u (aligned/unaligned), %2 = add/sub
+    movd    m4, maskd
+    SPLATW  m4, m4
+    add     wd, wd
+    test    wq, 2*mmsize - 1
+    jz %%.tomainloop
+    push  tmpq
+%%.wordloop:
+    sub     wq, 2
+%ifidn %2, add
+    mov   tmpw, [srcq+wq]
+    add   tmpw, [dstq+wq]
+%else
+    mov   tmpw, [src1q+wq]
+    sub   tmpw, [src2q+wq]
 %endif
-INIT_XMM sse2
-HFYU_MEDIAN
-
-
-%macro ADD_HFYU_LEFT_LOOP 2 ; %1 = dst_is_aligned, %2 = src_is_aligned
+    and   tmpw, maskw
+    mov     [dstq+wq], tmpw
+    test    wq, 2*mmsize - 1
+    jnz %%.wordloop
+    pop   tmpq
+%%.tomainloop:
+%ifidn %2, add
     add     srcq, wq
+%else
+    add     src1q, wq
+    add     src2q, wq
+%endif
     add     dstq, wq
     neg     wq
+    jz      %%.end
 %%.loop:
-%if %2
-    mova    m1, [srcq+wq]
+%ifidn %2, add
+    mov%1   m0, [srcq+wq]
+    mov%1   m1, [dstq+wq]
+    mov%1   m2, [srcq+wq+mmsize]
+    mov%1   m3, [dstq+wq+mmsize]
 %else
-    movu    m1, [srcq+wq]
-%endif
-    mova    m2, m1
-    psllw   m1, 8
-    paddb   m1, m2
-    mova    m2, m1
-    pshufb  m1, m3
-    paddb   m1, m2
-    pshufb  m0, m5
-    mova    m2, m1
-    pshufb  m1, m4
-    paddb   m1, m2
-%if mmsize == 16
-    mova    m2, m1
-    pshufb  m1, m6
-    paddb   m1, m2
+    mov%1   m0, [src1q+wq]
+    mov%1   m1, [src2q+wq]
+    mov%1   m2, [src1q+wq+mmsize]
+    mov%1   m3, [src2q+wq+mmsize]
 %endif
-    paddb   m0, m1
-%if %1
-    mova    [dstq+wq], m0
-%else
-    movq    [dstq+wq], m0
-    movhps  [dstq+wq+8], m0
-%endif
-    add     wq, mmsize
+    p%2w    m0, m1
+    p%2w    m2, m3
+    pand    m0, m4
+    pand    m2, m4
+    mov%1   [dstq+wq]       , m0
+    mov%1   [dstq+wq+mmsize], m2
+    add     wq, 2*mmsize
     jl %%.loop
-    mov     eax, mmsize-1
-    sub     eax, wd
-    movd    m1, eax
-    pshufb  m0, m1
-    movd    eax, m0
+%%.end:
     RET
 %endmacro
 
-; int ff_add_hfyu_left_pred(uint8_t *dst, const uint8_t *src, int w, int left)
-INIT_MMX ssse3
-cglobal add_hfyu_left_pred, 3,3,7, dst, src, w, left
-.skip_prologue:
-    mova    m5, [pb_7]
-    mova    m4, [pb_zzzz3333zzzzbbbb]
-    mova    m3, [pb_zz11zz55zz99zzdd]
-    movd    m0, leftm
-    psllq   m0, 56
-    ADD_HFYU_LEFT_LOOP 1, 1
-
-INIT_XMM sse4
-cglobal add_hfyu_left_pred, 3,3,7, dst, src, w, left
-    mova    m5, [pb_15]
-    mova    m6, [pb_zzzzzzzz77777777]
-    mova    m4, [pb_zzzz3333zzzzbbbb]
-    mova    m3, [pb_zz11zz55zz99zzdd]
-    movd    m0, leftm
-    pslldq  m0, 15
-    test    srcq, 15
-    jnz .src_unaligned
-    test    dstq, 15
-    jnz .dst_unaligned
-    ADD_HFYU_LEFT_LOOP 1, 1
-.dst_unaligned:
-    ADD_HFYU_LEFT_LOOP 0, 1
-.src_unaligned:
-    ADD_HFYU_LEFT_LOOP 0, 0
-
-%macro ADD_BYTES 0
-cglobal add_bytes, 3,4,2, dst, src, w, size
-    mov  sizeq, wq
-    and  sizeq, -2*mmsize
-    jz  .2
-    add   dstq, sizeq
-    add   srcq, sizeq
-    neg  sizeq
-.1:
-    mova    m0, [srcq + sizeq]
-    mova    m1, [srcq + sizeq + mmsize]
-    paddb   m0, [dstq + sizeq]
-    paddb   m1, [dstq + sizeq + mmsize]
-    mova   [dstq + sizeq], m0
-    mova   [dstq + sizeq + mmsize], m1
-    add  sizeq, 2*mmsize
-    jl .1
-.2:
-    and     wq, 2*mmsize-1
-    jz    .end
-    add   dstq, wq
-    add   srcq, wq
-    neg     wq
-.3:
-    mov  sizeb, [srcq + wq]
-    add [dstq + wq], sizeb
-    inc     wq
-    jl .3
-.end:
-    REP_RET
-%endmacro
-
 %if ARCH_X86_32
 INIT_MMX mmx
-ADD_BYTES
+cglobal add_int16, 4,4,5, dst, src, mask, w, tmp
+    INT16_LOOP a, add
 %endif
+
 INIT_XMM sse2
-ADD_BYTES
+cglobal add_int16, 4,4,5, dst, src, mask, w, tmp
+    test srcq, mmsize-1
+    jnz .unaligned
+    test dstq, mmsize-1
+    jnz .unaligned
+    INT16_LOOP a, add
+.unaligned:
+    INT16_LOOP u, add
 
 ; void add_hfyu_left_pred_bgr32(uint8_t *dst, const uint8_t *src,
 ;                               intptr_t w, uint8_t *left)
@@ -251,3 +135,68 @@ LEFT_BGR32
 %endif
 INIT_XMM sse2
 LEFT_BGR32
+
+; void add_hfyu_median_prediction_mmxext(uint8_t *dst, const uint8_t *top, const uint8_t *diff, int mask, int w, int *left, int *left_top)
+INIT_MMX mmxext
+cglobal add_hfyu_median_pred_int16, 7,7,0, dst, top, diff, mask, w, left, left_top
+    add      wd, wd
+    movd    mm6, maskd
+    SPLATW  mm6, mm6
+    movq    mm0, [topq]
+    movq    mm2, mm0
+    movd    mm4, [left_topq]
+    psllq   mm2, 16
+    movq    mm1, mm0
+    por     mm4, mm2
+    movd    mm3, [leftq]
+    psubw   mm0, mm4 ; t-tl
+    add    dstq, wq
+    add    topq, wq
+    add   diffq, wq
+    neg      wq
+    jmp .skip
+.loop:
+    movq    mm4, [topq+wq]
+    movq    mm0, mm4
+    psllq   mm4, 16
+    por     mm4, mm1
+    movq    mm1, mm0 ; t
+    psubw   mm0, mm4 ; t-tl
+.skip:
+    movq    mm2, [diffq+wq]
+%assign i 0
+%rep 4
+    movq    mm4, mm0
+    paddw   mm4, mm3 ; t-tl+l
+    pand    mm4, mm6
+    movq    mm5, mm3
+    pmaxsw  mm3, mm1
+    pminsw  mm5, mm1
+    pminsw  mm3, mm4
+    pmaxsw  mm3, mm5 ; median
+    paddw   mm3, mm2 ; +residual
+    pand    mm3, mm6
+%if i==0
+    movq    mm7, mm3
+    psllq   mm7, 48
+%else
+    movq    mm4, mm3
+    psrlq   mm7, 16
+    psllq   mm4, 48
+    por     mm7, mm4
+%endif
+%if i<3
+    psrlq   mm0, 16
+    psrlq   mm1, 16
+    psrlq   mm2, 16
+%endif
+%assign i i+1
+%endrep
+    movq [dstq+wq], mm7
+    add      wq, 8
+    jl .loop
+    movzx   r2d, word [dstq-2]
+    mov [leftq], r2d
+    movzx   r2d, word [topq-2]
+    mov [left_topq], r2d
+    RET
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/huffyuvdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/huffyuvdsp_init.c
index 3ced3c0a1cc..26cf6214d8f 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/huffyuvdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/huffyuvdsp_init.c
@@ -21,97 +21,35 @@
 #include "config.h"
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
+#include "libavutil/pixdesc.h"
 #include "libavutil/x86/asm.h"
 #include "libavutil/x86/cpu.h"
 #include "libavcodec/huffyuvdsp.h"
 
-void ff_add_bytes_mmx(uint8_t *dst, uint8_t *src, intptr_t w);
-void ff_add_bytes_sse2(uint8_t *dst, uint8_t *src, intptr_t w);
-
-void ff_add_hfyu_median_pred_mmxext(uint8_t *dst, const uint8_t *top,
-                                    const uint8_t *diff, intptr_t w,
-                                    int *left, int *left_top);
-void ff_add_hfyu_median_pred_sse2(uint8_t *dst, const uint8_t *top,
-                                  const uint8_t *diff, intptr_t w,
-                                  int *left, int *left_top);
-
-int  ff_add_hfyu_left_pred_ssse3(uint8_t *dst, const uint8_t *src,
-                                 intptr_t w, int left);
-int  ff_add_hfyu_left_pred_sse4(uint8_t *dst, const uint8_t *src,
-                                intptr_t w, int left);
-
+void ff_add_int16_mmx(uint16_t *dst, const uint16_t *src, unsigned mask, int w);
+void ff_add_int16_sse2(uint16_t *dst, const uint16_t *src, unsigned mask, int w);
 void ff_add_hfyu_left_pred_bgr32_mmx(uint8_t *dst, const uint8_t *src,
                                      intptr_t w, uint8_t *left);
 void ff_add_hfyu_left_pred_bgr32_sse2(uint8_t *dst, const uint8_t *src,
                                       intptr_t w, uint8_t *left);
+void ff_add_hfyu_median_pred_int16_mmxext(uint16_t *dst, const uint16_t *top, const uint16_t *diff, unsigned mask, int w, int *left, int *left_top);
 
-#if HAVE_INLINE_ASM && HAVE_7REGS && ARCH_X86_32
-static void add_hfyu_median_pred_cmov(uint8_t *dst, const uint8_t *top,
-                                      const uint8_t *diff, intptr_t w,
-                                      int *left, int *left_top)
-{
-    x86_reg w2 = -w;
-    x86_reg x;
-    int l  = *left     & 0xff;
-    int tl = *left_top & 0xff;
-    int t;
-    __asm__ volatile (
-        "mov          %7, %3            \n"
-        "1:                             \n"
-        "movzbl (%3, %4), %2            \n"
-        "mov          %2, %k3           \n"
-        "sub         %b1, %b3           \n"
-        "add         %b0, %b3           \n"
-        "mov          %2, %1            \n"
-        "cmp          %0, %2            \n"
-        "cmovg        %0, %2            \n"
-        "cmovg        %1, %0            \n"
-        "cmp         %k3, %0            \n"
-        "cmovg       %k3, %0            \n"
-        "mov          %7, %3            \n"
-        "cmp          %2, %0            \n"
-        "cmovl        %2, %0            \n"
-        "add    (%6, %4), %b0           \n"
-        "mov         %b0, (%5, %4)      \n"
-        "inc          %4                \n"
-        "jl           1b                \n"
-        : "+&q"(l), "+&q"(tl), "=&r"(t), "=&q"(x), "+&r"(w2)
-        : "r"(dst + w), "r"(diff + w), "rm"(top + w)
-    );
-    *left     = l;
-    *left_top = tl;
-}
-#endif
-
-av_cold void ff_huffyuvdsp_init_x86(HuffYUVDSPContext *c)
+av_cold void ff_huffyuvdsp_init_x86(HuffYUVDSPContext *c, enum AVPixelFormat pix_fmt)
 {
     int cpu_flags = av_get_cpu_flags();
-
-#if HAVE_INLINE_ASM && HAVE_7REGS && ARCH_X86_32
-    if (cpu_flags & AV_CPU_FLAG_CMOV)
-        c->add_hfyu_median_pred = add_hfyu_median_pred_cmov;
-#endif
+    const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(pix_fmt);
 
     if (ARCH_X86_32 && EXTERNAL_MMX(cpu_flags)) {
-        c->add_bytes = ff_add_bytes_mmx;
         c->add_hfyu_left_pred_bgr32 = ff_add_hfyu_left_pred_bgr32_mmx;
+        c->add_int16 = ff_add_int16_mmx;
     }
 
-    if (ARCH_X86_32 && EXTERNAL_MMXEXT(cpu_flags)) {
-        /* slower than cmov version on AMD */
-        if (!(cpu_flags & AV_CPU_FLAG_3DNOW))
-            c->add_hfyu_median_pred = ff_add_hfyu_median_pred_mmxext;
+    if (EXTERNAL_MMXEXT(cpu_flags) && pix_desc && pix_desc->comp[0].depth<16) {
+        c->add_hfyu_median_pred_int16 = ff_add_hfyu_median_pred_int16_mmxext;
     }
 
     if (EXTERNAL_SSE2(cpu_flags)) {
-        c->add_bytes            = ff_add_bytes_sse2;
-        c->add_hfyu_median_pred = ff_add_hfyu_median_pred_sse2;
+        c->add_int16 = ff_add_int16_sse2;
         c->add_hfyu_left_pred_bgr32 = ff_add_hfyu_left_pred_bgr32_sse2;
     }
-
-    if (EXTERNAL_SSSE3(cpu_flags)) {
-        c->add_hfyu_left_pred = ff_add_hfyu_left_pred_ssse3;
-        if (cpu_flags & AV_CPU_FLAG_SSE4) // not really SSE4, just slow on Conroe
-            c->add_hfyu_left_pred = ff_add_hfyu_left_pred_sse4;
-    }
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/huffyuvencdsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/huffyuvencdsp.asm
index a55a1de65de..eeef81ab8e5 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/huffyuvencdsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/huffyuvencdsp.asm
@@ -25,126 +25,119 @@
 
 %include "libavutil/x86/x86util.asm"
 
-section .text
+SECTION .text
 
-; void ff_diff_bytes(uint8_t *dst, const uint8_t *src1, const uint8_t *src2,
-;                    intptr_t w);
-%macro DIFF_BYTES_PROLOGUE 0
-%if ARCH_X86_32
-cglobal diff_bytes, 3,5,2, dst, src1, src2
-%define wq r4q
-    DECLARE_REG_TMP 3
-    mov               wq, r3mp
+; void ff_diff_int16(uint8_t *dst, const uint8_t *src1, const uint8_t *src2,
+;                    unsigned mask, int w);
+%macro INT16_LOOP 2 ; %1 = a/u (aligned/unaligned), %2 = add/sub
+    movd    m4, maskd
+    SPLATW  m4, m4
+    add     wd, wd
+    test    wq, 2*mmsize - 1
+    jz %%.tomainloop
+    push  tmpq
+%%.wordloop:
+    sub     wq, 2
+%ifidn %2, add
+    mov   tmpw, [srcq+wq]
+    add   tmpw, [dstq+wq]
 %else
-cglobal diff_bytes, 4,5,2, dst, src1, src2, w
-    DECLARE_REG_TMP 4
-%endif ; ARCH_X86_32
-%define i t0q
-%endmacro
-
-; label to jump to if w < regsize
-%macro DIFF_BYTES_LOOP_PREP 1
-    mov                i, wq
-    and                i, -2 * regsize
-        jz            %1
-    add             dstq, i
-    add            src1q, i
-    add            src2q, i
-    neg                i
-%endmacro
-
-; mov type used for src1q, dstq, first reg, second reg
-%macro DIFF_BYTES_LOOP_CORE 4
-%if mmsize != 16
-    mov%1             %3, [src1q + i]
-    mov%1             %4, [src1q + i + regsize]
-    psubb             %3, [src2q + i]
-    psubb             %4, [src2q + i + regsize]
-    mov%2           [dstq + i], %3
-    mov%2 [regsize + dstq + i], %4
+    mov   tmpw, [src1q+wq]
+    sub   tmpw, [src2q+wq]
+%endif
+    and   tmpw, maskw
+    mov     [dstq+wq], tmpw
+    test    wq, 2*mmsize - 1
+    jnz %%.wordloop
+    pop   tmpq
+%%.tomainloop:
+%ifidn %2, add
+    add     srcq, wq
 %else
-    ; SSE enforces alignment of psubb operand
-    mov%1             %3, [src1q + i]
-    movu              %4, [src2q + i]
-    psubb             %3, %4
-    mov%2     [dstq + i], %3
-    mov%1             %3, [src1q + i + regsize]
-    movu              %4, [src2q + i + regsize]
-    psubb             %3, %4
-    mov%2 [regsize + dstq + i], %3
+    add     src1q, wq
+    add     src2q, wq
 %endif
-%endmacro
-
-%macro DIFF_BYTES_BODY 2 ; mov type used for src1q, for dstq
-    %define regsize mmsize
-.loop_%1%2:
-    DIFF_BYTES_LOOP_CORE %1, %2, m0, m1
-    add                i, 2 * regsize
-        jl    .loop_%1%2
-.skip_main_%1%2:
-    and               wq, 2 * regsize - 1
-        jz     .end_%1%2
-%if mmsize > 16
-    ; fall back to narrower xmm
-    %define regsize mmsize / 2
-    DIFF_BYTES_LOOP_PREP .setup_loop_gpr_aa
-.loop2_%1%2:
-    DIFF_BYTES_LOOP_CORE %1, %2, xm0, xm1
-    add                i, 2 * regsize
-        jl   .loop2_%1%2
-.setup_loop_gpr_%1%2:
-    and               wq, 2 * regsize - 1
-        jz     .end_%1%2
+    add     dstq, wq
+    neg     wq
+    jz      %%.end
+%%.loop:
+%ifidn %2, add
+    mov%1   m0, [srcq+wq]
+    mov%1   m1, [dstq+wq]
+    mov%1   m2, [srcq+wq+mmsize]
+    mov%1   m3, [dstq+wq+mmsize]
+%else
+    mov%1   m0, [src1q+wq]
+    mov%1   m1, [src2q+wq]
+    mov%1   m2, [src1q+wq+mmsize]
+    mov%1   m3, [src2q+wq+mmsize]
 %endif
-    add             dstq, wq
-    add            src1q, wq
-    add            src2q, wq
-    neg               wq
-.loop_gpr_%1%2:
-    mov              t0b, [src1q + wq]
-    sub              t0b, [src2q + wq]
-    mov      [dstq + wq], t0b
-    inc               wq
-        jl .loop_gpr_%1%2
-.end_%1%2:
-    REP_RET
+    p%2w    m0, m1
+    p%2w    m2, m3
+    pand    m0, m4
+    pand    m2, m4
+    mov%1   [dstq+wq]       , m0
+    mov%1   [dstq+wq+mmsize], m2
+    add     wq, 2*mmsize
+    jl %%.loop
+%%.end:
+    RET
 %endmacro
 
 %if ARCH_X86_32
 INIT_MMX mmx
-DIFF_BYTES_PROLOGUE
-    %define regsize mmsize
-    DIFF_BYTES_LOOP_PREP .skip_main_aa
-    DIFF_BYTES_BODY    a, a
-%undef i
+cglobal diff_int16, 5,5,5, dst, src1, src2, mask, w, tmp
+    INT16_LOOP a, sub
 %endif
 
 INIT_XMM sse2
-DIFF_BYTES_PROLOGUE
-    %define regsize mmsize
-    DIFF_BYTES_LOOP_PREP .skip_main_aa
-    test            dstq, regsize - 1
-        jnz     .loop_uu
-    test           src1q, regsize - 1
-        jnz     .loop_ua
-    DIFF_BYTES_BODY    a, a
-    DIFF_BYTES_BODY    u, a
-    DIFF_BYTES_BODY    u, u
-%undef i
+cglobal diff_int16, 5,5,5, dst, src1, src2, mask, w, tmp
+    test src1q, mmsize-1
+    jnz .unaligned
+    test src2q, mmsize-1
+    jnz .unaligned
+    test dstq, mmsize-1
+    jnz .unaligned
+    INT16_LOOP a, sub
+.unaligned:
+    INT16_LOOP u, sub
 
-%if HAVE_AVX2_EXTERNAL
-INIT_YMM avx2
-DIFF_BYTES_PROLOGUE
-    %define regsize mmsize
-    ; Directly using unaligned SSE2 version is marginally faster than
-    ; branching based on arguments.
-    DIFF_BYTES_LOOP_PREP .skip_main_uu
-    test            dstq, regsize - 1
-        jnz     .loop_uu
-    test           src1q, regsize - 1
-        jnz     .loop_ua
-    DIFF_BYTES_BODY    a, a
-    DIFF_BYTES_BODY    u, a
-    DIFF_BYTES_BODY    u, u
-%undef i
-%endif
+INIT_MMX mmxext
+cglobal sub_hfyu_median_pred_int16, 7,7,0, dst, src1, src2, mask, w, left, left_top
+    add      wd, wd
+    movd    mm7, maskd
+    SPLATW  mm7, mm7
+    movq    mm0, [src1q]
+    movq    mm2, [src2q]
+    psllq   mm0, 16
+    psllq   mm2, 16
+    movd    mm6, [left_topq]
+    por     mm0, mm6
+    movd    mm6, [leftq]
+    por     mm2, mm6
+    xor     maskq, maskq
+.loop:
+    movq    mm1, [src1q + maskq]
+    movq    mm3, [src2q + maskq]
+    movq    mm4, mm2
+    psubw   mm2, mm0
+    paddw   mm2, mm1
+    pand    mm2, mm7
+    movq    mm5, mm4
+    pmaxsw  mm4, mm1
+    pminsw  mm1, mm5
+    pminsw  mm4, mm2
+    pmaxsw  mm4, mm1
+    psubw   mm3, mm4
+    pand    mm3, mm7
+    movq    [dstq + maskq], mm3
+    add     maskq, 8
+    movq    mm0, [src1q + maskq - 2]
+    movq    mm2, [src2q + maskq - 2]
+    cmp     maskq, wq
+        jb .loop
+    movzx maskd, word [src1q + wq - 2]
+    mov [left_topq], maskd
+    movzx maskd, word [src2q + wq - 2]
+    mov [leftq], maskd
+    RET
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/huffyuvencdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/huffyuvencdsp_init.c
new file mode 100644
index 00000000000..f66bc8c4f0a
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/huffyuvencdsp_init.c
@@ -0,0 +1,54 @@
+/*
+ * SIMD-optimized HuffYUV encoding functions
+ * Copyright (c) 2000, 2001 Fabrice Bellard
+ * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
+ *
+ * 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 "libavutil/cpu.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/x86/cpu.h"
+#include "libavcodec/huffyuvencdsp.h"
+
+void ff_diff_int16_mmx (uint16_t *dst, const uint16_t *src1, const uint16_t *src2,
+                        unsigned mask, int w);
+void ff_diff_int16_sse2(uint16_t *dst, const uint16_t *src1, const uint16_t *src2,
+                        unsigned mask, int w);
+void ff_sub_hfyu_median_pred_int16_mmxext(uint16_t *dst, const uint16_t *src1, const uint16_t *src2,
+                                          unsigned mask, int w, int *left, int *left_top);
+
+av_cold void ff_huffyuvencdsp_init_x86(HuffYUVEncDSPContext *c, AVCodecContext *avctx)
+{
+    av_unused int cpu_flags = av_get_cpu_flags();
+    const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(avctx->pix_fmt);
+
+    if (ARCH_X86_32 && EXTERNAL_MMX(cpu_flags)) {
+        c->diff_int16 = ff_diff_int16_mmx;
+    }
+
+    if (EXTERNAL_MMXEXT(cpu_flags) && pix_desc && pix_desc->comp[0].depth<16) {
+        c->sub_hfyu_median_pred_int16 = ff_sub_hfyu_median_pred_int16_mmxext;
+    }
+
+    if (EXTERNAL_SSE2(cpu_flags)) {
+        c->diff_int16 = ff_diff_int16_sse2;
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/idctdsp.h b/mythtv/external/FFmpeg/libavcodec/x86/idctdsp.h
index daa4e798ede..0d0bdb5f578 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/idctdsp.h
+++ b/mythtv/external/FFmpeg/libavcodec/x86/idctdsp.h
@@ -19,8 +19,8 @@
 #ifndef AVCODEC_X86_IDCTDSP_H
 #define AVCODEC_X86_IDCTDSP_H
 
-#include <stdint.h>
 #include <stddef.h>
+#include <stdint.h>
 
 void ff_add_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
                                ptrdiff_t line_size);
@@ -35,4 +35,5 @@ void ff_put_signed_pixels_clamped_mmx(const int16_t *block, uint8_t *pixels,
 void ff_put_signed_pixels_clamped_sse2(const int16_t *block, uint8_t *pixels,
                                        ptrdiff_t line_size);
 
+
 #endif /* AVCODEC_X86_IDCTDSP_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/idctdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/idctdsp_init.c
index bcf7e5be0e2..162560d4114 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/idctdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/idctdsp_init.c
@@ -63,47 +63,82 @@ av_cold void ff_idctdsp_init_x86(IDCTDSPContext *c, AVCodecContext *avctx,
 {
     int cpu_flags = av_get_cpu_flags();
 
-    if (INLINE_MMX(cpu_flags)) {
+    if (EXTERNAL_MMX(cpu_flags)) {
+        c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_mmx;
+        c->put_pixels_clamped        = ff_put_pixels_clamped_mmx;
+        c->add_pixels_clamped        = ff_add_pixels_clamped_mmx;
+
         if (!high_bit_depth &&
             avctx->lowres == 0 &&
             (avctx->idct_algo == FF_IDCT_AUTO ||
-             avctx->idct_algo == FF_IDCT_SIMPLEAUTO ||
-             avctx->idct_algo == FF_IDCT_SIMPLEMMX)) {
+                avctx->idct_algo == FF_IDCT_SIMPLEAUTO ||
+                avctx->idct_algo == FF_IDCT_SIMPLEMMX)) {
                 c->idct_put  = ff_simple_idct_put_mmx;
                 c->idct_add  = ff_simple_idct_add_mmx;
                 c->idct      = ff_simple_idct_mmx;
                 c->perm_type = FF_IDCT_PERM_SIMPLE;
         }
     }
-    if (EXTERNAL_MMX(cpu_flags)) {
-        c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_mmx;
-        c->put_pixels_clamped        = ff_put_pixels_clamped_mmx;
-        c->add_pixels_clamped        = ff_add_pixels_clamped_mmx;
-    }
+
     if (EXTERNAL_SSE2(cpu_flags)) {
         c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_sse2;
         c->put_pixels_clamped        = ff_put_pixels_clamped_sse2;
         c->add_pixels_clamped        = ff_add_pixels_clamped_sse2;
+
+        if (!high_bit_depth &&
+            avctx->lowres == 0 &&
+            (avctx->idct_algo == FF_IDCT_AUTO ||
+                avctx->idct_algo == FF_IDCT_SIMPLEAUTO ||
+                avctx->idct_algo == FF_IDCT_SIMPLEMMX)) {
+                c->idct_put  = ff_simple_idct_put_sse2;
+                c->idct_add  = ff_simple_idct_add_sse2;
+                c->perm_type = FF_IDCT_PERM_SIMPLE;
+        }
+
+        if (ARCH_X86_64 &&
+            !high_bit_depth &&
+            avctx->lowres == 0 &&
+            (avctx->idct_algo == FF_IDCT_AUTO ||
+                avctx->idct_algo == FF_IDCT_SIMPLEAUTO ||
+                avctx->idct_algo == FF_IDCT_SIMPLEMMX ||
+                avctx->idct_algo == FF_IDCT_SIMPLE)) {
+                c->idct      = ff_simple_idct8_sse2;
+                c->idct_put  = ff_simple_idct8_put_sse2;
+                c->idct_add  = ff_simple_idct8_add_sse2;
+                c->perm_type = FF_IDCT_PERM_TRANSPOSE;
+        }
     }
 
     if (ARCH_X86_64 && avctx->lowres == 0) {
+        if (EXTERNAL_AVX(cpu_flags) &&
+            !high_bit_depth &&
+            (avctx->idct_algo == FF_IDCT_AUTO ||
+                avctx->idct_algo == FF_IDCT_SIMPLEAUTO ||
+                avctx->idct_algo == FF_IDCT_SIMPLEMMX ||
+                avctx->idct_algo == FF_IDCT_SIMPLE)) {
+                c->idct      = ff_simple_idct8_avx;
+                c->idct_put  = ff_simple_idct8_put_avx;
+                c->idct_add  = ff_simple_idct8_add_avx;
+                c->perm_type = FF_IDCT_PERM_TRANSPOSE;
+        }
+
         if (avctx->bits_per_raw_sample == 10 &&
-        (avctx->idct_algo == FF_IDCT_AUTO ||
-         avctx->idct_algo == FF_IDCT_SIMPLEAUTO ||
-         avctx->idct_algo == FF_IDCT_SIMPLE)) {
-        if (EXTERNAL_SSE2(cpu_flags)) {
-            c->idct_put  = ff_simple_idct10_put_sse2;
-            c->idct_add  = NULL;
-            c->idct      = ff_simple_idct10_sse2;
-            c->perm_type = FF_IDCT_PERM_TRANSPOSE;
+            (avctx->idct_algo == FF_IDCT_AUTO ||
+             avctx->idct_algo == FF_IDCT_SIMPLEAUTO ||
+             avctx->idct_algo == FF_IDCT_SIMPLE)) {
+            if (EXTERNAL_SSE2(cpu_flags)) {
+                c->idct_put  = ff_simple_idct10_put_sse2;
+                c->idct_add  = NULL;
+                c->idct      = ff_simple_idct10_sse2;
+                c->perm_type = FF_IDCT_PERM_TRANSPOSE;
 
-        }
-        if (EXTERNAL_AVX(cpu_flags)) {
-            c->idct_put  = ff_simple_idct10_put_avx;
-            c->idct_add  = NULL;
-            c->idct      = ff_simple_idct10_avx;
-            c->perm_type = FF_IDCT_PERM_TRANSPOSE;
-        }
+            }
+            if (EXTERNAL_AVX(cpu_flags)) {
+                c->idct_put  = ff_simple_idct10_put_avx;
+                c->idct_add  = NULL;
+                c->idct      = ff_simple_idct10_avx;
+                c->perm_type = FF_IDCT_PERM_TRANSPOSE;
+            }
         }
 
         if (avctx->bits_per_raw_sample == 12 &&
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/imdct36.asm b/mythtv/external/FFmpeg/libavcodec/x86/imdct36.asm
index 409b2c5796f..960eabdda5e 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/imdct36.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/imdct36.asm
@@ -145,9 +145,9 @@ SECTION .text
 %macro STORE 4
 %if cpuflag(sse4)
     movss     [%3       ], %1
-    extractps [%3 +   %4], %1, 1
-    extractps [%3 + 2*%4], %1, 2
-    extractps [%3 + 3*%4], %1, 3
+    extractps dword [%3 +   %4], %1, 1
+    extractps dword [%3 + 2*%4], %1, 2
+    extractps dword [%3 + 3*%4], %1, 3
 %else
     movhlps %2, %1
     movss   [%3       ], %1
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/lossless_audiodsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/lossless_audiodsp_init.c
index 10b6a656226..f74c7e4361d 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/lossless_audiodsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/lossless_audiodsp_init.c
@@ -37,7 +37,7 @@ int32_t ff_scalarproduct_and_madd_int32_sse4(int16_t *v1, const int32_t *v2,
 
 av_cold void ff_llauddsp_init_x86(LLAudDSPContext *c)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_MMXEXT(cpu_flags))
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/lossless_videodsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/lossless_videodsp.asm
index f06fcdf7cfb..443fe02951d 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/lossless_videodsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/lossless_videodsp.asm
@@ -24,98 +24,198 @@
 
 SECTION_RODATA
 
+cextern pb_15
+pb_zzzzzzzz77777777: times 8 db -1
+pb_7: times 8 db 7
 pb_ef: times 8 db 14,15
 pb_67: times 8 db  6, 7
+pb_zzzz3333zzzzbbbb: db -1,-1,-1,-1,3,3,3,3,-1,-1,-1,-1,11,11,11,11
+pb_zz11zz55zz99zzdd: db -1,-1,1,1,-1,-1,5,5,-1,-1,9,9,-1,-1,13,13
 pb_zzzz2323zzzzabab: db -1,-1,-1,-1, 2, 3, 2, 3,-1,-1,-1,-1,10,11,10,11
 pb_zzzzzzzz67676767: db -1,-1,-1,-1,-1,-1,-1,-1, 6, 7, 6, 7, 6, 7, 6, 7
 
 SECTION .text
 
-%macro INT16_LOOP 2 ; %1 = a/u (aligned/unaligned), %2 = add/sub
-    movd    m4, maskd
-    SPLATW  m4, m4
-    add     wd, wd
-    test    wq, 2*mmsize - 1
-    jz %%.tomainloop
-    push  tmpq
-%%.wordloop:
-    sub     wq, 2
-%ifidn %2, add
-    mov   tmpw, [srcq+wq]
-    add   tmpw, [dstq+wq]
+; void ff_add_median_pred_mmxext(uint8_t *dst, const uint8_t *top,
+;                                const uint8_t *diff, int w,
+;                                int *left, int *left_top)
+%macro MEDIAN_PRED 0
+cglobal add_median_pred, 6,6,8, dst, top, diff, w, left, left_top
+    movu    m0, [topq]
+    mova    m2, m0
+    movd    m4, [left_topq]
+    LSHIFT  m2, 1
+    mova    m1, m0
+    por     m4, m2
+    movd    m3, [leftq]
+    psubb   m0, m4 ; t-tl
+    add    dstq, wq
+    add    topq, wq
+    add   diffq, wq
+    neg      wq
+    jmp .skip
+.loop:
+    movu    m4, [topq+wq]
+    mova    m0, m4
+    LSHIFT  m4, 1
+    por     m4, m1
+    mova    m1, m0 ; t
+    psubb   m0, m4 ; t-tl
+.skip:
+    movu    m2, [diffq+wq]
+%assign i 0
+%rep mmsize
+    mova    m4, m0
+    paddb   m4, m3 ; t-tl+l
+    mova    m5, m3
+    pmaxub  m3, m1
+    pminub  m5, m1
+    pminub  m3, m4
+    pmaxub  m3, m5 ; median
+    paddb   m3, m2 ; +residual
+%if i==0
+    mova    m7, m3
+    LSHIFT  m7, mmsize-1
 %else
-    mov   tmpw, [src1q+wq]
-    sub   tmpw, [src2q+wq]
+    mova    m6, m3
+    RSHIFT  m7, 1
+    LSHIFT  m6, mmsize-1
+    por     m7, m6
 %endif
-    and   tmpw, maskw
-    mov     [dstq+wq], tmpw
-    test    wq, 2*mmsize - 1
-    jnz %%.wordloop
-    pop   tmpq
-%%.tomainloop:
-%ifidn %2, add
-    add     srcq, wq
-%else
-    add     src1q, wq
-    add     src2q, wq
+%if i<mmsize-1
+    RSHIFT  m0, 1
+    RSHIFT  m1, 1
+    RSHIFT  m2, 1
+%endif
+%assign i i+1
+%endrep
+    movu [dstq+wq], m7
+    add      wq, mmsize
+    jl .loop
+    movzx   r2d, byte [dstq-1]
+    mov [leftq], r2d
+    movzx   r2d, byte [topq-1]
+    mov [left_topq], r2d
+    RET
+%endmacro
+
+%if ARCH_X86_32
+INIT_MMX mmxext
+MEDIAN_PRED
 %endif
+INIT_XMM sse2
+MEDIAN_PRED
+
+
+%macro ADD_LEFT_LOOP 2 ; %1 = dst_is_aligned, %2 = src_is_aligned
+    add     srcq, wq
     add     dstq, wq
     neg     wq
-    jz      %%.end
 %%.loop:
-%ifidn %2, add
-    mov%1   m0, [srcq+wq]
-    mov%1   m1, [dstq+wq]
-    mov%1   m2, [srcq+wq+mmsize]
-    mov%1   m3, [dstq+wq+mmsize]
+%if %2
+    mova    m1, [srcq+wq]
+%else
+    movu    m1, [srcq+wq]
+%endif
+    mova    m2, m1
+    psllw   m1, 8
+    paddb   m1, m2
+    mova    m2, m1
+    pshufb  m1, m3
+    paddb   m1, m2
+    pshufb  m0, m5
+    mova    m2, m1
+    pshufb  m1, m4
+    paddb   m1, m2
+%if mmsize == 16
+    mova    m2, m1
+    pshufb  m1, m6
+    paddb   m1, m2
+%endif
+    paddb   m0, m1
+%if %1
+    mova    [dstq+wq], m0
 %else
-    mov%1   m0, [src1q+wq]
-    mov%1   m1, [src2q+wq]
-    mov%1   m2, [src1q+wq+mmsize]
-    mov%1   m3, [src2q+wq+mmsize]
+    movq    [dstq+wq], m0
+    movhps  [dstq+wq+8], m0
 %endif
-    p%2w    m0, m1
-    p%2w    m2, m3
-    pand    m0, m4
-    pand    m2, m4
-    mov%1   [dstq+wq]       , m0
-    mov%1   [dstq+wq+mmsize], m2
-    add     wq, 2*mmsize
+    add     wq, mmsize
     jl %%.loop
-%%.end:
+    mov     eax, mmsize-1
+    sub     eax, wd
+    movd    m1, eax
+    pshufb  m0, m1
+    movd    eax, m0
     RET
 %endmacro
 
-INIT_MMX mmx
-cglobal add_int16, 4,4,5, dst, src, mask, w, tmp
-    INT16_LOOP a, add
+; int ff_add_left_pred(uint8_t *dst, const uint8_t *src, int w, int left)
+INIT_MMX ssse3
+cglobal add_left_pred, 3,3,7, dst, src, w, left
+.skip_prologue:
+    mova    m5, [pb_7]
+    mova    m4, [pb_zzzz3333zzzzbbbb]
+    mova    m3, [pb_zz11zz55zz99zzdd]
+    movd    m0, leftm
+    psllq   m0, 56
+    ADD_LEFT_LOOP 1, 1
 
-INIT_XMM sse2
-cglobal add_int16, 4,4,5, dst, src, mask, w, tmp
-    test srcq, mmsize-1
-    jnz .unaligned
-    test dstq, mmsize-1
-    jnz .unaligned
-    INT16_LOOP a, add
-.unaligned:
-    INT16_LOOP u, add
+INIT_XMM ssse3
+cglobal add_left_pred_unaligned, 3,3,7, dst, src, w, left
+    mova    m5, [pb_15]
+    mova    m6, [pb_zzzzzzzz77777777]
+    mova    m4, [pb_zzzz3333zzzzbbbb]
+    mova    m3, [pb_zz11zz55zz99zzdd]
+    movd    m0, leftm
+    pslldq  m0, 15
+    test    srcq, 15
+    jnz .src_unaligned
+    test    dstq, 15
+    jnz .dst_unaligned
+    ADD_LEFT_LOOP 1, 1
+.dst_unaligned:
+    ADD_LEFT_LOOP 0, 1
+.src_unaligned:
+    ADD_LEFT_LOOP 0, 0
 
-INIT_MMX mmx
-cglobal diff_int16, 5,5,5, dst, src1, src2, mask, w, tmp
-    INT16_LOOP a, sub
+%macro ADD_BYTES 0
+cglobal add_bytes, 3,4,2, dst, src, w, size
+    mov  sizeq, wq
+    and  sizeq, -2*mmsize
+    jz  .2
+    add   dstq, sizeq
+    add   srcq, sizeq
+    neg  sizeq
+.1:
+    mova    m0, [srcq + sizeq]
+    mova    m1, [srcq + sizeq + mmsize]
+    paddb   m0, [dstq + sizeq]
+    paddb   m1, [dstq + sizeq + mmsize]
+    mova   [dstq + sizeq], m0
+    mova   [dstq + sizeq + mmsize], m1
+    add  sizeq, 2*mmsize
+    jl .1
+.2:
+    and     wq, 2*mmsize-1
+    jz    .end
+    add   dstq, wq
+    add   srcq, wq
+    neg     wq
+.3:
+    mov  sizeb, [srcq + wq]
+    add [dstq + wq], sizeb
+    inc     wq
+    jl .3
+.end:
+    REP_RET
+%endmacro
 
+%if ARCH_X86_32
+INIT_MMX mmx
+ADD_BYTES
+%endif
 INIT_XMM sse2
-cglobal diff_int16, 5,5,5, dst, src1, src2, mask, w, tmp
-    test src1q, mmsize-1
-    jnz .unaligned
-    test src2q, mmsize-1
-    jnz .unaligned
-    test dstq, mmsize-1
-    jnz .unaligned
-    INT16_LOOP a, sub
-.unaligned:
-    INT16_LOOP u, sub
-
+ADD_BYTES
 
 %macro ADD_HFYU_LEFT_LOOP_INT16 2 ; %1 = dst alignment (a/u), %2 = src alignment (a/u)
     add     wd, wd
@@ -158,9 +258,9 @@ cglobal diff_int16, 5,5,5, dst, src1, src2, mask, w, tmp
     RET
 %endmacro
 
-; int add_hfyu_left_pred_int16(uint16_t *dst, const uint16_t *src, unsigned mask, int w, int left)
+; int add_left_pred_int16(uint16_t *dst, const uint16_t *src, unsigned mask, int w, int left)
 INIT_MMX ssse3
-cglobal add_hfyu_left_pred_int16, 4,4,8, dst, src, mask, w, left
+cglobal add_left_pred_int16, 4,4,8, dst, src, mask, w, left
 .skip_prologue:
     mova    m5, [pb_67]
     mova    m3, [pb_zzzz2323zzzzabab]
@@ -171,7 +271,7 @@ cglobal add_hfyu_left_pred_int16, 4,4,8, dst, src, mask, w, left
     ADD_HFYU_LEFT_LOOP_INT16 a, a
 
 INIT_XMM sse4
-cglobal add_hfyu_left_pred_int16, 4,4,8, dst, src, mask, w, left
+cglobal add_left_pred_int16, 4,4,8, dst, src, mask, w, left
     mova    m5, [pb_ef]
     mova    m4, [pb_zzzzzzzz67676767]
     mova    m3, [pb_zzzz2323zzzzabab]
@@ -188,107 +288,3 @@ cglobal add_hfyu_left_pred_int16, 4,4,8, dst, src, mask, w, left
     ADD_HFYU_LEFT_LOOP_INT16 u, a
 .src_unaligned:
     ADD_HFYU_LEFT_LOOP_INT16 u, u
-
-; void add_hfyu_median_prediction_mmxext(uint8_t *dst, const uint8_t *top, const uint8_t *diff, int mask, int w, int *left, int *left_top)
-INIT_MMX mmxext
-cglobal add_hfyu_median_pred_int16, 7,7,0, dst, top, diff, mask, w, left, left_top
-    add      wd, wd
-    movd    mm6, maskd
-    SPLATW  mm6, mm6
-    movq    mm0, [topq]
-    movq    mm2, mm0
-    movd    mm4, [left_topq]
-    psllq   mm2, 16
-    movq    mm1, mm0
-    por     mm4, mm2
-    movd    mm3, [leftq]
-    psubw   mm0, mm4 ; t-tl
-    add    dstq, wq
-    add    topq, wq
-    add   diffq, wq
-    neg      wq
-    jmp .skip
-.loop:
-    movq    mm4, [topq+wq]
-    movq    mm0, mm4
-    psllq   mm4, 16
-    por     mm4, mm1
-    movq    mm1, mm0 ; t
-    psubw   mm0, mm4 ; t-tl
-.skip:
-    movq    mm2, [diffq+wq]
-%assign i 0
-%rep 4
-    movq    mm4, mm0
-    paddw   mm4, mm3 ; t-tl+l
-    pand    mm4, mm6
-    movq    mm5, mm3
-    pmaxsw  mm3, mm1
-    pminsw  mm5, mm1
-    pminsw  mm3, mm4
-    pmaxsw  mm3, mm5 ; median
-    paddw   mm3, mm2 ; +residual
-    pand    mm3, mm6
-%if i==0
-    movq    mm7, mm3
-    psllq   mm7, 48
-%else
-    movq    mm4, mm3
-    psrlq   mm7, 16
-    psllq   mm4, 48
-    por     mm7, mm4
-%endif
-%if i<3
-    psrlq   mm0, 16
-    psrlq   mm1, 16
-    psrlq   mm2, 16
-%endif
-%assign i i+1
-%endrep
-    movq [dstq+wq], mm7
-    add      wq, 8
-    jl .loop
-    movzx   r2d, word [dstq-2]
-    mov [leftq], r2d
-    movzx   r2d, word [topq-2]
-    mov [left_topq], r2d
-    RET
-
-cglobal sub_hfyu_median_pred_int16, 7,7,0, dst, src1, src2, mask, w, left, left_top
-    add      wd, wd
-    movd    mm7, maskd
-    SPLATW  mm7, mm7
-    movq    mm0, [src1q]
-    movq    mm2, [src2q]
-    psllq   mm0, 16
-    psllq   mm2, 16
-    movd    mm6, [left_topq]
-    por     mm0, mm6
-    movd    mm6, [leftq]
-    por     mm2, mm6
-    xor     maskq, maskq
-.loop:
-    movq    mm1, [src1q + maskq]
-    movq    mm3, [src2q + maskq]
-    movq    mm4, mm2
-    psubw   mm2, mm0
-    paddw   mm2, mm1
-    pand    mm2, mm7
-    movq    mm5, mm4
-    pmaxsw  mm4, mm1
-    pminsw  mm1, mm5
-    pminsw  mm4, mm2
-    pmaxsw  mm4, mm1
-    psubw   mm3, mm4
-    pand    mm3, mm7
-    movq    [dstq + maskq], mm3
-    add     maskq, 8
-    movq    mm0, [src1q + maskq - 2]
-    movq    mm2, [src2q + maskq - 2]
-    cmp     maskq, wq
-        jb .loop
-    movzx maskd, word [src1q + wq - 2]
-    mov [left_topq], maskd
-    movzx maskd, word [src2q + wq - 2]
-    mov [leftq], maskd
-    RET
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/lossless_videodsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/lossless_videodsp_init.c
index b0fbcfef8f8..21bbd12bd2d 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/lossless_videodsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/lossless_videodsp_init.c
@@ -18,45 +18,101 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "config.h"
+#include "libavutil/x86/asm.h"
 #include "../lossless_videodsp.h"
-#include "libavutil/pixdesc.h"
 #include "libavutil/x86/cpu.h"
 
-void ff_add_int16_mmx(uint16_t *dst, const uint16_t *src, unsigned mask, int w);
-void ff_add_int16_sse2(uint16_t *dst, const uint16_t *src, unsigned mask, int w);
-void ff_diff_int16_mmx (uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w);
-void ff_diff_int16_sse2(uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w);
-int ff_add_hfyu_left_pred_int16_ssse3(uint16_t *dst, const uint16_t *src, unsigned mask, int w, unsigned acc);
-int ff_add_hfyu_left_pred_int16_sse4(uint16_t *dst, const uint16_t *src, unsigned mask, int w, unsigned acc);
-void ff_add_hfyu_median_pred_int16_mmxext(uint16_t *dst, const uint16_t *top, const uint16_t *diff, unsigned mask, int w, int *left, int *left_top);
-void ff_sub_hfyu_median_pred_int16_mmxext(uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w, int *left, int *left_top);
+void ff_add_bytes_mmx(uint8_t *dst, uint8_t *src, ptrdiff_t w);
+void ff_add_bytes_sse2(uint8_t *dst, uint8_t *src, ptrdiff_t w);
 
+void ff_add_median_pred_mmxext(uint8_t *dst, const uint8_t *top,
+                               const uint8_t *diff, ptrdiff_t w,
+                               int *left, int *left_top);
+void ff_add_median_pred_sse2(uint8_t *dst, const uint8_t *top,
+                             const uint8_t *diff, ptrdiff_t w,
+                             int *left, int *left_top);
 
-void ff_llviddsp_init_x86(LLVidDSPContext *c, AVCodecContext *avctx)
+int  ff_add_left_pred_ssse3(uint8_t *dst, const uint8_t *src,
+                            ptrdiff_t w, int left);
+int  ff_add_left_pred_unaligned_ssse3(uint8_t *dst, const uint8_t *src,
+                                      ptrdiff_t w, int left);
+
+int ff_add_left_pred_int16_ssse3(uint16_t *dst, const uint16_t *src, unsigned mask, ptrdiff_t w, unsigned acc);
+int ff_add_left_pred_int16_sse4(uint16_t *dst, const uint16_t *src, unsigned mask, ptrdiff_t w, unsigned acc);
+
+#if HAVE_INLINE_ASM && HAVE_7REGS && ARCH_X86_32
+static void add_median_pred_cmov(uint8_t *dst, const uint8_t *top,
+                                 const uint8_t *diff, ptrdiff_t w,
+                                 int *left, int *left_top)
+{
+    x86_reg w2 = -w;
+    x86_reg x;
+    int l  = *left     & 0xff;
+    int tl = *left_top & 0xff;
+    int t;
+    __asm__ volatile (
+        "mov          %7, %3            \n"
+        "1:                             \n"
+        "movzbl (%3, %4), %2            \n"
+        "mov          %2, %k3           \n"
+        "sub         %b1, %b3           \n"
+        "add         %b0, %b3           \n"
+        "mov          %2, %1            \n"
+        "cmp          %0, %2            \n"
+        "cmovg        %0, %2            \n"
+        "cmovg        %1, %0            \n"
+        "cmp         %k3, %0            \n"
+        "cmovg       %k3, %0            \n"
+        "mov          %7, %3            \n"
+        "cmp          %2, %0            \n"
+        "cmovl        %2, %0            \n"
+        "add    (%6, %4), %b0           \n"
+        "mov         %b0, (%5, %4)      \n"
+        "inc          %4                \n"
+        "jl           1b                \n"
+        : "+&q"(l), "+&q"(tl), "=&r"(t), "=&q"(x), "+&r"(w2)
+        : "r"(dst + w), "r"(diff + w), "rm"(top + w)
+    );
+    *left     = l;
+    *left_top = tl;
+}
+#endif
+
+void ff_llviddsp_init_x86(LLVidDSPContext *c)
 {
     int cpu_flags = av_get_cpu_flags();
-    const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(avctx->pix_fmt);
 
-    if (EXTERNAL_MMX(cpu_flags)) {
-        c->add_int16 = ff_add_int16_mmx;
-        c->diff_int16 = ff_diff_int16_mmx;
+#if HAVE_INLINE_ASM && HAVE_7REGS && ARCH_X86_32
+    if (cpu_flags & AV_CPU_FLAG_CMOV)
+        c->add_median_pred = add_median_pred_cmov;
+#endif
+
+    if (ARCH_X86_32 && EXTERNAL_MMX(cpu_flags)) {
+        c->add_bytes = ff_add_bytes_mmx;
     }
 
-    if (EXTERNAL_MMXEXT(cpu_flags) && pix_desc->comp[0].depth<16) {
-        c->add_hfyu_median_pred_int16 = ff_add_hfyu_median_pred_int16_mmxext;
-        c->sub_hfyu_median_pred_int16 = ff_sub_hfyu_median_pred_int16_mmxext;
+    if (ARCH_X86_32 && EXTERNAL_MMXEXT(cpu_flags)) {
+        /* slower than cmov version on AMD */
+        if (!(cpu_flags & AV_CPU_FLAG_3DNOW))
+            c->add_median_pred = ff_add_median_pred_mmxext;
     }
 
     if (EXTERNAL_SSE2(cpu_flags)) {
-        c->add_int16 = ff_add_int16_sse2;
-        c->diff_int16 = ff_diff_int16_sse2;
+        c->add_bytes       = ff_add_bytes_sse2;
+        c->add_median_pred = ff_add_median_pred_sse2;
     }
 
     if (EXTERNAL_SSSE3(cpu_flags)) {
-        c->add_hfyu_left_pred_int16 = ff_add_hfyu_left_pred_int16_ssse3;
+        c->add_left_pred = ff_add_left_pred_ssse3;
+        c->add_left_pred_int16 = ff_add_left_pred_int16_ssse3;
+    }
+
+    if (EXTERNAL_SSSE3_FAST(cpu_flags)) {
+        c->add_left_pred = ff_add_left_pred_unaligned_ssse3;
     }
 
     if (EXTERNAL_SSE4(cpu_flags)) {
-        c->add_hfyu_left_pred_int16 = ff_add_hfyu_left_pred_int16_sse4;
+        c->add_left_pred_int16 = ff_add_left_pred_int16_sse4;
     }
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/lossless_videoencdsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/lossless_videoencdsp.asm
new file mode 100644
index 00000000000..4d79eee36ba
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/lossless_videoencdsp.asm
@@ -0,0 +1,151 @@
+;************************************************************************
+;* SIMD-optimized lossless video encoding functions
+;* Copyright (c) 2000, 2001 Fabrice Bellard
+;* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
+;*
+;* MMX optimization by Nick Kurshev <nickols_k@mail.ru>
+;* Conversion to NASM format by Tiancheng "Timothy" Gu <timothygu99@gmail.com>
+;*
+;* 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
+;* 51, Inc., Foundation Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+;******************************************************************************
+
+%include "libavutil/x86/x86util.asm"
+
+SECTION .text
+
+; void ff_diff_bytes(uint8_t *dst, const uint8_t *src1, const uint8_t *src2,
+;                    intptr_t w);
+%macro DIFF_BYTES_PROLOGUE 0
+%if ARCH_X86_32
+cglobal diff_bytes, 3,5,2, dst, src1, src2
+%define wq r4q
+    DECLARE_REG_TMP 3
+    mov               wq, r3mp
+%else
+cglobal diff_bytes, 4,5,2, dst, src1, src2, w
+    DECLARE_REG_TMP 4
+%endif ; ARCH_X86_32
+%define i t0q
+%endmacro
+
+; labels to jump to if w < regsize and w < 0
+%macro DIFF_BYTES_LOOP_PREP 2
+    mov                i, wq
+    and                i, -2 * regsize
+        js            %2
+        jz            %1
+    add             dstq, i
+    add            src1q, i
+    add            src2q, i
+    neg                i
+%endmacro
+
+; mov type used for src1q, dstq, first reg, second reg
+%macro DIFF_BYTES_LOOP_CORE 4
+%if mmsize != 16
+    mov%1             %3, [src1q + i]
+    mov%1             %4, [src1q + i + regsize]
+    psubb             %3, [src2q + i]
+    psubb             %4, [src2q + i + regsize]
+    mov%2           [dstq + i], %3
+    mov%2 [regsize + dstq + i], %4
+%else
+    ; SSE enforces alignment of psubb operand
+    mov%1             %3, [src1q + i]
+    movu              %4, [src2q + i]
+    psubb             %3, %4
+    mov%2     [dstq + i], %3
+    mov%1             %3, [src1q + i + regsize]
+    movu              %4, [src2q + i + regsize]
+    psubb             %3, %4
+    mov%2 [regsize + dstq + i], %3
+%endif
+%endmacro
+
+%macro DIFF_BYTES_BODY 2 ; mov type used for src1q, for dstq
+    %define regsize mmsize
+.loop_%1%2:
+    DIFF_BYTES_LOOP_CORE %1, %2, m0, m1
+    add                i, 2 * regsize
+        jl    .loop_%1%2
+.skip_main_%1%2:
+    and               wq, 2 * regsize - 1
+        jz     .end_%1%2
+%if mmsize > 16
+    ; fall back to narrower xmm
+    %define regsize (mmsize / 2)
+    DIFF_BYTES_LOOP_PREP .setup_loop_gpr_aa, .end_aa
+.loop2_%1%2:
+    DIFF_BYTES_LOOP_CORE %1, %2, xm0, xm1
+    add                i, 2 * regsize
+        jl   .loop2_%1%2
+.setup_loop_gpr_%1%2:
+    and               wq, 2 * regsize - 1
+        jz     .end_%1%2
+%endif
+    add             dstq, wq
+    add            src1q, wq
+    add            src2q, wq
+    neg               wq
+.loop_gpr_%1%2:
+    mov              t0b, [src1q + wq]
+    sub              t0b, [src2q + wq]
+    mov      [dstq + wq], t0b
+    inc               wq
+        jl .loop_gpr_%1%2
+.end_%1%2:
+    REP_RET
+%endmacro
+
+%if ARCH_X86_32
+INIT_MMX mmx
+DIFF_BYTES_PROLOGUE
+    %define regsize mmsize
+    DIFF_BYTES_LOOP_PREP .skip_main_aa, .end_aa
+    DIFF_BYTES_BODY    a, a
+%undef i
+%endif
+
+INIT_XMM sse2
+DIFF_BYTES_PROLOGUE
+    %define regsize mmsize
+    DIFF_BYTES_LOOP_PREP .skip_main_aa, .end_aa
+    test            dstq, regsize - 1
+        jnz     .loop_uu
+    test           src1q, regsize - 1
+        jnz     .loop_ua
+    DIFF_BYTES_BODY    a, a
+    DIFF_BYTES_BODY    u, a
+    DIFF_BYTES_BODY    u, u
+%undef i
+
+%if HAVE_AVX2_EXTERNAL
+INIT_YMM avx2
+DIFF_BYTES_PROLOGUE
+    %define regsize mmsize
+    ; Directly using unaligned SSE2 version is marginally faster than
+    ; branching based on arguments.
+    DIFF_BYTES_LOOP_PREP .skip_main_uu, .end_uu
+    test            dstq, regsize - 1
+        jnz     .loop_uu
+    test           src1q, regsize - 1
+        jnz     .loop_ua
+    DIFF_BYTES_BODY    a, a
+    DIFF_BYTES_BODY    u, a
+    DIFF_BYTES_BODY    u, u
+%undef i
+%endif
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/huffyuvencdsp_mmx.c b/mythtv/external/FFmpeg/libavcodec/x86/lossless_videoencdsp_init.c
similarity index 88%
rename from mythtv/external/FFmpeg/libavcodec/x86/huffyuvencdsp_mmx.c
rename to mythtv/external/FFmpeg/libavcodec/x86/lossless_videoencdsp_init.c
index 9767b212da4..fc728c9fd1e 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/huffyuvencdsp_mmx.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/lossless_videoencdsp_init.c
@@ -1,5 +1,5 @@
 /*
- * SIMD-optimized HuffYUV encoding functions
+ * SIMD-optimized lossless video encoding functions
  * Copyright (c) 2000, 2001 Fabrice Bellard
  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
  *
@@ -26,7 +26,7 @@
 #include "libavutil/cpu.h"
 #include "libavutil/x86/asm.h"
 #include "libavutil/x86/cpu.h"
-#include "libavcodec/huffyuvencdsp.h"
+#include "libavcodec/lossless_videoencdsp.h"
 #include "libavcodec/mathops.h"
 
 void ff_diff_bytes_mmx(uint8_t *dst, const uint8_t *src1, const uint8_t *src2,
@@ -38,9 +38,9 @@ void ff_diff_bytes_avx2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2,
 
 #if HAVE_INLINE_ASM
 
-static void sub_hfyu_median_pred_mmxext(uint8_t *dst, const uint8_t *src1,
-                                        const uint8_t *src2, intptr_t w,
-                                        int *left, int *left_top)
+static void sub_median_pred_mmxext(uint8_t *dst, const uint8_t *src1,
+                                   const uint8_t *src2, intptr_t w,
+                                   int *left, int *left_top)
 {
     x86_reg i = 0;
     uint8_t l, lt;
@@ -80,7 +80,7 @@ static void sub_hfyu_median_pred_mmxext(uint8_t *dst, const uint8_t *src1,
 
 #endif /* HAVE_INLINE_ASM */
 
-av_cold void ff_huffyuvencdsp_init_x86(HuffYUVEncDSPContext *c)
+av_cold void ff_llvidencdsp_init_x86(LLVidEncDSPContext *c)
 {
     av_unused int cpu_flags = av_get_cpu_flags();
 
@@ -90,7 +90,7 @@ av_cold void ff_huffyuvencdsp_init_x86(HuffYUVEncDSPContext *c)
 
 #if HAVE_INLINE_ASM
     if (INLINE_MMXEXT(cpu_flags)) {
-        c->sub_hfyu_median_pred = sub_hfyu_median_pred_mmxext;
+        c->sub_median_pred = sub_median_pred_mmxext;
     }
 #endif /* HAVE_INLINE_ASM */
 
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/lpc.c b/mythtv/external/FFmpeg/libavcodec/x86/lpc.c
index 3a9493f7284..6c72e21bacf 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/lpc.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/lpc.c
@@ -154,7 +154,7 @@ av_cold void ff_lpc_init_x86(LPCContext *c)
 #if HAVE_SSE2_INLINE
     int cpu_flags = av_get_cpu_flags();
 
-    if (HAVE_SSE2_INLINE && cpu_flags & (AV_CPU_FLAG_SSE2 | AV_CPU_FLAG_SSE2SLOW)) {
+    if (INLINE_SSE2(cpu_flags) || INLINE_SSE2_SLOW(cpu_flags)) {
         c->lpc_apply_welch_window = lpc_apply_welch_window_sse2;
         c->lpc_compute_autocorr   = lpc_compute_autocorr_sse2;
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/mdct15.asm b/mythtv/external/FFmpeg/libavcodec/x86/mdct15.asm
new file mode 100644
index 00000000000..03091125387
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/mdct15.asm
@@ -0,0 +1,224 @@
+;******************************************************************************
+;* SIMD optimized non-power-of-two MDCT functions
+;*
+;* Copyright (C) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+;*
+;* 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/x86/x86util.asm"
+
+SECTION_RODATA 32
+
+perm_neg: dd 2, 5, 3, 4, 6, 1, 7, 0
+perm_pos: dd 0, 7, 1, 6, 4, 3, 5, 2
+sign_adjust_r: times 4 dd 0x80000000, 0x00000000
+
+sign_adjust_5: dd 0x00000000, 0x80000000, 0x80000000, 0x00000000
+
+SECTION .text
+
+%if ARCH_X86_64
+
+;*****************************************************************************************
+;void ff_fft15_avx(FFTComplex *out, FFTComplex *in, FFTComplex *exptab, ptrdiff_t stride);
+;*****************************************************************************************
+%macro FFT5 3 ; %1 - in_offset, %2 - dst1 (64bit used), %3 - dst2
+    VBROADCASTSD m0, [inq + %1]         ; in[ 0].re, in[ 0].im, in[ 0].re, in[ 0].im
+    movsd   xm1, [inq + 1*16 +  8 + %1] ; in[ 3].re, in[ 3].im,         0,         0
+    movsd   xm4, [inq + 6*16 +  0 + %1] ; in[12].re, in[12].im,         0,         0
+    movhps  xm1, [inq + 3*16 +  0 + %1] ; in[ 3].re, in[ 3].im, in[ 6].re, in[ 6].im
+    movhps  xm4, [inq + 4*16 +  8 + %1] ; in[12].re, in[12].im, in[ 9].re, in[ 9].im
+
+    subps       xm2,  xm1, xm4          ; t[2].im, t[2].re, t[3].im, t[3].re
+    addps       xm1,  xm4               ; t[0].re, t[0].im, t[1].re, t[1].im
+
+    movhlps     %2,   xm1               ; t[0].re, t[1].re, t[0].im, t[1].im
+    addps       %2,   xm1
+    addps       %2,   xm0               ; DC[0].re, DC[0].im, junk...
+    movlhps     %2,   %2                ; DC[0].re, DC[0].im, DC[0].re, DC[0].im
+
+    shufps      xm3,  xm1, xm2, q0110   ; t[0].re, t[0].im, t[2].re, t[2].im
+    shufps      xm1,  xm2, q2332        ; t[1].re, t[1].im, t[3].re, t[3].im
+
+    mulps       xm%3, xm1, xm5
+    mulps       xm4,  xm3, xm6
+    mulps       xm1,  xm6
+
+    xorps       xm1,  xm7
+    mulps       xm3,  xm5
+    addsubps    xm3,  xm1               ; t[0].re, t[0].im, t[2].re, t[2].im
+    subps       xm%3, xm4               ; t[4].re, t[4].im, t[5].re, t[5].im
+
+    movhlps     xm2, xm%3, xm3          ; t[2].re, t[2].im, t[5].re, t[5].im
+    movlhps     xm3, xm%3               ; t[0].re, t[0].im, t[4].re, t[4].im
+
+    xorps       xm2,  xm7
+    addps       xm%3, xm2, xm3
+    subps       xm3,  xm2
+
+    shufps      xm3,  xm3, q1032
+    vinsertf128 m%3,  m%3, xm3, 1       ; All ACs (tmp[1] through to tmp[4])
+    addps       m%3,  m%3,  m0          ; Finally offset with DCs
+%endmacro
+
+%macro BUTTERFLIES_DC 2 ; %1 - exptab_offset, %2 - out
+    mulps xm0,  xm9, [exptabq + %1 + 16*0]
+    mulps xm1, xm10, [exptabq + %1 + 16*1]
+
+    haddps  xm0,  xm1
+    movhlps xm1,  xm0                   ; t[0].re, t[1].re, t[0].im, t[1].im
+
+    addps   xm0,  xm1
+    addps   xm0,  xm8
+
+    movsd [%2q], xm0
+%endmacro
+
+%macro BUTTERFLIES_AC 2 ; exptab, exptab_offset, src1, src2, src3, out (uses m0-m3)
+    mulps  m0, m12, [exptabq + 64*0 + 0*mmsize + %1]
+    mulps  m1, m12, [exptabq + 64*0 + 1*mmsize + %1]
+    mulps  m2, m13, [exptabq + 64*1 + 0*mmsize + %1]
+    mulps  m3, m13, [exptabq + 64*1 + 1*mmsize + %1]
+
+    addps  m0, m0, m2
+    addps  m1, m1, m3
+    addps  m0, m0, m11
+
+    shufps m1, m1, m1, q2301
+    addps  m0, m0, m1
+
+    vextractf128 xm1, m0, 1
+
+    movlps [%2q + strideq*1], xm0
+    movhps [%2q + strideq*2], xm0
+    movlps [%2q +  stride3q], xm1
+    movhps [%2q + strideq*4], xm1
+%endmacro
+
+INIT_YMM avx
+cglobal fft15, 4, 6, 14, out, in, exptab, stride, stride3, stride5
+%define out0q inq
+    shl strideq, 3
+
+    movaps xm5, [exptabq + 480 + 16*0]
+    movaps xm6, [exptabq + 480 + 16*1]
+    movaps xm7, [sign_adjust_5]
+
+    FFT5  0,  xm8, 11
+    FFT5  8,  xm9, 12
+    FFT5 16, xm10, 13
+
+    lea stride3q, [strideq + strideq*2]
+    lea stride5q, [strideq + strideq*4]
+
+    mov out0q, outq
+
+    BUTTERFLIES_DC (8*6 + 4*0)*2*4, out0
+    lea outq, [out0q + stride5q*1]
+    BUTTERFLIES_DC (8*6 + 4*1)*2*4, out
+    lea outq, [out0q + stride5q*2]
+    BUTTERFLIES_DC (8*6 + 4*2)*2*4, out
+
+    BUTTERFLIES_AC (8*0)*2*4, out0
+    lea outq, [out0q + stride5q*1]
+    BUTTERFLIES_AC (8*2)*2*4, out
+    lea outq, [out0q + stride5q*2]
+    BUTTERFLIES_AC (8*4)*2*4, out
+
+    RET
+
+%endif ; ARCH_X86_64
+
+;*******************************************************************************************************
+;void ff_mdct15_postreindex(FFTComplex *out, FFTComplex *in, FFTComplex *exp, int *lut, ptrdiff_t len8);
+;*******************************************************************************************************
+%macro LUT_LOAD_4D 3
+    mov      r4d, [lutq + %3q*4 +  0]
+    movsd  xmm%1, [inq +  r4q*8]
+    mov      r4d, [lutq + %3q*4 +  4]
+    movhps xmm%1, [inq +  r4q*8]
+%if cpuflag(avx2)
+    mov      r4d, [lutq + %3q*4 +  8]
+    movsd     %2, [inq +  r4q*8]
+    mov      r4d, [lutq + %3q*4 + 12]
+    movhps    %2, [inq +  r4q*8]
+    vinsertf128 %1, %1, %2, 1
+%endif
+%endmacro
+
+%macro POSTROTATE_FN 1
+cglobal mdct15_postreindex, 5, 7, 8 + cpuflag(avx2)*2, out, in, exp, lut, len8, offset_p, offset_n
+
+    xor offset_nq, offset_nq
+    lea offset_pq, [len8q*2 - %1]
+
+    movaps m7,  [sign_adjust_r]
+
+%if cpuflag(avx2)
+    movaps   m8, [perm_pos]
+    movaps   m9, [perm_neg]
+%endif
+
+.loop:
+    movups m0, [expq + offset_pq*8]     ; exp[p0].re, exp[p0].im, exp[p1].re, exp[p1].im, exp[p2].re, exp[p2].im, exp[p3].re, exp[p3].im
+    movups m1, [expq + offset_nq*8]     ; exp[n3].re, exp[n3].im, exp[n2].re, exp[n2].im, exp[n1].re, exp[n1].im, exp[n0].re, exp[n0].im
+
+    LUT_LOAD_4D m3, xm4, offset_p       ; in[p0].re, in[p0].im, in[p1].re, in[p1].im, in[p2].re, in[p2].im, in[p3].re, in[p3].im
+    LUT_LOAD_4D m4, xm5, offset_n       ; in[n3].re, in[n3].im, in[n2].re, in[n2].im, in[n1].re, in[n1].im, in[n0].re, in[n0].im
+
+    mulps  m5, m3, m0                   ; in[p].reim * exp[p].reim
+    mulps  m6, m4, m1                   ; in[n].reim * exp[n].reim
+
+    xorps  m5, m7                       ; in[p].re *= -1, in[p].im *= 1
+    xorps  m6, m7                       ; in[n].re *= -1, in[n].im *= 1
+
+    shufps m3, m3, m3, q2301            ; in[p].imre
+    shufps m4, m4, m4, q2301            ; in[n].imre
+
+    mulps  m3, m0                       ; in[p].imre * exp[p].reim
+    mulps  m4, m1                       ; in[n].imre * exp[n].reim
+
+    haddps m3, m6                       ; out[n0].im, out[n1].im, out[n3].re, out[n2].re, out[n2].im, out[n3].im, out[n1].re, out[n0].re
+    haddps m5, m4                       ; out[p0].re, out[p1].re, out[p3].im, out[p2].im, out[p2].re, out[p3].re, out[p1].im, out[p0].im
+
+%if cpuflag(avx2)
+    vpermps m3, m9, m3                  ; out[n3].im, out[n3].re, out[n2].im, out[n2].re, out[n1].im, out[n1].re, out[n0].im, out[n0].re
+    vpermps m5, m8, m5                  ; out[p0].re, out[p0].im, out[p1].re, out[p1].im, out[p2].re, out[p2].im, out[p3].re, out[p3].im
+%else
+    shufps m3, m3, m3, q0312
+    shufps m5, m5, m5, q2130
+%endif
+
+    movups [outq + offset_nq*8], m3
+    movups [outq + offset_pq*8], m5
+
+    sub offset_pq, %1
+    add offset_nq, %1
+    cmp offset_nq, offset_pq
+    jle .loop
+
+    REP_RET
+%endmacro
+
+INIT_XMM sse3
+POSTROTATE_FN 2
+
+%if ARCH_X86_64 && HAVE_AVX2_EXTERNAL
+INIT_YMM avx2
+POSTROTATE_FN 4
+%endif
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/mdct15_init.c b/mythtv/external/FFmpeg/libavcodec/x86/mdct15_init.c
new file mode 100644
index 00000000000..45b91b7e212
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/mdct15_init.c
@@ -0,0 +1,104 @@
+/*
+ * SIMD optimized non-power-of-two MDCT functions
+ *
+ * Copyright (C) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
+ *
+ * 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/x86/cpu.h"
+#include "libavcodec/mdct15.h"
+
+void ff_mdct15_postreindex_sse3(FFTComplex *out, FFTComplex *in, FFTComplex *exp, int *lut, ptrdiff_t len8);
+void ff_mdct15_postreindex_avx2(FFTComplex *out, FFTComplex *in, FFTComplex *exp, int *lut, ptrdiff_t len8);
+
+void ff_fft15_avx(FFTComplex *out, FFTComplex *in, FFTComplex *exptab, ptrdiff_t stride);
+
+static void perm_twiddles(MDCT15Context *s)
+{
+    int k;
+    FFTComplex exp_5point[4];
+
+    FFTComplex tmp[21], tmp2[30];
+    memcpy(tmp, s->exptab, sizeof(FFTComplex)*21);
+
+    /* 15-point FFT twiddles */
+    for (k = 0; k < 5; k++) {
+        tmp2[6*k + 0] = tmp[k +  0];
+        tmp2[6*k + 2] = tmp[k +  5];
+        tmp2[6*k + 4] = tmp[k + 10];
+
+        tmp2[6*k + 1] = tmp[2 * (k + 0)];
+        tmp2[6*k + 3] = tmp[2 * (k + 5)];
+        tmp2[6*k + 5] = tmp[2 *  k + 5 ];
+    }
+
+    for (k = 0; k < 6; k++) {
+        FFTComplex ac_exp[] = {
+            { tmp2[6*1 + k].re,  tmp2[6*1 + k].re },
+            { tmp2[6*2 + k].re,  tmp2[6*2 + k].re },
+            { tmp2[6*3 + k].re,  tmp2[6*3 + k].re },
+            { tmp2[6*4 + k].re,  tmp2[6*4 + k].re },
+            { tmp2[6*1 + k].im, -tmp2[6*1 + k].im },
+            { tmp2[6*2 + k].im, -tmp2[6*2 + k].im },
+            { tmp2[6*3 + k].im, -tmp2[6*3 + k].im },
+            { tmp2[6*4 + k].im, -tmp2[6*4 + k].im },
+        };
+        memcpy(s->exptab + 8*k, ac_exp, 8*sizeof(FFTComplex));
+    }
+
+    /* Specialcase when k = 0 */
+    for (k = 0; k < 3; k++) {
+        FFTComplex dc_exp[] = {
+            { tmp2[2*k + 0].re, -tmp2[2*k + 0].im },
+            { tmp2[2*k + 0].im,  tmp2[2*k + 0].re },
+            { tmp2[2*k + 1].re, -tmp2[2*k + 1].im },
+            { tmp2[2*k + 1].im,  tmp2[2*k + 1].re },
+        };
+        memcpy(s->exptab + 8*6 + 4*k, dc_exp, 4*sizeof(FFTComplex));
+    }
+
+    /* 5-point FFT twiddles */
+    exp_5point[0].re = exp_5point[0].im = tmp[19].re;
+    exp_5point[1].re = exp_5point[1].im = tmp[19].im;
+    exp_5point[2].re = exp_5point[2].im = tmp[20].re;
+    exp_5point[3].re = exp_5point[3].im = tmp[20].im;
+
+    memcpy(s->exptab + 8*6 + 4*3, exp_5point, 4*sizeof(FFTComplex));
+}
+
+av_cold void ff_mdct15_init_x86(MDCT15Context *s)
+{
+    int adjust_twiddles = 0;
+    int cpu_flags = av_get_cpu_flags();
+
+    if (EXTERNAL_SSE3(cpu_flags))
+        s->postreindex = ff_mdct15_postreindex_sse3;
+
+    if (ARCH_X86_64 && EXTERNAL_AVX(cpu_flags)) {
+        s->fft15 = ff_fft15_avx;
+        adjust_twiddles = 1;
+    }
+
+    if (ARCH_X86_64 && EXTERNAL_AVX2_FAST(cpu_flags))
+        s->postreindex = ff_mdct15_postreindex_avx2;
+
+    if (adjust_twiddles)
+        perm_twiddles(s);
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/me_cmp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/me_cmp_init.c
index dc3e6f86688..6aec93e55ff 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/me_cmp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/me_cmp_init.c
@@ -89,7 +89,7 @@ hadamard_func(mmxext)
 hadamard_func(sse2)
 hadamard_func(ssse3)
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 static int nsse16_mmx(MpegEncContext *c, uint8_t *pix1, uint8_t *pix2,
                       ptrdiff_t stride, int h)
 {
@@ -121,7 +121,7 @@ static int nsse8_mmx(MpegEncContext *c, uint8_t *pix1, uint8_t *pix2,
         return score1 + FFABS(score2) * 8;
 }
 
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 #if HAVE_INLINE_ASM
 
@@ -586,7 +586,7 @@ av_cold void ff_me_cmp_init_x86(MECmpContext *c, AVCodecContext *avctx)
         c->sum_abs_dctelem   = ff_sum_abs_dctelem_mmx;
         c->sse[0]            = ff_sse16_mmx;
         c->sse[1]            = ff_sse8_mmx;
-#if HAVE_YASM
+#if HAVE_X86ASM
         c->nsse[0]           = nsse16_mmx;
         c->nsse[1]           = nsse8_mmx;
 #endif
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/mlpdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/mlpdsp_init.c
index 7f5e6b11d5c..cb90ca24f00 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/mlpdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/mlpdsp_init.c
@@ -61,13 +61,13 @@ extern char ff_mlp_iirorder_1;
 extern char ff_mlp_iirorder_0;
 
 static const void * const firtable[9] = { &ff_mlp_firorder_0, &ff_mlp_firorder_1,
-                                   &ff_mlp_firorder_2, &ff_mlp_firorder_3,
-                                   &ff_mlp_firorder_4, &ff_mlp_firorder_5,
-                                   &ff_mlp_firorder_6, &ff_mlp_firorder_7,
-                                   &ff_mlp_firorder_8 };
+                                          &ff_mlp_firorder_2, &ff_mlp_firorder_3,
+                                          &ff_mlp_firorder_4, &ff_mlp_firorder_5,
+                                          &ff_mlp_firorder_6, &ff_mlp_firorder_7,
+                                          &ff_mlp_firorder_8 };
 static const void * const iirtable[5] = { &ff_mlp_iirorder_0, &ff_mlp_iirorder_1,
-                                   &ff_mlp_iirorder_2, &ff_mlp_iirorder_3,
-                                   &ff_mlp_iirorder_4 };
+                                          &ff_mlp_iirorder_2, &ff_mlp_iirorder_3,
+                                          &ff_mlp_iirorder_4 };
 
 #if ARCH_X86_64
 
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/mpegaudiodsp.c b/mythtv/external/FFmpeg/libavcodec/x86/mpegaudiodsp.c
index d969f1df384..f46a5c4f3d3 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/mpegaudiodsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/mpegaudiodsp.c
@@ -30,7 +30,7 @@
 static void imdct36_blocks_ ## CPU(float *out, float *buf, float *in, int count, int switch_point, int block_type);\
 void ff_imdct36_float_ ## CPU(float *out, float *buf, float *in, float *win);
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 #if ARCH_X86_32
 DECL(sse)
 #endif
@@ -38,7 +38,7 @@ DECL(sse2)
 DECL(sse3)
 DECL(ssse3)
 DECL(avx)
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 void ff_four_imdct36_float_sse(float *out, float *buf, float *in, float *win,
                                float *tmpbuf);
@@ -109,7 +109,7 @@ static void apply_window(const float *buf, const float *win1,
 }
 
 static void apply_window_mp3(float *in, float *win, int *unused, float *out,
-                             int incr)
+                             ptrdiff_t incr)
 {
     LOCAL_ALIGNED_16(float, suma, [17]);
     LOCAL_ALIGNED_16(float, sumb, [17]);
@@ -193,7 +193,7 @@ static void apply_window_mp3(float *in, float *win, int *unused, float *out,
 
 #endif /* HAVE_6REGS && HAVE_SSE_INLINE */
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 #define DECL_IMDCT_BLOCKS(CPU1, CPU2)                                       \
 static void imdct36_blocks_ ## CPU1(float *out, float *buf, float *in,      \
                                int count, int switch_point, int block_type) \
@@ -237,7 +237,7 @@ DECL_IMDCT_BLOCKS(ssse3,sse)
 #if HAVE_AVX_EXTERNAL
 DECL_IMDCT_BLOCKS(avx,avx)
 #endif
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 av_cold void ff_mpadsp_init_x86(MPADSPContext *s)
 {
@@ -263,7 +263,7 @@ av_cold void ff_mpadsp_init_x86(MPADSPContext *s)
     }
 #endif /* HAVE_SSE_INLINE */
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 #if HAVE_SSE
 #if ARCH_X86_32
     if (EXTERNAL_SSE(cpu_flags)) {
@@ -285,5 +285,5 @@ av_cold void ff_mpadsp_init_x86(MPADSPContext *s)
         s->imdct36_blocks_float = imdct36_blocks_avx;
     }
 #endif
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/mpegvideo.c b/mythtv/external/FFmpeg/libavcodec/x86/mpegvideo.c
index 35a8264804a..73967cafda7 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/mpegvideo.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/mpegvideo.c
@@ -51,7 +51,7 @@ static void dct_unquantize_h263_intra_mmx(MpegEncContext *s,
     if(s->ac_pred)
         nCoeffs=63;
     else
-        nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
+        nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
 
 __asm__ volatile(
                 "movd %1, %%mm6                 \n\t" //qmul
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/mpegvideodsp.c b/mythtv/external/FFmpeg/libavcodec/x86/mpegvideodsp.c
index e0498f38496..6009b64e076 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/mpegvideodsp.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/mpegvideodsp.c
@@ -52,8 +52,9 @@ static void gmc_mmx(uint8_t *dst, uint8_t *src,
     const int dyh = (dyy - (1 << (16 + shift))) * (h - 1);
     const int dxh = dxy * (h - 1);
     const int dyw = dyx * (w - 1);
-    int need_emu  =  (unsigned) ix >= width  - w ||
-                     (unsigned) iy >= height - h;
+    int need_emu  =  (unsigned) ix >= width  - w || width < w ||
+                     (unsigned) iy >= height - h || height< h
+                     ;
 
     if ( // non-constant fullpel offset (3% of blocks)
         ((ox ^ (ox + dxw)) | (ox ^ (ox + dxh)) | (ox ^ (ox + dxw + dxh)) |
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/mpegvideoenc.c b/mythtv/external/FFmpeg/libavcodec/x86/mpegvideoenc.c
index 67b26178a82..c884cf121bd 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/mpegvideoenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/mpegvideoenc.c
@@ -28,7 +28,16 @@
 #include "libavcodec/mpegvideo.h"
 
 /* not permutated inverse zigzag_direct + 1 for MMX quantizer */
-DECLARE_ALIGNED(16, static uint16_t, inv_zigzag_direct16)[64];
+DECLARE_ALIGNED(16, static const uint16_t, inv_zigzag_direct16)[64] = {
+    1,  2,  6,  7,  15, 16, 28, 29,
+    3,  5,  8,  14, 17, 27, 30, 43,
+    4,  9,  13, 18, 26, 31, 42, 44,
+    10, 12, 19, 25, 32, 41, 45, 54,
+    11, 20, 24, 33, 40, 46, 53, 55,
+    21, 23, 34, 39, 47, 52, 56, 61,
+    22, 35, 38, 48, 51, 57, 60, 62,
+    36, 37, 49, 50, 58, 59, 63, 64,
+};
 
 #if HAVE_6REGS
 
@@ -204,10 +213,6 @@ static void  denoise_dct_sse2(MpegEncContext *s, int16_t *block){
 av_cold void ff_dct_encode_init_x86(MpegEncContext *s)
 {
     const int dct_algo = s->avctx->dct_algo;
-    int i;
-
-    for (i = 0; i < 64; i++)
-        inv_zigzag_direct16[ff_zigzag_direct[i]] = i + 1;
 
     if (dct_algo == FF_DCT_AUTO || dct_algo == FF_DCT_MMX) {
 #if HAVE_MMX_INLINE
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/mpegvideoenc_template.c b/mythtv/external/FFmpeg/libavcodec/x86/mpegvideoenc_template.c
index b2512744ca7..1201be514bb 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/mpegvideoenc_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/mpegvideoenc_template.c
@@ -322,7 +322,7 @@ static int RENAME(dct_quantize)(MpegEncContext *s,
         block[0x3E] = temp_block[0x3D]; block[0x33] = temp_block[0x36];
         block[0x2F] = temp_block[0x2F]; block[0x37] = temp_block[0x37];
         block[0x3B] = temp_block[0x3E]; block[0x3F] = temp_block[0x3F];
-    }else{
+    } else if (s->idsp.perm_type == FF_IDCT_PERM_NONE) {
         if(last_non_zero_p1 <= 1) goto end;
         block[0x01] = temp_block[0x01];
         block[0x08] = temp_block[0x08]; block[0x10] = temp_block[0x10];
@@ -366,6 +366,57 @@ static int RENAME(dct_quantize)(MpegEncContext *s,
         block[0x3D] = temp_block[0x3D]; block[0x36] = temp_block[0x36];
         block[0x2F] = temp_block[0x2F]; block[0x37] = temp_block[0x37];
         block[0x3E] = temp_block[0x3E]; block[0x3F] = temp_block[0x3F];
+    } else if (s->idsp.perm_type == FF_IDCT_PERM_TRANSPOSE) {
+        if(last_non_zero_p1 <= 1) goto end;
+        block[0x08] = temp_block[0x01];
+        block[0x01] = temp_block[0x08]; block[0x02] = temp_block[0x10];
+        if(last_non_zero_p1 <= 4) goto end;
+        block[0x09] = temp_block[0x09]; block[0x10] = temp_block[0x02];
+        block[0x18] = temp_block[0x03];
+        if(last_non_zero_p1 <= 7) goto end;
+        block[0x11] = temp_block[0x0A]; block[0x0A] = temp_block[0x11];
+        block[0x03] = temp_block[0x18]; block[0x04] = temp_block[0x20];
+        if(last_non_zero_p1 <= 11) goto end;
+        block[0x0B] = temp_block[0x19];
+        block[0x12] = temp_block[0x12]; block[0x19] = temp_block[0x0B];
+        block[0x20] = temp_block[0x04]; block[0x28] = temp_block[0x05];
+        if(last_non_zero_p1 <= 16) goto end;
+        block[0x21] = temp_block[0x0C]; block[0x1A] = temp_block[0x13];
+        block[0x13] = temp_block[0x1A]; block[0x0C] = temp_block[0x21];
+        block[0x05] = temp_block[0x28]; block[0x06] = temp_block[0x30];
+        block[0x0D] = temp_block[0x29]; block[0x14] = temp_block[0x22];
+        if(last_non_zero_p1 <= 24) goto end;
+        block[0x1B] = temp_block[0x1B]; block[0x22] = temp_block[0x14];
+        block[0x29] = temp_block[0x0D]; block[0x30] = temp_block[0x06];
+        block[0x38] = temp_block[0x07]; block[0x31] = temp_block[0x0E];
+        block[0x2A] = temp_block[0x15]; block[0x23] = temp_block[0x1C];
+        if(last_non_zero_p1 <= 32) goto end;
+        block[0x1C] = temp_block[0x23]; block[0x15] = temp_block[0x2A];
+        block[0x0E] = temp_block[0x31]; block[0x07] = temp_block[0x38];
+        block[0x0F] = temp_block[0x39]; block[0x16] = temp_block[0x32];
+        block[0x1D] = temp_block[0x2B]; block[0x24] = temp_block[0x24];
+        if(last_non_zero_p1 <= 40) goto end;
+        block[0x2B] = temp_block[0x1D]; block[0x32] = temp_block[0x16];
+        block[0x39] = temp_block[0x0F]; block[0x3A] = temp_block[0x17];
+        block[0x33] = temp_block[0x1E]; block[0x2C] = temp_block[0x25];
+        block[0x25] = temp_block[0x2C]; block[0x1E] = temp_block[0x33];
+        if(last_non_zero_p1 <= 48) goto end;
+        block[0x17] = temp_block[0x3A]; block[0x1F] = temp_block[0x3B];
+        block[0x26] = temp_block[0x34]; block[0x2D] = temp_block[0x2D];
+        block[0x34] = temp_block[0x26]; block[0x3B] = temp_block[0x1F];
+        block[0x3C] = temp_block[0x27]; block[0x35] = temp_block[0x2E];
+        if(last_non_zero_p1 <= 56) goto end;
+        block[0x2E] = temp_block[0x35]; block[0x27] = temp_block[0x3C];
+        block[0x2F] = temp_block[0x3D]; block[0x36] = temp_block[0x36];
+        block[0x3D] = temp_block[0x2F]; block[0x3E] = temp_block[0x37];
+        block[0x37] = temp_block[0x3E]; block[0x3F] = temp_block[0x3F];
+    } else {
+        av_log(s, AV_LOG_DEBUG, "s->idsp.perm_type: %d\n",
+                (int)s->idsp.perm_type);
+        av_assert0(s->idsp.perm_type == FF_IDCT_PERM_NONE ||
+                s->idsp.perm_type == FF_IDCT_PERM_LIBMPEG2 ||
+                s->idsp.perm_type == FF_IDCT_PERM_SIMPLE ||
+                s->idsp.perm_type == FF_IDCT_PERM_TRANSPOSE);
     }
     end:
     return last_non_zero_p1 - 1;
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/opus_dsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/opus_dsp_init.c
new file mode 100644
index 00000000000..a9f8a961590
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/opus_dsp_init.c
@@ -0,0 +1,45 @@
+/*
+ * Opus encoder assembly optimizations
+ * Copyright (C) 2017 Ivan Kalvachev <ikalvachev@gmail.com>
+ *
+ * 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/x86/cpu.h"
+#include "libavcodec/opus_pvq.h"
+
+extern float ff_pvq_search_approx_sse2(float *X, int *y, int K, int N);
+extern float ff_pvq_search_approx_sse4(float *X, int *y, int K, int N);
+extern float ff_pvq_search_exact_avx  (float *X, int *y, int K, int N);
+
+av_cold void ff_opus_dsp_init_x86(CeltPVQ *s)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+#if CONFIG_OPUS_ENCODER
+    if (EXTERNAL_SSE2(cpu_flags))
+        s->pvq_search = ff_pvq_search_approx_sse2;
+
+    if (EXTERNAL_SSE4(cpu_flags))
+        s->pvq_search = ff_pvq_search_approx_sse4;
+
+    if (EXTERNAL_AVX_FAST(cpu_flags))
+        s->pvq_search = ff_pvq_search_exact_avx;
+#endif
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/opus_pvq_search.asm b/mythtv/external/FFmpeg/libavcodec/x86/opus_pvq_search.asm
new file mode 100644
index 00000000000..5c1e6d6174c
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/opus_pvq_search.asm
@@ -0,0 +1,385 @@
+;******************************************************************************
+;* SIMD optimized Opus encoder DSP function
+;*
+;* Copyright (C) 2017 Ivan Kalvachev <ikalvachev@gmail.com>
+;*
+;* 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.asm"
+%include "libavutil/x86/x86util.asm"
+
+%ifdef __NASM_VER__
+%use "smartalign"
+ALIGNMODE p6
+%endif
+
+SECTION_RODATA 64
+
+const_float_abs_mask:   times 8 dd 0x7fffffff
+const_align_abs_edge:   times 8 dd 0
+
+const_float_0_5:        times 8 dd 0.5
+const_float_1:          times 8 dd 1.0
+const_float_sign_mask:  times 8 dd 0x80000000
+
+const_int32_offsets:
+                        %rep 8
+                                dd $-const_int32_offsets
+                        %endrep
+SECTION .text
+
+;
+;   Setup High Register to be used
+;   for holding memory constants
+;
+; %1 - the register to be used, assmues it is >= mm8
+; %2 - name of the constant.
+;
+; Subsequent opcodes are going to use the constant in the form
+; "addps m0, mm_const_name" and it would be turned into:
+; "addps m0, [const_name]" on 32 bit arch or
+; "addps m0, m8" on 64 bit arch
+%macro SET_HI_REG_MM_CONSTANT 3 ; movop, reg, const_name
+%if num_mmregs > 8
+    %define  mm_%3   %2
+    %{1}        %2, [%3]    ; movaps m8, [const_name]
+%else
+    %define  mm_%3  [%3]
+%endif
+%endmacro
+
+;
+;   Set Position Independent Code
+;       Base address of a constant
+; %1 - the register to be used, if PIC is set
+; %2 - name of the constant.
+;
+; Subsequent opcode are going to use the base address in the form
+; "movaps m0, [pic_base_constant_name+r4]" and it would be turned into
+; "movaps m0, [r5 + r4]" if PIC is enabled
+; "movaps m0, [constant_name + r4]" if texrel are used
+%macro SET_PIC_BASE 3; reg, const_label
+%ifdef PIC
+    %{1}     %2, [%3]      ; lea r5, [rip+const]
+    %define  pic_base_%3 %2
+%else
+    %define  pic_base_%3 %3
+%endif
+%endmacro
+
+%macro PULSES_SEARCH 1
+; m6 Syy_norm
+; m7 Sxy_norm
+    addps          m6, mm_const_float_0_5   ; Syy_norm += 1.0/2
+    pxor           m1, m1                   ; max_idx
+    xorps          m3, m3                   ; p_max
+    xor           r4d, r4d
+align 16
+%%distortion_search:
+    movd          xm2, dword r4d    ; movd zero extends
+%ifidn %1,add
+    movaps         m4, [tmpY + r4]  ; y[i]
+    movaps         m5, [tmpX + r4]  ; X[i]
+
+  %if USE_APPROXIMATION == 1
+    xorps          m0, m0
+    cmpps          m0, m0, m5, 4    ; m0 = (X[i] != 0.0)
+  %endif
+
+    addps          m4, m6           ; m4 = Syy_new = y[i] + Syy_norm
+    addps          m5, m7           ; m5 = Sxy_new = X[i] + Sxy_norm
+
+  %if USE_APPROXIMATION == 1
+    andps          m5, m0           ; if(X[i] == 0) Sxy_new = 0; Prevent aproximation error from setting pulses in array padding.
+  %endif
+
+%else
+    movaps         m5, [tmpY + r4]      ; m5 = y[i]
+
+    xorps          m0, m0               ; m0 = 0;
+    cmpps          m0, m0, m5, 1        ; m0 = (0<y)
+
+    subps          m4, m6, m5           ; m4 = Syy_new = Syy_norm - y[i]
+    subps          m5, m7, [tmpX + r4]  ; m5 = Sxy_new = Sxy_norm - X[i]
+    andps          m5, m0               ; (0<y)?m5:0
+%endif
+
+%if USE_APPROXIMATION == 1
+    rsqrtps        m4, m4
+    mulps          m5, m4           ; m5 = p = Sxy_new*approx(1/sqrt(Syy) )
+%else
+    mulps          m5, m5
+    divps          m5, m4           ; m5 = p = Sxy_new*Sxy_new/Syy
+%endif
+    VPBROADCASTD   m2, xm2          ; m2=i (all lanes get same values, we add the offset-per-lane, later)
+
+    cmpps          m0, m3, m5, 1    ; m0 = (m3 < m5) ; (p_max < p) ; (p > p_max)
+    maxps          m3, m5           ; m3=max(p_max,p)
+                                    ; maxps here is faster than blendvps, despite blend having lower latency.
+
+    pand           m2, m0           ; This version seems faster than sse41 pblendvb
+    pmaxsw         m1, m2           ; SSE2 signed word, so it would work for N < 32768/4
+
+    add           r4d, mmsize
+    cmp           r4d, Nd
+    jb   %%distortion_search
+
+    por            m1, mm_const_int32_offsets  ; max_idx offsets per individual lane (skipped in the inner loop)
+    movdqa         m4, m1                      ; needed for the aligned y[max_idx]+=1; processing
+
+%if mmsize >= 32
+; Merge parallel maximums round 8 (4 vs 4)
+
+    vextractf128  xm5, ym3, 1       ; xmm5 = ymm3[1x128] = ymm3[255..128b]
+    cmpps         xm0, xm3, xm5, 1  ; m0 = (m3 < m5) = ( p[0x128] < p[1x128] )
+
+    vextracti128  xm2, ym1, 1       ; xmm2 = ymm1[1x128] = ymm1[255..128b]
+    BLENDVPS      xm3, xm5, xm0     ; max_idx = m0 ? max_idx[1x128] : max_idx[0x128]
+    PBLENDVB      xm1, xm2, xm0     ; p       = m0 ? p[1x128]       : p[0x128]
+%endif
+
+; Merge parallel maximums round 4 (2 vs 2)
+                                    ; m3=p[3210]
+    movhlps       xm5, xm3          ; m5=p[xx32]
+    cmpps         xm0, xm3, xm5, 1  ; m0 = (m3 < m5) = ( p[1,0] < p[3,2] )
+
+    pshufd        xm2, xm1, q3232
+    BLENDVPS      xm3, xm5, xm0     ; max_idx = m0 ? max_idx[3,2] : max_idx[1,0]
+    PBLENDVB      xm1, xm2, xm0     ; p       = m0 ? p[3,2]       : p[1,0]
+
+; Merge parallel maximums final round (1 vs 1)
+    shufps        xm0, xm3, xm3, q1111  ; m0 = m3[1] = p[1]
+    cmpss         xm0, xm3, 5           ; m0 = !(m0 >= m3) = !( p[1] >= p[0] )
+
+    pshufd        xm2, xm1, q1111
+    PBLENDVB      xm1, xm2, xm0
+
+    movd    dword r4d, xm1          ; zero extends to the rest of r4q
+
+    VBROADCASTSS   m3, [tmpX + r4]
+    %{1}ps         m7, m3           ; Sxy += X[max_idx]
+
+    VBROADCASTSS   m5, [tmpY + r4]
+    %{1}ps         m6, m5           ; Syy += Y[max_idx]
+
+    ; We have to update a single element in Y[i]
+    ; However writing 4 bytes and then doing 16 byte load in the inner loop
+    ; could cause a stall due to breaking write forwarding.
+    VPBROADCASTD   m1, xm1
+    pcmpeqd        m1, m1, m4           ; exactly 1 element matches max_idx and this finds it
+
+    and           r4d, ~(mmsize-1)      ; align address down, so the value pointed by max_idx is inside a mmsize load
+    movaps         m5, [tmpY + r4]      ; m5 = Y[y3...ym...y0]
+    andps          m1, mm_const_float_1 ; m1 =  [ 0...1.0...0]
+    %{1}ps         m5, m1               ; m5 = Y[y3...ym...y0] +/- [0...1.0...0]
+    movaps [tmpY + r4], m5              ; Y[max_idx] +-= 1.0;
+%endmacro
+
+;
+; We need one more register for
+; PIC relative addressing. Use this
+; to count it in cglobal
+;
+%ifdef PIC
+  %define num_pic_regs 1
+%else
+  %define num_pic_regs 0
+%endif
+
+;
+; Pyramid Vector Quantization Search implementation
+;
+; float * inX   - Unaligned (SIMD) access, it will be overread,
+;                 but extra data is masked away.
+; int32 * outY  - Should be aligned and padded buffer.
+;                 It is used as temp buffer.
+; uint32 K      - Number of pulses to have after quantizations.
+; uint32 N      - Number of vector elements. Must be 0 < N < 256
+;
+%macro PVQ_FAST_SEARCH 1
+cglobal pvq_search%1, 4, 5+num_pic_regs, 11, 256*4, inX, outY, K, N
+%define tmpX rsp
+%define tmpY outYq
+
+    movaps     m0, [const_float_abs_mask]
+    shl        Nd, 2    ; N *= sizeof(float); also 32 bit operation zeroes the high 32 bits in 64 bit mode.
+    mov       r4d, Nd
+
+    neg       r4d
+    and       r4d, mmsize-1
+
+    SET_PIC_BASE lea, r5, const_align_abs_edge  ; rip+const
+    movups     m2, [pic_base_const_align_abs_edge + r4 - mmsize]
+
+    add        Nd, r4d              ; N = align(N, mmsize)
+
+    lea       r4d, [Nd - mmsize]    ; N is rounded up (aligned up) to mmsize, so r4 can't become negative here, unless N=0.
+    movups     m1, [inXq + r4]
+    andps      m1, m2
+    movaps  [tmpX + r4], m1         ; Sx = abs( X[N-1] )
+
+align 16
+%%loop_abs_sum:
+    sub       r4d, mmsize
+    jc   %%end_loop_abs_sum
+
+    movups     m2, [inXq + r4]
+    andps      m2, m0
+
+    movaps  [tmpX + r4], m2 ; tmpX[i]=abs(X[i])
+    addps      m1, m2       ; Sx += abs(X[i])
+    jmp  %%loop_abs_sum
+
+align 16
+%%end_loop_abs_sum:
+
+    HSUMPS     m1, m2       ; m1  = Sx
+
+    xorps      m0, m0
+    comiss    xm0, xm1      ;
+    jz   %%zero_input       ; if (Sx==0) goto zero_input
+
+    cvtsi2ss  xm0, dword Kd ; m0 = K
+%if USE_APPROXIMATION == 1
+    rcpss     xm1, xm1      ; m1 = approx(1/Sx)
+    mulss     xm0, xm1      ; m0 = K*(1/Sx)
+%else
+    divss     xm0, xm1      ; b = K/Sx
+                            ; b = K/max_x
+%endif
+
+    VBROADCASTSS  m0, xm0
+
+    lea       r4d, [Nd - mmsize]
+    pxor       m5, m5             ; Sy    ( Sum of abs( y[i]) )
+    xorps      m6, m6             ; Syy   ( Sum of y[i]*y[i]  )
+    xorps      m7, m7             ; Sxy   ( Sum of X[i]*y[i]  )
+align 16
+%%loop_guess:
+    movaps     m1, [tmpX + r4]    ; m1   = X[i]
+    mulps      m2, m0, m1         ; m2   = res*X[i]
+    cvtps2dq   m2, m2             ; yt   = (int)lrintf( res*X[i] )
+    paddd      m5, m2             ; Sy  += yt
+    cvtdq2ps   m2, m2             ; yt   = (float)yt
+    mulps      m1, m2             ; m1   = X[i]*yt
+    movaps  [tmpY + r4], m2       ; y[i] = m2
+    addps      m7, m1             ; Sxy += m1;
+    mulps      m2, m2             ; m2   = yt*yt
+    addps      m6, m2             ; Syy += m2
+
+    sub       r4d, mmsize
+    jnc  %%loop_guess
+
+    HSUMPS     m6, m1       ; Syy_norm
+    HADDD      m5, m4       ; pulses
+
+    movd  dword r4d, xm5    ; zero extends to the rest of r4q
+
+    sub        Kd, r4d      ; K -= pulses , also 32 bit operation zeroes high 32 bit in 64 bit mode.
+    jz   %%finish           ; K - pulses == 0
+
+    SET_HI_REG_MM_CONSTANT movaps,  m8, const_float_0_5
+    SET_HI_REG_MM_CONSTANT movaps,  m9, const_float_1
+    SET_HI_REG_MM_CONSTANT movdqa, m10, const_int32_offsets
+    ; Use Syy/2 in distortion parameter calculations.
+    ; Saves pre and post-caclulation to correct Y[] values.
+    ; Same precision, since float mantisa is normalized.
+    ; The SQRT approximation does differ.
+    HSUMPS     m7, m0         ; Sxy_norm
+    mulps      m6, mm_const_float_0_5
+
+    jc   %%remove_pulses_loop   ; K - pulses < 0
+
+align 16                        ; K - pulses > 0
+%%add_pulses_loop:
+
+    PULSES_SEARCH add   ; m6 Syy_norm ; m7 Sxy_norm
+
+    sub        Kd, 1
+    jnz  %%add_pulses_loop
+
+    addps      m6, m6 ; Syy*=2
+
+    jmp  %%finish
+
+align 16
+%%remove_pulses_loop:
+
+    PULSES_SEARCH sub   ; m6 Syy_norm ; m7 Sxy_norm
+
+    add        Kd, 1
+    jnz  %%remove_pulses_loop
+
+    addps      m6, m6 ; Syy*=2
+
+align 16
+%%finish:
+    lea       r4d, [Nd - mmsize]
+    movaps     m2, [const_float_sign_mask]
+
+align 16
+%%restore_sign_loop:
+    movaps     m0, [tmpY + r4]    ; m0 = Y[i]
+    movups     m1, [inXq + r4]    ; m1 = X[i]
+    andps      m1, m2             ; m1 = sign(X[i])
+    orps       m0, m1             ; m0 = Y[i]*sign
+    cvtps2dq   m3, m0             ; m3 = (int)m0
+    movaps  [outYq + r4], m3
+
+    sub       r4d, mmsize
+    jnc  %%restore_sign_loop
+%%return:
+
+%if ARCH_X86_64 == 0    ; sbrdsp
+    movss     r0m, xm6  ; return (float)Syy_norm
+    fld dword r0m
+%else
+    movaps     m0, m6   ; return (float)Syy_norm
+%endif
+
+    RET
+
+align 16
+%%zero_input:
+    lea       r4d, [Nd - mmsize]
+    xorps      m0, m0
+%%zero_loop:
+    movaps  [outYq + r4], m0
+    sub       r4d, mmsize
+    jnc  %%zero_loop
+
+    movaps     m6, [const_float_1]
+    jmp  %%return
+%endmacro
+
+; if 1, use a float op that give half precision but execute for around 3 cycles.
+; On Skylake & Ryzen the division is much faster (around 11c/3),
+; that makes the full precision code about 2% slower.
+; Opus also does use rsqrt approximation in their intrinsics code.
+%define USE_APPROXIMATION   1
+
+INIT_XMM sse2
+PVQ_FAST_SEARCH _approx
+
+INIT_XMM sse4
+PVQ_FAST_SEARCH _approx
+
+%define USE_APPROXIMATION   0
+
+INIT_XMM avx
+PVQ_FAST_SEARCH _exact
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/pixblockdsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/pixblockdsp.asm
index 2864d0c9774..440fe29bccd 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/pixblockdsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/pixblockdsp.asm
@@ -26,7 +26,7 @@
 SECTION .text
 
 INIT_MMX mmx
-; void ff_get_pixels_mmx(int16_t *block, const uint8_t *pixels, ptrdiff_t line_size)
+; void ff_get_pixels_mmx(int16_t *block, const uint8_t *pixels, ptrdiff_t stride)
 cglobal get_pixels, 3,4
     add          r0, 128
     mov          r3, -128
@@ -81,10 +81,9 @@ cglobal get_pixels, 3, 4, 5
     RET
 
 ; void ff_diff_pixels_mmx(int16_t *block, const uint8_t *s1, const uint8_t *s2,
-;                         int stride);
+;                         ptrdiff_t stride);
 %macro DIFF_PIXELS 0
 cglobal diff_pixels, 4,5,5
-    movsxdifnidn r3, r3d
     pxor         m4, m4
     add          r0,  128
     mov          r4, -128
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/pixblockdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/pixblockdsp_init.c
index 4d06a44c6d4..ade55e01a3a 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/pixblockdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/pixblockdsp_init.c
@@ -23,12 +23,12 @@
 #include "libavutil/x86/cpu.h"
 #include "libavcodec/pixblockdsp.h"
 
-void ff_get_pixels_mmx(int16_t *block, const uint8_t *pixels, ptrdiff_t line_size);
-void ff_get_pixels_sse2(int16_t *block, const uint8_t *pixels, ptrdiff_t line_size);
+void ff_get_pixels_mmx(int16_t *block, const uint8_t *pixels, ptrdiff_t stride);
+void ff_get_pixels_sse2(int16_t *block, const uint8_t *pixels, ptrdiff_t stride);
 void ff_diff_pixels_mmx(int16_t *block, const uint8_t *s1, const uint8_t *s2,
-                        int stride);
+                        ptrdiff_t stride);
 void ff_diff_pixels_sse2(int16_t *block, const uint8_t *s1, const uint8_t *s2,
-                         int stride);
+                         ptrdiff_t stride);
 
 av_cold void ff_pixblockdsp_init_x86(PixblockDSPContext *c,
                                      AVCodecContext *avctx,
@@ -39,12 +39,14 @@ av_cold void ff_pixblockdsp_init_x86(PixblockDSPContext *c,
     if (EXTERNAL_MMX(cpu_flags)) {
         if (!high_bit_depth)
             c->get_pixels = ff_get_pixels_mmx;
+        c->diff_pixels_unaligned =
         c->diff_pixels = ff_diff_pixels_mmx;
     }
 
     if (EXTERNAL_SSE2(cpu_flags)) {
         if (!high_bit_depth)
             c->get_pixels = ff_get_pixels_sse2;
+        c->diff_pixels_unaligned =
         c->diff_pixels = ff_diff_pixels_sse2;
     }
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/proresdsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/proresdsp.asm
index 16fc262aeb7..65c9fad51cd 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/proresdsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/proresdsp.asm
@@ -33,14 +33,14 @@ cextern pw_1
 cextern pw_4
 cextern pw_1019
 ; Below are defined in simple_idct10.asm built from selecting idctdsp
-cextern w4_plus_w2
-cextern w4_min_w2
-cextern w4_plus_w6
-cextern w4_min_w6
-cextern w1_plus_w3
-cextern w3_min_w1
-cextern w7_plus_w3
-cextern w3_min_w7
+cextern w4_plus_w2_hi
+cextern w4_min_w2_hi
+cextern w4_plus_w6_hi
+cextern w4_min_w6_hi
+cextern w1_plus_w3_hi
+cextern w3_min_w1_hi
+cextern w7_plus_w3_hi
+cextern w3_min_w7_hi
 cextern w1_plus_w5
 cextern w5_min_w1
 cextern w5_plus_w7
@@ -50,9 +50,11 @@ cextern w7_min_w5
 
 SECTION .text
 
+define_constants _hi
+
 %macro idct_fn 0
-cglobal prores_idct_put_10, 4, 4, 15
-    IDCT_FN    pw_1, 15, pw_88, 18, pw_4, pw_1019, r3
+cglobal prores_idct_put_10, 4, 4, 15, pixels, lsize, block, qmat
+    IDCT_FN    pw_1, 15, pw_88, 18, "put", pw_4, pw_1019, r3
     RET
 %endmacro
 
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/proresdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/proresdsp_init.c
index ead11ae9c17..8ca4d4d9b3c 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/proresdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/proresdsp_init.c
@@ -25,9 +25,9 @@
 #include "libavcodec/idctdsp.h"
 #include "libavcodec/proresdsp.h"
 
-void ff_prores_idct_put_10_sse2(uint16_t *dst, int linesize,
+void ff_prores_idct_put_10_sse2(uint16_t *dst, ptrdiff_t linesize,
                                 int16_t *block, const int16_t *qmat);
-void ff_prores_idct_put_10_avx (uint16_t *dst, int linesize,
+void ff_prores_idct_put_10_avx (uint16_t *dst, ptrdiff_t linesize,
                                 int16_t *block, const int16_t *qmat);
 
 av_cold void ff_proresdsp_init_x86(ProresDSPContext *dsp, AVCodecContext *avctx)
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/qpeldsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/qpeldsp_init.c
index 3268d907ab4..3b05e156cc2 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/qpeldsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/qpeldsp_init.c
@@ -82,7 +82,7 @@ void ff_put_no_rnd_mpeg4_qpel8_v_lowpass_mmxext(uint8_t *dst,
 #define ff_put_no_rnd_pixels16_mmxext ff_put_pixels16_mmx
 #define ff_put_no_rnd_pixels8_mmxext ff_put_pixels8_mmx
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 
 #define ff_put_pixels16_mmxext ff_put_pixels16_mmx
 #define ff_put_pixels8_mmxext  ff_put_pixels8_mmx
@@ -504,7 +504,7 @@ QPEL_OP(put_,        _,        mmxext)
 QPEL_OP(avg_,        _,        mmxext)
 QPEL_OP(put_no_rnd_, _no_rnd_, mmxext)
 
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 #define SET_QPEL_FUNCS(PFX, IDX, SIZE, CPU, PREFIX)                          \
 do {                                                                         \
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/rv34dsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/rv34dsp.asm
index 7732d65b2a9..692b4acfcdc 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/rv34dsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/rv34dsp.asm
@@ -64,6 +64,7 @@ rv34_idct dc
 rv34_idct dc_noround
 
 ; ff_rv34_idct_dc_add_mmx(uint8_t *dst, int stride, int dc);
+%if ARCH_X86_32
 INIT_MMX mmx
 cglobal rv34_idct_dc_add, 3, 3
     ; calculate DC
@@ -97,6 +98,7 @@ cglobal rv34_idct_dc_add, 3, 3
     movh       [r2], m4
     movh       [r2+r1], m5
     RET
+%endif
 
 ; Load coeffs and perform row transform
 ; Output: coeffs in mm[0467], rounder in mm5
@@ -167,7 +169,7 @@ cglobal rv34_idct_add, 3,3,0, d, s, b
     ret
 
 ; ff_rv34_idct_dc_add_sse4(uint8_t *dst, int stride, int dc);
-INIT_XMM sse4
+%macro RV34_IDCT_DC_ADD 0
 cglobal rv34_idct_dc_add, 3, 3, 6
     ; load data
     IDCT_DC_ROUND r2
@@ -190,7 +192,22 @@ cglobal rv34_idct_dc_add, 3, 3, 6
     paddw      m4, m0
     packuswb   m2, m4
     movd      [r0], m2
+%if cpuflag(sse4)
     pextrd [r0+r1], m2, 1
     pextrd    [r2], m2, 2
     pextrd [r2+r1], m2, 3
+%else
+    psrldq     m2, 4
+    movd   [r0+r1], m2
+    psrldq     m2, 4
+    movd      [r2], m2
+    psrldq     m2, 4
+    movd   [r2+r1], m2
+%endif
     RET
+%endmacro
+
+INIT_XMM sse2
+RV34_IDCT_DC_ADD
+INIT_XMM sse4
+RV34_IDCT_DC_ADD
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/rv34dsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/rv34dsp_init.c
index d417dac45b5..73101224589 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/rv34dsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/rv34dsp_init.c
@@ -27,6 +27,7 @@
 void ff_rv34_idct_dc_mmxext(int16_t *block);
 void ff_rv34_idct_dc_noround_mmxext(int16_t *block);
 void ff_rv34_idct_dc_add_mmx(uint8_t *dst, ptrdiff_t stride, int dc);
+void ff_rv34_idct_dc_add_sse2(uint8_t *dst, ptrdiff_t stride, int dc);
 void ff_rv34_idct_dc_add_sse4(uint8_t *dst, ptrdiff_t stride, int dc);
 void ff_rv34_idct_add_mmxext(uint8_t *dst, ptrdiff_t stride, int16_t *block);
 
@@ -34,12 +35,14 @@ av_cold void ff_rv34dsp_init_x86(RV34DSPContext* c)
 {
     int cpu_flags = av_get_cpu_flags();
 
-    if (EXTERNAL_MMX(cpu_flags))
+    if (ARCH_X86_32 && EXTERNAL_MMX(cpu_flags))
         c->rv34_idct_dc_add = ff_rv34_idct_dc_add_mmx;
     if (EXTERNAL_MMXEXT(cpu_flags)) {
         c->rv34_inv_transform_dc = ff_rv34_idct_dc_noround_mmxext;
         c->rv34_idct_add         = ff_rv34_idct_add_mmxext;
     }
+    if (EXTERNAL_SSE2(cpu_flags))
+        c->rv34_idct_dc_add = ff_rv34_idct_dc_add_sse2;
     if (EXTERNAL_SSE4(cpu_flags))
         c->rv34_idct_dc_add = ff_rv34_idct_dc_add_sse4;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/rv40dsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/rv40dsp_init.c
index 218deb822c6..b57a3fc31af 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/rv40dsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/rv40dsp_init.c
@@ -39,20 +39,20 @@ static void op##_rv40_qpel##size##_mc33_##insn(uint8_t *dst, const uint8_t *src,
     ff_##op##_pixels##size##_xy2_##insn(dst, src, stride, size); \
 }
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 void ff_put_rv40_chroma_mc8_mmx  (uint8_t *dst, uint8_t *src,
-                                  int stride, int h, int x, int y);
+                                  ptrdiff_t stride, int h, int x, int y);
 void ff_avg_rv40_chroma_mc8_mmxext(uint8_t *dst, uint8_t *src,
-                                   int stride, int h, int x, int y);
+                                   ptrdiff_t stride, int h, int x, int y);
 void ff_avg_rv40_chroma_mc8_3dnow(uint8_t *dst, uint8_t *src,
-                                  int stride, int h, int x, int y);
+                                  ptrdiff_t stride, int h, int x, int y);
 
 void ff_put_rv40_chroma_mc4_mmx  (uint8_t *dst, uint8_t *src,
-                                  int stride, int h, int x, int y);
+                                  ptrdiff_t stride, int h, int x, int y);
 void ff_avg_rv40_chroma_mc4_mmxext(uint8_t *dst, uint8_t *src,
-                                   int stride, int h, int x, int y);
+                                   ptrdiff_t stride, int h, int x, int y);
 void ff_avg_rv40_chroma_mc4_3dnow(uint8_t *dst, uint8_t *src,
-                                  int stride, int h, int x, int y);
+                                  ptrdiff_t stride, int h, int x, int y);
 
 #define DECLARE_WEIGHT(opt) \
 void ff_rv40_weight_func_rnd_16_##opt(uint8_t *dst, uint8_t *src1, uint8_t *src2, \
@@ -203,7 +203,7 @@ DEFINE_FN(avg, 8, ssse3)
 
 DEFINE_FN(avg, 16, sse2)
 DEFINE_FN(avg, 16, ssse3)
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 #if HAVE_MMX_INLINE
 DEFINE_FN(put, 8, mmx)
@@ -225,7 +225,7 @@ av_cold void ff_rv40dsp_init_x86(RV34DSPContext *c)
     }
 #endif /* HAVE_MMX_INLINE */
 
-#if HAVE_YASM
+#if HAVE_X86ASM
     if (EXTERNAL_MMX(cpu_flags)) {
         c->put_chroma_pixels_tab[0] = ff_put_rv40_chroma_mc8_mmx;
         c->put_chroma_pixels_tab[1] = ff_put_rv40_chroma_mc4_mmx;
@@ -274,5 +274,5 @@ av_cold void ff_rv40dsp_init_x86(RV34DSPContext *c)
         QPEL_MC_SET(put_, _ssse3)
         QPEL_MC_SET(avg_, _ssse3)
     }
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/sbrdsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/sbrdsp.asm
index 07a412b2ae1..62bbe512ec6 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/sbrdsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/sbrdsp.asm
@@ -38,7 +38,7 @@ SECTION .text
 
 INIT_XMM sse
 cglobal sbr_sum_square, 2, 3, 6
-    mov         r2, r1
+    mov        r2d, r1d
     xorps       m0, m0
     xorps       m1, m1
     sar         r2, 3
@@ -149,19 +149,19 @@ cglobal sbr_hf_gen, 4,4,8, X_high, X_low, alpha0, alpha1, BW, S, E
     ; start and end 6th and 7th args on stack
     mov        r2d, Sm
     mov        r3d, Em
-%define  start r2q
-%define  end   r3q
+    DEFINE_ARGS X_high, X_low, start, end
 %else
 ; BW does not actually occupy a register, so shift by 1
-%define  start BWq
-%define  end   Sq
+    DEFINE_ARGS X_high, X_low, alpha0, alpha1, start, end
+    movsxd  startq, startd
+    movsxd    endq, endd
 %endif
-    sub      start, end          ; neg num of loops
-    lea    X_highq, [X_highq + end*2*4]
-    lea     X_lowq, [X_lowq  + end*2*4 - 2*2*4]
-    shl      start, 3            ; offset from num loops
+    sub     startq, endq         ; neg num of loops
+    lea    X_highq, [X_highq + endq*2*4]
+    lea     X_lowq, [X_lowq  + endq*2*4 - 2*2*4]
+    shl     startq, 3            ; offset from num loops
 
-    mova        m0, [X_lowq + start]
+    mova        m0, [X_lowq + startq]
     shufps      m3, m3, q1111
     shufps      m4, m4, q1111
     xorps       m3, [ps_mask]
@@ -169,7 +169,7 @@ cglobal sbr_hf_gen, 4,4,8, X_high, X_low, alpha0, alpha1, BW, S, E
     shufps      m2, m2, q0000
     xorps       m4, [ps_mask]
 .loop2:
-    movu        m7, [X_lowq + start + 8]        ; BbCc
+    movu        m7, [X_lowq + startq + 8]       ; BbCc
     mova        m6, m0
     mova        m5, m7
     shufps      m0, m0, q2301                   ; aAbB
@@ -179,12 +179,12 @@ cglobal sbr_hf_gen, 4,4,8, X_high, X_low, alpha0, alpha1, BW, S, E
     mulps       m6, m2
     mulps       m5, m1
     addps       m7, m0
-    mova        m0, [X_lowq + start +16]        ; CcDd
+    mova        m0, [X_lowq + startq + 16]      ; CcDd
     addps       m7, m0
     addps       m6, m5
     addps       m7, m6
-    mova  [X_highq + start], m7
-    add     start, 16
+    mova  [X_highq + startq], m7
+    add     startq, 16
     jnz         .loop2
     RET
 
@@ -378,24 +378,24 @@ cglobal sbr_hf_apply_noise_3, 5,5+NREGS+UNIX64,8, Y,s_m,q_filt,noise,kx,m_max
 apply_noise_main:
 %if ARCH_X86_64 == 0 || WIN64
     mov       kxd, m_maxm
-%define count kxq
+    DEFINE_ARGS Y, s_m, q_filt, noise, count
 %else
-%define count m_maxq
+    DEFINE_ARGS Y, s_m, q_filt, noise, kx, count
 %endif
     movsxdifnidn    noiseq, noised
     dec    noiseq
-    shl    count, 2
+    shl    countd, 2
 %ifdef PIC
     lea NOISE_TABLE, [sbr_noise_table]
 %endif
-    lea        Yq, [Yq + 2*count]
-    add      s_mq, count
-    add   q_filtq, count
+    lea        Yq, [Yq + 2*countq]
+    add      s_mq, countq
+    add   q_filtq, countq
     shl    noiseq, 3
     pxor       m5, m5
-    neg    count
+    neg    countq
 .loop:
-    mova       m1, [q_filtq + count]
+    mova       m1, [q_filtq + countq]
     movu       m3, [noiseq + NOISE_TABLE + 1*mmsize]
     movu       m4, [noiseq + NOISE_TABLE + 2*mmsize]
     add    noiseq, 2*mmsize
@@ -404,7 +404,7 @@ apply_noise_main:
     punpckldq  m1, m1
     mulps      m1, m3 ; m2 = q_filt[m] * ff_sbr_noise_table[noise]
     mulps      m2, m4 ; m2 = q_filt[m] * ff_sbr_noise_table[noise]
-    mova       m3, [s_mq + count]
+    mova       m3, [s_mq + countq]
     ; TODO: replace by a vpermd in AVX2
     punpckhdq  m4, m3, m3
     punpckldq  m3, m3
@@ -414,15 +414,15 @@ apply_noise_main:
     mulps      m4, m0 ; s_m[m] * phi_sign
     pand       m1, m6
     pand       m2, m7
-    movu       m6, [Yq + 2*count]
-    movu       m7, [Yq + 2*count + mmsize]
+    movu       m6, [Yq + 2*countq]
+    movu       m7, [Yq + 2*countq + mmsize]
     addps      m3, m1
     addps      m4, m2
     addps      m6, m3
     addps      m7, m4
-    movu    [Yq + 2*count], m6
-    movu    [Yq + 2*count + mmsize], m7
-    add    count, mmsize
+    movu    [Yq + 2*countq], m6
+    movu    [Yq + 2*countq + mmsize], m7
+    add    countq, mmsize
     jl      .loop
     RET
 
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/simple_idct.asm b/mythtv/external/FFmpeg/libavcodec/x86/simple_idct.asm
new file mode 100644
index 00000000000..6fedbb5784b
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/simple_idct.asm
@@ -0,0 +1,889 @@
+;
+; Simple IDCT MMX
+;
+; Copyright (c) 2001, 2002 Michael Niedermayer <michaelni@gmx.at>
+;
+; Conversion from gcc syntax to x264asm syntax with minimal modifications
+; by James Darnley <jdarnley@obe.tv>.
+;
+; 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/x86/x86util.asm"
+
+SECTION_RODATA
+
+cextern pb_80
+
+wm1010: dw 0, 0xffff, 0, 0xffff
+d40000: dd 4 << 16, 0
+
+; 23170.475006
+; 22725.260826
+; 21406.727617
+; 19265.545870
+; 16384.000000
+; 12872.826198
+; 8866.956905
+; 4520.335430
+
+%define C0 23170 ; cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+%define C1 22725 ; cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+%define C2 21407 ; cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+%define C3 19266 ; cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+%define C4 16383 ; cos(i*M_PI/16)*sqrt(2)*(1<<14) - 0.5
+%define C5 12873 ; cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+%define C6 8867  ; cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+%define C7 4520  ; cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
+
+%define ROW_SHIFT 11
+%define COL_SHIFT 20 ; 6
+
+coeffs:
+    dw 1 << (ROW_SHIFT - 1), 0
+    dw 1 << (ROW_SHIFT - 1), 0
+    dw 1 << (ROW_SHIFT - 1), 1
+    dw 1 << (ROW_SHIFT - 1), 0
+
+    dw C4,  C4,  C4,  C4
+    dw C4, -C4,  C4, -C4
+
+    dw C2,  C6,  C2,  C6
+    dw C6, -C2,  C6, -C2
+
+    dw C1,  C3,  C1,  C3
+    dw C5,  C7,  C5,  C7
+
+    dw C3, -C7,  C3, -C7
+    dw -C1, -C5, -C1, -C5
+
+    dw C5, -C1,  C5, -C1
+    dw C7,  C3,  C7,  C3
+
+    dw C7, -C5,  C7, -C5
+    dw C3, -C1,  C3, -C1
+
+SECTION .text
+
+%macro DC_COND_IDCT 7
+    movq            mm0, [blockq + %1]  ; R4     R0      r4      r0
+    movq            mm1, [blockq + %2]  ; R6     R2      r6      r2
+    movq            mm2, [blockq + %3]  ; R3     R1      r3      r1
+    movq            mm3, [blockq + %4]  ; R7     R5      r7      r5
+    movq            mm4, [wm1010]
+    pand            mm4, mm0
+    por             mm4, mm1
+    por             mm4, mm2
+    por             mm4, mm3
+    packssdw        mm4, mm4
+    movd            t0d, mm4
+    or              t0d, t0d
+    jz              %%1
+    movq            mm4, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm4, mm0            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm5, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm0, mm5            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm5, [coeffs + 32]  ; C6     C2      C6      C2
+    pmaddwd         mm5, mm1            ; C6R6+C2R2      C6r6+C2r2
+    movq            mm6, [coeffs + 40]  ; -C2    C6      -C2     C6
+    pmaddwd         mm1, mm6            ; -C2R6+C6R2     -C2r6+C6r2
+    movq            mm7, [coeffs + 48]  ; C3     C1      C3      C1
+    pmaddwd         mm7, mm2            ; C3R3+C1R1      C3r3+C1r1
+    paddd           mm4, [coeffs + 8]
+    movq            mm6, mm4            ; C4R4+C4R0      C4r4+C4r0
+    paddd           mm4, mm5            ; A0             a0
+    psubd           mm6, mm5            ; A3             a3
+    movq            mm5, [coeffs + 56]  ; C7     C5      C7      C5
+    pmaddwd         mm5, mm3            ; C7R7+C5R5      C7r7+C5r5
+    paddd           mm0, [coeffs + 8]
+    paddd           mm1, mm0            ; A1             a1
+    paddd           mm0, mm0
+    psubd           mm0, mm1            ; A2             a2
+    pmaddwd         mm2, [coeffs + 64]  ; -C7R3+C3R1     -C7r3+C3r1
+    paddd           mm7, mm5            ; B0             b0
+    movq            mm5, [coeffs + 72]  ; -C5    -C1     -C5     -C1
+    pmaddwd         mm5, mm3            ; -C5R7-C1R5     -C5r7-C1r5
+    paddd           mm7, mm4            ; A0+B0          a0+b0
+    paddd           mm4, mm4            ; 2A0            2a0
+    psubd           mm4, mm7            ; A0-B0          a0-b0
+    paddd           mm5, mm2            ; B1             b1
+    psrad           mm7, %7
+    psrad           mm4, %7
+    movq            mm2, mm1            ; A1             a1
+    paddd           mm1, mm5            ; A1+B1          a1+b1
+    psubd           mm2, mm5            ; A1-B1          a1-b1
+    psrad           mm1, %7
+    psrad           mm2, %7
+    packssdw        mm7, mm1            ; A1+B1  a1+b1   A0+B0   a0+b0
+    packssdw        mm2, mm4            ; A0-B0  a0-b0   A1-B1   a1-b1
+    movq           [%5], mm7
+    movq            mm1, [blockq + %3]  ; R3     R1      r3      r1
+    movq            mm4, [coeffs + 80]  ; -C1    C5      -C1     C5
+    movq      [24 + %5], mm2
+    pmaddwd         mm4, mm1            ; -C1R3+C5R1     -C1r3+C5r1
+    movq            mm7, [coeffs + 88]  ; C3     C7      C3      C7
+    pmaddwd         mm1, [coeffs + 96]  ; -C5R3+C7R1     -C5r3+C7r1
+    pmaddwd         mm7, mm3            ; C3R7+C7R5      C3r7+C7r5
+    movq            mm2, mm0            ; A2             a2
+    pmaddwd         mm3, [coeffs + 104] ; -C1R7+C3R5     -C1r7+C3r5
+    paddd           mm4, mm7            ; B2             b2
+    paddd           mm2, mm4            ; A2+B2          a2+b2
+    psubd           mm0, mm4            ; a2-B2          a2-b2
+    psrad           mm2, %7
+    psrad           mm0, %7
+    movq            mm4, mm6            ; A3             a3
+    paddd           mm3, mm1            ; B3             b3
+    paddd           mm6, mm3            ; A3+B3          a3+b3
+    psubd           mm4, mm3            ; a3-B3          a3-b3
+    psrad           mm6, %7
+    packssdw        mm2, mm6            ; A3+B3  a3+b3   A2+B2   a2+b2
+    movq       [8 + %5], mm2
+    psrad           mm4, %7
+    packssdw        mm4, mm0            ; A2-B2  a2-b2   A3-B3   a3-b3
+    movq      [16 + %5], mm4
+    jmp             %%2
+%%1:
+    pslld           mm0, 16
+    paddd           mm0, [d40000]
+    psrad           mm0, 13
+    packssdw        mm0, mm0
+    movq           [%5], mm0
+    movq       [8 + %5], mm0
+    movq      [16 + %5], mm0
+    movq      [24 + %5], mm0
+%%2:
+%endmacro
+
+%macro Z_COND_IDCT 8
+    movq            mm0, [blockq + %1]  ; R4     R0      r4      r0
+    movq            mm1, [blockq + %2]  ; R6     R2      r6      r2
+    movq            mm2, [blockq + %3]  ; R3     R1      r3      r1
+    movq            mm3, [blockq + %4]  ; R7     R5      r7      r5
+    movq            mm4, mm0
+    por             mm4, mm1
+    por             mm4, mm2
+    por             mm4, mm3
+    packssdw        mm4, mm4
+    movd            t0d, mm4
+    or              t0d, t0d
+    jz               %8
+    movq            mm4, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm4, mm0            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm5, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm0, mm5            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm5, [coeffs + 32]  ; C6     C2      C6      C2
+    pmaddwd         mm5, mm1            ; C6R6+C2R2      C6r6+C2r2
+    movq            mm6, [coeffs + 40]  ; -C2    C6      -C2     C6
+    pmaddwd         mm1, mm6            ; -C2R6+C6R2     -C2r6+C6r2
+    movq            mm7, [coeffs + 48]  ; C3     C1      C3      C1
+    pmaddwd         mm7, mm2            ; C3R3+C1R1      C3r3+C1r1
+    paddd           mm4, [coeffs]
+    movq            mm6, mm4            ; C4R4+C4R0      C4r4+C4r0
+    paddd           mm4, mm5            ; A0             a0
+    psubd           mm6, mm5            ; A3             a3
+    movq            mm5, [coeffs + 56]  ; C7     C5      C7      C5
+    pmaddwd         mm5, mm3            ; C7R7+C5R5      C7r7+C5r5
+    paddd           mm0, [coeffs]
+    paddd           mm1, mm0            ; A1             a1
+    paddd           mm0, mm0
+    psubd           mm0, mm1            ; A2             a2
+    pmaddwd         mm2, [coeffs + 64]  ; -C7R3+C3R1     -C7r3+C3r1
+    paddd           mm7, mm5            ; B0             b0
+    movq            mm5, [coeffs + 72]  ; -C5    -C1     -C5     -C1
+    pmaddwd         mm5, mm3            ; -C5R7-C1R5     -C5r7-C1r5
+    paddd           mm7, mm4            ; A0+B0          a0+b0
+    paddd           mm4, mm4            ; 2A0            2a0
+    psubd           mm4, mm7            ; A0-B0          a0-b0
+    paddd           mm5, mm2            ; B1             b1
+    psrad           mm7, %7
+    psrad           mm4, %7
+    movq            mm2, mm1            ; A1             a1
+    paddd           mm1, mm5            ; A1+B1          a1+b1
+    psubd           mm2, mm5            ; A1-B1          a1-b1
+    psrad           mm1, %7
+    psrad           mm2, %7
+    packssdw        mm7, mm1            ; A1+B1  a1+b1   A0+B0   a0+b0
+    packssdw        mm2, mm4            ; A0-B0  a0-b0   A1-B1   a1-b1
+    movq           [%5], mm7
+    movq            mm1, [blockq + %3]  ; R3     R1      r3      r1
+    movq            mm4, [coeffs + 80]  ; -C1    C5      -C1     C5
+    movq      [24 + %5], mm2
+    pmaddwd         mm4, mm1            ; -C1R3+C5R1     -C1r3+C5r1
+    movq            mm7, [coeffs + 88]  ; C3     C7      C3      C7
+    pmaddwd         mm1, [coeffs + 96]  ; -C5R3+C7R1     -C5r3+C7r1
+    pmaddwd         mm7, mm3            ; C3R7+C7R5      C3r7+C7r5
+    movq            mm2, mm0            ; A2             a2
+    pmaddwd         mm3, [coeffs + 104] ; -C1R7+C3R5     -C1r7+C3r5
+    paddd           mm4, mm7            ; B2             b2
+    paddd           mm2, mm4            ; A2+B2          a2+b2
+    psubd           mm0, mm4            ; a2-B2          a2-b2
+    psrad           mm2, %7
+    psrad           mm0, %7
+    movq            mm4, mm6            ; A3             a3
+    paddd           mm3, mm1            ; B3             b3
+    paddd           mm6, mm3            ; A3+B3          a3+b3
+    psubd           mm4, mm3            ; a3-B3          a3-b3
+    psrad           mm6, %7
+    packssdw        mm2, mm6            ; A3+B3  a3+b3   A2+B2   a2+b2
+    movq       [8 + %5], mm2
+    psrad           mm4, %7
+    packssdw        mm4, mm0            ; A2-B2  a2-b2   A3-B3   a3-b3
+    movq      [16 + %5], mm4
+%endmacro
+
+%macro IDCT1 6
+    movq            mm0, %1             ; R4     R0      r4      r0
+    movq            mm1, %2             ; R6     R2      r6      r2
+    movq            mm2, %3             ; R3     R1      r3      r1
+    movq            mm3, %4             ; R7     R5      r7      r5
+    movq            mm4, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm4, mm0            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm5, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm0, mm5            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm5, [coeffs + 32]  ; C6     C2      C6      C2
+    pmaddwd         mm5, mm1            ; C6R6+C2R2      C6r6+C2r2
+    movq            mm6, [coeffs + 40]  ; -C2    C6      -C2     C6
+    pmaddwd         mm1, mm6            ; -C2R6+C6R2     -C2r6+C6r2
+    movq            mm6, mm4            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm7, [coeffs + 48]  ; C3     C1      C3      C1
+    pmaddwd         mm7, mm2            ; C3R3+C1R1      C3r3+C1r1
+    paddd           mm4, mm5            ; A0             a0
+    psubd           mm6, mm5            ; A3             a3
+    movq            mm5, mm0            ; -C4R4+C4R0     -C4r4+C4r0
+    paddd           mm0, mm1            ; A1             a1
+    psubd           mm5, mm1            ; A2             a2
+    movq            mm1, [coeffs + 56]  ; C7     C5      C7      C5
+    pmaddwd         mm1, mm3            ; C7R7+C5R5      C7r7+C5r5
+    pmaddwd         mm2, [coeffs + 64]  ; -C7R3+C3R1     -C7r3+C3r1
+    paddd           mm7, mm1            ; B0             b0
+    movq            mm1, [coeffs + 72]  ; -C5    -C1     -C5     -C1
+    pmaddwd         mm1, mm3            ; -C5R7-C1R5     -C5r7-C1r5
+    paddd           mm7, mm4            ; A0+B0          a0+b0
+    paddd           mm4, mm4            ; 2A0            2a0
+    psubd           mm4, mm7            ; A0-B0          a0-b0
+    paddd           mm1, mm2            ; B1             b1
+    psrad           mm7, %6
+    psrad           mm4, %6
+    movq            mm2, mm0            ; A1             a1
+    paddd           mm0, mm1            ; A1+B1          a1+b1
+    psubd           mm2, mm1            ; A1-B1          a1-b1
+    psrad           mm0, %6
+    psrad           mm2, %6
+    packssdw        mm7, mm7            ; A0+B0  a0+b0
+    movd           [%5], mm7
+    packssdw        mm0, mm0            ; A1+B1  a1+b1
+    movd      [16 + %5], mm0
+    packssdw        mm2, mm2            ; A1-B1  a1-b1
+    movd      [96 + %5], mm2
+    packssdw        mm4, mm4            ; A0-B0  a0-b0
+    movd     [112 + %5], mm4
+    movq            mm0, %3             ; R3     R1      r3      r1
+    movq            mm4, [coeffs + 80]  ; -C1    C5      -C1     C5
+    pmaddwd         mm4, mm0            ; -C1R3+C5R1     -C1r3+C5r1
+    movq            mm7, [coeffs + 88]  ; C3     C7      C3      C7
+    pmaddwd         mm0, [coeffs + 96]  ; -C5R3+C7R1     -C5r3+C7r1
+    pmaddwd         mm7, mm3            ; C3R7+C7R5      C3r7+C7r5
+    movq            mm2, mm5            ; A2             a2
+    pmaddwd         mm3, [coeffs + 104] ; -C1R7+C3R5     -C1r7+C3r5
+    paddd           mm4, mm7            ; B2             b2
+    paddd           mm2, mm4            ; A2+B2          a2+b2
+    psubd           mm5, mm4            ; a2-B2          a2-b2
+    psrad           mm2, %6
+    psrad           mm5, %6
+    movq            mm4, mm6            ; A3             a3
+    paddd           mm3, mm0            ; B3             b3
+    paddd           mm6, mm3            ; A3+B3          a3+b3
+    psubd           mm4, mm3            ; a3-B3          a3-b3
+    psrad           mm6, %6
+    psrad           mm4, %6
+    packssdw        mm2, mm2            ; A2+B2  a2+b2
+    packssdw        mm6, mm6            ; A3+B3  a3+b3
+    movd      [32 + %5], mm2
+    packssdw        mm4, mm4            ; A3-B3  a3-b3
+    packssdw        mm5, mm5            ; A2-B2  a2-b2
+    movd      [48 + %5], mm6
+    movd      [64 + %5], mm4
+    movd      [80 + %5], mm5
+%endmacro
+
+%macro IDCT2 6
+    movq            mm0, %1             ; R4     R0      r4      r0
+    movq            mm1, %2             ; R6     R2      r6      r2
+    movq            mm3, %4             ; R7     R5      r7      r5
+    movq            mm4, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm4, mm0            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm5, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm0, mm5            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm5, [coeffs + 32]  ; C6     C2      C6      C2
+    pmaddwd         mm5, mm1            ; C6R6+C2R2      C6r6+C2r2
+    movq            mm6, [coeffs + 40]  ; -C2    C6      -C2     C6
+    pmaddwd         mm1, mm6            ; -C2R6+C6R2     -C2r6+C6r2
+    movq            mm6, mm4            ; C4R4+C4R0      C4r4+C4r0
+    paddd           mm4, mm5            ; A0             a0
+    psubd           mm6, mm5            ; A3             a3
+    movq            mm5, mm0            ; -C4R4+C4R0     -C4r4+C4r0
+    paddd           mm0, mm1            ; A1             a1
+    psubd           mm5, mm1            ; A2             a2
+    movq            mm1, [coeffs + 56]  ; C7     C5      C7      C5
+    pmaddwd         mm1, mm3            ; C7R7+C5R5      C7r7+C5r5
+    movq            mm7, [coeffs + 72]  ; -C5    -C1     -C5     -C1
+    pmaddwd         mm7, mm3            ; -C5R7-C1R5     -C5r7-C1r5
+    paddd           mm1, mm4            ; A0+B0          a0+b0
+    paddd           mm4, mm4            ; 2A0            2a0
+    psubd           mm4, mm1            ; A0-B0          a0-b0
+    psrad           mm1, %6
+    psrad           mm4, %6
+    movq            mm2, mm0            ; A1             a1
+    paddd           mm0, mm7            ; A1+B1          a1+b1
+    psubd           mm2, mm7            ; A1-B1          a1-b1
+    psrad           mm0, %6
+    psrad           mm2, %6
+    packssdw        mm1, mm1            ; A0+B0  a0+b0
+    movd           [%5], mm1
+    packssdw        mm0, mm0            ; A1+B1  a1+b1
+    movd      [16 + %5], mm0
+    packssdw        mm2, mm2            ; A1-B1  a1-b1
+    movd      [96 + %5], mm2
+    packssdw        mm4, mm4            ; A0-B0  a0-b0
+    movd     [112 + %5], mm4
+    movq            mm1, [coeffs + 88]  ; C3     C7      C3      C7
+    pmaddwd         mm1, mm3            ; C3R7+C7R5      C3r7+C7r5
+    movq            mm2, mm5            ; A2             a2
+    pmaddwd         mm3, [coeffs + 104] ; -C1R7+C3R5     -C1r7+C3r5
+    paddd           mm2, mm1            ; A2+B2          a2+b2
+    psubd           mm5, mm1            ; a2-B2          a2-b2
+    psrad           mm2, %6
+    psrad           mm5, %6
+    movq            mm1, mm6            ; A3             a3
+    paddd           mm6, mm3            ; A3+B3          a3+b3
+    psubd           mm1, mm3            ; a3-B3          a3-b3
+    psrad           mm6, %6
+    psrad           mm1, %6
+    packssdw        mm2, mm2            ; A2+B2  a2+b2
+    packssdw        mm6, mm6            ; A3+B3  a3+b3
+    movd      [32 + %5], mm2
+    packssdw        mm1, mm1            ; A3-B3  a3-b3
+    packssdw        mm5, mm5            ; A2-B2  a2-b2
+    movd      [48 + %5], mm6
+    movd      [64 + %5], mm1
+    movd      [80 + %5], mm5
+%endmacro
+
+%macro IDCT3 6
+    movq            mm0, %1             ; R4     R0      r4      r0
+    movq            mm3, %4             ; R7     R5      r7      r5
+    movq            mm4, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm4, mm0            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm5, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm0, mm5            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm6, mm4            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm5, mm0            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm1, [coeffs + 56]  ; C7     C5      C7      C5
+    pmaddwd         mm1, mm3            ; C7R7+C5R5      C7r7+C5r5
+    movq            mm7, [coeffs + 72]  ; -C5    -C1     -C5     -C1
+    pmaddwd         mm7, mm3            ; -C5R7-C1R5     -C5r7-C1r5
+    paddd           mm1, mm4            ; A0+B0          a0+b0
+    paddd           mm4, mm4            ; 2A0            2a0
+    psubd           mm4, mm1            ; A0-B0          a0-b0
+    psrad           mm1, %6
+    psrad           mm4, %6
+    movq            mm2, mm0            ; A1             a1
+    paddd           mm0, mm7            ; A1+B1          a1+b1
+    psubd           mm2, mm7            ; A1-B1          a1-b1
+    psrad           mm0, %6
+    psrad           mm2, %6
+    packssdw        mm1, mm1            ; A0+B0  a0+b0
+    movd           [%5], mm1
+    packssdw        mm0, mm0            ; A1+B1  a1+b1
+    movd      [16 + %5], mm0
+    packssdw        mm2, mm2            ; A1-B1  a1-b1
+    movd      [96 + %5], mm2
+    packssdw        mm4, mm4            ; A0-B0  a0-b0
+    movd     [112 + %5], mm4
+    movq            mm1, [coeffs + 88]  ; C3     C7      C3      C7
+    pmaddwd         mm1, mm3            ; C3R7+C7R5      C3r7+C7r5
+    movq            mm2, mm5            ; A2             a2
+    pmaddwd         mm3, [coeffs + 104] ; -C1R7+C3R5     -C1r7+C3r5
+    paddd           mm2, mm1            ; A2+B2          a2+b2
+    psubd           mm5, mm1            ; a2-B2          a2-b2
+    psrad           mm2, %6
+    psrad           mm5, %6
+    movq            mm1, mm6            ; A3             a3
+    paddd           mm6, mm3            ; A3+B3          a3+b3
+    psubd           mm1, mm3            ; a3-B3          a3-b3
+    psrad           mm6, %6
+    psrad           mm1, %6
+    packssdw        mm2, mm2            ; A2+B2  a2+b2
+    packssdw        mm6, mm6            ; A3+B3  a3+b3
+    movd      [32 + %5], mm2
+    packssdw        mm1, mm1            ; A3-B3  a3-b3
+    packssdw        mm5, mm5            ; A2-B2  a2-b2
+    movd      [48 + %5], mm6
+    movd      [64 + %5], mm1
+    movd      [80 + %5], mm5
+%endmacro
+
+%macro IDCT4 6
+    movq            mm0, %1             ; R4     R0      r4      r0
+    movq            mm2, %3             ; R3     R1      r3      r1
+    movq            mm3, %4             ; R7     R5      r7      r5
+    movq            mm4, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm4, mm0            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm5, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm0, mm5            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm6, mm4            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm7, [coeffs + 48]  ; C3     C1      C3      C1
+    pmaddwd         mm7, mm2            ; C3R3+C1R1      C3r3+C1r1
+    movq            mm5, mm0            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm1, [coeffs + 56]  ; C7     C5      C7      C5
+    pmaddwd         mm1, mm3            ; C7R7+C5R5      C7r7+C5r5
+    pmaddwd         mm2, [coeffs + 64]  ; -C7R3+C3R1     -C7r3+C3r1
+    paddd           mm7, mm1            ; B0             b0
+    movq            mm1, [coeffs + 72]  ; -C5    -C1     -C5     -C1
+    pmaddwd         mm1, mm3            ; -C5R7-C1R5     -C5r7-C1r5
+    paddd           mm7, mm4            ; A0+B0          a0+b0
+    paddd           mm4, mm4            ; 2A0            2a0
+    psubd           mm4, mm7            ; A0-B0          a0-b0
+    paddd           mm1, mm2            ; B1             b1
+    psrad           mm7, %6
+    psrad           mm4, %6
+    movq            mm2, mm0            ; A1             a1
+    paddd           mm0, mm1            ; A1+B1          a1+b1
+    psubd           mm2, mm1            ; A1-B1          a1-b1
+    psrad           mm0, %6
+    psrad           mm2, %6
+    packssdw        mm7, mm7            ; A0+B0  a0+b0
+    movd           [%5], mm7
+    packssdw        mm0, mm0            ; A1+B1  a1+b1
+    movd      [16 + %5], mm0
+    packssdw        mm2, mm2            ; A1-B1  a1-b1
+    movd      [96 + %5], mm2
+    packssdw        mm4, mm4            ; A0-B0  a0-b0
+    movd     [112 + %5], mm4
+    movq            mm0, %3             ; R3     R1      r3      r1
+    movq            mm4, [coeffs + 80]  ; -C1    C5      -C1     C5
+    pmaddwd         mm4, mm0            ; -C1R3+C5R1     -C1r3+C5r1
+    movq            mm7, [coeffs + 88]  ; C3     C7      C3      C7
+    pmaddwd         mm0, [coeffs + 96]  ; -C5R3+C7R1     -C5r3+C7r1
+    pmaddwd         mm7, mm3            ; C3R7+C7R5      C3r7+C7r5
+    movq            mm2, mm5            ; A2             a2
+    pmaddwd         mm3, [coeffs + 104] ; -C1R7+C3R5     -C1r7+C3r5
+    paddd           mm4, mm7            ; B2             b2
+    paddd           mm2, mm4            ; A2+B2          a2+b2
+    psubd           mm5, mm4            ; a2-B2          a2-b2
+    psrad           mm2, %6
+    psrad           mm5, %6
+    movq            mm4, mm6            ; A3             a3
+    paddd           mm3, mm0            ; B3             b3
+    paddd           mm6, mm3            ; A3+B3          a3+b3
+    psubd           mm4, mm3            ; a3-B3          a3-b3
+    psrad           mm6, %6
+    psrad           mm4, %6
+    packssdw        mm2, mm2            ; A2+B2  a2+b2
+    packssdw        mm6, mm6            ; A3+B3  a3+b3
+    movd      [32 + %5], mm2
+    packssdw        mm4, mm4            ; A3-B3  a3-b3
+    packssdw        mm5, mm5            ; A2-B2  a2-b2
+    movd      [48 + %5], mm6
+    movd      [64 + %5], mm4
+    movd      [80 + %5], mm5
+%endmacro
+
+%macro IDCT5 6
+    movq            mm0, %1             ; R4     R0      r4      r0
+    movq            mm2, %3             ; R3     R1      r3      r1
+    movq            mm4, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm4, mm0            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm5, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm0, mm5            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm6, mm4            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm7, [coeffs + 48]  ; C3     C1      C3      C1
+    pmaddwd         mm7, mm2            ; C3R3+C1R1      C3r3+C1r1
+    movq            mm5, mm0            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm3, [coeffs + 64]
+    pmaddwd         mm3, mm2            ; -C7R3+C3R1     -C7r3+C3r1
+    paddd           mm7, mm4            ; A0+B0          a0+b0
+    paddd           mm4, mm4            ; 2A0            2a0
+    psubd           mm4, mm7            ; A0-B0          a0-b0
+    psrad           mm7, %6
+    psrad           mm4, %6
+    movq            mm1, mm0            ; A1             a1
+    paddd           mm0, mm3            ; A1+B1          a1+b1
+    psubd           mm1, mm3            ; A1-B1          a1-b1
+    psrad           mm0, %6
+    psrad           mm1, %6
+    packssdw        mm7, mm7            ; A0+B0  a0+b0
+    movd           [%5], mm7
+    packssdw        mm0, mm0            ; A1+B1  a1+b1
+    movd      [16 + %5], mm0
+    packssdw        mm1, mm1            ; A1-B1  a1-b1
+    movd      [96 + %5], mm1
+    packssdw        mm4, mm4            ; A0-B0  a0-b0
+    movd     [112 + %5], mm4
+    movq            mm4, [coeffs + 80]  ; -C1    C5      -C1     C5
+    pmaddwd         mm4, mm2            ; -C1R3+C5R1     -C1r3+C5r1
+    pmaddwd         mm2, [coeffs + 96]  ; -C5R3+C7R1     -C5r3+C7r1
+    movq            mm1, mm5            ; A2             a2
+    paddd           mm1, mm4            ; A2+B2          a2+b2
+    psubd           mm5, mm4            ; a2-B2          a2-b2
+    psrad           mm1, %6
+    psrad           mm5, %6
+    movq            mm4, mm6            ; A3             a3
+    paddd           mm6, mm2            ; A3+B3          a3+b3
+    psubd           mm4, mm2            ; a3-B3          a3-b3
+    psrad           mm6, %6
+    psrad           mm4, %6
+    packssdw        mm1, mm1            ; A2+B2  a2+b2
+    packssdw        mm6, mm6            ; A3+B3  a3+b3
+    movd      [32 + %5], mm1
+    packssdw        mm4, mm4            ; A3-B3  a3-b3
+    packssdw        mm5, mm5            ; A2-B2  a2-b2
+    movd      [48 + %5], mm6
+    movd      [64 + %5], mm4
+    movd      [80 + %5], mm5
+%endmacro
+
+%macro IDCT6 6
+    movq            mm0, [%1]           ; R4     R0      r4      r0
+    movq            mm1, [%2]           ; R6     R2      r6      r2
+    movq            mm4, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm4, mm0            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm5, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm0, mm5            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm5, [coeffs + 32]  ; C6     C2      C6      C2
+    pmaddwd         mm5, mm1            ; C6R6+C2R2      C6r6+C2r2
+    movq            mm6, [coeffs + 40]  ; -C2    C6      -C2     C6
+    pmaddwd         mm1, mm6            ; -C2R6+C6R2     -C2r6+C6r2
+    movq            mm6, mm4            ; C4R4+C4R0      C4r4+C4r0
+    paddd           mm4, mm5            ; A0             a0
+    psubd           mm6, mm5            ; A3             a3
+    movq            mm5, mm0            ; -C4R4+C4R0     -C4r4+C4r0
+    paddd           mm0, mm1            ; A1             a1
+    psubd           mm5, mm1            ; A2             a2
+    movq            mm2, [8 + %1]       ; R4     R0      r4      r0
+    movq            mm3, [8 + %2]       ; R6     R2      r6      r2
+    movq            mm1, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm1, mm2            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm7, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm2, mm7            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm7, [coeffs + 32]  ; C6     C2      C6      C2
+    pmaddwd         mm7, mm3            ; C6R6+C2R2      C6r6+C2r2
+    pmaddwd         mm3, [coeffs + 40]  ; -C2R6+C6R2     -C2r6+C6r2
+    paddd           mm7, mm1            ; A0             a0
+    paddd           mm1, mm1            ; 2C0            2c0
+    psubd           mm1, mm7            ; A3             a3
+    paddd           mm3, mm2            ; A1             a1
+    paddd           mm2, mm2            ; 2C1            2c1
+    psubd           mm2, mm3            ; A2             a2
+    psrad           mm4, %6
+    psrad           mm7, %6
+    psrad           mm3, %6
+    packssdw        mm4, mm7            ; A0     a0
+    movq           [%5], mm4
+    psrad           mm0, %6
+    packssdw        mm0, mm3            ; A1     a1
+    movq      [16 + %5], mm0
+    movq      [96 + %5], mm0
+    movq     [112 + %5], mm4
+    psrad           mm5, %6
+    psrad           mm6, %6
+    psrad           mm2, %6
+    packssdw        mm5, mm2            ; A2-B2  a2-b2
+    movq      [32 + %5], mm5
+    psrad           mm1, %6
+    packssdw        mm6, mm1            ; A3+B3  a3+b3
+    movq      [48 + %5], mm6
+    movq      [64 + %5], mm6
+    movq      [80 + %5], mm5
+%endmacro
+
+%macro IDCT7 6
+    movq            mm0, %1             ; R4     R0      r4      r0
+    movq            mm1, %2             ; R6     R2      r6      r2
+    movq            mm2, %3             ; R3     R1      r3      r1
+    movq            mm4, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm4, mm0            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm5, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm0, mm5            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm5, [coeffs + 32]  ; C6     C2      C6      C2
+    pmaddwd         mm5, mm1            ; C6R6+C2R2      C6r6+C2r2
+    movq            mm6, [coeffs + 40]  ; -C2    C6      -C2     C6
+    pmaddwd         mm1, mm6            ; -C2R6+C6R2     -C2r6+C6r2
+    movq            mm6, mm4            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm7, [coeffs + 48]  ; C3     C1      C3      C1
+    pmaddwd         mm7, mm2            ; C3R3+C1R1      C3r3+C1r1
+    paddd           mm4, mm5            ; A0             a0
+    psubd           mm6, mm5            ; A3             a3
+    movq            mm5, mm0            ; -C4R4+C4R0     -C4r4+C4r0
+    paddd           mm0, mm1            ; A1             a1
+    psubd           mm5, mm1            ; A2             a2
+    movq            mm1, [coeffs + 64]
+    pmaddwd         mm1, mm2            ; -C7R3+C3R1     -C7r3+C3r1
+    paddd           mm7, mm4            ; A0+B0          a0+b0
+    paddd           mm4, mm4            ; 2A0            2a0
+    psubd           mm4, mm7            ; A0-B0          a0-b0
+    psrad           mm7, %6
+    psrad           mm4, %6
+    movq            mm3, mm0            ; A1             a1
+    paddd           mm0, mm1            ; A1+B1          a1+b1
+    psubd           mm3, mm1            ; A1-B1          a1-b1
+    psrad           mm0, %6
+    psrad           mm3, %6
+    packssdw        mm7, mm7            ; A0+B0  a0+b0
+    movd           [%5], mm7
+    packssdw        mm0, mm0            ; A1+B1  a1+b1
+    movd      [16 + %5], mm0
+    packssdw        mm3, mm3            ; A1-B1  a1-b1
+    movd      [96 + %5], mm3
+    packssdw        mm4, mm4            ; A0-B0  a0-b0
+    movd     [112 + %5], mm4
+    movq            mm4, [coeffs + 80]  ; -C1    C5      -C1     C5
+    pmaddwd         mm4, mm2            ; -C1R3+C5R1     -C1r3+C5r1
+    pmaddwd         mm2, [coeffs + 96]  ; -C5R3+C7R1     -C5r3+C7r1
+    movq            mm3, mm5            ; A2             a2
+    paddd           mm3, mm4            ; A2+B2          a2+b2
+    psubd           mm5, mm4            ; a2-B2          a2-b2
+    psrad           mm3, %6
+    psrad           mm5, %6
+    movq            mm4, mm6            ; A3             a3
+    paddd           mm6, mm2            ; A3+B3          a3+b3
+    psubd           mm4, mm2            ; a3-B3          a3-b3
+    psrad           mm6, %6
+    packssdw        mm3, mm3            ; A2+B2  a2+b2
+    movd      [32 + %5], mm3
+    psrad           mm4, %6
+    packssdw        mm6, mm6            ; A3+B3  a3+b3
+    movd      [48 + %5], mm6
+    packssdw        mm4, mm4            ; A3-B3  a3-b3
+    packssdw        mm5, mm5            ; A2-B2  a2-b2
+    movd      [64 + %5], mm4
+    movd      [80 + %5], mm5
+%endmacro
+
+%macro IDCT8 6
+    movq            mm0, [%1]           ; R4     R0      r4      r0
+    movq            mm4, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm4, mm0            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm5, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm0, mm5            ; -C4R4+C4R0     -C4r4+C4r0
+    psrad           mm4, %6
+    psrad           mm0, %6
+    movq            mm2, [8 + %1]       ; R4     R0      r4      r0
+    movq            mm1, [coeffs + 16]  ; C4     C4      C4      C4
+    pmaddwd         mm1, mm2            ; C4R4+C4R0      C4r4+C4r0
+    movq            mm7, [coeffs + 24]  ; -C4    C4      -C4     C4
+    pmaddwd         mm2, mm7            ; -C4R4+C4R0     -C4r4+C4r0
+    movq            mm7, [coeffs + 32]  ; C6     C2      C6      C2
+    psrad           mm1, %6
+    packssdw        mm4, mm1            ; A0     a0
+    movq           [%5], mm4
+    psrad           mm2, %6
+    packssdw        mm0, mm2            ; A1     a1
+    movq      [16 + %5], mm0
+    movq      [96 + %5], mm0
+    movq     [112 + %5], mm4
+    movq      [32 + %5], mm0
+    movq      [48 + %5], mm4
+    movq      [64 + %5], mm4
+    movq      [80 + %5], mm0
+%endmacro
+
+%macro IDCT 0
+    DC_COND_IDCT  0,   8,  16,  24, rsp +  0, null, 11
+    Z_COND_IDCT  32,  40,  48,  56, rsp + 32, null, 11, %%4
+    Z_COND_IDCT  64,  72,  80,  88, rsp + 64, null, 11, %%2
+    Z_COND_IDCT  96, 104, 112, 120, rsp + 96, null, 11, %%1
+
+    IDCT1 [rsp +  0], [rsp + 64], [rsp + 32], [rsp +  96], blockq +  0, 20
+    IDCT1 [rsp +  8], [rsp + 72], [rsp + 40], [rsp + 104], blockq +  4, 20
+    IDCT1 [rsp + 16], [rsp + 80], [rsp + 48], [rsp + 112], blockq +  8, 20
+    IDCT1 [rsp + 24], [rsp + 88], [rsp + 56], [rsp + 120], blockq + 12, 20
+    jmp %%9
+
+    ALIGN 16
+    %%4:
+    Z_COND_IDCT 64,  72,  80,  88, rsp + 64, null, 11, %%6
+    Z_COND_IDCT 96, 104, 112, 120, rsp + 96, null, 11, %%5
+
+    IDCT2 [rsp +  0], [rsp + 64], [rsp + 32], [rsp +  96], blockq +  0, 20
+    IDCT2 [rsp +  8], [rsp + 72], [rsp + 40], [rsp + 104], blockq +  4, 20
+    IDCT2 [rsp + 16], [rsp + 80], [rsp + 48], [rsp + 112], blockq +  8, 20
+    IDCT2 [rsp + 24], [rsp + 88], [rsp + 56], [rsp + 120], blockq + 12, 20
+    jmp %%9
+
+    ALIGN 16
+    %%6:
+    Z_COND_IDCT 96, 104, 112, 120, rsp + 96, null, 11, %%7
+
+    IDCT3 [rsp +  0], [rsp + 64], [rsp + 32], [rsp +  96], blockq +  0, 20
+    IDCT3 [rsp +  8], [rsp + 72], [rsp + 40], [rsp + 104], blockq +  4, 20
+    IDCT3 [rsp + 16], [rsp + 80], [rsp + 48], [rsp + 112], blockq +  8, 20
+    IDCT3 [rsp + 24], [rsp + 88], [rsp + 56], [rsp + 120], blockq + 12, 20
+    jmp %%9
+
+    ALIGN 16
+    %%2:
+    Z_COND_IDCT 96, 104, 112, 120, rsp + 96, null, 11, %%3
+
+    IDCT4 [rsp +  0], [rsp + 64], [rsp + 32], [rsp +  96], blockq +  0, 20
+    IDCT4 [rsp +  8], [rsp + 72], [rsp + 40], [rsp + 104], blockq +  4, 20
+    IDCT4 [rsp + 16], [rsp + 80], [rsp + 48], [rsp + 112], blockq +  8, 20
+    IDCT4 [rsp + 24], [rsp + 88], [rsp + 56], [rsp + 120], blockq + 12, 20
+    jmp %%9
+
+    ALIGN 16
+    %%3:
+
+    IDCT5 [rsp +  0], [rsp + 64], [rsp + 32], [rsp +  96], blockq +  0, 20
+    IDCT5 [rsp +  8], [rsp + 72], [rsp + 40], [rsp + 104], blockq +  4, 20
+    IDCT5 [rsp + 16], [rsp + 80], [rsp + 48], [rsp + 112], blockq +  8, 20
+    IDCT5 [rsp + 24], [rsp + 88], [rsp + 56], [rsp + 120], blockq + 12, 20
+    jmp %%9
+
+    ALIGN 16
+    %%5:
+
+    IDCT6 rsp +  0, rsp + 64, rsp + 32, rsp +  96, blockq +  0, 20
+    IDCT6 rsp + 16, rsp + 80, rsp + 48, rsp + 112, blockq +  8, 20
+    jmp %%9
+
+    ALIGN 16
+    %%1:
+
+    IDCT7 [rsp +  0], [rsp + 64], [rsp + 32], [rsp +  96], blockq +  0, 20
+    IDCT7 [rsp +  8], [rsp + 72], [rsp + 40], [rsp + 104], blockq +  4, 20
+    IDCT7 [rsp + 16], [rsp + 80], [rsp + 48], [rsp + 112], blockq +  8, 20
+    IDCT7 [rsp + 24], [rsp + 88], [rsp + 56], [rsp + 120], blockq + 12, 20
+    jmp %%9
+
+    ALIGN 16
+    %%7:
+
+    IDCT8 rsp +  0, rsp + 64, rsp + 32, rsp +  96, blockq +  0, 20
+    IDCT8 rsp + 16, rsp + 80, rsp + 48, rsp + 112, blockq +  8, 20
+
+    %%9:
+%endmacro
+
+%macro PUT_PIXELS_CLAMPED_HALF 1
+    mova     m0, [blockq+mmsize*0+%1]
+    mova     m1, [blockq+mmsize*2+%1]
+%if mmsize == 8
+    mova     m2, [blockq+mmsize*4+%1]
+    mova     m3, [blockq+mmsize*6+%1]
+%endif
+    packuswb m0, [blockq+mmsize*1+%1]
+    packuswb m1, [blockq+mmsize*3+%1]
+%if mmsize == 8
+    packuswb m2, [blockq+mmsize*5+%1]
+    packuswb m3, [blockq+mmsize*7+%1]
+    movq           [pixelsq], m0
+    movq    [lsizeq+pixelsq], m1
+    movq  [2*lsizeq+pixelsq], m2
+    movq   [lsize3q+pixelsq], m3
+%else
+    movq           [pixelsq], m0
+    movhps  [lsizeq+pixelsq], m0
+    movq  [2*lsizeq+pixelsq], m1
+    movhps [lsize3q+pixelsq], m1
+%endif
+%endmacro
+
+%macro ADD_PIXELS_CLAMPED 1
+    mova       m0, [blockq+mmsize*0+%1]
+    mova       m1, [blockq+mmsize*1+%1]
+%if mmsize == 8
+    mova       m5, [blockq+mmsize*2+%1]
+    mova       m6, [blockq+mmsize*3+%1]
+%endif
+    movq       m2, [pixelsq]
+    movq       m3, [pixelsq+lsizeq]
+%if mmsize == 8
+    mova       m7, m2
+    punpcklbw  m2, m4
+    punpckhbw  m7, m4
+    paddsw     m0, m2
+    paddsw     m1, m7
+    mova       m7, m3
+    punpcklbw  m3, m4
+    punpckhbw  m7, m4
+    paddsw     m5, m3
+    paddsw     m6, m7
+%else
+    punpcklbw  m2, m4
+    punpcklbw  m3, m4
+    paddsw     m0, m2
+    paddsw     m1, m3
+%endif
+    packuswb   m0, m1
+%if mmsize == 8
+    packuswb   m5, m6
+    movq       [pixelsq], m0
+    movq       [pixelsq+lsizeq], m5
+%else
+    movq       [pixelsq], m0
+    movhps     [pixelsq+lsizeq], m0
+%endif
+%endmacro
+
+INIT_MMX mmx
+
+cglobal simple_idct, 1, 2, 8, 128, block, t0
+    IDCT
+RET
+
+cglobal simple_idct_put, 3, 5, 8, 128, pixels, lsize, block, lsize3, t0
+    IDCT
+    lea lsize3q, [lsizeq*3]
+    PUT_PIXELS_CLAMPED_HALF 0
+    lea pixelsq, [pixelsq+lsizeq*4]
+    PUT_PIXELS_CLAMPED_HALF 64
+RET
+
+cglobal simple_idct_add, 3, 4, 8, 128, pixels, lsize, block, t0
+    IDCT
+    pxor       m4, m4
+    ADD_PIXELS_CLAMPED 0
+    lea        pixelsq, [pixelsq+lsizeq*2]
+    ADD_PIXELS_CLAMPED 32
+    lea        pixelsq, [pixelsq+lsizeq*2]
+    ADD_PIXELS_CLAMPED 64
+    lea        pixelsq, [pixelsq+lsizeq*2]
+    ADD_PIXELS_CLAMPED 96
+RET
+
+INIT_XMM sse2
+
+cglobal simple_idct_put, 3, 5, 8, 128, pixels, lsize, block, lsize3, t0
+    IDCT
+    lea lsize3q, [lsizeq*3]
+    PUT_PIXELS_CLAMPED_HALF 0
+    lea pixelsq, [pixelsq+lsizeq*4]
+    PUT_PIXELS_CLAMPED_HALF 64
+RET
+
+cglobal simple_idct_add, 3, 4, 8, 128, pixels, lsize, block, t0
+    IDCT
+    pxor       m4, m4
+    ADD_PIXELS_CLAMPED 0
+    lea        pixelsq, [pixelsq+lsizeq*2]
+    ADD_PIXELS_CLAMPED 32
+    lea        pixelsq, [pixelsq+lsizeq*2]
+    ADD_PIXELS_CLAMPED 64
+    lea        pixelsq, [pixelsq+lsizeq*2]
+    ADD_PIXELS_CLAMPED 96
+RET
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/simple_idct.c b/mythtv/external/FFmpeg/libavcodec/x86/simple_idct.c
deleted file mode 100644
index 1d46212a13d..00000000000
--- a/mythtv/external/FFmpeg/libavcodec/x86/simple_idct.c
+++ /dev/null
@@ -1,1173 +0,0 @@
-/*
- * Simple IDCT MMX
- *
- * Copyright (c) 2001, 2002 Michael Niedermayer <michaelni@gmx.at>
- *
- * 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/mem.h"
-#include "libavutil/x86/asm.h"
-
-#include "libavcodec/idctdsp.h"
-
-#include "idctdsp.h"
-#include "simple_idct.h"
-
-#if HAVE_INLINE_ASM
-
-/*
-23170.475006
-22725.260826
-21406.727617
-19265.545870
-16384.000000
-12872.826198
-8866.956905
-4520.335430
-*/
-#define C0 23170 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
-#define C1 22725 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
-#define C2 21407 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
-#define C3 19266 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
-#define C4 16383 //cos(i*M_PI/16)*sqrt(2)*(1<<14) - 0.5
-#define C5 12873 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
-#define C6 8867  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
-#define C7 4520  //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
-
-#define ROW_SHIFT 11
-#define COL_SHIFT 20 // 6
-
-DECLARE_ASM_CONST(8, uint64_t, wm1010)= 0xFFFF0000FFFF0000ULL;
-DECLARE_ASM_CONST(8, uint64_t, d40000)= 0x0000000000040000ULL;
-
-DECLARE_ALIGNED(8, static const int16_t, coeffs)[]= {
-        1<<(ROW_SHIFT-1), 0, 1<<(ROW_SHIFT-1), 0,
-//        1<<(COL_SHIFT-1), 0, 1<<(COL_SHIFT-1), 0,
-//        0, 1<<(COL_SHIFT-1-16), 0, 1<<(COL_SHIFT-1-16),
-        1<<(ROW_SHIFT-1), 1, 1<<(ROW_SHIFT-1), 0,
-        // the 1 = ((1<<(COL_SHIFT-1))/C4)<<ROW_SHIFT :)
-//        0, 0, 0, 0,
-//        0, 0, 0, 0,
-
- C4,  C4,  C4,  C4,
- C4, -C4,  C4, -C4,
-
- C2,  C6,  C2,  C6,
- C6, -C2,  C6, -C2,
-
- C1,  C3,  C1,  C3,
- C5,  C7,  C5,  C7,
-
- C3, -C7,  C3, -C7,
--C1, -C5, -C1, -C5,
-
- C5, -C1,  C5, -C1,
- C7,  C3,  C7,  C3,
-
- C7, -C5,  C7, -C5,
- C3, -C1,  C3, -C1
-};
-
-static inline void idct(int16_t *block)
-{
-        LOCAL_ALIGNED_8(int64_t, align_tmp, [16]);
-        int16_t * const temp= (int16_t*)align_tmp;
-
-        __asm__ volatile(
-#if 0 //Alternative, simpler variant
-
-#define ROW_IDCT(src0, src4, src1, src5, dst, rounder, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src4 ", %%mm1          \n\t" /* R6     R2      r6      r2 */\
-        "movq " #src1 ", %%mm2          \n\t" /* R3     R1      r3      r1 */\
-        "movq " #src5 ", %%mm3          \n\t" /* R7     R5      r7      r5 */\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm5             \n\t" /* C6     C2      C6      C2 */\
-        "pmaddwd %%mm1, %%mm5           \n\t" /* C6R6+C2R2      C6r6+C2r2 */\
-        "movq 40(%2), %%mm6             \n\t" /* -C2    C6      -C2     C6 */\
-        "pmaddwd %%mm6, %%mm1           \n\t" /* -C2R6+C6R2     -C2r6+C6r2 */\
-        "movq 48(%2), %%mm7             \n\t" /* C3     C1      C3      C1 */\
-        "pmaddwd %%mm2, %%mm7           \n\t" /* C3R3+C1R1      C3r3+C1r1 */\
-        #rounder ", %%mm4               \n\t"\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "paddd %%mm5, %%mm4             \n\t" /* A0             a0 */\
-        "psubd %%mm5, %%mm6             \n\t" /* A3             a3 */\
-        "movq 56(%2), %%mm5             \n\t" /* C7     C5      C7      C5 */\
-        "pmaddwd %%mm3, %%mm5           \n\t" /* C7R7+C5R5      C7r7+C5r5 */\
-        #rounder ", %%mm0               \n\t"\
-        "paddd %%mm0, %%mm1             \n\t" /* A1             a1 */\
-        "paddd %%mm0, %%mm0             \n\t" \
-        "psubd %%mm1, %%mm0             \n\t" /* A2             a2 */\
-        "pmaddwd 64(%2), %%mm2          \n\t" /* -C7R3+C3R1     -C7r3+C3r1 */\
-        "paddd %%mm5, %%mm7             \n\t" /* B0             b0 */\
-        "movq 72(%2), %%mm5             \n\t" /* -C5    -C1     -C5     -C1 */\
-        "pmaddwd %%mm3, %%mm5           \n\t" /* -C5R7-C1R5     -C5r7-C1r5 */\
-        "paddd %%mm4, %%mm7             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm7, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "paddd %%mm2, %%mm5             \n\t" /* B1             b1 */\
-        "psrad $" #shift ", %%mm7       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm1, %%mm2              \n\t" /* A1             a1 */\
-        "paddd %%mm5, %%mm1             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm5, %%mm2             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm1, %%mm7          \n\t" /* A1+B1  a1+b1   A0+B0   a0+b0 */\
-        "packssdw %%mm4, %%mm2          \n\t" /* A0-B0  a0-b0   A1-B1   a1-b1 */\
-        "movq %%mm7, " #dst "           \n\t"\
-        "movq " #src1 ", %%mm1          \n\t" /* R3     R1      r3      r1 */\
-        "movq 80(%2), %%mm4             \n\t" /* -C1    C5      -C1     C5 */\
-        "movq %%mm2, 24+" #dst "        \n\t"\
-        "pmaddwd %%mm1, %%mm4           \n\t" /* -C1R3+C5R1     -C1r3+C5r1 */\
-        "movq 88(%2), %%mm7             \n\t" /* C3     C7      C3      C7 */\
-        "pmaddwd 96(%2), %%mm1          \n\t" /* -C5R3+C7R1     -C5r3+C7r1 */\
-        "pmaddwd %%mm3, %%mm7           \n\t" /* C3R7+C7R5      C3r7+C7r5 */\
-        "movq %%mm0, %%mm2              \n\t" /* A2             a2 */\
-        "pmaddwd 104(%2), %%mm3         \n\t" /* -C1R7+C3R5     -C1r7+C3r5 */\
-        "paddd %%mm7, %%mm4             \n\t" /* B2             b2 */\
-        "paddd %%mm4, %%mm2             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm4, %%mm0             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "movq %%mm6, %%mm4              \n\t" /* A3             a3 */\
-        "paddd %%mm1, %%mm3             \n\t" /* B3             b3 */\
-        "paddd %%mm3, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm3, %%mm4             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "packssdw %%mm6, %%mm2          \n\t" /* A3+B3  a3+b3   A2+B2   a2+b2 */\
-        "movq %%mm2, 8+" #dst "         \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "packssdw %%mm0, %%mm4          \n\t" /* A2-B2  a2-b2   A3-B3   a3-b3 */\
-        "movq %%mm4, 16+" #dst "        \n\t"\
-
-#define COL_IDCT(src0, src4, src1, src5, dst, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src4 ", %%mm1          \n\t" /* R6     R2      r6      r2 */\
-        "movq " #src1 ", %%mm2          \n\t" /* R3     R1      r3      r1 */\
-        "movq " #src5 ", %%mm3          \n\t" /* R7     R5      r7      r5 */\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm5             \n\t" /* C6     C2      C6      C2 */\
-        "pmaddwd %%mm1, %%mm5           \n\t" /* C6R6+C2R2      C6r6+C2r2 */\
-        "movq 40(%2), %%mm6             \n\t" /* -C2    C6      -C2     C6 */\
-        "pmaddwd %%mm6, %%mm1           \n\t" /* -C2R6+C6R2     -C2r6+C6r2 */\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 48(%2), %%mm7             \n\t" /* C3     C1      C3      C1 */\
-        "pmaddwd %%mm2, %%mm7           \n\t" /* C3R3+C1R1      C3r3+C1r1 */\
-        "paddd %%mm5, %%mm4             \n\t" /* A0             a0 */\
-        "psubd %%mm5, %%mm6             \n\t" /* A3             a3 */\
-        "movq %%mm0, %%mm5              \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "paddd %%mm1, %%mm0             \n\t" /* A1             a1 */\
-        "psubd %%mm1, %%mm5             \n\t" /* A2             a2 */\
-        "movq 56(%2), %%mm1             \n\t" /* C7     C5      C7      C5 */\
-        "pmaddwd %%mm3, %%mm1           \n\t" /* C7R7+C5R5      C7r7+C5r5 */\
-        "pmaddwd 64(%2), %%mm2          \n\t" /* -C7R3+C3R1     -C7r3+C3r1 */\
-        "paddd %%mm1, %%mm7             \n\t" /* B0             b0 */\
-        "movq 72(%2), %%mm1             \n\t" /* -C5    -C1     -C5     -C1 */\
-        "pmaddwd %%mm3, %%mm1           \n\t" /* -C5R7-C1R5     -C5r7-C1r5 */\
-        "paddd %%mm4, %%mm7             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm7, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "paddd %%mm2, %%mm1             \n\t" /* B1             b1 */\
-        "psrad $" #shift ", %%mm7       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm0, %%mm2              \n\t" /* A1             a1 */\
-        "paddd %%mm1, %%mm0             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm1, %%mm2             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm7, %%mm7          \n\t" /* A0+B0  a0+b0 */\
-        "movd %%mm7, " #dst "           \n\t"\
-        "packssdw %%mm0, %%mm0          \n\t" /* A1+B1  a1+b1 */\
-        "movd %%mm0, 16+" #dst "        \n\t"\
-        "packssdw %%mm2, %%mm2          \n\t" /* A1-B1  a1-b1 */\
-        "movd %%mm2, 96+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A0-B0  a0-b0 */\
-        "movd %%mm4, 112+" #dst "       \n\t"\
-        "movq " #src1 ", %%mm0          \n\t" /* R3     R1      r3      r1 */\
-        "movq 80(%2), %%mm4             \n\t" /* -C1    C5      -C1     C5 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* -C1R3+C5R1     -C1r3+C5r1 */\
-        "movq 88(%2), %%mm7             \n\t" /* C3     C7      C3      C7 */\
-        "pmaddwd 96(%2), %%mm0          \n\t" /* -C5R3+C7R1     -C5r3+C7r1 */\
-        "pmaddwd %%mm3, %%mm7           \n\t" /* C3R7+C7R5      C3r7+C7r5 */\
-        "movq %%mm5, %%mm2              \n\t" /* A2             a2 */\
-        "pmaddwd 104(%2), %%mm3         \n\t" /* -C1R7+C3R5     -C1r7+C3r5 */\
-        "paddd %%mm7, %%mm4             \n\t" /* B2             b2 */\
-        "paddd %%mm4, %%mm2             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm4, %%mm5             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "psrad $" #shift ", %%mm5       \n\t"\
-        "movq %%mm6, %%mm4              \n\t" /* A3             a3 */\
-        "paddd %%mm0, %%mm3             \n\t" /* B3             b3 */\
-        "paddd %%mm3, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm3, %%mm4             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "packssdw %%mm2, %%mm2          \n\t" /* A2+B2  a2+b2 */\
-        "packssdw %%mm6, %%mm6          \n\t" /* A3+B3  a3+b3 */\
-        "movd %%mm2, 32+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A3-B3  a3-b3 */\
-        "packssdw %%mm5, %%mm5          \n\t" /* A2-B2  a2-b2 */\
-        "movd %%mm6, 48+" #dst "        \n\t"\
-        "movd %%mm4, 64+" #dst "        \n\t"\
-        "movd %%mm5, 80+" #dst "        \n\t"\
-
-
-#define DC_COND_ROW_IDCT(src0, src4, src1, src5, dst, rounder, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src4 ", %%mm1          \n\t" /* R6     R2      r6      r2 */\
-        "movq " #src1 ", %%mm2          \n\t" /* R3     R1      r3      r1 */\
-        "movq " #src5 ", %%mm3          \n\t" /* R7     R5      r7      r5 */\
-        "movq "MANGLE(wm1010)", %%mm4   \n\t"\
-        "pand %%mm0, %%mm4              \n\t"\
-        "por %%mm1, %%mm4               \n\t"\
-        "por %%mm2, %%mm4               \n\t"\
-        "por %%mm3, %%mm4               \n\t"\
-        "packssdw %%mm4,%%mm4           \n\t"\
-        "movd %%mm4, %%eax              \n\t"\
-        "orl %%eax, %%eax               \n\t"\
-        "jz 1f                          \n\t"\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm5             \n\t" /* C6     C2      C6      C2 */\
-        "pmaddwd %%mm1, %%mm5           \n\t" /* C6R6+C2R2      C6r6+C2r2 */\
-        "movq 40(%2), %%mm6             \n\t" /* -C2    C6      -C2     C6 */\
-        "pmaddwd %%mm6, %%mm1           \n\t" /* -C2R6+C6R2     -C2r6+C6r2 */\
-        "movq 48(%2), %%mm7             \n\t" /* C3     C1      C3      C1 */\
-        "pmaddwd %%mm2, %%mm7           \n\t" /* C3R3+C1R1      C3r3+C1r1 */\
-        #rounder ", %%mm4               \n\t"\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "paddd %%mm5, %%mm4             \n\t" /* A0             a0 */\
-        "psubd %%mm5, %%mm6             \n\t" /* A3             a3 */\
-        "movq 56(%2), %%mm5             \n\t" /* C7     C5      C7      C5 */\
-        "pmaddwd %%mm3, %%mm5           \n\t" /* C7R7+C5R5      C7r7+C5r5 */\
-        #rounder ", %%mm0               \n\t"\
-        "paddd %%mm0, %%mm1             \n\t" /* A1             a1 */\
-        "paddd %%mm0, %%mm0             \n\t" \
-        "psubd %%mm1, %%mm0             \n\t" /* A2             a2 */\
-        "pmaddwd 64(%2), %%mm2          \n\t" /* -C7R3+C3R1     -C7r3+C3r1 */\
-        "paddd %%mm5, %%mm7             \n\t" /* B0             b0 */\
-        "movq 72(%2), %%mm5             \n\t" /* -C5    -C1     -C5     -C1 */\
-        "pmaddwd %%mm3, %%mm5           \n\t" /* -C5R7-C1R5     -C5r7-C1r5 */\
-        "paddd %%mm4, %%mm7             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm7, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "paddd %%mm2, %%mm5             \n\t" /* B1             b1 */\
-        "psrad $" #shift ", %%mm7       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm1, %%mm2              \n\t" /* A1             a1 */\
-        "paddd %%mm5, %%mm1             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm5, %%mm2             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm1, %%mm7          \n\t" /* A1+B1  a1+b1   A0+B0   a0+b0 */\
-        "packssdw %%mm4, %%mm2          \n\t" /* A0-B0  a0-b0   A1-B1   a1-b1 */\
-        "movq %%mm7, " #dst "           \n\t"\
-        "movq " #src1 ", %%mm1          \n\t" /* R3     R1      r3      r1 */\
-        "movq 80(%2), %%mm4             \n\t" /* -C1    C5      -C1     C5 */\
-        "movq %%mm2, 24+" #dst "        \n\t"\
-        "pmaddwd %%mm1, %%mm4           \n\t" /* -C1R3+C5R1     -C1r3+C5r1 */\
-        "movq 88(%2), %%mm7             \n\t" /* C3     C7      C3      C7 */\
-        "pmaddwd 96(%2), %%mm1          \n\t" /* -C5R3+C7R1     -C5r3+C7r1 */\
-        "pmaddwd %%mm3, %%mm7           \n\t" /* C3R7+C7R5      C3r7+C7r5 */\
-        "movq %%mm0, %%mm2              \n\t" /* A2             a2 */\
-        "pmaddwd 104(%2), %%mm3         \n\t" /* -C1R7+C3R5     -C1r7+C3r5 */\
-        "paddd %%mm7, %%mm4             \n\t" /* B2             b2 */\
-        "paddd %%mm4, %%mm2             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm4, %%mm0             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "movq %%mm6, %%mm4              \n\t" /* A3             a3 */\
-        "paddd %%mm1, %%mm3             \n\t" /* B3             b3 */\
-        "paddd %%mm3, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm3, %%mm4             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "packssdw %%mm6, %%mm2          \n\t" /* A3+B3  a3+b3   A2+B2   a2+b2 */\
-        "movq %%mm2, 8+" #dst "         \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "packssdw %%mm0, %%mm4          \n\t" /* A2-B2  a2-b2   A3-B3   a3-b3 */\
-        "movq %%mm4, 16+" #dst "        \n\t"\
-        "jmp 2f                         \n\t"\
-        "1:                             \n\t"\
-        "pslld $16, %%mm0               \n\t"\
-        "#paddd "MANGLE(d40000)", %%mm0 \n\t"\
-        "psrad $13, %%mm0               \n\t"\
-        "packssdw %%mm0, %%mm0          \n\t"\
-        "movq %%mm0, " #dst "           \n\t"\
-        "movq %%mm0, 8+" #dst "         \n\t"\
-        "movq %%mm0, 16+" #dst "        \n\t"\
-        "movq %%mm0, 24+" #dst "        \n\t"\
-        "2:                             \n\t"
-
-
-//IDCT(      src0,   src4,   src1,   src5,    dst,    rounder, shift)
-ROW_IDCT(    (%0),  8(%0), 16(%0), 24(%0),  0(%1),paddd 8(%2), 11)
-/*ROW_IDCT(  32(%0), 40(%0), 48(%0), 56(%0), 32(%1), paddd (%2), 11)
-ROW_IDCT(  64(%0), 72(%0), 80(%0), 88(%0), 64(%1), paddd (%2), 11)
-ROW_IDCT(  96(%0),104(%0),112(%0),120(%0), 96(%1), paddd (%2), 11)*/
-
-DC_COND_ROW_IDCT(  32(%0), 40(%0), 48(%0), 56(%0), 32(%1),paddd (%2), 11)
-DC_COND_ROW_IDCT(  64(%0), 72(%0), 80(%0), 88(%0), 64(%1),paddd (%2), 11)
-DC_COND_ROW_IDCT(  96(%0),104(%0),112(%0),120(%0), 96(%1),paddd (%2), 11)
-
-
-//IDCT(      src0,   src4,   src1,    src5,    dst, shift)
-COL_IDCT(    (%1), 64(%1), 32(%1),  96(%1),  0(%0), 20)
-COL_IDCT(   8(%1), 72(%1), 40(%1), 104(%1),  4(%0), 20)
-COL_IDCT(  16(%1), 80(%1), 48(%1), 112(%1),  8(%0), 20)
-COL_IDCT(  24(%1), 88(%1), 56(%1), 120(%1), 12(%0), 20)
-
-#else
-
-#define DC_COND_IDCT(src0, src4, src1, src5, dst, rounder, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src4 ", %%mm1          \n\t" /* R6     R2      r6      r2 */\
-        "movq " #src1 ", %%mm2          \n\t" /* R3     R1      r3      r1 */\
-        "movq " #src5 ", %%mm3          \n\t" /* R7     R5      r7      r5 */\
-        "movq "MANGLE(wm1010)", %%mm4   \n\t"\
-        "pand %%mm0, %%mm4              \n\t"\
-        "por %%mm1, %%mm4               \n\t"\
-        "por %%mm2, %%mm4               \n\t"\
-        "por %%mm3, %%mm4               \n\t"\
-        "packssdw %%mm4,%%mm4           \n\t"\
-        "movd %%mm4, %%eax              \n\t"\
-        "orl %%eax, %%eax               \n\t"\
-        "jz 1f                          \n\t"\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm5             \n\t" /* C6     C2      C6      C2 */\
-        "pmaddwd %%mm1, %%mm5           \n\t" /* C6R6+C2R2      C6r6+C2r2 */\
-        "movq 40(%2), %%mm6             \n\t" /* -C2    C6      -C2     C6 */\
-        "pmaddwd %%mm6, %%mm1           \n\t" /* -C2R6+C6R2     -C2r6+C6r2 */\
-        "movq 48(%2), %%mm7             \n\t" /* C3     C1      C3      C1 */\
-        "pmaddwd %%mm2, %%mm7           \n\t" /* C3R3+C1R1      C3r3+C1r1 */\
-        #rounder ", %%mm4               \n\t"\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "paddd %%mm5, %%mm4             \n\t" /* A0             a0 */\
-        "psubd %%mm5, %%mm6             \n\t" /* A3             a3 */\
-        "movq 56(%2), %%mm5             \n\t" /* C7     C5      C7      C5 */\
-        "pmaddwd %%mm3, %%mm5           \n\t" /* C7R7+C5R5      C7r7+C5r5 */\
-        #rounder ", %%mm0               \n\t"\
-        "paddd %%mm0, %%mm1             \n\t" /* A1             a1 */\
-        "paddd %%mm0, %%mm0             \n\t" \
-        "psubd %%mm1, %%mm0             \n\t" /* A2             a2 */\
-        "pmaddwd 64(%2), %%mm2          \n\t" /* -C7R3+C3R1     -C7r3+C3r1 */\
-        "paddd %%mm5, %%mm7             \n\t" /* B0             b0 */\
-        "movq 72(%2), %%mm5             \n\t" /* -C5    -C1     -C5     -C1 */\
-        "pmaddwd %%mm3, %%mm5           \n\t" /* -C5R7-C1R5     -C5r7-C1r5 */\
-        "paddd %%mm4, %%mm7             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm7, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "paddd %%mm2, %%mm5             \n\t" /* B1             b1 */\
-        "psrad $" #shift ", %%mm7       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm1, %%mm2              \n\t" /* A1             a1 */\
-        "paddd %%mm5, %%mm1             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm5, %%mm2             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm1, %%mm7          \n\t" /* A1+B1  a1+b1   A0+B0   a0+b0 */\
-        "packssdw %%mm4, %%mm2          \n\t" /* A0-B0  a0-b0   A1-B1   a1-b1 */\
-        "movq %%mm7, " #dst "           \n\t"\
-        "movq " #src1 ", %%mm1          \n\t" /* R3     R1      r3      r1 */\
-        "movq 80(%2), %%mm4             \n\t" /* -C1    C5      -C1     C5 */\
-        "movq %%mm2, 24+" #dst "        \n\t"\
-        "pmaddwd %%mm1, %%mm4           \n\t" /* -C1R3+C5R1     -C1r3+C5r1 */\
-        "movq 88(%2), %%mm7             \n\t" /* C3     C7      C3      C7 */\
-        "pmaddwd 96(%2), %%mm1          \n\t" /* -C5R3+C7R1     -C5r3+C7r1 */\
-        "pmaddwd %%mm3, %%mm7           \n\t" /* C3R7+C7R5      C3r7+C7r5 */\
-        "movq %%mm0, %%mm2              \n\t" /* A2             a2 */\
-        "pmaddwd 104(%2), %%mm3         \n\t" /* -C1R7+C3R5     -C1r7+C3r5 */\
-        "paddd %%mm7, %%mm4             \n\t" /* B2             b2 */\
-        "paddd %%mm4, %%mm2             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm4, %%mm0             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "movq %%mm6, %%mm4              \n\t" /* A3             a3 */\
-        "paddd %%mm1, %%mm3             \n\t" /* B3             b3 */\
-        "paddd %%mm3, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm3, %%mm4             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "packssdw %%mm6, %%mm2          \n\t" /* A3+B3  a3+b3   A2+B2   a2+b2 */\
-        "movq %%mm2, 8+" #dst "         \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "packssdw %%mm0, %%mm4          \n\t" /* A2-B2  a2-b2   A3-B3   a3-b3 */\
-        "movq %%mm4, 16+" #dst "        \n\t"\
-        "jmp 2f                         \n\t"\
-        "1:                             \n\t"\
-        "pslld $16, %%mm0               \n\t"\
-        "paddd "MANGLE(d40000)", %%mm0  \n\t"\
-        "psrad $13, %%mm0               \n\t"\
-        "packssdw %%mm0, %%mm0          \n\t"\
-        "movq %%mm0, " #dst "           \n\t"\
-        "movq %%mm0, 8+" #dst "         \n\t"\
-        "movq %%mm0, 16+" #dst "        \n\t"\
-        "movq %%mm0, 24+" #dst "        \n\t"\
-        "2:                             \n\t"
-
-#define Z_COND_IDCT(src0, src4, src1, src5, dst, rounder, shift, bt) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src4 ", %%mm1          \n\t" /* R6     R2      r6      r2 */\
-        "movq " #src1 ", %%mm2          \n\t" /* R3     R1      r3      r1 */\
-        "movq " #src5 ", %%mm3          \n\t" /* R7     R5      r7      r5 */\
-        "movq %%mm0, %%mm4              \n\t"\
-        "por %%mm1, %%mm4               \n\t"\
-        "por %%mm2, %%mm4               \n\t"\
-        "por %%mm3, %%mm4               \n\t"\
-        "packssdw %%mm4,%%mm4           \n\t"\
-        "movd %%mm4, %%eax              \n\t"\
-        "orl %%eax, %%eax               \n\t"\
-        "jz " #bt "                     \n\t"\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm5             \n\t" /* C6     C2      C6      C2 */\
-        "pmaddwd %%mm1, %%mm5           \n\t" /* C6R6+C2R2      C6r6+C2r2 */\
-        "movq 40(%2), %%mm6             \n\t" /* -C2    C6      -C2     C6 */\
-        "pmaddwd %%mm6, %%mm1           \n\t" /* -C2R6+C6R2     -C2r6+C6r2 */\
-        "movq 48(%2), %%mm7             \n\t" /* C3     C1      C3      C1 */\
-        "pmaddwd %%mm2, %%mm7           \n\t" /* C3R3+C1R1      C3r3+C1r1 */\
-        #rounder ", %%mm4               \n\t"\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "paddd %%mm5, %%mm4             \n\t" /* A0             a0 */\
-        "psubd %%mm5, %%mm6             \n\t" /* A3             a3 */\
-        "movq 56(%2), %%mm5             \n\t" /* C7     C5      C7      C5 */\
-        "pmaddwd %%mm3, %%mm5           \n\t" /* C7R7+C5R5      C7r7+C5r5 */\
-        #rounder ", %%mm0               \n\t"\
-        "paddd %%mm0, %%mm1             \n\t" /* A1             a1 */\
-        "paddd %%mm0, %%mm0             \n\t" \
-        "psubd %%mm1, %%mm0             \n\t" /* A2             a2 */\
-        "pmaddwd 64(%2), %%mm2          \n\t" /* -C7R3+C3R1     -C7r3+C3r1 */\
-        "paddd %%mm5, %%mm7             \n\t" /* B0             b0 */\
-        "movq 72(%2), %%mm5             \n\t" /* -C5    -C1     -C5     -C1 */\
-        "pmaddwd %%mm3, %%mm5           \n\t" /* -C5R7-C1R5     -C5r7-C1r5 */\
-        "paddd %%mm4, %%mm7             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm7, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "paddd %%mm2, %%mm5             \n\t" /* B1             b1 */\
-        "psrad $" #shift ", %%mm7       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm1, %%mm2              \n\t" /* A1             a1 */\
-        "paddd %%mm5, %%mm1             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm5, %%mm2             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm1, %%mm7          \n\t" /* A1+B1  a1+b1   A0+B0   a0+b0 */\
-        "packssdw %%mm4, %%mm2          \n\t" /* A0-B0  a0-b0   A1-B1   a1-b1 */\
-        "movq %%mm7, " #dst "           \n\t"\
-        "movq " #src1 ", %%mm1          \n\t" /* R3     R1      r3      r1 */\
-        "movq 80(%2), %%mm4             \n\t" /* -C1    C5      -C1     C5 */\
-        "movq %%mm2, 24+" #dst "        \n\t"\
-        "pmaddwd %%mm1, %%mm4           \n\t" /* -C1R3+C5R1     -C1r3+C5r1 */\
-        "movq 88(%2), %%mm7             \n\t" /* C3     C7      C3      C7 */\
-        "pmaddwd 96(%2), %%mm1          \n\t" /* -C5R3+C7R1     -C5r3+C7r1 */\
-        "pmaddwd %%mm3, %%mm7           \n\t" /* C3R7+C7R5      C3r7+C7r5 */\
-        "movq %%mm0, %%mm2              \n\t" /* A2             a2 */\
-        "pmaddwd 104(%2), %%mm3         \n\t" /* -C1R7+C3R5     -C1r7+C3r5 */\
-        "paddd %%mm7, %%mm4             \n\t" /* B2             b2 */\
-        "paddd %%mm4, %%mm2             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm4, %%mm0             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "movq %%mm6, %%mm4              \n\t" /* A3             a3 */\
-        "paddd %%mm1, %%mm3             \n\t" /* B3             b3 */\
-        "paddd %%mm3, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm3, %%mm4             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "packssdw %%mm6, %%mm2          \n\t" /* A3+B3  a3+b3   A2+B2   a2+b2 */\
-        "movq %%mm2, 8+" #dst "         \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "packssdw %%mm0, %%mm4          \n\t" /* A2-B2  a2-b2   A3-B3   a3-b3 */\
-        "movq %%mm4, 16+" #dst "        \n\t"\
-
-#define ROW_IDCT(src0, src4, src1, src5, dst, rounder, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src4 ", %%mm1          \n\t" /* R6     R2      r6      r2 */\
-        "movq " #src1 ", %%mm2          \n\t" /* R3     R1      r3      r1 */\
-        "movq " #src5 ", %%mm3          \n\t" /* R7     R5      r7      r5 */\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm5             \n\t" /* C6     C2      C6      C2 */\
-        "pmaddwd %%mm1, %%mm5           \n\t" /* C6R6+C2R2      C6r6+C2r2 */\
-        "movq 40(%2), %%mm6             \n\t" /* -C2    C6      -C2     C6 */\
-        "pmaddwd %%mm6, %%mm1           \n\t" /* -C2R6+C6R2     -C2r6+C6r2 */\
-        "movq 48(%2), %%mm7             \n\t" /* C3     C1      C3      C1 */\
-        "pmaddwd %%mm2, %%mm7           \n\t" /* C3R3+C1R1      C3r3+C1r1 */\
-        #rounder ", %%mm4               \n\t"\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "paddd %%mm5, %%mm4             \n\t" /* A0             a0 */\
-        "psubd %%mm5, %%mm6             \n\t" /* A3             a3 */\
-        "movq 56(%2), %%mm5             \n\t" /* C7     C5      C7      C5 */\
-        "pmaddwd %%mm3, %%mm5           \n\t" /* C7R7+C5R5      C7r7+C5r5 */\
-        #rounder ", %%mm0               \n\t"\
-        "paddd %%mm0, %%mm1             \n\t" /* A1             a1 */\
-        "paddd %%mm0, %%mm0             \n\t" \
-        "psubd %%mm1, %%mm0             \n\t" /* A2             a2 */\
-        "pmaddwd 64(%2), %%mm2          \n\t" /* -C7R3+C3R1     -C7r3+C3r1 */\
-        "paddd %%mm5, %%mm7             \n\t" /* B0             b0 */\
-        "movq 72(%2), %%mm5             \n\t" /* -C5    -C1     -C5     -C1 */\
-        "pmaddwd %%mm3, %%mm5           \n\t" /* -C5R7-C1R5     -C5r7-C1r5 */\
-        "paddd %%mm4, %%mm7             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm7, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "paddd %%mm2, %%mm5             \n\t" /* B1             b1 */\
-        "psrad $" #shift ", %%mm7       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm1, %%mm2              \n\t" /* A1             a1 */\
-        "paddd %%mm5, %%mm1             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm5, %%mm2             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm1, %%mm7          \n\t" /* A1+B1  a1+b1   A0+B0   a0+b0 */\
-        "packssdw %%mm4, %%mm2          \n\t" /* A0-B0  a0-b0   A1-B1   a1-b1 */\
-        "movq %%mm7, " #dst "           \n\t"\
-        "movq " #src1 ", %%mm1          \n\t" /* R3     R1      r3      r1 */\
-        "movq 80(%2), %%mm4             \n\t" /* -C1    C5      -C1     C5 */\
-        "movq %%mm2, 24+" #dst "        \n\t"\
-        "pmaddwd %%mm1, %%mm4           \n\t" /* -C1R3+C5R1     -C1r3+C5r1 */\
-        "movq 88(%2), %%mm7             \n\t" /* C3     C7      C3      C7 */\
-        "pmaddwd 96(%2), %%mm1          \n\t" /* -C5R3+C7R1     -C5r3+C7r1 */\
-        "pmaddwd %%mm3, %%mm7           \n\t" /* C3R7+C7R5      C3r7+C7r5 */\
-        "movq %%mm0, %%mm2              \n\t" /* A2             a2 */\
-        "pmaddwd 104(%2), %%mm3         \n\t" /* -C1R7+C3R5     -C1r7+C3r5 */\
-        "paddd %%mm7, %%mm4             \n\t" /* B2             b2 */\
-        "paddd %%mm4, %%mm2             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm4, %%mm0             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "movq %%mm6, %%mm4              \n\t" /* A3             a3 */\
-        "paddd %%mm1, %%mm3             \n\t" /* B3             b3 */\
-        "paddd %%mm3, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm3, %%mm4             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "packssdw %%mm6, %%mm2          \n\t" /* A3+B3  a3+b3   A2+B2   a2+b2 */\
-        "movq %%mm2, 8+" #dst "         \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "packssdw %%mm0, %%mm4          \n\t" /* A2-B2  a2-b2   A3-B3   a3-b3 */\
-        "movq %%mm4, 16+" #dst "        \n\t"\
-
-//IDCT(         src0,   src4,   src1,   src5,    dst,   rounder, shift)
-DC_COND_IDCT(  0(%0),  8(%0), 16(%0), 24(%0),  0(%1),paddd 8(%2), 11)
-Z_COND_IDCT(  32(%0), 40(%0), 48(%0), 56(%0), 32(%1),paddd (%2), 11, 4f)
-Z_COND_IDCT(  64(%0), 72(%0), 80(%0), 88(%0), 64(%1),paddd (%2), 11, 2f)
-Z_COND_IDCT(  96(%0),104(%0),112(%0),120(%0), 96(%1),paddd (%2), 11, 1f)
-
-#undef IDCT
-#define IDCT(src0, src4, src1, src5, dst, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src4 ", %%mm1          \n\t" /* R6     R2      r6      r2 */\
-        "movq " #src1 ", %%mm2          \n\t" /* R3     R1      r3      r1 */\
-        "movq " #src5 ", %%mm3          \n\t" /* R7     R5      r7      r5 */\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm5             \n\t" /* C6     C2      C6      C2 */\
-        "pmaddwd %%mm1, %%mm5           \n\t" /* C6R6+C2R2      C6r6+C2r2 */\
-        "movq 40(%2), %%mm6             \n\t" /* -C2    C6      -C2     C6 */\
-        "pmaddwd %%mm6, %%mm1           \n\t" /* -C2R6+C6R2     -C2r6+C6r2 */\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 48(%2), %%mm7             \n\t" /* C3     C1      C3      C1 */\
-        "pmaddwd %%mm2, %%mm7           \n\t" /* C3R3+C1R1      C3r3+C1r1 */\
-        "paddd %%mm5, %%mm4             \n\t" /* A0             a0 */\
-        "psubd %%mm5, %%mm6             \n\t" /* A3             a3 */\
-        "movq %%mm0, %%mm5              \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "paddd %%mm1, %%mm0             \n\t" /* A1             a1 */\
-        "psubd %%mm1, %%mm5             \n\t" /* A2             a2 */\
-        "movq 56(%2), %%mm1             \n\t" /* C7     C5      C7      C5 */\
-        "pmaddwd %%mm3, %%mm1           \n\t" /* C7R7+C5R5      C7r7+C5r5 */\
-        "pmaddwd 64(%2), %%mm2          \n\t" /* -C7R3+C3R1     -C7r3+C3r1 */\
-        "paddd %%mm1, %%mm7             \n\t" /* B0             b0 */\
-        "movq 72(%2), %%mm1             \n\t" /* -C5    -C1     -C5     -C1 */\
-        "pmaddwd %%mm3, %%mm1           \n\t" /* -C5R7-C1R5     -C5r7-C1r5 */\
-        "paddd %%mm4, %%mm7             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm7, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "paddd %%mm2, %%mm1             \n\t" /* B1             b1 */\
-        "psrad $" #shift ", %%mm7       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm0, %%mm2              \n\t" /* A1             a1 */\
-        "paddd %%mm1, %%mm0             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm1, %%mm2             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm7, %%mm7          \n\t" /* A0+B0  a0+b0 */\
-        "movd %%mm7, " #dst "           \n\t"\
-        "packssdw %%mm0, %%mm0          \n\t" /* A1+B1  a1+b1 */\
-        "movd %%mm0, 16+" #dst "        \n\t"\
-        "packssdw %%mm2, %%mm2          \n\t" /* A1-B1  a1-b1 */\
-        "movd %%mm2, 96+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A0-B0  a0-b0 */\
-        "movd %%mm4, 112+" #dst "       \n\t"\
-        "movq " #src1 ", %%mm0          \n\t" /* R3     R1      r3      r1 */\
-        "movq 80(%2), %%mm4             \n\t" /* -C1    C5      -C1     C5 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* -C1R3+C5R1     -C1r3+C5r1 */\
-        "movq 88(%2), %%mm7             \n\t" /* C3     C7      C3      C7 */\
-        "pmaddwd 96(%2), %%mm0          \n\t" /* -C5R3+C7R1     -C5r3+C7r1 */\
-        "pmaddwd %%mm3, %%mm7           \n\t" /* C3R7+C7R5      C3r7+C7r5 */\
-        "movq %%mm5, %%mm2              \n\t" /* A2             a2 */\
-        "pmaddwd 104(%2), %%mm3         \n\t" /* -C1R7+C3R5     -C1r7+C3r5 */\
-        "paddd %%mm7, %%mm4             \n\t" /* B2             b2 */\
-        "paddd %%mm4, %%mm2             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm4, %%mm5             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "psrad $" #shift ", %%mm5       \n\t"\
-        "movq %%mm6, %%mm4              \n\t" /* A3             a3 */\
-        "paddd %%mm0, %%mm3             \n\t" /* B3             b3 */\
-        "paddd %%mm3, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm3, %%mm4             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "packssdw %%mm2, %%mm2          \n\t" /* A2+B2  a2+b2 */\
-        "packssdw %%mm6, %%mm6          \n\t" /* A3+B3  a3+b3 */\
-        "movd %%mm2, 32+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A3-B3  a3-b3 */\
-        "packssdw %%mm5, %%mm5          \n\t" /* A2-B2  a2-b2 */\
-        "movd %%mm6, 48+" #dst "        \n\t"\
-        "movd %%mm4, 64+" #dst "        \n\t"\
-        "movd %%mm5, 80+" #dst "        \n\t"
-
-
-//IDCT(  src0,   src4,   src1,    src5,    dst, shift)
-IDCT(    (%1), 64(%1), 32(%1),  96(%1),  0(%0), 20)
-IDCT(   8(%1), 72(%1), 40(%1), 104(%1),  4(%0), 20)
-IDCT(  16(%1), 80(%1), 48(%1), 112(%1),  8(%0), 20)
-IDCT(  24(%1), 88(%1), 56(%1), 120(%1), 12(%0), 20)
-        "jmp 9f                         \n\t"
-
-        "# .p2align 4                   \n\t"\
-        "4:                             \n\t"
-Z_COND_IDCT(  64(%0), 72(%0), 80(%0), 88(%0), 64(%1),paddd (%2), 11, 6f)
-Z_COND_IDCT(  96(%0),104(%0),112(%0),120(%0), 96(%1),paddd (%2), 11, 5f)
-
-#undef IDCT
-#define IDCT(src0, src4, src1, src5, dst, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src4 ", %%mm1          \n\t" /* R6     R2      r6      r2 */\
-        "movq " #src5 ", %%mm3          \n\t" /* R7     R5      r7      r5 */\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm5             \n\t" /* C6     C2      C6      C2 */\
-        "pmaddwd %%mm1, %%mm5           \n\t" /* C6R6+C2R2      C6r6+C2r2 */\
-        "movq 40(%2), %%mm6             \n\t" /* -C2    C6      -C2     C6 */\
-        "pmaddwd %%mm6, %%mm1           \n\t" /* -C2R6+C6R2     -C2r6+C6r2 */\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "paddd %%mm5, %%mm4             \n\t" /* A0             a0 */\
-        "psubd %%mm5, %%mm6             \n\t" /* A3             a3 */\
-        "movq %%mm0, %%mm5              \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "paddd %%mm1, %%mm0             \n\t" /* A1             a1 */\
-        "psubd %%mm1, %%mm5             \n\t" /* A2             a2 */\
-        "movq 56(%2), %%mm1             \n\t" /* C7     C5      C7      C5 */\
-        "pmaddwd %%mm3, %%mm1           \n\t" /* C7R7+C5R5      C7r7+C5r5 */\
-        "movq 72(%2), %%mm7             \n\t" /* -C5    -C1     -C5     -C1 */\
-        "pmaddwd %%mm3, %%mm7           \n\t" /* -C5R7-C1R5     -C5r7-C1r5 */\
-        "paddd %%mm4, %%mm1             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm1, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm0, %%mm2              \n\t" /* A1             a1 */\
-        "paddd %%mm7, %%mm0             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm7, %%mm2             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm1, %%mm1          \n\t" /* A0+B0  a0+b0 */\
-        "movd %%mm1, " #dst "           \n\t"\
-        "packssdw %%mm0, %%mm0          \n\t" /* A1+B1  a1+b1 */\
-        "movd %%mm0, 16+" #dst "        \n\t"\
-        "packssdw %%mm2, %%mm2          \n\t" /* A1-B1  a1-b1 */\
-        "movd %%mm2, 96+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A0-B0  a0-b0 */\
-        "movd %%mm4, 112+" #dst "       \n\t"\
-        "movq 88(%2), %%mm1             \n\t" /* C3     C7      C3      C7 */\
-        "pmaddwd %%mm3, %%mm1           \n\t" /* C3R7+C7R5      C3r7+C7r5 */\
-        "movq %%mm5, %%mm2              \n\t" /* A2             a2 */\
-        "pmaddwd 104(%2), %%mm3         \n\t" /* -C1R7+C3R5     -C1r7+C3r5 */\
-        "paddd %%mm1, %%mm2             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm1, %%mm5             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "psrad $" #shift ", %%mm5       \n\t"\
-        "movq %%mm6, %%mm1              \n\t" /* A3             a3 */\
-        "paddd %%mm3, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm3, %%mm1             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "packssdw %%mm2, %%mm2          \n\t" /* A2+B2  a2+b2 */\
-        "packssdw %%mm6, %%mm6          \n\t" /* A3+B3  a3+b3 */\
-        "movd %%mm2, 32+" #dst "        \n\t"\
-        "packssdw %%mm1, %%mm1          \n\t" /* A3-B3  a3-b3 */\
-        "packssdw %%mm5, %%mm5          \n\t" /* A2-B2  a2-b2 */\
-        "movd %%mm6, 48+" #dst "        \n\t"\
-        "movd %%mm1, 64+" #dst "        \n\t"\
-        "movd %%mm5, 80+" #dst "        \n\t"
-
-//IDCT(  src0,   src4,   src1,    src5,    dst, shift)
-IDCT(    (%1), 64(%1), 32(%1),  96(%1),  0(%0), 20)
-IDCT(   8(%1), 72(%1), 40(%1), 104(%1),  4(%0), 20)
-IDCT(  16(%1), 80(%1), 48(%1), 112(%1),  8(%0), 20)
-IDCT(  24(%1), 88(%1), 56(%1), 120(%1), 12(%0), 20)
-        "jmp 9f                         \n\t"
-
-        "# .p2align 4                   \n\t"\
-        "6:                             \n\t"
-Z_COND_IDCT(  96(%0),104(%0),112(%0),120(%0), 96(%1),paddd (%2), 11, 7f)
-
-#undef IDCT
-#define IDCT(src0, src4, src1, src5, dst, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src5 ", %%mm3          \n\t" /* R7     R5      r7      r5 */\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq %%mm0, %%mm5              \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 56(%2), %%mm1             \n\t" /* C7     C5      C7      C5 */\
-        "pmaddwd %%mm3, %%mm1           \n\t" /* C7R7+C5R5      C7r7+C5r5 */\
-        "movq 72(%2), %%mm7             \n\t" /* -C5    -C1     -C5     -C1 */\
-        "pmaddwd %%mm3, %%mm7           \n\t" /* -C5R7-C1R5     -C5r7-C1r5 */\
-        "paddd %%mm4, %%mm1             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm1, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm0, %%mm2              \n\t" /* A1             a1 */\
-        "paddd %%mm7, %%mm0             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm7, %%mm2             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm1, %%mm1          \n\t" /* A0+B0  a0+b0 */\
-        "movd %%mm1, " #dst "           \n\t"\
-        "packssdw %%mm0, %%mm0          \n\t" /* A1+B1  a1+b1 */\
-        "movd %%mm0, 16+" #dst "        \n\t"\
-        "packssdw %%mm2, %%mm2          \n\t" /* A1-B1  a1-b1 */\
-        "movd %%mm2, 96+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A0-B0  a0-b0 */\
-        "movd %%mm4, 112+" #dst "       \n\t"\
-        "movq 88(%2), %%mm1             \n\t" /* C3     C7      C3      C7 */\
-        "pmaddwd %%mm3, %%mm1           \n\t" /* C3R7+C7R5      C3r7+C7r5 */\
-        "movq %%mm5, %%mm2              \n\t" /* A2             a2 */\
-        "pmaddwd 104(%2), %%mm3         \n\t" /* -C1R7+C3R5     -C1r7+C3r5 */\
-        "paddd %%mm1, %%mm2             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm1, %%mm5             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "psrad $" #shift ", %%mm5       \n\t"\
-        "movq %%mm6, %%mm1              \n\t" /* A3             a3 */\
-        "paddd %%mm3, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm3, %%mm1             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "packssdw %%mm2, %%mm2          \n\t" /* A2+B2  a2+b2 */\
-        "packssdw %%mm6, %%mm6          \n\t" /* A3+B3  a3+b3 */\
-        "movd %%mm2, 32+" #dst "        \n\t"\
-        "packssdw %%mm1, %%mm1          \n\t" /* A3-B3  a3-b3 */\
-        "packssdw %%mm5, %%mm5          \n\t" /* A2-B2  a2-b2 */\
-        "movd %%mm6, 48+" #dst "        \n\t"\
-        "movd %%mm1, 64+" #dst "        \n\t"\
-        "movd %%mm5, 80+" #dst "        \n\t"
-
-
-//IDCT(  src0,   src4,   src1,    src5,    dst, shift)
-IDCT(    (%1), 64(%1), 32(%1),  96(%1),  0(%0), 20)
-IDCT(   8(%1), 72(%1), 40(%1), 104(%1),  4(%0), 20)
-IDCT(  16(%1), 80(%1), 48(%1), 112(%1),  8(%0), 20)
-IDCT(  24(%1), 88(%1), 56(%1), 120(%1), 12(%0), 20)
-        "jmp 9f                         \n\t"
-
-        "# .p2align 4                   \n\t"\
-        "2:                             \n\t"
-Z_COND_IDCT(  96(%0),104(%0),112(%0),120(%0), 96(%1),paddd (%2), 11, 3f)
-
-#undef IDCT
-#define IDCT(src0, src4, src1, src5, dst, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src1 ", %%mm2          \n\t" /* R3     R1      r3      r1 */\
-        "movq " #src5 ", %%mm3          \n\t" /* R7     R5      r7      r5 */\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 48(%2), %%mm7             \n\t" /* C3     C1      C3      C1 */\
-        "pmaddwd %%mm2, %%mm7           \n\t" /* C3R3+C1R1      C3r3+C1r1 */\
-        "movq %%mm0, %%mm5              \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 56(%2), %%mm1             \n\t" /* C7     C5      C7      C5 */\
-        "pmaddwd %%mm3, %%mm1           \n\t" /* C7R7+C5R5      C7r7+C5r5 */\
-        "pmaddwd 64(%2), %%mm2          \n\t" /* -C7R3+C3R1     -C7r3+C3r1 */\
-        "paddd %%mm1, %%mm7             \n\t" /* B0             b0 */\
-        "movq 72(%2), %%mm1             \n\t" /* -C5    -C1     -C5     -C1 */\
-        "pmaddwd %%mm3, %%mm1           \n\t" /* -C5R7-C1R5     -C5r7-C1r5 */\
-        "paddd %%mm4, %%mm7             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm7, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "paddd %%mm2, %%mm1             \n\t" /* B1             b1 */\
-        "psrad $" #shift ", %%mm7       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm0, %%mm2              \n\t" /* A1             a1 */\
-        "paddd %%mm1, %%mm0             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm1, %%mm2             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm7, %%mm7          \n\t" /* A0+B0  a0+b0 */\
-        "movd %%mm7, " #dst "           \n\t"\
-        "packssdw %%mm0, %%mm0          \n\t" /* A1+B1  a1+b1 */\
-        "movd %%mm0, 16+" #dst "        \n\t"\
-        "packssdw %%mm2, %%mm2          \n\t" /* A1-B1  a1-b1 */\
-        "movd %%mm2, 96+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A0-B0  a0-b0 */\
-        "movd %%mm4, 112+" #dst "       \n\t"\
-        "movq " #src1 ", %%mm0          \n\t" /* R3     R1      r3      r1 */\
-        "movq 80(%2), %%mm4             \n\t" /* -C1    C5      -C1     C5 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* -C1R3+C5R1     -C1r3+C5r1 */\
-        "movq 88(%2), %%mm7             \n\t" /* C3     C7      C3      C7 */\
-        "pmaddwd 96(%2), %%mm0          \n\t" /* -C5R3+C7R1     -C5r3+C7r1 */\
-        "pmaddwd %%mm3, %%mm7           \n\t" /* C3R7+C7R5      C3r7+C7r5 */\
-        "movq %%mm5, %%mm2              \n\t" /* A2             a2 */\
-        "pmaddwd 104(%2), %%mm3         \n\t" /* -C1R7+C3R5     -C1r7+C3r5 */\
-        "paddd %%mm7, %%mm4             \n\t" /* B2             b2 */\
-        "paddd %%mm4, %%mm2             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm4, %%mm5             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "psrad $" #shift ", %%mm5       \n\t"\
-        "movq %%mm6, %%mm4              \n\t" /* A3             a3 */\
-        "paddd %%mm0, %%mm3             \n\t" /* B3             b3 */\
-        "paddd %%mm3, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm3, %%mm4             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "packssdw %%mm2, %%mm2          \n\t" /* A2+B2  a2+b2 */\
-        "packssdw %%mm6, %%mm6          \n\t" /* A3+B3  a3+b3 */\
-        "movd %%mm2, 32+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A3-B3  a3-b3 */\
-        "packssdw %%mm5, %%mm5          \n\t" /* A2-B2  a2-b2 */\
-        "movd %%mm6, 48+" #dst "        \n\t"\
-        "movd %%mm4, 64+" #dst "        \n\t"\
-        "movd %%mm5, 80+" #dst "        \n\t"
-
-//IDCT(  src0,   src4,   src1,    src5,    dst, shift)
-IDCT(    (%1), 64(%1), 32(%1),  96(%1),  0(%0), 20)
-IDCT(   8(%1), 72(%1), 40(%1), 104(%1),  4(%0), 20)
-IDCT(  16(%1), 80(%1), 48(%1), 112(%1),  8(%0), 20)
-IDCT(  24(%1), 88(%1), 56(%1), 120(%1), 12(%0), 20)
-        "jmp 9f                         \n\t"
-
-        "# .p2align 4                   \n\t"\
-        "3:                             \n\t"
-#undef IDCT
-#define IDCT(src0, src4, src1, src5, dst, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src1 ", %%mm2          \n\t" /* R3     R1      r3      r1 */\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 48(%2), %%mm7             \n\t" /* C3     C1      C3      C1 */\
-        "pmaddwd %%mm2, %%mm7           \n\t" /* C3R3+C1R1      C3r3+C1r1 */\
-        "movq %%mm0, %%mm5              \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 64(%2), %%mm3             \n\t"\
-        "pmaddwd %%mm2, %%mm3           \n\t" /* -C7R3+C3R1     -C7r3+C3r1 */\
-        "paddd %%mm4, %%mm7             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm7, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "psrad $" #shift ", %%mm7       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm0, %%mm1              \n\t" /* A1             a1 */\
-        "paddd %%mm3, %%mm0             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm3, %%mm1             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "packssdw %%mm7, %%mm7          \n\t" /* A0+B0  a0+b0 */\
-        "movd %%mm7, " #dst "           \n\t"\
-        "packssdw %%mm0, %%mm0          \n\t" /* A1+B1  a1+b1 */\
-        "movd %%mm0, 16+" #dst "        \n\t"\
-        "packssdw %%mm1, %%mm1          \n\t" /* A1-B1  a1-b1 */\
-        "movd %%mm1, 96+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A0-B0  a0-b0 */\
-        "movd %%mm4, 112+" #dst "       \n\t"\
-        "movq 80(%2), %%mm4             \n\t" /* -C1    C5      -C1     C5 */\
-        "pmaddwd %%mm2, %%mm4           \n\t" /* -C1R3+C5R1     -C1r3+C5r1 */\
-        "pmaddwd 96(%2), %%mm2          \n\t" /* -C5R3+C7R1     -C5r3+C7r1 */\
-        "movq %%mm5, %%mm1              \n\t" /* A2             a2 */\
-        "paddd %%mm4, %%mm1             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm4, %%mm5             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "psrad $" #shift ", %%mm5       \n\t"\
-        "movq %%mm6, %%mm4              \n\t" /* A3             a3 */\
-        "paddd %%mm2, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm2, %%mm4             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "packssdw %%mm1, %%mm1          \n\t" /* A2+B2  a2+b2 */\
-        "packssdw %%mm6, %%mm6          \n\t" /* A3+B3  a3+b3 */\
-        "movd %%mm1, 32+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A3-B3  a3-b3 */\
-        "packssdw %%mm5, %%mm5          \n\t" /* A2-B2  a2-b2 */\
-        "movd %%mm6, 48+" #dst "        \n\t"\
-        "movd %%mm4, 64+" #dst "        \n\t"\
-        "movd %%mm5, 80+" #dst "        \n\t"
-
-
-//IDCT(  src0,   src4,   src1,    src5,    dst, shift)
-IDCT(    (%1), 64(%1), 32(%1),  96(%1),  0(%0), 20)
-IDCT(   8(%1), 72(%1), 40(%1), 104(%1),  4(%0), 20)
-IDCT(  16(%1), 80(%1), 48(%1), 112(%1),  8(%0), 20)
-IDCT(  24(%1), 88(%1), 56(%1), 120(%1), 12(%0), 20)
-        "jmp 9f                         \n\t"
-
-        "# .p2align 4                   \n\t"\
-        "5:                             \n\t"
-#undef IDCT
-#define IDCT(src0, src4, src1, src5, dst, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src4 ", %%mm1          \n\t" /* R6     R2      r6      r2 */\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm5             \n\t" /* C6     C2      C6      C2 */\
-        "pmaddwd %%mm1, %%mm5           \n\t" /* C6R6+C2R2      C6r6+C2r2 */\
-        "movq 40(%2), %%mm6             \n\t" /* -C2    C6      -C2     C6 */\
-        "pmaddwd %%mm6, %%mm1           \n\t" /* -C2R6+C6R2     -C2r6+C6r2 */\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "paddd %%mm5, %%mm4             \n\t" /* A0             a0 */\
-        "psubd %%mm5, %%mm6             \n\t" /* A3             a3 */\
-        "movq %%mm0, %%mm5              \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "paddd %%mm1, %%mm0             \n\t" /* A1             a1 */\
-        "psubd %%mm1, %%mm5             \n\t" /* A2             a2 */\
-        "movq 8+" #src0 ", %%mm2        \n\t" /* R4     R0      r4      r0 */\
-        "movq 8+" #src4 ", %%mm3        \n\t" /* R6     R2      r6      r2 */\
-        "movq 16(%2), %%mm1             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm2, %%mm1           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm7             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm7, %%mm2           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm7             \n\t" /* C6     C2      C6      C2 */\
-        "pmaddwd %%mm3, %%mm7           \n\t" /* C6R6+C2R2      C6r6+C2r2 */\
-        "pmaddwd 40(%2), %%mm3          \n\t" /* -C2R6+C6R2     -C2r6+C6r2 */\
-        "paddd %%mm1, %%mm7             \n\t" /* A0             a0 */\
-        "paddd %%mm1, %%mm1             \n\t" /* 2C0            2c0 */\
-        "psubd %%mm7, %%mm1             \n\t" /* A3             a3 */\
-        "paddd %%mm2, %%mm3             \n\t" /* A1             a1 */\
-        "paddd %%mm2, %%mm2             \n\t" /* 2C1            2c1 */\
-        "psubd %%mm3, %%mm2             \n\t" /* A2             a2 */\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "psrad $" #shift ", %%mm7       \n\t"\
-        "psrad $" #shift ", %%mm3       \n\t"\
-        "packssdw %%mm7, %%mm4          \n\t" /* A0     a0 */\
-        "movq %%mm4, " #dst "           \n\t"\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "packssdw %%mm3, %%mm0          \n\t" /* A1     a1 */\
-        "movq %%mm0, 16+" #dst "        \n\t"\
-        "movq %%mm0, 96+" #dst "        \n\t"\
-        "movq %%mm4, 112+" #dst "       \n\t"\
-        "psrad $" #shift ", %%mm5       \n\t"\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm2, %%mm5          \n\t" /* A2-B2  a2-b2 */\
-        "movq %%mm5, 32+" #dst "        \n\t"\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "packssdw %%mm1, %%mm6          \n\t" /* A3+B3  a3+b3 */\
-        "movq %%mm6, 48+" #dst "        \n\t"\
-        "movq %%mm6, 64+" #dst "        \n\t"\
-        "movq %%mm5, 80+" #dst "        \n\t"
-
-
-//IDCT(  src0,   src4,   src1,    src5,    dst, shift)
-IDCT(    0(%1), 64(%1), 32(%1),  96(%1),  0(%0), 20)
-//IDCT(   8(%1), 72(%1), 40(%1), 104(%1),  4(%0), 20)
-IDCT(  16(%1), 80(%1), 48(%1), 112(%1),  8(%0), 20)
-//IDCT(  24(%1), 88(%1), 56(%1), 120(%1), 12(%0), 20)
-        "jmp 9f                         \n\t"
-
-
-        "# .p2align 4                   \n\t"\
-        "1:                             \n\t"
-#undef IDCT
-#define IDCT(src0, src4, src1, src5, dst, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq " #src4 ", %%mm1          \n\t" /* R6     R2      r6      r2 */\
-        "movq " #src1 ", %%mm2          \n\t" /* R3     R1      r3      r1 */\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm5             \n\t" /* C6     C2      C6      C2 */\
-        "pmaddwd %%mm1, %%mm5           \n\t" /* C6R6+C2R2      C6r6+C2r2 */\
-        "movq 40(%2), %%mm6             \n\t" /* -C2    C6      -C2     C6 */\
-        "pmaddwd %%mm6, %%mm1           \n\t" /* -C2R6+C6R2     -C2r6+C6r2 */\
-        "movq %%mm4, %%mm6              \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 48(%2), %%mm7             \n\t" /* C3     C1      C3      C1 */\
-        "pmaddwd %%mm2, %%mm7           \n\t" /* C3R3+C1R1      C3r3+C1r1 */\
-        "paddd %%mm5, %%mm4             \n\t" /* A0             a0 */\
-        "psubd %%mm5, %%mm6             \n\t" /* A3             a3 */\
-        "movq %%mm0, %%mm5              \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "paddd %%mm1, %%mm0             \n\t" /* A1             a1 */\
-        "psubd %%mm1, %%mm5             \n\t" /* A2             a2 */\
-        "movq 64(%2), %%mm1             \n\t"\
-        "pmaddwd %%mm2, %%mm1           \n\t" /* -C7R3+C3R1     -C7r3+C3r1 */\
-        "paddd %%mm4, %%mm7             \n\t" /* A0+B0          a0+b0 */\
-        "paddd %%mm4, %%mm4             \n\t" /* 2A0            2a0 */\
-        "psubd %%mm7, %%mm4             \n\t" /* A0-B0          a0-b0 */\
-        "psrad $" #shift ", %%mm7       \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "movq %%mm0, %%mm3              \n\t" /* A1             a1 */\
-        "paddd %%mm1, %%mm0             \n\t" /* A1+B1          a1+b1 */\
-        "psubd %%mm1, %%mm3             \n\t" /* A1-B1          a1-b1 */\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "psrad $" #shift ", %%mm3       \n\t"\
-        "packssdw %%mm7, %%mm7          \n\t" /* A0+B0  a0+b0 */\
-        "movd %%mm7, " #dst "           \n\t"\
-        "packssdw %%mm0, %%mm0          \n\t" /* A1+B1  a1+b1 */\
-        "movd %%mm0, 16+" #dst "        \n\t"\
-        "packssdw %%mm3, %%mm3          \n\t" /* A1-B1  a1-b1 */\
-        "movd %%mm3, 96+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A0-B0  a0-b0 */\
-        "movd %%mm4, 112+" #dst "       \n\t"\
-        "movq 80(%2), %%mm4             \n\t" /* -C1    C5      -C1     C5 */\
-        "pmaddwd %%mm2, %%mm4           \n\t" /* -C1R3+C5R1     -C1r3+C5r1 */\
-        "pmaddwd 96(%2), %%mm2          \n\t" /* -C5R3+C7R1     -C5r3+C7r1 */\
-        "movq %%mm5, %%mm3              \n\t" /* A2             a2 */\
-        "paddd %%mm4, %%mm3             \n\t" /* A2+B2          a2+b2 */\
-        "psubd %%mm4, %%mm5             \n\t" /* a2-B2          a2-b2 */\
-        "psrad $" #shift ", %%mm3       \n\t"\
-        "psrad $" #shift ", %%mm5       \n\t"\
-        "movq %%mm6, %%mm4              \n\t" /* A3             a3 */\
-        "paddd %%mm2, %%mm6             \n\t" /* A3+B3          a3+b3 */\
-        "psubd %%mm2, %%mm4             \n\t" /* a3-B3          a3-b3 */\
-        "psrad $" #shift ", %%mm6       \n\t"\
-        "packssdw %%mm3, %%mm3          \n\t" /* A2+B2  a2+b2 */\
-        "movd %%mm3, 32+" #dst "        \n\t"\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "packssdw %%mm6, %%mm6          \n\t" /* A3+B3  a3+b3 */\
-        "movd %%mm6, 48+" #dst "        \n\t"\
-        "packssdw %%mm4, %%mm4          \n\t" /* A3-B3  a3-b3 */\
-        "packssdw %%mm5, %%mm5          \n\t" /* A2-B2  a2-b2 */\
-        "movd %%mm4, 64+" #dst "        \n\t"\
-        "movd %%mm5, 80+" #dst "        \n\t"
-
-
-//IDCT(  src0,   src4,   src1,    src5,    dst, shift)
-IDCT(    (%1), 64(%1), 32(%1),  96(%1),  0(%0), 20)
-IDCT(   8(%1), 72(%1), 40(%1), 104(%1),  4(%0), 20)
-IDCT(  16(%1), 80(%1), 48(%1), 112(%1),  8(%0), 20)
-IDCT(  24(%1), 88(%1), 56(%1), 120(%1), 12(%0), 20)
-        "jmp 9f                         \n\t"
-
-
-        "# .p2align 4                   \n\t"
-        "7:                             \n\t"
-#undef IDCT
-#define IDCT(src0, src4, src1, src5, dst, shift) \
-        "movq " #src0 ", %%mm0          \n\t" /* R4     R0      r4      r0 */\
-        "movq 16(%2), %%mm4             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm0, %%mm4           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm5             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm5, %%mm0           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "psrad $" #shift ", %%mm4       \n\t"\
-        "psrad $" #shift ", %%mm0       \n\t"\
-        "movq 8+" #src0 ", %%mm2        \n\t" /* R4     R0      r4      r0 */\
-        "movq 16(%2), %%mm1             \n\t" /* C4     C4      C4      C4 */\
-        "pmaddwd %%mm2, %%mm1           \n\t" /* C4R4+C4R0      C4r4+C4r0 */\
-        "movq 24(%2), %%mm7             \n\t" /* -C4    C4      -C4     C4 */\
-        "pmaddwd %%mm7, %%mm2           \n\t" /* -C4R4+C4R0     -C4r4+C4r0 */\
-        "movq 32(%2), %%mm7             \n\t" /* C6     C2      C6      C2 */\
-        "psrad $" #shift ", %%mm1       \n\t"\
-        "packssdw %%mm1, %%mm4          \n\t" /* A0     a0 */\
-        "movq %%mm4, " #dst "           \n\t"\
-        "psrad $" #shift ", %%mm2       \n\t"\
-        "packssdw %%mm2, %%mm0          \n\t" /* A1     a1 */\
-        "movq %%mm0, 16+" #dst "        \n\t"\
-        "movq %%mm0, 96+" #dst "        \n\t"\
-        "movq %%mm4, 112+" #dst "       \n\t"\
-        "movq %%mm0, 32+" #dst "        \n\t"\
-        "movq %%mm4, 48+" #dst "        \n\t"\
-        "movq %%mm4, 64+" #dst "        \n\t"\
-        "movq %%mm0, 80+" #dst "        \n\t"
-
-//IDCT(  src0,   src4,   src1,    src5,    dst, shift)
-IDCT(   0(%1), 64(%1), 32(%1),  96(%1),  0(%0), 20)
-//IDCT(   8(%1), 72(%1), 40(%1), 104(%1),  4(%0), 20)
-IDCT(  16(%1), 80(%1), 48(%1), 112(%1),  8(%0), 20)
-//IDCT(  24(%1), 88(%1), 56(%1), 120(%1), 12(%0), 20)
-
-
-#endif
-
-/*
-Input
- 00 40 04 44 20 60 24 64
- 10 30 14 34 50 70 54 74
- 01 41 03 43 21 61 23 63
- 11 31 13 33 51 71 53 73
- 02 42 06 46 22 62 26 66
- 12 32 16 36 52 72 56 76
- 05 45 07 47 25 65 27 67
- 15 35 17 37 55 75 57 77
-
-Temp
- 00 04 10 14 20 24 30 34
- 40 44 50 54 60 64 70 74
- 01 03 11 13 21 23 31 33
- 41 43 51 53 61 63 71 73
- 02 06 12 16 22 26 32 36
- 42 46 52 56 62 66 72 76
- 05 07 15 17 25 27 35 37
- 45 47 55 57 65 67 75 77
-*/
-
-"9: \n\t"
-                :: "r" (block), "r" (temp), "r" (coeffs)
-                   NAMED_CONSTRAINTS_ADD(wm1010,d40000)
-                : "%eax"
-        );
-}
-
-void ff_simple_idct_mmx(int16_t *block)
-{
-    idct(block);
-}
-
-//FIXME merge add/put into the idct
-
-void ff_simple_idct_put_mmx(uint8_t *dest, int line_size, int16_t *block)
-{
-    idct(block);
-    ff_put_pixels_clamped(block, dest, line_size);
-}
-void ff_simple_idct_add_mmx(uint8_t *dest, int line_size, int16_t *block)
-{
-    idct(block);
-    ff_add_pixels_clamped(block, dest, line_size);
-}
-
-#endif /* HAVE_INLINE_ASM */
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/simple_idct.h b/mythtv/external/FFmpeg/libavcodec/x86/simple_idct.h
index 8eeb31e2998..9b64cfe9bc3 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/simple_idct.h
+++ b/mythtv/external/FFmpeg/libavcodec/x86/simple_idct.h
@@ -19,22 +19,35 @@
 #ifndef AVCODEC_X86_SIMPLE_IDCT_H
 #define AVCODEC_X86_SIMPLE_IDCT_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 void ff_simple_idct_mmx(int16_t *block);
-void ff_simple_idct_add_mmx(uint8_t *dest, int line_size, int16_t *block);
-void ff_simple_idct_put_mmx(uint8_t *dest, int line_size, int16_t *block);
+void ff_simple_idct_add_mmx(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct_put_mmx(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+
+void ff_simple_idct_add_sse2(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct_put_sse2(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+
+void ff_simple_idct8_sse2(int16_t *block);
+void ff_simple_idct8_avx(int16_t *block);
+
+void ff_simple_idct8_put_sse2(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct8_put_avx(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+
+void ff_simple_idct8_add_sse2(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct8_add_avx(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 
 void ff_simple_idct10_sse2(int16_t *block);
 void ff_simple_idct10_avx(int16_t *block);
 
-void ff_simple_idct10_put_sse2(uint8_t *dest, int line_size, int16_t *block);
-void ff_simple_idct10_put_avx(uint8_t *dest, int line_size, int16_t *block);
+void ff_simple_idct10_put_sse2(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct10_put_avx(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 
 void ff_simple_idct12_sse2(int16_t *block);
 void ff_simple_idct12_avx(int16_t *block);
 
-void ff_simple_idct12_put_sse2(uint8_t *dest, int line_size, int16_t *block);
-void ff_simple_idct12_put_avx(uint8_t *dest, int line_size, int16_t *block);
+void ff_simple_idct12_put_sse2(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_simple_idct12_put_avx(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 
 #endif /* AVCODEC_X86_SIMPLE_IDCT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/simple_idct10.asm b/mythtv/external/FFmpeg/libavcodec/x86/simple_idct10.asm
index 5dee533de0d..069bb61378f 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/simple_idct10.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/simple_idct10.asm
@@ -31,11 +31,14 @@ SECTION_RODATA
 
 cextern pw_2
 cextern pw_16
+cextern pw_32
 cextern pw_1023
 cextern pw_4095
+pd_round_11: times 4 dd 1<<(11-1)
 pd_round_12: times 4 dd 1<<(12-1)
 pd_round_15: times 4 dd 1<<(15-1)
 pd_round_19: times 4 dd 1<<(19-1)
+pd_round_20: times 4 dd 1<<(20-1)
 
 %macro CONST_DEC  3
 const %1
@@ -46,47 +49,149 @@ times 4 dw %2, %3
 %define W2sh2 21407 ; W2 = 85627 = 21407<<2 - 1
 %define W3sh2 19265 ; W3 = 77062 = 19265<<2 + 2
 %define W4sh2 16384 ; W4 = 65535 = 16384<<2 - 1
+%define W3sh2_lo 19266
+%define W4sh2_lo 16383
 %define W5sh2 12873 ; W5 = 51491 = 12873<<2 - 1
 %define W6sh2  8867 ; W6 = 35468 =  8867<<2
 %define W7sh2  4520 ; W7 = 18081 =  4520<<2 + 1
 
-CONST_DEC  w4_plus_w2,   W4sh2, +W2sh2
-CONST_DEC  w4_min_w2,    W4sh2, -W2sh2
-CONST_DEC  w4_plus_w6,   W4sh2, +W6sh2
-CONST_DEC  w4_min_w6,    W4sh2, -W6sh2
-CONST_DEC  w1_plus_w3,   W1sh2, +W3sh2
-CONST_DEC  w3_min_w1,    W3sh2, -W1sh2
-CONST_DEC  w7_plus_w3,   W7sh2, +W3sh2
-CONST_DEC  w3_min_w7,    W3sh2, -W7sh2
+CONST_DEC  w4_plus_w2_hi,   W4sh2, +W2sh2
+CONST_DEC  w4_min_w2_hi,    W4sh2, -W2sh2
+CONST_DEC  w4_plus_w6_hi,   W4sh2, +W6sh2
+CONST_DEC  w4_min_w6_hi,    W4sh2, -W6sh2
+CONST_DEC  w1_plus_w3_hi,   W1sh2, +W3sh2
+CONST_DEC  w3_min_w1_hi,    W3sh2, -W1sh2
+CONST_DEC  w7_plus_w3_hi,   W7sh2, +W3sh2
+CONST_DEC  w3_min_w7_hi,    W3sh2, -W7sh2
 CONST_DEC  w1_plus_w5,   W1sh2, +W5sh2
 CONST_DEC  w5_min_w1,    W5sh2, -W1sh2
 CONST_DEC  w5_plus_w7,   W5sh2, +W7sh2
 CONST_DEC  w7_min_w5,    W7sh2, -W5sh2
+CONST_DEC  w4_plus_w2_lo,   W4sh2_lo, +W2sh2
+CONST_DEC  w4_min_w2_lo,    W4sh2_lo, -W2sh2
+CONST_DEC  w4_plus_w6_lo,   W4sh2_lo, +W6sh2
+CONST_DEC  w4_min_w6_lo,    W4sh2_lo, -W6sh2
+CONST_DEC  w1_plus_w3_lo,   W1sh2,    +W3sh2_lo
+CONST_DEC  w3_min_w1_lo,    W3sh2_lo, -W1sh2
+CONST_DEC  w7_plus_w3_lo,   W7sh2,    +W3sh2_lo
+CONST_DEC  w3_min_w7_lo,    W3sh2_lo, -W7sh2
 
 %include "libavcodec/x86/simple_idct10_template.asm"
 
 SECTION .text
 
+%macro STORE_HI_LO 12
+    movq   %1, %9
+    movq   %3, %10
+    movq   %5, %11
+    movq   %7, %12
+    movhps %2, %9
+    movhps %4, %10
+    movhps %6, %11
+    movhps %8, %12
+%endmacro
+
+%macro LOAD_ZXBW_8 16
+    pmovzxbw %1, %9
+    pmovzxbw %2, %10
+    pmovzxbw %3, %11
+    pmovzxbw %4, %12
+    pmovzxbw %5, %13
+    pmovzxbw %6, %14
+    pmovzxbw %7, %15
+    pmovzxbw %8, %16
+%endmacro
+
+%macro LOAD_ZXBW_4 9
+    movh %1, %5
+    movh %2, %6
+    movh %3, %7
+    movh %4, %8
+    punpcklbw %1, %9
+    punpcklbw %2, %9
+    punpcklbw %3, %9
+    punpcklbw %4, %9
+%endmacro
+
+%define PASS4ROWS(base, stride, stride3) \
+    [base], [base + stride], [base + 2*stride], [base + stride3]
+
 %macro idct_fn 0
-cglobal simple_idct10, 1, 1, 16
-    IDCT_FN    "", 12, "", 19
+
+define_constants _lo
+
+cglobal simple_idct8, 1, 1, 16, 32, block
+    IDCT_FN    "", 11, pw_32, 20, "store"
+RET
+
+cglobal simple_idct8_put, 3, 4, 16, 32, pixels, lsize, block
+    IDCT_FN    "", 11, pw_32, 20
+    lea       r3, [3*lsizeq]
+    lea       r2, [pixelsq + r3]
+    packuswb  m8, m0
+    packuswb  m1, m2
+    packuswb  m4, m11
+    packuswb  m9, m10
+    STORE_HI_LO PASS8ROWS(pixelsq, r2, lsizeq, r3), m8, m1, m4, m9
+RET
+
+cglobal simple_idct8_add, 3, 4, 16, 32, pixels, lsize, block
+    IDCT_FN    "", 11, pw_32, 20
+    lea r2, [3*lsizeq]
+    %if cpuflag(sse4)
+        lea r3, [pixelsq + r2]
+        LOAD_ZXBW_8 m3, m5, m6, m7, m12, m13, m14, m15, PASS8ROWS(pixelsq, r3, lsizeq, r2)
+        paddsw m8, m3
+        paddsw m0, m5
+        paddsw m1, m6
+        paddsw m2, m7
+        paddsw m4, m12
+        paddsw m11, m13
+        paddsw m9, m14
+        paddsw m10, m15
+    %else
+        pxor m12, m12
+        LOAD_ZXBW_4 m3, m5, m6, m7, PASS4ROWS(pixelsq, lsizeq, r2), m12
+        paddsw m8, m3
+        paddsw m0, m5
+        paddsw m1, m6
+        paddsw m2, m7
+        lea r3, [pixelsq + 4*lsizeq]
+        LOAD_ZXBW_4 m3, m5, m6, m7, PASS4ROWS(r3, lsizeq, r2), m12
+        paddsw m4, m3
+        paddsw m11, m5
+        paddsw m9, m6
+        paddsw m10, m7
+        lea r3, [pixelsq + r2]
+    %endif
+    packuswb  m8, m0
+    packuswb  m1, m2
+    packuswb  m4, m11
+    packuswb  m9, m10
+    STORE_HI_LO PASS8ROWS(pixelsq, r3, lsizeq, r2), m8, m1, m4, m9
+RET
+
+define_constants _hi
+
+cglobal simple_idct10, 1, 1, 16, block
+    IDCT_FN    "", 12, "", 19, "store"
     RET
 
-cglobal simple_idct10_put, 3, 3, 16
-    IDCT_FN    "", 12, "", 19, 0, pw_1023
+cglobal simple_idct10_put, 3, 3, 16, pixels, lsize, block
+    IDCT_FN    "", 12, "", 19, "put", 0, pw_1023
     RET
 
-cglobal simple_idct12, 1, 1, 16
+cglobal simple_idct12, 1, 1, 16, block
     ; coeffs are already 15bits, adding the offset would cause
     ; overflow in the input
-    IDCT_FN    "", 15, pw_2, 16
+    IDCT_FN    "", 15, pw_2, 16, "store"
     RET
 
-cglobal simple_idct12_put, 3, 3, 16
+cglobal simple_idct12_put, 3, 3, 16, pixels, lsize, block
     ; range isn't known, so the C simple_idct range is used
     ; Also, using a bias on input overflows, so use the bias
     ; on output of the first butterfly instead
-    IDCT_FN    "", 15, pw_2, 16, 0, pw_4095
+    IDCT_FN    "", 15, pw_2, 16, "put", 0, pw_4095
     RET
 %endmacro
 
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/simple_idct10_template.asm b/mythtv/external/FFmpeg/libavcodec/x86/simple_idct10_template.asm
index e5deb0f2e2c..0d04a9818a9 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/simple_idct10_template.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/simple_idct10_template.asm
@@ -26,6 +26,25 @@
 
 %if ARCH_X86_64
 
+%macro define_constants 1
+    %undef w4_plus_w2
+    %undef w4_min_w2
+    %undef w4_plus_w6
+    %undef w4_min_w6
+    %undef w1_plus_w3
+    %undef w3_min_w1
+    %undef w7_plus_w3
+    %undef w3_min_w7
+    %define w4_plus_w2 w4_plus_w2%1
+    %define w4_min_w2  w4_min_w2%1
+    %define w4_plus_w6 w4_plus_w6%1
+    %define w4_min_w6  w4_min_w6%1
+    %define w1_plus_w3 w1_plus_w3%1
+    %define w3_min_w1  w3_min_w1%1
+    %define w7_plus_w3 w7_plus_w3%1
+    %define w3_min_w7  w3_min_w7%1
+%endmacro
+
 ; interleave data while maintaining source
 ; %1=type, %2=dstlo, %3=dsthi, %4=src, %5=interleave
 %macro SBUTTERFLY3 5
@@ -115,18 +134,18 @@
     psubd       m3,  m9            ; a1[4-7] intermediate
 
     ; load/store
-    mova   [COEFFS+  0], m0
-    mova   [COEFFS+ 32], m2
-    mova   [COEFFS+ 64], m4
-    mova   [COEFFS+ 96], m6
-    mova        m10,[COEFFS+ 16]       ; { row[1] }[0-7]
-    mova        m8, [COEFFS+ 48]       ; { row[3] }[0-7]
-    mova        m13,[COEFFS+ 80]       ; { row[5] }[0-7]
-    mova        m14,[COEFFS+112]       ; { row[7] }[0-7]
-    mova   [COEFFS+ 16], m1
-    mova   [COEFFS+ 48], m3
-    mova   [COEFFS+ 80], m5
-    mova   [COEFFS+112], m7
+    mova   [blockq+  0], m0
+    mova   [blockq+ 32], m2
+    mova   [blockq+ 64], m4
+    mova   [blockq+ 96], m6
+    mova        m10,[blockq+ 16]       ; { row[1] }[0-7]
+    mova        m8, [blockq+ 48]       ; { row[3] }[0-7]
+    mova        m13,[blockq+ 80]       ; { row[5] }[0-7]
+    mova        m14,[blockq+112]       ; { row[7] }[0-7]
+    mova   [blockq+ 16], m1
+    mova   [blockq+ 48], m3
+    mova   [blockq+ 80], m5
+    mova   [blockq+112], m7
 %if %0 == 3
     pmullw      m10,[%3+ 16]
     pmullw      m8, [%3+ 48]
@@ -197,64 +216,97 @@
     ; row[5] = (a2 - b2) >> 15;
     ; row[3] = (a3 + b3) >> 15;
     ; row[4] = (a3 - b3) >> 15;
-    mova        m8, [COEFFS+ 0]        ; a0[0-3]
-    mova        m9, [COEFFS+16]        ; a0[4-7]
+    mova        m8, [blockq+ 0]        ; a0[0-3]
+    mova        m9, [blockq+16]        ; a0[4-7]
     SUMSUB_SHPK m8,  m9,  m10, m11, m0,  m1,  %2
-    mova        m0, [COEFFS+32]        ; a1[0-3]
-    mova        m1, [COEFFS+48]        ; a1[4-7]
+    mova        m0, [blockq+32]        ; a1[0-3]
+    mova        m1, [blockq+48]        ; a1[4-7]
     SUMSUB_SHPK m0,  m1,  m9,  m11, m2,  m3,  %2
-    mova        m1, [COEFFS+64]        ; a2[0-3]
-    mova        m2, [COEFFS+80]        ; a2[4-7]
+    mova        m1, [blockq+64]        ; a2[0-3]
+    mova        m2, [blockq+80]        ; a2[4-7]
     SUMSUB_SHPK m1,  m2,  m11, m3,  m4,  m5,  %2
-    mova        m2, [COEFFS+96]        ; a3[0-3]
-    mova        m3, [COEFFS+112]       ; a3[4-7]
+    mova        m2, [blockq+96]        ; a3[0-3]
+    mova        m3, [blockq+112]       ; a3[4-7]
     SUMSUB_SHPK m2,  m3,  m4,  m5,  m6,  m7,  %2
 %endmacro
 
-; void ff_prores_idct_put_10_<opt>(uint8_t *pixels, int stride,
+; void ff_prores_idct_put_10_<opt>(uint8_t *pixels, ptrdiff_t stride,
 ;                                  int16_t *block, const int16_t *qmat);
 
 ; %1 = row shift
 ; %2 = row bias macro
 ; %3 = column shift
 ; %4 = column bias macro
-; %5 = min pixel value
-; %6 = max pixel value
-; %7 = qmat (for prores)
-
-%macro IDCT_FN 4-7
-%if %0 == 4
-    ; No clamping, means pure idct
-%xdefine COEFFS r0
-%else
-    movsxd      r1,  r1d
-%xdefine COEFFS r2
-%endif
+; %5 = final action (nothing, "store", "put", "add")
+; %6 = min pixel value
+; %7 = max pixel value
+; %8 = qmat (for prores)
 
+%macro IDCT_FN 4-8
     ; for (i = 0; i < 8; i++)
     ;     idctRowCondDC(block + i*8);
-    mova        m10,[COEFFS+ 0]        ; { row[0] }[0-7]
-    mova        m8, [COEFFS+32]        ; { row[2] }[0-7]
-    mova        m13,[COEFFS+64]        ; { row[4] }[0-7]
-    mova        m12,[COEFFS+96]        ; { row[6] }[0-7]
+    mova        m10,[blockq+ 0]        ; { row[0] }[0-7]
+    mova        m8, [blockq+32]        ; { row[2] }[0-7]
+    mova        m13,[blockq+64]        ; { row[4] }[0-7]
+    mova        m12,[blockq+96]        ; { row[6] }[0-7]
 
-%if %0 == 7
-    pmullw      m10,[%7+ 0]
-    pmullw      m8, [%7+32]
-    pmullw      m13,[%7+64]
-    pmullw      m12,[%7+96]
+%if %0 == 8
+    pmullw      m10,[%8+ 0]
+    pmullw      m8, [%8+32]
+    pmullw      m13,[%8+64]
+    pmullw      m12,[%8+96]
 
-    IDCT_1D     %1, %2, %7
+    IDCT_1D     %1, %2, %8
+%elif %2 == 11
+    ; This copies the DC-only shortcut.  When there is only a DC coefficient the
+    ; C shifts the value and splats it to all coeffs rather than multiplying and
+    ; doing the full IDCT.  This causes a difference on 8-bit because the
+    ; coefficient is 16383 rather than 16384 (which you can get with shifting).
+    por      m1,  m8, m13
+    por      m1,  m12
+    por      m1, [blockq+ 16]       ; { row[1] }[0-7]
+    por      m1, [blockq+ 48]       ; { row[3] }[0-7]
+    por      m1, [blockq+ 80]       ; { row[5] }[0-7]
+    por      m1, [blockq+112]       ; { row[7] }[0-7]
+    pxor     m2,  m2
+    pcmpeqw  m1,  m2
+    psllw    m2,  m10, 3
+    pand     m2,  m1
+    pcmpeqb  m3,  m3
+    pxor     m1,  m3
+    mova    [rsp],    m1
+    mova    [rsp+16], m2
+
+    IDCT_1D  %1,  %2
+
+    mova     m5, [rsp]
+    mova     m6, [rsp+16]
+    pand     m8,  m5
+    por      m8,  m6
+    pand     m0,  m5
+    por      m0,  m6
+    pand     m1,  m5
+    por      m1,  m6
+    pand     m2,  m5
+    por      m2,  m6
+    pand     m4,  m5
+    por      m4,  m6
+    pand     m11, m5
+    por      m11, m6
+    pand     m9,  m5
+    por      m9,  m6
+    pand     m10, m5
+    por      m10, m6
 %else
     IDCT_1D     %1, %2
 %endif
 
     ; transpose for second part of IDCT
     TRANSPOSE8x8W 8, 0, 1, 2, 4, 11, 9, 10, 3
-    mova   [COEFFS+ 16], m0
-    mova   [COEFFS+ 48], m2
-    mova   [COEFFS+ 80], m11
-    mova   [COEFFS+112], m10
+    mova   [blockq+ 16], m0
+    mova   [blockq+ 48], m2
+    mova   [blockq+ 80], m11
+    mova   [blockq+112], m10
     SWAP         8,  10
     SWAP         1,   8
     SWAP         4,  13
@@ -265,23 +317,24 @@
     IDCT_1D     %3, %4
 
     ; clip/store
-%if %0 == 4
+%if %0 >= 5
+%ifidn %5,"store"
     ; No clamping, means pure idct
-    mova  [r0+  0], m8
-    mova  [r0+ 16], m0
-    mova  [r0+ 32], m1
-    mova  [r0+ 48], m2
-    mova  [r0+ 64], m4
-    mova  [r0+ 80], m11
-    mova  [r0+ 96], m9
-    mova  [r0+112], m10
-%else
-%ifidn %5, 0
+    mova  [blockq+  0], m8
+    mova  [blockq+ 16], m0
+    mova  [blockq+ 32], m1
+    mova  [blockq+ 48], m2
+    mova  [blockq+ 64], m4
+    mova  [blockq+ 80], m11
+    mova  [blockq+ 96], m9
+    mova  [blockq+112], m10
+%elifidn %5,"put"
+%ifidn %6, 0
     pxor        m3, m3
 %else
-    mova        m3, [%5]
-%endif
-    mova        m5, [%6]
+    mova        m3, [%6]
+%endif ; ifidn %6, 0
+    mova        m5, [%7]
     pmaxsw      m8,  m3
     pmaxsw      m0,  m3
     pmaxsw      m1,  m3
@@ -309,7 +362,8 @@
     mova  [r0+r1  ], m11
     mova  [r0+r1*2], m9
     mova  [r0+r2  ], m10
-%endif
+%endif ; %5 action
+%endif; if %0 >= 5
 %endmacro
 
 %endif
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/synth_filter_init.c b/mythtv/external/FFmpeg/libavcodec/x86/synth_filter_init.c
index 9ef00cdb0a3..35e2b47a3ea 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/synth_filter_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/synth_filter_init.c
@@ -42,18 +42,18 @@ static void synth_filter_##opt(FFTContext *imdct,                              \
     *synth_buf_offset = (*synth_buf_offset - 32) & 511;                        \
 }                                                                              \
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 #if ARCH_X86_32
 SYNTH_FILTER_FUNC(sse)
 #endif
 SYNTH_FILTER_FUNC(sse2)
 SYNTH_FILTER_FUNC(avx)
 SYNTH_FILTER_FUNC(fma3)
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 av_cold void ff_synth_filter_init_x86(SynthFilterContext *s)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
 #if ARCH_X86_32
@@ -70,5 +70,5 @@ av_cold void ff_synth_filter_init_x86(SynthFilterContext *s)
     if (EXTERNAL_FMA3_FAST(cpu_flags)) {
         s->synth_filter_float = synth_filter_fma3;
     }
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/takdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/takdsp_init.c
index 555d0649c90..fe0c846afda 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/takdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/takdsp_init.c
@@ -29,7 +29,7 @@ void ff_tak_decorrelate_sf_sse4(int32_t *p1, int32_t *p2, int length, int dshift
 
 av_cold void ff_takdsp_init_x86(TAKDSPContext *c)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_SSE2(cpu_flags)) {
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/ttadsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/ttadsp_init.c
index aa998c1afdb..7441c97769a 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/ttadsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/ttadsp_init.c
@@ -31,7 +31,7 @@ void ff_tta_filter_process_sse4(int32_t *qm, int32_t *dx, int32_t *dl,
 
 av_cold void ff_ttadsp_init_x86(TTADSPContext *c)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_SSSE3(cpu_flags))
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/ttaencdsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/ttaencdsp_init.c
index c1a02fdac99..61971a42826 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/ttaencdsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/ttaencdsp_init.c
@@ -31,7 +31,7 @@ void ff_ttaenc_filter_process_sse4(int32_t *qm, int32_t *dx, int32_t *dl,
 
 av_cold void ff_ttaencdsp_init_x86(TTAEncDSPContext *c)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_SSSE3(cpu_flags))
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/utvideodsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/utvideodsp.asm
new file mode 100644
index 00000000000..e44c1ea4719
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/utvideodsp.asm
@@ -0,0 +1,111 @@
+;******************************************************************************
+;* SIMD-optimized UTVideo functions
+;* Copyright (c) 2017 Paul B Mahol
+;*
+;* 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/x86/x86util.asm"
+
+SECTION_RODATA
+
+pb_128:  times 16 db 128
+pw_512:  times 8  dw 512
+pw_1023: times 8  dw 1023
+
+SECTION .text
+
+INIT_XMM sse2
+
+; void restore_rgb_planes(uint8_t *src_r, uint8_t *src_g, uint8_t *src_b,
+;                         ptrdiff_t linesize_r, ptrdiff_t linesize_g, ptrdiff_t linesize_b,
+;                         int width, int height)
+cglobal restore_rgb_planes, 7 + ARCH_X86_64, 7 + ARCH_X86_64 * 2, 4, src_r, src_g, src_b, linesize_r, linesize_g, linesize_b, w, h, x
+    movsxdifnidn wq, wd
+    add      src_rq, wq
+    add      src_gq, wq
+    add      src_bq, wq
+    neg          wq
+%if ARCH_X86_64 == 0
+    mov          wm, wq
+DEFINE_ARGS src_r, src_g, src_b, linesize_r, linesize_g, linesize_b, x
+%define wq r6m
+%define hd r7mp
+%endif
+    mova         m3, [pb_128]
+.nextrow:
+    mov          xq, wq
+
+    .loop:
+        mova           m0, [src_rq + xq]
+        mova           m1, [src_gq + xq]
+        mova           m2, [src_bq + xq]
+        psubb          m1, m3
+        paddb          m0, m1
+        paddb          m2, m1
+        mova  [src_rq+xq], m0
+        mova  [src_bq+xq], m2
+        add            xq, mmsize
+    jl .loop
+
+    add        src_rq, linesize_rq
+    add        src_gq, linesize_gq
+    add        src_bq, linesize_bq
+    sub        hd, 1
+    jg .nextrow
+    REP_RET
+
+cglobal restore_rgb_planes10, 7 + ARCH_X86_64, 7 + ARCH_X86_64 * 2, 5, src_r, src_g, src_b, linesize_r, linesize_g, linesize_b, w, h, x
+    shl          wd, 1
+    shl linesize_rq, 1
+    shl linesize_gq, 1
+    shl linesize_bq, 1
+    add      src_rq, wq
+    add      src_gq, wq
+    add      src_bq, wq
+    mova         m3, [pw_512]
+    mova         m4, [pw_1023]
+    neg          wq
+%if ARCH_X86_64 == 0
+    mov          wm, wq
+DEFINE_ARGS src_r, src_g, src_b, linesize_r, linesize_g, linesize_b, x
+%define wq r6m
+%define hd r7mp
+%endif
+.nextrow:
+    mov          xq, wq
+
+    .loop:
+        mova           m0, [src_rq + xq]
+        mova           m1, [src_gq + xq]
+        mova           m2, [src_bq + xq]
+        psubw          m1, m3
+        paddw          m0, m1
+        paddw          m2, m1
+        pand           m0, m4
+        pand           m2, m4
+        mova  [src_rq+xq], m0
+        mova  [src_bq+xq], m2
+        add            xq, mmsize
+    jl .loop
+
+    add        src_rq, linesize_rq
+    add        src_gq, linesize_gq
+    add        src_bq, linesize_bq
+    sub        hd, 1
+    jg .nextrow
+    REP_RET
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/utvideodsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/utvideodsp_init.c
new file mode 100644
index 00000000000..f8b2a9b0749
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/x86/utvideodsp_init.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/x86/asm.h"
+#include "libavutil/x86/cpu.h"
+#include "libavcodec/utvideodsp.h"
+
+void ff_restore_rgb_planes_sse2(uint8_t *src_r, uint8_t *src_g, uint8_t *src_b,
+                                ptrdiff_t linesize_r, ptrdiff_t linesize_g,
+                                ptrdiff_t linesize_b, int width, int height);
+void ff_restore_rgb_planes10_sse2(uint16_t *src_r, uint16_t *src_g, uint16_t *src_b,
+                                  ptrdiff_t linesize_r, ptrdiff_t linesize_g,
+                                  ptrdiff_t linesize_b, int width, int height);
+
+av_cold void ff_utvideodsp_init_x86(UTVideoDSPContext *c)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (EXTERNAL_SSE2(cpu_flags)) {
+        c->restore_rgb_planes   = ff_restore_rgb_planes_sse2;
+        c->restore_rgb_planes10 = ff_restore_rgb_planes10_sse2;
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/v210-init.c b/mythtv/external/FFmpeg/libavcodec/x86/v210-init.c
index f579307aa04..d64dbca1a8a 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/v210-init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/v210-init.c
@@ -27,7 +27,7 @@ extern void ff_v210_planar_unpack_aligned_avx(const uint32_t *src, uint16_t *y,
 
 av_cold void ff_v210_x86_init(V210DecContext *s)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (s->aligned_input) {
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_init.c
index c8943fa2f7a..8e0c284cc09 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_init.c
@@ -51,7 +51,7 @@ static void vc1_h_loop_filter16_ ## EXT(uint8_t *src, int stride, int pq) \
     ff_vc1_h_loop_filter8_ ## EXT(src+8*stride, stride, pq); \
 }
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 LOOP_FILTER(mmxext)
 LOOP_FILTER(sse2)
 LOOP_FILTER(ssse3)
@@ -80,25 +80,25 @@ DECLARE_FUNCTION(avg_, 16, _mmxext)
 DECLARE_FUNCTION(put_, 16, _sse2)
 DECLARE_FUNCTION(avg_, 16, _sse2)
 
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 void ff_put_vc1_chroma_mc8_nornd_mmx  (uint8_t *dst, uint8_t *src,
-                                       int stride, int h, int x, int y);
+                                       ptrdiff_t stride, int h, int x, int y);
 void ff_avg_vc1_chroma_mc8_nornd_mmxext(uint8_t *dst, uint8_t *src,
-                                        int stride, int h, int x, int y);
+                                        ptrdiff_t stride, int h, int x, int y);
 void ff_avg_vc1_chroma_mc8_nornd_3dnow(uint8_t *dst, uint8_t *src,
-                                       int stride, int h, int x, int y);
+                                       ptrdiff_t stride, int h, int x, int y);
 void ff_put_vc1_chroma_mc8_nornd_ssse3(uint8_t *dst, uint8_t *src,
-                                       int stride, int h, int x, int y);
+                                       ptrdiff_t stride, int h, int x, int y);
 void ff_avg_vc1_chroma_mc8_nornd_ssse3(uint8_t *dst, uint8_t *src,
-                                       int stride, int h, int x, int y);
-void ff_vc1_inv_trans_4x4_dc_mmxext(uint8_t *dest, int linesize,
+                                       ptrdiff_t stride, int h, int x, int y);
+void ff_vc1_inv_trans_4x4_dc_mmxext(uint8_t *dest, ptrdiff_t linesize,
                                     int16_t *block);
-void ff_vc1_inv_trans_4x8_dc_mmxext(uint8_t *dest, int linesize,
+void ff_vc1_inv_trans_4x8_dc_mmxext(uint8_t *dest, ptrdiff_t linesize,
                                     int16_t *block);
-void ff_vc1_inv_trans_8x4_dc_mmxext(uint8_t *dest, int linesize,
+void ff_vc1_inv_trans_8x4_dc_mmxext(uint8_t *dest, ptrdiff_t linesize,
                                     int16_t *block);
-void ff_vc1_inv_trans_8x8_dc_mmxext(uint8_t *dest, int linesize,
+void ff_vc1_inv_trans_8x8_dc_mmxext(uint8_t *dest, ptrdiff_t linesize,
                                     int16_t *block);
 
 
@@ -106,10 +106,12 @@ av_cold void ff_vc1dsp_init_x86(VC1DSPContext *dsp)
 {
     int cpu_flags = av_get_cpu_flags();
 
-    if (HAVE_6REGS && INLINE_MMX(cpu_flags) && EXTERNAL_MMX(cpu_flags))
+    if (HAVE_6REGS && INLINE_MMX(cpu_flags))
+        if (EXTERNAL_MMX(cpu_flags))
         ff_vc1dsp_init_mmx(dsp);
 
-    if (HAVE_6REGS && INLINE_MMXEXT(cpu_flags) && EXTERNAL_MMXEXT(cpu_flags))
+    if (HAVE_6REGS && INLINE_MMXEXT(cpu_flags))
+        if (EXTERNAL_MMXEXT(cpu_flags))
         ff_vc1dsp_init_mmxext(dsp);
 
 #define ASSIGN_LF(EXT) \
@@ -120,7 +122,7 @@ av_cold void ff_vc1dsp_init_x86(VC1DSPContext *dsp)
         dsp->vc1_v_loop_filter16 = vc1_v_loop_filter16_ ## EXT; \
         dsp->vc1_h_loop_filter16 = vc1_h_loop_filter16_ ## EXT
 
-#if HAVE_YASM
+#if HAVE_X86ASM
     if (EXTERNAL_MMX(cpu_flags)) {
         dsp->put_no_rnd_vc1_chroma_pixels_tab[0] = ff_put_vc1_chroma_mc8_nornd_mmx;
 
@@ -162,5 +164,5 @@ av_cold void ff_vc1dsp_init_x86(VC1DSPContext *dsp)
         dsp->vc1_h_loop_filter8  = ff_vc1_h_loop_filter8_sse4;
         dsp->vc1_h_loop_filter16 = vc1_h_loop_filter16_sse4;
     }
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_loopfilter.asm b/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_loopfilter.asm
index 1838f6f2359..fd33bd13dc3 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_loopfilter.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_loopfilter.asm
@@ -24,7 +24,7 @@
 cextern pw_4
 cextern pw_5
 
-section .text
+SECTION .text
 
 ; dst_low, dst_high (src), zero
 ; zero-extends one vector from 8 to 16 bits
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_mc.asm b/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_mc.asm
index 7eaf043964d..0e6d87dd8b5 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_mc.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vc1dsp_mc.asm
@@ -24,7 +24,7 @@
 cextern pw_9
 cextern pw_128
 
-section .text
+SECTION .text
 
 %if HAVE_MMX_INLINE
 
@@ -155,7 +155,7 @@ cglobal vc1_%2_hor_16b_shift2, 4, 5, 0, dst, stride, src, rnd, h
     mov                hq, 8
     sub              srcq, 2
     sub              rndd, (-1+9+9-1) * 1024 ; add -1024 bias
-    LOAD_ROUNDER_MMX rndq
+    LOAD_ROUNDER_MMX rndd
     mova               m5, [pw_9]
     mova               m6, [pw_128]
     pxor               m0, m0
@@ -225,7 +225,7 @@ HOR_16B_SHIFT2 OP_AVG, avg
     mov%1 [linesize3q +destq], m5
 %endmacro
 
-; ff_vc1_inv_trans_?x?_dc_mmxext(uint8_t *dest, int linesize, int16_t *block)
+; ff_vc1_inv_trans_?x?_dc_mmxext(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
 INIT_MMX mmxext
 cglobal vc1_inv_trans_4x4_dc, 3,4,0, dest, linesize, block
     movsx         r3d, WORD [blockq]
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/videodsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/videodsp.asm
index a807d3b888f..e237860700b 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/videodsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/videodsp.asm
@@ -114,7 +114,7 @@ cglobal emu_edge_hvar, 5, 6, 1, dst, dst_stride, start_x, n_words, h, w
 .x_loop:                                        ;   do {
     movu    [dstq+wq*2], m0                     ;     write($reg, $mmsize)
     add              wq, mmsize/2               ;     w -= $mmsize/2
-    cmp              wq, -mmsize/2              ;   } while (w > $mmsize/2)
+    cmp              wq, -(mmsize/2)            ;   } while (w > $mmsize/2)
     jl .x_loop
     movu  [dstq-mmsize], m0                     ;   write($reg, $mmsize)
     add            dstq, dst_strideq            ;   dst += dst_stride
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/videodsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/videodsp_init.c
index 26e072bb12a..eeebb415479 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/videodsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/videodsp_init.c
@@ -29,7 +29,7 @@
 #include "libavutil/x86/cpu.h"
 #include "libavcodec/videodsp.h"
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 typedef void emu_edge_vfix_func(uint8_t *dst, x86_reg dst_stride,
                                 const uint8_t *src, x86_reg src_stride,
                                 x86_reg start_y, x86_reg end_y, x86_reg bh);
@@ -271,14 +271,14 @@ static av_noinline void emulated_edge_mc_avx2(uint8_t *buf, const uint8_t *src,
                      hfixtbl_avx2, &ff_emu_edge_hvar_avx2);
 }
 #endif /* HAVE_AVX2_EXTERNAL */
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 void ff_prefetch_mmxext(uint8_t *buf, ptrdiff_t stride, int h);
 void ff_prefetch_3dnow(uint8_t *buf, ptrdiff_t stride, int h);
 
 av_cold void ff_videodsp_init_x86(VideoDSPContext *ctx, int bpc)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
 #if ARCH_X86_32
@@ -305,5 +305,5 @@ av_cold void ff_videodsp_init_x86(VideoDSPContext *ctx, int bpc)
         ctx->emulated_edge_mc = emulated_edge_mc_avx2;
     }
 #endif
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vorbisdsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/vorbisdsp.asm
index b25d8388684..d9522967160 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vorbisdsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vorbisdsp.asm
@@ -57,13 +57,17 @@ cglobal vorbis_inverse_coupling, 3, 3, 6, mag, ang, block_size
 %endif
 
 INIT_XMM sse
-cglobal vorbis_inverse_coupling, 3, 4, 6, mag, ang, block_size, cntr
+cglobal vorbis_inverse_coupling, 3, 3, 6, mag, ang, block_size
     mova                     m5, [pdw_80000000]
-    xor                   cntrq, cntrq
+    shl             block_sized, 2
+    add                    magq, block_sizeq
+    add                    angq, block_sizeq
+    neg             block_sizeq
+
 align 16
 .loop:
-    mova                     m0, [magq+cntrq*4]
-    mova                     m1, [angq+cntrq*4]
+    mova                     m0, [magq+block_sizeq]
+    mova                     m1, [angq+block_sizeq]
     xorps                    m2, m2
     xorps                    m3, m3
     cmpleps                  m2, m0     ; m <= 0.0
@@ -75,9 +79,8 @@ align 16
     andnps                   m4, m1
     addps                    m3, m0     ; a = m + ((a < 0) & (a ^ sign(m)))
     subps                    m0, m4     ; m = m + ((a > 0) & (a ^ sign(m)))
-    mova         [angq+cntrq*4], m3
-    mova         [magq+cntrq*4], m0
-    add                   cntrq, 4
-    cmp                   cntrq, block_sizeq
+    mova     [angq+block_sizeq], m3
+    mova     [magq+block_sizeq], m0
+    add             block_sizeq, mmsize
     jl .loop
     RET
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp3dsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/vp3dsp.asm
index d457cd7de50..d88d5a1edf2 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp3dsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp3dsp.asm
@@ -105,9 +105,6 @@ SECTION .text
 
 INIT_MMX mmxext
 cglobal vp3_v_loop_filter, 3, 4
-%if ARCH_X86_64
-    movsxd        r1, r1d
-%endif
     mov           r3, r1
     neg           r1
     movq          m6, [r0+r1*2]
@@ -122,9 +119,6 @@ cglobal vp3_v_loop_filter, 3, 4
     RET
 
 cglobal vp3_h_loop_filter, 3, 4
-%if ARCH_X86_64
-    movsxd        r1, r1d
-%endif
     lea           r3, [r1*3]
 
     movd          m6, [r0     -2]
@@ -569,7 +563,6 @@ cglobal put_vp_no_rnd_pixels8_l2, 5, 6, 0, dst, src1, src2, stride, h, stride3
 cglobal vp3_idct_put, 3, 4, 9
     VP3_IDCT      r2
 
-    movsxdifnidn  r1, r1d
     mova          m4, [pb_80]
     lea           r3, [r1*3]
 %assign %%i 0
@@ -626,7 +619,6 @@ cglobal vp3_idct_put, 3, 4, 9
 cglobal vp3_idct_add, 3, 4, 9
     VP3_IDCT      r2
 
-    movsxdifnidn  r1, r1d
     lea           r3, [r1*3]
     pxor          m4, m4
 %if mmsize == 16
@@ -733,9 +725,6 @@ vp3_idct_funcs
 
 INIT_MMX mmxext
 cglobal vp3_idct_dc_add, 3, 4
-%if ARCH_X86_64
-    movsxd        r1, r1d
-%endif
     movsx         r3, word [r2]
     mov    word [r2], 0
     lea           r2, [r1*3]
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp3dsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/vp3dsp_init.c
index 2ece9ab7d54..1ba9576431a 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp3dsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp3dsp_init.c
@@ -26,18 +26,17 @@
 #include "libavcodec/avcodec.h"
 #include "libavcodec/vp3dsp.h"
 
-void ff_vp3_idct_put_mmx(uint8_t *dest, int line_size, int16_t *block);
-void ff_vp3_idct_add_mmx(uint8_t *dest, int line_size, int16_t *block);
+void ff_vp3_idct_put_mmx(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+void ff_vp3_idct_add_mmx(uint8_t *dest, ptrdiff_t stride, int16_t *block);
 
-void ff_vp3_idct_put_sse2(uint8_t *dest, int line_size, int16_t *block);
-void ff_vp3_idct_add_sse2(uint8_t *dest, int line_size, int16_t *block);
+void ff_vp3_idct_put_sse2(uint8_t *dest, ptrdiff_t stride, int16_t *block);
+void ff_vp3_idct_add_sse2(uint8_t *dest, ptrdiff_t stride, int16_t *block);
 
-void ff_vp3_idct_dc_add_mmxext(uint8_t *dest, int line_size,
-                               int16_t *block);
+void ff_vp3_idct_dc_add_mmxext(uint8_t *dest, ptrdiff_t stride, int16_t *block);
 
-void ff_vp3_v_loop_filter_mmxext(uint8_t *src, int stride,
+void ff_vp3_v_loop_filter_mmxext(uint8_t *src, ptrdiff_t stride,
                                  int *bounding_values);
-void ff_vp3_h_loop_filter_mmxext(uint8_t *src, int stride,
+void ff_vp3_h_loop_filter_mmxext(uint8_t *src, ptrdiff_t stride,
                                  int *bounding_values);
 
 void ff_put_vp_no_rnd_pixels8_l2_mmx(uint8_t *dst, const uint8_t *a,
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp6dsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/vp6dsp.asm
index 3d874ea62a6..0be531e5c27 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp6dsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp6dsp.asm
@@ -115,7 +115,7 @@ SECTION .text
 %endmacro
 
 %macro vp6_filter_diag4 0
-; void ff_vp6_filter_diag4_<opt>(uint8_t *dst, uint8_t *src, int stride,
+; void ff_vp6_filter_diag4_<opt>(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
 ;                                const int16_t h_weight[4], const int16_t v_weights[4])
 cglobal vp6_filter_diag4, 5, 7, 8
     mov          r5, rsp         ; backup stack pointer
@@ -126,9 +126,6 @@ cglobal vp6_filter_diag4, 5, 7, 8
     sub         rsp, 8*15
     movq         m6, [pw_64]
 %endif
-%if ARCH_X86_64
-    movsxd       r2, r2d
-%endif
 
     sub          r1, r2
 
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp6dsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/vp6dsp_init.c
index 81d371d97ec..ce498931d0a 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp6dsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp6dsp_init.c
@@ -25,12 +25,12 @@
 #include "libavutil/x86/cpu.h"
 #include "libavcodec/vp56dsp.h"
 
-void ff_vp6_filter_diag4_mmx(uint8_t *dst, uint8_t *src, int stride,
+void ff_vp6_filter_diag4_mmx(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                              const int16_t *h_weights,const int16_t *v_weights);
-void ff_vp6_filter_diag4_sse2(uint8_t *dst, uint8_t *src, int stride,
+void ff_vp6_filter_diag4_sse2(uint8_t *dst, uint8_t *src, ptrdiff_t stride,
                               const int16_t *h_weights,const int16_t *v_weights);
 
-av_cold void ff_vp6dsp_init_x86(VP56DSPContext* c, enum AVCodecID codec)
+av_cold void ff_vp6dsp_init_x86(VP56DSPContext *c)
 {
     int cpu_flags = av_get_cpu_flags();
 
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp.asm b/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp.asm
index 538b3f4a9b6..e303b802938 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp.asm
@@ -156,8 +156,8 @@ SECTION .text
 ;-------------------------------------------------------------------------------
 ; subpel MC functions:
 ;
-; void ff_put_vp8_epel<size>_h<htap>v<vtap>_<opt>(uint8_t *dst, int deststride,
-;                                                 uint8_t *src, int srcstride,
+; void ff_put_vp8_epel<size>_h<htap>v<vtap>_<opt>(uint8_t *dst, ptrdiff_t deststride,
+;                                                 uint8_t *src, ptrdiff_t srcstride,
 ;                                                 int height,   int mx, int my);
 ;-------------------------------------------------------------------------------
 
@@ -884,7 +884,7 @@ cglobal put_vp8_pixels16, 5, 5, 2, dst, dststride, src, srcstride, height
     REP_RET
 
 ;-----------------------------------------------------------------------------
-; void ff_vp8_idct_dc_add_<opt>(uint8_t *dst, int16_t block[16], int stride);
+; void ff_vp8_idct_dc_add_<opt>(uint8_t *dst, int16_t block[16], ptrdiff_t stride);
 ;-----------------------------------------------------------------------------
 
 %macro ADD_DC 4
@@ -906,6 +906,7 @@ cglobal put_vp8_pixels16, 5, 5, 2, dst, dststride, src, srcstride, height
     %4 [dst2q+strideq+%3], m5
 %endmacro
 
+%if ARCH_X86_32
 INIT_MMX mmx
 cglobal vp8_idct_dc_add, 3, 3, 0, dst, block, stride
     ; load data
@@ -929,8 +930,9 @@ cglobal vp8_idct_dc_add, 3, 3, 0, dst, block, stride
     lea     dst2q, [dst1q+strideq*2]
     ADD_DC     m0, m1, 0, movh
     RET
+%endif
 
-INIT_XMM sse4
+%macro VP8_IDCT_DC_ADD 0
 cglobal vp8_idct_dc_add, 3, 3, 6, dst, block, stride
     ; load data
     movd       m0, [blockq]
@@ -956,13 +958,28 @@ cglobal vp8_idct_dc_add, 3, 3, 6, dst, block, stride
     paddw      m4, m0
     packuswb   m2, m4
     movd   [dst1q], m2
+%if cpuflag(sse4)
     pextrd [dst1q+strideq], m2, 1
     pextrd [dst2q], m2, 2
     pextrd [dst2q+strideq], m2, 3
+%else
+    psrldq     m2, 4
+    movd [dst1q+strideq], m2
+    psrldq     m2, 4
+    movd [dst2q], m2
+    psrldq     m2, 4
+    movd [dst2q+strideq], m2
+%endif
     RET
+%endmacro
+
+INIT_XMM sse2
+VP8_IDCT_DC_ADD
+INIT_XMM sse4
+VP8_IDCT_DC_ADD
 
 ;-----------------------------------------------------------------------------
-; void ff_vp8_idct_dc_add4y_<opt>(uint8_t *dst, int16_t block[4][16], int stride);
+; void ff_vp8_idct_dc_add4y_<opt>(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride);
 ;-----------------------------------------------------------------------------
 
 %if ARCH_X86_32
@@ -1035,7 +1052,7 @@ cglobal vp8_idct_dc_add4y, 3, 3, 6, dst, block, stride
     RET
 
 ;-----------------------------------------------------------------------------
-; void ff_vp8_idct_dc_add4uv_<opt>(uint8_t *dst, int16_t block[4][16], int stride);
+; void ff_vp8_idct_dc_add4uv_<opt>(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride);
 ;-----------------------------------------------------------------------------
 
 INIT_MMX mmx
@@ -1077,7 +1094,7 @@ cglobal vp8_idct_dc_add4uv, 3, 3, 0, dst, block, stride
     RET
 
 ;-----------------------------------------------------------------------------
-; void ff_vp8_idct_add_<opt>(uint8_t *dst, int16_t block[16], int stride);
+; void ff_vp8_idct_add_<opt>(uint8_t *dst, int16_t block[16], ptrdiff_t stride);
 ;-----------------------------------------------------------------------------
 
 ; calculate %1=mul_35468(%1)-mul_20091(%2); %2=mul_20091(%1)+mul_35468(%2)
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp_init.c
index 897d5a0e77c..397b2518cba 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp_init.c
@@ -26,7 +26,7 @@
 #include "libavutil/x86/cpu.h"
 #include "libavcodec/vp8dsp.h"
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 
 /*
  * MC functions
@@ -233,6 +233,8 @@ HVBILIN(ssse3, 8, 16, 16)
 
 void ff_vp8_idct_dc_add_mmx(uint8_t *dst, int16_t block[16],
                             ptrdiff_t stride);
+void ff_vp8_idct_dc_add_sse2(uint8_t *dst, int16_t block[16],
+                             ptrdiff_t stride);
 void ff_vp8_idct_dc_add_sse4(uint8_t *dst, int16_t block[16],
                              ptrdiff_t stride);
 void ff_vp8_idct_dc_add4y_mmx(uint8_t *dst, int16_t block[4][16],
@@ -288,7 +290,7 @@ DECLARE_LOOP_FILTER(sse2)
 DECLARE_LOOP_FILTER(ssse3)
 DECLARE_LOOP_FILTER(sse4)
 
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 #define VP8_LUMA_MC_FUNC(IDX, SIZE, OPT) \
     c->put_vp8_epel_pixels_tab[IDX][0][2] = ff_put_vp8_epel ## SIZE ## _h6_ ## OPT; \
@@ -316,7 +318,7 @@ DECLARE_LOOP_FILTER(sse4)
 
 av_cold void ff_vp78dsp_init_x86(VP8DSPContext *c)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_MMX(cpu_flags)) {
@@ -346,7 +348,7 @@ av_cold void ff_vp78dsp_init_x86(VP8DSPContext *c)
         c->put_vp8_bilinear_pixels_tab[0][0][0] = ff_put_vp8_pixels16_sse;
     }
 
-    if (HAVE_SSE2_EXTERNAL && cpu_flags & (AV_CPU_FLAG_SSE2 | AV_CPU_FLAG_SSE2SLOW)) {
+    if (EXTERNAL_SSE2(cpu_flags) || EXTERNAL_SSE2_SLOW(cpu_flags)) {
         VP8_LUMA_MC_FUNC(0, 16, sse2);
         VP8_MC_FUNC(1, 8, sse2);
         VP8_BILINEAR_MC_FUNC(0, 16, sse2);
@@ -361,18 +363,18 @@ av_cold void ff_vp78dsp_init_x86(VP8DSPContext *c)
         VP8_BILINEAR_MC_FUNC(1, 8, ssse3);
         VP8_BILINEAR_MC_FUNC(2, 4, ssse3);
     }
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
 
 av_cold void ff_vp8dsp_init_x86(VP8DSPContext *c)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_MMX(cpu_flags)) {
-        c->vp8_idct_dc_add    = ff_vp8_idct_dc_add_mmx;
         c->vp8_idct_dc_add4uv = ff_vp8_idct_dc_add4uv_mmx;
 #if ARCH_X86_32
+        c->vp8_idct_dc_add    = ff_vp8_idct_dc_add_mmx;
         c->vp8_idct_dc_add4y  = ff_vp8_idct_dc_add4y_mmx;
         c->vp8_idct_add       = ff_vp8_idct_add_mmx;
         c->vp8_luma_dc_wht    = ff_vp8_luma_dc_wht_mmx;
@@ -416,7 +418,7 @@ av_cold void ff_vp8dsp_init_x86(VP8DSPContext *c)
         c->vp8_luma_dc_wht                      = ff_vp8_luma_dc_wht_sse;
     }
 
-    if (HAVE_SSE2_EXTERNAL && cpu_flags & (AV_CPU_FLAG_SSE2 | AV_CPU_FLAG_SSE2SLOW)) {
+    if (EXTERNAL_SSE2(cpu_flags) || EXTERNAL_SSE2_SLOW(cpu_flags)) {
         c->vp8_v_loop_filter_simple = ff_vp8_v_loop_filter_simple_sse2;
 
         c->vp8_v_loop_filter16y_inner = ff_vp8_v_loop_filter16y_inner_sse2;
@@ -427,6 +429,7 @@ av_cold void ff_vp8dsp_init_x86(VP8DSPContext *c)
     }
 
     if (EXTERNAL_SSE2(cpu_flags)) {
+        c->vp8_idct_dc_add            = ff_vp8_idct_dc_add_sse2;
         c->vp8_idct_dc_add4y          = ff_vp8_idct_dc_add4y_sse2;
 
         c->vp8_h_loop_filter_simple   = ff_vp8_h_loop_filter_simple_sse2;
@@ -460,5 +463,5 @@ av_cold void ff_vp8dsp_init_x86(VP8DSPContext *c)
         c->vp8_h_loop_filter16y       = ff_vp8_h_loop_filter16y_mbedge_sse4;
         c->vp8_h_loop_filter8uv       = ff_vp8_h_loop_filter8uv_mbedge_sse4;
     }
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp_loopfilter.asm b/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp_loopfilter.asm
index 98bb6696a03..caeb4052670 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp_loopfilter.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp8dsp_loopfilter.asm
@@ -43,7 +43,7 @@ cextern pb_80
 SECTION .text
 
 ;-----------------------------------------------------------------------------
-; void ff_vp8_h/v_loop_filter_simple_<opt>(uint8_t *dst, int stride, int flim);
+; void ff_vp8_h/v_loop_filter_simple_<opt>(uint8_t *dst, ptrdiff_t stride, int flim);
 ;-----------------------------------------------------------------------------
 
 ; macro called with 7 mm register indexes as argument, and 4 regular registers
@@ -429,7 +429,7 @@ INIT_XMM sse4
 SIMPLE_LOOPFILTER h, 5
 
 ;-----------------------------------------------------------------------------
-; void ff_vp8_h/v_loop_filter<size>_inner_<opt>(uint8_t *dst, [uint8_t *v,] int stride,
+; void ff_vp8_h/v_loop_filter<size>_inner_<opt>(uint8_t *dst, [uint8_t *v,] ptrdiff_t stride,
 ;                                               int flimE, int flimI, int hev_thr);
 ;-----------------------------------------------------------------------------
 
@@ -921,7 +921,7 @@ INNER_LOOPFILTER v,  8
 INNER_LOOPFILTER h,  8
 
 ;-----------------------------------------------------------------------------
-; void ff_vp8_h/v_loop_filter<size>_mbedge_<opt>(uint8_t *dst, [uint8_t *v,] int stride,
+; void ff_vp8_h/v_loop_filter<size>_mbedge_<opt>(uint8_t *dst, [uint8_t *v,] ptrdiff_t stride,
 ;                                                int flimE, int flimI, int hev_thr);
 ;-----------------------------------------------------------------------------
 
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init.c b/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init.c
index cc781a009bb..837cce85081 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init.c
@@ -27,7 +27,7 @@
 #include "libavcodec/vp9dsp.h"
 #include "libavcodec/x86/vp9dsp_init.h"
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 
 decl_fpel_func(put,  4,   , mmx);
 decl_fpel_func(put,  8,   , mmx);
@@ -114,7 +114,7 @@ itxfm_func(idct, idct, 32, sse2);
 itxfm_func(idct, idct, 32, ssse3);
 itxfm_func(idct, idct, 32, avx);
 itxfm_func(iwht, iwht, 4, mmx);
-itxfm_func(idct, idct, 16, avx2);
+itxfm_funcs(16, avx2);
 itxfm_func(idct, idct, 32, avx2);
 
 #undef itxfm_func
@@ -212,11 +212,11 @@ ipred_func(32, tm, avx2);
 #undef ipred_dir_tm_funcs
 #undef ipred_dc_funcs
 
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 av_cold void ff_vp9dsp_init_x86(VP9DSPContext *dsp, int bpp, int bitexact)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags;
 
     if (bpp == 10) {
@@ -391,6 +391,12 @@ av_cold void ff_vp9dsp_init_x86(VP9DSPContext *dsp, int bpp, int bitexact)
         if (ARCH_X86_64) {
 #if ARCH_X86_64 && HAVE_AVX2_EXTERNAL
             dsp->itxfm_add[TX_16X16][DCT_DCT] = ff_vp9_idct_idct_16x16_add_avx2;
+            dsp->itxfm_add[TX_16X16][ADST_DCT]  = ff_vp9_idct_iadst_16x16_add_avx2;
+            dsp->itxfm_add[TX_16X16][DCT_ADST]  = ff_vp9_iadst_idct_16x16_add_avx2;
+            dsp->itxfm_add[TX_16X16][ADST_ADST] = ff_vp9_iadst_iadst_16x16_add_avx2;
+            dsp->itxfm_add[TX_32X32][ADST_ADST] =
+            dsp->itxfm_add[TX_32X32][ADST_DCT] =
+            dsp->itxfm_add[TX_32X32][DCT_ADST] =
             dsp->itxfm_add[TX_32X32][DCT_DCT] = ff_vp9_idct_idct_32x32_add_avx2;
             init_subpel3_32_64(0, put, 8, avx2);
             init_subpel3_32_64(1, avg, 8, avx2);
@@ -406,5 +412,5 @@ av_cold void ff_vp9dsp_init_x86(VP9DSPContext *dsp, int bpp, int bitexact)
 #undef init_subpel2
 #undef init_subpel3
 
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init_16bpp.c b/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init_16bpp.c
index eb67499c962..60d10a12a3a 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init_16bpp.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init_16bpp.c
@@ -27,7 +27,7 @@
 #include "libavcodec/vp9dsp.h"
 #include "libavcodec/x86/vp9dsp_init.h"
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 
 decl_fpel_func(put,   8,    , mmx);
 decl_fpel_func(avg,   8, _16, mmxext);
@@ -51,6 +51,10 @@ decl_ipred_fns(h,       16, mmxext, sse2);
 decl_ipred_fns(dc,      16, mmxext, sse2);
 decl_ipred_fns(dc_top,  16, mmxext, sse2);
 decl_ipred_fns(dc_left, 16, mmxext, sse2);
+decl_ipred_fn(dl,       16,     16, avx2);
+decl_ipred_fn(dl,       32,     16, avx2);
+decl_ipred_fn(dr,       16,     16, avx2);
+decl_ipred_fn(dr,       32,     16, avx2);
 
 #define decl_ipred_dir_funcs(type) \
 decl_ipred_fns(type, 16, sse2,  sse2); \
@@ -63,11 +67,11 @@ decl_ipred_dir_funcs(vl);
 decl_ipred_dir_funcs(vr);
 decl_ipred_dir_funcs(hu);
 decl_ipred_dir_funcs(hd);
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 av_cold void ff_vp9dsp_init_16bpp_x86(VP9DSPContext *dsp)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_MMX(cpu_flags)) {
@@ -133,7 +137,13 @@ av_cold void ff_vp9dsp_init_16bpp_x86(VP9DSPContext *dsp)
         init_fpel_func(2, 1,  32, avg, _16, avx2);
         init_fpel_func(1, 1,  64, avg, _16, avx2);
         init_fpel_func(0, 1, 128, avg, _16, avx2);
+        init_ipred_func(dl, DIAG_DOWN_LEFT, 16, 16, avx2);
+        init_ipred_func(dl, DIAG_DOWN_LEFT, 32, 16, avx2);
+        init_ipred_func(dr, DIAG_DOWN_RIGHT, 16, 16, avx2);
+#if ARCH_X86_64
+        init_ipred_func(dr, DIAG_DOWN_RIGHT, 32, 16, avx2);
+#endif
     }
 
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init_16bpp_template.c b/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init_16bpp_template.c
index 4840b2844e3..b56afc7f504 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init_16bpp_template.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp9dsp_init_16bpp_template.c
@@ -27,7 +27,7 @@
 #include "libavcodec/vp9dsp.h"
 #include "libavcodec/x86/vp9dsp_init.h"
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 
 extern const int16_t ff_filters_16bpp[3][15][4][16];
 
@@ -137,11 +137,11 @@ decl_itxfm_func(iadst, iadst, 4, BPC, sse2);
 decl_itxfm_funcs(8, BPC, sse2);
 decl_itxfm_funcs(16, BPC, sse2);
 decl_itxfm_func(idct,  idct, 32, BPC, sse2);
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 av_cold void INIT_FUNC(VP9DSPContext *dsp, int bitexact)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
 #define init_lpf_8_func(idx1, idx2, dir, wd, bpp, opt) \
@@ -234,7 +234,7 @@ av_cold void INIT_FUNC(VP9DSPContext *dsp, int bitexact)
 #endif
     }
 
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
     ff_vp9dsp_init_16bpp_x86(dsp);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp9intrapred_16bpp.asm b/mythtv/external/FFmpeg/libavcodec/x86/vp9intrapred_16bpp.asm
index c0ac16d3eba..32b698243a8 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp9intrapred_16bpp.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp9intrapred_16bpp.asm
@@ -847,6 +847,108 @@ DL_FUNCS
 INIT_XMM avx
 DL_FUNCS
 
+%if HAVE_AVX2_EXTERNAL
+INIT_YMM avx2
+cglobal vp9_ipred_dl_16x16_16, 2, 4, 5, dst, stride, l, a
+    movifnidn               aq, amp
+    mova                    m0, [aq]                   ; abcdefghijklmnop
+    vpbroadcastw           xm1, [aq+30]                ; pppppppp
+    vperm2i128              m2, m0, m1, q0201          ; ijklmnoppppppppp
+    vpalignr                m3, m2, m0, 2              ; bcdefghijklmnopp
+    vpalignr                m4, m2, m0, 4              ; cdefghijklmnoppp
+    LOWPASS                  0,  3,  4                 ; BCDEFGHIJKLMNOPp
+    vperm2i128              m2, m0, m1, q0201          ; JKLMNOPppppppppp
+    DEFINE_ARGS dst, stride, stride3, cnt
+    mov                   cntd, 2
+    lea               stride3q, [strideq*3]
+
+.loop:
+    mova      [dstq+strideq*0], m0
+    vpalignr                m3, m2, m0, 2
+    vpalignr                m4, m2, m0, 4
+    mova      [dstq+strideq*1], m3
+    mova      [dstq+strideq*2], m4
+    vpalignr                m3, m2, m0, 6
+    vpalignr                m4, m2, m0, 8
+    mova      [dstq+stride3q ], m3
+    lea                   dstq, [dstq+strideq*4]
+    mova      [dstq+strideq*0], m4
+    vpalignr                m3, m2, m0, 10
+    vpalignr                m4, m2, m0, 12
+    mova      [dstq+strideq*1], m3
+    mova      [dstq+strideq*2], m4
+    vpalignr                m3, m2, m0, 14
+    mova      [dstq+stride3q ], m3
+    lea                   dstq, [dstq+strideq*4]
+    mova                    m0, m2
+    vperm2i128              m2, m2, m2, q0101          ; pppppppppppppppp
+    dec                   cntd
+    jg .loop
+    RET
+
+cglobal vp9_ipred_dl_32x32_16, 2, 6, 7, dst, stride, l, a
+    movifnidn               aq, amp
+    mova                    m0, [aq+mmsize*0+ 0]       ; abcdefghijklmnop
+    mova                    m1, [aq+mmsize*1+ 0]       ; qrstuvwxyz012345
+    vpbroadcastw           xm4, [aq+mmsize*1+30]       ; 55555555
+    vperm2i128              m5, m0, m1, q0201          ; ijklmnopqrstuvwx
+    vpalignr                m2, m5, m0, 2              ; bcdefghijklmnopq
+    vpalignr                m3, m5, m0, 4              ; cdefghijklmnopqr
+    LOWPASS                  0,  2,  3                 ; BCDEFGHIJKLMNOPQ
+    vperm2i128              m5, m1, m4, q0201          ; yz01234555555555
+    vpalignr                m2, m5, m1, 2              ; rstuvwxyz0123455
+    vpalignr                m3, m5, m1, 4              ; stuvwxyz01234555
+    LOWPASS                  1,  2,  3                 ; RSTUVWXYZ......5
+    vperm2i128              m2, m1, m4, q0201          ; Z......555555555
+    vperm2i128              m5, m0, m1, q0201          ; JKLMNOPQRSTUVWXY
+    DEFINE_ARGS dst, stride, stride3, cnt
+    lea               stride3q, [strideq*3]
+    mov                   cntd, 4
+
+.loop:
+    mova   [dstq+strideq*0 + 0], m0
+    mova   [dstq+strideq*0 +32], m1
+    vpalignr                 m3, m5, m0, 2
+    vpalignr                 m4, m2, m1, 2
+    mova   [dstq+strideq*1 + 0], m3
+    mova   [dstq+strideq*1 +32], m4
+    vpalignr                 m3, m5, m0, 4
+    vpalignr                 m4, m2, m1, 4
+    mova   [dstq+strideq*2 + 0], m3
+    mova   [dstq+strideq*2 +32], m4
+    vpalignr                 m3, m5, m0, 6
+    vpalignr                 m4, m2, m1, 6
+    mova   [dstq+stride3q*1+ 0], m3
+    mova   [dstq+stride3q*1+32], m4
+    lea                    dstq, [dstq+strideq*4]
+    vpalignr                 m3, m5, m0, 8
+    vpalignr                 m4, m2, m1, 8
+    mova   [dstq+strideq*0 + 0], m3
+    mova   [dstq+strideq*0 +32], m4
+    vpalignr                 m3, m5, m0, 10
+    vpalignr                 m4, m2, m1, 10
+    mova   [dstq+strideq*1 + 0], m3
+    mova   [dstq+strideq*1 +32], m4
+    vpalignr                 m3, m5, m0, 12
+    vpalignr                 m4, m2, m1, 12
+    mova   [dstq+strideq*2+ 0], m3
+    mova   [dstq+strideq*2+32], m4
+    vpalignr                 m3, m5, m0, 14
+    vpalignr                 m4, m2, m1, 14
+    mova   [dstq+stride3q+  0], m3
+    mova   [dstq+stride3q+ 32], m4
+    vpalignr                 m3, m5, m0, 16
+    vpalignr                 m4, m2, m1, 16
+    vperm2i128               m5, m3, m4, q0201
+    vperm2i128               m2, m4, m4, q0101
+    mova                     m0, m3
+    mova                     m1, m4
+    lea                    dstq, [dstq+strideq*4]
+    dec                    cntd
+    jg .loop
+    RET
+%endif
+
 %macro DR_FUNCS 1 ; stack_mem_for_32x32_32bit_function
 cglobal vp9_ipred_dr_4x4_16, 4, 4, 3, dst, stride, l, a
     movh                    m0, [lq]                ; wxyz....
@@ -1068,6 +1170,161 @@ DR_FUNCS 2
 INIT_XMM avx
 DR_FUNCS 2
 
+%if HAVE_AVX2_EXTERNAL
+INIT_YMM avx2
+cglobal vp9_ipred_dr_16x16_16, 4, 5, 6, dst, stride, l, a
+    mova                    m0, [lq]                   ; klmnopqrstuvwxyz
+    movu                    m1, [aq-2]                 ; *abcdefghijklmno
+    mova                    m2, [aq]                   ; abcdefghijklmnop
+    vperm2i128              m4, m2, m2, q2001          ; ijklmnop........
+    vpalignr                m5, m4, m2, 2              ; bcdefghijklmnop.
+    vperm2i128              m3, m0, m1, q0201          ; stuvwxyz*abcdefg
+    LOWPASS                  1,  2,  5                 ; ABCDEFGHIJKLMNO.
+    vpalignr                m4, m3, m0, 2              ; lmnopqrstuvwxyz*
+    vpalignr                m5, m3, m0, 4              ; mnopqrstuvwxyz*a
+    LOWPASS                  0,  4,  5                 ; LMNOPQRSTUVWXYZ#
+    vperm2i128              m5, m0, m1, q0201          ; TUVWXYZ#ABCDEFGH
+    DEFINE_ARGS dst, stride, stride3, stride5, dst3
+    lea                  dst3q, [dstq+strideq*4]
+    lea               stride3q, [strideq*3]
+    lea               stride5q, [stride3q+strideq*2]
+
+    vpalignr                m3, m5, m0, 2
+    vpalignr                m4, m1, m5, 2
+    mova    [dst3q+stride5q*2], m3                     ; 14
+    mova    [ dstq+stride3q*2], m4                     ; 6
+    vpalignr                m3, m5, m0, 4
+    vpalignr                m4, m1, m5, 4
+    sub                  dst3q, strideq
+    mova    [dst3q+stride5q*2], m3                     ; 13
+    mova    [dst3q+strideq*2 ], m4                     ; 5
+    mova    [dst3q+stride3q*4], m0                     ; 15
+    vpalignr                m3, m5, m0, 6
+    vpalignr                m4, m1, m5, 6
+    mova     [dstq+stride3q*4], m3                     ; 12
+    mova     [dst3q+strideq*1], m4                     ; 4
+    vpalignr                m3, m5, m0, 8
+    vpalignr                m4, m1, m5, 8
+    mova     [dst3q+strideq*8], m3                     ; 11
+    mova     [dst3q+strideq*0], m4                     ; 3
+    vpalignr                m3, m5, m0, 10
+    vpalignr                m4, m1, m5, 10
+    mova     [dstq+stride5q*2], m3                     ; 10
+    mova     [dstq+strideq*2 ], m4                     ; 2
+    vpalignr                m3, m5, m0, 12
+    vpalignr                m4, m1, m5, 12
+    mova    [dst3q+stride3q*2], m3                     ; 9
+    mova     [dstq+strideq*1 ], m4                     ; 1
+    vpalignr                m3, m5, m0, 14
+    vpalignr                m4, m1, m5, 14
+    mova      [dstq+strideq*8], m3                     ; 8
+    mova      [dstq+strideq*0], m4                     ; 0
+    mova     [dst3q+strideq*4], m5                     ; 7
+    RET
+
+%if ARCH_X86_64
+cglobal vp9_ipred_dr_32x32_16, 4, 7, 10, dst, stride, l, a
+    mova                    m0, [lq+mmsize*0+0]        ; l[0-15]
+    mova                    m1, [lq+mmsize*1+0]        ; l[16-31]
+    movu                    m2, [aq+mmsize*0-2]        ; *abcdefghijklmno
+    mova                    m3, [aq+mmsize*0+0]        ; abcdefghijklmnop
+    mova                    m4, [aq+mmsize*1+0]        ; qrstuvwxyz012345
+    vperm2i128              m5, m0, m1, q0201          ; lmnopqrstuvwxyz0
+    vpalignr                m6, m5, m0, 2              ; mnopqrstuvwxyz01
+    vpalignr                m7, m5, m0, 4              ; nopqrstuvwxyz012
+    LOWPASS                  0,  6,  7                 ; L[0-15]
+    vperm2i128              m7, m1, m2, q0201          ; stuvwxyz*abcdefg
+    vpalignr                m5, m7, m1, 2              ; lmnopqrstuvwxyz*
+    vpalignr                m6, m7, m1, 4              ; mnopqrstuvwxyz*a
+    LOWPASS                  1,  5,  6                 ; L[16-31]#
+    vperm2i128              m5, m3, m4, q0201          ; ijklmnopqrstuvwx
+    vpalignr                m6, m5, m3, 2              ; bcdefghijklmnopq
+    LOWPASS                  2,  3,  6                 ; A[0-15]
+    movu                    m3, [aq+mmsize*1-2]        ; pqrstuvwxyz01234
+    vperm2i128              m6, m4, m4, q2001          ; yz012345........
+    vpalignr                m7, m6, m4, 2              ; rstuvwxyz012345.
+    LOWPASS                  3,  4,  7                 ; A[16-31].
+    vperm2i128              m4, m1, m2, q0201          ; TUVWXYZ#ABCDEFGH
+    vperm2i128              m5, m0, m1, q0201          ; L[7-15]L[16-23]
+    vperm2i128              m8, m2, m3, q0201          ; IJKLMNOPQRSTUVWX
+    DEFINE_ARGS dst8, stride, stride3, stride7, stride5, dst24, cnt
+    lea               stride3q, [strideq*3]
+    lea               stride5q, [stride3q+strideq*2]
+    lea               stride7q, [strideq*4+stride3q]
+    lea                 dst24q, [dst8q+stride3q*8]
+    lea                  dst8q, [dst8q+strideq*8]
+    mov                   cntd, 2
+
+.loop:
+    mova  [dst24q+stride7q+0 ], m0                     ; 31 23 15 7
+    mova  [dst24q+stride7q+32], m1
+    mova    [dst8q+stride7q+0], m1
+    mova   [dst8q+stride7q+32], m2
+    vpalignr                m6, m4, m1, 2
+    vpalignr                m7, m5, m0, 2
+    vpalignr                m9, m8, m2, 2
+    mova [dst24q+stride3q*2+0], m7                     ; 30 22 14 6
+    mova [dst24q+stride3q*2+32], m6
+    mova  [dst8q+stride3q*2+0], m6
+    mova [dst8q+stride3q*2+32], m9
+    vpalignr                m6, m4, m1, 4
+    vpalignr                m7, m5, m0, 4
+    vpalignr                m9, m8, m2, 4
+    mova   [dst24q+stride5q+0], m7                     ; 29 21 13 5
+    mova  [dst24q+stride5q+32], m6
+    mova    [dst8q+stride5q+0], m6
+    mova   [dst8q+stride5q+32], m9
+    vpalignr                m6, m4, m1, 6
+    vpalignr                m7, m5, m0, 6
+    vpalignr                m9, m8, m2, 6
+    mova [dst24q+strideq*4+0 ], m7                     ; 28 20 12 4
+    mova [dst24q+strideq*4+32], m6
+    mova   [dst8q+strideq*4+0], m6
+    mova  [dst8q+strideq*4+32], m9
+    vpalignr                m6, m4, m1, 8
+    vpalignr                m7, m5, m0, 8
+    vpalignr                m9, m8, m2, 8
+    mova  [dst24q+stride3q+0 ], m7                     ; 27 19 11 3
+    mova  [dst24q+stride3q+32], m6
+    mova    [dst8q+stride3q+0], m6
+    mova   [dst8q+stride3q+32], m9
+    vpalignr                m6, m4, m1, 10
+    vpalignr                m7, m5, m0, 10
+    vpalignr                m9, m8, m2, 10
+    mova [dst24q+strideq*2+0 ], m7                     ; 26 18 10 2
+    mova [dst24q+strideq*2+32], m6
+    mova   [dst8q+strideq*2+0], m6
+    mova  [dst8q+strideq*2+32], m9
+    vpalignr                m6, m4, m1, 12
+    vpalignr                m7, m5, m0, 12
+    vpalignr                m9, m8, m2, 12
+    mova   [dst24q+strideq+0 ], m7                     ; 25 17 9 1
+    mova   [dst24q+strideq+32], m6
+    mova     [dst8q+strideq+0], m6
+    mova    [dst8q+strideq+32], m9
+    vpalignr                m6, m4, m1, 14
+    vpalignr                m7, m5, m0, 14
+    vpalignr                m9, m8, m2, 14
+    mova [dst24q+strideq*0+0 ], m7                     ; 24 16 8 0
+    mova [dst24q+strideq*0+32], m6
+    mova   [dst8q+strideq*0+0], m6
+    mova  [dst8q+strideq*0+32], m9
+    mova                    m0, m5
+    mova                    m5, m1
+    mova                    m1, m4
+    mova                    m4, m2
+    mova                    m2, m8
+    mova                    m8, m3
+    sub                 dst24q, stride7q
+    sub                 dst24q, strideq
+    sub                  dst8q, stride7q
+    sub                  dst8q, strideq
+    dec                   cntd
+    jg .loop
+    RET
+%endif
+%endif
+
 %macro VL_FUNCS 1 ; stack_mem_for_32x32_32bit_function
 cglobal vp9_ipred_vl_4x4_16, 2, 4, 3, dst, stride, l, a
     movifnidn               aq, amp
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp9itxfm.asm b/mythtv/external/FFmpeg/libavcodec/x86/vp9itxfm.asm
index 57d6d353bd8..2c63fe514a3 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp9itxfm.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp9itxfm.asm
@@ -1581,33 +1581,30 @@ cglobal vp9_idct_idct_16x16_add, 4, 4, 16, dst, stride, block, eob
     VP9_IDCT16_YMM_1D
 
     mova      [blockq+224], m7
-    mova      [blockq+480], m15
-    pxor               m15, m15
 
     ; store
-    VP9_IDCT8_WRITEx2    0,  1, 6, 7, 15, [pw_512], 6
+    VP9_IDCT8_WRITEx2    0,  1, 6, 7, unused, [pw_512], 6
     lea               dstq, [dstq+2*strideq]
-    VP9_IDCT8_WRITEx2    2,  3, 6, 7, 15, [pw_512], 6
+    VP9_IDCT8_WRITEx2    2,  3, 6, 7, unused, [pw_512], 6
     lea               dstq, [dstq+2*strideq]
-    VP9_IDCT8_WRITEx2    4,  5, 6, 7, 15, [pw_512], 6
+    VP9_IDCT8_WRITEx2    4,  5, 6, 7, unused, [pw_512], 6
     lea               dstq, [dstq+2*strideq]
     mova                m6, [blockq+192]
     mova                m7, [blockq+224]
-    SWAP                 0, 15
-    mova               m15, [blockq+480]
-    VP9_IDCT8_WRITEx2    6,  7, 1, 2, 0, [pw_512], 6
+    VP9_IDCT8_WRITEx2    6,  7, 1, 2, unused, [pw_512], 6
     lea               dstq, [dstq+2*strideq]
-    VP9_IDCT8_WRITEx2    8,  9, 1, 2, 0, [pw_512], 6
+    VP9_IDCT8_WRITEx2    8,  9, 1, 2, unused, [pw_512], 6
     lea               dstq, [dstq+2*strideq]
-    VP9_IDCT8_WRITEx2   10, 11, 1, 2, 0, [pw_512], 6
+    VP9_IDCT8_WRITEx2   10, 11, 1, 2, unused, [pw_512], 6
     lea               dstq, [dstq+2*strideq]
-    VP9_IDCT8_WRITEx2   12, 13, 1, 2, 0, [pw_512], 6
+    VP9_IDCT8_WRITEx2   12, 13, 1, 2, unused, [pw_512], 6
     lea               dstq, [dstq+2*strideq]
-    VP9_IDCT8_WRITEx2   14, 15, 1, 2, 0, [pw_512], 6
+    VP9_IDCT8_WRITEx2   14, 15, 1, 2, unused, [pw_512], 6
     lea               dstq, [dstq+2*strideq]
 
     ; at the end of the loop, m0 should still be zero
     ; use that to zero out block coefficients
+    pxor                m0, m0
     ZERO_BLOCK      blockq, 32, 16, m0
     RET
 %endif
@@ -1987,6 +1984,173 @@ IADST16_FN idct,  IDCT16,  iadst, IADST16, avx
 IADST16_FN iadst, IADST16, idct,  IDCT16,  avx
 IADST16_FN iadst, IADST16, iadst, IADST16, avx
 
+; in: data in m[0-15] except m0/m4, which are in [blockq+0] and [blockq+128]
+; out: m[0-15] except m6, which is in [blockq+192]
+; uses blockq as scratch space
+%macro VP9_IADST16_YMM_1D 0
+    mova          [blockq+ 32], m3
+    mova          [blockq+ 64], m7
+    mova          [blockq+ 96], m8
+
+    ; first half of round 1
+    VP9_UNPACK_MULSUB_2D_4X  9,  6,  0,  3, 13160,  9760    ; m9/x=t7[d], m6/x=t6[d]
+    VP9_UNPACK_MULSUB_2D_4X  1, 14,  4,  7,  2404, 16207    ; m1/x=t15[d], m14/x=t14[d]
+    VP9_RND_SH_SUMSUB_BA    14,  6,  7,  3,  8, [pd_8192]   ; m14=t6[w], m6=t14[w]
+    VP9_RND_SH_SUMSUB_BA     1,  9,  4,  0,  8, [pd_8192]   ; m1=t7[w], m9=t15[w]
+
+    VP9_UNPACK_MULSUB_2D_4X 13,  2,  4,  7, 15893,  3981    ; m13/x=t3[d], m2/x=t2[d]
+    VP9_UNPACK_MULSUB_2D_4X  5, 10,  0,  3,  8423, 14053    ; m5/x=t11[d], m10/x=t10[d]
+    VP9_RND_SH_SUMSUB_BA    10,  2,  3,  7,  8, [pd_8192]   ; m10=t2[w], m2=t10[w]
+    VP9_RND_SH_SUMSUB_BA     5, 13,  0,  4,  8, [pd_8192]   ; m5=t3[w], m13=t11[w]
+
+    ; half of round 2 t8-15
+    VP9_UNPACK_MULSUB_2D_4X  2, 13,  4,  7,  9102, 13623    ; m2/x=t11[d], m13/x=t10[d]
+    VP9_UNPACK_MULSUB_2D_4X  9,  6,  3,  0, 13623,  9102    ; m9/x=t14[d], m6/x=t15[d]
+    VP9_RND_SH_SUMSUB_BA     9, 13,  3,  7,  8, [pd_8192]   ; m9=t10[w], m13=t14[w]
+    VP9_RND_SH_SUMSUB_BA     6,  2,  0,  4,  8, [pd_8192]   ; m6=t11[w], m2=t15[w]
+
+    SUMSUB_BA            w, 14, 10,  8                      ; m14=t2, m10=t6
+    SUMSUB_BA            w,  1,  5,  8                      ; m1=t3, m5=t7
+
+    mova                    m0, [blockq+  0]
+    mova                    m4, [blockq+128]
+    mova                    m3, [blockq+ 32]
+    mova                    m7, [blockq+ 64]
+    mova                    m8, [blockq+ 96]
+    mova          [blockq+  0], m1
+    mova          [blockq+128], m14
+    mova          [blockq+ 32], m6
+    mova          [blockq+ 64], m9
+    mova          [blockq+ 96], m10
+
+    ; second half of round 1
+    VP9_UNPACK_MULSUB_2D_4X 15,  0,  1,  9, 16364,   804    ; m15/x=t1[d], m0/x=t0[d]
+    VP9_UNPACK_MULSUB_2D_4X  7,  8, 10,  6, 11003, 12140    ; m7/x=t9[d], m8/x=t8[d]
+    VP9_RND_SH_SUMSUB_BA     8,  0,  6,  9, 14, [pd_8192]   ; m8=t0[w], m0=t8[w]
+    VP9_RND_SH_SUMSUB_BA     7, 15, 10,  1, 14, [pd_8192]   ; m7=t1[w], m15=t9[w]
+
+    VP9_UNPACK_MULSUB_2D_4X 11,  4, 10,  6, 14811,  7005    ; m11/x=t5[d], m4/x=t4[d]
+    VP9_UNPACK_MULSUB_2D_4X  3, 12,  1,  9,  5520, 15426    ; m3/x=t13[d], m12/x=t12[d]
+    VP9_RND_SH_SUMSUB_BA    12,  4,  9,  6, 14, [pd_8192]   ; m12=t4[w], m4=t12[w]
+    VP9_RND_SH_SUMSUB_BA     3, 11,  1, 10, 14, [pd_8192]   ; m3=t5[w], m11=t13[w]
+
+    ; second half of round 2 t8-15
+    VP9_UNPACK_MULSUB_2D_4X  0, 15,  6, 10, 16069,  3196    ; m15/x=t8[d], m0/x=t9[d]
+    VP9_UNPACK_MULSUB_2D_4X 11,  4,  9,  1,  3196, 16069    ; m11/x=t12[d], m4/x=t13[d]
+    VP9_RND_SH_SUMSUB_BA    11, 15,  9, 10, 14, [pd_8192]   ; m11=t8[w], m15=t12[w]
+    VP9_RND_SH_SUMSUB_BA     4,  0,  1,  6, 14, [pd_8192]   ; m4=t9[w], m0=t13[w]
+
+    SUMSUB_BA            w, 12,  8, 14                      ; m12=t0, m8=t4
+    SUMSUB_BA            w,  3,  7, 14                      ; m3=t1, m7=t5
+
+    mova                   m10, [blockq+ 96]
+    mova          [blockq+ 96], m12
+
+    ; round 3
+    VP9_UNPACK_MULSUB_2D_4X 15,  0,  9, 12, 15137,  6270    ; m15/x=t13[d], m0/x=t12[d]
+    VP9_UNPACK_MULSUB_2D_4X  2, 13,  1,  6,  6270, 15137    ; m2/x=t14[d], m13/x=t15[d]
+    VP9_RND_SH_SUMSUB_BA     2,  0,  1, 12, 14, [pd_8192]   ; m2=out2[w], m0=t14a[w]
+    VP9_RND_SH_SUMSUB_BA    13, 15,  6,  9, 14, [pd_8192]
+    PSIGNW                 m13, [pw_m1]                     ; m13=out13[w], m15=t15a[w]
+
+    VP9_UNPACK_MULSUB_2D_4X  8,  7, 12,  9, 15137,  6270    ; m8/x=t5[d], m7/x=t4[d]
+    VP9_UNPACK_MULSUB_2D_4X  5, 10,  1,  6,  6270, 15137    ; m5/x=t6[d], m10/x=t7[d]
+    VP9_RND_SH_SUMSUB_BA     5,  7,  1,  9, 14, [pd_8192]
+    PSIGNW                  m5, [pw_m1]                     ; m5=out3[w], m7=t6[w]
+    VP9_RND_SH_SUMSUB_BA    10,  8,  6, 12, 14, [pd_8192]   ; m10=out12[w], m8=t7[w]
+
+    mova                    m1, [blockq+  0]
+    mova                   m14, [blockq+128]
+    mova                    m6, [blockq+ 32]
+    mova                    m9, [blockq+ 64]
+    mova                   m12, [blockq+ 96]
+    mova          [blockq+  0], m10
+    mova          [blockq+128], m5
+
+    SUMSUB_BA            w, 14, 12,  5                      ; m14=out0, m12=t2a
+    SUMSUB_BA            w,  1,  3,  5
+    PSIGNW                  m1, [pw_m1]                     ; m1=out15, m3=t3a
+
+    SUMSUB_BA            w,  9, 11,  5
+    PSIGNW                  m9, [pw_m1]                     ; m9=out1, m11=t10
+    SUMSUB_BA            w,  6,  4,  5                      ; m6=out14, m4=t11
+
+    VP9_UNPACK_MULSUB_2W_4X  4, 11, 11585, 11585, [pd_8192],  5, 10 ; m4=out9, m11=out6
+    mova                    m5, [blockq+128]
+    mova          [blockq+192], m11
+    PSIGNW                 m15, [pw_m1]
+    VP9_UNPACK_MULSUB_2W_4X 15,  0, 11585, 11585, [pd_8192], 10, 11 ; m15=out5, m0=out10
+
+    PSIGNW                  m3, [pw_m1]
+    VP9_UNPACK_MULSUB_2W_4X  3, 12, 11585, 11585, [pd_8192], 10, 11 ; m3=out7,m12=out8
+    VP9_UNPACK_MULSUB_2W_4X  8,  7, 11585, 11585, [pd_8192], 10, 11 ; m8=out11,m7=out4
+
+    mova                   m10, [blockq+  0]
+
+    SWAP                     0, 14,  6, 11,  8, 12, 10
+    SWAP                     1,  9, 15,  4,  7,  3,  5
+    SWAP                     5,  9, 15
+%endmacro
+
+%if ARCH_X86_64 && HAVE_AVX2_EXTERNAL
+%macro IADST16_YMM_FN 4
+INIT_YMM avx2
+cglobal vp9_%1_%3_16x16_add, 4, 4, 16, dst, stride, block, eob
+    mova                m1, [blockq+ 32]
+    mova                m2, [blockq+ 64]
+    mova                m3, [blockq+ 96]
+    mova                m5, [blockq+160]
+    mova                m6, [blockq+192]
+    mova                m7, [blockq+224]
+    mova                m8, [blockq+256]
+    mova                m9, [blockq+288]
+    mova               m10, [blockq+320]
+    mova               m11, [blockq+352]
+    mova               m12, [blockq+384]
+    mova               m13, [blockq+416]
+    mova               m14, [blockq+448]
+    mova               m15, [blockq+480]
+
+    VP9_%2_YMM_1D
+    TRANSPOSE16x16W      0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, \
+                         [blockq+192], [blockq+128], 1
+    mova      [blockq+  0], m0
+    VP9_%4_YMM_1D
+
+    mova      [blockq+224], m7
+
+    ; store
+    VP9_IDCT8_WRITEx2    0,  1, 6, 7, unused, [pw_512], 6
+    lea               dstq, [dstq+2*strideq]
+    VP9_IDCT8_WRITEx2    2,  3, 6, 7, unused, [pw_512], 6
+    lea               dstq, [dstq+2*strideq]
+    VP9_IDCT8_WRITEx2    4,  5, 6, 7, unused, [pw_512], 6
+    lea               dstq, [dstq+2*strideq]
+    mova                m6, [blockq+192]
+    mova                m7, [blockq+224]
+    VP9_IDCT8_WRITEx2    6,  7, 1, 2, unused, [pw_512], 6
+    lea               dstq, [dstq+2*strideq]
+    VP9_IDCT8_WRITEx2    8,  9, 1, 2, unused, [pw_512], 6
+    lea               dstq, [dstq+2*strideq]
+    VP9_IDCT8_WRITEx2   10, 11, 1, 2, unused, [pw_512], 6
+    lea               dstq, [dstq+2*strideq]
+    VP9_IDCT8_WRITEx2   12, 13, 1, 2, unused, [pw_512], 6
+    lea               dstq, [dstq+2*strideq]
+    VP9_IDCT8_WRITEx2   14, 15, 1, 2, unused, [pw_512], 6
+    lea               dstq, [dstq+2*strideq]
+
+    ; at the end of the loop, m0 should still be zero
+    ; use that to zero out block coefficients
+    pxor                m0, m0
+    ZERO_BLOCK      blockq, 32, 16, m0
+    RET
+%endmacro
+
+IADST16_YMM_FN idct,  IDCT16,  iadst, IADST16
+IADST16_YMM_FN iadst, IADST16, idct,  IDCT16
+IADST16_YMM_FN iadst, IADST16, iadst, IADST16
+%endif
+
 ;---------------------------------------------------------------------------------------------
 ; void vp9_idct_idct_32x32_add_<opt>(uint8_t *dst, ptrdiff_t stride, int16_t *block, int eob);
 ;---------------------------------------------------------------------------------------------
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/vp9mc.asm b/mythtv/external/FFmpeg/libavcodec/x86/vp9mc.asm
index 9152ba541be..f64161b2c28 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/vp9mc.asm
+++ b/mythtv/external/FFmpeg/libavcodec/x86/vp9mc.asm
@@ -1,5 +1,5 @@
 ;******************************************************************************
-;* VP9 MC SIMD optimizations
+;* VP9 motion compensation SIMD optimizations
 ;*
 ;* Copyright (c) 2013 Ronald S. Bultje <rsbultje gmail com>
 ;*
@@ -440,9 +440,8 @@ cglobal vp9_%1_8tap_1d_v_ %+ %%px %+ _8, 4, 7, 11, dst, dstride, src, sstride, f
     mova       m10, [filteryq+96]
 %endif
 .loop:
-    ; FIXME maybe reuse loads from previous rows, or just
-    ; more generally unroll this to prevent multiple loads of
-    ; the same data?
+    ; FIXME maybe reuse loads from previous rows, or just more generally
+    ; unroll this to prevent multiple loads of the same data?
     movh        m0, [srcq]
     movh        m1, [srcq+sstrideq]
     movh        m2, [srcq+sstrideq*2]
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/w64xmmtest.c b/mythtv/external/FFmpeg/libavcodec/x86/w64xmmtest.c
index 7d4a6630c2c..8f2b8a62992 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/w64xmmtest.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/w64xmmtest.c
@@ -23,7 +23,7 @@
 #include "libavutil/x86/w64xmmtest.h"
 
 wrap(avcodec_open2(AVCodecContext *avctx,
-                   AVCodec *codec,
+                   const AVCodec *codec,
                    AVDictionary **options))
 {
     testxmmclobbers(avcodec_open2, avctx, codec, options);
@@ -83,9 +83,9 @@ wrap(avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt))
     testxmmclobbers(avcodec_send_packet, avctx, avpkt);
 }
 
-wrap(avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame))
+wrap(avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt))
 {
-    testxmmclobbers(avcodec_receive_frame, avctx, frame);
+    testxmmclobbers(avcodec_receive_packet, avctx, avpkt);
 }
 
 wrap(avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame))
@@ -93,7 +93,7 @@ wrap(avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame))
     testxmmclobbers(avcodec_send_frame, avctx, frame);
 }
 
-wrap(avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt))
+wrap(avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame))
 {
-    testxmmclobbers(avcodec_receive_packet, avctx, avpkt);
+    testxmmclobbers(avcodec_receive_frame, avctx, frame);
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/xvididct.h b/mythtv/external/FFmpeg/libavcodec/x86/xvididct.h
index 573b25c6b50..edb5ebfd317 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/xvididct.h
+++ b/mythtv/external/FFmpeg/libavcodec/x86/xvididct.h
@@ -26,18 +26,19 @@
 #ifndef AVCODEC_X86_XVIDIDCT_H
 #define AVCODEC_X86_XVIDIDCT_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 void ff_xvid_idct_mmx(short *block);
-void ff_xvid_idct_mmx_put(uint8_t *dest, int line_size, int16_t *block);
-void ff_xvid_idct_mmx_add(uint8_t *dest, int line_size, int16_t *block);
+void ff_xvid_idct_mmx_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_xvid_idct_mmx_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 
 void ff_xvid_idct_mmxext(short *block);
-void ff_xvid_idct_mmxext_put(uint8_t *dest, int line_size, int16_t *block);
-void ff_xvid_idct_mmxext_add(uint8_t *dest, int line_size, int16_t *block);
+void ff_xvid_idct_mmxext_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
+void ff_xvid_idct_mmxext_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block);
 
 void ff_xvid_idct_sse2(short *block);
-void ff_xvid_idct_put_sse2(uint8_t *dest, int line_size, short *block);
-void ff_xvid_idct_add_sse2(uint8_t *dest, int line_size, short *block);
+void ff_xvid_idct_put_sse2(uint8_t *dest, ptrdiff_t line_size, short *block);
+void ff_xvid_idct_add_sse2(uint8_t *dest, ptrdiff_t line_size, short *block);
 
 #endif /* AVCODEC_X86_XVIDIDCT_H */
diff --git a/mythtv/external/FFmpeg/libavcodec/x86/xvididct_init.c b/mythtv/external/FFmpeg/libavcodec/x86/xvididct_init.c
index 8b9d8de0cd3..a91b416b740 100644
--- a/mythtv/external/FFmpeg/libavcodec/x86/xvididct_init.c
+++ b/mythtv/external/FFmpeg/libavcodec/x86/xvididct_init.c
@@ -26,36 +26,36 @@
 #include "idctdsp.h"
 #include "xvididct.h"
 
-#if ARCH_X86_32 && HAVE_YASM
-static void xvid_idct_mmx_put(uint8_t *dest, int line_size, short *block)
+#if ARCH_X86_32 && HAVE_X86ASM
+static void xvid_idct_mmx_put(uint8_t *dest, ptrdiff_t line_size, short *block)
 {
     ff_xvid_idct_mmx(block);
-    ff_put_pixels_clamped(block, dest, line_size);
+    ff_put_pixels_clamped_mmx(block, dest, line_size);
 }
 
-static void xvid_idct_mmx_add(uint8_t *dest, int line_size, short *block)
+static void xvid_idct_mmx_add(uint8_t *dest, ptrdiff_t line_size, short *block)
 {
     ff_xvid_idct_mmx(block);
-    ff_add_pixels_clamped(block, dest, line_size);
+    ff_add_pixels_clamped_mmx(block, dest, line_size);
 }
 
-static void xvid_idct_mmxext_put(uint8_t *dest, int line_size, short *block)
+static void xvid_idct_mmxext_put(uint8_t *dest, ptrdiff_t line_size, short *block)
 {
     ff_xvid_idct_mmxext(block);
-    ff_put_pixels_clamped(block, dest, line_size);
+    ff_put_pixels_clamped_mmx(block, dest, line_size);
 }
 
-static void xvid_idct_mmxext_add(uint8_t *dest, int line_size, short *block)
+static void xvid_idct_mmxext_add(uint8_t *dest, ptrdiff_t line_size, short *block)
 {
     ff_xvid_idct_mmxext(block);
-    ff_add_pixels_clamped(block, dest, line_size);
+    ff_add_pixels_clamped_mmx(block, dest, line_size);
 }
 #endif
 
 av_cold void ff_xvid_idct_init_x86(IDCTDSPContext *c, AVCodecContext *avctx,
                                    unsigned high_bit_depth)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (high_bit_depth ||
@@ -85,5 +85,5 @@ av_cold void ff_xvid_idct_init_x86(IDCTDSPContext *c, AVCodecContext *avctx,
         c->idct      = ff_xvid_idct_sse2;
         c->perm_type = FF_IDCT_PERM_SSE2;
     }
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/xan.c b/mythtv/external/FFmpeg/libavcodec/xan.c
index 4c01c0013fd..1ccf164847b 100644
--- a/mythtv/external/FFmpeg/libavcodec/xan.c
+++ b/mythtv/external/FFmpeg/libavcodec/xan.c
@@ -131,7 +131,10 @@ static int xan_huffman_decode(uint8_t *dest, int dest_len,
         return ret;
 
     while (val != 0x16) {
-        unsigned idx = val - 0x17 + get_bits1(&gb) * byte;
+        unsigned idx;
+        if (get_bits_left(&gb) < 1)
+            return AVERROR_INVALIDDATA;
+        idx = val - 0x17 + get_bits1(&gb) * byte;
         if (idx >= 2 * byte)
             return AVERROR_INVALIDDATA;
         val = src[idx];
@@ -263,7 +266,7 @@ static inline void xan_wc3_copy_pixel_run(XanContext *s, AVFrame *frame,
     prevframe_index = (y + motion_y) * stride + x + motion_x;
     prevframe_x = x + motion_x;
 
-    if (prev_palette_plane == palette_plane && FFABS(curframe_index - prevframe_index) < pixel_count) {
+    if (prev_palette_plane == palette_plane && FFABS(motion_x + width*motion_y) < pixel_count) {
          avpriv_request_sample(s->avctx, "Overlapping copy");
          return ;
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/xface.c b/mythtv/external/FFmpeg/libavcodec/xface.c
index 8c0cbfdb84a..184c1741775 100644
--- a/mythtv/external/FFmpeg/libavcodec/xface.c
+++ b/mythtv/external/FFmpeg/libavcodec/xface.c
@@ -315,9 +315,9 @@ void ff_xface_generate_face(uint8_t *dst, uint8_t * const src)
 
             for (l = i - 2; l <= i + 2; l++) {
                 for (m = j - 2; m <= j; m++) {
-                    if (l >= i && m == j)
+                    if (l <= 0 || l >= i && m == j)
                         continue;
-                    if (l > 0 && l <= XFACE_WIDTH && m > 0)
+                    if (l <= XFACE_WIDTH && m > 0)
                         k = 2*k + src[l + m * XFACE_WIDTH];
                 }
             }
diff --git a/mythtv/external/FFmpeg/libavcodec/xma_parser.c b/mythtv/external/FFmpeg/libavcodec/xma_parser.c
new file mode 100644
index 00000000000..05136792726
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/xma_parser.c
@@ -0,0 +1,62 @@
+/*
+ * 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
+ * XMA2 audio parser
+ */
+
+#include "parser.h"
+
+typedef struct XMAParserContext{
+    int skip_packets;
+} XMAParserContext;
+
+static int xma_parse(AVCodecParserContext *s1, AVCodecContext *avctx,
+                     const uint8_t **poutbuf, int *poutbuf_size,
+                     const uint8_t *buf, int buf_size)
+{
+    XMAParserContext *s = s1->priv_data;
+
+    if (buf_size % 2048 == 0) {
+        int duration = 0, packet, nb_packets = buf_size / 2048;
+
+        for (packet = 0; packet < nb_packets; packet++) {
+            if (s->skip_packets == 0) {
+                duration += buf[packet * 2048] * 128;
+                s->skip_packets = buf[packet * 2048 + 3] + 1;
+            }
+            s->skip_packets--;
+        }
+
+        s1->duration = duration;
+        s1->key_frame = !!duration;
+    }
+
+    /* always return the full packet. this parser isn't doing any splitting or
+       combining, only packet analysis */
+    *poutbuf      = buf;
+    *poutbuf_size = buf_size;
+    return buf_size;
+}
+
+AVCodecParser ff_xma_parser = {
+    .codec_ids      = { AV_CODEC_ID_XMA2 },
+    .priv_data_size = sizeof(XMAParserContext),
+    .parser_parse   = xma_parse,
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/xpmdec.c b/mythtv/external/FFmpeg/libavcodec/xpmdec.c
new file mode 100644
index 00000000000..03172e4aada
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavcodec/xpmdec.c
@@ -0,0 +1,443 @@
+/*
+ * XPM image format
+ *
+ * Copyright (c) 2012 Paul B Mahol
+ * Copyright (c) 2017 Paras Chadha
+ *
+ * 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/parseutils.h"
+#include "libavutil/avstring.h"
+#include "avcodec.h"
+#include "internal.h"
+
+typedef struct XPMContext {
+    uint32_t  *pixels;
+    int        pixels_size;
+    uint8_t   *buf;
+    int        buf_size;
+} XPMDecContext;
+
+typedef struct ColorEntry {
+    const char *name;         ///< a string representing the name of the color
+    uint32_t    rgb_color;    ///< RGB values for the color
+} ColorEntry;
+
+static int color_table_compare(const void *lhs, const void *rhs)
+{
+    return av_strcasecmp(lhs, ((const ColorEntry *)rhs)->name);
+}
+
+static const ColorEntry color_table[] = {
+    { "AliceBlue",            0xFFF0F8FF },
+    { "AntiqueWhite",         0xFFFAEBD7 },
+    { "Aqua",                 0xFF00FFFF },
+    { "Aquamarine",           0xFF7FFFD4 },
+    { "Azure",                0xFFF0FFFF },
+    { "Beige",                0xFFF5F5DC },
+    { "Bisque",               0xFFFFE4C4 },
+    { "Black",                0xFF000000 },
+    { "BlanchedAlmond",       0xFFFFEBCD },
+    { "Blue",                 0xFF0000FF },
+    { "BlueViolet",           0xFF8A2BE2 },
+    { "Brown",                0xFFA52A2A },
+    { "BurlyWood",            0xFFDEB887 },
+    { "CadetBlue",            0xFF5F9EA0 },
+    { "Chartreuse",           0xFF7FFF00 },
+    { "Chocolate",            0xFFD2691E },
+    { "Coral",                0xFFFF7F50 },
+    { "CornflowerBlue",       0xFF6495ED },
+    { "Cornsilk",             0xFFFFF8DC },
+    { "Crimson",              0xFFDC143C },
+    { "Cyan",                 0xFF00FFFF },
+    { "DarkBlue",             0xFF00008B },
+    { "DarkCyan",             0xFF008B8B },
+    { "DarkGoldenRod",        0xFFB8860B },
+    { "DarkGray",             0xFFA9A9A9 },
+    { "DarkGreen",            0xFF006400 },
+    { "DarkKhaki",            0xFFBDB76B },
+    { "DarkMagenta",          0xFF8B008B },
+    { "DarkOliveGreen",       0xFF556B2F },
+    { "Darkorange",           0xFFFF8C00 },
+    { "DarkOrchid",           0xFF9932CC },
+    { "DarkRed",              0xFF8B0000 },
+    { "DarkSalmon",           0xFFE9967A },
+    { "DarkSeaGreen",         0xFF8FBC8F },
+    { "DarkSlateBlue",        0xFF483D8B },
+    { "DarkSlateGray",        0xFF2F4F4F },
+    { "DarkTurquoise",        0xFF00CED1 },
+    { "DarkViolet",           0xFF9400D3 },
+    { "DeepPink",             0xFFFF1493 },
+    { "DeepSkyBlue",          0xFF00BFFF },
+    { "DimGray",              0xFF696969 },
+    { "DodgerBlue",           0xFF1E90FF },
+    { "FireBrick",            0xFFB22222 },
+    { "FloralWhite",          0xFFFFFAF0 },
+    { "ForestGreen",          0xFF228B22 },
+    { "Fuchsia",              0xFFFF00FF },
+    { "Gainsboro",            0xFFDCDCDC },
+    { "GhostWhite",           0xFFF8F8FF },
+    { "Gold",                 0xFFFFD700 },
+    { "GoldenRod",            0xFFDAA520 },
+    { "Gray",                 0xFFBEBEBE },
+    { "Green",                0xFF00FF00 },
+    { "GreenYellow",          0xFFADFF2F },
+    { "HoneyDew",             0xFFF0FFF0 },
+    { "HotPink",              0xFFFF69B4 },
+    { "IndianRed",            0xFFCD5C5C },
+    { "Indigo",               0xFF4B0082 },
+    { "Ivory",                0xFFFFFFF0 },
+    { "Khaki",                0xFFF0E68C },
+    { "Lavender",             0xFFE6E6FA },
+    { "LavenderBlush",        0xFFFFF0F5 },
+    { "LawnGreen",            0xFF7CFC00 },
+    { "LemonChiffon",         0xFFFFFACD },
+    { "LightBlue",            0xFFADD8E6 },
+    { "LightCoral",           0xFFF08080 },
+    { "LightCyan",            0xFFE0FFFF },
+    { "LightGoldenRodYellow", 0xFFFAFAD2 },
+    { "LightGreen",           0xFF90EE90 },
+    { "LightGrey",            0xFFD3D3D3 },
+    { "LightPink",            0xFFFFB6C1 },
+    { "LightSalmon",          0xFFFFA07A },
+    { "LightSeaGreen",        0xFF20B2AA },
+    { "LightSkyBlue",         0xFF87CEFA },
+    { "LightSlateGray",       0xFF778899 },
+    { "LightSteelBlue",       0xFFB0C4DE },
+    { "LightYellow",          0xFFFFFFE0 },
+    { "Lime",                 0xFF00FF00 },
+    { "LimeGreen",            0xFF32CD32 },
+    { "Linen",                0xFFFAF0E6 },
+    { "Magenta",              0xFFFF00FF },
+    { "Maroon",               0xFFB03060 },
+    { "MediumAquaMarine",     0xFF66CDAA },
+    { "MediumBlue",           0xFF0000CD },
+    { "MediumOrchid",         0xFFBA55D3 },
+    { "MediumPurple",         0xFF9370D8 },
+    { "MediumSeaGreen",       0xFF3CB371 },
+    { "MediumSlateBlue",      0xFF7B68EE },
+    { "MediumSpringGreen",    0xFF00FA9A },
+    { "MediumTurquoise",      0xFF48D1CC },
+    { "MediumVioletRed",      0xFFC71585 },
+    { "MidnightBlue",         0xFF191970 },
+    { "MintCream",            0xFFF5FFFA },
+    { "MistyRose",            0xFFFFE4E1 },
+    { "Moccasin",             0xFFFFE4B5 },
+    { "NavajoWhite",          0xFFFFDEAD },
+    { "Navy",                 0xFF000080 },
+    { "None",                 0x00000000 },
+    { "OldLace",              0xFFFDF5E6 },
+    { "Olive",                0xFF808000 },
+    { "OliveDrab",            0xFF6B8E23 },
+    { "Orange",               0xFFFFA500 },
+    { "OrangeRed",            0xFFFF4500 },
+    { "Orchid",               0xFFDA70D6 },
+    { "PaleGoldenRod",        0xFFEEE8AA },
+    { "PaleGreen",            0xFF98FB98 },
+    { "PaleTurquoise",        0xFFAFEEEE },
+    { "PaleVioletRed",        0xFFD87093 },
+    { "PapayaWhip",           0xFFFFEFD5 },
+    { "PeachPuff",            0xFFFFDAB9 },
+    { "Peru",                 0xFFCD853F },
+    { "Pink",                 0xFFFFC0CB },
+    { "Plum",                 0xFFDDA0DD },
+    { "PowderBlue",           0xFFB0E0E6 },
+    { "Purple",               0xFFA020F0 },
+    { "Red",                  0xFFFF0000 },
+    { "RosyBrown",            0xFFBC8F8F },
+    { "RoyalBlue",            0xFF4169E1 },
+    { "SaddleBrown",          0xFF8B4513 },
+    { "Salmon",               0xFFFA8072 },
+    { "SandyBrown",           0xFFF4A460 },
+    { "SeaGreen",             0xFF2E8B57 },
+    { "SeaShell",             0xFFFFF5EE },
+    { "Sienna",               0xFFA0522D },
+    { "Silver",               0xFFC0C0C0 },
+    { "SkyBlue",              0xFF87CEEB },
+    { "SlateBlue",            0xFF6A5ACD },
+    { "SlateGray",            0xFF708090 },
+    { "Snow",                 0xFFFFFAFA },
+    { "SpringGreen",          0xFF00FF7F },
+    { "SteelBlue",            0xFF4682B4 },
+    { "Tan",                  0xFFD2B48C },
+    { "Teal",                 0xFF008080 },
+    { "Thistle",              0xFFD8BFD8 },
+    { "Tomato",               0xFFFF6347 },
+    { "Turquoise",            0xFF40E0D0 },
+    { "Violet",               0xFFEE82EE },
+    { "Wheat",                0xFFF5DEB3 },
+    { "White",                0xFFFFFFFF },
+    { "WhiteSmoke",           0xFFF5F5F5 },
+    { "Yellow",               0xFFFFFF00 },
+    { "YellowGreen",          0xFF9ACD32 }
+};
+
+static unsigned hex_char_to_number(uint8_t x)
+{
+    if (x >= 'a' && x <= 'f')
+        x -= 'a' - 10;
+    else if (x >= 'A' && x <= 'F')
+        x -= 'A' - 10;
+    else if (x >= '0' && x <= '9')
+        x -= '0';
+    else
+        x = 0;
+    return x;
+}
+
+/*
+ * Function same as strcspn but ignores characters if they are inside a C style comments
+ */
+static size_t mod_strcspn(const char *string, const char *reject)
+{
+    int i, j;
+
+    for (i = 0; string && string[i]; i++) {
+        if (string[i] == '/' && string[i+1] == '*') {
+            i += 2;
+            while ( string && string[i] && (string[i] != '*' || string[i+1] != '/') )
+                i++;
+            i++;
+        } else if (string[i] == '/' && string[i+1] == '/') {
+            i += 2;
+            while ( string && string[i] && string[i] != '\n' )
+                i++;
+        } else {
+            for (j = 0; reject && reject[j]; j++) {
+                if (string[i] == reject[j])
+                    break;
+            }
+            if (reject && reject[j])
+                break;
+        }
+    }
+    return i;
+}
+
+static uint32_t color_string_to_rgba(const char *p, int len)
+{
+    uint32_t ret = 0xFF000000;
+    const ColorEntry *entry;
+    char color_name[100];
+
+    len = FFMIN(FFMAX(len, 0), sizeof(color_name) - 1);
+
+    if (*p == '#') {
+        p++;
+        len--;
+        if (len == 3) {
+            ret |= (hex_char_to_number(p[2]) <<  4) |
+                   (hex_char_to_number(p[1]) << 12) |
+                   (hex_char_to_number(p[0]) << 20);
+        } else if (len == 4) {
+            ret  = (hex_char_to_number(p[3]) <<  4) |
+                   (hex_char_to_number(p[2]) << 12) |
+                   (hex_char_to_number(p[1]) << 20) |
+                   (hex_char_to_number(p[0]) << 28);
+        } else if (len == 6) {
+            ret |=  hex_char_to_number(p[5])        |
+                   (hex_char_to_number(p[4]) <<  4) |
+                   (hex_char_to_number(p[3]) <<  8) |
+                   (hex_char_to_number(p[2]) << 12) |
+                   (hex_char_to_number(p[1]) << 16) |
+                   (hex_char_to_number(p[0]) << 20);
+        } else if (len == 8) {
+            ret  =  hex_char_to_number(p[7])        |
+                   (hex_char_to_number(p[6]) <<  4) |
+                   (hex_char_to_number(p[5]) <<  8) |
+                   (hex_char_to_number(p[4]) << 12) |
+                   (hex_char_to_number(p[3]) << 16) |
+                   (hex_char_to_number(p[2]) << 20) |
+                   (hex_char_to_number(p[1]) << 24) |
+                   (hex_char_to_number(p[0]) << 28);
+        }
+    } else {
+        strncpy(color_name, p, len);
+        color_name[len] = '\0';
+
+        entry = bsearch(color_name,
+                        color_table,
+                        FF_ARRAY_ELEMS(color_table),
+                        sizeof(ColorEntry),
+                        color_table_compare);
+
+        if (!entry)
+            return ret;
+
+        ret = entry->rgb_color;
+    }
+    return ret;
+}
+
+static int ascii2index(const uint8_t *cpixel, int cpp)
+{
+    const uint8_t *p = cpixel;
+    int n = 0, m = 1, i;
+
+    for (i = 0; i < cpp; i++) {
+        if (*p < ' ' || *p > '~')
+            return AVERROR_INVALIDDATA;
+        n += (*p++ - ' ') * m;
+        m *= 95;
+    }
+    return n;
+}
+
+static int xpm_decode_frame(AVCodecContext *avctx, void *data,
+                            int *got_frame, AVPacket *avpkt)
+{
+    XPMDecContext *x = avctx->priv_data;
+    AVFrame *p=data;
+    const uint8_t *end, *ptr;
+    int ncolors, cpp, ret, i, j;
+    int64_t size;
+    uint32_t *dst;
+
+    avctx->pix_fmt = AV_PIX_FMT_BGRA;
+
+    av_fast_padded_malloc(&x->buf, &x->buf_size, avpkt->size);
+    if (!x->buf)
+        return AVERROR(ENOMEM);
+    memcpy(x->buf, avpkt->data, avpkt->size);
+    x->buf[avpkt->size] = 0;
+
+    ptr = x->buf;
+    end = x->buf + avpkt->size;
+    while (end - ptr > 9 && memcmp(ptr, "/* XPM */", 9))
+        ptr++;
+
+    if (end - ptr <= 9) {
+        av_log(avctx, AV_LOG_ERROR, "missing signature\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    ptr += mod_strcspn(ptr, "\"");
+    if (sscanf(ptr, "\"%u %u %u %u\",",
+               &avctx->width, &avctx->height, &ncolors, &cpp) != 4) {
+        av_log(avctx, AV_LOG_ERROR, "missing image parameters\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    if ((ret = ff_set_dimensions(avctx, avctx->width, avctx->height)) < 0)
+        return ret;
+
+    if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
+        return ret;
+
+    if (cpp <= 0 || cpp >= 5) {
+        av_log(avctx, AV_LOG_ERROR, "unsupported/invalid number of chars per pixel: %d\n", cpp);
+        return AVERROR_INVALIDDATA;
+    }
+
+    size = 1;
+    for (i = 0; i < cpp; i++)
+        size *= 95;
+
+    if (ncolors <= 0 || ncolors > size) {
+        av_log(avctx, AV_LOG_ERROR, "invalid number of colors: %d\n", ncolors);
+        return AVERROR_INVALIDDATA;
+    }
+
+    size *= 4;
+
+    av_fast_padded_malloc(&x->pixels, &x->pixels_size, size);
+    if (!x->pixels)
+        return AVERROR(ENOMEM);
+
+    ptr += mod_strcspn(ptr, ",") + 1;
+    if (end - ptr < 1)
+        return AVERROR_INVALIDDATA;
+
+    for (i = 0; i < ncolors; i++) {
+        const uint8_t *index;
+        int len;
+
+        ptr += mod_strcspn(ptr, "\"") + 1;
+        if (end - ptr < cpp)
+            return AVERROR_INVALIDDATA;
+        index = ptr;
+        ptr += cpp;
+
+        ptr = strstr(ptr, "c ");
+        if (ptr) {
+            ptr += 2;
+        } else {
+            return AVERROR_INVALIDDATA;
+        }
+
+        len = strcspn(ptr, "\" ");
+
+        if ((ret = ascii2index(index, cpp)) < 0)
+            return ret;
+
+        x->pixels[ret] = color_string_to_rgba(ptr, len);
+        ptr += mod_strcspn(ptr, ",") + 1;
+        if (end - ptr < 1)
+            return AVERROR_INVALIDDATA;
+    }
+
+    for (i = 0; i < avctx->height; i++) {
+        dst = (uint32_t *)(p->data[0] + i * p->linesize[0]);
+        if (end - ptr < 1)
+            return AVERROR_INVALIDDATA;
+        ptr += mod_strcspn(ptr, "\"") + 1;
+        if (end - ptr < 1)
+            return AVERROR_INVALIDDATA;
+
+        for (j = 0; j < avctx->width; j++) {
+            if (end - ptr < cpp)
+                return AVERROR_INVALIDDATA;
+
+            if ((ret = ascii2index(ptr, cpp)) < 0)
+                return ret;
+
+            *dst++ = x->pixels[ret];
+            ptr += cpp;
+        }
+        ptr += mod_strcspn(ptr, ",") + 1;
+    }
+
+    p->key_frame = 1;
+    p->pict_type = AV_PICTURE_TYPE_I;
+
+    *got_frame = 1;
+
+    return avpkt->size;
+}
+
+static av_cold int xpm_decode_close(AVCodecContext *avctx)
+{
+    XPMDecContext *x = avctx->priv_data;
+    av_freep(&x->pixels);
+
+    av_freep(&x->buf);
+    x->buf_size = 0;
+
+    return 0;
+}
+
+AVCodec ff_xpm_decoder = {
+    .name           = "xpm",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_XPM,
+    .priv_data_size = sizeof(XPMDecContext),
+    .close          = xpm_decode_close,
+    .decode         = xpm_decode_frame,
+    .capabilities   = AV_CODEC_CAP_DR1,
+    .long_name      = NULL_IF_CONFIG_SMALL("XPM (X PixMap) image")
+};
diff --git a/mythtv/external/FFmpeg/libavcodec/xsubdec.c b/mythtv/external/FFmpeg/libavcodec/xsubdec.c
index b024535df60..93fd0f4d50e 100644
--- a/mythtv/external/FFmpeg/libavcodec/xsubdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/xsubdec.c
@@ -53,7 +53,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
     AVSubtitle *sub = data;
     const uint8_t *buf_end = buf + buf_size;
     uint8_t *bitmap;
-    int w, h, x, y, i;
+    int w, h, x, y, i, ret;
     int64_t packet_time = 0;
     GetBitContext gb;
     int has_alpha = avctx->codec_tag == MKTAG('D','X','S','A');
@@ -91,6 +91,9 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
     // we just ignore it
     bytestream_get_le16(&buf);
 
+    if (buf_end - buf < h + 3*4)
+        return AVERROR_INVALIDDATA;
+
     // allocate sub and set values
     sub->rects =  av_mallocz(sizeof(*sub->rects));
     if (!sub->rects)
@@ -145,7 +148,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
 #endif
 
     // process RLE-compressed data
-    init_get_bits(&gb, buf, (buf_end - buf) * 8);
+    if ((ret = init_get_bits8(&gb, buf, buf_end - buf)) < 0)
+        return ret;
     bitmap = sub->rects[0]->data[0];
     for (y = 0; y < h; y++) {
         // interlaced: do odd lines
diff --git a/mythtv/external/FFmpeg/libavcodec/xvididct.c b/mythtv/external/FFmpeg/libavcodec/xvididct.c
index 1f96ccc35c8..d8f3dd70726 100644
--- a/mythtv/external/FFmpeg/libavcodec/xvididct.c
+++ b/mythtv/external/FFmpeg/libavcodec/xvididct.c
@@ -318,16 +318,16 @@ void ff_xvid_idct(int16_t *const in)
     }
 }
 
-static void xvid_idct_put(uint8_t *dest, int line_size, int16_t *block)
+static void xvid_idct_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     ff_xvid_idct(block);
-    ff_put_pixels_clamped(block, dest, line_size);
+    ff_put_pixels_clamped_c(block, dest, line_size);
 }
 
-static void xvid_idct_add(uint8_t *dest, int line_size, int16_t *block)
+static void xvid_idct_add(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
 {
     ff_xvid_idct(block);
-    ff_add_pixels_clamped(block, dest, line_size);
+    ff_add_pixels_clamped_c(block, dest, line_size);
 }
 
 av_cold void ff_xvid_idct_init(IDCTDSPContext *c, AVCodecContext *avctx)
diff --git a/mythtv/external/FFmpeg/libavcodec/xwddec.c b/mythtv/external/FFmpeg/libavcodec/xwddec.c
index 64cd8418a20..8b0845fc013 100644
--- a/mythtv/external/FFmpeg/libavcodec/xwddec.c
+++ b/mythtv/external/FFmpeg/libavcodec/xwddec.c
@@ -157,9 +157,9 @@ static int xwd_decode_frame(AVCodecContext *avctx, void *data,
     case XWD_GRAY_SCALE:
         if (bpp != 1 && bpp != 8)
             return AVERROR_INVALIDDATA;
-        if (pixdepth == 1) {
+        if (bpp == 1 && pixdepth == 1) {
             avctx->pix_fmt = AV_PIX_FMT_MONOWHITE;
-        } else if (pixdepth == 8) {
+        } else if (bpp == 8 && pixdepth == 8) {
             avctx->pix_fmt = AV_PIX_FMT_GRAY8;
         }
         break;
diff --git a/mythtv/external/FFmpeg/libavcodec/y41pdec.c b/mythtv/external/FFmpeg/libavcodec/y41pdec.c
index 1b177d42621..85a39e4ae26 100644
--- a/mythtv/external/FFmpeg/libavcodec/y41pdec.c
+++ b/mythtv/external/FFmpeg/libavcodec/y41pdec.c
@@ -43,7 +43,7 @@ static int y41p_decode_frame(AVCodecContext *avctx, void *data,
     uint8_t *y, *u, *v;
     int i, j, ret;
 
-    if (avpkt->size < 3LL * avctx->height * avctx->width / 2) {
+    if (avpkt->size < 3LL * avctx->height * FFALIGN(avctx->width, 8) / 2) {
         av_log(avctx, AV_LOG_ERROR, "Insufficient input data.\n");
         return AVERROR(EINVAL);
     }
diff --git a/mythtv/external/FFmpeg/libavcodec/y41penc.c b/mythtv/external/FFmpeg/libavcodec/y41penc.c
index 94acc343fb5..ca94a3c171a 100644
--- a/mythtv/external/FFmpeg/libavcodec/y41penc.c
+++ b/mythtv/external/FFmpeg/libavcodec/y41penc.c
@@ -31,6 +31,7 @@ static av_cold int y41p_encode_init(AVCodecContext *avctx)
     }
 
     avctx->bits_per_coded_sample = 12;
+    avctx->bit_rate = ff_guess_coded_bitrate(avctx);
 
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavcodec/ylc.c b/mythtv/external/FFmpeg/libavcodec/ylc.c
index 95a5e05baac..11333222b94 100644
--- a/mythtv/external/FFmpeg/libavcodec/ylc.c
+++ b/mythtv/external/FFmpeg/libavcodec/ylc.c
@@ -31,6 +31,7 @@
 #include "get_bits.h"
 #include "huffyuvdsp.h"
 #include "internal.h"
+#include "thread.h"
 #include "unary.h"
 
 typedef struct YLCContext {
@@ -68,7 +69,7 @@ static void get_tree_codes(uint32_t *bits, int16_t *lens, uint8_t *xlat,
 
     s = nodes[node].sym;
     if (s != -1) {
-        bits[*pos] = (~pfx) & ((1 << FFMAX(pl, 1)) - 1);
+        bits[*pos] = (~pfx) & ((1ULL << FFMAX(pl, 1)) - 1);
         lens[*pos] = FFMAX(pl, 1);
         xlat[*pos] = s + (pl == 0);
         (*pos)++;
@@ -108,7 +109,7 @@ static int build_vlc(AVCodecContext *avctx, VLC *vlc, const uint32_t *table)
             int new_node = j;
             int first_node = cur_node;
             int second_node = cur_node;
-            int nd, st;
+            unsigned nd, st;
 
             nodes[cur_node].count = -1;
 
@@ -132,6 +133,10 @@ static int build_vlc(AVCodecContext *avctx, VLC *vlc, const uint32_t *table)
             st = nodes[first_node].count;
             nodes[second_node].count = 0;
             nodes[first_node].count  = 0;
+            if (nd >= UINT32_MAX - st) {
+                av_log(avctx, AV_LOG_ERROR, "count overflow\n");
+                return AVERROR_INVALIDDATA;
+            }
             nodes[cur_node].count = nd + st;
             nodes[cur_node].sym = -1;
             nodes[cur_node].n0 = cur_node;
@@ -282,6 +287,7 @@ static int decode_frame(AVCodecContext *avctx,
     int TL[4] = { 128, 128, 128, 128 };
     int L[4]  = { 128, 128, 128, 128 };
     YLCContext *s = avctx->priv_data;
+    ThreadFrame frame = { .f = data };
     const uint8_t *buf = avpkt->data;
     int ret, x, y, toffset, boffset;
     AVFrame * const p = data;
@@ -303,7 +309,7 @@ static int decode_frame(AVCodecContext *avctx,
     if (toffset >= boffset || boffset >= avpkt->size)
         return AVERROR_INVALIDDATA;
 
-    if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
+    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
         return ret;
 
     av_fast_malloc(&s->table_bits, &s->table_bits_size,
@@ -447,6 +453,24 @@ static int decode_frame(AVCodecContext *avctx,
     return avpkt->size;
 }
 
+#if HAVE_THREADS
+static int init_thread_copy(AVCodecContext *avctx)
+{
+    YLCContext *s = avctx->priv_data;
+
+    memset(&s->vlc[0], 0, sizeof(VLC));
+    memset(&s->vlc[1], 0, sizeof(VLC));
+    memset(&s->vlc[2], 0, sizeof(VLC));
+    memset(&s->vlc[3], 0, sizeof(VLC));
+    s->table_bits = NULL;
+    s->table_bits_size = 0;
+    s->bitstream_bits = NULL;
+    s->bitstream_bits_size = 0;
+
+    return 0;
+}
+#endif
+
 static av_cold int decode_end(AVCodecContext *avctx)
 {
     YLCContext *s = avctx->priv_data;
@@ -455,6 +479,10 @@ static av_cold int decode_end(AVCodecContext *avctx)
     ff_free_vlc(&s->vlc[1]);
     ff_free_vlc(&s->vlc[2]);
     ff_free_vlc(&s->vlc[3]);
+    av_freep(&s->table_bits);
+    s->table_bits_size = 0;
+    av_freep(&s->bitstream_bits);
+    s->bitstream_bits_size = 0;
 
     return 0;
 }
@@ -466,7 +494,9 @@ AVCodec ff_ylc_decoder = {
     .id             = AV_CODEC_ID_YLC,
     .priv_data_size = sizeof(YLCContext),
     .init           = decode_init,
+    .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
     .close          = decode_end,
     .decode         = decode_frame,
-    .capabilities   = AV_CODEC_CAP_DR1,
+    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/zerocodec.c b/mythtv/external/FFmpeg/libavcodec/zerocodec.c
index 55a9a9173a2..e67eee4f7d8 100644
--- a/mythtv/external/FFmpeg/libavcodec/zerocodec.c
+++ b/mythtv/external/FFmpeg/libavcodec/zerocodec.c
@@ -149,4 +149,5 @@ AVCodec ff_zerocodec_decoder = {
     .decode         = zerocodec_decode_frame,
     .close          = zerocodec_decode_close,
     .capabilities   = AV_CODEC_CAP_DR1,
+    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
 };
diff --git a/mythtv/external/FFmpeg/libavcodec/zmbv.c b/mythtv/external/FFmpeg/libavcodec/zmbv.c
index f126515bd17..f91d2e39317 100644
--- a/mythtv/external/FFmpeg/libavcodec/zmbv.c
+++ b/mythtv/external/FFmpeg/libavcodec/zmbv.c
@@ -539,6 +539,8 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
     } else {
         frame->key_frame = 0;
         frame->pict_type = AV_PICTURE_TYPE_P;
+        if (c->decomp_len < 2LL * ((c->width + c->bw - 1) / c->bw) * ((c->height + c->bh - 1) / c->bh))
+            return AVERROR_INVALIDDATA;
         if (c->decomp_len)
             c->decode_xor(c);
     }
@@ -589,6 +591,11 @@ static av_cold int decode_init(AVCodecContext *avctx)
     // Needed if zlib unused or init aborted before inflateInit
     memset(&c->zstream, 0, sizeof(z_stream));
 
+    if ((avctx->width + 255ULL) * (avctx->height + 64ULL) > FFMIN(avctx->max_pixels, INT_MAX / 4) ) {
+        av_log(avctx, AV_LOG_ERROR, "Internal buffer (decomp_size) larger than max_pixels or too large\n");
+        return AVERROR_INVALIDDATA;
+    }
+
     c->decomp_size = (avctx->width + 255) * 4 * (avctx->height + 64);
 
     /* Allocate decompression buffer */
diff --git a/mythtv/external/FFmpeg/libavcodec/zmbvenc.c b/mythtv/external/FFmpeg/libavcodec/zmbvenc.c
index e832bedbb24..4d9147657d2 100644
--- a/mythtv/external/FFmpeg/libavcodec/zmbvenc.c
+++ b/mythtv/external/FFmpeg/libavcodec/zmbvenc.c
@@ -54,16 +54,18 @@ typedef struct ZmbvEncContext {
     int comp_size;
     int keyint, curfrm;
     z_stream zstream;
+
+    int score_tab[256];
 } ZmbvEncContext;
 
-static int score_tab[256];
 
 /** Block comparing function
  * XXX should be optimized and moved to DSPContext
  * TODO handle out of edge ME
  */
-static inline int block_cmp(uint8_t *src, int stride, uint8_t *src2, int stride2,
-                            int bw, int bh, int *xored)
+static inline int block_cmp(ZmbvEncContext *c, uint8_t *src, int stride,
+                            uint8_t *src2, int stride2, int bw, int bh,
+                            int *xored)
 {
     int sum = 0;
     int i, j;
@@ -81,7 +83,7 @@ static inline int block_cmp(uint8_t *src, int stride, uint8_t *src2, int stride2
     }
 
     for(i = 1; i < 256; i++)
-        sum += score_tab[histogram[i]];
+        sum += c->score_tab[histogram[i]];
 
     return sum;
 }
@@ -97,14 +99,14 @@ static int zmbv_me(ZmbvEncContext *c, uint8_t *src, int sstride, uint8_t *prev,
     *mx = *my = 0;
     bw = FFMIN(ZMBV_BLOCK, c->avctx->width - x);
     bh = FFMIN(ZMBV_BLOCK, c->avctx->height - y);
-    bv = block_cmp(src, sstride, prev, pstride, bw, bh, xored);
+    bv = block_cmp(c, src, sstride, prev, pstride, bw, bh, xored);
     if(!bv) return 0;
     for(ty = FFMAX(y - c->range, 0); ty < FFMIN(y + c->range, c->avctx->height - bh); ty++){
         for(tx = FFMAX(x - c->range, 0); tx < FFMIN(x + c->range, c->avctx->width - bw); tx++){
             if(tx == x && ty == y) continue; // we already tested this block
             dx = tx - x;
             dy = ty - y;
-            tv = block_cmp(src, sstride, prev + dx + dy*pstride, pstride, bw, bh, xored);
+            tv = block_cmp(c, src, sstride, prev + dx + dy * pstride, pstride, bw, bh, xored);
             if(tv < bv){
                  bv = tv;
                  *mx = dx;
@@ -277,7 +279,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
     int lvl = 9;
 
     for(i=1; i<256; i++)
-        score_tab[i]= -i * log2(i/(double)(ZMBV_BLOCK*ZMBV_BLOCK)) * 256;
+        c->score_tab[i] = -i * log2(i / (double)(ZMBV_BLOCK * ZMBV_BLOCK)) * 256;
 
     c->avctx = avctx;
 
diff --git a/mythtv/external/FFmpeg/libavdevice/Makefile b/mythtv/external/FFmpeg/libavdevice/Makefile
index 256e140043a..8228d621479 100644
--- a/mythtv/external/FFmpeg/libavdevice/Makefile
+++ b/mythtv/external/FFmpeg/libavdevice/Makefile
@@ -1,6 +1,5 @@
-include $(SUBDIR)../config.mak
-
 NAME    = avdevice
+DESC    = FFmpeg device handling library
 
 HEADERS = avdevice.h                                                    \
           version.h                                                     \
@@ -10,6 +9,7 @@ OBJS    = alldevices.o                                                  \
           utils.o                                                       \
 
 OBJS-$(HAVE_LIBC_MSVCRT)                 += file_open.o
+OBJS-$(CONFIG_SHARED)                    += reverse.o
 
 # input/output devices
 OBJS-$(CONFIG_ALSA_INDEV)                += alsa_dec.o alsa.o timefilter.o
@@ -19,10 +19,11 @@ OBJS-$(CONFIG_BKTR_INDEV)                += bktr.o
 OBJS-$(CONFIG_CACA_OUTDEV)               += caca.o
 OBJS-$(CONFIG_DECKLINK_OUTDEV)           += decklink_enc.o decklink_enc_c.o decklink_common.o
 OBJS-$(CONFIG_DECKLINK_INDEV)            += decklink_dec.o decklink_dec_c.o decklink_common.o
+OBJS-$(CONFIG_LIBNDI_NEWTEK_OUTDEV)      += libndi_newtek_enc.o
+OBJS-$(CONFIG_LIBNDI_NEWTEK_INDEV)       += libndi_newtek_dec.o
 OBJS-$(CONFIG_DSHOW_INDEV)               += dshow_crossbar.o dshow.o dshow_enummediatypes.o \
                                             dshow_enumpins.o dshow_filter.o \
                                             dshow_pin.o dshow_common.o
-OBJS-$(CONFIG_DV1394_INDEV)              += dv1394.o
 OBJS-$(CONFIG_FBDEV_INDEV)               += fbdev_dec.o \
                                             fbdev_common.o
 OBJS-$(CONFIG_FBDEV_OUTDEV)              += fbdev_enc.o \
@@ -30,6 +31,7 @@ OBJS-$(CONFIG_FBDEV_OUTDEV)              += fbdev_enc.o \
 OBJS-$(CONFIG_GDIGRAB_INDEV)             += gdigrab.o
 OBJS-$(CONFIG_IEC61883_INDEV)            += iec61883.o
 OBJS-$(CONFIG_JACK_INDEV)                += jack.o timefilter.o
+OBJS-$(CONFIG_KMSGRAB_INDEV)             += kmsgrab.o
 OBJS-$(CONFIG_LAVFI_INDEV)               += lavfi.o
 OBJS-$(CONFIG_OPENAL_INDEV)              += openal-dec.o
 OBJS-$(CONFIG_OPENGL_OUTDEV)             += opengl_enc.o
@@ -39,16 +41,13 @@ OBJS-$(CONFIG_PULSE_INDEV)               += pulse_audio_dec.o \
                                             pulse_audio_common.o timefilter.o
 OBJS-$(CONFIG_PULSE_OUTDEV)              += pulse_audio_enc.o \
                                             pulse_audio_common.o
-OBJS-$(CONFIG_QTKIT_INDEV)               += qtkit.o
 OBJS-$(CONFIG_SDL2_OUTDEV)               += sdl2.o
 OBJS-$(CONFIG_SNDIO_INDEV)               += sndio_dec.o sndio.o
 OBJS-$(CONFIG_SNDIO_OUTDEV)              += sndio_enc.o sndio.o
 OBJS-$(CONFIG_V4L2_INDEV)                += v4l2.o v4l2-common.o timefilter.o
 OBJS-$(CONFIG_V4L2_OUTDEV)               += v4l2enc.o v4l2-common.o
-OBJS-$(CONFIG_V4L_INDEV)                 += v4l.o
 OBJS-$(CONFIG_VFWCAP_INDEV)              += vfwcap.o
-OBJS-$(CONFIG_X11GRAB_INDEV)             += x11grab.o
-OBJS-$(CONFIG_X11GRAB_XCB_INDEV)         += xcbgrab.o
+OBJS-$(CONFIG_XCBGRAB_INDEV)             += xcbgrab.o
 OBJS-$(CONFIG_XV_OUTDEV)                 += xv.o
 
 # external libraries
@@ -61,13 +60,15 @@ SLIBOBJS-$(HAVE_GNU_WINDRES)             += avdeviceres.o
 SKIPHEADERS                              += decklink_common.h
 SKIPHEADERS-$(CONFIG_DECKLINK)           += decklink_enc.h decklink_dec.h \
                                             decklink_common_c.h
+SKIPHEADERS-$(CONFIG_LIBNDI_NEWTEK_INDEV) += libndi_newtek_common.h
+SKIPHEADERS-$(CONFIG_LIBNDI_NEWTEK_OUTDEV) += libndi_newtek_common.h
 SKIPHEADERS-$(CONFIG_DSHOW_INDEV)        += dshow_capture.h
 SKIPHEADERS-$(CONFIG_FBDEV_INDEV)        += fbdev_common.h
 SKIPHEADERS-$(CONFIG_FBDEV_OUTDEV)       += fbdev_common.h
 SKIPHEADERS-$(CONFIG_LIBPULSE)           += pulse_audio_common.h
 SKIPHEADERS-$(CONFIG_V4L2_INDEV)         += v4l2-common.h
 SKIPHEADERS-$(CONFIG_V4L2_OUTDEV)        += v4l2-common.h
-SKIPHEADERS-$(HAVE_ALSA_ASOUNDLIB_H)     += alsa.h
-SKIPHEADERS-$(HAVE_SNDIO_H)              += sndio.h
+SKIPHEADERS-$(CONFIG_ALSA)               += alsa.h
+SKIPHEADERS-$(CONFIG_SNDIO)              += sndio.h
 
 TESTPROGS-$(CONFIG_JACK_INDEV)           += timefilter
diff --git a/mythtv/external/FFmpeg/libavdevice/alldevices.c b/mythtv/external/FFmpeg/libavdevice/alldevices.c
index a761be4f9c3..b767b6a7188 100644
--- a/mythtv/external/FFmpeg/libavdevice/alldevices.c
+++ b/mythtv/external/FFmpeg/libavdevice/alldevices.c
@@ -19,6 +19,7 @@
  */
 
 #include "config.h"
+#include "libavutil/thread.h"
 #include "avdevice.h"
 
 #define REGISTER_OUTDEV(X, x)                                           \
@@ -37,42 +38,41 @@
 
 #define REGISTER_INOUTDEV(X, x) REGISTER_OUTDEV(X, x); REGISTER_INDEV(X, x)
 
-void avdevice_register_all(void)
+static void register_all(void)
 {
-    static int initialized;
-
-    if (initialized)
-        return;
-    initialized = 1;
-
     /* devices */
     REGISTER_INOUTDEV(ALSA,             alsa);
     REGISTER_INDEV   (AVFOUNDATION,     avfoundation);
     REGISTER_INDEV   (BKTR,             bktr);
     REGISTER_OUTDEV  (CACA,             caca);
     REGISTER_INOUTDEV(DECKLINK,         decklink);
+    REGISTER_INOUTDEV(LIBNDI_NEWTEK,    libndi_newtek);
     REGISTER_INDEV   (DSHOW,            dshow);
-    REGISTER_INDEV   (DV1394,           dv1394);
     REGISTER_INOUTDEV(FBDEV,            fbdev);
     REGISTER_INDEV   (GDIGRAB,          gdigrab);
     REGISTER_INDEV   (IEC61883,         iec61883);
     REGISTER_INDEV   (JACK,             jack);
+    REGISTER_INDEV   (KMSGRAB,          kmsgrab);
     REGISTER_INDEV   (LAVFI,            lavfi);
     REGISTER_INDEV   (OPENAL,           openal);
     REGISTER_OUTDEV  (OPENGL,           opengl);
     REGISTER_INOUTDEV(OSS,              oss);
     REGISTER_INOUTDEV(PULSE,            pulse);
-    REGISTER_INDEV   (QTKIT,            qtkit);
     REGISTER_OUTDEV  (SDL2,             sdl2);
     REGISTER_INOUTDEV(SNDIO,            sndio);
     REGISTER_INOUTDEV(V4L2,             v4l2);
-//    REGISTER_INDEV   (V4L,              v4l
     REGISTER_INDEV   (VFWCAP,           vfwcap);
-    REGISTER_INDEV   (X11GRAB,          x11grab);
-    REGISTER_INDEV   (X11GRAB_XCB,      x11grab_xcb);
+    REGISTER_INDEV   (XCBGRAB,          xcbgrab);
     REGISTER_OUTDEV  (XV,               xv);
 
     /* external libraries */
     REGISTER_INDEV   (LIBCDIO,          libcdio);
     REGISTER_INDEV   (LIBDC1394,        libdc1394);
 }
+
+void avdevice_register_all(void)
+{
+    static AVOnce control = AV_ONCE_INIT;
+
+    ff_thread_once(&control, register_all);
+}
diff --git a/mythtv/external/FFmpeg/libavdevice/alsa.c b/mythtv/external/FFmpeg/libavdevice/alsa.c
index 8d27913a1a9..1bbff30d5cc 100644
--- a/mythtv/external/FFmpeg/libavdevice/alsa.c
+++ b/mythtv/external/FFmpeg/libavdevice/alsa.c
@@ -300,6 +300,8 @@ av_cold int ff_alsa_close(AVFormatContext *s1)
 {
     AlsaData *s = s1->priv_data;
 
+    snd_pcm_nonblock(s->h, 0);
+    snd_pcm_drain(s->h);
     av_freep(&s->reorder_buf);
     if (CONFIG_ALSA_INDEV)
         ff_timefilter_destroy(s->timefilter);
diff --git a/mythtv/external/FFmpeg/libavdevice/alsa_enc.c b/mythtv/external/FFmpeg/libavdevice/alsa_enc.c
index bddc61f4aaf..0bef625ea46 100644
--- a/mythtv/external/FFmpeg/libavdevice/alsa_enc.c
+++ b/mythtv/external/FFmpeg/libavdevice/alsa_enc.c
@@ -130,7 +130,7 @@ static int audio_write_frame(AVFormatContext *s1, int stream_index,
     pkt.data     = (*frame)->data[0];
     pkt.size     = (*frame)->nb_samples * s->frame_size;
     pkt.dts      = (*frame)->pkt_dts;
-    pkt.duration = av_frame_get_pkt_duration(*frame);
+    pkt.duration = (*frame)->pkt_duration;
     return audio_write_packet(s1, &pkt);
 }
 
diff --git a/mythtv/external/FFmpeg/libavdevice/avdevice.h b/mythtv/external/FFmpeg/libavdevice/avdevice.h
index 6153f2cd46d..ee9462480e2 100644
--- a/mythtv/external/FFmpeg/libavdevice/avdevice.h
+++ b/mythtv/external/FFmpeg/libavdevice/avdevice.h
@@ -37,7 +37,7 @@
  * (de)muxers in libavdevice are of the AVFMT_NOFILE type (they use their own
  * I/O functions). The filename passed to avformat_open_input() often does not
  * refer to an actually existing file, but has some special device-specific
- * meaning - e.g. for x11grab it is the display name.
+ * meaning - e.g. for xcbgrab it is the display name.
  *
  * To use libavdevice, simply call avdevice_register_all() to register all
  * compiled muxers and demuxers. They all use standard libavformat API.
@@ -67,7 +67,6 @@ const char *avdevice_license(void);
 
 /**
  * Initialize libavdevice and register all the input and output devices.
- * @warning This function is not thread safe.
  */
 void avdevice_register_all(void);
 
diff --git a/mythtv/external/FFmpeg/libavdevice/bktr.c b/mythtv/external/FFmpeg/libavdevice/bktr.c
index 2902425b4d4..418247dc4eb 100644
--- a/mythtv/external/FFmpeg/libavdevice/bktr.c
+++ b/mythtv/external/FFmpeg/libavdevice/bktr.c
@@ -103,7 +103,7 @@ static av_cold int bktr_init(const char *video_device, int width, int height,
     long ioctl_frequency;
     char *arg;
     int c;
-    struct sigaction act = { {0} }, old;
+    struct sigaction act, old;
     int ret;
     char errbuf[128];
 
@@ -134,6 +134,7 @@ static av_cold int bktr_init(const char *video_device, int width, int height,
             frequency = 0.0;
     }
 
+    memset(&act, 0, sizeof(act));
     sigemptyset(&act.sa_mask);
     act.sa_handler = catchsignal;
     sigaction(SIGUSR1, &act, &old);
diff --git a/mythtv/external/FFmpeg/libavdevice/decklink_common.cpp b/mythtv/external/FFmpeg/libavdevice/decklink_common.cpp
index a3bc58dd6a0..2bd63ac820c 100644
--- a/mythtv/external/FFmpeg/libavdevice/decklink_common.cpp
+++ b/mythtv/external/FFmpeg/libavdevice/decklink_common.cpp
@@ -19,6 +19,12 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+/* Include internal.h first to avoid conflict between winsock.h (used by
+ * DeckLink headers) and winsock2.h (used by libavformat) in MSVC++ builds */
+extern "C" {
+#include "libavformat/internal.h"
+}
+
 #include <DeckLinkAPI.h>
 #ifdef _WIN32
 #include <DeckLinkAPI_i.c>
@@ -26,13 +32,12 @@
 #include <DeckLinkAPIDispatch.cpp>
 #endif
 
-#include <pthread.h>
-#include <semaphore.h>
-
 extern "C" {
 #include "libavformat/avformat.h"
-#include "libavformat/internal.h"
 #include "libavutil/imgutils.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/bswap.h"
+#include "avdevice.h"
 }
 
 #include "decklink_common.h"
@@ -80,7 +85,7 @@ static char *dup_cfstring_to_utf8(CFStringRef w)
 }
 #define DECKLINK_STR    const __CFString *
 #define DECKLINK_STRDUP dup_cfstring_to_utf8
-#define DECKLINK_FREE(s) free((void *) s)
+#define DECKLINK_FREE(s) CFRelease(s)
 #define DECKLINK_BOOL bool
 #else
 #define DECKLINK_STR    const char *
@@ -130,9 +135,23 @@ static int decklink_select_input(AVFormatContext *avctx, BMDDeckLinkConfiguratio
     return 0;
 }
 
+static DECKLINK_BOOL field_order_eq(enum AVFieldOrder field_order, BMDFieldDominance bmd_field_order)
+{
+    if (field_order == AV_FIELD_UNKNOWN)
+        return true;
+    if ((field_order == AV_FIELD_TT || field_order == AV_FIELD_TB) && bmd_field_order == bmdUpperFieldFirst)
+        return true;
+    if ((field_order == AV_FIELD_BB || field_order == AV_FIELD_BT) && bmd_field_order == bmdLowerFieldFirst)
+        return true;
+    if (field_order == AV_FIELD_PROGRESSIVE && (bmd_field_order == bmdProgressiveFrame || bmd_field_order == bmdProgressiveSegmentedFrame))
+        return true;
+    return false;
+}
+
 int ff_decklink_set_format(AVFormatContext *avctx,
                                int width, int height,
                                int tb_num, int tb_den,
+                               enum AVFieldOrder field_order,
                                decklink_direction_t direction, int num)
 {
     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
@@ -143,8 +162,8 @@ int ff_decklink_set_format(AVFormatContext *avctx,
     int i = 1;
     HRESULT res;
 
-    av_log(avctx, AV_LOG_DEBUG, "Trying to find mode for frame size %dx%d, frame timing %d/%d, direction %d, mode number %d\n",
-        width, height, tb_num, tb_den, direction, num);
+    av_log(avctx, AV_LOG_DEBUG, "Trying to find mode for frame size %dx%d, frame timing %d/%d, field order %d, direction %d, mode number %d, format code %s\n",
+        width, height, tb_num, tb_den, field_order, direction, num, (cctx->format_code) ? cctx->format_code : "(unset)");
 
     if (ctx->duplex_mode) {
         DECKLINK_BOOL duplex_supported = false;
@@ -181,24 +200,34 @@ int ff_decklink_set_format(AVFormatContext *avctx,
             return AVERROR(EIO);
     }
 
+    char format_buf[] = "    ";
+    if (cctx->format_code)
+        memcpy(format_buf, cctx->format_code, FFMIN(strlen(cctx->format_code), sizeof(format_buf)));
+    BMDDisplayMode target_mode = (BMDDisplayMode)AV_RB32(format_buf);
     AVRational target_tb = av_make_q(tb_num, tb_den);
     ctx->bmd_mode = bmdModeUnknown;
     while ((ctx->bmd_mode == bmdModeUnknown) && itermode->Next(&mode) == S_OK) {
         BMDTimeValue bmd_tb_num, bmd_tb_den;
         int bmd_width  = mode->GetWidth();
         int bmd_height = mode->GetHeight();
+        BMDDisplayMode bmd_mode = mode->GetDisplayMode();
+        BMDFieldDominance bmd_field_dominance = mode->GetFieldDominance();
 
         mode->GetFrameRate(&bmd_tb_num, &bmd_tb_den);
         AVRational mode_tb = av_make_q(bmd_tb_num, bmd_tb_den);
 
-        if ((bmd_width == width && bmd_height == height &&
-            !av_cmp_q(mode_tb, target_tb)) || i == num) {
-            ctx->bmd_mode   = mode->GetDisplayMode();
+        if ((bmd_width == width &&
+             bmd_height == height &&
+             !av_cmp_q(mode_tb, target_tb) &&
+             field_order_eq(field_order, bmd_field_dominance))
+             || i == num
+             || target_mode == bmd_mode) {
+            ctx->bmd_mode   = bmd_mode;
             ctx->bmd_width  = bmd_width;
             ctx->bmd_height = bmd_height;
             ctx->bmd_tb_den = bmd_tb_den;
             ctx->bmd_tb_num = bmd_tb_num;
-            ctx->bmd_field_dominance = mode->GetFieldDominance();
+            ctx->bmd_field_dominance = bmd_field_dominance;
             av_log(avctx, AV_LOG_INFO, "Found Decklink mode %d x %d with rate %.2f%s\n",
                 bmd_width, bmd_height, 1/av_q2d(mode_tb),
                 (ctx->bmd_field_dominance==bmdLowerFieldFirst || ctx->bmd_field_dominance==bmdUpperFieldFirst)?"(i)":"");
@@ -213,7 +242,7 @@ int ff_decklink_set_format(AVFormatContext *avctx,
     if (ctx->bmd_mode == bmdModeUnknown)
         return -1;
     if (direction == DIRECTION_IN) {
-        if (ctx->dli->DoesSupportVideoMode(ctx->bmd_mode, bmdFormat8BitYUV,
+        if (ctx->dli->DoesSupportVideoMode(ctx->bmd_mode, (BMDPixelFormat) cctx->raw_format,
                                            bmdVideoOutputFlagDefault,
                                            &support, NULL) != S_OK)
             return -1;
@@ -230,27 +259,103 @@ int ff_decklink_set_format(AVFormatContext *avctx,
 }
 
 int ff_decklink_set_format(AVFormatContext *avctx, decklink_direction_t direction, int num) {
-    return ff_decklink_set_format(avctx, 0, 0, 0, 0, direction, num);
+    return ff_decklink_set_format(avctx, 0, 0, 0, 0, AV_FIELD_UNKNOWN, direction, num);
 }
 
-int ff_decklink_list_devices(AVFormatContext *avctx)
+int ff_decklink_list_devices(AVFormatContext *avctx,
+                             struct AVDeviceInfoList *device_list,
+                             int show_inputs, int show_outputs)
 {
     IDeckLink *dl = NULL;
     IDeckLinkIterator *iter = CreateDeckLinkIteratorInstance();
+    int ret = 0;
+
     if (!iter) {
         av_log(avctx, AV_LOG_ERROR, "Could not create DeckLink iterator\n");
         return AVERROR(EIO);
     }
-    av_log(avctx, AV_LOG_INFO, "Blackmagic DeckLink devices:\n");
-    while (iter->Next(&dl) == S_OK) {
+
+    while (ret == 0 && iter->Next(&dl) == S_OK) {
+        IDeckLinkOutput *output_config;
+        IDeckLinkInput *input_config;
         const char *displayName;
+        AVDeviceInfo *new_device = NULL;
+        int add = 0;
+
         ff_decklink_get_display_name(dl, &displayName);
-        av_log(avctx, AV_LOG_INFO, "\t'%s'\n", displayName);
-        av_free((void *) displayName);
+
+        if (show_outputs) {
+            if (dl->QueryInterface(IID_IDeckLinkOutput, (void **)&output_config) == S_OK) {
+                output_config->Release();
+                add = 1;
+            }
+        }
+
+        if (show_inputs) {
+            if (dl->QueryInterface(IID_IDeckLinkInput, (void **)&input_config) == S_OK) {
+                input_config->Release();
+                add = 1;
+            }
+        }
+
+        if (add == 1) {
+            new_device = (AVDeviceInfo *) av_mallocz(sizeof(AVDeviceInfo));
+            if (!new_device) {
+                ret = AVERROR(ENOMEM);
+                goto next;
+            }
+            new_device->device_name = av_strdup(displayName);
+            if (!new_device->device_name) {
+                ret = AVERROR(ENOMEM);
+                goto next;
+            }
+
+            new_device->device_description = av_strdup(displayName);
+            if (!new_device->device_description) {
+                av_freep(&new_device->device_name);
+                ret = AVERROR(ENOMEM);
+                goto next;
+            }
+
+            if ((ret = av_dynarray_add_nofree(&device_list->devices,
+                                              &device_list->nb_devices, new_device)) < 0) {
+                av_freep(&new_device->device_name);
+                av_freep(&new_device->device_description);
+                av_freep(&new_device);
+                goto next;
+            }
+        }
+
+    next:
+        av_freep(&displayName);
         dl->Release();
     }
     iter->Release();
-    return 0;
+    return ret;
+}
+
+/* This is a wrapper around the ff_decklink_list_devices() which dumps the
+   output to av_log() and exits (for backward compatibility with the
+   "-list_devices" argument). */
+void ff_decklink_list_devices_legacy(AVFormatContext *avctx,
+                                     int show_inputs, int show_outputs)
+{
+    struct AVDeviceInfoList *device_list = NULL;
+    int ret;
+
+    device_list = (struct AVDeviceInfoList *) av_mallocz(sizeof(AVDeviceInfoList));
+    if (!device_list)
+        return;
+
+    ret = ff_decklink_list_devices(avctx, device_list, show_inputs, show_outputs);
+    if (ret == 0) {
+        av_log(avctx, AV_LOG_INFO, "Blackmagic DeckLink %s devices:\n",
+               show_inputs ? "input" : "output");
+        for (int i = 0; i < device_list->nb_devices; i++) {
+            av_log(avctx, AV_LOG_INFO, "\t'%s'\n", device_list->devices[i]->device_name);
+        }
+    }
+    avdevice_free_list_devices(&device_list);
 }
 
 int ff_decklink_list_formats(AVFormatContext *avctx, decklink_direction_t direction)
@@ -259,7 +364,7 @@ int ff_decklink_list_formats(AVFormatContext *avctx, decklink_direction_t direct
     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
     IDeckLinkDisplayModeIterator *itermode;
     IDeckLinkDisplayMode *mode;
-    int i=0;
+    uint32_t format_code;
     HRESULT res;
 
     if (direction == DIRECTION_IN) {
@@ -280,13 +385,14 @@ int ff_decklink_list_formats(AVFormatContext *avctx, decklink_direction_t direct
             return AVERROR(EIO);
     }
 
-    av_log(avctx, AV_LOG_INFO, "Supported formats for '%s':\n",
+    av_log(avctx, AV_LOG_INFO, "Supported formats for '%s':\n\tformat_code\tdescription",
                avctx->filename);
     while (itermode->Next(&mode) == S_OK) {
         BMDTimeValue tb_num, tb_den;
         mode->GetFrameRate(&tb_num, &tb_den);
-        av_log(avctx, AV_LOG_INFO, "\t%d\t%ldx%ld at %d/%d fps",
-                ++i,mode->GetWidth(), mode->GetHeight(),
+        format_code = av_bswap32(mode->GetDisplayMode());
+        av_log(avctx, AV_LOG_INFO, "\n\t%.4s\t\t%ldx%ld at %d/%d fps",
+                (char*) &format_code, mode->GetWidth(), mode->GetHeight(),
                 (int) tb_den, (int) tb_num);
         switch (mode->GetFieldDominance()) {
         case bmdLowerFieldFirst:
@@ -294,9 +400,9 @@ int ff_decklink_list_formats(AVFormatContext *avctx, decklink_direction_t direct
         case bmdUpperFieldFirst:
         av_log(avctx, AV_LOG_INFO, " (interlaced, upper field first)"); break;
         }
-        av_log(avctx, AV_LOG_INFO, "\n");
         mode->Release();
     }
+    av_log(avctx, AV_LOG_INFO, "\n");
 
     itermode->Release();
 
diff --git a/mythtv/external/FFmpeg/libavdevice/decklink_common.h b/mythtv/external/FFmpeg/libavdevice/decklink_common.h
index bfa2b084849..6b2525fb536 100644
--- a/mythtv/external/FFmpeg/libavdevice/decklink_common.h
+++ b/mythtv/external/FFmpeg/libavdevice/decklink_common.h
@@ -1,6 +1,7 @@
 /*
  * Blackmagic DeckLink common code
  * Copyright (c) 2013-2014 Ramiro Polla, Luca Barbato, Deti Fliegl
+ * Copyright (c) 2017 Akamai Technologies, Inc.
  *
  * This file is part of FFmpeg.
  *
@@ -24,6 +25,7 @@
 
 #include <DeckLinkAPIVersion.h>
 
+#include "libavutil/thread.h"
 #include "decklink_common_c.h"
 
 class decklink_output_callback;
@@ -37,6 +39,7 @@ typedef struct AVPacketQueue {
     pthread_mutex_t mutex;
     pthread_cond_t cond;
     AVFormatContext *avctx;
+    int64_t max_q_size;
 } AVPacketQueue;
 
 struct decklink_ctx {
@@ -89,7 +92,9 @@ struct decklink_ctx {
     int frames_preroll;
     int frames_buffer;
 
-    sem_t semaphore;
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    int frames_buffer_available_spots;
 
     int channels;
 };
@@ -128,9 +133,10 @@ static const BMDVideoConnection decklink_video_connection_map[] = {
 };
 
 HRESULT ff_decklink_get_display_name(IDeckLink *This, const char **displayName);
-int ff_decklink_set_format(AVFormatContext *avctx, int width, int height, int tb_num, int tb_den, decklink_direction_t direction = DIRECTION_OUT, int num = 0);
+int ff_decklink_set_format(AVFormatContext *avctx, int width, int height, int tb_num, int tb_den, enum AVFieldOrder field_order, decklink_direction_t direction = DIRECTION_OUT, int num = 0);
 int ff_decklink_set_format(AVFormatContext *avctx, decklink_direction_t direction, int num);
-int ff_decklink_list_devices(AVFormatContext *avctx);
+int ff_decklink_list_devices(AVFormatContext *avctx, struct AVDeviceInfoList *device_list, int show_inputs, int show_outputs);
+void ff_decklink_list_devices_legacy(AVFormatContext *avctx, int show_inputs, int show_outputs);
 int ff_decklink_list_formats(AVFormatContext *avctx, decklink_direction_t direction = DIRECTION_OUT);
 void ff_decklink_cleanup(AVFormatContext *avctx);
 int ff_decklink_init_device(AVFormatContext *avctx, const char* name);
diff --git a/mythtv/external/FFmpeg/libavdevice/decklink_common_c.h b/mythtv/external/FFmpeg/libavdevice/decklink_common_c.h
index d5656317aec..5616ab32f9c 100644
--- a/mythtv/external/FFmpeg/libavdevice/decklink_common_c.h
+++ b/mythtv/external/FFmpeg/libavdevice/decklink_common_c.h
@@ -1,6 +1,7 @@
 /*
  * Blackmagic DeckLink common code
  * Copyright (c) 2013-2014 Ramiro Polla
+ * Copyright (c) 2017 Akamai Technologies, Inc.
  *
  * This file is part of FFmpeg.
  *
@@ -47,6 +48,9 @@ struct decklink_cctx {
     int audio_input;
     int video_input;
     int draw_bars;
+    char *format_code;
+    int raw_format;
+    int64_t queue_size;
 };
 
 #endif /* AVDEVICE_DECKLINK_COMMON_C_H */
diff --git a/mythtv/external/FFmpeg/libavdevice/decklink_dec.cpp b/mythtv/external/FFmpeg/libavdevice/decklink_dec.cpp
index c98c51f6bf7..d9ac01ac91b 100644
--- a/mythtv/external/FFmpeg/libavdevice/decklink_dec.cpp
+++ b/mythtv/external/FFmpeg/libavdevice/decklink_dec.cpp
@@ -1,6 +1,8 @@
 /*
  * Blackmagic DeckLink input
  * Copyright (c) 2013-2014 Luca Barbato, Deti Fliegl
+ * Copyright (c) 2014 Rafaël Carré
+ * Copyright (c) 2017 Akamai Technologies, Inc.
  *
  * This file is part of FFmpeg.
  *
@@ -19,20 +21,25 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include <DeckLinkAPI.h>
+/* Include internal.h first to avoid conflict between winsock.h (used by
+ * DeckLink headers) and winsock2.h (used by libavformat) in MSVC++ builds */
+extern "C" {
+#include "libavformat/internal.h"
+}
 
-#include <pthread.h>
-#include <semaphore.h>
+#include <DeckLinkAPI.h>
 
 extern "C" {
 #include "config.h"
 #include "libavformat/avformat.h"
-#include "libavformat/internal.h"
+#include "libavutil/avassert.h"
 #include "libavutil/avutil.h"
 #include "libavutil/common.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/time.h"
 #include "libavutil/mathematics.h"
+#include "libavutil/reverse.h"
+#include "avdevice.h"
 #if CONFIG_LIBZVBI
 #include <libzvbi.h>
 #endif
@@ -41,7 +48,105 @@ extern "C" {
 #include "decklink_common.h"
 #include "decklink_dec.h"
 
-#if CONFIG_LIBZVBI
+#define MAX_WIDTH_VANC 1920
+
+typedef struct VANCLineNumber {
+    BMDDisplayMode mode;
+    int vanc_start;
+    int field0_vanc_end;
+    int field1_vanc_start;
+    int vanc_end;
+} VANCLineNumber;
+
+/* These VANC line numbers need not be very accurate. In any case
+ * GetBufferForVerticalBlankingLine() will return an error when invalid
+ * ancillary line number was requested. We just need to make sure that the
+ * entire VANC region is covered, while making sure we don't decode VANC of
+ * another source during switching*/
+static VANCLineNumber vanc_line_numbers[] = {
+    /* SD Modes */
+
+    {bmdModeNTSC, 11, 19, 274, 282},
+    {bmdModeNTSC2398, 11, 19, 274, 282},
+    {bmdModePAL, 7, 22, 320, 335},
+    {bmdModeNTSCp, 11, -1, -1, 39},
+    {bmdModePALp, 7, -1, -1, 45},
+
+    /* HD 1080 Modes */
+
+    {bmdModeHD1080p2398, 8, -1, -1, 42},
+    {bmdModeHD1080p24, 8, -1, -1, 42},
+    {bmdModeHD1080p25, 8, -1, -1, 42},
+    {bmdModeHD1080p2997, 8, -1, -1, 42},
+    {bmdModeHD1080p30, 8, -1, -1, 42},
+    {bmdModeHD1080i50, 8, 20, 570, 585},
+    {bmdModeHD1080i5994, 8, 20, 570, 585},
+    {bmdModeHD1080i6000, 8, 20, 570, 585},
+    {bmdModeHD1080p50, 8, -1, -1, 42},
+    {bmdModeHD1080p5994, 8, -1, -1, 42},
+    {bmdModeHD1080p6000, 8, -1, -1, 42},
+
+     /* HD 720 Modes */
+
+    {bmdModeHD720p50, 8, -1, -1, 26},
+    {bmdModeHD720p5994, 8, -1, -1, 26},
+    {bmdModeHD720p60, 8, -1, -1, 26},
+
+    /* For all other modes, for which we don't support VANC */
+    {bmdModeUnknown, 0, -1, -1, -1}
+};
+
+static int get_vanc_line_idx(BMDDisplayMode mode)
+{
+    unsigned int i;
+    for (i = 0; i < FF_ARRAY_ELEMS(vanc_line_numbers); i++) {
+        if (mode == vanc_line_numbers[i].mode)
+            return i;
+    }
+    /* Return the VANC idx for Unknown mode */
+    return i - 1;
+}
+
+static inline void clear_parity_bits(uint16_t *buf, int len) {
+    int i;
+    for (i = 0; i < len; i++)
+        buf[i] &= 0xff;
+}
+
+static int check_vanc_parity_checksum(uint16_t *buf, int len, uint16_t checksum) {
+    int i;
+    uint16_t vanc_sum = 0;
+    for (i = 3; i < len - 1; i++) {
+        uint16_t v = buf[i];
+        int np = v >> 8;
+        int p = av_parity(v & 0xff);
+        if ((!!p ^ !!(v & 0x100)) || (np != 1 && np != 2)) {
+            // Parity check failed
+            return -1;
+        }
+        vanc_sum += v;
+    }
+    vanc_sum &= 0x1ff;
+    vanc_sum |= ((~vanc_sum & 0x100) << 1);
+    if (checksum != vanc_sum) {
+        // Checksum verification failed
+        return -1;
+    }
+    return 0;
+}
+
+/* The 10-bit VANC data is packed in V210, we only need the luma component. */
+static void extract_luma_from_v210(uint16_t *dst, const uint8_t *src, int width)
+{
+    int i;
+    for (i = 0; i < width / 3; i++) {
+        *dst++ = (src[1] >> 2) + ((src[2] & 15) << 6);
+        *dst++ =  src[4]       + ((src[5] &  3) << 8);
+        *dst++ = (src[6] >> 4) + ((src[7] & 63) << 4);
+        src += 8;
+    }
+}
+
 static uint8_t calc_parity_and_line_offset(int line)
 {
     uint8_t ret = (line < 313) << 5;
@@ -52,30 +157,262 @@ static uint8_t calc_parity_and_line_offset(int line)
     return ret;
 }
 
-int teletext_data_unit_from_vbi_data(int line, uint8_t *src, uint8_t *tgt)
+static void fill_data_unit_head(int line, uint8_t *tgt)
+{
+    tgt[0] = 0x02; // data_unit_id
+    tgt[1] = 0x2c; // data_unit_length
+    tgt[2] = calc_parity_and_line_offset(line); // field_parity, line_offset
+    tgt[3] = 0xe4; // framing code
+}
+
+#if CONFIG_LIBZVBI
+static uint8_t* teletext_data_unit_from_vbi_data(int line, uint8_t *src, uint8_t *tgt, vbi_pixfmt fmt)
 {
     vbi_bit_slicer slicer;
 
-    vbi_bit_slicer_init(&slicer, 720, 13500000, 6937500, 6937500, 0x00aaaae4, 0xffff, 18, 6, 42 * 8, VBI_MODULATION_NRZ_MSB, VBI_PIXFMT_UYVY);
+    vbi_bit_slicer_init(&slicer, 720, 13500000, 6937500, 6937500, 0x00aaaae4, 0xffff, 18, 6, 42 * 8, VBI_MODULATION_NRZ_MSB, fmt);
 
     if (vbi_bit_slice(&slicer, src, tgt + 4) == FALSE)
-        return -1;
+        return tgt;
 
-    tgt[0] = 0x02; // data_unit_id
-    tgt[1] = 0x2c; // data_unit_length
-    tgt[2] = calc_parity_and_line_offset(line); // field_parity, line_offset
-    tgt[3] = 0xe4; // framing code
+    fill_data_unit_head(line, tgt);
 
-    return 0;
+    return tgt + 46;
+}
+
+static uint8_t* teletext_data_unit_from_vbi_data_10bit(int line, uint8_t *src, uint8_t *tgt)
+{
+    uint8_t y[720];
+    uint8_t *py = y;
+    uint8_t *pend = y + 720;
+    /* The 10-bit VBI data is packed in V210, but libzvbi only supports 8-bit,
+     * so we extract the 8 MSBs of the luma component, that is enough for
+     * teletext bit slicing. */
+    while (py < pend) {
+        *py++ = (src[1] >> 4) + ((src[2] & 15) << 4);
+        *py++ = (src[4] >> 2) + ((src[5] & 3 ) << 6);
+        *py++ = (src[6] >> 6) + ((src[7] & 63) << 2);
+        src += 8;
+    }
+    return teletext_data_unit_from_vbi_data(line, y, tgt, VBI_PIXFMT_YUV420);
 }
 #endif
 
+static uint8_t* teletext_data_unit_from_op47_vbi_packet(int line, uint16_t *py, uint8_t *tgt)
+{
+    int i;
+
+    if (py[0] != 0x255 || py[1] != 0x255 || py[2] != 0x227)
+        return tgt;
+
+    fill_data_unit_head(line, tgt);
+
+    py += 3;
+    tgt += 4;
+
+    for (i = 0; i < 42; i++)
+       *tgt++ = ff_reverse[py[i] & 255];
+
+    return tgt;
+}
+
+static int linemask_matches(int line, int64_t mask)
+{
+    int shift = -1;
+    if (line >= 6 && line <= 22)
+        shift = line - 6;
+    if (line >= 318 && line <= 335)
+        shift = line - 318 + 17;
+    return shift >= 0 && ((1ULL << shift) & mask);
+}
+
+static uint8_t* teletext_data_unit_from_op47_data(uint16_t *py, uint16_t *pend, uint8_t *tgt, int64_t wanted_lines)
+{
+    if (py < pend - 9) {
+        if (py[0] == 0x151 && py[1] == 0x115 && py[3] == 0x102) {       // identifier, identifier, format code for WST teletext
+            uint16_t *descriptors = py + 4;
+            int i;
+            py += 9;
+            for (i = 0; i < 5 && py < pend - 45; i++, py += 45) {
+                int line = (descriptors[i] & 31) + (!(descriptors[i] & 128)) * 313;
+                if (line && linemask_matches(line, wanted_lines))
+                    tgt = teletext_data_unit_from_op47_vbi_packet(line, py, tgt);
+            }
+        }
+    }
+    return tgt;
+}
+
+static uint8_t* teletext_data_unit_from_ancillary_packet(uint16_t *py, uint16_t *pend, uint8_t *tgt, int64_t wanted_lines, int allow_multipacket)
+{
+    uint16_t did = py[0];                                               // data id
+    uint16_t sdid = py[1];                                              // secondary data id
+    uint16_t dc = py[2] & 255;                                          // data count
+    py += 3;
+    pend = FFMIN(pend, py + dc);
+    if (did == 0x143 && sdid == 0x102) {                                // subtitle distribution packet
+        tgt = teletext_data_unit_from_op47_data(py, pend, tgt, wanted_lines);
+    } else if (allow_multipacket && did == 0x143 && sdid == 0x203) {    // VANC multipacket
+        py += 2;                                                        // priority, line/field
+        while (py < pend - 3) {
+            tgt = teletext_data_unit_from_ancillary_packet(py, pend, tgt, wanted_lines, 0);
+            py += 4 + (py[2] & 255);                                    // ndid, nsdid, ndc, line/field
+        }
+    }
+    return tgt;
+}
+
+uint8_t *vanc_to_cc(AVFormatContext *avctx, uint16_t *buf, size_t words,
+    unsigned &cc_count)
+{
+    size_t i, len = (buf[5] & 0xff) + 6 + 1;
+    uint8_t cdp_sum, rate;
+    uint16_t hdr, ftr;
+    uint8_t *cc;
+    uint16_t *cdp = &buf[6]; // CDP follows
+    if (cdp[0] != 0x96 || cdp[1] != 0x69) {
+        av_log(avctx, AV_LOG_WARNING, "Invalid CDP header 0x%.2x 0x%.2x\n", cdp[0], cdp[1]);
+        return NULL;
+    }
+
+    len -= 7; // remove VANC header and checksum
+
+    if (cdp[2] != len) {
+        av_log(avctx, AV_LOG_WARNING, "CDP len %d != %zu\n", cdp[2], len);
+        return NULL;
+    }
+
+    cdp_sum = 0;
+    for (i = 0; i < len - 1; i++)
+        cdp_sum += cdp[i];
+    cdp_sum = cdp_sum ? 256 - cdp_sum : 0;
+    if (cdp[len - 1] != cdp_sum) {
+        av_log(avctx, AV_LOG_WARNING, "CDP checksum invalid 0x%.4x != 0x%.4x\n", cdp_sum, cdp[len-1]);
+        return NULL;
+    }
+
+    rate = cdp[3];
+    if (!(rate & 0x0f)) {
+        av_log(avctx, AV_LOG_WARNING, "CDP frame rate invalid (0x%.2x)\n", rate);
+        return NULL;
+    }
+    rate >>= 4;
+    if (rate > 8) {
+        av_log(avctx, AV_LOG_WARNING, "CDP frame rate invalid (0x%.2x)\n", rate);
+        return NULL;
+    }
+
+    if (!(cdp[4] & 0x43)) /* ccdata_present | caption_service_active | reserved */ {
+        av_log(avctx, AV_LOG_WARNING, "CDP flags invalid (0x%.2x)\n", cdp[4]);
+        return NULL;
+    }
+
+    hdr = (cdp[5] << 8) | cdp[6];
+    if (cdp[7] != 0x72) /* ccdata_id */ {
+        av_log(avctx, AV_LOG_WARNING, "Invalid ccdata_id 0x%.2x\n", cdp[7]);
+        return NULL;
+    }
+
+    cc_count = cdp[8];
+    if (!(cc_count & 0xe0)) {
+        av_log(avctx, AV_LOG_WARNING, "Invalid cc_count 0x%.2x\n", cc_count);
+        return NULL;
+    }
+
+    cc_count &= 0x1f;
+    if ((len - 13) < cc_count * 3) {
+        av_log(avctx, AV_LOG_WARNING, "Invalid cc_count %d (> %zu)\n", cc_count * 3, len - 13);
+        return NULL;
+    }
+
+    if (cdp[len - 4] != 0x74) /* footer id */ {
+        av_log(avctx, AV_LOG_WARNING, "Invalid footer id 0x%.2x\n", cdp[len-4]);
+        return NULL;
+    }
+
+    ftr = (cdp[len - 3] << 8) | cdp[len - 2];
+    if (ftr != hdr) {
+        av_log(avctx, AV_LOG_WARNING, "Header 0x%.4x != Footer 0x%.4x\n", hdr, ftr);
+        return NULL;
+    }
+
+    cc = (uint8_t *)av_malloc(cc_count * 3);
+    if (cc == NULL) {
+        av_log(avctx, AV_LOG_WARNING, "CC - av_malloc failed for cc_count = %d\n", cc_count);
+        return NULL;
+    }
+
+    for (size_t i = 0; i < cc_count; i++) {
+        cc[3*i + 0] = cdp[9 + 3*i+0] /* & 3 */;
+        cc[3*i + 1] = cdp[9 + 3*i+1];
+        cc[3*i + 2] = cdp[9 + 3*i+2];
+    }
+
+    cc_count *= 3;
+    return cc;
+}
+
+uint8_t *get_metadata(AVFormatContext *avctx, uint16_t *buf, size_t width,
+                      uint8_t *tgt, size_t tgt_size, AVPacket *pkt)
+{
+    decklink_cctx *cctx = (struct decklink_cctx *) avctx->priv_data;
+    uint16_t *max_buf = buf + width;
+
+    while (buf < max_buf - 6) {
+        int len;
+        uint16_t did = buf[3] & 0xFF;                                  // data id
+        uint16_t sdid = buf[4] & 0xFF;                                 // secondary data id
+        /* Check for VANC header */
+        if (buf[0] != 0 || buf[1] != 0x3ff || buf[2] != 0x3ff) {
+            return tgt;
+        }
+
+        len = (buf[5] & 0xff) + 6 + 1;
+        if (len > max_buf - buf) {
+            av_log(avctx, AV_LOG_WARNING, "Data Count (%d) > data left (%zu)\n",
+                    len, max_buf - buf);
+            return tgt;
+        }
+
+        if (did == 0x43 && (sdid == 0x02 || sdid == 0x03) && cctx->teletext_lines &&
+            width == 1920 && tgt_size >= 1920) {
+            if (check_vanc_parity_checksum(buf, len, buf[len - 1]) < 0) {
+                av_log(avctx, AV_LOG_WARNING, "VANC parity or checksum incorrect\n");
+                goto skip_packet;
+            }
+            tgt = teletext_data_unit_from_ancillary_packet(buf + 3, buf + len, tgt, cctx->teletext_lines, 1);
+        } else if (did == 0x61 && sdid == 0x01) {
+            unsigned int data_len;
+            uint8_t *data;
+            if (check_vanc_parity_checksum(buf, len, buf[len - 1]) < 0) {
+                av_log(avctx, AV_LOG_WARNING, "VANC parity or checksum incorrect\n");
+                goto skip_packet;
+            }
+            clear_parity_bits(buf, len);
+            data = vanc_to_cc(avctx, buf, width, data_len);
+            if (data) {
+                if (av_packet_add_side_data(pkt, AV_PKT_DATA_A53_CC, data, data_len) < 0)
+                    av_free(data);
+            }
+        } else {
+            av_log(avctx, AV_LOG_DEBUG, "Unknown meta data DID = 0x%.2x SDID = 0x%.2x\n",
+                    did, sdid);
+        }
+skip_packet:
+        buf += len;
+    }
+
+    return tgt;
+}
+
 static void avpacket_queue_init(AVFormatContext *avctx, AVPacketQueue *q)
 {
+    struct decklink_cctx *ctx = (struct decklink_cctx *)avctx->priv_data;
     memset(q, 0, sizeof(AVPacketQueue));
     pthread_mutex_init(&q->mutex, NULL);
     pthread_cond_init(&q->cond, NULL);
     q->avctx = avctx;
+    q->max_q_size = ctx->queue_size;
 }
 
 static void avpacket_queue_flush(AVPacketQueue *q)
@@ -114,22 +451,24 @@ static unsigned long long avpacket_queue_size(AVPacketQueue *q)
 static int avpacket_queue_put(AVPacketQueue *q, AVPacket *pkt)
 {
     AVPacketList *pkt1;
+    int ret;
 
-    // Drop Packet if queue size is > 1GB
-    if (avpacket_queue_size(q) >  1024 * 1024 * 1024 ) {
+    // Drop Packet if queue size is > maximum queue size
+    if (avpacket_queue_size(q) > (uint64_t)q->max_q_size) {
         av_log(q->avctx, AV_LOG_WARNING,  "Decklink input buffer overrun!\n");
         return -1;
     }
-    /* duplicate the packet */
-    if (av_dup_packet(pkt) < 0) {
-        return -1;
-    }
 
-    pkt1 = (AVPacketList *)av_malloc(sizeof(AVPacketList));
+    pkt1 = (AVPacketList *)av_mallocz(sizeof(AVPacketList));
     if (!pkt1) {
         return -1;
     }
-    pkt1->pkt  = *pkt;
+    ret = av_packet_ref(&pkt1->pkt, pkt);
+    av_packet_unref(pkt);
+    if (ret < 0) {
+        av_free(pkt1);
+        return -1;
+    }
     pkt1->next = NULL;
 
     pthread_mutex_lock(&q->mutex);
@@ -208,6 +547,7 @@ decklink_input_callback::decklink_input_callback(AVFormatContext *_avctx) : m_re
     avctx = _avctx;
     decklink_cctx       *cctx = (struct decklink_cctx *)avctx->priv_data;
     ctx = (struct decklink_ctx *)cctx->ctx;
+    no_video = 0;
     initial_audio_pts = initial_video_pts = AV_NOPTS_VALUE;
     pthread_mutex_init(&m_mutex, NULL);
 }
@@ -264,8 +604,15 @@ static int64_t get_pkt_pts(IDeckLinkVideoInputFrame *videoFrame,
                 res = videoFrame->GetHardwareReferenceTimestamp(time_base.den, &bmd_pts, &bmd_duration);
             break;
         case PTS_SRC_WALLCLOCK:
-            pts = av_rescale_q(wallclock, AV_TIME_BASE_Q, time_base);
+        {
+            /* MSVC does not support compound literals like AV_TIME_BASE_Q
+             * in C++ code (compiler error C4576) */
+            AVRational timebase;
+            timebase.num = 1;
+            timebase.den = AV_TIME_BASE;
+            pts = av_rescale_q(wallclock, timebase, time_base);
             break;
+        }
     }
     if (res == S_OK)
         pts = bmd_pts / time_base.num;
@@ -348,26 +695,48 @@ HRESULT decklink_input_callback::VideoInputFrameArrived(
                            videoFrame->GetHeight();
         //fprintf(stderr,"Video Frame size %d ts %d\n", pkt.size, pkt.pts);
 
-#if CONFIG_LIBZVBI
-        if (!no_video && ctx->teletext_lines && videoFrame->GetPixelFormat() == bmdFormat8BitYUV && videoFrame->GetWidth() == 720) {
+        if (!no_video) {
             IDeckLinkVideoFrameAncillary *vanc;
             AVPacket txt_pkt;
-            uint8_t txt_buf0[1611]; // max 35 * 46 bytes decoded teletext lines + 1 byte data_identifier
+            uint8_t txt_buf0[3531]; // 35 * 46 bytes decoded teletext lines + 1 byte data_identifier + 1920 bytes OP47 decode buffer
             uint8_t *txt_buf = txt_buf0;
 
             if (videoFrame->GetAncillaryData(&vanc) == S_OK) {
                 int i;
                 int64_t line_mask = 1;
+                BMDPixelFormat vanc_format = vanc->GetPixelFormat();
                 txt_buf[0] = 0x10;    // data_identifier - EBU_data
                 txt_buf++;
-                for (i = 6; i < 336; i++, line_mask <<= 1) {
-                    uint8_t *buf;
-                    if ((ctx->teletext_lines & line_mask) && vanc->GetBufferForVerticalBlankingLine(i, (void**)&buf) == S_OK) {
-                        if (teletext_data_unit_from_vbi_data(i, buf, txt_buf) >= 0)
-                            txt_buf += 46;
+#if CONFIG_LIBZVBI
+                if (ctx->bmd_mode == bmdModePAL && ctx->teletext_lines &&
+                    (vanc_format == bmdFormat8BitYUV || vanc_format == bmdFormat10BitYUV)) {
+                    av_assert0(videoFrame->GetWidth() == 720);
+                    for (i = 6; i < 336; i++, line_mask <<= 1) {
+                        uint8_t *buf;
+                        if ((ctx->teletext_lines & line_mask) && vanc->GetBufferForVerticalBlankingLine(i, (void**)&buf) == S_OK) {
+                            if (vanc_format == bmdFormat8BitYUV)
+                                txt_buf = teletext_data_unit_from_vbi_data(i, buf, txt_buf, VBI_PIXFMT_UYVY);
+                            else
+                                txt_buf = teletext_data_unit_from_vbi_data_10bit(i, buf, txt_buf);
+                        }
+                        if (i == 22)
+                            i = 317;
+                    }
+                }
+#endif
+                if (vanc_format == bmdFormat10BitYUV && videoFrame->GetWidth() <= MAX_WIDTH_VANC) {
+                    int idx = get_vanc_line_idx(ctx->bmd_mode);
+                    for (i = vanc_line_numbers[idx].vanc_start; i <= vanc_line_numbers[idx].vanc_end; i++) {
+                        uint8_t *buf;
+                        if (vanc->GetBufferForVerticalBlankingLine(i, (void**)&buf) == S_OK) {
+                            uint16_t luma_vanc[MAX_WIDTH_VANC];
+                            extract_luma_from_v210(luma_vanc, buf, videoFrame->GetWidth());
+                            txt_buf = get_metadata(avctx, luma_vanc, videoFrame->GetWidth(),
+                                                   txt_buf, sizeof(txt_buf0) - (txt_buf - txt_buf0), &pkt);
+                        }
+                        if (i == vanc_line_numbers[idx].field0_vanc_end)
+                            i = vanc_line_numbers[idx].field1_vanc_start - 1;
                     }
-                    if (i == 22)
-                        i = 317;
                 }
                 vanc->Release();
                 if (txt_buf - txt_buf0 > 1) {
@@ -389,7 +758,6 @@ HRESULT decklink_input_callback::VideoInputFrameArrived(
                 }
             }
         }
-#endif
 
         if (avpacket_queue_put(&ctx->queue, &pkt) < 0) {
             ++ctx->dropped;
@@ -488,13 +856,6 @@ av_cold int ff_decklink_read_header(AVFormatContext *avctx)
     ctx->draw_bars = cctx->draw_bars;
     cctx->ctx = ctx;
 
-#if !CONFIG_LIBZVBI
-    if (ctx->teletext_lines) {
-        av_log(avctx, AV_LOG_ERROR, "Libzvbi support is needed for capturing teletext, please recompile FFmpeg.\n");
-        return AVERROR(ENOSYS);
-    }
-#endif
-
     /* Check audio channel option for valid values: 2, 8 or 16 */
     switch (cctx->audio_channels) {
         case 2:
@@ -508,13 +869,19 @@ av_cold int ff_decklink_read_header(AVFormatContext *avctx)
 
     /* List available devices. */
     if (ctx->list_devices) {
-        ff_decklink_list_devices(avctx);
+        ff_decklink_list_devices_legacy(avctx, 1, 0);
         return AVERROR_EXIT;
     }
 
+    if (cctx->v210) {
+        av_log(avctx, AV_LOG_WARNING, "The bm_v210 option is deprecated and will be removed. Please use the -raw_format yuv422p10.\n");
+        cctx->raw_format = MKBETAG('v','2','1','0');
+    }
+
     strcpy (fname, avctx->filename);
     tmp=strchr (fname, '@');
     if (tmp != NULL) {
+        av_log(avctx, AV_LOG_WARNING, "The @mode syntax is deprecated and will be removed. Please use the -format_code option.\n");
         mode_num = atoi (tmp+1);
         *tmp = 0;
     }
@@ -538,14 +905,23 @@ av_cold int ff_decklink_read_header(AVFormatContext *avctx)
         goto error;
     }
 
-    if (mode_num > 0) {
+    if (mode_num > 0 || cctx->format_code) {
         if (ff_decklink_set_format(avctx, DIRECTION_IN, mode_num) < 0) {
-            av_log(avctx, AV_LOG_ERROR, "Could not set mode %d for %s\n", mode_num, fname);
+            av_log(avctx, AV_LOG_ERROR, "Could not set mode number %d or format code %s for %s\n",
+                mode_num, (cctx->format_code) ? cctx->format_code : "(unset)", fname);
             ret = AVERROR(EIO);
             goto error;
         }
     }
 
+#if !CONFIG_LIBZVBI
+    if (ctx->teletext_lines && ctx->bmd_mode == bmdModePAL) {
+        av_log(avctx, AV_LOG_ERROR, "Libzvbi support is needed for capturing SD PAL teletext, please recompile FFmpeg.\n");
+        ret = AVERROR(ENOSYS);
+        goto error;
+    }
+#endif
+
     /* Setup streams. */
     st = avformat_new_stream(avctx, NULL);
     if (!st) {
@@ -574,15 +950,55 @@ av_cold int ff_decklink_read_header(AVFormatContext *avctx)
     st->time_base.num      = ctx->bmd_tb_num;
     av_stream_set_r_frame_rate(st, av_make_q(st->time_base.den, st->time_base.num));
 
-    if (cctx->v210) {
-        st->codecpar->codec_id    = AV_CODEC_ID_V210;
-        st->codecpar->codec_tag   = MKTAG('V', '2', '1', '0');
-        st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 64, st->time_base.den, st->time_base.num * 3);
-    } else {
+    switch((BMDPixelFormat)cctx->raw_format) {
+    case bmdFormat8BitYUV:
         st->codecpar->codec_id    = AV_CODEC_ID_RAWVIDEO;
-        st->codecpar->format      = AV_PIX_FMT_UYVY422;
         st->codecpar->codec_tag   = MKTAG('U', 'Y', 'V', 'Y');
+        st->codecpar->format      = AV_PIX_FMT_UYVY422;
         st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 16, st->time_base.den, st->time_base.num);
+        break;
+    case bmdFormat10BitYUV:
+        st->codecpar->codec_id    = AV_CODEC_ID_V210;
+        st->codecpar->codec_tag   = MKTAG('V','2','1','0');
+        st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 64, st->time_base.den, st->time_base.num * 3);
+        st->codecpar->bits_per_coded_sample = 10;
+        break;
+    case bmdFormat8BitARGB:
+        st->codecpar->codec_id    = AV_CODEC_ID_RAWVIDEO;
+        st->codecpar->codec_tag   = avcodec_pix_fmt_to_codec_tag((enum AVPixelFormat)st->codecpar->format);;
+        st->codecpar->format      = AV_PIX_FMT_0RGB;
+        st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 32, st->time_base.den, st->time_base.num);
+        break;
+    case bmdFormat8BitBGRA:
+        st->codecpar->codec_id    = AV_CODEC_ID_RAWVIDEO;
+        st->codecpar->codec_tag   = avcodec_pix_fmt_to_codec_tag((enum AVPixelFormat)st->codecpar->format);
+        st->codecpar->format      = AV_PIX_FMT_BGR0;
+        st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 32, st->time_base.den, st->time_base.num);
+        break;
+    case bmdFormat10BitRGB:
+        st->codecpar->codec_id    = AV_CODEC_ID_R210;
+        st->codecpar->codec_tag   = MKTAG('R','2','1','0');
+        st->codecpar->format      = AV_PIX_FMT_RGB48LE;
+        st->codecpar->bit_rate    = av_rescale(ctx->bmd_width * ctx->bmd_height * 30, st->time_base.den, st->time_base.num);
+        st->codecpar->bits_per_coded_sample = 10;
+        break;
+    default:
+        av_log(avctx, AV_LOG_ERROR, "Raw Format %.4s not supported\n", (char*) &cctx->raw_format);
+        ret = AVERROR(EINVAL);
+        goto error;
+    }
+
+    switch (ctx->bmd_field_dominance) {
+    case bmdUpperFieldFirst:
+        st->codecpar->field_order = AV_FIELD_TT;
+        break;
+    case bmdLowerFieldFirst:
+        st->codecpar->field_order = AV_FIELD_BB;
+        break;
+    case bmdProgressiveFrame:
+    case bmdProgressiveSegmentedFrame:
+        st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
+        break;
     }
 
     avpriv_set_pts_info(st, 64, 1, 1000000);  /* 64 bits pts in us */
@@ -614,7 +1030,7 @@ av_cold int ff_decklink_read_header(AVFormatContext *avctx)
     }
 
     result = ctx->dli->EnableVideoInput(ctx->bmd_mode,
-                                        cctx->v210 ? bmdFormat10BitYUV : bmdFormat8BitYUV,
+                                        (BMDPixelFormat) cctx->raw_format,
                                         bmdVideoInputFlagDefault);
 
     if (result != S_OK) {
@@ -642,17 +1058,15 @@ int ff_decklink_read_packet(AVFormatContext *avctx, AVPacket *pkt)
 {
     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
-    AVFrame *frame = ctx->video_st->codec->coded_frame;
 
     avpacket_queue_get(&ctx->queue, pkt, 1);
-    if (frame && (ctx->bmd_field_dominance == bmdUpperFieldFirst || ctx->bmd_field_dominance == bmdLowerFieldFirst)) {
-        frame->interlaced_frame = 1;
-        if (ctx->bmd_field_dominance == bmdUpperFieldFirst) {
-            frame->top_field_first = 1;
-        }
-    }
 
     return 0;
 }
 
+int ff_decklink_list_input_devices(AVFormatContext *avctx, struct AVDeviceInfoList *device_list)
+{
+    return ff_decklink_list_devices(avctx, device_list, 1, 0);
+}
+
 } /* extern "C" */
diff --git a/mythtv/external/FFmpeg/libavdevice/decklink_dec.h b/mythtv/external/FFmpeg/libavdevice/decklink_dec.h
index 9b71870deb7..fbfbe6280e5 100644
--- a/mythtv/external/FFmpeg/libavdevice/decklink_dec.h
+++ b/mythtv/external/FFmpeg/libavdevice/decklink_dec.h
@@ -29,6 +29,7 @@ extern "C" {
 int ff_decklink_read_header(AVFormatContext *avctx);
 int ff_decklink_read_packet(AVFormatContext *avctx, AVPacket *pkt);
 int ff_decklink_read_close(AVFormatContext *avctx);
+int ff_decklink_list_input_devices(AVFormatContext *avctx, struct AVDeviceInfoList *device_list);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/mythtv/external/FFmpeg/libavdevice/decklink_dec_c.c b/mythtv/external/FFmpeg/libavdevice/decklink_dec_c.c
index 543d16b3966..1127d23adaa 100644
--- a/mythtv/external/FFmpeg/libavdevice/decklink_dec_c.c
+++ b/mythtv/external/FFmpeg/libavdevice/decklink_dec_c.c
@@ -1,6 +1,7 @@
 /*
  * Blackmagic DeckLink input
  * Copyright (c) 2014 Deti Fliegl
+ * Copyright (c) 2017 Akamai Technologies, Inc.
  *
  * This file is part of FFmpeg.
  *
@@ -31,7 +32,14 @@
 static const AVOption options[] = {
     { "list_devices", "list available devices"  , OFFSET(list_devices), AV_OPT_TYPE_INT   , { .i64 = 0   }, 0, 1, DEC },
     { "list_formats", "list supported formats"  , OFFSET(list_formats), AV_OPT_TYPE_INT   , { .i64 = 0   }, 0, 1, DEC },
+    { "format_code",  "set format by fourcc"    , OFFSET(format_code),  AV_OPT_TYPE_STRING, { .str = NULL}, 0, 0, DEC },
     { "bm_v210",      "v210 10 bit per channel" , OFFSET(v210),         AV_OPT_TYPE_INT   , { .i64 = 0   }, 0, 1, DEC },
+    { "raw_format",   "pixel format to be returned by the card when capturing" , OFFSET(raw_format),  AV_OPT_TYPE_INT, { .i64 = MKBETAG('2','v','u','y')}, 0, UINT_MAX, DEC, "raw_format" },
+    { "uyvy422",       NULL,   0,  AV_OPT_TYPE_CONST, { .i64 = MKBETAG('2','v','u','y') }, 0, 0, DEC, "raw_format"},
+    { "yuv422p10",     NULL,   0,  AV_OPT_TYPE_CONST, { .i64 = MKBETAG('v','2','1','0') }, 0, 0, DEC, "raw_format"},
+    { "argb",          NULL,   0,  AV_OPT_TYPE_CONST, { .i64 = 32                       }, 0, 0, DEC, "raw_format"},
+    { "bgra",          NULL,   0,  AV_OPT_TYPE_CONST, { .i64 = MKBETAG('B','G','R','A') }, 0, 0, DEC, "raw_format"},
+    { "rgb10",         NULL,   0,  AV_OPT_TYPE_CONST, { .i64 = MKBETAG('r','2','1','0') }, 0, 0, DEC, "raw_format"},
     { "teletext_lines", "teletext lines bitmask", OFFSET(teletext_lines), AV_OPT_TYPE_INT64, { .i64 = 0   }, 0, 0x7ffffffffLL, DEC, "teletext_lines"},
     { "standard",     NULL,                                           0,  AV_OPT_TYPE_CONST, { .i64 = 0x7fff9fffeLL}, 0, 0,    DEC, "teletext_lines"},
     { "all",          NULL,                                           0,  AV_OPT_TYPE_CONST, { .i64 = 0x7ffffffffLL}, 0, 0,    DEC, "teletext_lines"},
@@ -63,6 +71,7 @@ static const AVOption options[] = {
     { "reference",     NULL,                                          0,  AV_OPT_TYPE_CONST, { .i64 = PTS_SRC_REFERENCE}, 0, 0, DEC, "pts_source"},
     { "wallclock",     NULL,                                          0,  AV_OPT_TYPE_CONST, { .i64 = PTS_SRC_WALLCLOCK}, 0, 0, DEC, "pts_source"},
     { "draw_bars",     "draw bars on signal loss" , OFFSET(draw_bars),    AV_OPT_TYPE_BOOL,  { .i64 = 1}, 0, 1, DEC },
+    { "queue_size",    "input queue buffer size",   OFFSET(queue_size),   AV_OPT_TYPE_INT64, { .i64 = (1024 * 1024 * 1024)}, 0, INT64_MAX, DEC },
     { NULL },
 };
 
@@ -77,9 +86,10 @@ static const AVClass decklink_demuxer_class = {
 AVInputFormat ff_decklink_demuxer = {
     .name           = "decklink",
     .long_name      = NULL_IF_CONFIG_SMALL("Blackmagic DeckLink input"),
-    .flags          = AVFMT_NOFILE | AVFMT_RAWPICTURE,
+    .flags          = AVFMT_NOFILE,
     .priv_class     = &decklink_demuxer_class,
     .priv_data_size = sizeof(struct decklink_cctx),
+    .get_device_list = ff_decklink_list_input_devices,
     .read_header   = ff_decklink_read_header,
     .read_packet   = ff_decklink_read_packet,
     .read_close    = ff_decklink_read_close,
diff --git a/mythtv/external/FFmpeg/libavdevice/decklink_enc.cpp b/mythtv/external/FFmpeg/libavdevice/decklink_enc.cpp
index dc4a24b8b1c..81df563b3bf 100644
--- a/mythtv/external/FFmpeg/libavdevice/decklink_enc.cpp
+++ b/mythtv/external/FFmpeg/libavdevice/decklink_enc.cpp
@@ -19,15 +19,21 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include <DeckLinkAPI.h>
+#include <atomic>
+using std::atomic;
+
+/* Include internal.h first to avoid conflict between winsock.h (used by
+ * DeckLink headers) and winsock2.h (used by libavformat) in MSVC++ builds */
+extern "C" {
+#include "libavformat/internal.h"
+}
 
-#include <pthread.h>
-#include <semaphore.h>
+#include <DeckLinkAPI.h>
 
 extern "C" {
 #include "libavformat/avformat.h"
-#include "libavformat/internal.h"
 #include "libavutil/imgutils.h"
+#include "avdevice.h"
 }
 
 #include "decklink_common.h"
@@ -38,33 +44,73 @@ extern "C" {
 class decklink_frame : public IDeckLinkVideoFrame
 {
 public:
-    decklink_frame(struct decklink_ctx *ctx, AVFrame *avframe, long width,
-                   long height, void *buffer) :
-                   _ctx(ctx), _avframe(avframe), _width(width),
-                   _height(height), _buffer(buffer), _refs(0) { }
+    decklink_frame(struct decklink_ctx *ctx, AVFrame *avframe, AVCodecID codec_id, int height, int width) :
+        _ctx(ctx), _avframe(avframe), _avpacket(NULL), _codec_id(codec_id), _height(height), _width(width),  _refs(1) { }
+    decklink_frame(struct decklink_ctx *ctx, AVPacket *avpacket, AVCodecID codec_id, int height, int width) :
+        _ctx(ctx), _avframe(NULL), _avpacket(avpacket), _codec_id(codec_id), _height(height), _width(width), _refs(1) { }
 
     virtual long           STDMETHODCALLTYPE GetWidth      (void)          { return _width; }
     virtual long           STDMETHODCALLTYPE GetHeight     (void)          { return _height; }
-    virtual long           STDMETHODCALLTYPE GetRowBytes   (void)          { return _width<<1; }
-    virtual BMDPixelFormat STDMETHODCALLTYPE GetPixelFormat(void)          { return bmdFormat8BitYUV; }
-    virtual BMDFrameFlags  STDMETHODCALLTYPE GetFlags      (void)          { return bmdVideoOutputFlagDefault; }
-    virtual HRESULT        STDMETHODCALLTYPE GetBytes      (void **buffer) { *buffer = _buffer; return S_OK; }
+    virtual long           STDMETHODCALLTYPE GetRowBytes   (void)
+    {
+      if (_codec_id == AV_CODEC_ID_WRAPPED_AVFRAME)
+          return _avframe->linesize[0] < 0 ? -_avframe->linesize[0] : _avframe->linesize[0];
+      else
+          return ((GetWidth() + 47) / 48) * 128;
+    }
+    virtual BMDPixelFormat STDMETHODCALLTYPE GetPixelFormat(void)
+    {
+        if (_codec_id == AV_CODEC_ID_WRAPPED_AVFRAME)
+            return bmdFormat8BitYUV;
+        else
+            return bmdFormat10BitYUV;
+    }
+    virtual BMDFrameFlags  STDMETHODCALLTYPE GetFlags      (void)
+    {
+       if (_codec_id == AV_CODEC_ID_WRAPPED_AVFRAME)
+           return _avframe->linesize[0] < 0 ? bmdFrameFlagFlipVertical : bmdFrameFlagDefault;
+       else
+           return bmdFrameFlagDefault;
+    }
+
+    virtual HRESULT        STDMETHODCALLTYPE GetBytes      (void **buffer)
+    {
+        if (_codec_id == AV_CODEC_ID_WRAPPED_AVFRAME) {
+            if (_avframe->linesize[0] < 0)
+                *buffer = (void *)(_avframe->data[0] + _avframe->linesize[0] * (_avframe->height - 1));
+            else
+                *buffer = (void *)(_avframe->data[0]);
+        } else {
+            *buffer = (void *)(_avpacket->data);
+        }
+        return S_OK;
+    }
 
     virtual HRESULT STDMETHODCALLTYPE GetTimecode     (BMDTimecodeFormat format, IDeckLinkTimecode **timecode) { return S_FALSE; }
     virtual HRESULT STDMETHODCALLTYPE GetAncillaryData(IDeckLinkVideoFrameAncillary **ancillary)               { return S_FALSE; }
 
     virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, LPVOID *ppv) { return E_NOINTERFACE; }
     virtual ULONG   STDMETHODCALLTYPE AddRef(void)                            { return ++_refs; }
-    virtual ULONG   STDMETHODCALLTYPE Release(void)                           { if (!--_refs) delete this; return _refs; }
+    virtual ULONG   STDMETHODCALLTYPE Release(void)
+    {
+        int ret = --_refs;
+        if (!ret) {
+            av_frame_free(&_avframe);
+            av_packet_free(&_avpacket);
+            delete this;
+        }
+        return ret;
+    }
 
     struct decklink_ctx *_ctx;
     AVFrame *_avframe;
+    AVPacket *_avpacket;
+    AVCodecID _codec_id;
+    int _height;
+    int _width;
 
 private:
-    long  _width;
-    long  _height;
-    void *_buffer;
-    int   _refs;
+    std::atomic<int>  _refs;
 };
 
 class decklink_output_callback : public IDeckLinkVideoOutputCallback
@@ -74,11 +120,16 @@ class decklink_output_callback : public IDeckLinkVideoOutputCallback
     {
         decklink_frame *frame = static_cast<decklink_frame *>(_frame);
         struct decklink_ctx *ctx = frame->_ctx;
-        AVFrame *avframe = frame->_avframe;
 
-        av_frame_free(&avframe);
+        if (frame->_avframe)
+            av_frame_unref(frame->_avframe);
+        if (frame->_avpacket)
+            av_packet_unref(frame->_avpacket);
 
-        sem_post(&ctx->semaphore);
+        pthread_mutex_lock(&ctx->mutex);
+        ctx->frames_buffer_available_spots++;
+        pthread_cond_broadcast(&ctx->cond);
+        pthread_mutex_unlock(&ctx->mutex);
 
         return S_OK;
     }
@@ -92,21 +143,28 @@ static int decklink_setup_video(AVFormatContext *avctx, AVStream *st)
 {
     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
-    AVCodecContext *c = st->codec;
+    AVCodecParameters *c = st->codecpar;
 
     if (ctx->video) {
         av_log(avctx, AV_LOG_ERROR, "Only one video stream is supported!\n");
         return -1;
     }
 
-    if (c->pix_fmt != AV_PIX_FMT_UYVY422) {
-        av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format!"
-               " Only AV_PIX_FMT_UYVY422 is supported.\n");
+    if (c->codec_id == AV_CODEC_ID_WRAPPED_AVFRAME) {
+        if (c->format != AV_PIX_FMT_UYVY422) {
+            av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format!"
+                   " Only AV_PIX_FMT_UYVY422 is supported.\n");
+            return -1;
+        }
+    } else if (c->codec_id != AV_CODEC_ID_V210) {
+        av_log(avctx, AV_LOG_ERROR, "Unsupported codec type!"
+               " Only V210 and wrapped frame with AV_PIX_FMT_UYVY422 are supported.\n");
         return -1;
     }
+
     if (ff_decklink_set_format(avctx, c->width, c->height,
-                            c->time_base.num, c->time_base.den)) {
-        av_log(avctx, AV_LOG_ERROR, "Unsupported video size or framerate!"
+                            st->time_base.num, st->time_base.den, c->field_order)) {
+        av_log(avctx, AV_LOG_ERROR, "Unsupported video size, framerate or field order!"
                " Check available formats with -list_formats 1.\n");
         return -1;
     }
@@ -120,18 +178,19 @@ static int decklink_setup_video(AVFormatContext *avctx, AVStream *st)
     ctx->output_callback = new decklink_output_callback();
     ctx->dlo->SetScheduledFrameCompletionCallback(ctx->output_callback);
 
-    /* Start video semaphore. */
-    ctx->frames_preroll = c->time_base.den * ctx->preroll;
-    if (c->time_base.den > 1000)
+    ctx->frames_preroll = st->time_base.den * ctx->preroll;
+    if (st->time_base.den > 1000)
         ctx->frames_preroll /= 1000;
 
     /* Buffer twice as many frames as the preroll. */
     ctx->frames_buffer = ctx->frames_preroll * 2;
     ctx->frames_buffer = FFMIN(ctx->frames_buffer, 60);
-    sem_init(&ctx->semaphore, 0, ctx->frames_buffer);
+    pthread_mutex_init(&ctx->mutex, NULL);
+    pthread_cond_init(&ctx->cond, NULL);
+    ctx->frames_buffer_available_spots = ctx->frames_buffer;
 
     /* The device expects the framerate to be fixed. */
-    avpriv_set_pts_info(st, 64, c->time_base.num, c->time_base.den);
+    avpriv_set_pts_info(st, 64, st->time_base.num, st->time_base.den);
 
     ctx->video = 1;
 
@@ -142,7 +201,7 @@ static int decklink_setup_audio(AVFormatContext *avctx, AVStream *st)
 {
     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
-    AVCodecContext *c = st->codec;
+    AVCodecParameters *c = st->codecpar;
 
     if (ctx->audio) {
         av_log(avctx, AV_LOG_ERROR, "Only one audio stream is supported!\n");
@@ -153,9 +212,9 @@ static int decklink_setup_audio(AVFormatContext *avctx, AVStream *st)
                " Only 48kHz is supported.\n");
         return -1;
     }
-    if (c->channels != 2 && c->channels != 8) {
+    if (c->channels != 2 && c->channels != 8 && c->channels != 16) {
         av_log(avctx, AV_LOG_ERROR, "Unsupported number of channels!"
-               " Only stereo and 7.1 are supported.\n");
+               " Only 2, 8 or 16 channels are supported.\n");
         return -1;
     }
     if (ctx->dlo->EnableAudioOutput(bmdAudioSampleRate48kHz,
@@ -198,7 +257,8 @@ av_cold int ff_decklink_write_trailer(AVFormatContext *avctx)
     if (ctx->output_callback)
         delete ctx->output_callback;
 
-    sem_destroy(&ctx->semaphore);
+    pthread_mutex_destroy(&ctx->mutex);
+    pthread_cond_destroy(&ctx->cond);
 
     av_freep(&cctx->ctx);
 
@@ -209,55 +269,62 @@ static int decklink_write_video_packet(AVFormatContext *avctx, AVPacket *pkt)
 {
     struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
     struct decklink_ctx *ctx = (struct decklink_ctx *)cctx->ctx;
-    AVPicture *avpicture = (AVPicture *) pkt->data;
-    AVFrame *avframe, *tmp;
+    AVStream *st = avctx->streams[pkt->stream_index];
+    AVFrame *avframe = NULL, *tmp = (AVFrame *)pkt->data;
+    AVPacket *avpacket = NULL;
     decklink_frame *frame;
     buffercount_type buffered;
     HRESULT hr;
 
-    /* HACK while av_uncoded_frame() isn't implemented */
-    int ret;
+    if (st->codecpar->codec_id == AV_CODEC_ID_WRAPPED_AVFRAME) {
+        if (tmp->format != AV_PIX_FMT_UYVY422 ||
+            tmp->width  != ctx->bmd_width ||
+            tmp->height != ctx->bmd_height) {
+            av_log(avctx, AV_LOG_ERROR, "Got a frame with invalid pixel format or dimension.\n");
+            return AVERROR(EINVAL);
+        }
 
-    tmp = av_frame_alloc();
-    if (!tmp)
-        return AVERROR(ENOMEM);
-    tmp->format = AV_PIX_FMT_UYVY422;
-    tmp->width  = ctx->bmd_width;
-    tmp->height = ctx->bmd_height;
-    ret = av_frame_get_buffer(tmp, 32);
-    if (ret < 0) {
-        av_frame_free(&tmp);
-        return ret;
-    }
-    av_image_copy(tmp->data, tmp->linesize, (const uint8_t **) avpicture->data,
-                  avpicture->linesize, (AVPixelFormat) tmp->format, tmp->width,
-                  tmp->height);
-    avframe = av_frame_clone(tmp);
-    av_frame_free(&tmp);
-    if (!avframe) {
-        av_log(avctx, AV_LOG_ERROR, "Could not clone video frame.\n");
-        return AVERROR(EIO);
+        avframe = av_frame_clone(tmp);
+        if (!avframe) {
+            av_log(avctx, AV_LOG_ERROR, "Could not clone video frame.\n");
+            return AVERROR(EIO);
+        }
+
+        frame = new decklink_frame(ctx, avframe, st->codecpar->codec_id, avframe->height, avframe->width);
+    } else {
+        avpacket = av_packet_clone(pkt);
+        if (!avpacket) {
+            av_log(avctx, AV_LOG_ERROR, "Could not clone video frame.\n");
+            return AVERROR(EIO);
+        }
+
+        frame = new decklink_frame(ctx, avpacket, st->codecpar->codec_id, ctx->bmd_height, ctx->bmd_width);
     }
-    /* end HACK */
 
-    frame = new decklink_frame(ctx, avframe, ctx->bmd_width, ctx->bmd_height,
-                               (void *) avframe->data[0]);
     if (!frame) {
         av_log(avctx, AV_LOG_ERROR, "Could not create new frame.\n");
+        av_frame_free(&avframe);
+        av_packet_free(&avpacket);
         return AVERROR(EIO);
     }
 
     /* Always keep at most one second of frames buffered. */
-    sem_wait(&ctx->semaphore);
+    pthread_mutex_lock(&ctx->mutex);
+    while (ctx->frames_buffer_available_spots == 0) {
+        pthread_cond_wait(&ctx->cond, &ctx->mutex);
+    }
+    ctx->frames_buffer_available_spots--;
+    pthread_mutex_unlock(&ctx->mutex);
 
     /* Schedule frame for playback. */
     hr = ctx->dlo->ScheduleVideoFrame((struct IDeckLinkVideoFrame *) frame,
                                       pkt->pts * ctx->bmd_tb_num,
                                       ctx->bmd_tb_num, ctx->bmd_tb_den);
+    /* Pass ownership to DeckLink, or release on failure */
+    frame->Release();
     if (hr != S_OK) {
         av_log(avctx, AV_LOG_ERROR, "Could not schedule video frame."
                 " error %08x.\n", (uint32_t) hr);
-        frame->Release();
         return AVERROR(EIO);
     }
 
@@ -323,9 +390,9 @@ av_cold int ff_decklink_write_header(AVFormatContext *avctx)
     ctx->preroll      = cctx->preroll;
     cctx->ctx = ctx;
 
-    /* List available devices. */
+    /* List available devices and exit. */
     if (ctx->list_devices) {
-        ff_decklink_list_devices(avctx);
+        ff_decklink_list_devices_legacy(avctx, 0, 1);
         return AVERROR_EXIT;
     }
 
@@ -352,7 +419,7 @@ av_cold int ff_decklink_write_header(AVFormatContext *avctx)
     ret = AVERROR(EIO);
     for (n = 0; n < avctx->nb_streams; n++) {
         AVStream *st = avctx->streams[n];
-        AVCodecContext *c = st->codec;
+        AVCodecParameters *c = st->codecpar;
         if        (c->codec_type == AVMEDIA_TYPE_AUDIO) {
             if (decklink_setup_audio(avctx, st))
                 goto error;
@@ -380,12 +447,17 @@ int ff_decklink_write_packet(AVFormatContext *avctx, AVPacket *pkt)
 
     ctx->last_pts = FFMAX(ctx->last_pts, pkt->pts);
 
-    if      (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
+    if      (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
         return decklink_write_video_packet(avctx, pkt);
-    else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
+    else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
         return decklink_write_audio_packet(avctx, pkt);
 
     return AVERROR(EIO);
 }
 
+int ff_decklink_list_output_devices(AVFormatContext *avctx, struct AVDeviceInfoList *device_list)
+{
+    return ff_decklink_list_devices(avctx, device_list, 0, 1);
+}
+
 } /* extern "C" */
diff --git a/mythtv/external/FFmpeg/libavdevice/decklink_enc.h b/mythtv/external/FFmpeg/libavdevice/decklink_enc.h
index 5ffc05cd686..39237673b4d 100644
--- a/mythtv/external/FFmpeg/libavdevice/decklink_enc.h
+++ b/mythtv/external/FFmpeg/libavdevice/decklink_enc.h
@@ -29,6 +29,7 @@ extern "C" {
 int ff_decklink_write_header(AVFormatContext *avctx);
 int ff_decklink_write_packet(AVFormatContext *avctx, AVPacket *pkt);
 int ff_decklink_write_trailer(AVFormatContext *avctx);
+int ff_decklink_list_output_devices(AVFormatContext *avctx, struct AVDeviceInfoList *device_list);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/mythtv/external/FFmpeg/libavdevice/decklink_enc_c.c b/mythtv/external/FFmpeg/libavdevice/decklink_enc_c.c
index c3c90184f81..360535cfdaa 100644
--- a/mythtv/external/FFmpeg/libavdevice/decklink_enc_c.c
+++ b/mythtv/external/FFmpeg/libavdevice/decklink_enc_c.c
@@ -46,9 +46,10 @@ AVOutputFormat ff_decklink_muxer = {
     .name           = "decklink",
     .long_name      = NULL_IF_CONFIG_SMALL("Blackmagic DeckLink output"),
     .audio_codec    = AV_CODEC_ID_PCM_S16LE,
-    .video_codec    = AV_CODEC_ID_RAWVIDEO,
+    .video_codec    = AV_CODEC_ID_WRAPPED_AVFRAME,
     .subtitle_codec = AV_CODEC_ID_NONE,
-    .flags          = AVFMT_NOFILE | AVFMT_RAWPICTURE,
+    .flags          = AVFMT_NOFILE,
+    .get_device_list = ff_decklink_list_output_devices,
     .priv_class     = &decklink_muxer_class,
     .priv_data_size = sizeof(struct decklink_cctx),
     .write_header   = ff_decklink_write_header,
diff --git a/mythtv/external/FFmpeg/libavdevice/dv1394.c b/mythtv/external/FFmpeg/libavdevice/dv1394.c
deleted file mode 100644
index c3483010fa0..00000000000
--- a/mythtv/external/FFmpeg/libavdevice/dv1394.c
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
- * Linux DV1394 interface
- * Copyright (c) 2003 Max Krasnyansky <maxk@qualcomm.com>
- *
- * 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 <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <poll.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-
-#include "libavutil/internal.h"
-#include "libavutil/log.h"
-#include "libavutil/opt.h"
-#include "avdevice.h"
-#include "libavformat/dv.h"
-#include "dv1394.h"
-
-struct dv1394_data {
-    AVClass *class;
-    int fd;
-    int channel;
-    int format;
-
-    uint8_t *ring; /* Ring buffer */
-    int index;  /* Current frame index */
-    int avail;  /* Number of frames available for reading */
-    int done;   /* Number of completed frames */
-
-    DVDemuxContext* dv_demux; /* Generic DV muxing/demuxing context */
-};
-
-/*
- * The trick here is to kludge around well known problem with kernel Ooopsing
- * when you try to capture PAL on a device node configure for NTSC. That's
- * why we have to configure the device node for PAL, and then read only NTSC
- * amount of data.
- */
-static int dv1394_reset(struct dv1394_data *dv)
-{
-    struct dv1394_init init;
-
-    init.channel     = dv->channel;
-    init.api_version = DV1394_API_VERSION;
-    init.n_frames    = DV1394_RING_FRAMES;
-    init.format      = DV1394_PAL;
-
-    if (ioctl(dv->fd, DV1394_INIT, &init) < 0)
-        return -1;
-
-    dv->avail  = dv->done = 0;
-    return 0;
-}
-
-static int dv1394_start(struct dv1394_data *dv)
-{
-    /* Tell DV1394 driver to enable receiver */
-    if (ioctl(dv->fd, DV1394_START_RECEIVE, 0) < 0) {
-        av_log(NULL, AV_LOG_ERROR, "Failed to start receiver: %s\n", strerror(errno));
-        return -1;
-    }
-    return 0;
-}
-
-static int dv1394_read_header(AVFormatContext * context)
-{
-    struct dv1394_data *dv = context->priv_data;
-
-    dv->dv_demux = avpriv_dv_init_demux(context);
-    if (!dv->dv_demux)
-        goto failed;
-
-    /* Open and initialize DV1394 device */
-    dv->fd = avpriv_open(context->filename, O_RDONLY);
-    if (dv->fd < 0) {
-        av_log(context, AV_LOG_ERROR, "Failed to open DV interface: %s\n", strerror(errno));
-        goto failed;
-    }
-
-    if (dv1394_reset(dv) < 0) {
-        av_log(context, AV_LOG_ERROR, "Failed to initialize DV interface: %s\n", strerror(errno));
-        goto failed;
-    }
-
-    dv->ring = mmap(NULL, DV1394_PAL_FRAME_SIZE * DV1394_RING_FRAMES,
-                    PROT_READ, MAP_PRIVATE, dv->fd, 0);
-    if (dv->ring == MAP_FAILED) {
-        av_log(context, AV_LOG_ERROR, "Failed to mmap DV ring buffer: %s\n", strerror(errno));
-        goto failed;
-    }
-
-    if (dv1394_start(dv) < 0)
-        goto failed;
-
-    return 0;
-
-failed:
-    close(dv->fd);
-    return AVERROR(EIO);
-}
-
-static int dv1394_read_packet(AVFormatContext *context, AVPacket *pkt)
-{
-    struct dv1394_data *dv = context->priv_data;
-    int size;
-
-    size = avpriv_dv_get_packet(dv->dv_demux, pkt);
-    if (size > 0)
-        return size;
-
-    if (!dv->avail) {
-        struct dv1394_status s;
-        struct pollfd p;
-
-        if (dv->done) {
-            /* Request more frames */
-            if (ioctl(dv->fd, DV1394_RECEIVE_FRAMES, dv->done) < 0) {
-                /* This usually means that ring buffer overflowed.
-                 * We have to reset :(.
-                 */
-
-                av_log(context, AV_LOG_ERROR, "DV1394: Ring buffer overflow. Resetting ..\n");
-
-                dv1394_reset(dv);
-                dv1394_start(dv);
-            }
-            dv->done = 0;
-        }
-
-        /* Wait until more frames are available */
-restart_poll:
-        p.fd = dv->fd;
-        p.events = POLLIN | POLLERR | POLLHUP;
-        if (poll(&p, 1, -1) < 0) {
-            if (errno == EAGAIN || errno == EINTR)
-                goto restart_poll;
-            av_log(context, AV_LOG_ERROR, "Poll failed: %s\n", strerror(errno));
-            return AVERROR(EIO);
-        }
-
-        if (ioctl(dv->fd, DV1394_GET_STATUS, &s) < 0) {
-            av_log(context, AV_LOG_ERROR, "Failed to get status: %s\n", strerror(errno));
-            return AVERROR(EIO);
-        }
-        av_log(context, AV_LOG_TRACE, "DV1394: status\n"
-                "\tactive_frame\t%d\n"
-                "\tfirst_clear_frame\t%d\n"
-                "\tn_clear_frames\t%d\n"
-                "\tdropped_frames\t%d\n",
-                s.active_frame, s.first_clear_frame,
-                s.n_clear_frames, s.dropped_frames);
-
-        dv->avail = s.n_clear_frames;
-        dv->index = s.first_clear_frame;
-        dv->done  = 0;
-
-        if (s.dropped_frames) {
-            av_log(context, AV_LOG_ERROR, "DV1394: Frame drop detected (%d). Resetting ..\n",
-                    s.dropped_frames);
-
-            dv1394_reset(dv);
-            dv1394_start(dv);
-        }
-    }
-
-    av_log(context, AV_LOG_TRACE, "index %d, avail %d, done %d\n", dv->index, dv->avail,
-            dv->done);
-
-    size = avpriv_dv_produce_packet(dv->dv_demux, pkt,
-                             dv->ring + (dv->index * DV1394_PAL_FRAME_SIZE),
-                             DV1394_PAL_FRAME_SIZE, -1);
-    dv->index = (dv->index + 1) % DV1394_RING_FRAMES;
-    dv->done++; dv->avail--;
-
-    return size;
-}
-
-static int dv1394_close(AVFormatContext * context)
-{
-    struct dv1394_data *dv = context->priv_data;
-
-    /* Shutdown DV1394 receiver */
-    if (ioctl(dv->fd, DV1394_SHUTDOWN, 0) < 0)
-        av_log(context, AV_LOG_ERROR, "Failed to shutdown DV1394: %s\n", strerror(errno));
-
-    /* Unmap ring buffer */
-    if (munmap(dv->ring, DV1394_NTSC_FRAME_SIZE * DV1394_RING_FRAMES) < 0)
-        av_log(context, AV_LOG_ERROR, "Failed to munmap DV1394 ring buffer: %s\n", strerror(errno));
-
-    close(dv->fd);
-    av_freep(&dv->dv_demux);
-
-    return 0;
-}
-
-static const AVOption options[] = {
-    { "standard", "", offsetof(struct dv1394_data, format), AV_OPT_TYPE_INT, {.i64 = DV1394_NTSC}, DV1394_NTSC, DV1394_PAL, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-    { "PAL",      "", 0, AV_OPT_TYPE_CONST, {.i64 = DV1394_PAL},   0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-    { "NTSC",     "", 0, AV_OPT_TYPE_CONST, {.i64 = DV1394_NTSC},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-    { "channel",  "", offsetof(struct dv1394_data, channel), AV_OPT_TYPE_INT, {.i64 = DV1394_DEFAULT_CHANNEL}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
-    { NULL },
-};
-
-static const AVClass dv1394_class = {
-    .class_name = "DV1394 indev",
-    .item_name  = av_default_item_name,
-    .option     = options,
-    .version    = LIBAVUTIL_VERSION_INT,
-    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
-};
-
-AVInputFormat ff_dv1394_demuxer = {
-    .name           = "dv1394",
-    .long_name      = NULL_IF_CONFIG_SMALL("DV1394 A/V grab"),
-    .priv_data_size = sizeof(struct dv1394_data),
-    .read_header    = dv1394_read_header,
-    .read_packet    = dv1394_read_packet,
-    .read_close     = dv1394_close,
-    .flags          = AVFMT_NOFILE,
-    .priv_class     = &dv1394_class,
-};
diff --git a/mythtv/external/FFmpeg/libavdevice/dv1394.h b/mythtv/external/FFmpeg/libavdevice/dv1394.h
deleted file mode 100644
index b76d633ef69..00000000000
--- a/mythtv/external/FFmpeg/libavdevice/dv1394.h
+++ /dev/null
@@ -1,357 +0,0 @@
-/*
- * DV input/output over IEEE 1394 on OHCI chips
- *   Copyright (C)2001 Daniel Maas <dmaas@dcine.com>
- *     receive, proc_fs by Dan Dennedy <dan@dennedy.org>
- *
- * based on:
- *   video1394.h - driver for OHCI 1394 boards
- *   Copyright (C)1999,2000 Sebastien Rougeaux <sebastien.rougeaux@anu.edu.au>
- *                          Peter Schlaile <udbz@rz.uni-karlsruhe.de>
- *
- * 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 AVDEVICE_DV1394_H
-#define AVDEVICE_DV1394_H
-
-#define DV1394_DEFAULT_CHANNEL 63
-#define DV1394_DEFAULT_CARD    0
-#define DV1394_RING_FRAMES     20
-
-#define DV1394_WIDTH  720
-#define DV1394_NTSC_HEIGHT 480
-#define DV1394_PAL_HEIGHT 576
-
-/* This is the public user-space interface. Try not to break it. */
-
-#define DV1394_API_VERSION 0x20011127
-
-/* ********************
-   **                **
-   **   DV1394 API   **
-   **                **
-   ********************
-
-   There are two methods of operating the DV1394 DV output device.
-
-   1)
-
-   The simplest is an interface based on write(): simply write
-   full DV frames of data to the device, and they will be transmitted
-   as quickly as possible. The FD may be set for non-blocking I/O,
-   in which case you can use select() or poll() to wait for output
-   buffer space.
-
-   To set the DV output parameters (e.g. whether you want NTSC or PAL
-   video), use the DV1394_INIT ioctl, passing in the parameters you
-   want in a struct dv1394_init.
-
-   Example 1:
-         To play a raw .DV file:   cat foo.DV > /dev/dv1394
-         (cat will use write() internally)
-
-   Example 2:
-           static struct dv1394_init init = {
-              0x63,        (broadcast channel)
-              4,           (four-frame ringbuffer)
-              DV1394_NTSC, (send NTSC video)
-              0, 0         (default empty packet rate)
-           }
-
-           ioctl(fd, DV1394_INIT, &init);
-
-           while(1) {
-                  read( <a raw DV file>, buf, DV1394_NTSC_FRAME_SIZE );
-                  write( <the dv1394 FD>, buf, DV1394_NTSC_FRAME_SIZE );
-           }
-
-   2)
-
-   For more control over buffering, and to avoid unnecessary copies
-   of the DV data, you can use the more sophisticated the mmap() interface.
-   First, call the DV1394_INIT ioctl to specify your parameters,
-   including the number of frames in the ringbuffer. Then, calling mmap()
-   on the dv1394 device will give you direct access to the ringbuffer
-   from which the DV card reads your frame data.
-
-   The ringbuffer is simply one large, contiguous region of memory
-   containing two or more frames of packed DV data. Each frame of DV data
-   is 120000 bytes (NTSC) or 144000 bytes (PAL).
-
-   Fill one or more frames in the ringbuffer, then use the DV1394_SUBMIT_FRAMES
-   ioctl to begin I/O. You can use either the DV1394_WAIT_FRAMES ioctl
-   or select()/poll() to wait until the frames are transmitted. Next, you'll
-   need to call the DV1394_GET_STATUS ioctl to determine which ringbuffer
-   frames are clear (ready to be filled with new DV data). Finally, use
-   DV1394_SUBMIT_FRAMES again to send the new data to the DV output.
-
-
-   Example: here is what a four-frame ringbuffer might look like
-            during DV transmission:
-
-
-         frame 0   frame 1   frame 2   frame 3
-
-        *--------------------------------------*
-        | CLEAR   | DV data | DV data | CLEAR  |
-        *--------------------------------------*
-                   <ACTIVE>
-
-        transmission goes in this direction --->>>
-
-
-   The DV hardware is currently transmitting the data in frame 1.
-   Once frame 1 is finished, it will automatically transmit frame 2.
-   (if frame 2 finishes before frame 3 is submitted, the device
-   will continue to transmit frame 2, and will increase the dropped_frames
-   counter each time it repeats the transmission).
-
-
-   If you called DV1394_GET_STATUS at this instant, you would
-   receive the following values:
-
-                  n_frames          = 4
-                  active_frame      = 1
-                  first_clear_frame = 3
-                  n_clear_frames    = 2
-
-   At this point, you should write new DV data into frame 3 and optionally
-   frame 0. Then call DV1394_SUBMIT_FRAMES to inform the device that
-   it may transmit the new frames.
-
-   ERROR HANDLING
-
-   An error (buffer underflow/overflow or a break in the DV stream due
-   to a 1394 bus reset) can be detected by checking the dropped_frames
-   field of struct dv1394_status (obtained through the
-   DV1394_GET_STATUS ioctl).
-
-   The best way to recover from such an error is to re-initialize
-   dv1394, either by using the DV1394_INIT ioctl call, or closing the
-   file descriptor and opening it again. (note that you must unmap all
-   ringbuffer mappings when closing the file descriptor, or else
-   dv1394 will still be considered 'in use').
-
-   MAIN LOOP
-
-   For maximum efficiency and robustness against bus errors, you are
-   advised to model the main loop of your application after the
-   following pseudo-code example:
-
-   (checks of system call return values omitted for brevity; always
-   check return values in your code!)
-
-   while( frames left ) {
-
-    struct pollfd *pfd = ...;
-
-    pfd->fd = dv1394_fd;
-    pfd->revents = 0;
-    pfd->events = POLLOUT | POLLIN; (OUT for transmit, IN for receive)
-
-    (add other sources of I/O here)
-
-    poll(pfd, 1, -1); (or select(); add a timeout if you want)
-
-    if(pfd->revents) {
-         struct dv1394_status status;
-
-         ioctl(dv1394_fd, DV1394_GET_STATUS, &status);
-
-         if(status.dropped_frames > 0) {
-              reset_dv1394();
-         } else {
-              int i;
-              for (i = 0; i < status.n_clear_frames; i++) {
-                  copy_DV_frame();
-              }
-         }
-    }
-   }
-
-   where copy_DV_frame() reads or writes on the dv1394 file descriptor
-   (read/write mode) or copies data to/from the mmap ringbuffer and
-   then calls ioctl(DV1394_SUBMIT_FRAMES) to notify dv1394 that new
-   frames are available (mmap mode).
-
-   reset_dv1394() is called in the event of a buffer
-   underflow/overflow or a halt in the DV stream (e.g. due to a 1394
-   bus reset). To guarantee recovery from the error, this function
-   should close the dv1394 file descriptor (and munmap() all
-   ringbuffer mappings, if you are using them), then re-open the
-   dv1394 device (and re-map the ringbuffer).
-
-*/
-
-
-/* maximum number of frames in the ringbuffer */
-#define DV1394_MAX_FRAMES 32
-
-/* number of *full* isochronous packets per DV frame */
-#define DV1394_NTSC_PACKETS_PER_FRAME 250
-#define DV1394_PAL_PACKETS_PER_FRAME  300
-
-/* size of one frame's worth of DV data, in bytes */
-#define DV1394_NTSC_FRAME_SIZE (480 * DV1394_NTSC_PACKETS_PER_FRAME)
-#define DV1394_PAL_FRAME_SIZE  (480 * DV1394_PAL_PACKETS_PER_FRAME)
-
-
-/* ioctl() commands */
-
-enum {
-        /* I don't like using 0 as a valid ioctl() */
-        DV1394_INVALID = 0,
-
-
-        /* get the driver ready to transmit video.
-           pass a struct dv1394_init* as the parameter (see below),
-           or NULL to get default parameters */
-        DV1394_INIT,
-
-
-        /* stop transmitting video and free the ringbuffer */
-        DV1394_SHUTDOWN,
-
-
-        /* submit N new frames to be transmitted, where
-           the index of the first new frame is first_clear_buffer,
-           and the index of the last new frame is
-           (first_clear_buffer + N) % n_frames */
-        DV1394_SUBMIT_FRAMES,
-
-
-        /* block until N buffers are clear (pass N as the parameter)
-           Because we re-transmit the last frame on underrun, there
-           will at most be n_frames - 1 clear frames at any time */
-        DV1394_WAIT_FRAMES,
-
-        /* capture new frames that have been received, where
-           the index of the first new frame is first_clear_buffer,
-           and the index of the last new frame is
-           (first_clear_buffer + N) % n_frames */
-        DV1394_RECEIVE_FRAMES,
-
-
-        DV1394_START_RECEIVE,
-
-
-        /* pass a struct dv1394_status* as the parameter (see below) */
-        DV1394_GET_STATUS,
-};
-
-
-
-enum pal_or_ntsc {
-        DV1394_NTSC = 0,
-        DV1394_PAL
-};
-
-
-
-
-/* this is the argument to DV1394_INIT */
-struct dv1394_init {
-        /* DV1394_API_VERSION */
-        unsigned int api_version;
-
-        /* isochronous transmission channel to use */
-        unsigned int channel;
-
-        /* number of frames in the ringbuffer. Must be at least 2
-           and at most DV1394_MAX_FRAMES. */
-        unsigned int n_frames;
-
-        /* send/receive PAL or NTSC video format */
-        enum pal_or_ntsc format;
-
-        /* the following are used only for transmission */
-
-        /* set these to zero unless you want a
-           non-default empty packet rate (see below) */
-        unsigned long cip_n;
-        unsigned long cip_d;
-
-        /* set this to zero unless you want a
-           non-default SYT cycle offset (default = 3 cycles) */
-        unsigned int syt_offset;
-};
-
-/* NOTE: you may only allocate the DV frame ringbuffer once each time
-   you open the dv1394 device. DV1394_INIT will fail if you call it a
-   second time with different 'n_frames' or 'format' arguments (which
-   would imply a different size for the ringbuffer). If you need a
-   different buffer size, simply close and re-open the device, then
-   initialize it with your new settings. */
-
-/* Q: What are cip_n and cip_d? */
-
-/*
-  A: DV video streams do not utilize 100% of the potential bandwidth offered
-  by IEEE 1394 (FireWire). To achieve the correct rate of data transmission,
-  DV devices must periodically insert empty packets into the 1394 data stream.
-  Typically there is one empty packet per 14-16 data-carrying packets.
-
-  Some DV devices will accept a wide range of empty packet rates, while others
-  require a precise rate. If the dv1394 driver produces empty packets at
-  a rate that your device does not accept, you may see ugly patterns on the
-  DV output, or even no output at all.
-
-  The default empty packet insertion rate seems to work for many people; if
-  your DV output is stable, you can simply ignore this discussion. However,
-  we have exposed the empty packet rate as a parameter to support devices that
-  do not work with the default rate.
-
-  The decision to insert an empty packet is made with a numerator/denominator
-  algorithm. Empty packets are produced at an average rate of CIP_N / CIP_D.
-  You can alter the empty packet rate by passing non-zero values for cip_n
-  and cip_d to the INIT ioctl.
-
- */
-
-
-
-struct dv1394_status {
-        /* this embedded init struct returns the current dv1394
-           parameters in use */
-        struct dv1394_init init;
-
-        /* the ringbuffer frame that is currently being
-           displayed. (-1 if the device is not transmitting anything) */
-        int active_frame;
-
-        /* index of the first buffer (ahead of active_frame) that
-           is ready to be filled with data */
-        unsigned int first_clear_frame;
-
-        /* how many buffers, including first_clear_buffer, are
-           ready to be filled with data */
-        unsigned int n_clear_frames;
-
-        /* how many times the DV stream has underflowed, overflowed,
-           or otherwise encountered an error, since the previous call
-           to DV1394_GET_STATUS */
-        unsigned int dropped_frames;
-
-        /* N.B. The dropped_frames counter is only a lower bound on the actual
-           number of dropped frames, with the special case that if dropped_frames
-           is zero, then it is guaranteed that NO frames have been dropped
-           since the last call to DV1394_GET_STATUS.
-        */
-};
-
-
-#endif /* AVDEVICE_DV1394_H */
diff --git a/mythtv/external/FFmpeg/libavdevice/fbdev_dec.c b/mythtv/external/FFmpeg/libavdevice/fbdev_dec.c
index 3b31373fd64..d9c75df2029 100644
--- a/mythtv/external/FFmpeg/libavdevice/fbdev_dec.c
+++ b/mythtv/external/FFmpeg/libavdevice/fbdev_dec.c
@@ -140,7 +140,7 @@ static av_cold int fbdev_read_header(AVFormatContext *avctx)
            fbdev->width, fbdev->height, fbdev->varinfo.bits_per_pixel,
            av_get_pix_fmt_name(pix_fmt),
            fbdev->framerate_q.num, fbdev->framerate_q.den,
-           (int64_t)st->codecpar->bit_rate);
+           st->codecpar->bit_rate);
     return 0;
 
 fail:
diff --git a/mythtv/external/FFmpeg/libavdevice/iec61883.c b/mythtv/external/FFmpeg/libavdevice/iec61883.c
index c45ae9ae5cd..721dca38eef 100644
--- a/mythtv/external/FFmpeg/libavdevice/iec61883.c
+++ b/mythtv/external/FFmpeg/libavdevice/iec61883.c
@@ -120,6 +120,7 @@ static int iec61883_callback(unsigned char *data, int length,
 
     packet->buf = av_malloc(length);
     if (!packet->buf) {
+        av_free(packet);
         ret = -1;
         goto exit;
     }
diff --git a/mythtv/external/FFmpeg/libavdevice/kmsgrab.c b/mythtv/external/FFmpeg/libavdevice/kmsgrab.c
new file mode 100644
index 00000000000..6a6de09c376
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavdevice/kmsgrab.c
@@ -0,0 +1,465 @@
+/*
+ * KMS/DRM input device
+ *
+ * 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 <fcntl.h>
+#include <unistd.h>
+
+#include <drm.h>
+#include <drm_fourcc.h>
+#include <drm_mode.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_drm.h"
+#include "libavutil/internal.h"
+#include "libavutil/mathematics.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixfmt.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/time.h"
+
+#include "libavformat/avformat.h"
+#include "libavformat/internal.h"
+
+typedef struct KMSGrabContext {
+    const AVClass *class;
+
+    AVBufferRef *device_ref;
+    AVHWDeviceContext *device;
+    AVDRMDeviceContext *hwctx;
+
+    AVBufferRef *frames_ref;
+    AVHWFramesContext *frames;
+
+    uint32_t plane_id;
+    uint32_t drm_format;
+    unsigned int width;
+    unsigned int height;
+
+    int64_t frame_delay;
+    int64_t frame_last;
+
+    const char *device_path;
+    enum AVPixelFormat format;
+    int64_t drm_format_modifier;
+    int64_t source_plane;
+    int64_t source_crtc;
+    AVRational framerate;
+} KMSGrabContext;
+
+static void kmsgrab_free_desc(void *opaque, uint8_t *data)
+{
+    AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor*)data;
+
+    close(desc->objects[0].fd);
+
+    av_free(desc);
+}
+
+static void kmsgrab_free_frame(void *opaque, uint8_t *data)
+{
+    AVFrame *frame = (AVFrame*)data;
+
+    av_frame_free(&frame);
+}
+
+static int kmsgrab_read_packet(AVFormatContext *avctx, AVPacket *pkt)
+{
+    KMSGrabContext *ctx = avctx->priv_data;
+    drmModePlane *plane;
+    drmModeFB *fb;
+    AVDRMFrameDescriptor *desc;
+    AVFrame *frame;
+    int64_t now;
+    int err, fd;
+
+    now = av_gettime();
+    if (ctx->frame_last) {
+        int64_t delay;
+        while (1) {
+            delay = ctx->frame_last + ctx->frame_delay - now;
+            if (delay <= 0)
+                break;
+            av_usleep(delay);
+            now = av_gettime();
+        }
+    }
+    ctx->frame_last = now;
+
+    plane = drmModeGetPlane(ctx->hwctx->fd, ctx->plane_id);
+    if (!plane) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to get plane "
+               "%"PRIu32".\n", ctx->plane_id);
+        return AVERROR(EIO);
+    }
+    if (!plane->fb_id) {
+        av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" no longer has "
+               "an associated framebuffer.\n", ctx->plane_id);
+        return AVERROR(EIO);
+    }
+
+    fb = drmModeGetFB(ctx->hwctx->fd, plane->fb_id);
+    if (!fb) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to get framebuffer "
+               "%"PRIu32".\n", plane->fb_id);
+        return AVERROR(EIO);
+    }
+    if (fb->width != ctx->width || fb->height != ctx->height) {
+        av_log(avctx, AV_LOG_ERROR, "Plane %"PRIu32" framebuffer "
+               "dimensions changed: now %"PRIu32"x%"PRIu32".\n",
+               ctx->plane_id, fb->width, fb->height);
+        return AVERROR(EIO);
+    }
+    if (!fb->handle) {
+        av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer.\n");
+        return AVERROR(EIO);
+    }
+
+    err = drmPrimeHandleToFD(ctx->hwctx->fd, fb->handle, O_RDONLY, &fd);
+    if (err < 0) {
+        err = errno;
+        av_log(avctx, AV_LOG_ERROR, "Failed to get PRIME fd from "
+               "framebuffer handle: %s.\n", strerror(errno));
+        return AVERROR(err);
+    }
+
+    desc = av_mallocz(sizeof(*desc));
+    if (!desc)
+        return AVERROR(ENOMEM);
+
+    *desc = (AVDRMFrameDescriptor) {
+        .nb_objects = 1,
+        .objects[0] = {
+            .fd               = fd,
+            .size             = fb->height * fb->pitch,
+            .format_modifier  = ctx->drm_format_modifier,
+        },
+        .nb_layers = 1,
+        .layers[0] = {
+            .format           = ctx->drm_format,
+            .nb_planes        = 1,
+            .planes[0] = {
+                .object_index = 0,
+                .offset       = 0,
+                .pitch        = fb->pitch,
+            },
+        },
+    };
+
+    frame = av_frame_alloc();
+    if (!frame)
+        return AVERROR(ENOMEM);
+
+    frame->hw_frames_ctx = av_buffer_ref(ctx->frames_ref);
+    if (!frame->hw_frames_ctx)
+        return AVERROR(ENOMEM);
+
+    frame->buf[0] = av_buffer_create((uint8_t*)desc, sizeof(*desc),
+                                     &kmsgrab_free_desc, avctx, 0);
+    if (!frame->buf[0])
+        return AVERROR(ENOMEM);
+
+    frame->data[0] = (uint8_t*)desc;
+    frame->format  = AV_PIX_FMT_DRM_PRIME;
+    frame->width   = fb->width;
+    frame->height  = fb->height;
+
+    drmModeFreeFB(fb);
+    drmModeFreePlane(plane);
+
+    pkt->buf = av_buffer_create((uint8_t*)frame, sizeof(*frame),
+                                &kmsgrab_free_frame, avctx, 0);
+    if (!pkt->buf)
+        return AVERROR(ENOMEM);
+
+    pkt->data   = (uint8_t*)frame;
+    pkt->size   = sizeof(*frame);
+    pkt->pts    = now;
+    pkt->flags |= AV_PKT_FLAG_TRUSTED;
+
+    return 0;
+}
+
+static const struct {
+    enum AVPixelFormat pixfmt;
+    uint32_t drm_format;
+} kmsgrab_formats[] = {
+#ifdef DRM_FORMAT_R8
+    { AV_PIX_FMT_GRAY8,    DRM_FORMAT_R8       },
+#endif
+#ifdef DRM_FORMAT_R16
+    { AV_PIX_FMT_GRAY16LE, DRM_FORMAT_R16      },
+    { AV_PIX_FMT_GRAY16BE, DRM_FORMAT_R16      | DRM_FORMAT_BIG_ENDIAN },
+#endif
+    { AV_PIX_FMT_BGR8,     DRM_FORMAT_BGR233   },
+    { AV_PIX_FMT_RGB555LE, DRM_FORMAT_XRGB1555 },
+    { AV_PIX_FMT_RGB555BE, DRM_FORMAT_XRGB1555 | DRM_FORMAT_BIG_ENDIAN },
+    { AV_PIX_FMT_BGR555LE, DRM_FORMAT_XBGR1555 },
+    { AV_PIX_FMT_BGR555BE, DRM_FORMAT_XBGR1555 | DRM_FORMAT_BIG_ENDIAN },
+    { AV_PIX_FMT_RGB565LE, DRM_FORMAT_RGB565   },
+    { AV_PIX_FMT_RGB565BE, DRM_FORMAT_RGB565   | DRM_FORMAT_BIG_ENDIAN },
+    { AV_PIX_FMT_BGR565LE, DRM_FORMAT_BGR565   },
+    { AV_PIX_FMT_BGR565BE, DRM_FORMAT_BGR565   | DRM_FORMAT_BIG_ENDIAN },
+    { AV_PIX_FMT_RGB24,    DRM_FORMAT_RGB888   },
+    { AV_PIX_FMT_BGR24,    DRM_FORMAT_BGR888   },
+    { AV_PIX_FMT_0RGB,     DRM_FORMAT_BGRX8888 },
+    { AV_PIX_FMT_0BGR,     DRM_FORMAT_RGBX8888 },
+    { AV_PIX_FMT_RGB0,     DRM_FORMAT_XBGR8888 },
+    { AV_PIX_FMT_BGR0,     DRM_FORMAT_XRGB8888 },
+    { AV_PIX_FMT_ARGB,     DRM_FORMAT_BGRA8888 },
+    { AV_PIX_FMT_ABGR,     DRM_FORMAT_RGBA8888 },
+    { AV_PIX_FMT_RGBA,     DRM_FORMAT_ABGR8888 },
+    { AV_PIX_FMT_BGRA,     DRM_FORMAT_ARGB8888 },
+    { AV_PIX_FMT_YUYV422,  DRM_FORMAT_YUYV     },
+    { AV_PIX_FMT_YVYU422,  DRM_FORMAT_YVYU     },
+    { AV_PIX_FMT_UYVY422,  DRM_FORMAT_UYVY     },
+};
+
+static av_cold int kmsgrab_read_header(AVFormatContext *avctx)
+{
+    KMSGrabContext *ctx = avctx->priv_data;
+    drmModePlaneRes *plane_res = NULL;
+    drmModePlane *plane = NULL;
+    drmModeFB *fb = NULL;
+    AVStream *stream;
+    int err, i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(kmsgrab_formats); i++) {
+        if (kmsgrab_formats[i].pixfmt == ctx->format) {
+            ctx->drm_format = kmsgrab_formats[i].drm_format;
+            break;
+        }
+    }
+    if (i >= FF_ARRAY_ELEMS(kmsgrab_formats)) {
+        av_log(avctx, AV_LOG_ERROR, "Unsupported format %s.\n",
+               av_get_pix_fmt_name(ctx->format));
+        return AVERROR(EINVAL);
+    }
+
+    err = av_hwdevice_ctx_create(&ctx->device_ref, AV_HWDEVICE_TYPE_DRM,
+                                 ctx->device_path, NULL, 0);
+    if (err < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to open DRM device.\n");
+        return err;
+    }
+    ctx->device = (AVHWDeviceContext*) ctx->device_ref->data;
+    ctx->hwctx  = (AVDRMDeviceContext*)ctx->device->hwctx;
+
+    err = drmSetClientCap(ctx->hwctx->fd,
+                          DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
+    if (err < 0) {
+        av_log(avctx, AV_LOG_WARNING, "Failed to set universal planes "
+               "capability: primary planes will not be usable.\n");
+    }
+
+    if (ctx->source_plane > 0) {
+        plane = drmModeGetPlane(ctx->hwctx->fd, ctx->source_plane);
+        if (!plane) {
+            err = errno;
+            av_log(avctx, AV_LOG_ERROR, "Failed to get plane %"PRId64": "
+                   "%s.\n", ctx->source_plane, strerror(err));
+            err = AVERROR(err);
+            goto fail;
+        }
+
+        if (plane->fb_id == 0) {
+            av_log(avctx, AV_LOG_ERROR, "Plane %"PRId64" does not have "
+                   "an attached framebuffer.\n", ctx->source_plane);
+            err = AVERROR(EINVAL);
+            goto fail;
+        }
+    } else {
+        plane_res = drmModeGetPlaneResources(ctx->hwctx->fd);
+        if (!plane_res) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to get plane "
+                   "resources: %s.\n", strerror(errno));
+            err = AVERROR(EINVAL);
+            goto fail;
+        }
+
+        for (i = 0; i < plane_res->count_planes; i++) {
+            plane = drmModeGetPlane(ctx->hwctx->fd,
+                                    plane_res->planes[i]);
+            if (!plane) {
+                err = errno;
+                av_log(avctx, AV_LOG_VERBOSE, "Failed to get "
+                       "plane %"PRIu32": %s.\n",
+                       plane_res->planes[i], strerror(err));
+                continue;
+            }
+
+            av_log(avctx, AV_LOG_DEBUG, "Plane %"PRIu32": "
+                   "CRTC %"PRIu32" FB %"PRIu32".\n",
+                   plane->plane_id, plane->crtc_id, plane->fb_id);
+
+            if ((ctx->source_crtc > 0 &&
+                 plane->crtc_id != ctx->source_crtc) ||
+                plane->fb_id == 0) {
+                // Either not connected to the target source CRTC
+                // or not active.
+                drmModeFreePlane(plane);
+                plane = NULL;
+                continue;
+            }
+
+            break;
+        }
+
+        if (i == plane_res->count_planes) {
+            if (ctx->source_crtc > 0) {
+                av_log(avctx, AV_LOG_ERROR, "No usable planes found on "
+                       "CRTC %"PRId64".\n", ctx->source_crtc);
+            } else {
+                av_log(avctx, AV_LOG_ERROR, "No usable planes found.\n");
+            }
+            err = AVERROR(EINVAL);
+            goto fail;
+        }
+
+        av_log(avctx, AV_LOG_INFO, "Using plane %"PRIu32" to "
+               "locate framebuffers.\n", plane->plane_id);
+    }
+
+    ctx->plane_id = plane->plane_id;
+
+    fb = drmModeGetFB(ctx->hwctx->fd, plane->fb_id);
+    if (!fb) {
+        err = errno;
+        av_log(avctx, AV_LOG_ERROR, "Failed to get "
+               "framebuffer %"PRIu32": %s.\n",
+               plane->fb_id, strerror(err));
+        err = AVERROR(err);
+        goto fail;
+    }
+
+    av_log(avctx, AV_LOG_INFO, "Template framebuffer is %"PRIu32": "
+           "%"PRIu32"x%"PRIu32" %"PRIu32"bpp %"PRIu32"b depth.\n",
+           fb->fb_id, fb->width, fb->height, fb->bpp, fb->depth);
+
+    ctx->width  = fb->width;
+    ctx->height = fb->height;
+
+    if (!fb->handle) {
+        av_log(avctx, AV_LOG_ERROR, "No handle set on framebuffer: "
+               "maybe you need some additional capabilities?\n");
+        err = AVERROR(EINVAL);
+        goto fail;
+    }
+
+    stream = avformat_new_stream(avctx, NULL);
+    if (!stream) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
+    stream->codecpar->codec_id   = AV_CODEC_ID_WRAPPED_AVFRAME;
+    stream->codecpar->width      = fb->width;
+    stream->codecpar->height     = fb->height;
+    stream->codecpar->format     = AV_PIX_FMT_DRM_PRIME;
+
+    avpriv_set_pts_info(stream, 64, 1, 1000000);
+
+    ctx->frames_ref = av_hwframe_ctx_alloc(ctx->device_ref);
+    if (!ctx->frames_ref) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+    ctx->frames = (AVHWFramesContext*)ctx->frames_ref->data;
+
+    ctx->frames->format    = AV_PIX_FMT_DRM_PRIME;
+    ctx->frames->sw_format = ctx->format,
+    ctx->frames->width     = fb->width;
+    ctx->frames->height    = fb->height;
+
+    err = av_hwframe_ctx_init(ctx->frames_ref);
+    if (err < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to initialise "
+               "hardware frames context: %d.\n", err);
+        goto fail;
+    }
+
+    ctx->frame_delay = av_rescale_q(1, (AVRational) { ctx->framerate.den,
+                ctx->framerate.num }, AV_TIME_BASE_Q);
+
+    err = 0;
+fail:
+    if (plane_res)
+        drmModeFreePlaneResources(plane_res);
+    if (plane)
+        drmModeFreePlane(plane);
+    if (fb)
+        drmModeFreeFB(fb);
+
+    return err;
+}
+
+static av_cold int kmsgrab_read_close(AVFormatContext *avctx)
+{
+    KMSGrabContext *ctx = avctx->priv_data;
+
+    av_buffer_unref(&ctx->frames_ref);
+    av_buffer_unref(&ctx->device_ref);
+
+    return 0;
+}
+
+#define OFFSET(x) offsetof(KMSGrabContext, x)
+#define FLAGS AV_OPT_FLAG_DECODING_PARAM
+static const AVOption options[] = {
+    { "device", "DRM device path",
+      OFFSET(device_path), AV_OPT_TYPE_STRING,
+      { .str = "/dev/dri/card0" }, 0, 0, FLAGS },
+    { "format", "Pixel format for framebuffer",
+      OFFSET(format), AV_OPT_TYPE_PIXEL_FMT,
+      { .i64 = AV_PIX_FMT_BGR0 }, 0, UINT32_MAX, FLAGS },
+    { "format_modifier", "DRM format modifier for framebuffer",
+      OFFSET(drm_format_modifier), AV_OPT_TYPE_INT64,
+      { .i64 = DRM_FORMAT_MOD_NONE }, 0, INT64_MAX, FLAGS },
+    { "crtc_id", "CRTC ID to define capture source",
+      OFFSET(source_crtc), AV_OPT_TYPE_INT64,
+      { .i64 = 0 }, 0, UINT32_MAX, FLAGS },
+    { "plane_id", "Plane ID to define capture source",
+      OFFSET(source_plane), AV_OPT_TYPE_INT64,
+      { .i64 = 0 }, 0, UINT32_MAX, FLAGS },
+    { "framerate", "Framerate to capture at",
+      OFFSET(framerate), AV_OPT_TYPE_RATIONAL,
+      { .dbl = 30.0 }, 0, 1000, FLAGS },
+    { NULL },
+};
+
+static const AVClass kmsgrab_class = {
+    .class_name = "kmsgrab indev",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVInputFormat ff_kmsgrab_demuxer = {
+    .name           = "kmsgrab",
+    .long_name      = NULL_IF_CONFIG_SMALL("KMS screen capture"),
+    .priv_data_size = sizeof(KMSGrabContext),
+    .read_header    = &kmsgrab_read_header,
+    .read_packet    = &kmsgrab_read_packet,
+    .read_close     = &kmsgrab_read_close,
+    .flags          = AVFMT_NOFILE,
+    .priv_class     = &kmsgrab_class,
+};
diff --git a/mythtv/external/FFmpeg/libavdevice/lavfi.c b/mythtv/external/FFmpeg/libavdevice/lavfi.c
index f9b2694650e..ede391f4d6b 100644
--- a/mythtv/external/FFmpeg/libavdevice/lavfi.c
+++ b/mythtv/external/FFmpeg/libavdevice/lavfi.c
@@ -312,31 +312,32 @@ av_cold static int lavfi_read_header(AVFormatContext *avctx)
 
     /* fill each stream with the information in the corresponding sink */
     for (i = 0; i < lavfi->nb_sinks; i++) {
-        AVFilterLink *link = lavfi->sinks[lavfi->stream_sink_map[i]]->inputs[0];
+        AVFilterContext *sink = lavfi->sinks[lavfi->stream_sink_map[i]];
+        AVRational time_base = av_buffersink_get_time_base(sink);
         AVStream *st = avctx->streams[i];
-        st->codecpar->codec_type = link->type;
-        avpriv_set_pts_info(st, 64, link->time_base.num, link->time_base.den);
-        if (link->type == AVMEDIA_TYPE_VIDEO) {
+        st->codecpar->codec_type = av_buffersink_get_type(sink);
+        avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
+        if (av_buffersink_get_type(sink) == AVMEDIA_TYPE_VIDEO) {
             st->codecpar->codec_id   = AV_CODEC_ID_RAWVIDEO;
-            st->codecpar->format     = link->format;
-            st->codecpar->width      = link->w;
-            st->codecpar->height     = link->h;
+            st->codecpar->format     = av_buffersink_get_format(sink);
+            st->codecpar->width      = av_buffersink_get_w(sink);
+            st->codecpar->height     = av_buffersink_get_h(sink);
             st       ->sample_aspect_ratio =
-            st->codecpar->sample_aspect_ratio = link->sample_aspect_ratio;
+            st->codecpar->sample_aspect_ratio = av_buffersink_get_sample_aspect_ratio(sink);
             avctx->probesize = FFMAX(avctx->probesize,
-                                     link->w * link->h *
-                                     av_get_padded_bits_per_pixel(av_pix_fmt_desc_get(link->format)) *
+                                     av_buffersink_get_w(sink) * av_buffersink_get_h(sink) *
+                                     av_get_padded_bits_per_pixel(av_pix_fmt_desc_get(av_buffersink_get_format(sink))) *
                                      30);
-        } else if (link->type == AVMEDIA_TYPE_AUDIO) {
-            st->codecpar->codec_id    = av_get_pcm_codec(link->format, -1);
-            st->codecpar->channels    = avfilter_link_get_channels(link);
-            st->codecpar->format      = link->format;
-            st->codecpar->sample_rate = link->sample_rate;
-            st->codecpar->channel_layout = link->channel_layout;
+        } else if (av_buffersink_get_type(sink) == AVMEDIA_TYPE_AUDIO) {
+            st->codecpar->codec_id    = av_get_pcm_codec(av_buffersink_get_format(sink), -1);
+            st->codecpar->channels    = av_buffersink_get_channels(sink);
+            st->codecpar->format      = av_buffersink_get_format(sink);
+            st->codecpar->sample_rate = av_buffersink_get_sample_rate(sink);
+            st->codecpar->channel_layout = av_buffersink_get_channel_layout(sink);
             if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
                 av_log(avctx, AV_LOG_ERROR,
                        "Could not find PCM codec for sample format %s.\n",
-                       av_get_sample_fmt_name(link->format));
+                       av_get_sample_fmt_name(av_buffersink_get_format(sink)));
         }
     }
 
@@ -375,7 +376,7 @@ static int create_subcc_packet(AVFormatContext *avctx, AVFrame *frame,
     memcpy(lavfi->subcc_packet.data, sd->data, sd->size);
     lavfi->subcc_packet.stream_index = stream_idx;
     lavfi->subcc_packet.pts = frame->pts;
-    lavfi->subcc_packet.pos = av_frame_get_pkt_pos(frame);
+    lavfi->subcc_packet.pos = frame->pkt_pos;
     return 0;
 }
 
@@ -400,7 +401,7 @@ static int lavfi_read_packet(AVFormatContext *avctx, AVPacket *pkt)
     /* iterate through all the graph sinks. Select the sink with the
      * minimum PTS */
     for (i = 0; i < lavfi->nb_sinks; i++) {
-        AVRational tb = lavfi->sinks[i]->inputs[0]->time_base;
+        AVRational tb = av_buffersink_get_time_base(lavfi->sinks[i]);
         double d;
         int ret;
 
@@ -439,15 +440,15 @@ static int lavfi_read_packet(AVFormatContext *avctx, AVPacket *pkt)
 
         av_image_copy_to_buffer(pkt->data, size, (const uint8_t **)frame->data, frame->linesize,
                                 frame->format, frame->width, frame->height, 1);
-    } else if (av_frame_get_channels(frame) /* FIXME test audio */) {
+    } else if (frame->channels /* FIXME test audio */) {
         size = frame->nb_samples * av_get_bytes_per_sample(frame->format) *
-                                   av_frame_get_channels(frame);
+                                   frame->channels;
         if ((ret = av_new_packet(pkt, size)) < 0)
             return ret;
         memcpy(pkt->data, frame->data[0], size);
     }
 
-    frame_metadata = av_frame_get_metadata(frame);
+    frame_metadata = frame->metadata;
     if (frame_metadata) {
         uint8_t *metadata;
         AVDictionaryEntry *e = NULL;
@@ -478,7 +479,7 @@ static int lavfi_read_packet(AVFormatContext *avctx, AVPacket *pkt)
 
     pkt->stream_index = stream_idx;
     pkt->pts = frame->pts;
-    pkt->pos = av_frame_get_pkt_pos(frame);
+    pkt->pos = frame->pkt_pos;
     pkt->size = size;
     av_frame_unref(frame);
     return size;
diff --git a/mythtv/external/FFmpeg/libavdevice/libdc1394.c b/mythtv/external/FFmpeg/libavdevice/libdc1394.c
index 60c61466524..003335fdd88 100644
--- a/mythtv/external/FFmpeg/libavdevice/libdc1394.c
+++ b/mythtv/external/FFmpeg/libavdevice/libdc1394.c
@@ -20,26 +20,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "config.h"
-
-#if HAVE_LIBDC1394_2
 #include <dc1394/dc1394.h>
-#elif HAVE_LIBDC1394_1
-#include <libraw1394/raw1394.h>
-#include <libdc1394/dc1394_control.h>
-
-#define DC1394_VIDEO_MODE_320x240_YUV422 MODE_320x240_YUV422
-#define DC1394_VIDEO_MODE_640x480_YUV411 MODE_640x480_YUV411
-#define DC1394_VIDEO_MODE_640x480_YUV422 MODE_640x480_YUV422
-#define DC1394_FRAMERATE_1_875 FRAMERATE_1_875
-#define DC1394_FRAMERATE_3_75  FRAMERATE_3_75
-#define DC1394_FRAMERATE_7_5   FRAMERATE_7_5
-#define DC1394_FRAMERATE_15    FRAMERATE_15
-#define DC1394_FRAMERATE_30    FRAMERATE_30
-#define DC1394_FRAMERATE_60    FRAMERATE_60
-#define DC1394_FRAMERATE_120   FRAMERATE_120
-#define DC1394_FRAMERATE_240   FRAMERATE_240
-#endif
 
 #include "libavutil/imgutils.h"
 #include "libavutil/internal.h"
@@ -54,22 +35,17 @@
 
 typedef struct dc1394_data {
     AVClass *class;
-#if HAVE_LIBDC1394_1
-    raw1394handle_t handle;
-    dc1394_cameracapture camera;
-    int channel;
-#elif HAVE_LIBDC1394_2
     dc1394_t *d;
     dc1394camera_t *camera;
     dc1394video_frame_t *frame;
-#endif
     int current_frame;
     int  frame_rate;        /**< frames per 1000 seconds (fps * 1000) */
     char *video_size;       /**< String describing video size, set by a private option. */
     char *pixel_format;     /**< Set by a private option. */
     char *framerate;        /**< Set by a private option. */
 
-    AVPacket packet;
+    int size;
+    int stream_index;
 } dc1394_data;
 
 static const struct dc1394_frame_format {
@@ -103,9 +79,6 @@ static const struct dc1394_frame_rate {
 #define OFFSET(x) offsetof(dc1394_data, x)
 #define DEC AV_OPT_FLAG_DECODING_PARAM
 static const AVOption options[] = {
-#if HAVE_LIBDC1394_1
-    { "channel", "", offsetof(dc1394_data, channel), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
-#endif
     { "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), AV_OPT_TYPE_STRING, {.str = "qvga"}, 0, 0, DEC },
     { "pixel_format", "", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = "uyvy422"}, 0, 0, DEC },
     { "framerate", "", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = "ntsc"}, 0, 0, DEC },
@@ -178,118 +151,20 @@ static inline int dc1394_read_common(AVFormatContext *c,
     vst->codecpar->format = fmt->pix_fmt;
     vst->avg_frame_rate = framerate;
 
-    /* packet init */
-    av_init_packet(&dc1394->packet);
-    dc1394->packet.size = av_image_get_buffer_size(fmt->pix_fmt,
-                                                   fmt->width, fmt->height, 1);
-    dc1394->packet.stream_index = vst->index;
-    dc1394->packet.flags |= AV_PKT_FLAG_KEY;
-
     dc1394->current_frame = 0;
+    dc1394->stream_index = vst->index;
+    dc1394->size = av_image_get_buffer_size(fmt->pix_fmt,
+                                            fmt->width, fmt->height, 1);
 
-    vst->codecpar->bit_rate = av_rescale(dc1394->packet.size * 8, fps->frame_rate, 1000);
+    vst->codecpar->bit_rate = av_rescale(dc1394->size * 8,
+                                         fps->frame_rate, 1000);
     *select_fps = fps;
     *select_fmt = fmt;
 out:
     return ret;
 }
 
-#if HAVE_LIBDC1394_1
-static int dc1394_v1_read_header(AVFormatContext *c)
-{
-    dc1394_data* dc1394 = c->priv_data;
-    AVStream* vst;
-    nodeid_t* camera_nodes;
-    int res;
-    struct dc1394_frame_format *fmt = NULL;
-    struct dc1394_frame_rate *fps = NULL;
-
-    if (dc1394_read_common(c, &fmt, &fps) != 0)
-        return -1;
-
-    /* Now let us prep the hardware. */
-    dc1394->handle = dc1394_create_handle(0); /* FIXME: gotta have ap->port */
-    if (!dc1394->handle) {
-        av_log(c, AV_LOG_ERROR, "Can't acquire dc1394 handle on port %d\n", 0 /* ap->port */);
-        goto out;
-    }
-    camera_nodes = dc1394_get_camera_nodes(dc1394->handle, &res, 1);
-    if (!camera_nodes || camera_nodes[dc1394->channel] == DC1394_NO_CAMERA) {
-        av_log(c, AV_LOG_ERROR, "There's no IIDC camera on the channel %d\n", dc1394->channel);
-        goto out_handle;
-    }
-    res = dc1394_dma_setup_capture(dc1394->handle, camera_nodes[dc1394->channel],
-                                   0,
-                                   FORMAT_VGA_NONCOMPRESSED,
-                                   fmt->frame_size_id,
-                                   SPEED_400,
-                                   fps->frame_rate_id, 8, 1,
-                                   c->filename,
-                                   &dc1394->camera);
-    dc1394_free_camera_nodes(camera_nodes);
-    if (res != DC1394_SUCCESS) {
-        av_log(c, AV_LOG_ERROR, "Can't prepare camera for the DMA capture\n");
-        goto out_handle;
-    }
-
-    res = dc1394_start_iso_transmission(dc1394->handle, dc1394->camera.node);
-    if (res != DC1394_SUCCESS) {
-        av_log(c, AV_LOG_ERROR, "Can't start isochronous transmission\n");
-        goto out_handle_dma;
-    }
-
-    return 0;
-
-out_handle_dma:
-    dc1394_dma_unlisten(dc1394->handle, &dc1394->camera);
-    dc1394_dma_release_camera(dc1394->handle, &dc1394->camera);
-out_handle:
-    dc1394_destroy_handle(dc1394->handle);
-out:
-    return -1;
-}
-
-static int dc1394_v1_read_packet(AVFormatContext *c, AVPacket *pkt)
-{
-    struct dc1394_data *dc1394 = c->priv_data;
-    int res;
-
-    /* discard stale frame */
-    if (dc1394->current_frame++) {
-        if (dc1394_dma_done_with_buffer(&dc1394->camera) != DC1394_SUCCESS)
-            av_log(c, AV_LOG_ERROR, "failed to release %d frame\n", dc1394->current_frame);
-    }
-
-    res = dc1394_dma_single_capture(&dc1394->camera);
-
-    if (res == DC1394_SUCCESS) {
-        dc1394->packet.data = (uint8_t *)(dc1394->camera.capture_buffer);
-        dc1394->packet.pts = (dc1394->current_frame * 1000000) / dc1394->frame_rate;
-        res = dc1394->packet.size;
-    } else {
-        av_log(c, AV_LOG_ERROR, "DMA capture failed\n");
-        dc1394->packet.data = NULL;
-        res = -1;
-    }
-
-    *pkt = dc1394->packet;
-    return res;
-}
-
-static int dc1394_v1_close(AVFormatContext * context)
-{
-    struct dc1394_data *dc1394 = context->priv_data;
-
-    dc1394_stop_iso_transmission(dc1394->handle, dc1394->camera.node);
-    dc1394_dma_unlisten(dc1394->handle, &dc1394->camera);
-    dc1394_dma_release_camera(dc1394->handle, &dc1394->camera);
-    dc1394_destroy_handle(dc1394->handle);
-
-    return 0;
-}
-
-#elif HAVE_LIBDC1394_2
-static int dc1394_v2_read_header(AVFormatContext *c)
+static int dc1394_read_header(AVFormatContext *c)
 {
     dc1394_data* dc1394 = c->priv_data;
     dc1394camera_list_t *list;
@@ -315,6 +190,14 @@ static int dc1394_v2_read_header(AVFormatContext *c)
 
     /* FIXME: To select a specific camera I need to search in list its guid */
     dc1394->camera = dc1394_camera_new (dc1394->d, list->ids[0].guid);
+
+    if (!dc1394->camera) {
+         av_log(c, AV_LOG_ERROR, "Unable to open camera with guid 0x%"PRIx64"\n",
+                list->ids[0].guid);
+         dc1394_camera_free_list(list);
+         goto out;
+    }
+
     if (list->num > 1) {
         av_log(c, AV_LOG_INFO, "Working with the first camera found\n");
     }
@@ -367,7 +250,7 @@ static int dc1394_v2_read_header(AVFormatContext *c)
     return -1;
 }
 
-static int dc1394_v2_read_packet(AVFormatContext *c, AVPacket *pkt)
+static int dc1394_read_packet(AVFormatContext *c, AVPacket *pkt)
 {
     struct dc1394_data *dc1394 = c->priv_data;
     int res;
@@ -380,20 +263,20 @@ static int dc1394_v2_read_packet(AVFormatContext *c, AVPacket *pkt)
 
     res = dc1394_capture_dequeue(dc1394->camera, DC1394_CAPTURE_POLICY_WAIT, &dc1394->frame);
     if (res == DC1394_SUCCESS) {
-        dc1394->packet.data = (uint8_t *) dc1394->frame->image;
-        dc1394->packet.pts  = dc1394->current_frame * 1000000 / dc1394->frame_rate;
-        res = dc1394->frame->image_bytes;
+        pkt->data = (uint8_t *)dc1394->frame->image;
+        pkt->size = dc1394->frame->image_bytes;
+        pkt->pts = dc1394->current_frame * 1000000 / dc1394->frame_rate;
+        pkt->flags |= AV_PKT_FLAG_KEY;
+        pkt->stream_index = dc1394->stream_index;
     } else {
         av_log(c, AV_LOG_ERROR, "DMA capture failed\n");
-        dc1394->packet.data = NULL;
-        res = -1;
+        return AVERROR_INVALIDDATA;
     }
 
-    *pkt = dc1394->packet;
-    return res;
+    return pkt->size;
 }
 
-static int dc1394_v2_close(AVFormatContext * context)
+static int dc1394_close(AVFormatContext * context)
 {
     struct dc1394_data *dc1394 = context->priv_data;
 
@@ -409,23 +292,9 @@ AVInputFormat ff_libdc1394_demuxer = {
     .name           = "libdc1394",
     .long_name      = NULL_IF_CONFIG_SMALL("dc1394 v.2 A/V grab"),
     .priv_data_size = sizeof(struct dc1394_data),
-    .read_header    = dc1394_v2_read_header,
-    .read_packet    = dc1394_v2_read_packet,
-    .read_close     = dc1394_v2_close,
-    .flags          = AVFMT_NOFILE,
-    .priv_class     = &libdc1394_class,
-};
-
-#endif
-#if HAVE_LIBDC1394_1
-AVInputFormat ff_libdc1394_demuxer = {
-    .name           = "libdc1394",
-    .long_name      = NULL_IF_CONFIG_SMALL("dc1394 v.1 A/V grab"),
-    .priv_data_size = sizeof(struct dc1394_data),
-    .read_header    = dc1394_v1_read_header,
-    .read_packet    = dc1394_v1_read_packet,
-    .read_close     = dc1394_v1_close,
+    .read_header    = dc1394_read_header,
+    .read_packet    = dc1394_read_packet,
+    .read_close     = dc1394_close,
     .flags          = AVFMT_NOFILE,
     .priv_class     = &libdc1394_class,
 };
-#endif
diff --git a/mythtv/external/FFmpeg/compat/plan9/main.c b/mythtv/external/FFmpeg/libavdevice/libndi_newtek_common.h
similarity index 67%
rename from mythtv/external/FFmpeg/compat/plan9/main.c
rename to mythtv/external/FFmpeg/libavdevice/libndi_newtek_common.h
index d46f96d1705..899031707d1 100644
--- a/mythtv/external/FFmpeg/compat/plan9/main.c
+++ b/mythtv/external/FFmpeg/libavdevice/libndi_newtek_common.h
@@ -1,4 +1,7 @@
 /*
+ * NewTek NDI common code
+ * Copyright (c) 2017 Maksym Veremeyenko
+ *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
@@ -16,19 +19,12 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-int plan9_main(int argc, char **argv);
+#ifndef AVDEVICE_LIBNDI_NEWTEK_COMMON_H
+#define AVDEVICE_LIBNDI_NEWTEK_COMMON_H
 
-#undef main
-int main(int argc, char **argv)
-{
-    /* The setfcr() function in lib9 is broken, must use asm. */
-#ifdef __i386
-    short fcr;
-    __asm__ volatile ("fstcw        %0 \n"
-                      "or      $63, %0 \n"
-                      "fldcw        %0 \n"
-                      : "=m"(fcr));
-#endif
+#include <Processing.NDI.Lib.h>
 
-    return plan9_main(argc, argv);
-}
+#define NDI_TIME_BASE 10000000
+#define NDI_TIME_BASE_Q (AVRational){1, NDI_TIME_BASE}
+
+#endif
diff --git a/mythtv/external/FFmpeg/libavdevice/libndi_newtek_dec.c b/mythtv/external/FFmpeg/libavdevice/libndi_newtek_dec.c
new file mode 100644
index 00000000000..8cbcd9a1d20
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavdevice/libndi_newtek_dec.c
@@ -0,0 +1,340 @@
+/*
+ * Newtek NDI input
+ * Copyright (c) 2017 Maksym Veremeyenko
+ *
+ * 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 "libavformat/avformat.h"
+#include "libavformat/internal.h"
+#include "libavutil/opt.h"
+#include "libavutil/imgutils.h"
+
+#include "libndi_newtek_common.h"
+
+struct NDIContext {
+    const AVClass *cclass;
+
+    /* Options */
+    int find_sources;
+    int64_t wait_sources;
+    int allow_video_fields;
+
+    /* Runtime */
+    NDIlib_recv_create_t *recv;
+    NDIlib_find_instance_t ndi_find;
+
+    /* Streams */
+    AVStream *video_st, *audio_st;
+};
+
+static int ndi_set_video_packet(AVFormatContext *avctx, NDIlib_video_frame_t *v, AVPacket *pkt)
+{
+    int ret;
+    struct NDIContext *ctx = avctx->priv_data;
+
+    ret = av_new_packet(pkt, v->yres * v->line_stride_in_bytes);
+    if (ret < 0)
+        return ret;
+
+    pkt->dts = pkt->pts = av_rescale_q(v->timecode, NDI_TIME_BASE_Q, ctx->video_st->time_base);
+    pkt->duration = av_rescale_q(1, (AVRational){v->frame_rate_D, v->frame_rate_N}, ctx->video_st->time_base);
+
+    av_log(avctx, AV_LOG_DEBUG, "%s: pkt->dts = pkt->pts = %"PRId64", duration=%"PRId64", timecode=%"PRId64"\n",
+        __func__, pkt->dts, pkt->duration, v->timecode);
+
+    pkt->flags         |= AV_PKT_FLAG_KEY;
+    pkt->stream_index   = ctx->video_st->index;
+
+    memcpy(pkt->data, v->p_data, pkt->size);
+
+    return 0;
+}
+
+static int ndi_set_audio_packet(AVFormatContext *avctx, NDIlib_audio_frame_t *a, AVPacket *pkt)
+{
+    int ret;
+    struct NDIContext *ctx = avctx->priv_data;
+
+    NDIlib_audio_frame_interleaved_16s_t dst;
+
+    ret = av_new_packet(pkt, 2 * a->no_samples * a->no_channels);
+    if (ret < 0)
+        return ret;
+
+    pkt->dts = pkt->pts = av_rescale_q(a->timecode, NDI_TIME_BASE_Q, ctx->audio_st->time_base);
+    pkt->duration = av_rescale_q(1, (AVRational){a->no_samples, a->sample_rate}, ctx->audio_st->time_base);
+
+    av_log(avctx, AV_LOG_DEBUG, "%s: pkt->dts = pkt->pts = %"PRId64", duration=%"PRId64", timecode=%"PRId64"\n",
+        __func__, pkt->dts, pkt->duration, a->timecode);
+
+    pkt->flags       |= AV_PKT_FLAG_KEY;
+    pkt->stream_index = ctx->audio_st->index;
+
+    dst.reference_level = 0;
+    dst.p_data = (short *)pkt->data;
+    NDIlib_util_audio_to_interleaved_16s(a, &dst);
+
+    return 0;
+}
+
+static int ndi_find_sources(AVFormatContext *avctx, const char *name, NDIlib_source_t *source_to_connect_to)
+{
+    int j = AVERROR(ENODEV);
+    unsigned int n, i;
+    struct NDIContext *ctx = avctx->priv_data;
+    const NDIlib_source_t *ndi_srcs = NULL;
+    const NDIlib_find_create_t find_create_desc = { .show_local_sources = true,
+        .p_groups = NULL, .p_extra_ips = NULL };
+
+    if (!ctx->ndi_find)
+        ctx->ndi_find = NDIlib_find_create2(&find_create_desc);
+    if (!ctx->ndi_find) {
+        av_log(avctx, AV_LOG_ERROR, "NDIlib_find_create failed.\n");
+        return AVERROR(EIO);
+    }
+
+    while (1)
+    {
+        int f, t = ctx->wait_sources / 1000;
+        av_log(avctx, AV_LOG_DEBUG, "Waiting for sources %d miliseconds\n", t);
+        f = NDIlib_find_wait_for_sources(ctx->ndi_find, t);
+        av_log(avctx, AV_LOG_DEBUG, "NDIlib_find_wait_for_sources returns %d\n", f);
+        if (!f)
+            break;
+    };
+
+    ndi_srcs = NDIlib_find_get_current_sources(ctx->ndi_find, &n);
+
+    if (ctx->find_sources)
+        av_log(avctx, AV_LOG_INFO, "Found %d NDI sources:\n", n);
+
+    for (i = 0; i < n; i++) {
+        if (ctx->find_sources)
+            av_log(avctx, AV_LOG_INFO, "\t'%s'\t'%s'\n", ndi_srcs[i].p_ndi_name, ndi_srcs[i].p_ip_address);
+
+        if (!strcmp(name, ndi_srcs[i].p_ndi_name)) {
+            *source_to_connect_to = ndi_srcs[i];
+            j = i;
+        }
+    }
+
+    return j;
+}
+
+static int ndi_read_header(AVFormatContext *avctx)
+{
+    int ret;
+    NDIlib_recv_create_t recv_create_desc;
+    const NDIlib_tally_t tally_state = { .on_program = true, .on_preview = false };
+    struct NDIContext *ctx = avctx->priv_data;
+
+    if (!NDIlib_initialize()) {
+        av_log(avctx, AV_LOG_ERROR, "NDIlib_initialize failed.\n");
+        return AVERROR_EXTERNAL;
+    }
+
+    /* Find available sources. */
+    ret = ndi_find_sources(avctx, avctx->filename, &recv_create_desc.source_to_connect_to);
+    if (ctx->find_sources) {
+        return AVERROR_EXIT;
+    }
+    if (ret < 0)
+        return ret;
+
+    /* Create receiver description */
+    recv_create_desc.color_format = NDIlib_recv_color_format_e_UYVY_RGBA;
+    recv_create_desc.bandwidth = NDIlib_recv_bandwidth_highest;
+    recv_create_desc.allow_video_fields = ctx->allow_video_fields;
+
+    /* Create the receiver */
+    ctx->recv = NDIlib_recv_create(&recv_create_desc);
+    if (!ctx->recv) {
+        av_log(avctx, AV_LOG_ERROR, "NDIlib_recv_create2 failed.\n");
+        return AVERROR(EIO);
+    }
+
+    /* Set tally */
+    NDIlib_recv_set_tally(ctx->recv, &tally_state);
+
+    avctx->ctx_flags |= AVFMTCTX_NOHEADER;
+
+    return 0;
+}
+
+static int ndi_create_video_stream(AVFormatContext *avctx, NDIlib_video_frame_t *v)
+{
+    AVStream *st;
+    AVRational tmp;
+    struct NDIContext *ctx = avctx->priv_data;
+
+    st = avformat_new_stream(avctx, NULL);
+    if (!st) {
+        av_log(avctx, AV_LOG_ERROR, "Cannot add video stream\n");
+        return AVERROR(ENOMEM);
+    }
+
+    st->time_base                   = NDI_TIME_BASE_Q;
+    av_stream_set_r_frame_rate(st, av_make_q(v->frame_rate_N, v->frame_rate_D));
+
+    tmp = av_mul_q(av_d2q(v->picture_aspect_ratio, INT_MAX), (AVRational){v->yres, v->xres});
+    av_reduce(&st->sample_aspect_ratio.num, &st->sample_aspect_ratio.den, tmp.num, tmp.den, 1000);
+    st->codecpar->sample_aspect_ratio = st->sample_aspect_ratio;
+
+    st->codecpar->codec_type        = AVMEDIA_TYPE_VIDEO;
+    st->codecpar->width             = v->xres;
+    st->codecpar->height            = v->yres;
+    st->codecpar->codec_id          = AV_CODEC_ID_RAWVIDEO;
+    st->codecpar->bit_rate          = av_rescale(v->xres * v->yres * 16, v->frame_rate_N, v->frame_rate_D);
+    st->codecpar->field_order       = v->frame_format_type == NDIlib_frame_format_type_progressive
+        ? AV_FIELD_PROGRESSIVE : AV_FIELD_TT;
+
+    if (NDIlib_FourCC_type_UYVY == v->FourCC || NDIlib_FourCC_type_UYVA == v->FourCC) {
+        st->codecpar->format        = AV_PIX_FMT_UYVY422;
+        st->codecpar->codec_tag     = MKTAG('U', 'Y', 'V', 'Y');
+        if (NDIlib_FourCC_type_UYVA == v->FourCC)
+            av_log(avctx, AV_LOG_WARNING, "Alpha channel ignored\n");
+    } else if (NDIlib_FourCC_type_BGRA == v->FourCC) {
+        st->codecpar->format        = AV_PIX_FMT_BGRA;
+        st->codecpar->codec_tag     = MKTAG('B', 'G', 'R', 'A');
+    } else if (NDIlib_FourCC_type_BGRX == v->FourCC) {
+        st->codecpar->format        = AV_PIX_FMT_BGR0;
+        st->codecpar->codec_tag     = MKTAG('B', 'G', 'R', '0');
+    } else if (NDIlib_FourCC_type_RGBA == v->FourCC) {
+        st->codecpar->format        = AV_PIX_FMT_RGBA;
+        st->codecpar->codec_tag     = MKTAG('R', 'G', 'B', 'A');
+    } else if (NDIlib_FourCC_type_RGBX == v->FourCC) {
+        st->codecpar->format        = AV_PIX_FMT_RGB0;
+        st->codecpar->codec_tag     = MKTAG('R', 'G', 'B', '0');
+    } else {
+        av_log(avctx, AV_LOG_ERROR, "Unsupported video stream format, v->FourCC=%d\n", v->FourCC);
+        return AVERROR(EINVAL);
+    }
+
+    avpriv_set_pts_info(st, 64, 1, NDI_TIME_BASE);
+
+    ctx->video_st = st;
+
+    return 0;
+}
+
+static int ndi_create_audio_stream(AVFormatContext *avctx, NDIlib_audio_frame_t *a)
+{
+    AVStream *st;
+    struct NDIContext *ctx = avctx->priv_data;
+
+    st = avformat_new_stream(avctx, NULL);
+    if (!st) {
+        av_log(avctx, AV_LOG_ERROR, "Cannot add audio stream\n");
+        return AVERROR(ENOMEM);
+    }
+
+    st->codecpar->codec_type        = AVMEDIA_TYPE_AUDIO;
+    st->codecpar->codec_id          = AV_CODEC_ID_PCM_S16LE;
+    st->codecpar->sample_rate       = a->sample_rate;
+    st->codecpar->channels          = a->no_channels;
+
+    avpriv_set_pts_info(st, 64, 1, NDI_TIME_BASE);
+
+    ctx->audio_st = st;
+
+    return 0;
+}
+
+static int ndi_read_packet(AVFormatContext *avctx, AVPacket *pkt)
+{
+    int ret = 0;
+    struct NDIContext *ctx = avctx->priv_data;
+
+    while (!ret) {
+        NDIlib_video_frame_t v;
+        NDIlib_audio_frame_t a;
+        NDIlib_metadata_frame_t m;
+        NDIlib_frame_type_e t;
+
+        av_log(avctx, AV_LOG_DEBUG, "NDIlib_recv_capture...\n");
+        t = NDIlib_recv_capture(ctx->recv, &v, &a, &m, 40);
+        av_log(avctx, AV_LOG_DEBUG, "NDIlib_recv_capture=%d\n", t);
+
+        if (t == NDIlib_frame_type_video) {
+            if (!ctx->video_st)
+                ret = ndi_create_video_stream(avctx, &v);
+            if (!ret)
+                ret = ndi_set_video_packet(avctx, &v, pkt);
+            NDIlib_recv_free_video(ctx->recv, &v);
+            break;
+        }
+        else if (t == NDIlib_frame_type_audio) {
+            if (!ctx->audio_st)
+                ret = ndi_create_audio_stream(avctx, &a);
+            if (!ret)
+                ret = ndi_set_audio_packet(avctx, &a, pkt);
+            NDIlib_recv_free_audio(ctx->recv, &a);
+            break;
+        }
+        else if (t == NDIlib_frame_type_metadata)
+            NDIlib_recv_free_metadata(ctx->recv, &m);
+        else if (t == NDIlib_frame_type_error){
+            av_log(avctx, AV_LOG_ERROR, "NDIlib_recv_capture failed with error\n");
+            ret = AVERROR(EIO);
+        }
+    };
+
+    return ret;
+}
+
+static int ndi_read_close(AVFormatContext *avctx)
+{
+    struct NDIContext *ctx = (struct NDIContext *)avctx->priv_data;
+
+    if (ctx->recv)
+        NDIlib_recv_destroy(ctx->recv);
+
+    if (ctx->ndi_find)
+        NDIlib_find_destroy(ctx->ndi_find);
+
+    return 0;
+}
+
+#define OFFSET(x) offsetof(struct NDIContext, x)
+#define DEC AV_OPT_FLAG_DECODING_PARAM
+
+static const AVOption options[] = {
+    { "find_sources", "Find available sources"  , OFFSET(find_sources), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, DEC },
+    { "wait_sources", "Time to wait until the number of online sources have changed"  , OFFSET(wait_sources), AV_OPT_TYPE_DURATION, { .i64 = 1000000 }, 100000, 20000000, DEC },
+    { "allow_video_fields", "When this flag is FALSE, all video that you receive will be progressive"  , OFFSET(allow_video_fields), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, DEC },
+    { NULL },
+};
+
+static const AVClass libndi_newtek_demuxer_class = {
+    .class_name = "NDI demuxer",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
+};
+
+AVInputFormat ff_libndi_newtek_demuxer = {
+    .name           = "libndi_newtek",
+    .long_name      = NULL_IF_CONFIG_SMALL("Network Device Interface (NDI) input using NewTek library"),
+    .flags          = AVFMT_NOFILE,
+    .priv_class     = &libndi_newtek_demuxer_class,
+    .priv_data_size = sizeof(struct NDIContext),
+    .read_header   = ndi_read_header,
+    .read_packet   = ndi_read_packet,
+    .read_close    = ndi_read_close,
+};
diff --git a/mythtv/external/FFmpeg/libavdevice/libndi_newtek_enc.c b/mythtv/external/FFmpeg/libavdevice/libndi_newtek_enc.c
new file mode 100644
index 00000000000..6ca6f41b734
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavdevice/libndi_newtek_enc.c
@@ -0,0 +1,299 @@
+/*
+ * NewTek NDI output
+ * Copyright (c) 2017 Maksym Veremeyenko
+ *
+ * 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 "libavformat/avformat.h"
+#include "libavformat/internal.h"
+#include "libavutil/opt.h"
+#include "libavutil/imgutils.h"
+
+#include "libndi_newtek_common.h"
+
+struct NDIContext {
+    const AVClass *cclass;
+
+    /* Options */
+    int reference_level;
+    int clock_video, clock_audio;
+
+    NDIlib_video_frame_t *video;
+    NDIlib_audio_frame_interleaved_16s_t *audio;
+    NDIlib_send_instance_t ndi_send;
+    AVFrame *last_avframe;
+};
+
+static int ndi_write_trailer(AVFormatContext *avctx)
+{
+    struct NDIContext *ctx = avctx->priv_data;
+
+    if (ctx->ndi_send) {
+        NDIlib_send_destroy(ctx->ndi_send);
+        av_frame_free(&ctx->last_avframe);
+    }
+
+    av_freep(&ctx->video);
+    av_freep(&ctx->audio);
+
+    return 0;
+}
+
+static int ndi_write_video_packet(AVFormatContext *avctx, AVStream *st, AVPacket *pkt)
+{
+    struct NDIContext *ctx = avctx->priv_data;
+    AVFrame *avframe, *tmp = (AVFrame *)pkt->data;
+
+    if (tmp->format != AV_PIX_FMT_UYVY422 && tmp->format != AV_PIX_FMT_BGRA &&
+        tmp->format != AV_PIX_FMT_BGR0 && tmp->format != AV_PIX_FMT_RGBA &&
+        tmp->format != AV_PIX_FMT_RGB0) {
+        av_log(avctx, AV_LOG_ERROR, "Got a frame with invalid pixel format.\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (tmp->linesize[0] < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Got a frame with negative linesize.\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (tmp->width  != ctx->video->xres ||
+        tmp->height != ctx->video->yres) {
+        av_log(avctx, AV_LOG_ERROR, "Got a frame with invalid dimension.\n");
+        av_log(avctx, AV_LOG_ERROR, "tmp->width=%d, tmp->height=%d, ctx->video->xres=%d, ctx->video->yres=%d\n",
+            tmp->width, tmp->height, ctx->video->xres, ctx->video->yres);
+        return AVERROR(EINVAL);
+    }
+
+    avframe = av_frame_clone(tmp);
+    if (!avframe)
+        return AVERROR(ENOMEM);
+
+    ctx->video->timecode = av_rescale_q(pkt->pts, st->time_base, NDI_TIME_BASE_Q);
+
+    ctx->video->line_stride_in_bytes = avframe->linesize[0];
+    ctx->video->p_data = (void *)(avframe->data[0]);
+
+    av_log(avctx, AV_LOG_DEBUG, "%s: pkt->pts=%"PRId64", timecode=%"PRId64", st->time_base=%d/%d\n",
+        __func__, pkt->pts, ctx->video->timecode, st->time_base.num, st->time_base.den);
+
+    /* asynchronous for one frame, but will block if a second frame
+        is given before the first one has been sent */
+    NDIlib_send_send_video_async(ctx->ndi_send, ctx->video);
+
+    av_frame_free(&ctx->last_avframe);
+    ctx->last_avframe = avframe;
+
+    return 0;
+}
+
+static int ndi_write_audio_packet(AVFormatContext *avctx, AVStream *st, AVPacket *pkt)
+{
+    struct NDIContext *ctx = avctx->priv_data;
+
+    ctx->audio->p_data = (short *)pkt->data;
+    ctx->audio->timecode = av_rescale_q(pkt->pts, st->time_base, NDI_TIME_BASE_Q);
+    ctx->audio->no_samples = pkt->size / (ctx->audio->no_channels << 1);
+
+    av_log(avctx, AV_LOG_DEBUG, "%s: pkt->pts=%"PRId64", timecode=%"PRId64", st->time_base=%d/%d\n",
+        __func__, pkt->pts, ctx->audio->timecode, st->time_base.num, st->time_base.den);
+
+    NDIlib_util_send_send_audio_interleaved_16s(ctx->ndi_send, ctx->audio);
+
+    return 0;
+}
+
+static int ndi_write_packet(AVFormatContext *avctx, AVPacket *pkt)
+{
+    AVStream *st = avctx->streams[pkt->stream_index];
+
+    if      (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
+        return ndi_write_video_packet(avctx, st, pkt);
+    else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
+        return ndi_write_audio_packet(avctx, st, pkt);
+
+    return AVERROR_BUG;
+}
+
+static int ndi_setup_audio(AVFormatContext *avctx, AVStream *st)
+{
+    struct NDIContext *ctx = avctx->priv_data;
+    AVCodecParameters *c = st->codecpar;
+
+    if (ctx->audio) {
+        av_log(avctx, AV_LOG_ERROR, "Only one audio stream is supported!\n");
+        return AVERROR(EINVAL);
+    }
+
+    ctx->audio = av_mallocz(sizeof(NDIlib_audio_frame_interleaved_16s_t));
+    if (!ctx->audio)
+        return AVERROR(ENOMEM);
+
+    ctx->audio->sample_rate = c->sample_rate;
+    ctx->audio->no_channels = c->channels;
+    ctx->audio->reference_level = ctx->reference_level;
+
+    avpriv_set_pts_info(st, 64, 1, NDI_TIME_BASE);
+
+    return 0;
+}
+
+static int ndi_setup_video(AVFormatContext *avctx, AVStream *st)
+{
+    struct NDIContext *ctx = avctx->priv_data;
+    AVCodecParameters *c = st->codecpar;
+
+    if (ctx->video) {
+        av_log(avctx, AV_LOG_ERROR, "Only one video stream is supported!\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (c->codec_id != AV_CODEC_ID_WRAPPED_AVFRAME) {
+        av_log(avctx, AV_LOG_ERROR, "Unsupported codec format!"
+               " Only AV_CODEC_ID_WRAPPED_AVFRAME is supported (-vcodec wrapped_avframe).\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (c->format != AV_PIX_FMT_UYVY422 && c->format != AV_PIX_FMT_BGRA &&
+        c->format != AV_PIX_FMT_BGR0 && c->format != AV_PIX_FMT_RGBA &&
+        c->format != AV_PIX_FMT_RGB0) {
+        av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format!"
+               " Only AV_PIX_FMT_UYVY422, AV_PIX_FMT_BGRA, AV_PIX_FMT_BGR0,"
+               " AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB0 is supported.\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (c->field_order == AV_FIELD_BB || c->field_order == AV_FIELD_BT) {
+        av_log(avctx, AV_LOG_ERROR, "Lower field-first disallowed");
+        return AVERROR(EINVAL);
+    }
+
+    ctx->video = av_mallocz(sizeof(NDIlib_video_frame_t));
+    if (!ctx->video)
+        return AVERROR(ENOMEM);
+
+    switch(c->format) {
+        case AV_PIX_FMT_UYVY422:
+            ctx->video->FourCC = NDIlib_FourCC_type_UYVY;
+            break;
+        case AV_PIX_FMT_BGRA:
+            ctx->video->FourCC = NDIlib_FourCC_type_BGRA;
+            break;
+        case AV_PIX_FMT_BGR0:
+            ctx->video->FourCC = NDIlib_FourCC_type_BGRX;
+            break;
+        case AV_PIX_FMT_RGBA:
+            ctx->video->FourCC = NDIlib_FourCC_type_RGBA;
+            break;
+        case AV_PIX_FMT_RGB0:
+            ctx->video->FourCC = NDIlib_FourCC_type_RGBX;
+            break;
+    }
+
+    ctx->video->xres = c->width;
+    ctx->video->yres = c->height;
+    ctx->video->frame_rate_N = st->avg_frame_rate.num;
+    ctx->video->frame_rate_D = st->avg_frame_rate.den;
+    ctx->video->frame_format_type = c->field_order == AV_FIELD_PROGRESSIVE
+        ? NDIlib_frame_format_type_progressive
+        : NDIlib_frame_format_type_interleaved;
+
+    if (st->sample_aspect_ratio.num) {
+        AVRational display_aspect_ratio;
+        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
+                  st->codecpar->width  * (int64_t)st->sample_aspect_ratio.num,
+                  st->codecpar->height * (int64_t)st->sample_aspect_ratio.den,
+                  1024 * 1024);
+        ctx->video->picture_aspect_ratio = av_q2d(display_aspect_ratio);
+    }
+    else
+        ctx->video->picture_aspect_ratio = (double)st->codecpar->width/st->codecpar->height;
+
+    avpriv_set_pts_info(st, 64, 1, NDI_TIME_BASE);
+
+    return 0;
+}
+
+static int ndi_write_header(AVFormatContext *avctx)
+{
+    int ret = 0;
+    unsigned int n;
+    struct NDIContext *ctx = avctx->priv_data;
+    const NDIlib_send_create_t ndi_send_desc = { .p_ndi_name = avctx->filename,
+        .p_groups = NULL, .clock_video = ctx->clock_video, .clock_audio = ctx->clock_audio };
+
+    if (!NDIlib_initialize()) {
+        av_log(avctx, AV_LOG_ERROR, "NDIlib_initialize failed.\n");
+        return AVERROR_EXTERNAL;
+    }
+
+    /* check if streams compatible */
+    for (n = 0; n < avctx->nb_streams; n++) {
+        AVStream *st = avctx->streams[n];
+        AVCodecParameters *c = st->codecpar;
+        if        (c->codec_type == AVMEDIA_TYPE_AUDIO) {
+            if ((ret = ndi_setup_audio(avctx, st)))
+                goto error;
+        } else if (c->codec_type == AVMEDIA_TYPE_VIDEO) {
+            if ((ret = ndi_setup_video(avctx, st)))
+                goto error;
+        } else {
+            av_log(avctx, AV_LOG_ERROR, "Unsupported stream type.\n");
+            ret = AVERROR(EINVAL);
+            goto error;
+        }
+    }
+
+    ctx->ndi_send = NDIlib_send_create(&ndi_send_desc);
+    if (!ctx->ndi_send) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create NDI output %s\n", avctx->filename);
+        ret = AVERROR_EXTERNAL;
+    }
+
+error:
+    return ret;
+}
+
+#define OFFSET(x) offsetof(struct NDIContext, x)
+static const AVOption options[] = {
+    { "reference_level", "The audio reference level in dB"  , OFFSET(reference_level), AV_OPT_TYPE_INT, { .i64 = 0 }, -20, 20, AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM},
+    { "clock_video", "These specify whether video 'clock' themselves"  , OFFSET(clock_video), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM },
+    { "clock_audio", "These specify whether audio 'clock' themselves"  , OFFSET(clock_audio), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
+    { NULL },
+};
+
+static const AVClass libndi_newtek_muxer_class = {
+    .class_name = "NDI muxer",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_OUTPUT,
+};
+
+AVOutputFormat ff_libndi_newtek_muxer = {
+    .name           = "libndi_newtek",
+    .long_name      = NULL_IF_CONFIG_SMALL("Network Device Interface (NDI) output using NewTek library"),
+    .audio_codec    = AV_CODEC_ID_PCM_S16LE,
+    .video_codec    = AV_CODEC_ID_WRAPPED_AVFRAME,
+    .subtitle_codec = AV_CODEC_ID_NONE,
+    .flags          = AVFMT_NOFILE,
+    .priv_class     = &libndi_newtek_muxer_class,
+    .priv_data_size = sizeof(struct NDIContext),
+    .write_header   = ndi_write_header,
+    .write_packet   = ndi_write_packet,
+    .write_trailer  = ndi_write_trailer,
+};
diff --git a/mythtv/external/FFmpeg/libavdevice/opengl_enc.c b/mythtv/external/FFmpeg/libavdevice/opengl_enc.c
index 02af12cb60c..9402fdee96e 100644
--- a/mythtv/external/FFmpeg/libavdevice/opengl_enc.c
+++ b/mythtv/external/FFmpeg/libavdevice/opengl_enc.c
@@ -49,7 +49,7 @@
 #include <GL/glx.h>
 #endif
 
-#if HAVE_SDL2
+#if CONFIG_SDL2
 #include <SDL.h>
 #endif
 
@@ -68,7 +68,7 @@
 #define APIENTRY
 #endif
 
-/* FF_GL_RED_COMPONENT is used for plannar pixel types.
+/* FF_GL_RED_COMPONENT is used for planar pixel types.
  * Only red component is sampled in shaders.
  * On some platforms GL_RED is not available and GL_LUMINANCE have to be used,
  * but since OpenGL 3.0 GL_LUMINANCE is deprecated.
@@ -177,7 +177,7 @@ static const GLushort g_index[6] =
 typedef struct OpenGLContext {
     AVClass *class;                    ///< class for private options
 
-#if HAVE_SDL2
+#if CONFIG_SDL2
     SDL_Window *window;
     SDL_GLContext glcontext;
 #endif
@@ -264,6 +264,7 @@ static const struct OpenGLFormatDesc {
     { AV_PIX_FMT_RGB8,       &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET,  GL_RGB, FF_GL_UNSIGNED_BYTE_3_3_2 },
     { AV_PIX_FMT_BGR8,       &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET,  GL_RGB, FF_GL_UNSIGNED_BYTE_2_3_3_REV },
     { AV_PIX_FMT_RGB48,      &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET,  GL_RGB, GL_UNSIGNED_SHORT },
+    { AV_PIX_FMT_BGR48,      &FF_OPENGL_FRAGMENT_SHADER_RGB_PACKET,  GL_RGB, GL_UNSIGNED_SHORT },
     { AV_PIX_FMT_ARGB,       &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
     { AV_PIX_FMT_RGBA,       &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
     { AV_PIX_FMT_ABGR,       &FF_OPENGL_FRAGMENT_SHADER_RGBA_PACKET, GL_RGBA, GL_UNSIGNED_BYTE },
@@ -345,7 +346,7 @@ static int opengl_control_message(AVFormatContext *h, int type, void *data, size
     return AVERROR(ENOSYS);
 }
 
-#if HAVE_SDL2
+#if CONFIG_SDL2
 static int opengl_sdl_process_events(AVFormatContext *h)
 {
     OpenGLContext *opengl = h->priv_data;
@@ -450,14 +451,14 @@ static int av_cold opengl_sdl_load_procedures(OpenGLContext *opengl)
 
 #undef LOAD_OPENGL_FUN
 }
-#endif /* HAVE_SDL2 */
+#endif /* CONFIG_SDL2 */
 
 #if defined(__APPLE__)
 static int av_cold opengl_load_procedures(OpenGLContext *opengl)
 {
     FFOpenGLFunctions *procs = &opengl->glprocs;
 
-#if HAVE_SDL2
+#if CONFIG_SDL2
     if (!opengl->no_window)
         return opengl_sdl_load_procedures(opengl);
 #endif
@@ -509,7 +510,7 @@ static int av_cold opengl_load_procedures(OpenGLContext *opengl)
         return AVERROR(ENOSYS); \
     }
 
-#if HAVE_SDL2
+#if CONFIG_SDL2
     if (!opengl->no_window)
         return opengl_sdl_load_procedures(opengl);
 #endif
@@ -935,7 +936,7 @@ static int opengl_create_window(AVFormatContext *h)
     int ret;
 
     if (!opengl->no_window) {
-#if HAVE_SDL2
+#if CONFIG_SDL2
         if ((ret = opengl_sdl_create_window(h)) < 0) {
             av_log(opengl, AV_LOG_ERROR, "Cannot create default SDL window.\n");
             return ret;
@@ -967,7 +968,7 @@ static int opengl_release_window(AVFormatContext *h)
     int ret;
     OpenGLContext *opengl = h->priv_data;
     if (!opengl->no_window) {
-#if HAVE_SDL2
+#if CONFIG_SDL2
         SDL_GL_DeleteContext(opengl->glcontext);
         SDL_DestroyWindow(opengl->window);
         SDL_Quit();
@@ -1103,7 +1104,7 @@ static av_cold int opengl_write_header(AVFormatContext *h)
 
     glClear(GL_COLOR_BUFFER_BIT);
 
-#if HAVE_SDL2
+#if CONFIG_SDL2
     if (!opengl->no_window)
         SDL_GL_SwapWindow(opengl->window);
 #endif
@@ -1198,7 +1199,7 @@ static int opengl_draw(AVFormatContext *h, void *input, int repaint, int is_pkt)
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     int ret;
 
-#if HAVE_SDL2
+#if CONFIG_SDL2
     if (!opengl->no_window && (ret = opengl_sdl_process_events(h)) < 0)
         goto fail;
 #endif
@@ -1239,7 +1240,7 @@ static int opengl_draw(AVFormatContext *h, void *input, int repaint, int is_pkt)
     ret = AVERROR_EXTERNAL;
     OPENGL_ERROR_CHECK(opengl);
 
-#if HAVE_SDL2
+#if CONFIG_SDL2
     if (!opengl->no_window)
         SDL_GL_SwapWindow(opengl->window);
 #endif
diff --git a/mythtv/external/FFmpeg/libavdevice/pulse_audio_enc.c b/mythtv/external/FFmpeg/libavdevice/pulse_audio_enc.c
index 6fb634ee2b9..0efcf0fe7e5 100644
--- a/mythtv/external/FFmpeg/libavdevice/pulse_audio_enc.c
+++ b/mythtv/external/FFmpeg/libavdevice/pulse_audio_enc.c
@@ -681,9 +681,9 @@ static int pulse_write_frame(AVFormatContext *h, int stream_index,
                AVERROR(EINVAL) : 0;
 
     pkt.data     = (*frame)->data[0];
-    pkt.size     = (*frame)->nb_samples * av_get_bytes_per_sample((*frame)->format) * av_frame_get_channels(*frame);
+    pkt.size     = (*frame)->nb_samples * av_get_bytes_per_sample((*frame)->format) * (*frame)->channels;
     pkt.dts      = (*frame)->pkt_dts;
-    pkt.duration = av_frame_get_pkt_duration(*frame);
+    pkt.duration = (*frame)->pkt_duration;
     return pulse_write_packet(h, &pkt);
 }
 
diff --git a/mythtv/external/FFmpeg/libavdevice/qtkit.m b/mythtv/external/FFmpeg/libavdevice/qtkit.m
deleted file mode 100644
index 22a94ca561c..00000000000
--- a/mythtv/external/FFmpeg/libavdevice/qtkit.m
+++ /dev/null
@@ -1,362 +0,0 @@
-/*
- * QTKit input device
- * Copyright (c) 2013 Vadim Kalinsky <vadim@kalinsky.ru>
- *
- * 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
- * QTKit input device
- * @author Vadim Kalinsky <vadim@kalinsky.ru>
- */
-
-#if defined(__clang__)
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-#import <QTKit/QTKit.h>
-#include <pthread.h>
-
-#include "libavutil/pixdesc.h"
-#include "libavutil/opt.h"
-#include "libavformat/internal.h"
-#include "libavutil/internal.h"
-#include "libavutil/time.h"
-#include "avdevice.h"
-
-#define QTKIT_TIMEBASE 100
-
-static const AVRational kQTKitTimeBase_q = {
-    .num = 1,
-    .den = QTKIT_TIMEBASE
-};
-
-typedef struct
-{
-    AVClass*        class;
-
-    float           frame_rate;
-    int             frames_captured;
-    int64_t         first_pts;
-    pthread_mutex_t frame_lock;
-    pthread_cond_t  frame_wait_cond;
-    id              qt_delegate;
-
-    int             list_devices;
-    int             video_device_index;
-
-    QTCaptureSession*                 capture_session;
-    QTCaptureDecompressedVideoOutput* video_output;
-    CVImageBufferRef                  current_frame;
-} CaptureContext;
-
-static void lock_frames(CaptureContext* ctx)
-{
-    pthread_mutex_lock(&ctx->frame_lock);
-}
-
-static void unlock_frames(CaptureContext* ctx)
-{
-    pthread_mutex_unlock(&ctx->frame_lock);
-}
-
-/** FrameReciever class - delegate for QTCaptureSession
- */
-@interface FFMPEG_FrameReceiver : NSObject
-{
-    CaptureContext* _context;
-}
-
-- (id)initWithContext:(CaptureContext*)context;
-
-- (void)captureOutput:(QTCaptureOutput *)captureOutput
-  didOutputVideoFrame:(CVImageBufferRef)videoFrame
-     withSampleBuffer:(QTSampleBuffer *)sampleBuffer
-       fromConnection:(QTCaptureConnection *)connection;
-
-@end
-
-@implementation FFMPEG_FrameReceiver
-
-- (id)initWithContext:(CaptureContext*)context
-{
-    if (self = [super init]) {
-        _context = context;
-    }
-    return self;
-}
-
-- (void)captureOutput:(QTCaptureOutput *)captureOutput
-  didOutputVideoFrame:(CVImageBufferRef)videoFrame
-     withSampleBuffer:(QTSampleBuffer *)sampleBuffer
-       fromConnection:(QTCaptureConnection *)connection
-{
-    lock_frames(_context);
-    if (_context->current_frame != nil) {
-        CVBufferRelease(_context->current_frame);
-    }
-
-    _context->current_frame = CVBufferRetain(videoFrame);
-
-    pthread_cond_signal(&_context->frame_wait_cond);
-
-    unlock_frames(_context);
-
-    ++_context->frames_captured;
-}
-
-@end
-
-static void destroy_context(CaptureContext* ctx)
-{
-    [ctx->capture_session stopRunning];
-
-    [ctx->capture_session release];
-    [ctx->video_output    release];
-    [ctx->qt_delegate     release];
-
-    ctx->capture_session = NULL;
-    ctx->video_output    = NULL;
-    ctx->qt_delegate     = NULL;
-
-    pthread_mutex_destroy(&ctx->frame_lock);
-    pthread_cond_destroy(&ctx->frame_wait_cond);
-
-    if (ctx->current_frame)
-        CVBufferRelease(ctx->current_frame);
-}
-
-static int qtkit_read_header(AVFormatContext *s)
-{
-    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
-
-    CaptureContext* ctx = (CaptureContext*)s->priv_data;
-
-    ctx->first_pts = av_gettime();
-
-    pthread_mutex_init(&ctx->frame_lock, NULL);
-    pthread_cond_init(&ctx->frame_wait_cond, NULL);
-
-    // List devices if requested
-    if (ctx->list_devices) {
-        av_log(ctx, AV_LOG_INFO, "QTKit video devices:\n");
-        NSArray *devices = [QTCaptureDevice inputDevicesWithMediaType:QTMediaTypeVideo];
-        for (QTCaptureDevice *device in devices) {
-            const char *name = [[device localizedDisplayName] UTF8String];
-            int index  = [devices indexOfObject:device];
-            av_log(ctx, AV_LOG_INFO, "[%d] %s\n", index, name);
-        }
-        goto fail;
-    }
-
-    // Find capture device
-    QTCaptureDevice *video_device = nil;
-
-    // check for device index given in filename
-    if (ctx->video_device_index == -1) {
-        sscanf(s->filename, "%d", &ctx->video_device_index);
-    }
-
-    if (ctx->video_device_index >= 0) {
-        NSArray *devices = [QTCaptureDevice inputDevicesWithMediaType:QTMediaTypeVideo];
-
-        if (ctx->video_device_index >= [devices count]) {
-            av_log(ctx, AV_LOG_ERROR, "Invalid device index\n");
-            goto fail;
-        }
-
-        video_device = [devices objectAtIndex:ctx->video_device_index];
-    } else if (strncmp(s->filename, "",        1) &&
-               strncmp(s->filename, "default", 7)) {
-        NSArray *devices = [QTCaptureDevice inputDevicesWithMediaType:QTMediaTypeVideo];
-
-        for (QTCaptureDevice *device in devices) {
-            if (!strncmp(s->filename, [[device localizedDisplayName] UTF8String], strlen(s->filename))) {
-                video_device = device;
-                break;
-            }
-        }
-        if (!video_device) {
-            av_log(ctx, AV_LOG_ERROR, "Video device not found\n");
-            goto fail;
-        }
-    } else {
-        video_device = [QTCaptureDevice defaultInputDeviceWithMediaType:QTMediaTypeMuxed];
-    }
-
-    BOOL success = [video_device open:nil];
-
-    // Video capture device not found, looking for QTMediaTypeVideo
-    if (!success) {
-        video_device = [QTCaptureDevice defaultInputDeviceWithMediaType:QTMediaTypeVideo];
-        success      = [video_device open:nil];
-
-        if (!success) {
-            av_log(s, AV_LOG_ERROR, "No QT capture device found\n");
-            goto fail;
-        }
-    }
-
-    NSString* dev_display_name = [video_device localizedDisplayName];
-    av_log (s, AV_LOG_DEBUG, "'%s' opened\n", [dev_display_name UTF8String]);
-
-    // Initialize capture session
-    ctx->capture_session = [[QTCaptureSession alloc] init];
-
-    QTCaptureDeviceInput* capture_dev_input = [[[QTCaptureDeviceInput alloc] initWithDevice:video_device] autorelease];
-    success = [ctx->capture_session addInput:capture_dev_input error:nil];
-
-    if (!success) {
-        av_log (s, AV_LOG_ERROR, "Failed to add QT capture device to session\n");
-        goto fail;
-    }
-
-    // Attaching output
-    // FIXME: Allow for a user defined pixel format
-    ctx->video_output = [[QTCaptureDecompressedVideoOutput alloc] init];
-
-    NSDictionary *captureDictionary = [NSDictionary dictionaryWithObject:
-                                       [NSNumber numberWithUnsignedInt:kCVPixelFormatType_24RGB]
-                                       forKey:(id)kCVPixelBufferPixelFormatTypeKey];
-
-    [ctx->video_output setPixelBufferAttributes:captureDictionary];
-
-    ctx->qt_delegate = [[FFMPEG_FrameReceiver alloc] initWithContext:ctx];
-
-    [ctx->video_output setDelegate:ctx->qt_delegate];
-    [ctx->video_output setAutomaticallyDropsLateVideoFrames:YES];
-    [ctx->video_output setMinimumVideoFrameInterval:1.0/ctx->frame_rate];
-
-    success = [ctx->capture_session addOutput:ctx->video_output error:nil];
-
-    if (!success) {
-        av_log (s, AV_LOG_ERROR, "can't add video output to capture session\n");
-        goto fail;
-    }
-
-    [ctx->capture_session startRunning];
-
-    // Take stream info from the first frame.
-    while (ctx->frames_captured < 1) {
-        CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, YES);
-    }
-
-    lock_frames(ctx);
-
-    AVStream* stream = avformat_new_stream(s, NULL);
-
-    if (!stream) {
-        goto fail;
-    }
-
-    avpriv_set_pts_info(stream, 64, 1, QTKIT_TIMEBASE);
-
-    stream->codec->codec_id   = AV_CODEC_ID_RAWVIDEO;
-    stream->codec->codec_type = AVMEDIA_TYPE_VIDEO;
-    stream->codec->width      = (int)CVPixelBufferGetWidth (ctx->current_frame);
-    stream->codec->height     = (int)CVPixelBufferGetHeight(ctx->current_frame);
-    stream->codec->pix_fmt    = AV_PIX_FMT_RGB24;
-
-    CVBufferRelease(ctx->current_frame);
-    ctx->current_frame = nil;
-
-    unlock_frames(ctx);
-
-    [pool release];
-
-    return 0;
-
-fail:
-    [pool release];
-
-    destroy_context(ctx);
-
-    return AVERROR(EIO);
-}
-
-static int qtkit_read_packet(AVFormatContext *s, AVPacket *pkt)
-{
-    CaptureContext* ctx = (CaptureContext*)s->priv_data;
-
-    do {
-        lock_frames(ctx);
-
-        if (ctx->current_frame != nil) {
-            if (av_new_packet(pkt, (int)CVPixelBufferGetDataSize(ctx->current_frame)) < 0) {
-                return AVERROR(EIO);
-            }
-
-            pkt->pts = pkt->dts = av_rescale_q(av_gettime() - ctx->first_pts, AV_TIME_BASE_Q, kQTKitTimeBase_q);
-            pkt->stream_index = 0;
-            pkt->flags |= AV_PKT_FLAG_KEY;
-
-            CVPixelBufferLockBaseAddress(ctx->current_frame, 0);
-
-            void* data = CVPixelBufferGetBaseAddress(ctx->current_frame);
-            memcpy(pkt->data, data, pkt->size);
-
-            CVPixelBufferUnlockBaseAddress(ctx->current_frame, 0);
-            CVBufferRelease(ctx->current_frame);
-            ctx->current_frame = nil;
-        } else {
-            pkt->data = NULL;
-            pthread_cond_wait(&ctx->frame_wait_cond, &ctx->frame_lock);
-        }
-
-        unlock_frames(ctx);
-    } while (!pkt->data);
-
-    return 0;
-}
-
-static int qtkit_close(AVFormatContext *s)
-{
-    CaptureContext* ctx = (CaptureContext*)s->priv_data;
-
-    destroy_context(ctx);
-
-    return 0;
-}
-
-static const AVOption options[] = {
-    { "frame_rate", "set frame rate", offsetof(CaptureContext, frame_rate), AV_OPT_TYPE_FLOAT, { .dbl = 30.0 }, 0.1, 30.0, AV_OPT_TYPE_VIDEO_RATE, NULL },
-    { "list_devices", "list available devices", offsetof(CaptureContext, list_devices), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM, "list_devices" },
-    { "true", "", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "list_devices" },
-    { "false", "", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "list_devices" },
-    { "video_device_index", "select video device by index for devices with same name (starts at 0)", offsetof(CaptureContext, video_device_index), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
-    { NULL },
-};
-
-static const AVClass qtkit_class = {
-    .class_name = "QTKit input device",
-    .item_name  = av_default_item_name,
-    .option     = options,
-    .version    = LIBAVUTIL_VERSION_INT,
-    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
-};
-
-AVInputFormat ff_qtkit_demuxer = {
-    .name           = "qtkit",
-    .long_name      = NULL_IF_CONFIG_SMALL("QTKit input device"),
-    .priv_data_size = sizeof(CaptureContext),
-    .read_header    = qtkit_read_header,
-    .read_packet    = qtkit_read_packet,
-    .read_close     = qtkit_close,
-    .flags          = AVFMT_NOFILE,
-    .priv_class     = &qtkit_class,
-};
diff --git a/mythtv/external/FFmpeg/libavdevice/reverse.c b/mythtv/external/FFmpeg/libavdevice/reverse.c
new file mode 100644
index 00000000000..440badaf34d
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavdevice/reverse.c
@@ -0,0 +1 @@
+#include "libavutil/reverse.c"
diff --git a/mythtv/external/FFmpeg/libavdevice/tests/timefilter.c b/mythtv/external/FFmpeg/libavdevice/tests/timefilter.c
index 7c1ed0a4b6e..9aee91c6c7e 100644
--- a/mythtv/external/FFmpeg/libavdevice/tests/timefilter.c
+++ b/mythtv/external/FFmpeg/libavdevice/tests/timefilter.c
@@ -77,20 +77,7 @@ int main(void)
                     }
                 }
             } while (better);
-#if 0
-            double lastfil = 9;
-            TimeFilter *tf = ff_timefilter_new(1, bestpar0, bestpar1);
-            for (i = 0; i < SAMPLES; i++) {
-                double filtered;
-                filtered = ff_timefilter_update(tf, samples[i], 1);
-                printf("%f %f %f %f\n", i - samples[i] + 10, filtered - samples[i],
-                       samples[FFMAX(i, 1)] - samples[FFMAX(i - 1, 0)], filtered - lastfil);
-                lastfil = filtered;
-            }
-            ff_timefilter_destroy(tf);
-#else
             printf(" [%12f %11f %9f]", bestpar0, bestpar1, best_error);
-#endif
         }
         printf("\n");
     }
diff --git a/mythtv/external/FFmpeg/libavdevice/v4l.c b/mythtv/external/FFmpeg/libavdevice/v4l.c
deleted file mode 100644
index 81653e02fb5..00000000000
--- a/mythtv/external/FFmpeg/libavdevice/v4l.c
+++ /dev/null
@@ -1,364 +0,0 @@
-/*
- * Linux video grab interface
- * Copyright (c) 2000,2001 Fabrice Bellard
- *
- * 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 "avdevice.h"
-
-#undef __STRICT_ANSI__ //workaround due to broken kernel headers
-#include "config.h"
-#include "libavutil/rational.h"
-#include "libavutil/imgutils.h"
-#include "libavutil/internal.h"
-#include "libavutil/log.h"
-#include "libavutil/opt.h"
-#include "libavformat/internal.h"
-#include "libavcodec/dsputil.h"
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-#define _LINUX_TIME_H 1
-#include <linux/videodev.h>
-#include <time.h>
-
-typedef struct {
-    AVClass *class;
-    int fd;
-    int frame_format; /* see VIDEO_PALETTE_xxx */
-    int use_mmap;
-    AVRational time_base;
-    int64_t time_frame;
-    int frame_size;
-    struct video_capability video_cap;
-    struct video_audio audio_saved;
-    struct video_window video_win;
-    uint8_t *video_buf;
-    struct video_mbuf gb_buffers;
-    struct video_mmap gb_buf;
-    int gb_frame;
-    int standard;
-} VideoData;
-
-static const struct {
-    int palette;
-    int depth;
-    enum AVPixelFormat pix_fmt;
-} video_formats [] = {
-    {.palette = VIDEO_PALETTE_YUV420P, .depth = 12, .pix_fmt = AV_PIX_FMT_YUV420P },
-    {.palette = VIDEO_PALETTE_YUV422,  .depth = 16, .pix_fmt = AV_PIX_FMT_YUYV422 },
-    {.palette = VIDEO_PALETTE_UYVY,    .depth = 16, .pix_fmt = AV_PIX_FMT_UYVY422 },
-    {.palette = VIDEO_PALETTE_YUYV,    .depth = 16, .pix_fmt = AV_PIX_FMT_YUYV422 },
-    /* NOTE: v4l uses BGR24, not RGB24 */
-    {.palette = VIDEO_PALETTE_RGB24,   .depth = 24, .pix_fmt = AV_PIX_FMT_BGR24   },
-    {.palette = VIDEO_PALETTE_RGB565,  .depth = 16, .pix_fmt = AV_PIX_FMT_BGR565  },
-    {.palette = VIDEO_PALETTE_GREY,    .depth = 8,  .pix_fmt = AV_PIX_FMT_GRAY8   },
-};
-
-
-static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
-{
-    VideoData *s = s1->priv_data;
-    AVStream *st;
-    int video_fd;
-    int desired_palette, desired_depth;
-    struct video_tuner tuner;
-    struct video_audio audio;
-    struct video_picture pict;
-    int j;
-    int vformat_num = FF_ARRAY_ELEMS(video_formats);
-
-    av_log(s1, AV_LOG_WARNING, "V4L input device is deprecated and will be removed in the next release.");
-
-    if (ap->time_base.den <= 0) {
-        av_log(s1, AV_LOG_ERROR, "Wrong time base (%d)\n", ap->time_base.den);
-        return -1;
-    }
-    s->time_base = ap->time_base;
-
-    s->video_win.width = ap->width;
-    s->video_win.height = ap->height;
-
-    st = avformat_new_stream(s1, NULL);
-    if (!st)
-        return AVERROR(ENOMEM);
-    avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
-
-    video_fd = open(s1->filename, O_RDWR);
-    if (video_fd < 0) {
-        av_log(s1, AV_LOG_ERROR, "%s: %s\n", s1->filename, strerror(errno));
-        goto fail;
-    }
-
-    if (ioctl(video_fd, VIDIOCGCAP, &s->video_cap) < 0) {
-        av_log(s1, AV_LOG_ERROR, "VIDIOCGCAP: %s\n", strerror(errno));
-        goto fail;
-    }
-
-    if (!(s->video_cap.type & VID_TYPE_CAPTURE)) {
-        av_log(s1, AV_LOG_ERROR, "Fatal: grab device does not handle capture\n");
-        goto fail;
-    }
-
-    /* no values set, autodetect them */
-    if (s->video_win.width <= 0 || s->video_win.height <= 0) {
-        if (ioctl(video_fd, VIDIOCGWIN, &s->video_win, sizeof(s->video_win)) < 0) {
-            av_log(s1, AV_LOG_ERROR, "VIDIOCGWIN: %s\n", strerror(errno));
-            goto fail;
-        }
-    }
-
-    if(av_image_check_size(s->video_win.width, s->video_win.height, 0, s1) < 0)
-        return -1;
-
-    desired_palette = -1;
-    desired_depth = -1;
-    for (j = 0; j < vformat_num; j++) {
-        if (ap->pix_fmt == video_formats[j].pix_fmt) {
-            desired_palette = video_formats[j].palette;
-            desired_depth = video_formats[j].depth;
-            break;
-        }
-    }
-
-    /* set tv standard */
-    if (!ioctl(video_fd, VIDIOCGTUNER, &tuner)) {
-        tuner.mode = s->standard;
-        ioctl(video_fd, VIDIOCSTUNER, &tuner);
-    }
-
-    /* unmute audio */
-    audio.audio = 0;
-    ioctl(video_fd, VIDIOCGAUDIO, &audio);
-    memcpy(&s->audio_saved, &audio, sizeof(audio));
-    audio.flags &= ~VIDEO_AUDIO_MUTE;
-    ioctl(video_fd, VIDIOCSAUDIO, &audio);
-
-    ioctl(video_fd, VIDIOCGPICT, &pict);
-    ff_dlog(s1, "v4l: colour=%d hue=%d brightness=%d constrast=%d whiteness=%d\n",
-            pict.colour, pict.hue, pict.brightness, pict.contrast, pict.whiteness);
-    /* try to choose a suitable video format */
-    pict.palette = desired_palette;
-    pict.depth= desired_depth;
-    if (desired_palette == -1 || ioctl(video_fd, VIDIOCSPICT, &pict) < 0) {
-        for (j = 0; j < vformat_num; j++) {
-            pict.palette = video_formats[j].palette;
-            pict.depth = video_formats[j].depth;
-            if (-1 != ioctl(video_fd, VIDIOCSPICT, &pict))
-                break;
-        }
-        if (j >= vformat_num)
-            goto fail1;
-    }
-
-    if (ioctl(video_fd, VIDIOCGMBUF, &s->gb_buffers) < 0) {
-        /* try to use read based access */
-        int val;
-
-        s->video_win.x = 0;
-        s->video_win.y = 0;
-        s->video_win.chromakey = -1;
-        s->video_win.flags = 0;
-
-        if (ioctl(video_fd, VIDIOCSWIN, s->video_win) < 0) {
-            av_log(s1, AV_LOG_ERROR, "VIDIOCSWIN: %s\n", strerror(errno));
-            goto fail;
-        }
-
-        s->frame_format = pict.palette;
-
-        val = 1;
-        if (ioctl(video_fd, VIDIOCCAPTURE, &val) < 0) {
-            av_log(s1, AV_LOG_ERROR, "VIDIOCCAPTURE: %s\n", strerror(errno));
-            goto fail;
-        }
-
-        s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;
-        s->use_mmap = 0;
-    } else {
-        s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_SHARED, video_fd, 0);
-        if ((unsigned char*)-1 == s->video_buf) {
-            s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_PRIVATE, video_fd, 0);
-            if ((unsigned char*)-1 == s->video_buf) {
-                av_log(s1, AV_LOG_ERROR, "mmap: %s\n", strerror(errno));
-                goto fail;
-            }
-        }
-        s->gb_frame = 0;
-        s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;
-
-        /* start to grab the first frame */
-        s->gb_buf.frame = s->gb_frame % s->gb_buffers.frames;
-        s->gb_buf.height = s->video_win.height;
-        s->gb_buf.width = s->video_win.width;
-        s->gb_buf.format = pict.palette;
-
-        if (ioctl(video_fd, VIDIOCMCAPTURE, &s->gb_buf) < 0) {
-            if (errno != EAGAIN) {
-            fail1:
-                av_log(s1, AV_LOG_ERROR, "VIDIOCMCAPTURE: %s\n", strerror(errno));
-            } else {
-                av_log(s1, AV_LOG_ERROR, "Fatal: grab device does not receive any video signal\n");
-            }
-            goto fail;
-        }
-        for (j = 1; j < s->gb_buffers.frames; j++) {
-          s->gb_buf.frame = j;
-          ioctl(video_fd, VIDIOCMCAPTURE, &s->gb_buf);
-        }
-        s->frame_format = s->gb_buf.format;
-        s->use_mmap = 1;
-    }
-
-    for (j = 0; j < vformat_num; j++) {
-        if (s->frame_format == video_formats[j].palette) {
-            s->frame_size = s->video_win.width * s->video_win.height * video_formats[j].depth / 8;
-            st->codec->pix_fmt = video_formats[j].pix_fmt;
-            break;
-        }
-    }
-
-    if (j >= vformat_num)
-        goto fail;
-
-    s->fd = video_fd;
-
-    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
-    st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
-    st->codec->width = s->video_win.width;
-    st->codec->height = s->video_win.height;
-    st->codec->time_base = s->time_base;
-    st->codec->bit_rate = s->frame_size * 1/av_q2d(st->codec->time_base) * 8;
-
-    return 0;
- fail:
-    if (video_fd >= 0)
-        close(video_fd);
-    return AVERROR(EIO);
-}
-
-static int v4l_mm_read_picture(VideoData *s, uint8_t *buf)
-{
-    uint8_t *ptr;
-
-    while (ioctl(s->fd, VIDIOCSYNC, &s->gb_frame) < 0 &&
-           (errno == EAGAIN || errno == EINTR));
-
-    ptr = s->video_buf + s->gb_buffers.offsets[s->gb_frame];
-    memcpy(buf, ptr, s->frame_size);
-
-    /* Setup to capture the next frame */
-    s->gb_buf.frame = s->gb_frame;
-    if (ioctl(s->fd, VIDIOCMCAPTURE, &s->gb_buf) < 0) {
-        if (errno == EAGAIN)
-            av_log(NULL, AV_LOG_ERROR, "Cannot Sync\n");
-        else
-            av_log(NULL, AV_LOG_ERROR, "VIDIOCMCAPTURE: %s\n", strerror(errno));
-        return AVERROR(EIO);
-    }
-
-    /* This is now the grabbing frame */
-    s->gb_frame = (s->gb_frame + 1) % s->gb_buffers.frames;
-
-    return s->frame_size;
-}
-
-static int grab_read_packet(AVFormatContext *s1, AVPacket *pkt)
-{
-    VideoData *s = s1->priv_data;
-    int64_t curtime, delay;
-    struct timespec ts;
-
-    /* Calculate the time of the next frame */
-    s->time_frame += INT64_C(1000000);
-
-    /* wait based on the frame rate */
-    for(;;) {
-        curtime = av_gettime();
-        delay = s->time_frame * s->time_base.num / s->time_base.den - curtime;
-        if (delay <= 0) {
-            if (delay < INT64_C(-1000000) * s->time_base.num / s->time_base.den) {
-                /* printf("grabbing is %d frames late (dropping)\n", (int) -(delay / 16666)); */
-                s->time_frame += INT64_C(1000000);
-            }
-            break;
-        }
-        ts.tv_sec = delay / 1000000;
-        ts.tv_nsec = (delay % 1000000) * 1000;
-        nanosleep(&ts, NULL);
-    }
-
-    if (av_new_packet(pkt, s->frame_size) < 0)
-        return AVERROR(EIO);
-
-    pkt->pts = curtime;
-
-    /* read one frame */
-    if (s->use_mmap) {
-        return v4l_mm_read_picture(s, pkt->data);
-    } else {
-        if (read(s->fd, pkt->data, pkt->size) != pkt->size)
-            return AVERROR(EIO);
-        return s->frame_size;
-    }
-}
-
-static int grab_read_close(AVFormatContext *s1)
-{
-    VideoData *s = s1->priv_data;
-
-    if (s->use_mmap)
-        munmap(s->video_buf, s->gb_buffers.size);
-
-    /* mute audio. we must force it because the BTTV driver does not
-       return its state correctly */
-    s->audio_saved.flags |= VIDEO_AUDIO_MUTE;
-    ioctl(s->fd, VIDIOCSAUDIO, &s->audio_saved);
-
-    close(s->fd);
-    return 0;
-}
-
-static const AVOption options[] = {
-    { "standard", "", offsetof(VideoData, standard), AV_OPT_TYPE_INT, {.i64 = VIDEO_MODE_NTSC}, VIDEO_MODE_PAL, VIDEO_MODE_NTSC, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-    { "PAL",   "", 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_MODE_PAL},   0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-    { "SECAM", "", 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_MODE_SECAM}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-    { "NTSC",  "", 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_MODE_NTSC},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-    { NULL },
-};
-
-static const AVClass v4l_class = {
-    .class_name = "V4L indev",
-    .item_name  = av_default_item_name,
-    .option     = options,
-    .version    = LIBAVUTIL_VERSION_INT,
-    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
-};
-
-AVInputFormat ff_v4l_demuxer = {
-    .name           = "video4linux,v4l",
-    .long_name      = NULL_IF_CONFIG_SMALL("Video4Linux device grab"),
-    .priv_data_size = sizeof(VideoData),
-    .read_header    = grab_read_header,
-    .read_packet    = grab_read_packet,
-    .read_close     = grab_read_close,
-    .flags          = AVFMT_NOFILE,
-    .priv_class     = &v4l_class,
-};
diff --git a/mythtv/external/FFmpeg/libavdevice/v4l2-common.h b/mythtv/external/FFmpeg/libavdevice/v4l2-common.h
index 40c716489fe..0cbaec8bb9b 100644
--- a/mythtv/external/FFmpeg/libavdevice/v4l2-common.h
+++ b/mythtv/external/FFmpeg/libavdevice/v4l2-common.h
@@ -35,7 +35,6 @@
 #endif
 #include <linux/videodev2.h>
 #endif
-#include "libavutil/atomic.h"
 #include "libavutil/avassert.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/log.h"
diff --git a/mythtv/external/FFmpeg/libavdevice/v4l2.c b/mythtv/external/FFmpeg/libavdevice/v4l2.c
index ddf331d43d0..f087badf5ca 100644
--- a/mythtv/external/FFmpeg/libavdevice/v4l2.c
+++ b/mythtv/external/FFmpeg/libavdevice/v4l2.c
@@ -30,6 +30,8 @@
  * V4L2_PIX_FMT_* and AV_PIX_FMT_*
  */
 
+#include <stdatomic.h>
+
 #include "v4l2-common.h"
 #include <dirent.h>
 
@@ -78,7 +80,7 @@ struct video_data {
     int64_t last_time_m;
 
     int buffers;
-    volatile int buffers_queued;
+    atomic_int buffers_queued;
     void **buf_start;
     unsigned int *buf_len;
     char *standard;
@@ -402,7 +404,7 @@ static int enqueue_buffer(struct video_data *s, struct v4l2_buffer *buf)
         res = AVERROR(errno);
         av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n", av_err2str(res));
     } else {
-        avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1);
+        atomic_fetch_add(&s->buffers_queued, 1);
     }
 
     return res;
@@ -490,6 +492,7 @@ static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
         .type   = V4L2_BUF_TYPE_VIDEO_CAPTURE,
         .memory = V4L2_MEMORY_MMAP
     };
+    struct timeval buf_ts;
     int res;
 
     pkt->size = 0;
@@ -506,13 +509,15 @@ static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
         return res;
     }
 
+    buf_ts = buf.timestamp;
+
     if (buf.index >= s->buffers) {
         av_log(ctx, AV_LOG_ERROR, "Invalid buffer index received.\n");
         return AVERROR(EINVAL);
     }
-    avpriv_atomic_int_add_and_fetch(&s->buffers_queued, -1);
+    atomic_fetch_add(&s->buffers_queued, -1);
     // always keep at least one buffer queued
-    av_assert0(avpriv_atomic_int_get(&s->buffers_queued) >= 1);
+    av_assert0(atomic_load(&s->buffers_queued) >= 1);
 
 #ifdef V4L2_BUF_FLAG_ERROR
     if (buf.flags & V4L2_BUF_FLAG_ERROR) {
@@ -538,7 +543,7 @@ static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
     }
 
     /* Image is at s->buff_start[buf.index] */
-    if (avpriv_atomic_int_get(&s->buffers_queued) == FFMAX(s->buffers / 8, 1)) {
+    if (atomic_load(&s->buffers_queued) == FFMAX(s->buffers / 8, 1)) {
         /* when we start getting low on queued buffers, fall back on copying data */
         res = av_new_packet(pkt, buf.bytesused);
         if (res < 0) {
@@ -581,7 +586,7 @@ static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)
             return AVERROR(ENOMEM);
         }
     }
-    pkt->pts = buf.timestamp.tv_sec * INT64_C(1000000) + buf.timestamp.tv_usec;
+    pkt->pts = buf_ts.tv_sec * INT64_C(1000000) + buf_ts.tv_usec;
     convert_timestamp(ctx, &pkt->pts);
 
     return pkt->size;
@@ -607,7 +612,7 @@ static int mmap_start(AVFormatContext *ctx)
             return res;
         }
     }
-    s->buffers_queued = s->buffers;
+    atomic_store(&s->buffers_queued, s->buffers);
 
     type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     if (v4l2_ioctl(s->fd, VIDIOC_STREAMON, &type) < 0) {
@@ -882,14 +887,14 @@ static int v4l2_read_header(AVFormatContext *ctx)
     avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
 
     if (s->pixel_format) {
-        AVCodec *codec = avcodec_find_decoder_by_name(s->pixel_format);
+        const AVCodecDescriptor *desc = avcodec_descriptor_get_by_name(s->pixel_format);
 
-        if (codec)
-            ctx->video_codec_id = codec->id;
+        if (desc)
+            ctx->video_codec_id = desc->id;
 
         pix_fmt = av_get_pix_fmt(s->pixel_format);
 
-        if (pix_fmt == AV_PIX_FMT_NONE && !codec) {
+        if (pix_fmt == AV_PIX_FMT_NONE && !desc) {
             av_log(ctx, AV_LOG_ERROR, "No such input format: %s.\n",
                    s->pixel_format);
 
@@ -936,8 +941,9 @@ static int v4l2_read_header(AVFormatContext *ctx)
         goto fail;
 
     st->codecpar->format = ff_fmt_v4l2ff(desired_format, codec_id);
-    s->frame_size = av_image_get_buffer_size(st->codecpar->format,
-                                             s->width, s->height, 1);
+    if (st->codecpar->format != AV_PIX_FMT_NONE)
+        s->frame_size = av_image_get_buffer_size(st->codecpar->format,
+                                                 s->width, s->height, 1);
 
     if ((res = mmap_init(ctx)) ||
         (res = mmap_start(ctx)) < 0)
@@ -979,7 +985,6 @@ FF_ENABLE_DEPRECATION_WARNINGS
 #endif
     int res;
 
-    av_init_packet(pkt);
     if ((res = mmap_read_frame(ctx, pkt)) < 0) {
         return res;
     }
@@ -1000,7 +1005,7 @@ static int v4l2_read_close(AVFormatContext *ctx)
 {
     struct video_data *s = ctx->priv_data;
 
-    if (avpriv_atomic_int_get(&s->buffers_queued) != s->buffers)
+    if (atomic_load(&s->buffers_queued) != s->buffers)
         av_log(ctx, AV_LOG_WARNING, "Some buffers are still owned by the caller on "
                "close.\n");
 
diff --git a/mythtv/external/FFmpeg/libavdevice/version.h b/mythtv/external/FFmpeg/libavdevice/version.h
index d9b08f17d9a..9d900877af9 100644
--- a/mythtv/external/FFmpeg/libavdevice/version.h
+++ b/mythtv/external/FFmpeg/libavdevice/version.h
@@ -28,7 +28,7 @@
 #include "libavutil/version.h"
 
 #define LIBAVDEVICE_VERSION_MAJOR  57
-#define LIBAVDEVICE_VERSION_MINOR   1
+#define LIBAVDEVICE_VERSION_MINOR  10
 #define LIBAVDEVICE_VERSION_MICRO 100
 
 #define LIBAVDEVICE_VERSION_INT AV_VERSION_INT(LIBAVDEVICE_VERSION_MAJOR, \
diff --git a/mythtv/external/FFmpeg/libavdevice/vfwcap.c b/mythtv/external/FFmpeg/libavdevice/vfwcap.c
index 1ed73133cd9..f03d38ac262 100644
--- a/mythtv/external/FFmpeg/libavdevice/vfwcap.c
+++ b/mythtv/external/FFmpeg/libavdevice/vfwcap.c
@@ -387,8 +387,7 @@ static int vfw_read_header(AVFormatContext *s)
     if (par->format == AV_PIX_FMT_NONE) {
         par->codec_id = vfw_codecid(biCompression);
         if (par->codec_id == AV_CODEC_ID_NONE) {
-            av_log(s, AV_LOG_ERROR, "Unknown compression type. "
-                             "Please report verbose (-v 9) debug information.\n");
+            avpriv_report_missing_feature(s, "This compression type");
             vfw_read_close(s);
             return AVERROR_PATCHWELCOME;
         }
diff --git a/mythtv/external/FFmpeg/libavdevice/x11grab.c b/mythtv/external/FFmpeg/libavdevice/x11grab.c
deleted file mode 100644
index 5c8cfc13249..00000000000
--- a/mythtv/external/FFmpeg/libavdevice/x11grab.c
+++ /dev/null
@@ -1,696 +0,0 @@
-/*
- * X11 video grab interface
- *
- * This file is part of FFmpeg.
- *
- * FFmpeg integration:
- * Copyright (C) 2006 Clemens Fruhwirth <clemens@endorphin.org>
- *                    Edouard Gomez <ed.gomez@free.fr>
- *
- * This file contains code from grab.c:
- * Copyright (c) 2000-2001 Fabrice Bellard
- *
- * This file contains code from the xvidcap project:
- * Copyright (C) 1997-1998 Rasca, Berlin
- *               2003-2004 Karl H. Beckers, Frankfurt
- *
- * FFmpeg is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 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 General Public License for more details.
- *
- * You should have received a copy of the GNU 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
- * X11 frame device demuxer
- * @author Clemens Fruhwirth <clemens@endorphin.org>
- * @author Edouard Gomez <ed.gomez@free.fr>
- */
-
-#include "config.h"
-
-#include <time.h>
-#include <sys/shm.h>
-
-#include <X11/cursorfont.h>
-#include <X11/X.h>
-#include <X11/Xlib.h>
-#include <X11/Xlibint.h>
-#include <X11/Xproto.h>
-#include <X11/Xutil.h>
-
-#include <X11/extensions/shape.h>
-#include <X11/extensions/Xfixes.h>
-#include <X11/extensions/XShm.h>
-
-#include "libavutil/internal.h"
-#include "libavutil/log.h"
-#include "libavutil/opt.h"
-#include "libavutil/parseutils.h"
-#include "libavutil/time.h"
-
-#include "libavformat/internal.h"
-
-#include "avdevice.h"
-
-/** X11 device demuxer context */
-typedef struct X11GrabContext {
-    const AVClass *class;    /**< Class for private options. */
-    int frame_size;          /**< Size in bytes of a grabbed frame */
-    AVRational time_base;    /**< Time base */
-    int64_t time_frame;      /**< Current time */
-
-    int width;               /**< Width of the grab frame */
-    int height;              /**< Height of the grab frame */
-    int x_off;               /**< Horizontal top-left corner coordinate */
-    int y_off;               /**< Vertical top-left corner coordinate */
-
-    Display *dpy;            /**< X11 display from which x11grab grabs frames */
-    XImage *image;           /**< X11 image holding the grab */
-    int use_shm;             /**< !0 when using XShm extension */
-    XShmSegmentInfo shminfo; /**< When using XShm, keeps track of XShm info */
-    int draw_mouse;          /**< Set by a private option. */
-    int follow_mouse;        /**< Set by a private option. */
-    int show_region;         /**< set by a private option. */
-    AVRational framerate;    /**< Set by a private option. */
-    int palette_changed;
-    uint32_t palette[256];
-
-    Cursor c;
-    Window region_win;       /**< This is used by show_region option. */
-} X11GrabContext;
-
-#define REGION_WIN_BORDER 3
-
-/**
- * Draw grabbing region window
- *
- * @param s x11grab context
- */
-static void x11grab_draw_region_win(X11GrabContext *s)
-{
-    Display *dpy = s->dpy;
-    Window win   = s->region_win;
-    int screen = DefaultScreen(dpy);
-    GC gc = XCreateGC(dpy, win, 0, 0);
-
-    XSetForeground(dpy, gc, WhitePixel(dpy, screen));
-    XSetBackground(dpy, gc, BlackPixel(dpy, screen));
-    XSetLineAttributes(dpy, gc, REGION_WIN_BORDER, LineDoubleDash, 0, 0);
-    XDrawRectangle(dpy, win, gc, 1, 1,
-                   (s->width  + REGION_WIN_BORDER * 2) - 1 * 2 - 1,
-                   (s->height + REGION_WIN_BORDER * 2) - 1 * 2 - 1);
-    XFreeGC(dpy, gc);
-}
-
-/**
- * Initialize grabbing region window
- *
- * @param s x11grab context
- */
-static void x11grab_region_win_init(X11GrabContext *s)
-{
-    Display *dpy = s->dpy;
-    XRectangle rect;
-    XSetWindowAttributes attribs = { .override_redirect = True };
-    int screen = DefaultScreen(dpy);
-
-    s->region_win = XCreateWindow(dpy, RootWindow(dpy, screen),
-                                  s->x_off  - REGION_WIN_BORDER,
-                                  s->y_off  - REGION_WIN_BORDER,
-                                  s->width  + REGION_WIN_BORDER * 2,
-                                  s->height + REGION_WIN_BORDER * 2,
-                                  0, CopyFromParent,
-                                  InputOutput, CopyFromParent,
-                                  CWOverrideRedirect, &attribs);
-    rect.x      = 0;
-    rect.y      = 0;
-    rect.width  = s->width;
-    rect.height = s->height;
-    XShapeCombineRectangles(dpy, s->region_win,
-                            ShapeBounding, REGION_WIN_BORDER, REGION_WIN_BORDER,
-                            &rect, 1, ShapeSubtract, 0);
-    XMapWindow(dpy, s->region_win);
-    XSelectInput(dpy, s->region_win, ExposureMask | StructureNotifyMask);
-    x11grab_draw_region_win(s);
-}
-
-static int setup_shm(AVFormatContext *s, Display *dpy, XImage **image)
-{
-    X11GrabContext *g = s->priv_data;
-    int scr           = XDefaultScreen(dpy);
-    XImage *img       = XShmCreateImage(dpy, DefaultVisual(dpy, scr),
-                                        DefaultDepth(dpy, scr), ZPixmap, NULL,
-                                        &g->shminfo, g->width, g->height);
-
-    g->shminfo.shmid = shmget(IPC_PRIVATE, img->bytes_per_line * img->height,
-                              IPC_CREAT | 0777);
-
-    if (g->shminfo.shmid == -1) {
-        av_log(s, AV_LOG_ERROR, "Cannot get shared memory!\n");
-        return AVERROR(ENOMEM);
-    }
-
-    g->shminfo.shmaddr  = img->data = shmat(g->shminfo.shmid, 0, 0);
-    g->shminfo.readOnly = False;
-
-    if (!XShmAttach(dpy, &g->shminfo)) {
-        av_log(s, AV_LOG_ERROR, "Failed to attach shared memory!\n");
-        /* needs some better error subroutine :) */
-        return AVERROR(EIO);
-    }
-
-    *image = img;
-    return 0;
-}
-
-static int setup_mouse(Display *dpy, int screen)
-{
-    int ev_ret, ev_err;
-
-    if (XFixesQueryExtension(dpy, &ev_ret, &ev_err)) {
-        Window root = RootWindow(dpy, screen);
-        XFixesSelectCursorInput(dpy, root, XFixesDisplayCursorNotifyMask);
-        return 0;
-    }
-
-    return AVERROR(ENOSYS);
-}
-
-static int pixfmt_from_image(AVFormatContext *s, XImage *image, int *pix_fmt)
-{
-    av_log(s, AV_LOG_DEBUG,
-           "Image r 0x%.6lx g 0x%.6lx b 0x%.6lx and depth %i\n",
-           image->red_mask,
-           image->green_mask,
-           image->blue_mask,
-           image->bits_per_pixel);
-
-    *pix_fmt = AV_PIX_FMT_NONE;
-
-    switch (image->bits_per_pixel) {
-    case 8:
-        *pix_fmt =  AV_PIX_FMT_PAL8;
-        break;
-    case 16:
-        if (image->red_mask   == 0xf800 &&
-            image->green_mask == 0x07e0 &&
-            image->blue_mask  == 0x001f) {
-            *pix_fmt = AV_PIX_FMT_RGB565;
-        } else if (image->red_mask   == 0x7c00 &&
-                   image->green_mask == 0x03e0 &&
-                   image->blue_mask  == 0x001f) {
-            *pix_fmt = AV_PIX_FMT_RGB555;
-        }
-        break;
-    case 24:
-        if (image->red_mask   == 0xff0000 &&
-            image->green_mask == 0x00ff00 &&
-            image->blue_mask  == 0x0000ff) {
-            *pix_fmt = AV_PIX_FMT_BGR24;
-        } else if (image->red_mask   == 0x0000ff &&
-                   image->green_mask == 0x00ff00 &&
-                   image->blue_mask  == 0xff0000) {
-            *pix_fmt = AV_PIX_FMT_RGB24;
-        }
-        break;
-    case 32:
-        if (image->red_mask   == 0xff0000 &&
-            image->green_mask == 0x00ff00 &&
-            image->blue_mask  == 0x0000ff ) {
-            *pix_fmt = AV_PIX_FMT_0RGB32;
-        }
-        break;
-    }
-    if (*pix_fmt == AV_PIX_FMT_NONE) {
-        av_log(s, AV_LOG_ERROR,
-               "XImages with RGB mask 0x%.6lx 0x%.6lx 0x%.6lx and depth %i "
-               "are currently not supported.\n",
-               image->red_mask,
-               image->green_mask,
-               image->blue_mask,
-               image->bits_per_pixel);
-
-        return AVERROR_PATCHWELCOME;
-    }
-
-    return 0;
-}
-
-/**
- * Initialize the x11 grab device demuxer (public device demuxer API).
- *
- * @param s1 Context from avformat core
- * @return <ul>
- *          <li>AVERROR(ENOMEM) no memory left</li>
- *          <li>AVERROR(EIO) other failure case</li>
- *          <li>0 success</li>
- *         </ul>
- */
-static int x11grab_read_header(AVFormatContext *s1)
-{
-    X11GrabContext *x11grab = s1->priv_data;
-    Display *dpy;
-    AVStream *st = NULL;
-    XImage *image;
-    int x_off = 0, y_off = 0, ret = 0, screen, use_shm = 0;
-    char *dpyname, *offset;
-    Colormap color_map;
-    XColor color[256];
-    int i;
-
-    dpyname = av_strdup(s1->filename);
-    if (!dpyname)
-        goto out;
-
-    offset = strchr(dpyname, '+');
-    if (offset) {
-        sscanf(offset, "%d,%d", &x_off, &y_off);
-        if (strstr(offset, "nomouse")) {
-            av_log(s1, AV_LOG_WARNING,
-                   "'nomouse' specification in argument is deprecated: "
-                   "use 'draw_mouse' option with value 0 instead\n");
-            x11grab->draw_mouse = 0;
-        }
-        *offset = 0;
-    }
-
-    av_log(s1, AV_LOG_INFO,
-           "device: %s -> display: %s x: %d y: %d width: %d height: %d\n",
-           s1->filename, dpyname, x_off, y_off, x11grab->width, x11grab->height);
-
-    dpy = XOpenDisplay(dpyname);
-    av_freep(&dpyname);
-    if (!dpy) {
-        av_log(s1, AV_LOG_ERROR, "Could not open X display.\n");
-        ret = AVERROR(EIO);
-        goto out;
-    }
-
-    st = avformat_new_stream(s1, NULL);
-    if (!st) {
-        ret = AVERROR(ENOMEM);
-        goto out;
-    }
-    avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
-
-    screen = DefaultScreen(dpy);
-
-    if (x11grab->follow_mouse) {
-        int screen_w, screen_h;
-        Window w;
-
-        screen_w = DisplayWidth(dpy, screen);
-        screen_h = DisplayHeight(dpy, screen);
-        XQueryPointer(dpy, RootWindow(dpy, screen), &w, &w, &x_off, &y_off,
-                      &ret, &ret, &ret);
-        x_off -= x11grab->width / 2;
-        y_off -= x11grab->height / 2;
-        x_off = av_clip(x_off, 0, screen_w - x11grab->width);
-        y_off = av_clip(y_off, 0, screen_h - x11grab->height);
-        av_log(s1, AV_LOG_INFO,
-               "followmouse is enabled, resetting grabbing region to x: %d y: %d\n",
-               x_off, y_off);
-    }
-
-    if (x11grab->use_shm) {
-        use_shm = XShmQueryExtension(dpy);
-        av_log(s1, AV_LOG_INFO,
-               "shared memory extension %sfound\n", use_shm ? "" : "not ");
-    }
-
-    if (use_shm && setup_shm(s1, dpy, &image) < 0) {
-        av_log(s1, AV_LOG_WARNING, "Falling back to XGetImage\n");
-        use_shm = 0;
-    }
-
-    if (!use_shm) {
-        image = XGetImage(dpy, RootWindow(dpy, screen),
-                          x_off, y_off,
-                          x11grab->width, x11grab->height,
-                          AllPlanes, ZPixmap);
-    }
-
-    if (x11grab->draw_mouse && setup_mouse(dpy, screen) < 0) {
-        av_log(s1, AV_LOG_WARNING,
-               "XFixes not available, cannot draw the mouse cursor\n");
-        x11grab->draw_mouse = 0;
-    }
-
-    x11grab->frame_size = x11grab->width * x11grab->height * image->bits_per_pixel / 8;
-    x11grab->dpy        = dpy;
-    x11grab->time_base  = av_inv_q(x11grab->framerate);
-    x11grab->time_frame = av_gettime() / av_q2d(x11grab->time_base);
-    x11grab->x_off      = x_off;
-    x11grab->y_off      = y_off;
-    x11grab->image      = image;
-    x11grab->use_shm    = use_shm;
-
-    ret = pixfmt_from_image(s1, image, &st->codecpar->format);
-    if (ret < 0)
-        goto out;
-
-    if (st->codecpar->format == AV_PIX_FMT_PAL8) {
-        color_map = DefaultColormap(dpy, screen);
-        for (i = 0; i < 256; ++i)
-            color[i].pixel = i;
-        XQueryColors(dpy, color_map, color, 256);
-        for (i = 0; i < 256; ++i)
-            x11grab->palette[i] = (color[i].red   & 0xFF00) << 8 |
-                                  (color[i].green & 0xFF00)      |
-                                  (color[i].blue  & 0xFF00) >> 8;
-        x11grab->palette_changed = 1;
-    }
-
-
-    st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
-    st->codecpar->codec_id   = AV_CODEC_ID_RAWVIDEO;
-    st->codecpar->width      = x11grab->width;
-    st->codecpar->height     = x11grab->height;
-    st->codecpar->bit_rate   = x11grab->frame_size * 1 / av_q2d(x11grab->time_base) * 8;
-
-    st->avg_frame_rate       = av_inv_q(x11grab->time_base);
-
-out:
-    av_free(dpyname);
-    return ret;
-}
-
-/**
- * Paint a mouse pointer in an X11 image.
- *
- * @param image image to paint the mouse pointer to
- * @param s context used to retrieve original grabbing rectangle
- *          coordinates
- */
-static void paint_mouse_pointer(XImage *image, AVFormatContext *s1)
-{
-    X11GrabContext *s = s1->priv_data;
-    int x_off    = s->x_off;
-    int y_off    = s->y_off;
-    int width    = s->width;
-    int height   = s->height;
-    Display *dpy = s->dpy;
-    XFixesCursorImage *xcim;
-    int x, y;
-    int line, column;
-    int to_line, to_column;
-    int pixstride = image->bits_per_pixel >> 3;
-    /* Warning: in its insanity, xlib provides unsigned image data through a
-     * char* pointer, so we have to make it uint8_t to make things not break.
-     * Anyone who performs further investigation of the xlib API likely risks
-     * permanent brain damage. */
-    uint8_t *pix = image->data;
-    Window root;
-    XSetWindowAttributes attr;
-
-    /* Code doesn't currently support 16-bit or PAL8 */
-    if (image->bits_per_pixel != 24 && image->bits_per_pixel != 32)
-        return;
-
-    if (!s->c)
-        s->c = XCreateFontCursor(dpy, XC_left_ptr);
-    root = DefaultRootWindow(dpy);
-    attr.cursor = s->c;
-    XChangeWindowAttributes(dpy, root, CWCursor, &attr);
-
-    xcim = XFixesGetCursorImage(dpy);
-    if (!xcim) {
-        av_log(s1, AV_LOG_WARNING,
-               "XFixesGetCursorImage failed\n");
-        return;
-    }
-
-    x = xcim->x - xcim->xhot;
-    y = xcim->y - xcim->yhot;
-
-    to_line   = FFMIN((y + xcim->height), (height + y_off));
-    to_column = FFMIN((x + xcim->width),  (width  + x_off));
-
-    for (line = FFMAX(y, y_off); line < to_line; line++) {
-        for (column = FFMAX(x, x_off); column < to_column; column++) {
-            int xcim_addr  = (line  - y)     * xcim->width + column - x;
-            int image_addr = ((line - y_off) * width       + column - x_off) * pixstride;
-            int r          = (uint8_t)(xcim->pixels[xcim_addr] >>  0);
-            int g          = (uint8_t)(xcim->pixels[xcim_addr] >>  8);
-            int b          = (uint8_t)(xcim->pixels[xcim_addr] >> 16);
-            int a          = (uint8_t)(xcim->pixels[xcim_addr] >> 24);
-
-            if (a == 255) {
-                pix[image_addr + 0] = r;
-                pix[image_addr + 1] = g;
-                pix[image_addr + 2] = b;
-            } else if (a) {
-                /* pixel values from XFixesGetCursorImage come premultiplied by alpha */
-                pix[image_addr + 0] = r + (pix[image_addr + 0] * (255 - a) + 255 / 2) / 255;
-                pix[image_addr + 1] = g + (pix[image_addr + 1] * (255 - a) + 255 / 2) / 255;
-                pix[image_addr + 2] = b + (pix[image_addr + 2] * (255 - a) + 255 / 2) / 255;
-            }
-        }
-    }
-
-    XFree(xcim);
-    xcim = NULL;
-}
-
-/**
- * Read new data in the image structure.
- *
- * @param dpy X11 display to grab from
- * @param d
- * @param image Image where the grab will be put
- * @param x Top-Left grabbing rectangle horizontal coordinate
- * @param y Top-Left grabbing rectangle vertical coordinate
- * @return 0 if error, !0 if successful
- */
-static int xget_zpixmap(Display *dpy, Drawable d, XImage *image, int x, int y)
-{
-    xGetImageReply rep;
-    xGetImageReq *req;
-    long nbytes;
-
-    if (!image)
-        return 0;
-
-    LockDisplay(dpy);
-    GetReq(GetImage, req);
-
-    /* First set up the standard stuff in the request */
-    req->drawable  = d;
-    req->x         = x;
-    req->y         = y;
-    req->width     = image->width;
-    req->height    = image->height;
-    req->planeMask = (unsigned int)AllPlanes;
-    req->format    = ZPixmap;
-
-    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.length) {
-        UnlockDisplay(dpy);
-        SyncHandle();
-        return 0;
-    }
-
-    nbytes = (long)rep.length << 2;
-    _XReadPad(dpy, image->data, nbytes);
-
-    UnlockDisplay(dpy);
-    SyncHandle();
-    return 1;
-}
-
-/**
- * Grab a frame from x11 (public device demuxer API).
- *
- * @param s1 Context from avformat core
- * @param pkt Packet holding the brabbed frame
- * @return frame size in bytes
- */
-static int x11grab_read_packet(AVFormatContext *s1, AVPacket *pkt)
-{
-    X11GrabContext *s = s1->priv_data;
-    Display *dpy      = s->dpy;
-    XImage *image     = s->image;
-    int x_off         = s->x_off;
-    int y_off         = s->y_off;
-    int follow_mouse  = s->follow_mouse;
-    int screen, pointer_x, pointer_y, _, same_screen = 1;
-    Window w, root;
-    int64_t curtime, delay;
-    struct timespec ts;
-
-    /* wait based on the frame rate */
-    for (;;) {
-        curtime = av_gettime();
-        delay   = s->time_frame * av_q2d(s->time_base) - curtime;
-        if (delay <= 0) {
-            break;
-        }
-        ts.tv_sec  = delay / 1000000;
-        ts.tv_nsec = (delay % 1000000) * 1000;
-        nanosleep(&ts, NULL);
-    }
-
-    /* Calculate the time of the next frame */
-    do {
-      s->time_frame += INT64_C(1000000);
-    } while ((s->time_frame * av_q2d(s->time_base) - curtime) <= 0);
-
-    av_init_packet(pkt);
-    pkt->data = image->data;
-    pkt->size = s->frame_size;
-    pkt->pts  = curtime;
-    if (s->palette_changed) {
-        uint8_t *pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE,
-                                               AVPALETTE_SIZE);
-        if (!pal) {
-            av_log(s, AV_LOG_ERROR, "Cannot append palette to packet\n");
-        } else {
-            memcpy(pal, s->palette, AVPALETTE_SIZE);
-            s->palette_changed = 0;
-        }
-    }
-
-    screen = DefaultScreen(dpy);
-    root   = RootWindow(dpy, screen);
-
-    if (follow_mouse || s->draw_mouse)
-        same_screen = XQueryPointer(dpy, root, &w, &w,
-                                    &pointer_x, &pointer_y, &_, &_, &_);
-
-    if (follow_mouse && same_screen) {
-        int screen_w, screen_h;
-
-        screen_w = DisplayWidth(dpy, screen);
-        screen_h = DisplayHeight(dpy, screen);
-        if (follow_mouse == -1) {
-            // follow the mouse, put it at center of grabbing region
-            x_off += pointer_x - s->width / 2 - x_off;
-            y_off += pointer_y - s->height / 2 - y_off;
-        } else {
-            // follow the mouse, but only move the grabbing region when mouse
-            // reaches within certain pixels to the edge.
-            if (pointer_x > x_off + s->width - follow_mouse)
-                x_off += pointer_x - (x_off + s->width - follow_mouse);
-            else if (pointer_x < x_off + follow_mouse)
-                x_off -= (x_off + follow_mouse) - pointer_x;
-            if (pointer_y > y_off + s->height - follow_mouse)
-                y_off += pointer_y - (y_off + s->height - follow_mouse);
-            else if (pointer_y < y_off + follow_mouse)
-                y_off -= (y_off + follow_mouse) - pointer_y;
-        }
-        // adjust grabbing region position if it goes out of screen.
-        s->x_off = x_off = av_clip(x_off, 0, screen_w - s->width);
-        s->y_off = y_off = av_clip(y_off, 0, screen_h - s->height);
-
-        if (s->show_region && s->region_win)
-            XMoveWindow(dpy, s->region_win,
-                        s->x_off - REGION_WIN_BORDER,
-                        s->y_off - REGION_WIN_BORDER);
-    }
-
-    if (s->show_region && same_screen) {
-        if (s->region_win) {
-            XEvent evt = { .type = NoEventMask };
-            // Clean up the events, and do the initial draw or redraw.
-            while (XCheckMaskEvent(dpy, ExposureMask | StructureNotifyMask,
-                                   &evt))
-                ;
-            if (evt.type)
-                x11grab_draw_region_win(s);
-        } else {
-            x11grab_region_win_init(s);
-        }
-    }
-
-    if (s->use_shm) {
-        if (!XShmGetImage(dpy, root, image, x_off, y_off, AllPlanes))
-            av_log(s1, AV_LOG_INFO, "XShmGetImage() failed\n");
-    } else {
-        if (!xget_zpixmap(dpy, root, image, x_off, y_off))
-            av_log(s1, AV_LOG_INFO, "XGetZPixmap() failed\n");
-    }
-
-    if (s->draw_mouse && same_screen)
-        paint_mouse_pointer(image, s1);
-
-    return s->frame_size;
-}
-
-/**
- * Close x11 frame grabber (public device demuxer API).
- *
- * @param s1 Context from avformat core
- * @return 0 success, !0 failure
- */
-static int x11grab_read_close(AVFormatContext *s1)
-{
-    X11GrabContext *x11grab = s1->priv_data;
-
-    /* Detach cleanly from shared mem */
-    if (x11grab->use_shm) {
-        XShmDetach(x11grab->dpy, &x11grab->shminfo);
-        shmdt(x11grab->shminfo.shmaddr);
-        shmctl(x11grab->shminfo.shmid, IPC_RMID, NULL);
-    }
-
-    /* Destroy X11 image */
-    if (x11grab->image) {
-        XDestroyImage(x11grab->image);
-        x11grab->image = NULL;
-    }
-
-    if (x11grab->region_win)
-        XDestroyWindow(x11grab->dpy, x11grab->region_win);
-
-    /* Free X11 display */
-    XCloseDisplay(x11grab->dpy);
-    return 0;
-}
-
-#define OFFSET(x) offsetof(X11GrabContext, x)
-#define DEC AV_OPT_FLAG_DECODING_PARAM
-static const AVOption options[] = {
-    { "grab_x", "Initial x coordinate.", OFFSET(x_off), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, DEC },
-    { "grab_y", "Initial y coordinate.", OFFSET(y_off), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, DEC },
-    { "draw_mouse", "draw the mouse pointer", OFFSET(draw_mouse), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, DEC },
-
-    { "follow_mouse", "move the grabbing region when the mouse pointer reaches within specified amount of pixels to the edge of region",
-      OFFSET(follow_mouse), AV_OPT_TYPE_INT, {.i64 = 0}, -1, INT_MAX, DEC, "follow_mouse" },
-    { "centered",     "keep the mouse pointer at the center of grabbing region when following",
-      0, AV_OPT_TYPE_CONST, {.i64 = -1}, INT_MIN, INT_MAX, DEC, "follow_mouse" },
-
-    { "framerate",  "set video frame rate",      OFFSET(framerate),   AV_OPT_TYPE_VIDEO_RATE, {.str = "ntsc"}, 0, INT_MAX, DEC },
-    { "show_region", "show the grabbing region", OFFSET(show_region), AV_OPT_TYPE_INT,        {.i64 = 0}, 0, 1, DEC },
-    { "video_size",  "set video frame size",     OFFSET(width),       AV_OPT_TYPE_IMAGE_SIZE, {.str = "vga"}, 0, 0, DEC },
-    { "use_shm",     "use MIT-SHM extension",    OFFSET(use_shm),     AV_OPT_TYPE_INT,        {.i64 = 1}, 0, 1, DEC },
-    { NULL },
-};
-
-static const AVClass x11_class = {
-    .class_name = "X11grab indev",
-    .item_name  = av_default_item_name,
-    .option     = options,
-    .version    = LIBAVUTIL_VERSION_INT,
-    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
-};
-
-/** x11 grabber device demuxer declaration */
-AVInputFormat ff_x11grab_demuxer = {
-    .name           = "x11grab",
-    .long_name      = NULL_IF_CONFIG_SMALL("X11grab"),
-    .priv_data_size = sizeof(X11GrabContext),
-    .read_header    = x11grab_read_header,
-    .read_packet    = x11grab_read_packet,
-    .read_close     = x11grab_read_close,
-    .flags          = AVFMT_NOFILE,
-    .priv_class     = &x11_class,
-};
diff --git a/mythtv/external/FFmpeg/libavdevice/xcbgrab.c b/mythtv/external/FFmpeg/libavdevice/xcbgrab.c
index 9da46c8e0da..1968fe02d4f 100644
--- a/mythtv/external/FFmpeg/libavdevice/xcbgrab.c
+++ b/mythtv/external/FFmpeg/libavdevice/xcbgrab.c
@@ -49,6 +49,8 @@
 typedef struct XCBGrabContext {
     const AVClass *class;
 
+    uint8_t *buffer;
+
     xcb_connection_t *conn;
     xcb_screen_t *screen;
     xcb_window_t window;
@@ -219,22 +221,16 @@ static int check_shm(xcb_connection_t *conn)
     return 0;
 }
 
-static void dealloc_shm(void *unused, uint8_t *data)
-{
-    shmdt(data);
-}
-
-static int xcbgrab_frame_shm(AVFormatContext *s, AVPacket *pkt)
+static int allocate_shm(AVFormatContext *s)
 {
     XCBGrabContext *c = s->priv_data;
-    xcb_shm_get_image_cookie_t iq;
-    xcb_shm_get_image_reply_t *img;
-    xcb_drawable_t drawable = c->screen->root;
-    uint8_t *data;
     int size = c->frame_size + AV_INPUT_BUFFER_PADDING_SIZE;
-    int id   = shmget(IPC_PRIVATE, size, IPC_CREAT | 0777);
-    xcb_generic_error_t *e = NULL;
+    uint8_t *data;
+    int id;
 
+    if (c->buffer)
+        return 0;
+    id = shmget(IPC_PRIVATE, size, IPC_CREAT | 0777);
     if (id == -1) {
         char errbuf[1024];
         int err = AVERROR(errno);
@@ -243,15 +239,31 @@ static int xcbgrab_frame_shm(AVFormatContext *s, AVPacket *pkt)
                size, errbuf);
         return err;
     }
-
     xcb_shm_attach(c->conn, c->segment, id, 0);
+    data = shmat(id, NULL, 0);
+    shmctl(id, IPC_RMID, 0);
+    if ((intptr_t)data == -1 || !data)
+        return AVERROR(errno);
+    c->buffer = data;
+    return 0;
+}
+
+static int xcbgrab_frame_shm(AVFormatContext *s, AVPacket *pkt)
+{
+    XCBGrabContext *c = s->priv_data;
+    xcb_shm_get_image_cookie_t iq;
+    xcb_shm_get_image_reply_t *img;
+    xcb_drawable_t drawable = c->screen->root;
+    xcb_generic_error_t *e = NULL;
+    int ret;
+
+    ret = allocate_shm(s);
+    if (ret < 0)
+        return ret;
 
     iq = xcb_shm_get_image(c->conn, drawable,
                            c->x, c->y, c->width, c->height, ~0,
                            XCB_IMAGE_FORMAT_Z_PIXMAP, c->segment, 0);
-
-    xcb_shm_detach(c->conn, c->segment);
-
     img = xcb_shm_get_image_reply(c->conn, iq, &e);
 
     xcb_flush(c->conn);
@@ -264,25 +276,12 @@ static int xcbgrab_frame_shm(AVFormatContext *s, AVPacket *pkt)
                e->response_type, e->error_code,
                e->sequence, e->resource_id, e->minor_code, e->major_code);
 
-        shmctl(id, IPC_RMID, 0);
         return AVERROR(EACCES);
     }
 
     free(img);
 
-    data = shmat(id, NULL, 0);
-    shmctl(id, IPC_RMID, 0);
-
-    if ((intptr_t)data == -1)
-        return AVERROR(errno);
-
-    pkt->buf = av_buffer_create(data, size, dealloc_shm, NULL, 0);
-    if (!pkt->buf) {
-        shmdt(data);
-        return AVERROR(ENOMEM);
-    }
-
-    pkt->data = pkt->buf->data;
+    pkt->data = c->buffer;
     pkt->size = c->frame_size;
 
     return 0;
@@ -436,6 +435,12 @@ static av_cold int xcbgrab_read_close(AVFormatContext *s)
 {
     XCBGrabContext *ctx = s->priv_data;
 
+#if CONFIG_LIBXCB_SHM
+    if (ctx->buffer) {
+        shmdt(ctx->buffer);
+    }
+#endif
+
     xcb_disconnect(ctx->conn);
 
     return 0;
@@ -504,7 +509,7 @@ static int pixfmt_from_pixmap_format(AVFormatContext *s, int depth,
 
         fmt++;
     }
-    av_log(s, AV_LOG_ERROR, "Pixmap format not mappable.\n");
+    avpriv_report_missing_feature(s, "Mapping this pixmap format");
 
     return AVERROR_PATCHWELCOME;
 }
@@ -685,7 +690,7 @@ static av_cold int xcbgrab_read_header(AVFormatContext *s)
     return 0;
 }
 
-AVInputFormat ff_x11grab_xcb_demuxer = {
+AVInputFormat ff_xcbgrab_demuxer = {
     .name           = "x11grab",
     .long_name      = NULL_IF_CONFIG_SMALL("X11 screen capture, using XCB"),
     .priv_data_size = sizeof(XCBGrabContext),
diff --git a/mythtv/external/FFmpeg/libavfilter/Makefile b/mythtv/external/FFmpeg/libavfilter/Makefile
index 7ed46966a29..d2f0495f371 100644
--- a/mythtv/external/FFmpeg/libavfilter/Makefile
+++ b/mythtv/external/FFmpeg/libavfilter/Makefile
@@ -1,6 +1,5 @@
-include $(SUBDIR)../config.mak
-
 NAME = avfilter
+DESC = FFmpeg audio/video filtering library
 
 HEADERS = avfilter.h                                                    \
           avfiltergraph.h                                               \
@@ -18,6 +17,7 @@ OBJS = allfilters.o                                                     \
        fifo.o                                                           \
        formats.o                                                        \
        framepool.o                                                      \
+       framequeue.o                                                     \
        graphdump.o                                                      \
        graphparser.o                                                    \
        opencl_allkernels.o                                              \
@@ -29,6 +29,7 @@ OBJS-$(HAVE_THREADS)                         += pthread.o
 # audio filters
 OBJS-$(CONFIG_ABENCH_FILTER)                 += f_bench.o
 OBJS-$(CONFIG_ACOMPRESSOR_FILTER)            += af_sidechaincompress.o
+OBJS-$(CONFIG_ACOPY_FILTER)                  += af_acopy.o
 OBJS-$(CONFIG_ACROSSFADE_FILTER)             += af_afade.o
 OBJS-$(CONFIG_ACRUSHER_FILTER)               += af_acrusher.o
 OBJS-$(CONFIG_ADELAY_FILTER)                 += af_adelay.o
@@ -36,7 +37,8 @@ OBJS-$(CONFIG_AECHO_FILTER)                  += af_aecho.o
 OBJS-$(CONFIG_AEMPHASIS_FILTER)              += af_aemphasis.o
 OBJS-$(CONFIG_AEVAL_FILTER)                  += aeval.o
 OBJS-$(CONFIG_AFADE_FILTER)                  += af_afade.o
-OBJS-$(CONFIG_AFFTFILT_FILTER)               += af_afftfilt.o window_func.o
+OBJS-$(CONFIG_AFFTFILT_FILTER)               += af_afftfilt.o
+OBJS-$(CONFIG_AFIR_FILTER)                   += af_afir.o
 OBJS-$(CONFIG_AFORMAT_FILTER)                += af_aformat.o
 OBJS-$(CONFIG_AGATE_FILTER)                  += af_agate.o
 OBJS-$(CONFIG_AINTERLEAVE_FILTER)            += f_interleave.o
@@ -65,8 +67,7 @@ OBJS-$(CONFIG_ASHOWINFO_FILTER)              += af_ashowinfo.o
 OBJS-$(CONFIG_ASIDEDATA_FILTER)              += f_sidedata.o
 OBJS-$(CONFIG_ASPLIT_FILTER)                 += split.o
 OBJS-$(CONFIG_ASTATS_FILTER)                 += af_astats.o
-OBJS-$(CONFIG_ASTREAMSELECT_FILTER)          += f_streamselect.o
-OBJS-$(CONFIG_ASYNCTS_FILTER)                += af_asyncts.o
+OBJS-$(CONFIG_ASTREAMSELECT_FILTER)          += f_streamselect.o framesync.o
 OBJS-$(CONFIG_ATEMPO_FILTER)                 += af_atempo.o
 OBJS-$(CONFIG_ATRIM_FILTER)                  += trim.o
 OBJS-$(CONFIG_AZMQ_FILTER)                   += f_zmq.o
@@ -80,6 +81,7 @@ OBJS-$(CONFIG_CHANNELSPLIT_FILTER)           += af_channelsplit.o
 OBJS-$(CONFIG_CHORUS_FILTER)                 += af_chorus.o generate_wave_table.o
 OBJS-$(CONFIG_COMPAND_FILTER)                += af_compand.o
 OBJS-$(CONFIG_COMPENSATIONDELAY_FILTER)      += af_compensationdelay.o
+OBJS-$(CONFIG_CROSSFEED_FILTER)              += af_crossfeed.o
 OBJS-$(CONFIG_CRYSTALIZER_FILTER)            += af_crystalizer.o
 OBJS-$(CONFIG_DCSHIFT_FILTER)                += af_dcshift.o
 OBJS-$(CONFIG_DYNAUDNORM_FILTER)             += af_dynaudnorm.o
@@ -89,11 +91,13 @@ OBJS-$(CONFIG_EQUALIZER_FILTER)              += af_biquads.o
 OBJS-$(CONFIG_EXTRASTEREO_FILTER)            += af_extrastereo.o
 OBJS-$(CONFIG_FIREQUALIZER_FILTER)           += af_firequalizer.o
 OBJS-$(CONFIG_FLANGER_FILTER)                += af_flanger.o generate_wave_table.o
+OBJS-$(CONFIG_HAAS_FILTER)                   += af_haas.o
 OBJS-$(CONFIG_HDCD_FILTER)                   += af_hdcd.o
+OBJS-$(CONFIG_HEADPHONE_FILTER)              += af_headphone.o
 OBJS-$(CONFIG_HIGHPASS_FILTER)               += af_biquads.o
 OBJS-$(CONFIG_JOIN_FILTER)                   += af_join.o
 OBJS-$(CONFIG_LADSPA_FILTER)                 += af_ladspa.o
-OBJS-$(CONFIG_LOUDNORM_FILTER)               += af_loudnorm.o
+OBJS-$(CONFIG_LOUDNORM_FILTER)               += af_loudnorm.o ebur128.o
 OBJS-$(CONFIG_LOWPASS_FILTER)                += af_biquads.o
 OBJS-$(CONFIG_PAN_FILTER)                    += af_pan.o
 OBJS-$(CONFIG_REPLAYGAIN_FILTER)             += af_replaygain.o
@@ -106,6 +110,8 @@ OBJS-$(CONFIG_SILENCEREMOVE_FILTER)          += af_silenceremove.o
 OBJS-$(CONFIG_SOFALIZER_FILTER)              += af_sofalizer.o
 OBJS-$(CONFIG_STEREOTOOLS_FILTER)            += af_stereotools.o
 OBJS-$(CONFIG_STEREOWIDEN_FILTER)            += af_stereowiden.o
+OBJS-$(CONFIG_SUPEREQUALIZER_FILTER)         += af_superequalizer.o
+OBJS-$(CONFIG_SURROUND_FILTER)               += af_surround.o
 OBJS-$(CONFIG_TREBLE_FILTER)                 += af_biquads.o
 OBJS-$(CONFIG_TREMOLO_FILTER)                += af_tremolo.o
 OBJS-$(CONFIG_VIBRATO_FILTER)                += af_vibrato.o generate_wave_table.o
@@ -131,7 +137,7 @@ OBJS-$(CONFIG_BENCH_FILTER)                  += f_bench.o
 OBJS-$(CONFIG_BITPLANENOISE_FILTER)          += vf_bitplanenoise.o
 OBJS-$(CONFIG_BLACKDETECT_FILTER)            += vf_blackdetect.o
 OBJS-$(CONFIG_BLACKFRAME_FILTER)             += vf_blackframe.o
-OBJS-$(CONFIG_BLEND_FILTER)                  += vf_blend.o dualinput.o framesync.o
+OBJS-$(CONFIG_BLEND_FILTER)                  += vf_blend.o framesync.o
 OBJS-$(CONFIG_BOXBLUR_FILTER)                += vf_boxblur.o
 OBJS-$(CONFIG_BWDIF_FILTER)                  += vf_bwdif.o
 OBJS-$(CONFIG_CHROMAKEY_FILTER)              += vf_chromakey.o
@@ -144,6 +150,7 @@ OBJS-$(CONFIG_COLORLEVELS_FILTER)            += vf_colorlevels.o
 OBJS-$(CONFIG_COLORMATRIX_FILTER)            += vf_colormatrix.o
 OBJS-$(CONFIG_COLORSPACE_FILTER)             += vf_colorspace.o colorspacedsp.o
 OBJS-$(CONFIG_CONVOLUTION_FILTER)            += vf_convolution.o
+OBJS-$(CONFIG_CONVOLVE_FILTER)               += vf_convolve.o framesync.o
 OBJS-$(CONFIG_COPY_FILTER)                   += vf_copy.o
 OBJS-$(CONFIG_COREIMAGE_FILTER)              += vf_coreimage.o
 OBJS-$(CONFIG_COVER_RECT_FILTER)             += vf_cover_rect.o lavfutils.o
@@ -155,12 +162,17 @@ OBJS-$(CONFIG_DCTDNOIZ_FILTER)               += vf_dctdnoiz.o
 OBJS-$(CONFIG_DEBAND_FILTER)                 += vf_deband.o
 OBJS-$(CONFIG_DECIMATE_FILTER)               += vf_decimate.o
 OBJS-$(CONFIG_DEFLATE_FILTER)                += vf_neighbor.o
+OBJS-$(CONFIG_DEFLICKER_FILTER)              += vf_deflicker.o
+OBJS-$(CONFIG_DEINTERLACE_QSV_FILTER)        += vf_deinterlace_qsv.o
+OBJS-$(CONFIG_DEINTERLACE_VAAPI_FILTER)      += vf_deinterlace_vaapi.o
 OBJS-$(CONFIG_DEJUDDER_FILTER)               += vf_dejudder.o
 OBJS-$(CONFIG_DELOGO_FILTER)                 += vf_delogo.o
 OBJS-$(CONFIG_DESHAKE_FILTER)                += vf_deshake.o
+OBJS-$(CONFIG_DESPILL_FILTER)                += vf_despill.o
 OBJS-$(CONFIG_DETELECINE_FILTER)             += vf_detelecine.o
 OBJS-$(CONFIG_DILATION_FILTER)               += vf_neighbor.o
 OBJS-$(CONFIG_DISPLACE_FILTER)               += vf_displace.o framesync.o
+OBJS-$(CONFIG_DOUBLEWEAVE_FILTER)            += vf_weave.o
 OBJS-$(CONFIG_DRAWBOX_FILTER)                += vf_drawbox.o
 OBJS-$(CONFIG_DRAWGRAPH_FILTER)              += f_drawgraph.o
 OBJS-$(CONFIG_DRAWGRID_FILTER)               += vf_drawbox.o
@@ -177,6 +189,7 @@ OBJS-$(CONFIG_FIELDHINT_FILTER)              += vf_fieldhint.o
 OBJS-$(CONFIG_FIELDMATCH_FILTER)             += vf_fieldmatch.o
 OBJS-$(CONFIG_FIELDORDER_FILTER)             += vf_fieldorder.o
 OBJS-$(CONFIG_FIND_RECT_FILTER)              += vf_find_rect.o lavfutils.o
+OBJS-$(CONFIG_FLOODFILL_FILTER)              += vf_floodfill.o
 OBJS-$(CONFIG_FORMAT_FILTER)                 += vf_format.o
 OBJS-$(CONFIG_FPS_FILTER)                    += vf_fps.o
 OBJS-$(CONFIG_FRAMEPACK_FILTER)              += vf_framepack.o
@@ -187,7 +200,7 @@ OBJS-$(CONFIG_FSPP_FILTER)                   += vf_fspp.o
 OBJS-$(CONFIG_GBLUR_FILTER)                  += vf_gblur.o
 OBJS-$(CONFIG_GEQ_FILTER)                    += vf_geq.o
 OBJS-$(CONFIG_GRADFUN_FILTER)                += vf_gradfun.o
-OBJS-$(CONFIG_HALDCLUT_FILTER)               += vf_lut3d.o dualinput.o framesync.o
+OBJS-$(CONFIG_HALDCLUT_FILTER)               += vf_lut3d.o framesync.o
 OBJS-$(CONFIG_HFLIP_FILTER)                  += vf_hflip.o
 OBJS-$(CONFIG_HISTEQ_FILTER)                 += vf_histeq.o
 OBJS-$(CONFIG_HISTOGRAM_FILTER)              += vf_histogram.o
@@ -196,6 +209,7 @@ OBJS-$(CONFIG_HQX_FILTER)                    += vf_hqx.o
 OBJS-$(CONFIG_HSTACK_FILTER)                 += vf_stack.o framesync.o
 OBJS-$(CONFIG_HUE_FILTER)                    += vf_hue.o
 OBJS-$(CONFIG_HWDOWNLOAD_FILTER)             += vf_hwdownload.o
+OBJS-$(CONFIG_HWMAP_FILTER)                  += vf_hwmap.o
 OBJS-$(CONFIG_HWUPLOAD_CUDA_FILTER)          += vf_hwupload_cuda.o
 OBJS-$(CONFIG_HWUPLOAD_FILTER)               += vf_hwupload.o
 OBJS-$(CONFIG_HYSTERESIS_FILTER)             += vf_hysteresis.o framesync.o
@@ -206,7 +220,10 @@ OBJS-$(CONFIG_INTERLACE_FILTER)              += vf_interlace.o
 OBJS-$(CONFIG_INTERLEAVE_FILTER)             += f_interleave.o
 OBJS-$(CONFIG_KERNDEINT_FILTER)              += vf_kerndeint.o
 OBJS-$(CONFIG_LENSCORRECTION_FILTER)         += vf_lenscorrection.o
+OBJS-$(CONFIG_LIBVMAF_FILTER)                += vf_libvmaf.o framesync.o
+OBJS-$(CONFIG_LIMITER_FILTER)                += vf_limiter.o
 OBJS-$(CONFIG_LOOP_FILTER)                   += f_loop.o
+OBJS-$(CONFIG_LUMAKEY_FILTER)                += vf_lumakey.o
 OBJS-$(CONFIG_LUT_FILTER)                    += vf_lut.o
 OBJS-$(CONFIG_LUT2_FILTER)                   += vf_lut2.o framesync.o
 OBJS-$(CONFIG_LUT3D_FILTER)                  += vf_lut3d.o
@@ -218,6 +235,7 @@ OBJS-$(CONFIG_MCDEINT_FILTER)                += vf_mcdeint.o
 OBJS-$(CONFIG_MERGEPLANES_FILTER)            += vf_mergeplanes.o framesync.o
 OBJS-$(CONFIG_MESTIMATE_FILTER)              += vf_mestimate.o motion_estimation.o
 OBJS-$(CONFIG_METADATA_FILTER)               += f_metadata.o
+OBJS-$(CONFIG_MIDEQUALIZER_FILTER)           += vf_midequalizer.o framesync.o
 OBJS-$(CONFIG_MINTERPOLATE_FILTER)           += vf_minterpolate.o motion_estimation.o
 OBJS-$(CONFIG_MPDECIMATE_FILTER)             += vf_mpdecimate.o
 OBJS-$(CONFIG_NEGATE_FILTER)                 += vf_lut.o
@@ -229,22 +247,27 @@ OBJS-$(CONFIG_NULL_FILTER)                   += vf_null.o
 OBJS-$(CONFIG_OCR_FILTER)                    += vf_ocr.o
 OBJS-$(CONFIG_OCV_FILTER)                    += vf_libopencv.o
 OBJS-$(CONFIG_OPENCL)                        += deshake_opencl.o unsharp_opencl.o
-OBJS-$(CONFIG_OVERLAY_FILTER)                += vf_overlay.o dualinput.o framesync.o
+OBJS-$(CONFIG_OSCILLOSCOPE_FILTER)           += vf_datascope.o
+OBJS-$(CONFIG_OVERLAY_FILTER)                += vf_overlay.o framesync.o
 OBJS-$(CONFIG_OWDENOISE_FILTER)              += vf_owdenoise.o
 OBJS-$(CONFIG_PAD_FILTER)                    += vf_pad.o
 OBJS-$(CONFIG_PALETTEGEN_FILTER)             += vf_palettegen.o
-OBJS-$(CONFIG_PALETTEUSE_FILTER)             += vf_paletteuse.o dualinput.o framesync.o
+OBJS-$(CONFIG_PALETTEUSE_FILTER)             += vf_paletteuse.o framesync.o
 OBJS-$(CONFIG_PERMS_FILTER)                  += f_perms.o
 OBJS-$(CONFIG_PERSPECTIVE_FILTER)            += vf_perspective.o
 OBJS-$(CONFIG_PHASE_FILTER)                  += vf_phase.o
 OBJS-$(CONFIG_PIXDESCTEST_FILTER)            += vf_pixdesctest.o
+OBJS-$(CONFIG_PIXSCOPE_FILTER)               += vf_datascope.o
 OBJS-$(CONFIG_PP_FILTER)                     += vf_pp.o
 OBJS-$(CONFIG_PP7_FILTER)                    += vf_pp7.o
+OBJS-$(CONFIG_PREMULTIPLY_FILTER)            += vf_premultiply.o framesync.o
 OBJS-$(CONFIG_PREWITT_FILTER)                += vf_convolution.o
-OBJS-$(CONFIG_PSNR_FILTER)                   += vf_psnr.o dualinput.o framesync.o
+OBJS-$(CONFIG_PSEUDOCOLOR_FILTER)            += vf_pseudocolor.o
+OBJS-$(CONFIG_PSNR_FILTER)                   += vf_psnr.o framesync.o
 OBJS-$(CONFIG_PULLUP_FILTER)                 += vf_pullup.o
 OBJS-$(CONFIG_QP_FILTER)                     += vf_qp.o
 OBJS-$(CONFIG_RANDOM_FILTER)                 += vf_random.o
+OBJS-$(CONFIG_READEIA608_FILTER)             += vf_readeia608.o
 OBJS-$(CONFIG_READVITC_FILTER)               += vf_readvitc.o
 OBJS-$(CONFIG_REALTIME_FILTER)               += f_realtime.o
 OBJS-$(CONFIG_REMAP_FILTER)                  += vf_remap.o framesync.o
@@ -252,12 +275,15 @@ OBJS-$(CONFIG_REMOVEGRAIN_FILTER)            += vf_removegrain.o
 OBJS-$(CONFIG_REMOVELOGO_FILTER)             += bbox.o lswsutils.o lavfutils.o vf_removelogo.o
 OBJS-$(CONFIG_REPEATFIELDS_FILTER)           += vf_repeatfields.o
 OBJS-$(CONFIG_REVERSE_FILTER)                += f_reverse.o
+OBJS-$(CONFIG_ROBERTS_FILTER)                += vf_convolution.o
 OBJS-$(CONFIG_ROTATE_FILTER)                 += vf_rotate.o
 OBJS-$(CONFIG_SAB_FILTER)                    += vf_sab.o
-OBJS-$(CONFIG_SCALE_FILTER)                  += vf_scale.o
-OBJS-$(CONFIG_SCALE_NPP_FILTER)              += vf_scale_npp.o
-OBJS-$(CONFIG_SCALE_VAAPI_FILTER)            += vf_scale_vaapi.o
-OBJS-$(CONFIG_SCALE2REF_FILTER)              += vf_scale.o
+OBJS-$(CONFIG_SCALE_FILTER)                  += vf_scale.o scale.o
+OBJS-$(CONFIG_SCALE_CUDA_FILTER)             += vf_scale_cuda.o vf_scale_cuda.ptx.o
+OBJS-$(CONFIG_SCALE_NPP_FILTER)              += vf_scale_npp.o scale.o
+OBJS-$(CONFIG_SCALE_QSV_FILTER)              += vf_scale_qsv.o
+OBJS-$(CONFIG_SCALE_VAAPI_FILTER)            += vf_scale_vaapi.o scale.o
+OBJS-$(CONFIG_SCALE2REF_FILTER)              += vf_scale.o scale.o
 OBJS-$(CONFIG_SELECT_FILTER)                 += f_select.o
 OBJS-$(CONFIG_SELECTIVECOLOR_FILTER)         += vf_selectivecolor.o
 OBJS-$(CONFIG_SENDCMD_FILTER)                += f_sendcmd.o
@@ -273,24 +299,30 @@ OBJS-$(CONFIG_SHUFFLEFRAMES_FILTER)          += vf_shuffleframes.o
 OBJS-$(CONFIG_SHUFFLEPLANES_FILTER)          += vf_shuffleplanes.o
 OBJS-$(CONFIG_SIDEDATA_FILTER)               += f_sidedata.o
 OBJS-$(CONFIG_SIGNALSTATS_FILTER)            += vf_signalstats.o
+OBJS-$(CONFIG_SIGNATURE_FILTER)              += vf_signature.o
 OBJS-$(CONFIG_SMARTBLUR_FILTER)              += vf_smartblur.o
 OBJS-$(CONFIG_SOBEL_FILTER)                  += vf_convolution.o
 OBJS-$(CONFIG_SPLIT_FILTER)                  += split.o
 OBJS-$(CONFIG_SPP_FILTER)                    += vf_spp.o
-OBJS-$(CONFIG_SSIM_FILTER)                   += vf_ssim.o dualinput.o framesync.o
+OBJS-$(CONFIG_SSIM_FILTER)                   += vf_ssim.o framesync.o
 OBJS-$(CONFIG_STEREO3D_FILTER)               += vf_stereo3d.o
-OBJS-$(CONFIG_STREAMSELECT_FILTER)           += f_streamselect.o
+OBJS-$(CONFIG_STREAMSELECT_FILTER)           += f_streamselect.o framesync.o
 OBJS-$(CONFIG_SUBTITLES_FILTER)              += vf_subtitles.o
 OBJS-$(CONFIG_SUPER2XSAI_FILTER)             += vf_super2xsai.o
 OBJS-$(CONFIG_SWAPRECT_FILTER)               += vf_swaprect.o
 OBJS-$(CONFIG_SWAPUV_FILTER)                 += vf_swapuv.o
-OBJS-$(CONFIG_TBLEND_FILTER)                 += vf_blend.o dualinput.o framesync.o
+OBJS-$(CONFIG_TBLEND_FILTER)                 += vf_blend.o framesync.o
 OBJS-$(CONFIG_TELECINE_FILTER)               += vf_telecine.o
+OBJS-$(CONFIG_THRESHOLD_FILTER)              += vf_threshold.o framesync.o
 OBJS-$(CONFIG_THUMBNAIL_FILTER)              += vf_thumbnail.o
+OBJS-$(CONFIG_THUMBNAIL_CUDA_FILTER)         += vf_thumbnail_cuda.o vf_thumbnail_cuda.ptx.o
 OBJS-$(CONFIG_TILE_FILTER)                   += vf_tile.o
 OBJS-$(CONFIG_TINTERLACE_FILTER)             += vf_tinterlace.o
+OBJS-$(CONFIG_TLUT2_FILTER)                  += vf_lut2.o framesync.o
+OBJS-$(CONFIG_TONEMAP_FILTER)                += vf_tonemap.o
 OBJS-$(CONFIG_TRANSPOSE_FILTER)              += vf_transpose.o
 OBJS-$(CONFIG_TRIM_FILTER)                   += trim.o
+OBJS-$(CONFIG_UNPREMULTIPLY_FILTER)          += vf_premultiply.o framesync.o
 OBJS-$(CONFIG_UNSHARP_FILTER)                += vf_unsharp.o
 OBJS-$(CONFIG_USPP_FILTER)                   += vf_uspp.o
 OBJS-$(CONFIG_VAGUEDENOISER_FILTER)          += vf_vaguedenoiser.o
@@ -299,6 +331,7 @@ OBJS-$(CONFIG_VFLIP_FILTER)                  += vf_vflip.o
 OBJS-$(CONFIG_VIDSTABDETECT_FILTER)          += vidstabutils.o vf_vidstabdetect.o
 OBJS-$(CONFIG_VIDSTABTRANSFORM_FILTER)       += vidstabutils.o vf_vidstabtransform.o
 OBJS-$(CONFIG_VIGNETTE_FILTER)               += vf_vignette.o
+OBJS-$(CONFIG_VMAFMOTION_FILTER)             += vf_vmafmotion.o framesync.o
 OBJS-$(CONFIG_VSTACK_FILTER)                 += vf_stack.o framesync.o
 OBJS-$(CONFIG_W3FDIF_FILTER)                 += vf_w3fdif.o
 OBJS-$(CONFIG_WAVEFORM_FILTER)               += vf_waveform.o
@@ -330,19 +363,20 @@ OBJS-$(CONFIG_YUVTESTSRC_FILTER)             += vsrc_testsrc.o
 OBJS-$(CONFIG_NULLSINK_FILTER)               += vsink_nullsink.o
 
 # multimedia filters
+OBJS-$(CONFIG_ABITSCOPE_FILTER)              += avf_abitscope.o
 OBJS-$(CONFIG_ADRAWGRAPH_FILTER)             += f_drawgraph.o
 OBJS-$(CONFIG_AHISTOGRAM_FILTER)             += avf_ahistogram.o
 OBJS-$(CONFIG_APHASEMETER_FILTER)            += avf_aphasemeter.o
 OBJS-$(CONFIG_AVECTORSCOPE_FILTER)           += avf_avectorscope.o
 OBJS-$(CONFIG_CONCAT_FILTER)                 += avf_concat.o
 OBJS-$(CONFIG_SHOWCQT_FILTER)                += avf_showcqt.o lswsutils.o lavfutils.o
-OBJS-$(CONFIG_SHOWFREQS_FILTER)              += avf_showfreqs.o window_func.o
-OBJS-$(CONFIG_SHOWSPECTRUM_FILTER)           += avf_showspectrum.o window_func.o
-OBJS-$(CONFIG_SHOWSPECTRUMPIC_FILTER)        += avf_showspectrum.o window_func.o
+OBJS-$(CONFIG_SHOWFREQS_FILTER)              += avf_showfreqs.o
+OBJS-$(CONFIG_SHOWSPECTRUM_FILTER)           += avf_showspectrum.o
+OBJS-$(CONFIG_SHOWSPECTRUMPIC_FILTER)        += avf_showspectrum.o
 OBJS-$(CONFIG_SHOWVOLUME_FILTER)             += avf_showvolume.o
 OBJS-$(CONFIG_SHOWWAVES_FILTER)              += avf_showwaves.o
 OBJS-$(CONFIG_SHOWWAVESPIC_FILTER)           += avf_showwaves.o
-OBJS-$(CONFIG_SPECTRUMSYNTH_FILTER)          += vaf_spectrumsynth.o window_func.o
+OBJS-$(CONFIG_SPECTRUMSYNTH_FILTER)          += vaf_spectrumsynth.o
 
 # multimedia sources
 OBJS-$(CONFIG_AMOVIE_FILTER)                 += src_movie.o
diff --git a/mythtv/external/FFmpeg/libavfilter/aeval.c b/mythtv/external/FFmpeg/libavfilter/aeval.c
index ac9dea8f64a..cdddbaf31d4 100644
--- a/mythtv/external/FFmpeg/libavfilter/aeval.c
+++ b/mythtv/external/FFmpeg/libavfilter/aeval.c
@@ -53,7 +53,7 @@ enum var_name {
     VAR_VARS_NB
 };
 
-typedef struct {
+typedef struct EvalContext {
     const AVClass *class;
     char *sample_rate_str;
     int sample_rate;
@@ -277,16 +277,24 @@ static int request_frame(AVFilterLink *outlink)
     AVFrame *samplesref;
     int i, j;
     int64_t t = av_rescale(eval->n, AV_TIME_BASE, eval->sample_rate);
+    int nb_samples;
 
     if (eval->duration >= 0 && t >= eval->duration)
         return AVERROR_EOF;
 
-    samplesref = ff_get_audio_buffer(outlink, eval->nb_samples);
+    if (eval->duration >= 0) {
+        nb_samples = FFMIN(eval->nb_samples, av_rescale(eval->duration, eval->sample_rate, AV_TIME_BASE) - eval->pts);
+        if (!nb_samples)
+            return AVERROR_EOF;
+    } else {
+        nb_samples = eval->nb_samples;
+    }
+    samplesref = ff_get_audio_buffer(outlink, nb_samples);
     if (!samplesref)
         return AVERROR(ENOMEM);
 
     /* evaluate expression for each single sample and for each channel */
-    for (i = 0; i < eval->nb_samples; i++, eval->n++) {
+    for (i = 0; i < nb_samples; i++, eval->n++) {
         eval->var_values[VAR_N] = eval->n;
         eval->var_values[VAR_T] = eval->var_values[VAR_N] * (double)1/eval->sample_rate;
 
@@ -298,7 +306,7 @@ static int request_frame(AVFilterLink *outlink)
 
     samplesref->pts = eval->pts;
     samplesref->sample_rate = eval->sample_rate;
-    eval->pts += eval->nb_samples;
+    eval->pts += nb_samples;
 
     return ff_filter_frame(outlink, samplesref);
 }
@@ -419,10 +427,11 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     double t0;
     int i, j;
 
-    /* do volume scaling in-place if input buffer is writable */
     out = ff_get_audio_buffer(outlink, nb_samples);
-    if (!out)
+    if (!out) {
+        av_frame_free(&in);
         return AVERROR(ENOMEM);
+    }
     av_frame_copy_props(out, in);
 
     t0 = TS2T(in->pts, inlink->time_base);
diff --git a/mythtv/external/FFmpeg/libavfilter/af_acopy.c b/mythtv/external/FFmpeg/libavfilter/af_acopy.c
new file mode 100644
index 00000000000..d8490609663
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/af_acopy.c
@@ -0,0 +1,60 @@
+/*
+ * 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 "audio.h"
+#include "avfilter.h"
+#include "internal.h"
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterLink *outlink = inlink->dst->outputs[0];
+    AVFrame *out = ff_get_audio_buffer(outlink, in->nb_samples);
+
+    if (!out) {
+        av_frame_free(&in);
+        return AVERROR(ENOMEM);
+    }
+    av_frame_copy_props(out, in);
+    av_frame_copy(out, in);
+    av_frame_free(&in);
+    return ff_filter_frame(outlink, out);
+}
+
+static const AVFilterPad acopy_inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_AUDIO,
+        .filter_frame = filter_frame,
+    },
+    { NULL }
+};
+
+static const AVFilterPad acopy_outputs[] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_AUDIO,
+    },
+    { NULL }
+};
+
+AVFilter ff_af_acopy = {
+    .name          = "acopy",
+    .description   = NULL_IF_CONFIG_SMALL("Copy the input audio unchanged to the output."),
+    .inputs        = acopy_inputs,
+    .outputs       = acopy_outputs,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/af_adelay.c b/mythtv/external/FFmpeg/libavfilter/af_adelay.c
index 187cacf28af..983f089c21b 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_adelay.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_adelay.c
@@ -171,11 +171,6 @@ static int config_input(AVFilterLink *inlink)
         s->max_delay = FFMAX(s->max_delay, d->delay);
     }
 
-    if (!s->max_delay) {
-        av_log(ctx, AV_LOG_ERROR, "At least one delay >0 must be specified.\n");
-        return AVERROR(EINVAL);
-    }
-
     switch (inlink->format) {
     case AV_SAMPLE_FMT_U8P : s->delay_channel = delay_channel_u8p ; break;
     case AV_SAMPLE_FMT_S16P: s->delay_channel = delay_channel_s16p; break;
diff --git a/mythtv/external/FFmpeg/libavfilter/af_aecho.c b/mythtv/external/FFmpeg/libavfilter/af_aecho.c
index 82049e95411..cfaea3de430 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_aecho.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_aecho.c
@@ -77,7 +77,8 @@ static void fill_items(char *item_str, int *nb_items, float *items)
     for (i = 0; i < *nb_items; i++) {
         char *tstr = av_strtok(p, "|", &saveptr);
         p = NULL;
-        new_nb_items += sscanf(tstr, "%f", &items[i]) == 1;
+        if (tstr)
+            new_nb_items += sscanf(tstr, "%f", &items[new_nb_items]) == 1;
     }
 
     *nb_items = new_nb_items;
diff --git a/mythtv/external/FFmpeg/libavfilter/af_afade.c b/mythtv/external/FFmpeg/libavfilter/af_afade.c
index 9acadc51c50..7ad124e887b 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_afade.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_afade.c
@@ -29,11 +29,11 @@
 #include "avfilter.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct AudioFadeContext {
     const AVClass *class;
     int type;
     int curve, curve2;
-    int nb_samples;
+    int64_t nb_samples;
     int64_t start_sample;
     int64_t duration;
     int64_t start_time;
@@ -45,7 +45,7 @@ typedef struct {
 
     void (*fade_samples)(uint8_t **dst, uint8_t * const *src,
                          int nb_samples, int channels, int direction,
-                         int64_t start, int range, int curve);
+                         int64_t start, int64_t range, int curve);
     void (*crossfade_samples)(uint8_t **dst, uint8_t * const *cf0,
                               uint8_t * const *cf1,
                               int nb_samples, int channels,
@@ -90,7 +90,7 @@ static int query_formats(AVFilterContext *ctx)
     return ff_set_common_samplerates(ctx, formats);
 }
 
-static double fade_gain(int curve, int64_t index, int range)
+static double fade_gain(int curve, int64_t index, int64_t range)
 {
 #define CUBE(a) ((a)*(a)*(a))
     double gain;
@@ -154,7 +154,7 @@ static double fade_gain(int curve, int64_t index, int range)
 #define FADE_PLANAR(name, type)                                             \
 static void fade_samples_## name ##p(uint8_t **dst, uint8_t * const *src,   \
                                      int nb_samples, int channels, int dir, \
-                                     int64_t start, int range, int curve)   \
+                                     int64_t start, int64_t range, int curve) \
 {                                                                           \
     int i, c;                                                               \
                                                                             \
@@ -172,7 +172,7 @@ static void fade_samples_## name ##p(uint8_t **dst, uint8_t * const *src,   \
 #define FADE(name, type)                                                    \
 static void fade_samples_## name (uint8_t **dst, uint8_t * const *src,      \
                                   int nb_samples, int channels, int dir,    \
-                                  int64_t start, int range, int curve)      \
+                                  int64_t start, int64_t range, int curve)  \
 {                                                                           \
     type *d = (type *)dst[0];                                               \
     const type *s = (type *)src[0];                                         \
@@ -228,10 +228,10 @@ static const AVOption afade_options[] = {
     { "out",          "fade-out",                                    0,                    AV_OPT_TYPE_CONST,  {.i64 = 1    }, 0, 0, FLAGS, "type" },
     { "start_sample", "set number of first sample to start fading",  OFFSET(start_sample), AV_OPT_TYPE_INT64,  {.i64 = 0    }, 0, INT64_MAX, FLAGS },
     { "ss",           "set number of first sample to start fading",  OFFSET(start_sample), AV_OPT_TYPE_INT64,  {.i64 = 0    }, 0, INT64_MAX, FLAGS },
-    { "nb_samples",   "set number of samples for fade duration",     OFFSET(nb_samples),   AV_OPT_TYPE_INT,    {.i64 = 44100}, 1, INT32_MAX, FLAGS },
-    { "ns",           "set number of samples for fade duration",     OFFSET(nb_samples),   AV_OPT_TYPE_INT,    {.i64 = 44100}, 1, INT32_MAX, FLAGS },
-    { "start_time",   "set time to start fading",                    OFFSET(start_time),   AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT32_MAX, FLAGS },
-    { "st",           "set time to start fading",                    OFFSET(start_time),   AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT32_MAX, FLAGS },
+    { "nb_samples",   "set number of samples for fade duration",     OFFSET(nb_samples),   AV_OPT_TYPE_INT64,  {.i64 = 44100}, 1, INT64_MAX, FLAGS },
+    { "ns",           "set number of samples for fade duration",     OFFSET(nb_samples),   AV_OPT_TYPE_INT64,  {.i64 = 44100}, 1, INT64_MAX, FLAGS },
+    { "start_time",   "set time to start fading",                    OFFSET(start_time),   AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT64_MAX, FLAGS },
+    { "st",           "set time to start fading",                    OFFSET(start_time),   AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT64_MAX, FLAGS },
     { "duration",     "set fade duration",                           OFFSET(duration),     AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT32_MAX, FLAGS },
     { "d",            "set fade duration",                           OFFSET(duration),     AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT32_MAX, FLAGS },
     { "curve",        "set fade curve type",                         OFFSET(curve),        AV_OPT_TYPE_INT,    {.i64 = TRI  }, 0, NB_CURVES - 1, FLAGS, "curve" },
@@ -291,7 +291,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
     if ((!s->type && (cur_sample + nb_samples < s->start_sample)) ||
         ( s->type && (s->start_sample + s->nb_samples < cur_sample))) {
         av_samples_set_silence(out_buf->extended_data, 0, nb_samples,
-                               av_frame_get_channels(out_buf), out_buf->format);
+                               out_buf->channels, out_buf->format);
     } else {
         int64_t start;
 
@@ -301,7 +301,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
             start = s->start_sample + s->nb_samples - cur_sample;
 
         s->fade_samples(out_buf->extended_data, buf->extended_data,
-                        nb_samples, av_frame_get_channels(buf),
+                        nb_samples, buf->channels,
                         s->type ? -1 : 1, start,
                         s->nb_samples, s->curve);
     }
@@ -498,7 +498,7 @@ static int acrossfade_filter_frame(AVFilterLink *inlink, AVFrame *in)
 
             s->crossfade_samples(out->extended_data, cf[0]->extended_data,
                                  cf[1]->extended_data,
-                                 s->nb_samples, av_frame_get_channels(in),
+                                 s->nb_samples, in->channels,
                                  s->curve, s->curve2);
             out->pts = s->pts;
             s->pts += av_rescale_q(s->nb_samples,
diff --git a/mythtv/external/FFmpeg/libavfilter/af_afftfilt.c b/mythtv/external/FFmpeg/libavfilter/af_afftfilt.c
index 3fc1a1b4c92..52755a1fb42 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_afftfilt.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_afftfilt.c
@@ -166,7 +166,7 @@ static int config_input(AVFilterLink *inlink)
                                       sizeof(*s->window_func_lut));
     if (!s->window_func_lut)
         return AVERROR(ENOMEM);
-    ff_generate_window_func(s->window_func_lut, s->window_size, s->win_func, &overlap);
+    generate_window_func(s->window_func_lut, s->window_size, s->win_func, &overlap);
     if (s->overlap == 1)
         s->overlap = overlap;
 
@@ -371,6 +371,9 @@ static av_cold void uninit(AVFilterContext *ctx)
     av_freep(&s->real);
     av_freep(&s->imag);
     av_frame_free(&s->buffer);
+    av_freep(&s->window_func_lut);
+
+    av_audio_fifo_free(s->fifo);
 }
 
 static const AVFilterPad inputs[] = {
diff --git a/mythtv/external/FFmpeg/libavfilter/af_afir.c b/mythtv/external/FFmpeg/libavfilter/af_afir.c
new file mode 100644
index 00000000000..c4443fdffdd
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/af_afir.c
@@ -0,0 +1,535 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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
+ * An arbitrary audio FIR filter
+ */
+
+#include "libavutil/audio_fifo.h"
+#include "libavutil/common.h"
+#include "libavutil/float_dsp.h"
+#include "libavutil/opt.h"
+#include "libavcodec/avfft.h"
+
+#include "audio.h"
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "af_afir.h"
+
+static void fcmul_add_c(float *sum, const float *t, const float *c, ptrdiff_t len)
+{
+    int n;
+
+    for (n = 0; n < len; n++) {
+        const float cre = c[2 * n    ];
+        const float cim = c[2 * n + 1];
+        const float tre = t[2 * n    ];
+        const float tim = t[2 * n + 1];
+
+        sum[2 * n    ] += tre * cre - tim * cim;
+        sum[2 * n + 1] += tre * cim + tim * cre;
+    }
+
+    sum[2 * n] += t[2 * n] * c[2 * n];
+}
+
+static int fir_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)
+{
+    AudioFIRContext *s = ctx->priv;
+    const float *src = (const float *)s->in[0]->extended_data[ch];
+    int index1 = (s->index + 1) % 3;
+    int index2 = (s->index + 2) % 3;
+    float *sum = s->sum[ch];
+    AVFrame *out = arg;
+    float *block;
+    float *dst;
+    int n, i, j;
+
+    memset(sum, 0, sizeof(*sum) * s->fft_length);
+    block = s->block[ch] + s->part_index * s->block_size;
+    memset(block, 0, sizeof(*block) * s->fft_length);
+
+    s->fdsp->vector_fmul_scalar(block + s->part_size, src, s->dry_gain, FFALIGN(s->nb_samples, 4));
+    emms_c();
+
+    av_rdft_calc(s->rdft[ch], block);
+    block[2 * s->part_size] = block[1];
+    block[1] = 0;
+
+    j = s->part_index;
+
+    for (i = 0; i < s->nb_partitions; i++) {
+        const int coffset = i * s->coeff_size;
+        const FFTComplex *coeff = s->coeff[ch * !s->one2many] + coffset;
+
+        block = s->block[ch] + j * s->block_size;
+        s->fcmul_add(sum, block, (const float *)coeff, s->part_size);
+
+        if (j == 0)
+            j = s->nb_partitions;
+        j--;
+    }
+
+    sum[1] = sum[2 * s->part_size];
+    av_rdft_calc(s->irdft[ch], sum);
+
+    dst = (float *)s->buffer->extended_data[ch] + index1 * s->part_size;
+    for (n = 0; n < s->part_size; n++) {
+        dst[n] += sum[n];
+    }
+
+    dst = (float *)s->buffer->extended_data[ch] + index2 * s->part_size;
+
+    memcpy(dst, sum + s->part_size, s->part_size * sizeof(*dst));
+
+    dst = (float *)s->buffer->extended_data[ch] + s->index * s->part_size;
+
+    if (out) {
+        float *ptr = (float *)out->extended_data[ch];
+        s->fdsp->vector_fmul_scalar(ptr, dst, s->gain * s->wet_gain, FFALIGN(out->nb_samples, 4));
+        emms_c();
+    }
+
+    return 0;
+}
+
+static int fir_frame(AudioFIRContext *s, AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    AVFrame *out = NULL;
+    int ret;
+
+    s->nb_samples = FFMIN(s->part_size, av_audio_fifo_size(s->fifo[0]));
+
+    if (!s->want_skip) {
+        out = ff_get_audio_buffer(outlink, s->nb_samples);
+        if (!out)
+            return AVERROR(ENOMEM);
+    }
+
+    s->in[0] = ff_get_audio_buffer(ctx->inputs[0], s->nb_samples);
+    if (!s->in[0]) {
+        av_frame_free(&out);
+        return AVERROR(ENOMEM);
+    }
+
+    av_audio_fifo_peek(s->fifo[0], (void **)s->in[0]->extended_data, s->nb_samples);
+
+    ctx->internal->execute(ctx, fir_channel, out, NULL, outlink->channels);
+
+    s->part_index = (s->part_index + 1) % s->nb_partitions;
+
+    av_audio_fifo_drain(s->fifo[0], s->nb_samples);
+
+    if (!s->want_skip) {
+        out->pts = s->pts;
+        if (s->pts != AV_NOPTS_VALUE)
+            s->pts += av_rescale_q(out->nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
+    }
+
+    s->index++;
+    if (s->index == 3)
+        s->index = 0;
+
+    av_frame_free(&s->in[0]);
+
+    if (s->want_skip == 1) {
+        s->want_skip = 0;
+        ret = 0;
+    } else {
+        ret = ff_filter_frame(outlink, out);
+    }
+
+    return ret;
+}
+
+static int convert_coeffs(AVFilterContext *ctx)
+{
+    AudioFIRContext *s = ctx->priv;
+    int i, ch, n, N;
+    float power = 0;
+
+    s->nb_taps = av_audio_fifo_size(s->fifo[1]);
+    if (s->nb_taps <= 0)
+        return AVERROR(EINVAL);
+
+    for (n = 4; (1 << n) < s->nb_taps; n++);
+    N = FFMIN(n, 16);
+    s->ir_length = 1 << n;
+    s->fft_length = (1 << (N + 1)) + 1;
+    s->part_size = 1 << (N - 1);
+    s->block_size = FFALIGN(s->fft_length, 32);
+    s->coeff_size = FFALIGN(s->part_size + 1, 32);
+    s->nb_partitions = (s->nb_taps + s->part_size - 1) / s->part_size;
+    s->nb_coeffs = s->ir_length + s->nb_partitions;
+
+    for (ch = 0; ch < ctx->inputs[0]->channels; ch++) {
+        s->sum[ch] = av_calloc(s->fft_length, sizeof(**s->sum));
+        if (!s->sum[ch])
+            return AVERROR(ENOMEM);
+    }
+
+    for (ch = 0; ch < ctx->inputs[1]->channels; ch++) {
+        s->coeff[ch] = av_calloc(s->nb_partitions * s->coeff_size, sizeof(**s->coeff));
+        if (!s->coeff[ch])
+            return AVERROR(ENOMEM);
+    }
+
+    for (ch = 0; ch < ctx->inputs[0]->channels; ch++) {
+        s->block[ch] = av_calloc(s->nb_partitions * s->block_size, sizeof(**s->block));
+        if (!s->block[ch])
+            return AVERROR(ENOMEM);
+    }
+
+    for (ch = 0; ch < ctx->inputs[0]->channels; ch++) {
+        s->rdft[ch]  = av_rdft_init(N, DFT_R2C);
+        s->irdft[ch] = av_rdft_init(N, IDFT_C2R);
+        if (!s->rdft[ch] || !s->irdft[ch])
+            return AVERROR(ENOMEM);
+    }
+
+    s->in[1] = ff_get_audio_buffer(ctx->inputs[1], s->nb_taps);
+    if (!s->in[1])
+        return AVERROR(ENOMEM);
+
+    s->buffer = ff_get_audio_buffer(ctx->inputs[0], s->part_size * 3);
+    if (!s->buffer)
+        return AVERROR(ENOMEM);
+
+    av_audio_fifo_read(s->fifo[1], (void **)s->in[1]->extended_data, s->nb_taps);
+
+    for (ch = 0; ch < ctx->inputs[1]->channels; ch++) {
+        float *time = (float *)s->in[1]->extended_data[!s->one2many * ch];
+        float *block = s->block[ch];
+        FFTComplex *coeff = s->coeff[ch];
+
+        power += s->fdsp->scalarproduct_float(time, time, s->nb_taps);
+
+        for (i = FFMAX(1, s->length * s->nb_taps); i < s->nb_taps; i++)
+            time[i] = 0;
+
+        for (i = 0; i < s->nb_partitions; i++) {
+            const float scale = 1.f / s->part_size;
+            const int toffset = i * s->part_size;
+            const int coffset = i * s->coeff_size;
+            const int boffset = s->part_size;
+            const int remaining = s->nb_taps - (i * s->part_size);
+            const int size = remaining >= s->part_size ? s->part_size : remaining;
+
+            memset(block, 0, sizeof(*block) * s->fft_length);
+            memcpy(block + boffset, time + toffset, size * sizeof(*block));
+
+            av_rdft_calc(s->rdft[0], block);
+
+            coeff[coffset].re = block[0] * scale;
+            coeff[coffset].im = 0;
+            for (n = 1; n < s->part_size; n++) {
+                coeff[coffset + n].re = block[2 * n] * scale;
+                coeff[coffset + n].im = block[2 * n + 1] * scale;
+            }
+            coeff[coffset + s->part_size].re = block[1] * scale;
+            coeff[coffset + s->part_size].im = 0;
+        }
+    }
+
+    av_frame_free(&s->in[1]);
+    s->gain = s->again ? 1.f / sqrtf(power / ctx->inputs[1]->channels) : 1.f;
+    av_log(ctx, AV_LOG_DEBUG, "nb_taps: %d\n", s->nb_taps);
+    av_log(ctx, AV_LOG_DEBUG, "nb_partitions: %d\n", s->nb_partitions);
+    av_log(ctx, AV_LOG_DEBUG, "partition size: %d\n", s->part_size);
+    av_log(ctx, AV_LOG_DEBUG, "ir_length: %d\n", s->ir_length);
+
+    s->have_coeffs = 1;
+
+    return 0;
+}
+
+static int read_ir(AVFilterLink *link, AVFrame *frame)
+{
+    AVFilterContext *ctx = link->dst;
+    AudioFIRContext *s = ctx->priv;
+    int nb_taps, max_nb_taps;
+
+    av_audio_fifo_write(s->fifo[1], (void **)frame->extended_data,
+                        frame->nb_samples);
+    av_frame_free(&frame);
+
+    nb_taps = av_audio_fifo_size(s->fifo[1]);
+    max_nb_taps = MAX_IR_DURATION * ctx->outputs[0]->sample_rate;
+    if (nb_taps > max_nb_taps) {
+        av_log(ctx, AV_LOG_ERROR, "Too big number of coefficients: %d > %d.\n", nb_taps, max_nb_taps);
+        return AVERROR(EINVAL);
+    }
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *link, AVFrame *frame)
+{
+    AVFilterContext *ctx = link->dst;
+    AudioFIRContext *s = ctx->priv;
+    AVFilterLink *outlink = ctx->outputs[0];
+    int ret = 0;
+
+    av_audio_fifo_write(s->fifo[0], (void **)frame->extended_data,
+                        frame->nb_samples);
+    if (s->pts == AV_NOPTS_VALUE)
+        s->pts = frame->pts;
+
+    av_frame_free(&frame);
+
+    if (!s->have_coeffs && s->eof_coeffs) {
+        ret = convert_coeffs(ctx);
+        if (ret < 0)
+            return ret;
+    }
+
+    if (s->have_coeffs) {
+        while (av_audio_fifo_size(s->fifo[0]) >= s->part_size) {
+            ret = fir_frame(s, outlink);
+            if (ret < 0)
+                break;
+        }
+    }
+    return ret;
+}
+
+static int request_frame(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    AudioFIRContext *s = ctx->priv;
+    int ret;
+
+    if (!s->eof_coeffs) {
+        ret = ff_request_frame(ctx->inputs[1]);
+        if (ret == AVERROR_EOF) {
+            s->eof_coeffs = 1;
+            ret = 0;
+        }
+        return ret;
+    }
+    ret = ff_request_frame(ctx->inputs[0]);
+    if (ret == AVERROR_EOF && s->have_coeffs) {
+        if (s->need_padding) {
+            AVFrame *silence = ff_get_audio_buffer(outlink, s->part_size);
+
+            if (!silence)
+                return AVERROR(ENOMEM);
+            av_audio_fifo_write(s->fifo[0], (void **)silence->extended_data,
+                        silence->nb_samples);
+            av_frame_free(&silence);
+            s->need_padding = 0;
+        }
+
+        while (av_audio_fifo_size(s->fifo[0]) > 0) {
+            ret = fir_frame(s, outlink);
+            if (ret < 0)
+                return ret;
+        }
+        ret = AVERROR_EOF;
+    }
+    return ret;
+}
+
+static int query_formats(AVFilterContext *ctx)
+{
+    AVFilterFormats *formats;
+    AVFilterChannelLayouts *layouts;
+    static const enum AVSampleFormat sample_fmts[] = {
+        AV_SAMPLE_FMT_FLTP,
+        AV_SAMPLE_FMT_NONE
+    };
+    int ret, i;
+
+    layouts = ff_all_channel_counts();
+    if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0)
+        return ret;
+
+    for (i = 0; i < 2; i++) {
+        layouts = ff_all_channel_counts();
+        if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0)
+            return ret;
+    }
+
+    formats = ff_make_format_list(sample_fmts);
+    if ((ret = ff_set_common_formats(ctx, formats)) < 0)
+        return ret;
+
+    formats = ff_all_samplerates();
+    return ff_set_common_samplerates(ctx, formats);
+}
+
+static int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    AudioFIRContext *s = ctx->priv;
+
+    if (ctx->inputs[0]->channels != ctx->inputs[1]->channels &&
+        ctx->inputs[1]->channels != 1) {
+        av_log(ctx, AV_LOG_ERROR,
+               "Second input must have same number of channels as first input or "
+               "exactly 1 channel.\n");
+        return AVERROR(EINVAL);
+    }
+
+    s->one2many = ctx->inputs[1]->channels == 1;
+    outlink->sample_rate = ctx->inputs[0]->sample_rate;
+    outlink->time_base   = ctx->inputs[0]->time_base;
+    outlink->channel_layout = ctx->inputs[0]->channel_layout;
+    outlink->channels = ctx->inputs[0]->channels;
+
+    s->fifo[0] = av_audio_fifo_alloc(ctx->inputs[0]->format, ctx->inputs[0]->channels, 1024);
+    s->fifo[1] = av_audio_fifo_alloc(ctx->inputs[1]->format, ctx->inputs[1]->channels, 1024);
+    if (!s->fifo[0] || !s->fifo[1])
+        return AVERROR(ENOMEM);
+
+    s->sum = av_calloc(outlink->channels, sizeof(*s->sum));
+    s->coeff = av_calloc(ctx->inputs[1]->channels, sizeof(*s->coeff));
+    s->block = av_calloc(ctx->inputs[0]->channels, sizeof(*s->block));
+    s->rdft = av_calloc(outlink->channels, sizeof(*s->rdft));
+    s->irdft = av_calloc(outlink->channels, sizeof(*s->irdft));
+    if (!s->sum || !s->coeff || !s->block || !s->rdft || !s->irdft)
+        return AVERROR(ENOMEM);
+
+    s->nb_channels = outlink->channels;
+    s->nb_coef_channels = ctx->inputs[1]->channels;
+    s->want_skip = 1;
+    s->need_padding = 1;
+    s->pts = AV_NOPTS_VALUE;
+
+    return 0;
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    AudioFIRContext *s = ctx->priv;
+    int ch;
+
+    if (s->sum) {
+        for (ch = 0; ch < s->nb_channels; ch++) {
+            av_freep(&s->sum[ch]);
+        }
+    }
+    av_freep(&s->sum);
+
+    if (s->coeff) {
+        for (ch = 0; ch < s->nb_coef_channels; ch++) {
+            av_freep(&s->coeff[ch]);
+        }
+    }
+    av_freep(&s->coeff);
+
+    if (s->block) {
+        for (ch = 0; ch < s->nb_channels; ch++) {
+            av_freep(&s->block[ch]);
+        }
+    }
+    av_freep(&s->block);
+
+    if (s->rdft) {
+        for (ch = 0; ch < s->nb_channels; ch++) {
+            av_rdft_end(s->rdft[ch]);
+        }
+    }
+    av_freep(&s->rdft);
+
+    if (s->irdft) {
+        for (ch = 0; ch < s->nb_channels; ch++) {
+            av_rdft_end(s->irdft[ch]);
+        }
+    }
+    av_freep(&s->irdft);
+
+    av_frame_free(&s->in[0]);
+    av_frame_free(&s->in[1]);
+    av_frame_free(&s->buffer);
+
+    av_audio_fifo_free(s->fifo[0]);
+    av_audio_fifo_free(s->fifo[1]);
+
+    av_freep(&s->fdsp);
+}
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    AudioFIRContext *s = ctx->priv;
+
+    s->fcmul_add = fcmul_add_c;
+
+    s->fdsp = avpriv_float_dsp_alloc(0);
+    if (!s->fdsp)
+        return AVERROR(ENOMEM);
+
+    if (ARCH_X86)
+        ff_afir_init_x86(s);
+
+    return 0;
+}
+
+static const AVFilterPad afir_inputs[] = {
+    {
+        .name           = "main",
+        .type           = AVMEDIA_TYPE_AUDIO,
+        .filter_frame   = filter_frame,
+    },{
+        .name           = "ir",
+        .type           = AVMEDIA_TYPE_AUDIO,
+        .filter_frame   = read_ir,
+    },
+    { NULL }
+};
+
+static const AVFilterPad afir_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_AUDIO,
+        .config_props  = config_output,
+        .request_frame = request_frame,
+    },
+    { NULL }
+};
+
+#define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+#define OFFSET(x) offsetof(AudioFIRContext, x)
+
+static const AVOption afir_options[] = {
+    { "dry",    "set dry gain",     OFFSET(dry_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
+    { "wet",    "set wet gain",     OFFSET(wet_gain), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
+    { "length", "set IR length",    OFFSET(length),   AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 1, AF },
+    { "again",  "enable auto gain", OFFSET(again),    AV_OPT_TYPE_BOOL,  {.i64=1}, 0, 1, AF },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(afir);
+
+AVFilter ff_af_afir = {
+    .name          = "afir",
+    .description   = NULL_IF_CONFIG_SMALL("Apply Finite Impulse Response filter with supplied coefficients in 2nd stream."),
+    .priv_size     = sizeof(AudioFIRContext),
+    .priv_class    = &afir_class,
+    .query_formats = query_formats,
+    .init          = init,
+    .uninit        = uninit,
+    .inputs        = afir_inputs,
+    .outputs       = afir_outputs,
+    .flags         = AVFILTER_FLAG_SLICE_THREADS,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/af_afir.h b/mythtv/external/FFmpeg/libavfilter/af_afir.h
new file mode 100644
index 00000000000..aaeb66536fa
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/af_afir.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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 AVFILTER_AFIR_H
+#define AVFILTER_AFIR_H
+
+#include "libavutil/audio_fifo.h"
+#include "libavutil/common.h"
+#include "libavutil/float_dsp.h"
+#include "libavutil/opt.h"
+#include "libavcodec/avfft.h"
+
+#include "audio.h"
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+
+#define MAX_IR_DURATION 30
+
+typedef struct AudioFIRContext {
+    const AVClass *class;
+
+    float wet_gain;
+    float dry_gain;
+    float length;
+    int again;
+
+    float gain;
+
+    int eof_coeffs;
+    int have_coeffs;
+    int nb_coeffs;
+    int nb_taps;
+    int part_size;
+    int part_index;
+    int coeff_size;
+    int block_size;
+    int nb_partitions;
+    int nb_channels;
+    int ir_length;
+    int fft_length;
+    int nb_coef_channels;
+    int one2many;
+    int nb_samples;
+    int want_skip;
+    int need_padding;
+
+    RDFTContext **rdft, **irdft;
+    float **sum;
+    float **block;
+    FFTComplex **coeff;
+
+    AVAudioFifo *fifo[2];
+    AVFrame *in[2];
+    AVFrame *buffer;
+    int64_t pts;
+    int index;
+
+    AVFloatDSPContext *fdsp;
+    void (*fcmul_add)(float *sum, const float *t, const float *c,
+                      ptrdiff_t len);
+} AudioFIRContext;
+
+void ff_afir_init_x86(AudioFIRContext *s);
+
+#endif /* AVFILTER_AFIR_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/af_agate.c b/mythtv/external/FFmpeg/libavfilter/af_agate.c
index 328e25ba84e..20905ccb190 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_agate.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_agate.c
@@ -29,6 +29,7 @@
 #include "libavutil/opt.h"
 #include "avfilter.h"
 #include "audio.h"
+#include "filters.h"
 #include "formats.h"
 #include "hermite.h"
 
@@ -265,71 +266,71 @@ AVFilter ff_af_agate = {
 #define sidechaingate_options options
 AVFILTER_DEFINE_CLASS(sidechaingate);
 
-static int scfilter_frame(AVFilterLink *link, AVFrame *frame)
+static int activate(AVFilterContext *ctx)
 {
-    AVFilterContext *ctx = link->dst;
     AudioGateContext *s = ctx->priv;
-    AVFilterLink *outlink = ctx->outputs[0];
-    AVFrame *out, *in[2] = { NULL };
+    AVFrame *out = NULL, *in[2] = { NULL };
+    int ret, i, nb_samples;
     double *dst;
-    int nb_samples;
-    int i;
 
-    for (i = 0; i < 2; i++)
-        if (link == ctx->inputs[i])
-            break;
-    av_assert0(i < 2);
-    av_audio_fifo_write(s->fifo[i], (void **)frame->extended_data,
-                        frame->nb_samples);
-    av_frame_free(&frame);
+    FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);
+    if ((ret = ff_inlink_consume_frame(ctx->inputs[0], &in[0])) > 0) {
+        av_audio_fifo_write(s->fifo[0], (void **)in[0]->extended_data,
+                            in[0]->nb_samples);
+        av_frame_free(&in[0]);
+    }
+    if (ret < 0)
+        return ret;
+    if ((ret = ff_inlink_consume_frame(ctx->inputs[1], &in[1])) > 0) {
+        av_audio_fifo_write(s->fifo[1], (void **)in[1]->extended_data,
+                            in[1]->nb_samples);
+        av_frame_free(&in[1]);
+    }
+    if (ret < 0)
+        return ret;
 
     nb_samples = FFMIN(av_audio_fifo_size(s->fifo[0]), av_audio_fifo_size(s->fifo[1]));
-    if (!nb_samples)
-        return 0;
-
-    out = ff_get_audio_buffer(outlink, nb_samples);
-    if (!out)
-        return AVERROR(ENOMEM);
-    for (i = 0; i < 2; i++) {
-        in[i] = ff_get_audio_buffer(ctx->inputs[i], nb_samples);
-        if (!in[i]) {
-            av_frame_free(&in[0]);
-            av_frame_free(&in[1]);
-            av_frame_free(&out);
+    if (nb_samples) {
+        out = ff_get_audio_buffer(ctx->outputs[0], nb_samples);
+        if (!out)
             return AVERROR(ENOMEM);
+        for (i = 0; i < 2; i++) {
+            in[i] = ff_get_audio_buffer(ctx->inputs[i], nb_samples);
+            if (!in[i]) {
+                av_frame_free(&in[0]);
+                av_frame_free(&in[1]);
+                av_frame_free(&out);
+                return AVERROR(ENOMEM);
+            }
+            av_audio_fifo_read(s->fifo[i], (void **)in[i]->data, nb_samples);
         }
-        av_audio_fifo_read(s->fifo[i], (void **)in[i]->data, nb_samples);
-    }
-
-    dst = (double *)out->data[0];
-    out->pts = s->pts;
-    s->pts += nb_samples;
-
-    gate(s, (double *)in[0]->data[0], dst,
-         (double *)in[1]->data[0], nb_samples,
-         s->level_in, s->level_sc,
-         ctx->inputs[0], ctx->inputs[1]);
 
-    av_frame_free(&in[0]);
-    av_frame_free(&in[1]);
+        dst = (double *)out->data[0];
+        out->pts = s->pts;
+        s->pts += nb_samples;
 
-    return ff_filter_frame(outlink, out);
-}
+        gate(s, (double *)in[0]->data[0], dst,
+             (double *)in[1]->data[0], nb_samples,
+             s->level_in, s->level_sc,
+             ctx->inputs[0], ctx->inputs[1]);
 
-static int screquest_frame(AVFilterLink *outlink)
-{
-    AVFilterContext *ctx = outlink->src;
-    AudioGateContext *s = ctx->priv;
-    int i;
+        av_frame_free(&in[0]);
+        av_frame_free(&in[1]);
 
-    /* get a frame on each input */
-    for (i = 0; i < 2; i++) {
-        AVFilterLink *inlink = ctx->inputs[i];
-        if (!av_audio_fifo_size(s->fifo[i]))
-            return ff_request_frame(inlink);
+        ret = ff_filter_frame(ctx->outputs[0], out);
+        if (ret < 0)
+            return ret;
     }
-
-    return 0;
+    FF_FILTER_FORWARD_STATUS(ctx->inputs[0], ctx->outputs[0]);
+    FF_FILTER_FORWARD_STATUS(ctx->inputs[1], ctx->outputs[0]);
+    /* TODO reindent */
+        if (ff_outlink_frame_wanted(ctx->outputs[0])) {
+            if (!av_audio_fifo_size(s->fifo[0]))
+                ff_inlink_request_frame(ctx->inputs[0]);
+            if (!av_audio_fifo_size(s->fifo[1]))
+                ff_inlink_request_frame(ctx->inputs[1]);
+        }
+        return 0;
 }
 
 static int scquery_formats(AVFilterContext *ctx)
@@ -408,11 +409,9 @@ static const AVFilterPad sidechaingate_inputs[] = {
     {
         .name           = "main",
         .type           = AVMEDIA_TYPE_AUDIO,
-        .filter_frame   = scfilter_frame,
     },{
         .name           = "sidechain",
         .type           = AVMEDIA_TYPE_AUDIO,
-        .filter_frame   = scfilter_frame,
     },
     { NULL }
 };
@@ -422,7 +421,6 @@ static const AVFilterPad sidechaingate_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = scconfig_output,
-        .request_frame = screquest_frame,
     },
     { NULL }
 };
@@ -433,6 +431,7 @@ AVFilter ff_af_sidechaingate = {
     .priv_size      = sizeof(AudioGateContext),
     .priv_class     = &sidechaingate_class,
     .query_formats  = scquery_formats,
+    .activate       = activate,
     .uninit         = uninit,
     .inputs         = sidechaingate_inputs,
     .outputs        = sidechaingate_outputs,
diff --git a/mythtv/external/FFmpeg/libavfilter/af_amerge.c b/mythtv/external/FFmpeg/libavfilter/af_amerge.c
index 4a8c6d5bd0b..09c660ef49b 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_amerge.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_amerge.c
@@ -23,6 +23,9 @@
  * Audio merging filter
  */
 
+#define FF_INTERNAL_FIELDS 1
+#include "framequeue.h"
+
 #include "libavutil/avstring.h"
 #include "libavutil/bprint.h"
 #include "libavutil/channel_layout.h"
@@ -34,7 +37,7 @@
 
 #define SWR_CH_MAX 64
 
-typedef struct {
+typedef struct AMergeContext {
     const AVClass *class;
     int nb_inputs;
     int route[SWR_CH_MAX]; /**< channels routing, see copy_samples */
@@ -93,10 +96,15 @@ static int query_formats(AVFilterContext *ctx)
             av_get_channel_layout_string(buf, sizeof(buf), 0, inlayout[i]);
             av_log(ctx, AV_LOG_INFO, "Using \"%s\" for input %d\n", buf, i + 1);
         }
-        s->in[i].nb_ch = av_get_channel_layout_nb_channels(inlayout[i]);
-        if (outlayout & inlayout[i])
+        s->in[i].nb_ch = FF_LAYOUT2COUNT(inlayout[i]);
+        if (s->in[i].nb_ch) {
             overlap++;
-        outlayout |= inlayout[i];
+        } else {
+            s->in[i].nb_ch = av_get_channel_layout_nb_channels(inlayout[i]);
+            if (outlayout & inlayout[i])
+                overlap++;
+            outlayout |= inlayout[i];
+        }
         nb_ch += s->in[i].nb_ch;
     }
     if (nb_ch > SWR_CH_MAX) {
@@ -182,7 +190,9 @@ static int request_frame(AVFilterLink *outlink)
     int i, ret;
 
     for (i = 0; i < s->nb_inputs; i++)
-        if (!s->in[i].nb_samples)
+        if (!s->in[i].nb_samples ||
+            /* detect EOF immediately */
+            (ctx->inputs[i]->status_in && !ctx->inputs[i]->status_out))
             if ((ret = ff_request_frame(ctx->inputs[i])) < 0)
                 return ret;
     return 0;
@@ -270,7 +280,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
 
     outbuf->nb_samples     = nb_samples;
     outbuf->channel_layout = outlink->channel_layout;
-    av_frame_set_channels(outbuf, outlink->channels);
+    outbuf->channels       = outlink->channels;
 
     while (nb_samples) {
         ns = nb_samples;
@@ -312,7 +322,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
 static av_cold int init(AVFilterContext *ctx)
 {
     AMergeContext *s = ctx->priv;
-    int i;
+    int i, ret;
 
     s->in = av_calloc(s->nb_inputs, sizeof(*s->in));
     if (!s->in)
@@ -326,7 +336,10 @@ static av_cold int init(AVFilterContext *ctx)
         };
         if (!name)
             return AVERROR(ENOMEM);
-        ff_insert_inpad(ctx, i, &pad);
+        if ((ret = ff_insert_inpad(ctx, i, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
     }
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/af_amix.c b/mythtv/external/FFmpeg/libavfilter/af_amix.c
index e18743e0b8c..09848e5d91a 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_amix.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_amix.c
@@ -41,6 +41,7 @@
 
 #include "audio.h"
 #include "avfilter.h"
+#include "filters.h"
 #include "formats.h"
 #include "internal.h"
 
@@ -151,6 +152,7 @@ static int frame_list_add_frame(FrameList *frame_list, int nb_samples, int64_t p
     return 0;
 }
 
+/* FIXME: use directly links fifo */
 
 typedef struct MixContext {
     const AVClass *class;       /**< class for AVOptions */
@@ -177,12 +179,12 @@ typedef struct MixContext {
 #define F AV_OPT_FLAG_FILTERING_PARAM
 static const AVOption amix_options[] = {
     { "inputs", "Number of inputs.",
-            OFFSET(nb_inputs), AV_OPT_TYPE_INT, { .i64 = 2 }, 1, 32, A|F },
+            OFFSET(nb_inputs), AV_OPT_TYPE_INT, { .i64 = 2 }, 1, 1024, A|F },
     { "duration", "How to determine the end-of-stream.",
             OFFSET(duration_mode), AV_OPT_TYPE_INT, { .i64 = DURATION_LONGEST }, 0,  2, A|F, "duration" },
-        { "longest",  "Duration of longest input.",  0, AV_OPT_TYPE_CONST, { .i64 = DURATION_LONGEST  }, INT_MIN, INT_MAX, A|F, "duration" },
-        { "shortest", "Duration of shortest input.", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_SHORTEST }, INT_MIN, INT_MAX, A|F, "duration" },
-        { "first",    "Duration of first input.",    0, AV_OPT_TYPE_CONST, { .i64 = DURATION_FIRST    }, INT_MIN, INT_MAX, A|F, "duration" },
+        { "longest",  "Duration of longest input.",  0, AV_OPT_TYPE_CONST, { .i64 = DURATION_LONGEST  }, 0, 0, A|F, "duration" },
+        { "shortest", "Duration of shortest input.", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_SHORTEST }, 0, 0, A|F, "duration" },
+        { "first",    "Duration of first input.",    0, AV_OPT_TYPE_CONST, { .i64 = DURATION_FIRST    }, 0, 0, A|F, "duration" },
     { "dropout_transition", "Transition time, in seconds, for volume "
                             "renormalization when an input stream ends.",
             OFFSET(dropout_transition), AV_OPT_TYPE_FLOAT, { .dbl = 2.0 }, 0, INT_MAX, A|F },
@@ -263,8 +265,6 @@ static int config_output(AVFilterLink *outlink)
     return 0;
 }
 
-static int calc_active_inputs(MixContext *s);
-
 /**
  * Read samples from the input FIFOs, mix, and write to the output link.
  */
@@ -273,11 +273,7 @@ static int output_frame(AVFilterLink *outlink)
     AVFilterContext *ctx = outlink->src;
     MixContext      *s = ctx->priv;
     AVFrame *out_buf, *in_buf;
-    int nb_samples, ns, ret, i;
-
-    ret = calc_active_inputs(s);
-    if (ret < 0)
-        return ret;
+    int nb_samples, ns, i;
 
     if (s->input_state[0] & INPUT_ON) {
         /* first input live: use the corresponding frame size */
@@ -303,8 +299,10 @@ static int output_frame(AVFilterLink *outlink)
                 nb_samples = FFMIN(nb_samples, ns);
             }
         }
-        if (nb_samples == INT_MAX)
-            return AVERROR_EOF;
+        if (nb_samples == INT_MAX) {
+            ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
+            return 0;
+        }
     }
 
     s->next_pts = frame_list_next_pts(s->frame_list);
@@ -336,10 +334,19 @@ static int output_frame(AVFilterLink *outlink)
             plane_size = nb_samples * (s->planar ? 1 : s->nb_channels);
             plane_size = FFALIGN(plane_size, 16);
 
-            for (p = 0; p < planes; p++) {
-                s->fdsp->vector_fmac_scalar((float *)out_buf->extended_data[p],
-                                           (float *) in_buf->extended_data[p],
-                                           s->input_scale[i], plane_size);
+            if (out_buf->format == AV_SAMPLE_FMT_FLT ||
+                out_buf->format == AV_SAMPLE_FMT_FLTP) {
+                for (p = 0; p < planes; p++) {
+                    s->fdsp->vector_fmac_scalar((float *)out_buf->extended_data[p],
+                                                (float *) in_buf->extended_data[p],
+                                                s->input_scale[i], plane_size);
+                }
+            } else {
+                for (p = 0; p < planes; p++) {
+                    s->fdsp->vector_dmac_scalar((double *)out_buf->extended_data[p],
+                                                (double *) in_buf->extended_data[p],
+                                                s->input_scale[i], plane_size);
+                }
             }
         }
     }
@@ -358,25 +365,17 @@ static int output_frame(AVFilterLink *outlink)
 static int request_samples(AVFilterContext *ctx, int min_samples)
 {
     MixContext *s = ctx->priv;
-    int i, ret;
+    int i;
 
     av_assert0(s->nb_inputs > 1);
 
     for (i = 1; i < s->nb_inputs; i++) {
-        ret = 0;
-        if (!(s->input_state[i] & INPUT_ON))
+        if (!(s->input_state[i] & INPUT_ON) ||
+             (s->input_state[i] & INPUT_EOF))
             continue;
         if (av_audio_fifo_size(s->fifos[i]) >= min_samples)
             continue;
-        ret = ff_request_frame(ctx->inputs[i]);
-        if (ret == AVERROR_EOF) {
-            s->input_state[i] |= INPUT_EOF;
-            if (av_audio_fifo_size(s->fifos[i]) == 0) {
-                s->input_state[i] = 0;
-                continue;
-            }
-        } else if (ret < 0)
-            return ret;
+        ff_inlink_request_frame(ctx->inputs[i]);
     }
     return output_frame(ctx->outputs[0]);
 }
@@ -402,77 +401,93 @@ static int calc_active_inputs(MixContext *s)
     return 0;
 }
 
-static int request_frame(AVFilterLink *outlink)
+static int activate(AVFilterContext *ctx)
 {
-    AVFilterContext *ctx = outlink->src;
-    MixContext      *s = ctx->priv;
-    int ret;
-    int wanted_samples;
-
-    ret = calc_active_inputs(s);
-    if (ret < 0)
-        return ret;
-
-    if (!(s->input_state[0] & INPUT_ON))
-        return request_samples(ctx, 1);
-
-    if (s->frame_list->nb_frames == 0) {
-        ret = ff_request_frame(ctx->inputs[0]);
-        if (ret == AVERROR_EOF) {
-            s->input_state[0] = 0;
-            if (s->nb_inputs == 1)
-                return AVERROR_EOF;
-            return output_frame(ctx->outputs[0]);
-        }
-        return ret;
-    }
-    av_assert0(s->frame_list->nb_frames > 0);
+    AVFilterLink *outlink = ctx->outputs[0];
+    MixContext *s = ctx->priv;
+    AVFrame *buf = NULL;
+    int i, ret;
 
-    wanted_samples = frame_list_next_frame_size(s->frame_list);
+    for (i = 0; i < s->nb_inputs; i++) {
+        AVFilterLink *inlink = ctx->inputs[i];
+
+        if ((ret = ff_inlink_consume_frame(ctx->inputs[i], &buf)) > 0) {
+            if (i == 0) {
+                int64_t pts = av_rescale_q(buf->pts, inlink->time_base,
+                                           outlink->time_base);
+                ret = frame_list_add_frame(s->frame_list, buf->nb_samples, pts);
+                if (ret < 0) {
+                    av_frame_free(&buf);
+                    return ret;
+                }
+            }
 
-    return request_samples(ctx, wanted_samples);
-}
+            ret = av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data,
+                                      buf->nb_samples);
+            if (ret < 0) {
+                av_frame_free(&buf);
+                return ret;
+            }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
-{
-    AVFilterContext  *ctx = inlink->dst;
-    MixContext       *s = ctx->priv;
-    AVFilterLink *outlink = ctx->outputs[0];
-    int i, ret = 0;
+            av_frame_free(&buf);
 
-    for (i = 0; i < ctx->nb_inputs; i++)
-        if (ctx->inputs[i] == inlink)
-            break;
-    if (i >= ctx->nb_inputs) {
-        av_log(ctx, AV_LOG_ERROR, "unknown input link\n");
-        ret = AVERROR(EINVAL);
-        goto fail;
+            ret = output_frame(outlink);
+            if (ret < 0)
+                return ret;
+        }
     }
 
-    if (i == 0) {
-        int64_t pts = av_rescale_q(buf->pts, inlink->time_base,
-                                   outlink->time_base);
-        ret = frame_list_add_frame(s->frame_list, buf->nb_samples, pts);
-        if (ret < 0)
-            goto fail;
+    for (i = 0; i < s->nb_inputs; i++) {
+        int64_t pts;
+        int status;
+
+        if (ff_inlink_acknowledge_status(ctx->inputs[i], &status, &pts)) {
+            if (status == AVERROR_EOF) {
+                if (i == 0) {
+                    s->input_state[i] = 0;
+                    if (s->nb_inputs == 1) {
+                        ff_outlink_set_status(outlink, status, pts);
+                        return 0;
+                    }
+                } else {
+                    s->input_state[i] |= INPUT_EOF;
+                    if (av_audio_fifo_size(s->fifos[i]) == 0) {
+                        s->input_state[i] = 0;
+                    }
+                }
+            }
+        }
     }
 
-    ret = av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data,
-                              buf->nb_samples);
+    if (calc_active_inputs(s)) {
+        ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
+        return 0;
+    }
 
-    av_frame_free(&buf);
-    return output_frame(outlink);
+    if (ff_outlink_frame_wanted(outlink)) {
+        int wanted_samples;
 
-fail:
-    av_frame_free(&buf);
+        if (!(s->input_state[0] & INPUT_ON))
+            return request_samples(ctx, 1);
 
-    return ret;
+        if (s->frame_list->nb_frames == 0) {
+            ff_inlink_request_frame(ctx->inputs[0]);
+            return 0;
+        }
+        av_assert0(s->frame_list->nb_frames > 0);
+
+        wanted_samples = frame_list_next_frame_size(s->frame_list);
+
+        return request_samples(ctx, wanted_samples);
+    }
+
+    return 0;
 }
 
 static av_cold int init(AVFilterContext *ctx)
 {
     MixContext *s = ctx->priv;
-    int i;
+    int i, ret;
 
     for (i = 0; i < s->nb_inputs; i++) {
         char name[32];
@@ -483,9 +498,11 @@ static av_cold int init(AVFilterContext *ctx)
         pad.name           = av_strdup(name);
         if (!pad.name)
             return AVERROR(ENOMEM);
-        pad.filter_frame   = filter_frame;
 
-        ff_insert_inpad(ctx, i, &pad);
+        if ((ret = ff_insert_inpad(ctx, i, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
     }
 
     s->fdsp = avpriv_float_dsp_alloc(0);
@@ -529,6 +546,8 @@ static int query_formats(AVFilterContext *ctx)
 
     if ((ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLT ))          < 0 ||
         (ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLTP))          < 0 ||
+        (ret = ff_add_format(&formats, AV_SAMPLE_FMT_DBL ))          < 0 ||
+        (ret = ff_add_format(&formats, AV_SAMPLE_FMT_DBLP))          < 0 ||
         (ret = ff_set_common_formats        (ctx, formats))          < 0 ||
         (ret = ff_set_common_channel_layouts(ctx, layouts))          < 0 ||
         (ret = ff_set_common_samplerates(ctx, ff_all_samplerates())) < 0)
@@ -546,7 +565,6 @@ static const AVFilterPad avfilter_af_amix_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_output,
-        .request_frame = request_frame
     },
     { NULL }
 };
@@ -558,6 +576,7 @@ AVFilter ff_af_amix = {
     .priv_class     = &amix_class,
     .init           = init,
     .uninit         = uninit,
+    .activate       = activate,
     .query_formats  = query_formats,
     .inputs         = NULL,
     .outputs        = avfilter_af_amix_outputs,
diff --git a/mythtv/external/FFmpeg/libavfilter/af_anull.c b/mythtv/external/FFmpeg/libavfilter/af_anull.c
index fff456e8ea3..1d0af451dcd 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_anull.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_anull.c
@@ -46,7 +46,6 @@ static const AVFilterPad avfilter_af_anull_outputs[] = {
 AVFilter ff_af_anull = {
     .name          = "anull",
     .description   = NULL_IF_CONFIG_SMALL("Pass the source unchanged to the output."),
-    .query_formats = ff_query_formats_all,
     .inputs        = avfilter_af_anull_inputs,
     .outputs       = avfilter_af_anull_outputs,
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/af_apad.c b/mythtv/external/FFmpeg/libavfilter/af_apad.c
index 0a2d4206a9c..f7a4199c648 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_apad.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_apad.c
@@ -34,7 +34,7 @@
 #include "audio.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct APadContext {
     const AVClass *class;
     int64_t next_pts;
 
@@ -119,7 +119,7 @@ static int request_frame(AVFilterLink *outlink)
 
         av_samples_set_silence(outsamplesref->extended_data, 0,
                                n_out,
-                               av_frame_get_channels(outsamplesref),
+                               outsamplesref->channels,
                                outsamplesref->format);
 
         outsamplesref->pts = s->next_pts;
diff --git a/mythtv/external/FFmpeg/libavfilter/af_aphaser.c b/mythtv/external/FFmpeg/libavfilter/af_aphaser.c
index 33ecb1a7fbe..dcffc216dd3 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_aphaser.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_aphaser.c
@@ -248,13 +248,15 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *inbuf)
         outbuf = inbuf;
     } else {
         outbuf = ff_get_audio_buffer(inlink, inbuf->nb_samples);
-        if (!outbuf)
+        if (!outbuf) {
+            av_frame_free(&inbuf);
             return AVERROR(ENOMEM);
+        }
         av_frame_copy_props(outbuf, inbuf);
     }
 
     s->phaser(s, inbuf->extended_data, outbuf->extended_data,
-              outbuf->nb_samples, av_frame_get_channels(outbuf));
+              outbuf->nb_samples, outbuf->channels);
 
     if (inbuf != outbuf)
         av_frame_free(&inbuf);
diff --git a/mythtv/external/FFmpeg/libavfilter/af_apulsator.c b/mythtv/external/FFmpeg/libavfilter/af_apulsator.c
index 802b8d02567..67711a28ce9 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_apulsator.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_apulsator.c
@@ -47,7 +47,7 @@ typedef struct AudioPulsatorContext {
     double offset_r;
     double pwidth;
     double bpm;
-    double hz;
+    double hertz;
     int ms;
     int timing;
 
@@ -76,7 +76,7 @@ static const AVOption apulsator_options[] = {
     {   "hz",                   NULL, 0,                 AV_OPT_TYPE_CONST,  {.i64=UNIT_HZ},   0,          0, FLAGS, "timing" },
     { "bpm",               "set BPM", OFFSET(bpm),       AV_OPT_TYPE_DOUBLE, {.dbl=120},    30,          300, FLAGS },
     { "ms",                 "set ms", OFFSET(ms),        AV_OPT_TYPE_INT,    {.i64=500},    10,         2000, FLAGS },
-    { "hz",          "set frequency", OFFSET(hz),        AV_OPT_TYPE_DOUBLE, {.dbl=2},    0.01,          100, FLAGS },
+    { "hz",          "set frequency", OFFSET(hertz),     AV_OPT_TYPE_DOUBLE, {.dbl=2},    0.01,          100, FLAGS },
     { NULL }
 };
 
@@ -208,7 +208,7 @@ static int config_input(AVFilterLink *inlink)
     switch (s->timing) {
     case UNIT_BPM:  freq = s->bpm / 60;         break;
     case UNIT_MS:   freq = 1 / (s->ms / 1000.); break;
-    case UNIT_HZ:   freq = s->hz;               break;
+    case UNIT_HZ:   freq = s->hertz;            break;
     default: av_assert0(0);
     }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/af_aresample.c b/mythtv/external/FFmpeg/libavfilter/af_aresample.c
index 028e1053184..ef10621c359 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_aresample.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_aresample.c
@@ -34,7 +34,7 @@
 #include "audio.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct AResampleContext {
     const AVClass *class;
     int sample_rate_arg;
     double ratio;
@@ -195,12 +195,14 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamplesref)
 
     outsamplesref = ff_get_audio_buffer(outlink, n_out);
 
-    if(!outsamplesref)
+    if(!outsamplesref) {
+        av_frame_free(&insamplesref);
         return AVERROR(ENOMEM);
+    }
 
     av_frame_copy_props(outsamplesref, insamplesref);
     outsamplesref->format                = outlink->format;
-    av_frame_set_channels(outsamplesref, outlink->channels);
+    outsamplesref->channels              = outlink->channels;
     outsamplesref->channel_layout        = outlink->channel_layout;
     outsamplesref->sample_rate           = outlink->sample_rate;
 
diff --git a/mythtv/external/FFmpeg/libavfilter/af_asetnsamples.c b/mythtv/external/FFmpeg/libavfilter/af_asetnsamples.c
index b5aa193c2d5..3c2f66b30aa 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_asetnsamples.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_asetnsamples.c
@@ -33,7 +33,7 @@
 #include "internal.h"
 #include "formats.h"
 
-typedef struct {
+typedef struct ASNSContext {
     const AVClass *class;
     int nb_out_samples;  ///< how many samples to output
     AVAudioFifo *fifo;   ///< samples are queued here
diff --git a/mythtv/external/FFmpeg/libavfilter/af_asetrate.c b/mythtv/external/FFmpeg/libavfilter/af_asetrate.c
index 66febd71ba6..50a5f437499 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_asetrate.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_asetrate.c
@@ -22,7 +22,7 @@
 #include "avfilter.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct ASetRateContext {
     const AVClass *class;
     int sample_rate;
     int rescale_pts;
diff --git a/mythtv/external/FFmpeg/libavfilter/af_ashowinfo.c b/mythtv/external/FFmpeg/libavfilter/af_ashowinfo.c
index ca33add335f..9046e8d84af 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_ashowinfo.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_ashowinfo.c
@@ -199,17 +199,17 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
                        s->plane_checksums[0];
     }
 
-    av_get_channel_layout_string(chlayout_str, sizeof(chlayout_str), -1,
+    av_get_channel_layout_string(chlayout_str, sizeof(chlayout_str), buf->channels,
                                  buf->channel_layout);
 
     av_log(ctx, AV_LOG_INFO,
            "n:%"PRId64" pts:%s pts_time:%s pos:%"PRId64" "
            "fmt:%s channels:%d chlayout:%s rate:%d nb_samples:%d "
            "checksum:%08"PRIX32" ",
-           inlink->frame_count,
+           inlink->frame_count_out,
            av_ts2str(buf->pts), av_ts2timestr(buf->pts, &inlink->time_base),
-           av_frame_get_pkt_pos(buf),
-           av_get_sample_fmt_name(buf->format), av_frame_get_channels(buf), chlayout_str,
+           buf->pkt_pos,
+           av_get_sample_fmt_name(buf->format), buf->channels, chlayout_str,
            buf->sample_rate, buf->nb_samples,
            checksum);
 
diff --git a/mythtv/external/FFmpeg/libavfilter/af_astats.c b/mythtv/external/FFmpeg/libavfilter/af_astats.c
index e7f9675c2e0..2922da9f448 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_astats.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_astats.c
@@ -28,6 +28,7 @@
 
 typedef struct ChannelStats {
     double last;
+    double min_non_zero;
     double sigma_x, sigma_x2;
     double avg_sigma_x2, min_sigma_x2, max_sigma_x2;
     double min, max;
@@ -36,12 +37,13 @@ typedef struct ChannelStats {
     double min_runs, max_runs;
     double min_diff, max_diff;
     double diff1_sum;
+    double diff1_sum_x2;
     uint64_t mask, imask;
     uint64_t min_count, max_count;
     uint64_t nb_samples;
 } ChannelStats;
 
-typedef struct {
+typedef struct AudioStatsContext {
     const AVClass *class;
     ChannelStats *chstats;
     int nb_channels;
@@ -109,18 +111,18 @@ static void reset_stats(AudioStatsContext *s)
 
         p->min = p->nmin = p->min_sigma_x2 = DBL_MAX;
         p->max = p->nmax = p->max_sigma_x2 = DBL_MIN;
+        p->min_non_zero = DBL_MAX;
         p->min_diff = DBL_MAX;
         p->max_diff = DBL_MIN;
         p->sigma_x = 0;
         p->sigma_x2 = 0;
         p->avg_sigma_x2 = 0;
-        p->min_sigma_x2 = 0;
-        p->max_sigma_x2 = 0;
         p->min_run = 0;
         p->max_run = 0;
         p->min_runs = 0;
         p->max_runs = 0;
         p->diff1_sum = 0;
+        p->diff1_sum_x2 = 0;
         p->mask = 0;
         p->imask = 0xFFFFFFFFFFFFFFFF;
         p->min_count = 0;
@@ -178,6 +180,9 @@ static inline void update_stat(AudioStatsContext *s, ChannelStats *p, double d,
         p->min_runs += p->min_run * p->min_run;
     }
 
+    if (d != 0 && FFABS(d) < p->min_non_zero)
+        p->min_non_zero = FFABS(d);
+
     if (d > p->max) {
         p->max = d;
         p->nmax = nd;
@@ -197,6 +202,7 @@ static inline void update_stat(AudioStatsContext *s, ChannelStats *p, double d,
     p->min_diff = FFMIN(p->min_diff, fabs(d - p->last));
     p->max_diff = FFMAX(p->max_diff, fabs(d - p->last));
     p->diff1_sum += fabs(d - p->last);
+    p->diff1_sum_x2 += (d - p->last) * (d - p->last);
     p->last = d;
     p->mask |= i;
     p->imask &= i;
@@ -232,6 +238,7 @@ static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
            nmin = DBL_MAX, nmax = DBL_MIN,
            max_sigma_x = 0,
            diff1_sum = 0,
+           diff1_sum_x2 = 0,
            sigma_x = 0,
            sigma_x2 = 0,
            min_sigma_x2 = DBL_MAX,
@@ -251,7 +258,8 @@ static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
         nmax = FFMAX(nmax, p->nmax);
         min_diff = FFMIN(min_diff, p->min_diff);
         max_diff = FFMAX(max_diff, p->max_diff);
-        diff1_sum += p->diff1_sum,
+        diff1_sum += p->diff1_sum;
+        diff1_sum_x2 += p->diff1_sum_x2;
         min_sigma_x2 = FFMIN(min_sigma_x2, p->min_sigma_x2);
         max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
         sigma_x += p->sigma_x;
@@ -272,6 +280,7 @@ static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
         set_meta(metadata, c + 1, "Min_difference", "%f", p->min_diff);
         set_meta(metadata, c + 1, "Max_difference", "%f", p->max_diff);
         set_meta(metadata, c + 1, "Mean_difference", "%f", p->diff1_sum / (p->nb_samples - 1));
+        set_meta(metadata, c + 1, "RMS_difference", "%f", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
         set_meta(metadata, c + 1, "Peak_level", "%f", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
         set_meta(metadata, c + 1, "RMS_level", "%f", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
         set_meta(metadata, c + 1, "RMS_peak", "%f", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
@@ -282,6 +291,7 @@ static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
         bit_depth(s, p->mask, p->imask, &depth);
         set_meta(metadata, c + 1, "Bit_depth", "%f", depth.num);
         set_meta(metadata, c + 1, "Bit_depth2", "%f", depth.den);
+        set_meta(metadata, c + 1, "Dynamic_range", "%f", LINEAR_TO_DB(2 * FFMAX(FFABS(p->min), FFABS(p->max))/ p->min_non_zero));
     }
 
     set_meta(metadata, 0, "Overall.DC_offset", "%f", max_sigma_x / (nb_samples / s->nb_channels));
@@ -290,6 +300,7 @@ static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
     set_meta(metadata, 0, "Overall.Min_difference", "%f", min_diff);
     set_meta(metadata, 0, "Overall.Max_difference", "%f", max_diff);
     set_meta(metadata, 0, "Overall.Mean_difference", "%f", diff1_sum / (nb_samples - s->nb_channels));
+    set_meta(metadata, 0, "Overall.RMS_difference", "%f", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
     set_meta(metadata, 0, "Overall.Peak_level", "%f", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
     set_meta(metadata, 0, "Overall.RMS_level", "%f", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
     set_meta(metadata, 0, "Overall.RMS_peak", "%f", LINEAR_TO_DB(sqrt(max_sigma_x2)));
@@ -305,7 +316,7 @@ static void set_metadata(AudioStatsContext *s, AVDictionary **metadata)
 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
 {
     AudioStatsContext *s = inlink->dst->priv;
-    AVDictionary **metadata = avpriv_frame_get_metadatap(buf);
+    AVDictionary **metadata = &buf->metadata;
     const int channels = s->nb_channels;
     int i, c;
 
@@ -419,6 +430,7 @@ static void print_stats(AVFilterContext *ctx)
            min = DBL_MAX, max = DBL_MIN, min_diff = DBL_MAX, max_diff = 0,
            nmin = DBL_MAX, nmax = DBL_MIN,
            max_sigma_x = 0,
+           diff1_sum_x2 = 0,
            diff1_sum = 0,
            sigma_x = 0,
            sigma_x2 = 0,
@@ -439,7 +451,8 @@ static void print_stats(AVFilterContext *ctx)
         nmax = FFMAX(nmax, p->nmax);
         min_diff = FFMIN(min_diff, p->min_diff);
         max_diff = FFMAX(max_diff, p->max_diff);
-        diff1_sum += p->diff1_sum,
+        diff1_sum_x2 += p->diff1_sum_x2;
+        diff1_sum += p->diff1_sum;
         min_sigma_x2 = FFMIN(min_sigma_x2, p->min_sigma_x2);
         max_sigma_x2 = FFMAX(max_sigma_x2, p->max_sigma_x2);
         sigma_x += p->sigma_x;
@@ -461,6 +474,7 @@ static void print_stats(AVFilterContext *ctx)
         av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", p->min_diff);
         av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", p->max_diff);
         av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", p->diff1_sum / (p->nb_samples - 1));
+        av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(p->diff1_sum_x2 / (p->nb_samples - 1)));
         av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-p->nmin, p->nmax)));
         av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(p->sigma_x2 / p->nb_samples)));
         av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(p->max_sigma_x2)));
@@ -471,6 +485,7 @@ static void print_stats(AVFilterContext *ctx)
         av_log(ctx, AV_LOG_INFO, "Peak count: %"PRId64"\n", p->min_count + p->max_count);
         bit_depth(s, p->mask, p->imask, &depth);
         av_log(ctx, AV_LOG_INFO, "Bit depth: %u/%u\n", depth.num, depth.den);
+        av_log(ctx, AV_LOG_INFO, "Dynamic range: %f\n", LINEAR_TO_DB(2 * FFMAX(FFABS(p->min), FFABS(p->max))/ p->min_non_zero));
     }
 
     av_log(ctx, AV_LOG_INFO, "Overall\n");
@@ -480,6 +495,7 @@ static void print_stats(AVFilterContext *ctx)
     av_log(ctx, AV_LOG_INFO, "Min difference: %f\n", min_diff);
     av_log(ctx, AV_LOG_INFO, "Max difference: %f\n", max_diff);
     av_log(ctx, AV_LOG_INFO, "Mean difference: %f\n", diff1_sum / (nb_samples - s->nb_channels));
+    av_log(ctx, AV_LOG_INFO, "RMS difference: %f\n", sqrt(diff1_sum_x2 / (nb_samples - s->nb_channels)));
     av_log(ctx, AV_LOG_INFO, "Peak level dB: %f\n", LINEAR_TO_DB(FFMAX(-nmin, nmax)));
     av_log(ctx, AV_LOG_INFO, "RMS level dB: %f\n", LINEAR_TO_DB(sqrt(sigma_x2 / nb_samples)));
     av_log(ctx, AV_LOG_INFO, "RMS peak dB: %f\n", LINEAR_TO_DB(sqrt(max_sigma_x2)));
diff --git a/mythtv/external/FFmpeg/libavfilter/af_asyncts.c b/mythtv/external/FFmpeg/libavfilter/af_asyncts.c
deleted file mode 100644
index 22559a1e09c..00000000000
--- a/mythtv/external/FFmpeg/libavfilter/af_asyncts.c
+++ /dev/null
@@ -1,322 +0,0 @@
-/*
- * 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 <stdint.h>
-
-#include "libavresample/avresample.h"
-#include "libavutil/attributes.h"
-#include "libavutil/audio_fifo.h"
-#include "libavutil/common.h"
-#include "libavutil/mathematics.h"
-#include "libavutil/opt.h"
-#include "libavutil/samplefmt.h"
-
-#include "audio.h"
-#include "avfilter.h"
-#include "internal.h"
-
-typedef struct ASyncContext {
-    const AVClass *class;
-
-    AVAudioResampleContext *avr;
-    int64_t pts;            ///< timestamp in samples of the first sample in fifo
-    int min_delta;          ///< pad/trim min threshold in samples
-    int first_frame;        ///< 1 until filter_frame() has processed at least 1 frame with a pts != AV_NOPTS_VALUE
-    int64_t first_pts;      ///< user-specified first expected pts, in samples
-    int comp;               ///< current resample compensation
-
-    /* options */
-    int resample;
-    float min_delta_sec;
-    int max_comp;
-
-    /* set by filter_frame() to signal an output frame to request_frame() */
-    int got_output;
-} ASyncContext;
-
-#define OFFSET(x) offsetof(ASyncContext, x)
-#define A AV_OPT_FLAG_AUDIO_PARAM
-#define F AV_OPT_FLAG_FILTERING_PARAM
-static const AVOption asyncts_options[] = {
-    { "compensate", "Stretch/squeeze the data to make it match the timestamps", OFFSET(resample),      AV_OPT_TYPE_BOOL,  { .i64 = 0 },   0, 1,       A|F },
-    { "min_delta",  "Minimum difference between timestamps and audio data "
-                    "(in seconds) to trigger padding/trimmin the data.",        OFFSET(min_delta_sec), AV_OPT_TYPE_FLOAT, { .dbl = 0.1 }, 0, INT_MAX, A|F },
-    { "max_comp",   "Maximum compensation in samples per second.",              OFFSET(max_comp),      AV_OPT_TYPE_INT,   { .i64 = 500 }, 0, INT_MAX, A|F },
-    { "first_pts",  "Assume the first pts should be this value.",               OFFSET(first_pts),     AV_OPT_TYPE_INT64, { .i64 = AV_NOPTS_VALUE }, INT64_MIN, INT64_MAX, A|F },
-    { NULL }
-};
-
-AVFILTER_DEFINE_CLASS(asyncts);
-
-static av_cold int init(AVFilterContext *ctx)
-{
-    ASyncContext *s = ctx->priv;
-
-    s->pts         = AV_NOPTS_VALUE;
-    s->first_frame = 1;
-
-    return 0;
-}
-
-static av_cold void uninit(AVFilterContext *ctx)
-{
-    ASyncContext *s = ctx->priv;
-
-    if (s->avr) {
-        avresample_close(s->avr);
-        avresample_free(&s->avr);
-    }
-}
-
-static int config_props(AVFilterLink *link)
-{
-    ASyncContext *s = link->src->priv;
-    int ret;
-
-    s->min_delta = s->min_delta_sec * link->sample_rate;
-    link->time_base = (AVRational){1, link->sample_rate};
-
-    s->avr = avresample_alloc_context();
-    if (!s->avr)
-        return AVERROR(ENOMEM);
-
-    av_opt_set_int(s->avr,  "in_channel_layout", link->channel_layout, 0);
-    av_opt_set_int(s->avr, "out_channel_layout", link->channel_layout, 0);
-    av_opt_set_int(s->avr,  "in_sample_fmt",     link->format,         0);
-    av_opt_set_int(s->avr, "out_sample_fmt",     link->format,         0);
-    av_opt_set_int(s->avr,  "in_sample_rate",    link->sample_rate,    0);
-    av_opt_set_int(s->avr, "out_sample_rate",    link->sample_rate,    0);
-
-    if (s->resample)
-        av_opt_set_int(s->avr, "force_resampling", 1, 0);
-
-    if ((ret = avresample_open(s->avr)) < 0)
-        return ret;
-
-    return 0;
-}
-
-/* get amount of data currently buffered, in samples */
-static int64_t get_delay(ASyncContext *s)
-{
-    return avresample_available(s->avr) + avresample_get_delay(s->avr);
-}
-
-static void handle_trimming(AVFilterContext *ctx)
-{
-    ASyncContext *s = ctx->priv;
-
-    if (s->pts < s->first_pts) {
-        int delta = FFMIN(s->first_pts - s->pts, avresample_available(s->avr));
-        av_log(ctx, AV_LOG_VERBOSE, "Trimming %d samples from start\n",
-               delta);
-        avresample_read(s->avr, NULL, delta);
-        s->pts += delta;
-    } else if (s->first_frame)
-        s->pts = s->first_pts;
-}
-
-static int request_frame(AVFilterLink *link)
-{
-    AVFilterContext *ctx = link->src;
-    ASyncContext      *s = ctx->priv;
-    int ret = 0;
-    int nb_samples;
-
-    s->got_output = 0;
-    ret = ff_request_frame(ctx->inputs[0]);
-
-    /* flush the fifo */
-    if (ret == AVERROR_EOF) {
-        if (s->first_pts != AV_NOPTS_VALUE)
-            handle_trimming(ctx);
-
-        if (nb_samples = get_delay(s)) {
-            AVFrame *buf = ff_get_audio_buffer(link, nb_samples);
-            if (!buf)
-                return AVERROR(ENOMEM);
-            ret = avresample_convert(s->avr, buf->extended_data,
-                                     buf->linesize[0], nb_samples, NULL, 0, 0);
-            if (ret <= 0) {
-                av_frame_free(&buf);
-                return (ret < 0) ? ret : AVERROR_EOF;
-            }
-
-            buf->pts = s->pts;
-            return ff_filter_frame(link, buf);
-        }
-    }
-
-    return ret;
-}
-
-static int write_to_fifo(ASyncContext *s, AVFrame *buf)
-{
-    int ret = avresample_convert(s->avr, NULL, 0, 0, buf->extended_data,
-                                 buf->linesize[0], buf->nb_samples);
-    av_frame_free(&buf);
-    return ret;
-}
-
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
-{
-    AVFilterContext  *ctx = inlink->dst;
-    ASyncContext       *s = ctx->priv;
-    AVFilterLink *outlink = ctx->outputs[0];
-    int nb_channels = av_get_channel_layout_nb_channels(buf->channel_layout);
-    int64_t pts = (buf->pts == AV_NOPTS_VALUE) ? buf->pts :
-                  av_rescale_q(buf->pts, inlink->time_base, outlink->time_base);
-    int out_size, ret;
-    int64_t delta;
-    int64_t new_pts;
-
-    /* buffer data until we get the next timestamp */
-    if (s->pts == AV_NOPTS_VALUE || pts == AV_NOPTS_VALUE) {
-        if (pts != AV_NOPTS_VALUE) {
-            s->pts = pts - get_delay(s);
-        }
-        return write_to_fifo(s, buf);
-    }
-
-    if (s->first_pts != AV_NOPTS_VALUE) {
-        handle_trimming(ctx);
-        if (!avresample_available(s->avr))
-            return write_to_fifo(s, buf);
-    }
-
-    /* when we have two timestamps, compute how many samples would we have
-     * to add/remove to get proper sync between data and timestamps */
-    delta    = pts - s->pts - get_delay(s);
-    out_size = avresample_available(s->avr);
-
-    if (llabs(delta) > s->min_delta ||
-        (s->first_frame && delta && s->first_pts != AV_NOPTS_VALUE)) {
-        av_log(ctx, AV_LOG_VERBOSE, "Discontinuity - %"PRId64" samples.\n", delta);
-        out_size = av_clipl_int32((int64_t)out_size + delta);
-    } else {
-        if (s->resample) {
-            // adjust the compensation if delta is non-zero
-            int delay = get_delay(s);
-            int comp = s->comp + av_clip(delta * inlink->sample_rate / delay,
-                                         -s->max_comp, s->max_comp);
-            if (comp != s->comp) {
-                av_log(ctx, AV_LOG_VERBOSE, "Compensating %d samples per second.\n", comp);
-                if (avresample_set_compensation(s->avr, comp, inlink->sample_rate) == 0) {
-                    s->comp = comp;
-                }
-            }
-        }
-        // adjust PTS to avoid monotonicity errors with input PTS jitter
-        pts -= delta;
-        delta = 0;
-    }
-
-    if (out_size > 0) {
-        AVFrame *buf_out = ff_get_audio_buffer(outlink, out_size);
-        if (!buf_out) {
-            ret = AVERROR(ENOMEM);
-            goto fail;
-        }
-
-        if (s->first_frame && delta > 0) {
-            int planar = av_sample_fmt_is_planar(buf_out->format);
-            int planes = planar ?  nb_channels : 1;
-            int block_size = av_get_bytes_per_sample(buf_out->format) *
-                             (planar ? 1 : nb_channels);
-
-            int ch;
-
-            av_samples_set_silence(buf_out->extended_data, 0, delta,
-                                   nb_channels, buf->format);
-
-            for (ch = 0; ch < planes; ch++)
-                buf_out->extended_data[ch] += delta * block_size;
-
-            avresample_read(s->avr, buf_out->extended_data, out_size);
-
-            for (ch = 0; ch < planes; ch++)
-                buf_out->extended_data[ch] -= delta * block_size;
-        } else {
-            avresample_read(s->avr, buf_out->extended_data, out_size);
-
-            if (delta > 0) {
-                av_samples_set_silence(buf_out->extended_data, out_size - delta,
-                                       delta, nb_channels, buf->format);
-            }
-        }
-        buf_out->pts = s->pts;
-        ret = ff_filter_frame(outlink, buf_out);
-        if (ret < 0)
-            goto fail;
-        s->got_output = 1;
-    } else if (avresample_available(s->avr)) {
-        av_log(ctx, AV_LOG_WARNING, "Non-monotonous timestamps, dropping "
-               "whole buffer.\n");
-    }
-
-    /* drain any remaining buffered data */
-    avresample_read(s->avr, NULL, avresample_available(s->avr));
-
-    new_pts = pts - avresample_get_delay(s->avr);
-    /* check for s->pts monotonicity */
-    if (new_pts > s->pts) {
-        s->pts = new_pts;
-        ret = avresample_convert(s->avr, NULL, 0, 0, buf->extended_data,
-                                 buf->linesize[0], buf->nb_samples);
-    } else {
-        av_log(ctx, AV_LOG_WARNING, "Non-monotonous timestamps, dropping "
-               "whole buffer.\n");
-        ret = 0;
-    }
-
-    s->first_frame = 0;
-fail:
-    av_frame_free(&buf);
-
-    return ret;
-}
-
-static const AVFilterPad avfilter_af_asyncts_inputs[] = {
-    {
-        .name          = "default",
-        .type          = AVMEDIA_TYPE_AUDIO,
-        .filter_frame  = filter_frame
-    },
-    { NULL }
-};
-
-static const AVFilterPad avfilter_af_asyncts_outputs[] = {
-    {
-        .name          = "default",
-        .type          = AVMEDIA_TYPE_AUDIO,
-        .config_props  = config_props,
-        .request_frame = request_frame
-    },
-    { NULL }
-};
-
-AVFilter ff_af_asyncts = {
-    .name        = "asyncts",
-    .description = NULL_IF_CONFIG_SMALL("Sync audio data to timestamps."),
-    .init        = init,
-    .uninit      = uninit,
-    .priv_size   = sizeof(ASyncContext),
-    .priv_class  = &asyncts_class,
-    .inputs      = avfilter_af_asyncts_inputs,
-    .outputs     = avfilter_af_asyncts_outputs,
-};
diff --git a/mythtv/external/FFmpeg/libavfilter/af_atempo.c b/mythtv/external/FFmpeg/libavfilter/af_atempo.c
index d5d29b3665d..8b214bccd7b 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_atempo.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_atempo.c
@@ -53,7 +53,7 @@
 /**
  * A fragment of audio waveform
  */
-typedef struct {
+typedef struct AudioFragment {
     // index of the first sample of this fragment in the overall waveform;
     // 0: input sample position
     // 1: output sample position
@@ -84,7 +84,7 @@ typedef enum {
 /**
  * Filter state machine
  */
-typedef struct {
+typedef struct ATempoContext {
     const AVClass *class;
 
     // ring-buffer of input samples, necessary because some times
@@ -697,11 +697,11 @@ static int yae_adjust_position(ATempoContext *atempo)
     AudioFragment       *frag = yae_curr_frag(atempo);
 
     const double prev_output_position =
-        (double)(prev->position[1] - atempo->origin[1] + atempo->window / 2);
+        (double)(prev->position[1] - atempo->origin[1] + atempo->window / 2) *
+        atempo->tempo;
 
     const double ideal_output_position =
-        (double)(prev->position[0] - atempo->origin[0] + atempo->window / 2) /
-        atempo->tempo;
+        (double)(prev->position[0] - atempo->origin[0] + atempo->window / 2);
 
     const int drift = (int)(prev_output_position - ideal_output_position);
 
@@ -914,6 +914,11 @@ static int yae_flush(ATempoContext *atempo,
 
     atempo->state = YAE_FLUSH_OUTPUT;
 
+    if (!atempo->nfrag) {
+        // there is nothing to flush:
+        return 0;
+    }
+
     if (atempo->position[0] == frag->position[0] + frag->nsamples &&
         atempo->position[1] == frag->position[1] + frag->nsamples) {
         // the current fragment is already flushed:
@@ -1014,7 +1019,7 @@ static int query_formats(AVFilterContext *ctx)
     };
     int ret;
 
-    layouts = ff_all_channel_layouts();
+    layouts = ff_all_channel_counts();
     if (!layouts) {
         return AVERROR(ENOMEM);
     }
@@ -1090,8 +1095,10 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *src_buffer)
     while (src < src_end) {
         if (!atempo->dst_buffer) {
             atempo->dst_buffer = ff_get_audio_buffer(outlink, n_out);
-            if (!atempo->dst_buffer)
+            if (!atempo->dst_buffer) {
+                av_frame_free(&src_buffer);
                 return AVERROR(ENOMEM);
+            }
             av_frame_copy_props(atempo->dst_buffer, src_buffer);
 
             atempo->dst = atempo->dst_buffer->data[0];
@@ -1146,6 +1153,8 @@ static int request_frame(AVFilterLink *outlink)
 
             if (n_out) {
                 ret = push_samples(atempo, outlink, n_out);
+                if (ret < 0)
+                    return ret;
             }
         }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/af_biquads.c b/mythtv/external/FFmpeg/libavfilter/af_biquads.c
index 4953202d45a..c4f619a4239 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_biquads.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_biquads.c
@@ -105,12 +105,14 @@ typedef struct BiquadsContext {
     double gain;
     double frequency;
     double width;
+    uint64_t channels;
 
     double a0, a1, a2;
     double b0, b1, b2;
 
     ChanCache *cache;
     int clippings;
+    int block_align;
 
     void (*filter)(struct BiquadsContext *s, const void *ibuf, void *obuf, int len,
                    double *i1, double *i2, double *o1, double *o2,
@@ -388,6 +390,8 @@ static int config_output(AVFilterLink *outlink)
     default: av_assert0(0);
     }
 
+    s->block_align = av_get_bytes_per_sample(inlink->format);
+
     return 0;
 }
 
@@ -411,15 +415,22 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
         av_frame_copy_props(out_buf, buf);
     }
 
-    for (ch = 0; ch < av_frame_get_channels(buf); ch++)
+    for (ch = 0; ch < buf->channels; ch++) {
+        if (!((av_channel_layout_extract_channel(inlink->channel_layout, ch) & s->channels))) {
+            if (buf != out_buf)
+                memcpy(out_buf->extended_data[ch], buf->extended_data[ch], nb_samples * s->block_align);
+            continue;
+        }
         s->filter(s, buf->extended_data[ch],
                   out_buf->extended_data[ch], nb_samples,
                   &s->cache[ch].i1, &s->cache[ch].i2,
                   &s->cache[ch].o1, &s->cache[ch].o2,
                   s->b0, s->b1, s->b2, s->a1, s->a2);
+    }
 
     if (s->clippings > 0)
         av_log(ctx, AV_LOG_WARNING, "clipping %d times. Please reduce gain.\n", s->clippings);
+    s->clippings = 0;
 
     if (buf != out_buf)
         av_frame_free(&buf);
@@ -482,6 +493,7 @@ static const AVOption equalizer_options[] = {
     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, 999999, FLAGS},
     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
+    {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
@@ -490,6 +502,8 @@ static const AVOption equalizer_options[] = {
     {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=1}, 0, 999, FLAGS},
     {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
     {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
+    {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
+    {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
     {NULL}
 };
 
@@ -500,6 +514,7 @@ static const AVOption bass_options[] = {
     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=100}, 0, 999999, FLAGS},
     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
+    {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
@@ -508,6 +523,8 @@ static const AVOption bass_options[] = {
     {"w",     "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
     {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
     {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
+    {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
+    {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
     {NULL}
 };
 
@@ -518,6 +535,7 @@ static const AVOption treble_options[] = {
     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
+    {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
@@ -526,6 +544,8 @@ static const AVOption treble_options[] = {
     {"w",     "set shelf transition steep", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 99999, FLAGS},
     {"gain", "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
     {"g",    "set gain", OFFSET(gain), AV_OPT_TYPE_DOUBLE, {.dbl=0}, -900, 900, FLAGS},
+    {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
+    {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
     {NULL}
 };
 
@@ -536,6 +556,7 @@ static const AVOption bandpass_options[] = {
     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
+    {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
@@ -543,6 +564,8 @@ static const AVOption bandpass_options[] = {
     {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
     {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
     {"csg",   "use constant skirt gain", OFFSET(csg), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+    {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
+    {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
     {NULL}
 };
 
@@ -553,12 +576,15 @@ static const AVOption bandreject_options[] = {
     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
+    {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
     {"width", "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
     {"w",     "set band-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.5}, 0, 999, FLAGS},
+    {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
+    {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
     {NULL}
 };
 
@@ -569,6 +595,7 @@ static const AVOption lowpass_options[] = {
     {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
     {"f",         "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=500}, 0, 999999, FLAGS},
     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
+    {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
@@ -577,6 +604,8 @@ static const AVOption lowpass_options[] = {
     {"w",     "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
     {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
     {"p",     "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
+    {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
+    {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
     {NULL}
 };
 
@@ -587,6 +616,7 @@ static const AVOption highpass_options[] = {
     {"frequency", "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
     {"f",         "set frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
+    {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=QFACTOR}, HERTZ, SLOPE, FLAGS, "width_type"},
     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
@@ -595,6 +625,8 @@ static const AVOption highpass_options[] = {
     {"w",     "set width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=0.707}, 0, 99999, FLAGS},
     {"poles", "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
     {"p",     "set number of poles", OFFSET(poles), AV_OPT_TYPE_INT, {.i64=2}, 1, 2, FLAGS},
+    {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
+    {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
     {NULL}
 };
 
@@ -605,12 +637,15 @@ static const AVOption allpass_options[] = {
     {"frequency", "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
     {"f",         "set central frequency", OFFSET(frequency), AV_OPT_TYPE_DOUBLE, {.dbl=3000}, 0, 999999, FLAGS},
     {"width_type", "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, SLOPE, FLAGS, "width_type"},
+    {"t",          "set filter-width type", OFFSET(width_type), AV_OPT_TYPE_INT, {.i64=HERTZ}, HERTZ, SLOPE, FLAGS, "width_type"},
     {"h", "Hz", 0, AV_OPT_TYPE_CONST, {.i64=HERTZ}, 0, 0, FLAGS, "width_type"},
     {"q", "Q-Factor", 0, AV_OPT_TYPE_CONST, {.i64=QFACTOR}, 0, 0, FLAGS, "width_type"},
     {"o", "octave", 0, AV_OPT_TYPE_CONST, {.i64=OCTAVE}, 0, 0, FLAGS, "width_type"},
     {"s", "slope", 0, AV_OPT_TYPE_CONST, {.i64=SLOPE}, 0, 0, FLAGS, "width_type"},
     {"width", "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
     {"w",     "set filter-width", OFFSET(width), AV_OPT_TYPE_DOUBLE, {.dbl=707.1}, 0, 99999, FLAGS},
+    {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
+    {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
     {NULL}
 };
 
@@ -624,6 +659,8 @@ static const AVOption biquad_options[] = {
     {"b0", NULL, OFFSET(b0), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
     {"b1", NULL, OFFSET(b1), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
     {"b2", NULL, OFFSET(b2), AV_OPT_TYPE_DOUBLE, {.dbl=1}, INT16_MIN, INT16_MAX, FLAGS},
+    {"channels", "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
+    {"c",        "set channels to filter", OFFSET(channels), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64=-1}, INT64_MIN, INT64_MAX, FLAGS},
     {NULL}
 };
 
diff --git a/mythtv/external/FFmpeg/libavfilter/af_bs2b.c b/mythtv/external/FFmpeg/libavfilter/af_bs2b.c
index 54d52c5c6e9..b7cfd3815b0 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_bs2b.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_bs2b.c
@@ -45,7 +45,7 @@ typedef struct Bs2bContext {
 } Bs2bContext;
 
 #define OFFSET(x) offsetof(Bs2bContext, x)
-#define A AV_OPT_FLAG_AUDIO_PARAM
+#define A AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
 
 static const AVOption bs2b_options[] = {
     { "profile", "Apply a pre-defined crossfeed level",
@@ -134,8 +134,10 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
         out_frame = frame;
     } else {
         out_frame = ff_get_audio_buffer(inlink, frame->nb_samples);
-        if (!out_frame)
+        if (!out_frame) {
+            av_frame_free(&frame);
             return AVERROR(ENOMEM);
+        }
         av_frame_copy(out_frame, frame);
         ret = av_frame_copy_props(out_frame, frame);
         if (ret < 0) {
diff --git a/mythtv/external/FFmpeg/libavfilter/af_channelmap.c b/mythtv/external/FFmpeg/libavfilter/af_channelmap.c
index dcae2a21d9a..7c2be95bfd4 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_channelmap.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_channelmap.c
@@ -291,7 +291,7 @@ static int channelmap_query_formats(AVFilterContext *ctx)
     AVFilterChannelLayouts *channel_layouts = NULL;
     int ret;
 
-    layouts = ff_all_channel_layouts();
+    layouts = ff_all_channel_counts();
     if (!layouts) {
         ret = AVERROR(ENOMEM);
         goto fail;
@@ -316,7 +316,7 @@ static int channelmap_filter_frame(AVFilterLink *inlink, AVFrame *buf)
     AVFilterContext  *ctx = inlink->dst;
     AVFilterLink *outlink = ctx->outputs[0];
     const ChannelMapContext *s = ctx->priv;
-    const int nch_in = av_get_channel_layout_nb_channels(inlink->channel_layout);
+    const int nch_in = inlink->channels;
     const int nch_out = s->nch;
     int ch;
     uint8_t *source_planes[MAX_CH];
@@ -354,7 +354,7 @@ static int channelmap_filter_frame(AVFilterLink *inlink, AVFrame *buf)
            FFMIN(FF_ARRAY_ELEMS(buf->data), nch_out) * sizeof(buf->data[0]));
 
     buf->channel_layout = outlink->channel_layout;
-    av_frame_set_channels(buf, outlink->channels);
+    buf->channels       = outlink->channels;
 
     return ff_filter_frame(outlink, buf);
 }
@@ -363,7 +363,7 @@ static int channelmap_config_input(AVFilterLink *inlink)
 {
     AVFilterContext *ctx = inlink->dst;
     ChannelMapContext *s = ctx->priv;
-    int nb_channels = av_get_channel_layout_nb_channels(inlink->channel_layout);
+    int nb_channels = inlink->channels;
     int i, err = 0;
     const char *channel_name;
     char layout_name[256];
@@ -378,7 +378,7 @@ static int channelmap_config_input(AVFilterLink *inlink)
 
         if (m->in_channel_idx < 0 || m->in_channel_idx >= nb_channels) {
             av_get_channel_layout_string(layout_name, sizeof(layout_name),
-                                         0, inlink->channel_layout);
+                                         nb_channels, inlink->channel_layout);
             if (m->in_channel) {
                 channel_name = av_get_channel_name(m->in_channel);
                 av_log(ctx, AV_LOG_ERROR,
diff --git a/mythtv/external/FFmpeg/libavfilter/af_channelsplit.c b/mythtv/external/FFmpeg/libavfilter/af_channelsplit.c
index f50414984a9..8c6b00fe4f5 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_channelsplit.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_channelsplit.c
@@ -71,7 +71,9 @@ static av_cold int init(AVFilterContext *ctx)
         pad.type = AVMEDIA_TYPE_AUDIO;
         pad.name = av_get_channel_name(channel);
 
-        ff_insert_outpad(ctx, i, &pad);
+        if ((ret = ff_insert_outpad(ctx, i, &pad)) < 0) {
+            return ret;
+        }
     }
 
 fail:
@@ -120,7 +122,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
         buf_out->data[0] = buf_out->extended_data[0] = buf_out->extended_data[i];
         buf_out->channel_layout =
             av_channel_layout_extract_channel(buf->channel_layout, i);
-        av_frame_set_channels(buf_out, 1);
+        buf_out->channels = 1;
 
         ret = ff_filter_frame(ctx->outputs[i], buf_out);
         if (ret < 0)
diff --git a/mythtv/external/FFmpeg/libavfilter/af_chorus.c b/mythtv/external/FFmpeg/libavfilter/af_chorus.c
index c596164382d..87c82900970 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_chorus.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_chorus.c
@@ -96,7 +96,8 @@ static void fill_items(char *item_str, int *nb_items, float *items)
     for (i = 0; i < *nb_items; i++) {
         char *tstr = av_strtok(p, "|", &saveptr);
         p = NULL;
-        new_nb_items += sscanf(tstr, "%f", &items[i]) == 1;
+        if (tstr)
+            new_nb_items += sscanf(tstr, "%f", &items[new_nb_items]) == 1;
     }
 
     *nb_items = new_nb_items;
diff --git a/mythtv/external/FFmpeg/libavfilter/af_compand.c b/mythtv/external/FFmpeg/libavfilter/af_compand.c
index 0bb719fae5a..8589b1ef094 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_compand.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_compand.c
@@ -72,9 +72,9 @@ typedef struct CompandContext {
 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 
 static const AVOption compand_options[] = {
-    { "attacks", "set time over which increase of volume is determined", OFFSET(attacks), AV_OPT_TYPE_STRING, { .str = "0.3" }, 0, 0, A },
+    { "attacks", "set time over which increase of volume is determined", OFFSET(attacks), AV_OPT_TYPE_STRING, { .str = "0" }, 0, 0, A },
     { "decays", "set time over which decrease of volume is determined", OFFSET(decays), AV_OPT_TYPE_STRING, { .str = "0.8" }, 0, 0, A },
-    { "points", "set points of transfer function", OFFSET(points), AV_OPT_TYPE_STRING, { .str = "-70/-70|-60/-20" }, 0, 0, A },
+    { "points", "set points of transfer function", OFFSET(points), AV_OPT_TYPE_STRING, { .str = "-70/-70|-60/-20|1/0" }, 0, 0, A },
     { "soft-knee", "set soft-knee", OFFSET(curve_dB), AV_OPT_TYPE_DOUBLE, { .dbl = 0.01 }, 0.01, 900, A },
     { "gain", "set output gain", OFFSET(gain_dB), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -900, 900, A },
     { "volume", "set initial volume", OFFSET(initial_volume), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -900, 0, A },
@@ -368,6 +368,10 @@ static int config_output(AVFilterLink *outlink)
     p = s->attacks;
     for (i = 0, new_nb_items = 0; i < nb_attacks; i++) {
         char *tstr = av_strtok(p, " |", &saveptr);
+        if (!tstr) {
+            uninit(ctx);
+            return AVERROR(EINVAL);
+        }
         p = NULL;
         new_nb_items += sscanf(tstr, "%lf", &s->channels[i].attack) == 1;
         if (s->channels[i].attack < 0) {
@@ -380,6 +384,10 @@ static int config_output(AVFilterLink *outlink)
     p = s->decays;
     for (i = 0, new_nb_items = 0; i < nb_decays; i++) {
         char *tstr = av_strtok(p, " |", &saveptr);
+        if (!tstr) {
+            uninit(ctx);
+            return AVERROR(EINVAL);
+        }
         p = NULL;
         new_nb_items += sscanf(tstr, "%lf", &s->channels[i].decay) == 1;
         if (s->channels[i].decay < 0) {
@@ -407,7 +415,7 @@ static int config_output(AVFilterLink *outlink)
     for (i = 0, new_nb_items = 0; i < nb_points; i++) {
         char *tstr = av_strtok(p, " |", &saveptr);
         p = NULL;
-        if (sscanf(tstr, "%lf/%lf", &S(i).x, &S(i).y) != 2) {
+        if (!tstr || sscanf(tstr, "%lf/%lf", &S(i).x, &S(i).y) != 2) {
             av_log(ctx, AV_LOG_ERROR,
                     "Invalid and/or missing input/output value.\n");
             uninit(ctx);
diff --git a/mythtv/external/FFmpeg/libavfilter/af_crossfeed.c b/mythtv/external/FFmpeg/libavfilter/af_crossfeed.c
new file mode 100644
index 00000000000..d3def92fb39
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/af_crossfeed.c
@@ -0,0 +1,169 @@
+/*
+ * 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/channel_layout.h"
+#include "libavutil/opt.h"
+#include "avfilter.h"
+#include "audio.h"
+#include "formats.h"
+
+typedef struct CrossfeedContext {
+    const AVClass *class;
+
+    double range;
+    double strength;
+    double level_in;
+    double level_out;
+
+    double a0, a1, a2;
+    double b0, b1, b2;
+
+    double i1, i2;
+    double o1, o2;
+} CrossfeedContext;
+
+static int query_formats(AVFilterContext *ctx)
+{
+    AVFilterFormats *formats = NULL;
+    AVFilterChannelLayouts *layout = NULL;
+    int ret;
+
+    if ((ret = ff_add_format                 (&formats, AV_SAMPLE_FMT_DBL  )) < 0 ||
+        (ret = ff_set_common_formats         (ctx     , formats            )) < 0 ||
+        (ret = ff_add_channel_layout         (&layout , AV_CH_LAYOUT_STEREO)) < 0 ||
+        (ret = ff_set_common_channel_layouts (ctx     , layout             )) < 0 ||
+        (ret = ff_set_common_samplerates     (ctx     , ff_all_samplerates())) < 0)
+        return ret;
+
+    return 0;
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    CrossfeedContext *s = ctx->priv;
+    double A = exp(s->strength * -30 / 40 * log(10.));
+    double w0 = 2 * M_PI * (1. - s->range) * 2100 / inlink->sample_rate;
+    double alpha;
+
+    alpha = sin(w0) / 2 * sqrt(2 * (1 / 0.5 - 1) + 2);
+
+    s->a0 =          (A + 1) + (A - 1) * cos(w0) + 2 * sqrt(A) * alpha;
+    s->a1 =    -2 * ((A - 1) + (A + 1) * cos(w0));
+    s->a2 =          (A + 1) + (A - 1) * cos(w0) - 2 * sqrt(A) * alpha;
+    s->b0 =     A * ((A + 1) - (A - 1) * cos(w0) + 2 * sqrt(A) * alpha);
+    s->b1 = 2 * A * ((A - 1) - (A + 1) * cos(w0));
+    s->b2 =     A * ((A + 1) - (A - 1) * cos(w0) - 2 * sqrt(A) * alpha);
+
+    s->a1 /= s->a0;
+    s->a2 /= s->a0;
+    s->b0 /= s->a0;
+    s->b1 /= s->a0;
+    s->b2 /= s->a0;
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx = inlink->dst;
+    AVFilterLink *outlink = ctx->outputs[0];
+    CrossfeedContext *s = ctx->priv;
+    const double *src = (const double *)in->data[0];
+    const double level_in = s->level_in;
+    const double level_out = s->level_out;
+    const double b0 = s->b0;
+    const double b1 = s->b1;
+    const double b2 = s->b2;
+    const double a1 = s->a1;
+    const double a2 = s->a2;
+    AVFrame *out;
+    double *dst;
+    int n;
+
+    if (av_frame_is_writable(in)) {
+        out = in;
+    } else {
+        out = ff_get_audio_buffer(inlink, in->nb_samples);
+        if (!out) {
+            av_frame_free(&in);
+            return AVERROR(ENOMEM);
+        }
+        av_frame_copy_props(out, in);
+    }
+    dst = (double *)out->data[0];
+
+    for (n = 0; n < out->nb_samples; n++, src += 2, dst += 2) {
+        double mid = (src[0] + src[1]) * level_in * .5;
+        double side = (src[0] - src[1]) * level_in * .5;
+        double oside = side * b0 + s->i1 * b1 + s->i2 * b2 - s->o1 * a1 - s->o2 * a2;
+
+        s->i2 = s->i1;
+        s->i1 = side;
+        s->o2 = s->o1;
+        s->o1 = oside;
+
+        dst[0] = (mid + oside) * level_out;
+        dst[1] = (mid - oside) * level_out;
+    }
+
+    if (out != in)
+        av_frame_free(&in);
+    return ff_filter_frame(outlink, out);
+}
+
+#define OFFSET(x) offsetof(CrossfeedContext, x)
+#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+
+static const AVOption crossfeed_options[] = {
+    { "strength",  "set crossfeed strength",  OFFSET(strength),  AV_OPT_TYPE_DOUBLE, {.dbl=.2}, 0, 1, FLAGS },
+    { "range",     "set soundstage wideness", OFFSET(range),     AV_OPT_TYPE_DOUBLE, {.dbl=.5}, 0, 1, FLAGS },
+    { "level_in",  "set level in",            OFFSET(level_in),  AV_OPT_TYPE_DOUBLE, {.dbl=.9}, 0, 1, FLAGS },
+    { "level_out", "set level out",           OFFSET(level_out), AV_OPT_TYPE_DOUBLE, {.dbl=1.}, 0, 1, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(crossfeed);
+
+static const AVFilterPad inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_AUDIO,
+        .filter_frame = filter_frame,
+        .config_props = config_input,
+    },
+    { NULL }
+};
+
+static const AVFilterPad outputs[] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_AUDIO,
+    },
+    { NULL }
+};
+
+AVFilter ff_af_crossfeed = {
+    .name           = "crossfeed",
+    .description    = NULL_IF_CONFIG_SMALL("Apply headphone crossfeed filter."),
+    .query_formats  = query_formats,
+    .priv_size      = sizeof(CrossfeedContext),
+    .priv_class     = &crossfeed_class,
+    .inputs         = inputs,
+    .outputs        = outputs,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/af_crystalizer.c b/mythtv/external/FFmpeg/libavfilter/af_crystalizer.c
index 086549a93d1..dec30aa5f48 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_crystalizer.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_crystalizer.c
@@ -29,6 +29,8 @@ typedef struct CrystalizerContext {
     float mult;
     int clip;
     AVFrame *prev;
+    void (*filter)(void **dst, void **prv, const void **src,
+                   int nb_samples, int channels, float mult, int clip);
 } CrystalizerContext;
 
 #define OFFSET(x) offsetof(CrystalizerContext, x)
@@ -46,10 +48,18 @@ static int query_formats(AVFilterContext *ctx)
 {
     AVFilterFormats *formats = NULL;
     AVFilterChannelLayouts *layouts = NULL;
+    static const enum AVSampleFormat sample_fmts[] = {
+        AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
+        AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP,
+        AV_SAMPLE_FMT_NONE
+    };
     int ret;
 
-    if ((ret = ff_add_format        (&formats, AV_SAMPLE_FMT_FLT )) < 0 ||
-        (ret = ff_set_common_formats(ctx     , formats           )) < 0)
+    formats = ff_make_format_list(sample_fmts);
+    if (!formats)
+        return AVERROR(ENOMEM);
+    ret = ff_set_common_formats(ctx, formats);
+    if (ret < 0)
         return ret;
 
     layouts = ff_all_channel_counts();
@@ -64,16 +74,123 @@ static int query_formats(AVFilterContext *ctx)
     return ff_set_common_samplerates(ctx, formats);
 }
 
+static void filter_flt(void **d, void **p, const void **s,
+                       int nb_samples, int channels,
+                       float mult, int clip)
+{
+    const float *src = s[0];
+    float *dst = d[0];
+    float *prv = p[0];
+    int n, c;
+
+    for (n = 0; n < nb_samples; n++) {
+        for (c = 0; c < channels; c++) {
+            float current = src[c];
+
+            dst[c] = current + (current - prv[c]) * mult;
+            prv[c] = current;
+            if (clip) {
+                dst[c] = av_clipf(dst[c], -1, 1);
+            }
+        }
+
+        dst += c;
+        src += c;
+    }
+}
+
+static void filter_dbl(void **d, void **p, const void **s,
+                       int nb_samples, int channels,
+                       float mult, int clip)
+{
+    const double *src = s[0];
+    double *dst = d[0];
+    double *prv = p[0];
+    int n, c;
+
+    for (n = 0; n < nb_samples; n++) {
+        for (c = 0; c < channels; c++) {
+            double current = src[c];
+
+            dst[c] = current + (current - prv[c]) * mult;
+            prv[c] = current;
+            if (clip) {
+                dst[c] = av_clipd(dst[c], -1, 1);
+            }
+        }
+
+        dst += c;
+        src += c;
+    }
+}
+
+static void filter_fltp(void **d, void **p, const void **s,
+                        int nb_samples, int channels,
+                        float mult, int clip)
+{
+    int n, c;
+
+    for (c = 0; c < channels; c++) {
+        const float *src = s[c];
+        float *dst = d[c];
+        float *prv = p[c];
+
+        for (n = 0; n < nb_samples; n++) {
+            float current = src[n];
+
+            dst[n] = current + (current - prv[0]) * mult;
+            prv[0] = current;
+            if (clip) {
+                dst[n] = av_clipf(dst[n], -1, 1);
+            }
+        }
+    }
+}
+
+static void filter_dblp(void **d, void **p, const void **s,
+                        int nb_samples, int channels,
+                        float mult, int clip)
+{
+    int n, c;
+
+    for (c = 0; c < channels; c++) {
+        const double *src = s[c];
+        double *dst = d[c];
+        double *prv = p[c];
+
+        for (n = 0; n < nb_samples; n++) {
+            double current = src[n];
+
+            dst[n] = current + (current - prv[0]) * mult;
+            prv[0] = current;
+            if (clip) {
+                dst[n] = av_clipd(dst[n], -1, 1);
+            }
+        }
+    }
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    CrystalizerContext *s    = ctx->priv;
+
+    switch (inlink->format) {
+    case AV_SAMPLE_FMT_FLT:  s->filter = filter_flt;  break;
+    case AV_SAMPLE_FMT_DBL:  s->filter = filter_dbl;  break;
+    case AV_SAMPLE_FMT_FLTP: s->filter = filter_fltp; break;
+    case AV_SAMPLE_FMT_DBLP: s->filter = filter_dblp; break;
+    }
+
+    return 0;
+}
+
 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 {
     AVFilterContext *ctx = inlink->dst;
     AVFilterLink *outlink = ctx->outputs[0];
     CrystalizerContext *s = ctx->priv;
-    const float *src = (const float *)in->data[0];
-    const float mult = s->mult;
     AVFrame *out;
-    float *dst, *prv;
-    int n, c;
 
     if (!s->prev) {
         s->prev = ff_get_audio_buffer(inlink, 1);
@@ -94,22 +211,8 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         av_frame_copy_props(out, in);
     }
 
-    dst = (float *)out->data[0];
-    prv = (float *)s->prev->data[0];
-
-    for (n = 0; n < in->nb_samples; n++) {
-        for (c = 0; c < in->channels; c++) {
-            float current = src[c];
-
-            dst[c] = current + (current - prv[c]) * mult;
-            prv[c] = current;
-            if (s->clip) {
-                dst[c] = av_clipf(dst[c], -1, 1);
-            }
-        }
-        dst += c;
-        src += c;
-    }
+    s->filter((void **)out->extended_data, (void **)s->prev->extended_data, (const void **)in->extended_data,
+              in->nb_samples, in->channels, s->mult, s->clip);
 
     if (out != in)
         av_frame_free(&in);
@@ -129,6 +232,7 @@ static const AVFilterPad inputs[] = {
         .name         = "default",
         .type         = AVMEDIA_TYPE_AUDIO,
         .filter_frame = filter_frame,
+        .config_props = config_input,
     },
     { NULL }
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/af_dcshift.c b/mythtv/external/FFmpeg/libavfilter/af_dcshift.c
index 7332c12b195..6d33daee0b6 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_dcshift.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_dcshift.c
@@ -85,16 +85,21 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 {
     AVFilterContext *ctx = inlink->dst;
     AVFilterLink *outlink = ctx->outputs[0];
-    AVFrame *out = ff_get_audio_buffer(inlink, in->nb_samples);
+    AVFrame *out;
     DCShiftContext *s = ctx->priv;
     int i, j;
     double dcshift = s->dcshift;
 
-    if (!out) {
-        av_frame_free(&in);
-        return AVERROR(ENOMEM);
+    if (av_frame_is_writable(in)) {
+        out = in;
+    } else {
+        out = ff_get_audio_buffer(outlink, in->nb_samples);
+        if (!out) {
+            av_frame_free(&in);
+            return AVERROR(ENOMEM);
+        }
+        av_frame_copy_props(out, in);
     }
-    av_frame_copy_props(out, in);
 
     if (s->limitergain > 0) {
         for (i = 0; i < inlink->channels; i++) {
@@ -134,7 +139,8 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         }
     }
 
-    av_frame_free(&in);
+    if (out != in)
+        av_frame_free(&in);
     return ff_filter_frame(outlink, out);
 }
 static const AVFilterPad dcshift_inputs[] = {
diff --git a/mythtv/external/FFmpeg/libavfilter/af_dynaudnorm.c b/mythtv/external/FFmpeg/libavfilter/af_dynaudnorm.c
index 91ec45a2daf..59193042677 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_dynaudnorm.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_dynaudnorm.c
@@ -341,7 +341,7 @@ static inline double fade(double prev, double next, int pos,
     return fade_factors[0][pos] * prev + fade_factors[1][pos] * next;
 }
 
-static inline double pow2(const double value)
+static inline double pow_2(const double value)
 {
     return value * value;
 }
@@ -358,7 +358,7 @@ static double find_peak_magnitude(AVFrame *frame, int channel)
     int c, i;
 
     if (channel == -1) {
-        for (c = 0; c < av_frame_get_channels(frame); c++) {
+        for (c = 0; c < frame->channels; c++) {
             double *data_ptr = (double *)frame->extended_data[c];
 
             for (i = 0; i < frame->nb_samples; i++)
@@ -380,19 +380,19 @@ static double compute_frame_rms(AVFrame *frame, int channel)
     int c, i;
 
     if (channel == -1) {
-        for (c = 0; c < av_frame_get_channels(frame); c++) {
+        for (c = 0; c < frame->channels; c++) {
             const double *data_ptr = (double *)frame->extended_data[c];
 
             for (i = 0; i < frame->nb_samples; i++) {
-                rms_value += pow2(data_ptr[i]);
+                rms_value += pow_2(data_ptr[i]);
             }
         }
 
-        rms_value /= frame->nb_samples * av_frame_get_channels(frame);
+        rms_value /= frame->nb_samples * frame->channels;
     } else {
         const double *data_ptr = (double *)frame->extended_data[channel];
         for (i = 0; i < frame->nb_samples; i++) {
-            rms_value += pow2(data_ptr[i]);
+            rms_value += pow_2(data_ptr[i]);
         }
 
         rms_value /= frame->nb_samples;
@@ -460,7 +460,8 @@ static void update_gain_history(DynamicAudioNormalizerContext *s, int channel,
             int input = pre_fill_size;
 
             while (cqueue_size(s->gain_history_minimum[channel]) < pre_fill_size) {
-                initial_value = FFMIN(initial_value, cqueue_peek(s->gain_history_original[channel], ++input));
+                input++;
+                initial_value = FFMIN(initial_value, cqueue_peek(s->gain_history_original[channel], input));
                 cqueue_enqueue(s->gain_history_minimum[channel], initial_value);
             }
         }
@@ -545,7 +546,7 @@ static double compute_frame_std_dev(DynamicAudioNormalizerContext *s,
             const double *data_ptr = (double *)frame->extended_data[c];
 
             for (i = 0; i < frame->nb_samples; i++) {
-                variance += pow2(data_ptr[i]);  // Assume that MEAN is *zero*
+                variance += pow_2(data_ptr[i]);  // Assume that MEAN is *zero*
             }
         }
         variance /= (s->channels * frame->nb_samples) - 1;
@@ -553,7 +554,7 @@ static double compute_frame_std_dev(DynamicAudioNormalizerContext *s,
         const double *data_ptr = (double *)frame->extended_data[channel];
 
         for (i = 0; i < frame->nb_samples; i++) {
-            variance += pow2(data_ptr[i]);      // Assume that MEAN is *zero*
+            variance += pow_2(data_ptr[i]);      // Assume that MEAN is *zero*
         }
         variance /= frame->nb_samples - 1;
     }
@@ -708,8 +709,15 @@ static int request_frame(AVFilterLink *outlink)
 
     ret = ff_request_frame(ctx->inputs[0]);
 
-    if (ret == AVERROR_EOF && !ctx->is_disabled && s->delay)
-        ret = flush_buffer(s, ctx->inputs[0], outlink);
+    if (ret == AVERROR_EOF && !ctx->is_disabled && s->delay) {
+        if (!cqueue_empty(s->gain_history_smoothed[0])) {
+            ret = flush_buffer(s, ctx->inputs[0], outlink);
+        } else if (s->queue.available) {
+            AVFrame *out = ff_bufqueue_get(&s->queue);
+
+            ret = ff_filter_frame(outlink, out);
+        }
+    }
 
     return ret;
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/af_earwax.c b/mythtv/external/FFmpeg/libavfilter/af_earwax.c
index b0ba4cff654..7b880c86c6e 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_earwax.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_earwax.c
@@ -71,7 +71,7 @@ static const int8_t filt[NUMTAPS] = {
     0,   -5,
     4,    0};
 
-typedef struct {
+typedef struct EarwaxContext {
     int16_t taps[NUMTAPS * 2];
 } EarwaxContext;
 
diff --git a/mythtv/external/FFmpeg/libavfilter/af_firequalizer.c b/mythtv/external/FFmpeg/libavfilter/af_firequalizer.c
index 4988717cd8b..00ddc873412 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_firequalizer.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_firequalizer.c
@@ -52,30 +52,35 @@ enum Scale {
 };
 
 #define NB_GAIN_ENTRY_MAX 4096
-typedef struct {
+typedef struct GainEntry {
     double  freq;
     double  gain;
 } GainEntry;
 
-typedef struct {
+typedef struct OverlapIndex {
     int buf_idx;
     int overlap_idx;
 } OverlapIndex;
 
-typedef struct {
+typedef struct FIREqualizerContext {
     const AVClass *class;
 
     RDFTContext   *analysis_rdft;
     RDFTContext   *analysis_irdft;
     RDFTContext   *rdft;
     RDFTContext   *irdft;
+    FFTContext    *fft_ctx;
+    RDFTContext   *cepstrum_rdft;
+    RDFTContext   *cepstrum_irdft;
     int           analysis_rdft_len;
     int           rdft_len;
+    int           cepstrum_len;
 
     float         *analysis_buf;
     float         *dump_buf;
     float         *kernel_tmp_buf;
     float         *kernel_buf;
+    float         *cepstrum_buf;
     float         *conv_buf;
     OverlapIndex  *conv_idx;
     int           fir_len;
@@ -97,6 +102,8 @@ typedef struct {
     int           scale;
     char          *dumpfile;
     int           dumpscale;
+    int           fft2;
+    int           min_phase;
 
     int           nb_gain_entry;
     int           gain_entry_err;
@@ -132,6 +139,8 @@ static const AVOption firequalizer_options[] = {
         { "loglog", "logarithmic-freq logarithmic-gain", 0, AV_OPT_TYPE_CONST, { .i64 = SCALE_LOGLOG }, 0, 0, FLAGS, "scale" },
     { "dumpfile", "set dump file", OFFSET(dumpfile), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, FLAGS },
     { "dumpscale", "set dump scale", OFFSET(dumpscale), AV_OPT_TYPE_INT, { .i64 = SCALE_LINLOG }, 0, NB_SCALE-1, FLAGS, "scale" },
+    { "fft2", "set 2-channels fft", OFFSET(fft2), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
+    { "min_phase", "set minimum phase mode", OFFSET(min_phase), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
     { NULL }
 };
 
@@ -143,12 +152,19 @@ static void common_uninit(FIREqualizerContext *s)
     av_rdft_end(s->analysis_irdft);
     av_rdft_end(s->rdft);
     av_rdft_end(s->irdft);
+    av_fft_end(s->fft_ctx);
+    av_rdft_end(s->cepstrum_rdft);
+    av_rdft_end(s->cepstrum_irdft);
     s->analysis_rdft = s->analysis_irdft = s->rdft = s->irdft = NULL;
+    s->fft_ctx = NULL;
+    s->cepstrum_rdft = NULL;
+    s->cepstrum_irdft = NULL;
 
     av_freep(&s->analysis_buf);
     av_freep(&s->dump_buf);
     av_freep(&s->kernel_tmp_buf);
     av_freep(&s->kernel_buf);
+    av_freep(&s->cepstrum_buf);
     av_freep(&s->conv_buf);
     av_freep(&s->conv_idx);
 }
@@ -192,8 +208,8 @@ static int query_formats(AVFilterContext *ctx)
     return ff_set_common_samplerates(ctx, formats);
 }
 
-static void fast_convolute(FIREqualizerContext *s, const float *kernel_buf, float *conv_buf,
-                           OverlapIndex *idx, float *data, int nsamples)
+static void fast_convolute(FIREqualizerContext *av_restrict s, const float *av_restrict kernel_buf, float *av_restrict conv_buf,
+                           OverlapIndex *av_restrict idx, float *av_restrict data, int nsamples)
 {
     if (nsamples <= s->nsamples_max) {
         float *buf = conv_buf + idx->buf_idx * s->rdft_len;
@@ -230,6 +246,110 @@ static void fast_convolute(FIREqualizerContext *s, const float *kernel_buf, floa
     }
 }
 
+static void fast_convolute_nonlinear(FIREqualizerContext *av_restrict s, const float *av_restrict kernel_buf,
+                                     float *av_restrict conv_buf, OverlapIndex *av_restrict idx,
+                                     float *av_restrict data, int nsamples)
+{
+    if (nsamples <= s->nsamples_max) {
+        float *buf = conv_buf + idx->buf_idx * s->rdft_len;
+        float *obuf = conv_buf + !idx->buf_idx * s->rdft_len + idx->overlap_idx;
+        int k;
+
+        memcpy(buf, data, nsamples * sizeof(*data));
+        memset(buf + nsamples, 0, (s->rdft_len - nsamples) * sizeof(*data));
+        av_rdft_calc(s->rdft, buf);
+
+        buf[0] *= kernel_buf[0];
+        buf[1] *= kernel_buf[1];
+        for (k = 2; k < s->rdft_len; k += 2) {
+            float re, im;
+            re = buf[k] * kernel_buf[k] - buf[k+1] * kernel_buf[k+1];
+            im = buf[k] * kernel_buf[k+1] + buf[k+1] * kernel_buf[k];
+            buf[k] = re;
+            buf[k+1] = im;
+        }
+
+        av_rdft_calc(s->irdft, buf);
+        for (k = 0; k < s->rdft_len - idx->overlap_idx; k++)
+            buf[k] += obuf[k];
+        memcpy(data, buf, nsamples * sizeof(*data));
+        idx->buf_idx = !idx->buf_idx;
+        idx->overlap_idx = nsamples;
+    } else {
+        while (nsamples > s->nsamples_max * 2) {
+            fast_convolute_nonlinear(s, kernel_buf, conv_buf, idx, data, s->nsamples_max);
+            data += s->nsamples_max;
+            nsamples -= s->nsamples_max;
+        }
+        fast_convolute_nonlinear(s, kernel_buf, conv_buf, idx, data, nsamples/2);
+        fast_convolute_nonlinear(s, kernel_buf, conv_buf, idx, data + nsamples/2, nsamples - nsamples/2);
+    }
+}
+
+static void fast_convolute2(FIREqualizerContext *av_restrict s, const float *av_restrict kernel_buf, FFTComplex *av_restrict conv_buf,
+                            OverlapIndex *av_restrict idx, float *av_restrict data0, float *av_restrict data1, int nsamples)
+{
+    if (nsamples <= s->nsamples_max) {
+        FFTComplex *buf = conv_buf + idx->buf_idx * s->rdft_len;
+        FFTComplex *obuf = conv_buf + !idx->buf_idx * s->rdft_len + idx->overlap_idx;
+        int center = s->fir_len/2;
+        int k;
+        float tmp;
+
+        memset(buf, 0, center * sizeof(*buf));
+        for (k = 0; k < nsamples; k++) {
+            buf[center+k].re = data0[k];
+            buf[center+k].im = data1[k];
+        }
+        memset(buf + center + nsamples, 0, (s->rdft_len - nsamples - center) * sizeof(*buf));
+        av_fft_permute(s->fft_ctx, buf);
+        av_fft_calc(s->fft_ctx, buf);
+
+        /* swap re <-> im, do backward fft using forward fft_ctx */
+        /* normalize with 0.5f */
+        tmp = buf[0].re;
+        buf[0].re = 0.5f * kernel_buf[0] * buf[0].im;
+        buf[0].im = 0.5f * kernel_buf[0] * tmp;
+        for (k = 1; k < s->rdft_len/2; k++) {
+            int m = s->rdft_len - k;
+            tmp = buf[k].re;
+            buf[k].re = 0.5f * kernel_buf[k] * buf[k].im;
+            buf[k].im = 0.5f * kernel_buf[k] * tmp;
+            tmp = buf[m].re;
+            buf[m].re = 0.5f * kernel_buf[k] * buf[m].im;
+            buf[m].im = 0.5f * kernel_buf[k] * tmp;
+        }
+        tmp = buf[k].re;
+        buf[k].re = 0.5f * kernel_buf[k] * buf[k].im;
+        buf[k].im = 0.5f * kernel_buf[k] * tmp;
+
+        av_fft_permute(s->fft_ctx, buf);
+        av_fft_calc(s->fft_ctx, buf);
+
+        for (k = 0; k < s->rdft_len - idx->overlap_idx; k++) {
+            buf[k].re += obuf[k].re;
+            buf[k].im += obuf[k].im;
+        }
+
+        /* swapped re <-> im */
+        for (k = 0; k < nsamples; k++) {
+            data0[k] = buf[k].im;
+            data1[k] = buf[k].re;
+        }
+        idx->buf_idx = !idx->buf_idx;
+        idx->overlap_idx = nsamples;
+    } else {
+        while (nsamples > s->nsamples_max * 2) {
+            fast_convolute2(s, kernel_buf, conv_buf, idx, data0, data1, s->nsamples_max);
+            data0 += s->nsamples_max;
+            data1 += s->nsamples_max;
+            nsamples -= s->nsamples_max;
+        }
+        fast_convolute2(s, kernel_buf, conv_buf, idx, data0, data1, nsamples/2);
+        fast_convolute2(s, kernel_buf, conv_buf, idx, data0 + nsamples/2, data1 + nsamples/2, nsamples - nsamples/2);
+    }
+}
+
 static void dump_fir(AVFilterContext *ctx, FILE *fp, int ch)
 {
     FIREqualizerContext *s = ctx->priv;
@@ -241,10 +361,15 @@ static void dump_fir(AVFilterContext *ctx, FILE *fp, int ch)
     double delay = s->zero_phase ? 0.0 : (double) center / rate;
     double vx, ya, yb;
 
-    s->analysis_buf[0] *= s->rdft_len/2;
-    for (x = 1; x <= center; x++) {
-        s->analysis_buf[x] *= s->rdft_len/2;
-        s->analysis_buf[s->analysis_rdft_len - x] *= s->rdft_len/2;
+    if (!s->min_phase) {
+        s->analysis_buf[0] *= s->rdft_len/2;
+        for (x = 1; x <= center; x++) {
+            s->analysis_buf[x] *= s->rdft_len/2;
+            s->analysis_buf[s->analysis_rdft_len - x] *= s->rdft_len/2;
+        }
+    } else {
+        for (x = 0; x < s->fir_len; x++)
+            s->analysis_buf[x] *= s->rdft_len/2;
     }
 
     if (ch)
@@ -252,11 +377,16 @@ static void dump_fir(AVFilterContext *ctx, FILE *fp, int ch)
 
     fprintf(fp, "# time[%d] (time amplitude)\n", ch);
 
+    if (!s->min_phase) {
     for (x = center; x > 0; x--)
         fprintf(fp, "%15.10f %15.10f\n", delay - (double) x / rate, (double) s->analysis_buf[s->analysis_rdft_len - x]);
 
     for (x = 0; x <= center; x++)
         fprintf(fp, "%15.10f %15.10f\n", delay + (double)x / rate , (double) s->analysis_buf[x]);
+    } else {
+        for (x = 0; x < s->fir_len; x++)
+            fprintf(fp, "%15.10f %15.10f\n", (double)x / rate, (double) s->analysis_buf[x]);
+    }
 
     av_rdft_calc(s->analysis_rdft, s->analysis_buf);
 
@@ -268,7 +398,9 @@ static void dump_fir(AVFilterContext *ctx, FILE *fp, int ch)
         if (xlog)
             vx = log2(0.05*vx);
         ya = s->dump_buf[i];
-        yb = s->analysis_buf[i];
+        yb = s->min_phase && (i > 1) ? hypotf(s->analysis_buf[i], s->analysis_buf[i+1]) : s->analysis_buf[i];
+        if (s->min_phase)
+            yb = fabs(yb);
         if (ylog) {
             ya = 20.0 * log10(fabs(ya));
             yb = 20.0 * log10(fabs(yb));
@@ -418,6 +550,54 @@ enum VarOffset {
     VAR_NB
 };
 
+static void generate_min_phase_kernel(FIREqualizerContext *s, float *rdft_buf)
+{
+    int k, cepstrum_len = s->cepstrum_len, rdft_len = s->rdft_len;
+    double norm = 2.0 / cepstrum_len;
+    double minval = 1e-7 / rdft_len;
+
+    memset(s->cepstrum_buf, 0, cepstrum_len * sizeof(*s->cepstrum_buf));
+    memcpy(s->cepstrum_buf, rdft_buf, rdft_len/2 * sizeof(*rdft_buf));
+    memcpy(s->cepstrum_buf + cepstrum_len - rdft_len/2, rdft_buf + rdft_len/2, rdft_len/2  * sizeof(*rdft_buf));
+
+    av_rdft_calc(s->cepstrum_rdft, s->cepstrum_buf);
+
+    s->cepstrum_buf[0] = log(FFMAX(s->cepstrum_buf[0], minval));
+    s->cepstrum_buf[1] = log(FFMAX(s->cepstrum_buf[1], minval));
+
+    for (k = 2; k < cepstrum_len; k += 2) {
+        s->cepstrum_buf[k] = log(FFMAX(s->cepstrum_buf[k], minval));
+        s->cepstrum_buf[k+1] = 0;
+    }
+
+    av_rdft_calc(s->cepstrum_irdft, s->cepstrum_buf);
+
+    memset(s->cepstrum_buf + cepstrum_len/2 + 1, 0, (cepstrum_len/2 - 1) * sizeof(*s->cepstrum_buf));
+    for (k = 1; k < cepstrum_len/2; k++)
+        s->cepstrum_buf[k] *= 2;
+
+    av_rdft_calc(s->cepstrum_rdft, s->cepstrum_buf);
+
+    s->cepstrum_buf[0] = exp(s->cepstrum_buf[0] * norm) * norm;
+    s->cepstrum_buf[1] = exp(s->cepstrum_buf[1] * norm) * norm;
+    for (k = 2; k < cepstrum_len; k += 2) {
+        double mag = exp(s->cepstrum_buf[k] * norm) * norm;
+        double ph = s->cepstrum_buf[k+1] * norm;
+        s->cepstrum_buf[k] = mag * cos(ph);
+        s->cepstrum_buf[k+1] = mag * sin(ph);
+    }
+
+    av_rdft_calc(s->cepstrum_irdft, s->cepstrum_buf);
+    memset(rdft_buf, 0, s->rdft_len * sizeof(*rdft_buf));
+    memcpy(rdft_buf, s->cepstrum_buf, s->fir_len * sizeof(*rdft_buf));
+
+    if (s->dumpfile) {
+        memset(s->analysis_buf, 0, s->analysis_rdft_len * sizeof(*s->analysis_buf));
+        memcpy(s->analysis_buf, s->cepstrum_buf, s->fir_len * sizeof(*s->analysis_buf));
+    }
+
+}
+
 static int generate_kernel(AVFilterContext *ctx, const char *gain, const char *gain_entry)
 {
     FIREqualizerContext *s = ctx->priv;
@@ -480,7 +660,7 @@ static int generate_kernel(AVFilterContext *ctx, const char *gain, const char *g
             if (xlog)
                 vars[VAR_F] = log2(0.05 * vars[VAR_F]);
             result = av_expr_eval(gain_expr, vars, ctx);
-            s->analysis_buf[2*k] = ylog ? pow(10.0, 0.05 * result) : result;
+            s->analysis_buf[2*k] = ylog ? pow(10.0, 0.05 * result) : s->min_phase ? fabs(result) : result;
             s->analysis_buf[2*k+1] = 0.0;
         }
 
@@ -535,6 +715,8 @@ static int generate_kernel(AVFilterContext *ctx, const char *gain, const char *g
         memset(s->analysis_buf + center + 1, 0, (s->analysis_rdft_len - s->fir_len) * sizeof(*s->analysis_buf));
         memcpy(rdft_buf, s->analysis_buf, s->rdft_len/2 * sizeof(*s->analysis_buf));
         memcpy(rdft_buf + s->rdft_len/2, s->analysis_buf + s->analysis_rdft_len - s->rdft_len/2, s->rdft_len/2 * sizeof(*s->analysis_buf));
+        if (s->min_phase)
+            generate_min_phase_kernel(s, rdft_buf);
         av_rdft_calc(s->rdft, rdft_buf);
 
         for (k = 0; k < s->rdft_len; k++) {
@@ -547,10 +729,12 @@ static int generate_kernel(AVFilterContext *ctx, const char *gain, const char *g
             }
         }
 
-        rdft_buf[s->rdft_len-1] = rdft_buf[1];
-        for (k = 0; k < s->rdft_len/2; k++)
-            rdft_buf[k] = rdft_buf[2*k];
-        rdft_buf[s->rdft_len/2] = rdft_buf[s->rdft_len-1];
+        if (!s->min_phase) {
+            rdft_buf[s->rdft_len-1] = rdft_buf[1];
+            for (k = 0; k < s->rdft_len/2; k++)
+                rdft_buf[k] = rdft_buf[2*k];
+            rdft_buf[s->rdft_len/2] = rdft_buf[s->rdft_len-1];
+        }
 
         if (dump_fp)
             dump_fir(ctx, dump_fp, ch);
@@ -598,6 +782,28 @@ static int config_input(AVFilterLink *inlink)
     if (!(s->rdft = av_rdft_init(rdft_bits, DFT_R2C)) || !(s->irdft = av_rdft_init(rdft_bits, IDFT_C2R)))
         return AVERROR(ENOMEM);
 
+    if (s->fft2 && !s->multi && inlink->channels > 1 && !(s->fft_ctx = av_fft_init(rdft_bits, 0)))
+        return AVERROR(ENOMEM);
+
+    if (s->min_phase) {
+        int cepstrum_bits = rdft_bits + 2;
+        if (cepstrum_bits > RDFT_BITS_MAX) {
+            av_log(ctx, AV_LOG_ERROR, "too large delay, please decrease it.\n");
+            return AVERROR(EINVAL);
+        }
+
+        cepstrum_bits = FFMIN(RDFT_BITS_MAX, cepstrum_bits + 1);
+        s->cepstrum_rdft = av_rdft_init(cepstrum_bits, DFT_R2C);
+        s->cepstrum_irdft = av_rdft_init(cepstrum_bits, IDFT_C2R);
+        if (!s->cepstrum_rdft || !s->cepstrum_irdft)
+            return AVERROR(ENOMEM);
+
+        s->cepstrum_len = 1 << cepstrum_bits;
+        s->cepstrum_buf = av_malloc_array(s->cepstrum_len, sizeof(*s->cepstrum_buf));
+        if (!s->cepstrum_buf)
+            return AVERROR(ENOMEM);
+    }
+
     for ( ; rdft_bits <= RDFT_BITS_MAX; rdft_bits++) {
         s->analysis_rdft_len = 1 << rdft_bits;
         if (inlink->sample_rate <= s->accuracy * s->analysis_rdft_len)
@@ -640,16 +846,30 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     FIREqualizerContext *s = ctx->priv;
     int ch;
 
-    for (ch = 0; ch < inlink->channels; ch++) {
-        fast_convolute(s, s->kernel_buf + (s->multi ? ch * s->rdft_len : 0),
-                       s->conv_buf + 2 * ch * s->rdft_len, s->conv_idx + ch,
-                       (float *) frame->extended_data[ch], frame->nb_samples);
+    if (!s->min_phase) {
+        for (ch = 0; ch + 1 < inlink->channels && s->fft_ctx; ch += 2) {
+            fast_convolute2(s, s->kernel_buf, (FFTComplex *)(s->conv_buf + 2 * ch * s->rdft_len),
+                            s->conv_idx + ch, (float *) frame->extended_data[ch],
+                            (float *) frame->extended_data[ch+1], frame->nb_samples);
+        }
+
+        for ( ; ch < inlink->channels; ch++) {
+            fast_convolute(s, s->kernel_buf + (s->multi ? ch * s->rdft_len : 0),
+                        s->conv_buf + 2 * ch * s->rdft_len, s->conv_idx + ch,
+                        (float *) frame->extended_data[ch], frame->nb_samples);
+        }
+    } else {
+        for (ch = 0; ch < inlink->channels; ch++) {
+            fast_convolute_nonlinear(s, s->kernel_buf + (s->multi ? ch * s->rdft_len : 0),
+                                     s->conv_buf + 2 * ch * s->rdft_len, s->conv_idx + ch,
+                                     (float *) frame->extended_data[ch], frame->nb_samples);
+        }
     }
 
     s->next_pts = AV_NOPTS_VALUE;
     if (frame->pts != AV_NOPTS_VALUE) {
         s->next_pts = frame->pts + av_rescale_q(frame->nb_samples, av_make_q(1, inlink->sample_rate), inlink->time_base);
-        if (s->zero_phase)
+        if (s->zero_phase && !s->min_phase)
             frame->pts -= av_rescale_q(s->fir_len/2, av_make_q(1, inlink->sample_rate), inlink->time_base);
     }
     s->frame_nsamples_max = FFMAX(s->frame_nsamples_max, frame->nb_samples);
diff --git a/mythtv/external/FFmpeg/libavfilter/af_haas.c b/mythtv/external/FFmpeg/libavfilter/af_haas.c
new file mode 100644
index 00000000000..691c251f54e
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/af_haas.c
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2001-2010 Vladimir Sadovnikov
+ *
+ * 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/channel_layout.h"
+#include "libavutil/opt.h"
+#include "avfilter.h"
+#include "audio.h"
+#include "formats.h"
+
+#define MAX_HAAS_DELAY 40
+
+typedef struct HaasContext {
+    const AVClass *class;
+
+    int par_m_source;
+    double par_delay0;
+    double par_delay1;
+    int par_phase0;
+    int par_phase1;
+    int par_middle_phase;
+    double par_side_gain;
+    double par_gain0;
+    double par_gain1;
+    double par_balance0;
+    double par_balance1;
+    double level_in;
+    double level_out;
+
+    double *buffer;
+    size_t buffer_size;
+    uint32_t write_ptr;
+    uint32_t delay[2];
+    double balance_l[2];
+    double balance_r[2];
+    double phase0;
+    double phase1;
+} HaasContext;
+
+#define OFFSET(x) offsetof(HaasContext, x)
+#define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+
+static const AVOption haas_options[] = {
+    { "level_in",      "set level in",      OFFSET(level_in),         AV_OPT_TYPE_DOUBLE,  {.dbl=1}, 0.015625,  64, A },
+    { "level_out",     "set level out",     OFFSET(level_out),        AV_OPT_TYPE_DOUBLE,  {.dbl=1}, 0.015625,  64, A },
+    { "side_gain",     "set side gain",     OFFSET(par_side_gain),    AV_OPT_TYPE_DOUBLE,  {.dbl=1}, 0.015625,  64, A },
+    { "middle_source", "set middle source", OFFSET(par_m_source),     AV_OPT_TYPE_INT,     {.i64=2},        0,   3, A, "source" },
+    {   "left",        0,                   0,                        AV_OPT_TYPE_CONST,   {.i64=0},        0,   0, A, "source" },
+    {   "right",       0,                   0,                        AV_OPT_TYPE_CONST,   {.i64=1},        0,   0, A, "source" },
+    {   "mid",         "L+R",               0,                        AV_OPT_TYPE_CONST,   {.i64=2},        0,   0, A, "source" },
+    {   "side",        "L-R",               0,                        AV_OPT_TYPE_CONST,   {.i64=3},        0,   0, A, "source" },
+    { "middle_phase",  "set middle phase",  OFFSET(par_middle_phase), AV_OPT_TYPE_BOOL,    {.i64=0},        0,   1, A },
+    { "left_delay",    "set left delay",    OFFSET(par_delay0),       AV_OPT_TYPE_DOUBLE,  {.dbl=2.05},     0,  MAX_HAAS_DELAY, A },
+    { "left_balance",  "set left balance",  OFFSET(par_balance0),     AV_OPT_TYPE_DOUBLE,  {.dbl=-1.0},    -1,   1, A },
+    { "left_gain",     "set left gain",     OFFSET(par_gain0),        AV_OPT_TYPE_DOUBLE,  {.dbl=1}, 0.015625,  64, A },
+    { "left_phase",    "set left phase",    OFFSET(par_phase0),       AV_OPT_TYPE_BOOL,    {.i64=0},        0,   1, A },
+    { "right_delay",   "set right delay",   OFFSET(par_delay1),       AV_OPT_TYPE_DOUBLE,  {.dbl=2.12},     0,  MAX_HAAS_DELAY, A },
+    { "right_balance", "set right balance", OFFSET(par_balance1),     AV_OPT_TYPE_DOUBLE,  {.dbl=1},       -1,   1, A },
+    { "right_gain",    "set right gain",    OFFSET(par_gain1),        AV_OPT_TYPE_DOUBLE,  {.dbl=1}, 0.015625,  64, A },
+    { "right_phase",   "set right phase",   OFFSET(par_phase1),       AV_OPT_TYPE_BOOL,    {.i64=1},        0,   1, A },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(haas);
+
+static int query_formats(AVFilterContext *ctx)
+{
+    AVFilterFormats *formats = NULL;
+    AVFilterChannelLayouts *layout = NULL;
+    int ret;
+
+    if ((ret = ff_add_format                 (&formats, AV_SAMPLE_FMT_DBL  )) < 0 ||
+        (ret = ff_set_common_formats         (ctx     , formats            )) < 0 ||
+        (ret = ff_add_channel_layout         (&layout , AV_CH_LAYOUT_STEREO)) < 0 ||
+        (ret = ff_set_common_channel_layouts (ctx     , layout             )) < 0)
+        return ret;
+
+    formats = ff_all_samplerates();
+    return ff_set_common_samplerates(ctx, formats);
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    HaasContext *s = ctx->priv;
+    size_t min_buf_size = (size_t)(inlink->sample_rate * MAX_HAAS_DELAY * 0.001);
+    size_t new_buf_size = 1;
+
+    while (new_buf_size < min_buf_size)
+        new_buf_size <<= 1;
+
+    av_freep(&s->buffer);
+    s->buffer = av_calloc(new_buf_size, sizeof(*s->buffer));
+    if (!s->buffer)
+        return AVERROR(ENOMEM);
+
+    s->buffer_size = new_buf_size;
+    s->write_ptr = 0;
+
+    s->delay[0] = (uint32_t)(s->par_delay0 * 0.001 * inlink->sample_rate);
+    s->delay[1] = (uint32_t)(s->par_delay1 * 0.001 * inlink->sample_rate);
+
+    s->phase0 = s->par_phase0 ? 1.0 : -1.0;
+    s->phase1 = s->par_phase1 ? 1.0 : -1.0;
+
+    s->balance_l[0] = (s->par_balance0 + 1) / 2 * s->par_gain0 * s->phase0;
+    s->balance_r[0] = (1.0 - (s->par_balance0 + 1) / 2) * (s->par_gain0) * s->phase0;
+    s->balance_l[1] = (s->par_balance1 + 1) / 2 * s->par_gain1 * s->phase1;
+    s->balance_r[1] = (1.0 - (s->par_balance1 + 1) / 2) * (s->par_gain1) * s->phase1;
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx = inlink->dst;
+    AVFilterLink *outlink = ctx->outputs[0];
+    HaasContext *s = ctx->priv;
+    const double *src = (const double *)in->data[0];
+    const double level_in = s->level_in;
+    const double level_out = s->level_out;
+    const uint32_t mask = s->buffer_size - 1;
+    double *buffer = s->buffer;
+    AVFrame *out;
+    double *dst;
+    int n;
+
+    if (av_frame_is_writable(in)) {
+        out = in;
+    } else {
+        out = ff_get_audio_buffer(inlink, in->nb_samples);
+        if (!out) {
+            av_frame_free(&in);
+            return AVERROR(ENOMEM);
+        }
+        av_frame_copy_props(out, in);
+    }
+    dst = (double *)out->data[0];
+
+    for (n = 0; n < in->nb_samples; n++, src += 2, dst += 2) {
+        double mid, side[2], side_l, side_r;
+        uint32_t s0_ptr, s1_ptr;
+
+        switch (s->par_m_source) {
+        case 0: mid = src[0]; break;
+        case 1: mid = src[1]; break;
+        case 2: mid = (src[0] + src[1]) * 0.5; break;
+        case 3: mid = (src[0] - src[1]) * 0.5; break;
+        }
+
+        mid *= level_in;
+
+        buffer[s->write_ptr] = mid;
+
+        s0_ptr = (s->write_ptr + s->buffer_size - s->delay[0]) & mask;
+        s1_ptr = (s->write_ptr + s->buffer_size - s->delay[1]) & mask;
+
+        if (s->par_middle_phase)
+            mid = -mid;
+
+        side[0] = buffer[s0_ptr] * s->par_side_gain;
+        side[1] = buffer[s1_ptr] * s->par_side_gain;
+        side_l  = side[0] * s->balance_l[0] - side[1] * s->balance_l[1];
+        side_r  = side[1] * s->balance_r[1] - side[0] * s->balance_r[0];
+
+        dst[0] = (mid + side_l) * level_out;
+        dst[1] = (mid + side_r) * level_out;
+
+        s->write_ptr = (s->write_ptr + 1) & mask;
+    }
+
+    if (out != in)
+        av_frame_free(&in);
+    return ff_filter_frame(outlink, out);
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    HaasContext *s = ctx->priv;
+
+    av_freep(&s->buffer);
+    s->buffer_size = 0;
+}
+
+static const AVFilterPad inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_AUDIO,
+        .filter_frame = filter_frame,
+        .config_props = config_input,
+    },
+    { NULL }
+};
+
+static const AVFilterPad outputs[] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_AUDIO,
+    },
+    { NULL }
+};
+
+AVFilter ff_af_haas = {
+    .name           = "haas",
+    .description    = NULL_IF_CONFIG_SMALL("Apply Haas Stereo Enhancer."),
+    .query_formats  = query_formats,
+    .priv_size      = sizeof(HaasContext),
+    .priv_class     = &haas_class,
+    .uninit         = uninit,
+    .inputs         = inputs,
+    .outputs        = outputs,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/af_hdcd.c b/mythtv/external/FFmpeg/libavfilter/af_hdcd.c
index caee470c2ed..fd17646f09c 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_hdcd.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_hdcd.c
@@ -837,7 +837,7 @@ static const int32_t gaintab[] = {
 /** tone generator: sample_number, frequency, sample_rate, amplitude */
 #define TONEGEN16(sn, f, sr, a) (int16_t)(sin((6.28318530718 * (sn) * (f)) /(sr)) * (a) * 0x7fff)
 
-typedef struct {
+typedef struct hdcd_state {
     uint64_t window;
     unsigned char readahead;
 
@@ -904,7 +904,7 @@ static const char * const pf_str[] = {
     "?", "A", "B", "A+B"
 };
 
-typedef struct {
+typedef struct hdcd_detection_data {
     hdcd_dv hdcd_detected;
     hdcd_pf packet_type;
     int total_packets;         /**< valid packets */
@@ -1077,7 +1077,8 @@ static int hdcd_integrate(HDCDContext *ctx, hdcd_state *states, int channels, in
                         /* one of bits 3, 6, or 7 was not 0 */
                         states[i].code_counterA_almost++;
                         av_log(ctx->fctx, AV_LOG_VERBOSE,
-                            "hdcd error: Control A almost: 0x%02x near %d\n", wbits & 0xff, ctx->sample_count);
+                               "hdcd error: Control A almost: 0x%02"PRIx32" near %d\n",
+                               wbits & 0xff, ctx->sample_count);
                     }
                 } else if ((wbits & 0xa0060000) == 0xa0060000) {
                     /* B: 8-bit code, 8-bit XOR check, 0x7e0fa006[....] */
@@ -1091,7 +1092,9 @@ static int hdcd_integrate(HDCDContext *ctx, hdcd_state *states, int channels, in
                         /* XOR check failed */
                         states[i].code_counterB_checkfails++;
                         av_log(ctx->fctx, AV_LOG_VERBOSE,
-                            "hdcd error: Control B check failed: 0x%04x (0x%02x vs 0x%02x) near %d\n", wbits & 0xffff, (wbits & 0xff00) >> 8, ~wbits & 0xff, ctx->sample_count);
+                               "hdcd error: Control B check failed: 0x%04"PRIx32
+                               " (0x%02"PRIx32" vs 0x%02"PRIx32") near %d\n",
+                               wbits & 0xffff, (wbits & 0xff00) >> 8, ~wbits & 0xff, ctx->sample_count);
                     }
                 }
                 if (f) {
@@ -1635,13 +1638,11 @@ static int query_formats(AVFilterContext *ctx)
         return ret;
 
     in_formats = ff_make_format_list(sample_fmts_in);
-    out_formats = ff_make_format_list(sample_fmts_out);
-    if (!in_formats || !out_formats)
-        return AVERROR(ENOMEM);
-
     ret = ff_formats_ref(in_formats, &inlink->out_formats);
     if (ret < 0)
         return ret;
+
+    out_formats = ff_make_format_list(sample_fmts_out);
     ret = ff_formats_ref(out_formats, &outlink->in_formats);
     if (ret < 0)
         return ret;
diff --git a/mythtv/external/FFmpeg/libavfilter/af_headphone.c b/mythtv/external/FFmpeg/libavfilter/af_headphone.c
new file mode 100644
index 00000000000..3b76d1d7370
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/af_headphone.c
@@ -0,0 +1,820 @@
+/*
+ * Copyright (C) 2017 Paul B Mahol
+ * Copyright (C) 2013-2015 Andreas Fuchs, Wolfgang Hrauda
+ * 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 <math.h>
+
+#include "libavutil/audio_fifo.h"
+#include "libavutil/avstring.h"
+#include "libavutil/channel_layout.h"
+#include "libavutil/float_dsp.h"
+#include "libavutil/intmath.h"
+#include "libavutil/opt.h"
+#include "libavcodec/avfft.h"
+
+#include "avfilter.h"
+#include "internal.h"
+#include "audio.h"
+
+#define TIME_DOMAIN      0
+#define FREQUENCY_DOMAIN 1
+
+typedef struct HeadphoneContext {
+    const AVClass *class;
+
+    char *map;
+    int type;
+
+    int lfe_channel;
+
+    int have_hrirs;
+    int eof_hrirs;
+    int64_t pts;
+
+    int ir_len;
+
+    int mapping[64];
+
+    int nb_inputs;
+
+    int nb_irs;
+
+    float gain;
+    float lfe_gain, gain_lfe;
+
+    float *ringbuffer[2];
+    int write[2];
+
+    int buffer_length;
+    int n_fft;
+    int size;
+
+    int *delay[2];
+    float *data_ir[2];
+    float *temp_src[2];
+    FFTComplex *temp_fft[2];
+
+    FFTContext *fft[2], *ifft[2];
+    FFTComplex *data_hrtf[2];
+
+    AVFloatDSPContext *fdsp;
+    struct headphone_inputs {
+        AVAudioFifo *fifo;
+        AVFrame     *frame;
+        int          ir_len;
+        int          delay_l;
+        int          delay_r;
+        int          eof;
+    } *in;
+} HeadphoneContext;
+
+static int parse_channel_name(HeadphoneContext *s, int x, char **arg, int *rchannel, char *buf)
+{
+    int len, i, channel_id = 0;
+    int64_t layout, layout0;
+
+    if (sscanf(*arg, "%7[A-Z]%n", buf, &len)) {
+        layout0 = layout = av_get_channel_layout(buf);
+        if (layout == AV_CH_LOW_FREQUENCY)
+            s->lfe_channel = x;
+        for (i = 32; i > 0; i >>= 1) {
+            if (layout >= 1LL << i) {
+                channel_id += i;
+                layout >>= i;
+            }
+        }
+        if (channel_id >= 64 || layout0 != 1LL << channel_id)
+            return AVERROR(EINVAL);
+        *rchannel = channel_id;
+        *arg += len;
+        return 0;
+    }
+    return AVERROR(EINVAL);
+}
+
+static void parse_map(AVFilterContext *ctx)
+{
+    HeadphoneContext *s = ctx->priv;
+    char *arg, *tokenizer, *p, *args = av_strdup(s->map);
+    int i;
+
+    if (!args)
+        return;
+    p = args;
+
+    s->lfe_channel = -1;
+    s->nb_inputs = 1;
+
+    for (i = 0; i < 64; i++) {
+        s->mapping[i] = -1;
+    }
+
+    while ((arg = av_strtok(p, "|", &tokenizer))) {
+        int out_ch_id;
+        char buf[8];
+
+        p = NULL;
+        if (parse_channel_name(s, s->nb_inputs - 1, &arg, &out_ch_id, buf)) {
+            av_log(ctx, AV_LOG_WARNING, "Failed to parse \'%s\' as channel name.\n", buf);
+            continue;
+        }
+        s->mapping[s->nb_inputs - 1] = out_ch_id;
+        s->nb_inputs++;
+    }
+    s->nb_irs = s->nb_inputs - 1;
+
+    av_free(args);
+}
+
+typedef struct ThreadData {
+    AVFrame *in, *out;
+    int *write;
+    int **delay;
+    float **ir;
+    int *n_clippings;
+    float **ringbuffer;
+    float **temp_src;
+    FFTComplex **temp_fft;
+} ThreadData;
+
+static int headphone_convolute(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+    HeadphoneContext *s = ctx->priv;
+    ThreadData *td = arg;
+    AVFrame *in = td->in, *out = td->out;
+    int offset = jobnr;
+    int *write = &td->write[jobnr];
+    const int *const delay = td->delay[jobnr];
+    const float *const ir = td->ir[jobnr];
+    int *n_clippings = &td->n_clippings[jobnr];
+    float *ringbuffer = td->ringbuffer[jobnr];
+    float *temp_src = td->temp_src[jobnr];
+    const int ir_len = s->ir_len;
+    const float *src = (const float *)in->data[0];
+    float *dst = (float *)out->data[0];
+    const int in_channels = in->channels;
+    const int buffer_length = s->buffer_length;
+    const uint32_t modulo = (uint32_t)buffer_length - 1;
+    float *buffer[16];
+    int wr = *write;
+    int read;
+    int i, l;
+
+    dst += offset;
+    for (l = 0; l < in_channels; l++) {
+        buffer[l] = ringbuffer + l * buffer_length;
+    }
+
+    for (i = 0; i < in->nb_samples; i++) {
+        const float *temp_ir = ir;
+
+        *dst = 0;
+        for (l = 0; l < in_channels; l++) {
+            *(buffer[l] + wr) = src[l];
+        }
+
+        for (l = 0; l < in_channels; l++) {
+            const float *const bptr = buffer[l];
+
+            if (l == s->lfe_channel) {
+                *dst += *(buffer[s->lfe_channel] + wr) * s->gain_lfe;
+                temp_ir += FFALIGN(ir_len, 16);
+                continue;
+            }
+
+            read = (wr - *(delay + l) - (ir_len - 1) + buffer_length) & modulo;
+
+            if (read + ir_len < buffer_length) {
+                memcpy(temp_src, bptr + read, ir_len * sizeof(*temp_src));
+            } else {
+                int len = FFMIN(ir_len - (read % ir_len), buffer_length - read);
+
+                memcpy(temp_src, bptr + read, len * sizeof(*temp_src));
+                memcpy(temp_src + len, bptr, (ir_len - len) * sizeof(*temp_src));
+            }
+
+            dst[0] += s->fdsp->scalarproduct_float(temp_ir, temp_src, ir_len);
+            temp_ir += FFALIGN(ir_len, 16);
+        }
+
+        if (fabs(*dst) > 1)
+            *n_clippings += 1;
+
+        dst += 2;
+        src += in_channels;
+        wr   = (wr + 1) & modulo;
+    }
+
+    *write = wr;
+
+    return 0;
+}
+
+static int headphone_fast_convolute(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+    HeadphoneContext *s = ctx->priv;
+    ThreadData *td = arg;
+    AVFrame *in = td->in, *out = td->out;
+    int offset = jobnr;
+    int *write = &td->write[jobnr];
+    FFTComplex *hrtf = s->data_hrtf[jobnr];
+    int *n_clippings = &td->n_clippings[jobnr];
+    float *ringbuffer = td->ringbuffer[jobnr];
+    const int ir_len = s->ir_len;
+    const float *src = (const float *)in->data[0];
+    float *dst = (float *)out->data[0];
+    const int in_channels = in->channels;
+    const int buffer_length = s->buffer_length;
+    const uint32_t modulo = (uint32_t)buffer_length - 1;
+    FFTComplex *fft_in = s->temp_fft[jobnr];
+    FFTContext *ifft = s->ifft[jobnr];
+    FFTContext *fft = s->fft[jobnr];
+    const int n_fft = s->n_fft;
+    const float fft_scale = 1.0f / s->n_fft;
+    FFTComplex *hrtf_offset;
+    int wr = *write;
+    int n_read;
+    int i, j;
+
+    dst += offset;
+
+    n_read = FFMIN(s->ir_len, in->nb_samples);
+    for (j = 0; j < n_read; j++) {
+        dst[2 * j]     = ringbuffer[wr];
+        ringbuffer[wr] = 0.0;
+        wr  = (wr + 1) & modulo;
+    }
+
+    for (j = n_read; j < in->nb_samples; j++) {
+        dst[2 * j] = 0;
+    }
+
+    for (i = 0; i < in_channels; i++) {
+        if (i == s->lfe_channel) {
+            for (j = 0; j < in->nb_samples; j++) {
+                dst[2 * j] += src[i + j * in_channels] * s->gain_lfe;
+            }
+            continue;
+        }
+
+        offset = i * n_fft;
+        hrtf_offset = hrtf + offset;
+
+        memset(fft_in, 0, sizeof(FFTComplex) * n_fft);
+
+        for (j = 0; j < in->nb_samples; j++) {
+            fft_in[j].re = src[j * in_channels + i];
+        }
+
+        av_fft_permute(fft, fft_in);
+        av_fft_calc(fft, fft_in);
+        for (j = 0; j < n_fft; j++) {
+            const FFTComplex *hcomplex = hrtf_offset + j;
+            const float re = fft_in[j].re;
+            const float im = fft_in[j].im;
+
+            fft_in[j].re = re * hcomplex->re - im * hcomplex->im;
+            fft_in[j].im = re * hcomplex->im + im * hcomplex->re;
+        }
+
+        av_fft_permute(ifft, fft_in);
+        av_fft_calc(ifft, fft_in);
+
+        for (j = 0; j < in->nb_samples; j++) {
+            dst[2 * j] += fft_in[j].re * fft_scale;
+        }
+
+        for (j = 0; j < ir_len - 1; j++) {
+            int write_pos = (wr + j) & modulo;
+
+            *(ringbuffer + write_pos) += fft_in[in->nb_samples + j].re * fft_scale;
+        }
+    }
+
+    for (i = 0; i < out->nb_samples; i++) {
+        if (fabs(*dst) > 1) {
+            n_clippings[0]++;
+        }
+
+        dst += 2;
+    }
+
+    *write = wr;
+
+    return 0;
+}
+
+static int read_ir(AVFilterLink *inlink, AVFrame *frame)
+{
+    AVFilterContext *ctx = inlink->dst;
+    HeadphoneContext *s = ctx->priv;
+    int ir_len, max_ir_len, input_number;
+
+    for (input_number = 0; input_number < s->nb_inputs; input_number++)
+        if (inlink == ctx->inputs[input_number])
+            break;
+
+    av_audio_fifo_write(s->in[input_number].fifo, (void **)frame->extended_data,
+                        frame->nb_samples);
+    av_frame_free(&frame);
+
+    ir_len = av_audio_fifo_size(s->in[input_number].fifo);
+    max_ir_len = 65536;
+    if (ir_len > max_ir_len) {
+        av_log(ctx, AV_LOG_ERROR, "Too big length of IRs: %d > %d.\n", ir_len, max_ir_len);
+        return AVERROR(EINVAL);
+    }
+    s->in[input_number].ir_len = ir_len;
+    s->ir_len = FFMAX(ir_len, s->ir_len);
+
+    return 0;
+}
+
+static int headphone_frame(HeadphoneContext *s, AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    AVFrame *in = s->in[0].frame;
+    int n_clippings[2] = { 0 };
+    ThreadData td;
+    AVFrame *out;
+
+    av_audio_fifo_read(s->in[0].fifo, (void **)in->extended_data, s->size);
+
+    out = ff_get_audio_buffer(outlink, in->nb_samples);
+    if (!out)
+        return AVERROR(ENOMEM);
+    out->pts = s->pts;
+    if (s->pts != AV_NOPTS_VALUE)
+        s->pts += av_rescale_q(out->nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
+
+    td.in = in; td.out = out; td.write = s->write;
+    td.delay = s->delay; td.ir = s->data_ir; td.n_clippings = n_clippings;
+    td.ringbuffer = s->ringbuffer; td.temp_src = s->temp_src;
+    td.temp_fft = s->temp_fft;
+
+    if (s->type == TIME_DOMAIN) {
+        ctx->internal->execute(ctx, headphone_convolute, &td, NULL, 2);
+    } else {
+        ctx->internal->execute(ctx, headphone_fast_convolute, &td, NULL, 2);
+    }
+    emms_c();
+
+    if (n_clippings[0] + n_clippings[1] > 0) {
+        av_log(ctx, AV_LOG_WARNING, "%d of %d samples clipped. Please reduce gain.\n",
+               n_clippings[0] + n_clippings[1], out->nb_samples * 2);
+    }
+
+    return ff_filter_frame(outlink, out);
+}
+
+static int convert_coeffs(AVFilterContext *ctx, AVFilterLink *inlink)
+{
+    struct HeadphoneContext *s = ctx->priv;
+    const int ir_len = s->ir_len;
+    int nb_irs = s->nb_irs;
+    int nb_input_channels = ctx->inputs[0]->channels;
+    float gain_lin = expf((s->gain - 3 * nb_input_channels) / 20 * M_LN10);
+    FFTComplex *data_hrtf_l = NULL;
+    FFTComplex *data_hrtf_r = NULL;
+    FFTComplex *fft_in_l = NULL;
+    FFTComplex *fft_in_r = NULL;
+    float *data_ir_l = NULL;
+    float *data_ir_r = NULL;
+    int offset = 0, ret = 0;
+    int n_fft;
+    int i, j;
+
+    s->buffer_length = 1 << (32 - ff_clz(s->ir_len));
+    s->n_fft = n_fft = 1 << (32 - ff_clz(s->ir_len + inlink->sample_rate));
+
+    if (s->type == FREQUENCY_DOMAIN) {
+        fft_in_l = av_calloc(n_fft, sizeof(*fft_in_l));
+        fft_in_r = av_calloc(n_fft, sizeof(*fft_in_r));
+        if (!fft_in_l || !fft_in_r) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+
+        av_fft_end(s->fft[0]);
+        av_fft_end(s->fft[1]);
+        s->fft[0] = av_fft_init(log2(s->n_fft), 0);
+        s->fft[1] = av_fft_init(log2(s->n_fft), 0);
+        av_fft_end(s->ifft[0]);
+        av_fft_end(s->ifft[1]);
+        s->ifft[0] = av_fft_init(log2(s->n_fft), 1);
+        s->ifft[1] = av_fft_init(log2(s->n_fft), 1);
+
+        if (!s->fft[0] || !s->fft[1] || !s->ifft[0] || !s->ifft[1]) {
+            av_log(ctx, AV_LOG_ERROR, "Unable to create FFT contexts of size %d.\n", s->n_fft);
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+    }
+
+    s->data_ir[0] = av_calloc(FFALIGN(s->ir_len, 16), sizeof(float) * s->nb_irs);
+    s->data_ir[1] = av_calloc(FFALIGN(s->ir_len, 16), sizeof(float) * s->nb_irs);
+    s->delay[0] = av_malloc_array(s->nb_irs, sizeof(float));
+    s->delay[1] = av_malloc_array(s->nb_irs, sizeof(float));
+
+    if (s->type == TIME_DOMAIN) {
+        s->ringbuffer[0] = av_calloc(s->buffer_length, sizeof(float) * nb_input_channels);
+        s->ringbuffer[1] = av_calloc(s->buffer_length, sizeof(float) * nb_input_channels);
+    } else {
+        s->ringbuffer[0] = av_calloc(s->buffer_length, sizeof(float));
+        s->ringbuffer[1] = av_calloc(s->buffer_length, sizeof(float));
+        s->temp_fft[0] = av_malloc_array(s->n_fft, sizeof(FFTComplex));
+        s->temp_fft[1] = av_malloc_array(s->n_fft, sizeof(FFTComplex));
+        if (!s->temp_fft[0] || !s->temp_fft[1]) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+    }
+
+    if (!s->data_ir[0] || !s->data_ir[1] ||
+        !s->ringbuffer[0] || !s->ringbuffer[1]) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    s->in[0].frame = ff_get_audio_buffer(ctx->inputs[0], s->size);
+    if (!s->in[0].frame) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+    for (i = 0; i < s->nb_irs; i++) {
+        s->in[i + 1].frame = ff_get_audio_buffer(ctx->inputs[i + 1], s->ir_len);
+        if (!s->in[i + 1].frame) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+    }
+
+    if (s->type == TIME_DOMAIN) {
+        s->temp_src[0] = av_calloc(FFALIGN(ir_len, 16), sizeof(float));
+        s->temp_src[1] = av_calloc(FFALIGN(ir_len, 16), sizeof(float));
+
+        data_ir_l = av_calloc(nb_irs * FFALIGN(ir_len, 16), sizeof(*data_ir_l));
+        data_ir_r = av_calloc(nb_irs * FFALIGN(ir_len, 16), sizeof(*data_ir_r));
+        if (!data_ir_r || !data_ir_l || !s->temp_src[0] || !s->temp_src[1]) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+    } else {
+        data_hrtf_l = av_malloc_array(n_fft, sizeof(*data_hrtf_l) * nb_irs);
+        data_hrtf_r = av_malloc_array(n_fft, sizeof(*data_hrtf_r) * nb_irs);
+        if (!data_hrtf_r || !data_hrtf_l) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+    }
+
+    for (i = 0; i < s->nb_irs; i++) {
+        int len = s->in[i + 1].ir_len;
+        int delay_l = s->in[i + 1].delay_l;
+        int delay_r = s->in[i + 1].delay_r;
+        int idx = -1;
+        float *ptr;
+
+        for (j = 0; j < inlink->channels; j++) {
+            if (s->mapping[i] < 0) {
+                continue;
+            }
+
+            if ((av_channel_layout_extract_channel(inlink->channel_layout, j)) == (1LL << s->mapping[i])) {
+                idx = j;
+                break;
+            }
+        }
+        if (idx == -1)
+            continue;
+
+        av_audio_fifo_read(s->in[i + 1].fifo, (void **)s->in[i + 1].frame->extended_data, len);
+        ptr = (float *)s->in[i + 1].frame->extended_data[0];
+
+        if (s->type == TIME_DOMAIN) {
+            offset = idx * FFALIGN(len, 16);
+            for (j = 0; j < len; j++) {
+                data_ir_l[offset + j] = ptr[len * 2 - j * 2 - 2] * gain_lin;
+                data_ir_r[offset + j] = ptr[len * 2 - j * 2 - 1] * gain_lin;
+            }
+        } else {
+            memset(fft_in_l, 0, n_fft * sizeof(*fft_in_l));
+            memset(fft_in_r, 0, n_fft * sizeof(*fft_in_r));
+
+            offset = idx * n_fft;
+            for (j = 0; j < len; j++) {
+                fft_in_l[delay_l + j].re = ptr[j * 2    ] * gain_lin;
+                fft_in_r[delay_r + j].re = ptr[j * 2 + 1] * gain_lin;
+            }
+
+            av_fft_permute(s->fft[0], fft_in_l);
+            av_fft_calc(s->fft[0], fft_in_l);
+            memcpy(data_hrtf_l + offset, fft_in_l, n_fft * sizeof(*fft_in_l));
+            av_fft_permute(s->fft[0], fft_in_r);
+            av_fft_calc(s->fft[0], fft_in_r);
+            memcpy(data_hrtf_r + offset, fft_in_r, n_fft * sizeof(*fft_in_r));
+        }
+    }
+
+    if (s->type == TIME_DOMAIN) {
+        memcpy(s->data_ir[0], data_ir_l, sizeof(float) * nb_irs * FFALIGN(ir_len, 16));
+        memcpy(s->data_ir[1], data_ir_r, sizeof(float) * nb_irs * FFALIGN(ir_len, 16));
+    } else {
+        s->data_hrtf[0] = av_malloc_array(n_fft * s->nb_irs, sizeof(FFTComplex));
+        s->data_hrtf[1] = av_malloc_array(n_fft * s->nb_irs, sizeof(FFTComplex));
+        if (!s->data_hrtf[0] || !s->data_hrtf[1]) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+
+        memcpy(s->data_hrtf[0], data_hrtf_l,
+            sizeof(FFTComplex) * nb_irs * n_fft);
+        memcpy(s->data_hrtf[1], data_hrtf_r,
+            sizeof(FFTComplex) * nb_irs * n_fft);
+    }
+
+    s->have_hrirs = 1;
+
+fail:
+
+    av_freep(&data_ir_l);
+    av_freep(&data_ir_r);
+
+    av_freep(&data_hrtf_l);
+    av_freep(&data_hrtf_r);
+
+    av_freep(&fft_in_l);
+    av_freep(&fft_in_r);
+
+    return ret;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx = inlink->dst;
+    HeadphoneContext *s = ctx->priv;
+    AVFilterLink *outlink = ctx->outputs[0];
+    int ret = 0;
+
+    av_audio_fifo_write(s->in[0].fifo, (void **)in->extended_data,
+                        in->nb_samples);
+    if (s->pts == AV_NOPTS_VALUE)
+        s->pts = in->pts;
+
+    av_frame_free(&in);
+
+    if (!s->have_hrirs && s->eof_hrirs) {
+        ret = convert_coeffs(ctx, inlink);
+        if (ret < 0)
+            return ret;
+    }
+
+    if (s->have_hrirs) {
+        while (av_audio_fifo_size(s->in[0].fifo) >= s->size) {
+            ret = headphone_frame(s, outlink);
+            if (ret < 0)
+                break;
+        }
+    }
+    return ret;
+}
+
+static int query_formats(AVFilterContext *ctx)
+{
+    struct HeadphoneContext *s = ctx->priv;
+    AVFilterFormats *formats = NULL;
+    AVFilterChannelLayouts *layouts = NULL;
+    int ret, i;
+
+    ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLT);
+    if (ret)
+        return ret;
+    ret = ff_set_common_formats(ctx, formats);
+    if (ret)
+        return ret;
+
+    layouts = ff_all_channel_layouts();
+    if (!layouts)
+        return AVERROR(ENOMEM);
+
+    ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts);
+    if (ret)
+        return ret;
+
+    layouts = NULL;
+    ret = ff_add_channel_layout(&layouts, AV_CH_LAYOUT_STEREO);
+    if (ret)
+        return ret;
+
+    for (i = 1; i < s->nb_inputs; i++) {
+        ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
+        if (ret)
+            return ret;
+    }
+
+    ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);
+    if (ret)
+        return ret;
+
+    formats = ff_all_samplerates();
+    if (!formats)
+        return AVERROR(ENOMEM);
+    return ff_set_common_samplerates(ctx, formats);
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    HeadphoneContext *s = ctx->priv;
+
+    if (s->type == FREQUENCY_DOMAIN) {
+        inlink->partial_buf_size =
+        inlink->min_samples =
+        inlink->max_samples = inlink->sample_rate;
+    }
+
+    if (s->nb_irs < inlink->channels) {
+        av_log(ctx, AV_LOG_ERROR, "Number of inputs must be >= %d.\n", inlink->channels + 1);
+        return AVERROR(EINVAL);
+    }
+
+    return 0;
+}
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    HeadphoneContext *s = ctx->priv;
+    int i, ret;
+
+    AVFilterPad pad = {
+        .name         = "in0",
+        .type         = AVMEDIA_TYPE_AUDIO,
+        .config_props = config_input,
+        .filter_frame = filter_frame,
+    };
+    if ((ret = ff_insert_inpad(ctx, 0, &pad)) < 0)
+        return ret;
+
+    if (!s->map) {
+        av_log(ctx, AV_LOG_ERROR, "Valid mapping must be set.\n");
+        return AVERROR(EINVAL);
+    }
+
+    parse_map(ctx);
+
+    s->in = av_calloc(s->nb_inputs, sizeof(*s->in));
+    if (!s->in)
+        return AVERROR(ENOMEM);
+
+    for (i = 1; i < s->nb_inputs; i++) {
+        char *name = av_asprintf("hrir%d", i - 1);
+        AVFilterPad pad = {
+            .name         = name,
+            .type         = AVMEDIA_TYPE_AUDIO,
+            .filter_frame = read_ir,
+        };
+        if (!name)
+            return AVERROR(ENOMEM);
+        if ((ret = ff_insert_inpad(ctx, i, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
+    }
+
+    s->fdsp = avpriv_float_dsp_alloc(0);
+    if (!s->fdsp)
+        return AVERROR(ENOMEM);
+    s->pts = AV_NOPTS_VALUE;
+
+    return 0;
+}
+
+static int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    HeadphoneContext *s = ctx->priv;
+    AVFilterLink *inlink = ctx->inputs[0];
+    int i;
+
+    if (s->type == TIME_DOMAIN)
+        s->size = 1024;
+    else
+        s->size = inlink->sample_rate;
+
+    for (i = 0; i < s->nb_inputs; i++) {
+        s->in[i].fifo = av_audio_fifo_alloc(ctx->inputs[i]->format, ctx->inputs[i]->channels, 1024);
+        if (!s->in[i].fifo)
+            return AVERROR(ENOMEM);
+    }
+    s->gain_lfe = expf((s->gain - 3 * inlink->channels - 6 + s->lfe_gain) / 20 * M_LN10);
+
+    return 0;
+}
+
+static int request_frame(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    HeadphoneContext *s = ctx->priv;
+    int i, ret;
+
+    for (i = 1; !s->eof_hrirs && i < s->nb_inputs; i++) {
+        if (!s->in[i].eof) {
+            ret = ff_request_frame(ctx->inputs[i]);
+            if (ret == AVERROR_EOF) {
+                s->in[i].eof = 1;
+                ret = 0;
+            }
+            return ret;
+        } else {
+            if (i == s->nb_inputs - 1)
+                s->eof_hrirs = 1;
+        }
+    }
+    return ff_request_frame(ctx->inputs[0]);
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    HeadphoneContext *s = ctx->priv;
+    int i;
+
+    av_fft_end(s->ifft[0]);
+    av_fft_end(s->ifft[1]);
+    av_fft_end(s->fft[0]);
+    av_fft_end(s->fft[1]);
+    av_freep(&s->delay[0]);
+    av_freep(&s->delay[1]);
+    av_freep(&s->data_ir[0]);
+    av_freep(&s->data_ir[1]);
+    av_freep(&s->ringbuffer[0]);
+    av_freep(&s->ringbuffer[1]);
+    av_freep(&s->temp_src[0]);
+    av_freep(&s->temp_src[1]);
+    av_freep(&s->temp_fft[0]);
+    av_freep(&s->temp_fft[1]);
+    av_freep(&s->data_hrtf[0]);
+    av_freep(&s->data_hrtf[1]);
+    av_freep(&s->fdsp);
+
+    for (i = 0; i < s->nb_inputs; i++) {
+        av_frame_free(&s->in[i].frame);
+        av_audio_fifo_free(s->in[i].fifo);
+        if (ctx->input_pads && i)
+            av_freep(&ctx->input_pads[i].name);
+    }
+    av_freep(&s->in);
+}
+
+#define OFFSET(x) offsetof(HeadphoneContext, x)
+#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+
+static const AVOption headphone_options[] = {
+    { "map",       "set channels convolution mappings",  OFFSET(map),      AV_OPT_TYPE_STRING, {.str=NULL},            .flags = FLAGS },
+    { "gain",      "set gain in dB",                     OFFSET(gain),     AV_OPT_TYPE_FLOAT,  {.dbl=0},     -20,  40, .flags = FLAGS },
+    { "lfe",       "set lfe gain in dB",                 OFFSET(lfe_gain), AV_OPT_TYPE_FLOAT,  {.dbl=0},     -20,  40, .flags = FLAGS },
+    { "type",      "set processing",                     OFFSET(type),     AV_OPT_TYPE_INT,    {.i64=1},       0,   1, .flags = FLAGS, "type" },
+    { "time",      "time domain",                        0,                AV_OPT_TYPE_CONST,  {.i64=0},       0,   0, .flags = FLAGS, "type" },
+    { "freq",      "frequency domain",                   0,                AV_OPT_TYPE_CONST,  {.i64=1},       0,   0, .flags = FLAGS, "type" },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(headphone);
+
+static const AVFilterPad outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_AUDIO,
+        .config_props  = config_output,
+        .request_frame = request_frame,
+    },
+    { NULL }
+};
+
+AVFilter ff_af_headphone = {
+    .name          = "headphone",
+    .description   = NULL_IF_CONFIG_SMALL("Apply headphone binaural spatialization with HRTFs in additional streams."),
+    .priv_size     = sizeof(HeadphoneContext),
+    .priv_class    = &headphone_class,
+    .init          = init,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .inputs        = NULL,
+    .outputs       = outputs,
+    .flags         = AVFILTER_FLAG_SLICE_THREADS | AVFILTER_FLAG_DYNAMIC_INPUTS,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/af_join.c b/mythtv/external/FFmpeg/libavfilter/af_join.c
index bd780cc379d..f8af0a18040 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_join.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_join.c
@@ -232,7 +232,10 @@ static av_cold int join_init(AVFilterContext *ctx)
 
         pad.needs_fifo = 1;
 
-        ff_insert_inpad(ctx, i, &pad);
+        if ((ret = ff_insert_inpad(ctx, i, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
     }
 
     return 0;
@@ -491,7 +494,7 @@ static int try_push_frame(AVFilterContext *ctx)
 
     frame->nb_samples     = nb_samples;
     frame->channel_layout = outlink->channel_layout;
-    av_frame_set_channels(frame, outlink->channels);
+    frame->channels       = outlink->channels;
     frame->sample_rate    = outlink->sample_rate;
     frame->format         = outlink->format;
     frame->pts            = s->input_frames[0]->pts;
diff --git a/mythtv/external/FFmpeg/libavfilter/af_loudnorm.c b/mythtv/external/FFmpeg/libavfilter/af_loudnorm.c
index 604697e6f79..e3e815e2723 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_loudnorm.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_loudnorm.c
@@ -24,7 +24,7 @@
 #include "avfilter.h"
 #include "internal.h"
 #include "audio.h"
-#include <ebur128.h>
+#include "ebur128.h"
 
 enum FrameType {
     FIRST_FRAME,
@@ -91,8 +91,8 @@ typedef struct LoudNormContext {
     int prev_nb_samples;
     int channels;
 
-    ebur128_state *r128_in;
-    ebur128_state *r128_out;
+    FFEBUR128State *r128_in;
+    FFEBUR128State *r128_out;
 } LoudNormContext;
 
 #define OFFSET(x) offsetof(LoudNormContext, x)
@@ -437,15 +437,15 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     buf = s->buf;
     limiter_buf = s->limiter_buf;
 
-    ebur128_add_frames_double(s->r128_in, src, in->nb_samples);
+    ff_ebur128_add_frames_double(s->r128_in, src, in->nb_samples);
 
     if (s->frame_type == FIRST_FRAME && in->nb_samples < frame_size(inlink->sample_rate, 3000)) {
         double offset, offset_tp, true_peak;
 
-        ebur128_loudness_global(s->r128_in, &global);
+        ff_ebur128_loudness_global(s->r128_in, &global);
         for (c = 0; c < inlink->channels; c++) {
             double tmp;
-            ebur128_sample_peak(s->r128_in, c, &tmp);
+            ff_ebur128_sample_peak(s->r128_in, c, &tmp);
             if (c == 0 || tmp > true_peak)
                 true_peak = tmp;
         }
@@ -467,7 +467,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
             s->buf_index += inlink->channels;
         }
 
-        ebur128_loudness_shortterm(s->r128_in, &shortterm);
+        ff_ebur128_loudness_shortterm(s->r128_in, &shortterm);
 
         if (shortterm < s->measured_thresh) {
             s->above_threshold = 0;
@@ -497,7 +497,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 
         subframe_length = frame_size(inlink->sample_rate, 100);
         true_peak_limiter(s, dst, subframe_length, inlink->channels);
-        ebur128_add_frames_double(s->r128_out, dst, subframe_length);
+        ff_ebur128_add_frames_double(s->r128_out, dst, subframe_length);
 
         s->pts +=
         out->nb_samples =
@@ -536,12 +536,12 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         s->limiter_buf_index = s->limiter_buf_index + subframe_length < s->limiter_buf_size ? s->limiter_buf_index + subframe_length : s->limiter_buf_index + subframe_length - s->limiter_buf_size;
 
         true_peak_limiter(s, dst, in->nb_samples, inlink->channels);
-        ebur128_add_frames_double(s->r128_out, dst, in->nb_samples);
+        ff_ebur128_add_frames_double(s->r128_out, dst, in->nb_samples);
 
-        ebur128_loudness_range(s->r128_in, &lra);
-        ebur128_loudness_global(s->r128_in, &global);
-        ebur128_loudness_shortterm(s->r128_in, &shortterm);
-        ebur128_relative_threshold(s->r128_in, &relative_threshold);
+        ff_ebur128_loudness_range(s->r128_in, &lra);
+        ff_ebur128_loudness_global(s->r128_in, &global);
+        ff_ebur128_loudness_shortterm(s->r128_in, &shortterm);
+        ff_ebur128_relative_threshold(s->r128_in, &relative_threshold);
 
         if (s->above_threshold == 0) {
             double shortterm_out;
@@ -549,7 +549,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
             if (shortterm > s->measured_thresh)
                 s->prev_delta *= 1.0058;
 
-            ebur128_loudness_shortterm(s->r128_out, &shortterm_out);
+            ff_ebur128_loudness_shortterm(s->r128_out, &shortterm_out);
             if (shortterm_out >= s->target_i)
                 s->above_threshold = 1;
         }
@@ -611,7 +611,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         }
 
         dst = (double *)out->data[0];
-        ebur128_add_frames_double(s->r128_out, dst, in->nb_samples);
+        ff_ebur128_add_frames_double(s->r128_out, dst, in->nb_samples);
         break;
 
     case LINEAR_MODE:
@@ -624,7 +624,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         }
 
         dst = (double *)out->data[0];
-        ebur128_add_frames_double(s->r128_out, dst, in->nb_samples);
+        ff_ebur128_add_frames_double(s->r128_out, dst, in->nb_samples);
         s->pts += in->nb_samples;
         break;
     }
@@ -682,6 +682,7 @@ static int request_frame(AVFilterLink *outlink)
 
 static int query_formats(AVFilterContext *ctx)
 {
+    LoudNormContext *s = ctx->priv;
     AVFilterFormats *formats;
     AVFilterChannelLayouts *layouts;
     AVFilterLink *inlink = ctx->inputs[0];
@@ -707,15 +708,17 @@ static int query_formats(AVFilterContext *ctx)
     if (ret < 0)
         return ret;
 
-    formats = ff_make_format_list(input_srate);
-    if (!formats)
-        return AVERROR(ENOMEM);
-    ret = ff_formats_ref(formats, &inlink->out_samplerates);
-    if (ret < 0)
-        return ret;
-    ret = ff_formats_ref(formats, &outlink->in_samplerates);
-    if (ret < 0)
-        return ret;
+    if (s->frame_type != LINEAR_MODE) {
+        formats = ff_make_format_list(input_srate);
+        if (!formats)
+            return AVERROR(ENOMEM);
+        ret = ff_formats_ref(formats, &inlink->out_samplerates);
+        if (ret < 0)
+            return ret;
+        ret = ff_formats_ref(formats, &outlink->in_samplerates);
+        if (ret < 0)
+            return ret;
+    }
 
     return 0;
 }
@@ -725,17 +728,17 @@ static int config_input(AVFilterLink *inlink)
     AVFilterContext *ctx = inlink->dst;
     LoudNormContext *s = ctx->priv;
 
-    s->r128_in = ebur128_init(inlink->channels, inlink->sample_rate, EBUR128_MODE_I | EBUR128_MODE_S | EBUR128_MODE_LRA | EBUR128_MODE_SAMPLE_PEAK);
+    s->r128_in = ff_ebur128_init(inlink->channels, inlink->sample_rate, 0, FF_EBUR128_MODE_I | FF_EBUR128_MODE_S | FF_EBUR128_MODE_LRA | FF_EBUR128_MODE_SAMPLE_PEAK);
     if (!s->r128_in)
         return AVERROR(ENOMEM);
 
-    s->r128_out = ebur128_init(inlink->channels, inlink->sample_rate, EBUR128_MODE_I | EBUR128_MODE_S | EBUR128_MODE_LRA | EBUR128_MODE_SAMPLE_PEAK);
+    s->r128_out = ff_ebur128_init(inlink->channels, inlink->sample_rate, 0, FF_EBUR128_MODE_I | FF_EBUR128_MODE_S | FF_EBUR128_MODE_LRA | FF_EBUR128_MODE_SAMPLE_PEAK);
     if (!s->r128_out)
         return AVERROR(ENOMEM);
 
     if (inlink->channels == 1 && s->dual_mono) {
-        ebur128_set_channel(s->r128_in,  0, EBUR128_DUAL_MONO);
-        ebur128_set_channel(s->r128_out, 0, EBUR128_DUAL_MONO);
+        ff_ebur128_set_channel(s->r128_in,  0, FF_EBUR128_DUAL_MONO);
+        ff_ebur128_set_channel(s->r128_out, 0, FF_EBUR128_DUAL_MONO);
     }
 
     s->buf_size = frame_size(inlink->sample_rate, 3000) * inlink->channels;
@@ -754,21 +757,6 @@ static int config_input(AVFilterLink *inlink)
 
     init_gaussian_filter(s);
 
-    s->frame_type = FIRST_FRAME;
-
-    if (s->linear) {
-        double offset, offset_tp;
-        offset    = s->target_i - s->measured_i;
-        offset_tp = s->measured_tp + offset;
-
-        if (s->measured_tp != 99 && s->measured_thresh != -70 && s->measured_lra != 0 && s->measured_i != 0) {
-            if ((offset_tp <= s->target_tp) && (s->measured_lra <= s->target_lra)) {
-                s->frame_type = LINEAR_MODE;
-                s->offset = offset;
-            }
-        }
-    }
-
     if (s->frame_type != LINEAR_MODE) {
         inlink->min_samples =
         inlink->max_samples =
@@ -790,6 +778,27 @@ static int config_input(AVFilterLink *inlink)
     return 0;
 }
 
+static av_cold int init(AVFilterContext *ctx)
+{
+    LoudNormContext *s = ctx->priv;
+    s->frame_type = FIRST_FRAME;
+
+    if (s->linear) {
+        double offset, offset_tp;
+        offset    = s->target_i - s->measured_i;
+        offset_tp = s->measured_tp + offset;
+
+        if (s->measured_tp != 99 && s->measured_thresh != -70 && s->measured_lra != 0 && s->measured_i != 0) {
+            if ((offset_tp <= s->target_tp) && (s->measured_lra <= s->target_lra)) {
+                s->frame_type = LINEAR_MODE;
+                s->offset = offset;
+            }
+        }
+    }
+
+    return 0;
+}
+
 static av_cold void uninit(AVFilterContext *ctx)
 {
     LoudNormContext *s = ctx->priv;
@@ -799,22 +808,22 @@ static av_cold void uninit(AVFilterContext *ctx)
     if (!s->r128_in || !s->r128_out)
         goto end;
 
-    ebur128_loudness_range(s->r128_in, &lra_in);
-    ebur128_loudness_global(s->r128_in, &i_in);
-    ebur128_relative_threshold(s->r128_in, &thresh_in);
+    ff_ebur128_loudness_range(s->r128_in, &lra_in);
+    ff_ebur128_loudness_global(s->r128_in, &i_in);
+    ff_ebur128_relative_threshold(s->r128_in, &thresh_in);
     for (c = 0; c < s->channels; c++) {
         double tmp;
-        ebur128_sample_peak(s->r128_in, c, &tmp);
+        ff_ebur128_sample_peak(s->r128_in, c, &tmp);
         if ((c == 0) || (tmp > tp_in))
             tp_in = tmp;
     }
 
-    ebur128_loudness_range(s->r128_out, &lra_out);
-    ebur128_loudness_global(s->r128_out, &i_out);
-    ebur128_relative_threshold(s->r128_out, &thresh_out);
+    ff_ebur128_loudness_range(s->r128_out, &lra_out);
+    ff_ebur128_loudness_global(s->r128_out, &i_out);
+    ff_ebur128_relative_threshold(s->r128_out, &thresh_out);
     for (c = 0; c < s->channels; c++) {
         double tmp;
-        ebur128_sample_peak(s->r128_out, c, &tmp);
+        ff_ebur128_sample_peak(s->r128_out, c, &tmp);
         if ((c == 0) || (tmp > tp_out))
             tp_out = tmp;
     }
@@ -881,9 +890,9 @@ static av_cold void uninit(AVFilterContext *ctx)
 
 end:
     if (s->r128_in)
-        ebur128_destroy(&s->r128_in);
+        ff_ebur128_destroy(&s->r128_in);
     if (s->r128_out)
-        ebur128_destroy(&s->r128_out);
+        ff_ebur128_destroy(&s->r128_out);
     av_freep(&s->limiter_buf);
     av_freep(&s->prev_smp);
     av_freep(&s->buf);
@@ -914,6 +923,7 @@ AVFilter ff_af_loudnorm = {
     .priv_size     = sizeof(LoudNormContext),
     .priv_class    = &loudnorm_class,
     .query_formats = query_formats,
+    .init          = init,
     .uninit        = uninit,
     .inputs        = avfilter_af_loudnorm_inputs,
     .outputs       = avfilter_af_loudnorm_outputs,
diff --git a/mythtv/external/FFmpeg/libavfilter/af_pan.c b/mythtv/external/FFmpeg/libavfilter/af_pan.c
index fbd79a5a428..d8a63a79522 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_pan.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_pan.c
@@ -102,7 +102,7 @@ static av_cold int init(AVFilterContext *ctx)
 {
     PanContext *const pan = ctx->priv;
     char *arg, *arg0, *tokenizer, *args = av_strdup(pan->args);
-    int out_ch_id, in_ch_id, len, named, ret;
+    int out_ch_id, in_ch_id, len, named, ret, sign = 1;
     int nb_in_channels[2] = { 0, 0 }; // number of unnamed and named input channels
     double gain;
 
@@ -115,6 +115,11 @@ static av_cold int init(AVFilterContext *ctx)
     if (!args)
         return AVERROR(ENOMEM);
     arg = av_strtok(args, "|", &tokenizer);
+    if (!arg) {
+        av_log(ctx, AV_LOG_ERROR, "Channel layout not specified\n");
+        ret = AVERROR(EINVAL);
+        goto fail;
+    }
     ret = ff_parse_channel_layout(&pan->out_channel_layout,
                                   &pan->nb_output_channels, arg, ctx);
     if (ret < 0)
@@ -161,6 +166,7 @@ static av_cold int init(AVFilterContext *ctx)
             goto fail;
         }
         /* gains */
+        sign = 1;
         while (1) {
             gain = 1;
             if (sscanf(arg, "%lf%n *%n", &gain, &len, &len))
@@ -178,14 +184,18 @@ static av_cold int init(AVFilterContext *ctx)
                 ret = AVERROR(EINVAL);
                 goto fail;
             }
-            pan->gain[out_ch_id][in_ch_id] = gain;
+            pan->gain[out_ch_id][in_ch_id] = sign * gain;
             skip_spaces(&arg);
             if (!*arg)
                 break;
-            if (*arg != '+') {
+            if (*arg == '-') {
+                sign = -1;
+            } else if (*arg != '+') {
                 av_log(ctx, AV_LOG_ERROR, "Syntax error near \"%.8s\"\n", arg);
                 ret = AVERROR(EINVAL);
                 goto fail;
+            } else {
+                sign = 1;
             }
             arg++;
         }
@@ -374,13 +384,15 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
     AVFrame *outsamples = ff_get_audio_buffer(outlink, n);
     PanContext *pan = inlink->dst->priv;
 
-    if (!outsamples)
+    if (!outsamples) {
+        av_frame_free(&insamples);
         return AVERROR(ENOMEM);
+    }
     swr_convert(pan->swr, outsamples->extended_data, n,
                 (void *)insamples->extended_data, n);
     av_frame_copy_props(outsamples, insamples);
     outsamples->channel_layout = outlink->channel_layout;
-    av_frame_set_channels(outsamples, outlink->channels);
+    outsamples->channels = outlink->channels;
 
     ret = ff_filter_frame(outlink, outsamples);
     av_frame_free(&insamples);
diff --git a/mythtv/external/FFmpeg/libavfilter/af_sidechaincompress.c b/mythtv/external/FFmpeg/libavfilter/af_sidechaincompress.c
index 3f540e2dff2..55bed438446 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_sidechaincompress.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_sidechaincompress.c
@@ -32,6 +32,7 @@
 
 #include "audio.h"
 #include "avfilter.h"
+#include "filters.h"
 #include "formats.h"
 #include "hermite.h"
 #include "internal.h"
@@ -72,7 +73,7 @@ static const AVOption options[] = {
     { "ratio",     "set ratio",          OFFSET(ratio),     AV_OPT_TYPE_DOUBLE, {.dbl=2},               1,   20, A|F },
     { "attack",    "set attack",         OFFSET(attack),    AV_OPT_TYPE_DOUBLE, {.dbl=20},           0.01, 2000, A|F },
     { "release",   "set release",        OFFSET(release),   AV_OPT_TYPE_DOUBLE, {.dbl=250},          0.01, 9000, A|F },
-    { "makeup",    "set make up gain",   OFFSET(makeup),    AV_OPT_TYPE_DOUBLE, {.dbl=2},               1,   64, A|F },
+    { "makeup",    "set make up gain",   OFFSET(makeup),    AV_OPT_TYPE_DOUBLE, {.dbl=1},               1,   64, A|F },
     { "knee",      "set knee",           OFFSET(knee),      AV_OPT_TYPE_DOUBLE, {.dbl=2.82843},         1,    8, A|F },
     { "link",      "set link type",      OFFSET(link),      AV_OPT_TYPE_INT,    {.i64=0},               0,    1, A|F, "link" },
     {   "average", 0,                    0,                 AV_OPT_TYPE_CONST,  {.i64=0},               0,    0, A|F, "link" },
@@ -183,71 +184,71 @@ static void compressor(SidechainCompressContext *s,
 }
 
 #if CONFIG_SIDECHAINCOMPRESS_FILTER
-static int filter_frame(AVFilterLink *link, AVFrame *frame)
+static int activate(AVFilterContext *ctx)
 {
-    AVFilterContext *ctx = link->dst;
     SidechainCompressContext *s = ctx->priv;
-    AVFilterLink *outlink = ctx->outputs[0];
     AVFrame *out = NULL, *in[2] = { NULL };
+    int ret, i, nb_samples;
     double *dst;
-    int nb_samples;
-    int i;
 
-    for (i = 0; i < 2; i++)
-        if (link == ctx->inputs[i])
-            break;
-    av_assert0(i < 2);
-    av_audio_fifo_write(s->fifo[i], (void **)frame->extended_data,
-                        frame->nb_samples);
-    av_frame_free(&frame);
+    FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[0], ctx);
+    if ((ret = ff_inlink_consume_frame(ctx->inputs[0], &in[0])) > 0) {
+        av_audio_fifo_write(s->fifo[0], (void **)in[0]->extended_data,
+                            in[0]->nb_samples);
+        av_frame_free(&in[0]);
+    }
+    if (ret < 0)
+        return ret;
+    if ((ret = ff_inlink_consume_frame(ctx->inputs[1], &in[1])) > 0) {
+        av_audio_fifo_write(s->fifo[1], (void **)in[1]->extended_data,
+                            in[1]->nb_samples);
+        av_frame_free(&in[1]);
+    }
+    if (ret < 0)
+        return ret;
 
     nb_samples = FFMIN(av_audio_fifo_size(s->fifo[0]), av_audio_fifo_size(s->fifo[1]));
-    if (!nb_samples)
-        return 0;
-
-    out = ff_get_audio_buffer(outlink, nb_samples);
-    if (!out)
-        return AVERROR(ENOMEM);
-    for (i = 0; i < 2; i++) {
-        in[i] = ff_get_audio_buffer(ctx->inputs[i], nb_samples);
-        if (!in[i]) {
-            av_frame_free(&in[0]);
-            av_frame_free(&in[1]);
-            av_frame_free(&out);
+    if (nb_samples) {
+        out = ff_get_audio_buffer(ctx->outputs[0], nb_samples);
+        if (!out)
             return AVERROR(ENOMEM);
+        for (i = 0; i < 2; i++) {
+            in[i] = ff_get_audio_buffer(ctx->inputs[i], nb_samples);
+            if (!in[i]) {
+                av_frame_free(&in[0]);
+                av_frame_free(&in[1]);
+                av_frame_free(&out);
+                return AVERROR(ENOMEM);
+            }
+            av_audio_fifo_read(s->fifo[i], (void **)in[i]->data, nb_samples);
         }
-        av_audio_fifo_read(s->fifo[i], (void **)in[i]->data, nb_samples);
-    }
-
-    dst = (double *)out->data[0];
-    out->pts = s->pts;
-    s->pts += nb_samples;
-
-    compressor(s, (double *)in[0]->data[0], dst,
-               (double *)in[1]->data[0], nb_samples,
-               s->level_in, s->level_sc,
-               ctx->inputs[0], ctx->inputs[1]);
 
-    av_frame_free(&in[0]);
-    av_frame_free(&in[1]);
+        dst = (double *)out->data[0];
+        out->pts = s->pts;
+        s->pts += nb_samples;
 
-    return ff_filter_frame(outlink, out);
-}
+        compressor(s, (double *)in[0]->data[0], dst,
+                   (double *)in[1]->data[0], nb_samples,
+                   s->level_in, s->level_sc,
+                   ctx->inputs[0], ctx->inputs[1]);
 
-static int request_frame(AVFilterLink *outlink)
-{
-    AVFilterContext *ctx = outlink->src;
-    SidechainCompressContext *s = ctx->priv;
-    int i;
+        av_frame_free(&in[0]);
+        av_frame_free(&in[1]);
 
-    /* get a frame on each input */
-    for (i = 0; i < 2; i++) {
-        AVFilterLink *inlink = ctx->inputs[i];
-        if (!av_audio_fifo_size(s->fifo[i]))
-            return ff_request_frame(inlink);
+        ret = ff_filter_frame(ctx->outputs[0], out);
+        if (ret < 0)
+            return ret;
     }
-
-    return 0;
+    FF_FILTER_FORWARD_STATUS(ctx->inputs[0], ctx->outputs[0]);
+    FF_FILTER_FORWARD_STATUS(ctx->inputs[1], ctx->outputs[0]);
+    /* TODO reindent */
+        if (ff_outlink_frame_wanted(ctx->outputs[0])) {
+            if (!av_audio_fifo_size(s->fifo[0]))
+                ff_inlink_request_frame(ctx->inputs[0]);
+            if (!av_audio_fifo_size(s->fifo[1]))
+                ff_inlink_request_frame(ctx->inputs[1]);
+        }
+        return 0;
 }
 
 static int query_formats(AVFilterContext *ctx)
@@ -325,11 +326,9 @@ static const AVFilterPad sidechaincompress_inputs[] = {
     {
         .name           = "main",
         .type           = AVMEDIA_TYPE_AUDIO,
-        .filter_frame   = filter_frame,
     },{
         .name           = "sidechain",
         .type           = AVMEDIA_TYPE_AUDIO,
-        .filter_frame   = filter_frame,
     },
     { NULL }
 };
@@ -339,7 +338,6 @@ static const AVFilterPad sidechaincompress_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_AUDIO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -350,6 +348,7 @@ AVFilter ff_af_sidechaincompress = {
     .priv_size      = sizeof(SidechainCompressContext),
     .priv_class     = &sidechaincompress_class,
     .query_formats  = query_formats,
+    .activate       = activate,
     .uninit         = uninit,
     .inputs         = sidechaincompress_inputs,
     .outputs        = sidechaincompress_outputs,
diff --git a/mythtv/external/FFmpeg/libavfilter/af_silenceremove.c b/mythtv/external/FFmpeg/libavfilter/af_silenceremove.c
index f156d1883d5..af504630598 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_silenceremove.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_silenceremove.c
@@ -217,11 +217,18 @@ static int config_input(AVFilterLink *inlink)
     return 0;
 }
 
-static void flush(AVFrame *out, AVFilterLink *outlink,
+static void flush(SilenceRemoveContext *s,
+                  AVFrame *out, AVFilterLink *outlink,
                   int *nb_samples_written, int *ret)
 {
     if (*nb_samples_written) {
         out->nb_samples = *nb_samples_written / outlink->channels;
+
+        out->pts = s->next_pts;
+        s->next_pts += av_rescale_q(out->nb_samples,
+                                    (AVRational){1, outlink->sample_rate},
+                                    outlink->time_base);
+
         *ret = ff_filter_frame(outlink, out);
         *nb_samples_written = 0;
     } else {
@@ -297,6 +304,12 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 
         memcpy(out->data[0], &s->start_holdoff[s->start_holdoff_offset],
                nbs * sizeof(double));
+
+        out->pts = s->next_pts;
+        s->next_pts += av_rescale_q(out->nb_samples,
+                                    (AVRational){1, outlink->sample_rate},
+                                    outlink->time_base);
+
         s->start_holdoff_offset += nbs;
 
         ret = ff_filter_frame(outlink, out);
@@ -330,7 +343,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 
                 if (threshold && s->stop_holdoff_end && !s->leave_silence) {
                     s->mode = SILENCE_COPY_FLUSH;
-                    flush(out, outlink, &nb_samples_written, &ret);
+                    flush(s, out, outlink, &nb_samples_written, &ret);
                     goto silence_copy_flush;
                 } else if (threshold) {
                     for (j = 0; j < inlink->channels; j++) {
@@ -358,7 +371,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 
                             if (!s->restart) {
                                 s->mode = SILENCE_STOP;
-                                flush(out, outlink, &nb_samples_written, &ret);
+                                flush(s, out, outlink, &nb_samples_written, &ret);
                                 goto silence_stop;
                             } else {
                                 s->stop_found_periods = 0;
@@ -367,19 +380,25 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
                                 s->start_holdoff_end = 0;
                                 clear_window(s);
                                 s->mode = SILENCE_TRIM;
-                                flush(out, outlink, &nb_samples_written, &ret);
+                                flush(s, out, outlink, &nb_samples_written, &ret);
                                 goto silence_trim;
                             }
                         }
                         s->mode = SILENCE_COPY_FLUSH;
-                        flush(out, outlink, &nb_samples_written, &ret);
+                        flush(s, out, outlink, &nb_samples_written, &ret);
                         goto silence_copy_flush;
                     }
                 }
             }
-            flush(out, outlink, &nb_samples_written, &ret);
+            flush(s, out, outlink, &nb_samples_written, &ret);
         } else {
             memcpy(obuf, ibuf, sizeof(double) * nbs * inlink->channels);
+
+            out->pts = s->next_pts;
+            s->next_pts += av_rescale_q(out->nb_samples,
+                                        (AVRational){1, outlink->sample_rate},
+                                        outlink->time_base);
+
             ret = ff_filter_frame(outlink, out);
         }
         break;
@@ -401,6 +420,11 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
                nbs * sizeof(double));
         s->stop_holdoff_offset += nbs;
 
+        out->pts = s->next_pts;
+        s->next_pts += av_rescale_q(out->nb_samples,
+                                    (AVRational){1, outlink->sample_rate},
+                                    outlink->time_base);
+
         ret = ff_filter_frame(outlink, out);
 
         if (s->stop_holdoff_offset == s->stop_holdoff_end) {
@@ -439,6 +463,12 @@ static int request_frame(AVFilterLink *outlink)
 
             memcpy(frame->data[0], &s->stop_holdoff[s->stop_holdoff_offset],
                    nbs * sizeof(double));
+
+            frame->pts = s->next_pts;
+            s->next_pts += av_rescale_q(frame->nb_samples,
+                                        (AVRational){1, outlink->sample_rate},
+                                        outlink->time_base);
+
             ret = ff_filter_frame(ctx->inputs[0], frame);
         }
         s->mode = SILENCE_STOP;
diff --git a/mythtv/external/FFmpeg/libavfilter/af_sofalizer.c b/mythtv/external/FFmpeg/libavfilter/af_sofalizer.c
index 7558f57eb92..d9098d7679d 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_sofalizer.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_sofalizer.c
@@ -26,7 +26,7 @@
  *****************************************************************************/
 
 #include <math.h>
-#include <netcdf.h>
+#include <mysofa.h>
 
 #include "libavcodec/avfft.h"
 #include "libavutil/avstring.h"
@@ -41,18 +41,12 @@
 #define TIME_DOMAIN      0
 #define FREQUENCY_DOMAIN 1
 
-typedef struct NCSofa {  /* contains data of one SOFA file */
-    int ncid;            /* netCDF ID of the opened SOFA file */
+typedef struct MySofa {  /* contains data of one SOFA file */
+    struct MYSOFA_EASY *easy;
     int n_samples;       /* length of one impulse response (IR) */
-    int m_dim;           /* number of measurement positions */
-    int *data_delay;     /* broadband delay of each IR */
-                         /* all measurement positions for each receiver (i.e. ear): */
-    float *sp_a;         /* azimuth angles */
-    float *sp_e;         /* elevation angles */
-    float *sp_r;         /* radii */
-                         /* data at each measurement position for each receiver: */
-    float *data_ir;      /* IRs (time-domain) */
-} NCSofa;
+    float *lir, *rir;    /* IRs (time-domain) */
+    int max_delay;
+} MySofa;
 
 typedef struct VirtualSpeaker {
     uint8_t set;
@@ -64,12 +58,13 @@ typedef struct SOFAlizerContext {
     const AVClass *class;
 
     char *filename;             /* name of SOFA file */
-    NCSofa sofa;                /* contains data of the SOFA file */
+    MySofa sofa;                /* contains data of the SOFA file */
 
     int sample_rate;            /* sample rate from SOFA file */
     float *speaker_azim;        /* azimuth of the virtual loudspeakers */
     float *speaker_elev;        /* elevation of the virtual loudspeakers */
     char *speakers_pos;         /* custom positions of the virtual loudspeakers */
+    float lfe_gain;             /* initial gain for the LFE channel */
     float gain_lfe;             /* gain applied to LFE channel */
     int lfe_channel;            /* LFE channel position in channel layout */
 
@@ -106,276 +101,37 @@ typedef struct SOFAlizerContext {
     AVFloatDSPContext *fdsp;
 } SOFAlizerContext;
 
-static int close_sofa(struct NCSofa *sofa)
+static int close_sofa(struct MySofa *sofa)
 {
-    av_freep(&sofa->data_delay);
-    av_freep(&sofa->sp_a);
-    av_freep(&sofa->sp_e);
-    av_freep(&sofa->sp_r);
-    av_freep(&sofa->data_ir);
-    nc_close(sofa->ncid);
-    sofa->ncid = 0;
+    mysofa_close(sofa->easy);
+    sofa->easy = NULL;
 
     return 0;
 }
 
-static int load_sofa(AVFilterContext *ctx, char *filename, int *samplingrate)
+static int preload_sofa(AVFilterContext *ctx, char *filename, int *samplingrate)
 {
     struct SOFAlizerContext *s = ctx->priv;
-    /* variables associated with content of SOFA file: */
-    int ncid, n_dims, n_vars, n_gatts, n_unlim_dim_id, status;
-    char data_delay_dim_name[NC_MAX_NAME];
-    float *sp_a, *sp_e, *sp_r, *data_ir;
-    char *sofa_conventions;
-    char dim_name[NC_MAX_NAME];   /* names of netCDF dimensions */
-    size_t *dim_length;           /* lengths of netCDF dimensions */
-    char *text;
-    unsigned int sample_rate;
-    int data_delay_dim_id[2];
-    int samplingrate_id;
-    int data_delay_id;
-    int n_samples;
-    int m_dim_id = -1;
-    int n_dim_id = -1;
-    int data_ir_id;
-    size_t att_len;
-    int m_dim;
-    int *data_delay;
-    int sp_id;
-    int i, ret;
-
-    s->sofa.ncid = 0;
-    status = nc_open(filename, NC_NOWRITE, &ncid); /* open SOFA file read-only */
-    if (status != NC_NOERR) {
-        av_log(ctx, AV_LOG_ERROR, "Can't find SOFA-file '%s'\n", filename);
-        return AVERROR(EINVAL);
-    }
-
-    /* get number of dimensions, vars, global attributes and Id of unlimited dimensions: */
-    nc_inq(ncid, &n_dims, &n_vars, &n_gatts, &n_unlim_dim_id);
-
-    /* -- get number of measurements ("M") and length of one IR ("N") -- */
-    dim_length = av_malloc_array(n_dims, sizeof(*dim_length));
-    if (!dim_length) {
-        nc_close(ncid);
-        return AVERROR(ENOMEM);
-    }
-
-    for (i = 0; i < n_dims; i++) { /* go through all dimensions of file */
-        nc_inq_dim(ncid, i, (char *)&dim_name, &dim_length[i]); /* get dimensions */
-        if (!strncmp("M", (const char *)&dim_name, 1)) /* get ID of dimension "M" */
-            m_dim_id = i;
-        if (!strncmp("N", (const char *)&dim_name, 1)) /* get ID of dimension "N" */
-            n_dim_id = i;
-    }
+    struct MYSOFA_HRTF *mysofa;
+    int ret;
 
-    if ((m_dim_id == -1) || (n_dim_id == -1)) { /* dimension "M" or "N" couldn't be found */
-        av_log(ctx, AV_LOG_ERROR, "Can't find required dimensions in SOFA file.\n");
-        av_freep(&dim_length);
-        nc_close(ncid);
+    mysofa = mysofa_load(filename, &ret);
+    if (ret || !mysofa) {
+        av_log(ctx, AV_LOG_ERROR, "Can't find SOFA-file '%s'\n", filename);
         return AVERROR(EINVAL);
     }
 
-    n_samples = dim_length[n_dim_id]; /* get length of one IR */
-    m_dim     = dim_length[m_dim_id]; /* get number of measurements */
-
-    av_freep(&dim_length);
-
-    /* -- check file type -- */
-    /* get length of attritube "Conventions" */
-    status = nc_inq_attlen(ncid, NC_GLOBAL, "Conventions", &att_len);
-    if (status != NC_NOERR) {
-        av_log(ctx, AV_LOG_ERROR, "Can't get length of attribute \"Conventions\".\n");
-        nc_close(ncid);
-        return AVERROR_INVALIDDATA;
-    }
-
-    /* check whether file is SOFA file */
-    text = av_malloc(att_len + 1);
-    if (!text) {
-        nc_close(ncid);
-        return AVERROR(ENOMEM);
-    }
-
-    nc_get_att_text(ncid, NC_GLOBAL, "Conventions", text);
-    *(text + att_len) = 0;
-    if (strncmp("SOFA", text, 4)) {
-        av_log(ctx, AV_LOG_ERROR, "Not a SOFA file!\n");
-        av_freep(&text);
-        nc_close(ncid);
+    if (mysofa->DataSamplingRate.elements != 1)
         return AVERROR(EINVAL);
-    }
-    av_freep(&text);
-
-    status = nc_inq_attlen(ncid, NC_GLOBAL, "License", &att_len);
-    if (status == NC_NOERR) {
-        text = av_malloc(att_len + 1);
-        if (text) {
-            nc_get_att_text(ncid, NC_GLOBAL, "License", text);
-            *(text + att_len) = 0;
-            av_log(ctx, AV_LOG_INFO, "SOFA file License: %s\n", text);
-            av_freep(&text);
-        }
-    }
-
-    status = nc_inq_attlen(ncid, NC_GLOBAL, "SourceDescription", &att_len);
-    if (status == NC_NOERR) {
-        text = av_malloc(att_len + 1);
-        if (text) {
-            nc_get_att_text(ncid, NC_GLOBAL, "SourceDescription", text);
-            *(text + att_len) = 0;
-            av_log(ctx, AV_LOG_INFO, "SOFA file SourceDescription: %s\n", text);
-            av_freep(&text);
-        }
-    }
-
-    status = nc_inq_attlen(ncid, NC_GLOBAL, "Comment", &att_len);
-    if (status == NC_NOERR) {
-        text = av_malloc(att_len + 1);
-        if (text) {
-            nc_get_att_text(ncid, NC_GLOBAL, "Comment", text);
-            *(text + att_len) = 0;
-            av_log(ctx, AV_LOG_INFO, "SOFA file Comment: %s\n", text);
-            av_freep(&text);
-        }
-    }
-
-    status = nc_inq_attlen(ncid, NC_GLOBAL, "SOFAConventions", &att_len);
-    if (status != NC_NOERR) {
-        av_log(ctx, AV_LOG_ERROR, "Can't get length of attribute \"SOFAConventions\".\n");
-        nc_close(ncid);
-        return AVERROR_INVALIDDATA;
-    }
-
-    sofa_conventions = av_malloc(att_len + 1);
-    if (!sofa_conventions) {
-        nc_close(ncid);
-        return AVERROR(ENOMEM);
-    }
-
-    nc_get_att_text(ncid, NC_GLOBAL, "SOFAConventions", sofa_conventions);
-    *(sofa_conventions + att_len) = 0;
-    if (strncmp("SimpleFreeFieldHRIR", sofa_conventions, att_len)) {
-        av_log(ctx, AV_LOG_ERROR, "Not a SimpleFreeFieldHRIR file!\n");
-        av_freep(&sofa_conventions);
-        nc_close(ncid);
-        return AVERROR(EINVAL);
-    }
-    av_freep(&sofa_conventions);
-
-    /* -- get sampling rate of HRTFs -- */
-    /* read ID, then value */
-    status  = nc_inq_varid(ncid, "Data.SamplingRate", &samplingrate_id);
-    status += nc_get_var_uint(ncid, samplingrate_id, &sample_rate);
-    if (status != NC_NOERR) {
-        av_log(ctx, AV_LOG_ERROR, "Couldn't read Data.SamplingRate.\n");
-        nc_close(ncid);
-        return AVERROR(EINVAL);
-    }
-    *samplingrate = sample_rate; /* remember sampling rate */
-
-    /* -- allocate memory for one value for each measurement position: -- */
-    sp_a = s->sofa.sp_a = av_malloc_array(m_dim, sizeof(float));
-    sp_e = s->sofa.sp_e = av_malloc_array(m_dim, sizeof(float));
-    sp_r = s->sofa.sp_r = av_malloc_array(m_dim, sizeof(float));
-    /* delay and IR values required for each ear and measurement position: */
-    data_delay = s->sofa.data_delay = av_calloc(m_dim, 2 * sizeof(int));
-    data_ir = s->sofa.data_ir = av_calloc(m_dim * FFALIGN(n_samples, 16), sizeof(float) * 2);
-
-    if (!data_delay || !sp_a || !sp_e || !sp_r || !data_ir) {
-        /* if memory could not be allocated */
-        close_sofa(&s->sofa);
-        return AVERROR(ENOMEM);
-    }
-
-    /* get impulse responses (HRTFs): */
-    /* get corresponding ID */
-    status = nc_inq_varid(ncid, "Data.IR", &data_ir_id);
-    status += nc_get_var_float(ncid, data_ir_id, data_ir); /* read and store IRs */
-    if (status != NC_NOERR) {
-        av_log(ctx, AV_LOG_ERROR, "Couldn't read Data.IR!\n");
-        ret = AVERROR(EINVAL);
-        goto error;
-    }
-
-    /* get source positions of the HRTFs in the SOFA file: */
-    status  = nc_inq_varid(ncid, "SourcePosition", &sp_id); /* get corresponding ID */
-    status += nc_get_vara_float(ncid, sp_id, (size_t[2]){ 0, 0 } ,
-                (size_t[2]){ m_dim, 1}, sp_a); /* read & store azimuth angles */
-    status += nc_get_vara_float(ncid, sp_id, (size_t[2]){ 0, 1 } ,
-                (size_t[2]){ m_dim, 1}, sp_e); /* read & store elevation angles */
-    status += nc_get_vara_float(ncid, sp_id, (size_t[2]){ 0, 2 } ,
-                (size_t[2]){ m_dim, 1}, sp_r); /* read & store radii */
-    if (status != NC_NOERR) { /* if any source position variable coudn't be read */
-        av_log(ctx, AV_LOG_ERROR, "Couldn't read SourcePosition.\n");
-        ret = AVERROR(EINVAL);
-        goto error;
-    }
-
-    /* read Data.Delay, check for errors and fit it to data_delay */
-    status  = nc_inq_varid(ncid, "Data.Delay", &data_delay_id);
-    status += nc_inq_vardimid(ncid, data_delay_id, &data_delay_dim_id[0]);
-    status += nc_inq_dimname(ncid, data_delay_dim_id[0], data_delay_dim_name);
-    if (status != NC_NOERR) {
-        av_log(ctx, AV_LOG_ERROR, "Couldn't read Data.Delay.\n");
-        ret = AVERROR(EINVAL);
-        goto error;
-    }
-
-    /* Data.Delay dimension check */
-    /* dimension of Data.Delay is [I R]: */
-    if (!strncmp(data_delay_dim_name, "I", 2)) {
-        /* check 2 characters to assure string is 0-terminated after "I" */
-        int delay[2]; /* delays get from SOFA file: */
-        int *data_delay_r;
-
-        av_log(ctx, AV_LOG_DEBUG, "Data.Delay has dimension [I R]\n");
-        status = nc_get_var_int(ncid, data_delay_id, &delay[0]);
-        if (status != NC_NOERR) {
-            av_log(ctx, AV_LOG_ERROR, "Couldn't read Data.Delay\n");
-            ret = AVERROR(EINVAL);
-            goto error;
-        }
-        data_delay_r = data_delay + m_dim;
-        for (i = 0; i < m_dim; i++) { /* extend given dimension [I R] to [M R] */
-            /* assign constant delay value for all measurements to data_delay fields */
-            data_delay[i]   = delay[0];
-            data_delay_r[i] = delay[1];
-        }
-        /* dimension of Data.Delay is [M R] */
-    } else if (!strncmp(data_delay_dim_name, "M", 2)) {
-        av_log(ctx, AV_LOG_ERROR, "Data.Delay in dimension [M R]\n");
-        /* get delays from SOFA file: */
-        status = nc_get_var_int(ncid, data_delay_id, data_delay);
-        if (status != NC_NOERR) {
-            av_log(ctx, AV_LOG_ERROR, "Couldn't read Data.Delay\n");
-            ret = AVERROR(EINVAL);
-            goto error;
-        }
-    } else { /* dimension of Data.Delay is neither [I R] nor [M R] */
-        av_log(ctx, AV_LOG_ERROR, "Data.Delay does not have the required dimensions [I R] or [M R].\n");
-        ret = AVERROR(EINVAL);
-        goto error;
-    }
-
-    /* save information in SOFA struct: */
-    s->sofa.m_dim = m_dim; /* no. measurement positions */
-    s->sofa.n_samples = n_samples; /* length on one IR */
-    s->sofa.ncid = ncid; /* netCDF ID of SOFA file */
-    nc_close(ncid); /* close SOFA file */
-
-    av_log(ctx, AV_LOG_DEBUG, "m_dim: %d n_samples %d\n", m_dim, n_samples);
+    *samplingrate = mysofa->DataSamplingRate.values[0];
+    s->sofa.n_samples = mysofa->N;
+    mysofa_free(mysofa);
 
     return 0;
-
-error:
-    close_sofa(&s->sofa);
-    return ret;
 }
 
-static int parse_channel_name(char **arg, int *rchannel)
+static int parse_channel_name(char **arg, int *rchannel, char *buf)
 {
-    char buf[8];
     int len, i, channel_id = 0;
     int64_t layout, layout0;
 
@@ -384,13 +140,13 @@ static int parse_channel_name(char **arg, int *rchannel)
         layout0 = layout = av_get_channel_layout(buf);
         /* channel_id <- first set bit in layout */
         for (i = 32; i > 0; i >>= 1) {
-            if (layout >= (int64_t)1 << i) {
+            if (layout >= 1LL << i) {
                 channel_id += i;
                 layout >>= i;
             }
         }
         /* reject layouts that are not a single channel */
-        if (channel_id >= 64 || layout0 != (int64_t)1 << channel_id)
+        if (channel_id >= 64 || layout0 != 1LL << channel_id)
             return AVERROR(EINVAL);
         *rchannel = channel_id;
         *arg += len;
@@ -409,12 +165,15 @@ static void parse_speaker_pos(AVFilterContext *ctx, int64_t in_channel_layout)
     p = args;
 
     while ((arg = av_strtok(p, "|", &tokenizer))) {
+        char buf[8];
         float azim, elev;
         int out_ch_id;
 
         p = NULL;
-        if (parse_channel_name(&arg, &out_ch_id))
+        if (parse_channel_name(&arg, &out_ch_id, buf)) {
+            av_log(ctx, AV_LOG_WARNING, "Failed to parse \'%s\' as channel name.\n", buf);
             continue;
+        }
         if (sscanf(arg, "%f %f", &azim, &elev) == 2) {
             s->vspkrpos[out_ch_id].set = 1;
             s->vspkrpos[out_ch_id].azim = azim;
@@ -448,7 +207,7 @@ static int get_speaker_pos(AVFilterContext *ctx,
 
     /* set speaker positions according to input channel configuration: */
     for (m = 0, ch = 0; ch < n_conv && m < 64; m++) {
-        uint64_t mask = channels_layout & (1 << m);
+        uint64_t mask = channels_layout & (1ULL << m);
 
         switch (mask) {
         case AV_CH_FRONT_LEFT:            azim[ch] =  30;      break;
@@ -504,83 +263,6 @@ static int get_speaker_pos(AVFilterContext *ctx,
 
 }
 
-static int max_delay(struct NCSofa *sofa)
-{
-    int i, max = 0;
-
-    for (i = 0; i < sofa->m_dim * 2; i++) {
-        /* search maximum delay in given SOFA file */
-        max = FFMAX(max, sofa->data_delay[i]);
-    }
-
-    return max;
-}
-
-static int find_m(SOFAlizerContext *s, int azim, int elev, float radius)
-{
-    /* get source positions and M of currently selected SOFA file */
-    float *sp_a = s->sofa.sp_a; /* azimuth angle */
-    float *sp_e = s->sofa.sp_e; /* elevation angle */
-    float *sp_r = s->sofa.sp_r; /* radius */
-    int m_dim = s->sofa.m_dim; /* no. measurements */
-    int best_id = 0; /* index m currently closest to desired source pos. */
-    float delta = 1000; /* offset between desired and currently best pos. */
-    float current;
-    int i;
-
-    for (i = 0; i < m_dim; i++) {
-        /* search through all measurements in currently selected SOFA file */
-        /* distance of current to desired source position: */
-        current = fabs(sp_a[i] - azim) +
-                  fabs(sp_e[i] - elev) +
-                  fabs(sp_r[i] - radius);
-        if (current <= delta) {
-            /* if current distance is smaller than smallest distance so far */
-            delta = current;
-            best_id = i; /* remember index */
-        }
-    }
-
-    return best_id;
-}
-
-static int compensate_volume(AVFilterContext *ctx)
-{
-    struct SOFAlizerContext *s = ctx->priv;
-    float compensate;
-    float energy = 0;
-    float *ir;
-    int m;
-
-    if (s->sofa.ncid) {
-        /* find IR at front center position in the SOFA file (IR closest to 0°,0°,1m) */
-        struct NCSofa *sofa = &s->sofa;
-        m = find_m(s, 0, 0, 1);
-        /* get energy of that IR and compensate volume */
-        ir = sofa->data_ir + 2 * m * sofa->n_samples;
-        if (sofa->n_samples & 31) {
-            energy = avpriv_scalarproduct_float_c(ir, ir, sofa->n_samples);
-        } else {
-            energy = s->fdsp->scalarproduct_float(ir, ir, sofa->n_samples);
-        }
-        compensate = 256 / (sofa->n_samples * sqrt(energy));
-        av_log(ctx, AV_LOG_DEBUG, "Compensate-factor: %f\n", compensate);
-        ir = sofa->data_ir;
-        /* apply volume compensation to IRs */
-        if (sofa->n_samples & 31) {
-            int i;
-            for (i = 0; i < sofa->n_samples * sofa->m_dim * 2; i++) {
-                ir[i] = ir[i] * compensate;
-            }
-        } else {
-            s->fdsp->vector_fmul_scalar(ir, ir, compensate, sofa->n_samples * sofa->m_dim * 2);
-            emms_c();
-        }
-    }
-
-    return 0;
-}
-
 typedef struct ThreadData {
     AVFrame *in, *out;
     int *write;
@@ -626,10 +308,10 @@ static int sofalizer_convolute(AVFilterContext *ctx, void *arg, int jobnr, int n
     for (i = 0; i < in->nb_samples; i++) {
         const float *temp_ir = ir; /* using same set of IRs for each sample */
 
-        *dst = 0;
+        dst[0] = 0;
         for (l = 0; l < in_channels; l++) {
             /* write current input sample to ringbuffer (for each channel) */
-            *(buffer[l] + wr) = src[l];
+            buffer[l][wr] = src[l];
         }
 
         /* loop goes through all channels to be convolved */
@@ -640,31 +322,31 @@ static int sofalizer_convolute(AVFilterContext *ctx, void *arg, int jobnr, int n
                 /* LFE is an input channel but requires no convolution */
                 /* apply gain to LFE signal and add to output buffer */
                 *dst += *(buffer[s->lfe_channel] + wr) * s->gain_lfe;
-                temp_ir += FFALIGN(n_samples, 16);
+                temp_ir += FFALIGN(n_samples, 32);
                 continue;
             }
 
             /* current read position in ringbuffer: input sample write position
              * - delay for l-th ch. + diff. betw. IR length and buffer length
              * (mod buffer length) */
-            read = (wr - *(delay + l) - (n_samples - 1) + buffer_length) & modulo;
+            read = (wr - delay[l] - (n_samples - 1) + buffer_length) & modulo;
 
             if (read + n_samples < buffer_length) {
-                memcpy(temp_src, bptr + read, n_samples * sizeof(*temp_src));
+                memmove(temp_src, bptr + read, n_samples * sizeof(*temp_src));
             } else {
                 int len = FFMIN(n_samples - (read % n_samples), buffer_length - read);
 
-                memcpy(temp_src, bptr + read, len * sizeof(*temp_src));
-                memcpy(temp_src + len, bptr, (n_samples - len) * sizeof(*temp_src));
+                memmove(temp_src, bptr + read, len * sizeof(*temp_src));
+                memmove(temp_src + len, bptr, (n_samples - len) * sizeof(*temp_src));
             }
 
             /* multiply signal and IR, and add up the results */
             dst[0] += s->fdsp->scalarproduct_float(temp_ir, temp_src, n_samples);
-            temp_ir += FFALIGN(n_samples, 16);
+            temp_ir += FFALIGN(n_samples, 32);
         }
 
         /* clippings counter */
-        if (fabs(*dst) > 1)
+        if (fabs(dst[0]) > 1)
             *n_clippings += 1;
 
         /* move output buffer pointer by +2 to get to next sample of processed channel: */
@@ -701,6 +383,8 @@ static int sofalizer_fast_convolute(AVFilterContext *ctx, void *arg, int jobnr,
     FFTContext *fft = s->fft[jobnr];
     const int n_conv = s->n_conv;
     const int n_fft = s->n_fft;
+    const float fft_scale = 1.0f / s->n_fft;
+    FFTComplex *hrtf_offset;
     int wr = *write;
     int n_read;
     int i, j;
@@ -734,6 +418,7 @@ static int sofalizer_fast_convolute(AVFilterContext *ctx, void *arg, int jobnr,
 
         /* outer loop: go through all input channels to be convolved */
         offset = i * n_fft; /* no. samples already processed */
+        hrtf_offset = hrtf + offset;
 
         /* fill FFT input with 0 (we want to zero-pad) */
         memset(fft_in, 0, sizeof(FFTComplex) * n_fft);
@@ -748,14 +433,15 @@ static int sofalizer_fast_convolute(AVFilterContext *ctx, void *arg, int jobnr,
         av_fft_permute(fft, fft_in);
         av_fft_calc(fft, fft_in);
         for (j = 0; j < n_fft; j++) {
+            const FFTComplex *hcomplex = hrtf_offset + j;
             const float re = fft_in[j].re;
             const float im = fft_in[j].im;
 
             /* complex multiplication of input signal and HRTFs */
             /* output channel (real): */
-            fft_in[j].re = re * (hrtf + offset + j)->re - im * (hrtf + offset + j)->im;
+            fft_in[j].re = re * hcomplex->re - im * hcomplex->im;
             /* output channel (imag): */
-            fft_in[j].im = re * (hrtf + offset + j)->im + im * (hrtf + offset + j)->re;
+            fft_in[j].im = re * hcomplex->im + im * hcomplex->re;
         }
 
         /* transform output signal of current channel back to time domain */
@@ -764,14 +450,14 @@ static int sofalizer_fast_convolute(AVFilterContext *ctx, void *arg, int jobnr,
 
         for (j = 0; j < in->nb_samples; j++) {
             /* write output signal of current channel to output buffer */
-            dst[2 * j] += fft_in[j].re / (float)n_fft;
+            dst[2 * j] += fft_in[j].re * fft_scale;
         }
 
         for (j = 0; j < n_samples - 1; j++) { /* overflow length is IR length - 1 */
             /* write the rest of output signal to overflow buffer */
             int write_pos = (wr + j) & modulo;
 
-            *(ringbuffer + write_pos) += fft_in[in->nb_samples + j].re / (float)n_fft;
+            *(ringbuffer + write_pos) += fft_in[in->nb_samples + j].re * fft_scale;
         }
     }
 
@@ -779,7 +465,7 @@ static int sofalizer_fast_convolute(AVFilterContext *ctx, void *arg, int jobnr,
     for (i = 0; i < out->nb_samples; i++) {
         /* clippings counter */
         if (fabs(*dst) > 1) { /* if current output sample > 1 */
-            *n_clippings = *n_clippings + 1;
+            n_clippings[0]++;
         }
 
         /* move output buffer pointer by +2 to get to next sample of processed channel: */
@@ -868,14 +554,14 @@ static int query_formats(AVFilterContext *ctx)
     return ff_set_common_samplerates(ctx, formats);
 }
 
-static int load_data(AVFilterContext *ctx, int azim, int elev, float radius)
+static int load_data(AVFilterContext *ctx, int azim, int elev, float radius, int sample_rate)
 {
     struct SOFAlizerContext *s = ctx->priv;
-    const int n_samples = s->sofa.n_samples;
+    int n_samples;
     int n_conv = s->n_conv; /* no. channels to convolve */
-    int n_fft = s->n_fft;
-    int delay_l[16]; /* broadband delay for each IR */
-    int delay_r[16];
+    int n_fft;
+    float delay_l; /* broadband delay for each IR */
+    float delay_r;
     int nb_input_channels = ctx->inputs[0]->channels; /* no. input channels */
     float gain_lin = expf((s->gain - 3 * nb_input_channels) / 20 * M_LN10); /* gain - 3dB/channel */
     FFTComplex *data_hrtf_l = NULL;
@@ -885,68 +571,166 @@ static int load_data(AVFilterContext *ctx, int azim, int elev, float radius)
     float *data_ir_l = NULL;
     float *data_ir_r = NULL;
     int offset = 0; /* used for faster pointer arithmetics in for-loop */
-    int m[16]; /* measurement index m of IR closest to required source positions */
     int i, j, azim_orig = azim, elev_orig = elev;
+    int filter_length, ret = 0;
+    int n_current;
+    int n_max = 0;
 
-    if (!s->sofa.ncid) { /* if an invalid SOFA file has been selected */
+    s->sofa.easy = mysofa_open(s->filename, sample_rate, &filter_length, &ret);
+    if (!s->sofa.easy || ret) { /* if an invalid SOFA file has been selected */
         av_log(ctx, AV_LOG_ERROR, "Selected SOFA file is invalid. Please select valid SOFA file.\n");
         return AVERROR_INVALIDDATA;
     }
 
+    n_samples = s->sofa.n_samples;
+
+    s->data_ir[0] = av_calloc(FFALIGN(n_samples, 32), sizeof(float) * s->n_conv);
+    s->data_ir[1] = av_calloc(FFALIGN(n_samples, 32), sizeof(float) * s->n_conv);
+    s->delay[0] = av_calloc(s->n_conv, sizeof(int));
+    s->delay[1] = av_calloc(s->n_conv, sizeof(int));
+
+    if (!s->data_ir[0] || !s->data_ir[1] || !s->delay[0] || !s->delay[1]) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    /* get temporary IR for L and R channel */
+    data_ir_l = av_calloc(n_conv * FFALIGN(n_samples, 32), sizeof(*data_ir_l));
+    data_ir_r = av_calloc(n_conv * FFALIGN(n_samples, 32), sizeof(*data_ir_r));
+    if (!data_ir_r || !data_ir_l) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
     if (s->type == TIME_DOMAIN) {
-        s->temp_src[0] = av_calloc(FFALIGN(n_samples, 16), sizeof(float));
-        s->temp_src[1] = av_calloc(FFALIGN(n_samples, 16), sizeof(float));
-
-        /* get temporary IR for L and R channel */
-        data_ir_l = av_calloc(n_conv * FFALIGN(n_samples, 16), sizeof(*data_ir_l));
-        data_ir_r = av_calloc(n_conv * FFALIGN(n_samples, 16), sizeof(*data_ir_r));
-        if (!data_ir_r || !data_ir_l || !s->temp_src[0] || !s->temp_src[1]) {
-            av_free(data_ir_l);
-            av_free(data_ir_r);
-            return AVERROR(ENOMEM);
+        s->temp_src[0] = av_calloc(FFALIGN(n_samples, 32), sizeof(float));
+        s->temp_src[1] = av_calloc(FFALIGN(n_samples, 32), sizeof(float));
+        if (!s->temp_src[0] || !s->temp_src[1]) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
         }
+    }
+
+    s->speaker_azim = av_calloc(s->n_conv, sizeof(*s->speaker_azim));
+    s->speaker_elev = av_calloc(s->n_conv, sizeof(*s->speaker_elev));
+    if (!s->speaker_azim || !s->speaker_elev) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    /* get speaker positions */
+    if ((ret = get_speaker_pos(ctx, s->speaker_azim, s->speaker_elev)) < 0) {
+        av_log(ctx, AV_LOG_ERROR, "Couldn't get speaker positions. Input channel configuration not supported.\n");
+        goto fail;
+    }
+
+    for (i = 0; i < s->n_conv; i++) {
+        float coordinates[3];
+
+        /* load and store IRs and corresponding delays */
+        azim = (int)(s->speaker_azim[i] + azim_orig) % 360;
+        elev = (int)(s->speaker_elev[i] + elev_orig) % 90;
+
+        coordinates[0] = azim;
+        coordinates[1] = elev;
+        coordinates[2] = radius;
+
+        mysofa_s2c(coordinates);
+
+        /* get id of IR closest to desired position */
+        mysofa_getfilter_float(s->sofa.easy, coordinates[0], coordinates[1], coordinates[2],
+                               data_ir_l + FFALIGN(n_samples, 32) * i,
+                               data_ir_r + FFALIGN(n_samples, 32) * i,
+                               &delay_l, &delay_r);
+
+        s->delay[0][i] = delay_l * sample_rate;
+        s->delay[1][i] = delay_r * sample_rate;
+
+        s->sofa.max_delay = FFMAX3(s->sofa.max_delay, s->delay[0][i], s->delay[1][i]);
+    }
+
+    /* get size of ringbuffer (longest IR plus max. delay) */
+    /* then choose next power of 2 for performance optimization */
+    n_current = s->sofa.n_samples + s->sofa.max_delay;
+    /* length of longest IR plus max. delay */
+    n_max = FFMAX(n_max, n_current);
+
+    /* buffer length is longest IR plus max. delay -> next power of 2
+       (32 - count leading zeros gives required exponent)  */
+    s->buffer_length = 1 << (32 - ff_clz(n_max));
+    s->n_fft = n_fft = 1 << (32 - ff_clz(n_max + sample_rate));
+
+    if (s->type == FREQUENCY_DOMAIN) {
+        av_fft_end(s->fft[0]);
+        av_fft_end(s->fft[1]);
+        s->fft[0] = av_fft_init(log2(s->n_fft), 0);
+        s->fft[1] = av_fft_init(log2(s->n_fft), 0);
+        av_fft_end(s->ifft[0]);
+        av_fft_end(s->ifft[1]);
+        s->ifft[0] = av_fft_init(log2(s->n_fft), 1);
+        s->ifft[1] = av_fft_init(log2(s->n_fft), 1);
+
+        if (!s->fft[0] || !s->fft[1] || !s->ifft[0] || !s->ifft[1]) {
+            av_log(ctx, AV_LOG_ERROR, "Unable to create FFT contexts of size %d.\n", s->n_fft);
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+    }
+
+    if (s->type == TIME_DOMAIN) {
+        s->ringbuffer[0] = av_calloc(s->buffer_length, sizeof(float) * nb_input_channels);
+        s->ringbuffer[1] = av_calloc(s->buffer_length, sizeof(float) * nb_input_channels);
     } else {
         /* get temporary HRTF memory for L and R channel */
         data_hrtf_l = av_malloc_array(n_fft, sizeof(*data_hrtf_l) * n_conv);
         data_hrtf_r = av_malloc_array(n_fft, sizeof(*data_hrtf_r) * n_conv);
         if (!data_hrtf_r || !data_hrtf_l) {
-            av_free(data_hrtf_l);
-            av_free(data_hrtf_r);
-            return AVERROR(ENOMEM);
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+
+        s->ringbuffer[0] = av_calloc(s->buffer_length, sizeof(float));
+        s->ringbuffer[1] = av_calloc(s->buffer_length, sizeof(float));
+        s->temp_fft[0] = av_malloc_array(s->n_fft, sizeof(FFTComplex));
+        s->temp_fft[1] = av_malloc_array(s->n_fft, sizeof(FFTComplex));
+        if (!s->temp_fft[0] || !s->temp_fft[1]) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+    }
+
+    if (!s->ringbuffer[0] || !s->ringbuffer[1]) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    if (s->type == FREQUENCY_DOMAIN) {
+        fft_in_l = av_calloc(n_fft, sizeof(*fft_in_l));
+        fft_in_r = av_calloc(n_fft, sizeof(*fft_in_r));
+        if (!fft_in_l || !fft_in_r) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
         }
     }
 
     for (i = 0; i < s->n_conv; i++) {
-        /* load and store IRs and corresponding delays */
-        azim = (int)(s->speaker_azim[i] + azim_orig) % 360;
-        elev = (int)(s->speaker_elev[i] + elev_orig) % 90;
-        /* get id of IR closest to desired position */
-        m[i] = find_m(s, azim, elev, radius);
+        float *lir, *rir;
 
-        /* load the delays associated with the current IRs */
-        delay_l[i] = *(s->sofa.data_delay + 2 * m[i]);
-        delay_r[i] = *(s->sofa.data_delay + 2 * m[i] + 1);
+        offset = i * FFALIGN(n_samples, 32); /* no. samples already written */
+
+        lir = data_ir_l + offset;
+        rir = data_ir_r + offset;
 
         if (s->type == TIME_DOMAIN) {
-            offset = i * FFALIGN(n_samples, 16); /* no. samples already written */
             for (j = 0; j < n_samples; j++) {
                 /* load reversed IRs of the specified source position
                  * sample-by-sample for left and right ear; and apply gain */
-                *(data_ir_l + offset + j) = /* left channel */
-                *(s->sofa.data_ir + 2 * m[i] * n_samples + n_samples - 1 - j) * gain_lin;
-                *(data_ir_r + offset + j) = /* right channel */
-                *(s->sofa.data_ir + 2 * m[i] * n_samples + n_samples - 1 - j  + n_samples) * gain_lin;
+                s->data_ir[0][offset + j] = lir[n_samples - 1 - j] * gain_lin;
+                s->data_ir[1][offset + j] = rir[n_samples - 1 - j] * gain_lin;
             }
         } else {
-            fft_in_l = av_calloc(n_fft, sizeof(*fft_in_l));
-            fft_in_r = av_calloc(n_fft, sizeof(*fft_in_r));
-            if (!fft_in_l || !fft_in_r) {
-                av_free(data_hrtf_l);
-                av_free(data_hrtf_r);
-                av_free(fft_in_l);
-                av_free(fft_in_r);
-                return AVERROR(ENOMEM);
-            }
+            memset(fft_in_l, 0, n_fft * sizeof(*fft_in_l));
+            memset(fft_in_r, 0, n_fft * sizeof(*fft_in_r));
 
             offset = i * n_fft; /* no. samples already written */
             for (j = 0; j < n_samples; j++) {
@@ -954,10 +738,8 @@ static int load_data(AVFilterContext *ctx, int azim, int elev, float radius)
                  * sample-by-sample and apply gain,
                  * L channel is loaded to real part, R channel to imag part,
                  * IRs ared shifted by L and R delay */
-                fft_in_l[delay_l[i] + j].re = /* left channel */
-                *(s->sofa.data_ir + 2 * m[i] * n_samples + j) * gain_lin;
-                fft_in_r[delay_r[i] + j].re = /* right channel */
-                *(s->sofa.data_ir + (2 * m[i] + 1) * n_samples + j) * gain_lin;
+                fft_in_l[s->delay[0][i] + j].re = lir[j] * gain_lin;
+                fft_in_r[s->delay[1][i] + j].re = rir[j] * gain_lin;
             }
 
             /* actually transform to frequency domain (IRs -> HRTFs) */
@@ -968,45 +750,33 @@ static int load_data(AVFilterContext *ctx, int azim, int elev, float radius)
             av_fft_calc(s->fft[0], fft_in_r);
             memcpy(data_hrtf_r + offset, fft_in_r, n_fft * sizeof(*fft_in_r));
         }
-
-        av_log(ctx, AV_LOG_DEBUG, "Index: %d, Azimuth: %f, Elevation: %f, Radius: %f of SOFA file.\n",
-               m[i], *(s->sofa.sp_a + m[i]), *(s->sofa.sp_e + m[i]), *(s->sofa.sp_r + m[i]));
     }
 
-    if (s->type == TIME_DOMAIN) {
-        /* copy IRs and delays to allocated memory in the SOFAlizerContext struct: */
-        memcpy(s->data_ir[0], data_ir_l, sizeof(float) * n_conv * FFALIGN(n_samples, 16));
-        memcpy(s->data_ir[1], data_ir_r, sizeof(float) * n_conv * FFALIGN(n_samples, 16));
-
-        av_freep(&data_ir_l); /* free temporary IR memory */
-        av_freep(&data_ir_r);
-    } else {
+    if (s->type == FREQUENCY_DOMAIN) {
         s->data_hrtf[0] = av_malloc_array(n_fft * s->n_conv, sizeof(FFTComplex));
         s->data_hrtf[1] = av_malloc_array(n_fft * s->n_conv, sizeof(FFTComplex));
         if (!s->data_hrtf[0] || !s->data_hrtf[1]) {
-            av_freep(&data_hrtf_l);
-            av_freep(&data_hrtf_r);
-            av_freep(&fft_in_l);
-            av_freep(&fft_in_r);
-            return AVERROR(ENOMEM); /* memory allocation failed */
+            ret = AVERROR(ENOMEM);
+            goto fail;
         }
 
         memcpy(s->data_hrtf[0], data_hrtf_l, /* copy HRTF data to */
             sizeof(FFTComplex) * n_conv * n_fft); /* filter struct */
         memcpy(s->data_hrtf[1], data_hrtf_r,
             sizeof(FFTComplex) * n_conv * n_fft);
+    }
 
-        av_freep(&data_hrtf_l); /* free temporary HRTF memory */
-        av_freep(&data_hrtf_r);
+fail:
+    av_freep(&data_hrtf_l); /* free temporary HRTF memory */
+    av_freep(&data_hrtf_r);
 
-        av_freep(&fft_in_l); /* free temporary FFT memory */
-        av_freep(&fft_in_r);
-    }
+    av_freep(&data_ir_l); /* free temprary IR memory */
+    av_freep(&data_ir_r);
 
-    memcpy(s->delay[0], &delay_l[0], sizeof(int) * s->n_conv);
-    memcpy(s->delay[1], &delay_r[0], sizeof(int) * s->n_conv);
+    av_freep(&fft_in_l); /* free temporary FFT memory */
+    av_freep(&fft_in_r);
 
-    return 0;
+    return ret;
 }
 
 static av_cold int init(AVFilterContext *ctx)
@@ -1019,12 +789,8 @@ static av_cold int init(AVFilterContext *ctx)
         return AVERROR(EINVAL);
     }
 
-    /* load SOFA file, */
-    /* initialize file IDs to 0 before attempting to load SOFA files,
-     * this assures that in case of error, only the memory of already
-     * loaded files is free'd */
-    s->sofa.ncid = 0;
-    ret = load_sofa(ctx, s->filename, &s->sample_rate);
+    /* preload SOFA file, */
+    ret = preload_sofa(ctx, s->filename, &s->sample_rate);
     if (ret) {
         /* file loading error */
         av_log(ctx, AV_LOG_ERROR, "Error while loading SOFA file: '%s'\n", s->filename);
@@ -1048,10 +814,6 @@ static int config_input(AVFilterLink *inlink)
 {
     AVFilterContext *ctx = inlink->dst;
     SOFAlizerContext *s = ctx->priv;
-    int nb_input_channels = inlink->channels; /* no. input channels */
-    int n_max_ir = 0;
-    int n_current;
-    int n_max = 0;
     int ret;
 
     if (s->type == FREQUENCY_DOMAIN) {
@@ -1061,87 +823,16 @@ static int config_input(AVFilterLink *inlink)
     }
 
     /* gain -3 dB per channel, -6 dB to get LFE on a similar level */
-    s->gain_lfe = expf((s->gain - 3 * inlink->channels - 6) / 20 * M_LN10);
-
-    s->n_conv = nb_input_channels;
-
-    /* get size of ringbuffer (longest IR plus max. delay) */
-    /* then choose next power of 2 for performance optimization */
-    n_current = s->sofa.n_samples + max_delay(&s->sofa);
-    if (n_current > n_max) {
-        /* length of longest IR plus max. delay (in all SOFA files) */
-        n_max = n_current;
-        /* length of longest IR (without delay, in all SOFA files) */
-        n_max_ir = s->sofa.n_samples;
-    }
-    /* buffer length is longest IR plus max. delay -> next power of 2
-       (32 - count leading zeros gives required exponent)  */
-    s->buffer_length = 1 << (32 - ff_clz(n_max));
-    s->n_fft         = 1 << (32 - ff_clz(n_max + inlink->sample_rate));
-
-    if (s->type == FREQUENCY_DOMAIN) {
-        av_fft_end(s->fft[0]);
-        av_fft_end(s->fft[1]);
-        s->fft[0] = av_fft_init(log2(s->n_fft), 0);
-        s->fft[1] = av_fft_init(log2(s->n_fft), 0);
-        av_fft_end(s->ifft[0]);
-        av_fft_end(s->ifft[1]);
-        s->ifft[0] = av_fft_init(log2(s->n_fft), 1);
-        s->ifft[1] = av_fft_init(log2(s->n_fft), 1);
-
-        if (!s->fft[0] || !s->fft[1] || !s->ifft[0] || !s->ifft[1]) {
-            av_log(ctx, AV_LOG_ERROR, "Unable to create FFT contexts of size %d.\n", s->n_fft);
-            return AVERROR(ENOMEM);
-        }
-    }
-
-    /* Allocate memory for the impulse responses, delays and the ringbuffers */
-    /* size: (longest IR) * (number of channels to convolute) */
-    s->data_ir[0] = av_calloc(FFALIGN(n_max_ir, 16), sizeof(float) * s->n_conv);
-    s->data_ir[1] = av_calloc(FFALIGN(n_max_ir, 16), sizeof(float) * s->n_conv);
-    /* length:  number of channels to convolute */
-    s->delay[0] = av_malloc_array(s->n_conv, sizeof(float));
-    s->delay[1] = av_malloc_array(s->n_conv, sizeof(float));
-    /* length: (buffer length) * (number of input channels),
-     * OR: buffer length (if frequency domain processing)
-     * calloc zero-initializes the buffer */
+    s->gain_lfe = expf((s->gain - 3 * inlink->channels - 6 + s->lfe_gain) / 20 * M_LN10);
 
-    if (s->type == TIME_DOMAIN) {
-        s->ringbuffer[0] = av_calloc(s->buffer_length, sizeof(float) * nb_input_channels);
-        s->ringbuffer[1] = av_calloc(s->buffer_length, sizeof(float) * nb_input_channels);
-    } else {
-        s->ringbuffer[0] = av_calloc(s->buffer_length, sizeof(float));
-        s->ringbuffer[1] = av_calloc(s->buffer_length, sizeof(float));
-        s->temp_fft[0] = av_malloc_array(s->n_fft, sizeof(FFTComplex));
-        s->temp_fft[1] = av_malloc_array(s->n_fft, sizeof(FFTComplex));
-        if (!s->temp_fft[0] || !s->temp_fft[1])
-            return AVERROR(ENOMEM);
-    }
-
-    /* length: number of channels to convolute */
-    s->speaker_azim = av_calloc(s->n_conv, sizeof(*s->speaker_azim));
-    s->speaker_elev = av_calloc(s->n_conv, sizeof(*s->speaker_elev));
-
-    /* memory allocation failed: */
-    if (!s->data_ir[0] || !s->data_ir[1] || !s->delay[1] ||
-        !s->delay[0] || !s->ringbuffer[0] || !s->ringbuffer[1] ||
-        !s->speaker_azim || !s->speaker_elev)
-        return AVERROR(ENOMEM);
-
-    compensate_volume(ctx);
-
-    /* get speaker positions */
-    if ((ret = get_speaker_pos(ctx, s->speaker_azim, s->speaker_elev)) < 0) {
-        av_log(ctx, AV_LOG_ERROR, "Couldn't get speaker positions. Input channel configuration not supported.\n");
-        return ret;
-    }
+    s->n_conv = inlink->channels;
 
     /* load IRs to data_ir[0] and data_ir[1] for required directions */
-    if ((ret = load_data(ctx, s->rotation, s->elevation, s->radius)) < 0)
+    if ((ret = load_data(ctx, s->rotation, s->elevation, s->radius, inlink->sample_rate)) < 0)
         return ret;
 
     av_log(ctx, AV_LOG_DEBUG, "Samplerate: %d Channels to convolute: %d, Length of ringbuffer: %d x %d\n",
-        inlink->sample_rate, s->n_conv, nb_input_channels, s->buffer_length);
+        inlink->sample_rate, s->n_conv, inlink->channels, s->buffer_length);
 
     return 0;
 }
@@ -1150,13 +841,7 @@ static av_cold void uninit(AVFilterContext *ctx)
 {
     SOFAlizerContext *s = ctx->priv;
 
-    if (s->sofa.ncid) {
-        av_freep(&s->sofa.sp_a);
-        av_freep(&s->sofa.sp_e);
-        av_freep(&s->sofa.sp_r);
-        av_freep(&s->sofa.data_delay);
-        av_freep(&s->sofa.data_ir);
-    }
+    close_sofa(&s->sofa);
     av_fft_end(s->ifft[0]);
     av_fft_end(s->ifft[1]);
     av_fft_end(s->fft[0]);
@@ -1191,6 +876,7 @@ static const AVOption sofalizer_options[] = {
     { "time",      "time domain",      0,               AV_OPT_TYPE_CONST,  {.i64=0},       0,   0, .flags = FLAGS, "type" },
     { "freq",      "frequency domain", 0,               AV_OPT_TYPE_CONST,  {.i64=1},       0,   0, .flags = FLAGS, "type" },
     { "speakers",  "set speaker custom positions", OFFSET(speakers_pos), AV_OPT_TYPE_STRING,  {.str=0},    0, 0, .flags = FLAGS },
+    { "lfegain",   "set lfe gain",                 OFFSET(lfe_gain),     AV_OPT_TYPE_FLOAT,   {.dbl=0},   -9, 9, .flags = FLAGS },
     { NULL }
 };
 
diff --git a/mythtv/external/FFmpeg/libavfilter/af_stereotools.c b/mythtv/external/FFmpeg/libavfilter/af_stereotools.c
index 8ab184df11c..a5e0b427f1e 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_stereotools.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_stereotools.c
@@ -33,6 +33,8 @@ typedef struct StereoToolsContext {
     int phase_l;
     int phase_r;
     int mode;
+    int bmode_in;
+    int bmode_out;
     double slev;
     double sbal;
     double mlev;
@@ -67,7 +69,7 @@ static const AVOption stereotools_options[] = {
     { "muter",       "mute R",           OFFSET(mute_r),      AV_OPT_TYPE_BOOL,   {.i64=0},   0,          1, A },
     { "phasel",      "phase L",          OFFSET(phase_l),     AV_OPT_TYPE_BOOL,   {.i64=0},   0,          1, A },
     { "phaser",      "phase R",          OFFSET(phase_r),     AV_OPT_TYPE_BOOL,   {.i64=0},   0,          1, A },
-    { "mode",        "set stereo mode",  OFFSET(mode),        AV_OPT_TYPE_INT,    {.i64=0},   0,          6, A, "mode" },
+    { "mode",        "set stereo mode",  OFFSET(mode),        AV_OPT_TYPE_INT,    {.i64=0},   0,          8, A, "mode" },
     {     "lr>lr",   0,                  0,                   AV_OPT_TYPE_CONST,  {.i64=0},   0,          0, A, "mode" },
     {     "lr>ms",   0,                  0,                   AV_OPT_TYPE_CONST,  {.i64=1},   0,          0, A, "mode" },
     {     "ms>lr",   0,                  0,                   AV_OPT_TYPE_CONST,  {.i64=2},   0,          0, A, "mode" },
@@ -75,6 +77,8 @@ static const AVOption stereotools_options[] = {
     {     "lr>rr",   0,                  0,                   AV_OPT_TYPE_CONST,  {.i64=4},   0,          0, A, "mode" },
     {     "lr>l+r",  0,                  0,                   AV_OPT_TYPE_CONST,  {.i64=5},   0,          0, A, "mode" },
     {     "lr>rl",   0,                  0,                   AV_OPT_TYPE_CONST,  {.i64=6},   0,          0, A, "mode" },
+    {     "ms>ll",   0,                  0,                   AV_OPT_TYPE_CONST,  {.i64=7},   0,          0, A, "mode" },
+    {     "ms>rr",   0,                  0,                   AV_OPT_TYPE_CONST,  {.i64=8},   0,          0, A, "mode" },
     { "slev",        "set side level",   OFFSET(slev),        AV_OPT_TYPE_DOUBLE, {.dbl=1},   0.015625,  64, A },
     { "sbal",        "set side balance", OFFSET(sbal),        AV_OPT_TYPE_DOUBLE, {.dbl=0},  -1,          1, A },
     { "mlev",        "set middle level", OFFSET(mlev),        AV_OPT_TYPE_DOUBLE, {.dbl=1},   0.015625,  64, A },
@@ -83,6 +87,11 @@ static const AVOption stereotools_options[] = {
     { "delay",       "set delay",        OFFSET(delay),       AV_OPT_TYPE_DOUBLE, {.dbl=0}, -20,         20, A },
     { "sclevel",     "set S/C level",    OFFSET(sc_level),    AV_OPT_TYPE_DOUBLE, {.dbl=1},   1,        100, A },
     { "phase",       "set stereo phase", OFFSET(phase),       AV_OPT_TYPE_DOUBLE, {.dbl=0},   0,        360, A },
+    { "bmode_in",    "set balance in mode", OFFSET(bmode_in), AV_OPT_TYPE_INT,    {.i64=0},   0,          2, A, "bmode" },
+    {     "balance",   0,                0,                   AV_OPT_TYPE_CONST,  {.i64=0},   0,          0, A, "bmode" },
+    {     "amplitude", 0,                0,                   AV_OPT_TYPE_CONST,  {.i64=1},   0,          0, A, "bmode" },
+    {     "power",     0,                0,                   AV_OPT_TYPE_CONST,  {.i64=2},   0,          0, A, "bmode" },
+    { "bmode_out", "set balance out mode", OFFSET(bmode_out), AV_OPT_TYPE_INT,    {.i64=0},   0,          2, A, "bmode" },
     { NULL }
 };
 
@@ -167,13 +176,31 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     dst = (double *)out->data[0];
 
     for (n = 0; n < in->nb_samples; n++, src += 2, dst += 2) {
-        double L = src[0], R = src[1], l, r, m, S;
+        double L = src[0], R = src[1], l, r, m, S, gl, gr, gd;
 
         L *= level_in;
         R *= level_in;
 
-        L *= 1. - FFMAX(0., balance_in);
-        R *= 1. + FFMIN(0., balance_in);
+        gl = 1. - FFMAX(0., balance_in);
+        gr = 1. + FFMIN(0., balance_in);
+        switch (s->bmode_in) {
+        case 1:
+            gd = gl - gr;
+            gl = 1. + gd;
+            gr = 1. - gd;
+            break;
+        case 2:
+            if (balance_in < 0.) {
+                gr = FFMAX(0.5, gr);
+                gl = 1. / gr;
+            } else if (balance_in > 0.) {
+                gl = FFMAX(0.5, gl);
+                gr = 1. / gl;
+            }
+            break;
+        }
+        L *= gl;
+        R *= gr;
 
         if (s->softclip) {
             R = s->inv_atan_shape * atan(R * sc_level);
@@ -222,6 +249,16 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
             L = l;
             R = r;
             break;
+        case 7:
+            l = L * mlev * FFMIN(1., 2. - mpan) + R * slev * FFMIN(1., 2. - sbal);
+            L = l;
+            R = l;
+            break;
+        case 8:
+            r = L * mlev * FFMIN(1., mpan)      - R * slev * FFMIN(1., sbal);
+            L = r;
+            R = r;
+            break;
         }
 
         L *= 1. - mute_l;
@@ -253,8 +290,27 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 
         s->pos = (s->pos + 2) % s->length;
 
-        L *= 1. - FFMAX(0., balance_out);
-        R *= 1. + FFMIN(0., balance_out);
+        gl = 1. - FFMAX(0., balance_out);
+        gr = 1. + FFMIN(0., balance_out);
+        switch (s->bmode_out) {
+        case 1:
+            gd = gl - gr;
+            gl = 1. + gd;
+            gr = 1. - gd;
+            break;
+        case 2:
+            if (balance_out < 0.) {
+                gr = FFMAX(0.5, gr);
+                gl = 1. / gr;
+            } else if (balance_out > 0.) {
+                gl = FFMAX(0.5, gl);
+                gr = 1. / gl;
+            }
+            break;
+        }
+        L *= gl;
+        R *= gr;
+
 
         L *= level_out;
         R *= level_out;
diff --git a/mythtv/external/FFmpeg/libavfilter/af_superequalizer.c b/mythtv/external/FFmpeg/libavfilter/af_superequalizer.c
new file mode 100644
index 00000000000..f38cca5c8ba
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/af_superequalizer.c
@@ -0,0 +1,369 @@
+/*
+ * Copyright (c) 2002 Naoki Shibata
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/opt.h"
+
+#include "libavcodec/avfft.h"
+
+#include "audio.h"
+#include "avfilter.h"
+#include "internal.h"
+
+#define NBANDS 17
+#define M 15
+
+typedef struct EqParameter {
+    float lower, upper, gain;
+} EqParameter;
+
+typedef struct SuperEqualizerContext {
+    const AVClass *class;
+
+    EqParameter params[NBANDS + 1];
+
+    float gains[NBANDS + 1];
+
+    float fact[M + 1];
+    float aa;
+    float iza;
+    float *ires, *irest;
+    float *fsamples;
+    int winlen, tabsize;
+
+    AVFrame *in, *out;
+    RDFTContext *rdft, *irdft;
+} SuperEqualizerContext;
+
+static const float bands[] = {
+    65.406392, 92.498606, 130.81278, 184.99721, 261.62557, 369.99442, 523.25113, 739.9884, 1046.5023,
+    1479.9768, 2093.0045, 2959.9536, 4186.0091, 5919.9072, 8372.0181, 11839.814, 16744.036
+};
+
+static float izero(SuperEqualizerContext *s, float x)
+{
+    float ret = 1;
+    int m;
+
+    for (m = 1; m <= M; m++) {
+        float t;
+
+        t = pow(x / 2, m) / s->fact[m];
+        ret += t*t;
+    }
+
+    return ret;
+}
+
+static float hn_lpf(int n, float f, float fs)
+{
+    float t = 1 / fs;
+    float omega = 2 * M_PI * f;
+
+    if (n * omega * t == 0)
+        return 2 * f * t;
+    return 2 * f * t * sinf(n * omega * t) / (n * omega * t);
+}
+
+static float hn_imp(int n)
+{
+    return n == 0 ? 1.f : 0.f;
+}
+
+static float hn(int n, EqParameter *param, float fs)
+{
+    float ret, lhn;
+    int i;
+
+    lhn = hn_lpf(n, param[0].upper, fs);
+    ret = param[0].gain*lhn;
+
+    for (i = 1; i < NBANDS + 1 && param[i].upper < fs / 2; i++) {
+        float lhn2 = hn_lpf(n, param[i].upper, fs);
+        ret += param[i].gain * (lhn2 - lhn);
+        lhn = lhn2;
+    }
+
+    ret += param[i].gain * (hn_imp(n) - lhn);
+
+    return ret;
+}
+
+static float alpha(float a)
+{
+    if (a <= 21)
+        return 0;
+    if (a <= 50)
+        return .5842f * pow(a - 21, 0.4f) + 0.07886f * (a - 21);
+    return .1102f * (a - 8.7f);
+}
+
+static float win(SuperEqualizerContext *s, float n, int N)
+{
+    return izero(s, alpha(s->aa) * sqrtf(1 - 4 * n * n / ((N - 1) * (N - 1)))) / s->iza;
+}
+
+static void process_param(float *bc, EqParameter *param, float fs)
+{
+    int i;
+
+    for (i = 0; i <= NBANDS; i++) {
+        param[i].lower = i == 0 ? 0 : bands[i - 1];
+        param[i].upper = i == NBANDS ? fs : bands[i];
+        param[i].gain  = bc[i];
+    }
+}
+
+static int equ_init(SuperEqualizerContext *s, int wb)
+{
+    int i,j;
+
+    s->rdft  = av_rdft_init(wb, DFT_R2C);
+    s->irdft = av_rdft_init(wb, IDFT_C2R);
+    if (!s->rdft || !s->irdft)
+        return AVERROR(ENOMEM);
+
+    s->aa = 96;
+    s->winlen = (1 << (wb-1))-1;
+    s->tabsize  = 1 << wb;
+
+    s->ires     = av_calloc(s->tabsize, sizeof(float));
+    s->irest    = av_calloc(s->tabsize, sizeof(float));
+    s->fsamples = av_calloc(s->tabsize, sizeof(float));
+
+    for (i = 0; i <= M; i++) {
+        s->fact[i] = 1;
+        for (j = 1; j <= i; j++)
+            s->fact[i] *= j;
+    }
+
+    s->iza = izero(s, alpha(s->aa));
+
+    return 0;
+}
+
+static void make_fir(SuperEqualizerContext *s, float *lbc, float *rbc, EqParameter *param, float fs)
+{
+    const int winlen = s->winlen;
+    const int tabsize = s->tabsize;
+    float *nires;
+    int i;
+
+    if (fs <= 0)
+        return;
+
+    process_param(lbc, param, fs);
+    for (i = 0; i < winlen; i++)
+        s->irest[i] = hn(i - winlen / 2, param, fs) * win(s, i - winlen / 2, winlen);
+    for (; i < tabsize; i++)
+        s->irest[i] = 0;
+
+    av_rdft_calc(s->rdft, s->irest);
+    nires = s->ires;
+    for (i = 0; i < tabsize; i++)
+        nires[i] = s->irest[i];
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx = inlink->dst;
+    SuperEqualizerContext *s = ctx->priv;
+    AVFilterLink *outlink = ctx->outputs[0];
+    const float *ires = s->ires;
+    float *fsamples = s->fsamples;
+    int ch, i;
+
+    AVFrame *out = ff_get_audio_buffer(outlink, s->winlen);
+    float *src, *dst, *ptr;
+
+    if (!out) {
+        av_frame_free(&in);
+        return AVERROR(ENOMEM);
+    }
+
+    for (ch = 0; ch < in->channels; ch++) {
+        ptr = (float *)out->extended_data[ch];
+        dst = (float *)s->out->extended_data[ch];
+        src = (float *)in->extended_data[ch];
+
+        for (i = 0; i < s->winlen; i++)
+            fsamples[i] = src[i];
+        for (; i < s->tabsize; i++)
+            fsamples[i] = 0;
+
+        av_rdft_calc(s->rdft, fsamples);
+
+        fsamples[0] = ires[0] * fsamples[0];
+        fsamples[1] = ires[1] * fsamples[1];
+        for (i = 1; i < s->tabsize / 2; i++) {
+            float re, im;
+
+            re = ires[i*2  ] * fsamples[i*2] - ires[i*2+1] * fsamples[i*2+1];
+            im = ires[i*2+1] * fsamples[i*2] + ires[i*2  ] * fsamples[i*2+1];
+
+            fsamples[i*2  ] = re;
+            fsamples[i*2+1] = im;
+        }
+
+        av_rdft_calc(s->irdft, fsamples);
+
+        for (i = 0; i < s->winlen; i++)
+            dst[i] += fsamples[i] / s->tabsize * 2;
+        for (i = s->winlen; i < s->tabsize; i++)
+            dst[i]  = fsamples[i] / s->tabsize * 2;
+        for (i = 0; i < s->winlen; i++)
+            ptr[i] = dst[i];
+        for (i = 0; i < s->winlen; i++)
+            dst[i] = dst[i+s->winlen];
+    }
+
+    out->pts = in->pts;
+    av_frame_free(&in);
+
+    return ff_filter_frame(outlink, out);
+}
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    SuperEqualizerContext *s = ctx->priv;
+
+    return equ_init(s, 14);
+}
+
+static int query_formats(AVFilterContext *ctx)
+{
+    AVFilterFormats *formats;
+    AVFilterChannelLayouts *layouts;
+    static const enum AVSampleFormat sample_fmts[] = {
+        AV_SAMPLE_FMT_FLTP,
+        AV_SAMPLE_FMT_NONE
+    };
+    int ret;
+
+    layouts = ff_all_channel_counts();
+    if (!layouts)
+        return AVERROR(ENOMEM);
+    ret = ff_set_common_channel_layouts(ctx, layouts);
+    if (ret < 0)
+        return ret;
+
+    formats = ff_make_format_list(sample_fmts);
+    if ((ret = ff_set_common_formats(ctx, formats)) < 0)
+        return ret;
+
+    formats = ff_all_samplerates();
+    return ff_set_common_samplerates(ctx, formats);
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    SuperEqualizerContext *s = ctx->priv;
+
+    inlink->partial_buf_size =
+    inlink->min_samples =
+    inlink->max_samples = s->winlen;
+
+    s->out = ff_get_audio_buffer(inlink, s->tabsize);
+    if (!s->out)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+static int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    SuperEqualizerContext *s = ctx->priv;
+
+    make_fir(s, s->gains, s->gains, s->params, outlink->sample_rate);
+
+    return 0;
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    SuperEqualizerContext *s = ctx->priv;
+
+    av_frame_free(&s->out);
+    av_freep(&s->irest);
+    av_freep(&s->ires);
+    av_freep(&s->fsamples);
+    av_rdft_end(s->rdft);
+    av_rdft_end(s->irdft);
+}
+
+static const AVFilterPad superequalizer_inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_AUDIO,
+        .filter_frame = filter_frame,
+        .config_props = config_input,
+    },
+    { NULL }
+};
+
+static const AVFilterPad superequalizer_outputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_AUDIO,
+        .config_props = config_output,
+    },
+    { NULL }
+};
+
+#define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+#define OFFSET(x) offsetof(SuperEqualizerContext, x)
+
+static const AVOption superequalizer_options[] = {
+    {  "1b", "set 65Hz band gain",    OFFSET(gains [0]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    {  "2b", "set 92Hz band gain",    OFFSET(gains [1]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    {  "3b", "set 131Hz band gain",   OFFSET(gains [2]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    {  "4b", "set 185Hz band gain",   OFFSET(gains [3]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    {  "5b", "set 262Hz band gain",   OFFSET(gains [4]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    {  "6b", "set 370Hz band gain",   OFFSET(gains [5]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    {  "7b", "set 523Hz band gain",   OFFSET(gains [6]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    {  "8b", "set 740Hz band gain",   OFFSET(gains [7]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    {  "9b", "set 1047Hz band gain",  OFFSET(gains [8]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    { "10b", "set 1480Hz band gain",  OFFSET(gains [9]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    { "11b", "set 2093Hz band gain",  OFFSET(gains[10]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    { "12b", "set 2960Hz band gain",  OFFSET(gains[11]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    { "13b", "set 4186Hz band gain",  OFFSET(gains[12]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    { "14b", "set 5920Hz band gain",  OFFSET(gains[13]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    { "15b", "set 8372Hz band gain",  OFFSET(gains[14]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    { "16b", "set 11840Hz band gain", OFFSET(gains[15]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    { "17b", "set 16744Hz band gain", OFFSET(gains[16]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    { "18b", "set 20000Hz band gain", OFFSET(gains[17]), AV_OPT_TYPE_FLOAT, {.dbl=1}, 0, 20, AF },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(superequalizer);
+
+AVFilter ff_af_superequalizer = {
+    .name          = "superequalizer",
+    .description   = NULL_IF_CONFIG_SMALL("Apply 18 band equalization filter."),
+    .priv_size     = sizeof(SuperEqualizerContext),
+    .priv_class    = &superequalizer_class,
+    .query_formats = query_formats,
+    .init          = init,
+    .uninit        = uninit,
+    .inputs        = superequalizer_inputs,
+    .outputs       = superequalizer_outputs,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/af_surround.c b/mythtv/external/FFmpeg/libavfilter/af_surround.c
new file mode 100644
index 00000000000..c7122379d60
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/af_surround.c
@@ -0,0 +1,1264 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/audio_fifo.h"
+#include "libavutil/channel_layout.h"
+#include "libavutil/opt.h"
+#include "libavcodec/avfft.h"
+#include "avfilter.h"
+#include "audio.h"
+#include "formats.h"
+
+typedef struct AudioSurroundContext {
+    const AVClass *class;
+
+    char *out_channel_layout_str;
+    char *in_channel_layout_str;
+
+    float level_in;
+    float level_out;
+    float fc_in;
+    float fc_out;
+    float lfe_in;
+    float lfe_out;
+
+    float *input_levels;
+    float *output_levels;
+    int output_lfe;
+    int lowcutf;
+    int highcutf;
+
+    float lowcut;
+    float highcut;
+
+    uint64_t out_channel_layout;
+    uint64_t in_channel_layout;
+    int nb_in_channels;
+    int nb_out_channels;
+
+    AVFrame *input;
+    AVFrame *output;
+    AVFrame *overlap_buffer;
+
+    int buf_size;
+    int hop_size;
+    AVAudioFifo *fifo;
+    RDFTContext **rdft, **irdft;
+    float *window_func_lut;
+
+    int64_t pts;
+
+    void (*filter)(AVFilterContext *ctx);
+    void (*upmix_stereo)(AVFilterContext *ctx,
+                         float l_phase,
+                         float r_phase,
+                         float c_phase,
+                         float mag_total,
+                         float x, float y,
+                         int n);
+    void (*upmix_2_1)(AVFilterContext *ctx,
+                      float l_phase,
+                      float r_phase,
+                      float c_phase,
+                      float mag_total,
+                      float lfe_im,
+                      float lfe_re,
+                      float x, float y,
+                      int n);
+    void (*upmix_3_0)(AVFilterContext *ctx,
+                      float l_phase,
+                      float r_phase,
+                      float c_mag,
+                      float c_phase,
+                      float mag_total,
+                      float x, float y,
+                      int n);
+    void (*upmix_5_1)(AVFilterContext *ctx,
+                      float c_re, float c_im,
+                      float lfe_re, float lfe_im,
+                      float mag_totall, float mag_totalr,
+                      float fl_phase, float fr_phase,
+                      float bl_phase, float br_phase,
+                      float sl_phase, float sr_phase,
+                      float xl, float yl,
+                      float xr, float yr,
+                      int n);
+} AudioSurroundContext;
+
+static int query_formats(AVFilterContext *ctx)
+{
+    AudioSurroundContext *s = ctx->priv;
+    AVFilterFormats *formats = NULL;
+    AVFilterChannelLayouts *layouts = NULL;
+    int ret;
+
+    ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLTP);
+    if (ret)
+        return ret;
+    ret = ff_set_common_formats(ctx, formats);
+    if (ret)
+        return ret;
+
+    layouts = NULL;
+    ret = ff_add_channel_layout(&layouts, s->out_channel_layout);
+    if (ret)
+        return ret;
+
+    ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);
+    if (ret)
+        return ret;
+
+    layouts = NULL;
+    ret = ff_add_channel_layout(&layouts, s->in_channel_layout);
+    if (ret)
+        return ret;
+
+    ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts);
+    if (ret)
+        return ret;
+
+    formats = ff_all_samplerates();
+    if (!formats)
+        return AVERROR(ENOMEM);
+    return ff_set_common_samplerates(ctx, formats);
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    AudioSurroundContext *s = ctx->priv;
+    int ch;
+
+    s->rdft = av_calloc(inlink->channels, sizeof(*s->rdft));
+    if (!s->rdft)
+        return AVERROR(ENOMEM);
+
+    for (ch = 0; ch < inlink->channels; ch++) {
+        s->rdft[ch]  = av_rdft_init(ff_log2(s->buf_size), DFT_R2C);
+        if (!s->rdft[ch])
+            return AVERROR(ENOMEM);
+    }
+    s->nb_in_channels = inlink->channels;
+    s->input_levels = av_malloc_array(s->nb_in_channels, sizeof(*s->input_levels));
+    if (!s->input_levels)
+        return AVERROR(ENOMEM);
+    for (ch = 0;  ch < s->nb_in_channels; ch++)
+        s->input_levels[ch] = s->level_in;
+    ch = av_get_channel_layout_channel_index(inlink->channel_layout, AV_CH_FRONT_CENTER);
+    if (ch >= 0)
+        s->input_levels[ch] *= s->fc_in;
+    ch = av_get_channel_layout_channel_index(inlink->channel_layout, AV_CH_LOW_FREQUENCY);
+    if (ch >= 0)
+        s->input_levels[ch] *= s->lfe_in;
+
+    s->input = ff_get_audio_buffer(inlink, s->buf_size * 2);
+    if (!s->input)
+        return AVERROR(ENOMEM);
+
+    s->fifo = av_audio_fifo_alloc(inlink->format, inlink->channels, s->buf_size);
+    if (!s->fifo)
+        return AVERROR(ENOMEM);
+
+    s->lowcut = 1.f * s->lowcutf / (inlink->sample_rate * 0.5) * (s->buf_size / 2);
+    s->highcut = 1.f * s->highcutf / (inlink->sample_rate * 0.5) * (s->buf_size / 2);
+
+    return 0;
+}
+
+static int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    AudioSurroundContext *s = ctx->priv;
+    int ch;
+
+    s->irdft = av_calloc(outlink->channels, sizeof(*s->irdft));
+    if (!s->irdft)
+        return AVERROR(ENOMEM);
+
+    for (ch = 0; ch < outlink->channels; ch++) {
+        s->irdft[ch] = av_rdft_init(ff_log2(s->buf_size), IDFT_C2R);
+        if (!s->irdft[ch])
+            return AVERROR(ENOMEM);
+    }
+    s->nb_out_channels = outlink->channels;
+    s->output_levels = av_malloc_array(s->nb_out_channels, sizeof(*s->output_levels));
+    if (!s->output_levels)
+        return AVERROR(ENOMEM);
+    for (ch = 0;  ch < s->nb_out_channels; ch++)
+        s->output_levels[ch] = s->level_out;
+    ch = av_get_channel_layout_channel_index(outlink->channel_layout, AV_CH_FRONT_CENTER);
+    if (ch >= 0)
+        s->output_levels[ch] *= s->fc_out;
+    ch = av_get_channel_layout_channel_index(outlink->channel_layout, AV_CH_LOW_FREQUENCY);
+    if (ch >= 0)
+        s->output_levels[ch] *= s->lfe_out;
+
+    s->output = ff_get_audio_buffer(outlink, s->buf_size * 2);
+    s->overlap_buffer = ff_get_audio_buffer(outlink, s->buf_size * 2);
+    if (!s->overlap_buffer || !s->output)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+static void stereo_position(float a, float p, float *x, float *y)
+{
+      *x = av_clipf(a+FFMAX(0, sinf(p-M_PI_2))*FFDIFFSIGN(a,0), -1, 1);
+      *y = av_clipf(cosf(a*M_PI_2+M_PI)*cosf(M_PI_2-p/M_PI)*M_LN10+1, -1, 1);
+}
+
+static inline void get_lfe(int output_lfe, int n, float lowcut, float highcut,
+                           float *lfe_mag, float *mag_total)
+{
+    if (output_lfe && n < highcut) {
+        *lfe_mag    = n < lowcut ? 1.f : .5f*(1.f+cosf(M_PI*(lowcut-n)/(lowcut-highcut)));
+        *lfe_mag   *= *mag_total;
+        *mag_total -= *lfe_mag;
+    } else {
+        *lfe_mag = 0.f;
+    }
+}
+
+static void upmix_1_0(AVFilterContext *ctx,
+                      float l_phase,
+                      float r_phase,
+                      float c_phase,
+                      float mag_total,
+                      float x, float y,
+                      int n)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float mag, *dst;
+
+    dst = (float *)s->output->extended_data[0];
+
+    mag = sqrtf(1.f - fabsf(x)) * ((y + 1.f) * .5f) * mag_total;
+
+    dst[2 * n    ] = mag * cosf(c_phase);
+    dst[2 * n + 1] = mag * sinf(c_phase);
+}
+
+static void upmix_stereo(AVFilterContext *ctx,
+                         float l_phase,
+                         float r_phase,
+                         float c_phase,
+                         float mag_total,
+                         float x, float y,
+                         int n)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float l_mag, r_mag, *dstl, *dstr;
+
+    dstl = (float *)s->output->extended_data[0];
+    dstr = (float *)s->output->extended_data[1];
+
+    l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+}
+
+static void upmix_2_1(AVFilterContext *ctx,
+                      float l_phase,
+                      float r_phase,
+                      float c_phase,
+                      float mag_total,
+                      float x, float y,
+                      int n)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float lfe_mag, l_mag, r_mag, *dstl, *dstr, *dstlfe;
+
+    dstl = (float *)s->output->extended_data[0];
+    dstr = (float *)s->output->extended_data[1];
+    dstlfe = (float *)s->output->extended_data[2];
+
+    get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);
+
+    l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
+    dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
+}
+
+static void upmix_3_0(AVFilterContext *ctx,
+                      float l_phase,
+                      float r_phase,
+                      float c_phase,
+                      float mag_total,
+                      float x, float y,
+                      int n)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float l_mag, r_mag, c_mag, *dstc, *dstl, *dstr;
+
+    dstl = (float *)s->output->extended_data[0];
+    dstr = (float *)s->output->extended_data[1];
+    dstc = (float *)s->output->extended_data[2];
+
+    c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
+    l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstc[2 * n    ] = c_mag * cosf(c_phase);
+    dstc[2 * n + 1] = c_mag * sinf(c_phase);
+}
+
+static void upmix_3_1(AVFilterContext *ctx,
+                      float l_phase,
+                      float r_phase,
+                      float c_phase,
+                      float mag_total,
+                      float x, float y,
+                      int n)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float lfe_mag, l_mag, r_mag, c_mag, *dstc, *dstl, *dstr, *dstlfe;
+
+    dstl = (float *)s->output->extended_data[0];
+    dstr = (float *)s->output->extended_data[1];
+    dstc = (float *)s->output->extended_data[2];
+    dstlfe = (float *)s->output->extended_data[3];
+
+    get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);
+
+    c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
+    l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstc[2 * n    ] = c_mag * cosf(c_phase);
+    dstc[2 * n + 1] = c_mag * sinf(c_phase);
+
+    dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
+    dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
+}
+
+static void upmix_3_1_surround(AVFilterContext *ctx,
+                               float l_phase,
+                               float r_phase,
+                               float c_phase,
+                               float c_mag,
+                               float mag_total,
+                               float x, float y,
+                               int n)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float lfe_mag, l_mag, r_mag, *dstc, *dstl, *dstr, *dstlfe;
+
+    dstl = (float *)s->output->extended_data[0];
+    dstr = (float *)s->output->extended_data[1];
+    dstc = (float *)s->output->extended_data[2];
+    dstlfe = (float *)s->output->extended_data[3];
+
+    get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &c_mag);
+
+    l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstc[2 * n    ] = c_mag * cosf(c_phase);
+    dstc[2 * n + 1] = c_mag * sinf(c_phase);
+
+    dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
+    dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
+}
+
+static void upmix_4_0(AVFilterContext *ctx,
+                      float l_phase,
+                      float r_phase,
+                      float c_phase,
+                      float mag_total,
+                      float x, float y,
+                      int n)
+{
+    float b_mag, l_mag, r_mag, c_mag, *dstc, *dstl, *dstr, *dstb;
+    AudioSurroundContext *s = ctx->priv;
+
+    dstl = (float *)s->output->extended_data[0];
+    dstr = (float *)s->output->extended_data[1];
+    dstc = (float *)s->output->extended_data[2];
+    dstb = (float *)s->output->extended_data[3];
+
+    c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
+    b_mag = sqrtf(1.f - fabsf(x))   * ((1.f - y) * .5f) * mag_total;
+    l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstc[2 * n    ] = c_mag * cosf(c_phase);
+    dstc[2 * n + 1] = c_mag * sinf(c_phase);
+
+    dstb[2 * n    ] = b_mag * cosf(c_phase);
+    dstb[2 * n + 1] = b_mag * sinf(c_phase);
+}
+
+static void upmix_4_1(AVFilterContext *ctx,
+                      float l_phase,
+                      float r_phase,
+                      float c_phase,
+                      float mag_total,
+                      float x, float y,
+                      int n)
+{
+    float lfe_mag, b_mag, l_mag, r_mag, c_mag, *dstc, *dstl, *dstr, *dstb, *dstlfe;
+    AudioSurroundContext *s = ctx->priv;
+
+    dstl = (float *)s->output->extended_data[0];
+    dstr = (float *)s->output->extended_data[1];
+    dstc = (float *)s->output->extended_data[2];
+    dstlfe = (float *)s->output->extended_data[3];
+    dstb = (float *)s->output->extended_data[4];
+
+    get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);
+
+    dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
+    dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
+
+    c_mag = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
+    b_mag = sqrtf(1.f - fabsf(x))   * ((1.f - y) * .5f) * mag_total;
+    l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstc[2 * n    ] = c_mag * cosf(c_phase);
+    dstc[2 * n + 1] = c_mag * sinf(c_phase);
+
+    dstb[2 * n    ] = b_mag * cosf(c_phase);
+    dstb[2 * n + 1] = b_mag * sinf(c_phase);
+}
+
+static void upmix_5_0_back(AVFilterContext *ctx,
+                           float l_phase,
+                           float r_phase,
+                           float c_phase,
+                           float mag_total,
+                           float x, float y,
+                           int n)
+{
+    float l_mag, r_mag, ls_mag, rs_mag, c_mag, *dstc, *dstl, *dstr, *dstls, *dstrs;
+    AudioSurroundContext *s = ctx->priv;
+
+    dstl  = (float *)s->output->extended_data[0];
+    dstr  = (float *)s->output->extended_data[1];
+    dstc  = (float *)s->output->extended_data[2];
+    dstls = (float *)s->output->extended_data[3];
+    dstrs = (float *)s->output->extended_data[4];
+
+    c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
+    l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+    rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstc[2 * n    ] = c_mag * cosf(c_phase);
+    dstc[2 * n + 1] = c_mag * sinf(c_phase);
+
+    dstls[2 * n    ] = ls_mag * cosf(l_phase);
+    dstls[2 * n + 1] = ls_mag * sinf(l_phase);
+
+    dstrs[2 * n    ] = rs_mag * cosf(r_phase);
+    dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
+}
+
+static void upmix_5_1_back(AVFilterContext *ctx,
+                           float l_phase,
+                           float r_phase,
+                           float c_phase,
+                           float mag_total,
+                           float x, float y,
+                           int n)
+{
+    float lfe_mag, l_mag, r_mag, ls_mag, rs_mag, c_mag, *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlfe;
+    AudioSurroundContext *s = ctx->priv;
+
+    dstl  = (float *)s->output->extended_data[0];
+    dstr  = (float *)s->output->extended_data[1];
+    dstc  = (float *)s->output->extended_data[2];
+    dstlfe = (float *)s->output->extended_data[3];
+    dstls = (float *)s->output->extended_data[4];
+    dstrs = (float *)s->output->extended_data[5];
+
+    get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);
+
+    c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
+    l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+    rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstc[2 * n    ] = c_mag * cosf(c_phase);
+    dstc[2 * n + 1] = c_mag * sinf(c_phase);
+
+    dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
+    dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
+
+    dstls[2 * n    ] = ls_mag * cosf(l_phase);
+    dstls[2 * n + 1] = ls_mag * sinf(l_phase);
+
+    dstrs[2 * n    ] = rs_mag * cosf(r_phase);
+    dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
+}
+
+static void upmix_5_1_back_surround(AVFilterContext *ctx,
+                                    float l_phase,
+                                    float r_phase,
+                                    float c_phase,
+                                    float c_mag,
+                                    float mag_total,
+                                    float x, float y,
+                                    int n)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float lfe_mag, l_mag, r_mag, *dstc, *dstl, *dstr, *dstlfe;
+    float ls_mag, rs_mag, *dstls, *dstrs;
+
+    dstl = (float *)s->output->extended_data[0];
+    dstr = (float *)s->output->extended_data[1];
+    dstc = (float *)s->output->extended_data[2];
+    dstlfe = (float *)s->output->extended_data[3];
+    dstls = (float *)s->output->extended_data[4];
+    dstrs = (float *)s->output->extended_data[5];
+
+    get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &c_mag);
+
+    l_mag = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+    rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstc[2 * n    ] = c_mag * cosf(c_phase);
+    dstc[2 * n + 1] = c_mag * sinf(c_phase);
+
+    dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
+    dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
+
+    dstls[2 * n    ] = ls_mag * cosf(l_phase);
+    dstls[2 * n + 1] = ls_mag * sinf(l_phase);
+
+    dstrs[2 * n    ] = rs_mag * cosf(r_phase);
+    dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
+}
+
+static void upmix_5_1_back_2_1(AVFilterContext *ctx,
+                               float l_phase,
+                               float r_phase,
+                               float c_phase,
+                               float mag_total,
+                               float lfe_re,
+                               float lfe_im,
+                               float x, float y,
+                               int n)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float c_mag, l_mag, r_mag, *dstc, *dstl, *dstr, *dstlfe;
+    float ls_mag, rs_mag, *dstls, *dstrs;
+
+    dstl = (float *)s->output->extended_data[0];
+    dstr = (float *)s->output->extended_data[1];
+    dstc = (float *)s->output->extended_data[2];
+    dstlfe = (float *)s->output->extended_data[3];
+    dstls = (float *)s->output->extended_data[4];
+    dstrs = (float *)s->output->extended_data[5];
+
+    c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
+    l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+    rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstc[2 * n    ] = c_mag * cosf(c_phase);
+    dstc[2 * n + 1] = c_mag * sinf(c_phase);
+
+    dstlfe[2 * n    ] = lfe_re;
+    dstlfe[2 * n + 1] = lfe_im;
+
+    dstls[2 * n    ] = ls_mag * cosf(l_phase);
+    dstls[2 * n + 1] = ls_mag * sinf(l_phase);
+
+    dstrs[2 * n    ] = rs_mag * cosf(r_phase);
+    dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
+}
+
+static void upmix_7_0(AVFilterContext *ctx,
+                      float l_phase,
+                      float r_phase,
+                      float c_phase,
+                      float mag_total,
+                      float x, float y,
+                      int n)
+{
+    float l_mag, r_mag, ls_mag, rs_mag, c_mag, lb_mag, rb_mag;
+    float *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlb, *dstrb;
+    AudioSurroundContext *s = ctx->priv;
+
+    dstl  = (float *)s->output->extended_data[0];
+    dstr  = (float *)s->output->extended_data[1];
+    dstc  = (float *)s->output->extended_data[2];
+    dstlb = (float *)s->output->extended_data[3];
+    dstrb = (float *)s->output->extended_data[4];
+    dstls = (float *)s->output->extended_data[5];
+    dstrs = (float *)s->output->extended_data[6];
+
+    c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
+    l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    lb_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+    rb_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+    ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - fabsf(y)) * mag_total;
+    rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - fabsf(y)) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstc[2 * n    ] = c_mag * cosf(c_phase);
+    dstc[2 * n + 1] = c_mag * sinf(c_phase);
+
+    dstlb[2 * n    ] = lb_mag * cosf(l_phase);
+    dstlb[2 * n + 1] = lb_mag * sinf(l_phase);
+
+    dstrb[2 * n    ] = rb_mag * cosf(r_phase);
+    dstrb[2 * n + 1] = rb_mag * sinf(r_phase);
+
+    dstls[2 * n    ] = ls_mag * cosf(l_phase);
+    dstls[2 * n + 1] = ls_mag * sinf(l_phase);
+
+    dstrs[2 * n    ] = rs_mag * cosf(r_phase);
+    dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
+}
+
+static void upmix_7_1(AVFilterContext *ctx,
+                      float l_phase,
+                      float r_phase,
+                      float c_phase,
+                      float mag_total,
+                      float x, float y,
+                      int n)
+{
+    float lfe_mag, l_mag, r_mag, ls_mag, rs_mag, c_mag, lb_mag, rb_mag;
+    float *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlb, *dstrb, *dstlfe;
+    AudioSurroundContext *s = ctx->priv;
+
+    dstl  = (float *)s->output->extended_data[0];
+    dstr  = (float *)s->output->extended_data[1];
+    dstc  = (float *)s->output->extended_data[2];
+    dstlfe = (float *)s->output->extended_data[3];
+    dstlb = (float *)s->output->extended_data[4];
+    dstrb = (float *)s->output->extended_data[5];
+    dstls = (float *)s->output->extended_data[6];
+    dstrs = (float *)s->output->extended_data[7];
+
+    get_lfe(s->output_lfe, n, s->lowcut, s->highcut, &lfe_mag, &mag_total);
+
+    c_mag  = sqrtf(1.f - fabsf(x))   * ((y + 1.f) * .5f) * mag_total;
+    l_mag  = sqrtf(.5f * ( x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    r_mag  = sqrtf(.5f * (-x + 1.f)) * ((y + 1.f) * .5f) * mag_total;
+    lb_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+    rb_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - ((y + 1.f) * .5f)) * mag_total;
+    ls_mag = sqrtf(.5f * ( x + 1.f)) * (1.f - fabsf(y)) * mag_total;
+    rs_mag = sqrtf(.5f * (-x + 1.f)) * (1.f - fabsf(y)) * mag_total;
+
+    dstl[2 * n    ] = l_mag * cosf(l_phase);
+    dstl[2 * n + 1] = l_mag * sinf(l_phase);
+
+    dstr[2 * n    ] = r_mag * cosf(r_phase);
+    dstr[2 * n + 1] = r_mag * sinf(r_phase);
+
+    dstc[2 * n    ] = c_mag * cosf(c_phase);
+    dstc[2 * n + 1] = c_mag * sinf(c_phase);
+
+    dstlfe[2 * n    ] = lfe_mag * cosf(c_phase);
+    dstlfe[2 * n + 1] = lfe_mag * sinf(c_phase);
+
+    dstlb[2 * n    ] = lb_mag * cosf(l_phase);
+    dstlb[2 * n + 1] = lb_mag * sinf(l_phase);
+
+    dstrb[2 * n    ] = rb_mag * cosf(r_phase);
+    dstrb[2 * n + 1] = rb_mag * sinf(r_phase);
+
+    dstls[2 * n    ] = ls_mag * cosf(l_phase);
+    dstls[2 * n + 1] = ls_mag * sinf(l_phase);
+
+    dstrs[2 * n    ] = rs_mag * cosf(r_phase);
+    dstrs[2 * n + 1] = rs_mag * sinf(r_phase);
+}
+
+static void upmix_7_1_5_1(AVFilterContext *ctx,
+                          float c_re, float c_im,
+                          float lfe_re, float lfe_im,
+                          float mag_totall, float mag_totalr,
+                          float fl_phase, float fr_phase,
+                          float bl_phase, float br_phase,
+                          float sl_phase, float sr_phase,
+                          float xl, float yl,
+                          float xr, float yr,
+                          int n)
+{
+    float fl_mag, fr_mag, ls_mag, rs_mag, lb_mag, rb_mag;
+    float *dstc, *dstl, *dstr, *dstls, *dstrs, *dstlb, *dstrb, *dstlfe;
+    AudioSurroundContext *s = ctx->priv;
+
+    dstl  = (float *)s->output->extended_data[0];
+    dstr  = (float *)s->output->extended_data[1];
+    dstc  = (float *)s->output->extended_data[2];
+    dstlfe = (float *)s->output->extended_data[3];
+    dstlb = (float *)s->output->extended_data[4];
+    dstrb = (float *)s->output->extended_data[5];
+    dstls = (float *)s->output->extended_data[6];
+    dstrs = (float *)s->output->extended_data[7];
+
+    fl_mag = sqrtf(.5f * (xl + 1.f)) * ((yl + 1.f) * .5f) * mag_totall;
+    fr_mag = sqrtf(.5f * (xr + 1.f)) * ((yr + 1.f) * .5f) * mag_totalr;
+    lb_mag = sqrtf(.5f * (-xl + 1.f)) * ((yl + 1.f) * .5f) * mag_totall;
+    rb_mag = sqrtf(.5f * (-xr + 1.f)) * ((yr + 1.f) * .5f) * mag_totalr;
+    ls_mag = sqrtf(1.f - fabsf(xl)) * ((yl + 1.f) * .5f) * mag_totall;
+    rs_mag = sqrtf(1.f - fabsf(xr)) * ((yr + 1.f) * .5f) * mag_totalr;
+
+    dstl[2 * n    ] = fl_mag * cosf(fl_phase);
+    dstl[2 * n + 1] = fl_mag * sinf(fl_phase);
+
+    dstr[2 * n    ] = fr_mag * cosf(fr_phase);
+    dstr[2 * n + 1] = fr_mag * sinf(fr_phase);
+
+    dstc[2 * n    ] = c_re;
+    dstc[2 * n + 1] = c_im;
+
+    dstlfe[2 * n    ] = lfe_re;
+    dstlfe[2 * n + 1] = lfe_im;
+
+    dstlb[2 * n    ] = lb_mag * cosf(bl_phase);
+    dstlb[2 * n + 1] = lb_mag * sinf(bl_phase);
+
+    dstrb[2 * n    ] = rb_mag * cosf(br_phase);
+    dstrb[2 * n + 1] = rb_mag * sinf(br_phase);
+
+    dstls[2 * n    ] = ls_mag * cosf(sl_phase);
+    dstls[2 * n + 1] = ls_mag * sinf(sl_phase);
+
+    dstrs[2 * n    ] = rs_mag * cosf(sr_phase);
+    dstrs[2 * n + 1] = rs_mag * sinf(sr_phase);
+}
+
+static void filter_stereo(AVFilterContext *ctx)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float *srcl, *srcr;
+    int n;
+
+    srcl = (float *)s->input->extended_data[0];
+    srcr = (float *)s->input->extended_data[1];
+
+    for (n = 0; n < s->buf_size; n++) {
+        float l_re = srcl[2 * n], r_re = srcr[2 * n];
+        float l_im = srcl[2 * n + 1], r_im = srcr[2 * n + 1];
+        float c_phase = atan2f(l_im + r_im, l_re + r_re);
+        float l_mag = hypotf(l_re, l_im);
+        float r_mag = hypotf(r_re, r_im);
+        float l_phase = atan2f(l_im, l_re);
+        float r_phase = atan2f(r_im, r_re);
+        float phase_dif = fabsf(l_phase - r_phase);
+        float mag_dif = (l_mag - r_mag) / (l_mag + r_mag);
+        float mag_total = hypotf(l_mag, r_mag);
+        float x, y;
+
+        if (phase_dif > M_PI)
+            phase_dif = 2 * M_PI - phase_dif;
+
+        stereo_position(mag_dif, phase_dif, &x, &y);
+
+        s->upmix_stereo(ctx, l_phase, r_phase, c_phase, mag_total, x, y, n);
+    }
+}
+
+static void filter_surround(AVFilterContext *ctx)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float *srcl, *srcr, *srcc;
+    int n;
+
+    srcl = (float *)s->input->extended_data[0];
+    srcr = (float *)s->input->extended_data[1];
+    srcc = (float *)s->input->extended_data[2];
+
+    for (n = 0; n < s->buf_size; n++) {
+        float l_re = srcl[2 * n], r_re = srcr[2 * n];
+        float l_im = srcl[2 * n + 1], r_im = srcr[2 * n + 1];
+        float c_re = srcc[2 * n], c_im = srcc[2 * n + 1];
+        float c_mag = hypotf(c_re, c_im);
+        float c_phase = atan2f(c_im, c_re);
+        float l_mag = hypotf(l_re, l_im);
+        float r_mag = hypotf(r_re, r_im);
+        float l_phase = atan2f(l_im, l_re);
+        float r_phase = atan2f(r_im, r_re);
+        float phase_dif = fabsf(l_phase - r_phase);
+        float mag_dif = (l_mag - r_mag) / (l_mag + r_mag);
+        float mag_total = hypotf(l_mag, r_mag);
+        float x, y;
+
+        if (phase_dif > M_PI)
+            phase_dif = 2 * M_PI - phase_dif;
+
+        stereo_position(mag_dif, phase_dif, &x, &y);
+
+        s->upmix_3_0(ctx, l_phase, r_phase, c_phase, c_mag, mag_total, x, y, n);
+    }
+}
+
+static void filter_2_1(AVFilterContext *ctx)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float *srcl, *srcr, *srclfe;
+    int n;
+
+    srcl = (float *)s->input->extended_data[0];
+    srcr = (float *)s->input->extended_data[1];
+    srclfe = (float *)s->input->extended_data[2];
+
+    for (n = 0; n < s->buf_size; n++) {
+        float l_re = srcl[2 * n], r_re = srcr[2 * n];
+        float l_im = srcl[2 * n + 1], r_im = srcr[2 * n + 1];
+        float lfe_re = srclfe[2 * n], lfe_im = srclfe[2 * n + 1];
+        float c_phase = atan2f(l_im + r_im, l_re + r_re);
+        float l_mag = hypotf(l_re, l_im);
+        float r_mag = hypotf(r_re, r_im);
+        float l_phase = atan2f(l_im, l_re);
+        float r_phase = atan2f(r_im, r_re);
+        float phase_dif = fabsf(l_phase - r_phase);
+        float mag_dif = (l_mag - r_mag) / (l_mag + r_mag);
+        float mag_total = hypotf(l_mag, r_mag);
+        float x, y;
+
+        if (phase_dif > M_PI)
+            phase_dif = 2 * M_PI - phase_dif;
+
+        stereo_position(mag_dif, phase_dif, &x, &y);
+
+        s->upmix_2_1(ctx, l_phase, r_phase, c_phase, mag_total, lfe_re, lfe_im, x, y, n);
+    }
+}
+
+static void filter_5_1_back(AVFilterContext *ctx)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float *srcl, *srcr, *srcc, *srclfe, *srcbl, *srcbr;
+    int n;
+
+    srcl = (float *)s->input->extended_data[0];
+    srcr = (float *)s->input->extended_data[1];
+    srcc = (float *)s->input->extended_data[2];
+    srclfe = (float *)s->input->extended_data[3];
+    srcbl = (float *)s->input->extended_data[4];
+    srcbr = (float *)s->input->extended_data[5];
+
+    for (n = 0; n < s->buf_size; n++) {
+        float fl_re = srcl[2 * n], fr_re = srcr[2 * n];
+        float fl_im = srcl[2 * n + 1], fr_im = srcr[2 * n + 1];
+        float c_re = srcc[2 * n], c_im = srcc[2 * n + 1];
+        float lfe_re = srclfe[2 * n], lfe_im = srclfe[2 * n + 1];
+        float bl_re = srcbl[2 * n], bl_im = srcbl[2 * n + 1];
+        float br_re = srcbr[2 * n], br_im = srcbr[2 * n + 1];
+        float fl_mag = hypotf(fl_re, fl_im);
+        float fr_mag = hypotf(fr_re, fr_im);
+        float fl_phase = atan2f(fl_im, fl_re);
+        float fr_phase = atan2f(fr_im, fr_re);
+        float bl_mag = hypotf(bl_re, bl_im);
+        float br_mag = hypotf(br_re, br_im);
+        float bl_phase = atan2f(bl_im, bl_re);
+        float br_phase = atan2f(br_im, br_re);
+        float phase_difl = fabsf(fl_phase - bl_phase);
+        float phase_difr = fabsf(fr_phase - br_phase);
+        float mag_difl = (fl_mag - bl_mag) / (fl_mag + bl_mag);
+        float mag_difr = (fr_mag - br_mag) / (fr_mag + br_mag);
+        float mag_totall = hypotf(fl_mag, bl_mag);
+        float mag_totalr = hypotf(fr_mag, br_mag);
+        float sl_phase = atan2f(fl_im + bl_im, fl_re + bl_re);
+        float sr_phase = atan2f(fr_im + br_im, fr_re + br_re);
+        float xl, yl;
+        float xr, yr;
+
+        if (phase_difl > M_PI)
+            phase_difl = 2 * M_PI - phase_difl;
+
+        if (phase_difr > M_PI)
+            phase_difr = 2 * M_PI - phase_difr;
+
+        stereo_position(mag_difl, phase_difl, &xl, &yl);
+        stereo_position(mag_difr, phase_difr, &xr, &yr);
+
+        s->upmix_5_1(ctx, c_re, c_im, lfe_re, lfe_im,
+                     mag_totall, mag_totalr,
+                     fl_phase, fr_phase,
+                     bl_phase, br_phase,
+                     sl_phase, sr_phase,
+                     xl, yl, xr, yr, n);
+    }
+}
+
+static int init(AVFilterContext *ctx)
+{
+    AudioSurroundContext *s = ctx->priv;
+    float overlap;
+    int i;
+
+    if (!(s->out_channel_layout = av_get_channel_layout(s->out_channel_layout_str))) {
+        av_log(ctx, AV_LOG_ERROR, "Error parsing output channel layout '%s'.\n",
+               s->out_channel_layout_str);
+        return AVERROR(EINVAL);
+    }
+
+    if (!(s->in_channel_layout = av_get_channel_layout(s->in_channel_layout_str))) {
+        av_log(ctx, AV_LOG_ERROR, "Error parsing input channel layout '%s'.\n",
+               s->in_channel_layout_str);
+        return AVERROR(EINVAL);
+    }
+
+    if (s->lowcutf >= s->highcutf) {
+        av_log(ctx, AV_LOG_ERROR, "Low cut-off '%d' should be less than high cut-off '%d'.\n",
+               s->lowcutf, s->highcutf);
+        return AVERROR(EINVAL);
+    }
+
+    switch (s->in_channel_layout) {
+    case AV_CH_LAYOUT_STEREO:
+        s->filter = filter_stereo;
+        switch (s->out_channel_layout) {
+        case AV_CH_LAYOUT_MONO:
+            s->upmix_stereo = upmix_1_0;
+            break;
+        case AV_CH_LAYOUT_STEREO:
+            s->upmix_stereo = upmix_stereo;
+            break;
+        case AV_CH_LAYOUT_2POINT1:
+            s->upmix_stereo = upmix_2_1;
+            break;
+        case AV_CH_LAYOUT_SURROUND:
+            s->upmix_stereo = upmix_3_0;
+            break;
+        case AV_CH_LAYOUT_3POINT1:
+            s->upmix_stereo = upmix_3_1;
+            break;
+        case AV_CH_LAYOUT_4POINT0:
+            s->upmix_stereo = upmix_4_0;
+            break;
+        case AV_CH_LAYOUT_4POINT1:
+            s->upmix_stereo = upmix_4_1;
+            break;
+        case AV_CH_LAYOUT_5POINT0_BACK:
+            s->upmix_stereo = upmix_5_0_back;
+            break;
+        case AV_CH_LAYOUT_5POINT1_BACK:
+            s->upmix_stereo = upmix_5_1_back;
+            break;
+        case AV_CH_LAYOUT_7POINT0:
+            s->upmix_stereo = upmix_7_0;
+            break;
+        case AV_CH_LAYOUT_7POINT1:
+            s->upmix_stereo = upmix_7_1;
+            break;
+        default:
+            goto fail;
+        }
+        break;
+    case AV_CH_LAYOUT_2POINT1:
+        s->filter = filter_2_1;
+        switch (s->out_channel_layout) {
+        case AV_CH_LAYOUT_5POINT1_BACK:
+            s->upmix_2_1 = upmix_5_1_back_2_1;
+            break;
+        default:
+            goto fail;
+        }
+        break;
+    case AV_CH_LAYOUT_SURROUND:
+        s->filter = filter_surround;
+        switch (s->out_channel_layout) {
+        case AV_CH_LAYOUT_3POINT1:
+            s->upmix_3_0 = upmix_3_1_surround;
+            break;
+        case AV_CH_LAYOUT_5POINT1_BACK:
+            s->upmix_3_0 = upmix_5_1_back_surround;
+            break;
+        default:
+            goto fail;
+        }
+        break;
+    case AV_CH_LAYOUT_5POINT1_BACK:
+        s->filter = filter_5_1_back;
+        switch (s->out_channel_layout) {
+        case AV_CH_LAYOUT_7POINT1:
+            s->upmix_5_1 = upmix_7_1_5_1;
+            break;
+        default:
+            goto fail;
+        }
+        break;
+    default:
+fail:
+        av_log(ctx, AV_LOG_ERROR, "Unsupported upmix: '%s' -> '%s'.\n",
+               s->in_channel_layout_str, s->out_channel_layout_str);
+        return AVERROR(EINVAL);
+    }
+
+    s->buf_size = 4096;
+    s->pts = AV_NOPTS_VALUE;
+
+    s->window_func_lut = av_calloc(s->buf_size, sizeof(*s->window_func_lut));
+    if (!s->window_func_lut)
+        return AVERROR(ENOMEM);
+
+    for (i = 0; i < s->buf_size; i++)
+        s->window_func_lut[i] = sqrtf(0.5 * (1 - cosf(2 * M_PI * i / s->buf_size)) / s->buf_size);
+    overlap = .5;
+    s->hop_size = s->buf_size * (1. - overlap);
+
+    return 0;
+}
+
+static int fft_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)
+{
+    AudioSurroundContext *s = ctx->priv;
+    const float level_in = s->input_levels[ch];
+    float *dst;
+    int n;
+
+    memset(s->input->extended_data[ch] + s->buf_size * sizeof(float), 0, s->buf_size * sizeof(float));
+
+    dst = (float *)s->input->extended_data[ch];
+    for (n = 0; n < s->buf_size; n++) {
+        dst[n] *= s->window_func_lut[n] * level_in;
+    }
+
+    av_rdft_calc(s->rdft[ch], (float *)s->input->extended_data[ch]);
+
+    return 0;
+}
+
+static int ifft_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)
+{
+    AudioSurroundContext *s = ctx->priv;
+    const float level_out = s->output_levels[ch];
+    AVFrame *out = arg;
+    float *dst, *ptr;
+    int n;
+
+    av_rdft_calc(s->irdft[ch], (float *)s->output->extended_data[ch]);
+
+    dst = (float *)s->output->extended_data[ch];
+    ptr = (float *)s->overlap_buffer->extended_data[ch];
+
+    memmove(s->overlap_buffer->extended_data[ch],
+            s->overlap_buffer->extended_data[ch] + s->hop_size * sizeof(float),
+            s->buf_size * sizeof(float));
+    memset(s->overlap_buffer->extended_data[ch] + s->buf_size * sizeof(float),
+           0, s->hop_size * sizeof(float));
+
+    for (n = 0; n < s->buf_size; n++) {
+        ptr[n] += dst[n] * s->window_func_lut[n] * level_out;
+    }
+
+    ptr = (float *)s->overlap_buffer->extended_data[ch];
+    dst = (float *)out->extended_data[ch];
+    memcpy(dst, ptr, s->hop_size * sizeof(float));
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx = inlink->dst;
+    AVFilterLink *outlink = ctx->outputs[0];
+    AudioSurroundContext *s = ctx->priv;
+
+    av_audio_fifo_write(s->fifo, (void **)in->extended_data,
+                        in->nb_samples);
+
+    if (s->pts == AV_NOPTS_VALUE)
+        s->pts = in->pts;
+
+    av_frame_free(&in);
+
+    while (av_audio_fifo_size(s->fifo) >= s->buf_size) {
+        AVFrame *out;
+        int ret;
+
+        ret = av_audio_fifo_peek(s->fifo, (void **)s->input->extended_data, s->buf_size);
+        if (ret < 0)
+            return ret;
+
+        ctx->internal->execute(ctx, fft_channel, NULL, NULL, inlink->channels);
+
+        s->filter(ctx);
+
+        out = ff_get_audio_buffer(outlink, s->hop_size);
+        if (!out)
+            return AVERROR(ENOMEM);
+
+        ctx->internal->execute(ctx, ifft_channel, out, NULL, outlink->channels);
+
+        out->pts = s->pts;
+        if (s->pts != AV_NOPTS_VALUE)
+            s->pts += av_rescale_q(out->nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
+        av_audio_fifo_drain(s->fifo, s->hop_size);
+        ret = ff_filter_frame(outlink, out);
+        if (ret < 0)
+            return ret;
+    }
+
+    return 0;
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    AudioSurroundContext *s = ctx->priv;
+    int ch;
+
+    av_frame_free(&s->input);
+    av_frame_free(&s->output);
+    av_frame_free(&s->overlap_buffer);
+
+    for (ch = 0; ch < s->nb_in_channels; ch++) {
+        av_rdft_end(s->rdft[ch]);
+    }
+    for (ch = 0; ch < s->nb_out_channels; ch++) {
+        av_rdft_end(s->irdft[ch]);
+    }
+    av_freep(&s->input_levels);
+    av_freep(&s->output_levels);
+    av_freep(&s->rdft);
+    av_freep(&s->irdft);
+    av_audio_fifo_free(s->fifo);
+    av_freep(&s->window_func_lut);
+}
+
+#define OFFSET(x) offsetof(AudioSurroundContext, x)
+#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+
+static const AVOption surround_options[] = {
+    { "chl_out",   "set output channel layout", OFFSET(out_channel_layout_str), AV_OPT_TYPE_STRING, {.str="5.1"}, 0,   0, FLAGS },
+    { "chl_in",    "set input channel layout",  OFFSET(in_channel_layout_str),  AV_OPT_TYPE_STRING, {.str="stereo"},0, 0, FLAGS },
+    { "level_in",  "set input level",           OFFSET(level_in),               AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },
+    { "level_out", "set output level",          OFFSET(level_out),              AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },
+    { "lfe",       "output LFE",                OFFSET(output_lfe),             AV_OPT_TYPE_BOOL,   {.i64=1},     0,   1, FLAGS },
+    { "lfe_low",   "LFE low cut off",           OFFSET(lowcutf),                AV_OPT_TYPE_INT,    {.i64=128},   0, 256, FLAGS },
+    { "lfe_high",  "LFE high cut off",          OFFSET(highcutf),               AV_OPT_TYPE_INT,    {.i64=256},   0, 512, FLAGS },
+    { "fc_in",     "set front center channel input level",  OFFSET(fc_in),      AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },
+    { "fc_out",    "set front center channel output level", OFFSET(fc_out),     AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },
+    { "lfe_in",    "set lfe channel input level",  OFFSET(lfe_in),              AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },
+    { "lfe_out",   "set lfe channel output level", OFFSET(lfe_out),             AV_OPT_TYPE_FLOAT,  {.dbl=1},     0,  10, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(surround);
+
+static const AVFilterPad inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_AUDIO,
+        .filter_frame = filter_frame,
+        .config_props = config_input,
+    },
+    { NULL }
+};
+
+static const AVFilterPad outputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_AUDIO,
+        .config_props = config_output,
+    },
+    { NULL }
+};
+
+AVFilter ff_af_surround = {
+    .name           = "surround",
+    .description    = NULL_IF_CONFIG_SMALL("Apply audio surround upmix filter."),
+    .query_formats  = query_formats,
+    .priv_size      = sizeof(AudioSurroundContext),
+    .priv_class     = &surround_class,
+    .init           = init,
+    .uninit         = uninit,
+    .inputs         = inputs,
+    .outputs        = outputs,
+    .flags          = AVFILTER_FLAG_SLICE_THREADS,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/af_volume.c b/mythtv/external/FFmpeg/libavfilter/af_volume.c
index 4d6b91645a1..3d76f12f2cc 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_volume.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_volume.c
@@ -393,9 +393,9 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
     }
     vol->var_values[VAR_PTS] = TS2D(buf->pts);
     vol->var_values[VAR_T  ] = TS2T(buf->pts, inlink->time_base);
-    vol->var_values[VAR_N  ] = inlink->frame_count;
+    vol->var_values[VAR_N  ] = inlink->frame_count_out;
 
-    pos = av_frame_get_pkt_pos(buf);
+    pos = buf->pkt_pos;
     vol->var_values[VAR_POS] = pos == -1 ? NAN : pos;
     if (vol->eval_mode == EVAL_MODE_FRAME)
         set_volume(ctx);
@@ -411,8 +411,10 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
         out_buf = buf;
     } else {
         out_buf = ff_get_audio_buffer(inlink, nb_samples);
-        if (!out_buf)
+        if (!out_buf) {
+            av_frame_free(&buf);
             return AVERROR(ENOMEM);
+        }
         ret = av_frame_copy_props(out_buf, buf);
         if (ret < 0) {
             av_frame_free(&out_buf);
diff --git a/mythtv/external/FFmpeg/libavfilter/af_volumedetect.c b/mythtv/external/FFmpeg/libavfilter/af_volumedetect.c
index 4815bccf6ba..43c1ebf02cf 100644
--- a/mythtv/external/FFmpeg/libavfilter/af_volumedetect.c
+++ b/mythtv/external/FFmpeg/libavfilter/af_volumedetect.c
@@ -24,7 +24,7 @@
 #include "avfilter.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct VolDetectContext {
     /**
      * Number of samples at each PCM value.
      * histogram[0x8000 + i] is the number of samples at value i.
@@ -41,9 +41,19 @@ static int query_formats(AVFilterContext *ctx)
         AV_SAMPLE_FMT_NONE
     };
     AVFilterFormats *formats;
+    AVFilterChannelLayouts *layouts;
+    int ret;
 
     if (!(formats = ff_make_format_list(sample_fmts)))
         return AVERROR(ENOMEM);
+
+    layouts = ff_all_channel_counts();
+    if (!layouts)
+        return AVERROR(ENOMEM);
+    ret = ff_set_common_channel_layouts(ctx, layouts);
+    if (ret < 0)
+        return ret;
+
     return ff_set_common_formats(ctx, formats);
 }
 
@@ -51,9 +61,8 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *samples)
 {
     AVFilterContext *ctx = inlink->dst;
     VolDetectContext *vd = ctx->priv;
-    int64_t layout  = samples->channel_layout;
     int nb_samples  = samples->nb_samples;
-    int nb_channels = av_get_channel_layout_nb_channels(layout);
+    int nb_channels = samples->channels;
     int nb_planes   = nb_channels;
     int plane, i;
     int16_t *pcm;
diff --git a/mythtv/external/FFmpeg/libavfilter/allfilters.c b/mythtv/external/FFmpeg/libavfilter/allfilters.c
index 82a65ee339c..9b672a7a7e7 100644
--- a/mythtv/external/FFmpeg/libavfilter/allfilters.c
+++ b/mythtv/external/FFmpeg/libavfilter/allfilters.c
@@ -19,6 +19,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/thread.h"
 #include "avfilter.h"
 #include "config.h"
 #include "opencl_allkernels.h"
@@ -37,16 +38,11 @@
         avfilter_register(&ff_##x);                                     \
     }
 
-void avfilter_register_all(void)
+static void register_all(void)
 {
-    static int initialized;
-
-    if (initialized)
-        return;
-    initialized = 1;
-
     REGISTER_FILTER(ABENCH,         abench,         af);
     REGISTER_FILTER(ACOMPRESSOR,    acompressor,    af);
+    REGISTER_FILTER(ACOPY,          acopy,          af);
     REGISTER_FILTER(ACROSSFADE,     acrossfade,     af);
     REGISTER_FILTER(ACRUSHER,       acrusher,       af);
     REGISTER_FILTER(ADELAY,         adelay,         af);
@@ -55,6 +51,7 @@ void avfilter_register_all(void)
     REGISTER_FILTER(AEVAL,          aeval,          af);
     REGISTER_FILTER(AFADE,          afade,          af);
     REGISTER_FILTER(AFFTFILT,       afftfilt,       af);
+    REGISTER_FILTER(AFIR,           afir,           af);
     REGISTER_FILTER(AFORMAT,        aformat,        af);
     REGISTER_FILTER(AGATE,          agate,          af);
     REGISTER_FILTER(AINTERLEAVE,    ainterleave,    af);
@@ -84,7 +81,6 @@ void avfilter_register_all(void)
     REGISTER_FILTER(ASPLIT,         asplit,         af);
     REGISTER_FILTER(ASTATS,         astats,         af);
     REGISTER_FILTER(ASTREAMSELECT,  astreamselect,  af);
-    REGISTER_FILTER(ASYNCTS,        asyncts,        af);
     REGISTER_FILTER(ATEMPO,         atempo,         af);
     REGISTER_FILTER(ATRIM,          atrim,          af);
     REGISTER_FILTER(AZMQ,           azmq,           af);
@@ -98,6 +94,7 @@ void avfilter_register_all(void)
     REGISTER_FILTER(CHORUS,         chorus,         af);
     REGISTER_FILTER(COMPAND,        compand,        af);
     REGISTER_FILTER(COMPENSATIONDELAY, compensationdelay, af);
+    REGISTER_FILTER(CROSSFEED,      crossfeed,      af);
     REGISTER_FILTER(CRYSTALIZER,    crystalizer,    af);
     REGISTER_FILTER(DCSHIFT,        dcshift,        af);
     REGISTER_FILTER(DYNAUDNORM,     dynaudnorm,     af);
@@ -107,7 +104,9 @@ void avfilter_register_all(void)
     REGISTER_FILTER(EXTRASTEREO,    extrastereo,    af);
     REGISTER_FILTER(FIREQUALIZER,   firequalizer,   af);
     REGISTER_FILTER(FLANGER,        flanger,        af);
+    REGISTER_FILTER(HAAS,           haas,           af);
     REGISTER_FILTER(HDCD,           hdcd,           af);
+    REGISTER_FILTER(HEADPHONE,      headphone,      af);
     REGISTER_FILTER(HIGHPASS,       highpass,       af);
     REGISTER_FILTER(JOIN,           join,           af);
     REGISTER_FILTER(LADSPA,         ladspa,         af);
@@ -124,6 +123,8 @@ void avfilter_register_all(void)
     REGISTER_FILTER(SOFALIZER,      sofalizer,      af);
     REGISTER_FILTER(STEREOTOOLS,    stereotools,    af);
     REGISTER_FILTER(STEREOWIDEN,    stereowiden,    af);
+    REGISTER_FILTER(SUPEREQUALIZER, superequalizer, af);
+    REGISTER_FILTER(SURROUND,       surround,       af);
     REGISTER_FILTER(TREBLE,         treble,         af);
     REGISTER_FILTER(TREMOLO,        tremolo,        af);
     REGISTER_FILTER(VIBRATO,        vibrato,        af);
@@ -161,6 +162,7 @@ void avfilter_register_all(void)
     REGISTER_FILTER(COLORMATRIX,    colormatrix,    vf);
     REGISTER_FILTER(COLORSPACE,     colorspace,     vf);
     REGISTER_FILTER(CONVOLUTION,    convolution,    vf);
+    REGISTER_FILTER(CONVOLVE,       convolve,       vf);
     REGISTER_FILTER(COPY,           copy,           vf);
     REGISTER_FILTER(COREIMAGE,      coreimage,      vf);
     REGISTER_FILTER(COVER_RECT,     cover_rect,     vf);
@@ -172,12 +174,17 @@ void avfilter_register_all(void)
     REGISTER_FILTER(DEBAND,         deband,         vf);
     REGISTER_FILTER(DECIMATE,       decimate,       vf);
     REGISTER_FILTER(DEFLATE,        deflate,        vf);
+    REGISTER_FILTER(DEFLICKER,      deflicker,      vf);
+    REGISTER_FILTER(DEINTERLACE_QSV,deinterlace_qsv,vf);
+    REGISTER_FILTER(DEINTERLACE_VAAPI, deinterlace_vaapi, vf);
     REGISTER_FILTER(DEJUDDER,       dejudder,       vf);
     REGISTER_FILTER(DELOGO,         delogo,         vf);
     REGISTER_FILTER(DESHAKE,        deshake,        vf);
+    REGISTER_FILTER(DESPILL,        despill,        vf);
     REGISTER_FILTER(DETELECINE,     detelecine,     vf);
     REGISTER_FILTER(DILATION,       dilation,       vf);
     REGISTER_FILTER(DISPLACE,       displace,       vf);
+    REGISTER_FILTER(DOUBLEWEAVE,    doubleweave,    vf);
     REGISTER_FILTER(DRAWBOX,        drawbox,        vf);
     REGISTER_FILTER(DRAWGRAPH,      drawgraph,      vf);
     REGISTER_FILTER(DRAWGRID,       drawgrid,       vf);
@@ -194,6 +201,7 @@ void avfilter_register_all(void)
     REGISTER_FILTER(FIELDMATCH,     fieldmatch,     vf);
     REGISTER_FILTER(FIELDORDER,     fieldorder,     vf);
     REGISTER_FILTER(FIND_RECT,      find_rect,      vf);
+    REGISTER_FILTER(FLOODFILL,      floodfill,      vf);
     REGISTER_FILTER(FORMAT,         format,         vf);
     REGISTER_FILTER(FPS,            fps,            vf);
     REGISTER_FILTER(FRAMEPACK,      framepack,      vf);
@@ -213,6 +221,7 @@ void avfilter_register_all(void)
     REGISTER_FILTER(HSTACK,         hstack,         vf);
     REGISTER_FILTER(HUE,            hue,            vf);
     REGISTER_FILTER(HWDOWNLOAD,     hwdownload,     vf);
+    REGISTER_FILTER(HWMAP,          hwmap,          vf);
     REGISTER_FILTER(HWUPLOAD,       hwupload,       vf);
     REGISTER_FILTER(HWUPLOAD_CUDA,  hwupload_cuda,  vf);
     REGISTER_FILTER(HYSTERESIS,     hysteresis,     vf);
@@ -223,7 +232,10 @@ void avfilter_register_all(void)
     REGISTER_FILTER(INTERLEAVE,     interleave,     vf);
     REGISTER_FILTER(KERNDEINT,      kerndeint,      vf);
     REGISTER_FILTER(LENSCORRECTION, lenscorrection, vf);
+    REGISTER_FILTER(LIBVMAF,        libvmaf,        vf);
+    REGISTER_FILTER(LIMITER,        limiter,        vf);
     REGISTER_FILTER(LOOP,           loop,           vf);
+    REGISTER_FILTER(LUMAKEY,        lumakey,        vf);
     REGISTER_FILTER(LUT,            lut,            vf);
     REGISTER_FILTER(LUT2,           lut2,           vf);
     REGISTER_FILTER(LUT3D,          lut3d,          vf);
@@ -235,6 +247,7 @@ void avfilter_register_all(void)
     REGISTER_FILTER(MERGEPLANES,    mergeplanes,    vf);
     REGISTER_FILTER(MESTIMATE,      mestimate,      vf);
     REGISTER_FILTER(METADATA,       metadata,       vf);
+    REGISTER_FILTER(MIDEQUALIZER,   midequalizer,   vf);
     REGISTER_FILTER(MINTERPOLATE,   minterpolate,   vf);
     REGISTER_FILTER(MPDECIMATE,     mpdecimate,     vf);
     REGISTER_FILTER(NEGATE,         negate,         vf);
@@ -245,6 +258,7 @@ void avfilter_register_all(void)
     REGISTER_FILTER(NULL,           null,           vf);
     REGISTER_FILTER(OCR,            ocr,            vf);
     REGISTER_FILTER(OCV,            ocv,            vf);
+    REGISTER_FILTER(OSCILLOSCOPE,   oscilloscope,   vf);
     REGISTER_FILTER(OVERLAY,        overlay,        vf);
     REGISTER_FILTER(OWDENOISE,      owdenoise,      vf);
     REGISTER_FILTER(PAD,            pad,            vf);
@@ -254,13 +268,17 @@ void avfilter_register_all(void)
     REGISTER_FILTER(PERSPECTIVE,    perspective,    vf);
     REGISTER_FILTER(PHASE,          phase,          vf);
     REGISTER_FILTER(PIXDESCTEST,    pixdesctest,    vf);
+    REGISTER_FILTER(PIXSCOPE,       pixscope,       vf);
     REGISTER_FILTER(PP,             pp,             vf);
     REGISTER_FILTER(PP7,            pp7,            vf);
+    REGISTER_FILTER(PREMULTIPLY,    premultiply,    vf);
     REGISTER_FILTER(PREWITT,        prewitt,        vf);
+    REGISTER_FILTER(PSEUDOCOLOR,    pseudocolor,    vf);
     REGISTER_FILTER(PSNR,           psnr,           vf);
     REGISTER_FILTER(PULLUP,         pullup,         vf);
     REGISTER_FILTER(QP,             qp,             vf);
     REGISTER_FILTER(RANDOM,         random,         vf);
+    REGISTER_FILTER(READEIA608,     readeia608,     vf);
     REGISTER_FILTER(READVITC,       readvitc,       vf);
     REGISTER_FILTER(REALTIME,       realtime,       vf);
     REGISTER_FILTER(REMAP,          remap,          vf);
@@ -268,10 +286,13 @@ void avfilter_register_all(void)
     REGISTER_FILTER(REMOVELOGO,     removelogo,     vf);
     REGISTER_FILTER(REPEATFIELDS,   repeatfields,   vf);
     REGISTER_FILTER(REVERSE,        reverse,        vf);
+    REGISTER_FILTER(ROBERTS,        roberts,        vf);
     REGISTER_FILTER(ROTATE,         rotate,         vf);
     REGISTER_FILTER(SAB,            sab,            vf);
     REGISTER_FILTER(SCALE,          scale,          vf);
+    REGISTER_FILTER(SCALE_CUDA,     scale_cuda,     vf);
     REGISTER_FILTER(SCALE_NPP,      scale_npp,      vf);
+    REGISTER_FILTER(SCALE_QSV,      scale_qsv,      vf);
     REGISTER_FILTER(SCALE_VAAPI,    scale_vaapi,    vf);
     REGISTER_FILTER(SCALE2REF,      scale2ref,      vf);
     REGISTER_FILTER(SELECT,         select,         vf);
@@ -289,6 +310,7 @@ void avfilter_register_all(void)
     REGISTER_FILTER(SHUFFLEPLANES,  shuffleplanes,  vf);
     REGISTER_FILTER(SIDEDATA,       sidedata,       vf);
     REGISTER_FILTER(SIGNALSTATS,    signalstats,    vf);
+    REGISTER_FILTER(SIGNATURE,      signature,      vf);
     REGISTER_FILTER(SMARTBLUR,      smartblur,      vf);
     REGISTER_FILTER(SOBEL,          sobel,          vf);
     REGISTER_FILTER(SPLIT,          split,          vf);
@@ -302,11 +324,16 @@ void avfilter_register_all(void)
     REGISTER_FILTER(SWAPUV,         swapuv,         vf);
     REGISTER_FILTER(TBLEND,         tblend,         vf);
     REGISTER_FILTER(TELECINE,       telecine,       vf);
+    REGISTER_FILTER(THRESHOLD,      threshold,      vf);
     REGISTER_FILTER(THUMBNAIL,      thumbnail,      vf);
+    REGISTER_FILTER(THUMBNAIL_CUDA, thumbnail_cuda, vf);
     REGISTER_FILTER(TILE,           tile,           vf);
     REGISTER_FILTER(TINTERLACE,     tinterlace,     vf);
+    REGISTER_FILTER(TLUT2,          tlut2,          vf);
+    REGISTER_FILTER(TONEMAP,        tonemap,        vf);
     REGISTER_FILTER(TRANSPOSE,      transpose,      vf);
     REGISTER_FILTER(TRIM,           trim,           vf);
+    REGISTER_FILTER(UNPREMULTIPLY,  unpremultiply,  vf);
     REGISTER_FILTER(UNSHARP,        unsharp,        vf);
     REGISTER_FILTER(USPP,           uspp,           vf);
     REGISTER_FILTER(VAGUEDENOISER,  vaguedenoiser,  vf);
@@ -315,6 +342,7 @@ void avfilter_register_all(void)
     REGISTER_FILTER(VIDSTABDETECT,  vidstabdetect,  vf);
     REGISTER_FILTER(VIDSTABTRANSFORM, vidstabtransform, vf);
     REGISTER_FILTER(VIGNETTE,       vignette,       vf);
+    REGISTER_FILTER(VMAFMOTION,     vmafmotion,     vf);
     REGISTER_FILTER(VSTACK,         vstack,         vf);
     REGISTER_FILTER(W3FDIF,         w3fdif,         vf);
     REGISTER_FILTER(WAVEFORM,       waveform,       vf);
@@ -346,6 +374,7 @@ void avfilter_register_all(void)
     REGISTER_FILTER(NULLSINK,       nullsink,       vsink);
 
     /* multimedia filters */
+    REGISTER_FILTER(ABITSCOPE,      abitscope,      avf);
     REGISTER_FILTER(ADRAWGRAPH,     adrawgraph,     avf);
     REGISTER_FILTER(AHISTOGRAM,     ahistogram,     avf);
     REGISTER_FILTER(APHASEMETER,    aphasemeter,    avf);
@@ -374,3 +403,10 @@ void avfilter_register_all(void)
     REGISTER_FILTER_UNCONDITIONAL(vf_fifo);
     ff_opencl_register_filter_kernel_code_all();
 }
+
+void avfilter_register_all(void)
+{
+    static AVOnce control = AV_ONCE_INIT;
+
+    ff_thread_once(&control, register_all);
+}
diff --git a/mythtv/external/FFmpeg/libavfilter/asrc_anoisesrc.c b/mythtv/external/FFmpeg/libavfilter/asrc_anoisesrc.c
index e4d40137492..78f0af4fdee 100644
--- a/mythtv/external/FFmpeg/libavfilter/asrc_anoisesrc.c
+++ b/mythtv/external/FFmpeg/libavfilter/asrc_anoisesrc.c
@@ -25,7 +25,7 @@
 #include "libavutil/lfg.h"
 #include "libavutil/random_seed.h"
 
-typedef struct {
+typedef struct ANoiseSrcContext {
     const AVClass *class;
     int sample_rate;
     double amplitude;
@@ -41,24 +41,35 @@ typedef struct {
     AVLFG c;
 } ANoiseSrcContext;
 
+enum NoiseMode {
+    NM_WHITE,
+    NM_PINK,
+    NM_BROWN,
+    NM_BLUE,
+    NM_VIOLET,
+    NM_NB
+};
+
 #define OFFSET(x) offsetof(ANoiseSrcContext, x)
 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 
 static const AVOption anoisesrc_options[] = {
-    { "sample_rate",  "set sample rate",  OFFSET(sample_rate),  AV_OPT_TYPE_INT,       {.i64 = 48000},  15,  INT_MAX,    FLAGS },
-    { "r",            "set sample rate",  OFFSET(sample_rate),  AV_OPT_TYPE_INT,       {.i64 = 48000},  15,  INT_MAX,    FLAGS },
-    { "amplitude",    "set amplitude",    OFFSET(amplitude),    AV_OPT_TYPE_DOUBLE,    {.dbl = 1.},     0.,  1.,         FLAGS },
-    { "a",            "set amplitude",    OFFSET(amplitude),    AV_OPT_TYPE_DOUBLE,    {.dbl = 1.},     0.,  1.,         FLAGS },
-    { "duration",     "set duration",     OFFSET(duration),     AV_OPT_TYPE_DURATION,  {.i64 =  0},      0,  INT64_MAX,  FLAGS },
-    { "d",            "set duration",     OFFSET(duration),     AV_OPT_TYPE_DURATION,  {.i64 =  0},      0,  INT64_MAX,  FLAGS },
-    { "color",        "set noise color",  OFFSET(color),        AV_OPT_TYPE_INT,       {.i64 =  1},      0,  2,          FLAGS, "color" },
-    { "colour",       "set noise color",  OFFSET(color),        AV_OPT_TYPE_INT,       {.i64 =  1},      0,  2,          FLAGS, "color" },
-    { "c",            "set noise color",  OFFSET(color),        AV_OPT_TYPE_INT,       {.i64 =  0},      0,  2,          FLAGS, "color" },
-    {     "white",    0,                  0,                    AV_OPT_TYPE_CONST,     {.i64 =  0},      0,  0,          FLAGS, "color" },
-    {     "pink",     0,                  0,                    AV_OPT_TYPE_CONST,     {.i64 =  1},      0,  0,          FLAGS, "color" },
-    {     "brown",    0,                  0,                    AV_OPT_TYPE_CONST,     {.i64 =  2},      0,  0,          FLAGS, "color" },
-    { "seed",         "set random seed",  OFFSET(seed),         AV_OPT_TYPE_INT64,     {.i64 = -1},     -1,  UINT_MAX,   FLAGS },
-    { "s",            "set random seed",  OFFSET(seed),         AV_OPT_TYPE_INT64,     {.i64 = -1},     -1,  UINT_MAX,   FLAGS },
+    { "sample_rate",  "set sample rate",  OFFSET(sample_rate),  AV_OPT_TYPE_INT,       {.i64 = 48000},     15,  INT_MAX,    FLAGS },
+    { "r",            "set sample rate",  OFFSET(sample_rate),  AV_OPT_TYPE_INT,       {.i64 = 48000},     15,  INT_MAX,    FLAGS },
+    { "amplitude",    "set amplitude",    OFFSET(amplitude),    AV_OPT_TYPE_DOUBLE,    {.dbl = 1.},        0.,  1.,         FLAGS },
+    { "a",            "set amplitude",    OFFSET(amplitude),    AV_OPT_TYPE_DOUBLE,    {.dbl = 1.},        0.,  1.,         FLAGS },
+    { "duration",     "set duration",     OFFSET(duration),     AV_OPT_TYPE_DURATION,  {.i64 =  0},         0,  INT64_MAX,  FLAGS },
+    { "d",            "set duration",     OFFSET(duration),     AV_OPT_TYPE_DURATION,  {.i64 =  0},         0,  INT64_MAX,  FLAGS },
+    { "color",        "set noise color",  OFFSET(color),        AV_OPT_TYPE_INT,       {.i64 =  0},         0,  NM_NB - 1,  FLAGS, "color" },
+    { "colour",       "set noise color",  OFFSET(color),        AV_OPT_TYPE_INT,       {.i64 =  0},         0,  NM_NB - 1,  FLAGS, "color" },
+    { "c",            "set noise color",  OFFSET(color),        AV_OPT_TYPE_INT,       {.i64 =  0},         0,  NM_NB - 1,  FLAGS, "color" },
+    {     "white",    0,                  0,                    AV_OPT_TYPE_CONST,     {.i64 = NM_WHITE},   0,  0,          FLAGS, "color" },
+    {     "pink",     0,                  0,                    AV_OPT_TYPE_CONST,     {.i64 = NM_PINK},    0,  0,          FLAGS, "color" },
+    {     "brown",    0,                  0,                    AV_OPT_TYPE_CONST,     {.i64 = NM_BROWN},   0,  0,          FLAGS, "color" },
+    {     "blue",     0,                  0,                    AV_OPT_TYPE_CONST,     {.i64 = NM_BLUE},    0,  0,          FLAGS, "color" },
+    {     "violet",   0,                  0,                    AV_OPT_TYPE_CONST,     {.i64 = NM_VIOLET},  0,  0,          FLAGS, "color" },
+    { "seed",         "set random seed",  OFFSET(seed),         AV_OPT_TYPE_INT64,     {.i64 = -1},        -1,  UINT_MAX,   FLAGS },
+    { "s",            "set random seed",  OFFSET(seed),         AV_OPT_TYPE_INT64,     {.i64 = -1},        -1,  UINT_MAX,   FLAGS },
     { "nb_samples",   "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 1, INT_MAX, FLAGS },
     { "n",            "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 1024}, 1, INT_MAX, FLAGS },
     {NULL}
@@ -103,7 +114,7 @@ static av_cold int query_formats(AVFilterContext *ctx)
 static double white_filter(double white, double *buf)
 {
     return white;
-};
+}
 
 static double pink_filter(double white, double *buf)
 {
@@ -121,6 +132,22 @@ static double pink_filter(double white, double *buf)
     return pink * 0.11;
 }
 
+static double blue_filter(double white, double *buf)
+{
+    double blue;
+
+    /* Same as pink_filter but subtract the offsets rather than add */
+    buf[0] = 0.0555179 * white - 0.99886 * buf[0];
+    buf[1] = 0.0750759 * white - 0.99332 * buf[1];
+    buf[2] = 0.1538520 * white - 0.96900 * buf[2];
+    buf[3] = 0.3104856 * white - 0.86650 * buf[3];
+    buf[4] = 0.5329522 * white - 0.55000 * buf[4];
+    buf[5] = -0.016898 * white + 0.76160 * buf[5];
+    blue = buf[0] + buf[1] + buf[2] + buf[3] + buf[4] + buf[5] + buf[6] + white * 0.5362;
+    buf[6] = white * 0.115926;
+    return blue * 0.11;
+}
+
 static double brown_filter(double white, double *buf)
 {
     double brown;
@@ -130,6 +157,15 @@ static double brown_filter(double white, double *buf)
     return brown * 3.5;
 }
 
+static double violet_filter(double white, double *buf)
+{
+    double violet;
+
+    violet = ((0.02 * white) - buf[0]) / 1.02;
+    buf[0] = violet;
+    return violet * 3.5;
+}
+
 static av_cold int config_props(AVFilterLink *outlink)
 {
     AVFilterContext *ctx = outlink->src;
@@ -144,9 +180,11 @@ static av_cold int config_props(AVFilterLink *outlink)
     s->duration = av_rescale(s->duration, s->sample_rate, AV_TIME_BASE);
 
     switch (s->color) {
-    case 0: s->filter = white_filter; break;
-    case 1: s->filter = pink_filter;  break;
-    case 2: s->filter = brown_filter; break;
+    case NM_WHITE:  s->filter = white_filter;  break;
+    case NM_PINK:   s->filter = pink_filter;   break;
+    case NM_BROWN:  s->filter = brown_filter;  break;
+    case NM_BLUE:   s->filter = blue_filter;   break;
+    case NM_VIOLET: s->filter = violet_filter; break;
     }
 
     return 0;
diff --git a/mythtv/external/FFmpeg/libavfilter/asrc_anullsrc.c b/mythtv/external/FFmpeg/libavfilter/asrc_anullsrc.c
index 94bd0cab3a5..cb676947d8f 100644
--- a/mythtv/external/FFmpeg/libavfilter/asrc_anullsrc.c
+++ b/mythtv/external/FFmpeg/libavfilter/asrc_anullsrc.c
@@ -34,7 +34,7 @@
 #include "avfilter.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct ANullContext {
     const AVClass *class;
     char   *channel_layout_str;
     uint64_t channel_layout;
diff --git a/mythtv/external/FFmpeg/libavfilter/asrc_flite.c b/mythtv/external/FFmpeg/libavfilter/asrc_flite.c
index b3f83abd744..c9619ebbae9 100644
--- a/mythtv/external/FFmpeg/libavfilter/asrc_flite.c
+++ b/mythtv/external/FFmpeg/libavfilter/asrc_flite.c
@@ -32,7 +32,7 @@
 #include "formats.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct FliteContext {
     const AVClass *class;
     char *voice_str;
     char *textfile;
@@ -170,8 +170,10 @@ static av_cold int init(AVFilterContext *ctx)
             return ret;
         }
 
-        if (!(flite->text = av_malloc(textbuf_size+1)))
+        if (!(flite->text = av_malloc(textbuf_size+1))) {
+            av_file_unmap(textbuf, textbuf_size);
             return AVERROR(ENOMEM);
+        }
         memcpy(flite->text, textbuf, textbuf_size);
         flite->text[textbuf_size] = 0;
         av_file_unmap(textbuf, textbuf_size);
@@ -253,8 +255,8 @@ static int request_frame(AVFilterLink *outlink)
     memcpy(samplesref->data[0], flite->wave_samples,
            nb_samples * flite->wave->num_channels * 2);
     samplesref->pts = flite->pts;
-    av_frame_set_pkt_pos(samplesref, -1);
-    av_frame_set_sample_rate(samplesref, flite->wave->sample_rate);
+    samplesref->pkt_pos = -1;
+    samplesref->sample_rate = flite->wave->sample_rate;
     flite->pts += nb_samples;
     flite->wave_samples += nb_samples * flite->wave->num_channels;
     flite->wave_nb_samples -= nb_samples;
diff --git a/mythtv/external/FFmpeg/libavfilter/asrc_sine.c b/mythtv/external/FFmpeg/libavfilter/asrc_sine.c
index 2a2f3c37c0b..3a87210b4b1 100644
--- a/mythtv/external/FFmpeg/libavfilter/asrc_sine.c
+++ b/mythtv/external/FFmpeg/libavfilter/asrc_sine.c
@@ -28,7 +28,7 @@
 #include "avfilter.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct SineContext {
     const AVClass *class;
     double frequency;
     double beep_factor;
@@ -219,7 +219,7 @@ static int request_frame(AVFilterLink *outlink)
     SineContext *sine = outlink->src->priv;
     AVFrame *frame;
     double values[VAR_VARS_NB] = {
-        [VAR_N]   = outlink->frame_count,
+        [VAR_N]   = outlink->frame_count_in,
         [VAR_PTS] = sine->pts,
         [VAR_T]   = sine->pts * av_q2d(outlink->time_base),
         [VAR_TB]  = av_q2d(outlink->time_base),
diff --git a/mythtv/external/FFmpeg/libavfilter/audio.c b/mythtv/external/FFmpeg/libavfilter/audio.c
index a18be89293c..5996f607b24 100644
--- a/mythtv/external/FFmpeg/libavfilter/audio.c
+++ b/mythtv/external/FFmpeg/libavfilter/audio.c
@@ -27,6 +27,9 @@
 #include "avfilter.h"
 #include "internal.h"
 
+#define BUFFER_ALIGN 0
+
+
 AVFrame *ff_null_get_audio_buffer(AVFilterLink *link, int nb_samples)
 {
     return ff_get_audio_buffer(link->dst->outputs[0], nb_samples);
@@ -34,29 +37,48 @@ AVFrame *ff_null_get_audio_buffer(AVFilterLink *link, int nb_samples)
 
 AVFrame *ff_default_get_audio_buffer(AVFilterLink *link, int nb_samples)
 {
-    AVFrame *frame = av_frame_alloc();
+    AVFrame *frame = NULL;
     int channels = link->channels;
-    int ret;
 
     av_assert0(channels == av_get_channel_layout_nb_channels(link->channel_layout) || !av_get_channel_layout_nb_channels(link->channel_layout));
 
+    if (!link->frame_pool) {
+        link->frame_pool = ff_frame_pool_audio_init(av_buffer_allocz, channels,
+                                                    nb_samples, link->format, BUFFER_ALIGN);
+        if (!link->frame_pool)
+            return NULL;
+    } else {
+        int pool_channels = 0;
+        int pool_nb_samples = 0;
+        int pool_align = 0;
+        enum AVSampleFormat pool_format = AV_SAMPLE_FMT_NONE;
+
+        if (ff_frame_pool_get_audio_config(link->frame_pool,
+                                           &pool_channels, &pool_nb_samples,
+                                           &pool_format, &pool_align) < 0) {
+            return NULL;
+        }
+
+        if (pool_channels != channels || pool_nb_samples < nb_samples ||
+            pool_format != link->format || pool_align != BUFFER_ALIGN) {
+
+            ff_frame_pool_uninit((FFFramePool **)&link->frame_pool);
+            link->frame_pool = ff_frame_pool_audio_init(av_buffer_allocz, channels,
+                                                        nb_samples, link->format, BUFFER_ALIGN);
+            if (!link->frame_pool)
+                return NULL;
+        }
+    }
+
+    frame = ff_frame_pool_get(link->frame_pool);
     if (!frame)
         return NULL;
 
-    frame->nb_samples     = nb_samples;
-    frame->format         = link->format;
-    av_frame_set_channels(frame, link->channels);
+    frame->nb_samples = nb_samples;
     frame->channel_layout = link->channel_layout;
-    frame->sample_rate    = link->sample_rate;
-    ret = av_frame_get_buffer(frame, 0);
-    if (ret < 0) {
-        av_frame_free(&frame);
-        return NULL;
-    }
-
-    av_samples_set_silence(frame->extended_data, 0, nb_samples, channels,
-                           link->format);
+    frame->sample_rate = link->sample_rate;
 
+    av_samples_set_silence(frame->extended_data, 0, nb_samples, channels, link->format);
 
     return frame;
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/avf_abitscope.c b/mythtv/external/FFmpeg/libavfilter/avf_abitscope.c
new file mode 100644
index 00000000000..0e3eaa422e3
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/avf_abitscope.c
@@ -0,0 +1,252 @@
+/*
+ * Copyright (c) 2016 Paul B Mahol
+ *
+ * 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/avassert.h"
+#include "libavutil/avstring.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/opt.h"
+#include "libavutil/parseutils.h"
+#include "avfilter.h"
+#include "formats.h"
+#include "audio.h"
+#include "video.h"
+#include "internal.h"
+
+typedef struct AudioBitScopeContext {
+    const AVClass *class;
+    int w, h;
+    AVRational frame_rate;
+    char *colors;
+
+    int nb_channels;
+    int depth;
+    uint8_t *fg;
+
+    uint64_t counter[64];
+} AudioBitScopeContext;
+
+#define OFFSET(x) offsetof(AudioBitScopeContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption abitscope_options[] = {
+    { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
+    { "r",    "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="25"}, 0, INT_MAX, FLAGS },
+    { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="1024x256"}, 0, 0, FLAGS },
+    { "s",    "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="1024x256"}, 0, 0, FLAGS },
+    { "colors", "set channels colors", OFFSET(colors), AV_OPT_TYPE_STRING, {.str = "red|green|blue|yellow|orange|lime|pink|magenta|brown" }, 0, 0, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(abitscope);
+
+static int query_formats(AVFilterContext *ctx)
+{
+    AVFilterFormats *formats = NULL;
+    AVFilterChannelLayouts *layouts;
+    AVFilterLink *inlink = ctx->inputs[0];
+    AVFilterLink *outlink = ctx->outputs[0];
+    static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_NONE };
+    static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
+    int ret;
+
+    formats = ff_make_format_list(sample_fmts);
+    if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0)
+        return ret;
+
+    layouts = ff_all_channel_counts();
+    if (!layouts)
+        return AVERROR(ENOMEM);
+    if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0)
+        return ret;
+
+    formats = ff_all_samplerates();
+    if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0)
+        return ret;
+
+    formats = ff_make_format_list(pix_fmts);
+    if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
+        return ret;
+
+    return 0;
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    AudioBitScopeContext *s = ctx->priv;
+    int ch, nb_samples;
+    char *colors, *saveptr = NULL;
+
+    nb_samples = FFMAX(1024, ((double)inlink->sample_rate / av_q2d(s->frame_rate)) + 0.5);
+    inlink->partial_buf_size =
+    inlink->min_samples =
+    inlink->max_samples = nb_samples;
+    s->nb_channels = inlink->channels;
+    s->depth = inlink->format == AV_SAMPLE_FMT_S16P ? 16 : 32;
+
+    s->fg = av_malloc_array(s->nb_channels, 4 * sizeof(*s->fg));
+    if (!s->fg)
+        return AVERROR(ENOMEM);
+
+    colors = av_strdup(s->colors);
+    if (!colors)
+        return AVERROR(ENOMEM);
+
+    for (ch = 0; ch < s->nb_channels; ch++) {
+        uint8_t fg[4] = { 0xff, 0xff, 0xff, 0xff };
+        char *color;
+
+        color = av_strtok(ch == 0 ? colors : NULL, " |", &saveptr);
+        if (color)
+            av_parse_color(fg, color, -1, ctx);
+        s->fg[4 * ch + 0] = fg[0];
+        s->fg[4 * ch + 1] = fg[1];
+        s->fg[4 * ch + 2] = fg[2];
+        s->fg[4 * ch + 3] = fg[3];
+    }
+    av_free(colors);
+
+    return 0;
+}
+
+static int config_output(AVFilterLink *outlink)
+{
+    AudioBitScopeContext *s = outlink->src->priv;
+
+    outlink->w = s->w;
+    outlink->h = s->h;
+    outlink->sample_aspect_ratio = (AVRational){1,1};
+    outlink->frame_rate = s->frame_rate;
+
+    return 0;
+}
+
+static void count_bits(AudioBitScopeContext *s, uint32_t sample, int max)
+{
+    int i;
+
+    for (i = 0; i < max; i++) {
+        if (sample & (1 << i))
+            s->counter[i]++;
+    }
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
+{
+    AVFilterContext *ctx = inlink->dst;
+    AVFilterLink *outlink = ctx->outputs[0];
+    AudioBitScopeContext *s = ctx->priv;
+    AVFrame *outpicref;
+    int ch, i, j, b;
+
+    outpicref = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+    if (!outpicref) {
+        av_frame_free(&insamples);
+        return AVERROR(ENOMEM);
+    }
+
+    for (i = 0; i < outlink->h; i++)
+        memset(outpicref->data[0] + i * outpicref->linesize[0], 0, outlink->w * 4);
+
+    outpicref->pts = insamples->pts;
+    outpicref->sample_aspect_ratio = (AVRational){1,1};
+
+    switch (insamples->format) {
+    case AV_SAMPLE_FMT_S16P:
+        for (ch = 0; ch < inlink->channels; ch++) {
+            uint16_t *in = (uint16_t *)insamples->extended_data[ch];
+            int w = outpicref->width / inlink->channels;
+            int h = outpicref->height / 16;
+            uint32_t color = AV_RN32(&s->fg[4 * ch]);
+
+            memset(s->counter, 0, sizeof(s->counter));
+            for (i = 0; i < insamples->nb_samples; i++)
+                count_bits(s, in[i], 16);
+
+            for (b = 0; b < 16; b++) {
+                for (j = 1; j < h - 1; j++) {
+                    uint8_t *dst = outpicref->data[0] + (b * h + j) * outpicref->linesize[0] + w * ch * 4;
+                    int ww = (s->counter[16 - b - 1] / (float)insamples->nb_samples) * (w - 1);
+
+                    for (i = 0; i < ww; i++) {
+                        AV_WN32(&dst[i * 4], color);
+                    }
+                }
+            }
+        }
+        break;
+    case AV_SAMPLE_FMT_S32P:
+        for (ch = 0; ch < inlink->channels; ch++) {
+            uint32_t *in = (uint32_t *)insamples->extended_data[ch];
+            int w = outpicref->width / inlink->channels;
+            int h = outpicref->height / 32;
+            uint32_t color = AV_RN32(&s->fg[4 * ch]);
+
+            memset(s->counter, 0, sizeof(s->counter));
+            for (i = 0; i < insamples->nb_samples; i++)
+                count_bits(s, in[i], 32);
+
+            for (b = 0; b < 32; b++) {
+                for (j = 1; j < h - 1; j++) {
+                    uint8_t *dst = outpicref->data[0] + (b * h + j) * outpicref->linesize[0] + w * ch * 4;
+                    int ww = (s->counter[32 - b - 1] / (float)insamples->nb_samples) * (w - 1);
+
+                    for (i = 0; i < ww; i++) {
+                        AV_WN32(&dst[i * 4], color);
+                    }
+                }
+            }
+        }
+        break;
+    }
+
+    av_frame_free(&insamples);
+
+    return ff_filter_frame(outlink, outpicref);
+}
+
+static const AVFilterPad inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_AUDIO,
+        .config_props = config_input,
+        .filter_frame = filter_frame,
+    },
+    { NULL }
+};
+
+static const AVFilterPad outputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = config_output,
+    },
+    { NULL }
+};
+
+AVFilter ff_avf_abitscope = {
+    .name          = "abitscope",
+    .description   = NULL_IF_CONFIG_SMALL("Convert input audio to audio bit scope video output."),
+    .query_formats = query_formats,
+    .priv_size     = sizeof(AudioBitScopeContext),
+    .inputs        = inputs,
+    .outputs       = outputs,
+    .priv_class    = &abitscope_class,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/avf_aphasemeter.c b/mythtv/external/FFmpeg/libavfilter/avf_aphasemeter.c
index 8e8b292a5f5..8cdee9464c4 100644
--- a/mythtv/external/FFmpeg/libavfilter/avf_aphasemeter.c
+++ b/mythtv/external/FFmpeg/libavfilter/avf_aphasemeter.c
@@ -37,6 +37,7 @@
 typedef struct AudioPhaseMeterContext {
     const AVClass *class;
     AVFrame *out;
+    int do_video;
     int w, h;
     AVRational frame_rate;
     int contrast[4];
@@ -57,6 +58,7 @@ static const AVOption aphasemeter_options[] = {
     { "gc", "set green contrast", OFFSET(contrast[1]), AV_OPT_TYPE_INT, {.i64=7}, 0, 255, FLAGS },
     { "bc", "set blue contrast",  OFFSET(contrast[2]), AV_OPT_TYPE_INT, {.i64=1}, 0, 255, FLAGS },
     { "mpc", "set median phase color", OFFSET(mpc_str), AV_OPT_TYPE_STRING, {.str = "none"}, 0, 0, FLAGS },
+    { "video", "set video output", OFFSET(do_video), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS },
     { NULL }
 };
 
@@ -64,6 +66,7 @@ AVFILTER_DEFINE_CLASS(aphasemeter);
 
 static int query_formats(AVFilterContext *ctx)
 {
+    AudioPhaseMeterContext *s = ctx->priv;
     AVFilterFormats *formats = NULL;
     AVFilterChannelLayouts *layout = NULL;
     AVFilterLink *inlink = ctx->inputs[0];
@@ -74,17 +77,24 @@ static int query_formats(AVFilterContext *ctx)
 
     formats = ff_make_format_list(sample_fmts);
     if ((ret = ff_formats_ref         (formats, &inlink->out_formats        )) < 0 ||
+        (ret = ff_formats_ref         (formats, &outlink->in_formats        )) < 0 ||
         (ret = ff_add_channel_layout  (&layout, AV_CH_LAYOUT_STEREO         )) < 0 ||
-        (ret = ff_channel_layouts_ref (layout , &inlink->out_channel_layouts)) < 0)
+        (ret = ff_channel_layouts_ref (layout , &inlink->out_channel_layouts)) < 0 ||
+        (ret = ff_channel_layouts_ref (layout , &outlink->in_channel_layouts)) < 0)
         return ret;
 
     formats = ff_all_samplerates();
-    if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0)
+    if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0 ||
+        (ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0)
         return ret;
 
-    formats = ff_make_format_list(pix_fmts);
-    if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
-        return ret;
+    if (s->do_video) {
+        AVFilterLink *outlink = ctx->outputs[1];
+
+        formats = ff_make_format_list(pix_fmts);
+        if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
+            return ret;
+    }
 
     return 0;
 }
@@ -95,15 +105,17 @@ static int config_input(AVFilterLink *inlink)
     AudioPhaseMeterContext *s = ctx->priv;
     int nb_samples;
 
-    nb_samples = FFMAX(1024, ((double)inlink->sample_rate / av_q2d(s->frame_rate)) + 0.5);
-    inlink->partial_buf_size =
-    inlink->min_samples =
-    inlink->max_samples = nb_samples;
+    if (s->do_video) {
+        nb_samples = FFMAX(1024, ((double)inlink->sample_rate / av_q2d(s->frame_rate)) + 0.5);
+        inlink->partial_buf_size =
+        inlink->min_samples =
+        inlink->max_samples = nb_samples;
+    }
 
     return 0;
 }
 
-static int config_output(AVFilterLink *outlink)
+static int config_video_output(AVFilterLink *outlink)
 {
     AVFilterContext *ctx = outlink->src;
     AudioPhaseMeterContext *s = ctx->priv;
@@ -131,8 +143,9 @@ static inline int get_x(float phase, int w)
 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 {
     AVFilterContext *ctx = inlink->dst;
-    AVFilterLink *outlink = ctx->outputs[0];
     AudioPhaseMeterContext *s = ctx->priv;
+    AVFilterLink *outlink = s->do_video ? ctx->outputs[1] : NULL;
+    AVFilterLink *aoutlink = ctx->outputs[0];
     AVDictionary **metadata;
     const int rc = s->contrast[0];
     const int gc = s->contrast[1];
@@ -142,8 +155,8 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     uint8_t *dst;
     int i;
 
-    if (!s->out || s->out->width  != outlink->w ||
-                   s->out->height != outlink->h) {
+    if (s->do_video && (!s->out || s->out->width  != outlink->w ||
+                                   s->out->height != outlink->h)) {
         av_frame_free(&s->out);
         s->out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
         if (!s->out) {
@@ -154,7 +167,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         out = s->out;
         for (i = 0; i < outlink->h; i++)
             memset(out->data[0] + i * out->linesize[0], 0, outlink->w * 4);
-    } else {
+    } else if (s->do_video) {
         out = s->out;
         for (i = outlink->h - 1; i >= 10; i--)
             memmove(out->data[0] + (i  ) * out->linesize[0],
@@ -163,7 +176,6 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         for (i = 0; i < outlink->w; i++)
             AV_WL32(out->data[0] + i * 4, 0);
     }
-    s->out->pts = in->pts;
 
     for (i = 0; i < in->nb_samples; i++) {
         const float *src = (float *)in->data[0] + i * 2;
@@ -171,24 +183,28 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         const float phase = isnan(f) ? 1 : f;
         const int x = get_x(phase, s->w);
 
-        dst = out->data[0] + x * 4;
-        dst[0] = FFMIN(255, dst[0] + rc);
-        dst[1] = FFMIN(255, dst[1] + gc);
-        dst[2] = FFMIN(255, dst[2] + bc);
-        dst[3] = 255;
+        if (s->do_video) {
+            dst = out->data[0] + x * 4;
+            dst[0] = FFMIN(255, dst[0] + rc);
+            dst[1] = FFMIN(255, dst[1] + gc);
+            dst[2] = FFMIN(255, dst[2] + bc);
+            dst[3] = 255;
+        }
         fphase += phase;
     }
     fphase /= in->nb_samples;
 
-    if (s->draw_median_phase) {
-        dst = out->data[0] + get_x(fphase, s->w) * 4;
-        AV_WL32(dst, AV_RL32(s->mpc));
-    }
+    if (s->do_video) {
+        if (s->draw_median_phase) {
+            dst = out->data[0] + get_x(fphase, s->w) * 4;
+            AV_WL32(dst, AV_RL32(s->mpc));
+        }
 
-    for (i = 1; i < 10 && i < outlink->h; i++)
-        memcpy(out->data[0] + i * out->linesize[0], out->data[0], outlink->w * 4);
+        for (i = 1; i < 10 && i < outlink->h; i++)
+            memcpy(out->data[0] + i * out->linesize[0], out->data[0], outlink->w * 4);
+    }
 
-    metadata = avpriv_frame_get_metadatap(out);
+    metadata = &in->metadata;
     if (metadata) {
         uint8_t value[128];
 
@@ -196,15 +212,48 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         av_dict_set(metadata, "lavfi.aphasemeter.phase", value, 0);
     }
 
-    av_frame_free(&in);
-    return ff_filter_frame(outlink, av_frame_clone(s->out));
+    if (s->do_video) {
+        s->out->pts = in->pts;
+        ff_filter_frame(outlink, av_frame_clone(s->out));
+    }
+    return ff_filter_frame(aoutlink, in);
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
 {
     AudioPhaseMeterContext *s = ctx->priv;
+    int i;
 
     av_frame_free(&s->out);
+    for (i = 0; i < ctx->nb_outputs; i++)
+        av_freep(&ctx->output_pads[i].name);
+}
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    AudioPhaseMeterContext *s = ctx->priv;
+    AVFilterPad pad;
+
+    pad = (AVFilterPad){
+        .name         = av_strdup("out0"),
+        .type         = AVMEDIA_TYPE_AUDIO,
+    };
+    if (!pad.name)
+        return AVERROR(ENOMEM);
+    ff_insert_outpad(ctx, 0, &pad);
+
+    if (s->do_video) {
+        pad = (AVFilterPad){
+            .name         = av_strdup("out1"),
+            .type         = AVMEDIA_TYPE_VIDEO,
+            .config_props = config_video_output,
+        };
+        if (!pad.name)
+            return AVERROR(ENOMEM);
+        ff_insert_outpad(ctx, 1, &pad);
+    }
+
+    return 0;
 }
 
 static const AVFilterPad inputs[] = {
@@ -217,22 +266,15 @@ static const AVFilterPad inputs[] = {
     { NULL }
 };
 
-static const AVFilterPad outputs[] = {
-    {
-        .name         = "default",
-        .type         = AVMEDIA_TYPE_VIDEO,
-        .config_props = config_output,
-    },
-    { NULL }
-};
-
 AVFilter ff_avf_aphasemeter = {
     .name          = "aphasemeter",
     .description   = NULL_IF_CONFIG_SMALL("Convert input audio to phase meter video output."),
+    .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
     .priv_size     = sizeof(AudioPhaseMeterContext),
     .inputs        = inputs,
-    .outputs       = outputs,
+    .outputs       = NULL,
     .priv_class    = &aphasemeter_class,
+    .flags         = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/avf_avectorscope.c b/mythtv/external/FFmpeg/libavfilter/avf_avectorscope.c
index 3063283efb5..c8ff0698e3c 100644
--- a/mythtv/external/FFmpeg/libavfilter/avf_avectorscope.c
+++ b/mythtv/external/FFmpeg/libavfilter/avf_avectorscope.c
@@ -90,7 +90,7 @@ static const AVOption avectorscope_options[] = {
     { "gf", "set green fade",     OFFSET(fade[1]), AV_OPT_TYPE_INT, {.i64=10}, 0, 255, FLAGS },
     { "bf", "set blue fade",      OFFSET(fade[2]), AV_OPT_TYPE_INT, {.i64=5},  0, 255, FLAGS },
     { "af", "set alpha fade",     OFFSET(fade[3]), AV_OPT_TYPE_INT, {.i64=5},  0, 255, FLAGS },
-    { "zoom", "set zoom factor",  OFFSET(zoom), AV_OPT_TYPE_DOUBLE, {.dbl=1},  1, 10, FLAGS },
+    { "zoom", "set zoom factor",  OFFSET(zoom), AV_OPT_TYPE_DOUBLE, {.dbl=1},  0, 10, FLAGS },
     { "draw", "set draw mode", OFFSET(draw), AV_OPT_TYPE_INT, {.i64=DOT}, 0, DRAW_NB-1, FLAGS, "draw" },
     { "dot",   "", 0, AV_OPT_TYPE_CONST, {.i64=DOT} , 0, 0, FLAGS, "draw" },
     { "line",  "", 0, AV_OPT_TYPE_CONST, {.i64=LINE}, 0, 0, FLAGS, "draw" },
@@ -234,7 +234,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
     const int hh = s->hh;
     unsigned x, y;
     unsigned prev_x = s->prev_x, prev_y = s->prev_y;
-    const double zoom = s->zoom;
+    double zoom = s->zoom;
     int i;
 
     if (!s->outpicref || s->outpicref->width  != outlink->w ||
@@ -246,6 +246,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
             return AVERROR(ENOMEM);
         }
 
+        s->outpicref->sample_aspect_ratio = (AVRational){1,1};
         for (i = 0; i < outlink->h; i++)
             memset(s->outpicref->data[0] + i * s->outpicref->linesize[0], 0, outlink->w * 4);
     }
@@ -253,6 +254,35 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
 
     fade(s);
 
+    if (zoom < 1) {
+        float max = 0;
+
+        switch (insamples->format) {
+        case AV_SAMPLE_FMT_S16: {
+            int16_t *samples = (int16_t *)insamples->data[0];
+
+            for (i = 0; i < insamples->nb_samples * 2; i++) {
+                float sample = samples[i] / (float)INT16_MAX;
+                max = FFMAX(FFABS(sample), max);
+            }
+
+            }
+            break;
+        case AV_SAMPLE_FMT_FLT: {
+            float *samples = (float *)insamples->data[0];
+
+            for (i = 0; i < insamples->nb_samples * 2; i++) {
+                max = FFMAX(FFABS(samples[i]), max);
+            }
+            }
+            break;
+        default:
+            av_assert2(0);
+        }
+
+        zoom = 1. / max;
+    }
+
     for (i = 0; i < insamples->nb_samples; i++) {
         int16_t *samples = (int16_t *)insamples->data[0] + i * 2;
         float *samplesf = (float *)insamples->data[0] + i * 2;
@@ -267,6 +297,8 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
             src[0] = samplesf[0];
             src[1] = samplesf[1];
             break;
+        default:
+            av_assert2(0);
         }
 
         switch (s->scale) {
diff --git a/mythtv/external/FFmpeg/libavfilter/avf_concat.c b/mythtv/external/FFmpeg/libavfilter/avf_concat.c
index 56e41792a78..6198a33d535 100644
--- a/mythtv/external/FFmpeg/libavfilter/avf_concat.c
+++ b/mythtv/external/FFmpeg/libavfilter/avf_concat.c
@@ -36,7 +36,7 @@
 
 #define TYPE_ALL 2
 
-typedef struct {
+typedef struct ConcatContext {
     const AVClass *class;
     unsigned nb_streams[TYPE_ALL]; /**< number of out streams of each type */
     unsigned nb_segments;
@@ -361,6 +361,7 @@ static av_cold int init(AVFilterContext *ctx)
 {
     ConcatContext *cat = ctx->priv;
     unsigned seg, type, str;
+    int ret;
 
     /* create input pads */
     for (seg = 0; seg < cat->nb_segments; seg++) {
@@ -373,7 +374,10 @@ static av_cold int init(AVFilterContext *ctx)
                     .filter_frame     = filter_frame,
                 };
                 pad.name = av_asprintf("in%d:%c%d", seg, "va"[type], str);
-                ff_insert_inpad(ctx, ctx->nb_inputs, &pad);
+                if ((ret = ff_insert_inpad(ctx, ctx->nb_inputs, &pad)) < 0) {
+                    av_freep(&pad.name);
+                    return ret;
+                }
             }
         }
     }
@@ -386,7 +390,10 @@ static av_cold int init(AVFilterContext *ctx)
                 .request_frame = request_frame,
             };
             pad.name = av_asprintf("out:%c%d", "va"[type], str);
-            ff_insert_outpad(ctx, ctx->nb_outputs, &pad);
+            if ((ret = ff_insert_outpad(ctx, ctx->nb_outputs, &pad)) < 0) {
+                av_freep(&pad.name);
+                return ret;
+            }
         }
     }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/avf_showcqt.c b/mythtv/external/FFmpeg/libavfilter/avf_showcqt.c
index 49b950c4d8b..875ba48cee2 100644
--- a/mythtv/external/FFmpeg/libavfilter/avf_showcqt.c
+++ b/mythtv/external/FFmpeg/libavfilter/avf_showcqt.c
@@ -75,8 +75,10 @@ static const AVOption showcqt_options[] = {
     { "gamma",    "set sonogram gamma", OFFSET(sono_g),     AV_OPT_TYPE_FLOAT, { .dbl = 3.0 },            1.0, 7.0,      FLAGS },
     { "bar_g",    "set bargraph gamma", OFFSET(bar_g),      AV_OPT_TYPE_FLOAT, { .dbl = 1.0 },            1.0, 7.0,      FLAGS },
     { "gamma2",   "set bargraph gamma", OFFSET(bar_g),      AV_OPT_TYPE_FLOAT, { .dbl = 1.0 },            1.0, 7.0,      FLAGS },
-    { "timeclamp",     "set timeclamp", OFFSET(timeclamp), AV_OPT_TYPE_DOUBLE, { .dbl = 0.17 },           0.1, 1.0,      FLAGS },
-    { "tc",            "set timeclamp", OFFSET(timeclamp), AV_OPT_TYPE_DOUBLE, { .dbl = 0.17 },           0.1, 1.0,      FLAGS },
+    { "bar_t",  "set bar transparency", OFFSET(bar_t),      AV_OPT_TYPE_FLOAT, { .dbl = 1.0 },            0.0, 1.0,      FLAGS },
+    { "timeclamp",     "set timeclamp", OFFSET(timeclamp), AV_OPT_TYPE_DOUBLE, { .dbl = 0.17 },         0.002, 1.0,      FLAGS },
+    { "tc",            "set timeclamp", OFFSET(timeclamp), AV_OPT_TYPE_DOUBLE, { .dbl = 0.17 },         0.002, 1.0,      FLAGS },
+    { "attack",      "set attack time", OFFSET(attack),    AV_OPT_TYPE_DOUBLE, { .dbl = 0 },              0.0, 1.0,      FLAGS },
     { "basefreq", "set base frequency", OFFSET(basefreq),  AV_OPT_TYPE_DOUBLE, { .dbl = BASEFREQ },      10.0, 100000.0, FLAGS },
     { "endfreq",   "set end frequency", OFFSET(endfreq),   AV_OPT_TYPE_DOUBLE, { .dbl = ENDFREQ },       10.0, 100000.0, FLAGS },
     { "coeffclamp",   "set coeffclamp", OFFSET(coeffclamp), AV_OPT_TYPE_FLOAT, { .dbl = 1.0 },            0.1, 10.0,     FLAGS },
@@ -151,6 +153,7 @@ static void common_uninit(ShowCQTContext *s)
     av_freep(&s->fft_data);
     av_freep(&s->fft_result);
     av_freep(&s->cqt_result);
+    av_freep(&s->attack_data);
     av_freep(&s->c_buf);
     av_freep(&s->h_buf);
     av_freep(&s->rcp_h_buf);
@@ -752,10 +755,10 @@ static void yuv_from_cqt(ColorFloat *c, const FFTComplex *v, float gamma, int le
 }
 
 static void draw_bar_rgb(AVFrame *out, const float *h, const float *rcp_h,
-                         const ColorFloat *c, int bar_h)
+                         const ColorFloat *c, int bar_h, float bar_t)
 {
     int x, y, w = out->width;
-    float mul, ht, rcp_bar_h = 1.0f / bar_h;
+    float mul, ht, rcp_bar_h = 1.0f / bar_h, rcp_bar_t = 1.0f / bar_t;
     uint8_t *v = out->data[0], *lp;
     int ls = out->linesize[0];
 
@@ -769,6 +772,7 @@ static void draw_bar_rgb(AVFrame *out, const float *h, const float *rcp_h,
                 *lp++ = 0;
             } else {
                 mul = (h[x] - ht) * rcp_h[x];
+                mul = (mul < bar_t) ? (mul * rcp_bar_t) : 1.0f;
                 *lp++ = lrintf(mul * c[x].rgb.r);
                 *lp++ = lrintf(mul * c[x].rgb.g);
                 *lp++ = lrintf(mul * c[x].rgb.b);
@@ -785,6 +789,7 @@ do { \
         *lpv++ = 128; \
     } else { \
         mul = (h[x] - ht) * rcp_h[x]; \
+        mul = (mul < bar_t) ? (mul * rcp_bar_t) : 1.0f; \
         *lpy++ = lrintf(mul * c[x].yuv.y + 16.0f); \
         *lpu++ = lrintf(mul * c[x].yuv.u + 128.0f); \
         *lpv++ = lrintf(mul * c[x].yuv.v + 128.0f); \
@@ -797,15 +802,16 @@ do { \
         *lpy++ = 16; \
     } else { \
         mul = (h[x] - ht) * rcp_h[x]; \
+        mul = (mul < bar_t) ? (mul * rcp_bar_t) : 1.0f; \
         *lpy++ = lrintf(mul * c[x].yuv.y + 16.0f); \
     } \
 } while (0)
 
 static void draw_bar_yuv(AVFrame *out, const float *h, const float *rcp_h,
-                         const ColorFloat *c, int bar_h)
+                         const ColorFloat *c, int bar_h, float bar_t)
 {
     int x, y, yh, w = out->width;
-    float mul, ht, rcp_bar_h = 1.0f / bar_h;
+    float mul, ht, rcp_bar_h = 1.0f / bar_h, rcp_bar_t = 1.0f / bar_t;
     uint8_t *vy = out->data[0], *vu = out->data[1], *vv = out->data[2];
     uint8_t *lpy, *lpu, *lpv;
     int lsy = out->linesize[0], lsu = out->linesize[1], lsv = out->linesize[2];
@@ -1134,6 +1140,14 @@ static int plot_cqt(AVFilterContext *ctx, AVFrame **frameout)
     last_time = av_gettime();
 
     memcpy(s->fft_result, s->fft_data, s->fft_len * sizeof(*s->fft_data));
+    if (s->attack_data) {
+        int k;
+        for (k = 0; k < s->remaining_fill_max; k++) {
+            s->fft_result[s->fft_len/2+k].re *= s->attack_data[k];
+            s->fft_result[s->fft_len/2+k].im *= s->attack_data[k];
+        }
+    }
+
     av_fft_permute(s->fft_ctx, s->fft_result);
     av_fft_calc(s->fft_ctx, s->fft_result);
     s->fft_result[s->fft_len] = s->fft_result[0];
@@ -1155,12 +1169,12 @@ static int plot_cqt(AVFilterContext *ctx, AVFrame **frameout)
         if (!out)
             return AVERROR(ENOMEM);
         out->sample_aspect_ratio = av_make_q(1, 1);
-        av_frame_set_color_range(out, AVCOL_RANGE_MPEG);
-        av_frame_set_colorspace(out, s->csp);
+        out->color_range = AVCOL_RANGE_MPEG;
+        out->colorspace = s->csp;
         UPDATE_TIME(s->alloc_time);
 
         if (s->bar_h) {
-            s->draw_bar(out, s->h_buf, s->rcp_h_buf, s->c_buf, s->bar_h);
+            s->draw_bar(out, s->h_buf, s->rcp_h_buf, s->c_buf, s->bar_h, s->bar_t);
             UPDATE_TIME(s->bar_time);
         }
 
@@ -1362,7 +1376,7 @@ static int config_output(AVFilterLink *outlink)
     if ((ret = init_volume(s)) < 0)
         return ret;
 
-    s->fft_bits = ceil(log2(inlink->sample_rate * s->timeclamp));
+    s->fft_bits = FFMAX(ceil(log2(inlink->sample_rate * s->timeclamp)), 4);
     s->fft_len = 1 << s->fft_bits;
     av_log(ctx, AV_LOG_INFO, "fft_len = %d, cqt_len = %d.\n", s->fft_len, s->cqt_len);
 
@@ -1373,6 +1387,21 @@ static int config_output(AVFilterLink *outlink)
     if (!s->fft_ctx || !s->fft_data || !s->fft_result || !s->cqt_result)
         return AVERROR(ENOMEM);
 
+    s->remaining_fill_max = s->fft_len / 2;
+    if (s->attack > 0.0) {
+        int k;
+
+        s->remaining_fill_max = FFMIN(s->remaining_fill_max, ceil(inlink->sample_rate * s->attack));
+        s->attack_data = av_malloc_array(s->remaining_fill_max, sizeof(*s->attack_data));
+        if (!s->attack_data)
+            return AVERROR(ENOMEM);
+
+        for (k = 0; k < s->remaining_fill_max; k++) {
+            double y = M_PI * k / (inlink->sample_rate * s->attack);
+            s->attack_data[k] = 0.355768 + 0.487396 * cos(y) + 0.144232 * cos(2*y) + 0.012604 * cos(3*y);
+        }
+    }
+
     s->cqt_align = 1;
     s->cqt_calc = cqt_calc;
     s->permute_coeffs = NULL;
@@ -1431,7 +1460,7 @@ static int config_output(AVFilterLink *outlink)
     s->sono_count = 0;
     s->next_pts = 0;
     s->sono_idx = 0;
-    s->remaining_fill = s->fft_len / 2;
+    s->remaining_fill = s->remaining_fill_max;
     s->remaining_frac = 0;
     s->step_frac = av_div_q(av_make_q(inlink->sample_rate, s->count) , s->rate);
     s->step = (int)(s->step_frac.num / s->step_frac.den);
@@ -1459,15 +1488,15 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
     AVFrame *out = NULL;
 
     if (!insamples) {
-        while (s->remaining_fill < s->fft_len / 2) {
-            memset(&s->fft_data[s->fft_len - s->remaining_fill], 0, sizeof(*s->fft_data) * s->remaining_fill);
+        while (s->remaining_fill < s->remaining_fill_max) {
+            memset(&s->fft_data[s->fft_len/2 + s->remaining_fill_max - s->remaining_fill], 0, sizeof(*s->fft_data) * s->remaining_fill);
             ret = plot_cqt(ctx, &out);
             if (ret < 0)
                 return ret;
 
             step = s->step + (s->step_frac.num + s->remaining_frac) / s->step_frac.den;
             s->remaining_frac = (s->step_frac.num + s->remaining_frac) % s->step_frac.den;
-            for (x = 0; x < (s->fft_len-step); x++)
+            for (x = 0; x < (s->fft_len/2 + s->remaining_fill_max - step); x++)
                 s->fft_data[x] = s->fft_data[x+step];
             s->remaining_fill += step;
 
@@ -1482,7 +1511,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
 
     while (remaining) {
         i = insamples->nb_samples - remaining;
-        j = s->fft_len - s->remaining_fill;
+        j = s->fft_len/2 + s->remaining_fill_max - s->remaining_fill;
         if (remaining >= s->remaining_fill) {
             for (m = 0; m < s->remaining_fill; m++) {
                 s->fft_data[j+m].re = audio_data[2*(i+m)];
@@ -1496,7 +1525,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
             remaining -= s->remaining_fill;
             if (out) {
                 int64_t pts = av_rescale_q(insamples->pts, inlink->time_base, av_make_q(1, inlink->sample_rate));
-                pts += insamples->nb_samples - remaining - s->fft_len/2;
+                pts += insamples->nb_samples - remaining - s->remaining_fill_max;
                 pts = av_rescale_q(pts, av_make_q(1, inlink->sample_rate), outlink->time_base);
                 if (FFABS(pts - out->pts) > PTS_TOLERANCE) {
                     av_log(ctx, AV_LOG_DEBUG, "changing pts from %"PRId64" (%.3f) to %"PRId64" (%.3f).\n",
@@ -1514,7 +1543,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
             }
             step = s->step + (s->step_frac.num + s->remaining_frac) / s->step_frac.den;
             s->remaining_frac = (s->step_frac.num + s->remaining_frac) % s->step_frac.den;
-            for (m = 0; m < s->fft_len-step; m++)
+            for (m = 0; m < s->fft_len/2 + s->remaining_fill_max - step; m++)
                 s->fft_data[m] = s->fft_data[m+step];
             s->remaining_fill = step;
         } else {
diff --git a/mythtv/external/FFmpeg/libavfilter/avf_showcqt.h b/mythtv/external/FFmpeg/libavfilter/avf_showcqt.h
index 165d36e7638..0cef5a20030 100644
--- a/mythtv/external/FFmpeg/libavfilter/avf_showcqt.h
+++ b/mythtv/external/FFmpeg/libavfilter/avf_showcqt.h
@@ -25,16 +25,16 @@
 #include "avfilter.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct Coeffs {
     FFTSample *val;
     int start, len;
 } Coeffs;
 
-typedef struct {
+typedef struct RGBFloat {
     float r, g, b;
 } RGBFloat;
 
-typedef struct {
+typedef struct YUVFloat {
     float y, u, v;
 } YUVFloat;
 
@@ -43,7 +43,7 @@ typedef union {
     YUVFloat yuv;
 } ColorFloat;
 
-typedef struct {
+typedef struct ShowCQTContext {
     const AVClass       *class;
     AVFilterContext     *ctx;
     AVFrame             *axis_frame;
@@ -55,6 +55,7 @@ typedef struct {
     AVRational          step_frac;
     int                 remaining_frac;
     int                 remaining_fill;
+    int                 remaining_fill_max;
     int64_t             next_pts;
     double              *freq;
     FFTContext          *fft_ctx;
@@ -62,6 +63,7 @@ typedef struct {
     FFTComplex          *fft_data;
     FFTComplex          *fft_result;
     FFTComplex          *cqt_result;
+    float               *attack_data;
     int                 fft_bits;
     int                 fft_len;
     int                 cqt_len;
@@ -78,7 +80,7 @@ typedef struct {
                                     int len, int fft_len);
     void                (*permute_coeffs)(float *v, int len);
     void                (*draw_bar)(AVFrame *out, const float *h, const float *rcp_h,
-                                    const ColorFloat *c, int bar_h);
+                                    const ColorFloat *c, int bar_h, float bar_t);
     void                (*draw_axis)(AVFrame *out, AVFrame *axis, const ColorFloat *c, int off);
     void                (*draw_sono)(AVFrame *out, AVFrame *sono, int off, int idx);
     void                (*update_sono)(AVFrame *sono, const ColorFloat *c, int idx);
@@ -102,7 +104,9 @@ typedef struct {
     char                *bar_v;
     float               sono_g;
     float               bar_g;
+    float               bar_t;
     double              timeclamp;
+    double              attack;
     double              basefreq;
     double              endfreq;
     float               coeffclamp; /* deprecated - ignored */
diff --git a/mythtv/external/FFmpeg/libavfilter/avf_showfreqs.c b/mythtv/external/FFmpeg/libavfilter/avf_showfreqs.c
index e2a923b8645..22f28ec3871 100644
--- a/mythtv/external/FFmpeg/libavfilter/avf_showfreqs.c
+++ b/mythtv/external/FFmpeg/libavfilter/avf_showfreqs.c
@@ -218,7 +218,7 @@ static int config_output(AVFilterLink *outlink)
                                       sizeof(*s->window_func_lut));
     if (!s->window_func_lut)
         return AVERROR(ENOMEM);
-    ff_generate_window_func(s->window_func_lut, s->win_size, s->win_func, &overlap);
+    generate_window_func(s->window_func_lut, s->win_size, s->win_func, &overlap);
     if (s->overlap == 1.)
         s->overlap = overlap;
     s->hop_size = (1. - s->overlap) * s->win_size;
@@ -326,12 +326,12 @@ static inline void plot_freq(ShowFreqsContext *s, int ch,
 
     switch (s->avg) {
     case 0:
-        y = s->avg_data[ch][f] = !outlink->frame_count ? y : FFMIN(avg, y);
+        y = s->avg_data[ch][f] = !outlink->frame_count_in ? y : FFMIN(avg, y);
         break;
     case 1:
         break;
     default:
-        s->avg_data[ch][f] = avg + y * (y - avg) / (FFMIN(outlink->frame_count + 1, s->avg) * y);
+        s->avg_data[ch][f] = avg + y * (y - avg) / (FFMIN(outlink->frame_count_in + 1, s->avg) * y);
         y = s->avg_data[ch][f];
         break;
     }
@@ -434,6 +434,7 @@ static int plot_freqs(AVFilterLink *inlink, AVFrame *in)
 
     av_free(colors);
     out->pts = in->pts;
+    out->sample_aspect_ratio = (AVRational){1,1};
     return ff_filter_frame(outlink, out);
 }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/avf_showspectrum.c b/mythtv/external/FFmpeg/libavfilter/avf_showspectrum.c
index f63fbe8b20f..956f62f3adb 100644
--- a/mythtv/external/FFmpeg/libavfilter/avf_showspectrum.c
+++ b/mythtv/external/FFmpeg/libavfilter/avf_showspectrum.c
@@ -48,7 +48,7 @@ enum ColorMode    { CHANNEL, INTENSITY, RAINBOW, MORELAND, NEBULAE, FIRE, FIERY,
 enum SlideMode    { REPLACE, SCROLL, FULLFRAME, RSCROLL, NB_SLIDES };
 enum Orientation  { VERTICAL, HORIZONTAL, NB_ORIENTATIONS };
 
-typedef struct {
+typedef struct ShowSpectrumContext {
     const AVClass *class;
     int w, h;
     AVFrame *outpicref;
@@ -299,11 +299,14 @@ static int config_output(AVFilterLink *outlink)
     int i, fft_bits, h, w;
     float overlap;
 
+    s->pts = AV_NOPTS_VALUE;
+
     if (!strcmp(ctx->filter->name, "showspectrumpic"))
         s->single_pic = 1;
 
     outlink->w = s->w;
     outlink->h = s->h;
+    outlink->sample_aspect_ratio = (AVRational){1,1};
 
     if (s->legend) {
         s->start_x = log10(inlink->sample_rate) * 25;
@@ -400,7 +403,7 @@ static int config_output(AVFilterLink *outlink)
                          sizeof(*s->window_func_lut));
         if (!s->window_func_lut)
             return AVERROR(ENOMEM);
-        ff_generate_window_func(s->window_func_lut, s->win_size, s->win_func, &overlap);
+        generate_window_func(s->window_func_lut, s->win_size, s->win_func, &overlap);
         if (s->overlap == 1)
             s->overlap = overlap;
         s->hop_size = (1. - s->overlap) * s->win_size;
@@ -420,13 +423,13 @@ static int config_output(AVFilterLink *outlink)
             ff_get_video_buffer(outlink, outlink->w, outlink->h);
         if (!outpicref)
             return AVERROR(ENOMEM);
-        outlink->sample_aspect_ratio = (AVRational){1,1};
+        outpicref->sample_aspect_ratio = (AVRational){1,1};
         for (i = 0; i < outlink->h; i++) {
             memset(outpicref->data[0] + i * outpicref->linesize[0],   0, outlink->w);
             memset(outpicref->data[1] + i * outpicref->linesize[1], 128, outlink->w);
             memset(outpicref->data[2] + i * outpicref->linesize[2], 128, outlink->w);
         }
-        av_frame_set_color_range(outpicref, AVCOL_RANGE_JPEG);
+        outpicref->color_range = AVCOL_RANGE_JPEG;
     }
 
     if ((s->orientation == VERTICAL   && s->xpos >= s->w) ||
@@ -1022,17 +1025,19 @@ static int showspectrumpic_request_frame(AVFilterLink *outlink)
     AVFilterContext *ctx = outlink->src;
     ShowSpectrumContext *s = ctx->priv;
     AVFilterLink *inlink = ctx->inputs[0];
-    int ret;
+    int ret, samples;
 
     ret = ff_request_frame(inlink);
-    if (ret == AVERROR_EOF && s->outpicref) {
-        int samples = av_audio_fifo_size(s->fifo);
+    samples = av_audio_fifo_size(s->fifo);
+    if (ret == AVERROR_EOF && s->outpicref && samples > 0) {
         int consumed = 0;
         int y, x = 0, sz = s->orientation == VERTICAL ? s->w : s->h;
         int ch, spf, spb;
         AVFrame *fin;
 
         spf = s->win_size * (samples / ((s->win_size * sz) * ceil(samples / (float)(s->win_size * sz))));
+        spf = FFMAX(1, spf);
+
         spb = (samples / (spf * sz)) * spf;
 
         fin = ff_get_audio_buffer(inlink, s->win_size);
@@ -1120,13 +1125,13 @@ static int showspectrumpic_request_frame(AVFilterLink *outlink)
                         dst[x] = 200;
                     }
                     for (y = 0; y < h; y += 40) {
-                        float hz = y * (inlink->sample_rate / 2) / (float)(1 << (int)ceil(log2(h)));
+                        float hertz = y * (inlink->sample_rate / 2) / (float)(1 << (int)ceil(log2(h)));
                         char *units;
 
-                        if (hz == 0)
+                        if (hertz == 0)
                             units = av_asprintf("DC");
                         else
-                            units = av_asprintf("%.2f", hz);
+                            units = av_asprintf("%.2f", hertz);
                         if (!units)
                             return AVERROR(ENOMEM);
 
@@ -1185,13 +1190,13 @@ static int showspectrumpic_request_frame(AVFilterLink *outlink)
                         dst[x] = 200;
                     }
                     for (x = 0; x < w; x += 80) {
-                        float hz = x * (inlink->sample_rate / 2) / (float)(1 << (int)ceil(log2(w)));
+                        float hertz = x * (inlink->sample_rate / 2) / (float)(1 << (int)ceil(log2(w)));
                         char *units;
 
-                        if (hz == 0)
+                        if (hertz == 0)
                             units = av_asprintf("DC");
                         else
-                            units = av_asprintf("%.2f", hz);
+                            units = av_asprintf("%.2f", hertz);
                         if (!units)
                             return AVERROR(ENOMEM);
 
@@ -1255,6 +1260,7 @@ static int showspectrumpic_request_frame(AVFilterLink *outlink)
                     if (!text)
                         continue;
                     drawtext(s->outpicref, s->w + s->start_x + 35, s->start_y + y - 5, text, 0);
+                    av_free(text);
                 }
             }
         }
diff --git a/mythtv/external/FFmpeg/libavfilter/avf_showwaves.c b/mythtv/external/FFmpeg/libavfilter/avf_showwaves.c
index 05aa9955612..08669679846 100644
--- a/mythtv/external/FFmpeg/libavfilter/avf_showwaves.c
+++ b/mythtv/external/FFmpeg/libavfilter/avf_showwaves.c
@@ -55,7 +55,7 @@ struct frame_node {
     struct frame_node *next;
 };
 
-typedef struct {
+typedef struct ShowWavesContext {
     const AVClass *class;
     int w, h;
     AVRational rate;
@@ -676,6 +676,8 @@ static const AVOption showwavespic_options[] = {
     { "scale", "set amplitude scale", OFFSET(scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, SCALE_NB-1, FLAGS, .unit="scale" },
         { "lin", "linear",         0, AV_OPT_TYPE_CONST, {.i64=SCALE_LIN}, .flags=FLAGS, .unit="scale"},
         { "log", "logarithmic",    0, AV_OPT_TYPE_CONST, {.i64=SCALE_LOG}, .flags=FLAGS, .unit="scale"},
+        { "sqrt", "square root",   0, AV_OPT_TYPE_CONST, {.i64=SCALE_SQRT}, .flags=FLAGS, .unit="scale"},
+        { "cbrt", "cubic root",    0, AV_OPT_TYPE_CONST, {.i64=SCALE_CBRT}, .flags=FLAGS, .unit="scale"},
     { NULL }
 };
 
diff --git a/mythtv/external/FFmpeg/libavfilter/avfilter.c b/mythtv/external/FFmpeg/libavfilter/avfilter.c
index 1d469c3334a..f0f849b3261 100644
--- a/mythtv/external/FFmpeg/libavfilter/avfilter.c
+++ b/mythtv/external/FFmpeg/libavfilter/avfilter.c
@@ -34,16 +34,18 @@
 #include "libavutil/rational.h"
 #include "libavutil/samplefmt.h"
 
+#define FF_INTERNAL_FIELDS 1
+#include "framequeue.h"
+
 #include "audio.h"
 #include "avfilter.h"
+#include "filters.h"
 #include "formats.h"
 #include "internal.h"
 
 #include "libavutil/ffversion.h"
 const char av_filter_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
 
-static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame);
-
 void ff_tlog_ref(void *ctx, AVFrame *ref, int end)
 {
     av_unused char buf[16];
@@ -51,7 +53,7 @@ void ff_tlog_ref(void *ctx, AVFrame *ref, int end)
             "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,
             ref, ref->buf, ref->data[0],
             ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
-            ref->pts, av_frame_get_pkt_pos(ref));
+            ref->pts, ref->pkt_pos);
 
     if (ref->width) {
         ff_tlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
@@ -135,6 +137,10 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad,
 {
     AVFilterLink *link;
 
+    av_assert0(src->graph);
+    av_assert0(dst->graph);
+    av_assert0(src->graph == dst->graph);
+
     if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
         src->outputs[srcpad]      || dst->inputs[dstpad])
         return AVERROR(EINVAL);
@@ -160,6 +166,7 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad,
     link->type    = src->output_pads[srcpad].type;
     av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
     link->format  = -1;
+    ff_framequeue_init(&link->fifo, &src->graph->internal->frame_queues);
 
     return 0;
 }
@@ -170,7 +177,8 @@ void avfilter_link_free(AVFilterLink **link)
         return;
 
     av_frame_free(&(*link)->partial_buf);
-    ff_video_frame_pool_uninit((FFVideoFramePool**)&(*link)->video_frame_pool);
+    ff_framequeue_free(&(*link)->fifo);
+    ff_frame_pool_uninit((FFFramePool**)&(*link)->frame_pool);
 
     av_freep(link);
 }
@@ -180,16 +188,46 @@ int avfilter_link_get_channels(AVFilterLink *link)
     return link->channels;
 }
 
+void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
+{
+    filter->ready = FFMAX(filter->ready, priority);
+}
+
+/**
+ * Clear frame_blocked_in on all outputs.
+ * This is necessary whenever something changes on input.
+ */
+static void filter_unblock(AVFilterContext *filter)
+{
+    unsigned i;
+
+    for (i = 0; i < filter->nb_outputs; i++)
+        filter->outputs[i]->frame_blocked_in = 0;
+}
+
+
 void ff_avfilter_link_set_in_status(AVFilterLink *link, int status, int64_t pts)
 {
-    ff_avfilter_link_set_out_status(link, status, pts);
+    if (link->status_in == status)
+        return;
+    av_assert0(!link->status_in);
+    link->status_in = status;
+    link->status_in_pts = pts;
+    link->frame_wanted_out = 0;
+    link->frame_blocked_in = 0;
+    filter_unblock(link->dst);
+    ff_filter_set_ready(link->dst, 200);
 }
 
 void ff_avfilter_link_set_out_status(AVFilterLink *link, int status, int64_t pts)
 {
-    link->status = status;
-    link->frame_wanted_in = link->frame_wanted_out = 0;
-    ff_update_link_current_pts(link, pts);
+    av_assert0(!link->frame_wanted_out);
+    av_assert0(!link->status_out);
+    link->status_out = status;
+    if (pts != AV_NOPTS_VALUE)
+        ff_update_link_current_pts(link, pts);
+    filter_unblock(link->dst);
+    ff_filter_set_ready(link->src, 200);
 }
 
 void avfilter_link_set_closed(AVFilterLink *link, int closed)
@@ -317,14 +355,12 @@ int avfilter_config_links(AVFilterContext *filter)
             }
 
             if (link->src->nb_inputs && link->src->inputs[0]->hw_frames_ctx &&
-                !link->hw_frames_ctx) {
-                AVHWFramesContext *input_ctx = (AVHWFramesContext*)link->src->inputs[0]->hw_frames_ctx->data;
-
-                if (input_ctx->format == link->format) {
-                    link->hw_frames_ctx = av_buffer_ref(link->src->inputs[0]->hw_frames_ctx);
-                    if (!link->hw_frames_ctx)
-                        return AVERROR(ENOMEM);
-                }
+                !(link->src->filter->flags_internal & FF_FILTER_FLAG_HWFRAME_AWARE)) {
+                av_assert0(!link->hw_frames_ctx &&
+                           "should not be set by non-hwframe-aware filter");
+                link->hw_frames_ctx = av_buffer_ref(link->src->inputs[0]->hw_frames_ctx);
+                if (!link->hw_frames_ctx)
+                    return AVERROR(ENOMEM);
             }
 
             if ((config_link = link->dstpad->config_props))
@@ -370,34 +406,61 @@ int ff_request_frame(AVFilterLink *link)
 {
     FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1);
 
-    if (link->status)
-        return link->status;
-    link->frame_wanted_in = 1;
+    av_assert1(!link->dst->filter->activate);
+    if (link->status_out)
+        return link->status_out;
+    if (link->status_in) {
+        if (ff_framequeue_queued_frames(&link->fifo)) {
+            av_assert1(!link->frame_wanted_out);
+            av_assert1(link->dst->ready >= 300);
+            return 0;
+        } else {
+            /* Acknowledge status change. Filters using ff_request_frame() will
+               handle the change automatically. Filters can also check the
+               status directly but none do yet. */
+            ff_avfilter_link_set_out_status(link, link->status_in, link->status_in_pts);
+            return link->status_out;
+        }
+    }
     link->frame_wanted_out = 1;
+    ff_filter_set_ready(link->src, 100);
     return 0;
 }
 
-int ff_request_frame_to_filter(AVFilterLink *link)
+static int64_t guess_status_pts(AVFilterContext *ctx, int status, AVRational link_time_base)
+{
+    unsigned i;
+    int64_t r = INT64_MAX;
+
+    for (i = 0; i < ctx->nb_inputs; i++)
+        if (ctx->inputs[i]->status_out == status)
+            r = FFMIN(r, av_rescale_q(ctx->inputs[i]->current_pts, ctx->inputs[i]->time_base, link_time_base));
+    if (r < INT64_MAX)
+        return r;
+    av_log(ctx, AV_LOG_WARNING, "EOF timestamp not reliable\n");
+    for (i = 0; i < ctx->nb_inputs; i++)
+        r = FFMIN(r, av_rescale_q(ctx->inputs[i]->status_in_pts, ctx->inputs[i]->time_base, link_time_base));
+    if (r < INT64_MAX)
+        return r;
+    return AV_NOPTS_VALUE;
+}
+
+static int ff_request_frame_to_filter(AVFilterLink *link)
 {
     int ret = -1;
 
     FF_TPRINTF_START(NULL, request_frame_to_filter); ff_tlog_link(NULL, link, 1);
-    link->frame_wanted_in = 0;
+    /* Assume the filter is blocked, let the method clear it if not */
+    link->frame_blocked_in = 1;
     if (link->srcpad->request_frame)
         ret = link->srcpad->request_frame(link);
     else if (link->src->inputs[0])
         ret = ff_request_frame(link->src->inputs[0]);
-    if (ret == AVERROR_EOF && link->partial_buf) {
-        AVFrame *pbuf = link->partial_buf;
-        link->partial_buf = NULL;
-        ret = ff_filter_frame_framed(link, pbuf);
-        ff_avfilter_link_set_in_status(link, AVERROR_EOF, AV_NOPTS_VALUE);
-        link->frame_wanted_out = 0;
-        return ret;
-    }
     if (ret < 0) {
-        if (ret != AVERROR(EAGAIN) && ret != link->status)
-            ff_avfilter_link_set_in_status(link, ret, AV_NOPTS_VALUE);
+        if (ret != AVERROR(EAGAIN) && ret != link->status_in)
+            ff_avfilter_link_set_in_status(link, ret, guess_status_pts(link->src, ret, link->time_base));
+        if (ret == AVERROR_EOF)
+            ret = 0;
     }
     return ret;
 }
@@ -647,6 +710,7 @@ static int default_execute(AVFilterContext *ctx, avfilter_action_func *func, voi
 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
 {
     AVFilterContext *ret;
+    int preinited = 0;
 
     if (!filter)
         return NULL;
@@ -663,6 +727,11 @@ AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
         if (!ret->priv)
             goto err;
     }
+    if (filter->preinit) {
+        if (filter->preinit(ret) < 0)
+            goto err;
+        preinited = 1;
+    }
 
     av_opt_set_defaults(ret);
     if (filter->priv_class) {
@@ -700,6 +769,8 @@ AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
     return ret;
 
 err:
+    if (preinited)
+        filter->uninit(ret);
     av_freep(&ret->inputs);
     av_freep(&ret->input_pads);
     ret->nb_inputs = 0;
@@ -844,7 +915,7 @@ static int process_options(AVFilterContext *ctx, AVDictionary **options,
             }
         } else {
         av_dict_set(options, key, value, 0);
-        if ((ret = av_opt_set(ctx->priv, key, value, 0)) < 0) {
+        if ((ret = av_opt_set(ctx->priv, key, value, AV_OPT_SEARCH_CHILDREN)) < 0) {
             if (!av_opt_find(ctx->priv, key, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) {
             if (ret == AVERROR_OPTION_NOT_FOUND)
                 av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
@@ -895,7 +966,7 @@ int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options)
     }
 
     if (ctx->filter->priv_class) {
-        ret = av_opt_set_dict(ctx->priv, options);
+        ret = av_opt_set_dict2(ctx->priv, options, AV_OPT_SEARCH_CHILDREN);
         if (ret < 0) {
             av_log(ctx, AV_LOG_ERROR, "Error applying options to the filter.\n");
             return ret;
@@ -1051,143 +1122,35 @@ static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
     int (*filter_frame)(AVFilterLink *, AVFrame *);
     AVFilterContext *dstctx = link->dst;
     AVFilterPad *dst = link->dstpad;
-    AVFrame *out = NULL;
     int ret;
-    AVFilterCommand *cmd= link->dst->command_queue;
-    int64_t pts;
-
-    if (link->status) {
-        av_frame_free(&frame);
-        return link->status;
-    }
 
     if (!(filter_frame = dst->filter_frame))
         filter_frame = default_filter_frame;
 
-    /* copy the frame if needed */
-    if (dst->needs_writable && !av_frame_is_writable(frame)) {
-        av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
-
-        switch (link->type) {
-        case AVMEDIA_TYPE_VIDEO:
-            out = ff_get_video_buffer(link, link->w, link->h);
-            break;
-        case AVMEDIA_TYPE_AUDIO:
-            out = ff_get_audio_buffer(link, frame->nb_samples);
-            break;
-        default:
-            ret = AVERROR(EINVAL);
-            goto fail;
-        }
-        if (!out) {
-            ret = AVERROR(ENOMEM);
-            goto fail;
-        }
-
-        ret = av_frame_copy_props(out, frame);
+    if (dst->needs_writable) {
+        ret = ff_inlink_make_frame_writable(link, &frame);
         if (ret < 0)
             goto fail;
-
-        switch (link->type) {
-        case AVMEDIA_TYPE_VIDEO:
-            av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
-                          frame->format, frame->width, frame->height);
-            break;
-        case AVMEDIA_TYPE_AUDIO:
-            av_samples_copy(out->extended_data, frame->extended_data,
-                            0, 0, frame->nb_samples,
-                            av_get_channel_layout_nb_channels(frame->channel_layout),
-                            frame->format);
-            break;
-        default:
-            ret = AVERROR(EINVAL);
-            goto fail;
-        }
-
-        av_frame_free(&frame);
-    } else
-        out = frame;
-
-    while(cmd && cmd->time <= out->pts * av_q2d(link->time_base)){
-        av_log(link->dst, AV_LOG_DEBUG,
-               "Processing command time:%f command:%s arg:%s\n",
-               cmd->time, cmd->command, cmd->arg);
-        avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
-        ff_command_queue_pop(link->dst);
-        cmd= link->dst->command_queue;
     }
 
-    pts = out->pts;
-    if (dstctx->enable_str) {
-        int64_t pos = av_frame_get_pkt_pos(out);
-        dstctx->var_values[VAR_N] = link->frame_count;
-        dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
-        dstctx->var_values[VAR_W] = link->w;
-        dstctx->var_values[VAR_H] = link->h;
-        dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
-
-        dstctx->is_disabled = fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) < 0.5;
-        if (dstctx->is_disabled &&
-            (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))
-            filter_frame = default_filter_frame;
-    }
-    ret = filter_frame(link, out);
-    link->frame_count++;
-    ff_update_link_current_pts(link, pts);
-    return ret;
+    ff_inlink_process_commands(link, frame);
+    dstctx->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
 
-fail:
-    av_frame_free(&out);
-    av_frame_free(&frame);
+    if (dstctx->is_disabled &&
+        (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))
+        filter_frame = default_filter_frame;
+    ret = filter_frame(link, frame);
+    link->frame_count_out++;
     return ret;
-}
 
-static int ff_filter_frame_needs_framing(AVFilterLink *link, AVFrame *frame)
-{
-    int insamples = frame->nb_samples, inpos = 0, nb_samples;
-    AVFrame *pbuf = link->partial_buf;
-    int nb_channels = av_frame_get_channels(frame);
-    int ret = 0;
-
-    /* Handle framing (min_samples, max_samples) */
-    while (insamples) {
-        if (!pbuf) {
-            AVRational samples_tb = { 1, link->sample_rate };
-            pbuf = ff_get_audio_buffer(link, link->partial_buf_size);
-            if (!pbuf) {
-                av_log(link->dst, AV_LOG_WARNING,
-                       "Samples dropped due to memory allocation failure.\n");
-                return 0;
-            }
-            av_frame_copy_props(pbuf, frame);
-            pbuf->pts = frame->pts;
-            if (pbuf->pts != AV_NOPTS_VALUE)
-                pbuf->pts += av_rescale_q(inpos, samples_tb, link->time_base);
-            pbuf->nb_samples = 0;
-        }
-        nb_samples = FFMIN(insamples,
-                           link->partial_buf_size - pbuf->nb_samples);
-        av_samples_copy(pbuf->extended_data, frame->extended_data,
-                        pbuf->nb_samples, inpos,
-                        nb_samples, nb_channels, link->format);
-        inpos                   += nb_samples;
-        insamples               -= nb_samples;
-        pbuf->nb_samples += nb_samples;
-        if (pbuf->nb_samples >= link->min_samples) {
-            ret = ff_filter_frame_framed(link, pbuf);
-            pbuf = NULL;
-        } else {
-            if (link->frame_wanted_out)
-                link->frame_wanted_in = 1;
-        }
-    }
+fail:
     av_frame_free(&frame);
-    link->partial_buf = pbuf;
     return ret;
 }
 
 int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
 {
+    int ret;
     FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);
 
     /* Consistency checks */
@@ -1206,7 +1169,7 @@ int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
             av_log(link->dst, AV_LOG_ERROR, "Format change is not supported\n");
             goto error;
         }
-        if (av_frame_get_channels(frame) != link->channels) {
+        if (frame->channels != link->channels) {
             av_log(link->dst, AV_LOG_ERROR, "Channel count change is not supported\n");
             goto error;
         }
@@ -1220,22 +1183,511 @@ int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
         }
     }
 
-    link->frame_wanted_out = 0;
-    /* Go directly to actual filtering if possible */
-    if (link->type == AVMEDIA_TYPE_AUDIO &&
-        link->min_samples &&
-        (link->partial_buf ||
-         frame->nb_samples < link->min_samples ||
-         frame->nb_samples > link->max_samples)) {
-        return ff_filter_frame_needs_framing(link, frame);
-    } else {
-        return ff_filter_frame_framed(link, frame);
+    link->frame_blocked_in = link->frame_wanted_out = 0;
+    link->frame_count_in++;
+    filter_unblock(link->dst);
+    ret = ff_framequeue_add(&link->fifo, frame);
+    if (ret < 0) {
+        av_frame_free(&frame);
+        return ret;
     }
+    ff_filter_set_ready(link->dst, 300);
+    return 0;
+
 error:
     av_frame_free(&frame);
     return AVERROR_PATCHWELCOME;
 }
 
+static int samples_ready(AVFilterLink *link, unsigned min)
+{
+    return ff_framequeue_queued_frames(&link->fifo) &&
+           (ff_framequeue_queued_samples(&link->fifo) >= min ||
+            link->status_in);
+}
+
+static int take_samples(AVFilterLink *link, unsigned min, unsigned max,
+                        AVFrame **rframe)
+{
+    AVFrame *frame0, *frame, *buf;
+    unsigned nb_samples, nb_frames, i, p;
+    int ret;
+
+    /* Note: this function relies on no format changes and must only be
+       called with enough samples. */
+    av_assert1(samples_ready(link, link->min_samples));
+    frame0 = frame = ff_framequeue_peek(&link->fifo, 0);
+    if (!link->fifo.samples_skipped && frame->nb_samples >= min && frame->nb_samples <= max) {
+        *rframe = ff_framequeue_take(&link->fifo);
+        return 0;
+    }
+    nb_frames = 0;
+    nb_samples = 0;
+    while (1) {
+        if (nb_samples + frame->nb_samples > max) {
+            if (nb_samples < min)
+                nb_samples = max;
+            break;
+        }
+        nb_samples += frame->nb_samples;
+        nb_frames++;
+        if (nb_frames == ff_framequeue_queued_frames(&link->fifo))
+            break;
+        frame = ff_framequeue_peek(&link->fifo, nb_frames);
+    }
+
+    buf = ff_get_audio_buffer(link, nb_samples);
+    if (!buf)
+        return AVERROR(ENOMEM);
+    ret = av_frame_copy_props(buf, frame0);
+    if (ret < 0) {
+        av_frame_free(&buf);
+        return ret;
+    }
+    buf->pts = frame0->pts;
+
+    p = 0;
+    for (i = 0; i < nb_frames; i++) {
+        frame = ff_framequeue_take(&link->fifo);
+        av_samples_copy(buf->extended_data, frame->extended_data, p, 0,
+                        frame->nb_samples, link->channels, link->format);
+        p += frame->nb_samples;
+        av_frame_free(&frame);
+    }
+    if (p < nb_samples) {
+        unsigned n = nb_samples - p;
+        frame = ff_framequeue_peek(&link->fifo, 0);
+        av_samples_copy(buf->extended_data, frame->extended_data, p, 0, n,
+                        link->channels, link->format);
+        ff_framequeue_skip_samples(&link->fifo, n, link->time_base);
+    }
+
+    *rframe = buf;
+    return 0;
+}
+
+static int ff_filter_frame_to_filter(AVFilterLink *link)
+{
+    AVFrame *frame = NULL;
+    AVFilterContext *dst = link->dst;
+    int ret;
+
+    av_assert1(ff_framequeue_queued_frames(&link->fifo));
+    ret = link->min_samples ?
+          ff_inlink_consume_samples(link, link->min_samples, link->max_samples, &frame) :
+          ff_inlink_consume_frame(link, &frame);
+    av_assert1(ret);
+    if (ret < 0) {
+        av_assert1(!frame);
+        return ret;
+    }
+    /* The filter will soon have received a new frame, that may allow it to
+       produce one or more: unblock its outputs. */
+    filter_unblock(dst);
+    /* AVFilterPad.filter_frame() expect frame_count_out to have the value
+       before the frame; ff_filter_frame_framed() will re-increment it. */
+    link->frame_count_out--;
+    ret = ff_filter_frame_framed(link, frame);
+    if (ret < 0 && ret != link->status_out) {
+        ff_avfilter_link_set_out_status(link, ret, AV_NOPTS_VALUE);
+    } else {
+        /* Run once again, to see if several frames were available, or if
+           the input status has also changed, or any other reason. */
+        ff_filter_set_ready(dst, 300);
+    }
+    return ret;
+}
+
+static int forward_status_change(AVFilterContext *filter, AVFilterLink *in)
+{
+    unsigned out = 0, progress = 0;
+    int ret;
+
+    av_assert0(!in->status_out);
+    if (!filter->nb_outputs) {
+        /* not necessary with the current API and sinks */
+        return 0;
+    }
+    while (!in->status_out) {
+        if (!filter->outputs[out]->status_in) {
+            progress++;
+            ret = ff_request_frame_to_filter(filter->outputs[out]);
+            if (ret < 0)
+                return ret;
+        }
+        if (++out == filter->nb_outputs) {
+            if (!progress) {
+                /* Every output already closed: input no longer interesting
+                   (example: overlay in shortest mode, other input closed). */
+                ff_avfilter_link_set_out_status(in, in->status_in, in->status_in_pts);
+                return 0;
+            }
+            progress = 0;
+            out = 0;
+        }
+    }
+    ff_filter_set_ready(filter, 200);
+    return 0;
+}
+
+static int ff_filter_activate_default(AVFilterContext *filter)
+{
+    unsigned i;
+
+    for (i = 0; i < filter->nb_inputs; i++) {
+        if (samples_ready(filter->inputs[i], filter->inputs[i]->min_samples)) {
+            return ff_filter_frame_to_filter(filter->inputs[i]);
+        }
+    }
+    for (i = 0; i < filter->nb_inputs; i++) {
+        if (filter->inputs[i]->status_in && !filter->inputs[i]->status_out) {
+            av_assert1(!ff_framequeue_queued_frames(&filter->inputs[i]->fifo));
+            return forward_status_change(filter, filter->inputs[i]);
+        }
+    }
+    for (i = 0; i < filter->nb_outputs; i++) {
+        if (filter->outputs[i]->frame_wanted_out &&
+            !filter->outputs[i]->frame_blocked_in) {
+            return ff_request_frame_to_filter(filter->outputs[i]);
+        }
+    }
+    return FFERROR_NOT_READY;
+}
+
+/*
+   Filter scheduling and activation
+
+   When a filter is activated, it must:
+   - if possible, output a frame;
+   - else, if relevant, forward the input status change;
+   - else, check outputs for wanted frames and forward the requests.
+
+   The following AVFilterLink fields are used for activation:
+
+   - frame_wanted_out:
+
+     This field indicates if a frame is needed on this input of the
+     destination filter. A positive value indicates that a frame is needed
+     to process queued frames or internal data or to satisfy the
+     application; a zero value indicates that a frame is not especially
+     needed but could be processed anyway; a negative value indicates that a
+     frame would just be queued.
+
+     It is set by filters using ff_request_frame() or ff_request_no_frame(),
+     when requested by the application through a specific API or when it is
+     set on one of the outputs.
+
+     It is cleared when a frame is sent from the source using
+     ff_filter_frame().
+
+     It is also cleared when a status change is sent from the source using
+     ff_avfilter_link_set_in_status().
+
+   - frame_blocked_in:
+
+     This field means that the source filter can not generate a frame as is.
+     Its goal is to avoid repeatedly calling the request_frame() method on
+     the same link.
+
+     It is set by the framework on all outputs of a filter before activating it.
+
+     It is automatically cleared by ff_filter_frame().
+
+     It is also automatically cleared by ff_avfilter_link_set_in_status().
+
+     It is also cleared on all outputs (using filter_unblock()) when
+     something happens on an input: processing a frame or changing the
+     status.
+
+   - fifo:
+
+     Contains the frames queued on a filter input. If it contains frames and
+     frame_wanted_out is not set, then the filter can be activated. If that
+     result in the filter not able to use these frames, the filter must set
+     frame_wanted_out to ask for more frames.
+
+   - status_in and status_in_pts:
+
+     Status (EOF or error code) of the link and timestamp of the status
+     change (in link time base, same as frames) as seen from the input of
+     the link. The status change is considered happening after the frames
+     queued in fifo.
+
+     It is set by the source filter using ff_avfilter_link_set_in_status().
+
+   - status_out:
+
+     Status of the link as seen from the output of the link. The status
+     change is considered having already happened.
+
+     It is set by the destination filter using
+     ff_avfilter_link_set_out_status().
+
+   Filters are activated according to the ready field, set using the
+   ff_filter_set_ready(). Eventually, a priority queue will be used.
+   ff_filter_set_ready() is called whenever anything could cause progress to
+   be possible. Marking a filter ready when it is not is not a problem,
+   except for the small overhead it causes.
+
+   Conditions that cause a filter to be marked ready are:
+
+   - frames added on an input link;
+
+   - changes in the input or output status of an input link;
+
+   - requests for a frame on an output link;
+
+   - after any actual processing using the legacy methods (filter_frame(),
+     and request_frame() to acknowledge status changes), to run once more
+     and check if enough input was present for several frames.
+
+   Exemples of scenarios to consider:
+
+   - buffersrc: activate if frame_wanted_out to notify the application;
+     activate when the application adds a frame to push it immediately.
+
+   - testsrc: activate only if frame_wanted_out to produce and push a frame.
+
+   - concat (not at stitch points): can process a frame on any output.
+     Activate if frame_wanted_out on output to forward on the corresponding
+     input. Activate when a frame is present on input to process it
+     immediately.
+
+   - framesync: needs at least one frame on each input; extra frames on the
+     wrong input will accumulate. When a frame is first added on one input,
+     set frame_wanted_out<0 on it to avoid getting more (would trigger
+     testsrc) and frame_wanted_out>0 on the other to allow processing it.
+
+   Activation of old filters:
+
+   In order to activate a filter implementing the legacy filter_frame() and
+   request_frame() methods, perform the first possible of the following
+   actions:
+
+   - If an input has frames in fifo and frame_wanted_out == 0, dequeue a
+     frame and call filter_frame().
+
+     Ratinale: filter frames as soon as possible instead of leaving them
+     queued; frame_wanted_out < 0 is not possible since the old API does not
+     set it nor provides any similar feedback; frame_wanted_out > 0 happens
+     when min_samples > 0 and there are not enough samples queued.
+
+   - If an input has status_in set but not status_out, try to call
+     request_frame() on one of the outputs in the hope that it will trigger
+     request_frame() on the input with status_in and acknowledge it. This is
+     awkward and fragile, filters with several inputs or outputs should be
+     updated to direct activation as soon as possible.
+
+   - If an output has frame_wanted_out > 0 and not frame_blocked_in, call
+     request_frame().
+
+     Rationale: checking frame_blocked_in is necessary to avoid requesting
+     repeatedly on a blocked input if another is not blocked (example:
+     [buffersrc1][testsrc1][buffersrc2][testsrc2]concat=v=2).
+
+     TODO: respect needs_fifo and remove auto-inserted fifos.
+
+ */
+
+int ff_filter_activate(AVFilterContext *filter)
+{
+    int ret;
+
+    /* Generic timeline support is not yet implemented but should be easy */
+    av_assert1(!(filter->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC &&
+                 filter->filter->activate));
+    filter->ready = 0;
+    ret = filter->filter->activate ? filter->filter->activate(filter) :
+          ff_filter_activate_default(filter);
+    if (ret == FFERROR_NOT_READY)
+        ret = 0;
+    return ret;
+}
+
+int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
+{
+    *rpts = link->current_pts;
+    if (ff_framequeue_queued_frames(&link->fifo))
+        return *rstatus = 0;
+    if (link->status_out)
+        return *rstatus = link->status_out;
+    if (!link->status_in)
+        return *rstatus = 0;
+    *rstatus = link->status_out = link->status_in;
+    ff_update_link_current_pts(link, link->status_in_pts);
+    *rpts = link->current_pts;
+    return 1;
+}
+
+int ff_inlink_check_available_frame(AVFilterLink *link)
+{
+    return ff_framequeue_queued_frames(&link->fifo) > 0;
+}
+
+int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min)
+{
+    uint64_t samples = ff_framequeue_queued_samples(&link->fifo);
+    av_assert1(min);
+    return samples >= min || (link->status_in && samples);
+}
+
+static void consume_update(AVFilterLink *link, const AVFrame *frame)
+{
+    ff_update_link_current_pts(link, frame->pts);
+    ff_inlink_process_commands(link, frame);
+    link->dst->is_disabled = !ff_inlink_evaluate_timeline_at_frame(link, frame);
+    link->frame_count_out++;
+}
+
+int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
+{
+    AVFrame *frame;
+
+    *rframe = NULL;
+    if (!ff_inlink_check_available_frame(link))
+        return 0;
+
+    if (link->fifo.samples_skipped) {
+        frame = ff_framequeue_peek(&link->fifo, 0);
+        return ff_inlink_consume_samples(link, frame->nb_samples, frame->nb_samples, rframe);
+    }
+
+    frame = ff_framequeue_take(&link->fifo);
+    consume_update(link, frame);
+    *rframe = frame;
+    return 1;
+}
+
+int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
+                            AVFrame **rframe)
+{
+    AVFrame *frame;
+    int ret;
+
+    av_assert1(min);
+    *rframe = NULL;
+    if (!ff_inlink_check_available_samples(link, min))
+        return 0;
+    if (link->status_in)
+        min = FFMIN(min, ff_framequeue_queued_samples(&link->fifo));
+    ret = take_samples(link, min, link->max_samples, &frame);
+    if (ret < 0)
+        return ret;
+    consume_update(link, frame);
+    *rframe = frame;
+    return 1;
+}
+
+int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe)
+{
+    AVFrame *frame = *rframe;
+    AVFrame *out;
+    int ret;
+
+    if (av_frame_is_writable(frame))
+        return 0;
+    av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
+
+    switch (link->type) {
+    case AVMEDIA_TYPE_VIDEO:
+        out = ff_get_video_buffer(link, link->w, link->h);
+        break;
+    case AVMEDIA_TYPE_AUDIO:
+        out = ff_get_audio_buffer(link, frame->nb_samples);
+        break;
+    default:
+        return AVERROR(EINVAL);
+    }
+    if (!out)
+        return AVERROR(ENOMEM);
+
+    ret = av_frame_copy_props(out, frame);
+    if (ret < 0) {
+        av_frame_free(&out);
+        return ret;
+    }
+
+    switch (link->type) {
+    case AVMEDIA_TYPE_VIDEO:
+        av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
+                      frame->format, frame->width, frame->height);
+        break;
+    case AVMEDIA_TYPE_AUDIO:
+        av_samples_copy(out->extended_data, frame->extended_data,
+                        0, 0, frame->nb_samples,
+                        frame->channels,
+                        frame->format);
+        break;
+    default:
+        av_assert0(!"reached");
+    }
+
+    av_frame_free(&frame);
+    *rframe = out;
+    return 0;
+}
+
+int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame)
+{
+    AVFilterCommand *cmd = link->dst->command_queue;
+
+    while(cmd && cmd->time <= frame->pts * av_q2d(link->time_base)){
+        av_log(link->dst, AV_LOG_DEBUG,
+               "Processing command time:%f command:%s arg:%s\n",
+               cmd->time, cmd->command, cmd->arg);
+        avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
+        ff_command_queue_pop(link->dst);
+        cmd= link->dst->command_queue;
+    }
+    return 0;
+}
+
+int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame)
+{
+    AVFilterContext *dstctx = link->dst;
+    int64_t pts = frame->pts;
+    int64_t pos = frame->pkt_pos;
+
+    if (!dstctx->enable_str)
+        return 1;
+
+    dstctx->var_values[VAR_N] = link->frame_count_out;
+    dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
+    dstctx->var_values[VAR_W] = link->w;
+    dstctx->var_values[VAR_H] = link->h;
+    dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
+
+    return fabs(av_expr_eval(dstctx->enable, dstctx->var_values, NULL)) >= 0.5;
+}
+
+void ff_inlink_request_frame(AVFilterLink *link)
+{
+    av_assert1(!link->status_in);
+    av_assert1(!link->status_out);
+    link->frame_wanted_out = 1;
+    ff_filter_set_ready(link->src, 100);
+}
+
+void ff_inlink_set_status(AVFilterLink *link, int status)
+{
+    if (link->status_out)
+        return;
+    link->frame_wanted_out = 0;
+    link->frame_blocked_in = 0;
+    ff_avfilter_link_set_out_status(link, status, AV_NOPTS_VALUE);
+    while (ff_framequeue_queued_frames(&link->fifo)) {
+           AVFrame *frame = ff_framequeue_take(&link->fifo);
+           av_frame_free(&frame);
+    }
+    if (!link->status_in)
+        link->status_in = status;
+}
+
+int ff_outlink_get_status(AVFilterLink *link)
+{
+    return link->status_in;
+}
+
 const AVClass *avfilter_get_class(void)
 {
     return &avfilter_class;
diff --git a/mythtv/external/FFmpeg/libavfilter/avfilter.h b/mythtv/external/FFmpeg/libavfilter/avfilter.h
index 15d00f70586..73a723d5833 100644
--- a/mythtv/external/FFmpeg/libavfilter/avfilter.h
+++ b/mythtv/external/FFmpeg/libavfilter/avfilter.h
@@ -194,6 +194,21 @@ typedef struct AVFilter {
      *****************************************************************
      */
 
+    /**
+     * Filter pre-initialization function
+     *
+     * This callback will be called immediately after the filter context is
+     * allocated, to allow allocating and initing sub-objects.
+     *
+     * If this callback is not NULL, the uninit callback will be called on
+     * allocation failure.
+     *
+     * @return 0 on success,
+     *         AVERROR code on failure (but the code will be
+     *           dropped and treated as ENOMEM by the calling code)
+     */
+    int (*preinit)(AVFilterContext *ctx);
+
     /**
      * Filter initialization function.
      *
@@ -268,6 +283,8 @@ typedef struct AVFilter {
 
     int priv_size;      ///< size of private data to allocate for the filter
 
+    int flags_internal; ///< Additional flags for avfilter internal use only.
+
     /**
      * Used by the filter registration system. Must not be touched by any other
      * code.
@@ -294,6 +311,20 @@ typedef struct AVFilter {
      * used for providing binary data.
      */
     int (*init_opaque)(AVFilterContext *ctx, void *opaque);
+
+    /**
+     * Filter activation function.
+     *
+     * Called when any processing is needed from the filter, instead of any
+     * filter_frame and request_frame on pads.
+     *
+     * The function must examine inlinks and outlinks and perform a single
+     * step of processing. If there is nothing to do, the function must do
+     * nothing and not return an error. If more steps are or may be
+     * possible, it must use ff_filter_set_ready() to schedule another
+     * activation.
+     */
+    int (*activate)(AVFilterContext *ctx);
 } AVFilter;
 
 /**
@@ -368,6 +399,13 @@ struct AVFilterContext {
      * Overrides global number of threads set per filter graph.
      */
     int nb_threads;
+
+    /**
+     * Ready status of the filter.
+     * A non-0 value means that the filter needs activating;
+     * a higher value suggests a more urgent activation.
+     */
+    unsigned ready;
 };
 
 /**
@@ -376,6 +414,11 @@ struct AVFilterContext {
  * the pads involved. In addition, this link also contains the parameters
  * which have been negotiated and agreed upon between the filter, such as
  * image dimensions, format, etc.
+ *
+ * Applications must not normally access the link structure directly.
+ * Use the buffersrc and buffersink API instead.
+ * In the future, access to the header may be reserved for filters
+ * implementation.
  */
 struct AVFilterLink {
     AVFilterContext *src;       ///< source filter
@@ -508,18 +551,6 @@ struct AVFilterLink {
      */
     int max_samples;
 
-    /**
-     * Link status.
-     * If not zero, all attempts of filter_frame or request_frame
-     * will fail with the corresponding code, and if necessary the reference
-     * will be destroyed.
-     * If request_frame returns an error, the status is set on the
-     * corresponding link.
-     * It can be set also be set by either the source or the destination
-     * filter.
-     */
-    int status;
-
     /**
      * Number of channels.
      */
@@ -533,19 +564,12 @@ struct AVFilterLink {
     /**
      * Number of past frames sent through the link.
      */
-    int64_t frame_count;
+    int64_t frame_count_in, frame_count_out;
 
     /**
-     * A pointer to a FFVideoFramePool struct.
-     */
-    void *video_frame_pool;
-
-    /**
-     * True if a frame is currently wanted on the input of this filter.
-     * Set when ff_request_frame() is called by the output,
-     * cleared when the request is handled or forwarded.
+     * A pointer to a FFFramePool struct.
      */
-    int frame_wanted_in;
+    void *frame_pool;
 
     /**
      * True if a frame is currently wanted on the output of this filter.
@@ -559,6 +583,51 @@ struct AVFilterLink {
      * AVHWFramesContext describing the frames.
      */
     AVBufferRef *hw_frames_ctx;
+
+#ifndef FF_INTERNAL_FIELDS
+
+    /**
+     * Internal structure members.
+     * The fields below this limit are internal for libavfilter's use
+     * and must in no way be accessed by applications.
+     */
+    char reserved[0xF000];
+
+#else /* FF_INTERNAL_FIELDS */
+
+    /**
+     * Queue of frames waiting to be filtered.
+     */
+    FFFrameQueue fifo;
+
+    /**
+     * If set, the source filter can not generate a frame as is.
+     * The goal is to avoid repeatedly calling the request_frame() method on
+     * the same link.
+     */
+    int frame_blocked_in;
+
+    /**
+     * Link input status.
+     * If not zero, all attempts of filter_frame will fail with the
+     * corresponding code.
+     */
+    int status_in;
+
+    /**
+     * Timestamp of the input status change.
+     */
+    int64_t status_in_pts;
+
+    /**
+     * Link output status.
+     * If not zero, all attempts of request_frame will fail with the
+     * corresponding code.
+     */
+    int status_out;
+
+#endif /* FF_INTERNAL_FIELDS */
+
 };
 
 /**
@@ -789,7 +858,9 @@ typedef struct AVFilterGraph {
     unsigned nb_filters;
 
     char *scale_sws_opts; ///< sws options to use for the auto-inserted scale filters
-    char *resample_lavr_opts;   ///< libavresample options to use for the auto-inserted resample filters
+#if FF_API_LAVR_OPTS
+    attribute_deprecated char *resample_lavr_opts;   ///< libavresample options to use for the auto-inserted resample filters
+#endif
 
     /**
      * Type of multithreading allowed for filters in this graph. A combination
diff --git a/mythtv/external/FFmpeg/libavfilter/avfiltergraph.c b/mythtv/external/FFmpeg/libavfilter/avfiltergraph.c
index 3af698d4bef..4304c068479 100644
--- a/mythtv/external/FFmpeg/libavfilter/avfiltergraph.c
+++ b/mythtv/external/FFmpeg/libavfilter/avfiltergraph.c
@@ -32,7 +32,11 @@
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
 
+#define FF_INTERNAL_FIELDS 1
+#include "framequeue.h"
+
 #include "avfilter.h"
+#include "buffersink.h"
 #include "formats.h"
 #include "internal.h"
 #include "thread.h"
@@ -87,6 +91,7 @@ AVFilterGraph *avfilter_graph_alloc(void)
 
     ret->av_class = &filtergraph_class;
     av_opt_set_defaults(ret);
+    ff_framequeue_global_init(&ret->internal->frame_queues);
 
     return ret;
 }
@@ -123,7 +128,9 @@ void avfilter_graph_free(AVFilterGraph **graph)
 
     av_freep(&(*graph)->scale_sws_opts);
     av_freep(&(*graph)->aresample_swr_opts);
+#if FF_API_LAVR_OPTS
     av_freep(&(*graph)->resample_lavr_opts);
+#endif
     av_freep(&(*graph)->filters);
     av_freep(&(*graph)->internal);
     av_freep(graph);
@@ -186,7 +193,7 @@ AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,
         } else {
             int ret = ff_graph_thread_init(graph);
             if (ret < 0) {
-                av_log(graph, AV_LOG_ERROR, "Error initializing threading.\n");
+                av_log(graph, AV_LOG_ERROR, "Error initializing threading: %s.\n", av_err2str(ret));
                 return NULL;
             }
         }
@@ -524,7 +531,7 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
                         return AVERROR(EINVAL);
                     }
 
-                    snprintf(inst_name, sizeof(inst_name), "auto-inserted scaler %d",
+                    snprintf(inst_name, sizeof(inst_name), "auto_scaler_%d",
                              scaler_count++);
 
                     if ((ret = avfilter_graph_create_filter(&convert, filter,
@@ -539,7 +546,7 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
                         return AVERROR(EINVAL);
                     }
 
-                    snprintf(inst_name, sizeof(inst_name), "auto-inserted resampler %d",
+                    snprintf(inst_name, sizeof(inst_name), "auto_resampler_%d",
                              resampler_count++);
                     scale_args[0] = '\0';
                     if (graph->aresample_swr_opts)
@@ -871,6 +878,8 @@ static void swap_samplerates_on_filter(AVFilterContext *filter)
         for (j = 0; j < outlink->in_samplerates->nb_formats; j++) {
             int diff = abs(sample_rate - outlink->in_samplerates->formats[j]);
 
+            av_assert0(diff < INT_MAX); // This would lead to the use of uninitialized best_diff but is only possible with invalid sample rates
+
             if (diff < best_diff) {
                 best_diff = diff;
                 best_idx  = j;
@@ -1236,7 +1245,7 @@ static int graph_insert_fifos(AVFilterGraph *graph, AVClass *log_ctx)
                    avfilter_get_by_name("fifo") :
                    avfilter_get_by_name("afifo");
 
-            snprintf(name, sizeof(name), "auto-inserted fifo %d", fifo_count++);
+            snprintf(name, sizeof(name), "auto_fifo_%d", fifo_count++);
 
             ret = avfilter_graph_create_filter(&fifo_ctx, fifo, name, NULL,
                                                NULL, graph);
@@ -1315,6 +1324,9 @@ int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const
                 queue = &(*queue)->next;
             next = *queue;
             *queue = av_mallocz(sizeof(AVFilterCommand));
+            if (!*queue)
+                return AVERROR(ENOMEM);
+
             (*queue)->command = av_strdup(command);
             (*queue)->arg     = av_strdup(arg);
             (*queue)->time    = ts;
@@ -1377,15 +1389,23 @@ void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
     heap_bubble_down(graph, link, link->age_index);
 }
 
-
 int avfilter_graph_request_oldest(AVFilterGraph *graph)
 {
     AVFilterLink *oldest = graph->sink_links[0];
+    int64_t frame_count;
     int r;
 
     while (graph->sink_links_count) {
         oldest = graph->sink_links[0];
-        r = ff_request_frame(oldest);
+        if (oldest->dst->filter->activate) {
+            /* For now, buffersink is the only filter implementing activate. */
+            r = av_buffersink_get_frame_flags(oldest->dst, NULL,
+                                              AV_BUFFERSINK_FLAG_PEEK);
+            if (r != AVERROR_EOF)
+                return r;
+        } else {
+            r = ff_request_frame(oldest);
+        }
         if (r != AVERROR_EOF)
             break;
         av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n",
@@ -1399,50 +1419,32 @@ int avfilter_graph_request_oldest(AVFilterGraph *graph)
     }
     if (!graph->sink_links_count)
         return AVERROR_EOF;
+    av_assert1(!oldest->dst->filter->activate);
     av_assert1(oldest->age_index >= 0);
-    while (oldest->frame_wanted_out) {
+    frame_count = oldest->frame_count_out;
+    while (frame_count == oldest->frame_count_out) {
         r = ff_filter_graph_run_once(graph);
-        if (r < 0)
+        if (r == AVERROR(EAGAIN) &&
+            !oldest->frame_wanted_out && !oldest->frame_blocked_in &&
+            !oldest->status_in)
+            ff_request_frame(oldest);
+        else if (r < 0)
             return r;
     }
     return 0;
 }
 
-static AVFilterLink *graph_run_once_find_filter(AVFilterGraph *graph)
-{
-    unsigned i, j;
-    AVFilterContext *f;
-
-    /* TODO: replace scanning the graph with a priority list */
-    for (i = 0; i < graph->nb_filters; i++) {
-        f = graph->filters[i];
-        for (j = 0; j < f->nb_outputs; j++)
-            if (f->outputs[j]->frame_wanted_in)
-                return f->outputs[j];
-    }
-    for (i = 0; i < graph->nb_filters; i++) {
-        f = graph->filters[i];
-        for (j = 0; j < f->nb_outputs; j++)
-            if (f->outputs[j]->frame_wanted_out)
-                return f->outputs[j];
-    }
-    return NULL;
-}
-
 int ff_filter_graph_run_once(AVFilterGraph *graph)
 {
-    AVFilterLink *link;
-    int ret;
-
-    link = graph_run_once_find_filter(graph);
-    if (!link) {
-        av_log(NULL, AV_LOG_WARNING, "Useless run of a filter graph\n");
+    AVFilterContext *filter;
+    unsigned i;
+
+    av_assert0(graph->nb_filters);
+    filter = graph->filters[0];
+    for (i = 1; i < graph->nb_filters; i++)
+        if (graph->filters[i]->ready > filter->ready)
+            filter = graph->filters[i];
+    if (!filter->ready)
         return AVERROR(EAGAIN);
-    }
-    ret = ff_request_frame_to_filter(link);
-    if (ret == AVERROR_EOF)
-        /* local EOF will be forwarded through request_frame() /
-           set_status() until it reaches the sink */
-        ret = 0;
-    return ret < 0 ? ret : 1;
+    return ff_filter_activate(filter);
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/bbox.h b/mythtv/external/FFmpeg/libavfilter/bbox.h
index eb73154c14b..cf026b81f9c 100644
--- a/mythtv/external/FFmpeg/libavfilter/bbox.h
+++ b/mythtv/external/FFmpeg/libavfilter/bbox.h
@@ -23,7 +23,7 @@
 
 #include <stdint.h>
 
-typedef struct {
+typedef struct FFBoundingBox {
     int x1, x2, y1, y2;
 } FFBoundingBox;
 
diff --git a/mythtv/external/FFmpeg/libavfilter/blend.h b/mythtv/external/FFmpeg/libavfilter/blend.h
index 54c4fdb6d1e..eb202268398 100644
--- a/mythtv/external/FFmpeg/libavfilter/blend.h
+++ b/mythtv/external/FFmpeg/libavfilter/blend.h
@@ -33,7 +33,7 @@ enum BlendMode {
     BLEND_BURN,
     BLEND_DARKEN,
     BLEND_DIFFERENCE,
-    BLEND_DIFFERENCE128,
+    BLEND_GRAINEXTRACT,
     BLEND_DIVIDE,
     BLEND_DODGE,
     BLEND_EXCLUSION,
@@ -54,10 +54,11 @@ enum BlendMode {
     BLEND_HARDMIX,
     BLEND_LINEARLIGHT,
     BLEND_GLOW,
-    BLEND_ADDITION128,
+    BLEND_GRAINMERGE,
     BLEND_MULTIPLY128,
     BLEND_HEAT,
     BLEND_FREEZE,
+    BLEND_EXTREMITY,
     BLEND_NB
 };
 
diff --git a/mythtv/external/FFmpeg/libavfilter/buffersink.c b/mythtv/external/FFmpeg/libavfilter/buffersink.c
index 2feb56dee9b..0f87b5439ac 100644
--- a/mythtv/external/FFmpeg/libavfilter/buffersink.c
+++ b/mythtv/external/FFmpeg/libavfilter/buffersink.c
@@ -23,22 +23,23 @@
  * buffer sink
  */
 
-#include "libavutil/audio_fifo.h"
 #include "libavutil/avassert.h"
 #include "libavutil/channel_layout.h"
 #include "libavutil/common.h"
 #include "libavutil/internal.h"
-#include "libavutil/mathematics.h"
 #include "libavutil/opt.h"
 
+#define FF_INTERNAL_FIELDS 1
+#include "framequeue.h"
+
 #include "audio.h"
 #include "avfilter.h"
 #include "buffersink.h"
+#include "filters.h"
 #include "internal.h"
 
 typedef struct BufferSinkContext {
     const AVClass *class;
-    AVFifoBuffer *fifo;                      ///< FIFO buffer of video frame references
     unsigned warning_limit;
 
     /* only used for video */
@@ -56,174 +57,74 @@ typedef struct BufferSinkContext {
     int *sample_rates;                      ///< list of accepted sample rates, terminated by -1
     int sample_rates_size;
 
-    /* only used for compat API */
-    AVAudioFifo *audio_fifo;     ///< FIFO for audio samples
-    int64_t next_pts;            ///< interpolating audio pts
+    AVFrame *peeked_frame;
 } BufferSinkContext;
 
 #define NB_ITEMS(list) (list ## _size / sizeof(*list))
 #define FIFO_INIT_SIZE 8
 #define FIFO_INIT_ELEMENT_SIZE sizeof(void *)
 
-static av_cold void uninit(AVFilterContext *ctx)
-{
-    BufferSinkContext *sink = ctx->priv;
-    AVFrame *frame;
-
-    if (sink->audio_fifo)
-        av_audio_fifo_free(sink->audio_fifo);
-
-    if (sink->fifo) {
-        while (av_fifo_size(sink->fifo) >= FIFO_INIT_ELEMENT_SIZE) {
-            av_fifo_generic_read(sink->fifo, &frame, sizeof(frame), NULL);
-            av_frame_free(&frame);
-        }
-        av_fifo_freep(&sink->fifo);
-    }
-}
-
-static int add_buffer_ref(AVFilterContext *ctx, AVFrame *ref)
+int attribute_align_arg av_buffersink_get_frame(AVFilterContext *ctx, AVFrame *frame)
 {
-    BufferSinkContext *buf = ctx->priv;
-
-    if (av_fifo_space(buf->fifo) < FIFO_INIT_ELEMENT_SIZE) {
-        /* realloc fifo size */
-        if (av_fifo_realloc2(buf->fifo, av_fifo_size(buf->fifo) * 2) < 0) {
-            av_log(ctx, AV_LOG_ERROR,
-                   "Cannot buffer more frames. Consume some available frames "
-                   "before adding new ones.\n");
-            return AVERROR(ENOMEM);
-        }
-    }
-
-    /* cache frame */
-    av_fifo_generic_write(buf->fifo, &ref, FIFO_INIT_ELEMENT_SIZE, NULL);
-    return 0;
+    return av_buffersink_get_frame_flags(ctx, frame, 0);
 }
 
-static int filter_frame(AVFilterLink *link, AVFrame *frame)
+static int return_or_keep_frame(BufferSinkContext *buf, AVFrame *out, AVFrame *in, int flags)
 {
-    AVFilterContext *ctx = link->dst;
-    BufferSinkContext *buf = link->dst->priv;
-    int ret;
-
-    if ((ret = add_buffer_ref(ctx, frame)) < 0)
-        return ret;
-    if (buf->warning_limit &&
-        av_fifo_size(buf->fifo) / FIFO_INIT_ELEMENT_SIZE >= buf->warning_limit) {
-        av_log(ctx, AV_LOG_WARNING,
-               "%d buffers queued in %s, something may be wrong.\n",
-               buf->warning_limit,
-               (char *)av_x_if_null(ctx->name, ctx->filter->name));
-        buf->warning_limit *= 10;
+    if ((flags & AV_BUFFERSINK_FLAG_PEEK)) {
+        buf->peeked_frame = in;
+        return out ? av_frame_ref(out, in) : 0;
+    } else {
+        av_assert1(out);
+        buf->peeked_frame = NULL;
+        av_frame_move_ref(out, in);
+        av_frame_free(&in);
+        return 0;
     }
-    return 0;
-}
-
-int attribute_align_arg av_buffersink_get_frame(AVFilterContext *ctx, AVFrame *frame)
-{
-    return av_buffersink_get_frame_flags(ctx, frame, 0);
 }
 
-int attribute_align_arg av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
+static int get_frame_internal(AVFilterContext *ctx, AVFrame *frame, int flags, int samples)
 {
     BufferSinkContext *buf = ctx->priv;
     AVFilterLink *inlink = ctx->inputs[0];
-    int ret;
+    int status, ret;
     AVFrame *cur_frame;
+    int64_t pts;
 
-    /* no picref available, fetch it from the filterchain */
-    while (!av_fifo_size(buf->fifo)) {
-        if (inlink->status)
-            return inlink->status;
-        if (flags & AV_BUFFERSINK_FLAG_NO_REQUEST)
-            return AVERROR(EAGAIN);
-        if ((ret = ff_request_frame(inlink)) < 0)
+    if (buf->peeked_frame)
+        return return_or_keep_frame(buf, frame, buf->peeked_frame, flags);
+
+    while (1) {
+        ret = samples ? ff_inlink_consume_samples(inlink, samples, samples, &cur_frame) :
+                        ff_inlink_consume_frame(inlink, &cur_frame);
+        if (ret < 0) {
             return ret;
-        while (inlink->frame_wanted_out) {
+        } else if (ret) {
+            /* TODO return the frame instead of copying it */
+            return return_or_keep_frame(buf, frame, cur_frame, flags);
+        } else if (ff_inlink_acknowledge_status(inlink, &status, &pts)) {
+            return status;
+        } else if ((flags & AV_BUFFERSINK_FLAG_NO_REQUEST)) {
+            return AVERROR(EAGAIN);
+        } else if (inlink->frame_wanted_out) {
             ret = ff_filter_graph_run_once(ctx->graph);
             if (ret < 0)
                 return ret;
+        } else {
+            ff_inlink_request_frame(inlink);
         }
     }
-
-    if (flags & AV_BUFFERSINK_FLAG_PEEK) {
-        cur_frame = *((AVFrame **)av_fifo_peek2(buf->fifo, 0));
-        if ((ret = av_frame_ref(frame, cur_frame)) < 0)
-            return ret;
-    } else {
-        av_fifo_generic_read(buf->fifo, &cur_frame, sizeof(cur_frame), NULL);
-        av_frame_move_ref(frame, cur_frame);
-        av_frame_free(&cur_frame);
-    }
-
-    return 0;
 }
 
-static int read_from_fifo(AVFilterContext *ctx, AVFrame *frame,
-                          int nb_samples)
+int attribute_align_arg av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
 {
-    BufferSinkContext *s = ctx->priv;
-    AVFilterLink   *link = ctx->inputs[0];
-    AVFrame *tmp;
-
-    if (!(tmp = ff_get_audio_buffer(link, nb_samples)))
-        return AVERROR(ENOMEM);
-    av_audio_fifo_read(s->audio_fifo, (void**)tmp->extended_data, nb_samples);
-
-    tmp->pts = s->next_pts;
-    if (s->next_pts != AV_NOPTS_VALUE)
-        s->next_pts += av_rescale_q(nb_samples, (AVRational){1, link->sample_rate},
-                                    link->time_base);
-
-    av_frame_move_ref(frame, tmp);
-    av_frame_free(&tmp);
-
-    return 0;
+    return get_frame_internal(ctx, frame, flags, ctx->inputs[0]->min_samples);
 }
 
 int attribute_align_arg av_buffersink_get_samples(AVFilterContext *ctx,
                                                   AVFrame *frame, int nb_samples)
 {
-    BufferSinkContext *s = ctx->priv;
-    AVFilterLink   *link = ctx->inputs[0];
-    AVFrame *cur_frame;
-    int ret = 0;
-
-    if (!s->audio_fifo) {
-        int nb_channels = link->channels;
-        if (!(s->audio_fifo = av_audio_fifo_alloc(link->format, nb_channels, nb_samples)))
-            return AVERROR(ENOMEM);
-    }
-
-    while (ret >= 0) {
-        if (av_audio_fifo_size(s->audio_fifo) >= nb_samples)
-            return read_from_fifo(ctx, frame, nb_samples);
-
-        if (!(cur_frame = av_frame_alloc()))
-            return AVERROR(ENOMEM);
-        ret = av_buffersink_get_frame_flags(ctx, cur_frame, 0);
-        if (ret == AVERROR_EOF && av_audio_fifo_size(s->audio_fifo)) {
-            av_frame_free(&cur_frame);
-            return read_from_fifo(ctx, frame, av_audio_fifo_size(s->audio_fifo));
-        } else if (ret < 0) {
-            av_frame_free(&cur_frame);
-            return ret;
-        }
-
-        if (cur_frame->pts != AV_NOPTS_VALUE) {
-            s->next_pts = cur_frame->pts -
-                          av_rescale_q(av_audio_fifo_size(s->audio_fifo),
-                                       (AVRational){ 1, link->sample_rate },
-                                       link->time_base);
-        }
-
-        ret = av_audio_fifo_write(s->audio_fifo, (void**)cur_frame->extended_data,
-                                  cur_frame->nb_samples);
-        av_frame_free(&cur_frame);
-    }
-
-    return ret;
+    return get_frame_internal(ctx, frame, 0, nb_samples);
 }
 
 AVBufferSinkParams *av_buffersink_params_alloc(void)
@@ -250,13 +151,24 @@ static av_cold int common_init(AVFilterContext *ctx)
 {
     BufferSinkContext *buf = ctx->priv;
 
-    buf->fifo = av_fifo_alloc_array(FIFO_INIT_SIZE, FIFO_INIT_ELEMENT_SIZE);
-    if (!buf->fifo) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to allocate fifo\n");
-        return AVERROR(ENOMEM);
-    }
     buf->warning_limit = 100;
-    buf->next_pts = AV_NOPTS_VALUE;
+    return 0;
+}
+
+static int activate(AVFilterContext *ctx)
+{
+    BufferSinkContext *buf = ctx->priv;
+
+    if (buf->warning_limit &&
+        ff_framequeue_queued_frames(&ctx->inputs[0]->fifo) >= buf->warning_limit) {
+        av_log(ctx, AV_LOG_WARNING,
+               "%d buffers queued in %s, something may be wrong.\n",
+               buf->warning_limit,
+               (char *)av_x_if_null(ctx->name, ctx->filter->name));
+        buf->warning_limit *= 10;
+    }
+
+    /* The frame is queued, the rest is up to get_frame_internal */
     return 0;
 }
 
@@ -268,14 +180,27 @@ void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size)
     inlink->partial_buf_size = frame_size;
 }
 
-AVRational av_buffersink_get_frame_rate(AVFilterContext *ctx)
-{
-    av_assert0(   !strcmp(ctx->filter->name, "buffersink")
-               || !strcmp(ctx->filter->name, "ffbuffersink"));
-
-    return ctx->inputs[0]->frame_rate;
+#define MAKE_AVFILTERLINK_ACCESSOR(type, field) \
+type av_buffersink_get_##field(const AVFilterContext *ctx) { \
+    av_assert0(ctx->filter->activate == activate); \
+    return ctx->inputs[0]->field; \
 }
 
+MAKE_AVFILTERLINK_ACCESSOR(enum AVMediaType , type               )
+MAKE_AVFILTERLINK_ACCESSOR(AVRational       , time_base          )
+MAKE_AVFILTERLINK_ACCESSOR(int              , format             )
+
+MAKE_AVFILTERLINK_ACCESSOR(AVRational       , frame_rate         )
+MAKE_AVFILTERLINK_ACCESSOR(int              , w                  )
+MAKE_AVFILTERLINK_ACCESSOR(int              , h                  )
+MAKE_AVFILTERLINK_ACCESSOR(AVRational       , sample_aspect_ratio)
+
+MAKE_AVFILTERLINK_ACCESSOR(int              , channels           )
+MAKE_AVFILTERLINK_ACCESSOR(uint64_t         , channel_layout     )
+MAKE_AVFILTERLINK_ACCESSOR(int              , sample_rate        )
+
+MAKE_AVFILTERLINK_ACCESSOR(AVBufferRef *    , hw_frames_ctx      )
+
 static av_cold int vsink_init(AVFilterContext *ctx, void *opaque)
 {
     BufferSinkContext *buf = ctx->priv;
@@ -413,7 +338,6 @@ static const AVFilterPad avfilter_vsink_buffer_inputs[] = {
     {
         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },
     { NULL }
 };
@@ -424,9 +348,9 @@ AVFilter ff_vsink_buffer = {
     .priv_size   = sizeof(BufferSinkContext),
     .priv_class  = &buffersink_class,
     .init_opaque = vsink_init,
-    .uninit      = uninit,
 
     .query_formats = vsink_query_formats,
+    .activate    = activate,
     .inputs      = avfilter_vsink_buffer_inputs,
     .outputs     = NULL,
 };
@@ -435,7 +359,6 @@ static const AVFilterPad avfilter_asink_abuffer_inputs[] = {
     {
         .name         = "default",
         .type         = AVMEDIA_TYPE_AUDIO,
-        .filter_frame = filter_frame,
     },
     { NULL }
 };
@@ -446,9 +369,9 @@ AVFilter ff_asink_abuffer = {
     .priv_class  = &abuffersink_class,
     .priv_size   = sizeof(BufferSinkContext),
     .init_opaque = asink_init,
-    .uninit      = uninit,
 
     .query_formats = asink_query_formats,
+    .activate    = activate,
     .inputs      = avfilter_asink_abuffer_inputs,
     .outputs     = NULL,
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/buffersink.h b/mythtv/external/FFmpeg/libavfilter/buffersink.h
index e399b911753..21d6bb505b4 100644
--- a/mythtv/external/FFmpeg/libavfilter/buffersink.h
+++ b/mythtv/external/FFmpeg/libavfilter/buffersink.h
@@ -62,7 +62,7 @@ int av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flag
 /**
  * Struct to use for initializing a buffersink context.
  */
-typedef struct {
+typedef struct AVBufferSinkParams {
     const enum AVPixelFormat *pixel_fmts; ///< list of allowed pixel formats, terminated by AV_PIX_FMT_NONE
 } AVBufferSinkParams;
 
@@ -76,7 +76,7 @@ AVBufferSinkParams *av_buffersink_params_alloc(void);
 /**
  * Struct to use for initializing an abuffersink context.
  */
-typedef struct {
+typedef struct AVABufferSinkParams {
     const enum AVSampleFormat *sample_fmts; ///< list of allowed sample formats, terminated by AV_SAMPLE_FMT_NONE
     const int64_t *channel_layouts;         ///< list of allowed channel layouts, terminated by -1
     const int *channel_counts;              ///< list of allowed channel counts, terminated by -1
@@ -101,9 +101,27 @@ AVABufferSinkParams *av_abuffersink_params_alloc(void);
 void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size);
 
 /**
- * Get the frame rate of the input.
+ * @defgroup lavfi_buffersink_accessors Buffer sink accessors
+ * Get the properties of the stream
+ * @{
  */
-AVRational av_buffersink_get_frame_rate(AVFilterContext *ctx);
+
+enum AVMediaType av_buffersink_get_type                (const AVFilterContext *ctx);
+AVRational       av_buffersink_get_time_base           (const AVFilterContext *ctx);
+int              av_buffersink_get_format              (const AVFilterContext *ctx);
+
+AVRational       av_buffersink_get_frame_rate          (const AVFilterContext *ctx);
+int              av_buffersink_get_w                   (const AVFilterContext *ctx);
+int              av_buffersink_get_h                   (const AVFilterContext *ctx);
+AVRational       av_buffersink_get_sample_aspect_ratio (const AVFilterContext *ctx);
+
+int              av_buffersink_get_channels            (const AVFilterContext *ctx);
+uint64_t         av_buffersink_get_channel_layout      (const AVFilterContext *ctx);
+int              av_buffersink_get_sample_rate         (const AVFilterContext *ctx);
+
+AVBufferRef *    av_buffersink_get_hw_frames_ctx       (const AVFilterContext *ctx);
+
+/** @} */
 
 /**
  * Get a frame with filtered data from sink and put it in frame.
diff --git a/mythtv/external/FFmpeg/libavfilter/buffersrc.c b/mythtv/external/FFmpeg/libavfilter/buffersrc.c
index 9294811d365..ad5aedd5f7d 100644
--- a/mythtv/external/FFmpeg/libavfilter/buffersrc.c
+++ b/mythtv/external/FFmpeg/libavfilter/buffersrc.c
@@ -155,7 +155,7 @@ int attribute_align_arg av_buffersrc_add_frame_flags(AVFilterContext *ctx, AVFra
     int ret = 0;
 
     if (frame && frame->channel_layout &&
-        av_get_channel_layout_nb_channels(frame->channel_layout) != av_frame_get_channels(frame)) {
+        av_get_channel_layout_nb_channels(frame->channel_layout) != frame->channels) {
         av_log(ctx, AV_LOG_ERROR, "Layout indicates a different number of channels than actually present\n");
         return AVERROR(EINVAL);
     }
@@ -173,6 +173,20 @@ int attribute_align_arg av_buffersrc_add_frame_flags(AVFilterContext *ctx, AVFra
     return ret;
 }
 
+static int push_frame(AVFilterGraph *graph)
+{
+    int ret;
+
+    while (1) {
+        ret = ff_filter_graph_run_once(graph);
+        if (ret == AVERROR(EAGAIN))
+            break;
+        if (ret < 0)
+            return ret;
+    }
+    return 0;
+}
+
 static int av_buffersrc_add_frame_internal(AVFilterContext *ctx,
                                            AVFrame *frame, int flags)
 {
@@ -182,10 +196,9 @@ static int av_buffersrc_add_frame_internal(AVFilterContext *ctx,
 
     s->nb_failed_requests = 0;
 
-    if (!frame) {
-        s->eof = 1;
-        return 0;
-    } else if (s->eof)
+    if (!frame)
+        return av_buffersrc_close(ctx, AV_NOPTS_VALUE, flags);
+    if (s->eof)
         return AVERROR(EINVAL);
 
     refcounted = !!frame->buf[0];
@@ -202,7 +215,7 @@ static int av_buffersrc_add_frame_internal(AVFilterContext *ctx,
         if (!frame->channel_layout)
             frame->channel_layout = s->channel_layout;
         CHECK_AUDIO_PARAM_CHANGE(ctx, s, frame->sample_rate, frame->channel_layout,
-                                 av_frame_get_channels(frame), frame->format);
+                                 frame->channels, frame->format);
         break;
     default:
         return AVERROR(EINVAL);
@@ -235,13 +248,27 @@ static int av_buffersrc_add_frame_internal(AVFilterContext *ctx,
         return ret;
     }
 
-    if ((flags & AV_BUFFERSRC_FLAG_PUSH))
-        if ((ret = ctx->output_pads[0].request_frame(ctx->outputs[0])) < 0)
+    if ((ret = ctx->output_pads[0].request_frame(ctx->outputs[0])) < 0)
+        return ret;
+
+    if ((flags & AV_BUFFERSRC_FLAG_PUSH)) {
+        ret = push_frame(ctx->graph);
+        if (ret < 0)
             return ret;
+    }
 
     return 0;
 }
 
+int av_buffersrc_close(AVFilterContext *ctx, int64_t pts, unsigned flags)
+{
+    BufferSourceContext *s = ctx->priv;
+
+    s->eof = 1;
+    ff_avfilter_link_set_in_status(ctx->outputs[0], AVERROR_EOF, pts);
+    return (flags & AV_BUFFERSRC_FLAG_PUSH) ? push_frame(ctx->graph) : 0;
+}
+
 static av_cold int init_video(AVFilterContext *ctx)
 {
     BufferSourceContext *c = ctx->priv;
@@ -316,14 +343,16 @@ static av_cold int init_audio(AVFilterContext *ctx)
         return AVERROR(EINVAL);
     }
 
-    if (s->channel_layout_str) {
+    if (s->channel_layout_str || s->channel_layout) {
         int n;
 
-        s->channel_layout = av_get_channel_layout(s->channel_layout_str);
         if (!s->channel_layout) {
-            av_log(ctx, AV_LOG_ERROR, "Invalid channel layout %s.\n",
-                   s->channel_layout_str);
-            return AVERROR(EINVAL);
+            s->channel_layout = av_get_channel_layout(s->channel_layout_str);
+            if (!s->channel_layout) {
+                av_log(ctx, AV_LOG_ERROR, "Invalid channel layout %s.\n",
+                       s->channel_layout_str);
+                return AVERROR(EINVAL);
+            }
         }
         n = av_get_channel_layout_nb_channels(s->channel_layout);
         if (s->channels) {
diff --git a/mythtv/external/FFmpeg/libavfilter/buffersrc.h b/mythtv/external/FFmpeg/libavfilter/buffersrc.h
index e42c78196bd..0652113f2bc 100644
--- a/mythtv/external/FFmpeg/libavfilter/buffersrc.h
+++ b/mythtv/external/FFmpeg/libavfilter/buffersrc.h
@@ -193,6 +193,14 @@ av_warn_unused_result
 int av_buffersrc_add_frame_flags(AVFilterContext *buffer_src,
                                  AVFrame *frame, int flags);
 
+/**
+ * Close the buffer source after EOF.
+ *
+ * This is similar to passing NULL to av_buffersrc_add_frame_flags()
+ * except it takes the timestamp of the EOF, i.e. the timestamp of the end
+ * of the last frame.
+ */
+int av_buffersrc_close(AVFilterContext *ctx, int64_t pts, unsigned flags);
 
 /**
  * @}
diff --git a/mythtv/external/FFmpeg/libavfilter/deshake.h b/mythtv/external/FFmpeg/libavfilter/deshake.h
index becd6c248b2..5e25bb3a7af 100644
--- a/mythtv/external/FFmpeg/libavfilter/deshake.h
+++ b/mythtv/external/FFmpeg/libavfilter/deshake.h
@@ -37,17 +37,17 @@ enum SearchMethod {
     SEARCH_COUNT
 };
 
-typedef struct {
+typedef struct IntMotionVector {
     int x;             ///< Horizontal shift
     int y;             ///< Vertical shift
 } IntMotionVector;
 
-typedef struct {
+typedef struct MotionVector {
     double x;             ///< Horizontal shift
     double y;             ///< Vertical shift
 } MotionVector;
 
-typedef struct {
+typedef struct Transform {
     MotionVector vec;     ///< Motion vector
     double angle;         ///< Angle of rotation
     double zoom;          ///< Zoom percentage
@@ -55,7 +55,7 @@ typedef struct {
 
 #if CONFIG_OPENCL
 
-typedef struct {
+typedef struct DeshakeOpenclContext {
     cl_command_queue command_queue;
     cl_program program;
     cl_kernel kernel_luma;
@@ -73,7 +73,7 @@ typedef struct {
 
 #define MAX_R 64
 
-typedef struct {
+typedef struct DeshakeContext {
     const AVClass *class;
     int counts[2*MAX_R+1][2*MAX_R+1]; /// < Scratch buffer for motion search
     double *angles;            ///< Scratch buffer for block angles
diff --git a/mythtv/external/FFmpeg/libavfilter/deshake_opencl.c b/mythtv/external/FFmpeg/libavfilter/deshake_opencl.c
index 91ae7d5859b..877ec1dc03f 100644
--- a/mythtv/external/FFmpeg/libavfilter/deshake_opencl.c
+++ b/mythtv/external/FFmpeg/libavfilter/deshake_opencl.c
@@ -194,7 +194,5 @@ int ff_opencl_deshake_process_inout_buf(AVFilterContext *ctx, AVFrame *in, AVFra
                                  deshake->opencl_ctx.cl_inbuf_size,
                                  0, in->data,deshake->opencl_ctx.in_plane_size,
                                  deshake->opencl_ctx.plane_num);
-    if(ret < 0)
-        return ret;
     return ret;
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/deshake_opencl.h b/mythtv/external/FFmpeg/libavfilter/deshake_opencl.h
index 5b0a2414b82..f3d96dc4e90 100644
--- a/mythtv/external/FFmpeg/libavfilter/deshake_opencl.h
+++ b/mythtv/external/FFmpeg/libavfilter/deshake_opencl.h
@@ -23,7 +23,7 @@
 
 #include "deshake.h"
 
-typedef struct {
+typedef struct float4 {
     float x;
     float y;
     float z;
diff --git a/mythtv/external/FFmpeg/libavfilter/drawutils.c b/mythtv/external/FFmpeg/libavfilter/drawutils.c
index f19fc5df1d4..77ab86b7754 100644
--- a/mythtv/external/FFmpeg/libavfilter/drawutils.c
+++ b/mythtv/external/FFmpeg/libavfilter/drawutils.c
@@ -64,6 +64,8 @@ int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
     case AV_PIX_FMT_GBRP16LE:
     case AV_PIX_FMT_GBRP16BE:
     case AV_PIX_FMT_GBRAP:
+    case AV_PIX_FMT_GBRAP10LE:
+    case AV_PIX_FMT_GBRAP10BE:
     case AV_PIX_FMT_GBRAP12LE:
     case AV_PIX_FMT_GBRAP12BE:
     case AV_PIX_FMT_GBRAP16LE:
@@ -260,14 +262,16 @@ void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4
         EXPAND(2);
         EXPAND(1);
         EXPAND(0);
-    } else if (draw->format == AV_PIX_FMT_GRAY8 || draw->format == AV_PIX_FMT_GRAY8A) {
-        color->comp[0].u8[0] = RGB_TO_Y_CCIR(rgba[0], rgba[1], rgba[2]);
-        color->comp[1].u8[0] = rgba[3];
-    } else if (draw->format == AV_PIX_FMT_GRAY16LE || draw->format == AV_PIX_FMT_YA16LE) {
+    } else if (draw->format == AV_PIX_FMT_GRAY8 || draw->format == AV_PIX_FMT_GRAY8A ||
+               draw->format == AV_PIX_FMT_GRAY16LE || draw->format == AV_PIX_FMT_YA16LE ||
+               draw->format == AV_PIX_FMT_GRAY9LE  ||
+               draw->format == AV_PIX_FMT_GRAY10LE ||
+               draw->format == AV_PIX_FMT_GRAY12LE) {
+        const AVPixFmtDescriptor *desc = draw->desc;
         color->comp[0].u8[0] = RGB_TO_Y_CCIR(rgba[0], rgba[1], rgba[2]);
-        color->comp[0].u16[0] = color->comp[0].u8[0] << 8;
+        EXPAND(0);
         color->comp[1].u8[0] = rgba[3];
-        color->comp[1].u16[0] = color->comp[1].u8[0] << 8;
+        EXPAND(1);
     } else {
         av_log(NULL, AV_LOG_WARNING,
                "Color conversion not implemented for %s\n", draw->desc->name);
diff --git a/mythtv/external/FFmpeg/libavfilter/dualinput.c b/mythtv/external/FFmpeg/libavfilter/dualinput.c
deleted file mode 100644
index 44750973a60..00000000000
--- a/mythtv/external/FFmpeg/libavfilter/dualinput.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * 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 "dualinput.h"
-#include "libavutil/timestamp.h"
-
-static int process_frame(FFFrameSync *fs)
-{
-    AVFilterContext *ctx = fs->parent;
-    FFDualInputContext *s = fs->opaque;
-    AVFrame *mainpic = NULL, *secondpic = NULL;
-    int ret = 0;
-
-    if ((ret = ff_framesync_get_frame(&s->fs, 0, &mainpic,   1)) < 0 ||
-        (ret = ff_framesync_get_frame(&s->fs, 1, &secondpic, 0)) < 0) {
-        av_frame_free(&mainpic);
-        return ret;
-    }
-    av_assert0(mainpic);
-    mainpic->pts = av_rescale_q(s->fs.pts, s->fs.time_base, ctx->outputs[0]->time_base);
-    if (secondpic && !ctx->is_disabled)
-        mainpic = s->process(ctx, mainpic, secondpic);
-    ret = ff_filter_frame(ctx->outputs[0], mainpic);
-    av_assert1(ret != AVERROR(EAGAIN));
-    return ret;
-}
-
-int ff_dualinput_init(AVFilterContext *ctx, FFDualInputContext *s)
-{
-    FFFrameSyncIn *in;
-    int ret;
-
-    if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)
-        return ret;
-
-    in = s->fs.in;
-    s->fs.opaque = s;
-    s->fs.on_event = process_frame;
-    in[0].time_base = ctx->inputs[0]->time_base;
-    in[1].time_base = ctx->inputs[1]->time_base;
-    in[0].sync   = 2;
-    in[0].before = EXT_STOP;
-    in[0].after  = EXT_INFINITY;
-    in[1].sync   = 1;
-    in[1].before = EXT_NULL;
-    in[1].after  = EXT_INFINITY;
-
-    if (s->shortest)
-        in[0].after = in[1].after = EXT_STOP;
-    if (!s->repeatlast) {
-        in[1].after = EXT_NULL;
-        in[1].sync  = 0;
-    }
-    if (s->skip_initial_unpaired) {
-        in[1].before = EXT_STOP;
-    }
-
-    return ff_framesync_configure(&s->fs);
-}
-
-int ff_dualinput_filter_frame(FFDualInputContext *s,
-                                   AVFilterLink *inlink, AVFrame *in)
-{
-    return ff_framesync_filter_frame(&s->fs, inlink, in);
-}
-
-int ff_dualinput_request_frame(FFDualInputContext *s, AVFilterLink *outlink)
-{
-    return ff_framesync_request_frame(&s->fs, outlink);
-}
-
-void ff_dualinput_uninit(FFDualInputContext *s)
-{
-    ff_framesync_uninit(&s->fs);
-}
diff --git a/mythtv/external/FFmpeg/libavfilter/dualinput.h b/mythtv/external/FFmpeg/libavfilter/dualinput.h
deleted file mode 100644
index 707b10c3977..00000000000
--- a/mythtv/external/FFmpeg/libavfilter/dualinput.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * 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
- * Double input streams helper for filters
- */
-
-#ifndef AVFILTER_DUALINPUT_H
-#define AVFILTER_DUALINPUT_H
-
-#include <stdint.h>
-#include "bufferqueue.h"
-#include "framesync.h"
-#include "internal.h"
-
-typedef struct {
-    FFFrameSync fs;
-
-    AVFrame *(*process)(AVFilterContext *ctx, AVFrame *main, const AVFrame *second);
-    int shortest;               ///< terminate stream when the second input terminates
-    int repeatlast;             ///< repeat last second frame
-    int skip_initial_unpaired;  ///< Skip initial frames that do not have a 2nd input
-} FFDualInputContext;
-
-int ff_dualinput_init(AVFilterContext *ctx, FFDualInputContext *s);
-int ff_dualinput_filter_frame(FFDualInputContext *s, AVFilterLink *inlink, AVFrame *in);
-int ff_dualinput_request_frame(FFDualInputContext *s, AVFilterLink *outlink);
-void ff_dualinput_uninit(FFDualInputContext *s);
-
-#endif /* AVFILTER_DUALINPUT_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/ebur128.c b/mythtv/external/FFmpeg/libavfilter/ebur128.c
new file mode 100644
index 00000000000..e11008078d7
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/ebur128.c
@@ -0,0 +1,769 @@
+/*
+ * Copyright (c) 2011 Jan Kokemüller
+ *
+ * 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
+ *
+ * This file is based on libebur128 which is available at
+ * https://github.com/jiixyj/libebur128/
+ *
+ * Libebur128 has the following copyright:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+*/
+
+#include "ebur128.h"
+
+#include <float.h>
+#include <limits.h>
+#include <math.h>               /* You may have to define _USE_MATH_DEFINES if you use MSVC */
+
+#include "libavutil/common.h"
+#include "libavutil/mem.h"
+#include "libavutil/thread.h"
+
+#define CHECK_ERROR(condition, errorcode, goto_point)                          \
+    if ((condition)) {                                                         \
+        errcode = (errorcode);                                                 \
+        goto goto_point;                                                       \
+    }
+
+#define ALMOST_ZERO 0.000001
+
+#define RELATIVE_GATE         (-10.0)
+#define RELATIVE_GATE_FACTOR  pow(10.0, RELATIVE_GATE / 10.0)
+#define MINUS_20DB            pow(10.0, -20.0 / 10.0)
+
+struct FFEBUR128StateInternal {
+    /** Filtered audio data (used as ring buffer). */
+    double *audio_data;
+    /** Size of audio_data array. */
+    size_t audio_data_frames;
+    /** Current index for audio_data. */
+    size_t audio_data_index;
+    /** How many frames are needed for a gating block. Will correspond to 400ms
+     *  of audio at initialization, and 100ms after the first block (75% overlap
+     *  as specified in the 2011 revision of BS1770). */
+    unsigned long needed_frames;
+    /** The channel map. Has as many elements as there are channels. */
+    int *channel_map;
+    /** How many samples fit in 100ms (rounded). */
+    unsigned long samples_in_100ms;
+    /** BS.1770 filter coefficients (nominator). */
+    double b[5];
+    /** BS.1770 filter coefficients (denominator). */
+    double a[5];
+    /** BS.1770 filter state. */
+    double v[5][5];
+    /** Histograms, used to calculate LRA. */
+    unsigned long *block_energy_histogram;
+    unsigned long *short_term_block_energy_histogram;
+    /** Keeps track of when a new short term block is needed. */
+    size_t short_term_frame_counter;
+    /** Maximum sample peak, one per channel */
+    double *sample_peak;
+    /** The maximum window duration in ms. */
+    unsigned long window;
+    /** Data pointer array for interleaved data */
+    void **data_ptrs;
+};
+
+static AVOnce histogram_init = AV_ONCE_INIT;
+static DECLARE_ALIGNED(32, double, histogram_energies)[1000];
+static DECLARE_ALIGNED(32, double, histogram_energy_boundaries)[1001];
+
+static void ebur128_init_filter(FFEBUR128State * st)
+{
+    int i, j;
+
+    double f0 = 1681.974450955533;
+    double G = 3.999843853973347;
+    double Q = 0.7071752369554196;
+
+    double K = tan(M_PI * f0 / (double) st->samplerate);
+    double Vh = pow(10.0, G / 20.0);
+    double Vb = pow(Vh, 0.4996667741545416);
+
+    double pb[3] = { 0.0, 0.0, 0.0 };
+    double pa[3] = { 1.0, 0.0, 0.0 };
+    double rb[3] = { 1.0, -2.0, 1.0 };
+    double ra[3] = { 1.0, 0.0, 0.0 };
+
+    double a0 = 1.0 + K / Q + K * K;
+    pb[0] = (Vh + Vb * K / Q + K * K) / a0;
+    pb[1] = 2.0 * (K * K - Vh) / a0;
+    pb[2] = (Vh - Vb * K / Q + K * K) / a0;
+    pa[1] = 2.0 * (K * K - 1.0) / a0;
+    pa[2] = (1.0 - K / Q + K * K) / a0;
+
+    f0 = 38.13547087602444;
+    Q = 0.5003270373238773;
+    K = tan(M_PI * f0 / (double) st->samplerate);
+
+    ra[1] = 2.0 * (K * K - 1.0) / (1.0 + K / Q + K * K);
+    ra[2] = (1.0 - K / Q + K * K) / (1.0 + K / Q + K * K);
+
+    st->d->b[0] = pb[0] * rb[0];
+    st->d->b[1] = pb[0] * rb[1] + pb[1] * rb[0];
+    st->d->b[2] = pb[0] * rb[2] + pb[1] * rb[1] + pb[2] * rb[0];
+    st->d->b[3] = pb[1] * rb[2] + pb[2] * rb[1];
+    st->d->b[4] = pb[2] * rb[2];
+
+    st->d->a[0] = pa[0] * ra[0];
+    st->d->a[1] = pa[0] * ra[1] + pa[1] * ra[0];
+    st->d->a[2] = pa[0] * ra[2] + pa[1] * ra[1] + pa[2] * ra[0];
+    st->d->a[3] = pa[1] * ra[2] + pa[2] * ra[1];
+    st->d->a[4] = pa[2] * ra[2];
+
+    for (i = 0; i < 5; ++i) {
+        for (j = 0; j < 5; ++j) {
+            st->d->v[i][j] = 0.0;
+        }
+    }
+}
+
+static int ebur128_init_channel_map(FFEBUR128State * st)
+{
+    size_t i;
+    st->d->channel_map =
+        (int *) av_malloc_array(st->channels, sizeof(int));
+    if (!st->d->channel_map)
+        return AVERROR(ENOMEM);
+    if (st->channels == 4) {
+        st->d->channel_map[0] = FF_EBUR128_LEFT;
+        st->d->channel_map[1] = FF_EBUR128_RIGHT;
+        st->d->channel_map[2] = FF_EBUR128_LEFT_SURROUND;
+        st->d->channel_map[3] = FF_EBUR128_RIGHT_SURROUND;
+    } else if (st->channels == 5) {
+        st->d->channel_map[0] = FF_EBUR128_LEFT;
+        st->d->channel_map[1] = FF_EBUR128_RIGHT;
+        st->d->channel_map[2] = FF_EBUR128_CENTER;
+        st->d->channel_map[3] = FF_EBUR128_LEFT_SURROUND;
+        st->d->channel_map[4] = FF_EBUR128_RIGHT_SURROUND;
+    } else {
+        for (i = 0; i < st->channels; ++i) {
+            switch (i) {
+            case 0:
+                st->d->channel_map[i] = FF_EBUR128_LEFT;
+                break;
+            case 1:
+                st->d->channel_map[i] = FF_EBUR128_RIGHT;
+                break;
+            case 2:
+                st->d->channel_map[i] = FF_EBUR128_CENTER;
+                break;
+            case 3:
+                st->d->channel_map[i] = FF_EBUR128_UNUSED;
+                break;
+            case 4:
+                st->d->channel_map[i] = FF_EBUR128_LEFT_SURROUND;
+                break;
+            case 5:
+                st->d->channel_map[i] = FF_EBUR128_RIGHT_SURROUND;
+                break;
+            default:
+                st->d->channel_map[i] = FF_EBUR128_UNUSED;
+                break;
+            }
+        }
+    }
+    return 0;
+}
+
+static inline void init_histogram(void)
+{
+    int i;
+    /* initialize static constants */
+    histogram_energy_boundaries[0] = pow(10.0, (-70.0 + 0.691) / 10.0);
+    for (i = 0; i < 1000; ++i) {
+        histogram_energies[i] =
+            pow(10.0, ((double) i / 10.0 - 69.95 + 0.691) / 10.0);
+    }
+    for (i = 1; i < 1001; ++i) {
+        histogram_energy_boundaries[i] =
+            pow(10.0, ((double) i / 10.0 - 70.0 + 0.691) / 10.0);
+    }
+}
+
+FFEBUR128State *ff_ebur128_init(unsigned int channels,
+                                unsigned long samplerate,
+                                unsigned long window, int mode)
+{
+    int errcode;
+    FFEBUR128State *st;
+
+    st = (FFEBUR128State *) av_malloc(sizeof(FFEBUR128State));
+    CHECK_ERROR(!st, 0, exit)
+    st->d = (struct FFEBUR128StateInternal *)
+        av_malloc(sizeof(struct FFEBUR128StateInternal));
+    CHECK_ERROR(!st->d, 0, free_state)
+    st->channels = channels;
+    errcode = ebur128_init_channel_map(st);
+    CHECK_ERROR(errcode, 0, free_internal)
+
+    st->d->sample_peak =
+        (double *) av_mallocz_array(channels, sizeof(double));
+    CHECK_ERROR(!st->d->sample_peak, 0, free_channel_map)
+
+    st->samplerate = samplerate;
+    st->d->samples_in_100ms = (st->samplerate + 5) / 10;
+    st->mode = mode;
+    if ((mode & FF_EBUR128_MODE_S) == FF_EBUR128_MODE_S) {
+        st->d->window = FFMAX(window, 3000);
+    } else if ((mode & FF_EBUR128_MODE_M) == FF_EBUR128_MODE_M) {
+        st->d->window = FFMAX(window, 400);
+    } else {
+        goto free_sample_peak;
+    }
+    st->d->audio_data_frames = st->samplerate * st->d->window / 1000;
+    if (st->d->audio_data_frames % st->d->samples_in_100ms) {
+        /* round up to multiple of samples_in_100ms */
+        st->d->audio_data_frames = st->d->audio_data_frames
+            + st->d->samples_in_100ms
+            - (st->d->audio_data_frames % st->d->samples_in_100ms);
+    }
+    st->d->audio_data =
+        (double *) av_mallocz_array(st->d->audio_data_frames,
+                                    st->channels * sizeof(double));
+    CHECK_ERROR(!st->d->audio_data, 0, free_sample_peak)
+
+    ebur128_init_filter(st);
+
+    st->d->block_energy_histogram =
+        av_mallocz(1000 * sizeof(unsigned long));
+    CHECK_ERROR(!st->d->block_energy_histogram, 0, free_audio_data)
+    st->d->short_term_block_energy_histogram =
+        av_mallocz(1000 * sizeof(unsigned long));
+    CHECK_ERROR(!st->d->short_term_block_energy_histogram, 0,
+                free_block_energy_histogram)
+    st->d->short_term_frame_counter = 0;
+
+    /* the first block needs 400ms of audio data */
+    st->d->needed_frames = st->d->samples_in_100ms * 4;
+    /* start at the beginning of the buffer */
+    st->d->audio_data_index = 0;
+
+    if (ff_thread_once(&histogram_init, &init_histogram) != 0)
+        goto free_short_term_block_energy_histogram;
+
+    st->d->data_ptrs = av_malloc_array(channels, sizeof(void *));
+    CHECK_ERROR(!st->d->data_ptrs, 0,
+                free_short_term_block_energy_histogram);
+
+    return st;
+
+free_short_term_block_energy_histogram:
+    av_free(st->d->short_term_block_energy_histogram);
+free_block_energy_histogram:
+    av_free(st->d->block_energy_histogram);
+free_audio_data:
+    av_free(st->d->audio_data);
+free_sample_peak:
+    av_free(st->d->sample_peak);
+free_channel_map:
+    av_free(st->d->channel_map);
+free_internal:
+    av_free(st->d);
+free_state:
+    av_free(st);
+exit:
+    return NULL;
+}
+
+void ff_ebur128_destroy(FFEBUR128State ** st)
+{
+    av_free((*st)->d->block_energy_histogram);
+    av_free((*st)->d->short_term_block_energy_histogram);
+    av_free((*st)->d->audio_data);
+    av_free((*st)->d->channel_map);
+    av_free((*st)->d->sample_peak);
+    av_free((*st)->d->data_ptrs);
+    av_free((*st)->d);
+    av_free(*st);
+    *st = NULL;
+}
+
+#define EBUR128_FILTER(type, scaling_factor)                                       \
+static void ebur128_filter_##type(FFEBUR128State* st, const type** srcs,           \
+                                  size_t src_index, size_t frames,                 \
+                                  int stride) {                                    \
+    double* audio_data = st->d->audio_data + st->d->audio_data_index;              \
+    size_t i, c;                                                                   \
+                                                                                   \
+    if ((st->mode & FF_EBUR128_MODE_SAMPLE_PEAK) == FF_EBUR128_MODE_SAMPLE_PEAK) { \
+        for (c = 0; c < st->channels; ++c) {                                       \
+            double max = 0.0;                                                      \
+            for (i = 0; i < frames; ++i) {                                         \
+                type v = srcs[c][src_index + i * stride];                          \
+                if (v > max) {                                                     \
+                    max =        v;                                                \
+                } else if (-v > max) {                                             \
+                    max = -1.0 * v;                                                \
+                }                                                                  \
+            }                                                                      \
+            max /= scaling_factor;                                                 \
+            if (max > st->d->sample_peak[c]) st->d->sample_peak[c] = max;          \
+        }                                                                          \
+    }                                                                              \
+    for (c = 0; c < st->channels; ++c) {                                           \
+        int ci = st->d->channel_map[c] - 1;                                        \
+        if (ci < 0) continue;                                                      \
+        else if (ci == FF_EBUR128_DUAL_MONO - 1) ci = 0; /*dual mono */            \
+        for (i = 0; i < frames; ++i) {                                             \
+            st->d->v[ci][0] = (double) (srcs[c][src_index + i * stride] / scaling_factor) \
+                         - st->d->a[1] * st->d->v[ci][1]                           \
+                         - st->d->a[2] * st->d->v[ci][2]                           \
+                         - st->d->a[3] * st->d->v[ci][3]                           \
+                         - st->d->a[4] * st->d->v[ci][4];                          \
+            audio_data[i * st->channels + c] =                                     \
+                           st->d->b[0] * st->d->v[ci][0]                           \
+                         + st->d->b[1] * st->d->v[ci][1]                           \
+                         + st->d->b[2] * st->d->v[ci][2]                           \
+                         + st->d->b[3] * st->d->v[ci][3]                           \
+                         + st->d->b[4] * st->d->v[ci][4];                          \
+            st->d->v[ci][4] = st->d->v[ci][3];                                     \
+            st->d->v[ci][3] = st->d->v[ci][2];                                     \
+            st->d->v[ci][2] = st->d->v[ci][1];                                     \
+            st->d->v[ci][1] = st->d->v[ci][0];                                     \
+        }                                                                          \
+        st->d->v[ci][4] = fabs(st->d->v[ci][4]) < DBL_MIN ? 0.0 : st->d->v[ci][4]; \
+        st->d->v[ci][3] = fabs(st->d->v[ci][3]) < DBL_MIN ? 0.0 : st->d->v[ci][3]; \
+        st->d->v[ci][2] = fabs(st->d->v[ci][2]) < DBL_MIN ? 0.0 : st->d->v[ci][2]; \
+        st->d->v[ci][1] = fabs(st->d->v[ci][1]) < DBL_MIN ? 0.0 : st->d->v[ci][1]; \
+    }                                                                              \
+}
+EBUR128_FILTER(short, -((double)SHRT_MIN))
+EBUR128_FILTER(int, -((double)INT_MIN))
+EBUR128_FILTER(float,  1.0)
+EBUR128_FILTER(double, 1.0)
+
+static double ebur128_energy_to_loudness(double energy)
+{
+    return 10 * (log(energy) / log(10.0)) - 0.691;
+}
+
+static size_t find_histogram_index(double energy)
+{
+    size_t index_min = 0;
+    size_t index_max = 1000;
+    size_t index_mid;
+
+    do {
+        index_mid = (index_min + index_max) / 2;
+        if (energy >= histogram_energy_boundaries[index_mid]) {
+            index_min = index_mid;
+        } else {
+            index_max = index_mid;
+        }
+    } while (index_max - index_min != 1);
+
+    return index_min;
+}
+
+static void ebur128_calc_gating_block(FFEBUR128State * st,
+                                      size_t frames_per_block,
+                                      double *optional_output)
+{
+    size_t i, c;
+    double sum = 0.0;
+    double channel_sum;
+    for (c = 0; c < st->channels; ++c) {
+        if (st->d->channel_map[c] == FF_EBUR128_UNUSED)
+            continue;
+        channel_sum = 0.0;
+        if (st->d->audio_data_index < frames_per_block * st->channels) {
+            for (i = 0; i < st->d->audio_data_index / st->channels; ++i) {
+                channel_sum += st->d->audio_data[i * st->channels + c] *
+                    st->d->audio_data[i * st->channels + c];
+            }
+            for (i = st->d->audio_data_frames -
+                 (frames_per_block -
+                  st->d->audio_data_index / st->channels);
+                 i < st->d->audio_data_frames; ++i) {
+                channel_sum += st->d->audio_data[i * st->channels + c] *
+                    st->d->audio_data[i * st->channels + c];
+            }
+        } else {
+            for (i =
+                 st->d->audio_data_index / st->channels - frames_per_block;
+                 i < st->d->audio_data_index / st->channels; ++i) {
+                channel_sum +=
+                    st->d->audio_data[i * st->channels +
+                                      c] * st->d->audio_data[i *
+                                                             st->channels +
+                                                             c];
+            }
+        }
+        if (st->d->channel_map[c] == FF_EBUR128_Mp110 ||
+            st->d->channel_map[c] == FF_EBUR128_Mm110 ||
+            st->d->channel_map[c] == FF_EBUR128_Mp060 ||
+            st->d->channel_map[c] == FF_EBUR128_Mm060 ||
+            st->d->channel_map[c] == FF_EBUR128_Mp090 ||
+            st->d->channel_map[c] == FF_EBUR128_Mm090) {
+            channel_sum *= 1.41;
+        } else if (st->d->channel_map[c] == FF_EBUR128_DUAL_MONO) {
+            channel_sum *= 2.0;
+        }
+        sum += channel_sum;
+    }
+    sum /= (double) frames_per_block;
+    if (optional_output) {
+        *optional_output = sum;
+    } else if (sum >= histogram_energy_boundaries[0]) {
+        ++st->d->block_energy_histogram[find_histogram_index(sum)];
+    }
+}
+
+int ff_ebur128_set_channel(FFEBUR128State * st,
+                           unsigned int channel_number, int value)
+{
+    if (channel_number >= st->channels) {
+        return 1;
+    }
+    if (value == FF_EBUR128_DUAL_MONO &&
+        (st->channels != 1 || channel_number != 0)) {
+        return 1;
+    }
+    st->d->channel_map[channel_number] = value;
+    return 0;
+}
+
+static int ebur128_energy_shortterm(FFEBUR128State * st, double *out);
+#define FF_EBUR128_ADD_FRAMES_PLANAR(type)                                             \
+void ff_ebur128_add_frames_planar_##type(FFEBUR128State* st, const type** srcs,        \
+                                 size_t frames, int stride) {                          \
+    size_t src_index = 0;                                                              \
+    while (frames > 0) {                                                               \
+        if (frames >= st->d->needed_frames) {                                          \
+            ebur128_filter_##type(st, srcs, src_index, st->d->needed_frames, stride);  \
+            src_index += st->d->needed_frames * stride;                                \
+            frames -= st->d->needed_frames;                                            \
+            st->d->audio_data_index += st->d->needed_frames * st->channels;            \
+            /* calculate the new gating block */                                       \
+            if ((st->mode & FF_EBUR128_MODE_I) == FF_EBUR128_MODE_I) {                 \
+                ebur128_calc_gating_block(st, st->d->samples_in_100ms * 4, NULL);      \
+            }                                                                          \
+            if ((st->mode & FF_EBUR128_MODE_LRA) == FF_EBUR128_MODE_LRA) {             \
+                st->d->short_term_frame_counter += st->d->needed_frames;               \
+                if (st->d->short_term_frame_counter == st->d->samples_in_100ms * 30) { \
+                    double st_energy;                                                  \
+                    ebur128_energy_shortterm(st, &st_energy);                          \
+                    if (st_energy >= histogram_energy_boundaries[0]) {                 \
+                        ++st->d->short_term_block_energy_histogram[                    \
+                                                    find_histogram_index(st_energy)];  \
+                    }                                                                  \
+                    st->d->short_term_frame_counter = st->d->samples_in_100ms * 20;    \
+                }                                                                      \
+            }                                                                          \
+            /* 100ms are needed for all blocks besides the first one */                \
+            st->d->needed_frames = st->d->samples_in_100ms;                            \
+            /* reset audio_data_index when buffer full */                              \
+            if (st->d->audio_data_index == st->d->audio_data_frames * st->channels) {  \
+                st->d->audio_data_index = 0;                                           \
+            }                                                                          \
+        } else {                                                                       \
+            ebur128_filter_##type(st, srcs, src_index, frames, stride);                \
+            st->d->audio_data_index += frames * st->channels;                          \
+            if ((st->mode & FF_EBUR128_MODE_LRA) == FF_EBUR128_MODE_LRA) {             \
+                st->d->short_term_frame_counter += frames;                             \
+            }                                                                          \
+            st->d->needed_frames -= frames;                                            \
+            frames = 0;                                                                \
+        }                                                                              \
+    }                                                                                  \
+}
+FF_EBUR128_ADD_FRAMES_PLANAR(short)
+FF_EBUR128_ADD_FRAMES_PLANAR(int)
+FF_EBUR128_ADD_FRAMES_PLANAR(float)
+FF_EBUR128_ADD_FRAMES_PLANAR(double)
+#define FF_EBUR128_ADD_FRAMES(type)                                            \
+void ff_ebur128_add_frames_##type(FFEBUR128State* st, const type* src,         \
+                                    size_t frames) {                           \
+  int i;                                                                       \
+  const type **buf = (const type**)st->d->data_ptrs;                           \
+  for (i = 0; i < st->channels; i++)                                           \
+    buf[i] = src + i;                                                          \
+  ff_ebur128_add_frames_planar_##type(st, buf, frames, st->channels);          \
+}
+FF_EBUR128_ADD_FRAMES(short)
+FF_EBUR128_ADD_FRAMES(int)
+FF_EBUR128_ADD_FRAMES(float)
+FF_EBUR128_ADD_FRAMES(double)
+
+static int ebur128_calc_relative_threshold(FFEBUR128State **sts, size_t size,
+                                           double *relative_threshold)
+{
+    size_t i, j;
+    int above_thresh_counter = 0;
+    *relative_threshold = 0.0;
+
+    for (i = 0; i < size; i++) {
+        unsigned long *block_energy_histogram = sts[i]->d->block_energy_histogram;
+        for (j = 0; j < 1000; ++j) {
+            *relative_threshold += block_energy_histogram[j] * histogram_energies[j];
+            above_thresh_counter += block_energy_histogram[j];
+        }
+    }
+
+    if (above_thresh_counter != 0) {
+        *relative_threshold /= (double)above_thresh_counter;
+        *relative_threshold *= RELATIVE_GATE_FACTOR;
+    }
+
+    return above_thresh_counter;
+}
+
+static int ebur128_gated_loudness(FFEBUR128State ** sts, size_t size,
+                                  double *out)
+{
+    double gated_loudness = 0.0;
+    double relative_threshold;
+    size_t above_thresh_counter;
+    size_t i, j, start_index;
+
+    for (i = 0; i < size; i++)
+        if ((sts[i]->mode & FF_EBUR128_MODE_I) != FF_EBUR128_MODE_I)
+            return AVERROR(EINVAL);
+
+    if (!ebur128_calc_relative_threshold(sts, size, &relative_threshold)) {
+        *out = -HUGE_VAL;
+        return 0;
+    }
+
+    above_thresh_counter = 0;
+    if (relative_threshold < histogram_energy_boundaries[0]) {
+        start_index = 0;
+    } else {
+        start_index = find_histogram_index(relative_threshold);
+        if (relative_threshold > histogram_energies[start_index]) {
+            ++start_index;
+        }
+    }
+    for (i = 0; i < size; i++) {
+        for (j = start_index; j < 1000; ++j) {
+            gated_loudness += sts[i]->d->block_energy_histogram[j] *
+                histogram_energies[j];
+            above_thresh_counter += sts[i]->d->block_energy_histogram[j];
+        }
+    }
+    if (!above_thresh_counter) {
+        *out = -HUGE_VAL;
+        return 0;
+    }
+    gated_loudness /= (double) above_thresh_counter;
+    *out = ebur128_energy_to_loudness(gated_loudness);
+    return 0;
+}
+
+int ff_ebur128_relative_threshold(FFEBUR128State * st, double *out)
+{
+    double relative_threshold;
+
+    if ((st->mode & FF_EBUR128_MODE_I) != FF_EBUR128_MODE_I)
+        return AVERROR(EINVAL);
+
+    if (!ebur128_calc_relative_threshold(&st, 1, &relative_threshold)) {
+        *out = -70.0;
+        return 0;
+    }
+
+    *out = ebur128_energy_to_loudness(relative_threshold);
+    return 0;
+}
+
+int ff_ebur128_loudness_global(FFEBUR128State * st, double *out)
+{
+    return ebur128_gated_loudness(&st, 1, out);
+}
+
+int ff_ebur128_loudness_global_multiple(FFEBUR128State ** sts, size_t size,
+                                        double *out)
+{
+    return ebur128_gated_loudness(sts, size, out);
+}
+
+static int ebur128_energy_in_interval(FFEBUR128State * st,
+                                      size_t interval_frames, double *out)
+{
+    if (interval_frames > st->d->audio_data_frames) {
+        return AVERROR(EINVAL);
+    }
+    ebur128_calc_gating_block(st, interval_frames, out);
+    return 0;
+}
+
+static int ebur128_energy_shortterm(FFEBUR128State * st, double *out)
+{
+    return ebur128_energy_in_interval(st, st->d->samples_in_100ms * 30,
+                                      out);
+}
+
+int ff_ebur128_loudness_momentary(FFEBUR128State * st, double *out)
+{
+    double energy;
+    int error = ebur128_energy_in_interval(st, st->d->samples_in_100ms * 4,
+                                           &energy);
+    if (error) {
+        return error;
+    } else if (energy <= 0.0) {
+        *out = -HUGE_VAL;
+        return 0;
+    }
+    *out = ebur128_energy_to_loudness(energy);
+    return 0;
+}
+
+int ff_ebur128_loudness_shortterm(FFEBUR128State * st, double *out)
+{
+    double energy;
+    int error = ebur128_energy_shortterm(st, &energy);
+    if (error) {
+        return error;
+    } else if (energy <= 0.0) {
+        *out = -HUGE_VAL;
+        return 0;
+    }
+    *out = ebur128_energy_to_loudness(energy);
+    return 0;
+}
+
+int ff_ebur128_loudness_window(FFEBUR128State * st,
+                               unsigned long window, double *out)
+{
+    double energy;
+    size_t interval_frames = st->samplerate * window / 1000;
+    int error = ebur128_energy_in_interval(st, interval_frames, &energy);
+    if (error) {
+        return error;
+    } else if (energy <= 0.0) {
+        *out = -HUGE_VAL;
+        return 0;
+    }
+    *out = ebur128_energy_to_loudness(energy);
+    return 0;
+}
+
+/* EBU - TECH 3342 */
+int ff_ebur128_loudness_range_multiple(FFEBUR128State ** sts, size_t size,
+                                       double *out)
+{
+    size_t i, j;
+    size_t stl_size;
+    double stl_power, stl_integrated;
+    /* High and low percentile energy */
+    double h_en, l_en;
+    unsigned long hist[1000] = { 0 };
+    size_t percentile_low, percentile_high;
+    size_t index;
+
+    for (i = 0; i < size; ++i) {
+        if (sts[i]) {
+            if ((sts[i]->mode & FF_EBUR128_MODE_LRA) !=
+                FF_EBUR128_MODE_LRA) {
+                return AVERROR(EINVAL);
+            }
+        }
+    }
+
+    stl_size = 0;
+    stl_power = 0.0;
+    for (i = 0; i < size; ++i) {
+        if (!sts[i])
+            continue;
+        for (j = 0; j < 1000; ++j) {
+            hist[j] += sts[i]->d->short_term_block_energy_histogram[j];
+            stl_size += sts[i]->d->short_term_block_energy_histogram[j];
+            stl_power += sts[i]->d->short_term_block_energy_histogram[j]
+                * histogram_energies[j];
+        }
+    }
+    if (!stl_size) {
+        *out = 0.0;
+        return 0;
+    }
+
+    stl_power /= stl_size;
+    stl_integrated = MINUS_20DB * stl_power;
+
+    if (stl_integrated < histogram_energy_boundaries[0]) {
+        index = 0;
+    } else {
+        index = find_histogram_index(stl_integrated);
+        if (stl_integrated > histogram_energies[index]) {
+            ++index;
+        }
+    }
+    stl_size = 0;
+    for (j = index; j < 1000; ++j) {
+        stl_size += hist[j];
+    }
+    if (!stl_size) {
+        *out = 0.0;
+        return 0;
+    }
+
+    percentile_low = (size_t) ((stl_size - 1) * 0.1 + 0.5);
+    percentile_high = (size_t) ((stl_size - 1) * 0.95 + 0.5);
+
+    stl_size = 0;
+    j = index;
+    while (stl_size <= percentile_low) {
+        stl_size += hist[j++];
+    }
+    l_en = histogram_energies[j - 1];
+    while (stl_size <= percentile_high) {
+        stl_size += hist[j++];
+    }
+    h_en = histogram_energies[j - 1];
+    *out =
+        ebur128_energy_to_loudness(h_en) -
+        ebur128_energy_to_loudness(l_en);
+    return 0;
+}
+
+int ff_ebur128_loudness_range(FFEBUR128State * st, double *out)
+{
+    return ff_ebur128_loudness_range_multiple(&st, 1, out);
+}
+
+int ff_ebur128_sample_peak(FFEBUR128State * st,
+                           unsigned int channel_number, double *out)
+{
+    if ((st->mode & FF_EBUR128_MODE_SAMPLE_PEAK) !=
+        FF_EBUR128_MODE_SAMPLE_PEAK) {
+        return AVERROR(EINVAL);
+    } else if (channel_number >= st->channels) {
+        return AVERROR(EINVAL);
+    }
+    *out = st->d->sample_peak[channel_number];
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavfilter/ebur128.h b/mythtv/external/FFmpeg/libavfilter/ebur128.h
new file mode 100644
index 00000000000..74367545e8c
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/ebur128.h
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2011 Jan Kokemüller
+ *
+ * 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
+ *
+ * This file is based on libebur128 which is available at
+ * https://github.com/jiixyj/libebur128/
+ *
+*/
+
+#ifndef AVFILTER_EBUR128_H
+#define AVFILTER_EBUR128_H
+
+/** \file ebur128.h
+ *  \brief libebur128 - a library for loudness measurement according to
+ *         the EBU R128 standard.
+ */
+
+#include <stddef.h>             /* for size_t */
+
+/** \enum channel
+ *  Use these values when setting the channel map with ebur128_set_channel().
+ *  See definitions in ITU R-REC-BS 1770-4
+ */
+enum channel {
+    FF_EBUR128_UNUSED = 0,   /**< unused channel (for example LFE channel) */
+    FF_EBUR128_LEFT,
+    FF_EBUR128_Mp030 = 1,    /**< itu M+030 */
+    FF_EBUR128_RIGHT,
+    FF_EBUR128_Mm030 = 2,    /**< itu M-030 */
+    FF_EBUR128_CENTER,
+    FF_EBUR128_Mp000 = 3,    /**< itu M+000 */
+    FF_EBUR128_LEFT_SURROUND,
+    FF_EBUR128_Mp110 = 4,    /**< itu M+110 */
+    FF_EBUR128_RIGHT_SURROUND,
+    FF_EBUR128_Mm110 = 5,    /**< itu M-110 */
+    FF_EBUR128_DUAL_MONO,    /**< a channel that is counted twice */
+    FF_EBUR128_MpSC,         /**< itu M+SC */
+    FF_EBUR128_MmSC,         /**< itu M-SC */
+    FF_EBUR128_Mp060,        /**< itu M+060 */
+    FF_EBUR128_Mm060,        /**< itu M-060 */
+    FF_EBUR128_Mp090,        /**< itu M+090 */
+    FF_EBUR128_Mm090,        /**< itu M-090 */
+    FF_EBUR128_Mp135,        /**< itu M+135 */
+    FF_EBUR128_Mm135,        /**< itu M-135 */
+    FF_EBUR128_Mp180,        /**< itu M+180 */
+    FF_EBUR128_Up000,        /**< itu U+000 */
+    FF_EBUR128_Up030,        /**< itu U+030 */
+    FF_EBUR128_Um030,        /**< itu U-030 */
+    FF_EBUR128_Up045,        /**< itu U+045 */
+    FF_EBUR128_Um045,        /**< itu U-030 */
+    FF_EBUR128_Up090,        /**< itu U+090 */
+    FF_EBUR128_Um090,        /**< itu U-090 */
+    FF_EBUR128_Up110,        /**< itu U+110 */
+    FF_EBUR128_Um110,        /**< itu U-110 */
+    FF_EBUR128_Up135,        /**< itu U+135 */
+    FF_EBUR128_Um135,        /**< itu U-135 */
+    FF_EBUR128_Up180,        /**< itu U+180 */
+    FF_EBUR128_Tp000,        /**< itu T+000 */
+    FF_EBUR128_Bp000,        /**< itu B+000 */
+    FF_EBUR128_Bp045,        /**< itu B+045 */
+    FF_EBUR128_Bm045         /**< itu B-045 */
+};
+
+/** \enum mode
+ *  Use these values in ebur128_init (or'ed). Try to use the lowest possible
+ *  modes that suit your needs, as performance will be better.
+ */
+enum mode {
+  /** can call ff_ebur128_loudness_momentary */
+    FF_EBUR128_MODE_M = (1 << 0),
+  /** can call ff_ebur128_loudness_shortterm */
+    FF_EBUR128_MODE_S = (1 << 1) | FF_EBUR128_MODE_M,
+  /** can call ff_ebur128_loudness_global_* and ff_ebur128_relative_threshold */
+    FF_EBUR128_MODE_I = (1 << 2) | FF_EBUR128_MODE_M,
+  /** can call ff_ebur128_loudness_range */
+    FF_EBUR128_MODE_LRA = (1 << 3) | FF_EBUR128_MODE_S,
+  /** can call ff_ebur128_sample_peak */
+    FF_EBUR128_MODE_SAMPLE_PEAK = (1 << 4) | FF_EBUR128_MODE_M,
+};
+
+/** forward declaration of FFEBUR128StateInternal */
+struct FFEBUR128StateInternal;
+
+/** \brief Contains information about the state of a loudness measurement.
+ *
+ *  You should not need to modify this struct directly.
+ */
+typedef struct FFEBUR128State {
+    int mode;                         /**< The current mode. */
+    unsigned int channels;            /**< The number of channels. */
+    unsigned long samplerate;         /**< The sample rate. */
+    struct FFEBUR128StateInternal *d; /**< Internal state. */
+} FFEBUR128State;
+
+/** \brief Initialize library state.
+ *
+ *  @param channels the number of channels.
+ *  @param samplerate the sample rate.
+ *  @param window set the maximum window size in ms, set to 0 for auto.
+ *  @param mode see the mode enum for possible values.
+ *  @return an initialized library state.
+ */
+FFEBUR128State *ff_ebur128_init(unsigned int channels,
+                                unsigned long samplerate,
+                                unsigned long window, int mode);
+
+/** \brief Destroy library state.
+ *
+ *  @param st pointer to a library state.
+ */
+void ff_ebur128_destroy(FFEBUR128State ** st);
+
+/** \brief Set channel type.
+ *
+ *  The default is:
+ *  - 0 -> FF_EBUR128_LEFT
+ *  - 1 -> FF_EBUR128_RIGHT
+ *  - 2 -> FF_EBUR128_CENTER
+ *  - 3 -> FF_EBUR128_UNUSED
+ *  - 4 -> FF_EBUR128_LEFT_SURROUND
+ *  - 5 -> FF_EBUR128_RIGHT_SURROUND
+ *
+ *  @param st library state.
+ *  @param channel_number zero based channel index.
+ *  @param value channel type from the "channel" enum.
+ *  @return
+ *    - 0 on success.
+ *    - AVERROR(EINVAL) if invalid channel index.
+ */
+int ff_ebur128_set_channel(FFEBUR128State * st,
+                           unsigned int channel_number, int value);
+
+/** \brief Add frames to be processed.
+ *
+ *  @param st library state.
+ *  @param src array of source frames. Channels must be interleaved.
+ *  @param frames number of frames. Not number of samples!
+ */
+void ff_ebur128_add_frames_short(FFEBUR128State * st,
+                                 const short *src, size_t frames);
+/** \brief See \ref ebur128_add_frames_short */
+void ff_ebur128_add_frames_int(FFEBUR128State * st,
+                               const int *src, size_t frames);
+/** \brief See \ref ebur128_add_frames_short */
+void ff_ebur128_add_frames_float(FFEBUR128State * st,
+                                 const float *src, size_t frames);
+/** \brief See \ref ebur128_add_frames_short */
+void ff_ebur128_add_frames_double(FFEBUR128State * st,
+                                  const double *src, size_t frames);
+
+/** \brief Add frames to be processed.
+ *
+ *  @param st library state.
+ *  @param srcs array of source frame channel data pointers
+ *  @param frames number of frames. Not number of samples!
+ *  @param stride number of samples to skip to for the next sample of the same channel
+ */
+void ff_ebur128_add_frames_planar_short(FFEBUR128State * st,
+                                        const short **srcs,
+                                        size_t frames, int stride);
+/** \brief See \ref ebur128_add_frames_planar_short */
+void ff_ebur128_add_frames_planar_int(FFEBUR128State * st,
+                                      const int **srcs,
+                                      size_t frames, int stride);
+/** \brief See \ref ebur128_add_frames_planar_short */
+void ff_ebur128_add_frames_planar_float(FFEBUR128State * st,
+                                        const float **srcs,
+                                        size_t frames, int stride);
+/** \brief See \ref ebur128_add_frames_planar_short */
+void ff_ebur128_add_frames_planar_double(FFEBUR128State * st,
+                                         const double **srcs,
+                                         size_t frames, int stride);
+
+/** \brief Get global integrated loudness in LUFS.
+ *
+ *  @param st library state.
+ *  @param out integrated loudness in LUFS. -HUGE_VAL if result is negative
+ *             infinity.
+ *  @return
+ *    - 0 on success.
+ *    - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_I" has not been set.
+ */
+int ff_ebur128_loudness_global(FFEBUR128State * st, double *out);
+/** \brief Get global integrated loudness in LUFS across multiple instances.
+ *
+ *  @param sts array of library states.
+ *  @param size length of sts
+ *  @param out integrated loudness in LUFS. -HUGE_VAL if result is negative
+ *             infinity.
+ *  @return
+ *    - 0 on success.
+ *    - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_I" has not been set.
+ */
+int ff_ebur128_loudness_global_multiple(FFEBUR128State ** sts,
+                                        size_t size, double *out);
+
+/** \brief Get momentary loudness (last 400ms) in LUFS.
+ *
+ *  @param st library state.
+ *  @param out momentary loudness in LUFS. -HUGE_VAL if result is negative
+ *             infinity.
+ *  @return
+ *    - 0 on success.
+ */
+int ff_ebur128_loudness_momentary(FFEBUR128State * st, double *out);
+/** \brief Get short-term loudness (last 3s) in LUFS.
+ *
+ *  @param st library state.
+ *  @param out short-term loudness in LUFS. -HUGE_VAL if result is negative
+ *             infinity.
+ *  @return
+ *    - 0 on success.
+ *    - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_S" has not been set.
+ */
+int ff_ebur128_loudness_shortterm(FFEBUR128State * st, double *out);
+
+/** \brief Get loudness of the specified window in LUFS.
+ *
+ *  window must not be larger than the current window set in st.
+ *
+ *  @param st library state.
+ *  @param window window in ms to calculate loudness.
+ *  @param out loudness in LUFS. -HUGE_VAL if result is negative infinity.
+ *  @return
+ *    - 0 on success.
+ *    - AVERROR(EINVAL) if window larger than current window in st.
+ */
+int ff_ebur128_loudness_window(FFEBUR128State * st,
+                               unsigned long window, double *out);
+
+/** \brief Get loudness range (LRA) of programme in LU.
+ *
+ *  Calculates loudness range according to EBU 3342.
+ *
+ *  @param st library state.
+ *  @param out loudness range (LRA) in LU. Will not be changed in case of
+ *             error. AVERROR(EINVAL) will be returned in this case.
+ *  @return
+ *    - 0 on success.
+ *    - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_LRA" has not been set.
+ */
+int ff_ebur128_loudness_range(FFEBUR128State * st, double *out);
+/** \brief Get loudness range (LRA) in LU across multiple instances.
+ *
+ *  Calculates loudness range according to EBU 3342.
+ *
+ *  @param sts array of library states.
+ *  @param size length of sts
+ *  @param out loudness range (LRA) in LU. Will not be changed in case of
+ *             error. AVERROR(EINVAL) will be returned in this case.
+ *  @return
+ *    - 0 on success.
+ *    - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_LRA" has not been set.
+ */
+int ff_ebur128_loudness_range_multiple(FFEBUR128State ** sts,
+                                       size_t size, double *out);
+
+/** \brief Get maximum sample peak of selected channel in float format.
+ *
+ *  @param st library state
+ *  @param channel_number channel to analyse
+ *  @param out maximum sample peak in float format (1.0 is 0 dBFS)
+ *  @return
+ *    - 0 on success.
+ *    - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_SAMPLE_PEAK" has not been set.
+ *    - AVERROR(EINVAL) if invalid channel index.
+ */
+int ff_ebur128_sample_peak(FFEBUR128State * st,
+                           unsigned int channel_number, double *out);
+
+/** \brief Get relative threshold in LUFS.
+ *
+ *  @param st library state
+ *  @param out relative threshold in LUFS.
+ *  @return
+ *    - 0 on success.
+ *    - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_I" has not been set.
+ */
+int ff_ebur128_relative_threshold(FFEBUR128State * st, double *out);
+
+#endif                          /* AVFILTER_EBUR128_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/f_bench.c b/mythtv/external/FFmpeg/libavfilter/f_bench.c
index b7b179209a4..f9e1006925a 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_bench.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_bench.c
@@ -28,7 +28,7 @@ enum BenchAction {
     NB_ACTION
 };
 
-typedef struct {
+typedef struct BenchContext {
     const AVClass *class;
     int action;
     int64_t max, min;
diff --git a/mythtv/external/FFmpeg/libavfilter/f_drawgraph.c b/mythtv/external/FFmpeg/libavfilter/f_drawgraph.c
index 4c705fe8511..8be9b9f95a5 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_drawgraph.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_drawgraph.c
@@ -200,7 +200,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         av_frame_copy_props(out, in);
     }
 
-    metadata = av_frame_get_metadata(in);
+    metadata = in->metadata;
 
     for (i = 0; i < 4; i++) {
         double values[VAR_VARS_NB];
diff --git a/mythtv/external/FFmpeg/libavfilter/f_ebur128.c b/mythtv/external/FFmpeg/libavfilter/f_ebur128.c
index 983c889017c..1e8b90fa2fa 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_ebur128.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_ebur128.c
@@ -3,19 +3,19 @@
  *
  * This file is part of FFmpeg.
  *
- * FFmpeg is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ * 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 General Public License for more details.
+ * 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 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.
+ * 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
  */
 
 /**
@@ -90,7 +90,7 @@ struct integrator {
 
 struct rect { int x, y, w, h; };
 
-typedef struct {
+typedef struct EBUR128Context {
     const AVClass *class;           ///< AVClass context for log and options purpose
 
     /* peak metering */
@@ -269,6 +269,7 @@ static int config_video_output(AVFilterLink *outlink)
     }
     outlink->w = ebur128->w;
     outlink->h = ebur128->h;
+    outlink->sample_aspect_ratio = (AVRational){1,1};
 
 #define PAD 8
 
@@ -299,7 +300,7 @@ static int config_video_output(AVFilterLink *outlink)
         ff_get_video_buffer(outlink, outlink->w, outlink->h);
     if (!outpicref)
         return AVERROR(ENOMEM);
-    outlink->sample_aspect_ratio = (AVRational){1,1};
+    outpicref->sample_aspect_ratio = (AVRational){1,1};
 
     /* init y references values (to draw LU lines) */
     ebur128->y_line_ref = av_calloc(ebur128->graph.h + 1, sizeof(*ebur128->y_line_ref));
diff --git a/mythtv/external/FFmpeg/libavfilter/f_interleave.c b/mythtv/external/FFmpeg/libavfilter/f_interleave.c
index 422f2bfb29b..d8a73b52e5d 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_interleave.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_interleave.c
@@ -26,6 +26,10 @@
 #include "libavutil/avassert.h"
 #include "libavutil/avstring.h"
 #include "libavutil/opt.h"
+
+#define FF_INTERNAL_FIELDS 1
+#include "framequeue.h"
+
 #include "avfilter.h"
 #include "bufferqueue.h"
 #include "formats.h"
@@ -33,7 +37,7 @@
 #include "audio.h"
 #include "video.h"
 
-typedef struct {
+typedef struct InterleaveContext {
     const AVClass *class;
     int nb_inputs;
     struct FFBufQueue *queues;
@@ -59,7 +63,7 @@ inline static int push_frame(AVFilterContext *ctx)
     for (i = 0; i < ctx->nb_inputs; i++) {
         struct FFBufQueue *q = &s->queues[i];
 
-        if (!q->available && !ctx->inputs[i]->status)
+        if (!q->available && !ctx->inputs[i]->status_out)
             return 0;
         if (q->available) {
             frame = ff_bufqueue_peek(q, 0);
@@ -106,7 +110,7 @@ static av_cold int init(AVFilterContext *ctx)
 {
     InterleaveContext *s = ctx->priv;
     const AVFilterPad *outpad = &ctx->filter->outputs[0];
-    int i;
+    int i, ret;
 
     s->queues = av_calloc(s->nb_inputs, sizeof(s->queues[0]));
     if (!s->queues)
@@ -129,7 +133,10 @@ static av_cold int init(AVFilterContext *ctx)
         default:
             av_assert0(0);
         }
-        ff_insert_inpad(ctx, i, &inpad);
+        if ((ret = ff_insert_inpad(ctx, i, &inpad)) < 0) {
+            av_freep(&inpad.name);
+            return ret;
+        }
     }
 
     return 0;
@@ -190,7 +197,7 @@ static int request_frame(AVFilterLink *outlink)
     int i, ret;
 
     for (i = 0; i < ctx->nb_inputs; i++) {
-        if (!s->queues[i].available && !ctx->inputs[i]->status) {
+        if (!s->queues[i].available && !ctx->inputs[i]->status_out) {
             ret = ff_request_frame(ctx->inputs[i]);
             if (ret != AVERROR_EOF)
                 return ret;
diff --git a/mythtv/external/FFmpeg/libavfilter/f_loop.c b/mythtv/external/FFmpeg/libavfilter/f_loop.c
index 00e02154e86..255fe643da8 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_loop.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_loop.c
@@ -233,7 +233,6 @@ AVFilter ff_af_aloop = {
     .priv_size     = sizeof(LoopContext),
     .priv_class    = &aloop_class,
     .uninit        = auninit,
-    .query_formats = ff_query_formats_all,
     .inputs        = ainputs,
     .outputs       = aoutputs,
 };
@@ -276,7 +275,7 @@ static int push_frame(AVFilterContext *ctx)
     if (!out)
         return AVERROR(ENOMEM);
     out->pts += s->duration - s->start_pts;
-    pts = out->pts + av_frame_get_pkt_duration(out);
+    pts = out->pts + out->pkt_duration;
     ret = ff_filter_frame(outlink, out);
     s->current_frame++;
 
@@ -298,7 +297,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     LoopContext *s = ctx->priv;
     int ret = 0;
 
-    if (inlink->frame_count >= s->start && s->size > 0 && s->loop != 0) {
+    if (inlink->frame_count_out >= s->start && s->size > 0 && s->loop != 0) {
         if (s->nb_frames < s->size) {
             if (!s->nb_frames)
                 s->start_pts = frame->pts;
@@ -308,7 +307,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
                 return AVERROR(ENOMEM);
             }
             s->nb_frames++;
-            s->duration = frame->pts + av_frame_get_pkt_duration(frame);
+            s->duration = frame->pts + frame->pkt_duration;
             ret = ff_filter_frame(outlink, frame);
         } else {
             av_frame_free(&frame);
diff --git a/mythtv/external/FFmpeg/libavfilter/f_metadata.c b/mythtv/external/FFmpeg/libavfilter/f_metadata.c
index f2c71d98b4f..523a94d38cb 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_metadata.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_metadata.c
@@ -280,7 +280,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     AVFilterContext *ctx = inlink->dst;
     AVFilterLink *outlink = ctx->outputs[0];
     MetadataContext *s = ctx->priv;
-    AVDictionary **metadata = avpriv_frame_get_metadatap(frame);
+    AVDictionary **metadata = &frame->metadata;
     AVDictionaryEntry *e;
 
     if (!*metadata)
@@ -314,15 +314,15 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
         break;
     case METADATA_PRINT:
         if (!s->key && e) {
-            s->print(ctx, "frame:%-4"PRId64" pts:%-7s pts_time:%-7s\n",
-                     inlink->frame_count, av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base));
+            s->print(ctx, "frame:%-4"PRId64" pts:%-7s pts_time:%s\n",
+                     inlink->frame_count_out, av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base));
             s->print(ctx, "%s=%s\n", e->key, e->value);
             while ((e = av_dict_get(*metadata, "", e, AV_DICT_IGNORE_SUFFIX)) != NULL) {
                 s->print(ctx, "%s=%s\n", e->key, e->value);
             }
         } else if (e && e->value && (!s->value || (e->value && s->compare(s, e->value, s->value)))) {
-            s->print(ctx, "frame:%-4"PRId64" pts:%-7s pts_time:%-7s\n",
-                     inlink->frame_count, av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base));
+            s->print(ctx, "frame:%-4"PRId64" pts:%-7s pts_time:%s\n",
+                     inlink->frame_count_out, av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base));
             s->print(ctx, "%s=%s\n", s->key, e->value);
         }
         return ff_filter_frame(outlink, frame);
@@ -373,7 +373,6 @@ AVFilter ff_af_ametadata = {
     .priv_class    = &ametadata_class,
     .init          = init,
     .uninit        = uninit,
-    .query_formats = ff_query_formats_all,
     .inputs        = ainputs,
     .outputs       = aoutputs,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/mythtv/external/FFmpeg/libavfilter/f_perms.c b/mythtv/external/FFmpeg/libavfilter/f_perms.c
index 40b88111495..dc6ecbbb531 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_perms.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_perms.c
@@ -33,7 +33,7 @@ enum mode {
     NB_MODES
 };
 
-typedef struct {
+typedef struct PermsContext {
     const AVClass *class;
     AVLFG lfg;
     int64_t random_seed;
@@ -64,7 +64,7 @@ static av_cold int init(AVFilterContext *ctx)
         if (s->random_seed == -1)
             s->random_seed = av_get_random_seed();
         seed = s->random_seed;
-        av_log(ctx, AV_LOG_INFO, "random seed: 0x%08x\n", seed);
+        av_log(ctx, AV_LOG_INFO, "random seed: 0x%08"PRIx32"\n", seed);
         av_lfg_init(&s->lfg, seed);
     }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/f_select.c b/mythtv/external/FFmpeg/libavfilter/f_select.c
index 52f474eb935..b1b2cbc21a9 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_select.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_select.c
@@ -186,7 +186,10 @@ static av_cold int init(AVFilterContext *ctx)
             return AVERROR(ENOMEM);
         pad.type = ctx->filter->inputs[0].type;
         pad.request_frame = request_frame;
-        ff_insert_outpad(ctx, i, &pad);
+        if ((ret = ff_insert_outpad(ctx, i, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
     }
 
     return 0;
@@ -284,7 +287,7 @@ static double get_scene_score(AVFilterContext *ctx, AVFrame *frame)
 
 static double get_concatdec_select(AVFrame *frame, int64_t pts)
 {
-    AVDictionary *metadata = av_frame_get_metadata(frame);
+    AVDictionary *metadata = frame->metadata;
     AVDictionaryEntry *start_time_entry = av_dict_get(metadata, "lavf.concatdec.start_time", NULL, 0);
     AVDictionaryEntry *duration_entry = av_dict_get(metadata, "lavf.concatdec.duration", NULL, 0);
     if (start_time_entry) {
@@ -318,10 +321,10 @@ static void select_frame(AVFilterContext *ctx, AVFrame *frame)
     if (isnan(select->var_values[VAR_START_T]))
         select->var_values[VAR_START_T] = TS2D(frame->pts) * av_q2d(inlink->time_base);
 
-    select->var_values[VAR_N  ] = inlink->frame_count;
+    select->var_values[VAR_N  ] = inlink->frame_count_out;
     select->var_values[VAR_PTS] = TS2D(frame->pts);
     select->var_values[VAR_T  ] = TS2D(frame->pts) * av_q2d(inlink->time_base);
-    select->var_values[VAR_POS] = av_frame_get_pkt_pos(frame) == -1 ? NAN : av_frame_get_pkt_pos(frame);
+    select->var_values[VAR_POS] = frame->pkt_pos == -1 ? NAN : frame->pkt_pos;
     select->var_values[VAR_KEY] = frame->key_frame;
     select->var_values[VAR_CONCATDEC_SELECT] = get_concatdec_select(frame, av_rescale_q(frame->pts, inlink->time_base, AV_TIME_BASE_Q));
 
@@ -340,7 +343,7 @@ static void select_frame(AVFilterContext *ctx, AVFrame *frame)
             select->var_values[VAR_SCENE] = get_scene_score(ctx, frame);
             // TODO: document metadata
             snprintf(buf, sizeof(buf), "%f", select->var_values[VAR_SCENE]);
-            av_dict_set(avpriv_frame_get_metadatap(frame), "lavfi.scene_score", buf, 0);
+            av_dict_set(&frame->metadata, "lavfi.scene_score", buf, 0);
         }
         break;
     }
diff --git a/mythtv/external/FFmpeg/libavfilter/f_sendcmd.c b/mythtv/external/FFmpeg/libavfilter/f_sendcmd.c
index fb30220e7ca..b8740e88830 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_sendcmd.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_sendcmd.c
@@ -30,7 +30,6 @@
 #include "libavutil/parseutils.h"
 #include "avfilter.h"
 #include "internal.h"
-#include "avfiltergraph.h"
 #include "audio.h"
 #include "video.h"
 
@@ -55,13 +54,13 @@ static inline char *make_command_flags_str(AVBPrint *pbuf, int flags)
     return pbuf->str;
 }
 
-typedef struct {
+typedef struct Command {
     int flags;
     char *target, *command, *arg;
     int index;
 } Command;
 
-typedef struct {
+typedef struct Interval {
     int64_t start_ts;          ///< start timestamp expressed as microseconds units
     int64_t end_ts;            ///< end   timestamp expressed as microseconds units
     int index;                 ///< unique index for these interval commands
@@ -70,7 +69,7 @@ typedef struct {
     int enabled;               ///< current time detected inside this interval
 } Interval;
 
-typedef struct {
+typedef struct SendCmdContext {
     const AVClass *class;
     Interval *intervals;
     int   nb_intervals;
@@ -268,6 +267,13 @@ static int parse_interval(Interval *interval, int interval_count,
         char *start, *end;
 
         start = av_strtok(intervalstr, "-", &end);
+        if (!start) {
+            ret = AVERROR(EINVAL);
+            av_log(log_ctx, AV_LOG_ERROR,
+                   "Invalid interval specification '%s' in interval #%d\n",
+                   intervalstr, interval_count);
+            goto end;
+        }
         if ((ret = av_parse_time(&interval->start_ts, start, 1)) < 0) {
             av_log(log_ctx, AV_LOG_ERROR,
                    "Invalid start time specification '%s' in interval #%d\n",
diff --git a/mythtv/external/FFmpeg/libavfilter/f_sidedata.c b/mythtv/external/FFmpeg/libavfilter/f_sidedata.c
index 4863cc94ecf..45d246b7323 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_sidedata.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_sidedata.c
@@ -139,7 +139,6 @@ AVFilter ff_af_asidedata = {
     .priv_size     = sizeof(SideDataContext),
     .priv_class    = &asidedata_class,
     .init          = init,
-    .query_formats = ff_query_formats_all,
     .inputs        = ainputs,
     .outputs       = aoutputs,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
diff --git a/mythtv/external/FFmpeg/libavfilter/f_streamselect.c b/mythtv/external/FFmpeg/libavfilter/f_streamselect.c
index 03cedbaa8cb..923deb1a854 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_streamselect.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_streamselect.c
@@ -48,12 +48,6 @@ static const AVOption streamselect_options[] = {
 
 AVFILTER_DEFINE_CLASS(streamselect);
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *in)
-{
-    StreamSelectContext *s = inlink->dst->priv;
-    return ff_framesync_filter_frame(&s->fs, inlink, in);
-}
-
 static int process_frame(FFFrameSync *fs)
 {
     AVFilterContext *ctx = fs->parent;
@@ -72,7 +66,7 @@ static int process_frame(FFFrameSync *fs)
                 AVFrame *out;
 
                 if (s->is_audio && s->last_pts[j] == in[j]->pts &&
-                    ctx->outputs[i]->frame_count > 0)
+                    ctx->outputs[i]->frame_count_in > 0)
                     continue;
                 out = av_frame_clone(in[j]);
                 if (!out)
@@ -90,10 +84,10 @@ static int process_frame(FFFrameSync *fs)
     return ret;
 }
 
-static int request_frame(AVFilterLink *outlink)
+static int activate(AVFilterContext *ctx)
 {
-    StreamSelectContext *s = outlink->src->priv;
-    return ff_framesync_request_frame(&s->fs, outlink);
+    StreamSelectContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static int config_output(AVFilterLink *outlink)
@@ -151,9 +145,8 @@ static int config_output(AVFilterLink *outlink)
     return ff_framesync_configure(&s->fs);
 }
 
-static int parse_definition(AVFilterContext *ctx, int nb_pads, void *filter_frame, int is_audio)
+static int parse_definition(AVFilterContext *ctx, int nb_pads, int is_input, int is_audio)
 {
-    const int is_input = !!filter_frame;
     const char *padtype = is_input ? "in" : "out";
     int i = 0, ret = 0;
 
@@ -169,11 +162,9 @@ static int parse_definition(AVFilterContext *ctx, int nb_pads, void *filter_fram
         av_log(ctx, AV_LOG_DEBUG, "Add %s pad %s\n", padtype, pad.name);
 
         if (is_input) {
-            pad.filter_frame = filter_frame;
             ret = ff_insert_inpad(ctx, i, &pad);
         } else {
             pad.config_props  = config_output;
-            pad.request_frame = request_frame;
             ret = ff_insert_outpad(ctx, i, &pad);
         }
 
@@ -281,8 +272,8 @@ static av_cold int init(AVFilterContext *ctx)
     if (!s->last_pts)
         return AVERROR(ENOMEM);
 
-    if ((ret = parse_definition(ctx, s->nb_inputs, filter_frame, s->is_audio)) < 0 ||
-        (ret = parse_definition(ctx, nb_outputs, NULL, s->is_audio)) < 0)
+    if ((ret = parse_definition(ctx, s->nb_inputs, 1, s->is_audio)) < 0 ||
+        (ret = parse_definition(ctx, nb_outputs, 0, s->is_audio)) < 0)
         return ret;
 
     av_log(ctx, AV_LOG_DEBUG, "Configured with %d inpad and %d outpad\n",
@@ -332,6 +323,7 @@ AVFilter ff_vf_streamselect = {
     .query_formats   = query_formats,
     .process_command = process_command,
     .uninit          = uninit,
+    .activate        = activate,
     .priv_size       = sizeof(StreamSelectContext),
     .priv_class      = &streamselect_class,
     .flags           = AVFILTER_FLAG_DYNAMIC_INPUTS | AVFILTER_FLAG_DYNAMIC_OUTPUTS,
@@ -347,6 +339,7 @@ AVFilter ff_af_astreamselect = {
     .query_formats   = query_formats,
     .process_command = process_command,
     .uninit          = uninit,
+    .activate        = activate,
     .priv_size       = sizeof(StreamSelectContext),
     .priv_class      = &astreamselect_class,
     .flags           = AVFILTER_FLAG_DYNAMIC_INPUTS | AVFILTER_FLAG_DYNAMIC_OUTPUTS,
diff --git a/mythtv/external/FFmpeg/libavfilter/f_zmq.c b/mythtv/external/FFmpeg/libavfilter/f_zmq.c
index d6c3c65da49..89da5bef064 100644
--- a/mythtv/external/FFmpeg/libavfilter/f_zmq.c
+++ b/mythtv/external/FFmpeg/libavfilter/f_zmq.c
@@ -29,11 +29,10 @@
 #include "libavutil/opt.h"
 #include "avfilter.h"
 #include "internal.h"
-#include "avfiltergraph.h"
 #include "audio.h"
 #include "video.h"
 
-typedef struct {
+typedef struct ZMQContext {
     const AVClass *class;
     void *zmq;
     void *responder;
@@ -86,7 +85,7 @@ static void av_cold uninit(AVFilterContext *ctx)
     zmq_ctx_destroy(zmq->zmq);
 }
 
-typedef struct {
+typedef struct Command {
     char *target, *command, *arg;
 } Command;
 
diff --git a/mythtv/external/FFmpeg/libavfilter/fifo.c b/mythtv/external/FFmpeg/libavfilter/fifo.c
index abfbba10bb8..0fa0f86cb3f 100644
--- a/mythtv/external/FFmpeg/libavfilter/fifo.c
+++ b/mythtv/external/FFmpeg/libavfilter/fifo.c
@@ -129,7 +129,7 @@ static void buffer_offset(AVFilterLink *link, AVFrame *frame,
 static int calc_ptr_alignment(AVFrame *frame)
 {
     int planes = av_sample_fmt_is_planar(frame->format) ?
-                 av_frame_get_channels(frame) : 1;
+                 frame->channels : 1;
     int min_align = 128;
     int p;
 
diff --git a/mythtv/external/FFmpeg/libavfilter/filters.h b/mythtv/external/FFmpeg/libavfilter/filters.h
new file mode 100644
index 00000000000..4e2652ebe52
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/filters.h
@@ -0,0 +1,241 @@
+/*
+ * Filters implementation helper functions
+ *
+ * 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 AVFILTER_FILTERS_H
+#define AVFILTER_FILTERS_H
+
+/**
+ * Filters implementation helper functions
+ */
+
+#include "avfilter.h"
+#include "internal.h"
+
+/**
+ * Special return code when activate() did not do anything.
+ */
+#define FFERROR_NOT_READY FFERRTAG('N','R','D','Y')
+
+/**
+ * Mark a filter ready and schedule it for activation.
+ *
+ * This is automatically done when something happens to the filter (queued
+ * frame, status change, request on output).
+ * Filters implementing the activate callback can call it directly to
+ * perform one more round of processing later.
+ * It is also useful for filters reacting to external or asynchronous
+ * events.
+ */
+void ff_filter_set_ready(AVFilterContext *filter, unsigned priority);
+
+/**
+ * Process the commands queued in the link up to the time of the frame.
+ * Commands will trigger the process_command() callback.
+ * @return  >= 0 or AVERROR code.
+ */
+int ff_inlink_process_commands(AVFilterLink *link, const AVFrame *frame);
+
+/**
+ * Evaluate the timeline expression of the link for the time and properties
+ * of the frame.
+ * @return  >0 if enabled, 0 if disabled
+ * @note  It does not update link->dst->is_disabled.
+ */
+int ff_inlink_evaluate_timeline_at_frame(AVFilterLink *link, const AVFrame *frame);
+
+/**
+ * Test if a frame is available on the link.
+ * @return  >0 if a frame is available
+ */
+int ff_inlink_check_available_frame(AVFilterLink *link);
+
+/**
+ * Test if enough samples are available on the link.
+ * @return  >0 if enough samples are available
+ * @note  on EOF and error, min becomes 1
+ */
+int ff_inlink_check_available_samples(AVFilterLink *link, unsigned min);
+
+/**
+ * Take a frame from the link's FIFO and update the link's stats.
+ *
+ * If ff_inlink_check_available_frame() was previously called, the
+ * preferred way of expressing it is "av_assert1(ret);" immediately after
+ * ff_inlink_consume_frame(). Negative error codes must still be checked.
+ *
+ * @note  May trigger process_command() and/or update is_disabled.
+ * @return  >0 if a frame is available,
+ *          0 and set rframe to NULL if no frame available,
+ *          or AVERROR code
+ */
+int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe);
+
+/**
+ * Take samples from the link's FIFO and update the link's stats.
+ *
+ * If ff_inlink_check_available_samples() was previously called, the
+ * preferred way of expressing it is "av_assert1(ret);" immediately after
+ * ff_inlink_consume_samples(). Negative error codes must still be checked.
+ *
+ * @note  May trigger process_command() and/or update is_disabled.
+ * @return  >0 if a frame is available,
+ *          0 and set rframe to NULL if no frame available,
+ *          or AVERROR code
+ */
+int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max,
+                            AVFrame **rframe);
+
+/**
+ * Make sure a frame is writable.
+ * This is similar to av_frame_make_writable() except it uses the link's
+ * buffer allocation callback, and therefore allows direct rendering.
+ */
+int ff_inlink_make_frame_writable(AVFilterLink *link, AVFrame **rframe);
+
+/**
+ * Test and acknowledge the change of status on the link.
+ *
+ * Status means EOF or an error condition; a change from the normal (0)
+ * status to a non-zero status can be queued in a filter's input link, it
+ * becomes relevant after the frames queued in the link's FIFO are
+ * processed. This function tests if frames are still queued and if a queued
+ * status change has not yet been processed. In that case it performs basic
+ * treatment (updating the link's timestamp) and returns a positive value to
+ * let the filter do its own treatments (flushing...).
+ *
+ * Filters implementing the activate callback should call this function when
+ * they think it might succeed (usually after checking unsuccessfully for a
+ * queued frame).
+ * Filters implementing the filter_frame and request_frame callbacks do not
+ * need to call that since the same treatment happens in ff_filter_frame().
+ *
+ * @param[out] rstatus  new or current status
+ * @param[out] rpts     current timestamp of the link in link time base
+ * @return  >0 if status changed, <0 if status already acked, 0 otherwise
+ */
+int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts);
+
+/**
+ * Mark that a frame is wanted on the link.
+ * Unlike ff_filter_frame(), it must not be called when the link has a
+ * non-zero status, and thus does not acknowledge it.
+ * Also it cannot fail.
+ */
+void ff_inlink_request_frame(AVFilterLink *link);
+
+/**
+ * Set the status on an input link.
+ * Also discard all frames in the link's FIFO.
+ */
+void ff_inlink_set_status(AVFilterLink *link, int status);
+
+/**
+ * Test if a frame is wanted on an output link.
+ */
+static inline int ff_outlink_frame_wanted(AVFilterLink *link)
+{
+    return link->frame_wanted_out;
+}
+
+/**
+ * Get the status on an output link.
+ */
+int ff_outlink_get_status(AVFilterLink *link);
+
+/**
+ * Set the status field of a link from the source filter.
+ * The pts should reflect the timestamp of the status change,
+ * in link time base and relative to the frames timeline.
+ * In particular, for AVERROR_EOF, it should reflect the
+ * end time of the last frame.
+ */
+static inline void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
+{
+    ff_avfilter_link_set_in_status(link, status, pts);
+}
+
+/**
+ * Forward the status on an output link to an input link.
+ * If the status is set, it will discard all queued frames and this macro
+ * will return immediately.
+ */
+#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink) do { \
+    int ret = ff_outlink_get_status(outlink); \
+    if (ret) { \
+        ff_inlink_set_status(inlink, ret); \
+        return 0; \
+    } \
+} while (0)
+
+/**
+ * Forward the status on an output link to all input links.
+ * If the status is set, it will discard all queued frames and this macro
+ * will return immediately.
+ */
+#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter) do { \
+    int ret = ff_outlink_get_status(outlink); \
+    if (ret) { \
+        unsigned i; \
+        for (i = 0; i < filter->nb_inputs; i++) \
+            ff_inlink_set_status(filter->inputs[i], ret); \
+        return 0; \
+    } \
+} while (0)
+
+/**
+ * Acknowledge the status on an input link and forward it to an output link.
+ * If the status is set, this macro will return immediately.
+ */
+#define FF_FILTER_FORWARD_STATUS(inlink, outlink) do { \
+    int status; \
+    int64_t pts; \
+    if (ff_inlink_acknowledge_status(inlink, &status, &pts)) { \
+        ff_outlink_set_status(outlink, status, pts); \
+        return 0; \
+    } \
+} while (0)
+
+/**
+ * Acknowledge the status on an input link and forward it to an output link.
+ * If the status is set, this macro will return immediately.
+ */
+#define FF_FILTER_FORWARD_STATUS_ALL(inlink, filter) do { \
+    int status; \
+    int64_t pts; \
+    if (ff_inlink_acknowledge_status(inlink, &status, &pts)) { \
+        unsigned i; \
+        for (i = 0; i < filter->nb_outputs; i++) \
+            ff_outlink_set_status(filter->outputs[i], status, pts); \
+        return 0; \
+    } \
+} while (0)
+
+/**
+ * Forward the frame_wanted_out flag from an output link to an input link.
+ * If the flag is set, this macro will return immediately.
+ */
+#define FF_FILTER_FORWARD_WANTED(outlink, inlink) do { \
+    if (ff_outlink_frame_wanted(outlink)) { \
+        ff_inlink_request_frame(inlink); \
+        return 0; \
+    } \
+} while (0)
+
+#endif /* AVFILTER_FILTERS_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/formats.c b/mythtv/external/FFmpeg/libavfilter/formats.c
index 20f45e33cc7..d4de8622375 100644
--- a/mythtv/external/FFmpeg/libavfilter/formats.c
+++ b/mythtv/external/FFmpeg/libavfilter/formats.c
@@ -596,12 +596,12 @@ static int default_query_formats_common(AVFilterContext *ctx,
 
 int ff_default_query_formats(AVFilterContext *ctx)
 {
-    return default_query_formats_common(ctx, ff_all_channel_layouts);
+    return default_query_formats_common(ctx, ff_all_channel_counts);
 }
 
-int ff_query_formats_all(AVFilterContext *ctx)
+int ff_query_formats_all_layouts(AVFilterContext *ctx)
 {
-    return default_query_formats_common(ctx, ff_all_channel_counts);
+    return default_query_formats_common(ctx, ff_all_channel_layouts);
 }
 
 /* internal functions for parsing audio format arguments */
@@ -664,22 +664,26 @@ int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
 {
     char *tail;
     int64_t chlayout;
-
-    chlayout = av_get_channel_layout(arg);
-    if (chlayout == 0) {
-        chlayout = strtol(arg, &tail, 10);
-        if (!(*tail == '\0' || *tail == 'c' && *(tail + 1) == '\0') || chlayout <= 0 || chlayout > 63) {
+    int nb_channels;
+
+    if (av_get_extended_channel_layout(arg, &chlayout, &nb_channels) < 0) {
+        /* [TEMPORARY 2016-12 -> 2017-12]*/
+        nb_channels = strtol(arg, &tail, 10);
+        if (!errno && *tail == 'c' && *(tail + 1) == '\0' && nb_channels > 0 && nb_channels < 64) {
+            chlayout = 0;
+            av_log(log_ctx, AV_LOG_WARNING, "Deprecated channel count specification '%s'. This will stop working in releases made in 2018 and after.\n", arg);
+        } else {
             av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
             return AVERROR(EINVAL);
         }
-        if (nret) {
-            *nret = chlayout;
-            *ret = 0;
-            return 0;
-        }
+    }
+    if (!chlayout && !nret) {
+        av_log(log_ctx, AV_LOG_ERROR, "Unknown channel layout '%s' is not supported.\n", arg);
+        return AVERROR(EINVAL);
     }
     *ret = chlayout;
     if (nret)
-        *nret = av_get_channel_layout_nb_channels(chlayout);
+        *nret = nb_channels;
+
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/formats.h b/mythtv/external/FFmpeg/libavfilter/formats.h
index 77981f5b36e..870809b5a03 100644
--- a/mythtv/external/FFmpeg/libavfilter/formats.h
+++ b/mythtv/external/FFmpeg/libavfilter/formats.h
@@ -186,15 +186,13 @@ void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
 av_warn_unused_result
 int ff_default_query_formats(AVFilterContext *ctx);
 
-/**
- * Set the formats list to all existing formats.
- * This function behaves like ff_default_query_formats(), except it also
- * accepts channel layouts with unknown disposition. It should only be used
- * with audio filters.
+ /**
+ * Set the formats list to all known channel layouts. This function behaves
+ * like ff_default_query_formats(), except it only accepts known channel
+ * layouts. It should only be used with audio filters.
  */
 av_warn_unused_result
-int ff_query_formats_all(AVFilterContext *ctx);
-
+int ff_query_formats_all_layouts(AVFilterContext *ctx);
 
 /**
  * Create a list of supported formats. This is intended for use in
diff --git a/mythtv/external/FFmpeg/libavfilter/framepool.c b/mythtv/external/FFmpeg/libavfilter/framepool.c
index 6df574ea41a..42c0e58498b 100644
--- a/mythtv/external/FFmpeg/libavfilter/framepool.c
+++ b/mythtv/external/FFmpeg/libavfilter/framepool.c
@@ -20,16 +20,27 @@
 
 #include "framepool.h"
 #include "libavutil/avassert.h"
+#include "libavutil/avutil.h"
 #include "libavutil/buffer.h"
 #include "libavutil/frame.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/mem.h"
 #include "libavutil/pixfmt.h"
 
-struct FFVideoFramePool {
+struct FFFramePool {
 
+    enum AVMediaType type;
+
+    /* video */
     int width;
     int height;
+
+    /* audio */
+    int planes;
+    int channels;
+    int nb_samples;
+
+    /* common */
     int format;
     int align;
     int linesize[4];
@@ -37,23 +48,24 @@ struct FFVideoFramePool {
 
 };
 
-FFVideoFramePool *ff_video_frame_pool_init(AVBufferRef* (*alloc)(int size),
-                                           int width,
-                                           int height,
-                                           enum AVPixelFormat format,
-                                           int align)
+FFFramePool *ff_frame_pool_video_init(AVBufferRef* (*alloc)(int size),
+                                      int width,
+                                      int height,
+                                      enum AVPixelFormat format,
+                                      int align)
 {
     int i, ret;
-    FFVideoFramePool *pool;
+    FFFramePool *pool;
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(format);
 
     if (!desc)
         return NULL;
 
-    pool = av_mallocz(sizeof(FFVideoFramePool));
+    pool = av_mallocz(sizeof(FFFramePool));
     if (!pool)
         return NULL;
 
+    pool->type = AVMEDIA_TYPE_VIDEO;
     pool->width = width;
     pool->height = height;
     pool->format = format;
@@ -100,11 +112,49 @@ FFVideoFramePool *ff_video_frame_pool_init(AVBufferRef* (*alloc)(int size),
     return pool;
 
 fail:
-    ff_video_frame_pool_uninit(&pool);
+    ff_frame_pool_uninit(&pool);
     return NULL;
 }
 
-int ff_video_frame_pool_get_config(FFVideoFramePool *pool,
+FFFramePool *ff_frame_pool_audio_init(AVBufferRef* (*alloc)(int size),
+                                      int channels,
+                                      int nb_samples,
+                                      enum AVSampleFormat format,
+                                      int align)
+{
+    int ret, planar;
+    FFFramePool *pool;
+
+    pool = av_mallocz(sizeof(FFFramePool));
+    if (!pool)
+        return NULL;
+
+    planar = av_sample_fmt_is_planar(format);
+
+    pool->type = AVMEDIA_TYPE_AUDIO;
+    pool->planes = planar ? channels : 1;
+    pool->channels = channels;
+    pool->nb_samples = nb_samples;
+    pool->format = format;
+    pool->align = align;
+
+    ret = av_samples_get_buffer_size(&pool->linesize[0], channels,
+                                     nb_samples, format, 0);
+    if (ret < 0)
+        goto fail;
+
+    pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
+    if (!pool->pools[0])
+        goto fail;
+
+    return pool;
+
+fail:
+    ff_frame_pool_uninit(&pool);
+    return NULL;
+}
+
+int ff_frame_pool_get_video_config(FFFramePool *pool,
                                    int *width,
                                    int *height,
                                    enum AVPixelFormat *format,
@@ -113,6 +163,8 @@ int ff_video_frame_pool_get_config(FFVideoFramePool *pool,
     if (!pool)
         return AVERROR(EINVAL);
 
+    av_assert0(pool->type == AVMEDIA_TYPE_VIDEO);
+
     *width = pool->width;
     *height = pool->height;
     *format = pool->format;
@@ -121,8 +173,26 @@ int ff_video_frame_pool_get_config(FFVideoFramePool *pool,
     return 0;
 }
 
+int ff_frame_pool_get_audio_config(FFFramePool *pool,
+                                   int *channels,
+                                   int *nb_samples,
+                                   enum AVSampleFormat *format,
+                                   int *align)
+{
+    if (!pool)
+        return AVERROR(EINVAL);
+
+    av_assert0(pool->type == AVMEDIA_TYPE_AUDIO);
+
+    *channels = pool->channels;
+    *nb_samples = pool->nb_samples;
+    *format = pool->format;
+    *align = pool->align;
+
+    return 0;
+}
 
-AVFrame *ff_video_frame_pool_get(FFVideoFramePool *pool)
+AVFrame *ff_frame_pool_get(FFFramePool *pool)
 {
     int i;
     AVFrame *frame;
@@ -133,40 +203,77 @@ AVFrame *ff_video_frame_pool_get(FFVideoFramePool *pool)
         return NULL;
     }
 
-    desc = av_pix_fmt_desc_get(pool->format);
-    if (!desc) {
-        goto fail;
-    }
+    switch(pool->type) {
+    case AVMEDIA_TYPE_VIDEO:
+        desc = av_pix_fmt_desc_get(pool->format);
+        if (!desc) {
+            goto fail;
+        }
 
-    frame->width = pool->width;
-    frame->height = pool->height;
-    frame->format = pool->format;
+        frame->width = pool->width;
+        frame->height = pool->height;
+        frame->format = pool->format;
 
-    for (i = 0; i < 4; i++) {
-        frame->linesize[i] = pool->linesize[i];
-        if (!pool->pools[i])
-            break;
+        for (i = 0; i < 4; i++) {
+            frame->linesize[i] = pool->linesize[i];
+            if (!pool->pools[i])
+                break;
 
-        frame->buf[i] = av_buffer_pool_get(pool->pools[i]);
-        if (!frame->buf[i]) {
-            goto fail;
+            frame->buf[i] = av_buffer_pool_get(pool->pools[i]);
+            if (!frame->buf[i])
+                goto fail;
+
+            frame->data[i] = frame->buf[i]->data;
         }
 
-        frame->data[i] = frame->buf[i]->data;
-    }
+        if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
+            desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
+            enum AVPixelFormat format =
+                pool->format == AV_PIX_FMT_PAL8 ? AV_PIX_FMT_BGR8 : pool->format;
 
-    if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
-        desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
-        enum AVPixelFormat format =
-            pool->format == AV_PIX_FMT_PAL8 ? AV_PIX_FMT_BGR8 : pool->format;
+            av_assert0(frame->data[1] != NULL);
+            if (avpriv_set_systematic_pal2((uint32_t *)frame->data[1], format) < 0)
+                goto fail;
+        }
 
-        av_assert0(frame->data[1] != NULL);
-        if (avpriv_set_systematic_pal2((uint32_t *)frame->data[1], format) < 0) {
-            goto fail;
+        frame->extended_data = frame->data;
+        break;
+    case AVMEDIA_TYPE_AUDIO:
+        frame->nb_samples = pool->nb_samples;
+        frame->channels = pool->channels;
+        frame->format = pool->format;
+        frame->linesize[0] = pool->linesize[0];
+
+        if (pool->planes > AV_NUM_DATA_POINTERS) {
+            frame->extended_data = av_mallocz_array(pool->planes,
+                                                    sizeof(*frame->extended_data));
+            frame->nb_extended_buf = pool->planes - AV_NUM_DATA_POINTERS;
+            frame->extended_buf = av_mallocz_array(frame->nb_extended_buf,
+                                                   sizeof(*frame->extended_buf));
+            if (!frame->extended_data || !frame->extended_buf)
+                goto fail;
+        } else {
+            frame->extended_data = frame->data;
+            av_assert0(frame->nb_extended_buf == 0);
         }
-    }
 
-    frame->extended_data = frame->data;
+        for (i = 0; i < FFMIN(pool->planes, AV_NUM_DATA_POINTERS); i++) {
+            frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
+            if (!frame->buf[i])
+                goto fail;
+            frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
+        }
+        for (i = 0; i < frame->nb_extended_buf; i++) {
+            frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
+            if (!frame->extended_buf[i])
+                goto fail;
+            frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
+        }
+
+        break;
+    default:
+        av_assert0(0);
+    }
 
     return frame;
 fail:
@@ -174,7 +281,7 @@ AVFrame *ff_video_frame_pool_get(FFVideoFramePool *pool)
     return NULL;
 }
 
-void ff_video_frame_pool_uninit(FFVideoFramePool **pool)
+void ff_frame_pool_uninit(FFFramePool **pool)
 {
     int i;
 
diff --git a/mythtv/external/FFmpeg/libavfilter/framepool.h b/mythtv/external/FFmpeg/libavfilter/framepool.h
index 2a6c9e8636b..e5560e4c6e8 100644
--- a/mythtv/external/FFmpeg/libavfilter/framepool.h
+++ b/mythtv/external/FFmpeg/libavfilter/framepool.h
@@ -25,11 +25,11 @@
 #include "libavutil/frame.h"
 
 /**
- * Video frame pool. This structure is opaque and not meant to be accessed
- * directly. It is allocated with ff_video_frame_pool_init() and freed with
- * ff_video_frame_pool_uninit().
+ * Frame pool. This structure is opaque and not meant to be accessed
+ * directly. It is allocated with ff_frame_pool_init() and freed with
+ * ff_frame_pool_uninit().
  */
-typedef struct FFVideoFramePool FFVideoFramePool;
+typedef struct FFFramePool FFFramePool;
 
 /**
  * Allocate and initialize a video frame pool.
@@ -43,19 +43,37 @@ typedef struct FFVideoFramePool FFVideoFramePool;
  * @param align buffers alignement of each frame in this pool
  * @return newly created video frame pool on success, NULL on error.
  */
-FFVideoFramePool *ff_video_frame_pool_init(AVBufferRef* (*alloc)(int size),
-                                           int width,
-                                           int height,
-                                           enum AVPixelFormat format,
-                                           int align);
+FFFramePool *ff_frame_pool_video_init(AVBufferRef* (*alloc)(int size),
+                                      int width,
+                                      int height,
+                                      enum AVPixelFormat format,
+                                      int align);
 
 /**
- * Deallocate the video frame pool. It is safe to call this function while
- * some of the allocated video frame are still in use.
+ * Allocate and initialize an audio frame pool.
  *
- * @param pool pointer to the video frame pool to be freed. It will be set to NULL.
+ * @param alloc a function that will be used to allocate new frame buffers when
+ * the pool is empty. May be NULL, then the default allocator will be used
+ * (av_buffer_alloc()).
+ * @param channels channels of each frame in this pool
+ * @param nb_samples number of samples of each frame in this pool
+ * @param format format of each frame in this pool
+ * @param align buffers alignement of each frame in this pool
+ * @return newly created audio frame pool on success, NULL on error.
+ */
+FFFramePool *ff_frame_pool_audio_init(AVBufferRef* (*alloc)(int size),
+                                      int channels,
+                                      int samples,
+                                      enum AVSampleFormat format,
+                                      int align);
+
+/**
+ * Deallocate the frame pool. It is safe to call this function while
+ * some of the allocated frame are still in use.
+ *
+ * @param pool pointer to the frame pool to be freed. It will be set to NULL.
  */
-void ff_video_frame_pool_uninit(FFVideoFramePool **pool);
+void ff_frame_pool_uninit(FFFramePool **pool);
 
 /**
  * Get the video frame pool configuration.
@@ -66,19 +84,35 @@ void ff_video_frame_pool_uninit(FFVideoFramePool **pool);
  * @param align buffers alignement of each frame in this pool
  * @return 0 on success, a negative AVERROR otherwise.
  */
-int ff_video_frame_pool_get_config(FFVideoFramePool *pool,
+int ff_frame_pool_get_video_config(FFFramePool *pool,
                                    int *width,
                                    int *height,
                                    enum AVPixelFormat *format,
                                    int *align);
 
+/**
+ * Get the audio frame pool configuration.
+ *
+ * @param channels channels of each frame in this pool
+ * @param nb_samples number of samples of each frame in this pool
+ * @param format format of each frame in this pool
+ * @param align buffers alignement of each frame in this pool
+ * @return 0 on success, a negative AVERROR otherwise.
+ */
+int ff_frame_pool_get_audio_config(FFFramePool *pool,
+                                   int *channels,
+                                   int *nb_samples,
+                                   enum AVSampleFormat *format,
+                                   int *align);
+
+
 /**
  * Allocate a new AVFrame, reussing old buffers from the pool when available.
  * This function may be called simultaneously from multiple threads.
  *
  * @return a new AVFrame on success, NULL on error.
  */
-AVFrame *ff_video_frame_pool_get(FFVideoFramePool *pool);
+AVFrame *ff_frame_pool_get(FFFramePool *pool);
 
 
 #endif /* AVFILTER_FRAMEPOOL_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/framequeue.c b/mythtv/external/FFmpeg/libavfilter/framequeue.c
new file mode 100644
index 00000000000..fed11189758
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/framequeue.c
@@ -0,0 +1,152 @@
+/*
+ * Generic frame queue
+ * Copyright (c) 2016 Nicolas George
+ *
+ * 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/avassert.h"
+#include "framequeue.h"
+
+static inline FFFrameBucket *bucket(FFFrameQueue *fq, size_t idx)
+{
+    return &fq->queue[(fq->tail + idx) & (fq->allocated - 1)];
+}
+
+void ff_framequeue_global_init(FFFrameQueueGlobal *fqg)
+{
+}
+
+static void check_consistency(FFFrameQueue *fq)
+{
+#if defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2
+    uint64_t nb_samples = 0;
+    size_t i;
+
+    av_assert0(fq->queued == fq->total_frames_head - fq->total_frames_tail);
+    for (i = 0; i < fq->queued; i++)
+        nb_samples += bucket(fq, i)->frame->nb_samples;
+    av_assert0(nb_samples == fq->total_samples_head - fq->total_samples_tail);
+#endif
+}
+
+void ff_framequeue_init(FFFrameQueue *fq, FFFrameQueueGlobal *fqg)
+{
+    fq->queue = &fq->first_bucket;
+    fq->allocated = 1;
+}
+
+void ff_framequeue_free(FFFrameQueue *fq)
+{
+    while (fq->queued) {
+        AVFrame *frame = ff_framequeue_take(fq);
+        av_frame_free(&frame);
+    }
+    if (fq->queue != &fq->first_bucket)
+        av_freep(&fq->queue);
+}
+
+int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame)
+{
+    FFFrameBucket *b;
+
+    check_consistency(fq);
+    if (fq->queued == fq->allocated) {
+        if (fq->allocated == 1) {
+            size_t na = 8;
+            FFFrameBucket *nq = av_realloc_array(NULL, na, sizeof(*nq));
+            if (!nq)
+                return AVERROR(ENOMEM);
+            nq[0] = fq->queue[0];
+            fq->queue = nq;
+            fq->allocated = na;
+        } else {
+            size_t na = fq->allocated << 1;
+            FFFrameBucket *nq = av_realloc_array(fq->queue, na, sizeof(*nq));
+            if (!nq)
+                return AVERROR(ENOMEM);
+            if (fq->tail + fq->queued > fq->allocated)
+                memmove(nq + fq->allocated, nq,
+                        (fq->tail + fq->queued - fq->allocated) * sizeof(*nq));
+            fq->queue = nq;
+            fq->allocated = na;
+        }
+    }
+    b = bucket(fq, fq->queued);
+    b->frame = frame;
+    fq->queued++;
+    fq->total_frames_head++;
+    fq->total_samples_head += frame->nb_samples;
+    check_consistency(fq);
+    return 0;
+}
+
+AVFrame *ff_framequeue_take(FFFrameQueue *fq)
+{
+    FFFrameBucket *b;
+
+    check_consistency(fq);
+    av_assert1(fq->queued);
+    b = bucket(fq, 0);
+    fq->queued--;
+    fq->tail++;
+    fq->tail &= fq->allocated - 1;
+    fq->total_frames_tail++;
+    fq->total_samples_tail += b->frame->nb_samples;
+    fq->samples_skipped = 0;
+    check_consistency(fq);
+    return b->frame;
+}
+
+AVFrame *ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
+{
+    FFFrameBucket *b;
+
+    check_consistency(fq);
+    av_assert1(idx < fq->queued);
+    b = bucket(fq, idx);
+    check_consistency(fq);
+    return b->frame;
+}
+
+void ff_framequeue_skip_samples(FFFrameQueue *fq, size_t samples, AVRational time_base)
+{
+    FFFrameBucket *b;
+    size_t bytes;
+    int planar, planes, i;
+
+    check_consistency(fq);
+    av_assert1(fq->queued);
+    b = bucket(fq, 0);
+    av_assert1(samples < b->frame->nb_samples);
+    planar = av_sample_fmt_is_planar(b->frame->format);
+    planes = planar ? b->frame->channels : 1;
+    bytes = samples * av_get_bytes_per_sample(b->frame->format);
+    if (!planar)
+        bytes *= b->frame->channels;
+    if (b->frame->pts != AV_NOPTS_VALUE)
+        b->frame->pts += av_rescale_q(samples, av_make_q(1, b->frame->sample_rate), time_base);
+    b->frame->nb_samples -= samples;
+    b->frame->linesize[0] -= bytes;
+    for (i = 0; i < planes; i++)
+        b->frame->extended_data[i] += bytes;
+    for (i = 0; i < planes && i < AV_NUM_DATA_POINTERS; i++)
+        b->frame->data[i] = b->frame->extended_data[i];
+    fq->total_samples_tail += samples;
+    fq->samples_skipped = 1;
+    ff_framequeue_update_peeked(fq, 0);
+}
diff --git a/mythtv/external/FFmpeg/libavfilter/framequeue.h b/mythtv/external/FFmpeg/libavfilter/framequeue.h
new file mode 100644
index 00000000000..c49d872e854
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/framequeue.h
@@ -0,0 +1,178 @@
+/*
+ * Generic frame queue
+ * Copyright (c) 2016 Nicolas George
+ *
+ * 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 AVFILTER_FRAMEQUEUE_H
+#define AVFILTER_FRAMEQUEUE_H
+
+/**
+ * FFFrameQueue: simple AVFrame queue API
+ *
+ * Note: this API is not thread-safe. Concurrent access to the same queue
+ * must be protected by a mutex or any synchronization mechanism.
+ */
+
+#include "libavutil/frame.h"
+
+typedef struct FFFrameBucket {
+    AVFrame *frame;
+} FFFrameBucket;
+
+/**
+ * Structure to hold global options and statistics for frame queues.
+ *
+ * This structure is intended to allow implementing global control of the
+ * frame queues, including memory consumption caps.
+ *
+ * It is currently empty.
+ */
+typedef struct FFFrameQueueGlobal {
+    char dummy; /* C does not allow empty structs */
+} FFFrameQueueGlobal;
+
+/**
+ * Queue of AVFrame pointers.
+ */
+typedef struct FFFrameQueue {
+
+    /**
+     * Array of allocated buckets, used as a circular buffer.
+     */
+    FFFrameBucket *queue;
+
+    /**
+     * Size of the array of buckets.
+     */
+    size_t allocated;
+
+    /**
+     * Tail of the queue.
+     * It is the index in the array of the next frame to take.
+     */
+    size_t tail;
+
+    /**
+     * Number of currently queued frames.
+     */
+    size_t queued;
+
+    /**
+     * Pre-allocated bucket for queues of size 1.
+     */
+    FFFrameBucket first_bucket;
+
+    /**
+     * Total number of frames entered in the queue.
+     */
+    uint64_t total_frames_head;
+
+    /**
+     * Total number of frames dequeued from the queue.
+     * queued = total_frames_head - total_frames_tail
+     */
+    uint64_t total_frames_tail;
+
+    /**
+     * Total number of samples entered in the queue.
+     */
+    uint64_t total_samples_head;
+
+    /**
+     * Total number of samples dequeued from the queue.
+     * queued_samples = total_samples_head - total_samples_tail
+     */
+    uint64_t total_samples_tail;
+
+    /**
+     * Indicate that samples are skipped
+     */
+    int samples_skipped;
+
+} FFFrameQueue;
+
+/**
+ * Init a global structure.
+ */
+void ff_framequeue_global_init(FFFrameQueueGlobal *fqg);
+
+/**
+ * Init a frame queue and attach it to a global structure.
+ */
+void ff_framequeue_init(FFFrameQueue *fq, FFFrameQueueGlobal *fqg);
+
+/**
+ * Free the queue and all queued frames.
+ */
+void ff_framequeue_free(FFFrameQueue *fq);
+
+/**
+ * Add a frame.
+ * @return  >=0 or an AVERROR code.
+ */
+int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame);
+
+/**
+ * Take the first frame in the queue.
+ * Must not be used with empty queues.
+ */
+AVFrame *ff_framequeue_take(FFFrameQueue *fq);
+
+/**
+ * Access a frame in the queue, without removing it.
+ * The first frame is numbered 0; the designated frame must exist.
+ */
+AVFrame *ff_framequeue_peek(FFFrameQueue *fq, size_t idx);
+
+/**
+ * Get the number of queued frames.
+ */
+static inline size_t ff_framequeue_queued_frames(const FFFrameQueue *fq)
+{
+    return fq->queued;
+}
+
+/**
+ * Get the number of queued samples.
+ */
+static inline uint64_t ff_framequeue_queued_samples(const FFFrameQueue *fq)
+{
+    return fq->total_samples_head - fq->total_samples_tail;
+}
+
+/**
+ * Update the statistics after a frame accessed using ff_framequeue_peek()
+ * was modified.
+ * Currently used only as a marker.
+ */
+static inline void ff_framequeue_update_peeked(FFFrameQueue *fq, size_t idx)
+{
+}
+
+/**
+ * Skip samples from the first frame in the queue.
+ *
+ * This function must be used when the first frame was accessed using
+ * ff_framequeue_peek() and samples were consumed from it.
+ * It adapts the data pointers and timestamps of the head frame to account
+ * for the skipped samples.
+ */
+void ff_framequeue_skip_samples(FFFrameQueue *fq, size_t samples, AVRational time_base);
+
+#endif /* AVFILTER_FRAMEQUEUE_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/framesync.c b/mythtv/external/FFmpeg/libavfilter/framesync.c
index 7920cdb379c..82d715750c4 100644
--- a/mythtv/external/FFmpeg/libavfilter/framesync.c
+++ b/mythtv/external/FFmpeg/libavfilter/framesync.c
@@ -19,24 +19,37 @@
  */
 
 #include "libavutil/avassert.h"
+#include "libavutil/opt.h"
 #include "avfilter.h"
-#include "bufferqueue.h"
+#include "filters.h"
 #include "framesync.h"
 #include "internal.h"
 
 #define OFFSET(member) offsetof(FFFrameSync, member)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
 
 static const char *framesync_name(void *ptr)
 {
     return "framesync";
 }
 
+static const AVOption framesync_options[] = {
+    { "eof_action", "Action to take when encountering EOF from secondary input ",
+        OFFSET(opt_eof_action), AV_OPT_TYPE_INT, { .i64 = EOF_ACTION_REPEAT },
+        EOF_ACTION_REPEAT, EOF_ACTION_PASS, .flags = FLAGS, "eof_action" },
+        { "repeat", "Repeat the previous frame.",   0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_REPEAT }, .flags = FLAGS, "eof_action" },
+        { "endall", "End both streams.",            0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_ENDALL }, .flags = FLAGS, "eof_action" },
+        { "pass",   "Pass through the main input.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_PASS },   .flags = FLAGS, "eof_action" },
+    { "shortest", "force termination when the shortest input terminates", OFFSET(opt_shortest), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
+    { "repeatlast", "extend last frame of secondary streams beyond EOF", OFFSET(opt_repeatlast), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
+    { NULL }
+};
 static const AVClass framesync_class = {
     .version                   = LIBAVUTIL_VERSION_INT,
     .class_name                = "framesync",
     .item_name                 = framesync_name,
     .category                  = AV_CLASS_CATEGORY_FILTER,
-    .option                    = NULL,
+    .option                    = framesync_options,
     .parent_log_context_offset = OFFSET(parent),
 };
 
@@ -46,9 +59,29 @@ enum {
     STATE_EOF,
 };
 
-int ff_framesync_init(FFFrameSync *fs, void *parent, unsigned nb_in)
+static int consume_from_fifos(FFFrameSync *fs);
+
+const AVClass *framesync_get_class(void)
+{
+    return &framesync_class;
+}
+
+void ff_framesync_preinit(FFFrameSync *fs)
 {
+    if (fs->class)
+        return;
     fs->class  = &framesync_class;
+    av_opt_set_defaults(fs);
+}
+
+int ff_framesync_init(FFFrameSync *fs, AVFilterContext *parent, unsigned nb_in)
+{
+    /* For filters with several outputs, we will not be able to assume which
+       output is relevant for ff_outlink_frame_wanted() and
+       ff_outlink_set_status(). To be designed when needed. */
+    av_assert0(parent->nb_outputs == 1);
+
+    ff_framesync_preinit(fs);
     fs->parent = parent;
     fs->nb_in  = nb_in;
 
@@ -58,6 +91,13 @@ int ff_framesync_init(FFFrameSync *fs, void *parent, unsigned nb_in)
     return 0;
 }
 
+static void framesync_eof(FFFrameSync *fs)
+{
+    fs->eof = 1;
+    fs->frame_ready = 0;
+    ff_outlink_set_status(fs->parent->outputs[0], AVERROR_EOF, AV_NOPTS_VALUE);
+}
+
 static void framesync_sync_level_update(FFFrameSync *fs)
 {
     unsigned i, level = 0;
@@ -71,7 +111,7 @@ static void framesync_sync_level_update(FFFrameSync *fs)
     if (level)
         fs->sync_level = level;
     else
-        fs->eof = 1;
+        framesync_eof(fs);
 }
 
 int ff_framesync_configure(FFFrameSync *fs)
@@ -79,6 +119,25 @@ int ff_framesync_configure(FFFrameSync *fs)
     unsigned i;
     int64_t gcd, lcm;
 
+    if (!fs->opt_repeatlast || fs->opt_eof_action == EOF_ACTION_PASS) {
+        fs->opt_repeatlast = 0;
+        fs->opt_eof_action = EOF_ACTION_PASS;
+    }
+    if (fs->opt_shortest || fs->opt_eof_action == EOF_ACTION_ENDALL) {
+        fs->opt_shortest = 1;
+        fs->opt_eof_action = EOF_ACTION_ENDALL;
+    }
+    if (fs->opt_shortest) {
+        for (i = 0; i < fs->nb_in; i++)
+            fs->in[i].after = EXT_STOP;
+    }
+    if (!fs->opt_repeatlast) {
+        for (i = 1; i < fs->nb_in; i++) {
+            fs->in[i].after = EXT_NULL;
+            fs->in[i].sync  = 0;
+        }
+    }
+
     if (!fs->time_base.num) {
         for (i = 0; i < fs->nb_in; i++) {
             if (fs->in[i].sync) {
@@ -115,33 +174,23 @@ int ff_framesync_configure(FFFrameSync *fs)
     return 0;
 }
 
-static void framesync_advance(FFFrameSync *fs)
+static int framesync_advance(FFFrameSync *fs)
 {
-    int latest;
     unsigned i;
     int64_t pts;
+    int ret;
 
-    if (fs->eof)
-        return;
-    while (!fs->frame_ready) {
-        latest = -1;
-        for (i = 0; i < fs->nb_in; i++) {
-            if (!fs->in[i].have_next) {
-                if (latest < 0 || fs->in[i].pts < fs->in[latest].pts)
-                    latest = i;
-            }
-        }
-        if (latest >= 0) {
-            fs->in_request = latest;
-            break;
-        }
+    while (!(fs->frame_ready || fs->eof)) {
+        ret = consume_from_fifos(fs);
+        if (ret <= 0)
+            return ret;
 
-        pts = fs->in[0].pts_next;
-        for (i = 1; i < fs->nb_in; i++)
-            if (fs->in[i].pts_next < pts)
+        pts = INT64_MAX;
+        for (i = 0; i < fs->nb_in; i++)
+            if (fs->in[i].have_next && fs->in[i].pts_next < pts)
                 pts = fs->in[i].pts_next;
         if (pts == INT64_MAX) {
-            fs->eof = 1;
+            framesync_eof(fs);
             break;
         }
         for (i = 0; i < fs->nb_in; i++) {
@@ -159,11 +208,9 @@ static void framesync_advance(FFFrameSync *fs)
                     fs->frame_ready = 1;
                 if (fs->in[i].state == STATE_EOF &&
                     fs->in[i].after == EXT_STOP)
-                    fs->eof = 1;
+                    framesync_eof(fs);
             }
         }
-        if (fs->eof)
-            fs->frame_ready = 0;
         if (fs->frame_ready)
             for (i = 0; i < fs->nb_in; i++)
                 if ((fs->in[i].state == STATE_BOF &&
@@ -171,6 +218,7 @@ static void framesync_advance(FFFrameSync *fs)
                     fs->frame_ready = 0;
         fs->pts = pts;
     }
+    return 0;
 }
 
 static int64_t framesync_pts_extrapolate(FFFrameSync *fs, unsigned in,
@@ -185,49 +233,28 @@ static void framesync_inject_frame(FFFrameSync *fs, unsigned in, AVFrame *frame)
     int64_t pts;
 
     av_assert0(!fs->in[in].have_next);
-    if (frame) {
-        pts = av_rescale_q(frame->pts, fs->in[in].time_base, fs->time_base);
-        frame->pts = pts;
-    } else {
-        pts = fs->in[in].state != STATE_RUN || fs->in[in].after == EXT_INFINITY
-            ? INT64_MAX : framesync_pts_extrapolate(fs, in, fs->in[in].pts);
-        fs->in[in].sync = 0;
-        framesync_sync_level_update(fs);
-    }
+    av_assert0(frame);
+    pts = av_rescale_q(frame->pts, fs->in[in].time_base, fs->time_base);
+    frame->pts = pts;
     fs->in[in].frame_next = frame;
     fs->in[in].pts_next   = pts;
     fs->in[in].have_next  = 1;
 }
 
-int ff_framesync_add_frame(FFFrameSync *fs, unsigned in, AVFrame *frame)
+static void framesync_inject_status(FFFrameSync *fs, unsigned in, int status, int64_t pts)
 {
-    av_assert1(in < fs->nb_in);
-    if (!fs->in[in].have_next)
-        framesync_inject_frame(fs, in, frame);
-    else
-        ff_bufqueue_add(fs, &fs->in[in].queue, frame);
-    return 0;
-}
-
-void ff_framesync_next(FFFrameSync *fs)
-{
-    unsigned i;
-
-    av_assert0(!fs->frame_ready);
-    for (i = 0; i < fs->nb_in; i++)
-        if (!fs->in[i].have_next && fs->in[i].queue.available)
-            framesync_inject_frame(fs, i, ff_bufqueue_get(&fs->in[i].queue));
-    fs->frame_ready = 0;
-    framesync_advance(fs);
-}
-
-void ff_framesync_drop(FFFrameSync *fs)
-{
-    fs->frame_ready = 0;
+    av_assert0(!fs->in[in].have_next);
+    pts = fs->in[in].state != STATE_RUN || fs->in[in].after == EXT_INFINITY
+        ? INT64_MAX : framesync_pts_extrapolate(fs, in, fs->in[in].pts);
+    fs->in[in].sync = 0;
+    framesync_sync_level_update(fs);
+    fs->in[in].frame_next = NULL;
+    fs->in[in].pts_next   = pts;
+    fs->in[in].have_next  = 1;
 }
 
 int ff_framesync_get_frame(FFFrameSync *fs, unsigned in, AVFrame **rframe,
-                           unsigned get)
+                            unsigned get)
 {
     AVFrame *frame;
     unsigned need_copy = 0, i;
@@ -270,66 +297,117 @@ void ff_framesync_uninit(FFFrameSync *fs)
     for (i = 0; i < fs->nb_in; i++) {
         av_frame_free(&fs->in[i].frame);
         av_frame_free(&fs->in[i].frame_next);
-        ff_bufqueue_discard_all(&fs->in[i].queue);
     }
 
     av_freep(&fs->in);
 }
 
-int ff_framesync_process_frame(FFFrameSync *fs, unsigned all)
+static int consume_from_fifos(FFFrameSync *fs)
 {
-    int ret, count = 0;
+    AVFilterContext *ctx = fs->parent;
+    AVFrame *frame = NULL;
+    int64_t pts;
+    unsigned i, nb_active, nb_miss;
+    int ret, status;
 
-    av_assert0(fs->on_event);
-    while (1) {
-        ff_framesync_next(fs);
-        if (fs->eof || !fs->frame_ready)
-            break;
-        if ((ret = fs->on_event(fs)) < 0)
+    nb_active = nb_miss = 0;
+    for (i = 0; i < fs->nb_in; i++) {
+        if (fs->in[i].have_next || fs->in[i].state == STATE_EOF)
+            continue;
+        nb_active++;
+        ret = ff_inlink_consume_frame(ctx->inputs[i], &frame);
+        if (ret < 0)
             return ret;
-        ff_framesync_drop(fs);
-        count++;
-        if (!all)
-            break;
+        if (ret) {
+            av_assert0(frame);
+            framesync_inject_frame(fs, i, frame);
+        } else {
+            ret = ff_inlink_acknowledge_status(ctx->inputs[i], &status, &pts);
+            if (ret > 0) {
+                framesync_inject_status(fs, i, status, pts);
+            } else if (!ret) {
+                nb_miss++;
+            }
+        }
+    }
+    if (nb_miss) {
+        if (nb_miss == nb_active && !ff_outlink_frame_wanted(ctx->outputs[0]))
+            return FFERROR_NOT_READY;
+        for (i = 0; i < fs->nb_in; i++)
+            if (!fs->in[i].have_next && fs->in[i].state != STATE_EOF)
+                ff_inlink_request_frame(ctx->inputs[i]);
+        return 0;
     }
-    if (!count && fs->eof)
-        return AVERROR_EOF;
-    return count;
+    return 1;
 }
 
-int ff_framesync_filter_frame(FFFrameSync *fs, AVFilterLink *inlink,
-                              AVFrame *in)
+int ff_framesync_activate(FFFrameSync *fs)
 {
     int ret;
 
-    if ((ret = ff_framesync_process_frame(fs, 1)) < 0)
+    ret = framesync_advance(fs);
+    if (ret < 0)
         return ret;
-    if ((ret = ff_framesync_add_frame(fs, FF_INLINK_IDX(inlink), in)) < 0)
+    if (fs->eof || !fs->frame_ready)
+        return 0;
+    ret = fs->on_event(fs);
+    if (ret < 0)
         return ret;
-    if ((ret = ff_framesync_process_frame(fs, 0)) < 0)
+    fs->frame_ready = 0;
+
+    return 0;
+}
+
+int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent)
+{
+    int ret;
+
+    ret = ff_framesync_init(fs, parent, 2);
+    if (ret < 0)
         return ret;
+    fs->in[0].time_base = parent->inputs[0]->time_base;
+    fs->in[1].time_base = parent->inputs[1]->time_base;
+    fs->in[0].sync   = 2;
+    fs->in[0].before = EXT_STOP;
+    fs->in[0].after  = EXT_INFINITY;
+    fs->in[1].sync   = 1;
+    fs->in[1].before = EXT_NULL;
+    fs->in[1].after  = EXT_INFINITY;
     return 0;
 }
 
-int ff_framesync_request_frame(FFFrameSync *fs, AVFilterLink *outlink)
+int ff_framesync_dualinput_get(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)
 {
-    AVFilterContext *ctx = outlink->src;
-    int input, ret;
+    AVFilterContext *ctx = fs->parent;
+    AVFrame *mainpic = NULL, *secondpic = NULL;
+    int ret;
 
-    if ((ret = ff_framesync_process_frame(fs, 0)) < 0)
+    if ((ret = ff_framesync_get_frame(fs, 0, &mainpic,   1)) < 0 ||
+        (ret = ff_framesync_get_frame(fs, 1, &secondpic, 0)) < 0) {
+        av_frame_free(&mainpic);
         return ret;
-    if (ret > 0)
-        return 0;
-    if (fs->eof)
-        return AVERROR_EOF;
-    input = fs->in_request;
-    ret = ff_request_frame(ctx->inputs[input]);
-    if (ret == AVERROR_EOF) {
-        if ((ret = ff_framesync_add_frame(fs, input, NULL)) < 0)
-            return ret;
-        if ((ret = ff_framesync_process_frame(fs, 0)) < 0)
-            return ret;
-        ret = 0;
     }
-    return ret;
+    av_assert0(mainpic);
+    mainpic->pts = av_rescale_q(fs->pts, fs->time_base, ctx->outputs[0]->time_base);
+    if (ctx->is_disabled)
+        secondpic = NULL;
+    *f0 = mainpic;
+    *f1 = secondpic;
+    return 0;
+}
+
+int ff_framesync_dualinput_get_writable(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)
+{
+    int ret;
+
+    ret = ff_framesync_dualinput_get(fs, f0, f1);
+    if (ret < 0)
+        return ret;
+    ret = ff_inlink_make_frame_writable(fs->parent->inputs[0], f0);
+    if (ret < 0) {
+        av_frame_free(f0);
+        av_frame_free(f1);
+        return ret;
+    }
+    return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/framesync.h b/mythtv/external/FFmpeg/libavfilter/framesync.h
index 7ba99d5d861..9fdc4d1ae2d 100644
--- a/mythtv/external/FFmpeg/libavfilter/framesync.h
+++ b/mythtv/external/FFmpeg/libavfilter/framesync.h
@@ -23,9 +23,14 @@
 
 #include "bufferqueue.h"
 
+enum EOFAction {
+    EOF_ACTION_REPEAT,
+    EOF_ACTION_ENDALL,
+    EOF_ACTION_PASS
+};
+
 /*
  * TODO
- * Callback-based API similar to dualinput.
  * Export convenient options.
  */
 
@@ -41,16 +46,9 @@
  * situations where some stream extend beyond the beginning or the end of
  * others can be configured.
  *
- * The basic working of this API is the following:
- *
- * - When a frame is available on any input, add it using
- *   ff_framesync_add_frame().
- *
- * - When a frame event is ready to be processed (i.e. after adding a frame
- *   or when requested on input):
- *   - call ff_framesync_next();
- *   - if fs->frame_ready is true, process the frames;
- *   - call ff_framesync_drop().
+ * The basic working of this API is the following: set the on_event
+ * callback, then call ff_framesync_activate() from the filter's activate
+ * callback.
  */
 
 /**
@@ -82,11 +80,6 @@ enum FFFrameSyncExtMode {
  */
 typedef struct FFFrameSyncIn {
 
-    /**
-     * Queue of incoming AVFrame, and NULL to mark EOF
-     */
-    struct FFBufQueue queue;
-
     /**
      * Extrapolation mode for timestamps before the first frame
      */
@@ -152,7 +145,11 @@ typedef struct FFFrameSyncIn {
  */
 typedef struct FFFrameSync {
     const AVClass *class;
-    void *parent;
+
+    /**
+     * Parent filter context.
+     */
+    AVFilterContext *parent;
 
     /**
      * Number of input streams
@@ -205,19 +202,37 @@ typedef struct FFFrameSync {
      */
     FFFrameSyncIn *in;
 
+    int opt_repeatlast;
+    int opt_shortest;
+    int opt_eof_action;
+
 } FFFrameSync;
 
 /**
- * Initialize a frame sync structure.
+ * Get the class for the framesync object.
+ */
+const AVClass *framesync_get_class(void);
+
+/**
+ * Pre-initialize a frame sync structure.
  *
+ * It sets the class pointer and inits the options to their default values.
  * The entire structure is expected to be already set to 0.
+ * This step is optional, but necessary to use the options.
+ */
+void ff_framesync_preinit(FFFrameSync *fs);
+
+/**
+ * Initialize a frame sync structure.
+ *
+ * The entire structure is expected to be already set to 0 or preinited.
  *
  * @param  fs      frame sync structure to initialize
- * @param  parent  parent object, used for logging
+ * @param  parent  parent AVFilterContext object
  * @param  nb_in   number of inputs
  * @return  >= 0 for success or a negative error code
  */
-int ff_framesync_init(FFFrameSync *fs, void *parent, unsigned nb_in);
+int ff_framesync_init(FFFrameSync *fs, AVFilterContext *parent, unsigned nb_in);
 
 /**
  * Configure a frame sync structure.
@@ -233,29 +248,6 @@ int ff_framesync_configure(FFFrameSync *fs);
  */
 void ff_framesync_uninit(FFFrameSync *fs);
 
-/**
- * Add a frame to an input
- *
- * Typically called from the filter_frame() method.
- *
- * @param fs     frame sync structure
- * @param in     index of the input
- * @param frame  input frame, or NULL for EOF
- */
-int ff_framesync_add_frame(FFFrameSync *fs, unsigned in, AVFrame *frame);
-
-/**
- * Prepare the next frame event.
- *
- * The status of the operation can be found in fs->frame_ready and fs->eof.
- */
-void ff_framesync_next(FFFrameSync *fs);
-
-/**
- * Drop the current frame event.
- */
-void ff_framesync_drop(FFFrameSync *fs);
-
 /**
  * Get the current frame in an input.
  *
@@ -267,31 +259,63 @@ void ff_framesync_drop(FFFrameSync *fs);
  *                duplicated or removed from the framesync structure
  */
 int ff_framesync_get_frame(FFFrameSync *fs, unsigned in, AVFrame **rframe,
-                           unsigned get);
+                            unsigned get);
 
 /**
- * Process one or several frame using the on_event callback.
+ * Examine the frames in the filter's input and try to produce output.
  *
- * @return  number of frames processed or negative error code
+ * This function can be the complete implementation of the activate
+ * method of a filter using framesync.
  */
-int ff_framesync_process_frame(FFFrameSync *fs, unsigned all);
-
+int ff_framesync_activate(FFFrameSync *fs);
 
 /**
- * Accept a frame on a filter input.
+ * Initialize a frame sync structure for dualinput.
+ *
+ * Compared to generic framesync, dualinput assumes the first input is the
+ * main one and the filtering is performed on it. The first input will be
+ * the only one with sync set and generic timeline support will just pass it
+ * unchanged when disabled.
  *
- * This function can be the complete implementation of all filter_frame
- * methods of a filter using framesync.
+ * Equivalent to ff_framesync_init(fs, parent, 2) then setting the time
+ * base, sync and ext modes on the inputs.
  */
-int ff_framesync_filter_frame(FFFrameSync *fs, AVFilterLink *inlink,
-                              AVFrame *in);
+int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent);
 
 /**
- * Request a frame on the filter output.
- *
- * This function can be the complete implementation of all filter_frame
- * methods of a filter using framesync if it has only one output.
+ * @param f0  used to return the main frame
+ * @param f1  used to return the second frame, or NULL if disabled
+ * @return  >=0 for success or AVERROR code
+ */
+int ff_framesync_dualinput_get(FFFrameSync *fs, AVFrame **f0, AVFrame **f1);
+
+/**
+ * Same as ff_framesync_dualinput_get(), but make sure that f0 is writable.
  */
-int ff_framesync_request_frame(FFFrameSync *fs, AVFilterLink *outlink);
+int ff_framesync_dualinput_get_writable(FFFrameSync *fs, AVFrame **f0, AVFrame **f1);
+
+#define FRAMESYNC_DEFINE_CLASS(name, context, field) \
+static int name##_framesync_preinit(AVFilterContext *ctx) { \
+    context *s = ctx->priv; \
+    ff_framesync_preinit(&s->field); \
+    return 0; \
+} \
+static const AVClass *name##_child_class_next(const AVClass *prev) { \
+    return prev ? NULL : framesync_get_class(); \
+} \
+static void *name##_child_next(void *obj, void *prev) { \
+    context *s = obj; \
+    s->fs.class = framesync_get_class(); /* FIXME */ \
+    return prev ? NULL : &s->field; \
+} \
+static const AVClass name##_class = { \
+    .class_name       = #name, \
+    .item_name        = av_default_item_name, \
+    .option           = name##_options, \
+    .version          = LIBAVUTIL_VERSION_INT, \
+    .category         = AV_CLASS_CATEGORY_FILTER, \
+    .child_class_next = name##_child_class_next, \
+    .child_next       = name##_child_next, \
+}
 
 #endif /* AVFILTER_FRAMESYNC_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/graphdump.c b/mythtv/external/FFmpeg/libavfilter/graphdump.c
index 531bb571aa4..73777191d63 100644
--- a/mythtv/external/FFmpeg/libavfilter/graphdump.c
+++ b/mythtv/external/FFmpeg/libavfilter/graphdump.c
@@ -25,7 +25,6 @@
 #include "libavutil/bprint.h"
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
-#include "avfiltergraph.h"
 #include "internal.h"
 
 static int print_link_prop(AVBPrint *buf, AVFilterLink *link)
diff --git a/mythtv/external/FFmpeg/libavfilter/graphparser.c b/mythtv/external/FFmpeg/libavfilter/graphparser.c
index 04b4272e058..1405926bfd5 100644
--- a/mythtv/external/FFmpeg/libavfilter/graphparser.c
+++ b/mythtv/external/FFmpeg/libavfilter/graphparser.c
@@ -88,20 +88,36 @@ static char *parse_link_name(const char **buf, void *log_ctx)
  * @param filt_ctx put here a filter context in case of successful creation and configuration, NULL otherwise.
  * @param ctx the filtergraph context
  * @param index an index which is supposed to be unique for each filter instance added to the filtergraph
- * @param filt_name the name of the filter to create
+ * @param name the name of the filter to create, can be filter name or filter_name\@id as instance name
  * @param args the arguments provided to the filter during its initialization
  * @param log_ctx the log context to use
  * @return >= 0 in case of success, a negative AVERROR code otherwise
  */
 static int create_filter(AVFilterContext **filt_ctx, AVFilterGraph *ctx, int index,
-                         const char *filt_name, const char *args, void *log_ctx)
+                         const char *name, const char *args, void *log_ctx)
 {
     AVFilter *filt;
-    char inst_name[30];
+    char name2[30];
+    const char *inst_name = NULL, *filt_name = NULL;
     char *tmp_args = NULL;
-    int ret;
+    int ret, k;
+
+    av_strlcpy(name2, name, sizeof(name2));
+
+    for (k = 0; name2[k]; k++) {
+        if (name2[k] == '@' && name[k+1]) {
+            name2[k] = 0;
+            inst_name = name;
+            filt_name = name2;
+            break;
+        }
+    }
 
-    snprintf(inst_name, sizeof(inst_name), "Parsed_%s_%d", filt_name, index);
+    if (!inst_name) {
+        snprintf(name2, sizeof(name2), "Parsed_%s_%d", name, index);
+        inst_name = name2;
+        filt_name = name;
+    }
 
     filt = avfilter_get_by_name(filt_name);
 
diff --git a/mythtv/external/FFmpeg/libavfilter/interlace.h b/mythtv/external/FFmpeg/libavfilter/interlace.h
index da073aeba36..90a0198bdc4 100644
--- a/mythtv/external/FFmpeg/libavfilter/interlace.h
+++ b/mythtv/external/FFmpeg/libavfilter/interlace.h
@@ -25,9 +25,11 @@
 #ifndef AVFILTER_INTERLACE_H
 #define AVFILTER_INTERLACE_H
 
+#include "libavutil/bswap.h"
 #include "libavutil/common.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
 
 #include "avfilter.h"
 #include "formats.h"
@@ -44,13 +46,20 @@ enum FieldType {
     FIELD_LOWER = 1,
 };
 
+enum VLPFilter {
+    VLPF_OFF = 0,
+    VLPF_LIN = 1,
+    VLPF_CMP = 2,
+};
+
 typedef struct InterlaceContext {
     const AVClass *class;
     enum ScanMode scan;    // top or bottom field first scanning
     int lowpass;           // enable or disable low pass filtering
     AVFrame *cur, *next;   // the two frames from which the new one is obtained
+    const AVPixFmtDescriptor *csp;
     void (*lowpass_line)(uint8_t *dstp, ptrdiff_t linesize, const uint8_t *srcp,
-                         const uint8_t *srcp_above, const uint8_t *srcp_below);
+                         ptrdiff_t mref, ptrdiff_t pref, int clip_max);
 } InterlaceContext;
 
 void ff_interlace_init_x86(InterlaceContext *interlace);
diff --git a/mythtv/external/FFmpeg/libavfilter/internal.h b/mythtv/external/FFmpeg/libavfilter/internal.h
index 3856012aa93..f9679ed1d77 100644
--- a/mythtv/external/FFmpeg/libavfilter/internal.h
+++ b/mythtv/external/FFmpeg/libavfilter/internal.h
@@ -26,13 +26,14 @@
 
 #include "libavutil/internal.h"
 #include "avfilter.h"
-#include "avfiltergraph.h"
 #include "formats.h"
 #include "framepool.h"
+#include "framequeue.h"
 #include "thread.h"
 #include "version.h"
 #include "video.h"
 #include "libavcodec/avcodec.h"
+#include "libavcodec/internal.h"
 
 typedef struct AVFilterCommand {
     double time;                ///< time expressed in seconds
@@ -147,6 +148,7 @@ struct AVFilterPad {
 struct AVFilterGraphInternal {
     void *thread;
     avfilter_execute_func *thread_execute;
+    FFFrameQueueGlobal frame_queues;
 };
 
 struct AVFilterInternal {
@@ -245,14 +247,6 @@ void ff_command_queue_pop(AVFilterContext *filter);
 
 /* misc trace functions */
 
-/* #define FF_AVFILTER_TRACE */
-
-#ifdef FF_AVFILTER_TRACE
-#    define ff_tlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
-#else
-#    define ff_tlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0)
-#endif
-
 #define FF_TPRINTF_START(ctx, func) ff_tlog(NULL, "%-16s: ", #func)
 
 char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms);
@@ -307,6 +301,9 @@ int ff_poll_frame(AVFilterLink *link);
 /**
  * Request an input frame from the filter at the other end of the link.
  *
+ * This function must not be used by filters using the activate callback,
+ * use ff_link_set_frame_wanted() instead.
+ *
  * The input filter may pass the request on to its inputs, fulfill the
  * request from an internal buffer or any other means specific to its function.
  *
@@ -334,8 +331,6 @@ int ff_poll_frame(AVFilterLink *link);
  */
 int ff_request_frame(AVFilterLink *link);
 
-int ff_request_frame_to_filter(AVFilterLink *link);
-
 #define AVFILTER_DEFINE_CLASS(fname)            \
     static const AVClass fname##_class = {      \
         .class_name = #fname,                   \
@@ -376,11 +371,19 @@ int ff_filter_frame(AVFilterLink *link, AVFrame *frame);
  */
 AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name);
 
+int ff_filter_activate(AVFilterContext *filter);
+
 /**
  * Remove a filter from a graph;
  */
 void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter);
 
+/**
+ * The filter is aware of hardware frames, and any hardware frame context
+ * should not be automatically propagated through it.
+ */
+#define FF_FILTER_FLAG_HWFRAME_AWARE (1 << 0)
+
 /**
  * Run one round of processing on a filter graph.
  */
diff --git a/mythtv/external/FFmpeg/libavfilter/lavfutils.c b/mythtv/external/FFmpeg/libavfilter/lavfutils.c
index 706badf63d3..b6319cf0275 100644
--- a/mythtv/external/FFmpeg/libavfilter/lavfutils.c
+++ b/mythtv/external/FFmpeg/libavfilter/lavfutils.c
@@ -29,6 +29,7 @@ int ff_load_image(uint8_t *data[4], int linesize[4],
     AVFormatContext *format_ctx = NULL;
     AVCodec *codec;
     AVCodecContext *codec_ctx;
+    AVCodecParameters *par;
     AVFrame *frame;
     int frame_decoded, ret = 0;
     AVPacket pkt;
@@ -38,7 +39,7 @@ int ff_load_image(uint8_t *data[4], int linesize[4],
 
     av_register_all();
 
-    iformat = av_find_input_format("image2");
+    iformat = av_find_input_format("image2pipe");
     if ((ret = avformat_open_input(&format_ctx, filename, iformat, NULL)) < 0) {
         av_log(log_ctx, AV_LOG_ERROR,
                "Failed to open input file '%s'\n", filename);
@@ -50,14 +51,27 @@ int ff_load_image(uint8_t *data[4], int linesize[4],
         return ret;
     }
 
-    codec_ctx = format_ctx->streams[0]->codec;
-    codec = avcodec_find_decoder(codec_ctx->codec_id);
+    par = format_ctx->streams[0]->codecpar;
+    codec = avcodec_find_decoder(par->codec_id);
     if (!codec) {
         av_log(log_ctx, AV_LOG_ERROR, "Failed to find codec\n");
         ret = AVERROR(EINVAL);
         goto end;
     }
 
+    codec_ctx = avcodec_alloc_context3(codec);
+    if (!codec_ctx) {
+        av_log(log_ctx, AV_LOG_ERROR, "Failed to alloc video decoder context\n");
+        ret = AVERROR(ENOMEM);
+        goto end;
+    }
+
+    ret = avcodec_parameters_to_context(codec_ctx, par);
+    if (ret < 0) {
+        av_log(log_ctx, AV_LOG_ERROR, "Failed to copy codec parameters to decoder context\n");
+        goto end;
+    }
+
     av_dict_set(&opt, "thread_type", "slice", 0);
     if ((ret = avcodec_open2(codec_ctx, codec, &opt)) < 0) {
         av_log(log_ctx, AV_LOG_ERROR, "Failed to open codec\n");
@@ -96,7 +110,7 @@ int ff_load_image(uint8_t *data[4], int linesize[4],
 
 end:
     av_packet_unref(&pkt);
-    avcodec_close(codec_ctx);
+    avcodec_free_context(&codec_ctx);
     avformat_close_input(&format_ctx);
     av_frame_free(&frame);
     av_dict_free(&opt);
diff --git a/mythtv/external/FFmpeg/libavfilter/limiter.h b/mythtv/external/FFmpeg/libavfilter/limiter.h
new file mode 100644
index 00000000000..54d423d1f4b
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/limiter.h
@@ -0,0 +1,33 @@
+/*
+ * 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 AVFILTER_LIMITER_H
+#define AVFILTER_LIMITER_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct LimiterDSPContext {
+    void (*limiter)(const uint8_t *src, uint8_t *dst,
+                    ptrdiff_t slinesize, ptrdiff_t dlinesize,
+                    int w, int h, int min, int max);
+} LimiterDSPContext;
+
+void ff_limiter_init_x86(LimiterDSPContext *dsp, int bpp);
+
+#endif /* AVFILTER_LIMITER_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/maskedmerge.h b/mythtv/external/FFmpeg/libavfilter/maskedmerge.h
index a8c7551bad7..8e2b1cf676c 100644
--- a/mythtv/external/FFmpeg/libavfilter/maskedmerge.h
+++ b/mythtv/external/FFmpeg/libavfilter/maskedmerge.h
@@ -27,6 +27,7 @@
 typedef struct MaskedMergeContext {
     const AVClass *class;
     int width[4], height[4];
+    int linesize[4];
     int nb_planes;
     int planes;
     int half, depth;
diff --git a/mythtv/external/FFmpeg/libavfilter/pthread.c b/mythtv/external/FFmpeg/libavfilter/pthread.c
index ccb915eae56..567dd4c178c 100644
--- a/mythtv/external/FFmpeg/libavfilter/pthread.c
+++ b/mythtv/external/FFmpeg/libavfilter/pthread.c
@@ -27,6 +27,7 @@
 #include "libavutil/cpu.h"
 #include "libavutil/mem.h"
 #include "libavutil/thread.h"
+#include "libavutil/slicethread.h"
 
 #include "avfilter.h"
 #include "internal.h"
@@ -34,160 +35,50 @@
 
 typedef struct ThreadContext {
     AVFilterGraph *graph;
-
-    int nb_threads;
-    pthread_t *workers;
+    AVSliceThread *thread;
     avfilter_action_func *func;
 
     /* per-execute parameters */
     AVFilterContext *ctx;
     void *arg;
     int   *rets;
-    int nb_rets;
-    int nb_jobs;
-
-    pthread_cond_t last_job_cond;
-    pthread_cond_t current_job_cond;
-    pthread_mutex_t current_job_lock;
-    int current_job;
-    unsigned int current_execute;
-    int done;
 } ThreadContext;
 
-static void* attribute_align_arg worker(void *v)
+static void worker_func(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
 {
-    ThreadContext *c = v;
-    int our_job      = c->nb_jobs;
-    int nb_threads   = c->nb_threads;
-    unsigned int last_execute = 0;
-    int self_id;
-
-    pthread_mutex_lock(&c->current_job_lock);
-    self_id = c->current_job++;
-    for (;;) {
-        while (our_job >= c->nb_jobs) {
-            if (c->current_job == nb_threads + c->nb_jobs)
-                pthread_cond_signal(&c->last_job_cond);
-
-            while (last_execute == c->current_execute && !c->done)
-                pthread_cond_wait(&c->current_job_cond, &c->current_job_lock);
-            last_execute = c->current_execute;
-            our_job = self_id;
-
-            if (c->done) {
-                pthread_mutex_unlock(&c->current_job_lock);
-                return NULL;
-            }
-        }
-        pthread_mutex_unlock(&c->current_job_lock);
-
-        c->rets[our_job % c->nb_rets] = c->func(c->ctx, c->arg, our_job, c->nb_jobs);
-
-        pthread_mutex_lock(&c->current_job_lock);
-        our_job = c->current_job++;
-    }
+    ThreadContext *c = priv;
+    int ret = c->func(c->ctx, c->arg, jobnr, nb_jobs);
+    if (c->rets)
+        c->rets[jobnr] = ret;
 }
 
 static void slice_thread_uninit(ThreadContext *c)
 {
-    int i;
-
-    pthread_mutex_lock(&c->current_job_lock);
-    c->done = 1;
-    pthread_cond_broadcast(&c->current_job_cond);
-    pthread_mutex_unlock(&c->current_job_lock);
-
-    for (i = 0; i < c->nb_threads; i++)
-         pthread_join(c->workers[i], NULL);
-
-    pthread_mutex_destroy(&c->current_job_lock);
-    pthread_cond_destroy(&c->current_job_cond);
-    pthread_cond_destroy(&c->last_job_cond);
-    av_freep(&c->workers);
-}
-
-static void slice_thread_park_workers(ThreadContext *c)
-{
-    while (c->current_job != c->nb_threads + c->nb_jobs)
-        pthread_cond_wait(&c->last_job_cond, &c->current_job_lock);
-    pthread_mutex_unlock(&c->current_job_lock);
+    avpriv_slicethread_free(&c->thread);
 }
 
 static int thread_execute(AVFilterContext *ctx, avfilter_action_func *func,
                           void *arg, int *ret, int nb_jobs)
 {
     ThreadContext *c = ctx->graph->internal->thread;
-    int dummy_ret;
 
     if (nb_jobs <= 0)
         return 0;
-
-    pthread_mutex_lock(&c->current_job_lock);
-
-    c->current_job = c->nb_threads;
-    c->nb_jobs     = nb_jobs;
     c->ctx         = ctx;
     c->arg         = arg;
     c->func        = func;
-    if (ret) {
-        c->rets    = ret;
-        c->nb_rets = nb_jobs;
-    } else {
-        c->rets    = &dummy_ret;
-        c->nb_rets = 1;
-    }
-    c->current_execute++;
-
-    pthread_cond_broadcast(&c->current_job_cond);
-
-    slice_thread_park_workers(c);
+    c->rets        = ret;
 
+    avpriv_slicethread_execute(c->thread, nb_jobs, 0);
     return 0;
 }
 
 static int thread_init_internal(ThreadContext *c, int nb_threads)
 {
-    int i, ret;
-
-    if (!nb_threads) {
-        int nb_cpus = av_cpu_count();
-        // use number of cores + 1 as thread count if there is more than one
-        if (nb_cpus > 1)
-            nb_threads = nb_cpus + 1;
-        else
-            nb_threads = 1;
-    }
-
+    nb_threads = avpriv_slicethread_create(&c->thread, c, worker_func, NULL, nb_threads);
     if (nb_threads <= 1)
-        return 1;
-
-    c->nb_threads = nb_threads;
-    c->workers = av_mallocz_array(sizeof(*c->workers), nb_threads);
-    if (!c->workers)
-        return AVERROR(ENOMEM);
-
-    c->current_job = 0;
-    c->nb_jobs     = 0;
-    c->done        = 0;
-
-    pthread_cond_init(&c->current_job_cond, NULL);
-    pthread_cond_init(&c->last_job_cond,    NULL);
-
-    pthread_mutex_init(&c->current_job_lock, NULL);
-    pthread_mutex_lock(&c->current_job_lock);
-    for (i = 0; i < nb_threads; i++) {
-        ret = pthread_create(&c->workers[i], NULL, worker, c);
-        if (ret) {
-           pthread_mutex_unlock(&c->current_job_lock);
-           c->nb_threads = i;
-           slice_thread_uninit(c);
-           return AVERROR(ret);
-        }
-    }
-
-    slice_thread_park_workers(c);
-
-    return c->nb_threads;
+        avpriv_slicethread_free(&c->thread);
+    return FFMAX(nb_threads, 1);
 }
 
 int ff_graph_thread_init(AVFilterGraph *graph)
diff --git a/mythtv/external/FFmpeg/libavfilter/scale.c b/mythtv/external/FFmpeg/libavfilter/scale.c
new file mode 100644
index 00000000000..eaee95fac6a
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/scale.c
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2007 Bobby Bingham
+ *
+ * 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 <stdint.h>
+#include "scale.h"
+#include "libavutil/eval.h"
+#include "libavutil/mathematics.h"
+#include "libavutil/pixdesc.h"
+
+static const char *const var_names[] = {
+    "PI",
+    "PHI",
+    "E",
+    "in_w",   "iw",
+    "in_h",   "ih",
+    "out_w",  "ow",
+    "out_h",  "oh",
+    "a",
+    "sar",
+    "dar",
+    "hsub",
+    "vsub",
+    "ohsub",
+    "ovsub",
+    NULL
+};
+
+enum var_name {
+    VAR_PI,
+    VAR_PHI,
+    VAR_E,
+    VAR_IN_W,   VAR_IW,
+    VAR_IN_H,   VAR_IH,
+    VAR_OUT_W,  VAR_OW,
+    VAR_OUT_H,  VAR_OH,
+    VAR_A,
+    VAR_SAR,
+    VAR_DAR,
+    VAR_HSUB,
+    VAR_VSUB,
+    VAR_OHSUB,
+    VAR_OVSUB,
+    VARS_NB
+};
+
+/**
+ * This must be kept in sync with var_names so that it is always a
+ * complete list of var_names with the scale2ref specific names
+ * appended. scale2ref values must appear in the order they appear
+ * in the var_name_scale2ref enum but also be below all of the
+ * non-scale2ref specific values.
+ */
+static const char *const var_names_scale2ref[] = {
+    "PI",
+    "PHI",
+    "E",
+    "in_w",   "iw",
+    "in_h",   "ih",
+    "out_w",  "ow",
+    "out_h",  "oh",
+    "a",
+    "sar",
+    "dar",
+    "hsub",
+    "vsub",
+    "ohsub",
+    "ovsub",
+    "main_w",
+    "main_h",
+    "main_a",
+    "main_sar",
+    "main_dar", "mdar",
+    "main_hsub",
+    "main_vsub",
+    NULL
+};
+
+enum var_name_scale2ref {
+    VAR_S2R_MAIN_W,
+    VAR_S2R_MAIN_H,
+    VAR_S2R_MAIN_A,
+    VAR_S2R_MAIN_SAR,
+    VAR_S2R_MAIN_DAR, VAR_S2R_MDAR,
+    VAR_S2R_MAIN_HSUB,
+    VAR_S2R_MAIN_VSUB,
+    VARS_S2R_NB
+};
+
+int ff_scale_eval_dimensions(void *log_ctx,
+    const char *w_expr, const char *h_expr,
+    AVFilterLink *inlink, AVFilterLink *outlink,
+    int *ret_w, int *ret_h)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    const AVPixFmtDescriptor *out_desc = av_pix_fmt_desc_get(outlink->format);
+    const char *expr;
+    int w, h;
+    int factor_w, factor_h;
+    int eval_w, eval_h;
+    int ret;
+    const char scale2ref = outlink->src->nb_inputs == 2 && outlink->src->inputs[1] == inlink;
+    double var_values[VARS_NB + VARS_S2R_NB], res;
+    const AVPixFmtDescriptor *main_desc;
+    const AVFilterLink *main_link;
+    const char *const *names = scale2ref ? var_names_scale2ref : var_names;
+
+    if (scale2ref) {
+        main_link = outlink->src->inputs[0];
+        main_desc = av_pix_fmt_desc_get(main_link->format);
+    }
+
+    var_values[VAR_PI]    = M_PI;
+    var_values[VAR_PHI]   = M_PHI;
+    var_values[VAR_E]     = M_E;
+    var_values[VAR_IN_W]  = var_values[VAR_IW] = inlink->w;
+    var_values[VAR_IN_H]  = var_values[VAR_IH] = inlink->h;
+    var_values[VAR_OUT_W] = var_values[VAR_OW] = NAN;
+    var_values[VAR_OUT_H] = var_values[VAR_OH] = NAN;
+    var_values[VAR_A]     = (double) inlink->w / inlink->h;
+    var_values[VAR_SAR]   = inlink->sample_aspect_ratio.num ?
+        (double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1;
+    var_values[VAR_DAR]   = var_values[VAR_A] * var_values[VAR_SAR];
+    var_values[VAR_HSUB]  = 1 << desc->log2_chroma_w;
+    var_values[VAR_VSUB]  = 1 << desc->log2_chroma_h;
+    var_values[VAR_OHSUB] = 1 << out_desc->log2_chroma_w;
+    var_values[VAR_OVSUB] = 1 << out_desc->log2_chroma_h;
+
+    if (scale2ref) {
+        var_values[VARS_NB + VAR_S2R_MAIN_W] = main_link->w;
+        var_values[VARS_NB + VAR_S2R_MAIN_H] = main_link->h;
+        var_values[VARS_NB + VAR_S2R_MAIN_A] = (double) main_link->w / main_link->h;
+        var_values[VARS_NB + VAR_S2R_MAIN_SAR] = main_link->sample_aspect_ratio.num ?
+            (double) main_link->sample_aspect_ratio.num / main_link->sample_aspect_ratio.den : 1;
+        var_values[VARS_NB + VAR_S2R_MAIN_DAR] = var_values[VARS_NB + VAR_S2R_MDAR] =
+            var_values[VARS_NB + VAR_S2R_MAIN_A] * var_values[VARS_NB + VAR_S2R_MAIN_SAR];
+        var_values[VARS_NB + VAR_S2R_MAIN_HSUB] = 1 << main_desc->log2_chroma_w;
+        var_values[VARS_NB + VAR_S2R_MAIN_VSUB] = 1 << main_desc->log2_chroma_h;
+    }
+
+    /* evaluate width and height */
+    av_expr_parse_and_eval(&res, (expr = w_expr),
+                           names, var_values,
+                           NULL, NULL, NULL, NULL, NULL, 0, log_ctx);
+    eval_w = var_values[VAR_OUT_W] = var_values[VAR_OW] = (int) res == 0 ? inlink->w : (int) res;
+
+    if ((ret = av_expr_parse_and_eval(&res, (expr = h_expr),
+                                      names, var_values,
+                                      NULL, NULL, NULL, NULL, NULL, 0, log_ctx)) < 0)
+        goto fail;
+    eval_h = var_values[VAR_OUT_H] = var_values[VAR_OH] = (int) res == 0 ? inlink->h : (int) res;
+    /* evaluate again the width, as it may depend on the output height */
+    if ((ret = av_expr_parse_and_eval(&res, (expr = w_expr),
+                                      names, var_values,
+                                      NULL, NULL, NULL, NULL, NULL, 0, log_ctx)) < 0)
+        goto fail;
+    eval_w = (int) res == 0 ? inlink->w : (int) res;
+
+    w = eval_w;
+    h = eval_h;
+
+    /* Check if it is requested that the result has to be divisible by a some
+     * factor (w or h = -n with n being the factor). */
+    factor_w = 1;
+    factor_h = 1;
+    if (w < -1) {
+        factor_w = -w;
+    }
+    if (h < -1) {
+        factor_h = -h;
+    }
+
+    if (w < 0 && h < 0) {
+        w = inlink->w;
+        h = inlink->h;
+    }
+
+    /* Make sure that the result is divisible by the factor we determined
+     * earlier. If no factor was set, it is nothing will happen as the default
+     * factor is 1 */
+    if (w < 0)
+        w = av_rescale(h, inlink->w, inlink->h * factor_w) * factor_w;
+    if (h < 0)
+        h = av_rescale(w, inlink->h, inlink->w * factor_h) * factor_h;
+
+    *ret_w = w;
+    *ret_h = h;
+
+    return 0;
+
+fail:
+    av_log(log_ctx, AV_LOG_ERROR,
+           "Error when evaluating the expression '%s'.\n"
+           "Maybe the expression for out_w:'%s' or for out_h:'%s' is self-referencing.\n",
+           expr, w_expr, h_expr);
+    return ret;
+}
diff --git a/mythtv/external/FFmpeg/libavfilter/scale.h b/mythtv/external/FFmpeg/libavfilter/scale.h
new file mode 100644
index 00000000000..dfe67d0be01
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/scale.h
@@ -0,0 +1,28 @@
+/*
+ * 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 AVFILTER_SCALE_H
+#define AVFILTER_SCALE_H
+
+#include "avfilter.h"
+
+int ff_scale_eval_dimensions(void *ctx,
+    const char *w_expr, const char *h_expr,
+    AVFilterLink *inlink, AVFilterLink *outlink,
+    int *ret_w, int *ret_h);
+#endif
diff --git a/mythtv/external/FFmpeg/libavfilter/setpts.c b/mythtv/external/FFmpeg/libavfilter/setpts.c
index 2ccca28e9ae..4505498bf34 100644
--- a/mythtv/external/FFmpeg/libavfilter/setpts.c
+++ b/mythtv/external/FFmpeg/libavfilter/setpts.c
@@ -165,7 +165,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     }
     setpts->var_values[VAR_PTS       ] = TS2D(frame->pts);
     setpts->var_values[VAR_T         ] = TS2T(frame->pts, inlink->time_base);
-    setpts->var_values[VAR_POS       ] = av_frame_get_pkt_pos(frame) == -1 ? NAN : av_frame_get_pkt_pos(frame);
+    setpts->var_values[VAR_POS       ] = frame->pkt_pos == -1 ? NAN : frame->pkt_pos;
     setpts->var_values[VAR_RTCTIME   ] = av_gettime();
 
     if (inlink->type == AVMEDIA_TYPE_VIDEO) {
diff --git a/mythtv/external/FFmpeg/libavfilter/signature.h b/mythtv/external/FFmpeg/libavfilter/signature.h
new file mode 100644
index 00000000000..cc198dbaa03
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/signature.h
@@ -0,0 +1,569 @@
+/*
+ * Copyright (c) 2017 Gerion Entrup
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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
+ * MPEG-7 video signature calculation and lookup filter
+ */
+
+#ifndef AVFILTER_SIGNATURE_H
+#define AVFILTER_SIGNATURE_H
+
+#include <float.h>
+#include "libavutil/common.h"
+#include "libavutil/opt.h"
+#include "libavutil/timestamp.h"
+#include "avfilter.h"
+#include "internal.h"
+
+#define ELEMENT_COUNT 10
+#define SIGELEM_SIZE 380
+#define DIFFELEM_SIZE 348 /* SIGELEM_SIZE - elem_a1 - elem_a2 */
+#define COARSE_SIZE 90
+
+enum lookup_mode {
+    MODE_OFF,
+    MODE_FULL,
+    MODE_FAST,
+    NB_LOOKUP_MODE
+};
+
+enum formats {
+    FORMAT_BINARY,
+    FORMAT_XML,
+    NB_FORMATS
+};
+
+typedef struct Point {
+    uint8_t x;
+    uint8_t y;
+} Point;
+
+typedef struct Block {
+    Point up;
+    Point to;
+} Block;
+
+typedef struct ElemCat {
+    int av_elem; /* average element category */
+    short left_count; /* count of blocks that will be added together */
+    short block_count; /* count of blocks per element */
+    short elem_count;
+    const Block* blocks;
+} ElemCat;
+
+typedef struct FineSignature {
+    struct FineSignature* next;
+    struct FineSignature* prev;
+    uint64_t pts;
+    uint32_t index; /* needed for xmlexport */
+    uint8_t confidence;
+    uint8_t words[5];
+    uint8_t framesig[SIGELEM_SIZE/5];
+} FineSignature;
+
+typedef struct CoarseSignature {
+    uint8_t data[5][31]; /* 5 words with min. 243 bit */
+    struct FineSignature* first; /* associated Finesignatures */
+    struct FineSignature* last;
+    struct CoarseSignature* next;
+} CoarseSignature;
+
+/* lookup types */
+typedef struct MatchingInfo {
+    double meandist;
+    double framerateratio; /* second/first */
+    int score;
+    int offset;
+    int matchframes; /* number of matching frames */
+    int whole;
+    struct FineSignature* first;
+    struct FineSignature* second;
+    struct MatchingInfo* next;
+} MatchingInfo;
+
+typedef struct StreamContext {
+    AVRational time_base;
+    /* needed for xml_export */
+    int w; /* height */
+    int h; /* width */
+
+    /* overflow protection */
+    int divide;
+
+    FineSignature* finesiglist;
+    FineSignature* curfinesig;
+
+    CoarseSignature* coarsesiglist;
+    CoarseSignature* coarseend; /* needed for xml export */
+    /* helpers to store the alternating signatures */
+    CoarseSignature* curcoarsesig1;
+    CoarseSignature* curcoarsesig2;
+
+    int coarsecount; /* counter from 0 to 89 */
+    int midcoarse;   /* whether it is a coarsesignature beginning from 45 + i * 90 */
+    uint32_t lastindex; /* helper to store amount of frames */
+
+    int exported; /* boolean whether stream already exported */
+} StreamContext;
+
+typedef struct SignatureContext {
+    const AVClass *class;
+    /* input parameters */
+    int mode;
+    int nb_inputs;
+    char *filename;
+    int format;
+    int thworddist;
+    int thcomposdist;
+    int thl1;
+    int thdi;
+    int thit;
+    /* end input parameters */
+
+    uint8_t l1distlut[243*242/2]; /* 243 + 242 + 241 ... */
+    StreamContext* streamcontexts;
+} SignatureContext;
+
+
+static const Block elem_a1_data[] = {
+    {{ 0, 0},{ 7, 7}},
+    {{ 8, 0},{15, 7}},
+    {{ 0, 8},{ 7,15}},
+    {{ 8, 8},{15,15}},
+    {{16, 0},{23, 7}},
+    {{24, 0},{31, 7}},
+    {{16, 8},{23,15}},
+    {{24, 8},{31,15}},
+    {{ 0,16},{ 7,23}},
+    {{ 8,16},{15,23}},
+    {{ 0,24},{ 7,31}},
+    {{ 8,24},{15,31}},
+    {{16,16},{23,23}},
+    {{24,16},{31,23}},
+    {{16,24},{23,31}},
+    {{24,24},{31,31}},
+    {{ 0, 0},{15,15}},
+    {{16, 0},{31,15}},
+    {{ 0,16},{15,31}},
+    {{16,16},{31,31}}
+};
+static const ElemCat elem_a1 = { 1, 1, 1, 20, elem_a1_data };
+
+static const Block elem_a2_data[] = {
+    {{ 2, 2},{ 9, 9}},
+    {{12, 2},{19, 9}},
+    {{22, 2},{29, 9}},
+    {{ 2,12},{ 9,19}},
+    {{12,12},{19,19}},
+    {{22,12},{29,19}},
+    {{ 2,22},{ 9,29}},
+    {{12,22},{19,29}},
+    {{22,22},{29,29}},
+    {{ 9, 9},{22,22}},
+    {{ 6, 6},{25,25}},
+    {{ 3, 3},{28,28}}
+};
+static const ElemCat elem_a2 = { 1, 1, 1, 12, elem_a2_data };
+
+static const Block elem_d1_data[] = {
+    {{ 0, 0},{ 1, 3}},{{ 2, 0},{ 3, 3}},
+    {{ 4, 0},{ 7, 1}},{{ 4, 2},{ 7, 3}},
+    {{ 0, 6},{ 3, 7}},{{ 0, 4},{ 3, 5}},
+    {{ 6, 4},{ 7, 7}},{{ 4, 4},{ 5, 7}},
+    {{ 8, 0},{ 9, 3}},{{10, 0},{11, 3}},
+    {{12, 0},{15, 1}},{{12, 2},{15, 3}},
+    {{ 8, 6},{11, 7}},{{ 8, 4},{11, 5}},
+    {{14, 4},{15, 7}},{{12, 4},{13, 7}},
+    {{ 0, 8},{ 1,11}},{{ 2, 8},{ 3,11}},
+    {{ 4, 8},{ 7, 9}},{{ 4,10},{ 7,11}},
+    {{ 0,14},{ 3,15}},{{ 0,12},{ 3,13}},
+    {{ 6,12},{ 7,15}},{{ 4,12},{ 5,15}},
+    {{ 8, 8},{ 9,11}},{{10, 8},{11,11}},
+    {{12, 8},{15, 9}},{{12,10},{15,11}},
+    {{ 8,14},{11,15}},{{ 8,12},{11,13}},
+    {{14,12},{15,15}},{{12,12},{13,15}},
+    {{16, 0},{19, 1}},{{16, 2},{19, 3}},
+    {{22, 0},{23, 3}},{{20, 0},{21, 3}},
+    {{16, 4},{17, 7}},{{18, 4},{19, 7}},
+    {{20, 6},{23, 7}},{{20, 4},{23, 5}},
+    {{24, 0},{27, 1}},{{24, 2},{27, 3}},
+    {{30, 0},{31, 3}},{{28, 0},{29, 3}},
+    {{24, 4},{25, 7}},{{26, 4},{27, 7}},
+    {{28, 6},{31, 7}},{{28, 4},{31, 5}},
+    {{16, 8},{19, 9}},{{16,10},{19,11}},
+    {{22, 8},{23,11}},{{20, 8},{21,11}},
+    {{16,12},{17,15}},{{18,12},{19,15}},
+    {{20,14},{23,15}},{{20,12},{23,13}},
+    {{24, 8},{27, 9}},{{24,10},{27,11}},
+    {{30, 8},{31,11}},{{28, 8},{29,11}},
+    {{24,12},{25,15}},{{26,12},{27,15}},
+    {{28,14},{31,15}},{{28,12},{31,13}},
+    {{ 0,16},{ 3,17}},{{ 0,18},{ 3,19}},
+    {{ 6,16},{ 7,19}},{{ 4,16},{ 5,19}},
+    {{ 0,20},{ 1,23}},{{ 2,20},{ 3,23}},
+    {{ 4,22},{ 7,23}},{{ 4,20},{ 7,21}},
+    {{ 8,16},{11,17}},{{ 8,18},{11,19}},
+    {{14,16},{15,19}},{{12,16},{13,19}},
+    {{ 8,20},{ 9,23}},{{10,20},{11,23}},
+    {{12,22},{15,23}},{{12,20},{15,21}},
+    {{ 0,24},{ 3,25}},{{ 0,26},{ 3,27}},
+    {{ 6,24},{ 7,27}},{{ 4,24},{ 5,27}},
+    {{ 0,28},{ 1,31}},{{ 2,28},{ 3,31}},
+    {{ 4,30},{ 7,31}},{{ 4,28},{ 7,29}},
+    {{ 8,24},{11,25}},{{ 8,26},{11,27}},
+    {{14,24},{15,27}},{{12,24},{13,27}},
+    {{ 8,28},{ 9,31}},{{10,28},{11,31}},
+    {{12,30},{15,31}},{{12,28},{15,29}},
+    {{16,16},{17,19}},{{18,16},{19,19}},
+    {{20,16},{23,17}},{{20,18},{23,19}},
+    {{16,22},{19,23}},{{16,20},{19,21}},
+    {{22,20},{23,23}},{{20,20},{21,23}},
+    {{24,16},{25,19}},{{26,16},{27,19}},
+    {{28,16},{31,17}},{{28,18},{31,19}},
+    {{24,22},{27,23}},{{24,20},{27,21}},
+    {{30,20},{31,23}},{{28,20},{29,23}},
+    {{16,24},{17,27}},{{18,24},{19,27}},
+    {{20,24},{23,25}},{{20,26},{23,27}},
+    {{16,30},{19,31}},{{16,28},{19,29}},
+    {{22,28},{23,31}},{{20,28},{21,31}},
+    {{24,24},{25,27}},{{26,24},{27,27}},
+    {{28,24},{31,25}},{{28,26},{31,27}},
+    {{24,30},{27,31}},{{24,28},{27,29}},
+    {{30,28},{31,31}},{{28,28},{29,31}},
+    {{ 2, 2},{ 3, 5}},{{ 4, 2},{ 5, 5}},
+    {{ 6, 2},{ 9, 3}},{{ 6, 4},{ 9, 5}},
+    {{ 2, 8},{ 5, 9}},{{ 2, 6},{ 5, 7}},
+    {{ 8, 6},{ 9, 9}},{{ 6, 6},{ 7, 9}},
+    {{12, 2},{13, 5}},{{14, 2},{15, 5}},
+    {{16, 2},{19, 3}},{{16, 4},{19, 5}},
+    {{12, 8},{15, 9}},{{12, 6},{15, 7}},
+    {{18, 6},{19, 9}},{{16, 6},{17, 9}},
+    {{22, 2},{23, 5}},{{24, 2},{25, 5}},
+    {{26, 2},{29, 3}},{{26, 4},{29, 5}},
+    {{22, 8},{25, 9}},{{22, 6},{25, 7}},
+    {{28, 6},{29, 9}},{{26, 6},{27, 9}},
+    {{ 2,12},{ 3,15}},{{ 4,12},{ 5,15}},
+    {{ 6,12},{ 9,13}},{{ 6,14},{ 9,15}},
+    {{ 2,18},{ 5,19}},{{ 2,16},{ 5,17}},
+    {{ 8,16},{ 9,19}},{{ 6,16},{ 7,19}},
+    {{12,12},{15,13}},{{12,14},{15,15}},
+    {{16,12},{19,13}},{{16,14},{19,15}},
+    {{12,18},{15,19}},{{12,16},{15,17}},
+    {{16,18},{19,19}},{{16,16},{19,17}},
+    {{22,12},{23,15}},{{24,12},{25,15}},
+    {{26,12},{29,13}},{{26,14},{29,15}},
+    {{22,18},{25,19}},{{22,16},{25,17}},
+    {{28,16},{29,19}},{{26,16},{27,19}},
+    {{ 2,22},{ 3,25}},{{ 4,22},{ 5,25}},
+    {{ 6,22},{ 9,23}},{{ 6,24},{ 9,25}},
+    {{ 2,28},{ 5,29}},{{ 2,26},{ 5,27}},
+    {{ 8,26},{ 9,29}},{{ 6,26},{ 7,29}},
+    {{12,22},{13,25}},{{14,22},{15,25}},
+    {{16,22},{19,23}},{{16,24},{19,25}},
+    {{12,28},{15,29}},{{12,26},{15,27}},
+    {{18,26},{19,29}},{{16,26},{17,29}},
+    {{22,22},{23,25}},{{24,22},{25,25}},
+    {{26,22},{29,23}},{{26,24},{29,25}},
+    {{22,28},{25,29}},{{22,26},{25,27}},
+    {{28,26},{29,29}},{{26,26},{27,29}},
+    {{ 7, 7},{10, 8}},{{ 7, 9},{10,10}},
+    {{11, 7},{12,10}},{{13, 7},{14,10}},
+    {{ 7,11},{ 8,14}},{{ 9,11},{10,14}},
+    {{11,11},{14,12}},{{11,13},{14,14}},
+    {{17, 7},{20, 8}},{{17, 9},{20,10}},
+    {{21, 7},{22,10}},{{23, 7},{24,10}},
+    {{17,11},{18,14}},{{19,11},{20,14}},
+    {{21,11},{24,12}},{{21,13},{24,14}},
+    {{ 7,17},{10,18}},{{ 7,19},{10,20}},
+    {{11,17},{12,20}},{{13,17},{14,20}},
+    {{ 7,21},{ 8,24}},{{ 9,21},{10,24}},
+    {{11,21},{14,22}},{{11,23},{14,24}},
+    {{17,17},{20,18}},{{17,19},{20,20}},
+    {{21,17},{22,20}},{{23,17},{24,20}},
+    {{17,21},{18,24}},{{19,21},{20,24}},
+    {{21,21},{24,22}},{{21,23},{24,24}}
+};
+static const ElemCat elem_d1 = { 0, 1, 2, 116, elem_d1_data };
+
+static const Block elem_d2_data[] = {
+    {{ 0, 0},{ 3, 3}},{{ 4, 4},{ 7, 7}},{{ 4, 0},{ 7, 3}},{{ 0, 4},{ 3, 7}},
+    {{ 8, 0},{11, 3}},{{12, 4},{15, 7}},{{12, 0},{15, 3}},{{ 8, 4},{11, 7}},
+    {{16, 0},{19, 3}},{{20, 4},{23, 7}},{{20, 0},{23, 3}},{{16, 4},{19, 7}},
+    {{24, 0},{27, 3}},{{28, 4},{31, 7}},{{28, 0},{31, 3}},{{24, 4},{27, 7}},
+    {{ 0, 8},{ 3,11}},{{ 4,12},{ 7,15}},{{ 4, 8},{ 7,11}},{{ 0,12},{ 3,15}},
+    {{ 8, 8},{11,11}},{{12,12},{15,15}},{{12, 8},{15,11}},{{ 8,12},{11,15}},
+    {{16, 8},{19,11}},{{20,12},{23,15}},{{20, 8},{23,11}},{{16,12},{19,15}},
+    {{24, 8},{27,11}},{{28,12},{31,15}},{{28, 8},{31,11}},{{24,12},{27,15}},
+    {{ 0,16},{ 3,19}},{{ 4,20},{ 7,23}},{{ 4,16},{ 7,19}},{{ 0,20},{ 3,23}},
+    {{ 8,16},{11,19}},{{12,20},{15,23}},{{12,16},{15,19}},{{ 8,20},{11,23}},
+    {{16,16},{19,19}},{{20,20},{23,23}},{{20,16},{23,19}},{{16,20},{19,23}},
+    {{24,16},{27,19}},{{28,20},{31,23}},{{28,16},{31,19}},{{24,20},{27,23}},
+    {{ 0,24},{ 3,27}},{{ 4,28},{ 7,31}},{{ 4,24},{ 7,27}},{{ 0,28},{ 3,31}},
+    {{ 8,24},{11,27}},{{12,28},{15,31}},{{12,24},{15,27}},{{ 8,28},{11,31}},
+    {{16,24},{19,27}},{{20,28},{23,31}},{{20,24},{23,27}},{{16,28},{19,31}},
+    {{24,24},{27,27}},{{28,28},{31,31}},{{28,24},{31,27}},{{24,28},{27,31}},
+    {{ 4, 4},{ 7, 7}},{{ 8, 8},{11,11}},{{ 8, 4},{11, 7}},{{ 4, 8},{ 7,11}},
+    {{12, 4},{15, 7}},{{16, 8},{19,11}},{{16, 4},{19, 7}},{{12, 8},{15,11}},
+    {{20, 4},{23, 7}},{{24, 8},{27,11}},{{24, 4},{27, 7}},{{20, 8},{23,11}},
+    {{ 4,12},{ 7,15}},{{ 8,16},{11,19}},{{ 8,12},{11,15}},{{ 4,16},{ 7,19}},
+    {{12,12},{15,15}},{{16,16},{19,19}},{{16,12},{19,15}},{{12,16},{15,19}},
+    {{20,12},{23,15}},{{24,16},{27,19}},{{24,12},{27,15}},{{20,16},{23,19}},
+    {{ 4,20},{ 7,23}},{{ 8,24},{11,27}},{{ 8,20},{11,23}},{{ 4,24},{ 7,27}},
+    {{12,20},{15,23}},{{16,24},{19,27}},{{16,20},{19,23}},{{12,24},{15,27}},
+    {{20,20},{23,23}},{{24,24},{27,27}},{{24,20},{27,23}},{{20,24},{23,27}}
+};
+static const ElemCat elem_d2 = { 0, 2, 4, 25, elem_d2_data };
+
+static const Block elem_d3_data[] = {
+    {{ 1, 1},{10,10}},{{11, 1},{20,10}},
+    {{ 1, 1},{10,10}},{{21, 1},{30,10}},
+    {{ 1, 1},{10,10}},{{ 1,11},{10,20}},
+    {{ 1, 1},{10,10}},{{11,11},{20,20}},
+    {{ 1, 1},{10,10}},{{21,11},{30,20}},
+    {{ 1, 1},{10,10}},{{ 1,21},{10,30}},
+    {{ 1, 1},{10,10}},{{11,21},{20,30}},
+    {{ 1, 1},{10,10}},{{21,21},{30,30}},
+    {{11, 1},{20,10}},{{21, 1},{30,10}},
+    {{11, 1},{20,10}},{{ 1,11},{10,20}},
+    {{11, 1},{20,10}},{{11,11},{20,20}},
+    {{11, 1},{20,10}},{{21,11},{30,20}},
+    {{11, 1},{20,10}},{{ 1,21},{10,30}},
+    {{11, 1},{20,10}},{{11,21},{20,30}},
+    {{11, 1},{20,10}},{{21,21},{30,30}},
+    {{21, 1},{30,10}},{{ 1,11},{10,20}},
+    {{21, 1},{30,10}},{{11,11},{20,20}},
+    {{21, 1},{30,10}},{{21,11},{30,20}},
+    {{21, 1},{30,10}},{{ 1,21},{10,30}},
+    {{21, 1},{30,10}},{{11,21},{20,30}},
+    {{21, 1},{30,10}},{{21,21},{30,30}},
+    {{ 1,11},{10,20}},{{11,11},{20,20}},
+    {{ 1,11},{10,20}},{{21,11},{30,20}},
+    {{ 1,11},{10,20}},{{ 1,21},{10,30}},
+    {{ 1,11},{10,20}},{{11,21},{20,30}},
+    {{ 1,11},{10,20}},{{21,21},{30,30}},
+    {{11,11},{20,20}},{{21,11},{30,20}},
+    {{11,11},{20,20}},{{ 1,21},{10,30}},
+    {{11,11},{20,20}},{{11,21},{20,30}},
+    {{11,11},{20,20}},{{21,21},{30,30}},
+    {{21,11},{30,20}},{{ 1,21},{10,30}},
+    {{21,11},{30,20}},{{11,21},{20,30}},
+    {{21,11},{30,20}},{{21,21},{30,30}},
+    {{ 1,21},{10,30}},{{11,21},{20,30}},
+    {{ 1,21},{10,30}},{{21,21},{30,30}},
+    {{11,21},{20,30}},{{21,21},{30,30}}
+};
+static const ElemCat elem_d3 = { 0, 1, 2, 36, elem_d3_data };
+
+static const Block elem_d4_data[] = {
+    {{ 7,13},{12,18}},{{19,13},{24,18}},
+    {{13, 7},{18,12}},{{13,19},{18,24}},
+    {{ 7, 7},{12,12}},{{19,19},{24,24}},
+    {{19, 7},{24,12}},{{ 7,19},{12,24}},
+    {{13, 7},{18,12}},{{19,13},{24,18}},
+    {{19,13},{24,18}},{{13,19},{18,24}},
+    {{13,19},{18,24}},{{ 7,13},{12,18}},
+    {{ 7,13},{12,18}},{{13, 7},{18,12}},
+    {{ 7, 7},{12,12}},{{19, 7},{24,12}},
+    {{19, 7},{24,12}},{{19,19},{24,24}},
+    {{19,19},{24,24}},{{ 7,19},{12,24}},
+    {{ 7,19},{12,24}},{{ 7, 7},{12,12}},
+    {{13,13},{18,18}},{{13, 1},{18, 6}},
+    {{13,13},{18,18}},{{25,13},{30,18}},
+    {{13,13},{18,18}},{{13,25},{18,30}},
+    {{13,13},{18,18}},{{ 1,13},{ 6,18}},
+    {{13, 1},{18, 6}},{{13,25},{18,30}},
+    {{ 1,13},{ 6,18}},{{25,13},{30,18}},
+    {{ 7, 1},{12, 6}},{{19, 1},{24, 6}},
+    {{ 7,25},{12,30}},{{19,25},{24,30}},
+    {{ 1, 7},{ 6,12}},{{ 1,19},{ 6,24}},
+    {{25, 7},{30,12}},{{25,19},{30,24}},
+    {{ 7, 1},{12, 6}},{{ 1, 7},{ 6,12}},
+    {{19, 1},{24, 6}},{{25, 7},{30,12}},
+    {{25,19},{30,24}},{{19,25},{24,30}},
+    {{ 1,19},{ 6,24}},{{ 7,25},{12,30}},
+    {{ 1, 1},{ 6, 6}},{{25, 1},{30, 6}},
+    {{25, 1},{30, 6}},{{25,25},{30,30}},
+    {{25,25},{30,30}},{{ 1,25},{ 6,30}},
+    {{ 1,25},{ 6,30}},{{ 1, 1},{ 6, 6}}
+};
+static const ElemCat elem_d4 = { 0, 1, 2, 30, elem_d4_data };
+
+static const Block elem_d5_data[] = {
+    {{ 1, 1},{10, 3}},{{ 1, 4},{ 3, 7}},{{ 8, 4},{10, 7}},{{ 1, 8},{10,10}},{{ 4, 4},{ 7, 7}},
+    {{11, 1},{20, 3}},{{11, 4},{13, 7}},{{18, 4},{20, 7}},{{11, 8},{20,10}},{{14, 4},{17, 7}},
+    {{21, 1},{30, 3}},{{21, 4},{23, 7}},{{28, 4},{30, 7}},{{21, 8},{30,10}},{{24, 4},{27, 7}},
+    {{ 1,11},{10,13}},{{ 1,14},{ 3,17}},{{ 8,14},{10,17}},{{ 1,18},{10,20}},{{ 4,14},{ 7,17}},
+    {{11,11},{20,13}},{{11,14},{13,17}},{{18,14},{20,17}},{{11,18},{20,20}},{{14,14},{17,17}},
+    {{21,11},{30,13}},{{21,14},{23,17}},{{28,14},{30,17}},{{21,18},{30,20}},{{24,14},{27,17}},
+    {{ 1,21},{10,23}},{{ 1,24},{ 3,27}},{{ 8,24},{10,27}},{{ 1,28},{10,30}},{{ 4,24},{ 7,27}},
+    {{11,21},{20,23}},{{11,24},{13,27}},{{18,24},{20,27}},{{11,28},{20,30}},{{14,24},{17,27}},
+    {{21,21},{30,23}},{{21,24},{23,27}},{{28,24},{30,27}},{{21,28},{30,30}},{{24,24},{27,27}},
+    {{ 6, 6},{15, 8}},{{ 6, 9},{ 8,12}},{{13, 9},{15,12}},{{ 6,13},{15,15}},{{ 9, 9},{12,12}},
+    {{16, 6},{25, 8}},{{16, 9},{18,12}},{{23, 9},{25,12}},{{16,13},{25,15}},{{19, 9},{22,12}},
+    {{ 6,16},{15,18}},{{ 6,19},{ 8,22}},{{13,19},{15,22}},{{ 6,23},{15,25}},{{ 9,19},{12,22}},
+    {{16,16},{25,18}},{{16,19},{18,22}},{{23,19},{25,22}},{{16,23},{25,25}},{{19,19},{22,22}},
+    {{ 6, 1},{15, 3}},{{ 6, 4},{ 8, 7}},{{13, 4},{15, 7}},{{ 6, 8},{15,10}},{{ 9, 4},{12, 7}},
+    {{16, 1},{25, 3}},{{16, 4},{18, 7}},{{23, 4},{25, 7}},{{16, 8},{25,10}},{{19, 4},{22, 7}},
+    {{ 1, 6},{10, 8}},{{ 1, 9},{ 3,12}},{{ 8, 9},{10,12}},{{ 1,13},{10,15}},{{ 4, 9},{ 7,12}},
+    {{11, 6},{20, 8}},{{11, 9},{13,12}},{{18, 9},{20,12}},{{11,13},{20,15}},{{14, 9},{17,12}},
+    {{21, 6},{30, 8}},{{21, 9},{23,12}},{{28, 9},{30,12}},{{21,13},{30,15}},{{24, 9},{27,12}},
+    {{ 6,11},{15,13}},{{ 6,14},{ 8,17}},{{13,14},{15,17}},{{ 6,18},{15,20}},{{ 9,14},{12,17}},
+    {{16,11},{25,13}},{{16,14},{18,17}},{{23,14},{25,17}},{{16,18},{25,20}},{{19,14},{22,17}},
+    {{ 1,16},{10,18}},{{ 1,19},{ 3,22}},{{ 8,19},{10,22}},{{ 1,23},{10,25}},{{ 4,19},{ 7,22}},
+    {{11,16},{20,18}},{{11,19},{13,22}},{{18,19},{20,22}},{{11,23},{20,25}},{{14,19},{17,22}},
+    {{21,16},{30,18}},{{21,19},{23,22}},{{28,19},{30,22}},{{21,23},{30,25}},{{24,19},{27,22}},
+    {{ 6,21},{15,23}},{{ 6,24},{ 8,27}},{{13,24},{15,27}},{{ 6,28},{15,30}},{{ 9,24},{12,27}},
+    {{16,21},{25,23}},{{16,24},{18,27}},{{23,24},{25,27}},{{16,28},{25,30}},{{19,24},{22,27}},
+    {{ 2, 2},{14, 6}},{{ 2, 7},{ 6, 9}},{{10, 7},{14, 9}},{{ 2,10},{14,14}},{{ 7, 7},{ 9, 9}},
+    {{ 7, 2},{19, 6}},{{ 7, 7},{11, 9}},{{15, 7},{19, 9}},{{ 7,10},{19,14}},{{12, 7},{14, 9}},
+    {{12, 2},{24, 6}},{{12, 7},{16, 9}},{{20, 7},{24, 9}},{{12,10},{24,14}},{{17, 7},{19, 9}},
+    {{17, 2},{29, 6}},{{17, 7},{21, 9}},{{25, 7},{29, 9}},{{17,10},{29,14}},{{22, 7},{24, 9}},
+    {{ 2, 7},{14,11}},{{ 2,12},{ 6,14}},{{10,12},{14,14}},{{ 2,15},{14,19}},{{ 7,12},{ 9,14}},
+    {{ 7, 7},{19,11}},{{ 7,12},{11,14}},{{15,12},{19,14}},{{ 7,15},{19,19}},{{12,12},{14,14}},
+    {{12, 7},{24,11}},{{12,12},{16,14}},{{20,12},{24,14}},{{12,15},{24,19}},{{17,12},{19,14}},
+    {{17, 7},{29,11}},{{17,12},{21,14}},{{25,12},{29,14}},{{17,15},{29,19}},{{22,12},{24,14}},
+    {{ 2,12},{14,16}},{{ 2,17},{ 6,19}},{{10,17},{14,19}},{{ 2,20},{14,24}},{{ 7,17},{ 9,19}},
+    {{ 7,12},{19,16}},{{ 7,17},{11,19}},{{15,17},{19,19}},{{ 7,20},{19,24}},{{12,17},{14,19}},
+    {{12,12},{24,16}},{{12,17},{16,19}},{{20,17},{24,19}},{{12,20},{24,24}},{{17,17},{19,19}},
+    {{17,12},{29,16}},{{17,17},{21,19}},{{25,17},{29,19}},{{17,20},{29,24}},{{22,17},{24,19}},
+    {{ 2,17},{14,21}},{{ 2,22},{ 6,24}},{{10,22},{14,24}},{{ 2,25},{14,29}},{{ 7,22},{ 9,24}},
+    {{ 7,17},{19,21}},{{ 7,22},{11,24}},{{15,22},{19,24}},{{ 7,25},{19,29}},{{12,22},{14,24}},
+    {{12,17},{24,21}},{{12,22},{16,24}},{{20,22},{24,24}},{{12,25},{24,29}},{{17,22},{19,24}},
+    {{17,17},{29,21}},{{17,22},{21,24}},{{25,22},{29,24}},{{17,25},{29,29}},{{22,22},{24,24}},
+    {{ 8, 3},{13, 4}},{{ 8, 5},{ 9, 6}},{{12, 5},{13, 6}},{{ 8, 7},{13, 8}},{{10, 5},{11, 6}},
+    {{13, 3},{18, 4}},{{13, 5},{14, 6}},{{17, 5},{18, 6}},{{13, 7},{18, 8}},{{15, 5},{16, 6}},
+    {{18, 3},{23, 4}},{{18, 5},{19, 6}},{{22, 5},{23, 6}},{{18, 7},{23, 8}},{{20, 5},{21, 6}},
+    {{ 3, 8},{ 8, 9}},{{ 3,10},{ 4,11}},{{ 7,10},{ 8,11}},{{ 3,12},{ 8,13}},{{ 5,10},{ 6,11}},
+    {{ 8, 8},{13, 9}},{{ 8,10},{ 9,11}},{{12,10},{13,11}},{{ 8,12},{13,13}},{{10,10},{11,11}},
+    {{13, 8},{18, 9}},{{13,10},{14,11}},{{17,10},{18,11}},{{13,12},{18,13}},{{15,10},{16,11}},
+    {{18, 8},{23, 9}},{{18,10},{19,11}},{{22,10},{23,11}},{{18,12},{23,13}},{{20,10},{21,11}},
+    {{23, 8},{28, 9}},{{23,10},{24,11}},{{27,10},{28,11}},{{23,12},{28,13}},{{25,10},{26,11}},
+    {{ 3,13},{ 8,14}},{{ 3,15},{ 4,16}},{{ 7,15},{ 8,16}},{{ 3,17},{ 8,18}},{{ 5,15},{ 6,16}},
+    {{ 8,13},{13,14}},{{ 8,15},{ 9,16}},{{12,15},{13,16}},{{ 8,17},{13,18}},{{10,15},{11,16}},
+    {{13,13},{18,14}},{{13,15},{14,16}},{{17,15},{18,16}},{{13,17},{18,18}},{{15,15},{16,16}},
+    {{18,13},{23,14}},{{18,15},{19,16}},{{22,15},{23,16}},{{18,17},{23,18}},{{20,15},{21,16}},
+    {{23,13},{28,14}},{{23,15},{24,16}},{{27,15},{28,16}},{{23,17},{28,18}},{{25,15},{26,16}},
+    {{ 3,18},{ 8,19}},{{ 3,20},{ 4,21}},{{ 7,20},{ 8,21}},{{ 3,22},{ 8,23}},{{ 5,20},{ 6,21}},
+    {{ 8,18},{13,19}},{{ 8,20},{ 9,21}},{{12,20},{13,21}},{{ 8,22},{13,23}},{{10,20},{11,21}},
+    {{13,18},{18,19}},{{13,20},{14,21}},{{17,20},{18,21}},{{13,22},{18,23}},{{15,20},{16,21}},
+    {{18,18},{23,19}},{{18,20},{19,21}},{{22,20},{23,21}},{{18,22},{23,23}},{{20,20},{21,21}},
+    {{23,18},{28,19}},{{23,20},{24,21}},{{27,20},{28,21}},{{23,22},{28,23}},{{25,20},{26,21}},
+    {{ 8,23},{13,24}},{{ 8,25},{ 9,26}},{{12,25},{13,26}},{{ 8,27},{13,28}},{{10,25},{11,26}},
+    {{13,23},{18,24}},{{13,25},{14,26}},{{17,25},{18,26}},{{13,27},{18,28}},{{15,25},{16,26}},
+    {{18,23},{23,24}},{{18,25},{19,26}},{{22,25},{23,26}},{{18,27},{23,28}},{{20,25},{21,26}}
+};
+static const ElemCat elem_d5 = { 0, 4, 5, 62, elem_d5_data };
+
+static const Block elem_d6_data[] = {
+    {{ 3, 5},{12,10}},{{ 5, 3},{10,12}},
+    {{11, 5},{20,10}},{{13, 3},{18,12}},
+    {{19, 5},{28,10}},{{21, 3},{26,12}},
+    {{ 3,13},{12,18}},{{ 5,11},{10,20}},
+    {{11,13},{20,18}},{{13,11},{18,20}},
+    {{19,13},{28,18}},{{21,11},{26,20}},
+    {{ 3,21},{12,26}},{{ 5,19},{10,28}},
+    {{11,21},{20,26}},{{13,19},{18,28}},
+    {{19,21},{28,26}},{{21,19},{26,28}}
+};
+static const ElemCat elem_d6 = { 0, 1, 2, 9, elem_d6_data };
+
+static const Block elem_d7_data[] = {
+    {{ 0, 4},{ 3, 7}},{{ 8, 4},{11, 7}},{{ 4, 4},{ 7, 7}},
+    {{ 4, 0},{ 7, 3}},{{ 4, 8},{ 7,11}},{{ 4, 4},{ 7, 7}},
+    {{ 5, 4},{ 8, 7}},{{13, 4},{16, 7}},{{ 9, 4},{12, 7}},
+    {{ 9, 0},{12, 3}},{{ 9, 8},{12,11}},{{ 9, 4},{12, 7}},
+    {{10, 4},{13, 7}},{{18, 4},{21, 7}},{{14, 4},{17, 7}},
+    {{14, 0},{17, 3}},{{14, 8},{17,11}},{{14, 4},{17, 7}},
+    {{15, 4},{18, 7}},{{23, 4},{26, 7}},{{19, 4},{22, 7}},
+    {{19, 0},{22, 3}},{{19, 8},{22,11}},{{19, 4},{22, 7}},
+    {{20, 4},{23, 7}},{{28, 4},{31, 7}},{{24, 4},{27, 7}},
+    {{24, 0},{27, 3}},{{24, 8},{27,11}},{{24, 4},{27, 7}},
+    {{ 0, 9},{ 3,12}},{{ 8, 9},{11,12}},{{ 4, 9},{ 7,12}},
+    {{ 4, 5},{ 7, 8}},{{ 4,13},{ 7,16}},{{ 4, 9},{ 7,12}},
+    {{ 5, 9},{ 8,12}},{{13, 9},{16,12}},{{ 9, 9},{12,12}},
+    {{ 9, 5},{12, 8}},{{ 9,13},{12,16}},{{ 9, 9},{12,12}},
+    {{10, 9},{13,12}},{{18, 9},{21,12}},{{14, 9},{17,12}},
+    {{14, 5},{17, 8}},{{14,13},{17,16}},{{14, 9},{17,12}},
+    {{15, 9},{18,12}},{{23, 9},{26,12}},{{19, 9},{22,12}},
+    {{19, 5},{22, 8}},{{19,13},{22,16}},{{19, 9},{22,12}},
+    {{20, 9},{23,12}},{{28, 9},{31,12}},{{24, 9},{27,12}},
+    {{24, 5},{27, 8}},{{24,13},{27,16}},{{24, 9},{27,12}},
+    {{ 0,14},{ 3,17}},{{ 8,14},{11,17}},{{ 4,14},{ 7,17}},
+    {{ 4,10},{ 7,13}},{{ 4,18},{ 7,21}},{{ 4,14},{ 7,17}},
+    {{ 5,14},{ 8,17}},{{13,14},{16,17}},{{ 9,14},{12,17}},
+    {{ 9,10},{12,13}},{{ 9,18},{12,21}},{{ 9,14},{12,17}},
+    {{10,14},{13,17}},{{18,14},{21,17}},{{14,14},{17,17}},
+    {{14,10},{17,13}},{{14,18},{17,21}},{{14,14},{17,17}},
+    {{15,14},{18,17}},{{23,14},{26,17}},{{19,14},{22,17}},
+    {{19,10},{22,13}},{{19,18},{22,21}},{{19,14},{22,17}},
+    {{20,14},{23,17}},{{28,14},{31,17}},{{24,14},{27,17}},
+    {{24,10},{27,13}},{{24,18},{27,21}},{{24,14},{27,17}},
+    {{ 0,19},{ 3,22}},{{ 8,19},{11,22}},{{ 4,19},{ 7,22}},
+    {{ 4,15},{ 7,18}},{{ 4,23},{ 7,26}},{{ 4,19},{ 7,22}},
+    {{ 5,19},{ 8,22}},{{13,19},{16,22}},{{ 9,19},{12,22}},
+    {{ 9,15},{12,18}},{{ 9,23},{12,26}},{{ 9,19},{12,22}},
+    {{10,19},{13,22}},{{18,19},{21,22}},{{14,19},{17,22}},
+    {{14,15},{17,18}},{{14,23},{17,26}},{{14,19},{17,22}},
+    {{15,19},{18,22}},{{23,19},{26,22}},{{19,19},{22,22}},
+    {{19,15},{22,18}},{{19,23},{22,26}},{{19,19},{22,22}},
+    {{20,19},{23,22}},{{28,19},{31,22}},{{24,19},{27,22}},
+    {{24,15},{27,18}},{{24,23},{27,26}},{{24,19},{27,22}},
+    {{ 0,24},{ 3,27}},{{ 8,24},{11,27}},{{ 4,24},{ 7,27}},
+    {{ 4,20},{ 7,23}},{{ 4,28},{ 7,31}},{{ 4,24},{ 7,27}},
+    {{ 5,24},{ 8,27}},{{13,24},{16,27}},{{ 9,24},{12,27}},
+    {{ 9,20},{12,23}},{{ 9,28},{12,31}},{{ 9,24},{12,27}},
+    {{10,24},{13,27}},{{18,24},{21,27}},{{14,24},{17,27}},
+    {{14,20},{17,23}},{{14,28},{17,31}},{{14,24},{17,27}},
+    {{15,24},{18,27}},{{23,24},{26,27}},{{19,24},{22,27}},
+    {{19,20},{22,23}},{{19,28},{22,31}},{{19,24},{22,27}},
+    {{20,24},{23,27}},{{28,24},{31,27}},{{24,24},{27,27}},
+    {{24,20},{27,23}},{{24,28},{27,31}},{{24,24},{27,27}}
+};
+static const ElemCat elem_d7 = { 0, 2, 3, 50, elem_d7_data };
+
+static const Block elem_d8_data[] = {
+    {{ 0, 0},{ 7, 3}},{{ 0, 4},{ 7, 7}},
+    {{ 8, 0},{11, 7}},{{12, 0},{15, 7}},
+    {{ 0, 8},{ 3,15}},{{ 4, 8},{ 7,15}},
+    {{ 8, 8},{15,11}},{{ 8,12},{15,15}},
+    {{16, 0},{19, 7}},{{20, 0},{23, 7}},
+    {{24, 0},{31, 3}},{{24, 4},{31, 7}},
+    {{16, 8},{23,11}},{{16,12},{23,15}},
+    {{24, 8},{27,15}},{{28, 8},{31,15}},
+    {{ 0,16},{ 3,23}},{{ 4,16},{ 7,23}},
+    {{ 8,16},{15,19}},{{ 8,20},{15,23}},
+    {{ 0,24},{ 7,27}},{{ 0,28},{ 7,31}},
+    {{ 8,24},{11,31}},{{12,24},{15,31}},
+    {{16,16},{23,19}},{{16,20},{23,23}},
+    {{24,16},{27,23}},{{28,16},{31,23}},
+    {{16,24},{19,31}},{{20,24},{23,31}},
+    {{24,24},{31,27}},{{24,28},{31,31}},
+    {{ 0, 0},{ 7,15}},{{ 8, 0},{15,15}},
+    {{16, 0},{31, 7}},{{16, 8},{31,15}},
+    {{ 0,16},{15,23}},{{ 0,24},{15,31}},
+    {{16,16},{23,31}},{{24,16},{31,31}}
+};
+static const ElemCat elem_d8 = { 0, 1, 2, 20, elem_d8_data };
+
+static const ElemCat* elements[ELEMENT_COUNT] = { &elem_a1, &elem_a2,
+                                                  &elem_d1, &elem_d2, &elem_d3, &elem_d4,
+                                                  &elem_d5, &elem_d6, &elem_d7, &elem_d8 };
+#endif /* AVFILTER_SIGNATURE_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/signature_lookup.c b/mythtv/external/FFmpeg/libavfilter/signature_lookup.c
new file mode 100644
index 00000000000..272c717c77d
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/signature_lookup.c
@@ -0,0 +1,580 @@
+/*
+ * Copyright (c) 2017 Gerion Entrup
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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
+ * MPEG-7 video signature calculation and lookup filter
+ */
+
+#include "signature.h"
+
+#define HOUGH_MAX_OFFSET 90
+#define MAX_FRAMERATE 60
+
+#define DIR_PREV 0
+#define DIR_NEXT 1
+#define DIR_PREV_END 2
+#define DIR_NEXT_END 3
+
+#define STATUS_NULL 0
+#define STATUS_END_REACHED 1
+#define STATUS_BEGIN_REACHED 2
+
+static void fill_l1distlut(uint8_t lut[])
+{
+    int i, j, tmp_i, tmp_j,count;
+    uint8_t dist;
+
+    for (i = 0, count = 0; i < 242; i++) {
+        for (j = i + 1; j < 243; j++, count++) {
+            /* ternary distance between i and j */
+            dist = 0;
+            tmp_i = i; tmp_j = j;
+            do {
+                dist += FFABS((tmp_j % 3) - (tmp_i % 3));
+                tmp_j /= 3;
+                tmp_i /= 3;
+            } while (tmp_i > 0 || tmp_j > 0);
+            lut[count] = dist;
+        }
+    }
+}
+
+static unsigned int intersection_word(const uint8_t *first, const uint8_t *second)
+{
+    unsigned int val=0,i;
+    for (i = 0; i < 28; i += 4) {
+        val += av_popcount( (first[i]   & second[i]  ) << 24 |
+                            (first[i+1] & second[i+1]) << 16 |
+                            (first[i+2] & second[i+2]) << 8  |
+                            (first[i+3] & second[i+3]) );
+    }
+    val += av_popcount( (first[28] & second[28]) << 16 |
+                        (first[29] & second[29]) << 8  |
+                        (first[30] & second[30]) );
+    return val;
+}
+
+static unsigned int union_word(const uint8_t *first, const uint8_t *second)
+{
+    unsigned int val=0,i;
+    for (i = 0; i < 28; i += 4) {
+        val += av_popcount( (first[i]   | second[i]  ) << 24 |
+                            (first[i+1] | second[i+1]) << 16 |
+                            (first[i+2] | second[i+2]) << 8  |
+                            (first[i+3] | second[i+3]) );
+    }
+    val += av_popcount( (first[28] | second[28]) << 16 |
+                        (first[29] | second[29]) << 8  |
+                        (first[30] | second[30]) );
+    return val;
+}
+
+static unsigned int get_l1dist(AVFilterContext *ctx, SignatureContext *sc, const uint8_t *first, const uint8_t *second)
+{
+    unsigned int i;
+    unsigned int dist = 0;
+    uint8_t f, s;
+
+    for (i = 0; i < SIGELEM_SIZE/5; i++) {
+        if (first[i] != second[i]) {
+            f = first[i];
+            s = second[i];
+            if (f > s) {
+                /* little variation of gauss sum formula */
+                dist += sc->l1distlut[243*242/2 - (243-s)*(242-s)/2 + f - s - 1];
+            } else {
+                dist += sc->l1distlut[243*242/2 - (243-f)*(242-f)/2 + s - f - 1];
+            }
+        }
+    }
+    return dist;
+}
+
+/**
+ * calculates the jaccard distance and evaluates a pair of coarse signatures as good
+ * @return 0 if pair is bad, 1 otherwise
+ */
+static int get_jaccarddist(SignatureContext *sc, CoarseSignature *first, CoarseSignature *second)
+{
+    int jaccarddist, i, composdist = 0, cwthcount = 0;
+    for (i = 0; i < 5; i++) {
+        if ((jaccarddist = intersection_word(first->data[i], second->data[i])) > 0) {
+            jaccarddist /= union_word(first->data[i], second->data[i]);
+        }
+        if (jaccarddist >= sc->thworddist) {
+            if (++cwthcount > 2) {
+                /* more than half (5/2) of distances are too wide */
+                return 0;
+            }
+        }
+        composdist += jaccarddist;
+        if (composdist > sc->thcomposdist) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+/**
+ * step through the coarsesignatures as long as a good candidate is found
+ * @return 0 if no candidate is found, 1 otherwise
+ */
+static int find_next_coarsecandidate(SignatureContext *sc, CoarseSignature *secondstart, CoarseSignature **first, CoarseSignature **second, int start)
+{
+    /* go one coarsesignature foreword */
+    if (!start) {
+        if ((*second)->next) {
+            *second = (*second)->next;
+        } else if ((*first)->next) {
+            *second = secondstart;
+            *first = (*first)->next;
+        } else {
+            return 0;
+        }
+    }
+
+    while (1) {
+        if (get_jaccarddist(sc, *first, *second))
+            return 1;
+
+        /* next signature */
+        if ((*second)->next) {
+            *second = (*second)->next;
+        } else if ((*first)->next) {
+            *second = secondstart;
+            *first = (*first)->next;
+        } else {
+            return 0;
+        }
+    }
+}
+
+/**
+ * compares framesignatures and sorts out signatures with a l1 distance above a given threshold.
+ * Then tries to find out offset and differences between framerates with a hough transformation
+ */
+static MatchingInfo* get_matching_parameters(AVFilterContext *ctx, SignatureContext *sc, FineSignature *first, FineSignature *second)
+{
+    FineSignature *f, *s;
+    size_t i, j, k, l, hmax = 0, score;
+    int framerate, offset, l1dist;
+    double m;
+    MatchingInfo *cands = NULL, *c = NULL;
+
+    struct {
+        uint8_t size;
+        unsigned int dist;
+        FineSignature *a;
+        uint8_t b_pos[COARSE_SIZE];
+        FineSignature *b[COARSE_SIZE];
+    } pairs[COARSE_SIZE];
+
+    typedef struct hspace_elem {
+        int dist;
+        size_t score;
+        FineSignature *a;
+        FineSignature *b;
+    } hspace_elem;
+
+    /* houghspace */
+    hspace_elem** hspace = av_malloc_array(MAX_FRAMERATE, sizeof(hspace_elem *));
+
+    /* initialize houghspace */
+    for (i = 0; i < MAX_FRAMERATE; i++) {
+        hspace[i] = av_malloc_array(2 * HOUGH_MAX_OFFSET + 1, sizeof(hspace_elem));
+        for (j = 0; j < HOUGH_MAX_OFFSET; j++) {
+            hspace[i][j].score = 0;
+            hspace[i][j].dist = 99999;
+        }
+    }
+
+    /* l1 distances */
+    for (i = 0, f = first; i < COARSE_SIZE && f->next; i++, f = f->next) {
+        pairs[i].size = 0;
+        pairs[i].dist = 99999;
+        pairs[i].a = f;
+        for (j = 0, s = second; j < COARSE_SIZE && s->next; j++, s = s->next) {
+            /* l1 distance of finesignature */
+            l1dist = get_l1dist(ctx, sc, f->framesig, s->framesig);
+            if (l1dist < sc->thl1) {
+                if (l1dist < pairs[i].dist) {
+                    pairs[i].size = 1;
+                    pairs[i].dist = l1dist;
+                    pairs[i].b_pos[0] = j;
+                    pairs[i].b[0] = s;
+                } else if (l1dist == pairs[i].dist) {
+                    pairs[i].b[pairs[i].size] = s;
+                    pairs[i].b_pos[pairs[i].size] = j;
+                    pairs[i].size++;
+                }
+            }
+        }
+    }
+    /* last incomplete coarsesignature */
+    if (f->next == NULL) {
+        for (; i < COARSE_SIZE; i++) {
+            pairs[i].size = 0;
+            pairs[i].dist = 99999;
+        }
+    }
+
+    /* hough transformation */
+    for (i = 0; i < COARSE_SIZE; i++) {
+        for (j = 0; j < pairs[i].size; j++) {
+            for (k = i + 1; k < COARSE_SIZE; k++) {
+                for (l = 0; l < pairs[k].size; l++) {
+                    if (pairs[i].b[j] != pairs[k].b[l]) {
+                        /* linear regression */
+                        m = (pairs[k].b_pos[l]-pairs[i].b_pos[j]) / (k-i); /* good value between 0.0 - 2.0 */
+                        framerate = (int) m*30 + 0.5; /* round up to 0 - 60 */
+                        if (framerate>0 && framerate <= MAX_FRAMERATE) {
+                            offset = pairs[i].b_pos[j] - ((int) m*i + 0.5); /* only second part has to be rounded up */
+                            if (offset > -HOUGH_MAX_OFFSET && offset < HOUGH_MAX_OFFSET) {
+                                if (pairs[i].dist < pairs[k].dist) {
+                                    if (pairs[i].dist < hspace[framerate-1][offset+HOUGH_MAX_OFFSET].dist) {
+                                        hspace[framerate-1][offset+HOUGH_MAX_OFFSET].dist = pairs[i].dist;
+                                        hspace[framerate-1][offset+HOUGH_MAX_OFFSET].a = pairs[i].a;
+                                        hspace[framerate-1][offset+HOUGH_MAX_OFFSET].b = pairs[i].b[j];
+                                    }
+                                } else {
+                                    if (pairs[k].dist < hspace[framerate-1][offset+HOUGH_MAX_OFFSET].dist) {
+                                        hspace[framerate-1][offset+HOUGH_MAX_OFFSET].dist = pairs[k].dist;
+                                        hspace[framerate-1][offset+HOUGH_MAX_OFFSET].a = pairs[k].a;
+                                        hspace[framerate-1][offset+HOUGH_MAX_OFFSET].b = pairs[k].b[l];
+                                    }
+                                }
+
+                                score = hspace[framerate-1][offset+HOUGH_MAX_OFFSET].score + 1;
+                                if (score > hmax )
+                                    hmax = score;
+                                hspace[framerate-1][offset+HOUGH_MAX_OFFSET].score = score;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (hmax > 0) {
+        hmax = (int) (0.7*hmax);
+        for (i = 0; i < MAX_FRAMERATE; i++) {
+            for (j = 0; j < HOUGH_MAX_OFFSET; j++) {
+                if (hmax < hspace[i][j].score) {
+                    if (c == NULL) {
+                        c = av_malloc(sizeof(MatchingInfo));
+                        if (!c)
+                            av_log(ctx, AV_LOG_FATAL, "Could not allocate memory");
+                        cands = c;
+                    } else {
+                        c->next = av_malloc(sizeof(MatchingInfo));
+                        if (!c->next)
+                            av_log(ctx, AV_LOG_FATAL, "Could not allocate memory");
+                        c = c->next;
+                    }
+                    c->framerateratio = (i+1.0) / 30;
+                    c->score = hspace[i][j].score;
+                    c->offset = j-90;
+                    c->first = hspace[i][j].a;
+                    c->second = hspace[i][j].b;
+                    c->next = NULL;
+
+                    /* not used */
+                    c->meandist = 0;
+                    c->matchframes = 0;
+                    c->whole = 0;
+                }
+            }
+        }
+    }
+    for (i = 0; i < MAX_FRAMERATE; i++) {
+        av_freep(&hspace[i]);
+    }
+    av_freep(&hspace);
+    return cands;
+}
+
+static int iterate_frame(double frr, FineSignature **a, FineSignature **b, int fcount, int *bcount, int dir)
+{
+    int step;
+
+    /* between 1 and 2, because frr is between 1 and 2 */
+    step = ((int) 0.5 + fcount     * frr) /* current frame */
+          -((int) 0.5 + (fcount-1) * frr);/* last frame */
+
+    if (dir == DIR_NEXT) {
+        if (frr >= 1.0) {
+            if ((*a)->next) {
+                *a = (*a)->next;
+            } else {
+                return DIR_NEXT_END;
+            }
+
+            if (step == 1) {
+                if ((*b)->next) {
+                    *b = (*b)->next;
+                    (*bcount)++;
+                } else {
+                    return DIR_NEXT_END;
+                }
+            } else {
+                if ((*b)->next && (*b)->next->next) {
+                    *b = (*b)->next->next;
+                    (*bcount)++;
+                } else {
+                    return DIR_NEXT_END;
+                }
+            }
+        } else {
+            if ((*b)->next) {
+                *b = (*b)->next;
+                (*bcount)++;
+            } else {
+                return DIR_NEXT_END;
+            }
+
+            if (step == 1) {
+                if ((*a)->next) {
+                    *a = (*a)->next;
+                } else {
+                    return DIR_NEXT_END;
+                }
+            } else {
+                if ((*a)->next && (*a)->next->next) {
+                    *a = (*a)->next->next;
+                } else {
+                    return DIR_NEXT_END;
+                }
+            }
+        }
+        return DIR_NEXT;
+    } else {
+        if (frr >= 1.0) {
+            if ((*a)->prev) {
+                *a = (*a)->prev;
+            } else {
+                return DIR_PREV_END;
+            }
+
+            if (step == 1) {
+                if ((*b)->prev) {
+                    *b = (*b)->prev;
+                    (*bcount)++;
+                } else {
+                    return DIR_PREV_END;
+                }
+            } else {
+                if ((*b)->prev && (*b)->prev->prev) {
+                    *b = (*b)->prev->prev;
+                    (*bcount)++;
+                } else {
+                    return DIR_PREV_END;
+                }
+            }
+        } else {
+            if ((*b)->prev) {
+                *b = (*b)->prev;
+                (*bcount)++;
+            } else {
+                return DIR_PREV_END;
+            }
+
+            if (step == 1) {
+                if ((*a)->prev) {
+                    *a = (*a)->prev;
+                } else {
+                    return DIR_PREV_END;
+                }
+            } else {
+                if ((*a)->prev && (*a)->prev->prev) {
+                    *a = (*a)->prev->prev;
+                } else {
+                    return DIR_PREV_END;
+                }
+            }
+        }
+        return DIR_PREV;
+    }
+}
+
+static MatchingInfo evaluate_parameters(AVFilterContext *ctx, SignatureContext *sc, MatchingInfo *infos, MatchingInfo bestmatch, int mode)
+{
+    int dist, distsum = 0, bcount = 1, dir = DIR_NEXT;
+    int fcount = 0, goodfcount = 0, gooda = 0, goodb = 0;
+    double meandist, minmeandist = bestmatch.meandist;
+    int tolerancecount = 0;
+    FineSignature *a, *b, *aprev, *bprev;
+    int status = STATUS_NULL;
+
+    for (; infos != NULL; infos = infos->next) {
+        a = infos->first;
+        b = infos->second;
+        while (1) {
+            dist = get_l1dist(ctx, sc, a->framesig, b->framesig);
+
+            if (dist > sc->thl1) {
+                if (a->confidence >= 1 || b->confidence >= 1) {
+                    /* bad frame (because high different information) */
+                    tolerancecount++;
+                }
+
+                if (tolerancecount > 2) {
+                    a = aprev;
+                    b = bprev;
+                    if (dir == DIR_NEXT) {
+                        /* turn around */
+                        a = infos->first;
+                        b = infos->second;
+                        dir = DIR_PREV;
+                    } else {
+                        break;
+                    }
+                }
+            } else {
+                /* good frame */
+                distsum += dist;
+                goodfcount++;
+                tolerancecount=0;
+
+                aprev = a;
+                bprev = b;
+
+                if (a->confidence < 1) gooda++;
+                if (b->confidence < 1) goodb++;
+            }
+
+            fcount++;
+
+            dir = iterate_frame(infos->framerateratio, &a, &b, fcount, &bcount, dir);
+            if (dir == DIR_NEXT_END) {
+                status = STATUS_END_REACHED;
+                a = infos->first;
+                b = infos->second;
+                dir = iterate_frame(infos->framerateratio, &a, &b, fcount, &bcount, DIR_PREV);
+            }
+
+            if (dir == DIR_PREV_END) {
+                status |= STATUS_BEGIN_REACHED;
+                break;
+            }
+
+            if (sc->thdi != 0 && bcount >= sc->thdi) {
+                break; /* enough frames found */
+            }
+        }
+
+        if (bcount < sc->thdi)
+            continue; /* matching sequence is too short */
+        if ((double) goodfcount / (double) fcount < sc->thit)
+            continue;
+        if ((double) goodfcount*0.5 < FFMAX(gooda, goodb))
+            continue;
+
+        meandist = (double) goodfcount / (double) distsum;
+
+        if (meandist < minmeandist ||
+                status == STATUS_END_REACHED | STATUS_BEGIN_REACHED ||
+                mode == MODE_FAST){
+            minmeandist = meandist;
+            /* bestcandidate in this iteration */
+            bestmatch.meandist = meandist;
+            bestmatch.matchframes = bcount;
+            bestmatch.framerateratio = infos->framerateratio;
+            bestmatch.score = infos->score;
+            bestmatch.offset = infos->offset;
+            bestmatch.first = infos->first;
+            bestmatch.second = infos->second;
+            bestmatch.whole = 0; /* will be set to true later */
+            bestmatch.next = NULL;
+        }
+
+        /* whole sequence is automatically best match */
+        if (status == (STATUS_END_REACHED | STATUS_BEGIN_REACHED)) {
+            bestmatch.whole = 1;
+            break;
+        }
+
+        /* first matching sequence is enough, finding the best one is not necessary */
+        if (mode == MODE_FAST) {
+            break;
+        }
+    }
+    return bestmatch;
+}
+
+static void sll_free(MatchingInfo *sll)
+{
+    void *tmp;
+    while (sll) {
+        tmp = sll;
+        sll = sll->next;
+        av_freep(&tmp);
+    }
+}
+
+static MatchingInfo lookup_signatures(AVFilterContext *ctx, SignatureContext *sc, StreamContext *first, StreamContext *second, int mode)
+{
+    CoarseSignature *cs, *cs2;
+    MatchingInfo *infos;
+    MatchingInfo bestmatch;
+    MatchingInfo *i;
+
+    cs = first->coarsesiglist;
+    cs2 = second->coarsesiglist;
+
+    /* score of bestmatch is 0, if no match is found */
+    bestmatch.score = 0;
+    bestmatch.meandist = 99999;
+    bestmatch.whole = 0;
+
+    fill_l1distlut(sc->l1distlut);
+
+    /* stage 1: coarsesignature matching */
+    if (find_next_coarsecandidate(sc, second->coarsesiglist, &cs, &cs2, 1) == 0)
+        return bestmatch; /* no candidate found */
+    do {
+        av_log(ctx, AV_LOG_DEBUG, "Stage 1: got coarsesignature pair. "
+               "indices of first frame: %"PRIu32" and %"PRIu32"\n",
+               cs->first->index, cs2->first->index);
+        /* stage 2: l1-distance and hough-transform */
+        av_log(ctx, AV_LOG_DEBUG, "Stage 2: calculate matching parameters\n");
+        infos = get_matching_parameters(ctx, sc, cs->first, cs2->first);
+        if (av_log_get_level() == AV_LOG_DEBUG) {
+            for (i = infos; i != NULL; i = i->next) {
+                av_log(ctx, AV_LOG_DEBUG, "Stage 2: matching pair at %"PRIu32" and %"PRIu32", "
+                       "ratio %f, offset %d\n", i->first->index, i->second->index,
+                       i->framerateratio, i->offset);
+            }
+        }
+        /* stage 3: evaluation */
+        av_log(ctx, AV_LOG_DEBUG, "Stage 3: evaluate\n");
+        if (infos) {
+            bestmatch = evaluate_parameters(ctx, sc, infos, bestmatch, mode);
+            av_log(ctx, AV_LOG_DEBUG, "Stage 3: best matching pair at %"PRIu32" and %"PRIu32", "
+                   "ratio %f, offset %d, score %d, %d frames matching\n",
+                   bestmatch.first->index, bestmatch.second->index,
+                   bestmatch.framerateratio, bestmatch.offset, bestmatch.score, bestmatch.matchframes);
+            sll_free(infos);
+        }
+    } while (find_next_coarsecandidate(sc, second->coarsesiglist, &cs, &cs2, 0) && !bestmatch.whole);
+    return bestmatch;
+
+}
diff --git a/mythtv/external/FFmpeg/libavfilter/split.c b/mythtv/external/FFmpeg/libavfilter/split.c
index 6cf4ab13bc4..8b260a9ba33 100644
--- a/mythtv/external/FFmpeg/libavfilter/split.c
+++ b/mythtv/external/FFmpeg/libavfilter/split.c
@@ -30,6 +30,9 @@
 #include "libavutil/mem.h"
 #include "libavutil/opt.h"
 
+#define FF_INTERNAL_FIELDS 1
+#include "framequeue.h"
+
 #include "avfilter.h"
 #include "audio.h"
 #include "formats.h"
@@ -44,7 +47,7 @@ typedef struct SplitContext {
 static av_cold int split_init(AVFilterContext *ctx)
 {
     SplitContext *s = ctx->priv;
-    int i;
+    int i, ret;
 
     for (i = 0; i < s->nb_outputs; i++) {
         char name[32];
@@ -56,7 +59,10 @@ static av_cold int split_init(AVFilterContext *ctx)
         if (!pad.name)
             return AVERROR(ENOMEM);
 
-        ff_insert_outpad(ctx, i, &pad);
+        if ((ret = ff_insert_outpad(ctx, i, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
     }
 
     return 0;
@@ -78,7 +84,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     for (i = 0; i < ctx->nb_outputs; i++) {
         AVFrame *buf_out;
 
-        if (ctx->outputs[i]->status)
+        if (ctx->outputs[i]->status_in)
             continue;
         buf_out = av_frame_clone(frame);
         if (!buf_out) {
@@ -144,7 +150,6 @@ AVFilter ff_af_asplit = {
     .priv_class  = &asplit_class,
     .init        = split_init,
     .uninit      = split_uninit,
-    .query_formats = ff_query_formats_all,
     .inputs      = avfilter_af_asplit_inputs,
     .outputs     = NULL,
     .flags       = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
diff --git a/mythtv/external/FFmpeg/libavfilter/src_movie.c b/mythtv/external/FFmpeg/libavfilter/src_movie.c
index 23dcb7ba2e3..258ba504a57 100644
--- a/mythtv/external/FFmpeg/libavfilter/src_movie.c
+++ b/mythtv/external/FFmpeg/libavfilter/src_movie.c
@@ -37,7 +37,11 @@
 #include "libavutil/imgutils.h"
 #include "libavutil/internal.h"
 #include "libavutil/timestamp.h"
+
+#include "libavcodec/avcodec.h"
+
 #include "libavformat/avformat.h"
+
 #include "audio.h"
 #include "avfilter.h"
 #include "formats.h"
@@ -309,7 +313,10 @@ static av_cold int movie_common_init(AVFilterContext *ctx)
             return AVERROR(ENOMEM);
         pad.config_props  = movie_config_output_props;
         pad.request_frame = movie_request_frame;
-        ff_insert_outpad(ctx, i, &pad);
+        if ((ret = ff_insert_outpad(ctx, i, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
         if ( movie->st[i].st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
             !movie->st[i].st->codecpar->channel_layout) {
             ret = guess_channel_layout(&movie->st[i], i, ctx);
@@ -555,7 +562,7 @@ static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
         return 0;
     }
 
-    frame->pts = av_frame_get_best_effort_timestamp(frame);
+    frame->pts = frame->best_effort_timestamp;
     if (frame->pts != AV_NOPTS_VALUE) {
         if (movie->ts_offset)
             frame->pts += av_rescale_q_rnd(movie->ts_offset, AV_TIME_BASE_Q, outlink->time_base, AV_ROUND_UP);
diff --git a/mythtv/external/FFmpeg/libavfilter/tests/.gitignore b/mythtv/external/FFmpeg/libavfilter/tests/.gitignore
index b605afa9cf0..65ef86f2e5b 100644
--- a/mythtv/external/FFmpeg/libavfilter/tests/.gitignore
+++ b/mythtv/external/FFmpeg/libavfilter/tests/.gitignore
@@ -1,3 +1,4 @@
 /drawutils
 /filtfmts
 /formats
+/integral
diff --git a/mythtv/external/FFmpeg/libavfilter/tests/filtfmts.c b/mythtv/external/FFmpeg/libavfilter/tests/filtfmts.c
index 46a2d9447d3..199d74d7a93 100644
--- a/mythtv/external/FFmpeg/libavfilter/tests/filtfmts.c
+++ b/mythtv/external/FFmpeg/libavfilter/tests/filtfmts.c
@@ -25,8 +25,12 @@
 #include "libavutil/pixdesc.h"
 #include "libavutil/samplefmt.h"
 
+#define FF_INTERNAL_FIELDS 1
+#include "libavfilter/framequeue.h"
+
 #include "libavfilter/avfilter.h"
 #include "libavfilter/formats.h"
+#include "libavfilter/internal.h"
 
 static void print_formats(AVFilterContext *filter_ctx)
 {
diff --git a/mythtv/external/FFmpeg/libavfilter/tests/formats.c b/mythtv/external/FFmpeg/libavfilter/tests/formats.c
index 0e8ba4ad158..5450742b687 100644
--- a/mythtv/external/FFmpeg/libavfilter/tests/formats.c
+++ b/mythtv/external/FFmpeg/libavfilter/tests/formats.c
@@ -39,6 +39,9 @@ int main(void)
         "-1c",
         "60c",
         "65c",
+        "2C",
+        "60C",
+        "65C",
         "5.1",
         "stereo",
         "1+1+1+1",
diff --git a/mythtv/external/FFmpeg/libavfilter/tinterlace.h b/mythtv/external/FFmpeg/libavfilter/tinterlace.h
index 3b703e7b214..b5c39aac522 100644
--- a/mythtv/external/FFmpeg/libavfilter/tinterlace.h
+++ b/mythtv/external/FFmpeg/libavfilter/tinterlace.h
@@ -27,9 +27,16 @@
 #ifndef AVFILTER_TINTERLACE_H
 #define AVFILTER_TINTERLACE_H
 
+#include "libavutil/bswap.h"
 #include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "drawutils.h"
 #include "avfilter.h"
 
+#define TINTERLACE_FLAG_VLPF 01
+#define TINTERLACE_FLAG_EXACT_TB 2
+#define TINTERLACE_FLAG_CVLPF 4
+
 enum TInterlaceMode {
     MODE_MERGE = 0,
     MODE_DROP_EVEN,
@@ -42,7 +49,7 @@ enum TInterlaceMode {
     MODE_NB,
 };
 
-typedef struct {
+typedef struct TInterlaceContext {
     const AVClass *class;
     int mode;                   ///< TInterlaceMode, interlace mode selected
     AVRational preout_time_base;
@@ -53,8 +60,11 @@ typedef struct {
     AVFrame *next;
     uint8_t *black_data[4];     ///< buffer used to fill padded lines
     int black_linesize[4];
+    FFDrawContext draw;
+    FFDrawColor color;
+    const AVPixFmtDescriptor *csp;
     void (*lowpass_line)(uint8_t *dstp, ptrdiff_t width, const uint8_t *srcp,
-                         const uint8_t *srcp_above, const uint8_t *srcp_below);
+                         ptrdiff_t mref, ptrdiff_t pref, int clip_max);
 } TInterlaceContext;
 
 void ff_tinterlace_init_x86(TInterlaceContext *interlace);
diff --git a/mythtv/external/FFmpeg/libavfilter/trim.c b/mythtv/external/FFmpeg/libavfilter/trim.c
index 9daaeafa801..1dbbabbb931 100644
--- a/mythtv/external/FFmpeg/libavfilter/trim.c
+++ b/mythtv/external/FFmpeg/libavfilter/trim.c
@@ -365,7 +365,6 @@ AVFilter ff_af_atrim = {
     .name        = "atrim",
     .description = NULL_IF_CONFIG_SMALL("Pick one continuous section from the input, drop the rest."),
     .init        = init,
-    .query_formats = ff_query_formats_all,
     .priv_size   = sizeof(TrimContext),
     .priv_class  = &atrim_class,
     .inputs      = atrim_inputs,
diff --git a/mythtv/external/FFmpeg/libavfilter/unsharp.h b/mythtv/external/FFmpeg/libavfilter/unsharp.h
index fc651c06544..340a6a0caf4 100644
--- a/mythtv/external/FFmpeg/libavfilter/unsharp.h
+++ b/mythtv/external/FFmpeg/libavfilter/unsharp.h
@@ -33,7 +33,7 @@
 
 #if CONFIG_OPENCL
 
-typedef struct {
+typedef struct UnsharpOpenclContext {
     cl_command_queue command_queue;
     cl_program program;
     cl_kernel kernel_default;
diff --git a/mythtv/external/FFmpeg/libavfilter/unsharp_opencl.c b/mythtv/external/FFmpeg/libavfilter/unsharp_opencl.c
index d84920c5902..15454558465 100644
--- a/mythtv/external/FFmpeg/libavfilter/unsharp_opencl.c
+++ b/mythtv/external/FFmpeg/libavfilter/unsharp_opencl.c
@@ -43,7 +43,7 @@ static int compute_mask(int step, uint32_t *mask)
 {
     int i, z, ret = 0;
     int counter_size = sizeof(uint32_t) * (2 * step + 1);
-    uint32_t *temp1_counter, *temp2_counter, **counter;
+    uint32_t *temp1_counter, *temp2_counter, **counter = NULL;
     temp1_counter = av_mallocz(counter_size);
     if (!temp1_counter) {
         ret = AVERROR(ENOMEM);
@@ -80,7 +80,7 @@ static int compute_mask(int step, uint32_t *mask)
 end:
     av_freep(&temp1_counter);
     av_freep(&temp2_counter);
-    for (i = 0; i < 2 * step + 1; i++) {
+    for (i = 0; counter && i < 2 * step + 1; i++) {
         av_freep(&counter[i]);
     }
     av_freep(&counter);
diff --git a/mythtv/external/FFmpeg/libavfilter/vaf_spectrumsynth.c b/mythtv/external/FFmpeg/libavfilter/vaf_spectrumsynth.c
index ed191a3e34b..fed2cbba030 100644
--- a/mythtv/external/FFmpeg/libavfilter/vaf_spectrumsynth.c
+++ b/mythtv/external/FFmpeg/libavfilter/vaf_spectrumsynth.c
@@ -210,7 +210,7 @@ static int config_output(AVFilterLink *outlink)
                                       sizeof(*s->window_func_lut));
     if (!s->window_func_lut)
         return AVERROR(ENOMEM);
-    ff_generate_window_func(s->window_func_lut, s->win_size, s->win_func, &overlap);
+    generate_window_func(s->window_func_lut, s->win_size, s->win_func, &overlap);
     if (s->overlap == 1)
         s->overlap = overlap;
     s->hop_size = (1 - s->overlap) * s->win_size;
diff --git a/mythtv/external/FFmpeg/libavfilter/version.h b/mythtv/external/FFmpeg/libavfilter/version.h
index adf8c719c8f..3e67ad354c2 100644
--- a/mythtv/external/FFmpeg/libavfilter/version.h
+++ b/mythtv/external/FFmpeg/libavfilter/version.h
@@ -30,7 +30,7 @@
 #include "libavutil/version.h"
 
 #define LIBAVFILTER_VERSION_MAJOR   6
-#define LIBAVFILTER_VERSION_MINOR  65
+#define LIBAVFILTER_VERSION_MINOR 107
 #define LIBAVFILTER_VERSION_MICRO 100
 
 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
@@ -67,5 +67,8 @@
 #ifndef FF_API_NOCONST_GET_NAME
 #define FF_API_NOCONST_GET_NAME             (LIBAVFILTER_VERSION_MAJOR < 7)
 #endif
+#ifndef FF_API_LAVR_OPTS
+#define FF_API_LAVR_OPTS                    (LIBAVFILTER_VERSION_MAJOR < 7)
+#endif
 
 #endif /* AVFILTER_VERSION_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_alphamerge.c b/mythtv/external/FFmpeg/libavfilter/vf_alphamerge.c
index a8a8d568249..45fa340fcc6 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_alphamerge.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_alphamerge.c
@@ -25,6 +25,7 @@
 
 #include <string.h>
 
+#include "libavutil/imgutils.h"
 #include "libavutil/pixfmt.h"
 #include "avfilter.h"
 #include "bufferqueue.h"
@@ -35,7 +36,7 @@
 
 enum { Y, U, V, A };
 
-typedef struct {
+typedef struct AlphaMergeContext {
     int is_packed_rgb;
     uint8_t rgba_map[4];
     struct FFBufQueue queue_main;
@@ -53,6 +54,7 @@ static int query_formats(AVFilterContext *ctx)
 {
     static const enum AVPixelFormat main_fmts[] = {
         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
+        AV_PIX_FMT_GBRAP,
         AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA, AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR,
         AV_PIX_FMT_NONE
     };
@@ -84,7 +86,8 @@ static int config_input_main(AVFilterLink *inlink)
 {
     AlphaMergeContext *merge = inlink->dst->priv;
     merge->is_packed_rgb =
-        ff_fill_rgba_map(merge->rgba_map, inlink->format) >= 0;
+        ff_fill_rgba_map(merge->rgba_map, inlink->format) >= 0 &&
+        inlink->format != AV_PIX_FMT_GBRAP;
     return 0;
 }
 
@@ -129,14 +132,11 @@ static void draw_frame(AVFilterContext *ctx,
             }
         }
     } else {
-        int y;
         const int main_linesize = main_buf->linesize[A];
         const int alpha_linesize = alpha_buf->linesize[Y];
-        for (y = 0; y < h && y < alpha_buf->height; y++) {
-            memcpy(main_buf->data[A] + y * main_linesize,
-                   alpha_buf->data[Y] + y * alpha_linesize,
-                   FFMIN(main_linesize, alpha_linesize));
-        }
+        av_image_copy_plane(main_buf->data[A], main_linesize,
+                            alpha_buf->data[Y], alpha_linesize,
+                            FFMIN(main_linesize, alpha_linesize), alpha_buf->height);
     }
 }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_atadenoise.c b/mythtv/external/FFmpeg/libavfilter/vf_atadenoise.c
index bf75d53d927..03b772c6742 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_atadenoise.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_atadenoise.c
@@ -80,6 +80,9 @@ static int query_formats(AVFilterContext *ctx)
 {
     static const enum AVPixelFormat pixel_fmts[] = {
         AV_PIX_FMT_GRAY8,
+        AV_PIX_FMT_GRAY9,
+        AV_PIX_FMT_GRAY10,
+        AV_PIX_FMT_GRAY12,
         AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_avgblur.c b/mythtv/external/FFmpeg/libavfilter/vf_avgblur.c
index 2bb2ab1ed5a..afd4a6ab795 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_avgblur.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_avgblur.c
@@ -241,8 +241,8 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
-        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_NONE
     };
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_bbox.c b/mythtv/external/FFmpeg/libavfilter/vf_bbox.c
index e92c3b477f9..4ac2980a6c4 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_bbox.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_bbox.c
@@ -30,7 +30,7 @@
 #include "bbox.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct BBoxContext {
     const AVClass *class;
     int min_val;
 } BBoxContext;
@@ -80,11 +80,11 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     h = box.y2 - box.y1 + 1;
 
     av_log(ctx, AV_LOG_INFO,
-           "n:%"PRId64" pts:%s pts_time:%s", inlink->frame_count,
+           "n:%"PRId64" pts:%s pts_time:%s", inlink->frame_count_out,
            av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base));
 
     if (has_bbox) {
-        AVDictionary **metadata = avpriv_frame_get_metadatap(frame);
+        AVDictionary **metadata = &frame->metadata;
 
         SET_META("lavfi.bbox.x1", box.x1)
         SET_META("lavfi.bbox.x2", box.x2)
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_bitplanenoise.c b/mythtv/external/FFmpeg/libavfilter/vf_bitplanenoise.c
index de278bc22aa..dd6864bc5e3 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_bitplanenoise.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_bitplanenoise.c
@@ -63,8 +63,7 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV420P16,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
-        AV_PIX_FMT_GRAY8,
-        AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_NONE
     };
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_blackdetect.c b/mythtv/external/FFmpeg/libavfilter/vf_blackdetect.c
index fbe3d108db9..06ef9988d1f 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_blackdetect.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_blackdetect.c
@@ -30,7 +30,7 @@
 #include "avfilter.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct BlackDetectContext {
     const AVClass *class;
     double  black_min_duration_time; ///< minimum duration of detected black, in seconds
     int64_t black_min_duration;      ///< minimum duration of detected black, expressed in timebase units
@@ -155,7 +155,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
 
     av_log(ctx, AV_LOG_DEBUG,
            "frame:%"PRId64" picture_black_ratio:%f pts:%s t:%s type:%c\n",
-           inlink->frame_count, picture_black_ratio,
+           inlink->frame_count_out, picture_black_ratio,
            av_ts2str(picref->pts), av_ts2timestr(picref->pts, &inlink->time_base),
            av_get_picture_type_char(picref->pict_type));
 
@@ -164,7 +164,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
             /* black starts here */
             blackdetect->black_started = 1;
             blackdetect->black_start = picref->pts;
-            av_dict_set(avpriv_frame_get_metadatap(picref), "lavfi.black_start",
+            av_dict_set(&picref->metadata, "lavfi.black_start",
                 av_ts2timestr(blackdetect->black_start, &inlink->time_base), 0);
         }
     } else if (blackdetect->black_started) {
@@ -172,7 +172,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
         blackdetect->black_started = 0;
         blackdetect->black_end = picref->pts;
         check_black_end(ctx);
-        av_dict_set(avpriv_frame_get_metadatap(picref), "lavfi.black_end",
+        av_dict_set(&picref->metadata, "lavfi.black_end",
             av_ts2timestr(blackdetect->black_end, &inlink->time_base), 0);
     }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_blackframe.c b/mythtv/external/FFmpeg/libavfilter/vf_blackframe.c
index 9fe2a429429..804965c42c1 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_blackframe.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_blackframe.c
@@ -85,7 +85,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
 
     pblack = s->nblack * 100 / (inlink->w * inlink->h);
     if (pblack >= s->bamount) {
-        metadata = avpriv_frame_get_metadatap(frame);
+        metadata = &frame->metadata;
 
         av_log(ctx, AV_LOG_INFO, "frame:%u pblack:%u pts:%"PRId64" t:%f "
                "type:%c last_keyframe:%d\n",
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_blend.c b/mythtv/external/FFmpeg/libavfilter/vf_blend.c
index 2731ec81bfa..054c0d55d09 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_blend.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_blend.c
@@ -25,8 +25,8 @@
 #include "avfilter.h"
 #include "bufferqueue.h"
 #include "formats.h"
+#include "framesync.h"
 #include "internal.h"
-#include "dualinput.h"
 #include "video.h"
 #include "blend.h"
 
@@ -35,7 +35,7 @@
 
 typedef struct BlendContext {
     const AVClass *class;
-    FFDualInputContext dinput;
+    FFFrameSync fs;
     int hsub, vsub;             ///< chroma subsampling values
     int nb_planes;
     char *all_expr;
@@ -66,16 +66,19 @@ typedef struct ThreadData {
     { "c3_mode", "set component #3 blend mode", OFFSET(params[3].mode), AV_OPT_TYPE_INT, {.i64=0}, 0, BLEND_NB-1, FLAGS, "mode"},\
     { "all_mode", "set blend mode for all components", OFFSET(all_mode), AV_OPT_TYPE_INT, {.i64=-1},-1, BLEND_NB-1, FLAGS, "mode"},\
     { "addition",   "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_ADDITION},   0, 0, FLAGS, "mode" },\
-    { "addition128", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_ADDITION128}, 0, 0, FLAGS, "mode" },\
+    { "addition128","", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_GRAINMERGE}, 0, 0, FLAGS, "mode" },\
+    { "grainmerge", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_GRAINMERGE}, 0, 0, FLAGS, "mode" },\
     { "and",        "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_AND},        0, 0, FLAGS, "mode" },\
     { "average",    "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_AVERAGE},    0, 0, FLAGS, "mode" },\
     { "burn",       "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_BURN},       0, 0, FLAGS, "mode" },\
     { "darken",     "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DARKEN},     0, 0, FLAGS, "mode" },\
     { "difference", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DIFFERENCE}, 0, 0, FLAGS, "mode" },\
-    { "difference128", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DIFFERENCE128}, 0, 0, FLAGS, "mode" },\
+    { "difference128", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_GRAINEXTRACT}, 0, 0, FLAGS, "mode" },\
+    { "grainextract", "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_GRAINEXTRACT}, 0, 0, FLAGS, "mode" },\
     { "divide",     "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DIVIDE},     0, 0, FLAGS, "mode" },\
     { "dodge",      "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_DODGE},      0, 0, FLAGS, "mode" },\
     { "exclusion",  "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_EXCLUSION},  0, 0, FLAGS, "mode" },\
+    { "extremity",  "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_EXTREMITY},  0, 0, FLAGS, "mode" },\
     { "freeze",     "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_FREEZE},     0, 0, FLAGS, "mode" },\
     { "glow",       "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_GLOW},       0, 0, FLAGS, "mode" },\
     { "hardlight",  "", 0, AV_OPT_TYPE_CONST, {.i64=BLEND_HARDLIGHT},  0, 0, FLAGS, "mode" },\
@@ -113,12 +116,10 @@ typedef struct ThreadData {
 
 static const AVOption blend_options[] = {
     COMMON_OPTIONS,
-    { "shortest",    "force termination when the shortest input terminates", OFFSET(dinput.shortest), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
-    { "repeatlast",  "repeat last bottom frame", OFFSET(dinput.repeatlast), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
     { NULL }
 };
 
-AVFILTER_DEFINE_CLASS(blend);
+FRAMESYNC_DEFINE_CLASS(blend, BlendContext, fs);
 
 #define COPY(src)                                                            \
 static void blend_copy ## src(const uint8_t *top, ptrdiff_t top_linesize,    \
@@ -235,14 +236,15 @@ static void blend_## name##_16bit(const uint8_t *_top, ptrdiff_t top_linesize,
 #define DODGE(a, b)       (((a) == 255) ? (a) : FFMIN(255, (((b) << 8) / (255 - (a)))))
 
 DEFINE_BLEND8(addition,   FFMIN(255, A + B))
-DEFINE_BLEND8(addition128, av_clip_uint8(A + B - 128))
+DEFINE_BLEND8(grainmerge, av_clip_uint8(A + B - 128))
 DEFINE_BLEND8(average,    (A + B) / 2)
 DEFINE_BLEND8(subtract,   FFMAX(0, A - B))
 DEFINE_BLEND8(multiply,   MULTIPLY(1, A, B))
 DEFINE_BLEND8(multiply128,av_clip_uint8((A - 128) * B / 32. + 128))
 DEFINE_BLEND8(negation,   255 - FFABS(255 - A - B))
+DEFINE_BLEND8(extremity,  FFABS(255 - A - B))
 DEFINE_BLEND8(difference, FFABS(A - B))
-DEFINE_BLEND8(difference128, av_clip_uint8(128 + A - B))
+DEFINE_BLEND8(grainextract, av_clip_uint8(128 + A - B))
 DEFINE_BLEND8(screen,     SCREEN(1, A, B))
 DEFINE_BLEND8(overlay,    (A < 128) ? MULTIPLY(2, A, B) : SCREEN(2, A, B))
 DEFINE_BLEND8(hardlight,  (B < 128) ? MULTIPLY(2, B, A) : SCREEN(2, B, A))
@@ -277,14 +279,15 @@ DEFINE_BLEND8(linearlight,av_clip_uint8((B < 128) ? B + 2 * A - 255 : B + 2 * (A
 #define DODGE(a, b)       (((a) == 65535) ? (a) : FFMIN(65535, (((b) << 16) / (65535 - (a)))))
 
 DEFINE_BLEND16(addition,   FFMIN(65535, A + B))
-DEFINE_BLEND16(addition128, av_clip_uint16(A + B - 32768))
+DEFINE_BLEND16(grainmerge, av_clip_uint16(A + B - 32768))
 DEFINE_BLEND16(average,    (A + B) / 2)
 DEFINE_BLEND16(subtract,   FFMAX(0, A - B))
 DEFINE_BLEND16(multiply,   MULTIPLY(1, A, B))
 DEFINE_BLEND16(multiply128, av_clip_uint16((A - 32768) * B / 8192. + 32768))
 DEFINE_BLEND16(negation,   65535 - FFABS(65535 - A - B))
+DEFINE_BLEND16(extremity,  FFABS(65535 - A - B))
 DEFINE_BLEND16(difference, FFABS(A - B))
-DEFINE_BLEND16(difference128, av_clip_uint16(32768 + A - B))
+DEFINE_BLEND16(grainextract, av_clip_uint16(32768 + A - B))
 DEFINE_BLEND16(screen,     SCREEN(1, A, B))
 DEFINE_BLEND16(overlay,    (A < 32768) ? MULTIPLY(2, A, B) : SCREEN(2, A, B))
 DEFINE_BLEND16(hardlight,  (B < 32768) ? MULTIPLY(2, B, A) : SCREEN(2, B, A))
@@ -352,7 +355,7 @@ static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
     uint8_t *dst    = td->dst->data[td->plane];
     double values[VAR_VARS_NB];
 
-    values[VAR_N]  = td->inlink->frame_count;
+    values[VAR_N]  = td->inlink->frame_count_out;
     values[VAR_T]  = td->dst->pts == AV_NOPTS_VALUE ? NAN : td->dst->pts * av_q2d(td->inlink->time_base);
     values[VAR_W]  = td->w;
     values[VAR_H]  = td->h;
@@ -402,13 +405,28 @@ static AVFrame *blend_frame(AVFilterContext *ctx, AVFrame *top_buf,
     return dst_buf;
 }
 
+static int blend_frame_for_dualinput(FFFrameSync *fs)
+{
+    AVFilterContext *ctx = fs->parent;
+    AVFrame *top_buf, *bottom_buf, *dst_buf;
+    int ret;
+
+    ret = ff_framesync_dualinput_get(fs, &top_buf, &bottom_buf);
+    if (ret < 0)
+        return ret;
+    if (!bottom_buf)
+        return ff_filter_frame(ctx->outputs[0], top_buf);
+    dst_buf = blend_frame(ctx, top_buf, bottom_buf);
+    return ff_filter_frame(ctx->outputs[0], dst_buf);
+}
+
 static av_cold int init(AVFilterContext *ctx)
 {
     BlendContext *s = ctx->priv;
 
     s->tblend = !strcmp(ctx->filter->name, "tblend");
 
-    s->dinput.process = blend_frame;
+    s->fs.on_event = blend_frame_for_dualinput;
     return 0;
 }
 
@@ -421,7 +439,7 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8,
         AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
-        AV_PIX_FMT_GBRP16, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_NONE
     };
 
@@ -436,7 +454,7 @@ static av_cold void uninit(AVFilterContext *ctx)
     BlendContext *s = ctx->priv;
     int i;
 
-    ff_dualinput_uninit(&s->dinput);
+    ff_framesync_uninit(&s->fs);
     av_frame_free(&s->prev_frame);
 
     for (i = 0; i < FF_ARRAY_ELEMS(s->params); i++)
@@ -447,16 +465,17 @@ void ff_blend_init(FilterParams *param, int is_16bit)
 {
     switch (param->mode) {
     case BLEND_ADDITION:   param->blend = is_16bit ? blend_addition_16bit   : blend_addition_8bit;   break;
-    case BLEND_ADDITION128: param->blend = is_16bit ? blend_addition128_16bit : blend_addition128_8bit; break;
+    case BLEND_GRAINMERGE: param->blend = is_16bit ? blend_grainmerge_16bit : blend_grainmerge_8bit; break;
     case BLEND_AND:        param->blend = is_16bit ? blend_and_16bit        : blend_and_8bit;        break;
     case BLEND_AVERAGE:    param->blend = is_16bit ? blend_average_16bit    : blend_average_8bit;    break;
     case BLEND_BURN:       param->blend = is_16bit ? blend_burn_16bit       : blend_burn_8bit;       break;
     case BLEND_DARKEN:     param->blend = is_16bit ? blend_darken_16bit     : blend_darken_8bit;     break;
     case BLEND_DIFFERENCE: param->blend = is_16bit ? blend_difference_16bit : blend_difference_8bit; break;
-    case BLEND_DIFFERENCE128: param->blend = is_16bit ? blend_difference128_16bit: blend_difference128_8bit; break;
+    case BLEND_GRAINEXTRACT: param->blend = is_16bit ? blend_grainextract_16bit: blend_grainextract_8bit; break;
     case BLEND_DIVIDE:     param->blend = is_16bit ? blend_divide_16bit     : blend_divide_8bit;     break;
     case BLEND_DODGE:      param->blend = is_16bit ? blend_dodge_16bit      : blend_dodge_8bit;      break;
     case BLEND_EXCLUSION:  param->blend = is_16bit ? blend_exclusion_16bit  : blend_exclusion_8bit;  break;
+    case BLEND_EXTREMITY:  param->blend = is_16bit ? blend_extremity_16bit  : blend_extremity_8bit;  break;
     case BLEND_FREEZE:     param->blend = is_16bit ? blend_freeze_16bit     : blend_freeze_8bit;     break;
     case BLEND_GLOW:       param->blend = is_16bit ? blend_glow_16bit       : blend_glow_8bit;       break;
     case BLEND_HARDLIGHT:  param->blend = is_16bit ? blend_hardlight_16bit  : blend_hardlight_8bit;  break;
@@ -535,7 +554,7 @@ static int config_output(AVFilterLink *outlink)
     s->nb_planes = av_pix_fmt_count_planes(toplink->format);
 
     if (!s->tblend)
-        if ((ret = ff_dualinput_init(ctx, &s->dinput)) < 0)
+        if ((ret = ff_framesync_init_dualinput(&s->fs, ctx)) < 0)
             return ret;
 
     for (plane = 0; plane < FF_ARRAY_ELEMS(s->params); plane++) {
@@ -562,32 +581,24 @@ static int config_output(AVFilterLink *outlink)
         }
     }
 
-    return 0;
+    return s->tblend ? 0 : ff_framesync_configure(&s->fs);
 }
 
 #if CONFIG_BLEND_FILTER
 
-static int request_frame(AVFilterLink *outlink)
+static int activate(AVFilterContext *ctx)
 {
-    BlendContext *s = outlink->src->priv;
-    return ff_dualinput_request_frame(&s->dinput, outlink);
-}
-
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
-{
-    BlendContext *s = inlink->dst->priv;
-    return ff_dualinput_filter_frame(&s->dinput, inlink, buf);
+    BlendContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static const AVFilterPad blend_inputs[] = {
     {
         .name          = "top",
         .type          = AVMEDIA_TYPE_VIDEO,
-        .filter_frame  = filter_frame,
     },{
         .name          = "bottom",
         .type          = AVMEDIA_TYPE_VIDEO,
-        .filter_frame  = filter_frame,
     },
     { NULL }
 };
@@ -597,7 +608,6 @@ static const AVFilterPad blend_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -605,10 +615,12 @@ static const AVFilterPad blend_outputs[] = {
 AVFilter ff_vf_blend = {
     .name          = "blend",
     .description   = NULL_IF_CONFIG_SMALL("Blend two video frames into each other."),
+    .preinit       = blend_framesync_preinit,
     .init          = init,
     .uninit        = uninit,
     .priv_size     = sizeof(BlendContext),
     .query_formats = query_formats,
+    .activate      = activate,
     .inputs        = blend_inputs,
     .outputs       = blend_outputs,
     .priv_class    = &blend_class,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_ciescope.c b/mythtv/external/FFmpeg/libavfilter/vf_ciescope.c
index 450c17b1266..7c0cfed061a 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_ciescope.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_ciescope.c
@@ -1369,8 +1369,10 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 
     if (!s->background) {
         ret = draw_background(ctx);
-        if (ret < 0)
+        if (ret < 0) {
+            av_frame_free(&out);
             return ret;
+        }
         s->background = 1;
     }
     for (y = 0; y < outlink->h; y++) {
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_codecview.c b/mythtv/external/FFmpeg/libavfilter/vf_codecview.c
index dc3397316d8..331bfba777d 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_codecview.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_codecview.c
@@ -44,7 +44,7 @@
 #define FRAME_TYPE_P (1<<1)
 #define FRAME_TYPE_B (1<<2)
 
-typedef struct {
+typedef struct CodecViewContext {
     const AVClass *class;
     unsigned mv;
     unsigned frame_type;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_colorbalance.c b/mythtv/external/FFmpeg/libavfilter/vf_colorbalance.c
index e37f1995cac..f9965248fef 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_colorbalance.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_colorbalance.c
@@ -31,13 +31,13 @@
 #define B 2
 #define A 3
 
-typedef struct {
+typedef struct Range {
     double shadows;
     double midtones;
     double highlights;
 } Range;
 
-typedef struct {
+typedef struct ColorBalanceContext {
     const AVClass *class;
     Range cyan_red;
     Range magenta_green;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_colorchannelmixer.c b/mythtv/external/FFmpeg/libavfilter/vf_colorchannelmixer.c
index cda972dd002..2e068fa7947 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_colorchannelmixer.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_colorchannelmixer.c
@@ -30,7 +30,7 @@
 #define B 2
 #define A 3
 
-typedef struct {
+typedef struct ColorChannelMixerContext {
     const AVClass *class;
     double rr, rg, rb, ra;
     double gr, gg, gb, ga;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_colorlevels.c b/mythtv/external/FFmpeg/libavfilter/vf_colorlevels.c
index dedbe30d191..5385a5e7542 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_colorlevels.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_colorlevels.c
@@ -32,12 +32,12 @@
 #define B 2
 #define A 3
 
-typedef struct {
+typedef struct Range {
     double in_min, in_max;
     double out_min, out_max;
 } Range;
 
-typedef struct {
+typedef struct ColorLevelsContext {
     const AVClass *class;
     Range range[4];
     int nb_comp;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_colormatrix.c b/mythtv/external/FFmpeg/libavfilter/vf_colormatrix.c
index d237baa7b9b..3a02e2b86ea 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_colormatrix.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_colormatrix.c
@@ -58,7 +58,7 @@ enum ColorMode {
     COLOR_MODE_COUNT
 };
 
-typedef struct {
+typedef struct ColorMatrixContext {
     const AVClass *class;
     int yuv_convert[25][3][3];
     int interlaced;
@@ -435,7 +435,7 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
     av_frame_copy_props(out, in);
 
     if (color->source == COLOR_MODE_NONE) {
-        enum AVColorSpace cs = av_frame_get_colorspace(in);
+        enum AVColorSpace cs = in->colorspace;
         enum ColorMode source;
 
         switch(cs) {
@@ -456,11 +456,11 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
         color->mode = color->source * 5 + color->dest;
 
     switch(color->dest) {
-    case COLOR_MODE_BT709    : av_frame_set_colorspace(out, AVCOL_SPC_BT709)     ; break;
-    case COLOR_MODE_FCC      : av_frame_set_colorspace(out, AVCOL_SPC_FCC)       ; break;
-    case COLOR_MODE_SMPTE240M: av_frame_set_colorspace(out, AVCOL_SPC_SMPTE240M) ; break;
-    case COLOR_MODE_BT601    : av_frame_set_colorspace(out, AVCOL_SPC_BT470BG)   ; break;
-    case COLOR_MODE_BT2020   : av_frame_set_colorspace(out, AVCOL_SPC_BT2020_NCL); break;
+    case COLOR_MODE_BT709    : out->colorspace = AVCOL_SPC_BT709     ; break;
+    case COLOR_MODE_FCC      : out->colorspace = AVCOL_SPC_FCC       ; break;
+    case COLOR_MODE_SMPTE240M: out->colorspace = AVCOL_SPC_SMPTE240M ; break;
+    case COLOR_MODE_BT601    : out->colorspace = AVCOL_SPC_BT470BG   ; break;
+    case COLOR_MODE_BT2020   : out->colorspace = AVCOL_SPC_BT2020_NCL; break;
     }
 
     td.src = in;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_colorspace.c b/mythtv/external/FFmpeg/libavfilter/vf_colorspace.c
index 930aa951f1a..71ea08a20fe 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_colorspace.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_colorspace.c
@@ -56,6 +56,8 @@ enum Colorspace {
 enum Whitepoint {
     WP_D65,
     WP_C,
+    WP_DCI,
+    WP_E,
     WP_NB,
 };
 
@@ -167,7 +169,7 @@ typedef struct ColorSpaceContext {
     int did_warn_range;
 } ColorSpaceContext;
 
-// FIXME deal with odd width/heights (or just forbid it)
+// FIXME deal with odd width/heights
 // FIXME faster linearize/delinearize implementation (integer pow)
 // FIXME bt2020cl support (linearization between yuv/rgb step instead of between rgb/xyz)
 // FIXME test that the values in (de)lin_lut don't exceed their container storage
@@ -175,6 +177,20 @@ typedef struct ColorSpaceContext {
 // FIXME dithering if bitdepth goes down?
 // FIXME bitexact for fate integration?
 
+static const double ycgco_matrix[3][3] =
+{
+    {  0.25, 0.5,  0.25 },
+    { -0.25, 0.5, -0.25 },
+    {  0.5,  0,   -0.5  },
+};
+
+static const double gbr_matrix[3][3] =
+{
+    { 0,    1,   0   },
+    { 0,   -0.5, 0.5 },
+    { 0.5, -0.5, 0   },
+};
+
 /*
  * All constants explained in e.g. https://linuxtv.org/downloads/v4l-dvb-apis/ch02s06.html
  * The older ones (bt470bg/m) are also explained in their respective ITU docs
@@ -187,6 +203,8 @@ static const struct LumaCoefficients luma_coefficients[AVCOL_SPC_NB] = {
     [AVCOL_SPC_SMPTE170M]  = { 0.299,  0.587,  0.114  },
     [AVCOL_SPC_BT709]      = { 0.2126, 0.7152, 0.0722 },
     [AVCOL_SPC_SMPTE240M]  = { 0.212,  0.701,  0.087  },
+    [AVCOL_SPC_YCOCG]      = { 0.25,   0.5,    0.25   },
+    [AVCOL_SPC_RGB]        = { 1,      1,      1      },
     [AVCOL_SPC_BT2020_NCL] = { 0.2627, 0.6780, 0.0593 },
     [AVCOL_SPC_BT2020_CL]  = { 0.2627, 0.6780, 0.0593 },
 };
@@ -209,6 +227,15 @@ static void fill_rgb2yuv_table(const struct LumaCoefficients *coeffs,
 {
     double bscale, rscale;
 
+    // special ycgco matrix
+    if (coeffs->cr == 0.25 && coeffs->cg == 0.5 && coeffs->cb == 0.25) {
+        memcpy(rgb2yuv, ycgco_matrix, sizeof(double) * 9);
+        return;
+    } else if (coeffs->cr == 1 && coeffs->cg == 1 && coeffs->cb == 1) {
+        memcpy(rgb2yuv, gbr_matrix, sizeof(double) * 9);
+        return;
+    }
+
     rgb2yuv[0][0] = coeffs->cr;
     rgb2yuv[0][1] = coeffs->cg;
     rgb2yuv[0][2] = coeffs->cb;
@@ -232,6 +259,7 @@ static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_N
     [AVCOL_TRC_SMPTE170M] = { 1.099,  0.018,  0.45, 4.5 },
     [AVCOL_TRC_SMPTE240M] = { 1.1115, 0.0228, 0.45, 4.0 },
     [AVCOL_TRC_IEC61966_2_1] = { 1.055, 0.0031308, 1.0 / 2.4, 12.92 },
+    [AVCOL_TRC_IEC61966_2_4] = { 1.099, 0.018, 0.45, 4.5 },
     [AVCOL_TRC_BT2020_10] = { 1.099,  0.018,  0.45, 4.5 },
     [AVCOL_TRC_BT2020_12] = { 1.0993, 0.0181, 0.45, 4.5 },
 };
@@ -253,6 +281,8 @@ static const struct TransferCharacteristics *
 static const struct WhitepointCoefficients whitepoint_coefficients[WP_NB] = {
     [WP_D65] = { 0.3127, 0.3290 },
     [WP_C]   = { 0.3100, 0.3160 },
+    [WP_DCI] = { 0.3140, 0.3510 },
+    [WP_E]   = { 1/3.0f, 1/3.0f },
 };
 
 static const struct ColorPrimaries color_primaries[AVCOL_PRI_NB] = {
@@ -261,7 +291,12 @@ static const struct ColorPrimaries color_primaries[AVCOL_PRI_NB] = {
     [AVCOL_PRI_BT470BG]   = { WP_D65, 0.640, 0.330, 0.290, 0.600, 0.150, 0.060,},
     [AVCOL_PRI_SMPTE170M] = { WP_D65, 0.630, 0.340, 0.310, 0.595, 0.155, 0.070 },
     [AVCOL_PRI_SMPTE240M] = { WP_D65, 0.630, 0.340, 0.310, 0.595, 0.155, 0.070 },
+    [AVCOL_PRI_SMPTE428]  = { WP_E,   0.735, 0.265, 0.274, 0.718, 0.167, 0.009 },
+    [AVCOL_PRI_SMPTE431]  = { WP_DCI, 0.680, 0.320, 0.265, 0.690, 0.150, 0.060 },
+    [AVCOL_PRI_SMPTE432]  = { WP_D65, 0.680, 0.320, 0.265, 0.690, 0.150, 0.060 },
+    [AVCOL_PRI_FILM]      = { WP_C,   0.681, 0.319, 0.243, 0.692, 0.145, 0.049 },
     [AVCOL_PRI_BT2020]    = { WP_D65, 0.708, 0.292, 0.170, 0.797, 0.131, 0.046 },
+    [AVCOL_PRI_JEDEC_P22] = { WP_D65, 0.630, 0.340, 0.295, 0.605, 0.155, 0.077 },
 };
 
 static const struct ColorPrimaries *get_color_primaries(enum AVColorPrimaries prm)
@@ -1011,8 +1046,15 @@ static int query_formats(AVFilterContext *ctx)
 
 static int config_props(AVFilterLink *outlink)
 {
+    AVFilterContext *ctx = outlink->dst;
     AVFilterLink *inlink = outlink->src->inputs[0];
 
+    if (inlink->w % 2 || inlink->h % 2) {
+        av_log(ctx, AV_LOG_ERROR, "Invalid odd size (%dx%d)\n",
+               inlink->w, inlink->h);
+        return AVERROR_PATCHWELCOME;
+    }
+
     outlink->w = inlink->w;
     outlink->h = inlink->h;
     outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
@@ -1046,6 +1088,9 @@ static const AVOption colorspace_options[] = {
     ENUM("bt470bg",     AVCOL_SPC_BT470BG,     "csp"),
     ENUM("smpte170m",   AVCOL_SPC_SMPTE170M,   "csp"),
     ENUM("smpte240m",   AVCOL_SPC_SMPTE240M,   "csp"),
+    ENUM("ycgco",       AVCOL_SPC_YCGCO,       "csp"),
+    ENUM("gbr",         AVCOL_SPC_RGB,         "csp"),
+    ENUM("bt2020nc",    AVCOL_SPC_BT2020_NCL,  "csp"),
     ENUM("bt2020ncl",   AVCOL_SPC_BT2020_NCL,  "csp"),
 
     { "range",      "Output color range",
@@ -1064,7 +1109,12 @@ static const AVOption colorspace_options[] = {
     ENUM("bt470bg",      AVCOL_PRI_BT470BG,    "prm"),
     ENUM("smpte170m",    AVCOL_PRI_SMPTE170M,  "prm"),
     ENUM("smpte240m",    AVCOL_PRI_SMPTE240M,  "prm"),
+    ENUM("smpte428",     AVCOL_PRI_SMPTE428,   "prm"),
+    ENUM("film",         AVCOL_PRI_FILM,       "prm"),
+    ENUM("smpte431",     AVCOL_PRI_SMPTE431,   "prm"),
+    ENUM("smpte432",     AVCOL_PRI_SMPTE432,   "prm"),
     ENUM("bt2020",       AVCOL_PRI_BT2020,     "prm"),
+    ENUM("jedec-p22",    AVCOL_PRI_JEDEC_P22,  "prm"),
 
     { "trc",        "Output transfer characteristics",
       OFFSET(user_trc),   AV_OPT_TYPE_INT, { .i64 = AVCOL_TRC_UNSPECIFIED },
@@ -1078,6 +1128,8 @@ static const AVOption colorspace_options[] = {
     ENUM("smpte240m",    AVCOL_TRC_SMPTE240M,    "trc"),
     ENUM("srgb",         AVCOL_TRC_IEC61966_2_1, "trc"),
     ENUM("iec61966-2-1", AVCOL_TRC_IEC61966_2_1, "trc"),
+    ENUM("xvycc",        AVCOL_TRC_IEC61966_2_4, "trc"),
+    ENUM("iec61966-2-4", AVCOL_TRC_IEC61966_2_4, "trc"),
     ENUM("bt2020-10",    AVCOL_TRC_BT2020_10,    "trc"),
     ENUM("bt2020-12",    AVCOL_TRC_BT2020_12,    "trc"),
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_convolution.c b/mythtv/external/FFmpeg/libavfilter/vf_convolution.c
index 41e92497c3e..602031999f3 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_convolution.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_convolution.c
@@ -104,8 +104,8 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
-        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_NONE
     };
 
@@ -198,6 +198,55 @@ static int filter16_prewitt(AVFilterContext *ctx, void *arg, int jobnr, int nb_j
     return 0;
 }
 
+static int filter16_roberts(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+    ConvolutionContext *s = ctx->priv;
+    ThreadData *td = arg;
+    AVFrame *in = td->in;
+    AVFrame *out = td->out;
+    const int plane = td->plane;
+    const int peak = (1 << s->depth) - 1;
+    const int stride = in->linesize[plane] / 2;
+    const int bstride = s->bstride;
+    const int height = s->planeheight[plane];
+    const int width  = s->planewidth[plane];
+    const int slice_start = (height * jobnr) / nb_jobs;
+    const int slice_end = (height * (jobnr+1)) / nb_jobs;
+    const uint16_t *src = (const uint16_t *)in->data[plane] + slice_start * stride;
+    uint16_t *dst = (uint16_t *)out->data[plane] + slice_start * (out->linesize[plane] / 2);
+    const float scale = s->scale;
+    const float delta = s->delta;
+    uint16_t *p0 = (uint16_t *)s->bptrs[jobnr] + 16;
+    uint16_t *p1 = p0 + bstride;
+    uint16_t *p2 = p1 + bstride;
+    uint16_t *orig = p0, *end = p2;
+    int y, x;
+
+    line_copy16(p0, src + stride * (slice_start == 0 ? 1 : -1), width, 1);
+    line_copy16(p1, src, width, 1);
+
+    for (y = slice_start; y < slice_end; y++) {
+        src += stride * (y < height - 1 ? 1 : -1);
+        line_copy16(p2, src, width, 1);
+
+        for (x = 0; x < width; x++) {
+            int suma = p0[x - 1] *  1 +
+                       p1[x    ] * -1;
+            int sumb = p0[x    ] *  1 +
+                       p1[x - 1] * -1;
+
+            dst[x] = av_clip(sqrt(suma*suma + sumb*sumb) * scale + delta, 0, peak);
+        }
+
+        p0 = p1;
+        p1 = p2;
+        p2 = (p2 == end) ? orig: p2 + bstride;
+        dst += out->linesize[plane] / 2;
+    }
+
+    return 0;
+}
+
 static int filter16_sobel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
 {
     ConvolutionContext *s = ctx->priv;
@@ -311,6 +360,54 @@ static int filter_prewitt(AVFilterContext *ctx, void *arg, int jobnr, int nb_job
     return 0;
 }
 
+static int filter_roberts(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+    ConvolutionContext *s = ctx->priv;
+    ThreadData *td = arg;
+    AVFrame *in = td->in;
+    AVFrame *out = td->out;
+    const int plane = td->plane;
+    const int stride = in->linesize[plane];
+    const int bstride = s->bstride;
+    const int height = s->planeheight[plane];
+    const int width  = s->planewidth[plane];
+    const int slice_start = (height * jobnr) / nb_jobs;
+    const int slice_end = (height * (jobnr+1)) / nb_jobs;
+    const uint8_t *src = in->data[plane] + slice_start * stride;
+    uint8_t *dst = out->data[plane] + slice_start * out->linesize[plane];
+    const float scale = s->scale;
+    const float delta = s->delta;
+    uint8_t *p0 = s->bptrs[jobnr] + 16;
+    uint8_t *p1 = p0 + bstride;
+    uint8_t *p2 = p1 + bstride;
+    uint8_t *orig = p0, *end = p2;
+    int y, x;
+
+    line_copy8(p0, src + stride * (slice_start == 0 ? 1 : -1), width, 1);
+    line_copy8(p1, src, width, 1);
+
+    for (y = slice_start; y < slice_end; y++) {
+        src += stride * (y < height - 1 ? 1 : -1);
+        line_copy8(p2, src, width, 1);
+
+        for (x = 0; x < width; x++) {
+            int suma = p0[x - 1] *  1 +
+                       p1[x    ] * -1;
+            int sumb = p0[x    ] *  1 +
+                       p1[x - 1] * -1;
+
+            dst[x] = av_clip_uint8(sqrt(suma*suma + sumb*sumb) * scale + delta);
+        }
+
+        p0 = p1;
+        p1 = p2;
+        p2 = (p2 == end) ? orig: p2 + bstride;
+        dst += out->linesize[plane];
+    }
+
+    return 0;
+}
+
 static int filter_sobel(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
 {
     ConvolutionContext *s = ctx->priv;
@@ -651,6 +748,10 @@ static int config_input(AVFilterLink *inlink)
         if (s->depth > 8)
             for (p = 0; p < s->nb_planes; p++)
                 s->filter[p] = filter16_prewitt;
+    } else if (!strcmp(ctx->filter->name, "roberts")) {
+        if (s->depth > 8)
+            for (p = 0; p < s->nb_planes; p++)
+                s->filter[p] = filter16_roberts;
     } else if (!strcmp(ctx->filter->name, "sobel")) {
         if (s->depth > 8)
             for (p = 0; p < s->nb_planes; p++)
@@ -739,6 +840,13 @@ static av_cold int init(AVFilterContext *ctx)
             else
                 s->copy[i] = 1;
         }
+    } else if (!strcmp(ctx->filter->name, "roberts")) {
+        for (i = 0; i < 4; i++) {
+            if ((1 << i) & s->planes)
+                s->filter[i] = filter_roberts;
+            else
+                s->copy[i] = 1;
+        }
     } else if (!strcmp(ctx->filter->name, "sobel")) {
         for (i = 0; i < 4; i++) {
             if ((1 << i) & s->planes)
@@ -845,3 +953,29 @@ AVFilter ff_vf_sobel = {
 };
 
 #endif /* CONFIG_SOBEL_FILTER */
+
+#if CONFIG_ROBERTS_FILTER
+
+static const AVOption roberts_options[] = {
+    { "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT,  {.i64=15}, 0, 15, FLAGS},
+    { "scale",  "set scale",            OFFSET(scale), AV_OPT_TYPE_FLOAT, {.dbl=1.0}, 0.0,  65535, FLAGS},
+    { "delta",  "set delta",            OFFSET(delta), AV_OPT_TYPE_FLOAT, {.dbl=0}, -65535, 65535, FLAGS},
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(roberts);
+
+AVFilter ff_vf_roberts = {
+    .name          = "roberts",
+    .description   = NULL_IF_CONFIG_SMALL("Apply roberts cross operator."),
+    .priv_size     = sizeof(ConvolutionContext),
+    .priv_class    = &roberts_class,
+    .init          = init,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .inputs        = convolution_inputs,
+    .outputs       = convolution_outputs,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
+};
+
+#endif /* CONFIG_ROBERTS_FILTER */
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_convolve.c b/mythtv/external/FFmpeg/libavfilter/vf_convolve.c
new file mode 100644
index 00000000000..e00a44d63d7
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_convolve.c
@@ -0,0 +1,418 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/imgutils.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "libavcodec/avfft.h"
+
+#include "avfilter.h"
+#include "formats.h"
+#include "framesync.h"
+#include "internal.h"
+#include "video.h"
+
+typedef struct ConvolveContext {
+    const AVClass *class;
+    FFFrameSync fs;
+
+    FFTContext *fft[4];
+    FFTContext *ifft[4];
+
+    int fft_bits[4];
+    int fft_len[4];
+    int planewidth[4];
+    int planeheight[4];
+
+    FFTComplex *fft_hdata[4];
+    FFTComplex *fft_vdata[4];
+    FFTComplex *fft_hdata_impulse[4];
+    FFTComplex *fft_vdata_impulse[4];
+
+    int depth;
+    int planes;
+    int impulse;
+    int nb_planes;
+    int got_impulse[4];
+} ConvolveContext;
+
+#define OFFSET(x) offsetof(ConvolveContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption convolve_options[] = {
+    { "planes",  "set planes to convolve",                  OFFSET(planes),   AV_OPT_TYPE_INT,   {.i64=7}, 0, 15, FLAGS },
+    { "impulse", "when to process impulses",                OFFSET(impulse),  AV_OPT_TYPE_INT,   {.i64=1}, 0,  1, FLAGS, "impulse" },
+    {   "first", "process only first impulse, ignore rest", 0,                AV_OPT_TYPE_CONST, {.i64=0}, 0,  0, FLAGS, "impulse" },
+    {   "all",   "process all impulses",                    0,                AV_OPT_TYPE_CONST, {.i64=1}, 0,  0, FLAGS, "impulse" },
+    { NULL },
+};
+
+FRAMESYNC_DEFINE_CLASS(convolve, ConvolveContext, fs);
+
+static int query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pixel_fmts_fftfilt[] = {
+        AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
+        AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
+        AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
+        AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
+        AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+        AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
+        AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
+        AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
+        AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
+        AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
+        AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
+        AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
+        AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
+        AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
+        AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
+        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_NONE
+    };
+
+    AVFilterFormats *fmts_list = ff_make_format_list(pixel_fmts_fftfilt);
+    if (!fmts_list)
+        return AVERROR(ENOMEM);
+    return ff_set_common_formats(ctx, fmts_list);
+}
+
+static int config_input_main(AVFilterLink *inlink)
+{
+    ConvolveContext *s = inlink->dst->priv;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    int fft_bits, i;
+
+    s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
+    s->planewidth[0] = s->planewidth[3] = inlink->w;
+    s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
+    s->planeheight[0] = s->planeheight[3] = inlink->h;
+
+    s->nb_planes = desc->nb_components;
+    s->depth = desc->comp[0].depth;
+
+    for (i = 0; i < s->nb_planes; i++) {
+        int w = s->planewidth[i];
+        int h = s->planeheight[i];
+        int n = FFMAX(w, h) * 10/9;
+
+        for (fft_bits = 1; 1 << fft_bits < n; fft_bits++);
+
+        s->fft_bits[i] = fft_bits;
+        s->fft_len[i] = 1 << s->fft_bits[i];
+
+        if (!(s->fft_hdata[i] = av_calloc(s->fft_len[i], s->fft_len[i] * sizeof(FFTComplex))))
+            return AVERROR(ENOMEM);
+
+        if (!(s->fft_vdata[i] = av_calloc(s->fft_len[i], s->fft_len[i] * sizeof(FFTComplex))))
+            return AVERROR(ENOMEM);
+
+        if (!(s->fft_hdata_impulse[i] = av_calloc(s->fft_len[i], s->fft_len[i] * sizeof(FFTComplex))))
+            return AVERROR(ENOMEM);
+
+        if (!(s->fft_vdata_impulse[i] = av_calloc(s->fft_len[i], s->fft_len[i] * sizeof(FFTComplex))))
+            return AVERROR(ENOMEM);
+    }
+
+    return 0;
+}
+
+static int config_input_impulse(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx  = inlink->dst;
+
+    if (ctx->inputs[0]->w != ctx->inputs[1]->w ||
+        ctx->inputs[0]->h != ctx->inputs[1]->h) {
+        av_log(ctx, AV_LOG_ERROR, "Width and height of input videos must be same.\n");
+        return AVERROR(EINVAL);
+    }
+    if (ctx->inputs[0]->format != ctx->inputs[1]->format) {
+        av_log(ctx, AV_LOG_ERROR, "Inputs must be of same pixel format.\n");
+        return AVERROR(EINVAL);
+    }
+
+    return 0;
+}
+
+static void fft_horizontal(ConvolveContext *s, FFTComplex *fft_hdata,
+                           AVFrame *in, int w, int h, int n, int plane, float scale)
+{
+    int y, x;
+
+    for (y = 0; y < h; y++) {
+        if (s->depth == 8) {
+            const uint8_t *src = in->data[plane] + in->linesize[plane] * y;
+
+            for (x = 0; x < w; x++) {
+                fft_hdata[y * n + x].re = src[x] * scale;
+                fft_hdata[y * n + x].im = 0;
+            }
+        } else {
+            const uint16_t *src = (const uint16_t *)(in->data[plane] + in->linesize[plane] * y);
+
+            for (x = 0; x < w; x++) {
+                fft_hdata[y * n + x].re = src[x] * scale;
+                fft_hdata[y * n + x].im = 0;
+            }
+        }
+        for (; x < n; x++) {
+            fft_hdata[y * n + x].re = 0;
+            fft_hdata[y * n + x].im = 0;
+        }
+    }
+
+    for (; y < n; y++) {
+        for (x = 0; x < n; x++) {
+            fft_hdata[y * n + x].re = 0;
+            fft_hdata[y * n + x].im = 0;
+        }
+    }
+
+    for (y = 0; y < n; y++) {
+        av_fft_permute(s->fft[plane], fft_hdata + y * n);
+        av_fft_calc(s->fft[plane], fft_hdata + y * n);
+    }
+}
+
+static void fft_vertical(ConvolveContext *s, FFTComplex *fft_hdata, FFTComplex *fft_vdata,
+                         int n, int plane)
+{
+    int y, x;
+
+    for (y = 0; y < n; y++) {
+        for (x = 0; x < n; x++) {
+            fft_vdata[y * n + x].re = fft_hdata[x * n + y].re;
+            fft_vdata[y * n + x].im = fft_hdata[x * n + y].im;
+        }
+        for (; x < n; x++) {
+            fft_vdata[y * n + x].re = 0;
+            fft_vdata[y * n + x].im = 0;
+        }
+        av_fft_permute(s->fft[plane], fft_vdata + y * n);
+        av_fft_calc(s->fft[plane], fft_vdata + y * n);
+    }
+}
+
+static void ifft_vertical(ConvolveContext *s, int n, int plane)
+{
+    int y, x;
+
+    for (y = 0; y < n; y++) {
+        av_fft_permute(s->ifft[plane], s->fft_vdata[plane] + y * n);
+        av_fft_calc(s->ifft[plane], s->fft_vdata[plane] + y * n);
+        for (x = 0; x < n; x++) {
+            s->fft_hdata[plane][x * n + y].re = s->fft_vdata[plane][y * n + x].re;
+            s->fft_hdata[plane][x * n + y].im = s->fft_vdata[plane][y * n + x].im;
+        }
+    }
+}
+
+static void ifft_horizontal(ConvolveContext *s, AVFrame *out,
+                            int w, int h, int n, int plane)
+{
+    const float scale = 1.f / (n * n);
+    const int max = (1 << s->depth) - 1;
+    const int oh = h / 2;
+    const int ow = w / 2;
+    int y, x;
+
+    for (y = 0; y < n; y++) {
+        av_fft_permute(s->ifft[plane], s->fft_hdata[plane] + y * n);
+        av_fft_calc(s->ifft[plane], s->fft_hdata[plane] + y * n);
+    }
+
+    if (s->depth == 8) {
+        for (y = 0; y < h; y++) {
+            uint8_t *dst = out->data[plane] + y * out->linesize[plane];
+            for (x = 0; x < w; x++)
+                dst[x] = av_clip_uint8(s->fft_hdata[plane][(y+oh) * n + x+ow].re * scale);
+        }
+    } else {
+        for (y = 0; y < h; y++) {
+            uint16_t *dst = (uint16_t *)(out->data[plane] + y * out->linesize[plane]);
+            for (x = 0; x < w; x++)
+                dst[x] = av_clip(s->fft_hdata[plane][(y+oh) * n + x+ow].re * scale, 0, max);
+        }
+    }
+}
+
+static int do_convolve(FFFrameSync *fs)
+{
+    AVFilterContext *ctx = fs->parent;
+    AVFilterLink *outlink = ctx->outputs[0];
+    ConvolveContext *s = ctx->priv;
+    AVFrame *mainpic = NULL, *impulsepic = NULL;
+    int ret, y, x, plane;
+
+    ret = ff_framesync_dualinput_get(fs, &mainpic, &impulsepic);
+    if (ret < 0)
+        return ret;
+    if (!impulsepic)
+        return ff_filter_frame(outlink, mainpic);
+
+    for (plane = 0; plane < s->nb_planes; plane++) {
+        const int n = s->fft_len[plane];
+        const int w = s->planewidth[plane];
+        const int h = s->planeheight[plane];
+        float total = 0;
+
+        if (!(s->planes & (1 << plane))) {
+            continue;
+        }
+
+        fft_horizontal(s, s->fft_hdata[plane], mainpic, w, h, n, plane, 1.f);
+        fft_vertical(s, s->fft_hdata[plane], s->fft_vdata[plane],
+                     n, plane);
+
+        if ((!s->impulse && !s->got_impulse[plane]) || s->impulse) {
+            if (s->depth == 8) {
+                for (y = 0; y < h; y++) {
+                    const uint8_t *src = (const uint8_t *)(impulsepic->data[plane] + y * impulsepic->linesize[plane]) ;
+                    for (x = 0; x < w; x++) {
+                        total += src[x];
+                    }
+                }
+            } else {
+                for (y = 0; y < h; y++) {
+                    const uint16_t *src = (const uint16_t *)(impulsepic->data[plane] + y * impulsepic->linesize[plane]) ;
+                    for (x = 0; x < w; x++) {
+                        total += src[x];
+                    }
+                }
+            }
+            total = FFMAX(1, total);
+
+            fft_horizontal(s, s->fft_hdata_impulse[plane], impulsepic, w, h, n, plane, 1 / total);
+            fft_vertical(s, s->fft_hdata_impulse[plane], s->fft_vdata_impulse[plane],
+                         n, plane);
+
+            s->got_impulse[plane] = 1;
+        }
+
+        for (y = 0; y < n; y++) {
+            for (x = 0; x < n; x++) {
+                FFTSample re, im, ire, iim;
+
+                re = s->fft_vdata[plane][y*n + x].re;
+                im = s->fft_vdata[plane][y*n + x].im;
+                ire = s->fft_vdata_impulse[plane][y*n + x].re;
+                iim = s->fft_vdata_impulse[plane][y*n + x].im;
+
+                s->fft_vdata[plane][y*n + x].re = ire * re - iim * im;
+                s->fft_vdata[plane][y*n + x].im = iim * re + ire * im;
+            }
+        }
+
+        ifft_vertical(s, n, plane);
+        ifft_horizontal(s, mainpic, w, h, n, plane);
+    }
+
+    return ff_filter_frame(outlink, mainpic);
+}
+
+static int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    ConvolveContext *s = ctx->priv;
+    AVFilterLink *mainlink = ctx->inputs[0];
+    int ret, i;
+
+    s->fs.on_event = do_convolve;
+    ret = ff_framesync_init_dualinput(&s->fs, ctx);
+    if (ret < 0)
+        return ret;
+    outlink->w = mainlink->w;
+    outlink->h = mainlink->h;
+    outlink->time_base = mainlink->time_base;
+    outlink->sample_aspect_ratio = mainlink->sample_aspect_ratio;
+    outlink->frame_rate = mainlink->frame_rate;
+
+    if ((ret = ff_framesync_configure(&s->fs)) < 0)
+        return ret;
+
+    for (i = 0; i < s->nb_planes; i++) {
+        s->fft[i]  = av_fft_init(s->fft_bits[i], 0);
+        s->ifft[i] = av_fft_init(s->fft_bits[i], 1);
+        if (!s->fft[i] || !s->ifft[i])
+            return AVERROR(ENOMEM);
+    }
+
+    return 0;
+}
+
+static int activate(AVFilterContext *ctx)
+{
+    ConvolveContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    ConvolveContext *s = ctx->priv;
+    int i;
+
+    for (i = 0; i < 4; i++) {
+        av_freep(&s->fft_hdata[i]);
+        av_freep(&s->fft_vdata[i]);
+        av_freep(&s->fft_hdata_impulse[i]);
+        av_freep(&s->fft_vdata_impulse[i]);
+        av_fft_end(s->fft[i]);
+        av_fft_end(s->ifft[i]);
+    }
+
+    ff_framesync_uninit(&s->fs);
+}
+
+static const AVFilterPad convolve_inputs[] = {
+    {
+        .name          = "main",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .config_props  = config_input_main,
+    },{
+        .name          = "impulse",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .config_props  = config_input_impulse,
+    },
+    { NULL }
+};
+
+static const AVFilterPad convolve_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .config_props  = config_output,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_convolve = {
+    .name          = "convolve",
+    .description   = NULL_IF_CONFIG_SMALL("Convolve first video stream with second video stream."),
+    .preinit       = convolve_framesync_preinit,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .activate      = activate,
+    .priv_size     = sizeof(ConvolveContext),
+    .priv_class    = &convolve_class,
+    .inputs        = convolve_inputs,
+    .outputs       = convolve_outputs,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_coreimage.m b/mythtv/external/FFmpeg/libavfilter/vf_coreimage.m
index 9c8db028582..323a28caa1d 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_coreimage.m
+++ b/mythtv/external/FFmpeg/libavfilter/vf_coreimage.m
@@ -23,7 +23,7 @@
  * Video processing based on Apple's CoreImage API
  */
 
-#import <QuartzCore/CoreImage.h>
+#import <CoreImage/CoreImage.h>
 #import <AppKit/AppKit.h>
 
 #include "avfilter.h"
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_crop.c b/mythtv/external/FFmpeg/libavfilter/vf_crop.c
index bcdbb8cd583..7c31c1665d9 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_crop.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_crop.c
@@ -255,11 +255,11 @@ static int filter_frame(AVFilterLink *link, AVFrame *frame)
     frame->width  = s->w;
     frame->height = s->h;
 
-    s->var_values[VAR_N] = link->frame_count;
+    s->var_values[VAR_N] = link->frame_count_out;
     s->var_values[VAR_T] = frame->pts == AV_NOPTS_VALUE ?
         NAN : frame->pts * av_q2d(link->time_base);
-    s->var_values[VAR_POS] = av_frame_get_pkt_pos(frame) == -1 ?
-        NAN : av_frame_get_pkt_pos(frame);
+    s->var_values[VAR_POS] = frame->pkt_pos == -1 ?
+        NAN : frame->pkt_pos;
     s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, NULL);
     s->var_values[VAR_Y] = av_expr_eval(s->y_pexpr, s->var_values, NULL);
     s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, NULL);
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_cropdetect.c b/mythtv/external/FFmpeg/libavfilter/vf_cropdetect.c
index 4a898755028..7c7d0b953ab 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_cropdetect.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_cropdetect.c
@@ -169,7 +169,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
 
     // ignore first 2 frames - they may be empty
     if (++s->frame_nb > 0) {
-        metadata = avpriv_frame_get_metadatap(frame);
+        metadata = &frame->metadata;
 
         // Reset the crop area every reset_count frames, if reset_count is > 0
         if (s->reset_count > 0 && s->frame_nb > s->reset_count) {
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_curves.c b/mythtv/external/FFmpeg/libavfilter/vf_curves.c
index 69ec1084bb3..19ab789152e 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_curves.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_curves.c
@@ -58,7 +58,7 @@ enum preset {
     NB_PRESETS,
 };
 
-typedef struct {
+typedef struct CurvesContext {
     const AVClass *class;
     int preset;
     char *comp_points_str[NB_COMP + 1];
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_datascope.c b/mythtv/external/FFmpeg/libavfilter/vf_datascope.c
index 01a5d992b08..467663556e0 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_datascope.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_datascope.c
@@ -76,7 +76,7 @@ static int query_formats(AVFilterContext *ctx)
     return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
 }
 
-static void draw_text(DatascopeContext *s, AVFrame *frame, FFDrawColor *color,
+static void draw_text(FFDrawContext *draw, AVFrame *frame, FFDrawColor *color,
                       int x0, int y0, const uint8_t *text, int vertical)
 {
     int x = x0;
@@ -87,7 +87,7 @@ static void draw_text(DatascopeContext *s, AVFrame *frame, FFDrawColor *color,
             y0 += 8;
             continue;
         }
-        ff_blend_mask(&s->draw, color, frame->data, frame->linesize,
+        ff_blend_mask(draw, color, frame->data, frame->linesize,
                       frame->width, frame->height,
                       avpriv_cga_font + *text * 8, 1, 8, 8, 0, 0, x, y0);
         if (vertical) {
@@ -201,7 +201,7 @@ static int filter_color2(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs
                 char text[256];
 
                 snprintf(text, sizeof(text), format[C>>2], value[p]);
-                draw_text(s, out, &reverse, xoff + x * C * 10 + 2, yoff + y * P * 12 + p * 10 + 2, text, 0);
+                draw_text(&s->draw, out, &reverse, xoff + x * C * 10 + 2, yoff + y * P * 12 + p * 10 + 2, text, 0);
             }
         }
     }
@@ -239,7 +239,7 @@ static int filter_color(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
                 char text[256];
 
                 snprintf(text, sizeof(text), format[C>>2], value[p]);
-                draw_text(s, out, &color, xoff + x * C * 10 + 2, yoff + y * P * 12 + p * 10 + 2, text, 0);
+                draw_text(&s->draw, out, &color, xoff + x * C * 10 + 2, yoff + y * P * 12 + p * 10 + 2, text, 0);
             }
         }
     }
@@ -276,7 +276,7 @@ static int filter_mono(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
                 char text[256];
 
                 snprintf(text, sizeof(text), format[C>>2], value[p]);
-                draw_text(s, out, &s->white, xoff + x * C * 10 + 2, yoff + y * P * 12 + p * 10 + 2, text, 0);
+                draw_text(&s->draw, out, &s->white, xoff + x * C * 10 + 2, yoff + y * P * 12 + p * 10 + 2, text, 0);
             }
         }
     }
@@ -328,7 +328,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
             ff_fill_rectangle(&s->draw, &s->gray, out->data, out->linesize,
                               0, xmaxlen + y * P * 12 + (P + 1) * P - 2, ymaxlen, 10);
 
-            draw_text(s, out, &s->yellow, 2, xmaxlen + y * P * 12 + (P + 1) * P, text, 0);
+            draw_text(&s->draw, out, &s->yellow, 2, xmaxlen + y * P * 12 + (P + 1) * P, text, 0);
         }
 
         for (x = 0; x < X; x++) {
@@ -337,7 +337,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
             ff_fill_rectangle(&s->draw, &s->gray, out->data, out->linesize,
                               ymaxlen + x * C * 10 + 2 * C - 2, 0, 10, xmaxlen);
 
-            draw_text(s, out, &s->yellow, ymaxlen + x * C * 10 + 2 * C, 2, text, 1);
+            draw_text(&s->draw, out, &s->yellow, ymaxlen + x * C * 10 + 2 * C, 2, text, 1);
         }
     }
 
@@ -419,3 +419,636 @@ AVFilter ff_vf_datascope = {
     .outputs       = outputs,
     .flags         = AVFILTER_FLAG_SLICE_THREADS,
 };
+
+typedef struct PixscopeContext {
+    const AVClass *class;
+
+    float xpos, ypos;
+    float wx, wy;
+    int w, h;
+    float o;
+
+    int x, y;
+    int ww, wh;
+
+    int nb_planes;
+    int nb_comps;
+    int is_rgb;
+    uint8_t rgba_map[4];
+    FFDrawContext draw;
+    FFDrawColor   dark;
+    FFDrawColor   black;
+    FFDrawColor   white;
+    FFDrawColor   green;
+    FFDrawColor   blue;
+    FFDrawColor   red;
+    FFDrawColor  *colors[4];
+
+    void (*pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value);
+} PixscopeContext;
+
+#define POFFSET(x) offsetof(PixscopeContext, x)
+
+static const AVOption pixscope_options[] = {
+    { "x",  "set scope x offset",  POFFSET(xpos), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0,  1, FLAGS },
+    { "y",  "set scope y offset",  POFFSET(ypos), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0,  1, FLAGS },
+    { "w",  "set scope width",     POFFSET(w),    AV_OPT_TYPE_INT,   {.i64=7},   1, 80, FLAGS },
+    { "h",  "set scope height",    POFFSET(h),    AV_OPT_TYPE_INT,   {.i64=7},   1, 80, FLAGS },
+    { "o",  "set window opacity",  POFFSET(o),    AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0,  1, FLAGS },
+    { "wx", "set window x offset", POFFSET(wx),   AV_OPT_TYPE_FLOAT, {.dbl=-1}, -1,  1, FLAGS },
+    { "wy", "set window y offset", POFFSET(wy),   AV_OPT_TYPE_FLOAT, {.dbl=-1}, -1,  1, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(pixscope);
+
+static int pixscope_config_input(AVFilterLink *inlink)
+{
+    PixscopeContext *s = inlink->dst->priv;
+
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+    ff_draw_init(&s->draw, inlink->format, 0);
+    ff_draw_color(&s->draw, &s->dark,  (uint8_t[]){ 0, 0, 0, s->o * 255} );
+    ff_draw_color(&s->draw, &s->black, (uint8_t[]){ 0, 0, 0, 255} );
+    ff_draw_color(&s->draw, &s->white, (uint8_t[]){ 255, 255, 255, 255} );
+    ff_draw_color(&s->draw, &s->green, (uint8_t[]){   0, 255,   0, 255} );
+    ff_draw_color(&s->draw, &s->blue,  (uint8_t[]){   0,   0, 255, 255} );
+    ff_draw_color(&s->draw, &s->red,   (uint8_t[]){ 255,   0,   0, 255} );
+    s->nb_comps = s->draw.desc->nb_components;
+    s->is_rgb   = s->draw.desc->flags & AV_PIX_FMT_FLAG_RGB;
+
+    if (s->is_rgb) {
+        s->colors[0] = &s->red;
+        s->colors[1] = &s->green;
+        s->colors[2] = &s->blue;
+        s->colors[3] = &s->white;
+        ff_fill_rgba_map(s->rgba_map, inlink->format);
+    } else {
+        s->colors[0] = &s->white;
+        s->colors[1] = &s->blue;
+        s->colors[2] = &s->red;
+        s->colors[3] = &s->white;
+        s->rgba_map[0] = 0;
+        s->rgba_map[1] = 1;
+        s->rgba_map[2] = 2;
+        s->rgba_map[3] = 3;
+    }
+
+    if (s->draw.desc->comp[0].depth <= 8) {
+        s->pick_color = pick_color8;
+    } else {
+        s->pick_color = pick_color16;
+    }
+
+    if (inlink->w < 640 || inlink->h < 480) {
+        av_log(inlink->dst, AV_LOG_ERROR, "min supported resolution is 640x480\n");
+        return AVERROR(EINVAL);
+    }
+
+    s->ww = 300;
+    s->wh = 300 * 1.6180;
+    s->x = s->xpos * (inlink->w - 1);
+    s->y = s->ypos * (inlink->h - 1);
+    if (s->x + s->w >= inlink->w || s->y + s->h >= inlink->h) {
+        av_log(inlink->dst, AV_LOG_WARNING, "scope position is out of range, clipping\n");
+        s->x = FFMIN(s->x, inlink->w - s->w);
+        s->y = FFMIN(s->y, inlink->h - s->h);
+    }
+
+    return 0;
+}
+
+static int pixscope_filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx  = inlink->dst;
+    PixscopeContext *s = ctx->priv;
+    AVFilterLink *outlink = ctx->outputs[0];
+    AVFrame *out = ff_get_video_buffer(outlink, in->width, in->height);
+    int max[4] = { 0 }, min[4] = { INT_MAX, INT_MAX, INT_MAX, INT_MAX };
+    float average[4] = { 0 };
+    double rms[4] = { 0 };
+    const char rgba[4] = { 'R', 'G', 'B', 'A' };
+    const char yuva[4] = { 'Y', 'U', 'V', 'A' };
+    int x, y, X, Y, i, w, h;
+    char text[128];
+
+    if (!out) {
+        av_frame_free(&in);
+        return AVERROR(ENOMEM);
+    }
+    av_frame_copy_props(out, in);
+    av_frame_copy(out, in);
+
+    w = s->ww / s->w;
+    h = s->ww / s->h;
+
+    if (s->wx >= 0) {
+        X = (in->width - s->ww) * s->wx;
+    } else {
+        X = (in->width - s->ww) * -s->wx;
+    }
+    if (s->wy >= 0) {
+        Y = (in->height - s->wh) * s->wy;
+    } else {
+        Y = (in->height - s->wh) * -s->wy;
+    }
+
+    if (s->wx < 0) {
+        if (s->x + s->w >= X && (s->x + s->w <= X + s->ww) &&
+            s->y + s->h >= Y && (s->y + s->h <= Y + s->wh)) {
+            X = (in->width - s->ww) * (1 + s->wx);
+        }
+    }
+
+    if (s->wy < 0) {
+        if (s->x + s->w >= X && (s->x + s->w <= X + s->ww) &&
+            s->y + s->h >= Y && (s->y + s->h <= Y + s->wh)) {
+            Y = (in->height - s->wh) * (1 + s->wy);
+        }
+    }
+
+    ff_blend_rectangle(&s->draw, &s->dark, out->data, out->linesize,
+                       out->width, out->height,
+                       X,
+                       Y,
+                       s->ww,
+                       s->wh);
+
+    for (y = 0; y < s->h; y++) {
+        for (x = 0; x < s->w; x++) {
+            FFDrawColor color = { { 0 } };
+            int value[4] = { 0 };
+
+            s->pick_color(&s->draw, &color, in, x + s->x, y + s->y, value);
+            ff_fill_rectangle(&s->draw, &color, out->data, out->linesize,
+                              x * w + (s->ww - 4 - (s->w * w)) / 2 + X, y * h + 2 + Y, w, h);
+            for (i = 0; i < 4; i++) {
+                rms[i]     += (double)value[i] * (double)value[i];
+                average[i] += value[i];
+                min[i]      = FFMIN(min[i], value[i]);
+                max[i]      = FFMAX(max[i], value[i]);
+            }
+        }
+    }
+
+    ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,
+                       out->width, out->height,
+                       s->x - 2, s->y - 2, s->w + 4, 1);
+
+    ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,
+                       out->width, out->height,
+                       s->x - 1, s->y - 1, s->w + 2, 1);
+
+    ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,
+                       out->width, out->height,
+                       s->x - 1, s->y - 1, 1, s->h + 2);
+
+    ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,
+                       out->width, out->height,
+                       s->x - 2, s->y - 2, 1, s->h + 4);
+
+    ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,
+                       out->width, out->height,
+                       s->x - 1, s->y + 1 + s->h, s->w + 3, 1);
+
+    ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,
+                       out->width, out->height,
+                       s->x - 2, s->y + 2 + s->h, s->w + 4, 1);
+
+    ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,
+                       out->width, out->height,
+                       s->x + 1 + s->w, s->y - 1, 1, s->h + 2);
+
+    ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,
+                       out->width, out->height,
+                       s->x + 2 + s->w, s->y - 2, 1, s->h + 5);
+
+    for (i = 0; i < 4; i++) {
+        rms[i] /= s->w * s->h;
+        rms[i]  = sqrt(rms[i]);
+        average[i] /= s->w * s->h;
+    }
+
+    snprintf(text, sizeof(text), "CH   AVG    MIN    MAX    RMS\n");
+    draw_text(&s->draw, out, &s->white,        X + 28, Y + s->ww + 20,           text, 0);
+    for (i = 0; i < s->nb_comps; i++) {
+        int c = s->rgba_map[i];
+
+        snprintf(text, sizeof(text), "%c  %07.1f %05d %05d %07.1f\n", s->is_rgb ? rgba[i] : yuva[i], average[c], min[c], max[c], rms[c]);
+        draw_text(&s->draw, out, s->colors[i], X + 28, Y + s->ww + 20 * (i + 2), text, 0);
+    }
+
+    av_frame_free(&in);
+    return ff_filter_frame(outlink, out);
+}
+
+static const AVFilterPad pixscope_inputs[] = {
+    {
+        .name           = "default",
+        .type           = AVMEDIA_TYPE_VIDEO,
+        .filter_frame   = pixscope_filter_frame,
+        .config_props   = pixscope_config_input,
+    },
+    { NULL }
+};
+
+static const AVFilterPad pixscope_outputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_pixscope = {
+    .name          = "pixscope",
+    .description   = NULL_IF_CONFIG_SMALL("Pixel data analysis."),
+    .priv_size     = sizeof(PixscopeContext),
+    .priv_class    = &pixscope_class,
+    .query_formats = query_formats,
+    .inputs        = pixscope_inputs,
+    .outputs       = pixscope_outputs,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
+};
+
+typedef struct PixelValues {
+    uint16_t p[4];
+} PixelValues;
+
+typedef struct OscilloscopeContext {
+    const AVClass *class;
+
+    float xpos, ypos;
+    float tx, ty;
+    float size;
+    float tilt;
+    float theight, twidth;
+    float o;
+    int components;
+    int grid;
+    int statistics;
+    int scope;
+
+    int x1, y1, x2, y2;
+    int ox, oy;
+    int height, width;
+
+    int max;
+    int nb_planes;
+    int nb_comps;
+    int is_rgb;
+    uint8_t rgba_map[4];
+    FFDrawContext draw;
+    FFDrawColor   dark;
+    FFDrawColor   black;
+    FFDrawColor   white;
+    FFDrawColor   green;
+    FFDrawColor   blue;
+    FFDrawColor   red;
+    FFDrawColor   cyan;
+    FFDrawColor   magenta;
+    FFDrawColor   gray;
+    FFDrawColor  *colors[4];
+
+    int nb_values;
+    PixelValues  *values;
+
+    void (*pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value);
+    void (*draw_trace)(struct OscilloscopeContext *s, AVFrame *frame);
+} OscilloscopeContext;
+
+#define OOFFSET(x) offsetof(OscilloscopeContext, x)
+
+static const AVOption oscilloscope_options[] = {
+    { "x",  "set scope x position",    OOFFSET(xpos),       AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1,  FLAGS },
+    { "y",  "set scope y position",    OOFFSET(ypos),       AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1,  FLAGS },
+    { "s",  "set scope size",          OOFFSET(size),       AV_OPT_TYPE_FLOAT, {.dbl=0.8}, 0, 1,  FLAGS },
+    { "t",  "set scope tilt",          OOFFSET(tilt),       AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1,  FLAGS },
+    { "o",  "set trace opacity",       OOFFSET(o),          AV_OPT_TYPE_FLOAT, {.dbl=0.8}, 0, 1,  FLAGS },
+    { "tx", "set trace x position",    OOFFSET(tx),         AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1,  FLAGS },
+    { "ty", "set trace y position",    OOFFSET(ty),         AV_OPT_TYPE_FLOAT, {.dbl=0.9}, 0, 1,  FLAGS },
+    { "tw", "set trace width",         OOFFSET(twidth),     AV_OPT_TYPE_FLOAT, {.dbl=0.8},.1, 1,  FLAGS },
+    { "th", "set trace height",        OOFFSET(theight),    AV_OPT_TYPE_FLOAT, {.dbl=0.3},.1, 1,  FLAGS },
+    { "c",  "set components to trace", OOFFSET(components), AV_OPT_TYPE_INT,   {.i64=7},   0, 15, FLAGS },
+    { "g",  "draw trace grid",         OOFFSET(grid),       AV_OPT_TYPE_BOOL,  {.i64=1},   0, 1,  FLAGS },
+    { "st", "draw statistics",         OOFFSET(statistics), AV_OPT_TYPE_BOOL,  {.i64=1},   0, 1,  FLAGS },
+    { "sc", "draw scope",              OOFFSET(scope),      AV_OPT_TYPE_BOOL,  {.i64=1},   0, 1,  FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(oscilloscope);
+
+static void oscilloscope_uninit(AVFilterContext *ctx)
+{
+    OscilloscopeContext *s = ctx->priv;
+
+    av_freep(&s->values);
+}
+
+static void draw_line(FFDrawContext *draw, int x0, int y0, int x1, int y1,
+                      AVFrame *out, FFDrawColor *color)
+{
+    int dx = FFABS(x1 - x0), sx = x0 < x1 ? 1 : -1;
+    int dy = FFABS(y1 - y0), sy = y0 < y1 ? 1 : -1;
+    int err = (dx > dy ? dx : -dy) / 2, e2;
+    int p, i;
+
+    for (;;) {
+        if (x0 >= 0 && y0 >= 0 && x0 < out->width && y0 < out->height) {
+            for (p = 0; p < draw->nb_planes; p++) {
+                if (draw->desc->comp[p].depth == 8) {
+                    if (draw->nb_planes == 1) {
+                        for (i = 0; i < 4; i++) {
+                            out->data[0][y0 * out->linesize[0] + x0 * draw->pixelstep[0] + i] = color->comp[0].u8[i];
+                        }
+                    } else {
+                        out->data[p][out->linesize[p] * (y0 >> draw->vsub[p]) + (x0 >> draw->hsub[p])] = color->comp[p].u8[0];
+                    }
+                } else {
+                    if (draw->nb_planes == 1) {
+                        for (i = 0; i < 4; i++) {
+                            AV_WN16(out->data[0] + y0 * out->linesize[0] + 2 * (x0 * draw->pixelstep[0] + i), color->comp[0].u16[i]);
+                        }
+                    } else {
+                        AV_WN16(out->data[p] + out->linesize[p] * (y0 >> draw->vsub[p]) + (x0 >> draw->hsub[p]) * 2, color->comp[p].u16[0]);
+                    }
+                }
+            }
+        }
+
+        if (x0 == x1 && y0 == y1)
+            break;
+
+        e2 = err;
+
+        if (e2 >-dx) {
+            err -= dy;
+            x0 += sx;
+        }
+
+        if (e2 < dy) {
+            err += dx;
+            y0 += sy;
+        }
+    }
+}
+
+static void draw_trace8(OscilloscopeContext *s, AVFrame *frame)
+{
+    int i, c;
+
+    for (i = 1; i < s->nb_values; i++) {
+        for (c = 0; c < s->nb_comps; c++) {
+            if ((1 << c) & s->components) {
+                int x = i * s->width / s->nb_values;
+                int px = (i - 1) * s->width / s->nb_values;
+                int py = s->height - s->values[i-1].p[c] * s->height / 256;
+                int y = s->height - s->values[i].p[c] * s->height / 256;
+
+                draw_line(&s->draw, s->ox + x, s->oy + y, s->ox + px, s->oy + py, frame, s->colors[c]);
+            }
+        }
+    }
+}
+
+
+static void draw_trace16(OscilloscopeContext *s, AVFrame *frame)
+{
+    int i, c;
+
+    for (i = 1; i < s->nb_values; i++) {
+        for (c = 0; c < s->nb_comps; c++) {
+            if ((1 << c) & s->components) {
+                int x = i * s->width / s->nb_values;
+                int px = (i - 1) * s->width / s->nb_values;
+                int py = s->height - s->values[i-1].p[c] * s->height / s->max;
+                int y = s->height - s->values[i].p[c] * s->height / s->max;
+
+                draw_line(&s->draw, s->ox + x, s->oy + y, s->ox + px, s->oy + py, frame, s->colors[c]);
+            }
+        }
+    }
+}
+
+static int oscilloscope_config_input(AVFilterLink *inlink)
+{
+    OscilloscopeContext *s = inlink->dst->priv;
+    int cx, cy, size;
+    double tilt;
+
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+    ff_draw_init(&s->draw, inlink->format, 0);
+    ff_draw_color(&s->draw, &s->dark,    (uint8_t[]){   0,   0,   0, s->o * 255} );
+    ff_draw_color(&s->draw, &s->black,   (uint8_t[]){   0,   0,   0, 255} );
+    ff_draw_color(&s->draw, &s->white,   (uint8_t[]){ 255, 255, 255, 255} );
+    ff_draw_color(&s->draw, &s->green,   (uint8_t[]){   0, 255,   0, 255} );
+    ff_draw_color(&s->draw, &s->blue,    (uint8_t[]){   0,   0, 255, 255} );
+    ff_draw_color(&s->draw, &s->red,     (uint8_t[]){ 255,   0,   0, 255} );
+    ff_draw_color(&s->draw, &s->cyan,    (uint8_t[]){   0, 255, 255, 255} );
+    ff_draw_color(&s->draw, &s->magenta, (uint8_t[]){ 255,   0, 255, 255} );
+    ff_draw_color(&s->draw, &s->gray,    (uint8_t[]){ 128, 128, 128, 255} );
+    s->nb_comps = s->draw.desc->nb_components;
+    s->is_rgb   = s->draw.desc->flags & AV_PIX_FMT_FLAG_RGB;
+
+    if (s->is_rgb) {
+        s->colors[0] = &s->red;
+        s->colors[1] = &s->green;
+        s->colors[2] = &s->blue;
+        s->colors[3] = &s->white;
+        ff_fill_rgba_map(s->rgba_map, inlink->format);
+    } else {
+        s->colors[0] = &s->white;
+        s->colors[1] = &s->cyan;
+        s->colors[2] = &s->magenta;
+        s->colors[3] = &s->white;
+        s->rgba_map[0] = 0;
+        s->rgba_map[1] = 1;
+        s->rgba_map[2] = 2;
+        s->rgba_map[3] = 3;
+    }
+
+    if (s->draw.desc->comp[0].depth <= 8) {
+        s->pick_color = pick_color8;
+        s->draw_trace = draw_trace8;
+    } else {
+        s->pick_color = pick_color16;
+        s->draw_trace = draw_trace16;
+    }
+
+    s->max = (1 << s->draw.desc->comp[0].depth);
+    cx = s->xpos * (inlink->w - 1);
+    cy = s->ypos * (inlink->h - 1);
+    s->height = s->theight * inlink->h;
+    s->width = s->twidth * inlink->w;
+    size = hypot(inlink->w, inlink->h);
+
+    s->values = av_calloc(size, sizeof(*s->values));
+    if (!s->values)
+        return AVERROR(ENOMEM);
+
+    size *= s->size;
+    tilt  = (s->tilt - 0.5) * M_PI;
+    s->x1 = cx - size / 2.0 * cos(tilt);
+    s->x2 = cx + size / 2.0 * cos(tilt);
+    s->y1 = cy - size / 2.0 * sin(tilt);
+    s->y2 = cy + size / 2.0 * sin(tilt);
+    s->ox = (inlink->w - s->width) * s->tx;
+    s->oy = (inlink->h - s->height) * s->ty;
+
+    return 0;
+}
+
+static void draw_scope(OscilloscopeContext *s, int x0, int y0, int x1, int y1,
+                       AVFrame *out, PixelValues *p, int state)
+{
+    int dx = FFABS(x1 - x0), sx = x0 < x1 ? 1 : -1;
+    int dy = FFABS(y1 - y0), sy = y0 < y1 ? 1 : -1;
+    int err = (dx > dy ? dx : -dy) / 2, e2;
+
+    for (;;) {
+        if (x0 >= 0 && y0 >= 0 && x0 < out->width && y0 < out->height) {
+            FFDrawColor color = { { 0 } };
+            int value[4] = { 0 };
+
+            s->pick_color(&s->draw, &color, out, x0, y0, value);
+            s->values[s->nb_values].p[0] = value[0];
+            s->values[s->nb_values].p[1] = value[1];
+            s->values[s->nb_values].p[2] = value[2];
+            s->values[s->nb_values].p[3] = value[3];
+            s->nb_values++;
+
+            if (s->scope) {
+                if (s->draw.desc->comp[0].depth == 8) {
+                    if (s->draw.nb_planes == 1) {
+                        int i;
+
+                        for (i = 0; i < s->draw.pixelstep[0]; i++)
+                            out->data[0][out->linesize[0] * y0 + x0 * s->draw.pixelstep[0] + i] = 255 * ((s->nb_values + state) & 1);
+                    } else {
+                        out->data[0][out->linesize[0] * y0 + x0] = 255 * ((s->nb_values + state) & 1);
+                    }
+                } else {
+                    if (s->draw.nb_planes == 1) {
+                        int i;
+
+                        for (i = 0; i < s->draw.pixelstep[0]; i++)
+                            AV_WN16(out->data[0] + out->linesize[0] * y0 + 2 * x0 * (s->draw.pixelstep[0] + i), (s->max - 1) * ((s->nb_values + state) & 1));
+                    } else {
+                        AV_WN16(out->data[0] + out->linesize[0] * y0 + 2 * x0, (s->max - 1) * ((s->nb_values + state) & 1));
+                    }
+                }
+            }
+        }
+
+        if (x0 == x1 && y0 == y1)
+            break;
+
+        e2 = err;
+
+        if (e2 >-dx) {
+            err -= dy;
+            x0 += sx;
+        }
+
+        if (e2 < dy) {
+            err += dx;
+            y0 += sy;
+        }
+    }
+}
+
+static int oscilloscope_filter_frame(AVFilterLink *inlink, AVFrame *frame)
+{
+    AVFilterContext *ctx  = inlink->dst;
+    OscilloscopeContext *s = ctx->priv;
+    AVFilterLink *outlink = ctx->outputs[0];
+    float average[4] = { 0 };
+    int max[4] = { 0 };
+    int min[4] = { INT_MAX, INT_MAX, INT_MAX, INT_MAX };
+    int i, c;
+
+    s->nb_values = 0;
+    draw_scope(s, s->x1, s->y1, s->x2, s->y2, frame, s->values, inlink->frame_count_in & 1);
+    ff_blend_rectangle(&s->draw, &s->dark, frame->data, frame->linesize,
+                       frame->width, frame->height,
+                       s->ox, s->oy, s->width, s->height + 20 * s->statistics);
+
+    if (s->grid) {
+        ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,
+                          s->ox, s->oy, s->width - 1, 1);
+
+        for (i = 1; i < 5; i++) {
+            ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,
+                              s->ox, s->oy + i * (s->height - 1) / 4, s->width, 1);
+        }
+
+        for (i = 0; i < 10; i++) {
+            ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,
+                              s->ox + i * (s->width - 1) / 10, s->oy, 1, s->height);
+        }
+
+        ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,
+                          s->ox + s->width - 1, s->oy, 1, s->height);
+    }
+
+    s->draw_trace(s, frame);
+
+    for (i = 0; i < s->nb_values; i++) {
+        for (c = 0; c < s->nb_comps; c++) {
+            if ((1 << c) & s->components) {
+                max[c] = FFMAX(max[c], s->values[i].p[c]);
+                min[c] = FFMIN(min[c], s->values[i].p[c]);
+                average[c] += s->values[i].p[c];
+            }
+        }
+    }
+    for (c = 0; c < s->nb_comps; c++) {
+        average[c] /= s->nb_values;
+    }
+
+    if (s->statistics && s->height > 10 && s->width > 280 * av_popcount(s->components)) {
+        for (c = 0, i = 0; c < s->nb_comps; c++) {
+            if ((1 << c) & s->components) {
+                const char rgba[4] = { 'R', 'G', 'B', 'A' };
+                const char yuva[4] = { 'Y', 'U', 'V', 'A' };
+                char text[128];
+
+                snprintf(text, sizeof(text), "%c avg:%.1f min:%d max:%d\n", s->is_rgb ? rgba[c] : yuva[c], average[s->rgba_map[c]], min[s->rgba_map[c]], max[s->rgba_map[c]]);
+                draw_text(&s->draw, frame, &s->white, s->ox +  2 + 280 * i++, s->oy + s->height + 4, text, 0);
+            }
+        }
+    }
+
+    return ff_filter_frame(outlink, frame);
+}
+
+static const AVFilterPad oscilloscope_inputs[] = {
+    {
+        .name           = "default",
+        .type           = AVMEDIA_TYPE_VIDEO,
+        .filter_frame   = oscilloscope_filter_frame,
+        .config_props   = oscilloscope_config_input,
+        .needs_writable = 1,
+    },
+    { NULL }
+};
+
+static const AVFilterPad oscilloscope_outputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_oscilloscope = {
+    .name          = "oscilloscope",
+    .description   = NULL_IF_CONFIG_SMALL("2D Video Oscilloscope."),
+    .priv_size     = sizeof(OscilloscopeContext),
+    .priv_class    = &oscilloscope_class,
+    .query_formats = query_formats,
+    .uninit        = oscilloscope_uninit,
+    .inputs        = oscilloscope_inputs,
+    .outputs       = oscilloscope_outputs,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_dctdnoiz.c b/mythtv/external/FFmpeg/libavfilter/vf_dctdnoiz.c
index 62763bf3490..cdbe5f853fb 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_dctdnoiz.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_dctdnoiz.c
@@ -63,9 +63,9 @@ typedef struct DCTdnoizContext {
                              float *dst, int dst_linesize,
                              int thread_id);
     void (*color_decorrelation)(float **dst, int dst_linesize,
-                                const uint8_t *src, int src_linesize,
+                                const uint8_t **src, int src_linesize,
                                 int w, int h);
-    void (*color_correlation)(uint8_t *dst, int dst_linesize,
+    void (*color_correlation)(uint8_t **dst, int dst_linesize,
                               float **src, int src_linesize,
                               int w, int h);
 } DCTdnoizContext;
@@ -408,7 +408,7 @@ DEF_FILTER_FREQ_FUNCS(16)
 #define DCT3X3_2_2  0.4082482904638631f /*  1/sqrt(6) */
 
 static av_always_inline void color_decorrelation(float **dst, int dst_linesize,
-                                                 const uint8_t *src, int src_linesize,
+                                                 const uint8_t **src, int src_linesize,
                                                  int w, int h,
                                                  int r, int g, int b)
 {
@@ -416,24 +416,23 @@ static av_always_inline void color_decorrelation(float **dst, int dst_linesize,
     float *dstp_r = dst[0];
     float *dstp_g = dst[1];
     float *dstp_b = dst[2];
+    const uint8_t *srcp = src[0];
 
     for (y = 0; y < h; y++) {
-        const uint8_t *srcp = src;
-
         for (x = 0; x < w; x++) {
             dstp_r[x] = srcp[r] * DCT3X3_0_0 + srcp[g] * DCT3X3_0_1 + srcp[b] * DCT3X3_0_2;
             dstp_g[x] = srcp[r] * DCT3X3_1_0 +                        srcp[b] * DCT3X3_1_2;
             dstp_b[x] = srcp[r] * DCT3X3_2_0 + srcp[g] * DCT3X3_2_1 + srcp[b] * DCT3X3_2_2;
             srcp += 3;
         }
-        src += src_linesize;
+        srcp   += src_linesize - w * 3;
         dstp_r += dst_linesize;
         dstp_g += dst_linesize;
         dstp_b += dst_linesize;
     }
 }
 
-static av_always_inline void color_correlation(uint8_t *dst, int dst_linesize,
+static av_always_inline void color_correlation(uint8_t **dst, int dst_linesize,
                                                float **src, int src_linesize,
                                                int w, int h,
                                                int r, int g, int b)
@@ -442,17 +441,16 @@ static av_always_inline void color_correlation(uint8_t *dst, int dst_linesize,
     const float *src_r = src[0];
     const float *src_g = src[1];
     const float *src_b = src[2];
+    uint8_t *dstp = dst[0];
 
     for (y = 0; y < h; y++) {
-        uint8_t *dstp = dst;
-
         for (x = 0; x < w; x++) {
             dstp[r] = av_clip_uint8(src_r[x] * DCT3X3_0_0 + src_g[x] * DCT3X3_1_0 + src_b[x] * DCT3X3_2_0);
             dstp[g] = av_clip_uint8(src_r[x] * DCT3X3_0_1 +                         src_b[x] * DCT3X3_2_1);
             dstp[b] = av_clip_uint8(src_r[x] * DCT3X3_0_2 + src_g[x] * DCT3X3_1_2 + src_b[x] * DCT3X3_2_2);
             dstp += 3;
         }
-        dst += dst_linesize;
+        dstp  += dst_linesize - w * 3;
         src_r += src_linesize;
         src_g += src_linesize;
         src_b += src_linesize;
@@ -461,13 +459,13 @@ static av_always_inline void color_correlation(uint8_t *dst, int dst_linesize,
 
 #define DECLARE_COLOR_FUNCS(name, r, g, b)                                          \
 static void color_decorrelation_##name(float **dst, int dst_linesize,               \
-                                       const uint8_t *src, int src_linesize,        \
+                                       const uint8_t **src, int src_linesize,       \
                                        int w, int h)                                \
 {                                                                                   \
     color_decorrelation(dst, dst_linesize, src, src_linesize, w, h, r, g, b);       \
 }                                                                                   \
                                                                                     \
-static void color_correlation_##name(uint8_t *dst, int dst_linesize,                \
+static void color_correlation_##name(uint8_t **dst, int dst_linesize,               \
                                      float **src, int src_linesize,                 \
                                      int w, int h)                                  \
 {                                                                                   \
@@ -477,6 +475,60 @@ static void color_correlation_##name(uint8_t *dst, int dst_linesize,
 DECLARE_COLOR_FUNCS(rgb, 0, 1, 2)
 DECLARE_COLOR_FUNCS(bgr, 2, 1, 0)
 
+static av_always_inline void color_decorrelation_gbrp(float **dst, int dst_linesize,
+                                                      const uint8_t **src, int src_linesize,
+                                                      int w, int h)
+{
+    int x, y;
+    float *dstp_r = dst[0];
+    float *dstp_g = dst[1];
+    float *dstp_b = dst[2];
+    const uint8_t *srcp_r = src[2];
+    const uint8_t *srcp_g = src[0];
+    const uint8_t *srcp_b = src[1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dstp_r[x] = srcp_r[x] * DCT3X3_0_0 + srcp_g[x] * DCT3X3_0_1 + srcp_b[x] * DCT3X3_0_2;
+            dstp_g[x] = srcp_r[x] * DCT3X3_1_0 +                          srcp_b[x] * DCT3X3_1_2;
+            dstp_b[x] = srcp_r[x] * DCT3X3_2_0 + srcp_g[x] * DCT3X3_2_1 + srcp_b[x] * DCT3X3_2_2;
+        }
+        srcp_r += src_linesize;
+        srcp_g += src_linesize;
+        srcp_b += src_linesize;
+        dstp_r += dst_linesize;
+        dstp_g += dst_linesize;
+        dstp_b += dst_linesize;
+    }
+}
+
+static av_always_inline void color_correlation_gbrp(uint8_t **dst, int dst_linesize,
+                                                    float **src, int src_linesize,
+                                                    int w, int h)
+{
+    int x, y;
+    const float *src_r = src[0];
+    const float *src_g = src[1];
+    const float *src_b = src[2];
+    uint8_t *dstp_r = dst[2];
+    uint8_t *dstp_g = dst[0];
+    uint8_t *dstp_b = dst[1];
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dstp_r[x] = av_clip_uint8(src_r[x] * DCT3X3_0_0 + src_g[x] * DCT3X3_1_0 + src_b[x] * DCT3X3_2_0);
+            dstp_g[x] = av_clip_uint8(src_r[x] * DCT3X3_0_1 +                         src_b[x] * DCT3X3_2_1);
+            dstp_b[x] = av_clip_uint8(src_r[x] * DCT3X3_0_2 + src_g[x] * DCT3X3_1_2 + src_b[x] * DCT3X3_2_2);
+        }
+        dstp_r += dst_linesize;
+        dstp_g += dst_linesize;
+        dstp_b += dst_linesize;
+        src_r += src_linesize;
+        src_g += src_linesize;
+        src_b += src_linesize;
+    }
+}
+
 static int config_input(AVFilterLink *inlink)
 {
     AVFilterContext *ctx = inlink->dst;
@@ -493,6 +545,10 @@ static int config_input(AVFilterLink *inlink)
         s->color_decorrelation = color_decorrelation_rgb;
         s->color_correlation   = color_correlation_rgb;
         break;
+    case AV_PIX_FMT_GBRP:
+        s->color_decorrelation = color_decorrelation_gbrp;
+        s->color_correlation   = color_correlation_gbrp;
+        break;
     default:
         av_assert0(0);
     }
@@ -598,6 +654,7 @@ static int query_formats(AVFilterContext *ctx)
 {
     static const enum AVPixelFormat pix_fmts[] = {
         AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24,
+        AV_PIX_FMT_GBRP,
         AV_PIX_FMT_NONE
     };
     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
@@ -680,7 +737,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     }
 
     s->color_decorrelation(s->cbuf[0], s->p_linesize,
-                           in->data[0], in->linesize[0],
+                           (const uint8_t **)in->data, in->linesize[0],
                            s->pr_width, s->pr_height);
     for (plane = 0; plane < 3; plane++) {
         ThreadData td = {
@@ -689,7 +746,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         };
         ctx->internal->execute(ctx, filter_slice, &td, NULL, s->nb_threads);
     }
-    s->color_correlation(out->data[0], out->linesize[0],
+    s->color_correlation(out->data, out->linesize[0],
                          s->cbuf[1], s->p_linesize,
                          s->pr_width, s->pr_height);
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_deband.c b/mythtv/external/FFmpeg/libavfilter/vf_deband.c
index 3a1cfb8fbf3..713e80b0493 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_deband.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_deband.c
@@ -30,6 +30,7 @@
 typedef struct DebandContext {
     const AVClass *class;
 
+    int coupling;
     float threshold[4];
     int range;
     int blur;
@@ -38,6 +39,7 @@ typedef struct DebandContext {
     int nb_components;
     int planewidth[4];
     int planeheight[4];
+    int shift[2];
     int thr[4];
 
     int *x_pos;
@@ -59,6 +61,9 @@ static const AVOption deband_options[] = {
     { "direction", "set direction",           OFFSET(direction),    AV_OPT_TYPE_FLOAT, {.dbl=2*M_PI},-2*M_PI,  2*M_PI, FLAGS },
     { "d",         "set direction",           OFFSET(direction),    AV_OPT_TYPE_FLOAT, {.dbl=2*M_PI},-2*M_PI,  2*M_PI, FLAGS },
     { "blur",      "set blur",                OFFSET(blur),         AV_OPT_TYPE_BOOL,  {.i64=1},           0,       1, FLAGS },
+    { "b",         "set blur",                OFFSET(blur),         AV_OPT_TYPE_BOOL,  {.i64=1},           0,       1, FLAGS },
+    { "coupling",  "set plane coupling",      OFFSET(coupling),     AV_OPT_TYPE_BOOL,  {.i64=0},           0,       1, FLAGS },
+    { "c",         "set plane coupling",      OFFSET(coupling),     AV_OPT_TYPE_BOOL,  {.i64=0},           0,       1, FLAGS },
     { NULL }
 };
 
@@ -66,6 +71,8 @@ AVFILTER_DEFINE_CLASS(deband);
 
 static int query_formats(AVFilterContext *ctx)
 {
+    DebandContext *s = ctx->priv;
+
     static const enum AVPixelFormat pix_fmts[] = {
         AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
@@ -86,7 +93,21 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
         AV_PIX_FMT_NONE
     };
-    AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
+
+    static const enum AVPixelFormat cpix_fmts[] = {
+        AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+        AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P9,
+        AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10,
+        AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,
+        AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUVA444P16,
+        AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
+        AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
+        AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
+        AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_NONE
+    };
+
+    AVFilterFormats *fmts_list = ff_make_format_list(s->coupling ? cpix_fmts : pix_fmts);
     if (!fmts_list)
         return AVERROR(ENOMEM);
 
@@ -129,7 +150,7 @@ static int deband_8_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
         const int h = s->planeheight[p] - 1;
 
         for (y = start; y < end; y++) {
-            const int pos = y * s->planeheight[0];
+            const int pos = y * s->planewidth[0];
 
             for (x = 0; x < s->planewidth[p]; x++) {
                 const int x_pos = s->x_pos[pos + x];
@@ -158,6 +179,138 @@ static int deband_8_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
     return 0;
 }
 
+static int deband_8_coupling_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+    DebandContext *s = ctx->priv;
+    ThreadData *td = arg;
+    AVFrame *in = td->in;
+    AVFrame *out = td->out;
+    const int start = (s->planeheight[0] *  jobnr   ) / nb_jobs;
+    const int end   = (s->planeheight[0] * (jobnr+1)) / nb_jobs;
+    int x, y, p;
+
+    for (y = start; y < end; y++) {
+        const int pos = y * s->planewidth[0];
+
+        for (x = 0; x < s->planewidth[0]; x++) {
+            const int x_pos = s->x_pos[pos + x];
+            const int y_pos = s->y_pos[pos + x];
+            int avg[4], cmp[4] = { 0 }, src[4];
+
+            for (p = 0; p < s->nb_components; p++) {
+                const uint8_t *src_ptr = (const uint8_t *)in->data[p];
+                const int src_linesize = in->linesize[p];
+                const int thr = s->thr[p];
+                const int w = s->planewidth[p] - 1;
+                const int h = s->planeheight[p] - 1;
+                const int ref0 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];
+                const int ref1 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];
+                const int ref2 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];
+                const int ref3 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];
+                const int src0 = src_ptr[y * src_linesize + x];
+
+                src[p] = src0;
+                avg[p] = get_avg(ref0, ref1, ref2, ref3);
+
+                if (s->blur) {
+                    cmp[p] = FFABS(src0 - avg[p]) < thr;
+                } else {
+                    cmp[p] = (FFABS(src0 - ref0) < thr) &&
+                             (FFABS(src0 - ref1) < thr) &&
+                             (FFABS(src0 - ref2) < thr) &&
+                             (FFABS(src0 - ref3) < thr);
+                }
+            }
+
+            for (p = 0; p < s->nb_components; p++)
+                if (!cmp[p])
+                    break;
+            if (p == s->nb_components) {
+                for (p = 0; p < s->nb_components; p++) {
+                    const int dst_linesize = out->linesize[p];
+
+                    out->data[p][y * dst_linesize + x] = avg[p];
+                }
+            } else {
+                for (p = 0; p < s->nb_components; p++) {
+                    const int dst_linesize = out->linesize[p];
+
+                    out->data[p][y * dst_linesize + x] = src[p];
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int deband_16_coupling_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+    DebandContext *s = ctx->priv;
+    ThreadData *td = arg;
+    AVFrame *in = td->in;
+    AVFrame *out = td->out;
+    const int start = (s->planeheight[0] *  jobnr   ) / nb_jobs;
+    const int end   = (s->planeheight[0] * (jobnr+1)) / nb_jobs;
+    int x, y, p, z;
+
+    for (y = start; y < end; y++) {
+        const int pos = y * s->planewidth[0];
+
+        for (x = 0; x < s->planewidth[0]; x++) {
+            const int x_pos = s->x_pos[pos + x];
+            const int y_pos = s->y_pos[pos + x];
+            int avg[4], cmp[4] = { 0 }, src[4];
+
+            for (p = 0; p < s->nb_components; p++) {
+                const uint16_t *src_ptr = (const uint16_t *)in->data[p];
+                const int src_linesize = in->linesize[p] / 2;
+                const int thr = s->thr[p];
+                const int w = s->planewidth[p] - 1;
+                const int h = s->planeheight[p] - 1;
+                const int ref0 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];
+                const int ref1 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x +  x_pos, 0, w)];
+                const int ref2 = src_ptr[av_clip(y + -y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];
+                const int ref3 = src_ptr[av_clip(y +  y_pos, 0, h) * src_linesize + av_clip(x + -x_pos, 0, w)];
+                const int src0 = src_ptr[y * src_linesize + x];
+
+                src[p] = src0;
+                avg[p] = get_avg(ref0, ref1, ref2, ref3);
+
+                if (s->blur) {
+                    cmp[p] = FFABS(src0 - avg[p]) < thr;
+                } else {
+                    cmp[p] = (FFABS(src0 - ref0) < thr) &&
+                             (FFABS(src0 - ref1) < thr) &&
+                             (FFABS(src0 - ref2) < thr) &&
+                             (FFABS(src0 - ref3) < thr);
+                }
+            }
+
+            for (z = 0; z < s->nb_components; z++)
+                if (!cmp[z])
+                    break;
+            if (z == s->nb_components) {
+                for (p = 0; p < s->nb_components; p++) {
+                    const int dst_linesize = out->linesize[p] / 2;
+                    uint16_t *dst = (uint16_t *)out->data[p] + y * dst_linesize + x;
+
+                    dst[0] = avg[p];
+                }
+            } else {
+                for (p = 0; p < s->nb_components; p++) {
+                    const int dst_linesize = out->linesize[p] / 2;
+                    uint16_t *dst = (uint16_t *)out->data[p] + y * dst_linesize + x;
+
+                    dst[0] = src[p];
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
 static int deband_16_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
 {
     DebandContext *s = ctx->priv;
@@ -178,7 +331,7 @@ static int deband_16_c(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
         const int h = s->planeheight[p] - 1;
 
         for (y = start; y < end; y++) {
-            const int pos = y * s->planeheight[0];
+            const int pos = y * s->planewidth[0];
 
             for (x = 0; x < s->planewidth[p]; x++) {
                 const int x_pos = s->x_pos[pos + x];
@@ -222,8 +375,13 @@ static int config_input(AVFilterLink *inlink)
     s->planeheight[0] = s->planeheight[3] = inlink->h;
     s->planewidth[1]  = s->planewidth[2]  = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
     s->planewidth[0]  = s->planewidth[3]  = inlink->w;
+    s->shift[0] = desc->log2_chroma_w;
+    s->shift[1] = desc->log2_chroma_h;
 
-    s->deband = desc->comp[0].depth > 8 ? deband_16_c : deband_8_c;
+    if (s->coupling)
+        s->deband = desc->comp[0].depth > 8 ? deband_16_coupling_c : deband_8_coupling_c;
+    else
+        s->deband = desc->comp[0].depth > 8 ? deband_16_c : deband_8_c;
 
     s->thr[0] = ((1 << desc->comp[0].depth) - 1) * s->threshold[0];
     s->thr[1] = ((1 << desc->comp[1].depth) - 1) * s->threshold[1];
@@ -241,8 +399,8 @@ static int config_input(AVFilterLink *inlink)
             const float dir = direction < 0 ? -direction : r * direction;
             const int dist = range < 0 ? -range : r * range;
 
-            s->x_pos[y * s->planeheight[0] + x] = cosf(dir) * dist;
-            s->y_pos[y * s->planeheight[0] + x] = sinf(dir) * dist;
+            s->x_pos[y * s->planewidth[0] + x] = cosf(dir) * dist;
+            s->y_pos[y * s->planewidth[0] + x] = sinf(dir) * dist;
         }
     }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_decimate.c b/mythtv/external/FFmpeg/libavfilter/vf_decimate.c
index 39c33314259..53347c7f109 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_decimate.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_decimate.c
@@ -34,7 +34,7 @@ struct qitem {
     int64_t totdiff;
 };
 
-typedef struct {
+typedef struct DecimateContext {
     const AVClass *class;
     struct qitem *queue;    ///< window of cycle frames and the associated data diff
     int fid;                ///< current frame id in the queue
@@ -223,7 +223,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
                 av_frame_free(&frame);
                 frame = dm->clean_src[i];
             }
-            frame->pts = av_rescale_q(outlink->frame_count, dm->ts_unit, (AVRational){1,1}) +
+            frame->pts = av_rescale_q(outlink->frame_count_in, dm->ts_unit, (AVRational){1,1}) +
                          (dm->start_pts == AV_NOPTS_VALUE ? 0 : dm->start_pts);
             ret = ff_filter_frame(outlink, frame);
             if (ret < 0)
@@ -276,17 +276,24 @@ static av_cold int decimate_init(AVFilterContext *ctx)
         .filter_frame = filter_frame,
         .config_props = config_input,
     };
+    int ret;
 
     if (!pad.name)
         return AVERROR(ENOMEM);
-    ff_insert_inpad(ctx, INPUT_MAIN, &pad);
+    if ((ret = ff_insert_inpad(ctx, INPUT_MAIN, &pad)) < 0) {
+        av_freep(&pad.name);
+        return ret;
+    }
 
     if (dm->ppsrc) {
         pad.name = av_strdup("clean_src");
         pad.config_props = NULL;
         if (!pad.name)
             return AVERROR(ENOMEM);
-        ff_insert_inpad(ctx, INPUT_CLEANSRC, &pad);
+        if ((ret = ff_insert_inpad(ctx, INPUT_CLEANSRC, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
     }
 
     if ((dm->blockx & (dm->blockx - 1)) ||
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_deflicker.c b/mythtv/external/FFmpeg/libavfilter/vf_deflicker.c
new file mode 100644
index 00000000000..863a3508c1e
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_deflicker.c
@@ -0,0 +1,471 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/imgutils.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/qsort.h"
+#include "avfilter.h"
+
+#define FF_BUFQUEUE_SIZE 129
+#include "bufferqueue.h"
+
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+#define SIZE FF_BUFQUEUE_SIZE
+
+enum smooth_mode {
+    ARITHMETIC_MEAN,
+    GEOMETRIC_MEAN,
+    HARMONIC_MEAN,
+    QUADRATIC_MEAN,
+    CUBIC_MEAN,
+    POWER_MEAN,
+    MEDIAN,
+    NB_SMOOTH_MODE,
+};
+
+typedef struct DeflickerContext {
+    const AVClass *class;
+
+    int size;
+    int mode;
+    int bypass;
+
+    int eof;
+    int depth;
+    int nb_planes;
+    int planewidth[4];
+    int planeheight[4];
+
+    uint64_t *histogram;
+    float luminance[SIZE];
+    float sorted[SIZE];
+
+    struct FFBufQueue q;
+    int available;
+
+    void (*get_factor)(AVFilterContext *ctx, float *f);
+    float (*calc_avgy)(AVFilterContext *ctx, AVFrame *in);
+    int (*deflicker)(AVFilterContext *ctx, const uint8_t *src, ptrdiff_t src_linesize,
+                     uint8_t *dst, ptrdiff_t dst_linesize, int w, int h, float f);
+} DeflickerContext;
+
+#define OFFSET(x) offsetof(DeflickerContext, x)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+
+static const AVOption deflicker_options[] = {
+    { "size",  "set how many frames to use",  OFFSET(size), AV_OPT_TYPE_INT, {.i64=5}, 2, SIZE, FLAGS },
+    { "s",     "set how many frames to use",  OFFSET(size), AV_OPT_TYPE_INT, {.i64=5}, 2, SIZE, FLAGS },
+    { "mode",  "set how to smooth luminance", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_SMOOTH_MODE-1, FLAGS, "mode" },
+    { "m",     "set how to smooth luminance", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, NB_SMOOTH_MODE-1, FLAGS, "mode" },
+        { "am",      "arithmetic mean", 0, AV_OPT_TYPE_CONST, {.i64=ARITHMETIC_MEAN},  0, 0, FLAGS, "mode" },
+        { "gm",      "geometric mean",  0, AV_OPT_TYPE_CONST, {.i64=GEOMETRIC_MEAN},   0, 0, FLAGS, "mode" },
+        { "hm",      "harmonic mean",   0, AV_OPT_TYPE_CONST, {.i64=HARMONIC_MEAN},    0, 0, FLAGS, "mode" },
+        { "qm",      "quadratic mean",  0, AV_OPT_TYPE_CONST, {.i64=QUADRATIC_MEAN},   0, 0, FLAGS, "mode" },
+        { "cm",      "cubic mean",      0, AV_OPT_TYPE_CONST, {.i64=CUBIC_MEAN},       0, 0, FLAGS, "mode" },
+        { "pm",      "power mean",      0, AV_OPT_TYPE_CONST, {.i64=POWER_MEAN},       0, 0, FLAGS, "mode" },
+        { "median",  "median",          0, AV_OPT_TYPE_CONST, {.i64=MEDIAN},           0, 0, FLAGS, "mode" },
+    { "bypass", "leave frames unchanged",  OFFSET(bypass), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(deflicker);
+
+static int query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pixel_fmts[] = {
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10,
+        AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
+        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
+        AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
+        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
+        AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
+        AV_PIX_FMT_YUVJ411P,
+        AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
+        AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
+        AV_PIX_FMT_YUV440P10,
+        AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12,
+        AV_PIX_FMT_YUV440P12,
+        AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,
+        AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
+        AV_PIX_FMT_NONE
+    };
+    AVFilterFormats *formats = ff_make_format_list(pixel_fmts);
+    if (!formats)
+        return AVERROR(ENOMEM);
+    return ff_set_common_formats(ctx, formats);
+}
+
+static int deflicker8(AVFilterContext *ctx,
+                      const uint8_t *src, ptrdiff_t src_linesize,
+                      uint8_t *dst, ptrdiff_t dst_linesize,
+                      int w, int h, float f)
+{
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dst[x] = av_clip_uint8(src[x] * f);
+        }
+
+        dst += dst_linesize;
+        src += src_linesize;
+    }
+
+    return 0;
+}
+
+static int deflicker16(AVFilterContext *ctx,
+                       const uint8_t *ssrc, ptrdiff_t src_linesize,
+                       uint8_t *ddst, ptrdiff_t dst_linesize,
+                       int w, int h, float f)
+{
+    DeflickerContext *s = ctx->priv;
+    const uint16_t *src = (const uint16_t *)ssrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    const int max = (1 << s->depth) - 1;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dst[x] = av_clip(src[x] * f, 0, max);
+        }
+
+        dst += dst_linesize / 2;
+        src += src_linesize / 2;
+    }
+
+    return 0;
+}
+
+static float calc_avgy8(AVFilterContext *ctx, AVFrame *in)
+{
+    DeflickerContext *s = ctx->priv;
+    const uint8_t *src = in->data[0];
+    int64_t sum = 0;
+    int y, x;
+
+    memset(s->histogram, 0, (1 << s->depth) * sizeof(*s->histogram));
+
+    for (y = 0; y < s->planeheight[0]; y++) {
+        for (x = 0; x < s->planewidth[0]; x++) {
+            s->histogram[src[x]]++;
+        }
+        src += in->linesize[0];
+    }
+
+    for (y = 0; y < 1 << s->depth; y++) {
+        sum += s->histogram[y] * y;
+    }
+
+    return 1.0f * sum / (s->planeheight[0] * s->planewidth[0]);
+}
+
+static float calc_avgy16(AVFilterContext *ctx, AVFrame *in)
+{
+    DeflickerContext *s = ctx->priv;
+    const uint16_t *src = (const uint16_t *)in->data[0];
+    int64_t sum = 0;
+    int y, x;
+
+    memset(s->histogram, 0, (1 << s->depth) * sizeof(*s->histogram));
+
+    for (y = 0; y < s->planeheight[0]; y++) {
+        for (x = 0; x < s->planewidth[0]; x++) {
+            s->histogram[src[x]]++;
+        }
+        src += in->linesize[0] / 2;
+    }
+
+    for (y = 0; y < 1 << s->depth; y++) {
+        sum += s->histogram[y] * y;
+    }
+
+    return 1.0f * sum / (s->planeheight[0] * s->planewidth[0]);
+}
+
+static void get_am_factor(AVFilterContext *ctx, float *f)
+{
+    DeflickerContext *s = ctx->priv;
+    int y;
+
+    *f = 0.0f;
+
+    for (y = 0; y < s->size; y++) {
+        *f += s->luminance[y];
+    }
+
+    *f /= s->size;
+    *f /= s->luminance[0];
+}
+
+static void get_gm_factor(AVFilterContext *ctx, float *f)
+{
+    DeflickerContext *s = ctx->priv;
+    int y;
+
+    *f = 1;
+
+    for (y = 0; y < s->size; y++) {
+        *f *= s->luminance[y];
+    }
+
+    *f = pow(*f, 1.0f / s->size);
+    *f /= s->luminance[0];
+}
+
+static void get_hm_factor(AVFilterContext *ctx, float *f)
+{
+    DeflickerContext *s = ctx->priv;
+    int y;
+
+    *f = 0.0f;
+
+    for (y = 0; y < s->size; y++) {
+        *f += 1.0f / s->luminance[y];
+    }
+
+    *f = s->size / *f;
+    *f /= s->luminance[0];
+}
+
+static void get_qm_factor(AVFilterContext *ctx, float *f)
+{
+    DeflickerContext *s = ctx->priv;
+    int y;
+
+    *f = 0.0f;
+
+    for (y = 0; y < s->size; y++) {
+        *f += s->luminance[y] * s->luminance[y];
+    }
+
+    *f /= s->size;
+    *f  = sqrtf(*f);
+    *f /= s->luminance[0];
+}
+
+static void get_cm_factor(AVFilterContext *ctx, float *f)
+{
+    DeflickerContext *s = ctx->priv;
+    int y;
+
+    *f = 0.0f;
+
+    for (y = 0; y < s->size; y++) {
+        *f += s->luminance[y] * s->luminance[y] * s->luminance[y];
+    }
+
+    *f /= s->size;
+    *f  = cbrtf(*f);
+    *f /= s->luminance[0];
+}
+
+static void get_pm_factor(AVFilterContext *ctx, float *f)
+{
+    DeflickerContext *s = ctx->priv;
+    int y;
+
+    *f = 0.0f;
+
+    for (y = 0; y < s->size; y++) {
+        *f += powf(s->luminance[y], s->size);
+    }
+
+    *f /= s->size;
+    *f  = powf(*f, 1.0f / s->size);
+    *f /= s->luminance[0];
+}
+
+static int comparef(const void *a, const void *b)
+{
+    const float *aa = a, *bb = b;
+    return round(aa - bb);
+}
+
+static void get_median_factor(AVFilterContext *ctx, float *f)
+{
+    DeflickerContext *s = ctx->priv;
+
+    memcpy(s->sorted, s->luminance, sizeof(s->sorted));
+    AV_QSORT(s->sorted, s->size, float, comparef);
+
+    *f = s->sorted[s->size >> 1] / s->luminance[0];
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    AVFilterContext *ctx = inlink->dst;
+    DeflickerContext *s = ctx->priv;
+
+    s->nb_planes = desc->nb_components;
+
+    s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
+    s->planeheight[0] = s->planeheight[3] = inlink->h;
+    s->planewidth[1]  = s->planewidth[2]  = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
+    s->planewidth[0]  = s->planewidth[3]  = inlink->w;
+
+    s->depth = desc->comp[0].depth;
+    if (s->depth == 8) {
+        s->deflicker = deflicker8;
+        s->calc_avgy = calc_avgy8;
+    } else {
+        s->deflicker = deflicker16;
+        s->calc_avgy = calc_avgy16;
+    }
+
+    s->histogram = av_calloc(1 << s->depth, sizeof(*s->histogram));
+    if (!s->histogram)
+        return AVERROR(ENOMEM);
+
+    switch (s->mode) {
+    case MEDIAN:          s->get_factor = get_median_factor; break;
+    case ARITHMETIC_MEAN: s->get_factor = get_am_factor;     break;
+    case GEOMETRIC_MEAN:  s->get_factor = get_gm_factor;     break;
+    case HARMONIC_MEAN:   s->get_factor = get_hm_factor;     break;
+    case QUADRATIC_MEAN:  s->get_factor = get_qm_factor;     break;
+    case CUBIC_MEAN:      s->get_factor = get_cm_factor;     break;
+    case POWER_MEAN:      s->get_factor = get_pm_factor;     break;
+    }
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
+{
+    AVFilterContext *ctx = inlink->dst;
+    AVFilterLink *outlink = ctx->outputs[0];
+    DeflickerContext *s = ctx->priv;
+    AVDictionary **metadata;
+    AVFrame *out, *in;
+    float f;
+    int y;
+
+    if (s->q.available < s->size && !s->eof) {
+        s->luminance[s->available] = s->calc_avgy(ctx, buf);
+        ff_bufqueue_add(ctx, &s->q, buf);
+        s->available++;
+        return 0;
+    }
+
+    in = ff_bufqueue_peek(&s->q, 0);
+
+    out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+    if (!out) {
+        av_frame_free(&buf);
+        return AVERROR(ENOMEM);
+    }
+
+    s->get_factor(ctx, &f);
+    if (!s->bypass)
+        s->deflicker(ctx, in->data[0], in->linesize[0], out->data[0], out->linesize[0],
+                     outlink->w, outlink->h, f);
+    for (y = 1 - s->bypass; y < s->nb_planes; y++) {
+        av_image_copy_plane(out->data[y], out->linesize[y],
+                            in->data[y], in->linesize[y],
+                            s->planewidth[y] * (1 + (s->depth > 8)), s->planeheight[y]);
+    }
+
+    av_frame_copy_props(out, in);
+    metadata = &out->metadata;
+    if (metadata) {
+        uint8_t value[128];
+
+        snprintf(value, sizeof(value), "%f", s->luminance[0]);
+        av_dict_set(metadata, "lavfi.deflicker.luminance", value, 0);
+
+        snprintf(value, sizeof(value), "%f", s->luminance[0] * f);
+        av_dict_set(metadata, "lavfi.deflicker.new_luminance", value, 0);
+
+        snprintf(value, sizeof(value), "%f", f - 1.0f);
+        av_dict_set(metadata, "lavfi.deflicker.relative_change", value, 0);
+    }
+
+    in = ff_bufqueue_get(&s->q);
+    av_frame_free(&in);
+    memmove(&s->luminance[0], &s->luminance[1], sizeof(*s->luminance) * (s->size - 1));
+    s->luminance[s->available - 1] = s->calc_avgy(ctx, buf);
+    ff_bufqueue_add(ctx, &s->q, buf);
+
+    return ff_filter_frame(outlink, out);
+}
+
+static int request_frame(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    DeflickerContext *s = ctx->priv;
+    int ret;
+
+    ret = ff_request_frame(ctx->inputs[0]);
+    if (ret == AVERROR_EOF && s->available > 0) {
+        AVFrame *buf = av_frame_clone(ff_bufqueue_peek(&s->q, s->size - 1));
+        if (!buf)
+            return AVERROR(ENOMEM);
+
+        s->eof = 1;
+        ret = filter_frame(ctx->inputs[0], buf);
+        s->available--;
+    }
+
+    return ret;
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    DeflickerContext *s = ctx->priv;
+
+    ff_bufqueue_discard_all(&s->q);
+    av_freep(&s->histogram);
+}
+
+static const AVFilterPad inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = filter_frame,
+        .config_props = config_input,
+    },
+    { NULL }
+};
+
+static const AVFilterPad outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .request_frame = request_frame,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_deflicker = {
+    .name          = "deflicker",
+    .description   = NULL_IF_CONFIG_SMALL("Remove temporal frame luminance variations."),
+    .priv_size     = sizeof(DeflickerContext),
+    .priv_class    = &deflicker_class,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .inputs        = inputs,
+    .outputs       = outputs,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_deinterlace_qsv.c b/mythtv/external/FFmpeg/libavfilter/vf_deinterlace_qsv.c
new file mode 100644
index 00000000000..2810bffe461
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_deinterlace_qsv.c
@@ -0,0 +1,575 @@
+/*
+ * 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
+ * deinterlace video filter - QSV
+ */
+
+#include <mfx/mfxvideo.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include "libavutil/avstring.h"
+#include "libavutil/common.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_qsv.h"
+#include "libavutil/internal.h"
+#include "libavutil/mathematics.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/time.h"
+
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+enum {
+    QSVDEINT_MORE_OUTPUT = 1,
+    QSVDEINT_MORE_INPUT,
+};
+
+typedef struct QSVFrame {
+    AVFrame *frame;
+    mfxFrameSurface1 surface;
+    int used;
+
+    struct QSVFrame *next;
+} QSVFrame;
+
+typedef struct QSVDeintContext {
+    const AVClass *class;
+
+    AVBufferRef *hw_frames_ctx;
+    /* a clone of the main session, used internally for deinterlacing */
+    mfxSession   session;
+
+    mfxMemId *mem_ids;
+    int    nb_mem_ids;
+
+    mfxFrameSurface1 **surface_ptrs;
+    int             nb_surface_ptrs;
+
+    mfxExtOpaqueSurfaceAlloc opaque_alloc;
+    mfxExtBuffer            *ext_buffers[1];
+
+    QSVFrame *work_frames;
+
+    int64_t last_pts;
+
+    int eof;
+} QSVDeintContext;
+
+static void qsvdeint_uninit(AVFilterContext *ctx)
+{
+    QSVDeintContext *s = ctx->priv;
+    QSVFrame *cur;
+
+    if (s->session) {
+        MFXClose(s->session);
+        s->session = NULL;
+    }
+    av_buffer_unref(&s->hw_frames_ctx);
+
+    cur = s->work_frames;
+    while (cur) {
+        s->work_frames = cur->next;
+        av_frame_free(&cur->frame);
+        av_freep(&cur);
+        cur = s->work_frames;
+    }
+
+    av_freep(&s->mem_ids);
+    s->nb_mem_ids = 0;
+
+    av_freep(&s->surface_ptrs);
+    s->nb_surface_ptrs = 0;
+}
+
+static int qsvdeint_query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pixel_formats[] = {
+        AV_PIX_FMT_QSV, AV_PIX_FMT_NONE,
+    };
+    AVFilterFormats *pix_fmts  = ff_make_format_list(pixel_formats);
+    int ret;
+
+    if ((ret = ff_set_common_formats(ctx, pix_fmts)) < 0)
+        return ret;
+
+    return 0;
+}
+
+static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
+                             mfxFrameAllocResponse *resp)
+{
+    AVFilterContext *ctx = pthis;
+    QSVDeintContext   *s = ctx->priv;
+
+    if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) ||
+        !(req->Type & (MFX_MEMTYPE_FROM_VPPIN | MFX_MEMTYPE_FROM_VPPOUT)) ||
+        !(req->Type & MFX_MEMTYPE_EXTERNAL_FRAME))
+        return MFX_ERR_UNSUPPORTED;
+
+    resp->mids           = s->mem_ids;
+    resp->NumFrameActual = s->nb_mem_ids;
+
+    return MFX_ERR_NONE;
+}
+
+static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
+{
+    return MFX_ERR_NONE;
+}
+
+static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
+{
+    return MFX_ERR_UNSUPPORTED;
+}
+
+static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
+{
+    return MFX_ERR_UNSUPPORTED;
+}
+
+static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
+{
+    *hdl = mid;
+    return MFX_ERR_NONE;
+}
+
+static const mfxHandleType handle_types[] = {
+    MFX_HANDLE_VA_DISPLAY,
+    MFX_HANDLE_D3D9_DEVICE_MANAGER,
+    MFX_HANDLE_D3D11_DEVICE,
+};
+
+static int init_out_session(AVFilterContext *ctx)
+{
+
+    QSVDeintContext                  *s = ctx->priv;
+    AVHWFramesContext    *hw_frames_ctx = (AVHWFramesContext*)s->hw_frames_ctx->data;
+    AVQSVFramesContext *hw_frames_hwctx = hw_frames_ctx->hwctx;
+    AVQSVDeviceContext    *device_hwctx = hw_frames_ctx->device_ctx->hwctx;
+
+    int opaque = !!(hw_frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME);
+
+    mfxHDL handle = NULL;
+    mfxHandleType handle_type;
+    mfxVersion ver;
+    mfxIMPL impl;
+    mfxVideoParam par;
+    mfxStatus err;
+    int i;
+
+    /* extract the properties of the "master" session given to us */
+    err = MFXQueryIMPL(device_hwctx->session, &impl);
+    if (err == MFX_ERR_NONE)
+        err = MFXQueryVersion(device_hwctx->session, &ver);
+    if (err != MFX_ERR_NONE) {
+        av_log(ctx, AV_LOG_ERROR, "Error querying the session attributes\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    for (i = 0; i < FF_ARRAY_ELEMS(handle_types); i++) {
+        err = MFXVideoCORE_GetHandle(device_hwctx->session, handle_types[i], &handle);
+        if (err == MFX_ERR_NONE) {
+            handle_type = handle_types[i];
+            break;
+        }
+    }
+
+    /* create a "slave" session with those same properties, to be used for
+     * actual deinterlacing */
+    err = MFXInit(impl, &ver, &s->session);
+    if (err != MFX_ERR_NONE) {
+        av_log(ctx, AV_LOG_ERROR, "Error initializing a session for deinterlacing\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    if (handle) {
+        err = MFXVideoCORE_SetHandle(s->session, handle_type, handle);
+        if (err != MFX_ERR_NONE)
+            return AVERROR_UNKNOWN;
+    }
+
+    memset(&par, 0, sizeof(par));
+
+    if (opaque) {
+        s->surface_ptrs = av_mallocz_array(hw_frames_hwctx->nb_surfaces,
+                                           sizeof(*s->surface_ptrs));
+        if (!s->surface_ptrs)
+            return AVERROR(ENOMEM);
+        for (i = 0; i < hw_frames_hwctx->nb_surfaces; i++)
+            s->surface_ptrs[i] = hw_frames_hwctx->surfaces + i;
+        s->nb_surface_ptrs = hw_frames_hwctx->nb_surfaces;
+
+        s->opaque_alloc.In.Surfaces   = s->surface_ptrs;
+        s->opaque_alloc.In.NumSurface = s->nb_surface_ptrs;
+        s->opaque_alloc.In.Type       = hw_frames_hwctx->frame_type;
+
+        s->opaque_alloc.Out = s->opaque_alloc.In;
+
+        s->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
+        s->opaque_alloc.Header.BufferSz = sizeof(s->opaque_alloc);
+
+        s->ext_buffers[0] = (mfxExtBuffer*)&s->opaque_alloc;
+
+        par.ExtParam    = s->ext_buffers;
+        par.NumExtParam = FF_ARRAY_ELEMS(s->ext_buffers);
+
+        par.IOPattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY | MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
+    } else {
+        mfxFrameAllocator frame_allocator = {
+            .pthis  = ctx,
+            .Alloc  = frame_alloc,
+            .Lock   = frame_lock,
+            .Unlock = frame_unlock,
+            .GetHDL = frame_get_hdl,
+            .Free   = frame_free,
+        };
+
+        s->mem_ids = av_mallocz_array(hw_frames_hwctx->nb_surfaces,
+                                      sizeof(*s->mem_ids));
+        if (!s->mem_ids)
+            return AVERROR(ENOMEM);
+        for (i = 0; i < hw_frames_hwctx->nb_surfaces; i++)
+            s->mem_ids[i] = hw_frames_hwctx->surfaces[i].Data.MemId;
+        s->nb_mem_ids = hw_frames_hwctx->nb_surfaces;
+
+        err = MFXVideoCORE_SetFrameAllocator(s->session, &frame_allocator);
+        if (err != MFX_ERR_NONE)
+            return AVERROR_UNKNOWN;
+
+        par.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
+    }
+
+    par.AsyncDepth = 1;    // TODO async
+
+    par.vpp.In = hw_frames_hwctx->surfaces[0].Info;
+
+    par.vpp.In.CropW = ctx->inputs[0]->w;
+    par.vpp.In.CropH = ctx->inputs[0]->h;
+
+    if (ctx->inputs[0]->frame_rate.num) {
+        par.vpp.In.FrameRateExtN = ctx->inputs[0]->frame_rate.num;
+        par.vpp.In.FrameRateExtD = ctx->inputs[0]->frame_rate.den;
+    } else {
+        par.vpp.In.FrameRateExtN = ctx->inputs[0]->time_base.num;
+        par.vpp.In.FrameRateExtD = ctx->inputs[0]->time_base.den;
+    }
+
+    par.vpp.Out = par.vpp.In;
+
+    if (ctx->outputs[0]->frame_rate.num) {
+        par.vpp.Out.FrameRateExtN = ctx->outputs[0]->frame_rate.num;
+        par.vpp.Out.FrameRateExtD = ctx->outputs[0]->frame_rate.den;
+    } else {
+        par.vpp.Out.FrameRateExtN = ctx->outputs[0]->time_base.num;
+        par.vpp.Out.FrameRateExtD = ctx->outputs[0]->time_base.den;
+    }
+
+    err = MFXVideoVPP_Init(s->session, &par);
+    if (err != MFX_ERR_NONE) {
+        av_log(ctx, AV_LOG_ERROR, "Error opening the VPP for deinterlacing: %d\n", err);
+        return AVERROR_UNKNOWN;
+    }
+
+    return 0;
+}
+
+static int qsvdeint_config_props(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    AVFilterLink *inlink = ctx->inputs[0];
+    QSVDeintContext  *s = ctx->priv;
+    int ret;
+
+    qsvdeint_uninit(ctx);
+
+    s->last_pts = AV_NOPTS_VALUE;
+    outlink->frame_rate = av_mul_q(inlink->frame_rate,
+                                   (AVRational){ 2, 1 });
+    outlink->time_base  = av_mul_q(inlink->time_base,
+                                   (AVRational){ 1, 2 });
+
+    /* check that we have a hw context */
+    if (!inlink->hw_frames_ctx) {
+        av_log(ctx, AV_LOG_ERROR, "No hw context provided on input\n");
+        return AVERROR(EINVAL);
+    }
+
+    s->hw_frames_ctx = av_buffer_ref(inlink->hw_frames_ctx);
+    if (!s->hw_frames_ctx)
+        return AVERROR(ENOMEM);
+
+    av_buffer_unref(&outlink->hw_frames_ctx);
+    outlink->hw_frames_ctx = av_buffer_ref(inlink->hw_frames_ctx);
+    if (!outlink->hw_frames_ctx) {
+        qsvdeint_uninit(ctx);
+        return AVERROR(ENOMEM);
+    }
+
+    ret = init_out_session(ctx);
+    if (ret < 0)
+        return ret;
+
+
+    return 0;
+}
+
+static void clear_unused_frames(QSVDeintContext *s)
+{
+    QSVFrame *cur = s->work_frames;
+    while (cur) {
+        if (!cur->surface.Data.Locked) {
+            av_frame_free(&cur->frame);
+            cur->used = 0;
+        }
+        cur = cur->next;
+    }
+}
+
+static int get_free_frame(QSVDeintContext *s, QSVFrame **f)
+{
+    QSVFrame *frame, **last;
+
+    clear_unused_frames(s);
+
+    frame = s->work_frames;
+    last  = &s->work_frames;
+    while (frame) {
+        if (!frame->used) {
+            *f = frame;
+            return 0;
+        }
+
+        last  = &frame->next;
+        frame = frame->next;
+    }
+
+    frame = av_mallocz(sizeof(*frame));
+    if (!frame)
+        return AVERROR(ENOMEM);
+    *last = frame;
+    *f    = frame;
+
+    return 0;
+}
+
+static int submit_frame(AVFilterContext *ctx, AVFrame *frame,
+                        mfxFrameSurface1 **surface)
+{
+    QSVDeintContext *s = ctx->priv;
+    QSVFrame *qf;
+    int ret;
+
+    ret = get_free_frame(s, &qf);
+    if (ret < 0)
+        return ret;
+
+    qf->frame = frame;
+
+    qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
+
+    qf->surface.Data.Locked = 0;
+    qf->surface.Info.CropW  = qf->frame->width;
+    qf->surface.Info.CropH  = qf->frame->height;
+
+    qf->surface.Info.PicStruct = !qf->frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
+                                 (qf->frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
+                                                           MFX_PICSTRUCT_FIELD_BFF);
+    if (qf->frame->repeat_pict == 1)
+        qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
+    else if (qf->frame->repeat_pict == 2)
+        qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
+    else if (qf->frame->repeat_pict == 4)
+        qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
+
+    if (ctx->inputs[0]->frame_rate.num) {
+        qf->surface.Info.FrameRateExtN = ctx->inputs[0]->frame_rate.num;
+        qf->surface.Info.FrameRateExtD = ctx->inputs[0]->frame_rate.den;
+    } else {
+        qf->surface.Info.FrameRateExtN = ctx->inputs[0]->time_base.num;
+        qf->surface.Info.FrameRateExtD = ctx->inputs[0]->time_base.den;
+    }
+
+    qf->surface.Data.TimeStamp = av_rescale_q(qf->frame->pts,
+                                              ctx->inputs[0]->time_base,
+                                              (AVRational){1, 90000});
+
+    *surface = &qf->surface;
+    qf->used = 1;
+
+    return 0;
+}
+
+static int process_frame(AVFilterContext *ctx, const AVFrame *in,
+                         mfxFrameSurface1 *surf_in)
+{
+    QSVDeintContext    *s = ctx->priv;
+    AVFilterLink  *inlink = ctx->inputs[0];
+    AVFilterLink *outlink = ctx->outputs[0];
+
+    AVFrame *out;
+    mfxFrameSurface1 *surf_out;
+    mfxSyncPoint sync = NULL;
+    mfxStatus err;
+    int ret, again = 0;
+
+    out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+    if (!out) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    surf_out = (mfxFrameSurface1*)out->data[3];
+    surf_out->Info.CropW     = outlink->w;
+    surf_out->Info.CropH     = outlink->h;
+    surf_out->Info.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
+
+    do {
+        err = MFXVideoVPP_RunFrameVPPAsync(s->session, surf_in, surf_out,
+                                           NULL, &sync);
+        if (err == MFX_WRN_DEVICE_BUSY)
+            av_usleep(1);
+    } while (err == MFX_WRN_DEVICE_BUSY);
+
+    if (err == MFX_ERR_MORE_DATA) {
+        av_frame_free(&out);
+        return QSVDEINT_MORE_INPUT;
+    }
+
+    if ((err < 0 && err != MFX_ERR_MORE_SURFACE) || !sync) {
+        av_log(ctx, AV_LOG_ERROR, "Error during deinterlacing: %d\n", err);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+    if (err == MFX_ERR_MORE_SURFACE)
+        again = 1;
+
+    do {
+        err = MFXVideoCORE_SyncOperation(s->session, sync, 1000);
+    } while (err == MFX_WRN_IN_EXECUTION);
+    if (err < 0) {
+        av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation: %d\n", err);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    ret = av_frame_copy_props(out, in);
+    if (ret < 0)
+        goto fail;
+
+    out->width            = outlink->w;
+    out->height           = outlink->h;
+    out->interlaced_frame = 0;
+
+    out->pts = av_rescale_q(out->pts, inlink->time_base, outlink->time_base);
+    if (out->pts == s->last_pts)
+        out->pts++;
+    s->last_pts = out->pts;
+
+    ret = ff_filter_frame(outlink, out);
+    if (ret < 0)
+        return ret;
+
+    return again ? QSVDEINT_MORE_OUTPUT : 0;
+fail:
+    av_frame_free(&out);
+    return ret;
+}
+
+static int qsvdeint_filter_frame(AVFilterLink *link, AVFrame *in)
+{
+    AVFilterContext *ctx = link->dst;
+
+    mfxFrameSurface1 *surf_in;
+    int ret;
+
+    ret = submit_frame(ctx, in, &surf_in);
+    if (ret < 0) {
+        av_frame_free(&in);
+        return ret;
+    }
+
+    do {
+        ret = process_frame(ctx, in, surf_in);
+        if (ret < 0)
+            return ret;
+    } while (ret == QSVDEINT_MORE_OUTPUT);
+
+    return 0;
+}
+
+static int qsvdeint_request_frame(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+
+    return ff_request_frame(ctx->inputs[0]);
+}
+
+#define OFFSET(x) offsetof(QSVDeintContext, x)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+static const AVOption options[] = {
+    { NULL },
+};
+
+static const AVClass qsvdeint_class = {
+    .class_name = "deinterlace_qsv",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+static const AVFilterPad qsvdeint_inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = qsvdeint_filter_frame,
+    },
+    { NULL }
+};
+
+static const AVFilterPad qsvdeint_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .config_props  = qsvdeint_config_props,
+        .request_frame = qsvdeint_request_frame,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_deinterlace_qsv = {
+    .name      = "deinterlace_qsv",
+    .description = NULL_IF_CONFIG_SMALL("QuickSync video deinterlacing"),
+
+    .uninit        = qsvdeint_uninit,
+    .query_formats = qsvdeint_query_formats,
+
+    .priv_size = sizeof(QSVDeintContext),
+    .priv_class = &qsvdeint_class,
+
+    .inputs    = qsvdeint_inputs,
+    .outputs   = qsvdeint_outputs,
+
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_deinterlace_vaapi.c b/mythtv/external/FFmpeg/libavfilter/vf_deinterlace_vaapi.c
new file mode 100644
index 00000000000..44c5ae7642c
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_deinterlace_vaapi.c
@@ -0,0 +1,678 @@
+/*
+ * 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 <string.h>
+
+#include <va/va.h>
+#include <va/va_vpp.h>
+
+#include "libavutil/avassert.h"
+#include "libavutil/common.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_vaapi.h"
+#include "libavutil/mem.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+#define MAX_REFERENCES 8
+
+typedef struct DeintVAAPIContext {
+    const AVClass     *class;
+
+    AVVAAPIDeviceContext *hwctx;
+    AVBufferRef       *device_ref;
+
+    int                mode;
+    int                field_rate;
+    int                auto_enable;
+
+    int                valid_ids;
+    VAConfigID         va_config;
+    VAContextID        va_context;
+
+    AVBufferRef       *input_frames_ref;
+    AVHWFramesContext *input_frames;
+
+    AVBufferRef       *output_frames_ref;
+    AVHWFramesContext *output_frames;
+    int                output_height;
+    int                output_width;
+
+    VAProcFilterCapDeinterlacing
+                       deint_caps[VAProcDeinterlacingCount];
+    int             nb_deint_caps;
+    VAProcPipelineCaps pipeline_caps;
+
+    int                queue_depth;
+    int                queue_count;
+    AVFrame           *frame_queue[MAX_REFERENCES];
+    int                extra_delay_for_timestamps;
+
+    VABufferID         filter_buffer;
+} DeintVAAPIContext;
+
+static const char *deint_vaapi_mode_name(int mode)
+{
+    switch (mode) {
+#define D(name) case VAProcDeinterlacing ## name: return #name
+        D(Bob);
+        D(Weave);
+        D(MotionAdaptive);
+        D(MotionCompensated);
+#undef D
+    default:
+        return "Invalid";
+    }
+}
+
+static int deint_vaapi_query_formats(AVFilterContext *avctx)
+{
+    enum AVPixelFormat pix_fmts[] = {
+        AV_PIX_FMT_VAAPI, AV_PIX_FMT_NONE,
+    };
+    int err;
+
+    if ((err = ff_formats_ref(ff_make_format_list(pix_fmts),
+                              &avctx->inputs[0]->out_formats)) < 0)
+        return err;
+    if ((err = ff_formats_ref(ff_make_format_list(pix_fmts),
+                              &avctx->outputs[0]->in_formats)) < 0)
+        return err;
+
+    return 0;
+}
+
+static int deint_vaapi_pipeline_uninit(AVFilterContext *avctx)
+{
+    DeintVAAPIContext *ctx = avctx->priv;
+    int i;
+
+    for (i = 0; i < ctx->queue_count; i++)
+        av_frame_free(&ctx->frame_queue[i]);
+    ctx->queue_count = 0;
+
+    if (ctx->filter_buffer != VA_INVALID_ID) {
+        vaDestroyBuffer(ctx->hwctx->display, ctx->filter_buffer);
+        ctx->filter_buffer = VA_INVALID_ID;
+    }
+
+    if (ctx->va_context != VA_INVALID_ID) {
+        vaDestroyContext(ctx->hwctx->display, ctx->va_context);
+        ctx->va_context = VA_INVALID_ID;
+    }
+
+    if (ctx->va_config != VA_INVALID_ID) {
+        vaDestroyConfig(ctx->hwctx->display, ctx->va_config);
+        ctx->va_config = VA_INVALID_ID;
+    }
+
+    av_buffer_unref(&ctx->device_ref);
+    ctx->hwctx = NULL;
+
+    return 0;
+}
+
+static int deint_vaapi_config_input(AVFilterLink *inlink)
+{
+    AVFilterContext   *avctx = inlink->dst;
+    DeintVAAPIContext *ctx = avctx->priv;
+
+    deint_vaapi_pipeline_uninit(avctx);
+
+    if (!inlink->hw_frames_ctx) {
+        av_log(avctx, AV_LOG_ERROR, "A hardware frames reference is "
+               "required to associate the processing device.\n");
+        return AVERROR(EINVAL);
+    }
+
+    ctx->input_frames_ref = av_buffer_ref(inlink->hw_frames_ctx);
+    ctx->input_frames = (AVHWFramesContext*)ctx->input_frames_ref->data;
+
+    return 0;
+}
+
+static int deint_vaapi_build_filter_params(AVFilterContext *avctx)
+{
+    DeintVAAPIContext *ctx = avctx->priv;
+    VAStatus vas;
+    VAProcFilterParameterBufferDeinterlacing params;
+    int i;
+
+    ctx->nb_deint_caps = VAProcDeinterlacingCount;
+    vas = vaQueryVideoProcFilterCaps(ctx->hwctx->display,
+                                     ctx->va_context,
+                                     VAProcFilterDeinterlacing,
+                                     &ctx->deint_caps,
+                                     &ctx->nb_deint_caps);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to query deinterlacing "
+               "caps: %d (%s).\n", vas, vaErrorStr(vas));
+        return AVERROR(EIO);
+    }
+
+    if (ctx->mode == VAProcDeinterlacingNone) {
+        for (i = 0; i < ctx->nb_deint_caps; i++) {
+            if (ctx->deint_caps[i].type > ctx->mode)
+                ctx->mode = ctx->deint_caps[i].type;
+        }
+        av_log(avctx, AV_LOG_VERBOSE, "Picking %d (%s) as default "
+               "deinterlacing mode.\n", ctx->mode,
+               deint_vaapi_mode_name(ctx->mode));
+    } else {
+        for (i = 0; i < ctx->nb_deint_caps; i++) {
+            if (ctx->deint_caps[i].type == ctx->mode)
+                break;
+        }
+        if (i >= ctx->nb_deint_caps) {
+            av_log(avctx, AV_LOG_ERROR, "Deinterlacing mode %d (%s) is "
+                   "not supported.\n", ctx->mode,
+                   deint_vaapi_mode_name(ctx->mode));
+        }
+    }
+
+    params.type      = VAProcFilterDeinterlacing;
+    params.algorithm = ctx->mode;
+    params.flags     = 0;
+
+    av_assert0(ctx->filter_buffer == VA_INVALID_ID);
+    vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
+                         VAProcFilterParameterBufferType,
+                         sizeof(params), 1, &params,
+                         &ctx->filter_buffer);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create deinterlace "
+               "parameter buffer: %d (%s).\n", vas, vaErrorStr(vas));
+        return AVERROR(EIO);
+    }
+
+    vas = vaQueryVideoProcPipelineCaps(ctx->hwctx->display,
+                                       ctx->va_context,
+                                       &ctx->filter_buffer, 1,
+                                       &ctx->pipeline_caps);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to query pipeline "
+               "caps: %d (%s).\n", vas, vaErrorStr(vas));
+        return AVERROR(EIO);
+    }
+
+    ctx->extra_delay_for_timestamps = ctx->field_rate == 2 &&
+        ctx->pipeline_caps.num_backward_references == 0;
+
+    ctx->queue_depth = ctx->pipeline_caps.num_backward_references +
+                       ctx->pipeline_caps.num_forward_references +
+                       ctx->extra_delay_for_timestamps + 1;
+    if (ctx->queue_depth > MAX_REFERENCES) {
+        av_log(avctx, AV_LOG_ERROR, "Pipeline requires too many "
+               "references (%u forward, %u back).\n",
+               ctx->pipeline_caps.num_forward_references,
+               ctx->pipeline_caps.num_backward_references);
+        return AVERROR(ENOSYS);
+    }
+
+    return 0;
+}
+
+static int deint_vaapi_config_output(AVFilterLink *outlink)
+{
+    AVFilterContext    *avctx = outlink->src;
+    AVFilterLink      *inlink = avctx->inputs[0];
+    DeintVAAPIContext    *ctx = avctx->priv;
+    AVVAAPIHWConfig *hwconfig = NULL;
+    AVHWFramesConstraints *constraints = NULL;
+    AVVAAPIFramesContext *va_frames;
+    VAStatus vas;
+    int err;
+
+    deint_vaapi_pipeline_uninit(avctx);
+
+    av_assert0(ctx->input_frames);
+    ctx->device_ref = av_buffer_ref(ctx->input_frames->device_ref);
+    ctx->hwctx = ((AVHWDeviceContext*)ctx->device_ref->data)->hwctx;
+
+    ctx->output_width  = ctx->input_frames->width;
+    ctx->output_height = ctx->input_frames->height;
+
+    av_assert0(ctx->va_config == VA_INVALID_ID);
+    vas = vaCreateConfig(ctx->hwctx->display, VAProfileNone,
+                         VAEntrypointVideoProc, 0, 0, &ctx->va_config);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create processing pipeline "
+               "config: %d (%s).\n", vas, vaErrorStr(vas));
+        err = AVERROR(EIO);
+        goto fail;
+    }
+
+    hwconfig = av_hwdevice_hwconfig_alloc(ctx->device_ref);
+    if (!hwconfig) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+    hwconfig->config_id = ctx->va_config;
+
+    constraints = av_hwdevice_get_hwframe_constraints(ctx->device_ref,
+                                                      hwconfig);
+    if (!constraints) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    if (ctx->output_width  < constraints->min_width  ||
+        ctx->output_height < constraints->min_height ||
+        ctx->output_width  > constraints->max_width  ||
+        ctx->output_height > constraints->max_height) {
+        av_log(avctx, AV_LOG_ERROR, "Hardware does not support "
+               "deinterlacing to size %dx%d "
+               "(constraints: width %d-%d height %d-%d).\n",
+               ctx->output_width, ctx->output_height,
+               constraints->min_width,  constraints->max_width,
+               constraints->min_height, constraints->max_height);
+        err = AVERROR(EINVAL);
+        goto fail;
+    }
+
+    ctx->output_frames_ref = av_hwframe_ctx_alloc(ctx->device_ref);
+    if (!ctx->output_frames_ref) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create HW frame context "
+               "for output.\n");
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    ctx->output_frames = (AVHWFramesContext*)ctx->output_frames_ref->data;
+
+    ctx->output_frames->format    = AV_PIX_FMT_VAAPI;
+    ctx->output_frames->sw_format = ctx->input_frames->sw_format;
+    ctx->output_frames->width     = ctx->output_width;
+    ctx->output_frames->height    = ctx->output_height;
+
+    // The number of output frames we need is determined by what follows
+    // the filter.  If it's an encoder with complex frame reference
+    // structures then this could be very high.
+    ctx->output_frames->initial_pool_size = 10;
+
+    err = av_hwframe_ctx_init(ctx->output_frames_ref);
+    if (err < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to initialise VAAPI frame "
+               "context for output: %d\n", err);
+        goto fail;
+    }
+
+    va_frames = ctx->output_frames->hwctx;
+
+    av_assert0(ctx->va_context == VA_INVALID_ID);
+    vas = vaCreateContext(ctx->hwctx->display, ctx->va_config,
+                          ctx->output_width, ctx->output_height, 0,
+                          va_frames->surface_ids, va_frames->nb_surfaces,
+                          &ctx->va_context);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to create processing pipeline "
+               "context: %d (%s).\n", vas, vaErrorStr(vas));
+        err = AVERROR(EIO);
+        goto fail;
+    }
+
+    err = deint_vaapi_build_filter_params(avctx);
+    if (err < 0)
+        goto fail;
+
+    outlink->w = inlink->w;
+    outlink->h = inlink->h;
+
+    outlink->time_base  = av_mul_q(inlink->time_base,
+                                   (AVRational) { 1, ctx->field_rate });
+    outlink->frame_rate = av_mul_q(inlink->frame_rate,
+                                   (AVRational) { ctx->field_rate, 1 });
+
+    outlink->hw_frames_ctx = av_buffer_ref(ctx->output_frames_ref);
+    if (!outlink->hw_frames_ctx) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    av_freep(&hwconfig);
+    av_hwframe_constraints_free(&constraints);
+    return 0;
+
+fail:
+    av_buffer_unref(&ctx->output_frames_ref);
+    av_freep(&hwconfig);
+    av_hwframe_constraints_free(&constraints);
+    return err;
+}
+
+static int vaapi_proc_colour_standard(enum AVColorSpace av_cs)
+{
+    switch(av_cs) {
+#define CS(av, va) case AVCOL_SPC_ ## av: return VAProcColorStandard ## va;
+        CS(BT709,     BT709);
+        CS(BT470BG,   BT470BG);
+        CS(SMPTE170M, SMPTE170M);
+        CS(SMPTE240M, SMPTE240M);
+#undef CS
+    default:
+        return VAProcColorStandardNone;
+    }
+}
+
+static int deint_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
+{
+    AVFilterContext   *avctx = inlink->dst;
+    AVFilterLink    *outlink = avctx->outputs[0];
+    DeintVAAPIContext *ctx = avctx->priv;
+    AVFrame *output_frame = NULL;
+    VASurfaceID input_surface, output_surface;
+    VASurfaceID backward_references[MAX_REFERENCES];
+    VASurfaceID forward_references[MAX_REFERENCES];
+    VAProcPipelineParameterBuffer params;
+    VAProcFilterParameterBufferDeinterlacing *filter_params;
+    VARectangle input_region;
+    VABufferID params_id;
+    VAStatus vas;
+    void *filter_params_addr = NULL;
+    int err, i, field, current_frame_index;
+
+    av_log(avctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
+           av_get_pix_fmt_name(input_frame->format),
+           input_frame->width, input_frame->height, input_frame->pts);
+
+    if (ctx->queue_count < ctx->queue_depth) {
+        ctx->frame_queue[ctx->queue_count++] = input_frame;
+        if (ctx->queue_count < ctx->queue_depth) {
+            // Need more reference surfaces before we can continue.
+            return 0;
+        }
+    } else {
+        av_frame_free(&ctx->frame_queue[0]);
+        for (i = 0; i + 1 < ctx->queue_count; i++)
+            ctx->frame_queue[i] = ctx->frame_queue[i + 1];
+        ctx->frame_queue[i] = input_frame;
+    }
+
+    current_frame_index = ctx->pipeline_caps.num_forward_references;
+
+    input_frame = ctx->frame_queue[current_frame_index];
+    input_surface = (VASurfaceID)(uintptr_t)input_frame->data[3];
+    for (i = 0; i < ctx->pipeline_caps.num_forward_references; i++)
+        forward_references[i] = (VASurfaceID)(uintptr_t)
+            ctx->frame_queue[current_frame_index - i - 1]->data[3];
+    for (i = 0; i < ctx->pipeline_caps.num_backward_references; i++)
+        backward_references[i] = (VASurfaceID)(uintptr_t)
+            ctx->frame_queue[current_frame_index + i + 1]->data[3];
+
+    av_log(avctx, AV_LOG_DEBUG, "Using surface %#x for "
+           "deinterlace input.\n", input_surface);
+    av_log(avctx, AV_LOG_DEBUG, "Backward references:");
+    for (i = 0; i < ctx->pipeline_caps.num_backward_references; i++)
+        av_log(avctx, AV_LOG_DEBUG, " %#x", backward_references[i]);
+    av_log(avctx, AV_LOG_DEBUG, "\n");
+    av_log(avctx, AV_LOG_DEBUG, "Forward  references:");
+    for (i = 0; i < ctx->pipeline_caps.num_forward_references; i++)
+        av_log(avctx, AV_LOG_DEBUG, " %#x", forward_references[i]);
+    av_log(avctx, AV_LOG_DEBUG, "\n");
+
+    for (field = 0; field < ctx->field_rate; field++) {
+        output_frame = ff_get_video_buffer(outlink, ctx->output_width,
+                                           ctx->output_height);
+        if (!output_frame) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+
+        output_surface = (VASurfaceID)(uintptr_t)output_frame->data[3];
+        av_log(avctx, AV_LOG_DEBUG, "Using surface %#x for "
+               "deinterlace output.\n", output_surface);
+
+        memset(&params, 0, sizeof(params));
+
+        input_region = (VARectangle) {
+            .x      = 0,
+            .y      = 0,
+            .width  = input_frame->width,
+            .height = input_frame->height,
+        };
+
+        params.surface = input_surface;
+        params.surface_region = &input_region;
+        params.surface_color_standard =
+            vaapi_proc_colour_standard(input_frame->colorspace);
+
+        params.output_region = NULL;
+        params.output_background_color = 0xff000000;
+        params.output_color_standard = params.surface_color_standard;
+
+        params.pipeline_flags = 0;
+        params.filter_flags   = VA_FRAME_PICTURE;
+
+        if (!ctx->auto_enable || input_frame->interlaced_frame) {
+            vas = vaMapBuffer(ctx->hwctx->display, ctx->filter_buffer,
+                              &filter_params_addr);
+            if (vas != VA_STATUS_SUCCESS) {
+                av_log(avctx, AV_LOG_ERROR, "Failed to map filter parameter "
+                       "buffer: %d (%s).\n", vas, vaErrorStr(vas));
+                err = AVERROR(EIO);
+                goto fail;
+            }
+            filter_params = filter_params_addr;
+            filter_params->flags = 0;
+            if (input_frame->top_field_first) {
+                filter_params->flags |= field ? VA_DEINTERLACING_BOTTOM_FIELD : 0;
+            } else {
+                filter_params->flags |= VA_DEINTERLACING_BOTTOM_FIELD_FIRST;
+                filter_params->flags |= field ? 0 : VA_DEINTERLACING_BOTTOM_FIELD;
+            }
+            filter_params_addr = NULL;
+            vas = vaUnmapBuffer(ctx->hwctx->display, ctx->filter_buffer);
+            if (vas != VA_STATUS_SUCCESS)
+                av_log(avctx, AV_LOG_ERROR, "Failed to unmap filter parameter "
+                       "buffer: %d (%s).\n", vas, vaErrorStr(vas));
+
+            params.filters     = &ctx->filter_buffer;
+            params.num_filters = 1;
+
+            params.forward_references = forward_references;
+            params.num_forward_references =
+                ctx->pipeline_caps.num_forward_references;
+            params.backward_references = backward_references;
+            params.num_backward_references =
+                ctx->pipeline_caps.num_backward_references;
+
+        } else {
+            params.filters     = NULL;
+            params.num_filters = 0;
+        }
+
+        vas = vaBeginPicture(ctx->hwctx->display,
+                             ctx->va_context, output_surface);
+        if (vas != VA_STATUS_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to attach new picture: "
+                   "%d (%s).\n", vas, vaErrorStr(vas));
+            err = AVERROR(EIO);
+            goto fail;
+        }
+
+        vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
+                             VAProcPipelineParameterBufferType,
+                             sizeof(params), 1, &params, &params_id);
+        if (vas != VA_STATUS_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to create parameter buffer: "
+                   "%d (%s).\n", vas, vaErrorStr(vas));
+            err = AVERROR(EIO);
+            goto fail_after_begin;
+        }
+        av_log(avctx, AV_LOG_DEBUG, "Pipeline parameter buffer is %#x.\n",
+               params_id);
+
+        vas = vaRenderPicture(ctx->hwctx->display, ctx->va_context,
+                              &params_id, 1);
+        if (vas != VA_STATUS_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to render parameter buffer: "
+                   "%d (%s).\n", vas, vaErrorStr(vas));
+            err = AVERROR(EIO);
+            goto fail_after_begin;
+        }
+
+        vas = vaEndPicture(ctx->hwctx->display, ctx->va_context);
+        if (vas != VA_STATUS_SUCCESS) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to start picture processing: "
+                   "%d (%s).\n", vas, vaErrorStr(vas));
+            err = AVERROR(EIO);
+            goto fail_after_render;
+        }
+
+        if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &
+            AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS) {
+            vas = vaDestroyBuffer(ctx->hwctx->display, params_id);
+            if (vas != VA_STATUS_SUCCESS) {
+                av_log(avctx, AV_LOG_ERROR, "Failed to free parameter buffer: "
+                       "%d (%s).\n", vas, vaErrorStr(vas));
+                // And ignore.
+            }
+        }
+
+        err = av_frame_copy_props(output_frame, input_frame);
+        if (err < 0)
+            goto fail;
+
+        if (ctx->field_rate == 2) {
+            if (field == 0)
+                output_frame->pts = 2 * input_frame->pts;
+            else
+                output_frame->pts = input_frame->pts +
+                    ctx->frame_queue[current_frame_index + 1]->pts;
+        }
+        output_frame->interlaced_frame = 0;
+
+        av_log(avctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
+               av_get_pix_fmt_name(output_frame->format),
+               output_frame->width, output_frame->height, output_frame->pts);
+
+        err = ff_filter_frame(outlink, output_frame);
+        if (err < 0)
+            break;
+    }
+
+    return err;
+
+fail_after_begin:
+    vaRenderPicture(ctx->hwctx->display, ctx->va_context, &params_id, 1);
+fail_after_render:
+    vaEndPicture(ctx->hwctx->display, ctx->va_context);
+fail:
+    if (filter_params_addr)
+        vaUnmapBuffer(ctx->hwctx->display, ctx->filter_buffer);
+    av_frame_free(&output_frame);
+    return err;
+}
+
+static av_cold int deint_vaapi_init(AVFilterContext *avctx)
+{
+    DeintVAAPIContext *ctx = avctx->priv;
+
+    ctx->va_config     = VA_INVALID_ID;
+    ctx->va_context    = VA_INVALID_ID;
+    ctx->filter_buffer = VA_INVALID_ID;
+    ctx->valid_ids = 1;
+
+    return 0;
+}
+
+static av_cold void deint_vaapi_uninit(AVFilterContext *avctx)
+{
+    DeintVAAPIContext *ctx = avctx->priv;
+
+    if (ctx->valid_ids)
+        deint_vaapi_pipeline_uninit(avctx);
+
+    av_buffer_unref(&ctx->input_frames_ref);
+    av_buffer_unref(&ctx->output_frames_ref);
+    av_buffer_unref(&ctx->device_ref);
+}
+
+#define OFFSET(x) offsetof(DeintVAAPIContext, x)
+#define FLAGS (AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM)
+static const AVOption deint_vaapi_options[] = {
+    { "mode", "Deinterlacing mode",
+      OFFSET(mode), AV_OPT_TYPE_INT, { .i64 = VAProcDeinterlacingNone },
+      VAProcDeinterlacingNone, VAProcDeinterlacingCount - 1, FLAGS, "mode" },
+    { "default", "Use the highest-numbered (and therefore possibly most advanced) deinterlacing algorithm",
+      0, AV_OPT_TYPE_CONST, { .i64 = VAProcDeinterlacingNone }, .unit = "mode" },
+    { "bob", "Use the bob deinterlacing algorithm",
+      0, AV_OPT_TYPE_CONST, { .i64 = VAProcDeinterlacingBob }, .unit = "mode" },
+    { "weave", "Use the weave deinterlacing algorithm",
+      0, AV_OPT_TYPE_CONST, { .i64 = VAProcDeinterlacingWeave }, .unit = "mode" },
+    { "motion_adaptive", "Use the motion adaptive deinterlacing algorithm",
+      0, AV_OPT_TYPE_CONST, { .i64 = VAProcDeinterlacingMotionAdaptive }, .unit = "mode" },
+    { "motion_compensated", "Use the motion compensated deinterlacing algorithm",
+      0, AV_OPT_TYPE_CONST, { .i64 = VAProcDeinterlacingMotionCompensated }, .unit = "mode" },
+
+    { "rate", "Generate output at frame rate or field rate",
+      OFFSET(field_rate), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 2, FLAGS, "rate" },
+    { "frame", "Output at frame rate (one frame of output for each field-pair)",
+      0, AV_OPT_TYPE_CONST, { .i64 = 1 }, .unit = "rate" },
+    { "field", "Output at field rate (one frame of output for each field)",
+      0, AV_OPT_TYPE_CONST, { .i64 = 2 }, .unit = "rate" },
+
+    { "auto", "Only deinterlace fields, passing frames through unchanged",
+      OFFSET(auto_enable), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
+
+    { NULL },
+};
+
+static const AVClass deint_vaapi_class = {
+    .class_name = "deinterlace_vaapi",
+    .item_name  = av_default_item_name,
+    .option     = deint_vaapi_options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+static const AVFilterPad deint_vaapi_inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = &deint_vaapi_filter_frame,
+        .config_props = &deint_vaapi_config_input,
+    },
+    { NULL }
+};
+
+static const AVFilterPad deint_vaapi_outputs[] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_VIDEO,
+        .config_props = &deint_vaapi_config_output,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_deinterlace_vaapi = {
+    .name           = "deinterlace_vaapi",
+    .description    = NULL_IF_CONFIG_SMALL("Deinterlacing of VAAPI surfaces"),
+    .priv_size      = sizeof(DeintVAAPIContext),
+    .init           = &deint_vaapi_init,
+    .uninit         = &deint_vaapi_uninit,
+    .query_formats  = &deint_vaapi_query_formats,
+    .inputs         = deint_vaapi_inputs,
+    .outputs        = deint_vaapi_outputs,
+    .priv_class     = &deint_vaapi_class,
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_dejudder.c b/mythtv/external/FFmpeg/libavfilter/vf_dejudder.c
index c4d7b6bb6cc..4705cb61218 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_dejudder.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_dejudder.c
@@ -55,7 +55,7 @@
 #include "internal.h"
 #include "video.h"
 
-typedef struct {
+typedef struct DejudderContext {
     const AVClass *class;
     int64_t *ringbuff;
     int i1, i2, i3, i4;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_deshake.c b/mythtv/external/FFmpeg/libavfilter/vf_deshake.c
index 4eae9885c6c..64b48c6d02f 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_deshake.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_deshake.c
@@ -450,7 +450,7 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
     if (CONFIG_OPENCL && deshake->opencl) {
         ret = ff_opencl_deshake_process_inout_buf(link->dst,in, out);
         if (ret < 0)
-            return ret;
+            goto fail;
     }
 
     if (deshake->cx < 0 || deshake->cy < 0 || deshake->cw < 0 || deshake->ch < 0) {
@@ -536,13 +536,16 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
     av_frame_free(&deshake->ref);
 
     if (ret < 0)
-        return ret;
+        goto fail;
 
     // Store the current frame as the reference frame for calculating the
     // motion of the next frame
     deshake->ref = in;
 
     return ff_filter_frame(outlink, out);
+fail:
+    av_frame_free(&out);
+    return ret;
 }
 
 static const AVFilterPad deshake_inputs[] = {
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_despill.c b/mythtv/external/FFmpeg/libavfilter/vf_despill.c
new file mode 100644
index 00000000000..64c27f40609
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_despill.c
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/opt.h"
+#include "libavutil/imgutils.h"
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+typedef struct DespillContext {
+    const AVClass *class;
+
+    int co[4]; /* color offsets rgba */
+
+    int alpha;
+    int type;
+    float spillmix;
+    float spillexpand;
+    float redscale;
+    float greenscale;
+    float bluescale;
+    float brightness;
+} DespillContext;
+
+static int do_despill_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+    DespillContext *s = ctx->priv;
+    AVFrame *frame = arg;
+    const int ro = s->co[0], go = s->co[1], bo = s->co[2], ao = s->co[3];
+    const int slice_start = (frame->height * jobnr) / nb_jobs;
+    const int slice_end = (frame->height * (jobnr + 1)) / nb_jobs;
+    const float brightness = s->brightness;
+    const float redscale = s->redscale;
+    const float greenscale = s->greenscale;
+    const float bluescale = s->bluescale;
+    const float spillmix = s->spillmix;
+    const float factor = (1.f - spillmix) * (1.f - s->spillexpand);
+    float red, green, blue;
+    int x, y;
+
+    for (y = slice_start; y < slice_end; y++) {
+        uint8_t *dst = frame->data[0] + y * frame->linesize[0];
+
+        for (x = 0; x < frame->width; x++) {
+            float spillmap;
+
+            red   = dst[x * 4 + ro] / 255.f;
+            green = dst[x * 4 + go] / 255.f;
+            blue  = dst[x * 4 + bo] / 255.f;
+
+            if (s->type) {
+                spillmap = FFMAX(blue  - (red * spillmix + green * factor), 0.f);
+            } else {
+                spillmap = FFMAX(green - (red * spillmix + blue  * factor), 0.f);
+            }
+
+            red   = FFMAX(red   + spillmap * redscale   + brightness * spillmap, 0.f);
+            green = FFMAX(green + spillmap * greenscale + brightness * spillmap, 0.f);
+            blue  = FFMAX(blue  + spillmap * bluescale  + brightness * spillmap, 0.f);
+
+            dst[x * 4 + ro] = av_clip_uint8(red   * 255);
+            dst[x * 4 + go] = av_clip_uint8(green * 255);
+            dst[x * 4 + bo] = av_clip_uint8(blue  * 255);
+            if (s->alpha) {
+                spillmap = 1.f - spillmap;
+                dst[x * 4 + ao] = av_clip_uint8(spillmap * 255);
+            }
+        }
+    }
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *link, AVFrame *frame)
+{
+    AVFilterContext *ctx = link->dst;
+    int ret;
+
+    if (ret = av_frame_make_writable(frame))
+        return ret;
+
+    if (ret = ctx->internal->execute(ctx, do_despill_slice, frame, NULL, FFMIN(frame->height, ff_filter_get_nb_threads(ctx))))
+        return ret;
+
+    return ff_filter_frame(ctx->outputs[0], frame);
+}
+
+static av_cold int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    DespillContext *s = ctx->priv;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
+    int i;
+
+    for (i = 0; i < 4; ++i)
+        s->co[i] = desc->comp[i].offset;
+
+    return 0;
+}
+
+static av_cold int query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pixel_fmts[] = {
+        AV_PIX_FMT_ARGB,
+        AV_PIX_FMT_RGBA,
+        AV_PIX_FMT_ABGR,
+        AV_PIX_FMT_BGRA,
+        AV_PIX_FMT_NONE
+    };
+    AVFilterFormats *formats = NULL;
+
+    formats = ff_make_format_list(pixel_fmts);
+    if (!formats)
+        return AVERROR(ENOMEM);
+
+    return ff_set_common_formats(ctx, formats);
+}
+
+static const AVFilterPad despill_inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = filter_frame,
+    },
+    { NULL }
+};
+
+static const AVFilterPad despill_outputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = config_output,
+    },
+    { NULL }
+};
+
+#define OFFSET(x) offsetof(DespillContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption despill_options[] = {
+    { "type",       "set the screen type",     OFFSET(type),        AV_OPT_TYPE_INT,     {.i64=0},     0,   1, FLAGS, "type" },
+    {   "green",    "greenscreen",             0,                   AV_OPT_TYPE_CONST,   {.i64=0},     0,   0, FLAGS, "type" },
+    {   "blue",     "bluescreen",              0,                   AV_OPT_TYPE_CONST,   {.i64=1},     0,   0, FLAGS, "type" },
+    { "mix",        "set the spillmap mix",    OFFSET(spillmix),    AV_OPT_TYPE_FLOAT,   {.dbl=0.5},   0,   1, FLAGS },
+    { "expand",     "set the spillmap expand", OFFSET(spillexpand), AV_OPT_TYPE_FLOAT,   {.dbl=0},     0,   1, FLAGS },
+    { "red",        "set red scale",           OFFSET(redscale),    AV_OPT_TYPE_FLOAT,   {.dbl=0},  -100, 100, FLAGS },
+    { "green",      "set green scale",         OFFSET(greenscale),  AV_OPT_TYPE_FLOAT,   {.dbl=-1}, -100, 100, FLAGS },
+    { "blue",       "set blue scale",          OFFSET(bluescale),   AV_OPT_TYPE_FLOAT,   {.dbl=0},  -100, 100, FLAGS },
+    { "brightness", "set brightness",          OFFSET(brightness),  AV_OPT_TYPE_FLOAT,   {.dbl=0},   -10,  10, FLAGS },
+    { "alpha",      "change alpha component",  OFFSET(alpha),       AV_OPT_TYPE_BOOL,    {.i64=0},     0,   1, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(despill);
+
+AVFilter ff_vf_despill = {
+    .name          = "despill",
+    .description   = NULL_IF_CONFIG_SMALL("Despill video."),
+    .priv_size     = sizeof(DespillContext),
+    .priv_class    = &despill_class,
+    .query_formats = query_formats,
+    .inputs        = despill_inputs,
+    .outputs       = despill_outputs,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_detelecine.c b/mythtv/external/FFmpeg/libavfilter/vf_detelecine.c
index 9a7b4621999..0d1e2f2ffbb 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_detelecine.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_detelecine.c
@@ -32,7 +32,7 @@
 #include "internal.h"
 #include "video.h"
 
-typedef struct {
+typedef struct DetelecineContext {
     const AVClass *class;
     int first_field;
     char *pattern;
@@ -335,7 +335,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
 
         av_frame_copy_props(frame, inpicref);
         frame->pts = ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time) +
-                     av_rescale(outlink->frame_count, s->ts_unit.num,
+                     av_rescale(outlink->frame_count_in, s->ts_unit.num,
                                 s->ts_unit.den);
         ret = ff_filter_frame(outlink, frame);
     }
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_displace.c b/mythtv/external/FFmpeg/libavfilter/vf_displace.c
index 9daa0c9ddba..768af6def47 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_displace.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_displace.c
@@ -31,6 +31,7 @@ enum EdgeMode {
     EDGE_BLANK,
     EDGE_SMEAR,
     EDGE_WRAP,
+    EDGE_MIRROR,
     EDGE_NB
 };
 
@@ -53,9 +54,10 @@ typedef struct DisplaceContext {
 
 static const AVOption displace_options[] = {
     { "edge", "set edge mode", OFFSET(edge), AV_OPT_TYPE_INT, {.i64=EDGE_SMEAR}, 0, EDGE_NB-1, FLAGS, "edge" },
-    {   "blank", "", 0, AV_OPT_TYPE_CONST, {.i64=EDGE_BLANK}, 0, 0, FLAGS, "edge" },
-    {   "smear", "", 0, AV_OPT_TYPE_CONST, {.i64=EDGE_SMEAR}, 0, 0, FLAGS, "edge" },
-    {   "wrap" , "", 0, AV_OPT_TYPE_CONST, {.i64=EDGE_WRAP},  0, 0, FLAGS, "edge" },
+    {   "blank",   "", 0, AV_OPT_TYPE_CONST, {.i64=EDGE_BLANK},  0, 0, FLAGS, "edge" },
+    {   "smear",   "", 0, AV_OPT_TYPE_CONST, {.i64=EDGE_SMEAR},  0, 0, FLAGS, "edge" },
+    {   "wrap" ,   "", 0, AV_OPT_TYPE_CONST, {.i64=EDGE_WRAP},   0, 0, FLAGS, "edge" },
+    {   "mirror" , "", 0, AV_OPT_TYPE_CONST, {.i64=EDGE_MIRROR}, 0, 0, FLAGS, "edge" },
     { NULL }
 };
 
@@ -130,6 +132,22 @@ static void displace_planar(DisplaceContext *s, const AVFrame *in,
                     dst[x] = src[Y * slinesize + X];
                 }
                 break;
+            case EDGE_MIRROR:
+                for (x = 0; x < w; x++) {
+                    int Y = y + ysrc[x] - 128;
+                    int X = x + xsrc[x] - 128;
+
+                    if (Y < 0)
+                        Y = (-Y) % h;
+                    if (X < 0)
+                        X = (-X) % w;
+                    if (Y >= h)
+                        Y = h - (Y % h) - 1;
+                    if (X >= w)
+                        X = w - (X % w) - 1;
+                    dst[x] = src[Y * slinesize + X];
+                }
+                break;
             }
 
             ysrc += ylinesize;
@@ -196,6 +214,24 @@ static void displace_packed(DisplaceContext *s, const AVFrame *in,
                 }
             }
             break;
+        case EDGE_MIRROR:
+            for (x = 0; x < w; x++) {
+                for (c = 0; c < s->nb_components; c++) {
+                    int Y = y + ysrc[x * step + c] - 128;
+                    int X = x + xsrc[x * step + c] - 128;
+
+                    if (Y < 0)
+                        Y = (-Y) % h;
+                    if (X < 0)
+                        X = (-X) % w;
+                    if (Y >= h)
+                        Y = h - (Y % h) - 1;
+                    if (X >= w)
+                        X = w - (X % w) - 1;
+                    dst[x * step + c] = src[Y * slinesize + X * step + c];
+                }
+            }
+            break;
         }
 
         ysrc += ylinesize;
@@ -280,27 +316,17 @@ static int config_output(AVFilterLink *outlink)
         av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
         return AVERROR(EINVAL);
     }
-    if (srclink->w                       != xlink->w ||
-        srclink->h                       != xlink->h ||
-        srclink->sample_aspect_ratio.num != xlink->sample_aspect_ratio.num ||
-        srclink->sample_aspect_ratio.den != xlink->sample_aspect_ratio.den ||
-        srclink->w                       != ylink->w ||
-        srclink->h                       != ylink->h ||
-        srclink->sample_aspect_ratio.num != ylink->sample_aspect_ratio.num ||
-        srclink->sample_aspect_ratio.den != ylink->sample_aspect_ratio.den) {
+    if (srclink->w != xlink->w ||
+        srclink->h != xlink->h ||
+        srclink->w != ylink->w ||
+        srclink->h != ylink->h) {
         av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
-               "(size %dx%d, SAR %d:%d) do not match the corresponding "
-               "second input link %s parameters (%dx%d, SAR %d:%d) "
-               "and/or third input link %s parameters (%dx%d, SAR %d:%d)\n",
+               "(size %dx%d) do not match the corresponding "
+               "second input link %s parameters (%dx%d) "
+               "and/or third input link %s parameters (%dx%d)\n",
                ctx->input_pads[0].name, srclink->w, srclink->h,
-               srclink->sample_aspect_ratio.num,
-               srclink->sample_aspect_ratio.den,
                ctx->input_pads[1].name, xlink->w, xlink->h,
-               xlink->sample_aspect_ratio.num,
-               xlink->sample_aspect_ratio.den,
-               ctx->input_pads[2].name, ylink->w, ylink->h,
-               ylink->sample_aspect_ratio.num,
-               ylink->sample_aspect_ratio.den);
+               ctx->input_pads[2].name, ylink->w, ylink->h);
         return AVERROR(EINVAL);
     }
 
@@ -333,16 +359,10 @@ static int config_output(AVFilterLink *outlink)
     return ff_framesync_configure(&s->fs);
 }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
+static int activate(AVFilterContext *ctx)
 {
-    DisplaceContext *s = inlink->dst->priv;
-    return ff_framesync_filter_frame(&s->fs, inlink, buf);
-}
-
-static int request_frame(AVFilterLink *outlink)
-{
-    DisplaceContext *s = outlink->src->priv;
-    return ff_framesync_request_frame(&s->fs, outlink);
+    DisplaceContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
@@ -356,18 +376,15 @@ static const AVFilterPad displace_inputs[] = {
     {
         .name         = "source",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
         .config_props = config_input,
     },
     {
         .name         = "xmap",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },
     {
         .name         = "ymap",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },
     { NULL }
 };
@@ -377,7 +394,6 @@ static const AVFilterPad displace_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -388,6 +404,7 @@ AVFilter ff_vf_displace = {
     .priv_size     = sizeof(DisplaceContext),
     .uninit        = uninit,
     .query_formats = query_formats,
+    .activate      = activate,
     .inputs        = displace_inputs,
     .outputs       = displace_outputs,
     .priv_class    = &displace_class,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_drawtext.c b/mythtv/external/FFmpeg/libavfilter/vf_drawtext.c
index 65d3baafefa..f6151443bbb 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_drawtext.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_drawtext.c
@@ -156,8 +156,12 @@ typedef struct DrawTextContext {
     int max_glyph_h;                ///< max glyph height
     int shadowx, shadowy;
     int borderw;                    ///< border width
+    char *fontsize_expr;            ///< expression for fontsize
+    AVExpr *fontsize_pexpr;         ///< parsed expressions for fontsize
     unsigned int fontsize;          ///< font size to use
+    unsigned int default_fontsize;  ///< default font size to use
 
+    int line_spacing;               ///< lines spacing in pixels
     short int draw_box;             ///< draw box around text - true or false
     int boxborderw;                 ///< box border width
     int use_kerning;                ///< font kerning is used - true/false
@@ -209,7 +213,8 @@ static const AVOption drawtext_options[]= {
     {"shadowcolor", "set shadow color",     OFFSET(shadowcolor.rgba),   AV_OPT_TYPE_COLOR,  {.str="black"}, CHAR_MIN, CHAR_MAX, FLAGS},
     {"box",         "set box",              OFFSET(draw_box),           AV_OPT_TYPE_BOOL,   {.i64=0},     0,        1       , FLAGS},
     {"boxborderw",  "set box border width", OFFSET(boxborderw),         AV_OPT_TYPE_INT,    {.i64=0},     INT_MIN,  INT_MAX , FLAGS},
-    {"fontsize",    "set font size",        OFFSET(fontsize),           AV_OPT_TYPE_INT,    {.i64=0},     0,        INT_MAX , FLAGS},
+    {"line_spacing",  "set line spacing in pixels", OFFSET(line_spacing),   AV_OPT_TYPE_INT,    {.i64=0},     INT_MIN,  INT_MAX,FLAGS},
+    {"fontsize",    "set font size",        OFFSET(fontsize_expr),      AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX , FLAGS},
     {"x",           "set x expression",     OFFSET(x_expr),             AV_OPT_TYPE_STRING, {.str="0"},   CHAR_MIN, CHAR_MAX, FLAGS},
     {"y",           "set y expression",     OFFSET(y_expr),             AV_OPT_TYPE_STRING, {.str="0"},   CHAR_MIN, CHAR_MAX, FLAGS},
     {"shadowx",     "set shadow x offset",  OFFSET(shadowx),            AV_OPT_TYPE_INT,    {.i64=0},     INT_MIN,  INT_MAX , FLAGS},
@@ -267,8 +272,7 @@ AVFILTER_DEFINE_CLASS(drawtext);
 #define FT_ERRORDEF(e, v, s) { (e), (s) },
 #define FT_ERROR_END_LIST { 0, NULL } };
 
-static const struct ft_error
-{
+static const struct ft_error {
     int err;
     const char *err_msg;
 } ft_errors[] =
@@ -280,6 +284,7 @@ typedef struct Glyph {
     FT_Glyph glyph;
     FT_Glyph border_glyph;
     uint32_t code;
+    unsigned int fontsize;
     FT_Bitmap bitmap; ///< array holding bitmaps of font
     FT_Bitmap border_bitmap; ///< array holding bitmaps of font border
     FT_BBox bbox;
@@ -292,7 +297,11 @@ static int glyph_cmp(const void *key, const void *b)
 {
     const Glyph *a = key, *bb = b;
     int64_t diff = (int64_t)a->code - (int64_t)bb->code;
-    return diff > 0 ? 1 : diff < 0 ? -1 : 0;
+
+    if (diff != 0)
+         return diff > 0 ? 1 : -1;
+    else
+         return FFDIFFSIGN((int64_t)a->fontsize, (int64_t)bb->fontsize);
 }
 
 /**
@@ -316,6 +325,7 @@ static int load_glyph(AVFilterContext *ctx, Glyph **glyph_ptr, uint32_t code)
         goto error;
     }
     glyph->code  = code;
+    glyph->fontsize = s->fontsize;
 
     if (FT_Get_Glyph(s->face->glyph, &glyph->glyph)) {
         ret = AVERROR(EINVAL);
@@ -365,6 +375,76 @@ static int load_glyph(AVFilterContext *ctx, Glyph **glyph_ptr, uint32_t code)
     return ret;
 }
 
+static av_cold int set_fontsize(AVFilterContext *ctx, unsigned int fontsize)
+{
+    int err;
+    DrawTextContext *s = ctx->priv;
+
+    if ((err = FT_Set_Pixel_Sizes(s->face, 0, fontsize))) {
+        av_log(ctx, AV_LOG_ERROR, "Could not set font size to %d pixels: %s\n",
+               fontsize, FT_ERRMSG(err));
+        return AVERROR(EINVAL);
+    }
+
+    s->fontsize = fontsize;
+
+    return 0;
+}
+
+static av_cold int parse_fontsize(AVFilterContext *ctx)
+{
+    DrawTextContext *s = ctx->priv;
+    int err;
+
+    if (s->fontsize_pexpr)
+        return 0;
+
+    if (s->fontsize_expr == NULL)
+        return AVERROR(EINVAL);
+
+    if ((err = av_expr_parse(&s->fontsize_pexpr, s->fontsize_expr, var_names,
+                             NULL, NULL, fun2_names, fun2, 0, ctx)) < 0)
+        return err;
+
+    return 0;
+}
+
+static av_cold int update_fontsize(AVFilterContext *ctx)
+{
+    DrawTextContext *s = ctx->priv;
+    unsigned int fontsize = s->default_fontsize;
+    int err;
+    double size, roundedsize;
+
+    // if no fontsize specified use the default
+    if (s->fontsize_expr != NULL) {
+        if ((err = parse_fontsize(ctx)) < 0)
+           return err;
+
+        size = av_expr_eval(s->fontsize_pexpr, s->var_values, &s->prng);
+
+        if (!isnan(size)) {
+            roundedsize = round(size);
+            // test for overflow before cast
+            if (!(roundedsize > INT_MIN && roundedsize < INT_MAX)) {
+                av_log(ctx, AV_LOG_ERROR, "fontsize overflow\n");
+                return AVERROR(EINVAL);
+            }
+
+            fontsize = roundedsize;
+        }
+    }
+
+    if (fontsize == 0)
+        fontsize = 1;
+
+    // no change
+    if (fontsize == s->fontsize)
+        return 0;
+
+    return set_fontsize(ctx, fontsize);
+}
+
 static int load_font_file(AVFilterContext *ctx, const char *path, int index)
 {
     DrawTextContext *s = ctx->priv;
@@ -392,6 +472,7 @@ static int load_font_fontconfig(AVFilterContext *ctx)
     int index;
     double size;
     int err = AVERROR(ENOENT);
+    int parse_err;
 
     fontconfig = FcInitLoadConfigAndFonts();
     if (!fontconfig) {
@@ -406,8 +487,18 @@ static int load_font_fontconfig(AVFilterContext *ctx)
     }
 
     FcPatternAddString(pat, FC_FAMILY, s->font);
-    if (s->fontsize)
-        FcPatternAddDouble(pat, FC_SIZE, (double)s->fontsize);
+
+    parse_err = parse_fontsize(ctx);
+    if (!parse_err) {
+        double size = av_expr_eval(s->fontsize_pexpr, s->var_values, &s->prng);
+
+        if (isnan(size)) {
+            av_log(ctx, AV_LOG_ERROR, "impossible to find font information");
+            return AVERROR(EINVAL);
+        }
+
+        FcPatternAddDouble(pat, FC_SIZE, size);
+    }
 
     FcDefaultSubstitute(pat);
 
@@ -441,8 +532,8 @@ static int load_font_fontconfig(AVFilterContext *ctx)
     }
 
     av_log(ctx, AV_LOG_INFO, "Using \"%s\"\n", filename);
-    if (!s->fontsize)
-        s->fontsize = size + 0.5;
+    if (parse_err)
+        s->default_fontsize = size + 0.5;
 
     err = load_font_file(ctx, filename, index);
     if (err)
@@ -597,6 +688,12 @@ static av_cold int init(AVFilterContext *ctx)
     DrawTextContext *s = ctx->priv;
     Glyph *glyph;
 
+    av_expr_free(s->fontsize_pexpr);
+    s->fontsize_pexpr = NULL;
+
+    s->fontsize = 0;
+    s->default_fontsize = 16;
+
     if (!s->fontfile && !CONFIG_LIBFONTCONFIG) {
         av_log(ctx, AV_LOG_ERROR, "No font filename provided\n");
         return AVERROR(EINVAL);
@@ -644,16 +741,11 @@ static av_cold int init(AVFilterContext *ctx)
         return AVERROR(EINVAL);
     }
 
-    err = load_font(ctx);
-    if (err)
+    if ((err = load_font(ctx)) < 0)
+        return err;
+
+    if ((err = update_fontsize(ctx)) < 0)
         return err;
-    if (!s->fontsize)
-        s->fontsize = 16;
-    if ((err = FT_Set_Pixel_Sizes(s->face, 0, s->fontsize))) {
-        av_log(ctx, AV_LOG_ERROR, "Could not set font size to %d pixels: %s\n",
-               s->fontsize, FT_ERRMSG(err));
-        return AVERROR(EINVAL);
-    }
 
     if (s->borderw) {
         if (FT_Stroker_New(s->library, &s->stroker)) {
@@ -707,11 +799,14 @@ static av_cold void uninit(AVFilterContext *ctx)
 
     av_expr_free(s->x_pexpr);
     av_expr_free(s->y_pexpr);
-    s->x_pexpr = s->y_pexpr = NULL;
+    av_expr_free(s->a_pexpr);
+    av_expr_free(s->fontsize_pexpr);
+
+    s->x_pexpr = s->y_pexpr = s->a_pexpr = s->fontsize_pexpr = NULL;
+
     av_freep(&s->positions);
     s->nb_positions = 0;
 
-
     av_tree_enumerate(s->glyphs, NULL, NULL, glyph_enu_free);
     av_tree_destroy(s->glyphs);
     s->glyphs = NULL;
@@ -750,7 +845,8 @@ static int config_input(AVFilterLink *inlink)
 
     av_expr_free(s->x_pexpr);
     av_expr_free(s->y_pexpr);
-    s->x_pexpr = s->y_pexpr = NULL;
+    av_expr_free(s->a_pexpr);
+    s->x_pexpr = s->y_pexpr = s->a_pexpr = NULL;
 
     if ((ret = av_expr_parse(&s->x_pexpr, s->x_expr, var_names,
                              NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||
@@ -809,7 +905,7 @@ static int func_pts(AVFilterContext *ctx, AVBPrint *bp,
         pts += (double)delta / AV_TIME_BASE;
     }
     if (!strcmp(fmt, "flt")) {
-        av_bprintf(bp, "%.6f", s->var_values[VAR_T]);
+        av_bprintf(bp, "%.6f", pts);
     } else if (!strcmp(fmt, "hms")) {
         if (isnan(pts)) {
             av_bprintf(bp, " ??:??:??.???");
@@ -1091,6 +1187,7 @@ static int draw_glyphs(DrawTextContext *s, AVFrame *frame,
             continue;
 
         dummy.code = code;
+        dummy.fontsize = s->fontsize;
         glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
 
         bitmap = borderw ? glyph->border_bitmap : glyph->bitmap;
@@ -1184,7 +1281,7 @@ static int draw_text(AVFilterContext *ctx, AVFrame *frame,
 
     if (s->tc_opt_string) {
         char tcbuf[AV_TIMECODE_STR_SIZE];
-        av_timecode_make_string(&s->tc, tcbuf, inlink->frame_count);
+        av_timecode_make_string(&s->tc, tcbuf, inlink->frame_count_out);
         av_bprint_clear(bp);
         av_bprintf(bp, "%s%s", s->text, tcbuf);
     }
@@ -1216,12 +1313,16 @@ static int draw_text(AVFilterContext *ctx, AVFrame *frame,
     x = 0;
     y = 0;
 
+    if ((ret = update_fontsize(ctx)) < 0)
+        return ret;
+
     /* load and cache glyphs */
     for (i = 0, p = text; *p; i++) {
         GET_UTF8(code, *p++, continue;);
 
         /* get glyph */
         dummy.code = code;
+        dummy.fontsize = s->fontsize;
         glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
         if (!glyph) {
             ret = load_glyph(ctx, &glyph, code);
@@ -1250,7 +1351,7 @@ static int draw_text(AVFilterContext *ctx, AVFrame *frame,
         if (is_newline(code)) {
 
             max_text_line_w = FFMAX(max_text_line_w, x);
-            y += s->max_glyph_h;
+            y += s->max_glyph_h + s->line_spacing;
             x = 0;
             continue;
         }
@@ -1258,6 +1359,7 @@ static int draw_text(AVFilterContext *ctx, AVFrame *frame,
         /* get glyph */
         prev_glyph = glyph;
         dummy.code = code;
+        dummy.fontsize = s->fontsize;
         glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
 
         /* kerning */
@@ -1345,12 +1447,12 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
 #endif
     }
 
-    s->var_values[VAR_N] = inlink->frame_count+s->start_number;
+    s->var_values[VAR_N] = inlink->frame_count_out + s->start_number;
     s->var_values[VAR_T] = frame->pts == AV_NOPTS_VALUE ?
         NAN : frame->pts * av_q2d(inlink->time_base);
 
     s->var_values[VAR_PICT_TYPE] = frame->pict_type;
-    s->metadata = av_frame_get_metadata(frame);
+    s->metadata = frame->metadata;
 
     draw_text(ctx, frame, frame->width, frame->height);
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_edgedetect.c b/mythtv/external/FFmpeg/libavfilter/vf_edgedetect.c
index ac88e02a11b..173f9fe161a 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_edgedetect.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_edgedetect.c
@@ -44,7 +44,7 @@ struct plane_info {
     char     *directions;
 };
 
-typedef struct {
+typedef struct EdgeDetectContext {
     const AVClass *class;
     struct plane_info planes[3];
     int nb_planes;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_eq.c b/mythtv/external/FFmpeg/libavfilter/vf_eq.c
index 5ecdb31bcd4..2c4c7e4d544 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_eq.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_eq.c
@@ -254,18 +254,20 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     AVFilterLink *outlink = inlink->dst->outputs[0];
     EQContext *eq = ctx->priv;
     AVFrame *out;
-    int64_t pos = av_frame_get_pkt_pos(in);
+    int64_t pos = in->pkt_pos;
     const AVPixFmtDescriptor *desc;
     int i;
 
     out = ff_get_video_buffer(outlink, inlink->w, inlink->h);
-    if (!out)
+    if (!out) {
+        av_frame_free(&in);
         return AVERROR(ENOMEM);
+    }
 
     av_frame_copy_props(out, in);
     desc = av_pix_fmt_desc_get(inlink->format);
 
-    eq->var_values[VAR_N]   = inlink->frame_count;
+    eq->var_values[VAR_N]   = inlink->frame_count_out;
     eq->var_values[VAR_POS] = pos == -1 ? NAN : pos;
     eq->var_values[VAR_T]   = TS2T(in->pts, inlink->time_base);
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_eq.h b/mythtv/external/FFmpeg/libavfilter/vf_eq.h
index 8525048b3fc..fa49d46e5cf 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_eq.h
+++ b/mythtv/external/FFmpeg/libavfilter/vf_eq.h
@@ -55,7 +55,7 @@ typedef struct EQParameters {
 
 } EQParameters;
 
-typedef struct {
+typedef struct EQContext {
     const AVClass *class;
 
     EQParameters param[3];
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_extractplanes.c b/mythtv/external/FFmpeg/libavfilter/vf_extractplanes.c
index a23f838ac6d..fc676a25fae 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_extractplanes.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_extractplanes.c
@@ -22,6 +22,10 @@
 #include "libavutil/imgutils.h"
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
+
+#define FF_INTERNAL_FIELDS 1
+#include "libavfilter/framequeue.h"
+
 #include "avfilter.h"
 #include "drawutils.h"
 #include "internal.h"
@@ -34,7 +38,7 @@
 #define PLANE_U 0x20
 #define PLANE_V 0x40
 
-typedef struct {
+typedef struct ExtractPlanesContext {
     const AVClass *class;
     int requested_planes;
     int map[4];
@@ -86,6 +90,26 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_RGBA64LE, AV_PIX_FMT_BGRA64LE,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
         AV_PIX_FMT_GBRP16LE, AV_PIX_FMT_GBRAP16LE,
+        AV_PIX_FMT_YUV420P10LE,
+        AV_PIX_FMT_YUV422P10LE,
+        AV_PIX_FMT_YUV444P10LE,
+        AV_PIX_FMT_YUV440P10LE,
+        AV_PIX_FMT_YUVA420P10LE,
+        AV_PIX_FMT_YUVA422P10LE,
+        AV_PIX_FMT_YUVA444P10LE,
+        AV_PIX_FMT_YUV420P12LE,
+        AV_PIX_FMT_YUV422P12LE,
+        AV_PIX_FMT_YUV444P12LE,
+        AV_PIX_FMT_YUV440P12LE,
+        AV_PIX_FMT_GBRP10LE, AV_PIX_FMT_GBRAP10LE,
+        AV_PIX_FMT_GBRP12LE, AV_PIX_FMT_GBRAP12LE,
+        AV_PIX_FMT_YUV420P9LE,
+        AV_PIX_FMT_YUV422P9LE,
+        AV_PIX_FMT_YUV444P9LE,
+        AV_PIX_FMT_YUVA420P9LE,
+        AV_PIX_FMT_YUVA422P9LE,
+        AV_PIX_FMT_YUVA444P9LE,
+        AV_PIX_FMT_GBRP9LE,
         AV_PIX_FMT_NONE,
     };
     static const enum AVPixelFormat in_pixfmts_be[] = {
@@ -112,9 +136,35 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_RGBA64BE, AV_PIX_FMT_BGRA64BE,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
         AV_PIX_FMT_GBRP16BE, AV_PIX_FMT_GBRAP16BE,
+        AV_PIX_FMT_YUV420P10BE,
+        AV_PIX_FMT_YUV422P10BE,
+        AV_PIX_FMT_YUV444P10BE,
+        AV_PIX_FMT_YUV440P10BE,
+        AV_PIX_FMT_YUVA420P10BE,
+        AV_PIX_FMT_YUVA422P10BE,
+        AV_PIX_FMT_YUVA444P10BE,
+        AV_PIX_FMT_YUV420P12BE,
+        AV_PIX_FMT_YUV422P12BE,
+        AV_PIX_FMT_YUV444P12BE,
+        AV_PIX_FMT_YUV440P12BE,
+        AV_PIX_FMT_GBRP10BE, AV_PIX_FMT_GBRAP10BE,
+        AV_PIX_FMT_GBRP12BE, AV_PIX_FMT_GBRAP12BE,
+        AV_PIX_FMT_YUV420P9BE,
+        AV_PIX_FMT_YUV422P9BE,
+        AV_PIX_FMT_YUV444P9BE,
+        AV_PIX_FMT_YUVA420P9BE,
+        AV_PIX_FMT_YUVA422P9BE,
+        AV_PIX_FMT_YUVA444P9BE,
+        AV_PIX_FMT_GBRP9BE,
         AV_PIX_FMT_NONE,
     };
     static const enum AVPixelFormat out8_pixfmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
+    static const enum AVPixelFormat out9le_pixfmts[] = { AV_PIX_FMT_GRAY9LE, AV_PIX_FMT_NONE };
+    static const enum AVPixelFormat out9be_pixfmts[] = { AV_PIX_FMT_GRAY9BE, AV_PIX_FMT_NONE };
+    static const enum AVPixelFormat out10le_pixfmts[] = { AV_PIX_FMT_GRAY10LE, AV_PIX_FMT_NONE };
+    static const enum AVPixelFormat out10be_pixfmts[] = { AV_PIX_FMT_GRAY10BE, AV_PIX_FMT_NONE };
+    static const enum AVPixelFormat out12le_pixfmts[] = { AV_PIX_FMT_GRAY12LE, AV_PIX_FMT_NONE };
+    static const enum AVPixelFormat out12be_pixfmts[] = { AV_PIX_FMT_GRAY12BE, AV_PIX_FMT_NONE };
     static const enum AVPixelFormat out16le_pixfmts[] = { AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_NONE };
     static const enum AVPixelFormat out16be_pixfmts[] = { AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_NONE };
     const enum AVPixelFormat *out_pixfmts, *in_pixfmts;
@@ -150,6 +200,18 @@ static int query_formats(AVFilterContext *ctx)
 
     if (depth == 8)
         out_pixfmts = out8_pixfmts;
+    else if (!be && depth == 9)
+        out_pixfmts = out9le_pixfmts;
+    else if (be && depth == 9)
+        out_pixfmts = out9be_pixfmts;
+    else if (!be && depth == 10)
+        out_pixfmts = out10le_pixfmts;
+    else if (be && depth == 10)
+        out_pixfmts = out10be_pixfmts;
+    else if (!be && depth == 12)
+        out_pixfmts = out12le_pixfmts;
+    else if (be && depth == 12)
+        out_pixfmts = out12be_pixfmts;
     else if (be)
         out_pixfmts = out16be_pixfmts;
     else
@@ -245,7 +307,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
         const int idx = s->map[i];
         AVFrame *out;
 
-        if (outlink->status)
+        if (outlink->status_in)
             continue;
 
         out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
@@ -286,7 +348,7 @@ static av_cold int init(AVFilterContext *ctx)
 {
     ExtractPlanesContext *s = ctx->priv;
     int planes = (s->requested_planes & 0xf) | (s->requested_planes >> 4);
-    int i;
+    int i, ret;
 
     for (i = 0; i < 4; i++) {
         char *name;
@@ -303,7 +365,10 @@ static av_cold int init(AVFilterContext *ctx)
         pad.type = AVMEDIA_TYPE_VIDEO;
         pad.config_props = config_output;
 
-        ff_insert_outpad(ctx, ctx->nb_outputs, &pad);
+        if ((ret = ff_insert_outpad(ctx, ctx->nb_outputs, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
     }
 
     return 0;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_fade.c b/mythtv/external/FFmpeg/libavfilter/vf_fade.c
index 0496645c97d..c30c41db0da 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_fade.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_fade.c
@@ -300,7 +300,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     if (s->fade_state == VF_FADE_WAITING) {
         s->factor=0;
         if (frame_timestamp >= s->start_time/(double)AV_TIME_BASE
-            && inlink->frame_count >= s->start_frame) {
+            && inlink->frame_count_out >= s->start_frame) {
             // Time to start fading
             s->fade_state = VF_FADE_FADING;
 
@@ -311,15 +311,15 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
 
             // Save start frame in case we are starting based on time and fading based on frames
             if (s->start_time != 0 && s->start_frame == 0) {
-                s->start_frame = inlink->frame_count;
+                s->start_frame = inlink->frame_count_out;
             }
         }
     }
     if (s->fade_state == VF_FADE_FADING) {
         if (s->duration == 0) {
             // Fading based on frame count
-            s->factor = (inlink->frame_count - s->start_frame) * s->fade_per_frame;
-            if (inlink->frame_count > s->start_frame + s->nb_frames) {
+            s->factor = (inlink->frame_count_out - s->start_frame) * s->fade_per_frame;
+            if (inlink->frame_count_out > s->start_frame + s->nb_frames) {
                 s->fade_state = VF_FADE_DONE;
             }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_fftfilt.c b/mythtv/external/FFmpeg/libavfilter/vf_fftfilt.c
index 307b41a7338..7f60ca1f87b 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_fftfilt.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_fftfilt.c
@@ -33,10 +33,25 @@
 
 #define MAX_PLANES 4
 
-typedef struct {
+enum EvalMode {
+    EVAL_MODE_INIT,
+    EVAL_MODE_FRAME,
+    EVAL_MODE_NB
+};
+
+typedef struct FFTFILTContext {
     const AVClass *class;
 
-    RDFTContext *rdft;
+    int eval_mode;
+    int depth;
+    int nb_planes;
+    int planewidth[MAX_PLANES];
+    int planeheight[MAX_PLANES];
+
+    RDFTContext *hrdft[MAX_PLANES];
+    RDFTContext *vrdft[MAX_PLANES];
+    RDFTContext *ihrdft[MAX_PLANES];
+    RDFTContext *ivrdft[MAX_PLANES];
     int rdft_hbits[MAX_PLANES];
     int rdft_vbits[MAX_PLANES];
     size_t rdft_hlen[MAX_PLANES];
@@ -51,8 +66,8 @@ typedef struct {
 
 } FFTFILTContext;
 
-static const char *const var_names[] = {   "X",   "Y",   "W",   "H",     NULL    };
-enum                                   { VAR_X, VAR_Y, VAR_W, VAR_H, VAR_VARS_NB };
+static const char *const var_names[] = {   "X",   "Y",   "W",   "H",   "N", NULL        };
+enum                                   { VAR_X, VAR_Y, VAR_W, VAR_H, VAR_N, VAR_VARS_NB };
 
 enum { Y = 0, U, V };
 
@@ -66,6 +81,9 @@ static const AVOption fftfilt_options[] = {
     { "weight_Y", "set luminance expression in Y plane",   OFFSET(weight_str[Y]), AV_OPT_TYPE_STRING, {.str = "1"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "weight_U", "set chrominance expression in U plane", OFFSET(weight_str[U]), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "weight_V", "set chrominance expression in V plane", OFFSET(weight_str[V]), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS },
+    { "eval", "specify when to evaluate expressions", OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_INIT}, 0, EVAL_MODE_NB-1, FLAGS, "eval" },
+         { "init",  "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT},  .flags = FLAGS, .unit = "eval" },
+         { "frame", "eval expressions per-frame",                  0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },
     {NULL},
 };
 
@@ -96,7 +114,6 @@ static void copy_rev (FFTSample *dest, int w, int w2)
 static void rdft_horizontal(FFTFILTContext *s, AVFrame *in, int w, int h, int plane)
 {
     int i, j;
-    s->rdft = av_rdft_init(s->rdft_hbits[plane], DFT_R2C);
 
     for (i = 0; i < h; i++) {
         for (j = 0; j < w; j++)
@@ -106,16 +123,13 @@ static void rdft_horizontal(FFTFILTContext *s, AVFrame *in, int w, int h, int pl
     }
 
     for (i = 0; i < h; i++)
-        av_rdft_calc(s->rdft, s->rdft_hdata[plane] + i * s->rdft_hlen[plane]);
-
-    av_rdft_end(s->rdft);
+        av_rdft_calc(s->hrdft[plane], s->rdft_hdata[plane] + i * s->rdft_hlen[plane]);
 }
 
 /*Vertical pass - RDFT*/
 static void rdft_vertical(FFTFILTContext *s, int h, int plane)
 {
     int i, j;
-    s->rdft = av_rdft_init(s->rdft_vbits[plane], DFT_R2C);
 
     for (i = 0; i < s->rdft_hlen[plane]; i++) {
         for (j = 0; j < h; j++)
@@ -125,33 +139,29 @@ static void rdft_vertical(FFTFILTContext *s, int h, int plane)
     }
 
     for (i = 0; i < s->rdft_hlen[plane]; i++)
-        av_rdft_calc(s->rdft, s->rdft_vdata[plane] + i * s->rdft_vlen[plane]);
-
-    av_rdft_end(s->rdft);
+        av_rdft_calc(s->vrdft[plane], s->rdft_vdata[plane] + i * s->rdft_vlen[plane]);
 }
 /*Vertical pass - IRDFT*/
 static void irdft_vertical(FFTFILTContext *s, int h, int plane)
 {
     int i, j;
-    s->rdft = av_rdft_init(s->rdft_vbits[plane], IDFT_C2R);
+
     for (i = 0; i < s->rdft_hlen[plane]; i++)
-        av_rdft_calc(s->rdft, s->rdft_vdata[plane] + i * s->rdft_vlen[plane]);
+        av_rdft_calc(s->ivrdft[plane], s->rdft_vdata[plane] + i * s->rdft_vlen[plane]);
 
     for (i = 0; i < s->rdft_hlen[plane]; i++)
         for (j = 0; j < h; j++)
             s->rdft_hdata[plane][j * s->rdft_hlen[plane] + i] =
             s->rdft_vdata[plane][i * s->rdft_vlen[plane] + j];
-
-    av_rdft_end(s->rdft);
 }
 
 /*Horizontal pass - IRDFT*/
 static void irdft_horizontal(FFTFILTContext *s, AVFrame *out, int w, int h, int plane)
 {
     int i, j;
-    s->rdft = av_rdft_init(s->rdft_hbits[plane], IDFT_C2R);
+
     for (i = 0; i < h; i++)
-        av_rdft_calc(s->rdft, s->rdft_hdata[plane] + i * s->rdft_hlen[plane]);
+        av_rdft_calc(s->ihrdft[plane], s->rdft_hdata[plane] + i * s->rdft_hlen[plane]);
 
     for (i = 0; i < h; i++)
         for (j = 0; j < w; j++)
@@ -159,8 +169,6 @@ static void irdft_horizontal(FFTFILTContext *s, AVFrame *out, int w, int h, int
                                                                          *s->rdft_hlen[plane] + j] * 4 /
                                                                          (s->rdft_hlen[plane] *
                                                                           s->rdft_vlen[plane]), 0, 255);
-
-    av_rdft_end(s->rdft);
 }
 
 static av_cold int initialize(AVFilterContext *ctx)
@@ -197,17 +205,43 @@ static av_cold int initialize(AVFilterContext *ctx)
     return ret;
 }
 
+static void do_eval(FFTFILTContext *s, AVFilterLink *inlink, int plane)
+{
+    double values[VAR_VARS_NB];
+    int i, j;
+
+    values[VAR_N] = inlink->frame_count_out;
+    values[VAR_W] = s->planewidth[plane];
+    values[VAR_H] = s->planeheight[plane];
+
+    for (i = 0; i < s->rdft_hlen[plane]; i++) {
+        values[VAR_X] = i;
+        for (j = 0; j < s->rdft_vlen[plane]; j++) {
+            values[VAR_Y] = j;
+            s->weight[plane][i * s->rdft_vlen[plane] + j] =
+            av_expr_eval(s->weight_expr[plane], values, s);
+        }
+    }
+}
+
 static int config_props(AVFilterLink *inlink)
 {
     FFTFILTContext *s = inlink->dst->priv;
     const AVPixFmtDescriptor *desc;
-    int rdft_hbits, rdft_vbits, i, j, plane;
-    double values[VAR_VARS_NB];
+    int rdft_hbits, rdft_vbits, i, plane;
 
     desc = av_pix_fmt_desc_get(inlink->format);
+    s->depth = desc->comp[0].depth;
+    s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
+    s->planewidth[0] = s->planewidth[3] = inlink->w;
+    s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
+    s->planeheight[0] = s->planeheight[3] = inlink->h;
+
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
     for (i = 0; i < desc->nb_components; i++) {
-        int w = inlink->w;
-        int h = inlink->h;
+        int w = s->planewidth[i];
+        int h = s->planeheight[i];
 
         /* RDFT - Array initialization for Horizontal pass*/
         for (rdft_hbits = 1; 1 << rdft_hbits < w*10/9; rdft_hbits++);
@@ -216,31 +250,31 @@ static int config_props(AVFilterLink *inlink)
         if (!(s->rdft_hdata[i] = av_malloc_array(h, s->rdft_hlen[i] * sizeof(FFTSample))))
             return AVERROR(ENOMEM);
 
+        if (!(s->hrdft[i] = av_rdft_init(s->rdft_hbits[i], DFT_R2C)))
+            return AVERROR(ENOMEM);
+        if (!(s->ihrdft[i] = av_rdft_init(s->rdft_hbits[i], IDFT_C2R)))
+            return AVERROR(ENOMEM);
+
         /* RDFT - Array initialization for Vertical pass*/
         for (rdft_vbits = 1; 1 << rdft_vbits < h*10/9; rdft_vbits++);
         s->rdft_vbits[i] = rdft_vbits;
         s->rdft_vlen[i] = 1 << rdft_vbits;
         if (!(s->rdft_vdata[i] = av_malloc_array(s->rdft_hlen[i], s->rdft_vlen[i] * sizeof(FFTSample))))
             return AVERROR(ENOMEM);
+
+        if (!(s->vrdft[i] = av_rdft_init(s->rdft_vbits[i], DFT_R2C)))
+            return AVERROR(ENOMEM);
+        if (!(s->ivrdft[i] = av_rdft_init(s->rdft_vbits[i], IDFT_C2R)))
+            return AVERROR(ENOMEM);
     }
 
     /*Luminance value - Array initialization*/
-    values[VAR_W] = inlink->w;
-    values[VAR_H] = inlink->h;
-    for (plane = 0; plane < 3; plane++)
-    {
+    for (plane = 0; plane < 3; plane++) {
         if(!(s->weight[plane] = av_malloc_array(s->rdft_hlen[plane], s->rdft_vlen[plane] * sizeof(double))))
             return AVERROR(ENOMEM);
-        for (i = 0; i < s->rdft_hlen[plane]; i++)
-        {
-            values[VAR_X] = i;
-            for (j = 0; j < s->rdft_vlen[plane]; j++)
-            {
-                values[VAR_Y] = j;
-                s->weight[plane][i * s->rdft_vlen[plane] + j] =
-                av_expr_eval(s->weight_expr[plane], values, s);
-            }
-        }
+
+        if (s->eval_mode == EVAL_MODE_INIT)
+            do_eval(s, inlink, plane);
     }
     return 0;
 }
@@ -249,26 +283,24 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 {
     AVFilterContext *ctx = inlink->dst;
     AVFilterLink *outlink = inlink->dst->outputs[0];
-    const AVPixFmtDescriptor *desc;
     FFTFILTContext *s = ctx->priv;
     AVFrame *out;
     int i, j, plane;
 
     out = ff_get_video_buffer(outlink, inlink->w, inlink->h);
-    if (!out)
+    if (!out) {
+        av_frame_free(&in);
         return AVERROR(ENOMEM);
+    }
 
     av_frame_copy_props(out, in);
 
-    desc = av_pix_fmt_desc_get(inlink->format);
-    for (plane = 0; plane < desc->nb_components; plane++) {
-        int w = inlink->w;
-        int h = inlink->h;
+    for (plane = 0; plane < s->nb_planes; plane++) {
+        int w = s->planewidth[plane];
+        int h = s->planeheight[plane];
 
-        if (plane == 1 || plane == 2) {
-            w = AV_CEIL_RSHIFT(w, desc->log2_chroma_w);
-            h = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);
-        }
+        if (s->eval_mode == EVAL_MODE_FRAME)
+            do_eval(s, inlink, plane);
 
         rdft_horizontal(s, in, w, h, plane);
         rdft_vertical(s, h, plane);
@@ -298,6 +330,10 @@ static av_cold void uninit(AVFilterContext *ctx)
         av_free(s->rdft_vdata[i]);
         av_expr_free(s->weight_expr[i]);
         av_free(s->weight[i]);
+        av_rdft_end(s->hrdft[i]);
+        av_rdft_end(s->ihrdft[i]);
+        av_rdft_end(s->vrdft[i]);
+        av_rdft_end(s->ivrdft[i]);
     }
 }
 
@@ -305,7 +341,9 @@ static int query_formats(AVFilterContext *ctx)
 {
     static const enum AVPixelFormat pixel_fmts_fftfilt[] = {
         AV_PIX_FMT_GRAY8,
-        AV_PIX_FMT_YUV444P,
+        AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
+        AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
         AV_PIX_FMT_NONE
     };
 
@@ -343,4 +381,5 @@ AVFilter ff_vf_fftfilt = {
     .query_formats   = query_formats,
     .init            = initialize,
     .uninit          = uninit,
+    .flags           = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_field.c b/mythtv/external/FFmpeg/libavfilter/vf_field.c
index 72cabdb9296..2f4eb679eaa 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_field.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_field.c
@@ -31,7 +31,7 @@
 
 enum FieldType { FIELD_TYPE_TOP = 0, FIELD_TYPE_BOTTOM };
 
-typedef struct {
+typedef struct FieldContext {
     const AVClass *class;
     int type;                   ///< FieldType
     int nb_planes;              ///< number of planes of the current format
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_fieldhint.c b/mythtv/external/FFmpeg/libavfilter/vf_fieldhint.c
index 2b845e73305..3cfeb20a382 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_fieldhint.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_fieldhint.c
@@ -147,22 +147,22 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
             }
             switch (s->mode) {
             case 0:
-                if (tf > outlink->frame_count + 1 || tf < FFMAX(0, outlink->frame_count - 1) ||
-                    bf > outlink->frame_count + 1 || bf < FFMAX(0, outlink->frame_count - 1)) {
-                    av_log(ctx, AV_LOG_ERROR, "Out of range frames %"PRId64" and/or %"PRId64" on line %"PRId64" for %"PRId64". input frame.\n", tf, bf, s->line, inlink->frame_count);
+                if (tf > outlink->frame_count_in + 1 || tf < FFMAX(0, outlink->frame_count_in - 1) ||
+                    bf > outlink->frame_count_in + 1 || bf < FFMAX(0, outlink->frame_count_in - 1)) {
+                    av_log(ctx, AV_LOG_ERROR, "Out of range frames %"PRId64" and/or %"PRId64" on line %"PRId64" for %"PRId64". input frame.\n", tf, bf, s->line, inlink->frame_count_out);
                     return AVERROR_INVALIDDATA;
                 }
                 break;
             case 1:
                 if (tf > 1 || tf < -1 ||
                     bf > 1 || bf < -1) {
-                    av_log(ctx, AV_LOG_ERROR, "Out of range %"PRId64" and/or %"PRId64" on line %"PRId64" for %"PRId64". input frame.\n", tf, bf, s->line, inlink->frame_count);
+                    av_log(ctx, AV_LOG_ERROR, "Out of range %"PRId64" and/or %"PRId64" on line %"PRId64" for %"PRId64". input frame.\n", tf, bf, s->line, inlink->frame_count_out);
                     return AVERROR_INVALIDDATA;
                 }
             };
             break;
         } else {
-            av_log(ctx, AV_LOG_ERROR, "Missing entry for %"PRId64". input frame.\n", inlink->frame_count);
+            av_log(ctx, AV_LOG_ERROR, "Missing entry for %"PRId64". input frame.\n", inlink->frame_count_out);
             return AVERROR_INVALIDDATA;
         }
     }
@@ -174,8 +174,8 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 
     switch (s->mode) {
     case 0:
-        top    = s->frame[tf - outlink->frame_count + 1];
-        bottom = s->frame[bf - outlink->frame_count + 1];
+        top    = s->frame[tf - outlink->frame_count_in + 1];
+        bottom = s->frame[bf - outlink->frame_count_in + 1];
         break;
     case 1:
         top    = s->frame[1 + tf];
@@ -196,6 +196,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         break;
     default:
         av_log(ctx, AV_LOG_ERROR, "Invalid hint: %c.\n", hint);
+        av_frame_free(&out);
         return AVERROR(EINVAL);
     }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_fieldmatch.c b/mythtv/external/FFmpeg/libavfilter/vf_fieldmatch.c
index e155712caa0..3694f26d33f 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_fieldmatch.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_fieldmatch.c
@@ -72,7 +72,7 @@ enum comb_dbg {
     NB_COMBDBG
 };
 
-typedef struct {
+typedef struct FieldMatchContext {
     const AVClass *class;
 
     AVFrame *prv,  *src,  *nxt;     ///< main sliding window of 3 frames
@@ -740,7 +740,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 
     /* scene change check */
     if (fm->combmatch == COMBMATCH_SC) {
-        if (fm->lastn == outlink->frame_count - 1) {
+        if (fm->lastn == outlink->frame_count_in - 1) {
             if (fm->lastscdiff > fm->scthresh)
                 sc = 1;
         } else if (luma_abs_diff(fm->prv, fm->src) > fm->scthresh) {
@@ -748,7 +748,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         }
 
         if (!sc) {
-            fm->lastn = outlink->frame_count;
+            fm->lastn = outlink->frame_count_in;
             fm->lastscdiff = luma_abs_diff(fm->src, fm->nxt);
             sc = fm->lastscdiff > fm->scthresh;
         }
@@ -807,7 +807,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     dst->interlaced_frame = combs[match] >= fm->combpel;
     if (dst->interlaced_frame) {
         av_log(ctx, AV_LOG_WARNING, "Frame #%"PRId64" at %s is still interlaced\n",
-               outlink->frame_count, av_ts2timestr(in->pts, &inlink->time_base));
+               outlink->frame_count_in, av_ts2timestr(in->pts, &inlink->time_base));
         dst->top_field_first = field;
     }
 
@@ -904,17 +904,24 @@ static av_cold int fieldmatch_init(AVFilterContext *ctx)
         .filter_frame = filter_frame,
         .config_props = config_input,
     };
+    int ret;
 
     if (!pad.name)
         return AVERROR(ENOMEM);
-    ff_insert_inpad(ctx, INPUT_MAIN, &pad);
+    if ((ret = ff_insert_inpad(ctx, INPUT_MAIN, &pad)) < 0) {
+        av_freep(&pad.name);
+        return ret;
+    }
 
     if (fm->ppsrc) {
         pad.name = av_strdup("clean_src");
         pad.config_props = NULL;
         if (!pad.name)
             return AVERROR(ENOMEM);
-        ff_insert_inpad(ctx, INPUT_CLEANSRC, &pad);
+        if ((ret = ff_insert_inpad(ctx, INPUT_CLEANSRC, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
     }
 
     if ((fm->blockx & (fm->blockx - 1)) ||
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_floodfill.c b/mythtv/external/FFmpeg/libavfilter/vf_floodfill.c
new file mode 100644
index 00000000000..323dd0e2fa1
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_floodfill.c
@@ -0,0 +1,433 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/opt.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/intreadwrite.h"
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+typedef struct Points {
+    uint16_t x, y;
+} Points;
+
+typedef struct FloodfillContext {
+    const AVClass *class;
+
+    int x, y;
+    int s0, s1, s2, s3;
+    int d0, d1, d2, d3;
+
+    int back, front;
+    Points *points;
+
+    int (*is_same)(AVFrame *frame, int x, int y,
+                   unsigned s0, unsigned s1, unsigned s2, unsigned s3);
+    void (*set_pixel)(AVFrame *frame, int x, int y,
+                      unsigned d0, unsigned d1, unsigned d2, unsigned d3);
+    void (*pick_pixel)(AVFrame *frame, int x, int y,
+                       int *s0, int *s1, int *s2, int *s3);
+} FloodfillContext;
+
+static int is_inside(int x, int y, int w, int h)
+{
+    if (x >= 0 && x < w && y >= 0 && y < h)
+        return 1;
+    return 0;
+}
+
+static int is_same4(AVFrame *frame, int x, int y,
+                    unsigned s0, unsigned s1, unsigned s2, unsigned s3)
+{
+    unsigned c0 = frame->data[0][y * frame->linesize[0] + x];
+    unsigned c1 = frame->data[1][y * frame->linesize[1] + x];
+    unsigned c2 = frame->data[2][y * frame->linesize[2] + x];
+    unsigned c3 = frame->data[3][y * frame->linesize[3] + x];
+
+    if (s0 == c0 && s1 == c1 && s2 == c2 && s3 == c3)
+        return 1;
+    return 0;
+}
+
+static int is_same4_16(AVFrame *frame, int x, int y,
+                       unsigned s0, unsigned s1, unsigned s2, unsigned s3)
+{
+    unsigned c0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
+    unsigned c1 = AV_RN16(frame->data[1] + y * frame->linesize[1] + 2 * x);
+    unsigned c2 = AV_RN16(frame->data[2] + y * frame->linesize[2] + 2 * x);
+    unsigned c3 = AV_RN16(frame->data[3] + y * frame->linesize[3] + 2 * x);
+
+    if (s0 == c0 && s1 == c1 && s2 == c2 && s3 == c3)
+        return 1;
+    return 0;
+}
+
+static int is_same3(AVFrame *frame, int x, int y,
+                    unsigned s0, unsigned s1, unsigned s2, unsigned s3)
+{
+    unsigned c0 = frame->data[0][y * frame->linesize[0] + x];
+    unsigned c1 = frame->data[1][y * frame->linesize[1] + x];
+    unsigned c2 = frame->data[2][y * frame->linesize[2] + x];
+
+    if (s0 == c0 && s1 == c1 && s2 == c2)
+        return 1;
+    return 0;
+}
+
+static int is_same3_16(AVFrame *frame, int x, int y,
+                       unsigned s0, unsigned s1, unsigned s2, unsigned s3)
+{
+    unsigned c0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
+    unsigned c1 = AV_RN16(frame->data[1] + y * frame->linesize[1] + 2 * x);
+    unsigned c2 = AV_RN16(frame->data[2] + y * frame->linesize[2] + 2 * x);
+
+    if (s0 == c0 && s1 == c1 && s2 == c2)
+        return 1;
+    return 0;
+}
+
+static int is_same1(AVFrame *frame, int x, int y,
+                    unsigned s0, unsigned s1, unsigned s2, unsigned s3)
+{
+    unsigned c0 = frame->data[0][y * frame->linesize[0] + x];
+
+    if (s0 == c0)
+        return 1;
+    return 0;
+}
+
+static int is_same1_16(AVFrame *frame, int x, int y,
+                       unsigned s0, unsigned s1, unsigned s2, unsigned s3)
+{
+    unsigned c0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
+
+    if (s0 == c0)
+        return 1;
+    return 0;
+}
+
+static void set_pixel1(AVFrame *frame, int x, int y,
+                       unsigned d0, unsigned d1, unsigned d2, unsigned d3)
+{
+    frame->data[0][y * frame->linesize[0] + x] = d0;
+}
+
+static void set_pixel1_16(AVFrame *frame, int x, int y,
+                          unsigned d0, unsigned d1, unsigned d2, unsigned d3)
+{
+    AV_WN16(frame->data[0] + y * frame->linesize[0] + 2 * x, d0);
+}
+
+static void set_pixel3(AVFrame *frame, int x, int y,
+                       unsigned d0, unsigned d1, unsigned d2, unsigned d3)
+{
+    frame->data[0][y * frame->linesize[0] + x] = d0;
+    frame->data[1][y * frame->linesize[1] + x] = d1;
+    frame->data[2][y * frame->linesize[2] + x] = d2;
+}
+
+static void set_pixel3_16(AVFrame *frame, int x, int y,
+                          unsigned d0, unsigned d1, unsigned d2, unsigned d3)
+{
+    AV_WN16(frame->data[0] + y * frame->linesize[0] + 2 * x, d0);
+    AV_WN16(frame->data[1] + y * frame->linesize[1] + 2 * x, d1);
+    AV_WN16(frame->data[2] + y * frame->linesize[2] + 2 * x, d2);
+}
+
+static void set_pixel4(AVFrame *frame, int x, int y,
+                       unsigned d0, unsigned d1, unsigned d2, unsigned d3)
+{
+    frame->data[0][y * frame->linesize[0] + x] = d0;
+    frame->data[1][y * frame->linesize[1] + x] = d1;
+    frame->data[2][y * frame->linesize[2] + x] = d2;
+    frame->data[3][y * frame->linesize[3] + x] = d3;
+}
+
+static void set_pixel4_16(AVFrame *frame, int x, int y,
+                          unsigned d0, unsigned d1, unsigned d2, unsigned d3)
+{
+    AV_WN16(frame->data[0] + y * frame->linesize[0] + 2 * x, d0);
+    AV_WN16(frame->data[1] + y * frame->linesize[1] + 2 * x, d1);
+    AV_WN16(frame->data[2] + y * frame->linesize[2] + 2 * x, d2);
+    AV_WN16(frame->data[3] + y * frame->linesize[3] + 2 * x, d3);
+}
+
+static void pick_pixel1(AVFrame *frame, int x, int y,
+                        int *s0, int *s1, int *s2, int *s3)
+{
+    if (*s0 < 0)
+        *s0 = frame->data[0][y * frame->linesize[0] + x];
+}
+
+static void pick_pixel1_16(AVFrame *frame, int x, int y,
+                           int *s0, int *s1, int *s2, int *s3)
+{
+    if (*s0 < 0)
+        *s0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
+}
+
+static void pick_pixel3(AVFrame *frame, int x, int y,
+                        int *s0, int *s1, int *s2, int *s3)
+{
+    if (*s0 < 0)
+        *s0 = frame->data[0][y * frame->linesize[0] + x];
+    if (*s1 < 0)
+        *s1 = frame->data[1][y * frame->linesize[1] + x];
+    if (*s2 < 0)
+        *s2 = frame->data[2][y * frame->linesize[2] + x];
+}
+
+static void pick_pixel3_16(AVFrame *frame, int x, int y,
+                           int *s0, int *s1, int *s2, int *s3)
+{
+    if (*s0 < 0)
+        *s0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
+    if (*s1 < 0)
+        *s1 = AV_RN16(frame->data[1] + y * frame->linesize[1] + 2 * x);
+    if (*s2 < 0)
+        *s2 = AV_RN16(frame->data[2] + y * frame->linesize[2] + 2 * x);
+}
+
+static void pick_pixel4(AVFrame *frame, int x, int y,
+                        int *s0, int *s1, int *s2, int *s3)
+{
+    if (*s0 < 0)
+        *s0 = frame->data[0][y * frame->linesize[0] + x];
+    if (*s1 < 0)
+        *s1 = frame->data[1][y * frame->linesize[1] + x];
+    if (*s2 < 0)
+        *s2 = frame->data[2][y * frame->linesize[2] + x];
+    if (*s3 < 0)
+        *s3 = frame->data[3][y * frame->linesize[3] + x];
+}
+
+static void pick_pixel4_16(AVFrame *frame, int x, int y,
+                           int *s0, int *s1, int *s2, int *s3)
+{
+    if (*s0 < 0)
+        *s0 = AV_RN16(frame->data[0] + y * frame->linesize[0] + 2 * x);
+    if (*s1 < 0)
+        *s1 = AV_RN16(frame->data[1] + y * frame->linesize[1] + 2 * x);
+    if (*s2 < 0)
+        *s2 = AV_RN16(frame->data[2] + y * frame->linesize[2] + 2 * x);
+    if (*s3 < 0)
+        *s3 = AV_RN16(frame->data[3] + y * frame->linesize[3] + 2 * x);
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    AVFilterContext *ctx = inlink->dst;
+    FloodfillContext *s = ctx->priv;
+    int nb_planes = av_pix_fmt_count_planes(inlink->format);
+    int depth;
+
+    depth = desc->comp[0].depth;
+    if (depth == 8) {
+        switch (nb_planes) {
+        case 1: s->set_pixel  = set_pixel1;
+                s->is_same    = is_same1;
+                s->pick_pixel = pick_pixel1; break;
+        case 3: s->set_pixel  = set_pixel3;
+                s->is_same    = is_same3;
+                s->pick_pixel = pick_pixel3; break;
+        case 4: s->set_pixel  = set_pixel4;
+                s->is_same    = is_same4;
+                s->pick_pixel = pick_pixel4; break;
+       }
+    } else {
+        switch (nb_planes) {
+        case 1: s->set_pixel  = set_pixel1_16;
+                s->is_same    = is_same1_16;
+                s->pick_pixel = pick_pixel1_16; break;
+        case 3: s->set_pixel  = set_pixel3_16;
+                s->is_same    = is_same3_16;
+                s->pick_pixel = pick_pixel3_16; break;
+        case 4: s->set_pixel  = set_pixel4_16;
+                s->is_same    = is_same4_16;
+                s->pick_pixel = pick_pixel4_16; break;
+       }
+    }
+
+    s->front = s->back = 0;
+    s->points = av_calloc(inlink->w * inlink->h, 4 * sizeof(Points));
+    if (!s->points)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *link, AVFrame *frame)
+{
+    AVFilterContext *ctx = link->dst;
+    FloodfillContext *s = ctx->priv;
+    const unsigned d0 = s->d0;
+    const unsigned d1 = s->d1;
+    const unsigned d2 = s->d2;
+    const unsigned d3 = s->d3;
+    int s0 = s->s0;
+    int s1 = s->s1;
+    int s2 = s->s2;
+    int s3 = s->s3;
+    const int w = frame->width;
+    const int h = frame->height;
+    int ret;
+
+    if (ret = av_frame_make_writable(frame))
+        return ret;
+
+    if (is_inside(s->x, s->y, w, h)) {
+        s->pick_pixel(frame, s->x, s->y, &s0, &s1, &s2, &s3);
+
+        if (s->is_same(frame, s->x, s->y, s0, s1, s2, s3)) {
+            s->points[s->front].x = s->x;
+            s->points[s->front].y = s->y;
+            s->front++;
+        }
+
+        while (s->front > s->back) {
+            int x, y;
+
+            s->front--;
+            x = s->points[s->front].x;
+            y = s->points[s->front].y;
+
+            if (s->is_same(frame, x, y, s0, s1, s2, s3)) {
+                s->set_pixel(frame, x, y, d0, d1, d2, d3);
+
+                if (is_inside(x + 1, y, w, h)) {
+                    s->points[s->front]  .x = x + 1;
+                    s->points[s->front++].y = y;
+                }
+
+                if (is_inside(x - 1, y, w, h)) {
+                    s->points[s->front]  .x = x - 1;
+                    s->points[s->front++].y = y;
+                }
+
+                if (is_inside(x, y + 1, w, h)) {
+                    s->points[s->front]  .x = x;
+                    s->points[s->front++].y = y + 1;
+                }
+
+                if (is_inside(x, y - 1, w, h)) {
+                    s->points[s->front]  .x = x;
+                    s->points[s->front++].y = y - 1;
+                }
+            }
+        }
+    }
+
+    return ff_filter_frame(ctx->outputs[0], frame);
+}
+
+static av_cold int query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pixel_fmts[] = {
+        AV_PIX_FMT_GRAY8,
+        AV_PIX_FMT_YUV444P,
+        AV_PIX_FMT_YUVA444P,
+        AV_PIX_FMT_GBRP,
+        AV_PIX_FMT_GBRP9,
+        AV_PIX_FMT_GBRP10,
+        AV_PIX_FMT_GBRAP10,
+        AV_PIX_FMT_GBRP12,
+        AV_PIX_FMT_GBRAP12,
+        AV_PIX_FMT_GBRP14,
+        AV_PIX_FMT_GBRP16,
+        AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_GBRAP,
+        AV_PIX_FMT_YUV444P9,
+        AV_PIX_FMT_YUVA444P9,
+        AV_PIX_FMT_YUV444P10,
+        AV_PIX_FMT_YUVA444P10,
+        AV_PIX_FMT_YUV444P12,
+        AV_PIX_FMT_YUV444P14,
+        AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_YUV444P16,
+        AV_PIX_FMT_YUVA444P16,
+        AV_PIX_FMT_NONE
+    };
+    AVFilterFormats *formats;
+
+    formats = ff_make_format_list(pixel_fmts);
+    if (!formats)
+        return AVERROR(ENOMEM);
+
+    return ff_set_common_formats(ctx, formats);
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    FloodfillContext *s = ctx->priv;
+
+    av_freep(&s->points);
+}
+
+static const AVFilterPad floodfill_inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = filter_frame,
+        .config_props = config_input,
+    },
+    { NULL }
+};
+
+static const AVFilterPad floodfill_outputs[] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_VIDEO,
+    },
+    { NULL }
+};
+
+#define OFFSET(x) offsetof(FloodfillContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption floodfill_options[] = {
+    { "x",  "set pixel x coordinate",             OFFSET(x),  AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
+    { "y",  "set pixel y coordinate",             OFFSET(y),  AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
+    { "s0", "set source #0 component value",      OFFSET(s0), AV_OPT_TYPE_INT, {.i64=0},-1, UINT16_MAX, FLAGS },
+    { "s1", "set source #1 component value",      OFFSET(s1), AV_OPT_TYPE_INT, {.i64=0},-1, UINT16_MAX, FLAGS },
+    { "s2", "set source #2 component value",      OFFSET(s2), AV_OPT_TYPE_INT, {.i64=0},-1, UINT16_MAX, FLAGS },
+    { "s3", "set source #3 component value",      OFFSET(s3), AV_OPT_TYPE_INT, {.i64=0},-1, UINT16_MAX, FLAGS },
+    { "d0", "set destination #0 component value", OFFSET(d0), AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
+    { "d1", "set destination #1 component value", OFFSET(d1), AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
+    { "d2", "set destination #2 component value", OFFSET(d2), AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
+    { "d3", "set destination #3 component value", OFFSET(d3), AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(floodfill);
+
+AVFilter ff_vf_floodfill = {
+    .name          = "floodfill",
+    .description   = NULL_IF_CONFIG_SMALL("Fill area with same color with another color."),
+    .priv_size     = sizeof(FloodfillContext),
+    .priv_class    = &floodfill_class,
+    .query_formats = query_formats,
+    .uninit        = uninit,
+    .inputs        = floodfill_inputs,
+    .outputs       = floodfill_outputs,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_fps.c b/mythtv/external/FFmpeg/libavfilter/vf_fps.c
index 20ccd797d10..dbafd2c35a6 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_fps.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_fps.c
@@ -34,10 +34,18 @@
 #include "libavutil/opt.h"
 #include "libavutil/parseutils.h"
 
+#define FF_INTERNAL_FIELDS 1
+#include "framequeue.h"
 #include "avfilter.h"
 #include "internal.h"
 #include "video.h"
 
+enum EOFAction {
+    EOF_ACTION_ROUND,
+    EOF_ACTION_PASS,
+    EOF_ACTION_NB
+};
+
 typedef struct FPSContext {
     const AVClass *class;
 
@@ -50,6 +58,7 @@ typedef struct FPSContext {
 
     AVRational framerate;   ///< target framerate
     int rounding;           ///< AVRounding method for timestamps
+    int eof_action;         ///< action performed for last frame in FIFO
 
     /* statistics */
     int frames_in;             ///< number of frames on input
@@ -63,13 +72,16 @@ typedef struct FPSContext {
 #define F AV_OPT_FLAG_FILTERING_PARAM
 static const AVOption fps_options[] = {
     { "fps", "A string describing desired output framerate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, { .str = "25" }, 0, INT_MAX, V|F },
-    { "start_time", "Assume the first PTS should be this value.", OFFSET(start_time), AV_OPT_TYPE_DOUBLE, { .dbl = DBL_MAX}, -DBL_MAX, DBL_MAX, V },
+    { "start_time", "Assume the first PTS should be this value.", OFFSET(start_time), AV_OPT_TYPE_DOUBLE, { .dbl = DBL_MAX}, -DBL_MAX, DBL_MAX, V|F },
     { "round", "set rounding method for timestamps", OFFSET(rounding), AV_OPT_TYPE_INT, { .i64 = AV_ROUND_NEAR_INF }, 0, 5, V|F, "round" },
-    { "zero", "round towards 0",      OFFSET(rounding), AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_ZERO     }, 0, 5, V|F, "round" },
-    { "inf",  "round away from 0",    OFFSET(rounding), AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_INF      }, 0, 5, V|F, "round" },
-    { "down", "round towards -infty", OFFSET(rounding), AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_DOWN     }, 0, 5, V|F, "round" },
-    { "up",   "round towards +infty", OFFSET(rounding), AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_UP       }, 0, 5, V|F, "round" },
-    { "near", "round to nearest",     OFFSET(rounding), AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_NEAR_INF }, 0, 5, V|F, "round" },
+        { "zero", "round towards 0",                 0, AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_ZERO     }, 0, 0, V|F, "round" },
+        { "inf",  "round away from 0",               0, AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_INF      }, 0, 0, V|F, "round" },
+        { "down", "round towards -infty",            0, AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_DOWN     }, 0, 0, V|F, "round" },
+        { "up",   "round towards +infty",            0, AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_UP       }, 0, 0, V|F, "round" },
+        { "near", "round to nearest",                0, AV_OPT_TYPE_CONST, { .i64 = AV_ROUND_NEAR_INF }, 0, 0, V|F, "round" },
+    { "eof_action", "action performed for last frame", OFFSET(eof_action), AV_OPT_TYPE_INT, { .i64 = EOF_ACTION_ROUND }, 0, EOF_ACTION_NB-1, V|F, "eof_action" },
+        { "round", "round similar to other frames",  0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_ROUND }, 0, 0, V|F, "eof_action" },
+        { "pass",  "pass through last frame",        0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_PASS  }, 0, 0, V|F, "eof_action" },
     { NULL }
 };
 
@@ -137,13 +149,48 @@ static int request_frame(AVFilterLink *outlink)
             AVFrame *buf;
 
             av_fifo_generic_read(s->fifo, &buf, sizeof(buf), NULL);
-            buf->pts = av_rescale_q(s->first_pts, ctx->inputs[0]->time_base,
-                                    outlink->time_base) + s->frames_out;
+            if (av_fifo_size(s->fifo)) {
+                buf->pts = av_rescale_q(s->first_pts, ctx->inputs[0]->time_base,
+                                        outlink->time_base) + s->frames_out;
 
-            if ((ret = ff_filter_frame(outlink, buf)) < 0)
-                return ret;
+                if ((ret = ff_filter_frame(outlink, buf)) < 0)
+                    return ret;
 
-            s->frames_out++;
+                s->frames_out++;
+            } else {
+                /* This is the last frame, we may have to duplicate it to match
+                 * the last frame duration */
+                int j;
+                int eof_rounding = (s->eof_action == EOF_ACTION_PASS) ? AV_ROUND_UP : s->rounding;
+                int delta = av_rescale_q_rnd(ctx->inputs[0]->current_pts - s->first_pts,
+                                             ctx->inputs[0]->time_base,
+                                             outlink->time_base, eof_rounding) - s->frames_out;
+                av_log(ctx, AV_LOG_DEBUG, "EOF frames_out:%d delta:%d\n", s->frames_out, delta);
+                /* if the delta is equal to 1, it means we just need to output
+                 * the last frame. Greater than 1 means we will need duplicate
+                 * delta-1 frames */
+                if (delta > 0 ) {
+                    for (j = 0; j < delta; j++) {
+                        AVFrame *dup = av_frame_clone(buf);
+
+                        av_log(ctx, AV_LOG_DEBUG, "Duplicating frame.\n");
+                        dup->pts = av_rescale_q(s->first_pts, ctx->inputs[0]->time_base,
+                                                outlink->time_base) + s->frames_out;
+
+                        if ((ret = ff_filter_frame(outlink, dup)) < 0)
+                            return ret;
+
+                        s->frames_out++;
+                        if (j > 0) s->dup++;
+                    }
+                    av_frame_free(&buf);
+                } else {
+                    /* for delta less or equal to 0, we should drop the frame,
+                     * otherwise, we will have one or more extra frames */
+                    av_frame_free(&buf);
+                    s->drop++;
+                }
+            }
         }
         return 0;
     }
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_framerate.c b/mythtv/external/FFmpeg/libavfilter/vf_framerate.c
index 237a4873b35..dc8b05f40f2 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_framerate.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_framerate.c
@@ -440,7 +440,7 @@ static int process_work_frame(AVFilterContext *ctx, int stop)
         s->pending_end_frame = 0;
     s->last_dest_frame_pts = s->work->pts;
 
-    return ff_filter_frame(ctx->outputs[0], s->work);
+    return 1;
 }
 
 static void set_srce_frame_dest_pts(AVFilterContext *ctx)
@@ -526,7 +526,7 @@ static av_cold void uninit(AVFilterContext *ctx)
     FrameRateContext *s = ctx->priv;
     int i;
 
-    for (i = s->frst + 1; i < s->last; i++) {
+    for (i = s->frst; i < s->last; i++) {
         if (s->srce[i] && (s->srce[i] != s->srce[i + 1]))
             av_frame_free(&s->srce[i]);
     }
@@ -586,6 +586,7 @@ static int config_input(AVFilterLink *inlink)
 
 static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
 {
+    int ret;
     AVFilterContext *ctx = inlink->dst;
     FrameRateContext *s = ctx->priv;
 
@@ -606,7 +607,10 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
         set_srce_frame_dest_pts(ctx);
     }
 
-    return process_work_frame(ctx, 1);
+    ret = process_work_frame(ctx, 1);
+    if (ret < 0)
+        return ret;
+    return ret ? ff_filter_frame(ctx->outputs[0], s->work) : 0;
 }
 
 static int config_output(AVFilterLink *outlink)
@@ -658,23 +662,13 @@ static int request_frame(AVFilterLink *outlink)
 {
     AVFilterContext *ctx = outlink->src;
     FrameRateContext *s = ctx->priv;
-    int val, i;
+    int ret, i;
 
     ff_dlog(ctx, "request_frame()\n");
 
     // if there is no "next" frame AND we are not in flush then get one from our input filter
-    if (!s->srce[s->frst] && !s->flush) {
-        ff_dlog(ctx, "request_frame() call source's request_frame()\n");
-        val = ff_request_frame(outlink->src->inputs[0]);
-        if (val < 0 && (val != AVERROR_EOF)) {
-            ff_dlog(ctx, "request_frame() source's request_frame() returned error:%d\n", val);
-            return val;
-        } else if (val == AVERROR_EOF) {
-            s->flush = 1;
-        }
-        ff_dlog(ctx, "request_frame() source's request_frame() returned:%d\n", val);
-        return 0;
-    }
+    if (!s->srce[s->frst] && !s->flush)
+        goto request;
 
     ff_dlog(ctx, "request_frame() REPEAT or FLUSH\n");
 
@@ -695,7 +689,23 @@ static int request_frame(AVFilterLink *outlink)
     }
 
     set_work_frame_pts(ctx);
-    return process_work_frame(ctx, 0);
+    ret = process_work_frame(ctx, 0);
+    if (ret < 0)
+        return ret;
+    if (ret)
+        return ff_filter_frame(ctx->outputs[0], s->work);
+
+request:
+    ff_dlog(ctx, "request_frame() call source's request_frame()\n");
+    ret = ff_request_frame(ctx->inputs[0]);
+    if (ret < 0 && (ret != AVERROR_EOF)) {
+        ff_dlog(ctx, "request_frame() source's request_frame() returned error:%d\n", ret);
+        return ret;
+    } else if (ret == AVERROR_EOF) {
+        s->flush = 1;
+    }
+    ff_dlog(ctx, "request_frame() source's request_frame() returned:%d\n", ret);
+    return 0;
 }
 
 static const AVFilterPad framerate_inputs[] = {
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_framestep.c b/mythtv/external/FFmpeg/libavfilter/vf_framestep.c
index 6f198b8ff5b..8102e7c7195 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_framestep.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_framestep.c
@@ -63,7 +63,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *ref)
 {
     FrameStepContext *framestep = inlink->dst->priv;
 
-    if (!(inlink->frame_count % framestep->frame_step)) {
+    if (!(inlink->frame_count_out % framestep->frame_step)) {
         return ff_filter_frame(inlink->dst->outputs[0], ref);
     } else {
         av_frame_free(&ref);
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_gblur.c b/mythtv/external/FFmpeg/libavfilter/vf_gblur.c
index 27b702998e3..fd901e20d46 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_gblur.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_gblur.c
@@ -152,12 +152,12 @@ static int filter_postscale(AVFilterContext *ctx, void *arg, int jobnr, int nb_j
     ThreadData *td = arg;
     const int height = td->height;
     const int width = td->width;
-    const int64_t numpixels = width * height;
-    const int slice_start = (numpixels *  jobnr   ) / nb_jobs;
-    const int slice_end   = (numpixels * (jobnr+1)) / nb_jobs;
+    const int64_t numpixels = width * (int64_t)height;
+    const unsigned slice_start = (numpixels *  jobnr   ) / nb_jobs;
+    const unsigned slice_end   = (numpixels * (jobnr+1)) / nb_jobs;
     const float postscale = s->postscale * s->postscaleV;
     float *buffer = s->buffer;
-    int i;
+    unsigned i;
 
     for (i = slice_start; i < slice_end; i++)
         buffer[i] *= postscale;
@@ -201,8 +201,8 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
-        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_NONE
     };
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_geq.c b/mythtv/external/FFmpeg/libavfilter/vf_geq.c
index 88d3b75af11..36dbd421ce1 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_geq.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_geq.c
@@ -33,7 +33,7 @@
 #include "libavutil/pixdesc.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct GEQContext {
     const AVClass *class;
     AVExpr *e[4];               ///< expressions for each plane
     char *expr_str[4+3];        ///< expression strings for each plane
@@ -41,6 +41,7 @@ typedef struct {
     int hsub, vsub;             ///< chroma subsampling
     int planes;                 ///< number of planes
     int is_rgb;
+    int bps;
 } GEQContext;
 
 enum { Y = 0, U, V, A, G, B, R };
@@ -74,7 +75,7 @@ static inline double getpix(void *priv, double x, double y, int plane)
     GEQContext *geq = priv;
     AVFrame *picref = geq->picref;
     const uint8_t *src = picref->data[plane];
-    const int linesize = picref->linesize[plane];
+    int linesize = picref->linesize[plane];
     const int w = (plane == 1 || plane == 2) ? AV_CEIL_RSHIFT(picref->width,  geq->hsub) : picref->width;
     const int h = (plane == 1 || plane == 2) ? AV_CEIL_RSHIFT(picref->height, geq->vsub) : picref->height;
 
@@ -87,8 +88,16 @@ static inline double getpix(void *priv, double x, double y, int plane)
     x -= xi;
     y -= yi;
 
-    return (1-y)*((1-x)*src[xi +  yi    * linesize] + x*src[xi + 1 +  yi    * linesize])
-          +   y *((1-x)*src[xi + (yi+1) * linesize] + x*src[xi + 1 + (yi+1) * linesize]);
+    if (geq->bps > 8) {
+        const uint16_t *src16 = (const uint16_t*)src;
+        linesize /= 2;
+
+        return (1-y)*((1-x)*src16[xi +  yi    * linesize] + x*src16[xi + 1 +  yi    * linesize])
+              +   y *((1-x)*src16[xi + (yi+1) * linesize] + x*src16[xi + 1 + (yi+1) * linesize]);
+    } else {
+        return (1-y)*((1-x)*src[xi +  yi    * linesize] + x*src[xi + 1 +  yi    * linesize])
+              +   y *((1-x)*src[xi + (yi+1) * linesize] + x*src[xi + 1 + (yi+1) * linesize]);
+    }
 }
 
 //TODO: cubic interpolate
@@ -129,8 +138,11 @@ static av_cold int geq_init(AVFilterContext *ctx)
         if (!geq->expr_str[V]) geq->expr_str[V] = av_strdup(geq->expr_str[U]);
     }
 
-    if (!geq->expr_str[A])
-        geq->expr_str[A] = av_strdup("255");
+    if (!geq->expr_str[A]) {
+        char bps_string[8];
+        snprintf(bps_string, sizeof(bps_string), "%d", (1<<geq->bps) - 1);
+        geq->expr_str[A] = av_strdup(bps_string);
+    }
     if (!geq->expr_str[G])
         geq->expr_str[G] = av_strdup("g(X,Y)");
     if (!geq->expr_str[B])
@@ -171,10 +183,27 @@ static int geq_query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,
         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
         AV_PIX_FMT_GRAY8,
+        AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,  AV_PIX_FMT_YUV420P9,
+        AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
+        AV_PIX_FMT_YUV444P10,  AV_PIX_FMT_YUV422P10,  AV_PIX_FMT_YUV420P10,
+        AV_PIX_FMT_YUV440P10,
+        AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
+        AV_PIX_FMT_GRAY10,
+        AV_PIX_FMT_YUV444P12,  AV_PIX_FMT_YUV422P12,  AV_PIX_FMT_YUV420P12,
+        AV_PIX_FMT_GRAY12,
+        AV_PIX_FMT_YUV444P14,  AV_PIX_FMT_YUV422P14,  AV_PIX_FMT_YUV420P14,
+        AV_PIX_FMT_YUV444P16,  AV_PIX_FMT_YUV422P16,  AV_PIX_FMT_YUV420P16,
+        AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
+        AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_NONE
     };
     static const enum AVPixelFormat rgb_pix_fmts[] = {
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
+        AV_PIX_FMT_GBRP9,
+        AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
+        AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,
+        AV_PIX_FMT_GBRP14,
+        AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16,
         AV_PIX_FMT_NONE
     };
     AVFilterFormats *fmts_list;
@@ -198,6 +227,8 @@ static int geq_config_props(AVFilterLink *inlink)
     geq->hsub = desc->log2_chroma_w;
     geq->vsub = desc->log2_chroma_h;
     geq->planes = desc->nb_components;
+    geq->bps    = desc->comp[0].depth;
+
     return 0;
 }
 
@@ -208,7 +239,7 @@ static int geq_filter_frame(AVFilterLink *inlink, AVFrame *in)
     AVFilterLink *outlink = inlink->dst->outputs[0];
     AVFrame *out;
     double values[VAR_VARS_NB] = {
-        [VAR_N] = inlink->frame_count,
+        [VAR_N] = inlink->frame_count_out,
         [VAR_T] = in->pts == AV_NOPTS_VALUE ? NAN : in->pts * av_q2d(inlink->time_base),
     };
 
@@ -223,6 +254,7 @@ static int geq_filter_frame(AVFilterLink *inlink, AVFrame *in)
     for (plane = 0; plane < geq->planes && out->data[plane]; plane++) {
         int x, y;
         uint8_t *dst = out->data[plane];
+        uint16_t *dst16 = (uint16_t*)out->data[plane];
         const int linesize = out->linesize[plane];
         const int w = (plane == 1 || plane == 2) ? AV_CEIL_RSHIFT(inlink->w, geq->hsub) : inlink->w;
         const int h = (plane == 1 || plane == 2) ? AV_CEIL_RSHIFT(inlink->h, geq->vsub) : inlink->h;
@@ -234,11 +266,19 @@ static int geq_filter_frame(AVFilterLink *inlink, AVFrame *in)
 
         for (y = 0; y < h; y++) {
             values[VAR_Y] = y;
-            for (x = 0; x < w; x++) {
-                values[VAR_X] = x;
-                dst[x] = av_expr_eval(geq->e[plane], values, geq);
+            if (geq->bps > 8) {
+                for (x = 0; x < w; x++) {
+                    values[VAR_X] = x;
+                    dst16[x] = av_expr_eval(geq->e[plane], values, geq);
+                }
+                dst16 += linesize / 2;
+            } else {
+                for (x = 0; x < w; x++) {
+                    values[VAR_X] = x;
+                    dst[x] = av_expr_eval(geq->e[plane], values, geq);
+                }
+                dst += linesize;
             }
-            dst += linesize;
         }
     }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_histeq.c b/mythtv/external/FFmpeg/libavfilter/vf_histeq.c
index b3d2545b9f2..2449e10dea2 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_histeq.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_histeq.c
@@ -54,7 +54,7 @@ enum HisteqAntibanding {
     HISTEQ_ANTIBANDING_NB,
 };
 
-typedef struct {
+typedef struct HisteqContext {
     const AVClass *class;
     float strength;
     float intensity;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_histogram.c b/mythtv/external/FFmpeg/libavfilter/vf_histogram.c
index f04f5dea104..5185992de60 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_histogram.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_histogram.c
@@ -56,10 +56,11 @@ typedef struct HistogramContext {
 static const AVOption histogram_options[] = {
     { "level_height", "set level height", OFFSET(level_height), AV_OPT_TYPE_INT, {.i64=200}, 50, 2048, FLAGS},
     { "scale_height", "set scale height", OFFSET(scale_height), AV_OPT_TYPE_INT, {.i64=12}, 0, 40, FLAGS},
-    { "display_mode", "set display mode", OFFSET(display_mode), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, "display_mode"},
-    { "d",            "set display mode", OFFSET(display_mode), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, "display_mode"},
-        { "parade",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "display_mode" },
+    { "display_mode", "set display mode", OFFSET(display_mode), AV_OPT_TYPE_INT, {.i64=2}, 0, 2, FLAGS, "display_mode"},
+    { "d",            "set display mode", OFFSET(display_mode), AV_OPT_TYPE_INT, {.i64=2}, 0, 2, FLAGS, "display_mode"},
         { "overlay", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "display_mode" },
+        { "parade",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "display_mode" },
+        { "stack",   NULL, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "display_mode" },
     { "levels_mode", "set levels mode", OFFSET(levels_mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "levels_mode"},
     { "m",           "set levels mode", OFFSET(levels_mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "levels_mode"},
         { "linear",      NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "levels_mode" },
@@ -87,7 +88,7 @@ static const enum AVPixelFormat levels_in_pix_fmts[] = {
     AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
     AV_PIX_FMT_GBRAP,    AV_PIX_FMT_GBRP,
-    AV_PIX_FMT_GBRP9,    AV_PIX_FMT_GBRP10,
+    AV_PIX_FMT_GBRP9,    AV_PIX_FMT_GBRP10,  AV_PIX_FMT_GBRAP10,
     AV_PIX_FMT_GBRP12,   AV_PIX_FMT_GBRAP12,
     AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_NONE
@@ -124,7 +125,7 @@ static const enum AVPixelFormat levels_out_rgb9_pix_fmts[] = {
 };
 
 static const enum AVPixelFormat levels_out_rgb10_pix_fmts[] = {
-    AV_PIX_FMT_GBRP10,
+    AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
     AV_PIX_FMT_NONE
 };
 
@@ -199,7 +200,9 @@ static int config_input(AVFilterLink *inlink)
     h->mult = h->histogram_size / 256;
 
     switch (inlink->format) {
+    case AV_PIX_FMT_GBRAP12:
     case AV_PIX_FMT_GBRP12:
+    case AV_PIX_FMT_GBRAP10:
     case AV_PIX_FMT_GBRP10:
     case AV_PIX_FMT_GBRP9:
     case AV_PIX_FMT_GBRAP:
@@ -233,8 +236,8 @@ static int config_output(AVFilterLink *outlink)
         if ((1 << i) & h->components)
             ncomp++;
     }
-    outlink->w = h->histogram_size;
-    outlink->h = (h->level_height + h->scale_height) * FFMAX(ncomp * h->display_mode, 1);
+    outlink->w = h->histogram_size * FFMAX(ncomp * (h->display_mode == 1), 1);
+    outlink->h = (h->level_height + h->scale_height) * FFMAX(ncomp * (h->display_mode == 2), 1);
 
     h->odesc = av_pix_fmt_desc_get(outlink->format);
     h->dncomp = h->odesc->nb_components;
@@ -286,11 +289,12 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         const int width = h->planewidth[p];
         double max_hval_log;
         unsigned max_hval = 0;
-        int start;
+        int start, startx;
 
         if (!((1 << k) & h->components))
             continue;
-        start = m++ * (h->level_height + h->scale_height) * h->display_mode;
+        startx = m * h->histogram_size * (h->display_mode == 1);
+        start = m++ * (h->level_height + h->scale_height) * (h->display_mode == 2);
 
         if (h->histogram_size <= 256) {
             for (i = 0; i < height; i++) {
@@ -310,7 +314,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
             max_hval = FFMAX(max_hval, h->histogram[i]);
         max_hval_log = log2(max_hval + 1);
 
-        for (i = 0; i < outlink->w; i++) {
+        for (i = 0; i < h->histogram_size; i++) {
             int col_height;
 
             if (h->levels_mode)
@@ -322,26 +326,26 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
                 for (j = h->level_height - 1; j >= col_height; j--) {
                     if (h->display_mode) {
                         for (l = 0; l < h->dncomp; l++)
-                            out->data[l][(j + start) * out->linesize[l] + i] = h->fg_color[l];
+                            out->data[l][(j + start) * out->linesize[l] + startx + i] = h->fg_color[l];
                     } else {
-                        out->data[p][(j + start) * out->linesize[p] + i] = 255;
+                        out->data[p][(j + start) * out->linesize[p] + startx + i] = 255;
                     }
                 }
                 for (j = h->level_height + h->scale_height - 1; j >= h->level_height; j--)
-                    out->data[p][(j + start) * out->linesize[p] + i] = i;
+                    out->data[p][(j + start) * out->linesize[p] + startx + i] = i;
             } else {
                 const int mult = h->mult;
 
                 for (j = h->level_height - 1; j >= col_height; j--) {
                     if (h->display_mode) {
                         for (l = 0; l < h->dncomp; l++)
-                            AV_WN16(out->data[l] + (j + start) * out->linesize[l] + i * 2, h->fg_color[l] * mult);
+                            AV_WN16(out->data[l] + (j + start) * out->linesize[l] + startx * 2 + i * 2, h->fg_color[l] * mult);
                     } else {
-                        AV_WN16(out->data[p] + (j + start) * out->linesize[p] + i * 2, 255 * mult);
+                        AV_WN16(out->data[p] + (j + start) * out->linesize[p] + startx * 2 + i * 2, 255 * mult);
                     }
                 }
                 for (j = h->level_height + h->scale_height - 1; j >= h->level_height; j--)
-                    AV_WN16(out->data[p] + (j + start) * out->linesize[p] + i * 2, i);
+                    AV_WN16(out->data[p] + (j + start) * out->linesize[p] + startx * 2 + i * 2, i);
             }
         }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_hqx.c b/mythtv/external/FFmpeg/libavfilter/vf_hqx.c
index 5f63b2a3f9e..16a1be7bd4d 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_hqx.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_hqx.c
@@ -34,7 +34,7 @@
 
 typedef int (*hqxfunc_t)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
 
-typedef struct {
+typedef struct HQXContext {
     const AVClass *class;
     int n;
     hqxfunc_t func;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_hue.c b/mythtv/external/FFmpeg/libavfilter/vf_hue.c
index b5d72136a19..45a5a1a92f5 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_hue.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_hue.c
@@ -57,7 +57,7 @@ enum var_name {
     VAR_NB
 };
 
-typedef struct {
+typedef struct HueContext {
     const    AVClass *class;
     float    hue_deg; /* hue expressed in degrees */
     float    hue; /* hue expressed in radians */
@@ -318,7 +318,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)
         av_frame_copy_props(outpic, inpic);
     }
 
-    hue->var_values[VAR_N]   = inlink->frame_count;
+    hue->var_values[VAR_N]   = inlink->frame_count_out;
     hue->var_values[VAR_T]   = TS2T(inpic->pts, inlink->time_base);
     hue->var_values[VAR_PTS] = TS2D(inpic->pts);
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_hwdownload.c b/mythtv/external/FFmpeg/libavfilter/vf_hwdownload.c
index 1e8d81906da..33af30cf402 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_hwdownload.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_hwdownload.c
@@ -142,7 +142,8 @@ static int hwdownload_filter_frame(AVFilterLink *link, AVFrame *input)
         goto fail;
     }
 
-    output = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+    output = ff_get_video_buffer(outlink, ctx->hwframes->width,
+                                 ctx->hwframes->height);
     if (!output) {
         err = AVERROR(ENOMEM);
         goto fail;
@@ -154,6 +155,9 @@ static int hwdownload_filter_frame(AVFilterLink *link, AVFrame *input)
         goto fail;
     }
 
+    output->width  = outlink->w;
+    output->height = outlink->h;
+
     err = av_frame_copy_props(output, input);
     if (err < 0)
         goto fail;
@@ -210,4 +214,5 @@ AVFilter ff_vf_hwdownload = {
     .priv_class    = &hwdownload_class,
     .inputs        = hwdownload_inputs,
     .outputs       = hwdownload_outputs,
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_hwmap.c b/mythtv/external/FFmpeg/libavfilter/vf_hwmap.c
new file mode 100644
index 00000000000..8277241dc4e
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_hwmap.c
@@ -0,0 +1,426 @@
+/*
+ * 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/buffer.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/log.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+typedef struct HWMapContext {
+    const AVClass *class;
+
+    AVBufferRef   *hwframes_ref;
+
+    int            mode;
+    char          *derive_device_type;
+    int            reverse;
+} HWMapContext;
+
+static int hwmap_query_formats(AVFilterContext *avctx)
+{
+    int ret;
+
+    if ((ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
+                              &avctx->inputs[0]->out_formats)) < 0 ||
+        (ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
+                              &avctx->outputs[0]->in_formats)) < 0)
+        return ret;
+
+    return 0;
+}
+
+static int hwmap_config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *avctx = outlink->src;
+    HWMapContext      *ctx = avctx->priv;
+    AVFilterLink   *inlink = avctx->inputs[0];
+    AVHWFramesContext *hwfc;
+    AVBufferRef *device;
+    const AVPixFmtDescriptor *desc;
+    int err, device_is_derived;
+
+    av_log(avctx, AV_LOG_DEBUG, "Configure hwmap %s -> %s.\n",
+           av_get_pix_fmt_name(inlink->format),
+           av_get_pix_fmt_name(outlink->format));
+
+    av_buffer_unref(&ctx->hwframes_ref);
+
+    device = avctx->hw_device_ctx;
+    device_is_derived = 0;
+
+    if (inlink->hw_frames_ctx) {
+        hwfc = (AVHWFramesContext*)inlink->hw_frames_ctx->data;
+
+        if (ctx->derive_device_type) {
+            enum AVHWDeviceType type;
+
+            type = av_hwdevice_find_type_by_name(ctx->derive_device_type);
+            if (type == AV_HWDEVICE_TYPE_NONE) {
+                av_log(avctx, AV_LOG_ERROR, "Invalid device type.\n");
+                err = AVERROR(EINVAL);
+                goto fail;
+            }
+
+            err = av_hwdevice_ctx_create_derived(&device, type,
+                                                 hwfc->device_ref, 0);
+            if (err < 0) {
+                av_log(avctx, AV_LOG_ERROR, "Failed to created derived "
+                       "device context: %d.\n", err);
+                goto fail;
+            }
+            device_is_derived = 1;
+        }
+
+        desc = av_pix_fmt_desc_get(outlink->format);
+        if (!desc) {
+            err = AVERROR(EINVAL);
+            goto fail;
+        }
+
+        if (inlink->format == hwfc->format &&
+            (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
+            !ctx->reverse) {
+            // Map between two hardware formats (including the case of
+            // undoing an existing mapping).
+
+            if (!device) {
+                av_log(avctx, AV_LOG_ERROR, "A device reference is "
+                       "required to map to a hardware format.\n");
+                err = AVERROR(EINVAL);
+                goto fail;
+            }
+
+            err = av_hwframe_ctx_create_derived(&ctx->hwframes_ref,
+                                                outlink->format,
+                                                device,
+                                                inlink->hw_frames_ctx, 0);
+            if (err < 0) {
+                av_log(avctx, AV_LOG_ERROR, "Failed to create derived "
+                       "frames context: %d.\n", err);
+                goto fail;
+            }
+
+        } else if (inlink->format == hwfc->format &&
+                   (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
+                   ctx->reverse) {
+            // Map between two hardware formats, but do it in reverse.
+            // Make a new hwframe context for the target type, and then
+            // overwrite the input hwframe context with a derived context
+            // mapped from that back to the source type.
+            AVBufferRef *source;
+            AVHWFramesContext *frames;
+
+            ctx->hwframes_ref = av_hwframe_ctx_alloc(device);
+            if (!ctx->hwframes_ref) {
+                err = AVERROR(ENOMEM);
+                goto fail;
+            }
+            frames = (AVHWFramesContext*)ctx->hwframes_ref->data;
+
+            frames->format    = outlink->format;
+            frames->sw_format = hwfc->sw_format;
+            frames->width     = hwfc->width;
+            frames->height    = hwfc->height;
+            frames->initial_pool_size = 64;
+
+            err = av_hwframe_ctx_init(ctx->hwframes_ref);
+            if (err < 0) {
+                av_log(avctx, AV_LOG_ERROR, "Failed to initialise "
+                       "target frames context: %d.\n", err);
+                goto fail;
+            }
+
+            err = av_hwframe_ctx_create_derived(&source,
+                                                inlink->format,
+                                                hwfc->device_ref,
+                                                ctx->hwframes_ref,
+                                                ctx->mode);
+            if (err < 0) {
+                av_log(avctx, AV_LOG_ERROR, "Failed to create "
+                       "derived source frames context: %d.\n", err);
+                goto fail;
+            }
+
+            // Here is the naughty bit.  This overwriting changes what
+            // ff_get_video_buffer() in the previous filter returns -
+            // it will now give a frame allocated here mapped back to
+            // the format it expects.  If there were any additional
+            // constraints on the output frames there then this may
+            // break nastily.
+            av_buffer_unref(&inlink->hw_frames_ctx);
+            inlink->hw_frames_ctx = source;
+
+        } else if ((outlink->format == hwfc->format &&
+                    inlink->format  == hwfc->sw_format) ||
+                   inlink->format == hwfc->format) {
+            // Map from a hardware format to a software format, or
+            // undo an existing such mapping.
+
+            ctx->hwframes_ref = av_buffer_ref(inlink->hw_frames_ctx);
+            if (!ctx->hwframes_ref) {
+                err = AVERROR(ENOMEM);
+                goto fail;
+            }
+
+        } else {
+            // Non-matching formats - not supported.
+
+            av_log(avctx, AV_LOG_ERROR, "Unsupported formats for "
+                   "hwmap: from %s (%s) to %s.\n",
+                   av_get_pix_fmt_name(inlink->format),
+                   av_get_pix_fmt_name(hwfc->format),
+                   av_get_pix_fmt_name(outlink->format));
+            err = AVERROR(EINVAL);
+            goto fail;
+        }
+    } else if (avctx->hw_device_ctx) {
+        // Map from a software format to a hardware format.  This
+        // creates a new hwframe context like hwupload, but then
+        // returns frames mapped from that to the previous link in
+        // order to fill them without an additional copy.
+
+        if (!device) {
+            av_log(avctx, AV_LOG_ERROR, "A device reference is "
+                   "required to create new frames with reverse "
+                   "mapping.\n");
+            err = AVERROR(EINVAL);
+            goto fail;
+        }
+
+        ctx->reverse = 1;
+
+        ctx->hwframes_ref = av_hwframe_ctx_alloc(device);
+        if (!ctx->hwframes_ref) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+        hwfc = (AVHWFramesContext*)ctx->hwframes_ref->data;
+
+        hwfc->format    = outlink->format;
+        hwfc->sw_format = inlink->format;
+        hwfc->width     = inlink->w;
+        hwfc->height    = inlink->h;
+
+        err = av_hwframe_ctx_init(ctx->hwframes_ref);
+        if (err < 0) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to create frame "
+                   "context for reverse mapping: %d.\n", err);
+            goto fail;
+        }
+
+    } else {
+        av_log(avctx, AV_LOG_ERROR, "Mapping requires a hardware "
+               "context (a device, or frames on input).\n");
+        return AVERROR(EINVAL);
+    }
+
+    outlink->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
+    if (!outlink->hw_frames_ctx) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    outlink->w = inlink->w;
+    outlink->h = inlink->h;
+
+    if (device_is_derived)
+        av_buffer_unref(&device);
+    return 0;
+
+fail:
+    if (device_is_derived)
+        av_buffer_unref(&device);
+    av_buffer_unref(&ctx->hwframes_ref);
+    return err;
+}
+
+static AVFrame *hwmap_get_buffer(AVFilterLink *inlink, int w, int h)
+{
+    AVFilterContext *avctx = inlink->dst;
+    AVFilterLink  *outlink = avctx->outputs[0];
+    HWMapContext      *ctx = avctx->priv;
+
+    if (ctx->reverse && !inlink->hw_frames_ctx) {
+        AVFrame *src, *dst;
+        int err;
+
+        src = ff_get_video_buffer(outlink, w, h);
+        if (!src) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to allocate source "
+                   "frame for software mapping.\n");
+            return NULL;
+        }
+
+        dst = av_frame_alloc();
+        if (!dst) {
+            av_frame_free(&src);
+            return NULL;
+        }
+
+        err = av_hwframe_map(dst, src, ctx->mode);
+        if (err) {
+            av_log(avctx, AV_LOG_ERROR, "Failed to map frame to "
+                   "software: %d.\n", err);
+            av_frame_free(&src);
+            av_frame_free(&dst);
+            return NULL;
+        }
+
+        av_frame_free(&src);
+        return dst;
+    } else {
+        return ff_default_get_video_buffer(inlink, w, h);
+    }
+}
+
+static int hwmap_filter_frame(AVFilterLink *link, AVFrame *input)
+{
+    AVFilterContext *avctx = link->dst;
+    AVFilterLink  *outlink = avctx->outputs[0];
+    HWMapContext      *ctx = avctx->priv;
+    AVFrame *map = NULL;
+    int err;
+
+    av_log(ctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",
+           av_get_pix_fmt_name(input->format),
+           input->width, input->height, input->pts);
+
+    map = av_frame_alloc();
+    if (!map) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    map->format = outlink->format;
+    map->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
+    if (!map->hw_frames_ctx) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    if (ctx->reverse && !input->hw_frames_ctx) {
+        // If we mapped backwards from hardware to software, we need
+        // to attach the hardware frame context to the input frame to
+        // make the mapping visible to av_hwframe_map().
+        input->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);
+        if (!input->hw_frames_ctx) {
+            err = AVERROR(ENOMEM);
+            goto fail;
+        }
+    }
+
+    err = av_hwframe_map(map, input, ctx->mode);
+    if (err < 0) {
+        av_log(avctx, AV_LOG_ERROR, "Failed to map frame: %d.\n", err);
+        goto fail;
+    }
+
+    err = av_frame_copy_props(map, input);
+    if (err < 0)
+        goto fail;
+
+    av_frame_free(&input);
+
+    av_log(ctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",
+           av_get_pix_fmt_name(map->format),
+           map->width, map->height, map->pts);
+
+    return ff_filter_frame(outlink, map);
+
+fail:
+    av_frame_free(&input);
+    av_frame_free(&map);
+    return err;
+}
+
+static av_cold void hwmap_uninit(AVFilterContext *avctx)
+{
+    HWMapContext *ctx = avctx->priv;
+
+    av_buffer_unref(&ctx->hwframes_ref);
+}
+
+#define OFFSET(x) offsetof(HWMapContext, x)
+#define FLAGS (AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM)
+static const AVOption hwmap_options[] = {
+    { "mode", "Frame mapping mode",
+      OFFSET(mode), AV_OPT_TYPE_FLAGS,
+      { .i64 = AV_HWFRAME_MAP_READ | AV_HWFRAME_MAP_WRITE },
+      0, INT_MAX, FLAGS, "mode" },
+
+    { "read", "Mapping should be readable",
+      0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_READ },
+      INT_MIN, INT_MAX, FLAGS, "mode" },
+    { "write", "Mapping should be writeable",
+      0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_WRITE },
+      INT_MIN, INT_MAX, FLAGS, "mode" },
+    { "overwrite", "Mapping will always overwrite the entire frame",
+      0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_OVERWRITE },
+      INT_MIN, INT_MAX, FLAGS, "mode" },
+    { "direct", "Mapping should not involve any copying",
+      0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_DIRECT },
+      INT_MIN, INT_MAX, FLAGS, "mode" },
+
+    { "derive_device", "Derive a new device of this type",
+      OFFSET(derive_device_type), AV_OPT_TYPE_STRING,
+      { .str = NULL }, 0, 0, FLAGS },
+    { "reverse", "Map in reverse (create and allocate in the sink)",
+      OFFSET(reverse), AV_OPT_TYPE_INT,
+      { .i64 = 0 }, 0, 1, FLAGS },
+
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(hwmap);
+
+static const AVFilterPad hwmap_inputs[] = {
+    {
+        .name             = "default",
+        .type             = AVMEDIA_TYPE_VIDEO,
+        .get_video_buffer = hwmap_get_buffer,
+        .filter_frame     = hwmap_filter_frame,
+    },
+    { NULL }
+};
+
+static const AVFilterPad hwmap_outputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = hwmap_config_output,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_hwmap = {
+    .name           = "hwmap",
+    .description    = NULL_IF_CONFIG_SMALL("Map hardware frames"),
+    .uninit         = hwmap_uninit,
+    .priv_size      = sizeof(HWMapContext),
+    .priv_class     = &hwmap_class,
+    .query_formats  = hwmap_query_formats,
+    .inputs         = hwmap_inputs,
+    .outputs        = hwmap_outputs,
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_hwupload.c b/mythtv/external/FFmpeg/libavfilter/vf_hwupload.c
index 08af2dd49fe..157686b7b3b 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_hwupload.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_hwupload.c
@@ -74,17 +74,15 @@ static int hwupload_query_formats(AVFilterContext *avctx)
     if (input_pix_fmts) {
         for (i = 0; input_pix_fmts[i] != AV_PIX_FMT_NONE; i++) {
             err = ff_add_format(&input_formats, input_pix_fmts[i]);
-            if (err < 0) {
-                ff_formats_unref(&input_formats);
+            if (err < 0)
                 goto fail;
-            }
         }
     }
 
-    ff_formats_ref(input_formats, &avctx->inputs[0]->out_formats);
-
-    ff_formats_ref(ff_make_format_list(output_pix_fmts),
-                   &avctx->outputs[0]->in_formats);
+    if ((err = ff_formats_ref(input_formats, &avctx->inputs[0]->out_formats)) < 0 ||
+        (err = ff_formats_ref(ff_make_format_list(output_pix_fmts),
+                              &avctx->outputs[0]->in_formats)) < 0)
+        goto fail;
 
     av_hwframe_constraints_free(&constraints);
     return 0;
@@ -161,15 +159,10 @@ static int hwupload_filter_frame(AVFilterLink *link, AVFrame *input)
     if (input->format == outlink->format)
         return ff_filter_frame(outlink, input);
 
-    output = av_frame_alloc();
+    output = ff_get_video_buffer(outlink, outlink->w, outlink->h);
     if (!output) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-
-    err = av_hwframe_get_buffer(ctx->hwframes_ref, output, 0);
-    if (err < 0) {
         av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame to upload to.\n");
+        err = AVERROR(ENOMEM);
         goto fail;
     }
 
@@ -238,4 +231,5 @@ AVFilter ff_vf_hwupload = {
     .priv_class    = &hwupload_class,
     .inputs        = hwupload_inputs,
     .outputs       = hwupload_outputs,
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_hwupload_cuda.c b/mythtv/external/FFmpeg/libavfilter/vf_hwupload_cuda.c
index c22221c6994..063f0285c35 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_hwupload_cuda.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_hwupload_cuda.c
@@ -18,7 +18,6 @@
 
 #include "libavutil/buffer.h"
 #include "libavutil/hwcontext.h"
-#include "libavutil/hwcontext_cuda.h"
 #include "libavutil/log.h"
 #include "libavutil/opt.h"
 
@@ -35,60 +34,14 @@ typedef struct CudaUploadContext {
     AVBufferRef *hwframe;
 } CudaUploadContext;
 
-static void cudaupload_ctx_free(AVHWDeviceContext *ctx)
-{
-    AVCUDADeviceContext *hwctx = ctx->hwctx;
-    cuCtxDestroy(hwctx->cuda_ctx);
-}
-
 static av_cold int cudaupload_init(AVFilterContext *ctx)
 {
     CudaUploadContext *s = ctx->priv;
+    char buf[64] = { 0 };
 
-    AVHWDeviceContext   *device_ctx;
-    AVCUDADeviceContext *device_hwctx;
-    CUdevice device;
-    CUcontext cuda_ctx = NULL, dummy;
-    CUresult err;
-    int ret;
-
-    err = cuInit(0);
-    if (err != CUDA_SUCCESS) {
-        av_log(ctx, AV_LOG_ERROR, "Could not initialize the CUDA driver API\n");
-        return AVERROR_UNKNOWN;
-    }
-
-    err = cuDeviceGet(&device, s->device_idx);
-    if (err != CUDA_SUCCESS) {
-        av_log(ctx, AV_LOG_ERROR, "Could not get the device number %d\n", s->device_idx);
-        return AVERROR_UNKNOWN;
-    }
-
-    err = cuCtxCreate(&cuda_ctx, 0, device);
-    if (err != CUDA_SUCCESS) {
-        av_log(ctx, AV_LOG_ERROR, "Error creating a CUDA context\n");
-        return AVERROR_UNKNOWN;
-    }
-
-    cuCtxPopCurrent(&dummy);
-
-    s->hwdevice = av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_CUDA);
-    if (!s->hwdevice) {
-        cuCtxDestroy(cuda_ctx);
-        return AVERROR(ENOMEM);
-    }
-
-    device_ctx       = (AVHWDeviceContext*)s->hwdevice->data;
-    device_ctx->free = cudaupload_ctx_free;
-
-    device_hwctx = device_ctx->hwctx;
-    device_hwctx->cuda_ctx = cuda_ctx;
+    snprintf(buf, sizeof(buf), "%d", s->device_idx);
 
-    ret = av_hwdevice_ctx_init(s->hwdevice);
-    if (ret < 0)
-        return ret;
-
-    return 0;
+    return av_hwdevice_ctx_create(&s->hwdevice, AV_HWDEVICE_TYPE_CUDA, buf, NULL, 0);
 }
 
 static av_cold void cudaupload_uninit(AVFilterContext *ctx)
@@ -101,18 +54,28 @@ static av_cold void cudaupload_uninit(AVFilterContext *ctx)
 
 static int cudaupload_query_formats(AVFilterContext *ctx)
 {
+    int ret;
+
     static const enum AVPixelFormat input_pix_fmts[] = {
         AV_PIX_FMT_NV12, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P,
+        AV_PIX_FMT_P010, AV_PIX_FMT_P016, AV_PIX_FMT_YUV444P16,
         AV_PIX_FMT_NONE,
     };
     static const enum AVPixelFormat output_pix_fmts[] = {
         AV_PIX_FMT_CUDA, AV_PIX_FMT_NONE,
     };
     AVFilterFormats *in_fmts  = ff_make_format_list(input_pix_fmts);
-    AVFilterFormats *out_fmts = ff_make_format_list(output_pix_fmts);
+    AVFilterFormats *out_fmts;
+
+    ret = ff_formats_ref(in_fmts, &ctx->inputs[0]->out_formats);
+    if (ret < 0)
+        return ret;
+
+    out_fmts = ff_make_format_list(output_pix_fmts);
 
-    ff_formats_ref(in_fmts,  &ctx->inputs[0]->out_formats);
-    ff_formats_ref(out_fmts, &ctx->outputs[0]->in_formats);
+    ret = ff_formats_ref(out_fmts, &ctx->outputs[0]->in_formats);
+    if (ret < 0)
+        return ret;
 
     return 0;
 }
@@ -134,8 +97,8 @@ static int cudaupload_config_output(AVFilterLink *outlink)
     hwframe_ctx            = (AVHWFramesContext*)s->hwframe->data;
     hwframe_ctx->format    = AV_PIX_FMT_CUDA;
     hwframe_ctx->sw_format = inlink->format;
-    hwframe_ctx->width     = FFALIGN(inlink->w, 16);
-    hwframe_ctx->height    = FFALIGN(inlink->h, 16);
+    hwframe_ctx->width     = inlink->w;
+    hwframe_ctx->height    = inlink->h;
 
     ret = av_hwframe_ctx_init(s->hwframe);
     if (ret < 0)
@@ -151,21 +114,17 @@ static int cudaupload_config_output(AVFilterLink *outlink)
 static int cudaupload_filter_frame(AVFilterLink *link, AVFrame *in)
 {
     AVFilterContext   *ctx = link->dst;
-    CudaUploadContext   *s = ctx->priv;
+    AVFilterLink  *outlink = ctx->outputs[0];
 
     AVFrame *out = NULL;
     int ret;
 
-    out = av_frame_alloc();
+    out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
     if (!out) {
         ret = AVERROR(ENOMEM);
         goto fail;
     }
 
-    ret = av_hwframe_get_buffer(s->hwframe, out, 0);
-    if (ret < 0)
-        goto fail;
-
     out->width  = in->width;
     out->height = in->height;
 
@@ -191,7 +150,7 @@ static int cudaupload_filter_frame(AVFilterLink *link, AVFrame *in)
 #define OFFSET(x) offsetof(CudaUploadContext, x)
 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
 static const AVOption cudaupload_options[] = {
-    { "device", "Number of the device to use", OFFSET(device_idx), AV_OPT_TYPE_INT, { .i64 = 0 }, .flags = FLAGS },
+    { "device", "Number of the device to use", OFFSET(device_idx), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
     { NULL },
 };
 
@@ -229,4 +188,6 @@ AVFilter ff_vf_hwupload_cuda = {
 
     .inputs    = cudaupload_inputs,
     .outputs   = cudaupload_outputs,
+
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_hysteresis.c b/mythtv/external/FFmpeg/libavfilter/vf_hysteresis.c
index 8f05b716c9d..a788e1b9ee6 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_hysteresis.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_hysteresis.c
@@ -78,8 +78,8 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
-        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_NONE
     };
 
@@ -342,16 +342,10 @@ static int config_output(AVFilterLink *outlink)
     return ff_framesync_configure(&s->fs);
 }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
+static int activate(AVFilterContext *ctx)
 {
-    HysteresisContext *s = inlink->dst->priv;
-    return ff_framesync_filter_frame(&s->fs, inlink, buf);
-}
-
-static int request_frame(AVFilterLink *outlink)
-{
-    HysteresisContext *s = outlink->src->priv;
-    return ff_framesync_request_frame(&s->fs, outlink);
+    HysteresisContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
@@ -367,13 +361,11 @@ static const AVFilterPad hysteresis_inputs[] = {
     {
         .name         = "base",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
         .config_props = config_input,
     },
     {
         .name         = "alt",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },
     { NULL }
 };
@@ -383,7 +375,6 @@ static const AVFilterPad hysteresis_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -394,6 +385,7 @@ AVFilter ff_vf_hysteresis = {
     .priv_size     = sizeof(HysteresisContext),
     .uninit        = uninit,
     .query_formats = query_formats,
+    .activate      = activate,
     .inputs        = hysteresis_inputs,
     .outputs       = hysteresis_outputs,
     .priv_class    = &hysteresis_class,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_idet.c b/mythtv/external/FFmpeg/libavfilter/vf_idet.c
index 87d4144e9e1..14f031aaa95 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_idet.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_idet.c
@@ -120,7 +120,7 @@ static void filter(AVFilterContext *ctx)
     Type type, best_type;
     RepeatedField repeat;
     int match = 0;
-    AVDictionary **metadata = avpriv_frame_get_metadatap(idet->cur);
+    AVDictionary **metadata = &idet->cur->metadata;
 
     for (i = 0; i < idet->csp->nb_components; i++) {
         int w = idet->cur->width;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_idet.h b/mythtv/external/FFmpeg/libavfilter/vf_idet.h
index 47e3d9ce81a..afd8947055d 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_idet.h
+++ b/mythtv/external/FFmpeg/libavfilter/vf_idet.h
@@ -39,7 +39,7 @@ typedef enum {
     REPEAT_BOTTOM,
 } RepeatedField;
 
-typedef struct {
+typedef struct IDETContext {
     const AVClass *class;
     float interlace_threshold;
     float progressive_threshold;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_il.c b/mythtv/external/FFmpeg/libavfilter/vf_il.c
index e0bf8d59412..ae0cc1938a3 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_il.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_il.c
@@ -36,7 +36,7 @@ enum FilterMode {
     MODE_DEINTERLEAVE
 };
 
-typedef struct {
+typedef struct IlContext {
     const AVClass *class;
     int luma_mode, chroma_mode, alpha_mode; ///<FilterMode
     int luma_swap, chroma_swap, alpha_swap;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_interlace.c b/mythtv/external/FFmpeg/libavfilter/vf_interlace.c
index efa31287274..731069818f2 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_interlace.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_interlace.c
@@ -3,6 +3,7 @@
  * Copyright (c) 2010 Baptiste Coudurier
  * Copyright (c) 2011 Stefano Sabatini
  * Copyright (c) 2013 Vittorio Giovara <vittorio.giovara@gmail.com>
+ * Copyright (c) 2017 Thomas Mundt <tmundt75@gmail.com>
  *
  * This file is part of FFmpeg.
  *
@@ -47,17 +48,24 @@ static const AVOption interlace_options[] = {
     { "bff", "bottom field first", 0,
         AV_OPT_TYPE_CONST, {.i64 = MODE_BFF }, INT_MIN, INT_MAX, .flags = FLAGS, .unit = "scan" },
     { "lowpass", "set vertical low-pass filter", OFFSET(lowpass),
-        AV_OPT_TYPE_BOOL,  {.i64 = 1 },        0, 1, .flags = FLAGS },
+        AV_OPT_TYPE_INT,   {.i64 = VLPF_LIN }, 0, 2, .flags = FLAGS, .unit = "lowpass" },
+    { "off",     "disable vertical low-pass filter", 0,
+        AV_OPT_TYPE_CONST, {.i64 = VLPF_OFF }, INT_MIN, INT_MAX, .flags = FLAGS, .unit = "lowpass" },
+    { "linear",  "linear vertical low-pass filter",  0,
+        AV_OPT_TYPE_CONST, {.i64 = VLPF_LIN }, INT_MIN, INT_MAX, .flags = FLAGS, .unit = "lowpass" },
+    { "complex", "complex vertical low-pass filter", 0,
+        AV_OPT_TYPE_CONST, {.i64 = VLPF_CMP }, INT_MIN, INT_MAX, .flags = FLAGS, .unit = "lowpass" },
     { NULL }
 };
 
 AVFILTER_DEFINE_CLASS(interlace);
 
 static void lowpass_line_c(uint8_t *dstp, ptrdiff_t linesize,
-                           const uint8_t *srcp,
-                           const uint8_t *srcp_above,
-                           const uint8_t *srcp_below)
+                           const uint8_t *srcp, ptrdiff_t mref,
+                           ptrdiff_t pref, int clip_max)
 {
+    const uint8_t *srcp_above = srcp + mref;
+    const uint8_t *srcp_below = srcp + pref;
     int i;
     for (i = 0; i < linesize; i++) {
         // this calculation is an integer representation of
@@ -67,11 +75,98 @@ static void lowpass_line_c(uint8_t *dstp, ptrdiff_t linesize,
     }
 }
 
+static void lowpass_line_c_16(uint8_t *dst8, ptrdiff_t linesize,
+                              const uint8_t *src8, ptrdiff_t mref,
+                              ptrdiff_t pref, int clip_max)
+{
+    uint16_t *dstp = (uint16_t *)dst8;
+    const uint16_t *srcp = (const uint16_t *)src8;
+    const uint16_t *srcp_above = srcp + mref / 2;
+    const uint16_t *srcp_below = srcp + pref / 2;
+    int i, src_x;
+    for (i = 0; i < linesize; i++) {
+        // this calculation is an integer representation of
+        // '0.5 * current + 0.25 * above + 0.25 * below'
+        // '1 +' is for rounding.
+        src_x   = av_le2ne16(srcp[i]) << 1;
+        dstp[i] = av_le2ne16((1 + src_x + av_le2ne16(srcp_above[i])
+                             + av_le2ne16(srcp_below[i])) >> 2);
+    }
+}
+
+static void lowpass_line_complex_c(uint8_t *dstp, ptrdiff_t linesize,
+                                   const uint8_t *srcp, ptrdiff_t mref,
+                                   ptrdiff_t pref, int clip_max)
+{
+    const uint8_t *srcp_above = srcp + mref;
+    const uint8_t *srcp_below = srcp + pref;
+    const uint8_t *srcp_above2 = srcp + mref * 2;
+    const uint8_t *srcp_below2 = srcp + pref * 2;
+    int i, src_x, src_ab;
+    for (i = 0; i < linesize; i++) {
+        // this calculation is an integer representation of
+        // '0.75 * current + 0.25 * above + 0.25 * below - 0.125 * above2 - 0.125 * below2'
+        // '4 +' is for rounding.
+        src_x   = srcp[i] << 1;
+        src_ab  = srcp_above[i] + srcp_below[i];
+        dstp[i] = av_clip_uint8((4 + ((srcp[i] + src_x + src_ab) << 1)
+                                - srcp_above2[i] - srcp_below2[i]) >> 3);
+        // Prevent over-sharpening:
+        // dst must not exceed src when the average of above and below
+        // is less than src. And the other way around.
+        if (src_ab > src_x) {
+            if (dstp[i] < srcp[i])
+                dstp[i] = srcp[i];
+        } else if (dstp[i] > srcp[i])
+            dstp[i] = srcp[i];
+    }
+}
+
+static void lowpass_line_complex_c_16(uint8_t *dst8, ptrdiff_t linesize,
+                                      const uint8_t *src8, ptrdiff_t mref,
+                                      ptrdiff_t pref, int clip_max)
+{
+    uint16_t *dstp = (uint16_t *)dst8;
+    const uint16_t *srcp = (const uint16_t *)src8;
+    const uint16_t *srcp_above = srcp + mref / 2;
+    const uint16_t *srcp_below = srcp + pref / 2;
+    const uint16_t *srcp_above2 = srcp + mref;
+    const uint16_t *srcp_below2 = srcp + pref;
+    int i, dst_le, src_le, src_x, src_ab;
+    for (i = 0; i < linesize; i++) {
+        // this calculation is an integer representation of
+        // '0.75 * current + 0.25 * above + 0.25 * below - 0.125 * above2 - 0.125 * below2'
+        // '4 +' is for rounding.
+        src_le = av_le2ne16(srcp[i]);
+        src_x  = src_le << 1;
+        src_ab = av_le2ne16(srcp_above[i]) + av_le2ne16(srcp_below[i]);
+        dst_le = av_clip((4 + ((src_le + src_x + src_ab) << 1)
+                         - av_le2ne16(srcp_above2[i])
+                         - av_le2ne16(srcp_below2[i])) >> 3, 0, clip_max);
+        // Prevent over-sharpening:
+        // dst must not exceed src when the average of above and below
+        // is less than src. And the other way around.
+        if (src_ab > src_x) {
+            if (dst_le < src_le)
+                dstp[i] = av_le2ne16(src_le);
+            else
+                dstp[i] = av_le2ne16(dst_le);
+        } else if (dst_le > src_le) {
+            dstp[i] = av_le2ne16(src_le);
+        } else
+            dstp[i] = av_le2ne16(dst_le);
+    }
+}
+
 static const enum AVPixelFormat formats_supported[] = {
-    AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUVA420P,
-    AV_PIX_FMT_GRAY8,    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_NONE
+    AV_PIX_FMT_YUV410P,      AV_PIX_FMT_YUV411P,
+    AV_PIX_FMT_YUV420P,      AV_PIX_FMT_YUV422P,      AV_PIX_FMT_YUV444P,
+    AV_PIX_FMT_YUV420P10LE,  AV_PIX_FMT_YUV422P10LE,  AV_PIX_FMT_YUV444P10LE,
+    AV_PIX_FMT_YUV420P12LE,  AV_PIX_FMT_YUV422P12LE,  AV_PIX_FMT_YUV444P12LE,
+    AV_PIX_FMT_YUVA420P,     AV_PIX_FMT_YUVA422P,     AV_PIX_FMT_YUVA444P,
+    AV_PIX_FMT_YUVA420P10LE, AV_PIX_FMT_YUVA422P10LE, AV_PIX_FMT_YUVA444P10LE,
+    AV_PIX_FMT_GRAY8,        AV_PIX_FMT_YUVJ420P,     AV_PIX_FMT_YUVJ422P,
+    AV_PIX_FMT_YUVJ444P,     AV_PIX_FMT_YUVJ440P,     AV_PIX_FMT_NONE
 };
 
 static int query_formats(AVFilterContext *ctx)
@@ -114,9 +209,19 @@ static int config_out_props(AVFilterLink *outlink)
     outlink->time_base.num *= 2;
     outlink->frame_rate.den *= 2;
 
-
+    s->csp = av_pix_fmt_desc_get(outlink->format);
     if (s->lowpass) {
-        s->lowpass_line = lowpass_line_c;
+        if (s->lowpass == VLPF_LIN) {
+            if (s->csp->comp[0].depth > 8)
+                s->lowpass_line = lowpass_line_c_16;
+            else
+                s->lowpass_line = lowpass_line_c;
+        } else if (s->lowpass == VLPF_CMP) {
+            if (s->csp->comp[0].depth > 8)
+                s->lowpass_line = lowpass_line_complex_c_16;
+            else
+                s->lowpass_line = lowpass_line_complex_c;
+        }
         if (ARCH_X86)
             ff_interlace_init_x86(s);
     }
@@ -142,6 +247,9 @@ static void copy_picture_field(InterlaceContext *s,
         int lines = (plane == 1 || plane == 2) ? AV_CEIL_RSHIFT(inlink->h, vsub) : inlink->h;
         uint8_t *dstp = dst_frame->data[plane];
         const uint8_t *srcp = src_frame->data[plane];
+        int srcp_linesize = src_frame->linesize[plane] * 2;
+        int dstp_linesize = dst_frame->linesize[plane] * 2;
+        int clip_max = (1 << s->csp->comp[plane].depth) - 1;
 
         av_assert0(cols >= 0 || lines >= 0);
 
@@ -151,23 +259,24 @@ static void copy_picture_field(InterlaceContext *s,
             dstp += dst_frame->linesize[plane];
         }
         if (lowpass) {
-            int srcp_linesize = src_frame->linesize[plane] * 2;
-            int dstp_linesize = dst_frame->linesize[plane] * 2;
+            int x = 0;
+            if (lowpass == VLPF_CMP)
+                x = 1;
             for (j = lines; j > 0; j--) {
-                const uint8_t *srcp_above = srcp - src_frame->linesize[plane];
-                const uint8_t *srcp_below = srcp + src_frame->linesize[plane];
-                if (j == lines)
-                    srcp_above = srcp; // there is no line above
-                if (j == 1)
-                    srcp_below = srcp; // there is no line below
-                s->lowpass_line(dstp, cols, srcp, srcp_above, srcp_below);
+                ptrdiff_t pref = src_frame->linesize[plane];
+                ptrdiff_t mref = -pref;
+                if (j >= (lines - x))
+                    mref = 0;
+                else if (j <= (1 + x))
+                    pref = 0;
+                s->lowpass_line(dstp, cols, srcp, mref, pref, clip_max);
                 dstp += dstp_linesize;
                 srcp += srcp_linesize;
             }
         } else {
-            av_image_copy_plane(dstp, dst_frame->linesize[plane] * 2,
-                                srcp, src_frame->linesize[plane] * 2,
-                                cols, lines);
+            if (s->csp->comp[plane].depth > 8)
+                cols *= 2;
+            av_image_copy_plane(dstp, dstp_linesize, srcp, srcp_linesize, cols, lines);
         }
     }
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_kerndeint.c b/mythtv/external/FFmpeg/libavfilter/vf_kerndeint.c
index 4825ed5e3e2..057d15f9cb9 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_kerndeint.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_kerndeint.c
@@ -35,7 +35,7 @@
 #include "formats.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct KerndeintContext {
     const AVClass *class;
     int           frame; ///< frame count, starting from 0
     int           thresh, map, order, sharp, twoway;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_libopencv.c b/mythtv/external/FFmpeg/libavfilter/vf_libopencv.c
index f8ae9d5a6da..8128030b8c9 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_libopencv.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_libopencv.c
@@ -157,7 +157,8 @@ static int read_shape_from_file(int *cols, int *rows, int **values, const char *
         if (buf[i] == '\n') {
             if (*rows == INT_MAX) {
                 av_log(log_ctx, AV_LOG_ERROR, "Overflow on the number of rows in the file\n");
-                return AVERROR_INVALIDDATA;
+                ret = AVERROR_INVALIDDATA;
+                goto end;
             }
             ++(*rows);
             *cols = FFMAX(*cols, w);
@@ -171,10 +172,13 @@ static int read_shape_from_file(int *cols, int *rows, int **values, const char *
     if (*rows > (SIZE_MAX / sizeof(int) / *cols)) {
         av_log(log_ctx, AV_LOG_ERROR, "File with size %dx%d is too big\n",
                *rows, *cols);
-        return AVERROR_INVALIDDATA;
+        ret = AVERROR_INVALIDDATA;
+        goto end;
+    }
+    if (!(*values = av_mallocz_array(sizeof(int) * *rows, *cols))) {
+        ret = AVERROR(ENOMEM);
+        goto end;
     }
-    if (!(*values = av_mallocz_array(sizeof(int) * *rows, *cols)))
-        return AVERROR(ENOMEM);
 
     /* fill *values */
     p    = buf;
@@ -188,6 +192,8 @@ static int read_shape_from_file(int *cols, int *rows, int **values, const char *
                 (*values)[*cols*i + j] = !!av_isgraph(*(p++));
         }
     }
+
+end:
     av_file_unmap(buf, size);
 
 #ifdef DEBUG
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_libvmaf.c b/mythtv/external/FFmpeg/libavfilter/vf_libvmaf.c
new file mode 100644
index 00000000000..2c3a9f33493
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_libvmaf.c
@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) 2017 Ronald S. Bultje <rsbultje@gmail.com>
+ * Copyright (c) 2017 Ashish Pratap Singh <ashk43712@gmail.com>
+ *
+ * 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
+ * Calculate the VMAF between two input videos.
+ */
+
+#include <pthread.h>
+#include <libvmaf.h>
+#include "libavutil/avstring.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "avfilter.h"
+#include "drawutils.h"
+#include "formats.h"
+#include "framesync.h"
+#include "internal.h"
+#include "video.h"
+
+typedef struct LIBVMAFContext {
+    const AVClass *class;
+    FFFrameSync fs;
+    const AVPixFmtDescriptor *desc;
+    char *format;
+    int width;
+    int height;
+    double vmaf_score;
+    pthread_t vmaf_thread;
+    pthread_mutex_t lock;
+    pthread_cond_t cond;
+    int eof;
+    AVFrame *gmain;
+    AVFrame *gref;
+    int frame_set;
+    char *model_path;
+    char *log_path;
+    char *log_fmt;
+    int disable_clip;
+    int disable_avx;
+    int enable_transform;
+    int phone_model;
+    int psnr;
+    int ssim;
+    int ms_ssim;
+    char *pool;
+} LIBVMAFContext;
+
+#define OFFSET(x) offsetof(LIBVMAFContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption libvmaf_options[] = {
+    {"model_path",  "Set the model to be used for computing vmaf.",                     OFFSET(model_path), AV_OPT_TYPE_STRING, {.str="/usr/local/share/model/vmaf_v0.6.1.pkl"}, 0, 1, FLAGS},
+    {"log_path",  "Set the file path to be used to store logs.",                        OFFSET(log_path), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 1, FLAGS},
+    {"log_fmt",  "Set the format of the log (xml or json).",                            OFFSET(log_fmt), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 1, FLAGS},
+    {"enable_transform",  "Enables transform for computing vmaf.",                      OFFSET(enable_transform), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+    {"phone_model",  "Invokes the phone model that will generate higher VMAF scores.",  OFFSET(phone_model), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+    {"psnr",  "Enables computing psnr along with vmaf.",                                OFFSET(psnr), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+    {"ssim",  "Enables computing ssim along with vmaf.",                                OFFSET(ssim), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+    {"ms_ssim",  "Enables computing ms-ssim along with vmaf.",                          OFFSET(ms_ssim), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
+    {"pool",  "Set the pool method to be used for computing vmaf.",                     OFFSET(pool), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 1, FLAGS},
+    { NULL }
+};
+
+FRAMESYNC_DEFINE_CLASS(libvmaf, LIBVMAFContext, fs);
+
+#define read_frame_fn(type, bits)                                               \
+    static int read_frame_##bits##bit(float *ref_data, float *main_data,        \
+                                      float *temp_data, int stride, void *ctx)  \
+{                                                                               \
+    LIBVMAFContext *s = (LIBVMAFContext *) ctx;                                 \
+    int ret;                                                                    \
+    \
+    pthread_mutex_lock(&s->lock);                                               \
+    \
+    while (!s->frame_set && !s->eof) {                                          \
+        pthread_cond_wait(&s->cond, &s->lock);                                  \
+    }                                                                           \
+    \
+    if (s->frame_set) {                                                         \
+        int ref_stride = s->gref->linesize[0];                                  \
+        int main_stride = s->gmain->linesize[0];                                \
+        \
+        const type *ref_ptr = (const type *) s->gref->data[0];                  \
+        const type *main_ptr = (const type *) s->gmain->data[0];                \
+        \
+        float *ptr = ref_data;                                                  \
+        \
+        int h = s->height;                                                      \
+        int w = s->width;                                                       \
+        \
+        int i,j;                                                                \
+        \
+        for (i = 0; i < h; i++) {                                               \
+            for ( j = 0; j < w; j++) {                                          \
+                ptr[j] = (float)ref_ptr[j];                                     \
+            }                                                                   \
+            ref_ptr += ref_stride / sizeof(*ref_ptr);                           \
+            ptr += stride / sizeof(*ptr);                                       \
+        }                                                                       \
+        \
+        ptr = main_data;                                                        \
+        \
+        for (i = 0; i < h; i++) {                                               \
+            for (j = 0; j < w; j++) {                                           \
+                ptr[j] = (float)main_ptr[j];                                    \
+            }                                                                   \
+            main_ptr += main_stride / sizeof(*main_ptr);                        \
+            ptr += stride / sizeof(*ptr);                                       \
+        }                                                                       \
+    }                                                                           \
+    \
+    ret = !s->frame_set;                                                        \
+    \
+    s->frame_set = 0;                                                           \
+    \
+    pthread_cond_signal(&s->cond);                                              \
+    pthread_mutex_unlock(&s->lock);                                             \
+    \
+    if (ret) {                                                                  \
+        return 2;                                                               \
+    }                                                                           \
+    \
+    return 0;                                                                   \
+}
+
+read_frame_fn(uint8_t, 8);
+read_frame_fn(uint16_t, 10);
+
+static void compute_vmaf_score(LIBVMAFContext *s)
+{
+    int (*read_frame)(float *ref_data, float *main_data, float *temp_data,
+                      int stride, void *ctx);
+
+    if (s->desc->comp[0].depth <= 8) {
+        read_frame = read_frame_8bit;
+    } else {
+        read_frame = read_frame_10bit;
+    }
+
+    s->vmaf_score = compute_vmaf(s->format, s->width, s->height, read_frame, s,
+                                 s->model_path, s->log_path, s->log_fmt, 0, 0,
+                                 s->enable_transform, s->phone_model, s->psnr,
+                                 s->ssim, s->ms_ssim, s->pool);
+}
+
+static void *call_vmaf(void *ctx)
+{
+    LIBVMAFContext *s = (LIBVMAFContext *) ctx;
+    compute_vmaf_score(s);
+    av_log(ctx, AV_LOG_INFO, "VMAF score: %f\n",s->vmaf_score);
+    pthread_exit(NULL);
+}
+
+static int do_vmaf(FFFrameSync *fs)
+{
+    AVFilterContext *ctx = fs->parent;
+    LIBVMAFContext *s = ctx->priv;
+    AVFrame *main, *ref;
+    int ret;
+
+    ret = ff_framesync_dualinput_get(fs, &main, &ref);
+    if (ret < 0)
+        return ret;
+    if (!ref)
+        return ff_filter_frame(ctx->outputs[0], main);
+
+    pthread_mutex_lock(&s->lock);
+
+    while (s->frame_set != 0) {
+        pthread_cond_wait(&s->cond, &s->lock);
+    }
+
+    av_frame_ref(s->gref, ref);
+    av_frame_ref(s->gmain, main);
+
+    s->frame_set = 1;
+
+    pthread_cond_signal(&s->cond);
+    pthread_mutex_unlock(&s->lock);
+
+    return ff_filter_frame(ctx->outputs[0], main);
+}
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    LIBVMAFContext *s = ctx->priv;
+
+    s->gref = av_frame_alloc();
+    s->gmain = av_frame_alloc();
+
+    pthread_mutex_init(&s->lock, NULL);
+    pthread_cond_init (&s->cond, NULL);
+
+    s->fs.on_event = do_vmaf;
+    return 0;
+}
+
+static int query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pix_fmts[] = {
+        AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P,
+        AV_PIX_FMT_YUV444P10LE, AV_PIX_FMT_YUV422P10LE, AV_PIX_FMT_YUV420P10LE,
+        AV_PIX_FMT_NONE
+    };
+
+    AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
+    if (!fmts_list)
+        return AVERROR(ENOMEM);
+    return ff_set_common_formats(ctx, fmts_list);
+}
+
+
+static int config_input_ref(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx  = inlink->dst;
+    LIBVMAFContext *s = ctx->priv;
+    int th;
+
+    if (ctx->inputs[0]->w != ctx->inputs[1]->w ||
+        ctx->inputs[0]->h != ctx->inputs[1]->h) {
+        av_log(ctx, AV_LOG_ERROR, "Width and height of input videos must be same.\n");
+        return AVERROR(EINVAL);
+    }
+    if (ctx->inputs[0]->format != ctx->inputs[1]->format) {
+        av_log(ctx, AV_LOG_ERROR, "Inputs must be of same pixel format.\n");
+        return AVERROR(EINVAL);
+    }
+
+    s->desc = av_pix_fmt_desc_get(inlink->format);
+    s->width = ctx->inputs[0]->w;
+    s->height = ctx->inputs[0]->h;
+
+    th = pthread_create(&s->vmaf_thread, NULL, call_vmaf, (void *) s);
+    if (th) {
+        av_log(ctx, AV_LOG_ERROR, "Thread creation failed.\n");
+        return AVERROR(EINVAL);
+    }
+
+    return 0;
+}
+
+
+static int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    LIBVMAFContext *s = ctx->priv;
+    AVFilterLink *mainlink = ctx->inputs[0];
+    int ret;
+
+    ret = ff_framesync_init_dualinput(&s->fs, ctx);
+    if (ret < 0)
+        return ret;
+    outlink->w = mainlink->w;
+    outlink->h = mainlink->h;
+    outlink->time_base = mainlink->time_base;
+    outlink->sample_aspect_ratio = mainlink->sample_aspect_ratio;
+    outlink->frame_rate = mainlink->frame_rate;
+    if ((ret = ff_framesync_configure(&s->fs)) < 0)
+        return ret;
+
+    return 0;
+}
+
+static int activate(AVFilterContext *ctx)
+{
+    LIBVMAFContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    LIBVMAFContext *s = ctx->priv;
+
+    ff_framesync_uninit(&s->fs);
+
+    pthread_mutex_lock(&s->lock);
+    s->eof = 1;
+    pthread_cond_signal(&s->cond);
+    pthread_mutex_unlock(&s->lock);
+
+    pthread_join(s->vmaf_thread, NULL);
+
+    av_frame_free(&s->gref);
+    av_frame_free(&s->gmain);
+
+    pthread_mutex_destroy(&s->lock);
+    pthread_cond_destroy(&s->cond);
+}
+
+static const AVFilterPad libvmaf_inputs[] = {
+    {
+        .name         = "main",
+        .type         = AVMEDIA_TYPE_VIDEO,
+    },{
+        .name         = "reference",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = config_input_ref,
+    },
+    { NULL }
+};
+
+static const AVFilterPad libvmaf_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .config_props  = config_output,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_libvmaf = {
+    .name          = "libvmaf",
+    .description   = NULL_IF_CONFIG_SMALL("Calculate the VMAF between two video streams."),
+    .preinit       = libvmaf_framesync_preinit,
+    .init          = init,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .activate      = activate,
+    .priv_size     = sizeof(LIBVMAFContext),
+    .priv_class    = &libvmaf_class,
+    .inputs        = libvmaf_inputs,
+    .outputs       = libvmaf_outputs,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_limiter.c b/mythtv/external/FFmpeg/libavfilter/vf_limiter.c
new file mode 100644
index 00000000000..9c62b118849
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_limiter.c
@@ -0,0 +1,231 @@
+/*
+ * 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 "libavutil/common.h"
+#include "libavutil/eval.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "limiter.h"
+#include "video.h"
+
+typedef struct LimiterContext {
+    const AVClass *class;
+    int min;
+    int max;
+    int planes;
+    int nb_planes;
+    int linesize[4];
+    int width[4];
+    int height[4];
+
+    LimiterDSPContext dsp;
+} LimiterContext;
+
+#define OFFSET(x) offsetof(LimiterContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption limiter_options[] = {
+    { "min",    "set min value", OFFSET(min),    AV_OPT_TYPE_INT, {.i64=0},     0, 65535, .flags = FLAGS },
+    { "max",    "set max value", OFFSET(max),    AV_OPT_TYPE_INT, {.i64=65535}, 0, 65535, .flags = FLAGS },
+    { "planes", "set planes",    OFFSET(planes), AV_OPT_TYPE_INT, {.i64=15},    0,    15, .flags = FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(limiter);
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    LimiterContext *s = ctx->priv;
+
+    if (s->min > s->max)
+        return AVERROR(EINVAL);
+    return 0;
+}
+
+static int query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pix_fmts[] = {
+        AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
+        AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
+        AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
+        AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
+        AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+        AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
+        AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
+        AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
+        AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
+        AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
+        AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
+        AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
+        AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
+        AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
+        AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
+        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_NONE
+    };
+
+    AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
+    if (!fmts_list)
+        return AVERROR(ENOMEM);
+    return ff_set_common_formats(ctx, fmts_list);
+}
+
+static void limiter8(const uint8_t *src, uint8_t *dst,
+                     ptrdiff_t slinesize, ptrdiff_t dlinesize,
+                     int w, int h, int min, int max)
+{
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dst[x] = av_clip(src[x], min, max);
+        }
+
+        dst += dlinesize;
+        src += slinesize;
+    }
+}
+
+static void limiter16(const uint8_t *ssrc, uint8_t *ddst,
+                      ptrdiff_t slinesize, ptrdiff_t dlinesize,
+                      int w, int h, int min, int max)
+{
+    const uint16_t *src = (const uint16_t *)ssrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    dlinesize /= 2;
+    slinesize /= 2;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dst[x] = av_clip(src[x], min, max);
+        }
+
+        dst += dlinesize;
+        src += slinesize;
+    }
+}
+
+static int config_props(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    LimiterContext *s = ctx->priv;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    int vsub, hsub, ret;
+
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
+    if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
+        return ret;
+
+    hsub = desc->log2_chroma_w;
+    vsub = desc->log2_chroma_h;
+    s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
+    s->height[0] = s->height[3] = inlink->h;
+    s->width[1]  = s->width[2]  = AV_CEIL_RSHIFT(inlink->w, hsub);
+    s->width[0]  = s->width[3]  = inlink->w;
+
+    if (desc->comp[0].depth == 8) {
+        s->dsp.limiter = limiter8;
+        s->max = FFMIN(s->max, 255);
+        s->min = FFMIN(s->min, 255);
+    } else {
+        s->dsp.limiter = limiter16;
+    }
+
+    if (ARCH_X86)
+        ff_limiter_init_x86(&s->dsp, desc->comp[0].depth);
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx = inlink->dst;
+    LimiterContext *s = ctx->priv;
+    AVFilterLink *outlink = ctx->outputs[0];
+    AVFrame *out;
+    int p;
+
+    if (av_frame_is_writable(in)) {
+        out = in;
+    } else {
+        out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+        if (!out) {
+            av_frame_free(&in);
+            return AVERROR(ENOMEM);
+        }
+        av_frame_copy_props(out, in);
+    }
+
+    for (p = 0; p < s->nb_planes; p++) {
+        if (!((1 << p) & s->planes)) {
+            if (out != in)
+                av_image_copy_plane(out->data[p], out->linesize[p], in->data[p], in->linesize[p],
+                                    s->linesize[p], s->height[p]);
+            continue;
+        }
+
+        s->dsp.limiter(in->data[p], out->data[p],
+                       in->linesize[p], out->linesize[p],
+                       s->width[p], s->height[p],
+                       s->min, s->max);
+    }
+
+    if (out != in)
+        av_frame_free(&in);
+
+    return ff_filter_frame(outlink, out);
+}
+
+static const AVFilterPad inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = filter_frame,
+        .config_props = config_props,
+    },
+    { NULL }
+};
+
+static const AVFilterPad outputs[] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_VIDEO,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_limiter = {
+    .name          = "limiter",
+    .description   = NULL_IF_CONFIG_SMALL("Limit pixels components to the specified range."),
+    .priv_size     = sizeof(LimiterContext),
+    .priv_class    = &limiter_class,
+    .init          = init,
+    .query_formats = query_formats,
+    .inputs        = inputs,
+    .outputs       = outputs,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_lumakey.c b/mythtv/external/FFmpeg/libavfilter/vf_lumakey.c
new file mode 100644
index 00000000000..418538f929d
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_lumakey.c
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/opt.h"
+#include "libavutil/imgutils.h"
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+typedef struct LumakeyContext {
+    const AVClass *class;
+
+    int threshold;
+    int tolerance;
+    int softness;
+
+    int white;
+    int black;
+    int max;
+
+    int (*do_lumakey_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
+} LumakeyContext;
+
+static int do_lumakey_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+    LumakeyContext *s = ctx->priv;
+    AVFrame *frame = arg;
+    const int slice_start = (frame->height * jobnr) / nb_jobs;
+    const int slice_end = (frame->height * (jobnr + 1)) / nb_jobs;
+    uint8_t *alpha = frame->data[3] + slice_start * frame->linesize[3];
+    const uint8_t *luma = frame->data[0] + slice_start * frame->linesize[0];
+    const int so = s->softness;
+    const int w = s->white;
+    const int b = s->black;
+    int x, y;
+
+    for (y = slice_start; y < slice_end; y++) {
+        for (x = 0; x < frame->width; x++) {
+            if (luma[x] >= b && luma[x] <= w) {
+                alpha[x] = 0;
+            } else if (luma[x] > b - so && luma[x] < w + so) {
+                if (luma[x] < b) {
+                    alpha[x] = 255 - (luma[x] - b + so) * 255 / so;
+                } else {
+                    alpha[x] = (luma[x] - w) * 255 / so;
+                }
+            }
+        }
+        luma += frame->linesize[0];
+        alpha += frame->linesize[3];
+    }
+
+    return 0;
+}
+
+static int do_lumakey_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+    LumakeyContext *s = ctx->priv;
+    AVFrame *frame = arg;
+    const int slice_start = (frame->height * jobnr) / nb_jobs;
+    const int slice_end = (frame->height * (jobnr + 1)) / nb_jobs;
+    uint16_t *alpha = (uint16_t *)(frame->data[3] + slice_start * frame->linesize[3]);
+    const uint16_t *luma = (const uint16_t *)(frame->data[0] + slice_start * frame->linesize[0]);
+    const int so = s->softness;
+    const int w = s->white;
+    const int b = s->black;
+    const int m = s->max;
+    int x, y;
+
+    for (y = slice_start; y < slice_end; y++) {
+        for (x = 0; x < frame->width; x++) {
+            if (luma[x] >= b && luma[x] <= w) {
+                alpha[x] = 0;
+            } else if (luma[x] > b - so && luma[x] < w + so) {
+                if (luma[x] < b) {
+                    alpha[x] = m - (luma[x] - b + so) * m / so;
+                } else {
+                    alpha[x] = (luma[x] - w) * m / so;
+                }
+            }
+        }
+        luma += frame->linesize[0] / 2;
+        alpha += frame->linesize[3] / 2;
+    }
+
+    return 0;
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    AVFilterContext *ctx = inlink->dst;
+    LumakeyContext *s = ctx->priv;
+    int depth;
+
+    depth = desc->comp[0].depth;
+    if (depth == 8) {
+        s->white = av_clip_uint8(s->threshold + s->tolerance);
+        s->black = av_clip_uint8(s->threshold - s->tolerance);
+        s->do_lumakey_slice = do_lumakey_slice8;
+    } else {
+        s->max = (1 << depth) - 1;
+        s->white = av_clip(s->threshold + s->tolerance, 0, s->max);
+        s->black = av_clip(s->threshold - s->tolerance, 0, s->max);
+        s->do_lumakey_slice = do_lumakey_slice16;
+    }
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *link, AVFrame *frame)
+{
+    AVFilterContext *ctx = link->dst;
+    LumakeyContext *s = ctx->priv;
+    int ret;
+
+    if (ret = av_frame_make_writable(frame))
+        return ret;
+
+    if (ret = ctx->internal->execute(ctx, s->do_lumakey_slice, frame, NULL, FFMIN(frame->height, ff_filter_get_nb_threads(ctx))))
+        return ret;
+
+    return ff_filter_frame(ctx->outputs[0], frame);
+}
+
+static av_cold int query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pixel_fmts[] = {
+        AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
+        AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
+        AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,
+        AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
+        AV_PIX_FMT_NONE
+    };
+    AVFilterFormats *formats;
+
+    formats = ff_make_format_list(pixel_fmts);
+    if (!formats)
+        return AVERROR(ENOMEM);
+
+    return ff_set_common_formats(ctx, formats);
+}
+
+static const AVFilterPad lumakey_inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = filter_frame,
+        .config_props = config_input,
+    },
+    { NULL }
+};
+
+static const AVFilterPad lumakey_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+    },
+    { NULL }
+};
+
+#define OFFSET(x) offsetof(LumakeyContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption lumakey_options[] = {
+    { "threshold", "set the threshold value", OFFSET(threshold), AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
+    { "tolerance", "set the tolerance value", OFFSET(tolerance), AV_OPT_TYPE_INT, {.i64=1}, 0, UINT16_MAX, FLAGS },
+    { "softness",  "set the softness value",  OFFSET(softness),  AV_OPT_TYPE_INT, {.i64=0}, 0, UINT16_MAX, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(lumakey);
+
+AVFilter ff_vf_lumakey = {
+    .name          = "lumakey",
+    .description   = NULL_IF_CONFIG_SMALL("Turns a certain luma into transparency."),
+    .priv_size     = sizeof(LumakeyContext),
+    .priv_class    = &lumakey_class,
+    .query_formats = query_formats,
+    .inputs        = lumakey_inputs,
+    .outputs       = lumakey_outputs,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_lut.c b/mythtv/external/FFmpeg/libavfilter/vf_lut.c
index 312bb37a38f..11c039ead77 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_lut.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_lut.c
@@ -84,17 +84,17 @@ typedef struct LutContext {
 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
 
 static const AVOption options[] = {
-    { "c0", "set component #0 expression", OFFSET(comp_expr_str[0]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
-    { "c1", "set component #1 expression", OFFSET(comp_expr_str[1]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
-    { "c2", "set component #2 expression", OFFSET(comp_expr_str[2]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
-    { "c3", "set component #3 expression", OFFSET(comp_expr_str[3]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
-    { "y",  "set Y expression",            OFFSET(comp_expr_str[Y]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
-    { "u",  "set U expression",            OFFSET(comp_expr_str[U]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
-    { "v",  "set V expression",            OFFSET(comp_expr_str[V]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
-    { "r",  "set R expression",            OFFSET(comp_expr_str[R]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
-    { "g",  "set G expression",            OFFSET(comp_expr_str[G]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
-    { "b",  "set B expression",            OFFSET(comp_expr_str[B]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
-    { "a",  "set A expression",            OFFSET(comp_expr_str[A]),  AV_OPT_TYPE_STRING, { .str = "val" }, .flags = FLAGS },
+    { "c0", "set component #0 expression", OFFSET(comp_expr_str[0]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
+    { "c1", "set component #1 expression", OFFSET(comp_expr_str[1]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
+    { "c2", "set component #2 expression", OFFSET(comp_expr_str[2]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
+    { "c3", "set component #3 expression", OFFSET(comp_expr_str[3]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
+    { "y",  "set Y expression",            OFFSET(comp_expr_str[Y]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
+    { "u",  "set U expression",            OFFSET(comp_expr_str[U]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
+    { "v",  "set V expression",            OFFSET(comp_expr_str[V]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
+    { "r",  "set R expression",            OFFSET(comp_expr_str[R]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
+    { "g",  "set G expression",            OFFSET(comp_expr_str[G]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
+    { "b",  "set B expression",            OFFSET(comp_expr_str[B]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
+    { "a",  "set A expression",            OFFSET(comp_expr_str[A]),  AV_OPT_TYPE_STRING, { .str = "clipval" }, .flags = FLAGS },
     { NULL }
 };
 
@@ -130,6 +130,7 @@ static av_cold void uninit(AVFilterContext *ctx)
     AV_PIX_FMT_RGB48LE,      AV_PIX_FMT_RGBA64LE,     \
     AV_PIX_FMT_GBRP,         AV_PIX_FMT_GBRAP,        \
     AV_PIX_FMT_GBRP9LE,      AV_PIX_FMT_GBRP10LE,     \
+    AV_PIX_FMT_GBRAP10LE,                             \
     AV_PIX_FMT_GBRP12LE,     AV_PIX_FMT_GBRP14LE,     \
     AV_PIX_FMT_GBRP16LE,     AV_PIX_FMT_GBRAP12LE,    \
     AV_PIX_FMT_GBRAP16LE
@@ -265,7 +266,7 @@ static int config_props(AVFilterLink *inlink)
         max[Y] = 235 * (1 << (desc->comp[0].depth - 8));
         max[U] = 240 * (1 << (desc->comp[1].depth - 8));
         max[V] = 240 * (1 << (desc->comp[2].depth - 8));
-        max[A] = (1 << desc->comp[3].depth) - 1;
+        max[A] = (1 << desc->comp[0].depth) - 1;
         break;
     case AV_PIX_FMT_RGB48LE:
     case AV_PIX_FMT_RGBA64LE:
@@ -310,7 +311,7 @@ static int config_props(AVFilterLink *inlink)
         s->var_values[VAR_MAXVAL] = max[color];
         s->var_values[VAR_MINVAL] = min[color];
 
-        for (val = 0; val < (1 << desc->comp[0].depth); val++) {
+        for (val = 0; val < FF_ARRAY_ELEMS(s->lut[comp]); val++) {
             s->var_values[VAR_VAL] = val;
             s->var_values[VAR_CLIPVAL] = av_clip(val, min[color], max[color]);
             s->var_values[VAR_NEGVAL] =
@@ -324,7 +325,7 @@ static int config_props(AVFilterLink *inlink)
                        s->comp_expr_str[color], val, comp);
                 return AVERROR(EINVAL);
             }
-            s->lut[comp][val] = av_clip((int)res, min[color], max[color]);
+            s->lut[comp][val] = av_clip((int)res, 0, max[A]);
             av_log(ctx, AV_LOG_DEBUG, "val[%d][%d] = %d\n", comp, val, s->lut[comp][val]);
         }
     }
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_lut2.c b/mythtv/external/FFmpeg/libavfilter/vf_lut2.c
index 85b10531b6c..585d121ca35 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_lut2.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_lut2.c
@@ -52,6 +52,7 @@ enum var_name {
 
 typedef struct LUT2Context {
     const AVClass *class;
+    FFFrameSync fs;
 
     char   *comp_expr_str[4];
 
@@ -61,16 +62,17 @@ typedef struct LUT2Context {
     int width[4], height[4];
     int nb_planes;
     int depth, depthx, depthy;
+    int tlut2;
+    AVFrame *prev_frame;        /* only used with tlut2 */
 
     void (*lut2)(struct LUT2Context *s, AVFrame *dst, AVFrame *srcx, AVFrame *srcy);
 
-    FFFrameSync fs;
 } LUT2Context;
 
 #define OFFSET(x) offsetof(LUT2Context, x)
 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
 
-static const AVOption lut2_options[] = {
+static const AVOption options[] = {
     { "c0", "set component #0 expression", OFFSET(comp_expr_str[0]),  AV_OPT_TYPE_STRING, { .str = "x" }, .flags = FLAGS },
     { "c1", "set component #1 expression", OFFSET(comp_expr_str[1]),  AV_OPT_TYPE_STRING, { .str = "x" }, .flags = FLAGS },
     { "c2", "set component #2 expression", OFFSET(comp_expr_str[2]),  AV_OPT_TYPE_STRING, { .str = "x" }, .flags = FLAGS },
@@ -83,6 +85,9 @@ static av_cold void uninit(AVFilterContext *ctx)
     LUT2Context *s = ctx->priv;
     int i;
 
+    ff_framesync_uninit(&s->fs);
+    av_frame_free(&s->prev_frame);
+
     for (i = 0; i < 4; i++) {
         av_expr_free(s->comp_expr[i]);
         s->comp_expr[i] = NULL;
@@ -106,8 +111,8 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
         AV_PIX_FMT_GBRP12,
-        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP12,
-        AV_PIX_FMT_GRAY8,
+        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
         AV_PIX_FMT_NONE
     };
 
@@ -133,6 +138,11 @@ static int config_inputx(AVFilterLink *inlink)
     s->depthx = desc->comp[0].depth;
     s->var_values[VAR_BITDEPTHX] = s->depthx;
 
+    if (s->tlut2) {
+        s->depthy = desc->comp[0].depth;
+        s->var_values[VAR_BITDEPTHY] = s->depthy;
+    }
+
     return 0;
 }
 
@@ -203,14 +213,14 @@ static int process_frame(FFFrameSync *fs)
     AVFilterContext *ctx = fs->parent;
     LUT2Context *s = fs->opaque;
     AVFilterLink *outlink = ctx->outputs[0];
-    AVFrame *out, *srcx, *srcy;
+    AVFrame *out, *srcx = NULL, *srcy = NULL;
     int ret;
 
     if ((ret = ff_framesync_get_frame(&s->fs, 0, &srcx, 0)) < 0 ||
         (ret = ff_framesync_get_frame(&s->fs, 1, &srcy, 0)) < 0)
         return ret;
 
-    if (ctx->is_disabled) {
+    if (ctx->is_disabled || !srcy) {
         out = av_frame_clone(srcx);
         if (!out)
             return AVERROR(ENOMEM);
@@ -232,55 +242,10 @@ static int config_output(AVFilterLink *outlink)
 {
     AVFilterContext *ctx = outlink->src;
     LUT2Context *s = ctx->priv;
-    AVFilterLink *srcx = ctx->inputs[0];
-    AVFilterLink *srcy = ctx->inputs[1];
-    FFFrameSyncIn *in;
     int p, ret;
 
     s->depth = s->depthx + s->depthy;
 
-    if (srcx->format != srcy->format) {
-        av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
-        return AVERROR(EINVAL);
-    }
-    if (srcx->w                       != srcy->w ||
-        srcx->h                       != srcy->h ||
-        srcx->sample_aspect_ratio.num != srcy->sample_aspect_ratio.num ||
-        srcx->sample_aspect_ratio.den != srcy->sample_aspect_ratio.den) {
-        av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
-               "(size %dx%d, SAR %d:%d) do not match the corresponding "
-               "second input link %s parameters (%dx%d, SAR %d:%d)\n",
-               ctx->input_pads[0].name, srcx->w, srcx->h,
-               srcx->sample_aspect_ratio.num,
-               srcx->sample_aspect_ratio.den,
-               ctx->input_pads[1].name,
-               srcy->w, srcy->h,
-               srcy->sample_aspect_ratio.num,
-               srcy->sample_aspect_ratio.den);
-        return AVERROR(EINVAL);
-    }
-
-    outlink->w = srcx->w;
-    outlink->h = srcx->h;
-    outlink->time_base = srcx->time_base;
-    outlink->sample_aspect_ratio = srcx->sample_aspect_ratio;
-    outlink->frame_rate = srcx->frame_rate;
-
-    if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)
-        return ret;
-
-    in = s->fs.in;
-    in[0].time_base = srcx->time_base;
-    in[1].time_base = srcy->time_base;
-    in[0].sync   = 1;
-    in[0].before = EXT_STOP;
-    in[0].after  = EXT_INFINITY;
-    in[1].sync   = 1;
-    in[1].before = EXT_STOP;
-    in[1].after  = EXT_INFINITY;
-    s->fs.opaque   = s;
-    s->fs.on_event = process_frame;
-
     s->lut2 = s->depth > 16 ? lut2_16bit : lut2_8bit;
 
     for (p = 0; p < s->nb_planes; p++) {
@@ -323,32 +288,81 @@ static int config_output(AVFilterLink *outlink)
         }
     }
 
-    return ff_framesync_configure(&s->fs);
+    return 0;
 }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
+static int lut2_config_output(AVFilterLink *outlink)
 {
-    LUT2Context *s = inlink->dst->priv;
-    return ff_framesync_filter_frame(&s->fs, inlink, buf);
+    AVFilterContext *ctx = outlink->src;
+    LUT2Context *s = ctx->priv;
+    AVFilterLink *srcx = ctx->inputs[0];
+    AVFilterLink *srcy = ctx->inputs[1];
+    FFFrameSyncIn *in;
+    int ret;
+
+    if (srcx->format != srcy->format) {
+        av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
+        return AVERROR(EINVAL);
+    }
+    if (srcx->w                       != srcy->w ||
+        srcx->h                       != srcy->h ||
+        srcx->sample_aspect_ratio.num != srcy->sample_aspect_ratio.num ||
+        srcx->sample_aspect_ratio.den != srcy->sample_aspect_ratio.den) {
+        av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
+               "(size %dx%d, SAR %d:%d) do not match the corresponding "
+               "second input link %s parameters (%dx%d, SAR %d:%d)\n",
+               ctx->input_pads[0].name, srcx->w, srcx->h,
+               srcx->sample_aspect_ratio.num,
+               srcx->sample_aspect_ratio.den,
+               ctx->input_pads[1].name,
+               srcy->w, srcy->h,
+               srcy->sample_aspect_ratio.num,
+               srcy->sample_aspect_ratio.den);
+        return AVERROR(EINVAL);
+    }
+
+    outlink->w = srcx->w;
+    outlink->h = srcx->h;
+    outlink->time_base = srcx->time_base;
+    outlink->sample_aspect_ratio = srcx->sample_aspect_ratio;
+    outlink->frame_rate = srcx->frame_rate;
+
+    if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)
+        return ret;
+
+    in = s->fs.in;
+    in[0].time_base = srcx->time_base;
+    in[1].time_base = srcy->time_base;
+    in[0].sync   = 2;
+    in[0].before = EXT_STOP;
+    in[0].after  = EXT_INFINITY;
+    in[1].sync   = 1;
+    in[1].before = EXT_STOP;
+    in[1].after  = EXT_INFINITY;
+    s->fs.opaque   = s;
+    s->fs.on_event = process_frame;
+
+    if ((ret = config_output(outlink)) < 0)
+        return ret;
+
+    return ff_framesync_configure(&s->fs);
 }
 
-static int request_frame(AVFilterLink *outlink)
+static int activate(AVFilterContext *ctx)
 {
-    LUT2Context *s = outlink->src->priv;
-    return ff_framesync_request_frame(&s->fs, outlink);
+    LUT2Context *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static const AVFilterPad inputs[] = {
     {
         .name         = "srcx",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
         .config_props = config_inputx,
     },
     {
         .name         = "srcy",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
         .config_props = config_inputy,
     },
     { NULL }
@@ -358,22 +372,95 @@ static const AVFilterPad outputs[] = {
     {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
-        .config_props  = config_output,
-        .request_frame = request_frame,
+        .config_props  = lut2_config_output,
     },
     { NULL }
 };
 
-AVFILTER_DEFINE_CLASS(lut2);
+#define lut2_options options
+
+FRAMESYNC_DEFINE_CLASS(lut2, LUT2Context, fs);
 
 AVFilter ff_vf_lut2 = {
     .name          = "lut2",
     .description   = NULL_IF_CONFIG_SMALL("Compute and apply a lookup table from two video inputs."),
+    .preinit       = lut2_framesync_preinit,
     .priv_size     = sizeof(LUT2Context),
     .priv_class    = &lut2_class,
     .uninit        = uninit,
     .query_formats = query_formats,
+    .activate      = activate,
     .inputs        = inputs,
     .outputs       = outputs,
     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 };
+
+#if CONFIG_TLUT2_FILTER
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    LUT2Context *s = ctx->priv;
+
+    s->tlut2 = !strcmp(ctx->filter->name, "tlut2");
+
+    return 0;
+}
+
+static int tlut2_filter_frame(AVFilterLink *inlink, AVFrame *frame)
+{
+    LUT2Context *s = inlink->dst->priv;
+    AVFilterLink *outlink = inlink->dst->outputs[0];
+
+    if (s->prev_frame) {
+        AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+        if (!out) {
+            av_frame_free(&s->prev_frame);
+            s->prev_frame = frame;
+            return AVERROR(ENOMEM);
+        }
+        av_frame_copy_props(out, frame);
+        s->lut2(s, out, frame, s->prev_frame);
+        av_frame_free(&s->prev_frame);
+        s->prev_frame = frame;
+        return ff_filter_frame(outlink, out);
+    }
+    s->prev_frame = frame;
+    return 0;
+}
+
+#define tlut2_options options
+
+AVFILTER_DEFINE_CLASS(tlut2);
+
+static const AVFilterPad tlut2_inputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .filter_frame  = tlut2_filter_frame,
+        .config_props  = config_inputx,
+    },
+    { NULL }
+};
+
+static const AVFilterPad tlut2_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .config_props  = config_output,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_tlut2 = {
+    .name          = "tlut2",
+    .description   = NULL_IF_CONFIG_SMALL("Compute and apply a lookup table from two successive frames."),
+    .priv_size     = sizeof(LUT2Context),
+    .priv_class    = &tlut2_class,
+    .query_formats = query_formats,
+    .init          = init,
+    .uninit        = uninit,
+    .inputs        = tlut2_inputs,
+    .outputs       = tlut2_outputs,
+};
+
+#endif
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_lut3d.c b/mythtv/external/FFmpeg/libavfilter/vf_lut3d.c
index b136cda21d4..c9b72249aad 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_lut3d.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_lut3d.c
@@ -31,8 +31,8 @@
 #include "libavutil/avstring.h"
 #include "avfilter.h"
 #include "drawutils.h"
-#include "dualinput.h"
 #include "formats.h"
+#include "framesync.h"
 #include "internal.h"
 #include "video.h"
 
@@ -70,7 +70,7 @@ typedef struct LUT3DContext {
     int clut_step;
     int clut_is16bit;
     int clut_width;
-    FFDualInputContext dinput;
+    FFFrameSync fs;
 #endif
 } LUT3DContext;
 
@@ -320,6 +320,7 @@ static int parse_cube(AVFilterContext *ctx, FILE *f)
                         struct rgbvec *vec = &lut3d->lut[i][j][k];
 
                         do {
+try_again:
                             NEXT_LINE(0);
                             if (!strncmp(line, "DOMAIN_", 7)) {
                                 float *vals = NULL;
@@ -330,7 +331,7 @@ static int parse_cube(AVFilterContext *ctx, FILE *f)
                                 sscanf(line + 11, "%f %f %f", vals, vals + 1, vals + 2);
                                 av_log(ctx, AV_LOG_DEBUG, "min: %f %f %f | max: %f %f %f\n",
                                        min[0], min[1], min[2], max[0], max[1], max[2]);
-                                continue;
+                                goto try_again;
                             }
                         } while (skip_line(line));
                         if (sscanf(line, "%f %f %f", &vec->r, &vec->g, &vec->b) != 3)
@@ -680,24 +681,21 @@ static int config_output(AVFilterLink *outlink)
     LUT3DContext *lut3d = ctx->priv;
     int ret;
 
+    ret = ff_framesync_init_dualinput(&lut3d->fs, ctx);
+    if (ret < 0)
+        return ret;
     outlink->w = ctx->inputs[0]->w;
     outlink->h = ctx->inputs[0]->h;
     outlink->time_base = ctx->inputs[0]->time_base;
-    if ((ret = ff_dualinput_init(ctx, &lut3d->dinput)) < 0)
+    if ((ret = ff_framesync_configure(&lut3d->fs)) < 0)
         return ret;
     return 0;
 }
 
-static int filter_frame_hald(AVFilterLink *inlink, AVFrame *inpicref)
-{
-    LUT3DContext *s = inlink->dst->priv;
-    return ff_dualinput_filter_frame(&s->dinput, inlink, inpicref);
-}
-
-static int request_frame(AVFilterLink *outlink)
+static int activate(AVFilterContext *ctx)
 {
-    LUT3DContext *s = outlink->src->priv;
-    return ff_dualinput_request_frame(&s->dinput, outlink);
+    LUT3DContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static int config_clut(AVFilterLink *inlink)
@@ -750,45 +748,50 @@ static int config_clut(AVFilterLink *inlink)
     return 0;
 }
 
-static AVFrame *update_apply_clut(AVFilterContext *ctx, AVFrame *main,
-                                  const AVFrame *second)
+static int update_apply_clut(FFFrameSync *fs)
 {
+    AVFilterContext *ctx = fs->parent;
     AVFilterLink *inlink = ctx->inputs[0];
+    AVFrame *master, *second, *out;
+    int ret;
+
+    ret = ff_framesync_dualinput_get(fs, &master, &second);
+    if (ret < 0)
+        return ret;
+    if (!second)
+        return ff_filter_frame(ctx->outputs[0], master);
     update_clut(ctx->priv, second);
-    return apply_lut(inlink, main);
+    out = apply_lut(inlink, master);
+    return ff_filter_frame(ctx->outputs[0], out);
 }
 
 static av_cold int haldclut_init(AVFilterContext *ctx)
 {
     LUT3DContext *lut3d = ctx->priv;
-    lut3d->dinput.process = update_apply_clut;
+    lut3d->fs.on_event = update_apply_clut;
     return 0;
 }
 
 static av_cold void haldclut_uninit(AVFilterContext *ctx)
 {
     LUT3DContext *lut3d = ctx->priv;
-    ff_dualinput_uninit(&lut3d->dinput);
+    ff_framesync_uninit(&lut3d->fs);
 }
 
 static const AVOption haldclut_options[] = {
-    { "shortest",   "force termination when the shortest input terminates", OFFSET(dinput.shortest),   AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
-    { "repeatlast", "continue applying the last clut after eos",            OFFSET(dinput.repeatlast), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS },
     COMMON_OPTIONS
 };
 
-AVFILTER_DEFINE_CLASS(haldclut);
+FRAMESYNC_DEFINE_CLASS(haldclut, LUT3DContext, fs);
 
 static const AVFilterPad haldclut_inputs[] = {
     {
         .name         = "main",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame_hald,
         .config_props = config_input,
     },{
         .name         = "clut",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame_hald,
         .config_props = config_clut,
     },
     { NULL }
@@ -798,7 +801,6 @@ static const AVFilterPad haldclut_outputs[] = {
     {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
-        .request_frame = request_frame,
         .config_props  = config_output,
     },
     { NULL }
@@ -808,9 +810,11 @@ AVFilter ff_vf_haldclut = {
     .name          = "haldclut",
     .description   = NULL_IF_CONFIG_SMALL("Adjust colors using a Hald CLUT."),
     .priv_size     = sizeof(LUT3DContext),
+    .preinit       = haldclut_framesync_preinit,
     .init          = haldclut_init,
     .uninit        = haldclut_uninit,
     .query_formats = query_formats,
+    .activate      = activate,
     .inputs        = haldclut_inputs,
     .outputs       = haldclut_outputs,
     .priv_class    = &haldclut_class,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_maskedclamp.c b/mythtv/external/FFmpeg/libavfilter/vf_maskedclamp.c
index 855c73827b3..67a979f8c06 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_maskedclamp.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_maskedclamp.c
@@ -37,6 +37,7 @@ typedef struct MaskedClampContext {
     int undershoot;
     int overshoot;
 
+    int linesize[4];
     int width[4], height[4];
     int nb_planes;
     int depth;
@@ -50,9 +51,9 @@ typedef struct MaskedClampContext {
 } MaskedClampContext;
 
 static const AVOption maskedclamp_options[] = {
-    { "undershoot", "set undershoot", OFFSET(undershoot), AV_OPT_TYPE_INT, {.i64=0},   0, INT_MAX, FLAGS },
-    { "overshoot",  "set overshoot",  OFFSET(overshoot),  AV_OPT_TYPE_INT, {.i64=0},   0, INT_MAX, FLAGS },
-    { "planes",     "set planes",     OFFSET(planes),     AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF,     FLAGS },
+    { "undershoot", "set undershoot", OFFSET(undershoot), AV_OPT_TYPE_INT, {.i64=0},   0, UINT16_MAX, FLAGS },
+    { "overshoot",  "set overshoot",  OFFSET(overshoot),  AV_OPT_TYPE_INT, {.i64=0},   0, UINT16_MAX, FLAGS },
+    { "planes",     "set planes",     OFFSET(planes),     AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF,        FLAGS },
     { NULL }
 };
 
@@ -76,8 +77,8 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
-        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_NONE
     };
 
@@ -112,7 +113,7 @@ static int process_frame(FFFrameSync *fs)
         for (p = 0; p < s->nb_planes; p++) {
             if (!((1 << p) & s->planes)) {
                 av_image_copy_plane(out->data[p], out->linesize[p], base->data[p], base->linesize[p],
-                                    s->width[p], s->height[p]);
+                                    s->linesize[p], s->height[p]);
                 continue;
             }
 
@@ -195,10 +196,13 @@ static int config_input(AVFilterLink *inlink)
     AVFilterContext *ctx = inlink->dst;
     MaskedClampContext *s = ctx->priv;
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
-    int vsub, hsub;
+    int vsub, hsub, ret;
 
     s->nb_planes = av_pix_fmt_count_planes(inlink->format);
 
+    if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
+        return ret;
+
     hsub = desc->log2_chroma_w;
     vsub = desc->log2_chroma_h;
     s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
@@ -283,16 +287,10 @@ static int config_output(AVFilterLink *outlink)
     return ff_framesync_configure(&s->fs);
 }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
-{
-    MaskedClampContext *s = inlink->dst->priv;
-    return ff_framesync_filter_frame(&s->fs, inlink, buf);
-}
-
-static int request_frame(AVFilterLink *outlink)
+static int activate(AVFilterContext *ctx)
 {
-    MaskedClampContext *s = outlink->src->priv;
-    return ff_framesync_request_frame(&s->fs, outlink);
+    MaskedClampContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
@@ -306,18 +304,15 @@ static const AVFilterPad maskedclamp_inputs[] = {
     {
         .name         = "base",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
         .config_props = config_input,
     },
     {
         .name         = "dark",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },
     {
         .name         = "bright",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },
     { NULL }
 };
@@ -327,7 +322,6 @@ static const AVFilterPad maskedclamp_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -337,6 +331,7 @@ AVFilter ff_vf_maskedclamp = {
     .description   = NULL_IF_CONFIG_SMALL("Clamp first stream with second stream and third stream."),
     .priv_size     = sizeof(MaskedClampContext),
     .uninit        = uninit,
+    .activate      = activate,
     .query_formats = query_formats,
     .inputs        = maskedclamp_inputs,
     .outputs       = maskedclamp_outputs,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_maskedmerge.c b/mythtv/external/FFmpeg/libavfilter/vf_maskedmerge.c
index 46c88f45c12..d31b92659e2 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_maskedmerge.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_maskedmerge.c
@@ -55,8 +55,8 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
-        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_NONE
     };
 
@@ -91,7 +91,7 @@ static int process_frame(FFFrameSync *fs)
         for (p = 0; p < s->nb_planes; p++) {
             if (!((1 << p) & s->planes)) {
                 av_image_copy_plane(out->data[p], out->linesize[p], base->data[p], base->linesize[p],
-                                    s->width[p], s->height[p]);
+                                    s->linesize[p], s->height[p]);
                 continue;
             }
 
@@ -229,6 +229,9 @@ static int config_output(AVFilterLink *outlink)
     outlink->sample_aspect_ratio = base->sample_aspect_ratio;
     outlink->frame_rate = base->frame_rate;
 
+    if ((ret = av_image_fill_linesizes(s->linesize, outlink->format, outlink->w)) < 0)
+        return ret;
+
     if ((ret = ff_framesync_init(&s->fs, ctx, 3)) < 0)
         return ret;
 
@@ -251,16 +254,10 @@ static int config_output(AVFilterLink *outlink)
     return ff_framesync_configure(&s->fs);
 }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
-{
-    MaskedMergeContext *s = inlink->dst->priv;
-    return ff_framesync_filter_frame(&s->fs, inlink, buf);
-}
-
-static int request_frame(AVFilterLink *outlink)
+static int activate(AVFilterContext *ctx)
 {
-    MaskedMergeContext *s = outlink->src->priv;
-    return ff_framesync_request_frame(&s->fs, outlink);
+    MaskedMergeContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
@@ -274,18 +271,15 @@ static const AVFilterPad maskedmerge_inputs[] = {
     {
         .name         = "base",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
         .config_props = config_input,
     },
     {
         .name         = "overlay",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },
     {
         .name         = "mask",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },
     { NULL }
 };
@@ -295,7 +289,6 @@ static const AVFilterPad maskedmerge_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -306,6 +299,7 @@ AVFilter ff_vf_maskedmerge = {
     .priv_size     = sizeof(MaskedMergeContext),
     .uninit        = uninit,
     .query_formats = query_formats,
+    .activate      = activate,
     .inputs        = maskedmerge_inputs,
     .outputs       = maskedmerge_outputs,
     .priv_class    = &maskedmerge_class,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_mcdeint.c b/mythtv/external/FFmpeg/libavfilter/vf_mcdeint.c
index 050a8341d9b..9cdec6308d8 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_mcdeint.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_mcdeint.c
@@ -69,7 +69,7 @@ enum MCDeintParity {
     PARITY_BFF  =  1, ///< bottom field first
 };
 
-typedef struct {
+typedef struct MCDeintContext {
     const AVClass *class;
     int mode;           ///< MCDeintMode
     int parity;         ///< MCDeintParity
@@ -122,7 +122,7 @@ static int config_props(AVFilterLink *inlink)
     enc_ctx->gop_size = INT_MAX;
     enc_ctx->max_b_frames = 0;
     enc_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
-    enc_ctx->flags = AV_CODEC_FLAG_QSCALE | CODEC_FLAG_LOW_DELAY;
+    enc_ctx->flags = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_LOW_DELAY;
     enc_ctx->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
     enc_ctx->global_quality = 1;
     enc_ctx->me_cmp = enc_ctx->me_sub_cmp = FF_CMP_SAD;
@@ -134,7 +134,7 @@ static int config_props(AVFilterLink *inlink)
     case MODE_EXTRA_SLOW:
         enc_ctx->refs = 3;
     case MODE_SLOW:
-        enc_ctx->me_method = ME_ITER;
+        av_dict_set(&opts, "motion_est", "iter", 0);
     case MODE_MEDIUM:
         enc_ctx->flags |= AV_CODEC_FLAG_4MV;
         enc_ctx->dia_size = 2;
@@ -154,10 +154,7 @@ static av_cold void uninit(AVFilterContext *ctx)
 {
     MCDeintContext *mcdeint = ctx->priv;
 
-    if (mcdeint->enc_ctx) {
-        avcodec_close(mcdeint->enc_ctx);
-        av_freep(&mcdeint->enc_ctx);
-    }
+    avcodec_free_context(&mcdeint->enc_ctx);
 }
 
 static int query_formats(AVFilterContext *ctx)
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_mergeplanes.c b/mythtv/external/FFmpeg/libavfilter/vf_mergeplanes.c
index 8128f337044..4b4f91be5d2 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_mergeplanes.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_mergeplanes.c
@@ -58,12 +58,6 @@ static const AVOption mergeplanes_options[] = {
 
 AVFILTER_DEFINE_CLASS(mergeplanes);
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *in)
-{
-    MergePlanesContext *s = inlink->dst->priv;
-    return ff_framesync_filter_frame(&s->fs, inlink, in);
-}
-
 static av_cold int init(AVFilterContext *ctx)
 {
     MergePlanesContext *s = ctx->priv;
@@ -101,7 +95,6 @@ static av_cold int init(AVFilterContext *ctx)
         pad.name = av_asprintf("in%d", i);
         if (!pad.name)
             return AVERROR(ENOMEM);
-        pad.filter_frame = filter_frame;
 
         if ((ret = ff_insert_inpad(ctx, i, &pad)) < 0){
             av_freep(&pad.name);
@@ -122,6 +115,7 @@ static int query_formats(AVFilterContext *ctx)
     for (i = 0; av_pix_fmt_desc_get(i); i++) {
         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
         if (desc->comp[0].depth == s->outdesc->comp[0].depth &&
+            (desc->comp[0].depth <= 8 || (desc->flags & AV_PIX_FMT_FLAG_BE) == (s->outdesc->flags & AV_PIX_FMT_FLAG_BE)) &&
             av_pix_fmt_count_planes(i) == desc->nb_components &&
             (ret = ff_add_format(&formats, i)) < 0)
                 return ret;
@@ -192,9 +186,9 @@ static int config_output(AVFilterLink *outlink)
     outlink->sample_aspect_ratio = ctx->inputs[0]->sample_aspect_ratio;
 
     s->planewidth[1]  =
-    s->planewidth[2]  = AV_CEIL_RSHIFT(outlink->w, s->outdesc->log2_chroma_w);
+    s->planewidth[2]  = AV_CEIL_RSHIFT(((s->outdesc->comp[1].depth > 8) + 1) * outlink->w, s->outdesc->log2_chroma_w);
     s->planewidth[0]  =
-    s->planewidth[3]  = outlink->w;
+    s->planewidth[3]  = ((s->outdesc->comp[0].depth > 8) + 1) * outlink->w;
     s->planeheight[1] =
     s->planeheight[2] = AV_CEIL_RSHIFT(outlink->h, s->outdesc->log2_chroma_h);
     s->planeheight[0] =
@@ -220,9 +214,9 @@ static int config_output(AVFilterLink *outlink)
         }
 
         inputp->planewidth[1]  =
-        inputp->planewidth[2]  = AV_CEIL_RSHIFT(inlink->w, indesc->log2_chroma_w);
+        inputp->planewidth[2]  = AV_CEIL_RSHIFT(((indesc->comp[1].depth > 8) + 1) * inlink->w, indesc->log2_chroma_w);
         inputp->planewidth[0]  =
-        inputp->planewidth[3]  = inlink->w;
+        inputp->planewidth[3]  = ((indesc->comp[0].depth > 8) + 1) * inlink->w;
         inputp->planeheight[1] =
         inputp->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, indesc->log2_chroma_h);
         inputp->planeheight[0] =
@@ -276,10 +270,10 @@ static int config_output(AVFilterLink *outlink)
     return AVERROR(EINVAL);
 }
 
-static int request_frame(AVFilterLink *outlink)
+static int activate(AVFilterContext *ctx)
 {
-    MergePlanesContext *s = outlink->src->priv;
-    return ff_framesync_request_frame(&s->fs, outlink);
+    MergePlanesContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
@@ -298,7 +292,6 @@ static const AVFilterPad mergeplanes_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -311,6 +304,7 @@ AVFilter ff_vf_mergeplanes = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
+    .activate      = activate,
     .inputs        = NULL,
     .outputs       = mergeplanes_outputs,
     .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_midequalizer.c b/mythtv/external/FFmpeg/libavfilter/vf_midequalizer.c
new file mode 100644
index 00000000000..c03814a24fa
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_midequalizer.c
@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/imgutils.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/opt.h"
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+#include "framesync.h"
+
+typedef struct MidEqualizerContext {
+    const AVClass *class;
+    int width[2][4], height[2][4];
+    int nb_planes;
+    int planes;
+    int histogram_size;
+    float *histogram[2];
+    unsigned *cchange;
+    FFFrameSync fs;
+
+    void (*midequalizer)(const uint8_t *in0, const uint8_t *in1,
+                         uint8_t *dst,
+                         ptrdiff_t linesize1, ptrdiff_t linesize2,
+                         ptrdiff_t dlinesize,
+                         int w0, int h0,
+                         int w1, int h1,
+                         float *histogram1, float *histogram2,
+                         unsigned *cchange, size_t hsize);
+} MidEqualizerContext;
+
+#define OFFSET(x) offsetof(MidEqualizerContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption midequalizer_options[] = {
+    { "planes", "set planes", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(midequalizer);
+
+static int query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pix_fmts[] = {
+        AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
+        AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
+        AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
+        AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
+        AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+        AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
+        AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
+        AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
+        AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
+        AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
+        AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
+        AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
+        AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
+        AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12,
+        AV_PIX_FMT_NONE
+    };
+
+    return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
+}
+
+static int process_frame(FFFrameSync *fs)
+{
+    AVFilterContext *ctx = fs->parent;
+    MidEqualizerContext *s = fs->opaque;
+    AVFilterLink *outlink = ctx->outputs[0];
+    AVFrame *out, *in0, *in1;
+    int ret;
+
+    if ((ret = ff_framesync_get_frame(&s->fs, 0, &in0, 0)) < 0 ||
+        (ret = ff_framesync_get_frame(&s->fs, 1, &in1, 0)) < 0)
+        return ret;
+
+    if (ctx->is_disabled) {
+        out = av_frame_clone(in0);
+        if (!out)
+            return AVERROR(ENOMEM);
+    } else {
+        int p;
+
+        out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+        if (!out)
+            return AVERROR(ENOMEM);
+        av_frame_copy_props(out, in0);
+
+        for (p = 0; p < s->nb_planes; p++) {
+            if (!((1 << p) & s->planes)) {
+                av_image_copy_plane(out->data[p], out->linesize[p], in0->data[p], in0->linesize[p],
+                                    s->width[0][p] * (1 + (s->histogram_size > 256)), s->height[0][p]);
+                continue;
+            }
+
+            s->midequalizer(in0->data[p], in1->data[p],
+                            out->data[p],
+                            in0->linesize[p], in1->linesize[p],
+                            out->linesize[p],
+                            s->width[0][p], s->height[0][p],
+                            s->width[1][p], s->height[1][p],
+                            s->histogram[0], s->histogram[1],
+                            s->cchange, s->histogram_size);
+        }
+    }
+    out->pts = av_rescale_q(in0->pts, s->fs.time_base, outlink->time_base);
+
+    return ff_filter_frame(outlink, out);
+}
+
+static void compute_histogram8(const uint8_t *src, ptrdiff_t linesize,
+                               int w, int h, float *histogram, size_t hsize)
+{
+    int y, x;
+
+    memset(histogram, 0, hsize * sizeof(*histogram));
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            histogram[src[x]] += 1;
+        }
+        src += linesize;
+    }
+
+    for (x = 0; x < hsize - 1; x++) {
+        histogram[x + 1] += histogram[x];
+        histogram[x] /= hsize;
+    }
+    histogram[x] /= hsize;
+}
+
+static void compute_histogram16(const uint16_t *src, ptrdiff_t linesize,
+                                int w, int h, float *histogram, size_t hsize)
+{
+    int y, x;
+
+    memset(histogram, 0, hsize * sizeof(*histogram));
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            histogram[src[x]] += 1;
+        }
+        src += linesize;
+    }
+
+    for (x = 0; x < hsize - 1; x++) {
+        histogram[x + 1] += histogram[x];
+        histogram[x] /= hsize;
+    }
+    histogram[x] /= hsize;
+}
+
+static void compute_contrast_change(float *histogram1, float *histogram2,
+                                    unsigned *cchange, size_t hsize)
+{
+    int i;
+
+    for (i = 0; i < hsize; i++) {
+        int j;
+
+        for (j = 0; j < hsize && histogram2[j] < histogram1[i]; j++);
+
+        cchange[i] = (i + j) / 2;
+    }
+}
+
+static void midequalizer8(const uint8_t *in0, const uint8_t *in1,
+                          uint8_t *dst,
+                          ptrdiff_t linesize1, ptrdiff_t linesize2,
+                          ptrdiff_t dlinesize,
+                          int w0, int h0,
+                          int w1, int h1,
+                          float *histogram1, float *histogram2,
+                          unsigned *cchange,
+                          size_t hsize)
+{
+    int x, y;
+
+    compute_histogram8(in0, linesize1, w0, h0, histogram1, hsize);
+    compute_histogram8(in1, linesize2, w1, h1, histogram2, hsize);
+
+    compute_contrast_change(histogram1, histogram2, cchange, hsize);
+
+    for (y = 0; y < h0; y++) {
+        for (x = 0; x < w0; x++) {
+            dst[x] = av_clip_uint8(cchange[in0[x]]);
+        }
+        dst += dlinesize;
+        in0 += linesize1;
+    }
+}
+
+static void midequalizer16(const uint8_t *in0, const uint8_t *in1,
+                           uint8_t *dst,
+                           ptrdiff_t linesize1, ptrdiff_t linesize2,
+                           ptrdiff_t dlinesize,
+                           int w0, int h0,
+                           int w1, int h1,
+                           float *histogram1, float *histogram2,
+                           unsigned *cchange,
+                           size_t hsize)
+{
+    const uint16_t *i = (const uint16_t *)in0;
+    uint16_t *d = (uint16_t *)dst;
+    int x, y;
+
+    compute_histogram16(i, linesize1 / 2, w0, h0, histogram1, hsize);
+    compute_histogram16((const uint16_t *)in1, linesize2 / 2, w1, h1, histogram2, hsize);
+
+    compute_contrast_change(histogram1, histogram2, cchange, hsize);
+
+    for (y = 0; y < h0; y++) {
+        for (x = 0; x < w0; x++) {
+            d[x] = cchange[i[x]];
+        }
+        d += dlinesize / 2;
+        i += linesize1 / 2;
+    }
+}
+
+static int config_input0(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    MidEqualizerContext *s = ctx->priv;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    int vsub, hsub;
+
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
+    hsub = desc->log2_chroma_w;
+    vsub = desc->log2_chroma_h;
+
+    s->height[0][0] = s->height[0][3] = inlink->h;
+    s->width[0][0]  = s->width[0][3]  = inlink->w;
+    s->height[0][1] = s->height[0][2] = AV_CEIL_RSHIFT(inlink->h, vsub);
+    s->width[0][1]  = s->width[0][2]  = AV_CEIL_RSHIFT(inlink->w, hsub);
+
+    s->histogram_size = 1 << desc->comp[0].depth;
+
+    s->histogram[0] = av_calloc(s->histogram_size, sizeof(float));
+    s->histogram[1] = av_calloc(s->histogram_size, sizeof(float));
+    s->cchange      = av_calloc(s->histogram_size, sizeof(unsigned));
+    if (!s->histogram[0] || !s->histogram[1] || !s->cchange)
+        return AVERROR(ENOMEM);
+
+    if (s->histogram_size == 256) {
+        s->midequalizer = midequalizer8;
+    } else {
+        s->midequalizer = midequalizer16;
+    }
+
+    return 0;
+}
+
+static int config_input1(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    MidEqualizerContext *s = ctx->priv;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    int vsub, hsub;
+
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
+    hsub = desc->log2_chroma_w;
+    vsub = desc->log2_chroma_h;
+
+    s->height[1][0] = s->height[1][3] = inlink->h;
+    s->width[1][0]  = s->width[1][3]  = inlink->w;
+    s->height[1][1] = s->height[1][2] = AV_CEIL_RSHIFT(inlink->h, vsub);
+    s->width[1][1]  = s->width[1][2]  = AV_CEIL_RSHIFT(inlink->w, hsub);
+
+    return 0;
+}
+
+static int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    MidEqualizerContext *s = ctx->priv;
+    AVFilterLink *in0 = ctx->inputs[0];
+    AVFilterLink *in1 = ctx->inputs[1];
+    FFFrameSyncIn *in;
+    int ret;
+
+    if (in0->format != in1->format) {
+        av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
+        return AVERROR(EINVAL);
+    }
+
+    outlink->w = in0->w;
+    outlink->h = in0->h;
+    outlink->time_base = in0->time_base;
+    outlink->sample_aspect_ratio = in0->sample_aspect_ratio;
+    outlink->frame_rate = in0->frame_rate;
+
+    if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)
+        return ret;
+
+    in = s->fs.in;
+    in[0].time_base = in0->time_base;
+    in[1].time_base = in1->time_base;
+    in[0].sync   = 1;
+    in[0].before = EXT_STOP;
+    in[0].after  = EXT_INFINITY;
+    in[1].sync   = 1;
+    in[1].before = EXT_STOP;
+    in[1].after  = EXT_INFINITY;
+    s->fs.opaque   = s;
+    s->fs.on_event = process_frame;
+
+    return ff_framesync_configure(&s->fs);
+}
+
+static int activate(AVFilterContext *ctx)
+{
+    MidEqualizerContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    MidEqualizerContext *s = ctx->priv;
+
+    ff_framesync_uninit(&s->fs);
+    av_freep(&s->histogram[0]);
+    av_freep(&s->histogram[1]);
+    av_freep(&s->cchange);
+}
+
+static const AVFilterPad midequalizer_inputs[] = {
+    {
+        .name         = "in0",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = config_input0,
+    },
+    {
+        .name         = "in1",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = config_input1,
+    },
+    { NULL }
+};
+
+static const AVFilterPad midequalizer_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .config_props  = config_output,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_midequalizer = {
+    .name          = "midequalizer",
+    .description   = NULL_IF_CONFIG_SMALL("Apply Midway Equalization."),
+    .priv_size     = sizeof(MidEqualizerContext),
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .activate      = activate,
+    .inputs        = midequalizer_inputs,
+    .outputs       = midequalizer_outputs,
+    .priv_class    = &midequalizer_class,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_minterpolate.c b/mythtv/external/FFmpeg/libavfilter/vf_minterpolate.c
index 4bb5853fcfc..6c5c2640055 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_minterpolate.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_minterpolate.c
@@ -654,7 +654,7 @@ static int cluster_mvs(MIContext *mi_ctx)
                 dx = avg_x - mv_x;
                 dy = avg_y - mv_y;
 
-                if (FFABS(avg_x - mv_x) > CLUSTER_THRESHOLD || FFABS(avg_y - mv_y) > CLUSTER_THRESHOLD) {
+                if (FFABS(dx) > CLUSTER_THRESHOLD || FFABS(dy) > CLUSTER_THRESHOLD) {
 
                     for (d = 1; d < 5; d++)
                         for (y = FFMAX(mb_y - d, 0); y < FFMIN(mb_y + d + 1, mi_ctx->b_height); y++)
@@ -721,7 +721,7 @@ static int inject_frame(AVFilterLink *inlink, AVFrame *avf_in)
 {
     AVFilterContext *ctx = inlink->dst;
     MIContext *mi_ctx = ctx->priv;
-    Frame frame_tmp, *frame;
+    Frame frame_tmp;
     int mb_x, mb_y, dir;
 
     av_frame_free(&mi_ctx->frames[0].avf);
@@ -729,7 +729,6 @@ static int inject_frame(AVFilterLink *inlink, AVFrame *avf_in)
     memmove(&mi_ctx->frames[0], &mi_ctx->frames[1], sizeof(mi_ctx->frames[0]) * (NB_FRAMES - 1));
     mi_ctx->frames[NB_FRAMES - 1] = frame_tmp;
     mi_ctx->frames[NB_FRAMES - 1].avf = avf_in;
-    frame = &mi_ctx->frames[NB_FRAMES - 1];
 
     if (mi_ctx->mi_mode == MI_MODE_MCI) {
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_mpdecimate.c b/mythtv/external/FFmpeg/libavfilter/vf_mpdecimate.c
index dc345114cde..c9a9cb3a8ed 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_mpdecimate.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_mpdecimate.c
@@ -33,7 +33,7 @@
 #include "formats.h"
 #include "video.h"
 
-typedef struct {
+typedef struct DecimateContext {
     const AVClass *class;
     int lo, hi;                    ///< lower and higher threshold number of differences
                                    ///< values for 8x8 blocks
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_nlmeans.c b/mythtv/external/FFmpeg/libavfilter/vf_nlmeans.c
index 2487813504d..e4952e187e5 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_nlmeans.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_nlmeans.c
@@ -47,7 +47,7 @@ struct weighted_avg {
 #define WEIGHT_LUT_NBITS 9
 #define WEIGHT_LUT_SIZE  (1<<WEIGHT_LUT_NBITS)
 
-typedef struct {
+typedef struct NLMeansContext {
     const AVClass *class;
     int nb_planes;
     int chroma_w, chroma_h;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_noise.h b/mythtv/external/FFmpeg/libavfilter/vf_noise.h
index 2207ed961f5..92998e54c9a 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_noise.h
+++ b/mythtv/external/FFmpeg/libavfilter/vf_noise.h
@@ -34,7 +34,7 @@
 #define NOISE_AVERAGED 8
 #define NOISE_PATTERN  16
 
-typedef struct {
+typedef struct FilterParams {
     int strength;
     unsigned flags;
     AVLFG lfg;
@@ -45,7 +45,7 @@ typedef struct {
     int rand_shift_init;
 } FilterParams;
 
-typedef struct {
+typedef struct NoiseContext {
     const AVClass *class;
     int nb_planes;
     int bytewidth[4];
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_ocr.c b/mythtv/external/FFmpeg/libavfilter/vf_ocr.c
index 870dd688410..e003982f05f 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_ocr.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_ocr.c
@@ -97,7 +97,7 @@ static int query_formats(AVFilterContext *ctx)
 
 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 {
-    AVDictionary **metadata = avpriv_frame_get_metadatap(in);
+    AVDictionary **metadata = &in->metadata;
     AVFilterContext *ctx = inlink->dst;
     AVFilterLink *outlink = ctx->outputs[0];
     OCRContext *s = ctx->priv;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_overlay.c b/mythtv/external/FFmpeg/libavfilter/vf_overlay.c
index c592dca9ed0..5bf3d66cf1f 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_overlay.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_overlay.c
@@ -36,8 +36,8 @@
 #include "libavutil/opt.h"
 #include "libavutil/timestamp.h"
 #include "internal.h"
-#include "dualinput.h"
 #include "drawutils.h"
+#include "framesync.h"
 #include "video.h"
 
 static const char *const var_names[] = {
@@ -70,16 +70,6 @@ enum var_name {
     VAR_VARS_NB
 };
 
-enum EOFAction {
-    EOF_ACTION_REPEAT,
-    EOF_ACTION_ENDALL,
-    EOF_ACTION_PASS
-};
-
-static const char * const eof_action_str[] = {
-    "repeat", "endall", "pass"
-};
-
 #define MAIN    0
 #define OVERLAY 1
 
@@ -103,6 +93,8 @@ enum OverlayFormat {
     OVERLAY_FORMAT_YUV422,
     OVERLAY_FORMAT_YUV444,
     OVERLAY_FORMAT_RGB,
+    OVERLAY_FORMAT_GBRP,
+    OVERLAY_FORMAT_AUTO,
     OVERLAY_FORMAT_NB
 };
 
@@ -110,7 +102,6 @@ typedef struct OverlayContext {
     const AVClass *class;
     int x, y;                   ///< position of overlaid picture
 
-    int allow_packed_rgb;
     uint8_t main_is_packed_rgb;
     uint8_t main_rgba_map[4];
     uint8_t main_has_alpha;
@@ -120,17 +111,16 @@ typedef struct OverlayContext {
     int format;                 ///< OverlayFormat
     int eval_mode;              ///< EvalMode
 
-    FFDualInputContext dinput;
+    FFFrameSync fs;
 
     int main_pix_step[4];       ///< steps per pixel for each plane of the main output
     int overlay_pix_step[4];    ///< steps per pixel for each plane of the overlay
     int hsub, vsub;             ///< chroma subsampling values
+    const AVPixFmtDescriptor *main_desc; ///< format descriptor for main input
 
     double var_values[VAR_VARS_NB];
     char *x_expr, *y_expr;
 
-    int eof_action;             ///< action to take on EOF from source
-
     AVExpr *x_pexpr, *y_pexpr;
 
     void (*blend_image)(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y);
@@ -140,7 +130,7 @@ static av_cold void uninit(AVFilterContext *ctx)
 {
     OverlayContext *s = ctx->priv;
 
-    ff_dualinput_uninit(&s->dinput);
+    ff_framesync_uninit(&s->fs);
     av_expr_free(s->x_pexpr); s->x_pexpr = NULL;
     av_expr_free(s->y_pexpr); s->y_pexpr = NULL;
 }
@@ -209,13 +199,21 @@ static int process_command(AVFilterContext *ctx, const char *cmd, const char *ar
     return ret;
 }
 
+static const enum AVPixelFormat alpha_pix_fmts[] = {
+    AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
+    AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, AV_PIX_FMT_RGBA,
+    AV_PIX_FMT_BGRA, AV_PIX_FMT_GBRAP, AV_PIX_FMT_NONE
+};
+
 static int query_formats(AVFilterContext *ctx)
 {
     OverlayContext *s = ctx->priv;
 
     /* overlay formats contains alpha, for avoiding conversion with alpha information loss */
     static const enum AVPixelFormat main_pix_fmts_yuv420[] = {
-        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_NONE
+        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVA420P,
+        AV_PIX_FMT_NV12, AV_PIX_FMT_NV21,
+        AV_PIX_FMT_NONE
     };
     static const enum AVPixelFormat overlay_pix_fmts_yuv420[] = {
         AV_PIX_FMT_YUVA420P, AV_PIX_FMT_NONE
@@ -235,6 +233,13 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE
     };
 
+    static const enum AVPixelFormat main_pix_fmts_gbrp[] = {
+        AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_NONE
+    };
+    static const enum AVPixelFormat overlay_pix_fmts_gbrp[] = {
+        AV_PIX_FMT_GBRAP, AV_PIX_FMT_NONE
+    };
+
     static const enum AVPixelFormat main_pix_fmts_rgb[] = {
         AV_PIX_FMT_ARGB,  AV_PIX_FMT_RGBA,
         AV_PIX_FMT_ABGR,  AV_PIX_FMT_BGRA,
@@ -280,14 +285,33 @@ static int query_formats(AVFilterContext *ctx)
                 goto fail;
             }
         break;
+    case OVERLAY_FORMAT_GBRP:
+        if (!(main_formats    = ff_make_format_list(main_pix_fmts_gbrp)) ||
+            !(overlay_formats = ff_make_format_list(overlay_pix_fmts_gbrp))) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+        break;
+    case OVERLAY_FORMAT_AUTO:
+        if (!(main_formats    = ff_make_format_list(alpha_pix_fmts))) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+        break;
     default:
         av_assert0(0);
     }
 
-    if ((ret = ff_formats_ref(main_formats   , &ctx->inputs[MAIN]->out_formats   )) < 0 ||
-        (ret = ff_formats_ref(overlay_formats, &ctx->inputs[OVERLAY]->out_formats)) < 0 ||
-        (ret = ff_formats_ref(main_formats   , &ctx->outputs[MAIN]->in_formats   )) < 0)
+    if (s->format == OVERLAY_FORMAT_AUTO) {
+        ret = ff_set_common_formats(ctx, main_formats);
+        if (ret < 0)
             goto fail;
+    } else {
+        if ((ret = ff_formats_ref(main_formats   , &ctx->inputs[MAIN]->out_formats   )) < 0 ||
+            (ret = ff_formats_ref(overlay_formats, &ctx->inputs[OVERLAY]->out_formats)) < 0 ||
+            (ret = ff_formats_ref(main_formats   , &ctx->outputs[MAIN]->in_formats   )) < 0)
+                goto fail;
+    }
 
     return 0;
 fail:
@@ -300,12 +324,6 @@ static int query_formats(AVFilterContext *ctx)
     return ret;
 }
 
-static const enum AVPixelFormat alpha_pix_fmts[] = {
-    AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
-    AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, AV_PIX_FMT_RGBA,
-    AV_PIX_FMT_BGRA, AV_PIX_FMT_NONE
-};
-
 static int config_input_overlay(AVFilterLink *inlink)
 {
     AVFilterContext *ctx  = inlink->dst;
@@ -345,12 +363,11 @@ static int config_input_overlay(AVFilterLink *inlink)
     }
 
     av_log(ctx, AV_LOG_VERBOSE,
-           "main w:%d h:%d fmt:%s overlay w:%d h:%d fmt:%s eof_action:%s\n",
+           "main w:%d h:%d fmt:%s overlay w:%d h:%d fmt:%s\n",
            ctx->inputs[MAIN]->w, ctx->inputs[MAIN]->h,
            av_get_pix_fmt_name(ctx->inputs[MAIN]->format),
            ctx->inputs[OVERLAY]->w, ctx->inputs[OVERLAY]->h,
-           av_get_pix_fmt_name(ctx->inputs[OVERLAY]->format),
-           eof_action_str[s->eof_action]);
+           av_get_pix_fmt_name(ctx->inputs[OVERLAY]->format));
     return 0;
 }
 
@@ -360,14 +377,14 @@ static int config_output(AVFilterLink *outlink)
     OverlayContext *s = ctx->priv;
     int ret;
 
-    if ((ret = ff_dualinput_init(ctx, &s->dinput)) < 0)
+    if ((ret = ff_framesync_init_dualinput(&s->fs, ctx)) < 0)
         return ret;
 
     outlink->w = ctx->inputs[MAIN]->w;
     outlink->h = ctx->inputs[MAIN]->h;
     outlink->time_base = ctx->inputs[MAIN]->time_base;
 
-    return 0;
+    return ff_framesync_configure(&s->fs);
 }
 
 // divide by 255 and round to nearest
@@ -386,7 +403,7 @@ static int config_output(AVFilterLink *outlink)
 
 static void blend_image_packed_rgb(AVFilterContext *ctx,
                                    AVFrame *dst, const AVFrame *src,
-                                   int x, int y)
+                                   int main_has_alpha, int x, int y)
 {
     OverlayContext *s = ctx->priv;
     int i, imax, j, jmax;
@@ -405,7 +422,6 @@ static void blend_image_packed_rgb(AVFilterContext *ctx,
     const int sb = s->overlay_rgba_map[B];
     const int sa = s->overlay_rgba_map[A];
     const int sstep = s->overlay_pix_step[0];
-    const int main_has_alpha = s->main_has_alpha;
     uint8_t *S, *sp, *d, *dp;
 
     i = FFMAX(-y, 0);
@@ -468,7 +484,10 @@ static av_always_inline void blend_plane(AVFilterContext *ctx,
                                          int dst_w, int dst_h,
                                          int i, int hsub, int vsub,
                                          int x, int y,
-                                         int main_has_alpha)
+                                         int main_has_alpha,
+                                         int dst_plane,
+                                         int dst_offset,
+                                         int dst_step)
 {
     int src_wp = AV_CEIL_RSHIFT(src_w, hsub);
     int src_hp = AV_CEIL_RSHIFT(src_h, vsub);
@@ -476,19 +495,23 @@ static av_always_inline void blend_plane(AVFilterContext *ctx,
     int dst_hp = AV_CEIL_RSHIFT(dst_h, vsub);
     int yp = y>>vsub;
     int xp = x>>hsub;
-    uint8_t *s, *sp, *d, *dp, *a, *ap;
+    uint8_t *s, *sp, *d, *dp, *dap, *a, *da, *ap;
     int jmax, j, k, kmax;
 
     j = FFMAX(-yp, 0);
     sp = src->data[i] + j         * src->linesize[i];
-    dp = dst->data[i] + (yp+j)    * dst->linesize[i];
+    dp = dst->data[dst_plane]
+                      + (yp+j)    * dst->linesize[dst_plane]
+                      + dst_offset;
     ap = src->data[3] + (j<<vsub) * src->linesize[3];
+    dap = dst->data[3] + ((yp+j) << vsub) * dst->linesize[3];
 
     for (jmax = FFMIN(-yp + dst_hp, src_hp); j < jmax; j++) {
         k = FFMAX(-xp, 0);
-        d = dp + xp+k;
+        d = dp + (xp+k) * dst_step;
         s = sp + k;
         a = ap + (k<<hsub);
+        da = dap + ((xp+k) << hsub);
 
         for (kmax = FFMIN(-xp + dst_wp, src_wp); k < kmax; k++) {
             int alpha_v, alpha_h, alpha;
@@ -511,26 +534,28 @@ static av_always_inline void blend_plane(AVFilterContext *ctx,
                 // average alpha for color components, improve quality
                 uint8_t alpha_d;
                 if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) {
-                    alpha_d = (d[0] + d[src->linesize[3]] +
-                               d[1] + d[src->linesize[3]+1]) >> 2;
+                    alpha_d = (da[0] + da[dst->linesize[3]] +
+                               da[1] + da[dst->linesize[3]+1]) >> 2;
                 } else if (hsub || vsub) {
                     alpha_h = hsub && k+1 < src_wp ?
-                        (d[0] + d[1]) >> 1 : d[0];
+                        (da[0] + da[1]) >> 1 : da[0];
                     alpha_v = vsub && j+1 < src_hp ?
-                        (d[0] + d[src->linesize[3]]) >> 1 : d[0];
+                        (da[0] + da[dst->linesize[3]]) >> 1 : da[0];
                     alpha_d = (alpha_v + alpha_h) >> 1;
                 } else
-                    alpha_d = d[0];
+                    alpha_d = da[0];
                 alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d);
             }
             *d = FAST_DIV255(*d * (255 - alpha) + *s * alpha);
             s++;
-            d++;
+            d += dst_step;
+            da += 1 << hsub;
             a += 1 << hsub;
         }
-        dp += dst->linesize[i];
+        dp += dst->linesize[dst_plane];
         sp += src->linesize[i];
         ap += (1 << vsub) * src->linesize[3];
+        dap += (1 << vsub) * dst->linesize[3];
     }
 }
 
@@ -582,38 +607,94 @@ static av_always_inline void blend_image_yuv(AVFilterContext *ctx,
                                              int main_has_alpha,
                                              int x, int y)
 {
+    OverlayContext *s = ctx->priv;
     const int src_w = src->width;
     const int src_h = src->height;
     const int dst_w = dst->width;
     const int dst_h = dst->height;
 
+    blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 0, 0,       0, x, y, main_has_alpha,
+                s->main_desc->comp[0].plane, s->main_desc->comp[0].offset, s->main_desc->comp[0].step);
+    blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 1, hsub, vsub, x, y, main_has_alpha,
+                s->main_desc->comp[1].plane, s->main_desc->comp[1].offset, s->main_desc->comp[1].step);
+    blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 2, hsub, vsub, x, y, main_has_alpha,
+                s->main_desc->comp[2].plane, s->main_desc->comp[2].offset, s->main_desc->comp[2].step);
+
     if (main_has_alpha)
         alpha_composite(src, dst, src_w, src_h, dst_w, dst_h, x, y);
+}
+
+static av_always_inline void blend_image_planar_rgb(AVFilterContext *ctx,
+                                                    AVFrame *dst, const AVFrame *src,
+                                                    int hsub, int vsub,
+                                                    int main_has_alpha,
+                                                    int x, int y)
+{
+    OverlayContext *s = ctx->priv;
+    const int src_w = src->width;
+    const int src_h = src->height;
+    const int dst_w = dst->width;
+    const int dst_h = dst->height;
 
-    blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 0, 0,       0, x, y, main_has_alpha);
-    blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 1, hsub, vsub, x, y, main_has_alpha);
-    blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 2, hsub, vsub, x, y, main_has_alpha);
+    blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 0, 0,       0, x, y, main_has_alpha,
+                s->main_desc->comp[1].plane, s->main_desc->comp[1].offset, s->main_desc->comp[1].step);
+    blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 1, hsub, vsub, x, y, main_has_alpha,
+                s->main_desc->comp[2].plane, s->main_desc->comp[2].offset, s->main_desc->comp[2].step);
+    blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 2, hsub, vsub, x, y, main_has_alpha,
+                s->main_desc->comp[0].plane, s->main_desc->comp[0].offset, s->main_desc->comp[0].step);
+
+    if (main_has_alpha)
+        alpha_composite(src, dst, src_w, src_h, dst_w, dst_h, x, y);
 }
 
 static void blend_image_yuv420(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
 {
-    OverlayContext *s = ctx->priv;
+    blend_image_yuv(ctx, dst, src, 1, 1, 0, x, y);
+}
 
-    blend_image_yuv(ctx, dst, src, 1, 1, s->main_has_alpha, x, y);
+static void blend_image_yuva420(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
+{
+    blend_image_yuv(ctx, dst, src, 1, 1, 1, x, y);
 }
 
 static void blend_image_yuv422(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
 {
-    OverlayContext *s = ctx->priv;
+    blend_image_yuv(ctx, dst, src, 1, 0, 0, x, y);
+}
 
-    blend_image_yuv(ctx, dst, src, 1, 0, s->main_has_alpha, x, y);
+static void blend_image_yuva422(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
+{
+    blend_image_yuv(ctx, dst, src, 1, 0, 1, x, y);
 }
 
 static void blend_image_yuv444(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
 {
-    OverlayContext *s = ctx->priv;
+    blend_image_yuv(ctx, dst, src, 0, 0, 0, x, y);
+}
+
+static void blend_image_yuva444(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
+{
+    blend_image_yuv(ctx, dst, src, 0, 0, 1, x, y);
+}
+
+static void blend_image_gbrp(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
+{
+    blend_image_planar_rgb(ctx, dst, src, 0, 0, 0, x, y);
+}
 
-    blend_image_yuv(ctx, dst, src, 0, 0, s->main_has_alpha, x, y);
+static void blend_image_gbrap(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
+{
+    blend_image_planar_rgb(ctx, dst, src, 0, 0, 1, x, y);
+}
+
+static void blend_image_rgb(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
+{
+    blend_image_packed_rgb(ctx, dst, src, 0, x, y);
+}
+
+static void blend_image_rgba(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
+{
+    blend_image_packed_rgb(ctx, dst, src, 1, x, y);
 }
 
 static int config_input_main(AVFilterLink *inlink)
@@ -626,36 +707,74 @@ static int config_input_main(AVFilterLink *inlink)
     s->hsub = pix_desc->log2_chroma_w;
     s->vsub = pix_desc->log2_chroma_h;
 
+    s->main_desc = pix_desc;
+
     s->main_is_packed_rgb =
         ff_fill_rgba_map(s->main_rgba_map, inlink->format) >= 0;
     s->main_has_alpha = ff_fmt_is_in(inlink->format, alpha_pix_fmts);
     switch (s->format) {
     case OVERLAY_FORMAT_YUV420:
-        s->blend_image = blend_image_yuv420;
+        s->blend_image = s->main_has_alpha ? blend_image_yuva420 : blend_image_yuv420;
         break;
     case OVERLAY_FORMAT_YUV422:
-        s->blend_image = blend_image_yuv422;
+        s->blend_image = s->main_has_alpha ? blend_image_yuva422 : blend_image_yuv422;
         break;
     case OVERLAY_FORMAT_YUV444:
-        s->blend_image = blend_image_yuv444;
+        s->blend_image = s->main_has_alpha ? blend_image_yuva444 : blend_image_yuv444;
         break;
     case OVERLAY_FORMAT_RGB:
-        s->blend_image = blend_image_packed_rgb;
+        s->blend_image = s->main_has_alpha ? blend_image_rgba : blend_image_rgb;
+        break;
+    case OVERLAY_FORMAT_GBRP:
+        s->blend_image = s->main_has_alpha ? blend_image_gbrap : blend_image_gbrp;
+        break;
+    case OVERLAY_FORMAT_AUTO:
+        switch (inlink->format) {
+        case AV_PIX_FMT_YUVA420P:
+            s->blend_image = blend_image_yuva420;
+            break;
+        case AV_PIX_FMT_YUVA422P:
+            s->blend_image = blend_image_yuva422;
+            break;
+        case AV_PIX_FMT_YUVA444P:
+            s->blend_image = blend_image_yuva444;
+            break;
+        case AV_PIX_FMT_ARGB:
+        case AV_PIX_FMT_RGBA:
+        case AV_PIX_FMT_BGRA:
+        case AV_PIX_FMT_ABGR:
+            s->blend_image = blend_image_rgba;
+            break;
+        case AV_PIX_FMT_GBRAP:
+            s->blend_image = blend_image_gbrap;
+            break;
+        default:
+            av_assert0(0);
+            break;
+        }
         break;
     }
     return 0;
 }
 
-static AVFrame *do_blend(AVFilterContext *ctx, AVFrame *mainpic,
-                         const AVFrame *second)
+static int do_blend(FFFrameSync *fs)
 {
+    AVFilterContext *ctx = fs->parent;
+    AVFrame *mainpic, *second;
     OverlayContext *s = ctx->priv;
     AVFilterLink *inlink = ctx->inputs[0];
+    int ret;
+
+    ret = ff_framesync_dualinput_get_writable(fs, &mainpic, &second);
+    if (ret < 0)
+        return ret;
+    if (!second)
+        return ff_filter_frame(ctx->outputs[0], mainpic);
 
     if (s->eval_mode == EVAL_MODE_FRAME) {
-        int64_t pos = av_frame_get_pkt_pos(mainpic);
+        int64_t pos = mainpic->pkt_pos;
 
-        s->var_values[VAR_N] = inlink->frame_count;
+        s->var_values[VAR_N] = inlink->frame_count_out;
         s->var_values[VAR_T] = mainpic->pts == AV_NOPTS_VALUE ?
             NAN : mainpic->pts * av_q2d(inlink->time_base);
         s->var_values[VAR_POS] = pos == -1 ? NAN : pos;
@@ -675,42 +794,21 @@ static AVFrame *do_blend(AVFilterContext *ctx, AVFrame *mainpic,
     if (s->x < mainpic->width  && s->x + second->width  >= 0 ||
         s->y < mainpic->height && s->y + second->height >= 0)
         s->blend_image(ctx, mainpic, second, s->x, s->y);
-    return mainpic;
+    return ff_filter_frame(ctx->outputs[0], mainpic);
 }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
+static av_cold int init(AVFilterContext *ctx)
 {
-    OverlayContext *s = inlink->dst->priv;
-    av_log(inlink->dst, AV_LOG_DEBUG, "Incoming frame (time:%s) from link #%d\n", av_ts2timestr(inpicref->pts, &inlink->time_base), FF_INLINK_IDX(inlink));
-    return ff_dualinput_filter_frame(&s->dinput, inlink, inpicref);
-}
+    OverlayContext *s = ctx->priv;
 
-static int request_frame(AVFilterLink *outlink)
-{
-    OverlayContext *s = outlink->src->priv;
-    return ff_dualinput_request_frame(&s->dinput, outlink);
+    s->fs.on_event = do_blend;
+    return 0;
 }
 
-static av_cold int init(AVFilterContext *ctx)
+static int activate(AVFilterContext *ctx)
 {
     OverlayContext *s = ctx->priv;
-
-    if (s->allow_packed_rgb) {
-        av_log(ctx, AV_LOG_WARNING,
-               "The rgb option is deprecated and is overriding the format option, use format instead\n");
-        s->format = OVERLAY_FORMAT_RGB;
-    }
-    if (!s->dinput.repeatlast || s->eof_action == EOF_ACTION_PASS) {
-        s->dinput.repeatlast = 0;
-        s->eof_action = EOF_ACTION_PASS;
-    }
-    if (s->dinput.shortest || s->eof_action == EOF_ACTION_ENDALL) {
-        s->dinput.shortest = 1;
-        s->eof_action = EOF_ACTION_ENDALL;
-    }
-
-    s->dinput.process = do_blend;
-    return 0;
+    return ff_framesync_activate(&s->fs);
 }
 
 #define OFFSET(x) offsetof(OverlayContext, x)
@@ -720,7 +818,7 @@ static const AVOption overlay_options[] = {
     { "x", "set the x expression", OFFSET(x_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "y", "set the y expression", OFFSET(y_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "eof_action", "Action to take when encountering EOF from secondary input ",
-        OFFSET(eof_action), AV_OPT_TYPE_INT, { .i64 = EOF_ACTION_REPEAT },
+        OFFSET(fs.opt_eof_action), AV_OPT_TYPE_INT, { .i64 = EOF_ACTION_REPEAT },
         EOF_ACTION_REPEAT, EOF_ACTION_PASS, .flags = FLAGS, "eof_action" },
         { "repeat", "Repeat the previous frame.",   0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_REPEAT }, .flags = FLAGS, "eof_action" },
         { "endall", "End both streams.",            0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_ENDALL }, .flags = FLAGS, "eof_action" },
@@ -728,32 +826,30 @@ static const AVOption overlay_options[] = {
     { "eval", "specify when to evaluate expressions", OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_FRAME}, 0, EVAL_MODE_NB-1, FLAGS, "eval" },
          { "init",  "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT},  .flags = FLAGS, .unit = "eval" },
          { "frame", "eval expressions per-frame",                  0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },
-    { "rgb", "force packed RGB in input and output (deprecated)", OFFSET(allow_packed_rgb), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
-    { "shortest", "force termination when the shortest input terminates", OFFSET(dinput.shortest), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
+    { "shortest", "force termination when the shortest input terminates", OFFSET(fs.opt_shortest), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
     { "format", "set output format", OFFSET(format), AV_OPT_TYPE_INT, {.i64=OVERLAY_FORMAT_YUV420}, 0, OVERLAY_FORMAT_NB-1, FLAGS, "format" },
         { "yuv420", "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_YUV420}, .flags = FLAGS, .unit = "format" },
         { "yuv422", "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_YUV422}, .flags = FLAGS, .unit = "format" },
         { "yuv444", "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_YUV444}, .flags = FLAGS, .unit = "format" },
         { "rgb",    "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_RGB},    .flags = FLAGS, .unit = "format" },
-    { "repeatlast", "repeat overlay of the last overlay frame", OFFSET(dinput.repeatlast), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
+        { "gbrp",   "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_GBRP},   .flags = FLAGS, .unit = "format" },
+        { "auto",   "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_AUTO},   .flags = FLAGS, .unit = "format" },
+    { "repeatlast", "repeat overlay of the last overlay frame", OFFSET(fs.opt_repeatlast), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
     { NULL }
 };
 
-AVFILTER_DEFINE_CLASS(overlay);
+FRAMESYNC_DEFINE_CLASS(overlay, OverlayContext, fs);
 
 static const AVFilterPad avfilter_vf_overlay_inputs[] = {
     {
         .name         = "main",
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input_main,
-        .filter_frame = filter_frame,
-        .needs_writable = 1,
     },
     {
         .name         = "overlay",
         .type         = AVMEDIA_TYPE_VIDEO,
         .config_props = config_input_overlay,
-        .filter_frame = filter_frame,
     },
     { NULL }
 };
@@ -763,7 +859,6 @@ static const AVFilterPad avfilter_vf_overlay_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -771,11 +866,13 @@ static const AVFilterPad avfilter_vf_overlay_outputs[] = {
 AVFilter ff_vf_overlay = {
     .name          = "overlay",
     .description   = NULL_IF_CONFIG_SMALL("Overlay a video source on top of the input."),
+    .preinit       = overlay_framesync_preinit,
     .init          = init,
     .uninit        = uninit,
     .priv_size     = sizeof(OverlayContext),
     .priv_class    = &overlay_class,
     .query_formats = query_formats,
+    .activate      = activate,
     .process_command = process_command,
     .inputs        = avfilter_vf_overlay_inputs,
     .outputs       = avfilter_vf_overlay_outputs,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_owdenoise.c b/mythtv/external/FFmpeg/libavfilter/vf_owdenoise.c
index e0a953fba2c..6d6c2a3d539 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_owdenoise.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_owdenoise.c
@@ -34,7 +34,7 @@
 #include "avfilter.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct OWDenoiseContext {
     const AVClass *class;
     double luma_strength;
     double chroma_strength;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_pad.c b/mythtv/external/FFmpeg/libavfilter/vf_pad.c
index dfc873cd39d..ed155578e11 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_pad.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_pad.c
@@ -24,6 +24,8 @@
  * video padding filter
  */
 
+#include <float.h>  /* DBL_MAX */
+
 #include "avfilter.h"
 #include "formats.h"
 #include "internal.h"
@@ -75,11 +77,19 @@ static int query_formats(AVFilterContext *ctx)
     return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
 }
 
+enum EvalMode {
+    EVAL_MODE_INIT,
+    EVAL_MODE_FRAME,
+    EVAL_MODE_NB
+};
+
 typedef struct PadContext {
     const AVClass *class;
     int w, h;               ///< output dimensions, a value of 0 will result in the input size
     int x, y;               ///< offsets of the input area with respect to the padded area
     int in_w, in_h;         ///< width and height for the padded input video, which has to be aligned to the chroma values in order to avoid chroma issues
+    int inlink_w, inlink_h;
+    AVRational aspect;
 
     char *w_expr;           ///< width  expression string
     char *h_expr;           ///< height expression string
@@ -88,12 +98,15 @@ typedef struct PadContext {
     uint8_t rgba_color[4];  ///< color for the padding area
     FFDrawContext draw;
     FFDrawColor color;
+
+    int eval_mode;          ///< expression evaluation mode
 } PadContext;
 
 static int config_input(AVFilterLink *inlink)
 {
     AVFilterContext *ctx = inlink->dst;
     PadContext *s = ctx->priv;
+    AVRational adjusted_aspect = s->aspect;
     int ret;
     double var_values[VARS_NB], res;
     char *expr;
@@ -134,6 +147,15 @@ static int config_input(AVFilterLink *inlink)
     if (!s->w)
         var_values[VAR_OUT_W] = var_values[VAR_OW] = s->w = inlink->w;
 
+    if (adjusted_aspect.num && adjusted_aspect.den) {
+        adjusted_aspect = av_div_q(adjusted_aspect, inlink->sample_aspect_ratio);
+        if (s->h < av_rescale(s->w, adjusted_aspect.den, adjusted_aspect.num)) {
+            s->h = var_values[VAR_OUT_H] = var_values[VAR_OH] = av_rescale(s->w, adjusted_aspect.den, adjusted_aspect.num);
+        } else {
+            s->w = var_values[VAR_OUT_W] = var_values[VAR_OW] = av_rescale(s->h, adjusted_aspect.num, adjusted_aspect.den);
+        }
+    }
+
     /* evaluate x and y */
     av_expr_parse_and_eval(&res, (expr = s->x_expr),
                            var_names, var_values,
@@ -151,8 +173,13 @@ static int config_input(AVFilterLink *inlink)
         goto eval_fail;
     s->x = var_values[VAR_X] = res;
 
+    if (s->x < 0 || s->x + inlink->w > s->w)
+        s->x = var_values[VAR_X] = (s->w - inlink->w) / 2;
+    if (s->y < 0 || s->y + inlink->h > s->h)
+        s->y = var_values[VAR_Y] = (s->h - inlink->h) / 2;
+
     /* sanity check params */
-    if (s->w < 0 || s->h < 0 || s->x < 0 || s->y < 0) {
+    if (s->w < 0 || s->h < 0) {
         av_log(ctx, AV_LOG_ERROR, "Negative values are not acceptable.\n");
         return AVERROR(EINVAL);
     }
@@ -163,6 +190,8 @@ static int config_input(AVFilterLink *inlink)
     s->y    = ff_draw_round_to_sub(&s->draw, 1, -1, s->y);
     s->in_w = ff_draw_round_to_sub(&s->draw, 0, -1, inlink->w);
     s->in_h = ff_draw_round_to_sub(&s->draw, 1, -1, inlink->h);
+    s->inlink_w = inlink->w;
+    s->inlink_h = inlink->h;
 
     av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d -> w:%d h:%d x:%d y:%d color:0x%02X%02X%02X%02X\n",
            inlink->w, inlink->h, s->w, s->h, s->x, s->y,
@@ -199,12 +228,16 @@ static int config_output(AVFilterLink *outlink)
 static AVFrame *get_video_buffer(AVFilterLink *inlink, int w, int h)
 {
     PadContext *s = inlink->dst->priv;
-
-    AVFrame *frame = ff_get_video_buffer(inlink->dst->outputs[0],
-                                         w + (s->w - s->in_w),
-                                         h + (s->h - s->in_h) + (s->x > 0));
+    AVFrame *frame;
     int plane;
 
+    if (s->inlink_w <= 0)
+        return NULL;
+
+    frame = ff_get_video_buffer(inlink->dst->outputs[0],
+                                w + (s->w - s->in_w),
+                                h + (s->h - s->in_h) + (s->x > 0));
+
     if (!frame)
         return NULL;
 
@@ -290,8 +323,35 @@ static int frame_needs_copy(PadContext *s, AVFrame *frame)
 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 {
     PadContext *s = inlink->dst->priv;
+    AVFilterLink *outlink = inlink->dst->outputs[0];
     AVFrame *out;
-    int needs_copy = frame_needs_copy(s, in);
+    int needs_copy;
+    if(s->eval_mode == EVAL_MODE_FRAME && (
+           in->width  != s->inlink_w
+        || in->height != s->inlink_h
+        || in->format != outlink->format
+        || in->sample_aspect_ratio.den != outlink->sample_aspect_ratio.den || in->sample_aspect_ratio.num != outlink->sample_aspect_ratio.num)) {
+        int ret;
+
+        inlink->dst->inputs[0]->format = in->format;
+        inlink->dst->inputs[0]->w      = in->width;
+        inlink->dst->inputs[0]->h      = in->height;
+
+        inlink->dst->inputs[0]->sample_aspect_ratio.den = in->sample_aspect_ratio.den;
+        inlink->dst->inputs[0]->sample_aspect_ratio.num = in->sample_aspect_ratio.num;
+
+
+        if ((ret = config_input(inlink)) < 0) {
+            s->inlink_w = -1;
+            return ret;
+        }
+        if ((ret = config_output(outlink)) < 0) {
+            s->inlink_w = -1;
+            return ret;
+        }
+    }
+
+    needs_copy = frame_needs_copy(s, in);
 
     if (needs_copy) {
         av_log(inlink->dst, AV_LOG_DEBUG, "Direct padding impossible allocating new frame\n");
@@ -364,6 +424,10 @@ static const AVOption pad_options[] = {
     { "x",      "set the x offset expression for the input image position", OFFSET(x_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "y",      "set the y offset expression for the input image position", OFFSET(y_expr), AV_OPT_TYPE_STRING, {.str = "0"}, CHAR_MIN, CHAR_MAX, FLAGS },
     { "color",  "set the color of the padded area border", OFFSET(rgba_color), AV_OPT_TYPE_COLOR, {.str = "black"}, .flags = FLAGS },
+    { "eval",   "specify when to evaluate expressions",    OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_INIT}, 0, EVAL_MODE_NB-1, FLAGS, "eval" },
+         { "init",  "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT},  .flags = FLAGS, .unit = "eval" },
+         { "frame", "eval expressions during initialization and per-frame", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },
+    { "aspect",  "pad to fit an aspect instead of a resolution", OFFSET(aspect), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, 0, DBL_MAX, FLAGS },
     { NULL }
 };
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_palettegen.c b/mythtv/external/FFmpeg/libavfilter/vf_palettegen.c
index 668a4aee228..03de3173483 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_palettegen.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_palettegen.c
@@ -60,7 +60,7 @@ enum {
 #define NBITS 5
 #define HIST_SIZE (1<<(3*NBITS))
 
-typedef struct {
+typedef struct PaletteGenContext {
     const AVClass *class;
 
     int max_colors;
@@ -95,15 +95,10 @@ static int query_formats(AVFilterContext *ctx)
     static const enum AVPixelFormat in_fmts[]  = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
     static const enum AVPixelFormat out_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
     int ret;
-    AVFilterFormats *in  = ff_make_format_list(in_fmts);
-    AVFilterFormats *out = ff_make_format_list(out_fmts);
-    if (!in || !out) {
-        av_freep(&in);
-        av_freep(&out);
-        return AVERROR(ENOMEM);
-    }
-    if ((ret = ff_formats_ref(in , &ctx->inputs[0]->out_formats)) < 0 ||
-        (ret = ff_formats_ref(out, &ctx->outputs[0]->in_formats)) < 0)
+
+    if ((ret = ff_formats_ref(ff_make_format_list(in_fmts) , &ctx->inputs[0]->out_formats)) < 0)
+        return ret;
+    if ((ret = ff_formats_ref(ff_make_format_list(out_fmts), &ctx->outputs[0]->in_formats)) < 0)
         return ret;
     return 0;
 }
@@ -244,7 +239,7 @@ static void write_palette(AVFilterContext *ctx, AVFrame *out)
             if (box_id < s->nb_boxes) {
                 pal[x] = s->boxes[box_id++].color;
                 if ((x || y) && pal[x] == last_color)
-                    av_log(ctx, AV_LOG_WARNING, "Dupped color: %08X\n", pal[x]);
+                    av_log(ctx, AV_LOG_WARNING, "Dupped color: %08"PRIX32"\n", pal[x]);
                 last_color = pal[x];
             } else {
                 pal[x] = 0xff000000; // pad with black
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_paletteuse.c b/mythtv/external/FFmpeg/libavfilter/vf_paletteuse.c
index e063ff73863..79a06728919 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_paletteuse.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_paletteuse.c
@@ -27,8 +27,10 @@
 #include "libavutil/internal.h"
 #include "libavutil/opt.h"
 #include "libavutil/qsort.h"
-#include "dualinput.h"
 #include "avfilter.h"
+#include "filters.h"
+#include "framesync.h"
+#include "internal.h"
 
 enum dithering_mode {
     DITHERING_NONE,
@@ -80,7 +82,7 @@ typedef int (*set_frame_func)(struct PaletteUseContext *s, AVFrame *out, AVFrame
 
 typedef struct PaletteUseContext {
     const AVClass *class;
-    FFDualInputContext dinput;
+    FFFrameSync fs;
     struct cache_node cache[CACHE_SIZE];    /* lookup cache */
     struct color_node map[AVPALETTE_COUNT]; /* 3D-Tree (KD-Tree with K=3) for reverse colormap */
     uint32_t palette[AVPALETTE_COUNT];
@@ -129,6 +131,8 @@ static const AVOption paletteuse_options[] = {
 
 AVFILTER_DEFINE_CLASS(paletteuse);
 
+static int load_apply_palette(FFFrameSync *fs);
+
 static int query_formats(AVFilterContext *ctx)
 {
     static const enum AVPixelFormat in_fmts[]    = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
@@ -444,7 +448,7 @@ static av_always_inline int set_frame(PaletteUseContext *s, AVFrame *out, AVFram
                 if (down) {
                     if (left2)      src[  src_linesize + x - 2] = dither_color(src[  src_linesize + x - 2], er, eg, eb, 1, 4);
                     if (left)       src[  src_linesize + x - 1] = dither_color(src[  src_linesize + x - 1], er, eg, eb, 2, 4);
-                                    src[  src_linesize + x    ] = dither_color(src[  src_linesize + x    ], er, eg, eb, 3, 4);
+                    if (1)          src[  src_linesize + x    ] = dither_color(src[  src_linesize + x    ], er, eg, eb, 3, 4);
                     if (right)      src[  src_linesize + x + 1] = dither_color(src[  src_linesize + x + 1], er, eg, eb, 2, 4);
                     if (right2)     src[  src_linesize + x + 2] = dither_color(src[  src_linesize + x + 2], er, eg, eb, 1, 4);
                 }
@@ -491,7 +495,7 @@ static void disp_node(AVBPrint *buf,
     av_bprintf(buf, "%*cnode%d ["
                "label=\"%c%02X%c%02X%c%02X%c\" "
                "fillcolor=\"#%02x%02x%02x\" "
-               "fontcolor=\"#%06X\"]\n",
+               "fontcolor=\"#%06"PRIX32"\"]\n",
                depth*INDENT, ' ', node->palette_id,
                "[  "[node->split], node->val[0],
                "][ "[node->split], node->val[1],
@@ -552,7 +556,7 @@ static int debug_accuracy(const struct color_node *node, const uint32_t *palette
                     const int d2 = diff(palrgb2, rgb);
                     if (d1 != d2) {
                         av_log(NULL, AV_LOG_ERROR,
-                               "/!\\ %02X%02X%02X: %d ! %d (%06X ! %06X) / dist: %d ! %d\n",
+                               "/!\\ %02X%02X%02X: %d ! %d (%06"PRIX32" ! %06"PRIX32") / dist: %d ! %d\n",
                                r, g, b, r1, r2, c1 & 0xffffff, c2 & 0xffffff, d1, d2);
                         ret = 1;
                     }
@@ -889,7 +893,7 @@ static AVFrame *apply_palette(AVFilterLink *inlink, AVFrame *in)
     }
     memcpy(out->data[1], s->palette, AVPALETTE_SIZE);
     if (s->calc_mean_err)
-        debug_mean_error(s, in, out, inlink->frame_count);
+        debug_mean_error(s, in, out, inlink->frame_count_out);
     av_frame_free(&in);
     return out;
 }
@@ -900,11 +904,18 @@ static int config_output(AVFilterLink *outlink)
     AVFilterContext *ctx = outlink->src;
     PaletteUseContext *s = ctx->priv;
 
+    ret = ff_framesync_init_dualinput(&s->fs, ctx);
+    if (ret < 0)
+        return ret;
+    s->fs.opt_repeatlast = 1; // only 1 frame in the palette
+    s->fs.in[1].before = s->fs.in[1].after = EXT_INFINITY;
+    s->fs.on_event = load_apply_palette;
+
     outlink->w = ctx->inputs[0]->w;
     outlink->h = ctx->inputs[0]->h;
 
     outlink->time_base = ctx->inputs[0]->time_base;
-    if ((ret = ff_dualinput_init(ctx, &s->dinput)) < 0)
+    if ((ret = ff_framesync_configure(&s->fs)) < 0)
         return ret;
     return 0;
 }
@@ -951,21 +962,32 @@ static void load_palette(PaletteUseContext *s, const AVFrame *palette_frame)
         s->palette_loaded = 1;
 }
 
-static AVFrame *load_apply_palette(AVFilterContext *ctx, AVFrame *main,
-                                   const AVFrame *second)
+static int load_apply_palette(FFFrameSync *fs)
 {
+    AVFilterContext *ctx = fs->parent;
     AVFilterLink *inlink = ctx->inputs[0];
     PaletteUseContext *s = ctx->priv;
+    AVFrame *master, *second, *out;
+    int ret;
+
+    // writable for error diffusal dithering
+    ret = ff_framesync_dualinput_get_writable(fs, &master, &second);
+    if (ret < 0)
+        return ret;
+    if (!master || !second) {
+        ret = AVERROR_BUG;
+        goto error;
+    }
     if (!s->palette_loaded) {
         load_palette(s, second);
     }
-    return apply_palette(inlink, main);
-}
+    out = apply_palette(inlink, master);
+    return ff_filter_frame(ctx->outputs[0], out);
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *in)
-{
-    PaletteUseContext *s = inlink->dst->priv;
-    return ff_dualinput_filter_frame(&s->dinput, inlink, in);
+error:
+    av_frame_free(&master);
+    av_frame_free(&second);
+    return ret;
 }
 
 #define DEFINE_SET_FRAME(color_search, name, value)                             \
@@ -1013,9 +1035,6 @@ static int dither_value(int p)
 static av_cold int init(AVFilterContext *ctx)
 {
     PaletteUseContext *s = ctx->priv;
-    s->dinput.repeatlast = 1; // only 1 frame in the palette
-    s->dinput.skip_initial_unpaired = 1;
-    s->dinput.process    = load_apply_palette;
 
     s->set_frame = set_frame_lut[s->color_search_method][s->dither];
 
@@ -1030,10 +1049,10 @@ static av_cold int init(AVFilterContext *ctx)
     return 0;
 }
 
-static int request_frame(AVFilterLink *outlink)
+static int activate(AVFilterContext *ctx)
 {
-    PaletteUseContext *s = outlink->src->priv;
-    return ff_dualinput_request_frame(&s->dinput, outlink);
+    PaletteUseContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
@@ -1041,7 +1060,7 @@ static av_cold void uninit(AVFilterContext *ctx)
     int i;
     PaletteUseContext *s = ctx->priv;
 
-    ff_dualinput_uninit(&s->dinput);
+    ff_framesync_uninit(&s->fs);
     for (i = 0; i < CACHE_SIZE; i++)
         av_freep(&s->cache[i].entries);
     av_frame_free(&s->last_in);
@@ -1052,13 +1071,10 @@ static const AVFilterPad paletteuse_inputs[] = {
     {
         .name           = "default",
         .type           = AVMEDIA_TYPE_VIDEO,
-        .filter_frame   = filter_frame,
-        .needs_writable = 1, // for error diffusal dithering
     },{
         .name           = "palette",
         .type           = AVMEDIA_TYPE_VIDEO,
         .config_props   = config_input_palette,
-        .filter_frame   = filter_frame,
     },
     { NULL }
 };
@@ -1068,7 +1084,6 @@ static const AVFilterPad paletteuse_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -1080,6 +1095,7 @@ AVFilter ff_vf_paletteuse = {
     .query_formats = query_formats,
     .init          = init,
     .uninit        = uninit,
+    .activate      = activate,
     .inputs        = paletteuse_inputs,
     .outputs       = paletteuse_outputs,
     .priv_class    = &paletteuse_class,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_perspective.c b/mythtv/external/FFmpeg/libavfilter/vf_perspective.c
index 287db688454..92495097cc5 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_perspective.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_perspective.c
@@ -135,8 +135,8 @@ static int calc_persp_luts(AVFilterContext *ctx, AVFilterLink *inlink)
     double (*ref)[2]      = s->ref;
 
     double values[VAR_VARS_NB] = { [VAR_W] = inlink->w, [VAR_H] = inlink->h,
-                                   [VAR_IN] = inlink->frame_count  + 1,
-                                   [VAR_ON] = outlink->frame_count + 1 };
+                                   [VAR_IN] = inlink->frame_count_out + 1,
+                                   [VAR_ON] = outlink->frame_count_in + 1 };
     const int h = values[VAR_H];
     const int w = values[VAR_W];
     double x0, x1, x2, x3, x4, x5, x6, x7, x8, q;
@@ -463,6 +463,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
 
     if (s->eval_mode == EVAL_MODE_FRAME) {
         if ((ret = calc_persp_luts(ctx, inlink)) < 0) {
+            av_frame_free(&out);
             return ret;
         }
     }
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_pp.c b/mythtv/external/FFmpeg/libavfilter/vf_pp.c
index bac1d53356f..524ef1bb0a8 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_pp.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_pp.c
@@ -30,7 +30,7 @@
 
 #include "libpostproc/postprocess.h"
 
-typedef struct {
+typedef struct PPFilterContext {
     const AVClass *class;
     char *subfilters;
     int mode_id;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_premultiply.c b/mythtv/external/FFmpeg/libavfilter/vf_premultiply.c
new file mode 100644
index 00000000000..5120adc4766
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_premultiply.c
@@ -0,0 +1,722 @@
+/*
+ * Copyright (c) 2016 Paul B Mahol
+ *
+ * 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/imgutils.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/opt.h"
+#include "avfilter.h"
+#include "filters.h"
+#include "formats.h"
+#include "framesync.h"
+#include "internal.h"
+#include "video.h"
+
+typedef struct PreMultiplyContext {
+    const AVClass *class;
+    int width[4], height[4];
+    int linesize[4];
+    int nb_planes;
+    int planes;
+    int inverse;
+    int inplace;
+    int half, depth, offset, max;
+    FFFrameSync fs;
+
+    void (*premultiply[4])(const uint8_t *msrc, const uint8_t *asrc,
+                           uint8_t *dst,
+                           ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                           ptrdiff_t dlinesize,
+                           int w, int h,
+                           int half, int shift, int offset);
+} PreMultiplyContext;
+
+#define OFFSET(x) offsetof(PreMultiplyContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption options[] = {
+    { "planes", "set planes", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF, FLAGS },
+    { "inplace","enable inplace mode", OFFSET(inplace), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
+    { NULL }
+};
+
+#define premultiply_options options
+AVFILTER_DEFINE_CLASS(premultiply);
+
+static int query_formats(AVFilterContext *ctx)
+{
+    PreMultiplyContext *s = ctx->priv;
+
+    static const enum AVPixelFormat no_alpha_pix_fmts[] = {
+        AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+        AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
+        AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,
+        AV_PIX_FMT_YUV444P16,
+        AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
+        AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_NONE
+    };
+
+    static const enum AVPixelFormat alpha_pix_fmts[] = {
+        AV_PIX_FMT_YUVA444P,
+        AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA444P16,
+        AV_PIX_FMT_GBRAP,
+        AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_NONE
+    };
+
+    return ff_set_common_formats(ctx, ff_make_format_list(s->inplace ? alpha_pix_fmts : no_alpha_pix_fmts));
+}
+
+static void premultiply8(const uint8_t *msrc, const uint8_t *asrc,
+                         uint8_t *dst,
+                         ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                         ptrdiff_t dlinesize,
+                         int w, int h,
+                         int half, int shift, int offset)
+{
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dst[x] = ((msrc[x] * (((asrc[x] >> 1) & 1) + asrc[x])) + 128) >> 8;
+        }
+
+        dst  += dlinesize;
+        msrc += mlinesize;
+        asrc += alinesize;
+    }
+}
+
+static void premultiply8yuv(const uint8_t *msrc, const uint8_t *asrc,
+                            uint8_t *dst,
+                            ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                            ptrdiff_t dlinesize,
+                            int w, int h,
+                            int half, int shift, int offset)
+{
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dst[x] = ((((msrc[x] - 128) * (((asrc[x] >> 1) & 1) + asrc[x]))) >> 8) + 128;
+        }
+
+        dst  += dlinesize;
+        msrc += mlinesize;
+        asrc += alinesize;
+    }
+}
+
+static void premultiply8offset(const uint8_t *msrc, const uint8_t *asrc,
+                               uint8_t *dst,
+                               ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                               ptrdiff_t dlinesize,
+                               int w, int h,
+                               int half, int shift, int offset)
+{
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dst[x] = ((((msrc[x] - offset) * (((asrc[x] >> 1) & 1) + asrc[x])) + 128) >> 8) + offset;
+        }
+
+        dst  += dlinesize;
+        msrc += mlinesize;
+        asrc += alinesize;
+    }
+}
+
+static void premultiply16(const uint8_t *mmsrc, const uint8_t *aasrc,
+                          uint8_t *ddst,
+                          ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                          ptrdiff_t dlinesize,
+                          int w, int h,
+                          int half, int shift, int offset)
+{
+    const uint16_t *msrc = (const uint16_t *)mmsrc;
+    const uint16_t *asrc = (const uint16_t *)aasrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dst[x] = ((msrc[x] * (((asrc[x] >> 1) & 1) + asrc[x])) + half) >> shift;
+        }
+
+        dst  += dlinesize / 2;
+        msrc += mlinesize / 2;
+        asrc += alinesize / 2;
+    }
+}
+
+static void premultiply16yuv(const uint8_t *mmsrc, const uint8_t *aasrc,
+                             uint8_t *ddst,
+                             ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                             ptrdiff_t dlinesize,
+                             int w, int h,
+                             int half, int shift, int offset)
+{
+    const uint16_t *msrc = (const uint16_t *)mmsrc;
+    const uint16_t *asrc = (const uint16_t *)aasrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dst[x] = ((((msrc[x] - half) * (((asrc[x] >> 1) & 1) + asrc[x]))) >> shift) + half;
+        }
+
+        dst  += dlinesize / 2;
+        msrc += mlinesize / 2;
+        asrc += alinesize / 2;
+    }
+}
+
+static void premultiply16offset(const uint8_t *mmsrc, const uint8_t *aasrc,
+                                uint8_t *ddst,
+                                ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                                ptrdiff_t dlinesize,
+                                int w, int h,
+                                int half, int shift, int offset)
+{
+    const uint16_t *msrc = (const uint16_t *)mmsrc;
+    const uint16_t *asrc = (const uint16_t *)aasrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            dst[x] = ((((msrc[x] - offset) * (((asrc[x] >> 1) & 1) + asrc[x])) + half) >> shift) + offset;
+        }
+
+        dst  += dlinesize / 2;
+        msrc += mlinesize / 2;
+        asrc += alinesize / 2;
+    }
+}
+
+static void unpremultiply8(const uint8_t *msrc, const uint8_t *asrc,
+                           uint8_t *dst,
+                           ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                           ptrdiff_t dlinesize,
+                           int w, int h,
+                           int half, int max, int offset)
+{
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            if (asrc[x] > 0 && asrc[x] < 255)
+                dst[x] = FFMIN(msrc[x] * 255 / asrc[x], 255);
+            else
+                dst[x] = msrc[x];
+        }
+
+        dst  += dlinesize;
+        msrc += mlinesize;
+        asrc += alinesize;
+    }
+}
+
+static void unpremultiply8yuv(const uint8_t *msrc, const uint8_t *asrc,
+                              uint8_t *dst,
+                              ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                              ptrdiff_t dlinesize,
+                              int w, int h,
+                              int half, int max, int offset)
+{
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            if (asrc[x] > 0 && asrc[x] < 255)
+                dst[x] = FFMIN((msrc[x] - 128) * 255 / asrc[x] + 128, 255);
+            else
+                dst[x] = msrc[x];
+        }
+
+        dst  += dlinesize;
+        msrc += mlinesize;
+        asrc += alinesize;
+    }
+}
+
+static void unpremultiply8offset(const uint8_t *msrc, const uint8_t *asrc,
+                                 uint8_t *dst,
+                                 ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                                 ptrdiff_t dlinesize,
+                                 int w, int h,
+                                 int half, int max, int offset)
+{
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            if (asrc[x] > 0 && asrc[x] < 255)
+                dst[x] = FFMIN((msrc[x] - offset) * 255 / asrc[x] + offset, 255);
+            else
+                dst[x] = msrc[x];
+        }
+
+        dst  += dlinesize;
+        msrc += mlinesize;
+        asrc += alinesize;
+    }
+}
+
+static void unpremultiply16(const uint8_t *mmsrc, const uint8_t *aasrc,
+                            uint8_t *ddst,
+                            ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                            ptrdiff_t dlinesize,
+                            int w, int h,
+                            int half, int max, int offset)
+{
+    const uint16_t *msrc = (const uint16_t *)mmsrc;
+    const uint16_t *asrc = (const uint16_t *)aasrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            if (asrc[x] > 0 && asrc[x] < max)
+                dst[x] = FFMIN(msrc[x] * (unsigned)max / asrc[x], max);
+            else
+                dst[x] = msrc[x];
+        }
+
+        dst  += dlinesize / 2;
+        msrc += mlinesize / 2;
+        asrc += alinesize / 2;
+    }
+}
+
+static void unpremultiply16yuv(const uint8_t *mmsrc, const uint8_t *aasrc,
+                               uint8_t *ddst,
+                               ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                               ptrdiff_t dlinesize,
+                               int w, int h,
+                               int half, int max, int offset)
+{
+    const uint16_t *msrc = (const uint16_t *)mmsrc;
+    const uint16_t *asrc = (const uint16_t *)aasrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            if (asrc[x] > 0 && asrc[x] < max)
+                dst[x] = FFMAX(FFMIN((msrc[x] - half) * max / asrc[x], half - 1), -half) + half;
+            else
+                dst[x] = msrc[x];
+        }
+
+        dst  += dlinesize / 2;
+        msrc += mlinesize / 2;
+        asrc += alinesize / 2;
+    }
+}
+
+static void unpremultiply16offset(const uint8_t *mmsrc, const uint8_t *aasrc,
+                                  uint8_t *ddst,
+                                  ptrdiff_t mlinesize, ptrdiff_t alinesize,
+                                  ptrdiff_t dlinesize,
+                                  int w, int h,
+                                  int half, int max, int offset)
+{
+    const uint16_t *msrc = (const uint16_t *)mmsrc;
+    const uint16_t *asrc = (const uint16_t *)aasrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            if (asrc[x] > 0 && asrc[x] < max)
+                dst[x] = FFMAX(FFMIN((msrc[x] - offset) * (unsigned)max / asrc[x] + offset, max), 0);
+            else
+                dst[x] = msrc[x];
+        }
+
+        dst  += dlinesize / 2;
+        msrc += mlinesize / 2;
+        asrc += alinesize / 2;
+    }
+}
+
+static int filter_frame(AVFilterContext *ctx,
+                        AVFrame **out, AVFrame *base, AVFrame *alpha)
+{
+    PreMultiplyContext *s = ctx->priv;
+    AVFilterLink *outlink = ctx->outputs[0];
+
+    if (ctx->is_disabled) {
+        *out = av_frame_clone(base);
+        if (!*out)
+            return AVERROR(ENOMEM);
+    } else {
+        int p, full, limited;
+
+        *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+        if (!*out)
+            return AVERROR(ENOMEM);
+        av_frame_copy_props(*out, base);
+
+        full = base->color_range == AVCOL_RANGE_JPEG;
+        limited = base->color_range == AVCOL_RANGE_MPEG;
+
+        if (s->inverse) {
+            switch (outlink->format) {
+            case AV_PIX_FMT_YUV444P:
+            case AV_PIX_FMT_YUVA444P:
+                s->premultiply[0] = full ? unpremultiply8 : unpremultiply8offset;
+                s->premultiply[1] = s->premultiply[2] = unpremultiply8yuv;
+                break;
+            case AV_PIX_FMT_YUVJ444P:
+                s->premultiply[0] = unpremultiply8;
+                s->premultiply[1] = s->premultiply[2] = unpremultiply8yuv;
+                break;
+            case AV_PIX_FMT_GBRP:
+            case AV_PIX_FMT_GBRAP:
+                s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? unpremultiply8offset : unpremultiply8;
+                break;
+            case AV_PIX_FMT_YUV444P9:
+            case AV_PIX_FMT_YUVA444P9:
+            case AV_PIX_FMT_YUV444P10:
+            case AV_PIX_FMT_YUVA444P10:
+            case AV_PIX_FMT_YUV444P12:
+            case AV_PIX_FMT_YUV444P14:
+            case AV_PIX_FMT_YUV444P16:
+            case AV_PIX_FMT_YUVA444P16:
+                s->premultiply[0] = full ? unpremultiply16 : unpremultiply16offset;
+                s->premultiply[1] = s->premultiply[2] = unpremultiply16yuv;
+                break;
+            case AV_PIX_FMT_GBRP9:
+            case AV_PIX_FMT_GBRP10:
+            case AV_PIX_FMT_GBRAP10:
+            case AV_PIX_FMT_GBRP12:
+            case AV_PIX_FMT_GBRAP12:
+            case AV_PIX_FMT_GBRP14:
+            case AV_PIX_FMT_GBRP16:
+            case AV_PIX_FMT_GBRAP16:
+                s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? unpremultiply16offset : unpremultiply16;
+                break;
+            case AV_PIX_FMT_GRAY8:
+                s->premultiply[0] = limited ? unpremultiply8offset : unpremultiply8;
+                break;
+            case AV_PIX_FMT_GRAY9:
+            case AV_PIX_FMT_GRAY10:
+            case AV_PIX_FMT_GRAY12:
+            case AV_PIX_FMT_GRAY16:
+                s->premultiply[0] = limited ? unpremultiply16offset : unpremultiply16;
+                break;
+            }
+        } else {
+            switch (outlink->format) {
+            case AV_PIX_FMT_YUV444P:
+            case AV_PIX_FMT_YUVA444P:
+                s->premultiply[0] = full ? premultiply8 : premultiply8offset;
+                s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
+                break;
+            case AV_PIX_FMT_YUVJ444P:
+                s->premultiply[0] = premultiply8;
+                s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
+                break;
+            case AV_PIX_FMT_GBRP:
+            case AV_PIX_FMT_GBRAP:
+                s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiply8offset : premultiply8;
+                break;
+            case AV_PIX_FMT_YUV444P9:
+            case AV_PIX_FMT_YUVA444P9:
+            case AV_PIX_FMT_YUV444P10:
+            case AV_PIX_FMT_YUVA444P10:
+            case AV_PIX_FMT_YUV444P12:
+            case AV_PIX_FMT_YUV444P14:
+            case AV_PIX_FMT_YUV444P16:
+            case AV_PIX_FMT_YUVA444P16:
+                s->premultiply[0] = full ? premultiply16 : premultiply16offset;
+                s->premultiply[1] = s->premultiply[2] = premultiply16yuv;
+                break;
+            case AV_PIX_FMT_GBRP9:
+            case AV_PIX_FMT_GBRP10:
+            case AV_PIX_FMT_GBRAP10:
+            case AV_PIX_FMT_GBRP12:
+            case AV_PIX_FMT_GBRAP12:
+            case AV_PIX_FMT_GBRP14:
+            case AV_PIX_FMT_GBRP16:
+            case AV_PIX_FMT_GBRAP16:
+                s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiply16offset : premultiply16;
+                break;
+            case AV_PIX_FMT_GRAY8:
+                s->premultiply[0] = limited ? premultiply8offset : premultiply8;
+                break;
+            case AV_PIX_FMT_GRAY9:
+            case AV_PIX_FMT_GRAY10:
+            case AV_PIX_FMT_GRAY12:
+            case AV_PIX_FMT_GRAY16:
+                s->premultiply[0] = limited ? premultiply16offset : premultiply16;
+                break;
+            }
+        }
+
+        for (p = 0; p < s->nb_planes; p++) {
+            if (!((1 << p) & s->planes) || p == 3) {
+                av_image_copy_plane((*out)->data[p], (*out)->linesize[p], base->data[p], base->linesize[p],
+                                    s->linesize[p], s->height[p]);
+                continue;
+            }
+
+            s->premultiply[p](base->data[p], s->inplace ? alpha->data[3] : alpha->data[0],
+                              (*out)->data[p],
+                              base->linesize[p], s->inplace ? alpha->linesize[3] : alpha->linesize[0],
+                              (*out)->linesize[p],
+                              s->width[p], s->height[p],
+                              s->half, s->inverse ? s->max : s->depth, s->offset);
+        }
+    }
+
+    return 0;
+}
+
+static int process_frame(FFFrameSync *fs)
+{
+    AVFilterContext *ctx = fs->parent;
+    PreMultiplyContext *s = fs->opaque;
+    AVFilterLink *outlink = ctx->outputs[0];
+    AVFrame *out = NULL, *base, *alpha;
+    int ret;
+
+    if ((ret = ff_framesync_get_frame(&s->fs, 0, &base,  0)) < 0 ||
+        (ret = ff_framesync_get_frame(&s->fs, 1, &alpha, 0)) < 0)
+        return ret;
+
+    if ((ret = filter_frame(ctx, &out, base, alpha)) < 0)
+        return ret;
+
+    out->pts = av_rescale_q(base->pts, s->fs.time_base, outlink->time_base);
+
+    return ff_filter_frame(outlink, out);
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    PreMultiplyContext *s = ctx->priv;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    int vsub, hsub, ret;
+
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
+    if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
+        return ret;
+
+    hsub = desc->log2_chroma_w;
+    vsub = desc->log2_chroma_h;
+    s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
+    s->height[0] = s->height[3] = inlink->h;
+    s->width[1]  = s->width[2]  = AV_CEIL_RSHIFT(inlink->w, hsub);
+    s->width[0]  = s->width[3]  = inlink->w;
+
+    s->depth = desc->comp[0].depth;
+    s->max = (1 << s->depth) - 1;
+    s->half = (1 << s->depth) / 2;
+    s->offset = 16 << (s->depth - 8);
+
+    return 0;
+}
+
+static int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    PreMultiplyContext *s = ctx->priv;
+    AVFilterLink *base = ctx->inputs[0];
+    AVFilterLink *alpha;
+    FFFrameSyncIn *in;
+    int ret;
+
+    if (!s->inplace) {
+        alpha = ctx->inputs[1];
+
+        if (base->format != alpha->format) {
+            av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
+            return AVERROR(EINVAL);
+        }
+        if (base->w                       != alpha->w ||
+            base->h                       != alpha->h) {
+            av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
+                   "(size %dx%d) do not match the corresponding "
+                   "second input link %s parameters (%dx%d) ",
+                   ctx->input_pads[0].name, base->w, base->h,
+                   ctx->input_pads[1].name, alpha->w, alpha->h);
+            return AVERROR(EINVAL);
+        }
+    }
+
+    outlink->w = base->w;
+    outlink->h = base->h;
+    outlink->time_base = base->time_base;
+    outlink->sample_aspect_ratio = base->sample_aspect_ratio;
+    outlink->frame_rate = base->frame_rate;
+
+    if (s->inplace)
+        return 0;
+
+    if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)
+        return ret;
+
+    in = s->fs.in;
+    in[0].time_base = base->time_base;
+    in[1].time_base = alpha->time_base;
+    in[0].sync   = 1;
+    in[0].before = EXT_STOP;
+    in[0].after  = EXT_INFINITY;
+    in[1].sync   = 1;
+    in[1].before = EXT_STOP;
+    in[1].after  = EXT_INFINITY;
+    s->fs.opaque   = s;
+    s->fs.on_event = process_frame;
+
+    return ff_framesync_configure(&s->fs);
+}
+
+static int activate(AVFilterContext *ctx)
+{
+    PreMultiplyContext *s = ctx->priv;
+
+    if (s->inplace) {
+        AVFrame *frame = NULL;
+        AVFrame *out = NULL;
+        int ret, status;
+        int64_t pts;
+
+        if ((ret = ff_inlink_consume_frame(ctx->inputs[0], &frame)) > 0) {
+            if ((ret = filter_frame(ctx, &out, frame, frame)) < 0)
+                return ret;
+            av_frame_free(&frame);
+            ret = ff_filter_frame(ctx->outputs[0], out);
+        }
+        if (ret < 0) {
+            return ret;
+        } else if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
+            ff_outlink_set_status(ctx->outputs[0], status, pts);
+            return 0;
+        } else {
+            if (ff_outlink_frame_wanted(ctx->outputs[0]))
+                ff_inlink_request_frame(ctx->inputs[0]);
+            return 0;
+        }
+    } else {
+        return ff_framesync_activate(&s->fs);
+    }
+}
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    PreMultiplyContext *s = ctx->priv;
+    AVFilterPad pad = { 0 };
+    int ret;
+
+    if (!strcmp(ctx->filter->name, "unpremultiply"))
+        s->inverse = 1;
+
+    pad.type         = AVMEDIA_TYPE_VIDEO;
+    pad.name         = av_strdup("main");
+    pad.config_props = config_input;
+    if (!pad.name)
+        return AVERROR(ENOMEM);
+
+    if ((ret = ff_insert_inpad(ctx, 0, &pad)) < 0) {
+        av_freep(&pad.name);
+        return ret;
+    }
+
+    if (!s->inplace) {
+        pad.type         = AVMEDIA_TYPE_VIDEO;
+        pad.name         = av_strdup("alpha");
+        pad.config_props = NULL;
+        if (!pad.name)
+            return AVERROR(ENOMEM);
+
+        if ((ret = ff_insert_inpad(ctx, 1, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
+    }
+
+    return 0;
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    PreMultiplyContext *s = ctx->priv;
+
+    if (!s->inplace)
+        ff_framesync_uninit(&s->fs);
+}
+
+static const AVFilterPad premultiply_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .config_props  = config_output,
+    },
+    { NULL }
+};
+
+#if CONFIG_PREMULTIPLY_FILTER
+
+AVFilter ff_vf_premultiply = {
+    .name          = "premultiply",
+    .description   = NULL_IF_CONFIG_SMALL("PreMultiply first stream with first plane of second stream."),
+    .priv_size     = sizeof(PreMultiplyContext),
+    .init          = init,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .activate      = activate,
+    .inputs        = NULL,
+    .outputs       = premultiply_outputs,
+    .priv_class    = &premultiply_class,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
+                     AVFILTER_FLAG_DYNAMIC_INPUTS,
+};
+
+#endif /* CONFIG_PREMULTIPLY_FILTER */
+
+#if CONFIG_UNPREMULTIPLY_FILTER
+
+#define unpremultiply_options options
+AVFILTER_DEFINE_CLASS(unpremultiply);
+
+AVFilter ff_vf_unpremultiply = {
+    .name          = "unpremultiply",
+    .description   = NULL_IF_CONFIG_SMALL("UnPreMultiply first stream with first plane of second stream."),
+    .priv_size     = sizeof(PreMultiplyContext),
+    .init          = init,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .activate      = activate,
+    .inputs        = NULL,
+    .outputs       = premultiply_outputs,
+    .priv_class    = &unpremultiply_class,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
+                     AVFILTER_FLAG_DYNAMIC_INPUTS,
+};
+
+#endif /* CONFIG_UNPREMULTIPLY_FILTER */
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_pseudocolor.c b/mythtv/external/FFmpeg/libavfilter/vf_pseudocolor.c
new file mode 100644
index 00000000000..f8f53727529
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_pseudocolor.c
@@ -0,0 +1,662 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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 "libavutil/common.h"
+#include "libavutil/eval.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+static const char *const var_names[] = {
+    "w",        ///< width of the input video
+    "h",        ///< height of the input video
+    "val",      ///< input value for the pixel
+    "ymin",
+    "umin",
+    "vmin",
+    "amin",
+    "ymax",
+    "umax",
+    "vmax",
+    "amax",
+    NULL
+};
+
+enum var_name {
+    VAR_W,
+    VAR_H,
+    VAR_VAL,
+    VAR_YMIN,
+    VAR_UMIN,
+    VAR_VMIN,
+    VAR_AMIN,
+    VAR_YMAX,
+    VAR_UMAX,
+    VAR_VMAX,
+    VAR_AMAX,
+    VAR_VARS_NB
+};
+
+typedef struct PseudoColorContext {
+    const AVClass *class;
+    int max;
+    int index;
+    int nb_planes;
+    int color;
+    int linesize[4];
+    int width[4], height[4];
+    double var_values[VAR_VARS_NB];
+    char   *comp_expr_str[4];
+    AVExpr *comp_expr[4];
+    float lut[4][256*256];
+
+    void (*filter[4])(int max, int width, int height,
+                      const uint8_t *index, const uint8_t *src,
+                      uint8_t *dst,
+                      ptrdiff_t ilinesize,
+                      ptrdiff_t slinesize,
+                      ptrdiff_t dlinesize,
+                      float *lut);
+} PseudoColorContext;
+
+#define OFFSET(x) offsetof(PseudoColorContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption pseudocolor_options[] = {
+    { "c0", "set component #0 expression", OFFSET(comp_expr_str[0]), AV_OPT_TYPE_STRING, {.str="val"},   .flags = FLAGS },
+    { "c1", "set component #1 expression", OFFSET(comp_expr_str[1]), AV_OPT_TYPE_STRING, {.str="val"},   .flags = FLAGS },
+    { "c2", "set component #2 expression", OFFSET(comp_expr_str[2]), AV_OPT_TYPE_STRING, {.str="val"},   .flags = FLAGS },
+    { "c3", "set component #3 expression", OFFSET(comp_expr_str[3]), AV_OPT_TYPE_STRING, {.str="val"},   .flags = FLAGS },
+    { "i",  "set component as base",       OFFSET(index),            AV_OPT_TYPE_INT,    {.i64=0}, 0, 3, .flags = FLAGS },
+    { NULL }
+};
+
+static const enum AVPixelFormat pix_fmts[] = {
+    AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY16,
+    AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P,
+    AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P,
+    AV_PIX_FMT_YUV444P, AV_PIX_FMT_GBRP,
+    AV_PIX_FMT_YUVA444P, AV_PIX_FMT_GBRAP,
+    AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUVA422P9,
+    AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUVA420P9,
+    AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUVA444P9,
+    AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUVA420P10,
+    AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUVA422P10,
+    AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUVA444P10,
+    AV_PIX_FMT_YUV420P12,
+    AV_PIX_FMT_YUV422P12,
+    AV_PIX_FMT_YUV444P12,
+    AV_PIX_FMT_YUV420P14,
+    AV_PIX_FMT_YUV422P14,
+    AV_PIX_FMT_YUV444P14,
+    AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUVA420P16,
+    AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUVA422P16,
+    AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUVA444P16,
+    AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
+    AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16,
+    AV_PIX_FMT_NONE
+};
+
+static int query_formats(AVFilterContext *ctx)
+{
+    AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
+    if (!fmts_list)
+        return AVERROR(ENOMEM);
+    return ff_set_common_formats(ctx, fmts_list);
+}
+
+static void pseudocolor_filter(int max, int width, int height,
+                               const uint8_t *index,
+                               const uint8_t *src,
+                               uint8_t *dst,
+                               ptrdiff_t ilinesize,
+                               ptrdiff_t slinesize,
+                               ptrdiff_t dlinesize,
+                               float *lut)
+{
+    int x, y;
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            int v = lut[index[x]];
+
+            if (v >= 0 && v <= max) {
+                dst[x] = v;
+            } else {
+                dst[x] = src[x];
+            }
+        }
+        index += ilinesize;
+        src += slinesize;
+        dst += dlinesize;
+    }
+}
+
+static void pseudocolor_filter_11(int max, int width, int height,
+                                  const uint8_t *index,
+                                  const uint8_t *src,
+                                  uint8_t *dst,
+                                  ptrdiff_t ilinesize,
+                                  ptrdiff_t slinesize,
+                                  ptrdiff_t dlinesize,
+                                  float *lut)
+{
+    int x, y;
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            int v = lut[index[(y << 1) * ilinesize + (x << 1)]];
+
+            if (v >= 0 && v <= max) {
+                dst[x] = v;
+            } else {
+                dst[x] = src[x];
+            }
+        }
+        src += slinesize;
+        dst += dlinesize;
+    }
+}
+
+static void pseudocolor_filter_11d(int max, int width, int height,
+                                   const uint8_t *index,
+                                   const uint8_t *src,
+                                   uint8_t *dst,
+                                   ptrdiff_t ilinesize,
+                                   ptrdiff_t slinesize,
+                                   ptrdiff_t dlinesize,
+                                   float *lut)
+{
+    int x, y;
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            int v = lut[index[(y >> 1) * ilinesize + (x >> 1)]];
+
+            if (v >= 0 && v <= max) {
+                dst[x] = v;
+            } else {
+                dst[x] = src[x];
+            }
+        }
+        src += slinesize;
+        dst += dlinesize;
+    }
+}
+
+static void pseudocolor_filter_10(int max, int width, int height,
+                                  const uint8_t *index,
+                                  const uint8_t *src,
+                                  uint8_t *dst,
+                                  ptrdiff_t ilinesize,
+                                  ptrdiff_t slinesize,
+                                  ptrdiff_t dlinesize,
+                                  float *lut)
+{
+    int x, y;
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            int v = lut[index[x << 1]];
+
+            if (v >= 0 && v <= max) {
+                dst[x] = v;
+            } else {
+                dst[x] = src[x];
+            }
+        }
+        index += ilinesize;
+        src += slinesize;
+        dst += dlinesize;
+    }
+}
+
+static void pseudocolor_filter_10d(int max, int width, int height,
+                                   const uint8_t *index,
+                                   const uint8_t *src,
+                                   uint8_t *dst,
+                                   ptrdiff_t ilinesize,
+                                   ptrdiff_t slinesize,
+                                   ptrdiff_t dlinesize,
+                                   float *lut)
+{
+    int x, y;
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            int v = lut[index[x >> 1]];
+
+            if (v >= 0 && v <= max) {
+                dst[x] = v;
+            } else {
+                dst[x] = src[x];
+            }
+        }
+        index += ilinesize;
+        src += slinesize;
+        dst += dlinesize;
+    }
+}
+
+static void pseudocolor_filter_16(int max, int width, int height,
+                                  const uint8_t *iindex,
+                                  const uint8_t *ssrc,
+                                  uint8_t *ddst,
+                                  ptrdiff_t ilinesize,
+                                  ptrdiff_t slinesize,
+                                  ptrdiff_t dlinesize,
+                                  float *lut)
+{
+    const uint16_t *index = (const uint16_t *)iindex;
+    const uint16_t *src = (const uint16_t *)ssrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            int v = lut[index[x]];
+
+            if (v >= 0 && v <= max) {
+                dst[x] = v;
+            } else {
+                dst[x] = src[x];
+            }
+        }
+        index += ilinesize / 2;
+        src += slinesize / 2;
+        dst += dlinesize / 2;
+    }
+}
+
+static void pseudocolor_filter_16_10(int max, int width, int height,
+                                     const uint8_t *iindex,
+                                     const uint8_t *ssrc,
+                                     uint8_t *ddst,
+                                     ptrdiff_t ilinesize,
+                                     ptrdiff_t slinesize,
+                                     ptrdiff_t dlinesize,
+                                     float *lut)
+{
+    const uint16_t *index = (const uint16_t *)iindex;
+    const uint16_t *src = (const uint16_t *)ssrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            int v = lut[index[x << 1]];
+
+            if (v >= 0 && v <= max) {
+                dst[x] = v;
+            } else {
+                dst[x] = src[x];
+            }
+        }
+        index += ilinesize / 2;
+        src += slinesize / 2;
+        dst += dlinesize / 2;
+    }
+}
+
+static void pseudocolor_filter_16_10d(int max, int width, int height,
+                                      const uint8_t *iindex,
+                                      const uint8_t *ssrc,
+                                      uint8_t *ddst,
+                                      ptrdiff_t ilinesize,
+                                      ptrdiff_t slinesize,
+                                      ptrdiff_t dlinesize,
+                                      float *lut)
+{
+    const uint16_t *index = (const uint16_t *)iindex;
+    const uint16_t *src = (const uint16_t *)ssrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            int v = lut[index[x >> 1]];
+
+            if (v >= 0 && v <= max) {
+                dst[x] = v;
+            } else {
+                dst[x] = src[x];
+            }
+        }
+        index += ilinesize / 2;
+        src += slinesize / 2;
+        dst += dlinesize / 2;
+    }
+}
+
+static void pseudocolor_filter_16_11(int max, int width, int height,
+                                     const uint8_t *iindex,
+                                     const uint8_t *ssrc,
+                                     uint8_t *ddst,
+                                     ptrdiff_t ilinesize,
+                                     ptrdiff_t slinesize,
+                                     ptrdiff_t dlinesize,
+                                     float *lut)
+{
+    const uint16_t *index = (const uint16_t *)iindex;
+    const uint16_t *src = (const uint16_t *)ssrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    ilinesize /= 2;
+    dlinesize /= 2;
+    slinesize /= 2;
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            int v = lut[index[(y << 1) * ilinesize + (x << 1)]];
+
+            if (v >= 0 && v <= max) {
+                dst[x] = v;
+            } else {
+                dst[x] = src[x];
+            }
+        }
+        src += slinesize;
+        dst += dlinesize;
+    }
+}
+
+static void pseudocolor_filter_16_11d(int max, int width, int height,
+                                      const uint8_t *iindex,
+                                      const uint8_t *ssrc,
+                                      uint8_t *ddst,
+                                      ptrdiff_t ilinesize,
+                                      ptrdiff_t slinesize,
+                                      ptrdiff_t dlinesize,
+                                      float *lut)
+{
+    const uint16_t *index = (const uint16_t *)iindex;
+    const uint16_t *src = (const uint16_t *)ssrc;
+    uint16_t *dst = (uint16_t *)ddst;
+    int x, y;
+
+    ilinesize /= 2;
+    dlinesize /= 2;
+    slinesize /= 2;
+
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            int v = lut[index[(y >> 1) * ilinesize + (x >> 1)]];
+
+            if (v >= 0 && v <= max) {
+                dst[x] = v;
+            } else {
+                dst[x] = src[x];
+            }
+        }
+        src += slinesize;
+        dst += dlinesize;
+    }
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    PseudoColorContext *s = ctx->priv;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    int depth, ret, hsub, vsub, color;
+
+    depth = desc->comp[0].depth;
+    s->max = (1 << depth) - 1;
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
+    if (s->index >= s->nb_planes) {
+        av_log(ctx, AV_LOG_ERROR, "index out of allowed range\n");
+        return AVERROR(EINVAL);
+    }
+
+    if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
+        return ret;
+
+    hsub = desc->log2_chroma_w;
+    vsub = desc->log2_chroma_h;
+    s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
+    s->height[0] = s->height[3] = inlink->h;
+    s->width[1]  = s->width[2]  = AV_CEIL_RSHIFT(inlink->w, hsub);
+    s->width[0]  = s->width[3]  = inlink->w;
+
+    s->var_values[VAR_W] = inlink->w;
+    s->var_values[VAR_H] = inlink->h;
+
+    s->var_values[VAR_YMIN] = 16 * (1 << (depth - 8));
+    s->var_values[VAR_UMIN] = 16 * (1 << (depth - 8));
+    s->var_values[VAR_VMIN] = 16 * (1 << (depth - 8));
+    s->var_values[VAR_AMIN] = 0;
+    s->var_values[VAR_YMAX] = 235 * (1 << (depth - 8));
+    s->var_values[VAR_UMAX] = 240 * (1 << (depth - 8));
+    s->var_values[VAR_VMAX] = 240 * (1 << (depth - 8));
+    s->var_values[VAR_AMAX] = s->max;
+
+    for (color = 0; color < s->nb_planes; color++) {
+        double res;
+        int val;
+
+        /* create the parsed expression */
+        av_expr_free(s->comp_expr[color]);
+        s->comp_expr[color] = NULL;
+        ret = av_expr_parse(&s->comp_expr[color], s->comp_expr_str[color],
+                            var_names, NULL, NULL, NULL, NULL, 0, ctx);
+        if (ret < 0) {
+            av_log(ctx, AV_LOG_ERROR,
+                   "Error when parsing the expression '%s' for the component %d and color %d.\n",
+                   s->comp_expr_str[color], color, color);
+            return AVERROR(EINVAL);
+        }
+
+        /* compute the lut */
+        for (val = 0; val < FF_ARRAY_ELEMS(s->lut[color]); val++) {
+            s->var_values[VAR_VAL] = val;
+
+            res = av_expr_eval(s->comp_expr[color], s->var_values, s);
+            if (isnan(res)) {
+                av_log(ctx, AV_LOG_ERROR,
+                       "Error when evaluating the expression '%s' for the value %d for the component %d.\n",
+                       s->comp_expr_str[color], val, color);
+                return AVERROR(EINVAL);
+            }
+            s->lut[color][val] = res;
+        }
+    }
+
+    switch (inlink->format) {
+    case AV_PIX_FMT_YUV444P:
+    case AV_PIX_FMT_YUVA444P:
+    case AV_PIX_FMT_GBRP:
+    case AV_PIX_FMT_GBRAP:
+    case AV_PIX_FMT_GRAY8:
+        s->filter[0] = s->filter[1] = s->filter[2] = s->filter[3] = pseudocolor_filter;
+        break;
+    case AV_PIX_FMT_YUV420P:
+    case AV_PIX_FMT_YUVA420P:
+        switch (s->index) {
+        case 0:
+        case 3:
+            s->filter[0] = s->filter[3] = pseudocolor_filter;
+            s->filter[1] = s->filter[2] = pseudocolor_filter_11;
+            break;
+        case 1:
+        case 2:
+            s->filter[0] = s->filter[3] = pseudocolor_filter_11d;
+            s->filter[1] = s->filter[2] = pseudocolor_filter;
+            break;
+        }
+        break;
+    case AV_PIX_FMT_YUV422P:
+    case AV_PIX_FMT_YUVA422P:
+        switch (s->index) {
+        case 0:
+        case 3:
+            s->filter[0] = s->filter[3] = pseudocolor_filter;
+            s->filter[1] = s->filter[2] = pseudocolor_filter_10;
+            break;
+        case 1:
+        case 2:
+            s->filter[0] = s->filter[3] = pseudocolor_filter_10d;
+            s->filter[1] = s->filter[2] = pseudocolor_filter;
+            break;
+        }
+        break;
+    case AV_PIX_FMT_YUV444P9:
+    case AV_PIX_FMT_YUVA444P9:
+    case AV_PIX_FMT_YUV444P10:
+    case AV_PIX_FMT_YUVA444P10:
+    case AV_PIX_FMT_YUV444P12:
+    case AV_PIX_FMT_YUV444P14:
+    case AV_PIX_FMT_YUV444P16:
+    case AV_PIX_FMT_YUVA444P16:
+    case AV_PIX_FMT_GBRP10:
+    case AV_PIX_FMT_GBRAP10:
+    case AV_PIX_FMT_GBRP16:
+    case AV_PIX_FMT_GBRAP16:
+    case AV_PIX_FMT_GRAY10:
+    case AV_PIX_FMT_GRAY16:
+        s->filter[0] = s->filter[1] = s->filter[2] = s->filter[3] = pseudocolor_filter_16;
+        break;
+    case AV_PIX_FMT_YUV422P9:
+    case AV_PIX_FMT_YUVA422P9:
+    case AV_PIX_FMT_YUV422P10:
+    case AV_PIX_FMT_YUVA422P10:
+    case AV_PIX_FMT_YUV422P12:
+    case AV_PIX_FMT_YUV422P14:
+    case AV_PIX_FMT_YUV422P16:
+    case AV_PIX_FMT_YUVA422P16:
+        switch (s->index) {
+        case 0:
+        case 3:
+            s->filter[0] = s->filter[3] = pseudocolor_filter_16;
+            s->filter[1] = s->filter[2] = pseudocolor_filter_16_10;
+            break;
+        case 1:
+        case 2:
+            s->filter[0] = s->filter[3] = pseudocolor_filter_16_10d;
+            s->filter[1] = s->filter[2] = pseudocolor_filter_16;
+            break;
+        }
+        break;
+    case AV_PIX_FMT_YUV420P9:
+    case AV_PIX_FMT_YUVA420P9:
+    case AV_PIX_FMT_YUV420P10:
+    case AV_PIX_FMT_YUVA420P10:
+    case AV_PIX_FMT_YUV420P12:
+    case AV_PIX_FMT_YUV420P14:
+    case AV_PIX_FMT_YUV420P16:
+    case AV_PIX_FMT_YUVA420P16:
+        switch (s->index) {
+        case 0:
+        case 3:
+            s->filter[0] = s->filter[3] = pseudocolor_filter_16;
+            s->filter[1] = s->filter[2] = pseudocolor_filter_16_11;
+            break;
+        case 1:
+        case 2:
+            s->filter[0] = s->filter[3] = pseudocolor_filter_16_11d;
+            s->filter[1] = s->filter[2] = pseudocolor_filter_16;
+            break;
+        }
+        break;
+    }
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx = inlink->dst;
+    PseudoColorContext *s = ctx->priv;
+    AVFilterLink *outlink = ctx->outputs[0];
+    AVFrame *out;
+    int plane;
+
+    out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+    if (!out) {
+        av_frame_free(&in);
+        return AVERROR(ENOMEM);
+    }
+    av_frame_copy_props(out, in);
+
+    for (plane = 0; plane < s->nb_planes; plane++) {
+        const uint8_t *index = in->data[s->index];
+        const uint8_t *src = in->data[plane];
+        uint8_t *dst = out->data[plane];
+        ptrdiff_t ilinesize = in->linesize[s->index];
+        ptrdiff_t slinesize = in->linesize[plane];
+        ptrdiff_t dlinesize = out->linesize[plane];
+
+        s->filter[plane](s->max, s->width[plane], s->height[plane],
+                         index, src, dst, ilinesize, slinesize,
+                         dlinesize, s->lut[plane]);
+    }
+
+    av_frame_free(&in);
+    return ff_filter_frame(outlink, out);
+}
+
+static const AVFilterPad inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = filter_frame,
+        .config_props = config_input,
+    },
+    { NULL }
+};
+
+static const AVFilterPad outputs[] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_VIDEO,
+    },
+    { NULL }
+};
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    PseudoColorContext *s = ctx->priv;
+    int i;
+
+    for (i = 0; i < 4; i++) {
+        av_expr_free(s->comp_expr[i]);
+        s->comp_expr[i] = NULL;
+    }
+}
+
+AVFILTER_DEFINE_CLASS(pseudocolor);
+
+AVFilter ff_vf_pseudocolor = {
+    .name          = "pseudocolor",
+    .description   = NULL_IF_CONFIG_SMALL("Make pseudocolored video frames."),
+    .priv_size     = sizeof(PseudoColorContext),
+    .priv_class    = &pseudocolor_class,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .inputs        = inputs,
+    .outputs       = outputs,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_psnr.c b/mythtv/external/FFmpeg/libavfilter/vf_psnr.c
index 320f43307ec..493a501a7a4 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_psnr.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_psnr.c
@@ -29,16 +29,16 @@
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
-#include "dualinput.h"
 #include "drawutils.h"
 #include "formats.h"
+#include "framesync.h"
 #include "internal.h"
 #include "psnr.h"
 #include "video.h"
 
 typedef struct PSNRContext {
     const AVClass *class;
-    FFDualInputContext dinput;
+    FFFrameSync fs;
     double mse, min_mse, max_mse, mse_comp[4];
     uint64_t nb_frames;
     FILE *stats_file;
@@ -68,16 +68,16 @@ static const AVOption psnr_options[] = {
     { NULL }
 };
 
-AVFILTER_DEFINE_CLASS(psnr);
+FRAMESYNC_DEFINE_CLASS(psnr, PSNRContext, fs);
 
-static inline unsigned pow2(unsigned base)
+static inline unsigned pow_2(unsigned base)
 {
     return base*base;
 }
 
 static inline double get_psnr(double mse, uint64_t nb_frames, int max)
 {
-    return 10.0 * log10(pow2(max) / (mse / nb_frames));
+    return 10.0 * log10(pow_2(max) / (mse / nb_frames));
 }
 
 static uint64_t sse_line_8bit(const uint8_t *main_line,  const uint8_t *ref_line, int outw)
@@ -86,7 +86,7 @@ static uint64_t sse_line_8bit(const uint8_t *main_line,  const uint8_t *ref_line
     unsigned m2 = 0;
 
     for (j = 0; j < outw; j++)
-        m2 += pow2(main_line[j] - ref_line[j]);
+        m2 += pow_2(main_line[j] - ref_line[j]);
 
     return m2;
 }
@@ -99,7 +99,7 @@ static uint64_t sse_line_16bit(const uint8_t *_main_line, const uint8_t *_ref_li
     const uint16_t *ref_line = (const uint16_t *) _ref_line;
 
     for (j = 0; j < outw; j++)
-        m2 += pow2(main_line[j] - ref_line[j]);
+        m2 += pow_2(main_line[j] - ref_line[j]);
 
     return m2;
 }
@@ -142,17 +142,25 @@ static void set_meta(AVDictionary **metadata, const char *key, char comp, float
     }
 }
 
-static AVFrame *do_psnr(AVFilterContext *ctx, AVFrame *main,
-                        const AVFrame *ref)
+static int do_psnr(FFFrameSync *fs)
 {
+    AVFilterContext *ctx = fs->parent;
     PSNRContext *s = ctx->priv;
+    AVFrame *master, *ref;
     double comp_mse[4], mse = 0;
-    int j, c;
-    AVDictionary **metadata = avpriv_frame_get_metadatap(main);
+    int ret, j, c;
+    AVDictionary **metadata;
 
-    compute_images_mse(s, (const uint8_t **)main->data, main->linesize,
+    ret = ff_framesync_dualinput_get(fs, &master, &ref);
+    if (ret < 0)
+        return ret;
+    if (!ref)
+        return ff_filter_frame(ctx->outputs[0], master);
+    metadata = &master->metadata;
+
+    compute_images_mse(s, (const uint8_t **)master->data, master->linesize,
                           (const uint8_t **)ref->data, ref->linesize,
-                          main->width, main->height, comp_mse);
+                          master->width, master->height, comp_mse);
 
     for (j = 0; j < s->nb_components; j++)
         mse += comp_mse[j] * s->planeweight[j];
@@ -214,7 +222,7 @@ static AVFrame *do_psnr(AVFilterContext *ctx, AVFrame *main,
         fprintf(s->stats_file, "\n");
     }
 
-    return main;
+    return ff_filter_frame(ctx->outputs[0], master);
 }
 
 static av_cold int init(AVFilterContext *ctx)
@@ -245,14 +253,14 @@ static av_cold int init(AVFilterContext *ctx)
         }
     }
 
-    s->dinput.process = do_psnr;
+    s->fs.on_event = do_psnr;
     return 0;
 }
 
 static int query_formats(AVFilterContext *ctx)
 {
     static const enum AVPixelFormat pix_fmts[] = {
-        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
 #define PF_NOALPHA(suf) AV_PIX_FMT_YUV420##suf,  AV_PIX_FMT_YUV422##suf,  AV_PIX_FMT_YUV444##suf
 #define PF_ALPHA(suf)   AV_PIX_FMT_YUVA420##suf, AV_PIX_FMT_YUVA422##suf, AV_PIX_FMT_YUVA444##suf
 #define PF(suf)         PF_NOALPHA(suf), PF_ALPHA(suf)
@@ -331,27 +339,24 @@ static int config_output(AVFilterLink *outlink)
     AVFilterLink *mainlink = ctx->inputs[0];
     int ret;
 
+    ret = ff_framesync_init_dualinput(&s->fs, ctx);
+    if (ret < 0)
+        return ret;
     outlink->w = mainlink->w;
     outlink->h = mainlink->h;
     outlink->time_base = mainlink->time_base;
     outlink->sample_aspect_ratio = mainlink->sample_aspect_ratio;
     outlink->frame_rate = mainlink->frame_rate;
-    if ((ret = ff_dualinput_init(ctx, &s->dinput)) < 0)
+    if ((ret = ff_framesync_configure(&s->fs)) < 0)
         return ret;
 
     return 0;
 }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
+static int activate(AVFilterContext *ctx)
 {
-    PSNRContext *s = inlink->dst->priv;
-    return ff_dualinput_filter_frame(&s->dinput, inlink, inpicref);
-}
-
-static int request_frame(AVFilterLink *outlink)
-{
-    PSNRContext *s = outlink->src->priv;
-    return ff_dualinput_request_frame(&s->dinput, outlink);
+    PSNRContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
@@ -375,7 +380,7 @@ static av_cold void uninit(AVFilterContext *ctx)
                get_psnr(s->min_mse, 1, s->average_max));
     }
 
-    ff_dualinput_uninit(&s->dinput);
+    ff_framesync_uninit(&s->fs);
 
     if (s->stats_file && s->stats_file != stdout)
         fclose(s->stats_file);
@@ -385,11 +390,9 @@ static const AVFilterPad psnr_inputs[] = {
     {
         .name         = "main",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },{
         .name         = "reference",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
         .config_props = config_input_ref,
     },
     { NULL }
@@ -400,7 +403,6 @@ static const AVFilterPad psnr_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -408,9 +410,11 @@ static const AVFilterPad psnr_outputs[] = {
 AVFilter ff_vf_psnr = {
     .name          = "psnr",
     .description   = NULL_IF_CONFIG_SMALL("Calculate the PSNR between two video streams."),
+    .preinit       = psnr_framesync_preinit,
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
+    .activate      = activate,
     .priv_size     = sizeof(PSNRContext),
     .priv_class    = &psnr_class,
     .inputs        = psnr_inputs,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_readeia608.c b/mythtv/external/FFmpeg/libavfilter/vf_readeia608.c
new file mode 100644
index 00000000000..bc3abe7c4d2
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_readeia608.c
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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
+ * Filter for reading closed captioning data (EIA-608).
+ * See also https://en.wikipedia.org/wiki/EIA-608
+ */
+
+#include <string.h>
+
+#include "libavutil/internal.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/timestamp.h"
+
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+#define FALL 0
+#define RISE 1
+
+typedef struct ReadEIA608Context {
+    const AVClass *class;
+    int start, end;
+    int min_range;
+    int max_peak_diff;
+    int max_period_diff;
+    int max_start_diff;
+    int nb_found;
+    int white;
+    int black;
+    float mpd, mhd, msd, mac, spw, bhd, wth, bth;
+    int chp;
+} ReadEIA608Context;
+
+#define OFFSET(x) offsetof(ReadEIA608Context, x)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+
+static const AVOption readeia608_options[] = {
+    { "scan_min", "set from which line to scan for codes",                            OFFSET(start), AV_OPT_TYPE_INT,   {.i64=0},       0, INT_MAX, FLAGS },
+    { "scan_max", "set to which line to scan for codes",                              OFFSET(end),   AV_OPT_TYPE_INT,   {.i64=29},      0, INT_MAX, FLAGS },
+    { "mac",      "set minimal acceptable amplitude change for sync codes detection", OFFSET(mac),   AV_OPT_TYPE_FLOAT, {.dbl=.2},  0.001,       1, FLAGS },
+    { "spw",      "set ratio of width reserved for sync code detection",              OFFSET(spw),   AV_OPT_TYPE_FLOAT, {.dbl=.27},   0.1,     0.7, FLAGS },
+    { "mhd",      "set max peaks height difference for sync code detection",          OFFSET(mhd),   AV_OPT_TYPE_FLOAT, {.dbl=.1},      0,     0.5, FLAGS },
+    { "mpd",      "set max peaks period difference for sync code detection",          OFFSET(mpd),   AV_OPT_TYPE_FLOAT, {.dbl=.1},      0,     0.5, FLAGS },
+    { "msd",      "set first two max start code bits differences",                    OFFSET(msd),   AV_OPT_TYPE_FLOAT, {.dbl=.02},     0,     0.5, FLAGS },
+    { "bhd",      "set min ratio of bits height compared to 3rd start code bit",      OFFSET(bhd),   AV_OPT_TYPE_FLOAT, {.dbl=.75},  0.01,       1, FLAGS },
+    { "th_w",     "set white color threshold",                                        OFFSET(wth),   AV_OPT_TYPE_FLOAT, {.dbl=.35},   0.1,       1, FLAGS },
+    { "th_b",     "set black color threshold",                                        OFFSET(bth),   AV_OPT_TYPE_FLOAT, {.dbl=.15},     0,     0.5, FLAGS },
+    { "chp",      "check and apply parity bit",                                       OFFSET(chp),   AV_OPT_TYPE_BOOL,  {.i64= 0},      0,       1, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(readeia608);
+
+static int query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pixel_fmts[] = {
+        AV_PIX_FMT_GRAY8,
+        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
+        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
+        AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
+        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
+        AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
+        AV_PIX_FMT_YUVJ411P,
+        AV_PIX_FMT_NONE
+    };
+    AVFilterFormats *formats = ff_make_format_list(pixel_fmts);
+    if (!formats)
+        return AVERROR(ENOMEM);
+    return ff_set_common_formats(ctx, formats);
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    AVFilterContext *ctx = inlink->dst;
+    ReadEIA608Context *s = ctx->priv;
+    int depth = desc->comp[0].depth;
+
+    if (s->end >= inlink->h) {
+        av_log(ctx, AV_LOG_WARNING, "Last line to scan too large, clipping.\n");
+        s->end = inlink->h - 1;
+    }
+
+    if (s->start > s->end) {
+        av_log(ctx, AV_LOG_ERROR, "Invalid range.\n");
+        return AVERROR(EINVAL);
+    }
+
+    s->min_range = s->mac * ((1 << depth) - 1);
+    s->max_peak_diff = s->mhd * ((1 << depth) - 1);
+    s->max_period_diff = s->mpd * ((1 << depth) - 1);
+    s->max_start_diff = s->msd * ((1 << depth) - 1);
+    s->white = s->wth * ((1 << depth) - 1);
+    s->black = s->bth * ((1 << depth) - 1);
+
+    return 0;
+}
+
+static void extract_line(AVFilterContext *ctx, AVFilterLink *inlink, AVFrame *in, int line)
+{
+    ReadEIA608Context *s = ctx->priv;
+    int max = 0, min = INT_MAX;
+    int i, ch, range = 0;
+    const uint8_t *src;
+    uint16_t clock[8][2] = { { 0 } };
+    const int sync_width = s->spw * in->width;
+    int last = 0, peaks = 0, max_peak_diff = 0, dir = RISE;
+    const int width_per_bit = (in->width - sync_width) / 19;
+    uint8_t byte[2] = { 0 };
+    int s1, s2, s3, parity;
+
+    src = &in->data[0][line * in->linesize[0]];
+    for (i = 0; i < sync_width; i++) {
+        max = FFMAX(max, src[i]);
+        min = FFMIN(min, src[i]);
+    }
+
+    range = max - min;
+    if (range < s->min_range)
+        return;
+
+    for (i = 0; i < sync_width; i++) {
+        int Y = src[i];
+
+        if (dir == RISE) {
+            if (Y < last) {
+                dir = FALL;
+                if (last >= s->white) {
+                    clock[peaks][0] = last;
+                    clock[peaks][1] = i;
+                    peaks++;
+                    if (peaks > 7)
+                        break;
+                }
+            }
+        } else if (dir == FALL) {
+            if (Y > last && last <= s->black) {
+                dir = RISE;
+            }
+        }
+        last = Y;
+    }
+
+    if (peaks != 7)
+        return;
+
+    for (i = 1; i < 7; i++)
+        max_peak_diff = FFMAX(max_peak_diff, FFABS(clock[i][0] - clock[i-1][0]));
+
+    if (max_peak_diff > s->max_peak_diff)
+        return;
+
+    max = 0; min = INT_MAX;
+    for (i = 1; i < 7; i++) {
+        max = FFMAX(max, FFABS(clock[i][1] - clock[i-1][1]));
+        min = FFMIN(min, FFABS(clock[i][1] - clock[i-1][1]));
+    }
+
+    range = max - min;
+    if (range > s->max_period_diff)
+        return;
+
+    s1 = src[sync_width + width_per_bit * 0 + width_per_bit / 2];
+    s2 = src[sync_width + width_per_bit * 1 + width_per_bit / 2];
+    s3 = src[sync_width + width_per_bit * 2 + width_per_bit / 2];
+
+    if (FFABS(s1 - s2) > s->max_start_diff || s1 > s->black || s2 > s->black || s3 < s->white)
+        return;
+
+    for (ch = 0; ch < 2; ch++) {
+        for (parity = 0, i = 0; i < 8; i++) {
+            int b = src[sync_width + width_per_bit * (i + 3 + 8 * ch) + width_per_bit / 2];
+
+            if (b - s1 > (s3 - s1) * s->bhd) {
+                b = 1;
+                parity++;
+            } else {
+                b = 0;
+            }
+            byte[ch] |= b << i;
+        }
+
+        if (s->chp) {
+            if (!(parity & 1)) {
+                byte[ch] = 0;
+            }
+        }
+    }
+
+    {
+        uint8_t key[128], value[128];
+
+        snprintf(key, sizeof(key), "lavfi.readeia608.%d.cc", s->nb_found);
+        snprintf(value, sizeof(value), "0x%02X%02X", byte[0], byte[1]);
+        av_dict_set(&in->metadata, key, value, 0);
+
+        snprintf(key, sizeof(key), "lavfi.readeia608.%d.line", s->nb_found);
+        snprintf(value, sizeof(value), "%d", line);
+        av_dict_set(&in->metadata, key, value, 0);
+    }
+
+    s->nb_found++;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx  = inlink->dst;
+    AVFilterLink *outlink = ctx->outputs[0];
+    ReadEIA608Context *s = ctx->priv;
+    int i;
+
+    s->nb_found = 0;
+    for (i = s->start; i <= s->end; i++)
+        extract_line(ctx, inlink, in, i);
+
+    return ff_filter_frame(outlink, in);
+}
+
+static const AVFilterPad readeia608_inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = filter_frame,
+        .config_props = config_input,
+    },
+    { NULL }
+};
+
+static const AVFilterPad readeia608_outputs[] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_VIDEO,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_readeia608 = {
+    .name          = "readeia608",
+    .description   = NULL_IF_CONFIG_SMALL("Read EIA-608 Closed Caption codes from input video and write them to frame metadata."),
+    .priv_size     = sizeof(ReadEIA608Context),
+    .priv_class    = &readeia608_class,
+    .query_formats = query_formats,
+    .inputs        = readeia608_inputs,
+    .outputs       = readeia608_outputs,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_readvitc.c b/mythtv/external/FFmpeg/libavfilter/vf_readvitc.c
index d70af6a9ee1..7ef8cdae58e 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_readvitc.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_readvitc.c
@@ -221,9 +221,9 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     int found;
 
     found = read_vitc_line(s, frame->data[0], frame->linesize[0], inlink->w, inlink->h);
-    av_dict_set(avpriv_frame_get_metadatap(frame), "lavfi.readvitc.found", (found ? "1" : "0"), 0);
+    av_dict_set(&frame->metadata, "lavfi.readvitc.found", (found ? "1" : "0"), 0);
     if (found)
-        av_dict_set(avpriv_frame_get_metadatap(frame), "lavfi.readvitc.tc_str", make_vitc_tc_string(s->tcbuf, s->line_data), 0);
+        av_dict_set(&frame->metadata, "lavfi.readvitc.tc_str", make_vitc_tc_string(s->tcbuf, s->line_data), 0);
 
     return ff_filter_frame(outlink, frame);
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_remap.c b/mythtv/external/FFmpeg/libavfilter/vf_remap.c
index e70956d8c55..d24284703b8 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_remap.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_remap.c
@@ -83,6 +83,9 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
         AV_PIX_FMT_RGB48, AV_PIX_FMT_BGR48,
         AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9,
+        AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
+        AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_NONE
     };
     static const enum AVPixelFormat map_fmts[] = {
@@ -353,17 +356,12 @@ static int config_output(AVFilterLink *outlink)
     return ff_framesync_configure(&s->fs);
 }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
+static int activate(AVFilterContext *ctx)
 {
-    RemapContext *s = inlink->dst->priv;
-    return ff_framesync_filter_frame(&s->fs, inlink, buf);
+    RemapContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
-static int request_frame(AVFilterLink *outlink)
-{
-    RemapContext *s = outlink->src->priv;
-    return ff_framesync_request_frame(&s->fs, outlink);
-}
 
 static av_cold void uninit(AVFilterContext *ctx)
 {
@@ -376,18 +374,15 @@ static const AVFilterPad remap_inputs[] = {
     {
         .name         = "source",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
         .config_props = config_input,
     },
     {
         .name         = "xmap",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },
     {
         .name         = "ymap",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },
     { NULL }
 };
@@ -397,17 +392,17 @@ static const AVFilterPad remap_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
 
 AVFilter ff_vf_remap = {
     .name          = "remap",
-    .description   = NULL_IF_CONFIG_SMALL("Remap pixels"),
+    .description   = NULL_IF_CONFIG_SMALL("Remap pixels."),
     .priv_size     = sizeof(RemapContext),
     .uninit        = uninit,
     .query_formats = query_formats,
+    .activate      = activate,
     .inputs        = remap_inputs,
     .outputs       = remap_outputs,
     .priv_class    = &remap_class,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_removelogo.c b/mythtv/external/FFmpeg/libavfilter/vf_removelogo.c
index 94b92a58534..aff2d12a17b 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_removelogo.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_removelogo.c
@@ -79,7 +79,7 @@
 #include "lavfutils.h"
 #include "lswsutils.h"
 
-typedef struct {
+typedef struct RemovelogoContext {
     const AVClass *class;
     char *filename;
     /* Stores our collection of masks. The first is for an array of
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_rotate.c b/mythtv/external/FFmpeg/libavfilter/vf_rotate.c
index 42e725aca94..371ff7f722b 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_rotate.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_rotate.c
@@ -522,7 +522,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     }
     av_frame_copy_props(out, in);
 
-    rot->var_values[VAR_N] = inlink->frame_count;
+    rot->var_values[VAR_N] = inlink->frame_count_out;
     rot->var_values[VAR_T] = TS2T(in->pts, inlink->time_base);
     rot->angle = res = av_expr_eval(rot->angle_expr, rot->var_values, rot);
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_sab.c b/mythtv/external/FFmpeg/libavfilter/vf_sab.c
index 3f0951f32a0..6f636541616 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_sab.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_sab.c
@@ -31,7 +31,7 @@
 #include "formats.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct FilterParam {
     float radius;
     float pre_filter_radius;
     float strength;
@@ -46,7 +46,7 @@ typedef struct {
     int color_diff_coeff[COLOR_DIFF_COEFF_SIZE];
 } FilterParam;
 
-typedef struct {
+typedef struct SabContext {
     const AVClass *class;
     FilterParam  luma;
     FilterParam  chroma;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_scale.c b/mythtv/external/FFmpeg/libavfilter/vf_scale.c
index 22bee96d75b..3329c123466 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_scale.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_scale.c
@@ -29,9 +29,9 @@
 #include "avfilter.h"
 #include "formats.h"
 #include "internal.h"
+#include "scale.h"
 #include "video.h"
 #include "libavutil/avstring.h"
-#include "libavutil/eval.h"
 #include "libavutil/internal.h"
 #include "libavutil/mathematics.h"
 #include "libavutil/opt.h"
@@ -41,43 +41,12 @@
 #include "libavutil/avassert.h"
 #include "libswscale/swscale.h"
 
-static const char *const var_names[] = {
-    "in_w",   "iw",
-    "in_h",   "ih",
-    "out_w",  "ow",
-    "out_h",  "oh",
-    "a",
-    "sar",
-    "dar",
-    "hsub",
-    "vsub",
-    "ohsub",
-    "ovsub",
-    NULL
-};
-
-enum var_name {
-    VAR_IN_W,   VAR_IW,
-    VAR_IN_H,   VAR_IH,
-    VAR_OUT_W,  VAR_OW,
-    VAR_OUT_H,  VAR_OH,
-    VAR_A,
-    VAR_SAR,
-    VAR_DAR,
-    VAR_HSUB,
-    VAR_VSUB,
-    VAR_OHSUB,
-    VAR_OVSUB,
-    VARS_NB
-};
-
 enum EvalMode {
     EVAL_MODE_INIT,
     EVAL_MODE_FRAME,
     EVAL_MODE_NB
 };
 
-
 typedef struct ScaleContext {
     const AVClass *class;
     struct SwsContext *sws;     ///< software scaler context
@@ -256,74 +225,16 @@ static int config_props(AVFilterLink *outlink)
                             outlink->src->inputs[1] :
                             outlink->src->inputs[0];
     enum AVPixelFormat outfmt = outlink->format;
-    ScaleContext *scale = ctx->priv;
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
-    const AVPixFmtDescriptor *out_desc = av_pix_fmt_desc_get(outlink->format);
-    int64_t w, h;
-    double var_values[VARS_NB], res;
-    char *expr;
+    ScaleContext *scale = ctx->priv;
+    int w, h;
     int ret;
-    int factor_w, factor_h;
-
-    var_values[VAR_IN_W]  = var_values[VAR_IW] = inlink->w;
-    var_values[VAR_IN_H]  = var_values[VAR_IH] = inlink->h;
-    var_values[VAR_OUT_W] = var_values[VAR_OW] = NAN;
-    var_values[VAR_OUT_H] = var_values[VAR_OH] = NAN;
-    var_values[VAR_A]     = (double) inlink->w / inlink->h;
-    var_values[VAR_SAR]   = inlink->sample_aspect_ratio.num ?
-        (double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1;
-    var_values[VAR_DAR]   = var_values[VAR_A] * var_values[VAR_SAR];
-    var_values[VAR_HSUB]  = 1 << desc->log2_chroma_w;
-    var_values[VAR_VSUB]  = 1 << desc->log2_chroma_h;
-    var_values[VAR_OHSUB] = 1 << out_desc->log2_chroma_w;
-    var_values[VAR_OVSUB] = 1 << out_desc->log2_chroma_h;
-
-    /* evaluate width and height */
-    av_expr_parse_and_eval(&res, (expr = scale->w_expr),
-                           var_names, var_values,
-                           NULL, NULL, NULL, NULL, NULL, 0, ctx);
-    scale->w = var_values[VAR_OUT_W] = var_values[VAR_OW] = res;
-    if ((ret = av_expr_parse_and_eval(&res, (expr = scale->h_expr),
-                                      var_names, var_values,
-                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
-        goto fail;
-    scale->h = var_values[VAR_OUT_H] = var_values[VAR_OH] = res;
-    /* evaluate again the width, as it may depend on the output height */
-    if ((ret = av_expr_parse_and_eval(&res, (expr = scale->w_expr),
-                                      var_names, var_values,
-                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
-        goto fail;
-    scale->w = res;
-
-    w = scale->w;
-    h = scale->h;
-
-    /* Check if it is requested that the result has to be divisible by a some
-     * factor (w or h = -n with n being the factor). */
-    factor_w = 1;
-    factor_h = 1;
-    if (w < -1) {
-        factor_w = -w;
-    }
-    if (h < -1) {
-        factor_h = -h;
-    }
-
-    if (w < 0 && h < 0)
-        scale->w = scale->h = 0;
 
-    if (!(w = scale->w))
-        w = inlink->w;
-    if (!(h = scale->h))
-        h = inlink->h;
-
-    /* Make sure that the result is divisible by the factor we determined
-     * earlier. If no factor was set, it is nothing will happen as the default
-     * factor is 1 */
-    if (w < 0)
-        w = av_rescale(h, inlink->w, inlink->h * factor_w) * factor_w;
-    if (h < 0)
-        h = av_rescale(w, inlink->h, inlink->w * factor_h) * factor_h;
+    if ((ret = ff_scale_eval_dimensions(ctx,
+                                        scale->w_expr, scale->h_expr,
+                                        inlink, outlink,
+                                        &w, &h)) < 0)
+        goto fail;
 
     /* Note that force_original_aspect_ratio may overwrite the previous set
      * dimensions so that it is not divisible by the set factors anymore. */
@@ -374,6 +285,7 @@ static int config_props(AVFilterLink *outlink)
         int i;
 
         for (i = 0; i < 3; i++) {
+            int in_v_chr_pos = scale->in_v_chr_pos, out_v_chr_pos = scale->out_v_chr_pos;
             struct SwsContext **s = swscs[i];
             *s = sws_alloc_context();
             if (!*s)
@@ -406,17 +318,17 @@ static int config_props(AVFilterLink *outlink)
              * MPEG-2 chroma positions are used by convention
              * XXX: support other 4:2:0 pixel formats */
             if (inlink0->format == AV_PIX_FMT_YUV420P && scale->in_v_chr_pos == -513) {
-                scale->in_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
+                in_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
             }
 
             if (outlink->format == AV_PIX_FMT_YUV420P && scale->out_v_chr_pos == -513) {
-                scale->out_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
+                out_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
             }
 
             av_opt_set_int(*s, "src_h_chr_pos", scale->in_h_chr_pos, 0);
-            av_opt_set_int(*s, "src_v_chr_pos", scale->in_v_chr_pos, 0);
+            av_opt_set_int(*s, "src_v_chr_pos", in_v_chr_pos, 0);
             av_opt_set_int(*s, "dst_h_chr_pos", scale->out_h_chr_pos, 0);
-            av_opt_set_int(*s, "dst_v_chr_pos", scale->out_v_chr_pos, 0);
+            av_opt_set_int(*s, "dst_v_chr_pos", out_v_chr_pos, 0);
 
             if ((ret = sws_init_context(*s, NULL, NULL)) < 0)
                 return ret;
@@ -425,10 +337,10 @@ static int config_props(AVFilterLink *outlink)
         }
     }
 
-    if (inlink->sample_aspect_ratio.num){
-        outlink->sample_aspect_ratio = av_mul_q((AVRational){outlink->h * inlink->w, outlink->w * inlink->h}, inlink->sample_aspect_ratio);
+    if (inlink0->sample_aspect_ratio.num){
+        outlink->sample_aspect_ratio = av_mul_q((AVRational){outlink->h * inlink0->w, outlink->w * inlink0->h}, inlink0->sample_aspect_ratio);
     } else
-        outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
+        outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
 
     av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d fmt:%s sar:%d/%d -> w:%d h:%d fmt:%s sar:%d/%d flags:0x%0x\n",
            inlink ->w, inlink ->h, av_get_pix_fmt_name( inlink->format),
@@ -439,10 +351,6 @@ static int config_props(AVFilterLink *outlink)
     return 0;
 
 fail:
-    av_log(NULL, AV_LOG_ERROR,
-           "Error when evaluating the expression '%s'.\n"
-           "Maybe the expression for out_w:'%s' or for out_h:'%s' is self-referencing.\n",
-           expr, scale->w_expr, scale->h_expr);
     return ret;
 }
 
@@ -501,7 +409,7 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
     char buf[32];
     int in_range;
 
-    if (av_frame_get_colorspace(in) == AVCOL_SPC_YCGCO)
+    if (in->colorspace == AVCOL_SPC_YCGCO)
         av_log(link->dst, AV_LOG_WARNING, "Detected unsupported YCgCo colorspace.\n");
 
     if(   in->width  != link->w
@@ -548,7 +456,7 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
     if(scale->output_is_pal)
         avpriv_set_systematic_pal2((uint32_t*)out->data[1], outlink->format == AV_PIX_FMT_PAL8 ? AV_PIX_FMT_BGR8 : outlink->format);
 
-    in_range = av_frame_get_color_range(in);
+    in_range = in->color_range;
 
     if (   scale->in_color_matrix
         || scale->out_color_matrix
@@ -563,7 +471,7 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
                                  &brightness, &contrast, &saturation);
 
         if (scale->in_color_matrix)
-            inv_table = parse_yuv_type(scale->in_color_matrix, av_frame_get_colorspace(in));
+            inv_table = parse_yuv_type(scale->in_color_matrix, in->colorspace);
         if (scale->out_color_matrix)
             table     = parse_yuv_type(scale->out_color_matrix, AVCOL_SPC_UNSPECIFIED);
         else if (scale->in_color_matrix)
@@ -588,7 +496,7 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
                                      table, out_full,
                                      brightness, contrast, saturation);
 
-        av_frame_set_color_range(out, out_full ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG);
+        out->color_range = out_full ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
     }
 
     av_reduce(&out->sample_aspect_ratio.num, &out->sample_aspect_ratio.den,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_scale_cuda.c b/mythtv/external/FFmpeg/libavfilter/vf_scale_cuda.c
new file mode 100644
index 00000000000..23ac27a7dc4
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_scale_cuda.c
@@ -0,0 +1,556 @@
+/*
+* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+* DEALINGS IN THE SOFTWARE.
+*/
+
+#include <cuda.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libavutil/avstring.h"
+#include "libavutil/common.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_cuda_internal.h"
+#include "libavutil/internal.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "scale.h"
+#include "video.h"
+
+static const enum AVPixelFormat supported_formats[] = {
+    AV_PIX_FMT_YUV420P,
+    AV_PIX_FMT_NV12,
+    AV_PIX_FMT_YUV444P,
+    AV_PIX_FMT_P010,
+    AV_PIX_FMT_P016
+};
+
+#define DIV_UP(a, b) ( ((a) + (b) - 1) / (b) )
+#define ALIGN_UP(a, b) (((a) + (b) - 1) & ~((b) - 1))
+#define NUM_BUFFERS 2
+#define BLOCKX 32
+#define BLOCKY 16
+
+typedef struct CUDAScaleContext {
+    const AVClass *class;
+    enum AVPixelFormat in_fmt;
+    enum AVPixelFormat out_fmt;
+
+    struct {
+        int width;
+        int height;
+    } planes_in[3], planes_out[3];
+
+    AVBufferRef *frames_ctx;
+    AVFrame     *frame;
+
+    AVFrame *tmp_frame;
+    int passthrough;
+
+    /**
+     * Output sw format. AV_PIX_FMT_NONE for no conversion.
+     */
+    enum AVPixelFormat format;
+
+    char *w_expr;               ///< width  expression string
+    char *h_expr;               ///< height expression string
+
+    CUcontext   cu_ctx;
+    CUevent     cu_event;
+    CUmodule    cu_module;
+    CUfunction  cu_func_uchar;
+    CUfunction  cu_func_uchar2;
+    CUfunction  cu_func_uchar4;
+    CUfunction  cu_func_ushort;
+    CUfunction  cu_func_ushort2;
+    CUfunction  cu_func_ushort4;
+    CUtexref    cu_tex_uchar;
+    CUtexref    cu_tex_uchar2;
+    CUtexref    cu_tex_uchar4;
+    CUtexref    cu_tex_ushort;
+    CUtexref    cu_tex_ushort2;
+    CUtexref    cu_tex_ushort4;
+
+    CUdeviceptr srcBuffer;
+    CUdeviceptr dstBuffer;
+    int         tex_alignment;
+} CUDAScaleContext;
+
+static av_cold int cudascale_init(AVFilterContext *ctx)
+{
+    CUDAScaleContext *s = ctx->priv;
+
+    s->format = AV_PIX_FMT_NONE;
+    s->frame = av_frame_alloc();
+    if (!s->frame)
+        return AVERROR(ENOMEM);
+
+    s->tmp_frame = av_frame_alloc();
+    if (!s->tmp_frame)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+static av_cold void cudascale_uninit(AVFilterContext *ctx)
+{
+    CUDAScaleContext *s = ctx->priv;
+
+    av_frame_free(&s->frame);
+    av_buffer_unref(&s->frames_ctx);
+    av_frame_free(&s->tmp_frame);
+}
+
+static int cudascale_query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pixel_formats[] = {
+        AV_PIX_FMT_CUDA, AV_PIX_FMT_NONE,
+    };
+    AVFilterFormats *pix_fmts = ff_make_format_list(pixel_formats);
+
+    return ff_set_common_formats(ctx, pix_fmts);
+}
+
+static av_cold int init_stage(CUDAScaleContext *s, AVBufferRef *device_ctx)
+{
+    AVBufferRef *out_ref = NULL;
+    AVHWFramesContext *out_ctx;
+    int in_sw, in_sh, out_sw, out_sh;
+    int ret, i;
+
+    av_pix_fmt_get_chroma_sub_sample(s->in_fmt,  &in_sw,  &in_sh);
+    av_pix_fmt_get_chroma_sub_sample(s->out_fmt, &out_sw, &out_sh);
+    if (!s->planes_out[0].width) {
+        s->planes_out[0].width  = s->planes_in[0].width;
+        s->planes_out[0].height = s->planes_in[0].height;
+    }
+
+    for (i = 1; i < FF_ARRAY_ELEMS(s->planes_in); i++) {
+        s->planes_in[i].width   = s->planes_in[0].width   >> in_sw;
+        s->planes_in[i].height  = s->planes_in[0].height  >> in_sh;
+        s->planes_out[i].width  = s->planes_out[0].width  >> out_sw;
+        s->planes_out[i].height = s->planes_out[0].height >> out_sh;
+    }
+
+    out_ref = av_hwframe_ctx_alloc(device_ctx);
+    if (!out_ref)
+        return AVERROR(ENOMEM);
+    out_ctx = (AVHWFramesContext*)out_ref->data;
+
+    out_ctx->format    = AV_PIX_FMT_CUDA;
+    out_ctx->sw_format = s->out_fmt;
+    out_ctx->width     = FFALIGN(s->planes_out[0].width,  32);
+    out_ctx->height    = FFALIGN(s->planes_out[0].height, 32);
+
+    ret = av_hwframe_ctx_init(out_ref);
+    if (ret < 0)
+        goto fail;
+
+    av_frame_unref(s->frame);
+    ret = av_hwframe_get_buffer(out_ref, s->frame, 0);
+    if (ret < 0)
+        goto fail;
+
+    s->frame->width  = s->planes_out[0].width;
+    s->frame->height = s->planes_out[0].height;
+
+    av_buffer_unref(&s->frames_ctx);
+    s->frames_ctx = out_ref;
+
+    return 0;
+fail:
+    av_buffer_unref(&out_ref);
+    return ret;
+}
+
+static int format_is_supported(enum AVPixelFormat fmt)
+{
+    int i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++)
+        if (supported_formats[i] == fmt)
+            return 1;
+    return 0;
+}
+
+static av_cold int init_processing_chain(AVFilterContext *ctx, int in_width, int in_height,
+                                         int out_width, int out_height)
+{
+    CUDAScaleContext *s = ctx->priv;
+
+    AVHWFramesContext *in_frames_ctx;
+
+    enum AVPixelFormat in_format;
+    enum AVPixelFormat out_format;
+    int ret;
+
+    /* check that we have a hw context */
+    if (!ctx->inputs[0]->hw_frames_ctx) {
+        av_log(ctx, AV_LOG_ERROR, "No hw context provided on input\n");
+        return AVERROR(EINVAL);
+    }
+    in_frames_ctx = (AVHWFramesContext*)ctx->inputs[0]->hw_frames_ctx->data;
+    in_format     = in_frames_ctx->sw_format;
+    out_format    = (s->format == AV_PIX_FMT_NONE) ? in_format : s->format;
+
+    if (!format_is_supported(in_format)) {
+        av_log(ctx, AV_LOG_ERROR, "Unsupported input format: %s\n",
+               av_get_pix_fmt_name(in_format));
+        return AVERROR(ENOSYS);
+    }
+    if (!format_is_supported(out_format)) {
+        av_log(ctx, AV_LOG_ERROR, "Unsupported output format: %s\n",
+               av_get_pix_fmt_name(out_format));
+        return AVERROR(ENOSYS);
+    }
+
+    if (in_width == out_width && in_height == out_height)
+        s->passthrough = 1;
+
+    s->in_fmt = in_format;
+    s->out_fmt = out_format;
+
+    s->planes_in[0].width   = in_width;
+    s->planes_in[0].height  = in_height;
+    s->planes_out[0].width  = out_width;
+    s->planes_out[0].height = out_height;
+
+    ret = init_stage(s, in_frames_ctx->device_ref);
+    if (ret < 0)
+        return ret;
+
+    ctx->outputs[0]->hw_frames_ctx = av_buffer_ref(s->frames_ctx);
+    if (!ctx->outputs[0]->hw_frames_ctx)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+static av_cold int cudascale_config_props(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    AVFilterLink *inlink = outlink->src->inputs[0];
+    CUDAScaleContext *s  = ctx->priv;
+    AVHWFramesContext     *frames_ctx = (AVHWFramesContext*)inlink->hw_frames_ctx->data;
+    AVCUDADeviceContext *device_hwctx = frames_ctx->device_ctx->hwctx;
+    CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
+    CUresult err;
+    int w, h;
+    int ret;
+
+    extern char vf_scale_cuda_ptx[];
+
+    err = cuCtxPushCurrent(cuda_ctx);
+    if (err != CUDA_SUCCESS) {
+        av_log(ctx, AV_LOG_ERROR, "Error pushing cuda context\n");
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    err = cuModuleLoadData(&s->cu_module, vf_scale_cuda_ptx);
+    if (err != CUDA_SUCCESS) {
+        av_log(ctx, AV_LOG_ERROR, "Error loading module data\n");
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    cuModuleGetFunction(&s->cu_func_uchar, s->cu_module, "Subsample_Bilinear_uchar");
+    cuModuleGetFunction(&s->cu_func_uchar2, s->cu_module, "Subsample_Bilinear_uchar2");
+    cuModuleGetFunction(&s->cu_func_uchar4, s->cu_module, "Subsample_Bilinear_uchar4");
+    cuModuleGetFunction(&s->cu_func_ushort, s->cu_module, "Subsample_Bilinear_ushort");
+    cuModuleGetFunction(&s->cu_func_ushort2, s->cu_module, "Subsample_Bilinear_ushort2");
+    cuModuleGetFunction(&s->cu_func_ushort4, s->cu_module, "Subsample_Bilinear_ushort4");
+
+    cuModuleGetTexRef(&s->cu_tex_uchar, s->cu_module, "uchar_tex");
+    cuModuleGetTexRef(&s->cu_tex_uchar2, s->cu_module, "uchar2_tex");
+    cuModuleGetTexRef(&s->cu_tex_uchar4, s->cu_module, "uchar4_tex");
+    cuModuleGetTexRef(&s->cu_tex_ushort, s->cu_module, "ushort_tex");
+    cuModuleGetTexRef(&s->cu_tex_ushort2, s->cu_module, "ushort2_tex");
+    cuModuleGetTexRef(&s->cu_tex_ushort4, s->cu_module, "ushort4_tex");
+
+    cuTexRefSetFlags(s->cu_tex_uchar, CU_TRSF_READ_AS_INTEGER);
+    cuTexRefSetFlags(s->cu_tex_uchar2, CU_TRSF_READ_AS_INTEGER);
+    cuTexRefSetFlags(s->cu_tex_uchar4, CU_TRSF_READ_AS_INTEGER);
+    cuTexRefSetFlags(s->cu_tex_ushort, CU_TRSF_READ_AS_INTEGER);
+    cuTexRefSetFlags(s->cu_tex_ushort2, CU_TRSF_READ_AS_INTEGER);
+    cuTexRefSetFlags(s->cu_tex_ushort4, CU_TRSF_READ_AS_INTEGER);
+
+    cuTexRefSetFilterMode(s->cu_tex_uchar, CU_TR_FILTER_MODE_LINEAR);
+    cuTexRefSetFilterMode(s->cu_tex_uchar2, CU_TR_FILTER_MODE_LINEAR);
+    cuTexRefSetFilterMode(s->cu_tex_uchar4, CU_TR_FILTER_MODE_LINEAR);
+    cuTexRefSetFilterMode(s->cu_tex_ushort, CU_TR_FILTER_MODE_LINEAR);
+    cuTexRefSetFilterMode(s->cu_tex_ushort2, CU_TR_FILTER_MODE_LINEAR);
+    cuTexRefSetFilterMode(s->cu_tex_ushort4, CU_TR_FILTER_MODE_LINEAR);
+
+    cuCtxPopCurrent(&dummy);
+
+    if ((ret = ff_scale_eval_dimensions(s,
+                                        s->w_expr, s->h_expr,
+                                        inlink, outlink,
+                                        &w, &h)) < 0)
+        goto fail;
+
+    if (((int64_t)h * inlink->w) > INT_MAX  ||
+        ((int64_t)w * inlink->h) > INT_MAX)
+        av_log(ctx, AV_LOG_ERROR, "Rescaled value for width or height is too big.\n");
+
+    outlink->w = w;
+    outlink->h = h;
+
+    ret = init_processing_chain(ctx, inlink->w, inlink->h, w, h);
+    if (ret < 0)
+        return ret;
+
+    av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d -> w:%d h:%d\n",
+           inlink->w, inlink->h, outlink->w, outlink->h);
+
+    if (inlink->sample_aspect_ratio.num) {
+        outlink->sample_aspect_ratio = av_mul_q((AVRational){outlink->h*inlink->w,
+                                                             outlink->w*inlink->h},
+                                                inlink->sample_aspect_ratio);
+    } else {
+        outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
+    }
+
+    return 0;
+
+fail:
+    return ret;
+}
+
+static int call_resize_kernel(CUDAScaleContext *s, CUfunction func, CUtexref tex, int channels,
+                              uint8_t *src_dptr, int src_width, int src_height, int src_pitch,
+                              uint8_t *dst_dptr, int dst_width, int dst_height, int dst_pitch,
+                              int pixel_size)
+{
+    CUdeviceptr src_devptr = (CUdeviceptr)src_dptr;
+    CUdeviceptr dst_devptr = (CUdeviceptr)dst_dptr;
+    void *args_uchar[] = { &dst_devptr, &dst_width, &dst_height, &dst_pitch, &src_width, &src_height };
+    CUDA_ARRAY_DESCRIPTOR desc;
+
+    desc.Width  = src_width;
+    desc.Height = src_height;
+    desc.NumChannels = channels;
+    if (pixel_size == 1) {
+        desc.Format = CU_AD_FORMAT_UNSIGNED_INT8;
+    } else {
+        desc.Format = CU_AD_FORMAT_UNSIGNED_INT16;
+    }
+
+    cuTexRefSetAddress2D_v3(tex, &desc, src_devptr, src_pitch * pixel_size);
+    cuLaunchKernel(func, DIV_UP(dst_width, BLOCKX), DIV_UP(dst_height, BLOCKY), 1, BLOCKX, BLOCKY, 1, 0, 0, args_uchar, NULL);
+
+    return 0;
+}
+
+static int scalecuda_resize(AVFilterContext *ctx,
+                            AVFrame *out, AVFrame *in)
+{
+    AVHWFramesContext *in_frames_ctx = (AVHWFramesContext*)in->hw_frames_ctx->data;
+    CUDAScaleContext *s = ctx->priv;
+
+    switch (in_frames_ctx->sw_format) {
+    case AV_PIX_FMT_YUV420P:
+        call_resize_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+                           in->data[0], in->width, in->height, in->linesize[0],
+                           out->data[0], out->width, out->height, out->linesize[0],
+                           1);
+        call_resize_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+                           in->data[0]+in->linesize[0]*in->height, in->width/2, in->height/2, in->linesize[0]/2,
+                           out->data[0]+out->linesize[0]*out->height, out->width/2, out->height/2, out->linesize[0]/2,
+                           1);
+        call_resize_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+                           in->data[0]+ ALIGN_UP((in->linesize[0]*in->height*5)/4, s->tex_alignment), in->width/2, in->height/2, in->linesize[0]/2,
+                           out->data[0]+(out->linesize[0]*out->height*5)/4, out->width/2, out->height/2, out->linesize[0]/2,
+                           1);
+        break;
+    case AV_PIX_FMT_YUV444P:
+        call_resize_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+                           in->data[0], in->width, in->height, in->linesize[0],
+                           out->data[0], out->width, out->height, out->linesize[0],
+                           1);
+        call_resize_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+                           in->data[0]+in->linesize[0]*in->height, in->width, in->height, in->linesize[0],
+                           out->data[0]+out->linesize[0]*out->height, out->width, out->height, out->linesize[0],
+                           1);
+        call_resize_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+                           in->data[0]+in->linesize[0]*in->height*2, in->width, in->height, in->linesize[0],
+                           out->data[0]+out->linesize[0]*out->height*2, out->width, out->height, out->linesize[0],
+                           1);
+        break;
+    case AV_PIX_FMT_NV12:
+        call_resize_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+                           in->data[0], in->width, in->height, in->linesize[0],
+                           out->data[0], out->width, out->height, out->linesize[0],
+                           1);
+        call_resize_kernel(s, s->cu_func_uchar2, s->cu_tex_uchar2, 2,
+                           in->data[1], in->width/2, in->height/2, in->linesize[1],
+                           out->data[0] + out->linesize[0] * ((out->height + 31) & ~0x1f), out->width/2, out->height/2, out->linesize[1]/2,
+                           1);
+        break;
+    case AV_PIX_FMT_P010LE:
+        call_resize_kernel(s, s->cu_func_ushort, s->cu_tex_ushort, 1,
+                           in->data[0], in->width, in->height, in->linesize[0]/2,
+                           out->data[0], out->width, out->height, out->linesize[0]/2,
+                           2);
+        call_resize_kernel(s, s->cu_func_ushort2, s->cu_tex_ushort2, 2,
+                           in->data[1], in->width / 2, in->height / 2, in->linesize[1]/2,
+                           out->data[0] + out->linesize[0] * ((out->height + 31) & ~0x1f), out->width / 2, out->height / 2, out->linesize[1] / 4,
+                           2);
+        break;
+    case AV_PIX_FMT_P016LE:
+        call_resize_kernel(s, s->cu_func_ushort, s->cu_tex_ushort, 1,
+                           in->data[0], in->width, in->height, in->linesize[0] / 2,
+                           out->data[0], out->width, out->height, out->linesize[0] / 2,
+                           2);
+        call_resize_kernel(s, s->cu_func_ushort2, s->cu_tex_ushort2, 2,
+                           in->data[1], in->width / 2, in->height / 2, in->linesize[1] / 2,
+                           out->data[0] + out->linesize[0] * ((out->height + 31) & ~0x1f), out->width / 2, out->height / 2, out->linesize[1] / 4,
+                           2);
+        break;
+    default:
+        return AVERROR_BUG;
+    }
+
+    return 0;
+}
+
+static int cudascale_scale(AVFilterContext *ctx, AVFrame *out, AVFrame *in)
+{
+    CUDAScaleContext *s = ctx->priv;
+    AVFrame *src = in;
+    int ret;
+
+    ret = scalecuda_resize(ctx, s->frame, src);
+    if (ret < 0)
+        return ret;
+
+    src = s->frame;
+    ret = av_hwframe_get_buffer(src->hw_frames_ctx, s->tmp_frame, 0);
+    if (ret < 0)
+        return ret;
+
+    av_frame_move_ref(out, s->frame);
+    av_frame_move_ref(s->frame, s->tmp_frame);
+
+    ret = av_frame_copy_props(out, in);
+    if (ret < 0)
+        return ret;
+
+    return 0;
+}
+
+static int cudascale_filter_frame(AVFilterLink *link, AVFrame *in)
+{
+    AVFilterContext              *ctx = link->dst;
+    CUDAScaleContext               *s = ctx->priv;
+    AVFilterLink             *outlink = ctx->outputs[0];
+    AVHWFramesContext     *frames_ctx = (AVHWFramesContext*)s->frames_ctx->data;
+    AVCUDADeviceContext *device_hwctx = frames_ctx->device_ctx->hwctx;
+
+    AVFrame *out = NULL;
+    CUresult err;
+    CUcontext dummy;
+    int ret = 0;
+
+    out = av_frame_alloc();
+    if (!out) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    err = cuCtxPushCurrent(device_hwctx->cuda_ctx);
+    if (err != CUDA_SUCCESS) {
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    ret = cudascale_scale(ctx, out, in);
+
+    cuCtxPopCurrent(&dummy);
+    if (ret < 0)
+        goto fail;
+
+    av_reduce(&out->sample_aspect_ratio.num, &out->sample_aspect_ratio.den,
+              (int64_t)in->sample_aspect_ratio.num * outlink->h * link->w,
+              (int64_t)in->sample_aspect_ratio.den * outlink->w * link->h,
+              INT_MAX);
+
+    av_frame_free(&in);
+    return ff_filter_frame(outlink, out);
+fail:
+    av_frame_free(&in);
+    av_frame_free(&out);
+    return ret;
+}
+
+#define OFFSET(x) offsetof(CUDAScaleContext, x)
+#define FLAGS (AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM)
+static const AVOption options[] = {
+    { "w",      "Output video width",  OFFSET(w_expr),     AV_OPT_TYPE_STRING, { .str = "iw"   }, .flags = FLAGS },
+    { "h",      "Output video height", OFFSET(h_expr),     AV_OPT_TYPE_STRING, { .str = "ih"   }, .flags = FLAGS },
+    { NULL },
+};
+
+static const AVClass cudascale_class = {
+    .class_name = "cudascale",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+static const AVFilterPad cudascale_inputs[] = {
+    {
+        .name        = "default",
+        .type        = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = cudascale_filter_frame,
+    },
+    { NULL }
+};
+
+static const AVFilterPad cudascale_outputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = cudascale_config_props,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_scale_cuda = {
+    .name      = "scale_cuda",
+    .description = NULL_IF_CONFIG_SMALL("GPU accelerated video resizer"),
+
+    .init          = cudascale_init,
+    .uninit        = cudascale_uninit,
+    .query_formats = cudascale_query_formats,
+
+    .priv_size = sizeof(CUDAScaleContext),
+    .priv_class = &cudascale_class,
+
+    .inputs    = cudascale_inputs,
+    .outputs   = cudascale_outputs,
+
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_scale_cuda.cu b/mythtv/external/FFmpeg/libavfilter/vf_scale_cuda.cu
new file mode 100644
index 00000000000..5f5ec81989a
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_scale_cuda.cu
@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+extern "C" {
+
+texture<unsigned char, 2> uchar_tex;
+texture<uchar2, 2>  uchar2_tex;
+texture<uchar4, 2>  uchar4_tex;
+texture<unsigned short, 2> ushort_tex;
+texture<ushort2, 2>  ushort2_tex;
+texture<ushort4, 2>  ushort4_tex;
+
+__global__ void Subsample_Bilinear_uchar(unsigned char *dst,
+                                    int dst_width, int dst_height, int dst_pitch,
+                                    int src_width, int src_height)
+{
+    int xo = blockIdx.x * blockDim.x + threadIdx.x;
+    int yo = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (yo < dst_height && xo < dst_width)
+    {
+        float hscale = (float)src_width / (float)dst_width;
+        float vscale = (float)src_height / (float)dst_height;
+        float xi = (xo + 0.5f) * hscale;
+        float yi = (yo + 0.5f) * vscale;
+        // 3-tap filter weights are {wh,1.0,wh} and {wv,1.0,wv}
+        float wh = min(max(0.5f * (hscale - 1.0f), 0.0f), 1.0f);
+        float wv = min(max(0.5f * (vscale - 1.0f), 0.0f), 1.0f);
+        // Convert weights to two bilinear weights -> {wh,1.0,wh} -> {wh,0.5,0} + {0,0.5,wh}
+        float dx = wh / (0.5f + wh);
+        float dy = wv / (0.5f + wv);
+        int y0 = tex2D(uchar_tex, xi-dx, yi-dy);
+        int y1 = tex2D(uchar_tex, xi+dx, yi-dy);
+        int y2 = tex2D(uchar_tex, xi-dx, yi+dy);
+        int y3 = tex2D(uchar_tex, xi+dx, yi+dy);
+        dst[yo*dst_pitch+xo] = (unsigned char)((y0+y1+y2+y3+2) >> 2);
+    }
+}
+
+__global__ void Subsample_Bilinear_uchar2(uchar2 *dst,
+                                    int dst_width, int dst_height, int dst_pitch2,
+                                    int src_width, int src_height)
+{
+    int xo = blockIdx.x * blockDim.x + threadIdx.x;
+    int yo = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (yo < dst_height && xo < dst_width)
+    {
+        float hscale = (float)src_width / (float)dst_width;
+        float vscale = (float)src_height / (float)dst_height;
+        float xi = (xo + 0.5f) * hscale;
+        float yi = (yo + 0.5f) * vscale;
+        // 3-tap filter weights are {wh,1.0,wh} and {wv,1.0,wv}
+        float wh = min(max(0.5f * (hscale - 1.0f), 0.0f), 1.0f);
+        float wv = min(max(0.5f * (vscale - 1.0f), 0.0f), 1.0f);
+        // Convert weights to two bilinear weights -> {wh,1.0,wh} -> {wh,0.5,0} + {0,0.5,wh}
+        float dx = wh / (0.5f + wh);
+        float dy = wv / (0.5f + wv);
+        uchar2 c0 = tex2D(uchar2_tex, xi-dx, yi-dy);
+        uchar2 c1 = tex2D(uchar2_tex, xi+dx, yi-dy);
+        uchar2 c2 = tex2D(uchar2_tex, xi-dx, yi+dy);
+        uchar2 c3 = tex2D(uchar2_tex, xi+dx, yi+dy);
+        int2 uv;
+        uv.x = ((int)c0.x+(int)c1.x+(int)c2.x+(int)c3.x+2) >> 2;
+        uv.y = ((int)c0.y+(int)c1.y+(int)c2.y+(int)c3.y+2) >> 2;
+        dst[yo*dst_pitch2+xo] = make_uchar2((unsigned char)uv.x, (unsigned char)uv.y);
+    }
+}
+
+__global__ void Subsample_Bilinear_uchar4(uchar4 *dst,
+                                    int dst_width, int dst_height, int dst_pitch,
+                                    int src_width, int src_height)
+{
+    int xo = blockIdx.x * blockDim.x + threadIdx.x;
+    int yo = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (yo < dst_height && xo < dst_width)
+    {
+        float hscale = (float)src_width / (float)dst_width;
+        float vscale = (float)src_height / (float)dst_height;
+        float xi = (xo + 0.5f) * hscale;
+        float yi = (yo + 0.5f) * vscale;
+        // 3-tap filter weights are {wh,1.0,wh} and {wv,1.0,wv}
+        float wh = min(max(0.5f * (hscale - 1.0f), 0.0f), 1.0f);
+        float wv = min(max(0.5f * (vscale - 1.0f), 0.0f), 1.0f);
+        // Convert weights to two bilinear weights -> {wh,1.0,wh} -> {wh,0.5,0} + {0,0.5,wh}
+        float dx = wh / (0.5f + wh);
+        float dy = wv / (0.5f + wv);
+        uchar4 c0 = tex2D(uchar4_tex, xi-dx, yi-dy);
+        uchar4 c1 = tex2D(uchar4_tex, xi+dx, yi-dy);
+        uchar4 c2 = tex2D(uchar4_tex, xi-dx, yi+dy);
+        uchar4 c3 = tex2D(uchar4_tex, xi+dx, yi+dy);
+        int4 res;
+        res.x =  ((int)c0.x+(int)c1.x+(int)c2.x+(int)c3.x+2) >> 2;
+        res.y =  ((int)c0.y+(int)c1.y+(int)c2.y+(int)c3.y+2) >> 2;
+        res.z =  ((int)c0.z+(int)c1.z+(int)c2.z+(int)c3.z+2) >> 2;
+        res.w =  ((int)c0.w+(int)c1.w+(int)c2.w+(int)c3.w+2) >> 2;
+        dst[yo*dst_pitch+xo] = make_uchar4(
+            (unsigned char)res.x, (unsigned char)res.y, (unsigned char)res.z, (unsigned char)res.w);
+    }
+}
+
+__global__ void Subsample_Bilinear_ushort(unsigned short *dst,
+                                    int dst_width, int dst_height, int dst_pitch,
+                                    int src_width, int src_height)
+{
+    int xo = blockIdx.x * blockDim.x + threadIdx.x;
+    int yo = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (yo < dst_height && xo < dst_width)
+    {
+        float hscale = (float)src_width / (float)dst_width;
+        float vscale = (float)src_height / (float)dst_height;
+        float xi = (xo + 0.5f) * hscale;
+        float yi = (yo + 0.5f) * vscale;
+        // 3-tap filter weights are {wh,1.0,wh} and {wv,1.0,wv}
+        float wh = min(max(0.5f * (hscale - 1.0f), 0.0f), 1.0f);
+        float wv = min(max(0.5f * (vscale - 1.0f), 0.0f), 1.0f);
+        // Convert weights to two bilinear weights -> {wh,1.0,wh} -> {wh,0.5,0} + {0,0.5,wh}
+        float dx = wh / (0.5f + wh);
+        float dy = wv / (0.5f + wv);
+        int y0 = tex2D(ushort_tex, xi-dx, yi-dy);
+        int y1 = tex2D(ushort_tex, xi+dx, yi-dy);
+        int y2 = tex2D(ushort_tex, xi-dx, yi+dy);
+        int y3 = tex2D(ushort_tex, xi+dx, yi+dy);
+        dst[yo*dst_pitch+xo] = (unsigned short)((y0+y1+y2+y3+2) >> 2);
+    }
+}
+
+__global__ void Subsample_Bilinear_ushort2(ushort2 *dst,
+                                    int dst_width, int dst_height, int dst_pitch2,
+                                    int src_width, int src_height)
+{
+    int xo = blockIdx.x * blockDim.x + threadIdx.x;
+    int yo = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (yo < dst_height && xo < dst_width)
+    {
+        float hscale = (float)src_width / (float)dst_width;
+        float vscale = (float)src_height / (float)dst_height;
+        float xi = (xo + 0.5f) * hscale;
+        float yi = (yo + 0.5f) * vscale;
+        // 3-tap filter weights are {wh,1.0,wh} and {wv,1.0,wv}
+        float wh = min(max(0.5f * (hscale - 1.0f), 0.0f), 1.0f);
+        float wv = min(max(0.5f * (vscale - 1.0f), 0.0f), 1.0f);
+        // Convert weights to two bilinear weights -> {wh,1.0,wh} -> {wh,0.5,0} + {0,0.5,wh}
+        float dx = wh / (0.5f + wh);
+        float dy = wv / (0.5f + wv);
+        ushort2 c0 = tex2D(ushort2_tex, xi-dx, yi-dy);
+        ushort2 c1 = tex2D(ushort2_tex, xi+dx, yi-dy);
+        ushort2 c2 = tex2D(ushort2_tex, xi-dx, yi+dy);
+        ushort2 c3 = tex2D(ushort2_tex, xi+dx, yi+dy);
+        int2 uv;
+        uv.x = ((int)c0.x+(int)c1.x+(int)c2.x+(int)c3.x+2) >> 2;
+        uv.y = ((int)c0.y+(int)c1.y+(int)c2.y+(int)c3.y+2) >> 2;
+        dst[yo*dst_pitch2+xo] = make_ushort2((unsigned short)uv.x, (unsigned short)uv.y);
+    }
+}
+
+__global__ void Subsample_Bilinear_ushort4(ushort4 *dst,
+                                    int dst_width, int dst_height, int dst_pitch,
+                                    int src_width, int src_height)
+{
+    int xo = blockIdx.x * blockDim.x + threadIdx.x;
+    int yo = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (yo < dst_height && xo < dst_width)
+    {
+        float hscale = (float)src_width / (float)dst_width;
+        float vscale = (float)src_height / (float)dst_height;
+        float xi = (xo + 0.5f) * hscale;
+        float yi = (yo + 0.5f) * vscale;
+        // 3-tap filter weights are {wh,1.0,wh} and {wv,1.0,wv}
+        float wh = min(max(0.5f * (hscale - 1.0f), 0.0f), 1.0f);
+        float wv = min(max(0.5f * (vscale - 1.0f), 0.0f), 1.0f);
+        // Convert weights to two bilinear weights -> {wh,1.0,wh} -> {wh,0.5,0} + {0,0.5,wh}
+        float dx = wh / (0.5f + wh);
+        float dy = wv / (0.5f + wv);
+        ushort4 c0 = tex2D(ushort4_tex, xi-dx, yi-dy);
+        ushort4 c1 = tex2D(ushort4_tex, xi+dx, yi-dy);
+        ushort4 c2 = tex2D(ushort4_tex, xi-dx, yi+dy);
+        ushort4 c3 = tex2D(ushort4_tex, xi+dx, yi+dy);
+        int4 res;
+        res.x =  ((int)c0.x+(int)c1.x+(int)c2.x+(int)c3.x+2) >> 2;
+        res.y =  ((int)c0.y+(int)c1.y+(int)c2.y+(int)c3.y+2) >> 2;
+        res.z =  ((int)c0.z+(int)c1.z+(int)c2.z+(int)c3.z+2) >> 2;
+        res.w =  ((int)c0.w+(int)c1.w+(int)c2.w+(int)c3.w+2) >> 2;
+        dst[yo*dst_pitch+xo] = make_ushort4(
+            (unsigned short)res.x, (unsigned short)res.y, (unsigned short)res.z, (unsigned short)res.w);
+    }
+}
+
+}
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_scale_npp.c b/mythtv/external/FFmpeg/libavfilter/vf_scale_npp.c
index 8eafdc81fd5..8a277ce8e1d 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_scale_npp.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_scale_npp.c
@@ -27,17 +27,16 @@
 
 #include "libavutil/avstring.h"
 #include "libavutil/common.h"
-#include "libavutil/eval.h"
 #include "libavutil/hwcontext.h"
-#include "libavutil/hwcontext_cuda.h"
+#include "libavutil/hwcontext_cuda_internal.h"
 #include "libavutil/internal.h"
-#include "libavutil/mathematics.h"
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
 
 #include "avfilter.h"
 #include "formats.h"
 #include "internal.h"
+#include "scale.h"
 #include "video.h"
 
 static const enum AVPixelFormat supported_formats[] = {
@@ -50,32 +49,6 @@ static const enum AVPixelFormat deinterleaved_formats[][2] = {
     { AV_PIX_FMT_NV12, AV_PIX_FMT_YUV420P },
 };
 
-static const char *const var_names[] = {
-    "PI",
-    "PHI",
-    "E",
-    "in_w",   "iw",
-    "in_h",   "ih",
-    "out_w",  "ow",
-    "out_h",  "oh",
-    "a", "dar",
-    "sar",
-    NULL
-};
-
-enum var_name {
-    VAR_PI,
-    VAR_PHI,
-    VAR_E,
-    VAR_IN_W,   VAR_IW,
-    VAR_IN_H,   VAR_IH,
-    VAR_OUT_W,  VAR_OW,
-    VAR_OUT_H,  VAR_OH,
-    VAR_A, VAR_DAR,
-    VAR_SAR,
-    VARS_NB
-};
-
 enum ScaleStage {
     STAGE_DEINTERLEAVE,
     STAGE_RESIZE,
@@ -169,11 +142,9 @@ static int nppscale_query_formats(AVFilterContext *ctx)
     static const enum AVPixelFormat pixel_formats[] = {
         AV_PIX_FMT_CUDA, AV_PIX_FMT_NONE,
     };
-    AVFilterFormats *pix_fmts  = ff_make_format_list(pixel_formats);
+    AVFilterFormats *pix_fmts = ff_make_format_list(pixel_formats);
 
-    ff_set_common_formats(ctx, pix_fmts);
-
-    return 0;
+    return ff_set_common_formats(ctx, pix_fmts);
 }
 
 static int init_stage(NPPScaleStageContext *stage, AVBufferRef *device_ctx)
@@ -348,9 +319,11 @@ static int init_processing_chain(AVFilterContext *ctx, int in_width, int in_heig
         last_stage = i;
     }
 
-    if (last_stage < 0)
-        return 0;
-    ctx->outputs[0]->hw_frames_ctx = av_buffer_ref(s->stages[last_stage].frames_ctx);
+    if (last_stage >= 0)
+        ctx->outputs[0]->hw_frames_ctx = av_buffer_ref(s->stages[last_stage].frames_ctx);
+    else
+        ctx->outputs[0]->hw_frames_ctx = av_buffer_ref(ctx->inputs[0]->hw_frames_ctx);
+
     if (!ctx->outputs[0]->hw_frames_ctx)
         return AVERROR(ENOMEM);
 
@@ -361,64 +334,18 @@ static int nppscale_config_props(AVFilterLink *outlink)
 {
     AVFilterContext *ctx = outlink->src;
     AVFilterLink *inlink = outlink->src->inputs[0];
-    NPPScaleContext  *s = ctx->priv;
-    int64_t w, h;
-    double var_values[VARS_NB], res;
-    char *expr;
+    NPPScaleContext *s = ctx->priv;
+    int w, h;
     int ret;
 
-    var_values[VAR_PI]    = M_PI;
-    var_values[VAR_PHI]   = M_PHI;
-    var_values[VAR_E]     = M_E;
-    var_values[VAR_IN_W]  = var_values[VAR_IW] = inlink->w;
-    var_values[VAR_IN_H]  = var_values[VAR_IH] = inlink->h;
-    var_values[VAR_OUT_W] = var_values[VAR_OW] = NAN;
-    var_values[VAR_OUT_H] = var_values[VAR_OH] = NAN;
-    var_values[VAR_A]     = (double) inlink->w / inlink->h;
-    var_values[VAR_SAR]   = inlink->sample_aspect_ratio.num ?
-        (double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1;
-    var_values[VAR_DAR]   = var_values[VAR_A] * var_values[VAR_SAR];
-
-    /* evaluate width and height */
-    av_expr_parse_and_eval(&res, (expr = s->w_expr),
-                           var_names, var_values,
-                           NULL, NULL, NULL, NULL, NULL, 0, ctx);
-    s->w = var_values[VAR_OUT_W] = var_values[VAR_OW] = res;
-    if ((ret = av_expr_parse_and_eval(&res, (expr = s->h_expr),
-                                      var_names, var_values,
-                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
-        goto fail;
-    s->h = var_values[VAR_OUT_H] = var_values[VAR_OH] = res;
-    /* evaluate again the width, as it may depend on the output height */
-    if ((ret = av_expr_parse_and_eval(&res, (expr = s->w_expr),
-                                      var_names, var_values,
-                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
+    if ((ret = ff_scale_eval_dimensions(s,
+                                        s->w_expr, s->h_expr,
+                                        inlink, outlink,
+                                        &w, &h)) < 0)
         goto fail;
-    s->w = res;
-
-    w = s->w;
-    h = s->h;
 
-    /* sanity check params */
-    if (w <  -1 || h <  -1) {
-        av_log(ctx, AV_LOG_ERROR, "Size values less than -1 are not acceptable.\n");
-        return AVERROR(EINVAL);
-    }
-    if (w == -1 && h == -1)
-        s->w = s->h = 0;
-
-    if (!(w = s->w))
-        w = inlink->w;
-    if (!(h = s->h))
-        h = inlink->h;
-    if (w == -1)
-        w = av_rescale(h, inlink->w, inlink->h);
-    if (h == -1)
-        h = av_rescale(w, inlink->h, inlink->w);
-
-    if (w > INT_MAX || h > INT_MAX ||
-        (h * inlink->w) > INT_MAX  ||
-        (w * inlink->h) > INT_MAX)
+    if (((int64_t)h * inlink->w) > INT_MAX  ||
+        ((int64_t)w * inlink->h) > INT_MAX)
         av_log(ctx, AV_LOG_ERROR, "Rescaled value for width or height is too big.\n");
 
     outlink->w = w;
@@ -441,8 +368,6 @@ static int nppscale_config_props(AVFilterLink *outlink)
     return 0;
 
 fail:
-    av_log(NULL, AV_LOG_ERROR,
-           "Error when evaluating the expression '%s'\n", expr);
     return ret;
 }
 
@@ -477,7 +402,7 @@ static int nppscale_resize(AVFilterContext *ctx, NPPScaleStageContext *stage,
     NppStatus err;
     int i;
 
-    for (i = 0; i < FF_ARRAY_ELEMS(in->data) && in->data[i]; i++) {
+    for (i = 0; i < FF_ARRAY_ELEMS(stage->planes_in) && i < FF_ARRAY_ELEMS(in->data) && in->data[i]; i++) {
         int iw = stage->planes_in[i].width;
         int ih = stage->planes_in[i].height;
         int ow = stage->planes_out[i].width;
@@ -586,12 +511,7 @@ static int nppscale_filter_frame(AVFilterLink *link, AVFrame *in)
         goto fail;
     }
 
-    av_reduce(&out->sample_aspect_ratio.num, &out->sample_aspect_ratio.den,
-              (int64_t)in->sample_aspect_ratio.num * outlink->h * link->w,
-              (int64_t)in->sample_aspect_ratio.den * outlink->w * link->h,
-              INT_MAX);
-
-    err = cuCtxPushCurrent(device_hwctx->cuda_ctx);
+    err = device_hwctx->internal->cuda_dl->cuCtxPushCurrent(device_hwctx->cuda_ctx);
     if (err != CUDA_SUCCESS) {
         ret = AVERROR_UNKNOWN;
         goto fail;
@@ -599,10 +519,15 @@ static int nppscale_filter_frame(AVFilterLink *link, AVFrame *in)
 
     ret = nppscale_scale(ctx, out, in);
 
-    cuCtxPopCurrent(&dummy);
+    device_hwctx->internal->cuda_dl->cuCtxPopCurrent(&dummy);
     if (ret < 0)
         goto fail;
 
+    av_reduce(&out->sample_aspect_ratio.num, &out->sample_aspect_ratio.den,
+              (int64_t)in->sample_aspect_ratio.num * outlink->h * link->w,
+              (int64_t)in->sample_aspect_ratio.den * outlink->w * link->h,
+              INT_MAX);
+
     av_frame_free(&in);
     return ff_filter_frame(outlink, out);
 fail:
@@ -669,4 +594,6 @@ AVFilter ff_vf_scale_npp = {
 
     .inputs    = nppscale_inputs,
     .outputs   = nppscale_outputs,
+
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_scale_qsv.c b/mythtv/external/FFmpeg/libavfilter/vf_scale_qsv.c
new file mode 100644
index 00000000000..a5f5be7d66d
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_scale_qsv.c
@@ -0,0 +1,633 @@
+/*
+ * 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
+ * scale video filter - QSV
+ */
+
+#include <mfx/mfxvideo.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include "libavutil/avstring.h"
+#include "libavutil/common.h"
+#include "libavutil/eval.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_qsv.h"
+#include "libavutil/internal.h"
+#include "libavutil/mathematics.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "libavutil/time.h"
+
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+static const char *const var_names[] = {
+    "PI",
+    "PHI",
+    "E",
+    "in_w",   "iw",
+    "in_h",   "ih",
+    "out_w",  "ow",
+    "out_h",  "oh",
+    "a", "dar",
+    "sar",
+    NULL
+};
+
+enum var_name {
+    VAR_PI,
+    VAR_PHI,
+    VAR_E,
+    VAR_IN_W,   VAR_IW,
+    VAR_IN_H,   VAR_IH,
+    VAR_OUT_W,  VAR_OW,
+    VAR_OUT_H,  VAR_OH,
+    VAR_A, VAR_DAR,
+    VAR_SAR,
+    VARS_NB
+};
+
+typedef struct QSVScaleContext {
+    const AVClass *class;
+
+    AVBufferRef *out_frames_ref;
+    /* a clone of the main session, used internally for scaling */
+    mfxSession   session;
+
+    mfxMemId *mem_ids_in;
+    int nb_mem_ids_in;
+
+    mfxMemId *mem_ids_out;
+    int nb_mem_ids_out;
+
+    mfxFrameSurface1 **surface_ptrs_in;
+    int             nb_surface_ptrs_in;
+
+    mfxFrameSurface1 **surface_ptrs_out;
+    int             nb_surface_ptrs_out;
+
+    mfxExtOpaqueSurfaceAlloc opaque_alloc;
+    mfxExtBuffer            *ext_buffers[1];
+
+    int shift_width, shift_height;
+
+    /**
+     * New dimensions. Special values are:
+     *   0 = original width/height
+     *  -1 = keep original aspect
+     */
+    int w, h;
+
+    /**
+     * Output sw format. AV_PIX_FMT_NONE for no conversion.
+     */
+    enum AVPixelFormat format;
+
+    char *w_expr;               ///< width  expression string
+    char *h_expr;               ///< height expression string
+    char *format_str;
+} QSVScaleContext;
+
+static int qsvscale_init(AVFilterContext *ctx)
+{
+    QSVScaleContext *s = ctx->priv;
+
+    if (!strcmp(s->format_str, "same")) {
+        s->format = AV_PIX_FMT_NONE;
+    } else {
+        s->format = av_get_pix_fmt(s->format_str);
+        if (s->format == AV_PIX_FMT_NONE) {
+            av_log(ctx, AV_LOG_ERROR, "Unrecognized pixel format: %s\n", s->format_str);
+            return AVERROR(EINVAL);
+        }
+    }
+
+    return 0;
+}
+
+static void qsvscale_uninit(AVFilterContext *ctx)
+{
+    QSVScaleContext *s = ctx->priv;
+
+    if (s->session) {
+        MFXClose(s->session);
+        s->session = NULL;
+    }
+    av_buffer_unref(&s->out_frames_ref);
+
+    av_freep(&s->mem_ids_in);
+    av_freep(&s->mem_ids_out);
+    s->nb_mem_ids_in  = 0;
+    s->nb_mem_ids_out = 0;
+
+    av_freep(&s->surface_ptrs_in);
+    av_freep(&s->surface_ptrs_out);
+    s->nb_surface_ptrs_in  = 0;
+    s->nb_surface_ptrs_out = 0;
+}
+
+static int qsvscale_query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pixel_formats[] = {
+        AV_PIX_FMT_QSV, AV_PIX_FMT_NONE,
+    };
+    AVFilterFormats *pix_fmts  = ff_make_format_list(pixel_formats);
+    int ret;
+
+    if ((ret = ff_set_common_formats(ctx, pix_fmts)) < 0)
+        return ret;
+
+    return 0;
+}
+
+static int init_out_pool(AVFilterContext *ctx,
+                         int out_width, int out_height)
+{
+    QSVScaleContext *s = ctx->priv;
+
+    AVHWFramesContext *in_frames_ctx;
+    AVHWFramesContext *out_frames_ctx;
+    AVQSVFramesContext *in_frames_hwctx;
+    AVQSVFramesContext *out_frames_hwctx;
+    enum AVPixelFormat in_format;
+    enum AVPixelFormat out_format;
+    int i, ret;
+
+    /* check that we have a hw context */
+    if (!ctx->inputs[0]->hw_frames_ctx) {
+        av_log(ctx, AV_LOG_ERROR, "No hw context provided on input\n");
+        return AVERROR(EINVAL);
+    }
+    in_frames_ctx   = (AVHWFramesContext*)ctx->inputs[0]->hw_frames_ctx->data;
+    in_frames_hwctx = in_frames_ctx->hwctx;
+
+    in_format     = in_frames_ctx->sw_format;
+    out_format    = (s->format == AV_PIX_FMT_NONE) ? in_format : s->format;
+
+    s->out_frames_ref = av_hwframe_ctx_alloc(in_frames_ctx->device_ref);
+    if (!s->out_frames_ref)
+        return AVERROR(ENOMEM);
+    out_frames_ctx   = (AVHWFramesContext*)s->out_frames_ref->data;
+    out_frames_hwctx = out_frames_ctx->hwctx;
+
+    out_frames_ctx->format            = AV_PIX_FMT_QSV;
+    out_frames_ctx->width             = FFALIGN(out_width,  32);
+    out_frames_ctx->height            = FFALIGN(out_height, 32);
+    out_frames_ctx->sw_format         = out_format;
+    out_frames_ctx->initial_pool_size = 32;
+
+    out_frames_hwctx->frame_type = in_frames_hwctx->frame_type;
+
+    ret = av_hwframe_ctx_init(s->out_frames_ref);
+    if (ret < 0)
+        return ret;
+
+    for (i = 0; i < out_frames_hwctx->nb_surfaces; i++) {
+        mfxFrameInfo *info = &out_frames_hwctx->surfaces[i].Info;
+        info->CropW = out_width;
+        info->CropH = out_height;
+    }
+
+    return 0;
+}
+
+static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
+                             mfxFrameAllocResponse *resp)
+{
+    AVFilterContext *ctx = pthis;
+    QSVScaleContext   *s = ctx->priv;
+
+    if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) ||
+        !(req->Type & (MFX_MEMTYPE_FROM_VPPIN | MFX_MEMTYPE_FROM_VPPOUT)) ||
+        !(req->Type & MFX_MEMTYPE_EXTERNAL_FRAME))
+        return MFX_ERR_UNSUPPORTED;
+
+    if (req->Type & MFX_MEMTYPE_FROM_VPPIN) {
+        resp->mids           = s->mem_ids_in;
+        resp->NumFrameActual = s->nb_mem_ids_in;
+    } else {
+        resp->mids           = s->mem_ids_out;
+        resp->NumFrameActual = s->nb_mem_ids_out;
+    }
+
+    return MFX_ERR_NONE;
+}
+
+static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
+{
+    return MFX_ERR_NONE;
+}
+
+static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
+{
+    return MFX_ERR_UNSUPPORTED;
+}
+
+static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
+{
+    return MFX_ERR_UNSUPPORTED;
+}
+
+static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
+{
+    *hdl = mid;
+    return MFX_ERR_NONE;
+}
+
+static const mfxHandleType handle_types[] = {
+    MFX_HANDLE_VA_DISPLAY,
+    MFX_HANDLE_D3D9_DEVICE_MANAGER,
+    MFX_HANDLE_D3D11_DEVICE,
+};
+
+static int init_out_session(AVFilterContext *ctx)
+{
+
+    QSVScaleContext                   *s = ctx->priv;
+    AVHWFramesContext     *in_frames_ctx = (AVHWFramesContext*)ctx->inputs[0]->hw_frames_ctx->data;
+    AVHWFramesContext    *out_frames_ctx = (AVHWFramesContext*)s->out_frames_ref->data;
+    AVQSVFramesContext  *in_frames_hwctx = in_frames_ctx->hwctx;
+    AVQSVFramesContext *out_frames_hwctx = out_frames_ctx->hwctx;
+    AVQSVDeviceContext     *device_hwctx = in_frames_ctx->device_ctx->hwctx;
+
+    int opaque = !!(in_frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME);
+
+    mfxHDL handle = NULL;
+    mfxHandleType handle_type;
+    mfxVersion ver;
+    mfxIMPL impl;
+    mfxVideoParam par;
+    mfxStatus err;
+    int i;
+
+    /* extract the properties of the "master" session given to us */
+    err = MFXQueryIMPL(device_hwctx->session, &impl);
+    if (err == MFX_ERR_NONE)
+        err = MFXQueryVersion(device_hwctx->session, &ver);
+    if (err != MFX_ERR_NONE) {
+        av_log(ctx, AV_LOG_ERROR, "Error querying the session attributes\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    for (i = 0; i < FF_ARRAY_ELEMS(handle_types); i++) {
+        err = MFXVideoCORE_GetHandle(device_hwctx->session, handle_types[i], &handle);
+        if (err == MFX_ERR_NONE) {
+            handle_type = handle_types[i];
+            break;
+        }
+    }
+
+    /* create a "slave" session with those same properties, to be used for
+     * actual scaling */
+    err = MFXInit(impl, &ver, &s->session);
+    if (err != MFX_ERR_NONE) {
+        av_log(ctx, AV_LOG_ERROR, "Error initializing a session for scaling\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    if (handle) {
+        err = MFXVideoCORE_SetHandle(s->session, handle_type, handle);
+        if (err != MFX_ERR_NONE)
+            return AVERROR_UNKNOWN;
+    }
+
+    memset(&par, 0, sizeof(par));
+
+    if (opaque) {
+        s->surface_ptrs_in = av_mallocz_array(in_frames_hwctx->nb_surfaces,
+                                              sizeof(*s->surface_ptrs_in));
+        if (!s->surface_ptrs_in)
+            return AVERROR(ENOMEM);
+        for (i = 0; i < in_frames_hwctx->nb_surfaces; i++)
+            s->surface_ptrs_in[i] = in_frames_hwctx->surfaces + i;
+        s->nb_surface_ptrs_in = in_frames_hwctx->nb_surfaces;
+
+        s->surface_ptrs_out = av_mallocz_array(out_frames_hwctx->nb_surfaces,
+                                               sizeof(*s->surface_ptrs_out));
+        if (!s->surface_ptrs_out)
+            return AVERROR(ENOMEM);
+        for (i = 0; i < out_frames_hwctx->nb_surfaces; i++)
+            s->surface_ptrs_out[i] = out_frames_hwctx->surfaces + i;
+        s->nb_surface_ptrs_out = out_frames_hwctx->nb_surfaces;
+
+        s->opaque_alloc.In.Surfaces   = s->surface_ptrs_in;
+        s->opaque_alloc.In.NumSurface = s->nb_surface_ptrs_in;
+        s->opaque_alloc.In.Type       = in_frames_hwctx->frame_type;
+
+        s->opaque_alloc.Out.Surfaces   = s->surface_ptrs_out;
+        s->opaque_alloc.Out.NumSurface = s->nb_surface_ptrs_out;
+        s->opaque_alloc.Out.Type       = out_frames_hwctx->frame_type;
+
+        s->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
+        s->opaque_alloc.Header.BufferSz = sizeof(s->opaque_alloc);
+
+        s->ext_buffers[0] = (mfxExtBuffer*)&s->opaque_alloc;
+
+        par.ExtParam    = s->ext_buffers;
+        par.NumExtParam = FF_ARRAY_ELEMS(s->ext_buffers);
+
+        par.IOPattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY | MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
+    } else {
+        mfxFrameAllocator frame_allocator = {
+            .pthis  = ctx,
+            .Alloc  = frame_alloc,
+            .Lock   = frame_lock,
+            .Unlock = frame_unlock,
+            .GetHDL = frame_get_hdl,
+            .Free   = frame_free,
+        };
+
+        s->mem_ids_in = av_mallocz_array(in_frames_hwctx->nb_surfaces,
+                                         sizeof(*s->mem_ids_in));
+        if (!s->mem_ids_in)
+            return AVERROR(ENOMEM);
+        for (i = 0; i < in_frames_hwctx->nb_surfaces; i++)
+            s->mem_ids_in[i] = in_frames_hwctx->surfaces[i].Data.MemId;
+        s->nb_mem_ids_in = in_frames_hwctx->nb_surfaces;
+
+        s->mem_ids_out = av_mallocz_array(out_frames_hwctx->nb_surfaces,
+                                          sizeof(*s->mem_ids_out));
+        if (!s->mem_ids_out)
+            return AVERROR(ENOMEM);
+        for (i = 0; i < out_frames_hwctx->nb_surfaces; i++)
+            s->mem_ids_out[i] = out_frames_hwctx->surfaces[i].Data.MemId;
+        s->nb_mem_ids_out = out_frames_hwctx->nb_surfaces;
+
+        err = MFXVideoCORE_SetFrameAllocator(s->session, &frame_allocator);
+        if (err != MFX_ERR_NONE)
+            return AVERROR_UNKNOWN;
+
+        par.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
+    }
+
+    par.AsyncDepth = 1;    // TODO async
+
+    par.vpp.In  = in_frames_hwctx->surfaces[0].Info;
+    par.vpp.Out = out_frames_hwctx->surfaces[0].Info;
+
+    /* Apparently VPP requires the frame rate to be set to some value, otherwise
+     * init will fail (probably for the framerate conversion filter). Since we
+     * are only doing scaling here, we just invent an arbitrary
+     * value */
+    par.vpp.In.FrameRateExtN  = 25;
+    par.vpp.In.FrameRateExtD  = 1;
+    par.vpp.Out.FrameRateExtN = 25;
+    par.vpp.Out.FrameRateExtD = 1;
+
+    err = MFXVideoVPP_Init(s->session, &par);
+    if (err != MFX_ERR_NONE) {
+        av_log(ctx, AV_LOG_ERROR, "Error opening the VPP for scaling\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    return 0;
+}
+
+static int init_scale_session(AVFilterContext *ctx, int in_width, int in_height,
+                              int out_width, int out_height)
+{
+    QSVScaleContext *s = ctx->priv;
+
+    int ret;
+
+    qsvscale_uninit(ctx);
+
+    ret = init_out_pool(ctx, out_width, out_height);
+    if (ret < 0)
+        return ret;
+
+    ret = init_out_session(ctx);
+    if (ret < 0)
+        return ret;
+
+    av_buffer_unref(&ctx->outputs[0]->hw_frames_ctx);
+    ctx->outputs[0]->hw_frames_ctx = av_buffer_ref(s->out_frames_ref);
+    if (!ctx->outputs[0]->hw_frames_ctx)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+static int qsvscale_config_props(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    AVFilterLink *inlink = outlink->src->inputs[0];
+    QSVScaleContext  *s = ctx->priv;
+    int64_t w, h;
+    double var_values[VARS_NB], res;
+    char *expr;
+    int ret;
+
+    var_values[VAR_PI]    = M_PI;
+    var_values[VAR_PHI]   = M_PHI;
+    var_values[VAR_E]     = M_E;
+    var_values[VAR_IN_W]  = var_values[VAR_IW] = inlink->w;
+    var_values[VAR_IN_H]  = var_values[VAR_IH] = inlink->h;
+    var_values[VAR_OUT_W] = var_values[VAR_OW] = NAN;
+    var_values[VAR_OUT_H] = var_values[VAR_OH] = NAN;
+    var_values[VAR_A]     = (double) inlink->w / inlink->h;
+    var_values[VAR_SAR]   = inlink->sample_aspect_ratio.num ?
+        (double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1;
+    var_values[VAR_DAR]   = var_values[VAR_A] * var_values[VAR_SAR];
+
+    /* evaluate width and height */
+    av_expr_parse_and_eval(&res, (expr = s->w_expr),
+                           var_names, var_values,
+                           NULL, NULL, NULL, NULL, NULL, 0, ctx);
+    s->w = var_values[VAR_OUT_W] = var_values[VAR_OW] = res;
+    if ((ret = av_expr_parse_and_eval(&res, (expr = s->h_expr),
+                                      var_names, var_values,
+                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
+        goto fail;
+    s->h = var_values[VAR_OUT_H] = var_values[VAR_OH] = res;
+    /* evaluate again the width, as it may depend on the output height */
+    if ((ret = av_expr_parse_and_eval(&res, (expr = s->w_expr),
+                                      var_names, var_values,
+                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
+        goto fail;
+    s->w = res;
+
+    w = s->w;
+    h = s->h;
+
+    /* sanity check params */
+    if (w <  -1 || h <  -1) {
+        av_log(ctx, AV_LOG_ERROR, "Size values less than -1 are not acceptable.\n");
+        return AVERROR(EINVAL);
+    }
+    if (w == -1 && h == -1)
+        s->w = s->h = 0;
+
+    if (!(w = s->w))
+        w = inlink->w;
+    if (!(h = s->h))
+        h = inlink->h;
+    if (w == -1)
+        w = av_rescale(h, inlink->w, inlink->h);
+    if (h == -1)
+        h = av_rescale(w, inlink->h, inlink->w);
+
+    if (w > INT_MAX || h > INT_MAX ||
+        (h * inlink->w) > INT_MAX  ||
+        (w * inlink->h) > INT_MAX)
+        av_log(ctx, AV_LOG_ERROR, "Rescaled value for width or height is too big.\n");
+
+    outlink->w = w;
+    outlink->h = h;
+
+    ret = init_scale_session(ctx, inlink->w, inlink->h, w, h);
+    if (ret < 0)
+        return ret;
+
+    av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d -> w:%d h:%d\n",
+           inlink->w, inlink->h, outlink->w, outlink->h);
+
+    if (inlink->sample_aspect_ratio.num)
+        outlink->sample_aspect_ratio = av_mul_q((AVRational){outlink->h*inlink->w,
+                                                             outlink->w*inlink->h},
+                                                inlink->sample_aspect_ratio);
+    else
+        outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
+
+    return 0;
+
+fail:
+    av_log(NULL, AV_LOG_ERROR,
+           "Error when evaluating the expression '%s'\n", expr);
+    return ret;
+}
+
+static int qsvscale_filter_frame(AVFilterLink *link, AVFrame *in)
+{
+    AVFilterContext             *ctx = link->dst;
+    QSVScaleContext               *s = ctx->priv;
+    AVFilterLink            *outlink = ctx->outputs[0];
+
+    mfxSyncPoint sync = NULL;
+    mfxStatus err;
+
+    AVFrame *out = NULL;
+    int ret = 0;
+
+    out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+    if (!out) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    do {
+        err = MFXVideoVPP_RunFrameVPPAsync(s->session,
+                                           (mfxFrameSurface1*)in->data[3],
+                                           (mfxFrameSurface1*)out->data[3],
+                                           NULL, &sync);
+        if (err == MFX_WRN_DEVICE_BUSY)
+            av_usleep(1);
+    } while (err == MFX_WRN_DEVICE_BUSY);
+
+    if (err < 0 || !sync) {
+        av_log(ctx, AV_LOG_ERROR, "Error during scaling\n");
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    do {
+        err = MFXVideoCORE_SyncOperation(s->session, sync, 1000);
+    } while (err == MFX_WRN_IN_EXECUTION);
+    if (err < 0) {
+        av_log(ctx, AV_LOG_ERROR, "Error synchronizing the operation: %d\n", err);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    ret = av_frame_copy_props(out, in);
+    if (ret < 0)
+        goto fail;
+
+    out->width  = outlink->w;
+    out->height = outlink->h;
+
+    av_reduce(&out->sample_aspect_ratio.num, &out->sample_aspect_ratio.den,
+              (int64_t)in->sample_aspect_ratio.num * outlink->h * link->w,
+              (int64_t)in->sample_aspect_ratio.den * outlink->w * link->h,
+              INT_MAX);
+
+    av_frame_free(&in);
+    return ff_filter_frame(outlink, out);
+fail:
+    av_frame_free(&in);
+    av_frame_free(&out);
+    return ret;
+}
+
+#define OFFSET(x) offsetof(QSVScaleContext, x)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+static const AVOption options[] = {
+    { "w",      "Output video width",  OFFSET(w_expr),     AV_OPT_TYPE_STRING, { .str = "iw"   }, .flags = FLAGS },
+    { "h",      "Output video height", OFFSET(h_expr),     AV_OPT_TYPE_STRING, { .str = "ih"   }, .flags = FLAGS },
+    { "format", "Output pixel format", OFFSET(format_str), AV_OPT_TYPE_STRING, { .str = "same" }, .flags = FLAGS },
+
+    { NULL },
+};
+
+static const AVClass qsvscale_class = {
+    .class_name = "qsvscale",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+static const AVFilterPad qsvscale_inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = qsvscale_filter_frame,
+    },
+    { NULL }
+};
+
+static const AVFilterPad qsvscale_outputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = qsvscale_config_props,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_scale_qsv = {
+    .name      = "scale_qsv",
+    .description = NULL_IF_CONFIG_SMALL("QuickSync video scaling and format conversion"),
+
+    .init          = qsvscale_init,
+    .uninit        = qsvscale_uninit,
+    .query_formats = qsvscale_query_formats,
+
+    .priv_size = sizeof(QSVScaleContext),
+    .priv_class = &qsvscale_class,
+
+    .inputs    = qsvscale_inputs,
+    .outputs   = qsvscale_outputs,
+
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_scale_vaapi.c b/mythtv/external/FFmpeg/libavfilter/vf_scale_vaapi.c
index 8dd5acfadab..22e928c0988 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_scale_vaapi.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_scale_vaapi.c
@@ -31,6 +31,8 @@
 #include "avfilter.h"
 #include "formats.h"
 #include "internal.h"
+#include "scale.h"
+#include "video.h"
 
 typedef struct ScaleVAAPIContext {
     const AVClass *class;
@@ -50,9 +52,12 @@ typedef struct ScaleVAAPIContext {
 
     char *output_format_string;
     enum AVPixelFormat output_format;
-    int output_width;
-    int output_height;
 
+    char *w_expr;      // width expression string
+    char *h_expr;      // height expression string
+
+    int output_width;  // computed width
+    int output_height; // computed height
 } ScaleVAAPIContext;
 
 
@@ -61,11 +66,14 @@ static int scale_vaapi_query_formats(AVFilterContext *avctx)
     enum AVPixelFormat pix_fmts[] = {
         AV_PIX_FMT_VAAPI, AV_PIX_FMT_NONE,
     };
+    int err;
 
-    ff_formats_ref(ff_make_format_list(pix_fmts),
-                   &avctx->inputs[0]->out_formats);
-    ff_formats_ref(ff_make_format_list(pix_fmts),
-                   &avctx->outputs[0]->in_formats);
+    if ((err = ff_formats_ref(ff_make_format_list(pix_fmts),
+                              &avctx->inputs[0]->out_formats)) < 0)
+        return err;
+    if ((err = ff_formats_ref(ff_make_format_list(pix_fmts),
+                              &avctx->outputs[0]->in_formats)) < 0)
+        return err;
 
     return 0;
 }
@@ -110,6 +118,7 @@ static int scale_vaapi_config_input(AVFilterLink *inlink)
 
 static int scale_vaapi_config_output(AVFilterLink *outlink)
 {
+    AVFilterLink *inlink = outlink->src->inputs[0];
     AVFilterContext *avctx = outlink->src;
     ScaleVAAPIContext *ctx = avctx->priv;
     AVVAAPIHWConfig *hwconfig = NULL;
@@ -162,6 +171,12 @@ static int scale_vaapi_config_output(AVFilterLink *outlink)
         }
     }
 
+    if ((err = ff_scale_eval_dimensions(ctx,
+                                        ctx->w_expr, ctx->h_expr,
+                                        inlink, outlink,
+                                        &ctx->output_width, &ctx->output_height)) < 0)
+        goto fail;
+
     if (ctx->output_width  < constraints->min_width  ||
         ctx->output_height < constraints->min_height ||
         ctx->output_width  > constraints->max_width  ||
@@ -259,6 +274,7 @@ static int scale_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
     VASurfaceID input_surface, output_surface;
     VAProcPipelineParameterBuffer params;
     VABufferID params_id;
+    VARectangle input_region;
     VAStatus vas;
     int err;
 
@@ -273,27 +289,30 @@ static int scale_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
     av_log(ctx, AV_LOG_DEBUG, "Using surface %#x for scale input.\n",
            input_surface);
 
-    output_frame = av_frame_alloc();
+    output_frame = ff_get_video_buffer(outlink, ctx->output_width,
+                                       ctx->output_height);
     if (!output_frame) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to allocate output frame.");
         err = AVERROR(ENOMEM);
         goto fail;
     }
 
-    err = av_hwframe_get_buffer(ctx->output_frames_ref, output_frame, 0);
-    if (err < 0) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to get surface for "
-               "output: %d\n.", err);
-    }
-
     output_surface = (VASurfaceID)(uintptr_t)output_frame->data[3];
     av_log(ctx, AV_LOG_DEBUG, "Using surface %#x for scale output.\n",
            output_surface);
 
     memset(&params, 0, sizeof(params));
 
+    // If there were top/left cropping, it could be taken into
+    // account here.
+    input_region = (VARectangle) {
+        .x      = 0,
+        .y      = 0,
+        .width  = input_frame->width,
+        .height = input_frame->height,
+    };
+
     params.surface = input_surface;
-    params.surface_region = 0;
+    params.surface_region = &input_region;
     params.surface_color_standard =
         vaapi_proc_colour_standard(input_frame->colorspace);
 
@@ -342,13 +361,14 @@ static int scale_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
         goto fail_after_render;
     }
 
-    // This doesn't get freed automatically for some reason.
-    vas = vaDestroyBuffer(ctx->hwctx->display, params_id);
-    if (vas != VA_STATUS_SUCCESS) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to free parameter buffer: "
-               "%d (%s).\n", vas, vaErrorStr(vas));
-        err = AVERROR(EIO);
-        goto fail;
+    if (CONFIG_VAAPI_1 || ctx->hwctx->driver_quirks &
+        AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS) {
+        vas = vaDestroyBuffer(ctx->hwctx->display, params_id);
+        if (vas != VA_STATUS_SUCCESS) {
+            av_log(ctx, AV_LOG_ERROR, "Failed to free parameter buffer: "
+                   "%d (%s).\n", vas, vaErrorStr(vas));
+            // And ignore.
+        }
     }
 
     av_frame_copy_props(output_frame, input_frame);
@@ -413,9 +433,9 @@ static av_cold void scale_vaapi_uninit(AVFilterContext *avctx)
 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM)
 static const AVOption scale_vaapi_options[] = {
     { "w", "Output video width",
-      OFFSET(output_width),  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, .flags = FLAGS },
+      OFFSET(w_expr), AV_OPT_TYPE_STRING, {.str = "iw"}, .flags = FLAGS },
     { "h", "Output video height",
-      OFFSET(output_height), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, .flags = FLAGS },
+      OFFSET(h_expr), AV_OPT_TYPE_STRING, {.str = "ih"}, .flags = FLAGS },
     { "format", "Output video format (software format of hardware frames)",
       OFFSET(output_format_string), AV_OPT_TYPE_STRING, .flags = FLAGS },
     { NULL },
@@ -457,4 +477,5 @@ AVFilter ff_vf_scale_vaapi = {
     .inputs        = scale_vaapi_inputs,
     .outputs       = scale_vaapi_outputs,
     .priv_class    = &scale_vaapi_class,
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_selectivecolor.c b/mythtv/external/FFmpeg/libavfilter/vf_selectivecolor.c
index a5cb533bc07..c4d51bb70dd 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_selectivecolor.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_selectivecolor.c
@@ -19,6 +19,7 @@
  */
 
 /**
+ * @see http://blog.pkh.me/p/22-understanding-selective-coloring-in-adobe-photoshop.html
  * @todo
  * - use integers so it can be made bitexact and a FATE test can be added
  */
@@ -28,6 +29,7 @@
 #include "libavutil/intreadwrite.h"
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
+#include "libavcodec/mathops.h" // for mid_pred(), which is a macro so no link dependency
 #include "avfilter.h"
 #include "drawutils.h"
 #include "formats.h"
@@ -63,19 +65,19 @@ static const char *color_names[NB_RANGES] = {
     "red", "yellow", "green", "cyan", "blue", "magenta", "white", "neutral", "black"
 };
 
-typedef int (*get_adjust_range_func)(int r, int g, int b, int min_val, int max_val);
+typedef int (*get_range_scale_func)(int r, int g, int b, int min_val, int max_val);
 
 struct process_range {
     int range_id;
     uint32_t mask;
-    get_adjust_range_func get_adjust_range;
+    get_range_scale_func get_scale;
 };
 
 typedef struct ThreadData {
     AVFrame *in, *out;
 } ThreadData;
 
-typedef struct {
+typedef struct SelectiveColorContext {
     const AVClass *class;
     int correction_method;
     char *opt_cmyk_adjust[NB_RANGES];
@@ -112,66 +114,38 @@ static const AVOption selectivecolor_options[] = {
 
 AVFILTER_DEFINE_CLASS(selectivecolor);
 
-static inline int get_mid_val(int r, int g, int b)
+static int get_rgb_scale(int r, int g, int b, int min_val, int max_val)
 {
-    if ((r < g && r > b) || (r < b && r > g)) return r;
-    if ((g < r && g > b) || (g < b && g > r)) return g;
-    if ((b < r && b > g) || (b < g && b > r)) return b;
-    return -1;
+    return max_val - mid_pred(r, g, b);
 }
 
-static int get_rgb_adjust_range(int r, int g, int b, int min_val, int max_val)
+static int get_cmy_scale(int r, int g, int b, int min_val, int max_val)
 {
-    // max - mid
-    const int mid_val = get_mid_val(r, g, b);
-    if (mid_val == -1) {
-        // XXX: can be simplified
-        if ((r != min_val && g == min_val && b == min_val) ||
-            (r == min_val && g != min_val && b == min_val) ||
-            (r == min_val && g == min_val && b != min_val))
-            return max_val - min_val;
-        return 0;
-    }
-    return max_val - mid_val;
-}
-
-static int get_cmy_adjust_range(int r, int g, int b, int min_val, int max_val)
-{
-    // mid - min
-    const int mid_val = get_mid_val(r, g, b);
-    if (mid_val == -1) {
-        // XXX: refactor with rgb
-        if ((r != max_val && g == max_val && b == max_val) ||
-            (r == max_val && g != max_val && b == max_val) ||
-            (r == max_val && g == max_val && b != max_val))
-            return max_val - min_val;
-        return 0;
-    }
-    return mid_val - min_val;
+    return mid_pred(r, g, b) - min_val;
 }
 
-#define DECLARE_ADJUST_RANGE_FUNCS(nbits)                                                   \
-static int get_neutrals_adjust_range##nbits(int r, int g, int b, int min_val, int max_val)  \
+#define DECLARE_RANGE_SCALE_FUNCS(nbits)                                                    \
+static int get_neutrals_scale##nbits(int r, int g, int b, int min_val, int max_val)         \
 {                                                                                           \
     /* 1 - (|max-0.5| + |min-0.5|) */                                                       \
     return (((1<<nbits)-1)*2 - (  abs((max_val<<1) - ((1<<nbits)-1))                        \
                                 + abs((min_val<<1) - ((1<<nbits)-1))) + 1) >> 1;            \
 }                                                                                           \
                                                                                             \
-static int get_whites_adjust_range##nbits(int r, int g, int b, int min_val, int max_val)    \
+static int get_whites_scale##nbits(int r, int g, int b, int min_val, int max_val)           \
 {                                                                                           \
     /* (min - 0.5) * 2 */                                                                   \
     return (min_val<<1) - ((1<<nbits)-1);                                                   \
 }                                                                                           \
                                                                                             \
-static int get_blacks_adjust_range##nbits(int r, int g, int b, int min_val, int max_val)    \
+static int get_blacks_scale##nbits(int r, int g, int b, int min_val, int max_val)           \
 {                                                                                           \
     /* (0.5 - max) * 2 */                                                                   \
     return ((1<<nbits)-1) - (max_val<<1);                                                   \
 }                                                                                           \
 
-DECLARE_ADJUST_RANGE_FUNCS(8)
-DECLARE_ADJUST_RANGE_FUNCS(16)
+DECLARE_RANGE_SCALE_FUNCS(8)
+DECLARE_RANGE_SCALE_FUNCS(16)
 
 static int register_range(SelectiveColorContext *s, int range_id)
 {
@@ -194,14 +168,14 @@ static int register_range(SelectiveColorContext *s, int range_id)
 
         pr->range_id = range_id;
         pr->mask = 1 << range_id;
-        if      (pr->mask & (1<<RANGE_REDS  | 1<<RANGE_GREENS   | 1<<RANGE_BLUES))   pr->get_adjust_range = get_rgb_adjust_range;
-        else if (pr->mask & (1<<RANGE_CYANS | 1<<RANGE_MAGENTAS | 1<<RANGE_YELLOWS)) pr->get_adjust_range = get_cmy_adjust_range;
-        else if (!s->is_16bit && (pr->mask & 1<<RANGE_WHITES))                       pr->get_adjust_range = get_whites_adjust_range8;
-        else if (!s->is_16bit && (pr->mask & 1<<RANGE_NEUTRALS))                     pr->get_adjust_range = get_neutrals_adjust_range8;
-        else if (!s->is_16bit && (pr->mask & 1<<RANGE_BLACKS))                       pr->get_adjust_range = get_blacks_adjust_range8;
-        else if ( s->is_16bit && (pr->mask & 1<<RANGE_WHITES))                       pr->get_adjust_range = get_whites_adjust_range16;
-        else if ( s->is_16bit && (pr->mask & 1<<RANGE_NEUTRALS))                     pr->get_adjust_range = get_neutrals_adjust_range16;
-        else if ( s->is_16bit && (pr->mask & 1<<RANGE_BLACKS))                       pr->get_adjust_range = get_blacks_adjust_range16;
+        if      (pr->mask & (1<<RANGE_REDS  | 1<<RANGE_GREENS   | 1<<RANGE_BLUES))   pr->get_scale = get_rgb_scale;
+        else if (pr->mask & (1<<RANGE_CYANS | 1<<RANGE_MAGENTAS | 1<<RANGE_YELLOWS)) pr->get_scale = get_cmy_scale;
+        else if (!s->is_16bit && (pr->mask & 1<<RANGE_WHITES))                       pr->get_scale = get_whites_scale8;
+        else if (!s->is_16bit && (pr->mask & 1<<RANGE_NEUTRALS))                     pr->get_scale = get_neutrals_scale8;
+        else if (!s->is_16bit && (pr->mask & 1<<RANGE_BLACKS))                       pr->get_scale = get_blacks_scale8;
+        else if ( s->is_16bit && (pr->mask & 1<<RANGE_WHITES))                       pr->get_scale = get_whites_scale16;
+        else if ( s->is_16bit && (pr->mask & 1<<RANGE_NEUTRALS))                     pr->get_scale = get_neutrals_scale16;
+        else if ( s->is_16bit && (pr->mask & 1<<RANGE_BLACKS))                       pr->get_scale = get_blacks_scale16;
         else
             av_assert0(0);
     }
@@ -329,14 +303,14 @@ static int query_formats(AVFilterContext *ctx)
     return ff_set_common_formats(ctx, fmts_list);
 }
 
-static inline int comp_adjust(int adjust_range, float value, float adjust, float k, int correction_method)
+static inline int comp_adjust(int scale, float value, float adjust, float k, int correction_method)
 {
     const float min = -value;
     const float max = 1. - value;
     float res = (-1. - adjust) * k - adjust;
     if (correction_method == CORRECTION_METHOD_RELATIVE)
         res *= max;
-    return lrint(av_clipf(res, min, max) * adjust_range);
+    return lrint(av_clipf(res, min, max) * scale);
 }
 
 #define DECLARE_SELECTIVE_COLOR_FUNC(nbits)                                                             \
@@ -391,18 +365,18 @@ static inline int selective_color_##nbits(AVFilterContext *ctx, ThreadData *td,
                 const struct process_range *pr = &s->process_ranges[i];                                 \
                                                                                                         \
                 if (range_flag & pr->mask) {                                                            \
-                    const int adjust_range = pr->get_adjust_range(r, g, b, min_color, max_color);       \
+                    const int scale = pr->get_scale(r, g, b, min_color, max_color);                     \
                                                                                                         \
-                    if (adjust_range > 0) {                                                             \
+                    if (scale > 0) {                                                                    \
                         const float *cmyk_adjust = s->cmyk_adjust[pr->range_id];                        \
                         const float adj_c = cmyk_adjust[0];                                             \
                         const float adj_m = cmyk_adjust[1];                                             \
                         const float adj_y = cmyk_adjust[2];                                             \
                         const float k = cmyk_adjust[3];                                                 \
                                                                                                         \
-                        adjust_r += comp_adjust(adjust_range, rnorm, adj_c, k, correction_method);      \
-                        adjust_g += comp_adjust(adjust_range, gnorm, adj_m, k, correction_method);      \
-                        adjust_b += comp_adjust(adjust_range, bnorm, adj_y, k, correction_method);      \
+                        adjust_r += comp_adjust(scale, rnorm, adj_c, k, correction_method);             \
+                        adjust_g += comp_adjust(scale, gnorm, adj_m, k, correction_method);             \
+                        adjust_b += comp_adjust(scale, bnorm, adj_y, k, correction_method);             \
                     }                                                                                   \
                 }                                                                                       \
             }                                                                                           \
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_separatefields.c b/mythtv/external/FFmpeg/libavfilter/vf_separatefields.c
index 3ea5eb67d7f..3ed222f271b 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_separatefields.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_separatefields.c
@@ -22,7 +22,7 @@
 #include "avfilter.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct SeparateFieldsContext {
     int nb_planes;
     AVFrame *second;
 } SeparateFieldsContext;
@@ -118,6 +118,13 @@ static int request_frame(AVFilterLink *outlink)
     return ret;
 }
 
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    SeparateFieldsContext *s = ctx->priv;
+
+    av_frame_free(&s->second);
+}
+
 static const AVFilterPad separatefields_inputs[] = {
     {
         .name         = "default",
@@ -141,6 +148,7 @@ AVFilter ff_vf_separatefields = {
     .name        = "separatefields",
     .description = NULL_IF_CONFIG_SMALL("Split input video frames into fields."),
     .priv_size   = sizeof(SeparateFieldsContext),
+    .uninit      = uninit,
     .inputs      = separatefields_inputs,
     .outputs     = separatefields_outputs,
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_setfield.c b/mythtv/external/FFmpeg/libavfilter/vf_setfield.c
index 96e9d18bd3a..f4dc33d7e59 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_setfield.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_setfield.c
@@ -35,7 +35,7 @@ enum SetFieldMode {
     MODE_PROG,
 };
 
-typedef struct {
+typedef struct SetFieldContext {
     const AVClass *class;
     int mode;                   ///< SetFieldMode
 } SetFieldContext;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_showinfo.c b/mythtv/external/FFmpeg/libavfilter/vf_showinfo.c
index 5146995c23a..14b8aa4aff1 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_showinfo.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_showinfo.c
@@ -107,8 +107,8 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
            "n:%4"PRId64" pts:%7s pts_time:%-7s pos:%9"PRId64" "
            "fmt:%s sar:%d/%d s:%dx%d i:%c iskey:%d type:%c "
            "checksum:%08"PRIX32" plane_checksum:[%08"PRIX32,
-           inlink->frame_count,
-           av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base), av_frame_get_pkt_pos(frame),
+           inlink->frame_count_out,
+           av_ts2str(frame->pts), av_ts2timestr(frame->pts, &inlink->time_base), frame->pkt_pos,
            desc->name,
            frame->sample_aspect_ratio.num, frame->sample_aspect_ratio.den,
            frame->width, frame->height,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_showpalette.c b/mythtv/external/FFmpeg/libavfilter/vf_showpalette.c
index f1627ba58e4..d886ab87a77 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_showpalette.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_showpalette.c
@@ -28,7 +28,7 @@
 #include "internal.h"
 #include "video.h"
 
-typedef struct {
+typedef struct ShowPaletteContext {
     const AVClass *class;
     int size;
 } ShowPaletteContext;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_shuffleframes.c b/mythtv/external/FFmpeg/libavfilter/vf_shuffleframes.c
index bfbf4bd2688..8e595111b80 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_shuffleframes.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_shuffleframes.c
@@ -68,7 +68,7 @@ static av_cold int init(AVFilterContext *ctx)
             return AVERROR(EINVAL);
         }
 
-        if (s->map[n] < 0 || s->map[n] >= nb_items) {
+        if (s->map[n] < -1 || s->map[n] >= nb_items) {
             av_log(ctx, AV_LOG_ERROR, "Index out of range.\n");
             av_free(mapping);
             return AVERROR(EINVAL);
@@ -99,11 +99,13 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
             AVFrame *out;
 
             x = s->map[n];
-            out = av_frame_clone(s->frames[x]);
-            if (!out)
-                return AVERROR(ENOMEM);
-            out->pts = s->pts[n];
-            ret = ff_filter_frame(ctx->outputs[0], out);
+            if (x >= 0) {
+                out = av_frame_clone(s->frames[x]);
+                if (!out)
+                    return AVERROR(ENOMEM);
+                out->pts = s->pts[n];
+                ret = ff_filter_frame(ctx->outputs[0], out);
+            }
             s->in_frames--;
         }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_signalstats.c b/mythtv/external/FFmpeg/libavfilter/vf_signalstats.c
index 22a1db196f0..298881bc72b 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_signalstats.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_signalstats.c
@@ -33,7 +33,7 @@ enum FilterMode {
     FILT_NUMB
 };
 
-typedef struct {
+typedef struct SignalstatsContext {
     const AVClass *class;
     int chromah;    // height of chroma plane
     int chromaw;    // width of chroma plane
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_signature.c b/mythtv/external/FFmpeg/libavfilter/vf_signature.c
new file mode 100644
index 00000000000..f0078ba1a6e
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_signature.c
@@ -0,0 +1,770 @@
+/*
+ * Copyright (c) 2017 Gerion Entrup
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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
+ * MPEG-7 video signature calculation and lookup filter
+ * @see http://epubs.surrey.ac.uk/531590/1/MPEG-7%20Video%20Signature%20Author%27s%20Copy.pdf
+ */
+
+#include <float.h>
+#include "libavcodec/put_bits.h"
+#include "libavformat/avformat.h"
+#include "libavutil/opt.h"
+#include "libavutil/avstring.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/timestamp.h"
+#include "avfilter.h"
+#include "internal.h"
+#include "signature.h"
+#include "signature_lookup.c"
+
+#define OFFSET(x) offsetof(SignatureContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
+#define BLOCK_LCM (int64_t) 476985600
+
+static const AVOption signature_options[] = {
+    { "detectmode", "set the detectmode",
+        OFFSET(mode),         AV_OPT_TYPE_INT,    {.i64 = MODE_OFF}, 0, NB_LOOKUP_MODE-1, FLAGS, "mode" },
+        { "off",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = MODE_OFF},  0, 0, .flags = FLAGS, "mode" },
+        { "full", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = MODE_FULL}, 0, 0, .flags = FLAGS, "mode" },
+        { "fast", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = MODE_FAST}, 0, 0, .flags = FLAGS, "mode" },
+    { "nb_inputs",  "number of inputs",
+        OFFSET(nb_inputs),    AV_OPT_TYPE_INT,    {.i64 = 1},        1, INT_MAX,          FLAGS },
+    { "filename",   "filename for output files",
+        OFFSET(filename),     AV_OPT_TYPE_STRING, {.str = ""},       0, NB_FORMATS-1,     FLAGS },
+    { "format",     "set output format",
+        OFFSET(format),       AV_OPT_TYPE_INT,    {.i64 = FORMAT_BINARY}, 0, 1,           FLAGS , "format" },
+        { "binary", 0, 0, AV_OPT_TYPE_CONST, {.i64=FORMAT_BINARY}, 0, 0, FLAGS, "format" },
+        { "xml",    0, 0, AV_OPT_TYPE_CONST, {.i64=FORMAT_XML},    0, 0, FLAGS, "format" },
+    { "th_d",       "threshold to detect one word as similar",
+        OFFSET(thworddist),   AV_OPT_TYPE_INT,    {.i64 = 9000},     1, INT_MAX,          FLAGS },
+    { "th_dc",      "threshold to detect all words as similar",
+        OFFSET(thcomposdist), AV_OPT_TYPE_INT,    {.i64 = 60000},    1, INT_MAX,          FLAGS },
+    { "th_xh",      "threshold to detect frames as similar",
+        OFFSET(thl1),         AV_OPT_TYPE_INT,    {.i64 = 116},      1, INT_MAX,          FLAGS },
+    { "th_di",      "minimum length of matching sequence in frames",
+        OFFSET(thdi),         AV_OPT_TYPE_INT,    {.i64 = 0},        0, INT_MAX,          FLAGS },
+    { "th_it",      "threshold for relation of good to all frames",
+        OFFSET(thit),         AV_OPT_TYPE_DOUBLE, {.dbl = 0.5},    0.0, 1.0,              FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(signature);
+
+static int query_formats(AVFilterContext *ctx)
+{
+    /* all formats with a separate gray value */
+    static const enum AVPixelFormat pix_fmts[] = {
+        AV_PIX_FMT_GRAY8,
+        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
+        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
+        AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
+        AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P,
+        AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
+        AV_PIX_FMT_YUVJ440P,
+        AV_PIX_FMT_NV12, AV_PIX_FMT_NV21,
+        AV_PIX_FMT_NONE
+    };
+
+    return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    SignatureContext *sic = ctx->priv;
+    StreamContext *sc = &(sic->streamcontexts[FF_INLINK_IDX(inlink)]);
+
+    sc->time_base = inlink->time_base;
+    /* test for overflow */
+    sc->divide = (((uint64_t) inlink->w/32) * (inlink->w/32 + 1) * (inlink->h/32 * inlink->h/32 + 1) > INT64_MAX / (BLOCK_LCM * 255));
+    if (sc->divide) {
+        av_log(ctx, AV_LOG_WARNING, "Input dimension too high for precise calculation, numbers will be rounded.\n");
+    }
+    sc->w = inlink->w;
+    sc->h = inlink->h;
+    return 0;
+}
+
+static int get_block_size(const Block *b)
+{
+    return (b->to.y - b->up.y + 1) * (b->to.x - b->up.x + 1);
+}
+
+static uint64_t get_block_sum(StreamContext *sc, uint64_t intpic[32][32], const Block *b)
+{
+    uint64_t sum = 0;
+
+    int x0, y0, x1, y1;
+
+    x0 = b->up.x;
+    y0 = b->up.y;
+    x1 = b->to.x;
+    y1 = b->to.y;
+
+    if (x0-1 >= 0 && y0-1 >= 0) {
+        sum = intpic[y1][x1] + intpic[y0-1][x0-1] - intpic[y1][x0-1] - intpic[y0-1][x1];
+    } else if (x0-1 >= 0) {
+        sum = intpic[y1][x1] - intpic[y1][x0-1];
+    } else if (y0-1 >= 0) {
+        sum = intpic[y1][x1] - intpic[y0-1][x1];
+    } else {
+        sum = intpic[y1][x1];
+    }
+    return sum;
+}
+
+static int cmp(const uint64_t *a, const uint64_t *b)
+{
+    return *a < *b ? -1 : ( *a > *b ? 1 : 0 );
+}
+
+/**
+ * sets the bit at position pos to 1 in data
+ */
+static void set_bit(uint8_t* data, size_t pos)
+{
+    uint8_t mask = 1 << 7-(pos%8);
+    data[pos/8] |= mask;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
+{
+    AVFilterContext *ctx = inlink->dst;
+    SignatureContext *sic = ctx->priv;
+    StreamContext *sc = &(sic->streamcontexts[FF_INLINK_IDX(inlink)]);
+    FineSignature* fs;
+
+    static const uint8_t pot3[5] = { 3*3*3*3, 3*3*3, 3*3, 3, 1 };
+    /* indexes of words : 210,217,219,274,334  44,175,233,270,273  57,70,103,237,269  100,285,295,337,354  101,102,111,275,296
+    s2usw = sorted to unsorted wordvec: 44 is at index 5, 57 at index 10...
+    */
+    static const unsigned int wordvec[25] = {44,57,70,100,101,102,103,111,175,210,217,219,233,237,269,270,273,274,275,285,295,296,334,337,354};
+    static const uint8_t      s2usw[25]   = { 5,10,11, 15, 20, 21, 12, 22,  6,  0,  1,  2,  7, 13, 14,  8,  9,  3, 23, 16, 17, 24,  4, 18, 19};
+
+    uint8_t wordt2b[5] = { 0, 0, 0, 0, 0 }; /* word ternary to binary */
+    uint64_t intpic[32][32];
+    uint64_t rowcount;
+    uint8_t *p = picref->data[0];
+    int inti, intj;
+    int *intjlut;
+
+    uint64_t conflist[DIFFELEM_SIZE];
+    int f = 0, g = 0, w = 0;
+    int32_t dh1 = 1, dh2 = 1, dw1 = 1, dw2 = 1, a, b;
+    int64_t denom;
+    int i, j, k, ternary;
+    uint64_t blocksum;
+    int blocksize;
+    int64_t th; /* threshold */
+    int64_t sum;
+
+    int64_t precfactor = (sc->divide) ? 65536 : BLOCK_LCM;
+
+    /* initialize fs */
+    if (sc->curfinesig) {
+        fs = av_mallocz(sizeof(FineSignature));
+        if (!fs)
+            return AVERROR(ENOMEM);
+        sc->curfinesig->next = fs;
+        fs->prev = sc->curfinesig;
+        sc->curfinesig = fs;
+    } else {
+        fs = sc->curfinesig = sc->finesiglist;
+        sc->curcoarsesig1->first = fs;
+    }
+
+    fs->pts = picref->pts;
+    fs->index = sc->lastindex++;
+
+    memset(intpic, 0, sizeof(uint64_t)*32*32);
+    intjlut = av_malloc_array(inlink->w, sizeof(int));
+    if (!intjlut)
+        return AVERROR(ENOMEM);
+    for (i = 0; i < inlink->w; i++) {
+        intjlut[i] = (i*32)/inlink->w;
+    }
+
+    for (i = 0; i < inlink->h; i++) {
+        inti = (i*32)/inlink->h;
+        for (j = 0; j < inlink->w; j++) {
+            intj = intjlut[j];
+            intpic[inti][intj] += p[j];
+        }
+        p += picref->linesize[0];
+    }
+    av_freep(&intjlut);
+
+    /* The following calculates a summed area table (intpic) and brings the numbers
+     * in intpic to the same denominator.
+     * So you only have to handle the numinator in the following sections.
+     */
+    dh1 = inlink->h / 32;
+    if (inlink->h % 32)
+        dh2 = dh1 + 1;
+    dw1 = inlink->w / 32;
+    if (inlink->w % 32)
+        dw2 = dw1 + 1;
+    denom = (sc->divide) ? dh1 * dh2 * dw1 * dw2 : 1;
+
+    for (i = 0; i < 32; i++) {
+        rowcount = 0;
+        a = 1;
+        if (dh2 > 1) {
+            a = ((inlink->h*(i+1))%32 == 0) ? (inlink->h*(i+1))/32 - 1 : (inlink->h*(i+1))/32;
+            a -= ((inlink->h*i)%32 == 0) ? (inlink->h*i)/32 - 1 : (inlink->h*i)/32;
+            a = (a == dh1)? dh2 : dh1;
+        }
+        for (j = 0; j < 32; j++) {
+            b = 1;
+            if (dw2 > 1) {
+                b = ((inlink->w*(j+1))%32 == 0) ? (inlink->w*(j+1))/32 - 1 : (inlink->w*(j+1))/32;
+                b -= ((inlink->w*j)%32 == 0) ? (inlink->w*j)/32 - 1 : (inlink->w*j)/32;
+                b = (b == dw1)? dw2 : dw1;
+            }
+            rowcount += intpic[i][j] * a * b * precfactor / denom;
+            if (i > 0) {
+                intpic[i][j] = intpic[i-1][j] + rowcount;
+            } else {
+                intpic[i][j] = rowcount;
+            }
+        }
+    }
+
+    denom = (sc->divide) ? 1 : dh1 * dh2 * dw1 * dw2;
+
+    for (i = 0; i < ELEMENT_COUNT; i++) {
+        const ElemCat* elemcat = elements[i];
+        int64_t* elemsignature;
+        uint64_t* sortsignature;
+
+        elemsignature = av_malloc_array(elemcat->elem_count, sizeof(int64_t));
+        if (!elemsignature)
+            return AVERROR(ENOMEM);
+        sortsignature = av_malloc_array(elemcat->elem_count, sizeof(int64_t));
+        if (!sortsignature) {
+            av_freep(&elemsignature);
+            return AVERROR(ENOMEM);
+        }
+
+        for (j = 0; j < elemcat->elem_count; j++) {
+            blocksum = 0;
+            blocksize = 0;
+            for (k = 0; k < elemcat->left_count; k++) {
+                blocksum += get_block_sum(sc, intpic, &elemcat->blocks[j*elemcat->block_count+k]);
+                blocksize += get_block_size(&elemcat->blocks[j*elemcat->block_count+k]);
+            }
+            sum = blocksum / blocksize;
+            if (elemcat->av_elem) {
+                sum -= 128 * precfactor * denom;
+            } else {
+                blocksum = 0;
+                blocksize = 0;
+                for (; k < elemcat->block_count; k++) {
+                    blocksum += get_block_sum(sc, intpic, &elemcat->blocks[j*elemcat->block_count+k]);
+                    blocksize += get_block_size(&elemcat->blocks[j*elemcat->block_count+k]);
+                }
+                sum -= blocksum / blocksize;
+                conflist[g++] = FFABS(sum * 8 / (precfactor * denom));
+            }
+
+            elemsignature[j] = sum;
+            sortsignature[j] = FFABS(sum);
+        }
+
+        /* get threshold */
+        qsort(sortsignature, elemcat->elem_count, sizeof(uint64_t), (void*) cmp);
+        th = sortsignature[(int) (elemcat->elem_count*0.333)];
+
+        /* ternarize */
+        for (j = 0; j < elemcat->elem_count; j++) {
+            if (elemsignature[j] < -th) {
+                ternary = 0;
+            } else if (elemsignature[j] <= th) {
+                ternary = 1;
+            } else {
+                ternary = 2;
+            }
+            fs->framesig[f/5] += ternary * pot3[f%5];
+
+            if (f == wordvec[w]) {
+                fs->words[s2usw[w]/5] += ternary * pot3[wordt2b[s2usw[w]/5]++];
+                if (w < 24)
+                    w++;
+            }
+            f++;
+        }
+        av_freep(&elemsignature);
+        av_freep(&sortsignature);
+    }
+
+    /* confidence */
+    qsort(conflist, DIFFELEM_SIZE, sizeof(uint64_t), (void*) cmp);
+    fs->confidence = FFMIN(conflist[DIFFELEM_SIZE/2], 255);
+
+    /* coarsesignature */
+    if (sc->coarsecount == 0) {
+        if (sc->curcoarsesig2) {
+            sc->curcoarsesig1 = av_mallocz(sizeof(CoarseSignature));
+            if (!sc->curcoarsesig1)
+                return AVERROR(ENOMEM);
+            sc->curcoarsesig1->first = fs;
+            sc->curcoarsesig2->next = sc->curcoarsesig1;
+            sc->coarseend = sc->curcoarsesig1;
+        }
+    }
+    if (sc->coarsecount == 45) {
+        sc->midcoarse = 1;
+        sc->curcoarsesig2 = av_mallocz(sizeof(CoarseSignature));
+        if (!sc->curcoarsesig2)
+            return AVERROR(ENOMEM);
+        sc->curcoarsesig2->first = fs;
+        sc->curcoarsesig1->next = sc->curcoarsesig2;
+        sc->coarseend = sc->curcoarsesig2;
+    }
+    for (i = 0; i < 5; i++) {
+        set_bit(sc->curcoarsesig1->data[i], fs->words[i]);
+    }
+    /* assuming the actual frame is the last */
+    sc->curcoarsesig1->last = fs;
+    if (sc->midcoarse) {
+        for (i = 0; i < 5; i++) {
+            set_bit(sc->curcoarsesig2->data[i], fs->words[i]);
+        }
+        sc->curcoarsesig2->last = fs;
+    }
+
+    sc->coarsecount = (sc->coarsecount+1)%90;
+
+    /* debug printing finesignature */
+    if (av_log_get_level() == AV_LOG_DEBUG) {
+        av_log(ctx, AV_LOG_DEBUG, "input %d, confidence: %d\n", FF_INLINK_IDX(inlink), fs->confidence);
+
+        av_log(ctx, AV_LOG_DEBUG, "words:");
+        for (i = 0; i < 5; i++) {
+            av_log(ctx, AV_LOG_DEBUG, " %d:", fs->words[i] );
+            av_log(ctx, AV_LOG_DEBUG, " %d", fs->words[i] / pot3[0] );
+            for (j = 1; j < 5; j++)
+                av_log(ctx, AV_LOG_DEBUG, ",%d", fs->words[i] % pot3[j-1] / pot3[j] );
+            av_log(ctx, AV_LOG_DEBUG, ";");
+        }
+        av_log(ctx, AV_LOG_DEBUG, "\n");
+
+        av_log(ctx, AV_LOG_DEBUG, "framesignature:");
+        for (i = 0; i < SIGELEM_SIZE/5; i++) {
+            av_log(ctx, AV_LOG_DEBUG, " %d", fs->framesig[i] / pot3[0] );
+            for (j = 1; j < 5; j++)
+                av_log(ctx, AV_LOG_DEBUG, ",%d", fs->framesig[i] % pot3[j-1] / pot3[j] );
+        }
+        av_log(ctx, AV_LOG_DEBUG, "\n");
+    }
+
+    if (FF_INLINK_IDX(inlink) == 0)
+        return ff_filter_frame(inlink->dst->outputs[0], picref);
+    return 1;
+}
+
+static int xml_export(AVFilterContext *ctx, StreamContext *sc, const char* filename)
+{
+    FineSignature* fs;
+    CoarseSignature* cs;
+    int i, j;
+    FILE* f;
+    unsigned int pot3[5] = { 3*3*3*3, 3*3*3, 3*3, 3, 1 };
+
+    f = fopen(filename, "w");
+    if (!f) {
+        int err = AVERROR(EINVAL);
+        char buf[128];
+        av_strerror(err, buf, sizeof(buf));
+        av_log(ctx, AV_LOG_ERROR, "cannot open xml file %s: %s\n", filename, buf);
+        return err;
+    }
+
+    /* header */
+    fprintf(f, "<?xml version='1.0' encoding='ASCII' ?>\n");
+    fprintf(f, "<Mpeg7 xmlns=\"urn:mpeg:mpeg7:schema:2001\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"urn:mpeg:mpeg7:schema:2001 schema/Mpeg7-2001.xsd\">\n");
+    fprintf(f, "  <DescriptionUnit xsi:type=\"DescriptorCollectionType\">\n");
+    fprintf(f, "    <Descriptor xsi:type=\"VideoSignatureType\">\n");
+    fprintf(f, "      <VideoSignatureRegion>\n");
+    fprintf(f, "        <VideoSignatureSpatialRegion>\n");
+    fprintf(f, "          <Pixel>0 0 </Pixel>\n");
+    fprintf(f, "          <Pixel>%d %d </Pixel>\n", sc->w - 1, sc->h - 1);
+    fprintf(f, "        </VideoSignatureSpatialRegion>\n");
+    fprintf(f, "        <StartFrameOfSpatialRegion>0</StartFrameOfSpatialRegion>\n");
+    /* hoping num is 1, other values are vague */
+    fprintf(f, "        <MediaTimeUnit>%d</MediaTimeUnit>\n", sc->time_base.den / sc->time_base.num);
+    fprintf(f, "        <MediaTimeOfSpatialRegion>\n");
+    fprintf(f, "          <StartMediaTimeOfSpatialRegion>0</StartMediaTimeOfSpatialRegion>\n");
+    fprintf(f, "          <EndMediaTimeOfSpatialRegion>%" PRIu64 "</EndMediaTimeOfSpatialRegion>\n", sc->coarseend->last->pts);
+    fprintf(f, "        </MediaTimeOfSpatialRegion>\n");
+
+    /* coarsesignatures */
+    for (cs = sc->coarsesiglist; cs; cs = cs->next) {
+        fprintf(f, "        <VSVideoSegment>\n");
+        fprintf(f, "          <StartFrameOfSegment>%" PRIu32 "</StartFrameOfSegment>\n", cs->first->index);
+        fprintf(f, "          <EndFrameOfSegment>%" PRIu32 "</EndFrameOfSegment>\n", cs->last->index);
+        fprintf(f, "          <MediaTimeOfSegment>\n");
+        fprintf(f, "            <StartMediaTimeOfSegment>%" PRIu64 "</StartMediaTimeOfSegment>\n", cs->first->pts);
+        fprintf(f, "            <EndMediaTimeOfSegment>%" PRIu64 "</EndMediaTimeOfSegment>\n", cs->last->pts);
+        fprintf(f, "          </MediaTimeOfSegment>\n");
+        for (i = 0; i < 5; i++) {
+            fprintf(f, "          <BagOfWords>");
+            for (j = 0; j < 31; j++) {
+                uint8_t n = cs->data[i][j];
+                if (j < 30) {
+                    fprintf(f, "%d  %d  %d  %d  %d  %d  %d  %d  ", (n & 0x80) >> 7,
+                                                                   (n & 0x40) >> 6,
+                                                                   (n & 0x20) >> 5,
+                                                                   (n & 0x10) >> 4,
+                                                                   (n & 0x08) >> 3,
+                                                                   (n & 0x04) >> 2,
+                                                                   (n & 0x02) >> 1,
+                                                                   (n & 0x01));
+                } else {
+                    /* print only 3 bit in last byte */
+                    fprintf(f, "%d  %d  %d ", (n & 0x80) >> 7,
+                                              (n & 0x40) >> 6,
+                                              (n & 0x20) >> 5);
+                }
+            }
+            fprintf(f, "</BagOfWords>\n");
+        }
+        fprintf(f, "        </VSVideoSegment>\n");
+    }
+
+    /* finesignatures */
+    for (fs = sc->finesiglist; fs; fs = fs->next) {
+        fprintf(f, "        <VideoFrame>\n");
+        fprintf(f, "          <MediaTimeOfFrame>%" PRIu64 "</MediaTimeOfFrame>\n", fs->pts);
+        /* confidence */
+        fprintf(f, "          <FrameConfidence>%d</FrameConfidence>\n", fs->confidence);
+        /* words */
+        fprintf(f, "          <Word>");
+        for (i = 0; i < 5; i++) {
+            fprintf(f, "%d ", fs->words[i]);
+            if (i < 4) {
+                fprintf(f, " ");
+            }
+        }
+        fprintf(f, "</Word>\n");
+        /* framesignature */
+        fprintf(f, "          <FrameSignature>");
+        for (i = 0; i< SIGELEM_SIZE/5; i++) {
+            if (i > 0) {
+                fprintf(f, " ");
+            }
+            fprintf(f, "%d ", fs->framesig[i] / pot3[0]);
+            for (j = 1; j < 5; j++)
+                fprintf(f, " %d ", fs->framesig[i] % pot3[j-1] / pot3[j] );
+        }
+        fprintf(f, "</FrameSignature>\n");
+        fprintf(f, "        </VideoFrame>\n");
+    }
+    fprintf(f, "      </VideoSignatureRegion>\n");
+    fprintf(f, "    </Descriptor>\n");
+    fprintf(f, "  </DescriptionUnit>\n");
+    fprintf(f, "</Mpeg7>\n");
+
+    fclose(f);
+    return 0;
+}
+
+static int binary_export(AVFilterContext *ctx, StreamContext *sc, const char* filename)
+{
+    FILE* f;
+    FineSignature* fs;
+    CoarseSignature* cs;
+    uint32_t numofsegments = (sc->lastindex + 44)/45;
+    int i, j;
+    PutBitContext buf;
+    /* buffer + header + coarsesignatures + finesignature */
+    int len = (512 + 6 * 32 + 3*16 + 2 +
+        numofsegments * (4*32 + 1 + 5*243) +
+        sc->lastindex * (2 + 32 + 6*8 + 608)) / 8;
+    uint8_t* buffer = av_malloc_array(len, sizeof(uint8_t));
+    if (!buffer)
+        return AVERROR(ENOMEM);
+
+    f = fopen(filename, "wb");
+    if (!f) {
+        int err = AVERROR(EINVAL);
+        char buf[128];
+        av_strerror(err, buf, sizeof(buf));
+        av_log(ctx, AV_LOG_ERROR, "cannot open file %s: %s\n", filename, buf);
+        av_freep(&buffer);
+        return err;
+    }
+    init_put_bits(&buf, buffer, len);
+
+    put_bits32(&buf, 1); /* NumOfSpatial Regions, only 1 supported */
+    put_bits(&buf, 1, 1); /* SpatialLocationFlag, always the whole image */
+    put_bits32(&buf, 0); /* PixelX,1 PixelY,1, 0,0 */
+    put_bits(&buf, 16, sc->w-1 & 0xFFFF); /* PixelX,2 */
+    put_bits(&buf, 16, sc->h-1 & 0xFFFF); /* PixelY,2 */
+    put_bits32(&buf, 0); /* StartFrameOfSpatialRegion */
+    put_bits32(&buf, sc->lastindex); /* NumOfFrames */
+    /* hoping num is 1, other values are vague */
+    /* den/num might be greater than 16 bit, so cutting it */
+    put_bits(&buf, 16, 0xFFFF & (sc->time_base.den / sc->time_base.num)); /* MediaTimeUnit */
+    put_bits(&buf, 1, 1); /* MediaTimeFlagOfSpatialRegion */
+    put_bits32(&buf, 0); /* StartMediaTimeOfSpatialRegion */
+    put_bits32(&buf, 0xFFFFFFFF & sc->coarseend->last->pts); /* EndMediaTimeOfSpatialRegion */
+    put_bits32(&buf, numofsegments); /* NumOfSegments */
+    /* coarsesignatures */
+    for (cs = sc->coarsesiglist; cs; cs = cs->next) {
+        put_bits32(&buf, cs->first->index); /* StartFrameOfSegment */
+        put_bits32(&buf, cs->last->index); /* EndFrameOfSegment */
+        put_bits(&buf, 1, 1); /* MediaTimeFlagOfSegment */
+        put_bits32(&buf, 0xFFFFFFFF & cs->first->pts); /* StartMediaTimeOfSegment */
+        put_bits32(&buf, 0xFFFFFFFF & cs->last->pts); /* EndMediaTimeOfSegment */
+        for (i = 0; i < 5; i++) {
+            /* put 243 bits ( = 7 * 32 + 19 = 8 * 28 + 19) into buffer */
+            for (j = 0; j < 30; j++) {
+                put_bits(&buf, 8, cs->data[i][j]);
+            }
+            put_bits(&buf, 3, cs->data[i][30] >> 5);
+        }
+    }
+    /* finesignatures */
+    put_bits(&buf, 1, 0); /* CompressionFlag, only 0 supported */
+    for (fs = sc->finesiglist; fs; fs = fs->next) {
+        put_bits(&buf, 1, 1); /* MediaTimeFlagOfFrame */
+        put_bits32(&buf, 0xFFFFFFFF & fs->pts); /* MediaTimeOfFrame */
+        put_bits(&buf, 8, fs->confidence); /* FrameConfidence */
+        for (i = 0; i < 5; i++) {
+            put_bits(&buf, 8, fs->words[i]); /* Words */
+        }
+        /* framesignature */
+        for (i = 0; i < SIGELEM_SIZE/5; i++) {
+            put_bits(&buf, 8, fs->framesig[i]);
+        }
+    }
+
+    avpriv_align_put_bits(&buf);
+    flush_put_bits(&buf);
+    fwrite(buffer, 1, put_bits_count(&buf)/8, f);
+    fclose(f);
+    av_freep(&buffer);
+    return 0;
+}
+
+static int export(AVFilterContext *ctx, StreamContext *sc, int input)
+{
+    SignatureContext* sic = ctx->priv;
+    char filename[1024];
+
+    if (sic->nb_inputs > 1) {
+        /* error already handled */
+        av_assert0(av_get_frame_filename(filename, sizeof(filename), sic->filename, input) == 0);
+    } else {
+        strcpy(filename, sic->filename);
+    }
+    if (sic->format == FORMAT_XML) {
+        return xml_export(ctx, sc, filename);
+    } else {
+        return binary_export(ctx, sc, filename);
+    }
+}
+
+static int request_frame(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    SignatureContext *sic = ctx->priv;
+    StreamContext *sc, *sc2;
+    MatchingInfo match;
+    int i, j, ret;
+    int lookup = 1; /* indicates wheather EOF of all files is reached */
+
+    /* process all inputs */
+    for (i = 0; i < sic->nb_inputs; i++){
+        sc = &(sic->streamcontexts[i]);
+
+        ret = ff_request_frame(ctx->inputs[i]);
+
+        /* return if unexpected error occurs in input stream */
+        if (ret < 0 && ret != AVERROR_EOF)
+            return ret;
+
+        /* export signature at EOF */
+        if (ret == AVERROR_EOF && !sc->exported) {
+            /* export if wanted */
+            if (strlen(sic->filename) > 0) {
+                if (export(ctx, sc, i) < 0)
+                    return ret;
+            }
+            sc->exported = 1;
+        }
+        lookup &= sc->exported;
+    }
+
+    /* signature lookup */
+    if (lookup && sic->mode != MODE_OFF) {
+        /* iterate over every pair */
+        for (i = 0; i < sic->nb_inputs; i++) {
+            sc = &(sic->streamcontexts[i]);
+            for (j = i+1; j < sic->nb_inputs; j++) {
+                sc2 = &(sic->streamcontexts[j]);
+                match = lookup_signatures(ctx, sic, sc, sc2, sic->mode);
+                if (match.score != 0) {
+                    av_log(ctx, AV_LOG_INFO, "matching of video %d at %f and %d at %f, %d frames matching\n",
+                            i, ((double) match.first->pts * sc->time_base.num) / sc->time_base.den,
+                            j, ((double) match.second->pts * sc2->time_base.num) / sc2->time_base.den,
+                            match.matchframes);
+                    if (match.whole)
+                        av_log(ctx, AV_LOG_INFO, "whole video matching\n");
+                } else {
+                    av_log(ctx, AV_LOG_INFO, "no matching of video %d and %d\n", i, j);
+                }
+            }
+        }
+    }
+
+    return ret;
+}
+
+static av_cold int init(AVFilterContext *ctx)
+{
+
+    SignatureContext *sic = ctx->priv;
+    StreamContext *sc;
+    int i, ret;
+    char tmp[1024];
+
+    sic->streamcontexts = av_mallocz(sic->nb_inputs * sizeof(StreamContext));
+    if (!sic->streamcontexts)
+        return AVERROR(ENOMEM);
+
+    for (i = 0; i < sic->nb_inputs; i++) {
+        AVFilterPad pad = {
+            .type = AVMEDIA_TYPE_VIDEO,
+            .name = av_asprintf("in%d", i),
+            .config_props = config_input,
+            .filter_frame = filter_frame,
+        };
+
+        if (!pad.name)
+            return AVERROR(ENOMEM);
+
+        sc = &(sic->streamcontexts[i]);
+
+        sc->lastindex = 0;
+        sc->finesiglist = av_mallocz(sizeof(FineSignature));
+        if (!sc->finesiglist)
+            return AVERROR(ENOMEM);
+        sc->curfinesig = NULL;
+
+        sc->coarsesiglist = av_mallocz(sizeof(CoarseSignature));
+        if (!sc->coarsesiglist)
+            return AVERROR(ENOMEM);
+        sc->curcoarsesig1 = sc->coarsesiglist;
+        sc->coarseend = sc->coarsesiglist;
+        sc->coarsecount = 0;
+        sc->midcoarse = 0;
+
+        if ((ret = ff_insert_inpad(ctx, i, &pad)) < 0) {
+            av_freep(&pad.name);
+            return ret;
+        }
+    }
+
+    /* check filename */
+    if (sic->nb_inputs > 1 && strlen(sic->filename) > 0 && av_get_frame_filename(tmp, sizeof(tmp), sic->filename, 0) == -1) {
+        av_log(ctx, AV_LOG_ERROR, "The filename must contain %%d or %%0nd, if you have more than one input.\n");
+        return AVERROR(EINVAL);
+    }
+
+    return 0;
+}
+
+
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    SignatureContext *sic = ctx->priv;
+    StreamContext *sc;
+    void* tmp;
+    FineSignature* finsig;
+    CoarseSignature* cousig;
+    int i;
+
+
+    /* free the lists */
+    if (sic->streamcontexts != NULL) {
+        for (i = 0; i < sic->nb_inputs; i++) {
+            sc = &(sic->streamcontexts[i]);
+            finsig = sc->finesiglist;
+            cousig = sc->coarsesiglist;
+
+            while (finsig) {
+                tmp = finsig;
+                finsig = finsig->next;
+                av_freep(&tmp);
+            }
+            sc->finesiglist = NULL;
+
+            while (cousig) {
+                tmp = cousig;
+                cousig = cousig->next;
+                av_freep(&tmp);
+            }
+            sc->coarsesiglist = NULL;
+        }
+        av_freep(&sic->streamcontexts);
+    }
+}
+
+static int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    AVFilterLink *inlink = ctx->inputs[0];
+
+    outlink->time_base = inlink->time_base;
+    outlink->frame_rate = inlink->frame_rate;
+    outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
+    outlink->w = inlink->w;
+    outlink->h = inlink->h;
+
+    return 0;
+}
+
+static const AVFilterPad signature_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .request_frame = request_frame,
+        .config_props  = config_output,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_signature = {
+    .name          = "signature",
+    .description   = NULL_IF_CONFIG_SMALL("Calculate the MPEG-7 video signature"),
+    .priv_size     = sizeof(SignatureContext),
+    .priv_class    = &signature_class,
+    .init          = init,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .outputs       = signature_outputs,
+    .inputs        = NULL,
+    .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_smartblur.c b/mythtv/external/FFmpeg/libavfilter/vf_smartblur.c
index 117e0ec6018..1955ac43d89 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_smartblur.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_smartblur.c
@@ -42,7 +42,7 @@
 #define THRESHOLD_MIN -30
 #define THRESHOLD_MAX 30
 
-typedef struct {
+typedef struct FilterParam {
     float              radius;
     float              strength;
     int                threshold;
@@ -50,7 +50,7 @@ typedef struct {
     struct SwsContext *filter_context;
 } FilterParam;
 
-typedef struct {
+typedef struct SmartblurContext {
     const AVClass *class;
     FilterParam  luma;
     FilterParam  chroma;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_spp.h b/mythtv/external/FFmpeg/libavfilter/vf_spp.h
index 6b70a91770e..c03073a4e17 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_spp.h
+++ b/mythtv/external/FFmpeg/libavfilter/vf_spp.h
@@ -28,7 +28,7 @@
 
 #define MAX_LEVEL 6 /* quality levels */
 
-typedef struct {
+typedef struct SPPContext {
     const AVClass *av_class;
 
     int log2_count;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_ssim.c b/mythtv/external/FFmpeg/libavfilter/vf_ssim.c
index dd8f264812f..4dcdc0548b1 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_ssim.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_ssim.c
@@ -38,19 +38,20 @@
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
-#include "dualinput.h"
 #include "drawutils.h"
 #include "formats.h"
+#include "framesync.h"
 #include "internal.h"
 #include "ssim.h"
 #include "video.h"
 
 typedef struct SSIMContext {
     const AVClass *class;
-    FFDualInputContext dinput;
+    FFFrameSync fs;
     FILE *stats_file;
     char *stats_file_str;
     int nb_components;
+    int max;
     uint64_t nb_frames;
     double ssim[4], ssim_total;
     char comps[4];
@@ -60,6 +61,11 @@ typedef struct SSIMContext {
     int planeheight[4];
     int *temp;
     int is_rgb;
+    float (*ssim_plane)(SSIMDSPContext *dsp,
+                        uint8_t *main, int main_stride,
+                        uint8_t *ref, int ref_stride,
+                        int width, int height, void *temp,
+                        int max);
     SSIMDSPContext dsp;
 } SSIMContext;
 
@@ -72,7 +78,7 @@ static const AVOption ssim_options[] = {
     { NULL }
 };
 
-AVFILTER_DEFINE_CLASS(ssim);
+FRAMESYNC_DEFINE_CLASS(ssim, SSIMContext, fs);
 
 static void set_meta(AVDictionary **metadata, const char *key, char comp, float d)
 {
@@ -87,9 +93,45 @@ static void set_meta(AVDictionary **metadata, const char *key, char comp, float
     }
 }
 
-static void ssim_4x4xn(const uint8_t *main, ptrdiff_t main_stride,
-                       const uint8_t *ref, ptrdiff_t ref_stride,
-                       int (*sums)[4], int width)
+static void ssim_4x4xn_16bit(const uint8_t *main8, ptrdiff_t main_stride,
+                             const uint8_t *ref8, ptrdiff_t ref_stride,
+                             int64_t (*sums)[4], int width)
+{
+    const uint16_t *main16 = (const uint16_t *)main8;
+    const uint16_t *ref16  = (const uint16_t *)ref8;
+    int x, y, z;
+
+    main_stride >>= 1;
+    ref_stride >>= 1;
+
+    for (z = 0; z < width; z++) {
+        uint64_t s1 = 0, s2 = 0, ss = 0, s12 = 0;
+
+        for (y = 0; y < 4; y++) {
+            for (x = 0; x < 4; x++) {
+                unsigned a = main16[x + y * main_stride];
+                unsigned b = ref16[x + y * ref_stride];
+
+                s1  += a;
+                s2  += b;
+                ss  += a*a;
+                ss  += b*b;
+                s12 += a*b;
+            }
+        }
+
+        sums[z][0] = s1;
+        sums[z][1] = s2;
+        sums[z][2] = ss;
+        sums[z][3] = s12;
+        main16 += 4;
+        ref16 += 4;
+    }
+}
+
+static void ssim_4x4xn_8bit(const uint8_t *main, ptrdiff_t main_stride,
+                            const uint8_t *ref, ptrdiff_t ref_stride,
+                            int (*sums)[4], int width)
 {
     int x, y, z;
 
@@ -118,6 +160,22 @@ static void ssim_4x4xn(const uint8_t *main, ptrdiff_t main_stride,
     }
 }
 
+static float ssim_end1x(int64_t s1, int64_t s2, int64_t ss, int64_t s12, int max)
+{
+    int64_t ssim_c1 = (int64_t)(.01*.01*max*max*64 + .5);
+    int64_t ssim_c2 = (int64_t)(.03*.03*max*max*64*63 + .5);
+
+    int64_t fs1 = s1;
+    int64_t fs2 = s2;
+    int64_t fss = ss;
+    int64_t fs12 = s12;
+    int64_t vars = fss * 64 - fs1 * fs1 - fs2 * fs2;
+    int64_t covar = fs12 * 64 - fs1 * fs2;
+
+    return (float)(2 * fs1 * fs2 + ssim_c1) * (float)(2 * covar + ssim_c2)
+         / ((float)(fs1 * fs1 + fs2 * fs2 + ssim_c1) * (float)(vars + ssim_c2));
+}
+
 static float ssim_end1(int s1, int s2, int ss, int s12)
 {
     static const int ssim_c1 = (int)(.01*.01*255*255*64 + .5);
@@ -134,7 +192,21 @@ static float ssim_end1(int s1, int s2, int ss, int s12)
          / ((float)(fs1 * fs1 + fs2 * fs2 + ssim_c1) * (float)(vars + ssim_c2));
 }
 
-static float ssim_endn(const int (*sum0)[4], const int (*sum1)[4], int width)
+static float ssim_endn_16bit(const int64_t (*sum0)[4], const int64_t (*sum1)[4], int width, int max)
+{
+    float ssim = 0.0;
+    int i;
+
+    for (i = 0; i < width; i++)
+        ssim += ssim_end1x(sum0[i][0] + sum0[i + 1][0] + sum1[i][0] + sum1[i + 1][0],
+                           sum0[i][1] + sum0[i + 1][1] + sum1[i][1] + sum1[i + 1][1],
+                           sum0[i][2] + sum0[i + 1][2] + sum1[i][2] + sum1[i + 1][2],
+                           sum0[i][3] + sum0[i + 1][3] + sum1[i][3] + sum1[i + 1][3],
+                           max);
+    return ssim;
+}
+
+static float ssim_endn_8bit(const int (*sum0)[4], const int (*sum1)[4], int width)
 {
     float ssim = 0.0;
     int i;
@@ -147,15 +219,46 @@ static float ssim_endn(const int (*sum0)[4], const int (*sum1)[4], int width)
     return ssim;
 }
 
+#define SUM_LEN(w) (((w) >> 2) + 3)
+
+static float ssim_plane_16bit(SSIMDSPContext *dsp,
+                              uint8_t *main, int main_stride,
+                              uint8_t *ref, int ref_stride,
+                              int width, int height, void *temp,
+                              int max)
+{
+    int z = 0, y;
+    float ssim = 0.0;
+    int64_t (*sum0)[4] = temp;
+    int64_t (*sum1)[4] = sum0 + SUM_LEN(width);
+
+    width >>= 2;
+    height >>= 2;
+
+    for (y = 1; y < height; y++) {
+        for (; z <= y; z++) {
+            FFSWAP(void*, sum0, sum1);
+            ssim_4x4xn_16bit(&main[4 * z * main_stride], main_stride,
+                             &ref[4 * z * ref_stride], ref_stride,
+                             sum0, width);
+        }
+
+        ssim += ssim_endn_16bit((const int64_t (*)[4])sum0, (const int64_t (*)[4])sum1, width - 1, max);
+    }
+
+    return ssim / ((height - 1) * (width - 1));
+}
+
 static float ssim_plane(SSIMDSPContext *dsp,
                         uint8_t *main, int main_stride,
                         uint8_t *ref, int ref_stride,
-                        int width, int height, void *temp)
+                        int width, int height, void *temp,
+                        int max)
 {
     int z = 0, y;
     float ssim = 0.0;
     int (*sum0)[4] = temp;
-    int (*sum1)[4] = sum0 + (width >> 2) + 3;
+    int (*sum1)[4] = sum0 + SUM_LEN(width);
 
     width >>= 2;
     height >>= 2;
@@ -179,20 +282,29 @@ static double ssim_db(double ssim, double weight)
     return 10 * log10(weight / (weight - ssim));
 }
 
-static AVFrame *do_ssim(AVFilterContext *ctx, AVFrame *main,
-                        const AVFrame *ref)
+static int do_ssim(FFFrameSync *fs)
 {
-    AVDictionary **metadata = avpriv_frame_get_metadatap(main);
+    AVFilterContext *ctx = fs->parent;
     SSIMContext *s = ctx->priv;
+    AVFrame *master, *ref;
+    AVDictionary **metadata;
     float c[4], ssimv = 0.0;
-    int i;
+    int ret, i;
+
+    ret = ff_framesync_dualinput_get(fs, &master, &ref);
+    if (ret < 0)
+        return ret;
+    if (!ref)
+        return ff_filter_frame(ctx->outputs[0], master);
+    metadata = &master->metadata;
 
     s->nb_frames++;
 
     for (i = 0; i < s->nb_components; i++) {
-        c[i] = ssim_plane(&s->dsp, main->data[i], main->linesize[i],
-                          ref->data[i], ref->linesize[i],
-                          s->planewidth[i], s->planeheight[i], s->temp);
+        c[i] = s->ssim_plane(&s->dsp, master->data[i], master->linesize[i],
+                             ref->data[i], ref->linesize[i],
+                             s->planewidth[i], s->planeheight[i], s->temp,
+                             s->max);
         ssimv += s->coefs[i] * c[i];
         s->ssim[i] += c[i];
     }
@@ -216,7 +328,7 @@ static AVFrame *do_ssim(AVFilterContext *ctx, AVFrame *main,
         fprintf(s->stats_file, "All:%f (%f)\n", ssimv, ssim_db(ssimv, 1.0));
     }
 
-    return main;
+    return ff_filter_frame(ctx->outputs[0], master);
 }
 
 static av_cold int init(AVFilterContext *ctx)
@@ -239,21 +351,22 @@ static av_cold int init(AVFilterContext *ctx)
         }
     }
 
-    s->dinput.process = do_ssim;
-    s->dinput.shortest = 1;
-    s->dinput.repeatlast = 0;
+    s->fs.on_event = do_ssim;
     return 0;
 }
 
 static int query_formats(AVFilterContext *ctx)
 {
     static const enum AVPixelFormat pix_fmts[] = {
-        AV_PIX_FMT_GRAY8,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10,
+        AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
         AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
         AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
         AV_PIX_FMT_GBRP,
+#define PF(suf) AV_PIX_FMT_YUV420##suf,  AV_PIX_FMT_YUV422##suf,  AV_PIX_FMT_YUV444##suf, AV_PIX_FMT_GBR##suf
+        PF(P9), PF(P10), PF(P12), PF(P14), PF(P16),
         AV_PIX_FMT_NONE
     };
 
@@ -297,12 +410,14 @@ static int config_input_ref(AVFilterLink *inlink)
     for (i = 0; i < s->nb_components; i++)
         s->coefs[i] = (double) s->planeheight[i] * s->planewidth[i] / sum;
 
-    s->temp = av_malloc((2 * inlink->w + 12) * sizeof(*s->temp));
+    s->temp = av_mallocz_array(2 * SUM_LEN(inlink->w), (desc->comp[0].depth > 8) ? sizeof(int64_t[4]) : sizeof(int[4]));
     if (!s->temp)
         return AVERROR(ENOMEM);
+    s->max = (1 << desc->comp[0].depth) - 1;
 
-    s->dsp.ssim_4x4_line = ssim_4x4xn;
-    s->dsp.ssim_end_line = ssim_endn;
+    s->ssim_plane = desc->comp[0].depth > 8 ? ssim_plane_16bit : ssim_plane;
+    s->dsp.ssim_4x4_line = ssim_4x4xn_8bit;
+    s->dsp.ssim_end_line = ssim_endn_8bit;
     if (ARCH_X86)
         ff_ssim_init_x86(&s->dsp);
 
@@ -316,28 +431,25 @@ static int config_output(AVFilterLink *outlink)
     AVFilterLink *mainlink = ctx->inputs[0];
     int ret;
 
+    ret = ff_framesync_init_dualinput(&s->fs, ctx);
+    if (ret < 0)
+        return ret;
     outlink->w = mainlink->w;
     outlink->h = mainlink->h;
     outlink->time_base = mainlink->time_base;
     outlink->sample_aspect_ratio = mainlink->sample_aspect_ratio;
     outlink->frame_rate = mainlink->frame_rate;
 
-    if ((ret = ff_dualinput_init(ctx, &s->dinput)) < 0)
+    if ((ret = ff_framesync_configure(&s->fs)) < 0)
         return ret;
 
     return 0;
 }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
+static int activate(AVFilterContext *ctx)
 {
-    SSIMContext *s = inlink->dst->priv;
-    return ff_dualinput_filter_frame(&s->dinput, inlink, buf);
-}
-
-static int request_frame(AVFilterLink *outlink)
-{
-    SSIMContext *s = outlink->src->priv;
-    return ff_dualinput_request_frame(&s->dinput, outlink);
+    SSIMContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
 }
 
 static av_cold void uninit(AVFilterContext *ctx)
@@ -357,7 +469,7 @@ static av_cold void uninit(AVFilterContext *ctx)
                s->ssim_total / s->nb_frames, ssim_db(s->ssim_total, s->nb_frames));
     }
 
-    ff_dualinput_uninit(&s->dinput);
+    ff_framesync_uninit(&s->fs);
 
     if (s->stats_file && s->stats_file != stdout)
         fclose(s->stats_file);
@@ -369,11 +481,9 @@ static const AVFilterPad ssim_inputs[] = {
     {
         .name         = "main",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
     },{
         .name         = "reference",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
         .config_props = config_input_ref,
     },
     { NULL }
@@ -384,7 +494,6 @@ static const AVFilterPad ssim_outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -392,9 +501,11 @@ static const AVFilterPad ssim_outputs[] = {
 AVFilter ff_vf_ssim = {
     .name          = "ssim",
     .description   = NULL_IF_CONFIG_SMALL("Calculate the SSIM between two video streams."),
+    .preinit       = ssim_framesync_preinit,
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
+    .activate      = activate,
     .priv_size     = sizeof(SSIMContext),
     .priv_class    = &ssim_class,
     .inputs        = ssim_inputs,
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_stack.c b/mythtv/external/FFmpeg/libavfilter/vf_stack.c
index 03643b6f960..2467302159f 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_stack.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_stack.c
@@ -58,12 +58,6 @@ static int query_formats(AVFilterContext *ctx)
     return ff_set_common_formats(ctx, pix_fmts);
 }
 
-static int filter_frame(AVFilterLink *inlink, AVFrame *in)
-{
-    StackContext *s = inlink->dst->priv;
-    return ff_framesync_filter_frame(&s->fs, inlink, in);
-}
-
 static av_cold int init(AVFilterContext *ctx)
 {
     StackContext *s = ctx->priv;
@@ -83,7 +77,6 @@ static av_cold int init(AVFilterContext *ctx)
         pad.name = av_asprintf("input%d", i);
         if (!pad.name)
             return AVERROR(ENOMEM);
-        pad.filter_frame = filter_frame;
 
         if ((ret = ff_insert_inpad(ctx, i, &pad)) < 0) {
             av_freep(&pad.name);
@@ -206,12 +199,6 @@ static int config_output(AVFilterLink *outlink)
     return ff_framesync_configure(&s->fs);
 }
 
-static int request_frame(AVFilterLink *outlink)
-{
-    StackContext *s = outlink->src->priv;
-    return ff_framesync_request_frame(&s->fs, outlink);
-}
-
 static av_cold void uninit(AVFilterContext *ctx)
 {
     StackContext *s = ctx->priv;
@@ -224,6 +211,12 @@ static av_cold void uninit(AVFilterContext *ctx)
         av_freep(&ctx->input_pads[i].name);
 }
 
+static int activate(AVFilterContext *ctx)
+{
+    StackContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
+}
+
 #define OFFSET(x) offsetof(StackContext, x)
 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
 static const AVOption stack_options[] = {
@@ -237,7 +230,6 @@ static const AVFilterPad outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -256,6 +248,7 @@ AVFilter ff_vf_hstack = {
     .outputs       = outputs,
     .init          = init,
     .uninit        = uninit,
+    .activate      = activate,
     .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };
 
@@ -275,6 +268,7 @@ AVFilter ff_vf_vstack = {
     .outputs       = outputs,
     .init          = init,
     .uninit        = uninit,
+    .activate      = activate,
     .flags         = AVFILTER_FLAG_DYNAMIC_INPUTS,
 };
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_stereo3d.c b/mythtv/external/FFmpeg/libavfilter/vf_stereo3d.c
index 3e23890208c..8b22f880ca6 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_stereo3d.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_stereo3d.c
@@ -150,6 +150,7 @@ typedef struct Stereo3DContext {
     AVFrame *prev;
     int blanks;
     int in_off_left[4], in_off_right[4];
+    AVRational aspect;
     Stereo3DDSPContext dsp;
 } Stereo3DContext;
 
@@ -359,11 +360,11 @@ static int config_output(AVFilterLink *outlink)
     AVFilterContext *ctx = outlink->src;
     AVFilterLink *inlink = ctx->inputs[0];
     Stereo3DContext *s = ctx->priv;
-    AVRational aspect = inlink->sample_aspect_ratio;
     AVRational fps = inlink->frame_rate;
     AVRational tb = inlink->time_base;
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
     int ret;
+    s->aspect = inlink->sample_aspect_ratio;
 
     switch (s->in.format) {
     case INTERLEAVE_COLS_LR:
@@ -404,25 +405,25 @@ static int config_output(AVFilterLink *outlink)
 
     switch (s->in.format) {
     case SIDE_BY_SIDE_2_LR:
-        aspect.num     *= 2;
+        s->aspect.num  *= 2;
     case SIDE_BY_SIDE_LR:
         s->width        = inlink->w / 2;
         s->in.off_right = s->width;
         break;
     case SIDE_BY_SIDE_2_RL:
-        aspect.num     *= 2;
+        s->aspect.num  *= 2;
     case SIDE_BY_SIDE_RL:
         s->width        = inlink->w / 2;
         s->in.off_left  = s->width;
         break;
     case ABOVE_BELOW_2_LR:
-        aspect.den     *= 2;
+        s->aspect.den  *= 2;
     case ABOVE_BELOW_LR:
         s->in.row_right =
         s->height       = inlink->h / 2;
         break;
     case ABOVE_BELOW_2_RL:
-        aspect.den     *= 2;
+        s->aspect.den  *= 2;
     case ABOVE_BELOW_RL:
         s->in.row_left  =
         s->height       = inlink->h / 2;
@@ -486,19 +487,19 @@ static int config_output(AVFilterLink *outlink)
         break;
     }
     case SIDE_BY_SIDE_2_LR:
-        aspect.den      *= 2;
+        s->aspect.den   *= 2;
     case SIDE_BY_SIDE_LR:
         s->out.width     = s->width * 2;
         s->out.off_right = s->width;
         break;
     case SIDE_BY_SIDE_2_RL:
-        aspect.den      *= 2;
+        s->aspect.den   *= 2;
     case SIDE_BY_SIDE_RL:
         s->out.width     = s->width * 2;
         s->out.off_left  = s->width;
         break;
     case ABOVE_BELOW_2_LR:
-        aspect.num      *= 2;
+        s->aspect.num   *= 2;
     case ABOVE_BELOW_LR:
         s->out.height    = s->height * 2;
         s->out.row_right = s->height;
@@ -514,7 +515,7 @@ static int config_output(AVFilterLink *outlink)
         s->out.row_right = s->height + s->blanks;
         break;
     case ABOVE_BELOW_2_RL:
-        aspect.num      *= 2;
+        s->aspect.num   *= 2;
     case ABOVE_BELOW_RL:
         s->out.height    = s->height * 2;
         s->out.row_left  = s->height;
@@ -576,7 +577,7 @@ static int config_output(AVFilterLink *outlink)
     outlink->h = s->out.height;
     outlink->frame_rate = fps;
     outlink->time_base = tb;
-    outlink->sample_aspect_ratio = aspect;
+    outlink->sample_aspect_ratio = s->aspect;
 
     if ((ret = av_image_fill_linesizes(s->linesize, outlink->format, s->width)) < 0)
         return ret;
@@ -1075,6 +1076,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
         av_frame_free(&s->prev);
         av_frame_free(&inpicref);
     }
+    out->sample_aspect_ratio = s->aspect;
     return ff_filter_frame(outlink, out);
 }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_subtitles.c b/mythtv/external/FFmpeg/libavfilter/vf_subtitles.c
index 0f22644cc6f..66a564699a0 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_subtitles.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_subtitles.c
@@ -44,7 +44,7 @@
 #include "formats.h"
 #include "video.h"
 
-typedef struct {
+typedef struct AssContext {
     const AVClass *class;
     ASS_Library  *library;
     ASS_Renderer *renderer;
@@ -54,6 +54,7 @@ typedef struct {
     char *charenc;
     char *force_style;
     int stream_index;
+    int alpha;
     uint8_t rgba_map[4];
     int     pix_step[4];       ///< steps per pixel for each plane of the main output
     int original_w, original_h;
@@ -69,6 +70,7 @@ typedef struct {
     {"f",              "set the filename of file to read",                         OFFSET(filename),   AV_OPT_TYPE_STRING,     {.str = NULL},  CHAR_MIN, CHAR_MAX, FLAGS }, \
     {"original_size",  "set the size of the original video (used to scale fonts)", OFFSET(original_w), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL},  CHAR_MIN, CHAR_MAX, FLAGS }, \
     {"fontsdir",       "set the directory containing the fonts to read",           OFFSET(fontsdir),   AV_OPT_TYPE_STRING,     {.str = NULL},  CHAR_MIN, CHAR_MAX, FLAGS }, \
+    {"alpha",          "enable processing of alpha channel",                       OFFSET(alpha),      AV_OPT_TYPE_BOOL,       {.i64 = 0   },         0,        1, FLAGS }, \
 
 /* libass supports a log level ranging from 0 to 7 */
 static const int ass_libavfilter_log_level_map[] = {
@@ -140,7 +142,7 @@ static int config_input(AVFilterLink *inlink)
 {
     AssContext *ass = inlink->dst->priv;
 
-    ff_draw_init(&ass->draw, inlink->format, 0);
+    ff_draw_init(&ass->draw, inlink->format, ass->alpha ? FF_DRAW_PROCESS_ALPHA : 0);
 
     ass_set_frame_size  (ass->renderer, inlink->w, inlink->h);
     if (ass->original_w && ass->original_h)
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_super2xsai.c b/mythtv/external/FFmpeg/libavfilter/vf_super2xsai.c
index cbb3f62414b..87eec04da8d 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_super2xsai.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_super2xsai.c
@@ -33,7 +33,7 @@
 #include "internal.h"
 #include "video.h"
 
-typedef struct {
+typedef struct Super2xSaIContext {
     /* masks used for two pixels interpolation */
     uint32_t hi_pixel_mask;
     uint32_t lo_pixel_mask;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_swaprect.c b/mythtv/external/FFmpeg/libavfilter/vf_swaprect.c
index a46762738a6..f96f8978183 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_swaprect.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_swaprect.c
@@ -97,9 +97,9 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     var_values[VAR_A]   = (float) inlink->w / inlink->h;
     var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ? av_q2d(inlink->sample_aspect_ratio) : 1;
     var_values[VAR_DAR] = var_values[VAR_A] * var_values[VAR_SAR];
-    var_values[VAR_N]   = inlink->frame_count;
+    var_values[VAR_N]   = inlink->frame_count_out;
     var_values[VAR_T]   = in->pts == AV_NOPTS_VALUE ? NAN : in->pts * av_q2d(inlink->time_base);
-    var_values[VAR_POS] = av_frame_get_pkt_pos(in) == -1 ? NAN : av_frame_get_pkt_pos(in);
+    var_values[VAR_POS] = in->pkt_pos ? NAN : in->pkt_pos;
 
     ret = av_expr_parse_and_eval(&dw, s->w,
                                  var_names, &var_values[0],
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_telecine.c b/mythtv/external/FFmpeg/libavfilter/vf_telecine.c
index 58babca9a16..62599a7a3a6 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_telecine.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_telecine.c
@@ -33,7 +33,7 @@
 #include "internal.h"
 #include "video.h"
 
-typedef struct {
+typedef struct TelecineContext {
     const AVClass *class;
     int first_field;
     char *pattern;
@@ -244,7 +244,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
 
         av_frame_copy_props(frame, inpicref);
         frame->pts = ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time) +
-                     av_rescale(outlink->frame_count, s->ts_unit.num,
+                     av_rescale(outlink->frame_count_in, s->ts_unit.num,
                                 s->ts_unit.den);
         ret = ff_filter_frame(outlink, frame);
     }
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_threshold.c b/mythtv/external/FFmpeg/libavfilter/vf_threshold.c
new file mode 100644
index 00000000000..88f6ef28d78
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_threshold.c
@@ -0,0 +1,339 @@
+/*
+ * Copyright (c) 2016 Paul B Mahol
+ *
+ * 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
+ * threshold video filter
+ */
+
+#include "libavutil/imgutils.h"
+#include "libavutil/internal.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "avfilter.h"
+#include "framesync.h"
+#include "internal.h"
+#include "video.h"
+
+typedef struct ThresholdContext {
+    const AVClass *class;
+
+    int planes;
+    int bpc;
+
+    int nb_planes;
+    int width[4], height[4];
+
+    void (*threshold)(const uint8_t *in, const uint8_t *threshold,
+                      const uint8_t *min, const uint8_t *max,
+                      uint8_t *out,
+                      ptrdiff_t ilinesize, ptrdiff_t tlinesize,
+                      ptrdiff_t flinesize, ptrdiff_t slinesize,
+                      ptrdiff_t olinesize,
+                      int w, int h);
+
+    AVFrame *frames[4];
+    FFFrameSync fs;
+} ThresholdContext;
+
+#define OFFSET(x) offsetof(ThresholdContext, x)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+
+static const AVOption threshold_options[] = {
+    { "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT,  {.i64=15}, 0, 15, FLAGS},
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(threshold);
+
+static int query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pix_fmts[] = {
+        AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
+        AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
+        AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
+        AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
+        AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+        AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
+        AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
+        AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
+        AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
+        AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
+        AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
+        AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
+        AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
+        AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12 , AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10,
+        AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY16,
+        AV_PIX_FMT_NONE
+    };
+
+    return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
+}
+
+static int process_frame(FFFrameSync *fs)
+{
+    AVFilterContext *ctx = fs->parent;
+    ThresholdContext *s = fs->opaque;
+    AVFilterLink *outlink = ctx->outputs[0];
+    AVFrame *out, *in, *threshold, *min, *max;
+    int ret;
+
+    if ((ret = ff_framesync_get_frame(&s->fs, 0, &in,        0)) < 0 ||
+        (ret = ff_framesync_get_frame(&s->fs, 1, &threshold, 0)) < 0 ||
+        (ret = ff_framesync_get_frame(&s->fs, 2, &min,       0)) < 0 ||
+        (ret = ff_framesync_get_frame(&s->fs, 3, &max,       0)) < 0)
+        return ret;
+
+    if (ctx->is_disabled) {
+        out = av_frame_clone(in);
+        if (!out)
+            return AVERROR(ENOMEM);
+    } else {
+        int p;
+
+        out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+        if (!out)
+            return AVERROR(ENOMEM);
+        av_frame_copy_props(out, in);
+
+        for (p = 0; p < s->nb_planes; p++) {
+            if (!(s->planes & (1 << p))) {
+                av_image_copy_plane(out->data[p], out->linesize[p],
+                                    in->data[p], in->linesize[p],
+                                    s->width[p] * s->bpc,
+                                    s->height[p]);
+                continue;
+            }
+            s->threshold(in->data[p], threshold->data[p],
+                         min->data[p], max->data[p],
+                         out->data[p],
+                         in->linesize[p], threshold->linesize[p],
+                         min->linesize[p], max->linesize[p],
+                         out->linesize[p],
+                         s->width[p], s->height[p]);
+        }
+    }
+
+    out->pts = av_rescale_q(s->fs.pts, s->fs.time_base, outlink->time_base);
+
+    return ff_filter_frame(outlink, out);
+}
+
+static void threshold8(const uint8_t *in, const uint8_t *threshold,
+                       const uint8_t *min, const uint8_t *max,
+                       uint8_t *out,
+                       ptrdiff_t ilinesize, ptrdiff_t tlinesize,
+                       ptrdiff_t flinesize, ptrdiff_t slinesize,
+                       ptrdiff_t olinesize,
+                       int w, int h)
+{
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            out[x] = in[x] < threshold[x] ? min[x] : max[x];
+        }
+
+        in        += ilinesize;
+        threshold += tlinesize;
+        min       += flinesize;
+        max       += flinesize;
+        out       += olinesize;
+    }
+}
+
+static void threshold16(const uint8_t *iin, const uint8_t *tthreshold,
+                        const uint8_t *ffirst, const uint8_t *ssecond,
+                        uint8_t *oout,
+                        ptrdiff_t ilinesize, ptrdiff_t tlinesize,
+                        ptrdiff_t flinesize, ptrdiff_t slinesize,
+                        ptrdiff_t olinesize,
+                        int w, int h)
+{
+    const uint16_t *in = (const uint16_t *)iin;
+    const uint16_t *threshold = (const uint16_t *)tthreshold;
+    const uint16_t *min = (const uint16_t *)ffirst;
+    const uint16_t *max = (const uint16_t *)ssecond;
+    uint16_t *out = (uint16_t *)oout;
+    int x, y;
+
+    for (y = 0; y < h; y++) {
+        for (x = 0; x < w; x++) {
+            out[x] = in[x] < threshold[x] ? min[x] : max[x];
+        }
+
+        in        += ilinesize / 2;
+        threshold += tlinesize / 2;
+        min       += flinesize / 2;
+        max       += flinesize / 2;
+        out       += olinesize / 2;
+    }
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    ThresholdContext *s = ctx->priv;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    int vsub, hsub;
+
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
+    hsub = desc->log2_chroma_w;
+    vsub = desc->log2_chroma_h;
+    s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
+    s->height[0] = s->height[3] = inlink->h;
+    s->width[1]  = s->width[2]  = AV_CEIL_RSHIFT(inlink->w, hsub);
+    s->width[0]  = s->width[3]  = inlink->w;
+
+    if (desc->comp[0].depth == 8) {
+        s->threshold = threshold8;
+        s->bpc = 1;
+    } else {
+        s->threshold = threshold16;
+        s->bpc = 2;
+    }
+
+    return 0;
+}
+
+static int config_output(AVFilterLink *outlink)
+{
+    AVFilterContext *ctx = outlink->src;
+    ThresholdContext *s = ctx->priv;
+    AVFilterLink *base = ctx->inputs[0];
+    AVFilterLink *threshold = ctx->inputs[1];
+    AVFilterLink *min = ctx->inputs[2];
+    AVFilterLink *max = ctx->inputs[3];
+    FFFrameSyncIn *in;
+    int ret;
+
+    if (base->format != threshold->format ||
+        base->format != min->format ||
+        base->format != max->format) {
+        av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
+        return AVERROR(EINVAL);
+    }
+    if (base->w                       != threshold->w ||
+        base->h                       != threshold->h ||
+        base->w                       != min->w ||
+        base->h                       != min->h ||
+        base->w                       != max->w ||
+        base->h                       != max->h) {
+        av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
+               "(size %dx%d) do not match the corresponding "
+               "second input link %s parameters (%dx%d) "
+               "and/or third input link %s parameters (%dx%d) "
+               "and/or fourth input link %s parameters (%dx%d)\n",
+               ctx->input_pads[0].name, base->w, base->h,
+               ctx->input_pads[1].name, threshold->w, threshold->h,
+               ctx->input_pads[2].name, min->w, min->h,
+               ctx->input_pads[3].name, max->w, max->h);
+        return AVERROR(EINVAL);
+    }
+
+    outlink->w = base->w;
+    outlink->h = base->h;
+    outlink->time_base = base->time_base;
+    outlink->sample_aspect_ratio = base->sample_aspect_ratio;
+    outlink->frame_rate = base->frame_rate;
+
+    if ((ret = ff_framesync_init(&s->fs, ctx, 4)) < 0)
+        return ret;
+
+    in = s->fs.in;
+    in[0].time_base = base->time_base;
+    in[1].time_base = threshold->time_base;
+    in[2].time_base = min->time_base;
+    in[3].time_base = max->time_base;
+    in[0].sync   = 1;
+    in[0].before = EXT_STOP;
+    in[0].after  = EXT_STOP;
+    in[1].sync   = 1;
+    in[1].before = EXT_STOP;
+    in[1].after  = EXT_STOP;
+    in[2].sync   = 1;
+    in[2].before = EXT_STOP;
+    in[2].after  = EXT_STOP;
+    in[3].sync   = 1;
+    in[3].before = EXT_STOP;
+    in[3].after  = EXT_STOP;
+    s->fs.opaque   = s;
+    s->fs.on_event = process_frame;
+
+    return ff_framesync_configure(&s->fs);
+}
+
+static int activate(AVFilterContext *ctx)
+{
+    ThresholdContext *s = ctx->priv;
+    return ff_framesync_activate(&s->fs);
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    ThresholdContext *s = ctx->priv;
+
+    ff_framesync_uninit(&s->fs);
+}
+
+static const AVFilterPad inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = config_input,
+    },
+    {
+        .name         = "threshold",
+        .type         = AVMEDIA_TYPE_VIDEO,
+    },
+    {
+        .name         = "min",
+        .type         = AVMEDIA_TYPE_VIDEO,
+    },
+    {
+        .name         = "max",
+        .type         = AVMEDIA_TYPE_VIDEO,
+    },
+    { NULL }
+};
+
+static const AVFilterPad outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .config_props  = config_output,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_threshold = {
+    .name          = "threshold",
+    .description   = NULL_IF_CONFIG_SMALL("Threshold first video stream using other video streams."),
+    .priv_size     = sizeof(ThresholdContext),
+    .priv_class    = &threshold_class,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .activate      = activate,
+    .inputs        = inputs,
+    .outputs       = outputs,
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_thumbnail.c b/mythtv/external/FFmpeg/libavfilter/vf_thumbnail.c
index 417ccd56d09..0effdc91e9a 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_thumbnail.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_thumbnail.c
@@ -38,7 +38,7 @@ struct thumb_frame {
     int histogram[HIST_SIZE];   ///< RGB color distribution histogram of the frame
 };
 
-typedef struct {
+typedef struct ThumbContext {
     const AVClass *class;
     int n;                      ///< current frame
     int n_frames;               ///< number of frames for analysis
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_thumbnail_cuda.c b/mythtv/external/FFmpeg/libavfilter/vf_thumbnail_cuda.c
new file mode 100644
index 00000000000..09377ca7f40
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_thumbnail_cuda.c
@@ -0,0 +1,445 @@
+/*
+* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+* DEALINGS IN THE SOFTWARE.
+*/
+
+#include <cuda.h>
+
+#include "libavutil/hwcontext.h"
+#include "libavutil/hwcontext_cuda_internal.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+
+#include "avfilter.h"
+#include "internal.h"
+
+#define HIST_SIZE (3*256)
+#define DIV_UP(a, b) ( ((a) + (b) - 1) / (b) )
+#define BLOCKX 32
+#define BLOCKY 16
+
+static const enum AVPixelFormat supported_formats[] = {
+    AV_PIX_FMT_NV12,
+    AV_PIX_FMT_YUV420P,
+    AV_PIX_FMT_YUV444P,
+    AV_PIX_FMT_P010,
+    AV_PIX_FMT_P016,
+    AV_PIX_FMT_YUV444P16,
+};
+
+struct thumb_frame {
+    AVFrame *buf;               ///< cached frame
+    int histogram[HIST_SIZE];   ///< RGB color distribution histogram of the frame
+};
+
+typedef struct ThumbnailCudaContext {
+    const AVClass *class;
+    int n;                      ///< current frame
+    int n_frames;               ///< number of frames for analysis
+    struct thumb_frame *frames; ///< the n_frames frames
+    AVRational tb;              ///< copy of the input timebase to ease access
+
+    AVBufferRef *hw_frames_ctx;
+
+    CUmodule    cu_module;
+
+    CUfunction  cu_func_uchar;
+    CUfunction  cu_func_uchar2;
+    CUfunction  cu_func_ushort;
+    CUfunction  cu_func_ushort2;
+    CUtexref    cu_tex_uchar;
+    CUtexref    cu_tex_uchar2;
+    CUtexref    cu_tex_ushort;
+    CUtexref    cu_tex_ushort2;
+
+    CUdeviceptr data;
+} ThumbnailCudaContext;
+
+#define OFFSET(x) offsetof(ThumbnailCudaContext, x)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+
+static const AVOption thumbnail_cuda_options[] = {
+    { "n", "set the frames batch size", OFFSET(n_frames), AV_OPT_TYPE_INT, {.i64=100}, 2, INT_MAX, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(thumbnail_cuda);
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    ThumbnailCudaContext *s = ctx->priv;
+
+    s->frames = av_calloc(s->n_frames, sizeof(*s->frames));
+    if (!s->frames) {
+        av_log(ctx, AV_LOG_ERROR,
+               "Allocation failure, try to lower the number of frames\n");
+        return AVERROR(ENOMEM);
+    }
+    av_log(ctx, AV_LOG_VERBOSE, "batch size: %d frames\n", s->n_frames);
+    return 0;
+}
+
+/**
+ * @brief        Compute Sum-square deviation to estimate "closeness".
+ * @param hist   color distribution histogram
+ * @param median average color distribution histogram
+ * @return       sum of squared errors
+ */
+static double frame_sum_square_err(const int *hist, const double *median)
+{
+    int i;
+    double err, sum_sq_err = 0;
+
+    for (i = 0; i < HIST_SIZE; i++) {
+        err = median[i] - (double)hist[i];
+        sum_sq_err += err*err;
+    }
+    return sum_sq_err;
+}
+
+static AVFrame *get_best_frame(AVFilterContext *ctx)
+{
+    AVFrame *picref;
+    ThumbnailCudaContext *s = ctx->priv;
+    int i, j, best_frame_idx = 0;
+    int nb_frames = s->n;
+    double avg_hist[HIST_SIZE] = {0}, sq_err, min_sq_err = -1;
+
+    // average histogram of the N frames
+    for (j = 0; j < FF_ARRAY_ELEMS(avg_hist); j++) {
+        for (i = 0; i < nb_frames; i++)
+            avg_hist[j] += (double)s->frames[i].histogram[j];
+        avg_hist[j] /= nb_frames;
+    }
+
+    // find the frame closer to the average using the sum of squared errors
+    for (i = 0; i < nb_frames; i++) {
+        sq_err = frame_sum_square_err(s->frames[i].histogram, avg_hist);
+        if (i == 0 || sq_err < min_sq_err)
+            best_frame_idx = i, min_sq_err = sq_err;
+    }
+
+    // free and reset everything (except the best frame buffer)
+    for (i = 0; i < nb_frames; i++) {
+        memset(s->frames[i].histogram, 0, sizeof(s->frames[i].histogram));
+        if (i != best_frame_idx)
+            av_frame_free(&s->frames[i].buf);
+    }
+    s->n = 0;
+
+    // raise the chosen one
+    picref = s->frames[best_frame_idx].buf;
+    av_log(ctx, AV_LOG_INFO, "frame id #%d (pts_time=%f) selected "
+           "from a set of %d images\n", best_frame_idx,
+           picref->pts * av_q2d(s->tb), nb_frames);
+    s->frames[best_frame_idx].buf = NULL;
+
+    return picref;
+}
+
+static int thumbnail_kernel(ThumbnailCudaContext *s, CUfunction func, CUtexref tex, int channels,
+    int *histogram, uint8_t *src_dptr, int src_width, int src_height, int src_pitch, int pixel_size)
+{
+    CUdeviceptr src_devptr = (CUdeviceptr)src_dptr;
+    void *args[] = { &histogram, &src_width, &src_height };
+    CUDA_ARRAY_DESCRIPTOR desc;
+
+    desc.Width = src_width;
+    desc.Height = src_height;
+    desc.NumChannels = channels;
+    if (pixel_size == 1) {
+        desc.Format = CU_AD_FORMAT_UNSIGNED_INT8;
+    }
+    else {
+        desc.Format = CU_AD_FORMAT_UNSIGNED_INT16;
+    }
+
+    cuTexRefSetAddress2D_v3(tex, &desc, src_devptr, src_pitch);
+    cuLaunchKernel(func, DIV_UP(src_width, BLOCKX), DIV_UP(src_height, BLOCKY), 1, BLOCKX, BLOCKY, 1, 0, 0, args, NULL);
+
+    return 0;
+}
+
+static int thumbnail(AVFilterContext *ctx, int *histogram, AVFrame *in)
+{
+    AVHWFramesContext *in_frames_ctx = (AVHWFramesContext*)in->hw_frames_ctx->data;
+    ThumbnailCudaContext *s = ctx->priv;
+
+    switch (in_frames_ctx->sw_format) {
+    case AV_PIX_FMT_NV12:
+        thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+            histogram, in->data[0], in->width, in->height, in->linesize[0], 1);
+        thumbnail_kernel(s, s->cu_func_uchar2, s->cu_tex_uchar2, 2,
+            histogram + 256, in->data[1], in->width / 2, in->height / 2, in->linesize[1], 1);
+        break;
+    case AV_PIX_FMT_YUV420P:
+        thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+            histogram, in->data[0], in->width, in->height, in->linesize[0], 1);
+        thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+            histogram + 256, in->data[1], in->width / 2, in->height / 2, in->linesize[1], 1);
+        thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+            histogram + 512, in->data[2], in->width / 2, in->height / 2, in->linesize[2], 1);
+        break;
+    case AV_PIX_FMT_YUV444P:
+        thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+            histogram, in->data[0], in->width, in->height, in->linesize[0], 1);
+        thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+            histogram + 256, in->data[1], in->width, in->height, in->linesize[1], 1);
+        thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
+            histogram + 512, in->data[2], in->width, in->height, in->linesize[2], 1);
+        break;
+    case AV_PIX_FMT_P010LE:
+    case AV_PIX_FMT_P016LE:
+        thumbnail_kernel(s, s->cu_func_ushort, s->cu_tex_ushort, 1,
+            histogram, in->data[0], in->width, in->height, in->linesize[0], 2);
+        thumbnail_kernel(s, s->cu_func_ushort2, s->cu_tex_ushort2, 2,
+            histogram + 256, in->data[1], in->width / 2, in->height / 2, in->linesize[1], 2);
+        break;
+    case AV_PIX_FMT_YUV444P16:
+        thumbnail_kernel(s, s->cu_func_ushort2, s->cu_tex_uchar, 1,
+            histogram, in->data[0], in->width, in->height, in->linesize[0], 2);
+        thumbnail_kernel(s, s->cu_func_ushort2, s->cu_tex_uchar, 1,
+            histogram + 256, in->data[1], in->width, in->height, in->linesize[1], 2);
+        thumbnail_kernel(s, s->cu_func_ushort2, s->cu_tex_uchar, 1,
+            histogram + 512, in->data[2], in->width, in->height, in->linesize[2], 2);
+        break;
+    default:
+        return AVERROR_BUG;
+    }
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
+{
+    AVFilterContext *ctx  = inlink->dst;
+    ThumbnailCudaContext *s   = ctx->priv;
+    AVFilterLink *outlink = ctx->outputs[0];
+    int *hist = s->frames[s->n].histogram;
+    AVHWFramesContext *hw_frames_ctx = (AVHWFramesContext*)s->hw_frames_ctx->data;
+    AVCUDADeviceContext *device_hwctx = hw_frames_ctx->device_ctx->hwctx;
+    CUresult err;
+    CUcontext dummy;
+    CUDA_MEMCPY2D cpy = { 0 };
+    int ret = 0;
+
+    // keep a reference of each frame
+    s->frames[s->n].buf = frame;
+
+    err = cuCtxPushCurrent(device_hwctx->cuda_ctx);
+    if (err != CUDA_SUCCESS)
+        return AVERROR_UNKNOWN;
+
+    cuMemsetD8(s->data, 0, HIST_SIZE * sizeof(int));
+
+    thumbnail(ctx, (int*)s->data, frame);
+
+    cpy.srcMemoryType = CU_MEMORYTYPE_DEVICE;
+    cpy.dstMemoryType = CU_MEMORYTYPE_HOST;
+    cpy.srcDevice = s->data;
+    cpy.dstHost = hist;
+    cpy.srcPitch = HIST_SIZE * sizeof(int);
+    cpy.dstPitch = HIST_SIZE * sizeof(int);
+    cpy.WidthInBytes = HIST_SIZE * sizeof(int);
+    cpy.Height = 1;
+
+    err = cuMemcpy2D(&cpy);
+    if (err != CUDA_SUCCESS) {
+        av_log(ctx, AV_LOG_ERROR, "Error transferring the data from the CUDA frame\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    if (hw_frames_ctx->sw_format == AV_PIX_FMT_NV12 || hw_frames_ctx->sw_format == AV_PIX_FMT_YUV420P ||
+        hw_frames_ctx->sw_format == AV_PIX_FMT_P010LE || hw_frames_ctx->sw_format == AV_PIX_FMT_P016LE)
+    {
+        int i;
+        for (i = 256; i < HIST_SIZE; i++)
+            hist[i] = 4 * hist[i];
+    }
+
+    cuCtxPopCurrent(&dummy);
+    if (ret < 0)
+        return ret;
+
+    // no selection until the buffer of N frames is filled up
+    s->n++;
+    if (s->n < s->n_frames)
+        return 0;
+
+    return ff_filter_frame(outlink, get_best_frame(ctx));
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    int i;
+    ThumbnailCudaContext *s = ctx->priv;
+
+    if (s->data) {
+        cuMemFree(s->data);
+        s->data = 0;
+    }
+
+    if (s->cu_module) {
+        cuModuleUnload(s->cu_module);
+        s->cu_module = NULL;
+    }
+
+    for (i = 0; i < s->n_frames && s->frames[i].buf; i++)
+        av_frame_free(&s->frames[i].buf);
+    av_freep(&s->frames);
+}
+
+static int request_frame(AVFilterLink *link)
+{
+    AVFilterContext *ctx = link->src;
+    ThumbnailCudaContext *s = ctx->priv;
+    int ret = ff_request_frame(ctx->inputs[0]);
+
+    if (ret == AVERROR_EOF && s->n) {
+        ret = ff_filter_frame(link, get_best_frame(ctx));
+        if (ret < 0)
+            return ret;
+        ret = AVERROR_EOF;
+    }
+    if (ret < 0)
+        return ret;
+    return 0;
+}
+
+static int format_is_supported(enum AVPixelFormat fmt)
+{
+    int i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++)
+        if (supported_formats[i] == fmt)
+            return 1;
+    return 0;
+}
+
+static int config_props(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    ThumbnailCudaContext *s = ctx->priv;
+    AVHWFramesContext     *hw_frames_ctx = (AVHWFramesContext*)inlink->hw_frames_ctx->data;
+    AVCUDADeviceContext *device_hwctx = hw_frames_ctx->device_ctx->hwctx;
+    CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
+    CUresult err;
+
+    extern char vf_thumbnail_cuda_ptx[];
+
+    err = cuCtxPushCurrent(cuda_ctx);
+    if (err != CUDA_SUCCESS) {
+        av_log(ctx, AV_LOG_ERROR, "Error pushing cuda context\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    err = cuModuleLoadData(&s->cu_module, vf_thumbnail_cuda_ptx);
+    if (err != CUDA_SUCCESS) {
+        av_log(ctx, AV_LOG_ERROR, "Error loading module data\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    cuModuleGetFunction(&s->cu_func_uchar, s->cu_module, "Thumbnail_uchar");
+    cuModuleGetFunction(&s->cu_func_uchar2, s->cu_module, "Thumbnail_uchar2");
+    cuModuleGetFunction(&s->cu_func_ushort, s->cu_module, "Thumbnail_ushort");
+    cuModuleGetFunction(&s->cu_func_ushort2, s->cu_module, "Thumbnail_ushort2");
+
+    cuModuleGetTexRef(&s->cu_tex_uchar, s->cu_module, "uchar_tex");
+    cuModuleGetTexRef(&s->cu_tex_uchar2, s->cu_module, "uchar2_tex");
+    cuModuleGetTexRef(&s->cu_tex_ushort, s->cu_module, "ushort_tex");
+    cuModuleGetTexRef(&s->cu_tex_ushort2, s->cu_module, "ushort2_tex");
+
+    cuTexRefSetFlags(s->cu_tex_uchar, CU_TRSF_READ_AS_INTEGER);
+    cuTexRefSetFlags(s->cu_tex_uchar2, CU_TRSF_READ_AS_INTEGER);
+    cuTexRefSetFlags(s->cu_tex_ushort, CU_TRSF_READ_AS_INTEGER);
+    cuTexRefSetFlags(s->cu_tex_ushort2, CU_TRSF_READ_AS_INTEGER);
+
+    cuTexRefSetFilterMode(s->cu_tex_uchar, CU_TR_FILTER_MODE_LINEAR);
+    cuTexRefSetFilterMode(s->cu_tex_uchar2, CU_TR_FILTER_MODE_LINEAR);
+    cuTexRefSetFilterMode(s->cu_tex_ushort, CU_TR_FILTER_MODE_LINEAR);
+    cuTexRefSetFilterMode(s->cu_tex_ushort2, CU_TR_FILTER_MODE_LINEAR);
+
+    err = cuMemAlloc(&s->data, HIST_SIZE * sizeof(int));
+    if (err != CUDA_SUCCESS) {
+        av_log(ctx, AV_LOG_ERROR, "Error allocating cuda memory\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    cuCtxPopCurrent(&dummy);
+
+    s->hw_frames_ctx = ctx->inputs[0]->hw_frames_ctx;
+
+    ctx->outputs[0]->hw_frames_ctx = av_buffer_ref(s->hw_frames_ctx);
+    if (!ctx->outputs[0]->hw_frames_ctx)
+        return AVERROR(ENOMEM);
+
+    s->tb = inlink->time_base;
+
+    if (!format_is_supported(hw_frames_ctx->sw_format)) {
+        av_log(ctx, AV_LOG_ERROR, "Unsupported input format: %s\n", av_get_pix_fmt_name(hw_frames_ctx->sw_format));
+        return AVERROR(ENOSYS);
+    }
+
+    return 0;
+}
+
+static int query_formats(AVFilterContext *ctx)
+{
+    static const enum AVPixelFormat pix_fmts[] = {
+        AV_PIX_FMT_CUDA,
+        AV_PIX_FMT_NONE
+    };
+    AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
+    if (!fmts_list)
+        return AVERROR(ENOMEM);
+    return ff_set_common_formats(ctx, fmts_list);
+}
+
+static const AVFilterPad thumbnail_cuda_inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .config_props = config_props,
+        .filter_frame = filter_frame,
+    },
+    { NULL }
+};
+
+static const AVFilterPad thumbnail_cuda_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .request_frame = request_frame,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_thumbnail_cuda = {
+    .name          = "thumbnail_cuda",
+    .description   = NULL_IF_CONFIG_SMALL("Select the most representative frame in a given sequence of consecutive frames."),
+    .priv_size     = sizeof(ThumbnailCudaContext),
+    .init          = init,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .inputs        = thumbnail_cuda_inputs,
+    .outputs       = thumbnail_cuda_outputs,
+    .priv_class    = &thumbnail_cuda_class,
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_thumbnail_cuda.cu b/mythtv/external/FFmpeg/libavfilter/vf_thumbnail_cuda.cu
new file mode 100644
index 00000000000..98fad4303a7
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_thumbnail_cuda.cu
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+extern "C" {
+
+texture<unsigned char, 2> uchar_tex;
+texture<uchar2, 2>  uchar2_tex;
+texture<unsigned short, 2> ushort_tex;
+texture<ushort2, 2>  ushort2_tex;
+
+__global__ void Thumbnail_uchar(int *histogram, int src_width, int src_height)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+    if (y < src_height && x < src_width)
+    {
+        unsigned char pixel = tex2D(uchar_tex, x, y);
+        atomicAdd(&histogram[pixel], 1);
+    }
+}
+
+__global__ void Thumbnail_uchar2(int *histogram, int src_width, int src_height)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (y < src_height && x < src_width)
+    {
+        uchar2 pixel = tex2D(uchar2_tex, x, y);
+        atomicAdd(&histogram[pixel.x], 1);
+        atomicAdd(&histogram[256 + pixel.y], 1);
+    }
+}
+
+__global__ void Thumbnail_ushort(int *histogram, int src_width, int src_height)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (y < src_height && x < src_width)
+    {
+        unsigned short pixel = (tex2D(ushort_tex, x, y) + 128) >> 8;
+        atomicAdd(&histogram[pixel], 1);
+    }
+}
+
+__global__ void Thumbnail_ushort2(int *histogram, int src_width, int src_height)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (y < src_height && x < src_width)
+    {
+        ushort2 pixel = tex2D(ushort2_tex, x, y);
+        atomicAdd(&histogram[(pixel.x + 128) >> 8], 1);
+        atomicAdd(&histogram[256 + (pixel.y + 128) >> 8], 1);
+    }
+}
+
+}
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_tile.c b/mythtv/external/FFmpeg/libavfilter/vf_tile.c
index 9af00bd8f51..87e0b940cfc 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_tile.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_tile.c
@@ -31,7 +31,7 @@
 #include "video.h"
 #include "internal.h"
 
-typedef struct {
+typedef struct TileContext {
     const AVClass *class;
     unsigned w, h;
     unsigned margin;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_tinterlace.c b/mythtv/external/FFmpeg/libavfilter/vf_tinterlace.c
index 8a796ce933d..f13791d254f 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_tinterlace.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_tinterlace.c
@@ -1,4 +1,5 @@
 /*
+ * Copyright (c) 2017 Thomas Mundt <tmundt75@gmail.com>
  * Copyright (c) 2011 Stefano Sabatini
  * Copyright (c) 2010 Baptiste Coudurier
  * Copyright (c) 2003 Michael Zucchi <notzed@ximian.com>
@@ -34,8 +35,6 @@
 
 #define OFFSET(x) offsetof(TInterlaceContext, x)
 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
-#define TINTERLACE_FLAG_VLPF 01
-#define TINTERLACE_FLAG_EXACT_TB 2
 
 static const AVOption tinterlace_options[] = {
     {"mode",              "select interlace mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=MODE_MERGE}, 0, MODE_NB-1, FLAGS, "mode"},
@@ -51,6 +50,8 @@ static const AVOption tinterlace_options[] = {
     {"flags",             "set flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, 0, INT_MAX, 0, "flags" },
     {"low_pass_filter",   "enable vertical low-pass filter",              0, AV_OPT_TYPE_CONST, {.i64 = TINTERLACE_FLAG_VLPF}, INT_MIN, INT_MAX, FLAGS, "flags" },
     {"vlpf",              "enable vertical low-pass filter",              0, AV_OPT_TYPE_CONST, {.i64 = TINTERLACE_FLAG_VLPF}, INT_MIN, INT_MAX, FLAGS, "flags" },
+    {"complex_filter",    "enable complex vertical low-pass filter",      0, AV_OPT_TYPE_CONST, {.i64 = TINTERLACE_FLAG_CVLPF},INT_MIN, INT_MAX, FLAGS, "flags" },
+    {"cvlpf",             "enable complex vertical low-pass filter",      0, AV_OPT_TYPE_CONST, {.i64 = TINTERLACE_FLAG_CVLPF},INT_MIN, INT_MAX, FLAGS, "flags" },
     {"exact_tb",          "force a timebase which can represent timestamps exactly", 0, AV_OPT_TYPE_CONST, {.i64 = TINTERLACE_FLAG_EXACT_TB}, INT_MIN, INT_MAX, FLAGS, "flags" },
 
     {NULL}
@@ -77,7 +78,12 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
+        AV_PIX_FMT_YUV420P10LE, AV_PIX_FMT_YUV422P10LE,
+        AV_PIX_FMT_YUV440P10LE, AV_PIX_FMT_YUV444P10LE,
+        AV_PIX_FMT_YUV420P12LE, AV_PIX_FMT_YUV422P12LE,
+        AV_PIX_FMT_YUV440P12LE, AV_PIX_FMT_YUV444P12LE,
         AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
+        AV_PIX_FMT_YUVA420P10LE, AV_PIX_FMT_YUVA422P10LE, AV_PIX_FMT_YUVA444P10LE,
         AV_PIX_FMT_GRAY8, FULL_SCALE_YUVJ_FORMATS,
         AV_PIX_FMT_NONE
     };
@@ -89,8 +95,10 @@ static int query_formats(AVFilterContext *ctx)
 }
 
 static void lowpass_line_c(uint8_t *dstp, ptrdiff_t width, const uint8_t *srcp,
-                           const uint8_t *srcp_above, const uint8_t *srcp_below)
+                           ptrdiff_t mref, ptrdiff_t pref, int clip_max)
 {
+    const uint8_t *srcp_above = srcp + mref;
+    const uint8_t *srcp_below = srcp + pref;
     int i;
     for (i = 0; i < width; i++) {
         // this calculation is an integer representation of
@@ -100,6 +108,86 @@ static void lowpass_line_c(uint8_t *dstp, ptrdiff_t width, const uint8_t *srcp,
     }
 }
 
+static void lowpass_line_c_16(uint8_t *dst8, ptrdiff_t width, const uint8_t *src8,
+                              ptrdiff_t mref, ptrdiff_t pref, int clip_max)
+{
+    uint16_t *dstp = (uint16_t *)dst8;
+    const uint16_t *srcp = (const uint16_t *)src8;
+    const uint16_t *srcp_above = srcp + mref / 2;
+    const uint16_t *srcp_below = srcp + pref / 2;
+    int i, src_x;
+    for (i = 0; i < width; i++) {
+        // this calculation is an integer representation of
+        // '0.5 * current + 0.25 * above + 0.25 * below'
+        // '1 +' is for rounding.
+        src_x   = av_le2ne16(srcp[i]) << 1;
+        dstp[i] = av_le2ne16((1 + src_x + av_le2ne16(srcp_above[i])
+                             + av_le2ne16(srcp_below[i])) >> 2);
+    }
+}
+
+static void lowpass_line_complex_c(uint8_t *dstp, ptrdiff_t width, const uint8_t *srcp,
+                                   ptrdiff_t mref, ptrdiff_t pref, int clip_max)
+{
+    const uint8_t *srcp_above = srcp + mref;
+    const uint8_t *srcp_below = srcp + pref;
+    const uint8_t *srcp_above2 = srcp + mref * 2;
+    const uint8_t *srcp_below2 = srcp + pref * 2;
+    int i, src_x, src_ab;
+    for (i = 0; i < width; i++) {
+        // this calculation is an integer representation of
+        // '0.75 * current + 0.25 * above + 0.25 * below - 0.125 * above2 - 0.125 * below2'
+        // '4 +' is for rounding.
+        src_x   = srcp[i] << 1;
+        src_ab  = srcp_above[i] + srcp_below[i];
+        dstp[i] = av_clip_uint8((4 + ((srcp[i] + src_x + src_ab) << 1)
+                                - srcp_above2[i] - srcp_below2[i]) >> 3);
+        // Prevent over-sharpening:
+        // dst must not exceed src when the average of above and below
+        // is less than src. And the other way around.
+        if (src_ab > src_x) {
+            if (dstp[i] < srcp[i])
+                dstp[i] = srcp[i];
+        } else if (dstp[i] > srcp[i])
+            dstp[i] = srcp[i];
+    }
+}
+
+static void lowpass_line_complex_c_16(uint8_t *dst8, ptrdiff_t width, const uint8_t *src8,
+                                      ptrdiff_t mref, ptrdiff_t pref, int clip_max)
+{
+    uint16_t *dstp = (uint16_t *)dst8;
+    const uint16_t *srcp = (const uint16_t *)src8;
+    const uint16_t *srcp_above = srcp + mref / 2;
+    const uint16_t *srcp_below = srcp + pref / 2;
+    const uint16_t *srcp_above2 = srcp + mref;
+    const uint16_t *srcp_below2 = srcp + pref;
+    int i, dst_le, src_le, src_x, src_ab;
+    for (i = 0; i < width; i++) {
+        // this calculation is an integer representation of
+        // '0.75 * current + 0.25 * above + 0.25 * below - 0.125 * above2 - 0.125 * below2'
+        // '4 +' is for rounding.
+        src_le = av_le2ne16(srcp[i]);
+        src_x  = src_le << 1;
+        src_ab = av_le2ne16(srcp_above[i]) + av_le2ne16(srcp_below[i]);
+        dst_le = av_clip((4 + ((src_le + src_x + src_ab) << 1)
+                         - av_le2ne16(srcp_above2[i])
+                         - av_le2ne16(srcp_below2[i])) >> 3, 0, clip_max);
+        // Prevent over-sharpening:
+        // dst must not exceed src when the average of above and below
+        // is less than src. And the other way around.
+        if (src_ab > src_x) {
+            if (dst_le < src_le)
+                dstp[i] = av_le2ne16(src_le);
+            else
+                dstp[i] = av_le2ne16(dst_le);
+        } else if (dst_le > src_le) {
+            dstp[i] = av_le2ne16(src_le);
+        } else
+            dstp[i] = av_le2ne16(dst_le);
+    }
+}
+
 static av_cold void uninit(AVFilterContext *ctx)
 {
     TInterlaceContext *tinterlace = ctx->priv;
@@ -126,28 +214,26 @@ static int config_out_props(AVFilterLink *outlink)
                                                 av_make_q(2, 1));
 
     if (tinterlace->mode == MODE_PAD) {
-        uint8_t black[4] = { 16, 128, 128, 16 };
-        int i, ret;
+        uint8_t black[4] = { 0, 0, 0, 16 };
+        int ret;
+        ff_draw_init(&tinterlace->draw, outlink->format, 0);
+        ff_draw_color(&tinterlace->draw, &tinterlace->color, black);
         if (ff_fmt_is_in(outlink->format, full_scale_yuvj_pix_fmts))
-            black[0] = black[3] = 0;
+            tinterlace->color.comp[0].u8[0] = 0;
         ret = av_image_alloc(tinterlace->black_data, tinterlace->black_linesize,
                              outlink->w, outlink->h, outlink->format, 16);
         if (ret < 0)
             return ret;
 
-        /* fill black picture with black */
-        for (i = 0; i < 4 && tinterlace->black_data[i]; i++) {
-            int h = i == 1 || i == 2 ? AV_CEIL_RSHIFT(outlink->h, desc->log2_chroma_h) : outlink->h;
-            memset(tinterlace->black_data[i], black[i],
-                   tinterlace->black_linesize[i] * h);
-        }
+        ff_fill_rectangle(&tinterlace->draw, &tinterlace->color, tinterlace->black_data,
+                          tinterlace->black_linesize, 0, 0, outlink->w, outlink->h);
     }
-    if ((tinterlace->flags & TINTERLACE_FLAG_VLPF)
+    if (tinterlace->flags & (TINTERLACE_FLAG_VLPF | TINTERLACE_FLAG_CVLPF)
             && !(tinterlace->mode == MODE_INTERLEAVE_TOP
               || tinterlace->mode == MODE_INTERLEAVE_BOTTOM)) {
-        av_log(ctx, AV_LOG_WARNING, "low_pass_filter flag ignored with mode %d\n",
+        av_log(ctx, AV_LOG_WARNING, "low_pass_filter flags ignored with mode %d\n",
                 tinterlace->mode);
-        tinterlace->flags &= ~TINTERLACE_FLAG_VLPF;
+        tinterlace->flags &= ~(TINTERLACE_FLAG_VLPF | TINTERLACE_FLAG_CVLPF);
     }
     tinterlace->preout_time_base = inlink->time_base;
     if (tinterlace->mode == MODE_INTERLACEX2) {
@@ -170,14 +256,26 @@ static int config_out_props(AVFilterLink *outlink)
         (tinterlace->flags & TINTERLACE_FLAG_EXACT_TB))
         outlink->time_base = tinterlace->preout_time_base;
 
-    if (tinterlace->flags & TINTERLACE_FLAG_VLPF) {
-        tinterlace->lowpass_line = lowpass_line_c;
+    tinterlace->csp = av_pix_fmt_desc_get(outlink->format);
+    if (tinterlace->flags & TINTERLACE_FLAG_CVLPF) {
+        if (tinterlace->csp->comp[0].depth > 8)
+            tinterlace->lowpass_line = lowpass_line_complex_c_16;
+        else
+            tinterlace->lowpass_line = lowpass_line_complex_c;
+        if (ARCH_X86)
+            ff_tinterlace_init_x86(tinterlace);
+    } else if (tinterlace->flags & TINTERLACE_FLAG_VLPF) {
+        if (tinterlace->csp->comp[0].depth > 8)
+            tinterlace->lowpass_line = lowpass_line_c_16;
+        else
+            tinterlace->lowpass_line = lowpass_line_c;
         if (ARCH_X86)
             ff_tinterlace_init_x86(tinterlace);
     }
 
-    av_log(ctx, AV_LOG_VERBOSE, "mode:%d filter:%s h:%d -> h:%d\n",
-           tinterlace->mode, (tinterlace->flags & TINTERLACE_FLAG_VLPF) ? "on" : "off",
+    av_log(ctx, AV_LOG_VERBOSE, "mode:%d filter:%s h:%d -> h:%d\n", tinterlace->mode,
+           (tinterlace->flags & TINTERLACE_FLAG_CVLPF) ? "complex" :
+           (tinterlace->flags & TINTERLACE_FLAG_VLPF) ? "linear" : "off",
            inlink->h, outlink->h);
 
     return 0;
@@ -215,31 +313,34 @@ void copy_picture_field(TInterlaceContext *tinterlace,
         int cols  = plane == 1 || plane == 2 ? AV_CEIL_RSHIFT(    w, hsub) : w;
         uint8_t *dstp = dst[plane];
         const uint8_t *srcp = src[plane];
+        int srcp_linesize = src_linesize[plane] * k;
+        int dstp_linesize = dst_linesize[plane] * (interleave ? 2 : 1);
+        int clip_max = (1 << tinterlace->csp->comp[plane].depth) - 1;
 
         lines = (lines + (src_field == FIELD_UPPER)) / k;
         if (src_field == FIELD_LOWER)
             srcp += src_linesize[plane];
         if (interleave && dst_field == FIELD_LOWER)
             dstp += dst_linesize[plane];
-        if (flags & TINTERLACE_FLAG_VLPF) {
-            // Low-pass filtering is required when creating an interlaced destination from
-            // a progressive source which contains high-frequency vertical detail.
-            // Filtering will reduce interlace 'twitter' and Moire patterning.
-            int srcp_linesize = src_linesize[plane] * k;
-            int dstp_linesize = dst_linesize[plane] * (interleave ? 2 : 1);
+        // Low-pass filtering is required when creating an interlaced destination from
+        // a progressive source which contains high-frequency vertical detail.
+        // Filtering will reduce interlace 'twitter' and Moire patterning.
+        if (flags & (TINTERLACE_FLAG_VLPF | TINTERLACE_FLAG_CVLPF)) {
+            int x = !!(flags & TINTERLACE_FLAG_CVLPF);
             for (h = lines; h > 0; h--) {
-                const uint8_t *srcp_above = srcp - src_linesize[plane];
-                const uint8_t *srcp_below = srcp + src_linesize[plane];
-                if (h == lines) srcp_above = srcp; // there is no line above
-                if (h == 1) srcp_below = srcp;     // there is no line below
+                ptrdiff_t pref = src_linesize[plane];
+                ptrdiff_t mref = -pref;
+                if (h >= (lines - x))  mref = 0; // there is no line above
+                else if (h <= (1 + x)) pref = 0; // there is no line below
 
-                tinterlace->lowpass_line(dstp, cols, srcp, srcp_above, srcp_below);
+                tinterlace->lowpass_line(dstp, cols, srcp, mref, pref, clip_max);
                 dstp += dstp_linesize;
                 srcp += srcp_linesize;
             }
         } else {
-            av_image_copy_plane(dstp, dst_linesize[plane] * (interleave ? 2 : 1),
-                                srcp, src_linesize[plane]*k, cols, lines);
+            if (tinterlace->csp->comp[plane].depth > 8)
+                cols *= 2;
+            av_image_copy_plane(dstp, dstp_linesize, srcp, srcp_linesize, cols, lines);
         }
     }
 }
@@ -280,12 +381,12 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
         copy_picture_field(tinterlace, out->data, out->linesize,
                            (const uint8_t **)cur->data, cur->linesize,
                            inlink->format, inlink->w, inlink->h,
-                           FIELD_UPPER_AND_LOWER, 1, tinterlace->mode == MODE_MERGEX2 ? inlink->frame_count & 1 ? FIELD_LOWER : FIELD_UPPER : FIELD_UPPER, tinterlace->flags);
+                           FIELD_UPPER_AND_LOWER, 1, tinterlace->mode == MODE_MERGEX2 ? inlink->frame_count_out & 1 ? FIELD_LOWER : FIELD_UPPER : FIELD_UPPER, tinterlace->flags);
         /* write even frame lines into the lower field of the new frame */
         copy_picture_field(tinterlace, out->data, out->linesize,
                            (const uint8_t **)next->data, next->linesize,
                            inlink->format, inlink->w, inlink->h,
-                           FIELD_UPPER_AND_LOWER, 1, tinterlace->mode == MODE_MERGEX2 ? inlink->frame_count & 1 ? FIELD_UPPER : FIELD_LOWER : FIELD_LOWER, tinterlace->flags);
+                           FIELD_UPPER_AND_LOWER, 1, tinterlace->mode == MODE_MERGEX2 ? inlink->frame_count_out & 1 ? FIELD_UPPER : FIELD_LOWER : FIELD_LOWER, tinterlace->flags);
         if (tinterlace->mode != MODE_MERGEX2)
             av_frame_free(&tinterlace->next);
         break;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_tonemap.c b/mythtv/external/FFmpeg/libavfilter/vf_tonemap.c
new file mode 100644
index 00000000000..10308bdb16c
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_tonemap.c
@@ -0,0 +1,354 @@
+/*
+ * Copyright (c) 2017 Vittorio Giovara <vittorio.giovara@gmail.com>
+ *
+ * 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
+ * tonemap algorithms
+ */
+
+#include <float.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libavutil/imgutils.h"
+#include "libavutil/internal.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/mastering_display_metadata.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+
+#include "avfilter.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+#define REFERENCE_WHITE 100.0f
+
+enum TonemapAlgorithm {
+    TONEMAP_NONE,
+    TONEMAP_LINEAR,
+    TONEMAP_GAMMA,
+    TONEMAP_CLIP,
+    TONEMAP_REINHARD,
+    TONEMAP_HABLE,
+    TONEMAP_MOBIUS,
+    TONEMAP_MAX,
+};
+
+typedef struct LumaCoefficients {
+    double cr, cg, cb;
+} LumaCoefficients;
+
+
+static const struct LumaCoefficients luma_coefficients[AVCOL_SPC_NB] = {
+    [AVCOL_SPC_FCC]        = { 0.30,   0.59,   0.11   },
+    [AVCOL_SPC_BT470BG]    = { 0.299,  0.587,  0.114  },
+    [AVCOL_SPC_SMPTE170M]  = { 0.299,  0.587,  0.114  },
+    [AVCOL_SPC_BT709]      = { 0.2126, 0.7152, 0.0722 },
+    [AVCOL_SPC_SMPTE240M]  = { 0.212,  0.701,  0.087  },
+    [AVCOL_SPC_BT2020_NCL] = { 0.2627, 0.6780, 0.0593 },
+    [AVCOL_SPC_BT2020_CL]  = { 0.2627, 0.6780, 0.0593 },
+};
+
+typedef struct TonemapContext {
+    const AVClass *class;
+
+    enum TonemapAlgorithm tonemap;
+    double param;
+    double desat;
+    double peak;
+
+    const LumaCoefficients *coeffs;
+} TonemapContext;
+
+static const enum AVPixelFormat pix_fmts[] = {
+    AV_PIX_FMT_GBRPF32,
+    AV_PIX_FMT_GBRAPF32,
+    AV_PIX_FMT_NONE,
+};
+
+static int query_formats(AVFilterContext *ctx)
+{
+    return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
+}
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    TonemapContext *s = ctx->priv;
+
+    switch(s->tonemap) {
+    case TONEMAP_GAMMA:
+        if (isnan(s->param))
+            s->param = 1.8f;
+        break;
+    case TONEMAP_REINHARD:
+        if (!isnan(s->param))
+            s->param = (1.0f - s->param) / s->param;
+        break;
+    case TONEMAP_MOBIUS:
+        if (isnan(s->param))
+            s->param = 0.3f;
+        break;
+    }
+
+    if (isnan(s->param))
+        s->param = 1.0f;
+
+    return 0;
+}
+
+static double determine_signal_peak(AVFrame *in)
+{
+    AVFrameSideData *sd = av_frame_get_side_data(in, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL);
+    double peak = 0;
+
+    if (sd) {
+        AVContentLightMetadata *clm = (AVContentLightMetadata *)sd->data;
+        peak = clm->MaxCLL / REFERENCE_WHITE;
+    }
+
+    sd = av_frame_get_side_data(in, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA);
+    if (!peak && sd) {
+        AVMasteringDisplayMetadata *metadata = (AVMasteringDisplayMetadata *)sd->data;
+        if (metadata->has_luminance)
+            peak = av_q2d(metadata->max_luminance) / REFERENCE_WHITE;
+    }
+
+    /* smpte2084 needs the side data above to work correctly
+     * if missing, assume that the original transfer was arib-std-b67 */
+    if (!peak)
+        peak = 12;
+
+    return peak;
+}
+
+static float hable(float in)
+{
+    float a = 0.15f, b = 0.50f, c = 0.10f, d = 0.20f, e = 0.02f, f = 0.30f;
+    return (in * (in * a + b * c) + d * e) / (in * (in * a + b) + d * f) - e / f;
+}
+
+static float mobius(float in, float j, double peak)
+{
+    float a, b;
+
+    if (in <= j)
+        return in;
+
+    a = -j * j * (peak - 1.0f) / (j * j - 2.0f * j + peak);
+    b = (j * j - 2.0f * j * peak + peak) / FFMAX(peak - 1.0f, 1e-6);
+
+    return (b * b + 2.0f * b * j + j * j) / (b - a) * (in + a) / (in + b);
+}
+
+#define MIX(x,y,a) (x) * (1 - (a)) + (y) * (a)
+static void tonemap(TonemapContext *s, AVFrame *out, const AVFrame *in,
+                    const AVPixFmtDescriptor *desc, int x, int y, double peak)
+{
+    const float *r_in = (const float *)(in->data[0] + x * desc->comp[0].step + y * in->linesize[0]);
+    const float *b_in = (const float *)(in->data[1] + x * desc->comp[1].step + y * in->linesize[1]);
+    const float *g_in = (const float *)(in->data[2] + x * desc->comp[2].step + y * in->linesize[2]);
+    float *r_out = (float *)(out->data[0] + x * desc->comp[0].step + y * out->linesize[0]);
+    float *b_out = (float *)(out->data[1] + x * desc->comp[1].step + y * out->linesize[1]);
+    float *g_out = (float *)(out->data[2] + x * desc->comp[2].step + y * out->linesize[2]);
+    float sig, sig_orig;
+
+    /* load values */
+    *r_out = *r_in;
+    *b_out = *b_in;
+    *g_out = *g_in;
+
+    /* desaturate to prevent unnatural colors */
+    if (s->desat > 0) {
+        float luma = s->coeffs->cr * *r_in + s->coeffs->cg * *g_in + s->coeffs->cb * *b_in;
+        float overbright = FFMAX(luma - s->desat, 1e-6) / FFMAX(luma, 1e-6);
+        *r_out = MIX(*r_in, luma, overbright);
+        *g_out = MIX(*g_in, luma, overbright);
+        *b_out = MIX(*b_in, luma, overbright);
+    }
+
+    /* pick the brightest component, reducing the value range as necessary
+     * to keep the entire signal in range and preventing discoloration due to
+     * out-of-bounds clipping */
+    sig = FFMAX(FFMAX3(*r_out, *g_out, *b_out), 1e-6);
+    sig_orig = sig;
+
+    switch(s->tonemap) {
+    default:
+    case TONEMAP_NONE:
+        // do nothing
+        break;
+    case TONEMAP_LINEAR:
+        sig = sig * s->param / peak;
+        break;
+    case TONEMAP_GAMMA:
+        sig = sig > 0.05f ? pow(sig / peak, 1.0f / s->param)
+                          : sig * pow(0.05f / peak, 1.0f / s->param) / 0.05f;
+        break;
+    case TONEMAP_CLIP:
+        sig = av_clipf(sig * s->param, 0, 1.0f);
+        break;
+    case TONEMAP_HABLE:
+        sig = hable(sig) / hable(peak);
+        break;
+    case TONEMAP_REINHARD:
+        sig = sig / (sig + s->param) * (peak + s->param) / peak;
+        break;
+    case TONEMAP_MOBIUS:
+        sig = mobius(sig, s->param, peak);
+        break;
+    }
+
+    /* apply the computed scale factor to the color,
+     * linearly to prevent discoloration */
+    *r_out *= sig / sig_orig;
+    *g_out *= sig / sig_orig;
+    *b_out *= sig / sig_orig;
+}
+
+static int filter_frame(AVFilterLink *link, AVFrame *in)
+{
+    TonemapContext *s = link->dst->priv;
+    AVFilterLink *outlink = link->dst->outputs[0];
+    AVFrame *out;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(link->format);
+    const AVPixFmtDescriptor *odesc = av_pix_fmt_desc_get(outlink->format);
+    int ret, x, y;
+    double peak = s->peak;
+
+    if (!desc || !odesc) {
+        av_frame_free(&in);
+        return AVERROR_BUG;
+    }
+
+    out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+    if (!out) {
+        av_frame_free(&in);
+        return AVERROR(ENOMEM);
+    }
+
+    ret = av_frame_copy_props(out, in);
+    if (ret < 0) {
+        av_frame_free(&in);
+        av_frame_free(&out);
+        return ret;
+    }
+
+    /* input and output transfer will be linear */
+    if (in->color_trc == AVCOL_TRC_UNSPECIFIED) {
+        av_log(s, AV_LOG_WARNING, "Untagged transfer, assuming linear light\n");
+        out->color_trc = AVCOL_TRC_LINEAR;
+    } else if (in->color_trc != AVCOL_TRC_LINEAR)
+        av_log(s, AV_LOG_WARNING, "Tonemapping works on linear light only\n");
+
+    /* read peak from side data if not passed in */
+    if (!peak) {
+        peak = determine_signal_peak(in);
+        av_log(s, AV_LOG_DEBUG, "Computed signal peak: %f\n", peak);
+    }
+
+    /* load original color space even if pixel format is RGB to compute overbrights */
+    s->coeffs = &luma_coefficients[in->colorspace];
+    if (s->desat > 0 && (in->colorspace == AVCOL_SPC_UNSPECIFIED || !s->coeffs)) {
+        if (in->colorspace == AVCOL_SPC_UNSPECIFIED)
+            av_log(s, AV_LOG_WARNING, "Missing color space information, ");
+        else if (!s->coeffs)
+            av_log(s, AV_LOG_WARNING, "Unsupported color space '%s', ",
+                   av_color_space_name(in->colorspace));
+        av_log(s, AV_LOG_WARNING, "desaturation is disabled\n");
+        s->desat = 0;
+    }
+
+    /* do the tone map */
+    for (y = 0; y < out->height; y++)
+        for (x = 0; x < out->width; x++)
+            tonemap(s, out, in, desc, x, y, peak);
+
+    /* copy/generate alpha if needed */
+    if (desc->flags & AV_PIX_FMT_FLAG_ALPHA && odesc->flags & AV_PIX_FMT_FLAG_ALPHA) {
+        av_image_copy_plane(out->data[3], out->linesize[3],
+                            in->data[3], in->linesize[3],
+                            out->linesize[3], outlink->h);
+    } else if (odesc->flags & AV_PIX_FMT_FLAG_ALPHA) {
+        for (y = 0; y < out->height; y++) {
+            for (x = 0; x < out->width; x++) {
+                AV_WN32(out->data[3] + x * odesc->comp[3].step + y * out->linesize[3],
+                        av_float2int(1.0f));
+            }
+        }
+    }
+
+    av_frame_free(&in);
+
+    return ff_filter_frame(outlink, out);
+}
+
+#define OFFSET(x) offsetof(TonemapContext, x)
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
+static const AVOption tonemap_options[] = {
+    { "tonemap",      "tonemap algorithm selection", OFFSET(tonemap), AV_OPT_TYPE_INT, {.i64 = TONEMAP_NONE}, TONEMAP_NONE, TONEMAP_MAX - 1, FLAGS, "tonemap" },
+    {     "none",     0, 0, AV_OPT_TYPE_CONST, {.i64 = TONEMAP_NONE},              0, 0, FLAGS, "tonemap" },
+    {     "linear",   0, 0, AV_OPT_TYPE_CONST, {.i64 = TONEMAP_LINEAR},            0, 0, FLAGS, "tonemap" },
+    {     "gamma",    0, 0, AV_OPT_TYPE_CONST, {.i64 = TONEMAP_GAMMA},             0, 0, FLAGS, "tonemap" },
+    {     "clip",     0, 0, AV_OPT_TYPE_CONST, {.i64 = TONEMAP_CLIP},              0, 0, FLAGS, "tonemap" },
+    {     "reinhard", 0, 0, AV_OPT_TYPE_CONST, {.i64 = TONEMAP_REINHARD},          0, 0, FLAGS, "tonemap" },
+    {     "hable",    0, 0, AV_OPT_TYPE_CONST, {.i64 = TONEMAP_HABLE},             0, 0, FLAGS, "tonemap" },
+    {     "mobius",   0, 0, AV_OPT_TYPE_CONST, {.i64 = TONEMAP_MOBIUS},            0, 0, FLAGS, "tonemap" },
+    { "param",        "tonemap parameter", OFFSET(param), AV_OPT_TYPE_DOUBLE, {.dbl = NAN}, DBL_MIN, DBL_MAX, FLAGS },
+    { "desat",        "desaturation strength", OFFSET(desat), AV_OPT_TYPE_DOUBLE, {.dbl = 2}, 0, DBL_MAX, FLAGS },
+    { "peak",         "signal peak override", OFFSET(peak), AV_OPT_TYPE_DOUBLE, {.dbl = 0}, 0, DBL_MAX, FLAGS },
+    { NULL }
+};
+
+static const AVClass tonemap_class = {
+    .class_name       = "tonemap",
+    .item_name        = av_default_item_name,
+    .option           = tonemap_options,
+    .version          = LIBAVUTIL_VERSION_INT,
+    .category         = AV_CLASS_CATEGORY_FILTER,
+};
+
+static const AVFilterPad tonemap_inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = filter_frame,
+    },
+    { NULL }
+};
+
+static const AVFilterPad tonemap_outputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_tonemap = {
+    .name            = "tonemap",
+    .description     = NULL_IF_CONFIG_SMALL("Conversion to/from different dynamic ranges."),
+    .init            = init,
+    .query_formats   = query_formats,
+    .priv_size       = sizeof(TonemapContext),
+    .priv_class      = &tonemap_class,
+    .inputs          = tonemap_inputs,
+    .outputs         = tonemap_outputs,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_transpose.c b/mythtv/external/FFmpeg/libavfilter/vf_transpose.c
index 28226c3cfd1..982fb0c8ca4 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_transpose.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_transpose.c
@@ -58,6 +58,12 @@ typedef struct TransContext {
 
     int passthrough;    ///< PassthroughType, landscape passthrough mode enabled
     int dir;            ///< TransposeDir
+
+    void (*transpose_8x8)(uint8_t *src, ptrdiff_t src_linesize,
+                          uint8_t *dst, ptrdiff_t dst_linesize);
+    void (*transpose_block)(uint8_t *src, ptrdiff_t src_linesize,
+                            uint8_t *dst, ptrdiff_t dst_linesize,
+                            int w, int h);
 } TransContext;
 
 static int query_formats(AVFilterContext *ctx)
@@ -79,6 +85,109 @@ static int query_formats(AVFilterContext *ctx)
     return ff_set_common_formats(ctx, pix_fmts);
 }
 
+static inline void transpose_block_8_c(uint8_t *src, ptrdiff_t src_linesize,
+                                       uint8_t *dst, ptrdiff_t dst_linesize,
+                                       int w, int h)
+{
+    int x, y;
+    for (y = 0; y < h; y++, dst += dst_linesize, src++)
+        for (x = 0; x < w; x++)
+            dst[x] = src[x*src_linesize];
+}
+
+static void transpose_8x8_8_c(uint8_t *src, ptrdiff_t src_linesize,
+                              uint8_t *dst, ptrdiff_t dst_linesize)
+{
+    transpose_block_8_c(src, src_linesize, dst, dst_linesize, 8, 8);
+}
+
+static inline void transpose_block_16_c(uint8_t *src, ptrdiff_t src_linesize,
+                                        uint8_t *dst, ptrdiff_t dst_linesize,
+                                        int w, int h)
+{
+    int x, y;
+    for (y = 0; y < h; y++, dst += dst_linesize, src += 2)
+        for (x = 0; x < w; x++)
+            *((uint16_t *)(dst + 2*x)) = *((uint16_t *)(src + x*src_linesize));
+}
+
+static void transpose_8x8_16_c(uint8_t *src, ptrdiff_t src_linesize,
+                               uint8_t *dst, ptrdiff_t dst_linesize)
+{
+    transpose_block_16_c(src, src_linesize, dst, dst_linesize, 8, 8);
+}
+
+static inline void transpose_block_24_c(uint8_t *src, ptrdiff_t src_linesize,
+                                        uint8_t *dst, ptrdiff_t dst_linesize,
+                                        int w, int h)
+{
+    int x, y;
+    for (y = 0; y < h; y++, dst += dst_linesize) {
+        for (x = 0; x < w; x++) {
+            int32_t v = AV_RB24(src + x*src_linesize + y*3);
+            AV_WB24(dst + 3*x, v);
+        }
+    }
+}
+
+static void transpose_8x8_24_c(uint8_t *src, ptrdiff_t src_linesize,
+                               uint8_t *dst, ptrdiff_t dst_linesize)
+{
+    transpose_block_24_c(src, src_linesize, dst, dst_linesize, 8, 8);
+}
+
+static inline void transpose_block_32_c(uint8_t *src, ptrdiff_t src_linesize,
+                                        uint8_t *dst, ptrdiff_t dst_linesize,
+                                        int w, int h)
+{
+    int x, y;
+    for (y = 0; y < h; y++, dst += dst_linesize, src += 4) {
+        for (x = 0; x < w; x++)
+            *((uint32_t *)(dst + 4*x)) = *((uint32_t *)(src + x*src_linesize));
+    }
+}
+
+static void transpose_8x8_32_c(uint8_t *src, ptrdiff_t src_linesize,
+                               uint8_t *dst, ptrdiff_t dst_linesize)
+{
+    transpose_block_32_c(src, src_linesize, dst, dst_linesize, 8, 8);
+}
+
+static inline void transpose_block_48_c(uint8_t *src, ptrdiff_t src_linesize,
+                                        uint8_t *dst, ptrdiff_t dst_linesize,
+                                        int w, int h)
+{
+    int x, y;
+    for (y = 0; y < h; y++, dst += dst_linesize, src += 6) {
+        for (x = 0; x < w; x++) {
+            int64_t v = AV_RB48(src + x*src_linesize);
+            AV_WB48(dst + 6*x, v);
+        }
+    }
+}
+
+static void transpose_8x8_48_c(uint8_t *src, ptrdiff_t src_linesize,
+                               uint8_t *dst, ptrdiff_t dst_linesize)
+{
+    transpose_block_48_c(src, src_linesize, dst, dst_linesize, 8, 8);
+}
+
+static inline void transpose_block_64_c(uint8_t *src, ptrdiff_t src_linesize,
+                                        uint8_t *dst, ptrdiff_t dst_linesize,
+                                        int w, int h)
+{
+    int x, y;
+    for (y = 0; y < h; y++, dst += dst_linesize, src += 8)
+        for (x = 0; x < w; x++)
+            *((uint64_t *)(dst + 8*x)) = *((uint64_t *)(src + x*src_linesize));
+}
+
+static void transpose_8x8_64_c(uint8_t *src, ptrdiff_t src_linesize,
+                               uint8_t *dst, ptrdiff_t dst_linesize)
+{
+    transpose_block_64_c(src, src_linesize, dst, dst_linesize, 8, 8);
+}
+
 static int config_props_output(AVFilterLink *outlink)
 {
     AVFilterContext *ctx = outlink->src;
@@ -118,6 +227,21 @@ static int config_props_output(AVFilterLink *outlink)
     else
         outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
 
+    switch (s->pixsteps[0]) {
+    case 1: s->transpose_block = transpose_block_8_c;
+            s->transpose_8x8   = transpose_8x8_8_c;  break;
+    case 2: s->transpose_block = transpose_block_16_c;
+            s->transpose_8x8   = transpose_8x8_16_c; break;
+    case 3: s->transpose_block = transpose_block_24_c;
+            s->transpose_8x8   = transpose_8x8_24_c; break;
+    case 4: s->transpose_block = transpose_block_32_c;
+            s->transpose_8x8   = transpose_8x8_32_c; break;
+    case 6: s->transpose_block = transpose_block_48_c;
+            s->transpose_8x8   = transpose_8x8_48_c; break;
+    case 8: s->transpose_block = transpose_block_64_c;
+            s->transpose_8x8   = transpose_8x8_64_c; break;
+    }
+
     av_log(ctx, AV_LOG_VERBOSE,
            "w:%d h:%d dir:%d -> w:%d h:%d rotation:%s vflip:%d\n",
            inlink->w, inlink->h, s->dir, outlink->w, outlink->h,
@@ -176,49 +300,25 @@ static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr,
             dstlinesize *= -1;
         }
 
-        switch (pixstep) {
-        case 1:
-            for (y = start; y < end; y++, dst += dstlinesize)
-                for (x = 0; x < outw; x++)
-                    dst[x] = src[x * srclinesize + y];
-            break;
-        case 2:
-            for (y = start; y < end; y++, dst += dstlinesize) {
-                for (x = 0; x < outw; x++)
-                    *((uint16_t *)(dst + 2 * x)) =
-                        *((uint16_t *)(src + x * srclinesize + y * 2));
-            }
-            break;
-        case 3:
-            for (y = start; y < end; y++, dst += dstlinesize) {
-                for (x = 0; x < outw; x++) {
-                    int32_t v = AV_RB24(src + x * srclinesize + y * 3);
-                    AV_WB24(dst + 3 * x, v);
-                }
-            }
-            break;
-        case 4:
-            for (y = start; y < end; y++, dst += dstlinesize) {
-                for (x = 0; x < outw; x++)
-                    *((uint32_t *)(dst + 4 * x)) =
-                        *((uint32_t *)(src + x * srclinesize + y * 4));
+        for (y = start; y < end - 7; y += 8) {
+            for (x = 0; x < outw - 7; x += 8) {
+                s->transpose_8x8(src + x * srclinesize + y * pixstep,
+                                 srclinesize,
+                                 dst + (y - start) * dstlinesize + x * pixstep,
+                                 dstlinesize);
             }
-            break;
-        case 6:
-            for (y = start; y < end; y++, dst += dstlinesize) {
-                for (x = 0; x < outw; x++) {
-                    int64_t v = AV_RB48(src + x * srclinesize + y*6);
-                    AV_WB48(dst + 6*x, v);
-                }
-            }
-            break;
-        case 8:
-            for (y = start; y < end; y++, dst += dstlinesize) {
-                for (x = 0; x < outw; x++)
-                    *((uint64_t *)(dst + 8*x)) = *((uint64_t *)(src + x * srclinesize + y*8));
-            }
-            break;
+            if (outw - x > 0 && end - y > 0)
+                s->transpose_block(src + x * srclinesize + y * pixstep,
+                                   srclinesize,
+                                   dst + (y - start) * dstlinesize + x * pixstep,
+                                   dstlinesize, outw - x, end - y);
         }
+
+        if (end - y > 0)
+            s->transpose_block(src + 0 * srclinesize + y * pixstep,
+                               srclinesize,
+                               dst + (y - start) * dstlinesize + 0 * pixstep,
+                               dstlinesize, outw, end - y);
     }
 
     return 0;
@@ -260,10 +360,10 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
 
 static const AVOption transpose_options[] = {
     { "dir", "set transpose direction", OFFSET(dir), AV_OPT_TYPE_INT, { .i64 = TRANSPOSE_CCLOCK_FLIP }, 0, 7, FLAGS, "dir" },
-        { "cclock_flip", "rotate counter-clockwise with vertical flip", 0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CCLOCK_FLIP }, .unit = "dir" },
-        { "clock",       "rotate clockwise",                            0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CLOCK       }, .unit = "dir" },
-        { "cclock",      "rotate counter-clockwise",                    0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CCLOCK      }, .unit = "dir" },
-        { "clock_flip",  "rotate clockwise with vertical flip",         0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CLOCK_FLIP  }, .unit = "dir" },
+        { "cclock_flip", "rotate counter-clockwise with vertical flip", 0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CCLOCK_FLIP }, .flags=FLAGS, .unit = "dir" },
+        { "clock",       "rotate clockwise",                            0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CLOCK       }, .flags=FLAGS, .unit = "dir" },
+        { "cclock",      "rotate counter-clockwise",                    0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CCLOCK      }, .flags=FLAGS, .unit = "dir" },
+        { "clock_flip",  "rotate clockwise with vertical flip",         0, AV_OPT_TYPE_CONST, { .i64 = TRANSPOSE_CLOCK_FLIP  }, .flags=FLAGS, .unit = "dir" },
 
     { "passthrough", "do not apply transposition if the input matches the specified geometry",
       OFFSET(passthrough), AV_OPT_TYPE_INT, {.i64=TRANSPOSE_PT_TYPE_NONE},  0, INT_MAX, FLAGS, "passthrough" },
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_unsharp.c b/mythtv/external/FFmpeg/libavfilter/vf_unsharp.c
index 7c600c91c1c..438ff6d8fb2 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_unsharp.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_unsharp.c
@@ -258,8 +258,10 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
 end:
     av_frame_free(&in);
 
-    if (ret < 0)
+    if (ret < 0) {
+        av_frame_free(&out);
         return ret;
+    }
     return ff_filter_frame(outlink, out);
 }
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_uspp.c b/mythtv/external/FFmpeg/libavfilter/vf_uspp.c
index 8a6d0fbb939..da4029f4b2c 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_uspp.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_uspp.c
@@ -37,7 +37,7 @@
 #define MAX_LEVEL 8 /* quality levels */
 #define BLOCK 16
 
-typedef struct {
+typedef struct USPPContext {
     const AVClass *av_class;
     int log2_count;
     int hsub, vsub;
@@ -228,8 +228,8 @@ static void filter(USPPContext *p, uint8_t *dst[3], uint8_t *src[3],
         p->frame->quality = ff_norm_qscale((qpsum + qpcount/2) / qpcount, p->qscale_type) * FF_QP2LAMBDA;
     }
 //    init per MB qscale stuff FIXME
-    p->frame->height = height;
-    p->frame->width  = width;
+    p->frame->height = height + BLOCK;
+    p->frame->width  = width + BLOCK;
 
     for (i = 0; i < count; i++) {
         const int x1 = offset[i+count-1][0];
@@ -357,7 +357,7 @@ static int config_input(AVFilterLink *inlink)
         avctx_enc->gop_size = INT_MAX;
         avctx_enc->max_b_frames = 0;
         avctx_enc->pix_fmt = inlink->format;
-        avctx_enc->flags = AV_CODEC_FLAG_QSCALE | CODEC_FLAG_LOW_DELAY;
+        avctx_enc->flags = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_LOW_DELAY;
         avctx_enc->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
         avctx_enc->global_quality = 123;
         av_dict_set(&opts, "no_bitstream", "1", 0);
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_vectorscope.c b/mythtv/external/FFmpeg/libavfilter/vf_vectorscope.c
index 987bc66bd49..e3e00797d0c 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_vectorscope.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_vectorscope.c
@@ -154,7 +154,7 @@ static const enum AVPixelFormat out_rgb9_pix_fmts[] = {
 };
 
 static const enum AVPixelFormat out_rgb10_pix_fmts[] = {
-    AV_PIX_FMT_GBRP10,
+    AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
     AV_PIX_FMT_NONE
 };
 
@@ -169,7 +169,7 @@ static const enum AVPixelFormat in1_pix_fmts[] = {
     AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10,
     AV_PIX_FMT_YUV444P12,
     AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRP,
-    AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
+    AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
     AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,
     AV_PIX_FMT_NONE
 };
@@ -181,7 +181,7 @@ static const enum AVPixelFormat in2_pix_fmts[] = {
     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV440P,  AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRP,
-    AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
+    AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
     AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
@@ -1212,7 +1212,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     if (s->colorspace) {
         s->cs = (s->depth - 8) * 2 + s->colorspace - 1;
     } else {
-        switch (av_frame_get_colorspace(in)) {
+        switch (in->colorspace) {
         case AVCOL_SPC_SMPTE170M:
         case AVCOL_SPC_BT470BG:
             s->cs = (s->depth - 8) * 2 + 0;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_vidstabdetect.c b/mythtv/external/FFmpeg/libavfilter/vf_vidstabdetect.c
index 47429494f3f..63a178a0c2b 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_vidstabdetect.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_vidstabdetect.c
@@ -30,7 +30,7 @@
 
 #include "vidstabutils.h"
 
-typedef struct {
+typedef struct StabData {
     const AVClass *class;
 
     VSMotionDetect md;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_vidstabtransform.c b/mythtv/external/FFmpeg/libavfilter/vf_vidstabtransform.c
index dac0a2d19e5..11a0e3d5125 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_vidstabtransform.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_vidstabtransform.c
@@ -30,7 +30,7 @@
 
 #include "vidstabutils.h"
 
-typedef struct {
+typedef struct TransformContext {
     const AVClass *class;
 
     VSTransformData td;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_vignette.c b/mythtv/external/FFmpeg/libavfilter/vf_vignette.c
index 1d66c5025d0..47b59e5ba09 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_vignette.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_vignette.c
@@ -57,7 +57,7 @@ enum EvalMode {
     EVAL_MODE_NB
 };
 
-typedef struct {
+typedef struct VignetteContext {
     const AVClass *class;
     const AVPixFmtDescriptor *desc;
     int backward;
@@ -165,7 +165,7 @@ static void update_context(VignetteContext *s, AVFilterLink *inlink, AVFrame *fr
     int dst_linesize = s->fmap_linesize;
 
     if (frame) {
-        s->var_values[VAR_N]   = inlink->frame_count;
+        s->var_values[VAR_N]   = inlink->frame_count_out;
         s->var_values[VAR_T]   = TS2T(frame->pts, inlink->time_base);
         s->var_values[VAR_PTS] = TS2D(frame->pts);
     } else {
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_vmafmotion.c b/mythtv/external/FFmpeg/libavfilter/vf_vmafmotion.c
new file mode 100644
index 00000000000..9bcc4ff16fd
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vf_vmafmotion.c
@@ -0,0 +1,369 @@
+/*
+ * Copyright (c) 2017 Ronald S. Bultje <rsbultje@gmail.com>
+ * Copyright (c) 2017 Ashish Pratap Singh <ashk43712@gmail.com>
+ *
+ * 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
+ * Calculate VMAF Motion score.
+ */
+
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "avfilter.h"
+#include "drawutils.h"
+#include "formats.h"
+#include "internal.h"
+#include "vmaf_motion.h"
+
+#define BIT_SHIFT 15
+
+static const float FILTER_5[5] = {
+    0.054488685,
+    0.244201342,
+    0.402619947,
+    0.244201342,
+    0.054488685
+};
+
+typedef struct VMAFMotionContext {
+    const AVClass *class;
+    VMAFMotionData data;
+    FILE *stats_file;
+    char *stats_file_str;
+} VMAFMotionContext;
+
+#define OFFSET(x) offsetof(VMAFMotionContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
+
+static const AVOption vmafmotion_options[] = {
+    {"stats_file", "Set file where to store per-frame difference information", OFFSET(stats_file_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(vmafmotion);
+
+static uint64_t image_sad(const uint16_t *img1, const uint16_t *img2, int w,
+                          int h, ptrdiff_t _img1_stride, ptrdiff_t _img2_stride)
+{
+    ptrdiff_t img1_stride = _img1_stride / sizeof(*img1);
+    ptrdiff_t img2_stride = _img2_stride / sizeof(*img2);
+    uint64_t sum = 0;
+    int i, j;
+
+    for (i = 0; i < h; i++) {
+        for (j = 0; j < w; j++) {
+            sum += abs(img1[j] - img2[j]);
+        }
+        img1 += img1_stride;
+        img2 += img2_stride;
+    }
+
+    return sum;
+}
+
+static void convolution_x(const uint16_t *filter, int filt_w, const uint16_t *src,
+                          uint16_t *dst, int w, int h, ptrdiff_t _src_stride,
+                          ptrdiff_t _dst_stride)
+{
+    ptrdiff_t src_stride = _src_stride / sizeof(*src);
+    ptrdiff_t dst_stride = _dst_stride / sizeof(*dst);
+    int radius = filt_w / 2;
+    int borders_left = radius;
+    int borders_right = w - (filt_w - radius);
+    int i, j, k;
+    int sum = 0;
+
+    for (i = 0; i < h; i++) {
+        for (j = 0; j < borders_left; j++) {
+            sum = 0;
+            for (k = 0; k < filt_w; k++) {
+                int j_tap = FFABS(j - radius + k);
+                if (j_tap >= w) {
+                    j_tap = w - (j_tap - w + 1);
+                }
+                sum += filter[k] * src[i * src_stride + j_tap];
+            }
+            dst[i * dst_stride + j] = sum >> BIT_SHIFT;
+        }
+
+        for (j = borders_left; j < borders_right; j++) {
+            int sum = 0;
+            for (k = 0; k < filt_w; k++) {
+                sum += filter[k] * src[i * src_stride + j - radius + k];
+            }
+            dst[i * dst_stride + j] = sum >> BIT_SHIFT;
+        }
+
+        for (j = borders_right; j < w; j++) {
+            sum = 0;
+            for (k = 0; k < filt_w; k++) {
+                int j_tap = FFABS(j - radius + k);
+                if (j_tap >= w) {
+                    j_tap = w - (j_tap - w + 1);
+                }
+                sum += filter[k] * src[i * src_stride + j_tap];
+            }
+            dst[i * dst_stride + j] = sum >> BIT_SHIFT;
+        }
+    }
+}
+
+#define conv_y_fn(type, bits) \
+static void convolution_y_##bits##bit(const uint16_t *filter, int filt_w, \
+                                      const uint8_t *_src, uint16_t *dst, \
+                                      int w, int h, ptrdiff_t _src_stride, \
+                                      ptrdiff_t _dst_stride) \
+{ \
+    const type *src = (const type *) _src; \
+    ptrdiff_t src_stride = _src_stride / sizeof(*src); \
+    ptrdiff_t dst_stride = _dst_stride / sizeof(*dst); \
+    int radius = filt_w / 2; \
+    int borders_top = radius; \
+    int borders_bottom = h - (filt_w - radius); \
+    int i, j, k; \
+    int sum = 0; \
+    \
+    for (i = 0; i < borders_top; i++) { \
+        for (j = 0; j < w; j++) { \
+            sum = 0; \
+            for (k = 0; k < filt_w; k++) { \
+                int i_tap = FFABS(i - radius + k); \
+                if (i_tap >= h) { \
+                    i_tap = h - (i_tap - h + 1); \
+                } \
+                sum += filter[k] * src[i_tap * src_stride + j]; \
+            } \
+            dst[i * dst_stride + j] = sum >> bits; \
+        } \
+    } \
+    for (i = borders_top; i < borders_bottom; i++) { \
+        for (j = 0; j < w; j++) { \
+            sum = 0; \
+            for (k = 0; k < filt_w; k++) { \
+                sum += filter[k] * src[(i - radius + k) * src_stride + j]; \
+            } \
+            dst[i * dst_stride + j] = sum >> bits; \
+        } \
+    } \
+    for (i = borders_bottom; i < h; i++) { \
+        for (j = 0; j < w; j++) { \
+            sum = 0; \
+            for (k = 0; k < filt_w; k++) { \
+                int i_tap = FFABS(i - radius + k); \
+                if (i_tap >= h) { \
+                    i_tap = h - (i_tap - h + 1); \
+                } \
+                sum += filter[k] * src[i_tap * src_stride + j]; \
+            } \
+            dst[i * dst_stride + j] = sum >> bits; \
+        } \
+    } \
+}
+
+conv_y_fn(uint8_t, 8);
+conv_y_fn(uint16_t, 10);
+
+static void vmafmotiondsp_init(VMAFMotionDSPContext *dsp, int bpp) {
+    dsp->convolution_x = convolution_x;
+    dsp->convolution_y = bpp == 10 ? convolution_y_10bit : convolution_y_8bit;
+    dsp->sad = image_sad;
+}
+
+double ff_vmafmotion_process(VMAFMotionData *s, AVFrame *ref)
+{
+    double score;
+
+    s->vmafdsp.convolution_y(s->filter, 5, ref->data[0], s->temp_data,
+                             s->width, s->height, ref->linesize[0], s->stride);
+    s->vmafdsp.convolution_x(s->filter, 5, s->temp_data, s->blur_data[0],
+                             s->width, s->height, s->stride, s->stride);
+
+    if (!s->nb_frames) {
+        score = 0.0;
+    } else {
+        uint64_t sad = s->vmafdsp.sad(s->blur_data[1], s->blur_data[0],
+                                      s->width, s->height, s->stride, s->stride);
+        // the output score is always normalized to 8 bits
+        score = (double) (sad * 1.0 / (s->width * s->height << (BIT_SHIFT - 8)));
+    }
+
+    FFSWAP(uint16_t *, s->blur_data[0], s->blur_data[1]);
+    s->nb_frames++;
+    s->motion_sum += score;
+
+    return score;
+}
+
+static void set_meta(AVDictionary **metadata, const char *key, float d)
+{
+    char value[128];
+    snprintf(value, sizeof(value), "%0.2f", d);
+    av_dict_set(metadata, key, value, 0);
+}
+
+static void do_vmafmotion(AVFilterContext *ctx, AVFrame *ref)
+{
+    VMAFMotionContext *s = ctx->priv;
+    double score;
+
+    score = ff_vmafmotion_process(&s->data, ref);
+    set_meta(&ref->metadata, "lavfi.vmafmotion.score", score);
+    if (s->stats_file) {
+        fprintf(s->stats_file,
+                "n:%"PRId64" motion:%0.2lf\n", s->data.nb_frames, score);
+    }
+}
+
+
+int ff_vmafmotion_init(VMAFMotionData *s,
+                       int w, int h, enum AVPixelFormat fmt)
+{
+    size_t data_sz;
+    int i;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
+
+    s->width = w;
+    s->height = h;
+    s->stride = FFALIGN(w * sizeof(uint16_t), 32);
+
+    data_sz = (size_t) s->stride * h;
+    if (!(s->blur_data[0] = av_malloc(data_sz)) ||
+        !(s->blur_data[1] = av_malloc(data_sz)) ||
+        !(s->temp_data    = av_malloc(data_sz))) {
+        return AVERROR(ENOMEM);
+    }
+
+    for (i = 0; i < 5; i++) {
+        s->filter[i] = lrint(FILTER_5[i] * (1 << BIT_SHIFT));
+    }
+
+    vmafmotiondsp_init(&s->vmafdsp, desc->comp[0].depth);
+
+    return 0;
+}
+
+static int query_formats(AVFilterContext *ctx)
+{
+    AVFilterFormats *fmts_list = NULL;
+    int format, ret;
+
+    for (format = 0; av_pix_fmt_desc_get(format); format++) {
+        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(format);
+        if (!(desc->flags & (AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_HWACCEL | AV_PIX_FMT_FLAG_BITSTREAM | AV_PIX_FMT_FLAG_PAL)) &&
+            (desc->flags & AV_PIX_FMT_FLAG_PLANAR || desc->nb_components == 1) &&
+            (!(desc->flags & AV_PIX_FMT_FLAG_BE) == !HAVE_BIGENDIAN || desc->comp[0].depth == 8) &&
+            (desc->comp[0].depth == 8 || desc->comp[0].depth == 10) &&
+            (ret = ff_add_format(&fmts_list, format)) < 0)
+            return ret;
+    }
+
+    return ff_set_common_formats(ctx, fmts_list);
+}
+
+static int config_input_ref(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx  = inlink->dst;
+    VMAFMotionContext *s = ctx->priv;
+
+    return ff_vmafmotion_init(&s->data, ctx->inputs[0]->w,
+                              ctx->inputs[0]->h, ctx->inputs[0]->format);
+}
+
+double ff_vmafmotion_uninit(VMAFMotionData *s)
+{
+    av_free(s->blur_data[0]);
+    av_free(s->blur_data[1]);
+    av_free(s->temp_data);
+
+    return s->nb_frames > 0 ? s->motion_sum / s->nb_frames : 0.0;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *ref)
+{
+    AVFilterContext *ctx = inlink->dst;
+    do_vmafmotion(ctx, ref);
+    return ff_filter_frame(ctx->outputs[0], ref);
+}
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    VMAFMotionContext *s = ctx->priv;
+
+    if (s->stats_file_str) {
+        if (!strcmp(s->stats_file_str, "-")) {
+            s->stats_file = stdout;
+        } else {
+            s->stats_file = fopen(s->stats_file_str, "w");
+            if (!s->stats_file) {
+                int err = AVERROR(errno);
+                char buf[128];
+                av_strerror(err, buf, sizeof(buf));
+                av_log(ctx, AV_LOG_ERROR, "Could not open stats file %s: %s\n",
+                       s->stats_file_str, buf);
+                return err;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static av_cold void uninit(AVFilterContext *ctx)
+{
+    VMAFMotionContext *s = ctx->priv;
+    double avg_motion = ff_vmafmotion_uninit(&s->data);
+
+    if (s->data.nb_frames > 0) {
+        av_log(ctx, AV_LOG_INFO, "VMAF Motion avg: %.3f\n", avg_motion);
+    }
+
+    if (s->stats_file && s->stats_file != stdout)
+        fclose(s->stats_file);
+}
+
+static const AVFilterPad vmafmotion_inputs[] = {
+    {
+        .name         = "reference",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = filter_frame,
+        .config_props = config_input_ref,
+    },
+    { NULL }
+};
+
+static const AVFilterPad vmafmotion_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+    },
+    { NULL }
+};
+
+AVFilter ff_vf_vmafmotion = {
+    .name          = "vmafmotion",
+    .description   = NULL_IF_CONFIG_SMALL("Calculate the VMAF Motion score."),
+    .init          = init,
+    .uninit        = uninit,
+    .query_formats = query_formats,
+    .priv_size     = sizeof(VMAFMotionContext),
+    .priv_class    = &vmafmotion_class,
+    .inputs        = vmafmotion_inputs,
+    .outputs       = vmafmotion_outputs,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_w3fdif.c b/mythtv/external/FFmpeg/libavfilter/vf_w3fdif.c
index cde17d246a1..c6a65507784 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_w3fdif.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_w3fdif.c
@@ -43,6 +43,7 @@ typedef struct W3FDIFContext {
     AVFrame *prev, *cur, *next;  ///< previous, current, next frames
     int32_t **work_line;  ///< lines we are calculating
     int nb_threads;
+    int max;
 
     W3FDIFDSPContext dsp;
 } W3FDIFContext;
@@ -75,6 +76,11 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
         AV_PIX_FMT_GRAY8,
+        AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
+        AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
+        AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
+        AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
+        AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
         AV_PIX_FMT_NONE
     };
 
@@ -148,7 +154,7 @@ static void filter_complex_high(int32_t *work_line,
     }
 }
 
-static void filter_scale(uint8_t *out_pixel, const int32_t *work_pixel, int linesize)
+static void filter_scale(uint8_t *out_pixel, const int32_t *work_pixel, int linesize, int max)
 {
     int j;
 
@@ -156,12 +162,111 @@ static void filter_scale(uint8_t *out_pixel, const int32_t *work_pixel, int line
         *out_pixel = av_clip(*work_pixel, 0, 255 * 256 * 128) >> 15;
 }
 
+static void filter16_simple_low(int32_t *work_line,
+                                uint8_t *in_lines_cur8[2],
+                                const int16_t *coef, int linesize)
+{
+    uint16_t *in_lines_cur[2] = { (uint16_t *)in_lines_cur8[0], (uint16_t *)in_lines_cur8[1] };
+    int i;
+
+    linesize /= 2;
+    for (i = 0; i < linesize; i++) {
+        *work_line    = *in_lines_cur[0]++ * coef[0];
+        *work_line++ += *in_lines_cur[1]++ * coef[1];
+    }
+}
+
+static void filter16_complex_low(int32_t *work_line,
+                                 uint8_t *in_lines_cur8[4],
+                                 const int16_t *coef, int linesize)
+{
+    uint16_t *in_lines_cur[4] = { (uint16_t *)in_lines_cur8[0],
+                                  (uint16_t *)in_lines_cur8[1],
+                                  (uint16_t *)in_lines_cur8[2],
+                                  (uint16_t *)in_lines_cur8[3] };
+    int i;
+
+    linesize /= 2;
+    for (i = 0; i < linesize; i++) {
+        *work_line    = *in_lines_cur[0]++ * coef[0];
+        *work_line   += *in_lines_cur[1]++ * coef[1];
+        *work_line   += *in_lines_cur[2]++ * coef[2];
+        *work_line++ += *in_lines_cur[3]++ * coef[3];
+    }
+}
+
+static void filter16_simple_high(int32_t *work_line,
+                                 uint8_t *in_lines_cur8[3],
+                                 uint8_t *in_lines_adj8[3],
+                                 const int16_t *coef, int linesize)
+{
+    uint16_t *in_lines_cur[3] = { (uint16_t *)in_lines_cur8[0],
+                                  (uint16_t *)in_lines_cur8[1],
+                                  (uint16_t *)in_lines_cur8[2] };
+    uint16_t *in_lines_adj[3] = { (uint16_t *)in_lines_adj8[0],
+                                  (uint16_t *)in_lines_adj8[1],
+                                  (uint16_t *)in_lines_adj8[2] };
+    int i;
+
+    linesize /= 2;
+    for (i = 0; i < linesize; i++) {
+        *work_line   += *in_lines_cur[0]++ * coef[0];
+        *work_line   += *in_lines_adj[0]++ * coef[0];
+        *work_line   += *in_lines_cur[1]++ * coef[1];
+        *work_line   += *in_lines_adj[1]++ * coef[1];
+        *work_line   += *in_lines_cur[2]++ * coef[2];
+        *work_line++ += *in_lines_adj[2]++ * coef[2];
+    }
+}
+
+static void filter16_complex_high(int32_t *work_line,
+                                  uint8_t *in_lines_cur8[5],
+                                  uint8_t *in_lines_adj8[5],
+                                  const int16_t *coef, int linesize)
+{
+    uint16_t *in_lines_cur[5] = { (uint16_t *)in_lines_cur8[0],
+                                  (uint16_t *)in_lines_cur8[1],
+                                  (uint16_t *)in_lines_cur8[2],
+                                  (uint16_t *)in_lines_cur8[3],
+                                  (uint16_t *)in_lines_cur8[4] };
+    uint16_t *in_lines_adj[5] = { (uint16_t *)in_lines_adj8[0],
+                                  (uint16_t *)in_lines_adj8[1],
+                                  (uint16_t *)in_lines_adj8[2],
+                                  (uint16_t *)in_lines_adj8[3],
+                                  (uint16_t *)in_lines_adj8[4] };
+    int i;
+
+    linesize /= 2;
+    for (i = 0; i < linesize; i++) {
+        *work_line   += *in_lines_cur[0]++ * coef[0];
+        *work_line   += *in_lines_adj[0]++ * coef[0];
+        *work_line   += *in_lines_cur[1]++ * coef[1];
+        *work_line   += *in_lines_adj[1]++ * coef[1];
+        *work_line   += *in_lines_cur[2]++ * coef[2];
+        *work_line   += *in_lines_adj[2]++ * coef[2];
+        *work_line   += *in_lines_cur[3]++ * coef[3];
+        *work_line   += *in_lines_adj[3]++ * coef[3];
+        *work_line   += *in_lines_cur[4]++ * coef[4];
+        *work_line++ += *in_lines_adj[4]++ * coef[4];
+    }
+}
+
+static void filter16_scale(uint8_t *out_pixel8, const int32_t *work_pixel, int linesize, int max)
+{
+    uint16_t *out_pixel = (uint16_t *)out_pixel8;
+    int j;
+
+    linesize /= 2;
+    for (j = 0; j < linesize; j++, out_pixel++, work_pixel++)
+        *out_pixel = av_clip(*work_pixel, 0, max) >> 15;
+}
+
 static int config_input(AVFilterLink *inlink)
 {
     AVFilterContext *ctx = inlink->dst;
     W3FDIFContext *s = ctx->priv;
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
-    int ret, i;
+    int ret, i, depth;
 
     if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
         return ret;
@@ -181,14 +286,24 @@ static int config_input(AVFilterLink *inlink)
             return AVERROR(ENOMEM);
     }
 
-    s->dsp.filter_simple_low   = filter_simple_low;
-    s->dsp.filter_complex_low  = filter_complex_low;
-    s->dsp.filter_simple_high  = filter_simple_high;
-    s->dsp.filter_complex_high = filter_complex_high;
-    s->dsp.filter_scale        = filter_scale;
+    depth = desc->comp[0].depth;
+    s->max = ((1 << depth) - 1) * 256 * 128;
+    if (depth <= 8) {
+        s->dsp.filter_simple_low   = filter_simple_low;
+        s->dsp.filter_complex_low  = filter_complex_low;
+        s->dsp.filter_simple_high  = filter_simple_high;
+        s->dsp.filter_complex_high = filter_complex_high;
+        s->dsp.filter_scale        = filter_scale;
+    } else {
+        s->dsp.filter_simple_low   = filter16_simple_low;
+        s->dsp.filter_complex_low  = filter16_complex_low;
+        s->dsp.filter_simple_high  = filter16_simple_high;
+        s->dsp.filter_complex_high = filter16_complex_high;
+        s->dsp.filter_scale        = filter16_scale;
+    }
 
     if (ARCH_X86)
-        ff_w3fdif_init_x86(&s->dsp);
+        ff_w3fdif_init_x86(&s->dsp, depth);
 
     return 0;
 }
@@ -247,10 +362,11 @@ static int deinterlace_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_
     const int dst_line_stride = out->linesize[plane];
     const int start = (height * jobnr) / nb_jobs;
     const int end = (height * (jobnr+1)) / nb_jobs;
+    const int max = s->max;
     int j, y_in, y_out;
 
     /* copy unchanged the lines of the field */
-    y_out = start + (s->field == cur->top_field_first) - (start & 1);
+    y_out = start + ((s->field == cur->top_field_first) ^ (start & 1));
 
     in_line  = cur_data + (y_out * cur_line_stride);
     out_line = dst_data + (y_out * dst_line_stride);
@@ -263,7 +379,7 @@ static int deinterlace_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_
     }
 
     /* interpolate other lines of the field */
-    y_out = start + (s->field != cur->top_field_first) - (start & 1);
+    y_out = start + ((s->field != cur->top_field_first) ^ (start & 1));
 
     out_line = dst_data + (y_out * dst_line_stride);
 
@@ -319,7 +435,7 @@ static int deinterlace_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_
         work_pixel = s->work_line[jobnr];
         out_pixel = out_line;
 
-        s->dsp.filter_scale(out_pixel, work_pixel, linesize);
+        s->dsp.filter_scale(out_pixel, work_pixel, linesize, max);
 
         /* move on to next line */
         y_out += 2;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_waveform.c b/mythtv/external/FFmpeg/libavfilter/vf_waveform.c
index 64abbf2226f..0c574742a0a 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_waveform.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_waveform.c
@@ -166,7 +166,7 @@ static const enum AVPixelFormat in_lowpass_pix_fmts[] = {
     AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P,
     AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
-    AV_PIX_FMT_GRAY8,
+    AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
     AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
     AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10,
@@ -218,12 +218,12 @@ static const enum AVPixelFormat out_rgb9_lowpass_pix_fmts[] = {
 };
 
 static const enum AVPixelFormat out_rgb10_lowpass_pix_fmts[] = {
-    AV_PIX_FMT_GBRP10,
+    AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
     AV_PIX_FMT_NONE
 };
 
 static const enum AVPixelFormat out_rgb12_lowpass_pix_fmts[] = {
-    AV_PIX_FMT_GBRP12,
+    AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12,
     AV_PIX_FMT_NONE
 };
 
@@ -252,6 +252,21 @@ static const enum AVPixelFormat out_gray8_lowpass_pix_fmts[] = {
     AV_PIX_FMT_NONE
 };
 
+static const enum AVPixelFormat out_gray9_lowpass_pix_fmts[] = {
+    AV_PIX_FMT_GRAY9,
+    AV_PIX_FMT_NONE
+};
+
+static const enum AVPixelFormat out_gray10_lowpass_pix_fmts[] = {
+    AV_PIX_FMT_GRAY10,
+    AV_PIX_FMT_NONE
+};
+
+static const enum AVPixelFormat out_gray12_lowpass_pix_fmts[] = {
+    AV_PIX_FMT_GRAY12,
+    AV_PIX_FMT_NONE
+};
+
 static const enum AVPixelFormat flat_pix_fmts[] = {
     AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
@@ -301,6 +316,12 @@ static int query_formats(AVFilterContext *ctx)
 
     if (s->filter == LOWPASS && ncomp == 1 && depth == 8)
         out_pix_fmts = out_gray8_lowpass_pix_fmts;
+    else if (s->filter == LOWPASS && ncomp == 1 && depth == 9)
+        out_pix_fmts = out_gray9_lowpass_pix_fmts;
+    else if (s->filter == LOWPASS && ncomp == 1 && depth == 10)
+        out_pix_fmts = out_gray10_lowpass_pix_fmts;
+    else if (s->filter == LOWPASS && ncomp == 1 && depth == 12)
+        out_pix_fmts = out_gray12_lowpass_pix_fmts;
     else if (rgb && depth == 8 && ncomp > 2)
         out_pix_fmts = out_rgb8_lowpass_pix_fmts;
     else if (rgb && depth == 9 && ncomp > 2)
@@ -2740,7 +2761,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
         return AVERROR(ENOMEM);
     }
     out->pts = in->pts;
-    av_frame_set_color_range(out, AVCOL_RANGE_JPEG);
+    out->color_range = AVCOL_RANGE_JPEG;
 
     for (k = 0; k < s->dcomp; k++) {
         if (s->bits <= 8) {
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_weave.c b/mythtv/external/FFmpeg/libavfilter/vf_weave.c
index a5fc1b7403c..037f5d1cf20 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_weave.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_weave.c
@@ -27,6 +27,7 @@
 typedef struct WeaveContext {
     const AVClass *class;
     int first_field;
+    int double_weave;
     int nb_planes;
     int planeheight[4];
     int linesize[4];
@@ -56,10 +57,12 @@ static int config_props_output(AVFilterLink *outlink)
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
     int ret;
 
-    outlink->time_base.num = inlink->time_base.num * 2;
-    outlink->time_base.den = inlink->time_base.den;
-    outlink->frame_rate.num = inlink->frame_rate.num;
-    outlink->frame_rate.den = inlink->frame_rate.den * 2;
+    if (!s->double_weave) {
+        outlink->time_base.num = inlink->time_base.num * 2;
+        outlink->time_base.den = inlink->time_base.den;
+        outlink->frame_rate.num = inlink->frame_rate.num;
+        outlink->frame_rate.den = inlink->frame_rate.den * 2;
+    }
     outlink->w = inlink->w;
     outlink->h = inlink->h * 2;
 
@@ -96,22 +99,36 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     av_frame_copy_props(out, in);
 
     for (i = 0; i < s->nb_planes; i++) {
-        av_image_copy_plane(out->data[i] + out->linesize[i] * s->first_field,
-                            out->linesize[i] * 2,
-                            in->data[i], in->linesize[i],
-                            s->linesize[i], s->planeheight[i]);
-        av_image_copy_plane(out->data[i] + out->linesize[i] * !s->first_field,
-                            out->linesize[i] * 2,
-                            s->prev->data[i], s->prev->linesize[i],
-                            s->linesize[i], s->planeheight[i]);
+        if (s->double_weave && !(inlink->frame_count_out & 1)) {
+            av_image_copy_plane(out->data[i] + out->linesize[i] * s->first_field,
+                                out->linesize[i] * 2,
+                                in->data[i], in->linesize[i],
+                                s->linesize[i], s->planeheight[i]);
+            av_image_copy_plane(out->data[i] + out->linesize[i] * !s->first_field,
+                                out->linesize[i] * 2,
+                                s->prev->data[i], s->prev->linesize[i],
+                                s->linesize[i], s->planeheight[i]);
+        } else {
+            av_image_copy_plane(out->data[i] + out->linesize[i] * !s->first_field,
+                                out->linesize[i] * 2,
+                                in->data[i], in->linesize[i],
+                                s->linesize[i], s->planeheight[i]);
+            av_image_copy_plane(out->data[i] + out->linesize[i] * s->first_field,
+                                out->linesize[i] * 2,
+                                s->prev->data[i], s->prev->linesize[i],
+                                s->linesize[i], s->planeheight[i]);
+        }
     }
 
-    out->pts = in->pts / 2;
+    out->pts = s->double_weave ? s->prev->pts : in->pts / 2;
     out->interlaced_frame = 1;
     out->top_field_first = !s->first_field;
 
-    av_frame_free(&in);
+    if (!s->double_weave)
+        av_frame_free(&in);
     av_frame_free(&s->prev);
+    if (s->double_weave)
+        s->prev = in;
     return ff_filter_frame(outlink, out);
 }
 
@@ -149,3 +166,27 @@ AVFilter ff_vf_weave = {
     .inputs        = weave_inputs,
     .outputs       = weave_outputs,
 };
+
+static av_cold int init(AVFilterContext *ctx)
+{
+    WeaveContext *s = ctx->priv;
+
+    if (!strcmp(ctx->filter->name, "doubleweave"))
+        s->double_weave = 1;
+
+    return 0;
+}
+
+#define doubleweave_options weave_options
+AVFILTER_DEFINE_CLASS(doubleweave);
+
+AVFilter ff_vf_doubleweave = {
+    .name          = "doubleweave",
+    .description   = NULL_IF_CONFIG_SMALL("Weave input video fields into double number of frames."),
+    .priv_size     = sizeof(WeaveContext),
+    .priv_class    = &doubleweave_class,
+    .init          = init,
+    .uninit        = uninit,
+    .inputs        = weave_inputs,
+    .outputs       = weave_outputs,
+};
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_xbr.c b/mythtv/external/FFmpeg/libavfilter/vf_xbr.c
index 9893e0cc803..78094e02877 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_xbr.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_xbr.c
@@ -37,9 +37,13 @@
 #define RED_BLUE_MASK 0x00FF00FF
 #define GREEN_MASK    0x0000FF00
 
+#ifdef PI
+#undef PI
+#endif
+
 typedef int (*xbrfunc_t)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
 
-typedef struct {
+typedef struct XBRContext {
     const AVClass *class;
     int n;
     xbrfunc_t func;
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_zoompan.c b/mythtv/external/FFmpeg/libavfilter/vf_zoompan.c
index 7a71503168f..0635171b578 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_zoompan.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_zoompan.c
@@ -23,6 +23,7 @@
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
+#include "filters.h"
 #include "formats.h"
 #include "internal.h"
 #include "video.h"
@@ -80,6 +81,9 @@ typedef struct ZPcontext {
     char *x_expr_str;
     char *y_expr_str;
     char *duration_expr_str;
+
+    AVExpr *zoom_expr, *x_expr, *y_expr;
+
     int w, h;
     double x, y;
     double prev_zoom;
@@ -122,12 +126,26 @@ static int config_output(AVFilterLink *outlink)
 {
     AVFilterContext *ctx = outlink->src;
     ZPContext *s = ctx->priv;
+    int ret;
 
     outlink->w = s->w;
     outlink->h = s->h;
     outlink->time_base = av_inv_q(s->framerate);
     outlink->frame_rate = s->framerate;
     s->desc = av_pix_fmt_desc_get(outlink->format);
+    s->finished = 1;
+
+    ret = av_expr_parse(&s->zoom_expr, s->zoom_expr_str, var_names, NULL, NULL, NULL, NULL, 0, ctx);
+    if (ret < 0)
+        return ret;
+
+    ret = av_expr_parse(&s->x_expr, s->x_expr_str, var_names, NULL, NULL, NULL, NULL, 0, ctx);
+    if (ret < 0)
+        return ret;
+
+    ret = av_expr_parse(&s->y_expr, s->y_expr_str, var_names, NULL, NULL, NULL, NULL, 0, ctx);
+    if (ret < 0)
+        return ret;
 
     return 0;
 }
@@ -149,29 +167,23 @@ static int output_single_frame(AVFilterContext *ctx, AVFrame *in, double *var_va
     var_values[VAR_PDURATION] = s->prev_nb_frames;
     var_values[VAR_TIME] = pts * av_q2d(outlink->time_base);
     var_values[VAR_FRAME] = i;
-    var_values[VAR_ON] = outlink->frame_count + 1;
-    if ((ret = av_expr_parse_and_eval(zoom, s->zoom_expr_str,
-                                      var_names, var_values,
-                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
-        return ret;
+    var_values[VAR_ON] = outlink->frame_count_in + 1;
+
+    *zoom = av_expr_eval(s->zoom_expr, var_values, NULL);
 
     *zoom = av_clipd(*zoom, 1, 10);
     var_values[VAR_ZOOM] = *zoom;
     w = in->width * (1.0 / *zoom);
     h = in->height * (1.0 / *zoom);
 
-    if ((ret = av_expr_parse_and_eval(dx, s->x_expr_str,
-                                      var_names, var_values,
-                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
-        return ret;
+    *dx = av_expr_eval(s->x_expr, var_values, NULL);
+
     x = *dx = av_clipd(*dx, 0, FFMAX(in->width - w, 0));
     var_values[VAR_X] = *dx;
     x &= ~((1 << s->desc->log2_chroma_w) - 1);
 
-    if ((ret = av_expr_parse_and_eval(dy, s->y_expr_str,
-                                      var_names, var_values,
-                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)
-        return ret;
+    *dy = av_expr_eval(s->y_expr, var_values, NULL);
+
     y = *dy = av_clipd(*dy, 0, FFMAX(in->height - h, 0));
     var_values[VAR_Y] = *dy;
     y &= ~((1 << s->desc->log2_chroma_h) - 1);
@@ -191,7 +203,7 @@ static int output_single_frame(AVFilterContext *ctx, AVFrame *in, double *var_va
     s->sws = sws_alloc_context();
     if (!s->sws) {
         ret = AVERROR(ENOMEM);
-        return ret;
+        goto error;
     }
 
     for (k = 0; in->data[k]; k++)
@@ -206,7 +218,7 @@ static int output_single_frame(AVFilterContext *ctx, AVFrame *in, double *var_va
     av_opt_set_int(s->sws, "sws_flags", SWS_BICUBIC, 0);
 
     if ((ret = sws_init_context(s->sws, NULL, NULL)) < 0)
-        return ret;
+        goto error;
 
     sws_scale(s->sws, (const uint8_t *const *)&input, in->linesize, 0, h, out->data, out->linesize);
 
@@ -217,94 +229,91 @@ static int output_single_frame(AVFilterContext *ctx, AVFrame *in, double *var_va
     sws_freeContext(s->sws);
     s->sws = NULL;
     s->current_frame++;
-    return ret;
-}
-
-static int filter_frame(AVFilterLink *inlink, AVFrame *in)
-{
-    AVFilterContext *ctx = inlink->dst;
-    AVFilterLink *outlink = ctx->outputs[0];
-    ZPContext *s = ctx->priv;
-    double nb_frames;
-    int ret;
-
-    av_assert0(s->in == NULL);
-
-    s->finished = 0;
-    s->var_values[VAR_IN_W]  = s->var_values[VAR_IW] = in->width;
-    s->var_values[VAR_IN_H]  = s->var_values[VAR_IH] = in->height;
-    s->var_values[VAR_OUT_W] = s->var_values[VAR_OW] = s->w;
-    s->var_values[VAR_OUT_H] = s->var_values[VAR_OH] = s->h;
-    s->var_values[VAR_IN]    = inlink->frame_count + 1;
-    s->var_values[VAR_ON]    = outlink->frame_count + 1;
-    s->var_values[VAR_PX]    = s->x;
-    s->var_values[VAR_PY]    = s->y;
-    s->var_values[VAR_X]     = 0;
-    s->var_values[VAR_Y]     = 0;
-    s->var_values[VAR_PZOOM] = s->prev_zoom;
-    s->var_values[VAR_ZOOM]  = 1;
-    s->var_values[VAR_PDURATION] = s->prev_nb_frames;
-    s->var_values[VAR_A]     = (double) in->width / in->height;
-    s->var_values[VAR_SAR]   = inlink->sample_aspect_ratio.num ?
-        (double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1;
-    s->var_values[VAR_DAR]   = s->var_values[VAR_A] * s->var_values[VAR_SAR];
-    s->var_values[VAR_HSUB]  = 1 << s->desc->log2_chroma_w;
-    s->var_values[VAR_VSUB]  = 1 << s->desc->log2_chroma_h;
-
-    if ((ret = av_expr_parse_and_eval(&nb_frames, s->duration_expr_str,
-                                      var_names, s->var_values,
-                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
-        av_frame_free(&in);
-        return ret;
-    }
-
-    s->var_values[VAR_DURATION] = s->nb_frames = nb_frames;
-    s->in = in;
-
-    return 0;
-}
-
-static int request_frame(AVFilterLink *outlink)
-{
-    AVFilterContext *ctx = outlink->src;
-    ZPContext *s = ctx->priv;
-    AVFrame *in = s->in;
-    double zoom=-1, dx=-1, dy=-1;
-    int ret = -1;
-
-    if (in) {
-        ret = output_single_frame(ctx, in, s->var_values, s->current_frame,
-                                  &zoom, &dx, &dy);
-        if (ret < 0)
-            goto fail;
-    }
 
     if (s->current_frame >= s->nb_frames) {
-        if (dx != -1)
-            s->x = dx;
-        if (dy != -1)
-            s->y = dy;
-        if (zoom != -1)
-            s->prev_zoom = zoom;
+        if (*dx != -1)
+            s->x = *dx;
+        if (*dy != -1)
+            s->y = *dy;
+        if (*zoom != -1)
+            s->prev_zoom = *zoom;
         s->prev_nb_frames = s->nb_frames;
         s->nb_frames = 0;
         s->current_frame = 0;
         av_frame_free(&s->in);
         s->finished = 1;
-        ret = ff_request_frame(ctx->inputs[0]);
     }
-
-fail:
-    sws_freeContext(s->sws);
-    s->sws = NULL;
-
+    return ret;
+error:
+    av_frame_free(&out);
     return ret;
 }
 
-static int poll_frame(AVFilterLink *link)
+static int activate(AVFilterContext *ctx)
 {
-    ZPContext *s = link->src->priv;
-    return s->nb_frames - s->current_frame;
+    ZPContext *s = ctx->priv;
+    AVFilterLink *inlink = ctx->inputs[0];
+    AVFilterLink *outlink = ctx->outputs[0];
+    int status, ret = 0;
+    int64_t pts;
+
+    if (s->in && ff_outlink_frame_wanted(outlink)) {
+        double zoom = -1, dx = -1, dy = -1;
+
+        ret = output_single_frame(ctx, s->in, s->var_values, s->current_frame,
+                                  &zoom, &dx, &dy);
+        if (ret < 0)
+            return ret;
+    }
+
+    if (!s->in && (ret = ff_inlink_consume_frame(inlink, &s->in)) > 0) {
+        double zoom = -1, dx = -1, dy = -1, nb_frames;
+
+        s->finished = 0;
+        s->var_values[VAR_IN_W]  = s->var_values[VAR_IW] = s->in->width;
+        s->var_values[VAR_IN_H]  = s->var_values[VAR_IH] = s->in->height;
+        s->var_values[VAR_OUT_W] = s->var_values[VAR_OW] = s->w;
+        s->var_values[VAR_OUT_H] = s->var_values[VAR_OH] = s->h;
+        s->var_values[VAR_IN]    = inlink->frame_count_out + 1;
+        s->var_values[VAR_ON]    = outlink->frame_count_in + 1;
+        s->var_values[VAR_PX]    = s->x;
+        s->var_values[VAR_PY]    = s->y;
+        s->var_values[VAR_X]     = 0;
+        s->var_values[VAR_Y]     = 0;
+        s->var_values[VAR_PZOOM] = s->prev_zoom;
+        s->var_values[VAR_ZOOM]  = 1;
+        s->var_values[VAR_PDURATION] = s->prev_nb_frames;
+        s->var_values[VAR_A]     = (double) s->in->width / s->in->height;
+        s->var_values[VAR_SAR]   = inlink->sample_aspect_ratio.num ?
+            (double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1;
+        s->var_values[VAR_DAR]   = s->var_values[VAR_A] * s->var_values[VAR_SAR];
+        s->var_values[VAR_HSUB]  = 1 << s->desc->log2_chroma_w;
+        s->var_values[VAR_VSUB]  = 1 << s->desc->log2_chroma_h;
+
+        if ((ret = av_expr_parse_and_eval(&nb_frames, s->duration_expr_str,
+                                          var_names, s->var_values,
+                                          NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
+            av_frame_free(&s->in);
+            return ret;
+        }
+
+        s->var_values[VAR_DURATION] = s->nb_frames = nb_frames;
+
+        ret = output_single_frame(ctx, s->in, s->var_values, s->current_frame,
+                                  &zoom, &dx, &dy);
+        if (ret < 0)
+            return ret;
+    }
+    if (ret < 0) {
+        return ret;
+    } else if (s->finished && ff_inlink_acknowledge_status(inlink, &status, &pts)) {
+        ff_outlink_set_status(outlink, status, pts);
+        return 0;
+    } else {
+        if (ff_outlink_frame_wanted(outlink) && s->finished)
+            ff_inlink_request_frame(inlink);
+        return 0;
+    }
 }
 
 static int query_formats(AVFilterContext *ctx)
@@ -341,8 +350,6 @@ static const AVFilterPad inputs[] = {
     {
         .name         = "default",
         .type         = AVMEDIA_TYPE_VIDEO,
-        .filter_frame = filter_frame,
-        .needs_fifo   = 1,
     },
     { NULL }
 };
@@ -352,8 +359,6 @@ static const AVFilterPad outputs[] = {
         .name          = "default",
         .type          = AVMEDIA_TYPE_VIDEO,
         .config_props  = config_output,
-        .poll_frame    = poll_frame,
-        .request_frame = request_frame,
     },
     { NULL }
 };
@@ -366,7 +371,7 @@ AVFilter ff_vf_zoompan = {
     .init          = init,
     .uninit        = uninit,
     .query_formats = query_formats,
+    .activate      = activate,
     .inputs        = inputs,
     .outputs       = outputs,
-    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
 };
diff --git a/mythtv/external/FFmpeg/libavfilter/vf_zscale.c b/mythtv/external/FFmpeg/libavfilter/vf_zscale.c
index bc884262c48..c303dd4d63d 100644
--- a/mythtv/external/FFmpeg/libavfilter/vf_zscale.c
+++ b/mythtv/external/FFmpeg/libavfilter/vf_zscale.c
@@ -23,6 +23,7 @@
  * zscale video filter using z.lib library
  */
 
+#include <float.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -35,6 +36,7 @@
 #include "libavutil/avstring.h"
 #include "libavutil/eval.h"
 #include "libavutil/internal.h"
+#include "libavutil/intreadwrite.h"
 #include "libavutil/mathematics.h"
 #include "libavutil/opt.h"
 #include "libavutil/parseutils.h"
@@ -95,6 +97,8 @@ typedef struct ZScaleContext {
     int range_in;
     int chromal_in;
     char *size_str;
+    double nominal_peak_luminance;
+    int approximate_gamma;
 
     char *w_expr;               ///< width  expression string
     char *h_expr;               ///< height expression string
@@ -176,6 +180,7 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
         AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP16,
+        AV_PIX_FMT_GBRPF32, AV_PIX_FMT_GBRAPF32,
         AV_PIX_FMT_NONE
     };
     int ret;
@@ -377,6 +382,12 @@ static int convert_trc(enum AVColorTransferCharacteristic color_trc)
         return ZIMG_TRANSFER_2020_10;
     case AVCOL_TRC_BT2020_12:
         return ZIMG_TRANSFER_2020_12;
+    case AVCOL_TRC_SMPTE2084:
+        return ZIMG_TRANSFER_ST2084;
+    case AVCOL_TRC_ARIB_STD_B67:
+        return ZIMG_TRANSFER_ARIB_B67;
+    case AVCOL_TRC_IEC61966_2_1:
+        return ZIMG_TRANSFER_IEC_61966_2_1;
     }
     return ZIMG_TRANSFER_UNSPECIFIED;
 }
@@ -394,6 +405,8 @@ static int convert_primaries(enum AVColorPrimaries color_primaries)
         return ZIMG_PRIMARIES_240M;
     case AVCOL_PRI_BT2020:
         return ZIMG_PRIMARIES_2020;
+    case AVCOL_PRI_SMPTE432:
+        return ZIMG_PRIMARIES_ST432_1;
     }
     return ZIMG_PRIMARIES_UNSPECIFIED;
 }
@@ -410,6 +423,51 @@ static int convert_range(enum AVColorRange color_range)
     return ZIMG_RANGE_LIMITED;
 }
 
+static void format_init(zimg_image_format *format, AVFrame *frame, const AVPixFmtDescriptor *desc,
+                        int colorspace, int primaries, int transfer, int range, int location)
+{
+    format->width = frame->width;
+    format->height = frame->height;
+    format->subsample_w = desc->log2_chroma_w;
+    format->subsample_h = desc->log2_chroma_h;
+    format->depth = desc->comp[0].depth;
+    format->pixel_type = (desc->flags & AV_PIX_FMT_FLAG_FLOAT) ? ZIMG_PIXEL_FLOAT : desc->comp[0].depth > 8 ? ZIMG_PIXEL_WORD : ZIMG_PIXEL_BYTE;
+    format->color_family = (desc->flags & AV_PIX_FMT_FLAG_RGB) ? ZIMG_COLOR_RGB : ZIMG_COLOR_YUV;
+    format->matrix_coefficients = (desc->flags & AV_PIX_FMT_FLAG_RGB) ? ZIMG_MATRIX_RGB : colorspace == -1 ? convert_matrix(frame->colorspace) : colorspace;
+    format->color_primaries = primaries == -1 ? convert_primaries(frame->color_primaries) : primaries;
+    format->transfer_characteristics = transfer == - 1 ? convert_trc(frame->color_trc) : transfer;
+    format->pixel_range = (desc->flags & AV_PIX_FMT_FLAG_RGB) ? ZIMG_RANGE_FULL : range == -1 ? convert_range(frame->color_range) : range;
+    format->chroma_location = location == -1 ? convert_chroma_location(frame->chroma_location) : location;
+}
+
+static int graph_build(zimg_filter_graph **graph, zimg_graph_builder_params *params,
+                       zimg_image_format *src_format, zimg_image_format *dst_format,
+                       void **tmp, size_t *tmp_size)
+{
+    int ret;
+    size_t size;
+
+    zimg_filter_graph_free(*graph);
+    *graph = zimg_filter_graph_build(src_format, dst_format, params);
+    if (!*graph)
+        return print_zimg_error(NULL);
+
+    ret = zimg_filter_graph_get_tmp_size(*graph, &size);
+    if (ret)
+        return print_zimg_error(NULL);
+
+    if (size > *tmp_size) {
+        av_freep(tmp);
+        *tmp = av_malloc(size);
+        if (!*tmp)
+            return AVERROR(ENOMEM);
+
+        *tmp_size = size;
+    }
+
+    return 0;
+}
+
 static int filter_frame(AVFilterLink *link, AVFrame *in)
 {
     ZScaleContext *s = link->dst->priv;
@@ -419,7 +477,6 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
     zimg_image_buffer_const src_buf = { ZIMG_API_VERSION };
     zimg_image_buffer dst_buf = { ZIMG_API_VERSION };
     char buf[32];
-    size_t tmp_size;
     int ret = 0, plane;
     AVFrame *out;
 
@@ -469,32 +526,13 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
         s->params.cpu_type = ZIMG_CPU_AUTO;
         s->params.resample_filter = s->filter;
         s->params.resample_filter_uv = s->filter;
+        s->params.nominal_peak_luminance = s->nominal_peak_luminance;
+        s->params.allow_approximate_gamma = s->approximate_gamma;
 
-        s->src_format.width = in->width;
-        s->src_format.height = in->height;
-        s->src_format.subsample_w = desc->log2_chroma_w;
-        s->src_format.subsample_h = desc->log2_chroma_h;
-        s->src_format.depth = desc->comp[0].depth;
-        s->src_format.pixel_type = desc->comp[0].depth > 8 ? ZIMG_PIXEL_WORD : ZIMG_PIXEL_BYTE;
-        s->src_format.color_family = (desc->flags & AV_PIX_FMT_FLAG_RGB) ? ZIMG_COLOR_RGB : ZIMG_COLOR_YUV;
-        s->src_format.matrix_coefficients = (desc->flags & AV_PIX_FMT_FLAG_RGB) ? ZIMG_MATRIX_RGB : s->colorspace_in == -1 ? convert_matrix(in->colorspace) : s->colorspace_in;
-        s->src_format.transfer_characteristics = s->trc_in == - 1 ? convert_trc(in->color_trc) : s->trc_in;
-        s->src_format.color_primaries = s->primaries_in == -1 ? convert_primaries(in->color_primaries) : s->primaries_in;
-        s->src_format.pixel_range = (desc->flags & AV_PIX_FMT_FLAG_RGB) ? ZIMG_RANGE_FULL : s->range_in == -1 ? convert_range(in->color_range) : s->range_in;
-        s->src_format.chroma_location = s->chromal_in == -1 ? convert_chroma_location(in->chroma_location) : s->chromal_in;
-
-        s->dst_format.width = out->width;
-        s->dst_format.height = out->height;
-        s->dst_format.subsample_w = odesc->log2_chroma_w;
-        s->dst_format.subsample_h = odesc->log2_chroma_h;
-        s->dst_format.depth = odesc->comp[0].depth;
-        s->dst_format.pixel_type = odesc->comp[0].depth > 8 ? ZIMG_PIXEL_WORD : ZIMG_PIXEL_BYTE;
-        s->dst_format.color_family = (odesc->flags & AV_PIX_FMT_FLAG_RGB) ? ZIMG_COLOR_RGB : ZIMG_COLOR_YUV;
-        s->dst_format.matrix_coefficients = (odesc->flags & AV_PIX_FMT_FLAG_RGB) ? ZIMG_MATRIX_RGB : s->colorspace == -1 ? convert_matrix(out->colorspace) : s->colorspace;
-        s->dst_format.transfer_characteristics = s->trc == -1 ? convert_trc(out->color_trc) : s->trc;
-        s->dst_format.color_primaries = s->primaries == -1 ? convert_primaries(out->color_primaries) : s->primaries;
-        s->dst_format.pixel_range = (odesc->flags & AV_PIX_FMT_FLAG_RGB) ? ZIMG_RANGE_FULL : s->range == -1 ? convert_range(out->color_range) : s->range;
-        s->dst_format.chroma_location = s->chromal == -1 ? convert_chroma_location(out->chroma_location) : s->chromal;
+        format_init(&s->src_format, in, desc, s->colorspace_in,
+                    s->primaries_in, s->trc_in, s->range_in, s->chromal_in);
+        format_init(&s->dst_format, out, odesc, s->colorspace,
+                    s->primaries, s->trc, s->range, s->chromal);
 
         if (s->colorspace != -1)
             out->colorspace = (int)s->dst_format.matrix_coefficients;
@@ -511,27 +549,10 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
         if (s->chromal != -1)
             out->chroma_location = (int)s->dst_format.chroma_location - 1;
 
-        zimg_filter_graph_free(s->graph);
-        s->graph = zimg_filter_graph_build(&s->src_format, &s->dst_format, &s->params);
-        if (!s->graph) {
-            ret = print_zimg_error(link->dst);
+        ret = graph_build(&s->graph, &s->params, &s->src_format, &s->dst_format,
+                          &s->tmp, &s->tmp_size);
+        if (ret < 0)
             goto fail;
-        }
-
-        if ((ret = zimg_filter_graph_get_tmp_size(s->graph, &tmp_size))) {
-            ret = print_zimg_error(link->dst);
-            goto fail;
-        }
-
-        if (tmp_size > s->tmp_size) {
-            av_freep(&s->tmp);
-            s->tmp = av_malloc(tmp_size);
-            if (!s->tmp) {
-                ret = AVERROR(ENOMEM);
-                goto fail;
-            }
-            s->tmp_size = tmp_size;
-        }
 
         s->in_colorspace  = in->colorspace;
         s->in_trc         = in->color_trc;
@@ -554,13 +575,13 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
             s->alpha_src_format.width = in->width;
             s->alpha_src_format.height = in->height;
             s->alpha_src_format.depth = desc->comp[0].depth;
-            s->alpha_src_format.pixel_type = desc->comp[0].depth > 8 ? ZIMG_PIXEL_WORD : ZIMG_PIXEL_BYTE;
+            s->alpha_src_format.pixel_type = (desc->flags & AV_PIX_FMT_FLAG_FLOAT) ? ZIMG_PIXEL_FLOAT : desc->comp[0].depth > 8 ? ZIMG_PIXEL_WORD : ZIMG_PIXEL_BYTE;
             s->alpha_src_format.color_family = ZIMG_COLOR_GREY;
 
             s->alpha_dst_format.width = out->width;
             s->alpha_dst_format.height = out->height;
             s->alpha_dst_format.depth = odesc->comp[0].depth;
-            s->alpha_dst_format.pixel_type = odesc->comp[0].depth > 8 ? ZIMG_PIXEL_WORD : ZIMG_PIXEL_BYTE;
+            s->alpha_dst_format.pixel_type = (desc->flags & AV_PIX_FMT_FLAG_FLOAT) ? ZIMG_PIXEL_FLOAT : odesc->comp[0].depth > 8 ? ZIMG_PIXEL_WORD : ZIMG_PIXEL_BYTE;
             s->alpha_dst_format.color_family = ZIMG_COLOR_GREY;
 
             zimg_filter_graph_free(s->alpha_graph);
@@ -622,10 +643,19 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
             goto fail;
         }
     } else if (odesc->flags & AV_PIX_FMT_FLAG_ALPHA) {
-        int y;
-
-        for (y = 0; y < outlink->h; y++)
-            memset(out->data[3] + y * out->linesize[3], 0xff, outlink->w);
+        int x, y;
+
+        if (odesc->flags & AV_PIX_FMT_FLAG_FLOAT) {
+            for (y = 0; y < out->height; y++) {
+                for (x = 0; x < out->width; x++) {
+                    AV_WN32(out->data[3] + x * odesc->comp[3].step + y * out->linesize[3],
+                            av_float2int(1.0f));
+                }
+            }
+        } else {
+            for (y = 0; y < outlink->h; y++)
+                memset(out->data[3] + y * out->linesize[3], 0xff, outlink->w);
+        }
     }
 
 fail:
@@ -695,21 +725,31 @@ static const AVOption zscale_options[] = {
     {     "spline16",         0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_RESIZE_SPLINE16}, 0, 0, FLAGS, "filter" },
     {     "spline36",         0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_RESIZE_SPLINE36}, 0, 0, FLAGS, "filter" },
     {     "lanczos",          0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_RESIZE_LANCZOS},  0, 0, FLAGS, "filter" },
+    { "out_range", "set color range",  OFFSET(range),     AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_RANGE_FULL, FLAGS, "range" },
     { "range", "set color range",      OFFSET(range),     AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_RANGE_FULL, FLAGS, "range" },
     { "r",     "set color range",      OFFSET(range),     AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_RANGE_FULL, FLAGS, "range" },
     {     "input",            0,       0,                 AV_OPT_TYPE_CONST, {.i64 = -1},                 0, 0, FLAGS, "range" },
     {     "limited",          0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_RANGE_LIMITED}, 0, 0, FLAGS, "range" },
     {     "full",             0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_RANGE_FULL},    0, 0, FLAGS, "range" },
-    { "primaries", "set color primaries", OFFSET(primaries), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_PRIMARIES_2020, FLAGS, "primaries" },
-    { "p",         "set color primaries", OFFSET(primaries), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_PRIMARIES_2020, FLAGS, "primaries" },
+    {     "unknown",          0,       0,                 AV_OPT_TYPE_CONST, {.i64 = -1},                 0, 0, FLAGS, "range" },
+    {     "tv",               0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_RANGE_LIMITED}, 0, 0, FLAGS, "range" },
+    {     "pc",               0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_RANGE_FULL},    0, 0, FLAGS, "range" },
+    { "primaries", "set color primaries", OFFSET(primaries), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_PRIMARIES_ST432_1, FLAGS, "primaries" },
+    { "p",         "set color primaries", OFFSET(primaries), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_PRIMARIES_ST432_1, FLAGS, "primaries" },
     {     "input",            0,       0,                 AV_OPT_TYPE_CONST, {.i64 = -1},                         0, 0, FLAGS, "primaries" },
     {     "709",              0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_PRIMARIES_709},         0, 0, FLAGS, "primaries" },
     {     "unspecified",      0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_PRIMARIES_UNSPECIFIED}, 0, 0, FLAGS, "primaries" },
     {     "170m",             0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_PRIMARIES_170M},        0, 0, FLAGS, "primaries" },
     {     "240m",             0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_PRIMARIES_240M},        0, 0, FLAGS, "primaries" },
     {     "2020",             0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_PRIMARIES_2020},        0, 0, FLAGS, "primaries" },
-    { "transfer", "set transfer characteristic", OFFSET(trc), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_TRANSFER_2020_12, FLAGS, "transfer" },
-    { "t",        "set transfer characteristic", OFFSET(trc), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_TRANSFER_2020_12, FLAGS, "transfer" },
+    {     "unknown",          0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_PRIMARIES_UNSPECIFIED}, 0, 0, FLAGS, "primaries" },
+    {     "bt709",            0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_PRIMARIES_709},         0, 0, FLAGS, "primaries" },
+    {     "smpte170m",        0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_PRIMARIES_170M},        0, 0, FLAGS, "primaries" },
+    {     "smpte240m",        0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_PRIMARIES_240M},        0, 0, FLAGS, "primaries" },
+    {     "bt2020",           0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_PRIMARIES_2020},        0, 0, FLAGS, "primaries" },
+    {     "smpte432",         0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_PRIMARIES_ST432_1},     0, 0, FLAGS, "primaries" },
+    { "transfer", "set transfer characteristic", OFFSET(trc), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_TRANSFER_ARIB_B67, FLAGS, "transfer" },
+    { "t",        "set transfer characteristic", OFFSET(trc), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_TRANSFER_ARIB_B67, FLAGS, "transfer" },
     {     "input",            0,       0,                 AV_OPT_TYPE_CONST, {.i64 = -1},                         0, 0, FLAGS, "transfer" },
     {     "709",              0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_709},         0, 0, FLAGS, "transfer" },
     {     "unspecified",      0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_UNSPECIFIED}, 0, 0, FLAGS, "transfer" },
@@ -717,6 +757,15 @@ static const AVOption zscale_options[] = {
     {     "linear",           0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_LINEAR},      0, 0, FLAGS, "transfer" },
     {     "2020_10",          0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_2020_10},     0, 0, FLAGS, "transfer" },
     {     "2020_12",          0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_2020_12},     0, 0, FLAGS, "transfer" },
+    {     "unknown",          0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_UNSPECIFIED}, 0, 0, FLAGS, "transfer" },
+    {     "smpte170m",        0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_601},         0, 0, FLAGS, "transfer" },
+    {     "bt709",            0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_709},         0, 0, FLAGS, "transfer" },
+    {     "linear",           0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_LINEAR},      0, 0, FLAGS, "transfer" },
+    {     "bt2020-10",        0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_2020_10},     0, 0, FLAGS, "transfer" },
+    {     "bt2020-12",        0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_2020_12},     0, 0, FLAGS, "transfer" },
+    {     "smpte2084",        0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_ST2084},      0, 0, FLAGS, "transfer" },
+    {     "iec61966-2-1",     0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_IEC_61966_2_1},0, 0, FLAGS, "transfer" },
+    {     "arib-std-b67",     0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_TRANSFER_ARIB_B67},    0, 0, FLAGS, "transfer" },
     { "matrix", "set colorspace matrix", OFFSET(colorspace), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_MATRIX_2020_CL, FLAGS, "matrix" },
     { "m",      "set colorspace matrix", OFFSET(colorspace), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_MATRIX_2020_CL, FLAGS, "matrix" },
     {     "input",            0,       0,                 AV_OPT_TYPE_CONST, {.i64 = -1},                      0, 0, FLAGS, "matrix" },
@@ -724,15 +773,22 @@ static const AVOption zscale_options[] = {
     {     "unspecified",      0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_UNSPECIFIED}, 0, 0, FLAGS, "matrix" },
     {     "470bg",            0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_470BG},       0, 0, FLAGS, "matrix" },
     {     "170m",             0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_170M},        0, 0, FLAGS, "matrix" },
-    {     "ycgco",            0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_YCGCO},       0, 0, FLAGS, "matrix" },
     {     "2020_ncl",         0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_2020_NCL},    0, 0, FLAGS, "matrix" },
     {     "2020_cl",          0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_2020_CL},     0, 0, FLAGS, "matrix" },
+    {     "unknown",          0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_UNSPECIFIED}, 0, 0, FLAGS, "matrix" },
+    {     "bt709",            0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_709},         0, 0, FLAGS, "matrix" },
+    {     "bt470bg",          0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_470BG},       0, 0, FLAGS, "matrix" },
+    {     "smpte170m",        0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_170M},        0, 0, FLAGS, "matrix" },
+    {     "ycgco",            0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_YCGCO},       0, 0, FLAGS, "matrix" },
+    {     "bt2020nc",         0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_2020_NCL},    0, 0, FLAGS, "matrix" },
+    {     "bt2020c",          0,       0,                 AV_OPT_TYPE_CONST, {.i64 = ZIMG_MATRIX_2020_CL},     0, 0, FLAGS, "matrix" },
+    { "in_range", "set input color range", OFFSET(range_in),    AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_RANGE_FULL, FLAGS, "range" },
     { "rangein", "set input color range", OFFSET(range_in),     AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_RANGE_FULL, FLAGS, "range" },
     { "rin",     "set input color range", OFFSET(range_in),     AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_RANGE_FULL, FLAGS, "range" },
-    { "primariesin", "set input color primaries", OFFSET(primaries_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_PRIMARIES_2020, FLAGS, "primaries" },
-    { "pin",         "set input color primaries", OFFSET(primaries_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_PRIMARIES_2020, FLAGS, "primaries" },
-    { "transferin", "set input transfer characteristic", OFFSET(trc_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_TRANSFER_2020_12, FLAGS, "transfer" },
-    { "tin",        "set input transfer characteristic", OFFSET(trc_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_TRANSFER_2020_12, FLAGS, "transfer" },
+    { "primariesin", "set input color primaries", OFFSET(primaries_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_PRIMARIES_ST432_1, FLAGS, "primaries" },
+    { "pin",         "set input color primaries", OFFSET(primaries_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_PRIMARIES_ST432_1, FLAGS, "primaries" },
+    { "transferin", "set input transfer characteristic", OFFSET(trc_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_TRANSFER_ARIB_B67, FLAGS, "transfer" },
+    { "tin",        "set input transfer characteristic", OFFSET(trc_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_TRANSFER_ARIB_B67, FLAGS, "transfer" },
     { "matrixin", "set input colorspace matrix", OFFSET(colorspace_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_MATRIX_2020_CL, FLAGS, "matrix" },
     { "min",      "set input colorspace matrix", OFFSET(colorspace_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_MATRIX_2020_CL, FLAGS, "matrix" },
     { "chromal",  "set output chroma location", OFFSET(chromal), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_CHROMA_BOTTOM, FLAGS, "chroma" },
@@ -746,6 +802,8 @@ static const AVOption zscale_options[] = {
     {     "bottom",    0, 0, AV_OPT_TYPE_CONST, {.i64 = ZIMG_CHROMA_BOTTOM},       0, 0, FLAGS, "chroma" },
     { "chromalin",  "set input chroma location", OFFSET(chromal_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_CHROMA_BOTTOM, FLAGS, "chroma" },
     { "cin",        "set input chroma location", OFFSET(chromal_in), AV_OPT_TYPE_INT, {.i64 = -1}, -1, ZIMG_CHROMA_BOTTOM, FLAGS, "chroma" },
+    { "npl",       "set nominal peak luminance", OFFSET(nominal_peak_luminance), AV_OPT_TYPE_DOUBLE, {.dbl = NAN}, 0, DBL_MAX, FLAGS },
+    { "agamma",       "allow approximate gamma", OFFSET(approximate_gamma),      AV_OPT_TYPE_BOOL,   {.i64 = 1},   0, 1,       FLAGS },
     { NULL }
 };
 
diff --git a/mythtv/external/FFmpeg/libavfilter/video.c b/mythtv/external/FFmpeg/libavfilter/video.c
index 2744be6360d..6f9020b9fe0 100644
--- a/mythtv/external/FFmpeg/libavfilter/video.c
+++ b/mythtv/external/FFmpeg/libavfilter/video.c
@@ -25,6 +25,7 @@
 
 #include "libavutil/avassert.h"
 #include "libavutil/buffer.h"
+#include "libavutil/hwcontext.h"
 #include "libavutil/imgutils.h"
 #include "libavutil/mem.h"
 
@@ -47,13 +48,28 @@ AVFrame *ff_default_get_video_buffer(AVFilterLink *link, int w, int h)
     int pool_align = 0;
     enum AVPixelFormat pool_format = AV_PIX_FMT_NONE;
 
-    if (!link->video_frame_pool) {
-        link->video_frame_pool = ff_video_frame_pool_init(av_buffer_allocz, w, h,
-                                                          link->format, BUFFER_ALIGN);
-        if (!link->video_frame_pool)
+    if (link->hw_frames_ctx &&
+        ((AVHWFramesContext*)link->hw_frames_ctx->data)->format == link->format) {
+        int ret;
+        AVFrame *frame = av_frame_alloc();
+
+        if (!frame)
+            return NULL;
+
+        ret = av_hwframe_get_buffer(link->hw_frames_ctx, frame, 0);
+        if (ret < 0)
+            av_frame_free(&frame);
+
+        return frame;
+    }
+
+    if (!link->frame_pool) {
+        link->frame_pool = ff_frame_pool_video_init(av_buffer_allocz, w, h,
+                                                    link->format, BUFFER_ALIGN);
+        if (!link->frame_pool)
             return NULL;
     } else {
-        if (ff_video_frame_pool_get_config(link->video_frame_pool,
+        if (ff_frame_pool_get_video_config(link->frame_pool,
                                            &pool_width, &pool_height,
                                            &pool_format, &pool_align) < 0) {
             return NULL;
@@ -62,15 +78,15 @@ AVFrame *ff_default_get_video_buffer(AVFilterLink *link, int w, int h)
         if (pool_width != w || pool_height != h ||
             pool_format != link->format || pool_align != BUFFER_ALIGN) {
 
-            ff_video_frame_pool_uninit((FFVideoFramePool **)&link->video_frame_pool);
-            link->video_frame_pool = ff_video_frame_pool_init(av_buffer_allocz, w, h,
-                                                              link->format, BUFFER_ALIGN);
-            if (!link->video_frame_pool)
+            ff_frame_pool_uninit((FFFramePool **)&link->frame_pool);
+            link->frame_pool = ff_frame_pool_video_init(av_buffer_allocz, w, h,
+                                                        link->format, BUFFER_ALIGN);
+            if (!link->frame_pool)
                 return NULL;
         }
     }
 
-    return ff_video_frame_pool_get(link->video_frame_pool);
+    return ff_frame_pool_get(link->frame_pool);
 }
 
 AVFrame *ff_get_video_buffer(AVFilterLink *link, int w, int h)
diff --git a/mythtv/external/FFmpeg/libavfilter/vidstabutils.c b/mythtv/external/FFmpeg/libavfilter/vidstabutils.c
index 13544cf5739..1199dbd56e3 100644
--- a/mythtv/external/FFmpeg/libavfilter/vidstabutils.c
+++ b/mythtv/external/FFmpeg/libavfilter/vidstabutils.c
@@ -42,7 +42,7 @@ VSPixelFormat ff_av2vs_pixfmt(AVFilterContext *ctx, enum AVPixelFormat pf)
 }
 
 /** struct to hold a valid context for logging from within vid.stab lib */
-typedef struct {
+typedef struct VS2AVLogCtx {
     const AVClass *class;
 } VS2AVLogCtx;
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vmaf_motion.h b/mythtv/external/FFmpeg/libavfilter/vmaf_motion.h
new file mode 100644
index 00000000000..09984506824
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/vmaf_motion.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2017 Ronald S. Bultje <rsbultje@gmail.com>
+ * Copyright (c) 2017 Ashish Pratap Singh <ashk43712@gmail.com>
+ *
+ * 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 AVFILTER_VMAF_MOTION_H
+#define AVFILTER_VMAF_MOTION_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include "video.h"
+
+typedef struct VMAFMotionDSPContext {
+    uint64_t (*sad)(const uint16_t *img1, const uint16_t *img2, int w, int h,
+                    ptrdiff_t img1_stride, ptrdiff_t img2_stride);
+    void (*convolution_x)(const uint16_t *filter, int filt_w, const uint16_t *src,
+                          uint16_t *dst, int w, int h, ptrdiff_t src_stride,
+                          ptrdiff_t dst_stride);
+    void (*convolution_y)(const uint16_t *filter, int filt_w, const uint8_t *src,
+                          uint16_t *dst, int w, int h, ptrdiff_t src_stride,
+                          ptrdiff_t dst_stride);
+} VMAFMotionDSPContext;
+
+void ff_vmafmotion_init_x86(VMAFMotionDSPContext *dsp);
+
+typedef struct VMAFMotionData {
+    uint16_t filter[5];
+    int width;
+    int height;
+    ptrdiff_t stride;
+    uint16_t *blur_data[2 /* cur, prev */];
+    uint16_t *temp_data;
+    double motion_sum;
+    uint64_t nb_frames;
+    VMAFMotionDSPContext vmafdsp;
+} VMAFMotionData;
+
+int ff_vmafmotion_init(VMAFMotionData *data, int w, int h, enum AVPixelFormat fmt);
+double ff_vmafmotion_process(VMAFMotionData *data, AVFrame *frame);
+double ff_vmafmotion_uninit(VMAFMotionData *data);
+
+#endif /* AVFILTER_VMAF_MOTION_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/vsrc_cellauto.c b/mythtv/external/FFmpeg/libavfilter/vsrc_cellauto.c
index 4961f762f42..7a6d9659f7a 100644
--- a/mythtv/external/FFmpeg/libavfilter/vsrc_cellauto.c
+++ b/mythtv/external/FFmpeg/libavfilter/vsrc_cellauto.c
@@ -37,7 +37,7 @@
 #include "formats.h"
 #include "video.h"
 
-typedef struct {
+typedef struct CellAutoContext {
     const AVClass *class;
     int w, h;
     char *filename;
@@ -199,7 +199,7 @@ static av_cold int init(AVFilterContext *ctx)
     }
 
     av_log(ctx, AV_LOG_VERBOSE,
-           "s:%dx%d r:%d/%d rule:%d stitch:%d scroll:%d full:%d seed:%u\n",
+           "s:%dx%d r:%d/%d rule:%d stitch:%d scroll:%d full:%d seed:%"PRIu32"\n",
            s->w, s->h, s->frame_rate.num, s->frame_rate.den,
            s->rule, s->stitch, s->scroll, s->start_full,
            s->random_seed);
diff --git a/mythtv/external/FFmpeg/libavfilter/vsrc_life.c b/mythtv/external/FFmpeg/libavfilter/vsrc_life.c
index 8d510514870..a87ceef15d4 100644
--- a/mythtv/external/FFmpeg/libavfilter/vsrc_life.c
+++ b/mythtv/external/FFmpeg/libavfilter/vsrc_life.c
@@ -38,7 +38,7 @@
 #include "formats.h"
 #include "video.h"
 
-typedef struct {
+typedef struct LifeContext {
     const AVClass *class;
     int w, h;
     char *filename;
@@ -260,7 +260,7 @@ static av_cold int init(AVFilterContext *ctx)
     }
 
     av_log(ctx, AV_LOG_VERBOSE,
-           "s:%dx%d r:%d/%d rule:%s stay_rule:%d born_rule:%d stitch:%d seed:%u\n",
+           "s:%dx%d r:%d/%d rule:%s stay_rule:%d born_rule:%d stitch:%d seed:%"PRIu32"\n",
            life->w, life->h, life->frame_rate.num, life->frame_rate.den,
            life->rule_str, life->stay_rule, life->born_rule, life->stitch,
            life->random_seed);
diff --git a/mythtv/external/FFmpeg/libavfilter/vsrc_mandelbrot.c b/mythtv/external/FFmpeg/libavfilter/vsrc_mandelbrot.c
index 2f6944f02fd..6ad108151f6 100644
--- a/mythtv/external/FFmpeg/libavfilter/vsrc_mandelbrot.c
+++ b/mythtv/external/FFmpeg/libavfilter/vsrc_mandelbrot.c
@@ -57,7 +57,7 @@ typedef struct Point {
     uint32_t val;
 } Point;
 
-typedef struct {
+typedef struct MBContext {
     const AVClass *class;
     int w, h;
     AVRational frame_rate;
diff --git a/mythtv/external/FFmpeg/libavfilter/vsrc_mptestsrc.c b/mythtv/external/FFmpeg/libavfilter/vsrc_mptestsrc.c
index 3c758212bae..c5fdea75dc7 100644
--- a/mythtv/external/FFmpeg/libavfilter/vsrc_mptestsrc.c
+++ b/mythtv/external/FFmpeg/libavfilter/vsrc_mptestsrc.c
@@ -303,7 +303,7 @@ static int request_frame(AVFilterLink *outlink)
     AVFrame *picref;
     int w = WIDTH, h = HEIGHT,
         cw = AV_CEIL_RSHIFT(w, test->hsub), ch = AV_CEIL_RSHIFT(h, test->vsub);
-    unsigned int frame = outlink->frame_count;
+    unsigned int frame = outlink->frame_count_in;
     enum test_type tt = test->test;
     int i;
 
diff --git a/mythtv/external/FFmpeg/libavfilter/vsrc_testsrc.c b/mythtv/external/FFmpeg/libavfilter/vsrc_testsrc.c
index 08f6e07e501..fe0d50aa41a 100644
--- a/mythtv/external/FFmpeg/libavfilter/vsrc_testsrc.c
+++ b/mythtv/external/FFmpeg/libavfilter/vsrc_testsrc.c
@@ -66,6 +66,9 @@ typedef struct TestSourceContext {
     /* only used by testsrc */
     int nb_decimals;
 
+    /* only used by testsrc2 */
+    int alpha;
+
     /* only used by color */
     FFDrawContext draw;
     FFDrawColor color;
@@ -685,6 +688,7 @@ AVFilter ff_vsrc_testsrc = {
 
 static const AVOption testsrc2_options[] = {
     COMMON_OPTIONS
+    { "alpha", "set global alpha (opacity)", OFFSET(alpha), AV_OPT_TYPE_INT, {.i64 = 255}, 0, 255, FLAGS },
     { NULL }
 };
 
@@ -735,6 +739,7 @@ static void test2_fill_picture(AVFilterContext *ctx, AVFrame *frame)
 {
     TestSourceContext *s = ctx->priv;
     FFDrawColor color;
+    unsigned alpha = (uint32_t)s->alpha << 24;
 
     /* colored background */
     {
@@ -746,7 +751,8 @@ static void test2_fill_picture(AVFilterContext *ctx, AVFrame *frame)
             x2 = ff_draw_round_to_sub(&s->draw, 0, 0, x2);
             set_color(s, &color, ((i & 1) ? 0xFF0000 : 0) |
                                  ((i & 2) ? 0x00FF00 : 0) |
-                                 ((i & 4) ? 0x0000FF : 0));
+                                 ((i & 4) ? 0x0000FF : 0) |
+                                 alpha);
             ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,
                               x, 0, x2 - x, frame->height);
             x = x2;
@@ -763,7 +769,7 @@ static void test2_fill_picture(AVFilterContext *ctx, AVFrame *frame)
         g0 = av_rescale_q(s->pts, s->time_base, av_make_q(1, 128));
         for (x = 0; x < s->w; x += dx) {
             g = (av_rescale(x, 6 * 256, s->w) + g0) % (6 * 256);
-            set_color(s, &color, color_gradient(g));
+            set_color(s, &color, color_gradient(g) | alpha);
             y = y0 + av_rescale(x, s->h / 2, s->w);
             y %= 2 * (s->h - 16);
             if (y > s->h - 16)
@@ -785,7 +791,7 @@ static void test2_fill_picture(AVFilterContext *ctx, AVFrame *frame)
         int c, i;
 
         for (c = 0; c < 3; c++) {
-            set_color(s, &color, 0xBBBBBB ^ (0xFF << (c << 3)));
+            set_color(s, &color, (0xBBBBBB ^ (0xFF << (c << 3))) | alpha);
             pos = av_rescale_q(s->pts, s->time_base, av_make_q(64 >> (c << 1), cycle)) % cycle;
             xh = pos < 1 * l ? pos :
                  pos < 2 * l ? l :
@@ -1309,8 +1315,8 @@ static void draw_bar(TestSourceContext *test, const uint8_t color[4],
 
     x = FFMIN(x, test->w - 1);
     y = FFMIN(y, test->h - 1);
-    w = FFMIN(w, test->w - x);
-    h = FFMIN(h, test->h - y);
+    w = FFMAX(FFMIN(w, test->w - x), 0);
+    h = FFMAX(FFMIN(h, test->h - y), 0);
 
     av_assert0(x + w <= test->w);
     av_assert0(y + h <= test->h);
@@ -1376,7 +1382,7 @@ static void smptebars_fill_picture(AVFilterContext *ctx, AVFrame *picref)
     int r_w, r_h, w_h, p_w, p_h, i, tmp, x = 0;
     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);
 
-    av_frame_set_colorspace(picref, AVCOL_SPC_BT470BG);
+    picref->colorspace = AVCOL_SPC_BT470BG;
 
     r_w = FFALIGN((test->w + 6) / 7, 1 << pixdesc->log2_chroma_w);
     r_h = FFALIGN(test->h * 2 / 3, 1 << pixdesc->log2_chroma_h);
@@ -1443,7 +1449,7 @@ static void smptehdbars_fill_picture(AVFilterContext *ctx, AVFrame *picref)
     int d_w, r_w, r_h, l_w, i, tmp, x = 0, y = 0;
     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);
 
-    av_frame_set_colorspace(picref, AVCOL_SPC_BT709);
+    picref->colorspace = AVCOL_SPC_BT709;
 
     d_w = FFALIGN(test->w / 8, 1 << pixdesc->log2_chroma_w);
     r_h = FFALIGN(test->h * 7 / 12, 1 << pixdesc->log2_chroma_h);
diff --git a/mythtv/external/FFmpeg/libavfilter/w3fdif.h b/mythtv/external/FFmpeg/libavfilter/w3fdif.h
index 67bb87461f7..9c0b723a021 100644
--- a/mythtv/external/FFmpeg/libavfilter/w3fdif.h
+++ b/mythtv/external/FFmpeg/libavfilter/w3fdif.h
@@ -39,9 +39,10 @@ typedef struct W3FDIFDSPContext {
                                 uint8_t *in_lines_cur[5],
                                 uint8_t *in_lines_adj[5],
                                 const int16_t *coef, int linesize);
-    void (*filter_scale)(uint8_t *out_pixel, const int32_t *work_pixel, int linesize);
+    void (*filter_scale)(uint8_t *out_pixel, const int32_t *work_pixel,
+                         int linesize, int max);
 } W3FDIFDSPContext;
 
-void ff_w3fdif_init_x86(W3FDIFDSPContext *dsp);
+void ff_w3fdif_init_x86(W3FDIFDSPContext *dsp, int depth);
 
 #endif /* AVFILTER_W3FDIF_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/window_func.c b/mythtv/external/FFmpeg/libavfilter/window_func.c
deleted file mode 100644
index acf1b20847c..00000000000
--- a/mythtv/external/FFmpeg/libavfilter/window_func.c
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * Copyright (c) 2015 Paul B Mahol
- *
- * 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 <math.h>
-
-#include "libavutil/avassert.h"
-#include "window_func.h"
-
-void ff_generate_window_func(float *lut, int N, int win_func, float *overlap)
-{
-    int n;
-
-    switch (win_func) {
-    case WFUNC_RECT:
-        for (n = 0; n < N; n++)
-            lut[n] = 1.;
-        *overlap = 0.;
-        break;
-    case WFUNC_BARTLETT:
-        for (n = 0; n < N; n++)
-            lut[n] = 1.-fabs((n-(N-1)/2.)/((N-1)/2.));
-        *overlap = 0.5;
-        break;
-    case WFUNC_HANNING:
-        for (n = 0; n < N; n++)
-            lut[n] = .5*(1-cos(2*M_PI*n/(N-1)));
-        *overlap = 0.5;
-        break;
-    case WFUNC_HAMMING:
-        for (n = 0; n < N; n++)
-            lut[n] = .54-.46*cos(2*M_PI*n/(N-1));
-        *overlap = 0.5;
-        break;
-    case WFUNC_BLACKMAN:
-        for (n = 0; n < N; n++)
-            lut[n] = .42659-.49656*cos(2*M_PI*n/(N-1))+.076849*cos(4*M_PI*n/(N-1));
-        *overlap = 0.661;
-        break;
-    case WFUNC_WELCH:
-        for (n = 0; n < N; n++)
-            lut[n] = 1.-(n-(N-1)/2.)/((N-1)/2.)*(n-(N-1)/2.)/((N-1)/2.);
-        *overlap = 0.293;
-        break;
-    case WFUNC_FLATTOP:
-        for (n = 0; n < N; n++)
-            lut[n] = 1.-1.985844164102*cos( 2*M_PI*n/(N-1))+1.791176438506*cos( 4*M_PI*n/(N-1))-
-                        1.282075284005*cos( 6*M_PI*n/(N-1))+0.667777530266*cos( 8*M_PI*n/(N-1))-
-                        0.240160796576*cos(10*M_PI*n/(N-1))+0.056656381764*cos(12*M_PI*n/(N-1))-
-                        0.008134974479*cos(14*M_PI*n/(N-1))+0.000624544650*cos(16*M_PI*n/(N-1))-
-                        0.000019808998*cos(18*M_PI*n/(N-1))+0.000000132974*cos(20*M_PI*n/(N-1));
-        *overlap = 0.841;
-        break;
-    case WFUNC_BHARRIS:
-        for (n = 0; n < N; n++)
-            lut[n] = 0.35875-0.48829*cos(2*M_PI*n/(N-1))+0.14128*cos(4*M_PI*n/(N-1))-0.01168*cos(6*M_PI*n/(N-1));
-        *overlap = 0.661;
-        break;
-    case WFUNC_BNUTTALL:
-        for (n = 0; n < N; n++)
-            lut[n] = 0.3635819-0.4891775*cos(2*M_PI*n/(N-1))+0.1365995*cos(4*M_PI*n/(N-1))-0.0106411*cos(6*M_PI*n/(N-1));
-        *overlap = 0.661;
-        break;
-    case WFUNC_BHANN:
-        for (n = 0; n < N; n++)
-            lut[n] = 0.62-0.48*fabs(n/(double)(N-1)-.5)-0.38*cos(2*M_PI*n/(N-1));
-        *overlap = 0.5;
-        break;
-    case WFUNC_SINE:
-        for (n = 0; n < N; n++)
-            lut[n] = sin(M_PI*n/(N-1));
-        *overlap = 0.75;
-        break;
-    case WFUNC_NUTTALL:
-        for (n = 0; n < N; n++)
-            lut[n] = 0.355768-0.487396*cos(2*M_PI*n/(N-1))+0.144232*cos(4*M_PI*n/(N-1))-0.012604*cos(6*M_PI*n/(N-1));
-        *overlap = 0.663;
-        break;
-    case WFUNC_LANCZOS:
-#define SINC(x) (!(x)) ? 1 : sin(M_PI * (x))/(M_PI * (x));
-        for (n = 0; n < N; n++)
-            lut[n] = SINC((2.*n)/(N-1)-1);
-        *overlap = 0.75;
-        break;
-    case WFUNC_GAUSS:
-#define SQR(x) ((x)*(x))
-        for (n = 0; n < N; n++)
-            lut[n] = exp(-0.5 * SQR((n-(N-1)/2)/(0.4*(N-1)/2.f)));
-        *overlap = 0.75;
-        break;
-    case WFUNC_TUKEY:
-        for (n = 0; n < N; n++) {
-            float M = (N-1)/2.;
-
-            if (FFABS(n - M) >= 0.3 * M) {
-                lut[n] = 0.5 * (1 + cos((M_PI*(FFABS(n - M) - 0.3 * M))/((1 - 0.3) * M)));
-            } else {
-                lut[n] = 1;
-            }
-        }
-        *overlap = 0.33;
-        break;
-    case WFUNC_DOLPH: {
-        double b = cosh(7.6009022095419887 / (N-1)), sum, t, c, norm = 0;
-        int j;
-        for (c = 1 - 1 / (b*b), n = (N-1) / 2; n >= 0; --n) {
-            for (sum = !n, b = t = j = 1; j <= n && sum != t; b *= (n-j) * (1./j), ++j)
-                t = sum, sum += (b *= c * (N - n - j) * (1./j));
-            sum /= (N - 1 - n), sum /= (norm = norm ? norm : sum);
-            lut[n] = sum;
-            lut[N - 1 - n] = sum;
-        }
-        *overlap = 0.5;}
-        break;
-    case WFUNC_CAUCHY:
-        for (n = 0; n < N; n++) {
-            double x = 2 * ((n / (double)(N - 1)) - .5);
-
-            if (x <= -.5 || x >= .5) {
-                lut[n] = 0;
-            } else {
-                lut[n] = FFMIN(1, fabs(1/(1+4*16*x*x)));
-            }
-        }
-        *overlap = 0.75;
-        break;
-    case WFUNC_PARZEN:
-        for (n = 0; n < N; n++) {
-            double x = 2 * ((n / (double)(N - 1)) - .5);
-
-            if (x > 0.25 && x <= 0.5) {
-                lut[n] = -2 * powf(-1 + 2 * x, 3);
-            } else if (x >= -.5 && x < -.25) {
-                lut[n] = 2 * powf(1 + 2 * x, 3);
-            } else if (x >= -.25 && x < 0) {
-                lut[n] = 1 - 24 * x * x - 48 * x * x * x;
-            } else if (x >= 0 && x <= .25) {
-                lut[n] = 1 - 24 * x * x + 48 * x * x * x;
-            } else {
-                lut[n] = 0;
-            }
-        }
-        *overlap = 0.75;
-        break;
-    case WFUNC_POISSON:
-        for (n = 0; n < N; n++) {
-            double x = 2 * ((n / (double)(N - 1)) - .5);
-
-            if (x >= 0 && x <= .5) {
-                lut[n] = exp(-6*x);
-            } else if (x < 0 && x >= -.5) {
-                lut[n] = exp(6*x);
-            } else {
-                lut[n] = 0;
-            }
-        }
-        *overlap = 0.75;
-        break;
-    default:
-        av_assert0(0);
-    }
-}
diff --git a/mythtv/external/FFmpeg/libavfilter/window_func.h b/mythtv/external/FFmpeg/libavfilter/window_func.h
index 4611498d47b..a94482c9379 100644
--- a/mythtv/external/FFmpeg/libavfilter/window_func.h
+++ b/mythtv/external/FFmpeg/libavfilter/window_func.h
@@ -22,6 +22,9 @@
 #ifndef AVFILTER_WINDOW_FUNC_H
 #define AVFILTER_WINDOW_FUNC_H
 
+#include <math.h>
+#include "libavutil/avassert.h"
+
 enum WindowFunc     { WFUNC_RECT, WFUNC_HANNING, WFUNC_HAMMING, WFUNC_BLACKMAN,
                       WFUNC_BARTLETT, WFUNC_WELCH, WFUNC_FLATTOP,
                       WFUNC_BHARRIS, WFUNC_BNUTTALL, WFUNC_SINE, WFUNC_NUTTALL,
@@ -29,6 +32,159 @@ enum WindowFunc     { WFUNC_RECT, WFUNC_HANNING, WFUNC_HAMMING, WFUNC_BLACKMAN,
                       WFUNC_DOLPH, WFUNC_CAUCHY, WFUNC_PARZEN, WFUNC_POISSON,
                       NB_WFUNC };
 
-void ff_generate_window_func(float *lut, int N, int win_func, float *overlap);
+static inline void generate_window_func(float *lut, int N, int win_func,
+                                        float *overlap)
+{
+    int n;
+
+    switch (win_func) {
+    case WFUNC_RECT:
+        for (n = 0; n < N; n++)
+            lut[n] = 1.;
+        *overlap = 0.;
+        break;
+    case WFUNC_BARTLETT:
+        for (n = 0; n < N; n++)
+            lut[n] = 1.-fabs((n-(N-1)/2.)/((N-1)/2.));
+        *overlap = 0.5;
+        break;
+    case WFUNC_HANNING:
+        for (n = 0; n < N; n++)
+            lut[n] = .5*(1-cos(2*M_PI*n/(N-1)));
+        *overlap = 0.5;
+        break;
+    case WFUNC_HAMMING:
+        for (n = 0; n < N; n++)
+            lut[n] = .54-.46*cos(2*M_PI*n/(N-1));
+        *overlap = 0.5;
+        break;
+    case WFUNC_BLACKMAN:
+        for (n = 0; n < N; n++)
+            lut[n] = .42659-.49656*cos(2*M_PI*n/(N-1))+.076849*cos(4*M_PI*n/(N-1));
+        *overlap = 0.661;
+        break;
+    case WFUNC_WELCH:
+        for (n = 0; n < N; n++)
+            lut[n] = 1.-(n-(N-1)/2.)/((N-1)/2.)*(n-(N-1)/2.)/((N-1)/2.);
+        *overlap = 0.293;
+        break;
+    case WFUNC_FLATTOP:
+        for (n = 0; n < N; n++)
+            lut[n] = 1.-1.985844164102*cos( 2*M_PI*n/(N-1))+1.791176438506*cos( 4*M_PI*n/(N-1))-
+            1.282075284005*cos( 6*M_PI*n/(N-1))+0.667777530266*cos( 8*M_PI*n/(N-1))-
+            0.240160796576*cos(10*M_PI*n/(N-1))+0.056656381764*cos(12*M_PI*n/(N-1))-
+            0.008134974479*cos(14*M_PI*n/(N-1))+0.000624544650*cos(16*M_PI*n/(N-1))-
+            0.000019808998*cos(18*M_PI*n/(N-1))+0.000000132974*cos(20*M_PI*n/(N-1));
+        *overlap = 0.841;
+        break;
+    case WFUNC_BHARRIS:
+        for (n = 0; n < N; n++)
+            lut[n] = 0.35875-0.48829*cos(2*M_PI*n/(N-1))+0.14128*cos(4*M_PI*n/(N-1))-0.01168*cos(6*M_PI*n/(N-1));
+        *overlap = 0.661;
+        break;
+    case WFUNC_BNUTTALL:
+        for (n = 0; n < N; n++)
+            lut[n] = 0.3635819-0.4891775*cos(2*M_PI*n/(N-1))+0.1365995*cos(4*M_PI*n/(N-1))-0.0106411*cos(6*M_PI*n/(N-1));
+        *overlap = 0.661;
+        break;
+    case WFUNC_BHANN:
+        for (n = 0; n < N; n++)
+            lut[n] = 0.62-0.48*fabs(n/(double)(N-1)-.5)-0.38*cos(2*M_PI*n/(N-1));
+        *overlap = 0.5;
+        break;
+    case WFUNC_SINE:
+        for (n = 0; n < N; n++)
+            lut[n] = sin(M_PI*n/(N-1));
+        *overlap = 0.75;
+        break;
+    case WFUNC_NUTTALL:
+        for (n = 0; n < N; n++)
+            lut[n] = 0.355768-0.487396*cos(2*M_PI*n/(N-1))+0.144232*cos(4*M_PI*n/(N-1))-0.012604*cos(6*M_PI*n/(N-1));
+        *overlap = 0.663;
+        break;
+    case WFUNC_LANCZOS:
+        #define SINC(x) (!(x)) ? 1 : sin(M_PI * (x))/(M_PI * (x));
+        for (n = 0; n < N; n++)
+            lut[n] = SINC((2.*n)/(N-1)-1);
+        *overlap = 0.75;
+        break;
+    case WFUNC_GAUSS:
+        #define SQR(x) ((x)*(x))
+        for (n = 0; n < N; n++)
+            lut[n] = exp(-0.5 * SQR((n-(N-1)/2)/(0.4*(N-1)/2.f)));
+        *overlap = 0.75;
+        break;
+    case WFUNC_TUKEY:
+        for (n = 0; n < N; n++) {
+            float M = (N-1)/2.;
+
+            if (FFABS(n - M) >= 0.3 * M) {
+                lut[n] = 0.5 * (1 + cos((M_PI*(FFABS(n - M) - 0.3 * M))/((1 - 0.3) * M)));
+            } else {
+                lut[n] = 1;
+            }
+        }
+        *overlap = 0.33;
+        break;
+    case WFUNC_DOLPH: {
+        double b = cosh(7.6009022095419887 / (N-1)), sum, t, c, norm = 0;
+        int j;
+        for (c = 1 - 1 / (b*b), n = (N-1) / 2; n >= 0; --n) {
+            for (sum = !n, b = t = j = 1; j <= n && sum != t; b *= (n-j) * (1./j), ++j)
+                t = sum, sum += (b *= c * (N - n - j) * (1./j));
+            sum /= (N - 1 - n), sum /= (norm = norm ? norm : sum);
+            lut[n] = sum;
+            lut[N - 1 - n] = sum;
+        }
+        *overlap = 0.5;}
+        break;
+    case WFUNC_CAUCHY:
+        for (n = 0; n < N; n++) {
+            double x = 2 * ((n / (double)(N - 1)) - .5);
+
+            if (x <= -.5 || x >= .5) {
+                lut[n] = 0;
+            } else {
+                lut[n] = FFMIN(1, fabs(1/(1+4*16*x*x)));
+            }
+        }
+        *overlap = 0.75;
+        break;
+    case WFUNC_PARZEN:
+        for (n = 0; n < N; n++) {
+            double x = 2 * ((n / (double)(N - 1)) - .5);
+
+            if (x > 0.25 && x <= 0.5) {
+                lut[n] = -2 * powf(-1 + 2 * x, 3);
+            } else if (x >= -.5 && x < -.25) {
+                lut[n] = 2 * powf(1 + 2 * x, 3);
+            } else if (x >= -.25 && x < 0) {
+                lut[n] = 1 - 24 * x * x - 48 * x * x * x;
+            } else if (x >= 0 && x <= .25) {
+                lut[n] = 1 - 24 * x * x + 48 * x * x * x;
+            } else {
+                lut[n] = 0;
+            }
+        }
+        *overlap = 0.75;
+        break;
+    case WFUNC_POISSON:
+        for (n = 0; n < N; n++) {
+            double x = 2 * ((n / (double)(N - 1)) - .5);
+
+            if (x >= 0 && x <= .5) {
+                lut[n] = exp(-6*x);
+            } else if (x < 0 && x >= -.5) {
+                lut[n] = exp(6*x);
+            } else {
+                lut[n] = 0;
+            }
+        }
+        *overlap = 0.75;
+        break;
+    default:
+        av_assert0(0);
+    }
+}
 
 #endif /* AVFILTER_WINDOW_FUNC_H */
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/Makefile b/mythtv/external/FFmpeg/libavfilter/x86/Makefile
index b6195f84c45..34316258839 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/Makefile
+++ b/mythtv/external/FFmpeg/libavfilter/x86/Makefile
@@ -1,3 +1,4 @@
+OBJS-$(CONFIG_AFIR_FILTER)                   += x86/af_afir_init.o
 OBJS-$(CONFIG_BLEND_FILTER)                  += x86/vf_blend_init.o
 OBJS-$(CONFIG_BWDIF_FILTER)                  += x86/vf_bwdif_init.o
 OBJS-$(CONFIG_COLORSPACE_FILTER)             += x86/colorspacedsp_init.o
@@ -7,6 +8,7 @@ OBJS-$(CONFIG_GRADFUN_FILTER)                += x86/vf_gradfun_init.o
 OBJS-$(CONFIG_HQDN3D_FILTER)                 += x86/vf_hqdn3d_init.o
 OBJS-$(CONFIG_IDET_FILTER)                   += x86/vf_idet_init.o
 OBJS-$(CONFIG_INTERLACE_FILTER)              += x86/vf_interlace_init.o
+OBJS-$(CONFIG_LIMITER_FILTER)                += x86/vf_limiter_init.o
 OBJS-$(CONFIG_MASKEDMERGE_FILTER)            += x86/vf_maskedmerge_init.o
 OBJS-$(CONFIG_NOISE_FILTER)                  += x86/vf_noise.o
 OBJS-$(CONFIG_PP7_FILTER)                    += x86/vf_pp7_init.o
@@ -23,26 +25,28 @@ OBJS-$(CONFIG_VOLUME_FILTER)                 += x86/af_volume_init.o
 OBJS-$(CONFIG_W3FDIF_FILTER)                 += x86/vf_w3fdif_init.o
 OBJS-$(CONFIG_YADIF_FILTER)                  += x86/vf_yadif_init.o
 
-YASM-OBJS-$(CONFIG_BLEND_FILTER)             += x86/vf_blend.o
-YASM-OBJS-$(CONFIG_BWDIF_FILTER)             += x86/vf_bwdif.o
-YASM-OBJS-$(CONFIG_COLORSPACE_FILTER)        += x86/colorspacedsp.o
-YASM-OBJS-$(CONFIG_FSPP_FILTER)              += x86/vf_fspp.o
-YASM-OBJS-$(CONFIG_GRADFUN_FILTER)           += x86/vf_gradfun.o
-YASM-OBJS-$(CONFIG_HQDN3D_FILTER)            += x86/vf_hqdn3d.o
-YASM-OBJS-$(CONFIG_IDET_FILTER)              += x86/vf_idet.o
-YASM-OBJS-$(CONFIG_INTERLACE_FILTER)         += x86/vf_interlace.o
-YASM-OBJS-$(CONFIG_MASKEDMERGE_FILTER)       += x86/vf_maskedmerge.o
-YASM-OBJS-$(CONFIG_PP7_FILTER)               += x86/vf_pp7.o
-YASM-OBJS-$(CONFIG_PSNR_FILTER)              += x86/vf_psnr.o
-YASM-OBJS-$(CONFIG_PULLUP_FILTER)            += x86/vf_pullup.o
+X86ASM-OBJS-$(CONFIG_AFIR_FILTER)            += x86/af_afir.o
+X86ASM-OBJS-$(CONFIG_BLEND_FILTER)           += x86/vf_blend.o
+X86ASM-OBJS-$(CONFIG_BWDIF_FILTER)           += x86/vf_bwdif.o
+X86ASM-OBJS-$(CONFIG_COLORSPACE_FILTER)      += x86/colorspacedsp.o
+X86ASM-OBJS-$(CONFIG_FSPP_FILTER)            += x86/vf_fspp.o
+X86ASM-OBJS-$(CONFIG_GRADFUN_FILTER)         += x86/vf_gradfun.o
+X86ASM-OBJS-$(CONFIG_HQDN3D_FILTER)          += x86/vf_hqdn3d.o
+X86ASM-OBJS-$(CONFIG_IDET_FILTER)            += x86/vf_idet.o
+X86ASM-OBJS-$(CONFIG_INTERLACE_FILTER)       += x86/vf_interlace.o
+X86ASM-OBJS-$(CONFIG_LIMITER_FILTER)         += x86/vf_limiter.o
+X86ASM-OBJS-$(CONFIG_MASKEDMERGE_FILTER)     += x86/vf_maskedmerge.o
+X86ASM-OBJS-$(CONFIG_PP7_FILTER)             += x86/vf_pp7.o
+X86ASM-OBJS-$(CONFIG_PSNR_FILTER)            += x86/vf_psnr.o
+X86ASM-OBJS-$(CONFIG_PULLUP_FILTER)          += x86/vf_pullup.o
 ifdef CONFIG_GPL
-YASM-OBJS-$(CONFIG_REMOVEGRAIN_FILTER)       += x86/vf_removegrain.o
+X86ASM-OBJS-$(CONFIG_REMOVEGRAIN_FILTER)     += x86/vf_removegrain.o
 endif
-YASM-OBJS-$(CONFIG_SHOWCQT_FILTER)           += x86/avf_showcqt.o
-YASM-OBJS-$(CONFIG_SSIM_FILTER)              += x86/vf_ssim.o
-YASM-OBJS-$(CONFIG_STEREO3D_FILTER)          += x86/vf_stereo3d.o
-YASM-OBJS-$(CONFIG_TBLEND_FILTER)            += x86/vf_blend.o
-YASM-OBJS-$(CONFIG_TINTERLACE_FILTER)        += x86/vf_interlace.o
-YASM-OBJS-$(CONFIG_VOLUME_FILTER)            += x86/af_volume.o
-YASM-OBJS-$(CONFIG_W3FDIF_FILTER)            += x86/vf_w3fdif.o
-YASM-OBJS-$(CONFIG_YADIF_FILTER)             += x86/vf_yadif.o x86/yadif-16.o x86/yadif-10.o
+X86ASM-OBJS-$(CONFIG_SHOWCQT_FILTER)         += x86/avf_showcqt.o
+X86ASM-OBJS-$(CONFIG_SSIM_FILTER)            += x86/vf_ssim.o
+X86ASM-OBJS-$(CONFIG_STEREO3D_FILTER)        += x86/vf_stereo3d.o
+X86ASM-OBJS-$(CONFIG_TBLEND_FILTER)          += x86/vf_blend.o
+X86ASM-OBJS-$(CONFIG_TINTERLACE_FILTER)      += x86/vf_interlace.o
+X86ASM-OBJS-$(CONFIG_VOLUME_FILTER)          += x86/af_volume.o
+X86ASM-OBJS-$(CONFIG_W3FDIF_FILTER)          += x86/vf_w3fdif.o
+X86ASM-OBJS-$(CONFIG_YADIF_FILTER)           += x86/vf_yadif.o x86/yadif-16.o x86/yadif-10.o
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/af_afir.asm b/mythtv/external/FFmpeg/libavfilter/x86/af_afir.asm
new file mode 100644
index 00000000000..849d85e70fb
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/x86/af_afir.asm
@@ -0,0 +1,60 @@
+;*****************************************************************************
+;* x86-optimized functions for afir filter
+;* Copyright (c) 2017 Paul B Mahol
+;*
+;* 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/x86/x86util.asm"
+
+SECTION .text
+
+;------------------------------------------------------------------------------
+; void ff_fcmul_add(float *sum, const float *t, const float *c, int len)
+;------------------------------------------------------------------------------
+
+INIT_XMM sse3
+cglobal fcmul_add, 4,4,6, sum, t, c, len
+    shl       lend, 3
+    add       lend, mmsize*2
+    add         tq, lenq
+    add         cq, lenq
+    add       sumq, lenq
+    neg       lenq
+ALIGN 16
+.loop:
+    movsldup  m0, [tq + lenq]
+    movsldup  m3, [tq + lenq+mmsize]
+    movaps    m1, [cq + lenq]
+    movaps    m4, [cq + lenq+mmsize]
+    mulps     m0, m1
+    mulps     m3, m4
+    shufps    m1, m1, 0xb1
+    shufps    m4, m4, 0xb1
+    movshdup  m2, [tq + lenq]
+    movshdup  m5, [tq + lenq+mmsize]
+    mulps     m2, m1
+    mulps     m5, m4
+    addsubps  m0, m2
+    addsubps  m3, m5
+    addps     m0, [sumq + lenq]
+    addps     m3, [sumq + lenq+mmsize]
+    movaps    [sumq + lenq], m0
+    movaps    [sumq + lenq+mmsize], m3
+    add       lenq, mmsize*2
+    jl .loop
+    REP_RET
diff --git a/mythtv/external/FFmpeg/libavcodec/aarch64/imdct15_init.c b/mythtv/external/FFmpeg/libavfilter/x86/af_afir_init.c
similarity index 51%
rename from mythtv/external/FFmpeg/libavcodec/aarch64/imdct15_init.c
rename to mythtv/external/FFmpeg/libavfilter/x86/af_afir_init.c
index 58af9f00c0c..6a652b9b835 100644
--- a/mythtv/external/FFmpeg/libavcodec/aarch64/imdct15_init.c
+++ b/mythtv/external/FFmpeg/libavfilter/x86/af_afir_init.c
@@ -16,31 +16,20 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include <stddef.h>
-
+#include "config.h"
+#include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
-#include "libavutil/aarch64/cpu.h"
-#include "libavutil/internal.h"
-
-#include "libavcodec/imdct15.h"
-
-#include "asm-offsets.h"
-
-AV_CHECK_OFFSET(IMDCT15Context, exptab,         CELT_EXPTAB);
-AV_CHECK_OFFSET(IMDCT15Context, fft_n,          CELT_FFT_N);
-AV_CHECK_OFFSET(IMDCT15Context, len2,           CELT_LEN2);
-AV_CHECK_OFFSET(IMDCT15Context, len4,           CELT_LEN4);
-AV_CHECK_OFFSET(IMDCT15Context, tmp,            CELT_TMP);
-AV_CHECK_OFFSET(IMDCT15Context, twiddle_exptab, CELT_TWIDDLE);
+#include "libavutil/x86/cpu.h"
+#include "libavfilter/af_afir.h"
 
-void ff_celt_imdct_half_neon(IMDCT15Context *s, float *dst, const float *src,
-                             ptrdiff_t stride, float scale);
+void ff_fcmul_add_sse3(float *sum, const float *t, const float *c,
+                       ptrdiff_t len);
 
-void ff_imdct15_init_aarch64(IMDCT15Context *s)
+av_cold void ff_afir_init_x86(AudioFIRContext *s)
 {
     int cpu_flags = av_get_cpu_flags();
 
-    if (have_neon(cpu_flags)) {
-        s->imdct_half = ff_celt_imdct_half_neon;
+    if (EXTERNAL_SSE3(cpu_flags)) {
+        s->fcmul_add = ff_fcmul_add_sse3;
     }
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_blend.asm b/mythtv/external/FFmpeg/libavfilter/x86/vf_blend.asm
index 33b1ad14960..4916aaf251e 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/vf_blend.asm
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_blend.asm
@@ -83,7 +83,7 @@ BLEND_SIMPLE subtract, subusb
 BLEND_SIMPLE darken,   minub
 BLEND_SIMPLE lighten,  maxub
 
-BLEND_INIT difference128, 4
+BLEND_INIT grainextract, 4
     pxor       m2, m2
     mova       m3, [pw_128]
 .nextrow:
@@ -181,7 +181,7 @@ BLEND_INIT average, 3
     jl .loop
 BLEND_END
 
-BLEND_INIT addition128, 4
+BLEND_INIT grainmerge, 4
     pxor       m2, m2
     mova       m3, [pw_128]
 .nextrow:
@@ -268,44 +268,74 @@ BLEND_INIT phoenix, 4
 BLEND_END
 
 %macro BLEND_ABS 0
-BLEND_INIT difference, 3
+BLEND_INIT difference, 5
     pxor       m2, m2
 .nextrow:
     mov        xq, widthq
 
     .loop:
-        movh            m0, [topq + xq]
-        movh            m1, [bottomq + xq]
+        movu            m0, [topq + xq]
+        movu            m1, [bottomq + xq]
+        punpckhbw       m3, m0, m2
         punpcklbw       m0, m2
+        punpckhbw       m4, m1, m2
         punpcklbw       m1, m2
         psubw           m0, m1
-        ABS1            m0, m1
-        packuswb        m0, m0
-        movh   [dstq + xq], m0
-        add             xq, mmsize / 2
+        psubw           m3, m4
+        ABS2            m0, m3, m1, m4
+        packuswb        m0, m3
+        mova   [dstq + xq], m0
+        add             xq, mmsize
     jl .loop
 BLEND_END
 
-BLEND_INIT negation, 5
+BLEND_INIT extremity, 8
     pxor       m2, m2
     mova       m4, [pw_255]
 .nextrow:
     mov        xq, widthq
 
     .loop:
-        movh            m0, [topq + xq]
-        movh            m1, [bottomq + xq]
+        movu            m0, [topq + xq]
+        movu            m1, [bottomq + xq]
+        punpckhbw       m5, m0, m2
         punpcklbw       m0, m2
+        punpckhbw       m6, m1, m2
         punpcklbw       m1, m2
-        mova            m3, m4
-        psubw           m3, m0
+        psubw           m3, m4, m0
+        psubw           m7, m4, m5
         psubw           m3, m1
-        ABS1            m3, m1
-        mova            m0, m4
-        psubw           m0, m3
-        packuswb        m0, m0
-        movh   [dstq + xq], m0
-        add             xq, mmsize / 2
+        psubw           m7, m6
+        ABS2            m3, m7, m1, m6
+        packuswb        m3, m7
+        mova   [dstq + xq], m3
+        add             xq, mmsize
+    jl .loop
+BLEND_END
+
+BLEND_INIT negation, 8
+    pxor       m2, m2
+    mova       m4, [pw_255]
+.nextrow:
+    mov        xq, widthq
+
+    .loop:
+        movu            m0, [topq + xq]
+        movu            m1, [bottomq + xq]
+        punpckhbw       m5, m0, m2
+        punpcklbw       m0, m2
+        punpckhbw       m6, m1, m2
+        punpcklbw       m1, m2
+        psubw           m3, m4, m0
+        psubw           m7, m4, m5
+        psubw           m3, m1
+        psubw           m7, m6
+        ABS2            m3, m7, m1, m6
+        psubw           m0, m4, m3
+        psubw           m1, m4, m7
+        packuswb        m0, m1
+        mova   [dstq + xq], m0
+        add             xq, mmsize
     jl .loop
 BLEND_END
 %endmacro
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_blend_init.c b/mythtv/external/FFmpeg/libavfilter/x86/vf_blend_init.c
index 96fe3d8baab..a4fc9af2469 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/vf_blend_init.c
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_blend_init.c
@@ -31,11 +31,11 @@ void ff_blend_##name##_##opt(const uint8_t *top, ptrdiff_t top_linesize,       \
                              struct FilterParams *param, double *values, int starty);
 
 BLEND_FUNC(addition, sse2)
-BLEND_FUNC(addition128, sse2)
+BLEND_FUNC(grainmerge, sse2)
 BLEND_FUNC(average, sse2)
 BLEND_FUNC(and, sse2)
 BLEND_FUNC(darken, sse2)
-BLEND_FUNC(difference128, sse2)
+BLEND_FUNC(grainextract, sse2)
 BLEND_FUNC(multiply, sse2)
 BLEND_FUNC(screen, sse2)
 BLEND_FUNC(hardmix, sse2)
@@ -47,6 +47,8 @@ BLEND_FUNC(subtract, sse2)
 BLEND_FUNC(xor, sse2)
 BLEND_FUNC(difference, sse2)
 BLEND_FUNC(difference, ssse3)
+BLEND_FUNC(extremity, sse2)
+BLEND_FUNC(extremity, ssse3)
 BLEND_FUNC(negation, sse2)
 BLEND_FUNC(negation, ssse3)
 
@@ -57,27 +59,29 @@ av_cold void ff_blend_init_x86(FilterParams *param, int is_16bit)
     if (EXTERNAL_SSE2(cpu_flags) && param->opacity == 1 && !is_16bit) {
         switch (param->mode) {
         case BLEND_ADDITION: param->blend = ff_blend_addition_sse2; break;
-        case BLEND_ADDITION128: param->blend = ff_blend_addition128_sse2; break;
+        case BLEND_GRAINMERGE: param->blend = ff_blend_grainmerge_sse2; break;
         case BLEND_AND:      param->blend = ff_blend_and_sse2;      break;
         case BLEND_AVERAGE:  param->blend = ff_blend_average_sse2;  break;
         case BLEND_DARKEN:   param->blend = ff_blend_darken_sse2;   break;
-        case BLEND_DIFFERENCE128: param->blend = ff_blend_difference128_sse2; break;
+        case BLEND_GRAINEXTRACT: param->blend = ff_blend_grainextract_sse2; break;
         case BLEND_DIVIDE:   param->blend = ff_blend_divide_sse2;   break;
         case BLEND_HARDMIX:  param->blend = ff_blend_hardmix_sse2;  break;
         case BLEND_LIGHTEN:  param->blend = ff_blend_lighten_sse2;  break;
         case BLEND_MULTIPLY: param->blend = ff_blend_multiply_sse2; break;
         case BLEND_OR:       param->blend = ff_blend_or_sse2;       break;
         case BLEND_PHOENIX:  param->blend = ff_blend_phoenix_sse2;  break;
-        case BLEND_SCREEN:   param->blend = ff_blend_screen_sse2; break;
+        case BLEND_SCREEN:   param->blend = ff_blend_screen_sse2;   break;
         case BLEND_SUBTRACT: param->blend = ff_blend_subtract_sse2; break;
         case BLEND_XOR:      param->blend = ff_blend_xor_sse2;      break;
         case BLEND_DIFFERENCE: param->blend = ff_blend_difference_sse2; break;
+        case BLEND_EXTREMITY:  param->blend = ff_blend_extremity_sse2;  break;
         case BLEND_NEGATION:   param->blend = ff_blend_negation_sse2;   break;
         }
     }
     if (EXTERNAL_SSSE3(cpu_flags) && param->opacity == 1 && !is_16bit) {
         switch (param->mode) {
         case BLEND_DIFFERENCE: param->blend = ff_blend_difference_ssse3; break;
+        case BLEND_EXTREMITY:  param->blend = ff_blend_extremity_ssse3;  break;
         case BLEND_NEGATION:   param->blend = ff_blend_negation_ssse3;   break;
         }
     }
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_gradfun_init.c b/mythtv/external/FFmpeg/libavfilter/x86/vf_gradfun_init.c
index 3f515622b64..4009711701d 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/vf_gradfun_init.c
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_gradfun_init.c
@@ -39,7 +39,7 @@ void ff_gradfun_blur_line_movdqu_sse2(intptr_t x, uint16_t *buf,
                                       const uint16_t *buf1, uint16_t *dc,
                                       const uint8_t *src1, const uint8_t *src2);
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 static void gradfun_filter_line_mmxext(uint8_t *dst, const uint8_t *src,
                                        const uint16_t *dc,
                                        int width, int thresh,
@@ -87,11 +87,11 @@ static void gradfun_blur_line_sse2(uint16_t *dc, uint16_t *buf, const uint16_t *
                                          dc + width, src + width * 2,
                                          src + width * 2 + src_linesize);
 }
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 
 av_cold void ff_gradfun_init_x86(GradFunContext *gf)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_MMXEXT(cpu_flags))
@@ -101,5 +101,5 @@ av_cold void ff_gradfun_init_x86(GradFunContext *gf)
 
     if (EXTERNAL_SSE2(cpu_flags))
         gf->blur_line = gradfun_blur_line_sse2;
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_hqdn3d_init.c b/mythtv/external/FFmpeg/libavfilter/x86/vf_hqdn3d_init.c
index b63916b6743..43aca908b09 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/vf_hqdn3d_init.c
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_hqdn3d_init.c
@@ -40,10 +40,10 @@ void ff_hqdn3d_row_16_x86(uint8_t *src, uint8_t *dst, uint16_t *line_ant,
 
 av_cold void ff_hqdn3d_init_x86(HQDN3DContext *hqdn3d)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     hqdn3d->denoise_row[8]  = ff_hqdn3d_row_8_x86;
     hqdn3d->denoise_row[9]  = ff_hqdn3d_row_9_x86;
     hqdn3d->denoise_row[10] = ff_hqdn3d_row_10_x86;
     hqdn3d->denoise_row[16] = ff_hqdn3d_row_16_x86;
-#endif /* HAVE_YASM */
+#endif /* HAVE_X86ASM */
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_idet_init.c b/mythtv/external/FFmpeg/libavfilter/x86/vf_idet_init.c
index 1147ca8ba8b..ca175e2d400 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/vf_idet_init.c
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_idet_init.c
@@ -23,7 +23,7 @@
 #include "libavutil/x86/cpu.h"
 #include "libavfilter/vf_idet.h"
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 
 /* declares main callable idet_filter_line_{mmx,mmxext,sse2}() */
 #define FUNC_MAIN_DECL(KIND, SPAN)                                        \
@@ -68,7 +68,7 @@ FUNC_MAIN_DECL_16bit(mmx, 4)
 #endif
 av_cold void ff_idet_init_x86(IDETContext *idet, int for_16b)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     const int cpu_flags = av_get_cpu_flags();
 
 #if ARCH_X86_32
@@ -83,5 +83,5 @@ av_cold void ff_idet_init_x86(IDETContext *idet, int for_16b)
     if (EXTERNAL_SSE2(cpu_flags)) {
         idet->filter_line = for_16b ? (ff_idet_filter_func)idet_filter_line_16bit_sse2 : idet_filter_line_sse2;
     }
-#endif // HAVE_YASM
+#endif // HAVE_X86ASM
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_interlace.asm b/mythtv/external/FFmpeg/libavfilter/x86/vf_interlace.asm
index f70c700965c..7c0065d4d94 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/vf_interlace.asm
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_interlace.asm
@@ -3,6 +3,7 @@
 ;*
 ;* Copyright (C) 2014 Kieran Kunhya <kierank@obe.tv>
 ;* Copyright (c) 2014 Michael Niedermayer <michaelni@gmx.at>
+;* Copyright (c) 2017 Thomas Mundt <tmundt75@gmail.com>
 ;*
 ;* This file is part of FFmpeg.
 ;*
@@ -25,41 +26,177 @@
 
 SECTION_RODATA
 
+pw_4: times 8 dw 4
+
 SECTION .text
 
-%macro LOWPASS_LINE 0
-cglobal lowpass_line, 5, 5, 7
-    add r0, r1
-    add r2, r1
-    add r3, r1
-    add r4, r1
-    neg r1
+%macro LOWPASS 1
+    add dstq, hq
+    add srcq, hq
+    add mrefq, srcq
+    add prefq, srcq
+    neg hq
 
-    pcmpeqb m6, m6
+    pcmpeq%1 m6, m6
 
 .loop:
-    mova m0, [r3+r1]
-    mova m1, [r3+r1+mmsize]
-    pavgb m0, [r4+r1]
-    pavgb m1, [r4+r1+mmsize]
+    mova m0, [mrefq+hq]
+    mova m1, [mrefq+hq+mmsize]
+    pavg%1 m0, [prefq+hq]
+    pavg%1 m1, [prefq+hq+mmsize]
     pxor m0, m6
     pxor m1, m6
-    pxor m2, m6, [r2+r1]
-    pxor m3, m6, [r2+r1+mmsize]
-    pavgb m0, m2
-    pavgb m1, m3
+    pxor m2, m6, [srcq+hq]
+    pxor m3, m6, [srcq+hq+mmsize]
+    pavg%1 m0, m2
+    pavg%1 m1, m3
     pxor m0, m6
     pxor m1, m6
-    mova [r0+r1], m0
-    mova [r0+r1+mmsize], m1
+    mova [dstq+hq], m0
+    mova [dstq+hq+mmsize], m1
 
-    add r1, 2*mmsize
+    add hq, 2*mmsize
     jl .loop
 REP_RET
 %endmacro
 
+%macro LOWPASS_LINE 0
+cglobal lowpass_line, 5, 5, 7, dst, h, src, mref, pref
+    LOWPASS b
+
+cglobal lowpass_line_16, 5, 5, 7, dst, h, src, mref, pref
+    shl hq, 1
+    LOWPASS w
+%endmacro
+
+%macro LOWPASS_LINE_COMPLEX 0
+cglobal lowpass_line_complex, 5, 5, 8, dst, h, src, mref, pref
+    pxor m7, m7
+.loop:
+    mova m0, [srcq+mrefq]
+    mova m2, [srcq+prefq]
+    mova m1, m0
+    mova m3, m2
+    punpcklbw m0, m7
+    punpcklbw m2, m7
+    punpckhbw m1, m7
+    punpckhbw m3, m7
+    paddw m0, m2
+    paddw m1, m3
+    mova m6, m0
+    mova m5, m1
+    mova m2, [srcq]
+    mova m3, m2
+    punpcklbw m2, m7
+    punpckhbw m3, m7
+    paddw m0, m2
+    paddw m1, m3
+    psllw m2, 1
+    psllw m3, 1
+    paddw m0, m2
+    paddw m1, m3
+    psllw m0, 1
+    psllw m1, 1
+    pcmpgtw m6, m2
+    pcmpgtw m5, m3
+    packsswb m6, m5
+    mova m2, [srcq+mrefq*2]
+    mova m4, [srcq+prefq*2]
+    mova m3, m2
+    mova m5, m4
+    punpcklbw m2, m7
+    punpcklbw m4, m7
+    punpckhbw m3, m7
+    punpckhbw m5, m7
+    paddw m2, m4
+    paddw m3, m5
+    paddw m0, [pw_4]
+    paddw m1, [pw_4]
+    psubusw m0, m2
+    psubusw m1, m3
+    psrlw m0, 3
+    psrlw m1, 3
+    packuswb m0, m1
+    mova m1, m0
+    pmaxub m0, [srcq]
+    pminub m1, [srcq]
+    pand m0, m6
+    pandn m6, m1
+    por m0, m6
+    mova [dstq], m0
+
+    add dstq, mmsize
+    add srcq, mmsize
+    sub hd, mmsize
+    jg .loop
+REP_RET
+
+cglobal lowpass_line_complex_12, 5, 5, 8, 16, dst, h, src, mref, pref, clip_max
+    movd m7, DWORD clip_maxm
+    SPLATW m7, m7, 0
+    mova [rsp], m7
+.loop:
+    mova m0, [srcq+mrefq]
+    mova m1, [srcq+mrefq+mmsize]
+    mova m2, [srcq+prefq]
+    mova m3, [srcq+prefq+mmsize]
+    paddw m0, m2
+    paddw m1, m3
+    mova m6, m0
+    mova m7, m1
+    mova m2, [srcq]
+    mova m3, [srcq+mmsize]
+    paddw m0, m2
+    paddw m1, m3
+    psllw m2, 1
+    psllw m3, 1
+    paddw m0, m2
+    paddw m1, m3
+    psllw m0, 1
+    psllw m1, 1
+    pcmpgtw m6, m2
+    pcmpgtw m7, m3
+    mova m2, [srcq+2*mrefq]
+    mova m3, [srcq+2*mrefq+mmsize]
+    mova m4, [srcq+2*prefq]
+    mova m5, [srcq+2*prefq+mmsize]
+    paddw m2, m4
+    paddw m3, m5
+    paddw m0, [pw_4]
+    paddw m1, [pw_4]
+    psubusw m0, m2
+    psubusw m1, m3
+    psrlw m0, 3
+    psrlw m1, 3
+    pminsw m0, [rsp]
+    pminsw m1, [rsp]
+    mova m2, m0
+    mova m3, m1
+    pmaxsw m0, [srcq]
+    pmaxsw m1, [srcq+mmsize]
+    pminsw m2, [srcq]
+    pminsw m3, [srcq+mmsize]
+    pand m0, m6
+    pand m1, m7
+    pandn m6, m2
+    pandn m7, m3
+    por m0, m6
+    por m1, m7
+    mova [dstq], m0
+    mova [dstq+mmsize], m1
+
+    add dstq, 2*mmsize
+    add srcq, 2*mmsize
+    sub hd, mmsize
+    jg .loop
+REP_RET
+%endmacro
+
 INIT_XMM sse2
 LOWPASS_LINE
 
 INIT_XMM avx
 LOWPASS_LINE
+
+INIT_XMM sse2
+LOWPASS_LINE_COMPLEX
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_interlace_init.c b/mythtv/external/FFmpeg/libavfilter/x86/vf_interlace_init.c
index 52a22f80c72..70fe86ccff0 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/vf_interlace_init.c
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_interlace_init.c
@@ -27,20 +27,50 @@
 #include "libavfilter/interlace.h"
 
 void ff_lowpass_line_sse2(uint8_t *dstp, ptrdiff_t linesize,
-                          const uint8_t *srcp,
-                          const uint8_t *srcp_above,
-                          const uint8_t *srcp_below);
+                          const uint8_t *srcp, ptrdiff_t mref,
+                          ptrdiff_t pref, int clip_max);
 void ff_lowpass_line_avx (uint8_t *dstp, ptrdiff_t linesize,
-                          const uint8_t *srcp,
-                          const uint8_t *srcp_above,
-                          const uint8_t *srcp_below);
+                          const uint8_t *srcp, ptrdiff_t mref,
+                          ptrdiff_t pref, int clip_max);
+
+void ff_lowpass_line_16_sse2(uint8_t *dstp, ptrdiff_t linesize,
+                             const uint8_t *srcp, ptrdiff_t mref,
+                             ptrdiff_t pref, int clip_max);
+void ff_lowpass_line_16_avx (uint8_t *dstp, ptrdiff_t linesize,
+                             const uint8_t *srcp, ptrdiff_t mref,
+                             ptrdiff_t pref, int clip_max);
+
+void ff_lowpass_line_complex_sse2(uint8_t *dstp, ptrdiff_t linesize,
+                                  const uint8_t *srcp, ptrdiff_t mref,
+                                  ptrdiff_t pref, int clip_max);
+
+void ff_lowpass_line_complex_12_sse2(uint8_t *dstp, ptrdiff_t linesize,
+                                     const uint8_t *srcp, ptrdiff_t mref,
+                                     ptrdiff_t pref, int clip_max);
 
 av_cold void ff_interlace_init_x86(InterlaceContext *s)
 {
     int cpu_flags = av_get_cpu_flags();
 
-    if (EXTERNAL_SSE2(cpu_flags))
-        s->lowpass_line = ff_lowpass_line_sse2;
-    if (EXTERNAL_AVX(cpu_flags))
-        s->lowpass_line = ff_lowpass_line_avx;
+    if (s->csp->comp[0].depth > 8) {
+        if (EXTERNAL_SSE2(cpu_flags)) {
+            if (s->lowpass == VLPF_LIN)
+                s->lowpass_line = ff_lowpass_line_16_sse2;
+            else if (s->lowpass == VLPF_CMP)
+                s->lowpass_line = ff_lowpass_line_complex_12_sse2;
+        }
+        if (EXTERNAL_AVX(cpu_flags))
+            if (s->lowpass == VLPF_LIN)
+                s->lowpass_line = ff_lowpass_line_16_avx;
+    } else {
+        if (EXTERNAL_SSE2(cpu_flags)) {
+            if (s->lowpass == VLPF_LIN)
+                s->lowpass_line = ff_lowpass_line_sse2;
+            else if (s->lowpass == VLPF_CMP)
+                s->lowpass_line = ff_lowpass_line_complex_sse2;
+        }
+        if (EXTERNAL_AVX(cpu_flags))
+            if (s->lowpass == VLPF_LIN)
+                s->lowpass_line = ff_lowpass_line_avx;
+    }
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_limiter.asm b/mythtv/external/FFmpeg/libavfilter/x86/vf_limiter.asm
new file mode 100644
index 00000000000..c5b9b0a64dd
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_limiter.asm
@@ -0,0 +1,80 @@
+;*****************************************************************************
+;* x86-optimized functions for limiter filter
+;*
+;* 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/x86/x86util.asm"
+
+SECTION .text
+
+INIT_XMM sse2
+
+cglobal limiter_8bit, 6, 7, 3, src, dst, slinesize, dlinesize, w, h, x
+    movsxdifnidn wq, wd
+    add        srcq, wq
+    add        dstq, wq
+    neg          wq
+    movd         m1, r6m
+    punpcklbw    m1, m1
+    SPLATW       m1, m1
+    movd         m2, r7m
+    punpcklbw    m2, m2
+    SPLATW       m2, m2
+.nextrow:
+    mov          xq, wq
+
+    .loop:
+        movu           m0, [srcq + xq]
+        CLIPUB         m0, m1, m2
+        mova    [dstq+xq], m0
+        add            xq, mmsize
+    jl .loop
+
+    add        srcq, slinesizeq
+    add        dstq, dlinesizeq
+    sub        hd, 1
+    jg .nextrow
+    RET
+
+INIT_XMM sse4
+
+cglobal limiter_16bit, 6, 7, 3, src, dst, slinesize, dlinesize, w, h, x
+    shl          wd, 1
+    add        srcq, wq
+    add        dstq, wq
+    neg          wq
+    movd         m1, r6m
+    SPLATW       m1, m1
+    movd         m2, r7m
+    SPLATW       m2, m2
+.nextrow:
+    mov          xq, wq
+
+    .loop:
+        movu           m0, [srcq + xq]
+        pmaxuw         m0, m1
+        pminuw         m0, m2
+        mova    [dstq+xq], m0
+        add            xq, mmsize
+    jl .loop
+
+    add        srcq, slinesizeq
+    add        dstq, dlinesizeq
+    sub        hd, 1
+    jg .nextrow
+    RET
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_limiter_init.c b/mythtv/external/FFmpeg/libavfilter/x86/vf_limiter_init.c
new file mode 100644
index 00000000000..07c733dc21b
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_limiter_init.c
@@ -0,0 +1,44 @@
+/*
+ * 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/x86/cpu.h"
+
+#include "libavfilter/limiter.h"
+
+void ff_limiter_8bit_sse2(const uint8_t *src, uint8_t *dst,
+                          ptrdiff_t slinesize, ptrdiff_t dlinesize,
+                          int w, int h, int min, int max);
+void ff_limiter_16bit_sse4(const uint8_t *src, uint8_t *dst,
+                           ptrdiff_t slinesize, ptrdiff_t dlinesize,
+                           int w, int h, int min, int max);
+
+void ff_limiter_init_x86(LimiterDSPContext *dsp, int bpp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (EXTERNAL_SSE2(cpu_flags)) {
+        if (bpp <= 8) {
+            dsp->limiter = ff_limiter_8bit_sse2;
+        }
+    }
+    if (EXTERNAL_SSE4(cpu_flags)) {
+        if (bpp > 8) {
+            dsp->limiter = ff_limiter_16bit_sse4;
+        }
+    }
+}
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_pullup_init.c b/mythtv/external/FFmpeg/libavfilter/x86/vf_pullup_init.c
index 5b36b68e517..3dc0798da07 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/vf_pullup_init.c
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_pullup_init.c
@@ -29,7 +29,7 @@ int ff_pullup_filter_var_mmx (const uint8_t *a, const uint8_t *b, ptrdiff_t s);
 
 av_cold void ff_pullup_init_x86(PullupContext *s)
 {
-#if HAVE_YASM
+#if HAVE_X86ASM
     int cpu_flags = av_get_cpu_flags();
 
     if (EXTERNAL_MMX(cpu_flags)) {
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_spp.c b/mythtv/external/FFmpeg/libavfilter/x86/vf_spp.c
index 45a9eb068c9..7d5da610daa 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/vf_spp.c
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_spp.c
@@ -21,6 +21,7 @@
 
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
+#include "libavutil/crc.h"
 #include "libavutil/mem.h"
 #include "libavutil/x86/asm.h"
 #include "libavfilter/vf_spp.h"
@@ -223,10 +224,15 @@ av_cold void ff_spp_init_x86(SPPContext *s)
     int cpu_flags = av_get_cpu_flags();
 
     if (cpu_flags & AV_CPU_FLAG_MMX) {
+        static const uint32_t mmx_idct_perm_crc = 0xe5e8adc4;
+        uint32_t idct_perm_crc =
+            av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0,
+                   s->dct->idct_permutation,
+                   sizeof(s->dct->idct_permutation));
         int64_t bps;
         s->store_slice = store_slice_mmx;
         av_opt_get_int(s->dct, "bits_per_sample", 0, &bps);
-        if (bps <= 8) {
+        if (bps <= 8 && idct_perm_crc == mmx_idct_perm_crc) {
             switch (s->mode) {
             case 0: s->requantize = hardthresh_mmx; break;
             case 1: s->requantize = softthresh_mmx; break;
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_tinterlace_init.c b/mythtv/external/FFmpeg/libavfilter/x86/vf_tinterlace_init.c
index ddb0cced363..209812964d0 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/vf_tinterlace_init.c
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_tinterlace_init.c
@@ -28,20 +28,50 @@
 #include "libavfilter/tinterlace.h"
 
 void ff_lowpass_line_sse2(uint8_t *dstp, ptrdiff_t linesize,
-                          const uint8_t *srcp,
-                          const uint8_t *srcp_above,
-                          const uint8_t *srcp_below);
+                          const uint8_t *srcp, ptrdiff_t mref,
+                          ptrdiff_t pref, int clip_max);
 void ff_lowpass_line_avx (uint8_t *dstp, ptrdiff_t linesize,
-                          const uint8_t *srcp,
-                          const uint8_t *srcp_above,
-                          const uint8_t *srcp_below);
+                          const uint8_t *srcp, ptrdiff_t mref,
+                          ptrdiff_t pref, int clip_max);
+
+void ff_lowpass_line_16_sse2(uint8_t *dstp, ptrdiff_t linesize,
+                             const uint8_t *srcp, ptrdiff_t mref,
+                             ptrdiff_t pref, int clip_max);
+void ff_lowpass_line_16_avx (uint8_t *dstp, ptrdiff_t linesize,
+                             const uint8_t *srcp, ptrdiff_t mref,
+                             ptrdiff_t pref, int clip_max);
+
+void ff_lowpass_line_complex_sse2(uint8_t *dstp, ptrdiff_t linesize,
+                                  const uint8_t *srcp, ptrdiff_t mref,
+                                  ptrdiff_t pref, int clip_max);
+
+void ff_lowpass_line_complex_12_sse2(uint8_t *dstp, ptrdiff_t linesize,
+                                     const uint8_t *srcp, ptrdiff_t mref,
+                                     ptrdiff_t pref, int clip_max);
 
 av_cold void ff_tinterlace_init_x86(TInterlaceContext *s)
 {
     int cpu_flags = av_get_cpu_flags();
 
-    if (EXTERNAL_SSE2(cpu_flags))
-        s->lowpass_line = ff_lowpass_line_sse2;
-    if (EXTERNAL_AVX(cpu_flags))
-        s->lowpass_line = ff_lowpass_line_avx;
+    if (s->csp->comp[0].depth > 8) {
+        if (EXTERNAL_SSE2(cpu_flags)) {
+            if (!(s->flags & TINTERLACE_FLAG_CVLPF))
+                s->lowpass_line = ff_lowpass_line_16_sse2;
+            else
+                s->lowpass_line = ff_lowpass_line_complex_12_sse2;
+        }
+        if (EXTERNAL_AVX(cpu_flags))
+            if (!(s->flags & TINTERLACE_FLAG_CVLPF))
+                s->lowpass_line = ff_lowpass_line_16_avx;
+    } else {
+        if (EXTERNAL_SSE2(cpu_flags)) {
+            if (!(s->flags & TINTERLACE_FLAG_CVLPF))
+                s->lowpass_line = ff_lowpass_line_sse2;
+            else
+                s->lowpass_line = ff_lowpass_line_complex_sse2;
+        }
+        if (EXTERNAL_AVX(cpu_flags))
+            if (!(s->flags & TINTERLACE_FLAG_CVLPF))
+                s->lowpass_line = ff_lowpass_line_avx;
+    }
 }
diff --git a/mythtv/external/FFmpeg/libavfilter/x86/vf_w3fdif_init.c b/mythtv/external/FFmpeg/libavfilter/x86/vf_w3fdif_init.c
index 9bf06e84a5d..d4534bb1edf 100644
--- a/mythtv/external/FFmpeg/libavfilter/x86/vf_w3fdif_init.c
+++ b/mythtv/external/FFmpeg/libavfilter/x86/vf_w3fdif_init.c
@@ -43,20 +43,21 @@ void ff_w3fdif_complex_high_sse2(int32_t *work_line,
                                  uint8_t *in_lines_adj[5],
                                  const int16_t *coef, int linesize);
 
-void ff_w3fdif_scale_sse2(uint8_t *out_pixel, const int32_t *work_pixel, int linesize);
+void ff_w3fdif_scale_sse2(uint8_t *out_pixel, const int32_t *work_pixel,
+                          int linesize, int max);
 
-av_cold void ff_w3fdif_init_x86(W3FDIFDSPContext *dsp)
+av_cold void ff_w3fdif_init_x86(W3FDIFDSPContext *dsp, int depth)
 {
     int cpu_flags = av_get_cpu_flags();
 
-    if (EXTERNAL_SSE2(cpu_flags)) {
+    if (EXTERNAL_SSE2(cpu_flags) && depth <= 8) {
         dsp->filter_simple_low   = ff_w3fdif_simple_low_sse2;
         dsp->filter_simple_high  = ff_w3fdif_simple_high_sse2;
         dsp->filter_complex_low  = ff_w3fdif_complex_low_sse2;
         dsp->filter_scale        = ff_w3fdif_scale_sse2;
     }
 
-    if (ARCH_X86_64 && EXTERNAL_SSE2(cpu_flags)) {
+    if (ARCH_X86_64 && EXTERNAL_SSE2(cpu_flags) && depth <= 8) {
         dsp->filter_complex_high = ff_w3fdif_complex_high_sse2;
     }
 }
diff --git a/mythtv/external/FFmpeg/libavformat/4xm.c b/mythtv/external/FFmpeg/libavformat/4xm.c
index 8a50778686f..ead6d2b4243 100644
--- a/mythtv/external/FFmpeg/libavformat/4xm.c
+++ b/mythtv/external/FFmpeg/libavformat/4xm.c
@@ -29,6 +29,7 @@
 
 #include "libavutil/intreadwrite.h"
 #include "libavutil/intfloat.h"
+#include "libavcodec/internal.h"
 #include "avformat.h"
 #include "internal.h"
 
@@ -153,8 +154,10 @@ static int parse_strk(AVFormatContext *s,
     fourxm->tracks[track].audio_pts   = 0;
 
     if (fourxm->tracks[track].channels    <= 0 ||
+        fourxm->tracks[track].channels     > FF_SANE_NB_CHANNELS ||
         fourxm->tracks[track].sample_rate <= 0 ||
-        fourxm->tracks[track].bits        <= 0) {
+        fourxm->tracks[track].bits        <= 0 ||
+        fourxm->tracks[track].bits         > INT_MAX / FF_SANE_NB_CHANNELS) {
         av_log(s, AV_LOG_ERROR, "audio header invalid\n");
         return AVERROR_INVALIDDATA;
     }
@@ -163,6 +166,12 @@ static int parse_strk(AVFormatContext *s,
         return AVERROR_INVALIDDATA;
     }
 
+    if (fourxm->tracks[track].sample_rate > INT64_MAX / fourxm->tracks[track].bits / fourxm->tracks[track].channels) {
+        av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %d * %d * %d\n",
+               fourxm->tracks[track].sample_rate, fourxm->tracks[track].bits, fourxm->tracks[track].channels);
+        return AVERROR_INVALIDDATA;
+    }
+
     /* allocate a new AVStream */
     st = avformat_new_stream(s, NULL);
     if (!st)
@@ -178,7 +187,7 @@ static int parse_strk(AVFormatContext *s,
     st->codecpar->channels              = fourxm->tracks[track].channels;
     st->codecpar->sample_rate           = fourxm->tracks[track].sample_rate;
     st->codecpar->bits_per_coded_sample = fourxm->tracks[track].bits;
-    st->codecpar->bit_rate              = st->codecpar->channels *
+    st->codecpar->bit_rate              = (int64_t)st->codecpar->channels *
                                           st->codecpar->sample_rate *
                                           st->codecpar->bits_per_coded_sample;
     st->codecpar->block_align           = st->codecpar->channels *
diff --git a/mythtv/external/FFmpeg/libavformat/Makefile b/mythtv/external/FFmpeg/libavformat/Makefile
index 07abe9514b8..a00ae19f3a1 100644
--- a/mythtv/external/FFmpeg/libavformat/Makefile
+++ b/mythtv/external/FFmpeg/libavformat/Makefile
@@ -1,6 +1,5 @@
-include $(SUBDIR)../config.mak
-
 NAME = avformat
+DESC = FFmpeg container format library
 
 HEADERS = avformat.h                                                    \
           avio.h                                                        \
@@ -56,6 +55,7 @@ OBJS-$(CONFIG_RTPDEC)                    += rdt.o                       \
                                             rtpdec_qcelp.o              \
                                             rtpdec_qdm2.o               \
                                             rtpdec_qt.o                 \
+                                            rtpdec_rfc4175.o            \
                                             rtpdec_svq3.o               \
                                             rtpdec_vc2hq.o              \
                                             rtpdec_vp8.o                \
@@ -84,7 +84,7 @@ OBJS-$(CONFIG_AEA_DEMUXER)               += aea.o pcm.o
 OBJS-$(CONFIG_AFC_DEMUXER)               += afc.o
 OBJS-$(CONFIG_AIFF_DEMUXER)              += aiffdec.o pcm.o isom.o \
                                             mov_chan.o
-OBJS-$(CONFIG_AIFF_MUXER)                += aiffenc.o isom.o id3v2enc.o
+OBJS-$(CONFIG_AIFF_MUXER)                += aiffenc.o id3v2enc.o
 OBJS-$(CONFIG_AIX_DEMUXER)               += aixdec.o
 OBJS-$(CONFIG_AMR_DEMUXER)               += amr.o
 OBJS-$(CONFIG_AMR_MUXER)                 += amr.o
@@ -107,7 +107,6 @@ OBJS-$(CONFIG_AU_DEMUXER)                += au.o pcm.o
 OBJS-$(CONFIG_AU_MUXER)                  += au.o rawenc.o
 OBJS-$(CONFIG_AVI_DEMUXER)               += avidec.o
 OBJS-$(CONFIG_AVI_MUXER)                 += avienc.o mpegtsenc.o avlanguage.o rawutils.o
-OBJS-$(CONFIG_AVISYNTH)                  += avisynth.o
 OBJS-$(CONFIG_AVM2_MUXER)                += swfenc.o swf.o
 OBJS-$(CONFIG_AVR_DEMUXER)               += avr.o pcm.o
 OBJS-$(CONFIG_AVS_DEMUXER)               += avs.o voc_packet.o vocdec.o voc.o
@@ -124,7 +123,7 @@ OBJS-$(CONFIG_BRSTM_DEMUXER)             += brstm.o
 OBJS-$(CONFIG_C93_DEMUXER)               += c93.o voc_packet.o vocdec.o voc.o
 OBJS-$(CONFIG_CAF_DEMUXER)               += cafdec.o caf.o mov.o mov_chan.o \
                                             replaygain.o
-OBJS-$(CONFIG_CAF_MUXER)                 += cafenc.o caf.o riff.o isom.o
+OBJS-$(CONFIG_CAF_MUXER)                 += cafenc.o caf.o riff.o
 OBJS-$(CONFIG_CAVSVIDEO_DEMUXER)         += cavsvideodec.o rawdec.o
 OBJS-$(CONFIG_CAVSVIDEO_MUXER)           += rawenc.o
 OBJS-$(CONFIG_CDG_DEMUXER)               += cdg.o
@@ -133,8 +132,9 @@ OBJS-$(CONFIG_CINE_DEMUXER)              += cinedec.o
 OBJS-$(CONFIG_CONCAT_DEMUXER)            += concatdec.o
 OBJS-$(CONFIG_CRC_MUXER)                 += crcenc.o
 OBJS-$(CONFIG_DATA_DEMUXER)              += rawdec.o
-OBJS-$(CONFIG_DATA_MUXER)                += rawdec.o
-OBJS-$(CONFIG_DASH_MUXER)                += dashenc.o
+OBJS-$(CONFIG_DATA_MUXER)                += rawenc.o
+OBJS-$(CONFIG_DASH_MUXER)                += dash.o dashenc.o
+OBJS-$(CONFIG_DASH_DEMUXER)              += dashdec.o
 OBJS-$(CONFIG_DAUD_DEMUXER)              += dauddec.o
 OBJS-$(CONFIG_DAUD_MUXER)                += daudenc.o
 OBJS-$(CONFIG_DCSTR_DEMUXER)             += dcstr.o
@@ -166,6 +166,8 @@ OBJS-$(CONFIG_FFMETADATA_MUXER)          += ffmetaenc.o
 OBJS-$(CONFIG_FIFO_MUXER)                += fifo.o
 OBJS-$(CONFIG_FILMSTRIP_DEMUXER)         += filmstripdec.o
 OBJS-$(CONFIG_FILMSTRIP_MUXER)           += filmstripenc.o
+OBJS-$(CONFIG_FITS_DEMUXER)              += fitsdec.o
+OBJS-$(CONFIG_FITS_MUXER)                += fitsenc.o
 OBJS-$(CONFIG_FLAC_DEMUXER)              += flacdec.o rawdec.o \
                                             flac_picture.o   \
                                             oggparsevorbis.o \
@@ -193,7 +195,12 @@ OBJS-$(CONFIG_G722_DEMUXER)              += g722.o rawdec.o
 OBJS-$(CONFIG_G722_MUXER)                += rawenc.o
 OBJS-$(CONFIG_G723_1_DEMUXER)            += g723_1.o
 OBJS-$(CONFIG_G723_1_MUXER)              += rawenc.o
+OBJS-$(CONFIG_G726_DEMUXER)              += g726.o
+OBJS-$(CONFIG_G726_MUXER)                += rawenc.o
+OBJS-$(CONFIG_G726LE_DEMUXER)            += g726.o
+OBJS-$(CONFIG_G726LE_MUXER)              += rawenc.o
 OBJS-$(CONFIG_G729_DEMUXER)              += g729dec.o
+OBJS-$(CONFIG_GDV_DEMUXER)               += gdv.o
 OBJS-$(CONFIG_GENH_DEMUXER)              += genh.o
 OBJS-$(CONFIG_H261_DEMUXER)              += h261dec.o rawdec.o
 OBJS-$(CONFIG_H261_MUXER)                += rawenc.o
@@ -236,11 +243,14 @@ OBJS-$(CONFIG_IMAGE_PGM_PIPE_DEMUXER)     += img2dec.o img2.o
 OBJS-$(CONFIG_IMAGE_PICTOR_PIPE_DEMUXER)  += img2dec.o img2.o
 OBJS-$(CONFIG_IMAGE_PNG_PIPE_DEMUXER)     += img2dec.o img2.o
 OBJS-$(CONFIG_IMAGE_PPM_PIPE_DEMUXER)     += img2dec.o img2.o
+OBJS-$(CONFIG_IMAGE_PSD_PIPE_DEMUXER)     += img2dec.o img2.o
 OBJS-$(CONFIG_IMAGE_QDRAW_PIPE_DEMUXER)   += img2dec.o img2.o
 OBJS-$(CONFIG_IMAGE_SGI_PIPE_DEMUXER)     += img2dec.o img2.o
+OBJS-$(CONFIG_IMAGE_SVG_PIPE_DEMUXER)     += img2dec.o img2.o
 OBJS-$(CONFIG_IMAGE_SUNRAST_PIPE_DEMUXER) += img2dec.o img2.o
 OBJS-$(CONFIG_IMAGE_TIFF_PIPE_DEMUXER)    += img2dec.o img2.o
 OBJS-$(CONFIG_IMAGE_WEBP_PIPE_DEMUXER)    += img2dec.o img2.o
+OBJS-$(CONFIG_IMAGE_XPM_PIPE_DEMUXER)     += img2dec.o img2.o
 OBJS-$(CONFIG_INGENIENT_DEMUXER)         += ingenientdec.o rawdec.o
 OBJS-$(CONFIG_IPMOVIE_DEMUXER)           += ipmovie.o
 OBJS-$(CONFIG_IRCAM_DEMUXER)             += ircamdec.o ircam.o pcm.o
@@ -274,6 +284,7 @@ OBJS-$(CONFIG_MD5_MUXER)                 += hashenc.o
 OBJS-$(CONFIG_MGSTS_DEMUXER)             += mgsts.o
 OBJS-$(CONFIG_MICRODVD_DEMUXER)          += microdvddec.o subtitles.o
 OBJS-$(CONFIG_MICRODVD_MUXER)            += microdvdenc.o
+OBJS-$(CONFIG_MJPEG_2000_DEMUXER)        += rawdec.o mj2kdec.o
 OBJS-$(CONFIG_MJPEG_DEMUXER)             += rawdec.o
 OBJS-$(CONFIG_MJPEG_MUXER)               += rawenc.o
 OBJS-$(CONFIG_MLP_DEMUXER)               += rawdec.o mlpdec.o
@@ -286,7 +297,7 @@ OBJS-$(CONFIG_MOV_DEMUXER)               += mov.o mov_chan.o replaygain.o
 OBJS-$(CONFIG_MOV_MUXER)                 += movenc.o avc.o hevc.o vpcc.o \
                                             movenchint.o mov_chan.o rtp.o \
                                             movenccenc.o rawutils.o
-OBJS-$(CONFIG_MP2_MUXER)                 += mp3enc.o rawenc.o id3v2enc.o
+OBJS-$(CONFIG_MP2_MUXER)                 += rawenc.o
 OBJS-$(CONFIG_MP3_DEMUXER)               += mp3dec.o replaygain.o
 OBJS-$(CONFIG_MP3_MUXER)                 += mp3enc.o rawenc.o id3v2enc.o
 OBJS-$(CONFIG_MPC_DEMUXER)               += mpc.o apetag.o img2.o
@@ -430,12 +441,17 @@ OBJS-$(CONFIG_RTSP_DEMUXER)              += rtsp.o rtspdec.o httpauth.o \
                                             urldecode.o
 OBJS-$(CONFIG_RTSP_MUXER)                += rtsp.o rtspenc.o httpauth.o \
                                             urldecode.o
+OBJS-$(CONFIG_S337M_DEMUXER)             += s337m.o spdif.o
 OBJS-$(CONFIG_SAMI_DEMUXER)              += samidec.o subtitles.o
 OBJS-$(CONFIG_SAP_DEMUXER)               += sapdec.o
 OBJS-$(CONFIG_SAP_MUXER)                 += sapenc.o
 OBJS-$(CONFIG_SBG_DEMUXER)               += sbgdec.o
+OBJS-$(CONFIG_SCC_DEMUXER)               += sccdec.o subtitles.o
+OBJS-$(CONFIG_SCC_MUXER)                 += sccenc.o subtitles.o
 OBJS-$(CONFIG_SDP_DEMUXER)               += rtsp.o
 OBJS-$(CONFIG_SDR2_DEMUXER)              += sdr2.o
+OBJS-$(CONFIG_SDS_DEMUXER)               += sdsdec.o
+OBJS-$(CONFIG_SDX_DEMUXER)               += sdxdec.o
 OBJS-$(CONFIG_SEGAFILM_DEMUXER)          += segafilm.o
 OBJS-$(CONFIG_SEGMENT_MUXER)             += segment.o
 OBJS-$(CONFIG_SHORTEN_DEMUXER)           += shortendec.o rawdec.o
@@ -460,6 +476,7 @@ OBJS-$(CONFIG_STR_DEMUXER)               += psxstr.o
 OBJS-$(CONFIG_SUBVIEWER1_DEMUXER)        += subviewer1dec.o subtitles.o
 OBJS-$(CONFIG_SUBVIEWER_DEMUXER)         += subviewerdec.o subtitles.o
 OBJS-$(CONFIG_SUP_DEMUXER)               += supdec.o
+OBJS-$(CONFIG_SUP_MUXER)                 += supenc.o
 OBJS-$(CONFIG_SVAG_DEMUXER)              += svag.o
 OBJS-$(CONFIG_SWF_DEMUXER)               += swfdec.o swf.o
 OBJS-$(CONFIG_SWF_MUXER)                 += swfenc.o swf.o
@@ -528,11 +545,10 @@ OBJS-$(CONFIG_YUV4MPEGPIPE_DEMUXER)      += yuv4mpegdec.o
 OBJS-$(CONFIG_YUV4MPEGPIPE_MUXER)        += yuv4mpegenc.o
 
 # external libraries
+OBJS-$(CONFIG_AVISYNTH_DEMUXER)          += avisynth.o
 OBJS-$(CONFIG_CHROMAPRINT_MUXER)         += chromaprint.o
 OBJS-$(CONFIG_LIBGME_DEMUXER)            += libgme.o
 OBJS-$(CONFIG_LIBMODPLUG_DEMUXER)        += libmodplug.o
-OBJS-$(CONFIG_LIBNUT_DEMUXER)            += libnut.o
-OBJS-$(CONFIG_LIBNUT_MUXER)              += libnut.o
 OBJS-$(CONFIG_LIBOPENMPT_DEMUXER)        += libopenmpt.o
 OBJS-$(CONFIG_LIBRTMP)                   += librtmp.o
 OBJS-$(CONFIG_LIBSSH_PROTOCOL)           += libssh.o
@@ -560,6 +576,7 @@ OBJS-$(CONFIG_MD5_PROTOCOL)              += md5proto.o
 OBJS-$(CONFIG_MMSH_PROTOCOL)             += mmsh.o mms.o asf.o
 OBJS-$(CONFIG_MMST_PROTOCOL)             += mmst.o mms.o asf.o
 OBJS-$(CONFIG_PIPE_PROTOCOL)             += file.o
+OBJS-$(CONFIG_PROMPEG_PROTOCOL)          += prompeg.o
 OBJS-$(CONFIG_RTMP_PROTOCOL)             += rtmpproto.o rtmppkt.o
 OBJS-$(CONFIG_RTMPE_PROTOCOL)            += rtmpproto.o rtmppkt.o
 OBJS-$(CONFIG_RTMPS_PROTOCOL)            += rtmpproto.o rtmppkt.o
@@ -593,7 +610,8 @@ TESTPROGS = seek                                                        \
             url                                                         \
 #           async                                                       \
 
-TESTPROGS-$(CONFIG_FIFO_MUXER)          += fifo_muxer
+FIFO-MUXER-TESTPROGS-$(CONFIG_NETWORK)   += fifo_muxer
+TESTPROGS-$(CONFIG_FIFO_MUXER)           += $(FIFO-MUXER-TESTPROGS-yes)
 TESTPROGS-$(CONFIG_FFRTMPCRYPT_PROTOCOL) += rtmpdh
 TESTPROGS-$(CONFIG_MOV_MUXER)            += movenc
 TESTPROGS-$(CONFIG_NETWORK)              += noproxy
diff --git a/mythtv/external/FFmpeg/libavformat/aacdec.c b/mythtv/external/FFmpeg/libavformat/aacdec.c
index fecb1e381da..36d558ff54c 100644
--- a/mythtv/external/FFmpeg/libavformat/aacdec.c
+++ b/mythtv/external/FFmpeg/libavformat/aacdec.c
@@ -23,10 +23,11 @@
 #include "libavutil/intreadwrite.h"
 #include "avformat.h"
 #include "internal.h"
-#include "rawdec.h"
 #include "id3v1.h"
 #include "apetag.h"
 
+#define ADTS_HEADER_SIZE 7
+
 static int adts_aac_probe(AVProbeData *p)
 {
     int max_frames = 0, first_frames = 0;
@@ -79,6 +80,7 @@ static int adts_aac_probe(AVProbeData *p)
 static int adts_aac_read_header(AVFormatContext *s)
 {
     AVStream *st;
+    uint16_t state;
 
     st = avformat_new_stream(s, NULL);
     if (!st)
@@ -89,25 +91,67 @@ static int adts_aac_read_header(AVFormatContext *s)
     st->need_parsing         = AVSTREAM_PARSE_FULL_RAW;
 
     ff_id3v1_read(s);
-    if (s->pb->seekable &&
+    if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
         !av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX)) {
         int64_t cur = avio_tell(s->pb);
         ff_ape_parse_tag(s);
         avio_seek(s->pb, cur, SEEK_SET);
     }
 
+    // skip data until the first ADTS frame is found
+    state = avio_r8(s->pb);
+    while (!avio_feof(s->pb) && avio_tell(s->pb) < s->probesize) {
+        state = (state << 8) | avio_r8(s->pb);
+        if ((state >> 4) != 0xFFF)
+            continue;
+        avio_seek(s->pb, -2, SEEK_CUR);
+        break;
+    }
+    if ((state >> 4) != 0xFFF)
+        return AVERROR_INVALIDDATA;
+
     // LCM of all possible ADTS sample rates
     avpriv_set_pts_info(st, 64, 1, 28224000);
 
     return 0;
 }
 
+static int adts_aac_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    int ret, fsize;
+
+    ret = av_get_packet(s->pb, pkt, ADTS_HEADER_SIZE);
+    if (ret < 0)
+        return ret;
+    if (ret < ADTS_HEADER_SIZE) {
+        av_packet_unref(pkt);
+        return AVERROR(EIO);
+    }
+
+    if ((AV_RB16(pkt->data) >> 4) != 0xfff) {
+        av_packet_unref(pkt);
+        return AVERROR_INVALIDDATA;
+    }
+
+    fsize = (AV_RB32(pkt->data + 3) >> 13) & 0x1FFF;
+    if (fsize < ADTS_HEADER_SIZE) {
+        av_packet_unref(pkt);
+        return AVERROR_INVALIDDATA;
+    }
+
+    ret = av_append_packet(s->pb, pkt, fsize - ADTS_HEADER_SIZE);
+    if (ret < 0)
+        av_packet_unref(pkt);
+
+    return ret;
+}
+
 AVInputFormat ff_aac_demuxer = {
     .name         = "aac",
     .long_name    = NULL_IF_CONFIG_SMALL("raw ADTS AAC (Advanced Audio Coding)"),
     .read_probe   = adts_aac_probe,
     .read_header  = adts_aac_read_header,
-    .read_packet  = ff_raw_read_partial_packet,
+    .read_packet  = adts_aac_read_packet,
     .flags        = AVFMT_GENERIC_INDEX,
     .extensions   = "aac",
     .mime_type    = "audio/aac,audio/aacp,audio/x-aac",
diff --git a/mythtv/external/FFmpeg/libavformat/aadec.c b/mythtv/external/FFmpeg/libavformat/aadec.c
index cf5f3d107ad..8d39b1d9baa 100644
--- a/mythtv/external/FFmpeg/libavformat/aadec.c
+++ b/mythtv/external/FFmpeg/libavformat/aadec.c
@@ -25,6 +25,7 @@
 
 #include "avformat.h"
 #include "internal.h"
+#include "libavutil/dict.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/tea.h"
 #include "libavutil/opt.h"
@@ -101,27 +102,18 @@ static int aa_read_header(AVFormatContext *s)
         avio_skip(pb, 1); // unidentified integer
         nkey = avio_rb32(pb); // key string length
         nval = avio_rb32(pb); // value string length
-        if (nkey > sizeof(key)) {
-            avio_skip(pb, nkey);
-        } else {
-            avio_read(pb, key, nkey); // key string
-        }
-        if (nval > sizeof(val)) {
-            avio_skip(pb, nval);
-        } else {
-            avio_read(pb, val, nval); // value string
-        }
+        avio_get_str(pb, nkey, key, sizeof(key));
+        avio_get_str(pb, nval, val, sizeof(val));
         if (!strcmp(key, "codec")) {
             av_log(s, AV_LOG_DEBUG, "Codec is <%s>\n", val);
             strncpy(codec_name, val, sizeof(codec_name) - 1);
-        }
-        if (!strcmp(key, "HeaderSeed")) {
+        } else if (!strcmp(key, "HeaderSeed")) {
             av_log(s, AV_LOG_DEBUG, "HeaderSeed is <%s>\n", val);
             header_seed = atoi(val);
-        }
-        if (!strcmp(key, "HeaderKey")) { // this looks like "1234567890 1234567890 1234567890 1234567890"
+        } else if (!strcmp(key, "HeaderKey")) { // this looks like "1234567890 1234567890 1234567890 1234567890"
             av_log(s, AV_LOG_DEBUG, "HeaderKey is <%s>\n", val);
-            sscanf(val, "%u%u%u%u", &header_key_part[0], &header_key_part[1], &header_key_part[2], &header_key_part[3]);
+            sscanf(val, "%"SCNu32"%"SCNu32"%"SCNu32"%"SCNu32,
+                   &header_key_part[0], &header_key_part[1], &header_key_part[2], &header_key_part[3]);
             for (idx = 0; idx < 4; idx++) {
                 AV_WB32(&header_key[idx * 4], header_key_part[idx]); // convert each part to BE!
             }
@@ -129,6 +121,8 @@ static int aa_read_header(AVFormatContext *s)
             for (i = 0; i < 16; i++)
                 av_log(s, AV_LOG_DEBUG, "%02x", header_key[i]);
             av_log(s, AV_LOG_DEBUG, "\n");
+        } else {
+            av_dict_set(&s->metadata, key, val, 0);
         }
     }
 
@@ -184,11 +178,13 @@ static int aa_read_header(AVFormatContext *s)
         st->codecpar->block_align = 19;
         st->codecpar->channels = 1;
         st->codecpar->sample_rate = 8500;
+        st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
     } else if (!strcmp(codec_name, "acelp16")) {
         st->codecpar->codec_id = AV_CODEC_ID_SIPR;
         st->codecpar->block_align = 20;
         st->codecpar->channels = 1;
         st->codecpar->sample_rate = 16000;
+        st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
     }
 
     /* determine, and jump to audio start offset */
diff --git a/mythtv/external/FFmpeg/libavformat/ac3dec.c b/mythtv/external/FFmpeg/libavformat/ac3dec.c
index 363a32e04ec..e85b0ac7c9e 100644
--- a/mythtv/external/FFmpeg/libavformat/ac3dec.c
+++ b/mythtv/external/FFmpeg/libavformat/ac3dec.c
@@ -49,8 +49,8 @@ static int ac3_eac3_probe(AVProbeData *p, enum AVCodecID expected_codec_id)
                 buf2+=16;
             if (buf[0] == 0x77 && buf[1] == 0x0B) {
                 for(i=0; i<8; i+=2) {
-                    buf3[i  ] = buf[i+1];
-                    buf3[i+1] = buf[i  ];
+                    buf3[i  ] = buf2[i+1];
+                    buf3[i+1] = buf2[i  ];
                 }
                 init_get_bits(&gbc, buf3, 54);
             }else
@@ -62,8 +62,8 @@ static int ac3_eac3_probe(AVProbeData *p, enum AVCodecID expected_codec_id)
             if (buf[0] == 0x77 && buf[1] == 0x0B) {
                 av_assert0(phdr->frame_size <= sizeof(buf3));
                 for(i=8; i<phdr->frame_size; i+=2) {
-                    buf3[i  ] = buf[i+1];
-                    buf3[i+1] = buf[i  ];
+                    buf3[i  ] = buf2[i+1];
+                    buf3[i+1] = buf2[i  ];
                 }
             }
             if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, gbc.buffer + 2, phdr->frame_size - 2))
diff --git a/mythtv/external/FFmpeg/libavformat/adp.c b/mythtv/external/FFmpeg/libavformat/adp.c
index 9ab2ec4566f..3914857ad53 100644
--- a/mythtv/external/FFmpeg/libavformat/adp.c
+++ b/mythtv/external/FFmpeg/libavformat/adp.c
@@ -27,7 +27,7 @@
 static int adp_probe(AVProbeData *p)
 {
     int i, changes = 0;
-    char last = 0;
+    uint8_t last = 0;
 
     if (p->buf_size < 32)
         return 0;
@@ -59,7 +59,7 @@ static int adp_read_header(AVFormatContext *s)
     st->codecpar->channels       = 2;
     st->codecpar->sample_rate    = 48000;
     st->start_time            = 0;
-    if (s->pb->seekable)
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
         st->duration          = av_get_audio_frame_duration2(st->codecpar, avio_size(s->pb));
 
     avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
diff --git a/mythtv/external/FFmpeg/libavformat/adtsenc.c b/mythtv/external/FFmpeg/libavformat/adtsenc.c
index 5e006dd38f6..a046c2f2f43 100644
--- a/mythtv/external/FFmpeg/libavformat/adtsenc.c
+++ b/mythtv/external/FFmpeg/libavformat/adtsenc.c
@@ -149,11 +149,28 @@ static int adts_write_frame_header(ADTSContext *ctx,
 static int adts_write_packet(AVFormatContext *s, AVPacket *pkt)
 {
     ADTSContext *adts = s->priv_data;
+    AVCodecParameters *par = s->streams[0]->codecpar;
     AVIOContext *pb = s->pb;
     uint8_t buf[ADTS_HEADER_SIZE];
 
     if (!pkt->size)
         return 0;
+    if (!par->extradata_size) {
+        uint8_t *side_data;
+        int side_data_size = 0, ret;
+
+        side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,
+                                            &side_data_size);
+        if (side_data_size) {
+            ret = adts_decode_extradata(s, adts, side_data, side_data_size);
+            if (ret < 0)
+                return ret;
+            ret = ff_alloc_extradata(par, side_data_size);
+            if (ret < 0)
+                return ret;
+            memcpy(par->extradata, side_data, side_data_size);
+        }
+    }
     if (adts->write_adts) {
         int err = adts_write_frame_header(adts, buf, pkt->size,
                                              adts->pce_size);
diff --git a/mythtv/external/FFmpeg/libavformat/adxdec.c b/mythtv/external/FFmpeg/libavformat/adxdec.c
index cf4453195ec..a271e2afa80 100644
--- a/mythtv/external/FFmpeg/libavformat/adxdec.c
+++ b/mythtv/external/FFmpeg/libavformat/adxdec.c
@@ -109,9 +109,14 @@ static int adx_read_header(AVFormatContext *s)
         return AVERROR_INVALIDDATA;
     }
 
+    if (par->sample_rate <= 0) {
+        av_log(s, AV_LOG_ERROR, "Invalid sample rate %d\n", par->sample_rate);
+        return AVERROR_INVALIDDATA;
+    }
+
     par->codec_type  = AVMEDIA_TYPE_AUDIO;
     par->codec_id    = s->iformat->raw_codec_id;
-    par->bit_rate    = par->sample_rate * par->channels * BLOCK_SIZE * 8LL / BLOCK_SAMPLES;
+    par->bit_rate    = (int64_t)par->sample_rate * par->channels * BLOCK_SIZE * 8LL / BLOCK_SAMPLES;
 
     avpriv_set_pts_info(st, 64, BLOCK_SAMPLES, par->sample_rate);
 
diff --git a/mythtv/external/FFmpeg/libavformat/aiffdec.c b/mythtv/external/FFmpeg/libavformat/aiffdec.c
index 59e969d12d4..99e05c78eca 100644
--- a/mythtv/external/FFmpeg/libavformat/aiffdec.c
+++ b/mythtv/external/FFmpeg/libavformat/aiffdec.c
@@ -128,11 +128,9 @@ static int get_aiff_header(AVFormatContext *s, int size,
     } else if (version == AIFF_C_VERSION1) {
         par->codec_tag = avio_rl32(pb);
         par->codec_id  = ff_codec_get_id(ff_codec_aiff_tags, par->codec_tag);
-        if (par->codec_id == AV_CODEC_ID_NONE) {
-            char tag[32];
-            av_get_codec_tag_string(tag, sizeof(tag), par->codec_tag);
-            avpriv_request_sample(s, "unknown or unsupported codec tag: %s", tag);
-        }
+        if (par->codec_id == AV_CODEC_ID_NONE)
+            avpriv_request_sample(s, "unknown or unsupported codec tag: %s",
+                                  av_fourcc2str(par->codec_tag));
         size -= 4;
     }
 
@@ -181,7 +179,7 @@ static int get_aiff_header(AVFormatContext *s, int size,
         par->block_align = (av_get_bits_per_sample(par->codec_id) * par->channels) >> 3;
 
     if (aiff->block_duration) {
-        par->bit_rate = par->sample_rate * (par->block_align << 3) /
+        par->bit_rate = (int64_t)par->sample_rate * (par->block_align << 3) /
                         aiff->block_duration;
     }
 
@@ -260,7 +258,8 @@ static int aiff_read_header(AVFormatContext *s)
             position = avio_tell(pb);
             ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, size);
             if (id3v2_extra_meta)
-                if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0) {
+                if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0 ||
+                    (ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0) {
                     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
                     return ret;
                 }
@@ -288,9 +287,9 @@ static int aiff_read_header(AVFormatContext *s)
             offset = avio_rb32(pb);      /* Offset of sound data */
             avio_rb32(pb);               /* BlockSize... don't care */
             offset += avio_tell(pb);    /* Compute absolute data offset */
-            if (st->codecpar->block_align && !pb->seekable)    /* Assume COMM already parsed */
+            if (st->codecpar->block_align && !(pb->seekable & AVIO_SEEKABLE_NORMAL))    /* Assume COMM already parsed */
                 goto got_sound;
-            if (!pb->seekable) {
+            if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
                 av_log(s, AV_LOG_ERROR, "file is not seekable\n");
                 return -1;
             }
@@ -318,7 +317,7 @@ static int aiff_read_header(AVFormatContext *s)
                     st->codecpar->block_align = 35;
                 }
                 aiff->block_duration = 160;
-                st->codecpar->bit_rate = st->codecpar->sample_rate * (st->codecpar->block_align << 3) /
+                st->codecpar->bit_rate = (int64_t)st->codecpar->sample_rate * (st->codecpar->block_align << 3) /
                                          aiff->block_duration;
             }
             break;
@@ -330,10 +329,14 @@ static int aiff_read_header(AVFormatContext *s)
             if (offset > 0 && st->codecpar->block_align) // COMM && SSND
                 goto got_sound;
         default: /* Jump */
-            if (size & 1)   /* Always even aligned */
-                size++;
             avio_skip(pb, size);
         }
+
+        /* Skip required padding byte for odd-sized chunks. */
+        if (size & 1) {
+            filesize--;
+            avio_skip(pb, 1);
+        }
     }
 
 got_sound:
diff --git a/mythtv/external/FFmpeg/libavformat/aiffenc.c b/mythtv/external/FFmpeg/libavformat/aiffenc.c
index 74b778bbcba..aab37418f0d 100644
--- a/mythtv/external/FFmpeg/libavformat/aiffenc.c
+++ b/mythtv/external/FFmpeg/libavformat/aiffenc.c
@@ -49,7 +49,7 @@ static int put_id3v2_tags(AVFormatContext *s, AIFFOutputContext *aiff)
     AVIOContext *pb = s->pb;
     AVPacketList *pict_list = aiff->pict_list;
 
-    if (!pb->seekable)
+    if (!pb->seekable & AVIO_SEEKABLE_NORMAL)
         return 0;
 
     if (!s->metadata && !aiff->pict_list)
@@ -233,7 +233,8 @@ static int aiff_write_packet(AVFormatContext *s, AVPacket *pkt)
         if (!pict_list)
             return AVERROR(ENOMEM);
 
-        if ((ret = av_copy_packet(&pict_list->pkt, pkt)) < 0) {
+        ret = av_packet_ref(&pict_list->pkt, pkt);
+        if (ret < 0) {
             av_freep(&pict_list);
             return ret;
         }
@@ -267,7 +268,7 @@ static int aiff_write_trailer(AVFormatContext *s)
         end_size++;
     }
 
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         /* Number of sample frames */
         avio_seek(pb, aiff->frames, SEEK_SET);
         avio_wb32(pb, (file_size - aiff->ssnd - 12) / par->block_align);
diff --git a/mythtv/external/FFmpeg/libavformat/allformats.c b/mythtv/external/FFmpeg/libavformat/allformats.c
index 405440d6309..246663834ef 100644
--- a/mythtv/external/FFmpeg/libavformat/allformats.c
+++ b/mythtv/external/FFmpeg/libavformat/allformats.c
@@ -19,6 +19,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/thread.h"
 #include "avformat.h"
 #include "rtp.h"
 #include "rdt.h"
@@ -41,13 +42,8 @@
 
 #define REGISTER_MUXDEMUX(X, x) REGISTER_MUXER(X, x); REGISTER_DEMUXER(X, x)
 
-void av_register_all(void)
+static void register_all(void)
 {
-    static int initialized;
-
-    if (initialized)
-        return;
-
     avcodec_register_all();
 
     /* (de)muxers */
@@ -100,7 +96,7 @@ void av_register_all(void)
     REGISTER_DEMUXER (CINE,             cine);
     REGISTER_DEMUXER (CONCAT,           concat);
     REGISTER_MUXER   (CRC,              crc);
-    REGISTER_MUXER   (DASH,             dash);
+    REGISTER_MUXDEMUX(DASH,             dash);
     REGISTER_MUXDEMUX(DATA,             data);
     REGISTER_MUXDEMUX(DAUD,             daud);
     REGISTER_DEMUXER (DCSTR,            dcstr);
@@ -125,6 +121,7 @@ void av_register_all(void)
     REGISTER_MUXDEMUX(FFMETADATA,       ffmetadata);
     REGISTER_MUXER   (FIFO,             fifo);
     REGISTER_MUXDEMUX(FILMSTRIP,        filmstrip);
+    REGISTER_MUXDEMUX(FITS,             fits);
     REGISTER_MUXDEMUX(FLAC,             flac);
     REGISTER_DEMUXER (FLIC,             flic);
     REGISTER_MUXDEMUX(FLV,              flv);
@@ -137,7 +134,10 @@ void av_register_all(void)
     REGISTER_DEMUXER (FSB,              fsb);
     REGISTER_MUXDEMUX(G722,             g722);
     REGISTER_MUXDEMUX(G723_1,           g723_1);
+    REGISTER_MUXDEMUX(G726,             g726);
+    REGISTER_MUXDEMUX(G726LE,           g726le);
     REGISTER_DEMUXER (G729,             g729);
+    REGISTER_DEMUXER (GDV,              gdv);
     REGISTER_DEMUXER (GENH,             genh);
     REGISTER_MUXDEMUX(GIF,              gif);
     REGISTER_MUXDEMUX(GSM,              gsm);
@@ -183,6 +183,7 @@ void av_register_all(void)
     REGISTER_DEMUXER (MGSTS,            mgsts);
     REGISTER_MUXDEMUX(MICRODVD,         microdvd);
     REGISTER_MUXDEMUX(MJPEG,            mjpeg);
+    REGISTER_DEMUXER (MJPEG_2000,       mjpeg_2000);
     REGISTER_MUXDEMUX(MLP,              mlp);
     REGISTER_DEMUXER (MLV,              mlv);
     REGISTER_DEMUXER (MM,               mm);
@@ -271,11 +272,15 @@ void av_register_all(void)
     REGISTER_MUXDEMUX(RTP,              rtp);
     REGISTER_MUXER   (RTP_MPEGTS,       rtp_mpegts);
     REGISTER_MUXDEMUX(RTSP,             rtsp);
+    REGISTER_DEMUXER (S337M,            s337m);
     REGISTER_DEMUXER (SAMI,             sami);
     REGISTER_MUXDEMUX(SAP,              sap);
     REGISTER_DEMUXER (SBG,              sbg);
+    REGISTER_MUXDEMUX(SCC,              scc);
     REGISTER_DEMUXER (SDP,              sdp);
     REGISTER_DEMUXER (SDR2,             sdr2);
+    REGISTER_DEMUXER (SDS,              sds);
+    REGISTER_DEMUXER (SDX,              sdx);
 #if CONFIG_RTPDEC
     ff_register_rtp_dynamic_payload_handlers();
     ff_register_rdt_dynamic_payload_handlers();
@@ -300,7 +305,7 @@ void av_register_all(void)
     REGISTER_DEMUXER (STL,              stl);
     REGISTER_DEMUXER (SUBVIEWER1,       subviewer1);
     REGISTER_DEMUXER (SUBVIEWER,        subviewer);
-    REGISTER_DEMUXER (SUP,              sup);
+    REGISTER_MUXDEMUX(SUP,              sup);
     REGISTER_DEMUXER (SVAG,             svag);
     REGISTER_MUXDEMUX(SWF,              swf);
     REGISTER_DEMUXER (TAK,              tak);
@@ -368,18 +373,25 @@ void av_register_all(void)
     REGISTER_DEMUXER (IMAGE_PICTOR_PIPE,     image_pictor_pipe);
     REGISTER_DEMUXER (IMAGE_PNG_PIPE,        image_png_pipe);
     REGISTER_DEMUXER (IMAGE_PPM_PIPE,        image_ppm_pipe);
+    REGISTER_DEMUXER (IMAGE_PSD_PIPE,        image_psd_pipe);
     REGISTER_DEMUXER (IMAGE_QDRAW_PIPE,      image_qdraw_pipe);
     REGISTER_DEMUXER (IMAGE_SGI_PIPE,        image_sgi_pipe);
+    REGISTER_DEMUXER (IMAGE_SVG_PIPE,        image_svg_pipe);
     REGISTER_DEMUXER (IMAGE_SUNRAST_PIPE,    image_sunrast_pipe);
     REGISTER_DEMUXER (IMAGE_TIFF_PIPE,       image_tiff_pipe);
     REGISTER_DEMUXER (IMAGE_WEBP_PIPE,       image_webp_pipe);
+    REGISTER_DEMUXER (IMAGE_XPM_PIPE,        image_xpm_pipe);
 
     /* external libraries */
     REGISTER_MUXER   (CHROMAPRINT,      chromaprint);
     REGISTER_DEMUXER (LIBGME,           libgme);
     REGISTER_DEMUXER (LIBMODPLUG,       libmodplug);
-    REGISTER_MUXDEMUX(LIBNUT,           libnut);
     REGISTER_DEMUXER (LIBOPENMPT,       libopenmpt);
+}
+
+void av_register_all(void)
+{
+    static AVOnce control = AV_ONCE_INIT;
 
-    initialized = 1;
+    ff_thread_once(&control, register_all);
 }
diff --git a/mythtv/external/FFmpeg/libavformat/amr.c b/mythtv/external/FFmpeg/libavformat/amr.c
index 59963e14b89..b5194a2d9e3 100644
--- a/mythtv/external/FFmpeg/libavformat/amr.c
+++ b/mythtv/external/FFmpeg/libavformat/amr.c
@@ -118,7 +118,7 @@ static int amr_read_packet(AVFormatContext *s, AVPacket *pkt)
     AMRContext *amr = s->priv_data;
 
     if (avio_feof(s->pb)) {
-        return AVERROR(EIO);
+        return AVERROR_EOF;
     }
 
     // FIXME this is wrong, this should rather be in an AVParser
@@ -156,6 +156,8 @@ static int amr_read_packet(AVFormatContext *s, AVPacket *pkt)
 
     if (read != size - 1) {
         av_packet_unref(pkt);
+        if (read < 0)
+            return read;
         return AVERROR(EIO);
     }
 
diff --git a/mythtv/external/FFmpeg/libavformat/apc.c b/mythtv/external/FFmpeg/libavformat/apc.c
index a4dcf660e56..b180a50c9bd 100644
--- a/mythtv/external/FFmpeg/libavformat/apc.c
+++ b/mythtv/external/FFmpeg/libavformat/apc.c
@@ -65,7 +65,7 @@ static int apc_read_header(AVFormatContext *s)
     }
 
     st->codecpar->bits_per_coded_sample = 4;
-    st->codecpar->bit_rate = st->codecpar->bits_per_coded_sample * st->codecpar->channels
+    st->codecpar->bit_rate = (int64_t)st->codecpar->bits_per_coded_sample * st->codecpar->channels
                           * st->codecpar->sample_rate;
     st->codecpar->block_align = 1;
 
diff --git a/mythtv/external/FFmpeg/libavformat/ape.c b/mythtv/external/FFmpeg/libavformat/ape.c
index 061f32866f6..c06db784808 100644
--- a/mythtv/external/FFmpeg/libavformat/ape.c
+++ b/mythtv/external/FFmpeg/libavformat/ape.c
@@ -57,7 +57,6 @@ typedef struct APEContext {
     APEFrame *frames;
 
     /* Info from Descriptor Block */
-    char magic[4];
     int16_t fileversion;
     int16_t padding1;
     uint32_t descriptorlength;
@@ -102,7 +101,6 @@ static void ape_dumpinfo(AVFormatContext * s, APEContext * ape_ctx)
     int i;
 
     av_log(s, AV_LOG_DEBUG, "Descriptor Block:\n\n");
-    av_log(s, AV_LOG_DEBUG, "magic                = \"%c%c%c%c\"\n", ape_ctx->magic[0], ape_ctx->magic[1], ape_ctx->magic[2], ape_ctx->magic[3]);
     av_log(s, AV_LOG_DEBUG, "fileversion          = %"PRId16"\n", ape_ctx->fileversion);
     av_log(s, AV_LOG_DEBUG, "descriptorlength     = %"PRIu32"\n", ape_ctx->descriptorlength);
     av_log(s, AV_LOG_DEBUG, "headerlength         = %"PRIu32"\n", ape_ctx->headerlength);
@@ -374,7 +372,7 @@ static int ape_read_header(AVFormatContext * s)
     }
 
     /* try to read APE tags */
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         ff_ape_parse_tag(s);
         avio_seek(pb, 0, SEEK_SET);
     }
diff --git a/mythtv/external/FFmpeg/libavformat/apetag.c b/mythtv/external/FFmpeg/libavformat/apetag.c
index 08e80f4aa38..cdc602e1a9c 100644
--- a/mythtv/external/FFmpeg/libavformat/apetag.c
+++ b/mythtv/external/FFmpeg/libavformat/apetag.c
@@ -30,7 +30,7 @@
 #include "internal.h"
 
 #define APE_TAG_FLAG_CONTAINS_HEADER  (1 << 31)
-#define APE_TAG_FLAG_CONTAINS_FOOTER  (1 << 30)
+#define APE_TAG_FLAG_LACKS_FOOTER     (1 << 30)
 #define APE_TAG_FLAG_IS_HEADER        (1 << 29)
 #define APE_TAG_FLAG_IS_BINARY        (1 << 1)
 
@@ -150,7 +150,6 @@ int64_t ff_ape_parse_tag(AVFormatContext *s)
         av_log(s, AV_LOG_ERROR, "Invalid tag size %"PRIu32".\n", tag_bytes);
         return 0;
     }
-    tag_start = file_size - tag_bytes - APE_TAG_FOOTER_BYTES;
 
     fields = avio_rl32(pb);    /* number of fields */
     if (fields > 65536) {
@@ -166,6 +165,11 @@ int64_t ff_ape_parse_tag(AVFormatContext *s)
 
     avio_seek(pb, file_size - tag_bytes, SEEK_SET);
 
+    if (val & APE_TAG_FLAG_CONTAINS_HEADER)
+        tag_bytes += APE_TAG_HEADER_BYTES;
+
+    tag_start = file_size - tag_bytes;
+
     for (i=0; i<fields; i++)
         if (ape_tag_read_field(s) < 0) break;
 
@@ -188,11 +192,6 @@ int ff_ape_write_tag(AVFormatContext *s)
     if ((ret = avio_open_dyn_buf(&dyn_bc)) < 0)
         goto end;
 
-    // flags
-    avio_wl32(dyn_bc, APE_TAG_FLAG_CONTAINS_HEADER | APE_TAG_FLAG_CONTAINS_FOOTER |
-                     APE_TAG_FLAG_IS_HEADER);
-    ffio_fill(dyn_bc, 0, 8);             // reserved
-
     ff_standardize_creation_time(s);
     while ((e = av_dict_get(s->metadata, "", e, AV_DICT_IGNORE_SUFFIX))) {
         int val_len;
@@ -215,7 +214,7 @@ int ff_ape_write_tag(AVFormatContext *s)
     size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
     if (size <= 0)
         goto end;
-    size += 20;
+    size += APE_TAG_FOOTER_BYTES;
 
     // header
     avio_write(s->pb, "APETAGEX", 8);   // id
@@ -223,7 +222,11 @@ int ff_ape_write_tag(AVFormatContext *s)
     avio_wl32(s->pb, size);
     avio_wl32(s->pb, count);
 
-    avio_write(s->pb, dyn_buf, size - 20);
+    // flags
+    avio_wl32(s->pb, APE_TAG_FLAG_CONTAINS_HEADER | APE_TAG_FLAG_IS_HEADER);
+    ffio_fill(s->pb, 0, 8);             // reserved
+
+    avio_write(s->pb, dyn_buf, size - APE_TAG_FOOTER_BYTES);
 
     // footer
     avio_write(s->pb, "APETAGEX", 8);   // id
@@ -232,7 +235,7 @@ int ff_ape_write_tag(AVFormatContext *s)
     avio_wl32(s->pb, count);            // tag count
 
     // flags
-    avio_wl32(s->pb, APE_TAG_FLAG_CONTAINS_HEADER | APE_TAG_FLAG_CONTAINS_FOOTER);
+    avio_wl32(s->pb, APE_TAG_FLAG_CONTAINS_HEADER);
     ffio_fill(s->pb, 0, 8);             // reserved
 
 end:
diff --git a/mythtv/external/FFmpeg/libavformat/apetag.h b/mythtv/external/FFmpeg/libavformat/apetag.h
index cf2a5f8ab48..49cd10eb01d 100644
--- a/mythtv/external/FFmpeg/libavformat/apetag.h
+++ b/mythtv/external/FFmpeg/libavformat/apetag.h
@@ -28,6 +28,7 @@
 #define APE_TAG_PREAMBLE        "APETAGEX"
 #define APE_TAG_VERSION         2000
 #define APE_TAG_FOOTER_BYTES    32
+#define APE_TAG_HEADER_BYTES    32
 
 /**
  * Read and parse an APE tag
diff --git a/mythtv/external/FFmpeg/libavformat/apngdec.c b/mythtv/external/FFmpeg/libavformat/apngdec.c
index bb17896ee50..ffff03710a0 100644
--- a/mythtv/external/FFmpeg/libavformat/apngdec.c
+++ b/mythtv/external/FFmpeg/libavformat/apngdec.c
@@ -269,7 +269,7 @@ static int decode_fctl_chunk(AVFormatContext *s, APNGDemuxContext *ctx, AVPacket
     /* default is hundredths of seconds */
     if (!delay_den)
         delay_den = 100;
-    if (!delay_num || delay_den / delay_num > ctx->max_fps) {
+    if (!delay_num || (ctx->max_fps && delay_den / delay_num > ctx->max_fps)) {
         delay_num = 1;
         delay_den = ctx->default_fps;
     }
@@ -404,13 +404,9 @@ static int apng_read_packet(AVFormatContext *s, AVPacket *pkt)
             return ret;
         return 0;
     default:
-        {
-        char tag_buf[32];
-
-        av_get_codec_tag_string(tag_buf, sizeof(tag_buf), tag);
-        avpriv_request_sample(s, "In-stream tag=%s (0x%08X) len=%"PRIu32, tag_buf, tag, len);
+        avpriv_request_sample(s, "In-stream tag=%s (0x%08"PRIX32") len=%"PRIu32,
+                              av_fourcc2str(tag), tag, len);
         avio_skip(pb, len + 4);
-        }
     }
 
     /* Handle the unsupported yet cases */
@@ -421,7 +417,7 @@ static const AVOption options[] = {
     { "ignore_loop", "ignore loop setting"                         , offsetof(APNGDemuxContext, ignore_loop),
       AV_OPT_TYPE_BOOL, { .i64 = 1 }              , 0, 1      , AV_OPT_FLAG_DECODING_PARAM },
     { "max_fps"    , "maximum framerate (0 is no limit)"           , offsetof(APNGDemuxContext, max_fps),
-      AV_OPT_TYPE_INT, { .i64 = DEFAULT_APNG_FPS }, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
+      AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
     { "default_fps", "default framerate (0 is as fast as possible)", offsetof(APNGDemuxContext, default_fps),
       AV_OPT_TYPE_INT, { .i64 = DEFAULT_APNG_FPS }, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
     { NULL },
diff --git a/mythtv/external/FFmpeg/libavformat/apngenc.c b/mythtv/external/FFmpeg/libavformat/apngenc.c
index e25df2eb5e5..77c1c916c2e 100644
--- a/mythtv/external/FFmpeg/libavformat/apngenc.c
+++ b/mythtv/external/FFmpeg/libavformat/apngenc.c
@@ -44,6 +44,9 @@ typedef struct APNGMuxContext {
     AVRational prev_delay;
 
     int framerate_warned;
+
+    uint8_t *extra_data;
+    int extra_data_size;
 } APNGMuxContext;
 
 static uint8_t *apng_find_chunk(uint32_t tag, uint8_t *buf, size_t length)
@@ -78,6 +81,7 @@ static void apng_write_chunk(AVIOContext *io_context, uint32_t tag,
 static int apng_write_header(AVFormatContext *format_context)
 {
     APNGMuxContext *apng = format_context->priv_data;
+    AVCodecParameters *par = format_context->streams[0]->codecpar;
 
     if (format_context->nb_streams != 1 ||
         format_context->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO ||
@@ -98,18 +102,38 @@ static int apng_write_header(AVFormatContext *format_context)
     avio_wb64(format_context->pb, PNGSIG);
     // Remaining headers are written when they are copied from the encoder
 
+    if (par->extradata_size) {
+        apng->extra_data = av_mallocz(par->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+        if (!apng->extra_data)
+            return AVERROR(ENOMEM);
+        apng->extra_data_size = par->extradata_size;
+        memcpy(apng->extra_data, par->extradata, par->extradata_size);
+    }
+
     return 0;
 }
 
-static void flush_packet(AVFormatContext *format_context, AVPacket *packet)
+static int flush_packet(AVFormatContext *format_context, AVPacket *packet)
 {
     APNGMuxContext *apng = format_context->priv_data;
     AVIOContext *io_context = format_context->pb;
     AVStream *codec_stream = format_context->streams[0];
-    AVCodecParameters *codec_par = codec_stream->codecpar;
+    uint8_t *side_data = NULL;
+    int side_data_size = 0;
 
     av_assert0(apng->prev_packet);
 
+    side_data = av_packet_get_side_data(apng->prev_packet, AV_PKT_DATA_NEW_EXTRADATA, &side_data_size);
+
+    if (side_data_size) {
+        av_freep(&apng->extra_data);
+        apng->extra_data = av_mallocz(side_data_size + AV_INPUT_BUFFER_PADDING_SIZE);
+        if (!apng->extra_data)
+            return AVERROR(ENOMEM);
+        apng->extra_data_size = side_data_size;
+        memcpy(apng->extra_data, side_data, apng->extra_data_size);
+    }
+
     if (apng->frame_number == 0 && !packet) {
         uint8_t *existing_acTL_chunk;
         uint8_t *existing_fcTL_chunk;
@@ -117,13 +141,13 @@ static void flush_packet(AVFormatContext *format_context, AVPacket *packet)
         av_log(format_context, AV_LOG_INFO, "Only a single frame so saving as a normal PNG.\n");
 
         // Write normal PNG headers without acTL chunk
-        existing_acTL_chunk = apng_find_chunk(MKBETAG('a', 'c', 'T', 'L'), codec_par->extradata, codec_par->extradata_size);
+        existing_acTL_chunk = apng_find_chunk(MKBETAG('a', 'c', 'T', 'L'), apng->extra_data, apng->extra_data_size);
         if (existing_acTL_chunk) {
             uint8_t *chunk_after_acTL = existing_acTL_chunk + AV_RB32(existing_acTL_chunk) + 12;
-            avio_write(io_context, codec_par->extradata, existing_acTL_chunk - codec_par->extradata);
-            avio_write(io_context, chunk_after_acTL, codec_par->extradata + codec_par->extradata_size - chunk_after_acTL);
+            avio_write(io_context, apng->extra_data, existing_acTL_chunk - apng->extra_data);
+            avio_write(io_context, chunk_after_acTL, apng->extra_data + apng->extra_data_size - chunk_after_acTL);
         } else {
-            avio_write(io_context, codec_par->extradata, codec_par->extradata_size);
+            avio_write(io_context, apng->extra_data, apng->extra_data_size);
         }
 
         // Write frame data without fcTL chunk
@@ -142,9 +166,9 @@ static void flush_packet(AVFormatContext *format_context, AVPacket *packet)
             uint8_t *existing_acTL_chunk;
 
             // Write normal PNG headers
-            avio_write(io_context, codec_par->extradata, codec_par->extradata_size);
+            avio_write(io_context, apng->extra_data, apng->extra_data_size);
 
-            existing_acTL_chunk = apng_find_chunk(MKBETAG('a', 'c', 'T', 'L'), codec_par->extradata, codec_par->extradata_size);
+            existing_acTL_chunk = apng_find_chunk(MKBETAG('a', 'c', 'T', 'L'), apng->extra_data, apng->extra_data_size);
             if (!existing_acTL_chunk) {
                 uint8_t buf[8];
                 // Write animation control header
@@ -194,21 +218,25 @@ static void flush_packet(AVFormatContext *format_context, AVPacket *packet)
 
     av_packet_unref(apng->prev_packet);
     if (packet)
-        av_copy_packet(apng->prev_packet, packet);
+        av_packet_ref(apng->prev_packet, packet);
+    return 0;
 }
 
 static int apng_write_packet(AVFormatContext *format_context, AVPacket *packet)
 {
     APNGMuxContext *apng = format_context->priv_data;
+    int ret;
 
     if (!apng->prev_packet) {
-        apng->prev_packet = av_malloc(sizeof(*apng->prev_packet));
+        apng->prev_packet = av_packet_alloc();
         if (!apng->prev_packet)
             return AVERROR(ENOMEM);
 
-        av_copy_packet(apng->prev_packet, packet);
+        av_packet_ref(apng->prev_packet, packet);
     } else {
-        flush_packet(format_context, packet);
+        ret = flush_packet(format_context, packet);
+        if (ret < 0)
+            return ret;
     }
 
     return 0;
@@ -219,15 +247,18 @@ static int apng_write_trailer(AVFormatContext *format_context)
     APNGMuxContext *apng = format_context->priv_data;
     AVIOContext *io_context = format_context->pb;
     uint8_t buf[8];
+    int ret;
 
     if (apng->prev_packet) {
-        flush_packet(format_context, NULL);
+        ret = flush_packet(format_context, NULL);
         av_freep(&apng->prev_packet);
+        if (ret < 0)
+            return ret;
     }
 
     apng_write_chunk(io_context, MKBETAG('I', 'E', 'N', 'D'), NULL, 0);
 
-    if (apng->acTL_offset && io_context->seekable) {
+    if (apng->acTL_offset && (io_context->seekable & AVIO_SEEKABLE_NORMAL)) {
         avio_seek(io_context, apng->acTL_offset, SEEK_SET);
 
         AV_WB32(buf, apng->frame_number);
@@ -235,6 +266,9 @@ static int apng_write_trailer(AVFormatContext *format_context)
         apng_write_chunk(io_context, MKBETAG('a', 'c', 'T', 'L'), buf, 8);
     }
 
+    av_freep(&apng->extra_data);
+    apng->extra_data = 0;
+
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavformat/asfdec_f.c b/mythtv/external/FFmpeg/libavformat/asfdec_f.c
index b973eff96e4..64a0b9d7f2a 100644
--- a/mythtv/external/FFmpeg/libavformat/asfdec_f.c
+++ b/mythtv/external/FFmpeg/libavformat/asfdec_f.c
@@ -307,8 +307,10 @@ static void get_id3_tag(AVFormatContext *s, int len)
     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
 
     ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, len);
-    if (id3v2_extra_meta)
+    if (id3v2_extra_meta) {
         ff_id3v2_parse_apic(s, &id3v2_extra_meta);
+        ff_id3v2_parse_chapters(s, &id3v2_extra_meta);
+    }
     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
 }
 
@@ -749,13 +751,15 @@ static int asf_read_marker(AVFormatContext *s, int64_t size)
     count = avio_rl32(pb);    // markers count
     avio_rl16(pb);            // reserved 2 bytes
     name_len = avio_rl16(pb); // name length
-    for (i = 0; i < name_len; i++)
-        avio_r8(pb); // skip the name
+    avio_skip(pb, name_len);
 
     for (i = 0; i < count; i++) {
         int64_t pres_time;
         int name_len;
 
+        if (avio_feof(pb))
+            return AVERROR_INVALIDDATA;
+
         avio_rl64(pb);             // offset, 8 bytes
         pres_time = avio_rl64(pb); // presentation time
         pres_time -= asf->hdr.preroll * 10000;
@@ -1010,7 +1014,7 @@ static int asf_get_packet(AVFormatContext *s, AVIOContext *pb)
             }
 
             if (c != 0x82)
-                avpriv_request_sample(s, "Invalid ECC byte\n");
+                avpriv_request_sample(s, "Invalid ECC byte");
 
             if (!asf->uses_std_ecc)
                 asf->uses_std_ecc =  (c == 0x82 && !d && !e) ? 1 : -1;
@@ -1608,6 +1612,11 @@ static int asf_build_simple_index(AVFormatContext *s, int stream_index)
             int64_t pos       = s->internal->data_offset + s->packet_size * (int64_t)pktnum;
             int64_t index_pts = FFMAX(av_rescale(itime, i, 10000) - asf->hdr.preroll, 0);
 
+            if (avio_feof(s->pb)) {
+                ret = AVERROR_INVALIDDATA;
+                goto end;
+            }
+
             if (pos != last_pos) {
                 av_log(s, AV_LOG_DEBUG, "pktnum:%d, pktct:%d  pts: %"PRId64"\n",
                        pktnum, pktct, index_pts);
diff --git a/mythtv/external/FFmpeg/libavformat/asfdec_o.c b/mythtv/external/FFmpeg/libavformat/asfdec_o.c
index 56f8446b5ff..5122e33c787 100644
--- a/mythtv/external/FFmpeg/libavformat/asfdec_o.c
+++ b/mythtv/external/FFmpeg/libavformat/asfdec_o.c
@@ -460,8 +460,10 @@ static void get_id3_tag(AVFormatContext *s, int len)
     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
 
     ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, len);
-    if (id3v2_extra_meta)
+    if (id3v2_extra_meta) {
         ff_id3v2_parse_apic(s, &id3v2_extra_meta);
+        ff_id3v2_parse_chapters(s, &id3v2_extra_meta);
+    }
     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
 }
 
@@ -691,20 +693,22 @@ static int asf_read_properties(AVFormatContext *s, const GUIDParseTable *g)
 
 static int parse_video_info(AVIOContext *pb, AVStream *st)
 {
-    uint16_t size;
+    uint16_t size_asf; // ASF-specific Format Data size
+    uint32_t size_bmp; // BMP_HEADER-specific Format Data size
     unsigned int tag;
 
     st->codecpar->width  = avio_rl32(pb);
     st->codecpar->height = avio_rl32(pb);
     avio_skip(pb, 1); // skip reserved flags
-    size = avio_rl16(pb); // size of the Format Data
-    tag  = ff_get_bmp_header(pb, st, NULL);
+    size_asf = avio_rl16(pb);
+    tag = ff_get_bmp_header(pb, st, &size_bmp);
     st->codecpar->codec_tag = tag;
     st->codecpar->codec_id  = ff_codec_get_id(ff_codec_bmp_tags, tag);
+    size_bmp = FFMAX(size_asf, size_bmp);
 
-    if (size > BMP_HEADER_SIZE) {
+    if (size_bmp > BMP_HEADER_SIZE) {
         int ret;
-        st->codecpar->extradata_size  = size - BMP_HEADER_SIZE;
+        st->codecpar->extradata_size  = size_bmp - BMP_HEADER_SIZE;
         if (!(st->codecpar->extradata = av_malloc(st->codecpar->extradata_size +
                                                AV_INPUT_BUFFER_PADDING_SIZE))) {
             st->codecpar->extradata_size = 0;
@@ -960,7 +964,7 @@ static int asf_read_data(AVFormatContext *s, const GUIDParseTable *g)
                size, asf->nb_packets);
     avio_skip(pb, 2); // skip reserved field
     asf->first_packet_offset = avio_tell(pb);
-    if (pb->seekable && !(asf->b_flags & ASF_FLAG_BROADCAST))
+    if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !(asf->b_flags & ASF_FLAG_BROADCAST))
         align_position(pb, asf->offset, asf->data_size);
 
     return 0;
@@ -974,7 +978,8 @@ static int asf_read_simple_index(AVFormatContext *s, const GUIDParseTable *g)
     uint64_t interval; // index entry time interval in 100 ns units, usually it's 1s
     uint32_t pkt_num, nb_entries;
     int32_t prev_pkt_num = -1;
-    int i, ret;
+    int i;
+    int64_t offset;
     uint64_t size = avio_rl64(pb);
 
     // simple index objects should be ordered by stream number, this loop tries to find
@@ -996,10 +1001,10 @@ static int asf_read_simple_index(AVFormatContext *s, const GUIDParseTable *g)
     nb_entries = avio_rl32(pb);
     for (i = 0; i < nb_entries; i++) {
         pkt_num = avio_rl32(pb);
-        ret = avio_skip(pb, 2);
-        if (ret < 0) {
+        offset = avio_skip(pb, 2);
+        if (offset < 0) {
             av_log(s, AV_LOG_ERROR, "Skipping failed in asf_read_simple_index.\n");
-            return ret;
+            return offset;
         }
         if (prev_pkt_num != pkt_num) {
             av_add_index_entry(st, asf->first_packet_offset + asf->packet_size *
@@ -1485,7 +1490,7 @@ static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
             asf->return_subpayload = 0;
             return 0;
         }
-        for (i = 0; i < s->nb_streams; i++) {
+        for (i = 0; i < asf->nb_streams; i++) {
             ASFPacket *asf_pkt = &asf->asf_st[i]->pkt;
             if (asf_pkt && !asf_pkt->size_left && asf_pkt->data_size) {
                 if (asf->asf_st[i]->span > 1 &&
@@ -1738,7 +1743,9 @@ static int asf_read_header(AVFormatContext *s)
             size = avio_rl64(pb);
             align_position(pb, asf->offset, size);
         }
-        if (asf->data_reached && (!pb->seekable || (asf->b_flags & ASF_FLAG_BROADCAST)))
+        if (asf->data_reached &&
+            (!(pb->seekable & AVIO_SEEKABLE_NORMAL) ||
+             (asf->b_flags & ASF_FLAG_BROADCAST)))
             break;
     }
 
@@ -1747,7 +1754,7 @@ static int asf_read_header(AVFormatContext *s)
         ret = AVERROR_INVALIDDATA;
         goto failed;
     }
-    if (pb->seekable)
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL)
         avio_seek(pb, asf->first_packet_offset, SEEK_SET);
 
     for (i = 0; i < asf->nb_streams; i++) {
diff --git a/mythtv/external/FFmpeg/libavformat/asfenc.c b/mythtv/external/FFmpeg/libavformat/asfenc.c
index 19dee3d5285..3cfe75a5d5e 100644
--- a/mythtv/external/FFmpeg/libavformat/asfenc.c
+++ b/mythtv/external/FFmpeg/libavformat/asfenc.c
@@ -473,7 +473,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
     avio_wl64(pb, duration); /* end time stamp (in 100ns units) */
     avio_wl64(pb, asf->duration); /* duration (in 100ns units) */
     avio_wl64(pb, PREROLL_TIME); /* start time stamp */
-    avio_wl32(pb, (asf->is_streamed || !pb->seekable) ? 3 : 2);  /* ??? */
+    avio_wl32(pb, (asf->is_streamed || !(pb->seekable & AVIO_SEEKABLE_NORMAL)) ? 3 : 2);  /* ??? */
     avio_wl32(pb, s->packet_size); /* packet size */
     avio_wl32(pb, s->packet_size); /* packet size */
     avio_wl32(pb, bit_rate ? bit_rate : -1); /* Maximum data rate in bps */
@@ -530,7 +530,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
             avio_wl32(pb, 5000); /* maximum buffer size ms */
             avio_wl32(pb, 0); /* max initial buffer fullness */
             avio_wl32(pb, 0); /* max object size */
-            avio_wl32(pb, (!asf->is_streamed && pb->seekable) << 1); /* flags - seekable */
+            avio_wl32(pb, (!asf->is_streamed && (pb->seekable & AVIO_SEEKABLE_NORMAL)) << 1); /* flags - seekable */
             avio_wl16(pb, n + 1); /* stream number */
             avio_wl16(pb, asf->streams[n].stream_language_index); /* language id index */
             avio_wl64(pb, 0); /* avg time per frame */
@@ -683,7 +683,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size,
             avio_wl16(pb, 40 + par->extradata_size); /* size */
 
             /* BITMAPINFOHEADER header */
-            ff_put_bmp_header(pb, par, ff_codec_bmp_tags, 1, 0);
+            ff_put_bmp_header(pb, par, 1, 0);
         }
         end_header(pb, hpos);
     }
@@ -1135,7 +1135,7 @@ static int asf_write_trailer(AVFormatContext *s)
     }
     avio_flush(s->pb);
 
-    if (asf->is_streamed || !s->pb->seekable) {
+    if (asf->is_streamed || !(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
         put_chunk(s, 0x4524, 0, 0); /* end of stream */
     } else {
         /* rewrite an updated header */
diff --git a/mythtv/external/FFmpeg/libavformat/astdec.c b/mythtv/external/FFmpeg/libavformat/astdec.c
index 7a53d0bb708..4ba08c21807 100644
--- a/mythtv/external/FFmpeg/libavformat/astdec.c
+++ b/mythtv/external/FFmpeg/libavformat/astdec.c
@@ -102,7 +102,7 @@ static int ast_read_packet(AVFormatContext *s, AVPacket *pkt)
         pkt->stream_index = 0;
         pkt->pos = pos;
     } else {
-        av_log(s, AV_LOG_ERROR, "unknown chunk %x\n", type);
+        av_log(s, AV_LOG_ERROR, "unknown chunk %"PRIx32"\n", type);
         avio_skip(s->pb, size);
         ret = AVERROR_INVALIDDATA;
     }
diff --git a/mythtv/external/FFmpeg/libavformat/astenc.c b/mythtv/external/FFmpeg/libavformat/astenc.c
index 11f8717495d..578e658891e 100644
--- a/mythtv/external/FFmpeg/libavformat/astenc.c
+++ b/mythtv/external/FFmpeg/libavformat/astenc.c
@@ -139,7 +139,7 @@ static int ast_write_trailer(AVFormatContext *s)
 
     av_log(s, AV_LOG_DEBUG, "total samples: %"PRId64"\n", samples);
 
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         /* Number of samples */
         avio_seek(pb, ast->samples, SEEK_SET);
         avio_wb32(pb, samples);
diff --git a/mythtv/external/FFmpeg/libavformat/au.c b/mythtv/external/FFmpeg/libavformat/au.c
index f70f8272012..520824fc123 100644
--- a/mythtv/external/FFmpeg/libavformat/au.c
+++ b/mythtv/external/FFmpeg/libavformat/au.c
@@ -321,7 +321,7 @@ static int au_write_trailer(AVFormatContext *s)
     AUContext *au = s->priv_data;
     int64_t file_size = avio_tell(pb);
 
-    if (s->pb->seekable && file_size < INT32_MAX) {
+    if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && file_size < INT32_MAX) {
         /* update file size */
         avio_seek(pb, 8, SEEK_SET);
         avio_wb32(pb, (uint32_t)(file_size - au->header_size));
diff --git a/mythtv/external/FFmpeg/libavformat/avformat.h b/mythtv/external/FFmpeg/libavformat/avformat.h
index 6b375604a1b..ee12d3136db 100644
--- a/mythtv/external/FFmpeg/libavformat/avformat.h
+++ b/mythtv/external/FFmpeg/libavformat/avformat.h
@@ -930,6 +930,9 @@ typedef struct AVStream {
      * Decoding: duration of the stream, in stream time base.
      * If a source file does not specify a duration, but does specify
      * a bitrate, this value will be estimated from bitrate and file size.
+     *
+     * Encoding: May be set by the caller before avformat_write_header() to
+     * provide a hint to the muxer about the estimated duration.
      */
     int64_t duration;
 
@@ -1002,12 +1005,14 @@ typedef struct AVStream {
      * All fields below this line are not part of the public API. They
      * may not be used outside of libavformat and can be changed and
      * removed at will.
-     * New public fields should be added right above.
+     * Internal note: be aware that physically removing these fields
+     * will break ABI. Replace removed fields with dummy fields, and
+     * add new fields to AVStreamInternal.
      *****************************************************************
      */
 
     /**
-     * Stream information used internally by av_find_stream_info()
+     * Stream information used internally by avformat_find_stream_info()
      */
 #define MAX_STD_TIMEBASES (30*12+30+3+6)
     struct {
@@ -1059,7 +1064,7 @@ typedef struct AVStream {
     int probe_packets;
 
     /**
-     * Number of frames that have been demuxed during av_find_stream_info()
+     * Number of frames that have been demuxed during avformat_find_stream_info()
      */
     int codec_info_nb_frames;
 
@@ -1206,6 +1211,12 @@ typedef struct AVStream {
      */
     int inject_global_side_data;
 
+    /*****************************************************************
+     * All fields above this line are not part of the public API.
+     * Fields below are part of the public API and ABI again.
+     *****************************************************************
+     */
+
     /**
      * String containing paris of key and values describing recommended encoder configuration.
      * Paris are separated by ','.
@@ -1475,7 +1486,9 @@ typedef struct AVFormatContext {
 #define AVFMT_FLAG_MP4A_LATM    0x8000 ///< Enable RTP MP4A-LATM payload
 #define AVFMT_FLAG_SORT_DTS    0x10000 ///< try to interleave outputted packets by dts (using this flag can slow demuxing down)
 #define AVFMT_FLAG_PRIV_OPT    0x20000 ///< Enable use of private options by delaying codec open (this could be made default once all code is converted)
-#define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000 ///< Don't merge side data but keep it separate.
+#if FF_API_LAVF_KEEPSIDE_FLAG
+#define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000 ///< Don't merge side data but keep it separate. Deprecated, will be the default.
+#endif
 #define AVFMT_FLAG_FAST_SEEK   0x80000 ///< Enable fast, but inaccurate seeks for some formats
 #define AVFMT_FLAG_SHORTEST   0x100000 ///< Stop muxing when the shortest stream stops.
 #define AVFMT_FLAG_AUTO_BSF   0x200000 ///< Wait for packet data before writing a header, and add bitstream filters as requested by the muxer
@@ -1664,7 +1677,7 @@ typedef struct AVFormatContext {
     /**
      * Audio preload in microseconds.
      * Note, not all formats support this and unpredictable things may happen if it is used when not supported.
-     * - encoding: Set by user via AVOptions (NO direct access)
+     * - encoding: Set by user
      * - decoding: unused
      */
     int audio_preload;
@@ -1672,7 +1685,7 @@ typedef struct AVFormatContext {
     /**
      * Max chunk time in microseconds.
      * Note, not all formats support this and unpredictable things may happen if it is used when not supported.
-     * - encoding: Set by user via AVOptions (NO direct access)
+     * - encoding: Set by user
      * - decoding: unused
      */
     int max_chunk_duration;
@@ -1680,7 +1693,7 @@ typedef struct AVFormatContext {
     /**
      * Max chunk size in bytes
      * Note, not all formats support this and unpredictable things may happen if it is used when not supported.
-     * - encoding: Set by user via AVOptions (NO direct access)
+     * - encoding: Set by user
      * - decoding: unused
      */
     int max_chunk_size;
@@ -1689,14 +1702,14 @@ typedef struct AVFormatContext {
      * forces the use of wallclock timestamps as pts/dts of packets
      * This has undefined results in the presence of B frames.
      * - encoding: unused
-     * - decoding: Set by user via AVOptions (NO direct access)
+     * - decoding: Set by user
      */
     int use_wallclock_as_timestamps;
 
     /**
      * avio flags, used to force AVIO_FLAG_DIRECT.
      * - encoding: unused
-     * - decoding: Set by user via AVOptions (NO direct access)
+     * - decoding: Set by user
      */
     int avio_flags;
 
@@ -1704,34 +1717,34 @@ typedef struct AVFormatContext {
      * The duration field can be estimated through various ways, and this field can be used
      * to know how the duration was estimated.
      * - encoding: unused
-     * - decoding: Read by user via AVOptions (NO direct access)
+     * - decoding: Read by user
      */
     enum AVDurationEstimationMethod duration_estimation_method;
 
     /**
      * Skip initial bytes when opening stream
      * - encoding: unused
-     * - decoding: Set by user via AVOptions (NO direct access)
+     * - decoding: Set by user
      */
     int64_t skip_initial_bytes;
 
     /**
      * Correct single timestamp overflows
      * - encoding: unused
-     * - decoding: Set by user via AVOptions (NO direct access)
+     * - decoding: Set by user
      */
     unsigned int correct_ts_overflow;
 
     /**
      * Force seeking to any (also non key) frames.
      * - encoding: unused
-     * - decoding: Set by user via AVOptions (NO direct access)
+     * - decoding: Set by user
      */
     int seek2any;
 
     /**
      * Flush the I/O context after each packet.
-     * - encoding: Set by user via AVOptions (NO direct access)
+     * - encoding: Set by user
      * - decoding: unused
      */
     int flush_packets;
@@ -1741,14 +1754,14 @@ typedef struct AVFormatContext {
      * The maximal score is AVPROBE_SCORE_MAX, its set when the demuxer probes
      * the format.
      * - encoding: unused
-     * - decoding: set by avformat, read by user via av_format_get_probe_score() (NO direct access)
+     * - decoding: set by avformat, read by user
      */
     int probe_score;
 
     /**
      * number of bytes to read maximally to identify format.
      * - encoding: unused
-     * - decoding: set by user through AVOPtions (NO direct access)
+     * - decoding: set by user
      */
     int format_probesize;
 
@@ -1756,7 +1769,7 @@ typedef struct AVFormatContext {
      * ',' separated list of allowed decoders.
      * If NULL then all are allowed
      * - encoding: unused
-     * - decoding: set by user through AVOptions (NO direct access)
+     * - decoding: set by user
      */
     char *codec_whitelist;
 
@@ -1764,7 +1777,7 @@ typedef struct AVFormatContext {
      * ',' separated list of allowed demuxers.
      * If NULL then all are allowed
      * - encoding: unused
-     * - decoding: set by user through AVOptions (NO direct access)
+     * - decoding: set by user
      */
     char *format_whitelist;
 
@@ -1786,7 +1799,7 @@ typedef struct AVFormatContext {
      * Forced video codec.
      * This allows forcing a specific decoder, even when there are multiple with
      * the same codec_id.
-     * Demuxing: Set by user via av_format_set_video_codec (NO direct access).
+     * Demuxing: Set by user
      */
     AVCodec *video_codec;
 
@@ -1794,7 +1807,7 @@ typedef struct AVFormatContext {
      * Forced audio codec.
      * This allows forcing a specific decoder, even when there are multiple with
      * the same codec_id.
-     * Demuxing: Set by user via av_format_set_audio_codec (NO direct access).
+     * Demuxing: Set by user
      */
     AVCodec *audio_codec;
 
@@ -1802,7 +1815,7 @@ typedef struct AVFormatContext {
      * Forced subtitle codec.
      * This allows forcing a specific decoder, even when there are multiple with
      * the same codec_id.
-     * Demuxing: Set by user via av_format_set_subtitle_codec (NO direct access).
+     * Demuxing: Set by user
      */
     AVCodec *subtitle_codec;
 
@@ -1810,7 +1823,7 @@ typedef struct AVFormatContext {
      * Forced data codec.
      * This allows forcing a specific decoder, even when there are multiple with
      * the same codec_id.
-     * Demuxing: Set by user via av_format_set_data_codec (NO direct access).
+     * Demuxing: Set by user
      */
     AVCodec *data_codec;
 
@@ -1834,15 +1847,13 @@ typedef struct AVFormatContext {
 
     /**
      * Output timestamp offset, in microseconds.
-     * Muxing: set by user via AVOptions (NO direct access)
+     * Muxing: set by user
      */
     int64_t output_ts_offset;
 
     /**
      * dump format separator.
      * can be ", " or "\n      " or anything else
-     * Code outside libavformat should access this field using AVOptions
-     * (NO direct access).
      * - muxing: Set by user.
      * - demuxing: Set by user.
      */
@@ -1879,7 +1890,7 @@ typedef struct AVFormatContext {
     /**
      * ',' separated list of allowed protocols.
      * - encoding: unused
-     * - decoding: set by user through AVOptions (NO direct access)
+     * - decoding: set by user
      */
     char *protocol_whitelist;
 
@@ -1914,11 +1925,22 @@ typedef struct AVFormatContext {
     /**
      * ',' separated list of disallowed protocols.
      * - encoding: unused
-     * - decoding: set by user through AVOptions (NO direct access)
+     * - decoding: set by user
      */
     char *protocol_blacklist;
+
+    /**
+     * The maximum number of streams.
+     * - encoding: unused
+     * - decoding: set by user
+     */
+    int max_streams;
 } AVFormatContext;
 
+/**
+ * Accessors for some AVFormatContext fields. These used to be provided for ABI
+ * compatibility, and do not need to be used anymore.
+ */
 int av_format_get_probe_score(const AVFormatContext *s);
 AVCodec * av_format_get_video_codec(const AVFormatContext *s);
 void      av_format_set_video_codec(AVFormatContext *s, AVCodec *c);
@@ -2066,6 +2088,21 @@ const AVClass *avformat_get_class(void);
  */
 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c);
 
+/**
+ * Wrap an existing array as stream side data.
+ *
+ * @param st stream
+ * @param type side information type
+ * @param data the side data array. It must be allocated with the av_malloc()
+ *             family of functions. The ownership of the data is transferred to
+ *             st.
+ * @param size side information size
+ * @return zero on success, a negative AVERROR code on failure. On failure,
+ *         the stream is unchanged and the data remains owned by the caller.
+ */
+int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
+                            uint8_t *data, size_t size);
+
 /**
  * Allocate new information from stream.
  *
@@ -2935,6 +2972,7 @@ int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
 
 int avformat_queue_attached_pictures(AVFormatContext *s);
 
+#if FF_API_OLD_BSF
 /**
  * Apply a list of bitstream filters to a packet.
  *
@@ -2946,7 +2984,6 @@ int avformat_queue_attached_pictures(AVFormatContext *s);
  * @return  >=0 on success;
  *          AVERROR code on failure
  */
-#if FF_API_OLD_BSF
 attribute_deprecated
 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
                                AVBitStreamFilterContext *bsfc);
diff --git a/mythtv/external/FFmpeg/libavformat/avi.h b/mythtv/external/FFmpeg/libavformat/avi.h
index af21f2c3c35..b1711f0c179 100644
--- a/mythtv/external/FFmpeg/libavformat/avi.h
+++ b/mythtv/external/FFmpeg/libavformat/avi.h
@@ -29,7 +29,6 @@
 #define AVIF_COPYRIGHTED        0x00020000
 
 #define AVI_MAX_RIFF_SIZE       0x40000000LL
-#define AVI_MASTER_INDEX_SIZE   256
 #define AVI_MAX_STREAM_COUNT    100
 
 /* stream header flags */
diff --git a/mythtv/external/FFmpeg/libavformat/avidec.c b/mythtv/external/FFmpeg/libavformat/avidec.c
index e5a292ee428..b8a31dcff28 100644
--- a/mythtv/external/FFmpeg/libavformat/avidec.c
+++ b/mythtv/external/FFmpeg/libavformat/avidec.c
@@ -117,13 +117,9 @@ static const AVMetadataConv avi_metadata_conv[] = {
 static int avi_load_index(AVFormatContext *s);
 static int guess_ni_flag(AVFormatContext *s);
 
-#define print_tag(str, tag, size)                        \
-    av_log(NULL, AV_LOG_TRACE, "pos:%"PRIX64" %s: tag=%c%c%c%c size=0x%x\n", \
-            avio_tell(pb), str, tag & 0xff,              \
-            (tag >> 8) & 0xff,                           \
-            (tag >> 16) & 0xff,                          \
-            (tag >> 24) & 0xff,                          \
-            size)
+#define print_tag(str, tag, size)                                      \
+    av_log(NULL, AV_LOG_TRACE, "pos:%"PRIX64" %s: tag=%s size=0x%x\n", \
+           avio_tell(pb), str, av_fourcc2str(tag), size)                  \
 
 static inline int get_duration(AVIStream *ast, int len)
 {
@@ -160,11 +156,11 @@ static int get_riff(AVFormatContext *s, AVIOContext *pb)
     return 0;
 }
 
-static int read_braindead_odml_indx(AVFormatContext *s, int frame_num)
+static int read_odml_index(AVFormatContext *s, int frame_num)
 {
     AVIContext *avi     = s->priv_data;
     AVIOContext *pb     = s->pb;
-    int longs_pre_entry = avio_rl16(pb);
+    int longs_per_entry = avio_rl16(pb);
     int index_sub_type  = avio_r8(pb);
     int index_type      = avio_r8(pb);
     int entries_in_use  = avio_rl32(pb);
@@ -179,9 +175,9 @@ static int read_braindead_odml_indx(AVFormatContext *s, int frame_num)
     int64_t filesize = avi->fsize;
 
     av_log(s, AV_LOG_TRACE,
-            "longs_pre_entry:%d index_type:%d entries_in_use:%d "
+            "longs_per_entry:%d index_type:%d entries_in_use:%d "
             "chunk_id:%X base:%16"PRIX64" frame_num:%d\n",
-            longs_pre_entry,
+            longs_per_entry,
             index_type,
             entries_in_use,
             chunk_id,
@@ -198,7 +194,7 @@ static int read_braindead_odml_indx(AVFormatContext *s, int frame_num)
 
     avio_rl32(pb);
 
-    if (index_type && longs_pre_entry != 2)
+    if (index_type && longs_per_entry != 2)
         return AVERROR_INVALIDDATA;
     if (index_type > 1)
         return AVERROR_INVALIDDATA;
@@ -253,7 +249,7 @@ static int read_braindead_odml_indx(AVFormatContext *s, int frame_num)
             if (avio_seek(pb, offset + 8, SEEK_SET) < 0)
                 return -1;
             avi->odml_depth++;
-            read_braindead_odml_indx(s, frame_num);
+            read_odml_index(s, frame_num);
             avi->odml_depth--;
             frame_num += duration;
 
@@ -731,7 +727,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
             break;
         case MKTAG('s', 't', 'r', 'f'):
             /* stream header */
-            if (!size)
+            if (!size && (codec_type == AVMEDIA_TYPE_AUDIO ||
+                          codec_type == AVMEDIA_TYPE_VIDEO))
                 break;
             if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) {
                 avio_skip(pb, size);
@@ -770,6 +767,10 @@ FF_ENABLE_DEPRECATION_WARNINGS
                             st->codecpar->extradata_size = esize - 10 * 4;
                         } else
                             st->codecpar->extradata_size =  size - 10 * 4;
+                        if (st->codecpar->extradata) {
+                            av_log(s, AV_LOG_WARNING, "New extradata in strf chunk, freeing previous one.\n");
+                            av_freep(&st->codecpar->extradata);
+                        }
                         if (ff_get_extradata(s, st->codecpar, pb, st->codecpar->extradata_size) < 0)
                             return AVERROR(ENOMEM);
                     }
@@ -795,7 +796,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
                             !memcmp(st->codecpar->extradata + st->codecpar->extradata_size - 9, "BottomUp", 9))
                             pal_src -= 9;
                         for (i = 0; i < pal_size / 4; i++)
-                            ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src+4*i);
+                            ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src + 4 * i);
                         ast->has_pal = 1;
                     }
 
@@ -807,14 +808,12 @@ FF_ENABLE_DEPRECATION_WARNINGS
                                                             tag1);
                     /* If codec is not found yet, try with the mov tags. */
                     if (!st->codecpar->codec_id) {
-                        char tag_buf[32];
-                        av_get_codec_tag_string(tag_buf, sizeof(tag_buf), tag1);
                         st->codecpar->codec_id =
                             ff_codec_get_id(ff_codec_movvideo_tags, tag1);
                         if (st->codecpar->codec_id)
                            av_log(s, AV_LOG_WARNING,
                                   "mov tag found in avi (fourcc %s)\n",
-                                  tag_buf);
+                                  av_fourcc2str(tag1));
                     }
                     /* This is needed to get the pict type which is necessary
                      * for generating correct pts. */
@@ -925,6 +924,10 @@ FF_ENABLE_DEPRECATION_WARNINGS
                 st = s->streams[stream_index];
 
                 if (size<(1<<30)) {
+                    if (st->codecpar->extradata) {
+                        av_log(s, AV_LOG_WARNING, "New extradata in strd chunk, freeing previous one.\n");
+                        av_freep(&st->codecpar->extradata);
+                    }
                     if (ff_get_extradata(s, st->codecpar, pb, size) < 0)
                         return AVERROR(ENOMEM);
                 }
@@ -940,9 +943,9 @@ FF_ENABLE_DEPRECATION_WARNINGS
             break;
         case MKTAG('i', 'n', 'd', 'x'):
             pos = avio_tell(pb);
-            if (pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX) &&
+            if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !(s->flags & AVFMT_FLAG_IGNIDX) &&
                 avi->use_odml &&
-                read_braindead_odml_indx(s, 0) < 0 &&
+                read_odml_index(s, 0) < 0 &&
                 (s->error_recognition & AV_EF_EXPLODE))
                 goto fail;
             avio_seek(pb, pos + size, SEEK_SET);
@@ -984,13 +987,11 @@ FF_ENABLE_DEPRECATION_WARNINGS
             }
         default:
             if (size > 1000000) {
-                char tag_buf[32];
-                av_get_codec_tag_string(tag_buf, sizeof(tag_buf), tag);
                 av_log(s, AV_LOG_ERROR,
                        "Something went wrong during header parsing, "
                        "tag %s has size %u, "
                        "I will ignore it and try to continue anyway.\n",
-                       tag_buf, size);
+                       av_fourcc2str(tag), size);
                 if (s->error_recognition & AV_EF_EXPLODE)
                     goto fail;
                 avi->movi_list = avio_tell(pb) - 4;
@@ -1014,7 +1015,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
         return AVERROR_INVALIDDATA;
     }
 
-    if (!avi->index_loaded && pb->seekable)
+    if (!avi->index_loaded && (pb->seekable & AVIO_SEEKABLE_NORMAL))
         avi_load_index(s);
     calculate_bitrate(s);
     avi->index_loaded    |= 1;
@@ -1098,6 +1099,9 @@ static int read_gab2_sub(AVFormatContext *s, AVStream *st, AVPacket *pkt)
         if (!sub_demuxer)
             goto error;
 
+        if (strcmp(sub_demuxer->name, "srt") && strcmp(sub_demuxer->name, "ass"))
+            goto error;
+
         if (!(ast->sub_ctx = avformat_alloc_context()))
             goto error;
 
@@ -1120,7 +1124,7 @@ static int read_gab2_sub(AVFormatContext *s, AVStream *st, AVPacket *pkt)
 
 error:
         av_freep(&ast->sub_ctx);
-        av_freep(&pb);
+        avio_context_free(&pb);
     }
     return 0;
 }
@@ -1203,7 +1207,8 @@ static int avi_sync(AVFormatContext *s, int exit_early)
         if ((d[0] == 'i' && d[1] == 'x' && n < s->nb_streams) ||
             // parse JUNK
             (d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K') ||
-            (d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1')) {
+            (d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1') ||
+            (d[0] == 'i' && d[1] == 'n' && d[2] == 'd' && d[3] == 'x')) {
             avio_skip(pb, size);
             goto start_sync;
         }
@@ -1260,19 +1265,6 @@ static int avi_sync(AVFormatContext *s, int exit_early)
                 }
             }
 
-            if (!avi->dv_demux &&
-                ((st->discard >= AVDISCARD_DEFAULT && size == 0) /* ||
-                 // FIXME: needs a little reordering
-                 (st->discard >= AVDISCARD_NONKEY &&
-                 !(pkt->flags & AV_PKT_FLAG_KEY)) */
-                || st->discard >= AVDISCARD_ALL)) {
-                if (!exit_early) {
-                    ast->frame_offset += get_duration(ast, size);
-                    avio_skip(pb, size);
-                    goto start_sync;
-                }
-            }
-
             if (d[2] == 'p' && d[3] == 'c' && size <= 4 * 256 + 4) {
                 int k    = avio_r8(pb);
                 int last = (k + avio_r8(pb) - 1) & 0xFF;
@@ -1299,6 +1291,18 @@ static int avi_sync(AVFormatContext *s, int exit_early)
                     ast->prefix_count = 0;
                 }
 
+                if (!avi->dv_demux &&
+                    ((st->discard >= AVDISCARD_DEFAULT && size == 0) /* ||
+                        // FIXME: needs a little reordering
+                        (st->discard >= AVDISCARD_NONKEY &&
+                        !(pkt->flags & AV_PKT_FLAG_KEY)) */
+                    || st->discard >= AVDISCARD_ALL)) {
+
+                    ast->frame_offset += get_duration(ast, size);
+                    avio_skip(pb, size);
+                    goto start_sync;
+                }
+
                 avi->stream_index = n;
                 ast->packet_size  = size + 8;
                 ast->remaining    = size;
@@ -1470,17 +1474,6 @@ static int avi_read_packet(AVFormatContext *s, AVPacket *pkt)
 //                pkt->dts += ast->start;
             if (ast->sample_size)
                 pkt->dts /= ast->sample_size;
-            av_log(s, AV_LOG_TRACE,
-                    "dts:%"PRId64" offset:%"PRId64" %d/%d smpl_siz:%d "
-                    "base:%d st:%d size:%d\n",
-                    pkt->dts,
-                    ast->frame_offset,
-                    ast->scale,
-                    ast->rate,
-                    ast->sample_size,
-                    AV_TIME_BASE,
-                    avi->stream_index,
-                    size);
             pkt->stream_index = avi->stream_index;
 
             if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->index_entries) {
@@ -1751,13 +1744,6 @@ static int avi_load_index(AVFormatContext *s)
             break;
         next = avio_tell(pb) + size + (size & 1);
 
-        av_log(s, AV_LOG_TRACE, "tag=%c%c%c%c size=0x%x\n",
-                 tag        & 0xff,
-                (tag >>  8) & 0xff,
-                (tag >> 16) & 0xff,
-                (tag >> 24) & 0xff,
-                size);
-
         if (tag == MKTAG('i', 'd', 'x', '1') &&
             avi_read_idx1(s, size) >= 0) {
             avi->index_loaded=2;
diff --git a/mythtv/external/FFmpeg/libavformat/avienc.c b/mythtv/external/FFmpeg/libavformat/avienc.c
index fd16fff365d..483f5b54b14 100644
--- a/mythtv/external/FFmpeg/libavformat/avienc.c
+++ b/mythtv/external/FFmpeg/libavformat/avienc.c
@@ -19,7 +19,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-//#define DEBUG
+#include <math.h>
 
 #include "avformat.h"
 #include "internal.h"
@@ -29,6 +29,7 @@
 #include "mpegts.h"
 #include "libavformat/avlanguage.h"
 #include "libavutil/avstring.h"
+#include "libavutil/avutil.h"
 #include "libavutil/internal.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/dict.h"
@@ -51,6 +52,9 @@ typedef struct AVIIentry {
 } AVIIentry;
 
 #define AVI_INDEX_CLUSTER_SIZE 16384
+#define AVI_MASTER_INDEX_PREFIX_SIZE    (8+2+1+1+4+8+4+4)
+#define AVI_MASTER_INDEX_ENTRY_SIZE     16  /* bytes per entry */
+#define AVI_MASTER_INDEX_SIZE_DEFAULT   256 /* number of entries */
 
 typedef struct AVIIndex {
     int64_t     indx_start;
@@ -66,6 +70,8 @@ typedef struct AVIContext {
     int64_t riff_start, movi_list, odml_list;
     int64_t frames_hdr_all;
     int riff_id;
+    int reserve_index_space;
+    int master_index_max_size;
     int write_channel_mask;
 } AVIContext;
 
@@ -134,6 +140,21 @@ static int avi_add_ientry(AVFormatContext *s, int stream_index, char *tag,
     return 0;
 }
 
+static av_cold int avi_init(struct AVFormatContext *s)
+{
+    AVIContext *avi = s->priv_data;
+
+    if (avi->reserve_index_space > 0) {
+        avi->master_index_max_size = (avi->reserve_index_space - AVI_MASTER_INDEX_PREFIX_SIZE) / AVI_MASTER_INDEX_ENTRY_SIZE;
+        avi->master_index_max_size = FFMAX(avi->master_index_max_size, 16);
+    } else
+        avi->master_index_max_size = AVI_MASTER_INDEX_SIZE_DEFAULT;
+    av_log(s, AV_LOG_DEBUG, "reserve_index_space:%d master_index_max_size:%d\n",
+           avi->reserve_index_space, avi->master_index_max_size);
+
+    return 1; /* stream initialization continues in avi_write_header */
+}
+
 static int64_t avi_start_new_riff(AVFormatContext *s, AVIOContext *pb,
                                   const char *riff_tag, const char *list_tag)
 {
@@ -210,6 +231,7 @@ static int avi_write_counters(AVFormatContext *s, int riff_id)
 static void write_odml_master(AVFormatContext *s, int stream_index)
 {
     AVIOContext *pb = s->pb;
+    AVIContext *avi = s->priv_data;
     AVStream *st = s->streams[stream_index];
     AVCodecParameters *par = st->codecpar;
     AVIStream *avist = st->priv_data;
@@ -229,7 +251,7 @@ static void write_odml_master(AVFormatContext *s, int stream_index)
                         /* dwChunkId */
     avio_wl64(pb, 0);   /* dwReserved[3] */
     avio_wl32(pb, 0);   /* Must be 0.    */
-    for (j = 0; j < AVI_MASTER_INDEX_SIZE * 2; j++)
+    for (j = 0; j < avi->master_index_max_size * 2; j++)
         avio_wl64(pb, 0);
     ff_end_tag(pb, avist->indexes.indx_start);
 }
@@ -239,6 +261,7 @@ static int avi_write_header(AVFormatContext *s)
     AVIContext *avi = s->priv_data;
     AVIOContext *pb = s->pb;
     int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale;
+    int64_t max_stream_duration = 0;
     AVCodecParameters *video_par;
     AVStream *video_st = NULL;
     int64_t list1, list2, strh, strf;
@@ -269,13 +292,34 @@ static int avi_write_header(AVFormatContext *s)
     video_par = NULL;
     for (n = 0; n < s->nb_streams; n++) {
         AVCodecParameters *par = s->streams[n]->codecpar;
-        bitrate += par->bit_rate;
+        AVStream *st = s->streams[n];
+        bitrate = FFMIN(bitrate + par->bit_rate, INT32_MAX);
+        if (st->duration > 0) {
+            int64_t stream_duration = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
+            max_stream_duration = FFMAX(stream_duration, max_stream_duration);
+        }
         if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
             video_par = par;
-            video_st = s->streams[n];
+            video_st = st;
         }
     }
 
+    /* guess master index size based on bitrate and duration */
+    if (!avi->reserve_index_space) {
+        double duration_est, filesize_est;
+        if (s->duration > 0)
+            duration_est = (double)s->duration / AV_TIME_BASE;
+        else if (max_stream_duration > 0)
+            duration_est = (double)max_stream_duration / AV_TIME_BASE;
+        else
+            duration_est = 10 * 60 * 60; /* default to 10 hours */
+        filesize_est = duration_est * (bitrate / 8) * 1.10; /* add 10% safety margin for muxer+bitrate */
+        avi->master_index_max_size = FFMAX((int)ceil(filesize_est / AVI_MAX_RIFF_SIZE) + 1,
+                                           avi->master_index_max_size);
+        av_log(s, AV_LOG_DEBUG, "duration_est:%0.3f, filesize_est:%0.1fGiB, master_index_max_size:%d\n",
+               duration_est, filesize_est / (1024*1024*1024), avi->master_index_max_size);
+    }
+
     nb_frames = 0;
 
     // TODO: should be avg_frame_rate
@@ -286,7 +330,7 @@ static int avi_write_header(AVFormatContext *s)
         avio_wl32(pb, 0);
     avio_wl32(pb, bitrate / 8); /* XXX: not quite exact */
     avio_wl32(pb, 0); /* padding */
-    if (!pb->seekable)
+    if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
         avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_ISINTERLEAVED);  /* flags */
     else
         avio_wl32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED);  /* flags */
@@ -322,8 +366,7 @@ static int avi_write_header(AVFormatContext *s)
             // XSUB subtitles behave like video tracks, other subtitles
             // are not (yet) supported.
             if (par->codec_id != AV_CODEC_ID_XSUB) {
-                av_log(s, AV_LOG_ERROR,
-                       "Subtitle streams other than DivX XSUB are not supported by the AVI muxer.\n");
+                avpriv_report_missing_feature(s, "Subtitle streams other than DivX XSUB");
                 return AVERROR_PATCHWELCOME;
             }
         case AVMEDIA_TYPE_VIDEO:
@@ -368,7 +411,7 @@ static int avi_write_header(AVFormatContext *s)
         avio_wl32(pb, 0); /* start */
         /* remember this offset to fill later */
         avist->frames_hdr_strm = avio_tell(pb);
-        if (!pb->seekable)
+        if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
             /* FIXME: this may be broken, but who cares */
             avio_wl32(pb, AVI_MAX_RIFF_SIZE);
         else
@@ -407,7 +450,7 @@ static int avi_write_header(AVFormatContext *s)
                     && par->bits_per_coded_sample == 15)
                     par->bits_per_coded_sample = 16;
                 avist->pal_offset = avio_tell(pb) + 40;
-                ff_put_bmp_header(pb, par, ff_codec_bmp_tags, 0, 0);
+                ff_put_bmp_header(pb, par, 0, 0);
                 pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,
                                               par->bits_per_coded_sample);
                 if (   !par->codec_tag
@@ -447,7 +490,7 @@ static int avi_write_header(AVFormatContext *s)
             }
         }
 
-        if (pb->seekable) {
+        if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
             write_odml_master(s, i);
         }
 
@@ -488,7 +531,7 @@ static int avi_write_header(AVFormatContext *s)
         ff_end_tag(pb, list2);
     }
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         /* AVI could become an OpenDML one, if it grows beyond 2Gb range */
         avi->odml_list = ff_start_tag(pb, "JUNK");
         ffio_wfourcc(pb, "odml");
@@ -565,13 +608,13 @@ static int avi_write_ix(AVFormatContext *s)
     char ix_tag[] = "ix00";
     int i, j;
 
-    av_assert0(pb->seekable);
+    av_assert0(pb->seekable & AVIO_SEEKABLE_NORMAL);
 
     for (i = 0; i < s->nb_streams; i++) {
         AVIStream *avist = s->streams[i]->priv_data;
-        if (avi->riff_id - avist->indexes.master_odml_riff_id_base == AVI_MASTER_INDEX_SIZE) {
+        if (avi->riff_id - avist->indexes.master_odml_riff_id_base == avi->master_index_max_size) {
             int64_t pos;
-            int size = 8+2+1+1+4+8+4+4+16*AVI_MASTER_INDEX_SIZE;
+            int size = AVI_MASTER_INDEX_PREFIX_SIZE + AVI_MASTER_INDEX_ENTRY_SIZE * avi->master_index_max_size;
 
             pos = avio_tell(pb);
             update_odml_entry(s, i, pos, size);
@@ -579,7 +622,7 @@ static int avi_write_ix(AVFormatContext *s)
             av_assert1(avio_tell(pb) - pos == size);
             avist->indexes.master_odml_riff_id_base = avi->riff_id - 1;
         }
-        av_assert0(avi->riff_id - avist->indexes.master_odml_riff_id_base < AVI_MASTER_INDEX_SIZE);
+        av_assert0(avi->riff_id - avist->indexes.master_odml_riff_id_base < avi->master_index_max_size);
     }
 
     for (i = 0; i < s->nb_streams; i++) {
@@ -623,7 +666,7 @@ static int avi_write_idx1(AVFormatContext *s)
     int i;
     char tag[5];
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         AVIStream *avist;
         AVIIentry *ie = 0, *tie;
         int empty, stream_id = -1;
@@ -737,7 +780,7 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
 
                 av_assert0(par->bits_per_coded_sample >= 0 && par->bits_per_coded_sample <= 8);
 
-                if (pb->seekable && avist->pal_offset) {
+                if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && avist->pal_offset) {
                     int64_t cur_offset = avio_tell(pb);
                     avio_seek(pb, avist->pal_offset, SEEK_SET);
                     for (i = 0; i < pal_size; i++) {
@@ -752,7 +795,7 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
                     unsigned char tag[5];
                     avi_stream2fourcc(tag, stream_index, par->codec_type);
                     tag[2] = 'p'; tag[3] = 'c';
-                    if (s->pb->seekable) {
+                    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
                         if (avist->strh_flags_offset) {
                             int64_t cur_offset = avio_tell(pb);
                             avio_seek(pb, avist->strh_flags_offset, SEEK_SET);
@@ -808,7 +851,7 @@ static int avi_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
     avist->packet_count++;
 
     // Make sure to put an OpenDML chunk when the file size exceeds the limits
-    if (pb->seekable &&
+    if ((pb->seekable & AVIO_SEEKABLE_NORMAL) &&
         (avio_tell(pb) - avi->riff_start > AVI_MAX_RIFF_SIZE)) {
         avi_write_ix(s);
         ff_end_tag(pb, avi->movi_list);
@@ -826,7 +869,7 @@ static int avi_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
     if (par->codec_type == AVMEDIA_TYPE_AUDIO)
         avist->audio_strm_length += size;
 
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         int ret;
         ret = avi_add_ientry(s, stream_index, NULL, flags, size);
         if (ret < 0)
@@ -855,7 +898,7 @@ static int avi_write_trailer(AVFormatContext *s)
         write_skip_frames(s, i, avist->last_dts);
     }
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         if (avi->riff_id == 1) {
             ff_end_tag(pb, avi->movi_list);
             res = avi_write_idx1(s);
@@ -890,13 +933,21 @@ static int avi_write_trailer(AVFormatContext *s)
         }
     }
 
+    if (avi->riff_id >= avi->master_index_max_size) {
+        int index_space = AVI_MASTER_INDEX_PREFIX_SIZE +
+                          AVI_MASTER_INDEX_ENTRY_SIZE * avi->riff_id;
+        av_log(s, AV_LOG_WARNING, "Output file not strictly OpenDML compliant, "
+               "consider re-muxing with 'reserve_index_space' option value >= %d\n",
+               index_space);
+    }
+
     for (i = 0; i < s->nb_streams; i++) {
         AVIStream *avist = s->streams[i]->priv_data;
         for (j = 0; j < avist->indexes.ents_allocated / AVI_INDEX_CLUSTER_SIZE; j++)
             av_freep(&avist->indexes.cluster[j]);
         av_freep(&avist->indexes.cluster);
         avist->indexes.ents_allocated = avist->indexes.entry = 0;
-        if (pb->seekable) {
+        if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
             avio_seek(pb, avist->frames_hdr_strm + 4, SEEK_SET);
             avio_wl32(pb, avist->max_size);
         }
@@ -908,6 +959,7 @@ static int avi_write_trailer(AVFormatContext *s)
 #define OFFSET(x) offsetof(AVIContext, x)
 #define ENC AV_OPT_FLAG_ENCODING_PARAM
 static const AVOption options[] = {
+    { "reserve_index_space", "reserve space (in bytes) at the beginning of the file for each stream index", OFFSET(reserve_index_space), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, ENC },
     { "write_channel_mask", "write channel mask into wave format header", OFFSET(write_channel_mask), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, ENC },
     { NULL },
 };
@@ -927,6 +979,7 @@ AVOutputFormat ff_avi_muxer = {
     .priv_data_size = sizeof(AVIContext),
     .audio_codec    = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_AC3,
     .video_codec    = AV_CODEC_ID_MPEG4,
+    .init           = avi_init,
     .write_header   = avi_write_header,
     .write_packet   = avi_write_packet,
     .write_trailer  = avi_write_trailer,
diff --git a/mythtv/external/FFmpeg/libavformat/avio.c b/mythtv/external/FFmpeg/libavformat/avio.c
index 3606eb0fda9..64248e098b9 100644
--- a/mythtv/external/FFmpeg/libavformat/avio.c
+++ b/mythtv/external/FFmpeg/libavformat/avio.c
@@ -179,12 +179,12 @@ int ffurl_connect(URLContext *uc, AVDictionary **options)
                (uc->protocol_blacklist && !strcmp(uc->protocol_blacklist, e->value)));
 
     if (uc->protocol_whitelist && av_match_list(uc->prot->name, uc->protocol_whitelist, ',') <= 0) {
-        av_log(uc, AV_LOG_ERROR, "Protocol not on whitelist \'%s\'!\n", uc->protocol_whitelist);
+        av_log(uc, AV_LOG_ERROR, "Protocol '%s' not on whitelist '%s'!\n", uc->prot->name, uc->protocol_whitelist);
         return AVERROR(EINVAL);
     }
 
     if (uc->protocol_blacklist && av_match_list(uc->prot->name, uc->protocol_blacklist, ',') > 0) {
-        av_log(uc, AV_LOG_ERROR, "Protocol blacklisted \'%s\'!\n", uc->protocol_blacklist);
+        av_log(uc, AV_LOG_ERROR, "Protocol '%s' on blacklist '%s'!\n", uc->prot->name, uc->protocol_blacklist);
         return AVERROR(EINVAL);
     }
 
@@ -263,8 +263,6 @@ static const struct URLProtocol *url_find_protocol(const char *filename)
         av_strlcpy(proto_str, filename,
                    FFMIN(proto_len + 1, sizeof(proto_str)));
 
-    if ((ptr = strchr(proto_str, ',')))
-        *ptr = '\0';
     av_strlcpy(proto_nested, proto_str, sizeof(proto_nested));
     if ((ptr = strchr(proto_nested, '+')))
         *ptr = '\0';
@@ -645,6 +643,13 @@ int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)
     return h->prot->url_get_multi_file_handle(h, handles, numhandles);
 }
 
+int ffurl_get_short_seek(URLContext *h)
+{
+    if (!h->prot->url_get_short_seek)
+        return AVERROR(ENOSYS);
+    return h->prot->url_get_short_seek(h);
+}
+
 int ffurl_shutdown(URLContext *h, int flags)
 {
     if (!h->prot->url_shutdown)
diff --git a/mythtv/external/FFmpeg/libavformat/avio.h b/mythtv/external/FFmpeg/libavformat/avio.h
index b1ce1d1c72e..f9c5972adae 100644
--- a/mythtv/external/FFmpeg/libavformat/avio.h
+++ b/mythtv/external/FFmpeg/libavformat/avio.h
@@ -34,7 +34,15 @@
 
 #include "libavformat/version.h"
 
-#define AVIO_SEEKABLE_NORMAL 0x0001 /**< Seeking works like for a local file */
+/**
+ * Seeking works like for a local file.
+ */
+#define AVIO_SEEKABLE_NORMAL (1 << 0)
+
+/**
+ * Seeking by timestamp with avio_seek_time() is possible.
+ */
+#define AVIO_SEEKABLE_TIME   (1 << 1)
 
 /**
  * Callback for checking whether to abort blocking functions.
@@ -129,7 +137,13 @@ enum AVIODataMarkerType {
      * Trailer data, which doesn't contain actual content, but only for
      * finalizing the output file.
      */
-    AVIO_DATA_MARKER_TRAILER
+    AVIO_DATA_MARKER_TRAILER,
+    /**
+     * A point in the output bytestream where the underlying AVIOContext might
+     * flush the buffer depending on latency or buffering requirements. Typically
+     * means the end of a packet.
+     */
+    AVIO_DATA_MARKER_FLUSH_POINT,
 };
 
 /**
@@ -160,8 +174,9 @@ typedef struct AVIOContext {
     const AVClass *av_class;
 
     /*
-     * The following shows the relationship between buffer, buf_ptr, buf_end, buf_size,
-     * and pos, when reading and when writing (since AVIOContext is used for both):
+     * The following shows the relationship between buffer, buf_ptr,
+     * buf_ptr_max, buf_end, buf_size, and pos, when reading and when writing
+     * (since AVIOContext is used for both):
      *
      **********************************************************************************
      *                                   READING
@@ -188,21 +203,24 @@ typedef struct AVIOContext {
      *                                   WRITING
      **********************************************************************************
      *
-     *                                          |          buffer_size          |
-     *                                          |-------------------------------|
-     *                                          |                               |
+     *                             |          buffer_size                 |
+     *                             |--------------------------------------|
+     *                             |                                      |
      *
-     *                                       buffer              buf_ptr     buf_end
-     *                                          +-------------------+-----------+
-     *                                          |/ / / / / / / / / /|           |
-     *  write buffer:                           | / to be flushed / |           |
-     *                                          |/ / / / / / / / / /|           |
-     *                                          +-------------------+-----------+
+     *                                                buf_ptr_max
+     *                          buffer                 (buf_ptr)       buf_end
+     *                             +-----------------------+--------------+
+     *                             |/ / / / / / / / / / / /|              |
+     *  write buffer:              | / / to be flushed / / |              |
+     *                             |/ / / / / / / / / / / /|              |
+     *                             +-----------------------+--------------+
+     *                               buf_ptr can be in this
+     *                               due to a backward seek
      *
-     *                                         pos
-     *               +--------------------------+-----------------------------------+
-     *  output file: |                          |                                   |
-     *               +--------------------------+-----------------------------------+
+     *                            pos
+     *               +-------------+----------------------------------------------+
+     *  output file: |             |                                              |
+     *               +-------------+----------------------------------------------+
      *
      */
     unsigned char *buffer;  /**< Start of the buffer. */
@@ -218,7 +236,7 @@ typedef struct AVIOContext {
     int (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
     int64_t (*seek)(void *opaque, int64_t offset, int whence);
     int64_t pos;            /**< position in the file of the current buffer */
-    int must_flush;         /**< true if the next seek should flush */
+    int must_flush;         /**< unused */
     int eof_reached;        /**< true if eof reached */
     int write_flag;         /**< true if open for writing */
     int max_packet_size;
@@ -313,6 +331,25 @@ typedef struct AVIOContext {
      */
     enum AVIODataMarkerType current_type;
     int64_t last_time;
+
+    /**
+     * A callback that is used instead of short_seek_threshold.
+     * This is current internal only, do not use from outside.
+     */
+    int (*short_seek_get)(void *opaque);
+
+    int64_t written;
+
+    /**
+     * Maximum reached position before a backward seek in the write buffer,
+     * used keeping track of already written data for a later flush.
+     */
+    unsigned char *buf_ptr_max;
+
+    /**
+     * Try to buffer at least this amount of data before flushing it
+     */
+    int min_packet_size;
 } AVIOContext;
 
 /**
@@ -402,7 +439,7 @@ void avio_free_directory_entry(AVIODirEntry **entry);
 
 /**
  * Allocate and initialize an AVIOContext for buffered I/O. It must be later
- * freed with av_free().
+ * freed with avio_context_free().
  *
  * @param buffer Memory block for input/output operations via AVIOContext.
  *        The buffer must be allocated with av_malloc() and friends.
@@ -430,6 +467,14 @@ AVIOContext *avio_alloc_context(
                   int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
                   int64_t (*seek)(void *opaque, int64_t offset, int whence));
 
+/**
+ * Free the supplied IO context and everything associated with it.
+ *
+ * @param s Double pointer to the IO context. This function will write NULL
+ * into s.
+ */
+void avio_context_free(AVIOContext **s);
+
 void avio_w8(AVIOContext *s, int b);
 void avio_write(AVIOContext *s, const unsigned char *buf, int size);
 void avio_wl64(AVIOContext *s, uint64_t val);
@@ -553,6 +598,15 @@ void avio_flush(AVIOContext *s);
  */
 int avio_read(AVIOContext *s, unsigned char *buf, int size);
 
+/**
+ * Read size bytes from AVIOContext into buf. Unlike avio_read(), this is allowed
+ * to read fewer bytes than requested. The missing bytes can be read in the next
+ * call. This always tries to read at least 1 byte.
+ * Useful to reduce latency in certain cases.
+ * @return number of bytes read or AVERROR
+ */
+int avio_read_partial(AVIOContext *s, unsigned char *buf, int size);
+
 /**
  * @name Functions for reading from AVIOContext
  * @{
@@ -703,6 +757,18 @@ int avio_closep(AVIOContext **s);
  */
 int avio_open_dyn_buf(AVIOContext **s);
 
+/**
+ * Return the written size and a pointer to the buffer.
+ * The AVIOContext stream is left intact.
+ * The buffer must NOT be freed.
+ * No padding is added to the buffer.
+ *
+ * @param s IO context
+ * @param pbuffer pointer to a byte buffer
+ * @return the length of the byte buffer
+ */
+int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
+
 /**
  * Return the written size and a pointer to the buffer. The buffer
  * must be freed with av_free().
diff --git a/mythtv/external/FFmpeg/libavformat/avio_internal.h b/mythtv/external/FFmpeg/libavformat/avio_internal.h
index fdb323c8f1e..c01835df96f 100644
--- a/mythtv/external/FFmpeg/libavformat/avio_internal.h
+++ b/mythtv/external/FFmpeg/libavformat/avio_internal.h
@@ -53,14 +53,6 @@ int ffio_init_context(AVIOContext *s,
  */
 int ffio_read_indirect(AVIOContext *s, unsigned char *buf, int size, const unsigned char **data);
 
-/**
- * Read size bytes from AVIOContext into buf.
- * This reads at most 1 packet. If that is not enough fewer bytes will be
- * returned.
- * @return number of bytes read or AVERROR
- */
-int ffio_read_partial(AVIOContext *s, unsigned char *buf, int size);
-
 void ffio_fill(AVIOContext *s, int b, int count);
 
 static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
diff --git a/mythtv/external/FFmpeg/libavformat/aviobuf.c b/mythtv/external/FFmpeg/libavformat/aviobuf.c
index 134d627a6e0..636cb46161a 100644
--- a/mythtv/external/FFmpeg/libavformat/aviobuf.c
+++ b/mythtv/external/FFmpeg/libavformat/aviobuf.c
@@ -91,6 +91,7 @@ int ffio_init_context(AVIOContext *s,
     s->orig_buffer_size =
     s->buffer_size = buffer_size;
     s->buf_ptr     = buffer;
+    s->buf_ptr_max = buffer;
     s->opaque      = opaque;
     s->direct      = 0;
 
@@ -100,10 +101,10 @@ int ffio_init_context(AVIOContext *s,
     s->read_packet     = read_packet;
     s->seek            = seek;
     s->pos             = 0;
-    s->must_flush      = 0;
     s->eof_reached     = 0;
     s->error           = 0;
     s->seekable        = seek ? AVIO_SEEKABLE_NORMAL : 0;
+    s->min_packet_size = 0;
     s->max_packet_size = 0;
     s->update_checksum = NULL;
     s->short_seek_threshold = SHORT_SEEK_THRESHOLD;
@@ -119,6 +120,8 @@ int ffio_init_context(AVIOContext *s,
     s->ignore_boundary_point = 0;
     s->current_type          = AVIO_DATA_MARKER_UNKNOWN;
     s->last_time             = AV_NOPTS_VALUE;
+    s->short_seek_get        = NULL;
+    s->written               = 0;
 
     return 0;
 }
@@ -140,6 +143,11 @@ AVIOContext *avio_alloc_context(
     return s;
 }
 
+void avio_context_free(AVIOContext **ps)
+{
+    av_freep(ps);
+}
+
 static void writeout(AVIOContext *s, const uint8_t *data, int len)
 {
     if (!s->error) {
@@ -153,6 +161,9 @@ static void writeout(AVIOContext *s, const uint8_t *data, int len)
             ret = s->write_packet(s->opaque, (uint8_t *)data, len);
         if (ret < 0) {
             s->error = ret;
+        } else {
+            if (s->pos + len > s->written)
+                s->written = s->pos + len;
         }
     }
     if (s->current_type == AVIO_DATA_MARKER_SYNC_POINT ||
@@ -166,15 +177,16 @@ static void writeout(AVIOContext *s, const uint8_t *data, int len)
 
 static void flush_buffer(AVIOContext *s)
 {
-    if (s->write_flag && s->buf_ptr > s->buffer) {
-        writeout(s, s->buffer, s->buf_ptr - s->buffer);
+    s->buf_ptr_max = FFMAX(s->buf_ptr, s->buf_ptr_max);
+    if (s->write_flag && s->buf_ptr_max > s->buffer) {
+        writeout(s, s->buffer, s->buf_ptr_max - s->buffer);
         if (s->update_checksum) {
             s->checksum     = s->update_checksum(s->checksum, s->checksum_ptr,
-                                                 s->buf_ptr - s->checksum_ptr);
+                                                 s->buf_ptr_max - s->checksum_ptr);
             s->checksum_ptr = s->buffer;
         }
     }
-    s->buf_ptr = s->buffer;
+    s->buf_ptr = s->buf_ptr_max = s->buffer;
     if (!s->write_flag)
         s->buf_end = s->buffer;
 }
@@ -223,8 +235,10 @@ void avio_write(AVIOContext *s, const unsigned char *buf, int size)
 
 void avio_flush(AVIOContext *s)
 {
+    int seekback = s->write_flag ? FFMIN(0, s->buf_ptr - s->buf_ptr_max) : 0;
     flush_buffer(s);
-    s->must_flush = 0;
+    if (seekback)
+        avio_seek(s, seekback, SEEK_CUR);
 }
 
 int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
@@ -233,6 +247,7 @@ int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
     int64_t pos;
     int force = whence & AVSEEK_FORCE;
     int buffer_size;
+    int short_seek;
     whence &= ~AVSEEK_FORCE;
 
     if(!s)
@@ -249,18 +264,29 @@ int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
         offset1 = pos + (s->buf_ptr - s->buffer);
         if (offset == 0)
             return offset1;
+        if (offset > INT64_MAX - offset1)
+            return AVERROR(EINVAL);
         offset += offset1;
     }
     if (offset < 0)
         return AVERROR(EINVAL);
 
+    if (s->short_seek_get) {
+        short_seek = s->short_seek_get(s->opaque);
+        /* fallback to default short seek */
+        if (short_seek <= 0)
+            short_seek = s->short_seek_threshold;
+    } else
+        short_seek = s->short_seek_threshold;
+
     offset1 = offset - pos; // "offset1" is the relative offset from the beginning of s->buffer
-    if (!s->must_flush && (!s->direct || !s->seek) &&
-        offset1 >= 0 && offset1 <= buffer_size - s->write_flag) {
+    s->buf_ptr_max = FFMAX(s->buf_ptr_max, s->buf_ptr);
+    if ((!s->direct || !s->seek) &&
+        offset1 >= 0 && offset1 <= (s->write_flag ? s->buf_ptr_max - s->buffer : buffer_size)) {
         /* can do the seek inside the buffer */
         s->buf_ptr = s->buffer + offset1;
-    } else if ((!s->seekable ||
-               offset1 <= buffer_size + s->short_seek_threshold) &&
+    } else if ((!(s->seekable & AVIO_SEEKABLE_NORMAL) ||
+               offset1 <= buffer_size + short_seek) &&
                !s->write_flag && offset1 >= 0 &&
                (!s->direct || !s->seek) &&
               (whence != SEEK_END || force)) {
@@ -285,7 +311,6 @@ int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
         int64_t res;
         if (s->write_flag) {
             flush_buffer(s);
-            s->must_flush = 1;
         }
         if (!s->seek)
             return AVERROR(EPIPE);
@@ -294,7 +319,7 @@ int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
         s->seek_count ++;
         if (!s->write_flag)
             s->buf_end = s->buffer;
-        s->buf_ptr = s->buffer;
+        s->buf_ptr = s->buf_ptr_max = s->buffer;
         s->pos = offset;
     }
     s->eof_reached = 0;
@@ -313,6 +338,9 @@ int64_t avio_size(AVIOContext *s)
     if (!s)
         return AVERROR(EINVAL);
 
+    if (s->written)
+        return s->written;
+
     if (!s->seek)
         return AVERROR(ENOSYS);
     size = s->seek(s->opaque, 0, AVSEEK_SIZE);
@@ -469,6 +497,11 @@ void avio_wb24(AVIOContext *s, unsigned int val)
 
 void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
 {
+    if (type == AVIO_DATA_MARKER_FLUSH_POINT) {
+        if (s->buf_ptr - s->buffer >= s->min_packet_size)
+            avio_flush(s);
+        return;
+    }
     if (!s->write_data_type)
         return;
     // If ignoring boundary points, just treat it as unknown
@@ -525,7 +558,7 @@ static void fill_buffer(AVIOContext *s)
 
     /* make buffer smaller in case it ended up large after probing */
     if (s->read_packet && s->orig_buffer_size && s->buffer_size > s->orig_buffer_size) {
-        if (dst == s->buffer) {
+        if (dst == s->buffer && s->buf_ptr != dst) {
             int ret = ffio_set_buf_size(s, s->orig_buffer_size);
             if (ret < 0)
                 av_log(s, AV_LOG_WARNING, "Failed to decrease buffer size\n");
@@ -670,7 +703,7 @@ int ffio_read_indirect(AVIOContext *s, unsigned char *buf, int size, const unsig
     }
 }
 
-int ffio_read_partial(AVIOContext *s, unsigned char *buf, int size)
+int avio_read_partial(AVIOContext *s, unsigned char *buf, int size)
 {
     int len;
 
@@ -858,6 +891,12 @@ static int64_t io_seek(void *opaque, int64_t offset, int whence)
     return ffurl_seek(internal->h, offset, whence);
 }
 
+static int io_short_seek(void *opaque)
+{
+    AVIOInternal *internal = opaque;
+    return ffurl_get_short_seek(internal->h);
+}
+
 static int io_read_pause(void *opaque, int pause)
 {
     AVIOInternal *internal = opaque;
@@ -915,10 +954,15 @@ int ffio_fdopen(AVIOContext **s, URLContext *h)
 
     (*s)->seekable = h->is_streamed ? 0 : AVIO_SEEKABLE_NORMAL;
     (*s)->max_packet_size = max_packet_size;
+    (*s)->min_packet_size = h->min_packet_size;
     if(h->prot) {
         (*s)->read_pause = io_read_pause;
         (*s)->read_seek  = io_read_seek;
+
+        if (h->prot->url_read_seek)
+            (*s)->seekable |= AVIO_SEEKABLE_TIME;
     }
+    (*s)->short_seek_get = io_short_seek;
     (*s)->av_class = &ff_avio_class;
     return 0;
 fail:
@@ -967,7 +1011,7 @@ int ffio_set_buf_size(AVIOContext *s, int buf_size)
     s->buffer = buffer;
     s->orig_buffer_size =
     s->buffer_size = buf_size;
-    s->buf_ptr = buffer;
+    s->buf_ptr = s->buf_ptr_max = buffer;
     url_resetbuf(s, s->write_flag ? AVIO_FLAG_WRITE : AVIO_FLAG_READ);
     return 0;
 }
@@ -1025,7 +1069,6 @@ int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char **bufp, int buf_si
     s->pos = buf_size;
     s->buf_end = s->buf_ptr + buf_size;
     s->eof_reached = 0;
-    s->must_flush = 0;
 
     return 0;
 }
@@ -1085,7 +1128,9 @@ int avio_close(AVIOContext *s)
     else
         av_log(s, AV_LOG_DEBUG, "Statistics: %"PRId64" bytes read, %d seeks\n", s->bytes_read, s->seek_count);
     av_opt_free(s);
-    av_free(s);
+
+    avio_context_free(&s);
+
     return ffurl_close(h);
 }
 
@@ -1277,6 +1322,23 @@ int ffio_open_dyn_packet_buf(AVIOContext **s, int max_packet_size)
     return url_open_dyn_buf_internal(s, max_packet_size);
 }
 
+int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
+{
+    DynBuffer *d;
+
+    if (!s) {
+        *pbuffer = NULL;
+        return 0;
+    }
+
+    avio_flush(s);
+
+    d = s->opaque;
+    *pbuffer = d->buffer;
+
+    return d->size;
+}
+
 int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
 {
     DynBuffer *d;
@@ -1301,7 +1363,9 @@ int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
     *pbuffer = d->buffer;
     size = d->size;
     av_free(d);
-    av_free(s);
+
+    avio_context_free(&s);
+
     return size - padding;
 }
 
@@ -1344,6 +1408,8 @@ int ffio_close_null_buf(AVIOContext *s)
 
     size = d->size;
     av_free(d);
-    av_free(s);
+
+    avio_context_free(&s);
+
     return size;
 }
diff --git a/mythtv/external/FFmpeg/libavformat/avisynth.c b/mythtv/external/FFmpeg/libavformat/avisynth.c
index 1acc44f4c52..56700288f77 100644
--- a/mythtv/external/FFmpeg/libavformat/avisynth.c
+++ b/mythtv/external/FFmpeg/libavformat/avisynth.c
@@ -3,6 +3,7 @@
  * Copyright (c) 2012 AvxSynth Team
  *
  * 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
@@ -18,8 +19,11 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/attributes.h"
 #include "libavutil/internal.h"
+
 #include "libavcodec/internal.h"
+
 #include "avformat.h"
 #include "internal.h"
 #include "config.h"
@@ -29,7 +33,7 @@
 
 /* Platform-specific directives for AviSynth vs AvxSynth. */
 #ifdef _WIN32
-  #include <windows.h>
+  #include "compat/w32dlfcn.h"
   #undef EXTERN_C
   #include "compat/avisynth/avisynth_c.h"
   #define AVISYNTH_LIB "avisynth"
@@ -39,10 +43,6 @@
   #include "compat/avisynth/avxsynth_c.h"
   #define AVISYNTH_NAME "libavxsynth"
   #define AVISYNTH_LIB AVISYNTH_NAME SLIBSUF
-
-  #define LoadLibrary(x) dlopen(x, RTLD_NOW | RTLD_LOCAL)
-  #define GetProcAddress dlsym
-  #define FreeLibrary dlclose
 #endif
 
 typedef struct AviSynthLibrary {
@@ -118,13 +118,12 @@ static av_cold void avisynth_atexit_handler(void);
 
 static av_cold int avisynth_load_library(void)
 {
-    avs_library.library = LoadLibrary(AVISYNTH_LIB);
+    avs_library.library = dlopen(AVISYNTH_LIB, RTLD_NOW | RTLD_LOCAL);
     if (!avs_library.library)
         return AVERROR_UNKNOWN;
 
 #define LOAD_AVS_FUNC(name, continue_on_fail)                          \
-        avs_library.name =                                             \
-            (void *)GetProcAddress(avs_library.library, #name);        \
+        avs_library.name = dlsym(avs_library.library, #name);          \
         if (!continue_on_fail && !avs_library.name)                    \
             goto fail;
 
@@ -157,7 +156,7 @@ static av_cold int avisynth_load_library(void)
     return 0;
 
 fail:
-    FreeLibrary(avs_library.library);
+    dlclose(avs_library.library);
     return AVERROR_UNKNOWN;
 }
 
@@ -225,7 +224,7 @@ static av_cold void avisynth_atexit_handler(void)
         avisynth_context_destroy(avs);
         avs = next;
     }
-    FreeLibrary(avs_library.library);
+    dlclose(avs_library.library);
 
     avs_atexit_called = 1;
 }
@@ -250,7 +249,7 @@ static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
 
     switch (avs->vi->pixel_type) {
 #ifdef USING_AVISYNTH
-/* 10~16-bit YUV pix_fmts (AviSynth+) */
+    /* 10~16-bit YUV pix_fmts (AviSynth+) */
     case AVS_CS_YUV444P10:
         st->codecpar->format = AV_PIX_FMT_YUV444P10;
         planar               = 1;
@@ -299,7 +298,7 @@ static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
         st->codecpar->format = AV_PIX_FMT_YUV420P16;
         planar               = 1;
         break;
-/* 8~16-bit YUV pix_fmts with Alpha (AviSynth+) */
+    /* 8~16-bit YUV pix_fmts with Alpha (AviSynth+) */
     case AVS_CS_YUVA444:
         st->codecpar->format = AV_PIX_FMT_YUVA444P;
         planar               = 4;
@@ -336,7 +335,7 @@ static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
         st->codecpar->format = AV_PIX_FMT_YUVA420P16;
         planar               = 4;
         break;
-/* Planar RGB pix_fmts (AviSynth+)  */
+    /* Planar RGB pix_fmts (AviSynth+) */
     case AVS_CS_RGBP:
         st->codecpar->format = AV_PIX_FMT_GBRP;
         planar               = 3;
@@ -357,7 +356,7 @@ static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
         st->codecpar->format = AV_PIX_FMT_GBRP16;
         planar               = 3;
         break;
-/* Planar RGB pix_fmts with Alpha (AviSynth+) */
+    /* Planar RGB pix_fmts with Alpha (AviSynth+) */
     case AVS_CS_RGBAP:
         st->codecpar->format = AV_PIX_FMT_GBRAP;
         planar               = 5;
@@ -374,12 +373,12 @@ static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
         st->codecpar->format = AV_PIX_FMT_GBRAP16;
         planar               = 5;
         break;
-/* GRAY16 (AviSynth+) */
+    /* GRAY16 (AviSynth+) */
     case AVS_CS_Y16:
         st->codecpar->format = AV_PIX_FMT_GRAY16;
         planar               = 2;
         break;
-/* pix_fmts added in AviSynth 2.6 */
+    /* pix_fmts added in AviSynth 2.6 */
     case AVS_CS_YV24:
         st->codecpar->format = AV_PIX_FMT_YUV444P;
         planar               = 1;
@@ -396,7 +395,7 @@ static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
         st->codecpar->format = AV_PIX_FMT_GRAY8;
         planar               = 2;
         break;
-/* 16-bit packed RGB pix_fmts (AviSynth+) */
+    /* 16-bit packed RGB pix_fmts (AviSynth+) */
     case AVS_CS_BGR48:
         st->codecpar->format = AV_PIX_FMT_BGR48;
         break;
@@ -404,7 +403,7 @@ static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
         st->codecpar->format = AV_PIX_FMT_BGRA64;
         break;
 #endif
-/* AviSynth 2.5 and AvxSynth pix_fmts */
+    /* AviSynth 2.5 and AvxSynth pix_fmts */
     case AVS_CS_BGR24:
         st->codecpar->format = AV_PIX_FMT_BGR24;
         break;
@@ -611,6 +610,7 @@ static int avisynth_read_packet_video(AVFormatContext *s, AVPacket *pkt,
     const unsigned char *src_p;
     int n, i, plane, rowsize, planeheight, pitch, bits;
     const char *error;
+    int avsplus av_unused;
 
     if (avs->curr_frame >= avs->vi->num_frames)
         return AVERROR_EOF;
@@ -623,9 +623,6 @@ static int avisynth_read_packet_video(AVFormatContext *s, AVPacket *pkt,
 #ifdef USING_AVISYNTH
     /* Detect whether we're using AviSynth 2.6 or AviSynth+ by
      * looking for whether avs_is_planar_rgb exists. */
-
-    int avsplus;
-
     if (GetProcAddress(avs_library.library, "avs_is_planar_rgb") == NULL)
         avsplus = 0;
     else
@@ -688,7 +685,7 @@ static int avisynth_read_packet_video(AVFormatContext *s, AVPacket *pkt,
         }
 
 #ifdef USING_AVISYNTH
-        /* Flip Planar RGB video. */
+        /* Flip Planar RGB video */
         if (avsplus && (avs_library.avs_is_planar_rgb(avs->vi) ||
                         avs_library.avs_is_planar_rgba(avs->vi))) {
             src_p = src_p + (planeheight - 1) * pitch;
diff --git a/mythtv/external/FFmpeg/libavformat/bfi.c b/mythtv/external/FFmpeg/libavformat/bfi.c
index 568363dd91b..6c98e33ab4a 100644
--- a/mythtv/external/FFmpeg/libavformat/bfi.c
+++ b/mythtv/external/FFmpeg/libavformat/bfi.c
@@ -88,6 +88,10 @@ static int bfi_read_header(AVFormatContext * s)
                vstream->codecpar->extradata_size);
 
     astream->codecpar->sample_rate = avio_rl32(pb);
+    if (astream->codecpar->sample_rate <= 0) {
+        av_log(s, AV_LOG_ERROR, "Invalid sample rate %d\n", astream->codecpar->sample_rate);
+        return AVERROR_INVALIDDATA;
+    }
 
     /* Set up the video codec... */
     avpriv_set_pts_info(vstream, 32, 1, fps);
@@ -104,7 +108,7 @@ static int bfi_read_header(AVFormatContext * s)
     astream->codecpar->channel_layout  = AV_CH_LAYOUT_MONO;
     astream->codecpar->bits_per_coded_sample = 8;
     astream->codecpar->bit_rate        =
-        astream->codecpar->sample_rate * astream->codecpar->bits_per_coded_sample;
+        (int64_t)astream->codecpar->sample_rate * astream->codecpar->bits_per_coded_sample;
     avio_seek(pb, chunk_header - 3, SEEK_SET);
     avpriv_set_pts_info(astream, 64, 1, astream->codecpar->sample_rate);
     return 0;
diff --git a/mythtv/external/FFmpeg/libavformat/bink.c b/mythtv/external/FFmpeg/libavformat/bink.c
index e6f0cb78ed4..8a05082fcd8 100644
--- a/mythtv/external/FFmpeg/libavformat/bink.c
+++ b/mythtv/external/FFmpeg/libavformat/bink.c
@@ -65,10 +65,12 @@ static int probe(AVProbeData *p)
     int smush = AV_RN32(p->buf) == AV_RN32("SMUS");
 
     do {
-        if (((b[0] == 'B' && b[1] == 'I' && b[2] == 'K' &&
-             (b[3] == 'b' || b[3] == 'f' || b[3] == 'g' || b[3] == 'h' || b[3] == 'i')) ||
+        if (((b[0] == 'B' && b[1] == 'I' && b[2] == 'K' && /* Bink 1 */
+             (b[3] == 'b' || b[3] == 'f' || b[3] == 'g' || b[3] == 'h' || b[3] == 'i' ||
+              b[3] == 'k')) ||
              (b[0] == 'K' && b[1] == 'B' && b[2] == '2' && /* Bink 2 */
-             (b[3] == 'a' || b[3] == 'd' || b[3] == 'f' || b[3] == 'g'))) &&
+             (b[3] == 'a' || b[3] == 'd' || b[3] == 'f' || b[3] == 'g' || b[3] == 'h' ||
+              b[3] == 'i' || b[3] == 'j' || b[3] == 'k'))) &&
             AV_RL32(b+8) > 0 &&  // num_frames
             AV_RL32(b+20) > 0 && AV_RL32(b+20) <= BINK_MAX_WIDTH &&
             AV_RL32(b+24) > 0 && AV_RL32(b+24) <= BINK_MAX_HEIGHT &&
@@ -159,7 +161,14 @@ static int read_header(AVFormatContext *s)
     }
 
     if (bink->num_audio_tracks) {
-        avio_skip(pb, 4 * bink->num_audio_tracks);
+        uint32_t signature = (vst->codecpar->codec_tag & 0xFFFFFF);
+        uint8_t revision = ((vst->codecpar->codec_tag >> 24) % 0xFF);
+
+        if ((signature == AV_RL32("BIK") && (revision == 0x6b)) || /* k */
+            (signature == AV_RL32("KB2") && (revision == 0x69 || revision == 0x6a || revision == 0x6b))) /* i,j,k */
+            avio_skip(pb, 4); /* unknown new field */
+
+        avio_skip(pb, 4 * bink->num_audio_tracks); /* max decoded size */
 
         for (i = 0; i < bink->num_audio_tracks; i++) {
             ast = avformat_new_stream(s, NULL);
@@ -292,7 +301,7 @@ static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, in
     BinkDemuxContext *bink = s->priv_data;
     AVStream *vst = s->streams[0];
 
-    if (!s->pb->seekable)
+    if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
         return -1;
 
     /* seek to the first frame */
diff --git a/mythtv/external/FFmpeg/libavformat/bintext.c b/mythtv/external/FFmpeg/libavformat/bintext.c
index a264fd1b5f5..12e3bfde4de 100644
--- a/mythtv/external/FFmpeg/libavformat/bintext.c
+++ b/mythtv/external/FFmpeg/libavformat/bintext.c
@@ -141,7 +141,7 @@ static int bintext_read_header(AVFormatContext *s)
     st->codecpar->extradata[0] = 16;
     st->codecpar->extradata[1] = 0;
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         int got_width = 0;
         bin->fsize = avio_size(pb);
         if (ff_sauce_read(s, &bin->fsize, &got_width, 0) < 0)
@@ -199,7 +199,7 @@ static int xbin_read_header(AVFormatContext *s)
     if (avio_read(pb, st->codecpar->extradata + 2, st->codecpar->extradata_size - 2) < 0)
         return AVERROR(EIO);
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         bin->fsize = avio_size(pb) - 9 - st->codecpar->extradata_size;
         ff_sauce_read(s, &bin->fsize, NULL, 0);
         avio_seek(pb, 9 + st->codecpar->extradata_size, SEEK_SET);
@@ -237,7 +237,7 @@ static int adf_read_header(AVFormatContext *s)
     if (avio_read(pb, st->codecpar->extradata + 2 + 48, 4096) < 0)
         return AVERROR(EIO);
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         int got_width = 0;
         bin->fsize = avio_size(pb) - 1 - 192 - 4096;
         st->codecpar->width = 80<<3;
@@ -271,7 +271,7 @@ static int idf_read_header(AVFormatContext *s)
     AVStream *st;
     int got_width = 0;
 
-    if (!pb->seekable)
+    if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
         return AVERROR(EIO);
 
     st = init_stream(s);
diff --git a/mythtv/external/FFmpeg/libavformat/bit.c b/mythtv/external/FFmpeg/libavformat/bit.c
index c3f2fdfbe38..76aae2d4a10 100644
--- a/mythtv/external/FFmpeg/libavformat/bit.c
+++ b/mythtv/external/FFmpeg/libavformat/bit.c
@@ -29,22 +29,26 @@
 #define BIT_0      0x7f
 #define BIT_1      0x81
 
+#if CONFIG_BIT_DEMUXER
 static int probe(AVProbeData *p)
 {
-    int i, j;
+    int i = 0, j, valid = 0;
 
-    if(p->buf_size < 0x40)
-        return 0;
-
-    for(i=0; i+3<p->buf_size && i< 10*0x50; ){
-        if(AV_RL16(&p->buf[0]) != SYNC_WORD)
+    while (2 * i + 3 < p->buf_size){
+        if (AV_RL16(&p->buf[2 * i++]) != SYNC_WORD)
             return 0;
-        j=AV_RL16(&p->buf[2]);
-        if(j!=0x40 && j!=0x50)
+        j = AV_RL16(&p->buf[2 * i++]);
+        if (j != 0 && j != 0x10 && j != 0x40 && j != 0x50 && j != 0x76)
             return 0;
-        i+=j;
+        if (j)
+            valid++;
+        i += j;
     }
-    return AVPROBE_SCORE_EXTENSION;
+    if (valid > 10)
+        return AVPROBE_SCORE_MAX;
+    if (valid > 2)
+        return AVPROBE_SCORE_EXTENSION - 1;
+    return 0;
 }
 
 static int read_header(AVFormatContext *s)
@@ -113,8 +117,9 @@ AVInputFormat ff_bit_demuxer = {
     .read_packet = read_packet,
     .extensions  = "bit",
 };
+#endif
 
-#if CONFIG_MUXERS
+#if CONFIG_BIT_MUXER
 static int write_header(AVFormatContext *s)
 {
     AVCodecParameters *par = s->streams[0]->codecpar;
@@ -141,10 +146,10 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
         return AVERROR(EINVAL);
 
     avio_wl16(pb, SYNC_WORD);
-    avio_wl16(pb, 8 * 10);
+    avio_wl16(pb, 8 * pkt->size);
 
-    init_get_bits(&gb, pkt->data, 8*10);
-    for(i=0; i< 8 * 10; i++)
+    init_get_bits(&gb, pkt->data, 8 * pkt->size);
+    for (i = 0; i < 8 * pkt->size; i++)
         avio_wl16(pb, get_bits1(&gb) ? BIT_1 : BIT_0);
 
     return 0;
diff --git a/mythtv/external/FFmpeg/libavformat/boadec.c b/mythtv/external/FFmpeg/libavformat/boadec.c
index ac2a33b3f0a..730e9573d5a 100644
--- a/mythtv/external/FFmpeg/libavformat/boadec.c
+++ b/mythtv/external/FFmpeg/libavformat/boadec.c
@@ -20,6 +20,7 @@
  */
 
 #include "libavutil/intreadwrite.h"
+#include "libavcodec/internal.h"
 #include "avformat.h"
 #include "internal.h"
 
@@ -53,9 +54,14 @@ static int read_header(AVFormatContext *s)
     avio_rl32(s->pb);
     st->codecpar->sample_rate = avio_rl32(s->pb);
     st->codecpar->channels    = avio_rl32(s->pb);
+    if (st->codecpar->channels > FF_SANE_NB_CHANNELS)
+        return AVERROR(ENOSYS);
     s->internal->data_offset = avio_rl32(s->pb);
     avio_r8(s->pb);
-    st->codecpar->block_align = st->codecpar->channels * avio_rl32(s->pb);
+    st->codecpar->block_align = avio_rl32(s->pb);
+    if (st->codecpar->block_align > INT_MAX / FF_SANE_NB_CHANNELS)
+        return AVERROR_INVALIDDATA;
+    st->codecpar->block_align *= st->codecpar->channels;
 
     avio_seek(s->pb, s->internal->data_offset, SEEK_SET);
 
diff --git a/mythtv/external/FFmpeg/libavformat/brstm.c b/mythtv/external/FFmpeg/libavformat/brstm.c
index 2e1cada158e..87690e3f73e 100644
--- a/mythtv/external/FFmpeg/libavformat/brstm.c
+++ b/mythtv/external/FFmpeg/libavformat/brstm.c
@@ -230,7 +230,7 @@ static int read_header(AVFormatContext *s)
     b->current_block = 0;
     b->block_count = read32(s);
     if (b->block_count > UINT16_MAX) {
-        av_log(s, AV_LOG_WARNING, "too many blocks: %u\n", b->block_count);
+        av_log(s, AV_LOG_WARNING, "too many blocks: %"PRIu32"\n", b->block_count);
         return AVERROR_INVALIDDATA;
     }
 
diff --git a/mythtv/external/FFmpeg/libavformat/caf.c b/mythtv/external/FFmpeg/libavformat/caf.c
index c05fb8087c6..fe242ff0327 100644
--- a/mythtv/external/FFmpeg/libavformat/caf.c
+++ b/mythtv/external/FFmpeg/libavformat/caf.c
@@ -33,6 +33,7 @@
  */
 const AVCodecTag ff_codec_caf_tags[] = {
     { AV_CODEC_ID_AAC,             MKTAG('a','a','c',' ') },
+    { AV_CODEC_ID_AAC,             MKTAG('a','a','c','l') },
     { AV_CODEC_ID_AC3,             MKTAG('a','c','-','3') },
     { AV_CODEC_ID_ADPCM_IMA_QT,    MKTAG('i','m','a','4') },
     { AV_CODEC_ID_ADPCM_IMA_WAV,   MKTAG('m','s', 0, 17 ) },
@@ -51,6 +52,7 @@ const AVCodecTag ff_codec_caf_tags[] = {
     { AV_CODEC_ID_MP2,             MKTAG('.','m','p','2') },
     { AV_CODEC_ID_MP3,             MKTAG('.','m','p','3') },
     { AV_CODEC_ID_MP3,             MKTAG('m','s', 0 ,'U') },
+    { AV_CODEC_ID_OPUS,            MKTAG('o','p','u','s') },
     { AV_CODEC_ID_PCM_ALAW,        MKTAG('a','l','a','w') },
     { AV_CODEC_ID_PCM_MULAW,       MKTAG('u','l','a','w') },
     { AV_CODEC_ID_QCELP,           MKTAG('Q','c','l','p') },
diff --git a/mythtv/external/FFmpeg/libavformat/cafdec.c b/mythtv/external/FFmpeg/libavformat/cafdec.c
index 1c4ca401c2c..7652d9e2385 100644
--- a/mythtv/external/FFmpeg/libavformat/cafdec.c
+++ b/mythtv/external/FFmpeg/libavformat/cafdec.c
@@ -166,6 +166,14 @@ static int read_kuki_chunk(AVFormatContext *s, int64_t size)
             }
             avio_skip(pb, size - ALAC_NEW_KUKI);
         }
+    } else if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
+        // The data layout for Opus is currently unknown, so we do not export
+        // extradata at all. Multichannel streams are not supported.
+        if (st->codecpar->channels > 2) {
+            avpriv_request_sample(s, "multichannel Opus in CAF");
+            return AVERROR_PATCHWELCOME;
+        }
+        avio_skip(pb, size);
     } else {
         av_freep(&st->codecpar->extradata);
         if (ff_get_extradata(s, st->codecpar, pb, size) < 0)
@@ -257,7 +265,7 @@ static int read_header(AVFormatContext *s)
 
         /* stop at data chunk if seeking is not supported or
            data chunk size is unknown */
-        if (found_data && (caf->data_size < 0 || !pb->seekable))
+        if (found_data && (caf->data_size < 0 || !(pb->seekable & AVIO_SEEKABLE_NORMAL)))
             break;
 
         tag  = avio_rb32(pb);
@@ -271,7 +279,7 @@ static int read_header(AVFormatContext *s)
             avio_skip(pb, 4); /* edit count */
             caf->data_start = avio_tell(pb);
             caf->data_size  = size < 0 ? -1 : size - 4;
-            if (caf->data_size > 0 && pb->seekable)
+            if (caf->data_size > 0 && (pb->seekable & AVIO_SEEKABLE_NORMAL))
                 avio_skip(pb, caf->data_size);
             found_data = 1;
             break;
@@ -298,11 +306,9 @@ static int read_header(AVFormatContext *s)
             break;
 
         default:
-#define _(x) ((x) >= ' ' ? (x) : ' ')
             av_log(s, AV_LOG_WARNING,
-                   "skipping CAF chunk: %08"PRIX32" (%c%c%c%c), size %"PRId64"\n",
-                tag, _(tag>>24), _((tag>>16)&0xFF), _((tag>>8)&0xFF), _(tag&0xFF), size);
-#undef _
+                   "skipping CAF chunk: %08"PRIX32" (%s), size %"PRId64"\n",
+                   tag, av_fourcc2str(av_bswap32(tag)), size);
         case MKBETAG('f','r','e','e'):
             if (size < 0)
                 return AVERROR_INVALIDDATA;
@@ -323,8 +329,13 @@ static int read_header(AVFormatContext *s)
         if (caf->data_size > 0)
             st->nb_frames = (caf->data_size / caf->bytes_per_packet) * caf->frames_per_packet;
     } else if (st->nb_index_entries && st->duration > 0) {
-        st->codecpar->bit_rate = st->codecpar->sample_rate * caf->data_size * 8 /
-                                 st->duration;
+        if (st->codecpar->sample_rate && caf->data_size / st->duration > INT64_MAX / st->codecpar->sample_rate / 8) {
+            av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %d * 8 * %"PRId64"\n",
+                   st->codecpar->sample_rate, caf->data_size / st->duration);
+            return AVERROR_INVALIDDATA;
+        }
+        st->codecpar->bit_rate = st->codecpar->sample_rate * 8LL *
+                                 (caf->data_size / st->duration);
     } else {
         av_log(s, AV_LOG_ERROR, "Missing packet table. It is required when "
                                 "block size or frame size are variable.\n");
diff --git a/mythtv/external/FFmpeg/libavformat/cafenc.c b/mythtv/external/FFmpeg/libavformat/cafenc.c
index 5ea8e69cc8d..f550cd965a3 100644
--- a/mythtv/external/FFmpeg/libavformat/cafenc.c
+++ b/mythtv/external/FFmpeg/libavformat/cafenc.c
@@ -117,6 +117,7 @@ static int caf_write_header(AVFormatContext *s)
 
     switch (par->codec_id) {
     case AV_CODEC_ID_AAC:
+    case AV_CODEC_ID_OPUS:
         av_log(s, AV_LOG_ERROR, "muxing codec currently unsupported\n");
         return AVERROR_PATCHWELCOME;
     }
@@ -126,7 +127,7 @@ static int caf_write_header(AVFormatContext *s)
         return AVERROR_INVALIDDATA;
     }
 
-    if (!par->block_align && !pb->seekable) {
+    if (!par->block_align && !(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
         av_log(s, AV_LOG_ERROR, "Muxing variable packet size not supported on non seekable output\n");
         return AVERROR_INVALIDDATA;
     }
@@ -236,7 +237,7 @@ static int caf_write_trailer(AVFormatContext *s)
     AVIOContext *pb = s->pb;
     AVCodecParameters *par = s->streams[0]->codecpar;
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         int64_t file_size = avio_tell(pb);
 
         avio_seek(pb, caf->data, SEEK_SET);
diff --git a/mythtv/external/FFmpeg/libavformat/chromaprint.c b/mythtv/external/FFmpeg/libavformat/chromaprint.c
index 8c9a6c01111..4da02bef762 100644
--- a/mythtv/external/FFmpeg/libavformat/chromaprint.c
+++ b/mythtv/external/FFmpeg/libavformat/chromaprint.c
@@ -39,7 +39,11 @@ typedef struct ChromaprintMuxContext {
     int silence_threshold;
     int algorithm;
     FingerprintFormat fp_format;
+#if CPR_VERSION_INT >= AV_VERSION_INT(1, 4, 0)
+    ChromaprintContext *ctx;
+#else
     ChromaprintContext ctx;
+#endif
 } ChromaprintMuxContext;
 
 static void cleanup(ChromaprintMuxContext *cpr)
diff --git a/mythtv/external/FFmpeg/libavformat/cinedec.c b/mythtv/external/FFmpeg/libavformat/cinedec.c
index 32cccf566b4..de34fb96382 100644
--- a/mythtv/external/FFmpeg/libavformat/cinedec.c
+++ b/mythtv/external/FFmpeg/libavformat/cinedec.c
@@ -267,8 +267,12 @@ static int cine_read_header(AVFormatContext *avctx)
 
     /* parse image offsets */
     avio_seek(pb, offImageOffsets, SEEK_SET);
-    for (i = 0; i < st->duration; i++)
+    for (i = 0; i < st->duration; i++) {
+        if (avio_feof(pb))
+            return AVERROR_INVALIDDATA;
+
         av_add_index_entry(st, avio_rl64(pb), i, 0, 0, AVINDEX_KEYFRAME);
+    }
 
     return 0;
 }
@@ -307,7 +311,7 @@ static int cine_read_seek(AVFormatContext *avctx, int stream_index, int64_t time
     if ((flags & AVSEEK_FLAG_FRAME) || (flags & AVSEEK_FLAG_BYTE))
         return AVERROR(ENOSYS);
 
-    if (!avctx->pb->seekable)
+    if (!(avctx->pb->seekable & AVIO_SEEKABLE_NORMAL))
         return AVERROR(EIO);
 
     cine->pts = timestamp;
diff --git a/mythtv/external/FFmpeg/libavformat/concatdec.c b/mythtv/external/FFmpeg/libavformat/concatdec.c
index 5cc239a1b65..0e189012adf 100644
--- a/mythtv/external/FFmpeg/libavformat/concatdec.c
+++ b/mythtv/external/FFmpeg/libavformat/concatdec.c
@@ -34,8 +34,7 @@ typedef enum ConcatMatchMode {
 } ConcatMatchMode;
 
 typedef struct ConcatStream {
-    AVBitStreamFilterContext *bsf;
-    AVCodecContext *avctx;
+    AVBSFContext *bsf;
     int out_stream_index;
 } ConcatStream;
 
@@ -45,6 +44,7 @@ typedef struct {
     int64_t file_start_time;
     int64_t file_inpoint;
     int64_t duration;
+    int64_t next_dts;
     ConcatStream *streams;
     int64_t inpoint;
     int64_t outpoint;
@@ -121,7 +121,7 @@ static int add_file(AVFormatContext *avf, char *filename, ConcatFile **rfile,
 
     proto = avio_find_protocol_name(filename);
     proto_len = proto ? strlen(proto) : 0;
-    if (!memcmp(filename, proto, proto_len) &&
+    if (proto && !memcmp(filename, proto, proto_len) &&
         (filename[proto_len] == ':' || filename[proto_len] == ',')) {
         url = filename;
         filename = NULL;
@@ -150,6 +150,7 @@ static int add_file(AVFormatContext *avf, char *filename, ConcatFile **rfile,
     file->url        = url;
     file->start_time = AV_NOPTS_VALUE;
     file->duration   = AV_NOPTS_VALUE;
+    file->next_dts   = AV_NOPTS_VALUE;
     file->inpoint    = AV_NOPTS_VALUE;
     file->outpoint   = AV_NOPTS_VALUE;
 
@@ -196,36 +197,39 @@ static int detect_stream_specific(AVFormatContext *avf, int idx)
     ConcatContext *cat = avf->priv_data;
     AVStream *st = cat->avf->streams[idx];
     ConcatStream *cs = &cat->cur_file->streams[idx];
-    AVBitStreamFilterContext *bsf;
+    const AVBitStreamFilter *filter;
+    AVBSFContext *bsf;
     int ret;
 
-    if (cat->auto_convert && st->codecpar->codec_id == AV_CODEC_ID_H264 &&
-        (st->codecpar->extradata_size < 4 || AV_RB32(st->codecpar->extradata) != 1)) {
+    if (cat->auto_convert && st->codecpar->codec_id == AV_CODEC_ID_H264) {
+        if (!st->codecpar->extradata_size                                                ||
+            (st->codecpar->extradata_size >= 3 && AV_RB24(st->codecpar->extradata) == 1) ||
+            (st->codecpar->extradata_size >= 4 && AV_RB32(st->codecpar->extradata) == 1))
+            return 0;
         av_log(cat->avf, AV_LOG_INFO,
                "Auto-inserting h264_mp4toannexb bitstream filter\n");
-        if (!(bsf = av_bitstream_filter_init("h264_mp4toannexb"))) {
+        filter = av_bsf_get_by_name("h264_mp4toannexb");
+        if (!filter) {
             av_log(avf, AV_LOG_ERROR, "h264_mp4toannexb bitstream filter "
                    "required for H.264 streams\n");
             return AVERROR_BSF_NOT_FOUND;
         }
+        ret = av_bsf_alloc(filter, &bsf);
+        if (ret < 0)
+            return ret;
         cs->bsf = bsf;
 
-        cs->avctx = avcodec_alloc_context3(NULL);
-        if (!cs->avctx)
-            return AVERROR(ENOMEM);
-
-        /* This really should be part of the bsf work.
-           Note: input bitstream filtering will not work with bsf that
-           create extradata from the first packet. */
-        av_freep(&st->codecpar->extradata);
-        st->codecpar->extradata_size = 0;
+        ret = avcodec_parameters_copy(bsf->par_in, st->codecpar);
+        if (ret < 0)
+           return ret;
 
-        ret = avcodec_parameters_to_context(cs->avctx, st->codecpar);
-        if (ret < 0) {
-            avcodec_free_context(&cs->avctx);
+        ret = av_bsf_init(bsf);
+        if (ret < 0)
             return ret;
-        }
 
+        ret = avcodec_parameters_copy(st->codecpar, bsf->par_out);
+        if (ret < 0)
+            return ret;
     }
     return 0;
 }
@@ -288,8 +292,11 @@ static int match_streams(AVFormatContext *avf)
     memset(map + cat->cur_file->nb_streams, 0,
            (cat->avf->nb_streams - cat->cur_file->nb_streams) * sizeof(*map));
 
-    for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++)
+    for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++) {
         map[i].out_stream_index = -1;
+        if ((ret = detect_stream_specific(avf, i)) < 0)
+            return ret;
+    }
     switch (cat->stream_match_mode) {
     case MATCH_ONE_TO_ONE:
         ret = match_streams_one_to_one(avf);
@@ -302,9 +309,6 @@ static int match_streams(AVFormatContext *avf)
     }
     if (ret < 0)
         return ret;
-    for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++)
-        if ((ret = detect_stream_specific(avf, i)) < 0)
-            return ret;
     cat->cur_file->nb_streams = cat->avf->nb_streams;
     return 0;
 }
@@ -322,6 +326,7 @@ static int open_file(AVFormatContext *avf, unsigned fileno)
     if (!cat->avf)
         return AVERROR(ENOMEM);
 
+    cat->avf->flags |= avf->flags & ~AVFMT_FLAG_CUSTOM_IO;
     cat->avf->interrupt_callback = avf->interrupt_callback;
 
     if ((ret = ff_copy_whiteblacklists(cat->avf, avf)) < 0)
@@ -366,10 +371,8 @@ static int concat_read_close(AVFormatContext *avf)
     for (i = 0; i < cat->nb_files; i++) {
         av_freep(&cat->files[i].url);
         for (j = 0; j < cat->files[i].nb_streams; j++) {
-            if (cat->files[i].streams[j].avctx)
-                avcodec_free_context(&cat->files[i].streams[j].avctx);
             if (cat->files[i].streams[j].bsf)
-                av_bitstream_filter_close(cat->files[i].streams[j].bsf);
+                av_bsf_free(&cat->files[i].streams[j].bsf);
         }
         av_freep(&cat->files[i].streams);
         av_dict_free(&cat->files[i].metadata);
@@ -508,8 +511,14 @@ static int open_next_file(AVFormatContext *avf)
     ConcatContext *cat = avf->priv_data;
     unsigned fileno = cat->cur_file - cat->files;
 
-    if (cat->cur_file->duration == AV_NOPTS_VALUE)
-        cat->cur_file->duration = cat->avf->duration - (cat->cur_file->file_inpoint - cat->cur_file->file_start_time);
+    if (cat->cur_file->duration == AV_NOPTS_VALUE) {
+        if (cat->avf->duration > 0 || cat->cur_file->next_dts == AV_NOPTS_VALUE) {
+            cat->cur_file->duration = cat->avf->duration;
+        } else {
+            cat->cur_file->duration = cat->cur_file->next_dts;
+        }
+        cat->cur_file->duration -= (cat->cur_file->file_inpoint - cat->cur_file->file_start_time);
+    }
 
     if (++fileno >= cat->nb_files) {
         cat->eof = 1;
@@ -520,56 +529,25 @@ static int open_next_file(AVFormatContext *avf)
 
 static int filter_packet(AVFormatContext *avf, ConcatStream *cs, AVPacket *pkt)
 {
-    AVStream *st = avf->streams[cs->out_stream_index];
-    AVBitStreamFilterContext *bsf;
-    AVPacket pkt2;
     int ret;
 
-    av_assert0(cs->out_stream_index >= 0);
-    for (bsf = cs->bsf; bsf; bsf = bsf->next) {
-        pkt2 = *pkt;
-
-        ret = av_bitstream_filter_filter(bsf, cs->avctx, NULL,
-                                         &pkt2.data, &pkt2.size,
-                                         pkt->data, pkt->size,
-                                         !!(pkt->flags & AV_PKT_FLAG_KEY));
+    if (cs->bsf) {
+        ret = av_bsf_send_packet(cs->bsf, pkt);
         if (ret < 0) {
+            av_log(avf, AV_LOG_ERROR, "h264_mp4toannexb filter "
+                   "failed to send input packet\n");
             av_packet_unref(pkt);
             return ret;
         }
 
-        if (cs->avctx->extradata_size > st->codecpar->extradata_size) {
-            int eret;
-            if (st->codecpar->extradata)
-                av_freep(&st->codecpar->extradata);
+        while (!ret)
+            ret = av_bsf_receive_packet(cs->bsf, pkt);
 
-            eret = ff_alloc_extradata(st->codecpar, cs->avctx->extradata_size);
-            if (eret < 0) {
-                av_packet_unref(pkt);
-                return AVERROR(ENOMEM);
-            }
-            st->codecpar->extradata_size = cs->avctx->extradata_size;
-            memcpy(st->codecpar->extradata, cs->avctx->extradata, cs->avctx->extradata_size);
-        }
-
-        av_assert0(pkt2.buf);
-        if (ret == 0 && pkt2.data != pkt->data) {
-            if ((ret = av_copy_packet(&pkt2, pkt)) < 0) {
-                av_free(pkt2.data);
-                return ret;
-            }
-            ret = 1;
-        }
-        if (ret > 0) {
-            av_packet_unref(pkt);
-            pkt2.buf = av_buffer_create(pkt2.data, pkt2.size,
-                                        av_buffer_default_free, NULL, 0);
-            if (!pkt2.buf) {
-                av_free(pkt2.data);
-                return AVERROR(ENOMEM);
-            }
+        if (ret < 0 && (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)) {
+            av_log(avf, AV_LOG_ERROR, "h264_mp4toannexb filter "
+                   "failed to receive output packet\n");
+            return ret;
         }
-        *pkt = pkt2;
     }
     return 0;
 }
@@ -657,6 +635,14 @@ static int concat_read_packet(AVFormatContext *avf, AVPacket *pkt)
         memcpy(metadata, packed_metadata, metadata_len);
         av_freep(&packed_metadata);
     }
+
+    if (cat->cur_file->duration == AV_NOPTS_VALUE && st->cur_dts != AV_NOPTS_VALUE) {
+        int64_t next_dts = av_rescale_q(st->cur_dts, st->time_base, AV_TIME_BASE_Q);
+        if (cat->cur_file->next_dts == AV_NOPTS_VALUE || next_dts > cat->cur_file->next_dts) {
+            cat->cur_file->next_dts = next_dts;
+        }
+    }
+
     return ret;
 }
 
diff --git a/mythtv/external/FFmpeg/libavformat/crypto.c b/mythtv/external/FFmpeg/libavformat/crypto.c
index 346c7061b4a..9a48f2e6f51 100644
--- a/mythtv/external/FFmpeg/libavformat/crypto.c
+++ b/mythtv/external/FFmpeg/libavformat/crypto.c
@@ -54,10 +54,10 @@ typedef struct CryptoContext {
     int encrypt_ivlen;
     struct AVAES *aes_decrypt;
     struct AVAES *aes_encrypt;
-
+    uint8_t *write_buf;
+    unsigned int write_buf_size;
     uint8_t pad[BLOCKSIZE];
     int pad_len;
-
 } CryptoContext;
 
 #define OFFSET(x) offsetof(CryptoContext, x)
@@ -80,16 +80,16 @@ static const AVClass crypto_class = {
     .version        = LIBAVUTIL_VERSION_INT,
 };
 
-static int set_aes_arg(CryptoContext *c, uint8_t **buf, int *buf_len,
+static int set_aes_arg(URLContext *h, uint8_t **buf, int *buf_len,
                        uint8_t *default_buf, int default_buf_len,
                        const char *desc)
 {
     if (!*buf_len) {
         if (!default_buf_len) {
-            av_log(c, AV_LOG_ERROR, "%s not set\n", desc);
+            av_log(h, AV_LOG_ERROR, "%s not set\n", desc);
             return AVERROR(EINVAL);
         } else if (default_buf_len != BLOCKSIZE) {
-            av_log(c, AV_LOG_ERROR,
+            av_log(h, AV_LOG_ERROR,
                    "invalid %s size (%d bytes, block size is %d)\n",
                    desc, default_buf_len, BLOCKSIZE);
             return AVERROR(EINVAL);
@@ -99,7 +99,7 @@ static int set_aes_arg(CryptoContext *c, uint8_t **buf, int *buf_len,
             return AVERROR(ENOMEM);
         *buf_len = default_buf_len;
     } else if (*buf_len != BLOCKSIZE) {
-        av_log(c, AV_LOG_ERROR,
+        av_log(h, AV_LOG_ERROR,
                "invalid %s size (%d bytes, block size is %d)\n",
                desc, *buf_len, BLOCKSIZE);
         return AVERROR(EINVAL);
@@ -121,23 +121,21 @@ static int crypto_open2(URLContext *h, const char *uri, int flags, AVDictionary
         goto err;
     }
 
-    c->position = 0;
-
     if (flags & AVIO_FLAG_READ) {
-        if ((ret = set_aes_arg(c, &c->decrypt_key, &c->decrypt_keylen,
+        if ((ret = set_aes_arg(h, &c->decrypt_key, &c->decrypt_keylen,
                                c->key, c->keylen, "decryption key")) < 0)
             goto err;
-        if ((ret = set_aes_arg(c, &c->decrypt_iv, &c->decrypt_ivlen,
+        if ((ret = set_aes_arg(h, &c->decrypt_iv, &c->decrypt_ivlen,
                                c->iv, c->ivlen, "decryption IV")) < 0)
             goto err;
     }
 
     if (flags & AVIO_FLAG_WRITE) {
-        if ((ret = set_aes_arg(c, &c->encrypt_key, &c->encrypt_keylen,
+        if ((ret = set_aes_arg(h, &c->encrypt_key, &c->encrypt_keylen,
                                c->key, c->keylen, "encryption key")) < 0)
         if (ret < 0)
             goto err;
-        if ((ret = set_aes_arg(c, &c->encrypt_iv, &c->encrypt_ivlen,
+        if ((ret = set_aes_arg(h, &c->encrypt_iv, &c->encrypt_ivlen,
                                c->iv, c->ivlen, "encryption IV")) < 0)
             goto err;
     }
@@ -155,7 +153,7 @@ static int crypto_open2(URLContext *h, const char *uri, int flags, AVDictionary
             ret = AVERROR(ENOMEM);
             goto err;
         }
-        ret = av_aes_init(c->aes_decrypt, c->decrypt_key, BLOCKSIZE*8, 1);
+        ret = av_aes_init(c->aes_decrypt, c->decrypt_key, BLOCKSIZE * 8, 1);
         if (ret < 0)
             goto err;
 
@@ -170,7 +168,7 @@ static int crypto_open2(URLContext *h, const char *uri, int flags, AVDictionary
             ret = AVERROR(ENOMEM);
             goto err;
         }
-        ret = av_aes_init(c->aes_encrypt, c->encrypt_key, BLOCKSIZE*8, 0);
+        ret = av_aes_init(c->aes_encrypt, c->encrypt_key, BLOCKSIZE * 8, 0);
         if (ret < 0)
             goto err;
         // for write, we must be streamed
@@ -178,8 +176,6 @@ static int crypto_open2(URLContext *h, const char *uri, int flags, AVDictionary
         h->is_streamed = 1;
     }
 
-    c->pad_len = 0;
-
 err:
     return ret;
 }
@@ -338,7 +334,6 @@ static int crypto_write(URLContext *h, const unsigned char *buf, int size)
 {
     CryptoContext *c = h->priv_data;
     int total_size, blocks, pad_len, out_size;
-    uint8_t *out_buf;
     int ret = 0;
 
     total_size = size + c->pad_len;
@@ -347,22 +342,23 @@ static int crypto_write(URLContext *h, const unsigned char *buf, int size)
     blocks = out_size / BLOCKSIZE;
 
     if (out_size) {
-        out_buf = av_malloc(out_size);
-        if (!out_buf)
+        av_fast_malloc(&c->write_buf, &c->write_buf_size, out_size);
+
+        if (!c->write_buf)
             return AVERROR(ENOMEM);
 
         if (c->pad_len) {
             memcpy(&c->pad[c->pad_len], buf, BLOCKSIZE - c->pad_len);
-            av_aes_crypt(c->aes_encrypt, out_buf, c->pad, 1, c->encrypt_iv, 0);
+            av_aes_crypt(c->aes_encrypt, c->write_buf, c->pad, 1, c->encrypt_iv, 0);
             blocks--;
         }
 
-        av_aes_crypt(c->aes_encrypt, &out_buf[c->pad_len ? BLOCKSIZE : 0],
-                             &buf[c->pad_len ? BLOCKSIZE - c->pad_len: 0],
-                             blocks, c->encrypt_iv, 0);
+        av_aes_crypt(c->aes_encrypt,
+                     &c->write_buf[c->pad_len ? BLOCKSIZE : 0],
+                     &buf[c->pad_len ? BLOCKSIZE - c->pad_len : 0],
+                     blocks, c->encrypt_iv, 0);
 
-        ret = ffurl_write(c->hd, out_buf, out_size);
-        av_free(out_buf);
+        ret = ffurl_write(c->hd, c->write_buf, out_size);
         if (ret < 0)
             return ret;
 
@@ -378,22 +374,23 @@ static int crypto_write(URLContext *h, const unsigned char *buf, int size)
 static int crypto_close(URLContext *h)
 {
     CryptoContext *c = h->priv_data;
-    uint8_t out_buf[BLOCKSIZE];
-    int ret, pad;
+    int ret = 0;
 
     if (c->aes_encrypt) {
-        pad = BLOCKSIZE - c->pad_len;
+        uint8_t out_buf[BLOCKSIZE];
+        int pad = BLOCKSIZE - c->pad_len;
+
         memset(&c->pad[c->pad_len], pad, pad);
         av_aes_crypt(c->aes_encrypt, out_buf, c->pad, 1, c->encrypt_iv, 0);
-        if ((ret =  ffurl_write(c->hd, out_buf, BLOCKSIZE)) < 0)
-            return ret;
+        ret = ffurl_write(c->hd, out_buf, BLOCKSIZE);
     }
 
     if (c->hd)
         ffurl_close(c->hd);
     av_freep(&c->aes_decrypt);
     av_freep(&c->aes_encrypt);
-    return 0;
+    av_freep(&c->write_buf);
+    return ret;
 }
 
 const URLProtocol ff_crypto_protocol = {
diff --git a/mythtv/external/FFmpeg/libavformat/dash.c b/mythtv/external/FFmpeg/libavformat/dash.c
new file mode 100644
index 00000000000..d2501f013a7
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/dash.c
@@ -0,0 +1,157 @@
+/*
+ * MPEG-DASH ISO BMFF segmenter
+ * Copyright (c) 2014 Martin Storsjo
+ *
+ * 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"
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include "libavutil/avassert.h"
+#include "libavutil/avstring.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/mathematics.h"
+#include "libavutil/opt.h"
+#include "libavutil/rational.h"
+#include "libavutil/time_internal.h"
+
+#include "avc.h"
+#include "avformat.h"
+#include "avio_internal.h"
+#include "internal.h"
+#include "isom.h"
+#include "os_support.h"
+#include "url.h"
+#include "dash.h"
+
+static DASHTmplId dash_read_tmpl_id(const char *identifier, char *format_tag,
+                                    size_t format_tag_size, const char **ptr) {
+    const char *next_ptr;
+    DASHTmplId id_type = DASH_TMPL_ID_UNDEFINED;
+
+    if (av_strstart(identifier, "$$", &next_ptr)) {
+        id_type = DASH_TMPL_ID_ESCAPE;
+        *ptr = next_ptr;
+    } else if (av_strstart(identifier, "$RepresentationID$", &next_ptr)) {
+        id_type = DASH_TMPL_ID_REP_ID;
+        // default to basic format, as $RepresentationID$ identifiers
+        // are not allowed to have custom format-tags.
+        av_strlcpy(format_tag, "%d", format_tag_size);
+        *ptr = next_ptr;
+    } else { // the following identifiers may have an explicit format_tag
+        if (av_strstart(identifier, "$Number", &next_ptr))
+            id_type = DASH_TMPL_ID_NUMBER;
+        else if (av_strstart(identifier, "$Bandwidth", &next_ptr))
+            id_type = DASH_TMPL_ID_BANDWIDTH;
+        else if (av_strstart(identifier, "$Time", &next_ptr))
+            id_type = DASH_TMPL_ID_TIME;
+        else
+            id_type = DASH_TMPL_ID_UNDEFINED;
+
+        // next parse the dash format-tag and generate a c-string format tag
+        // (next_ptr now points at the first '%' at the beginning of the format-tag)
+        if (id_type != DASH_TMPL_ID_UNDEFINED) {
+            const char *number_format = (id_type == DASH_TMPL_ID_TIME) ? PRId64 : "d";
+            if (next_ptr[0] == '$') { // no dash format-tag
+                snprintf(format_tag, format_tag_size, "%%%s", number_format);
+                *ptr = &next_ptr[1];
+            } else {
+                const char *width_ptr;
+                // only tolerate single-digit width-field (i.e. up to 9-digit width)
+                if (av_strstart(next_ptr, "%0", &width_ptr) &&
+                    av_isdigit(width_ptr[0]) &&
+                    av_strstart(&width_ptr[1], "d$", &next_ptr)) {
+                    // yes, we're using a format tag to build format_tag.
+                    snprintf(format_tag, format_tag_size, "%s%c%s", "%0", width_ptr[0], number_format);
+                    *ptr = next_ptr;
+                } else {
+                    av_log(NULL, AV_LOG_WARNING, "Failed to parse format-tag beginning with %s. Expected either a "
+                                                 "closing '$' character or a format-string like '%%0[width]d', "
+                                                 "where width must be a single digit\n", next_ptr);
+                    id_type = DASH_TMPL_ID_UNDEFINED;
+                }
+            }
+        }
+    }
+    return id_type;
+}
+
+void ff_dash_fill_tmpl_params(char *dst, size_t buffer_size,
+                                  const char *template, int rep_id,
+                                  int number, int bit_rate,
+                                  int64_t time) {
+    int dst_pos = 0;
+    const char *t_cur = template;
+    while (dst_pos < buffer_size - 1 && *t_cur) {
+        char format_tag[7]; // May be "%d", "%0Xd", or "%0Xlld" (for $Time$), where X is in [0-9]
+        int n = 0;
+        DASHTmplId id_type;
+        const char *t_next = strchr(t_cur, '$'); // copy over everything up to the first '$' character
+        if (t_next) {
+            int num_copy_bytes = FFMIN(t_next - t_cur, buffer_size - dst_pos - 1);
+            av_strlcpy(&dst[dst_pos], t_cur, num_copy_bytes + 1);
+            // advance
+            dst_pos += num_copy_bytes;
+            t_cur = t_next;
+        } else { // no more DASH identifiers to substitute - just copy the rest over and break
+            av_strlcpy(&dst[dst_pos], t_cur, buffer_size - dst_pos);
+            break;
+        }
+
+        if (dst_pos >= buffer_size - 1 || !*t_cur)
+            break;
+
+        // t_cur is now pointing to a '$' character
+        id_type = dash_read_tmpl_id(t_cur, format_tag, sizeof(format_tag), &t_next);
+        switch (id_type) {
+        case DASH_TMPL_ID_ESCAPE:
+            av_strlcpy(&dst[dst_pos], "$", 2);
+            n = 1;
+            break;
+        case DASH_TMPL_ID_REP_ID:
+            n = snprintf(&dst[dst_pos], buffer_size - dst_pos, format_tag, rep_id);
+            break;
+        case DASH_TMPL_ID_NUMBER:
+            n = snprintf(&dst[dst_pos], buffer_size - dst_pos, format_tag, number);
+            break;
+        case DASH_TMPL_ID_BANDWIDTH:
+            n = snprintf(&dst[dst_pos], buffer_size - dst_pos, format_tag, bit_rate);
+            break;
+        case DASH_TMPL_ID_TIME:
+            n = snprintf(&dst[dst_pos], buffer_size - dst_pos, format_tag, time);
+            break;
+        case DASH_TMPL_ID_UNDEFINED:
+            // copy over one byte and advance
+            av_strlcpy(&dst[dst_pos], t_cur, 2);
+            n = 1;
+            t_next = &t_cur[1];
+            break;
+        }
+        // t_next points just past the processed identifier
+        // n is the number of bytes that were attempted to be written to dst
+        // (may have failed to write all because buffer_size).
+
+        // advance
+        dst_pos += FFMIN(n, buffer_size - dst_pos - 1);
+        t_cur = t_next;
+    }
+}
+
+
diff --git a/mythtv/external/FFmpeg/libavformat/dash.h b/mythtv/external/FFmpeg/libavformat/dash.h
new file mode 100644
index 00000000000..c6d9d2c3318
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/dash.h
@@ -0,0 +1,39 @@
+/*
+ * MPEG-DASH ISO BMFF segmenter
+ * Copyright (c) 2014 Martin Storsjo
+ *
+ * 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 AVFORMAT_DASH_H
+#define AVFORMAT_DASH_H
+#include "avformat.h"
+
+// See ISO/IEC 23009-1:2014 5.3.9.4.4
+typedef enum {
+    DASH_TMPL_ID_UNDEFINED = -1,
+    DASH_TMPL_ID_ESCAPE,
+    DASH_TMPL_ID_REP_ID,
+    DASH_TMPL_ID_NUMBER,
+    DASH_TMPL_ID_BANDWIDTH,
+    DASH_TMPL_ID_TIME,
+} DASHTmplId;
+
+
+void ff_dash_fill_tmpl_params(char *dst, size_t buffer_size, const char *template, int rep_id, int number, int bit_rate, int64_t time);
+
+#endif /* AVFORMAT_DASH_H */
diff --git a/mythtv/external/FFmpeg/libavformat/dashdec.c b/mythtv/external/FFmpeg/libavformat/dashdec.c
new file mode 100644
index 00000000000..f63f1fffbd3
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/dashdec.c
@@ -0,0 +1,1848 @@
+/*
+ * Dynamic Adaptive Streaming over HTTP demux
+ * Copyright (c) 2017 samsamsam@o2.pl based on HLS demux
+ * Copyright (c) 2017 Steven Liu
+ *
+ * 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 <libxml/parser.h>
+#include "libavutil/intreadwrite.h"
+#include "libavutil/opt.h"
+#include "libavutil/time.h"
+#include "libavutil/parseutils.h"
+#include "internal.h"
+#include "avio_internal.h"
+#include "dash.h"
+
+#define INITIAL_BUFFER_SIZE 32768
+
+struct fragment {
+    int64_t url_offset;
+    int64_t size;
+    char *url;
+};
+
+/*
+ * reference to : ISO_IEC_23009-1-DASH-2012
+ * Section: 5.3.9.6.2
+ * Table: Table 17 — Semantics of SegmentTimeline element
+ * */
+struct timeline {
+    /* starttime: Element or Attribute Name
+     * specifies the MPD start time, in @timescale units,
+     * the first Segment in the series starts relative to the beginning of the Period.
+     * The value of this attribute must be equal to or greater than the sum of the previous S
+     * element earliest presentation time and the sum of the contiguous Segment durations.
+     * If the value of the attribute is greater than what is expressed by the previous S element,
+     * it expresses discontinuities in the timeline.
+     * If not present then the value shall be assumed to be zero for the first S element
+     * and for the subsequent S elements, the value shall be assumed to be the sum of
+     * the previous S element's earliest presentation time and contiguous duration
+     * (i.e. previous S@starttime + @duration * (@repeat + 1)).
+     * */
+    int64_t starttime;
+    /* repeat: Element or Attribute Name
+     * specifies the repeat count of the number of following contiguous Segments with
+     * the same duration expressed by the value of @duration. This value is zero-based
+     * (e.g. a value of three means four Segments in the contiguous series).
+     * */
+    int64_t repeat;
+    /* duration: Element or Attribute Name
+     * specifies the Segment duration, in units of the value of the @timescale.
+     * */
+    int64_t duration;
+};
+
+/*
+ * Each playlist has its own demuxer. If it is currently active,
+ * it has an opened AVIOContext too, and potentially an AVPacket
+ * containing the next packet from this stream.
+ */
+struct representation {
+    char *url_template;
+    AVIOContext pb;
+    AVIOContext *input;
+    AVFormatContext *parent;
+    AVFormatContext *ctx;
+    AVPacket pkt;
+    int rep_idx;
+    int rep_count;
+    int stream_index;
+
+    enum AVMediaType type;
+
+    int n_fragments;
+    struct fragment **fragments; /* VOD list of fragment for profile */
+
+    int n_timelines;
+    struct timeline **timelines;
+
+    int64_t first_seq_no;
+    int64_t last_seq_no;
+    int64_t start_number; /* used in case when we have dynamic list of segment to know which segments are new one*/
+
+    int64_t fragment_duration;
+    int64_t fragment_timescale;
+
+    int64_t presentation_timeoffset;
+
+    int64_t cur_seq_no;
+    int64_t cur_seg_offset;
+    int64_t cur_seg_size;
+    struct fragment *cur_seg;
+
+    /* Currently active Media Initialization Section */
+    struct fragment *init_section;
+    uint8_t *init_sec_buf;
+    uint32_t init_sec_buf_size;
+    uint32_t init_sec_data_len;
+    uint32_t init_sec_buf_read_offset;
+    int64_t cur_timestamp;
+    int is_restart_needed;
+};
+
+typedef struct DASHContext {
+    const AVClass *class;
+    char *base_url;
+    struct representation *cur_video;
+    struct representation *cur_audio;
+
+    /* MediaPresentationDescription Attribute */
+    uint64_t media_presentation_duration;
+    uint64_t suggested_presentation_delay;
+    uint64_t availability_start_time;
+    uint64_t publish_time;
+    uint64_t minimum_update_period;
+    uint64_t time_shift_buffer_depth;
+    uint64_t min_buffer_time;
+
+    /* Period Attribute */
+    uint64_t period_duration;
+    uint64_t period_start;
+
+    int is_live;
+    AVIOInterruptCB *interrupt_callback;
+    char *user_agent;                    ///< holds HTTP user agent set as an AVOption to the HTTP protocol context
+    char *cookies;                       ///< holds HTTP cookie values set in either the initial response or as an AVOption to the HTTP protocol context
+    char *headers;                       ///< holds HTTP headers set as an AVOption to the HTTP protocol context
+    char *allowed_extensions;
+    AVDictionary *avio_opts;
+} DASHContext;
+
+static uint64_t get_current_time_in_sec(void)
+{
+    return  av_gettime() / 1000000;
+}
+
+static uint64_t get_utc_date_time_insec(AVFormatContext *s, const char *datetime)
+{
+    struct tm timeinfo;
+    int year = 0;
+    int month = 0;
+    int day = 0;
+    int hour = 0;
+    int minute = 0;
+    int ret = 0;
+    float second = 0.0;
+
+    /* ISO-8601 date parser */
+    if (!datetime)
+        return 0;
+
+    ret = sscanf(datetime, "%d-%d-%dT%d:%d:%fZ", &year, &month, &day, &hour, &minute, &second);
+    /* year, month, day, hour, minute, second  6 arguments */
+    if (ret != 6) {
+        av_log(s, AV_LOG_WARNING, "get_utc_date_time_insec get a wrong time format\n");
+    }
+    timeinfo.tm_year = year - 1900;
+    timeinfo.tm_mon  = month - 1;
+    timeinfo.tm_mday = day;
+    timeinfo.tm_hour = hour;
+    timeinfo.tm_min  = minute;
+    timeinfo.tm_sec  = (int)second;
+
+    return av_timegm(&timeinfo);
+}
+
+static uint32_t get_duration_insec(AVFormatContext *s, const char *duration)
+{
+    /* ISO-8601 duration parser */
+    uint32_t days = 0;
+    uint32_t hours = 0;
+    uint32_t mins = 0;
+    uint32_t secs = 0;
+    int size = 0;
+    float value = 0;
+    char type = '\0';
+    const char *ptr = duration;
+
+    while (*ptr) {
+        if (*ptr == 'P' || *ptr == 'T') {
+            ptr++;
+            continue;
+        }
+
+        if (sscanf(ptr, "%f%c%n", &value, &type, &size) != 2) {
+            av_log(s, AV_LOG_WARNING, "get_duration_insec get a wrong time format\n");
+            return 0; /* parser error */
+        }
+        switch (type) {
+            case 'D':
+                days = (uint32_t)value;
+                break;
+            case 'H':
+                hours = (uint32_t)value;
+                break;
+            case 'M':
+                mins = (uint32_t)value;
+                break;
+            case 'S':
+                secs = (uint32_t)value;
+                break;
+            default:
+                // handle invalid type
+                break;
+        }
+        ptr += size;
+    }
+    return  ((days * 24 + hours) * 60 + mins) * 60 + secs;
+}
+
+static int64_t get_segment_start_time_based_on_timeline(struct representation *pls, int64_t cur_seq_no)
+{
+    int64_t start_time = 0;
+    int64_t i = 0;
+    int64_t j = 0;
+    int64_t num = 0;
+
+    if (pls->n_timelines) {
+        for (i = 0; i < pls->n_timelines; i++) {
+            if (pls->timelines[i]->starttime > 0) {
+                start_time = pls->timelines[i]->starttime;
+            }
+            if (num == cur_seq_no)
+                goto finish;
+
+            start_time += pls->timelines[i]->duration;
+            for (j = 0; j < pls->timelines[i]->repeat; j++) {
+                num++;
+                if (num == cur_seq_no)
+                    goto finish;
+                start_time += pls->timelines[i]->duration;
+            }
+            num++;
+        }
+    }
+finish:
+    return start_time;
+}
+
+static int64_t calc_next_seg_no_from_timelines(struct representation *pls, int64_t cur_time)
+{
+    int64_t i = 0;
+    int64_t j = 0;
+    int64_t num = 0;
+    int64_t start_time = 0;
+
+    for (i = 0; i < pls->n_timelines; i++) {
+        if (pls->timelines[i]->starttime > 0) {
+            start_time = pls->timelines[i]->starttime;
+        }
+        if (start_time > cur_time)
+            goto finish;
+
+        start_time += pls->timelines[i]->duration;
+        for (j = 0; j < pls->timelines[i]->repeat; j++) {
+            num++;
+            if (start_time > cur_time)
+                goto finish;
+            start_time += pls->timelines[i]->duration;
+        }
+        num++;
+    }
+
+    return -1;
+
+finish:
+    return num;
+}
+
+static void free_fragment(struct fragment **seg)
+{
+    if (!(*seg)) {
+        return;
+    }
+    av_freep(&(*seg)->url);
+    av_freep(seg);
+}
+
+static void free_fragment_list(struct representation *pls)
+{
+    int i;
+
+    for (i = 0; i < pls->n_fragments; i++) {
+        free_fragment(&pls->fragments[i]);
+    }
+    av_freep(&pls->fragments);
+    pls->n_fragments = 0;
+}
+
+static void free_timelines_list(struct representation *pls)
+{
+    int i;
+
+    for (i = 0; i < pls->n_timelines; i++) {
+        av_freep(&pls->timelines[i]);
+    }
+    av_freep(&pls->timelines);
+    pls->n_timelines = 0;
+}
+
+static void free_representation(struct representation *pls)
+{
+    free_fragment_list(pls);
+    free_timelines_list(pls);
+    free_fragment(&pls->cur_seg);
+    free_fragment(&pls->init_section);
+    av_freep(&pls->init_sec_buf);
+    av_freep(&pls->pb.buffer);
+    if (pls->input)
+        ff_format_io_close(pls->parent, &pls->input);
+    if (pls->ctx) {
+        pls->ctx->pb = NULL;
+        avformat_close_input(&pls->ctx);
+    }
+
+    av_freep(&pls->url_template);
+    av_freep(pls);
+}
+
+static void set_httpheader_options(DASHContext *c, AVDictionary *opts)
+{
+    // broker prior HTTP options that should be consistent across requests
+    av_dict_set(&opts, "user-agent", c->user_agent, 0);
+    av_dict_set(&opts, "cookies", c->cookies, 0);
+    av_dict_set(&opts, "headers", c->headers, 0);
+    if (c->is_live) {
+        av_dict_set(&opts, "seekable", "0", 0);
+    }
+}
+static void update_options(char **dest, const char *name, void *src)
+{
+    av_freep(dest);
+    av_opt_get(src, name, AV_OPT_SEARCH_CHILDREN, (uint8_t**)dest);
+    if (*dest)
+        av_freep(dest);
+}
+
+static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url,
+                    AVDictionary *opts, AVDictionary *opts2, int *is_http)
+{
+    DASHContext *c = s->priv_data;
+    AVDictionary *tmp = NULL;
+    const char *proto_name = NULL;
+    int ret;
+
+    av_dict_copy(&tmp, opts, 0);
+    av_dict_copy(&tmp, opts2, 0);
+
+    if (av_strstart(url, "crypto", NULL)) {
+        if (url[6] == '+' || url[6] == ':')
+            proto_name = avio_find_protocol_name(url + 7);
+    }
+
+    if (!proto_name)
+        proto_name = avio_find_protocol_name(url);
+
+    if (!proto_name)
+        return AVERROR_INVALIDDATA;
+
+    // only http(s) & file are allowed
+    if (av_strstart(proto_name, "file", NULL)) {
+        if (strcmp(c->allowed_extensions, "ALL") && !av_match_ext(url, c->allowed_extensions)) {
+            av_log(s, AV_LOG_ERROR,
+                "Filename extension of \'%s\' is not a common multimedia extension, blocked for security reasons.\n"
+                "If you wish to override this adjust allowed_extensions, you can set it to \'ALL\' to allow all\n",
+                url);
+            return AVERROR_INVALIDDATA;
+        }
+    } else if (av_strstart(proto_name, "http", NULL)) {
+        ;
+    } else
+        return AVERROR_INVALIDDATA;
+
+    if (!strncmp(proto_name, url, strlen(proto_name)) && url[strlen(proto_name)] == ':')
+        ;
+    else if (av_strstart(url, "crypto", NULL) && !strncmp(proto_name, url + 7, strlen(proto_name)) && url[7 + strlen(proto_name)] == ':')
+        ;
+    else if (strcmp(proto_name, "file") || !strncmp(url, "file,", 5))
+        return AVERROR_INVALIDDATA;
+
+    ret = s->io_open(s, pb, url, AVIO_FLAG_READ, &tmp);
+    if (ret >= 0) {
+        // update cookies on http response with setcookies.
+        char *new_cookies = NULL;
+
+        if (!(s->flags & AVFMT_FLAG_CUSTOM_IO))
+            av_opt_get(*pb, "cookies", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&new_cookies);
+
+        if (new_cookies) {
+            av_free(c->cookies);
+            c->cookies = new_cookies;
+        }
+
+        av_dict_set(&opts, "cookies", c->cookies, 0);
+    }
+
+    av_dict_free(&tmp);
+
+    if (is_http)
+        *is_http = av_strstart(proto_name, "http", NULL);
+
+    return ret;
+}
+
+static char *get_content_url(xmlNodePtr *baseurl_nodes,
+                             int n_baseurl_nodes,
+                             char *rep_id_val,
+                             char *rep_bandwidth_val,
+                             char *val)
+{
+    int i;
+    char *text;
+    char *url = NULL;
+    char tmp_str[MAX_URL_SIZE];
+    char tmp_str_2[MAX_URL_SIZE];
+
+    memset(tmp_str, 0, sizeof(tmp_str));
+
+    for (i = 0; i < n_baseurl_nodes; ++i) {
+        if (baseurl_nodes[i] &&
+            baseurl_nodes[i]->children &&
+            baseurl_nodes[i]->children->type == XML_TEXT_NODE) {
+            text = xmlNodeGetContent(baseurl_nodes[i]->children);
+            if (text) {
+                memset(tmp_str, 0, sizeof(tmp_str));
+                memset(tmp_str_2, 0, sizeof(tmp_str_2));
+                ff_make_absolute_url(tmp_str_2, MAX_URL_SIZE, tmp_str, text);
+                av_strlcpy(tmp_str, tmp_str_2, sizeof(tmp_str));
+                xmlFree(text);
+            }
+        }
+    }
+
+    if (val)
+        av_strlcat(tmp_str, (const char*)val, sizeof(tmp_str));
+
+    if (rep_id_val) {
+        url = av_strireplace(tmp_str, "$RepresentationID$", (const char*)rep_id_val);
+        if (!url) {
+            return NULL;
+        }
+        av_strlcpy(tmp_str, url, sizeof(tmp_str));
+        av_free(url);
+    }
+    if (rep_bandwidth_val && tmp_str[0] != '\0') {
+        url = av_strireplace(tmp_str, "$Bandwidth$", (const char*)rep_bandwidth_val);
+        if (!url) {
+            return NULL;
+        }
+    }
+    return url;
+}
+
+static char *get_val_from_nodes_tab(xmlNodePtr *nodes, const int n_nodes, const char *attrname)
+{
+    int i;
+    char *val;
+
+    for (i = 0; i < n_nodes; ++i) {
+        if (nodes[i]) {
+            val = xmlGetProp(nodes[i], attrname);
+            if (val)
+                return val;
+        }
+    }
+
+    return NULL;
+}
+
+static xmlNodePtr find_child_node_by_name(xmlNodePtr rootnode, const char *nodename)
+{
+    xmlNodePtr node = rootnode;
+    if (!node) {
+        return NULL;
+    }
+
+    node = xmlFirstElementChild(node);
+    while (node) {
+        if (!av_strcasecmp(node->name, nodename)) {
+            return node;
+        }
+        node = xmlNextElementSibling(node);
+    }
+    return NULL;
+}
+
+static enum AVMediaType get_content_type(xmlNodePtr node)
+{
+    enum AVMediaType type = AVMEDIA_TYPE_UNKNOWN;
+    int i = 0;
+    const char *attr;
+    char *val = NULL;
+
+    if (node) {
+        for (i = 0; i < 2; i++) {
+            attr = i ? "mimeType" : "contentType";
+            val = xmlGetProp(node, attr);
+            if (val) {
+                if (av_stristr((const char *)val, "video")) {
+                    type = AVMEDIA_TYPE_VIDEO;
+                } else if (av_stristr((const char *)val, "audio")) {
+                    type = AVMEDIA_TYPE_AUDIO;
+                }
+                xmlFree(val);
+            }
+        }
+    }
+    return type;
+}
+
+static int parse_manifest_segmenturlnode(AVFormatContext *s, struct representation *rep,
+                                         xmlNodePtr fragmenturl_node,
+                                         xmlNodePtr *baseurl_nodes,
+                                         char *rep_id_val,
+                                         char *rep_bandwidth_val)
+{
+    char *initialization_val = NULL;
+    char *media_val = NULL;
+
+    if (!av_strcasecmp(fragmenturl_node->name, (const char *)"Initialization")) {
+        initialization_val = xmlGetProp(fragmenturl_node, "sourceURL");
+        if (initialization_val) {
+            rep->init_section = av_mallocz(sizeof(struct fragment));
+            if (!rep->init_section) {
+                xmlFree(initialization_val);
+                return AVERROR(ENOMEM);
+            }
+            rep->init_section->url = get_content_url(baseurl_nodes, 4,
+                                                     rep_id_val,
+                                                     rep_bandwidth_val,
+                                                     initialization_val);
+            if (!rep->init_section->url) {
+                av_free(rep->init_section);
+                xmlFree(initialization_val);
+                return AVERROR(ENOMEM);
+            }
+            rep->init_section->size = -1;
+            xmlFree(initialization_val);
+        }
+    } else if (!av_strcasecmp(fragmenturl_node->name, (const char *)"SegmentURL")) {
+        media_val = xmlGetProp(fragmenturl_node, "media");
+        if (media_val) {
+            struct fragment *seg = av_mallocz(sizeof(struct fragment));
+            if (!seg) {
+                xmlFree(media_val);
+                return AVERROR(ENOMEM);
+            }
+            seg->url = get_content_url(baseurl_nodes, 4,
+                                       rep_id_val,
+                                       rep_bandwidth_val,
+                                       media_val);
+            if (!seg->url) {
+                av_free(seg);
+                xmlFree(media_val);
+                return AVERROR(ENOMEM);
+            }
+            seg->size = -1;
+            dynarray_add(&rep->fragments, &rep->n_fragments, seg);
+            xmlFree(media_val);
+        }
+    }
+
+    return 0;
+}
+
+static int parse_manifest_segmenttimeline(AVFormatContext *s, struct representation *rep,
+                                          xmlNodePtr fragment_timeline_node)
+{
+    xmlAttrPtr attr = NULL;
+    char *val  = NULL;
+
+    if (!av_strcasecmp(fragment_timeline_node->name, (const char *)"S")) {
+        struct timeline *tml = av_mallocz(sizeof(struct timeline));
+        if (!tml) {
+            return AVERROR(ENOMEM);
+        }
+        attr = fragment_timeline_node->properties;
+        while (attr) {
+            val = xmlGetProp(fragment_timeline_node, attr->name);
+
+            if (!val) {
+                av_log(s, AV_LOG_WARNING, "parse_manifest_segmenttimeline attr->name = %s val is NULL\n", attr->name);
+                continue;
+            }
+
+            if (!av_strcasecmp(attr->name, (const char *)"t")) {
+                tml->starttime = (int64_t)strtoll(val, NULL, 10);
+            } else if (!av_strcasecmp(attr->name, (const char *)"r")) {
+                tml->repeat =(int64_t) strtoll(val, NULL, 10);
+            } else if (!av_strcasecmp(attr->name, (const char *)"d")) {
+                tml->duration = (int64_t)strtoll(val, NULL, 10);
+            }
+            attr = attr->next;
+            xmlFree(val);
+        }
+        dynarray_add(&rep->timelines, &rep->n_timelines, tml);
+    }
+
+    return 0;
+}
+
+static int parse_manifest_representation(AVFormatContext *s, const char *url,
+                                         xmlNodePtr node,
+                                         xmlNodePtr adaptionset_node,
+                                         xmlNodePtr mpd_baseurl_node,
+                                         xmlNodePtr period_baseurl_node,
+                                         xmlNodePtr fragment_template_node,
+                                         xmlNodePtr content_component_node,
+                                         xmlNodePtr adaptionset_baseurl_node)
+{
+    int32_t ret = 0;
+    int32_t audio_rep_idx = 0;
+    int32_t video_rep_idx = 0;
+    DASHContext *c = s->priv_data;
+    struct representation *rep = NULL;
+    struct fragment *seg = NULL;
+    xmlNodePtr representation_segmenttemplate_node = NULL;
+    xmlNodePtr representation_baseurl_node = NULL;
+    xmlNodePtr representation_segmentlist_node = NULL;
+    xmlNodePtr fragment_timeline_node = NULL;
+    xmlNodePtr fragment_templates_tab[2];
+    char *duration_val = NULL;
+    char *presentation_timeoffset_val = NULL;
+    char *startnumber_val = NULL;
+    char *timescale_val = NULL;
+    char *initialization_val = NULL;
+    char *media_val = NULL;
+    xmlNodePtr baseurl_nodes[4];
+    xmlNodePtr representation_node = node;
+    char *rep_id_val = xmlGetProp(representation_node, "id");
+    char *rep_bandwidth_val = xmlGetProp(representation_node, "bandwidth");
+    enum AVMediaType type = AVMEDIA_TYPE_UNKNOWN;
+
+    // try get information from representation
+    if (type == AVMEDIA_TYPE_UNKNOWN)
+        type = get_content_type(representation_node);
+    // try get information from contentComponen
+    if (type == AVMEDIA_TYPE_UNKNOWN)
+        type = get_content_type(content_component_node);
+    // try get information from adaption set
+    if (type == AVMEDIA_TYPE_UNKNOWN)
+        type = get_content_type(adaptionset_node);
+    if (type == AVMEDIA_TYPE_UNKNOWN) {
+        av_log(s, AV_LOG_VERBOSE, "Parsing '%s' - skipp not supported representation type\n", url);
+    } else if ((type == AVMEDIA_TYPE_VIDEO && !c->cur_video) || (type == AVMEDIA_TYPE_AUDIO && !c->cur_audio)) {
+        // convert selected representation to our internal struct
+        rep = av_mallocz(sizeof(struct representation));
+        if (!rep) {
+            ret = AVERROR(ENOMEM);
+            goto end;
+        }
+        representation_segmenttemplate_node = find_child_node_by_name(representation_node, "SegmentTemplate");
+        representation_baseurl_node = find_child_node_by_name(representation_node, "BaseURL");
+        representation_segmentlist_node = find_child_node_by_name(representation_node, "SegmentList");
+
+        baseurl_nodes[0] = mpd_baseurl_node;
+        baseurl_nodes[1] = period_baseurl_node;
+        baseurl_nodes[2] = adaptionset_baseurl_node;
+        baseurl_nodes[3] = representation_baseurl_node;
+
+        if (representation_segmenttemplate_node || fragment_template_node) {
+            fragment_timeline_node = NULL;
+            fragment_templates_tab[0] = representation_segmenttemplate_node;
+            fragment_templates_tab[1] = fragment_template_node;
+
+            presentation_timeoffset_val = get_val_from_nodes_tab(fragment_templates_tab, 2, "presentationTimeOffset");
+            duration_val = get_val_from_nodes_tab(fragment_templates_tab, 2, "duration");
+            startnumber_val = get_val_from_nodes_tab(fragment_templates_tab, 2, "startNumber");
+            timescale_val = get_val_from_nodes_tab(fragment_templates_tab, 2, "timescale");
+            initialization_val = get_val_from_nodes_tab(fragment_templates_tab, 2, "initialization");
+            media_val = get_val_from_nodes_tab(fragment_templates_tab, 2, "media");
+
+            if (initialization_val) {
+                rep->init_section = av_mallocz(sizeof(struct fragment));
+                if (!rep->init_section) {
+                    av_free(rep);
+                    ret = AVERROR(ENOMEM);
+                    goto end;
+                }
+                rep->init_section->url = get_content_url(baseurl_nodes, 4, rep_id_val, rep_bandwidth_val, initialization_val);
+                if (!rep->init_section->url) {
+                    av_free(rep->init_section);
+                    av_free(rep);
+                    ret = AVERROR(ENOMEM);
+                    goto end;
+                }
+                rep->init_section->size = -1;
+                xmlFree(initialization_val);
+            }
+
+            if (media_val) {
+                rep->url_template = get_content_url(baseurl_nodes, 4, rep_id_val, rep_bandwidth_val, media_val);
+                xmlFree(media_val);
+            }
+
+            if (presentation_timeoffset_val) {
+                rep->presentation_timeoffset = (int64_t) strtoll(presentation_timeoffset_val, NULL, 10);
+                xmlFree(presentation_timeoffset_val);
+            }
+            if (duration_val) {
+                rep->fragment_duration = (int64_t) strtoll(duration_val, NULL, 10);
+                xmlFree(duration_val);
+            }
+            if (timescale_val) {
+                rep->fragment_timescale = (int64_t) strtoll(timescale_val, NULL, 10);
+                xmlFree(timescale_val);
+            }
+            if (startnumber_val) {
+                rep->first_seq_no = (int64_t) strtoll(startnumber_val, NULL, 10);
+                xmlFree(startnumber_val);
+            }
+
+            fragment_timeline_node = find_child_node_by_name(representation_segmenttemplate_node, "SegmentTimeline");
+
+            if (!fragment_timeline_node)
+                fragment_timeline_node = find_child_node_by_name(fragment_template_node, "SegmentTimeline");
+            if (fragment_timeline_node) {
+                fragment_timeline_node = xmlFirstElementChild(fragment_timeline_node);
+                while (fragment_timeline_node) {
+                    ret = parse_manifest_segmenttimeline(s, rep, fragment_timeline_node);
+                    if (ret < 0) {
+                        return ret;
+                    }
+                    fragment_timeline_node = xmlNextElementSibling(fragment_timeline_node);
+                }
+            }
+        } else if (representation_baseurl_node && !representation_segmentlist_node) {
+            seg = av_mallocz(sizeof(struct fragment));
+            if (!seg) {
+                ret = AVERROR(ENOMEM);
+                goto end;
+            }
+            seg->url = get_content_url(baseurl_nodes, 4, rep_id_val, rep_bandwidth_val, NULL);
+            if (!seg->url) {
+                av_free(seg);
+                ret = AVERROR(ENOMEM);
+                goto end;
+            }
+            seg->size = -1;
+            dynarray_add(&rep->fragments, &rep->n_fragments, seg);
+        } else if (representation_segmentlist_node) {
+            // TODO: https://www.brendanlong.com/the-structure-of-an-mpeg-dash-mpd.html
+            // http://www-itec.uni-klu.ac.at/dash/ddash/mpdGenerator.php?fragmentlength=15&type=full
+            xmlNodePtr fragmenturl_node = NULL;
+            duration_val = xmlGetProp(representation_segmentlist_node, "duration");
+            timescale_val = xmlGetProp(representation_segmentlist_node, "timescale");
+            if (duration_val) {
+                rep->fragment_duration = (int64_t) strtoll(duration_val, NULL, 10);
+                xmlFree(duration_val);
+            }
+            if (timescale_val) {
+                rep->fragment_timescale = (int64_t) strtoll(timescale_val, NULL, 10);
+                xmlFree(timescale_val);
+            }
+            fragmenturl_node = xmlFirstElementChild(representation_segmentlist_node);
+            while (fragmenturl_node) {
+                ret = parse_manifest_segmenturlnode(s, rep, fragmenturl_node,
+                                                    baseurl_nodes,
+                                                    rep_id_val,
+                                                    rep_bandwidth_val);
+                if (ret < 0) {
+                    return ret;
+                }
+                fragmenturl_node = xmlNextElementSibling(fragmenturl_node);
+            }
+
+            fragment_timeline_node = find_child_node_by_name(representation_segmenttemplate_node, "SegmentTimeline");
+
+            if (!fragment_timeline_node)
+                fragment_timeline_node = find_child_node_by_name(fragment_template_node, "SegmentTimeline");
+            if (fragment_timeline_node) {
+                fragment_timeline_node = xmlFirstElementChild(fragment_timeline_node);
+                while (fragment_timeline_node) {
+                    ret = parse_manifest_segmenttimeline(s, rep, fragment_timeline_node);
+                    if (ret < 0) {
+                        return ret;
+                    }
+                    fragment_timeline_node = xmlNextElementSibling(fragment_timeline_node);
+                }
+            }
+        } else {
+            free_representation(rep);
+            rep = NULL;
+            av_log(s, AV_LOG_ERROR, "Unknown format of Representation node id[%s] \n", (const char *)rep_id_val);
+        }
+
+        if (rep) {
+            if (rep->fragment_duration > 0 && !rep->fragment_timescale)
+                rep->fragment_timescale = 1;
+            if (type == AVMEDIA_TYPE_VIDEO) {
+                rep->rep_idx = video_rep_idx;
+                c->cur_video = rep;
+            } else {
+                rep->rep_idx = audio_rep_idx;
+                c->cur_audio = rep;
+            }
+        }
+    }
+
+    video_rep_idx += type == AVMEDIA_TYPE_VIDEO;
+    audio_rep_idx += type == AVMEDIA_TYPE_AUDIO;
+
+end:
+    if (rep_id_val)
+        xmlFree(rep_id_val);
+    if (rep_bandwidth_val)
+        xmlFree(rep_bandwidth_val);
+
+    return ret;
+}
+
+static int parse_manifest_adaptationset(AVFormatContext *s, const char *url,
+                                        xmlNodePtr adaptionset_node,
+                                        xmlNodePtr mpd_baseurl_node,
+                                        xmlNodePtr period_baseurl_node)
+{
+    int ret = 0;
+    xmlNodePtr fragment_template_node = NULL;
+    xmlNodePtr content_component_node = NULL;
+    xmlNodePtr adaptionset_baseurl_node = NULL;
+    xmlNodePtr node = NULL;
+
+    node = xmlFirstElementChild(adaptionset_node);
+    while (node) {
+        if (!av_strcasecmp(node->name, (const char *)"SegmentTemplate")) {
+            fragment_template_node = node;
+        } else if (!av_strcasecmp(node->name, (const char *)"ContentComponent")) {
+            content_component_node = node;
+        } else if (!av_strcasecmp(node->name, (const char *)"BaseURL")) {
+            adaptionset_baseurl_node = node;
+        } else if (!av_strcasecmp(node->name, (const char *)"Representation")) {
+            ret = parse_manifest_representation(s, url, node,
+                                                adaptionset_node,
+                                                mpd_baseurl_node,
+                                                period_baseurl_node,
+                                                fragment_template_node,
+                                                content_component_node,
+                                                adaptionset_baseurl_node);
+            if (ret < 0) {
+                return ret;
+            }
+        }
+        node = xmlNextElementSibling(node);
+    }
+    return 0;
+}
+
+static int parse_manifest(AVFormatContext *s, const char *url, AVIOContext *in)
+{
+    DASHContext *c = s->priv_data;
+    int ret = 0;
+    int close_in = 0;
+    uint8_t *new_url = NULL;
+    int64_t filesize = 0;
+    char *buffer = NULL;
+    AVDictionary *opts = NULL;
+    xmlDoc *doc = NULL;
+    xmlNodePtr root_element = NULL;
+    xmlNodePtr node = NULL;
+    xmlNodePtr period_node = NULL;
+    xmlNodePtr mpd_baseurl_node = NULL;
+    xmlNodePtr period_baseurl_node = NULL;
+    xmlNodePtr adaptionset_node = NULL;
+    xmlAttrPtr attr = NULL;
+    char *val  = NULL;
+    uint32_t perdiod_duration_sec = 0;
+    uint32_t perdiod_start_sec = 0;
+    int32_t audio_rep_idx = 0;
+    int32_t video_rep_idx = 0;
+
+    if (!in) {
+        close_in = 1;
+
+        set_httpheader_options(c, opts);
+        ret = avio_open2(&in, url, AVIO_FLAG_READ, c->interrupt_callback, &opts);
+        av_dict_free(&opts);
+        if (ret < 0)
+            return ret;
+    }
+
+    if (av_opt_get(in, "location", AV_OPT_SEARCH_CHILDREN, &new_url) >= 0) {
+        c->base_url = av_strdup(new_url);
+    } else {
+        c->base_url = av_strdup(url);
+    }
+
+    filesize = avio_size(in);
+    if (filesize <= 0) {
+        filesize = 8 * 1024;
+    }
+
+    buffer = av_mallocz(filesize);
+    if (!buffer) {
+        av_free(c->base_url);
+        return AVERROR(ENOMEM);
+    }
+
+    filesize = avio_read(in, buffer, filesize);
+    if (filesize <= 0) {
+        av_log(s, AV_LOG_ERROR, "Unable to read to offset '%s'\n", url);
+        ret = AVERROR_INVALIDDATA;
+    } else {
+        LIBXML_TEST_VERSION
+
+        doc = xmlReadMemory(buffer, filesize, c->base_url, NULL, 0);
+        root_element = xmlDocGetRootElement(doc);
+        node = root_element;
+
+        if (!node) {
+            ret = AVERROR_INVALIDDATA;
+            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing root node\n", url);
+            goto cleanup;
+        }
+
+        if (node->type != XML_ELEMENT_NODE ||
+            av_strcasecmp(node->name, (const char *)"MPD")) {
+            ret = AVERROR_INVALIDDATA;
+            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - wrong root node name[%s] type[%d]\n", url, node->name, (int)node->type);
+            goto cleanup;
+        }
+
+        val = xmlGetProp(node, "type");
+        if (!val) {
+            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing type attrib\n", url);
+            ret = AVERROR_INVALIDDATA;
+            goto cleanup;
+        }
+        if (!av_strcasecmp(val, (const char *)"dynamic"))
+            c->is_live = 1;
+        xmlFree(val);
+
+        attr = node->properties;
+        while (attr) {
+            val = xmlGetProp(node, attr->name);
+
+            if (!av_strcasecmp(attr->name, (const char *)"availabilityStartTime")) {
+                c->availability_start_time = get_utc_date_time_insec(s, (const char *)val);
+            } else if (!av_strcasecmp(attr->name, (const char *)"publishTime")) {
+                c->publish_time = get_utc_date_time_insec(s, (const char *)val);
+            } else if (!av_strcasecmp(attr->name, (const char *)"minimumUpdatePeriod")) {
+                c->minimum_update_period = get_duration_insec(s, (const char *)val);
+            } else if (!av_strcasecmp(attr->name, (const char *)"timeShiftBufferDepth")) {
+                c->time_shift_buffer_depth = get_duration_insec(s, (const char *)val);
+            } else if (!av_strcasecmp(attr->name, (const char *)"minBufferTime")) {
+                c->min_buffer_time = get_duration_insec(s, (const char *)val);
+            } else if (!av_strcasecmp(attr->name, (const char *)"suggestedPresentationDelay")) {
+                c->suggested_presentation_delay = get_duration_insec(s, (const char *)val);
+            } else if (!av_strcasecmp(attr->name, (const char *)"mediaPresentationDuration")) {
+                c->media_presentation_duration = get_duration_insec(s, (const char *)val);
+            }
+            attr = attr->next;
+            xmlFree(val);
+        }
+
+        mpd_baseurl_node = find_child_node_by_name(node, "BaseURL");
+
+        // at now we can handle only one period, with the longest duration
+        node = xmlFirstElementChild(node);
+        while (node) {
+            if (!av_strcasecmp(node->name, (const char *)"Period")) {
+                perdiod_duration_sec = 0;
+                perdiod_start_sec = 0;
+                attr = node->properties;
+                while (attr) {
+                    val = xmlGetProp(node, attr->name);
+                    if (!av_strcasecmp(attr->name, (const char *)"duration")) {
+                        perdiod_duration_sec = get_duration_insec(s, (const char *)val);
+                    } else if (!av_strcasecmp(attr->name, (const char *)"start")) {
+                        perdiod_start_sec = get_duration_insec(s, (const char *)val);
+                    }
+                    attr = attr->next;
+                    xmlFree(val);
+                }
+                if ((perdiod_duration_sec) >= (c->period_duration)) {
+                    period_node = node;
+                    c->period_duration = perdiod_duration_sec;
+                    c->period_start = perdiod_start_sec;
+                    if (c->period_start > 0)
+                        c->media_presentation_duration = c->period_duration;
+                }
+            }
+            node = xmlNextElementSibling(node);
+        }
+        if (!period_node) {
+            av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing Period node\n", url);
+            ret = AVERROR_INVALIDDATA;
+            goto cleanup;
+        }
+
+        adaptionset_node = xmlFirstElementChild(period_node);
+        while (adaptionset_node) {
+            if (!av_strcasecmp(adaptionset_node->name, (const char *)"BaseURL")) {
+                period_baseurl_node = adaptionset_node;
+            } else if (!av_strcasecmp(adaptionset_node->name, (const char *)"AdaptationSet")) {
+                parse_manifest_adaptationset(s, url, adaptionset_node, mpd_baseurl_node, period_baseurl_node);
+            }
+            adaptionset_node = xmlNextElementSibling(adaptionset_node);
+        }
+        if (c->cur_video) {
+            c->cur_video->rep_count = video_rep_idx;
+            av_log(s, AV_LOG_VERBOSE, "rep_idx[%d]\n", (int)c->cur_video->rep_idx);
+            av_log(s, AV_LOG_VERBOSE, "rep_count[%d]\n", (int)video_rep_idx);
+        }
+        if (c->cur_audio) {
+            c->cur_audio->rep_count = audio_rep_idx;
+        }
+cleanup:
+        /*free the document */
+        xmlFreeDoc(doc);
+        xmlCleanupParser();
+    }
+
+    av_free(new_url);
+    av_free(buffer);
+    if (close_in) {
+        avio_close(in);
+    }
+    return ret;
+}
+
+static int64_t calc_cur_seg_no(AVFormatContext *s, struct representation *pls)
+{
+    DASHContext *c = s->priv_data;
+    int64_t num = 0;
+    int64_t start_time_offset = 0;
+
+    if (c->is_live) {
+        if (pls->n_fragments) {
+            num = pls->first_seq_no;
+        } else if (pls->n_timelines) {
+            start_time_offset = get_segment_start_time_based_on_timeline(pls, 0xFFFFFFFF) - pls->timelines[pls->first_seq_no]->starttime; // total duration of playlist
+            if (start_time_offset < 60 * pls->fragment_timescale)
+                start_time_offset = 0;
+            else
+                start_time_offset = start_time_offset - 60 * pls->fragment_timescale;
+
+            num = calc_next_seg_no_from_timelines(pls, pls->timelines[pls->first_seq_no]->starttime + start_time_offset);
+            if (num == -1)
+                num = pls->first_seq_no;
+        } else if (pls->fragment_duration){
+            if (pls->presentation_timeoffset) {
+                num = pls->presentation_timeoffset * pls->fragment_timescale / pls->fragment_duration;
+            } else if (c->publish_time > 0 && !c->availability_start_time) {
+                num = pls->first_seq_no + (((c->publish_time - c->availability_start_time) - c->suggested_presentation_delay) * pls->fragment_timescale) / pls->fragment_duration;
+            } else {
+                num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time) - c->suggested_presentation_delay) * pls->fragment_timescale) / pls->fragment_duration;
+            }
+        }
+    } else {
+        num = pls->first_seq_no;
+    }
+    return num;
+}
+
+static int64_t calc_min_seg_no(AVFormatContext *s, struct representation *pls)
+{
+    DASHContext *c = s->priv_data;
+    int64_t num = 0;
+
+    if (c->is_live && pls->fragment_duration) {
+        num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time) - c->time_shift_buffer_depth) * pls->fragment_timescale) / pls->fragment_duration;
+    } else {
+        num = pls->first_seq_no;
+    }
+    return num;
+}
+
+static int64_t calc_max_seg_no(struct representation *pls)
+{
+    DASHContext *c = pls->parent->priv_data;
+    int64_t num = 0;
+
+    if (pls->n_fragments) {
+        num = pls->first_seq_no + pls->n_fragments - 1;
+    } else if (pls->n_timelines) {
+        int i = 0;
+        num = pls->first_seq_no + pls->n_timelines - 1;
+        for (i = 0; i < pls->n_timelines; i++) {
+            num += pls->timelines[i]->repeat;
+        }
+    } else if (c->is_live && pls->fragment_duration) {
+        num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time)) * pls->fragment_timescale)  / pls->fragment_duration;
+    } else if (pls->fragment_duration) {
+        num = pls->first_seq_no + (c->media_presentation_duration * pls->fragment_timescale) / pls->fragment_duration;
+    }
+
+    return num;
+}
+
+static void move_timelines(struct representation *rep_src, struct representation *rep_dest)
+{
+    if (rep_dest && rep_src ) {
+        free_timelines_list(rep_dest);
+        rep_dest->timelines    = rep_src->timelines;
+        rep_dest->n_timelines  = rep_src->n_timelines;
+        rep_dest->first_seq_no = rep_src->first_seq_no;
+        rep_dest->last_seq_no = calc_max_seg_no(rep_dest);
+        rep_src->timelines = NULL;
+        rep_src->n_timelines = 0;
+        rep_dest->cur_seq_no = rep_src->cur_seq_no;
+    }
+}
+
+static void move_segments(struct representation *rep_src, struct representation *rep_dest)
+{
+    if (rep_dest && rep_src ) {
+        free_fragment_list(rep_dest);
+        if (rep_src->start_number > (rep_dest->start_number + rep_dest->n_fragments))
+            rep_dest->cur_seq_no = 0;
+        else
+            rep_dest->cur_seq_no += rep_src->start_number - rep_dest->start_number;
+        rep_dest->fragments    = rep_src->fragments;
+        rep_dest->n_fragments  = rep_src->n_fragments;
+        rep_dest->parent  = rep_src->parent;
+        rep_dest->last_seq_no = calc_max_seg_no(rep_dest);
+        rep_src->fragments = NULL;
+        rep_src->n_fragments = 0;
+    }
+}
+
+
+static int refresh_manifest(AVFormatContext *s)
+{
+
+    int ret = 0;
+    DASHContext *c = s->priv_data;
+
+    // save current context
+    struct representation *cur_video =  c->cur_video;
+    struct representation *cur_audio =  c->cur_audio;
+    char *base_url = c->base_url;
+
+    c->base_url = NULL;
+    c->cur_video = NULL;
+    c->cur_audio = NULL;
+    ret = parse_manifest(s, s->filename, NULL);
+    if (ret)
+        goto finish;
+
+    if (cur_video && cur_video->timelines || cur_audio && cur_audio->timelines) {
+        // calc current time
+        int64_t currentVideoTime = 0;
+        int64_t currentAudioTime = 0;
+        if (cur_video && cur_video->timelines)
+            currentVideoTime = get_segment_start_time_based_on_timeline(cur_video, cur_video->cur_seq_no) / cur_video->fragment_timescale;
+        if (cur_audio && cur_audio->timelines)
+            currentAudioTime = get_segment_start_time_based_on_timeline(cur_audio, cur_audio->cur_seq_no) / cur_audio->fragment_timescale;
+        // update segments
+        if (cur_video && cur_video->timelines) {
+            c->cur_video->cur_seq_no = calc_next_seg_no_from_timelines(c->cur_video, currentVideoTime * cur_video->fragment_timescale - 1);
+            if (c->cur_video->cur_seq_no >= 0) {
+                move_timelines(c->cur_video, cur_video);
+            }
+        }
+        if (cur_audio && cur_audio->timelines) {
+            c->cur_audio->cur_seq_no = calc_next_seg_no_from_timelines(c->cur_audio, currentAudioTime * cur_audio->fragment_timescale - 1);
+            if (c->cur_audio->cur_seq_no >= 0) {
+               move_timelines(c->cur_audio, cur_audio);
+            }
+        }
+    }
+    if (cur_video && cur_video->fragments) {
+        move_segments(c->cur_video, cur_video);
+    }
+    if (cur_audio && cur_audio->fragments) {
+        move_segments(c->cur_audio, cur_audio);
+    }
+
+finish:
+    // restore context
+    if (c->base_url)
+        av_free(base_url);
+    else
+        c->base_url  = base_url;
+    if (c->cur_audio)
+        free_representation(c->cur_audio);
+    if (c->cur_video)
+        free_representation(c->cur_video);
+    c->cur_audio = cur_audio;
+    c->cur_video = cur_video;
+    return ret;
+}
+
+static struct fragment *get_current_fragment(struct representation *pls)
+{
+    int64_t min_seq_no = 0;
+    int64_t max_seq_no = 0;
+    struct fragment *seg = NULL;
+    struct fragment *seg_ptr = NULL;
+    DASHContext *c = pls->parent->priv_data;
+
+    while (( !ff_check_interrupt(c->interrupt_callback)&& pls->n_fragments > 0)) {
+        if (pls->cur_seq_no < pls->n_fragments) {
+            seg_ptr = pls->fragments[pls->cur_seq_no];
+            seg = av_mallocz(sizeof(struct fragment));
+            if (!seg) {
+                return NULL;
+            }
+            seg->url = av_strdup(seg_ptr->url);
+            if (!seg->url) {
+                av_free(seg);
+                return NULL;
+            }
+            seg->size = seg_ptr->size;
+            seg->url_offset = seg_ptr->url_offset;
+            return seg;
+        } else if (c->is_live) {
+            refresh_manifest(pls->parent);
+        } else {
+            break;
+        }
+    }
+    if (c->is_live) {
+        min_seq_no = calc_min_seg_no(pls->parent, pls);
+        max_seq_no = calc_max_seg_no(pls);
+
+        if (pls->timelines || pls->fragments) {
+            refresh_manifest(pls->parent);
+        }
+        if (pls->cur_seq_no <= min_seq_no) {
+            av_log(pls->parent, AV_LOG_VERBOSE, "old fragment: cur[%"PRId64"] min[%"PRId64"] max[%"PRId64"], playlist %d\n", (int64_t)pls->cur_seq_no, min_seq_no, max_seq_no, (int)pls->rep_idx);
+            pls->cur_seq_no = calc_cur_seg_no(pls->parent, pls);
+        } else if (pls->cur_seq_no > max_seq_no) {
+            av_log(pls->parent, AV_LOG_VERBOSE, "new fragment: min[%"PRId64"] max[%"PRId64"], playlist %d\n", min_seq_no, max_seq_no, (int)pls->rep_idx);
+        }
+        seg = av_mallocz(sizeof(struct fragment));
+        if (!seg) {
+            return NULL;
+        }
+    } else if (pls->cur_seq_no <= pls->last_seq_no) {
+        seg = av_mallocz(sizeof(struct fragment));
+        if (!seg) {
+            return NULL;
+        }
+    }
+    if (seg) {
+        char tmpfilename[MAX_URL_SIZE];
+
+        ff_dash_fill_tmpl_params(tmpfilename, sizeof(tmpfilename), pls->url_template, 0, pls->cur_seq_no, 0, get_segment_start_time_based_on_timeline(pls, pls->cur_seq_no));
+        seg->url = av_strireplace(pls->url_template, pls->url_template, tmpfilename);
+        if (!seg->url) {
+            av_log(pls->parent, AV_LOG_WARNING, "Unable to resolve template url '%s', try to use origin template\n", pls->url_template);
+            seg->url = av_strdup(pls->url_template);
+            if (!seg->url) {
+                av_log(pls->parent, AV_LOG_ERROR, "Cannot resolve template url '%s'\n", pls->url_template);
+                return NULL;
+            }
+        }
+
+        seg->size = -1;
+    }
+
+    return seg;
+}
+
+enum ReadFromURLMode {
+    READ_NORMAL,
+    READ_COMPLETE,
+};
+
+static int read_from_url(struct representation *pls, struct fragment *seg,
+                         uint8_t *buf, int buf_size,
+                         enum ReadFromURLMode mode)
+{
+    int ret;
+
+    /* limit read if the fragment was only a part of a file */
+    if (seg->size >= 0)
+        buf_size = FFMIN(buf_size, pls->cur_seg_size - pls->cur_seg_offset);
+
+    if (mode == READ_COMPLETE) {
+        ret = avio_read(pls->input, buf, buf_size);
+        if (ret < buf_size) {
+            av_log(pls->parent, AV_LOG_WARNING, "Could not read complete fragment.\n");
+        }
+    } else {
+        ret = avio_read(pls->input, buf, buf_size);
+    }
+    if (ret > 0)
+        pls->cur_seg_offset += ret;
+
+    return ret;
+}
+
+static int open_input(DASHContext *c, struct representation *pls, struct fragment *seg)
+{
+    AVDictionary *opts = NULL;
+    char url[MAX_URL_SIZE];
+    int ret;
+
+    set_httpheader_options(c, opts);
+    if (seg->size >= 0) {
+        /* try to restrict the HTTP request to the part we want
+         * (if this is in fact a HTTP request) */
+        av_dict_set_int(&opts, "offset", seg->url_offset, 0);
+        av_dict_set_int(&opts, "end_offset", seg->url_offset + seg->size, 0);
+    }
+
+    ff_make_absolute_url(url, MAX_URL_SIZE, c->base_url, seg->url);
+    av_log(pls->parent, AV_LOG_VERBOSE, "DASH request for url '%s', offset %"PRId64", playlist %d\n",
+           url, seg->url_offset, pls->rep_idx);
+    ret = open_url(pls->parent, &pls->input, url, c->avio_opts, opts, NULL);
+    if (ret < 0) {
+        goto cleanup;
+    }
+
+    /* Seek to the requested position. If this was a HTTP request, the offset
+     * should already be where want it to, but this allows e.g. local testing
+     * without a HTTP server. */
+    if (!ret && seg->url_offset) {
+        int64_t seekret = avio_seek(pls->input, seg->url_offset, SEEK_SET);
+        if (seekret < 0) {
+            av_log(pls->parent, AV_LOG_ERROR, "Unable to seek to offset %"PRId64" of DASH fragment '%s'\n", seg->url_offset, seg->url);
+            ret = (int) seekret;
+            ff_format_io_close(pls->parent, &pls->input);
+        }
+    }
+
+cleanup:
+    av_dict_free(&opts);
+    pls->cur_seg_offset = 0;
+    pls->cur_seg_size = seg->size;
+    return ret;
+}
+
+static int update_init_section(struct representation *pls)
+{
+    static const int max_init_section_size = 1024 * 1024;
+    DASHContext *c = pls->parent->priv_data;
+    int64_t sec_size;
+    int64_t urlsize;
+    int ret;
+
+    if (!pls->init_section || pls->init_sec_buf)
+        return 0;
+
+    ret = open_input(c, pls, pls->init_section);
+    if (ret < 0) {
+        av_log(pls->parent, AV_LOG_WARNING,
+               "Failed to open an initialization section in playlist %d\n",
+               pls->rep_idx);
+        return ret;
+    }
+
+    if (pls->init_section->size >= 0)
+        sec_size = pls->init_section->size;
+    else if ((urlsize = avio_size(pls->input)) >= 0)
+        sec_size = urlsize;
+    else
+        sec_size = max_init_section_size;
+
+    av_log(pls->parent, AV_LOG_DEBUG,
+           "Downloading an initialization section of size %"PRId64"\n",
+           sec_size);
+
+    sec_size = FFMIN(sec_size, max_init_section_size);
+
+    av_fast_malloc(&pls->init_sec_buf, &pls->init_sec_buf_size, sec_size);
+
+    ret = read_from_url(pls, pls->init_section, pls->init_sec_buf,
+                        pls->init_sec_buf_size, READ_COMPLETE);
+    ff_format_io_close(pls->parent, &pls->input);
+
+    if (ret < 0)
+        return ret;
+
+    pls->init_sec_data_len = ret;
+    pls->init_sec_buf_read_offset = 0;
+
+    return 0;
+}
+
+static int64_t seek_data(void *opaque, int64_t offset, int whence)
+{
+    struct representation *v = opaque;
+    if (v->n_fragments && !v->init_sec_data_len) {
+        return avio_seek(v->input, offset, whence);
+    }
+
+    return AVERROR(ENOSYS);
+}
+
+static int read_data(void *opaque, uint8_t *buf, int buf_size)
+{
+    int ret = 0;
+    struct representation *v = opaque;
+    DASHContext *c = v->parent->priv_data;
+
+restart:
+    if (!v->input) {
+        free_fragment(&v->cur_seg);
+        v->cur_seg = get_current_fragment(v);
+        if (!v->cur_seg) {
+            ret = AVERROR_EOF;
+            goto end;
+        }
+
+        /* load/update Media Initialization Section, if any */
+        ret = update_init_section(v);
+        if (ret)
+            goto end;
+
+        ret = open_input(c, v, v->cur_seg);
+        if (ret < 0) {
+            if (ff_check_interrupt(c->interrupt_callback)) {
+                goto end;
+                ret = AVERROR_EXIT;
+            }
+            av_log(v->parent, AV_LOG_WARNING, "Failed to open fragment of playlist %d\n", v->rep_idx);
+            v->cur_seq_no++;
+            goto restart;
+        }
+    }
+
+    if (v->init_sec_buf_read_offset < v->init_sec_data_len) {
+        /* Push init section out first before first actual fragment */
+        int copy_size = FFMIN(v->init_sec_data_len - v->init_sec_buf_read_offset, buf_size);
+        memcpy(buf, v->init_sec_buf, copy_size);
+        v->init_sec_buf_read_offset += copy_size;
+        ret = copy_size;
+        goto end;
+    }
+
+    /* check the v->cur_seg, if it is null, get current and double check if the new v->cur_seg*/
+    if (!v->cur_seg) {
+        v->cur_seg = get_current_fragment(v);
+    }
+    if (!v->cur_seg) {
+        ret = AVERROR_EOF;
+        goto end;
+    }
+    ret = read_from_url(v, v->cur_seg, buf, buf_size, READ_NORMAL);
+    if (ret > 0)
+        goto end;
+
+    if (!v->is_restart_needed)
+        v->cur_seq_no++;
+    v->is_restart_needed = 1;
+
+end:
+    return ret;
+}
+
+static int save_avio_options(AVFormatContext *s)
+{
+    DASHContext *c = s->priv_data;
+    const char *opts[] = { "headers", "user_agent", "user-agent", "cookies", NULL }, **opt = opts;
+    uint8_t *buf = NULL;
+    int ret = 0;
+
+    while (*opt) {
+        if (av_opt_get(s->pb, *opt, AV_OPT_SEARCH_CHILDREN, &buf) >= 0) {
+            if (buf[0] != '\0') {
+                ret = av_dict_set(&c->avio_opts, *opt, buf, AV_DICT_DONT_STRDUP_VAL);
+                if (ret < 0)
+                    return ret;
+            }
+        }
+        opt++;
+    }
+
+    return ret;
+}
+
+static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url,
+                          int flags, AVDictionary **opts)
+{
+    av_log(s, AV_LOG_ERROR,
+           "A DASH playlist item '%s' referred to an external file '%s'. "
+           "Opening this file was forbidden for security reasons\n",
+           s->filename, url);
+    return AVERROR(EPERM);
+}
+
+static int reopen_demux_for_component(AVFormatContext *s, struct representation *pls)
+{
+    DASHContext *c = s->priv_data;
+    AVInputFormat *in_fmt = NULL;
+    AVDictionary  *in_fmt_opts = NULL;
+    uint8_t *avio_ctx_buffer  = NULL;
+    int ret = 0;
+
+    if (pls->ctx) {
+        /* note: the internal buffer could have changed, and be != avio_ctx_buffer */
+        av_freep(&pls->pb.buffer);
+        memset(&pls->pb, 0x00, sizeof(AVIOContext));
+        pls->ctx->pb = NULL;
+        avformat_close_input(&pls->ctx);
+        pls->ctx = NULL;
+    }
+    if (!(pls->ctx = avformat_alloc_context())) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    avio_ctx_buffer  = av_malloc(INITIAL_BUFFER_SIZE);
+    if (!avio_ctx_buffer ) {
+        ret = AVERROR(ENOMEM);
+        avformat_free_context(pls->ctx);
+        pls->ctx = NULL;
+        goto fail;
+    }
+    if (c->is_live) {
+        ffio_init_context(&pls->pb, avio_ctx_buffer , INITIAL_BUFFER_SIZE, 0, pls, read_data, NULL, NULL);
+    } else {
+        ffio_init_context(&pls->pb, avio_ctx_buffer , INITIAL_BUFFER_SIZE, 0, pls, read_data, NULL, seek_data);
+    }
+    pls->pb.seekable = 0;
+
+    if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0)
+        goto fail;
+
+    pls->ctx->flags = AVFMT_FLAG_CUSTOM_IO;
+    pls->ctx->probesize = 1024 * 4;
+    pls->ctx->max_analyze_duration = 4 * AV_TIME_BASE;
+    ret = av_probe_input_buffer(&pls->pb, &in_fmt, "", NULL, 0, 0);
+    if (ret < 0) {
+        av_log(s, AV_LOG_ERROR, "Error when loading first fragment, playlist %d\n", (int)pls->rep_idx);
+        avformat_free_context(pls->ctx);
+        pls->ctx = NULL;
+        goto fail;
+    }
+
+    pls->ctx->pb = &pls->pb;
+    pls->ctx->io_open  = nested_io_open;
+
+    // provide additional information from mpd if available
+    ret = avformat_open_input(&pls->ctx, "", in_fmt, &in_fmt_opts); //pls->init_section->url
+    av_dict_free(&in_fmt_opts);
+    if (ret < 0)
+        goto fail;
+    if (pls->n_fragments) {
+        ret = avformat_find_stream_info(pls->ctx, NULL);
+        if (ret < 0)
+            goto fail;
+    }
+
+fail:
+    return ret;
+}
+
+static int open_demux_for_component(AVFormatContext *s, struct representation *pls)
+{
+    int ret = 0;
+    int i;
+
+    pls->parent = s;
+    pls->cur_seq_no  = calc_cur_seg_no(s, pls);
+    pls->last_seq_no = calc_max_seg_no(pls);
+
+    ret = reopen_demux_for_component(s, pls);
+    if (ret < 0) {
+        goto fail;
+    }
+    for (i = 0; i < pls->ctx->nb_streams; i++) {
+        AVStream *st = avformat_new_stream(s, NULL);
+        AVStream *ist = pls->ctx->streams[i];
+        if (!st) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+        st->id = i;
+        avcodec_parameters_copy(st->codecpar, pls->ctx->streams[i]->codecpar);
+        avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den);
+    }
+
+    return 0;
+fail:
+    return ret;
+}
+
+static int dash_read_header(AVFormatContext *s)
+{
+    void *u = (s->flags & AVFMT_FLAG_CUSTOM_IO) ? NULL : s->pb;
+    DASHContext *c = s->priv_data;
+    int ret = 0;
+    int stream_index = 0;
+
+    c->interrupt_callback = &s->interrupt_callback;
+    // if the URL context is good, read important options we must broker later
+    if (u) {
+        update_options(&c->user_agent, "user-agent", u);
+        update_options(&c->cookies, "cookies", u);
+        update_options(&c->headers, "headers", u);
+    }
+
+    if ((ret = parse_manifest(s, s->filename, s->pb)) < 0)
+        goto fail;
+
+    if ((ret = save_avio_options(s)) < 0)
+        goto fail;
+
+    /* If this isn't a live stream, fill the total duration of the
+     * stream. */
+    if (!c->is_live) {
+        s->duration = (int64_t) c->media_presentation_duration * AV_TIME_BASE;
+    }
+
+    /* Open the demuxer for curent video and current audio components if available */
+    if (!ret && c->cur_video) {
+        ret = open_demux_for_component(s, c->cur_video);
+        if (!ret) {
+            c->cur_video->stream_index = stream_index;
+            ++stream_index;
+        } else {
+            free_representation(c->cur_video);
+            c->cur_video = NULL;
+        }
+    }
+
+    if (!ret && c->cur_audio) {
+        ret = open_demux_for_component(s, c->cur_audio);
+        if (!ret) {
+            c->cur_audio->stream_index = stream_index;
+            ++stream_index;
+        } else {
+            free_representation(c->cur_audio);
+            c->cur_audio = NULL;
+        }
+    }
+
+    if (!stream_index) {
+        ret = AVERROR_INVALIDDATA;
+        goto fail;
+    }
+
+    /* Create a program */
+    if (!ret) {
+        AVProgram *program;
+        program = av_new_program(s, 0);
+        if (!program) {
+            goto fail;
+        }
+
+        if (c->cur_video) {
+            av_program_add_stream_index(s, 0, c->cur_video->stream_index);
+        }
+        if (c->cur_audio) {
+            av_program_add_stream_index(s, 0, c->cur_audio->stream_index);
+        }
+    }
+
+    return 0;
+fail:
+    return ret;
+}
+
+static int dash_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    DASHContext *c = s->priv_data;
+    int ret = 0;
+    struct representation *cur = NULL;
+
+    if (!c->cur_audio && !c->cur_video ) {
+        return AVERROR_INVALIDDATA;
+    }
+    if (c->cur_audio && !c->cur_video) {
+        cur = c->cur_audio;
+    } else if (!c->cur_audio && c->cur_video) {
+        cur = c->cur_video;
+    } else if (c->cur_video->cur_timestamp < c->cur_audio->cur_timestamp) {
+        cur = c->cur_video;
+    } else {
+        cur = c->cur_audio;
+    }
+
+    if (cur->ctx) {
+        while (!ff_check_interrupt(c->interrupt_callback) && !ret) {
+            ret = av_read_frame(cur->ctx, pkt);
+            if (ret >= 0) {
+                /* If we got a packet, return it */
+                cur->cur_timestamp = av_rescale(pkt->pts, (int64_t)cur->ctx->streams[0]->time_base.num * 90000, cur->ctx->streams[0]->time_base.den);
+                pkt->stream_index = cur->stream_index;
+                return 0;
+            }
+            if (cur->is_restart_needed) {
+                cur->cur_seg_offset = 0;
+                cur->init_sec_buf_read_offset = 0;
+                if (cur->input)
+                    ff_format_io_close(cur->parent, &cur->input);
+                ret = reopen_demux_for_component(s, cur);
+                cur->is_restart_needed = 0;
+            }
+
+        }
+    }
+    return AVERROR_EOF;
+}
+
+static int dash_close(AVFormatContext *s)
+{
+    DASHContext *c = s->priv_data;
+    if (c->cur_audio) {
+        free_representation(c->cur_audio);
+    }
+    if (c->cur_video) {
+        free_representation(c->cur_video);
+    }
+
+    av_freep(&c->cookies);
+    av_freep(&c->user_agent);
+    av_dict_free(&c->avio_opts);
+    av_freep(&c->base_url);
+    return 0;
+}
+
+static int dash_seek(AVFormatContext *s, struct representation *pls, int64_t seek_pos_msec, int flags)
+{
+    int ret = 0;
+    int i = 0;
+    int j = 0;
+    int64_t duration = 0;
+
+    av_log(pls->parent, AV_LOG_VERBOSE, "DASH seek pos[%"PRId64"ms], playlist %d\n", seek_pos_msec, pls->rep_idx);
+
+    // single fragment mode
+    if (pls->n_fragments == 1) {
+        pls->cur_timestamp = 0;
+        pls->cur_seg_offset = 0;
+        ff_read_frame_flush(pls->ctx);
+        return av_seek_frame(pls->ctx, -1, seek_pos_msec * 1000, flags);
+    }
+
+    if (pls->input)
+        ff_format_io_close(pls->parent, &pls->input);
+
+    // find the nearest fragment
+    if (pls->n_timelines > 0 && pls->fragment_timescale > 0) {
+        int64_t num = pls->first_seq_no;
+        av_log(pls->parent, AV_LOG_VERBOSE, "dash_seek with SegmentTimeline start n_timelines[%d] "
+               "last_seq_no[%"PRId64"], playlist %d.\n",
+               (int)pls->n_timelines, (int64_t)pls->last_seq_no, (int)pls->rep_idx);
+        for (i = 0; i < pls->n_timelines; i++) {
+            if (pls->timelines[i]->starttime > 0) {
+                duration = pls->timelines[i]->starttime;
+            }
+            duration += pls->timelines[i]->duration;
+            if (seek_pos_msec < ((duration * 1000) /  pls->fragment_timescale)) {
+                goto set_seq_num;
+            }
+            for (j = 0; j < pls->timelines[i]->repeat; j++) {
+                duration += pls->timelines[i]->duration;
+                num++;
+                if (seek_pos_msec < ((duration * 1000) /  pls->fragment_timescale)) {
+                    goto set_seq_num;
+                }
+            }
+            num++;
+        }
+
+set_seq_num:
+        pls->cur_seq_no = num > pls->last_seq_no ? pls->last_seq_no : num;
+        av_log(pls->parent, AV_LOG_VERBOSE, "dash_seek with SegmentTimeline end cur_seq_no[%"PRId64"], playlist %d.\n",
+               (int64_t)pls->cur_seq_no, (int)pls->rep_idx);
+    } else if (pls->fragment_duration > 0) {
+        pls->cur_seq_no = pls->first_seq_no + ((seek_pos_msec * pls->fragment_timescale) / pls->fragment_duration) / 1000;
+    } else {
+        av_log(pls->parent, AV_LOG_ERROR, "dash_seek missing fragment_duration\n");
+        pls->cur_seq_no = pls->first_seq_no;
+    }
+    pls->cur_timestamp = 0;
+    pls->cur_seg_offset = 0;
+    pls->init_sec_buf_read_offset = 0;
+    ret = reopen_demux_for_component(s, pls);
+
+    return ret;
+}
+
+static int dash_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
+{
+    int ret = 0;
+    DASHContext *c = s->priv_data;
+    int64_t seek_pos_msec = av_rescale_rnd(timestamp, 1000,
+                                           s->streams[stream_index]->time_base.den,
+                                           flags & AVSEEK_FLAG_BACKWARD ?
+                                           AV_ROUND_DOWN : AV_ROUND_UP);
+    if ((flags & AVSEEK_FLAG_BYTE) || c->is_live)
+        return AVERROR(ENOSYS);
+    if (c->cur_audio) {
+        ret = dash_seek(s, c->cur_audio, seek_pos_msec, flags);
+    }
+    if (!ret && c->cur_video) {
+        ret = dash_seek(s, c->cur_video, seek_pos_msec, flags);
+    }
+    return ret;
+}
+
+static int dash_probe(AVProbeData *p)
+{
+    if (!av_stristr(p->buf, "<MPD"))
+        return 0;
+
+    if (av_stristr(p->buf, "dash:profile:isoff-on-demand:2011") ||
+        av_stristr(p->buf, "dash:profile:isoff-live:2011") ||
+        av_stristr(p->buf, "dash:profile:isoff-live:2012") ||
+        av_stristr(p->buf, "dash:profile:isoff-main:2011")) {
+        return AVPROBE_SCORE_MAX;
+    }
+    if (av_stristr(p->buf, "dash:profile")) {
+        return AVPROBE_SCORE_MAX;
+    }
+
+    return 0;
+}
+
+#define OFFSET(x) offsetof(DASHContext, x)
+#define FLAGS AV_OPT_FLAG_DECODING_PARAM
+static const AVOption dash_options[] = {
+    {"allowed_extensions", "List of file extensions that dash is allowed to access",
+        OFFSET(allowed_extensions), AV_OPT_TYPE_STRING,
+        {.str = "aac,m4a,m4s,m4v,mov,mp4"},
+        INT_MIN, INT_MAX, FLAGS},
+    {NULL}
+};
+
+static const AVClass dash_class = {
+    .class_name = "dash",
+    .item_name  = av_default_item_name,
+    .option     = dash_options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVInputFormat ff_dash_demuxer = {
+    .name           = "dash",
+    .long_name      = NULL_IF_CONFIG_SMALL("Dynamic Adaptive Streaming over HTTP"),
+    .priv_class     = &dash_class,
+    .priv_data_size = sizeof(DASHContext),
+    .read_probe     = dash_probe,
+    .read_header    = dash_read_header,
+    .read_packet    = dash_read_packet,
+    .read_close     = dash_close,
+    .read_seek      = dash_read_seek,
+    .flags          = AVFMT_NO_BYTE_SEEK,
+};
diff --git a/mythtv/external/FFmpeg/libavformat/dashenc.c b/mythtv/external/FFmpeg/libavformat/dashenc.c
index 534fa754b4d..240ff413805 100644
--- a/mythtv/external/FFmpeg/libavformat/dashenc.c
+++ b/mythtv/external/FFmpeg/libavformat/dashenc.c
@@ -25,6 +25,7 @@
 #endif
 
 #include "libavutil/avassert.h"
+#include "libavutil/avutil.h"
 #include "libavutil/avstring.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/mathematics.h"
@@ -39,16 +40,7 @@
 #include "isom.h"
 #include "os_support.h"
 #include "url.h"
-
-// See ISO/IEC 23009-1:2014 5.3.9.4.4
-typedef enum {
-    DASH_TMPL_ID_UNDEFINED = -1,
-    DASH_TMPL_ID_ESCAPE,
-    DASH_TMPL_ID_REP_ID,
-    DASH_TMPL_ID_NUMBER,
-    DASH_TMPL_ID_BANDWIDTH,
-    DASH_TMPL_ID_TIME,
-} DASHTmplId;
+#include "dash.h"
 
 typedef struct Segment {
     char file[1024];
@@ -59,14 +51,20 @@ typedef struct Segment {
     int n;
 } Segment;
 
+typedef struct AdaptationSet {
+    char id[10];
+    enum AVMediaType media_type;
+    AVDictionary *metadata;
+} AdaptationSet;
+
 typedef struct OutputStream {
     AVFormatContext *ctx;
-    int ctx_inited;
-    uint8_t iobuf[32768];
+    int ctx_inited, as_idx;
     AVIOContext *out;
+    char format_name[8];
     int packets_written;
     char initfile[1024];
-    int64_t init_start_pos;
+    int64_t init_start_pos, pos;
     int init_range_length;
     int nb_segments, segments_size, segment_index;
     Segment **segments;
@@ -80,6 +78,9 @@ typedef struct OutputStream {
 
 typedef struct DASHContext {
     const AVClass *class;  /* Class for private options. */
+    char *adaptation_sets;
+    AdaptationSet *as;
+    int nb_as;
     int window_size;
     int extra_window_size;
     int min_seg_duration;
@@ -88,7 +89,7 @@ typedef struct DASHContext {
     int use_timeline;
     int single_file;
     OutputStream *streams;
-    int has_video, has_audio;
+    int has_video;
     int64_t last_duration;
     int64_t total_duration;
     char availability_start_time[100];
@@ -98,22 +99,35 @@ typedef struct DASHContext {
     const char *media_seg_name;
     AVRational min_frame_rate, max_frame_rate;
     int ambiguous_frame_rate;
+    const char *utc_timing_url;
 } DASHContext;
 
-static int dash_write(void *opaque, uint8_t *buf, int buf_size)
-{
-    OutputStream *os = opaque;
-    if (os->out)
-        avio_write(os->out, buf, buf_size);
-    return buf_size;
-}
+static struct codec_string {
+    int id;
+    const char *str;
+} codecs[] = {
+    { AV_CODEC_ID_VP8, "vp8" },
+    { AV_CODEC_ID_VP9, "vp9" },
+    { AV_CODEC_ID_VORBIS, "vorbis" },
+    { AV_CODEC_ID_OPUS, "opus" },
+    { 0, NULL }
+};
 
-// RFC 6381
 static void set_codec_str(AVFormatContext *s, AVCodecParameters *par,
                           char *str, int size)
 {
     const AVCodecTag *tags[2] = { NULL, NULL };
     uint32_t tag;
+    int i;
+
+    // common Webm codecs are not part of RFC 6381
+    for (i = 0; codecs[i].id; i++)
+        if (codecs[i].id == par->codec_id) {
+            av_strlcpy(str, codecs[i].str, size);
+            return;
+        }
+
+    // for codecs part of RFC 6381
     if (par->codec_type == AVMEDIA_TYPE_VIDEO)
         tags[0] = ff_codec_movvideo_tags;
     else if (par->codec_type == AVMEDIA_TYPE_AUDIO)
@@ -134,7 +148,7 @@ static void set_codec_str(AVFormatContext *s, AVCodecParameters *par,
         tags[0] = ff_mp4_obj_type;
         oti = av_codec_get_tag(tags, par->codec_id);
         if (oti)
-            av_strlcatf(str, size, ".%02x", oti);
+            av_strlcatf(str, size, ".%02"PRIx32, oti);
         else
             return;
 
@@ -174,10 +188,55 @@ static void set_codec_str(AVFormatContext *s, AVCodecParameters *par,
     }
 }
 
+static int flush_dynbuf(OutputStream *os, int *range_length)
+{
+    uint8_t *buffer;
+
+    if (!os->ctx->pb) {
+        return AVERROR(EINVAL);
+    }
+
+    // flush
+    av_write_frame(os->ctx, NULL);
+    avio_flush(os->ctx->pb);
+
+    // write out to file
+    *range_length = avio_close_dyn_buf(os->ctx->pb, &buffer);
+    os->ctx->pb = NULL;
+    avio_write(os->out, buffer, *range_length);
+    av_free(buffer);
+
+    // re-open buffer
+    return avio_open_dyn_buf(&os->ctx->pb);
+}
+
+static int flush_init_segment(AVFormatContext *s, OutputStream *os)
+{
+    DASHContext *c = s->priv_data;
+    int ret, range_length;
+
+    ret = flush_dynbuf(os, &range_length);
+    if (ret < 0)
+        return ret;
+
+    os->pos = os->init_range_length = range_length;
+    if (!c->single_file)
+        ff_format_io_close(s, &os->out);
+    return 0;
+}
+
 static void dash_free(AVFormatContext *s)
 {
     DASHContext *c = s->priv_data;
     int i, j;
+
+    if (c->as) {
+        for (i = 0; i < c->nb_as; i++)
+            av_dict_free(&c->as[i].metadata);
+        av_freep(&c->as);
+        c->nb_as = 0;
+    }
+
     if (!c->streams)
         return;
     for (i = 0; i < s->nb_streams; i++) {
@@ -185,7 +244,7 @@ static void dash_free(AVFormatContext *s)
         if (os->ctx && os->ctx_inited)
             av_write_trailer(os->ctx);
         if (os->ctx && os->ctx->pb)
-            av_free(os->ctx->pb);
+            ffio_free_dyn_buf(&os->ctx->pb);
         ff_format_io_close(s, &os->out);
         if (os->ctx)
             avformat_free_context(os->ctx);
@@ -258,119 +317,6 @@ static void output_segment_list(OutputStream *os, AVIOContext *out, DASHContext
     }
 }
 
-static DASHTmplId dash_read_tmpl_id(const char *identifier, char *format_tag,
-                                    size_t format_tag_size, const char **ptr) {
-    const char *next_ptr;
-    DASHTmplId id_type = DASH_TMPL_ID_UNDEFINED;
-
-    if (av_strstart(identifier, "$$", &next_ptr)) {
-        id_type = DASH_TMPL_ID_ESCAPE;
-        *ptr = next_ptr;
-    } else if (av_strstart(identifier, "$RepresentationID$", &next_ptr)) {
-        id_type = DASH_TMPL_ID_REP_ID;
-        // default to basic format, as $RepresentationID$ identifiers
-        // are not allowed to have custom format-tags.
-        av_strlcpy(format_tag, "%d", format_tag_size);
-        *ptr = next_ptr;
-    } else { // the following identifiers may have an explicit format_tag
-        if (av_strstart(identifier, "$Number", &next_ptr))
-            id_type = DASH_TMPL_ID_NUMBER;
-        else if (av_strstart(identifier, "$Bandwidth", &next_ptr))
-            id_type = DASH_TMPL_ID_BANDWIDTH;
-        else if (av_strstart(identifier, "$Time", &next_ptr))
-            id_type = DASH_TMPL_ID_TIME;
-        else
-            id_type = DASH_TMPL_ID_UNDEFINED;
-
-        // next parse the dash format-tag and generate a c-string format tag
-        // (next_ptr now points at the first '%' at the beginning of the format-tag)
-        if (id_type != DASH_TMPL_ID_UNDEFINED) {
-            const char *number_format = (id_type == DASH_TMPL_ID_TIME) ? PRId64 : "d";
-            if (next_ptr[0] == '$') { // no dash format-tag
-                snprintf(format_tag, format_tag_size, "%%%s", number_format);
-                *ptr = &next_ptr[1];
-            } else {
-                const char *width_ptr;
-                // only tolerate single-digit width-field (i.e. up to 9-digit width)
-                if (av_strstart(next_ptr, "%0", &width_ptr) &&
-                    av_isdigit(width_ptr[0]) &&
-                    av_strstart(&width_ptr[1], "d$", &next_ptr)) {
-                    // yes, we're using a format tag to build format_tag.
-                    snprintf(format_tag, format_tag_size, "%s%c%s", "%0", width_ptr[0], number_format);
-                    *ptr = next_ptr;
-                } else {
-                    av_log(NULL, AV_LOG_WARNING, "Failed to parse format-tag beginning with %s. Expected either a "
-                                                 "closing '$' character or a format-string like '%%0[width]d', "
-                                                 "where width must be a single digit\n", next_ptr);
-                    id_type = DASH_TMPL_ID_UNDEFINED;
-                }
-            }
-        }
-    }
-    return id_type;
-}
-
-static void dash_fill_tmpl_params(char *dst, size_t buffer_size,
-                                  const char *template, int rep_id,
-                                  int number, int bit_rate,
-                                  int64_t time) {
-    int dst_pos = 0;
-    const char *t_cur = template;
-    while (dst_pos < buffer_size - 1 && *t_cur) {
-        char format_tag[7]; // May be "%d", "%0Xd", or "%0Xlld" (for $Time$), where X is in [0-9]
-        int n = 0;
-        DASHTmplId id_type;
-        const char *t_next = strchr(t_cur, '$'); // copy over everything up to the first '$' character
-        if (t_next) {
-            int num_copy_bytes = FFMIN(t_next - t_cur, buffer_size - dst_pos - 1);
-            av_strlcpy(&dst[dst_pos], t_cur, num_copy_bytes + 1);
-            // advance
-            dst_pos += num_copy_bytes;
-            t_cur = t_next;
-        } else { // no more DASH identifiers to substitute - just copy the rest over and break
-            av_strlcpy(&dst[dst_pos], t_cur, buffer_size - dst_pos);
-            break;
-        }
-
-        if (dst_pos >= buffer_size - 1 || !*t_cur)
-            break;
-
-        // t_cur is now pointing to a '$' character
-        id_type = dash_read_tmpl_id(t_cur, format_tag, sizeof(format_tag), &t_next);
-        switch (id_type) {
-        case DASH_TMPL_ID_ESCAPE:
-            av_strlcpy(&dst[dst_pos], "$", 2);
-            n = 1;
-            break;
-        case DASH_TMPL_ID_REP_ID:
-            n = snprintf(&dst[dst_pos], buffer_size - dst_pos, format_tag, rep_id);
-            break;
-        case DASH_TMPL_ID_NUMBER:
-            n = snprintf(&dst[dst_pos], buffer_size - dst_pos, format_tag, number);
-            break;
-        case DASH_TMPL_ID_BANDWIDTH:
-            n = snprintf(&dst[dst_pos], buffer_size - dst_pos, format_tag, bit_rate);
-            break;
-        case DASH_TMPL_ID_TIME:
-            n = snprintf(&dst[dst_pos], buffer_size - dst_pos, format_tag, time);
-            break;
-        case DASH_TMPL_ID_UNDEFINED:
-            // copy over one byte and advance
-            av_strlcpy(&dst[dst_pos], t_cur, 2);
-            n = 1;
-            t_next = &t_cur[1];
-            break;
-        }
-        // t_next points just past the processed identifier
-        // n is the number of bytes that were attempted to be written to dst
-        // (may have failed to write all because buffer_size).
-
-        // advance
-        dst_pos += FFMIN(n, buffer_size - dst_pos - 1);
-        t_cur = t_next;
-    }
-}
-
 static char *xmlescape(const char *str) {
     int outlen = strlen(str)*3/2 + 6;
     char *out = av_realloc(NULL, outlen + 1);
@@ -433,20 +379,207 @@ static void format_date_now(char *buf, int size)
     struct tm *ptm, tmbuf;
     ptm = gmtime_r(&t, &tmbuf);
     if (ptm) {
-        if (!strftime(buf, size, "%Y-%m-%dT%H:%M:%S", ptm))
+        if (!strftime(buf, size, "%Y-%m-%dT%H:%M:%SZ", ptm))
             buf[0] = '\0';
     }
 }
 
+static int write_adaptation_set(AVFormatContext *s, AVIOContext *out, int as_index)
+{
+    DASHContext *c = s->priv_data;
+    AdaptationSet *as = &c->as[as_index];
+    AVDictionaryEntry *lang, *role;
+    int i;
+
+    avio_printf(out, "\t\t<AdaptationSet id=\"%s\" contentType=\"%s\" segmentAlignment=\"true\" bitstreamSwitching=\"true\"",
+                as->id, as->media_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio");
+    if (as->media_type == AVMEDIA_TYPE_VIDEO && c->max_frame_rate.num && !c->ambiguous_frame_rate)
+        avio_printf(out, " %s=\"%d/%d\"", (av_cmp_q(c->min_frame_rate, c->max_frame_rate) < 0) ? "maxFrameRate" : "frameRate", c->max_frame_rate.num, c->max_frame_rate.den);
+    lang = av_dict_get(as->metadata, "language", NULL, 0);
+    if (lang)
+        avio_printf(out, " lang=\"%s\"", lang->value);
+    avio_printf(out, ">\n");
+
+    role = av_dict_get(as->metadata, "role", NULL, 0);
+    if (role)
+        avio_printf(out, "\t\t\t<Role schemeIdUri=\"urn:mpeg:dash:role:2011\" value=\"%s\"/>\n", role->value);
+
+    for (i = 0; i < s->nb_streams; i++) {
+        OutputStream *os = &c->streams[i];
+
+        if (os->as_idx - 1 != as_index)
+            continue;
+
+        if (as->media_type == AVMEDIA_TYPE_VIDEO) {
+            AVStream *st = s->streams[i];
+            avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"video/%s\" codecs=\"%s\"%s width=\"%d\" height=\"%d\"",
+                i, os->format_name, os->codec_str, os->bandwidth_str, s->streams[i]->codecpar->width, s->streams[i]->codecpar->height);
+            if (st->avg_frame_rate.num)
+                avio_printf(out, " frameRate=\"%d/%d\"", st->avg_frame_rate.num, st->avg_frame_rate.den);
+            avio_printf(out, ">\n");
+        } else {
+            avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"audio/%s\" codecs=\"%s\"%s audioSamplingRate=\"%d\">\n",
+                i, os->format_name, os->codec_str, os->bandwidth_str, s->streams[i]->codecpar->sample_rate);
+            avio_printf(out, "\t\t\t\t<AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"%d\" />\n",
+                s->streams[i]->codecpar->channels);
+        }
+        output_segment_list(os, out, c);
+        avio_printf(out, "\t\t\t</Representation>\n");
+    }
+    avio_printf(out, "\t\t</AdaptationSet>\n");
+
+    return 0;
+}
+
+static int add_adaptation_set(AVFormatContext *s, AdaptationSet **as, enum AVMediaType type)
+{
+    DASHContext *c = s->priv_data;
+
+    void *mem = av_realloc(c->as, sizeof(*c->as) * (c->nb_as + 1));
+    if (!mem)
+        return AVERROR(ENOMEM);
+    c->as = mem;
+    ++c->nb_as;
+
+    *as = &c->as[c->nb_as - 1];
+    memset(*as, 0, sizeof(**as));
+    (*as)->media_type = type;
+
+    return 0;
+}
+
+static int adaptation_set_add_stream(AVFormatContext *s, int as_idx, int i)
+{
+    DASHContext *c = s->priv_data;
+    AdaptationSet *as = &c->as[as_idx - 1];
+    OutputStream *os = &c->streams[i];
+
+    if (as->media_type != s->streams[i]->codecpar->codec_type) {
+        av_log(s, AV_LOG_ERROR, "Codec type of stream %d doesn't match AdaptationSet's media type\n", i);
+        return AVERROR(EINVAL);
+    } else if (os->as_idx) {
+        av_log(s, AV_LOG_ERROR, "Stream %d is already assigned to an AdaptationSet\n", i);
+        return AVERROR(EINVAL);
+    }
+    os->as_idx = as_idx;
+
+    return 0;
+}
+
+static int parse_adaptation_sets(AVFormatContext *s)
+{
+    DASHContext *c = s->priv_data;
+    const char *p = c->adaptation_sets;
+    enum { new_set, parse_id, parsing_streams } state;
+    AdaptationSet *as;
+    int i, n, ret;
+
+    // default: one AdaptationSet for each stream
+    if (!p) {
+        for (i = 0; i < s->nb_streams; i++) {
+            if ((ret = add_adaptation_set(s, &as, s->streams[i]->codecpar->codec_type)) < 0)
+                return ret;
+            snprintf(as->id, sizeof(as->id), "%d", i);
+
+            c->streams[i].as_idx = c->nb_as;
+        }
+        goto end;
+    }
+
+    // syntax id=0,streams=0,1,2 id=1,streams=3,4 and so on
+    state = new_set;
+    while (*p) {
+        if (*p == ' ') {
+            p++;
+            continue;
+        } else if (state == new_set && av_strstart(p, "id=", &p)) {
+
+            if ((ret = add_adaptation_set(s, &as, AVMEDIA_TYPE_UNKNOWN)) < 0)
+                return ret;
+
+            n = strcspn(p, ",");
+            snprintf(as->id, sizeof(as->id), "%.*s", n, p);
+
+            p += n;
+            if (*p)
+                p++;
+            state = parse_id;
+        } else if (state == parse_id && av_strstart(p, "streams=", &p)) {
+            state = parsing_streams;
+        } else if (state == parsing_streams) {
+            AdaptationSet *as = &c->as[c->nb_as - 1];
+            char idx_str[8], *end_str;
+
+            n = strcspn(p, " ,");
+            snprintf(idx_str, sizeof(idx_str), "%.*s", n, p);
+            p += n;
+
+            // if value is "a" or "v", map all streams of that type
+            if (as->media_type == AVMEDIA_TYPE_UNKNOWN && (idx_str[0] == 'v' || idx_str[0] == 'a')) {
+                enum AVMediaType type = (idx_str[0] == 'v') ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO;
+                av_log(s, AV_LOG_DEBUG, "Map all streams of type %s\n", idx_str);
+
+                for (i = 0; i < s->nb_streams; i++) {
+                    if (s->streams[i]->codecpar->codec_type != type)
+                        continue;
+
+                    as->media_type = s->streams[i]->codecpar->codec_type;
+
+                    if ((ret = adaptation_set_add_stream(s, c->nb_as, i)) < 0)
+                        return ret;
+                }
+            } else { // select single stream
+                i = strtol(idx_str, &end_str, 10);
+                if (idx_str == end_str || i < 0 || i >= s->nb_streams) {
+                    av_log(s, AV_LOG_ERROR, "Selected stream \"%s\" not found!\n", idx_str);
+                    return AVERROR(EINVAL);
+                }
+                av_log(s, AV_LOG_DEBUG, "Map stream %d\n", i);
+
+                if (as->media_type == AVMEDIA_TYPE_UNKNOWN) {
+                    as->media_type = s->streams[i]->codecpar->codec_type;
+                }
+
+                if ((ret = adaptation_set_add_stream(s, c->nb_as, i)) < 0)
+                    return ret;
+            }
+
+            if (*p == ' ')
+                state = new_set;
+            if (*p)
+                p++;
+        } else {
+            return AVERROR(EINVAL);
+        }
+    }
+
+end:
+    // check for unassigned streams
+    for (i = 0; i < s->nb_streams; i++) {
+        OutputStream *os = &c->streams[i];
+        if (!os->as_idx) {
+            av_log(s, AV_LOG_ERROR, "Stream %d is not mapped to an AdaptationSet\n", i);
+            return AVERROR(EINVAL);
+        }
+    }
+    return 0;
+}
+
 static int write_manifest(AVFormatContext *s, int final)
 {
     DASHContext *c = s->priv_data;
     AVIOContext *out;
     char temp_filename[1024];
     int ret, i;
+    const char *proto = avio_find_protocol_name(s->filename);
+    int use_rename = proto && !strcmp(proto, "file");
+    static unsigned int warned_non_file = 0;
     AVDictionaryEntry *title = av_dict_get(s->metadata, "title", NULL, 0);
 
-    snprintf(temp_filename, sizeof(temp_filename), "%s.tmp", s->filename);
+    if (!use_rename && !warned_non_file++)
+        av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
+
+    snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", s->filename);
     ret = s->io_open(s, &out, temp_filename, AVIO_FLAG_WRITE, NULL);
     if (ret < 0) {
         av_log(s, AV_LOG_ERROR, "Unable to open %s for writing\n", temp_filename);
@@ -485,7 +618,7 @@ static int write_manifest(AVFormatContext *s, int final)
         }
     }
     avio_printf(out, "\tminBufferTime=\"");
-    write_time(out, c->last_duration);
+    write_time(out, c->last_duration * 2);
     avio_printf(out, "\">\n");
     avio_printf(out, "\t<ProgramInformation>\n");
     if (title) {
@@ -494,68 +627,55 @@ static int write_manifest(AVFormatContext *s, int final)
         av_free(escaped);
     }
     avio_printf(out, "\t</ProgramInformation>\n");
+    if (c->utc_timing_url)
+        avio_printf(out, "\t<UTCTiming schemeIdUri=\"urn:mpeg:dash:utc:http-xsdate:2014\" value=\"%s\"/>\n", c->utc_timing_url);
+
     if (c->window_size && s->nb_streams > 0 && c->streams[0].nb_segments > 0 && !c->use_template) {
         OutputStream *os = &c->streams[0];
         int start_index = FFMAX(os->nb_segments - c->window_size, 0);
         int64_t start_time = av_rescale_q(os->segments[start_index]->time, s->streams[0]->time_base, AV_TIME_BASE_Q);
-        avio_printf(out, "\t<Period start=\"");
+        avio_printf(out, "\t<Period id=\"0\" start=\"");
         write_time(out, start_time);
         avio_printf(out, "\">\n");
     } else {
-        avio_printf(out, "\t<Period start=\"PT0.0S\">\n");
-    }
-
-    if (c->has_video) {
-        avio_printf(out, "\t\t<AdaptationSet contentType=\"video\" segmentAlignment=\"true\" bitstreamSwitching=\"true\"");
-        if (c->max_frame_rate.num && !c->ambiguous_frame_rate)
-            avio_printf(out, " %s=\"%d/%d\"", (av_cmp_q(c->min_frame_rate, c->max_frame_rate) < 0) ? "maxFrameRate" : "frameRate", c->max_frame_rate.num, c->max_frame_rate.den);
-        avio_printf(out, ">\n");
-
-        for (i = 0; i < s->nb_streams; i++) {
-            AVStream *st = s->streams[i];
-            OutputStream *os = &c->streams[i];
-
-            if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
-                continue;
-
-            avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"video/mp4\" codecs=\"%s\"%s width=\"%d\" height=\"%d\"", i, os->codec_str, os->bandwidth_str, st->codecpar->width, st->codecpar->height);
-            if (st->avg_frame_rate.num)
-                avio_printf(out, " frameRate=\"%d/%d\"", st->avg_frame_rate.num, st->avg_frame_rate.den);
-            avio_printf(out, ">\n");
-
-            output_segment_list(&c->streams[i], out, c);
-            avio_printf(out, "\t\t\t</Representation>\n");
-        }
-        avio_printf(out, "\t\t</AdaptationSet>\n");
+        avio_printf(out, "\t<Period id=\"0\" start=\"PT0.0S\">\n");
     }
-    if (c->has_audio) {
-        avio_printf(out, "\t\t<AdaptationSet contentType=\"audio\" segmentAlignment=\"true\" bitstreamSwitching=\"true\">\n");
-        for (i = 0; i < s->nb_streams; i++) {
-            AVStream *st = s->streams[i];
-            OutputStream *os = &c->streams[i];
 
-            if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
-                continue;
-
-            avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"audio/mp4\" codecs=\"%s\"%s audioSamplingRate=\"%d\">\n", i, os->codec_str, os->bandwidth_str, st->codecpar->sample_rate);
-            avio_printf(out, "\t\t\t\t<AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"%d\" />\n", st->codecpar->channels);
-            output_segment_list(&c->streams[i], out, c);
-            avio_printf(out, "\t\t\t</Representation>\n");
-        }
-        avio_printf(out, "\t\t</AdaptationSet>\n");
+    for (i = 0; i < c->nb_as; i++) {
+        if ((ret = write_adaptation_set(s, out, i)) < 0)
+            return ret;
     }
     avio_printf(out, "\t</Period>\n");
     avio_printf(out, "</MPD>\n");
     avio_flush(out);
     ff_format_io_close(s, &out);
-    return avpriv_io_move(temp_filename, s->filename);
+
+    if (use_rename)
+        return avpriv_io_move(temp_filename, s->filename);
+
+    return 0;
+}
+
+static int dict_copy_entry(AVDictionary **dst, const AVDictionary *src, const char *key)
+{
+    AVDictionaryEntry *entry = av_dict_get(src, key, NULL, 0);
+    if (entry)
+        av_dict_set(dst, key, entry->value, AV_DICT_DONT_OVERWRITE);
+    return 0;
+}
+
+static int dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
+{
+    char valuestr[22];
+    snprintf(valuestr, sizeof(valuestr), "%"PRId64, value);
+    flags &= ~AV_DICT_DONT_STRDUP_VAL;
+    return av_dict_set(pm, key, valuestr, flags);
 }
 
 static int dash_init(AVFormatContext *s)
 {
     DASHContext *c = s->priv_data;
     int ret = 0, i;
-    AVOutputFormat *oformat;
     char *ptr;
     char basename[1024];
 
@@ -579,16 +699,16 @@ static int dash_init(AVFormatContext *s)
     if (ptr)
         *ptr = '\0';
 
-    oformat = av_guess_format("mp4", NULL, NULL);
-    if (!oformat)
-        return AVERROR_MUXER_NOT_FOUND;
-
     c->streams = av_mallocz(sizeof(*c->streams) * s->nb_streams);
     if (!c->streams)
         return AVERROR(ENOMEM);
 
+    if ((ret = parse_adaptation_sets(s)) < 0)
+        return ret;
+
     for (i = 0; i < s->nb_streams; i++) {
         OutputStream *os = &c->streams[i];
+        AdaptationSet *as = &c->as[os->as_idx - 1];
         AVFormatContext *ctx;
         AVStream *st;
         AVDictionary *opts = NULL;
@@ -606,11 +726,29 @@ static int dash_init(AVFormatContext *s)
                 return AVERROR(EINVAL);
         }
 
+        // copy AdaptationSet language and role from stream metadata
+        dict_copy_entry(&as->metadata, s->streams[i]->metadata, "language");
+        dict_copy_entry(&as->metadata, s->streams[i]->metadata, "role");
+
         ctx = avformat_alloc_context();
         if (!ctx)
             return AVERROR(ENOMEM);
+
+        // choose muxer based on codec: webm for VP8/9 and opus, mp4 otherwise
+        // note: os->format_name is also used as part of the mimetype of the
+        //       representation, e.g. video/<format_name>
+        if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_VP8 ||
+            s->streams[i]->codecpar->codec_id == AV_CODEC_ID_VP9 ||
+            s->streams[i]->codecpar->codec_id == AV_CODEC_ID_OPUS ||
+            s->streams[i]->codecpar->codec_id == AV_CODEC_ID_VORBIS) {
+            snprintf(os->format_name, sizeof(os->format_name), "webm");
+        } else {
+            snprintf(os->format_name, sizeof(os->format_name), "mp4");
+        }
+        ctx->oformat = av_guess_format(os->format_name, NULL, NULL);
+        if (!ctx->oformat)
+            return AVERROR_MUXER_NOT_FOUND;
         os->ctx = ctx;
-        ctx->oformat = oformat;
         ctx->interrupt_callback = s->interrupt_callback;
         ctx->opaque             = s->opaque;
         ctx->io_close           = s->io_close;
@@ -624,17 +762,16 @@ static int dash_init(AVFormatContext *s)
         ctx->avoid_negative_ts = s->avoid_negative_ts;
         ctx->flags = s->flags;
 
-        ctx->pb = avio_alloc_context(os->iobuf, sizeof(os->iobuf), AVIO_FLAG_WRITE, os, NULL, dash_write, NULL);
-        if (!ctx->pb)
-            return AVERROR(ENOMEM);
+        if ((ret = avio_open_dyn_buf(&ctx->pb)) < 0)
+            return ret;
 
         if (c->single_file) {
             if (c->single_file_name)
-                dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), c->single_file_name, i, 0, os->bit_rate, 0);
+                ff_dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), c->single_file_name, i, 0, os->bit_rate, 0);
             else
                 snprintf(os->initfile, sizeof(os->initfile), "%s-stream%d.m4s", basename, i);
         } else {
-            dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), c->init_seg_name, i, 0, os->bit_rate, 0);
+            ff_dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), c->init_seg_name, i, 0, os->bit_rate, 0);
         }
         snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile);
         ret = s->io_open(s, &os->out, filename, AVIO_FLAG_WRITE, NULL);
@@ -642,8 +779,13 @@ static int dash_init(AVFormatContext *s)
             return ret;
         os->init_start_pos = 0;
 
-        av_dict_set(&opts, "movflags", "frag_custom+dash+delay_moov", 0);
-        if ((ret = avformat_init_output(ctx, &opts)) < 0)
+        if (!strcmp(os->format_name, "mp4")) {
+            av_dict_set(&opts, "movflags", "frag_custom+dash+delay_moov", 0);
+        } else {
+            dict_set_int(&opts, "cluster_time_limit", c->min_seg_duration / 1000, 0);
+            dict_set_int(&opts, "cluster_size_limit", 5 * 1024 * 1024, 0); // set a large cluster size limit
+        }
+        if ((ret = avformat_write_header(ctx, &opts)) < 0)
             return ret;
         os->ctx_inited = 1;
         avio_flush(ctx->pb);
@@ -651,6 +793,13 @@ static int dash_init(AVFormatContext *s)
 
         av_log(s, AV_LOG_VERBOSE, "Representation %d init segment will be written to: %s\n", i, filename);
 
+        // Flush init segment
+        // except for mp4, since delay_moov is set and the init segment
+        // is then flushed after the first packets
+        if (strcmp(os->format_name, "mp4")) {
+            flush_init_segment(s, os);
+        }
+
         s->streams[i]->time_base = st->time_base;
         // If the muxer wants to shift timestamps, request to have them shifted
         // already before being handed to this muxer, so we don't have mismatches
@@ -667,8 +816,6 @@ static int dash_init(AVFormatContext *s)
                 c->ambiguous_frame_rate = 1;
             }
             c->has_video = 1;
-        } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
-            c->has_audio = 1;
         }
 
         set_codec_str(s, st->codecpar, os->codec_str, sizeof(os->codec_str));
@@ -796,6 +943,10 @@ static int dash_flush(AVFormatContext *s, int final, int stream)
 {
     DASHContext *c = s->priv_data;
     int i, ret = 0;
+
+    const char *proto = avio_find_protocol_name(s->filename);
+    int use_rename = proto && !strcmp(proto, "file");
+
     int cur_flush_segment_index = 0;
     if (stream >= 0)
         cur_flush_segment_index = c->streams[stream].segment_index;
@@ -803,7 +954,6 @@ static int dash_flush(AVFormatContext *s, int final, int stream)
     for (i = 0; i < s->nb_streams; i++) {
         OutputStream *os = &c->streams[i];
         char filename[1024] = "", full_path[1024], temp_path[1024];
-        int64_t start_pos;
         int range_length, index_length = 0;
 
         if (!os->packets_written)
@@ -822,41 +972,52 @@ static int dash_flush(AVFormatContext *s, int final, int stream)
         }
 
         if (!os->init_range_length) {
-            av_write_frame(os->ctx, NULL);
-            os->init_range_length = avio_tell(os->ctx->pb);
-            if (!c->single_file)
-                ff_format_io_close(s, &os->out);
+            flush_init_segment(s, os);
         }
 
-        start_pos = avio_tell(os->ctx->pb);
-
         if (!c->single_file) {
-            dash_fill_tmpl_params(filename, sizeof(filename), c->media_seg_name, i, os->segment_index, os->bit_rate, os->start_pts);
+            ff_dash_fill_tmpl_params(filename, sizeof(filename), c->media_seg_name, i, os->segment_index, os->bit_rate, os->start_pts);
             snprintf(full_path, sizeof(full_path), "%s%s", c->dirname, filename);
-            snprintf(temp_path, sizeof(temp_path), "%s.tmp", full_path);
+            snprintf(temp_path, sizeof(temp_path), use_rename ? "%s.tmp" : "%s", full_path);
             ret = s->io_open(s, &os->out, temp_path, AVIO_FLAG_WRITE, NULL);
             if (ret < 0)
                 break;
-            write_styp(os->ctx->pb);
+            if (!strcmp(os->format_name, "mp4"))
+                write_styp(os->ctx->pb);
         } else {
             snprintf(full_path, sizeof(full_path), "%s%s", c->dirname, os->initfile);
         }
 
-        av_write_frame(os->ctx, NULL);
-        avio_flush(os->ctx->pb);
+        ret = flush_dynbuf(os, &range_length);
+        if (ret < 0)
+            break;
         os->packets_written = 0;
 
-        range_length = avio_tell(os->ctx->pb) - start_pos;
         if (c->single_file) {
-            find_index_range(s, full_path, start_pos, &index_length);
+            find_index_range(s, full_path, os->pos, &index_length);
         } else {
             ff_format_io_close(s, &os->out);
-            ret = avpriv_io_move(temp_path, full_path);
-            if (ret < 0)
-                break;
+
+            if (use_rename) {
+                ret = avpriv_io_move(temp_path, full_path);
+                if (ret < 0)
+                    break;
+            }
         }
-        add_segment(os, filename, os->start_pts, os->max_pts - os->start_pts, start_pos, range_length, index_length);
+
+        if (!os->bit_rate) {
+            // calculate average bitrate of first segment
+            int64_t bitrate = (int64_t) range_length * 8 * AV_TIME_BASE / (os->max_pts - os->start_pts);
+            if (bitrate >= 0) {
+                os->bit_rate = bitrate;
+                snprintf(os->bandwidth_str, sizeof(os->bandwidth_str),
+                     " bandwidth=\"%d\"", os->bit_rate);
+            }
+        }
+        add_segment(os, filename, os->start_pts, os->max_pts - os->start_pts, os->pos, range_length, index_length);
         av_log(s, AV_LOG_VERBOSE, "Representation %d media segment %d written to: %s\n", i, os->segment_index, full_path);
+
+        os->pos += range_length;
     }
 
     if (c->window_size || (final && c->remove_at_exit)) {
@@ -889,7 +1050,6 @@ static int dash_write_packet(AVFormatContext *s, AVPacket *pkt)
     DASHContext *c = s->priv_data;
     AVStream *st = s->streams[pkt->stream_index];
     OutputStream *os = &c->streams[pkt->stream_index];
-    int64_t seg_end_duration = (os->segment_index) * (int64_t) c->min_seg_duration;
     int ret;
 
     ret = update_stream_extradata(s, os, st->codecpar);
@@ -919,8 +1079,8 @@ static int dash_write_packet(AVFormatContext *s, AVPacket *pkt)
 
     if ((!c->has_video || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
         pkt->flags & AV_PKT_FLAG_KEY && os->packets_written &&
-        av_compare_ts(pkt->pts - os->first_pts, st->time_base,
-                      seg_end_duration, AV_TIME_BASE_Q) >= 0) {
+        av_compare_ts(pkt->pts - os->start_pts, st->time_base,
+                      c->min_seg_duration, AV_TIME_BASE_Q) >= 0) {
         int64_t prev_duration = c->last_duration;
 
         c->last_duration = av_rescale_q(pkt->pts - os->start_pts,
@@ -1018,6 +1178,7 @@ static int dash_check_bitstream(struct AVFormatContext *s, const AVPacket *avpkt
 #define OFFSET(x) offsetof(DASHContext, x)
 #define E AV_OPT_FLAG_ENCODING_PARAM
 static const AVOption options[] = {
+    { "adaptation_sets", "Adaptation sets. Syntax: id=0,streams=0,1,2 id=1,streams=3,4 and so on", OFFSET(adaptation_sets), AV_OPT_TYPE_STRING, { 0 }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
     { "window_size", "number of segments kept in the manifest", OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E },
     { "extra_window_size", "number of segments kept outside of the manifest before removing from disk", OFFSET(extra_window_size), AV_OPT_TYPE_INT, { .i64 = 5 }, 0, INT_MAX, E },
     { "min_seg_duration", "minimum segment duration (in microseconds)", OFFSET(min_seg_duration), AV_OPT_TYPE_INT64, { .i64 = 5000000 }, 0, INT_MAX, E },
@@ -1028,6 +1189,7 @@ static const AVOption options[] = {
     { "single_file_name", "DASH-templated name to be used for baseURL. Implies storing all segments in one file, accessed using byte ranges", OFFSET(single_file_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
     { "init_seg_name", "DASH-templated name to used for the initialization segment", OFFSET(init_seg_name), AV_OPT_TYPE_STRING, {.str = "init-stream$RepresentationID$.m4s"}, 0, 0, E },
     { "media_seg_name", "DASH-templated name to used for the media segments", OFFSET(media_seg_name), AV_OPT_TYPE_STRING, {.str = "chunk-stream$RepresentationID$-$Number%05d$.m4s"}, 0, 0, E },
+    { "utc_timing_url", "URL of the page that will return the UTC timestamp in ISO format", OFFSET(utc_timing_url), AV_OPT_TYPE_STRING, { 0 }, 0, 0, E },
     { NULL },
 };
 
@@ -1050,7 +1212,6 @@ AVOutputFormat ff_dash_muxer = {
     .write_packet   = dash_write_packet,
     .write_trailer  = dash_write_trailer,
     .deinit         = dash_free,
-    .codec_tag      = (const AVCodecTag* const []){ ff_mp4_obj_type, 0 },
     .check_bitstream = dash_check_bitstream,
     .priv_class     = &dash_class,
 };
diff --git a/mythtv/external/FFmpeg/libavformat/dsfdec.c b/mythtv/external/FFmpeg/libavformat/dsfdec.c
index f16b397df2c..41538fd83c0 100644
--- a/mythtv/external/FFmpeg/libavformat/dsfdec.c
+++ b/mythtv/external/FFmpeg/libavformat/dsfdec.c
@@ -53,8 +53,10 @@ static void read_id3(AVFormatContext *s, uint64_t id3pos)
         return;
 
     ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
-    if (id3v2_extra_meta)
+    if (id3v2_extra_meta) {
         ff_id3v2_parse_apic(s, &id3v2_extra_meta);
+        ff_id3v2_parse_chapters(s, &id3v2_extra_meta);
+    }
     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
 }
 
@@ -77,7 +79,7 @@ static int dsf_read_header(AVFormatContext *s)
 
     avio_skip(pb, 8);
     id3pos = avio_rl64(pb);
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         read_id3(s, id3pos);
         avio_seek(pb, 28, SEEK_SET);
     }
diff --git a/mythtv/external/FFmpeg/libavformat/dss.c b/mythtv/external/FFmpeg/libavformat/dss.c
index 2f7f20d1348..083eb4ad43b 100644
--- a/mythtv/external/FFmpeg/libavformat/dss.c
+++ b/mythtv/external/FFmpeg/libavformat/dss.c
@@ -42,7 +42,6 @@
 #define DSS_COMMENT_SIZE              64
 
 #define DSS_BLOCK_SIZE                512
-#define DSS_HEADER_SIZE              (DSS_BLOCK_SIZE * 2)
 #define DSS_AUDIO_BLOCK_HEADER_SIZE   6
 #define DSS_FRAME_SIZE                42
 
@@ -56,11 +55,13 @@ typedef struct DSSDemuxContext {
     int8_t *dss_sp_buf;
 
     int packet_size;
+    int dss_header_size;
 } DSSDemuxContext;
 
 static int dss_probe(AVProbeData *p)
 {
-    if (AV_RL32(p->buf) != MKTAG(0x2, 'd', 's', 's'))
+    if (   AV_RL32(p->buf) != MKTAG(0x2, 'd', 's', 's')
+        && AV_RL32(p->buf) != MKTAG(0x3, 'd', 's', 's'))
         return 0;
 
     return AVPROBE_SCORE_MAX;
@@ -120,12 +121,15 @@ static int dss_read_header(AVFormatContext *s)
     DSSDemuxContext *ctx = s->priv_data;
     AVIOContext *pb = s->pb;
     AVStream *st;
-    int ret;
+    int ret, version;
 
     st = avformat_new_stream(s, NULL);
     if (!st)
         return AVERROR(ENOMEM);
 
+    version = avio_r8(pb);
+    ctx->dss_header_size = version * DSS_BLOCK_SIZE;
+
     ret = dss_read_metadata_string(s, DSS_HEAD_OFFSET_AUTHOR,
                                    DSS_AUTHOR_SIZE, "author");
     if (ret)
@@ -164,7 +168,7 @@ static int dss_read_header(AVFormatContext *s)
 
     /* Jump over header */
 
-    if (avio_seek(pb, DSS_HEADER_SIZE, SEEK_SET) != DSS_HEADER_SIZE)
+    if (avio_seek(pb, ctx->dss_header_size, SEEK_SET) != ctx->dss_header_size)
         return AVERROR(EIO);
 
     ctx->counter = 0;
@@ -261,9 +265,6 @@ static int dss_sp_read_packet(AVFormatContext *s, AVPacket *pkt)
         goto error_eof;
     }
 
-    if (pkt->data[0] == 0xff)
-        return AVERROR_INVALIDDATA;
-
     return pkt->size;
 
 error_eof:
@@ -361,7 +362,7 @@ static int dss_read_seek(AVFormatContext *s, int stream_index,
     if (seekto < 0)
         seekto = 0;
 
-    seekto += DSS_HEADER_SIZE;
+    seekto += ctx->dss_header_size;
 
     ret = avio_seek(s->pb, seekto, SEEK_SET);
     if (ret < 0)
diff --git a/mythtv/external/FFmpeg/libavformat/dtsdec.c b/mythtv/external/FFmpeg/libavformat/dtsdec.c
index 8c985b88773..a3e52cd5966 100644
--- a/mythtv/external/FFmpeg/libavformat/dtsdec.c
+++ b/mythtv/external/FFmpeg/libavformat/dtsdec.c
@@ -35,13 +35,13 @@ static int dts_probe(AVProbeData *p)
     uint32_t state = -1;
     int markers[4*16] = {0};
     int exss_markers = 0, exss_nextpos = 0;
-    int sum, max, pos, i;
+    int sum, max, pos, ret, i;
     int64_t diff = 0;
-    uint8_t hdr[12 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
+    uint8_t hdr[DCA_CORE_FRAME_HEADER_SIZE + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
 
     for (pos = FFMIN(4096, p->buf_size); pos < p->buf_size - 2; pos += 2) {
-        int marker, sample_blocks, sample_rate, sr_code, framesize;
-        int lfe, wide_hdr, hdr_size;
+        int marker, wide_hdr, hdr_size, framesize;
+        DCACoreFrameHeader h;
         GetBitContext gb;
 
         bufp = buf = p->buf + pos;
@@ -98,36 +98,13 @@ static int dts_probe(AVProbeData *p)
         else
             continue;
 
-        if (avpriv_dca_convert_bitstream(buf-2, 12, hdr, 12) < 0)
+        if ((ret = avpriv_dca_convert_bitstream(buf - 2, DCA_CORE_FRAME_HEADER_SIZE,
+                                                hdr,     DCA_CORE_FRAME_HEADER_SIZE)) < 0)
             continue;
-
-        init_get_bits(&gb, hdr, 96);
-        skip_bits_long(&gb, 39);
-
-        sample_blocks = get_bits(&gb, 7) + 1;
-        if (sample_blocks < 8)
-            continue;
-
-        framesize = get_bits(&gb, 14) + 1;
-        if (framesize < 95)
-            continue;
-
-        skip_bits(&gb, 6);
-        sr_code = get_bits(&gb, 4);
-        sample_rate = avpriv_dca_sample_rates[sr_code];
-        if (sample_rate == 0)
-            continue;
-
-        get_bits(&gb, 5);
-        if (get_bits(&gb, 1))
-            continue;
-
-        skip_bits_long(&gb, 9);
-        lfe = get_bits(&gb, 2);
-        if (lfe > 2)
+        if (avpriv_dca_parse_core_frame_header(&h, hdr, ret) < 0)
             continue;
 
-        marker += 4* sr_code;
+        marker += 4 * h.sr_code;
 
         markers[marker] ++;
     }
diff --git a/mythtv/external/FFmpeg/libavformat/dtshddec.c b/mythtv/external/FFmpeg/libavformat/dtshddec.c
index f5f040773b2..1bd403c8435 100644
--- a/mythtv/external/FFmpeg/libavformat/dtshddec.c
+++ b/mythtv/external/FFmpeg/libavformat/dtshddec.c
@@ -89,7 +89,7 @@ static int dtshd_read_header(AVFormatContext *s)
             dtshd->data_end = data_start + chunk_size;
             if (dtshd->data_end <= chunk_size)
                 return AVERROR_INVALIDDATA;
-            if (!pb->seekable)
+            if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
                 goto break_loop;
             goto skip;
             break;
diff --git a/mythtv/external/FFmpeg/libavformat/dump.c b/mythtv/external/FFmpeg/libavformat/dump.c
index cd14625f651..77043e3fdbf 100644
--- a/mythtv/external/FFmpeg/libavformat/dump.c
+++ b/mythtv/external/FFmpeg/libavformat/dump.c
@@ -31,6 +31,7 @@
 #include "libavutil/opt.h"
 #include "libavutil/avstring.h"
 #include "libavutil/replaygain.h"
+#include "libavutil/spherical.h"
 #include "libavutil/stereo3d.h"
 
 #include "avformat.h"
@@ -330,7 +331,7 @@ static void dump_mastering_display_metadata(void *ctx, AVPacketSideData* sd) {
     av_log(ctx, AV_LOG_INFO, "Mastering Display Metadata, "
            "has_primaries:%d has_luminance:%d "
            "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) "
-           "min_luminance=%f, max_luminance=%f\n",
+           "min_luminance=%f, max_luminance=%f",
            metadata->has_primaries, metadata->has_luminance,
            av_q2d(metadata->display_primaries[0][0]),
            av_q2d(metadata->display_primaries[0][1]),
@@ -342,6 +343,41 @@ static void dump_mastering_display_metadata(void *ctx, AVPacketSideData* sd) {
            av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
 }
 
+static void dump_content_light_metadata(void *ctx, AVPacketSideData* sd)
+{
+    AVContentLightMetadata* metadata = (AVContentLightMetadata*)sd->data;
+    av_log(ctx, AV_LOG_INFO, "Content Light Level Metadata, "
+           "MaxCLL=%d, MaxFALL=%d",
+           metadata->MaxCLL, metadata->MaxFALL);
+}
+
+static void dump_spherical(void *ctx, AVCodecParameters *par, AVPacketSideData *sd)
+{
+    AVSphericalMapping *spherical = (AVSphericalMapping *)sd->data;
+    double yaw, pitch, roll;
+
+    if (sd->size < sizeof(*spherical)) {
+        av_log(ctx, AV_LOG_INFO, "invalid data");
+        return;
+    }
+
+    av_log(ctx, AV_LOG_INFO, "%s ", av_spherical_projection_name(spherical->projection));
+
+    yaw = ((double)spherical->yaw) / (1 << 16);
+    pitch = ((double)spherical->pitch) / (1 << 16);
+    roll = ((double)spherical->roll) / (1 << 16);
+    av_log(ctx, AV_LOG_INFO, "(%f/%f/%f) ", yaw, pitch, roll);
+
+    if (spherical->projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) {
+        size_t l, t, r, b;
+        av_spherical_tile_bounds(spherical, par->width, par->height,
+                                 &l, &t, &r, &b);
+        av_log(ctx, AV_LOG_INFO, "[%zu, %zu, %zu, %zu] ", l, t, r, b);
+    } else if (spherical->projection == AV_SPHERICAL_CUBEMAP) {
+        av_log(ctx, AV_LOG_INFO, "[pad %"PRIu32"] ", spherical->padding);
+    }
+}
+
 static void dump_sidedata(void *ctx, AVStream *st, const char *indent)
 {
     int i;
@@ -384,7 +420,8 @@ static void dump_sidedata(void *ctx, AVStream *st, const char *indent)
             dump_audioservicetype(ctx, &sd);
             break;
         case AV_PKT_DATA_QUALITY_STATS:
-            av_log(ctx, AV_LOG_INFO, "quality factor: %d, pict_type: %c", AV_RL32(sd.data), av_get_picture_type_char(sd.data[4]));
+            av_log(ctx, AV_LOG_INFO, "quality factor: %"PRId32", pict_type: %c",
+                   AV_RL32(sd.data), av_get_picture_type_char(sd.data[4]));
             break;
         case AV_PKT_DATA_CPB_PROPERTIES:
             av_log(ctx, AV_LOG_INFO, "cpb: ");
@@ -393,6 +430,13 @@ static void dump_sidedata(void *ctx, AVStream *st, const char *indent)
         case AV_PKT_DATA_MASTERING_DISPLAY_METADATA:
             dump_mastering_display_metadata(ctx, &sd);
             break;
+        case AV_PKT_DATA_SPHERICAL:
+            av_log(ctx, AV_LOG_INFO, "spherical: ");
+            dump_spherical(ctx, st->codecpar, &sd);
+            break;
+        case AV_PKT_DATA_CONTENT_LIGHT_LEVEL:
+            dump_content_light_metadata(ctx, &sd);
+            break;
         default:
             av_log(ctx, AV_LOG_INFO,
                    "unknown side data type %d (%d bytes)", sd.type, sd.size);
@@ -551,7 +595,7 @@ void av_dump_format(AVFormatContext *ic, int index,
         }
         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
         if (ic->bit_rate)
-            av_log(NULL, AV_LOG_INFO, "%"PRId64" kb/s", (int64_t)ic->bit_rate / 1000);
+            av_log(NULL, AV_LOG_INFO, "%"PRId64" kb/s", ic->bit_rate / 1000);
         else
             av_log(NULL, AV_LOG_INFO, "N/A");
         av_log(NULL, AV_LOG_INFO, "\n");
diff --git a/mythtv/external/FFmpeg/libavformat/dv.c b/mythtv/external/FFmpeg/libavformat/dv.c
index 89a9e10c14a..06de04485c8 100644
--- a/mythtv/external/FFmpeg/libavformat/dv.c
+++ b/mythtv/external/FFmpeg/libavformat/dv.c
@@ -534,7 +534,7 @@ static int dv_read_header(AVFormatContext *s)
                                (AVRational) { 8, 1 },
                                c->dv_demux->sys->time_base);
 
-    if (s->pb->seekable)
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
         dv_read_timecode(s);
 
     return 0;
diff --git a/mythtv/external/FFmpeg/libavformat/dxa.c b/mythtv/external/FFmpeg/libavformat/dxa.c
index 162838c1351..50193907be1 100644
--- a/mythtv/external/FFmpeg/libavformat/dxa.c
+++ b/mythtv/external/FFmpeg/libavformat/dxa.c
@@ -171,11 +171,13 @@ static int dxa_read_packet(AVFormatContext *s, AVPacket *pkt)
     }
     avio_seek(s->pb, c->vidpos, SEEK_SET);
     while(!avio_feof(s->pb) && c->frames){
+        uint32_t tag;
         if ((ret = avio_read(s->pb, buf, 4)) != 4) {
             av_log(s, AV_LOG_ERROR, "failed reading chunk type\n");
             return ret < 0 ? ret : AVERROR_INVALIDDATA;
         }
-        switch(AV_RL32(buf)){
+        tag = AV_RL32(buf);
+        switch (tag) {
         case MKTAG('N', 'U', 'L', 'L'):
             if(av_new_packet(pkt, 4 + pal_size) < 0)
                 return AVERROR(ENOMEM);
@@ -217,7 +219,7 @@ static int dxa_read_packet(AVFormatContext *s, AVPacket *pkt)
             c->readvid = 0;
             return 0;
         default:
-            av_log(s, AV_LOG_ERROR, "Unknown tag %c%c%c%c\n", buf[0], buf[1], buf[2], buf[3]);
+            av_log(s, AV_LOG_ERROR, "Unknown tag %s\n", av_fourcc2str(tag));
             return AVERROR_INVALIDDATA;
         }
     }
diff --git a/mythtv/external/FFmpeg/libavformat/electronicarts.c b/mythtv/external/FFmpeg/libavformat/electronicarts.c
index 80ce4c6e378..bfd3fed3a2a 100644
--- a/mythtv/external/FFmpeg/libavformat/electronicarts.c
+++ b/mythtv/external/FFmpeg/libavformat/electronicarts.c
@@ -539,7 +539,7 @@ static int ea_read_header(AVFormatContext *s)
             ea->audio_codec = 0;
             return 1;
         }
-        if (ea->bytes <= 0) {
+        if (ea->bytes <= 0 || ea->bytes > 2) {
             av_log(s, AV_LOG_ERROR,
                    "Invalid number of bytes per sample: %d\n", ea->bytes);
             ea->audio_codec = AV_CODEC_ID_NONE;
@@ -557,7 +557,7 @@ static int ea_read_header(AVFormatContext *s)
         st->codecpar->channels              = ea->num_channels;
         st->codecpar->sample_rate           = ea->sample_rate;
         st->codecpar->bits_per_coded_sample = ea->bytes * 8;
-        st->codecpar->bit_rate              = st->codecpar->channels *
+        st->codecpar->bit_rate              = (int64_t)st->codecpar->channels *
                                               st->codecpar->sample_rate *
                                               st->codecpar->bits_per_coded_sample / 4;
         st->codecpar->block_align           = st->codecpar->channels *
diff --git a/mythtv/external/FFmpeg/libavformat/epafdec.c b/mythtv/external/FFmpeg/libavformat/epafdec.c
index 29190fff720..0cd9627a4b2 100644
--- a/mythtv/external/FFmpeg/libavformat/epafdec.c
+++ b/mythtv/external/FFmpeg/libavformat/epafdec.c
@@ -20,6 +20,7 @@
  */
 
 #include "libavutil/intreadwrite.h"
+#include "libavcodec/internal.h"
 #include "avformat.h"
 #include "internal.h"
 #include "pcm.h"
@@ -59,7 +60,7 @@ static int epaf_read_header(AVFormatContext *s)
         channels    = avio_rb32(s->pb);
     }
 
-    if (!channels || !sample_rate)
+    if (channels <= 0 || channels > FF_SANE_NB_CHANNELS || sample_rate <= 0)
         return AVERROR_INVALIDDATA;
 
     st = avformat_new_stream(s, NULL);
diff --git a/mythtv/external/FFmpeg/libavformat/ffmdec.c b/mythtv/external/FFmpeg/libavformat/ffmdec.c
index 16ba8ecf58e..de6ac272523 100644
--- a/mythtv/external/FFmpeg/libavformat/ffmdec.c
+++ b/mythtv/external/FFmpeg/libavformat/ffmdec.c
@@ -21,6 +21,7 @@
 
 #include <stdint.h>
 
+#include "libavutil/imgutils.h"
 #include "libavutil/internal.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/intfloat.h"
@@ -28,6 +29,7 @@
 #include "libavutil/avassert.h"
 #include "libavutil/avstring.h"
 #include "libavutil/pixdesc.h"
+#include "libavcodec/internal.h"
 #include "avformat.h"
 #include "internal.h"
 #include "ffm.h"
@@ -246,16 +248,6 @@ static void adjust_write_index(AVFormatContext *s)
 }
 
 
-static int ffm_close(AVFormatContext *s)
-{
-    int i;
-
-    for (i = 0; i < s->nb_streams; i++)
-        av_freep(&s->streams[i]->codec->rc_eq);
-
-    return 0;
-}
-
 static int ffm_append_recommended_configuration(AVStream *st, char **conf)
 {
     int ret;
@@ -277,14 +269,23 @@ static int ffm_append_recommended_configuration(AVStream *st, char **conf)
     return 0;
 }
 
+#define VALIDATE_PARAMETER(parameter, name, check) {                              \
+    if (check) {                                                                  \
+        av_log(s, AV_LOG_ERROR, "Invalid " name " %d\n", codecpar->parameter);   \
+        ret = AVERROR_INVALIDDATA;                                                \
+        goto fail;                                                                \
+    }                                                                             \
+}
+
 static int ffm2_read_header(AVFormatContext *s)
 {
     FFMContext *ffm = s->priv_data;
-    AVStream *st;
+    AVStream *st = NULL;
     AVIOContext *pb = s->pb;
-    AVCodecContext *codec;
+    AVCodecContext *dummy_codec = NULL;
+    AVCodecParameters *codecpar = NULL;
     const AVCodecDescriptor *codec_desc;
-    int ret, i;
+    int ret;
     int f_main = 0, f_cprv = -1, f_stvi = -1, f_stau = -1;
     AVCodec *enc;
     char *buffer;
@@ -299,19 +300,21 @@ static int ffm2_read_header(AVFormatContext *s)
 
     ffm->write_index = avio_rb64(pb);
     /* get also filesize */
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         ffm->file_size = avio_size(pb);
         if (ffm->write_index && 0)
             adjust_write_index(s);
     } else {
         ffm->file_size = (UINT64_C(1) << 63) - 1;
     }
+    dummy_codec = avcodec_alloc_context3(NULL);
 
     while(!avio_feof(pb)) {
         unsigned id = avio_rb32(pb);
         unsigned size = avio_rb32(pb);
         int64_t next = avio_tell(pb) + size;
         char rc_eq_buf[128];
+        int flags;
 
         if(!id)
             break;
@@ -335,112 +338,132 @@ static int ffm2_read_header(AVFormatContext *s)
 
             avpriv_set_pts_info(st, 64, 1, 1000000);
 
-            codec = st->codec;
+            codecpar = st->codecpar;
             /* generic info */
-            codec->codec_id = avio_rb32(pb);
-            codec_desc = avcodec_descriptor_get(codec->codec_id);
+            codecpar->codec_id = avio_rb32(pb);
+            codec_desc = avcodec_descriptor_get(codecpar->codec_id);
             if (!codec_desc) {
-                av_log(s, AV_LOG_ERROR, "Invalid codec id: %d\n", codec->codec_id);
-                codec->codec_id = AV_CODEC_ID_NONE;
+                av_log(s, AV_LOG_ERROR, "Invalid codec id: %d\n", codecpar->codec_id);
+                codecpar->codec_id = AV_CODEC_ID_NONE;
+                ret = AVERROR_INVALIDDATA;
                 goto fail;
             }
-            codec->codec_type = avio_r8(pb);
-            if (codec->codec_type != codec_desc->type) {
+            codecpar->codec_type = avio_r8(pb);
+            if (codecpar->codec_type != codec_desc->type) {
                 av_log(s, AV_LOG_ERROR, "Codec type mismatch: expected %d, found %d\n",
-                       codec_desc->type, codec->codec_type);
-                codec->codec_id = AV_CODEC_ID_NONE;
-                codec->codec_type = AVMEDIA_TYPE_UNKNOWN;
+                       codec_desc->type, codecpar->codec_type);
+                codecpar->codec_id = AV_CODEC_ID_NONE;
+                codecpar->codec_type = AVMEDIA_TYPE_UNKNOWN;
+                ret = AVERROR_INVALIDDATA;
+                goto fail;
+            }
+            codecpar->bit_rate = avio_rb32(pb);
+            if (codecpar->bit_rate < 0) {
+                av_log(s, AV_LOG_ERROR, "Invalid bit rate %"PRId64"\n", codecpar->bit_rate);
+                ret = AVERROR_INVALIDDATA;
                 goto fail;
             }
-            codec->bit_rate = avio_rb32(pb);
-            codec->flags = avio_rb32(pb);
-            codec->flags2 = avio_rb32(pb);
-            codec->debug = avio_rb32(pb);
-            if (codec->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
+            flags = avio_rb32(pb);
+#if FF_API_LAVF_AVCTX
+FF_DISABLE_DEPRECATION_WARNINGS
+            st->codec->flags = flags;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+            avio_rb32(pb); // flags2
+            avio_rb32(pb); // debug
+            if (flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
                 int size = avio_rb32(pb);
-                codec->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
-                if (!codec->extradata)
-                    return AVERROR(ENOMEM);
-                codec->extradata_size = size;
-                avio_read(pb, codec->extradata, size);
+                if (size < 0 || size >= FF_MAX_EXTRADATA_SIZE) {
+                    av_log(s, AV_LOG_ERROR, "Invalid extradata size %d\n", size);
+                    ret = AVERROR_INVALIDDATA;
+                    goto fail;
+                }
+                codecpar->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
+                if (!codecpar->extradata) {
+                    ret = AVERROR(ENOMEM);
+                    goto fail;
+                }
+                codecpar->extradata_size = size;
+                avio_read(pb, codecpar->extradata, size);
             }
             break;
         case MKBETAG('S', 'T', 'V', 'I'):
-            if (f_stvi++) {
+            if (f_stvi++ || codecpar->codec_type != AVMEDIA_TYPE_VIDEO) {
                 ret = AVERROR(EINVAL);
                 goto fail;
             }
-            codec->time_base.num = avio_rb32(pb);
-            codec->time_base.den = avio_rb32(pb);
-            if (codec->time_base.num <= 0 || codec->time_base.den <= 0) {
-                av_log(s, AV_LOG_ERROR, "Invalid time base %d/%d\n",
-                       codec->time_base.num, codec->time_base.den);
-                ret = AVERROR_INVALIDDATA;
+            avio_rb32(pb); // time_base.num
+            avio_rb32(pb); // time_base.den
+            codecpar->width = avio_rb16(pb);
+            codecpar->height = avio_rb16(pb);
+            ret = av_image_check_size(codecpar->width, codecpar->height, 0, s);
+            if (ret < 0)
                 goto fail;
-            }
-            codec->width = avio_rb16(pb);
-            codec->height = avio_rb16(pb);
-            codec->gop_size = avio_rb16(pb);
-            codec->pix_fmt = avio_rb32(pb);
-            if (!av_pix_fmt_desc_get(codec->pix_fmt)) {
-                av_log(s, AV_LOG_ERROR, "Invalid pix fmt id: %d\n", codec->pix_fmt);
-                codec->pix_fmt = AV_PIX_FMT_NONE;
+            avio_rb16(pb); // gop_size
+            codecpar->format = avio_rb32(pb);
+            if (!av_pix_fmt_desc_get(codecpar->format)) {
+                av_log(s, AV_LOG_ERROR, "Invalid pix fmt id: %d\n", codecpar->format);
+                codecpar->format = AV_PIX_FMT_NONE;
+                ret = AVERROR_INVALIDDATA;
                 goto fail;
             }
-            codec->qmin = avio_r8(pb);
-            codec->qmax = avio_r8(pb);
-            codec->max_qdiff = avio_r8(pb);
-            codec->qcompress = avio_rb16(pb) / 10000.0;
-            codec->qblur = avio_rb16(pb) / 10000.0;
-            codec->bit_rate_tolerance = avio_rb32(pb);
+            avio_r8(pb);   // qmin
+            avio_r8(pb);   // qmax
+            avio_r8(pb);   // max_qdiff
+            avio_rb16(pb); // qcompress / 10000.0
+            avio_rb16(pb); // qblur / 10000.0
+            avio_rb32(pb); // bit_rate_tolerance
             avio_get_str(pb, INT_MAX, rc_eq_buf, sizeof(rc_eq_buf));
-            codec->rc_eq = av_strdup(rc_eq_buf);
-            codec->rc_max_rate = avio_rb32(pb);
-            codec->rc_min_rate = avio_rb32(pb);
-            codec->rc_buffer_size = avio_rb32(pb);
-            codec->i_quant_factor = av_int2double(avio_rb64(pb));
-            codec->b_quant_factor = av_int2double(avio_rb64(pb));
-            codec->i_quant_offset = av_int2double(avio_rb64(pb));
-            codec->b_quant_offset = av_int2double(avio_rb64(pb));
-            codec->dct_algo = avio_rb32(pb);
-            codec->strict_std_compliance = avio_rb32(pb);
-            codec->max_b_frames = avio_rb32(pb);
-            codec->mpeg_quant = avio_rb32(pb);
-            codec->intra_dc_precision = avio_rb32(pb);
-            codec->me_method = avio_rb32(pb);
-            codec->mb_decision = avio_rb32(pb);
-            codec->nsse_weight = avio_rb32(pb);
-            codec->frame_skip_cmp = avio_rb32(pb);
-            codec->rc_buffer_aggressivity = av_int2double(avio_rb64(pb));
-            codec->codec_tag = avio_rb32(pb);
-            codec->thread_count = avio_r8(pb);
-            codec->coder_type = avio_rb32(pb);
-            codec->me_cmp = avio_rb32(pb);
-            codec->me_subpel_quality = avio_rb32(pb);
-            codec->me_range = avio_rb32(pb);
-            codec->keyint_min = avio_rb32(pb);
-            codec->scenechange_threshold = avio_rb32(pb);
-            codec->b_frame_strategy = avio_rb32(pb);
-            codec->qcompress = av_int2double(avio_rb64(pb));
-            codec->qblur = av_int2double(avio_rb64(pb));
-            codec->max_qdiff = avio_rb32(pb);
-            codec->refs = avio_rb32(pb);
+
+            avio_rb32(pb); // rc_max_rate
+            avio_rb32(pb); // rc_min_rate
+            avio_rb32(pb); // rc_buffer_size
+            avio_rb64(pb); // i_quant_factor
+            avio_rb64(pb); // b_quant_factor
+            avio_rb64(pb); // i_quant_offset
+            avio_rb64(pb); // b_quant_offset
+            avio_rb32(pb); // dct_algo
+            avio_rb32(pb); // strict_std_compliance
+            avio_rb32(pb); // max_b_frames
+            avio_rb32(pb); // mpeg_quant
+            avio_rb32(pb); // intra_dc_precision
+            avio_rb32(pb); // me_method
+            avio_rb32(pb); // mb_decision
+            avio_rb32(pb); // nsse_weight
+            avio_rb32(pb); // frame_skip_cmp
+            avio_rb64(pb); // rc_buffer_aggressivity
+            codecpar->codec_tag = avio_rb32(pb);
+            avio_r8(pb);   // thread_count
+            avio_rb32(pb); // coder_type
+            avio_rb32(pb); // me_cmp
+            avio_rb32(pb); // me_subpel_quality
+            avio_rb32(pb); // me_range
+            avio_rb32(pb); // keyint_min
+            avio_rb32(pb); // scenechange_threshold
+            avio_rb32(pb); // b_frame_strategy
+            avio_rb64(pb); // qcompress
+            avio_rb64(pb); // qblur
+            avio_rb32(pb); // max_qdiff
+            avio_rb32(pb); // refs
             break;
         case MKBETAG('S', 'T', 'A', 'U'):
-            if (f_stau++) {
+            if (f_stau++ || codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
                 ret = AVERROR(EINVAL);
                 goto fail;
             }
-            codec->sample_rate = avio_rb32(pb);
-            codec->channels = avio_rl16(pb);
-            codec->frame_size = avio_rl16(pb);
+            codecpar->sample_rate = avio_rb32(pb);
+            VALIDATE_PARAMETER(sample_rate, "sample rate",        codecpar->sample_rate < 0)
+            codecpar->channels = avio_rl16(pb);
+            VALIDATE_PARAMETER(channels,    "number of channels", codecpar->channels < 0)
+            codecpar->frame_size = avio_rl16(pb);
+            VALIDATE_PARAMETER(frame_size,  "frame size",         codecpar->frame_size < 0)
             break;
         case MKBETAG('C', 'P', 'R', 'V'):
             if (f_cprv++) {
                 ret = AVERROR(EINVAL);
                 goto fail;
             }
-            enc = avcodec_find_encoder(codec->codec_id);
+            enc = avcodec_find_encoder(codecpar->codec_id);
             if (enc && enc->priv_data_size && enc->priv_class) {
                 buffer = av_malloc(size + 1);
                 if (!buffer) {
@@ -453,7 +476,7 @@ static int ffm2_read_header(AVFormatContext *s)
             }
             break;
         case MKBETAG('S', '2', 'V', 'I'):
-            if (f_stvi++ || !size) {
+            if (f_stvi++ || !size || codecpar->codec_type != AVMEDIA_TYPE_VIDEO) {
                 ret = AVERROR(EINVAL);
                 goto fail;
             }
@@ -463,12 +486,15 @@ static int ffm2_read_header(AVFormatContext *s)
                 goto fail;
             }
             avio_get_str(pb, INT_MAX, buffer, size);
-            av_set_options_string(codec, buffer, "=", ",");
+            // The lack of AVOptions support in AVCodecParameters makes this back and forth copying needed
+            avcodec_parameters_to_context(dummy_codec, codecpar);
+            av_set_options_string(dummy_codec, buffer, "=", ",");
+            avcodec_parameters_from_context(codecpar, dummy_codec);
             if ((ret = ffm_append_recommended_configuration(st, &buffer)) < 0)
                 goto fail;
             break;
         case MKBETAG('S', '2', 'A', 'U'):
-            if (f_stau++ || !size) {
+            if (f_stau++ || !size || codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
                 ret = AVERROR(EINVAL);
                 goto fail;
             }
@@ -478,7 +504,10 @@ static int ffm2_read_header(AVFormatContext *s)
                 goto fail;
             }
             avio_get_str(pb, INT_MAX, buffer, size);
-            av_set_options_string(codec, buffer, "=", ",");
+            // The lack of AVOptions support in AVCodecParameters makes this back and forth copying needed
+            avcodec_parameters_to_context(dummy_codec, codecpar);
+            av_set_options_string(dummy_codec, buffer, "=", ",");
+            avcodec_parameters_from_context(codecpar, dummy_codec);
             if ((ret = ffm_append_recommended_configuration(st, &buffer)) < 0)
                 goto fail;
             break;
@@ -486,9 +515,6 @@ static int ffm2_read_header(AVFormatContext *s)
         avio_seek(pb, next, SEEK_SET);
     }
 
-    for (i = 0; i < s->nb_streams; i++)
-        avcodec_parameters_from_context(s->streams[i]->codecpar, s->streams[i]->codec);
-
     /* get until end of block reached */
     while ((avio_tell(pb) % ffm->packet_size) != 0 && !pb->eof_reached)
         avio_r8(pb);
@@ -500,9 +526,10 @@ static int ffm2_read_header(AVFormatContext *s)
     ffm->dts = 0;
     ffm->read_state = READ_HEADER;
     ffm->first_packet = 1;
+    avcodec_free_context(&dummy_codec);
     return 0;
  fail:
-    ffm_close(s);
+    avcodec_free_context(&dummy_codec);
     return ret;
 }
 
@@ -511,139 +538,167 @@ static int ffm_read_header(AVFormatContext *s)
     FFMContext *ffm = s->priv_data;
     AVStream *st;
     AVIOContext *pb = s->pb;
-    AVCodecContext *codec;
+    AVCodecContext *dummy_codec = NULL;
+    AVCodecParameters *codecpar;
     const AVCodecDescriptor *codec_desc;
-    int i, nb_streams;
+    int i, nb_streams, ret;
     uint32_t tag;
 
     /* header */
     tag = avio_rl32(pb);
     if (tag == MKTAG('F', 'F', 'M', '2'))
         return ffm2_read_header(s);
-    if (tag != MKTAG('F', 'F', 'M', '1'))
+    if (tag != MKTAG('F', 'F', 'M', '1')) {
+        ret = AVERROR_INVALIDDATA;
         goto fail;
+    }
     ffm->packet_size = avio_rb32(pb);
-    if (ffm->packet_size != FFM_PACKET_SIZE)
+    if (ffm->packet_size != FFM_PACKET_SIZE) {
+        ret = AVERROR_INVALIDDATA;
         goto fail;
+    }
     ffm->write_index = avio_rb64(pb);
     /* get also filesize */
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         ffm->file_size = avio_size(pb);
         if (ffm->write_index && 0)
             adjust_write_index(s);
     } else {
         ffm->file_size = (UINT64_C(1) << 63) - 1;
     }
+    dummy_codec = avcodec_alloc_context3(NULL);
 
     nb_streams = avio_rb32(pb);
     avio_rb32(pb); /* total bitrate */
     /* read each stream */
     for(i=0;i<nb_streams;i++) {
         char rc_eq_buf[128];
+        int flags;
 
         st = avformat_new_stream(s, NULL);
-        if (!st)
+        if (!st) {
+            ret = AVERROR(ENOMEM);
             goto fail;
+        }
 
         avpriv_set_pts_info(st, 64, 1, 1000000);
 
-        codec = st->codec;
+        codecpar = st->codecpar;
         /* generic info */
-        codec->codec_id = avio_rb32(pb);
-        codec_desc = avcodec_descriptor_get(codec->codec_id);
+        codecpar->codec_id = avio_rb32(pb);
+        codec_desc = avcodec_descriptor_get(codecpar->codec_id);
         if (!codec_desc) {
-            av_log(s, AV_LOG_ERROR, "Invalid codec id: %d\n", codec->codec_id);
-            codec->codec_id = AV_CODEC_ID_NONE;
+            av_log(s, AV_LOG_ERROR, "Invalid codec id: %d\n", codecpar->codec_id);
+            codecpar->codec_id = AV_CODEC_ID_NONE;
+            ret = AVERROR_INVALIDDATA;
             goto fail;
         }
-        codec->codec_type = avio_r8(pb); /* codec_type */
-        if (codec->codec_type != codec_desc->type) {
+        codecpar->codec_type = avio_r8(pb); /* codec_type */
+        if (codecpar->codec_type != codec_desc->type) {
             av_log(s, AV_LOG_ERROR, "Codec type mismatch: expected %d, found %d\n",
-                   codec_desc->type, codec->codec_type);
-            codec->codec_id = AV_CODEC_ID_NONE;
-            codec->codec_type = AVMEDIA_TYPE_UNKNOWN;
+                   codec_desc->type, codecpar->codec_type);
+            codecpar->codec_id = AV_CODEC_ID_NONE;
+            codecpar->codec_type = AVMEDIA_TYPE_UNKNOWN;
+            ret = AVERROR_INVALIDDATA;
+            goto fail;
+        }
+        codecpar->bit_rate = avio_rb32(pb);
+        if (codecpar->bit_rate < 0) {
+            av_log(s, AV_LOG_WARNING, "Invalid bit rate %"PRId64"\n", codecpar->bit_rate);
+            ret = AVERROR_INVALIDDATA;
             goto fail;
         }
-        codec->bit_rate = avio_rb32(pb);
-        codec->flags = avio_rb32(pb);
-        codec->flags2 = avio_rb32(pb);
-        codec->debug = avio_rb32(pb);
+        flags = avio_rb32(pb);
+#if FF_API_LAVF_AVCTX
+FF_DISABLE_DEPRECATION_WARNINGS
+            st->codec->flags = flags;
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+        avio_rb32(pb); // flags2
+        avio_rb32(pb); // debug
         /* specific info */
-        switch(codec->codec_type) {
+        switch(codecpar->codec_type) {
         case AVMEDIA_TYPE_VIDEO:
-            codec->time_base.num = avio_rb32(pb);
-            codec->time_base.den = avio_rb32(pb);
-            if (codec->time_base.num <= 0 || codec->time_base.den <= 0) {
-                av_log(s, AV_LOG_ERROR, "Invalid time base %d/%d\n",
-                       codec->time_base.num, codec->time_base.den);
+            avio_rb32(pb); // time_base.num
+            avio_rb32(pb); // time_base.den
+            codecpar->width = avio_rb16(pb);
+            codecpar->height = avio_rb16(pb);
+            if ((ret = av_image_check_size(codecpar->width, codecpar->height, 0, s)) < 0)
                 goto fail;
-            }
-            codec->width = avio_rb16(pb);
-            codec->height = avio_rb16(pb);
-            codec->gop_size = avio_rb16(pb);
-            codec->pix_fmt = avio_rb32(pb);
-            if (!av_pix_fmt_desc_get(codec->pix_fmt)) {
-                av_log(s, AV_LOG_ERROR, "Invalid pix fmt id: %d\n", codec->pix_fmt);
-                codec->pix_fmt = AV_PIX_FMT_NONE;
+            avio_rb16(pb); // gop_size
+            codecpar->format = avio_rb32(pb);
+            if (!av_pix_fmt_desc_get(codecpar->format)) {
+                av_log(s, AV_LOG_ERROR, "Invalid pix fmt id: %d\n", codecpar->format);
+                codecpar->format = AV_PIX_FMT_NONE;
+                ret = AVERROR_INVALIDDATA;
                 goto fail;
             }
-            codec->qmin = avio_r8(pb);
-            codec->qmax = avio_r8(pb);
-            codec->max_qdiff = avio_r8(pb);
-            codec->qcompress = avio_rb16(pb) / 10000.0;
-            codec->qblur = avio_rb16(pb) / 10000.0;
-            codec->bit_rate_tolerance = avio_rb32(pb);
+            avio_r8(pb);   // qmin
+            avio_r8(pb);   // qmax
+            avio_r8(pb);   // max_qdiff
+            avio_rb16(pb); // qcompress / 10000.0
+            avio_rb16(pb); // qblur / 10000.0
+            avio_rb32(pb); // bit_rate_tolerance
             avio_get_str(pb, INT_MAX, rc_eq_buf, sizeof(rc_eq_buf));
-            codec->rc_eq = av_strdup(rc_eq_buf);
-            codec->rc_max_rate = avio_rb32(pb);
-            codec->rc_min_rate = avio_rb32(pb);
-            codec->rc_buffer_size = avio_rb32(pb);
-            codec->i_quant_factor = av_int2double(avio_rb64(pb));
-            codec->b_quant_factor = av_int2double(avio_rb64(pb));
-            codec->i_quant_offset = av_int2double(avio_rb64(pb));
-            codec->b_quant_offset = av_int2double(avio_rb64(pb));
-            codec->dct_algo = avio_rb32(pb);
-            codec->strict_std_compliance = avio_rb32(pb);
-            codec->max_b_frames = avio_rb32(pb);
-            codec->mpeg_quant = avio_rb32(pb);
-            codec->intra_dc_precision = avio_rb32(pb);
-            codec->me_method = avio_rb32(pb);
-            codec->mb_decision = avio_rb32(pb);
-            codec->nsse_weight = avio_rb32(pb);
-            codec->frame_skip_cmp = avio_rb32(pb);
-            codec->rc_buffer_aggressivity = av_int2double(avio_rb64(pb));
-            codec->codec_tag = avio_rb32(pb);
-            codec->thread_count = avio_r8(pb);
-            codec->coder_type = avio_rb32(pb);
-            codec->me_cmp = avio_rb32(pb);
-            codec->me_subpel_quality = avio_rb32(pb);
-            codec->me_range = avio_rb32(pb);
-            codec->keyint_min = avio_rb32(pb);
-            codec->scenechange_threshold = avio_rb32(pb);
-            codec->b_frame_strategy = avio_rb32(pb);
-            codec->qcompress = av_int2double(avio_rb64(pb));
-            codec->qblur = av_int2double(avio_rb64(pb));
-            codec->max_qdiff = avio_rb32(pb);
-            codec->refs = avio_rb32(pb);
+
+            avio_rb32(pb); // rc_max_rate
+            avio_rb32(pb); // rc_min_rate
+            avio_rb32(pb); // rc_buffer_size
+            avio_rb64(pb); // i_quant_factor
+            avio_rb64(pb); // b_quant_factor
+            avio_rb64(pb); // i_quant_offset
+            avio_rb64(pb); // b_quant_offset
+            avio_rb32(pb); // dct_algo
+            avio_rb32(pb); // strict_std_compliance
+            avio_rb32(pb); // max_b_frames
+            avio_rb32(pb); // mpeg_quant
+            avio_rb32(pb); // intra_dc_precision
+            avio_rb32(pb); // me_method
+            avio_rb32(pb); // mb_decision
+            avio_rb32(pb); // nsse_weight
+            avio_rb32(pb); // frame_skip_cmp
+            avio_rb64(pb); // rc_buffer_aggressivity
+            codecpar->codec_tag = avio_rb32(pb);
+            avio_r8(pb);   // thread_count
+            avio_rb32(pb); // coder_type
+            avio_rb32(pb); // me_cmp
+            avio_rb32(pb); // me_subpel_quality
+            avio_rb32(pb); // me_range
+            avio_rb32(pb); // keyint_min
+            avio_rb32(pb); // scenechange_threshold
+            avio_rb32(pb); // b_frame_strategy
+            avio_rb64(pb); // qcompress
+            avio_rb64(pb); // qblur
+            avio_rb32(pb); // max_qdiff
+            avio_rb32(pb); // refs
             break;
         case AVMEDIA_TYPE_AUDIO:
-            codec->sample_rate = avio_rb32(pb);
-            codec->channels = avio_rl16(pb);
-            codec->frame_size = avio_rl16(pb);
+            codecpar->sample_rate = avio_rb32(pb);
+            VALIDATE_PARAMETER(sample_rate, "sample rate",        codecpar->sample_rate < 0)
+            codecpar->channels = avio_rl16(pb);
+            VALIDATE_PARAMETER(channels,    "number of channels", codecpar->channels < 0)
+            codecpar->frame_size = avio_rl16(pb);
+            VALIDATE_PARAMETER(frame_size,  "frame size",         codecpar->frame_size < 0)
             break;
         default:
+            ret = AVERROR_INVALIDDATA;
             goto fail;
         }
-        if (codec->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
+        if (flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
             int size = avio_rb32(pb);
-            codec->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
-            if (!codec->extradata)
-                return AVERROR(ENOMEM);
-            codec->extradata_size = size;
-            avio_read(pb, codec->extradata, size);
+            if (size < 0 || size >= FF_MAX_EXTRADATA_SIZE) {
+                av_log(s, AV_LOG_ERROR, "Invalid extradata size %d\n", size);
+                ret = AVERROR_INVALIDDATA;
+                goto fail;
+            }
+            codecpar->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
+            if (!codecpar->extradata) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+            codecpar->extradata_size = size;
+            avio_read(pb, codecpar->extradata, size);
         }
-
-        avcodec_parameters_from_context(st->codecpar, codec);
     }
 
     /* get until end of block reached */
@@ -657,10 +712,11 @@ static int ffm_read_header(AVFormatContext *s)
     ffm->dts = 0;
     ffm->read_state = READ_HEADER;
     ffm->first_packet = 1;
+    avcodec_free_context(&dummy_codec);
     return 0;
  fail:
-    ffm_close(s);
-    return -1;
+    avcodec_free_context(&dummy_codec);
+    return ret;
 }
 
 /* return < 0 if eof */
@@ -817,7 +873,6 @@ AVInputFormat ff_ffm_demuxer = {
     .read_probe     = ffm_probe,
     .read_header    = ffm_read_header,
     .read_packet    = ffm_read_packet,
-    .read_close     = ffm_close,
     .read_seek      = ffm_seek,
     .priv_class     = &ffm_class,
 };
diff --git a/mythtv/external/FFmpeg/libavformat/ffmenc.c b/mythtv/external/FFmpeg/libavformat/ffmenc.c
index 0f23b796a07..ef7dc3a0311 100644
--- a/mythtv/external/FFmpeg/libavformat/ffmenc.c
+++ b/mythtv/external/FFmpeg/libavformat/ffmenc.c
@@ -95,40 +95,12 @@ static void write_header_chunk(AVIOContext *pb, AVIOContext *dpb, unsigned id)
     av_free(dyn_buf);
 }
 
-static int ffm_write_header_codec_private_ctx(AVFormatContext *s, AVCodecContext *ctx, int type)
-{
-    AVIOContext *pb = s->pb;
-    AVIOContext *tmp;
-    char *buf = NULL;
-    int ret;
-    const AVCodec *enc = ctx->codec ? ctx->codec : avcodec_find_encoder(ctx->codec_id);
-
-    if (!enc) {
-        av_log(s, AV_LOG_WARNING, "Stream codec is not found. Codec private options are not stored.\n");
-        return 0;
-    }
-    if (ctx->priv_data && enc->priv_class && enc->priv_data_size) {
-        if ((ret = av_opt_serialize(ctx->priv_data, AV_OPT_FLAG_ENCODING_PARAM | type,
-                                    AV_OPT_SERIALIZE_SKIP_DEFAULTS, &buf, '=', ',')) < 0)
-            return ret;
-        if (buf && strlen(buf)) {
-            if (avio_open_dyn_buf(&tmp) < 0) {
-                av_free(buf);
-                return AVERROR(ENOMEM);
-            }
-            avio_put_str(tmp, buf);
-            write_header_chunk(pb, tmp, MKBETAG('C', 'P', 'R', 'V'));
-        }
-        av_free(buf);
-    }
-    return 0;
-}
-
-static int ffm_write_header_codec_ctx(AVIOContext *pb, AVCodecContext *ctx, unsigned tag, int type)
+static int ffm_write_header_codec_ctx(AVIOContext *pb, AVCodecParameters *ctxpar, unsigned tag, int type)
 {
     AVIOContext *tmp;
     char *buf = NULL;
     int ret, need_coma = 0;
+    AVCodecContext *ctx = NULL;
 
 #define SKIP_DEFAULTS   AV_OPT_SERIALIZE_SKIP_DEFAULTS
 #define OPT_FLAGS_EXACT AV_OPT_SERIALIZE_OPT_FLAGS_EXACT
@@ -136,6 +108,16 @@ static int ffm_write_header_codec_ctx(AVIOContext *pb, AVCodecContext *ctx, unsi
 
     if (avio_open_dyn_buf(&tmp) < 0)
         return AVERROR(ENOMEM);
+
+    // AVCodecParameters does not suport AVOptions, we thus must copy it over to a context that does
+    // otherwise it could be used directly and this would be much simpler
+    ctx = avcodec_alloc_context3(NULL);
+    if (!ctx) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+    avcodec_parameters_to_context(ctx, ctxpar);
+
     if ((ret = av_opt_serialize(ctx, ENC | type, SKIP_DEFAULTS, &buf, '=', ',')) < 0)
         goto fail;
     if (buf && strlen(buf)) {
@@ -153,10 +135,12 @@ static int ffm_write_header_codec_ctx(AVIOContext *pb, AVCodecContext *ctx, unsi
     av_freep(&buf);
     avio_w8(tmp, 0);
     write_header_chunk(pb, tmp, tag);
+    avcodec_free_context(&ctx);
     return 0;
   fail:
     av_free(buf);
     ffio_free_dyn_buf(&tmp);
+    avcodec_free_context(&ctx);
     return ret;
 
 #undef SKIP_DEFAULTS
@@ -164,11 +148,11 @@ static int ffm_write_header_codec_ctx(AVIOContext *pb, AVCodecContext *ctx, unsi
 #undef ENC
 }
 
-static int ffm_write_recommended_config(AVIOContext *pb, AVCodecContext *ctx, unsigned tag,
+static int ffm_write_recommended_config(AVIOContext *pb, AVCodecParameters *codecpar, unsigned tag,
                                         const char *configuration)
 {
     int ret;
-    const AVCodec *enc = ctx->codec ? ctx->codec : avcodec_find_encoder(ctx->codec_id);
+    const AVCodec *enc = avcodec_find_encoder(codecpar->codec_id);
     AVIOContext *tmp;
     AVDictionaryEntry *t = NULL;
     AVDictionary *all = NULL, *comm = NULL, *prv = NULL;
@@ -223,7 +207,7 @@ static int ffm_write_header(AVFormatContext *s)
     FFMContext *ffm = s->priv_data;
     AVStream *st;
     AVIOContext *pb = s->pb;
-    AVCodecContext *codec;
+    AVCodecParameters *codecpar;
     int bit_rate, i, ret;
 
     if ((ret = ff_parse_creation_time_metadata(s, &ffm->start_time, 0)) < 0)
@@ -243,7 +227,7 @@ static int ffm_write_header(AVFormatContext *s)
     bit_rate = 0;
     for(i=0;i<s->nb_streams;i++) {
         st = s->streams[i];
-        bit_rate += st->codec->bit_rate;
+        bit_rate += st->codecpar->bit_rate;
     }
     avio_wb32(pb, bit_rate);
 
@@ -251,46 +235,54 @@ static int ffm_write_header(AVFormatContext *s)
 
     /* list of streams */
     for(i=0;i<s->nb_streams;i++) {
+        int flags = 0;
         st = s->streams[i];
         avpriv_set_pts_info(st, 64, 1, 1000000);
         if(avio_open_dyn_buf(&pb) < 0)
             return AVERROR(ENOMEM);
 
-        codec = st->codec;
+        codecpar = st->codecpar;
         /* generic info */
-        avio_wb32(pb, codec->codec_id);
-        avio_w8(pb, codec->codec_type);
-        avio_wb32(pb, codec->bit_rate);
-        avio_wb32(pb, codec->flags);
-        avio_wb32(pb, codec->flags2);
-        avio_wb32(pb, codec->debug);
-        if (codec->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
-            avio_wb32(pb, codec->extradata_size);
-            avio_write(pb, codec->extradata, codec->extradata_size);
+        avio_wb32(pb, codecpar->codec_id);
+        avio_w8(pb, codecpar->codec_type);
+        avio_wb32(pb, codecpar->bit_rate);
+        if (codecpar->extradata_size)
+            flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
+
+        // If the user is not providing us with a configuration we have to fill it in as we cannot access the encoder
+        if (!st->recommended_encoder_configuration) {
+            if (s->flags & AVFMT_FLAG_BITEXACT)
+                flags |= AV_CODEC_FLAG_BITEXACT;
+        }
+
+        avio_wb32(pb, flags);
+        avio_wb32(pb, 0); // flags2
+        avio_wb32(pb, 0); // debug
+        if (codecpar->extradata_size) {
+            avio_wb32(pb, codecpar->extradata_size);
+            avio_write(pb, codecpar->extradata, codecpar->extradata_size);
         }
         write_header_chunk(s->pb, pb, MKBETAG('C', 'O', 'M', 'M'));
         /* specific info */
-        switch(codec->codec_type) {
+        switch(codecpar->codec_type) {
         case AVMEDIA_TYPE_VIDEO:
             if (st->recommended_encoder_configuration) {
                 av_log(NULL, AV_LOG_DEBUG, "writing recommended configuration: %s\n",
                        st->recommended_encoder_configuration);
-                if ((ret = ffm_write_recommended_config(s->pb, codec, MKBETAG('S', '2', 'V', 'I'),
+                if ((ret = ffm_write_recommended_config(s->pb, codecpar, MKBETAG('S', '2', 'V', 'I'),
                                                         st->recommended_encoder_configuration)) < 0)
                 return ret;
-            } else if ((ret = ffm_write_header_codec_ctx(s->pb, codec, MKBETAG('S', '2', 'V', 'I'), AV_OPT_FLAG_VIDEO_PARAM)) < 0 ||
-                       (ret = ffm_write_header_codec_private_ctx(s, codec, AV_OPT_FLAG_VIDEO_PARAM)) < 0)
+            } else if ((ret = ffm_write_header_codec_ctx(s->pb, codecpar, MKBETAG('S', '2', 'V', 'I'), AV_OPT_FLAG_VIDEO_PARAM)) < 0)
                 return ret;
             break;
         case AVMEDIA_TYPE_AUDIO:
             if (st->recommended_encoder_configuration) {
                 av_log(NULL, AV_LOG_DEBUG, "writing recommended configuration: %s\n",
                        st->recommended_encoder_configuration);
-                if ((ret = ffm_write_recommended_config(s->pb, codec, MKBETAG('S', '2', 'A', 'U'),
+                if ((ret = ffm_write_recommended_config(s->pb, codecpar, MKBETAG('S', '2', 'A', 'U'),
                                                         st->recommended_encoder_configuration)) < 0)
                 return ret;
-            } else if ((ret = ffm_write_header_codec_ctx(s->pb, codec, MKBETAG('S', '2', 'A', 'U'), AV_OPT_FLAG_AUDIO_PARAM)) < 0 ||
-                     (ret = ffm_write_header_codec_private_ctx(s, codec, AV_OPT_FLAG_AUDIO_PARAM)) < 0)
+            } else if ((ret = ffm_write_header_codec_ctx(s->pb, codecpar, MKBETAG('S', '2', 'A', 'U'), AV_OPT_FLAG_AUDIO_PARAM)) < 0)
                 return ret;
             break;
         default:
diff --git a/mythtv/external/FFmpeg/libavformat/fifo.c b/mythtv/external/FFmpeg/libavformat/fifo.c
index 15435fe3080..c881f31e94f 100644
--- a/mythtv/external/FFmpeg/libavformat/fifo.c
+++ b/mythtv/external/FFmpeg/libavformat/fifo.c
@@ -19,6 +19,7 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/avassert.h"
 #include "libavutil/opt.h"
 #include "libavutil/time.h"
 #include "libavutil/thread.h"
@@ -73,6 +74,7 @@ typedef struct FifoContext {
     int restart_with_keyframe;
 
     pthread_mutex_t overflow_flag_lock;
+    int overflow_flag_lock_initialized;
     /* Value > 0 signals queue overflow */
     volatile uint8_t overflow_flag;
 
@@ -206,7 +208,7 @@ static int fifo_thread_write_trailer(FifoThreadContext *ctx)
 
 static int fifo_thread_dispatch_message(FifoThreadContext *ctx, FifoMessage *msg)
 {
-    int ret;
+    int ret = AVERROR(EINVAL);
 
     if (!ctx->header_written) {
         ret = fifo_thread_write_header(ctx);
@@ -216,6 +218,7 @@ static int fifo_thread_dispatch_message(FifoThreadContext *ctx, FifoMessage *msg
 
     switch(msg->type) {
     case FIFO_WRITE_HEADER:
+        av_assert0(ret >= 0);
         return ret;
     case FIFO_WRITE_PACKET:
         return fifo_thread_write_packet(ctx, &msg->pkt);
@@ -223,6 +226,7 @@ static int fifo_thread_dispatch_message(FifoThreadContext *ctx, FifoMessage *msg
         return fifo_thread_flush_output(ctx);
     }
 
+    av_assert0(0);
     return AVERROR(EINVAL);
 }
 
@@ -438,13 +442,14 @@ static void *fifo_consumer_thread(void *data)
     return NULL;
 }
 
-static int fifo_mux_init(AVFormatContext *avf, AVOutputFormat *oformat)
+static int fifo_mux_init(AVFormatContext *avf, AVOutputFormat *oformat,
+                         const char *filename)
 {
     FifoContext *fifo = avf->priv_data;
     AVFormatContext *avf2;
     int ret = 0, i;
 
-    ret = avformat_alloc_output_context2(&avf2, oformat, NULL, NULL);
+    ret = avformat_alloc_output_context2(&avf2, oformat, NULL, filename);
     if (ret < 0)
         return ret;
 
@@ -501,7 +506,7 @@ static int fifo_init(AVFormatContext *avf)
         return ret;
     }
 
-    ret = fifo_mux_init(avf, oformat);
+    ret = fifo_mux_init(avf, oformat, avf->filename);
     if (ret < 0)
         return ret;
 
@@ -515,6 +520,7 @@ static int fifo_init(AVFormatContext *avf)
     ret = pthread_mutex_init(&fifo->overflow_flag_lock, NULL);
     if (ret < 0)
         return AVERROR(ret);
+    fifo->overflow_flag_lock_initialized = 1;
 
     return 0;
 }
@@ -601,7 +607,8 @@ static void fifo_deinit(AVFormatContext *avf)
     av_dict_free(&fifo->format_options);
     avformat_free_context(fifo->avf);
     av_thread_message_queue_free(&fifo->queue);
-    pthread_mutex_destroy(&fifo->overflow_flag_lock);
+    if (fifo->overflow_flag_lock_initialized)
+        pthread_mutex_destroy(&fifo->overflow_flag_lock);
 }
 
 #define OFFSET(x) offsetof(FifoContext, x)
diff --git a/mythtv/external/FFmpeg/libavformat/file.c b/mythtv/external/FFmpeg/libavformat/file.c
index 264542a36a7..1d321c42050 100644
--- a/mythtv/external/FFmpeg/libavformat/file.c
+++ b/mythtv/external/FFmpeg/libavformat/file.c
@@ -112,6 +112,8 @@ static int file_read(URLContext *h, unsigned char *buf, int size)
     ret = read(c->fd, buf, size);
     if (ret == 0 && c->follow)
         return AVERROR(EAGAIN);
+    if (ret == 0)
+        return AVERROR_EOF;
     return (ret == -1) ? AVERROR(errno) : ret;
 }
 
@@ -227,6 +229,11 @@ static int file_open(URLContext *h, const char *filename, int flags)
 
     h->is_streamed = !fstat(fd, &st) && S_ISFIFO(st.st_mode);
 
+    /* Buffer writes more than the default 32k to improve throughput especially
+     * with networked file systems */
+    if (!h->is_streamed && flags & AVIO_FLAG_WRITE)
+        h->min_packet_size = h->max_packet_size = 262144;
+
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavformat/filmstripdec.c b/mythtv/external/FFmpeg/libavformat/filmstripdec.c
index 414e276bfe9..0bf5a808303 100644
--- a/mythtv/external/FFmpeg/libavformat/filmstripdec.c
+++ b/mythtv/external/FFmpeg/libavformat/filmstripdec.c
@@ -25,6 +25,7 @@
  */
 
 #include "libavutil/intreadwrite.h"
+#include "libavutil/imgutils.h"
 #include "avformat.h"
 #include "internal.h"
 
@@ -40,7 +41,7 @@ static int read_header(AVFormatContext *s)
     AVIOContext *pb = s->pb;
     AVStream *st;
 
-    if (!s->pb->seekable)
+    if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
         return AVERROR(EIO);
 
     avio_seek(pb, avio_size(pb) - 36, SEEK_SET);
@@ -68,10 +69,8 @@ static int read_header(AVFormatContext *s)
     st->codecpar->height     = avio_rb16(pb);
     film->leading         = avio_rb16(pb);
 
-    if (st->codecpar->width * 4LL * st->codecpar->height >= INT_MAX) {
-        av_log(s, AV_LOG_ERROR, "dimensions too large\n");
-        return AVERROR_PATCHWELCOME;
-    }
+    if (av_image_check_size(st->codecpar->width, st->codecpar->height, 0, s) < 0)
+        return AVERROR_INVALIDDATA;
 
     avpriv_set_pts_info(st, 64, 1, avio_rb16(pb));
 
diff --git a/mythtv/external/FFmpeg/libavformat/fitsdec.c b/mythtv/external/FFmpeg/libavformat/fitsdec.c
new file mode 100644
index 00000000000..4b288b39039
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/fitsdec.c
@@ -0,0 +1,231 @@
+/*
+ * FITS demuxer
+ * Copyright (c) 2017 Paras Chadha
+ *
+ * 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
+ * FITS demuxer.
+ */
+
+#include "libavutil/intreadwrite.h"
+#include "internal.h"
+#include "libavutil/opt.h"
+#include "libavcodec/fits.h"
+#include "libavutil/bprint.h"
+
+#define FITS_BLOCK_SIZE 2880
+
+typedef struct FITSContext {
+    const AVClass *class;
+    AVRational framerate;
+    int first_image;
+    int64_t pts;
+} FITSContext;
+
+static int fits_probe(AVProbeData *p)
+{
+    const uint8_t *b = p->buf;
+    if (!memcmp(b, "SIMPLE  =                    T", 30))
+        return AVPROBE_SCORE_MAX - 1;
+    return 0;
+}
+
+static int fits_read_header(AVFormatContext *s)
+{
+    AVStream *st;
+    FITSContext * fits = s->priv_data;
+
+    st = avformat_new_stream(s, NULL);
+    if (!st)
+        return AVERROR(ENOMEM);
+
+    st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
+    st->codecpar->codec_id = AV_CODEC_ID_FITS;
+
+    avpriv_set_pts_info(st, 64, fits->framerate.den, fits->framerate.num);
+    fits->pts = 0;
+    fits->first_image = 1;
+    return 0;
+}
+
+/**
+ * Parses header and checks that the current HDU contains image or not
+ * It also stores the header in the avbuf and stores the size of data part in data_size
+ * @param s pointer to AVFormat Context
+ * @param fits pointer to FITSContext
+ * @param header pointer to FITSHeader
+ * @param avbuf pointer to AVBPrint to store the header
+ * @param data_size to store the size of data part
+ * @return 1 if image found, 0 if any other extension and AVERROR_INVALIDDATA otherwise
+ */
+static int64_t is_image(AVFormatContext *s, FITSContext *fits, FITSHeader *header,
+                         AVBPrint *avbuf, uint64_t *data_size)
+{
+    int i, ret, image = 0;
+    char buf[FITS_BLOCK_SIZE] = { 0 };
+    int64_t buf_size = 0, size = 0, t;
+
+    do {
+        ret = avio_read(s->pb, buf, FITS_BLOCK_SIZE);
+        if (ret < 0) {
+            return ret;
+        } else if (ret < FITS_BLOCK_SIZE) {
+            return AVERROR_INVALIDDATA;
+        }
+
+        av_bprint_append_data(avbuf, buf, FITS_BLOCK_SIZE);
+        ret = 0;
+        buf_size = 0;
+        while(!ret && buf_size < FITS_BLOCK_SIZE) {
+            ret = avpriv_fits_header_parse_line(s, header, buf + buf_size, NULL);
+            buf_size += 80;
+        }
+    } while (!ret);
+    if (ret < 0)
+        return ret;
+
+    image = fits->first_image || header->image_extension;
+    fits->first_image = 0;
+
+    if (header->groups) {
+        image = 0;
+        if (header->naxis > 1)
+            size = 1;
+    } else if (header->naxis) {
+        size = header->naxisn[0];
+    } else {
+        image = 0;
+    }
+
+    for (i = 1; i < header->naxis; i++) {
+        if(size && header->naxisn[i] > UINT64_MAX / size)
+            return AVERROR_INVALIDDATA;
+        size *= header->naxisn[i];
+    }
+
+    if(header->pcount > UINT64_MAX - size)
+        return AVERROR_INVALIDDATA;
+    size += header->pcount;
+
+    t = (abs(header->bitpix) >> 3) * ((int64_t) header->gcount);
+    if(size && t > UINT64_MAX / size)
+        return AVERROR_INVALIDDATA;
+    size *= t;
+
+    if (!size) {
+        image = 0;
+    } else {
+        if(FITS_BLOCK_SIZE - 1 > UINT64_MAX - size)
+            return AVERROR_INVALIDDATA;
+        size = ((size + FITS_BLOCK_SIZE - 1) / FITS_BLOCK_SIZE) * FITS_BLOCK_SIZE;
+    }
+    *data_size = size;
+    return image;
+}
+
+static int fits_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    int64_t pos, ret;
+    uint64_t size;
+    FITSContext *fits = s->priv_data;
+    FITSHeader header;
+    AVBPrint avbuf;
+    char *buf;
+
+    if (fits->first_image) {
+        avpriv_fits_header_init(&header, STATE_SIMPLE);
+    } else {
+        avpriv_fits_header_init(&header, STATE_XTENSION);
+    }
+
+    av_bprint_init(&avbuf, FITS_BLOCK_SIZE, AV_BPRINT_SIZE_UNLIMITED);
+    while ((ret = is_image(s, fits, &header, &avbuf, &size)) == 0) {
+        pos = avio_skip(s->pb, size);
+        if (pos < 0)
+            return pos;
+
+        av_bprint_finalize(&avbuf, NULL);
+        av_bprint_init(&avbuf, FITS_BLOCK_SIZE, AV_BPRINT_SIZE_UNLIMITED);
+        avpriv_fits_header_init(&header, STATE_XTENSION);
+    }
+    if (ret < 0)
+        goto fail;
+
+    if (!av_bprint_is_complete(&avbuf)) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    // Header is sent with the first line removed...
+    ret = av_new_packet(pkt, avbuf.len - 80 + size);
+    if (ret < 0)
+        goto fail;
+
+    pkt->stream_index = 0;
+    pkt->flags |= AV_PKT_FLAG_KEY;
+
+    ret = av_bprint_finalize(&avbuf, &buf);
+    if (ret < 0) {
+        av_packet_unref(pkt);
+        return ret;
+    }
+
+    memcpy(pkt->data, buf + 80, avbuf.len - 80);
+    pkt->size = avbuf.len - 80;
+    av_freep(&buf);
+    ret = avio_read(s->pb, pkt->data + pkt->size, size);
+    if (ret < 0) {
+        av_packet_unref(pkt);
+        return ret;
+    }
+
+    pkt->size += ret;
+    pkt->pts = fits->pts;
+    fits->pts++;
+
+    return 0;
+
+fail:
+    av_bprint_finalize(&avbuf, NULL);
+    return ret;
+}
+
+static const AVOption fits_options[] = {
+    { "framerate", "set the framerate", offsetof(FITSContext, framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "1"}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM},
+    { NULL },
+};
+
+static const AVClass fits_demuxer_class = {
+    .class_name = "FITS demuxer",
+    .item_name  = av_default_item_name,
+    .option     = fits_options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVInputFormat ff_fits_demuxer = {
+    .name           = "fits",
+    .long_name      = NULL_IF_CONFIG_SMALL("Flexible Image Transport System"),
+    .priv_data_size = sizeof(FITSContext),
+    .read_probe     = fits_probe,
+    .read_header    = fits_read_header,
+    .read_packet    = fits_read_packet,
+    .priv_class     = &fits_demuxer_class,
+    .raw_codec_id   = AV_CODEC_ID_FITS,
+};
diff --git a/mythtv/external/FFmpeg/libavformat/fitsenc.c b/mythtv/external/FFmpeg/libavformat/fitsenc.c
new file mode 100644
index 00000000000..7cb171596c4
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/fitsenc.c
@@ -0,0 +1,183 @@
+/*
+ * FITS muxer
+ * Copyright (c) 2017 Paras Chadha
+ *
+ * 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
+ * FITS muxer.
+ */
+
+#include "internal.h"
+
+typedef struct FITSContext {
+    int first_image;
+} FITSContext;
+
+static int fits_write_header(AVFormatContext *s)
+{
+    FITSContext *fitsctx = s->priv_data;
+    fitsctx->first_image = 1;
+    return 0;
+}
+
+/**
+ * Write one header line comprising of keyword and value(int)
+ * @param s AVFormat Context
+ * @param keyword pointer to the char array in which keyword is stored
+ * @param value the value corresponding to the keyword
+ * @param lines_written to keep track of lines written so far
+ * @return 0
+ */
+static int write_keyword_value(AVFormatContext *s, const char *keyword, int value, int *lines_written)
+{
+    int len, ret;
+    uint8_t header[80];
+
+    len = strlen(keyword);
+    memset(header, ' ', sizeof(header));
+    memcpy(header, keyword, len);
+
+    header[8] = '=';
+    header[9] = ' ';
+
+    ret = snprintf(header + 10, 70, "%d", value);
+    memset(&header[ret + 10], ' ', sizeof(header) - (ret + 10));
+
+    avio_write(s->pb, header, sizeof(header));
+    *lines_written += 1;
+    return 0;
+}
+
+static int write_image_header(AVFormatContext *s)
+{
+    AVStream *st = s->streams[0];
+    AVCodecParameters *encctx = st->codecpar;
+    FITSContext *fitsctx = s->priv_data;
+    uint8_t buffer[80];
+    int bitpix, naxis, naxis3 = 1, bzero = 0, rgb = 0, lines_written = 0, lines_left;
+
+    switch (encctx->format) {
+        case AV_PIX_FMT_GRAY8:
+            bitpix = 8;
+            naxis = 2;
+            break;
+        case AV_PIX_FMT_GRAY16BE:
+            bitpix = 16;
+            naxis = 2;
+            bzero = 32768;
+            break;
+        case AV_PIX_FMT_GBRP:
+        case AV_PIX_FMT_GBRAP:
+            bitpix = 8;
+            naxis = 3;
+            rgb = 1;
+            if (encctx->format == AV_PIX_FMT_GBRP) {
+                naxis3 = 3;
+            } else {
+                naxis3 = 4;
+            }
+            break;
+        case AV_PIX_FMT_GBRP16BE:
+        case AV_PIX_FMT_GBRAP16BE:
+            bitpix = 16;
+            naxis = 3;
+            rgb = 1;
+            if (encctx->format == AV_PIX_FMT_GBRP16BE) {
+                naxis3 = 3;
+            } else {
+                naxis3 = 4;
+            }
+            bzero = 32768;
+            break;
+    }
+
+    if (fitsctx->first_image) {
+        memcpy(buffer, "SIMPLE  = ", 10);
+        memset(buffer + 10, ' ', 70);
+        buffer[29] = 'T';
+        avio_write(s->pb, buffer, sizeof(buffer));
+    } else {
+        memcpy(buffer, "XTENSION= 'IMAGE   '", 20);
+        memset(buffer + 20, ' ', 60);
+        avio_write(s->pb, buffer, sizeof(buffer));
+    }
+    lines_written++;
+
+    write_keyword_value(s, "BITPIX", bitpix, &lines_written);         // no of bits per pixel
+    write_keyword_value(s, "NAXIS", naxis, &lines_written);           // no of dimensions of image
+    write_keyword_value(s, "NAXIS1", encctx->width, &lines_written);   // first dimension i.e. width
+    write_keyword_value(s, "NAXIS2", encctx->height, &lines_written);  // second dimension i.e. height
+
+    if (rgb)
+        write_keyword_value(s, "NAXIS3", naxis3, &lines_written);     // third dimension to store RGBA planes
+
+    if (!fitsctx->first_image) {
+        write_keyword_value(s, "PCOUNT", 0, &lines_written);
+        write_keyword_value(s, "GCOUNT", 1, &lines_written);
+    } else {
+        fitsctx->first_image = 0;
+    }
+
+    /*
+     * Since FITS does not support unsigned 16 bit integers,
+     * BZERO = 32768 is used to store unsigned 16 bit integers as
+     * signed integers so that it can be read properly.
+     */
+    if (bitpix == 16)
+        write_keyword_value(s, "BZERO", bzero, &lines_written);
+
+    if (rgb) {
+        memcpy(buffer, "CTYPE3  = 'RGB     '", 20);
+        memset(buffer + 20, ' ', 60);
+        avio_write(s->pb, buffer, sizeof(buffer));
+        lines_written++;
+    }
+
+    memcpy(buffer, "END", 3);
+    memset(buffer + 3, ' ', 77);
+    avio_write(s->pb, buffer, sizeof(buffer));
+    lines_written++;
+
+    lines_left = ((lines_written + 35) / 36) * 36 - lines_written;
+    memset(buffer, ' ', 80);
+    while (lines_left > 0) {
+        avio_write(s->pb, buffer, sizeof(buffer));
+        lines_left--;
+    }
+    return 0;
+}
+
+static int fits_write_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    write_image_header(s);
+    avio_write(s->pb, pkt->data, pkt->size);
+    return 0;
+}
+
+AVOutputFormat ff_fits_muxer = {
+    .name         = "fits",
+    .long_name    = NULL_IF_CONFIG_SMALL("Flexible Image Transport System"),
+    .extensions   = "fits",
+    .priv_data_size = sizeof(FITSContext),
+    .audio_codec  = AV_CODEC_ID_NONE,
+    .video_codec  = AV_CODEC_ID_FITS,
+    .write_header = fits_write_header,
+    .write_packet = fits_write_packet,
+};
diff --git a/mythtv/external/FFmpeg/libavformat/flac_picture.c b/mythtv/external/FFmpeg/libavformat/flac_picture.c
index a3217f02a6b..38982b960de 100644
--- a/mythtv/external/FFmpeg/libavformat/flac_picture.c
+++ b/mythtv/external/FFmpeg/libavformat/flac_picture.c
@@ -140,14 +140,14 @@ int ff_flac_parse_picture(AVFormatContext *s, uint8_t *buf, int buf_size)
     if (desc)
         av_dict_set(&st->metadata, "title", desc, AV_DICT_DONT_STRDUP_VAL);
 
-    av_freep(&pb);
+    avio_context_free(&pb);
 
     return 0;
 
 fail:
     av_buffer_unref(&data);
     av_freep(&desc);
-    av_freep(&pb);
+    avio_context_free(&pb);
 
     return ret;
 }
diff --git a/mythtv/external/FFmpeg/libavformat/flacdec.c b/mythtv/external/FFmpeg/libavformat/flacdec.c
index 3060dc45fd7..a0323780452 100644
--- a/mythtv/external/FFmpeg/libavformat/flacdec.c
+++ b/mythtv/external/FFmpeg/libavformat/flacdec.c
@@ -65,7 +65,8 @@ static int flac_read_header(AVFormatContext *s)
 
     /* process metadata blocks */
     while (!avio_feof(s->pb) && !metadata_last) {
-        avio_read(s->pb, header, 4);
+        if (avio_read(s->pb, header, 4) != 4)
+            return AVERROR(AVERROR_INVALIDDATA);
         flac_parse_block_header(header, &metadata_last, &metadata_type,
                                    &metadata_size);
         switch (metadata_type) {
@@ -230,9 +231,27 @@ static int flac_probe(AVProbeData *p)
 {
     if ((AV_RB16(p->buf) & 0xFFFE) == 0xFFF8)
         return raw_flac_probe(p);
-    if (p->buf_size < 4 || memcmp(p->buf, "fLaC", 4))
-        return 0;
-    return AVPROBE_SCORE_EXTENSION;
+
+    /* file header + metadata header + checked bytes of streaminfo */
+    if (p->buf_size >= 4 + 4 + 13) {
+        int type           = p->buf[4] & 0x7f;
+        int size           = AV_RB24(p->buf + 5);
+        int min_block_size = AV_RB16(p->buf + 8);
+        int max_block_size = AV_RB16(p->buf + 10);
+        int sample_rate    = AV_RB24(p->buf + 18) >> 4;
+
+        if (memcmp(p->buf, "fLaC", 4))
+            return 0;
+        if (type == FLAC_METADATA_TYPE_STREAMINFO &&
+            size == FLAC_STREAMINFO_SIZE          &&
+            min_block_size >= 16                  &&
+            max_block_size >= min_block_size      &&
+            sample_rate && sample_rate <= 655350)
+            return AVPROBE_SCORE_MAX;
+        return AVPROBE_SCORE_EXTENSION;
+    }
+
+    return 0;
 }
 
 static av_unused int64_t flac_read_timestamp(AVFormatContext *s, int stream_index,
diff --git a/mythtv/external/FFmpeg/libavformat/flacenc.c b/mythtv/external/FFmpeg/libavformat/flacenc.c
index 89b21e9e23c..b894f9ef614 100644
--- a/mythtv/external/FFmpeg/libavformat/flacenc.c
+++ b/mythtv/external/FFmpeg/libavformat/flacenc.c
@@ -147,7 +147,7 @@ static int flac_write_trailer(struct AVFormatContext *s)
     if (!c->write_header || !streaminfo)
         return 0;
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         /* rewrite the STREAMINFO header block data */
         file_size = avio_tell(pb);
         avio_seek(pb, 8, SEEK_SET);
diff --git a/mythtv/external/FFmpeg/libavformat/flic.c b/mythtv/external/FFmpeg/libavformat/flic.c
index 49f5d21f989..7c62cb423c8 100644
--- a/mythtv/external/FFmpeg/libavformat/flic.c
+++ b/mythtv/external/FFmpeg/libavformat/flic.c
@@ -204,7 +204,7 @@ static int flic_read_packet(AVFormatContext *s,
     int ret = 0;
     unsigned char preamble[FLIC_PREAMBLE_SIZE];
 
-    while (!packet_read) {
+    while (!packet_read && !avio_feof(pb)) {
 
         if ((ret = avio_read(pb, preamble, FLIC_PREAMBLE_SIZE)) !=
             FLIC_PREAMBLE_SIZE) {
@@ -256,7 +256,7 @@ static int flic_read_packet(AVFormatContext *s,
         }
     }
 
-    return ret;
+    return avio_feof(pb) ? AVERROR_EOF : ret;
 }
 
 AVInputFormat ff_flic_demuxer = {
diff --git a/mythtv/external/FFmpeg/libavformat/flvdec.c b/mythtv/external/FFmpeg/libavformat/flvdec.c
index 68ab6805d40..2d89bef15f2 100644
--- a/mythtv/external/FFmpeg/libavformat/flvdec.c
+++ b/mythtv/external/FFmpeg/libavformat/flvdec.c
@@ -64,8 +64,12 @@ typedef struct FLVContext {
 
     int last_keyframe_stream_index;
     int keyframe_count;
+    int64_t video_bit_rate;
+    int64_t audio_bit_rate;
     int64_t *keyframe_times;
     int64_t *keyframe_filepositions;
+    int missing_streams;
+    AVRational framerate;
 } FLVContext;
 
 static int probe(AVProbeData *p, int live)
@@ -113,6 +117,8 @@ static void add_keyframes_index(AVFormatContext *s)
 
     if (stream->nb_index_entries == 0) {
         for (i = 0; i < flv->keyframe_count; i++) {
+            av_log(s, AV_LOG_TRACE, "keyframe filepositions = %"PRId64" times = %"PRId64"\n",
+                   flv->keyframe_filepositions[i], flv->keyframe_times[i] * 1000);
             av_add_index_entry(stream, flv->keyframe_filepositions[i],
                 flv->keyframe_times[i] * 1000, 0, 0, AVINDEX_KEYFRAME);
         }
@@ -137,6 +143,16 @@ static AVStream *create_stream(AVFormatContext *s, int codec_type)
                            && s->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE
                            && s->streams[1]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE))
         s->ctx_flags &= ~AVFMTCTX_NOHEADER;
+    if (codec_type == AVMEDIA_TYPE_AUDIO) {
+        st->codecpar->bit_rate = flv->audio_bit_rate;
+        flv->missing_streams &= ~FLV_HEADER_FLAG_HASAUDIO;
+    }
+    if (codec_type == AVMEDIA_TYPE_VIDEO) {
+        st->codecpar->bit_rate = flv->video_bit_rate;
+        flv->missing_streams &= ~FLV_HEADER_FLAG_HASVIDEO;
+        st->avg_frame_rate = flv->framerate;
+    }
+
 
     avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
     flv->last_keyframe_stream_index = s->nb_streams - 1;
@@ -283,7 +299,9 @@ static int flv_same_video_codec(AVCodecParameters *vpar, int flags)
 static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream,
                                int flv_codecid, int read)
 {
+    int ret = 0;
     AVCodecParameters *par = vstream->codecpar;
+    enum AVCodecID old_codec_id = vstream->codecpar->codec_id;
     switch (flv_codecid) {
     case FLV_CODECID_H263:
         par->codec_id = AV_CODEC_ID_FLV1;
@@ -311,20 +329,28 @@ static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream,
             else
                 avio_skip(s->pb, 1);
         }
-        return 1;     // 1 byte body size adjustment for flv_read_packet()
+        ret = 1;     // 1 byte body size adjustment for flv_read_packet()
+        break;
     case FLV_CODECID_H264:
         par->codec_id = AV_CODEC_ID_H264;
         vstream->need_parsing = AVSTREAM_PARSE_HEADERS;
-        return 3;     // not 4, reading packet type will consume one byte
+        ret = 3;     // not 4, reading packet type will consume one byte
+        break;
     case FLV_CODECID_MPEG4:
         par->codec_id = AV_CODEC_ID_MPEG4;
-        return 3;
+        ret = 3;
+        break;
     default:
         avpriv_request_sample(s, "Video codec (%x)", flv_codecid);
         par->codec_tag = flv_codecid;
     }
 
-    return 0;
+    if (!vstream->internal->need_context_update && par->codec_id != old_codec_id) {
+        avpriv_request_sample(s, "Changing the codec id midstream");
+        return AVERROR_PATCHWELCOME;
+    }
+
+    return ret;
 }
 
 static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize)
@@ -458,7 +484,7 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream,
         break;
     case AMF_DATA_TYPE_OBJECT:
         if (key &&
-            ioc->seekable &&
+            (ioc->seekable & AVIO_SEEKABLE_NORMAL) &&
             !strcmp(KEYFRAMES_TAG, key) && depth == 1)
             if (parse_keyframes_index(s, ioc,
                                       max_pos) < 0)
@@ -526,20 +552,26 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream,
                 amf_type == AMF_DATA_TYPE_BOOL) {
                 if (!strcmp(key, "duration"))
                     s->duration = num_val * AV_TIME_BASE;
-                else if (!strcmp(key, "videodatarate") && vpar &&
+                else if (!strcmp(key, "videodatarate") &&
                          0 <= (int)(num_val * 1024.0))
-                    vpar->bit_rate = num_val * 1024.0;
-                else if (!strcmp(key, "audiodatarate") && apar &&
+                    flv->video_bit_rate = num_val * 1024.0;
+                else if (!strcmp(key, "audiodatarate") &&
                          0 <= (int)(num_val * 1024.0))
-                    apar->bit_rate = num_val * 1024.0;
+                    flv->audio_bit_rate = num_val * 1024.0;
                 else if (!strcmp(key, "datastream")) {
                     AVStream *st = create_stream(s, AVMEDIA_TYPE_SUBTITLE);
                     if (!st)
                         return AVERROR(ENOMEM);
                     st->codecpar->codec_id = AV_CODEC_ID_TEXT;
+                } else if (!strcmp(key, "framerate")) {
+                    flv->framerate = av_d2q(num_val, 1000);
+                    if (vstream)
+                        vstream->avg_frame_rate = flv->framerate;
                 } else if (flv->trust_metadata) {
                     if (!strcmp(key, "videocodecid") && vpar) {
-                        flv_set_video_codec(s, vstream, num_val, 0);
+                        int ret = flv_set_video_codec(s, vstream, num_val, 0);
+                        if (ret < 0)
+                            return ret;
                     } else if (!strcmp(key, "audiocodecid") && apar) {
                         int id = ((int)num_val) << FLV_AUDIO_CODECID_OFFSET;
                         flv_set_audio_codec(s, astream, apar, id);
@@ -674,17 +706,30 @@ static int flv_read_metabody(AVFormatContext *s, int64_t next_pos)
 
 static int flv_read_header(AVFormatContext *s)
 {
+    int flags;
     FLVContext *flv = s->priv_data;
     int offset;
+    int pre_tag_size = 0;
 
     avio_skip(s->pb, 4);
-    avio_r8(s->pb); // flags
+    flags = avio_r8(s->pb);
+
+    flv->missing_streams = flags & (FLV_HEADER_FLAG_HASVIDEO | FLV_HEADER_FLAG_HASAUDIO);
 
     s->ctx_flags |= AVFMTCTX_NOHEADER;
 
     offset = avio_rb32(s->pb);
     avio_seek(s->pb, offset, SEEK_SET);
-    avio_skip(s->pb, 4);
+
+    /* Annex E. The FLV File Format
+     * E.3 TheFLVFileBody
+     *     Field               Type    Comment
+     *     PreviousTagSize0    UI32    Always 0
+     * */
+    pre_tag_size = avio_rb32(s->pb);
+    if (pre_tag_size) {
+        av_log(s, AV_LOG_WARNING, "Read FLV header error, input file is not a standard flv format, first PreviousTagSize0 always is 0\n");
+    }
 
     s->start_time = 0;
     flv->sum_flv_tag_size = 0;
@@ -709,6 +754,7 @@ static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)
     av_freep(&st->codecpar->extradata);
     if (ff_get_extradata(s, st->codecpar, s->pb, size) < 0)
         return AVERROR(ENOMEM);
+    st->internal->need_context_update = 1;
     return 0;
 }
 
@@ -969,7 +1015,13 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
                    "Skipping flv packet: type %d, size %d, flags %d.\n",
                    type, size, flags);
 skip:
-            avio_seek(s->pb, next, SEEK_SET);
+            if (avio_seek(s->pb, next, SEEK_SET) != next) {
+                 // This can happen if flv_read_metabody above read past
+                 // next, on a non-seekable input, and the preceding data has
+                 // been flushed out from the IO buffer.
+                 av_log(s, AV_LOG_ERROR, "Unable to seek to the next packet\n");
+                 return AVERROR_INVALIDDATA;
+            }
             ret = FFERROR_REDO;
             goto leave;
         }
@@ -998,7 +1050,6 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
         }
         if (i == s->nb_streams) {
             static const enum AVMediaType stream_types[] = {AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_SUBTITLE};
-            av_log(s, AV_LOG_WARNING, "%s stream discovered after head already parsed\n", av_get_media_type_string(stream_types[stream_type]));
             st = create_stream(s, stream_types[stream_type]);
             if (!st)
                 return AVERROR(ENOMEM);
@@ -1006,7 +1057,7 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
         }
         av_log(s, AV_LOG_TRACE, "%d %X %d \n", stream_type, flags, st->discard);
 
-        if (s->pb->seekable &&
+        if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
             ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY ||
               stream_type == FLV_STREAM_TYPE_AUDIO))
             av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);
@@ -1022,7 +1073,8 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
 
     // if not streamed and no duration from metadata then seek to end to find
     // the duration from the timestamps
-    if (s->pb->seekable && (!s->duration || s->duration == AV_NOPTS_VALUE) &&
+    if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
+        (!s->duration || s->duration == AV_NOPTS_VALUE) &&
         !flv->searched_for_end) {
         int size;
         const int64_t pos   = avio_tell(s->pb);
@@ -1087,7 +1139,10 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
             avcodec_parameters_free(&par);
         }
     } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
-        size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK, 1);
+        int ret = flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK, 1);
+        if (ret < 0)
+            return ret;
+        size -= ret;
     } else if (stream_type == FLV_STREAM_TYPE_DATA) {
         st->codecpar->codec_id = AV_CODEC_ID_TEXT;
     }
@@ -1216,6 +1271,7 @@ static int flv_read_seek(AVFormatContext *s, int stream_index,
 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
 static const AVOption options[] = {
     { "flv_metadata", "Allocate streams according to the onMetaData array", OFFSET(trust_metadata), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
+    { "missing_streams", "", OFFSET(missing_streams), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 0xFF, VD | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY },
     { NULL }
 };
 
diff --git a/mythtv/external/FFmpeg/libavformat/flvenc.c b/mythtv/external/FFmpeg/libavformat/flvenc.c
index 99b322bb65d..899b07ea7be 100644
--- a/mythtv/external/FFmpeg/libavformat/flvenc.c
+++ b/mythtv/external/FFmpeg/libavformat/flvenc.c
@@ -24,6 +24,8 @@
 #include "libavutil/intfloat.h"
 #include "libavutil/avassert.h"
 #include "libavutil/mathematics.h"
+#include "avio_internal.h"
+#include "avio.h"
 #include "avc.h"
 #include "avformat.h"
 #include "flv.h"
@@ -64,9 +66,17 @@ static const AVCodecTag flv_audio_codec_ids[] = {
 typedef enum {
     FLV_AAC_SEQ_HEADER_DETECT = (1 << 0),
     FLV_NO_SEQUENCE_END = (1 << 1),
+    FLV_ADD_KEYFRAME_INDEX = (1 << 2),
+    FLV_NO_METADATA = (1 << 3),
     FLV_NO_DURATION_FILESIZE = (1 << 4),
 } FLVFlags;
 
+typedef struct FLVFileposition {
+    int64_t keyframe_position;
+    double keyframe_timestamp;
+    struct FLVFileposition *next;
+} FLVFileposition;
+
 typedef struct FLVContext {
     AVClass *av_class;
     int     reserved;
@@ -75,6 +85,33 @@ typedef struct FLVContext {
     int64_t duration;
     int64_t delay;      ///< first dts delay (needed for AVC & Speex)
 
+    int64_t datastart_offset;
+    int64_t datasize_offset;
+    int64_t datasize;
+    int64_t videosize_offset;
+    int64_t videosize;
+    int64_t audiosize_offset;
+    int64_t audiosize;
+
+    int64_t metadata_size_pos;
+    int64_t metadata_totalsize_pos;
+    int64_t metadata_totalsize;
+    int64_t keyframe_index_size;
+
+    int64_t lasttimestamp_offset;
+    double lasttimestamp;
+    int64_t lastkeyframetimestamp_offset;
+    double lastkeyframetimestamp;
+    int64_t lastkeyframelocation_offset;
+    int64_t lastkeyframelocation;
+
+    int acurframeindex;
+    int64_t keyframes_info_offset;
+
+    int64_t filepositions_count;
+    FLVFileposition *filepositions;
+    FLVFileposition *head_filepositions;
+
     AVCodecParameters *audio_par;
     AVCodecParameters *video_par;
     double framerate;
@@ -108,6 +145,14 @@ static int get_audio_flags(AVFormatContext *s, AVCodecParameters *par)
         return FLV_CODECID_SPEEX | FLV_SAMPLERATE_11025HZ | FLV_SAMPLESSIZE_16BIT;
     } else {
         switch (par->sample_rate) {
+        case 48000:
+            // 48khz mp3 is stored with 44k1 samplerate identifer
+            if (par->codec_id == AV_CODEC_ID_MP3) {
+                flags |= FLV_SAMPLERATE_44100HZ;
+                break;
+            } else {
+                goto error;
+            }
         case 44100:
             flags |= FLV_SAMPLERATE_44100HZ;
             break;
@@ -125,6 +170,7 @@ static int get_audio_flags(AVFormatContext *s, AVCodecParameters *par)
                 break;
             }
         default:
+error:
             av_log(s, AV_LOG_ERROR,
                    "FLV does not support sample rate %d, "
                    "choose from (44100, 22050, 11025)\n", par->sample_rate);
@@ -203,6 +249,17 @@ static void put_amf_double(AVIOContext *pb, double d)
     avio_wb64(pb, av_double2int(d));
 }
 
+static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
+{
+    avio_w8(pb, abyte);
+}
+
+static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
+{
+    avio_w8(pb, AMF_DATA_TYPE_ARRAY);
+    avio_wb32(pb, dw);
+}
+
 static void put_amf_bool(AVIOContext *pb, int b)
 {
     avio_w8(pb, AMF_DATA_TYPE_BOOL);
@@ -215,12 +272,12 @@ static void write_metadata(AVFormatContext *s, unsigned int ts)
     FLVContext *flv = s->priv_data;
     int write_duration_filesize = !(flv->flags & FLV_NO_DURATION_FILESIZE);
     int metadata_count = 0;
-    int64_t metadata_size_pos, data_size, metadata_count_pos;
+    int64_t metadata_count_pos;
     AVDictionaryEntry *tag = NULL;
 
     /* write meta_tag */
-    avio_w8(pb, 18);            // tag type META
-    metadata_size_pos = avio_tell(pb);
+    avio_w8(pb, FLV_TAG_TYPE_META);            // tag type META
+    flv->metadata_size_pos = avio_tell(pb);
     avio_wb24(pb, 0);           // size of data part (sum of all parts below)
     avio_wb24(pb, ts);          // timestamp
     avio_wb32(pb, 0);           // reserved
@@ -329,19 +386,87 @@ static void write_metadata(AVFormatContext *s, unsigned int ts)
         put_amf_double(pb, 0); // delayed write
     }
 
+    if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
+        flv->acurframeindex = 0;
+        flv->keyframe_index_size = 0;
+
+        put_amf_string(pb, "hasVideo");
+        put_amf_bool(pb, !!flv->video_par);
+        metadata_count++;
+
+        put_amf_string(pb, "hasKeyframes");
+        put_amf_bool(pb, 1);
+        metadata_count++;
+
+        put_amf_string(pb, "hasAudio");
+        put_amf_bool(pb, !!flv->audio_par);
+        metadata_count++;
+
+        put_amf_string(pb, "hasMetadata");
+        put_amf_bool(pb, 1);
+        metadata_count++;
+
+        put_amf_string(pb, "canSeekToEnd");
+        put_amf_bool(pb, 1);
+        metadata_count++;
+
+        put_amf_string(pb, "datasize");
+        flv->datasize_offset = avio_tell(pb);
+        flv->datasize = 0;
+        put_amf_double(pb, flv->datasize);
+        metadata_count++;
+
+        put_amf_string(pb, "videosize");
+        flv->videosize_offset = avio_tell(pb);
+        flv->videosize = 0;
+        put_amf_double(pb, flv->videosize);
+        metadata_count++;
+
+        put_amf_string(pb, "audiosize");
+        flv->audiosize_offset = avio_tell(pb);
+        flv->audiosize = 0;
+        put_amf_double(pb, flv->audiosize);
+        metadata_count++;
+
+        put_amf_string(pb, "lasttimestamp");
+        flv->lasttimestamp_offset = avio_tell(pb);
+        flv->lasttimestamp = 0;
+        put_amf_double(pb, 0);
+        metadata_count++;
+
+        put_amf_string(pb, "lastkeyframetimestamp");
+        flv->lastkeyframetimestamp_offset = avio_tell(pb);
+        flv->lastkeyframetimestamp = 0;
+        put_amf_double(pb, 0);
+        metadata_count++;
+
+        put_amf_string(pb, "lastkeyframelocation");
+        flv->lastkeyframelocation_offset = avio_tell(pb);
+        flv->lastkeyframelocation = 0;
+        put_amf_double(pb, 0);
+        metadata_count++;
+
+        put_amf_string(pb, "keyframes");
+        put_amf_byte(pb, AMF_DATA_TYPE_OBJECT);
+        metadata_count++;
+
+        flv->keyframes_info_offset = avio_tell(pb);
+    }
+
     put_amf_string(pb, "");
     avio_w8(pb, AMF_END_OF_OBJECT);
 
     /* write total size of tag */
-    data_size = avio_tell(pb) - metadata_size_pos - 10;
+    flv->metadata_totalsize = avio_tell(pb) - flv->metadata_size_pos - 10;
 
     avio_seek(pb, metadata_count_pos, SEEK_SET);
     avio_wb32(pb, metadata_count);
 
-    avio_seek(pb, metadata_size_pos, SEEK_SET);
-    avio_wb24(pb, data_size);
-    avio_skip(pb, data_size + 10 - 3);
-    avio_wb32(pb, data_size + 11);
+    avio_seek(pb, flv->metadata_size_pos, SEEK_SET);
+    avio_wb24(pb, flv->metadata_totalsize);
+    avio_skip(pb, flv->metadata_totalsize + 10 - 3);
+    flv->metadata_totalsize_pos = avio_tell(pb);
+    avio_wb32(pb, flv->metadata_totalsize + 11);
 }
 
 static int unsupported_codec(AVFormatContext *s,
@@ -418,6 +543,113 @@ static void flv_write_codec_header(AVFormatContext* s, AVCodecParameters* par) {
     }
 }
 
+static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
+{
+    FLVFileposition *position = av_malloc(sizeof(FLVFileposition));
+
+    if (!position) {
+        av_log(s, AV_LOG_WARNING, "no mem for add keyframe index!\n");
+        return AVERROR(ENOMEM);
+    }
+
+    position->keyframe_timestamp = ts;
+    position->keyframe_position = pos;
+
+    if (!flv->filepositions_count) {
+        flv->filepositions = position;
+        flv->head_filepositions = flv->filepositions;
+        position->next = NULL;
+    } else {
+        flv->filepositions->next = position;
+        position->next = NULL;
+        flv->filepositions = flv->filepositions->next;
+    }
+
+    flv->filepositions_count++;
+
+    return 0;
+}
+
+static int shift_data(AVFormatContext *s)
+{
+    int ret = 0;
+    int n = 0;
+    int64_t metadata_size = 0;
+    FLVContext *flv = s->priv_data;
+    int64_t pos, pos_end = avio_tell(s->pb);
+    uint8_t *buf, *read_buf[2];
+    int read_buf_id = 0;
+    int read_size[2];
+    AVIOContext *read_pb;
+
+    metadata_size = flv->filepositions_count * 9 * 2 + 10; /* filepositions and times value */
+    metadata_size += 2 + 13; /* filepositions String */
+    metadata_size += 2 + 5; /* times String */
+    metadata_size += 3; /* Object end */
+
+    flv->keyframe_index_size = metadata_size;
+
+    if (metadata_size < 0)
+        return metadata_size;
+
+    buf = av_malloc_array(metadata_size, 2);
+    if (!buf) {
+        return AVERROR(ENOMEM);
+    }
+    read_buf[0] = buf;
+    read_buf[1] = buf + metadata_size;
+
+    avio_seek(s->pb, flv->metadata_size_pos, SEEK_SET);
+    avio_wb24(s->pb, flv->metadata_totalsize + metadata_size);
+
+    avio_seek(s->pb, flv->metadata_totalsize_pos, SEEK_SET);
+    avio_wb32(s->pb, flv->metadata_totalsize + 11 + metadata_size);
+    avio_seek(s->pb, pos_end, SEEK_SET);
+
+    /* Shift the data: the AVIO context of the output can only be used for
+     * writing, so we re-open the same output, but for reading. It also avoids
+     * a read/seek/write/seek back and forth. */
+    avio_flush(s->pb);
+    ret = s->io_open(s, &read_pb, s->filename, AVIO_FLAG_READ, NULL);
+    if (ret < 0) {
+        av_log(s, AV_LOG_ERROR, "Unable to re-open %s output file for "
+               "the second pass (add_keyframe_index)\n", s->filename);
+        goto end;
+    }
+
+    /* mark the end of the shift to up to the last data we wrote, and get ready
+     * for writing */
+    pos_end = avio_tell(s->pb);
+    avio_seek(s->pb, flv->keyframes_info_offset + metadata_size, SEEK_SET);
+
+    /* start reading at where the keyframe index information will be placed */
+    avio_seek(read_pb, flv->keyframes_info_offset, SEEK_SET);
+    pos = avio_tell(read_pb);
+
+#define READ_BLOCK do {                                                             \
+    read_size[read_buf_id] = avio_read(read_pb, read_buf[read_buf_id], metadata_size);  \
+    read_buf_id ^= 1;                                                               \
+} while (0)
+
+    /* shift data by chunk of at most keyframe *filepositions* and *times* size */
+    READ_BLOCK;
+    do {
+        READ_BLOCK;
+        n = read_size[read_buf_id];
+        if (n < 0)
+            break;
+        avio_write(s->pb, read_buf[read_buf_id], n);
+        pos += n;
+    } while (pos <= pos_end);
+
+    ff_format_io_close(s, &read_pb);
+
+end:
+    av_free(buf);
+    return ret;
+}
+
+
 static int flv_write_header(AVFormatContext *s)
 {
     int i;
@@ -517,23 +749,85 @@ static int flv_write_header(AVFormatContext *s)
             flv->reserved = 5;
         }
 
-    write_metadata(s, 0);
+    if (flv->flags & FLV_NO_METADATA) {
+        pb->seekable = 0;
+    } else {
+        write_metadata(s, 0);
+    }
 
     for (i = 0; i < s->nb_streams; i++) {
         flv_write_codec_header(s, s->streams[i]->codecpar);
     }
 
+    flv->datastart_offset = avio_tell(pb);
     return 0;
 }
 
 static int flv_write_trailer(AVFormatContext *s)
 {
     int64_t file_size;
-
     AVIOContext *pb = s->pb;
     FLVContext *flv = s->priv_data;
-    int i;
+    int build_keyframes_idx = flv->flags & FLV_ADD_KEYFRAME_INDEX;
+    int i, res;
+    int64_t cur_pos = avio_tell(s->pb);
+
+    if (build_keyframes_idx) {
+        FLVFileposition *newflv_posinfo, *p;
+
+        avio_seek(pb, flv->videosize_offset, SEEK_SET);
+        put_amf_double(pb, flv->videosize);
+
+        avio_seek(pb, flv->audiosize_offset, SEEK_SET);
+        put_amf_double(pb, flv->audiosize);
+
+        avio_seek(pb, flv->lasttimestamp_offset, SEEK_SET);
+        put_amf_double(pb, flv->lasttimestamp);
 
+        avio_seek(pb, flv->lastkeyframetimestamp_offset, SEEK_SET);
+        put_amf_double(pb, flv->lastkeyframetimestamp);
+
+        avio_seek(pb, flv->lastkeyframelocation_offset, SEEK_SET);
+        put_amf_double(pb, flv->lastkeyframelocation + flv->keyframe_index_size);
+        avio_seek(pb, cur_pos, SEEK_SET);
+
+        res = shift_data(s);
+        if (res < 0) {
+             goto end;
+        }
+        avio_seek(pb, flv->keyframes_info_offset, SEEK_SET);
+        put_amf_string(pb, "filepositions");
+        put_amf_dword_array(pb, flv->filepositions_count);
+        for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
+            put_amf_double(pb, newflv_posinfo->keyframe_position + flv->keyframe_index_size);
+        }
+
+        put_amf_string(pb, "times");
+        put_amf_dword_array(pb, flv->filepositions_count);
+        for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
+            put_amf_double(pb, newflv_posinfo->keyframe_timestamp);
+        }
+
+        newflv_posinfo = flv->head_filepositions;
+        while (newflv_posinfo) {
+            p = newflv_posinfo->next;
+            if (p) {
+                newflv_posinfo->next = p->next;
+                av_free(p);
+                p = NULL;
+            } else {
+                av_free(newflv_posinfo);
+                newflv_posinfo = NULL;
+            }
+        }
+
+        put_amf_string(pb, "");
+        avio_w8(pb, AMF_END_OF_OBJECT);
+
+        avio_seek(pb, cur_pos + flv->keyframe_index_size, SEEK_SET);
+    }
+
+end:
     if (flv->flags & FLV_NO_SEQUENCE_END) {
         av_log(s, AV_LOG_DEBUG, "FLV no sequence end mode open\n");
     } else {
@@ -549,20 +843,27 @@ static int flv_write_trailer(AVFormatContext *s)
 
     file_size = avio_tell(pb);
 
-    if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
-        /* update information */
-        if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
-            av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
-        } else {
-            put_amf_double(pb, flv->duration / (double)1000);
-        }
-        if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
-            av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
-        } else {
-            put_amf_double(pb, file_size);
+    if (build_keyframes_idx) {
+        flv->datasize = file_size - flv->datastart_offset;
+        avio_seek(pb, flv->datasize_offset, SEEK_SET);
+        put_amf_double(pb, flv->datasize);
+    }
+    if (!(flv->flags & FLV_NO_METADATA)) {
+        if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
+            /* update information */
+            if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
+                av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
+            } else {
+                put_amf_double(pb, flv->duration / (double)1000);
+            }
+            if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
+                av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
+            } else {
+                put_amf_double(pb, file_size);
+            }
         }
     }
-    avio_seek(pb, file_size, SEEK_SET);
+
     return 0;
 }
 
@@ -576,6 +877,7 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
     int size = pkt->size;
     uint8_t *data = NULL;
     int flags = -1, flags_size, ret;
+    int64_t cur_offset = avio_tell(pb);
 
     if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
         par->codec_id == AV_CODEC_ID_VP6  || par->codec_id == AV_CODEC_ID_AAC)
@@ -592,6 +894,10 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
         if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
             av_free(par->extradata);
             par->extradata = av_mallocz(side_size + AV_INPUT_BUFFER_PADDING_SIZE);
+            if (!par->extradata) {
+                par->extradata_size = 0;
+                return AVERROR(ENOMEM);
+            }
             memcpy(par->extradata, side, side_size);
             par->extradata_size = side_size;
             flv_write_codec_header(s, par);
@@ -729,6 +1035,32 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
                               pkt->pts + flv->delay + pkt->duration);
     }
 
+    if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
+        switch (par->codec_type) {
+            case AVMEDIA_TYPE_VIDEO:
+                flv->videosize += (avio_tell(pb) - cur_offset);
+                flv->lasttimestamp = flv->acurframeindex / flv->framerate;
+                if (pkt->flags & AV_PKT_FLAG_KEY) {
+                    double ts = flv->acurframeindex / flv->framerate;
+                    int64_t pos = cur_offset;
+
+                    flv->lastkeyframetimestamp = flv->acurframeindex / flv->framerate;
+                    flv->lastkeyframelocation = pos;
+                    flv_append_keyframe_info(s, flv, ts, pos);
+                }
+                flv->acurframeindex++;
+                break;
+
+            case AVMEDIA_TYPE_AUDIO:
+                flv->audiosize += (avio_tell(pb) - cur_offset);
+                break;
+
+            default:
+                av_log(s, AV_LOG_WARNING, "par->codec_type is type = [%d]\n", par->codec_type);
+                break;
+        }
+    }
+
     av_free(data);
 
     return pb->error;
@@ -738,7 +1070,9 @@ static const AVOption options[] = {
     { "flvflags", "FLV muxer flags", offsetof(FLVContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
     { "aac_seq_header_detect", "Put AAC sequence header based on stream data", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_AAC_SEQ_HEADER_DETECT}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
     { "no_sequence_end", "disable sequence end for FLV", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_NO_SEQUENCE_END}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
+    { "no_metadata", "disable metadata for FLV", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_NO_METADATA}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
     { "no_duration_filesize", "disable duration and filesize zero value metadata for FLV", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_NO_DURATION_FILESIZE}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
+    { "add_keyframe_index", "Add keyframe index metadata", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_ADD_KEYFRAME_INDEX}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
     { NULL },
 };
 
diff --git a/mythtv/external/FFmpeg/libavformat/framecrcenc.c b/mythtv/external/FFmpeg/libavformat/framecrcenc.c
index 91bcdcd99e2..a567b5299c8 100644
--- a/mythtv/external/FFmpeg/libavformat/framecrcenc.c
+++ b/mythtv/external/FFmpeg/libavformat/framecrcenc.c
@@ -68,7 +68,7 @@ static int framecrc_write_packet(struct AVFormatContext *s, AVPacket *pkt)
                                                   pkt->side_data[i].data,
                                                   pkt->side_data[i].size);
             }
-            av_strlcatf(buf, sizeof(buf), ", %8d, 0x%08x", pkt->side_data[i].size, side_data_crc);
+            av_strlcatf(buf, sizeof(buf), ", %8d, 0x%08"PRIx32, pkt->side_data[i].size, side_data_crc);
         }
     }
     av_strlcatf(buf, sizeof(buf), "\n");
diff --git a/mythtv/external/FFmpeg/libavformat/framehash.c b/mythtv/external/FFmpeg/libavformat/framehash.c
index 4c5499ea7bc..3ae9092c61d 100644
--- a/mythtv/external/FFmpeg/libavformat/framehash.c
+++ b/mythtv/external/FFmpeg/libavformat/framehash.c
@@ -29,13 +29,16 @@ int ff_framehash_write_header(AVFormatContext *s)
     for (i = 0; i < s->nb_streams; i++) {
         AVStream *st = s->streams[i];
         AVCodecParameters *avctx = st->codecpar;
+        char buf[256] = { 0 };
         avio_printf(s->pb, "#tb %d: %d/%d\n", i, st->time_base.num, st->time_base.den);
         avio_printf(s->pb, "#media_type %d: %s\n", i, av_get_media_type_string(avctx->codec_type));
         avio_printf(s->pb, "#codec_id %d: %s\n", i, avcodec_get_name(avctx->codec_id));
         switch (avctx->codec_type) {
         case AVMEDIA_TYPE_AUDIO:
+            av_get_channel_layout_string(buf, sizeof(buf), avctx->channels, avctx->channel_layout);
             avio_printf(s->pb, "#sample_rate %d: %d\n", i,avctx->sample_rate);
             avio_printf(s->pb, "#channel_layout %d: %"PRIx64"\n", i,avctx->channel_layout);
+            avio_printf(s->pb, "#channel_layout_name %d: %s\n", i, buf);
             break;
         case AVMEDIA_TYPE_VIDEO:
             avio_printf(s->pb, "#dimensions %d: %dx%d\n", i, avctx->width, avctx->height);
diff --git a/mythtv/external/FFmpeg/libavformat/ftp.c b/mythtv/external/FFmpeg/libavformat/ftp.c
index 0663b47bc49..9aa7a45629f 100644
--- a/mythtv/external/FFmpeg/libavformat/ftp.c
+++ b/mythtv/external/FFmpeg/libavformat/ftp.c
@@ -206,6 +206,9 @@ static int ftp_send_command(FTPContext *s, const char *command,
     if (response)
         *response = NULL;
 
+    if (!s->conn_control)
+        return AVERROR(EIO);
+
     if ((err = ffurl_write(s->conn_control, command, strlen(command))) < 0)
         return err;
     if (!err)
diff --git a/mythtv/external/FFmpeg/libavformat/g726.c b/mythtv/external/FFmpeg/libavformat/g726.c
new file mode 100644
index 00000000000..eca94048665
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/g726.c
@@ -0,0 +1,105 @@
+/*
+ * G.726 raw demuxer
+ * Copyright 2017 Carl Eugen Hoyos
+ *
+ * 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 "avformat.h"
+#include "internal.h"
+#include "libavutil/opt.h"
+
+typedef struct G726Context {
+    AVClass *class;
+    int code_size;
+    int sample_rate;
+} G726Context;
+
+static int g726_read_header(AVFormatContext *s)
+{
+    G726Context *c = s->priv_data;
+    AVStream *st = avformat_new_stream(s, NULL);
+    if (!st)
+        return AVERROR(ENOMEM);
+
+    st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
+    st->codecpar->codec_id   = s->iformat->raw_codec_id;
+
+    st->codecpar->sample_rate           = c->sample_rate;
+    st->codecpar->bits_per_coded_sample = c->code_size;
+    st->codecpar->bit_rate              = ((int[]){ 16000, 24000, 32000, 40000 })[c->code_size - 2];
+    st->codecpar->channels              = 1;
+
+    return 0;
+}
+
+static int g726_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    int res;
+    res = av_get_packet(s->pb, pkt, 1020); // a size similar to RAW_PACKET_SIZE divisible by all code_size values
+    if (res < 0)
+        return res;
+    return 0;
+}
+
+#define OFFSET(x) offsetof(G726Context, x)
+static const AVOption options[] = {
+    { "code_size", "Bits per G.726 code",
+        OFFSET(code_size),   AV_OPT_TYPE_INT, {.i64 =    4}, 2,       5, AV_OPT_FLAG_DECODING_PARAM },
+    { "sample_rate", "",
+        OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64 = 8000}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
+    { NULL },
+};
+
+#if CONFIG_G726_DEMUXER
+static const AVClass g726le_demuxer_class = {
+    .class_name     = "G.726 big-endian demuxer",
+    .item_name      = av_default_item_name,
+    .option         = options,
+    .version        = LIBAVUTIL_VERSION_INT,
+};
+
+AVInputFormat ff_g726_demuxer = {
+    .name           = "g726",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw big-endian G.726 (\"left aligned\")"),
+    .read_header    = g726_read_header,
+    .read_packet    = g726_read_packet,
+    .priv_data_size = sizeof(G726Context),
+    .priv_class     = &g726le_demuxer_class,
+    .raw_codec_id   = AV_CODEC_ID_ADPCM_G726,
+};
+#endif
+
+#if CONFIG_G726LE_DEMUXER
+static const AVClass g726_demuxer_class = {
+    .class_name     = "G.726 little-endian demuxer",
+    .item_name      = av_default_item_name,
+    .option         = options,
+    .version        = LIBAVUTIL_VERSION_INT,
+};
+
+AVInputFormat ff_g726le_demuxer = {
+    .name           = "g726le",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw little-endian G.726 (\"right aligned\")"),
+    .read_header    = g726_read_header,
+    .read_packet    = g726_read_packet,
+    .priv_data_size = sizeof(G726Context),
+    .priv_class     = &g726_demuxer_class,
+    .raw_codec_id   = AV_CODEC_ID_ADPCM_G726LE,
+};
+#endif
+
diff --git a/mythtv/external/FFmpeg/libavformat/gdv.c b/mythtv/external/FFmpeg/libavformat/gdv.c
new file mode 100644
index 00000000000..a69c349cab3
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/gdv.c
@@ -0,0 +1,201 @@
+/*
+ * Gremlin Digital Video demuxer
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/intreadwrite.h"
+
+#include "avformat.h"
+#include "avio.h"
+#include "internal.h"
+
+typedef struct GDVContext {
+    int is_first_video;
+    int is_audio;
+    int audio_size;
+    int audio_stream_index;
+    int video_stream_index;
+    unsigned pal[256];
+} GDVContext;
+
+static int gdv_read_probe(AVProbeData *p)
+{
+    if (AV_RL32(p->buf) == 0x29111994)
+        return AVPROBE_SCORE_MAX;
+
+    return 0;
+}
+
+static struct {
+    uint16_t id;
+    uint16_t width;
+    uint16_t height;
+} FixedSize[] = {
+    { 0, 320, 200},
+    { 1, 640, 200},
+    { 2, 320, 167},
+    { 3, 320, 180},
+    { 4, 320, 400},
+    { 5, 320, 170},
+    { 6, 160,  85},
+    { 7, 160,  83},
+    { 8, 160,  90},
+    { 9, 280, 128},
+    {10, 320, 240},
+    {11, 320, 201},
+    {16, 640, 400},
+    {17, 640, 200},
+    {18, 640, 180},
+    {19, 640, 167},
+    {20, 640, 170},
+    {21, 320, 240}
+};
+
+static int gdv_read_header(AVFormatContext *ctx)
+{
+    GDVContext *gdv = ctx->priv_data;
+    AVIOContext *pb = ctx->pb;
+    AVStream *vst, *ast;
+    unsigned fps, snd_flags, vid_depth, size_id;
+
+    avio_skip(pb, 4);
+    size_id = avio_rl16(pb);
+
+    vst = avformat_new_stream(ctx, 0);
+    if (!vst)
+        return AVERROR(ENOMEM);
+
+    vst->start_time        = 0;
+    vst->duration          =
+    vst->nb_frames         = avio_rl16(pb);
+
+    fps = avio_rl16(pb);
+    snd_flags = avio_rl16(pb);
+    if (snd_flags & 1) {
+        ast = avformat_new_stream(ctx, 0);
+        if (!ast)
+            return AVERROR(ENOMEM);
+
+        ast->start_time = 0;
+        ast->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;
+        ast->codecpar->codec_tag   = 0;
+        ast->codecpar->sample_rate = avio_rl16(pb);
+        ast->codecpar->channels    = 1 + !!(snd_flags & 2);
+        if (snd_flags & 8) {
+            ast->codecpar->codec_id = AV_CODEC_ID_GREMLIN_DPCM;
+        } else {
+            ast->codecpar->codec_id = (snd_flags & 4) ? AV_CODEC_ID_PCM_S16LE : AV_CODEC_ID_PCM_U8;
+        }
+
+        avpriv_set_pts_info(ast, 64, 1, ast->codecpar->sample_rate);
+        gdv->audio_size = (ast->codecpar->sample_rate / fps) *
+                           ast->codecpar->channels * (1 + !!(snd_flags & 4)) / (1 + !!(snd_flags & 8));
+        gdv->is_audio = 1;
+    } else {
+        avio_skip(pb, 2);
+    }
+    vid_depth = avio_rl16(pb);
+    avio_skip(pb, 4);
+
+    vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
+    vst->codecpar->codec_id   = AV_CODEC_ID_GDV;
+    vst->codecpar->codec_tag  = 0;
+    vst->codecpar->width      = avio_rl16(pb);
+    vst->codecpar->height     = avio_rl16(pb);
+
+    if (vst->codecpar->width == 0 || vst->codecpar->height == 0) {
+        int i;
+
+        for (i = 0; i < FF_ARRAY_ELEMS(FixedSize) - 1; i++) {
+            if (FixedSize[i].id == size_id)
+                break;
+        }
+
+        vst->codecpar->width  = FixedSize[i].width;
+        vst->codecpar->height = FixedSize[i].height;
+    }
+
+    avpriv_set_pts_info(vst, 64, 1, fps);
+
+    if (vid_depth & 1) {
+        int i;
+
+        for (i = 0; i < 256; i++) {
+            unsigned r = avio_r8(pb);
+            unsigned g = avio_r8(pb);
+            unsigned b = avio_r8(pb);
+            gdv->pal[i] = 0xFFU << 24 | r << 18 | g << 10 | b << 2;
+        }
+    }
+
+    gdv->is_first_video = 1;
+
+    return 0;
+}
+
+static int gdv_read_packet(AVFormatContext *ctx, AVPacket *pkt)
+{
+    GDVContext *gdv = ctx->priv_data;
+    AVIOContext *pb = ctx->pb;
+    int ret;
+
+    if (avio_feof(pb))
+        return pb->error ? pb->error : AVERROR_EOF;
+
+    if (gdv->audio_size && gdv->is_audio) {
+        ret = av_get_packet(pb, pkt, gdv->audio_size);
+        if (ret < 0)
+            return ret;
+        pkt->stream_index = 1;
+        gdv->is_audio = 0;
+    } else {
+        uint8_t *pal;
+
+        if (avio_rl16(pb) != 0x1305)
+            return AVERROR_INVALIDDATA;
+        ret = av_get_packet(pb, pkt, 4 + avio_rl16(pb));
+        if (ret < 0)
+            return ret;
+        pkt->stream_index = 0;
+        gdv->is_audio = 1;
+
+        if (gdv->is_first_video) {
+            pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE,
+                                          AVPALETTE_SIZE);
+            if (!pal) {
+                av_packet_unref(pkt);
+                return AVERROR(ENOMEM);
+            }
+            memcpy(pal, gdv->pal, AVPALETTE_SIZE);
+            pkt->flags |= AV_PKT_FLAG_KEY;
+            gdv->is_first_video = 0;
+        }
+    }
+
+    return 0;
+}
+
+AVInputFormat ff_gdv_demuxer = {
+    .name           = "gdv",
+    .long_name      = NULL_IF_CONFIG_SMALL("Gremlin Digital Video"),
+    .priv_data_size = sizeof(GDVContext),
+    .read_probe     = gdv_read_probe,
+    .read_header    = gdv_read_header,
+    .read_packet    = gdv_read_packet,
+};
diff --git a/mythtv/external/FFmpeg/libavformat/genh.c b/mythtv/external/FFmpeg/libavformat/genh.c
index b683e026d1c..dd4e76d3d95 100644
--- a/mythtv/external/FFmpeg/libavformat/genh.c
+++ b/mythtv/external/FFmpeg/libavformat/genh.c
@@ -20,6 +20,7 @@
  */
 
 #include "libavutil/intreadwrite.h"
+#include "libavcodec/internal.h"
 #include "avformat.h"
 #include "internal.h"
 
@@ -54,7 +55,7 @@ static int genh_read_header(AVFormatContext *s)
 
     st->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;
     st->codecpar->channels    = avio_rl32(s->pb);
-    if (st->codecpar->channels <= 0)
+    if (st->codecpar->channels <= 0 || st->codecpar->channels > FF_SANE_NB_CHANNELS)
         return AVERROR_INVALIDDATA;
     if (st->codecpar->channels == 1)
         st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
diff --git a/mythtv/external/FFmpeg/libavformat/gif.c b/mythtv/external/FFmpeg/libavformat/gif.c
index 91cd40db5c1..01d98a27b05 100644
--- a/mythtv/external/FFmpeg/libavformat/gif.c
+++ b/mythtv/external/FFmpeg/libavformat/gif.c
@@ -175,7 +175,7 @@ static int flush_packet(AVFormatContext *s, AVPacket *new)
 
     av_packet_unref(gif->prev_pkt);
     if (new)
-        av_copy_packet(gif->prev_pkt, new);
+        av_packet_ref(gif->prev_pkt, new);
 
     return 0;
 }
@@ -186,7 +186,7 @@ static int gif_write_packet(AVFormatContext *s, AVPacket *pkt)
     AVStream *video_st = s->streams[0];
 
     if (!gif->prev_pkt) {
-        gif->prev_pkt = av_malloc(sizeof(*gif->prev_pkt));
+        gif->prev_pkt = av_packet_alloc();
         if (!gif->prev_pkt)
             return AVERROR(ENOMEM);
 
@@ -206,7 +206,7 @@ static int gif_write_packet(AVFormatContext *s, AVPacket *pkt)
             gif_image_write_header(s->pb, video_st, gif->loop, palette);
         }
 
-        return av_copy_packet(gif->prev_pkt, pkt);
+        return av_packet_ref(gif->prev_pkt, pkt);
     }
     return flush_packet(s, pkt);
 }
diff --git a/mythtv/external/FFmpeg/libavformat/gxfenc.c b/mythtv/external/FFmpeg/libavformat/gxfenc.c
index 79951b59af5..0e0772b7441 100644
--- a/mythtv/external/FFmpeg/libavformat/gxfenc.c
+++ b/mythtv/external/FFmpeg/libavformat/gxfenc.c
@@ -709,7 +709,7 @@ static int gxf_write_header(AVFormatContext *s)
     int ret;
     AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
 
-    if (!pb->seekable) {
+    if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
         av_log(s, AV_LOG_ERROR, "gxf muxer does not support streamed output, patch welcome\n");
         return -1;
     }
diff --git a/mythtv/external/FFmpeg/libavformat/hdsenc.c b/mythtv/external/FFmpeg/libavformat/hdsenc.c
index 347df83a516..72829f7257a 100644
--- a/mythtv/external/FFmpeg/libavformat/hdsenc.c
+++ b/mythtv/external/FFmpeg/libavformat/hdsenc.c
@@ -145,7 +145,7 @@ static void hds_free(AVFormatContext *s)
         if (os->ctx && os->ctx_inited)
             av_write_trailer(os->ctx);
         if (os->ctx)
-            av_freep(&os->ctx->pb);
+            avio_context_free(&os->ctx->pb);
         if (os->ctx)
             avformat_free_context(os->ctx);
         av_freep(&os->metadata);
@@ -420,7 +420,6 @@ static int hds_write_header(AVFormatContext *s)
         if (!os->has_video && c->min_frag_duration <= 0) {
             av_log(s, AV_LOG_WARNING,
                    "No video stream in output stream %d and no min frag duration set\n", i);
-            ret = AVERROR(EINVAL);
         }
         os->fragment_index = 1;
         write_abst(s, os, 0);
diff --git a/mythtv/external/FFmpeg/libavformat/hevc.c b/mythtv/external/FFmpeg/libavformat/hevc.c
index 7c294ef8a24..1a2d6cdd2b2 100644
--- a/mythtv/external/FFmpeg/libavformat/hevc.c
+++ b/mythtv/external/FFmpeg/libavformat/hevc.c
@@ -18,6 +18,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavcodec/avcodec.h"
 #include "libavcodec/get_bits.h"
 #include "libavcodec/golomb.h"
 #include "libavcodec/hevc.h"
@@ -127,8 +128,8 @@ static void hvcc_parse_ptl(GetBitContext *gb,
 {
     unsigned int i;
     HVCCProfileTierLevel general_ptl;
-    uint8_t sub_layer_profile_present_flag[MAX_SUB_LAYERS];
-    uint8_t sub_layer_level_present_flag[MAX_SUB_LAYERS];
+    uint8_t sub_layer_profile_present_flag[HEVC_MAX_SUB_LAYERS];
+    uint8_t sub_layer_level_present_flag[HEVC_MAX_SUB_LAYERS];
 
     general_ptl.profile_space               = get_bits(gb, 2);
     general_ptl.tier_flag                   = get_bits1(gb);
@@ -416,7 +417,7 @@ static void skip_scaling_list_data(GetBitContext *gb)
 
 static int parse_rps(GetBitContext *gb, unsigned int rps_idx,
                      unsigned int num_rps,
-                     unsigned int num_delta_pocs[MAX_SHORT_TERM_RPS_COUNT])
+                     unsigned int num_delta_pocs[HEVC_MAX_SHORT_TERM_RPS_COUNT])
 {
     unsigned int i;
 
@@ -485,7 +486,7 @@ static int hvcc_parse_sps(GetBitContext *gb,
                           HEVCDecoderConfigurationRecord *hvcc)
 {
     unsigned int i, sps_max_sub_layers_minus1, log2_max_pic_order_cnt_lsb_minus4;
-    unsigned int num_short_term_ref_pic_sets, num_delta_pocs[MAX_SHORT_TERM_RPS_COUNT];
+    unsigned int num_short_term_ref_pic_sets, num_delta_pocs[HEVC_MAX_SHORT_TERM_RPS_COUNT];
 
     skip_bits(gb, 4); // sps_video_parameter_set_id
 
@@ -555,7 +556,7 @@ static int hvcc_parse_sps(GetBitContext *gb,
     }
 
     num_short_term_ref_pic_sets = get_ue_golomb_long(gb);
-    if (num_short_term_ref_pic_sets > MAX_SHORT_TERM_RPS_COUNT)
+    if (num_short_term_ref_pic_sets > HEVC_MAX_SHORT_TERM_RPS_COUNT)
         return AVERROR_INVALIDDATA;
 
     for (i = 0; i < num_short_term_ref_pic_sets; i++) {
@@ -734,7 +735,7 @@ static int hvcc_array_add_nal_unit(uint8_t *nal_buf, uint32_t nal_size,
      * for all other arrays. When the sample entry name is ‘hev1’, the default
      * value of array_completeness is 0 for all arrays.
      */
-    if (nal_type == NAL_VPS || nal_type == NAL_SPS || nal_type == NAL_PPS)
+    if (nal_type == HEVC_NAL_VPS || nal_type == HEVC_NAL_SPS || nal_type == HEVC_NAL_PPS)
         array->array_completeness = ps_array_completeness;
 
     return 0;
@@ -768,20 +769,20 @@ static int hvcc_add_nal_unit(uint8_t *nal_buf, uint32_t nal_size,
      * and non-declarative SEI messages discarded?
      */
     switch (nal_type) {
-    case NAL_VPS:
-    case NAL_SPS:
-    case NAL_PPS:
-    case NAL_SEI_PREFIX:
-    case NAL_SEI_SUFFIX:
+    case HEVC_NAL_VPS:
+    case HEVC_NAL_SPS:
+    case HEVC_NAL_PPS:
+    case HEVC_NAL_SEI_PREFIX:
+    case HEVC_NAL_SEI_SUFFIX:
         ret = hvcc_array_add_nal_unit(nal_buf, nal_size, nal_type,
                                       ps_array_completeness, hvcc);
         if (ret < 0)
             goto end;
-        else if (nal_type == NAL_VPS)
+        else if (nal_type == HEVC_NAL_VPS)
             ret = hvcc_parse_vps(&gbc, hvcc);
-        else if (nal_type == NAL_SPS)
+        else if (nal_type == HEVC_NAL_SPS)
             ret = hvcc_parse_sps(&gbc, hvcc);
-        else if (nal_type == NAL_PPS)
+        else if (nal_type == HEVC_NAL_PPS)
             ret = hvcc_parse_pps(&gbc, hvcc);
         if (ret < 0)
             goto end;
@@ -915,21 +916,21 @@ static int hvcc_write(AVIOContext *pb, HEVCDecoderConfigurationRecord *hvcc)
      */
     for (i = 0; i < hvcc->numOfArrays; i++)
         switch (hvcc->array[i].NAL_unit_type) {
-        case NAL_VPS:
+        case HEVC_NAL_VPS:
             vps_count += hvcc->array[i].numNalus;
             break;
-        case NAL_SPS:
+        case HEVC_NAL_SPS:
             sps_count += hvcc->array[i].numNalus;
             break;
-        case NAL_PPS:
+        case HEVC_NAL_PPS:
             pps_count += hvcc->array[i].numNalus;
             break;
         default:
             break;
         }
-    if (!vps_count || vps_count > MAX_VPS_COUNT ||
-        !sps_count || sps_count > MAX_SPS_COUNT ||
-        !pps_count || pps_count > MAX_PPS_COUNT)
+    if (!vps_count || vps_count > HEVC_MAX_VPS_COUNT ||
+        !sps_count || sps_count > HEVC_MAX_SPS_COUNT ||
+        !pps_count || pps_count > HEVC_MAX_PPS_COUNT)
         return AVERROR_INVALIDDATA;
 
     /* unsigned int(8) configurationVersion = 1; */
@@ -1052,9 +1053,9 @@ int ff_hevc_annexb2mp4(AVIOContext *pb, const uint8_t *buf_in,
         buf += 4;
 
         switch (type) {
-        case NAL_VPS:
-        case NAL_SPS:
-        case NAL_PPS:
+        case HEVC_NAL_VPS:
+        case HEVC_NAL_SPS:
+        case HEVC_NAL_PPS:
             num_ps++;
             break;
         default:
@@ -1127,11 +1128,11 @@ int ff_isom_write_hvcc(AVIOContext *pb, const uint8_t *data,
         buf += 4;
 
         switch (type) {
-        case NAL_VPS:
-        case NAL_SPS:
-        case NAL_PPS:
-        case NAL_SEI_PREFIX:
-        case NAL_SEI_SUFFIX:
+        case HEVC_NAL_VPS:
+        case HEVC_NAL_SPS:
+        case HEVC_NAL_PPS:
+        case HEVC_NAL_SEI_PREFIX:
+        case HEVC_NAL_SEI_SUFFIX:
             ret = hvcc_add_nal_unit(buf, len, ps_array_completeness, &hvcc);
             if (ret < 0)
                 goto end;
diff --git a/mythtv/external/FFmpeg/libavformat/hevcdec.c b/mythtv/external/FFmpeg/libavformat/hevcdec.c
index e36a0513e3f..aaab0ffa2f6 100644
--- a/mythtv/external/FFmpeg/libavformat/hevcdec.c
+++ b/mythtv/external/FFmpeg/libavformat/hevcdec.c
@@ -43,15 +43,15 @@ static int hevc_probe(AVProbeData *p)
                 return 0;
 
             switch (type) {
-            case NAL_VPS:        vps++;  break;
-            case NAL_SPS:        sps++;  break;
-            case NAL_PPS:        pps++;  break;
-            case NAL_BLA_N_LP:
-            case NAL_BLA_W_LP:
-            case NAL_BLA_W_RADL:
-            case NAL_CRA_NUT:
-            case NAL_IDR_N_LP:
-            case NAL_IDR_W_RADL: irap++; break;
+            case HEVC_NAL_VPS:        vps++;  break;
+            case HEVC_NAL_SPS:        sps++;  break;
+            case HEVC_NAL_PPS:        pps++;  break;
+            case HEVC_NAL_BLA_N_LP:
+            case HEVC_NAL_BLA_W_LP:
+            case HEVC_NAL_BLA_W_RADL:
+            case HEVC_NAL_CRA_NUT:
+            case HEVC_NAL_IDR_N_LP:
+            case HEVC_NAL_IDR_W_RADL: irap++; break;
             }
         }
     }
diff --git a/mythtv/external/FFmpeg/libavformat/hls.c b/mythtv/external/FFmpeg/libavformat/hls.c
index 2bf86fadc64..786934af032 100644
--- a/mythtv/external/FFmpeg/libavformat/hls.c
+++ b/mythtv/external/FFmpeg/libavformat/hls.c
@@ -204,6 +204,8 @@ typedef struct HLSContext {
     char *http_proxy;                    ///< holds the address of the HTTP proxy server
     AVDictionary *avio_opts;
     int strict_std_compliance;
+    char *allowed_extensions;
+    int max_reload;
 } HLSContext;
 
 static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
@@ -618,8 +620,19 @@ static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url,
         return AVERROR_INVALIDDATA;
 
     // only http(s) & file are allowed
-    if (!av_strstart(proto_name, "http", NULL) && !av_strstart(proto_name, "file", NULL))
+    if (av_strstart(proto_name, "file", NULL)) {
+        if (strcmp(c->allowed_extensions, "ALL") && !av_match_ext(url, c->allowed_extensions)) {
+            av_log(s, AV_LOG_ERROR,
+                "Filename extension of \'%s\' is not a common multimedia extension, blocked for security reasons.\n"
+                "If you wish to override this adjust allowed_extensions, you can set it to \'ALL\' to allow all\n",
+                url);
+            return AVERROR_INVALIDDATA;
+        }
+    } else if (av_strstart(proto_name, "http", NULL)) {
+        ;
+    } else
         return AVERROR_INVALIDDATA;
+
     if (!strncmp(proto_name, url, strlen(proto_name)) && url[strlen(proto_name)] == ':')
         ;
     else if (av_strstart(url, "crypto", NULL) && !strncmp(proto_name, url + 7, strlen(proto_name)) && url[7 + strlen(proto_name)] == ':')
@@ -630,8 +643,16 @@ static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url,
     ret = s->io_open(s, pb, url, AVIO_FLAG_READ, &tmp);
     if (ret >= 0) {
         // update cookies on http response with setcookies.
-        void *u = (s->flags & AVFMT_FLAG_CUSTOM_IO) ? NULL : s->pb;
-        update_options(&c->cookies, "cookies", u);
+        char *new_cookies = NULL;
+
+        if (!(s->flags & AVFMT_FLAG_CUSTOM_IO))
+            av_opt_get(*pb, "cookies", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&new_cookies);
+
+        if (new_cookies) {
+            av_free(c->cookies);
+            c->cookies = new_cookies;
+        }
+
         av_dict_set(&opts, "cookies", c->cookies, 0);
     }
 
@@ -670,7 +691,7 @@ static int parse_playlist(HLSContext *c, const char *url,
         av_dict_set(&opts, "seekable", "0", 0);
 
         // broker prior HTTP options that should be consistent across requests
-        av_dict_set(&opts, "user-agent", c->user_agent, 0);
+        av_dict_set(&opts, "user_agent", c->user_agent, 0);
         av_dict_set(&opts, "cookies", c->cookies, 0);
         av_dict_set(&opts, "headers", c->headers, 0);
         av_dict_set(&opts, "http_proxy", c->http_proxy, 0);
@@ -1084,7 +1105,7 @@ static int open_input(HLSContext *c, struct playlist *pls, struct segment *seg)
     int is_http = 0;
 
     // broker prior HTTP options that should be consistent across requests
-    av_dict_set(&opts, "user-agent", c->user_agent, 0);
+    av_dict_set(&opts, "user_agent", c->user_agent, 0);
     av_dict_set(&opts, "cookies", c->cookies, 0);
     av_dict_set(&opts, "headers", c->headers, 0);
     av_dict_set(&opts, "http_proxy", c->http_proxy, 0);
@@ -1243,6 +1264,7 @@ static int read_data(void *opaque, uint8_t *buf, int buf_size)
     HLSContext *c = v->parent->priv_data;
     int ret, i;
     int just_opened = 0;
+    int reload_count = 0;
 
 restart:
     if (!v->needed)
@@ -1274,6 +1296,9 @@ static int read_data(void *opaque, uint8_t *buf, int buf_size)
         reload_interval = default_reload_interval(v);
 
 reload:
+        reload_count++;
+        if (reload_count > c->max_reload)
+            return AVERROR_EOF;
         if (!v->finished &&
             av_gettime_relative() - v->last_load_time >= reload_interval) {
             if ((ret = parse_playlist(c, v->url, v, NULL)) < 0) {
@@ -1473,9 +1498,9 @@ static int select_cur_seq_no(HLSContext *c, struct playlist *pls)
 static int save_avio_options(AVFormatContext *s)
 {
     HLSContext *c = s->priv_data;
-    static const char *opts[] = {
+    static const char * const opts[] = {
         "headers", "http_proxy", "user_agent", "user-agent", "cookies", NULL };
-    const char **opt = opts;
+    const char * const * opt = opts;
     uint8_t *buf;
     int ret = 0;
 
@@ -1593,6 +1618,19 @@ static void update_noheader_flag(AVFormatContext *s)
         s->ctx_flags &= ~AVFMTCTX_NOHEADER;
 }
 
+static int hls_close(AVFormatContext *s)
+{
+    HLSContext *c = s->priv_data;
+
+    free_playlist_list(c);
+    free_variant_list(c);
+    free_rendition_list(c);
+
+    av_dict_free(&c->avio_opts);
+
+    return 0;
+}
+
 static int hls_read_header(AVFormatContext *s)
 {
     void *u = (s->flags & AVFMT_FLAG_CUSTOM_IO) ? NULL : s->pb;
@@ -1610,7 +1648,7 @@ static int hls_read_header(AVFormatContext *s)
 
     if (u) {
         // get the previous user agent & set back to null if string size is zero
-        update_options(&c->user_agent, "user-agent", u);
+        update_options(&c->user_agent, "user_agent", u);
 
         // get the previous cookies & set back to null if string size is zero
         update_options(&c->cookies, "cookies", u);
@@ -1748,6 +1786,7 @@ static int hls_read_header(AVFormatContext *s)
         }
         pls->ctx->pb       = &pls->pb;
         pls->ctx->io_open  = nested_io_open;
+        pls->ctx->flags   |= s->flags & ~AVFMT_FLAG_CUSTOM_IO;
 
         if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0)
             goto fail;
@@ -1794,9 +1833,7 @@ static int hls_read_header(AVFormatContext *s)
 
     return 0;
 fail:
-    free_playlist_list(c);
-    free_variant_list(c);
-    free_rendition_list(c);
+    hls_close(s);
     return ret;
 }
 
@@ -2013,19 +2050,6 @@ static int hls_read_packet(AVFormatContext *s, AVPacket *pkt)
     return AVERROR_EOF;
 }
 
-static int hls_close(AVFormatContext *s)
-{
-    HLSContext *c = s->priv_data;
-
-    free_playlist_list(c);
-    free_variant_list(c);
-    free_rendition_list(c);
-
-    av_dict_free(&c->avio_opts);
-
-    return 0;
-}
-
 static int hls_read_seek(AVFormatContext *s, int stream_index,
                                int64_t timestamp, int flags)
 {
@@ -2127,6 +2151,12 @@ static int hls_probe(AVProbeData *p)
 static const AVOption hls_options[] = {
     {"live_start_index", "segment index to start live streams at (negative values are from the end)",
         OFFSET(live_start_index), AV_OPT_TYPE_INT, {.i64 = -3}, INT_MIN, INT_MAX, FLAGS},
+    {"allowed_extensions", "List of file extensions that hls is allowed to access",
+        OFFSET(allowed_extensions), AV_OPT_TYPE_STRING,
+        {.str = "3gp,aac,avi,flac,mkv,m3u8,m4a,m4s,m4v,mpg,mov,mp2,mp3,mp4,mpeg,mpegts,ogg,ogv,oga,ts,vob,wav"},
+        INT_MIN, INT_MAX, FLAGS},
+    {"max_reload", "Maximum number of times a insufficient list is attempted to be reloaded",
+        OFFSET(max_reload), AV_OPT_TYPE_INT, {.i64 = 1000}, 0, INT_MAX, FLAGS},
     {NULL}
 };
 
diff --git a/mythtv/external/FFmpeg/libavformat/hlsenc.c b/mythtv/external/FFmpeg/libavformat/hlsenc.c
index 9ca2df7bf29..e0cef8b8795 100644
--- a/mythtv/external/FFmpeg/libavformat/hlsenc.c
+++ b/mythtv/external/FFmpeg/libavformat/hlsenc.c
@@ -26,10 +26,18 @@
 #include <unistd.h>
 #endif
 
+#if CONFIG_GCRYPT
+#include <gcrypt.h>
+#elif CONFIG_OPENSSL
+#include <openssl/rand.h>
+#endif
+
 #include "libavutil/avassert.h"
 #include "libavutil/mathematics.h"
 #include "libavutil/parseutils.h"
 #include "libavutil/avstring.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/random_seed.h"
 #include "libavutil/opt.h"
 #include "libavutil/log.h"
 #include "libavutil/time_internal.h"
@@ -39,13 +47,21 @@
 #include "internal.h"
 #include "os_support.h"
 
+typedef enum {
+  HLS_START_SEQUENCE_AS_START_NUMBER = 0,
+  HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH = 1,
+  HLS_START_SEQUENCE_AS_FORMATTED_DATETIME = 2,  // YYYYMMDDhhmmss
+} StartSequenceSourceType;
+
 #define KEYSIZE 16
 #define LINE_BUFFER_SIZE 1024
+#define HLS_MICROSECOND_UNIT   1000000
 
 typedef struct HLSSegment {
     char filename[1024];
     char sub_filename[1024];
     double duration; /* in seconds */
+    int discont;
     int64_t pos;
     int64_t size;
 
@@ -65,8 +81,18 @@ typedef enum HLSFlags {
     HLS_SPLIT_BY_TIME = (1 << 5),
     HLS_APPEND_LIST = (1 << 6),
     HLS_PROGRAM_DATE_TIME = (1 << 7),
+    HLS_SECOND_LEVEL_SEGMENT_INDEX = (1 << 8), // include segment index in segment filenames when use_localtime  e.g.: %%03d
+    HLS_SECOND_LEVEL_SEGMENT_DURATION = (1 << 9), // include segment duration (microsec) in segment filenames when use_localtime  e.g.: %%09t
+    HLS_SECOND_LEVEL_SEGMENT_SIZE = (1 << 10), // include segment size (bytes) in segment filenames when use_localtime  e.g.: %%014s
+    HLS_TEMP_FILE = (1 << 11),
+    HLS_PERIODIC_REKEY = (1 << 12),
 } HLSFlags;
 
+typedef enum {
+    SEGMENT_TYPE_MPEGTS,
+    SEGMENT_TYPE_FMP4,
+} SegmentType;
+
 typedef enum {
     PLAYLIST_TYPE_NONE,
     PLAYLIST_TYPE_EVENT,
@@ -79,8 +105,12 @@ typedef struct HLSContext {
     unsigned number;
     int64_t sequence;
     int64_t start_sequence;
+    uint32_t start_sequence_source_type;  // enum StartSequenceSourceType
     AVOutputFormat *oformat;
     AVOutputFormat *vtt_oformat;
+    AVIOContext *out;
+    int packets_written;
+    int init_range_length;
 
     AVFormatContext *avf;
     AVFormatContext *vtt_avf;
@@ -88,10 +118,15 @@ typedef struct HLSContext {
     float time;            // Set by a private option.
     float init_time;       // Set by a private option.
     int max_nb_segments;   // Set by a private option.
+#if FF_API_HLS_WRAP
     int  wrap;             // Set by a private option.
+#endif
     uint32_t flags;        // enum HLSFlags
     uint32_t pl_type;      // enum PlaylistType
     char *segment_filename;
+    char *fmp4_init_filename;
+    int segment_type;
+    int fmp4_init_mode;
 
     int use_localtime;      ///< flag to expand filename with localtime
     int use_localtime_mkdir;///< flag to mkdir dirname in timebased filename
@@ -99,6 +134,8 @@ typedef struct HLSContext {
     int64_t recording_time;
     int has_video;
     int has_subtitle;
+    int new_start;
+    double dpp;           // duration per packet
     int64_t start_pts;
     int64_t end_pts;
     double duration;      // last segment duration computed so far, in seconds
@@ -107,12 +144,14 @@ typedef struct HLSContext {
     int64_t max_seg_size; // every segment file max size
     int nb_entries;
     int discontinuity_set;
+    int discontinuity;
 
     HLSSegment *segments;
     HLSSegment *last_segment;
     HLSSegment *old_segments;
 
     char *basename;
+    char *base_output_dirname;
     char *vtt_basename;
     char *vtt_m3u8_name;
     char *baseurl;
@@ -121,6 +160,12 @@ typedef struct HLSContext {
     char *subtitle_filename;
     AVDictionary *format_options;
 
+    int encrypt;
+    char *key;
+    char *key_url;
+    char *iv;
+    char *key_basename;
+
     char *key_info_file;
     char key_file[LINE_BUFFER_SIZE + 1];
     char key_uri[LINE_BUFFER_SIZE + 1];
@@ -131,8 +176,15 @@ typedef struct HLSContext {
     char *method;
 
     double initial_prog_date_time;
+    char current_segment_final_filename_fmt[1024]; // when renaming segments
+    char *user_agent;
 } HLSContext;
 
+static int get_int_from_double(double val)
+{
+    return (int)((val - (int)val) >= 0.001) ? (int)(val + 1) : (int)val;
+}
+
 static int mkdir_p(const char *path) {
     int ret = 0;
     char *temp = av_strdup(path);
@@ -166,13 +218,94 @@ static int mkdir_p(const char *path) {
     return ret;
 }
 
-static int hls_delete_old_segments(HLSContext *hls) {
+static void set_http_options(AVFormatContext *s, AVDictionary **options, HLSContext *c)
+{
+    const char *proto = avio_find_protocol_name(s->filename);
+    int http_base_proto = proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
+
+    if (c->method) {
+        av_dict_set(options, "method", c->method, 0);
+    } else if (http_base_proto) {
+        av_log(c, AV_LOG_WARNING, "No HTTP method set, hls muxer defaulting to method PUT.\n");
+        av_dict_set(options, "method", "PUT", 0);
+    }
+    if (c->user_agent)
+        av_dict_set(options, "user_agent", c->user_agent, 0);
+
+}
+
+static int replace_int_data_in_filename(char *buf, int buf_size, const char *filename, char placeholder, int64_t number)
+{
+    const char *p;
+    char *q, buf1[20], c;
+    int nd, len, addchar_count;
+    int found_count = 0;
+
+    q = buf;
+    p = filename;
+    for (;;) {
+        c = *p;
+        if (c == '\0')
+            break;
+        if (c == '%' && *(p+1) == '%')  // %%
+            addchar_count = 2;
+        else if (c == '%' && (av_isdigit(*(p+1)) || *(p+1) == placeholder)) {
+            nd = 0;
+            addchar_count = 1;
+            while (av_isdigit(*(p + addchar_count))) {
+                nd = nd * 10 + *(p + addchar_count) - '0';
+                addchar_count++;
+            }
+
+            if (*(p + addchar_count) == placeholder) {
+                len = snprintf(buf1, sizeof(buf1), "%0*"PRId64, (number < 0) ? nd : nd++, number);
+                if (len < 1)  // returned error or empty buf1
+                    goto fail;
+                if ((q - buf + len) > buf_size - 1)
+                    goto fail;
+                memcpy(q, buf1, len);
+                q += len;
+                p += (addchar_count + 1);
+                addchar_count = 0;
+                found_count++;
+            }
+
+        } else
+            addchar_count = 1;
+
+        while (addchar_count--)
+            if ((q - buf) < buf_size - 1)
+                *q++ = *p++;
+            else
+                goto fail;
+    }
+    *q = '\0';
+    return found_count;
+fail:
+    *q = '\0';
+    return -1;
+}
+
+static void write_styp(AVIOContext *pb)
+{
+    avio_wb32(pb, 24);
+    ffio_wfourcc(pb, "styp");
+    ffio_wfourcc(pb, "msdh");
+    avio_wb32(pb, 0); /* minor */
+    ffio_wfourcc(pb, "msdh");
+    ffio_wfourcc(pb, "msix");
+}
+
+static int hls_delete_old_segments(AVFormatContext *s, HLSContext *hls) {
 
     HLSSegment *segment, *previous_segment = NULL;
     float playlist_duration = 0.0f;
     int ret = 0, path_size, sub_path_size;
     char *dirname = NULL, *p, *sub_path;
     char *path = NULL;
+    AVDictionary *options = NULL;
+    AVIOContext *out = NULL;
+    const char *proto = NULL;
 
     segment = hls->segments;
     while (segment) {
@@ -191,7 +324,7 @@ static int hls_delete_old_segments(HLSContext *hls) {
         }
     }
 
-    if (segment) {
+    if (segment && !hls->use_localtime_mkdir) {
         if (hls->segment_filename) {
             dirname = av_strdup(hls->segment_filename);
         } else {
@@ -208,22 +341,33 @@ static int hls_delete_old_segments(HLSContext *hls) {
     while (segment) {
         av_log(hls, AV_LOG_DEBUG, "deleting old segment %s\n",
                                   segment->filename);
-        path_size = strlen(dirname) + strlen(segment->filename) + 1;
+        path_size =  (hls->use_localtime_mkdir ? 0 : strlen(dirname)) + strlen(segment->filename) + 1;
         path = av_malloc(path_size);
         if (!path) {
             ret = AVERROR(ENOMEM);
             goto fail;
         }
 
-        av_strlcpy(path, dirname, path_size);
-        av_strlcat(path, segment->filename, path_size);
-        if (unlink(path) < 0) {
+        if (hls->use_localtime_mkdir)
+            av_strlcpy(path, segment->filename, path_size);
+        else { // segment->filename contains basename only
+            av_strlcpy(path, dirname, path_size);
+            av_strlcat(path, segment->filename, path_size);
+        }
+
+        proto = avio_find_protocol_name(s->filename);
+        if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
+            av_dict_set(&options, "method", "DELETE", 0);
+            if ((ret = hls->avf->io_open(hls->avf, &out, path, AVIO_FLAG_WRITE, &options)) < 0)
+                goto fail;
+            ff_format_io_close(hls->avf, &out);
+        } else if (unlink(path) < 0) {
             av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
                                      path, strerror(errno));
         }
 
-        if (segment->sub_filename[0] != '\0') {
-            sub_path_size = strlen(dirname) + strlen(segment->sub_filename) + 1;
+        if ((segment->sub_filename[0] != '\0')) {
+            sub_path_size = strlen(segment->sub_filename) + 1 + (dirname ? strlen(dirname) : 0);
             sub_path = av_malloc(sub_path_size);
             if (!sub_path) {
                 ret = AVERROR(ENOMEM);
@@ -232,7 +376,15 @@ static int hls_delete_old_segments(HLSContext *hls) {
 
             av_strlcpy(sub_path, dirname, sub_path_size);
             av_strlcat(sub_path, segment->sub_filename, sub_path_size);
-            if (unlink(sub_path) < 0) {
+
+            if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
+                av_dict_set(&options, "method", "DELETE", 0);
+                if ((ret = hls->avf->io_open(hls->avf, &out, sub_path, AVIO_FLAG_WRITE, &options)) < 0) {
+                    av_free(sub_path);
+                    goto fail;
+                }
+                ff_format_io_close(hls->avf, &out);
+            } else if (unlink(sub_path) < 0) {
                 av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
                                          sub_path, strerror(errno));
             }
@@ -251,6 +403,89 @@ static int hls_delete_old_segments(HLSContext *hls) {
     return ret;
 }
 
+static int randomize(uint8_t *buf, int len)
+{
+#if CONFIG_GCRYPT
+    gcry_randomize(buf, len, GCRY_VERY_STRONG_RANDOM);
+    return 0;
+#elif CONFIG_OPENSSL
+    if (RAND_bytes(buf, len))
+        return 0;
+#else
+    return AVERROR(ENOSYS);
+#endif
+    return AVERROR(EINVAL);
+}
+
+static int do_encrypt(AVFormatContext *s)
+{
+    HLSContext *hls = s->priv_data;
+    int ret;
+    int len;
+    AVIOContext *pb;
+    uint8_t key[KEYSIZE];
+
+    len = strlen(hls->basename) + 4 + 1;
+    hls->key_basename = av_mallocz(len);
+    if (!hls->key_basename)
+        return AVERROR(ENOMEM);
+
+    av_strlcpy(hls->key_basename, s->filename, len);
+    av_strlcat(hls->key_basename, ".key", len);
+
+    if (hls->key_url) {
+        av_strlcpy(hls->key_file, hls->key_url, sizeof(hls->key_file));
+        av_strlcpy(hls->key_uri, hls->key_url, sizeof(hls->key_uri));
+    } else {
+        av_strlcpy(hls->key_file, hls->key_basename, sizeof(hls->key_file));
+        av_strlcpy(hls->key_uri, hls->key_basename, sizeof(hls->key_uri));
+    }
+
+    if (!*hls->iv_string) {
+        uint8_t iv[16] = { 0 };
+        char buf[33];
+
+        if (!hls->iv) {
+            AV_WB64(iv + 8, hls->sequence);
+        } else {
+            memcpy(iv, hls->iv, sizeof(iv));
+        }
+        ff_data_to_hex(buf, iv, sizeof(iv), 0);
+        buf[32] = '\0';
+        memcpy(hls->iv_string, buf, sizeof(hls->iv_string));
+    }
+
+    if (!*hls->key_uri) {
+        av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (!*hls->key_file) {
+        av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n");
+        return AVERROR(EINVAL);
+    }
+
+    if (!*hls->key_string) {
+        if (!hls->key) {
+            if ((ret = randomize(key, sizeof(key))) < 0) {
+                av_log(s, AV_LOG_ERROR, "Cannot generate a strong random key\n");
+                return ret;
+            }
+        } else {
+            memcpy(key, hls->key, sizeof(key));
+        }
+
+        ff_data_to_hex(hls->key_string, key, sizeof(key), 0);
+        if ((ret = s->io_open(s, &pb, hls->key_file, AVIO_FLAG_WRITE, NULL)) < 0)
+            return ret;
+        avio_seek(pb, 0, SEEK_CUR);
+        avio_write(pb, key, KEYSIZE);
+        avio_close(pb);
+    }
+    return 0;
+}
+
+
 static int hls_encryption_start(AVFormatContext *s)
 {
     HLSContext *hls = s->priv_data;
@@ -313,9 +548,11 @@ static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
 
 static int hls_mux_init(AVFormatContext *s)
 {
+    AVDictionary *options = NULL;
     HLSContext *hls = s->priv_data;
     AVFormatContext *oc;
     AVFormatContext *vtt_oc = NULL;
+    int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
     int i, ret;
 
     ret = avformat_alloc_output_context2(&hls->avf, hls->oformat, NULL, NULL);
@@ -323,6 +560,7 @@ static int hls_mux_init(AVFormatContext *s)
         return ret;
     oc = hls->avf;
 
+    oc->filename[0]        = '\0';
     oc->oformat            = hls->oformat;
     oc->interrupt_callback = s->interrupt_callback;
     oc->max_delay          = s->max_delay;
@@ -351,11 +589,222 @@ static int hls_mux_init(AVFormatContext *s)
         if (!(st = avformat_new_stream(loc, NULL)))
             return AVERROR(ENOMEM);
         avcodec_parameters_copy(st->codecpar, s->streams[i]->codecpar);
+        if (!oc->oformat->codec_tag ||
+            av_codec_get_id (oc->oformat->codec_tag, s->streams[i]->codecpar->codec_tag) == st->codecpar->codec_id ||
+            av_codec_get_tag(oc->oformat->codec_tag, s->streams[i]->codecpar->codec_id) <= 0) {
+            st->codecpar->codec_tag = s->streams[i]->codecpar->codec_tag;
+        } else {
+            st->codecpar->codec_tag = 0;
+        }
+
         st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
         st->time_base = s->streams[i]->time_base;
+        av_dict_copy(&st->metadata, s->streams[i]->metadata, 0);
     }
+    hls->packets_written = 1;
     hls->start_pos = 0;
+    hls->new_start = 1;
+    hls->fmp4_init_mode = 0;
+
+    if (hls->segment_type == SEGMENT_TYPE_FMP4) {
+        if (hls->max_seg_size > 0) {
+            av_log(s, AV_LOG_WARNING, "Multi-file byterange mode is currently unsupported in the HLS muxer.\n");
+            return AVERROR_PATCHWELCOME;
+        }
+        hls->packets_written = 0;
+        hls->init_range_length = 0;
+        hls->fmp4_init_mode = !byterange_mode;
+        set_http_options(s, &options, hls);
+        if ((ret = avio_open_dyn_buf(&oc->pb)) < 0)
+            return ret;
+
+        if ((ret = s->io_open(s, &hls->out, hls->base_output_dirname, AVIO_FLAG_WRITE, &options)) < 0) {
+            av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", hls->fmp4_init_filename);
+            return ret;
+        }
+
+        if (hls->format_options_str) {
+            ret = av_dict_parse_string(&hls->format_options, hls->format_options_str, "=", ":", 0);
+            if (ret < 0) {
+                av_log(s, AV_LOG_ERROR, "Could not parse format options list '%s'\n",
+                       hls->format_options_str);
+                return ret;
+            }
+        }
+
+        av_dict_copy(&options, hls->format_options, 0);
+        av_dict_set(&options, "fflags", "-autobsf", 0);
+        av_dict_set(&options, "movflags", "frag_custom+dash+delay_moov", 0);
+        ret = avformat_init_output(oc, &options);
+        if (ret < 0)
+            return ret;
+        if (av_dict_count(options)) {
+            av_log(s, AV_LOG_ERROR, "Some of the provided format options in '%s' are not recognized\n", hls->format_options_str);
+            av_dict_free(&options);
+            return AVERROR(EINVAL);
+        }
+        avio_flush(oc->pb);
+        av_dict_free(&options);
+    }
+    return 0;
+}
+
+static HLSSegment *find_segment_by_filename(HLSSegment *segment, const char *filename)
+{
+    while (segment) {
+        if (!av_strcasecmp(segment->filename,filename))
+            return segment;
+        segment = segment->next;
+    }
+    return (HLSSegment *) NULL;
+}
+
+static int sls_flags_filename_process(struct AVFormatContext *s, HLSContext *hls, HLSSegment *en, double duration,
+                                         int64_t pos, int64_t size)
+{
+    if ((hls->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) &&
+        strlen(hls->current_segment_final_filename_fmt)) {
+        av_strlcpy(hls->avf->filename, hls->current_segment_final_filename_fmt, sizeof(hls->avf->filename));
+        if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
+            char * filename = av_strdup(hls->avf->filename);  // %%s will be %s after strftime
+            if (!filename) {
+                av_free(en);
+                return AVERROR(ENOMEM);
+            }
+            if (replace_int_data_in_filename(hls->avf->filename, sizeof(hls->avf->filename),
+                filename, 's', pos + size) < 1) {
+                av_log(hls, AV_LOG_ERROR,
+                       "Invalid second level segment filename template '%s', "
+                        "you can try to remove second_level_segment_size flag\n",
+                       filename);
+                av_free(filename);
+                av_free(en);
+                return AVERROR(EINVAL);
+            }
+            av_free(filename);
+        }
+        if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
+            char * filename = av_strdup(hls->avf->filename);  // %%t will be %t after strftime
+            if (!filename) {
+                av_free(en);
+                return AVERROR(ENOMEM);
+            }
+            if (replace_int_data_in_filename(hls->avf->filename, sizeof(hls->avf->filename),
+                filename, 't',  (int64_t)round(duration * HLS_MICROSECOND_UNIT)) < 1) {
+                av_log(hls, AV_LOG_ERROR,
+                       "Invalid second level segment filename template '%s', "
+                        "you can try to remove second_level_segment_time flag\n",
+                       filename);
+                av_free(filename);
+                av_free(en);
+                return AVERROR(EINVAL);
+            }
+            av_free(filename);
+        }
+    }
+    return 0;
+}
+
+static int sls_flag_check_duration_size_index(HLSContext *hls)
+{
+    int ret = 0;
+
+    if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
+         av_log(hls, AV_LOG_ERROR,
+                "second_level_segment_duration hls_flag requires use_localtime to be true\n");
+         ret = AVERROR(EINVAL);
+    }
+    if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
+         av_log(hls, AV_LOG_ERROR,
+                "second_level_segment_size hls_flag requires use_localtime to be true\n");
+         ret = AVERROR(EINVAL);
+    }
+    if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_INDEX) {
+        av_log(hls, AV_LOG_ERROR,
+               "second_level_segment_index hls_flag requires use_localtime to be true\n");
+        ret = AVERROR(EINVAL);
+    }
+
+    return ret;
+}
+
+static int sls_flag_check_duration_size(HLSContext *hls)
+{
+    const char *proto = avio_find_protocol_name(hls->basename);
+    int segment_renaming_ok = proto && !strcmp(proto, "file");
+    int ret = 0;
+
+    if ((hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) && !segment_renaming_ok) {
+         av_log(hls, AV_LOG_ERROR,
+                "second_level_segment_duration hls_flag works only with file protocol segment names\n");
+         ret = AVERROR(EINVAL);
+    }
+    if ((hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) && !segment_renaming_ok) {
+         av_log(hls, AV_LOG_ERROR,
+                "second_level_segment_size hls_flag works only with file protocol segment names\n");
+         ret = AVERROR(EINVAL);
+    }
 
+    return ret;
+}
+
+static void sls_flag_file_rename(HLSContext *hls, char *old_filename) {
+    if ((hls->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) &&
+        strlen(hls->current_segment_final_filename_fmt)) {
+        ff_rename(old_filename, hls->avf->filename, hls);
+    }
+}
+
+static int sls_flag_use_localtime_filename(AVFormatContext *oc, HLSContext *c)
+{
+    if (c->flags & HLS_SECOND_LEVEL_SEGMENT_INDEX) {
+        char * filename = av_strdup(oc->filename);  // %%d will be %d after strftime
+        if (!filename)
+            return AVERROR(ENOMEM);
+        if (replace_int_data_in_filename(oc->filename, sizeof(oc->filename),
+#if FF_API_HLS_WRAP
+            filename, 'd', c->wrap ? c->sequence % c->wrap : c->sequence) < 1) {
+#else
+            filename, 'd', c->sequence) < 1) {
+#endif
+            av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
+                    "you can try to remove second_level_segment_index flag\n",
+                   filename);
+            av_free(filename);
+            return AVERROR(EINVAL);
+        }
+        av_free(filename);
+    }
+    if (c->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) {
+        av_strlcpy(c->current_segment_final_filename_fmt, oc->filename,
+                   sizeof(c->current_segment_final_filename_fmt));
+        if (c->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
+            char * filename = av_strdup(oc->filename);  // %%s will be %s after strftime
+            if (!filename)
+                return AVERROR(ENOMEM);
+            if (replace_int_data_in_filename(oc->filename, sizeof(oc->filename), filename, 's', 0) < 1) {
+                av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
+                        "you can try to remove second_level_segment_size flag\n",
+                       filename);
+                av_free(filename);
+                return AVERROR(EINVAL);
+            }
+            av_free(filename);
+        }
+        if (c->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
+            char * filename = av_strdup(oc->filename);  // %%t will be %t after strftime
+            if (!filename)
+                return AVERROR(ENOMEM);
+            if (replace_int_data_in_filename(oc->filename, sizeof(oc->filename), filename, 't', 0) < 1) {
+                av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
+                        "you can try to remove second_level_segment_time flag\n",
+                       filename);
+                av_free(filename);
+                return AVERROR(EINVAL);
+            }
+            av_free(filename);
+        }
+    }
     return 0;
 }
 
@@ -365,16 +814,26 @@ static int hls_append_segment(struct AVFormatContext *s, HLSContext *hls, double
 {
     HLSSegment *en = av_malloc(sizeof(*en));
     const char  *filename;
+    int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
     int ret;
 
     if (!en)
         return AVERROR(ENOMEM);
 
+    ret = sls_flags_filename_process(s, hls, en, duration, pos, size);
+    if (ret < 0) {
+        return ret;
+    }
+
     filename = av_basename(hls->avf->filename);
 
     if (hls->use_localtime_mkdir) {
         filename = hls->avf->filename;
     }
+    if ((find_segment_by_filename(hls->segments, filename) || find_segment_by_filename(hls->old_segments, filename))
+        && !byterange_mode) {
+        av_log(hls, AV_LOG_WARNING, "Duplicated segment filename detected: %s\n", filename);
+    }
     av_strlcpy(en->filename, filename, sizeof(en->filename));
 
     if(hls->has_subtitle)
@@ -386,8 +845,14 @@ static int hls_append_segment(struct AVFormatContext *s, HLSContext *hls, double
     en->pos      = pos;
     en->size     = size;
     en->next     = NULL;
+    en->discont  = 0;
 
-    if (hls->key_info_file) {
+    if (hls->discontinuity) {
+        en->discont = 1;
+        hls->discontinuity = 0;
+    }
+
+    if (hls->key_info_file || hls->encrypt) {
         av_strlcpy(en->key_uri, hls->key_uri, sizeof(en->key_uri));
         av_strlcpy(en->iv_string, hls->iv_string, sizeof(en->iv_string));
     }
@@ -405,12 +870,17 @@ static int hls_append_segment(struct AVFormatContext *s, HLSContext *hls, double
 
     if (hls->max_nb_segments && hls->nb_entries >= hls->max_nb_segments) {
         en = hls->segments;
+        hls->initial_prog_date_time += en->duration;
         hls->segments = en->next;
         if (en && hls->flags & HLS_DELETE_SEGMENTS &&
+#if FF_API_HLS_WRAP
                 !(hls->flags & HLS_SINGLE_FILE || hls->wrap)) {
+#else
+                !(hls->flags & HLS_SINGLE_FILE)) {
+#endif
             en->next = hls->old_segments;
             hls->old_segments = en;
-            if ((ret = hls_delete_old_segments(hls)) < 0)
+            if ((ret = hls_delete_old_segments(s, hls)) < 0)
                 return ret;
         } else
             av_free(en);
@@ -433,6 +903,7 @@ static int parse_playlist(AVFormatContext *s, const char *url)
     int64_t new_start_pos;
     char line[1024];
     const char *ptr;
+    const char *end;
 
     if ((ret = ffio_open_whitelist(&in, url, AVIO_FLAG_READ,
                                    &s->interrupt_callback, NULL,
@@ -445,13 +916,49 @@ static int parse_playlist(AVFormatContext *s, const char *url)
         goto fail;
     }
 
+    hls->discontinuity = 0;
     while (!avio_feof(in)) {
         read_chomp_line(in, line, sizeof(line));
         if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
-            hls->sequence = atoi(ptr);
+            int64_t tmp_sequence = strtoll(ptr, NULL, 10);
+            if (tmp_sequence < hls->sequence)
+              av_log(hls, AV_LOG_VERBOSE,
+                     "Found playlist sequence number was smaller """
+                     "than specified start sequence number: %"PRId64" < %"PRId64", "
+                     "omitting\n", tmp_sequence, hls->start_sequence);
+            else {
+              av_log(hls, AV_LOG_DEBUG, "Found playlist sequence number: %"PRId64"\n", tmp_sequence);
+              hls->sequence = tmp_sequence;
+            }
+        } else if (av_strstart(line, "#EXT-X-DISCONTINUITY", &ptr)) {
+            is_segment = 1;
+            hls->discontinuity = 1;
         } else if (av_strstart(line, "#EXTINF:", &ptr)) {
             is_segment = 1;
             hls->duration = atof(ptr);
+        } else if (av_stristart(line, "#EXT-X-KEY:", &ptr)) {
+            ptr = av_stristr(line, "URI=\"");
+            if (ptr) {
+                ptr += strlen("URI=\"");
+                end = av_stristr(ptr, ",");
+                if (end) {
+                    av_strlcpy(hls->key_uri, ptr, end - ptr);
+                } else {
+                    av_strlcpy(hls->key_uri, ptr, sizeof(hls->key_uri));
+                }
+            }
+
+            ptr = av_stristr(line, "IV=0x");
+            if (ptr) {
+                ptr += strlen("IV=0x");
+                end = av_stristr(ptr, ",");
+                if (end) {
+                    av_strlcpy(hls->iv_string, ptr, end - ptr);
+                } else {
+                    av_strlcpy(hls->iv_string, ptr, sizeof(hls->iv_string));
+                }
+            }
+
         } else if (av_strstart(line, "#", NULL)) {
             continue;
         } else if (line[0]) {
@@ -484,10 +991,28 @@ static void hls_free_segments(HLSSegment *p)
     }
 }
 
-static void set_http_options(AVDictionary **options, HLSContext *c)
+static void write_m3u8_head_block(HLSContext *hls, AVIOContext *out, int version,
+                                  int target_duration, int64_t sequence)
 {
-    if (c->method)
-        av_dict_set(options, "method", c->method, 0);
+    avio_printf(out, "#EXTM3U\n");
+    avio_printf(out, "#EXT-X-VERSION:%d\n", version);
+    if (hls->allowcache == 0 || hls->allowcache == 1) {
+        avio_printf(out, "#EXT-X-ALLOW-CACHE:%s\n", hls->allowcache == 0 ? "NO" : "YES");
+    }
+    avio_printf(out, "#EXT-X-TARGETDURATION:%d\n", target_duration);
+    avio_printf(out, "#EXT-X-MEDIA-SEQUENCE:%"PRId64"\n", sequence);
+    av_log(hls, AV_LOG_VERBOSE, "EXT-X-MEDIA-SEQUENCE:%"PRId64"\n", sequence);
+}
+
+static void hls_rename_temp_file(AVFormatContext *s, AVFormatContext *oc)
+{
+    size_t len = strlen(oc->filename);
+    char final_filename[sizeof(oc->filename)];
+
+    av_strlcpy(final_filename, oc->filename, len);
+    final_filename[len-4] = '\0';
+    ff_rename(oc->filename, final_filename, s);
+    oc->filename[len-4] = '\0';
 }
 
 static int hls_window(AVFormatContext *s, int last)
@@ -515,41 +1040,37 @@ static int hls_window(AVFormatContext *s, int last)
         sequence = 0;
     }
 
+    if (hls->segment_type == SEGMENT_TYPE_FMP4) {
+        version = 7;
+    }
+
     if (!use_rename && !warned_non_file++)
         av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
 
-    set_http_options(&options, hls);
+    set_http_options(s, &options, hls);
     snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", s->filename);
     if ((ret = s->io_open(s, &out, temp_filename, AVIO_FLAG_WRITE, &options)) < 0)
         goto fail;
 
     for (en = hls->segments; en; en = en->next) {
-        if (target_duration < en->duration)
-            target_duration = ceil(en->duration);
+        if (target_duration <= en->duration)
+            target_duration = get_int_from_double(en->duration);
     }
 
     hls->discontinuity_set = 0;
-    avio_printf(out, "#EXTM3U\n");
-    avio_printf(out, "#EXT-X-VERSION:%d\n", version);
-    if (hls->allowcache == 0 || hls->allowcache == 1) {
-        avio_printf(out, "#EXT-X-ALLOW-CACHE:%s\n", hls->allowcache == 0 ? "NO" : "YES");
-    }
-    avio_printf(out, "#EXT-X-TARGETDURATION:%d\n", target_duration);
-    avio_printf(out, "#EXT-X-MEDIA-SEQUENCE:%"PRId64"\n", sequence);
+    write_m3u8_head_block(hls, out, version, target_duration, sequence);
     if (hls->pl_type == PLAYLIST_TYPE_EVENT) {
         avio_printf(out, "#EXT-X-PLAYLIST-TYPE:EVENT\n");
     } else if (hls->pl_type == PLAYLIST_TYPE_VOD) {
         avio_printf(out, "#EXT-X-PLAYLIST-TYPE:VOD\n");
     }
 
-    av_log(s, AV_LOG_VERBOSE, "EXT-X-MEDIA-SEQUENCE:%"PRId64"\n",
-           sequence);
     if((hls->flags & HLS_DISCONT_START) && sequence==hls->start_sequence && hls->discontinuity_set==0 ){
         avio_printf(out, "#EXT-X-DISCONTINUITY\n");
         hls->discontinuity_set = 1;
     }
     for (en = hls->segments; en; en = en->next) {
-        if (hls->key_info_file && (!key_uri || strcmp(en->key_uri, key_uri) ||
+        if ((hls->encrypt || hls->key_info_file) && (!key_uri || strcmp(en->key_uri, key_uri) ||
                                     av_strcasecmp(en->iv_string, iv_string))) {
             avio_printf(out, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri);
             if (*en->iv_string)
@@ -559,13 +1080,25 @@ static int hls_window(AVFormatContext *s, int last)
             iv_string = en->iv_string;
         }
 
+        if (en->discont) {
+            avio_printf(out, "#EXT-X-DISCONTINUITY\n");
+        }
+
+        if ((hls->segment_type == SEGMENT_TYPE_FMP4) && (en == hls->segments)) {
+            avio_printf(out, "#EXT-X-MAP:URI=\"%s\"", hls->fmp4_init_filename);
+            if (hls->flags & HLS_SINGLE_FILE) {
+                avio_printf(out, ",BYTERANGE=\"%"PRId64"@%"PRId64"\"", en->size, en->pos);
+            }
+            avio_printf(out, "\n");
+        }
         if (hls->flags & HLS_ROUND_DURATIONS)
             avio_printf(out, "#EXTINF:%ld,\n",  lrint(en->duration));
         else
             avio_printf(out, "#EXTINF:%f,\n", en->duration);
         if (byterange_mode)
-             avio_printf(out, "#EXT-X-BYTERANGE:%"PRIi64"@%"PRIi64"\n",
-                         en->size, en->pos);
+            avio_printf(out, "#EXT-X-BYTERANGE:%"PRId64"@%"PRId64"\n",
+                        en->size, en->pos);
+
         if (hls->flags & HLS_PROGRAM_DATE_TIME) {
             time_t tt, wrongsecs;
             int milli;
@@ -601,16 +1134,7 @@ static int hls_window(AVFormatContext *s, int last)
     if( hls->vtt_m3u8_name ) {
         if ((ret = s->io_open(s, &sub_out, hls->vtt_m3u8_name, AVIO_FLAG_WRITE, &options)) < 0)
             goto fail;
-        avio_printf(sub_out, "#EXTM3U\n");
-        avio_printf(sub_out, "#EXT-X-VERSION:%d\n", version);
-        if (hls->allowcache == 0 || hls->allowcache == 1) {
-            avio_printf(sub_out, "#EXT-X-ALLOW-CACHE:%s\n", hls->allowcache == 0 ? "NO" : "YES");
-        }
-        avio_printf(sub_out, "#EXT-X-TARGETDURATION:%d\n", target_duration);
-        avio_printf(sub_out, "#EXT-X-MEDIA-SEQUENCE:%"PRId64"\n", sequence);
-
-        av_log(s, AV_LOG_VERBOSE, "EXT-X-MEDIA-SEQUENCE:%"PRId64"\n",
-               sequence);
+        write_m3u8_head_block(hls, sub_out, version, target_duration, sequence);
 
         for (en = hls->segments; en; en = en->next) {
             avio_printf(sub_out, "#EXTINF:%f,\n", en->duration);
@@ -652,9 +1176,12 @@ static int hls_start(AVFormatContext *s)
             av_strlcpy(vtt_oc->filename, c->vtt_basename,
                   sizeof(vtt_oc->filename));
     } else if (c->max_seg_size > 0) {
-        if (av_get_frame_filename2(oc->filename, sizeof(oc->filename),
-            c->basename, c->wrap ? c->sequence % c->wrap : c->sequence,
-            AV_FRAME_FILENAME_FLAGS_MULTIPLE) < 0) {
+        if (replace_int_data_in_filename(oc->filename, sizeof(oc->filename),
+#if FF_API_HLS_WRAP
+            c->basename, 'd', c->wrap ? c->sequence % c->wrap : c->sequence) < 1) {
+#else
+            c->basename, 'd', c->sequence) < 1) {
+#endif
                 av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s', you can try to use -use_localtime 1 with it\n", c->basename);
                 return AVERROR(EINVAL);
         }
@@ -669,6 +1196,11 @@ static int hls_start(AVFormatContext *s)
                 return AVERROR(EINVAL);
             }
 
+            err = sls_flag_use_localtime_filename(oc, c);
+            if (err < 0) {
+                return AVERROR(ENOMEM);
+            }
+
             if (c->use_localtime_mkdir) {
                 const char *dir;
                 char *fn_copy = av_strdup(oc->filename);
@@ -683,16 +1215,22 @@ static int hls_start(AVFormatContext *s)
                 }
                 av_free(fn_copy);
             }
-        } else if (av_get_frame_filename2(oc->filename, sizeof(oc->filename),
-                                  c->basename, c->wrap ? c->sequence % c->wrap : c->sequence,
-                                  AV_FRAME_FILENAME_FLAGS_MULTIPLE) < 0) {
+        } else if (replace_int_data_in_filename(oc->filename, sizeof(oc->filename),
+#if FF_API_HLS_WRAP
+                   c->basename, 'd', c->wrap ? c->sequence % c->wrap : c->sequence) < 1) {
+#else
+                   c->basename, 'd', c->sequence) < 1) {
+#endif
             av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s' you can try to use -use_localtime 1 with it\n", c->basename);
             return AVERROR(EINVAL);
         }
         if( c->vtt_basename) {
-            if (av_get_frame_filename2(vtt_oc->filename, sizeof(vtt_oc->filename),
-                              c->vtt_basename, c->wrap ? c->sequence % c->wrap : c->sequence,
-                              AV_FRAME_FILENAME_FLAGS_MULTIPLE) < 0) {
+            if (replace_int_data_in_filename(vtt_oc->filename, sizeof(vtt_oc->filename),
+#if FF_API_HLS_WRAP
+                c->vtt_basename, 'd', c->wrap ? c->sequence % c->wrap : c->sequence) < 1) {
+#else
+                c->vtt_basename, 'd', c->sequence) < 1) {
+#endif
                 av_log(vtt_oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", c->vtt_basename);
                 return AVERROR(EINVAL);
             }
@@ -700,11 +1238,27 @@ static int hls_start(AVFormatContext *s)
     }
     c->number++;
 
-    set_http_options(&options, c);
+    set_http_options(s, &options, c);
 
-    if (c->key_info_file) {
-        if ((err = hls_encryption_start(s)) < 0)
-            goto fail;
+    if (c->flags & HLS_TEMP_FILE) {
+        av_strlcat(oc->filename, ".tmp", sizeof(oc->filename));
+    }
+
+    if (c->key_info_file || c->encrypt) {
+        if (c->key_info_file && c->encrypt) {
+            av_log(s, AV_LOG_WARNING, "Cannot use both -hls_key_info_file and -hls_enc,"
+                  " will use -hls_key_info_file priority\n");
+        }
+
+        if (c->number <= 1 || (c->flags & HLS_PERIODIC_REKEY)) {
+            if (c->key_info_file) {
+                if ((err = hls_encryption_start(s)) < 0)
+                    goto fail;
+            } else {
+                if ((err = do_encrypt(s)) < 0)
+                    goto fail;
+            }
+        }
         if ((err = av_dict_set(&options, "encryption_key", c->key_string, 0))
                 < 0)
             goto fail;
@@ -728,21 +1282,25 @@ static int hls_start(AVFormatContext *s)
         if ((err = s->io_open(s, &oc->pb, oc->filename, AVIO_FLAG_WRITE, &options)) < 0)
             goto fail;
     if (c->vtt_basename) {
-        set_http_options(&options, c);
+        set_http_options(s, &options, c);
         if ((err = s->io_open(s, &vtt_oc->pb, vtt_oc->filename, AVIO_FLAG_WRITE, &options)) < 0)
             goto fail;
     }
     av_dict_free(&options);
 
-    /* We only require one PAT/PMT per segment. */
-    if (oc->oformat->priv_class && oc->priv_data) {
-        char period[21];
+    if (c->segment_type == SEGMENT_TYPE_FMP4 && !(c->flags & HLS_SINGLE_FILE)) {
+            write_styp(oc->pb);
+    } else {
+        /* We only require one PAT/PMT per segment. */
+        if (oc->oformat->priv_class && oc->priv_data) {
+            char period[21];
 
-        snprintf(period, sizeof(period), "%d", (INT_MAX / 2) - 1);
+            snprintf(period, sizeof(period), "%d", (INT_MAX / 2) - 1);
 
-        av_opt_set(oc->priv_data, "mpegts_flags", "resend_headers", 0);
-        av_opt_set(oc->priv_data, "sdt_period", period, 0);
-        av_opt_set(oc->priv_data, "pat_period", period, 0);
+            av_opt_set(oc->priv_data, "mpegts_flags", "resend_headers", 0);
+            av_opt_set(oc->priv_data, "sdt_period", period, 0);
+            av_opt_set(oc->priv_data, "pat_period", period, 0);
+        }
     }
 
     if (c->vtt_basename) {
@@ -758,21 +1316,59 @@ static int hls_start(AVFormatContext *s)
     return err;
 }
 
+static const char * get_default_pattern_localtime_fmt(AVFormatContext *s)
+{
+    char b[21];
+    time_t t = time(NULL);
+    struct tm *p, tmbuf;
+    HLSContext *hls = s->priv_data;
+
+    p = localtime_r(&t, &tmbuf);
+    // no %s support when strftime returned error or left format string unchanged
+    // also no %s support on MSVC, which invokes the invalid parameter handler on unsupported format strings, instead of returning an error
+    if (hls->segment_type == SEGMENT_TYPE_FMP4) {
+        return (HAVE_LIBC_MSVCRT || !strftime(b, sizeof(b), "%s", p) || !strcmp(b, "%s")) ? "-%Y%m%d%H%M%S.m4s" : "-%s.m4s";
+    }
+    return (HAVE_LIBC_MSVCRT || !strftime(b, sizeof(b), "%s", p) || !strcmp(b, "%s")) ? "-%Y%m%d%H%M%S.ts" : "-%s.ts";
+}
+
 static int hls_write_header(AVFormatContext *s)
 {
     HLSContext *hls = s->priv_data;
     int ret, i;
-    char *p;
+    char *p = NULL;
     const char *pattern = "%d.ts";
-    const char *pattern_localtime_fmt = "-%s.ts";
+    const char *pattern_localtime_fmt = get_default_pattern_localtime_fmt(s);
     const char *vtt_pattern = "%d.vtt";
     AVDictionary *options = NULL;
-    int basename_size;
-    int vtt_basename_size;
+    int basename_size = 0;
+    int vtt_basename_size = 0;
+    int fmp4_init_filename_len = strlen(hls->fmp4_init_filename) + 1;
+
+    if (hls->segment_type == SEGMENT_TYPE_FMP4) {
+        pattern = "%d.m4s";
+    }
+    if ((hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH) ||
+        (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_FORMATTED_DATETIME)) {
+        time_t t = time(NULL); // we will need it in either case
+        if (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH) {
+            hls->start_sequence = (int64_t)t;
+        } else if (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_FORMATTED_DATETIME) {
+            char b[15];
+            struct tm *p, tmbuf;
+            if (!(p = localtime_r(&t, &tmbuf)))
+                return AVERROR(ENOMEM);
+            if (!strftime(b, sizeof(b), "%Y%m%d%H%M%S", p))
+                return AVERROR(ENOMEM);
+            hls->start_sequence = strtoll(b, NULL, 10);
+        }
+        av_log(hls, AV_LOG_DEBUG, "start_number evaluated to %"PRId64"\n", hls->start_sequence);
+    }
 
     hls->sequence       = hls->start_sequence;
     hls->recording_time = (hls->init_time ? hls->init_time : hls->time) * AV_TIME_BASE;
     hls->start_pts      = AV_NOPTS_VALUE;
+    hls->current_segment_final_filename_fmt[0] = '\0';
 
     if (hls->flags & HLS_PROGRAM_DATE_TIME) {
         time_t now0;
@@ -800,7 +1396,11 @@ static int hls_write_header(AVFormatContext *s)
                "More than a single video stream present, "
                "expect issues decoding it.\n");
 
-    hls->oformat = av_guess_format("mpegts", NULL, NULL);
+    if (hls->segment_type == SEGMENT_TYPE_FMP4) {
+        hls->oformat = av_guess_format("mp4", NULL, NULL);
+    } else {
+        hls->oformat = av_guess_format("mpegts", NULL, NULL);
+    }
 
     if (!hls->oformat) {
         ret = AVERROR_MUXER_NOT_FOUND;
@@ -822,8 +1422,13 @@ static int hls_write_header(AVFormatContext *s)
             goto fail;
         }
     } else {
-        if (hls->flags & HLS_SINGLE_FILE)
-            pattern = ".ts";
+        if (hls->flags & HLS_SINGLE_FILE) {
+            if (hls->segment_type == SEGMENT_TYPE_FMP4) {
+                pattern = ".m4s";
+            } else {
+                pattern = ".ts";
+            }
+        }
 
         if (hls->use_localtime) {
             basename_size = strlen(s->filename) + strlen(pattern_localtime_fmt) + 1;
@@ -848,6 +1453,49 @@ static int hls_write_header(AVFormatContext *s)
         }
     }
 
+    if (hls->segment_type == SEGMENT_TYPE_FMP4) {
+        if (av_strcasecmp(hls->fmp4_init_filename, "init.mp4")) {
+            hls->base_output_dirname = av_malloc(fmp4_init_filename_len);
+            if (!hls->base_output_dirname) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+            av_strlcpy(hls->base_output_dirname, hls->fmp4_init_filename, fmp4_init_filename_len);
+        } else {
+            if (basename_size > 0) {
+                hls->base_output_dirname = av_malloc(basename_size);
+            } else {
+                hls->base_output_dirname = av_malloc(strlen(hls->fmp4_init_filename) + 1);
+            }
+            if (!hls->base_output_dirname) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+
+            if (basename_size > 0) {
+                av_strlcpy(hls->base_output_dirname, s->filename, basename_size);
+                p = strrchr(hls->base_output_dirname, '/');
+            }
+            if (p) {
+                *(p + 1) = '\0';
+                av_strlcat(hls->base_output_dirname, hls->fmp4_init_filename, basename_size);
+            } else {
+                av_strlcpy(hls->base_output_dirname, hls->fmp4_init_filename, fmp4_init_filename_len);
+            }
+        }
+    }
+
+    if (!hls->use_localtime) {
+        ret = sls_flag_check_duration_size_index(hls);
+        if (ret < 0) {
+             goto fail;
+        }
+    } else {
+        ret = sls_flag_check_duration_size(hls);
+        if (ret < 0) {
+             goto fail;
+        }
+    }
     if(hls->has_subtitle) {
 
         if (hls->flags & HLS_SINGLE_FILE)
@@ -877,11 +1525,20 @@ static int hls_write_header(AVFormatContext *s)
         av_strlcat(hls->vtt_basename, vtt_pattern, vtt_basename_size);
     }
 
+    if ((hls->flags & HLS_SINGLE_FILE) && (hls->segment_type == SEGMENT_TYPE_FMP4)) {
+        hls->fmp4_init_filename  = av_strdup(hls->basename);
+        if (!hls->fmp4_init_filename) {
+            ret = AVERROR(ENOMEM);
+            goto fail;
+        }
+    }
+
     if ((ret = hls_mux_init(s)) < 0)
         goto fail;
 
     if (hls->flags & HLS_APPEND_LIST) {
         parse_playlist(s, s->filename);
+        hls->discontinuity = 1;
         if (hls->init_time > 0) {
             av_log(s, AV_LOG_WARNING, "append_list mode does not support hls_init_time,"
                    " hls_init_time value will have no effect\n");
@@ -890,8 +1547,10 @@ static int hls_write_header(AVFormatContext *s)
         }
     }
 
-    if ((ret = hls_start(s)) < 0)
-        goto fail;
+    if (hls->segment_type != SEGMENT_TYPE_FMP4 || hls->flags & HLS_SINGLE_FILE) {
+        if ((ret = hls_start(s)) < 0)
+            goto fail;
+    }
 
     av_dict_copy(&options, hls->format_options, 0);
     ret = avformat_write_header(hls->avf, &options);
@@ -929,8 +1588,10 @@ static int hls_write_header(AVFormatContext *s)
 
     av_dict_free(&options);
     if (ret < 0) {
+        av_freep(&hls->fmp4_init_filename);
         av_freep(&hls->basename);
         av_freep(&hls->vtt_basename);
+        av_freep(&hls->key_basename);
         if (hls->avf)
             avformat_free_context(hls->avf);
         if (hls->vtt_avf)
@@ -947,8 +1608,10 @@ static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
     AVStream *st = s->streams[pkt->stream_index];
     int64_t end_pts = hls->recording_time * hls->number;
     int is_ref_pkt = 1;
-    int ret, can_split = 1;
+    int ret = 0, can_split = 1;
     int stream_index = 0;
+    int range_length = 0;
+    uint8_t *buffer = NULL;
 
     if (hls->sequence - hls->nb_entries > hls->start_sequence && hls->init_time > 0) {
         /* reset end_pts, hls->recording_time at end of the init hls list */
@@ -978,37 +1641,83 @@ static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
     if (pkt->pts == AV_NOPTS_VALUE)
         is_ref_pkt = can_split = 0;
 
-    if (is_ref_pkt)
-        hls->duration = (double)(pkt->pts - hls->end_pts)
-                                   * st->time_base.num / st->time_base.den;
+    if (is_ref_pkt) {
+        if (hls->new_start) {
+            hls->new_start = 0;
+            hls->duration = (double)(pkt->pts - hls->end_pts)
+                                       * st->time_base.num / st->time_base.den;
+            hls->dpp = (double)(pkt->duration) * st->time_base.num / st->time_base.den;
+        } else {
+            if (pkt->duration) {
+                hls->duration += (double)(pkt->duration) * st->time_base.num / st->time_base.den;
+            } else {
+                av_log(s, AV_LOG_WARNING, "pkt->duration = 0, maybe the hls segment duration will not precise\n");
+                hls->duration = (double)(pkt->pts - hls->end_pts) * st->time_base.num / st->time_base.den;
+            }
+        }
 
-    if (can_split && av_compare_ts(pkt->pts - hls->start_pts, st->time_base,
+    }
+    if (hls->packets_written && can_split && av_compare_ts(pkt->pts - hls->start_pts, st->time_base,
                                    end_pts, AV_TIME_BASE_Q) >= 0) {
         int64_t new_start_pos;
-        av_write_frame(oc, NULL); /* Flush any buffered data */
+        char *old_filename = av_strdup(hls->avf->filename);
+        int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
+
+        if (!old_filename) {
+            return AVERROR(ENOMEM);
+        }
+
+        av_write_frame(hls->avf, NULL); /* Flush any buffered data */
 
         new_start_pos = avio_tell(hls->avf->pb);
         hls->size = new_start_pos - hls->start_pos;
-        ret = hls_append_segment(s, hls, hls->duration, hls->start_pos, hls->size);
+
+        if (!byterange_mode) {
+            if (hls->segment_type == SEGMENT_TYPE_FMP4 && !hls->init_range_length) {
+                avio_flush(oc->pb);
+                range_length = avio_close_dyn_buf(oc->pb, &buffer);
+                avio_write(hls->out, buffer, range_length);
+                hls->init_range_length = range_length;
+                avio_open_dyn_buf(&oc->pb);
+                hls->packets_written = 0;
+                ff_format_io_close(s, &hls->out);
+            } else {
+                ff_format_io_close(s, &oc->pb);
+            }
+            if (hls->vtt_avf) {
+                ff_format_io_close(s, &hls->vtt_avf->pb);
+            }
+        }
+        if ((hls->flags & HLS_TEMP_FILE) && oc->filename[0]) {
+            if (!(hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size <= 0))
+                if ((hls->avf->oformat->priv_class && hls->avf->priv_data) && hls->segment_type != SEGMENT_TYPE_FMP4)
+                    av_opt_set(hls->avf->priv_data, "mpegts_flags", "resend_headers", 0);
+            hls_rename_temp_file(s, oc);
+        }
+
+        if (hls->fmp4_init_mode) {
+            hls->number--;
+        }
+
+        if (!hls->fmp4_init_mode || byterange_mode)
+            ret = hls_append_segment(s, hls, hls->duration, hls->start_pos, hls->size);
+
         hls->start_pos = new_start_pos;
-        if (ret < 0)
+        if (ret < 0) {
+            av_free(old_filename);
             return ret;
+        }
 
         hls->end_pts = pkt->pts;
         hls->duration = 0;
 
+        hls->fmp4_init_mode = 0;
         if (hls->flags & HLS_SINGLE_FILE) {
-            if (hls->avf->oformat->priv_class && hls->avf->priv_data)
-                av_opt_set(hls->avf->priv_data, "mpegts_flags", "resend_headers", 0);
             hls->number++;
         } else if (hls->max_seg_size > 0) {
-            if (hls->avf->oformat->priv_class && hls->avf->priv_data)
-                av_opt_set(hls->avf->priv_data, "mpegts_flags", "resend_headers", 0);
             if (hls->start_pos >= hls->max_seg_size) {
                 hls->sequence++;
-                ff_format_io_close(s, &oc->pb);
-                if (hls->vtt_avf)
-                    ff_format_io_close(s, &hls->vtt_avf->pb);
+                sls_flag_file_rename(hls, old_filename);
                 ret = hls_start(s);
                 hls->start_pos = 0;
                 /* When split segment by byte, the duration is short than hls_time,
@@ -1017,25 +1726,22 @@ static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
             }
             hls->number++;
         } else {
-            ff_format_io_close(s, &oc->pb);
-            if (hls->vtt_avf)
-                ff_format_io_close(s, &hls->vtt_avf->pb);
-
+            sls_flag_file_rename(hls, old_filename);
             ret = hls_start(s);
         }
+        av_free(old_filename);
 
-        if (ret < 0)
+        if (ret < 0) {
             return ret;
+        }
 
-        if( st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE )
-            oc = hls->vtt_avf;
-        else
-        oc = hls->avf;
-
-        if ((ret = hls_window(s, 0)) < 0)
-            return ret;
+        if (!hls->fmp4_init_mode || byterange_mode)
+            if ((ret = hls_window(s, 0)) < 0) {
+                return ret;
+            }
     }
 
+    hls->packets_written++;
     ret = ff_write_chained(oc, stream_index, pkt, s, 0);
 
     return ret;
@@ -1046,14 +1752,28 @@ static int hls_write_trailer(struct AVFormatContext *s)
     HLSContext *hls = s->priv_data;
     AVFormatContext *oc = hls->avf;
     AVFormatContext *vtt_oc = hls->vtt_avf;
+    char *old_filename = av_strdup(hls->avf->filename);
+
+    if (!old_filename) {
+        return AVERROR(ENOMEM);
+    }
+
 
     av_write_trailer(oc);
     if (oc->pb) {
         hls->size = avio_tell(hls->avf->pb) - hls->start_pos;
         ff_format_io_close(s, &oc->pb);
-        hls_append_segment(s, hls, hls->duration, hls->start_pos, hls->size);
+
+        if ((hls->flags & HLS_TEMP_FILE) && oc->filename[0]) {
+            hls_rename_temp_file(s, oc);
+        }
+
+        /* after av_write_trailer, then duration + 1 duration per packet */
+        hls_append_segment(s, hls, hls->duration + hls->dpp, hls->start_pos, hls->size);
     }
 
+    sls_flag_file_rename(hls, old_filename);
+
     if (vtt_oc) {
         if (vtt_oc->pb)
             av_write_trailer(vtt_oc);
@@ -1061,11 +1781,14 @@ static int hls_write_trailer(struct AVFormatContext *s)
         ff_format_io_close(s, &vtt_oc->pb);
     }
     av_freep(&hls->basename);
+    av_freep(&hls->base_output_dirname);
+    av_freep(&hls->key_basename);
     avformat_free_context(oc);
 
     hls->avf = NULL;
     hls_window(s, 1);
 
+    av_freep(&hls->fmp4_init_filename);
     if (vtt_oc) {
         av_freep(&hls->vtt_basename);
         av_freep(&hls->vtt_m3u8_name);
@@ -1074,6 +1797,7 @@ static int hls_write_trailer(struct AVFormatContext *s)
 
     hls_free_segments(hls->segments);
     hls_free_segments(hls->old_segments);
+    av_free(old_filename);
     return 0;
 }
 
@@ -1086,15 +1810,26 @@ static const AVOption options[] = {
     {"hls_list_size", "set maximum number of playlist entries",  OFFSET(max_nb_segments),    AV_OPT_TYPE_INT,    {.i64 = 5},     0, INT_MAX, E},
     {"hls_ts_options","set hls mpegts list of options for the container format used for hls", OFFSET(format_options_str), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
     {"hls_vtt_options","set hls vtt list of options for the container format used for hls", OFFSET(vtt_format_options_str), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
-    {"hls_wrap",      "set number after which the index wraps",  OFFSET(wrap),    AV_OPT_TYPE_INT,    {.i64 = 0},     0, INT_MAX, E},
+#if FF_API_HLS_WRAP
+    {"hls_wrap",      "set number after which the index wraps (will be deprecated)",  OFFSET(wrap),    AV_OPT_TYPE_INT,    {.i64 = 0},     0, INT_MAX, E},
+#endif
     {"hls_allow_cache", "explicitly set whether the client MAY (1) or MUST NOT (0) cache media segments", OFFSET(allowcache), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, E},
     {"hls_base_url",  "url to prepend to each playlist entry",   OFFSET(baseurl), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E},
     {"hls_segment_filename", "filename template for segment files", OFFSET(segment_filename),   AV_OPT_TYPE_STRING, {.str = NULL},            0,       0,         E},
     {"hls_segment_size", "maximum size per segment file, (in bytes)",  OFFSET(max_seg_size),    AV_OPT_TYPE_INT,    {.i64 = 0},               0,       INT_MAX,   E},
     {"hls_key_info_file",    "file with key URI and key file path", OFFSET(key_info_file),      AV_OPT_TYPE_STRING, {.str = NULL},            0,       0,         E},
+    {"hls_enc",    "enable AES128 encryption support", OFFSET(encrypt),      AV_OPT_TYPE_BOOL, {.i64 = 0},            0,       1,         E},
+    {"hls_enc_key",    "hex-coded 16 byte key to encrypt the segments", OFFSET(key),      AV_OPT_TYPE_STRING, .flags = E},
+    {"hls_enc_key_url",    "url to access the key to decrypt the segments", OFFSET(key_url),      AV_OPT_TYPE_STRING, {.str = NULL},            0,       0,         E},
+    {"hls_enc_iv",    "hex-coded 16 byte initialization vector", OFFSET(iv),      AV_OPT_TYPE_STRING, .flags = E},
     {"hls_subtitle_path",     "set path of hls subtitles", OFFSET(subtitle_filename), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
+    {"hls_segment_type",     "set hls segment files type", OFFSET(segment_type), AV_OPT_TYPE_INT, {.i64 = SEGMENT_TYPE_MPEGTS }, 0, SEGMENT_TYPE_FMP4, E, "segment_type"},
+    {"mpegts",   "make segment file to mpegts files in m3u8", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_MPEGTS }, 0, UINT_MAX,   E, "segment_type"},
+    {"fmp4",   "make segment file to fragment mp4 files in m3u8", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_FMP4 }, 0, UINT_MAX,   E, "segment_type"},
+    {"hls_fmp4_init_filename", "set fragment mp4 file init filename", OFFSET(fmp4_init_filename),   AV_OPT_TYPE_STRING, {.str = "init.mp4"},            0,       0,         E},
     {"hls_flags",     "set flags affecting HLS playlist and media file generation", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0 }, 0, UINT_MAX, E, "flags"},
     {"single_file",   "generate a single media file indexed with byte ranges", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SINGLE_FILE }, 0, UINT_MAX,   E, "flags"},
+    {"temp_file", "write segment to temporary file and rename when complete", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_TEMP_FILE }, 0, UINT_MAX,   E, "flags"},
     {"delete_segments", "delete segment files that are no longer part of the playlist", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DELETE_SEGMENTS }, 0, UINT_MAX,   E, "flags"},
     {"round_durations", "round durations in m3u8 to whole numbers", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_ROUND_DURATIONS }, 0, UINT_MAX,   E, "flags"},
     {"discont_start", "start the playlist with a discontinuity tag", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DISCONT_START }, 0, UINT_MAX,   E, "flags"},
@@ -1102,13 +1837,21 @@ static const AVOption options[] = {
     {"split_by_time", "split the hls segment by time which user set by hls_time", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SPLIT_BY_TIME }, 0, UINT_MAX,   E, "flags"},
     {"append_list", "append the new segments into old hls segment list", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_APPEND_LIST }, 0, UINT_MAX,   E, "flags"},
     {"program_date_time", "add EXT-X-PROGRAM-DATE-TIME", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PROGRAM_DATE_TIME }, 0, UINT_MAX,   E, "flags"},
+    {"second_level_segment_index", "include segment index in segment filenames when use_localtime", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SECOND_LEVEL_SEGMENT_INDEX }, 0, UINT_MAX,   E, "flags"},
+    {"second_level_segment_duration", "include segment duration in segment filenames when use_localtime", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SECOND_LEVEL_SEGMENT_DURATION }, 0, UINT_MAX,   E, "flags"},
+    {"second_level_segment_size", "include segment size in segment filenames when use_localtime", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SECOND_LEVEL_SEGMENT_SIZE }, 0, UINT_MAX,   E, "flags"},
+    {"periodic_rekey", "reload keyinfo file periodically for re-keying", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PERIODIC_REKEY }, 0, UINT_MAX,   E, "flags"},
     {"use_localtime", "set filename expansion with strftime at segment creation", OFFSET(use_localtime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
     {"use_localtime_mkdir", "create last directory component in strftime-generated filename", OFFSET(use_localtime_mkdir), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
     {"hls_playlist_type", "set the HLS playlist type", OFFSET(pl_type), AV_OPT_TYPE_INT, {.i64 = PLAYLIST_TYPE_NONE }, 0, PLAYLIST_TYPE_NB-1, E, "pl_type" },
     {"event", "EVENT playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_EVENT }, INT_MIN, INT_MAX, E, "pl_type" },
     {"vod", "VOD playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_VOD }, INT_MIN, INT_MAX, E, "pl_type" },
-    {"method", "set the HTTP method", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
-
+    {"method", "set the HTTP method(default: PUT)", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
+    {"hls_start_number_source", "set source of first number in sequence", OFFSET(start_sequence_source_type), AV_OPT_TYPE_INT, {.i64 = HLS_START_SEQUENCE_AS_START_NUMBER }, 0, HLS_START_SEQUENCE_AS_FORMATTED_DATETIME, E, "start_sequence_source_type" },
+    {"generic", "start_number value (default)", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_START_NUMBER }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
+    {"epoch", "seconds since epoch", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
+    {"datetime", "current datetime as YYYYMMDDhhmmss", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_FORMATTED_DATETIME }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
+    {"http_user_agent", "override User-Agent field in HTTP header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
     { NULL },
 };
 
@@ -1128,7 +1871,7 @@ AVOutputFormat ff_hls_muxer = {
     .audio_codec    = AV_CODEC_ID_AAC,
     .video_codec    = AV_CODEC_ID_H264,
     .subtitle_codec = AV_CODEC_ID_WEBVTT,
-    .flags          = AVFMT_NOFILE | AVFMT_ALLOW_FLUSH,
+    .flags          = AVFMT_NOFILE | AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
     .write_header   = hls_write_header,
     .write_packet   = hls_write_packet,
     .write_trailer  = hls_write_trailer,
diff --git a/mythtv/external/FFmpeg/libavformat/http.c b/mythtv/external/FFmpeg/libavformat/http.c
index d48958d8a3c..668cd519866 100644
--- a/mythtv/external/FFmpeg/libavformat/http.c
+++ b/mythtv/external/FFmpeg/libavformat/http.c
@@ -29,6 +29,7 @@
 #include "libavutil/avstring.h"
 #include "libavutil/opt.h"
 #include "libavutil/time.h"
+#include "libavutil/parseutils.h"
 
 #include "avformat.h"
 #include "http.h"
@@ -48,6 +49,8 @@
 #define MAX_REDIRECTS 8
 #define HTTP_SINGLE   1
 #define HTTP_MUTLI    2
+#define MAX_EXPIRY    19
+#define WHITESPACES " \n\t\r"
 typedef enum {
     LOWER_PROTO,
     READ_HEADERS,
@@ -62,8 +65,8 @@ typedef struct HTTPContext {
     int line_count;
     int http_code;
     /* Used if "Transfer-Encoding: chunked" otherwise -1. */
-    int64_t chunksize;
-    int64_t off, end_off, filesize;
+    uint64_t chunksize;
+    uint64_t off, end_off, filesize;
     char *location;
     HTTPAuthState auth_state;
     HTTPAuthState proxy_auth_state;
@@ -95,9 +98,9 @@ typedef struct HTTPContext {
     AVDictionary *cookie_dict;
     int icy;
     /* how much data was read since the last ICY metadata packet */
-    int icy_data_read;
+    uint64_t icy_data_read;
     /* after how many bytes of read data a new metadata packet will be found */
-    int icy_metaint;
+    uint64_t icy_metaint;
     char *icy_metadata_headers;
     char *icy_metadata_packet;
     AVDictionary *metadata;
@@ -489,7 +492,7 @@ static int http_open(URLContext *h, const char *uri, int flags,
     else
         h->is_streamed = 1;
 
-    s->filesize = -1;
+    s->filesize = UINT64_MAX;
     s->location = av_strdup(uri);
     if (!s->location)
         return AVERROR(ENOMEM);
@@ -616,9 +619,9 @@ static void parse_content_range(URLContext *h, const char *p)
 
     if (!strncmp(p, "bytes ", 6)) {
         p     += 6;
-        s->off = strtoll(p, NULL, 10);
+        s->off = strtoull(p, NULL, 10);
         if ((slash = strchr(p, '/')) && strlen(slash) > 0)
-            s->filesize = strtoll(slash + 1, NULL, 10);
+            s->filesize = strtoull(slash + 1, NULL, 10);
     }
     if (s->seekable == -1 && (!s->is_akamai || s->filesize != 2147483647))
         h->is_streamed = 0; /* we _can_ in fact seek */
@@ -680,10 +683,112 @@ static int parse_icy(HTTPContext *s, const char *tag, const char *p)
     return 0;
 }
 
+static int parse_set_cookie_expiry_time(const char *exp_str, struct tm *buf)
+{
+    char exp_buf[MAX_EXPIRY];
+    int i, j, exp_buf_len = MAX_EXPIRY-1;
+    char *expiry;
+
+    // strip off any punctuation or whitespace
+    for (i = 0, j = 0; exp_str[i] != '\0' && j < exp_buf_len; i++) {
+        if ((exp_str[i] >= '0' && exp_str[i] <= '9') ||
+            (exp_str[i] >= 'A' && exp_str[i] <= 'Z') ||
+            (exp_str[i] >= 'a' && exp_str[i] <= 'z')) {
+            exp_buf[j] = exp_str[i];
+            j++;
+        }
+    }
+    exp_buf[j] = '\0';
+    expiry = exp_buf;
+
+    // move the string beyond the day of week
+    while ((*expiry < '0' || *expiry > '9') && *expiry != '\0')
+        expiry++;
+
+    return av_small_strptime(expiry, "%d%b%Y%H%M%S", buf) ? 0 : AVERROR(EINVAL);
+}
+
+static int parse_set_cookie(const char *set_cookie, AVDictionary **dict)
+{
+    char *param, *next_param, *cstr, *back;
+
+    if (!(cstr = av_strdup(set_cookie)))
+        return AVERROR(EINVAL);
+
+    // strip any trailing whitespace
+    back = &cstr[strlen(cstr)-1];
+    while (strchr(WHITESPACES, *back)) {
+        *back='\0';
+        back--;
+    }
+
+    next_param = cstr;
+    while ((param = av_strtok(next_param, ";", &next_param))) {
+        char *name, *value;
+        param += strspn(param, WHITESPACES);
+        if ((name = av_strtok(param, "=", &value))) {
+            if (av_dict_set(dict, name, value, 0) < 0) {
+                av_free(cstr);
+                return -1;
+            }
+        }
+    }
+
+    av_free(cstr);
+    return 0;
+}
+
 static int parse_cookie(HTTPContext *s, const char *p, AVDictionary **cookies)
 {
+    AVDictionary *new_params = NULL;
+    AVDictionaryEntry *e, *cookie_entry;
     char *eql, *name;
 
+    // ensure the cookie is parsable
+    if (parse_set_cookie(p, &new_params))
+        return -1;
+
+    // if there is no cookie value there is nothing to parse
+    cookie_entry = av_dict_get(new_params, "", NULL, AV_DICT_IGNORE_SUFFIX);
+    if (!cookie_entry || !cookie_entry->value) {
+        av_dict_free(&new_params);
+        return -1;
+    }
+
+    // ensure the cookie is not expired or older than an existing value
+    if ((e = av_dict_get(new_params, "expires", NULL, 0)) && e->value) {
+        struct tm new_tm = {0};
+        if (!parse_set_cookie_expiry_time(e->value, &new_tm)) {
+            AVDictionaryEntry *e2;
+
+            // if the cookie has already expired ignore it
+            if (av_timegm(&new_tm) < av_gettime() / 1000000) {
+                av_dict_free(&new_params);
+                return -1;
+            }
+
+            // only replace an older cookie with the same name
+            e2 = av_dict_get(*cookies, cookie_entry->key, NULL, 0);
+            if (e2 && e2->value) {
+                AVDictionary *old_params = NULL;
+                if (!parse_set_cookie(p, &old_params)) {
+                    e2 = av_dict_get(old_params, "expires", NULL, 0);
+                    if (e2 && e2->value) {
+                        struct tm old_tm = {0};
+                        if (!parse_set_cookie_expiry_time(e->value, &old_tm)) {
+                            if (av_timegm(&new_tm) < av_timegm(&old_tm)) {
+                                av_dict_free(&new_params);
+                                av_dict_free(&old_params);
+                                return -1;
+                            }
+                        }
+                    }
+                }
+                av_dict_free(&old_params);
+            }
+        }
+    }
+
     // duplicate the cookie name (dict will dupe the value)
     if (!(eql = strchr(p, '='))) return AVERROR(EINVAL);
     if (!(name = av_strndup(p, eql - p))) return AVERROR(ENOMEM);
@@ -808,8 +913,9 @@ static int process_line(URLContext *h, char *line, int line_count,
             if ((ret = parse_location(s, p)) < 0)
                 return ret;
             *new_location = 1;
-        } else if (!av_strcasecmp(tag, "Content-Length") && s->filesize == -1) {
-            s->filesize = strtoll(p, NULL, 10);
+        } else if (!av_strcasecmp(tag, "Content-Length") &&
+                   s->filesize == UINT64_MAX) {
+            s->filesize = strtoull(p, NULL, 10);
         } else if (!av_strcasecmp(tag, "Content-Range")) {
             parse_content_range(h, p);
         } else if (!av_strcasecmp(tag, "Accept-Ranges") &&
@@ -818,7 +924,7 @@ static int process_line(URLContext *h, char *line, int line_count,
             h->is_streamed = 0;
         } else if (!av_strcasecmp(tag, "Transfer-Encoding") &&
                    !av_strncasecmp(p, "chunked", 7)) {
-            s->filesize  = -1;
+            s->filesize  = UINT64_MAX;
             s->chunksize = 0;
         } else if (!av_strcasecmp(tag, "WWW-Authenticate")) {
             ff_http_auth_handle_header(&s->auth_state, tag, p);
@@ -842,7 +948,7 @@ static int process_line(URLContext *h, char *line, int line_count,
             if (parse_cookie(s, p, &s->cookie_dict))
                 av_log(h, AV_LOG_WARNING, "Unable to parse '%s'\n", p);
         } else if (!av_strcasecmp(tag, "Icy-MetaInt")) {
-            s->icy_metaint = strtoll(p, NULL, 10);
+            s->icy_metaint = strtoull(p, NULL, 10);
         } else if (!av_strncasecmp(tag, "Icy-", 4)) {
             if ((ret = parse_icy(s, tag, p)) < 0)
                 return ret;
@@ -867,7 +973,7 @@ static int get_cookies(HTTPContext *s, char **cookies, const char *path,
     // cookie strings will look like Set-Cookie header field values.  Multiple
     // Set-Cookie fields will result in multiple values delimited by a newline
     int ret = 0;
-    char *next, *cookie, *set_cookies = av_strdup(s->cookies), *cset_cookies = set_cookies;
+    char *cookie, *set_cookies = av_strdup(s->cookies), *next = set_cookies;
 
     if (!set_cookies) return AVERROR(EINVAL);
 
@@ -875,87 +981,81 @@ static int get_cookies(HTTPContext *s, char **cookies, const char *path,
     av_dict_free(&s->cookie_dict);
 
     *cookies = NULL;
-    while ((cookie = av_strtok(set_cookies, "\n", &next))) {
-        int domain_offset = 0;
-        char *param, *next_param, *cdomain = NULL, *cpath = NULL, *cvalue = NULL;
-        set_cookies = NULL;
+    while ((cookie = av_strtok(next, "\n", &next))) {
+        AVDictionary *cookie_params = NULL;
+        AVDictionaryEntry *cookie_entry, *e;
 
         // store the cookie in a dict in case it is updated in the response
         if (parse_cookie(s, cookie, &s->cookie_dict))
             av_log(s, AV_LOG_WARNING, "Unable to parse '%s'\n", cookie);
 
-        while ((param = av_strtok(cookie, "; ", &next_param))) {
-            if (cookie) {
-                // first key-value pair is the actual cookie value
-                cvalue = av_strdup(param);
-                cookie = NULL;
-            } else if (!av_strncasecmp("path=",   param, 5)) {
-                av_free(cpath);
-                cpath = av_strdup(&param[5]);
-            } else if (!av_strncasecmp("domain=", param, 7)) {
-                // if the cookie specifies a sub-domain, skip the leading dot thereby
-                // supporting URLs that point to sub-domains and the master domain
-                int leading_dot = (param[7] == '.');
-                av_free(cdomain);
-                cdomain = av_strdup(&param[7+leading_dot]);
-            } else {
-                // ignore unknown attributes
-            }
+        // continue on to the next cookie if this one cannot be parsed
+        if (parse_set_cookie(cookie, &cookie_params))
+            continue;
+
+        // if the cookie has no value, skip it
+        cookie_entry = av_dict_get(cookie_params, "", NULL, AV_DICT_IGNORE_SUFFIX);
+        if (!cookie_entry || !cookie_entry->value) {
+            av_dict_free(&cookie_params);
+            continue;
         }
-        if (!cdomain)
-            cdomain = av_strdup(domain);
-
-        // ensure all of the necessary values are valid
-        if (!cdomain || !cpath || !cvalue) {
-            av_log(s, AV_LOG_WARNING,
-                   "Invalid cookie found, no value, path or domain specified\n");
-            goto done_cookie;
+
+        // if the cookie has expired, don't add it
+        if ((e = av_dict_get(cookie_params, "expires", NULL, 0)) && e->value) {
+            struct tm tm_buf = {0};
+            if (!parse_set_cookie_expiry_time(e->value, &tm_buf)) {
+                if (av_timegm(&tm_buf) < av_gettime() / 1000000) {
+                    av_dict_free(&cookie_params);
+                    continue;
+                }
+            }
         }
 
-        // check if the request path matches the cookie path
-        if (av_strncasecmp(path, cpath, strlen(cpath)))
-            goto done_cookie;
+        // if no domain in the cookie assume it appied to this request
+        if ((e = av_dict_get(cookie_params, "domain", NULL, 0)) && e->value) {
+            // find the offset comparison is on the min domain (b.com, not a.b.com)
+            int domain_offset = strlen(domain) - strlen(e->value);
+            if (domain_offset < 0) {
+                av_dict_free(&cookie_params);
+                continue;
+            }
 
-        // the domain should be at least the size of our cookie domain
-        domain_offset = strlen(domain) - strlen(cdomain);
-        if (domain_offset < 0)
-            goto done_cookie;
+            // match the cookie domain
+            if (av_strcasecmp(&domain[domain_offset], e->value)) {
+                av_dict_free(&cookie_params);
+                continue;
+            }
+        }
 
-        // match the cookie domain
-        if (av_strcasecmp(&domain[domain_offset], cdomain))
-            goto done_cookie;
+        // ensure this cookie matches the path
+        e = av_dict_get(cookie_params, "path", NULL, 0);
+        if (!e || av_strncasecmp(path, e->value, strlen(e->value))) {
+            av_dict_free(&cookie_params);
+            continue;
+        }
 
         // cookie parameters match, so copy the value
         if (!*cookies) {
-            if (!(*cookies = av_strdup(cvalue))) {
+            if (!(*cookies = av_asprintf("%s=%s", cookie_entry->key, cookie_entry->value))) {
                 ret = AVERROR(ENOMEM);
-                goto done_cookie;
+                break;
             }
         } else {
             char *tmp = *cookies;
-            size_t str_size = strlen(cvalue) + strlen(*cookies) + 3;
+            size_t str_size = strlen(cookie_entry->key) + strlen(cookie_entry->value) + strlen(*cookies) + 4;
             if (!(*cookies = av_malloc(str_size))) {
                 ret = AVERROR(ENOMEM);
-                goto done_cookie;
+                av_free(tmp);
+                break;
             }
-            snprintf(*cookies, str_size, "%s; %s", tmp, cvalue);
+            snprintf(*cookies, str_size, "%s; %s=%s", tmp, cookie_entry->key, cookie_entry->value);
             av_free(tmp);
         }
-
-        done_cookie:
-        av_freep(&cdomain);
-        av_freep(&cpath);
-        av_freep(&cvalue);
-        if (ret < 0) {
-            if (*cookies) av_freep(cookies);
-            av_free(cset_cookies);
-            return ret;
-        }
     }
 
-    av_free(cset_cookies);
+    av_free(set_cookies);
 
-    return 0;
+    return ret;
 }
 
 static inline int has_header(const char *str, const char *header)
@@ -972,7 +1072,7 @@ static int http_read_header(URLContext *h, int *new_location)
     char line[MAX_URL_SIZE];
     int err = 0;
 
-    s->chunksize = -1;
+    s->chunksize = UINT64_MAX;
 
     for (;;) {
         if ((err = http_get_line(s, line, sizeof(line))) < 0)
@@ -1006,10 +1106,11 @@ static int http_connect(URLContext *h, const char *path, const char *local_path,
     int post, err;
     char headers[HTTP_HEADERS_SIZE] = "";
     char *authstr = NULL, *proxyauthstr = NULL;
-    int64_t off = s->off;
+    uint64_t off = s->off;
     int len = 0;
     const char *method;
     int send_expect_100 = 0;
+    int ret;
 
     /* send http header */
     post = h->flags & AVIO_FLAG_WRITE;
@@ -1060,7 +1161,7 @@ static int http_connect(URLContext *h, const char *path, const char *local_path,
     // server supports seeking by analysing the reply headers.
     if (!has_header(s->headers, "\r\nRange: ") && !post && (s->off > 0 || s->end_off || s->seekable == -1)) {
         len += av_strlcatf(headers + len, sizeof(headers) - len,
-                           "Range: bytes=%"PRId64"-", s->off);
+                           "Range: bytes=%"PRIu64"-", s->off);
         if (s->end_off)
             len += av_strlcatf(headers + len, sizeof(headers) - len,
                                "%"PRId64, s->end_off - 1);
@@ -1106,7 +1207,7 @@ static int http_connect(URLContext *h, const char *path, const char *local_path,
     if (s->headers)
         av_strlcpy(headers + len, s->headers, sizeof(headers) - len);
 
-    snprintf(s->buffer, sizeof(s->buffer),
+    ret = snprintf(s->buffer, sizeof(s->buffer),
              "%s %s HTTP/1.1\r\n"
              "%s"
              "%s"
@@ -1122,6 +1223,14 @@ static int http_connect(URLContext *h, const char *path, const char *local_path,
 
     av_log(h, AV_LOG_DEBUG, "request: %s\n", s->buffer);
 
+    if (strlen(headers) + 1 == sizeof(headers) ||
+        ret >= sizeof(s->buffer)) {
+        av_log(h, AV_LOG_ERROR, "overlong headers\n");
+        err = AVERROR(EINVAL);
+        goto done;
+    }
+
+
     if ((err = ffurl_write(s->hd, s->buffer, strlen(s->buffer))) < 0)
         goto done;
 
@@ -1135,10 +1244,13 @@ static int http_connect(URLContext *h, const char *path, const char *local_path,
     s->line_count       = 0;
     s->off              = 0;
     s->icy_data_read    = 0;
-    s->filesize         = -1;
+    s->filesize         = UINT64_MAX;
     s->willclose        = 0;
     s->end_chunked_post = 0;
     s->end_header       = 0;
+#if CONFIG_ZLIB
+    s->compressed       = 0;
+#endif
     if (post && !s->post_data && !send_expect_100) {
         /* Pretend that it did work. We didn't read any header yet, since
          * we've still to send the POST data, but the code calling this
@@ -1167,6 +1279,34 @@ static int http_buf_read(URLContext *h, uint8_t *buf, int size)
 {
     HTTPContext *s = h->priv_data;
     int len;
+
+    if (s->chunksize != UINT64_MAX) {
+        if (!s->chunksize) {
+            char line[32];
+            int err;
+
+            do {
+                if ((err = http_get_line(s, line, sizeof(line))) < 0)
+                    return err;
+            } while (!*line);    /* skip CR LF from last chunk */
+
+            s->chunksize = strtoull(line, NULL, 16);
+
+            av_log(h, AV_LOG_TRACE,
+                   "Chunked encoding data size: %"PRIu64"'\n",
+                    s->chunksize);
+
+            if (!s->chunksize)
+                return 0;
+            else if (s->chunksize == UINT64_MAX) {
+                av_log(h, AV_LOG_ERROR, "Invalid chunk size %"PRIu64"\n",
+                       s->chunksize);
+                return AVERROR(EINVAL);
+            }
+        }
+        size = FFMIN(size, s->chunksize);
+    }
+
     /* read bytes from input buffer first */
     len = s->buf_end - s->buf_ptr;
     if (len > 0) {
@@ -1175,15 +1315,13 @@ static int http_buf_read(URLContext *h, uint8_t *buf, int size)
         memcpy(buf, s->buf_ptr, len);
         s->buf_ptr += len;
     } else {
-        int64_t target_end = s->end_off ? s->end_off : s->filesize;
-        if ((!s->willclose || s->chunksize < 0) &&
-            target_end >= 0 && s->off >= target_end)
+        uint64_t target_end = s->end_off ? s->end_off : s->filesize;
+        if ((!s->willclose || s->chunksize == UINT64_MAX) && s->off >= target_end)
             return AVERROR_EOF;
         len = ffurl_read(s->hd, buf, size);
-        if (!len && (!s->willclose || s->chunksize < 0) &&
-            target_end >= 0 && s->off < target_end) {
+        if (!len && (!s->willclose || s->chunksize == UINT64_MAX) && s->off < target_end) {
             av_log(h, AV_LOG_ERROR,
-                   "Stream ends prematurely at %"PRId64", should be %"PRId64"\n",
+                   "Stream ends prematurely at %"PRIu64", should be %"PRIu64"\n",
                    s->off, target_end
                   );
             return AVERROR(EIO);
@@ -1191,8 +1329,10 @@ static int http_buf_read(URLContext *h, uint8_t *buf, int size)
     }
     if (len > 0) {
         s->off += len;
-        if (s->chunksize > 0)
+        if (s->chunksize > 0 && s->chunksize != UINT64_MAX) {
+            av_assert0(s->chunksize >= len);
             s->chunksize -= len;
+        }
     }
     return len;
 }
@@ -1247,25 +1387,6 @@ static int http_read_stream(URLContext *h, uint8_t *buf, int size)
             return err;
     }
 
-    if (s->chunksize >= 0) {
-        if (!s->chunksize) {
-            char line[32];
-
-                do {
-                    if ((err = http_get_line(s, line, sizeof(line))) < 0)
-                        return err;
-                } while (!*line);    /* skip CR LF from last chunk */
-
-                s->chunksize = strtoll(line, NULL, 16);
-
-                av_log(NULL, AV_LOG_TRACE, "Chunked encoding data size: %"PRId64"'\n",
-                        s->chunksize);
-
-                if (!s->chunksize)
-                    return 0;
-        }
-        size = FFMIN(size, s->chunksize);
-    }
 #if CONFIG_ZLIB
     if (s->compressed)
         return http_buf_read_compressed(h, buf, size);
@@ -1273,17 +1394,17 @@ static int http_read_stream(URLContext *h, uint8_t *buf, int size)
     read_ret = http_buf_read(h, buf, size);
     if (   (read_ret  < 0 && s->reconnect        && (!h->is_streamed || s->reconnect_streamed) && s->filesize > 0 && s->off < s->filesize)
         || (read_ret == 0 && s->reconnect_at_eof && (!h->is_streamed || s->reconnect_streamed))) {
-        int64_t target = h->is_streamed ? 0 : s->off;
+        uint64_t target = h->is_streamed ? 0 : s->off;
 
         if (s->reconnect_delay > s->reconnect_delay_max)
             return AVERROR(EIO);
 
-        av_log(h, AV_LOG_INFO, "Will reconnect at %"PRId64" error=%s.\n", s->off, av_err2str(read_ret));
+        av_log(h, AV_LOG_INFO, "Will reconnect at %"PRIu64" error=%s.\n", s->off, av_err2str(read_ret));
         av_usleep(1000U*1000*s->reconnect_delay);
         s->reconnect_delay = 1 + 2*s->reconnect_delay;
         seek_ret = http_seek_internal(h, target, SEEK_SET, 1);
         if (seek_ret != target) {
-            av_log(h, AV_LOG_ERROR, "Failed to reconnect at %"PRId64".\n", target);
+            av_log(h, AV_LOG_ERROR, "Failed to reconnect at %"PRIu64".\n", target);
             return read_ret;
         }
 
@@ -1338,10 +1459,11 @@ static int store_icy(URLContext *h, int size)
 {
     HTTPContext *s = h->priv_data;
     /* until next metadata packet */
-    int remaining = s->icy_metaint - s->icy_data_read;
+    uint64_t remaining;
 
-    if (remaining < 0)
+    if (s->icy_metaint < s->icy_data_read)
         return AVERROR_INVALIDDATA;
+    remaining = s->icy_metaint - s->icy_data_read;
 
     if (!remaining) {
         /* The metadata packet is variable sized. It has a 1 byte header
@@ -1455,7 +1577,7 @@ static int64_t http_seek_internal(URLContext *h, int64_t off, int whence, int fo
 {
     HTTPContext *s = h->priv_data;
     URLContext *old_hd = s->hd;
-    int64_t old_off = s->off;
+    uint64_t old_off = s->off;
     uint8_t old_buf[BUFFER_SIZE];
     int old_buf_size, ret;
     AVDictionary *options = NULL;
@@ -1466,7 +1588,7 @@ static int64_t http_seek_internal(URLContext *h, int64_t off, int whence, int fo
              ((whence == SEEK_CUR && off == 0) ||
               (whence == SEEK_SET && off == s->off)))
         return s->off;
-    else if ((s->filesize == -1 && whence == SEEK_END))
+    else if ((s->filesize == UINT64_MAX && whence == SEEK_END))
         return AVERROR(ENOSYS);
 
     if (whence == SEEK_CUR)
@@ -1513,6 +1635,12 @@ static int http_get_file_handle(URLContext *h)
     return ffurl_get_file_handle(s->hd);
 }
 
+static int http_get_short_seek(URLContext *h)
+{
+    HTTPContext *s = h->priv_data;
+    return ffurl_get_short_seek(s->hd);
+}
+
 #define HTTP_CLASS(flavor)                          \
 static const AVClass flavor ## _context_class = {   \
     .class_name = # flavor,                         \
@@ -1534,6 +1662,7 @@ const URLProtocol ff_http_protocol = {
     .url_seek            = http_seek,
     .url_close           = http_close,
     .url_get_file_handle = http_get_file_handle,
+    .url_get_short_seek  = http_get_short_seek,
     .url_shutdown        = http_shutdown,
     .priv_data_size      = sizeof(HTTPContext),
     .priv_data_class     = &http_context_class,
@@ -1553,6 +1682,7 @@ const URLProtocol ff_https_protocol = {
     .url_seek            = http_seek,
     .url_close           = http_close,
     .url_get_file_handle = http_get_file_handle,
+    .url_get_short_seek  = http_get_short_seek,
     .url_shutdown        = http_shutdown,
     .priv_data_size      = sizeof(HTTPContext),
     .priv_data_class     = &https_context_class,
@@ -1621,7 +1751,7 @@ static int http_proxy_open(URLContext *h, const char *uri, int flags)
     s->buf_ptr    = s->buffer;
     s->buf_end    = s->buffer;
     s->line_count = 0;
-    s->filesize   = -1;
+    s->filesize   = UINT64_MAX;
     cur_auth_type = s->proxy_auth_state.auth_type;
 
     /* Note: This uses buffering, potentially reading more than the
diff --git a/mythtv/external/FFmpeg/libavformat/icodec.c b/mythtv/external/FFmpeg/libavformat/icodec.c
index 8019a35f443..f33fa1195b9 100644
--- a/mythtv/external/FFmpeg/libavformat/icodec.c
+++ b/mythtv/external/FFmpeg/libavformat/icodec.c
@@ -109,6 +109,10 @@ static int read_header(AVFormatContext *s)
         avio_skip(pb, 5);
 
         ico->images[i].size   = avio_rl32(pb);
+        if (ico->images[i].size <= 0) {
+            av_log(s, AV_LOG_ERROR, "Invalid image size %d\n", ico->images[i].size);
+            return AVERROR_INVALIDDATA;
+        }
         ico->images[i].offset = avio_rl32(pb);
 
         if (avio_seek(pb, ico->images[i].offset, SEEK_SET) < 0)
@@ -174,8 +178,10 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
         bytestream_put_le16(&buf, 0);
         bytestream_put_le32(&buf, 0);
 
-        if ((ret = avio_read(pb, buf, image->size)) < 0)
-            return ret;
+        if ((ret = avio_read(pb, buf, image->size)) != image->size) {
+            av_packet_unref(pkt);
+            return ret < 0 ? ret : AVERROR_INVALIDDATA;
+        }
 
         st->codecpar->bits_per_coded_sample = AV_RL16(buf + 14);
 
@@ -197,6 +203,13 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
     return 0;
 }
 
+static int ico_read_close(AVFormatContext * s)
+{
+    IcoDemuxContext *ico = s->priv_data;
+    av_freep(&ico->images);
+    return 0;
+}
+
 AVInputFormat ff_ico_demuxer = {
     .name           = "ico",
     .long_name      = NULL_IF_CONFIG_SMALL("Microsoft Windows ICO"),
@@ -204,5 +217,6 @@ AVInputFormat ff_ico_demuxer = {
     .read_probe     = probe,
     .read_header    = read_header,
     .read_packet    = read_packet,
+    .read_close     = ico_read_close,
     .flags          = AVFMT_NOTIMESTAMPS,
 };
diff --git a/mythtv/external/FFmpeg/libavformat/icoenc.c b/mythtv/external/FFmpeg/libavformat/icoenc.c
index a7ada19fcd7..e641f7bdc71 100644
--- a/mythtv/external/FFmpeg/libavformat/icoenc.c
+++ b/mythtv/external/FFmpeg/libavformat/icoenc.c
@@ -82,7 +82,7 @@ static int ico_write_header(AVFormatContext *s)
     int ret;
     int i;
 
-    if (!pb->seekable) {
+    if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
         av_log(s, AV_LOG_ERROR, "Output is not seekable\n");
         return AVERROR(EINVAL);
     }
diff --git a/mythtv/external/FFmpeg/libavformat/id3v1.c b/mythtv/external/FFmpeg/libavformat/id3v1.c
index 218ed73f81e..19be42121d3 100644
--- a/mythtv/external/FFmpeg/libavformat/id3v1.c
+++ b/mythtv/external/FFmpeg/libavformat/id3v1.c
@@ -238,7 +238,7 @@ void ff_id3v1_read(AVFormatContext *s)
     uint8_t buf[ID3v1_TAG_SIZE];
     int64_t filesize, position = avio_tell(s->pb);
 
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         /* XXX: change that */
         filesize = avio_size(s->pb);
         if (filesize > 128) {
diff --git a/mythtv/external/FFmpeg/libavformat/id3v2.c b/mythtv/external/FFmpeg/libavformat/id3v2.c
index 9969d7a6ca6..6c216ba7a25 100644
--- a/mythtv/external/FFmpeg/libavformat/id3v2.c
+++ b/mythtv/external/FFmpeg/libavformat/id3v2.c
@@ -102,7 +102,7 @@ const char ff_id3v2_3_tags[][4] = {
     { 0 },
 };
 
-const char *ff_id3v2_picture_types[21] = {
+const char * const ff_id3v2_picture_types[21] = {
     "Other",
     "32x32 pixels 'file icon'",
     "Other file icon",
@@ -670,59 +670,68 @@ static void read_apic(AVFormatContext *s, AVIOContext *pb, int taglen,
     avio_seek(pb, end, SEEK_SET);
 }
 
+static void free_chapter(void *obj)
+{
+    ID3v2ExtraMetaCHAP *chap = obj;
+    av_freep(&chap->element_id);
+    av_dict_free(&chap->meta);
+    av_freep(&chap);
+}
+
 static void read_chapter(AVFormatContext *s, AVIOContext *pb, int len, const char *ttag, ID3v2ExtraMeta **extra_meta, int isv34)
 {
-    AVRational time_base = {1, 1000};
-    uint32_t start, end;
-    AVChapter *chapter;
-    uint8_t *dst = NULL;
     int taglen;
     char tag[5];
+    ID3v2ExtraMeta *new_extra = NULL;
+    ID3v2ExtraMetaCHAP *chap  = NULL;
 
-    if (!s) {
-        /* We should probably just put the chapter data to extra_meta here
-         * and do the AVFormatContext-needing part in a separate
-         * ff_id3v2_parse_apic()-like function. */
-        av_log(NULL, AV_LOG_DEBUG, "No AVFormatContext, skipped ID3 chapter data\n");
-        return;
-    }
+    new_extra = av_mallocz(sizeof(*new_extra));
+    chap      = av_mallocz(sizeof(*chap));
+
+    if (!new_extra || !chap)
+        goto fail;
+
+    if (decode_str(s, pb, 0, &chap->element_id, &len) < 0)
+        goto fail;
 
-    if (decode_str(s, pb, 0, &dst, &len) < 0)
-        return;
     if (len < 16)
-        return;
+        goto fail;
 
-    start = avio_rb32(pb);
-    end   = avio_rb32(pb);
+    chap->start = avio_rb32(pb);
+    chap->end   = avio_rb32(pb);
     avio_skip(pb, 8);
 
-    chapter = avpriv_new_chapter(s, s->nb_chapters + 1, time_base, start, end, dst);
-    if (!chapter) {
-        av_free(dst);
-        return;
-    }
-
     len -= 16;
     while (len > 10) {
         if (avio_read(pb, tag, 4) < 4)
-            goto end;
+            goto fail;
         tag[4] = 0;
         taglen = avio_rb32(pb);
         avio_skip(pb, 2);
         len -= 10;
         if (taglen < 0 || taglen > len)
-            goto end;
+            goto fail;
         if (tag[0] == 'T')
-            read_ttag(s, pb, taglen, &chapter->metadata, tag);
+            read_ttag(s, pb, taglen, &chap->meta, tag);
         else
             avio_skip(pb, taglen);
         len -= taglen;
     }
 
-    ff_metadata_conv(&chapter->metadata, NULL, ff_id3v2_34_metadata_conv);
-    ff_metadata_conv(&chapter->metadata, NULL, ff_id3v2_4_metadata_conv);
-end:
-    av_free(dst);
+    ff_metadata_conv(&chap->meta, NULL, ff_id3v2_34_metadata_conv);
+    ff_metadata_conv(&chap->meta, NULL, ff_id3v2_4_metadata_conv);
+
+    new_extra->tag  = "CHAP";
+    new_extra->data = chap;
+    new_extra->next = *extra_meta;
+    *extra_meta     = new_extra;
+
+    return;
+
+fail:
+    if (chap)
+        free_chapter(chap);
+    av_freep(&new_extra);
 }
 
 static void free_priv(void *obj)
@@ -782,7 +791,7 @@ typedef struct ID3v2EMFunc {
 static const ID3v2EMFunc id3v2_extra_meta_funcs[] = {
     { "GEO", "GEOB", read_geobtag, free_geobtag },
     { "PIC", "APIC", read_apic,    free_apic    },
-    { "CHAP","CHAP", read_chapter, NULL         },
+    { "CHAP","CHAP", read_chapter, free_chapter },
     { "PRIV","PRIV", read_priv,    free_priv    },
     { NULL }
 };
@@ -823,6 +832,7 @@ static void id3v2_parse(AVIOContext *pb, AVDictionary **metadata,
     const ID3v2EMFunc *extra_func = NULL;
     unsigned char *uncompressed_buffer = NULL;
     av_unused int uncompressed_buffer_size = 0;
+    const char *comm_frame;
 
     av_log(s, AV_LOG_DEBUG, "id3v2 ver:%d flags:%02X len:%d\n", version, flags, len);
 
@@ -834,12 +844,14 @@ static void id3v2_parse(AVIOContext *pb, AVDictionary **metadata,
         }
         isv34     = 0;
         taghdrlen = 6;
+        comm_frame = "COM";
         break;
 
     case 3:
     case 4:
         isv34     = 1;
         taghdrlen = 10;
+        comm_frame = "COMM";
         break;
 
     default:
@@ -950,7 +962,7 @@ static void id3v2_parse(AVIOContext *pb, AVDictionary **metadata,
         /* check for text tag or supported special meta tag */
         } else if (tag[0] == 'T' ||
                    !memcmp(tag, "USLT", 4) ||
-                   !memcmp(tag, "COMM", 4) ||
+                   !strcmp(tag, comm_frame) ||
                    (extra_meta &&
                     (extra_func = get_extra_meta_func(tag, isv34)))) {
             pbx = pb;
@@ -1018,7 +1030,7 @@ static void id3v2_parse(AVIOContext *pb, AVDictionary **metadata,
                 read_ttag(s, pbx, tlen, metadata, tag);
             else if (!memcmp(tag, "USLT", 4))
                 read_uslt(s, pbx, tlen, metadata);
-            else if (!memcmp(tag, "COMM", 4))
+            else if (!strcmp(tag, comm_frame))
                 read_comment(s, pbx, tlen, metadata);
             else
                 /* parse special meta tag */
@@ -1069,7 +1081,9 @@ static void id3v2_read_internal(AVIOContext *pb, AVDictionary **metadata,
             break;
         }
 
-        ret = avio_read(pb, buf, ID3v2_HEADER_SIZE);
+        ret = ffio_ensure_seekback(pb, ID3v2_HEADER_SIZE);
+        if (ret >= 0)
+            ret = avio_read(pb, buf, ID3v2_HEADER_SIZE);
         if (ret != ID3v2_HEADER_SIZE) {
             avio_seek(pb, off, SEEK_SET);
             break;
@@ -1159,3 +1173,54 @@ int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)
 
     return 0;
 }
+
+int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta **extra_meta)
+{
+    int ret = 0;
+    ID3v2ExtraMeta *cur;
+    AVRational time_base = {1, 1000};
+    ID3v2ExtraMetaCHAP **chapters = NULL;
+    int num_chapters = 0;
+    int i;
+
+    // since extra_meta is a linked list where elements are prepended,
+    // we need to reverse the order of chapters
+    for (cur = *extra_meta; cur; cur = cur->next) {
+        ID3v2ExtraMetaCHAP *chap;
+
+        if (strcmp(cur->tag, "CHAP"))
+            continue;
+        chap = cur->data;
+
+        if ((ret = av_dynarray_add_nofree(&chapters, &num_chapters, chap)) < 0)
+            goto end;
+    }
+
+    for (i = 0; i < (num_chapters / 2); i++) {
+        ID3v2ExtraMetaCHAP *right;
+        int right_index;
+
+        right_index = (num_chapters - 1) - i;
+        right = chapters[right_index];
+
+        chapters[right_index] = chapters[i];
+        chapters[i] = right;
+    }
+
+    for (i = 0; i < num_chapters; i++) {
+        ID3v2ExtraMetaCHAP *chap;
+        AVChapter *chapter;
+
+        chap = chapters[i];
+        chapter = avpriv_new_chapter(s, i, time_base, chap->start, chap->end, chap->element_id);
+        if (!chapter)
+            continue;
+
+        if ((ret = av_dict_copy(&chapter->metadata, chap->meta, 0)) < 0)
+            goto end;
+    }
+
+end:
+    av_freep(&chapters);
+    return ret;
+}
diff --git a/mythtv/external/FFmpeg/libavformat/id3v2.h b/mythtv/external/FFmpeg/libavformat/id3v2.h
index 9d7bf1c03c1..5e64ead096a 100644
--- a/mythtv/external/FFmpeg/libavformat/id3v2.h
+++ b/mythtv/external/FFmpeg/libavformat/id3v2.h
@@ -79,6 +79,12 @@ typedef struct ID3v2ExtraMetaPRIV {
     uint32_t datasize;
 } ID3v2ExtraMetaPRIV;
 
+typedef struct ID3v2ExtraMetaCHAP {
+    uint8_t *element_id;
+    uint32_t start, end;
+    AVDictionary *meta;
+} ID3v2ExtraMetaCHAP;
+
 /**
  * Detect ID3v2 Header.
  * @param buf   must be ID3v2_HEADER_SIZE byte long
@@ -97,8 +103,6 @@ int ff_id3v2_tag_len(const uint8_t *buf);
 /**
  * Read an ID3v2 tag into specified dictionary and retrieve supported extra metadata.
  *
- * Chapters are not currently read by this variant.
- *
  * @param metadata Parsed metadata is stored here
  * @param extra_meta If not NULL, extra metadata is parsed into a list of
  * ID3v2ExtraMeta structs and *extra_meta points to the head of the list
@@ -106,7 +110,7 @@ int ff_id3v2_tag_len(const uint8_t *buf);
 void ff_id3v2_read_dict(AVIOContext *pb, AVDictionary **metadata, const char *magic, ID3v2ExtraMeta **extra_meta);
 
 /**
- * Read an ID3v2 tag, including supported extra metadata and chapters.
+ * Read an ID3v2 tag, including supported extra metadata.
  *
  * Data is read from and stored to AVFormatContext.
  *
@@ -158,6 +162,11 @@ void ff_id3v2_free_extra_meta(ID3v2ExtraMeta **extra_meta);
  */
 int ff_id3v2_parse_apic(AVFormatContext *s, ID3v2ExtraMeta **extra_meta);
 
+/**
+ * Create chapters for all CHAP tags found in the ID3v2 header.
+ */
+int ff_id3v2_parse_chapters(AVFormatContext *s, ID3v2ExtraMeta **extra_meta);
+
 extern const AVMetadataConv ff_id3v2_34_metadata_conv[];
 extern const AVMetadataConv ff_id3v2_4_metadata_conv[];
 
@@ -180,6 +189,6 @@ extern const char ff_id3v2_3_tags[][4];
 
 extern const CodecMime ff_id3v2_mime_tags[];
 
-extern const char *ff_id3v2_picture_types[21];
+extern const char * const ff_id3v2_picture_types[21];
 
 #endif /* AVFORMAT_ID3V2_H */
diff --git a/mythtv/external/FFmpeg/libavformat/idroqdec.c b/mythtv/external/FFmpeg/libavformat/idroqdec.c
index b66427968f8..8fd67a6818b 100644
--- a/mythtv/external/FFmpeg/libavformat/idroqdec.c
+++ b/mythtv/external/FFmpeg/libavformat/idroqdec.c
@@ -157,6 +157,9 @@ static int roq_read_packet(AVFormatContext *s,
             chunk_size = AV_RL32(&preamble[2]) + RoQ_CHUNK_PREAMBLE_SIZE * 2 +
                 codebook_size;
 
+            if (chunk_size > INT_MAX)
+                return AVERROR_INVALIDDATA;
+
             /* rewind */
             avio_seek(pb, codebook_offset, SEEK_SET);
 
@@ -219,8 +222,10 @@ static int roq_read_packet(AVFormatContext *s,
             pkt->pos= avio_tell(pb);
             ret = avio_read(pb, pkt->data + RoQ_CHUNK_PREAMBLE_SIZE,
                 chunk_size);
-            if (ret != chunk_size)
+            if (ret != chunk_size) {
+                av_packet_unref(pkt);
                 ret = AVERROR(EIO);
+            }
 
             packet_read = 1;
             break;
diff --git a/mythtv/external/FFmpeg/libavformat/iff.c b/mythtv/external/FFmpeg/libavformat/iff.c
index bf441701932..4cf17f6e1a9 100644
--- a/mythtv/external/FFmpeg/libavformat/iff.c
+++ b/mythtv/external/FFmpeg/libavformat/iff.c
@@ -296,8 +296,8 @@ static int parse_dsd_prop(AVFormatContext *s, AVStream *st, uint64_t eof)
             st->codecpar->codec_tag = tag = avio_rl32(pb);
             st->codecpar->codec_id = ff_codec_get_id(dsd_codec_tags, tag);
             if (!st->codecpar->codec_id) {
-                av_log(s, AV_LOG_ERROR, "'%c%c%c%c' compression is not supported\n",
-                    tag&0xFF, (tag>>8)&0xFF, (tag>>16)&0xFF, (tag>>24)&0xFF);
+                av_log(s, AV_LOG_ERROR, "'%s' compression is not supported\n",
+                       av_fourcc2str(tag));
                 return AVERROR_PATCHWELCOME;
             }
             break;
@@ -312,7 +312,8 @@ static int parse_dsd_prop(AVFormatContext *s, AVStream *st, uint64_t eof)
             id3v2_extra_meta = NULL;
             ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, size);
             if (id3v2_extra_meta) {
-                if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0) {
+                if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0 ||
+                    (ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0) {
                     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
                     return ret;
                 }
@@ -748,7 +749,7 @@ static int iff_read_header(AVFormatContext *s)
         }
 
         st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
-        st->codecpar->bit_rate = st->codecpar->channels * st->codecpar->sample_rate * st->codecpar->bits_per_coded_sample;
+        st->codecpar->bit_rate = (int64_t)st->codecpar->channels * st->codecpar->sample_rate * st->codecpar->bits_per_coded_sample;
         st->codecpar->block_align = st->codecpar->channels * st->codecpar->bits_per_coded_sample;
         if (st->codecpar->codec_tag == ID_DSD && st->codecpar->block_align <= 0)
             return AVERROR_INVALIDDATA;
diff --git a/mythtv/external/FFmpeg/libavformat/img2.c b/mythtv/external/FFmpeg/libavformat/img2.c
index f9f53ff558d..8432cc09554 100644
--- a/mythtv/external/FFmpeg/libavformat/img2.c
+++ b/mythtv/external/FFmpeg/libavformat/img2.c
@@ -65,6 +65,8 @@ const IdStrMap ff_img_tags[] = {
     { AV_CODEC_ID_SUNRAST,    "im24"     },
     { AV_CODEC_ID_SUNRAST,    "im32"     },
     { AV_CODEC_ID_SUNRAST,    "sunras"   },
+    { AV_CODEC_ID_SVG,        "svg"      },
+    { AV_CODEC_ID_SVG,        "svgz"     },
     { AV_CODEC_ID_JPEG2000,   "j2c"      },
     { AV_CODEC_ID_JPEG2000,   "jp2"      },
     { AV_CODEC_ID_JPEG2000,   "jpc"      },
@@ -75,6 +77,7 @@ const IdStrMap ff_img_tags[] = {
     { AV_CODEC_ID_V210X,      "yuv10"    },
     { AV_CODEC_ID_WEBP,       "webp"     },
     { AV_CODEC_ID_XBM,        "xbm"      },
+    { AV_CODEC_ID_XPM,        "xpm"      },
     { AV_CODEC_ID_XFACE,      "xface"    },
     { AV_CODEC_ID_XWD,        "xwd"      },
     { AV_CODEC_ID_NONE,       NULL       }
diff --git a/mythtv/external/FFmpeg/libavformat/img2dec.c b/mythtv/external/FFmpeg/libavformat/img2dec.c
index a920f4611f4..ecf64eaffae 100644
--- a/mythtv/external/FFmpeg/libavformat/img2dec.c
+++ b/mythtv/external/FFmpeg/libavformat/img2dec.c
@@ -34,6 +34,7 @@
 #include "internal.h"
 #include "img2.h"
 #include "libavcodec/mjpeg.h"
+#include "subtitles.h"
 
 #if HAVE_GLOB
 /* Locally define as 0 (bitwise-OR no-op) any missing glob options that
@@ -755,6 +756,8 @@ static int jpeg_probe(AVProbeData *p)
 
     if (state == EOI)
         return AVPROBE_SCORE_EXTENSION + 1;
+    if (state == SOS)
+        return AVPROBE_SCORE_EXTENSION / 2;
     return AVPROBE_SCORE_EXTENSION / 8;
 }
 
@@ -822,6 +825,34 @@ static int png_probe(AVProbeData *p)
     return 0;
 }
 
+static int psd_probe(AVProbeData *p)
+{
+    const uint8_t *b = p->buf;
+    int ret = 0;
+    uint16_t color_mode;
+
+    if (AV_RL32(b) == MKTAG('8','B','P','S')) {
+        ret += 1;
+    } else {
+        return 0;
+    }
+
+    if ((b[4] == 0) && (b[5] == 1)) {/* version 1 is PSD, version 2 is PSB */
+        ret += 1;
+    } else {
+        return 0;
+    }
+
+    if ((AV_RL32(b+6) == 0) && (AV_RL16(b+10) == 0))/* reserved must be 0 */
+        ret += 1;
+
+    color_mode = AV_RB16(b+24);
+    if ((color_mode <= 9) && (color_mode != 5) && (color_mode != 6))
+        ret += 1;
+
+    return AVPROBE_SCORE_EXTENSION + ret;
+}
+
 static int sgi_probe(AVProbeData *p)
 {
     const uint8_t *b = p->buf;
@@ -843,6 +874,22 @@ static int sunrast_probe(AVProbeData *p)
     return 0;
 }
 
+static int svg_probe(AVProbeData *p)
+{
+    const uint8_t *b = p->buf;
+    const uint8_t *end = p->buf + p->buf_size;
+    if (memcmp(p->buf, "<?xml", 5))
+        return 0;
+    while (b < end) {
+        b += ff_subtitles_next_line(b);
+        if (b >= end - 4)
+            return 0;
+        if (!memcmp(b, "<svg", 4))
+            return AVPROBE_SCORE_EXTENSION + 1;
+    }
+    return 0;
+}
+
 static int tiff_probe(AVProbeData *p)
 {
     const uint8_t *b = p->buf;
@@ -913,6 +960,15 @@ static int pam_probe(AVProbeData *p)
     return pnm_magic_check(p, 7) ? pnm_probe(p) : 0;
 }
 
+static int xpm_probe(AVProbeData *p)
+{
+    const uint8_t *b = p->buf;
+
+    if (AV_RB64(b) == 0x2f2a2058504d202a && *(b+8) == '/')
+        return AVPROBE_SCORE_MAX - 1;
+    return 0;
+}
+
 #define IMAGEAUTO_DEMUXER(imgname, codecid)\
 static const AVClass imgname ## _class = {\
     .class_name = AV_STRINGIFY(imgname) " demuxer",\
@@ -947,8 +1003,11 @@ IMAGEAUTO_DEMUXER(pgmyuv,  AV_CODEC_ID_PGMYUV)
 IMAGEAUTO_DEMUXER(pictor,  AV_CODEC_ID_PICTOR)
 IMAGEAUTO_DEMUXER(png,     AV_CODEC_ID_PNG)
 IMAGEAUTO_DEMUXER(ppm,     AV_CODEC_ID_PPM)
+IMAGEAUTO_DEMUXER(psd,     AV_CODEC_ID_PSD)
 IMAGEAUTO_DEMUXER(qdraw,   AV_CODEC_ID_QDRAW)
 IMAGEAUTO_DEMUXER(sgi,     AV_CODEC_ID_SGI)
 IMAGEAUTO_DEMUXER(sunrast, AV_CODEC_ID_SUNRAST)
+IMAGEAUTO_DEMUXER(svg,     AV_CODEC_ID_SVG)
 IMAGEAUTO_DEMUXER(tiff,    AV_CODEC_ID_TIFF)
 IMAGEAUTO_DEMUXER(webp,    AV_CODEC_ID_WEBP)
+IMAGEAUTO_DEMUXER(xpm,     AV_CODEC_ID_XPM)
diff --git a/mythtv/external/FFmpeg/libavformat/img2enc.c b/mythtv/external/FFmpeg/libavformat/img2enc.c
index 1297b1aaba5..d793807b33c 100644
--- a/mythtv/external/FFmpeg/libavformat/img2enc.c
+++ b/mythtv/external/FFmpeg/libavformat/img2enc.c
@@ -62,6 +62,8 @@ static int write_header(AVFormatContext *s)
 
     if (st->codecpar->codec_id == AV_CODEC_ID_GIF) {
         img->muxer = "gif";
+    } else if (st->codecpar->codec_id == AV_CODEC_ID_FITS) {
+        img->muxer = "fits";
     } else if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
         const char *str = strrchr(img->path, '.');
         img->split_planes =     str
@@ -159,8 +161,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
         st->id = pkt->stream_index;
 
         fmt->pb = pb[0];
-        if ((ret = av_copy_packet(&pkt2, pkt))                            < 0 ||
-            (ret = av_dup_packet(&pkt2))                                  < 0 ||
+        if ((ret = av_packet_ref(&pkt2, pkt))                             < 0 ||
             (ret = avcodec_parameters_copy(st->codecpar, s->streams[0]->codecpar)) < 0 ||
             (ret = avformat_write_header(fmt, NULL))                      < 0 ||
             (ret = av_interleaved_write_frame(fmt, &pkt2))                < 0 ||
diff --git a/mythtv/external/FFmpeg/libavformat/internal.h b/mythtv/external/FFmpeg/libavformat/internal.h
index da64c641a71..d136c79bdd4 100644
--- a/mythtv/external/FFmpeg/libavformat/internal.h
+++ b/mythtv/external/FFmpeg/libavformat/internal.h
@@ -140,6 +140,16 @@ struct AVFormatInternal {
      * Whether or not avformat_init_output fully initialized streams
      */
     int streams_initialized;
+
+    /**
+     * ID3v2 tag useful for MP3 demuxing
+     */
+    AVDictionary *id3v2_meta;
+
+    /*
+     * Prefer the codec framerate for avg_frame_rate computation.
+     */
+    int prefer_codec_framerate;
 };
 
 struct AVStreamInternal {
@@ -173,6 +183,15 @@ struct AVStreamInternal {
 
     enum AVCodecID orig_codec_id;
 
+    /* the context for extracting extradata in find_stream_info()
+     * inited=1/bsf=NULL signals that extracting is not possible (codec not
+     * supported) */
+    struct {
+        AVBSFContext *bsf;
+        AVPacket     *pkt;
+        int inited;
+    } extract_extradata;
+
     /**
      * Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
      */
@@ -657,14 +676,13 @@ int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf
 
 /**
  * Find the next packet in the interleaving queue for the given stream.
- * The packet is not removed from the interleaving queue, but only
- * a pointer to it is returned.
- *
- * @param ts_offset the ts difference between packet in the queue and the muxer.
+ * The pkt parameter is filled in with the queued packet, including
+ * references to the data (which the caller is not allowed to keep or
+ * modify).
  *
- * @return a pointer to the next packet, or NULL if no packet is queued
- *         for this stream.
+ * @return 0 if a packet was found, a negative value if no packet was found
  */
-const AVPacket *ff_interleaved_peek(AVFormatContext *s, int stream, int64_t *ts_offset);
+int ff_interleaved_peek(AVFormatContext *s, int stream,
+                        AVPacket *pkt, int add_offset);
 
 #endif /* AVFORMAT_INTERNAL_H */
diff --git a/mythtv/external/FFmpeg/libavformat/ipmovie.c b/mythtv/external/FFmpeg/libavformat/ipmovie.c
index f9ab3e0d57e..7f5a8c62ef6 100644
--- a/mythtv/external/FFmpeg/libavformat/ipmovie.c
+++ b/mythtv/external/FFmpeg/libavformat/ipmovie.c
@@ -58,7 +58,7 @@
 #define OPCODE_INIT_AUDIO_BUFFERS      0x03
 #define OPCODE_START_STOP_AUDIO        0x04
 #define OPCODE_INIT_VIDEO_BUFFERS      0x05
-#define OPCODE_UNKNOWN_06              0x06
+#define OPCODE_VIDEO_DATA_06           0x06
 #define OPCODE_SEND_BUFFER             0x07
 #define OPCODE_AUDIO_FRAME             0x08
 #define OPCODE_SILENCE_FRAME           0x09
@@ -66,10 +66,10 @@
 #define OPCODE_CREATE_GRADIENT         0x0B
 #define OPCODE_SET_PALETTE             0x0C
 #define OPCODE_SET_PALETTE_COMPRESSED  0x0D
-#define OPCODE_UNKNOWN_0E              0x0E
+#define OPCODE_SET_SKIP_MAP            0x0E
 #define OPCODE_SET_DECODING_MAP        0x0F
-#define OPCODE_UNKNOWN_10              0x10
-#define OPCODE_VIDEO_DATA              0x11
+#define OPCODE_VIDEO_DATA_10           0x10
+#define OPCODE_VIDEO_DATA_11           0x11
 #define OPCODE_UNKNOWN_12              0x12
 #define OPCODE_UNKNOWN_13              0x13
 #define OPCODE_UNKNOWN_14              0x14
@@ -91,6 +91,8 @@ typedef struct IPMVEContext {
     uint32_t     palette[256];
     int          has_palette;
     int          changed;
+    uint8_t      send_buffer;
+    uint8_t      frame_format;
 
     unsigned int audio_bits;
     unsigned int audio_channels;
@@ -105,6 +107,8 @@ typedef struct IPMVEContext {
     int audio_chunk_size;
     int64_t video_chunk_offset;
     int video_chunk_size;
+    int64_t skip_map_chunk_offset;
+    int skip_map_chunk_size;
     int64_t decode_map_chunk_offset;
     int decode_map_chunk_size;
 
@@ -152,11 +156,11 @@ static int load_ipmovie_packet(IPMVEContext *s, AVIOContext *pb,
 
         chunk_type = CHUNK_VIDEO;
 
-    } else if (s->decode_map_chunk_offset) {
+    } else if (s->frame_format) {
 
-        /* send both the decode map and the video data together */
+        /* send the frame format, decode map, the video data, skip map, and the send_buffer flag together */
 
-        if (av_new_packet(pkt, 2 + s->decode_map_chunk_size + s->video_chunk_size))
+        if (av_new_packet(pkt, 8 + s->decode_map_chunk_size + s->video_chunk_size + s->skip_map_chunk_size))
             return CHUNK_NOMEM;
 
         if (s->has_palette) {
@@ -174,26 +178,54 @@ static int load_ipmovie_packet(IPMVEContext *s, AVIOContext *pb,
             ff_add_param_change(pkt, 0, 0, 0, s->video_width, s->video_height);
             s->changed = 0;
         }
-        pkt->pos= s->decode_map_chunk_offset;
-        avio_seek(pb, s->decode_map_chunk_offset, SEEK_SET);
-        s->decode_map_chunk_offset = 0;
 
-        AV_WL16(pkt->data, s->decode_map_chunk_size);
-        if (avio_read(pb, pkt->data + 2, s->decode_map_chunk_size) !=
-            s->decode_map_chunk_size) {
-            av_packet_unref(pkt);
-            return CHUNK_EOF;
-        }
+        AV_WL8(pkt->data, s->frame_format);
+        AV_WL8(pkt->data + 1, s->send_buffer);
+        AV_WL16(pkt->data + 2, s->video_chunk_size);
+        AV_WL16(pkt->data + 4, s->decode_map_chunk_size);
+        AV_WL16(pkt->data + 6, s->skip_map_chunk_size);
+
+        s->frame_format = 0;
+        s->send_buffer = 0;
 
+        pkt->pos = s->video_chunk_offset;
         avio_seek(pb, s->video_chunk_offset, SEEK_SET);
         s->video_chunk_offset = 0;
 
-        if (avio_read(pb, pkt->data + 2 + s->decode_map_chunk_size,
-            s->video_chunk_size) != s->video_chunk_size) {
+        if (avio_read(pb, pkt->data + 8, s->video_chunk_size) !=
+            s->video_chunk_size) {
             av_packet_unref(pkt);
             return CHUNK_EOF;
         }
 
+        if (s->decode_map_chunk_size) {
+            pkt->pos = s->decode_map_chunk_offset;
+            avio_seek(pb, s->decode_map_chunk_offset, SEEK_SET);
+            s->decode_map_chunk_offset = 0;
+
+            if (avio_read(pb, pkt->data + 8 + s->video_chunk_size,
+                s->decode_map_chunk_size) != s->decode_map_chunk_size) {
+                av_packet_unref(pkt);
+                return CHUNK_EOF;
+            }
+        }
+
+        if (s->skip_map_chunk_size) {
+            pkt->pos = s->skip_map_chunk_offset;
+            avio_seek(pb, s->skip_map_chunk_offset, SEEK_SET);
+            s->skip_map_chunk_offset = 0;
+
+            if (avio_read(pb, pkt->data + 8 + s->video_chunk_size + s->decode_map_chunk_size,
+                s->skip_map_chunk_size) != s->skip_map_chunk_size) {
+                av_packet_unref(pkt);
+                return CHUNK_EOF;
+            }
+        }
+
+        s->video_chunk_size = 0;
+        s->decode_map_chunk_size = 0;
+        s->skip_map_chunk_size = 0;
+
         pkt->stream_index = s->video_stream_index;
         pkt->pts = s->video_pts;
 
@@ -358,9 +390,6 @@ static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,
                 break;
             }
             s->frame_pts_inc = ((uint64_t)AV_RL32(&scratch[0])) * AV_RL16(&scratch[4]);
-            av_log(s->avf, AV_LOG_TRACE, "  %.2f frames/second (timer div = %d, subdiv = %d)\n",
-                    1000000.0 / s->frame_pts_inc, AV_RL32(&scratch[0]),
-                    AV_RL16(&scratch[4]));
             break;
 
         case OPCODE_INIT_AUDIO_BUFFERS:
@@ -433,9 +462,6 @@ static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,
                     s->video_width, s->video_height);
             break;
 
-        case OPCODE_UNKNOWN_06:
-        case OPCODE_UNKNOWN_0E:
-        case OPCODE_UNKNOWN_10:
         case OPCODE_UNKNOWN_12:
         case OPCODE_UNKNOWN_13:
         case OPCODE_UNKNOWN_14:
@@ -447,6 +473,7 @@ static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,
         case OPCODE_SEND_BUFFER:
             av_log(s->avf, AV_LOG_TRACE, "send buffer\n");
             avio_skip(pb, opcode_size);
+            s->send_buffer = 1;
             break;
 
         case OPCODE_AUDIO_FRAME:
@@ -516,6 +543,15 @@ static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,
             avio_skip(pb, opcode_size);
             break;
 
+        case OPCODE_SET_SKIP_MAP:
+            av_log(s->avf, AV_LOG_TRACE, "set skip map\n");
+
+            /* log position and move on for now */
+            s->skip_map_chunk_offset = avio_tell(pb);
+            s->skip_map_chunk_size = opcode_size;
+            avio_skip(pb, opcode_size);
+            break;
+
         case OPCODE_SET_DECODING_MAP:
             av_log(s->avf, AV_LOG_TRACE, "set decoding map\n");
 
@@ -525,8 +561,29 @@ static int process_ipmovie_chunk(IPMVEContext *s, AVIOContext *pb,
             avio_skip(pb, opcode_size);
             break;
 
-        case OPCODE_VIDEO_DATA:
-            av_log(s->avf, AV_LOG_TRACE, "set video data\n");
+        case OPCODE_VIDEO_DATA_06:
+            av_log(s->avf, AV_LOG_TRACE, "set video data format 0x06\n");
+            s->frame_format = 0x06;
+
+            /* log position and move on for now */
+            s->video_chunk_offset = avio_tell(pb);
+            s->video_chunk_size = opcode_size;
+            avio_skip(pb, opcode_size);
+            break;
+
+        case OPCODE_VIDEO_DATA_10:
+            av_log(s->avf, AV_LOG_TRACE, "set video data format 0x10\n");
+            s->frame_format = 0x10;
+
+            /* log position and move on for now */
+            s->video_chunk_offset = avio_tell(pb);
+            s->video_chunk_size = opcode_size;
+            avio_skip(pb, opcode_size);
+            break;
+
+        case OPCODE_VIDEO_DATA_11:
+            av_log(s->avf, AV_LOG_TRACE, "set video data format 0x11\n");
+            s->frame_format = 0x11;
 
             /* log position and move on for now */
             s->video_chunk_offset = avio_tell(pb);
@@ -592,7 +649,10 @@ static int ipmovie_read_header(AVFormatContext *s)
     /* initialize private context members */
     ipmovie->video_pts = ipmovie->audio_frame_count = 0;
     ipmovie->audio_chunk_offset = ipmovie->video_chunk_offset =
-    ipmovie->decode_map_chunk_offset = 0;
+    ipmovie->decode_map_chunk_offset = ipmovie->skip_map_chunk_offset = 0;
+    ipmovie->decode_map_chunk_size = ipmovie->video_chunk_size =
+    ipmovie->skip_map_chunk_size = 0;
+    ipmovie->send_buffer = ipmovie->frame_format = 0;
 
     /* on the first read, this will position the stream at the first chunk */
     ipmovie->next_chunk_offset = avio_tell(pb) + 4;
@@ -653,6 +713,8 @@ static int ipmovie_read_packet(AVFormatContext *s,
         ret = AVERROR(EIO);
     else if (ret == CHUNK_NOMEM)
         ret = AVERROR(ENOMEM);
+    else if (ret == CHUNK_END || ret == CHUNK_SHUTDOWN)
+        ret = AVERROR_EOF;
     else if (ret == CHUNK_VIDEO)
         ret = 0;
     else if (ret == CHUNK_INIT_VIDEO || ret == CHUNK_INIT_AUDIO)
diff --git a/mythtv/external/FFmpeg/libavformat/ircamdec.c b/mythtv/external/FFmpeg/libavformat/ircamdec.c
index 59f3a494113..d376ffef63f 100644
--- a/mythtv/external/FFmpeg/libavformat/ircamdec.c
+++ b/mythtv/external/FFmpeg/libavformat/ircamdec.c
@@ -20,6 +20,7 @@
  */
 
 #include "libavutil/intreadwrite.h"
+#include "libavcodec/internal.h"
 #include "avformat.h"
 #include "internal.h"
 #include "pcm.h"
@@ -87,11 +88,13 @@ static int ircam_read_header(AVFormatContext *s)
 
     st->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;
     st->codecpar->channels    = channels;
+    if (st->codecpar->channels > FF_SANE_NB_CHANNELS)
+        return AVERROR(ENOSYS);
     st->codecpar->sample_rate = sample_rate;
 
     st->codecpar->codec_id = ff_codec_get_id(tags, tag);
     if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
-        av_log(s, AV_LOG_ERROR, "unknown tag %X\n", tag);
+        av_log(s, AV_LOG_ERROR, "unknown tag %"PRIx32"\n", tag);
         return AVERROR_INVALIDDATA;
     }
 
diff --git a/mythtv/external/FFmpeg/libavformat/isom.c b/mythtv/external/FFmpeg/libavformat/isom.c
index ab79e226e5d..77983c5eaab 100644
--- a/mythtv/external/FFmpeg/libavformat/isom.c
+++ b/mythtv/external/FFmpeg/libavformat/isom.c
@@ -59,8 +59,11 @@ const AVCodecTag ff_mp4_obj_type[] = {
     { AV_CODEC_ID_AC3         , 0xA5 },
     { AV_CODEC_ID_EAC3        , 0xA6 },
     { AV_CODEC_ID_DTS         , 0xA9 }, /* mp4ra.org */
-    { AV_CODEC_ID_VP9         , 0xC0 }, /* nonstandard, update when there is a standard value */
+    { AV_CODEC_ID_OPUS        , 0xAD }, /* mp4ra.org */
+    { AV_CODEC_ID_VP9         , 0xB1 }, /* mp4ra.org */
+    { AV_CODEC_ID_FLAC        , 0xC1 }, /* nonstandard, update when there is a standard value */
     { AV_CODEC_ID_TSCC2       , 0xD0 }, /* nonstandard, camtasia uses it */
+    { AV_CODEC_ID_EVRC        , 0xD1 }, /* nonstandard, pvAuthor uses it */
     { AV_CODEC_ID_VORBIS      , 0xDD }, /* nonstandard, gpac uses it */
     { AV_CODEC_ID_DVD_SUBTITLE, 0xE0 }, /* nonstandard, see unsupported-embedded-subs-2.mp4 */
     { AV_CODEC_ID_QCELP       , 0xE1 },
@@ -180,6 +183,8 @@ const AVCodecTag ff_codec_movvideo_tags[] = {
     { AV_CODEC_ID_H264, MKTAG('A', 'V', 'i', 'n') }, /* AVC-Intra with implicit SPS/PPS */
     { AV_CODEC_ID_H264, MKTAG('a', 'i', 'v', 'x') }, /* XAVC 10-bit 4:2:2 */
     { AV_CODEC_ID_H264, MKTAG('r', 'v', '6', '4') }, /* X-Com Radvision */
+    { AV_CODEC_ID_H264, MKTAG('x', 'a', 'l', 'g') }, /* XAVC-L HD422 produced by FCP */
+    { AV_CODEC_ID_H264, MKTAG('a', 'v', 'l', 'g') }, /* Panasonic P2 AVC-LongG */
 
     { AV_CODEC_ID_VP9,  MKTAG('v', 'p', '0', '9') }, /* VP9 */
 
@@ -269,10 +274,16 @@ const AVCodecTag ff_codec_movvideo_tags[] = {
     { AV_CODEC_ID_HAP, MKTAG('H', 'a', 'p', '1') },
     { AV_CODEC_ID_HAP, MKTAG('H', 'a', 'p', '5') },
     { AV_CODEC_ID_HAP, MKTAG('H', 'a', 'p', 'Y') },
+    { AV_CODEC_ID_HAP, MKTAG('H', 'a', 'p', 'A') },
+    { AV_CODEC_ID_HAP, MKTAG('H', 'a', 'p', 'M') },
 
     { AV_CODEC_ID_DXV, MKTAG('D', 'X', 'D', '3') },
     { AV_CODEC_ID_DXV, MKTAG('D', 'X', 'D', 'I') },
 
+    { AV_CODEC_ID_MAGICYUV, MKTAG('M', '0', 'R', '0') },
+    { AV_CODEC_ID_MAGICYUV, MKTAG('M', '0', 'R', 'A') },
+    { AV_CODEC_ID_MAGICYUV, MKTAG('M', '0', 'R', 'G') },
+    { AV_CODEC_ID_MAGICYUV, MKTAG('M', '0', 'Y', '2') },
     { AV_CODEC_ID_MAGICYUV, MKTAG('M', '8', 'R', 'G') },
     { AV_CODEC_ID_MAGICYUV, MKTAG('M', '8', 'R', 'A') },
     { AV_CODEC_ID_MAGICYUV, MKTAG('M', '8', 'G', '0') },
@@ -280,6 +291,8 @@ const AVCodecTag ff_codec_movvideo_tags[] = {
     { AV_CODEC_ID_MAGICYUV, MKTAG('M', '8', 'Y', '2') },
     { AV_CODEC_ID_MAGICYUV, MKTAG('M', '8', 'Y', '4') },
     { AV_CODEC_ID_MAGICYUV, MKTAG('M', '8', 'Y', 'A') },
+    { AV_CODEC_ID_MAGICYUV, MKTAG('M', '2', 'R', 'A') },
+    { AV_CODEC_ID_MAGICYUV, MKTAG('M', '2', 'R', 'G') },
 
     { AV_CODEC_ID_SHEERVIDEO, MKTAG('S', 'h', 'r', '0') },
     { AV_CODEC_ID_SHEERVIDEO, MKTAG('S', 'h', 'r', '1') },
@@ -290,6 +303,8 @@ const AVCodecTag ff_codec_movvideo_tags[] = {
     { AV_CODEC_ID_SHEERVIDEO, MKTAG('S', 'h', 'r', '6') },
     { AV_CODEC_ID_SHEERVIDEO, MKTAG('S', 'h', 'r', '7') },
 
+    { AV_CODEC_ID_PIXLET, MKTAG('p', 'x', 'l', 't') },
+
     { AV_CODEC_ID_NONE, 0 },
 };
 
@@ -304,6 +319,7 @@ const AVCodecTag ff_codec_movaudio_tags[] = {
     { AV_CODEC_ID_DTS,             MKTAG('d', 't', 's', 'c') }, /* DTS formats prior to DTS-HD */
     { AV_CODEC_ID_DTS,             MKTAG('d', 't', 's', 'h') }, /* DTS-HD audio formats */
     { AV_CODEC_ID_DTS,             MKTAG('d', 't', 's', 'l') }, /* DTS-HD Lossless formats */
+    { AV_CODEC_ID_DTS,             MKTAG('d', 't', 's', 'e') }, /* DTS Express */
     { AV_CODEC_ID_DTS,             MKTAG('D', 'T', 'S', ' ') }, /* non-standard */
     { AV_CODEC_ID_EAC3,            MKTAG('e', 'c', '-', '3') }, /* ETSI TS 102 366 Annex F (only valid in ISOBMFF) */
     { AV_CODEC_ID_DVAUDIO,         MKTAG('v', 'd', 'v', 'a') },
@@ -342,9 +358,10 @@ const AVCodecTag ff_codec_movaudio_tags[] = {
     { AV_CODEC_ID_QDMC,            MKTAG('Q', 'D', 'M', 'C') },
     { AV_CODEC_ID_SPEEX,           MKTAG('s', 'p', 'e', 'x') }, /* Flash Media Server */
     { AV_CODEC_ID_SPEEX,           MKTAG('S', 'P', 'X', 'N') }, /* ZygoAudio (quality 10 mode) */
-    { AV_CODEC_ID_WMAV2,           MKTAG('W', 'M', 'A', '2') },
     { AV_CODEC_ID_EVRC,            MKTAG('s', 'e', 'v', 'c') }, /* 3GPP2 */
     { AV_CODEC_ID_SMV,             MKTAG('s', 's', 'm', 'v') }, /* 3GPP2 */
+    { AV_CODEC_ID_FLAC,            MKTAG('f', 'L', 'a', 'C') }, /* nonstandard */
+    { AV_CODEC_ID_OPUS,            MKTAG('O', 'p', 'u', 's') }, /* mp4ra.org */
     { AV_CODEC_ID_NONE, 0 },
 };
 
@@ -513,8 +530,10 @@ FF_ENABLE_DEPRECATION_WARNINGS
             return ret;
         if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
             MPEG4AudioConfig cfg = {0};
-            avpriv_mpeg4audio_get_config(&cfg, st->codecpar->extradata,
-                                         st->codecpar->extradata_size * 8, 1);
+            ret = avpriv_mpeg4audio_get_config(&cfg, st->codecpar->extradata,
+                                               st->codecpar->extradata_size * 8, 1);
+            if (ret < 0)
+                return ret;
             st->codecpar->channels = cfg.channels;
             if (cfg.object_type == 29 && cfg.sampling_index < 3) // old mp3on4
                 st->codecpar->sample_rate = avpriv_mpa_freq_tab[cfg.sampling_index];
diff --git a/mythtv/external/FFmpeg/libavformat/isom.h b/mythtv/external/FFmpeg/libavformat/isom.h
index 16c38e602e3..a30b13ec1ae 100644
--- a/mythtv/external/FFmpeg/libavformat/isom.h
+++ b/mythtv/external/FFmpeg/libavformat/isom.h
@@ -24,6 +24,13 @@
 #ifndef AVFORMAT_ISOM_H
 #define AVFORMAT_ISOM_H
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include "libavutil/mastering_display_metadata.h"
+#include "libavutil/spherical.h"
+#include "libavutil/stereo3d.h"
+
 #include "avio.h"
 #include "internal.h"
 #include "dv.h"
@@ -45,7 +52,7 @@ struct AVAESCTR;
  */
 
 typedef struct MOVStts {
-    int count;
+    unsigned int count;
     int duration;
 } MOVStts;
 
@@ -115,6 +122,11 @@ typedef struct MOVFragmentIndex {
     MOVFragmentIndexItem *items;
 } MOVFragmentIndex;
 
+typedef struct MOVIndexRange {
+    int64_t start;
+    int64_t end;
+} MOVIndexRange;
+
 typedef struct MOVStreamContext {
     AVIOContext *pb;
     int pb_is_copied;
@@ -125,10 +137,11 @@ typedef struct MOVStreamContext {
     unsigned int stts_count;
     MOVStts *stts_data;
     unsigned int ctts_count;
+    unsigned int ctts_allocated_size;
     MOVStts *ctts_data;
     unsigned int stsc_count;
     MOVStsc *stsc_data;
-    int stsc_index;
+    unsigned int stsc_index;
     int stsc_sample;
     unsigned int stps_count;
     unsigned *stps_data;  ///< partial sync sample for mpeg-2 open gop
@@ -146,6 +159,9 @@ typedef struct MOVStreamContext {
     int time_scale;
     int64_t time_offset;  ///< time offset of the edit list entries
     int current_sample;
+    int64_t current_index;
+    MOVIndexRange* index_ranges;
+    MOVIndexRange* current_index_range;
     unsigned int bytes_per_frame;
     unsigned int samples_per_frame;
     int dv_audio_container;
@@ -177,8 +193,16 @@ typedef struct MOVStreamContext {
     int stsd_count;
 
     int32_t *display_matrix;
+    AVStereo3D *stereo3d;
+    AVSphericalMapping *spherical;
+    size_t spherical_size;
+    AVMasteringDisplayMetadata *mastering;
+    AVContentLightMetadata *coll;
+    size_t coll_size;
+
     uint32_t format;
 
+    int has_sidx;  // If there is an sidx entry for this stream.
     struct {
         int use_subsamples;
         uint8_t* auxiliary_info;
@@ -187,6 +211,7 @@ typedef struct MOVStreamContext {
         uint8_t auxiliary_info_default_size;
         uint8_t* auxiliary_info_sizes;
         size_t auxiliary_info_sizes_count;
+        int64_t auxiliary_info_index;
         struct AVAESCTR* aes_ctr;
     } cenc;
 } MOVStreamContext;
@@ -214,6 +239,7 @@ typedef struct MOVContext {
     unsigned int nb_chapter_tracks;
     int use_absolute_path;
     int ignore_editlist;
+    int advanced_editlist;
     int ignore_chapters;
     int seek_individually;
     int64_t next_root_atom; ///< offset of the next root atom
@@ -239,6 +265,7 @@ typedef struct MOVContext {
     uint8_t *decryption_key;
     int decryption_key_len;
     int enable_drefs;
+    int32_t movie_display_matrix[3][3]; ///< display matrix from mvhd
 } MOVContext;
 
 int ff_mp4_read_descr_len(AVIOContext *pb);
diff --git a/mythtv/external/FFmpeg/libavformat/ivfenc.c b/mythtv/external/FFmpeg/libavformat/ivfenc.c
index f3ae4dca66b..fdc0ee03e16 100644
--- a/mythtv/external/FFmpeg/libavformat/ivfenc.c
+++ b/mythtv/external/FFmpeg/libavformat/ivfenc.c
@@ -75,7 +75,7 @@ static int ivf_write_trailer(AVFormatContext *s)
     AVIOContext *pb = s->pb;
     IVFEncContext *ctx = s->priv_data;
 
-    if (pb->seekable && ctx->frame_cnt > 1) {
+    if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && ctx->frame_cnt > 1) {
         size_t end = avio_tell(pb);
 
         avio_seek(pb, 24, SEEK_SET);
diff --git a/mythtv/external/FFmpeg/libavformat/latmenc.c b/mythtv/external/FFmpeg/libavformat/latmenc.c
index 43ca4821cb1..c919976d49d 100644
--- a/mythtv/external/FFmpeg/libavformat/latmenc.c
+++ b/mythtv/external/FFmpeg/libavformat/latmenc.c
@@ -146,20 +146,34 @@ static void latm_write_frame_header(AVFormatContext *s, PutBitContext *bs)
 static int latm_write_packet(AVFormatContext *s, AVPacket *pkt)
 {
     LATMContext *ctx = s->priv_data;
+    AVCodecParameters *par = s->streams[0]->codecpar;
     AVIOContext *pb = s->pb;
     PutBitContext bs;
     int i, len;
     uint8_t loas_header[] = "\x56\xe0\x00";
 
-    if (s->streams[0]->codecpar->codec_id == AV_CODEC_ID_AAC_LATM)
+    if (par->codec_id == AV_CODEC_ID_AAC_LATM)
         return ff_raw_write_packet(s, pkt);
 
-    if (!s->streams[0]->codecpar->extradata) {
+    if (!par->extradata) {
         if(pkt->size > 2 && pkt->data[0] == 0x56 && (pkt->data[1] >> 4) == 0xe &&
             (AV_RB16(pkt->data + 1) & 0x1FFF) + 3 == pkt->size)
             return ff_raw_write_packet(s, pkt);
-        else
-            return AVERROR_INVALIDDATA;
+        else {
+            uint8_t *side_data;
+            int side_data_size = 0, ret;
+
+            side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,
+                                                &side_data_size);
+            if (side_data_size) {
+                if (latm_decode_extradata(ctx, side_data, side_data_size) < 0)
+                    return AVERROR_INVALIDDATA;
+                ret = ff_alloc_extradata(par, side_data_size);
+                if (ret < 0)
+                    return ret;
+                memcpy(par->extradata, side_data, side_data_size);
+            }
+        }
     }
 
     if (pkt->size > 0x1fff)
diff --git a/mythtv/external/FFmpeg/libavformat/libnut.c b/mythtv/external/FFmpeg/libavformat/libnut.c
deleted file mode 100644
index 26bb35483f7..00000000000
--- a/mythtv/external/FFmpeg/libavformat/libnut.c
+++ /dev/null
@@ -1,324 +0,0 @@
-/*
- * NUT (de)muxing via libnut
- * copyright (c) 2006 Oded Shimon <ods15@ods15.dyndns.org>
- *
- * 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
- * NUT demuxing and muxing via libnut.
- * @author Oded Shimon <ods15@ods15.dyndns.org>
- */
-
-#include "avformat.h"
-#include "internal.h"
-#include "riff.h"
-#include <libnut.h>
-
-#define ID_STRING "nut/multimedia container"
-#define ID_LENGTH (strlen(ID_STRING) + 1)
-
-typedef struct {
-    nut_context_tt * nut;
-    nut_stream_header_tt * s;
-} NUTContext;
-
-static const AVCodecTag nut_tags[] = {
-    { AV_CODEC_ID_MPEG4,  MKTAG('m', 'p', '4', 'v') },
-    { AV_CODEC_ID_MP3,    MKTAG('m', 'p', '3', ' ') },
-    { AV_CODEC_ID_VORBIS, MKTAG('v', 'r', 'b', 's') },
-    { 0, 0 },
-};
-
-#if CONFIG_LIBNUT_MUXER
-static int av_write(void * h, size_t len, const uint8_t * buf) {
-    AVIOContext * bc = h;
-    avio_write(bc, buf, len);
-    //avio_flush(bc);
-    return len;
-}
-
-static int nut_write_header(AVFormatContext * avf) {
-    NUTContext * priv = avf->priv_data;
-    AVIOContext * bc = avf->pb;
-    nut_muxer_opts_tt mopts = {
-        .output = {
-            .priv = bc,
-            .write = av_write,
-        },
-        .alloc = { av_malloc, av_realloc, av_free },
-        .write_index = 1,
-        .realtime_stream = 0,
-        .max_distance = 32768,
-        .fti = NULL,
-    };
-    nut_stream_header_tt * s;
-    int i;
-
-    priv->s = s = av_mallocz_array(avf->nb_streams + 1, sizeof*s);
-    if(!s)
-        return AVERROR(ENOMEM);
-
-    for (i = 0; i < avf->nb_streams; i++) {
-        AVCodecParameters *par = avf->streams[i]->codecpar;
-        int j;
-        int fourcc = 0;
-        int num, denom, ssize;
-
-        s[i].type = par->codec_type == AVMEDIA_TYPE_VIDEO ? NUT_VIDEO_CLASS : NUT_AUDIO_CLASS;
-
-        if (par->codec_tag) fourcc = par->codec_tag;
-        else fourcc = ff_codec_get_tag(nut_tags, par->codec_id);
-
-        if (!fourcc) {
-            if (par->codec_type == AVMEDIA_TYPE_VIDEO) fourcc = ff_codec_get_tag(ff_codec_bmp_tags, par->codec_id);
-            if (par->codec_type == AVMEDIA_TYPE_AUDIO) fourcc = ff_codec_get_tag(ff_codec_wav_tags, par->codec_id);
-        }
-
-        s[i].fourcc_len = 4;
-        s[i].fourcc = av_malloc(s[i].fourcc_len);
-        for (j = 0; j < s[i].fourcc_len; j++) s[i].fourcc[j] = (fourcc >> (j*8)) & 0xFF;
-
-        ff_parse_specific_params(avf->streams[i], &num, &ssize, &denom);
-        avpriv_set_pts_info(avf->streams[i], 60, denom, num);
-
-        s[i].time_base.num = denom;
-        s[i].time_base.den = num;
-
-        s[i].fixed_fps = 0;
-        s[i].decode_delay = par->video_delay;
-        s[i].codec_specific_len = par->extradata_size;
-        s[i].codec_specific = par->extradata;
-
-        if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
-            s[i].width = par->width;
-            s[i].height = par->height;
-            s[i].sample_width = 0;
-            s[i].sample_height = 0;
-            s[i].colorspace_type = 0;
-        } else {
-            s[i].samplerate_num = par->sample_rate;
-            s[i].samplerate_denom = 1;
-            s[i].channel_count = par->channels;
-        }
-    }
-
-    s[avf->nb_streams].type = -1;
-    priv->nut = nut_muxer_init(&mopts, s, NULL);
-
-    return 0;
-}
-
-static int nut_write_packet(AVFormatContext * avf, AVPacket * pkt) {
-    NUTContext * priv = avf->priv_data;
-    nut_packet_tt p;
-
-    p.len = pkt->size;
-    p.stream = pkt->stream_index;
-    p.pts = pkt->pts;
-    p.flags = pkt->flags & AV_PKT_FLAG_KEY ? NUT_FLAG_KEY : 0;
-    p.next_pts = 0;
-
-    nut_write_frame_reorder(priv->nut, &p, pkt->data);
-
-    return 0;
-}
-
-static int nut_write_trailer(AVFormatContext * avf) {
-    AVIOContext * bc = avf->pb;
-    NUTContext * priv = avf->priv_data;
-    int i;
-
-    nut_muxer_uninit_reorder(priv->nut);
-    avio_flush(bc);
-
-    for(i = 0; priv->s[i].type != -1; i++ ) av_freep(&priv->s[i].fourcc);
-    av_freep(&priv->s);
-
-    return 0;
-}
-
-AVOutputFormat ff_libnut_muxer = {
-    .name              = "libnut",
-    .long_name         = "nut format",
-    .mime_type         = "video/x-nut",
-    .extensions        = "nut",
-    .priv_data_size    = sizeof(NUTContext),
-    .audio_codec       = AV_CODEC_ID_VORBIS,
-    .video_codec       = AV_CODEC_ID_MPEG4,
-    .write_header      = nut_write_header,
-    .write_packet      = nut_write_packet,
-    .write_trailer     = nut_write_trailer,
-    .flags             = AVFMT_GLOBALHEADER,
-};
-#endif /* CONFIG_LIBNUT_MUXER */
-
-static int nut_probe(AVProbeData *p) {
-    if (!memcmp(p->buf, ID_STRING, ID_LENGTH)) return AVPROBE_SCORE_MAX;
-
-    return 0;
-}
-
-static size_t av_read(void * h, size_t len, uint8_t * buf) {
-    AVIOContext * bc = h;
-    return avio_read(bc, buf, len);
-}
-
-static off_t av_seek(void * h, int64_t pos, int whence) {
-    AVIOContext * bc = h;
-    if (whence == SEEK_END) {
-        pos = avio_size(bc) + pos;
-        whence = SEEK_SET;
-    }
-    return avio_seek(bc, pos, whence);
-}
-
-static int nut_read_header(AVFormatContext * avf) {
-    NUTContext * priv = avf->priv_data;
-    AVIOContext * bc = avf->pb;
-    nut_demuxer_opts_tt dopts = {
-        .input = {
-            .priv = bc,
-            .seek = av_seek,
-            .read = av_read,
-            .eof = NULL,
-            .file_pos = 0,
-        },
-        .alloc = { av_malloc, av_realloc, av_free },
-        .read_index = 1,
-        .cache_syncpoints = 1,
-    };
-    nut_context_tt * nut = priv->nut = nut_demuxer_init(&dopts);
-    nut_stream_header_tt * s;
-    int ret, i;
-
-    if(!nut)
-        return -1;
-
-    if ((ret = nut_read_headers(nut, &s, NULL))) {
-        av_log(avf, AV_LOG_ERROR, " NUT error: %s\n", nut_error(ret));
-        nut_demuxer_uninit(nut);
-        priv->nut = NULL;
-        return -1;
-    }
-
-    priv->s = s;
-
-    for (i = 0; s[i].type != -1 && i < 2; i++) {
-        AVStream * st = avformat_new_stream(avf, NULL);
-        int j;
-
-        if (!st)
-            return AVERROR(ENOMEM);
-
-        for (j = 0; j < s[i].fourcc_len && j < 8; j++) st->codecpar->codec_tag |= s[i].fourcc[j]<<(j*8);
-
-        st->codecpar->video_delay = s[i].decode_delay;
-
-        st->codecpar->extradata_size = s[i].codec_specific_len;
-        if (st->codecpar->extradata_size) {
-            if(ff_alloc_extradata(st->codecpar, st->codecpar->extradata_size)){
-                nut_demuxer_uninit(nut);
-                priv->nut = NULL;
-                return AVERROR(ENOMEM);
-            }
-            memcpy(st->codecpar->extradata, s[i].codec_specific, st->codecpar->extradata_size);
-        }
-
-        avpriv_set_pts_info(avf->streams[i], 60, s[i].time_base.num, s[i].time_base.den);
-        st->start_time = 0;
-        st->duration = s[i].max_pts;
-
-        st->codecpar->codec_id = ff_codec_get_id(nut_tags, st->codecpar->codec_tag);
-
-        switch(s[i].type) {
-        case NUT_AUDIO_CLASS:
-            st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
-            if (st->codecpar->codec_id == AV_CODEC_ID_NONE) st->codecpar->codec_id = ff_codec_get_id(ff_codec_wav_tags, st->codecpar->codec_tag);
-
-            st->codecpar->channels = s[i].channel_count;
-            st->codecpar->sample_rate = s[i].samplerate_num / s[i].samplerate_denom;
-            break;
-        case NUT_VIDEO_CLASS:
-            st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
-            if (st->codecpar->codec_id == AV_CODEC_ID_NONE) st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags, st->codecpar->codec_tag);
-
-            st->codecpar->width = s[i].width;
-            st->codecpar->height = s[i].height;
-            st->sample_aspect_ratio.num = s[i].sample_width;
-            st->sample_aspect_ratio.den = s[i].sample_height;
-            break;
-        }
-        if (st->codecpar->codec_id == AV_CODEC_ID_NONE) av_log(avf, AV_LOG_ERROR, "Unknown codec?!\n");
-    }
-
-    return 0;
-}
-
-static int nut_read_packet(AVFormatContext * avf, AVPacket * pkt) {
-    NUTContext * priv = avf->priv_data;
-    nut_packet_tt pd;
-    int ret;
-
-    ret = nut_read_next_packet(priv->nut, &pd);
-
-    if (ret || av_new_packet(pkt, pd.len) < 0) {
-        if (ret != NUT_ERR_EOF)
-            av_log(avf, AV_LOG_ERROR, " NUT error: %s\n", nut_error(ret));
-        return -1;
-    }
-
-    if (pd.flags & NUT_FLAG_KEY) pkt->flags |= AV_PKT_FLAG_KEY;
-    pkt->pts = pd.pts;
-    pkt->stream_index = pd.stream;
-    pkt->pos = avio_tell(avf->pb);
-
-    ret = nut_read_frame(priv->nut, &pd.len, pkt->data);
-
-    return ret;
-}
-
-static int nut_read_seek(AVFormatContext * avf, int stream_index, int64_t target_ts, int flags) {
-    NUTContext * priv = avf->priv_data;
-    int active_streams[] = { stream_index, -1 };
-    double time_pos = target_ts * priv->s[stream_index].time_base.num / (double)priv->s[stream_index].time_base.den;
-
-    if (nut_seek(priv->nut, time_pos, 2*!(flags & AVSEEK_FLAG_BACKWARD), active_streams)) return -1;
-
-    return 0;
-}
-
-static int nut_read_close(AVFormatContext *s) {
-    NUTContext * priv = s->priv_data;
-
-    nut_demuxer_uninit(priv->nut);
-
-    return 0;
-}
-
-AVInputFormat ff_libnut_demuxer = {
-    .name           = "libnut",
-    .long_name      = NULL_IF_CONFIG_SMALL("NUT format"),
-    .priv_data_size = sizeof(NUTContext),
-    .read_probe     = nut_probe,
-    .read_header    = nut_read_header,
-    .read_packet    = nut_read_packet,
-    .read_close     = nut_read_close,
-    .read_seek      = nut_read_seek,
-    .extensions     = "nut",
-};
diff --git a/mythtv/external/FFmpeg/libavformat/libopenmpt.c b/mythtv/external/FFmpeg/libavformat/libopenmpt.c
index e7091ef9fc5..af6eb1ac4a0 100644
--- a/mythtv/external/FFmpeg/libavformat/libopenmpt.c
+++ b/mythtv/external/FFmpeg/libavformat/libopenmpt.c
@@ -73,7 +73,7 @@ static int read_header_openmpt(AVFormatContext *s)
     AVStream *st;
     OpenMPTContext *openmpt = s->priv_data;
     int64_t size = avio_size(s->pb);
-    if (!size)
+    if (size <= 0)
         return AVERROR_INVALIDDATA;
     char *buf = av_malloc(size);
     int ret;
@@ -82,20 +82,18 @@ static int read_header_openmpt(AVFormatContext *s)
     if (!buf)
         return AVERROR(ENOMEM);
     size = avio_read(s->pb, buf, size);
+    if (size < 0) {
+        av_log(s, AV_LOG_ERROR, "Reading input buffer failed.\n");
+        av_freep(&buf);
+        return size;
+    }
 
     openmpt->module = openmpt_module_create_from_memory(buf, size, openmpt_logfunc, s, NULL);
     av_freep(&buf);
     if (!openmpt->module)
             return AVERROR_INVALIDDATA;
 
-    openmpt->channels   = av_get_channel_layout_nb_channels(openmpt->layout);
-    openmpt->duration   = openmpt_module_get_duration_seconds(openmpt->module);
-
-    add_meta(s, "artist",  openmpt_module_get_metadata(openmpt->module, "artist"));
-    add_meta(s, "title",   openmpt_module_get_metadata(openmpt->module, "title"));
-    add_meta(s, "encoder", openmpt_module_get_metadata(openmpt->module, "tracker"));
-    add_meta(s, "comment", openmpt_module_get_metadata(openmpt->module, "message"));
-    add_meta(s, "date",    openmpt_module_get_metadata(openmpt->module, "date"));
+    openmpt->channels = av_get_channel_layout_nb_channels(openmpt->layout);
 
     if (openmpt->subsong >= openmpt_module_get_num_subsongs(openmpt->module)) {
         openmpt_module_destroy(openmpt->module);
@@ -115,6 +113,14 @@ static int read_header_openmpt(AVFormatContext *s)
         }
     }
 
+    openmpt->duration = openmpt_module_get_duration_seconds(openmpt->module);
+
+    add_meta(s, "artist",  openmpt_module_get_metadata(openmpt->module, "artist"));
+    add_meta(s, "title",   openmpt_module_get_metadata(openmpt->module, "title"));
+    add_meta(s, "encoder", openmpt_module_get_metadata(openmpt->module, "tracker"));
+    add_meta(s, "comment", openmpt_module_get_metadata(openmpt->module, "message"));
+    add_meta(s, "date",    openmpt_module_get_metadata(openmpt->module, "date"));
+
     st = avformat_new_stream(s, NULL);
     if (!st) {
         openmpt_module_destroy(openmpt->module);
diff --git a/mythtv/external/FFmpeg/libavformat/librtmp.c b/mythtv/external/FFmpeg/libavformat/librtmp.c
index 146df660acf..f3cfa9a8e25 100644
--- a/mythtv/external/FFmpeg/libavformat/librtmp.c
+++ b/mythtv/external/FFmpeg/libavformat/librtmp.c
@@ -239,7 +239,10 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
 #if CONFIG_NETWORK
     if (ctx->buffer_size >= 0 && (flags & AVIO_FLAG_WRITE)) {
         int tmp = ctx->buffer_size;
-        setsockopt(r->m_sb.sb_socket, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp));
+        if (setsockopt(r->m_sb.sb_socket, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp))) {
+            rc = AVERROR_EXTERNAL;
+            goto fail;
+        }
     }
 #endif
 
diff --git a/mythtv/external/FFmpeg/libavformat/libssh.c b/mythtv/external/FFmpeg/libavformat/libssh.c
index 49e92e7516f..9e3d4da45ef 100644
--- a/mythtv/external/FFmpeg/libavformat/libssh.c
+++ b/mythtv/external/FFmpeg/libavformat/libssh.c
@@ -103,7 +103,7 @@ static av_cold int libssh_authentication(LIBSSHContext *libssh, const char *user
         }
     }
 
-    if (!authorized && (auth_methods & SSH_AUTH_METHOD_PASSWORD)) {
+    if (!authorized && password && (auth_methods & SSH_AUTH_METHOD_PASSWORD)) {
         if (ssh_userauth_password(libssh->session, NULL, password) == SSH_AUTH_SUCCESS) {
             av_log(libssh, AV_LOG_DEBUG, "Authentication successful with password.\n");
             authorized = 1;
diff --git a/mythtv/external/FFmpeg/libavformat/lxfdec.c b/mythtv/external/FFmpeg/libavformat/lxfdec.c
index 99e56f243f8..9b3eb6a6505 100644
--- a/mythtv/external/FFmpeg/libavformat/lxfdec.c
+++ b/mythtv/external/FFmpeg/libavformat/lxfdec.c
@@ -181,7 +181,7 @@ static int get_packet_header(AVFormatContext *s)
         st->codecpar->bits_per_coded_sample = (audio_format >> 6) & 0x3F;
 
         if (st->codecpar->bits_per_coded_sample != (audio_format & 0x3F)) {
-            av_log(s, AV_LOG_WARNING, "only tightly packed PCM currently supported\n");
+            avpriv_report_missing_feature(s, "Not tightly packed PCM");
             return AVERROR_PATCHWELCOME;
         }
 
@@ -191,8 +191,7 @@ static int get_packet_header(AVFormatContext *s)
         case 24: st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE_PLANAR; break;
         case 32: st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE_PLANAR; break;
         default:
-            av_log(s, AV_LOG_WARNING,
-                   "only 16-, 20-, 24- and 32-bit PCM currently supported\n");
+            avpriv_report_missing_feature(s, "PCM not 16-, 20-, 24- or 32-bits");
             return AVERROR_PATCHWELCOME;
         }
 
diff --git a/mythtv/external/FFmpeg/libavformat/m4vdec.c b/mythtv/external/FFmpeg/libavformat/m4vdec.c
index d8ee530010a..34d434f7d26 100644
--- a/mythtv/external/FFmpeg/libavformat/m4vdec.c
+++ b/mythtv/external/FFmpeg/libavformat/m4vdec.c
@@ -53,6 +53,9 @@ static int mpeg4video_probe(AVProbeData *probe_packet)
 
     if (VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res == 0)
         return VOP+VO > 4 ? AVPROBE_SCORE_EXTENSION : AVPROBE_SCORE_EXTENSION/2;
+
+    if (VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && VOP+VO > 4)
+        return AVPROBE_SCORE_EXTENSION/10;
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavformat/matroska.c b/mythtv/external/FFmpeg/libavformat/matroska.c
index c592fb0ce30..94ccbecedb5 100644
--- a/mythtv/external/FFmpeg/libavformat/matroska.c
+++ b/mythtv/external/FFmpeg/libavformat/matroska.c
@@ -35,7 +35,7 @@ const CodecTags ff_mkv_codec_tags[]={
     {"A_FLAC"           , AV_CODEC_ID_FLAC},
     {"A_MLP"            , AV_CODEC_ID_MLP},
     {"A_MPEG/L2"        , AV_CODEC_ID_MP2},
-    {"A_MPEG/L1"        , AV_CODEC_ID_MP2},
+    {"A_MPEG/L1"        , AV_CODEC_ID_MP1},
     {"A_MPEG/L3"        , AV_CODEC_ID_MP3},
     {"A_OPUS"           , AV_CODEC_ID_OPUS},
     {"A_OPUS/EXPERIMENTAL",AV_CODEC_ID_OPUS},
@@ -48,6 +48,7 @@ const CodecTags ff_mkv_codec_tags[]={
     {"A_PCM/INT/LIT"    , AV_CODEC_ID_PCM_S24LE},
     {"A_PCM/INT/LIT"    , AV_CODEC_ID_PCM_S32LE},
     {"A_PCM/INT/LIT"    , AV_CODEC_ID_PCM_U8},
+    {"A_QUICKTIME/QDMC" , AV_CODEC_ID_QDMC},
     {"A_QUICKTIME/QDM2" , AV_CODEC_ID_QDM2},
     {"A_REAL/14_4"      , AV_CODEC_ID_RA_144},
     {"A_REAL/28_8"      , AV_CODEC_ID_RA_288},
@@ -74,8 +75,11 @@ const CodecTags ff_mkv_codec_tags[]={
     {"S_VOBSUB"         , AV_CODEC_ID_DVD_SUBTITLE},
     {"S_DVBSUB"         , AV_CODEC_ID_DVB_SUBTITLE},
     {"S_HDMV/PGS"       , AV_CODEC_ID_HDMV_PGS_SUBTITLE},
+    {"S_HDMV/TEXTST"    , AV_CODEC_ID_HDMV_TEXT_SUBTITLE},
 
+    {"V_AV1"            , AV_CODEC_ID_AV1},
     {"V_DIRAC"          , AV_CODEC_ID_DIRAC},
+    {"V_FFV1"           , AV_CODEC_ID_FFV1},
     {"V_MJPEG"          , AV_CODEC_ID_MJPEG},
     {"V_MPEG1"          , AV_CODEC_ID_MPEG1VIDEO},
     {"V_MPEG2"          , AV_CODEC_ID_MPEG2VIDEO},
@@ -150,26 +154,13 @@ const char * const ff_matroska_video_stereo_plane[MATROSKA_VIDEO_STEREO_PLANE_CO
 
 int ff_mkv_stereo3d_conv(AVStream *st, MatroskaVideoStereoModeType stereo_mode)
 {
-    AVPacketSideData *sd, *tmp;
     AVStereo3D *stereo;
+    int ret;
 
     stereo = av_stereo3d_alloc();
     if (!stereo)
         return AVERROR(ENOMEM);
 
-    tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
-    if (!tmp) {
-        av_freep(&stereo);
-        return AVERROR(ENOMEM);
-    }
-    st->side_data = tmp;
-    st->nb_side_data++;
-
-    sd = &st->side_data[st->nb_side_data - 1];
-    sd->type = AV_PKT_DATA_STEREO3D;
-    sd->data = (uint8_t *)stereo;
-    sd->size = sizeof(*stereo);
-
     // note: the missing breaks are intentional
     switch (stereo_mode) {
     case MATROSKA_VIDEO_STEREOMODE_TYPE_MONO:
@@ -207,5 +198,12 @@ int ff_mkv_stereo3d_conv(AVStream *st, MatroskaVideoStereoModeType stereo_mode)
         break;
     }
 
+    ret = av_stream_add_side_data(st, AV_PKT_DATA_STEREO3D, (uint8_t *)stereo,
+                                  sizeof(*stereo));
+    if (ret < 0) {
+        av_freep(&stereo);
+        return ret;
+    }
+
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavformat/matroska.h b/mythtv/external/FFmpeg/libavformat/matroska.h
index 13155e5ed0b..83c824614de 100644
--- a/mythtv/external/FFmpeg/libavformat/matroska.h
+++ b/mythtv/external/FFmpeg/libavformat/matroska.h
@@ -153,6 +153,13 @@
 #define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX 0x55D9
 #define MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN 0x55DA
 
+#define MATROSKA_ID_VIDEOPROJECTION 0x7670
+#define MATROSKA_ID_VIDEOPROJECTIONTYPE 0x7671
+#define MATROSKA_ID_VIDEOPROJECTIONPRIVATE 0x7672
+#define MATROSKA_ID_VIDEOPROJECTIONPOSEYAW 0x7673
+#define MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH 0x7674
+#define MATROSKA_ID_VIDEOPROJECTIONPOSEROLL 0x7675
+
 /* IDs in the trackaudio master */
 #define MATROSKA_ID_AUDIOSAMPLINGFREQ 0xB5
 #define MATROSKA_ID_AUDIOOUTSAMPLINGFREQ 0x78B5
@@ -331,6 +338,13 @@ typedef enum {
   MATROSKA_COLOUR_CHROMASITINGVERT_NB
 } MatroskaColourChromaSitingVert;
 
+typedef enum {
+  MATROSKA_VIDEO_PROJECTION_TYPE_RECTANGULAR        = 0,
+  MATROSKA_VIDEO_PROJECTION_TYPE_EQUIRECTANGULAR    = 1,
+  MATROSKA_VIDEO_PROJECTION_TYPE_CUBEMAP            = 2,
+  MATROSKA_VIDEO_PROJECTION_TYPE_MESH               = 3,
+} MatroskaVideoProjectionType;
+
 /*
  * Matroska Codec IDs, strings
  */
diff --git a/mythtv/external/FFmpeg/libavformat/matroskadec.c b/mythtv/external/FFmpeg/libavformat/matroskadec.c
index 32f5e49f0c3..94a56ebfa7a 100644
--- a/mythtv/external/FFmpeg/libavformat/matroskadec.c
+++ b/mythtv/external/FFmpeg/libavformat/matroskadec.c
@@ -43,6 +43,7 @@
 #include "libavutil/mathematics.h"
 #include "libavutil/opt.h"
 #include "libavutil/time_internal.h"
+#include "libavutil/spherical.h"
 
 #include "libavcodec/bytestream.h"
 #include "libavcodec/flac.h"
@@ -88,6 +89,7 @@ typedef const struct EbmlSyntax {
     int list_elem_size;
     int data_offset;
     union {
+        int64_t     i;
         uint64_t    u;
         double      f;
         const char *s;
@@ -161,6 +163,14 @@ typedef struct MatroskaTrackVideoColor {
     MatroskaMasteringMeta mastering_meta;
 } MatroskaTrackVideoColor;
 
+typedef struct MatroskaTrackVideoProjection {
+    uint64_t type;
+    EbmlBin private;
+    double yaw;
+    double pitch;
+    double roll;
+} MatroskaTrackVideoProjection;
+
 typedef struct MatroskaTrackVideo {
     double   frame_rate;
     uint64_t display_width;
@@ -173,7 +183,8 @@ typedef struct MatroskaTrackVideo {
     uint64_t field_order;
     uint64_t stereo_mode;
     uint64_t alpha_mode;
-    MatroskaTrackVideoColor color;
+    EbmlList color;
+    MatroskaTrackVideoProjection projection;
 } MatroskaTrackVideo;
 
 typedef struct MatroskaTrackAudio {
@@ -351,8 +362,11 @@ typedef struct MatroskaDemuxContext {
     /* File has SSA subtitles which prevent incremental cluster parsing. */
     int contains_ssa;
 
-    /* WebM DASH Manifest live flag/ */
+    /* WebM DASH Manifest live flag */
     int is_live;
+
+    /* Bandwidth value for WebM DASH Manifest */
+    int bandwidth;
 } MatroskaDemuxContext;
 
 typedef struct MatroskaBlock {
@@ -424,6 +438,15 @@ static const EbmlSyntax matroska_track_video_color[] = {
     { 0 }
 };
 
+static const EbmlSyntax matroska_track_video_projection[] = {
+    { MATROSKA_ID_VIDEOPROJECTIONTYPE,        EBML_UINT,  0, offsetof(MatroskaTrackVideoProjection, type), { .u = MATROSKA_VIDEO_PROJECTION_TYPE_RECTANGULAR } },
+    { MATROSKA_ID_VIDEOPROJECTIONPRIVATE,     EBML_BIN,   0, offsetof(MatroskaTrackVideoProjection, private) },
+    { MATROSKA_ID_VIDEOPROJECTIONPOSEYAW,     EBML_FLOAT, 0, offsetof(MatroskaTrackVideoProjection, yaw), { .f=0.0 } },
+    { MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH,   EBML_FLOAT, 0, offsetof(MatroskaTrackVideoProjection, pitch), { .f=0.0 } },
+    { MATROSKA_ID_VIDEOPROJECTIONPOSEROLL,    EBML_FLOAT, 0, offsetof(MatroskaTrackVideoProjection, roll), { .f=0.0 } },
+    { 0 }
+};
+
 static const EbmlSyntax matroska_track_video[] = {
     { MATROSKA_ID_VIDEOFRAMERATE,      EBML_FLOAT, 0, offsetof(MatroskaTrackVideo, frame_rate) },
     { MATROSKA_ID_VIDEODISPLAYWIDTH,   EBML_UINT,  0, offsetof(MatroskaTrackVideo, display_width), { .u=-1 } },
@@ -432,7 +455,8 @@ static const EbmlSyntax matroska_track_video[] = {
     { MATROSKA_ID_VIDEOPIXELHEIGHT,    EBML_UINT,  0, offsetof(MatroskaTrackVideo, pixel_height) },
     { MATROSKA_ID_VIDEOCOLORSPACE,     EBML_BIN,   0, offsetof(MatroskaTrackVideo, color_space) },
     { MATROSKA_ID_VIDEOALPHAMODE,      EBML_UINT,  0, offsetof(MatroskaTrackVideo, alpha_mode) },
-    { MATROSKA_ID_VIDEOCOLOR,          EBML_NEST,  0, offsetof(MatroskaTrackVideo, color), { .n = matroska_track_video_color } },
+    { MATROSKA_ID_VIDEOCOLOR,          EBML_NEST,  sizeof(MatroskaTrackVideoColor), offsetof(MatroskaTrackVideo, color), { .n = matroska_track_video_color } },
+    { MATROSKA_ID_VIDEOPROJECTION,     EBML_NEST,  0, offsetof(MatroskaTrackVideo, projection), { .n = matroska_track_video_projection } },
     { MATROSKA_ID_VIDEOPIXELCROPB,     EBML_NONE },
     { MATROSKA_ID_VIDEOPIXELCROPT,     EBML_NONE },
     { MATROSKA_ID_VIDEOPIXELCROPL,     EBML_NONE },
@@ -676,7 +700,7 @@ static const EbmlSyntax matroska_blockgroup[] = {
     { MATROSKA_ID_SIMPLEBLOCK,    EBML_BIN,  0, offsetof(MatroskaBlock, bin) },
     { MATROSKA_ID_BLOCKDURATION,  EBML_UINT, 0, offsetof(MatroskaBlock, duration) },
     { MATROSKA_ID_DISCARDPADDING, EBML_SINT, 0, offsetof(MatroskaBlock, discard_padding) },
-    { MATROSKA_ID_BLOCKREFERENCE, EBML_SINT, 0, offsetof(MatroskaBlock, reference) },
+    { MATROSKA_ID_BLOCKREFERENCE, EBML_SINT, 0, offsetof(MatroskaBlock, reference), { .i = INT64_MIN } },
     { MATROSKA_ID_CODECSTATE,     EBML_NONE },
     {                          1, EBML_UINT, 0, offsetof(MatroskaBlock, non_simple), { .u = 1 } },
     { 0 }
@@ -1051,6 +1075,9 @@ static int ebml_parse_nest(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
 
     for (i = 0; syntax[i].id; i++)
         switch (syntax[i].type) {
+        case EBML_SINT:
+            *(int64_t *) ((char *) data + syntax[i].data_offset) = syntax[i].def.i;
+            break;
         case EBML_UINT:
             *(uint64_t *) ((char *) data + syntax[i].data_offset) = syntax[i].def.u;
             break;
@@ -1237,6 +1264,7 @@ static void ebml_free(EbmlSyntax *syntax, void *data)
                      j++, ptr += syntax[i].list_elem_size)
                     ebml_free(syntax[i].def.n, ptr);
                 av_freep(&list->elem);
+                list->nb_elem = 0;
             } else
                 ebml_free(syntax[i].def.n, data_off);
         default:
@@ -1591,7 +1619,7 @@ static void matroska_execute_seekhead(MatroskaDemuxContext *matroska)
     int i;
 
     // we should not do any seeking in the streaming case
-    if (!matroska->ctx->pb->seekable)
+    if (!(matroska->ctx->pb->seekable & AVIO_SEEKABLE_NORMAL))
         return;
 
     for (i = 0; i < seekhead_list->nb_elem; i++) {
@@ -1806,34 +1834,55 @@ static void mkv_stereo_mode_display_mul(int stereo_mode,
 }
 
 static int mkv_parse_video_color(AVStream *st, const MatroskaTrack *track) {
-    const MatroskaMasteringMeta* mastering_meta =
-        &track->video.color.mastering_meta;
+    const MatroskaTrackVideoColor *color = track->video.color.elem;
+    const MatroskaMasteringMeta *mastering_meta;
+    int has_mastering_primaries, has_mastering_luminance;
+
+    if (!track->video.color.nb_elem)
+        return 0;
+
+    mastering_meta = &color->mastering_meta;
     // Mastering primaries are CIE 1931 coords, and must be > 0.
-    const int has_mastering_primaries =
+    has_mastering_primaries =
         mastering_meta->r_x > 0 && mastering_meta->r_y > 0 &&
         mastering_meta->g_x > 0 && mastering_meta->g_y > 0 &&
         mastering_meta->b_x > 0 && mastering_meta->b_y > 0 &&
         mastering_meta->white_x > 0 && mastering_meta->white_y > 0;
-    const int has_mastering_luminance = mastering_meta->max_luminance > 0;
-
-    if (track->video.color.matrix_coefficients != AVCOL_SPC_RESERVED)
-        st->codecpar->color_space = track->video.color.matrix_coefficients;
-    if (track->video.color.primaries != AVCOL_PRI_RESERVED &&
-        track->video.color.primaries != AVCOL_PRI_RESERVED0)
-        st->codecpar->color_primaries = track->video.color.primaries;
-    if (track->video.color.transfer_characteristics != AVCOL_TRC_RESERVED &&
-        track->video.color.transfer_characteristics != AVCOL_TRC_RESERVED0)
-        st->codecpar->color_trc = track->video.color.transfer_characteristics;
-    if (track->video.color.range != AVCOL_RANGE_UNSPECIFIED &&
-        track->video.color.range <= AVCOL_RANGE_JPEG)
-        st->codecpar->color_range = track->video.color.range;
-    if (track->video.color.chroma_siting_horz != MATROSKA_COLOUR_CHROMASITINGHORZ_UNDETERMINED &&
-        track->video.color.chroma_siting_vert != MATROSKA_COLOUR_CHROMASITINGVERT_UNDETERMINED &&
-        track->video.color.chroma_siting_horz  < MATROSKA_COLOUR_CHROMASITINGHORZ_NB &&
-        track->video.color.chroma_siting_vert  < MATROSKA_COLOUR_CHROMASITINGVERT_NB) {
+    has_mastering_luminance = mastering_meta->max_luminance > 0;
+
+    if (color->matrix_coefficients != AVCOL_SPC_RESERVED)
+        st->codecpar->color_space = color->matrix_coefficients;
+    if (color->primaries != AVCOL_PRI_RESERVED &&
+        color->primaries != AVCOL_PRI_RESERVED0)
+        st->codecpar->color_primaries = color->primaries;
+    if (color->transfer_characteristics != AVCOL_TRC_RESERVED &&
+        color->transfer_characteristics != AVCOL_TRC_RESERVED0)
+        st->codecpar->color_trc = color->transfer_characteristics;
+    if (color->range != AVCOL_RANGE_UNSPECIFIED &&
+        color->range <= AVCOL_RANGE_JPEG)
+        st->codecpar->color_range = color->range;
+    if (color->chroma_siting_horz != MATROSKA_COLOUR_CHROMASITINGHORZ_UNDETERMINED &&
+        color->chroma_siting_vert != MATROSKA_COLOUR_CHROMASITINGVERT_UNDETERMINED &&
+        color->chroma_siting_horz  < MATROSKA_COLOUR_CHROMASITINGHORZ_NB &&
+        color->chroma_siting_vert  < MATROSKA_COLOUR_CHROMASITINGVERT_NB) {
         st->codecpar->chroma_location =
-            avcodec_chroma_pos_to_enum((track->video.color.chroma_siting_horz - 1) << 7,
-                                       (track->video.color.chroma_siting_vert - 1) << 7);
+            avcodec_chroma_pos_to_enum((color->chroma_siting_horz - 1) << 7,
+                                       (color->chroma_siting_vert - 1) << 7);
+    }
+    if (color->max_cll && color->max_fall) {
+        size_t size = 0;
+        int ret;
+        AVContentLightMetadata *metadata = av_content_light_metadata_alloc(&size);
+        if (!metadata)
+            return AVERROR(ENOMEM);
+        ret = av_stream_add_side_data(st, AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
+                                      (uint8_t *)metadata, size);
+        if (ret < 0) {
+            av_freep(&metadata);
+            return ret;
+        }
+        metadata->MaxCLL  = color->max_cll;
+        metadata->MaxFALL = color->max_fall;
     }
 
     if (has_mastering_primaries || has_mastering_luminance) {
@@ -1878,6 +1927,98 @@ static int mkv_parse_video_color(AVStream *st, const MatroskaTrack *track) {
     return 0;
 }
 
+static int mkv_parse_video_projection(AVStream *st, const MatroskaTrack *track) {
+    AVSphericalMapping *spherical;
+    enum AVSphericalProjection projection;
+    size_t spherical_size;
+    uint32_t l = 0, t = 0, r = 0, b = 0;
+    uint32_t padding = 0;
+    int ret;
+    GetByteContext gb;
+
+    bytestream2_init(&gb, track->video.projection.private.data,
+                     track->video.projection.private.size);
+
+    if (bytestream2_get_byte(&gb) != 0) {
+        av_log(NULL, AV_LOG_WARNING, "Unknown spherical metadata\n");
+        return 0;
+    }
+
+    bytestream2_skip(&gb, 3); // flags
+
+    switch (track->video.projection.type) {
+    case MATROSKA_VIDEO_PROJECTION_TYPE_EQUIRECTANGULAR:
+        if (track->video.projection.private.size == 20) {
+            t = bytestream2_get_be32(&gb);
+            b = bytestream2_get_be32(&gb);
+            l = bytestream2_get_be32(&gb);
+            r = bytestream2_get_be32(&gb);
+
+            if (b >= UINT_MAX - t || r >= UINT_MAX - l) {
+                av_log(NULL, AV_LOG_ERROR,
+                       "Invalid bounding rectangle coordinates "
+                       "%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32"\n",
+                       l, t, r, b);
+                return AVERROR_INVALIDDATA;
+            }
+        } else if (track->video.projection.private.size != 0) {
+            av_log(NULL, AV_LOG_ERROR, "Unknown spherical metadata\n");
+            return AVERROR_INVALIDDATA;
+        }
+
+        if (l || t || r || b)
+            projection = AV_SPHERICAL_EQUIRECTANGULAR_TILE;
+        else
+            projection = AV_SPHERICAL_EQUIRECTANGULAR;
+        break;
+    case MATROSKA_VIDEO_PROJECTION_TYPE_CUBEMAP:
+        if (track->video.projection.private.size < 4) {
+            av_log(NULL, AV_LOG_ERROR, "Missing projection private properties\n");
+            return AVERROR_INVALIDDATA;
+        } else if (track->video.projection.private.size == 12) {
+            uint32_t layout = bytestream2_get_be32(&gb);
+            if (layout) {
+                av_log(NULL, AV_LOG_WARNING,
+                       "Unknown spherical cubemap layout %"PRIu32"\n", layout);
+                return 0;
+            }
+            projection = AV_SPHERICAL_CUBEMAP;
+            padding = bytestream2_get_be32(&gb);
+        } else {
+            av_log(NULL, AV_LOG_ERROR, "Unknown spherical metadata\n");
+            return AVERROR_INVALIDDATA;
+        }
+        break;
+    default:
+        return 0;
+    }
+
+    spherical = av_spherical_alloc(&spherical_size);
+    if (!spherical)
+        return AVERROR(ENOMEM);
+    spherical->projection = projection;
+
+    spherical->yaw   = (int32_t)(track->video.projection.yaw   * (1 << 16));
+    spherical->pitch = (int32_t)(track->video.projection.pitch * (1 << 16));
+    spherical->roll  = (int32_t)(track->video.projection.roll  * (1 << 16));
+
+    spherical->padding = padding;
+
+    spherical->bound_left   = l;
+    spherical->bound_top    = t;
+    spherical->bound_right  = r;
+    spherical->bound_bottom = b;
+
+    ret = av_stream_add_side_data(st, AV_PKT_DATA_SPHERICAL, (uint8_t *)spherical,
+                                  spherical_size);
+    if (ret < 0) {
+        av_freep(&spherical);
+        return ret;
+    }
+
+    return 0;
+}
+
 static int get_qt_codec(MatroskaTrack *track, uint32_t *fourcc, enum AVCodecID *codec_id)
 {
     const AVCodecTag *codec_tags;
@@ -2089,12 +2230,9 @@ static int matroska_parse_tracks(AVFormatContext *s)
                 fourcc = MKTAG('S','V','Q','3');
                 codec_id = ff_codec_get_id(ff_codec_movvideo_tags, fourcc);
             }
-            if (codec_id == AV_CODEC_ID_NONE) {
-                char buf[32];
-                av_get_codec_tag_string(buf, sizeof(buf), fourcc);
+            if (codec_id == AV_CODEC_ID_NONE)
                 av_log(matroska->ctx, AV_LOG_ERROR,
-                       "mov FourCC not found %s.\n", buf);
-            }
+                       "mov FourCC not found %s.\n", av_fourcc2str(fourcc));
             if (track->codec_priv.size >= 86) {
                 bit_depth = AV_RB16(track->codec_priv.data + 82);
                 ffio_init_context(&b, track->codec_priv.data,
@@ -2220,7 +2358,7 @@ static int matroska_parse_tracks(AVFormatContext *s)
                 track->audio.coded_framesize <= 0 ||
                 track->audio.sub_packet_h    <= 0 ||
                 track->audio.frame_size      <= 0 ||
-                track->audio.sub_packet_size <= 0)
+                track->audio.sub_packet_size <= 0 && codec_id != AV_CODEC_ID_SIPR)
                 return AVERROR_INVALIDDATA;
             track->audio.buf = av_malloc_array(track->audio.sub_packet_h,
                                                track->audio.frame_size);
@@ -2355,11 +2493,12 @@ static int matroska_parse_tracks(AVFormatContext *s)
                     return ret;
             }
 
-            if (s->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
-                int ret = mkv_parse_video_color(st, track);
-                if (ret < 0)
-                    return ret;
-            }
+            ret = mkv_parse_video_color(st, track);
+            if (ret < 0)
+                return ret;
+            ret = mkv_parse_video_projection(st, track);
+            if (ret < 0)
+                return ret;
         } else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
             st->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;
             st->codecpar->codec_tag   = fourcc;
@@ -2427,10 +2566,9 @@ static int matroska_read_header(AVFormatContext *s)
         ebml.max_size        > sizeof(uint64_t)  ||
         ebml.id_length       > sizeof(uint32_t)  ||
         ebml.doctype_version > 3) {
-        av_log(matroska->ctx, AV_LOG_ERROR,
-               "EBML header using unsupported features\n"
-               "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
-               ebml.version, ebml.doctype, ebml.doctype_version);
+        avpriv_report_missing_feature(matroska->ctx,
+                                      "EBML version %"PRIu64", doctype %s, doc version %"PRIu64,
+                                      ebml.version, ebml.doctype, ebml.doctype_version);
         ebml_free(ebml_syntax, &ebml);
         return AVERROR_PATCHWELCOME;
     } else if (ebml.doctype_version == 3) {
@@ -3082,10 +3220,14 @@ static int matroska_parse_frame(MatroskaDemuxContext *matroska,
             av_free(pkt);
             return AVERROR(ENOMEM);
         }
-        AV_WL32(side_data, 0);
-        AV_WL32(side_data + 4, av_rescale_q(discard_padding,
+        discard_padding = av_rescale_q(discard_padding,
                                             (AVRational){1, 1000000000},
-                                            (AVRational){1, st->codecpar->sample_rate}));
+                                            (AVRational){1, st->codecpar->sample_rate});
+        if (discard_padding > 0) {
+            AV_WL32(side_data + 4, discard_padding);
+        } else {
+            AV_WL32(side_data, -discard_padding);
+        }
     }
 
     if (track->ms_compat)
@@ -3162,9 +3304,11 @@ static int matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data,
         if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE &&
             timecode < track->end_timecode)
             is_keyframe = 0;  /* overlapping subtitles are not key frame */
-        if (is_keyframe)
+        if (is_keyframe) {
+            ff_reduce_index(matroska->ctx, st->index);
             av_add_index_entry(st, cluster_pos, timecode, 0, 0,
                                AVINDEX_KEYFRAME);
+        }
     }
 
     if (matroska->skip_to_keyframe &&
@@ -3289,7 +3433,7 @@ static int matroska_parse_cluster_incremental(MatroskaDemuxContext *matroska)
         matroska->current_cluster_num_blocks = blocks_list->nb_elem;
         i                                    = blocks_list->nb_elem - 1;
         if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
-            int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
+            int is_keyframe = blocks[i].non_simple ? blocks[i].reference == INT64_MIN : -1;
             uint8_t* additional = blocks[i].additional.size > 0 ?
                                     blocks[i].additional.data : NULL;
             if (!blocks[i].non_simple)
@@ -3327,7 +3471,7 @@ static int matroska_parse_cluster(MatroskaDemuxContext *matroska)
     blocks      = blocks_list->elem;
     for (i = 0; i < blocks_list->nb_elem; i++)
         if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
-            int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
+            int is_keyframe = blocks[i].non_simple ? blocks[i].reference == INT64_MIN : -1;
             res = matroska_parse_block(matroska, blocks[i].bin.data,
                                        blocks[i].bin.size, blocks[i].bin.pos,
                                        cluster.timecode, blocks[i].duration,
@@ -3360,7 +3504,7 @@ static int matroska_read_seek(AVFormatContext *s, int stream_index,
     MatroskaDemuxContext *matroska = s->priv_data;
     MatroskaTrack *tracks = NULL;
     AVStream *st = s->streams[stream_index];
-    int i, index, index_sub, index_min;
+    int i, index, index_min;
 
     /* Parse the CUES now since we need the index data to seek. */
     if (matroska->cues_parsing_deferred > 0) {
@@ -3394,18 +3538,6 @@ static int matroska_read_seek(AVFormatContext *s, int stream_index,
         tracks[i].audio.sub_packet_cnt = 0;
         tracks[i].audio.buf_timecode   = AV_NOPTS_VALUE;
         tracks[i].end_timecode         = 0;
-        if (tracks[i].type == MATROSKA_TRACK_TYPE_SUBTITLE &&
-            tracks[i].stream &&
-            tracks[i].stream->discard != AVDISCARD_ALL) {
-            index_sub = av_index_search_timestamp(
-                tracks[i].stream, st->index_entries[index].timestamp,
-                AVSEEK_FLAG_BACKWARD);
-            while (index_sub >= 0 &&
-                  index_min > 0 &&
-                  tracks[i].stream->index_entries[index_sub].pos < st->index_entries[index_min].pos &&
-                  st->index_entries[index].timestamp - tracks[i].stream->index_entries[index_sub].timestamp < 30000000000 / matroska->time_scale)
-                index_min--;
-        }
     }
 
     avio_seek(s->pb, st->index_entries[index_min].pos, SEEK_SET);
@@ -3458,7 +3590,7 @@ typedef struct {
     int64_t end_offset;
 } CueDesc;
 
-/* This function searches all the Cues and returns the CueDesc corresponding the
+/* This function searches all the Cues and returns the CueDesc corresponding to
  * the timestamp ts. Returned CueDesc will be such that start_time_ns <= ts <
  * end_time_ns. All 4 fields will be set to -1 if ts >= file's duration.
  */
@@ -3698,7 +3830,7 @@ static int64_t webm_dash_manifest_compute_bandwidth(AVFormatContext *s, int64_t
     return (int64_t)bandwidth;
 }
 
-static int webm_dash_manifest_cues(AVFormatContext *s)
+static int webm_dash_manifest_cues(AVFormatContext *s, int64_t init_range)
 {
     MatroskaDemuxContext *matroska = s->priv_data;
     EbmlList *seekhead_list = &matroska->seekhead;
@@ -3706,6 +3838,7 @@ static int webm_dash_manifest_cues(AVFormatContext *s)
     char *buf;
     int64_t cues_start = -1, cues_end = -1, before_pos, bandwidth;
     int i;
+    int end = 0;
 
     // determine cues start and end positions
     for (i = 0; i < seekhead_list->nb_elem; i++)
@@ -3737,6 +3870,11 @@ static int webm_dash_manifest_cues(AVFormatContext *s)
     // cues end
     av_dict_set_int(&s->streams[0]->metadata, CUES_END, cues_end, 0);
 
+    // if the file has cues at the start, fix up the init range so tht
+    // it does not include it
+    if (cues_start <= init_range)
+        av_dict_set_int(&s->streams[0]->metadata, INITIALIZATION_RANGE, cues_start - 1, 0);
+
     // bandwidth
     bandwidth = webm_dash_manifest_compute_bandwidth(s, cues_start);
     if (bandwidth < 0) return -1;
@@ -3751,10 +3889,18 @@ static int webm_dash_manifest_cues(AVFormatContext *s)
     if (!buf) return -1;
     strcpy(buf, "");
     for (i = 0; i < s->streams[0]->nb_index_entries; i++) {
-        snprintf(buf, (i + 1) * 20 * sizeof(char),
-                 "%s%" PRId64, buf, s->streams[0]->index_entries[i].timestamp);
-        if (i != s->streams[0]->nb_index_entries - 1)
+        int ret = snprintf(buf + end, 20 * sizeof(char),
+                           "%" PRId64, s->streams[0]->index_entries[i].timestamp);
+        if (ret <= 0 || (ret == 20 && i ==  s->streams[0]->nb_index_entries - 1)) {
+            av_log(s, AV_LOG_ERROR, "timestamp too long.\n");
+            av_free(buf);
+            return AVERROR_INVALIDDATA;
+        }
+        end += ret;
+        if (i != s->streams[0]->nb_index_entries - 1) {
             strncat(buf, ",", sizeof(char));
+            end++;
+        }
     }
     av_dict_set(&s->streams[0]->metadata, CUE_TIMESTAMPS, buf, 0);
     av_free(buf);
@@ -3766,12 +3912,18 @@ static int webm_dash_manifest_read_header(AVFormatContext *s)
 {
     char *buf;
     int ret = matroska_read_header(s);
+    int64_t init_range;
     MatroskaTrack *tracks;
     MatroskaDemuxContext *matroska = s->priv_data;
     if (ret) {
         av_log(s, AV_LOG_ERROR, "Failed to read file headers\n");
         return -1;
     }
+    if (!s->nb_streams) {
+        matroska_read_close(s);
+        av_log(s, AV_LOG_ERROR, "No streams found\n");
+        return AVERROR_INVALIDDATA;
+    }
 
     if (!matroska->is_live) {
         buf = av_asprintf("%g", matroska->duration);
@@ -3781,7 +3933,8 @@ static int webm_dash_manifest_read_header(AVFormatContext *s)
 
         // initialization range
         // 5 is the offset of Cluster ID.
-        av_dict_set_int(&s->streams[0]->metadata, INITIALIZATION_RANGE, avio_tell(s->pb) - 5, 0);
+        init_range = avio_tell(s->pb) - 5;
+        av_dict_set_int(&s->streams[0]->metadata, INITIALIZATION_RANGE, init_range, 0);
     }
 
     // basename of the file
@@ -3793,7 +3946,20 @@ static int webm_dash_manifest_read_header(AVFormatContext *s)
     av_dict_set_int(&s->streams[0]->metadata, TRACK_NUMBER, tracks[0].num, 0);
 
     // parse the cues and populate Cue related fields
-    return matroska->is_live ? 0 : webm_dash_manifest_cues(s);
+    if (!matroska->is_live) {
+        ret = webm_dash_manifest_cues(s, init_range);
+        if (ret < 0) {
+            av_log(s, AV_LOG_ERROR, "Error parsing Cues\n");
+            return ret;
+        }
+    }
+
+    // use the bandwidth from the command line if it was provided
+    if (matroska->bandwidth > 0) {
+        av_dict_set_int(&s->streams[0]->metadata, BANDWIDTH,
+                        matroska->bandwidth, 0);
+    }
+    return 0;
 }
 
 static int webm_dash_manifest_read_packet(AVFormatContext *s, AVPacket *pkt)
@@ -3804,6 +3970,7 @@ static int webm_dash_manifest_read_packet(AVFormatContext *s, AVPacket *pkt)
 #define OFFSET(x) offsetof(MatroskaDemuxContext, x)
 static const AVOption options[] = {
     { "live", "flag indicating that the input is a live file that only has the headers.", OFFSET(is_live), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
+    { "bandwidth", "bandwidth of this stream to be specified in the DASH manifest.", OFFSET(bandwidth), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
     { NULL },
 };
 
diff --git a/mythtv/external/FFmpeg/libavformat/matroskaenc.c b/mythtv/external/FFmpeg/libavformat/matroskaenc.c
index d91055f89ef..3073fd8f77a 100644
--- a/mythtv/external/FFmpeg/libavformat/matroskaenc.c
+++ b/mythtv/external/FFmpeg/libavformat/matroskaenc.c
@@ -93,6 +93,9 @@ typedef struct mkv_cues {
 typedef struct mkv_track {
     int             write_dts;
     int             has_cue;
+    int             sample_rate;
+    int64_t         sample_rate_offset;
+    int64_t         codecpriv_offset;
     int64_t         ts_offset;
 } mkv_track;
 
@@ -121,6 +124,8 @@ typedef struct MatroskaMuxContext {
     ebml_master     tags;
     AVIOContext     *info_bc;
     ebml_master     info;
+    AVIOContext     *tracks_bc;
+    ebml_master     tracks_master;
     ebml_master     segment;
     int64_t         segment_offset;
     ebml_master     cluster;
@@ -330,7 +335,7 @@ static int start_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, Matros
     if ((ret = avio_open_dyn_buf(dyn_cp)) < 0)
         return ret;
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         *master = start_ebml_master(pb, elementid, expectedsize);
         if (mkv->write_crc && mkv->mode != MODE_WEBM)
             put_ebml_void(*dyn_cp, 6); /* Reserve space for CRC32 so position/size calculations using avio_tell() take it into account */
@@ -346,7 +351,7 @@ static void end_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, Matrosk
     uint8_t *buf, crc[4];
     int size, skip = 0;
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         size = avio_close_dyn_buf(*dyn_cp, &buf);
         if (mkv->write_crc && mkv->mode != MODE_WEBM) {
             skip = 6; /* Skip reserved 6-byte long void element from the dynamic buffer. */
@@ -364,6 +369,22 @@ static void end_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, Matrosk
     *dyn_cp = NULL;
 }
 
+/**
+* Complete ebml master whithout destroying the buffer, allowing for later updates
+*/
+static void end_ebml_master_crc32_preliminary(AVIOContext *pb, AVIOContext **dyn_cp, MatroskaMuxContext *mkv,
+    ebml_master master)
+{
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
+
+        uint8_t *buf;
+        int size = avio_get_dyn_buf(*dyn_cp, &buf);
+
+        avio_write(pb, buf, size);
+        end_ebml_master(pb, master);
+    }
+}
+
 static void put_xiph_size(AVIOContext *pb, int size)
 {
     ffio_fill(pb, 255, size / 255);
@@ -374,6 +395,23 @@ static void put_xiph_size(AVIOContext *pb, int size)
  * Free the members allocated in the mux context.
  */
 static void mkv_free(MatroskaMuxContext *mkv) {
+    uint8_t* buf;
+    if (mkv->dyn_bc) {
+        avio_close_dyn_buf(mkv->dyn_bc, &buf);
+        av_free(buf);
+    }
+    if (mkv->info_bc) {
+        avio_close_dyn_buf(mkv->info_bc, &buf);
+        av_free(buf);
+    }
+    if (mkv->tracks_bc) {
+        avio_close_dyn_buf(mkv->tracks_bc, &buf);
+        av_free(buf);
+    }
+    if (mkv->tags_bc) {
+        avio_close_dyn_buf(mkv->tags_bc, &buf);
+        av_free(buf);
+    }
     if (mkv->main_seekhead) {
         av_freep(&mkv->main_seekhead->entries);
         av_freep(&mkv->main_seekhead);
@@ -679,24 +717,40 @@ static int put_flac_codecpriv(AVFormatContext *s,
     return 0;
 }
 
-static int get_aac_sample_rates(AVFormatContext *s, AVCodecParameters *par,
+static int get_aac_sample_rates(AVFormatContext *s, uint8_t *extradata, int extradata_size,
                                 int *sample_rate, int *output_sample_rate)
 {
     MPEG4AudioConfig mp4ac;
+    int ret;
 
-    if (avpriv_mpeg4audio_get_config(&mp4ac, par->extradata,
-                                     par->extradata_size * 8, 1) < 0) {
+    ret = avpriv_mpeg4audio_get_config(&mp4ac, extradata,
+                                       extradata_size * 8, 1);
+    /* Don't abort if the failure is because of missing extradata. Assume in that
+     * case a bitstream filter will provide the muxer with the extradata in the
+     * first packet.
+     * Abort however if s->pb is not seekable, as we would not be able to seek back
+     * to write the sample rate elements once the extradata shows up, anyway. */
+    if (ret < 0 && (extradata_size || !(s->pb->seekable & AVIO_SEEKABLE_NORMAL))) {
         av_log(s, AV_LOG_ERROR,
                "Error parsing AAC extradata, unable to determine samplerate.\n");
         return AVERROR(EINVAL);
     }
 
-    *sample_rate        = mp4ac.sample_rate;
-    *output_sample_rate = mp4ac.ext_sample_rate;
+    if (ret < 0) {
+        /* This will only happen when this function is called while writing the
+         * header and no extradata is available. The space for this element has
+         * to be reserved for when this function is called again after the
+         * extradata shows up in the first packet, as there's no way to know if
+         * output_sample_rate will be different than sample_rate or not. */
+        *output_sample_rate = *sample_rate;
+    } else {
+        *sample_rate        = mp4ac.sample_rate;
+        *output_sample_rate = mp4ac.ext_sample_rate;
+    }
     return 0;
 }
 
-static int mkv_write_native_codecprivate(AVFormatContext *s,
+static int mkv_write_native_codecprivate(AVFormatContext *s, AVIOContext *pb,
                                          AVCodecParameters *par,
                                          AVIOContext *dyn_cp)
 {
@@ -725,6 +779,12 @@ static int mkv_write_native_codecprivate(AVFormatContext *s,
             avio_write(dyn_cp, par->extradata + 12,
                        par->extradata_size - 12);
         break;
+    case AV_CODEC_ID_AAC:
+        if (par->extradata_size)
+            avio_write(dyn_cp, par->extradata, par->extradata_size);
+        else
+            put_ebml_void(pb, MAX_PCE_SIZE + 2 + 4);
+        break;
     default:
         if (par->codec_id == AV_CODEC_ID_PRORES &&
             ff_codec_get_id(ff_codec_movvideo_tags, par->codec_tag) == AV_CODEC_ID_PRORES) {
@@ -749,22 +809,22 @@ static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb,
         return ret;
 
     if (native_id) {
-        ret = mkv_write_native_codecprivate(s, par, dyn_cp);
+        ret = mkv_write_native_codecprivate(s, pb, par, dyn_cp);
     } else if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
         if (qt_id) {
             if (!par->codec_tag)
                 par->codec_tag = ff_codec_get_tag(ff_codec_movvideo_tags,
                                                     par->codec_id);
-                if (   ff_codec_get_id(ff_codec_movvideo_tags, par->codec_tag) == par->codec_id
-                    && (!par->extradata_size || ff_codec_get_id(ff_codec_movvideo_tags, AV_RL32(par->extradata + 4)) != par->codec_id)
-                ) {
-                    int i;
-                    avio_wb32(dyn_cp, 0x5a + par->extradata_size);
-                    avio_wl32(dyn_cp, par->codec_tag);
-                    for(i = 0; i < 0x5a - 8; i++)
-                        avio_w8(dyn_cp, 0);
-                }
-                avio_write(dyn_cp, par->extradata, par->extradata_size);
+            if (   ff_codec_get_id(ff_codec_movvideo_tags, par->codec_tag) == par->codec_id
+                && (!par->extradata_size || ff_codec_get_id(ff_codec_movvideo_tags, AV_RL32(par->extradata + 4)) != par->codec_id)
+            ) {
+                int i;
+                avio_wb32(dyn_cp, 0x5a + par->extradata_size);
+                avio_wl32(dyn_cp, par->codec_tag);
+                for(i = 0; i < 0x5a - 8; i++)
+                    avio_w8(dyn_cp, 0);
+            }
+            avio_write(dyn_cp, par->extradata, par->extradata_size);
         } else {
             if (!ff_codec_get_tag(ff_codec_bmp_tags, par->codec_id))
                 av_log(s, AV_LOG_WARNING, "codec %s is not supported by this format\n",
@@ -779,7 +839,7 @@ static int mkv_write_codecprivate(AVFormatContext *s, AVIOContext *pb,
                 ret = AVERROR(EINVAL);
             }
 
-            ff_put_bmp_header(dyn_cp, par, ff_codec_bmp_tags, 0, 0);
+            ff_put_bmp_header(dyn_cp, par, 0, 0);
         }
     } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
         unsigned int tag;
@@ -808,8 +868,7 @@ static int mkv_write_video_color(AVIOContext *pb, AVCodecParameters *par, AVStre
     uint8_t *colorinfo_ptr;
     int side_data_size = 0;
     int ret, colorinfo_size;
-    const uint8_t *side_data = av_stream_get_side_data(
-        st, AV_PKT_DATA_MASTERING_DISPLAY_METADATA, &side_data_size);
+    const uint8_t *side_data;
 
     ret = avio_open_dyn_buf(&dyn_cp);
     if (ret < 0)
@@ -832,6 +891,26 @@ static int mkv_write_video_color(AVIOContext *pb, AVCodecParameters *par, AVStre
         par->color_range < AVCOL_RANGE_NB) {
         put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORRANGE, par->color_range);
     }
+    if (par->chroma_location != AVCHROMA_LOC_UNSPECIFIED &&
+        par->chroma_location <= AVCHROMA_LOC_TOP) {
+        int xpos, ypos;
+
+        avcodec_enum_to_chroma_pos(&xpos, &ypos, par->chroma_location);
+        put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORCHROMASITINGHORZ, (xpos >> 7) + 1);
+        put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORCHROMASITINGVERT, (ypos >> 7) + 1);
+    }
+
+    side_data = av_stream_get_side_data(st, AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
+                                        &side_data_size);
+    if (side_data_size) {
+        const AVContentLightMetadata *metadata =
+            (const AVContentLightMetadata*)side_data;
+        put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORMAXCLL,  metadata->MaxCLL);
+        put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOCOLORMAXFALL, metadata->MaxFALL);
+    }
+
+    side_data = av_stream_get_side_data(st, AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
+                                        &side_data_size);
     if (side_data_size == sizeof(AVMasteringDisplayMetadata)) {
         ebml_master meta_element = start_ebml_master(
             dyn_cp, MATROSKA_ID_VIDEOCOLORMASTERINGMETA, 0);
@@ -866,7 +945,7 @@ static int mkv_write_video_color(AVIOContext *pb, AVCodecParameters *par, AVStre
 
     colorinfo_size = avio_close_dyn_buf(dyn_cp, &colorinfo_ptr);
     if (colorinfo_size) {
-        ebml_master colorinfo = start_ebml_master(pb, MATROSKA_ID_VIDEOCOLOR, 0);
+        ebml_master colorinfo = start_ebml_master(pb, MATROSKA_ID_VIDEOCOLOR, colorinfo_size);
         avio_write(pb, colorinfo_ptr, colorinfo_size);
         end_ebml_master(pb, colorinfo);
     }
@@ -874,6 +953,82 @@ static int mkv_write_video_color(AVIOContext *pb, AVCodecParameters *par, AVStre
     return 0;
 }
 
+static int mkv_write_video_projection(AVFormatContext *s, AVIOContext *pb, AVStream *st)
+{
+    int side_data_size = 0;
+    const AVSphericalMapping *spherical =
+        (const AVSphericalMapping*) av_stream_get_side_data(st, AV_PKT_DATA_SPHERICAL,
+                                                            &side_data_size);
+
+    if (side_data_size) {
+        AVIOContext *dyn_cp;
+        uint8_t *projection_ptr;
+        int ret, projection_size;
+
+        ret = avio_open_dyn_buf(&dyn_cp);
+        if (ret < 0)
+            return ret;
+
+        switch (spherical->projection) {
+        case AV_SPHERICAL_EQUIRECTANGULAR:
+            put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOPROJECTIONTYPE,
+                          MATROSKA_VIDEO_PROJECTION_TYPE_EQUIRECTANGULAR);
+            break;
+        case AV_SPHERICAL_EQUIRECTANGULAR_TILE:
+        {
+            AVIOContext b;
+            uint8_t private[20];
+            ffio_init_context(&b, private, sizeof(private),
+                              1, NULL, NULL, NULL, NULL);
+            put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOPROJECTIONTYPE,
+                          MATROSKA_VIDEO_PROJECTION_TYPE_EQUIRECTANGULAR);
+            avio_wb32(&b, 0); // version + flags
+            avio_wb32(&b, spherical->bound_top);
+            avio_wb32(&b, spherical->bound_bottom);
+            avio_wb32(&b, spherical->bound_left);
+            avio_wb32(&b, spherical->bound_right);
+            put_ebml_binary(dyn_cp, MATROSKA_ID_VIDEOPROJECTIONPRIVATE, private, sizeof(private));
+            break;
+        }
+        case AV_SPHERICAL_CUBEMAP:
+        {
+            AVIOContext b;
+            uint8_t private[12];
+            ffio_init_context(&b, private, sizeof(private),
+                              1, NULL, NULL, NULL, NULL);
+            put_ebml_uint(dyn_cp, MATROSKA_ID_VIDEOPROJECTIONTYPE,
+                          MATROSKA_VIDEO_PROJECTION_TYPE_CUBEMAP);
+            avio_wb32(&b, 0); // version + flags
+            avio_wb32(&b, 0); // layout
+            avio_wb32(&b, spherical->padding);
+            put_ebml_binary(dyn_cp, MATROSKA_ID_VIDEOPROJECTIONPRIVATE, private, sizeof(private));
+            break;
+        }
+        default:
+            av_log(s, AV_LOG_WARNING, "Unknown projection type\n");
+            goto end;
+        }
+
+        if (spherical->yaw)
+            put_ebml_float(dyn_cp, MATROSKA_ID_VIDEOPROJECTIONPOSEYAW,   (double)spherical->yaw   / (1 << 16));
+        if (spherical->pitch)
+            put_ebml_float(dyn_cp, MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH, (double)spherical->pitch / (1 << 16));
+        if (spherical->roll)
+            put_ebml_float(dyn_cp, MATROSKA_ID_VIDEOPROJECTIONPOSEROLL,  (double)spherical->roll  / (1 << 16));
+
+end:
+        projection_size = avio_close_dyn_buf(dyn_cp, &projection_ptr);
+        if (projection_size) {
+            ebml_master projection = start_ebml_master(pb, MATROSKA_ID_VIDEOPROJECTION, projection_size);
+            avio_write(pb, projection_ptr, projection_size);
+            end_ebml_master(pb, projection);
+        }
+        av_freep(&projection_ptr);
+    }
+
+    return 0;
+}
+
 static void mkv_write_field_order(AVIOContext *pb, int mode,
                                   enum AVFieldOrder field_order)
 {
@@ -1044,7 +1199,8 @@ static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv,
     }
 
     if (par->codec_id == AV_CODEC_ID_AAC) {
-        ret = get_aac_sample_rates(s, par, &sample_rate, &output_sample_rate);
+        ret = get_aac_sample_rates(s, par->extradata, par->extradata_size, &sample_rate,
+                                   &output_sample_rate);
         if (ret < 0)
             return ret;
     }
@@ -1092,14 +1248,15 @@ static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv,
     } else {
         // look for a codec ID string specific to mkv to use,
         // if none are found, use AVI codes
-        for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
-            if (ff_mkv_codec_tags[j].id == par->codec_id) {
-                put_ebml_string(pb, MATROSKA_ID_CODECID, ff_mkv_codec_tags[j].str);
-                native_id = 1;
-                break;
+        if (par->codec_id != AV_CODEC_ID_RAWVIDEO || par->codec_tag) {
+            for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
+                if (ff_mkv_codec_tags[j].id == par->codec_id && par->codec_id != AV_CODEC_ID_FFV1) {
+                    put_ebml_string(pb, MATROSKA_ID_CODECID, ff_mkv_codec_tags[j].str);
+                    native_id = 1;
+                    break;
+                }
             }
-        }
-        if (par->codec_id == AV_CODEC_ID_RAWVIDEO && !par->codec_tag) {
+        } else {
             if (mkv->allow_raw_vfw) {
                 native_id = 0;
             } else {
@@ -1196,24 +1353,36 @@ static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv,
                 return AVERROR(EINVAL);
             }
             if (d_width != par->width || display_width_div != 1 || display_height_div != 1) {
-                put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width / display_width_div);
-                put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
+                if (mkv->mode == MODE_WEBM || display_width_div != 1 || display_height_div != 1) {
+                    put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , d_width / display_width_div);
+                    put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
+                } else {
+                    AVRational display_aspect_ratio;
+                    av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
+                              par->width  * (int64_t)st->sample_aspect_ratio.num,
+                              par->height * (int64_t)st->sample_aspect_ratio.den,
+                              1024 * 1024);
+                    put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH,  display_aspect_ratio.num);
+                    put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, display_aspect_ratio.den);
+                    put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYUNIT, MATROSKA_VIDEO_DISPLAYUNIT_DAR);
+                }
             }
         } else if (display_width_div != 1 || display_height_div != 1) {
             put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYWIDTH , par->width / display_width_div);
             put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYHEIGHT, par->height / display_height_div);
-        } else
+        } else if (mkv->mode != MODE_WEBM)
             put_ebml_uint(pb, MATROSKA_ID_VIDEODISPLAYUNIT, MATROSKA_VIDEO_DISPLAYUNIT_UNKNOWN);
 
         if (par->codec_id == AV_CODEC_ID_RAWVIDEO) {
             uint32_t color_space = av_le2ne32(par->codec_tag);
             put_ebml_binary(pb, MATROSKA_ID_VIDEOCOLORSPACE, &color_space, sizeof(color_space));
         }
-        if (s->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
-            ret = mkv_write_video_color(pb, par, st);
-            if (ret < 0)
-                return ret;
-        }
+        ret = mkv_write_video_color(pb, par, st);
+        if (ret < 0)
+            return ret;
+        ret = mkv_write_video_projection(s, pb, st);
+        if (ret < 0)
+            return ret;
         end_ebml_master(pb, subinfo);
         break;
 
@@ -1226,6 +1395,8 @@ static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv,
 
         subinfo = start_ebml_master(pb, MATROSKA_ID_TRACKAUDIO, 0);
         put_ebml_uint  (pb, MATROSKA_ID_AUDIOCHANNELS    , par->channels);
+
+        mkv->tracks[i].sample_rate_offset = avio_tell(pb);
         put_ebml_float (pb, MATROSKA_ID_AUDIOSAMPLINGFREQ, sample_rate);
         if (output_sample_rate)
             put_ebml_float(pb, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
@@ -1251,6 +1422,7 @@ static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv,
     }
 
     if (mkv->mode != MODE_WEBM || par->codec_id != AV_CODEC_ID_WEBVTT) {
+        mkv->tracks[i].codecpriv_offset = avio_tell(pb);
         ret = mkv_write_codecprivate(s, pb, par, native_id, qt_id);
         if (ret < 0)
             return ret;
@@ -1264,15 +1436,14 @@ static int mkv_write_track(AVFormatContext *s, MatroskaMuxContext *mkv,
 static int mkv_write_tracks(AVFormatContext *s)
 {
     MatroskaMuxContext *mkv = s->priv_data;
-    AVIOContext *dyn_cp, *pb = s->pb;
-    ebml_master tracks;
+    AVIOContext *pb = s->pb;
     int i, ret, default_stream_exists = 0;
 
     ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TRACKS, avio_tell(pb));
     if (ret < 0)
         return ret;
 
-    ret = start_ebml_master_crc32(pb, &dyn_cp, mkv, &tracks, MATROSKA_ID_TRACKS, 0);
+    ret = start_ebml_master_crc32(pb, &mkv->tracks_bc, mkv, &mkv->tracks_master, MATROSKA_ID_TRACKS, 0);
     if (ret < 0)
         return ret;
 
@@ -1281,11 +1452,16 @@ static int mkv_write_tracks(AVFormatContext *s)
         default_stream_exists |= st->disposition & AV_DISPOSITION_DEFAULT;
     }
     for (i = 0; i < s->nb_streams; i++) {
-        ret = mkv_write_track(s, mkv, i, dyn_cp, default_stream_exists);
+        ret = mkv_write_track(s, mkv, i, mkv->tracks_bc, default_stream_exists);
         if (ret < 0)
             return ret;
     }
-    end_ebml_master_crc32(pb, &dyn_cp, mkv, tracks);
+
+    if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live)
+        end_ebml_master_crc32_preliminary(pb, &mkv->tracks_bc, mkv, mkv->tracks_master);
+    else
+        end_ebml_master_crc32(pb, &mkv->tracks_bc, mkv, mkv->tracks_master);
+
     return 0;
 }
 
@@ -1307,8 +1483,10 @@ static int mkv_write_chapters(AVFormatContext *s)
     if (ret < 0) return ret;
 
     editionentry = start_ebml_master(dyn_cp, MATROSKA_ID_EDITIONENTRY, 0);
-    put_ebml_uint(dyn_cp, MATROSKA_ID_EDITIONFLAGDEFAULT, 1);
-    put_ebml_uint(dyn_cp, MATROSKA_ID_EDITIONFLAGHIDDEN , 0);
+    if (mkv->mode != MODE_WEBM) {
+        put_ebml_uint(dyn_cp, MATROSKA_ID_EDITIONFLAGDEFAULT, 1);
+        put_ebml_uint(dyn_cp, MATROSKA_ID_EDITIONFLAGHIDDEN , 0);
+    }
     for (i = 0; i < s->nb_chapters; i++) {
         ebml_master chapteratom, chapterdisplay;
         AVChapter *c     = s->chapters[i];
@@ -1326,8 +1504,10 @@ static int mkv_write_chapters(AVFormatContext *s)
         put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERUID, c->id + mkv->chapter_id_offset);
         put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMESTART, chapterstart);
         put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERTIMEEND, chapterend);
-        put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERFLAGHIDDEN , 0);
-        put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERFLAGENABLED, 1);
+        if (mkv->mode != MODE_WEBM) {
+            put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERFLAGHIDDEN , 0);
+            put_ebml_uint(dyn_cp, MATROSKA_ID_CHAPTERFLAGENABLED, 1);
+        }
         if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
             chapterdisplay = start_ebml_master(dyn_cp, MATROSKA_ID_CHAPTERDISPLAY, 0);
             put_ebml_string(dyn_cp, MATROSKA_ID_CHAPSTRING, t->value);
@@ -1476,7 +1656,7 @@ static int mkv_write_tags(AVFormatContext *s)
         if (ret < 0) return ret;
     }
 
-    if (s->pb->seekable && !mkv->is_live) {
+    if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
         for (i = 0; i < s->nb_streams; i++) {
             AVIOContext *pb;
             AVStream *st = s->streams[i];
@@ -1501,17 +1681,20 @@ static int mkv_write_tags(AVFormatContext *s)
         }
     }
 
-    for (i = 0; i < s->nb_chapters; i++) {
-        AVChapter *ch = s->chapters[i];
+    if (mkv->mode != MODE_WEBM) {
+        for (i = 0; i < s->nb_chapters; i++) {
+            AVChapter *ch = s->chapters[i];
 
-        if (!mkv_check_tag(ch->metadata, MATROSKA_ID_TAGTARGETS_CHAPTERUID))
-            continue;
+            if (!mkv_check_tag(ch->metadata, MATROSKA_ID_TAGTARGETS_CHAPTERUID))
+                continue;
 
-        ret = mkv_write_tag(s, ch->metadata, MATROSKA_ID_TAGTARGETS_CHAPTERUID, ch->id + mkv->chapter_id_offset, &mkv->tags);
-        if (ret < 0) return ret;
+            ret = mkv_write_tag(s, ch->metadata, MATROSKA_ID_TAGTARGETS_CHAPTERUID, ch->id + mkv->chapter_id_offset, &mkv->tags);
+            if (ret < 0)
+                return ret;
+        }
     }
 
-    if (mkv->have_attachments) {
+    if (mkv->have_attachments && mkv->mode != MODE_WEBM) {
         for (i = 0; i < mkv->attachments->num_entries; i++) {
             mkv_attachment *attachment = &mkv->attachments->entries[i];
             AVStream *st = s->streams[attachment->stream_idx];
@@ -1526,8 +1709,8 @@ static int mkv_write_tags(AVFormatContext *s)
     }
 
     if (mkv->tags.pos) {
-        if (s->pb->seekable && !mkv->is_live)
-            put_ebml_void(s->pb, avio_tell(mkv->tags_bc));
+        if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live)
+            end_ebml_master_crc32_preliminary(s->pb, &mkv->tags_bc, mkv, mkv->tags);
         else
             end_ebml_master_crc32(s->pb, &mkv->tags_bc, mkv, mkv->tags);
     }
@@ -1547,7 +1730,7 @@ static int mkv_write_attachments(AVFormatContext *s)
 
     mkv->attachments = av_mallocz(sizeof(*mkv->attachments));
     if (!mkv->attachments)
-        return ret;
+        return AVERROR(ENOMEM);
 
     av_lfg_init(&c, av_get_random_seed());
 
@@ -1675,6 +1858,13 @@ static int mkv_write_header(AVFormatContext *s)
         av_dict_get(s->metadata, "alpha_mode", NULL, 0))
         version = 4;
 
+    if (s->nb_streams > MAX_TRACKS) {
+        av_log(s, AV_LOG_ERROR,
+               "At most %d streams are supported for muxing in Matroska\n",
+               MAX_TRACKS);
+        return AVERROR(EINVAL);
+    }
+
     for (i = 0; i < s->nb_streams; i++) {
         if (s->streams[i]->codecpar->codec_id == AV_CODEC_ID_ATRAC3 ||
             s->streams[i]->codecpar->codec_id == AV_CODEC_ID_COOK ||
@@ -1783,8 +1973,8 @@ static int mkv_write_header(AVFormatContext *s)
             put_ebml_void(pb, 11);              // assumes double-precision float to be written
         }
     }
-    if (s->pb->seekable)
-        put_ebml_void(s->pb, avio_tell(pb));
+    if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live)
+        end_ebml_master_crc32_preliminary(s->pb, &mkv->info_bc, mkv, mkv->info);
     else
         end_ebml_master_crc32(s->pb, &mkv->info_bc, mkv, mkv->info);
     pb = s->pb;
@@ -1792,6 +1982,10 @@ static int mkv_write_header(AVFormatContext *s)
     // initialize stream_duration fields
     mkv->stream_durations = av_mallocz(s->nb_streams * sizeof(int64_t));
     mkv->stream_duration_offsets = av_mallocz(s->nb_streams * sizeof(int64_t));
+    if (!mkv->stream_durations || !mkv->stream_duration_offsets) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
 
     ret = mkv_write_tracks(s);
     if (ret < 0)
@@ -1800,21 +1994,21 @@ static int mkv_write_header(AVFormatContext *s)
     for (i = 0; i < s->nb_chapters; i++)
         mkv->chapter_id_offset = FFMAX(mkv->chapter_id_offset, 1LL - s->chapters[i]->id);
 
-    if (mkv->mode != MODE_WEBM) {
-        ret = mkv_write_chapters(s);
-        if (ret < 0)
-            goto fail;
+    ret = mkv_write_chapters(s);
+    if (ret < 0)
+        goto fail;
 
+    if (mkv->mode != MODE_WEBM) {
         ret = mkv_write_attachments(s);
         if (ret < 0)
             goto fail;
-
-        ret = mkv_write_tags(s);
-        if (ret < 0)
-            goto fail;
     }
 
-    if (!s->pb->seekable && !mkv->is_live)
+    ret = mkv_write_tags(s);
+    if (ret < 0)
+        goto fail;
+
+    if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live)
         mkv_write_seekhead(pb, mkv);
 
     mkv->cues = mkv_start_cues(mkv->segment_offset);
@@ -1822,7 +2016,7 @@ static int mkv_write_header(AVFormatContext *s)
         ret = AVERROR(ENOMEM);
         goto fail;
     }
-    if (pb->seekable && mkv->reserve_cues_space) {
+    if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && mkv->reserve_cues_space) {
         mkv->cues_pos = avio_tell(pb);
         put_ebml_void(pb, mkv->reserve_cues_space);
     }
@@ -1835,7 +2029,7 @@ static int mkv_write_header(AVFormatContext *s)
 
     // start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
     // after 4k and on a keyframe
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         if (mkv->cluster_time_limit < 0)
             mkv->cluster_time_limit = 5000;
         if (mkv->cluster_size_limit < 0)
@@ -1930,6 +2124,8 @@ static void mkv_write_block(AVFormatContext *s, AVIOContext *pb,
     uint8_t track_number = (mkv->is_dash ? mkv->dash_track_number : (pkt->stream_index + 1));
     ebml_master block_group, block_additions, block_more;
 
+    ts += mkv->tracks[pkt->stream_index].ts_offset;
+
     av_log(s, AV_LOG_DEBUG, "Writing block at offset %" PRIu64 ", size %d, "
            "pts %" PRId64 ", dts %" PRId64 ", duration %" PRId64 ", keyframe %d\n",
            avio_tell(pb), pkt->size, pkt->pts, pkt->dts, pkt->duration,
@@ -2060,7 +2256,7 @@ static void mkv_start_new_cluster(AVFormatContext *s, AVPacket *pkt)
 
     end_ebml_master_crc32(s->pb, &mkv->dyn_bc, mkv, mkv->cluster);
     mkv->cluster_pos = -1;
-    if (s->pb->seekable)
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
         av_log(s, AV_LOG_DEBUG,
                "Starting new cluster at offset %" PRIu64 " bytes, "
                "pts %" PRIu64 "dts %" PRIu64 "\n",
@@ -2072,6 +2268,83 @@ static void mkv_start_new_cluster(AVFormatContext *s, AVPacket *pkt)
     avio_flush(s->pb);
 }
 
+static int mkv_check_new_extra_data(AVFormatContext *s, AVPacket *pkt)
+{
+    MatroskaMuxContext *mkv = s->priv_data;
+    mkv_track *track        = &mkv->tracks[pkt->stream_index];
+    AVCodecParameters *par  = s->streams[pkt->stream_index]->codecpar;
+    uint8_t *side_data;
+    int side_data_size = 0, ret;
+
+    side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,
+                                        &side_data_size);
+
+    switch (par->codec_id) {
+    case AV_CODEC_ID_AAC:
+        if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
+            int filler, output_sample_rate = 0;
+            int64_t curpos;
+            ret = get_aac_sample_rates(s, side_data, side_data_size, &track->sample_rate,
+                                       &output_sample_rate);
+            if (ret < 0)
+                return ret;
+            if (!output_sample_rate)
+                output_sample_rate = track->sample_rate; // Space is already reserved, so it's this or a void element.
+            av_freep(&par->extradata);
+            ret = ff_alloc_extradata(par, side_data_size);
+            if (ret < 0)
+                return ret;
+            memcpy(par->extradata, side_data, side_data_size);
+            curpos = avio_tell(mkv->tracks_bc);
+            avio_seek(mkv->tracks_bc, track->codecpriv_offset, SEEK_SET);
+            mkv_write_codecprivate(s, mkv->tracks_bc, par, 1, 0);
+            filler = MAX_PCE_SIZE + 2 + 4 - (avio_tell(mkv->tracks_bc) - track->codecpriv_offset);
+            if (filler)
+                put_ebml_void(mkv->tracks_bc, filler);
+            avio_seek(mkv->tracks_bc, track->sample_rate_offset, SEEK_SET);
+            put_ebml_float(mkv->tracks_bc, MATROSKA_ID_AUDIOSAMPLINGFREQ, track->sample_rate);
+            put_ebml_float(mkv->tracks_bc, MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, output_sample_rate);
+            avio_seek(mkv->tracks_bc, curpos, SEEK_SET);
+        } else if (!par->extradata_size && !track->sample_rate) {
+            // No extradata (codecpar or packet side data).
+            av_log(s, AV_LOG_ERROR, "Error parsing AAC extradata, unable to determine samplerate.\n");
+            return AVERROR(EINVAL);
+        }
+        break;
+    case AV_CODEC_ID_FLAC:
+        if (side_data_size && (s->pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
+            AVCodecParameters *codecpriv_par;
+            int64_t curpos;
+            if (side_data_size != par->extradata_size) {
+                av_log(s, AV_LOG_ERROR, "Invalid FLAC STREAMINFO metadata for output stream %d\n",
+                       pkt->stream_index);
+                return AVERROR(EINVAL);
+            }
+            codecpriv_par = avcodec_parameters_alloc();
+            if (!codecpriv_par)
+                return AVERROR(ENOMEM);
+            ret = avcodec_parameters_copy(codecpriv_par, par);
+            if (ret < 0) {
+                avcodec_parameters_free(&codecpriv_par);
+                return ret;
+            }
+            memcpy(codecpriv_par->extradata, side_data, side_data_size);
+            curpos = avio_tell(mkv->tracks_bc);
+            avio_seek(mkv->tracks_bc, track->codecpriv_offset, SEEK_SET);
+            mkv_write_codecprivate(s, mkv->tracks_bc, codecpriv_par, 1, 0);
+            avio_seek(mkv->tracks_bc, curpos, SEEK_SET);
+            avcodec_parameters_free(&codecpriv_par);
+        }
+        break;
+    default:
+        if (side_data_size)
+            av_log(s, AV_LOG_DEBUG, "Ignoring new extradata in a packet for stream %d.\n", pkt->stream_index);
+        break;
+    }
+
+    return 0;
+}
+
 static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt, int add_cue)
 {
     MatroskaMuxContext *mkv = s->priv_data;
@@ -2112,7 +2385,7 @@ static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt, int add_
 
     if (par->codec_type != AVMEDIA_TYPE_SUBTITLE) {
         mkv_write_block(s, pb, MATROSKA_ID_SIMPLEBLOCK, pkt, keyframe);
-        if (s->pb->seekable && (par->codec_type == AVMEDIA_TYPE_VIDEO && keyframe || add_cue)) {
+        if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && (par->codec_type == AVMEDIA_TYPE_VIDEO && keyframe || add_cue)) {
             ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, dash_tracknum, ts, mkv->cluster_pos, relative_packet_pos, -1);
             if (ret < 0) return ret;
         }
@@ -2137,7 +2410,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
             end_ebml_master(pb, blockgroup);
         }
 
-        if (s->pb->seekable) {
+        if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
             ret = mkv_add_cuepoint(mkv->cues, pkt->stream_index, dash_tracknum, ts,
                                    mkv->cluster_pos, relative_packet_pos, duration);
             if (ret < 0)
@@ -2164,6 +2437,10 @@ static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
     int ret;
     int start_new_cluster;
 
+    ret = mkv_check_new_extra_data(s, pkt);
+    if (ret < 0)
+        return ret;
+
     if (mkv->tracks[pkt->stream_index].write_dts)
         cluster_time = pkt->dts - mkv->cluster_pts;
     else
@@ -2233,7 +2510,7 @@ static int mkv_write_flush_packet(AVFormatContext *s, AVPacket *pkt)
         if (mkv->cluster_pos != -1) {
             end_ebml_master_crc32(s->pb, &mkv->dyn_bc, mkv, mkv->cluster);
             mkv->cluster_pos = -1;
-            if (s->pb->seekable)
+            if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
                 av_log(s, AV_LOG_DEBUG,
                        "Flushing cluster at offset %" PRIu64 " bytes\n",
                        avio_tell(s->pb));
@@ -2268,13 +2545,12 @@ static int mkv_write_trailer(AVFormatContext *s)
         end_ebml_master_crc32(pb, &mkv->dyn_bc, mkv, mkv->cluster);
     }
 
-    if (mkv->mode != MODE_WEBM) {
-        ret = mkv_write_chapters(s);
-        if (ret < 0)
-            return ret;
-    }
+    ret = mkv_write_chapters(s);
+    if (ret < 0)
+        return ret;
 
-    if (pb->seekable) {
+
+    if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mkv->is_live) {
         if (mkv->cues->num_entries) {
             if (mkv->reserve_cues_space) {
                 int64_t cues_end;
@@ -2317,6 +2593,10 @@ static int mkv_write_trailer(AVFormatContext *s)
         avio_seek(pb, mkv->info.pos, SEEK_SET);
         end_ebml_master_crc32(pb, &mkv->info_bc, mkv, mkv->info);
 
+        // write tracks master
+        avio_seek(pb, mkv->tracks_master.pos, SEEK_SET);
+        end_ebml_master_crc32(pb, &mkv->tracks_bc, mkv, mkv->tracks_master);
+
         // update stream durations
         if (!mkv->is_live && mkv->stream_durations) {
             int i;
@@ -2415,6 +2695,7 @@ static const AVCodecTag additional_audio_tags[] = {
     { AV_CODEC_ID_PCM_S16BE, 0xFFFFFFFF },
     { AV_CODEC_ID_PCM_S24BE, 0xFFFFFFFF },
     { AV_CODEC_ID_PCM_S32BE, 0xFFFFFFFF },
+    { AV_CODEC_ID_QDMC,      0xFFFFFFFF },
     { AV_CODEC_ID_QDM2,      0xFFFFFFFF },
     { AV_CODEC_ID_RA_144,    0xFFFFFFFF },
     { AV_CODEC_ID_RA_288,    0xFFFFFFFF },
diff --git a/mythtv/external/FFmpeg/libavformat/mj2kdec.c b/mythtv/external/FFmpeg/libavformat/mj2kdec.c
new file mode 100644
index 00000000000..1fb94094cc2
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/mj2kdec.c
@@ -0,0 +1,54 @@
+/*
+ * MJPEG 2000 Demuxer
+ * Copyright (c) 2016 Ståle Kristoffersen
+ *
+ * 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/intreadwrite.h"
+#include "avformat.h"
+#include "rawdec.h"
+
+#if CONFIG_MJPEG_2000_DEMUXER
+static int mjpeg2000_probe(AVProbeData *p)
+{
+    const uint8_t *b = p->buf;
+    int i, marker, marker_size;
+    int frames = 0, invalid = 0;
+
+    for (i = 0; i < p->buf_size - 5; i++) {
+        if (AV_RB32(b) == 0xff4fff51){
+            marker_size = AV_RB16(b+4);
+            if (marker_size + i < p->buf_size - 4) {
+                marker = AV_RB8(b+4+marker_size);
+                if (marker == 0xff)
+                    frames++;
+                else
+                    invalid++;
+            }
+        }
+        b += 1;
+    }
+    if (invalid*4 + 1 < frames) {
+        if (invalid == 0 && frames > 2)
+            return AVPROBE_SCORE_EXTENSION / 2;
+        return AVPROBE_SCORE_EXTENSION / 4;
+    }
+    return 0;
+}
+FF_DEF_RAWVIDEO_DEMUXER2(mjpeg_2000, "raw MJPEG 2000 video", mjpeg2000_probe, "j2k", AV_CODEC_ID_JPEG2000, AVFMT_GENERIC_INDEX|AVFMT_NOTIMESTAMPS)
+#endif
diff --git a/mythtv/external/FFmpeg/libavformat/mlvdec.c b/mythtv/external/FFmpeg/libavformat/mlvdec.c
index 665b28d4f8c..319cd26de4f 100644
--- a/mythtv/external/FFmpeg/libavformat/mlvdec.c
+++ b/mythtv/external/FFmpeg/libavformat/mlvdec.c
@@ -242,7 +242,8 @@ static int scan_file(AVFormatContext *avctx, AVStream *vst, AVStream *ast, int f
         } else if (type == MKTAG('N','U','L','L')) {
         } else if (type == MKTAG('M','L','V','I')) { /* occurs when MLV and Mnn files are concatenated */
         } else {
-            av_log(avctx, AV_LOG_INFO, "unsupported tag %c%c%c%c, size %u\n", type&0xFF, (type>>8)&0xFF, (type>>16)&0xFF, (type>>24)&0xFF, size);
+            av_log(avctx, AV_LOG_INFO, "unsupported tag %s, size %u\n",
+                   av_fourcc2str(type), size);
         }
         avio_skip(pb, size);
     }
@@ -449,7 +450,7 @@ static int read_seek(AVFormatContext *avctx, int stream_index, int64_t timestamp
     if ((flags & AVSEEK_FLAG_FRAME) || (flags & AVSEEK_FLAG_BYTE))
         return AVERROR(ENOSYS);
 
-    if (!avctx->pb->seekable)
+    if (!(avctx->pb->seekable & AVIO_SEEKABLE_NORMAL))
         return AVERROR(EIO);
 
     mlv->pts = timestamp;
diff --git a/mythtv/external/FFmpeg/libavformat/mmf.c b/mythtv/external/FFmpeg/libavformat/mmf.c
index b8a9cad32ef..1393627d8ab 100644
--- a/mythtv/external/FFmpeg/libavformat/mmf.c
+++ b/mythtv/external/FFmpeg/libavformat/mmf.c
@@ -147,7 +147,7 @@ static int mmf_write_trailer(AVFormatContext *s)
     int64_t pos, size;
     int gatetime;
 
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         /* Fill in length fields */
         end_tag_be(pb, mmf->awapos);
         end_tag_be(pb, mmf->atrpos);
diff --git a/mythtv/external/FFmpeg/libavformat/mov.c b/mythtv/external/FFmpeg/libavformat/mov.c
index 805f8efc972..7980b162275 100644
--- a/mythtv/external/FFmpeg/libavformat/mov.c
+++ b/mythtv/external/FFmpeg/libavformat/mov.c
@@ -41,9 +41,13 @@
 #include "libavutil/opt.h"
 #include "libavutil/aes.h"
 #include "libavutil/aes_ctr.h"
+#include "libavutil/pixdesc.h"
 #include "libavutil/sha.h"
+#include "libavutil/spherical.h"
+#include "libavutil/stereo3d.h"
 #include "libavutil/timecode.h"
 #include "libavcodec/ac3tab.h"
+#include "libavcodec/flac.h"
 #include "libavcodec/mpegaudiodecheader.h"
 #include "avformat.h"
 #include "internal.h"
@@ -70,6 +74,8 @@ typedef struct MOVParseTableEntry {
 
 static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom);
 static int mov_read_mfra(MOVContext *c, AVIOContext *f);
+static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, unsigned int* allocated_size,
+                              int count, int duration);
 
 static int mov_metadata_track_or_disc_number(MOVContext *c, AVIOContext *pb,
                                              unsigned len, const char *key)
@@ -158,7 +164,11 @@ static int mov_read_mac_string(MOVContext *c, AVIOContext *pb, int len,
 
     for (i = 0; i < len; i++) {
         uint8_t t, c = avio_r8(pb);
-        if (c < 0x80 && p < end)
+
+        if (p >= end)
+            continue;
+
+        if (c < 0x80)
             *p++ = c;
         else if (p < end)
             PUT_UTF8(mac_to_unicode[c-0x80], t, if (p < end) *p++ = t;);
@@ -404,11 +414,11 @@ static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                 return ret;
             } else if (!key && c->found_hdlr_mdta && c->meta_keys) {
                 uint32_t index = AV_RB32(&atom.type);
-                if (index < c->meta_keys_count) {
+                if (index < c->meta_keys_count && index > 0) {
                     key = c->meta_keys[index];
                 } else {
                     av_log(c->fc, AV_LOG_WARNING,
-                           "The index of 'data' is out of range: %d >= %d.\n",
+                           "The index of 'data' is out of range: %"PRId32" < 1 or >= %d.\n",
                            index, c->meta_keys_count);
                 }
             }
@@ -511,9 +521,6 @@ static int mov_read_udta_string(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             }
         }
     }
-    av_log(c->fc, AV_LOG_TRACE, "lang \"%3s\" ", language);
-    av_log(c->fc, AV_LOG_TRACE, "tag \"%s\" value \"%s\" atom \"%.4s\" %d %"PRId64"\n",
-            key, str, (char*)&atom.type, str_size_alloc, atom.size);
 
     av_freep(&str);
     return 0;
@@ -593,7 +600,6 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
         dref->type = avio_rl32(pb);
         avio_rb32(pb); // version + flags
-        av_log(c->fc, AV_LOG_TRACE, "type %.4s size %d\n", (char*)&dref->type, size);
 
         if (dref->type == MKTAG('a','l','i','s') && size > 150) {
             /* macintosh alias record */
@@ -686,7 +692,7 @@ static int mov_read_dref(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                     avio_skip(pb, len);
             }
         } else {
-            av_log(c->fc, AV_LOG_DEBUG, "Unknown dref type 0x08%x size %d\n",
+            av_log(c->fc, AV_LOG_DEBUG, "Unknown dref type 0x%08"PRIx32" size %"PRIu32"\n",
                    dref->type, size);
             entries--;
             i--;
@@ -700,7 +706,7 @@ static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 {
     AVStream *st;
     uint32_t type;
-    uint32_t av_unused ctype;
+    uint32_t ctype;
     int64_t title_size;
     char *title_str;
     int ret;
@@ -712,8 +718,8 @@ static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     ctype = avio_rl32(pb);
     type = avio_rl32(pb); /* component subtype */
 
-    av_log(c->fc, AV_LOG_TRACE, "ctype= %.4s (0x%08x)\n", (char*)&ctype, ctype);
-    av_log(c->fc, AV_LOG_TRACE, "stype= %.4s\n", (char*)&type);
+    av_log(c->fc, AV_LOG_TRACE, "ctype=%s\n", av_fourcc2str(ctype));
+    av_log(c->fc, AV_LOG_TRACE, "stype=%s\n", av_fourcc2str(type));
 
     if (c->trak_index < 0) {  // meta not inside a trak
         if (type == MKTAG('m','d','t','a')) {
@@ -739,6 +745,8 @@ static int mov_read_hdlr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     title_size = atom.size - 24;
     if (title_size > 0) {
+        if (title_size > FFMIN(INT_MAX, SIZE_MAX-1))
+            return AVERROR_INVALIDDATA;
         title_str = av_malloc(title_size + 1); /* Add null terminator */
         if (!title_str)
             return AVERROR(ENOMEM);
@@ -871,7 +879,7 @@ static int mov_read_ddts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     uint32_t channel_layout_code = 0;
     GetBitContext gb;
 
-    buf = av_malloc(ddts_size + FF_INPUT_BUFFER_PADDING_SIZE);
+    buf = av_malloc(ddts_size + AV_INPUT_BUFFER_PADDING_SIZE);
     if (!buf) {
         return AVERROR(ENOMEM);
     }
@@ -883,11 +891,17 @@ static int mov_read_ddts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     init_get_bits(&gb, buf, 8*ddts_size);
 
     if (c->fc->nb_streams < 1) {
+        av_free(buf);
         return 0;
     }
     st = c->fc->streams[c->fc->nb_streams-1];
 
     st->codecpar->sample_rate = get_bits_long(&gb, 32);
+    if (st->codecpar->sample_rate <= 0) {
+        av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
+        av_free(buf);
+        return AVERROR_INVALIDDATA;
+    }
     skip_bits_long(&gb, 32); /* max bitrate */
     st->codecpar->bit_rate = get_bits_long(&gb, 32);
     st->codecpar->bits_per_coded_sample = get_bits(&gb, 8);
@@ -913,6 +927,7 @@ static int mov_read_ddts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             ((channel_layout_code & 0x8) ? AV_CH_LOW_FREQUENCY : 0);
 
     st->codecpar->channels = av_get_channel_layout_nb_channels(st->codecpar->channel_layout);
+    av_free(buf);
 
     return 0;
 }
@@ -1157,7 +1172,7 @@ static int mov_read_moof(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 {
     if (!c->has_looked_for_mfra && c->use_mfra_for > 0) {
         c->has_looked_for_mfra = 1;
-        if (pb->seekable) {
+        if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
             int ret;
             av_log(c->fc, AV_LOG_VERBOSE, "stream has moof boxes, will look "
                     "for a mfra\n");
@@ -1180,6 +1195,12 @@ static void mov_metadata_creation_time(AVDictionary **metadata, int64_t time)
     if (time) {
         if(time >= 2082844800)
             time -= 2082844800;  /* seconds between 1904-01-01 and Epoch */
+
+        if ((int64_t)(time * 1000000ULL) / 1000000 != time) {
+            av_log(NULL, AV_LOG_DEBUG, "creation_time is not representable\n");
+            return;
+        }
+
         avpriv_dict_set_timestamp(metadata, "creation_time", time * 1000000);
     }
 }
@@ -1219,6 +1240,10 @@ static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     mov_metadata_creation_time(&st->metadata, creation_time);
 
     sc->time_scale = avio_rb32(pb);
+    if (sc->time_scale <= 0) {
+        av_log(c->fc, AV_LOG_ERROR, "Invalid mdhd time scale %d, defaulting to 1\n", sc->time_scale);
+        sc->time_scale = 1;
+    }
     st->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
 
     lang = avio_rb16(pb); /* language */
@@ -1231,6 +1256,7 @@ static int mov_read_mdhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
 static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 {
+    int i;
     int64_t creation_time;
     int version = avio_r8(pb); /* version */
     avio_rb24(pb); /* flags */
@@ -1244,7 +1270,10 @@ static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
     mov_metadata_creation_time(&c->fc->metadata, creation_time);
     c->time_scale = avio_rb32(pb); /* time scale */
-
+    if (c->time_scale <= 0) {
+        av_log(c->fc, AV_LOG_ERROR, "Invalid mvhd time scale %d, defaulting to 1\n", c->time_scale);
+        c->time_scale = 1;
+    }
     av_log(c->fc, AV_LOG_TRACE, "time scale = %i\n", c->time_scale);
 
     c->duration = (version == 1) ? avio_rb64(pb) : avio_rb32(pb); /* duration */
@@ -1258,7 +1287,12 @@ static int mov_read_mvhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     avio_skip(pb, 10); /* reserved */
 
-    avio_skip(pb, 36); /* display matrix */
+    /* movie display matrix, store it in main context and use it later on */
+    for (i = 0; i < 3; i++) {
+        c->movie_display_matrix[i][0] = avio_rb32(pb); // 16.16 fixed point
+        c->movie_display_matrix[i][1] = avio_rb32(pb); // 16.16 fixed point
+        c->movie_display_matrix[i][2] = avio_rb32(pb); //  2.30 fixed point
+    }
 
     avio_rb32(pb); /* preview time */
     avio_rb32(pb); /* preview duration */
@@ -1340,12 +1374,14 @@ static int mov_read_colr(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         else
             st->codecpar->color_range = AVCOL_RANGE_MPEG;
     }
-    if (color_primaries >= AVCOL_PRI_NB)
+
+    if (!av_color_primaries_name(color_primaries))
         color_primaries = AVCOL_PRI_UNSPECIFIED;
-    if (color_trc >= AVCOL_TRC_NB)
+    if (!av_color_transfer_name(color_trc))
         color_trc = AVCOL_TRC_UNSPECIFIED;
-    if (color_matrix >= AVCOL_SPC_NB)
+    if (!av_color_space_name(color_matrix))
         color_matrix = AVCOL_SPC_UNSPECIFIED;
+
     st->codecpar->color_primaries = color_primaries;
     st->codecpar->color_trc       = color_trc;
     st->codecpar->color_space     = color_matrix;
@@ -1821,7 +1857,7 @@ static int mov_codec_id(AVStream *st, uint32_t format)
 static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb,
                                  AVStream *st, MOVStreamContext *sc)
 {
-    uint8_t codec_name[32];
+    uint8_t codec_name[32] = { 0 };
     int64_t stsd_start;
     unsigned int len;
 
@@ -1854,14 +1890,14 @@ static void mov_parse_stsd_video(MOVContext *c, AVIOContext *pb,
         av_dict_set(&st->metadata, "encoder", codec_name, 0);
 
     /* codec_tag YV12 triggers an UV swap in rawdec.c */
-    if (!memcmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) {
+    if (!strncmp(codec_name, "Planar Y'CbCr 8-bit 4:2:0", 25)) {
         st->codecpar->codec_tag = MKTAG('I', '4', '2', '0');
         st->codecpar->width &= ~1;
         st->codecpar->height &= ~1;
     }
     /* Flash Media Server uses tag H.263 with Sorenson Spark */
     if (st->codecpar->codec_tag == MKTAG('H','2','6','3') &&
-        !memcmp(codec_name, "Sorenson H263", 13))
+        !strncmp(codec_name, "Sorenson H263", 13))
         st->codecpar->codec_id = AV_CODEC_ID_FLV1;
 
     st->codecpar->bits_per_coded_sample = avio_rb16(pb); /* depth */
@@ -2200,8 +2236,12 @@ static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb,
 
     if (codec_tag &&
          (codec_tag != format &&
+          // AVID 1:1 samples with differing data format and codec tag exist
+          (codec_tag != AV_RL32("AV1x") || format != AV_RL32("AVup")) &&
           // prores is allowed to have differing data format and codec tag
           codec_tag != AV_RL32("apcn") && codec_tag != AV_RL32("apch") &&
+          // so is dv (sigh)
+          codec_tag != AV_RL32("dvpp") && codec_tag != AV_RL32("dvcp") &&
           (c->fc->video_codec_id ? video_codec_id != c->fc->video_codec_id
                                  : codec_tag != MKTAG('j','p','e','g')))) {
         /* Multiple fourcc, we skip JPEG. This is not correct, we should
@@ -2212,10 +2252,6 @@ static int mov_skip_multiple_stsd(MOVContext *c, AVIOContext *pb,
         avio_skip(pb, size);
         return 1;
     }
-    if ( codec_tag == AV_RL32("hvc1") ||
-         codec_tag == AV_RL32("hev1")
-    )
-        av_log(c->fc, AV_LOG_WARNING, "Concatenated H.264 or H.265 might not play correctly.\n");
 
     return 0;
 }
@@ -2263,9 +2299,8 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
         id = mov_codec_id(st, format);
 
         av_log(c->fc, AV_LOG_TRACE,
-               "size=%"PRId64" 4CC= %c%c%c%c/0x%08x codec_type=%d\n", size,
-                (format >> 0) & 0xff, (format >> 8) & 0xff, (format >> 16) & 0xff,
-                (format >> 24) & 0xff, format, st->codecpar->codec_type);
+               "size=%"PRId64" 4CC=%s codec_type=%d\n", size,
+               av_fourcc2str(format), st->codecpar->codec_type);
 
         if (st->codecpar->codec_type==AVMEDIA_TYPE_VIDEO) {
             st->codecpar->codec_id = id;
@@ -2273,6 +2308,10 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
         } else if (st->codecpar->codec_type==AVMEDIA_TYPE_AUDIO) {
             st->codecpar->codec_id = id;
             mov_parse_stsd_audio(c, pb, st, sc);
+            if (st->codecpar->sample_rate < 0) {
+                av_log(c->fc, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
+                return AVERROR_INVALIDDATA;
+            }
         } else if (st->codecpar->codec_type==AVMEDIA_TYPE_SUBTITLE){
             st->codecpar->codec_id = id;
             mov_parse_stsd_subtitle(c, pb, st, sc,
@@ -2291,7 +2330,7 @@ int ff_mov_read_stsd_entries(MOVContext *c, AVIOContext *pb, int entries)
         } else if (a.size > 0)
             avio_skip(pb, a.size);
 
-        if (sc->extradata) {
+        if (sc->extradata && st->codecpar->extradata) {
             int extra_size = st->codecpar->extradata_size;
 
             /* Move the current stream extradata to the stream context one. */
@@ -2315,8 +2354,7 @@ static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 {
     AVStream *st;
     MOVStreamContext *sc;
-    int ret;
-    int entries;
+    int ret, entries;
 
     if (c->fc->nb_streams < 1)
         return 0;
@@ -2325,7 +2363,7 @@ static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     avio_r8(pb); /* version */
     avio_rb24(pb); /* flags */
-    entries = avio_rb32(pb); /* entries */
+    entries = avio_rb32(pb);
 
     if (entries <= 0) {
         av_log(c->fc, AV_LOG_ERROR, "invalid STSD entries %d\n", entries);
@@ -2333,9 +2371,11 @@ static int mov_read_stsd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
 
     if (sc->extradata) {
-        av_log(c->fc, AV_LOG_ERROR, "Duplicate STSD\n");
+        av_log(c->fc, AV_LOG_ERROR,
+               "Duplicate stsd found in this track.\n");
         return AVERROR_INVALIDDATA;
     }
+
     /* Prepare space for hosting multiple extradata. */
     sc->extradata = av_mallocz_array(entries, sizeof(*sc->extradata));
     sc->extradata_size = av_mallocz_array(entries, sizeof(*sc->extradata_size));
@@ -2382,8 +2422,10 @@ static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     avio_rb24(pb); /* flags */
 
     entries = avio_rb32(pb);
+    if ((uint64_t)entries * 12 + 4 > atom.size)
+        return AVERROR_INVALIDDATA;
 
-    av_log(c->fc, AV_LOG_TRACE, "track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
+    av_log(c->fc, AV_LOG_TRACE, "track[%u].stsc.entries = %u\n", c->fc->nb_streams - 1, entries);
 
     if (!entries)
         return 0;
@@ -2409,12 +2451,17 @@ static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
+static inline int mov_stsc_index_valid(unsigned int index, unsigned int count)
+{
+    return index < count - 1;
+}
+
 /* Compute the samples value for the stsc entry at the given index. */
-static inline int mov_get_stsc_samples(MOVStreamContext *sc, int index)
+static inline int mov_get_stsc_samples(MOVStreamContext *sc, unsigned int index)
 {
     int chunk_count;
 
-    if (index < sc->stsc_count - 1)
+    if (mov_stsc_index_valid(index, sc->stsc_count))
         chunk_count = sc->stsc_data[index + 1].first - sc->stsc_data[index].first;
     else
         chunk_count = sc->chunk_count - (sc->stsc_data[index].first - 1);
@@ -2446,7 +2493,6 @@ static int mov_read_stps(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     for (i = 0; i < entries && !pb->eof_reached; i++) {
         sc->stps_data[i] = avio_rb32(pb);
-        //av_log(c->fc, AV_LOG_TRACE, "stps %d\n", sc->stps_data[i]);
     }
 
     sc->stps_count = i;
@@ -2473,7 +2519,7 @@ static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     entries = avio_rb32(pb);
 
-    av_log(c->fc, AV_LOG_TRACE, "keyframe_count = %d\n", entries);
+    av_log(c->fc, AV_LOG_TRACE, "keyframe_count = %u\n", entries);
 
     if (!entries)
     {
@@ -2494,7 +2540,6 @@ static int mov_read_stss(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     for (i = 0; i < entries && !pb->eof_reached; i++) {
         sc->keyframes[i] = avio_rb32(pb);
-        //av_log(c->fc, AV_LOG_TRACE, "keyframes[]=%d\n", sc->keyframes[i]);
     }
 
     sc->keyframe_count = i;
@@ -2535,14 +2580,14 @@ static int mov_read_stsz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
     entries = avio_rb32(pb);
 
-    av_log(c->fc, AV_LOG_TRACE, "sample_size = %d sample_count = %d\n", sc->sample_size, entries);
+    av_log(c->fc, AV_LOG_TRACE, "sample_size = %u sample_count = %u\n", sc->sample_size, entries);
 
     sc->sample_count = entries;
     if (sample_size)
         return 0;
 
     if (field_size != 4 && field_size != 8 && field_size != 16 && field_size != 32) {
-        av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %d\n", field_size);
+        av_log(c->fc, AV_LOG_ERROR, "Invalid sample field size %u\n", field_size);
         return AVERROR_INVALIDDATA;
     }
 
@@ -2607,7 +2652,7 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     avio_rb24(pb); /* flags */
     entries = avio_rb32(pb);
 
-    av_log(c->fc, AV_LOG_TRACE, "track[%i].stts.entries = %i\n",
+    av_log(c->fc, AV_LOG_TRACE, "track[%u].stts.entries = %u\n",
             c->fc->nb_streams-1, entries);
 
     if (sc->stts_data)
@@ -2620,15 +2665,11 @@ static int mov_read_stts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     for (i = 0; i < entries && !pb->eof_reached; i++) {
         int sample_duration;
-        int sample_count;
+        unsigned int sample_count;
 
         sample_count=avio_rb32(pb);
         sample_duration = avio_rb32(pb);
 
-        if (sample_count < 0) {
-            av_log(c->fc, AV_LOG_ERROR, "Invalid sample_count=%d\n", sample_count);
-            return AVERROR_INVALIDDATA;
-        }
         sc->stts_data[i].count= sample_count;
         sc->stts_data[i].duration= sample_duration;
 
@@ -2686,14 +2727,14 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     avio_rb24(pb); /* flags */
     entries = avio_rb32(pb);
 
-    av_log(c->fc, AV_LOG_TRACE, "track[%i].ctts.entries = %i\n", c->fc->nb_streams-1, entries);
+    av_log(c->fc, AV_LOG_TRACE, "track[%u].ctts.entries = %u\n", c->fc->nb_streams - 1, entries);
 
     if (!entries)
         return 0;
     if (entries >= UINT_MAX / sizeof(*sc->ctts_data))
         return AVERROR_INVALIDDATA;
     av_freep(&sc->ctts_data);
-    sc->ctts_data = av_realloc(NULL, entries * sizeof(*sc->ctts_data));
+    sc->ctts_data = av_fast_realloc(NULL, &sc->ctts_allocated_size, entries * sizeof(*sc->ctts_data));
     if (!sc->ctts_data)
         return AVERROR(ENOMEM);
 
@@ -2708,9 +2749,8 @@ static int mov_read_ctts(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             continue;
         }
 
-        sc->ctts_data[ctts_count].count    = count;
-        sc->ctts_data[ctts_count].duration = duration;
-        ctts_count++;
+        add_ctts_entry(&sc->ctts_data, &ctts_count, &sc->ctts_allocated_size,
+                       count, duration);
 
         av_log(c->fc, AV_LOG_TRACE, "count=%d, duration=%d\n",
                 count, duration);
@@ -2805,25 +2845,38 @@ static int get_edit_list_entry(MOVContext *mov,
 }
 
 /**
- * Find the closest previous keyframe to the timestamp, in e_old index
- * entries.
+ * Find the closest previous frame to the timestamp, in e_old index
+ * entries. Searching for just any frame / just key frames can be controlled by
+ * last argument 'flag'.
  * Returns the index of the entry in st->index_entries if successful,
  * else returns -1.
  */
-static int64_t find_prev_closest_keyframe_index(AVStream *st,
-                                                AVIndexEntry *e_old,
-                                                int nb_old,
-                                                int64_t timestamp,
-                                                int flag)
+static int64_t find_prev_closest_index(AVStream *st,
+                                       AVIndexEntry *e_old,
+                                       int nb_old,
+                                       int64_t timestamp,
+                                       int flag)
 {
     AVIndexEntry *e_keep = st->index_entries;
     int nb_keep = st->nb_index_entries;
     int64_t found = -1;
+    int64_t i = 0;
 
     st->index_entries = e_old;
     st->nb_index_entries = nb_old;
     found = av_index_search_timestamp(st, timestamp, flag | AVSEEK_FLAG_BACKWARD);
 
+    // Keep going backwards in the index entries until the timestamp is the same.
+    if (found >= 0) {
+        for (i = found; i > 0 && e_old[i].timestamp == e_old[i - 1].timestamp;
+             i--) {
+            if ((flag & AVSEEK_FLAG_ANY) ||
+                (e_old[i - 1].flags & AVINDEX_KEYFRAME)) {
+                found = i - 1;
+            }
+        }
+    }
+
     /* restore AVStream state*/
     st->index_entries = e_keep;
     st->nb_index_entries = nb_keep;
@@ -2923,6 +2976,52 @@ static int64_t add_ctts_entry(MOVStts** ctts_data, unsigned int* ctts_count, uns
     return *ctts_count;
 }
 
+static void mov_current_sample_inc(MOVStreamContext *sc)
+{
+    sc->current_sample++;
+    sc->current_index++;
+    if (sc->index_ranges &&
+        sc->current_index >= sc->current_index_range->end &&
+        sc->current_index_range->end) {
+        sc->current_index_range++;
+        sc->current_index = sc->current_index_range->start;
+    }
+}
+
+static void mov_current_sample_dec(MOVStreamContext *sc)
+{
+    sc->current_sample--;
+    sc->current_index--;
+    if (sc->index_ranges &&
+        sc->current_index < sc->current_index_range->start &&
+        sc->current_index_range > sc->index_ranges) {
+        sc->current_index_range--;
+        sc->current_index = sc->current_index_range->end - 1;
+    }
+}
+
+static void mov_current_sample_set(MOVStreamContext *sc, int current_sample)
+{
+    int64_t range_size;
+
+    sc->current_sample = current_sample;
+    sc->current_index = current_sample;
+    if (!sc->index_ranges) {
+        return;
+    }
+
+    for (sc->current_index_range = sc->index_ranges;
+        sc->current_index_range->end;
+        sc->current_index_range++) {
+        range_size = sc->current_index_range->end - sc->current_index_range->start;
+        if (range_size > current_sample) {
+            sc->current_index = sc->current_index_range->start + current_sample;
+            break;
+        }
+        current_sample -= range_size;
+    }
+}
+
 /**
  * Fix st->index_entries, so that it contains only the entries (and the entries
  * which are needed to decode them) that fall in the edit list time ranges.
@@ -2947,11 +3046,13 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
     int64_t edit_list_dts_entry_end = 0;
     int64_t edit_list_start_ctts_sample = 0;
     int64_t curr_cts;
+    int64_t curr_ctts = 0;
+    int64_t min_corrected_pts = -1;
+    int64_t empty_edits_sum_duration = 0;
     int64_t edit_list_index = 0;
     int64_t index;
     int64_t index_ctts_count;
     int flags;
-    unsigned int ctts_allocated_size = 0;
     int64_t start_dts = 0;
     int64_t edit_list_media_time_dts = 0;
     int64_t edit_list_start_encountered = 0;
@@ -2960,10 +3061,22 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
     int num_discarded_begin = 0;
     int first_non_zero_audio_edit = -1;
     int packet_skip_samples = 0;
+    MOVIndexRange *current_index_range;
+    int i;
 
-    if (!msc->elst_data || msc->elst_count <= 0) {
+    if (!msc->elst_data || msc->elst_count <= 0 || nb_old <= 0) {
         return;
     }
+
+    // allocate the index ranges array
+    msc->index_ranges = av_malloc((msc->elst_count + 1) * sizeof(msc->index_ranges[0]));
+    if (!msc->index_ranges) {
+        av_log(mov->fc, AV_LOG_ERROR, "Cannot allocate index ranges buffer\n");
+        return;
+    }
+    msc->current_index_range = msc->index_ranges;
+    current_index_range = msc->index_ranges - 1;
+
     // Clean AVStream from traces of old index
     st->index_entries = NULL;
     st->index_entries_allocated_size = 0;
@@ -2974,16 +3087,13 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
     msc->ctts_count = 0;
     msc->ctts_index = 0;
     msc->ctts_sample = 0;
+    msc->ctts_allocated_size = 0;
 
     // If the dts_shift is positive (in case of negative ctts values in mov),
     // then negate the DTS by dts_shift
-    if (msc->dts_shift > 0)
+    if (msc->dts_shift > 0) {
         edit_list_dts_entry_end -= msc->dts_shift;
-
-    // Offset the DTS by ctts[0] to make the PTS of the first frame 0
-    if (ctts_data_old && ctts_count_old > 0) {
-        edit_list_dts_entry_end -= ctts_data_old[0].duration;
-        av_log(mov->fc, AV_LOG_DEBUG, "Offset DTS by ctts[%d].duration: %d\n", 0, ctts_data_old[0].duration);
+        av_log(mov->fc, AV_LOG_DEBUG, "Shifting DTS by %d because of negative CTTS.\n", msc->dts_shift);
     }
 
     start_dts = edit_list_dts_entry_end;
@@ -2997,6 +3107,7 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
         edit_list_dts_entry_end += edit_list_duration;
         num_discarded_begin = 0;
         if (edit_list_media_time == -1) {
+            empty_edits_sum_duration += edit_list_duration;
             continue;
         }
 
@@ -3028,13 +3139,24 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
             // Audio decoders like AAC need need a decoder delay samples previous to the current sample,
             // to correctly decode this frame. Hence for audio we seek to a frame 1 sec. before the
             // edit_list_media_time to cover the decoder delay.
-            search_timestamp = FFMAX(search_timestamp - mov->time_scale, e_old[0].timestamp);
+            search_timestamp = FFMAX(search_timestamp - msc->time_scale, e_old[0].timestamp);
         }
 
-        index = find_prev_closest_keyframe_index(st, e_old, nb_old, search_timestamp, 0);
+        index = find_prev_closest_index(st, e_old, nb_old, search_timestamp, 0);
         if (index == -1) {
-            av_log(mov->fc, AV_LOG_ERROR, "Missing key frame while reordering index according to edit list\n");
-            continue;
+            av_log(mov->fc, AV_LOG_WARNING,
+                   "st: %d edit list: %"PRId64" Missing key frame while searching for timestamp: %"PRId64"\n",
+                   st->index, edit_list_index, search_timestamp);
+            index = find_prev_closest_index(st, e_old, nb_old, search_timestamp, AVSEEK_FLAG_ANY);
+
+            if (index == -1) {
+                av_log(mov->fc, AV_LOG_WARNING,
+                       "st: %d edit list %"PRId64" Cannot find an index entry before timestamp: %"PRId64".\n"
+                       "Rounding edit list media time to zero.\n",
+                       st->index, edit_list_index, search_timestamp);
+                index = 0;
+                edit_list_media_time = 0;
+            }
         }
         current = e_old + index;
 
@@ -3065,15 +3187,17 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
 
             // frames (pts) before or after edit list
             curr_cts = current->timestamp + msc->dts_shift;
+            curr_ctts = 0;
 
             if (ctts_data_old && ctts_index_old < ctts_count_old) {
-                av_log(mov->fc, AV_LOG_DEBUG, "shifted frame pts, curr_cts: %"PRId64" @ %"PRId64", ctts: %d, ctts_count: %"PRId64"\n",
-                       curr_cts, ctts_index_old, ctts_data_old[ctts_index_old].duration, ctts_count_old);
-                curr_cts += ctts_data_old[ctts_index_old].duration;
+                curr_ctts = ctts_data_old[ctts_index_old].duration;
+                av_log(mov->fc, AV_LOG_DEBUG, "stts: %"PRId64" ctts: %"PRId64", ctts_index: %"PRId64", ctts_count: %"PRId64"\n",
+                       curr_cts, curr_ctts, ctts_index_old, ctts_count_old);
+                curr_cts += curr_ctts;
                 ctts_sample_old++;
                 if (ctts_sample_old == ctts_data_old[ctts_index_old].count) {
                     if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
-                                       &ctts_allocated_size,
+                                       &msc->ctts_allocated_size,
                                        ctts_data_old[ctts_index_old].count - edit_list_start_ctts_sample,
                                        ctts_data_old[ctts_index_old].duration) == -1) {
                         av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
@@ -3130,14 +3254,21 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
                         }
                     }
                 }
-            } else if (edit_list_start_encountered == 0) {
-                edit_list_start_encountered = 1;
-                // Make timestamps strictly monotonically increasing for audio, by rewriting timestamps for
-                // discarded packets.
-                if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && frame_duration_buffer) {
-                    fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
-                                               frame_duration_buffer, num_discarded_begin);
-                    av_freep(&frame_duration_buffer);
+            } else {
+                if (min_corrected_pts < 0) {
+                    min_corrected_pts = edit_list_dts_counter + curr_ctts + msc->dts_shift;
+                } else {
+                    min_corrected_pts = FFMIN(min_corrected_pts, edit_list_dts_counter + curr_ctts + msc->dts_shift);
+                }
+                if (edit_list_start_encountered == 0) {
+                    edit_list_start_encountered = 1;
+                    // Make timestamps strictly monotonically increasing for audio, by rewriting timestamps for
+                    // discarded packets.
+                    if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && frame_duration_buffer) {
+                        fix_index_entry_timestamps(st, st->nb_index_entries, edit_list_dts_counter,
+                                                   frame_duration_buffer, num_discarded_begin);
+                        av_freep(&frame_duration_buffer);
+                    }
                 }
             }
 
@@ -3147,6 +3278,13 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
                 break;
             }
 
+            // Update the index ranges array
+            if (current_index_range < msc->index_ranges || index != current_index_range->end) {
+                current_index_range++;
+                current_index_range->start = index;
+            }
+            current_index_range->end = index + 1;
+
             // Only start incrementing DTS in frame_duration amounts, when we encounter a frame in edit list.
             if (edit_list_start_encountered > 0) {
                 edit_list_dts_counter = edit_list_dts_counter + frame_duration;
@@ -3158,7 +3296,7 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
 
                 if (ctts_data_old && ctts_sample_old != 0) {
                     if (add_ctts_entry(&msc->ctts_data, &msc->ctts_count,
-                                       &ctts_allocated_size,
+                                       &msc->ctts_allocated_size,
                                        ctts_sample_old - edit_list_start_ctts_sample,
                                        ctts_data_old[ctts_index_old].duration) == -1) {
                         av_log(mov->fc, AV_LOG_ERROR, "Cannot add CTTS entry %"PRId64" - {%"PRId64", %d}\n",
@@ -3171,12 +3309,32 @@ static void mov_fix_index(MOVContext *mov, AVStream *st)
             }
         }
     }
+    // If there are empty edits, then min_corrected_pts might be positive intentionally. So we subtract the
+    // sum duration of emtpy edits here.
+    min_corrected_pts -= empty_edits_sum_duration;
+
+    // If the minimum pts turns out to be greater than zero after fixing the index, then we subtract the
+    // dts by that amount to make the first pts zero.
+    if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && min_corrected_pts > 0) {
+        av_log(mov->fc, AV_LOG_DEBUG, "Offset DTS by %"PRId64" to make first pts zero.\n", min_corrected_pts);
+        for (i = 0; i < st->nb_index_entries; ++i) {
+            st->index_entries[i].timestamp -= min_corrected_pts;
+        }
+    }
+
     // Update av stream length
     st->duration = edit_list_dts_entry_end - start_dts;
 
     // Free the old index and the old CTTS structures
     av_free(e_old);
     av_free(ctts_data_old);
+    av_freep(&frame_duration_buffer);
+
+    // Null terminate the index ranges array
+    current_index_range++;
+    current_index_range->start = 0;
+    current_index_range->end = 0;
+    msc->current_index = msc->index_ranges[0].start;
 }
 
 static void mov_build_index(MOVContext *mov, AVStream *st)
@@ -3190,9 +3348,11 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
     unsigned int stps_index = 0;
     unsigned int i, j;
     uint64_t stream_size = 0;
+    MOVStts *ctts_data_old = sc->ctts_data;
+    unsigned int ctts_count_old = sc->ctts_count;
 
     if (sc->elst_count) {
-        int i, edit_start_index = 0;
+        int i, edit_start_index = 0, multiple_edits = 0;
         int64_t empty_duration = 0; // empty duration of the first edit list entry
         int64_t start_time = 0; // start time of the media
 
@@ -3205,15 +3365,28 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
                 edit_start_index = 1;
             } else if (i == edit_start_index && e->time >= 0) {
                 start_time = e->time;
+            } else {
+                multiple_edits = 1;
             }
         }
 
+        if (multiple_edits && !mov->advanced_editlist)
+            av_log(mov->fc, AV_LOG_WARNING, "multiple edit list entries, "
+                   "Use -advanced_editlist to correctly decode otherwise "
+                   "a/v desync might occur\n");
+
         /* adjust first dts according to edit list */
         if ((empty_duration || start_time) && mov->time_scale > 0) {
             if (empty_duration)
                 empty_duration = av_rescale(empty_duration, sc->time_scale, mov->time_scale);
             sc->time_offset = start_time - empty_duration;
+            if (!mov->advanced_editlist)
+                current_dts = -sc->time_offset;
         }
+
+        if (!multiple_edits && !mov->advanced_editlist &&
+            st->codecpar->codec_id == AV_CODEC_ID_AAC && start_time > 0)
+            sc->start_pad = start_time;
     }
 
     /* only use old uncompressed audio chunk demuxing when stts specifies it */
@@ -3245,10 +3418,32 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
         }
         st->index_entries_allocated_size = (st->nb_index_entries + sc->sample_count) * sizeof(*st->index_entries);
 
+        if (ctts_data_old) {
+            // Expand ctts entries such that we have a 1-1 mapping with samples
+            if (sc->sample_count >= UINT_MAX / sizeof(*sc->ctts_data))
+                return;
+            sc->ctts_count = 0;
+            sc->ctts_allocated_size = 0;
+            sc->ctts_data = av_fast_realloc(NULL, &sc->ctts_allocated_size,
+                                    sc->sample_count * sizeof(*sc->ctts_data));
+            if (!sc->ctts_data) {
+                av_free(ctts_data_old);
+                return;
+            }
+            for (i = 0; i < ctts_count_old &&
+                        sc->ctts_count < sc->sample_count; i++)
+                for (j = 0; j < ctts_data_old[i].count &&
+                            sc->ctts_count < sc->sample_count; j++)
+                    add_ctts_entry(&sc->ctts_data, &sc->ctts_count,
+                                   &sc->ctts_allocated_size, 1,
+                                   ctts_data_old[i].duration);
+            av_free(ctts_data_old);
+        }
+
         for (i = 0; i < sc->chunk_count; i++) {
             int64_t next_offset = i+1 < sc->chunk_count ? sc->chunk_offsets[i+1] : INT64_MAX;
             current_offset = sc->chunk_offsets[i];
-            while (stsc_index + 1 < sc->stsc_count &&
+            while (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
                 i + 1 == sc->stsc_data[stsc_index + 1].first)
                 stsc_index++;
 
@@ -3307,8 +3502,8 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
                     e->size = sample_size;
                     e->min_distance = distance;
                     e->flags = keyframe ? AVINDEX_KEYFRAME : 0;
-                    av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
-                            "size %d, distance %d, keyframe %d\n", st->index, current_sample,
+                    av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %u, offset %"PRIx64", dts %"PRId64", "
+                            "size %u, distance %u, keyframe %d\n", st->index, current_sample,
                             current_offset, current_dts, sample_size, distance, keyframe);
                     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->nb_index_entries < 100)
                         ff_rfps_add_frame(mov->fc, st, current_dts);
@@ -3371,14 +3566,14 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
                 count = (chunk_samples+1023) / 1024;
             }
 
-            if (i < sc->stsc_count - 1)
+            if (mov_stsc_index_valid(i, sc->stsc_count))
                 chunk_count = sc->stsc_data[i+1].first - sc->stsc_data[i].first;
             else
                 chunk_count = sc->chunk_count - (sc->stsc_data[i].first - 1);
             total += chunk_count * count;
         }
 
-        av_log(mov->fc, AV_LOG_TRACE, "chunk count %d\n", total);
+        av_log(mov->fc, AV_LOG_TRACE, "chunk count %u\n", total);
         if (total >= UINT_MAX / sizeof(*st->index_entries) - st->nb_index_entries)
             return;
         if (av_reallocp_array(&st->index_entries,
@@ -3392,7 +3587,7 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
         // populate index
         for (i = 0; i < sc->chunk_count; i++) {
             current_offset = sc->chunk_offsets[i];
-            if (stsc_index + 1 < sc->stsc_count &&
+            if (mov_stsc_index_valid(stsc_index, sc->stsc_count) &&
                 i + 1 == sc->stsc_data[stsc_index + 1].first)
                 stsc_index++;
             chunk_samples = sc->stsc_data[stsc_index].count;
@@ -3423,7 +3618,7 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
                 }
 
                 if (st->nb_index_entries >= total) {
-                    av_log(mov->fc, AV_LOG_ERROR, "wrong chunk count %d\n", total);
+                    av_log(mov->fc, AV_LOG_ERROR, "wrong chunk count %u\n", total);
                     return;
                 }
                 if (size > 0x3FFFFFFF) {
@@ -3436,9 +3631,9 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
                 e->size = size;
                 e->min_distance = 0;
                 e->flags = AVINDEX_KEYFRAME;
-                av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, chunk %d, offset %"PRIx64", dts %"PRId64", "
-                        "size %d, duration %d\n", st->index, i, current_offset, current_dts,
-                        size, samples);
+                av_log(mov->fc, AV_LOG_TRACE, "AVIndex stream %d, chunk %u, offset %"PRIx64", dts %"PRId64", "
+                       "size %u, duration %u\n", st->index, i, current_offset, current_dts,
+                       size, samples);
 
                 current_offset += size;
                 current_dts += samples;
@@ -3447,8 +3642,10 @@ static void mov_build_index(MOVContext *mov, AVStream *st)
         }
     }
 
-    // Fix index according to edit lists.
-    mov_fix_index(mov, st);
+    if (!mov->ignore_editlist && mov->advanced_editlist) {
+        // Fix index according to edit lists.
+        mov_fix_index(mov, st);
+    }
 }
 
 static int test_same_origin(const char *src, const char *ref) {
@@ -3585,8 +3782,9 @@ static int mov_read_trak(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     c->trak_index = -1;
 
     /* sanity checks */
-    if (sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
-                            (!sc->sample_size && !sc->sample_count))) {
+    if ((sc->chunk_count && (!sc->stts_count || !sc->stsc_count ||
+                            (!sc->sample_size && !sc->sample_count))) ||
+        (!sc->chunk_count && sc->sample_count)) {
         av_log(c->fc, AV_LOG_ERROR, "stream %d, missing mandatory atoms, broken header\n",
                st->index);
         return 0;
@@ -3699,7 +3897,7 @@ static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     count = avio_rb32(pb);
     if (count > UINT_MAX / sizeof(*c->meta_keys) - 1) {
         av_log(c->fc, AV_LOG_ERROR,
-               "The 'keys' atom with the invalid key count: %d\n", count);
+               "The 'keys' atom with the invalid key count: %"PRIu32"\n", count);
         return AVERROR_INVALIDDATA;
     }
 
@@ -3713,7 +3911,8 @@ static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         uint32_t type = avio_rl32(pb);
         if (key_size < 8) {
             av_log(c->fc, AV_LOG_ERROR,
-                   "The key# %d in meta has invalid size: %d\n", i, key_size);
+                   "The key# %"PRIu32" in meta has invalid size:"
+                   "%"PRIu32"\n", i, key_size);
             return AVERROR_INVALIDDATA;
         }
         key_size -= 8;
@@ -3819,12 +4018,22 @@ static int mov_read_meta(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
+// return 1 when matrix is identity, 0 otherwise
+#define IS_MATRIX_IDENT(matrix)            \
+    ( (matrix)[0][0] == (1 << 16) &&       \
+      (matrix)[1][1] == (1 << 16) &&       \
+      (matrix)[2][2] == (1 << 30) &&       \
+     !(matrix)[0][1] && !(matrix)[0][2] && \
+     !(matrix)[1][0] && !(matrix)[1][2] && \
+     !(matrix)[2][0] && !(matrix)[2][1])
+
 static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 {
-    int i;
+    int i, j, e;
     int width;
     int height;
     int display_matrix[3][3];
+    int res_display_matrix[3][3] = { { 0 } };
     AVStream *st;
     MOVStreamContext *sc;
     int version;
@@ -3874,15 +4083,20 @@ static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     sc->width = width >> 16;
     sc->height = height >> 16;
 
-    // save the matrix and add rotate metadata when it is not the default
-    // identity
-    if (display_matrix[0][0] != (1 << 16) ||
-        display_matrix[1][1] != (1 << 16) ||
-        display_matrix[2][2] != (1 << 30) ||
-        display_matrix[0][1] || display_matrix[0][2] ||
-        display_matrix[1][0] || display_matrix[1][2] ||
-        display_matrix[2][0] || display_matrix[2][1]) {
-        int i, j;
+    // apply the moov display matrix (after the tkhd one)
+    for (i = 0; i < 3; i++) {
+        const int sh[3] = { 16, 16, 30 };
+        for (j = 0; j < 3; j++) {
+            for (e = 0; e < 3; e++) {
+                res_display_matrix[i][j] +=
+                    ((int64_t) display_matrix[i][e] *
+                     c->movie_display_matrix[e][j]) >> sh[e];
+            }
+        }
+    }
+
+    // save the matrix when it is not the default identity
+    if (!IS_MATRIX_IDENT(res_display_matrix)) {
         double rotate;
 
         av_freep(&sc->display_matrix);
@@ -3892,8 +4106,9 @@ static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
         for (i = 0; i < 3; i++)
             for (j = 0; j < 3; j++)
-                sc->display_matrix[i * 3 + j] = display_matrix[i][j];
+                sc->display_matrix[i * 3 + j] = res_display_matrix[i][j];
 
+#if FF_API_OLD_ROTATE_API
         rotate = av_display_rotation_get(sc->display_matrix);
         if (!isnan(rotate)) {
             char rotate_buf[64];
@@ -3903,6 +4118,7 @@ static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             snprintf(rotate_buf, sizeof(rotate_buf), "%g", rotate);
             av_dict_set(&st->metadata, "rotate", rotate_buf, 0);
         }
+#endif
     }
 
     // transform the display width/height according to the matrix
@@ -3911,7 +4127,8 @@ static int mov_read_tkhd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         double disp_transform[2];
 
         for (i = 0; i < 2; i++)
-            disp_transform[i] = hypot(display_matrix[i][0], display_matrix[i][1]);
+            disp_transform[i] = hypot(sc->display_matrix[0 + i],
+                                      sc->display_matrix[3 + i]);
 
         if (disp_transform[0] > 0       && disp_transform[1] > 0 &&
             disp_transform[0] < (1<<24) && disp_transform[1] < (1<<24) &&
@@ -4049,7 +4266,7 @@ static int mov_read_tfdt(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         }
     }
     if (!st) {
-        av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %d\n", frag->track_id);
+        av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %u\n", frag->track_id);
         return AVERROR_INVALIDDATA;
     }
     sc = st->priv_data;
@@ -4075,7 +4292,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     int64_t dts;
     int data_offset = 0;
     unsigned entries, first_sample_flags = frag->flags;
-    int flags, distance, i, err;
+    int flags, distance, i;
 
     for (i = 0; i < c->fc->nb_streams; i++) {
         if (c->fc->streams[i]->id == frag->track_id) {
@@ -4084,7 +4301,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         }
     }
     if (!st) {
-        av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %d\n", frag->track_id);
+        av_log(c->fc, AV_LOG_ERROR, "could not find corresponding track id %u\n", frag->track_id);
         return AVERROR_INVALIDDATA;
     }
     sc = st->priv_data;
@@ -4093,31 +4310,10 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     avio_r8(pb); /* version */
     flags = avio_rb24(pb);
     entries = avio_rb32(pb);
-    av_log(c->fc, AV_LOG_TRACE, "flags 0x%x entries %d\n", flags, entries);
-
-    /* Always assume the presence of composition time offsets.
-     * Without this assumption, for instance, we cannot deal with a track in fragmented movies that meet the following.
-     *  1) in the initial movie, there are no samples.
-     *  2) in the first movie fragment, there is only one sample without composition time offset.
-     *  3) in the subsequent movie fragments, there are samples with composition time offset. */
-    if (!sc->ctts_count && sc->sample_count)
-    {
-        /* Complement ctts table if moov atom doesn't have ctts atom. */
-        ctts_data = av_realloc(NULL, sizeof(*sc->ctts_data));
-        if (!ctts_data)
-            return AVERROR(ENOMEM);
-        sc->ctts_data = ctts_data;
-        sc->ctts_data[sc->ctts_count].count = sc->sample_count;
-        sc->ctts_data[sc->ctts_count].duration = 0;
-        sc->ctts_count++;
-    }
+    av_log(c->fc, AV_LOG_TRACE, "flags 0x%x entries %u\n", flags, entries);
+
     if ((uint64_t)entries+sc->ctts_count >= UINT_MAX/sizeof(*sc->ctts_data))
         return AVERROR_INVALIDDATA;
-    if ((err = av_reallocp_array(&sc->ctts_data, entries + sc->ctts_count,
-                                 sizeof(*sc->ctts_data))) < 0) {
-        sc->ctts_count = 0;
-        return err;
-    }
     if (flags & MOV_TRUN_DATA_OFFSET)        data_offset        = avio_rb32(pb);
     if (flags & MOV_TRUN_FIRST_SAMPLE_FLAGS) first_sample_flags = avio_rb32(pb);
     dts    = sc->track_end - sc->time_offset;
@@ -4128,26 +4324,28 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         unsigned sample_size = frag->size;
         int sample_flags = i ? frag->flags : first_sample_flags;
         unsigned sample_duration = frag->duration;
+        unsigned ctts_duration = 0;
         int keyframe = 0;
+        int ctts_index = 0;
+        int old_nb_index_entries = st->nb_index_entries;
 
         if (flags & MOV_TRUN_SAMPLE_DURATION) sample_duration = avio_rb32(pb);
         if (flags & MOV_TRUN_SAMPLE_SIZE)     sample_size     = avio_rb32(pb);
         if (flags & MOV_TRUN_SAMPLE_FLAGS)    sample_flags    = avio_rb32(pb);
-        sc->ctts_data[sc->ctts_count].count = 1;
-        sc->ctts_data[sc->ctts_count].duration = (flags & MOV_TRUN_SAMPLE_CTS) ?
-                                                  avio_rb32(pb) : 0;
-        mov_update_dts_shift(sc, sc->ctts_data[sc->ctts_count].duration);
+        if (flags & MOV_TRUN_SAMPLE_CTS)      ctts_duration   = avio_rb32(pb);
+
+        mov_update_dts_shift(sc, ctts_duration);
         if (frag->time != AV_NOPTS_VALUE) {
             if (c->use_mfra_for == FF_MOV_FLAG_MFRA_PTS) {
                 int64_t pts = frag->time;
                 av_log(c->fc, AV_LOG_DEBUG, "found frag time %"PRId64
                         " sc->dts_shift %d ctts.duration %d"
                         " sc->time_offset %"PRId64" flags & MOV_TRUN_SAMPLE_CTS %d\n", pts,
-                        sc->dts_shift, sc->ctts_data[sc->ctts_count].duration,
+                        sc->dts_shift, ctts_duration,
                         sc->time_offset, flags & MOV_TRUN_SAMPLE_CTS);
                 dts = pts - sc->dts_shift;
                 if (flags & MOV_TRUN_SAMPLE_CTS) {
-                    dts -= sc->ctts_data[sc->ctts_count].duration;
+                    dts -= ctts_duration;
                 } else {
                     dts -= sc->time_offset;
                 }
@@ -4159,7 +4357,7 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             }
             frag->time = AV_NOPTS_VALUE;
         }
-        sc->ctts_count++;
+
         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
             keyframe = 1;
         else
@@ -4168,13 +4366,44 @@ static int mov_read_trun(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                                   MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES));
         if (keyframe)
             distance = 0;
-        err = av_add_index_entry(st, offset, dts, sample_size, distance,
-                                 keyframe ? AVINDEX_KEYFRAME : 0);
-        if (err < 0) {
+        ctts_index = av_add_index_entry(st, offset, dts, sample_size, distance,
+                                        keyframe ? AVINDEX_KEYFRAME : 0);
+        if (ctts_index >= 0 && old_nb_index_entries < st->nb_index_entries) {
+            unsigned int size_needed = st->nb_index_entries * sizeof(*sc->ctts_data);
+            unsigned int request_size = size_needed > sc->ctts_allocated_size ?
+                FFMAX(size_needed, 2 * sc->ctts_allocated_size) : size_needed;
+            unsigned int old_ctts_size = sc->ctts_allocated_size;
+            ctts_data = av_fast_realloc(sc->ctts_data, &sc->ctts_allocated_size, request_size);
+            if (!ctts_data) {
+                av_freep(&sc->ctts_data);
+                return AVERROR(ENOMEM);
+            }
+            sc->ctts_data = ctts_data;
+
+            // In case there were samples without ctts entries, ensure they get
+            // zero valued entries. This ensures clips which mix boxes with and
+            // without ctts entries don't pickup uninitialized data.
+            memset((uint8_t*)(sc->ctts_data) + old_ctts_size, 0, sc->ctts_allocated_size - old_ctts_size);
+
+            if (ctts_index != old_nb_index_entries) {
+                memmove(sc->ctts_data + ctts_index + 1, sc->ctts_data + ctts_index,
+                        sizeof(*sc->ctts_data) * (sc->ctts_count - ctts_index));
+                if (ctts_index <= sc->current_sample) {
+                    // if we inserted a new item before the current sample, move the
+                    // counter ahead so it is still pointing to the same sample.
+                    sc->current_sample++;
+                }
+            }
+
+            sc->ctts_data[ctts_index].count = 1;
+            sc->ctts_data[ctts_index].duration = ctts_duration;
+            sc->ctts_count++;
+        } else {
             av_log(c->fc, AV_LOG_ERROR, "Failed to add index entry\n");
         }
+
         av_log(c->fc, AV_LOG_TRACE, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
-                "size %d, distance %d, keyframe %d\n", st->index, sc->sample_count+i,
+                "size %u, distance %d, keyframe %d\n", st->index, ctts_index,
                 offset, dts, sample_size, distance, keyframe);
         distance++;
         dts += sample_duration;
@@ -4202,7 +4431,8 @@ static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     uint8_t version;
     unsigned i, track_id;
     AVStream *st = NULL;
-    MOVStreamContext *sc;
+    AVStream *ref_st = NULL;
+    MOVStreamContext *sc, *ref_sc = NULL;
     MOVFragmentIndex *index = NULL;
     MOVFragmentIndex **tmp;
     AVRational timescale;
@@ -4231,6 +4461,11 @@ static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     timescale = av_make_q(1, avio_rb32(pb));
 
+    if (timescale.den <= 0) {
+        av_log(c->fc, AV_LOG_ERROR, "Invalid sidx timescale 1/%d\n", timescale.den);
+        return AVERROR_INVALIDDATA;
+    }
+
     if (version == 0) {
         pts = avio_rb32(pb);
         offset += avio_rb32(pb);
@@ -4284,9 +4519,26 @@ static int mov_read_sidx(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     c->fragment_index_data = tmp;
     c->fragment_index_data[c->fragment_index_count++] = index;
+    sc->has_sidx = 1;
+
+    if (offset == avio_size(pb)) {
+        for (i = 0; i < c->fc->nb_streams; i++) {
+            if (c->fc->streams[i]->id == c->fragment_index_data[0]->track_id) {
+                ref_st = c->fc->streams[i];
+                ref_sc = ref_st->priv_data;
+                break;
+            }
+        }
+        for (i = 0; i < c->fc->nb_streams; i++) {
+            st = c->fc->streams[i];
+            sc = st->priv_data;
+            if (!sc->has_sidx) {
+                st->duration = sc->track_end = av_rescale(ref_st->duration, sc->time_scale, ref_sc->time_scale);
+            }
+        }
 
-    if (offset == avio_size(pb))
         c->fragment_index_complete = 1;
+    }
 
     return 0;
 }
@@ -4390,7 +4642,7 @@ static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     if (!sc->elst_data)
         return AVERROR(ENOMEM);
 
-    av_log(c->fc, AV_LOG_TRACE, "track[%i].edit_count = %i\n", c->fc->nb_streams-1, edit_count);
+    av_log(c->fc, AV_LOG_TRACE, "track[%u].edit_count = %i\n", c->fc->nb_streams - 1, edit_count);
     for (i = 0; i < edit_count && !pb->eof_reached; i++) {
         MOVElst *e = &sc->elst_data[i];
 
@@ -4403,7 +4655,14 @@ static int mov_read_elst(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         }
         e->rate = avio_rb32(pb) / 65536.0;
         av_log(c->fc, AV_LOG_TRACE, "duration=%"PRId64" time=%"PRId64" rate=%f\n",
-                e->duration, e->time, e->rate);
+               e->duration, e->time, e->rate);
+
+        if (e->time < 0 && e->time != -1 &&
+            c->fc->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
+            av_log(c->fc, AV_LOG_ERROR, "Track %d, edit %d: Invalid edit list media time=%"PRId64"\n",
+                   c->fc->nb_streams-1, i, e->time);
+            return AVERROR_INVALIDDATA;
+        }
     }
     sc->elst_count = i;
 
@@ -4421,9 +4680,357 @@ static int mov_read_tmcd(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
+static int mov_read_vpcc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+{
+    AVStream *st;
+    int version, color_range, color_primaries, color_trc, color_space;
+
+    if (c->fc->nb_streams < 1)
+        return 0;
+    st = c->fc->streams[c->fc->nb_streams - 1];
+
+    if (atom.size < 5) {
+        av_log(c->fc, AV_LOG_ERROR, "Empty VP Codec Configuration box\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    version = avio_r8(pb);
+    if (version != 1) {
+        av_log(c->fc, AV_LOG_WARNING, "Unsupported VP Codec Configuration box version %d\n", version);
+        return 0;
+    }
+    avio_skip(pb, 3); /* flags */
+
+    avio_skip(pb, 2); /* profile + level */
+    color_range     = avio_r8(pb); /* bitDepth, chromaSubsampling, videoFullRangeFlag */
+    color_primaries = avio_r8(pb);
+    color_trc       = avio_r8(pb);
+    color_space     = avio_r8(pb);
+    if (avio_rb16(pb)) /* codecIntializationDataSize */
+        return AVERROR_INVALIDDATA;
+
+    if (!av_color_primaries_name(color_primaries))
+        color_primaries = AVCOL_PRI_UNSPECIFIED;
+    if (!av_color_transfer_name(color_trc))
+        color_trc = AVCOL_TRC_UNSPECIFIED;
+    if (!av_color_space_name(color_space))
+        color_space = AVCOL_SPC_UNSPECIFIED;
+
+    st->codecpar->color_range     = (color_range & 1) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
+    st->codecpar->color_primaries = color_primaries;
+    st->codecpar->color_trc       = color_trc;
+    st->codecpar->color_space     = color_space;
+
+    return 0;
+}
+
+static int mov_read_smdm(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+{
+    MOVStreamContext *sc;
+    const int chroma_den = 50000;
+    const int luma_den = 10000;
+    int i, j, version;
+
+    if (c->fc->nb_streams < 1)
+        return AVERROR_INVALIDDATA;
+
+    sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
+
+    if (atom.size < 5) {
+        av_log(c->fc, AV_LOG_ERROR, "Empty Mastering Display Metadata box\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    version = avio_r8(pb);
+    if (version) {
+        av_log(c->fc, AV_LOG_WARNING, "Unsupported Mastering Display Metadata box version %d\n", version);
+        return 0;
+    }
+    avio_skip(pb, 3); /* flags */
+
+    sc->mastering = av_mastering_display_metadata_alloc();
+    if (!sc->mastering)
+        return AVERROR(ENOMEM);
+
+    for (i = 0; i < 3; i++)
+        for (j = 0; j < 2; j++)
+            sc->mastering->display_primaries[i][j] =
+                av_make_q(lrint(((double)avio_rb16(pb) / (1 << 16)) * chroma_den), chroma_den);
+    for (i = 0; i < 2; i++)
+        sc->mastering->white_point[i] =
+            av_make_q(lrint(((double)avio_rb16(pb) / (1 << 16)) * chroma_den), chroma_den);
+    sc->mastering->max_luminance =
+        av_make_q(lrint(((double)avio_rb32(pb) / (1 <<  8)) * luma_den), luma_den);
+    sc->mastering->min_luminance =
+        av_make_q(lrint(((double)avio_rb32(pb) / (1 << 14)) * luma_den), luma_den);
+
+    sc->mastering->has_primaries = 1;
+    sc->mastering->has_luminance = 1;
+
+    return 0;
+}
+
+static int mov_read_coll(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+{
+    MOVStreamContext *sc;
+    int version;
+
+    if (c->fc->nb_streams < 1)
+        return AVERROR_INVALIDDATA;
+
+    sc = c->fc->streams[c->fc->nb_streams - 1]->priv_data;
+
+    if (atom.size < 5) {
+        av_log(c->fc, AV_LOG_ERROR, "Empty Content Light Level box\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    version = avio_r8(pb);
+    if (version) {
+        av_log(c->fc, AV_LOG_WARNING, "Unsupported Content Light Level box version %d\n", version);
+        return 0;
+    }
+    avio_skip(pb, 3); /* flags */
+
+    sc->coll = av_content_light_metadata_alloc(&sc->coll_size);
+    if (!sc->coll)
+        return AVERROR(ENOMEM);
+
+    sc->coll->MaxCLL  = avio_rb16(pb);
+    sc->coll->MaxFALL = avio_rb16(pb);
+
+    return 0;
+}
+
+static int mov_read_st3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+{
+    AVStream *st;
+    MOVStreamContext *sc;
+    enum AVStereo3DType type;
+    int mode;
+
+    if (c->fc->nb_streams < 1)
+        return 0;
+
+    st = c->fc->streams[c->fc->nb_streams - 1];
+    sc = st->priv_data;
+
+    if (atom.size < 5) {
+        av_log(c->fc, AV_LOG_ERROR, "Empty stereoscopic video box\n");
+        return AVERROR_INVALIDDATA;
+    }
+    avio_skip(pb, 4); /* version + flags */
+
+    mode = avio_r8(pb);
+    switch (mode) {
+    case 0:
+        type = AV_STEREO3D_2D;
+        break;
+    case 1:
+        type = AV_STEREO3D_TOPBOTTOM;
+        break;
+    case 2:
+        type = AV_STEREO3D_SIDEBYSIDE;
+        break;
+    default:
+        av_log(c->fc, AV_LOG_WARNING, "Unknown st3d mode value %d\n", mode);
+        return 0;
+    }
+
+    sc->stereo3d = av_stereo3d_alloc();
+    if (!sc->stereo3d)
+        return AVERROR(ENOMEM);
+
+    sc->stereo3d->type = type;
+    return 0;
+}
+
+static int mov_read_sv3d(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+{
+    AVStream *st;
+    MOVStreamContext *sc;
+    int size, layout;
+    int32_t yaw, pitch, roll;
+    uint32_t l = 0, t = 0, r = 0, b = 0;
+    uint32_t tag, padding = 0;
+    enum AVSphericalProjection projection;
+
+    if (c->fc->nb_streams < 1)
+        return 0;
+
+    st = c->fc->streams[c->fc->nb_streams - 1];
+    sc = st->priv_data;
+
+    if (atom.size < 8) {
+        av_log(c->fc, AV_LOG_ERROR, "Empty spherical video box\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    size = avio_rb32(pb);
+    if (size <= 12 || size > atom.size)
+        return AVERROR_INVALIDDATA;
+
+    tag = avio_rl32(pb);
+    if (tag != MKTAG('s','v','h','d')) {
+        av_log(c->fc, AV_LOG_ERROR, "Missing spherical video header\n");
+        return 0;
+    }
+    avio_skip(pb, 4); /*  version + flags */
+    avio_skip(pb, size - 12); /* metadata_source */
+
+    size = avio_rb32(pb);
+    if (size > atom.size)
+        return AVERROR_INVALIDDATA;
+
+    tag = avio_rl32(pb);
+    if (tag != MKTAG('p','r','o','j')) {
+        av_log(c->fc, AV_LOG_ERROR, "Missing projection box\n");
+        return 0;
+    }
+
+    size = avio_rb32(pb);
+    if (size > atom.size)
+        return AVERROR_INVALIDDATA;
+
+    tag = avio_rl32(pb);
+    if (tag != MKTAG('p','r','h','d')) {
+        av_log(c->fc, AV_LOG_ERROR, "Missing projection header box\n");
+        return 0;
+    }
+    avio_skip(pb, 4); /*  version + flags */
+
+    /* 16.16 fixed point */
+    yaw   = avio_rb32(pb);
+    pitch = avio_rb32(pb);
+    roll  = avio_rb32(pb);
+
+    size = avio_rb32(pb);
+    if (size > atom.size)
+        return AVERROR_INVALIDDATA;
+
+    tag = avio_rl32(pb);
+    avio_skip(pb, 4); /*  version + flags */
+    switch (tag) {
+    case MKTAG('c','b','m','p'):
+        layout = avio_rb32(pb);
+        if (layout) {
+            av_log(c->fc, AV_LOG_WARNING,
+                   "Unsupported cubemap layout %d\n", layout);
+            return 0;
+        }
+        projection = AV_SPHERICAL_CUBEMAP;
+        padding = avio_rb32(pb);
+        break;
+    case MKTAG('e','q','u','i'):
+        t = avio_rb32(pb);
+        b = avio_rb32(pb);
+        l = avio_rb32(pb);
+        r = avio_rb32(pb);
+
+        if (b >= UINT_MAX - t || r >= UINT_MAX - l) {
+            av_log(c->fc, AV_LOG_ERROR,
+                   "Invalid bounding rectangle coordinates "
+                   "%"PRIu32",%"PRIu32",%"PRIu32",%"PRIu32"\n", l, t, r, b);
+            return AVERROR_INVALIDDATA;
+        }
+
+        if (l || t || r || b)
+            projection = AV_SPHERICAL_EQUIRECTANGULAR_TILE;
+        else
+            projection = AV_SPHERICAL_EQUIRECTANGULAR;
+        break;
+    default:
+        av_log(c->fc, AV_LOG_ERROR, "Unknown projection type\n");
+        return 0;
+    }
+
+    sc->spherical = av_spherical_alloc(&sc->spherical_size);
+    if (!sc->spherical)
+        return AVERROR(ENOMEM);
+
+    sc->spherical->projection = projection;
+
+    sc->spherical->yaw   = yaw;
+    sc->spherical->pitch = pitch;
+    sc->spherical->roll  = roll;
+
+    sc->spherical->padding = padding;
+
+    sc->spherical->bound_left   = l;
+    sc->spherical->bound_top    = t;
+    sc->spherical->bound_right  = r;
+    sc->spherical->bound_bottom = b;
+
+    return 0;
+}
+
+static int mov_parse_uuid_spherical(MOVStreamContext *sc, AVIOContext *pb, size_t len)
+{
+    int ret = 0;
+    uint8_t *buffer = av_malloc(len + 1);
+    const char *val;
+
+    if (!buffer)
+        return AVERROR(ENOMEM);
+    buffer[len] = '\0';
+
+    ret = ffio_read_size(pb, buffer, len);
+    if (ret < 0)
+        goto out;
+
+    /* Check for mandatory keys and values, try to support XML as best-effort */
+    if (av_stristr(buffer, "<GSpherical:StitchingSoftware>") &&
+        (val = av_stristr(buffer, "<GSpherical:Spherical>")) &&
+        av_stristr(val, "true") &&
+        (val = av_stristr(buffer, "<GSpherical:Stitched>")) &&
+        av_stristr(val, "true") &&
+        (val = av_stristr(buffer, "<GSpherical:ProjectionType>")) &&
+        av_stristr(val, "equirectangular")) {
+        sc->spherical = av_spherical_alloc(&sc->spherical_size);
+        if (!sc->spherical)
+            goto out;
+
+        sc->spherical->projection = AV_SPHERICAL_EQUIRECTANGULAR;
+
+        if (av_stristr(buffer, "<GSpherical:StereoMode>")) {
+            enum AVStereo3DType mode;
+
+            if (av_stristr(buffer, "left-right"))
+                mode = AV_STEREO3D_SIDEBYSIDE;
+            else if (av_stristr(buffer, "top-bottom"))
+                mode = AV_STEREO3D_TOPBOTTOM;
+            else
+                mode = AV_STEREO3D_2D;
+
+            sc->stereo3d = av_stereo3d_alloc();
+            if (!sc->stereo3d)
+                goto out;
+
+            sc->stereo3d->type = mode;
+        }
+
+        /* orientation */
+        val = av_stristr(buffer, "<GSpherical:InitialViewHeadingDegrees>");
+        if (val)
+            sc->spherical->yaw = strtol(val, NULL, 10) * (1 << 16);
+        val = av_stristr(buffer, "<GSpherical:InitialViewPitchDegrees>");
+        if (val)
+            sc->spherical->pitch = strtol(val, NULL, 10) * (1 << 16);
+        val = av_stristr(buffer, "<GSpherical:InitialViewRollDegrees>");
+        if (val)
+            sc->spherical->roll = strtol(val, NULL, 10) * (1 << 16);
+    }
+
+out:
+    av_free(buffer);
+    return ret;
+}
+
 static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 {
-    int ret;
+    AVStream *st;
+    MOVStreamContext *sc;
+    int64_t ret;
     uint8_t uuid[16];
     static const uint8_t uuid_isml_manifest[] = {
         0xa5, 0xd4, 0x0b, 0x30, 0xe8, 0x14, 0x11, 0xdd,
@@ -4433,10 +5040,19 @@ static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         0xbe, 0x7a, 0xcf, 0xcb, 0x97, 0xa9, 0x42, 0xe8,
         0x9c, 0x71, 0x99, 0x94, 0x91, 0xe3, 0xaf, 0xac
     };
+    static const uint8_t uuid_spherical[] = {
+        0xff, 0xcc, 0x82, 0x63, 0xf8, 0x55, 0x4a, 0x93,
+        0x88, 0x14, 0x58, 0x7a, 0x02, 0x52, 0x1f, 0xdd,
+    };
 
-    if (atom.size < sizeof(uuid) || atom.size == INT64_MAX)
+    if (atom.size < sizeof(uuid) || atom.size >= FFMIN(INT_MAX, SIZE_MAX))
         return AVERROR_INVALIDDATA;
 
+    if (c->fc->nb_streams < 1)
+        return 0;
+    st = c->fc->streams[c->fc->nb_streams - 1];
+    sc = st->priv_data;
+
     ret = avio_read(pb, uuid, sizeof(uuid));
     if (ret < 0) {
         return ret;
@@ -4490,25 +5106,36 @@ static int mov_read_uuid(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     } else if (!memcmp(uuid, uuid_xmp, sizeof(uuid))) {
         uint8_t *buffer;
         size_t len = atom.size - sizeof(uuid);
-
-        buffer = av_mallocz(len + 1);
-        if (!buffer) {
-            return AVERROR(ENOMEM);
-        }
-        ret = avio_read(pb, buffer, len);
-        if (ret < 0) {
-            av_free(buffer);
-            return ret;
-        } else if (ret != len) {
-            av_free(buffer);
-            return AVERROR_INVALIDDATA;
-        }
         if (c->export_xmp) {
+            buffer = av_mallocz(len + 1);
+            if (!buffer) {
+                return AVERROR(ENOMEM);
+            }
+            ret = avio_read(pb, buffer, len);
+            if (ret < 0) {
+                av_free(buffer);
+                return ret;
+            } else if (ret != len) {
+                av_free(buffer);
+                return AVERROR_INVALIDDATA;
+            }
             buffer[len] = '\0';
             av_dict_set(&c->fc->metadata, "xmp", buffer, 0);
+            av_free(buffer);
+        } else {
+            // skip all uuid atom, which makes it fast for long uuid-xmp file
+            ret = avio_skip(pb, len);
+            if (ret < 0)
+                return ret;
         }
-        av_free(buffer);
-    }
+    } else if (!memcmp(uuid, uuid_spherical, sizeof(uuid))) {
+        size_t len = atom.size - sizeof(uuid);
+        ret = mov_parse_uuid_spherical(sc, pb, len);
+        if (ret < 0)
+            return ret;
+        if (!sc->spherical)
+            av_log(c->fc, AV_LOG_WARNING, "Invalid spherical metadata found\n");    }
+
     return 0;
 }
 
@@ -4597,8 +5224,8 @@ static int mov_read_senc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     avio_rb32(pb);        /* entries */
 
-    if (atom.size < 8) {
-        av_log(c->fc, AV_LOG_ERROR, "senc atom size %"PRId64" too small\n", atom.size);
+    if (atom.size < 8 || atom.size > FFMIN(INT_MAX, SIZE_MAX)) {
+        av_log(c->fc, AV_LOG_ERROR, "senc atom size %"PRId64" invalid\n", atom.size);
         return AVERROR_INVALIDDATA;
     }
 
@@ -4611,8 +5238,8 @@ static int mov_read_senc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     }
 
     sc->cenc.auxiliary_info_end = sc->cenc.auxiliary_info + auxiliary_info_size;
-
     sc->cenc.auxiliary_info_pos = sc->cenc.auxiliary_info;
+    sc->cenc.auxiliary_info_index = 0;
 
     if (avio_read(pb, sc->cenc.auxiliary_info, auxiliary_info_size) != auxiliary_info_size) {
         av_log(c->fc, AV_LOG_ERROR, "failed to read the auxiliary info");
@@ -4666,6 +5293,11 @@ static int mov_read_saiz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
         return 0;
     }
 
+    if (atom.size > FFMIN(INT_MAX, SIZE_MAX)) {
+        av_log(c->fc, AV_LOG_ERROR, "saiz atom auxiliary_info_sizes size %"PRId64" invalid\n", atom.size);
+        return AVERROR_INVALIDDATA;
+    }
+
     /* save the auxiliary info sizes as is */
     data_size = atom.size - atom_header_size;
 
@@ -4684,12 +5316,87 @@ static int mov_read_saiz(MOVContext *c, AVIOContext *pb, MOVAtom atom)
     return 0;
 }
 
-static int cenc_filter(MOVContext *c, MOVStreamContext *sc, uint8_t *input, int size)
+static int mov_read_dfla(MOVContext *c, AVIOContext *pb, MOVAtom atom)
+{
+    AVStream *st;
+    int last, type, size, ret;
+    uint8_t buf[4];
+
+    if (c->fc->nb_streams < 1)
+        return 0;
+    st = c->fc->streams[c->fc->nb_streams-1];
+
+    if ((uint64_t)atom.size > (1<<30) || atom.size < 42)
+        return AVERROR_INVALIDDATA;
+
+    /* Check FlacSpecificBox version. */
+    if (avio_r8(pb) != 0)
+        return AVERROR_INVALIDDATA;
+
+    avio_rb24(pb); /* Flags */
+
+    avio_read(pb, buf, sizeof(buf));
+    flac_parse_block_header(buf, &last, &type, &size);
+
+    if (type != FLAC_METADATA_TYPE_STREAMINFO || size != FLAC_STREAMINFO_SIZE) {
+        av_log(c->fc, AV_LOG_ERROR, "STREAMINFO must be first FLACMetadataBlock\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    ret = ff_get_extradata(c->fc, st->codecpar, pb, size);
+    if (ret < 0)
+        return ret;
+
+    if (!last)
+        av_log(c->fc, AV_LOG_WARNING, "non-STREAMINFO FLACMetadataBlock(s) ignored\n");
+
+    return 0;
+}
+
+static int mov_seek_auxiliary_info(MOVContext *c, MOVStreamContext *sc, int64_t index)
+{
+    size_t auxiliary_info_seek_offset = 0;
+    int i;
+
+    if (sc->cenc.auxiliary_info_default_size) {
+        auxiliary_info_seek_offset = (size_t)sc->cenc.auxiliary_info_default_size * index;
+    } else if (sc->cenc.auxiliary_info_sizes) {
+        if (index > sc->cenc.auxiliary_info_sizes_count) {
+            av_log(c, AV_LOG_ERROR, "current sample %"PRId64" greater than the number of auxiliary info sample sizes %"SIZE_SPECIFIER"\n",
+                index, sc->cenc.auxiliary_info_sizes_count);
+            return AVERROR_INVALIDDATA;
+        }
+
+        for (i = 0; i < index; i++) {
+            auxiliary_info_seek_offset += sc->cenc.auxiliary_info_sizes[i];
+        }
+    }
+
+    if (auxiliary_info_seek_offset > sc->cenc.auxiliary_info_end - sc->cenc.auxiliary_info) {
+        av_log(c, AV_LOG_ERROR, "auxiliary info offset %"SIZE_SPECIFIER" greater than auxiliary info size %"SIZE_SPECIFIER"\n",
+            auxiliary_info_seek_offset, (size_t)(sc->cenc.auxiliary_info_end - sc->cenc.auxiliary_info));
+        return AVERROR_INVALIDDATA;
+    }
+
+    sc->cenc.auxiliary_info_pos = sc->cenc.auxiliary_info + auxiliary_info_seek_offset;
+    sc->cenc.auxiliary_info_index = index;
+    return 0;
+}
+
+static int cenc_filter(MOVContext *c, MOVStreamContext *sc, int64_t index, uint8_t *input, int size)
 {
     uint32_t encrypted_bytes;
     uint16_t subsample_count;
     uint16_t clear_bytes;
     uint8_t* input_end = input + size;
+    int ret;
+
+    if (index != sc->cenc.auxiliary_info_index) {
+        ret = mov_seek_auxiliary_info(c, sc, index);
+        if (ret < 0) {
+            return ret;
+        }
+    }
 
     /* read the iv */
     if (AES_CTR_IV_SIZE > sc->cenc.auxiliary_info_end - sc->cenc.auxiliary_info_pos) {
@@ -4747,35 +5454,54 @@ static int cenc_filter(MOVContext *c, MOVStreamContext *sc, uint8_t *input, int
         return AVERROR_INVALIDDATA;
     }
 
+    sc->cenc.auxiliary_info_index++;
     return 0;
 }
 
-static int mov_seek_auxiliary_info(AVFormatContext *s, MOVStreamContext *sc)
+static int mov_read_dops(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 {
-    size_t auxiliary_info_seek_offset = 0;
-    int i;
+    const int OPUS_SEEK_PREROLL_MS = 80;
+    AVStream *st;
+    size_t size;
+    int16_t pre_skip;
 
-    if (sc->cenc.auxiliary_info_default_size) {
-        auxiliary_info_seek_offset = (size_t)sc->cenc.auxiliary_info_default_size * sc->current_sample;
-    } else if (sc->cenc.auxiliary_info_sizes) {
-        if (sc->current_sample > sc->cenc.auxiliary_info_sizes_count) {
-            av_log(s, AV_LOG_ERROR, "current sample %d greater than the number of auxiliary info sample sizes %"SIZE_SPECIFIER"\n",
-                sc->current_sample, sc->cenc.auxiliary_info_sizes_count);
-            return AVERROR_INVALIDDATA;
-        }
+    if (c->fc->nb_streams < 1)
+        return 0;
+    st = c->fc->streams[c->fc->nb_streams-1];
 
-        for (i = 0; i < sc->current_sample; i++) {
-            auxiliary_info_seek_offset += sc->cenc.auxiliary_info_sizes[i];
-        }
-    }
+    if ((uint64_t)atom.size > (1<<30) || atom.size < 11)
+        return AVERROR_INVALIDDATA;
 
-    if (auxiliary_info_seek_offset > sc->cenc.auxiliary_info_end - sc->cenc.auxiliary_info) {
-        av_log(s, AV_LOG_ERROR, "auxiliary info offset %"SIZE_SPECIFIER" greater than auxiliary info size %"SIZE_SPECIFIER"\n",
-            auxiliary_info_seek_offset, (size_t)(sc->cenc.auxiliary_info_end - sc->cenc.auxiliary_info));
+    /* Check OpusSpecificBox version. */
+    if (avio_r8(pb) != 0) {
+        av_log(c->fc, AV_LOG_ERROR, "unsupported OpusSpecificBox version\n");
         return AVERROR_INVALIDDATA;
     }
 
-    sc->cenc.auxiliary_info_pos = sc->cenc.auxiliary_info + auxiliary_info_seek_offset;
+    /* OpusSpecificBox size plus magic for Ogg OpusHead header. */
+    size = atom.size + 8;
+
+    if (ff_alloc_extradata(st->codecpar, size))
+        return AVERROR(ENOMEM);
+
+    AV_WL32(st->codecpar->extradata, MKTAG('O','p','u','s'));
+    AV_WL32(st->codecpar->extradata + 4, MKTAG('H','e','a','d'));
+    AV_WB8(st->codecpar->extradata + 8, 1); /* OpusHead version */
+    avio_read(pb, st->codecpar->extradata + 9, size - 9);
+
+    /* OpusSpecificBox is stored in big-endian, but OpusHead is
+       little-endian; aside from the preceeding magic and version they're
+       otherwise currently identical.  Data after output gain at offset 16
+       doesn't need to be bytewapped. */
+    pre_skip = AV_RB16(st->codecpar->extradata + 10);
+    AV_WL16(st->codecpar->extradata + 10, pre_skip);
+    AV_WL32(st->codecpar->extradata + 12, AV_RB32(st->codecpar->extradata + 12));
+    AV_WL16(st->codecpar->extradata + 16, AV_RB16(st->codecpar->extradata + 16));
+
+    st->codecpar->initial_padding = pre_skip;
+    st->codecpar->seek_preroll = av_rescale_q(OPUS_SEEK_PREROLL_MS,
+                                              (AVRational){1, 1000},
+                                              (AVRational){1, 48000});
 
     return 0;
 }
@@ -4858,6 +5584,13 @@ static const MOVParseTableEntry mov_default_parse_table[] = {
 { MKTAG('f','r','m','a'), mov_read_frma },
 { MKTAG('s','e','n','c'), mov_read_senc },
 { MKTAG('s','a','i','z'), mov_read_saiz },
+{ MKTAG('d','f','L','a'), mov_read_dfla },
+{ MKTAG('s','t','3','d'), mov_read_st3d }, /* stereoscopic 3D video box */
+{ MKTAG('s','v','3','d'), mov_read_sv3d }, /* spherical video box */
+{ MKTAG('d','O','p','s'), mov_read_dops },
+{ MKTAG('S','m','D','m'), mov_read_smdm },
+{ MKTAG('C','o','L','L'), mov_read_coll },
+{ MKTAG('v','p','c','C'), mov_read_vpcc },
 { 0, NULL }
 };
 
@@ -4875,7 +5608,7 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     if (atom.size < 0)
         atom.size = INT64_MAX;
-    while (total_size + 8 <= atom.size && !avio_feof(pb)) {
+    while (total_size <= atom.size - 8 && !avio_feof(pb)) {
         int (*parse)(MOVContext*, AVIOContext*, MOVAtom) = NULL;
         a.size = atom.size;
         a.type=0;
@@ -4884,6 +5617,7 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
             a.type = avio_rl32(pb);
             if (a.type == MKTAG('f','r','e','e') &&
                 a.size >= 8 &&
+                c->fc->strict_std_compliance < FF_COMPLIANCE_STRICT &&
                 c->moov_retry) {
                 uint8_t buf[8];
                 uint32_t *type = (uint32_t *)buf + 1;
@@ -4913,8 +5647,8 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                 total_size += 8;
             }
         }
-        av_log(c->fc, AV_LOG_TRACE, "type: %08x '%.4s' parent:'%.4s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
-                a.type, (char*)&a.type, (char*)&atom.type, a.size, total_size, atom.size);
+        av_log(c->fc, AV_LOG_TRACE, "type:'%s' parent:'%s' sz: %"PRId64" %"PRId64" %"PRId64"\n",
+               av_fourcc2str(a.type), av_fourcc2str(atom.type), a.size, total_size, atom.size);
         if (a.size == 0) {
             a.size = atom.size - total_size + 8;
         }
@@ -4953,9 +5687,9 @@ static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
                 return err;
             }
             if (c->found_moov && c->found_mdat &&
-                ((!pb->seekable || c->fc->flags & AVFMT_FLAG_IGNIDX || c->fragment_index_complete) ||
+                ((!(pb->seekable & AVIO_SEEKABLE_NORMAL) || c->fc->flags & AVFMT_FLAG_IGNIDX || c->fragment_index_complete) ||
                  start_pos + a.size == avio_size(pb))) {
-                if (!pb->seekable || c->fc->flags & AVFMT_FLAG_IGNIDX || c->fragment_index_complete)
+                if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) || c->fc->flags & AVFMT_FLAG_IGNIDX || c->fragment_index_complete)
                     c->next_root_atom = start_pos + a.size;
                 c->atom_depth --;
                 return 0;
@@ -5267,6 +6001,7 @@ static int mov_read_close(AVFormatContext *s)
         av_freep(&sc->elst_data);
         av_freep(&sc->rap_group);
         av_freep(&sc->display_matrix);
+        av_freep(&sc->index_ranges);
 
         if (sc->extradata)
             for (j = 0; j < sc->stsd_count; j++)
@@ -5277,6 +6012,11 @@ static int mov_read_close(AVFormatContext *s)
         av_freep(&sc->cenc.auxiliary_info);
         av_freep(&sc->cenc.auxiliary_info_sizes);
         av_aes_ctr_free(sc->cenc.aes_ctr);
+
+        av_freep(&sc->stereo3d);
+        av_freep(&sc->spherical);
+        av_freep(&sc->mastering);
+        av_freep(&sc->coll);
     }
 
     if (mov->dv_demux) {
@@ -5302,6 +6042,7 @@ static int mov_read_close(AVFormatContext *s)
     av_freep(&mov->fragment_index_data);
 
     av_freep(&mov->aes_decrypt);
+    av_freep(&mov->chapter_tracks);
 
     return 0;
 }
@@ -5380,6 +6121,13 @@ static int read_tfra(MOVContext *mov, AVIOContext *f)
     }
     for (i = 0; i < index->item_count; i++) {
         int64_t time, offset;
+
+        if (avio_feof(f)) {
+            index->item_count = 0;
+            av_freep(&index->items);
+            return AVERROR_INVALIDDATA;
+        }
+
         if (version == 1) {
             time   = avio_rb64(f);
             offset = avio_rb64(f);
@@ -5463,7 +6211,7 @@ static int mov_read_header(AVFormatContext *s)
     mov->fc = s;
     mov->trak_index = -1;
     /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */
-    if (pb->seekable)
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL)
         atom.size = avio_size(pb);
     else
         atom.size = INT64_MAX;
@@ -5477,7 +6225,7 @@ static int mov_read_header(AVFormatContext *s)
         mov_read_close(s);
         return err;
     }
-    } while (pb->seekable && !mov->found_moov && !mov->moov_retry++);
+    } while ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !mov->found_moov && !mov->moov_retry++);
     if (!mov->found_moov) {
         av_log(s, AV_LOG_ERROR, "moov atom not found\n");
         mov_read_close(s);
@@ -5485,7 +6233,7 @@ static int mov_read_header(AVFormatContext *s)
     }
     av_log(mov->fc, AV_LOG_TRACE, "on_parse_exit_offset=%"PRId64"\n", avio_tell(pb));
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         if (mov->nb_chapter_tracks > 0 && !mov->ignore_chapters)
             mov_read_chapters(s);
         for (i = 0; i < s->nb_streams; i++)
@@ -5550,8 +6298,15 @@ static int mov_read_header(AVFormatContext *s)
         for (i = 0; i < s->nb_streams; i++) {
             AVStream *st = s->streams[i];
             MOVStreamContext *sc = st->priv_data;
-            if (st->duration > 0)
+            if (st->duration > 0) {
+                if (sc->data_size > INT64_MAX / sc->time_scale / 8) {
+                    av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %"PRId64" * 8 * %d\n",
+                           sc->data_size, sc->time_scale);
+                    mov_read_close(s);
+                    return AVERROR_INVALIDDATA;
+                }
                 st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale / st->duration;
+            }
         }
     }
 
@@ -5560,6 +6315,12 @@ static int mov_read_header(AVFormatContext *s)
             AVStream *st = s->streams[i];
             MOVStreamContext *sc = st->priv_data;
             if (sc->duration_for_fps > 0) {
+                if (sc->data_size > INT64_MAX / sc->time_scale / 8) {
+                    av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %"PRId64" * 8 * %d\n",
+                           sc->data_size, sc->time_scale);
+                    mov_read_close(s);
+                    return AVERROR_INVALIDDATA;
+                }
                 st->codecpar->bit_rate = sc->data_size * 8 * sc->time_scale /
                     sc->duration_for_fps;
             }
@@ -5588,27 +6349,61 @@ static int mov_read_header(AVFormatContext *s)
             break;
         case AVMEDIA_TYPE_VIDEO:
             if (sc->display_matrix) {
-                AVPacketSideData *sd, *tmp;
+                err = av_stream_add_side_data(st, AV_PKT_DATA_DISPLAYMATRIX, (uint8_t*)sc->display_matrix,
+                                              sizeof(int32_t) * 9);
+                if (err < 0)
+                    return err;
 
-                tmp = av_realloc_array(st->side_data,
-                                       st->nb_side_data + 1, sizeof(*tmp));
-                if (!tmp)
-                    return AVERROR(ENOMEM);
+                sc->display_matrix = NULL;
+            }
+            if (sc->stereo3d) {
+                err = av_stream_add_side_data(st, AV_PKT_DATA_STEREO3D,
+                                              (uint8_t *)sc->stereo3d,
+                                              sizeof(*sc->stereo3d));
+                if (err < 0)
+                    return err;
 
-                st->side_data = tmp;
-                st->nb_side_data++;
+                sc->stereo3d = NULL;
+            }
+            if (sc->spherical) {
+                err = av_stream_add_side_data(st, AV_PKT_DATA_SPHERICAL,
+                                              (uint8_t *)sc->spherical,
+                                              sc->spherical_size);
+                if (err < 0)
+                    return err;
 
-                sd = &st->side_data[st->nb_side_data - 1];
-                sd->type = AV_PKT_DATA_DISPLAYMATRIX;
-                sd->size = sizeof(int32_t) * 9;
-                sd->data = (uint8_t*)sc->display_matrix;
-                sc->display_matrix = NULL;
+                sc->spherical = NULL;
+            }
+            if (sc->mastering) {
+                err = av_stream_add_side_data(st, AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
+                                              (uint8_t *)sc->mastering,
+                                              sizeof(*sc->mastering));
+                if (err < 0)
+                    return err;
+
+                sc->mastering = NULL;
+            }
+            if (sc->coll) {
+                err = av_stream_add_side_data(st, AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
+                                              (uint8_t *)sc->coll,
+                                              sc->coll_size);
+                if (err < 0)
+                    return err;
+
+                sc->coll = NULL;
             }
             break;
         }
     }
     ff_configure_buffers_for_index(s, AV_TIME_BASE);
 
+    for (i = 0; i < mov->fragment_index_count; i++) {
+        MOVFragmentIndex *idx = mov->fragment_index_data[i];
+        for (j = 0; j < idx->item_count; j++)
+            if (idx->items[j].moof_offset <= mov->fragment.moof_offset)
+                idx->items[j].headers_read = 1;
+    }
+
     return 0;
 }
 
@@ -5624,8 +6419,8 @@ static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
             AVIndexEntry *current_sample = &avst->index_entries[msc->current_sample];
             int64_t dts = av_rescale(current_sample->timestamp, AV_TIME_BASE, msc->time_scale);
             av_log(s, AV_LOG_TRACE, "stream %d, sample %d, dts %"PRId64"\n", i, msc->current_sample, dts);
-            if (!sample || (!s->pb->seekable && current_sample->pos < sample->pos) ||
-                (s->pb->seekable &&
+            if (!sample || (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) && current_sample->pos < sample->pos) ||
+                ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
                  ((msc->pb != s->pb && dts < best_dts) || (msc->pb == s->pb &&
                  ((FFABS(best_dts - dts) <= 4*AV_TIME_BASE && current_sample->pos < sample->pos) ||
                   (FFABS(best_dts - dts) > 4*AV_TIME_BASE && dts < best_dts)))))) {
@@ -5647,6 +6442,7 @@ static int should_retry(AVIOContext *pb, int error_code) {
 
 static int mov_switch_root(AVFormatContext *s, int64_t target)
 {
+    int ret;
     MOVContext *mov = s->priv_data;
     int i, j;
     int already_read = 0;
@@ -5683,8 +6479,10 @@ static int mov_switch_root(AVFormatContext *s, int64_t target)
 
     mov->found_mdat = 0;
 
-    if (mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||
-        avio_feof(s->pb))
+    ret = mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX });
+    if (ret < 0)
+        return ret;
+    if (avio_feof(s->pb))
         return AVERROR_EOF;
     av_log(s, AV_LOG_TRACE, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb));
 
@@ -5720,6 +6518,7 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
     MOVStreamContext *sc;
     AVIndexEntry *sample;
     AVStream *st = NULL;
+    int64_t current_index;
     int ret;
     mov->fc = s;
  retry:
@@ -5733,7 +6532,8 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
     }
     sc = st->priv_data;
     /* must be done just before reading, to avoid infinite loop on sample */
-    sc->current_sample++;
+    current_index = sc->current_index;
+    mov_current_sample_inc(sc);
 
     if (mov->next_root_atom) {
         sample->pos = FFMIN(sample->pos, mov->next_root_atom);
@@ -5745,7 +6545,9 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
         if (ret64 != sample->pos) {
             av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
                    sc->ffindex, sample->pos);
-            sc->current_sample -= should_retry(sc->pb, ret64);
+            if (should_retry(sc->pb, ret64)) {
+                mov_current_sample_dec(sc);
+            }
             return AVERROR_INVALIDDATA;
         }
 
@@ -5756,7 +6558,9 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
 
         ret = av_get_packet(sc->pb, pkt, sample->size);
         if (ret < 0) {
-            sc->current_sample -= should_retry(sc->pb, ret);
+            if (should_retry(sc->pb, ret)) {
+                mov_current_sample_dec(sc);
+            }
             return ret;
         }
         if (sc->has_palette) {
@@ -5816,7 +6620,7 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
         /* Keep track of the stsc index for the given sample, then check
         * if the stsd index is different from the last used one. */
         sc->stsc_sample++;
-        if (sc->stsc_index < sc->stsc_count - 1 &&
+        if (mov_stsc_index_valid(sc->stsc_index, sc->stsc_count) &&
             mov_get_stsc_samples(sc, sc->stsc_index) == sc->stsc_sample) {
             sc->stsc_index++;
             sc->stsc_sample = 0;
@@ -5834,7 +6638,7 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
         aax_filter(pkt->data, pkt->size, mov);
 
     if (sc->cenc.aes_ctr) {
-        ret = cenc_filter(mov, sc, pkt->data, pkt->size);
+        ret = cenc_filter(mov, sc, current_index, pkt->data, pkt->size);
         if (ret) {
             return ret;
         }
@@ -5846,13 +6650,14 @@ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
 static int mov_seek_fragment(AVFormatContext *s, AVStream *st, int64_t timestamp)
 {
     MOVContext *mov = s->priv_data;
+    MOVStreamContext *sc = st->priv_data;
     int i, j;
 
     if (!mov->fragment_index_complete)
         return 0;
 
     for (i = 0; i < mov->fragment_index_count; i++) {
-        if (mov->fragment_index_data[i]->track_id == st->id) {
+        if (mov->fragment_index_data[i]->track_id == st->id || !sc->has_sidx) {
             MOVFragmentIndex *index = mov->fragment_index_data[i];
             for (j = index->item_count - 1; j >= 0; j--) {
                 if (index->items[j].time <= timestamp) {
@@ -5872,7 +6677,7 @@ static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp,
 {
     MOVStreamContext *sc = st->priv_data;
     int sample, time_sample;
-    int i;
+    unsigned int i;
 
     int ret = mov_seek_fragment(s, st, timestamp);
     if (ret < 0)
@@ -5884,7 +6689,7 @@ static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp,
         sample = 0;
     if (sample < 0) /* not sure what to do */
         return AVERROR_INVALIDDATA;
-    sc->current_sample = sample;
+    mov_current_sample_set(sc, sample);
     av_log(s, AV_LOG_TRACE, "stream %d, found sample %d\n", st->index, sc->current_sample);
     /* adjust ctts index */
     if (sc->ctts_data) {
@@ -5912,11 +6717,6 @@ static int mov_seek_stream(AVFormatContext *s, AVStream *st, int64_t timestamp,
         time_sample = next;
     }
 
-    ret = mov_seek_auxiliary_info(s, sc);
-    if (ret < 0) {
-        return ret;
-    }
-
     return sample;
 }
 
@@ -5956,7 +6756,7 @@ static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_ti
             MOVStreamContext *sc;
             st = s->streams[i];
             sc = st->priv_data;
-            sc->current_sample = 0;
+            mov_current_sample_set(sc, 0);
         }
         while (1) {
             MOVStreamContext *sc;
@@ -5966,7 +6766,7 @@ static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_ti
             sc = st->priv_data;
             if (sc->ffindex == stream_index && sc->current_sample == sample)
                 break;
-            sc->current_sample++;
+            mov_current_sample_inc(sc);
         }
     }
     return 0;
@@ -5983,7 +6783,11 @@ static const AVOption mov_options[] = {
         "Seek each stream individually to the to the closest point",
         OFFSET(seek_individually), AV_OPT_TYPE_BOOL, { .i64 = 1 },
         0, 1, FLAGS},
-    {"ignore_editlist", "", OFFSET(ignore_editlist), AV_OPT_TYPE_BOOL, {.i64 = 0},
+    {"ignore_editlist", "Ignore the edit list atom.", OFFSET(ignore_editlist), AV_OPT_TYPE_BOOL, {.i64 = 0},
+        0, 1, FLAGS},
+    {"advanced_editlist",
+        "Modify the AVIndex according to the editlists. Use this option to decode in the order specified by the edits.",
+        OFFSET(advanced_editlist), AV_OPT_TYPE_BOOL, {.i64 = 1},
         0, 1, FLAGS},
     {"ignore_chapters", "", OFFSET(ignore_chapters), AV_OPT_TYPE_BOOL, {.i64 = 0},
         0, 1, FLAGS},
diff --git a/mythtv/external/FFmpeg/libavformat/mov_chan.c b/mythtv/external/FFmpeg/libavformat/mov_chan.c
index dc8bf8dccc3..324dd5f9139 100644
--- a/mythtv/external/FFmpeg/libavformat/mov_chan.c
+++ b/mythtv/external/FFmpeg/libavformat/mov_chan.c
@@ -557,8 +557,9 @@ int ff_mov_read_chan(AVFormatContext *s, AVIOContext *pb, AVStream *st,
     bitmap     = avio_rb32(pb);
     num_descr  = avio_rb32(pb);
 
-    av_log(s, AV_LOG_TRACE, "chan: layout=%u bitmap=%u num_descr=%u\n",
-            layout_tag, bitmap, num_descr);
+    av_log(s, AV_LOG_TRACE, "chan: layout=%"PRIu32" "
+           "bitmap=%"PRIu32" num_descr=%"PRIu32"\n",
+           layout_tag, bitmap, num_descr);
 
     if (size < 12ULL + num_descr * 20ULL)
         return 0;
diff --git a/mythtv/external/FFmpeg/libavformat/movenc.c b/mythtv/external/FFmpeg/libavformat/movenc.c
index 6228192f989..28382861418 100644
--- a/mythtv/external/FFmpeg/libavformat/movenc.c
+++ b/mythtv/external/FFmpeg/libavformat/movenc.c
@@ -33,7 +33,10 @@
 #include "avc.h"
 #include "libavcodec/ac3_parser.h"
 #include "libavcodec/dnxhddata.h"
+#include "libavcodec/flac.h"
 #include "libavcodec/get_bits.h"
+
+#include "libavcodec/internal.h"
 #include "libavcodec/put_bits.h"
 #include "libavcodec/vc1_common.h"
 #include "libavcodec/raw.h"
@@ -45,6 +48,7 @@
 #include "libavutil/opt.h"
 #include "libavutil/dict.h"
 #include "libavutil/pixdesc.h"
+#include "libavutil/stereo3d.h"
 #include "libavutil/timecode.h"
 #include "libavutil/color_utils.h"
 #include "hevc.h"
@@ -72,6 +76,8 @@ static const AVOption options[] = {
     { "write_colr", "Write colr atom (Experimental, may be renamed or changed, do not use from scripts)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_WRITE_COLR}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
     { "write_gama", "Write deprecated gama atom", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_WRITE_GAMA}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
     { "use_metadata_tags", "Use mdta atom for metadata.", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_USE_MDTA}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+    { "skip_trailer", "Skip writing the mfra/tfra/mfro trailer for fragmented files", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_SKIP_TRAILER}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+    { "negative_cts_offsets", "Use negative CTS offsets (reducing the need for edit lists)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
     FF_RTP_FLAG_OPTS(MOVMuxContext, rtp_flags),
     { "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext, iods_skip), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
     { "iods_audio_profile", "iods audio profile atom.", offsetof(MOVMuxContext, iods_audio_profile), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 255, AV_OPT_FLAG_ENCODING_PARAM},
@@ -432,8 +438,8 @@ static int handle_eac3(MOVMuxContext *mov, AVPacket *pkt, MOVTrack *track)
         return AVERROR_INVALIDDATA;
 
     if (!info->num_blocks) {
-        int ret;
-        if ((ret = av_copy_packet(&info->pkt, pkt)) < 0)
+        int ret = av_packet_ref(&info->pkt, pkt);
+        if (ret < 0)
             return ret;
         info->num_blocks = num_blocks;
         return 0;
@@ -449,7 +455,8 @@ static int handle_eac3(MOVMuxContext *mov, AVPacket *pkt, MOVTrack *track)
         if (info->num_blocks != 6)
             return 0;
         av_packet_unref(pkt);
-        if ((ret = av_copy_packet(pkt, &info->pkt)) < 0)
+        ret = av_packet_ref(pkt, &info->pkt);
+        if (ret < 0)
             return ret;
         av_packet_unref(&info->pkt);
         info->num_blocks = 0;
@@ -654,6 +661,49 @@ static int mov_write_wfex_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *tra
     return update_size(pb, pos);
 }
 
+static int mov_write_dfla_tag(AVIOContext *pb, MOVTrack *track)
+{
+    int64_t pos = avio_tell(pb);
+    avio_wb32(pb, 0);
+    ffio_wfourcc(pb, "dfLa");
+    avio_w8(pb, 0); /* version */
+    avio_wb24(pb, 0); /* flags */
+
+    /* Expect the encoder to pass a METADATA_BLOCK_TYPE_STREAMINFO. */
+    if (track->par->extradata_size != FLAC_STREAMINFO_SIZE)
+        return AVERROR_INVALIDDATA;
+
+    /* TODO: Write other METADATA_BLOCK_TYPEs if the encoder makes them available. */
+    avio_w8(pb, 1 << 7 | FLAC_METADATA_TYPE_STREAMINFO); /* LastMetadataBlockFlag << 7 | BlockType */
+    avio_wb24(pb, track->par->extradata_size); /* Length */
+    avio_write(pb, track->par->extradata, track->par->extradata_size); /* BlockData[Length] */
+
+    return update_size(pb, pos);
+}
+
+static int mov_write_dops_tag(AVIOContext *pb, MOVTrack *track)
+{
+    int64_t pos = avio_tell(pb);
+    avio_wb32(pb, 0);
+    ffio_wfourcc(pb, "dOps");
+    avio_w8(pb, 0); /* Version */
+    if (track->par->extradata_size < 19) {
+        av_log(pb, AV_LOG_ERROR, "invalid extradata size\n");
+        return AVERROR_INVALIDDATA;
+    }
+    /* extradata contains an Ogg OpusHead, other than byte-ordering and
+       OpusHead's preceeding magic/version, OpusSpecificBox is currently
+       identical. */
+    avio_w8(pb, AV_RB8(track->par->extradata + 9)); /* OuputChannelCount */
+    avio_wb16(pb, AV_RL16(track->par->extradata + 10)); /* PreSkip */
+    avio_wb32(pb, AV_RL32(track->par->extradata + 12)); /* InputSampleRate */
+    avio_wb16(pb, AV_RL16(track->par->extradata + 16)); /* OutputGain */
+    /* Write the rest of the header out without byte-swapping. */
+    avio_write(pb, track->par->extradata + 18, track->par->extradata_size - 18);
+
+    return update_size(pb, pos);
+}
+
 static int mov_write_chan_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
 {
     uint32_t layout_tag, bitmap;
@@ -963,14 +1013,26 @@ static int mov_write_audio_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContex
                 avio_wb16(pb, 16);
             avio_wb16(pb, track->audio_vbr ? -2 : 0); /* compression ID */
         } else { /* reserved for mp4/3gp */
-            avio_wb16(pb, 2);
-            avio_wb16(pb, 16);
+            if (track->par->codec_id == AV_CODEC_ID_FLAC ||
+                track->par->codec_id == AV_CODEC_ID_OPUS) {
+                avio_wb16(pb, track->par->channels);
+            } else {
+                avio_wb16(pb, 2);
+            }
+            if (track->par->codec_id == AV_CODEC_ID_FLAC) {
+                avio_wb16(pb, track->par->bits_per_raw_sample);
+            } else {
+                avio_wb16(pb, 16);
+            }
             avio_wb16(pb, 0);
         }
 
         avio_wb16(pb, 0); /* packet size (= 0) */
-        avio_wb16(pb, track->par->sample_rate <= UINT16_MAX ?
-                      track->par->sample_rate : 0);
+        if (track->par->codec_id == AV_CODEC_ID_OPUS)
+            avio_wb16(pb, 48000);
+        else
+            avio_wb16(pb, track->par->sample_rate <= UINT16_MAX ?
+                          track->par->sample_rate : 0);
         avio_wb16(pb, 0); /* Reserved */
     }
 
@@ -1009,6 +1071,10 @@ static int mov_write_audio_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContex
         mov_write_extradata_tag(pb, track);
     else if (track->par->codec_id == AV_CODEC_ID_WMAPRO)
         mov_write_wfex_tag(s, pb, track);
+    else if (track->par->codec_id == AV_CODEC_ID_FLAC)
+        mov_write_dfla_tag(pb, track);
+    else if (track->par->codec_id == AV_CODEC_ID_OPUS)
+        mov_write_dops_tag(pb, track);
     else if (track->vos_len > 0)
         mov_write_glbl_tag(pb, track);
 
@@ -1050,7 +1116,8 @@ static int mov_write_vpcc_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *tra
 
     avio_wb32(pb, 0);
     ffio_wfourcc(pb, "vpcC");
-    avio_wb32(pb, 0); /* version & flags */
+    avio_w8(pb, 1); /* version */
+    avio_wb24(pb, 0); /* flags */
     ff_isom_write_vpcc(s, pb, track->par);
     return update_size(pb, pos);
 }
@@ -1061,7 +1128,10 @@ static int mov_write_hvcc_tag(AVIOContext *pb, MOVTrack *track)
 
     avio_wb32(pb, 0);
     ffio_wfourcc(pb, "hvcC");
-    ff_isom_write_hvcc(pb, track->vos_data, track->vos_len, 0);
+    if (track->tag == MKTAG('h','v','c','1'))
+        ff_isom_write_hvcc(pb, track->vos_data, track->vos_len, 1);
+    else
+        ff_isom_write_hvcc(pb, track->vos_data, track->vos_len, 0);
     return update_size(pb, pos);
 }
 
@@ -1162,58 +1232,6 @@ static int mov_write_dpxe_tag(AVIOContext *pb, MOVTrack *track)
     return 0;
 }
 
-static int mp4_get_codec_tag(AVFormatContext *s, MOVTrack *track)
-{
-    int tag = track->par->codec_tag;
-
-    if (!ff_codec_get_tag(ff_mp4_obj_type, track->par->codec_id))
-        return 0;
-
-    if      (track->par->codec_id == AV_CODEC_ID_H264)      tag = MKTAG('a','v','c','1');
-    else if (track->par->codec_id == AV_CODEC_ID_HEVC)      tag = MKTAG('h','e','v','1');
-    else if (track->par->codec_id == AV_CODEC_ID_VP9)       tag = MKTAG('v','p','0','9');
-    else if (track->par->codec_id == AV_CODEC_ID_AC3)       tag = MKTAG('a','c','-','3');
-    else if (track->par->codec_id == AV_CODEC_ID_EAC3)      tag = MKTAG('e','c','-','3');
-    else if (track->par->codec_id == AV_CODEC_ID_DIRAC)     tag = MKTAG('d','r','a','c');
-    else if (track->par->codec_id == AV_CODEC_ID_MOV_TEXT)  tag = MKTAG('t','x','3','g');
-    else if (track->par->codec_id == AV_CODEC_ID_VC1)       tag = MKTAG('v','c','-','1');
-    else if (track->par->codec_type == AVMEDIA_TYPE_VIDEO)  tag = MKTAG('m','p','4','v');
-    else if (track->par->codec_type == AVMEDIA_TYPE_AUDIO)  tag = MKTAG('m','p','4','a');
-    else if (track->par->codec_id == AV_CODEC_ID_DVD_SUBTITLE)  tag = MKTAG('m','p','4','s');
-
-    return tag;
-}
-
-static const AVCodecTag codec_ipod_tags[] = {
-    { AV_CODEC_ID_H264,     MKTAG('a','v','c','1') },
-    { AV_CODEC_ID_MPEG4,    MKTAG('m','p','4','v') },
-    { AV_CODEC_ID_AAC,      MKTAG('m','p','4','a') },
-    { AV_CODEC_ID_ALAC,     MKTAG('a','l','a','c') },
-    { AV_CODEC_ID_AC3,      MKTAG('a','c','-','3') },
-    { AV_CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },
-    { AV_CODEC_ID_MOV_TEXT, MKTAG('t','e','x','t') },
-    { AV_CODEC_ID_NONE, 0 },
-};
-
-static int ipod_get_codec_tag(AVFormatContext *s, MOVTrack *track)
-{
-    int tag = track->par->codec_tag;
-
-    // keep original tag for subs, ipod supports both formats
-    if (!(track->par->codec_type == AVMEDIA_TYPE_SUBTITLE &&
-          (tag == MKTAG('t', 'x', '3', 'g') ||
-           tag == MKTAG('t', 'e', 'x', 't'))))
-        tag = ff_codec_get_tag(codec_ipod_tags, track->par->codec_id);
-
-    if (!av_match_ext(s->filename, "m4a") &&
-        !av_match_ext(s->filename, "m4b") &&
-        !av_match_ext(s->filename, "m4v"))
-        av_log(s, AV_LOG_WARNING, "Warning, extension is not .m4a, .m4v nor  .m4b "
-               "Quicktime/Ipod might not play the file\n");
-
-    return tag;
-}
-
 static int mov_get_dv_codec_tag(AVFormatContext *s, MOVTrack *track)
 {
     int tag;
@@ -1257,12 +1275,21 @@ static AVRational find_fps(AVFormatContext *s, AVStream *st)
     return rate;
 }
 
+static int defined_frame_rate(AVFormatContext *s, AVStream *st)
+{
+    AVRational rational_framerate = find_fps(s, st);
+    int rate = 0;
+    if (rational_framerate.den != 0)
+        rate = av_q2d(rational_framerate);
+    return rate;
+}
+
 static int mov_get_mpeg2_xdcam_codec_tag(AVFormatContext *s, MOVTrack *track)
 {
     int tag = track->par->codec_tag;
     int interlaced = track->par->field_order > AV_FIELD_PROGRESSIVE;
     AVStream *st = track->st;
-    int rate = av_q2d(find_fps(s, st));
+    int rate = defined_frame_rate(s, st);
 
     if (!tag)
         tag = MKTAG('m', '2', 'v', '1'); //fallback tag
@@ -1324,7 +1351,7 @@ static int mov_get_h264_codec_tag(AVFormatContext *s, MOVTrack *track)
     int tag = track->par->codec_tag;
     int interlaced = track->par->field_order > AV_FIELD_PROGRESSIVE;
     AVStream *st = track->st;
-    int rate = av_q2d(find_fps(s, st));
+    int rate = defined_frame_rate(s, st);
 
     if (!tag)
         tag = MKTAG('a', 'v', 'c', 'i'); //fallback tag
@@ -1427,6 +1454,7 @@ static int mov_get_rawvideo_codec_tag(AVFormatContext *s, MOVTrack *track)
                                   track->par->bits_per_coded_sample);
     if (tag == MKTAG('r','a','w',' ') &&
         track->par->format != pix_fmt &&
+        track->par->format != AV_PIX_FMT_GRAY8 &&
         track->par->format != AV_PIX_FMT_NONE)
         av_log(s, AV_LOG_ERROR, "%s rawvideo cannot be written to mov, output file will be unreadable\n",
                av_get_pix_fmt_name(track->par->format));
@@ -1480,42 +1508,25 @@ static int mov_get_codec_tag(AVFormatContext *s, MOVTrack *track)
     return tag;
 }
 
-static const AVCodecTag codec_3gp_tags[] = {
-    { AV_CODEC_ID_H263,     MKTAG('s','2','6','3') },
-    { AV_CODEC_ID_H264,     MKTAG('a','v','c','1') },
-    { AV_CODEC_ID_MPEG4,    MKTAG('m','p','4','v') },
-    { AV_CODEC_ID_AAC,      MKTAG('m','p','4','a') },
-    { AV_CODEC_ID_AMR_NB,   MKTAG('s','a','m','r') },
-    { AV_CODEC_ID_AMR_WB,   MKTAG('s','a','w','b') },
-    { AV_CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },
-    { AV_CODEC_ID_NONE, 0 },
-};
-
-static const AVCodecTag codec_f4v_tags[] = { // XXX: add GIF/PNG/JPEG?
-    { AV_CODEC_ID_MP3,    MKTAG('.','m','p','3') },
-    { AV_CODEC_ID_AAC,    MKTAG('m','p','4','a') },
-    { AV_CODEC_ID_H264,   MKTAG('a','v','c','1') },
-    { AV_CODEC_ID_VP6A,   MKTAG('V','P','6','A') },
-    { AV_CODEC_ID_VP6F,   MKTAG('V','P','6','F') },
-    { AV_CODEC_ID_NONE, 0 },
-};
-
 static int mov_find_codec_tag(AVFormatContext *s, MOVTrack *track)
 {
     int tag;
 
     if (track->mode == MODE_MP4 || track->mode == MODE_PSP)
-        tag = mp4_get_codec_tag(s, track);
-    else if (track->mode == MODE_ISM) {
-        tag = mp4_get_codec_tag(s, track);
-        if (!tag && track->par->codec_id == AV_CODEC_ID_WMAPRO)
-            tag = MKTAG('w', 'm', 'a', ' ');
-    } else if (track->mode == MODE_IPOD)
-        tag = ipod_get_codec_tag(s, track);
-    else if (track->mode & MODE_3GP)
-        tag = ff_codec_get_tag(codec_3gp_tags, track->par->codec_id);
+        tag = track->par->codec_tag;
+    else if (track->mode == MODE_ISM)
+        tag = track->par->codec_tag;
+    else if (track->mode == MODE_IPOD) {
+        if (!av_match_ext(s->filename, "m4a") &&
+            !av_match_ext(s->filename, "m4v") &&
+            !av_match_ext(s->filename, "m4b"))
+            av_log(s, AV_LOG_WARNING, "Warning, extension is not .m4a nor .m4v "
+                   "Quicktime/Ipod might not play the file\n");
+        tag = track->par->codec_tag;
+    } else if (track->mode & MODE_3GP)
+        tag = track->par->codec_tag;
     else if (track->mode == MODE_F4V)
-        tag = ff_codec_get_tag(codec_f4v_tags, track->par->codec_id);
+        tag = track->par->codec_tag;
     else
         tag = mov_get_codec_tag(s, track);
 
@@ -1572,6 +1583,94 @@ static int mov_write_subtitle_tag(AVIOContext *pb, MOVTrack *track)
     return update_size(pb, pos);
 }
 
+static int mov_write_st3d_tag(AVIOContext *pb, AVStereo3D *stereo_3d)
+{
+    int8_t stereo_mode;
+
+    if (stereo_3d->flags != 0) {
+        av_log(pb, AV_LOG_WARNING, "Unsupported stereo_3d flags %x. st3d not written.\n", stereo_3d->flags);
+        return 0;
+    }
+
+    switch (stereo_3d->type) {
+    case AV_STEREO3D_2D:
+        stereo_mode = 0;
+        break;
+    case AV_STEREO3D_TOPBOTTOM:
+        stereo_mode = 1;
+        break;
+    case AV_STEREO3D_SIDEBYSIDE:
+        stereo_mode = 2;
+        break;
+    default:
+        av_log(pb, AV_LOG_WARNING, "Unsupported stereo_3d type %s. st3d not written.\n", av_stereo3d_type_name(stereo_3d->type));
+        return 0;
+    }
+    avio_wb32(pb, 13); /* size */
+    ffio_wfourcc(pb, "st3d");
+    avio_wb32(pb, 0); /* version = 0 & flags = 0 */
+    avio_w8(pb, stereo_mode);
+    return 13;
+}
+
+static int mov_write_sv3d_tag(AVFormatContext *s, AVIOContext *pb, AVSphericalMapping *spherical_mapping)
+{
+    int64_t sv3d_pos, svhd_pos, proj_pos;
+    const char* metadata_source = s->flags & AVFMT_FLAG_BITEXACT ? "Lavf" : LIBAVFORMAT_IDENT;
+
+    if (spherical_mapping->projection != AV_SPHERICAL_EQUIRECTANGULAR &&
+        spherical_mapping->projection != AV_SPHERICAL_EQUIRECTANGULAR_TILE &&
+        spherical_mapping->projection != AV_SPHERICAL_CUBEMAP) {
+        av_log(pb, AV_LOG_WARNING, "Unsupported projection %d. sv3d not written.\n", spherical_mapping->projection);
+        return 0;
+    }
+
+    sv3d_pos = avio_tell(pb);
+    avio_wb32(pb, 0);  /* size */
+    ffio_wfourcc(pb, "sv3d");
+
+    svhd_pos = avio_tell(pb);
+    avio_wb32(pb, 0);  /* size */
+    ffio_wfourcc(pb, "svhd");
+    avio_wb32(pb, 0); /* version = 0 & flags = 0 */
+    avio_put_str(pb, metadata_source);
+    update_size(pb, svhd_pos);
+
+    proj_pos = avio_tell(pb);
+    avio_wb32(pb, 0); /* size */
+    ffio_wfourcc(pb, "proj");
+
+    avio_wb32(pb, 24); /* size */
+    ffio_wfourcc(pb, "prhd");
+    avio_wb32(pb, 0); /* version = 0 & flags = 0 */
+    avio_wb32(pb, spherical_mapping->yaw);
+    avio_wb32(pb, spherical_mapping->pitch);
+    avio_wb32(pb, spherical_mapping->roll);
+
+    switch (spherical_mapping->projection) {
+    case AV_SPHERICAL_EQUIRECTANGULAR:
+    case AV_SPHERICAL_EQUIRECTANGULAR_TILE:
+        avio_wb32(pb, 28);    /* size */
+        ffio_wfourcc(pb, "equi");
+        avio_wb32(pb, 0); /* version = 0 & flags = 0 */
+        avio_wb32(pb, spherical_mapping->bound_top);
+        avio_wb32(pb, spherical_mapping->bound_bottom);
+        avio_wb32(pb, spherical_mapping->bound_left);
+        avio_wb32(pb, spherical_mapping->bound_right);
+        break;
+    case AV_SPHERICAL_CUBEMAP:
+        avio_wb32(pb, 20);    /* size */
+        ffio_wfourcc(pb, "cbmp");
+        avio_wb32(pb, 0); /* version = 0 & flags = 0 */
+        avio_wb32(pb, 0); /* layout */
+        avio_wb32(pb, spherical_mapping->padding); /* padding */
+        break;
+    }
+    update_size(pb, proj_pos);
+
+    return update_size(pb, sv3d_pos);
+}
+
 static int mov_write_pasp_tag(AVIOContext *pb, MOVTrack *track)
 {
     AVRational sar;
@@ -1596,7 +1695,7 @@ static int mov_write_gama_tag(AVIOContext *pb, MOVTrack *track, double gamma)
 
     if (gamma > 1e-6) {
         gama = (uint32_t)lrint((double)(1<<16) * gamma);
-        av_log(pb, AV_LOG_DEBUG, "writing gama value %d\n", gama);
+        av_log(pb, AV_LOG_DEBUG, "writing gama value %"PRId32"\n", gama);
 
         av_assert0(track->mode == MODE_MOV);
         avio_wb32(pb, 12);
@@ -1697,7 +1796,7 @@ static void find_compressor(char * compressor_name, int len, MOVTrack *track)
     } else if (track->par->codec_id == AV_CODEC_ID_MPEG2VIDEO && xdcam_res) {
         int interlaced = track->par->field_order > AV_FIELD_PROGRESSIVE;
         AVStream *st = track->st;
-        int rate = av_q2d(find_fps(NULL, st));
+        int rate = defined_frame_rate(NULL, st);
         av_strlcatf(compressor_name, len, "XDCAM");
         if (track->par->format == AV_PIX_FMT_YUV422P) {
             av_strlcatf(compressor_name, len, " HD422");
@@ -1842,6 +1941,16 @@ static int mov_write_video_tag(AVIOContext *pb, MOVMuxContext *mov, MOVTrack *tr
             av_log(mov->fc, AV_LOG_WARNING, "Not writing 'colr' atom. Format is not MOV or MP4.\n");
     }
 
+    if (track->mode == MODE_MP4 && mov->fc->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
+        AVStereo3D* stereo_3d = (AVStereo3D*) av_stream_get_side_data(track->st, AV_PKT_DATA_STEREO3D, NULL);
+        AVSphericalMapping* spherical_mapping = (AVSphericalMapping*)av_stream_get_side_data(track->st, AV_PKT_DATA_SPHERICAL, NULL);
+
+        if (stereo_3d)
+            mov_write_st3d_tag(pb, stereo_3d);
+        if (spherical_mapping)
+            mov_write_sv3d_tag(mov->fc, pb, spherical_mapping);
+    }
+
     if (track->par->sample_aspect_ratio.den && track->par->sample_aspect_ratio.num) {
         mov_write_pasp_tag(pb, track);
     }
@@ -1953,6 +2062,18 @@ static int mov_write_tmcd_tag(AVIOContext *pb, MOVTrack *track)
     return update_size(pb, pos);
 }
 
+static int mov_write_gpmd_tag(AVIOContext *pb, const MOVTrack *track)
+{
+    int64_t pos = avio_tell(pb);
+    avio_wb32(pb, 0); /* size */
+    ffio_wfourcc(pb, "gpmd");
+    avio_wb32(pb, 0); /* Reserved */
+    avio_wb16(pb, 0); /* Reserved */
+    avio_wb16(pb, 1); /* Data-reference index */
+    avio_wb32(pb, 0); /* Reserved */
+    return update_size(pb, pos);
+}
+
 static int mov_write_stsd_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
 {
     int64_t pos = avio_tell(pb);
@@ -1970,11 +2091,14 @@ static int mov_write_stsd_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext
         mov_write_rtp_tag(pb, track);
     else if (track->par->codec_tag == MKTAG('t','m','c','d'))
         mov_write_tmcd_tag(pb, track);
+    else if (track->par->codec_tag == MKTAG('g','p','m','d'))
+        mov_write_gpmd_tag(pb, track);
     return update_size(pb, pos);
 }
 
-static int mov_write_ctts_tag(AVIOContext *pb, MOVTrack *track)
+static int mov_write_ctts_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *track)
 {
+    MOVMuxContext *mov = s->priv_data;
     MOVStts *ctts_entries;
     uint32_t entries = 0;
     uint32_t atom_size;
@@ -1998,7 +2122,11 @@ static int mov_write_ctts_tag(AVIOContext *pb, MOVTrack *track)
     atom_size = 16 + (entries * 8);
     avio_wb32(pb, atom_size); /* size */
     ffio_wfourcc(pb, "ctts");
-    avio_wb32(pb, 0); /* version & flags */
+    if (mov->flags & FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS)
+        avio_w8(pb, 1); /* version */
+    else
+        avio_w8(pb, 0); /* version */
+    avio_wb24(pb, 0); /* flags */
     avio_wb32(pb, entries); /* entry count */
     for (i = 0; i < entries; i++) {
         avio_wb32(pb, ctts_entries[i].count);
@@ -2069,6 +2197,101 @@ static int mov_write_dref_tag(AVIOContext *pb)
     return 28;
 }
 
+static int mov_preroll_write_stbl_atoms(AVIOContext *pb, MOVTrack *track)
+{
+    struct sgpd_entry {
+        int count;
+        int16_t roll_distance;
+        int group_description_index;
+    };
+
+    struct sgpd_entry *sgpd_entries = NULL;
+    int entries = -1;
+    int group = 0;
+    int i, j;
+
+    const int OPUS_SEEK_PREROLL_MS = 80;
+    int roll_samples = av_rescale_q(OPUS_SEEK_PREROLL_MS,
+                                    (AVRational){1, 1000},
+                                    (AVRational){1, 48000});
+
+    if (!track->entry)
+        return 0;
+
+    sgpd_entries = av_malloc_array(track->entry, sizeof(*sgpd_entries));
+    if (!sgpd_entries)
+        return AVERROR(ENOMEM);
+
+    av_assert0(track->par->codec_id == AV_CODEC_ID_OPUS || track->par->codec_id == AV_CODEC_ID_AAC);
+
+    if (track->par->codec_id == AV_CODEC_ID_OPUS) {
+        for (i = 0; i < track->entry; i++) {
+            int roll_samples_remaining = roll_samples;
+            int distance = 0;
+            for (j = i - 1; j >= 0; j--) {
+                roll_samples_remaining -= get_cluster_duration(track, j);
+                distance++;
+                if (roll_samples_remaining <= 0)
+                    break;
+            }
+            /* We don't have enough preceeding samples to compute a valid
+               roll_distance here, so this sample can't be independently
+               decoded. */
+            if (roll_samples_remaining > 0)
+                distance = 0;
+            /* Verify distance is a minimum of 2 (60ms) packets and a maximum of
+               32 (2.5ms) packets. */
+            av_assert0(distance == 0 || (distance >= 2 && distance <= 32));
+            if (i && distance == sgpd_entries[entries].roll_distance) {
+                sgpd_entries[entries].count++;
+            } else {
+                entries++;
+                sgpd_entries[entries].count = 1;
+                sgpd_entries[entries].roll_distance = distance;
+                sgpd_entries[entries].group_description_index = distance ? ++group : 0;
+            }
+        }
+    } else {
+        entries++;
+        sgpd_entries[entries].count = track->sample_count;
+        sgpd_entries[entries].roll_distance = 1;
+        sgpd_entries[entries].group_description_index = ++group;
+    }
+    entries++;
+
+    if (!group) {
+        av_free(sgpd_entries);
+        return 0;
+    }
+
+    /* Write sgpd tag */
+    avio_wb32(pb, 24 + (group * 2)); /* size */
+    ffio_wfourcc(pb, "sgpd");
+    avio_wb32(pb, 1 << 24); /* fullbox */
+    ffio_wfourcc(pb, "roll");
+    avio_wb32(pb, 2); /* default_length */
+    avio_wb32(pb, group); /* entry_count */
+    for (i = 0; i < entries; i++) {
+        if (sgpd_entries[i].group_description_index) {
+            avio_wb16(pb, -sgpd_entries[i].roll_distance); /* roll_distance */
+        }
+    }
+
+    /* Write sbgp tag */
+    avio_wb32(pb, 20 + (entries * 8)); /* size */
+    ffio_wfourcc(pb, "sbgp");
+    avio_wb32(pb, 0); /* fullbox */
+    ffio_wfourcc(pb, "roll");
+    avio_wb32(pb, entries); /* entry_count */
+    for (i = 0; i < entries; i++) {
+        avio_wb32(pb, sgpd_entries[i].count); /* sample_count */
+        avio_wb32(pb, sgpd_entries[i].group_description_index); /* group_description_index */
+    }
+
+    av_free(sgpd_entries);
+    return 0;
+}
+
 static int mov_write_stbl_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
 {
     int64_t pos = avio_tell(pb);
@@ -2087,15 +2310,18 @@ static int mov_write_stbl_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext
     if (track->par->codec_type == AVMEDIA_TYPE_VIDEO &&
         track->flags & MOV_TRACK_CTTS && track->entry) {
 
-        if ((ret = mov_write_ctts_tag(pb, track)) < 0)
+        if ((ret = mov_write_ctts_tag(s, pb, track)) < 0)
             return ret;
     }
     mov_write_stsc_tag(pb, track);
     mov_write_stsz_tag(pb, track);
     mov_write_stco_tag(pb, track);
-    if (mov->encryption_scheme == MOV_ENC_CENC_AES_CTR) {
+    if (track->cenc.aes_ctr) {
         ff_mov_cenc_write_stbl_atoms(&track->cenc, pb);
     }
+    if (track->par->codec_id == AV_CODEC_ID_OPUS || track->par->codec_id == AV_CODEC_ID_AAC) {
+        mov_preroll_write_stbl_atoms(pb, track);
+    }
     return update_size(pb, pos);
 }
 
@@ -2180,6 +2406,12 @@ static int mov_write_gmhd_tag(AVIOContext *pb, MOVTrack *track)
         ffio_wfourcc(pb, "tmcd");
         mov_write_tcmi_tag(pb, track);
         update_size(pb, tmcd_pos);
+    } else if (track->par->codec_tag == MKTAG('g','p','m','d')) {
+        int64_t gpmd_pos = avio_tell(pb);
+        avio_wb32(pb, 0); /* size */
+        ffio_wfourcc(pb, "gpmd");
+        avio_wb32(pb, 0); /* version */
+        update_size(pb, gpmd_pos);
     }
     return update_size(pb, pos);
 }
@@ -2246,14 +2478,13 @@ static int mov_write_hdlr_tag(AVFormatContext *s, AVIOContext *pb, MOVTrack *tra
         } else if (track->par->codec_tag == MKTAG('t','m','c','d')) {
             hdlr_type = "tmcd";
             descr = "TimeCodeHandler";
+        } else if (track->par->codec_tag == MKTAG('g','p','m','d')) {
+            hdlr_type = "meta";
+            descr = "GoPro MET"; // GoPro Metadata
         } else {
-            char tag_buf[32];
-            av_get_codec_tag_string(tag_buf, sizeof(tag_buf),
-                                    track->par->codec_tag);
-
             av_log(s, AV_LOG_WARNING,
-                   "Unknown hldr_type for %s / 0x%04X, writing dummy values\n",
-                   tag_buf, track->par->codec_tag);
+                   "Unknown hldr_type for %s, writing dummy values\n",
+                   av_fourcc2str(track->par->codec_tag));
         }
         if (track->st) {
             // hdlr.name is used by some players to identify the content title
@@ -2321,6 +2552,8 @@ static int mov_write_minf_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext
             mov_write_nmhd_tag(pb);
         else
             mov_write_gmhd_tag(pb, track);
+    } else if (track->tag == MKTAG('g','p','m','d')) {
+        mov_write_gmhd_tag(pb, track);
     }
     if (track->mode == MODE_MOV) /* FIXME: Why do it for MODE_MOV only ? */
         mov_write_hdlr_tag(s, pb, NULL);
@@ -2465,19 +2698,23 @@ static int mov_write_tkhd_tag(AVIOContext *pb, MOVMuxContext *mov,
     avio_wb16(pb, 0); /* reserved */
 
     /* Matrix structure */
+#if FF_API_OLD_ROTATE_API
     if (st && st->metadata) {
         AVDictionaryEntry *rot = av_dict_get(st->metadata, "rotate", NULL, 0);
         rotation = (rot && rot->value) ? atoi(rot->value) : 0;
     }
+#endif
     if (display_matrix) {
         for (i = 0; i < 9; i++)
             avio_wb32(pb, display_matrix[i]);
+#if FF_API_OLD_ROTATE_API
     } else if (rotation == 90) {
         write_matrix(pb,  0,  1, -1,  0, track->par->height, 0);
     } else if (rotation == 180) {
         write_matrix(pb, -1,  0,  0, -1, track->par->width, track->par->height);
     } else if (rotation == 270) {
         write_matrix(pb,  0, -1,  1,  0, 0, track->par->width);
+#endif
     } else {
         write_matrix(pb,  1,  0,  0,  1, 0, 0);
     }
@@ -3124,6 +3361,7 @@ static int mov_write_ilst_tag(AVIOContext *pb, MOVMuxContext *mov,
     mov_write_string_metadata(s, pb, "tvsh",    "show"     , 1);
     mov_write_string_metadata(s, pb, "tven",    "episode_id",1);
     mov_write_string_metadata(s, pb, "tvnn",    "network"  , 1);
+    mov_write_string_metadata(s, pb, "keyw",    "keywords"  , 1);
     mov_write_int8_metadata  (s, pb, "tves",    "episode_sort",4);
     mov_write_int8_metadata  (s, pb, "tvsn",    "season_number",4);
     mov_write_int8_metadata  (s, pb, "stik",    "media_type",1);
@@ -3346,6 +3584,7 @@ static int mov_write_udta_tag(AVIOContext *pb, MOVMuxContext *mov,
         mov_write_string_metadata(s, pb_buf, "\251mak", "make",        0);
         mov_write_string_metadata(s, pb_buf, "\251mod", "model",       0);
         mov_write_string_metadata(s, pb_buf, "\251xyz", "location",    0);
+        mov_write_string_metadata(s, pb_buf, "\251key", "keywords",    0);
         mov_write_raw_metadata_tag(s, pb_buf, "XMP_", "xmp");
     } else {
         /* iTunes meta data */
@@ -3614,6 +3853,7 @@ static int mov_write_isml_manifest(AVIOContext *pb, MOVMuxContext *mov, AVFormat
         MOVTrack *track = &mov->tracks[i];
         const char *type;
         int track_id = track->track_id;
+        char track_name_buf[32] = { 0 };
 
         AVStream *st = track->st;
         AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0);
@@ -3639,6 +3879,23 @@ static int mov_write_isml_manifest(AVIOContext *pb, MOVMuxContext *mov, AVFormat
         param_write_int(pb, "systemBitrate", manifest_bit_rate);
         param_write_int(pb, "trackID", track_id);
         param_write_string(pb, "systemLanguage", lang ? lang->value : "und");
+
+        /* Build track name piece by piece: */
+        /* 1. track type */
+        av_strlcat(track_name_buf, type, sizeof(track_name_buf));
+        /* 2. track language, if available */
+        if (lang)
+            av_strlcatf(track_name_buf, sizeof(track_name_buf),
+                        "_%s", lang->value);
+        /* 3. special type suffix */
+        /* "_cc" = closed captions, "_ad" = audio_description */
+        if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
+            av_strlcat(track_name_buf, "_cc", sizeof(track_name_buf));
+        else if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
+            av_strlcat(track_name_buf, "_ad", sizeof(track_name_buf));
+
+        param_write_string(pb, "trackName", track_name_buf);
+
         if (track->par->codec_type == AVMEDIA_TYPE_VIDEO) {
             if (track->par->codec_id == AV_CODEC_ID_H264) {
                 uint8_t *ptr;
@@ -3794,7 +4051,10 @@ static int mov_write_trun_tag(AVIOContext *pb, MOVMuxContext *mov,
 
     avio_wb32(pb, 0); /* size placeholder */
     ffio_wfourcc(pb, "trun");
-    avio_w8(pb, 0); /* version */
+    if (mov->flags & FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS)
+        avio_w8(pb, 1); /* version */
+    else
+        avio_w8(pb, 0); /* version */
     avio_wb24(pb, flags);
 
     avio_wb32(pb, end - first); /* sample count */
@@ -3933,6 +4193,20 @@ static int mov_add_tfra_entries(AVIOContext *pb, MOVMuxContext *mov, int tracks,
     return 0;
 }
 
+static void mov_prune_frag_info(MOVMuxContext *mov, int tracks, int max)
+{
+    int i;
+    for (i = 0; i < mov->nb_streams; i++) {
+        MOVTrack *track = &mov->tracks[i];
+        if ((tracks >= 0 && i != tracks) || !track->entry)
+            continue;
+        if (track->nb_frag_info > max) {
+            memmove(track->frag_info, track->frag_info + (track->nb_frag_info - max), max * sizeof(*track->frag_info));
+            track->nb_frag_info = max;
+        }
+    }
+}
+
 static int mov_write_tfdt_tag(AVIOContext *pb, MOVTrack *track)
 {
     int64_t pos = avio_tell(pb);
@@ -4118,8 +4392,16 @@ static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks,
     if (mov->flags & FF_MOV_FLAG_DASH && !(mov->flags & FF_MOV_FLAG_GLOBAL_SIDX))
         mov_write_sidx_tags(pb, mov, tracks, moof_size + 8 + mdat_size);
 
-    if ((ret = mov_add_tfra_entries(pb, mov, tracks, moof_size + 8 + mdat_size)) < 0)
-        return ret;
+    if (mov->flags & FF_MOV_FLAG_GLOBAL_SIDX ||
+        !(mov->flags & FF_MOV_FLAG_SKIP_TRAILER) ||
+        mov->ism_lookahead) {
+        if ((ret = mov_add_tfra_entries(pb, mov, tracks, moof_size + 8 + mdat_size)) < 0)
+            return ret;
+        if (!(mov->flags & FF_MOV_FLAG_GLOBAL_SIDX) &&
+            mov->flags & FF_MOV_FLAG_SKIP_TRAILER) {
+            mov_prune_frag_info(mov, tracks, mov->ism_lookahead + 1);
+        }
+    }
 
     return mov_write_moof_tag_internal(pb, mov, tracks, moof_size);
 }
@@ -4217,6 +4499,8 @@ static int mov_write_ftyp_tag(AVIOContext *pb, AVFormatContext *s)
         ffio_wfourcc(pb, "MSNV");
     else if (mov->mode == MODE_MP4 && mov->flags & FF_MOV_FLAG_DEFAULT_BASE_MOOF)
         ffio_wfourcc(pb, "iso5"); // Required when using default-base-is-moof
+    else if (mov->mode == MODE_MP4 && mov->flags & FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS)
+        ffio_wfourcc(pb, "iso4");
     else if (mov->mode == MODE_MP4)
         ffio_wfourcc(pb, "isom");
     else if (mov->mode == MODE_IPOD)
@@ -4267,7 +4551,9 @@ static int mov_write_uuidprof_tag(AVIOContext *pb, AVFormatContext *s)
     AVCodecParameters *video_par = s->streams[0]->codecpar;
     AVCodecParameters *audio_par = s->streams[1]->codecpar;
     int audio_rate = audio_par->sample_rate;
-    int64_t frame_rate = (video_st->avg_frame_rate.num * 0x10000LL) / video_st->avg_frame_rate.den;
+    int64_t frame_rate = video_st->avg_frame_rate.den ?
+                        (video_st->avg_frame_rate.num * 0x10000LL) / video_st->avg_frame_rate.den :
+                        0;
     int audio_kbitrate = audio_par->bit_rate / 1000;
     int video_kbitrate = FFMIN(video_par->bit_rate / 1000, 800 - audio_kbitrate);
 
@@ -4483,15 +4769,15 @@ static int mov_flush_fragment(AVFormatContext *s, int force)
     for (i = 0; i < s->nb_streams; i++) {
         MOVTrack *track = &mov->tracks[i];
         if (!track->end_reliable) {
-            int64_t ts_offset;
-            const AVPacket *next = ff_interleaved_peek(s, i, &ts_offset);
-            if (next) {
-                track->track_duration = next->dts - track->start_dts + ts_offset;
-                if (next->pts != AV_NOPTS_VALUE)
-                    track->end_pts = next->pts;
+            AVPacket pkt;
+            if (!ff_interleaved_peek(s, i, &pkt, 1)) {
+                if (track->dts_shift != AV_NOPTS_VALUE)
+                    pkt.dts += track->dts_shift;
+                track->track_duration = pkt.dts - track->start_dts;
+                if (pkt.pts != AV_NOPTS_VALUE)
+                    track->end_pts = pkt.pts;
                 else
-                    track->end_pts = next->dts;
-                track->end_pts += ts_offset;
+                    track->end_pts = pkt.dts;
             }
         }
     }
@@ -4703,6 +4989,12 @@ static int check_pkt(AVFormatContext *s, AVPacket *pkt)
     } else
         ref = pkt->dts; // Skip tests for the first packet
 
+    if (trk->dts_shift != AV_NOPTS_VALUE) {
+        /* With negative CTS offsets we have set an offset to the DTS,
+         * reverse this for the check. */
+        ref -= trk->dts_shift;
+    }
+
     duration = pkt->dts - ref;
     if (pkt->dts < ref || duration >= INT_MAX) {
         av_log(s, AV_LOG_ERROR, "Application provided duration: %"PRId64" / timestamp: %"PRId64" is out of range for mov/mp4 format\n",
@@ -4811,7 +5103,7 @@ int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
                                        &size);
             avio_write(pb, reformatted_data, size);
         } else {
-            if (mov->encryption_scheme == MOV_ENC_CENC_AES_CTR) {
+            if (trk->cenc.aes_ctr) {
                 size = ff_mov_cenc_avc_parse_nal_units(&trk->cenc, pb, pkt->data, size);
                 if (size < 0) {
                     ret = size;
@@ -4840,7 +5132,7 @@ int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
         avio_write(pb, pkt->data, size);
 #endif
     } else {
-        if (mov->encryption_scheme == MOV_ENC_CENC_AES_CTR) {
+        if (trk->cenc.aes_ctr) {
             if (par->codec_id == AV_CODEC_ID_H264 && par->extradata_size > 4) {
                 int nal_size_length = (par->extradata[4] & 0x3) + 1;
                 ret = ff_mov_cenc_avc_write_nal_units(s, &trk->cenc, nal_size_length, pb, pkt->data, size);
@@ -5010,6 +5302,30 @@ static int mov_write_single_packet(AVFormatContext *s, AVPacket *pkt)
             mov->flags &= ~FF_MOV_FLAG_FRAG_DISCONT;
         }
 
+        if (mov->flags & FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS) {
+            if (trk->dts_shift == AV_NOPTS_VALUE)
+                trk->dts_shift = pkt->pts - pkt->dts;
+            pkt->dts += trk->dts_shift;
+        }
+
+        if (trk->par->codec_id == AV_CODEC_ID_MP4ALS ||
+            trk->par->codec_id == AV_CODEC_ID_AAC ||
+            trk->par->codec_id == AV_CODEC_ID_FLAC) {
+            int side_size = 0;
+            uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
+            if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
+                void *newextra = av_mallocz(side_size + AV_INPUT_BUFFER_PADDING_SIZE);
+                if (!newextra)
+                    return AVERROR(ENOMEM);
+                av_free(par->extradata);
+                par->extradata = newextra;
+                memcpy(par->extradata, side, side_size);
+                par->extradata_size = side_size;
+                if (!pkt->size) // Flush packet
+                    mov->need_rewrite_extradata = 1;
+            }
+        }
+
         if (!pkt->size) {
             if (trk->start_dts == AV_NOPTS_VALUE && trk->frag_discont) {
                 trk->start_dts = pkt->dts;
@@ -5019,21 +5335,6 @@ static int mov_write_single_packet(AVFormatContext *s, AVPacket *pkt)
                     trk->start_cts = 0;
             }
 
-            if (trk->par->codec_id == AV_CODEC_ID_MP4ALS) {
-                int side_size = 0;
-                uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
-                if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
-                    void *newextra = av_mallocz(side_size + AV_INPUT_BUFFER_PADDING_SIZE);
-                    if (!newextra)
-                        return AVERROR(ENOMEM);
-                    av_free(par->extradata);
-                    par->extradata = newextra;
-                    memcpy(par->extradata, side, side_size);
-                    par->extradata_size = side_size;
-                    mov->need_rewrite_extradata = 1;
-                }
-            }
-
             return 0;             /* Discard 0 sized packets */
         }
 
@@ -5463,7 +5764,7 @@ static int mov_init(AVFormatContext *s)
 {
     MOVMuxContext *mov = s->priv_data;
     AVDictionaryEntry *global_tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
-    int i, ret, hint_track = 0, tmcd_track = 0;
+    int i, ret;
 
     mov->fc = s;
 
@@ -5544,7 +5845,7 @@ static int mov_init(AVFormatContext *s)
 
     /* Non-seekable output is ok if using fragmentation. If ism_lookahead
      * is enabled, we don't support non-seekable output at all. */
-    if (!s->pb->seekable &&
+    if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
         (!(mov->flags & FF_MOV_FLAG_FRAGMENT) || mov->ism_lookahead)) {
         av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n");
         return AVERROR(EINVAL);
@@ -5556,7 +5857,6 @@ static int mov_init(AVFormatContext *s)
 
     if (mov->flags & FF_MOV_FLAG_RTP_HINT) {
         /* Add hint tracks for each audio and video stream */
-        hint_track = mov->nb_streams;
         for (i = 0; i < s->nb_streams; i++) {
             AVStream *st = s->streams[i];
             if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
@@ -5568,8 +5868,6 @@ static int mov_init(AVFormatContext *s)
 
     if (   mov->write_tmcd == -1 && (mov->mode == MODE_MOV || mov->mode == MODE_MP4)
         || mov->write_tmcd == 1) {
-        tmcd_track = mov->nb_streams;
-
         /* +1 tmcd track for each video stream with a timecode */
         for (i = 0; i < s->nb_streams; i++) {
             AVStream *st = s->streams[i];
@@ -5650,6 +5948,7 @@ static int mov_init(AVFormatContext *s)
         track->start_dts  = AV_NOPTS_VALUE;
         track->start_cts  = AV_NOPTS_VALUE;
         track->end_pts    = AV_NOPTS_VALUE;
+        track->dts_shift  = AV_NOPTS_VALUE;
         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
             if (track->tag == MKTAG('m','x','3','p') || track->tag == MKTAG('m','x','3','n') ||
                 track->tag == MKTAG('m','x','4','p') || track->tag == MKTAG('m','x','4','n') ||
@@ -5690,14 +5989,10 @@ static int mov_init(AVFormatContext *s)
                         pix_fmt == AV_PIX_FMT_MONOWHITE ||
                         pix_fmt == AV_PIX_FMT_MONOBLACK;
             }
-            if (track->mode == MODE_MP4 &&
-                track->par->codec_id == AV_CODEC_ID_VP9) {
-                if (s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
-                    av_log(s, AV_LOG_ERROR,
-                           "VP9 in MP4 support is experimental, add "
-                           "'-strict %d' if you want to use it.\n",
-                           FF_COMPLIANCE_EXPERIMENTAL);
-                    return AVERROR_EXPERIMENTAL;
+            if (track->par->codec_id == AV_CODEC_ID_VP9) {
+                if (track->mode != MODE_MP4) {
+                    av_log(s, AV_LOG_ERROR, "VP9 only supported in MP4.\n");
+                    return AVERROR(EINVAL);
                 }
             }
         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
@@ -5733,6 +6028,20 @@ static int mov_init(AVFormatContext *s)
                            i, track->par->sample_rate);
                 }
             }
+            if (track->par->codec_id == AV_CODEC_ID_FLAC ||
+                track->par->codec_id == AV_CODEC_ID_OPUS) {
+                if (track->mode != MODE_MP4) {
+                    av_log(s, AV_LOG_ERROR, "%s only supported in MP4.\n", avcodec_get_name(track->par->codec_id));
+                    return AVERROR(EINVAL);
+                }
+                if (s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
+                    av_log(s, AV_LOG_ERROR,
+                           "%s in MP4 support is experimental, add "
+                           "'-strict %d' if you want to use it.\n",
+                           avcodec_get_name(track->par->codec_id), FF_COMPLIANCE_EXPERIMENTAL);
+                    return AVERROR_EXPERIMENTAL;
+                }
+            }
         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
             track->timescale = st->time_base.den;
         } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
@@ -6151,7 +6460,7 @@ static int mov_write_trailer(AVFormatContext *s)
             avio_seek(pb, end, SEEK_SET);
             avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_TRAILER);
             mov_write_mfra_tag(pb, mov);
-        } else {
+        } else if (!(mov->flags & FF_MOV_FLAG_SKIP_TRAILER)) {
             avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_TRAILER);
             mov_write_mfra_tag(pb, mov);
         }
@@ -6168,11 +6477,80 @@ static int mov_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
     if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
         if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
             ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
+    } else if (st->codecpar->codec_id == AV_CODEC_ID_VP9) {
+        ret = ff_stream_add_bitstream_filter(st, "vp9_superframe", NULL);
     }
 
     return ret;
 }
 
+static const AVCodecTag codec_3gp_tags[] = {
+    { AV_CODEC_ID_H263,     MKTAG('s','2','6','3') },
+    { AV_CODEC_ID_H264,     MKTAG('a','v','c','1') },
+    { AV_CODEC_ID_MPEG4,    MKTAG('m','p','4','v') },
+    { AV_CODEC_ID_AAC,      MKTAG('m','p','4','a') },
+    { AV_CODEC_ID_AMR_NB,   MKTAG('s','a','m','r') },
+    { AV_CODEC_ID_AMR_WB,   MKTAG('s','a','w','b') },
+    { AV_CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },
+    { AV_CODEC_ID_NONE, 0 },
+};
+
+const AVCodecTag codec_mp4_tags[] = {
+    { AV_CODEC_ID_MPEG4       , MKTAG('m', 'p', '4', 'v') },
+    { AV_CODEC_ID_H264        , MKTAG('a', 'v', 'c', '1') },
+    { AV_CODEC_ID_HEVC        , MKTAG('h', 'e', 'v', '1') },
+    { AV_CODEC_ID_HEVC        , MKTAG('h', 'v', 'c', '1') },
+    { AV_CODEC_ID_MPEG2VIDEO  , MKTAG('m', 'p', '4', 'v') },
+    { AV_CODEC_ID_MPEG1VIDEO  , MKTAG('m', 'p', '4', 'v') },
+    { AV_CODEC_ID_MJPEG       , MKTAG('m', 'p', '4', 'v') },
+    { AV_CODEC_ID_PNG         , MKTAG('m', 'p', '4', 'v') },
+    { AV_CODEC_ID_JPEG2000    , MKTAG('m', 'p', '4', 'v') },
+    { AV_CODEC_ID_VC1         , MKTAG('v', 'c', '-', '1') },
+    { AV_CODEC_ID_DIRAC       , MKTAG('d', 'r', 'a', 'c') },
+    { AV_CODEC_ID_TSCC2       , MKTAG('m', 'p', '4', 'v') },
+    { AV_CODEC_ID_VP9         , MKTAG('v', 'p', '0', '9') },
+    { AV_CODEC_ID_AAC         , MKTAG('m', 'p', '4', 'a') },
+    { AV_CODEC_ID_MP4ALS      , MKTAG('m', 'p', '4', 'a') },
+    { AV_CODEC_ID_MP3         , MKTAG('m', 'p', '4', 'a') },
+    { AV_CODEC_ID_MP2         , MKTAG('m', 'p', '4', 'a') },
+    { AV_CODEC_ID_AC3         , MKTAG('a', 'c', '-', '3') },
+    { AV_CODEC_ID_EAC3        , MKTAG('e', 'c', '-', '3') },
+    { AV_CODEC_ID_DTS         , MKTAG('m', 'p', '4', 'a') },
+    { AV_CODEC_ID_FLAC        , MKTAG('f', 'L', 'a', 'C') },
+    { AV_CODEC_ID_OPUS        , MKTAG('O', 'p', 'u', 's') },
+    { AV_CODEC_ID_VORBIS      , MKTAG('m', 'p', '4', 'a') },
+    { AV_CODEC_ID_QCELP       , MKTAG('m', 'p', '4', 'a') },
+    { AV_CODEC_ID_EVRC        , MKTAG('m', 'p', '4', 'a') },
+    { AV_CODEC_ID_DVD_SUBTITLE, MKTAG('m', 'p', '4', 's') },
+    { AV_CODEC_ID_MOV_TEXT    , MKTAG('t', 'x', '3', 'g') },
+    { AV_CODEC_ID_NONE        ,    0 },
+};
+
+const AVCodecTag codec_ism_tags[] = {
+    { AV_CODEC_ID_WMAPRO      , MKTAG('w', 'm', 'a', ' ') },
+    { AV_CODEC_ID_NONE        ,    0 },
+};
+
+static const AVCodecTag codec_ipod_tags[] = {
+    { AV_CODEC_ID_H264,     MKTAG('a','v','c','1') },
+    { AV_CODEC_ID_MPEG4,    MKTAG('m','p','4','v') },
+    { AV_CODEC_ID_AAC,      MKTAG('m','p','4','a') },
+    { AV_CODEC_ID_ALAC,     MKTAG('a','l','a','c') },
+    { AV_CODEC_ID_AC3,      MKTAG('a','c','-','3') },
+    { AV_CODEC_ID_MOV_TEXT, MKTAG('t','x','3','g') },
+    { AV_CODEC_ID_MOV_TEXT, MKTAG('t','e','x','t') },
+    { AV_CODEC_ID_NONE, 0 },
+};
+
+static const AVCodecTag codec_f4v_tags[] = {
+    { AV_CODEC_ID_MP3,    MKTAG('.','m','p','3') },
+    { AV_CODEC_ID_AAC,    MKTAG('m','p','4','a') },
+    { AV_CODEC_ID_H264,   MKTAG('a','v','c','1') },
+    { AV_CODEC_ID_VP6A,   MKTAG('V','P','6','A') },
+    { AV_CODEC_ID_VP6F,   MKTAG('V','P','6','F') },
+    { AV_CODEC_ID_NONE, 0 },
+};
+
 #if CONFIG_MOV_MUXER
 MOV_CLASS(mov)
 AVOutputFormat ff_mov_muxer = {
@@ -6233,7 +6611,7 @@ AVOutputFormat ff_mp4_muxer = {
     .write_trailer     = mov_write_trailer,
     .deinit            = mov_free,
     .flags             = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE,
-    .codec_tag         = (const AVCodecTag* const []){ ff_mp4_obj_type, 0 },
+    .codec_tag         = (const AVCodecTag* const []){ codec_mp4_tags, 0 },
     .check_bitstream   = mov_check_bitstream,
     .priv_class        = &mp4_muxer_class,
 };
@@ -6254,7 +6632,7 @@ AVOutputFormat ff_psp_muxer = {
     .write_trailer     = mov_write_trailer,
     .deinit            = mov_free,
     .flags             = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE,
-    .codec_tag         = (const AVCodecTag* const []){ ff_mp4_obj_type, 0 },
+    .codec_tag         = (const AVCodecTag* const []){ codec_mp4_tags, 0 },
     .check_bitstream   = mov_check_bitstream,
     .priv_class        = &psp_muxer_class,
 };
@@ -6316,7 +6694,8 @@ AVOutputFormat ff_ismv_muxer = {
     .write_trailer     = mov_write_trailer,
     .deinit            = mov_free,
     .flags             = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_TS_NEGATIVE,
-    .codec_tag         = (const AVCodecTag* const []){ ff_mp4_obj_type, 0 },
+    .codec_tag         = (const AVCodecTag* const []){
+        codec_mp4_tags, codec_ism_tags, 0 },
     .check_bitstream   = mov_check_bitstream,
     .priv_class        = &ismv_muxer_class,
 };
diff --git a/mythtv/external/FFmpeg/libavformat/movenc.h b/mythtv/external/FFmpeg/libavformat/movenc.h
index 1f7a9d7abda..cc2a155d79a 100644
--- a/mythtv/external/FFmpeg/libavformat/movenc.h
+++ b/mythtv/external/FFmpeg/libavformat/movenc.h
@@ -116,6 +116,7 @@ typedef struct MOVTrack {
     int64_t     start_cts;
     int64_t     end_pts;
     int         end_reliable;
+    int64_t     dts_shift;
 
     int         hint_track;   ///< the track that hints this track, -1 if no hint track is set
     int         src_track;    ///< the track that this hint (or tmcd) track describes
@@ -240,6 +241,8 @@ typedef struct MOVMuxContext {
 #define FF_MOV_FLAG_WRITE_COLR            (1 << 15)
 #define FF_MOV_FLAG_WRITE_GAMA            (1 << 16)
 #define FF_MOV_FLAG_USE_MDTA              (1 << 17)
+#define FF_MOV_FLAG_SKIP_TRAILER          (1 << 18)
+#define FF_MOV_FLAG_NEGATIVE_CTS_OFFSETS  (1 << 19)
 
 int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt);
 
diff --git a/mythtv/external/FFmpeg/libavformat/mp3dec.c b/mythtv/external/FFmpeg/libavformat/mp3dec.c
index 56c7f8caee2..a5c4f2ea127 100644
--- a/mythtv/external/FFmpeg/libavformat/mp3dec.c
+++ b/mythtv/external/FFmpeg/libavformat/mp3dec.c
@@ -142,7 +142,7 @@ static void mp3_parse_info_tag(AVFormatContext *s, AVStream *st,
                                MPADecodeHeader *c, uint32_t spf)
 {
 #define LAST_BITS(k, n) ((k) & ((1 << (n)) - 1))
-#define MIDDLE_BITS(k, m, n) LAST_BITS((k) >> (m), ((n) - (m)))
+#define MIDDLE_BITS(k, m, n) LAST_BITS((k) >> (m), ((n) - (m) + 1))
 
     uint16_t crc;
     uint32_t v;
@@ -349,6 +349,9 @@ static int mp3_read_header(AVFormatContext *s)
     int ret;
     int i;
 
+    s->metadata = s->internal->id3v2_meta;
+    s->internal->id3v2_meta = NULL;
+
     st = avformat_new_stream(s, NULL);
     if (!st)
         return AVERROR(ENOMEM);
@@ -367,7 +370,7 @@ static int mp3_read_header(AVFormatContext *s)
     if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
         ff_id3v1_read(s);
 
-    if(s->pb->seekable)
+    if(s->pb->seekable & AVIO_SEEKABLE_NORMAL)
         mp3->filesize = avio_size(s->pb);
 
     if (mp3_parse_vbr_tags(s, st, off) < 0)
@@ -457,7 +460,8 @@ static int check(AVIOContext *pb, int64_t pos, uint32_t *ret_header)
         return CHECK_SEEK_FAILED;
 
     ret = avio_read(pb, &header_buf[0], 4);
-    if (ret < 0)
+    /* We should always find four bytes for a valid mpa header. */
+    if (ret < 4)
         return CHECK_SEEK_FAILED;
 
     header = AV_RB32(&header_buf[0]);
diff --git a/mythtv/external/FFmpeg/libavformat/mp3enc.c b/mythtv/external/FFmpeg/libavformat/mp3enc.c
index 4c97fa113b8..8479e2485bb 100644
--- a/mythtv/external/FFmpeg/libavformat/mp3enc.c
+++ b/mythtv/external/FFmpeg/libavformat/mp3enc.c
@@ -144,7 +144,7 @@ static int mp3_write_xing(AVFormatContext *s)
     int ver = 0;
     int bytes_needed;
 
-    if (!s->pb->seekable || !mp3->write_xing)
+    if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL) || !mp3->write_xing)
         return 0;
 
     for (i = 0; i < FF_ARRAY_ELEMS(avpriv_mpa_freq_tab); i++) {
@@ -319,7 +319,7 @@ static int mp3_write_audio_packet(AVFormatContext *s, AVPacket *pkt)
             if ((mpah.bit_rate == 0) || (mp3->initial_bitrate != mpah.bit_rate))
                 mp3->has_variable_bitrate = 1;
         } else {
-            av_log(s, AV_LOG_WARNING, "Audio packet of size %d (starting with %08X...) "
+            av_log(s, AV_LOG_WARNING, "Audio packet of size %d (starting with %08"PRIX32"...) "
                    "is invalid, writing it anyway.\n", pkt->size, h);
         }
 
@@ -490,21 +490,6 @@ static int query_codec(enum AVCodecID id, int std_compliance)
     return -1;
 }
 
-#if CONFIG_MP2_MUXER
-AVOutputFormat ff_mp2_muxer = {
-    .name              = "mp2",
-    .long_name         = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
-    .mime_type         = "audio/mpeg",
-    .extensions        = "mp2,m2a,mpa",
-    .audio_codec       = AV_CODEC_ID_MP2,
-    .video_codec       = AV_CODEC_ID_NONE,
-    .write_packet      = ff_raw_write_packet,
-    .flags             = AVFMT_NOTIMESTAMPS,
-};
-#endif
-
-#if CONFIG_MP3_MUXER
-
 static const AVOption options[] = {
     { "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are supported.",
       offsetof(MP3Context, id3v2_version), AV_OPT_TYPE_INT, {.i64 = 4}, 0, 4, AV_OPT_FLAG_ENCODING_PARAM},
@@ -530,20 +515,15 @@ static int mp3_write_packet(AVFormatContext *s, AVPacket *pkt)
         if (mp3->pics_to_write) {
             /* buffer audio packets until we get all the pictures */
             AVPacketList *pktl = av_mallocz(sizeof(*pktl));
-            int ret;
-            if (!pktl) {
+
+            if (!pktl || av_packet_ref(&pktl->pkt, pkt) < 0) {
+                av_freep(&pktl);
                 av_log(s, AV_LOG_WARNING, "Not enough memory to buffer audio. Skipping picture streams\n");
                 mp3->pics_to_write = 0;
                 mp3_queue_flush(s);
                 return mp3_write_audio_packet(s, pkt);
             }
 
-            ret = av_copy_packet(&pktl->pkt, pkt);
-            if (ret < 0) {
-                av_freep(&pktl);
-                return ret;
-            }
-
             if (mp3->queue_end)
                 mp3->queue_end->next = pktl;
             else
@@ -652,4 +632,3 @@ AVOutputFormat ff_mp3_muxer = {
     .flags             = AVFMT_NOTIMESTAMPS,
     .priv_class        = &mp3_muxer_class,
 };
-#endif
diff --git a/mythtv/external/FFmpeg/libavformat/mpc.c b/mythtv/external/FFmpeg/libavformat/mpc.c
index 4bd1f5018b8..af333746e3a 100644
--- a/mythtv/external/FFmpeg/libavformat/mpc.c
+++ b/mythtv/external/FFmpeg/libavformat/mpc.c
@@ -104,7 +104,7 @@ static int mpc_read_header(AVFormatContext *s)
     st->duration = c->fcount;
 
     /* try to read APE tags */
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         int64_t pos = avio_tell(s->pb);
         ff_ape_parse_tag(s);
         if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
diff --git a/mythtv/external/FFmpeg/libavformat/mpc8.c b/mythtv/external/FFmpeg/libavformat/mpc8.c
index 05d0c1ae868..f280faa5ccd 100644
--- a/mythtv/external/FFmpeg/libavformat/mpc8.c
+++ b/mythtv/external/FFmpeg/libavformat/mpc8.c
@@ -239,7 +239,7 @@ static int mpc8_read_header(AVFormatContext *s)
     avio_skip(pb, 4); //CRC
     c->ver = avio_r8(pb);
     if(c->ver != 8){
-        av_log(s, AV_LOG_ERROR, "Unknown stream version %d\n", c->ver);
+        avpriv_report_missing_feature(s, "Stream version %d", c->ver);
         return AVERROR_PATCHWELCOME;
     }
     c->samples = ffio_read_varlen(pb);
@@ -264,7 +264,7 @@ static int mpc8_read_header(AVFormatContext *s)
     if (size > 0)
         avio_skip(pb, size);
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         int64_t pos = avio_tell(s->pb);
         c->apetag_start = ff_ape_parse_tag(s);
         avio_seek(s->pb, pos, SEEK_SET);
diff --git a/mythtv/external/FFmpeg/libavformat/mpeg.c b/mythtv/external/FFmpeg/libavformat/mpeg.c
index 47895353212..d7acc3a00e4 100644
--- a/mythtv/external/FFmpeg/libavformat/mpeg.c
+++ b/mythtv/external/FFmpeg/libavformat/mpeg.c
@@ -112,7 +112,7 @@ static int mpegps_probe(AVProbeData *p)
                           : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
     if ((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys &&
         !pspack && p->buf_size > 2048 && vid + audio > invalid) /* PES stream */
-        return (audio > 12 || vid > 3 + 2 * invalid) ? AVPROBE_SCORE_EXTENSION + 2
+        return (audio > 12 || vid > 6 + 2 * invalid) ? AVPROBE_SCORE_EXTENSION + 2
                                                      : AVPROBE_SCORE_EXTENSION / 2;
 
     // 02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
@@ -138,7 +138,7 @@ typedef struct MpegDemuxContext {
 static int mpegps_read_header(AVFormatContext *s)
 {
     MpegDemuxContext *m = s->priv_data;
-    char buffer[7];
+    char buffer[7] = { 0 };
     int64_t last_pos = avio_tell(s->pb);
 
     m->header_state = 0xff;
@@ -451,7 +451,7 @@ static int mpegps_read_pes_header(AVFormatContext *s,
         int i;
         for (i = 0; i < s->nb_streams; i++) {
             if (startcode == s->streams[i]->id &&
-                s->pb->seekable /* index useless on streams anyway */) {
+                (s->pb->seekable & AVIO_SEEKABLE_NORMAL) /* index useless on streams anyway */) {
                 ff_reduce_index(s, i);
                 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0,
                                    AVINDEX_KEYFRAME /* FIXME keyframe? */);
@@ -895,7 +895,7 @@ static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)
     FFDemuxSubtitlesQueue *q;
     AVIOContext *pb = vobsub->sub_ctx->pb;
     int ret, psize, total_read = 0, i;
-    AVPacket idx_pkt;
+    AVPacket idx_pkt = { 0 };
 
     int64_t min_ts = INT64_MAX;
     int sid = 0;
diff --git a/mythtv/external/FFmpeg/libavformat/mpegenc.c b/mythtv/external/FFmpeg/libavformat/mpegenc.c
index 878fa6381f1..c77c3dfe414 100644
--- a/mythtv/external/FFmpeg/libavformat/mpegenc.c
+++ b/mythtv/external/FFmpeg/libavformat/mpegenc.c
@@ -1146,6 +1146,8 @@ static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
         stream->next_packet = &stream->premux_packet;
     *stream->next_packet     =
     pkt_desc                 = av_mallocz(sizeof(PacketDesc));
+    if (!pkt_desc)
+        return AVERROR(ENOMEM);
     pkt_desc->pts            = pts;
     pkt_desc->dts            = dts;
     pkt_desc->unwritten_size =
diff --git a/mythtv/external/FFmpeg/libavformat/mpegts.c b/mythtv/external/FFmpeg/libavformat/mpegts.c
index c6277fd723f..eb9fea1f671 100644
--- a/mythtv/external/FFmpeg/libavformat/mpegts.c
+++ b/mythtv/external/FFmpeg/libavformat/mpegts.c
@@ -814,7 +814,7 @@ static int mpegts_set_stream_info(AVStream *st, PESContext *pes,
     st->codecpar->codec_tag = pes->stream_type;
 
     mpegts_find_stream_type(st, pes->stream_type, ISO_types);
-    if (pes->stream_type == 4)
+    if (pes->stream_type == 4 || pes->stream_type == 0x0f)
         st->request_probe = 50;
     if ((prog_reg_desc == AV_RL32("HDMV") ||
          prog_reg_desc == AV_RL32("HDPR")) &&
@@ -881,7 +881,7 @@ static void reset_pes_packet_state(PESContext *pes)
 static void new_data_packet(const uint8_t *buffer, int len, AVPacket *pkt)
 {
     av_init_packet(pkt);
-    pkt->data = buffer;
+    pkt->data = (uint8_t *)buffer;
     pkt->size = len;
 }
 
@@ -2605,7 +2605,7 @@ static void seek_back(AVFormatContext *s, AVIOContext *pb, int64_t pos) {
      * probe buffer usually is big enough. Only warn if the seek failed
      * on files where the seek should work. */
     if (avio_seek(pb, pos, SEEK_SET) < 0)
-        av_log(s, pb->seekable ? AV_LOG_ERROR : AV_LOG_INFO, "Unable to seek back to the start\n");
+        av_log(s, (pb->seekable & AVIO_SEEKABLE_NORMAL) ? AV_LOG_ERROR : AV_LOG_INFO, "Unable to seek back to the start\n");
 }
 
 static int mpegts_read_header(AVFormatContext *s)
@@ -2616,6 +2616,8 @@ static int mpegts_read_header(AVFormatContext *s)
     int len;
     int64_t pos, probesize = s->probesize;
 
+    s->internal->prefer_codec_framerate = 1;
+
     if (ffio_ensure_seekback(pb, probesize) < 0)
         av_log(s, AV_LOG_WARNING, "Failed to allocate buffers for seekback\n");
 
@@ -2681,8 +2683,17 @@ static int mpegts_read_header(AVFormatContext *s)
                 packet_count[nb_pcrs] = nb_packets;
                 pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
                 nb_pcrs++;
-                if (nb_pcrs >= 2)
-                    break;
+                if (nb_pcrs >= 2) {
+                    if (pcrs[1] - pcrs[0] > 0) {
+                        /* the difference needs to be positive to make sense for bitrate computation */
+                        break;
+                    } else {
+                        av_log(ts->stream, AV_LOG_WARNING, "invalid pcr pair %"PRId64" >= %"PRId64"\n", pcrs[0], pcrs[1]);
+                        pcrs[0] = pcrs[1];
+                        packet_count[0] = packet_count[1];
+                        nb_pcrs--;
+                    }
+                }
             } else {
                 finished_reading_packet(s, ts->raw_packet_size);
             }
diff --git a/mythtv/external/FFmpeg/libavformat/mpegtsenc.c b/mythtv/external/FFmpeg/libavformat/mpegtsenc.c
index 3ad3de705c1..fdfa544ee26 100644
--- a/mythtv/external/FFmpeg/libavformat/mpegtsenc.c
+++ b/mythtv/external/FFmpeg/libavformat/mpegtsenc.c
@@ -46,6 +46,7 @@
 typedef struct MpegTSSection {
     int pid;
     int cc;
+    int discontinuity;
     void (*write_packet)(struct MpegTSSection *s, const uint8_t *packet);
     void *opaque;
 } MpegTSSection;
@@ -104,6 +105,7 @@ typedef struct MpegTSWrite {
 #define MPEGTS_FLAG_AAC_LATM        0x02
 #define MPEGTS_FLAG_PAT_PMT_AT_FRAMES           0x04
 #define MPEGTS_FLAG_SYSTEM_B        0x08
+#define MPEGTS_FLAG_DISCONT         0x10
     int flags;
     int copyts;
     int tables_version;
@@ -153,6 +155,12 @@ static void mpegts_write_section(MpegTSSection *s, uint8_t *buf, int len)
         *q++  = s->pid;
         s->cc = s->cc + 1 & 0xf;
         *q++  = 0x10 | s->cc;
+        if (s->discontinuity) {
+            q[-1] |= 0x20;
+            *q++ = 1;
+            *q++ = 0x80;
+            s->discontinuity = 0;
+        }
         if (first)
             *q++ = 0; /* 0 offset */
         len1 = TS_PACKET_SIZE - (q - packet);
@@ -223,6 +231,7 @@ typedef struct MpegTSWriteStream {
     struct MpegTSService *service;
     int pid; /* stream associated pid */
     int cc;
+    int discontinuity;
     int payload_size;
     int first_pts_check; ///< first pts check needed
     int prev_payload_key;
@@ -255,6 +264,28 @@ static void mpegts_write_pat(AVFormatContext *s)
                           data, q - data);
 }
 
+/* NOTE: !str is accepted for an empty string */
+static void putstr8(uint8_t **q_ptr, const char *str, int write_len)
+{
+    uint8_t *q;
+    int len;
+
+    q = *q_ptr;
+    if (!str)
+        len = 0;
+    else
+        len = strlen(str);
+    if (write_len)
+        *q++ = len;
+    if (!str) {
+        *q_ptr = q;
+        return;
+    }
+    memcpy(q, str, len);
+    q     += len;
+    *q_ptr = q;
+}
+
 static int mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
 {
     MpegTSWrite *ts = s->priv_data;
@@ -611,12 +642,15 @@ static int mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
                 *q++ = 'V';
                 *q++ = 'A';
             } else if (st->codecpar->codec_id == AV_CODEC_ID_TIMED_ID3) {
-                *q++ = 0x5; /* MPEG-2 registration descriptor */
-                *q++ = 4;
-                *q++ = 'I';
-                *q++ = 'D';
-                *q++ = '3';
-                *q++ = ' ';
+                const char *tag = "ID3 ";
+                *q++ = 0x26; /* metadata descriptor */
+                *q++ = 13;
+                put16(&q, 0xffff);    /* metadata application format */
+                putstr8(&q, tag, 0);
+                *q++ = 0xff;        /* metadata format */
+                putstr8(&q, tag, 0);
+                *q++ = 0;            /* metadata service ID */
+                *q++ = 0xF;          /* metadata_locator_record_flag|MPEG_carriage_flags|reserved */
             }
             break;
         }
@@ -637,23 +671,6 @@ static int mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
     return 0;
 }
 
-/* NOTE: !str is accepted for an empty string */
-static void putstr8(uint8_t **q_ptr, const char *str)
-{
-    uint8_t *q;
-    int len;
-
-    q = *q_ptr;
-    if (!str)
-        len = 0;
-    else
-        len = strlen(str);
-    *q++ = len;
-    memcpy(q, str, len);
-    q     += len;
-    *q_ptr = q;
-}
-
 static void mpegts_write_sdt(AVFormatContext *s)
 {
     MpegTSWrite *ts = s->priv_data;
@@ -678,8 +695,8 @@ static void mpegts_write_sdt(AVFormatContext *s)
         desc_len_ptr = q;
         q++;
         *q++         = ts->service_type;
-        putstr8(&q, service->provider_name);
-        putstr8(&q, service->name);
+        putstr8(&q, service->provider_name, 1);
+        putstr8(&q, service->name, 1);
         desc_len_ptr[0] = q - desc_len_ptr - 1;
 
         /* fill descriptor length */
@@ -782,6 +799,7 @@ static int mpegts_init(AVFormatContext *s)
         service->pmt.write_packet = section_write_packet;
         service->pmt.opaque       = s;
         service->pmt.cc           = 15;
+        service->pmt.discontinuity= ts->flags & MPEGTS_FLAG_DISCONT;
     } else {
         for (i = 0; i < s->nb_programs; i++) {
             AVProgram *program = s->programs[i];
@@ -800,6 +818,7 @@ static int mpegts_init(AVFormatContext *s)
             service->pmt.write_packet = section_write_packet;
             service->pmt.opaque       = s;
             service->pmt.cc           = 15;
+            service->pmt.discontinuity= ts->flags & MPEGTS_FLAG_DISCONT;
             service->program          = program;
         }
     }
@@ -808,11 +827,13 @@ static int mpegts_init(AVFormatContext *s)
     /* Initialize at 15 so that it wraps and is equal to 0 for the
      * first packet we write. */
     ts->pat.cc           = 15;
+    ts->pat.discontinuity= ts->flags & MPEGTS_FLAG_DISCONT;
     ts->pat.write_packet = section_write_packet;
     ts->pat.opaque       = s;
 
     ts->sdt.pid          = SDT_PID;
     ts->sdt.cc           = 15;
+    ts->sdt.discontinuity= ts->flags & MPEGTS_FLAG_DISCONT;
     ts->sdt.write_packet = section_write_packet;
     ts->sdt.opaque       = s;
 
@@ -883,6 +904,7 @@ static int mpegts_init(AVFormatContext *s)
         ts_st->payload_dts     = AV_NOPTS_VALUE;
         ts_st->first_pts_check = 1;
         ts_st->cc              = 15;
+        ts_st->discontinuity   = ts->flags & MPEGTS_FLAG_DISCONT;
         /* update PCR pid by using the first video stream */
         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
             service->pcr_pid == 0x1fff) {
@@ -1078,6 +1100,10 @@ static void mpegts_insert_pcr_only(AVFormatContext *s, AVStream *st)
     /* Continuity Count field does not increment (see 13818-1 section 2.4.3.3) */
     *q++ = TS_PACKET_SIZE - 5; /* Adaptation Field Length */
     *q++ = 0x10;               /* Adaptation flags: PCR present */
+    if (ts_st->discontinuity) {
+        q[-1] |= 0x80;
+        ts_st->discontinuity = 0;
+    }
 
     /* PCR coded into 6 bytes */
     q += write_pcr_bits(q, get_pcr(ts, s->pb));
@@ -1195,6 +1221,11 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
         *q++      = ts_st->pid;
         ts_st->cc = ts_st->cc + 1 & 0xf;
         *q++      = 0x10 | ts_st->cc; // payload indicator + CC
+        if (ts_st->discontinuity) {
+            set_af_flag(buf, 0x80);
+            q = get_ts_payload_start(buf);
+            ts_st->discontinuity = 0;
+        }
         if (key && is_start && pts != AV_NOPTS_VALUE) {
             // set Random Access for key frames
             if (ts_st->pid == ts_st->service->pcr_pid)
@@ -1406,7 +1437,8 @@ int ff_check_h264_startcode(AVFormatContext *s, const AVStream *st, const AVPack
             return AVERROR_INVALIDDATA;
         }
         av_log(s, AV_LOG_WARNING, "H.264 bitstream error, startcode missing, size %d", pkt->size);
-        if (pkt->size) av_log(s, AV_LOG_WARNING, " data %08X", AV_RB32(pkt->data));
+        if (pkt->size)
+            av_log(s, AV_LOG_WARNING, " data %08"PRIX32, AV_RB32(pkt->data));
         av_log(s, AV_LOG_WARNING, "\n");
     }
     return 0;
@@ -1420,7 +1452,8 @@ static int check_hevc_startcode(AVFormatContext *s, const AVStream *st, const AV
             return AVERROR_PATCHWELCOME;
         }
         av_log(s, AV_LOG_WARNING, "HEVC bitstream error, startcode missing, size %d", pkt->size);
-        if (pkt->size) av_log(s, AV_LOG_WARNING, " data %08X", AV_RB32(pkt->data));
+        if (pkt->size)
+            av_log(s, AV_LOG_WARNING, " data %08"PRIX32, AV_RB32(pkt->data));
         av_log(s, AV_LOG_WARNING, "\n");
     }
     return 0;
@@ -1538,7 +1571,7 @@ static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
 
         do {
             p = avpriv_find_start_code(p, buf_end, &state);
-            av_log(s, AV_LOG_TRACE, "nal %d\n", state & 0x1f);
+            av_log(s, AV_LOG_TRACE, "nal %"PRId32"\n", state & 0x1f);
             if ((state & 0x1f) == 7)
                 extradd = 0;
         } while (p < buf_end && (state & 0x1f) != 9 &&
@@ -1592,9 +1625,39 @@ static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
             }
         }
     } else if (st->codecpar->codec_id == AV_CODEC_ID_HEVC) {
+        const uint8_t *p = buf, *buf_end = p + size;
+        uint32_t state = -1;
+        int extradd = (pkt->flags & AV_PKT_FLAG_KEY) ? st->codecpar->extradata_size : 0;
         int ret = check_hevc_startcode(s, st, pkt);
         if (ret < 0)
             return ret;
+
+        if (extradd && AV_RB24(st->codecpar->extradata) > 1)
+            extradd = 0;
+
+        do {
+            p = avpriv_find_start_code(p, buf_end, &state);
+            av_log(s, AV_LOG_TRACE, "nal %"PRId32"\n", (state & 0x7e)>>1);
+            if ((state & 0x7e) == 2*32)
+                extradd = 0;
+        } while (p < buf_end && (state & 0x7e) != 2*35 &&
+                 (state & 0x7e) >= 2*32);
+
+        if ((state & 0x7e) < 2*16 && (state & 0x7e) >= 2*24)
+            extradd = 0;
+        if ((state & 0x7e) != 2*35) { // AUD NAL
+            data = av_malloc(pkt->size + 7 + extradd);
+            if (!data)
+                return AVERROR(ENOMEM);
+            memcpy(data + 7, st->codecpar->extradata, extradd);
+            memcpy(data + 7 + extradd, pkt->data, pkt->size);
+            AV_WB32(data, 0x00000001);
+            data[4] = 2*35;
+            data[5] = 1;
+            data[6] = 0x50; // any slice type (0x4) + rbsp stop one bit
+            buf     = data;
+            size    = pkt->size + 7 + extradd;
+        }
     } else if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
         if (pkt->size < 2) {
             av_log(s, AV_LOG_ERROR, "Opus packet too short\n");
@@ -1872,6 +1935,9 @@ static const AVOption options[] = {
     { "system_b", "Conform to System B (DVB) instead of System A (ATSC)",
       0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_SYSTEM_B }, 0, INT_MAX,
       AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
+    { "initial_discontinuity", "Mark initial packets as discontinuous",
+      0, AV_OPT_TYPE_CONST, { .i64 = MPEGTS_FLAG_DISCONT }, 0, INT_MAX,
+      AV_OPT_FLAG_ENCODING_PARAM, "mpegts_flags" },
     // backward compatibility
     { "resend_headers", "Reemit PAT/PMT before writing the next packet",
       offsetof(MpegTSWrite, reemit_pat_pmt), AV_OPT_TYPE_INT,
@@ -1885,7 +1951,7 @@ static const AVOption options[] = {
     { "omit_video_pes_length", "Omit the PES packet length for video packets",
       offsetof(MpegTSWrite, omit_video_pes_length), AV_OPT_TYPE_BOOL,
       { .i64 = 1 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
-    { "pcr_period", "PCR retransmission time",
+    { "pcr_period", "PCR retransmission time in milliseconds",
       offsetof(MpegTSWrite, pcr_period), AV_OPT_TYPE_INT,
       { .i64 = PCR_RETRANS_TIME }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
     { "pat_period", "PAT/PMT retransmission time limit in seconds",
diff --git a/mythtv/external/FFmpeg/libavformat/mpjpegdec.c b/mythtv/external/FFmpeg/libavformat/mpjpegdec.c
index 4c7764412f0..83aa70d0c97 100644
--- a/mythtv/external/FFmpeg/libavformat/mpjpegdec.c
+++ b/mythtv/external/FFmpeg/libavformat/mpjpegdec.c
@@ -126,7 +126,7 @@ static int mpjpeg_read_probe(AVProbeData *p)
 
     ret = (parse_multipart_header(pb, &size, "--", NULL) >= 0) ? AVPROBE_SCORE_MAX : 0;
 
-    av_free(pb);
+    avio_context_free(&pb);
 
     return ret;
 }
diff --git a/mythtv/external/FFmpeg/libavformat/mpl2dec.c b/mythtv/external/FFmpeg/libavformat/mpl2dec.c
index 59589d5b5e8..dfcdf5a5645 100644
--- a/mythtv/external/FFmpeg/libavformat/mpl2dec.c
+++ b/mythtv/external/FFmpeg/libavformat/mpl2dec.c
@@ -23,6 +23,8 @@
  * MPL2 subtitles format demuxer
  */
 
+#include "libavutil/intreadwrite.h"
+
 #include "avformat.h"
 #include "internal.h"
 #include "subtitles.h"
@@ -39,6 +41,9 @@ static int mpl2_probe(AVProbeData *p)
     const unsigned char *ptr = p->buf;
     const unsigned char *ptr_end = ptr + p->buf_size;
 
+    if (AV_RB24(ptr) == 0xefbbbf)
+        ptr += 3;
+
     for (i = 0; i < 2; i++) {
         if (sscanf(ptr, "[%"SCNd64"][%"SCNd64"]%c", &start, &end, &c) != 3 &&
             sscanf(ptr, "[%"SCNd64"][]%c",          &start,       &c) != 2)
@@ -83,6 +88,9 @@ static int mpl2_read_header(AVFormatContext *s)
     st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
     st->codecpar->codec_id   = AV_CODEC_ID_MPL2;
 
+    if (avio_rb24(s->pb) != 0xefbbbf)
+        avio_seek(s->pb, -3, SEEK_CUR);
+
     while (!avio_feof(s->pb)) {
         char line[4096];
         char *p = line;
diff --git a/mythtv/external/FFmpeg/libavformat/msf.c b/mythtv/external/FFmpeg/libavformat/msf.c
index 24654e65698..6bd18f29bd7 100644
--- a/mythtv/external/FFmpeg/libavformat/msf.c
+++ b/mythtv/external/FFmpeg/libavformat/msf.c
@@ -42,7 +42,7 @@ static int msf_probe(AVProbeData *p)
 
 static int msf_read_header(AVFormatContext *s)
 {
-    unsigned codec, align, size;
+    unsigned codec, size;
     AVStream *st;
     int ret;
 
@@ -61,12 +61,10 @@ static int msf_read_header(AVFormatContext *s)
     st->codecpar->sample_rate = avio_rb32(s->pb);
     if (st->codecpar->sample_rate <= 0)
         return AVERROR_INVALIDDATA;
-    align = avio_rb32(s->pb) ;
-    if (align > INT_MAX / st->codecpar->channels)
-        return AVERROR_INVALIDDATA;
-    st->codecpar->block_align = align;
+    // avio_rb32(s->pb); /* byte flags with encoder info */
     switch (codec) {
     case 0: st->codecpar->codec_id = AV_CODEC_ID_PCM_S16BE; break;
+    case 1: st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE; break;
     case 3: st->codecpar->block_align = 16 * st->codecpar->channels;
             st->codecpar->codec_id = AV_CODEC_ID_ADPCM_PSX; break;
     case 4:
@@ -76,8 +74,10 @@ static int msf_read_header(AVFormatContext *s)
             if (ret < 0)
                 return ret;
             memset(st->codecpar->extradata, 0, st->codecpar->extradata_size);
-            AV_WL16(st->codecpar->extradata, 1);
-            AV_WL16(st->codecpar->extradata+4, 4096);
+            AV_WL16(st->codecpar->extradata, 1); /* version */
+            AV_WL16(st->codecpar->extradata+2, 2048 * st->codecpar->channels); /* unknown size */
+            AV_WL16(st->codecpar->extradata+6, codec == 4 ? 1 : 0); /* joint stereo */
+            AV_WL16(st->codecpar->extradata+8, codec == 4 ? 1 : 0); /* joint stereo (repeat?) */
             AV_WL16(st->codecpar->extradata+10, 1);
             st->codecpar->codec_id = AV_CODEC_ID_ATRAC3;    break;
     case 7: st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
diff --git a/mythtv/external/FFmpeg/libavformat/mux.c b/mythtv/external/FFmpeg/libavformat/mux.c
index 06d87dec7fb..53ad46df42d 100644
--- a/mythtv/external/FFmpeg/libavformat/mux.c
+++ b/mythtv/external/FFmpeg/libavformat/mux.c
@@ -309,12 +309,6 @@ FF_DISABLE_DEPRECATION_WARNINGS
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
 
-        /* update internal context from codecpar, old bsf api needs this
-         * FIXME: remove when autobsf uses new bsf API */
-        ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
-        if (ret < 0)
-            goto fail;
-
         if (!st->time_base.num) {
             /* fall back on the default timebase values */
             if (par->codec_type == AVMEDIA_TYPE_AUDIO && par->sample_rate)
@@ -376,12 +370,10 @@ FF_ENABLE_DEPRECATION_WARNINGS
             }
             if (par->codec_tag) {
                 if (!validate_codec_tag(s, st)) {
-                    char tagbuf[32], tagbuf2[32];
-                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), par->codec_tag);
-                    av_get_codec_tag_string(tagbuf2, sizeof(tagbuf2), av_codec_get_tag(s->oformat->codec_tag, par->codec_id));
+                    const uint32_t otag = av_codec_get_tag(s->oformat->codec_tag, par->codec_id);
                     av_log(s, AV_LOG_ERROR,
-                           "Tag %s/0x%08x incompatible with output codec id '%d' (%s)\n",
-                           tagbuf, par->codec_tag, par->codec_id, tagbuf2);
+                           "Tag %s incompatible with output codec id '%d' (%s)\n",
+                           av_fourcc2str(par->codec_tag), par->codec_id, av_fourcc2str(otag));
                     ret = AVERROR_INVALIDDATA;
                     goto fail;
                 }
@@ -476,6 +468,16 @@ static int init_pts(AVFormatContext *s)
     return 0;
 }
 
+static void flush_if_needed(AVFormatContext *s)
+{
+    if (s->pb && s->pb->error >= 0) {
+        if (s->flush_packets == 1 || s->flags & AVFMT_FLAG_FLUSH_PACKETS)
+            avio_flush(s->pb);
+        else if (s->flush_packets && !(s->oformat->flags & AVFMT_NOFILE))
+            avio_write_marker(s->pb, AV_NOPTS_VALUE, AVIO_DATA_MARKER_FLUSH_POINT);
+    }
+}
+
 static int write_header_internal(AVFormatContext *s)
 {
     if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
@@ -487,8 +489,7 @@ static int write_header_internal(AVFormatContext *s)
         s->internal->write_header_ret = ret;
         if (ret < 0)
             return ret;
-        if (s->flush_packets && s->pb && s->pb->error >= 0 && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
-            avio_flush(s->pb);
+        flush_if_needed(s);
     }
     s->internal->header_written = 1;
     if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
@@ -581,6 +582,7 @@ static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *
 
     if (!s->internal->missing_ts_warning &&
         !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
+        (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC) || (st->disposition & AV_DISPOSITION_TIMED_THUMBNAILS)) &&
         (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
         av_log(s, AV_LOG_WARNING,
                "Timestamps are unset in a packet for stream %d. "
@@ -698,6 +700,8 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
     pts_backup = pkt->pts;
     dts_backup = pkt->dts;
 
+    // If the timestamp offsetting below is adjusted, adjust
+    // ff_interleaved_peek similarly.
     if (s->output_ts_offset) {
         AVStream *st = s->streams[pkt->stream_index];
         int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
@@ -737,7 +741,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
                 av_log(s, AV_LOG_WARNING, "failed to avoid negative "
                     "pts %s in stream %d.\n"
                     "Try -avoid_negative_ts 1 as a possible workaround.\n",
-                    av_ts2str(pkt->dts),
+                    av_ts2str(pkt->pts),
                     pkt->stream_index
                 );
             }
@@ -755,7 +759,11 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
         }
     }
 
+#if FF_API_LAVF_MERGE_SD
+FF_DISABLE_DEPRECATION_WARNINGS
     did_split = av_packet_split_side_data(pkt);
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
 
     if (!s->internal->header_written) {
         ret = s->internal->write_header_ret ? s->internal->write_header_ret : write_header_internal(s);
@@ -773,15 +781,18 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
     }
 
     if (s->pb && ret >= 0) {
-        if (s->flush_packets && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
-            avio_flush(s->pb);
+        flush_if_needed(s);
         if (s->pb->error < 0)
             ret = s->pb->error;
     }
 
 fail:
+#if FF_API_LAVF_MERGE_SD
+FF_DISABLE_DEPRECATION_WARNINGS
     if (did_split)
         av_packet_merge_side_data(pkt);
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
 
     if (ret < 0) {
         pkt->pts = pts_backup;
@@ -818,7 +829,7 @@ static int prepare_input_packet(AVFormatContext *s, AVPacket *pkt)
     if (ret < 0)
         return ret;
 
-#if !FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
+#if !FF_API_COMPUTE_PKT_FIELDS2 || !FF_API_LAVF_AVCTX
     /* sanitize the timestamps */
     if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
         AVStream *st = s->streams[pkt->stream_index];
@@ -878,20 +889,23 @@ static int do_packet_auto_bsf(AVFormatContext *s, AVPacket *pkt) {
         }
     }
 
+#if FF_API_LAVF_MERGE_SD
+FF_DISABLE_DEPRECATION_WARNINGS
+    if (st->internal->nb_bsfcs) {
+        ret = av_packet_split_side_data(pkt);
+        if (ret < 0)
+            av_log(s, AV_LOG_WARNING, "Failed to split side data before bitstream filter\n");
+    }
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
+
     for (i = 0; i < st->internal->nb_bsfcs; i++) {
         AVBSFContext *ctx = st->internal->bsfcs[i];
-        if (i > 0) {
-            AVBSFContext* prev_ctx = st->internal->bsfcs[i - 1];
-            if (prev_ctx->par_out->extradata_size != ctx->par_in->extradata_size) {
-                if ((ret = avcodec_parameters_copy(ctx->par_in, prev_ctx->par_out)) < 0)
-                    return ret;
-            }
-        }
         // TODO: when any bitstream filter requires flushing at EOF, we'll need to
         // flush each stream's BSF chain on write_trailer.
         if ((ret = av_bsf_send_packet(ctx, pkt)) < 0) {
             av_log(ctx, AV_LOG_ERROR,
-                    "Failed to send packet to filter %s for stream %d",
+                    "Failed to send packet to filter %s for stream %d\n",
                     ctx->filter->name, pkt->stream_index);
             return ret;
         }
@@ -902,16 +916,10 @@ static int do_packet_auto_bsf(AVFormatContext *s, AVPacket *pkt) {
             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                 return 0;
             av_log(ctx, AV_LOG_ERROR,
-                    "Failed to send packet to filter %s for stream %d",
+                    "Failed to send packet to filter %s for stream %d\n",
                     ctx->filter->name, pkt->stream_index);
             return ret;
         }
-        if (i == st->internal->nb_bsfcs - 1) {
-            if (ctx->par_out->extradata_size != st->codecpar->extradata_size) {
-                if ((ret = avcodec_parameters_copy(st->codecpar, ctx->par_out)) < 0)
-                    return ret;
-            }
-        }
     }
     return 1;
 }
@@ -932,8 +940,7 @@ int av_write_frame(AVFormatContext *s, AVPacket *pkt)
                     return ret;
             }
             ret = s->oformat->write_packet(s, NULL);
-            if (s->flush_packets && s->pb && s->pb->error >= 0 && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
-                avio_flush(s->pb);
+            flush_if_needed(s);
             if (ret >= 0 && s->pb && s->pb->error < 0)
                 ret = s->pb->error;
             return ret;
@@ -1183,23 +1190,30 @@ int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
     }
 }
 
-const AVPacket *ff_interleaved_peek(AVFormatContext *s, int stream, int64_t *ts_offset)
+int ff_interleaved_peek(AVFormatContext *s, int stream,
+                        AVPacket *pkt, int add_offset)
 {
     AVPacketList *pktl = s->internal->packet_buffer;
     while (pktl) {
         if (pktl->pkt.stream_index == stream) {
-            AVPacket *pkt = &pktl->pkt;
-            AVStream *st = s->streams[pkt->stream_index];
-            *ts_offset = st->mux_ts_offset;
-
-            if (s->output_ts_offset)
-                *ts_offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
-
-            return pkt;
+            *pkt = pktl->pkt;
+            if (add_offset) {
+                AVStream *st = s->streams[pkt->stream_index];
+                int64_t offset = st->mux_ts_offset;
+
+                if (s->output_ts_offset)
+                    offset += av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);
+
+                if (pkt->dts != AV_NOPTS_VALUE)
+                    pkt->dts += offset;
+                if (pkt->pts != AV_NOPTS_VALUE)
+                    pkt->pts += offset;
+            }
+            return 0;
         }
         pktl = pktl->next;
     }
-    return NULL;
+    return AVERROR(ENOENT);
 }
 
 /**
@@ -1402,7 +1416,7 @@ static int av_write_uncoded_frame_internal(AVFormatContext *s, int stream_index,
         pkt.size         = UNCODED_FRAME_PACKET_SIZE;
         pkt.pts          =
         pkt.dts          = frame->pts;
-        pkt.duration     = av_frame_get_pkt_duration(frame);
+        pkt.duration     = frame->pkt_duration;
         pkt.stream_index = stream_index;
         pkt.flags |= AV_PKT_FLAG_UNCODED_FRAME;
     }
diff --git a/mythtv/external/FFmpeg/libavformat/mvdec.c b/mythtv/external/FFmpeg/libavformat/mvdec.c
index 80ef4b1569a..f7aa4cbaecf 100644
--- a/mythtv/external/FFmpeg/libavformat/mvdec.c
+++ b/mythtv/external/FFmpeg/libavformat/mvdec.c
@@ -317,6 +317,10 @@ static int mv_read_header(AVFormatContext *avctx)
         ast->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;
         ast->nb_frames          = vst->nb_frames;
         ast->codecpar->sample_rate = avio_rb32(pb);
+        if (ast->codecpar->sample_rate <= 0) {
+            av_log(avctx, AV_LOG_ERROR, "Invalid sample rate %d\n", ast->codecpar->sample_rate);
+            return AVERROR_INVALIDDATA;
+        }
         avpriv_set_pts_info(ast, 33, 1, ast->codecpar->sample_rate);
         if (set_channels(avctx, ast, avio_rb32(pb)) < 0)
             return AVERROR_INVALIDDATA;
@@ -338,6 +342,8 @@ static int mv_read_header(AVFormatContext *avctx)
             uint32_t pos   = avio_rb32(pb);
             uint32_t asize = avio_rb32(pb);
             uint32_t vsize = avio_rb32(pb);
+            if (avio_feof(pb))
+                return AVERROR_INVALIDDATA;
             avio_skip(pb, 8);
             av_add_index_entry(ast, pos, timestamp, asize, 0, AVINDEX_KEYFRAME);
             av_add_index_entry(vst, pos + asize, i, vsize, 0, AVINDEX_KEYFRAME);
@@ -417,7 +423,7 @@ static int mv_read_packet(AVFormatContext *avctx, AVPacket *pkt)
         if (index->pos > pos)
             avio_skip(pb, index->pos - pos);
         else if (index->pos < pos) {
-            if (!pb->seekable)
+            if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
                 return AVERROR(EIO);
             ret = avio_seek(pb, index->pos, SEEK_SET);
             if (ret < 0)
@@ -459,7 +465,7 @@ static int mv_read_seek(AVFormatContext *avctx, int stream_index,
     if ((flags & AVSEEK_FLAG_FRAME) || (flags & AVSEEK_FLAG_BYTE))
         return AVERROR(ENOSYS);
 
-    if (!avctx->pb->seekable)
+    if (!(avctx->pb->seekable & AVIO_SEEKABLE_NORMAL))
         return AVERROR(EIO);
 
     frame = av_index_search_timestamp(st, timestamp, flags);
diff --git a/mythtv/external/FFmpeg/libavformat/mxf.c b/mythtv/external/FFmpeg/libavformat/mxf.c
index e9c48e8d7fd..bfc3218b815 100644
--- a/mythtv/external/FFmpeg/libavformat/mxf.c
+++ b/mythtv/external/FFmpeg/libavformat/mxf.c
@@ -61,6 +61,7 @@ const MXFCodecUL ff_mxf_codec_uls[] = {
     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x31,0x11,0x01 }, 14,       AV_CODEC_ID_H264 }, /* H.264/MPEG-4 AVC SPS/PPS in-band */
     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x01,0x01,0x02,0x02,0x01 }, 16,       AV_CODEC_ID_V210 }, /* V210 */
     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0E,0x04,0x02,0x01,0x02,0x11,0x00,0x00 }, 14,     AV_CODEC_ID_PRORES }, /* Avid MC7 ProRes */
+    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0D,0x04,0x01,0x02,0x02,0x03,0x06,0x00,0x00 }, 14,     AV_CODEC_ID_PRORES }, /* Apple ProRes */
     /* SoundEssenceCompression */
     { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14,        AV_CODEC_ID_AAC }, /* MPEG-2 AAC ADTS (legacy) */
     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x02,0x02,0x01,0x00,0x00,0x00,0x00 }, 13,  AV_CODEC_ID_PCM_S16LE }, /* uncompressed */
diff --git a/mythtv/external/FFmpeg/libavformat/mxfdec.c b/mythtv/external/FFmpeg/libavformat/mxfdec.c
index d2166ee5a19..118e3e40b44 100644
--- a/mythtv/external/FFmpeg/libavformat/mxfdec.c
+++ b/mythtv/external/FFmpeg/libavformat/mxfdec.c
@@ -391,7 +391,7 @@ static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
     for (i = 0; i < s->nb_streams; i++) {
         MXFTrack *track = s->streams[i]->priv_data;
         /* SMPTE 379M 7.3 */
-        if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
+        if (track && !memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
             return i;
     }
     /* return 0 if only one stream, for OP Atom files with 0 as track number */
@@ -500,7 +500,7 @@ static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, U
         avpriv_request_sample(pb, "Primer pack item length %d", item_len);
         return AVERROR_PATCHWELCOME;
     }
-    if (item_num > 65536) {
+    if (item_num > 65536 || item_num < 0) {
         av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
         return AVERROR_INVALIDDATA;
     }
@@ -899,6 +899,8 @@ static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *seg
     segment->nb_index_entries = avio_rb32(pb);
 
     length = avio_rb32(pb);
+    if(segment->nb_index_entries && length < 11)
+        return AVERROR_INVALIDDATA;
 
     if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
         !(segment->flag_entries          = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
@@ -909,6 +911,8 @@ static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *seg
     }
 
     for (i = 0; i < segment->nb_index_entries; i++) {
+        if(avio_feof(pb))
+            return AVERROR_INVALIDDATA;
         segment->temporal_offset_entries[i] = avio_r8(pb);
         avio_r8(pb);                                        /* KeyFrameOffset */
         segment->flag_entries[i] = avio_r8(pb);
@@ -1200,7 +1204,7 @@ static const MXFCodecUL mxf_data_essence_container_uls[] = {
     { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },  0, AV_CODEC_ID_NONE },
 };
 
-static const char* const mxf_data_essence_descriptor[] = {
+static const char * const mxf_data_essence_descriptor[] = {
     "vbi_vanc_smpte_436M",
 };
 
@@ -1974,7 +1978,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf)
             source_package = mxf_resolve_source_package(mxf, component->source_package_uid);
             if (!source_package) {
                 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
-                break;
+                continue;
             }
             for (k = 0; k < source_package->tracks_count; k++) {
                 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
@@ -2590,7 +2594,7 @@ static int mxf_parse_handle_essence(MXFContext *mxf)
         /* remember where we were so we don't end up seeking further back than this */
         mxf->last_forward_tell = avio_tell(pb);
 
-        if (!pb->seekable) {
+        if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
             av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
             return -1;
         }
@@ -2777,7 +2781,7 @@ static void mxf_read_random_index_pack(AVFormatContext *s)
     int64_t file_size, max_rip_length, min_rip_length;
     KLVPacket klv;
 
-    if (!s->pb->seekable)
+    if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
         return;
 
     file_size = avio_size(s->pb);
@@ -3056,6 +3060,32 @@ static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
     return 0;
 }
 
+static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt, int64_t next_ofs)
+{
+    AVCodecParameters *par = st->codecpar;
+    MXFTrack *track = st->priv_data;
+
+    if (par->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
+        /* mxf->current_edit_unit good - see if we have an
+         * index table to derive timestamps from */
+        MXFIndexTable *t = &mxf->index_tables[0];
+
+        if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
+            pkt->dts = mxf->current_edit_unit + t->first_dts;
+            pkt->pts = t->ptses[mxf->current_edit_unit];
+        } else if (track && track->intra_only) {
+            /* intra-only -> PTS = EditUnit.
+             * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
+            pkt->pts = mxf->current_edit_unit;
+        }
+    } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
+        int ret = mxf_set_audio_pts(mxf, par, pkt);
+        if (ret < 0)
+            return ret;
+    }
+    return 0;
+}
+
 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
 {
     KLVPacket klv;
@@ -3079,8 +3109,6 @@ static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
             int index = mxf_get_stream_index(s, &klv);
             int64_t next_ofs, next_klv;
             AVStream *st;
-            MXFTrack *track;
-            AVCodecParameters *par;
 
             if (index < 0) {
                 av_log(s, AV_LOG_ERROR,
@@ -3090,7 +3118,6 @@ static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
             }
 
             st = s->streams[index];
-            track = st->priv_data;
 
             if (s->streams[index]->discard == AVDISCARD_ALL)
                 goto skip;
@@ -3125,26 +3152,9 @@ static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
             pkt->stream_index = index;
             pkt->pos = klv.offset;
 
-            par = st->codecpar;
-
-            if (par->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
-                /* mxf->current_edit_unit good - see if we have an
-                 * index table to derive timestamps from */
-                MXFIndexTable *t = &mxf->index_tables[0];
-
-                if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
-                    pkt->dts = mxf->current_edit_unit + t->first_dts;
-                    pkt->pts = t->ptses[mxf->current_edit_unit];
-                } else if (track->intra_only) {
-                    /* intra-only -> PTS = EditUnit.
-                     * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
-                    pkt->pts = mxf->current_edit_unit;
-                }
-            } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
-                ret = mxf_set_audio_pts(mxf, par, pkt);
-                if (ret < 0)
-                    return ret;
-            }
+            ret = mxf_set_pts(mxf, st, pkt, next_ofs);
+            if (ret < 0)
+                return ret;
 
             /* seek for truncated packets */
             avio_seek(s->pb, next_klv, SEEK_SET);
@@ -3207,15 +3217,9 @@ static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
 
     pkt->stream_index = st->index;
 
-    if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
-        mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
-        pkt->dts = mxf->current_edit_unit + t->first_dts;
-        pkt->pts = t->ptses[mxf->current_edit_unit];
-    } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
-        int ret = mxf_set_audio_pts(mxf, st->codecpar, pkt);
-        if (ret < 0)
-            return ret;
-    }
+    ret = mxf_set_pts(mxf, st, pkt, next_pos);
+    if (ret < 0)
+        return ret;
 
     mxf->current_edit_unit += edit_units;
 
diff --git a/mythtv/external/FFmpeg/libavformat/mxfenc.c b/mythtv/external/FFmpeg/libavformat/mxfenc.c
index afea117d5a5..035e65ed43a 100644
--- a/mythtv/external/FFmpeg/libavformat/mxfenc.c
+++ b/mythtv/external/FFmpeg/libavformat/mxfenc.c
@@ -21,7 +21,7 @@
  */
 
 /*
- * signal_standard, color_siting, store_user_comments and klv_fill_key version
+ * signal_standard, color_siting, store_user_comments, sample rate and klv_fill_key version
  * fixes sponsored by NOA GmbH
  */
 
@@ -48,6 +48,7 @@
 #include "libavutil/time_internal.h"
 #include "libavcodec/bytestream.h"
 #include "libavcodec/dnxhddata.h"
+#include "libavcodec/dv_profile.h"
 #include "libavcodec/h264.h"
 #include "libavcodec/internal.h"
 #include "audiointerleave.h"
@@ -100,17 +101,58 @@ typedef struct MXFContainerEssenceEntry {
     void (*write_desc)(AVFormatContext *, AVStream *);
 } MXFContainerEssenceEntry;
 
+enum ULIndex {
+    INDEX_MPEG2 = 0,
+    INDEX_AES3,
+    INDEX_WAV,
+    INDEX_D10_625_50_50_VIDEO,
+    INDEX_D10_625_50_50_AUDIO,
+    INDEX_D10_525_60_50_VIDEO,
+    INDEX_D10_525_60_50_AUDIO,
+    INDEX_D10_625_50_40_VIDEO,
+    INDEX_D10_625_50_40_AUDIO,
+    INDEX_D10_525_60_40_VIDEO,
+    INDEX_D10_525_60_40_AUDIO,
+    INDEX_D10_625_50_30_VIDEO,
+    INDEX_D10_625_50_30_AUDIO,
+    INDEX_D10_525_60_30_VIDEO,
+    INDEX_D10_525_60_30_AUDIO,
+    INDEX_DV,
+    INDEX_DV25_525_60,
+    INDEX_DV25_625_50,
+    INDEX_DV25_525_60_IEC,
+    INDEX_DV25_625_50_IEC,
+    INDEX_DV50_525_60,
+    INDEX_DV50_625_50,
+    INDEX_DV100_1080_60,
+    INDEX_DV100_1080_50,
+    INDEX_DV100_720_60,
+    INDEX_DV100_720_50,
+    INDEX_DNXHD_1080p_10bit_HIGH,
+    INDEX_DNXHD_1080p_8bit_MEDIUM,
+    INDEX_DNXHD_1080p_8bit_HIGH,
+    INDEX_DNXHD_1080i_10bit_HIGH,
+    INDEX_DNXHD_1080i_8bit_MEDIUM,
+    INDEX_DNXHD_1080i_8bit_HIGH,
+    INDEX_DNXHD_720p_10bit,
+    INDEX_DNXHD_720p_8bit_HIGH,
+    INDEX_DNXHD_720p_8bit_MEDIUM,
+    INDEX_DNXHD_720p_8bit_LOW,
+    INDEX_JPEG2000,
+    INDEX_H264,
+};
+
 static const struct {
     enum AVCodecID id;
-    int index;
+    enum ULIndex index;
 } mxf_essence_mappings[] = {
-    { AV_CODEC_ID_MPEG2VIDEO, 0 },
-    { AV_CODEC_ID_PCM_S24LE,  1 },
-    { AV_CODEC_ID_PCM_S16LE,  1 },
-    { AV_CODEC_ID_DVVIDEO,   15 },
-    { AV_CODEC_ID_DNXHD,     24 },
-    { AV_CODEC_ID_JPEG2000,  34 },
-    { AV_CODEC_ID_H264,      35 },
+    { AV_CODEC_ID_MPEG2VIDEO, INDEX_MPEG2 },
+    { AV_CODEC_ID_PCM_S24LE,  INDEX_AES3 },
+    { AV_CODEC_ID_PCM_S16LE,  INDEX_AES3 },
+    { AV_CODEC_ID_DVVIDEO,    INDEX_DV },
+    { AV_CODEC_ID_DNXHD,      INDEX_DNXHD_1080p_10bit_HIGH },
+    { AV_CODEC_ID_JPEG2000,   INDEX_JPEG2000 },
+    { AV_CODEC_ID_H264,       INDEX_H264 },
     { AV_CODEC_ID_NONE }
 };
 
@@ -192,6 +234,7 @@ static const MXFContainerEssenceEntry mxf_essence_container_uls[] = {
       { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x18,0x01,0x01,0x00 },
       { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x00,0x00,0x00 },
       mxf_write_cdci_desc },
+
     // DV25 525/60
     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x40,0x01 },
       { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x18,0x01,0x01,0x00 },
@@ -202,7 +245,19 @@ static const MXFContainerEssenceEntry mxf_essence_container_uls[] = {
       { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x18,0x01,0x01,0x00 },
       { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x02,0x00 },
       mxf_write_cdci_desc },
-    // DV50 525/60
+
+    // IEC DV25 525/60
+    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x01,0x01 },
+      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x18,0x01,0x01,0x00 },
+      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x01,0x00 },
+      mxf_write_cdci_desc },
+    // IEC DV25 625/50
+    { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x02,0x01 },
+      { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x18,0x01,0x01,0x00 },
+      { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x01,0x02,0x00 },
+      mxf_write_cdci_desc },
+
+      // DV50 525/60
     { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x50,0x01 },
       { 0x06,0x0E,0x2B,0x34,0x01,0x02,0x01,0x01,0x0D,0x01,0x03,0x01,0x18,0x01,0x01,0x00 },
       { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x04,0x01,0x02,0x02,0x02,0x02,0x03,0x00 },
@@ -804,9 +859,10 @@ static void mxf_write_track(AVFormatContext *s, AVStream *st, enum MXFMetadataSe
     else
         avio_write(pb, sc->track_essence_element_key + 12, 4);
 
+    // write edit rate
     mxf_write_local_tag(pb, 8, 0x4B01);
 
-    if (st == mxf->timecode_track && s->oformat == &ff_mxf_opatom_muxer){
+    if (st == mxf->timecode_track && s->oformat == &ff_mxf_opatom_muxer) {
         avio_wb32(pb, mxf->tc.rate.num);
         avio_wb32(pb, mxf->tc.rate.den);
     } else {
@@ -842,7 +898,7 @@ static void mxf_write_common_fields(AVFormatContext *s, AVStream *st)
     // write duration
     mxf_write_local_tag(pb, 8, 0x0202);
 
-    if (st != mxf->timecode_track && s->oformat == &ff_mxf_opatom_muxer && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO){
+    if (st != mxf->timecode_track && s->oformat == &ff_mxf_opatom_muxer && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
         avio_wb64(pb, mxf->body_offset / mxf->edit_unit_byte_count);
     } else {
         avio_wb64(pb, mxf->duration);
@@ -994,8 +1050,19 @@ static void mxf_write_generic_desc(AVFormatContext *s, AVStream *st, const UID k
     avio_wb32(pb, st->index+2);
 
     mxf_write_local_tag(pb, 8, 0x3001);
-    avio_wb32(pb, mxf->time_base.den);
-    avio_wb32(pb, mxf->time_base.num);
+    if (s->oformat == &ff_mxf_d10_muxer) {
+        avio_wb32(pb, mxf->time_base.den);
+        avio_wb32(pb, mxf->time_base.num);
+    } else {
+        if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE ||
+            st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE) {
+            avio_wb32(pb, st->codecpar->sample_rate);
+            avio_wb32(pb, 1);
+        } else {
+            avio_wb32(pb, mxf->time_base.den);
+            avio_wb32(pb, mxf->time_base.num);
+        }
+    }
 
     mxf_write_local_tag(pb, 16, 0x3004);
     avio_write(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
@@ -1143,7 +1210,7 @@ static void mxf_write_generic_sound_common(AVFormatContext *s, AVStream *st, con
 
     mxf_write_generic_desc(s, st, key, size+duration_size+5+12+8+8);
 
-    if (duration_size > 0){
+    if (duration_size > 0) {
         mxf_write_local_tag(pb, 8, 0x3002);
         avio_wb64(pb, mxf->body_offset / mxf->edit_unit_byte_count);
     }
@@ -1277,7 +1344,7 @@ static void mxf_write_package(AVFormatContext *s, enum MXFMetadataSetType type,
     // write uid
     mxf_write_local_tag(pb, 16, 0x3C0A);
     mxf_write_uuid(pb, type, 0);
-    av_log(s,AV_LOG_DEBUG, "package type:%d\n", type);
+    av_log(s, AV_LOG_DEBUG, "package type:%d\n", type);
     PRINT_KEY(s, "package uid", pb->buf_ptr - 16);
 
     // write package umid
@@ -1680,37 +1747,37 @@ AVPacket *pkt)
 
     switch (cid) {
     case 1235:
-        sc->index = 24;
+        sc->index = INDEX_DNXHD_1080p_10bit_HIGH;
         sc->component_depth = 10;
         break;
     case 1237:
-        sc->index = 25;
+        sc->index = INDEX_DNXHD_1080p_8bit_MEDIUM;
         break;
     case 1238:
-        sc->index = 26;
+        sc->index = INDEX_DNXHD_1080p_8bit_HIGH;
         break;
     case 1241:
-        sc->index = 27;
+        sc->index = INDEX_DNXHD_1080i_10bit_HIGH;
         sc->component_depth = 10;
         break;
     case 1242:
-        sc->index = 28;
+        sc->index = INDEX_DNXHD_1080i_8bit_MEDIUM;
         break;
     case 1243:
-        sc->index = 29;
+        sc->index = INDEX_DNXHD_1080i_8bit_HIGH;
         break;
     case 1250:
-        sc->index = 30;
+        sc->index = INDEX_DNXHD_720p_10bit;
         sc->component_depth = 10;
         break;
     case 1251:
-        sc->index = 31;
+        sc->index = INDEX_DNXHD_720p_8bit_HIGH;
         break;
     case 1252:
-        sc->index = 32;
+        sc->index = INDEX_DNXHD_720p_8bit_MEDIUM;
         break;
     case 1253:
-        sc->index = 33;
+        sc->index = INDEX_DNXHD_720p_8bit_LOW;
         break;
     default:
         return -1;
@@ -1719,7 +1786,7 @@ AVPacket *pkt)
     sc->codec_ul = &mxf_essence_container_uls[sc->index].codec_ul;
     sc->aspect_ratio = (AVRational){ 16, 9 };
 
-    if(s->oformat == &ff_mxf_opatom_muxer){
+    if (s->oformat == &ff_mxf_opatom_muxer) {
         mxf->edit_unit_byte_count = frame_size;
         return 1;
     }
@@ -1746,6 +1813,7 @@ static int mxf_parse_dv_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
     MXFStreamContext *sc = st->priv_data;
     uint8_t *vs_pack, *vsc_pack;
     int i, ul_index, frame_size, stype, pal;
+    const AVDVProfile *profile;
 
     if (mxf->header_written)
         return 1;
@@ -1754,15 +1822,18 @@ static int mxf_parse_dv_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
     if (pkt->size < 120000)
         return -1;
 
+    profile = av_dv_frame_profile(NULL, pkt->data, pkt->size);
+
     vs_pack  = pkt->data + 80*5 + 48;
     vsc_pack = pkt->data + 80*5 + 53;
     stype    = vs_pack[3] & 0x1f;
     pal      = (vs_pack[3] >> 5) & 0x1;
 
-    if ((vs_pack[2] & 0x07) == 0x02)
+    if ((vsc_pack[2] & 0x07) == 0x02) {
         sc->aspect_ratio = (AVRational){ 16, 9 };
-    else
+    } else {
         sc->aspect_ratio = (AVRational){ 4, 3 };
+    }
 
     sc->interlaced = (vsc_pack[3] >> 4) & 0x01;
     // TODO: fix dv encoder to set proper FF/FS value in VSC pack
@@ -1771,7 +1842,7 @@ static int mxf_parse_dv_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
 
     switch (stype) {
     case 0x18: // DV100 720p
-        ul_index = 6 + pal;
+        ul_index = INDEX_DV100_720_50 + pal;
         frame_size = pal ? 288000 : 240000;
         if (sc->interlaced) {
             av_log(s, AV_LOG_ERROR, "source marked as interlaced but codec profile is progressive\n");
@@ -1779,19 +1850,24 @@ static int mxf_parse_dv_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
         }
         break;
     case 0x14: // DV100 1080i
-        ul_index = 4 + pal;
+        ul_index = INDEX_DV100_1080_50 + pal;
         frame_size = pal ? 576000 : 480000;
         break;
     case 0x04: // DV50
-        ul_index = 2 + pal;
+        ul_index = INDEX_DV50_525_60 + pal;
         frame_size = pal ? 288000 : 240000;
         break;
     default: // DV25
-        ul_index = 0 + pal;
+        if (profile && profile->pix_fmt == AV_PIX_FMT_YUV420P && pal) {
+            ul_index = INDEX_DV25_525_60_IEC + pal;
+            frame_size = pal ? 144000 : 120000;
+            break;
+        }
+        ul_index = INDEX_DV25_525_60 + pal;
         frame_size = pal ? 144000 : 120000;
     }
 
-    sc->index = ul_index + 16;
+    sc->index = ul_index;
     sc->codec_ul =  &mxf_essence_container_uls[sc->index].codec_ul;
 
     if(s->oformat == &ff_mxf_opatom_muxer) {
@@ -2046,7 +2122,7 @@ static int mxf_write_header(AVFormatContext *s)
     if (!s->nb_streams)
         return -1;
 
-    if (s->oformat == &ff_mxf_opatom_muxer && s->nb_streams !=1){
+    if (s->oformat == &ff_mxf_opatom_muxer && s->nb_streams !=1) {
         av_log(s, AV_LOG_ERROR, "there must be exactly one stream for mxf opatom\n");
         return -1;
     }
@@ -2101,16 +2177,20 @@ static int mxf_write_header(AVFormatContext *s)
 
             sc->video_bit_rate = st->codecpar->bit_rate;
             if (s->oformat == &ff_mxf_d10_muxer) {
+                if (st->codecpar->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
+                    av_log(s, AV_LOG_ERROR, "error MXF D-10 only support MPEG-2 Video\n");
+                    return AVERROR(EINVAL);
+                }
                 if ((sc->video_bit_rate == 50000000) && (mxf->time_base.den == 25)) {
-                    sc->index = 3;
+                    sc->index = INDEX_D10_625_50_50_VIDEO;
                 } else if ((sc->video_bit_rate == 49999840 || sc->video_bit_rate == 50000000) && (mxf->time_base.den != 25)) {
-                    sc->index = 5;
+                    sc->index = INDEX_D10_525_60_50_VIDEO;
                 } else if (sc->video_bit_rate == 40000000) {
-                    if (mxf->time_base.den == 25) sc->index = 7;
-                    else                          sc->index = 9;
+                    if (mxf->time_base.den == 25) sc->index = INDEX_D10_625_50_40_VIDEO;
+                    else                          sc->index = INDEX_D10_525_60_40_VIDEO;
                 } else if (sc->video_bit_rate == 30000000) {
-                    if (mxf->time_base.den == 25) sc->index = 11;
-                    else                          sc->index = 13;
+                    if (mxf->time_base.den == 25) sc->index = INDEX_D10_625_50_30_VIDEO;
+                    else                          sc->index = INDEX_D10_525_60_30_VIDEO;
                 } else {
                     av_log(s, AV_LOG_ERROR, "error MXF D-10 only support 30/40/50 mbit/s\n");
                     return -1;
@@ -2157,7 +2237,7 @@ static int mxf_write_header(AVFormatContext *s)
                 }
 
                 spf = ff_mxf_get_samples_per_frame(s, tbc);
-                if (!spf){
+                if (!spf) {
                     av_log(s, AV_LOG_ERROR, "Unsupported timecode frame rate %d/%d\n", tbc.den, tbc.num);
                     return AVERROR(EINVAL);
                 }
@@ -2168,7 +2248,7 @@ static int mxf_write_header(AVFormatContext *s)
 
                 mxf->timecode_base = (tbc.den + tbc.num/2) / tbc.num;
                 mxf->edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
-                sc->index = 2;
+                sc->index = INDEX_WAV;
             } else {
                 mxf->slice_count = 1;
             }
@@ -2549,8 +2629,8 @@ static int mxf_write_footer(AVFormatContext *s)
     mxf_write_klv_fill(s);
     mxf_write_random_index_pack(s);
 
-    if (s->pb->seekable) {
-        if (s->oformat == &ff_mxf_opatom_muxer){
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
+        if (s->oformat == &ff_mxf_opatom_muxer) {
             /* rewrite body partition to update lengths */
             avio_seek(pb, mxf->body_partition_offset[0], SEEK_SET);
             if ((err = mxf_write_opatom_body_partition(s)) < 0)
diff --git a/mythtv/external/FFmpeg/libavformat/network.c b/mythtv/external/FFmpeg/libavformat/network.c
index 2fb1c8b02af..b3987a4d116 100644
--- a/mythtv/external/FFmpeg/libavformat/network.c
+++ b/mythtv/external/FFmpeg/libavformat/network.c
@@ -159,7 +159,7 @@ static int ff_poll_interrupt(struct pollfd *p, nfds_t nfds, int timeout,
     if (!ret)
         return AVERROR(ETIMEDOUT);
     if (ret < 0)
-        return AVERROR(errno);
+        return ff_neterrno();
     return ret;
 }
 
diff --git a/mythtv/external/FFmpeg/libavformat/nistspheredec.c b/mythtv/external/FFmpeg/libavformat/nistspheredec.c
index 782d1dfbfbb..55f22ebcf4f 100644
--- a/mythtv/external/FFmpeg/libavformat/nistspheredec.c
+++ b/mythtv/external/FFmpeg/libavformat/nistspheredec.c
@@ -89,7 +89,7 @@ static int nist_read_header(AVFormatContext *s)
 
             return 0;
         } else if (!memcmp(buffer, "channel_count", 13)) {
-            sscanf(buffer, "%*s %*s %"SCNd32, &st->codecpar->channels);
+            sscanf(buffer, "%*s %*s %u", &st->codecpar->channels);
         } else if (!memcmp(buffer, "sample_byte_format", 18)) {
             sscanf(buffer, "%*s %*s %31s", format);
 
@@ -108,11 +108,11 @@ static int nist_read_header(AVFormatContext *s)
         } else if (!memcmp(buffer, "sample_count", 12)) {
             sscanf(buffer, "%*s %*s %"SCNd64, &st->duration);
         } else if (!memcmp(buffer, "sample_n_bytes", 14)) {
-            sscanf(buffer, "%*s %*s %"SCNd32, &bps);
+            sscanf(buffer, "%*s %*s %d", &bps);
         } else if (!memcmp(buffer, "sample_rate", 11)) {
-            sscanf(buffer, "%*s %*s %"SCNd32, &st->codecpar->sample_rate);
+            sscanf(buffer, "%*s %*s %d", &st->codecpar->sample_rate);
         } else if (!memcmp(buffer, "sample_sig_bits", 15)) {
-            sscanf(buffer, "%*s %*s %"SCNd32, &st->codecpar->bits_per_coded_sample);
+            sscanf(buffer, "%*s %*s %d", &st->codecpar->bits_per_coded_sample);
         } else {
             char key[32], value[32];
             if (sscanf(buffer, "%31s %*s %31s", key, value) == 2) {
diff --git a/mythtv/external/FFmpeg/libavformat/nsvdec.c b/mythtv/external/FFmpeg/libavformat/nsvdec.c
index 507fb396a51..d8ce656817c 100644
--- a/mythtv/external/FFmpeg/libavformat/nsvdec.c
+++ b/mythtv/external/FFmpeg/libavformat/nsvdec.c
@@ -176,7 +176,6 @@ typedef struct NSVContext {
     int16_t avsync;
     AVRational framerate;
     uint32_t *nsvs_timestamps;
-    //DVDemuxContext* dv_demux;
 } NSVContext;
 
 static const AVCodecTag nsv_codec_video_tags[] = {
@@ -212,13 +211,6 @@ static const AVCodecTag nsv_codec_audio_tags[] = {
 //static int nsv_load_index(AVFormatContext *s);
 static int nsv_read_chunk(AVFormatContext *s, int fill_header);
 
-#define print_tag(str, tag, size)       \
-    av_log(NULL, AV_LOG_TRACE, "%s: tag=%c%c%c%c\n", \
-            str, tag & 0xff,            \
-            (tag >> 8) & 0xff,          \
-            (tag >> 16) & 0xff,         \
-            (tag >> 24) & 0xff);
-
 /* try to find something we recognize, and set the state accordingly */
 static int nsv_resync(AVFormatContext *s)
 {
@@ -227,10 +219,6 @@ static int nsv_resync(AVFormatContext *s)
     uint32_t v = 0;
     int i;
 
-    av_log(s, AV_LOG_TRACE, "%s(), offset = %"PRId64", state = %d\n", __FUNCTION__, avio_tell(pb), nsv->state);
-
-    //nsv->state = NSV_UNSYNC;
-
     for (i = 0; i < NSV_MAX_RESYNC; i++) {
         if (avio_feof(pb)) {
             av_log(s, AV_LOG_TRACE, "NSV EOF\n");
@@ -240,7 +228,7 @@ static int nsv_resync(AVFormatContext *s)
         v <<= 8;
         v |= avio_r8(pb);
         if (i < 8) {
-            av_log(s, AV_LOG_TRACE, "NSV resync: [%d] = %02x\n", i, v & 0x0FF);
+            av_log(s, AV_LOG_TRACE, "NSV resync: [%d] = %02"PRIx32"\n", i, v & 0x0FF);
         }
 
         if ((v & 0x0000ffff) == 0xefbe) { /* BEEF */
@@ -276,8 +264,6 @@ static int nsv_parse_NSVf_header(AVFormatContext *s)
     int table_entries;
     int table_entries_used;
 
-    av_log(s, AV_LOG_TRACE, "%s()\n", __FUNCTION__);
-
     nsv->state = NSV_UNSYNC; /* in case we fail */
 
     size = avio_rl32(pb);
@@ -285,7 +271,6 @@ static int nsv_parse_NSVf_header(AVFormatContext *s)
         return -1;
     nsv->NSVf_end = size;
 
-    //s->file_size = (uint32_t)avio_rl32(pb);
     file_size = (uint32_t)avio_rl32(pb);
     av_log(s, AV_LOG_TRACE, "NSV NSVf chunk_size %u\n", size);
     av_log(s, AV_LOG_TRACE, "NSV NSVf file_size %u\n", file_size);
@@ -350,8 +335,11 @@ static int nsv_parse_NSVf_header(AVFormatContext *s)
         if (!nsv->nsvs_file_offset)
             return AVERROR(ENOMEM);
 
-        for(i=0;i<table_entries_used;i++)
+        for(i=0;i<table_entries_used;i++) {
+            if (avio_feof(pb))
+                return AVERROR_INVALIDDATA;
             nsv->nsvs_file_offset[i] = avio_rl32(pb) + size;
+        }
 
         if(table_entries > table_entries_used &&
            avio_rl32(pb) == MKTAG('T','O','C','2')) {
@@ -384,7 +372,6 @@ static int nsv_parse_NSVs_header(AVFormatContext *s)
     int i;
     AVStream *st;
     NSVStream *nst;
-    av_log(s, AV_LOG_TRACE, "%s()\n", __FUNCTION__);
 
     vtag = avio_rl32(pb);
     atag = avio_rl32(pb);
@@ -413,8 +400,6 @@ static int nsv_parse_NSVs_header(AVFormatContext *s)
     nsv->avsync = avio_rl16(pb);
     nsv->framerate = framerate;
 
-    print_tag("NSV NSVs vtag", vtag, 0);
-    print_tag("NSV NSVs atag", atag, 0);
     av_log(s, AV_LOG_TRACE, "NSV NSVs vsize %dx%d\n", vwidth, vheight);
 
     /* XXX change to ap != NULL ? */
@@ -496,9 +481,6 @@ static int nsv_read_header(AVFormatContext *s)
     NSVContext *nsv = s->priv_data;
     int i, err;
 
-    av_log(s, AV_LOG_TRACE, "%s()\n", __FUNCTION__);
-    av_log(s, AV_LOG_TRACE, "filename '%s'\n", s->filename);
-
     nsv->state = NSV_UNSYNC;
     nsv->ahead[0].data = nsv->ahead[1].data = NULL;
 
@@ -541,8 +523,6 @@ static int nsv_read_chunk(AVFormatContext *s, int fill_header)
     uint16_t auxsize;
     int ret;
 
-    av_log(s, AV_LOG_TRACE, "%s(%d)\n", __FUNCTION__, fill_header);
-
     if (nsv->ahead[0].data || nsv->ahead[1].data)
         return 0; //-1; /* hey! eat what you've in your plate first! */
 
@@ -566,18 +546,12 @@ static int nsv_read_chunk(AVFormatContext *s, int fill_header)
     asize = avio_rl16(pb);
     vsize = (vsize << 4) | (auxcount >> 4);
     auxcount &= 0x0f;
-    av_log(s, AV_LOG_TRACE, "NSV CHUNK %d aux, %u bytes video, %d bytes audio\n", auxcount, vsize, asize);
+    av_log(s, AV_LOG_TRACE, "NSV CHUNK %d aux, %"PRIu32" bytes video, %d bytes audio\n", auxcount, vsize, asize);
     /* skip aux stuff */
     for (i = 0; i < auxcount; i++) {
         uint32_t av_unused auxtag;
         auxsize = avio_rl16(pb);
         auxtag = avio_rl32(pb);
-        av_log(s, AV_LOG_TRACE, "NSV aux data: '%c%c%c%c', %d bytes\n",
-              (auxtag & 0x0ff),
-              ((auxtag >> 8) & 0x0ff),
-              ((auxtag >> 16) & 0x0ff),
-              ((auxtag >> 24) & 0x0ff),
-              auxsize);
         avio_skip(pb, auxsize);
         vsize -= auxsize + sizeof(uint16_t) + sizeof(uint32_t); /* that's becoming brain-dead */
     }
@@ -664,8 +638,6 @@ static int nsv_read_packet(AVFormatContext *s, AVPacket *pkt)
     NSVContext *nsv = s->priv_data;
     int i, err = 0;
 
-    av_log(s, AV_LOG_TRACE, "%s()\n", __FUNCTION__);
-
     /* in case we don't already have something to eat ... */
     if (!nsv->ahead[0].data && !nsv->ahead[1].data)
         err = nsv_read_chunk(s, 0);
@@ -675,7 +647,6 @@ static int nsv_read_packet(AVFormatContext *s, AVPacket *pkt)
     /* now pick one of the plates */
     for (i = 0; i < 2; i++) {
         if (nsv->ahead[i].data) {
-            av_log(s, AV_LOG_TRACE, "%s: using cached packet[%d]\n", __FUNCTION__, i);
             /* avoid the cost of new_packet + memcpy(->data) */
             memcpy(pkt, &nsv->ahead[i], sizeof(AVPacket));
             nsv->ahead[i].data = NULL; /* we ate that one */
diff --git a/mythtv/external/FFmpeg/libavformat/nut.c b/mythtv/external/FFmpeg/libavformat/nut.c
index 452fc35fd24..592fe4dc28a 100644
--- a/mythtv/external/FFmpeg/libavformat/nut.c
+++ b/mythtv/external/FFmpeg/libavformat/nut.c
@@ -42,6 +42,7 @@ const AVCodecTag ff_nut_video_tags[] = {
     { AV_CODEC_ID_GIF,              MKTAG('G', 'I', 'F',  0 ) },
     { AV_CODEC_ID_XFACE,            MKTAG('X', 'F', 'A', 'C') },
     { AV_CODEC_ID_VP9,              MKTAG('V', 'P', '9', '0') },
+    { AV_CODEC_ID_HEVC,             MKTAG('H', 'E', 'V', 'C') },
     { AV_CODEC_ID_RAWVIDEO,         MKTAG('R', 'G', 'B', 15 ) },
     { AV_CODEC_ID_RAWVIDEO,         MKTAG('B', 'G', 'R', 15 ) },
     { AV_CODEC_ID_RAWVIDEO,         MKTAG('R', 'G', 'B', 16 ) },
@@ -142,6 +143,8 @@ const AVCodecTag ff_nut_video_tags[] = {
     { AV_CODEC_ID_RAWVIDEO,         MKTAG('Y', '4',   0,  10) },
     { AV_CODEC_ID_RAWVIDEO,         MKTAG(10,    0, '4', 'Y') },
 
+    { AV_CODEC_ID_RAWVIDEO,         MKTAG('Y', '1',   0,  12) },
+    { AV_CODEC_ID_RAWVIDEO,         MKTAG(12,    0, '1', 'Y') },
     { AV_CODEC_ID_RAWVIDEO,         MKTAG('Y', '1',   0,  16) },
     { AV_CODEC_ID_RAWVIDEO,         MKTAG(16,    0, '1', 'Y') },
     { AV_CODEC_ID_RAWVIDEO,         MKTAG('Y', '4',  11,  16) },
@@ -199,6 +202,7 @@ const AVCodecTag ff_nut_audio_extra_tags[] = {
     { AV_CODEC_ID_PCM_ALAW,         MKTAG('A', 'L', 'A', 'W') },
     { AV_CODEC_ID_PCM_MULAW,        MKTAG('U', 'L', 'A', 'W') },
     { AV_CODEC_ID_MP3,              MKTAG('M', 'P', '3', ' ') },
+    { AV_CODEC_ID_OPUS,             MKTAG('O', 'p', 'u', 's') },
     { AV_CODEC_ID_WAVPACK,          MKTAG('w', 'v', 'p', 'k') },
     { AV_CODEC_ID_NONE,             0                         }
 };
diff --git a/mythtv/external/FFmpeg/libavformat/nutdec.c b/mythtv/external/FFmpeg/libavformat/nutdec.c
index 2e309bcad7f..27440c88d46 100644
--- a/mythtv/external/FFmpeg/libavformat/nutdec.c
+++ b/mythtv/external/FFmpeg/libavformat/nutdec.c
@@ -86,46 +86,10 @@ static uint64_t get_fourcc(AVIOContext *bc)
     }
 }
 
-#ifdef TRACE
-static inline uint64_t get_v_trace(AVIOContext *bc, const char *file,
-                                   const char *func, int line)
-{
-    uint64_t v = ffio_read_varlen(bc);
-
-    av_log(NULL, AV_LOG_DEBUG, "get_v %5"PRId64" / %"PRIX64" in %s %s:%d\n",
-           v, v, file, func, line);
-    return v;
-}
-
-static inline int64_t get_s_trace(AVIOContext *bc, const char *file,
-                                  const char *func, int line)
-{
-    int64_t v = get_s(bc);
-
-    av_log(NULL, AV_LOG_DEBUG, "get_s %5"PRId64" / %"PRIX64" in %s %s:%d\n",
-           v, v, file, func, line);
-    return v;
-}
-
-static inline uint64_t get_4cc_trace(AVIOContext *bc, char *file,
-                                    char *func, int line)
-{
-    uint64_t v = get_fourcc(bc);
-
-    av_log(NULL, AV_LOG_DEBUG, "get_fourcc %5"PRId64" / %"PRIX64" in %s %s:%d\n",
-           v, v, file, func, line);
-    return v;
-}
-#define ffio_read_varlen(bc) get_v_trace(bc,  __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#define get_s(bc)            get_s_trace(bc,  __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#define get_fourcc(bc)       get_4cc_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#endif
-
 static int get_packetheader(NUTContext *nut, AVIOContext *bc,
                             int calculate_checksum, uint64_t startcode)
 {
     int64_t size;
-//    start = avio_tell(bc) - 8;
 
     startcode = av_be2ne64(startcode);
     startcode = ff_crc04C11DB7_update(0, (uint8_t*) &startcode, 8);
@@ -238,7 +202,7 @@ static int decode_main_header(NUTContext *nut)
     end += avio_tell(bc);
 
     nut->version = ffio_read_varlen(bc);
-    if (nut->version < NUT_MIN_VERSION &&
+    if (nut->version < NUT_MIN_VERSION ||
         nut->version > NUT_MAX_VERSION) {
         av_log(s, AV_LOG_ERROR, "Version %d not supported.\n",
                nut->version);
@@ -876,7 +840,7 @@ static int nut_read_header(AVFormatContext *s)
 
     s->internal->data_offset = pos - 8;
 
-    if (bc->seekable) {
+    if (bc->seekable & AVIO_SEEKABLE_NORMAL) {
         int64_t orig_pos = avio_tell(bc);
         find_and_decode_index(nut);
         avio_seek(bc, orig_pos, SEEK_SET);
diff --git a/mythtv/external/FFmpeg/libavformat/nutenc.c b/mythtv/external/FFmpeg/libavformat/nutenc.c
index 9e422e1aa87..a92ff55c013 100644
--- a/mythtv/external/FFmpeg/libavformat/nutenc.c
+++ b/mythtv/external/FFmpeg/libavformat/nutenc.c
@@ -299,25 +299,6 @@ static void put_s(AVIOContext *bc, int64_t val)
     ff_put_v(bc, 2 * FFABS(val) - (val > 0));
 }
 
-#ifdef TRACE
-static inline void ff_put_v_trace(AVIOContext *bc, uint64_t v, const char *file,
-                                  const char *func, int line)
-{
-    av_log(NULL, AV_LOG_DEBUG, "ff_put_v %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
-
-    ff_put_v(bc, v);
-}
-
-static inline void put_s_trace(AVIOContext *bc, int64_t v, const char *file, const char *func, int line)
-{
-    av_log(NULL, AV_LOG_DEBUG, "put_s %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
-
-    put_s(bc, v);
-}
-#define ff_put_v(bc, v)  ff_put_v_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#define put_s(bc, v)  put_s_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#endif
-
 //FIXME remove calculate_checksum
 static void put_packet(NUTContext *nut, AVIOContext *bc, AVIOContext *dyn_bc,
                        int calculate_checksum, uint64_t startcode)
diff --git a/mythtv/external/FFmpeg/libavformat/nuv.c b/mythtv/external/FFmpeg/libavformat/nuv.c
index d92025003b0..9bdea4ab554 100644
--- a/mythtv/external/FFmpeg/libavformat/nuv.c
+++ b/mythtv/external/FFmpeg/libavformat/nuv.c
@@ -66,7 +66,7 @@ static int nuv_probe(AVProbeData *p)
  * @param myth set if this is a MythTVVideo format file
  * @return 0 or AVERROR code
  */
-static int get_codec_data(AVIOContext *pb, AVStream *vst,
+static int get_codec_data(AVFormatContext *s, AVIOContext *pb, AVStream *vst,
                           AVStream *ast, int myth)
 {
     nuv_frametype frametype;
@@ -114,6 +114,10 @@ static int get_codec_data(AVIOContext *pb, AVStream *vst,
 
                 ast->codecpar->codec_tag             = avio_rl32(pb);
                 ast->codecpar->sample_rate           = avio_rl32(pb);
+                if (ast->codecpar->sample_rate <= 0) {
+                    av_log(s, AV_LOG_ERROR, "Invalid sample rate %d\n", ast->codecpar->sample_rate);
+                    return AVERROR_INVALIDDATA;
+                }
                 ast->codecpar->bits_per_coded_sample = avio_rl32(pb);
                 ast->codecpar->channels              = avio_rl32(pb);
                 ast->codecpar->channel_layout        = 0;
@@ -232,7 +236,7 @@ static int nuv_header(AVFormatContext *s)
     } else
         ctx->a_id = -1;
 
-    if ((ret = get_codec_data(pb, vst, ast, is_mythtv)) < 0)
+    if ((ret = get_codec_data(s, pb, vst, ast, is_mythtv)) < 0)
         return ret;
 
     ctx->rtjpg_video = vst && vst->codecpar->codec_id == AV_CODEC_ID_NUV;
diff --git a/mythtv/external/FFmpeg/libavformat/oggdec.c b/mythtv/external/FFmpeg/libavformat/oggdec.c
index 47a0cbae053..193a286e435 100644
--- a/mythtv/external/FFmpeg/libavformat/oggdec.c
+++ b/mythtv/external/FFmpeg/libavformat/oggdec.c
@@ -61,7 +61,22 @@ static const struct ogg_codec * const ogg_codecs[] = {
 
 static int64_t ogg_calc_pts(AVFormatContext *s, int idx, int64_t *dts);
 static int ogg_new_stream(AVFormatContext *s, uint32_t serial);
-static int ogg_restore(AVFormatContext *s, int discard);
+static int ogg_restore(AVFormatContext *s);
+
+static void free_stream(AVFormatContext *s, int i)
+{
+    struct ogg *ogg = s->priv_data;
+    struct ogg_stream *stream = &ogg->streams[i];
+
+    av_freep(&stream->buf);
+    if (stream->codec &&
+        stream->codec->cleanup) {
+        stream->codec->cleanup(s, i);
+    }
+
+    av_freep(&stream->private);
+    av_freep(&stream->new_metadata);
+}
 
 //FIXME We could avoid some structure duplication
 static int ogg_save(AVFormatContext *s)
@@ -95,12 +110,12 @@ static int ogg_save(AVFormatContext *s)
     ogg->state = ost;
 
     if (ret < 0)
-        ogg_restore(s, 0);
+        ogg_restore(s);
 
     return ret;
 }
 
-static int ogg_restore(AVFormatContext *s, int discard)
+static int ogg_restore(AVFormatContext *s)
 {
     struct ogg *ogg = s->priv_data;
     AVIOContext *bc = s->pb;
@@ -112,10 +127,12 @@ static int ogg_restore(AVFormatContext *s, int discard)
 
     ogg->state = ost->next;
 
-    if (!discard) {
-
-        for (i = 0; i < ogg->nstreams; i++)
+        for (i = 0; i < ogg->nstreams; i++) {
             av_freep(&ogg->streams[i].buf);
+            if (i >= ost->nstreams || !ost->streams[i].private) {
+                free_stream(s, i);
+            }
+        }
 
         avio_seek(bc, ost->pos, SEEK_SET);
         ogg->page_pos = -1;
@@ -128,7 +145,6 @@ static int ogg_restore(AVFormatContext *s, int discard)
         } else
             memcpy(ogg->streams, ost->streams,
                    ost->nstreams * sizeof(*ogg->streams));
-    }
 
     av_free(ost);
 
@@ -193,7 +209,7 @@ static int ogg_replace_stream(AVFormatContext *s, uint32_t serial, int nsegs)
     const struct ogg_codec *codec;
     int i = 0;
 
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         uint8_t magic[8];
         int64_t pos = avio_tell(s->pb);
         avio_skip(s->pb, nsegs);
@@ -339,7 +355,7 @@ static int ogg_read_page(AVFormatContext *s, int *sid)
             sync[(sp + 2) & 3] == 'g' && sync[(sp + 3) & 3] == 'S')
             break;
 
-        if(!i && bc->seekable && ogg->page_pos > 0) {
+        if(!i && (bc->seekable & AVIO_SEEKABLE_NORMAL) && ogg->page_pos > 0) {
             memset(sync, 0, 4);
             avio_seek(bc, ogg->page_pos+4, SEEK_SET);
             ogg->page_pos = -1;
@@ -597,7 +613,7 @@ static int ogg_get_length(AVFormatContext *s)
     int64_t size, end;
     int streams_left=0;
 
-    if (!s->pb->seekable)
+    if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
         return 0;
 
 // already set
@@ -631,7 +647,7 @@ static int ogg_get_length(AVFormatContext *s)
         }
     }
 
-    ogg_restore(s, 0);
+    ogg_restore(s);
 
     ret = ogg_save(s);
     if (ret < 0)
@@ -643,6 +659,8 @@ static int ogg_get_length(AVFormatContext *s)
         int64_t pts;
         if (i < 0) continue;
         pts = ogg_calc_pts(s, i, NULL);
+        if (s->streams[i]->duration == AV_NOPTS_VALUE)
+            continue;
         if (pts != AV_NOPTS_VALUE && s->streams[i]->start_time == AV_NOPTS_VALUE && !ogg->streams[i].got_start) {
             s->streams[i]->duration -= pts;
             ogg->streams[i].got_start= 1;
@@ -652,7 +670,7 @@ static int ogg_get_length(AVFormatContext *s)
             streams_left--;
         }
     }
-    ogg_restore (s, 0);
+    ogg_restore (s);
 
     return 0;
 }
@@ -663,13 +681,7 @@ static int ogg_read_close(AVFormatContext *s)
     int i;
 
     for (i = 0; i < ogg->nstreams; i++) {
-        av_freep(&ogg->streams[i].buf);
-        if (ogg->streams[i].codec &&
-            ogg->streams[i].codec->cleanup) {
-            ogg->streams[i].codec->cleanup(s, i);
-        }
-        av_freep(&ogg->streams[i].private);
-        av_freep(&ogg->streams[i].new_metadata);
+        free_stream(s, i);
     }
 
     ogg->nstreams = 0;
@@ -707,8 +719,10 @@ static int ogg_read_header(AVFormatContext *s)
                    "Headers mismatch for stream %d: "
                    "expected %d received %d.\n",
                    i, os->codec->nb_header, os->nb_header);
-            if (s->error_recognition & AV_EF_EXPLODE)
+            if (s->error_recognition & AV_EF_EXPLODE) {
+                ogg_read_close(s);
                 return AVERROR_INVALIDDATA;
+            }
         }
         if (os->start_granule != OGG_NOGRANULE_VALUE)
             os->lastpts = s->streams[i]->start_time =
diff --git a/mythtv/external/FFmpeg/libavformat/oggenc.c b/mythtv/external/FFmpeg/libavformat/oggenc.c
index 0713a13a707..10c4eda0621 100644
--- a/mythtv/external/FFmpeg/libavformat/oggenc.c
+++ b/mythtv/external/FFmpeg/libavformat/oggenc.c
@@ -483,7 +483,7 @@ static void ogg_write_pages(AVFormatContext *s, int flush)
     ogg->page_list = p;
 }
 
-static int ogg_write_header(AVFormatContext *s)
+static int ogg_init(AVFormatContext *s)
 {
     OGGContext *ogg = s->priv_data;
     OGGStreamContext *oggstream = NULL;
@@ -617,8 +617,16 @@ static int ogg_write_header(AVFormatContext *s)
         }
     }
 
+    return 0;
+}
+
+static int ogg_write_header(AVFormatContext *s)
+{
+    OGGStreamContext *oggstream = NULL;
+    int i, j;
+
     for (j = 0; j < s->nb_streams; j++) {
-        OGGStreamContext *oggstream = s->streams[j]->priv_data;
+        oggstream = s->streams[j]->priv_data;
         ogg_buffer_data(s, s->streams[j], oggstream->header[0],
                         oggstream->header_len[0], 0, 1);
         oggstream->page.flags |= 2; // bos
@@ -626,7 +634,7 @@ static int ogg_write_header(AVFormatContext *s)
     }
     for (j = 0; j < s->nb_streams; j++) {
         AVStream *st = s->streams[j];
-        OGGStreamContext *oggstream = st->priv_data;
+        oggstream = st->priv_data;
         for (i = 1; i < 3; i++) {
             if (oggstream->header_len[i])
                 ogg_buffer_data(s, st, oggstream->header[i],
@@ -725,9 +733,18 @@ static int ogg_write_trailer(AVFormatContext *s)
 
     ogg_write_pages(s, 1);
 
+    return 0;
+}
+
+static void ogg_free(AVFormatContext *s)
+{
+    int i;
+
     for (i = 0; i < s->nb_streams; i++) {
         AVStream *st = s->streams[i];
         OGGStreamContext *oggstream = st->priv_data;
+        if (!oggstream)
+            continue;
         if (st->codecpar->codec_id == AV_CODEC_ID_FLAC ||
             st->codecpar->codec_id == AV_CODEC_ID_SPEEX ||
             st->codecpar->codec_id == AV_CODEC_ID_OPUS ||
@@ -737,7 +754,6 @@ static int ogg_write_trailer(AVFormatContext *s)
         av_freep(&oggstream->header[1]);
         av_freep(&st->priv_data);
     }
-    return 0;
 }
 
 #if CONFIG_OGG_MUXER
@@ -761,9 +777,11 @@ AVOutputFormat ff_ogg_muxer = {
     .audio_codec       = CONFIG_LIBVORBIS_ENCODER ?
                          AV_CODEC_ID_VORBIS : AV_CODEC_ID_FLAC,
     .video_codec       = AV_CODEC_ID_THEORA,
+    .init              = ogg_init,
     .write_header      = ogg_write_header,
     .write_packet      = ogg_write_packet,
     .write_trailer     = ogg_write_trailer,
+    .deinit            = ogg_free,
     .flags             = AVFMT_TS_NEGATIVE | AVFMT_TS_NONSTRICT | AVFMT_ALLOW_FLUSH,
     .priv_class        = &ogg_muxer_class,
 };
@@ -778,9 +796,11 @@ AVOutputFormat ff_oga_muxer = {
     .extensions        = "oga",
     .priv_data_size    = sizeof(OGGContext),
     .audio_codec       = AV_CODEC_ID_FLAC,
+    .init              = ogg_init,
     .write_header      = ogg_write_header,
     .write_packet      = ogg_write_packet,
     .write_trailer     = ogg_write_trailer,
+    .deinit            = ogg_free,
     .flags             = AVFMT_TS_NEGATIVE | AVFMT_ALLOW_FLUSH,
     .priv_class        = &oga_muxer_class,
 };
@@ -798,9 +818,11 @@ AVOutputFormat ff_ogv_muxer = {
                          AV_CODEC_ID_VORBIS : AV_CODEC_ID_FLAC,
     .video_codec       = CONFIG_LIBTHEORA_ENCODER ?
                          AV_CODEC_ID_THEORA : AV_CODEC_ID_VP8,
+    .init              = ogg_init,
     .write_header      = ogg_write_header,
     .write_packet      = ogg_write_packet,
     .write_trailer     = ogg_write_trailer,
+    .deinit            = ogg_free,
     .flags             = AVFMT_TS_NEGATIVE | AVFMT_TS_NONSTRICT | AVFMT_ALLOW_FLUSH,
     .priv_class        = &ogv_muxer_class,
 };
@@ -815,9 +837,11 @@ AVOutputFormat ff_spx_muxer = {
     .extensions        = "spx",
     .priv_data_size    = sizeof(OGGContext),
     .audio_codec       = AV_CODEC_ID_SPEEX,
+    .init              = ogg_init,
     .write_header      = ogg_write_header,
     .write_packet      = ogg_write_packet,
     .write_trailer     = ogg_write_trailer,
+    .deinit            = ogg_free,
     .flags             = AVFMT_TS_NEGATIVE | AVFMT_ALLOW_FLUSH,
     .priv_class        = &spx_muxer_class,
 };
@@ -832,9 +856,11 @@ AVOutputFormat ff_opus_muxer = {
     .extensions        = "opus",
     .priv_data_size    = sizeof(OGGContext),
     .audio_codec       = AV_CODEC_ID_OPUS,
+    .init              = ogg_init,
     .write_header      = ogg_write_header,
     .write_packet      = ogg_write_packet,
     .write_trailer     = ogg_write_trailer,
+    .deinit            = ogg_free,
     .flags             = AVFMT_TS_NEGATIVE | AVFMT_ALLOW_FLUSH,
     .priv_class        = &opus_muxer_class,
 };
diff --git a/mythtv/external/FFmpeg/libavformat/oggparsecelt.c b/mythtv/external/FFmpeg/libavformat/oggparsecelt.c
index 6d567f988a3..9c438a096ae 100644
--- a/mythtv/external/FFmpeg/libavformat/oggparsecelt.c
+++ b/mythtv/external/FFmpeg/libavformat/oggparsecelt.c
@@ -65,9 +65,14 @@ static int celt_header(AVFormatContext *s, int idx)
         st->codecpar->channels       = nb_channels;
         if (sample_rate)
             avpriv_set_pts_info(st, 64, 1, sample_rate);
-        priv->extra_headers_left  = 1 + extra_headers;
-        av_free(os->private);
+
+        if (os->private) {
+            av_free(priv);
+            priv = os->private;
+        }
         os->private = priv;
+        priv->extra_headers_left  = 1 + extra_headers;
+
         AV_WL32(st->codecpar->extradata + 0, overlap);
         AV_WL32(st->codecpar->extradata + 4, version);
         return 1;
diff --git a/mythtv/external/FFmpeg/libavformat/oggparsedaala.c b/mythtv/external/FFmpeg/libavformat/oggparsedaala.c
index 89bda589943..a373b41b4ca 100644
--- a/mythtv/external/FFmpeg/libavformat/oggparsedaala.c
+++ b/mythtv/external/FFmpeg/libavformat/oggparsedaala.c
@@ -126,6 +126,7 @@ static int daala_header(AVFormatContext *s, int idx)
         if (hdr->gpshift >= 32) {
             av_log(s, AV_LOG_ERROR, "Too large gpshift %d (>= 32).\n",
                    hdr->gpshift);
+            hdr->gpshift = 0;
             return AVERROR_INVALIDDATA;
         }
         hdr->gpmask  = (1U << hdr->gpshift) - 1;
@@ -232,7 +233,7 @@ static int daala_packet(AVFormatContext *s, int idx)
         os->lastpts = os->lastdts = daala_gptopts(s, idx, os->granule, NULL) - duration;
         if(s->streams[idx]->start_time == AV_NOPTS_VALUE) {
             s->streams[idx]->start_time = os->lastpts;
-            if (s->streams[idx]->duration)
+            if (s->streams[idx]->duration != AV_NOPTS_VALUE)
                 s->streams[idx]->duration -= s->streams[idx]->start_time;
         }
     }
diff --git a/mythtv/external/FFmpeg/libavformat/oggparseogm.c b/mythtv/external/FFmpeg/libavformat/oggparseogm.c
index f8e656dcb1a..e7a501b5a71 100644
--- a/mythtv/external/FFmpeg/libavformat/oggparseogm.c
+++ b/mythtv/external/FFmpeg/libavformat/oggparseogm.c
@@ -108,7 +108,10 @@ ogm_header(AVFormatContext *s, int idx)
             if (size > 52) {
                 av_assert0(AV_INPUT_BUFFER_PADDING_SIZE <= 52);
                 size -= 52;
-                ff_alloc_extradata(st->codecpar, size);
+                if (bytestream2_get_bytes_left(&p) < size)
+                    return AVERROR_INVALIDDATA;
+                if (ff_alloc_extradata(st->codecpar, size) < 0)
+                    return AVERROR(ENOMEM);
                 bytestream2_get_buffer(&p, st->codecpar->extradata, st->codecpar->extradata_size);
             }
         }
diff --git a/mythtv/external/FFmpeg/libavformat/oggparsespeex.c b/mythtv/external/FFmpeg/libavformat/oggparsespeex.c
index 434b0fdab15..27fc99247de 100644
--- a/mythtv/external/FFmpeg/libavformat/oggparsespeex.c
+++ b/mythtv/external/FFmpeg/libavformat/oggparsespeex.c
@@ -68,6 +68,10 @@ static int speex_header(AVFormatContext *s, int idx) {
         }
 
         st->codecpar->sample_rate = AV_RL32(p + 36);
+        if (st->codecpar->sample_rate <= 0) {
+            av_log(s, AV_LOG_ERROR, "Invalid sample rate %d\n", st->codecpar->sample_rate);
+            return AVERROR_INVALIDDATA;
+        }
         st->codecpar->channels = AV_RL32(p + 48);
         if (st->codecpar->channels < 1 || st->codecpar->channels > 2) {
             av_log(s, AV_LOG_ERROR, "invalid channel count. Speex must be mono or stereo.\n");
@@ -78,6 +82,13 @@ static int speex_header(AVFormatContext *s, int idx) {
 
         spxp->packet_size  = AV_RL32(p + 56);
         frames_per_packet  = AV_RL32(p + 64);
+        if (spxp->packet_size < 0 ||
+            frames_per_packet < 0 ||
+            spxp->packet_size * (int64_t)frames_per_packet > INT32_MAX / 256) {
+            av_log(s, AV_LOG_ERROR, "invalid packet_size, frames_per_packet %d %d\n", spxp->packet_size, frames_per_packet);
+            spxp->packet_size = 0;
+            return AVERROR_INVALIDDATA;
+        }
         if (frames_per_packet)
             spxp->packet_size *= frames_per_packet;
 
diff --git a/mythtv/external/FFmpeg/libavformat/oggparsevp8.c b/mythtv/external/FFmpeg/libavformat/oggparsevp8.c
index c534ab117d9..b76ac71cc50 100644
--- a/mythtv/external/FFmpeg/libavformat/oggparsevp8.c
+++ b/mythtv/external/FFmpeg/libavformat/oggparsevp8.c
@@ -125,7 +125,7 @@ static int vp8_packet(AVFormatContext *s, int idx)
         os->lastdts = vp8_gptopts(s, idx, os->granule, NULL) - duration;
         if(s->streams[idx]->start_time == AV_NOPTS_VALUE) {
             s->streams[idx]->start_time = os->lastpts;
-            if (s->streams[idx]->duration)
+            if (s->streams[idx]->duration && s->streams[idx]->duration != AV_NOPTS_VALUE)
                 s->streams[idx]->duration -= s->streams[idx]->start_time;
         }
     }
diff --git a/mythtv/external/FFmpeg/libavformat/oma.c b/mythtv/external/FFmpeg/libavformat/oma.c
index 27028674dbd..f7ae3c99488 100644
--- a/mythtv/external/FFmpeg/libavformat/oma.c
+++ b/mythtv/external/FFmpeg/libavformat/oma.c
@@ -26,10 +26,12 @@
 const uint16_t ff_oma_srate_tab[8] = { 320, 441, 480, 882, 960, 0 };
 
 const AVCodecTag ff_oma_codec_tags[] = {
-    { AV_CODEC_ID_ATRAC3,      OMA_CODECID_ATRAC3  },
-    { AV_CODEC_ID_ATRAC3P,     OMA_CODECID_ATRAC3P },
-    { AV_CODEC_ID_MP3,         OMA_CODECID_MP3     },
-    { AV_CODEC_ID_PCM_S16BE,   OMA_CODECID_LPCM    },
+    { AV_CODEC_ID_ATRAC3,      OMA_CODECID_ATRAC3    },
+    { AV_CODEC_ID_ATRAC3P,     OMA_CODECID_ATRAC3P   },
+    { AV_CODEC_ID_MP3,         OMA_CODECID_MP3       },
+    { AV_CODEC_ID_PCM_S16BE,   OMA_CODECID_LPCM      },
+    { AV_CODEC_ID_ATRAC3PAL,   OMA_CODECID_ATRAC3PAL },
+    { AV_CODEC_ID_ATRAC3AL,    OMA_CODECID_ATRAC3AL  },
     { 0 },
 };
 
diff --git a/mythtv/external/FFmpeg/libavformat/oma.h b/mythtv/external/FFmpeg/libavformat/oma.h
index e2a187baccf..36fd0125e49 100644
--- a/mythtv/external/FFmpeg/libavformat/oma.h
+++ b/mythtv/external/FFmpeg/libavformat/oma.h
@@ -35,6 +35,8 @@ enum {
     OMA_CODECID_MP3     = 3,
     OMA_CODECID_LPCM    = 4,
     OMA_CODECID_WMA     = 5,
+    OMA_CODECID_ATRAC3PAL = 33,
+    OMA_CODECID_ATRAC3AL  = 34,
 };
 
 extern const uint16_t ff_oma_srate_tab[8];
diff --git a/mythtv/external/FFmpeg/libavformat/omadec.c b/mythtv/external/FFmpeg/libavformat/omadec.c
index 6e476dbf25b..423d52b3aaf 100644
--- a/mythtv/external/FFmpeg/libavformat/omadec.c
+++ b/mythtv/external/FFmpeg/libavformat/omadec.c
@@ -75,6 +75,8 @@ typedef struct OMAContext {
     uint8_t e_val[8];
     uint8_t iv[8];
     struct AVDES *av_des;
+
+    int (*read_packet)(AVFormatContext *s, AVPacket *pkt);
 } OMAContext;
 
 static void hex_log(AVFormatContext *s, int level,
@@ -302,6 +304,87 @@ static int decrypt_init(AVFormatContext *s, ID3v2ExtraMeta *em, uint8_t *header)
     return 0;
 }
 
+static int read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    OMAContext *oc  = s->priv_data;
+    AVStream *st    = s->streams[0];
+    int packet_size = st->codecpar->block_align;
+    int byte_rate   = st->codecpar->bit_rate >> 3;
+    int64_t pos     = avio_tell(s->pb);
+    int ret         = av_get_packet(s->pb, pkt, packet_size);
+
+    if (ret < packet_size)
+        pkt->flags |= AV_PKT_FLAG_CORRUPT;
+
+    if (ret < 0)
+        return ret;
+    if (!ret)
+        return AVERROR_EOF;
+
+    pkt->stream_index = 0;
+
+    if (pos >= oc->content_start && byte_rate > 0) {
+        pkt->pts =
+        pkt->dts = av_rescale(pos - oc->content_start, st->time_base.den,
+                              byte_rate * (int64_t)st->time_base.num);
+    }
+
+    if (oc->encrypted) {
+        /* previous unencrypted block saved in IV for
+         * the next packet (CBC mode) */
+        if (ret == packet_size)
+            av_des_crypt(oc->av_des, pkt->data, pkt->data,
+                         (packet_size >> 3), oc->iv, 1);
+        else
+            memset(oc->iv, 0, 8);
+    }
+
+    return ret;
+}
+
+static int aal_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    int64_t pos = avio_tell(s->pb);
+    int ret, pts;
+    int packet_size;
+    unsigned tag;
+
+    if (avio_feof(s->pb))
+        return AVERROR_EOF;
+
+    tag = avio_rb24(s->pb);
+    if (tag == 0)
+        return AVERROR_EOF;
+    else if (tag != MKBETAG(0,'B','L','K'))
+        return AVERROR_INVALIDDATA;
+
+    avio_skip(s->pb, 1);
+    packet_size = avio_rb16(s->pb);
+    avio_skip(s->pb, 2);
+    pts = avio_rb32(s->pb);
+    avio_skip(s->pb, 12);
+    ret = av_get_packet(s->pb, pkt, packet_size);
+    if (ret < packet_size)
+        pkt->flags |= AV_PKT_FLAG_CORRUPT;
+
+    if (ret < 0)
+        return ret;
+    if (!ret)
+        return AVERROR_EOF;
+
+    pkt->stream_index = 0;
+    pkt->pos = pos;
+    if (s->streams[0]->codecpar->codec_id == AV_CODEC_ID_ATRAC3AL) {
+        pkt->duration = 1024;
+        pkt->pts = pts * 1024LL;
+    } else {
+        pkt->duration = 2048;
+        pkt->pts = pts * 2048LL;
+    }
+
+    return ret;
+}
+
 static int oma_read_header(AVFormatContext *s)
 {
     int     ret, framesize, jsflag, samplerate;
@@ -314,6 +397,11 @@ static int oma_read_header(AVFormatContext *s)
     OMAContext *oc = s->priv_data;
 
     ff_id3v2_read(s, ID3v2_EA3_MAGIC, &extra_meta, 0);
+    if ((ret = ff_id3v2_parse_chapters(s, &extra_meta)) < 0) {
+        ff_id3v2_free_extra_meta(&extra_meta);
+        return ret;
+    }
+
     ret = avio_read(s->pb, buf, EA3_HEADER_SIZE);
     if (ret < EA3_HEADER_SIZE)
         return -1;
@@ -347,6 +435,8 @@ static int oma_read_header(AVFormatContext *s)
     st->codecpar->codec_id   = ff_codec_get_id(ff_oma_codec_tags,
                                                st->codecpar->codec_tag);
 
+    oc->read_packet = read_packet;
+
     switch (buf[32]) {
     case OMA_CODECID_ATRAC3:
         samplerate = ff_oma_srate_tab[(codec_params >> 13) & 7] * 100;
@@ -365,7 +455,7 @@ static int oma_read_header(AVFormatContext *s)
         st->codecpar->channels    = 2;
         st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
         st->codecpar->sample_rate = samplerate;
-        st->codecpar->bit_rate    = st->codecpar->sample_rate * framesize * 8 / 1024;
+        st->codecpar->bit_rate    = st->codecpar->sample_rate * framesize / (1024 / 8);
 
         /* fake the ATRAC3 extradata
          * (wav format, makes stream copy to wav work) */
@@ -398,7 +488,7 @@ static int oma_read_header(AVFormatContext *s)
             return AVERROR_INVALIDDATA;
         }
         st->codecpar->sample_rate = samplerate;
-        st->codecpar->bit_rate    = samplerate * framesize * 8 / 2048;
+        st->codecpar->bit_rate    = samplerate * framesize / (2048 / 8);
         avpriv_set_pts_info(st, 64, 1, samplerate);
         break;
     case OMA_CODECID_MP3:
@@ -417,6 +507,22 @@ static int oma_read_header(AVFormatContext *s)
             av_get_bits_per_sample(st->codecpar->codec_id);
         avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
         break;
+    case OMA_CODECID_ATRAC3AL:
+        st->codecpar->channels    = 2;
+        st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
+        st->codecpar->sample_rate = 44100;
+        avpriv_set_pts_info(st, 64, 1, 44100);
+        oc->read_packet = aal_read_packet;
+        framesize = 4096;
+        break;
+    case OMA_CODECID_ATRAC3PAL:
+        st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
+        st->codecpar->channels       = 2;
+        st->codecpar->sample_rate = 44100;
+        avpriv_set_pts_info(st, 64, 1, 44100);
+        oc->read_packet = aal_read_packet;
+        framesize = 4096;
+        break;
     default:
         av_log(s, AV_LOG_ERROR, "Unsupported codec %d!\n", buf[32]);
         return AVERROR(ENOSYS);
@@ -427,43 +533,10 @@ static int oma_read_header(AVFormatContext *s)
     return 0;
 }
 
-
 static int oma_read_packet(AVFormatContext *s, AVPacket *pkt)
 {
     OMAContext *oc  = s->priv_data;
-    AVStream *st    = s->streams[0];
-    int packet_size = st->codecpar->block_align;
-    int byte_rate   = st->codecpar->bit_rate >> 3;
-    int64_t pos     = avio_tell(s->pb);
-    int ret         = av_get_packet(s->pb, pkt, packet_size);
-
-    if (ret < packet_size)
-        pkt->flags |= AV_PKT_FLAG_CORRUPT;
-
-    if (ret < 0)
-        return ret;
-    if (!ret)
-        return AVERROR_EOF;
-
-    pkt->stream_index = 0;
-
-    if (pos >= oc->content_start && byte_rate > 0) {
-        pkt->pts =
-        pkt->dts = av_rescale(pos - oc->content_start, st->time_base.den,
-                              byte_rate * (int64_t)st->time_base.num);
-    }
-
-    if (oc->encrypted) {
-        /* previous unencrypted block saved in IV for
-         * the next packet (CBC mode) */
-        if (ret == packet_size)
-            av_des_crypt(oc->av_des, pkt->data, pkt->data,
-                         (packet_size >> 3), oc->iv, 1);
-        else
-            memset(oc->iv, 0, 8);
-    }
-
-    return ret;
+    return oc->read_packet(s, pkt);
 }
 
 static int oma_read_probe(AVProbeData *p)
@@ -491,8 +564,14 @@ static int oma_read_seek(struct AVFormatContext *s,
                          int stream_index, int64_t timestamp, int flags)
 {
     OMAContext *oc = s->priv_data;
-    int64_t err = ff_pcm_read_seek(s, stream_index, timestamp, flags);
+    AVStream *st = s->streams[0];
+    int64_t err;
+
+    if (st->codecpar->codec_id == AV_CODEC_ID_ATRAC3PAL ||
+        st->codecpar->codec_id == AV_CODEC_ID_ATRAC3AL)
+        return -1;
 
+    err = ff_pcm_read_seek(s, stream_index, timestamp, flags);
     if (!oc->encrypted)
         return err;
 
diff --git a/mythtv/external/FFmpeg/libavformat/omaenc.c b/mythtv/external/FFmpeg/libavformat/omaenc.c
index d89cc37ee0a..7952808bf86 100644
--- a/mythtv/external/FFmpeg/libavformat/omaenc.c
+++ b/mythtv/external/FFmpeg/libavformat/omaenc.c
@@ -84,8 +84,8 @@ static av_cold int oma_write_header(AVFormatContext *s)
                          (par->block_align/8 - 1));
         break;
     default:
-        av_log(s, AV_LOG_ERROR, "unsupported codec tag %d for write\n",
-               par->codec_tag);
+        av_log(s, AV_LOG_ERROR, "unsupported codec tag %s for write\n",
+               av_fourcc2str(par->codec_tag));
         return AVERROR(EINVAL);
     }
     for (i = 0; i < (EA3_HEADER_SIZE - 36)/4; i++)
diff --git a/mythtv/external/FFmpeg/libavformat/options.c b/mythtv/external/FFmpeg/libavformat/options.c
index 25a506eef86..9371c726674 100644
--- a/mythtv/external/FFmpeg/libavformat/options.c
+++ b/mythtv/external/FFmpeg/libavformat/options.c
@@ -102,6 +102,18 @@ static const AVClass av_format_context_class = {
 static int io_open_default(AVFormatContext *s, AVIOContext **pb,
                            const char *url, int flags, AVDictionary **options)
 {
+    int loglevel;
+
+    if (!strcmp(url, s->filename) ||
+        s->iformat && !strcmp(s->iformat->name, "image2") ||
+        s->oformat && !strcmp(s->oformat->name, "image2")
+    ) {
+        loglevel = AV_LOG_DEBUG;
+    } else
+        loglevel = AV_LOG_INFO;
+
+    av_log(s, loglevel, "Opening \'%s\' for %s\n", url, flags & AVIO_FLAG_WRITE ? "writing" : "reading");
+
 #if FF_API_OLD_OPEN_CALLBACKS
 FF_DISABLE_DEPRECATION_WARNINGS
     if (s->open_cb)
diff --git a/mythtv/external/FFmpeg/libavformat/options_table.h b/mythtv/external/FFmpeg/libavformat/options_table.h
index 9d61d5a158b..118086df665 100644
--- a/mythtv/external/FFmpeg/libavformat/options_table.h
+++ b/mythtv/external/FFmpeg/libavformat/options_table.h
@@ -39,7 +39,7 @@ static const AVOption avformat_options[] = {
 {"probesize", "set probing size", OFFSET(probesize), AV_OPT_TYPE_INT64, {.i64 = 5000000 }, 32, INT64_MAX, D},
 {"formatprobesize", "number of bytes to probe file format", OFFSET(format_probesize), AV_OPT_TYPE_INT, {.i64 = PROBE_BUF_MAX}, 0, INT_MAX-1, D},
 {"packetsize", "set packet size", OFFSET(packet_size), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, E},
-{"fflags", NULL, OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = AVFMT_FLAG_FLUSH_PACKETS | AVFMT_FLAG_AUTO_BSF }, INT_MIN, INT_MAX, D|E, "fflags"},
+{"fflags", NULL, OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = AVFMT_FLAG_AUTO_BSF }, INT_MIN, INT_MAX, D|E, "fflags"},
 {"flush_packets", "reduce the latency by flushing out packets immediately", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_FLUSH_PACKETS }, INT_MIN, INT_MAX, E, "fflags"},
 {"ignidx", "ignore index", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_IGNIDX }, INT_MIN, INT_MAX, D, "fflags"},
 {"genpts", "generate pts", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_GENPTS }, INT_MIN, INT_MAX, D, "fflags"},
@@ -48,7 +48,9 @@ static const AVOption avformat_options[] = {
 {"igndts", "ignore dts", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_IGNDTS }, INT_MIN, INT_MAX, D, "fflags"},
 {"discardcorrupt", "discard corrupted frames", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_DISCARD_CORRUPT }, INT_MIN, INT_MAX, D, "fflags"},
 {"sortdts", "try to interleave outputted packets by dts", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_SORT_DTS }, INT_MIN, INT_MAX, D, "fflags"},
+#if FF_API_LAVF_KEEPSIDE_FLAG
 {"keepside", "don't merge side data", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_KEEP_SIDE_DATA }, INT_MIN, INT_MAX, D, "fflags"},
+#endif
 {"fastseek", "fast but inaccurate seeks", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_FAST_SEEK }, INT_MIN, INT_MAX, D, "fflags"},
 {"latm", "enable RTP MP4A-LATM payload", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_MP4A_LATM }, INT_MIN, INT_MAX, E, "fflags"},
 {"nobuffer", "reduce the latency introduced by optional buffering", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_NOBUFFER }, 0, INT_MAX, D, "fflags"},
@@ -83,7 +85,7 @@ static const AVOption avformat_options[] = {
 {"use_wallclock_as_timestamps", "use wallclock as timestamps", OFFSET(use_wallclock_as_timestamps), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, D},
 {"skip_initial_bytes", "set number of bytes to skip before reading header and frames", OFFSET(skip_initial_bytes), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX-1, D},
 {"correct_ts_overflow", "correct single timestamp overflows", OFFSET(correct_ts_overflow), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, D},
-{"flush_packets", "enable flushing of the I/O context after each packet", OFFSET(flush_packets), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E},
+{"flush_packets", "enable flushing of the I/O context after each packet", OFFSET(flush_packets), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, E},
 {"metadata_header_padding", "set number of bytes to be written as padding in a metadata header", OFFSET(metadata_header_padding), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, E},
 {"output_ts_offset", "set output timestamp offset", OFFSET(output_ts_offset), AV_OPT_TYPE_DURATION, {.i64 = 0}, -INT64_MAX, INT64_MAX, E},
 {"max_interleave_delta", "maximum buffering duration for interleaving", OFFSET(max_interleave_delta), AV_OPT_TYPE_INT64, { .i64 = 10000000 }, 0, INT64_MAX, E },
@@ -105,6 +107,7 @@ static const AVOption avformat_options[] = {
 {"format_whitelist", "List of demuxers that are allowed to be used", OFFSET(format_whitelist), AV_OPT_TYPE_STRING, { .str = NULL },  CHAR_MIN, CHAR_MAX, D },
 {"protocol_whitelist", "List of protocols that are allowed to be used", OFFSET(protocol_whitelist), AV_OPT_TYPE_STRING, { .str = NULL },  CHAR_MIN, CHAR_MAX, D },
 {"protocol_blacklist", "List of protocols that are not allowed to be used", OFFSET(protocol_blacklist), AV_OPT_TYPE_STRING, { .str = NULL },  CHAR_MIN, CHAR_MAX, D },
+{"max_streams", "maximum number of streams", OFFSET(max_streams), AV_OPT_TYPE_INT, { .i64 = 1000 }, 0, INT_MAX, D },
 {NULL},
 };
 
diff --git a/mythtv/external/FFmpeg/libavformat/os_support.h b/mythtv/external/FFmpeg/libavformat/os_support.h
index caf1a2fab47..91220e9716a 100644
--- a/mythtv/external/FFmpeg/libavformat/os_support.h
+++ b/mythtv/external/FFmpeg/libavformat/os_support.h
@@ -76,7 +76,7 @@ static inline int is_dos_path(const char *path)
     return 0;
 }
 
-#if defined(__OS2__) || defined(__Plan9__)
+#if defined(__OS2__)
 #define SHUT_RD 0
 #define SHUT_WR 1
 #define SHUT_RDWR 2
@@ -146,18 +146,6 @@ int ff_poll(struct pollfd *fds, nfds_t numfds, int timeout);
 #include <windows.h>
 #include "libavutil/wchar_filename.h"
 
-#ifdef WINAPI_FAMILY
-#include <winapifamily.h>
-// If a WINAPI_FAMILY is defined, check that the desktop API subset
-// is enabled
-#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-#define USE_MOVEFILEEXA
-#endif
-#else
-// If no WINAPI_FAMILY is defined, assume the full API subset
-#define USE_MOVEFILEEXA
-#endif
-
 #define DEF_FS_FUNCTION(name, wfunc, afunc)               \
 static inline int win32_##name(const char *filename_utf8) \
 {                                                         \
@@ -232,7 +220,7 @@ static inline int win32_rename(const char *src_utf8, const char *dest_utf8)
 
 fallback:
     /* filename may be be in CP_ACP */
-#ifdef USE_MOVEFILEEXA
+#if !HAVE_WINRT
     ret = MoveFileExA(src_utf8, dest_utf8, MOVEFILE_REPLACE_EXISTING);
     if (ret)
         errno = EPERM;
diff --git a/mythtv/external/FFmpeg/libavformat/pcmdec.c b/mythtv/external/FFmpeg/libavformat/pcmdec.c
index 3c7e8ac84b4..d0ceea6fa9f 100644
--- a/mythtv/external/FFmpeg/libavformat/pcmdec.c
+++ b/mythtv/external/FFmpeg/libavformat/pcmdec.c
@@ -68,6 +68,7 @@ static int pcm_read_header(AVFormatContext *s)
                 av_log(s, AV_LOG_ERROR,
                        "Invalid sample_rate found in mime_type \"%s\"\n",
                        mime_type);
+                av_freep(&mime_type);
                 return AVERROR_INVALIDDATA;
             }
             st->codecpar->sample_rate = rate;
@@ -75,6 +76,7 @@ static int pcm_read_header(AVFormatContext *s)
                 st->codecpar->channels = channels;
         }
     }
+    av_freep(&mime_type);
 
     st->codecpar->bits_per_coded_sample =
         av_get_bits_per_sample(st->codecpar->codec_id);
diff --git a/mythtv/external/FFmpeg/libavformat/prompeg.c b/mythtv/external/FFmpeg/libavformat/prompeg.c
new file mode 100644
index 00000000000..9770a916a2b
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/prompeg.c
@@ -0,0 +1,481 @@
+/*
+ * Pro-MPEG Code of Practice #3 Release 2 FEC
+ * Copyright (c) 2016 Mobibase, France (http://www.mobibase.com)
+ *
+ * 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
+ * Pro-MPEG Code of Practice #3 Release 2 FEC protocol
+ * @author Vlad Tarca <vlad.tarca@gmail.com>
+ */
+
+/*
+ * Reminder:
+
+ [RFC 2733] FEC Packet Structure
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                         RTP Header                            |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                         FEC Header                            |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                         FEC Payload                           |
+   |                                                               |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+ [RFC 3550] RTP header
+
+    0                   1                   2                   3
+    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |V=2|P|X|  CC   |M|     PT      |       sequence number         |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                           timestamp                           |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |           synchronization source (SSRC) identifier            |
+   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+   |            contributing source (CSRC) identifiers             |
+   |                             ....                              |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ [RFC 3550] RTP header extension (after CSRC)
+
+    0                   1                   2                   3
+    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |      defined by profile       |           length              |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                        header extension                       |
+   |                             ....                              |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ [Pro-MPEG COP3] FEC Header
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |      SNBase low bits          |        length recovery        |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |E| PT recovery |                 mask                          |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                          TS recovery                          |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |X|D|type |index|    offset     |      NA       |SNBase ext bits|
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ */
+
+#include "libavutil/avstring.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/opt.h"
+#include "libavutil/parseutils.h"
+#include "libavutil/random_seed.h"
+#include "avformat.h"
+#include "config.h"
+#include "url.h"
+
+#define PROMPEG_RTP_PT 0x60
+#define PROMPEG_FEC_COL 0x0
+#define PROMPEG_FEC_ROW 0x1
+
+typedef struct PrompegFec {
+    uint16_t sn;
+    uint32_t ts;
+    uint8_t *bitstring;
+} PrompegFec;
+
+typedef struct PrompegContext {
+    const AVClass *class;
+    URLContext *fec_col_hd, *fec_row_hd;
+    PrompegFec **fec_arr, **fec_col_tmp, **fec_col, *fec_row;
+    int ttl;
+    uint8_t l, d;
+    uint8_t *rtp_buf;
+    uint16_t rtp_col_sn, rtp_row_sn;
+    uint16_t length_recovery;
+    int packet_size;
+    int packet_idx, packet_idx_max;
+    int fec_arr_len;
+    int bitstring_size;
+    int rtp_buf_size;
+    int init;
+    int first;
+} PrompegContext;
+
+#define OFFSET(x) offsetof(PrompegContext, x)
+#define E AV_OPT_FLAG_ENCODING_PARAM
+
+static const AVOption options[] = {
+    { "ttl",   "Time to live (in milliseconds, multicast only)", OFFSET(ttl), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = E },
+    { "l", "FEC L", OFFSET(l), AV_OPT_TYPE_INT, { .i64 =  5 }, 4, 20, .flags = E },
+    { "d", "FEC D", OFFSET(d), AV_OPT_TYPE_INT, { .i64 =  5 }, 4, 20, .flags = E },
+    { NULL }
+};
+
+static const AVClass prompeg_class = {
+    .class_name = "prompeg",
+    .item_name  = av_default_item_name,
+    .option     = options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+static void xor_fast(const uint8_t *in1, const uint8_t *in2, uint8_t *out, int size) {
+    int i, n, s;
+
+#if HAVE_FAST_64BIT
+    uint64_t v1, v2;
+
+    n = size / sizeof (uint64_t);
+    s = n * sizeof (uint64_t);
+
+    for (i = 0; i < n; i++) {
+        v1 = AV_RN64A(in1);
+        v2 = AV_RN64A(in2);
+        AV_WN64A(out, v1 ^ v2);
+        in1 += 8;
+        in2 += 8;
+        out += 8;
+    }
+#else
+    uint32_t v1, v2;
+
+    n = size / sizeof (uint32_t);
+    s = n * sizeof (uint32_t);
+
+    for (i = 0; i < n; i++) {
+        v1 = AV_RN32A(in1);
+        v2 = AV_RN32A(in2);
+        AV_WN32A(out, v1 ^ v2);
+        in1 += 4;
+        in2 += 4;
+        out += 4;
+    }
+#endif
+
+    n = size - s;
+
+    for (i = 0; i < n; i++) {
+        out[i] = in1[i] ^ in2[i];
+    }
+}
+
+static int prompeg_create_bitstring(URLContext *h, const uint8_t *buf, int size,
+        uint8_t **bitstring) {
+    PrompegContext *s = h->priv_data;
+    uint8_t *b;
+
+    if (size < 12 || (buf[0] & 0xc0) != 0x80 || (buf[1] & 0x7f) != 0x21) {
+        av_log(h, AV_LOG_ERROR, "Unsupported stream format (expected MPEG-TS over RTP)\n");
+        return AVERROR(EINVAL);
+    }
+    if (size != s->packet_size) {
+        av_log(h, AV_LOG_ERROR, "The RTP packet size must be constant (set pkt_size)\n");
+        return AVERROR(EINVAL);
+    }
+
+    *bitstring = av_malloc(s->bitstring_size);
+    if (!*bitstring) {
+        av_log(h, AV_LOG_ERROR, "Failed to allocate the bitstring buffer\n");
+        return AVERROR(ENOMEM);
+    }
+    b = *bitstring;
+
+    // P, X, CC
+    b[0] = buf[0] & 0x3f;
+    // M, PT
+    b[1] = buf[1];
+    // Timestamp
+    b[2] = buf[4];
+    b[3] = buf[5];
+    b[4] = buf[6];
+    b[5] = buf[7];
+    /*
+     * length_recovery: the unsigned network-ordered sum of lengths of CSRC,
+     * padding, extension and media payload
+     */
+    AV_WB16(b + 6, s->length_recovery);
+    // Payload
+    memcpy(b + 8, buf + 12, s->length_recovery);
+
+    return 0;
+}
+
+static int prompeg_write_fec(URLContext *h, PrompegFec *fec, uint8_t type) {
+    PrompegContext *s = h->priv_data;
+    URLContext *hd;
+    uint8_t *buf = s->rtp_buf; // zero-filled
+    uint8_t *b = fec->bitstring;
+    uint16_t sn;
+    int ret;
+
+    sn = type == PROMPEG_FEC_COL ? ++s->rtp_col_sn : ++s->rtp_row_sn;
+
+    // V, P, X, CC
+    buf[0] = 0x80 | (b[0] & 0x3f);
+    // M, PT
+    buf[1] = (b[1] & 0x80) | PROMPEG_RTP_PT;
+    // SN
+    AV_WB16(buf + 2, sn);
+    // TS
+    AV_WB32(buf + 4, fec->ts);
+    // CSRC=0
+    //AV_WB32(buf + 8, 0);
+    // SNBase low bits
+    AV_WB16(buf + 12, fec->sn);
+    // Length recovery
+    buf[14] = b[6];
+    buf[15] = b[7];
+    // E=1, PT recovery
+    buf[16] = 0x80 | b[1];
+    // Mask=0
+    //buf[17] = 0x0;
+    //buf[18] = 0x0;
+    //buf[19] = 0x0;
+    // TS recovery
+    buf[20] = b[2];
+    buf[21] = b[3];
+    buf[22] = b[4];
+    buf[23] = b[5];
+    // X=0, D, type=0, index=0
+    buf[24] = type == PROMPEG_FEC_COL ? 0x0 : 0x40;
+    // offset
+    buf[25] = type == PROMPEG_FEC_COL ? s->l : 0x1;
+    // NA
+    buf[26] = type == PROMPEG_FEC_COL ? s->d : s->l;
+    // SNBase ext bits=0
+    //buf[27] = 0x0;
+    // Payload
+    memcpy(buf + 28, b + 8, s->length_recovery);
+
+    hd = type == PROMPEG_FEC_COL ? s->fec_col_hd : s->fec_row_hd;
+    ret = ffurl_write(hd, buf, s->rtp_buf_size);
+    return ret;
+}
+
+static int prompeg_open(URLContext *h, const char *uri, int flags) {
+    PrompegContext *s = h->priv_data;
+    AVDictionary *udp_opts = NULL;
+    int rtp_port;
+    char hostname[256];
+    char buf[1024];
+
+    s->fec_col_hd = NULL;
+    s->fec_row_hd = NULL;
+
+    if (s->l * s->d > 100) {
+        av_log(h, AV_LOG_ERROR, "L * D must be <= 100\n");
+        return AVERROR(EINVAL);
+    }
+
+    av_url_split(NULL, 0, NULL, 0, hostname, sizeof (hostname), &rtp_port,
+            NULL, 0, uri);
+
+    if (rtp_port < 1 || rtp_port > UINT16_MAX - 4) {
+        av_log(h, AV_LOG_ERROR, "Invalid RTP base port %d\n", rtp_port);
+        return AVERROR(EINVAL);
+    }
+
+    if (s->ttl > 0) {
+        snprintf(buf, sizeof (buf), "%d", s->ttl);
+        av_dict_set(&udp_opts, "ttl", buf, 0);
+    }
+
+    ff_url_join(buf, sizeof (buf), "udp", NULL, hostname, rtp_port + 2, NULL);
+    if (ffurl_open_whitelist(&s->fec_col_hd, buf, flags, &h->interrupt_callback,
+            &udp_opts, h->protocol_whitelist, h->protocol_blacklist, h) < 0)
+        goto fail;
+    ff_url_join(buf, sizeof (buf), "udp", NULL, hostname, rtp_port + 4, NULL);
+    if (ffurl_open_whitelist(&s->fec_row_hd, buf, flags, &h->interrupt_callback,
+            &udp_opts, h->protocol_whitelist, h->protocol_blacklist, h) < 0)
+        goto fail;
+
+    h->max_packet_size = s->fec_col_hd->max_packet_size;
+    s->init = 1;
+
+    av_dict_free(&udp_opts);
+    av_log(h, AV_LOG_INFO, "ProMPEG CoP#3-R2 FEC L=%d D=%d\n", s->l, s->d);
+    return 0;
+
+fail:
+    ffurl_closep(&s->fec_col_hd);
+    ffurl_closep(&s->fec_row_hd);
+    av_dict_free(&udp_opts);
+    return AVERROR(EIO);
+}
+
+static int prompeg_init(URLContext *h, const uint8_t *buf, int size) {
+    PrompegContext *s = h->priv_data;
+    uint32_t seed;
+    int i;
+
+    s->fec_arr = NULL;
+    s->rtp_buf = NULL;
+
+    if (size < 12 || size > UINT16_MAX + 12) {
+        av_log(h, AV_LOG_ERROR, "Invalid RTP packet size\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    s->packet_idx = 0;
+    s->packet_idx_max = s->l * s->d;
+    s->packet_size = size;
+    s->length_recovery = size - 12;
+    s->rtp_buf_size = 28 + s->length_recovery; // 12 + 16: RTP + FEC headers
+    s->bitstring_size = 8 + s->length_recovery; // 8: P, X, CC, M, PT, SN, TS
+    s->fec_arr_len = 1 + 2 * s->l; // row + column tmp + column out
+
+    if (h->flags & AVFMT_FLAG_BITEXACT) {
+        s->rtp_col_sn = 0;
+        s->rtp_row_sn = 0;
+    } else {
+        seed = av_get_random_seed();
+        s->rtp_col_sn = seed & 0x0fff;
+        s->rtp_row_sn = (seed >> 16) & 0x0fff;
+    }
+
+    s->fec_arr = av_malloc_array(s->fec_arr_len, sizeof (PrompegFec*));
+    if (!s->fec_arr) {
+        goto fail;
+    }
+    for (i = 0; i < s->fec_arr_len; i++) {
+        s->fec_arr[i] = av_malloc(sizeof (PrompegFec));
+        if (!s->fec_arr[i]) {
+            goto fail;
+        }
+        s->fec_arr[i]->bitstring = av_malloc_array(s->bitstring_size, sizeof (uint8_t));
+        if (!s->fec_arr[i]->bitstring) {
+            av_freep(&s->fec_arr[i]);
+            goto fail;
+        }
+    }
+    s->fec_row = *s->fec_arr;
+    s->fec_col = s->fec_arr + 1;
+    s->fec_col_tmp = s->fec_arr + 1 + s->l;
+
+    s->rtp_buf = av_malloc_array(s->rtp_buf_size, sizeof (uint8_t));
+    if (!s->rtp_buf) {
+        goto fail;
+    }
+    memset(s->rtp_buf, 0, s->rtp_buf_size);
+
+    s->init = 0;
+    s->first = 1;
+
+    return 0;
+
+fail:
+    av_log(h, AV_LOG_ERROR, "Failed to allocate the FEC buffer\n");
+    return AVERROR(ENOMEM);
+}
+
+static int prompeg_write(URLContext *h, const uint8_t *buf, int size) {
+    PrompegContext *s = h->priv_data;
+    PrompegFec *fec_tmp;
+    uint8_t *bitstring = NULL;
+    int col_idx, col_out_idx, row_idx;
+    int ret, written = 0;
+
+    if (s->init && ((ret = prompeg_init(h, buf, size)) < 0))
+        goto end;
+
+    if ((ret = prompeg_create_bitstring(h, buf, size, &bitstring)) < 0)
+        goto end;
+
+    col_idx = s->packet_idx % s->l;
+    row_idx = s->packet_idx / s->l % s->d;
+
+    // FEC' (row) send block-aligned, xor
+    if (col_idx == 0) {
+        if (!s->first || s->packet_idx > 0) {
+            if ((ret = prompeg_write_fec(h, s->fec_row, PROMPEG_FEC_ROW)) < 0)
+                goto end;
+            written += ret;
+        }
+        memcpy(s->fec_row->bitstring, bitstring, s->bitstring_size);
+        s->fec_row->sn = AV_RB16(buf + 2);
+        s->fec_row->ts = AV_RB32(buf + 4);
+    } else {
+        xor_fast(s->fec_row->bitstring, bitstring, s->fec_row->bitstring,
+                s->bitstring_size);
+    }
+
+    // FEC (column) xor
+    if (row_idx == 0) {
+        if (!s->first) {
+            // swap fec_col and fec_col_tmp
+            fec_tmp = s->fec_col[col_idx];
+            s->fec_col[col_idx] = s->fec_col_tmp[col_idx];
+            s->fec_col_tmp[col_idx] = fec_tmp;
+        }
+        memcpy(s->fec_col_tmp[col_idx]->bitstring, bitstring, s->bitstring_size);
+        s->fec_col_tmp[col_idx]->sn = AV_RB16(buf + 2);
+        s->fec_col_tmp[col_idx]->ts = AV_RB32(buf + 4);
+    } else {
+        xor_fast(s->fec_col_tmp[col_idx]->bitstring, bitstring,
+                s->fec_col_tmp[col_idx]->bitstring, s->bitstring_size);
+    }
+
+    // FEC (column) send block-aligned
+    if (!s->first && s->packet_idx % s->d == 0) {
+        col_out_idx = s->packet_idx / s->d;
+        if ((ret = prompeg_write_fec(h, s->fec_col[col_out_idx], PROMPEG_FEC_COL)) < 0)
+            goto end;
+        written += ret;
+    }
+
+    if (++s->packet_idx >= s->packet_idx_max) {
+        s->packet_idx = 0;
+        if (s->first)
+            s->first = 0;
+    }
+
+    ret = written;
+
+end:
+    av_free(bitstring);
+    return ret;
+}
+
+static int prompeg_close(URLContext *h) {
+    PrompegContext *s = h->priv_data;
+    int i;
+
+    ffurl_closep(&s->fec_col_hd);
+    ffurl_closep(&s->fec_row_hd);
+
+    if (s->fec_arr) {
+        for (i = 0; i < s->fec_arr_len; i++) {
+            av_free(s->fec_arr[i]->bitstring);
+            av_freep(&s->fec_arr[i]);
+        }
+        av_freep(&s->fec_arr);
+    }
+    av_freep(&s->rtp_buf);
+
+    return 0;
+}
+
+const URLProtocol ff_prompeg_protocol = {
+    .name                      = "prompeg",
+    .url_open                  = prompeg_open,
+    .url_write                 = prompeg_write,
+    .url_close                 = prompeg_close,
+    .priv_data_size            = sizeof(PrompegContext),
+    .flags                     = URL_PROTOCOL_FLAG_NETWORK,
+    .priv_data_class           = &prompeg_class,
+};
diff --git a/mythtv/external/FFmpeg/libavformat/protocols.c b/mythtv/external/FFmpeg/libavformat/protocols.c
index b250f4934c9..8d3555ed520 100644
--- a/mythtv/external/FFmpeg/libavformat/protocols.c
+++ b/mythtv/external/FFmpeg/libavformat/protocols.c
@@ -43,6 +43,7 @@ extern const URLProtocol ff_mmsh_protocol;
 extern const URLProtocol ff_mmst_protocol;
 extern const URLProtocol ff_md5_protocol;
 extern const URLProtocol ff_pipe_protocol;
+extern const URLProtocol ff_prompeg_protocol;
 extern const URLProtocol ff_rtmp_protocol;
 extern const URLProtocol ff_rtmpe_protocol;
 extern const URLProtocol ff_rtmps_protocol;
diff --git a/mythtv/external/FFmpeg/libavformat/pvfdec.c b/mythtv/external/FFmpeg/libavformat/pvfdec.c
index b9f6d4f2c2f..c6652b9b43c 100644
--- a/mythtv/external/FFmpeg/libavformat/pvfdec.c
+++ b/mythtv/external/FFmpeg/libavformat/pvfdec.c
@@ -19,6 +19,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavcodec/internal.h"
 #include "avformat.h"
 #include "internal.h"
 #include "pcm.h"
@@ -44,7 +45,8 @@ static int pvf_read_header(AVFormatContext *s)
                &bps) != 3)
         return AVERROR_INVALIDDATA;
 
-    if (channels <= 0 || bps <= 0 || sample_rate <= 0)
+    if (channels <= 0 || channels > FF_SANE_NB_CHANNELS ||
+        bps <= 0 || bps > INT_MAX / FF_SANE_NB_CHANNELS || sample_rate <= 0)
         return AVERROR_INVALIDDATA;
 
     st = avformat_new_stream(s, NULL);
diff --git a/mythtv/external/FFmpeg/libavformat/r3d.c b/mythtv/external/FFmpeg/libavformat/r3d.c
index b6094888399..1f53d847e95 100644
--- a/mythtv/external/FFmpeg/libavformat/r3d.c
+++ b/mythtv/external/FFmpeg/libavformat/r3d.c
@@ -186,7 +186,7 @@ static int r3d_read_header(AVFormatContext *s)
 
     s->internal->data_offset = avio_tell(s->pb);
     av_log(s, AV_LOG_TRACE, "data offset %#"PRIx64"\n", s->internal->data_offset);
-    if (!s->pb->seekable)
+    if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
         return 0;
     // find REOB/REOF/REOS to load index
     avio_seek(s->pb, avio_size(s->pb)-48-8, SEEK_SET);
diff --git a/mythtv/external/FFmpeg/libavformat/rawdec.c b/mythtv/external/FFmpeg/libavformat/rawdec.c
index 876a6e6a753..e926549a603 100644
--- a/mythtv/external/FFmpeg/libavformat/rawdec.c
+++ b/mythtv/external/FFmpeg/libavformat/rawdec.c
@@ -43,7 +43,7 @@ int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
 
     pkt->pos= avio_tell(s->pb);
     pkt->stream_index = 0;
-    ret = ffio_read_partial(s->pb, pkt->data, size);
+    ret = avio_read_partial(s->pb, pkt->data, size);
     if (ret < 0) {
         av_packet_unref(pkt);
         return ret;
diff --git a/mythtv/external/FFmpeg/libavformat/rawenc.c b/mythtv/external/FFmpeg/libavformat/rawenc.c
index 730e99a0208..f640121cb46 100644
--- a/mythtv/external/FFmpeg/libavformat/rawenc.c
+++ b/mythtv/external/FFmpeg/libavformat/rawenc.c
@@ -65,7 +65,7 @@ static int adx_write_trailer(AVFormatContext *s)
     AVIOContext *pb = s->pb;
     AVCodecParameters *par = s->streams[0]->codecpar;
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         int64_t file_size = avio_tell(pb);
         uint64_t sample_count = (file_size - 36) / par->channels / 18 * 32;
         if (sample_count <= UINT32_MAX) {
@@ -196,6 +196,30 @@ AVOutputFormat ff_g723_1_muxer = {
 };
 #endif
 
+#if CONFIG_G726_MUXER
+AVOutputFormat ff_g726_muxer = {
+    .name              = "g726",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw big-endian G.726 (\"left-justified\")"),
+    .audio_codec       = AV_CODEC_ID_ADPCM_G726,
+    .video_codec       = AV_CODEC_ID_NONE,
+    .write_header      = force_one_stream,
+    .write_packet      = ff_raw_write_packet,
+    .flags             = AVFMT_NOTIMESTAMPS,
+};
+#endif
+
+#if CONFIG_G726LE_MUXER
+AVOutputFormat ff_g726le_muxer = {
+    .name              = "g726le",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw little-endian G.726 (\"right-justified\")"),
+    .audio_codec       = AV_CODEC_ID_ADPCM_G726LE,
+    .video_codec       = AV_CODEC_ID_NONE,
+    .write_header      = force_one_stream,
+    .write_packet      = ff_raw_write_packet,
+    .flags             = AVFMT_NOTIMESTAMPS,
+};
+#endif
+
 #if CONFIG_GSM_MUXER
 AVOutputFormat ff_gsm_muxer = {
     .name              = "gsm",
@@ -337,6 +361,19 @@ AVOutputFormat ff_mlp_muxer = {
 };
 #endif
 
+#if CONFIG_MP2_MUXER
+AVOutputFormat ff_mp2_muxer = {
+    .name              = "mp2",
+    .long_name         = NULL_IF_CONFIG_SMALL("MP2 (MPEG audio layer 2)"),
+    .mime_type         = "audio/mpeg",
+    .extensions        = "mp2,m2a,mpa",
+    .audio_codec       = AV_CODEC_ID_MP2,
+    .video_codec       = AV_CODEC_ID_NONE,
+    .write_packet      = ff_raw_write_packet,
+    .flags             = AVFMT_NOTIMESTAMPS,
+};
+#endif
+
 #if CONFIG_MPEG1VIDEO_MUXER
 AVOutputFormat ff_mpeg1video_muxer = {
     .name              = "mpeg1video",
diff --git a/mythtv/external/FFmpeg/libavformat/rdt.c b/mythtv/external/FFmpeg/libavformat/rdt.c
index 8670eadce67..b69827fcbfc 100644
--- a/mythtv/external/FFmpeg/libavformat/rdt.c
+++ b/mythtv/external/FFmpeg/libavformat/rdt.c
@@ -323,7 +323,7 @@ rdt_parse_packet (AVFormatContext *ctx, PayloadContext *rdt, AVStream *st,
                                   st, rdt->rmst[st->index], pkt);
         if (rdt->audio_pkt_cnt == 0 &&
             st->codecpar->codec_id == AV_CODEC_ID_AAC)
-            av_freep(&rdt->rmctx->pb);
+            avio_context_free(&rdt->rmctx->pb);
     }
     pkt->stream_index = st->index;
     pkt->pts = *timestamp;
diff --git a/mythtv/external/FFmpeg/libavformat/riff.c b/mythtv/external/FFmpeg/libavformat/riff.c
index 3c5a37c3f68..3f0b390774f 100644
--- a/mythtv/external/FFmpeg/libavformat/riff.c
+++ b/mythtv/external/FFmpeg/libavformat/riff.c
@@ -153,7 +153,6 @@ const AVCodecTag ff_codec_bmp_tags[] = {
     { AV_CODEC_ID_DVVIDEO,      MKTAG('S', 'L', 'D', 'V') },
     { AV_CODEC_ID_DVVIDEO,      MKTAG('A', 'V', 'd', '1') },
     { AV_CODEC_ID_MPEG1VIDEO,   MKTAG('m', 'p', 'g', '1') },
-    { AV_CODEC_ID_MPEG1VIDEO,   MKTAG('m', 'p', 'g', '2') },
     { AV_CODEC_ID_MPEG2VIDEO,   MKTAG('m', 'p', 'g', '2') },
     { AV_CODEC_ID_MPEG2VIDEO,   MKTAG('M', 'P', 'E', 'G') },
     { AV_CODEC_ID_MPEG1VIDEO,   MKTAG('P', 'I', 'M', '1') },
@@ -284,6 +283,14 @@ const AVCodecTag ff_codec_bmp_tags[] = {
     { AV_CODEC_ID_RAWVIDEO,     MKTAG('I', '4', 'A', 'B') },
     { AV_CODEC_ID_RAWVIDEO,     MKTAG('I', '4', 'F', 'L') },
     { AV_CODEC_ID_RAWVIDEO,     MKTAG('I', '4', 'F', 'B') },
+    { AV_CODEC_ID_RAWVIDEO,     MKTAG('I', '0', 'C', 'L') },
+    { AV_CODEC_ID_RAWVIDEO,     MKTAG('I', '0', 'C', 'B') },
+    { AV_CODEC_ID_RAWVIDEO,     MKTAG('I', '2', 'C', 'L') },
+    { AV_CODEC_ID_RAWVIDEO,     MKTAG('I', '2', 'C', 'B') },
+    { AV_CODEC_ID_RAWVIDEO,     MKTAG('I', '4', 'C', 'L') },
+    { AV_CODEC_ID_RAWVIDEO,     MKTAG('I', '4', 'C', 'B') },
+    { AV_CODEC_ID_RAWVIDEO,     MKTAG('I', '0', 'F', 'L') },
+    { AV_CODEC_ID_RAWVIDEO,     MKTAG('I', '0', 'F', 'B') },
     { AV_CODEC_ID_FRWU,         MKTAG('F', 'R', 'W', 'U') },
     { AV_CODEC_ID_R10K,         MKTAG('R', '1', '0', 'k') },
     { AV_CODEC_ID_R210,         MKTAG('r', '2', '1', '0') },
@@ -428,8 +435,34 @@ const AVCodecTag ff_codec_bmp_tags[] = {
     { AV_CODEC_ID_M101,         MKTAG('M', '1', '0', '1') },
     { AV_CODEC_ID_M101,         MKTAG('M', '1', '0', '2') },
     { AV_CODEC_ID_MAGICYUV,     MKTAG('M', 'A', 'G', 'Y') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '8', 'R', 'G') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '8', 'R', 'A') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '8', 'G', '0') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '8', 'Y', '0') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '8', 'Y', '2') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '8', 'Y', '4') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '8', 'Y', 'A') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '0', 'R', 'A') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '0', 'R', 'G') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '0', 'G', '0') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '0', 'Y', '2') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '2', 'R', 'A') },
+    { AV_CODEC_ID_MAGICYUV,     MKTAG('M', '2', 'R', 'G') },
     { AV_CODEC_ID_YLC,          MKTAG('Y', 'L', 'C', '0') },
-
+    { AV_CODEC_ID_SPEEDHQ,      MKTAG('S', 'H', 'Q', '0') },
+    { AV_CODEC_ID_SPEEDHQ,      MKTAG('S', 'H', 'Q', '1') },
+    { AV_CODEC_ID_SPEEDHQ,      MKTAG('S', 'H', 'Q', '2') },
+    { AV_CODEC_ID_SPEEDHQ,      MKTAG('S', 'H', 'Q', '3') },
+    { AV_CODEC_ID_SPEEDHQ,      MKTAG('S', 'H', 'Q', '4') },
+    { AV_CODEC_ID_SPEEDHQ,      MKTAG('S', 'H', 'Q', '5') },
+    { AV_CODEC_ID_SPEEDHQ,      MKTAG('S', 'H', 'Q', '7') },
+    { AV_CODEC_ID_SPEEDHQ,      MKTAG('S', 'H', 'Q', '9') },
+    { AV_CODEC_ID_FMVC,         MKTAG('F', 'M', 'V', 'C') },
+    { AV_CODEC_ID_SCPR,         MKTAG('S', 'C', 'P', 'R') },
+    { AV_CODEC_ID_CLEARVIDEO,   MKTAG('U', 'C', 'O', 'D') },
+    { AV_CODEC_ID_AV1,          MKTAG('A', 'V', '0', '1') },
+    { AV_CODEC_ID_MSCC,         MKTAG('M', 'S', 'C', 'C') },
+    { AV_CODEC_ID_SRGC,         MKTAG('S', 'R', 'G', 'C') },
     { AV_CODEC_ID_NONE,         0 }
 };
 
diff --git a/mythtv/external/FFmpeg/libavformat/riff.h b/mythtv/external/FFmpeg/libavformat/riff.h
index fe87e819335..323aa38b4d7 100644
--- a/mythtv/external/FFmpeg/libavformat/riff.h
+++ b/mythtv/external/FFmpeg/libavformat/riff.h
@@ -41,11 +41,12 @@ void ff_end_tag(AVIOContext *pb, int64_t start);
 /**
  * Read BITMAPINFOHEADER structure and set AVStream codec width, height and
  * bits_per_encoded_sample fields. Does not read extradata.
+ * Writes the size of the BMP file to *size.
  * @return codec tag
  */
-int ff_get_bmp_header(AVIOContext *pb, AVStream *st, unsigned *esize);
+int ff_get_bmp_header(AVIOContext *pb, AVStream *st, uint32_t *size);
 
-void ff_put_bmp_header(AVIOContext *pb, AVCodecParameters *par, const AVCodecTag *tags, int for_asf, int ignore_extradata);
+void ff_put_bmp_header(AVIOContext *pb, AVCodecParameters *par, int for_asf, int ignore_extradata);
 
 /**
  * Tell ff_put_wav_header() to use WAVEFORMATEX even for PCM codecs.
@@ -109,6 +110,8 @@ extern const AVCodecGuid ff_codec_wav_guids[];
     0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71
 #define FF_AMBISONIC_BASE_GUID \
     0x21, 0x07, 0xD3, 0x11, 0x86, 0x44, 0xC8, 0xC1, 0xCA, 0x00, 0x00, 0x00
+#define FF_BROKEN_BASE_GUID \
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA
 
 static av_always_inline int ff_guidcmp(const void *g1, const void *g2)
 {
diff --git a/mythtv/external/FFmpeg/libavformat/riffdec.c b/mythtv/external/FFmpeg/libavformat/riffdec.c
index 1602c31169b..b448f9116fd 100644
--- a/mythtv/external/FFmpeg/libavformat/riffdec.c
+++ b/mythtv/external/FFmpeg/libavformat/riffdec.c
@@ -61,15 +61,18 @@ enum AVCodecID ff_codec_guid_get_id(const AVCodecGuid *guids, ff_asf_guid guid)
 static void parse_waveformatex(AVIOContext *pb, AVCodecParameters *par)
 {
     ff_asf_guid subformat;
-    int bps = avio_rl16(pb);
+    int bps;
+
+    bps = avio_rl16(pb);
     if (bps)
         par->bits_per_coded_sample = bps;
-
     par->channel_layout        = avio_rl32(pb); /* dwChannelMask */
 
     ff_get_guid(pb, &subformat);
     if (!memcmp(subformat + 4,
                 (const uint8_t[]){ FF_AMBISONIC_BASE_GUID }, 12) ||
+        !memcmp(subformat + 4,
+                (const uint8_t[]){ FF_BROKEN_BASE_GUID }, 12) ||
         !memcmp(subformat + 4,
                 (const uint8_t[]){ FF_MEDIASUBTYPE_BASE_GUID }, 12)) {
         par->codec_tag = AV_RL32(subformat);
@@ -205,11 +208,12 @@ enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
     return id;
 }
 
-int ff_get_bmp_header(AVIOContext *pb, AVStream *st, unsigned *esize)
+int ff_get_bmp_header(AVIOContext *pb, AVStream *st, uint32_t *size)
 {
     int tag1;
-    if(esize) *esize  = avio_rl32(pb);
-    else                avio_rl32(pb);
+    uint32_t size_ = avio_rl32(pb);
+    if (size)
+        *size = size_;
     st->codecpar->width  = avio_rl32(pb);
     st->codecpar->height = (int32_t)avio_rl32(pb);
     avio_rl16(pb); /* planes */
diff --git a/mythtv/external/FFmpeg/libavformat/riffenc.c b/mythtv/external/FFmpeg/libavformat/riffenc.c
index c96329da487..c04d55c4230 100644
--- a/mythtv/external/FFmpeg/libavformat/riffenc.c
+++ b/mythtv/external/FFmpeg/libavformat/riffenc.c
@@ -207,7 +207,7 @@ int ff_put_wav_header(AVFormatContext *s, AVIOContext *pb,
 
 /* BITMAPINFOHEADER header */
 void ff_put_bmp_header(AVIOContext *pb, AVCodecParameters *par,
-                       const AVCodecTag *tags, int for_asf, int ignore_extradata)
+                       int for_asf, int ignore_extradata)
 {
     int keep_height = par->extradata_size >= 9 &&
                       !memcmp(par->extradata + par->extradata_size - 9, "BottomUp", 9);
diff --git a/mythtv/external/FFmpeg/libavformat/rl2.c b/mythtv/external/FFmpeg/libavformat/rl2.c
index 0bec8f1d9ab..eb1682dfcb7 100644
--- a/mythtv/external/FFmpeg/libavformat/rl2.c
+++ b/mythtv/external/FFmpeg/libavformat/rl2.c
@@ -170,12 +170,21 @@ static av_cold int rl2_read_header(AVFormatContext *s)
     }
 
     /** read offset and size tables */
-    for(i=0; i < frame_count;i++)
+    for(i=0; i < frame_count;i++) {
+        if (avio_feof(pb))
+            return AVERROR_INVALIDDATA;
         chunk_size[i] = avio_rl32(pb);
-    for(i=0; i < frame_count;i++)
+    }
+    for(i=0; i < frame_count;i++) {
+        if (avio_feof(pb))
+            return AVERROR_INVALIDDATA;
         chunk_offset[i] = avio_rl32(pb);
-    for(i=0; i < frame_count;i++)
+    }
+    for(i=0; i < frame_count;i++) {
+        if (avio_feof(pb))
+            return AVERROR_INVALIDDATA;
         audio_size[i] = avio_rl32(pb) & 0xFFFF;
+    }
 
     /** build the sample index */
     for(i=0;i<frame_count;i++){
diff --git a/mythtv/external/FFmpeg/libavformat/rm.c b/mythtv/external/FFmpeg/libavformat/rm.c
index 0591a1735ad..52c7ccc1e8e 100644
--- a/mythtv/external/FFmpeg/libavformat/rm.c
+++ b/mythtv/external/FFmpeg/libavformat/rm.c
@@ -43,5 +43,6 @@ const AVCodecTag ff_rm_codec_tags[] = {
     { AV_CODEC_ID_AAC,    MKTAG('r','a','a','c') },
     { AV_CODEC_ID_AAC,    MKTAG('r','a','c','p') },
     { AV_CODEC_ID_RALF,   MKTAG('L','S','D',':') },
+    { AV_CODEC_ID_CLEARVIDEO, MKTAG('C','L','V','1') },
     { AV_CODEC_ID_NONE },
 };
diff --git a/mythtv/external/FFmpeg/libavformat/rmdec.c b/mythtv/external/FFmpeg/libavformat/rmdec.c
index d1758628ad6..d6d7d9cd841 100644
--- a/mythtv/external/FFmpeg/libavformat/rmdec.c
+++ b/mythtv/external/FFmpeg/libavformat/rmdec.c
@@ -236,6 +236,7 @@ static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb,
                     return -1;
                 }
                 st->codecpar->block_align = ff_sipr_subpk_size[flavor];
+                st->need_parsing = AVSTREAM_PARSE_FULL_RAW;
             } else {
                 if(sub_packet_size <= 0){
                     av_log(s, AV_LOG_ERROR, "sub_packet_size is invalid\n");
@@ -379,7 +380,8 @@ int ff_rm_read_mdpr_codecdata(AVFormatContext *s, AVIOContext *pb,
         st->codecpar->codec_tag = avio_rl32(pb);
         st->codecpar->codec_id  = ff_codec_get_id(ff_rm_codec_tags,
                                                   st->codecpar->codec_tag);
-        av_log(s, AV_LOG_TRACE, "%X %X\n", st->codecpar->codec_tag, MKTAG('R', 'V', '2', '0'));
+        av_log(s, AV_LOG_TRACE, "%"PRIX32" %X\n",
+               st->codecpar->codec_tag, MKTAG('R', 'V', '2', '0'));
         if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
             goto fail1;
         st->codecpar->width  = avio_rb16(pb);
@@ -563,13 +565,8 @@ static int rm_read_header(AVFormatContext *s)
         tag = avio_rl32(pb);
         tag_size = avio_rb32(pb);
         avio_rb16(pb);
-        av_log(s, AV_LOG_TRACE, "tag=%c%c%c%c (%08x) size=%d\n",
-                (tag      ) & 0xff,
-                (tag >>  8) & 0xff,
-                (tag >> 16) & 0xff,
-                (tag >> 24) & 0xff,
-                tag,
-                tag_size);
+        av_log(s, AV_LOG_TRACE, "tag=%s size=%d\n",
+               av_fourcc2str(tag), tag_size);
         if (tag_size < 10 && tag != MKTAG('D', 'A', 'T', 'A'))
             goto fail;
         switch(tag) {
@@ -650,7 +647,8 @@ static int rm_read_header(AVFormatContext *s)
 
     if (!data_off)
         data_off = avio_tell(pb) - 18;
-    if (indx_off && pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX) &&
+    if (indx_off && (pb->seekable & AVIO_SEEKABLE_NORMAL) &&
+        !(s->flags & AVFMT_FLAG_IGNIDX) &&
         avio_seek(pb, indx_off, SEEK_SET) >= 0) {
         rm_read_index(s);
         avio_seek(pb, data_off + 18, SEEK_SET);
@@ -934,6 +932,10 @@ ff_rm_parse_packet (AVFormatContext *s, AVIOContext *pb,
 
              ast->sub_packet_cnt = 0;
              rm->audio_stream_num = st->index;
+            if (st->codecpar->block_align <= 0) {
+                av_log(s, AV_LOG_ERROR, "Invalid block alignment %d\n", st->codecpar->block_align);
+                return AVERROR_INVALIDDATA;
+            }
              rm->audio_pkt_cnt = h * w / st->codecpar->block_align;
         } else if ((ast->deint_id == DEINT_ID_VBRF) ||
                    (ast->deint_id == DEINT_ID_VBRS)) {
@@ -959,19 +961,6 @@ ff_rm_parse_packet (AVFormatContext *s, AVIOContext *pb,
 
     pkt->stream_index = st->index;
 
-#if 0
-    if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
-        if(st->codecpar->codec_id == AV_CODEC_ID_RV20){
-            int seq= 128*(pkt->data[2]&0x7F) + (pkt->data[3]>>1);
-            av_log(s, AV_LOG_DEBUG, "%d %"PRId64" %d\n", *timestamp, *timestamp*512LL/25, seq);
-
-            seq |= (timestamp&~0x3FFF);
-            if(seq - timestamp >  0x2000) seq -= 0x4000;
-            if(seq - timestamp < -0x2000) seq += 0x4000;
-        }
-    }
-#endif
-
     pkt->pts = timestamp;
     if (flags & 2)
         pkt->flags |= AV_PKT_FLAG_KEY;
@@ -1234,8 +1223,11 @@ static int ivr_read_header(AVFormatContext *s)
             av_log(s, AV_LOG_DEBUG, "%s = '%s'\n", key, val);
         } else if (type == 4) {
             av_log(s, AV_LOG_DEBUG, "%s = '0x", key);
-            for (j = 0; j < len; j++)
+            for (j = 0; j < len; j++) {
+                if (avio_feof(pb))
+                    return AVERROR_INVALIDDATA;
                 av_log(s, AV_LOG_DEBUG, "%X", avio_r8(pb));
+            }
             av_log(s, AV_LOG_DEBUG, "'\n");
         } else if (len == 4 && type == 3 && !strncmp(key, "StreamCount", tlen)) {
             nb_streams = value = avio_rb32(pb);
diff --git a/mythtv/external/FFmpeg/libavformat/rmenc.c b/mythtv/external/FFmpeg/libavformat/rmenc.c
index 3708f421bc4..3bff4daf0a7 100644
--- a/mythtv/external/FFmpeg/libavformat/rmenc.c
+++ b/mythtv/external/FFmpeg/libavformat/rmenc.c
@@ -72,14 +72,12 @@ static int rv10_write_header(AVFormatContext *ctx,
     RMMuxContext *rm = ctx->priv_data;
     AVIOContext *s = ctx->pb;
     StreamInfo *stream;
-    unsigned char *data_offset_ptr, *start_ptr;
     const char *desc, *mimetype;
     int nb_packets, packet_total_size, packet_max_size, size, packet_avg_size, i;
-    int bit_rate, v, duration, flags, data_pos;
+    int bit_rate, v, duration, flags;
+    int data_offset;
     AVDictionaryEntry *tag;
 
-    start_ptr = s->buf_ptr;
-
     ffio_wfourcc(s, ".RMF");
     avio_wb32(s,18); /* header size */
     avio_wb16(s,0);
@@ -119,11 +117,11 @@ static int rv10_write_header(AVFormatContext *ctx,
     avio_wb32(s, BUFFER_DURATION);           /* preroll */
     avio_wb32(s, index_pos);           /* index offset */
     /* computation of data the data offset */
-    data_offset_ptr = s->buf_ptr;
+    data_offset = avio_tell(s);
     avio_wb32(s, 0);           /* data offset : will be patched after */
     avio_wb16(s, ctx->nb_streams);    /* num streams */
     flags = 1 | 2; /* save allowed & perfect play */
-    if (!s->seekable)
+    if (!(s->seekable & AVIO_SEEKABLE_NORMAL))
         flags |= 4; /* live broadcast */
     avio_wb16(s, flags);
 
@@ -175,7 +173,7 @@ static int rv10_write_header(AVFormatContext *ctx,
         avio_wb32(s, 0);           /* start time */
         avio_wb32(s, BUFFER_DURATION);           /* preroll */
         /* duration */
-        if (!s->seekable || !stream->total_frames)
+        if (!(s->seekable & AVIO_SEEKABLE_NORMAL) || !stream->total_frames)
             avio_wb32(s, (int)(3600 * 1000));
         else
             avio_wb32(s, av_rescale_q_rnd(stream->total_frames, (AVRational){1000, 1},  stream->frame_rate, AV_ROUND_ZERO));
@@ -253,6 +251,12 @@ static int rv10_write_header(AVFormatContext *ctx,
                 ffio_wfourcc(s,"RV20");
             avio_wb16(s, stream->par->width);
             avio_wb16(s, stream->par->height);
+
+            if (stream->frame_rate.num / stream->frame_rate.den > 65535) {
+                av_log(s, AV_LOG_ERROR, "Frame rate %d is too high\n", stream->frame_rate.num / stream->frame_rate.den);
+                return AVERROR(EINVAL);
+            }
+
             avio_wb16(s, stream->frame_rate.num / stream->frame_rate.den); /* frames per seconds ? */
             avio_wb32(s,0);     /* unknown meaning */
             avio_wb16(s, stream->frame_rate.num / stream->frame_rate.den);  /* unknown meaning */
@@ -270,12 +274,11 @@ static int rv10_write_header(AVFormatContext *ctx,
     }
 
     /* patch data offset field */
-    data_pos = s->buf_ptr - start_ptr;
-    rm->data_pos = data_pos;
-    data_offset_ptr[0] = data_pos >> 24;
-    data_offset_ptr[1] = data_pos >> 16;
-    data_offset_ptr[2] = data_pos >> 8;
-    data_offset_ptr[3] = data_pos;
+    rm->data_pos = avio_tell(s);
+    if (avio_seek(s, data_offset, SEEK_SET) >= 0) {
+        avio_wb32(s, rm->data_pos);
+        avio_seek(s, rm->data_pos, SEEK_SET);
+    }
 
     /* data stream */
     ffio_wfourcc(s, "DATA");
@@ -394,7 +397,6 @@ static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int
 
     /* Well, I spent some time finding the meaning of these bits. I am
        not sure I understood everything, but it works !! */
-#if 1
     if (size > MAX_PACKET_SIZE) {
         av_log(s, AV_LOG_ERROR, "Muxing packets larger than 64 kB (%d) is not supported\n", size);
         return AVERROR_PATCHWELCOME;
@@ -416,13 +418,6 @@ static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int
         avio_wb16(pb, 0x4000 | size); /* total frame size */
         avio_wb16(pb, 0x4000 | size); /* offset from the start or the end */
     }
-#else
-    /* full frame */
-    write_packet_header(s, size + 6);
-    avio_w8(pb, 0xc0);
-    avio_wb16(pb, 0x4000 + size); /* total frame size */
-    avio_wb16(pb, 0x4000 + packet_number * 126); /* position in stream */
-#endif
     avio_w8(pb, stream->nb_frames & 0xff);
 
     avio_write(pb, buf, size);
@@ -446,7 +441,7 @@ static int rm_write_trailer(AVFormatContext *s)
     int data_size, index_pos, i;
     AVIOContext *pb = s->pb;
 
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         /* end of file: finish to write header */
         index_pos = avio_tell(pb);
         data_size = index_pos - rm->data_pos;
diff --git a/mythtv/external/FFmpeg/libavformat/rpl.c b/mythtv/external/FFmpeg/libavformat/rpl.c
index a794d3b4853..d3736004786 100644
--- a/mythtv/external/FFmpeg/libavformat/rpl.c
+++ b/mythtv/external/FFmpeg/libavformat/rpl.c
@@ -170,8 +170,8 @@ static int rpl_read_header(AVFormatContext *s)
             vst->codecpar->codec_id = AV_CODEC_ID_ESCAPE130;
             break;
         default:
-            avpriv_report_missing_feature(s, "Video format %i",
-                                          vst->codecpar->codec_tag);
+            avpriv_report_missing_feature(s, "Video format %s",
+                                          av_fourcc2str(vst->codecpar->codec_tag));
             vst->codecpar->codec_id = AV_CODEC_ID_NONE;
     }
 
@@ -233,8 +233,8 @@ static int rpl_read_header(AVFormatContext *s)
     rpl->frames_per_chunk = read_line_and_int(pb, &error);  // video frames per chunk
     if (rpl->frames_per_chunk > 1 && vst->codecpar->codec_tag != 124)
         av_log(s, AV_LOG_WARNING,
-               "Don't know how to split frames for video format %i. "
-               "Video stream will be broken!\n", vst->codecpar->codec_tag);
+               "Don't know how to split frames for video format %s. "
+               "Video stream will be broken!\n", av_fourcc2str(vst->codecpar->codec_tag));
 
     number_of_chunks = read_line_and_int(pb, &error);  // number of chunks in the file
     // The number in the header is actually the index of the last chunk.
diff --git a/mythtv/external/FFmpeg/libavformat/rsd.c b/mythtv/external/FFmpeg/libavformat/rsd.c
index 5a56e72bb3c..1c99f8c21ca 100644
--- a/mythtv/external/FFmpeg/libavformat/rsd.c
+++ b/mythtv/external/FFmpeg/libavformat/rsd.c
@@ -70,9 +70,7 @@ static int rsd_read_header(AVFormatContext *s)
     par->codec_tag  = avio_rl32(pb);
     par->codec_id   = ff_codec_get_id(rsd_tags, par->codec_tag);
     if (!par->codec_id) {
-        char tag_buf[32];
-
-        av_get_codec_tag_string(tag_buf, sizeof(tag_buf), par->codec_tag);
+        const char *tag_buf = av_fourcc2str(par->codec_tag);
         for (i=0; i < FF_ARRAY_ELEMS(rsd_unsupported_tags); i++) {
             if (par->codec_tag == rsd_unsupported_tags[i]) {
                 avpriv_request_sample(s, "Codec tag: %s", tag_buf);
@@ -106,12 +104,12 @@ static int rsd_read_header(AVFormatContext *s)
         break;
     case AV_CODEC_ID_ADPCM_PSX:
         par->block_align = 16 * par->channels;
-        if (pb->seekable)
+        if (pb->seekable & AVIO_SEEKABLE_NORMAL)
             st->duration = av_get_audio_frame_duration2(par, avio_size(pb) - start);
         break;
     case AV_CODEC_ID_ADPCM_IMA_RAD:
         par->block_align = 20 * par->channels;
-        if (pb->seekable)
+        if (pb->seekable & AVIO_SEEKABLE_NORMAL)
             st->duration = av_get_audio_frame_duration2(par, avio_size(pb) - start);
         break;
     case AV_CODEC_ID_ADPCM_IMA_WAV:
@@ -120,7 +118,7 @@ static int rsd_read_header(AVFormatContext *s)
 
         par->bits_per_coded_sample = 4;
         par->block_align = 36 * par->channels;
-        if (pb->seekable)
+        if (pb->seekable & AVIO_SEEKABLE_NORMAL)
             st->duration = av_get_audio_frame_duration2(par, avio_size(pb) - start);
         break;
     case AV_CODEC_ID_ADPCM_THP_LE:
@@ -131,7 +129,7 @@ static int rsd_read_header(AVFormatContext *s)
 
         if ((ret = ff_get_extradata(s, par, s->pb, 32)) < 0)
             return ret;
-        if (pb->seekable)
+        if (pb->seekable & AVIO_SEEKABLE_NORMAL)
             st->duration = av_get_audio_frame_duration2(par, avio_size(pb) - start);
         break;
     case AV_CODEC_ID_ADPCM_THP:
@@ -145,7 +143,7 @@ static int rsd_read_header(AVFormatContext *s)
             avio_read(s->pb, st->codecpar->extradata + 32 * i, 32);
             avio_skip(s->pb, 8);
         }
-        if (pb->seekable)
+        if (pb->seekable & AVIO_SEEKABLE_NORMAL)
             st->duration = (avio_size(pb) - start) / (8 * par->channels) * 14;
         break;
     case AV_CODEC_ID_PCM_S16LE:
@@ -153,7 +151,7 @@ static int rsd_read_header(AVFormatContext *s)
         if (version != 4)
             start = avio_rl32(pb);
 
-        if (pb->seekable)
+        if (pb->seekable & AVIO_SEEKABLE_NORMAL)
             st->duration = (avio_size(pb) - start) / 2 / par->channels;
         break;
     }
diff --git a/mythtv/external/FFmpeg/libavformat/rsoenc.c b/mythtv/external/FFmpeg/libavformat/rsoenc.c
index 3c5c1180f5b..e34e2c64e20 100644
--- a/mythtv/external/FFmpeg/libavformat/rsoenc.c
+++ b/mythtv/external/FFmpeg/libavformat/rsoenc.c
@@ -38,7 +38,7 @@ static int rso_write_header(AVFormatContext *s)
         return AVERROR_INVALIDDATA;
     }
 
-    if (!s->pb->seekable) {
+    if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
         av_log(s, AV_LOG_ERROR, "muxer does not support non seekable output\n");
         return AVERROR_INVALIDDATA;
     }
@@ -50,7 +50,7 @@ static int rso_write_header(AVFormatContext *s)
     }
 
     if (par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
-        av_log(s, AV_LOG_ERROR, "ADPCM in RSO not implemented\n");
+        avpriv_report_missing_feature(s, "ADPCM in RSO");
         return AVERROR_PATCHWELCOME;
     }
 
diff --git a/mythtv/external/FFmpeg/libavformat/rtmpdh.c b/mythtv/external/FFmpeg/libavformat/rtmpdh.c
index 1876fd44f9e..8eb088237b7 100644
--- a/mythtv/external/FFmpeg/libavformat/rtmpdh.c
+++ b/mythtv/external/FFmpeg/libavformat/rtmpdh.c
@@ -54,7 +54,6 @@
     "F71C35FDAD44CFD2D74F9208BE258FF324943328F67329C0" \
     "FFFFFFFFFFFFFFFF"
 
-#if CONFIG_GMP || CONFIG_GCRYPT
 #if CONFIG_GMP
 #define bn_new(bn)                      \
     do {                                \
@@ -93,7 +92,6 @@
         else                                        \
             ret = 1;                                \
     } while (0)
-#define bn_modexp(bn, y, q, p)      mpz_powm(bn, y, q, p)
 #define bn_random(bn, num_bits)                       \
     do {                                              \
         int bits = num_bits;                          \
@@ -104,6 +102,11 @@
         }                                             \
         mpz_fdiv_r_2exp(bn, bn, num_bits);            \
     } while (0)
+static int bn_modexp(FFBigNum bn, FFBigNum y, FFBigNum q, FFBigNum p)
+{
+    mpz_powm(bn, y, q, p);
+    return 0;
+}
 #elif CONFIG_GCRYPT
 #define bn_new(bn)                                              \
     do {                                                        \
@@ -125,13 +128,42 @@
 #define bn_bn2bin(bn, buf, len)     gcry_mpi_print(GCRYMPI_FMT_USG, buf, len, NULL, bn)
 #define bn_bin2bn(bn, buf, len)     gcry_mpi_scan(&bn, GCRYMPI_FMT_USG, buf, len, NULL)
 #define bn_hex2bn(bn, buf, ret)     ret = (gcry_mpi_scan(&bn, GCRYMPI_FMT_HEX, buf, 0, 0) == 0)
-#define bn_modexp(bn, y, q, p)      gcry_mpi_powm(bn, y, q, p)
 #define bn_random(bn, num_bits)     gcry_mpi_randomize(bn, num_bits, GCRY_WEAK_RANDOM)
+static int bn_modexp(FFBigNum bn, FFBigNum y, FFBigNum q, FFBigNum p)
+{
+    gcry_mpi_powm(bn, y, q, p);
+    return 0;
+}
+#elif CONFIG_OPENSSL
+#define bn_new(bn)                  bn = BN_new()
+#define bn_free(bn)                 BN_free(bn)
+#define bn_set_word(bn, w)          BN_set_word(bn, w)
+#define bn_cmp(a, b)                BN_cmp(a, b)
+#define bn_copy(to, from)           BN_copy(to, from)
+#define bn_sub_word(bn, w)          BN_sub_word(bn, w)
+#define bn_cmp_1(bn)                BN_cmp(bn, BN_value_one())
+#define bn_num_bytes(bn)            BN_num_bytes(bn)
+#define bn_bn2bin(bn, buf, len)     BN_bn2bin(bn, buf)
+#define bn_bin2bn(bn, buf, len)     bn = BN_bin2bn(buf, len, 0)
+#define bn_hex2bn(bn, buf, ret)     ret = BN_hex2bn(&bn, buf)
+#define bn_random(bn, num_bits)     BN_rand(bn, num_bits, 0, 0)
+static int bn_modexp(FFBigNum bn, FFBigNum y, FFBigNum q, FFBigNum p)
+{
+    BN_CTX *ctx = BN_CTX_new();
+    if (!ctx)
+        return AVERROR(ENOMEM);
+    if (!BN_mod_exp(bn, y, q, p, ctx)) {
+        BN_CTX_free(ctx);
+        return AVERROR(EINVAL);
+    }
+    BN_CTX_free(ctx);
+    return 0;
+}
 #endif
 
 #define MAX_BYTES 18000
 
-#define dh_new()                    av_malloc(sizeof(FF_DH))
+#define dh_new()                    av_mallocz(sizeof(FF_DH))
 
 static FFBigNum dh_generate_key(FF_DH *dh)
 {
@@ -152,7 +184,8 @@ static FFBigNum dh_generate_key(FF_DH *dh)
         return NULL;
     }
 
-    bn_modexp(dh->pub_key, dh->g, dh->priv_key, dh->p);
+    if (bn_modexp(dh->pub_key, dh->g, dh->priv_key, dh->p) < 0)
+        return NULL;
 
     return dh->pub_key;
 }
@@ -161,12 +194,16 @@ static int dh_compute_key(FF_DH *dh, FFBigNum pub_key_bn,
                           uint32_t secret_key_len, uint8_t *secret_key)
 {
     FFBigNum k;
+    int ret;
 
     bn_new(k);
     if (!k)
         return -1;
 
-    bn_modexp(k, pub_key_bn, dh->priv_key, dh->p);
+    if ((ret = bn_modexp(k, pub_key_bn, dh->priv_key, dh->p)) < 0) {
+        bn_free(k);
+        return ret;
+    }
     bn_bn2bin(k, secret_key, secret_key_len);
     bn_free(k);
 
@@ -184,48 +221,6 @@ void ff_dh_free(FF_DH *dh)
     bn_free(dh->priv_key);
     av_free(dh);
 }
-#elif CONFIG_OPENSSL
-#define bn_new(bn)                  bn = BN_new()
-#define bn_free(bn)                 BN_free(bn)
-#define bn_set_word(bn, w)          BN_set_word(bn, w)
-#define bn_cmp(a, b)                BN_cmp(a, b)
-#define bn_copy(to, from)           BN_copy(to, from)
-#define bn_sub_word(bn, w)          BN_sub_word(bn, w)
-#define bn_cmp_1(bn)                BN_cmp(bn, BN_value_one())
-#define bn_num_bytes(bn)            BN_num_bytes(bn)
-#define bn_bn2bin(bn, buf, len)     BN_bn2bin(bn, buf)
-#define bn_bin2bn(bn, buf, len)     bn = BN_bin2bn(buf, len, 0)
-#define bn_hex2bn(bn, buf, ret)     ret = BN_hex2bn(&bn, buf)
-#define bn_modexp(bn, y, q, p)               \
-    do {                                     \
-        BN_CTX *ctx = BN_CTX_new();          \
-        if (!ctx)                            \
-            return AVERROR(ENOMEM);          \
-        if (!BN_mod_exp(bn, y, q, p, ctx)) { \
-            BN_CTX_free(ctx);                \
-            return AVERROR(EINVAL);          \
-        }                                    \
-        BN_CTX_free(ctx);                    \
-    } while (0)
-
-#define dh_new()                                DH_new()
-#define dh_generate_key(dh)                     DH_generate_key(dh)
-
-static int dh_compute_key(FF_DH *dh, FFBigNum pub_key_bn,
-                          uint32_t secret_key_len, uint8_t *secret_key)
-{
-    if (secret_key_len < DH_size(dh))
-        return AVERROR(EINVAL);
-    return DH_compute_key(secret_key, pub_key_bn, dh);
-}
-
-void ff_dh_free(FF_DH *dh)
-{
-    if (!dh)
-        return;
-    DH_free(dh);
-}
-#endif
 
 static int dh_is_valid_public_key(FFBigNum y, FFBigNum p, FFBigNum q)
 {
@@ -254,8 +249,10 @@ static int dh_is_valid_public_key(FFBigNum y, FFBigNum p, FFBigNum q)
      * random data.
      */
     /* y must fulfill y^q mod p = 1 */
-    bn_modexp(bn, y, q, p);
+    if ((ret = bn_modexp(bn, y, q, p)) < 0)
+        goto fail;
 
+    ret = AVERROR(EINVAL);
     if (bn_cmp_1(bn))
         goto fail;
 
diff --git a/mythtv/external/FFmpeg/libavformat/rtmpdh.h b/mythtv/external/FFmpeg/libavformat/rtmpdh.h
index 2b250f595d3..188aad7a45c 100644
--- a/mythtv/external/FFmpeg/libavformat/rtmpdh.h
+++ b/mythtv/external/FFmpeg/libavformat/rtmpdh.h
@@ -26,7 +26,6 @@
 
 #include "config.h"
 
-#if CONFIG_GMP || CONFIG_GCRYPT
 #if CONFIG_GMP
 #include <gmp.h>
 
@@ -35,6 +34,12 @@ typedef mpz_ptr FFBigNum;
 #include <gcrypt.h>
 
 typedef gcry_mpi_t FFBigNum;
+
+#elif CONFIG_OPENSSL
+#include <openssl/bn.h>
+#include <openssl/dh.h>
+
+typedef BIGNUM *FFBigNum;
 #endif
 
 typedef struct FF_DH {
@@ -45,13 +50,6 @@ typedef struct FF_DH {
     long length;
 } FF_DH;
 
-#elif CONFIG_OPENSSL
-#include <openssl/bn.h>
-#include <openssl/dh.h>
-
-typedef BIGNUM *FFBigNum;
-typedef DH FF_DH;
-#endif
 
 /**
  * Initialize a Diffie-Hellmann context.
diff --git a/mythtv/external/FFmpeg/libavformat/rtmphttp.c b/mythtv/external/FFmpeg/libavformat/rtmphttp.c
index e5ce10ca4f0..ef6146ca864 100644
--- a/mythtv/external/FFmpeg/libavformat/rtmphttp.c
+++ b/mythtv/external/FFmpeg/libavformat/rtmphttp.c
@@ -208,7 +208,7 @@ static int rtmp_http_open(URLContext *h, const char *uri, int flags)
     }
 
     /* alloc the http context */
-    if ((ret = ffurl_alloc(&rt->stream, url, AVIO_FLAG_READ_WRITE, NULL)) < 0)
+    if ((ret = ffurl_alloc(&rt->stream, url, AVIO_FLAG_READ_WRITE, &h->interrupt_callback)) < 0)
         goto fail;
 
     /* set options */
diff --git a/mythtv/external/FFmpeg/libavformat/rtmppkt.c b/mythtv/external/FFmpeg/libavformat/rtmppkt.c
index 0d693c27f7f..1eeae17337b 100644
--- a/mythtv/external/FFmpeg/libavformat/rtmppkt.c
+++ b/mythtv/external/FFmpeg/libavformat/rtmppkt.c
@@ -235,6 +235,14 @@ static int rtmp_packet_read_one_chunk(URLContext *h, RTMPPacket *p,
     if (hdr != RTMP_PS_TWELVEBYTES)
         timestamp += prev_pkt[channel_id].timestamp;
 
+    if (prev_pkt[channel_id].read && size != prev_pkt[channel_id].size) {
+        av_log(h, AV_LOG_ERROR, "RTMP packet size mismatch %d != %d\n",
+                                size, prev_pkt[channel_id].size);
+        ff_rtmp_packet_destroy(&prev_pkt[channel_id]);
+        prev_pkt[channel_id].read = 0;
+        return AVERROR_INVALIDDATA;
+    }
+
     if (!prev_pkt[channel_id].read) {
         if ((ret = ff_rtmp_packet_create(p, channel_id, type, timestamp,
                                          size)) < 0)
@@ -425,105 +433,150 @@ void ff_rtmp_packet_destroy(RTMPPacket *pkt)
     pkt->size = 0;
 }
 
-int ff_amf_tag_size(const uint8_t *data, const uint8_t *data_end)
+static int amf_tag_skip(GetByteContext *gb)
 {
-    const uint8_t *base = data;
     AMFDataType type;
     unsigned nb   = -1;
     int parse_key = 1;
 
-    if (data >= data_end)
+    if (bytestream2_get_bytes_left(gb) < 1)
         return -1;
-    switch ((type = *data++)) {
-    case AMF_DATA_TYPE_NUMBER:      return 9;
-    case AMF_DATA_TYPE_BOOL:        return 2;
-    case AMF_DATA_TYPE_STRING:      return 3 + AV_RB16(data);
-    case AMF_DATA_TYPE_LONG_STRING: return 5 + AV_RB32(data);
-    case AMF_DATA_TYPE_NULL:        return 1;
-    case AMF_DATA_TYPE_DATE:        return 11;
+
+    type = bytestream2_get_byte(gb);
+    switch (type) {
+    case AMF_DATA_TYPE_NUMBER:
+        bytestream2_get_be64(gb);
+        return 0;
+    case AMF_DATA_TYPE_BOOL:
+        bytestream2_get_byte(gb);
+        return 0;
+    case AMF_DATA_TYPE_STRING:
+        bytestream2_skip(gb, bytestream2_get_be16(gb));
+        return 0;
+    case AMF_DATA_TYPE_LONG_STRING:
+        bytestream2_skip(gb, bytestream2_get_be32(gb));
+        return 0;
+    case AMF_DATA_TYPE_NULL:
+        return 0;
+    case AMF_DATA_TYPE_DATE:
+        bytestream2_skip(gb, 10);
+        return 0;
     case AMF_DATA_TYPE_ARRAY:
         parse_key = 0;
     case AMF_DATA_TYPE_MIXEDARRAY:
-        nb = bytestream_get_be32(&data);
+        nb = bytestream2_get_be32(gb);
     case AMF_DATA_TYPE_OBJECT:
         while (nb-- > 0 || type != AMF_DATA_TYPE_ARRAY) {
             int t;
             if (parse_key) {
-                int size = bytestream_get_be16(&data);
+                int size = bytestream2_get_be16(gb);
                 if (!size) {
-                    data++;
+                    bytestream2_get_byte(gb);
                     break;
                 }
-                if (size < 0 || size >= data_end - data)
+                if (size < 0 || size >= bytestream2_get_bytes_left(gb))
                     return -1;
-                data += size;
+                bytestream2_skip(gb, size);
             }
-            t = ff_amf_tag_size(data, data_end);
-            if (t < 0 || t >= data_end - data)
+            t = amf_tag_skip(gb);
+            if (t < 0 || bytestream2_get_bytes_left(gb) <= 0)
                 return -1;
-            data += t;
         }
-        return data - base;
-    case AMF_DATA_TYPE_OBJECT_END:  return 1;
+        return 0;
+    case AMF_DATA_TYPE_OBJECT_END:  return 0;
     default:                        return -1;
     }
 }
 
-int ff_amf_get_field_value(const uint8_t *data, const uint8_t *data_end,
+int ff_amf_tag_size(const uint8_t *data, const uint8_t *data_end)
+{
+    GetByteContext gb;
+    int ret;
+
+    if (data >= data_end)
+        return -1;
+
+    bytestream2_init(&gb, data, data_end - data);
+
+    ret = amf_tag_skip(&gb);
+    if (ret < 0 || bytestream2_get_bytes_left(&gb) <= 0)
+        return -1;
+    av_assert0(bytestream2_tell(&gb) >= 0 && bytestream2_tell(&gb) <= data_end - data);
+    return bytestream2_tell(&gb);
+}
+
+static int amf_get_field_value2(GetByteContext *gb,
                            const uint8_t *name, uint8_t *dst, int dst_size)
 {
     int namelen = strlen(name);
     int len;
 
-    while (*data != AMF_DATA_TYPE_OBJECT && data < data_end) {
-        len = ff_amf_tag_size(data, data_end);
-        if (len < 0)
-            len = data_end - data;
-        data += len;
+    while (bytestream2_peek_byte(gb) != AMF_DATA_TYPE_OBJECT && bytestream2_get_bytes_left(gb) > 0) {
+        int ret = amf_tag_skip(gb);
+        if (ret < 0)
+            return -1;
     }
-    if (data_end - data < 3)
+    if (bytestream2_get_bytes_left(gb) < 3)
         return -1;
-    data++;
+    bytestream2_get_byte(gb);
+
     for (;;) {
-        int size = bytestream_get_be16(&data);
+        int size = bytestream2_get_be16(gb);
         if (!size)
             break;
-        if (size < 0 || size >= data_end - data)
+        if (size < 0 || size >= bytestream2_get_bytes_left(gb))
             return -1;
-        data += size;
-        if (size == namelen && !memcmp(data-size, name, namelen)) {
-            switch (*data++) {
+        bytestream2_skip(gb, size);
+        if (size == namelen && !memcmp(gb->buffer-size, name, namelen)) {
+            switch (bytestream2_get_byte(gb)) {
             case AMF_DATA_TYPE_NUMBER:
-                snprintf(dst, dst_size, "%g", av_int2double(AV_RB64(data)));
+                snprintf(dst, dst_size, "%g", av_int2double(bytestream2_get_be64(gb)));
                 break;
             case AMF_DATA_TYPE_BOOL:
-                snprintf(dst, dst_size, "%s", *data ? "true" : "false");
+                snprintf(dst, dst_size, "%s", bytestream2_get_byte(gb) ? "true" : "false");
                 break;
             case AMF_DATA_TYPE_STRING:
-                len = bytestream_get_be16(&data);
-                av_strlcpy(dst, data, FFMIN(len+1, dst_size));
+                len = bytestream2_get_be16(gb);
+                if (dst_size < 1)
+                    return -1;
+                if (dst_size < len + 1)
+                    len = dst_size - 1;
+                bytestream2_get_buffer(gb, dst, len);
+                dst[len] = 0;
                 break;
             default:
                 return -1;
             }
             return 0;
         }
-        len = ff_amf_tag_size(data, data_end);
-        if (len < 0 || len >= data_end - data)
+        len = amf_tag_skip(gb);
+        if (len < 0 || bytestream2_get_bytes_left(gb) <= 0)
             return -1;
-        data += len;
     }
     return -1;
 }
 
+int ff_amf_get_field_value(const uint8_t *data, const uint8_t *data_end,
+                           const uint8_t *name, uint8_t *dst, int dst_size)
+{
+    GetByteContext gb;
+
+    if (data >= data_end)
+        return -1;
+
+    bytestream2_init(&gb, data, data_end - data);
+
+    return amf_get_field_value2(&gb, name, dst, dst_size);
+}
+
 static const char* rtmp_packet_type(int type)
 {
     switch (type) {
     case RTMP_PT_CHUNK_SIZE:     return "chunk size";
     case RTMP_PT_BYTES_READ:     return "bytes read";
-    case RTMP_PT_PING:           return "ping";
-    case RTMP_PT_SERVER_BW:      return "server bandwidth";
-    case RTMP_PT_CLIENT_BW:      return "client bandwidth";
+    case RTMP_PT_USER_CONTROL:   return "user control";
+    case RTMP_PT_WINDOW_ACK_SIZE: return "window acknowledgement size";
+    case RTMP_PT_SET_PEER_BW:    return "set peer bandwidth";
     case RTMP_PT_AUDIO:          return "audio packet";
     case RTMP_PT_VIDEO:          return "video packet";
     case RTMP_PT_FLEX_STREAM:    return "Flex shared stream";
@@ -621,10 +674,10 @@ void ff_rtmp_packet_dump(void *ctx, RTMPPacket *p)
                 break;
             src += sz;
         }
-    } else if (p->type == RTMP_PT_SERVER_BW){
-        av_log(ctx, AV_LOG_DEBUG, "Server BW = %d\n", AV_RB32(p->data));
-    } else if (p->type == RTMP_PT_CLIENT_BW){
-        av_log(ctx, AV_LOG_DEBUG, "Client BW = %d\n", AV_RB32(p->data));
+    } else if (p->type == RTMP_PT_WINDOW_ACK_SIZE) {
+        av_log(ctx, AV_LOG_DEBUG, "Window acknowledgement size = %d\n", AV_RB32(p->data));
+    } else if (p->type == RTMP_PT_SET_PEER_BW) {
+        av_log(ctx, AV_LOG_DEBUG, "Set Peer BW = %d\n", AV_RB32(p->data));
     } else if (p->type != RTMP_PT_AUDIO && p->type != RTMP_PT_VIDEO && p->type != RTMP_PT_METADATA) {
         int i;
         for (i = 0; i < p->size; i++)
diff --git a/mythtv/external/FFmpeg/libavformat/rtmppkt.h b/mythtv/external/FFmpeg/libavformat/rtmppkt.h
index a082b45f981..eb68f1d3e15 100644
--- a/mythtv/external/FFmpeg/libavformat/rtmppkt.h
+++ b/mythtv/external/FFmpeg/libavformat/rtmppkt.h
@@ -47,9 +47,9 @@ enum RTMPChannel {
 typedef enum RTMPPacketType {
     RTMP_PT_CHUNK_SIZE   =  1,  ///< chunk size change
     RTMP_PT_BYTES_READ   =  3,  ///< number of bytes read
-    RTMP_PT_PING,               ///< ping
-    RTMP_PT_SERVER_BW,          ///< server bandwidth
-    RTMP_PT_CLIENT_BW,          ///< client bandwidth
+    RTMP_PT_USER_CONTROL,       ///< user control
+    RTMP_PT_WINDOW_ACK_SIZE,    ///< window acknowledgement size
+    RTMP_PT_SET_PEER_BW,        ///< peer bandwidth
     RTMP_PT_AUDIO        =  8,  ///< audio packet
     RTMP_PT_VIDEO,              ///< video packet
     RTMP_PT_FLEX_STREAM  = 15,  ///< Flex shared stream
diff --git a/mythtv/external/FFmpeg/libavformat/rtmpproto.c b/mythtv/external/FFmpeg/libavformat/rtmpproto.c
index b118b4e16c5..7320b4f022a 100644
--- a/mythtv/external/FFmpeg/libavformat/rtmpproto.c
+++ b/mythtv/external/FFmpeg/libavformat/rtmpproto.c
@@ -93,9 +93,9 @@ typedef struct RTMPContext {
     int           flv_off;                    ///< number of bytes read from current buffer
     int           flv_nb_packets;             ///< number of flv packets published
     RTMPPacket    out_pkt;                    ///< rtmp packet, created from flv a/v or metadata (for output)
-    uint32_t      client_report_size;         ///< number of bytes after which client should report to server
-    uint32_t      bytes_read;                 ///< number of bytes read from server
-    uint32_t      last_bytes_read;            ///< number of bytes read last reported to server
+    uint32_t      receive_report_size;        ///< number of bytes after which we should report the number of received bytes to the peer
+    uint64_t      bytes_read;                 ///< number of bytes read from server
+    uint64_t      last_bytes_read;            ///< number of bytes read last reported to server
     uint32_t      last_timestamp;             ///< last timestamp received in a packet
     int           skip_bytes;                 ///< number of bytes to skip from the input FLV stream in the next write call
     int           has_audio;                  ///< presence of audio data
@@ -114,7 +114,7 @@ typedef struct RTMPContext {
     char          swfverification[42];        ///< hash of the SWF verification
     char*         pageurl;                    ///< url of the web page
     char*         subscribe;                  ///< name of live stream to subscribe
-    int           server_bw;                  ///< server bandwidth
+    int           max_sent_unacked;           ///< max unacked sent bytes
     int           client_buffer_time;         ///< client buffer time in ms
     int           flush_interval;             ///< number of packets flushed in the same request (RTMPT only)
     int           encrypted;                  ///< use an encrypted connection (RTMPE only)
@@ -156,8 +156,8 @@ static const uint8_t rtmp_server_key[] = {
 };
 
 static int handle_chunk_size(URLContext *s, RTMPPacket *pkt);
-static int handle_server_bw(URLContext *s, RTMPPacket *pkt);
-static int handle_client_bw(URLContext *s, RTMPPacket *pkt);
+static int handle_window_ack_size(URLContext *s, RTMPPacket *pkt);
+static int handle_set_peer_bw(URLContext *s, RTMPPacket *pkt);
 
 static int add_tracked_method(RTMPContext *rt, const char *name, int id)
 {
@@ -341,9 +341,12 @@ static int gen_connect(URLContext *s, RTMPContext *rt)
     ff_amf_write_field_name(&p, "flashVer");
     ff_amf_write_string(&p, rt->flashver);
 
-    if (rt->swfurl) {
+    if (rt->swfurl || rt->swfverify) {
         ff_amf_write_field_name(&p, "swfUrl");
-        ff_amf_write_string(&p, rt->swfurl);
+        if (rt->swfurl)
+            ff_amf_write_string(&p, rt->swfurl);
+        else
+            ff_amf_write_string(&p, rt->swfverify);
     }
 
     ff_amf_write_field_name(&p, "tcUrl");
@@ -435,13 +438,13 @@ static int read_connect(URLContext *s, RTMPContext *rt)
             return AVERROR_UNKNOWN;
         } else if (pkt.type == RTMP_PT_BYTES_READ) {
             av_log(s, AV_LOG_TRACE, "received acknowledgement\n");
-        } else if (pkt.type == RTMP_PT_SERVER_BW) {
-            if ((ret = handle_server_bw(s, &pkt)) < 0) {
+        } else if (pkt.type == RTMP_PT_WINDOW_ACK_SIZE) {
+            if ((ret = handle_window_ack_size(s, &pkt)) < 0) {
                 ff_rtmp_packet_destroy(&pkt);
                 return ret;
             }
-        } else if (pkt.type == RTMP_PT_CLIENT_BW) {
-            if ((ret = handle_client_bw(s, &pkt)) < 0) {
+        } else if (pkt.type == RTMP_PT_SET_PEER_BW) {
+            if ((ret = handle_set_peer_bw(s, &pkt)) < 0) {
                 ff_rtmp_packet_destroy(&pkt);
                 return ret;
             }
@@ -482,22 +485,26 @@ static int read_connect(URLContext *s, RTMPContext *rt)
 
     // Send Window Acknowledgement Size (as defined in specification)
     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
-                                     RTMP_PT_SERVER_BW, 0, 4)) < 0)
+                                     RTMP_PT_WINDOW_ACK_SIZE, 0, 4)) < 0)
         return ret;
     p = pkt.data;
-    bytestream_put_be32(&p, rt->server_bw);
+    // Inform the peer about how often we want acknowledgements about what
+    // we send. (We don't check for the acknowledgements currently.)
+    bytestream_put_be32(&p, rt->max_sent_unacked);
     pkt.size = p - pkt.data;
     ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
                                &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
     if (ret < 0)
         return ret;
-    // Send Peer Bandwidth
+    // Set Peer Bandwidth
     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
-                                     RTMP_PT_CLIENT_BW, 0, 5)) < 0)
+                                     RTMP_PT_SET_PEER_BW, 0, 5)) < 0)
         return ret;
     p = pkt.data;
-    bytestream_put_be32(&p, rt->server_bw);
+    // Tell the peer to only send this many bytes unless it gets acknowledgements.
+    // This could be any arbitrary value we want here.
+    bytestream_put_be32(&p, rt->max_sent_unacked);
     bytestream_put_byte(&p, 2); // dynamic
     pkt.size = p - pkt.data;
     ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
@@ -506,14 +513,14 @@ static int read_connect(URLContext *s, RTMPContext *rt)
     if (ret < 0)
         return ret;
 
-    // Ping request
+    // User control
     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
-                                     RTMP_PT_PING, 0, 6)) < 0)
+                                     RTMP_PT_USER_CONTROL, 0, 6)) < 0)
         return ret;
 
     p = pkt.data;
     bytestream_put_be16(&p, 0); // 0 -> Stream Begin
-    bytestream_put_be32(&p, 0);
+    bytestream_put_be32(&p, 0); // Stream 0
     ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
                                &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
@@ -521,7 +528,7 @@ static int read_connect(URLContext *s, RTMPContext *rt)
         return ret;
 
     // Chunk size
-    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL,
+    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
                                      RTMP_PT_CHUNK_SIZE, 0, 4)) < 0)
         return ret;
 
@@ -739,12 +746,12 @@ static int gen_buffer_time(URLContext *s, RTMPContext *rt)
     uint8_t *p;
     int ret;
 
-    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
+    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_USER_CONTROL,
                                      1, 10)) < 0)
         return ret;
 
     p = pkt.data;
-    bytestream_put_be16(&p, 3);
+    bytestream_put_be16(&p, 3); // SetBuffer Length
     bytestream_put_be32(&p, rt->stream_id);
     bytestream_put_be32(&p, rt->client_buffer_time);
 
@@ -871,12 +878,12 @@ static int gen_pong(URLContext *s, RTMPContext *rt, RTMPPacket *ppkt)
         return AVERROR_INVALIDDATA;
     }
 
-    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
+    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,RTMP_PT_USER_CONTROL,
                                      ppkt->timestamp + 1, 6)) < 0)
         return ret;
 
     p = pkt.data;
-    bytestream_put_be16(&p, 7);
+    bytestream_put_be16(&p, 7); // PingResponse
     bytestream_put_be32(&p, AV_RB32(ppkt->data+2));
 
     return rtmp_send_packet(rt, &pkt, 0);
@@ -892,7 +899,7 @@ static int gen_swf_verification(URLContext *s, RTMPContext *rt)
     int ret;
 
     av_log(s, AV_LOG_DEBUG, "Sending SWF verification...\n");
-    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
+    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_USER_CONTROL,
                                      0, 44)) < 0)
         return ret;
 
@@ -904,20 +911,20 @@ static int gen_swf_verification(URLContext *s, RTMPContext *rt)
 }
 
 /**
- * Generate server bandwidth message and send it to the server.
+ * Generate window acknowledgement size message and send it to the server.
  */
-static int gen_server_bw(URLContext *s, RTMPContext *rt)
+static int gen_window_ack_size(URLContext *s, RTMPContext *rt)
 {
     RTMPPacket pkt;
     uint8_t *p;
     int ret;
 
-    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_SERVER_BW,
+    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_WINDOW_ACK_SIZE,
                                      0, 4)) < 0)
         return ret;
 
     p = pkt.data;
-    bytestream_put_be32(&p, rt->server_bw);
+    bytestream_put_be32(&p, rt->max_sent_unacked);
 
     return rtmp_send_packet(rt, &pkt, 0);
 }
@@ -1140,7 +1147,7 @@ static int rtmp_calc_swfhash(URLContext *s)
 {
     RTMPContext *rt = s->priv_data;
     uint8_t *in_data = NULL, *out_data = NULL, *swfdata;
-    int64_t in_size, out_size;
+    int64_t in_size;
     URLContext *stream;
     char swfhash[32];
     int swfsize;
@@ -1173,6 +1180,8 @@ static int rtmp_calc_swfhash(URLContext *s)
     }
 
     if (!memcmp(in_data, "CWS", 3)) {
+#if CONFIG_ZLIB
+        int64_t out_size;
         /* Decompress the SWF player file using Zlib. */
         if (!(out_data = av_malloc(8))) {
             ret = AVERROR(ENOMEM);
@@ -1182,18 +1191,17 @@ static int rtmp_calc_swfhash(URLContext *s)
         memcpy(out_data, in_data, 8);
         out_size = 8;
 
-#if CONFIG_ZLIB
         if ((ret = rtmp_uncompress_swfplayer(in_data + 8, in_size - 8,
                                              &out_data, &out_size)) < 0)
             goto fail;
+        swfsize = out_size;
+        swfdata = out_data;
 #else
         av_log(s, AV_LOG_ERROR,
                "Zlib is required for decompressing the SWF player file.\n");
         ret = AVERROR(EINVAL);
         goto fail;
 #endif
-        swfsize = out_size;
-        swfdata = out_data;
     } else {
         swfsize = in_size;
         swfdata = in_data;
@@ -1549,19 +1557,19 @@ static int handle_chunk_size(URLContext *s, RTMPPacket *pkt)
     return 0;
 }
 
-static int handle_ping(URLContext *s, RTMPPacket *pkt)
+static int handle_user_control(URLContext *s, RTMPPacket *pkt)
 {
     RTMPContext *rt = s->priv_data;
     int t, ret;
 
     if (pkt->size < 2) {
-        av_log(s, AV_LOG_ERROR, "Too short ping packet (%d)\n",
+        av_log(s, AV_LOG_ERROR, "Too short user control packet (%d)\n",
                pkt->size);
         return AVERROR_INVALIDDATA;
     }
 
     t = AV_RB16(pkt->data);
-    if (t == 6) {
+    if (t == 6) { // PingRequest
         if ((ret = gen_pong(s, rt, pkt)) < 0)
             return ret;
     } else if (t == 26) {
@@ -1576,48 +1584,55 @@ static int handle_ping(URLContext *s, RTMPPacket *pkt)
     return 0;
 }
 
-static int handle_client_bw(URLContext *s, RTMPPacket *pkt)
+static int handle_set_peer_bw(URLContext *s, RTMPPacket *pkt)
 {
     RTMPContext *rt = s->priv_data;
 
     if (pkt->size < 4) {
         av_log(s, AV_LOG_ERROR,
-               "Client bandwidth report packet is less than 4 bytes long (%d)\n",
+               "Peer bandwidth packet is less than 4 bytes long (%d)\n",
                pkt->size);
         return AVERROR_INVALIDDATA;
     }
 
-    rt->client_report_size = AV_RB32(pkt->data);
-    if (rt->client_report_size <= 0) {
-        av_log(s, AV_LOG_ERROR, "Incorrect client bandwidth %d\n",
-                rt->client_report_size);
+    // We currently don't check how much the peer has acknowledged of
+    // what we have sent. To do that properly, we should call
+    // gen_window_ack_size here, to tell the peer that we want an
+    // acknowledgement with (at least) that interval.
+    rt->max_sent_unacked = AV_RB32(pkt->data);
+    if (rt->max_sent_unacked <= 0) {
+        av_log(s, AV_LOG_ERROR, "Incorrect set peer bandwidth %d\n",
+               rt->max_sent_unacked);
         return AVERROR_INVALIDDATA;
 
     }
-    av_log(s, AV_LOG_DEBUG, "Client bandwidth = %d\n", rt->client_report_size);
-    rt->client_report_size >>= 1;
+    av_log(s, AV_LOG_DEBUG, "Max sent, unacked = %d\n", rt->max_sent_unacked);
 
     return 0;
 }
 
-static int handle_server_bw(URLContext *s, RTMPPacket *pkt)
+static int handle_window_ack_size(URLContext *s, RTMPPacket *pkt)
 {
     RTMPContext *rt = s->priv_data;
 
     if (pkt->size < 4) {
         av_log(s, AV_LOG_ERROR,
-               "Too short server bandwidth report packet (%d)\n",
+               "Too short window acknowledgement size packet (%d)\n",
                pkt->size);
         return AVERROR_INVALIDDATA;
     }
 
-    rt->server_bw = AV_RB32(pkt->data);
-    if (rt->server_bw <= 0) {
-        av_log(s, AV_LOG_ERROR, "Incorrect server bandwidth %d\n",
-               rt->server_bw);
+    rt->receive_report_size = AV_RB32(pkt->data);
+    if (rt->receive_report_size <= 0) {
+        av_log(s, AV_LOG_ERROR, "Incorrect window acknowledgement size %d\n",
+               rt->receive_report_size);
         return AVERROR_INVALIDDATA;
     }
-    av_log(s, AV_LOG_DEBUG, "Server bandwidth = %d\n", rt->server_bw);
+    av_log(s, AV_LOG_DEBUG, "Window acknowledgement size = %d\n", rt->receive_report_size);
+    // Send an Acknowledgement packet after receiving half the maximum
+    // size, to make sure the peer can keep on sending without waiting
+    // for acknowledgements.
+    rt->receive_report_size >>= 1;
 
     return 0;
 }
@@ -1859,7 +1874,7 @@ static int write_begin(URLContext *s)
 
     // Send Stream Begin 1
     if ((ret = ff_rtmp_packet_create(&spkt, RTMP_NETWORK_CHANNEL,
-                                     RTMP_PT_PING, 0, 6)) < 0) {
+                                     RTMP_PT_USER_CONTROL, 0, 6)) < 0) {
         av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
         return ret;
     }
@@ -1909,9 +1924,6 @@ static int write_status(URLContext *s, RTMPPacket *pkt,
     ff_amf_write_string(&pp, statusmsg);
     ff_amf_write_field_name(&pp, "details");
     ff_amf_write_string(&pp, filename);
-    ff_amf_write_field_name(&pp, "clientid");
-    snprintf(statusmsg, sizeof(statusmsg), "%s", LIBAVFORMAT_IDENT);
-    ff_amf_write_string(&pp, statusmsg);
     ff_amf_write_object_end(&pp);
 
     spkt.size = pp - spkt.data;
@@ -1926,7 +1938,7 @@ static int send_invoke_response(URLContext *s, RTMPPacket *pkt)
 {
     RTMPContext *rt = s->priv_data;
     double seqnum;
-    char filename[64];
+    char filename[128];
     char command[64];
     int stringlen;
     char *pchar;
@@ -1953,6 +1965,13 @@ static int send_invoke_response(URLContext *s, RTMPPacket *pkt)
         !strcmp(command, "publish")) {
         ret = ff_amf_read_string(&gbc, filename,
                                  sizeof(filename), &stringlen);
+        if (ret) {
+            if (ret == AVERROR(EINVAL))
+                av_log(s, AV_LOG_ERROR, "Unable to parse stream name - name too long?\n");
+            else
+                av_log(s, AV_LOG_ERROR, "Unable to parse stream name\n");
+            return ret;
+        }
         // check with url
         if (s->filename) {
             pchar = strrchr(s->filename, '/');
@@ -2083,7 +2102,7 @@ static int handle_invoke_result(URLContext *s, RTMPPacket *pkt)
             if ((ret = gen_fcpublish_stream(s, rt)) < 0)
                 goto fail;
         } else {
-            if ((ret = gen_server_bw(s, rt)) < 0)
+            if ((ret = gen_window_ack_size(s, rt)) < 0)
                 goto fail;
         }
 
@@ -2332,16 +2351,16 @@ static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
         if ((ret = handle_chunk_size(s, pkt)) < 0)
             return ret;
         break;
-    case RTMP_PT_PING:
-        if ((ret = handle_ping(s, pkt)) < 0)
+    case RTMP_PT_USER_CONTROL:
+        if ((ret = handle_user_control(s, pkt)) < 0)
             return ret;
         break;
-    case RTMP_PT_CLIENT_BW:
-        if ((ret = handle_client_bw(s, pkt)) < 0)
+    case RTMP_PT_SET_PEER_BW:
+        if ((ret = handle_set_peer_bw(s, pkt)) < 0)
             return ret;
         break;
-    case RTMP_PT_SERVER_BW:
-        if ((ret = handle_server_bw(s, pkt)) < 0)
+    case RTMP_PT_WINDOW_ACK_SIZE:
+        if ((ret = handle_window_ack_size(s, pkt)) < 0)
             return ret;
         break;
     case RTMP_PT_INVOKE:
@@ -2446,7 +2465,7 @@ static int get_packet(URLContext *s, int for_header)
         rt->last_timestamp = rpkt.timestamp;
 
         rt->bytes_read += ret;
-        if (rt->bytes_read - rt->last_bytes_read > rt->client_report_size) {
+        if (rt->bytes_read - rt->last_bytes_read > rt->receive_report_size) {
             av_log(s, AV_LOG_DEBUG, "Sending bytes read report\n");
             if ((ret = gen_bytes_read(s, rt, rpkt.timestamp + 1)) < 0)
                 return ret;
@@ -2499,7 +2518,7 @@ static int get_packet(URLContext *s, int for_header)
         } else if (rpkt.type == RTMP_PT_METADATA) {
             ret = handle_metadata(rt, &rpkt);
             ff_rtmp_packet_destroy(&rpkt);
-            return 0;
+            return ret;
         }
         ff_rtmp_packet_destroy(&rpkt);
     }
@@ -2604,14 +2623,13 @@ static int inject_fake_duration_metadata(RTMPContext *rt)
  *             and 'playpath' is a file name (the rest of the path,
  *             may be prefixed with "mp4:")
  */
-static int rtmp_open(URLContext *s, const char *uri, int flags)
+static int rtmp_open(URLContext *s, const char *uri, int flags, AVDictionary **opts)
 {
     RTMPContext *rt = s->priv_data;
     char proto[8], hostname[256], path[1024], auth[100], *fname;
     char *old_app, *qmark, *n, fname_buffer[1024];
     uint8_t buf[2048];
     int port;
-    AVDictionary *opts = NULL;
     int ret;
 
     if (rt->listen_timeout > 0)
@@ -2648,7 +2666,7 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
     }
     if (!strcmp(proto, "rtmpt") || !strcmp(proto, "rtmpts")) {
         if (!strcmp(proto, "rtmpts"))
-            av_dict_set(&opts, "ffrtmphttp_tls", "1", 1);
+            av_dict_set(opts, "ffrtmphttp_tls", "1", 1);
 
         /* open the http tunneling connection */
         ff_url_join(buf, sizeof(buf), "ffrtmphttp", NULL, hostname, port, NULL);
@@ -2659,7 +2677,7 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
         ff_url_join(buf, sizeof(buf), "tls", NULL, hostname, port, NULL);
     } else if (!strcmp(proto, "rtmpe") || (!strcmp(proto, "rtmpte"))) {
         if (!strcmp(proto, "rtmpte"))
-            av_dict_set(&opts, "ffrtmpcrypt_tunneling", "1", 1);
+            av_dict_set(opts, "ffrtmpcrypt_tunneling", "1", 1);
 
         /* open the encrypted connection */
         ff_url_join(buf, sizeof(buf), "ffrtmpcrypt", NULL, hostname, port, NULL);
@@ -2678,7 +2696,7 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
 
 reconnect:
     if ((ret = ffurl_open_whitelist(&rt->stream, buf, AVIO_FLAG_READ_WRITE,
-                                    &s->interrupt_callback, &opts,
+                                    &s->interrupt_callback, opts,
                                     s->protocol_whitelist, s->protocol_blacklist, s)) < 0) {
         av_log(s , AV_LOG_ERROR, "Cannot open connection %s\n", buf);
         goto fail;
@@ -2811,13 +2829,13 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
         }
     }
 
-    rt->client_report_size = 1048576;
+    rt->receive_report_size = 1048576;
     rt->bytes_read = 0;
     rt->has_audio = 0;
     rt->has_video = 0;
     rt->received_metadata = 0;
     rt->last_bytes_read = 0;
-    rt->server_bw = 2500000;
+    rt->max_sent_unacked = 2500000;
     rt->duration = 0;
 
     av_log(s, AV_LOG_DEBUG, "Proto = %s, path = %s, app = %s, fname = %s\n",
@@ -2896,7 +2914,7 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
     return 0;
 
 fail:
-    av_dict_free(&opts);
+    av_dict_free(opts);
     rtmp_close(s);
     return ret;
 }
@@ -3141,7 +3159,7 @@ static const AVClass flavor##_class = {          \
                                                  \
 const URLProtocol ff_##flavor##_protocol = {     \
     .name           = #flavor,                   \
-    .url_open       = rtmp_open,                 \
+    .url_open2      = rtmp_open,                 \
     .url_read       = rtmp_read,                 \
     .url_read_seek  = rtmp_seek,                 \
     .url_read_pause = rtmp_pause,                \
diff --git a/mythtv/external/FFmpeg/libavformat/rtpdec.c b/mythtv/external/FFmpeg/libavformat/rtpdec.c
index 51feeeaad3f..4acb1ca629d 100644
--- a/mythtv/external/FFmpeg/libavformat/rtpdec.c
+++ b/mythtv/external/FFmpeg/libavformat/rtpdec.c
@@ -33,6 +33,12 @@
 
 #define MIN_FEEDBACK_INTERVAL 200000 /* 200 ms in us */
 
+static RTPDynamicProtocolHandler l24_dynamic_handler = {
+    .enc_name   = "L24",
+    .codec_type = AVMEDIA_TYPE_AUDIO,
+    .codec_id   = AV_CODEC_ID_PCM_S24BE,
+};
+
 static RTPDynamicProtocolHandler gsm_dynamic_handler = {
     .enc_name   = "GSM",
     .codec_type = AVMEDIA_TYPE_AUDIO,
@@ -108,6 +114,7 @@ void ff_register_rtp_dynamic_payload_handlers(void)
     ff_register_dynamic_payload_handler(&ff_qt_rtp_vid_handler);
     ff_register_dynamic_payload_handler(&ff_quicktime_rtp_aud_handler);
     ff_register_dynamic_payload_handler(&ff_quicktime_rtp_vid_handler);
+    ff_register_dynamic_payload_handler(&ff_rfc4175_rtp_handler);
     ff_register_dynamic_payload_handler(&ff_svq3_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_theora_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_vc2hq_dynamic_handler);
@@ -115,6 +122,7 @@ void ff_register_rtp_dynamic_payload_handlers(void)
     ff_register_dynamic_payload_handler(&ff_vp8_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_vp9_dynamic_handler);
     ff_register_dynamic_payload_handler(&gsm_dynamic_handler);
+    ff_register_dynamic_payload_handler(&l24_dynamic_handler);
     ff_register_dynamic_payload_handler(&opus_dynamic_handler);
     ff_register_dynamic_payload_handler(&realmedia_mp3_dynamic_handler);
     ff_register_dynamic_payload_handler(&speex_dynamic_handler);
diff --git a/mythtv/external/FFmpeg/libavformat/rtpdec_formats.h b/mythtv/external/FFmpeg/libavformat/rtpdec_formats.h
index 3292a3d2658..a436c9d62c6 100644
--- a/mythtv/external/FFmpeg/libavformat/rtpdec_formats.h
+++ b/mythtv/external/FFmpeg/libavformat/rtpdec_formats.h
@@ -82,6 +82,7 @@ extern RTPDynamicProtocolHandler ff_qt_rtp_aud_handler;
 extern RTPDynamicProtocolHandler ff_qt_rtp_vid_handler;
 extern RTPDynamicProtocolHandler ff_quicktime_rtp_aud_handler;
 extern RTPDynamicProtocolHandler ff_quicktime_rtp_vid_handler;
+extern RTPDynamicProtocolHandler ff_rfc4175_rtp_handler;
 extern RTPDynamicProtocolHandler ff_svq3_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_theora_dynamic_handler;
 extern RTPDynamicProtocolHandler ff_vc2hq_dynamic_handler;
diff --git a/mythtv/external/FFmpeg/libavformat/rtpdec_h264.c b/mythtv/external/FFmpeg/libavformat/rtpdec_h264.c
index 8dd56a549e4..6f8148ab6d5 100644
--- a/mythtv/external/FFmpeg/libavformat/rtpdec_h264.c
+++ b/mythtv/external/FFmpeg/libavformat/rtpdec_h264.c
@@ -166,7 +166,7 @@ static int sdp_parse_fmtp_config_h264(AVFormatContext *s,
             parse_profile_level_id(s, h264_data, value);
     } else if (!strcmp(attr, "sprop-parameter-sets")) {
         int ret;
-        if (value[strlen(value) - 1] == ',') {
+        if (*value == 0 || value[strlen(value) - 1] == ',') {
             av_log(s, AV_LOG_WARNING, "Missing PPS in sprop-parameter-sets, ignoring\n");
             return 0;
         }
diff --git a/mythtv/external/FFmpeg/libavformat/rtpdec_jpeg.c b/mythtv/external/FFmpeg/libavformat/rtpdec_jpeg.c
index 397b5cf56c3..465d9bc2921 100644
--- a/mythtv/external/FFmpeg/libavformat/rtpdec_jpeg.c
+++ b/mythtv/external/FFmpeg/libavformat/rtpdec_jpeg.c
@@ -247,7 +247,7 @@ static int jpeg_parse_packet(AVFormatContext *ctx, PayloadContext *jpeg,
         type &= ~0x40;
     }
     if (type > 1) {
-        av_log(ctx, AV_LOG_ERROR, "Unimplemented RTP/JPEG type %d\n", type);
+        avpriv_report_missing_feature(ctx, "RTP/JPEG type %"PRIu8, type);
         return AVERROR_PATCHWELCOME;
     }
 
diff --git a/mythtv/external/FFmpeg/libavformat/rtpdec_latm.c b/mythtv/external/FFmpeg/libavformat/rtpdec_latm.c
index e51f0cdae8f..a25c07fe52f 100644
--- a/mythtv/external/FFmpeg/libavformat/rtpdec_latm.c
+++ b/mythtv/external/FFmpeg/libavformat/rtpdec_latm.c
@@ -109,9 +109,9 @@ static int parse_fmtp_config(AVStream *st, const char *value)
     num_layers        = get_bits(&gb, 3);
     if (audio_mux_version != 0 || same_time_framing != 1 || num_programs != 0 ||
         num_layers != 0) {
-        av_log(NULL, AV_LOG_WARNING, "Unsupported LATM config (%d,%d,%d,%d)\n",
-                                     audio_mux_version, same_time_framing,
-                                     num_programs, num_layers);
+        avpriv_report_missing_feature(NULL, "LATM config (%d,%d,%d,%d)",
+                                      audio_mux_version, same_time_framing,
+                                      num_programs, num_layers);
         ret = AVERROR_PATCHWELCOME;
         goto end;
     }
diff --git a/mythtv/external/FFmpeg/libavformat/rtpdec_mpeg4.c b/mythtv/external/FFmpeg/libavformat/rtpdec_mpeg4.c
index 304699ea41a..994ab492517 100644
--- a/mythtv/external/FFmpeg/libavformat/rtpdec_mpeg4.c
+++ b/mythtv/external/FFmpeg/libavformat/rtpdec_mpeg4.c
@@ -97,7 +97,7 @@ static void close_context(PayloadContext *data)
     av_freep(&data->mode);
 }
 
-static int parse_fmtp_config(AVCodecParameters *par, char *value)
+static int parse_fmtp_config(AVCodecParameters *par, const char *value)
 {
     /* decode the hexa encoded parameter */
     int len = ff_hex_to_data(NULL, value);
@@ -289,11 +289,22 @@ static int parse_fmtp(AVFormatContext *s,
         for (i = 0; attr_names[i].str; ++i) {
             if (!av_strcasecmp(attr, attr_names[i].str)) {
                 if (attr_names[i].type == ATTR_NAME_TYPE_INT) {
+                    int val = atoi(value);
+                    if (val > 32) {
+                        av_log(s, AV_LOG_ERROR,
+                               "The %s field size is invalid (%d)\n",
+                               attr, val);
+                        return AVERROR_INVALIDDATA;
+                    }
                     *(int *)((char *)data+
-                        attr_names[i].offset) = atoi(value);
-                } else if (attr_names[i].type == ATTR_NAME_TYPE_STR)
+                        attr_names[i].offset) = val;
+                } else if (attr_names[i].type == ATTR_NAME_TYPE_STR) {
+                    char *val = av_strdup(value);
+                    if (!val)
+                        return AVERROR(ENOMEM);
                     *(char **)((char *)data+
-                        attr_names[i].offset) = av_strdup(value);
+                        attr_names[i].offset) = val;
+                }
             }
         }
     }
diff --git a/mythtv/external/FFmpeg/libavformat/rtpdec_rfc4175.c b/mythtv/external/FFmpeg/libavformat/rtpdec_rfc4175.c
new file mode 100644
index 00000000000..498381dfd3f
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/rtpdec_rfc4175.c
@@ -0,0 +1,236 @@
+/*
+ * RTP Depacketization of RAW video (TR-03)
+ * Copyright (c) 2016 Savoir-faire Linux, Inc
+ *
+ * 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
+ */
+
+/* Development sponsored by CBC/Radio-Canada */
+
+#include "avio_internal.h"
+#include "rtpdec_formats.h"
+#include "libavutil/avstring.h"
+#include "libavutil/pixdesc.h"
+
+struct PayloadContext {
+    char *sampling;
+    int depth;
+    int width;
+    int height;
+
+    uint8_t *frame;
+    unsigned int frame_size;
+    unsigned int pgroup; /* size of the pixel group in bytes */
+    unsigned int xinc;
+
+    uint32_t timestamp;
+};
+
+static int rfc4175_parse_format(AVStream *stream, PayloadContext *data)
+{
+    enum AVPixelFormat pixfmt = AV_PIX_FMT_NONE;
+    int bits_per_sample = 0;
+    int tag = 0;
+
+    if (!strncmp(data->sampling, "YCbCr-4:2:2", 11)) {
+        tag = MKTAG('U', 'Y', 'V', 'Y');
+        data->xinc = 2;
+
+        if (data->depth == 8) {
+            data->pgroup = 4;
+            bits_per_sample = 16;
+            pixfmt = AV_PIX_FMT_UYVY422;
+        } else if (data->depth == 10) {
+            data->pgroup = 5;
+            bits_per_sample = 20;
+            pixfmt = AV_PIX_FMT_YUV422P10;
+        } else {
+            return AVERROR_INVALIDDATA;
+        }
+    } else {
+        return AVERROR_INVALIDDATA;
+    }
+
+    stream->codecpar->format = pixfmt;
+    stream->codecpar->codec_tag = tag;
+    stream->codecpar->bits_per_coded_sample = bits_per_sample;
+    data->frame_size = data->width * data->height * data->pgroup / data->xinc;
+
+    return 0;
+}
+
+static int rfc4175_parse_fmtp(AVFormatContext *s, AVStream *stream,
+                              PayloadContext *data, const char *attr,
+                              const char *value)
+{
+    if (!strncmp(attr, "width", 5))
+        data->width = atoi(value);
+    else if (!strncmp(attr, "height", 6))
+        data->height = atoi(value);
+    else if (!strncmp(attr, "sampling", 8))
+        data->sampling = av_strdup(value);
+    else if (!strncmp(attr, "depth", 5))
+        data->depth = atoi(value);
+
+    return 0;
+}
+
+static int rfc4175_parse_sdp_line(AVFormatContext *s, int st_index,
+                                  PayloadContext *data, const char *line)
+{
+    const char *p;
+
+    if (st_index < 0)
+        return 0;
+
+    if (av_strstart(line, "fmtp:", &p)) {
+        AVStream *stream = s->streams[st_index];
+        int ret = ff_parse_fmtp(s, stream, data, p, rfc4175_parse_fmtp);
+
+        if (ret < 0)
+            return ret;
+
+
+        if (!data->sampling || !data->depth || !data->width || !data->height)
+            return -1;
+
+        stream->codecpar->width = data->width;
+        stream->codecpar->height = data->height;
+
+        ret = rfc4175_parse_format(stream, data);
+        av_freep(&data->sampling);
+
+        return ret;
+    }
+
+    return 0;
+}
+
+static int rfc4175_finalize_packet(PayloadContext *data, AVPacket *pkt,
+                                   int stream_index)
+{
+   int ret;
+
+   pkt->stream_index = stream_index;
+   ret = av_packet_from_data(pkt, data->frame, data->frame_size);
+   if (ret < 0) {
+       av_freep(&data->frame);
+   }
+
+   data->frame = NULL;
+
+   return ret;
+}
+
+static int rfc4175_handle_packet(AVFormatContext *ctx, PayloadContext *data,
+                                 AVStream *st, AVPacket *pkt, uint32_t *timestamp,
+                                 const uint8_t * buf, int len,
+                                 uint16_t seq, int flags)
+{
+    int length, line, offset, cont;
+    const uint8_t *headers = buf + 2; /* skip extended seqnum */
+    const uint8_t *payload = buf + 2;
+    int payload_len = len - 2;
+    int missed_last_packet = 0;
+
+    uint8_t *dest;
+
+    if (*timestamp != data->timestamp) {
+        if (data->frame) {
+            /*
+             * if we're here, it means that two RTP packets didn't have the
+             * same timestamp, which is a sign that they were packets from two
+             * different frames, but we didn't get the flag RTP_FLAG_MARKER on
+             * the first one of these frames (last packet of a frame).
+             * Finalize the previous frame anyway by filling the AVPacket.
+             */
+            av_log(ctx, AV_LOG_ERROR, "Missed previous RTP Marker\n");
+            missed_last_packet = 1;
+            rfc4175_finalize_packet(data, pkt, st->index);
+        }
+
+        data->frame = av_malloc(data->frame_size);
+
+        data->timestamp = *timestamp;
+
+        if (!data->frame) {
+            av_log(ctx, AV_LOG_ERROR, "Out of memory.\n");
+            return AVERROR(ENOMEM);
+        }
+    }
+
+    /*
+     * looks for the 'Continuation bit' in scan lines' headers
+     * to find where data start
+     */
+    do {
+        if (payload_len < 6)
+            return AVERROR_INVALIDDATA;
+
+        cont = payload[4] & 0x80;
+        payload += 6;
+        payload_len -= 6;
+    } while (cont);
+
+    /* and now iterate over every scan lines */
+    do {
+        int copy_offset;
+
+        if (payload_len < data->pgroup)
+            return AVERROR_INVALIDDATA;
+
+        length = (headers[0] << 8) | headers[1];
+        line = ((headers[2] & 0x7f) << 8) | headers[3];
+        offset = ((headers[4] & 0x7f) << 8) | headers[5];
+        cont = headers[4] & 0x80;
+        headers += 6;
+
+        if (length % data->pgroup)
+            return AVERROR_INVALIDDATA;
+
+        if (length > payload_len)
+            length = payload_len;
+
+        /* prevent ill-formed packets to write after buffer's end */
+        copy_offset = (line * data->width + offset) * data->pgroup / data->xinc;
+        if (copy_offset + length > data->frame_size)
+            return AVERROR_INVALIDDATA;
+
+        dest = data->frame + copy_offset;
+        memcpy(dest, payload, length);
+
+        payload += length;
+        payload_len -= length;
+    } while (cont);
+
+    if ((flags & RTP_FLAG_MARKER)) {
+        return rfc4175_finalize_packet(data, pkt, st->index);
+    } else if (missed_last_packet) {
+        return 0;
+    }
+
+    return AVERROR(EAGAIN);
+}
+
+RTPDynamicProtocolHandler ff_rfc4175_rtp_handler = {
+    .enc_name           = "raw",
+    .codec_type         = AVMEDIA_TYPE_VIDEO,
+    .codec_id           = AV_CODEC_ID_BITPACKED,
+    .priv_data_size     = sizeof(PayloadContext),
+    .parse_sdp_a_line   = rfc4175_parse_sdp_line,
+    .parse_packet       = rfc4175_handle_packet,
+};
diff --git a/mythtv/external/FFmpeg/libavformat/rtpdec_xiph.c b/mythtv/external/FFmpeg/libavformat/rtpdec_xiph.c
index 26aef54e1d8..43de6ce3431 100644
--- a/mythtv/external/FFmpeg/libavformat/rtpdec_xiph.c
+++ b/mythtv/external/FFmpeg/libavformat/rtpdec_xiph.c
@@ -108,15 +108,14 @@ static int xiph_handle_packet(AVFormatContext *ctx, PayloadContext *data,
     }
 
     if (ident != data->ident) {
-        av_log(ctx, AV_LOG_ERROR,
-               "Unimplemented Xiph SDP configuration change detected\n");
+        avpriv_report_missing_feature(ctx, "Xiph SDP configuration change");
         return AVERROR_PATCHWELCOME;
     }
 
     if (tdt) {
-        av_log(ctx, AV_LOG_ERROR,
-               "Unimplemented RTP Xiph packet settings (%d,%d,%d)\n",
-               fragmented, tdt, num_pkts);
+        avpriv_report_missing_feature(ctx,
+                                      "RTP Xiph packet settings (%d,%d,%d)",
+                                      fragmented, tdt, num_pkts);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -246,16 +245,15 @@ parse_packed_headers(AVFormatContext *s,
     length2            = get_base128(&packed_headers, packed_headers_end);
 
     if (num_packed != 1 || num_headers > 3) {
-        av_log(s, AV_LOG_ERROR,
-               "Unimplemented number of headers: %d packed headers, %d headers\n",
-               num_packed, num_headers);
+        avpriv_report_missing_feature(s, "%u packed headers, %u headers",
+                                      num_packed, num_headers);
         return AVERROR_PATCHWELCOME;
     }
 
     if (packed_headers_end - packed_headers != length ||
         length1 > length || length2 > length - length1) {
         av_log(s, AV_LOG_ERROR,
-               "Bad packed header lengths (%d,%d,%"PTRDIFF_SPECIFIER",%d)\n", length1,
+               "Bad packed header lengths (%d,%d,%"PTRDIFF_SPECIFIER",%u)\n", length1,
                length2, packed_headers_end - packed_headers, length);
         return AVERROR_INVALIDDATA;
     }
diff --git a/mythtv/external/FFmpeg/libavformat/rtpenc.c b/mythtv/external/FFmpeg/libavformat/rtpenc.c
index efa63a55753..573593fa663 100644
--- a/mythtv/external/FFmpeg/libavformat/rtpenc.c
+++ b/mythtv/external/FFmpeg/libavformat/rtpenc.c
@@ -78,6 +78,7 @@ static int is_supported(enum AVCodecID id)
     case AV_CODEC_ID_VP9:
     case AV_CODEC_ID_ADPCM_G722:
     case AV_CODEC_ID_ADPCM_G726:
+    case AV_CODEC_ID_ADPCM_G726LE:
     case AV_CODEC_ID_ILBC:
     case AV_CODEC_ID_MJPEG:
     case AV_CODEC_ID_SPEEX:
@@ -145,7 +146,7 @@ static int rtp_write_header(AVFormatContext *s1)
     } else
         s1->packet_size = s1->pb->max_packet_size;
     if (s1->packet_size <= 12) {
-        av_log(s1, AV_LOG_ERROR, "Max packet size %d too low\n", s1->packet_size);
+        av_log(s1, AV_LOG_ERROR, "Max packet size %u too low\n", s1->packet_size);
         return AVERROR(EIO);
     }
     s->buf = av_malloc(s1->packet_size);
@@ -285,7 +286,7 @@ static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)
     RTPMuxContext *s = s1->priv_data;
     uint32_t rtp_ts;
 
-    av_log(s1, AV_LOG_TRACE, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);
+    av_log(s1, AV_LOG_TRACE, "RTCP: %02x %"PRIx64" %"PRIx32"\n", s->payload_type, ntp_time, s->timestamp);
 
     s->last_rtcp_ntp_time = ntp_time;
     rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},
@@ -550,6 +551,7 @@ static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
          * clock. */
         return rtp_send_samples(s1, pkt->data, size, 8 * st->codecpar->channels);
     case AV_CODEC_ID_ADPCM_G726:
+    case AV_CODEC_ID_ADPCM_G726LE:
         return rtp_send_samples(s1, pkt->data, size,
                                 st->codecpar->bits_per_coded_sample * st->codecpar->channels);
     case AV_CODEC_ID_MP2:
diff --git a/mythtv/external/FFmpeg/libavformat/rtpproto.c b/mythtv/external/FFmpeg/libavformat/rtpproto.c
index fa1dcb5570f..0706cae25f3 100644
--- a/mythtv/external/FFmpeg/libavformat/rtpproto.c
+++ b/mythtv/external/FFmpeg/libavformat/rtpproto.c
@@ -44,7 +44,7 @@
 
 typedef struct RTPContext {
     const AVClass *class;
-    URLContext *rtp_hd, *rtcp_hd;
+    URLContext *rtp_hd, *rtcp_hd, *fec_hd;
     int rtp_fd, rtcp_fd, nb_ssm_include_addrs, nb_ssm_exclude_addrs;
     struct sockaddr_storage **ssm_include_addrs, **ssm_exclude_addrs;
     int write_to_source;
@@ -58,6 +58,7 @@ typedef struct RTPContext {
     int dscp;
     char *sources;
     char *block;
+    char *fec_options_str;
 } RTPContext;
 
 #define OFFSET(x) offsetof(RTPContext, x)
@@ -75,6 +76,7 @@ static const AVOption options[] = {
     { "dscp",               "DSCP class",                                                       OFFSET(dscp),            AV_OPT_TYPE_INT,    { .i64 = -1 },    -1, INT_MAX, .flags = D|E },
     { "sources",            "Source list",                                                      OFFSET(sources),         AV_OPT_TYPE_STRING, { .str = NULL },               .flags = D|E },
     { "block",              "Block list",                                                       OFFSET(block),           AV_OPT_TYPE_STRING, { .str = NULL },               .flags = D|E },
+    { "fec",                "FEC",                                                              OFFSET(fec_options_str), AV_OPT_TYPE_STRING, { .str = NULL },               .flags = E },
     { NULL }
 };
 
@@ -316,9 +318,11 @@ static void rtp_parse_addr_list(URLContext *h, char *buf,
 static int rtp_open(URLContext *h, const char *uri, int flags)
 {
     RTPContext *s = h->priv_data;
+    AVDictionary *fec_opts = NULL;
     int rtp_port;
     char hostname[256], include_sources[1024] = "", exclude_sources[1024] = "";
     char *sources = include_sources, *block = exclude_sources;
+    char *fec_protocol = NULL;
     char buf[1024];
     char path[1024];
     const char *p;
@@ -377,6 +381,31 @@ static int rtp_open(URLContext *h, const char *uri, int flags)
         }
     }
 
+    if (s->fec_options_str) {
+        p = s->fec_options_str;
+
+        if (!(fec_protocol = av_get_token(&p, "="))) {
+            av_log(h, AV_LOG_ERROR, "Failed to parse the FEC protocol value\n");
+            goto fail;
+        }
+        if (strcmp(fec_protocol, "prompeg")) {
+            av_log(h, AV_LOG_ERROR, "Unsupported FEC protocol %s\n", fec_protocol);
+            goto fail;
+        }
+
+        p = s->fec_options_str + strlen(fec_protocol);
+        while (*p && *p == '=') p++;
+
+        if (av_dict_parse_string(&fec_opts, p, "=", ":", 0) < 0) {
+            av_log(h, AV_LOG_ERROR, "Failed to parse the FEC options\n");
+            goto fail;
+        }
+        if (s->ttl > 0) {
+            snprintf(buf, sizeof (buf), "%d", s->ttl);
+            av_dict_set(&fec_opts, "ttl", buf, 0);
+        }
+    }
+
     for (i = 0; i < max_retry_count; i++) {
         build_udp_url(s, buf, sizeof(buf),
                       hostname, rtp_port, s->local_rtpport,
@@ -412,6 +441,14 @@ static int rtp_open(URLContext *h, const char *uri, int flags)
         break;
     }
 
+    s->fec_hd = NULL;
+    if (fec_protocol) {
+        ff_url_join(buf, sizeof(buf), fec_protocol, NULL, hostname, rtp_port, NULL);
+        if (ffurl_open_whitelist(&s->fec_hd, buf, flags, &h->interrupt_callback,
+                             &fec_opts, h->protocol_whitelist, h->protocol_blacklist, h) < 0)
+            goto fail;
+    }
+
     /* just to ease handle access. XXX: need to suppress direct handle
        access */
     s->rtp_fd = ffurl_get_file_handle(s->rtp_hd);
@@ -419,6 +456,10 @@ static int rtp_open(URLContext *h, const char *uri, int flags)
 
     h->max_packet_size = s->rtp_hd->max_packet_size;
     h->is_streamed = 1;
+
+    av_free(fec_protocol);
+    av_dict_free(&fec_opts);
+
     return 0;
 
  fail:
@@ -426,6 +467,9 @@ static int rtp_open(URLContext *h, const char *uri, int flags)
         ffurl_close(s->rtp_hd);
     if (s->rtcp_hd)
         ffurl_close(s->rtcp_hd);
+    ffurl_closep(&s->fec_hd);
+    av_free(fec_protocol);
+    av_dict_free(&fec_opts);
     return AVERROR(EIO);
 }
 
@@ -468,13 +512,12 @@ static int rtp_read(URLContext *h, uint8_t *buf, int size)
         if (h->flags & AVIO_FLAG_NONBLOCK)
             return AVERROR(EAGAIN);
     }
-    return len;
 }
 
 static int rtp_write(URLContext *h, const uint8_t *buf, int size)
 {
     RTPContext *s = h->priv_data;
-    int ret;
+    int ret, ret_fec;
     URLContext *hd;
 
     if (size < 2)
@@ -543,7 +586,17 @@ static int rtp_write(URLContext *h, const uint8_t *buf, int size)
         hd = s->rtp_hd;
     }
 
-    ret = ffurl_write(hd, buf, size);
+    if ((ret = ffurl_write(hd, buf, size)) < 0) {
+        return ret;
+    }
+
+    if (s->fec_hd && !RTP_PT_IS_RTCP(buf[1])) {
+        if ((ret_fec = ffurl_write(s->fec_hd, buf, size)) < 0) {
+            av_log(h, AV_LOG_ERROR, "Failed to send FEC\n");
+            return ret_fec;
+        }
+    }
+
     return ret;
 }
 
@@ -561,6 +614,7 @@ static int rtp_close(URLContext *h)
 
     ffurl_close(s->rtp_hd);
     ffurl_close(s->rtcp_hd);
+    ffurl_closep(&s->fec_hd);
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libavformat/rtsp.c b/mythtv/external/FFmpeg/libavformat/rtsp.c
index 00ce08e1020..2969b0bdad9 100644
--- a/mythtv/external/FFmpeg/libavformat/rtsp.c
+++ b/mythtv/external/FFmpeg/libavformat/rtsp.c
@@ -670,7 +670,6 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
 
 int ff_sdp_parse(AVFormatContext *s, const char *content)
 {
-    RTSPState *rt = s->priv_data;
     const char *p;
     int letter, i;
     /* Some SDP lines, particularly for Realmedia or ASF RTSP streams,
@@ -717,8 +716,6 @@ int ff_sdp_parse(AVFormatContext *s, const char *content)
         av_freep(&s1->default_exclude_source_addrs[i]);
     av_freep(&s1->default_exclude_source_addrs);
 
-    rt->p = av_malloc_array(rt->nb_rtsp_streams + 1, sizeof(struct pollfd) * 2);
-    if (!rt->p) return AVERROR(ENOMEM);
     return 0;
 }
 #endif /* CONFIG_RTPDEC */
@@ -1340,8 +1337,7 @@ static int rtsp_send_cmd_with_content_async(AVFormatContext *s,
     ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
     if (send_content_length > 0 && send_content) {
         if (rt->control_transport == RTSP_MODE_TUNNEL) {
-            av_log(s, AV_LOG_ERROR, "tunneling of RTSP requests "
-                                    "with content data not supported\n");
+            avpriv_report_missing_feature(s, "Tunneling of RTSP requests with content data");
             return AVERROR_PATCHWELCOME;
         }
         ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);
@@ -1922,28 +1918,50 @@ int ff_rtsp_connect(AVFormatContext *s)
 #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
 
 #if CONFIG_RTPDEC
+static int parse_rtsp_message(AVFormatContext *s)
+{
+    RTSPState *rt = s->priv_data;
+    int ret;
+
+    if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
+        if (rt->state == RTSP_STATE_STREAMING) {
+            if (!ff_rtsp_parse_streaming_commands(s))
+                return AVERROR_EOF;
+            else
+                av_log(s, AV_LOG_WARNING,
+                       "Unable to answer to TEARDOWN\n");
+        } else
+            return 0;
+    } else {
+        RTSPMessageHeader reply;
+        ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
+        if (ret < 0)
+            return ret;
+        /* XXX: parse message */
+        if (rt->state != RTSP_STATE_STREAMING)
+            return 0;
+    }
+
+    return 0;
+}
+
 static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
                            uint8_t *buf, int buf_size, int64_t wait_end)
 {
     RTSPState *rt = s->priv_data;
     RTSPStream *rtsp_st;
-    int n, i, ret, tcp_fd, timeout_cnt = 0;
-    int max_p = 0;
+    int n, i, ret, timeout_cnt = 0;
     struct pollfd *p = rt->p;
     int *fds = NULL, fdsnum, fdsidx;
 
-    for (;;) {
-        if (ff_check_interrupt(&s->interrupt_callback))
-            return AVERROR_EXIT;
-        if (wait_end && wait_end - av_gettime_relative() < 0)
-            return AVERROR(EAGAIN);
-        max_p = 0;
+    if (!p) {
+        p = rt->p = av_malloc_array(2 * (rt->nb_rtsp_streams + 1), sizeof(struct pollfd));
+        if (!p)
+            return AVERROR(ENOMEM);
+
         if (rt->rtsp_hd) {
-            tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
-            p[max_p].fd = tcp_fd;
-            p[max_p++].events = POLLIN;
-        } else {
-            tcp_fd = -1;
+            p[rt->max_p].fd = ffurl_get_file_handle(rt->rtsp_hd);
+            p[rt->max_p++].events = POLLIN;
         }
         for (i = 0; i < rt->nb_rtsp_streams; i++) {
             rtsp_st = rt->rtsp_streams[i];
@@ -1959,15 +1977,22 @@ static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
                     return AVERROR_INVALIDDATA;
                 }
                 for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
-                    p[max_p].fd       = fds[fdsidx];
-                    p[max_p++].events = POLLIN;
+                    p[rt->max_p].fd       = fds[fdsidx];
+                    p[rt->max_p++].events = POLLIN;
                 }
                 av_freep(&fds);
             }
         }
-        n = poll(p, max_p, POLL_TIMEOUT_MS);
+    }
+
+    for (;;) {
+        if (ff_check_interrupt(&s->interrupt_callback))
+            return AVERROR_EXIT;
+        if (wait_end && wait_end - av_gettime_relative() < 0)
+            return AVERROR(EAGAIN);
+        n = poll(p, rt->max_p, POLL_TIMEOUT_MS);
         if (n > 0) {
-            int j = 1 - (tcp_fd == -1);
+            int j = rt->rtsp_hd ? 1 : 0;
             timeout_cnt = 0;
             for (i = 0; i < rt->nb_rtsp_streams; i++) {
                 rtsp_st = rt->rtsp_streams[i];
@@ -1983,25 +2008,8 @@ static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
                 }
             }
 #if CONFIG_RTSP_DEMUXER
-            if (tcp_fd != -1 && p[0].revents & POLLIN) {
-                if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
-                    if (rt->state == RTSP_STATE_STREAMING) {
-                        if (!ff_rtsp_parse_streaming_commands(s))
-                            return AVERROR_EOF;
-                        else
-                            av_log(s, AV_LOG_WARNING,
-                                   "Unable to answer to TEARDOWN\n");
-                    } else
-                        return 0;
-                } else {
-                    RTSPMessageHeader reply;
-                    ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
-                    if (ret < 0)
-                        return ret;
-                    /* XXX: parse message */
-                    if (rt->state != RTSP_STATE_STREAMING)
-                        return 0;
-                }
+            if (rt->rtsp_hd && p[0].revents & POLLIN) {
+                return parse_rtsp_message(s);
             }
 #endif
         } else if (n == 0 && ++timeout_cnt >= MAX_TIMEOUTS) {
@@ -2055,6 +2063,44 @@ static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st,
     return AVERROR(EAGAIN);
 }
 
+static int read_packet(AVFormatContext *s,
+                       RTSPStream **rtsp_st, RTSPStream *first_queue_st,
+                       int64_t wait_end)
+{
+    RTSPState *rt = s->priv_data;
+    int len;
+
+    switch(rt->lower_transport) {
+    default:
+#if CONFIG_RTSP_DEMUXER
+    case RTSP_LOWER_TRANSPORT_TCP:
+        len = ff_rtsp_tcp_read_packet(s, rtsp_st, rt->recvbuf, RECVBUF_SIZE);
+        break;
+#endif
+    case RTSP_LOWER_TRANSPORT_UDP:
+    case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
+        len = udp_read_packet(s, rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
+        if (len > 0 && (*rtsp_st)->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
+            ff_rtp_check_and_send_back_rr((*rtsp_st)->transport_priv, (*rtsp_st)->rtp_handle, NULL, len);
+        break;
+    case RTSP_LOWER_TRANSPORT_CUSTOM:
+        if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&
+            wait_end && wait_end < av_gettime_relative())
+            len = AVERROR(EAGAIN);
+        else
+            len = avio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE);
+        len = pick_stream(s, rtsp_st, rt->recvbuf, len);
+        if (len > 0 && (*rtsp_st)->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
+            ff_rtp_check_and_send_back_rr((*rtsp_st)->transport_priv, NULL, s->pb, len);
+        break;
+    }
+
+    if (len == 0)
+        return AVERROR_EOF;
+
+    return len;
+}
+
 int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
 {
     RTSPState *rt = s->priv_data;
@@ -2119,30 +2165,7 @@ int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
             return AVERROR(ENOMEM);
     }
 
-    switch(rt->lower_transport) {
-    default:
-#if CONFIG_RTSP_DEMUXER
-    case RTSP_LOWER_TRANSPORT_TCP:
-        len = ff_rtsp_tcp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE);
-        break;
-#endif
-    case RTSP_LOWER_TRANSPORT_UDP:
-    case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
-        len = udp_read_packet(s, &rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
-        if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
-            ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, rtsp_st->rtp_handle, NULL, len);
-        break;
-    case RTSP_LOWER_TRANSPORT_CUSTOM:
-        if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&
-            wait_end && wait_end < av_gettime_relative())
-            len = AVERROR(EAGAIN);
-        else
-            len = ffio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE);
-        len = pick_stream(s, &rtsp_st, rt->recvbuf, len);
-        if (len > 0 && rtsp_st->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
-            ff_rtp_check_and_send_back_rr(rtsp_st->transport_priv, NULL, s->pb, len);
-        break;
-    }
+    len = read_packet(s, &rtsp_st, first_queue_st, wait_end);
     if (len == AVERROR(EAGAIN) && first_queue_st &&
         rt->transport == RTSP_TRANSPORT_RTP) {
         av_log(s, AV_LOG_WARNING,
@@ -2153,8 +2176,7 @@ int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
     }
     if (len < 0)
         return len;
-    if (len == 0)
-        return AVERROR_EOF;
+
     if (rt->transport == RTSP_TRANSPORT_RDT) {
         ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
     } else if (rt->transport == RTSP_TRANSPORT_RTP) {
diff --git a/mythtv/external/FFmpeg/libavformat/rtsp.h b/mythtv/external/FFmpeg/libavformat/rtsp.h
index 852fd6704e1..36fdae492b4 100644
--- a/mythtv/external/FFmpeg/libavformat/rtsp.h
+++ b/mythtv/external/FFmpeg/libavformat/rtsp.h
@@ -352,6 +352,7 @@ typedef struct RTSPState {
      * Polling array for udp
      */
     struct pollfd *p;
+    int max_p;
 
     /**
      * Whether the server supports the GET_PARAMETER method.
diff --git a/mythtv/external/FFmpeg/libavformat/rtspdec.c b/mythtv/external/FFmpeg/libavformat/rtspdec.c
index a722b98e404..fdf75a0979f 100644
--- a/mythtv/external/FFmpeg/libavformat/rtspdec.c
+++ b/mythtv/external/FFmpeg/libavformat/rtspdec.c
@@ -498,7 +498,6 @@ int ff_rtsp_parse_streaming_commands(AVFormatContext *s)
     } else if (methodcode == TEARDOWN) {
         rt->state = RTSP_STATE_IDLE;
         ret       = rtsp_send_reply(s, RTSP_STATUS_OK, NULL , request.seq);
-        return 0;
     }
     return ret;
 }
@@ -698,7 +697,6 @@ static int rtsp_listen(AVFormatContext *s)
             return AVERROR_INVALIDDATA;
         }
     }
-    return 0;
 }
 
 static int rtsp_probe(AVProbeData *p)
diff --git a/mythtv/external/FFmpeg/libavformat/s337m.c b/mythtv/external/FFmpeg/libavformat/s337m.c
new file mode 100644
index 00000000000..2e85d487b5e
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/s337m.c
@@ -0,0 +1,206 @@
+/*
+ * Copyright (C) 2017 foo86
+ *
+ * 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/intreadwrite.h"
+#include "avformat.h"
+#include "spdif.h"
+
+#define MARKER_16LE         0x72F81F4E
+#define MARKER_20LE         0x20876FF0E154
+#define MARKER_24LE         0x72F8961F4EA5
+
+#define IS_16LE_MARKER(state)   ((state & 0xFFFFFFFF) == MARKER_16LE)
+#define IS_20LE_MARKER(state)   ((state & 0xF0FFFFF0FFFF) == MARKER_20LE)
+#define IS_24LE_MARKER(state)   ((state & 0xFFFFFFFFFFFF) == MARKER_24LE)
+#define IS_LE_MARKER(state)     (IS_16LE_MARKER(state) || IS_20LE_MARKER(state) || IS_24LE_MARKER(state))
+
+static int s337m_get_offset_and_codec(AVFormatContext *s,
+                                      uint64_t state,
+                                      int data_type, int data_size,
+                                      int *offset, enum AVCodecID *codec)
+{
+    int word_bits;
+
+    if (IS_16LE_MARKER(state)) {
+        word_bits = 16;
+    } else if (IS_20LE_MARKER(state)) {
+        data_type >>= 8;
+        data_size >>= 4;
+        word_bits = 20;
+    } else {
+        data_type >>= 8;
+        word_bits = 24;
+    }
+
+    if ((data_type & 0x1F) != 0x1C) {
+        if (s)
+            avpriv_report_missing_feature(s, "Data type %#x in SMPTE 337M", data_type & 0x1F);
+        return AVERROR_PATCHWELCOME;
+    }
+
+    if (codec)
+        *codec = AV_CODEC_ID_DOLBY_E;
+
+    switch (data_size / word_bits) {
+    case 3648:
+        *offset = 1920;
+        break;
+    case 3644:
+        *offset = 2002;
+        break;
+    case 3640:
+        *offset = 2000;
+        break;
+    case 3040:
+        *offset = 1601;
+        break;
+    default:
+        if (s)
+            avpriv_report_missing_feature(s, "Dolby E data size %d in SMPTE 337M", data_size);
+        return AVERROR_PATCHWELCOME;
+    }
+
+    *offset -= 4;
+    *offset *= (word_bits + 7 >> 3) * 2;
+    return 0;
+}
+
+static int s337m_probe(AVProbeData *p)
+{
+    uint64_t state = 0;
+    int markers[3] = { 0 };
+    int i, pos, sum, max, data_type, data_size, offset;
+    uint8_t *buf;
+
+    for (pos = 0; pos < p->buf_size; pos++) {
+        state = (state << 8) | p->buf[pos];
+        if (!IS_LE_MARKER(state))
+            continue;
+
+        buf = p->buf + pos + 1;
+        if (IS_16LE_MARKER(state)) {
+            data_type = AV_RL16(buf    );
+            data_size = AV_RL16(buf + 2);
+        } else {
+            data_type = AV_RL24(buf    );
+            data_size = AV_RL24(buf + 3);
+        }
+
+        if (s337m_get_offset_and_codec(NULL, state, data_type, data_size, &offset, NULL))
+            continue;
+
+        i = IS_16LE_MARKER(state) ? 0 : IS_20LE_MARKER(state) ? 1 : 2;
+        markers[i]++;
+
+        pos  += IS_16LE_MARKER(state) ? 4 : 6;
+        pos  += offset;
+        state = 0;
+    }
+
+    sum = max = 0;
+    for (i = 0; i < FF_ARRAY_ELEMS(markers); i++) {
+        sum += markers[i];
+        if (markers[max] < markers[i])
+            max = i;
+    }
+
+    if (markers[max] > 3 && markers[max] * 4 > sum * 3)
+        return AVPROBE_SCORE_EXTENSION + 1;
+
+    return 0;
+}
+
+static int s337m_read_header(AVFormatContext *s)
+{
+    s->ctx_flags |= AVFMTCTX_NOHEADER;
+    return 0;
+}
+
+static void bswap_buf24(uint8_t *data, int size)
+{
+    int i;
+
+    for (i = 0; i < size / 3; i++, data += 3)
+        FFSWAP(uint8_t, data[0], data[2]);
+}
+
+static int s337m_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    AVIOContext *pb = s->pb;
+    uint64_t state = 0;
+    int ret, data_type, data_size, offset;
+    enum AVCodecID codec;
+    int64_t pos;
+
+    while (!IS_LE_MARKER(state)) {
+        state = (state << 8) | avio_r8(pb);
+        if (avio_feof(pb))
+            return AVERROR_EOF;
+    }
+
+    if (IS_16LE_MARKER(state)) {
+        data_type = avio_rl16(pb);
+        data_size = avio_rl16(pb);
+    } else {
+        data_type = avio_rl24(pb);
+        data_size = avio_rl24(pb);
+    }
+
+    pos = avio_tell(pb);
+
+    if ((ret = s337m_get_offset_and_codec(s, state, data_type, data_size, &offset, &codec)) < 0)
+        return ret;
+
+    if ((ret = av_new_packet(pkt, offset)) < 0)
+        return ret;
+
+    pkt->pos = pos;
+
+    if (avio_read(pb, pkt->data, pkt->size) < pkt->size) {
+        av_packet_unref(pkt);
+        return AVERROR_EOF;
+    }
+
+    if (IS_16LE_MARKER(state))
+        ff_spdif_bswap_buf16((uint16_t *)pkt->data, (uint16_t *)pkt->data, pkt->size >> 1);
+    else
+        bswap_buf24(pkt->data, pkt->size);
+
+    if (!s->nb_streams) {
+        AVStream *st = avformat_new_stream(s, NULL);
+        if (!st) {
+            av_packet_unref(pkt);
+            return AVERROR(ENOMEM);
+        }
+        st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
+        st->codecpar->codec_id   = codec;
+    }
+
+    return 0;
+}
+
+AVInputFormat ff_s337m_demuxer = {
+    .name           = "s337m",
+    .long_name      = NULL_IF_CONFIG_SMALL("SMPTE 337M"),
+    .read_probe     = s337m_probe,
+    .read_header    = s337m_read_header,
+    .read_packet    = s337m_read_packet,
+    .flags          = AVFMT_GENERIC_INDEX,
+};
diff --git a/mythtv/external/FFmpeg/libavformat/sbgdec.c b/mythtv/external/FFmpeg/libavformat/sbgdec.c
index bb020d7f9a2..cbedd120fbf 100644
--- a/mythtv/external/FFmpeg/libavformat/sbgdec.c
+++ b/mythtv/external/FFmpeg/libavformat/sbgdec.c
@@ -927,7 +927,7 @@ static void expand_timestamps(void *log, struct sbg_script *s)
         }
     }
     if (s->start_ts == AV_NOPTS_VALUE)
-        s->start_ts = s->opt_start_at_first ? s->tseq[0].ts.t : now;
+        s->start_ts = (s->opt_start_at_first && s->tseq) ? s->tseq[0].ts.t : now;
     s->end_ts = s->opt_duration ? s->start_ts + s->opt_duration :
                 AV_NOPTS_VALUE; /* may be overridden later by -E option */
     cur_ts = now;
diff --git a/mythtv/external/FFmpeg/libavformat/sccdec.c b/mythtv/external/FFmpeg/libavformat/sccdec.c
new file mode 100644
index 00000000000..89d21b9c1fb
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/sccdec.c
@@ -0,0 +1,180 @@
+/*
+ * SCC subtitle demuxer
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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 "avformat.h"
+#include "internal.h"
+#include "subtitles.h"
+#include "libavutil/bprint.h"
+#include "libavutil/intreadwrite.h"
+
+typedef struct SCCContext {
+    FFDemuxSubtitlesQueue q;
+} SCCContext;
+
+static int scc_probe(AVProbeData *p)
+{
+    char buf[18];
+    FFTextReader tr;
+
+    ff_text_init_buf(&tr, p->buf, p->buf_size);
+
+    while (ff_text_peek_r8(&tr) == '\r' || ff_text_peek_r8(&tr) == '\n')
+        ff_text_r8(&tr);
+
+    ff_text_read(&tr, buf, sizeof(buf));
+
+    if (!memcmp(buf, "Scenarist_SCC V1.0", 18))
+        return AVPROBE_SCORE_MAX;
+
+    return 0;
+}
+
+static int convert(uint8_t x)
+{
+    if (x >= 'a')
+        x -= 87;
+    else if (x >= 'A')
+        x -= 55;
+    else
+        x -= '0';
+    return x;
+}
+
+static int scc_read_header(AVFormatContext *s)
+{
+    SCCContext *scc = s->priv_data;
+    AVStream *st = avformat_new_stream(s, NULL);
+    char line[4096], line2[4096];
+    int count = 0, ret = 0;
+    ptrdiff_t len2, len;
+    uint8_t out[4096];
+    FFTextReader tr;
+
+    ff_text_init_avio(s, &tr, s->pb);
+
+    if (!st)
+        return AVERROR(ENOMEM);
+    avpriv_set_pts_info(st, 64, 1, 1000);
+    st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
+    st->codecpar->codec_id   = AV_CODEC_ID_EIA_608;
+
+    while (!ff_text_eof(&tr)) {
+        const int64_t pos = ff_text_pos(&tr);
+        char *saveptr = NULL, *lline;
+        int hh1, mm1, ss1, fs1, i;
+        int hh2, mm2, ss2, fs2;
+        int64_t ts_start, ts_end;
+        AVPacket *sub;
+
+        if (count == 0) {
+            while (!ff_text_eof(&tr)) {
+                len = ff_subtitles_read_line(&tr, line, sizeof(line));
+                if (len > 13)
+                    break;
+            }
+        }
+
+        if (!strncmp(line, "Scenarist_SCC V1.0", 18))
+            continue;
+        if (sscanf(line, "%d:%d:%d%*[:;]%d", &hh1, &mm1, &ss1, &fs1) != 4)
+            continue;
+
+        ts_start = (hh1 * 3600LL + mm1 * 60LL + ss1) * 1000LL + fs1 * 33;
+
+        while (!ff_text_eof(&tr)) {
+            len2 = ff_subtitles_read_line(&tr, line2, sizeof(line2));
+            if (len2 > 13)
+                break;
+        }
+        if (sscanf(line2, "%d:%d:%d%*[:;]%d", &hh2, &mm2, &ss2, &fs2) != 4)
+            continue;
+
+        ts_end = (hh2 * 3600LL + mm2 * 60LL + ss2) * 1000LL + fs2 * 33;
+        count++;
+
+        lline = (char *)&line;
+        lline += 12;
+
+        for (i = 0; i < 4095; i += 3) {
+            char *ptr = av_strtok(lline, " ", &saveptr);
+            char c1, c2, c3, c4;
+
+            if (!ptr)
+                break;
+
+            if (sscanf(ptr, "%c%c%c%c", &c1, &c2, &c3, &c4) != 4)
+                break;
+
+            lline = NULL;
+            out[i+0] = 0xfc;
+            out[i+1] = convert(c2) | (convert(c1) << 4);
+            out[i+2] = convert(c4) | (convert(c3) << 4);
+        }
+        out[i] = 0;
+
+        sub = ff_subtitles_queue_insert(&scc->q, out, i, 0);
+        if (!sub)
+            return AVERROR(ENOMEM);
+
+        sub->pos = pos;
+        sub->pts = ts_start;
+        sub->duration = FFMAX(1200, ts_end - ts_start);
+        memmove(line, line2, sizeof(line));
+        FFSWAP(ptrdiff_t, len, len2);
+    }
+
+    ff_subtitles_queue_finalize(s, &scc->q);
+
+    return ret;
+}
+
+static int scc_read_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    SCCContext *scc = s->priv_data;
+    return ff_subtitles_queue_read_packet(&scc->q, pkt);
+}
+
+static int scc_read_seek(AVFormatContext *s, int stream_index,
+                         int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
+{
+    SCCContext *scc = s->priv_data;
+    return ff_subtitles_queue_seek(&scc->q, s, stream_index,
+                                   min_ts, ts, max_ts, flags);
+}
+
+static int scc_read_close(AVFormatContext *s)
+{
+    SCCContext *scc = s->priv_data;
+    ff_subtitles_queue_clean(&scc->q);
+    return 0;
+}
+
+AVInputFormat ff_scc_demuxer = {
+    .name           = "scc",
+    .long_name      = NULL_IF_CONFIG_SMALL("Scenarist Closed Captions"),
+    .priv_data_size = sizeof(SCCContext),
+    .read_probe     = scc_probe,
+    .read_header    = scc_read_header,
+    .read_packet    = scc_read_packet,
+    .read_seek2     = scc_read_seek,
+    .read_close     = scc_read_close,
+    .extensions     = "scc",
+};
diff --git a/mythtv/external/FFmpeg/libavformat/sccenc.c b/mythtv/external/FFmpeg/libavformat/sccenc.c
new file mode 100644
index 00000000000..f3cf3d599cc
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/sccenc.c
@@ -0,0 +1,123 @@
+/*
+ * SCC muxer
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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 "avformat.h"
+#include "internal.h"
+#include "libavutil/log.h"
+#include "libavutil/intreadwrite.h"
+
+typedef struct SCCContext {
+    int prev_h, prev_m, prev_s, prev_f;
+    int inside;
+    int n;
+} SCCContext;
+
+static int scc_write_header(AVFormatContext *avf)
+{
+    SCCContext *scc = avf->priv_data;
+
+    if (avf->nb_streams != 1 ||
+        avf->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
+        av_log(avf, AV_LOG_ERROR,
+               "SCC supports only a single subtitles stream.\n");
+        return AVERROR(EINVAL);
+    }
+    if (avf->streams[0]->codecpar->codec_id != AV_CODEC_ID_EIA_608) {
+        av_log(avf, AV_LOG_ERROR,
+               "Unsupported subtitles codec: %s\n",
+               avcodec_get_name(avf->streams[0]->codecpar->codec_id));
+        return AVERROR(EINVAL);
+    }
+    avpriv_set_pts_info(avf->streams[0], 64, 1, 1000);
+    avio_printf(avf->pb, "Scenarist_SCC V1.0\n");
+
+    scc->prev_h = scc->prev_m = scc->prev_s = scc->prev_f = -1;
+    scc->inside = 0;
+
+    return 0;
+}
+
+static int scc_write_packet(AVFormatContext *avf, AVPacket *pkt)
+{
+    SCCContext *scc = avf->priv_data;
+    int64_t pts = pkt->pts;
+    int i, h, m, s, f;
+
+    if (pts == AV_NOPTS_VALUE) {
+        av_log(avf, AV_LOG_WARNING,
+               "Insufficient timestamps.\n");
+        return 0;
+    }
+
+    h = (int)(pts / (3600000));
+    m = (int)(pts / (60000)) % 60;
+    s = (int)(pts /  1000) % 60;
+    f = (int)(pts %  1000) / 33;
+
+    for (i = 0; i < pkt->size; i+=3) {
+        if (pkt->data[i] == 0xfc && ((pkt->data[i + 1] != 0x80 || pkt->data[i + 2] != 0x80)))
+            break;
+    }
+    if (i >= pkt->size)
+        return 0;
+
+    if (!scc->inside && (scc->prev_h != h || scc->prev_m != m || scc->prev_s != s || scc->prev_f != f)) {
+        avio_printf(avf->pb, "\n%02d:%02d:%02d:%02d\t", h, m, s, f);
+        scc->inside = 1;
+    }
+    for (i = 0; i < pkt->size; i+=3) {
+        if (i + 3 > pkt->size)
+            break;
+
+        if (pkt->data[i] != 0xfc || (pkt->data[i + 1] == 0x80 && pkt->data[i + 2] == 0x80))
+            continue;
+        if (!scc->inside) {
+            avio_printf(avf->pb, "\n%02d:%02d:%02d:%02d\t", h, m, s, f);
+            scc->inside = 1;
+        }
+        if (scc->n > 0)
+            avio_printf(avf->pb, " ");
+        avio_printf(avf->pb, "%02x%02x", pkt->data[i + 1], pkt->data[i + 2]);
+        scc->n++;
+    }
+    if (scc->inside && (scc->prev_h != h || scc->prev_m != m || scc->prev_s != s || scc->prev_f != f)) {
+        avio_printf(avf->pb, "\n");
+        scc->n = 0;
+        scc->inside = 0;
+    }
+
+    scc->prev_h = h;
+    scc->prev_m = m;
+    scc->prev_s = s;
+    scc->prev_f = f;
+    return 0;
+}
+
+AVOutputFormat ff_scc_muxer = {
+    .name           = "scc",
+    .long_name      = NULL_IF_CONFIG_SMALL("Scenarist Closed Captions"),
+    .extensions     = "scc",
+    .priv_data_size = sizeof(SCCContext),
+    .write_header   = scc_write_header,
+    .write_packet   = scc_write_packet,
+    .flags          = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS | AVFMT_TS_NONSTRICT,
+    .subtitle_codec = AV_CODEC_ID_EIA_608,
+};
diff --git a/mythtv/external/FFmpeg/libavformat/sdp.c b/mythtv/external/FFmpeg/libavformat/sdp.c
index 4e37f65b09e..0242ca379c2 100644
--- a/mythtv/external/FFmpeg/libavformat/sdp.c
+++ b/mythtv/external/FFmpeg/libavformat/sdp.c
@@ -673,6 +673,14 @@ static char *sdp_write_media_attributes(char *buff, int size, AVStream *st, int
                                          8000, p->channels);
             break;
         case AV_CODEC_ID_ADPCM_G726: {
+            if (payload_type >= RTP_PT_PRIVATE)
+                av_strlcatf(buff, size, "a=rtpmap:%d AAL2-G726-%d/%d\r\n",
+                                         payload_type,
+                                         p->bits_per_coded_sample*8,
+                                         p->sample_rate);
+            break;
+        }
+        case AV_CODEC_ID_ADPCM_G726LE: {
             if (payload_type >= RTP_PT_PRIVATE)
                 av_strlcatf(buff, size, "a=rtpmap:%d G726-%d/%d\r\n",
                                          payload_type,
@@ -748,7 +756,7 @@ void ff_sdp_write_media(char *buff, int size, AVStream *st, int idx,
     av_strlcatf(buff, size, "m=%s %d RTP/AVP %d\r\n", type, port, payload_type);
     sdp_write_address(buff, size, dest_addr, dest_type, ttl);
     if (p->bit_rate) {
-        av_strlcatf(buff, size, "b=AS:%"PRId64"\r\n", (int64_t)p->bit_rate / 1000);
+        av_strlcatf(buff, size, "b=AS:%"PRId64"\r\n", p->bit_rate / 1000);
     }
 
     sdp_write_media_attributes(buff, size, st, payload_type, fmt);
diff --git a/mythtv/external/FFmpeg/libavformat/sdsdec.c b/mythtv/external/FFmpeg/libavformat/sdsdec.c
new file mode 100644
index 00000000000..081bb4ca2d8
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/sdsdec.c
@@ -0,0 +1,165 @@
+/*
+ * MIDI Sample Dump Standard format demuxer
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/intreadwrite.h"
+#include "avformat.h"
+#include "internal.h"
+
+typedef struct SDSContext {
+    uint8_t data[120];
+    int bit_depth;
+    int size;
+    void (*read_block)(const uint8_t *src, uint32_t *dst);
+} SDSContext;
+
+static int sds_probe(AVProbeData *p)
+{
+    if (AV_RB32(p->buf) == 0xF07E0001 && p->buf[20] == 0xF7 &&
+        p->buf[6] >= 8 && p->buf[6] <= 28)
+        return AVPROBE_SCORE_EXTENSION;
+    return 0;
+}
+
+static void byte2_read(const uint8_t *src, uint32_t *dst)
+{
+    int i;
+
+    for (i = 0; i < 120; i += 2) {
+        unsigned sample = (src[i + 0] << 25) + (src[i + 1] << 18);
+
+        dst[i / 2] = sample;
+    }
+}
+
+static void byte3_read(const uint8_t *src, uint32_t *dst)
+{
+    int i;
+
+    for (i = 0; i < 120; i += 3) {
+        unsigned sample;
+
+        sample = (src[i + 0] << 25) | (src[i + 1] << 18) | (src[i + 2] << 11);
+        dst[i / 3] = sample;
+    }
+}
+
+static void byte4_read(const uint8_t *src, uint32_t *dst)
+{
+    int i;
+
+    for (i = 0; i < 120; i += 4) {
+        unsigned sample;
+
+        sample = (src[i + 0] << 25) | (src[i + 1] << 18) | (src[i + 2] << 11) | (src[i + 3] << 4);
+        dst[i / 4] = sample;
+    }
+}
+
+#define SDS_3BYTE_TO_INT_DECODE(x) (((x) & 0x7F) | (((x) & 0x7F00) >> 1) | (((x) & 0x7F0000) >> 2))
+
+static int sds_read_header(AVFormatContext *ctx)
+{
+    SDSContext *s = ctx->priv_data;
+    unsigned sample_period;
+    AVIOContext *pb = ctx->pb;
+    AVStream *st;
+
+    st = avformat_new_stream(ctx, NULL);
+    if (!st)
+        return AVERROR(ENOMEM);
+
+    avio_skip(pb, 4);
+    avio_skip(pb, 2);
+
+    s->bit_depth = avio_r8(pb);
+    if (s->bit_depth < 8 || s->bit_depth > 28)
+        return AVERROR_INVALIDDATA;
+
+    if (s->bit_depth < 14) {
+        s->read_block = byte2_read;
+        s->size = 60 * 4;
+    } else if (s->bit_depth < 21) {
+        s->read_block = byte3_read;
+        s->size = 40 * 4;
+    } else {
+        s->read_block = byte4_read;
+        s->size = 30 * 4;
+    }
+    st->codecpar->codec_id = AV_CODEC_ID_PCM_U32LE;
+
+    sample_period = avio_rl24(pb);
+    sample_period = SDS_3BYTE_TO_INT_DECODE(sample_period);
+    avio_skip(pb, 11);
+
+    st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
+    st->codecpar->channels = 1;
+    st->codecpar->sample_rate = sample_period ? 1000000000 / sample_period : 16000;
+    st->duration = (avio_size(pb) - 21) / (127) * s->size / 4;
+
+    avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
+
+    return 0;
+}
+
+static int sds_read_packet(AVFormatContext *ctx, AVPacket *pkt)
+{
+    SDSContext *s = ctx->priv_data;
+    AVIOContext *pb = ctx->pb;
+    int64_t pos;
+    int ret;
+
+    if (avio_feof(pb))
+        return AVERROR_EOF;
+
+    pos = avio_tell(pb);
+    if (avio_rb16(pb) != 0xF07E)
+        return AVERROR_INVALIDDATA;
+    avio_skip(pb, 3);
+
+    ret = av_new_packet(pkt, s->size);
+    if (ret < 0)
+        return ret;
+
+    ret = avio_read(pb, s->data, 120);
+
+    s->read_block(s->data, (uint32_t *)pkt->data);
+
+    avio_skip(pb, 1); // checksum
+    if (avio_r8(pb) != 0xF7)
+        return AVERROR_INVALIDDATA;
+
+    pkt->flags &= ~AV_PKT_FLAG_CORRUPT;
+    pkt->stream_index = 0;
+    pkt->pos = pos;
+
+    return ret;
+}
+
+AVInputFormat ff_sds_demuxer = {
+    .name           = "sds",
+    .long_name      = NULL_IF_CONFIG_SMALL("MIDI Sample Dump Standard"),
+    .priv_data_size = sizeof(SDSContext),
+    .read_probe     = sds_probe,
+    .read_header    = sds_read_header,
+    .read_packet    = sds_read_packet,
+    .extensions     = "sds",
+    .flags          = AVFMT_GENERIC_INDEX,
+};
diff --git a/mythtv/external/FFmpeg/libavformat/sdxdec.c b/mythtv/external/FFmpeg/libavformat/sdxdec.c
new file mode 100644
index 00000000000..e8e7a4f88d0
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/sdxdec.c
@@ -0,0 +1,90 @@
+/*
+ * SDX demuxer
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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/avstring.h"
+#include "libavutil/intreadwrite.h"
+#include "avformat.h"
+#include "internal.h"
+#include "pcm.h"
+
+static int sdx_probe(AVProbeData *p)
+{
+    if (AV_RB32(p->buf) == AV_RB32("SDX:"))
+        return AVPROBE_SCORE_EXTENSION;
+    return 0;
+}
+
+static int sdx_read_header(AVFormatContext *s)
+{
+    AVStream *st;
+    int depth, length;
+
+    avio_skip(s->pb, 4);
+    while (!avio_feof(s->pb)) {
+        if (avio_r8(s->pb) == 0x1a)
+            break;
+    }
+    if (avio_r8(s->pb) != 1)
+        return AVERROR_INVALIDDATA;
+    length = avio_r8(s->pb);
+    avio_skip(s->pb, length);
+    avio_skip(s->pb, 4);
+    depth = avio_r8(s->pb);
+
+    st = avformat_new_stream(s, NULL);
+    if (!st)
+        return AVERROR(ENOMEM);
+
+    st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
+    st->codecpar->channels = 1;
+    st->codecpar->sample_rate = avio_rl32(s->pb);
+    switch (depth) {
+    case 8:
+        st->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
+        break;
+    case 16:
+        st->codecpar->codec_id = AV_CODEC_ID_PCM_U16LE;
+        break;
+    case 24:
+        st->codecpar->codec_id = AV_CODEC_ID_PCM_U24LE;
+        break;
+    case 32:
+        st->codecpar->codec_id = AV_CODEC_ID_PCM_U32LE;
+        break;
+    default:
+        return AVERROR_INVALIDDATA;
+    }
+    avio_skip(s->pb, 16);
+    st->codecpar->block_align = depth / 8;
+
+    return 0;
+}
+
+AVInputFormat ff_sdx_demuxer = {
+    .name           = "sdx",
+    .long_name      = NULL_IF_CONFIG_SMALL("Sample Dump eXchange"),
+    .read_probe     = sdx_probe,
+    .read_header    = sdx_read_header,
+    .read_packet    = ff_pcm_read_packet,
+    .read_seek      = ff_pcm_read_seek,
+    .extensions     = "sdx",
+    .flags          = AVFMT_GENERIC_INDEX,
+};
diff --git a/mythtv/external/FFmpeg/libavformat/segment.c b/mythtv/external/FFmpeg/libavformat/segment.c
index 868f0a81dad..81d3f1d9408 100644
--- a/mythtv/external/FFmpeg/libavformat/segment.c
+++ b/mythtv/external/FFmpeg/libavformat/segment.c
@@ -24,8 +24,6 @@
  * @url{http://tools.ietf.org/id/draft-pantos-http-live-streaming}
  */
 
-/* #define DEBUG */
-
 #include <float.h>
 #include <time.h>
 
@@ -87,7 +85,6 @@ typedef struct SegmentContext {
     int64_t clocktime_offset; //< clock offset for cutting the segments at regular clock time
     int64_t clocktime_wrap_duration; //< wrapping duration considered for starting a new segment
     int64_t last_val;      ///< remember last time for wrap around detection
-    int64_t last_cut;      ///< remember last cut
     int cut_pending;
     int header_written;    ///< whether we've already called avformat_write_header
 
@@ -114,7 +111,7 @@ typedef struct SegmentContext {
     int  write_header_trailer; /**< Set by a private option. */
     char *header_filename;  ///< filename to write the output header to
 
-    int reset_timestamps;  ///< reset timestamps at the begin of each segment
+    int reset_timestamps;  ///< reset timestamps at the beginning of each segment
     int64_t initial_offset;    ///< initial timestamps offset, expressed in microseconds
     char *reference_stream_specifier; ///< reference stream specifier
     int   reference_stream_index;
@@ -354,6 +351,9 @@ static int segment_end(AVFormatContext *s, int write_trailer, int is_last)
     int i;
     int err;
 
+    if (!oc || !oc->pb)
+        return AVERROR(EINVAL);
+
     av_write_frame(oc, NULL); /* Flush any buffered data (fragmented mp4) */
     if (write_trailer)
         ret = av_write_trailer(oc);
@@ -569,7 +569,7 @@ static int open_null_ctx(AVIOContext **ctx)
 static void close_null_ctxp(AVIOContext **pb)
 {
     av_freep(&(*pb)->buffer);
-    av_freep(pb);
+    avio_context_free(pb);
 }
 
 static int select_reference_stream(AVFormatContext *s)
@@ -798,9 +798,26 @@ static int seg_write_header(AVFormatContext *s)
 {
     SegmentContext *seg = s->priv_data;
     AVFormatContext *oc = seg->avf;
-    int ret;
+    int ret, i;
 
     if (!seg->header_written) {
+        for (i = 0; i < s->nb_streams; i++) {
+            AVStream *st = oc->streams[i];
+            AVCodecParameters *ipar, *opar;
+
+            ipar = s->streams[i]->codecpar;
+            opar = oc->streams[i]->codecpar;
+            avcodec_parameters_copy(opar, ipar);
+            if (!oc->oformat->codec_tag ||
+                av_codec_get_id (oc->oformat->codec_tag, ipar->codec_tag) == opar->codec_id ||
+                av_codec_get_tag(oc->oformat->codec_tag, ipar->codec_id) <= 0) {
+                opar->codec_tag = ipar->codec_tag;
+            } else {
+                opar->codec_tag = 0;
+            }
+            st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
+            st->time_base = s->streams[i]->time_base;
+        }
         ret = avformat_write_header(oc, NULL);
         if (ret < 0)
             return ret;
@@ -833,7 +850,7 @@ static int seg_write_packet(AVFormatContext *s, AVPacket *pkt)
     int64_t usecs;
     int64_t wrapped_val;
 
-    if (!seg->avf)
+    if (!seg->avf || !seg->avf->pb)
         return AVERROR(EINVAL);
 
 calc_times:
@@ -850,10 +867,8 @@ static int seg_write_packet(AVFormatContext *s, AVPacket *pkt)
             localtime_r(&sec, &ti);
             usecs = (int64_t)(ti.tm_hour * 3600 + ti.tm_min * 60 + ti.tm_sec) * 1000000 + (avgt % 1000000);
             wrapped_val = (usecs + seg->clocktime_offset) % seg->time;
-            if (seg->last_cut != usecs && wrapped_val < seg->last_val && wrapped_val < seg->clocktime_wrap_duration) {
+            if (wrapped_val < seg->last_val && wrapped_val < seg->clocktime_wrap_duration)
                 seg->cut_pending = 1;
-                seg->last_cut = usecs;
-            }
             seg->last_val = wrapped_val;
         } else {
             end_pts = seg->time * (seg->segment_count + 1);
@@ -978,6 +993,25 @@ static int seg_write_trailer(struct AVFormatContext *s)
     return ret;
 }
 
+static int seg_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
+{
+    SegmentContext *seg = s->priv_data;
+    AVFormatContext *oc = seg->avf;
+    if (oc->oformat->check_bitstream) {
+        int ret = oc->oformat->check_bitstream(oc, pkt);
+        if (ret == 1) {
+            AVStream *st = s->streams[pkt->stream_index];
+            AVStream *ost = oc->streams[pkt->stream_index];
+            st->internal->bsfcs = ost->internal->bsfcs;
+            st->internal->nb_bsfcs = ost->internal->nb_bsfcs;
+            ost->internal->bsfcs = NULL;
+            ost->internal->nb_bsfcs = 0;
+        }
+        return ret;
+    }
+    return 1;
+}
+
 #define OFFSET(x) offsetof(SegmentContext, x)
 #define E AV_OPT_FLAG_ENCODING_PARAM
 static const AVOption options[] = {
@@ -1018,7 +1052,7 @@ static const AVOption options[] = {
 
     { "individual_header_trailer", "write header/trailer to each segment", OFFSET(individual_header_trailer), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E },
     { "write_header_trailer", "write a header to the first segment and a trailer to the last one", OFFSET(write_header_trailer), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E },
-    { "reset_timestamps", "reset timestamps at the begin of each segment", OFFSET(reset_timestamps), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },
+    { "reset_timestamps", "reset timestamps at the beginning of each segment", OFFSET(reset_timestamps), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },
     { "initial_offset", "set initial timestamp offset", OFFSET(initial_offset), AV_OPT_TYPE_DURATION, {.i64 = 0}, -INT64_MAX, INT64_MAX, E },
     { "write_empty_segments", "allow writing empty 'filler' segments", OFFSET(write_empty), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },
     { NULL },
@@ -1041,6 +1075,7 @@ AVOutputFormat ff_segment_muxer = {
     .write_packet   = seg_write_packet,
     .write_trailer  = seg_write_trailer,
     .deinit         = seg_free,
+    .check_bitstream = seg_check_bitstream,
     .priv_class     = &seg_class,
 };
 
@@ -1061,5 +1096,6 @@ AVOutputFormat ff_stream_segment_muxer = {
     .write_packet   = seg_write_packet,
     .write_trailer  = seg_write_trailer,
     .deinit         = seg_free,
+    .check_bitstream = seg_check_bitstream,
     .priv_class     = &sseg_class,
 };
diff --git a/mythtv/external/FFmpeg/libavformat/sierravmd.c b/mythtv/external/FFmpeg/libavformat/sierravmd.c
index 734a3f2c1e7..6960c2868fb 100644
--- a/mythtv/external/FFmpeg/libavformat/sierravmd.c
+++ b/mythtv/external/FFmpeg/libavformat/sierravmd.c
@@ -142,13 +142,6 @@ static int vmd_read_header(AVFormatContext *s)
         st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
         st->codecpar->codec_id   = AV_CODEC_ID_VMDAUDIO;
         st->codecpar->codec_tag  = 0;  /* no fourcc */
-        if (vmd->vmd_header[811] & 0x80) {
-            st->codecpar->channels       = 2;
-            st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
-        } else {
-            st->codecpar->channels       = 1;
-            st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
-        }
         st->codecpar->sample_rate = vmd->sample_rate;
         st->codecpar->block_align = AV_RL16(&vmd->vmd_header[806]);
         if (st->codecpar->block_align & 0x8000) {
@@ -157,6 +150,19 @@ static int vmd_read_header(AVFormatContext *s)
         } else {
             st->codecpar->bits_per_coded_sample = 8;
         }
+        if (vmd->vmd_header[811] & 0x80) {
+            st->codecpar->channels       = 2;
+            st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
+        } else if (vmd->vmd_header[811] & 0x2) {
+            /* Shivers 2 stereo audio */
+            /* Frame length is for 1 channel */
+            st->codecpar->channels       = 2;
+            st->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
+            st->codecpar->block_align = st->codecpar->block_align << 1;
+        } else {
+            st->codecpar->channels       = 1;
+            st->codecpar->channel_layout = AV_CH_LAYOUT_MONO;
+        }
         st->codecpar->bit_rate = st->codecpar->sample_rate *
             st->codecpar->bits_per_coded_sample * st->codecpar->channels;
 
diff --git a/mythtv/external/FFmpeg/libavformat/smjpegenc.c b/mythtv/external/FFmpeg/libavformat/smjpegenc.c
index 314593a5c93..68a128647e3 100644
--- a/mythtv/external/FFmpeg/libavformat/smjpegenc.c
+++ b/mythtv/external/FFmpeg/libavformat/smjpegenc.c
@@ -121,7 +121,7 @@ static int smjpeg_write_trailer(AVFormatContext *s)
     AVIOContext *pb = s->pb;
     int64_t currentpos;
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         currentpos = avio_tell(pb);
         avio_seek(pb, 12, SEEK_SET);
         avio_wb32(pb, smc->duration);
diff --git a/mythtv/external/FFmpeg/libavformat/smoothstreamingenc.c b/mythtv/external/FFmpeg/libavformat/smoothstreamingenc.c
index dabd1ea304c..54a1c49caae 100644
--- a/mythtv/external/FFmpeg/libavformat/smoothstreamingenc.c
+++ b/mythtv/external/FFmpeg/libavformat/smoothstreamingenc.c
@@ -182,7 +182,7 @@ static void ism_free(AVFormatContext *s)
         if (os->ctx && os->ctx_inited)
             av_write_trailer(os->ctx);
         if (os->ctx && os->ctx->pb)
-            av_freep(&os->ctx->pb);
+            avio_context_free(&os->ctx->pb);
         if (os->ctx)
             avformat_free_context(os->ctx);
         av_freep(&os->private_str);
@@ -263,7 +263,7 @@ static int write_manifest(AVFormatContext *s, int final)
             if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
                 continue;
             last = i;
-            avio_printf(out, "<QualityLevel Index=\"%d\" Bitrate=\"%"PRId64"\" FourCC=\"%s\" MaxWidth=\"%d\" MaxHeight=\"%d\" CodecPrivateData=\"%s\" />\n", index, (int64_t)s->streams[i]->codecpar->bit_rate, os->fourcc, s->streams[i]->codecpar->width, s->streams[i]->codecpar->height, os->private_str);
+            avio_printf(out, "<QualityLevel Index=\"%d\" Bitrate=\"%"PRId64"\" FourCC=\"%s\" MaxWidth=\"%d\" MaxHeight=\"%d\" CodecPrivateData=\"%s\" />\n", index, s->streams[i]->codecpar->bit_rate, os->fourcc, s->streams[i]->codecpar->width, s->streams[i]->codecpar->height, os->private_str);
             index++;
         }
         output_chunk_list(&c->streams[last], out, final, c->lookahead_count, c->window_size);
@@ -277,7 +277,7 @@ static int write_manifest(AVFormatContext *s, int final)
             if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
                 continue;
             last = i;
-            avio_printf(out, "<QualityLevel Index=\"%d\" Bitrate=\"%"PRId64"\" FourCC=\"%s\" SamplingRate=\"%d\" Channels=\"%d\" BitsPerSample=\"16\" PacketSize=\"%d\" AudioTag=\"%d\" CodecPrivateData=\"%s\" />\n", index, (int64_t)s->streams[i]->codecpar->bit_rate, os->fourcc, s->streams[i]->codecpar->sample_rate, s->streams[i]->codecpar->channels, os->packet_size, os->audio_tag, os->private_str);
+            avio_printf(out, "<QualityLevel Index=\"%d\" Bitrate=\"%"PRId64"\" FourCC=\"%s\" SamplingRate=\"%d\" Channels=\"%d\" BitsPerSample=\"16\" PacketSize=\"%d\" AudioTag=\"%d\" CodecPrivateData=\"%s\" />\n", index, s->streams[i]->codecpar->bit_rate, os->fourcc, s->streams[i]->codecpar->sample_rate, s->streams[i]->codecpar->channels, os->packet_size, os->audio_tag, os->private_str);
             index++;
         }
         output_chunk_list(&c->streams[last], out, final, c->lookahead_count, c->window_size);
@@ -324,7 +324,7 @@ static int ism_write_header(AVFormatContext *s)
             ret = AVERROR(EINVAL);
             goto fail;
         }
-        snprintf(os->dirname, sizeof(os->dirname), "%s/QualityLevels(%"PRId64")", s->filename, (int64_t)s->streams[i]->codecpar->bit_rate);
+        snprintf(os->dirname, sizeof(os->dirname), "%s/QualityLevels(%"PRId64")", s->filename, s->streams[i]->codecpar->bit_rate);
         if (mkdir(os->dirname, 0777) == -1 && errno != EEXIST) {
             ret = AVERROR(errno);
             av_log(s, AV_LOG_ERROR, "mkdir failed\n");
@@ -647,6 +647,5 @@ AVOutputFormat ff_smoothstreaming_muxer = {
     .write_header   = ism_write_header,
     .write_packet   = ism_write_packet,
     .write_trailer  = ism_write_trailer,
-    .codec_tag      = (const AVCodecTag* const []){ ff_mp4_obj_type, 0 },
     .priv_class     = &ism_class,
 };
diff --git a/mythtv/external/FFmpeg/libavformat/smush.c b/mythtv/external/FFmpeg/libavformat/smush.c
index 5a9249ac4f9..fe544d87611 100644
--- a/mythtv/external/FFmpeg/libavformat/smush.c
+++ b/mythtv/external/FFmpeg/libavformat/smush.c
@@ -129,7 +129,6 @@ static int smush_read_header(AVFormatContext *ctx)
                 break;
             default:
                 return AVERROR_INVALIDDATA;
-                break;
             }
         }
 
diff --git a/mythtv/external/FFmpeg/libavformat/soxdec.c b/mythtv/external/FFmpeg/libavformat/soxdec.c
index 0a937e7cc74..12a94c8ffab 100644
--- a/mythtv/external/FFmpeg/libavformat/soxdec.c
+++ b/mythtv/external/FFmpeg/libavformat/soxdec.c
@@ -113,7 +113,7 @@ static int sox_read_header(AVFormatContext *s)
 
     st->codecpar->sample_rate           = sample_rate;
     st->codecpar->bits_per_coded_sample = 32;
-    st->codecpar->bit_rate              = st->codecpar->sample_rate *
+    st->codecpar->bit_rate              = (int64_t)st->codecpar->sample_rate *
                                           st->codecpar->bits_per_coded_sample *
                                           st->codecpar->channels;
     st->codecpar->block_align           = st->codecpar->bits_per_coded_sample *
diff --git a/mythtv/external/FFmpeg/libavformat/soxenc.c b/mythtv/external/FFmpeg/libavformat/soxenc.c
index b307157856f..7b37bd48484 100644
--- a/mythtv/external/FFmpeg/libavformat/soxenc.c
+++ b/mythtv/external/FFmpeg/libavformat/soxenc.c
@@ -91,7 +91,7 @@ static int sox_write_trailer(AVFormatContext *s)
     AVIOContext *pb = s->pb;
     AVCodecParameters *par = s->streams[0]->codecpar;
 
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         /* update number of samples */
         int64_t file_size = avio_tell(pb);
         int64_t num_samples = (file_size - sox->header_size - 4LL) >> 2LL;
diff --git a/mythtv/external/FFmpeg/libavformat/spdifenc.c b/mythtv/external/FFmpeg/libavformat/spdifenc.c
index daf1c1f87c2..b47ec123e8b 100644
--- a/mythtv/external/FFmpeg/libavformat/spdifenc.c
+++ b/mythtv/external/FFmpeg/libavformat/spdifenc.c
@@ -470,7 +470,8 @@ static int spdif_write_header(AVFormatContext *s)
             return AVERROR(ENOMEM);
         break;
     default:
-        av_log(s, AV_LOG_ERROR, "codec not supported\n");
+        avpriv_report_missing_feature(s, "Codec %d",
+                                      s->streams[0]->codecpar->codec_id);
         return AVERROR_PATCHWELCOME;
     }
     return 0;
diff --git a/mythtv/external/FFmpeg/libavformat/srtdec.c b/mythtv/external/FFmpeg/libavformat/srtdec.c
index 067db63f215..56bd0c43f69 100644
--- a/mythtv/external/FFmpeg/libavformat/srtdec.c
+++ b/mythtv/external/FFmpeg/libavformat/srtdec.c
@@ -78,7 +78,7 @@ static int get_event_info(const char *line, struct event_info *ei)
     ei->pts = AV_NOPTS_VALUE;
     ei->pos = -1;
     if (sscanf(line, "%d:%d:%d%*1[,.]%d --> %d:%d:%d%*1[,.]%d"
-               "%*[ ]X1:%u X2:%u Y1:%u Y2:%u",
+               "%*[ ]X1:%"PRId32" X2:%"PRId32" Y1:%"PRId32" Y2:%"PRId32,
                &hh1, &mm1, &ss1, &ms1,
                &hh2, &mm2, &ss2, &ms2,
                &ei->x1, &ei->x2, &ei->y1, &ei->y2) >= 8) {
diff --git a/mythtv/external/FFmpeg/libavformat/subfile.c b/mythtv/external/FFmpeg/libavformat/subfile.c
index fa971e19021..497cf852116 100644
--- a/mythtv/external/FFmpeg/libavformat/subfile.c
+++ b/mythtv/external/FFmpeg/libavformat/subfile.c
@@ -102,7 +102,7 @@ static int subfile_read(URLContext *h, unsigned char *buf, int size)
     int ret;
 
     if (rest <= 0)
-        return 0;
+        return AVERROR_EOF;
     size = FFMIN(size, rest);
     ret = ffurl_read(c->h, buf, size);
     if (ret >= 0)
diff --git a/mythtv/external/FFmpeg/libavformat/subtitles.c b/mythtv/external/FFmpeg/libavformat/subtitles.c
index 108f909c848..93c9ef05cf0 100644
--- a/mythtv/external/FFmpeg/libavformat/subtitles.c
+++ b/mythtv/external/FFmpeg/libavformat/subtitles.c
@@ -211,7 +211,7 @@ int ff_subtitles_queue_read_packet(FFDemuxSubtitlesQueue *q, AVPacket *pkt)
 
     if (q->current_sub_idx == q->nb_subs)
         return AVERROR_EOF;
-    if (av_copy_packet(pkt, sub) < 0) {
+    if (av_packet_ref(pkt, sub) < 0) {
         return AVERROR(ENOMEM);
     }
 
diff --git a/mythtv/external/FFmpeg/libavformat/supenc.c b/mythtv/external/FFmpeg/libavformat/supenc.c
new file mode 100644
index 00000000000..f5f6b58c87f
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavformat/supenc.c
@@ -0,0 +1,96 @@
+/*
+ * SUP muxer
+ * Copyright (c) 2014 Petri Hintukainen <phintuka@users.sourceforge.net>
+ *
+ * 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 "avformat.h"
+#include "internal.h"
+#include "libavutil/intreadwrite.h"
+
+#define SUP_PGS_MAGIC 0x5047 /* "PG", big endian */
+
+static int sup_write_packet(AVFormatContext *s, AVPacket *pkt)
+{
+    uint8_t *data = pkt->data;
+    size_t size = pkt->size;
+    uint32_t pts = 0, dts = 0;
+
+    if (pkt->pts != AV_NOPTS_VALUE) {
+        pts = (uint32_t)pkt->pts;
+    }
+    if (pkt->dts != AV_NOPTS_VALUE) {
+        dts = (uint32_t)pkt->dts;
+    }
+
+    /*
+      Split frame to segments.
+      mkvmerge stores multiple segments in one frame.
+    */
+    while (size > 2) {
+        size_t len = AV_RB16(data + 1) + 3;
+
+        if (len > size) {
+            av_log(s, AV_LOG_ERROR, "Not enough data, skipping %d bytes\n",
+                     (int)size);
+            return AVERROR_INVALIDDATA;
+        }
+
+        /* header */
+        avio_wb16(s->pb, SUP_PGS_MAGIC);
+        avio_wb32(s->pb, pts);
+        avio_wb32(s->pb, dts);
+
+        avio_write(s->pb, data, len);
+
+        data += len;
+        size -= len;
+    }
+
+    if (size > 0) {
+        av_log(s, AV_LOG_ERROR, "Skipping %d bytes after last segment in frame\n",
+                 (int)size);
+        return AVERROR_INVALIDDATA;
+    }
+
+    return 0;
+}
+
+static int sup_write_header(AVFormatContext *s)
+{
+    if (s->nb_streams != 1) {
+        av_log(s, AV_LOG_ERROR, "%s files have exactly one stream\n",
+               s->oformat->name);
+        return AVERROR(EINVAL);
+    }
+
+    avpriv_set_pts_info(s->streams[0], 32, 1, 90000);
+
+    return 0;
+}
+
+AVOutputFormat ff_sup_muxer = {
+    .name           = "sup",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw HDMV Presentation Graphic Stream subtitles"),
+    .extensions     = "sup",
+    .mime_type      = "application/x-pgs",
+    .subtitle_codec = AV_CODEC_ID_HDMV_PGS_SUBTITLE,
+    .write_header   = sup_write_header,
+    .write_packet   = sup_write_packet,
+    .flags          = AVFMT_VARIABLE_FPS | AVFMT_TS_NONSTRICT,
+};
diff --git a/mythtv/external/FFmpeg/libavformat/swfdec.c b/mythtv/external/FFmpeg/libavformat/swfdec.c
index b91560c56ce..57b619fb203 100644
--- a/mythtv/external/FFmpeg/libavformat/swfdec.c
+++ b/mythtv/external/FFmpeg/libavformat/swfdec.c
@@ -531,7 +531,7 @@ static av_cold int swf_read_close(AVFormatContext *avctx)
     inflateEnd(&s->zstream);
     av_freep(&s->zbuf_in);
     av_freep(&s->zbuf_out);
-    av_freep(&s->zpb);
+    avio_context_free(&s->zpb);
     return 0;
 }
 #endif
diff --git a/mythtv/external/FFmpeg/libavformat/swfenc.c b/mythtv/external/FFmpeg/libavformat/swfenc.c
index 3733a0442cd..cada45ef9a7 100644
--- a/mythtv/external/FFmpeg/libavformat/swfenc.c
+++ b/mythtv/external/FFmpeg/libavformat/swfenc.c
@@ -500,7 +500,7 @@ static int swf_write_trailer(AVFormatContext *s)
     put_swf_end_tag(s);
 
     /* patch file size and number of frames if not streamed */
-    if (s->pb->seekable && video_par) {
+    if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && video_par) {
         file_size = avio_tell(pb);
         avio_seek(pb, 4, SEEK_SET);
         avio_wl32(pb, file_size);
diff --git a/mythtv/external/FFmpeg/libavformat/takdec.c b/mythtv/external/FFmpeg/libavformat/takdec.c
index a8fb363b34b..1535bec64f3 100644
--- a/mythtv/external/FFmpeg/libavformat/takdec.c
+++ b/mythtv/external/FFmpeg/libavformat/takdec.c
@@ -128,7 +128,7 @@ static int tak_read_header(AVFormatContext *s)
         case TAK_METADATA_END: {
             int64_t curpos = avio_tell(pb);
 
-            if (pb->seekable) {
+            if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
                 ff_ape_parse_tag(s);
                 avio_seek(pb, curpos, SEEK_SET);
             }
diff --git a/mythtv/external/FFmpeg/libavformat/tcp.c b/mythtv/external/FFmpeg/libavformat/tcp.c
index c1054799c44..07b4ed9fa3a 100644
--- a/mythtv/external/FFmpeg/libavformat/tcp.c
+++ b/mythtv/external/FFmpeg/libavformat/tcp.c
@@ -122,6 +122,16 @@ static int tcp_open(URLContext *h, const char *uri, int flags)
     cur_ai = ai;
 
  restart:
+#if HAVE_STRUCT_SOCKADDR_IN6
+    // workaround for IOS9 getaddrinfo in IPv6 only network use hardcode IPv4 address can not resolve port number.
+    if (cur_ai->ai_family == AF_INET6){
+        struct sockaddr_in6 * sockaddr_v6 = (struct sockaddr_in6 *)cur_ai->ai_addr;
+        if (!sockaddr_v6->sin6_port){
+            sockaddr_v6->sin6_port = htons(port);
+        }
+    }
+#endif
+
     fd = ff_socket(cur_ai->ai_family,
                    cur_ai->ai_socktype,
                    cur_ai->ai_protocol);
@@ -130,6 +140,15 @@ static int tcp_open(URLContext *h, const char *uri, int flags)
         goto fail;
     }
 
+    /* Set the socket's send or receive buffer sizes, if specified.
+       If unspecified or setting fails, system default is used. */
+    if (s->recv_buffer_size > 0) {
+        setsockopt (fd, SOL_SOCKET, SO_RCVBUF, &s->recv_buffer_size, sizeof (s->recv_buffer_size));
+    }
+    if (s->send_buffer_size > 0) {
+        setsockopt (fd, SOL_SOCKET, SO_SNDBUF, &s->send_buffer_size, sizeof (s->send_buffer_size));
+    }
+
     if (s->listen == 2) {
         // multi-client
         if ((ret = ff_listen(fd, cur_ai->ai_addr, cur_ai->ai_addrlen)) < 0)
@@ -154,14 +173,6 @@ static int tcp_open(URLContext *h, const char *uri, int flags)
 
     h->is_streamed = 1;
     s->fd = fd;
-    /* Set the socket's send or receive buffer sizes, if specified.
-       If unspecified or setting fails, system default is used. */
-    if (s->recv_buffer_size > 0) {
-        setsockopt (fd, SOL_SOCKET, SO_RCVBUF, &s->recv_buffer_size, sizeof (s->recv_buffer_size));
-    }
-    if (s->send_buffer_size > 0) {
-        setsockopt (fd, SOL_SOCKET, SO_SNDBUF, &s->send_buffer_size, sizeof (s->send_buffer_size));
-    }
 
     freeaddrinfo(ai);
     return 0;
@@ -193,7 +204,7 @@ static int tcp_accept(URLContext *s, URLContext **c)
     cc = (*c)->priv_data;
     ret = ff_accept(sc->fd, sc->listen_timeout, s);
     if (ret < 0)
-        return ff_neterrno();
+        return ret;
     cc->fd = ret;
     return 0;
 }
@@ -255,6 +266,26 @@ static int tcp_get_file_handle(URLContext *h)
     return s->fd;
 }
 
+static int tcp_get_window_size(URLContext *h)
+{
+    TCPContext *s = h->priv_data;
+    int avail;
+    int avail_len = sizeof(avail);
+
+#if HAVE_WINSOCK2_H
+    /* SO_RCVBUF with winsock only reports the actual TCP window size when
+    auto-tuning has been disabled via setting SO_RCVBUF */
+    if (s->recv_buffer_size < 0) {
+        return AVERROR(ENOSYS);
+    }
+#endif
+
+    if (getsockopt(s->fd, SOL_SOCKET, SO_RCVBUF, &avail, &avail_len)) {
+        return ff_neterrno();
+    }
+    return avail;
+}
+
 const URLProtocol ff_tcp_protocol = {
     .name                = "tcp",
     .url_open            = tcp_open,
@@ -263,6 +294,7 @@ const URLProtocol ff_tcp_protocol = {
     .url_write           = tcp_write,
     .url_close           = tcp_close,
     .url_get_file_handle = tcp_get_file_handle,
+    .url_get_short_seek  = tcp_get_window_size,
     .url_shutdown        = tcp_shutdown,
     .priv_data_size      = sizeof(TCPContext),
     .flags               = URL_PROTOCOL_FLAG_NETWORK,
diff --git a/mythtv/external/FFmpeg/libavformat/tee.c b/mythtv/external/FFmpeg/libavformat/tee.c
index d59ad4d183b..dd1844ac0e1 100644
--- a/mythtv/external/FFmpeg/libavformat/tee.c
+++ b/mythtv/external/FFmpeg/libavformat/tee.c
@@ -40,6 +40,8 @@ typedef struct {
     AVBSFContext **bsfs; ///< bitstream filters per stream
 
     SlaveFailurePolicy on_fail;
+    int use_fifo;
+    AVDictionary *fifo_options;
 
     /** map from input to output streams indexes,
      * disabled output streams are set to -1 */
@@ -52,15 +54,28 @@ typedef struct TeeContext {
     unsigned nb_slaves;
     unsigned nb_alive;
     TeeSlave *slaves;
+    int use_fifo;
+    AVDictionary *fifo_options;
+    char *fifo_options_str;
 } TeeContext;
 
 static const char *const slave_delim     = "|";
 static const char *const slave_bsfs_spec_sep = "/";
 static const char *const slave_select_sep = ",";
 
+#define OFFSET(x) offsetof(TeeContext, x)
+static const AVOption options[] = {
+        {"use_fifo", "Use fifo pseudo-muxer to separate actual muxers from encoder",
+         OFFSET(use_fifo), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
+        {"fifo_options", "fifo pseudo-muxer options", OFFSET(fifo_options_str),
+         AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, AV_OPT_FLAG_ENCODING_PARAM},
+        {NULL}
+};
+
 static const AVClass tee_muxer_class = {
     .class_name = "Tee muxer",
     .item_name  = av_default_item_name,
+    .option = options,
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
@@ -81,6 +96,29 @@ static inline int parse_slave_failure_policy_option(const char *opt, TeeSlave *t
     return AVERROR(EINVAL);
 }
 
+static int parse_slave_fifo_options(const char *use_fifo,
+                                    const char *fifo_options, TeeSlave *tee_slave)
+{
+    int ret = 0;
+
+    if (use_fifo) {
+        /*TODO - change this to use proper function for parsing boolean
+         *       options when there is one */
+        if (av_match_name(use_fifo, "true,y,yes,enable,enabled,on,1")) {
+            tee_slave->use_fifo = 1;
+        } else if (av_match_name(use_fifo, "false,n,no,disable,disabled,off,0")) {
+            tee_slave->use_fifo = 0;
+        } else {
+            return AVERROR(EINVAL);
+        }
+    }
+
+    if (fifo_options)
+        ret = av_dict_parse_string(&tee_slave->fifo_options, fifo_options, "=", ":", 0);
+
+    return ret;
+}
+
 static int close_slave(TeeSlave *tee_slave)
 {
     AVFormatContext *avf;
@@ -125,6 +163,7 @@ static int open_slave(AVFormatContext *avf, char *slave, TeeSlave *tee_slave)
     AVDictionaryEntry *entry;
     char *filename;
     char *format = NULL, *select = NULL, *on_fail = NULL;
+    char *use_fifo = NULL, *fifo_options_str = NULL;
     AVFormatContext *avf2 = NULL;
     AVStream *st, *st2;
     int stream_count;
@@ -145,6 +184,8 @@ static int open_slave(AVFormatContext *avf, char *slave, TeeSlave *tee_slave)
     STEAL_OPTION("f", format);
     STEAL_OPTION("select", select);
     STEAL_OPTION("onfail", on_fail);
+    STEAL_OPTION("use_fifo", use_fifo);
+    STEAL_OPTION("fifo_options", fifo_options_str);
 
     ret = parse_slave_failure_policy_option(on_fail, tee_slave);
     if (ret < 0) {
@@ -153,7 +194,39 @@ static int open_slave(AVFormatContext *avf, char *slave, TeeSlave *tee_slave)
         goto end;
     }
 
-    ret = avformat_alloc_output_context2(&avf2, NULL, format, filename);
+    ret = parse_slave_fifo_options(use_fifo, fifo_options_str, tee_slave);
+    if (ret < 0) {
+        av_log(avf, AV_LOG_ERROR, "Error parsing fifo options: %s\n", av_err2str(ret));
+        goto end;
+    }
+
+    if (tee_slave->use_fifo) {
+
+        if (options) {
+            char *format_options_str = NULL;
+            ret = av_dict_get_string(options, &format_options_str, '=', ':');
+            if (ret < 0)
+                goto end;
+
+            ret = av_dict_set(&tee_slave->fifo_options, "format_opts", format_options_str,
+                              AV_DICT_DONT_STRDUP_VAL);
+            if (ret < 0)
+                goto end;
+        }
+
+        if (format) {
+            ret = av_dict_set(&tee_slave->fifo_options, "fifo_format", format,
+                              AV_DICT_DONT_STRDUP_VAL);
+            format = NULL;
+            if (ret < 0)
+                goto end;
+        }
+
+        av_dict_free(&options);
+        options = tee_slave->fifo_options;
+    }
+    ret = avformat_alloc_output_context2(&avf2, NULL,
+                                         tee_slave->use_fifo ? "fifo" :format, filename);
     if (ret < 0)
         goto end;
     tee_slave->avf = avf2;
@@ -394,6 +467,12 @@ static int tee_write_header(AVFormatContext *avf)
             filename++;
     }
 
+    if (tee->fifo_options_str) {
+        ret = av_dict_parse_string(&tee->fifo_options, tee->fifo_options_str, "=", ":", 0);
+        if (ret < 0)
+            goto fail;
+    }
+
     if (!(tee->slaves = av_mallocz_array(nb_slaves, sizeof(*tee->slaves)))) {
         ret = AVERROR(ENOMEM);
         goto fail;
@@ -401,6 +480,12 @@ static int tee_write_header(AVFormatContext *avf)
     tee->nb_slaves = tee->nb_alive = nb_slaves;
 
     for (i = 0; i < nb_slaves; i++) {
+
+        tee->slaves[i].use_fifo = tee->use_fifo;
+        ret = av_dict_copy(&tee->slaves[i].fifo_options, tee->fifo_options, 0);
+        if (ret < 0)
+            goto fail;
+
         if ((ret = open_slave(avf, slaves[i], &tee->slaves[i])) < 0) {
             ret = tee_process_slave_failure(avf, i, ret);
             if (ret < 0)
diff --git a/mythtv/external/FFmpeg/libavformat/tests/fifo_muxer.c b/mythtv/external/FFmpeg/libavformat/tests/fifo_muxer.c
index 9659198ff17..e20bd6e7b2b 100644
--- a/mythtv/external/FFmpeg/libavformat/tests/fifo_muxer.c
+++ b/mythtv/external/FFmpeg/libavformat/tests/fifo_muxer.c
@@ -25,6 +25,7 @@
 #include "libavutil/avassert.h"
 #include "libavformat/avformat.h"
 #include "libavformat/url.h"
+#include "libavformat/network.h"
 
 #define MAX_TST_PACKETS 128
 #define SLEEPTIME_50_MS 50000
@@ -150,6 +151,9 @@ static int prepare_packet(AVPacket *pkt,const FailingMuxerPacketData *pkt_data,
 {
     int ret;
     FailingMuxerPacketData *data = av_malloc(sizeof(*data));
+    if (!data) {
+        return AVERROR(ENOMEM);
+    }
     memcpy(data, pkt_data, sizeof(FailingMuxerPacketData));
     ret = av_packet_from_data(pkt, (uint8_t*) data, sizeof(*data));
 
diff --git a/mythtv/external/FFmpeg/libavformat/tests/movenc.c b/mythtv/external/FFmpeg/libavformat/tests/movenc.c
index ab871765d93..8e59b74259e 100644
--- a/mythtv/external/FFmpeg/libavformat/tests/movenc.c
+++ b/mythtv/external/FFmpeg/libavformat/tests/movenc.c
@@ -344,7 +344,7 @@ static void signal_init_ts(void)
 static void finish(void)
 {
     av_write_trailer(ctx);
-    av_free(ctx->pb);
+    avio_context_free(&ctx->pb);
     avformat_free_context(ctx);
     ctx = NULL;
 }
@@ -766,6 +766,25 @@ int main(int argc, char **argv)
     clear_duration = 0;
     do_interleave = 0;
 
+    // Write a fragmented file with b-frames and audio preroll,
+    // with negative cts values, removing the edit list for the
+    // video track.
+    init_out("delay-moov-elst-neg-cts");
+    av_dict_set(&opts, "movflags", "frag_keyframe+delay_moov+negative_cts_offsets", 0);
+    init(1, 1);
+    mux_gops(2);
+    finish();
+    close_out();
+
+    // Write a fragmented file with b-frames without audio preroll,
+    // with negative cts values, avoiding any edit lists, allowing
+    // to use empty_moov instead of delay_moov.
+    init_out("empty-moov-neg-cts");
+    av_dict_set(&opts, "movflags", "frag_keyframe+empty_moov+negative_cts_offsets", 0);
+    init(1, 0);
+    mux_gops(2);
+    finish();
+    close_out();
 
     av_free(md5);
 
diff --git a/mythtv/external/FFmpeg/libavformat/tests/rtmpdh.c b/mythtv/external/FFmpeg/libavformat/tests/rtmpdh.c
index 929b3f3ff27..77139a539c8 100644
--- a/mythtv/external/FFmpeg/libavformat/tests/rtmpdh.c
+++ b/mythtv/external/FFmpeg/libavformat/tests/rtmpdh.c
@@ -16,6 +16,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavformat/avformat.h"
 #include "libavformat/rtmpdh.c"
 
 #include <stdio.h>
@@ -150,6 +151,7 @@ static int test_ref_data(void)
 
 int main(void)
 {
+    avformat_network_init();
     if (test_random_shared_secret() < 0)
         return 1;
     if (test_ref_data() < 0)
diff --git a/mythtv/external/FFmpeg/libavformat/tests/seek.c b/mythtv/external/FFmpeg/libavformat/tests/seek.c
index 7ed56ba4ef9..5cf3a123e33 100644
--- a/mythtv/external/FFmpeg/libavformat/tests/seek.c
+++ b/mythtv/external/FFmpeg/libavformat/tests/seek.c
@@ -67,6 +67,8 @@ int main(int argc, char **argv)
     int frame_count = 1;
     int duration = 4;
 
+    ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
+
     for(i=2; i<argc; i+=2){
         if       (!strcmp(argv[i], "-seekforw")){
             seekfirst = atoi(argv[i+1]);
diff --git a/mythtv/external/FFmpeg/libavformat/tls_gnutls.c b/mythtv/external/FFmpeg/libavformat/tls_gnutls.c
index 991b36b95fc..5ce6c3d448c 100644
--- a/mythtv/external/FFmpeg/libavformat/tls_gnutls.c
+++ b/mythtv/external/FFmpeg/libavformat/tls_gnutls.c
@@ -35,6 +35,10 @@
 #include "libavutil/opt.h"
 #include "libavutil/parseutils.h"
 
+#ifndef GNUTLS_VERSION_NUMBER
+#define GNUTLS_VERSION_NUMBER LIBGNUTLS_VERSION_NUMBER
+#endif
+
 #if HAVE_THREADS && GNUTLS_VERSION_NUMBER <= 0x020b00
 #include <gcrypt.h>
 #include "libavutil/thread.h"
@@ -72,6 +76,9 @@ static int print_tls_error(URLContext *h, int ret)
     switch (ret) {
     case GNUTLS_E_AGAIN:
     case GNUTLS_E_INTERRUPTED:
+#ifdef GNUTLS_E_PREMATURE_TERMINATION
+    case GNUTLS_E_PREMATURE_TERMINATION:
+#endif
         break;
     case GNUTLS_E_WARNING_ALERT_RECEIVED:
         av_log(h, AV_LOG_WARNING, "%s\n", gnutls_strerror(ret));
@@ -235,6 +242,12 @@ static int tls_write(URLContext *h, const uint8_t *buf, int size)
     return print_tls_error(h, ret);
 }
 
+static int tls_get_file_handle(URLContext *h)
+{
+    TLSContext *c = h->priv_data;
+    return ffurl_get_file_handle(c->tls_shared.tcp);
+}
+
 static const AVOption options[] = {
     TLS_COMMON_OPTIONS(TLSContext, tls_shared),
     { NULL }
@@ -253,6 +266,7 @@ const URLProtocol ff_tls_gnutls_protocol = {
     .url_read       = tls_read,
     .url_write      = tls_write,
     .url_close      = tls_close,
+    .url_get_file_handle = tls_get_file_handle,
     .priv_data_size = sizeof(TLSContext),
     .flags          = URL_PROTOCOL_FLAG_NETWORK,
     .priv_data_class = &tls_class,
diff --git a/mythtv/external/FFmpeg/libavformat/tls_openssl.c b/mythtv/external/FFmpeg/libavformat/tls_openssl.c
index c551ac74e24..38af8a21c00 100644
--- a/mythtv/external/FFmpeg/libavformat/tls_openssl.c
+++ b/mythtv/external/FFmpeg/libavformat/tls_openssl.c
@@ -86,17 +86,15 @@ static int url_bio_destroy(BIO *b)
 }
 
 #if OPENSSL_VERSION_NUMBER >= 0x1010000fL
-#define GET_BIO_DATA(x) BIO_get_data(x);
+#define GET_BIO_DATA(x) BIO_get_data(x)
 #else
-#define GET_BIO_DATA(x) (x)->ptr;
+#define GET_BIO_DATA(x) (x)->ptr
 #endif
 
 static int url_bio_bread(BIO *b, char *buf, int len)
 {
-    URLContext *h;
-    int ret;
-    h = GET_BIO_DATA(b);
-    ret = ffurl_read(h, buf, len);
+    URLContext *h = GET_BIO_DATA(b);
+    int ret = ffurl_read(h, buf, len);
     if (ret >= 0)
         return ret;
     BIO_clear_retry_flags(b);
@@ -107,10 +105,8 @@ static int url_bio_bread(BIO *b, char *buf, int len)
 
 static int url_bio_bwrite(BIO *b, const char *buf, int len)
 {
-    URLContext *h;
-    int ret;
-    h = GET_BIO_DATA(b);
-    ret = ffurl_write(h, buf, len);
+    URLContext *h = GET_BIO_DATA(b);
+    int ret = ffurl_write(h, buf, len);
     if (ret >= 0)
         return ret;
     BIO_clear_retry_flags(b);
@@ -233,12 +229,17 @@ static int tls_open(URLContext *h, const char *uri, int flags, AVDictionary **op
     if ((ret = ff_tls_open_underlying(c, h, uri, options)) < 0)
         goto fail;
 
-    p->ctx = SSL_CTX_new(c->listen ? TLSv1_server_method() : TLSv1_client_method());
+    // We want to support all versions of TLS >= 1.0, but not the deprecated
+    // and insecure SSLv2 and SSLv3.  Despite the name, SSLv23_*_method()
+    // enables support for all versions of SSL and TLS, and we then disable
+    // support for the old protocols immediately after creating the context.
+    p->ctx = SSL_CTX_new(c->listen ? SSLv23_server_method() : SSLv23_client_method());
     if (!p->ctx) {
         av_log(h, AV_LOG_ERROR, "%s\n", ERR_error_string(ERR_get_error(), NULL));
         ret = AVERROR(EIO);
         goto fail;
     }
+    SSL_CTX_set_options(p->ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
     if (c->ca_file) {
         if (!SSL_CTX_load_verify_locations(p->ctx, c->ca_file, NULL))
             av_log(h, AV_LOG_ERROR, "SSL_CTX_load_verify_locations %s\n", ERR_error_string(ERR_get_error(), NULL));
@@ -320,6 +321,12 @@ static int tls_write(URLContext *h, const uint8_t *buf, int size)
     return print_tls_error(h, ret);
 }
 
+static int tls_get_file_handle(URLContext *h)
+{
+    TLSContext *c = h->priv_data;
+    return ffurl_get_file_handle(c->tls_shared.tcp);
+}
+
 static const AVOption options[] = {
     TLS_COMMON_OPTIONS(TLSContext, tls_shared),
     { NULL }
@@ -338,6 +345,7 @@ const URLProtocol ff_tls_openssl_protocol = {
     .url_read       = tls_read,
     .url_write      = tls_write,
     .url_close      = tls_close,
+    .url_get_file_handle = tls_get_file_handle,
     .priv_data_size = sizeof(TLSContext),
     .flags          = URL_PROTOCOL_FLAG_NETWORK,
     .priv_data_class = &tls_class,
diff --git a/mythtv/external/FFmpeg/libavformat/tls_schannel.c b/mythtv/external/FFmpeg/libavformat/tls_schannel.c
index c11b7d42cf0..9f1c08806fe 100644
--- a/mythtv/external/FFmpeg/libavformat/tls_schannel.c
+++ b/mythtv/external/FFmpeg/libavformat/tls_schannel.c
@@ -494,7 +494,7 @@ static int tls_read(URLContext *h, uint8_t *buf, int len)
             ret = AVERROR(EAGAIN);
             goto cleanup;
         } else {
-            av_log(h, AV_LOG_ERROR, "Unable to decrypt message\n");
+            av_log(h, AV_LOG_ERROR, "Unable to decrypt message (error 0x%x)\n", (unsigned)sspi_ret);
             ret = AVERROR(EIO);
             goto cleanup;
         }
@@ -577,6 +577,12 @@ static int tls_write(URLContext *h, const uint8_t *buf, int len)
     return ret < 0 ? ret : outbuf[1].cbBuffer;
 }
 
+static int tls_get_file_handle(URLContext *h)
+{
+    TLSContext *c = h->priv_data;
+    return ffurl_get_file_handle(c->tls_shared.tcp);
+}
+
 static const AVOption options[] = {
     TLS_COMMON_OPTIONS(TLSContext, tls_shared),
     { NULL }
@@ -595,6 +601,7 @@ const URLProtocol ff_tls_schannel_protocol = {
     .url_read       = tls_read,
     .url_write      = tls_write,
     .url_close      = tls_close,
+    .url_get_file_handle = tls_get_file_handle,
     .priv_data_size = sizeof(TLSContext),
     .flags          = URL_PROTOCOL_FLAG_NETWORK,
     .priv_data_class = &tls_class,
diff --git a/mythtv/external/FFmpeg/libavformat/tls_securetransport.c b/mythtv/external/FFmpeg/libavformat/tls_securetransport.c
index 253c89c5ab2..bc8a32069e2 100644
--- a/mythtv/external/FFmpeg/libavformat/tls_securetransport.c
+++ b/mythtv/external/FFmpeg/libavformat/tls_securetransport.c
@@ -375,6 +375,12 @@ static int tls_write(URLContext *h, const uint8_t *buf, int size)
     return print_tls_error(h, ret);
 }
 
+static int tls_get_file_handle(URLContext *h)
+{
+    TLSContext *c = h->priv_data;
+    return ffurl_get_file_handle(c->tls_shared.tcp);
+}
+
 static const AVOption options[] = {
     TLS_COMMON_OPTIONS(TLSContext, tls_shared),
     { NULL }
@@ -393,6 +399,7 @@ const URLProtocol ff_tls_securetransport_protocol = {
     .url_read       = tls_read,
     .url_write      = tls_write,
     .url_close      = tls_close,
+    .url_get_file_handle = tls_get_file_handle,
     .priv_data_size = sizeof(TLSContext),
     .flags          = URL_PROTOCOL_FLAG_NETWORK,
     .priv_data_class = &tls_class,
diff --git a/mythtv/external/FFmpeg/libavformat/tta.c b/mythtv/external/FFmpeg/libavformat/tta.c
index 1447effcd89..ae90a85544c 100644
--- a/mythtv/external/FFmpeg/libavformat/tta.c
+++ b/mythtv/external/FFmpeg/libavformat/tta.c
@@ -136,7 +136,7 @@ static int tta_read_header(AVFormatContext *s)
     st->codecpar->sample_rate = samplerate;
     st->codecpar->bits_per_coded_sample = bps;
 
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         int64_t pos = avio_tell(s->pb);
         ff_ape_parse_tag(s);
         avio_seek(s->pb, pos, SEEK_SET);
diff --git a/mythtv/external/FFmpeg/libavformat/tty.c b/mythtv/external/FFmpeg/libavformat/tty.c
index b407645ee4b..8d48f2c45c1 100644
--- a/mythtv/external/FFmpeg/libavformat/tty.c
+++ b/mythtv/external/FFmpeg/libavformat/tty.c
@@ -94,7 +94,7 @@ static int read_header(AVFormatContext *avctx)
     /* simulate tty display speed */
     s->chars_per_frame = FFMAX(av_q2d(st->time_base)*s->chars_per_frame, 1);
 
-    if (avctx->pb->seekable) {
+    if (avctx->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         s->fsize = avio_size(avctx->pb);
         st->duration = (s->fsize + s->chars_per_frame - 1) / s->chars_per_frame;
 
diff --git a/mythtv/external/FFmpeg/libavformat/uncodedframecrcenc.c b/mythtv/external/FFmpeg/libavformat/uncodedframecrcenc.c
index 5e1a445f4fa..2f1a14ca971 100644
--- a/mythtv/external/FFmpeg/libavformat/uncodedframecrcenc.c
+++ b/mythtv/external/FFmpeg/libavformat/uncodedframecrcenc.c
@@ -79,7 +79,7 @@ static void audio_frame_cksum(AVBPrint *bp, AVFrame *frame)
     int nb_planes, nb_samples, p;
     const char *name;
 
-    nb_planes  = av_frame_get_channels(frame);
+    nb_planes  = frame->channels;
     nb_samples = frame->nb_samples;
     if (!av_sample_fmt_is_planar(frame->format)) {
         nb_samples *= nb_planes;
@@ -115,7 +115,7 @@ static void audio_frame_cksum(AVBPrint *bp, AVFrame *frame)
         default:
             av_assert0(!"reached");
         }
-        av_bprintf(bp, ", 0x%08x", cksum);
+        av_bprintf(bp, ", 0x%08"PRIx32, cksum);
     }
 }
 
diff --git a/mythtv/external/FFmpeg/libavformat/url.h b/mythtv/external/FFmpeg/libavformat/url.h
index 5c5024553e8..4750bfff825 100644
--- a/mythtv/external/FFmpeg/libavformat/url.h
+++ b/mythtv/external/FFmpeg/libavformat/url.h
@@ -48,6 +48,7 @@ typedef struct URLContext {
     int64_t rw_timeout;         /**< maximum time to wait for (network) read/write operation completion, in mcs */
     const char *protocol_whitelist;
     const char *protocol_blacklist;
+    int min_packet_size;        /**< if non zero, the stream is packetized with this min packet size */
 } URLContext;
 
 typedef struct URLProtocol {
@@ -84,6 +85,7 @@ typedef struct URLProtocol {
     int (*url_get_file_handle)(URLContext *h);
     int (*url_get_multi_file_handle)(URLContext *h, int **handles,
                                      int *numhandles);
+    int (*url_get_short_seek)(URLContext *h);
     int (*url_shutdown)(URLContext *h, int flags);
     int priv_data_size;
     const AVClass *priv_data_class;
@@ -248,6 +250,13 @@ int ffurl_get_file_handle(URLContext *h);
  */
 int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles);
 
+/**
+ * Return the current short seek threshold value for this URL.
+ *
+ * @return threshold (>0) on success or <=0 on error.
+ */
+int ffurl_get_short_seek(URLContext *h);
+
 /**
  * Signal the URLContext that we are done reading or writing the stream.
  *
diff --git a/mythtv/external/FFmpeg/libavformat/utils.c b/mythtv/external/FFmpeg/libavformat/utils.c
index 9be7eee13ea..6850d16d056 100644
--- a/mythtv/external/FFmpeg/libavformat/utils.c
+++ b/mythtv/external/FFmpeg/libavformat/utils.c
@@ -336,6 +336,7 @@ static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
         { "hevc",      AV_CODEC_ID_HEVC,       AVMEDIA_TYPE_VIDEO },
         { "loas",      AV_CODEC_ID_AAC_LATM,   AVMEDIA_TYPE_AUDIO },
         { "m4v",       AV_CODEC_ID_MPEG4,      AVMEDIA_TYPE_VIDEO },
+        { "mjpeg_2000",AV_CODEC_ID_JPEG2000,   AVMEDIA_TYPE_VIDEO },
         { "mp3",       AV_CODEC_ID_MP3,        AVMEDIA_TYPE_AUDIO },
         { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
         { "truehd",    AV_CODEC_ID_TRUEHD,     AVMEDIA_TYPE_AUDIO },
@@ -488,6 +489,12 @@ static int update_stream_avctx(AVFormatContext *s)
         if (!st->internal->need_context_update)
             continue;
 
+        /* close parser, because it depends on the codec */
+        if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
+            av_parser_close(st->parser);
+            st->parser = NULL;
+        }
+
         /* update internal codec context, for the parser */
         ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
         if (ret < 0)
@@ -534,6 +541,7 @@ int avformat_open_input(AVFormatContext **ps, const char *filename,
     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
         goto fail;
 
+    av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
     if ((ret = init_input(s, filename, &tmp)) < 0)
         goto fail;
     s->probe_score = ret;
@@ -572,7 +580,6 @@ int avformat_open_input(AVFormatContext **ps, const char *filename,
 
     s->build_index = 1;
     s->duration = s->start_time = AV_NOPTS_VALUE;
-    av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
 
     /* Allocate private data. */
     if (s->iformat->priv_data_size > 0) {
@@ -590,17 +597,33 @@ int avformat_open_input(AVFormatContext **ps, const char *filename,
 
     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
     if (s->pb)
-        ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
+        ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
+
 
     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
         if ((ret = s->iformat->read_header(s)) < 0)
             goto fail;
 
+    if (!s->metadata) {
+        s->metadata = s->internal->id3v2_meta;
+        s->internal->id3v2_meta = NULL;
+    } else if (s->internal->id3v2_meta) {
+        int level = AV_LOG_WARNING;
+        if (s->error_recognition & AV_EF_COMPLIANT)
+            level = AV_LOG_ERROR;
+        av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
+        av_dict_free(&s->internal->id3v2_meta);
+        if (s->error_recognition & AV_EF_EXPLODE)
+            return AVERROR_INVALIDDATA;
+    }
+
     if (id3v2_extra_meta) {
         if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
             !strcmp(s->iformat->name, "tta")) {
             if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
                 goto fail;
+            if ((ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0)
+                goto fail;
         } else
             av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
     }
@@ -885,12 +908,13 @@ int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
 
 static int determinable_frame_size(AVCodecContext *avctx)
 {
-    if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
-        avctx->codec_id == AV_CODEC_ID_MP1 ||
-        avctx->codec_id == AV_CODEC_ID_MP2 ||
-        avctx->codec_id == AV_CODEC_ID_MP3/* ||
-        avctx->codec_id == AV_CODEC_ID_CELT*/)
+    switch(avctx->codec_id) {
+    case AV_CODEC_ID_MP1:
+    case AV_CODEC_ID_MP2:
+    case AV_CODEC_ID_MP3:
         return 1;
+    }
+
     return 0;
 }
 
@@ -1164,8 +1188,11 @@ static void update_initial_durations(AVFormatContext *s, AVStream *st,
     for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
         if (pktl->pkt.stream_index != stream_index)
             continue;
-        if (pktl->pkt.pts == pktl->pkt.dts  &&
-            (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
+        if ((pktl->pkt.pts == pktl->pkt.dts ||
+             pktl->pkt.pts == AV_NOPTS_VALUE) &&
+            (pktl->pkt.dts == AV_NOPTS_VALUE ||
+             pktl->pkt.dts == st->first_dts ||
+             pktl->pkt.dts == RELATIVE_TS_BASE) &&
             !pktl->pkt.duration) {
             pktl->pkt.dts = cur_dts;
             if (!st->internal->avctx->has_b_frames)
@@ -1543,6 +1570,12 @@ static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
                 st->info->found_decoder = 0;
             }
 
+            /* close parser, because it depends on the codec */
+            if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
+                av_parser_close(st->parser);
+                st->parser = NULL;
+            }
+
             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
             if (ret < 0)
                 return ret;
@@ -1675,8 +1708,12 @@ FF_ENABLE_DEPRECATION_WARNINGS
             st->inject_global_side_data = 0;
         }
 
+#if FF_API_LAVF_MERGE_SD
+FF_DISABLE_DEPRECATION_WARNINGS
         if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
             av_packet_merge_side_data(pkt);
+FF_ENABLE_DEPRECATION_WARNINGS
+#endif
     }
 
     av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
@@ -1731,10 +1768,11 @@ int av_read_frame(AVFormatContext *s, AVPacket *pkt)
                 // last dts seen for this stream. if any of packets following
                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
                 int64_t last_dts = next_pkt->dts;
+                av_assert2(wrap_bits <= 64);
                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
-                        (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
-                        if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
+                        av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
+                        if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
                             // not B-frame
                             next_pkt->pts = pktl->pkt.dts;
                         }
@@ -2002,7 +2040,7 @@ int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
         m         = (a + b) >> 1;
 
         // Search for the next non-discarded packet.
-        while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b) {
+        while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
             m++;
             if (m == b && entries[m].timestamp >= wanted_timestamp) {
                 m = b - 1;
@@ -2619,11 +2657,14 @@ static void update_stream_timings(AVFormatContext *ic)
             if (ic->nb_programs > 1) {
                 for (i = 0; i < ic->nb_programs; i++) {
                     p = ic->programs[i];
-                    if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
+                    if (p->start_time != AV_NOPTS_VALUE &&
+                        p->end_time > p->start_time &&
+                        p->end_time - (uint64_t)p->start_time <= INT64_MAX)
                         duration = FFMAX(duration, p->end_time - p->start_time);
                 }
-            } else
+            } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
                 duration = FFMAX(duration, end_time - start_time);
+            }
         }
     }
     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
@@ -2874,7 +2915,7 @@ void estimate_timings(AVFormatContext *ic, int64_t old_offset)
 
     if ((!strcmp(ic->iformat->name, "mpeg") ||
          !strcmp(ic->iformat->name, "mpegts")) &&
-        file_size && ic->pb->seekable) {
+        file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
         /* get accurate estimate from the PTSes */
         estimate_timings_from_pts(ic, old_offset);
         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
@@ -3183,7 +3224,7 @@ static void compute_chapters_end(AVFormatContext *s)
                 if (j != i && next_start > ch->start && next_start < end)
                     end = next_start;
             }
-            ch->end = (end == INT64_MAX) ? ch->start : end;
+            ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
         }
 }
 
@@ -3387,6 +3428,127 @@ void ff_rfps_calculate(AVFormatContext *ic)
     }
 }
 
+static int extract_extradata_check(AVStream *st)
+{
+    const AVBitStreamFilter *f;
+
+    f = av_bsf_get_by_name("extract_extradata");
+    if (!f)
+        return 0;
+
+    if (f->codec_ids) {
+        const enum AVCodecID *ids;
+        for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
+            if (*ids == st->codecpar->codec_id)
+                return 1;
+    }
+
+    return 0;
+}
+
+static int extract_extradata_init(AVStream *st)
+{
+    AVStreamInternal *i = st->internal;
+    const AVBitStreamFilter *f;
+    int ret;
+
+    f = av_bsf_get_by_name("extract_extradata");
+    if (!f)
+        goto finish;
+
+    /* check that the codec id is supported */
+    ret = extract_extradata_check(st);
+    if (!ret)
+        goto finish;
+
+    i->extract_extradata.pkt = av_packet_alloc();
+    if (!i->extract_extradata.pkt)
+        return AVERROR(ENOMEM);
+
+    ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
+    if (ret < 0)
+        goto fail;
+
+    ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
+                                  st->codecpar);
+    if (ret < 0)
+        goto fail;
+
+    i->extract_extradata.bsf->time_base_in = st->time_base;
+
+    /* if init fails here, we assume extracting extradata is just not
+     * supported for this codec, so we return success */
+    ret = av_bsf_init(i->extract_extradata.bsf);
+    if (ret < 0) {
+        av_bsf_free(&i->extract_extradata.bsf);
+        ret = 0;
+    }
+
+finish:
+    i->extract_extradata.inited = 1;
+
+    return 0;
+fail:
+    av_bsf_free(&i->extract_extradata.bsf);
+    av_packet_free(&i->extract_extradata.pkt);
+    return ret;
+}
+
+static int extract_extradata(AVStream *st, AVPacket *pkt)
+{
+    AVStreamInternal *i = st->internal;
+    AVPacket *pkt_ref;
+    int ret;
+
+    if (!i->extract_extradata.inited) {
+        ret = extract_extradata_init(st);
+        if (ret < 0)
+            return ret;
+    }
+
+    if (i->extract_extradata.inited && !i->extract_extradata.bsf)
+        return 0;
+
+    pkt_ref = i->extract_extradata.pkt;
+    ret = av_packet_ref(pkt_ref, pkt);
+    if (ret < 0)
+        return ret;
+
+    ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
+    if (ret < 0) {
+        av_packet_unref(pkt_ref);
+        return ret;
+    }
+
+    while (ret >= 0 && !i->avctx->extradata) {
+        int extradata_size;
+        uint8_t *extradata;
+
+        ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
+        if (ret < 0) {
+            if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
+                return ret;
+            continue;
+        }
+
+        extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
+                                            &extradata_size);
+
+        if (extradata) {
+            i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
+            if (!i->avctx->extradata) {
+                av_packet_unref(pkt_ref);
+                return AVERROR(ENOMEM);
+            }
+            memcpy(i->avctx->extradata, extradata, extradata_size);
+            i->avctx->extradata_size = extradata_size;
+        }
+        av_packet_unref(pkt_ref);
+    }
+
+    return 0;
+}
+
 /* absolute maximum size we read until we abort */
 #define MAX_READ_SIZE        5000000
 
@@ -3409,6 +3571,7 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
     int64_t max_subtitle_analyze_duration;
     int64_t probesize = ic->probesize;
     int eof_reached = 0;
+    int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
 
     flush_codecs = probesize > 0;
 
@@ -3497,7 +3660,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
             && codec && !avctx->codec) {
             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
                 av_log(ic, AV_LOG_WARNING,
-                       "Failed to open codec in av_find_stream_info\n");
+                       "Failed to open codec in %s\n",__FUNCTION__);
         }
 
         // Try to just open decoders, in case this is enough to get parameters.
@@ -3505,7 +3668,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
             if (codec && !avctx->codec)
                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
                     av_log(ic, AV_LOG_WARNING,
-                           "Failed to open codec in av_find_stream_info\n");
+                           "Failed to open codec in %s\n",__FUNCTION__);
         }
         if (!options)
             av_dict_free(&thread_opt);
@@ -3558,8 +3721,10 @@ FF_ENABLE_DEPRECATION_WARNINGS
                 if (count < fps_analyze_framecount)
                     break;
             }
-            if (st->parser && st->parser->parser->split &&
-                !st->internal->avctx->extradata)
+            if (!st->internal->avctx->extradata &&
+                (!st->internal->extract_extradata.inited ||
+                 st->internal->extract_extradata.bsf) &&
+                extract_extradata_check(st))
                 break;
             if (st->first_dts == AV_NOPTS_VALUE &&
                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
@@ -3572,6 +3737,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
                 hasaudio = 1;
         }
         analyzed_all_streams = 0;
+        if (!missing_streams || !*missing_streams)
         if (i == ic->nb_streams) {
             analyzed_all_streams = 1;
             /* NOTE: If the format has no header, then we need to read some
@@ -3723,17 +3889,10 @@ FF_ENABLE_DEPRECATION_WARNINGS
         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
             ff_rfps_add_frame(ic, st, pkt->dts);
 #endif
-        if (st->parser && st->parser->parser->split && !avctx->extradata) {
-            int i = st->parser->parser->split(avctx, pkt->data, pkt->size);
-            if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
-                avctx->extradata_size = i;
-                avctx->extradata      = av_mallocz(avctx->extradata_size +
-                                                   AV_INPUT_BUFFER_PADDING_SIZE);
-                if (!avctx->extradata)
-                    return AVERROR(ENOMEM);
-                memcpy(avctx->extradata, pkt->data,
-                       avctx->extradata_size);
-            }
+        if (!st->internal->avctx->extradata) {
+            ret = extract_extradata(st, pkt);
+            if (ret < 0)
+                goto find_stream_info_err;
         }
 
         /* If still no information, we try to open the codec and to
@@ -3763,9 +3922,13 @@ FF_ENABLE_DEPRECATION_WARNINGS
             if (!has_codec_parameters(st, NULL)) {
                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
                 if (codec && !avctx->codec) {
-                    if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : NULL) < 0)
+                    AVDictionary *opts = NULL;
+                    if (ic->codec_whitelist)
+                        av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
+                    if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
                         av_log(ic, AV_LOG_WARNING,
-                            "Failed to open codec in av_find_stream_info\n");
+                               "Failed to open codec in %s\n",__FUNCTION__);
+                    av_dict_free(&opts);
                 }
             }
 
@@ -3802,12 +3965,6 @@ FF_ENABLE_DEPRECATION_WARNINGS
         }
     }
 
-    // close codecs which were opened in try_decode_frame()
-    for (i = 0; i < ic->nb_streams; i++) {
-        st = ic->streams[i];
-        avcodec_close(st->internal->avctx);
-    }
-
     ff_rfps_calculate(ic);
 
     for (i = 0; i < ic->nb_streams; i++) {
@@ -3826,6 +3983,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
                 st->info->codec_info_duration) {
                 int best_fps      = 0;
                 double best_error = 0.01;
+                AVRational codec_frame_rate = avctx->framerate;
 
                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
@@ -3846,6 +4004,15 @@ FF_ENABLE_DEPRECATION_WARNINGS
                         best_error = error;
                         best_fps   = std_fps.num;
                     }
+
+                    if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
+                        error       = fabs(av_q2d(codec_frame_rate) /
+                                           av_q2d(std_fps) - 1);
+                        if (error < best_error) {
+                            best_error = error;
+                            best_fps   = std_fps.num;
+                        }
+                    }
                 }
                 if (best_fps)
                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
@@ -3855,8 +4022,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
             if (!st->r_frame_rate.num) {
                 if (    avctx->time_base.den * (int64_t) st->time_base.num
                     <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
-                    st->r_frame_rate.num = avctx->time_base.den;
-                    st->r_frame_rate.den = avctx->time_base.num * avctx->ticks_per_frame;
+                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
+                              avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
                 } else {
                     st->r_frame_rate.num = st->time_base.den;
                     st->r_frame_rate.den = st->time_base.num;
@@ -3988,7 +4155,10 @@ FF_ENABLE_DEPRECATION_WARNINGS
         st = ic->streams[i];
         if (st->info)
             av_freep(&st->info->duration_error);
+        avcodec_close(ic->streams[i]->internal->avctx);
         av_freep(&ic->streams[i]->info);
+        av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
+        av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
     }
     if (ic->pb)
         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
@@ -4018,7 +4188,11 @@ int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
                         AVCodec **decoder_ret, int flags)
 {
     int i, nb_streams = ic->nb_streams;
-    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
+    int ret = AVERROR_STREAM_NOT_FOUND;
+    int best_count = -1, best_multiframe = -1, best_disposition = -1;
+    int count, multiframe, disposition;
+    int64_t best_bitrate = -1;
+    int64_t bitrate;
     unsigned *program = NULL;
     const AVCodec *decoder = NULL, *best_decoder = NULL;
 
@@ -4037,10 +4211,6 @@ int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
             continue;
         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
             continue;
-        if (wanted_stream_nb != real_stream_index &&
-            st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
-                               AV_DISPOSITION_VISUAL_IMPAIRED))
-            continue;
         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
             continue;
         if (decoder_ret) {
@@ -4051,13 +4221,16 @@ int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
                 continue;
             }
         }
+        disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
         count = st->codec_info_nb_frames;
         bitrate = par->bit_rate;
         multiframe = FFMIN(5, count);
-        if ((best_multiframe >  multiframe) ||
-            (best_multiframe == multiframe && best_bitrate >  bitrate) ||
-            (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
+        if ((best_disposition >  disposition) ||
+            (best_disposition == disposition && best_multiframe >  multiframe) ||
+            (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
+            (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
             continue;
+        best_disposition = disposition;
         best_count   = count;
         best_bitrate = bitrate;
         best_multiframe = multiframe;
@@ -4176,6 +4349,8 @@ static void free_stream(AVStream **pst)
             av_bsf_free(&st->internal->bsfcs[i]);
             av_freep(&st->internal->bsfcs);
         }
+        av_bsf_free(&st->internal->extract_extradata.bsf);
+        av_packet_free(&st->internal->extract_extradata.pkt);
     }
     av_freep(&st->internal);
 
@@ -4185,9 +4360,7 @@ static void free_stream(AVStream **pst)
     av_freep(&st->index_entries);
 #if FF_API_LAVF_AVCTX
 FF_DISABLE_DEPRECATION_WARNINGS
-    av_freep(&st->codec->extradata);
-    av_freep(&st->codec->subtitle_header);
-    av_freep(&st->codec);
+    avcodec_free_context(&st->codec);
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
     av_freep(&st->priv_data);
@@ -4238,9 +4411,10 @@ void avformat_free_context(AVFormatContext *s)
     }
     av_freep(&s->chapters);
     av_dict_free(&s->metadata);
+    av_dict_free(&s->internal->id3v2_meta);
     av_freep(&s->streams);
-    av_freep(&s->internal);
     flush_packet_queue(s);
+    av_freep(&s->internal);
     av_free(s);
 }
 
@@ -4278,8 +4452,11 @@ AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
     int i;
     AVStream **streams;
 
-    if (s->nb_streams >= INT_MAX/sizeof(*streams))
+    if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
+        if (s->max_streams < INT_MAX/sizeof(*streams))
+            av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
         return NULL;
+    }
     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
     if (!streams)
         return NULL;
@@ -5172,15 +5349,11 @@ uint8_t *av_stream_get_side_data(const AVStream *st,
     return NULL;
 }
 
-uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
-                                 int size)
+int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
+                            uint8_t *data, size_t size)
 {
     AVPacketSideData *sd, *tmp;
     int i;
-    uint8_t *data = av_malloc(size);
-
-    if (!data)
-        return NULL;
 
     for (i = 0; i < st->nb_side_data; i++) {
         sd = &st->side_data[i];
@@ -5189,14 +5362,16 @@ uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
             av_freep(&sd->data);
             sd->data = data;
             sd->size = size;
-            return sd->data;
+            return 0;
         }
     }
 
-    tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
+    if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
+        return AVERROR(ERANGE);
+
+    tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
     if (!tmp) {
-        av_freep(&data);
-        return NULL;
+        return AVERROR(ENOMEM);
     }
 
     st->side_data = tmp;
@@ -5206,6 +5381,25 @@ uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
     sd->type = type;
     sd->data = data;
     sd->size = size;
+
+    return 0;
+}
+
+uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
+                                 int size)
+{
+    int ret;
+    uint8_t *data = av_malloc(size);
+
+    if (!data)
+        return NULL;
+
+    ret = av_stream_add_side_data(st, type, data, size);
+    if (ret < 0) {
+        av_freep(&data);
+        return NULL;
+    }
+
     return data;
 }
 
diff --git a/mythtv/external/FFmpeg/libavformat/vc1testenc.c b/mythtv/external/FFmpeg/libavformat/vc1testenc.c
index 60fb894a977..cf95d1d80d2 100644
--- a/mythtv/external/FFmpeg/libavformat/vc1testenc.c
+++ b/mythtv/external/FFmpeg/libavformat/vc1testenc.c
@@ -73,7 +73,7 @@ static int vc1test_write_trailer(AVFormatContext *s)
     RCVContext *ctx = s->priv_data;
     AVIOContext *pb = s->pb;
 
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         avio_seek(pb, 0, SEEK_SET);
         avio_wl24(pb, ctx->frames);
         avio_flush(pb);
diff --git a/mythtv/external/FFmpeg/libavformat/version.h b/mythtv/external/FFmpeg/libavformat/version.h
index 45c83347fd8..878917d65dd 100644
--- a/mythtv/external/FFmpeg/libavformat/version.h
+++ b/mythtv/external/FFmpeg/libavformat/version.h
@@ -32,7 +32,7 @@
 // Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium)
 // Also please add any ticket numbers that you believe might be affected here
 #define LIBAVFORMAT_VERSION_MAJOR  57
-#define LIBAVFORMAT_VERSION_MINOR  56
+#define LIBAVFORMAT_VERSION_MINOR  83
 #define LIBAVFORMAT_VERSION_MICRO 100
 
 #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
@@ -85,6 +85,19 @@
 #ifndef FF_API_HTTP_USER_AGENT
 #define FF_API_HTTP_USER_AGENT          (LIBAVFORMAT_VERSION_MAJOR < 58)
 #endif
+#ifndef FF_API_HLS_WRAP
+#define FF_API_HLS_WRAP                 (LIBAVFORMAT_VERSION_MAJOR < 58)
+#endif
+#ifndef FF_API_LAVF_MERGE_SD
+#define FF_API_LAVF_MERGE_SD            (LIBAVFORMAT_VERSION_MAJOR < 58)
+#endif
+#ifndef FF_API_LAVF_KEEPSIDE_FLAG
+#define FF_API_LAVF_KEEPSIDE_FLAG       (LIBAVFORMAT_VERSION_MAJOR < 58)
+#endif
+#ifndef FF_API_OLD_ROTATE_API
+#define FF_API_OLD_ROTATE_API           (LIBAVFORMAT_VERSION_MAJOR < 58)
+#endif
+
 
 #ifndef FF_API_R_FRAME_RATE
 #define FF_API_R_FRAME_RATE            1
diff --git a/mythtv/external/FFmpeg/libavformat/vivo.c b/mythtv/external/FFmpeg/libavformat/vivo.c
index a9effd5835b..c9e9c37f37d 100644
--- a/mythtv/external/FFmpeg/libavformat/vivo.c
+++ b/mythtv/external/FFmpeg/libavformat/vivo.c
@@ -63,7 +63,7 @@ static int vivo_probe(AVProbeData *p)
         return 0;
     buf += 15;
 
-    if (*buf < '0' && *buf > '2')
+    if (*buf < '0' || *buf > '2')
         return 0;
 
     return AVPROBE_SCORE_MAX;
diff --git a/mythtv/external/FFmpeg/libavformat/voc_packet.c b/mythtv/external/FFmpeg/libavformat/voc_packet.c
index 5833a79b564..1e2e19e1c36 100644
--- a/mythtv/external/FFmpeg/libavformat/voc_packet.c
+++ b/mythtv/external/FFmpeg/libavformat/voc_packet.c
@@ -49,7 +49,7 @@ ff_voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
             return AVERROR_EOF;
         voc->remaining_size = avio_rl24(pb);
         if (!voc->remaining_size) {
-            if (!s->pb->seekable)
+            if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
                 return AVERROR(EIO);
             voc->remaining_size = avio_size(pb) - avio_tell(pb);
         }
@@ -106,6 +106,11 @@ ff_voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
         }
     }
 
+    if (par->sample_rate <= 0) {
+        av_log(s, AV_LOG_ERROR, "Invalid sample rate %d\n", par->sample_rate);
+        return AVERROR_INVALIDDATA;
+    }
+
     if (tmp_codec >= 0) {
         tmp_codec = ff_codec_get_id(ff_voc_codec_tags, tmp_codec);
         if (par->codec_id == AV_CODEC_ID_NONE)
@@ -121,7 +126,7 @@ ff_voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
         }
     }
 
-    par->bit_rate = par->sample_rate * par->channels * par->bits_per_coded_sample;
+    par->bit_rate = (int64_t)par->sample_rate * par->channels * par->bits_per_coded_sample;
 
     if (max_size <= 0)
         max_size = 2048;
diff --git a/mythtv/external/FFmpeg/libavformat/vpcc.c b/mythtv/external/FFmpeg/libavformat/vpcc.c
index 2390e1711c1..df08de59a6a 100644
--- a/mythtv/external/FFmpeg/libavformat/vpcc.c
+++ b/mythtv/external/FFmpeg/libavformat/vpcc.c
@@ -23,44 +23,6 @@
 #include "libavutil/pixfmt.h"
 #include "vpcc.h"
 
-enum VpxColorSpace
-{
-    VPX_COLOR_SPACE_UNSPECIFIED = 0,
-    VPX_COLOR_SPACE_BT601 = 1,
-    VPX_COLOR_SPACE_BT709 = 2,
-    VPX_COLOR_SPACE_SMPTE_170 = 3,
-    VPX_COLOR_SPACE_SMPTE_240 = 4,
-    VPX_COLOR_SPACE_BT2020_NCL = 5,
-    VPX_COLOR_SPACE_BT2020_CL = 6,
-    VPX_COLOR_SPACE_RGB = 7,
-};
-
-static int get_vpx_color_space(AVFormatContext *s,
-                               enum AVColorSpace color_space)
-{
-    switch (color_space) {
-    case AVCOL_SPC_RGB:
-        return VPX_COLOR_SPACE_RGB;
-    case AVCOL_SPC_BT709:
-        return VPX_COLOR_SPACE_BT709;
-    case AVCOL_SPC_UNSPECIFIED:
-        return VPX_COLOR_SPACE_UNSPECIFIED;
-    case AVCOL_SPC_BT470BG:
-        return VPX_COLOR_SPACE_BT601;
-    case AVCOL_SPC_SMPTE170M:
-        return VPX_COLOR_SPACE_SMPTE_170;
-    case AVCOL_SPC_SMPTE240M:
-        return VPX_COLOR_SPACE_SMPTE_240;
-    case AVCOL_SPC_BT2020_NCL:
-        return VPX_COLOR_SPACE_BT2020_NCL;
-    case AVCOL_SPC_BT2020_CL:
-        return VPX_COLOR_SPACE_BT2020_CL;
-    default:
-        av_log(s, AV_LOG_ERROR, "Unsupported color space (%d)\n", color_space);
-        return -1;
-    }
-}
-
 enum VPX_CHROMA_SUBSAMPLING
 {
     VPX_SUBSAMPLING_420_VERTICAL = 0,
@@ -100,12 +62,6 @@ static int get_bit_depth(AVFormatContext *s, enum AVPixelFormat pixel_format)
     return desc->comp[0].depth;
 }
 
-static int get_vpx_transfer_function(
-    enum AVColorTransferCharacteristic transfer)
-{
-    return transfer == AVCOL_TRC_SMPTEST2084;
-}
-
 static int get_vpx_video_full_range_flag(enum AVColorRange color_range)
 {
     return color_range == AVCOL_RANGE_JPEG;
@@ -117,14 +73,12 @@ int ff_isom_write_vpcc(AVFormatContext *s, AVIOContext *pb,
     int profile = par->profile;
     int level = par->level == FF_LEVEL_UNKNOWN ? 0 : par->level;
     int bit_depth = get_bit_depth(s, par->format);
-    int vpx_color_space = get_vpx_color_space(s, par->color_space);
     int vpx_chroma_subsampling =
         get_vpx_chroma_subsampling(s, par->format, par->chroma_location);
-    int vpx_transfer_function = get_vpx_transfer_function(par->color_trc);
     int vpx_video_full_range_flag =
         get_vpx_video_full_range_flag(par->color_range);
 
-    if (bit_depth < 0 || vpx_color_space < 0 || vpx_chroma_subsampling < 0)
+    if (bit_depth < 0 || vpx_chroma_subsampling < 0)
         return AVERROR_INVALIDDATA;
 
     if (profile == FF_PROFILE_UNKNOWN) {
@@ -138,9 +92,10 @@ int ff_isom_write_vpcc(AVFormatContext *s, AVIOContext *pb,
 
     avio_w8(pb, profile);
     avio_w8(pb, level);
-    avio_w8(pb, (bit_depth << 4) | vpx_color_space);
-    avio_w8(pb, (vpx_chroma_subsampling << 4) | (vpx_transfer_function << 1) |
-                    vpx_video_full_range_flag);
+    avio_w8(pb, (bit_depth << 4) | (vpx_chroma_subsampling << 1) | vpx_video_full_range_flag);
+    avio_w8(pb, par->color_primaries);
+    avio_w8(pb, par->color_trc);
+    avio_w8(pb, par->color_space);
 
     // vp9 does not have codec initialization data.
     avio_wb16(pb, 0);
diff --git a/mythtv/external/FFmpeg/libavformat/vqf.c b/mythtv/external/FFmpeg/libavformat/vqf.c
index 969fbefea6d..d00fa5e08c6 100644
--- a/mythtv/external/FFmpeg/libavformat/vqf.c
+++ b/mythtv/external/FFmpeg/libavformat/vqf.c
@@ -140,7 +140,7 @@ static int vqf_read_header(AVFormatContext *s)
                 return AVERROR_INVALIDDATA;
             }
 
-            st->codecpar->bit_rate = read_bitrate * 1000;
+            st->codecpar->bit_rate = (int64_t)read_bitrate * 1000;
             break;
         case MKTAG('D','S','I','Z'): // size of compressed data
         {
@@ -212,7 +212,7 @@ static int vqf_read_header(AVFormatContext *s)
         break;
     default:
         av_log(s, AV_LOG_ERROR, "Mode not supported: %d Hz, %"PRId64" kb/s.\n",
-               st->codecpar->sample_rate, (int64_t)st->codecpar->bit_rate);
+               st->codecpar->sample_rate, st->codecpar->bit_rate);
         return -1;
     }
     c->frame_bit_len = st->codecpar->bit_rate*size/st->codecpar->sample_rate;
diff --git a/mythtv/external/FFmpeg/libavformat/wavdec.c b/mythtv/external/FFmpeg/libavformat/wavdec.c
index 7176cd6f2d9..b016185a1b7 100644
--- a/mythtv/external/FFmpeg/libavformat/wavdec.c
+++ b/mythtv/external/FFmpeg/libavformat/wavdec.c
@@ -64,34 +64,30 @@ static void set_spdif(AVFormatContext *s, WAVDemuxContext *wav)
 {
     if (CONFIG_SPDIF_DEMUXER && s->streams[0]->codecpar->codec_tag == 1) {
         enum AVCodecID codec;
-        uint8_t *buf = NULL;
         int len = 1<<16;
         int ret = ffio_ensure_seekback(s->pb, len);
-        int64_t pos = avio_tell(s->pb);
 
-        if (ret < 0)
-            goto end;
-
-        buf = av_malloc(len);
-        if (!buf) {
-            ret = AVERROR(ENOMEM);
-            goto end;
+        if (ret >= 0) {
+            uint8_t *buf = av_malloc(len);
+            if (!buf) {
+                ret = AVERROR(ENOMEM);
+            } else {
+                int64_t pos = avio_tell(s->pb);
+                len = ret = avio_read(s->pb, buf, len);
+                if (len >= 0) {
+                    ret = ff_spdif_probe(buf, len, &codec);
+                    if (ret > AVPROBE_SCORE_EXTENSION) {
+                        s->streams[0]->codecpar->codec_id = codec;
+                        wav->spdif = 1;
+                    }
+                }
+                avio_seek(s->pb, pos, SEEK_SET);
+                av_free(buf);
+            }
         }
 
-        len = ret = avio_read(s->pb, buf, len);
-        if (ret < 0)
-            goto end;
-
-        ret = ff_spdif_probe(buf, len, &codec);
-        if (ret > AVPROBE_SCORE_EXTENSION) {
-            s->streams[0]->codecpar->codec_id = codec;
-            wav->spdif = 1;
-        }
-end:
-        avio_seek(s->pb, pos, SEEK_SET);
         if (ret < 0)
             av_log(s, AV_LOG_WARNING, "Cannot check for SPDIF\n");
-        av_free(buf);
     }
 }
 
@@ -184,9 +180,9 @@ static int wav_parse_fmt_tag(AVFormatContext *s, int64_t size, AVStream **st)
 static int wav_parse_xma2_tag(AVFormatContext *s, int64_t size, AVStream **st)
 {
     AVIOContext *pb = s->pb;
-    int num_streams, i, channels = 0;
+    int version, num_streams, i, channels = 0;
 
-    if (size < 44)
+    if (size < 36)
         return AVERROR_INVALIDDATA;
 
     *st = avformat_new_stream(s, NULL);
@@ -197,13 +193,17 @@ static int wav_parse_xma2_tag(AVFormatContext *s, int64_t size, AVStream **st)
     (*st)->codecpar->codec_id   = AV_CODEC_ID_XMA2;
     (*st)->need_parsing         = AVSTREAM_PARSE_FULL_RAW;
 
-    avio_skip(pb, 1);
+    version = avio_r8(pb);
+    if (version != 3 && version != 4)
+        return AVERROR_INVALIDDATA;
     num_streams = avio_r8(pb);
-    if (size < 40 + num_streams * 4)
+    if (size != (32 + ((version==3)?0:8) + 4*num_streams))
         return AVERROR_INVALIDDATA;
     avio_skip(pb, 10);
     (*st)->codecpar->sample_rate = avio_rb32(pb);
-    avio_skip(pb, 12);
+    if (version == 4)
+        avio_skip(pb, 8);
+    avio_skip(pb, 4);
     (*st)->duration = avio_rb32(pb);
     avio_skip(pb, 8);
 
@@ -217,9 +217,11 @@ static int wav_parse_xma2_tag(AVFormatContext *s, int64_t size, AVStream **st)
         return AVERROR_INVALIDDATA;
 
     avpriv_set_pts_info(*st, 64, 1, (*st)->codecpar->sample_rate);
-    if (ff_alloc_extradata((*st)->codecpar, 34))
+
+    avio_seek(pb, -size, SEEK_CUR);
+    av_freep(&(*st)->codecpar->extradata);
+    if (ff_get_extradata(s, (*st)->codecpar, pb, size) < 0)
         return AVERROR(ENOMEM);
-    memset((*st)->codecpar->extradata, 0, 34);
 
     return 0;
 }
@@ -327,7 +329,6 @@ static int wav_read_header(AVFormatContext *s)
     int64_t size, av_uninit(data_size);
     int64_t sample_count = 0;
     int rf64 = 0;
-    char start_code[32];
     uint32_t tag;
     AVIOContext *pb      = s->pb;
     AVStream *st         = NULL;
@@ -351,8 +352,8 @@ static int wav_read_header(AVFormatContext *s)
         rf64 = 1;
         break;
     default:
-        av_get_codec_tag_string(start_code, sizeof(start_code), tag);
-        av_log(s, AV_LOG_ERROR, "invalid start code %s in RIFF header\n", start_code);
+        av_log(s, AV_LOG_ERROR, "invalid start code %s in RIFF header\n",
+               av_fourcc2str(tag));
         return AVERROR_INVALIDDATA;
     }
 
@@ -414,7 +415,7 @@ static int wav_read_header(AVFormatContext *s)
             got_xma2 = 1;
             break;
         case MKTAG('d', 'a', 't', 'a'):
-            if (!pb->seekable && !got_fmt && !got_xma2) {
+            if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) && !got_fmt && !got_xma2) {
                 av_log(s, AV_LOG_ERROR,
                        "found no 'fmt ' tag before the 'data' tag\n");
                 return AVERROR_INVALIDDATA;
@@ -437,7 +438,7 @@ static int wav_read_header(AVFormatContext *s)
             /* don't look for footer metadata if we can't seek or if we don't
              * know where the data tag ends
              */
-            if (!pb->seekable || (!rf64 && !size))
+            if (!(pb->seekable & AVIO_SEEKABLE_NORMAL) || (!rf64 && !size))
                 goto break_loop;
             break;
         case MKTAG('f', 'a', 'c', 't'):
@@ -560,6 +561,22 @@ static int wav_read_header(AVFormatContext *s)
     if (sample_count)
         st->duration = sample_count;
 
+    if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S32LE &&
+        st->codecpar->block_align == st->codecpar->channels * 4 &&
+        st->codecpar->bits_per_coded_sample == 32 &&
+        st->codecpar->extradata_size == 2 &&
+        AV_RL16(st->codecpar->extradata) == 1) {
+        st->codecpar->codec_id = AV_CODEC_ID_PCM_F16LE;
+        st->codecpar->bits_per_coded_sample = 16;
+    } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE &&
+               st->codecpar->block_align == st->codecpar->channels * 4 &&
+               st->codecpar->bits_per_coded_sample == 24) {
+        st->codecpar->codec_id = AV_CODEC_ID_PCM_F24LE;
+    } else if (st->codecpar->codec_id == AV_CODEC_ID_XMA1 ||
+               st->codecpar->codec_id == AV_CODEC_ID_XMA2) {
+        st->codecpar->block_align = 2048;
+    }
+
     ff_metadata_conv_ctx(s, NULL, wav_metadata_conv);
     ff_metadata_conv_ctx(s, NULL, ff_riff_info_conv);
 
@@ -707,6 +724,7 @@ static int wav_read_seek(AVFormatContext *s,
     case AV_CODEC_ID_MP3:
     case AV_CODEC_ID_AC3:
     case AV_CODEC_ID_DTS:
+    case AV_CODEC_ID_XMA2:
         /* use generic seeking with dynamically generated indexes */
         return -1;
     default:
@@ -808,7 +826,7 @@ static int w64_read_header(AVFormatContext *s)
             wav->data_end = avio_tell(pb) + size - 24;
 
             data_ofs = avio_tell(pb);
-            if (!pb->seekable)
+            if (!(pb->seekable & AVIO_SEEKABLE_NORMAL))
                 break;
 
             avio_skip(pb, size - 24);
@@ -829,6 +847,8 @@ static int w64_read_header(AVFormatContext *s)
                 chunk_key[4] = 0;
                 avio_read(pb, chunk_key, 4);
                 chunk_size = avio_rl32(pb);
+                if (chunk_size == UINT32_MAX)
+                    return AVERROR_INVALIDDATA;
 
                 value = av_mallocz(chunk_size + 1);
                 if (!value)
diff --git a/mythtv/external/FFmpeg/libavformat/wavenc.c b/mythtv/external/FFmpeg/libavformat/wavenc.c
index a21d4c547ee..adb20cb2156 100644
--- a/mythtv/external/FFmpeg/libavformat/wavenc.c
+++ b/mythtv/external/FFmpeg/libavformat/wavenc.c
@@ -331,7 +331,7 @@ static int wav_write_header(AVFormatContext *s)
         ffio_fill(pb, 0, 28);
     }
 
-    if (wav->write_peak != 2) {
+    if (wav->write_peak != PEAK_ONLY) {
         /* format header */
         fmt = ff_start_tag(pb, "fmt ");
         if (ff_put_wav_header(s, pb, s->streams[0]->codecpar, 0) < 0) {
@@ -344,7 +344,7 @@ static int wav_write_header(AVFormatContext *s)
     }
 
     if (s->streams[0]->codecpar->codec_tag != 0x01 /* hence for all other than PCM */
-        && s->pb->seekable) {
+        && (s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
         wav->fact_pos = ff_start_tag(pb, "fact");
         avio_wl32(pb, 0);
         ff_end_tag(pb, wav->fact_pos);
@@ -363,7 +363,7 @@ static int wav_write_header(AVFormatContext *s)
     wav->maxpts = wav->last_duration = 0;
     wav->minpts = INT64_MAX;
 
-    if (wav->write_peak != 2) {
+    if (wav->write_peak != PEAK_ONLY) {
         /* info header */
         ff_riff_write_info(s);
 
@@ -381,7 +381,7 @@ static int wav_write_packet(AVFormatContext *s, AVPacket *pkt)
     AVIOContext *pb  = s->pb;
     WAVMuxContext    *wav = s->priv_data;
 
-    if (wav->write_peak != 2)
+    if (wav->write_peak != PEAK_ONLY)
         avio_write(pb, pkt->data, pkt->size);
 
     if (wav->write_peak) {
@@ -425,8 +425,8 @@ static int wav_write_trailer(AVFormatContext *s)
 
     avio_flush(pb);
 
-    if (s->pb->seekable) {
-        if (wav->write_peak != 2 && avio_tell(pb) - wav->data < UINT32_MAX) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
+        if (wav->write_peak != PEAK_ONLY && avio_tell(pb) - wav->data < UINT32_MAX) {
             ff_end_tag(pb, wav->data);
             avio_flush(pb);
         }
@@ -584,7 +584,7 @@ static int w64_write_header(AVFormatContext *s)
     end_guid(pb, start);
 
     if (s->streams[0]->codecpar->codec_tag != 0x01 /* hence for all other than PCM */
-        && s->pb->seekable) {
+        && (s->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
         start_guid(pb, ff_w64_guid_fact, &wav->fact_pos);
         avio_wl64(pb, 0);
         end_guid(pb, wav->fact_pos);
@@ -601,7 +601,7 @@ static int w64_write_trailer(AVFormatContext *s)
     WAVMuxContext *wav = s->priv_data;
     int64_t file_size;
 
-    if (pb->seekable) {
+    if (pb->seekable & AVIO_SEEKABLE_NORMAL) {
         end_guid(pb, wav->data);
 
         file_size = avio_tell(pb);
diff --git a/mythtv/external/FFmpeg/libavformat/wc3movie.c b/mythtv/external/FFmpeg/libavformat/wc3movie.c
index 642dcbbf7e8..cb4d4d933ba 100644
--- a/mythtv/external/FFmpeg/libavformat/wc3movie.c
+++ b/mythtv/external/FFmpeg/libavformat/wc3movie.c
@@ -150,9 +150,8 @@ static int wc3_read_header(AVFormatContext *s)
             break;
 
         default:
-            av_log(s, AV_LOG_ERROR, "  unrecognized WC3 chunk: %c%c%c%c (0x%02X%02X%02X%02X)\n",
-                (uint8_t)fourcc_tag, (uint8_t)(fourcc_tag >> 8), (uint8_t)(fourcc_tag >> 16), (uint8_t)(fourcc_tag >> 24),
-                (uint8_t)fourcc_tag, (uint8_t)(fourcc_tag >> 8), (uint8_t)(fourcc_tag >> 16), (uint8_t)(fourcc_tag >> 24));
+            av_log(s, AV_LOG_ERROR, "unrecognized WC3 chunk: %s\n",
+                   av_fourcc2str(fourcc_tag));
             return AVERROR_INVALIDDATA;
         }
 
@@ -242,9 +241,6 @@ static int wc3_read_packet(AVFormatContext *s,
 
         case TEXT_TAG:
             /* subtitle chunk */
-#if 0
-            avio_skip(pb, size);
-#else
             if ((unsigned)size > sizeof(text) || (ret = avio_read(pb, text, size)) != size)
                 ret = AVERROR(EIO);
             else {
@@ -262,7 +258,6 @@ static int wc3_read_packet(AVFormatContext *s,
                     return AVERROR_INVALIDDATA;
                 av_log (s, AV_LOG_DEBUG, "  fronsay: %s\n", &text[i + 1]);
             }
-#endif
             break;
 
         case AUDI_TAG:
@@ -278,9 +273,8 @@ static int wc3_read_packet(AVFormatContext *s,
             break;
 
         default:
-            av_log (s, AV_LOG_ERROR, "  unrecognized WC3 chunk: %c%c%c%c (0x%02X%02X%02X%02X)\n",
-                (uint8_t)fourcc_tag, (uint8_t)(fourcc_tag >> 8), (uint8_t)(fourcc_tag >> 16), (uint8_t)(fourcc_tag >> 24),
-                (uint8_t)fourcc_tag, (uint8_t)(fourcc_tag >> 8), (uint8_t)(fourcc_tag >> 16), (uint8_t)(fourcc_tag >> 24));
+            av_log(s, AV_LOG_ERROR, "unrecognized WC3 chunk: %s\n",
+                   av_fourcc2str(fourcc_tag));
             ret = AVERROR_INVALIDDATA;
             packet_read = 1;
             break;
diff --git a/mythtv/external/FFmpeg/libavformat/webmdashenc.c b/mythtv/external/FFmpeg/libavformat/webmdashenc.c
index d4b31467906..1280d8a763b 100644
--- a/mythtv/external/FFmpeg/libavformat/webmdashenc.c
+++ b/mythtv/external/FFmpeg/libavformat/webmdashenc.c
@@ -182,14 +182,19 @@ static int write_representation(AVFormatContext *s, AVStream *stream, char *id,
     AVDictionaryEntry *cues_end = av_dict_get(stream->metadata, CUES_END, NULL, 0);
     AVDictionaryEntry *filename = av_dict_get(stream->metadata, FILENAME, NULL, 0);
     AVDictionaryEntry *bandwidth = av_dict_get(stream->metadata, BANDWIDTH, NULL, 0);
+    const char *bandwidth_str;
     if ((w->is_live && (!filename)) ||
         (!w->is_live && (!irange || !cues_start || !cues_end || !filename || !bandwidth))) {
         return AVERROR_INVALIDDATA;
     }
     avio_printf(s->pb, "<Representation id=\"%s\"", id);
-    // FIXME: For live, This should be obtained from the input file or as an AVOption.
-    avio_printf(s->pb, " bandwidth=\"%s\"",
-                w->is_live ? (stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ? "128000" : "1000000") : bandwidth->value);
+    // if bandwidth for live was not provided, use a default
+    if (w->is_live && !bandwidth) {
+        bandwidth_str = (stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ? "128000" : "1000000";
+    } else {
+        bandwidth_str = bandwidth->value;
+    }
+    avio_printf(s->pb, " bandwidth=\"%s\"", bandwidth_str);
     if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && output_width)
         avio_printf(s->pb, " width=\"%d\"", stream->codecpar->width);
     if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && output_height)
@@ -283,33 +288,55 @@ static int parse_filename(char *filename, char **representation_id,
     char *period_pos = NULL;
     char *temp_pos = NULL;
     char *filename_str = av_strdup(filename);
-    if (!filename_str) return AVERROR(ENOMEM);
+    int ret = 0;
+
+    if (!filename_str) {
+        ret = AVERROR(ENOMEM);
+        goto end;
+    }
     temp_pos = av_stristr(filename_str, "_");
     while (temp_pos) {
         underscore_pos = temp_pos + 1;
         temp_pos = av_stristr(temp_pos + 1, "_");
     }
-    if (!underscore_pos) return AVERROR_INVALIDDATA;
+    if (!underscore_pos) {
+        ret = AVERROR_INVALIDDATA;
+        goto end;
+    }
     period_pos = av_stristr(underscore_pos, ".");
-    if (!period_pos) return AVERROR_INVALIDDATA;
+    if (!period_pos) {
+        ret = AVERROR_INVALIDDATA;
+        goto end;
+    }
     *(underscore_pos - 1) = 0;
     if (representation_id) {
         *representation_id = av_malloc(period_pos - underscore_pos + 1);
-        if (!(*representation_id)) return AVERROR(ENOMEM);
+        if (!(*representation_id)) {
+            ret = AVERROR(ENOMEM);
+            goto end;
+        }
         av_strlcpy(*representation_id, underscore_pos, period_pos - underscore_pos + 1);
     }
     if (initialization_pattern) {
         *initialization_pattern = av_asprintf("%s_$RepresentationID$.hdr",
                                               filename_str);
-        if (!(*initialization_pattern)) return AVERROR(ENOMEM);
+        if (!(*initialization_pattern)) {
+            ret = AVERROR(ENOMEM);
+            goto end;
+        }
     }
     if (media_pattern) {
         *media_pattern = av_asprintf("%s_$RepresentationID$_$Number$.chk",
                                      filename_str);
-        if (!(*media_pattern)) return AVERROR(ENOMEM);
+        if (!(*media_pattern)) {
+            ret = AVERROR(ENOMEM);
+            goto end;
+        }
     }
-    av_free(filename_str);
-    return 0;
+
+end:
+    av_freep(&filename_str);
+    return ret;
 }
 
 /*
@@ -428,6 +455,10 @@ static int parse_adaptation_sets(AVFormatContext *s)
     char *p = w->adaptation_sets;
     char *q;
     enum { new_set, parsed_id, parsing_streams } state;
+    if (!w->adaptation_sets) {
+        av_log(s, AV_LOG_ERROR, "The 'adaptation_sets' option must be set.\n");
+        return AVERROR(EINVAL);
+    }
     // syntax id=0,streams=0,1,2 id=1,streams=3,4 and so on
     state = new_set;
     while (p < w->adaptation_sets + strlen(w->adaptation_sets)) {
@@ -458,7 +489,11 @@ static int parse_adaptation_sets(AVFormatContext *s)
             if (as->streams == NULL)
                 return AVERROR(ENOMEM);
             as->streams[as->nb_streams - 1] = to_integer(p, q - p + 1);
-            if (as->streams[as->nb_streams - 1] < 0) return -1;
+            if (as->streams[as->nb_streams - 1] < 0 ||
+                as->streams[as->nb_streams - 1] >= s->nb_streams) {
+                av_log(s, AV_LOG_ERROR, "Invalid value for 'streams' in adapation_sets.\n");
+                return AVERROR(EINVAL);
+            }
             if (*q == '\0') break;
             if (*q == ' ') state = new_set;
             p = ++q;
diff --git a/mythtv/external/FFmpeg/libavformat/webpenc.c b/mythtv/external/FFmpeg/libavformat/webpenc.c
index 2e0147cefd4..9fb472257d7 100644
--- a/mythtv/external/FFmpeg/libavformat/webpenc.c
+++ b/mythtv/external/FFmpeg/libavformat/webpenc.c
@@ -158,7 +158,7 @@ static int webp_write_packet(AVFormatContext *s, AVPacket *pkt)
         int ret;
         if ((ret = flush(s, 0, pkt->pts)) < 0)
             return ret;
-        av_copy_packet(&w->last_pkt, pkt);
+        av_packet_ref(&w->last_pkt, pkt);
     }
     ++w->frame_count;
 
diff --git a/mythtv/external/FFmpeg/libavformat/westwood_vqa.c b/mythtv/external/FFmpeg/libavformat/westwood_vqa.c
index 3635c6ab36f..efb9847ff09 100644
--- a/mythtv/external/FFmpeg/libavformat/westwood_vqa.c
+++ b/mythtv/external/FFmpeg/libavformat/westwood_vqa.c
@@ -144,9 +144,8 @@ static int wsvqa_read_header(AVFormatContext *s)
             break;
 
         default:
-            av_log (s, AV_LOG_ERROR, " note: unknown chunk seen (%c%c%c%c)\n",
-                scratch[0], scratch[1],
-                scratch[2], scratch[3]);
+            av_log(s, AV_LOG_ERROR, " note: unknown chunk seen (%s)\n",
+                   av_fourcc2str(chunk_tag));
             break;
         }
 
@@ -251,7 +250,8 @@ static int wsvqa_read_packet(AVFormatContext *s,
             case CMDS_TAG:
                 break;
             default:
-                av_log(s, AV_LOG_INFO, "Skipping unknown chunk 0x%08X\n", chunk_type);
+                av_log(s, AV_LOG_INFO, "Skipping unknown chunk %s\n",
+                       av_fourcc2str(av_bswap32(chunk_type)));
             }
             avio_skip(pb, chunk_size + skip_byte);
         }
diff --git a/mythtv/external/FFmpeg/libavformat/wsddec.c b/mythtv/external/FFmpeg/libavformat/wsddec.c
index 9ca05768156..81a4dcc71e9 100644
--- a/mythtv/external/FFmpeg/libavformat/wsddec.c
+++ b/mythtv/external/FFmpeg/libavformat/wsddec.c
@@ -128,7 +128,7 @@ static int wsd_read_header(AVFormatContext *s)
     st->codecpar->sample_rate = avio_rb32(pb) / 8;
     avio_skip(pb, 4);
     st->codecpar->channels    = avio_r8(pb) & 0xF;
-    st->codecpar->bit_rate    = st->codecpar->channels * st->codecpar->sample_rate * 8LL;
+    st->codecpar->bit_rate    = (int64_t)st->codecpar->channels * st->codecpar->sample_rate * 8LL;
     if (!st->codecpar->channels)
         return AVERROR_INVALIDDATA;
 
diff --git a/mythtv/external/FFmpeg/libavformat/wtvdec.c b/mythtv/external/FFmpeg/libavformat/wtvdec.c
index 070240fc13d..dbf2d824aaa 100644
--- a/mythtv/external/FFmpeg/libavformat/wtvdec.c
+++ b/mythtv/external/FFmpeg/libavformat/wtvdec.c
@@ -305,7 +305,7 @@ static void wtvfile_close(AVIOContext *pb)
     av_freep(&wf->sectors);
     av_freep(&pb->opaque);
     av_freep(&pb->buffer);
-    av_free(pb);
+    avio_context_free(&pb);
 }
 
 /*
diff --git a/mythtv/external/FFmpeg/libavformat/wtvenc.c b/mythtv/external/FFmpeg/libavformat/wtvenc.c
index a7ca1c39aab..4a68b8133f9 100644
--- a/mythtv/external/FFmpeg/libavformat/wtvenc.c
+++ b/mythtv/external/FFmpeg/libavformat/wtvenc.c
@@ -241,7 +241,7 @@ static void put_videoinfoheader2(AVIOContext *pb, AVStream *st)
     avio_wl32(pb, 0);
     avio_wl32(pb, 0);
 
-    ff_put_bmp_header(pb, st->codecpar, ff_codec_bmp_tags, 0, 1);
+    ff_put_bmp_header(pb, st->codecpar, 0, 1);
 
     if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
         int padding = (st->codecpar->extradata_size & 3) ? 4 - (st->codecpar->extradata_size & 3) : 0;
@@ -464,7 +464,7 @@ static int write_packet(AVFormatContext *s, AVPacket *pkt)
     AVStream    *st   = s->streams[pkt->stream_index];
 
     if (st->codecpar->codec_id == AV_CODEC_ID_MJPEG && !wctx->thumbnail.size) {
-        av_copy_packet(&wctx->thumbnail, pkt);
+        av_packet_ref(&wctx->thumbnail, pkt);
         return 0;
     } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
         int ret = ff_check_h264_startcode(s, st, pkt);
diff --git a/mythtv/external/FFmpeg/libavformat/wvdec.c b/mythtv/external/FFmpeg/libavformat/wvdec.c
index 1ec52f689d5..82526563ec1 100644
--- a/mythtv/external/FFmpeg/libavformat/wvdec.c
+++ b/mythtv/external/FFmpeg/libavformat/wvdec.c
@@ -98,7 +98,8 @@ static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb)
     }
 
     if (wc->header.version < 0x402 || wc->header.version > 0x410) {
-        av_log(ctx, AV_LOG_ERROR, "Unsupported version %03X\n", wc->header.version);
+        avpriv_report_missing_feature(ctx, "WV version 0x%03X",
+                                      wc->header.version);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -119,7 +120,7 @@ static int wv_read_block_header(AVFormatContext *ctx, AVIOContext *pb)
     }
     if ((rate == -1 || !chan) && !wc->block_parsed) {
         int64_t block_end = avio_tell(pb) + wc->header.blocksize;
-        if (!pb->seekable) {
+        if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
             av_log(ctx, AV_LOG_ERROR,
                    "Cannot determine additional parameters\n");
             return AVERROR_INVALIDDATA;
@@ -241,7 +242,7 @@ static int wv_read_header(AVFormatContext *s)
     if (wc->header.total_samples != 0xFFFFFFFFu)
         st->duration = wc->header.total_samples;
 
-    if (s->pb->seekable) {
+    if (s->pb->seekable & AVIO_SEEKABLE_NORMAL) {
         int64_t cur = avio_tell(s->pb);
         wc->apetag_start = ff_ape_parse_tag(s);
         if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
diff --git a/mythtv/external/FFmpeg/libavformat/wvenc.c b/mythtv/external/FFmpeg/libavformat/wvenc.c
index 48e371aa13c..8743739e8da 100644
--- a/mythtv/external/FFmpeg/libavformat/wvenc.c
+++ b/mythtv/external/FFmpeg/libavformat/wvenc.c
@@ -64,7 +64,7 @@ static av_cold int wv_write_trailer(AVFormatContext *ctx)
     WvMuxContext *s = ctx->priv_data;
 
     /* update total number of samples in the first block */
-    if (ctx->pb->seekable && s->samples &&
+    if ((ctx->pb->seekable & AVIO_SEEKABLE_NORMAL) && s->samples &&
         s->samples < UINT32_MAX) {
         int64_t pos = avio_tell(ctx->pb);
         avio_seek(ctx->pb, 12, SEEK_SET);
diff --git a/mythtv/external/FFmpeg/libavformat/xmv.c b/mythtv/external/FFmpeg/libavformat/xmv.c
index b85d0ccc431..b974e5a6e69 100644
--- a/mythtv/external/FFmpeg/libavformat/xmv.c
+++ b/mythtv/external/FFmpeg/libavformat/xmv.c
@@ -77,7 +77,7 @@ typedef struct XMVAudioPacket {
     /* Stream format properties. */
     uint16_t compression;     ///< The type of compression.
     uint16_t channels;        ///< Number of channels.
-    uint32_t sample_rate;     ///< Sampling rate.
+    int32_t sample_rate;      ///< Sampling rate.
     uint16_t bits_per_sample; ///< Bits per compressed sample.
     uint32_t bit_rate;        ///< Bits of compressed data per second.
     uint16_t flags;           ///< Flags
@@ -210,7 +210,7 @@ static int xmv_read_header(AVFormatContext *s)
             av_log(s, AV_LOG_WARNING, "Unsupported 5.1 ADPCM audio stream "
                                       "(0x%04X)\n", packet->flags);
 
-        if (!packet->channels || !packet->sample_rate ||
+        if (!packet->channels || packet->sample_rate <= 0 ||
              packet->channels >= UINT16_MAX / XMV_BLOCK_ALIGN_SIZE) {
             av_log(s, AV_LOG_ERROR, "Invalid parameters for audio track %"PRIu16".\n",
                    audio_track);
diff --git a/mythtv/external/FFmpeg/libavformat/xvag.c b/mythtv/external/FFmpeg/libavformat/xvag.c
index 5ef4fb09003..22e4f1e3c87 100644
--- a/mythtv/external/FFmpeg/libavformat/xvag.c
+++ b/mythtv/external/FFmpeg/libavformat/xvag.c
@@ -20,6 +20,7 @@
  */
 
 #include "libavutil/bswap.h"
+#include "libavcodec/internal.h"
 #include "avformat.h"
 #include "internal.h"
 
@@ -68,7 +69,7 @@ static int xvag_read_header(AVFormatContext *s)
 
     if (st->codecpar->sample_rate <= 0)
         return AVERROR_INVALIDDATA;
-    if (st->codecpar->channels <= 0)
+    if (st->codecpar->channels <= 0 || st->codecpar->channels > FF_SANE_NB_CHANNELS)
         return AVERROR_INVALIDDATA;
 
     switch (codec) {
diff --git a/mythtv/external/FFmpeg/libavformat/xwma.c b/mythtv/external/FFmpeg/libavformat/xwma.c
index df84d253316..1c187729289 100644
--- a/mythtv/external/FFmpeg/libavformat/xwma.c
+++ b/mythtv/external/FFmpeg/libavformat/xwma.c
@@ -87,8 +87,9 @@ static int xwma_read_header(AVFormatContext *s)
      */
     if (st->codecpar->codec_id != AV_CODEC_ID_WMAV2 &&
         st->codecpar->codec_id != AV_CODEC_ID_WMAPRO) {
-        avpriv_request_sample(s, "Unexpected codec (tag 0x04%x; id %d)",
-                              st->codecpar->codec_tag, st->codecpar->codec_id);
+        avpriv_request_sample(s, "Unexpected codec (tag %s; id %d)",
+                              av_fourcc2str(st->codecpar->codec_tag),
+                              st->codecpar->codec_id);
     } else {
         /* In all xWMA files I have seen, there is no extradata. But the WMA
          * codecs require extradata, so we provide our own fake extradata.
diff --git a/mythtv/external/FFmpeg/libavformat/yuv4mpegdec.c b/mythtv/external/FFmpeg/libavformat/yuv4mpegdec.c
index a91645f6d61..462b8238606 100644
--- a/mythtv/external/FFmpeg/libavformat/yuv4mpegdec.c
+++ b/mythtv/external/FFmpeg/libavformat/yuv4mpegdec.c
@@ -295,9 +295,10 @@ static int yuv4_read_packet(AVFormatContext *s, AVPacket *pkt)
     ret = av_get_packet(s->pb, pkt, s->packet_size - Y4M_FRAME_MAGIC_LEN);
     if (ret < 0)
         return ret;
-    else if (ret != s->packet_size - Y4M_FRAME_MAGIC_LEN)
+    else if (ret != s->packet_size - Y4M_FRAME_MAGIC_LEN) {
+        av_packet_unref(pkt);
         return s->pb->eof_reached ? AVERROR_EOF : AVERROR(EIO);
-
+    }
     pkt->stream_index = 0;
     pkt->pts = (off - s->internal->data_offset) / s->packet_size;
     pkt->duration = 1;
diff --git a/mythtv/external/FFmpeg/libavresample/Makefile b/mythtv/external/FFmpeg/libavresample/Makefile
index 7d857a0e368..90f025a9f90 100644
--- a/mythtv/external/FFmpeg/libavresample/Makefile
+++ b/mythtv/external/FFmpeg/libavresample/Makefile
@@ -1,4 +1,5 @@
 NAME = avresample
+DESC = Libav audio resampling library
 
 HEADERS = avresample.h                                                  \
           version.h                                                     \
diff --git a/mythtv/external/FFmpeg/libavresample/avresample.h b/mythtv/external/FFmpeg/libavresample/avresample.h
index 4cfbdfcf8a9..193443e2a6b 100644
--- a/mythtv/external/FFmpeg/libavresample/avresample.h
+++ b/mythtv/external/FFmpeg/libavresample/avresample.h
@@ -490,8 +490,8 @@ int avresample_convert_frame(AVAudioResampleContext *avr,
  * @see avresample_close();
  *
  * @param avr             audio resample context
- * @param output          output AVFrame
- * @param input           input AVFrame
+ * @param out             output AVFrame
+ * @param in              input AVFrame
  * @return                0 on success, AVERROR on failure.
  */
 int avresample_config(AVAudioResampleContext *avr, AVFrame *out, AVFrame *in);
diff --git a/mythtv/external/FFmpeg/libavresample/version.h b/mythtv/external/FFmpeg/libavresample/version.h
index 0f4c8baad0a..20c78c74d3f 100644
--- a/mythtv/external/FFmpeg/libavresample/version.h
+++ b/mythtv/external/FFmpeg/libavresample/version.h
@@ -28,7 +28,7 @@
 #include "libavutil/version.h"
 
 #define LIBAVRESAMPLE_VERSION_MAJOR  3
-#define LIBAVRESAMPLE_VERSION_MINOR  1
+#define LIBAVRESAMPLE_VERSION_MINOR  7
 #define LIBAVRESAMPLE_VERSION_MICRO  0
 
 #define LIBAVRESAMPLE_VERSION_INT  AV_VERSION_INT(LIBAVRESAMPLE_VERSION_MAJOR, \
diff --git a/mythtv/external/FFmpeg/libavresample/x86/Makefile b/mythtv/external/FFmpeg/libavresample/x86/Makefile
index 0ca2d79045d..55b709ce36c 100644
--- a/mythtv/external/FFmpeg/libavresample/x86/Makefile
+++ b/mythtv/external/FFmpeg/libavresample/x86/Makefile
@@ -4,6 +4,6 @@ OBJS      += x86/audio_convert_init.o                                   \
 
 OBJS-$(CONFIG_XMM_CLOBBER_TEST) += x86/w64xmmtest.o
 
-YASM-OBJS += x86/audio_convert.o                                        \
+X86ASM-OBJS += x86/audio_convert.o                                      \
              x86/audio_mix.o                                            \
              x86/dither.o                                               \
diff --git a/mythtv/external/FFmpeg/libavutil/Makefile b/mythtv/external/FFmpeg/libavutil/Makefile
index 0fa90fea2ca..65e285a7011 100644
--- a/mythtv/external/FFmpeg/libavutil/Makefile
+++ b/mythtv/external/FFmpeg/libavutil/Makefile
@@ -1,6 +1,5 @@
-include $(SUBDIR)../config.mak
-
 NAME = avutil
+DESC = FFmpeg utility library
 
 HEADERS = adler32.h                                                     \
           aes.h                                                         \
@@ -34,9 +33,12 @@ HEADERS = adler32.h                                                     \
           hmac.h                                                        \
           hwcontext.h                                                   \
           hwcontext_cuda.h                                              \
+          hwcontext_d3d11va.h                                           \
+          hwcontext_drm.h                                               \
           hwcontext_dxva2.h                                             \
           hwcontext_qsv.h                                               \
           hwcontext_vaapi.h                                             \
+          hwcontext_videotoolbox.h                                      \
           hwcontext_vdpau.h                                             \
           imgutils.h                                                    \
           intfloat.h                                                    \
@@ -63,6 +65,7 @@ HEADERS = adler32.h                                                     \
           samplefmt.h                                                   \
           sha.h                                                         \
           sha512.h                                                      \
+          spherical.h                                                   \
           stereo3d.h                                                    \
           threadmessage.h                                               \
           time.h                                                        \
@@ -140,6 +143,8 @@ OBJS = adler32.o                                                        \
        samplefmt.o                                                      \
        sha.o                                                            \
        sha512.o                                                         \
+       slicethread.o                                                    \
+       spherical.o                                                      \
        stereo3d.o                                                       \
        threadmessage.o                                                  \
        time.o                                                           \
@@ -154,11 +159,14 @@ OBJS = adler32.o                                                        \
 OBJS-$(!HAVE_ATOMICS_NATIVE)            += atomic.o                     \
 
 OBJS-$(CONFIG_CUDA)                     += hwcontext_cuda.o
+OBJS-$(CONFIG_D3D11VA)                  += hwcontext_d3d11va.o
 OBJS-$(CONFIG_DXVA2)                    += hwcontext_dxva2.o
 OBJS-$(CONFIG_QSV)                   += hwcontext_qsv.o
+OBJS-$(CONFIG_LIBDRM)                   += hwcontext_drm.o
 OBJS-$(CONFIG_LZO)                      += lzo.o
 OBJS-$(CONFIG_OPENCL)                   += opencl.o opencl_internal.o
 OBJS-$(CONFIG_VAAPI)                    += hwcontext_vaapi.o
+OBJS-$(CONFIG_VIDEOTOOLBOX)             += hwcontext_videotoolbox.o
 OBJS-$(CONFIG_VDPAU)                    += hwcontext_vdpau.o
 
 OBJS += $(COMPAT_OBJS:%=../compat/%)
@@ -166,10 +174,13 @@ OBJS += $(COMPAT_OBJS:%=../compat/%)
 # Windows resource file
 SLIBOBJS-$(HAVE_GNU_WINDRES)            += avutilres.o
 
-SKIPHEADERS-$(CONFIG_CUDA)             += hwcontext_cuda.h
+SKIPHEADERS-$(HAVE_CUDA_H)             += hwcontext_cuda.h
+SKIPHEADERS-$(CONFIG_CUDA)             += hwcontext_cuda_internal.h
+SKIPHEADERS-$(CONFIG_D3D11VA)          += hwcontext_d3d11va.h
 SKIPHEADERS-$(CONFIG_DXVA2)            += hwcontext_dxva2.h
 SKIPHEADERS-$(CONFIG_QSV)           += hwcontext_qsv.h
 SKIPHEADERS-$(CONFIG_VAAPI)            += hwcontext_vaapi.h
+SKIPHEADERS-$(CONFIG_VIDEOTOOLBOX)     += hwcontext_videotoolbox.h
 SKIPHEADERS-$(CONFIG_VDPAU)            += hwcontext_vdpau.h
 SKIPHEADERS-$(HAVE_ATOMICS_GCC)        += atomic_gcc.h
 SKIPHEADERS-$(HAVE_ATOMICS_SUNCC)      += atomic_suncc.h
@@ -178,7 +189,9 @@ SKIPHEADERS-$(CONFIG_OPENCL)           += opencl.h
 
 TESTPROGS = adler32                                                     \
             aes                                                         \
+            aes_ctr                                                     \
             atomic                                                      \
+            audio_fifo                                                  \
             avstring                                                    \
             base64                                                      \
             blowfish                                                    \
@@ -195,9 +208,9 @@ TESTPROGS = adler32                                                     \
             eval                                                        \
             file                                                        \
             fifo                                                        \
-            float_dsp                                                   \
             hash                                                        \
             hmac                                                        \
+            imgutils                                                    \
             lfg                                                         \
             lls                                                         \
             log                                                         \
@@ -208,6 +221,7 @@ TESTPROGS = adler32                                                     \
             parseutils                                                  \
             pixdesc                                                     \
             pixelutils                                                  \
+            pixfmt_best                                                 \
             random_seed                                                 \
             rational                                                    \
             ripemd                                                      \
@@ -220,6 +234,7 @@ TESTPROGS = adler32                                                     \
             xtea                                                        \
             tea                                                         \
 
+TESTPROGS-$(HAVE_THREADS)            += cpu_init
 TESTPROGS-$(HAVE_LZO1X_999_COMPRESS) += lzo
 
 TOOLS = crypto_bench ffhash ffeval ffescape
diff --git a/mythtv/external/FFmpeg/libavutil/aarch64/asm.S b/mythtv/external/FFmpeg/libavutil/aarch64/asm.S
index ff34e7a5e56..42897294280 100644
--- a/mythtv/external/FFmpeg/libavutil/aarch64/asm.S
+++ b/mythtv/external/FFmpeg/libavutil/aarch64/asm.S
@@ -72,15 +72,21 @@ ELF     .size   \name, . - \name
 \name:
 .endm
 
-.macro  movrel rd, val
+.macro  movrel rd, val, offset=0
 #if CONFIG_PIC && defined(__APPLE__)
+    .if \offset < 0
         adrp            \rd, \val@PAGE
         add             \rd, \rd, \val@PAGEOFF
+        sub             \rd, \rd, -(\offset)
+    .else
+        adrp            \rd, \val+(\offset)@PAGE
+        add             \rd, \rd, \val+(\offset)@PAGEOFF
+    .endif
 #elif CONFIG_PIC
-        adrp            \rd, \val
-        add             \rd, \rd, :lo12:\val
+        adrp            \rd, \val+(\offset)
+        add             \rd, \rd, :lo12:\val+(\offset)
 #else
-        ldr             \rd, =\val
+        ldr             \rd, =\val+\offset
 #endif
 .endm
 
diff --git a/mythtv/external/FFmpeg/libavutil/aarch64/cpu.c b/mythtv/external/FFmpeg/libavutil/aarch64/cpu.c
index 8ef077aaea3..cc641da576a 100644
--- a/mythtv/external/FFmpeg/libavutil/aarch64/cpu.c
+++ b/mythtv/external/FFmpeg/libavutil/aarch64/cpu.c
@@ -26,3 +26,13 @@ int ff_get_cpu_flags_aarch64(void)
            AV_CPU_FLAG_NEON  * HAVE_NEON  |
            AV_CPU_FLAG_VFP   * HAVE_VFP;
 }
+
+size_t ff_get_cpu_max_align_aarch64(void)
+{
+    int flags = av_get_cpu_flags();
+
+    if (flags & AV_CPU_FLAG_NEON)
+        return 16;
+
+    return 8;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/arm/asm.S b/mythtv/external/FFmpeg/libavutil/arm/asm.S
index e9b0bcabdb4..7d33a64fac3 100644
--- a/mythtv/external/FFmpeg/libavutil/arm/asm.S
+++ b/mythtv/external/FFmpeg/libavutil/arm/asm.S
@@ -40,6 +40,12 @@
 #   define FUNC @
 #endif
 
+#if HAVE_AS_FPU_DIRECTIVE
+#   define FPU
+#else
+#   define FPU @
+#endif
+
 #if   HAVE_NEON
         .arch           armv7-a
 #elif HAVE_ARMV6T2
@@ -54,11 +60,11 @@ ELF     .object_arch    armv4
 #endif
 
 #if   HAVE_NEON
-        .fpu            neon
+FPU     .fpu            neon
 ELF     .eabi_attribute 10, 0           @ suppress Tag_FP_arch
 ELF     .eabi_attribute 12, 0           @ suppress Tag_Advanced_SIMD_arch
 #elif HAVE_VFP
-        .fpu            vfp
+FPU     .fpu            vfp
 ELF     .eabi_attribute 10, 0           @ suppress Tag_FP_arch
 #endif
 
@@ -77,6 +83,9 @@ ELF     .section .note.GNU-stack,"",%progbits @ Mark stack as non-executable
         put_pic         %(.Lpic_idx - 1)
         .noaltmacro
       .endif
+      .if .Lpic_gp
+        .unreq          gp
+      .endif
 ELF     .size   \name, . - \name
 FUNC    .endfunc
         .purgem endfunc
@@ -175,6 +184,15 @@ T       ldr             \rd, [\rd]
 .endm
 
 .macro  movrelx         rd,  val, gp
+    .ifc \rd,\gp
+        .error      "movrelx needs two distinct registers"
+    .endif
+    .ifc \rd\()_\gp,r12_
+        .warning    "movrelx rd=\rd without explicit set gp"
+    .endif
+    .ifc \rd\()_\gp,ip_
+        .warning    "movrelx rd=\rd without explicit set gp"
+    .endif
 #if CONFIG_PIC && defined(__ELF__)
     .ifnb \gp
       .if .Lpic_gp
diff --git a/mythtv/external/FFmpeg/libavutil/arm/cpu.c b/mythtv/external/FFmpeg/libavutil/arm/cpu.c
index 3889ef011ca..81e85e25255 100644
--- a/mythtv/external/FFmpeg/libavutil/arm/cpu.c
+++ b/mythtv/external/FFmpeg/libavutil/arm/cpu.c
@@ -158,3 +158,13 @@ int ff_get_cpu_flags_arm(void)
 }
 
 #endif
+
+size_t ff_get_cpu_max_align_arm(void)
+{
+    int flags = av_get_cpu_flags();
+
+    if (flags & AV_CPU_FLAG_NEON)
+        return 16;
+
+    return 8;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/arm/float_dsp_init_vfp.c b/mythtv/external/FFmpeg/libavutil/arm/float_dsp_init_vfp.c
index e15abf3f54c..05873e7e375 100644
--- a/mythtv/external/FFmpeg/libavutil/arm/float_dsp_init_vfp.c
+++ b/mythtv/external/FFmpeg/libavutil/arm/float_dsp_init_vfp.c
@@ -36,11 +36,11 @@ void ff_butterflies_float_vfp(float *av_restrict v1, float *av_restrict v2, int
 
 av_cold void ff_float_dsp_init_vfp(AVFloatDSPContext *fdsp, int cpu_flags)
 {
-    if (!have_vfpv3(cpu_flags)) {
+    if (have_vfp_vm(cpu_flags)) {
         fdsp->vector_fmul = ff_vector_fmul_vfp;
         fdsp->vector_fmul_window = ff_vector_fmul_window_vfp;
     }
     fdsp->vector_fmul_reverse = ff_vector_fmul_reverse_vfp;
-    if (!have_vfpv3(cpu_flags))
+    if (have_vfp_vm(cpu_flags))
         fdsp->butterflies_float = ff_butterflies_float_vfp;
 }
diff --git a/mythtv/external/FFmpeg/libavutil/atomic_gcc.h b/mythtv/external/FFmpeg/libavutil/atomic_gcc.h
index 5f9fc49ba08..2bb43c3cea0 100644
--- a/mythtv/external/FFmpeg/libavutil/atomic_gcc.h
+++ b/mythtv/external/FFmpeg/libavutil/atomic_gcc.h
@@ -28,40 +28,27 @@
 #define avpriv_atomic_int_get atomic_int_get_gcc
 static inline int atomic_int_get_gcc(volatile int *ptr)
 {
-#if HAVE_ATOMIC_COMPARE_EXCHANGE
-    return __atomic_load_n(ptr, __ATOMIC_SEQ_CST);
-#else
     __sync_synchronize();
     return *ptr;
-#endif
 }
 
 #define avpriv_atomic_int_set atomic_int_set_gcc
 static inline void atomic_int_set_gcc(volatile int *ptr, int val)
 {
-#if HAVE_ATOMIC_COMPARE_EXCHANGE
-    __atomic_store_n(ptr, val, __ATOMIC_SEQ_CST);
-#else
     *ptr = val;
     __sync_synchronize();
-#endif
 }
 
 #define avpriv_atomic_int_add_and_fetch atomic_int_add_and_fetch_gcc
 static inline int atomic_int_add_and_fetch_gcc(volatile int *ptr, int inc)
 {
-#if HAVE_ATOMIC_COMPARE_EXCHANGE
-    return __atomic_add_fetch(ptr, inc, __ATOMIC_SEQ_CST);
-#else
     return __sync_add_and_fetch(ptr, inc);
-#endif
 }
 
 #define avpriv_atomic_ptr_cas atomic_ptr_cas_gcc
 static inline void *atomic_ptr_cas_gcc(void * volatile *ptr,
                                        void *oldval, void *newval)
 {
-#if HAVE_SYNC_VAL_COMPARE_AND_SWAP
 #ifdef __ARMCC_VERSION
     // armcc will throw an error if ptr is not an integer type
     volatile uintptr_t *tmp = (volatile uintptr_t*)ptr;
@@ -69,10 +56,6 @@ static inline void *atomic_ptr_cas_gcc(void * volatile *ptr,
 #else
     return __sync_val_compare_and_swap(ptr, oldval, newval);
 #endif
-#else
-    __atomic_compare_exchange_n(ptr, &oldval, newval, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
-    return oldval;
-#endif
 }
 
 #endif /* AVUTIL_ATOMIC_GCC_H */
diff --git a/mythtv/external/FFmpeg/libavutil/attributes.h b/mythtv/external/FFmpeg/libavutil/attributes.h
index 5c6b9deecb7..54d19011169 100644
--- a/mythtv/external/FFmpeg/libavutil/attributes.h
+++ b/mythtv/external/FFmpeg/libavutil/attributes.h
@@ -121,8 +121,7 @@
 #endif
 #endif
 
-
-#if defined(__GNUC__)
+#if defined(__GNUC__) || defined(__clang__)
 #    define av_unused __attribute__((unused))
 #else
 #    define av_unused
@@ -133,7 +132,7 @@
  * away.  This is useful for variables accessed only from inline
  * assembler without the compiler being aware.
  */
-#if AV_GCC_VERSION_AT_LEAST(3,1)
+#if AV_GCC_VERSION_AT_LEAST(3,1) || defined(__clang__)
 #    define av_used __attribute__((used))
 #else
 #    define av_used
diff --git a/mythtv/external/FFmpeg/libavutil/audio_fifo.c b/mythtv/external/FFmpeg/libavutil/audio_fifo.c
index de187104e6e..1bf75ced54b 100644
--- a/mythtv/external/FFmpeg/libavutil/audio_fifo.c
+++ b/mythtv/external/FFmpeg/libavutil/audio_fifo.c
@@ -180,7 +180,7 @@ int av_audio_fifo_peek_at(AVAudioFifo *af, void **data, int nb_samples, int offs
 
 int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
 {
-    int i, ret, size;
+    int i, size;
 
     if (nb_samples < 0)
         return AVERROR(EINVAL);
@@ -190,7 +190,7 @@ int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples)
 
     size = nb_samples * af->sample_size;
     for (i = 0; i < af->nb_buffers; i++) {
-        if ((ret = av_fifo_generic_read(af->buf[i], data[i], size, NULL)) < 0)
+        if (av_fifo_generic_read(af->buf[i], data[i], size, NULL) < 0)
             return AVERROR_BUG;
     }
     af->nb_samples -= nb_samples;
diff --git a/mythtv/external/FFmpeg/libavutil/avstring.c b/mythtv/external/FFmpeg/libavutil/avstring.c
index 1787a1ef54f..f03dd251417 100644
--- a/mythtv/external/FFmpeg/libavutil/avstring.c
+++ b/mythtv/external/FFmpeg/libavutil/avstring.c
@@ -231,6 +231,29 @@ int av_strncasecmp(const char *a, const char *b, size_t n)
     return c1 - c2;
 }
 
+char *av_strireplace(const char *str, const char *from, const char *to)
+{
+    char *ret = NULL;
+    const char *pstr2, *pstr = str;
+    size_t tolen = strlen(to), fromlen = strlen(from);
+    AVBPrint pbuf;
+
+    av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
+    while ((pstr2 = av_stristr(pstr, from))) {
+        av_bprint_append_data(&pbuf, pstr, pstr2 - pstr);
+        pstr = pstr2 + fromlen;
+        av_bprint_append_data(&pbuf, to, tolen);
+    }
+    av_bprint_append_data(&pbuf, pstr, strlen(pstr));
+    if (!av_bprint_is_complete(&pbuf)) {
+        av_bprint_finalize(&pbuf, NULL);
+    } else {
+        av_bprint_finalize(&pbuf, &ret);
+    }
+
+    return ret;
+}
+
 const char *av_basename(const char *path)
 {
     char *p = strrchr(path, '/');
diff --git a/mythtv/external/FFmpeg/libavutil/avstring.h b/mythtv/external/FFmpeg/libavutil/avstring.h
index dd2876990f2..04d2695640a 100644
--- a/mythtv/external/FFmpeg/libavutil/avstring.h
+++ b/mythtv/external/FFmpeg/libavutil/avstring.h
@@ -266,6 +266,11 @@ int av_strcasecmp(const char *a, const char *b);
  */
 int av_strncasecmp(const char *a, const char *b, size_t n);
 
+/**
+ * Locale-independent strings replace.
+ * @note This means only ASCII-range characters are replace
+ */
+char *av_strireplace(const char *str, const char *from, const char *to);
 
 /**
  * Thread safe basename.
diff --git a/mythtv/external/FFmpeg/libavutil/avutil.h b/mythtv/external/FFmpeg/libavutil/avutil.h
index 29dd830bf5e..4d633156d14 100644
--- a/mythtv/external/FFmpeg/libavutil/avutil.h
+++ b/mythtv/external/FFmpeg/libavutil/avutil.h
@@ -118,6 +118,12 @@
  *
  * @}
  *
+ * @defgroup lavu_video Video related
+ *
+ * @{
+ *
+ * @}
+ *
  * @defgroup lavu_audio Audio related
  *
  * @{
@@ -337,6 +343,20 @@ FILE *av_fopen_utf8(const char *path, const char *mode);
  */
 AVRational av_get_time_base_q(void);
 
+#define AV_FOURCC_MAX_STRING_SIZE 32
+
+#define av_fourcc2str(fourcc) av_fourcc_make_string((char[AV_FOURCC_MAX_STRING_SIZE]){0}, fourcc)
+
+/**
+ * Fill the provided buffer with a string containing a FourCC (four-character
+ * code) representation.
+ *
+ * @param buf    a buffer with size in bytes of at least AV_FOURCC_MAX_STRING_SIZE
+ * @param fourcc the fourcc to represent
+ * @return the buffer in input
+ */
+char *av_fourcc_make_string(char *buf, uint32_t fourcc);
+
 /**
  * @}
  * @}
diff --git a/mythtv/external/FFmpeg/libavutil/buffer.c b/mythtv/external/FFmpeg/libavutil/buffer.c
index 694e116a3c8..8d1aa5fa841 100644
--- a/mythtv/external/FFmpeg/libavutil/buffer.c
+++ b/mythtv/external/FFmpeg/libavutil/buffer.c
@@ -16,10 +16,10 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <stdatomic.h>
 #include <stdint.h>
 #include <string.h>
 
-#include "atomic.h"
 #include "buffer_internal.h"
 #include "common.h"
 #include "mem.h"
@@ -40,7 +40,8 @@ AVBufferRef *av_buffer_create(uint8_t *data, int size,
     buf->size     = size;
     buf->free     = free ? free : av_buffer_default_free;
     buf->opaque   = opaque;
-    buf->refcount = 1;
+
+    atomic_init(&buf->refcount, 1);
 
     if (flags & AV_BUFFER_FLAG_READONLY)
         buf->flags |= BUFFER_FLAG_READONLY;
@@ -98,7 +99,7 @@ AVBufferRef *av_buffer_ref(AVBufferRef *buf)
 
     *ret = *buf;
 
-    avpriv_atomic_int_add_and_fetch(&buf->buffer->refcount, 1);
+    atomic_fetch_add_explicit(&buf->buffer->refcount, 1, memory_order_relaxed);
 
     return ret;
 }
@@ -115,7 +116,7 @@ static void buffer_replace(AVBufferRef **dst, AVBufferRef **src)
     } else
         av_freep(dst);
 
-    if (!avpriv_atomic_int_add_and_fetch(&b->refcount, -1)) {
+    if (atomic_fetch_add_explicit(&b->refcount, -1, memory_order_acq_rel) == 1) {
         b->free(b->opaque, b->data);
         av_freep(&b);
     }
@@ -134,7 +135,7 @@ int av_buffer_is_writable(const AVBufferRef *buf)
     if (buf->buffer->flags & AV_BUFFER_FLAG_READONLY)
         return 0;
 
-    return avpriv_atomic_int_get(&buf->buffer->refcount) == 1;
+    return atomic_load(&buf->buffer->refcount) == 1;
 }
 
 void *av_buffer_get_opaque(const AVBufferRef *buf)
@@ -144,7 +145,7 @@ void *av_buffer_get_opaque(const AVBufferRef *buf)
 
 int av_buffer_get_ref_count(const AVBufferRef *buf)
 {
-    return buf->buffer->refcount;
+    return atomic_load(&buf->buffer->refcount);
 }
 
 int av_buffer_make_writable(AVBufferRef **pbuf)
@@ -191,7 +192,7 @@ int av_buffer_realloc(AVBufferRef **pbuf, int size)
         return 0;
 
     if (!(buf->buffer->flags & BUFFER_FLAG_REALLOCATABLE) ||
-        !av_buffer_is_writable(buf)) {
+        !av_buffer_is_writable(buf) || buf->data != buf->buffer->data) {
         /* cannot realloc, allocate a new reallocable buffer and copy data */
         AVBufferRef *new = NULL;
 
@@ -229,7 +230,7 @@ AVBufferPool *av_buffer_pool_init2(int size, void *opaque,
     pool->alloc2    = alloc;
     pool->pool_free = pool_free;
 
-    avpriv_atomic_int_set(&pool->refcount, 1);
+    atomic_init(&pool->refcount, 1);
 
     return pool;
 }
@@ -245,7 +246,7 @@ AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size))
     pool->size     = size;
     pool->alloc    = alloc ? alloc : av_buffer_alloc;
 
-    avpriv_atomic_int_set(&pool->refcount, 1);
+    atomic_init(&pool->refcount, 1);
 
     return pool;
 }
@@ -280,48 +281,10 @@ void av_buffer_pool_uninit(AVBufferPool **ppool)
     pool   = *ppool;
     *ppool = NULL;
 
-    if (!avpriv_atomic_int_add_and_fetch(&pool->refcount, -1))
+    if (atomic_fetch_add_explicit(&pool->refcount, -1, memory_order_acq_rel) == 1)
         buffer_pool_free(pool);
 }
 
-#if USE_ATOMICS
-/* remove the whole buffer list from the pool and return it */
-static BufferPoolEntry *get_pool(AVBufferPool *pool)
-{
-    BufferPoolEntry *cur = *(void * volatile *)&pool->pool, *last = NULL;
-
-    while (cur != last) {
-        last = cur;
-        cur = avpriv_atomic_ptr_cas((void * volatile *)&pool->pool, last, NULL);
-        if (!cur)
-            return NULL;
-    }
-
-    return cur;
-}
-
-static void add_to_pool(BufferPoolEntry *buf)
-{
-    AVBufferPool *pool;
-    BufferPoolEntry *cur, *end = buf;
-
-    if (!buf)
-        return;
-    pool = buf->pool;
-
-    while (end->next)
-        end = end->next;
-
-    while (avpriv_atomic_ptr_cas((void * volatile *)&pool->pool, NULL, buf)) {
-        /* pool is not empty, retrieve it and append it to our list */
-        cur = get_pool(pool);
-        end->next = cur;
-        while (end->next)
-            end = end->next;
-    }
-}
-#endif
-
 static void pool_release_buffer(void *opaque, uint8_t *data)
 {
     BufferPoolEntry *buf = opaque;
@@ -330,16 +293,12 @@ static void pool_release_buffer(void *opaque, uint8_t *data)
     if(CONFIG_MEMORY_POISONING)
         memset(buf->data, FF_MEMORY_POISON, pool->size);
 
-#if USE_ATOMICS
-    add_to_pool(buf);
-#else
     ff_mutex_lock(&pool->mutex);
     buf->next = pool->pool;
     pool->pool = buf;
     ff_mutex_unlock(&pool->mutex);
-#endif
 
-    if (!avpriv_atomic_int_add_and_fetch(&pool->refcount, -1))
+    if (atomic_fetch_add_explicit(&pool->refcount, -1, memory_order_acq_rel) == 1)
         buffer_pool_free(pool);
 }
 
@@ -369,11 +328,6 @@ static AVBufferRef *pool_alloc_buffer(AVBufferPool *pool)
     ret->buffer->opaque = buf;
     ret->buffer->free   = pool_release_buffer;
 
-#if USE_ATOMICS
-    avpriv_atomic_int_add_and_fetch(&pool->refcount, 1);
-    avpriv_atomic_int_add_and_fetch(&pool->nb_allocated, 1);
-#endif
-
     return ret;
 }
 
@@ -382,29 +336,6 @@ AVBufferRef *av_buffer_pool_get(AVBufferPool *pool)
     AVBufferRef *ret;
     BufferPoolEntry *buf;
 
-#if USE_ATOMICS
-    /* check whether the pool is empty */
-    buf = get_pool(pool);
-    if (!buf && pool->refcount <= pool->nb_allocated) {
-        av_log(NULL, AV_LOG_DEBUG, "Pool race dectected, spining to avoid overallocation and eventual OOM\n");
-        while (!buf && avpriv_atomic_int_get(&pool->refcount) <= avpriv_atomic_int_get(&pool->nb_allocated))
-            buf = get_pool(pool);
-    }
-
-    if (!buf)
-        return pool_alloc_buffer(pool);
-
-    /* keep the first entry, return the rest of the list to the pool */
-    add_to_pool(buf->next);
-    buf->next = NULL;
-
-    ret = av_buffer_create(buf->data, pool->size, pool_release_buffer,
-                           buf, 0);
-    if (!ret) {
-        add_to_pool(buf);
-        return NULL;
-    }
-#else
     ff_mutex_lock(&pool->mutex);
     buf = pool->pool;
     if (buf) {
@@ -418,10 +349,9 @@ AVBufferRef *av_buffer_pool_get(AVBufferPool *pool)
         ret = pool_alloc_buffer(pool);
     }
     ff_mutex_unlock(&pool->mutex);
-#endif
 
     if (ret)
-        avpriv_atomic_int_add_and_fetch(&pool->refcount, 1);
+        atomic_fetch_add_explicit(&pool->refcount, 1, memory_order_relaxed);
 
     return ret;
 }
diff --git a/mythtv/external/FFmpeg/libavutil/buffer.h b/mythtv/external/FFmpeg/libavutil/buffer.h
index 0c0ce12cf2f..73b6bd0b148 100644
--- a/mythtv/external/FFmpeg/libavutil/buffer.h
+++ b/mythtv/external/FFmpeg/libavutil/buffer.h
@@ -256,9 +256,10 @@ AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size));
  * @param alloc a function that will be used to allocate new buffers when the
  *              pool is empty.
  * @param pool_free a function that will be called immediately before the pool
- *                  is freed. I.e. after av_buffer_pool_can_uninit() is called
- *                  by the pool and all the frames are returned to the pool and
- *                  freed. It is intended to uninitialize the user opaque data.
+ *                  is freed. I.e. after av_buffer_pool_uninit() is called
+ *                  by the caller and all the frames are returned to the pool
+ *                  and freed. It is intended to uninitialize the user opaque
+ *                  data.
  * @return newly created buffer pool on success, NULL on error.
  */
 AVBufferPool *av_buffer_pool_init2(int size, void *opaque,
diff --git a/mythtv/external/FFmpeg/libavutil/buffer_internal.h b/mythtv/external/FFmpeg/libavutil/buffer_internal.h
index 29ce8a643c0..54b67047e5e 100644
--- a/mythtv/external/FFmpeg/libavutil/buffer_internal.h
+++ b/mythtv/external/FFmpeg/libavutil/buffer_internal.h
@@ -19,6 +19,7 @@
 #ifndef AVUTIL_BUFFER_INTERNAL_H
 #define AVUTIL_BUFFER_INTERNAL_H
 
+#include <stdatomic.h>
 #include <stdint.h>
 
 #include "buffer.h"
@@ -40,7 +41,7 @@ struct AVBuffer {
     /**
      *  number of existing AVBufferRef instances referring to this buffer
      */
-    volatile int refcount;
+    atomic_uint refcount;
 
     /**
      * a callback for freeing the data
@@ -85,9 +86,7 @@ struct AVBufferPool {
      * buffers have been released, then it's safe to free the pool and all
      * the buffers in it.
      */
-    volatile int refcount;
-
-    volatile int nb_allocated;
+    atomic_uint refcount;
 
     int size;
     void *opaque;
diff --git a/mythtv/external/FFmpeg/libavutil/channel_layout.c b/mythtv/external/FFmpeg/libavutil/channel_layout.c
index 26c87c96a89..3bd5ee29b75 100644
--- a/mythtv/external/FFmpeg/libavutil/channel_layout.c
+++ b/mythtv/external/FFmpeg/libavutil/channel_layout.c
@@ -152,6 +152,28 @@ uint64_t av_get_channel_layout(const char *name)
     return layout;
 }
 
+int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, int* nb_channels)
+{
+    int nb = 0;
+    char *end;
+    uint64_t layout = av_get_channel_layout(name);
+
+    if (layout) {
+        *channel_layout = layout;
+        *nb_channels = av_get_channel_layout_nb_channels(layout);
+        return 0;
+    }
+
+    nb = strtol(name, &end, 10);
+    if (!errno && *end  == 'C' && *(end + 1) == '\0' && nb > 0 && nb < 64) {
+        *channel_layout = 0;
+        *nb_channels = nb;
+        return 0;
+    }
+
+    return AVERROR(EINVAL);
+}
+
 void av_bprint_channel_layout(struct AVBPrint *bp,
                               int nb_channels, uint64_t channel_layout)
 {
diff --git a/mythtv/external/FFmpeg/libavutil/channel_layout.h b/mythtv/external/FFmpeg/libavutil/channel_layout.h
index ec7effead1d..50bb8f03c58 100644
--- a/mythtv/external/FFmpeg/libavutil/channel_layout.h
+++ b/mythtv/external/FFmpeg/libavutil/channel_layout.h
@@ -131,21 +131,30 @@ enum AVMatrixEncoding {
  *   5.0(side), 5.1, 5.1(side), 7.1, 7.1(wide), downmix);
  * - the name of a single channel (FL, FR, FC, LFE, BL, BR, FLC, FRC, BC,
  *   SL, SR, TC, TFL, TFC, TFR, TBL, TBC, TBR, DL, DR);
- * - a number of channels, in decimal, optionally followed by 'c', yielding
+ * - a number of channels, in decimal, followed by 'c', yielding
  *   the default channel layout for that number of channels (@see
  *   av_get_default_channel_layout);
  * - a channel layout mask, in hexadecimal starting with "0x" (see the
  *   AV_CH_* macros).
  *
- * @warning Starting from the next major bump the trailing character
- * 'c' to specify a number of channels will be required, while a
- * channel layout mask could also be specified as a decimal number
- * (if and only if not followed by "c").
- *
  * Example: "stereo+FC" = "2c+FC" = "2c+1c" = "0x7"
  */
 uint64_t av_get_channel_layout(const char *name);
 
+/**
+ * Return a channel layout and the number of channels based on the specified name.
+ *
+ * This function is similar to (@see av_get_channel_layout), but can also parse
+ * unknown channel layout specifications.
+ *
+ * @param[in]  name             channel layout specification string
+ * @param[out] channel_layout   parsed channel layout (0 if unknown)
+ * @param[out] nb_channels      number of channels
+ *
+ * @return 0 on success, AVERROR(EINVAL) if the parsing fails.
+ */
+int av_get_extended_channel_layout(const char *name, uint64_t* channel_layout, int* nb_channels);
+
 /**
  * Return a description of a channel layout.
  * If nb_channels is <= 0, it is guessed from the channel_layout.
diff --git a/mythtv/external/FFmpeg/libavutil/cpu.c b/mythtv/external/FFmpeg/libavutil/cpu.c
index f5785fc13fb..c8401b82580 100644
--- a/mythtv/external/FFmpeg/libavutil/cpu.c
+++ b/mythtv/external/FFmpeg/libavutil/cpu.c
@@ -16,8 +16,11 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <stddef.h>
 #include <stdint.h>
+#include <stdatomic.h>
 
+#include "attributes.h"
 #include "cpu.h"
 #include "cpu_internal.h"
 #include "config.h"
@@ -44,10 +47,24 @@
 #include <unistd.h>
 #endif
 
-static int flags, checked;
+static atomic_int cpu_flags = ATOMIC_VAR_INIT(-1);
+
+static int get_cpu_flags(void)
+{
+    if (ARCH_AARCH64)
+        return ff_get_cpu_flags_aarch64();
+    if (ARCH_ARM)
+        return ff_get_cpu_flags_arm();
+    if (ARCH_PPC)
+        return ff_get_cpu_flags_ppc();
+    if (ARCH_X86)
+        return ff_get_cpu_flags_x86();
+    return 0;
+}
 
 void av_force_cpu_flags(int arg){
-    if (   (arg & ( AV_CPU_FLAG_3DNOW    |
+    if (ARCH_X86 &&
+           (arg & ( AV_CPU_FLAG_3DNOW    |
                     AV_CPU_FLAG_3DNOWEXT |
                     AV_CPU_FLAG_MMXEXT   |
                     AV_CPU_FLAG_SSE      |
@@ -69,33 +86,23 @@ void av_force_cpu_flags(int arg){
         arg |= AV_CPU_FLAG_MMX;
     }
 
-    flags   = arg;
-    checked = arg != -1;
+    atomic_store_explicit(&cpu_flags, arg, memory_order_relaxed);
 }
 
 int av_get_cpu_flags(void)
 {
-    if (checked)
-        return flags;
-
-    if (ARCH_AARCH64)
-        flags = ff_get_cpu_flags_aarch64();
-    if (ARCH_ARM)
-        flags = ff_get_cpu_flags_arm();
-    if (ARCH_PPC)
-        flags = ff_get_cpu_flags_ppc();
-    if (ARCH_X86)
-        flags = ff_get_cpu_flags_x86();
-
-    checked = 1;
+    int flags = atomic_load_explicit(&cpu_flags, memory_order_relaxed);
+    if (flags == -1) {
+        flags = get_cpu_flags();
+        atomic_store_explicit(&cpu_flags, flags, memory_order_relaxed);
+    }
     return flags;
 }
 
 void av_set_cpu_flags_mask(int mask)
 {
-    checked       = 0;
-    flags         = av_get_cpu_flags() & mask;
-    checked       = 1;
+    atomic_store_explicit(&cpu_flags, get_cpu_flags() & mask,
+                          memory_order_relaxed);
 }
 
 int av_parse_cpu_flags(const char *s)
@@ -294,3 +301,17 @@ int av_cpu_count(void)
 
     return nb_cpus;
 }
+
+size_t av_cpu_max_align(void)
+{
+    if (ARCH_AARCH64)
+        return ff_get_cpu_max_align_aarch64();
+    if (ARCH_ARM)
+        return ff_get_cpu_max_align_arm();
+    if (ARCH_PPC)
+        return ff_get_cpu_max_align_ppc();
+    if (ARCH_X86)
+        return ff_get_cpu_max_align_x86();
+
+    return 8;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/cpu.h b/mythtv/external/FFmpeg/libavutil/cpu.h
index 4bff16714a3..9e5d40affef 100644
--- a/mythtv/external/FFmpeg/libavutil/cpu.h
+++ b/mythtv/external/FFmpeg/libavutil/cpu.h
@@ -21,6 +21,8 @@
 #ifndef AVUTIL_CPU_H
 #define AVUTIL_CPU_H
 
+#include <stddef.h>
+
 #include "attributes.h"
 
 #define AV_CPU_FLAG_FORCE    0x80000000 /* force usage of selected flags (OR) */
@@ -39,6 +41,7 @@
 #define AV_CPU_FLAG_SSE3SLOW 0x20000000 ///< SSE3 supported, but usually not faster
                                         ///< than regular MMX/SSE (e.g. Core1)
 #define AV_CPU_FLAG_SSSE3        0x0080 ///< Conroe SSSE3 functions
+#define AV_CPU_FLAG_SSSE3SLOW 0x4000000 ///< SSSE3 supported, but usually not faster
 #define AV_CPU_FLAG_ATOM     0x10000000 ///< Atom processor, some SSSE3 instructions are slower
 #define AV_CPU_FLAG_SSE4         0x0100 ///< Penryn SSE4.1 functions
 #define AV_CPU_FLAG_SSE42        0x0200 ///< Nehalem SSE4.2 functions
@@ -85,8 +88,6 @@ void av_force_cpu_flags(int flags);
  * Set a mask on flags returned by av_get_cpu_flags().
  * This function is mainly useful for testing.
  * Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible
- *
- * @warning this function is not thread safe.
  */
 attribute_deprecated void av_set_cpu_flags_mask(int mask);
 
@@ -114,4 +115,15 @@ int av_parse_cpu_caps(unsigned *flags, const char *s);
  */
 int av_cpu_count(void);
 
+/**
+ * Get the maximum data alignment that may be required by FFmpeg.
+ *
+ * Note that this is affected by the build configuration and the CPU flags mask,
+ * so e.g. if the CPU supports AVX, but libavutil has been built with
+ * --disable-avx or the AV_CPU_FLAG_AVX flag has been disabled through
+ *  av_set_cpu_flags_mask(), then this function will behave as if AVX is not
+ *  present.
+ */
+size_t av_cpu_max_align(void);
+
 #endif /* AVUTIL_CPU_H */
diff --git a/mythtv/external/FFmpeg/libavutil/cpu_internal.h b/mythtv/external/FFmpeg/libavutil/cpu_internal.h
index 6c352abe1b6..b8bf1e53964 100644
--- a/mythtv/external/FFmpeg/libavutil/cpu_internal.h
+++ b/mythtv/external/FFmpeg/libavutil/cpu_internal.h
@@ -44,4 +44,9 @@ int ff_get_cpu_flags_arm(void);
 int ff_get_cpu_flags_ppc(void);
 int ff_get_cpu_flags_x86(void);
 
+size_t ff_get_cpu_max_align_aarch64(void);
+size_t ff_get_cpu_max_align_arm(void);
+size_t ff_get_cpu_max_align_ppc(void);
+size_t ff_get_cpu_max_align_x86(void);
+
 #endif /* AVUTIL_CPU_INTERNAL_H */
diff --git a/mythtv/external/FFmpeg/libavutil/display.h b/mythtv/external/FFmpeg/libavutil/display.h
index 39c15ee6b83..515adad795d 100644
--- a/mythtv/external/FFmpeg/libavutil/display.h
+++ b/mythtv/external/FFmpeg/libavutil/display.h
@@ -18,6 +18,11 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+/**
+ * @file
+ * Display matrix
+ */
+
 #ifndef AVUTIL_DISPLAY_H
 #define AVUTIL_DISPLAY_H
 
@@ -25,15 +30,26 @@
 #include "common.h"
 
 /**
+ * @addtogroup lavu_video
+ * @{
+ *
+ * @defgroup lavu_video_display Display transformation matrix functions
+ * @{
+ */
+
+/**
+ * @addtogroup lavu_video_display
  * The display transformation matrix specifies an affine transformation that
  * should be applied to video frames for correct presentation. It is compatible
  * with the matrices stored in the ISO/IEC 14496-12 container format.
  *
  * The data is a 3x3 matrix represented as a 9-element array:
  *
+ * @code{.unparsed}
  *                                  | a b u |
  *   (a, b, u, c, d, v, x, y, w) -> | c d v |
  *                                  | x y w |
+ * @endcode
  *
  * All numbers are stored in native endianness, as 16.16 fixed-point values,
  * except for u, v and w, which are stored as 2.30 fixed-point values.
@@ -41,15 +57,21 @@
  * The transformation maps a point (p, q) in the source (pre-transformation)
  * frame to the point (p', q') in the destination (post-transformation) frame as
  * follows:
+ *
+ * @code{.unparsed}
  *               | a b u |
  *   (p, q, 1) . | c d v | = z * (p', q', 1)
  *               | x y w |
+ * @endcode
  *
  * The transformation can also be more explicitly written in components as
  * follows:
+ *
+ * @code{.unparsed}
  *   p' = (a * p + c * q + x) / z;
  *   q' = (b * p + d * q + y) / z;
  *   z  =  u * p + v * q + w
+ * @endcode
  */
 
 /**
@@ -84,4 +106,9 @@ void av_display_rotation_set(int32_t matrix[9], double angle);
  */
 void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip);
 
+/**
+ * @}
+ * @}
+ */
+
 #endif /* AVUTIL_DISPLAY_H */
diff --git a/mythtv/external/FFmpeg/libavutil/eval.c b/mythtv/external/FFmpeg/libavutil/eval.c
index d291c5d6d50..b5f4ea2409e 100644
--- a/mythtv/external/FFmpeg/libavutil/eval.c
+++ b/mythtv/external/FFmpeg/libavutil/eval.c
@@ -38,6 +38,7 @@
 #include "time.h"
 #include "avstring.h"
 #include "timer.h"
+#include "reverse.h"
 
 typedef struct Parser {
     const AVClass *class;
@@ -152,9 +153,9 @@ struct AVExpr {
         e_squish, e_gauss, e_ld, e_isnan, e_isinf,
         e_mod, e_max, e_min, e_eq, e_gt, e_gte, e_lte, e_lt,
         e_pow, e_mul, e_div, e_add,
-        e_last, e_st, e_while, e_taylor, e_root, e_floor, e_ceil, e_trunc,
+        e_last, e_st, e_while, e_taylor, e_root, e_floor, e_ceil, e_trunc, e_round,
         e_sqrt, e_not, e_random, e_hypot, e_gcd,
-        e_if, e_ifnot, e_print, e_bitand, e_bitor, e_between, e_clip
+        e_if, e_ifnot, e_print, e_bitand, e_bitor, e_between, e_clip, e_atan2, e_lerp,
     } type;
     double value; // is sign in other types
     union {
@@ -188,6 +189,7 @@ static double eval_expr(Parser *p, AVExpr *e)
         case e_floor:  return e->value * floor(eval_expr(p, e->param[0]));
         case e_ceil :  return e->value * ceil (eval_expr(p, e->param[0]));
         case e_trunc:  return e->value * trunc(eval_expr(p, e->param[0]));
+        case e_round:  return e->value * round(eval_expr(p, e->param[0]));
         case e_sqrt:   return e->value * sqrt (eval_expr(p, e->param[0]));
         case e_not:    return e->value * (eval_expr(p, e->param[0]) == 0);
         case e_if:     return e->value * (eval_expr(p, e->param[0]) ? eval_expr(p, e->param[1]) :
@@ -206,6 +208,12 @@ static double eval_expr(Parser *p, AVExpr *e)
             return e->value * (d >= eval_expr(p, e->param[1]) &&
                                d <= eval_expr(p, e->param[2]));
         }
+        case e_lerp: {
+            double v0 = eval_expr(p, e->param[0]);
+            double v1 = eval_expr(p, e->param[1]);
+            double f  = eval_expr(p, e->param[2]);
+            return v0 + (v1 - v0) * f;
+        }
         case e_print: {
             double x = eval_expr(p, e->param[0]);
             int level = e->param[1] ? av_clip(eval_expr(p, e->param[1]), INT_MIN, INT_MAX) : AV_LOG_INFO;
@@ -305,6 +313,7 @@ static double eval_expr(Parser *p, AVExpr *e)
                 case e_last:return e->value * d2;
                 case e_st : return e->value * (p->var[av_clip(d, 0, VARS-1)]= d2);
                 case e_hypot:return e->value * hypot(d, d2);
+                case e_atan2:return e->value * atan2(d, d2);
                 case e_bitand: return isnan(d) || isnan(d2) ? NAN : e->value * ((long int)d & (long int)d2);
                 case e_bitor:  return isnan(d) || isnan(d2) ? NAN : e->value * ((long int)d | (long int)d2);
             }
@@ -438,6 +447,7 @@ static int parse_primary(AVExpr **e, Parser *p)
     else if (strmatch(next, "floor" )) d->type = e_floor;
     else if (strmatch(next, "ceil"  )) d->type = e_ceil;
     else if (strmatch(next, "trunc" )) d->type = e_trunc;
+    else if (strmatch(next, "round" )) d->type = e_round;
     else if (strmatch(next, "sqrt"  )) d->type = e_sqrt;
     else if (strmatch(next, "not"   )) d->type = e_not;
     else if (strmatch(next, "pow"   )) d->type = e_pow;
@@ -451,6 +461,8 @@ static int parse_primary(AVExpr **e, Parser *p)
     else if (strmatch(next, "bitor" )) d->type = e_bitor;
     else if (strmatch(next, "between"))d->type = e_between;
     else if (strmatch(next, "clip"  )) d->type = e_clip;
+    else if (strmatch(next, "atan2" )) d->type = e_atan2;
+    else if (strmatch(next, "lerp"  )) d->type = e_lerp;
     else {
         for (i=0; p->func1_names && p->func1_names[i]; i++) {
             if (strmatch(next, p->func1_names[i])) {
@@ -634,6 +646,7 @@ static int verify_expr(AVExpr *e)
         case e_floor:
         case e_ceil:
         case e_trunc:
+        case e_round:
         case e_sqrt:
         case e_not:
         case e_random:
@@ -648,6 +661,7 @@ static int verify_expr(AVExpr *e)
                    && (!e->param[2] || verify_expr(e->param[2]));
         case e_between:
         case e_clip:
+        case e_lerp:
             return verify_expr(e->param[0]) &&
                    verify_expr(e->param[1]) &&
                    verify_expr(e->param[2]);
diff --git a/mythtv/external/FFmpeg/libavutil/float_dsp.c b/mythtv/external/FFmpeg/libavutil/float_dsp.c
index c85daffc6a9..1d4911d8152 100644
--- a/mythtv/external/FFmpeg/libavutil/float_dsp.c
+++ b/mythtv/external/FFmpeg/libavutil/float_dsp.c
@@ -40,6 +40,14 @@ static void vector_fmac_scalar_c(float *dst, const float *src, float mul,
         dst[i] += src[i] * mul;
 }
 
+static void vector_dmac_scalar_c(double *dst, const double *src, double mul,
+                                 int len)
+{
+    int i;
+    for (i = 0; i < len; i++)
+        dst[i] += src[i] * mul;
+}
+
 static void vector_fmul_scalar_c(float *dst, const float *src, float mul,
                                  int len)
 {
@@ -125,6 +133,7 @@ av_cold AVFloatDSPContext *avpriv_float_dsp_alloc(int bit_exact)
     fdsp->vector_fmul = vector_fmul_c;
     fdsp->vector_fmac_scalar = vector_fmac_scalar_c;
     fdsp->vector_fmul_scalar = vector_fmul_scalar_c;
+    fdsp->vector_dmac_scalar = vector_dmac_scalar_c;
     fdsp->vector_dmul_scalar = vector_dmul_scalar_c;
     fdsp->vector_fmul_window = vector_fmul_window_c;
     fdsp->vector_fmul_add = vector_fmul_add_c;
diff --git a/mythtv/external/FFmpeg/libavutil/float_dsp.h b/mythtv/external/FFmpeg/libavutil/float_dsp.h
index d1be38f947d..2c24d93471f 100644
--- a/mythtv/external/FFmpeg/libavutil/float_dsp.h
+++ b/mythtv/external/FFmpeg/libavutil/float_dsp.h
@@ -54,6 +54,22 @@ typedef struct AVFloatDSPContext {
     void (*vector_fmac_scalar)(float *dst, const float *src, float mul,
                                int len);
 
+    /**
+     * Multiply a vector of doubles by a scalar double and add to
+     * destination vector.  Source and destination vectors must
+     * overlap exactly or not at all.
+     *
+     * @param dst result vector
+     *            constraints: 32-byte aligned
+     * @param src input vector
+     *            constraints: 32-byte aligned
+     * @param mul scalar value
+     * @param len length of vector
+     *            constraints: multiple of 16
+     */
+    void (*vector_dmac_scalar)(double *dst, const double *src, double mul,
+                               int len);
+
     /**
      * Multiply a vector of floats by a scalar float.  Source and
      * destination vectors must overlap exactly or not at all.
diff --git a/mythtv/external/FFmpeg/libavutil/frame.c b/mythtv/external/FFmpeg/libavutil/frame.c
index 6d64d8c86d3..4839db95c43 100644
--- a/mythtv/external/FFmpeg/libavutil/frame.c
+++ b/mythtv/external/FFmpeg/libavutil/frame.c
@@ -26,6 +26,11 @@
 #include "mem.h"
 #include "samplefmt.h"
 
+
+static AVFrameSideData *frame_new_side_data(AVFrame *frame,
+                                            enum AVFrameSideDataType type,
+                                            AVBufferRef *buf);
+
 MAKE_ACCESSORS(AVFrame, frame, int64_t, best_effort_timestamp)
 MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_duration)
 MAKE_ACCESSORS(AVFrame, frame, int64_t, pkt_pos)
@@ -176,6 +181,9 @@ static int get_video_buffer(AVFrame *frame, int align)
         return ret;
 
     if (!frame->linesize[0]) {
+        if (align <= 0)
+            align = 32; /* STRIDE_ALIGN. Should be av_cpu_max_align() */
+
         for(i=1; i<=align; i+=i) {
             ret = av_image_fill_linesizes(frame->linesize, frame->format,
                                           FFALIGN(frame->width, i));
@@ -292,6 +300,10 @@ static int frame_copy_props(AVFrame *dst, const AVFrame *src, int force_copy)
     dst->key_frame              = src->key_frame;
     dst->pict_type              = src->pict_type;
     dst->sample_aspect_ratio    = src->sample_aspect_ratio;
+    dst->crop_top               = src->crop_top;
+    dst->crop_bottom            = src->crop_bottom;
+    dst->crop_left              = src->crop_left;
+    dst->crop_right             = src->crop_right;
     dst->pts                    = src->pts;
     dst->repeat_pict            = src->repeat_pict;
     dst->interlaced_frame       = src->interlaced_frame;
@@ -344,18 +356,11 @@ FF_ENABLE_DEPRECATION_WARNINGS
             }
             memcpy(sd_dst->data, sd_src->data, sd_src->size);
         } else {
-            sd_dst = av_frame_new_side_data(dst, sd_src->type, 0);
+            sd_dst = frame_new_side_data(dst, sd_src->type, av_buffer_ref(sd_src->buf));
             if (!sd_dst) {
                 wipe_side_data(dst);
                 return AVERROR(ENOMEM);
             }
-            sd_dst->buf = av_buffer_ref(sd_src->buf);
-            if (!sd_dst->buf) {
-                wipe_side_data(dst);
-                return AVERROR(ENOMEM);
-            }
-            sd_dst->data = sd_dst->buf->data;
-            sd_dst->size = sd_dst->buf->size;
         }
         av_dict_copy(&sd_dst->metadata, sd_src->metadata, 0);
     }
@@ -384,6 +389,13 @@ FF_ENABLE_DEPRECATION_WARNINGS
     memcpy(dst->scte_cc_buf, src->scte_cc_buf, src->scte_cc_len);
     /* MythTV ATSC Subtitle Support -- End */
 
+    av_buffer_unref(&dst->opaque_ref);
+    if (src->opaque_ref) {
+        dst->opaque_ref = av_buffer_ref(src->opaque_ref);
+        if (!dst->opaque_ref)
+            return AVERROR(ENOMEM);
+    }
+
     return 0;
 }
 
@@ -518,6 +530,8 @@ void av_frame_unref(AVFrame *frame)
 
     av_buffer_unref(&frame->hw_frames_ctx);
 
+    av_buffer_unref(&frame->opaque_ref);
+
     get_frame_defaults(frame);
 }
 
@@ -629,40 +643,47 @@ AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane)
     return NULL;
 }
 
-AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
-                                        enum AVFrameSideDataType type,
-                                        int size)
+static AVFrameSideData *frame_new_side_data(AVFrame *frame,
+                                            enum AVFrameSideDataType type,
+                                            AVBufferRef *buf)
 {
     AVFrameSideData *ret, **tmp;
 
-    if (frame->nb_side_data > INT_MAX / sizeof(*frame->side_data) - 1)
+    if (!buf)
         return NULL;
 
+    if (frame->nb_side_data > INT_MAX / sizeof(*frame->side_data) - 1)
+        goto fail;
+
     tmp = av_realloc(frame->side_data,
                      (frame->nb_side_data + 1) * sizeof(*frame->side_data));
     if (!tmp)
-        return NULL;
+        goto fail;
     frame->side_data = tmp;
 
     ret = av_mallocz(sizeof(*ret));
     if (!ret)
-        return NULL;
+        goto fail;
 
-    if (size > 0) {
-        ret->buf = av_buffer_alloc(size);
-        if (!ret->buf) {
-            av_freep(&ret);
-            return NULL;
-        }
-
-        ret->data = ret->buf->data;
-        ret->size = size;
-    }
+    ret->buf = buf;
+    ret->data = ret->buf->data;
+    ret->size = buf->size;
     ret->type = type;
 
     frame->side_data[frame->nb_side_data++] = ret;
 
     return ret;
+fail:
+    av_buffer_unref(&buf);
+    return NULL;
+}
+
+AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
+                                        enum AVFrameSideDataType type,
+                                        int size)
+{
+
+    return frame_new_side_data(frame, type, av_buffer_alloc(size));
 }
 
 AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
@@ -730,7 +751,7 @@ int av_frame_copy(AVFrame *dst, const AVFrame *src)
 
     if (dst->width > 0 && dst->height > 0)
         return frame_copy_video(dst, src);
-    else if (dst->nb_samples > 0 && dst->channel_layout)
+    else if (dst->nb_samples > 0 && dst->channels > 0)
         return frame_copy_audio(dst, src);
 
     return AVERROR(EINVAL);
@@ -765,7 +786,109 @@ const char *av_frame_side_data_name(enum AVFrameSideDataType type)
     case AV_FRAME_DATA_SKIP_SAMPLES:    return "Skip samples";
     case AV_FRAME_DATA_AUDIO_SERVICE_TYPE:          return "Audio service type";
     case AV_FRAME_DATA_MASTERING_DISPLAY_METADATA:  return "Mastering display metadata";
+    case AV_FRAME_DATA_CONTENT_LIGHT_LEVEL:         return "Content light level metadata";
     case AV_FRAME_DATA_GOP_TIMECODE:                return "GOP timecode";
+    case AV_FRAME_DATA_ICC_PROFILE:                 return "ICC profile";
     }
     return NULL;
 }
+
+static int calc_cropping_offsets(size_t offsets[4], const AVFrame *frame,
+                                 const AVPixFmtDescriptor *desc)
+{
+    int i, j;
+
+    for (i = 0; frame->data[i]; i++) {
+        const AVComponentDescriptor *comp = NULL;
+        int shift_x = (i == 1 || i == 2) ? desc->log2_chroma_w : 0;
+        int shift_y = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
+
+        if (desc->flags & (AV_PIX_FMT_FLAG_PAL | AV_PIX_FMT_FLAG_PSEUDOPAL) && i == 1) {
+            offsets[i] = 0;
+            break;
+        }
+
+        /* find any component descriptor for this plane */
+        for (j = 0; j < desc->nb_components; j++) {
+            if (desc->comp[j].plane == i) {
+                comp = &desc->comp[j];
+                break;
+            }
+        }
+        if (!comp)
+            return AVERROR_BUG;
+
+        offsets[i] = (frame->crop_top  >> shift_y) * frame->linesize[i] +
+                     (frame->crop_left >> shift_x) * comp->step;
+    }
+
+    return 0;
+}
+
+int av_frame_apply_cropping(AVFrame *frame, int flags)
+{
+    const AVPixFmtDescriptor *desc;
+    size_t offsets[4];
+    int i;
+
+    if (!(frame->width > 0 && frame->height > 0))
+        return AVERROR(EINVAL);
+
+    if (frame->crop_left >= INT_MAX - frame->crop_right        ||
+        frame->crop_top  >= INT_MAX - frame->crop_bottom       ||
+        (frame->crop_left + frame->crop_right) >= frame->width ||
+        (frame->crop_top + frame->crop_bottom) >= frame->height)
+        return AVERROR(ERANGE);
+
+    desc = av_pix_fmt_desc_get(frame->format);
+    if (!desc)
+        return AVERROR_BUG;
+
+    /* Apply just the right/bottom cropping for hwaccel formats. Bitstream
+     * formats cannot be easily handled here either (and corresponding decoders
+     * should not export any cropping anyway), so do the same for those as well.
+     * */
+    if (desc->flags & (AV_PIX_FMT_FLAG_BITSTREAM | AV_PIX_FMT_FLAG_HWACCEL)) {
+        frame->width      -= frame->crop_right;
+        frame->height     -= frame->crop_bottom;
+        frame->crop_right  = 0;
+        frame->crop_bottom = 0;
+        return 0;
+    }
+
+    /* calculate the offsets for each plane */
+    calc_cropping_offsets(offsets, frame, desc);
+
+    /* adjust the offsets to avoid breaking alignment */
+    if (!(flags & AV_FRAME_CROP_UNALIGNED)) {
+        int log2_crop_align = frame->crop_left ? ff_ctz(frame->crop_left) : INT_MAX;
+        int min_log2_align = INT_MAX;
+
+        for (i = 0; frame->data[i]; i++) {
+            int log2_align = offsets[i] ? ff_ctz(offsets[i]) : INT_MAX;
+            min_log2_align = FFMIN(log2_align, min_log2_align);
+        }
+
+        /* we assume, and it should always be true, that the data alignment is
+         * related to the cropping alignment by a constant power-of-2 factor */
+        if (log2_crop_align < min_log2_align)
+            return AVERROR_BUG;
+
+        if (min_log2_align < 5) {
+            frame->crop_left &= ~((1 << (5 + log2_crop_align - min_log2_align)) - 1);
+            calc_cropping_offsets(offsets, frame, desc);
+        }
+    }
+
+    for (i = 0; frame->data[i]; i++)
+        frame->data[i] += offsets[i];
+
+    frame->width      -= (frame->crop_left + frame->crop_right);
+    frame->height     -= (frame->crop_top  + frame->crop_bottom);
+    frame->crop_left   = 0;
+    frame->crop_right  = 0;
+    frame->crop_top    = 0;
+    frame->crop_bottom = 0;
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/frame.h b/mythtv/external/FFmpeg/libavutil/frame.h
index 048869ac5a2..770f2b5e12c 100644
--- a/mythtv/external/FFmpeg/libavutil/frame.h
+++ b/mythtv/external/FFmpeg/libavutil/frame.h
@@ -25,6 +25,7 @@
 #ifndef AVUTIL_FRAME_H
 #define AVUTIL_FRAME_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "avutil.h"
@@ -120,7 +121,26 @@ enum AVFrameSideDataType {
      * The GOP timecode in 25 bit timecode format. Data format is 64-bit integer.
      * This is set on the first frame of a GOP that has a temporal reference of 0.
      */
-    AV_FRAME_DATA_GOP_TIMECODE
+    AV_FRAME_DATA_GOP_TIMECODE,
+
+    /**
+     * The data represents the AVSphericalMapping structure defined in
+     * libavutil/spherical.h.
+     */
+    AV_FRAME_DATA_SPHERICAL,
+
+    /**
+     * Content light level (based on CTA-861.3). This payload contains data in
+     * the form of the AVContentLightMetadata struct.
+     */
+    AV_FRAME_DATA_CONTENT_LIGHT_LEVEL,
+
+    /**
+     * The data contains an ICC profile as an opaque octet buffer following the
+     * format described by ISO 15076-1 with an optional name defined in the
+     * metadata key entry "name".
+     */
+    AV_FRAME_DATA_ICC_PROFILE,
 };
 
 enum AVActiveFormatDescription {
@@ -173,9 +193,6 @@ typedef struct AVFrameSideData {
  *
  * sizeof(AVFrame) is not a part of the public ABI, so new fields may be added
  * to the end with a minor bump.
- * Similarly fields that are marked as to be only accessed by
- * av_opt_ptr() can be reordered. This allows 2 forks to add fields
- * without breaking compatibility with each other.
  *
  * Fields can be accessed through AVOptions, the name string used, matches the
  * C structure field name for fields accessible through AVOptions. The AVClass
@@ -231,9 +248,18 @@ typedef struct AVFrame {
     uint8_t **extended_data;
 
     /**
-     * width and height of the video frame
+     * @name Video dimensions
+     * Video frames only. The coded dimensions (in pixels) of the video frame,
+     * i.e. the size of the rectangle that contains some well-defined values.
+     *
+     * @note The part of the frame intended for display/presentation is further
+     * restricted by the @ref cropping "Cropping rectangle".
+     * @{
      */
     int width, height;
+    /**
+     * @}
+     */
 
     /**
      * number of audio samples (per channel) described by this frame
@@ -414,8 +440,6 @@ typedef struct AVFrame {
 
     /**
      * MPEG vs JPEG YUV range.
-     * It must be accessed using av_frame_get_color_range() and
-     * av_frame_set_color_range().
      * - encoding: Set by user
      * - decoding: Set by libavcodec
      */
@@ -427,8 +451,6 @@ typedef struct AVFrame {
 
     /**
      * YUV colorspace type.
-     * It must be accessed using av_frame_get_colorspace() and
-     * av_frame_set_colorspace().
      * - encoding: Set by user
      * - decoding: Set by libavcodec
      */
@@ -438,8 +460,6 @@ typedef struct AVFrame {
 
     /**
      * frame timestamp estimated using various heuristics, in stream time base
-     * Code outside libavutil should access this field using:
-     * av_frame_get_best_effort_timestamp(frame)
      * - encoding: unused
      * - decoding: set by libavcodec, read by user.
      */
@@ -447,8 +467,6 @@ typedef struct AVFrame {
 
     /**
      * reordered pos from the last AVPacket that has been input into the decoder
-     * Code outside libavutil should access this field using:
-     * av_frame_get_pkt_pos(frame)
      * - encoding: unused
      * - decoding: Read by user.
      */
@@ -457,8 +475,6 @@ typedef struct AVFrame {
     /**
      * duration of the corresponding packet, expressed in
      * AVStream->time_base units, 0 if unknown.
-     * Code outside libavutil should access this field using:
-     * av_frame_get_pkt_duration(frame)
      * - encoding: unused
      * - decoding: Read by user.
      */
@@ -466,8 +482,6 @@ typedef struct AVFrame {
 
     /**
      * metadata.
-     * Code outside libavutil should access this field using:
-     * av_frame_get_metadata(frame)
      * - encoding: Set by user.
      * - decoding: Set by libavcodec.
      */
@@ -477,8 +491,6 @@ typedef struct AVFrame {
      * decode error flags of the frame, set to a combination of
      * FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there
      * were errors during the decoding.
-     * Code outside libavutil should access this field using:
-     * av_frame_get_decode_error_flags(frame)
      * - encoding: unused
      * - decoding: set by libavcodec, read by user.
      */
@@ -488,8 +500,6 @@ typedef struct AVFrame {
 
     /**
      * number of audio channels, only used for audio.
-     * Code outside libavutil should access this field using:
-     * av_frame_get_channels(frame)
      * - encoding: unused
      * - decoding: Read by user.
      */
@@ -511,8 +521,7 @@ typedef struct AVFrame {
 
     /**
      * size of the corresponding packet containing the compressed
-     * frame. It must be accessed using av_frame_get_pkt_size() and
-     * av_frame_set_pkt_size().
+     * frame.
      * It is set to a negative value if unknown.
      * - encoding: unused
      * - decoding: set by libavcodec, read by user.
@@ -522,13 +531,11 @@ typedef struct AVFrame {
 #if FF_API_FRAME_QP
     /**
      * QP table
-     * Not to be accessed directly from outside libavutil
      */
     attribute_deprecated
     int8_t *qscale_table;
     /**
      * QP store stride
-     * Not to be accessed directly from outside libavutil
      */
     attribute_deprecated
     int qstride;
@@ -536,9 +543,6 @@ typedef struct AVFrame {
     attribute_deprecated
     int qscale_type;
 
-    /**
-     * Not to be accessed directly from outside libavutil
-     */
     AVBufferRef *qp_table_buf;
 #endif
     /**
@@ -546,12 +550,38 @@ typedef struct AVFrame {
      * AVHWFramesContext describing the frame.
      */
     AVBufferRef *hw_frames_ctx;
+
+    /**
+     * AVBufferRef for free use by the API user. FFmpeg will never check the
+     * contents of the buffer ref. FFmpeg calls av_buffer_unref() on it when
+     * the frame is unreferenced. av_frame_copy_props() calls create a new
+     * reference with av_buffer_ref() for the target frame's opaque_ref field.
+     *
+     * This is unrelated to the opaque field, although it serves a similar
+     * purpose.
+     */
+    AVBufferRef *opaque_ref;
+
+    /**
+     * @anchor cropping
+     * @name Cropping
+     * Video frames only. The number of pixels to discard from the the
+     * top/bottom/left/right border of the frame to obtain the sub-rectangle of
+     * the frame intended for presentation.
+     * @{
+     */
+    size_t crop_top;
+    size_t crop_bottom;
+    size_t crop_left;
+    size_t crop_right;
+    /**
+     * @}
+     */
 } AVFrame;
 
 /**
- * Accessors for some AVFrame fields.
- * The position of these field in the structure is not part of the ABI,
- * they should not be accessed directly outside libavutil.
+ * Accessors for some AVFrame fields. These used to be provided for ABI
+ * compatibility, and do not need to be used anymore.
  */
 int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame);
 void    av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val);
@@ -665,7 +695,9 @@ void av_frame_move_ref(AVFrame *dst, AVFrame *src);
  *           cases.
  *
  * @param frame frame in which to store the new buffers.
- * @param align required buffer size alignment
+ * @param align Required buffer size alignment. If equal to 0, alignment will be
+ *              chosen automatically for the current CPU. It is highly
+ *              recommended to pass 0 here unless you know what you are doing.
  *
  * @return 0 on success, a negative AVERROR on error.
  */
@@ -757,6 +789,40 @@ AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
  */
 void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type);
 
+
+/**
+ * Flags for frame cropping.
+ */
+enum {
+    /**
+     * Apply the maximum possible cropping, even if it requires setting the
+     * AVFrame.data[] entries to unaligned pointers. Passing unaligned data
+     * to FFmpeg API is generally not allowed, and causes undefined behavior
+     * (such as crashes). You can pass unaligned data only to FFmpeg APIs that
+     * are explicitly documented to accept it. Use this flag only if you
+     * absolutely know what you are doing.
+     */
+    AV_FRAME_CROP_UNALIGNED     = 1 << 0,
+};
+
+/**
+ * Crop the given video AVFrame according to its crop_left/crop_top/crop_right/
+ * crop_bottom fields. If cropping is successful, the function will adjust the
+ * data pointers and the width/height fields, and set the crop fields to 0.
+ *
+ * In all cases, the cropping boundaries will be rounded to the inherent
+ * alignment of the pixel format. In some cases, such as for opaque hwaccel
+ * formats, the left/top cropping is ignored. The crop fields are set to 0 even
+ * if the cropping was rounded or ignored.
+ *
+ * @param frame the frame which should be cropped
+ * @param flags Some combination of AV_FRAME_CROP_* flags, or 0.
+ *
+ * @return >= 0 on success, a negative AVERROR on error. If the cropping fields
+ * were invalid, AVERROR(ERANGE) is returned, and nothing is changed.
+ */
+int av_frame_apply_cropping(AVFrame *frame, int flags);
+
 /**
  * @return a string identifying the side data type
  */
diff --git a/mythtv/external/FFmpeg/libavutil/hmac.c b/mythtv/external/FFmpeg/libavutil/hmac.c
index 8ec6d70406c..d064a105f42 100644
--- a/mythtv/external/FFmpeg/libavutil/hmac.c
+++ b/mythtv/external/FFmpeg/libavutil/hmac.c
@@ -18,6 +18,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <stddef.h>
+#include <stdint.h>
 #include <string.h>
 
 #include "attributes.h"
@@ -26,16 +28,25 @@
 #include "sha.h"
 #include "sha512.h"
 #include "mem.h"
+#include "version.h"
 
 #define MAX_HASHLEN 64
 #define MAX_BLOCKLEN 128
 
+typedef void (*hmac_final)(void *ctx, uint8_t *dst);
+#if FF_API_CRYPTO_SIZE_T
+typedef void (*hmac_update)(void *ctx, const uint8_t *src, int len);
+#else
+typedef void (*hmac_update)(void *ctx, const uint8_t *src, size_t len);
+#endif
+typedef void (*hmac_init)(void *ctx);
+
 struct AVHMAC {
     void *hash;
     int blocklen, hashlen;
-    void (*final)(void*, uint8_t*);
-    void (*update)(void*, const uint8_t*, int len);
-    void (*init)(void*);
+    hmac_final  final;
+    hmac_update update;
+    hmac_init   init;
     uint8_t key[MAX_BLOCKLEN];
     int keylen;
 };
@@ -67,49 +78,49 @@ AVHMAC *av_hmac_alloc(enum AVHMACType type)
     case AV_HMAC_MD5:
         c->blocklen = 64;
         c->hashlen  = 16;
-        c->init     = (void*)av_md5_init;
-        c->update   = (void*)av_md5_update;
-        c->final    = (void*)av_md5_final;
+        c->init     = (hmac_init) av_md5_init;
+        c->update   = (hmac_update) av_md5_update;
+        c->final    = (hmac_final) av_md5_final;
         c->hash     = av_md5_alloc();
         break;
     case AV_HMAC_SHA1:
         c->blocklen = 64;
         c->hashlen  = 20;
         c->init     = sha160_init;
-        c->update   = (void*)av_sha_update;
-        c->final    = (void*)av_sha_final;
+        c->update   = (hmac_update) av_sha_update;
+        c->final    = (hmac_final) av_sha_final;
         c->hash     = av_sha_alloc();
         break;
     case AV_HMAC_SHA224:
         c->blocklen = 64;
         c->hashlen  = 28;
         c->init     = sha224_init;
-        c->update   = (void*)av_sha_update;
-        c->final    = (void*)av_sha_final;
+        c->update   = (hmac_update) av_sha_update;
+        c->final    = (hmac_final) av_sha_final;
         c->hash     = av_sha_alloc();
         break;
     case AV_HMAC_SHA256:
         c->blocklen = 64;
         c->hashlen  = 32;
         c->init     = sha256_init;
-        c->update   = (void*)av_sha_update;
-        c->final    = (void*)av_sha_final;
+        c->update   = (hmac_update) av_sha_update;
+        c->final    = (hmac_final) av_sha_final;
         c->hash     = av_sha_alloc();
         break;
     case AV_HMAC_SHA384:
         c->blocklen = 128;
         c->hashlen  = 48;
         c->init     = sha384_init;
-        c->update   = (void*)av_sha512_update;
-        c->final    = (void*)av_sha512_final;
+        c->update   = (hmac_update) av_sha512_update;
+        c->final    = (hmac_final) av_sha512_final;
         c->hash     = av_sha512_alloc();
         break;
     case AV_HMAC_SHA512:
         c->blocklen = 128;
         c->hashlen  = 64;
         c->init     = sha512_init;
-        c->update   = (void*)av_sha512_update;
-        c->final    = (void*)av_sha512_final;
+        c->update   = (hmac_update) av_sha512_update;
+        c->final    = (hmac_final) av_sha512_final;
         c->hash     = av_sha512_alloc();
         break;
     default:
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext.c b/mythtv/external/FFmpeg/libavutil/hwcontext.c
index be1d73e82f6..048e82126fb 100644
--- a/mythtv/external/FFmpeg/libavutil/hwcontext.c
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext.c
@@ -28,10 +28,16 @@
 #include "pixdesc.h"
 #include "pixfmt.h"
 
-static const HWContextType *hw_table[] = {
+static const HWContextType * const hw_table[] = {
 #if CONFIG_CUDA
     &ff_hwcontext_type_cuda,
 #endif
+#if CONFIG_D3D11VA
+    &ff_hwcontext_type_d3d11va,
+#endif
+#if CONFIG_LIBDRM
+    &ff_hwcontext_type_drm,
+#endif
 #if CONFIG_DXVA2
     &ff_hwcontext_type_dxva2,
 #endif
@@ -43,10 +49,57 @@ static const HWContextType *hw_table[] = {
 #endif
 #if CONFIG_VDPAU
     &ff_hwcontext_type_vdpau,
+#endif
+#if CONFIG_VIDEOTOOLBOX
+    &ff_hwcontext_type_videotoolbox,
 #endif
     NULL,
 };
 
+static const char *const hw_type_names[] = {
+    [AV_HWDEVICE_TYPE_CUDA]   = "cuda",
+    [AV_HWDEVICE_TYPE_DRM]    = "drm",
+    [AV_HWDEVICE_TYPE_DXVA2]  = "dxva2",
+    [AV_HWDEVICE_TYPE_D3D11VA] = "d3d11va",
+    [AV_HWDEVICE_TYPE_QSV]    = "qsv",
+    [AV_HWDEVICE_TYPE_VAAPI]  = "vaapi",
+    [AV_HWDEVICE_TYPE_VDPAU]  = "vdpau",
+    [AV_HWDEVICE_TYPE_VIDEOTOOLBOX] = "videotoolbox",
+};
+
+enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
+{
+    int type;
+    for (type = 0; type < FF_ARRAY_ELEMS(hw_type_names); type++) {
+        if (hw_type_names[type] && !strcmp(hw_type_names[type], name))
+            return type;
+    }
+    return AV_HWDEVICE_TYPE_NONE;
+}
+
+const char *av_hwdevice_get_type_name(enum AVHWDeviceType type)
+{
+    if (type >= 0 && type < FF_ARRAY_ELEMS(hw_type_names))
+        return hw_type_names[type];
+    else
+        return NULL;
+}
+
+enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev)
+{
+    enum AVHWDeviceType next;
+    int i, set = 0;
+    for (i = 0; hw_table[i]; i++) {
+        if (prev != AV_HWDEVICE_TYPE_NONE && hw_table[i]->type <= prev)
+            continue;
+        if (!set || hw_table[i]->type < next) {
+            next = hw_table[i]->type;
+            set = 1;
+        }
+    }
+    return set ? next : AV_HWDEVICE_TYPE_NONE;
+}
+
 static const AVClass hwdevice_ctx_class = {
     .class_name = "AVHWDeviceContext",
     .item_name  = av_default_item_name,
@@ -65,6 +118,8 @@ static void hwdevice_ctx_free(void *opaque, uint8_t *data)
     if (ctx->free)
         ctx->free(ctx);
 
+    av_buffer_unref(&ctx->internal->source_device);
+
     av_freep(&ctx->hwctx);
     av_freep(&ctx->internal->priv);
     av_freep(&ctx->internal);
@@ -157,14 +212,19 @@ static void hwframe_ctx_free(void *opaque, uint8_t *data)
 {
     AVHWFramesContext *ctx = (AVHWFramesContext*)data;
 
-    if (ctx->internal->pool_internal)
-        av_buffer_pool_uninit(&ctx->internal->pool_internal);
+    if (ctx->internal->source_frames) {
+        av_buffer_unref(&ctx->internal->source_frames);
 
-    if (ctx->internal->hw_type->frames_uninit)
-        ctx->internal->hw_type->frames_uninit(ctx);
+    } else {
+        if (ctx->internal->pool_internal)
+            av_buffer_pool_uninit(&ctx->internal->pool_internal);
 
-    if (ctx->free)
-        ctx->free(ctx);
+        if (ctx->internal->hw_type->frames_uninit)
+            ctx->internal->hw_type->frames_uninit(ctx);
+
+        if (ctx->free)
+            ctx->free(ctx);
+    }
 
     av_buffer_unref(&ctx->device_ref);
 
@@ -266,6 +326,11 @@ int av_hwframe_ctx_init(AVBufferRef *ref)
     const enum AVPixelFormat *pix_fmt;
     int ret;
 
+    if (ctx->internal->source_frames) {
+        /* A derived frame context is already initialised. */
+        return 0;
+    }
+
     /* validate the pixel format */
     for (pix_fmt = ctx->internal->hw_type->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++) {
         if (*pix_fmt == ctx->format)
@@ -321,6 +386,7 @@ int av_hwframe_transfer_get_formats(AVBufferRef *hwframe_ref,
 
 static int transfer_data_alloc(AVFrame *dst, const AVFrame *src, int flags)
 {
+    AVHWFramesContext *ctx = (AVHWFramesContext*)src->hw_frames_ctx->data;
     AVFrame *frame_tmp;
     int ret = 0;
 
@@ -343,8 +409,8 @@ static int transfer_data_alloc(AVFrame *dst, const AVFrame *src, int flags)
         frame_tmp->format = formats[0];
         av_freep(&formats);
     }
-    frame_tmp->width  = src->width;
-    frame_tmp->height = src->height;
+    frame_tmp->width  = ctx->width;
+    frame_tmp->height = ctx->height;
 
     ret = av_frame_get_buffer(frame_tmp, 32);
     if (ret < 0)
@@ -354,6 +420,9 @@ static int transfer_data_alloc(AVFrame *dst, const AVFrame *src, int flags)
     if (ret < 0)
         goto fail;
 
+    frame_tmp->width  = src->width;
+    frame_tmp->height = src->height;
+
     av_frame_move_ref(dst, frame_tmp);
 
 fail:
@@ -392,6 +461,41 @@ int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
     AVHWFramesContext *ctx = (AVHWFramesContext*)hwframe_ref->data;
     int ret;
 
+    if (ctx->internal->source_frames) {
+        // This is a derived frame context, so we allocate in the source
+        // and map the frame immediately.
+        AVFrame *src_frame;
+
+        frame->format = ctx->format;
+        frame->hw_frames_ctx = av_buffer_ref(hwframe_ref);
+        if (!frame->hw_frames_ctx)
+            return AVERROR(ENOMEM);
+
+        src_frame = av_frame_alloc();
+        if (!src_frame)
+            return AVERROR(ENOMEM);
+
+        ret = av_hwframe_get_buffer(ctx->internal->source_frames,
+                                    src_frame, 0);
+        if (ret < 0)
+            return ret;
+
+        ret = av_hwframe_map(frame, src_frame,
+                             ctx->internal->source_allocation_map_flags);
+        if (ret) {
+            av_log(ctx, AV_LOG_ERROR, "Failed to map frame into derived "
+                   "frame context: %d.\n", ret);
+            av_frame_free(&src_frame);
+            return ret;
+        }
+
+        // Free the source frame immediately - the mapped frame still
+        // contains a reference to it.
+        av_frame_free(&src_frame);
+
+        return 0;
+    }
+
     if (!ctx->internal->hw_type->frames_get_buffer)
         return AVERROR(ENOSYS);
 
@@ -491,3 +595,271 @@ int av_hwdevice_ctx_create(AVBufferRef **pdevice_ref, enum AVHWDeviceType type,
     *pdevice_ref = NULL;
     return ret;
 }
+
+int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ref_ptr,
+                                   enum AVHWDeviceType type,
+                                   AVBufferRef *src_ref, int flags)
+{
+    AVBufferRef *dst_ref = NULL, *tmp_ref;
+    AVHWDeviceContext *dst_ctx, *tmp_ctx;
+    int ret = 0;
+
+    tmp_ref = src_ref;
+    while (tmp_ref) {
+        tmp_ctx = (AVHWDeviceContext*)tmp_ref->data;
+        if (tmp_ctx->type == type) {
+            dst_ref = av_buffer_ref(tmp_ref);
+            if (!dst_ref) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+            goto done;
+        }
+        tmp_ref = tmp_ctx->internal->source_device;
+    }
+
+    dst_ref = av_hwdevice_ctx_alloc(type);
+    if (!dst_ref) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+    dst_ctx = (AVHWDeviceContext*)dst_ref->data;
+
+    tmp_ref = src_ref;
+    while (tmp_ref) {
+        tmp_ctx = (AVHWDeviceContext*)tmp_ref->data;
+        if (dst_ctx->internal->hw_type->device_derive) {
+            ret = dst_ctx->internal->hw_type->device_derive(dst_ctx,
+                                                            tmp_ctx,
+                                                            flags);
+            if (ret == 0) {
+                dst_ctx->internal->source_device = av_buffer_ref(src_ref);
+                if (!dst_ctx->internal->source_device) {
+                    ret = AVERROR(ENOMEM);
+                    goto fail;
+                }
+                goto done;
+            }
+            if (ret != AVERROR(ENOSYS))
+                goto fail;
+        }
+        tmp_ref = tmp_ctx->internal->source_device;
+    }
+
+    ret = AVERROR(ENOSYS);
+    goto fail;
+
+done:
+    ret = av_hwdevice_ctx_init(dst_ref);
+    if (ret < 0)
+        goto fail;
+
+    *dst_ref_ptr = dst_ref;
+    return 0;
+
+fail:
+    av_buffer_unref(&dst_ref);
+    *dst_ref_ptr = NULL;
+    return ret;
+}
+
+static void ff_hwframe_unmap(void *opaque, uint8_t *data)
+{
+    HWMapDescriptor *hwmap = (HWMapDescriptor*)data;
+    AVHWFramesContext *ctx = opaque;
+
+    if (hwmap->unmap)
+        hwmap->unmap(ctx, hwmap);
+
+    av_frame_free(&hwmap->source);
+
+    av_buffer_unref(&hwmap->hw_frames_ctx);
+
+    av_free(hwmap);
+}
+
+int ff_hwframe_map_create(AVBufferRef *hwframe_ref,
+                          AVFrame *dst, const AVFrame *src,
+                          void (*unmap)(AVHWFramesContext *ctx,
+                                        HWMapDescriptor *hwmap),
+                          void *priv)
+{
+    AVHWFramesContext *ctx = (AVHWFramesContext*)hwframe_ref->data;
+    HWMapDescriptor *hwmap;
+    int ret;
+
+    hwmap = av_mallocz(sizeof(*hwmap));
+    if (!hwmap) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    hwmap->source = av_frame_alloc();
+    if (!hwmap->source) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+    ret = av_frame_ref(hwmap->source, src);
+    if (ret < 0)
+        goto fail;
+
+    hwmap->hw_frames_ctx = av_buffer_ref(hwframe_ref);
+    if (!hwmap->hw_frames_ctx) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    hwmap->unmap = unmap;
+    hwmap->priv  = priv;
+
+    dst->buf[0] = av_buffer_create((uint8_t*)hwmap, sizeof(*hwmap),
+                                   &ff_hwframe_unmap, ctx, 0);
+    if (!dst->buf[0]) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    return 0;
+
+fail:
+    if (hwmap) {
+        av_buffer_unref(&hwmap->hw_frames_ctx);
+        av_frame_free(&hwmap->source);
+    }
+    av_free(hwmap);
+    return ret;
+}
+
+int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags)
+{
+    AVHWFramesContext *src_frames, *dst_frames;
+    HWMapDescriptor *hwmap;
+    int ret;
+
+    if (src->hw_frames_ctx && dst->hw_frames_ctx) {
+        src_frames = (AVHWFramesContext*)src->hw_frames_ctx->data;
+        dst_frames = (AVHWFramesContext*)dst->hw_frames_ctx->data;
+
+        if ((src_frames == dst_frames &&
+             src->format == dst_frames->sw_format &&
+             dst->format == dst_frames->format) ||
+            (src_frames->internal->source_frames &&
+             src_frames->internal->source_frames->data ==
+             (uint8_t*)dst_frames)) {
+            // This is an unmap operation.  We don't need to directly
+            // do anything here other than fill in the original frame,
+            // because the real unmap will be invoked when the last
+            // reference to the mapped frame disappears.
+            if (!src->buf[0]) {
+                av_log(src_frames, AV_LOG_ERROR, "Invalid mapping "
+                       "found when attempting unmap.\n");
+                return AVERROR(EINVAL);
+            }
+            hwmap = (HWMapDescriptor*)src->buf[0]->data;
+            av_frame_unref(dst);
+            return av_frame_ref(dst, hwmap->source);
+        }
+    }
+
+    if (src->hw_frames_ctx) {
+        src_frames = (AVHWFramesContext*)src->hw_frames_ctx->data;
+
+        if (src_frames->format == src->format &&
+            src_frames->internal->hw_type->map_from) {
+            ret = src_frames->internal->hw_type->map_from(src_frames,
+                                                          dst, src, flags);
+            if (ret != AVERROR(ENOSYS))
+                return ret;
+        }
+    }
+
+    if (dst->hw_frames_ctx) {
+        dst_frames = (AVHWFramesContext*)dst->hw_frames_ctx->data;
+
+        if (dst_frames->format == dst->format &&
+            dst_frames->internal->hw_type->map_to) {
+            ret = dst_frames->internal->hw_type->map_to(dst_frames,
+                                                        dst, src, flags);
+            if (ret != AVERROR(ENOSYS))
+                return ret;
+        }
+    }
+
+    return AVERROR(ENOSYS);
+}
+
+int av_hwframe_ctx_create_derived(AVBufferRef **derived_frame_ctx,
+                                  enum AVPixelFormat format,
+                                  AVBufferRef *derived_device_ctx,
+                                  AVBufferRef *source_frame_ctx,
+                                  int flags)
+{
+    AVBufferRef   *dst_ref = NULL;
+    AVHWFramesContext *dst = NULL;
+    AVHWFramesContext *src = (AVHWFramesContext*)source_frame_ctx->data;
+    int ret;
+
+    if (src->internal->source_frames) {
+        AVHWFramesContext *src_src =
+            (AVHWFramesContext*)src->internal->source_frames->data;
+        AVHWDeviceContext *dst_dev =
+            (AVHWDeviceContext*)derived_device_ctx->data;
+
+        if (src_src->device_ctx == dst_dev) {
+            // This is actually an unmapping, so we just return a
+            // reference to the source frame context.
+            *derived_frame_ctx =
+                av_buffer_ref(src->internal->source_frames);
+            if (!*derived_frame_ctx) {
+                ret = AVERROR(ENOMEM);
+                goto fail;
+            }
+            return 0;
+        }
+    }
+
+    dst_ref = av_hwframe_ctx_alloc(derived_device_ctx);
+    if (!dst_ref) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    dst = (AVHWFramesContext*)dst_ref->data;
+
+    dst->format    = format;
+    dst->sw_format = src->sw_format;
+    dst->width     = src->width;
+    dst->height    = src->height;
+
+    dst->internal->source_frames = av_buffer_ref(source_frame_ctx);
+    if (!dst->internal->source_frames) {
+        ret = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    dst->internal->source_allocation_map_flags =
+        flags & (AV_HWFRAME_MAP_READ      |
+                 AV_HWFRAME_MAP_WRITE     |
+                 AV_HWFRAME_MAP_OVERWRITE |
+                 AV_HWFRAME_MAP_DIRECT);
+
+    ret = AVERROR(ENOSYS);
+    if (src->internal->hw_type->frames_derive_from)
+        ret = src->internal->hw_type->frames_derive_from(dst, src, flags);
+    if (ret == AVERROR(ENOSYS) &&
+        dst->internal->hw_type->frames_derive_to)
+        ret = dst->internal->hw_type->frames_derive_to(dst, src, flags);
+    if (ret == AVERROR(ENOSYS))
+        ret = 0;
+    if (ret)
+        goto fail;
+
+    *derived_frame_ctx = dst_ref;
+    return 0;
+
+fail:
+    if (dst)
+        av_buffer_unref(&dst->internal->source_frames);
+    av_buffer_unref(&dst_ref);
+    return ret;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext.h b/mythtv/external/FFmpeg/libavutil/hwcontext.h
index 5e2af092a41..03334e20e06 100644
--- a/mythtv/external/FFmpeg/libavutil/hwcontext.h
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext.h
@@ -30,6 +30,10 @@ enum AVHWDeviceType {
     AV_HWDEVICE_TYPE_VAAPI,
     AV_HWDEVICE_TYPE_DXVA2,
     AV_HWDEVICE_TYPE_QSV,
+    AV_HWDEVICE_TYPE_VIDEOTOOLBOX,
+    AV_HWDEVICE_TYPE_NONE,
+    AV_HWDEVICE_TYPE_D3D11VA,
+    AV_HWDEVICE_TYPE_DRM,
 };
 
 typedef struct AVHWDeviceInternal AVHWDeviceInternal;
@@ -223,10 +227,36 @@ typedef struct AVHWFramesContext {
 } AVHWFramesContext;
 
 /**
- * Allocate an AVHWDeviceContext for a given pixel format.
+ * Look up an AVHWDeviceType by name.
  *
- * @param format a hwaccel pixel format (AV_PIX_FMT_FLAG_HWACCEL must be set
- *               on the corresponding format descriptor)
+ * @param name String name of the device type (case-insensitive).
+ * @return The type from enum AVHWDeviceType, or AV_HWDEVICE_TYPE_NONE if
+ *         not found.
+ */
+enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name);
+
+/** Get the string name of an AVHWDeviceType.
+ *
+ * @param type Type from enum AVHWDeviceType.
+ * @return Pointer to a static string containing the name, or NULL if the type
+ *         is not valid.
+ */
+const char *av_hwdevice_get_type_name(enum AVHWDeviceType type);
+
+/**
+ * Iterate over supported device types.
+ *
+ * @param type AV_HWDEVICE_TYPE_NONE initially, then the previous type
+ *             returned by this function in subsequent iterations.
+ * @return The next usable device type from enum AVHWDeviceType, or
+ *         AV_HWDEVICE_TYPE_NONE if there are no more.
+ */
+enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev);
+
+/**
+ * Allocate an AVHWDeviceContext for a given hardware type.
+ *
+ * @param type the type of the hardware device to allocate.
  * @return a reference to the newly created AVHWDeviceContext on success or NULL
  *         on failure.
  */
@@ -270,6 +300,32 @@ int av_hwdevice_ctx_init(AVBufferRef *ref);
 int av_hwdevice_ctx_create(AVBufferRef **device_ctx, enum AVHWDeviceType type,
                            const char *device, AVDictionary *opts, int flags);
 
+/**
+ * Create a new device of the specified type from an existing device.
+ *
+ * If the source device is a device of the target type or was originally
+ * derived from such a device (possibly through one or more intermediate
+ * devices of other types), then this will return a reference to the
+ * existing device of the same type as is requested.
+ *
+ * Otherwise, it will attempt to derive a new device from the given source
+ * device.  If direct derivation to the new type is not implemented, it will
+ * attempt the same derivation from each ancestor of the source device in
+ * turn looking for an implemented derivation method.
+ *
+ * @param dst_ctx On success, a reference to the newly-created
+ *                AVHWDeviceContext.
+ * @param type    The type of the new device to create.
+ * @param src_ctx A reference to an existing AVHWDeviceContext which will be
+ *                used to create the new device.
+ * @param flags   Currently unused; should be set to zero.
+ * @return        Zero on success, a negative AVERROR code on failure.
+ */
+int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ctx,
+                                   enum AVHWDeviceType type,
+                                   AVBufferRef *src_ctx, int flags);
+
+
 /**
  * Allocate an AVHWFramesContext tied to a given device context.
  *
@@ -318,6 +374,14 @@ int av_hwframe_get_buffer(AVBufferRef *hwframe_ctx, AVFrame *frame, int flags);
  * If dst->format is set, then this format will be used, otherwise (when
  * dst->format is AV_PIX_FMT_NONE) the first acceptable format will be chosen.
  *
+ * The two frames must have matching allocated dimensions (i.e. equal to
+ * AVHWFramesContext.width/height), since not all device types support
+ * transferring a sub-rectangle of the whole surface. The display dimensions
+ * (i.e. AVFrame.width/height) may be smaller than the allocated dimensions, but
+ * also have to be equal for both frames. When the display dimensions are
+ * smaller than the allocated dimensions, the content of the padding in the
+ * destination frame is unspecified.
+ *
  * @param dst the destination frame. dst is not touched on failure.
  * @param src the source frame.
  * @param flags currently unused, should be set to zero
@@ -410,7 +474,7 @@ void *av_hwdevice_hwconfig_alloc(AVBufferRef *device_ctx);
  * configuration is provided, returns the maximum possible capabilities
  * of the device.
  *
- * @param device_ctx a reference to the associated AVHWDeviceContext.
+ * @param ref a reference to the associated AVHWDeviceContext.
  * @param hwconfig a filled HW-specific configuration structure, or NULL
  *        to return the maximum possible capabilities of the device.
  * @return AVHWFramesConstraints structure describing the constraints
@@ -426,4 +490,93 @@ AVHWFramesConstraints *av_hwdevice_get_hwframe_constraints(AVBufferRef *ref,
  */
 void av_hwframe_constraints_free(AVHWFramesConstraints **constraints);
 
+
+/**
+ * Flags to apply to frame mappings.
+ */
+enum {
+    /**
+     * The mapping must be readable.
+     */
+    AV_HWFRAME_MAP_READ      = 1 << 0,
+    /**
+     * The mapping must be writeable.
+     */
+    AV_HWFRAME_MAP_WRITE     = 1 << 1,
+    /**
+     * The mapped frame will be overwritten completely in subsequent
+     * operations, so the current frame data need not be loaded.  Any values
+     * which are not overwritten are unspecified.
+     */
+    AV_HWFRAME_MAP_OVERWRITE = 1 << 2,
+    /**
+     * The mapping must be direct.  That is, there must not be any copying in
+     * the map or unmap steps.  Note that performance of direct mappings may
+     * be much lower than normal memory.
+     */
+    AV_HWFRAME_MAP_DIRECT    = 1 << 3,
+};
+
+/**
+ * Map a hardware frame.
+ *
+ * This has a number of different possible effects, depending on the format
+ * and origin of the src and dst frames.  On input, src should be a usable
+ * frame with valid buffers and dst should be blank (typically as just created
+ * by av_frame_alloc()).  src should have an associated hwframe context, and
+ * dst may optionally have a format and associated hwframe context.
+ *
+ * If src was created by mapping a frame from the hwframe context of dst,
+ * then this function undoes the mapping - dst is replaced by a reference to
+ * the frame that src was originally mapped from.
+ *
+ * If both src and dst have an associated hwframe context, then this function
+ * attempts to map the src frame from its hardware context to that of dst and
+ * then fill dst with appropriate data to be usable there.  This will only be
+ * possible if the hwframe contexts and associated devices are compatible -
+ * given compatible devices, av_hwframe_ctx_create_derived() can be used to
+ * create a hwframe context for dst in which mapping should be possible.
+ *
+ * If src has a hwframe context but dst does not, then the src frame is
+ * mapped to normal memory and should thereafter be usable as a normal frame.
+ * If the format is set on dst, then the mapping will attempt to create dst
+ * with that format and fail if it is not possible.  If format is unset (is
+ * AV_PIX_FMT_NONE) then dst will be mapped with whatever the most appropriate
+ * format to use is (probably the sw_format of the src hwframe context).
+ *
+ * A return value of AVERROR(ENOSYS) indicates that the mapping is not
+ * possible with the given arguments and hwframe setup, while other return
+ * values indicate that it failed somehow.
+ *
+ * @param dst Destination frame, to contain the mapping.
+ * @param src Source frame, to be mapped.
+ * @param flags Some combination of AV_HWFRAME_MAP_* flags.
+ * @return Zero on success, negative AVERROR code on failure.
+ */
+int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags);
+
+
+/**
+ * Create and initialise an AVHWFramesContext as a mapping of another existing
+ * AVHWFramesContext on a different device.
+ *
+ * av_hwframe_ctx_init() should not be called after this.
+ *
+ * @param derived_frame_ctx  On success, a reference to the newly created
+ *                           AVHWFramesContext.
+ * @param derived_device_ctx A reference to the device to create the new
+ *                           AVHWFramesContext on.
+ * @param source_frame_ctx   A reference to an existing AVHWFramesContext
+ *                           which will be mapped to the derived context.
+ * @param flags  Some combination of AV_HWFRAME_MAP_* flags, defining the
+ *               mapping parameters to apply to frames which are allocated
+ *               in the derived device.
+ * @return       Zero on success, negative AVERROR code on failure.
+ */
+int av_hwframe_ctx_create_derived(AVBufferRef **derived_frame_ctx,
+                                  enum AVPixelFormat format,
+                                  AVBufferRef *derived_device_ctx,
+                                  AVBufferRef *source_frame_ctx,
+                                  int flags);
+
 #endif /* AVUTIL_HWCONTEXT_H */
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_cuda.c b/mythtv/external/FFmpeg/libavutil/hwcontext_cuda.c
index e1dcab0f253..dfb67bc941e 100644
--- a/mythtv/external/FFmpeg/libavutil/hwcontext_cuda.c
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_cuda.c
@@ -20,7 +20,7 @@
 #include "common.h"
 #include "hwcontext.h"
 #include "hwcontext_internal.h"
-#include "hwcontext_cuda.h"
+#include "hwcontext_cuda_internal.h"
 #include "mem.h"
 #include "pixdesc.h"
 #include "pixfmt.h"
@@ -35,50 +35,80 @@ static const enum AVPixelFormat supported_formats[] = {
     AV_PIX_FMT_NV12,
     AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUV444P,
+    AV_PIX_FMT_P010,
+    AV_PIX_FMT_P016,
+    AV_PIX_FMT_YUV444P16,
 };
 
+static int cuda_frames_get_constraints(AVHWDeviceContext *ctx,
+                                       const void *hwconfig,
+                                       AVHWFramesConstraints *constraints)
+{
+    int i;
+
+    constraints->valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(supported_formats) + 1,
+                                                    sizeof(*constraints->valid_sw_formats));
+    if (!constraints->valid_sw_formats)
+        return AVERROR(ENOMEM);
+
+    for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++)
+        constraints->valid_sw_formats[i] = supported_formats[i];
+    constraints->valid_sw_formats[FF_ARRAY_ELEMS(supported_formats)] = AV_PIX_FMT_NONE;
+
+    constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));
+    if (!constraints->valid_hw_formats)
+        return AVERROR(ENOMEM);
+
+    constraints->valid_hw_formats[0] = AV_PIX_FMT_CUDA;
+    constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
+
+    return 0;
+}
+
 static void cuda_buffer_free(void *opaque, uint8_t *data)
 {
     AVHWFramesContext *ctx = opaque;
     AVCUDADeviceContext *hwctx = ctx->device_ctx->hwctx;
+    CudaFunctions *cu = hwctx->internal->cuda_dl;
 
     CUcontext dummy;
 
-    cuCtxPushCurrent(hwctx->cuda_ctx);
+    cu->cuCtxPushCurrent(hwctx->cuda_ctx);
 
-    cuMemFree((CUdeviceptr)data);
+    cu->cuMemFree((CUdeviceptr)data);
 
-    cuCtxPopCurrent(&dummy);
+    cu->cuCtxPopCurrent(&dummy);
 }
 
 static AVBufferRef *cuda_pool_alloc(void *opaque, int size)
 {
     AVHWFramesContext     *ctx = opaque;
     AVCUDADeviceContext *hwctx = ctx->device_ctx->hwctx;
+    CudaFunctions          *cu = hwctx->internal->cuda_dl;
 
     AVBufferRef *ret = NULL;
     CUcontext dummy = NULL;
     CUdeviceptr data;
     CUresult err;
 
-    err = cuCtxPushCurrent(hwctx->cuda_ctx);
+    err = cu->cuCtxPushCurrent(hwctx->cuda_ctx);
     if (err != CUDA_SUCCESS) {
         av_log(ctx, AV_LOG_ERROR, "Error setting current CUDA context\n");
         return NULL;
     }
 
-    err = cuMemAlloc(&data, size);
+    err = cu->cuMemAlloc(&data, size);
     if (err != CUDA_SUCCESS)
         goto fail;
 
     ret = av_buffer_create((uint8_t*)data, size, cuda_buffer_free, ctx, 0);
     if (!ret) {
-        cuMemFree(data);
+        cu->cuMemFree(data);
         goto fail;
     }
 
 fail:
-    cuCtxPopCurrent(&dummy);
+    cu->cuCtxPopCurrent(&dummy);
     return ret;
 }
 
@@ -109,8 +139,16 @@ static int cuda_frames_init(AVHWFramesContext *ctx)
             size = aligned_width * ctx->height * 3 / 2;
             break;
         case AV_PIX_FMT_YUV444P:
+        case AV_PIX_FMT_P010:
+        case AV_PIX_FMT_P016:
             size = aligned_width * ctx->height * 3;
             break;
+        case AV_PIX_FMT_YUV444P16:
+            size = aligned_width * ctx->height * 6;
+            break;
+        default:
+            av_log(ctx, AV_LOG_ERROR, "BUG: Pixel format missing from size calculation.");
+            return AVERROR_BUG;
         }
 
         ctx->internal->pool_internal = av_buffer_pool_init2(size, ctx, cuda_pool_alloc, NULL);
@@ -123,7 +161,15 @@ static int cuda_frames_init(AVHWFramesContext *ctx)
 
 static int cuda_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
 {
-    int aligned_width = FFALIGN(ctx->width, CUDA_FRAME_ALIGNMENT);
+    int aligned_width;
+    int width_in_bytes = ctx->width;
+
+    if (ctx->sw_format == AV_PIX_FMT_P010 ||
+        ctx->sw_format == AV_PIX_FMT_P016 ||
+        ctx->sw_format == AV_PIX_FMT_YUV444P16) {
+       width_in_bytes *= 2;
+    }
+    aligned_width = FFALIGN(width_in_bytes, CUDA_FRAME_ALIGNMENT);
 
     frame->buf[0] = av_buffer_pool_get(ctx->pool);
     if (!frame->buf[0])
@@ -131,6 +177,8 @@ static int cuda_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
 
     switch (ctx->sw_format) {
     case AV_PIX_FMT_NV12:
+    case AV_PIX_FMT_P010:
+    case AV_PIX_FMT_P016:
         frame->data[0]     = frame->buf[0]->data;
         frame->data[1]     = frame->data[0] + aligned_width * ctx->height;
         frame->linesize[0] = aligned_width;
@@ -145,6 +193,7 @@ static int cuda_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
         frame->linesize[2] = aligned_width / 2;
         break;
     case AV_PIX_FMT_YUV444P:
+    case AV_PIX_FMT_YUV444P16:
         frame->data[0]     = frame->buf[0]->data;
         frame->data[1]     = frame->data[0] + aligned_width * ctx->height;
         frame->data[2]     = frame->data[1] + aligned_width * ctx->height;
@@ -187,12 +236,13 @@ static int cuda_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
 {
     CUDAFramesContext           *priv = ctx->internal->priv;
     AVCUDADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
+    CudaFunctions                 *cu = device_hwctx->internal->cuda_dl;
 
     CUcontext dummy;
     CUresult err;
     int i;
 
-    err = cuCtxPushCurrent(device_hwctx->cuda_ctx);
+    err = cu->cuCtxPushCurrent(device_hwctx->cuda_ctx);
     if (err != CUDA_SUCCESS)
         return AVERROR_UNKNOWN;
 
@@ -208,14 +258,14 @@ static int cuda_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
             .Height        = src->height >> (i ? priv->shift_height : 0),
         };
 
-        err = cuMemcpy2D(&cpy);
+        err = cu->cuMemcpy2D(&cpy);
         if (err != CUDA_SUCCESS) {
             av_log(ctx, AV_LOG_ERROR, "Error transferring the data from the CUDA frame\n");
             return AVERROR_UNKNOWN;
         }
     }
 
-    cuCtxPopCurrent(&dummy);
+    cu->cuCtxPopCurrent(&dummy);
 
     return 0;
 }
@@ -225,12 +275,13 @@ static int cuda_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
 {
     CUDAFramesContext           *priv = ctx->internal->priv;
     AVCUDADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
+    CudaFunctions                 *cu = device_hwctx->internal->cuda_dl;
 
     CUcontext dummy;
     CUresult err;
     int i;
 
-    err = cuCtxPushCurrent(device_hwctx->cuda_ctx);
+    err = cu->cuCtxPushCurrent(device_hwctx->cuda_ctx);
     if (err != CUDA_SUCCESS)
         return AVERROR_UNKNOWN;
 
@@ -246,28 +297,64 @@ static int cuda_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
             .Height        = src->height >> (i ? priv->shift_height : 0),
         };
 
-        err = cuMemcpy2D(&cpy);
+        err = cu->cuMemcpy2D(&cpy);
         if (err != CUDA_SUCCESS) {
             av_log(ctx, AV_LOG_ERROR, "Error transferring the data from the CUDA frame\n");
             return AVERROR_UNKNOWN;
         }
     }
 
-    cuCtxPopCurrent(&dummy);
+    cu->cuCtxPopCurrent(&dummy);
 
     return 0;
 }
 
-static void cuda_device_free(AVHWDeviceContext *ctx)
+static void cuda_device_uninit(AVHWDeviceContext *ctx)
+{
+    AVCUDADeviceContext *hwctx = ctx->hwctx;
+
+    if (hwctx->internal) {
+        if (hwctx->internal->is_allocated && hwctx->cuda_ctx) {
+            hwctx->internal->cuda_dl->cuCtxDestroy(hwctx->cuda_ctx);
+            hwctx->cuda_ctx = NULL;
+        }
+        cuda_free_functions(&hwctx->internal->cuda_dl);
+    }
+
+    av_freep(&hwctx->internal);
+}
+
+static int cuda_device_init(AVHWDeviceContext *ctx)
 {
     AVCUDADeviceContext *hwctx = ctx->hwctx;
-    cuCtxDestroy(hwctx->cuda_ctx);
+    int ret;
+
+    if (!hwctx->internal) {
+        hwctx->internal = av_mallocz(sizeof(*hwctx->internal));
+        if (!hwctx->internal)
+            return AVERROR(ENOMEM);
+    }
+
+    if (!hwctx->internal->cuda_dl) {
+        ret = cuda_load_functions(&hwctx->internal->cuda_dl);
+        if (ret < 0) {
+            av_log(ctx, AV_LOG_ERROR, "Could not dynamically load CUDA\n");
+            goto error;
+        }
+    }
+
+    return 0;
+
+error:
+    cuda_device_uninit(ctx);
+    return ret;
 }
 
 static int cuda_device_create(AVHWDeviceContext *ctx, const char *device,
                               AVDictionary *opts, int flags)
 {
     AVCUDADeviceContext *hwctx = ctx->hwctx;
+    CudaFunctions *cu;
     CUdevice cu_device;
     CUcontext dummy;
     CUresult err;
@@ -276,29 +363,38 @@ static int cuda_device_create(AVHWDeviceContext *ctx, const char *device,
     if (device)
         device_idx = strtol(device, NULL, 0);
 
-    err = cuInit(0);
+    if (cuda_device_init(ctx) < 0)
+        goto error;
+
+    cu = hwctx->internal->cuda_dl;
+
+    err = cu->cuInit(0);
     if (err != CUDA_SUCCESS) {
         av_log(ctx, AV_LOG_ERROR, "Could not initialize the CUDA driver API\n");
-        return AVERROR_UNKNOWN;
+        goto error;
     }
 
-    err = cuDeviceGet(&cu_device, device_idx);
+    err = cu->cuDeviceGet(&cu_device, device_idx);
     if (err != CUDA_SUCCESS) {
         av_log(ctx, AV_LOG_ERROR, "Could not get the device number %d\n", device_idx);
-        return AVERROR_UNKNOWN;
+        goto error;
     }
 
-    err = cuCtxCreate(&hwctx->cuda_ctx, CU_CTX_SCHED_BLOCKING_SYNC, cu_device);
+    err = cu->cuCtxCreate(&hwctx->cuda_ctx, CU_CTX_SCHED_BLOCKING_SYNC, cu_device);
     if (err != CUDA_SUCCESS) {
         av_log(ctx, AV_LOG_ERROR, "Error creating a CUDA context\n");
-        return AVERROR_UNKNOWN;
+        goto error;
     }
 
-    cuCtxPopCurrent(&dummy);
+    cu->cuCtxPopCurrent(&dummy);
 
-    ctx->free = cuda_device_free;
+    hwctx->internal->is_allocated = 1;
 
     return 0;
+
+error:
+    cuda_device_uninit(ctx);
+    return AVERROR_UNKNOWN;
 }
 
 const HWContextType ff_hwcontext_type_cuda = {
@@ -309,6 +405,9 @@ const HWContextType ff_hwcontext_type_cuda = {
     .frames_priv_size     = sizeof(CUDAFramesContext),
 
     .device_create        = cuda_device_create,
+    .device_init          = cuda_device_init,
+    .device_uninit        = cuda_device_uninit,
+    .frames_get_constraints = cuda_frames_get_constraints,
     .frames_init          = cuda_frames_init,
     .frames_get_buffer    = cuda_get_buffer,
     .transfer_get_formats = cuda_transfer_get_formats,
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_cuda.h b/mythtv/external/FFmpeg/libavutil/hwcontext_cuda.h
index 23a77cee734..12dae8449ec 100644
--- a/mythtv/external/FFmpeg/libavutil/hwcontext_cuda.h
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_cuda.h
@@ -20,7 +20,9 @@
 #ifndef AVUTIL_HWCONTEXT_CUDA_H
 #define AVUTIL_HWCONTEXT_CUDA_H
 
+#ifndef CUDA_VERSION
 #include <cuda.h>
+#endif
 
 #include "pixfmt.h"
 
@@ -32,11 +34,14 @@
  * AVBufferRefs whose data pointer is a CUdeviceptr.
  */
 
+typedef struct AVCUDADeviceContextInternal AVCUDADeviceContextInternal;
+
 /**
  * This struct is allocated as AVHWDeviceContext.hwctx
  */
 typedef struct AVCUDADeviceContext {
     CUcontext cuda_ctx;
+    AVCUDADeviceContextInternal *internal;
 } AVCUDADeviceContext;
 
 /**
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_cuda_internal.h b/mythtv/external/FFmpeg/libavutil/hwcontext_cuda_internal.h
new file mode 100644
index 00000000000..e1bc6ff3504
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_cuda_internal.h
@@ -0,0 +1,37 @@
+/*
+ * 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_HWCONTEXT_CUDA_INTERNAL_H
+#define AVUTIL_HWCONTEXT_CUDA_INTERNAL_H
+
+#include "compat/cuda/dynlink_loader.h"
+#include "hwcontext_cuda.h"
+
+/**
+ * @file
+ * FFmpeg internal API for CUDA.
+ */
+
+struct AVCUDADeviceContextInternal {
+    CudaFunctions *cuda_dl;
+    int is_allocated;
+};
+
+#endif /* AVUTIL_HWCONTEXT_CUDA_INTERNAL_H */
+
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_d3d11va.c b/mythtv/external/FFmpeg/libavutil/hwcontext_d3d11va.c
new file mode 100644
index 00000000000..52683b92cd7
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_d3d11va.c
@@ -0,0 +1,568 @@
+/*
+ * 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 <windows.h>
+
+// Include thread.h before redefining _WIN32_WINNT, to get
+// the right implementation for AVOnce
+#include "thread.h"
+
+#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0600
+#endif
+#define COBJMACROS
+
+#include <initguid.h>
+#include <d3d11.h>
+#include <dxgi1_2.h>
+
+#if HAVE_DXGIDEBUG_H
+#include <dxgidebug.h>
+#endif
+
+#include "avassert.h"
+#include "common.h"
+#include "hwcontext.h"
+#include "hwcontext_d3d11va.h"
+#include "hwcontext_internal.h"
+#include "imgutils.h"
+#include "pixdesc.h"
+#include "pixfmt.h"
+
+typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory);
+
+static AVOnce functions_loaded = AV_ONCE_INIT;
+
+static PFN_CREATE_DXGI_FACTORY mCreateDXGIFactory;
+static PFN_D3D11_CREATE_DEVICE mD3D11CreateDevice;
+
+static av_cold void load_functions(void)
+{
+#if !HAVE_UWP
+    // We let these "leak" - this is fine, as unloading has no great benefit, and
+    // Windows will mark a DLL as loaded forever if its internal refcount overflows
+    // from too many LoadLibrary calls.
+    HANDLE d3dlib, dxgilib;
+
+    d3dlib  = LoadLibrary("d3d11.dll");
+    dxgilib = LoadLibrary("dxgi.dll");
+    if (!d3dlib || !dxgilib)
+        return;
+
+    mD3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE) GetProcAddress(d3dlib, "D3D11CreateDevice");
+    mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) GetProcAddress(dxgilib, "CreateDXGIFactory");
+#else
+    // In UWP (which lacks LoadLibrary), CreateDXGIFactory isn't available,
+    // only CreateDXGIFactory1
+    mD3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE) D3D11CreateDevice;
+    mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) CreateDXGIFactory1;
+#endif
+}
+
+typedef struct D3D11VAFramesContext {
+    int nb_surfaces_used;
+
+    DXGI_FORMAT format;
+
+    ID3D11Texture2D *staging_texture;
+} D3D11VAFramesContext;
+
+static const struct {
+    DXGI_FORMAT d3d_format;
+    enum AVPixelFormat pix_fmt;
+} supported_formats[] = {
+    { DXGI_FORMAT_NV12,         AV_PIX_FMT_NV12 },
+    { DXGI_FORMAT_P010,         AV_PIX_FMT_P010 },
+    // Special opaque formats. The pix_fmt is merely a place holder, as the
+    // opaque format cannot be accessed directly.
+    { DXGI_FORMAT_420_OPAQUE,   AV_PIX_FMT_YUV420P },
+};
+
+static void d3d11va_default_lock(void *ctx)
+{
+    WaitForSingleObjectEx(ctx, INFINITE, FALSE);
+}
+
+static void d3d11va_default_unlock(void *ctx)
+{
+    ReleaseMutex(ctx);
+}
+
+static void d3d11va_frames_uninit(AVHWFramesContext *ctx)
+{
+    AVD3D11VAFramesContext *frames_hwctx = ctx->hwctx;
+    D3D11VAFramesContext *s = ctx->internal->priv;
+
+    if (frames_hwctx->texture)
+        ID3D11Texture2D_Release(frames_hwctx->texture);
+    frames_hwctx->texture = NULL;
+
+    if (s->staging_texture)
+        ID3D11Texture2D_Release(s->staging_texture);
+    s->staging_texture = NULL;
+}
+
+static void free_texture(void *opaque, uint8_t *data)
+{
+    ID3D11Texture2D_Release((ID3D11Texture2D *)opaque);
+}
+
+static AVBufferRef *wrap_texture_buf(ID3D11Texture2D *tex, int index)
+{
+    AVBufferRef *buf;
+    AVD3D11FrameDescriptor *desc = av_mallocz(sizeof(*desc));
+    if (!desc) {
+        ID3D11Texture2D_Release(tex);
+        return NULL;
+    }
+
+    desc->texture = tex;
+    desc->index   = index;
+
+    buf = av_buffer_create((uint8_t *)desc, sizeof(desc), free_texture, tex, 0);
+    if (!buf) {
+        ID3D11Texture2D_Release(tex);
+        av_free(desc);
+        return NULL;
+    }
+
+    return buf;
+}
+
+static AVBufferRef *d3d11va_alloc_single(AVHWFramesContext *ctx)
+{
+    D3D11VAFramesContext       *s = ctx->internal->priv;
+    AVD3D11VAFramesContext *hwctx = ctx->hwctx;
+    AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
+    HRESULT hr;
+    ID3D11Texture2D *tex;
+    D3D11_TEXTURE2D_DESC texDesc = {
+        .Width      = ctx->width,
+        .Height     = ctx->height,
+        .MipLevels  = 1,
+        .Format     = s->format,
+        .SampleDesc = { .Count = 1 },
+        .ArraySize  = 1,
+        .Usage      = D3D11_USAGE_DEFAULT,
+        .BindFlags  = hwctx->BindFlags,
+        .MiscFlags  = hwctx->MiscFlags,
+    };
+
+    hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &tex);
+    if (FAILED(hr)) {
+        av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
+        return NULL;
+    }
+
+    return wrap_texture_buf(tex, 0);
+}
+
+static AVBufferRef *d3d11va_pool_alloc(void *opaque, int size)
+{
+    AVHWFramesContext        *ctx = (AVHWFramesContext*)opaque;
+    D3D11VAFramesContext       *s = ctx->internal->priv;
+    AVD3D11VAFramesContext *hwctx = ctx->hwctx;
+    D3D11_TEXTURE2D_DESC  texDesc;
+
+    if (!hwctx->texture)
+        return d3d11va_alloc_single(ctx);
+
+    ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc);
+
+    if (s->nb_surfaces_used >= texDesc.ArraySize) {
+        av_log(ctx, AV_LOG_ERROR, "Static surface pool size exceeded.\n");
+        return NULL;
+    }
+
+    ID3D11Texture2D_AddRef(hwctx->texture);
+    return wrap_texture_buf(hwctx->texture, s->nb_surfaces_used++);
+}
+
+static int d3d11va_frames_init(AVHWFramesContext *ctx)
+{
+    AVD3D11VAFramesContext *hwctx        = ctx->hwctx;
+    AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
+    D3D11VAFramesContext              *s = ctx->internal->priv;
+
+    int i;
+    HRESULT hr;
+    D3D11_TEXTURE2D_DESC texDesc;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
+        if (ctx->sw_format == supported_formats[i].pix_fmt) {
+            s->format = supported_formats[i].d3d_format;
+            break;
+        }
+    }
+    if (i == FF_ARRAY_ELEMS(supported_formats)) {
+        av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n",
+               av_get_pix_fmt_name(ctx->sw_format));
+        return AVERROR(EINVAL);
+    }
+
+    texDesc = (D3D11_TEXTURE2D_DESC){
+        .Width      = ctx->width,
+        .Height     = ctx->height,
+        .MipLevels  = 1,
+        .Format     = s->format,
+        .SampleDesc = { .Count = 1 },
+        .ArraySize  = ctx->initial_pool_size,
+        .Usage      = D3D11_USAGE_DEFAULT,
+        .BindFlags  = hwctx->BindFlags,
+        .MiscFlags  = hwctx->MiscFlags,
+    };
+
+    if (hwctx->texture) {
+        D3D11_TEXTURE2D_DESC texDesc2;
+        ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc2);
+
+        if (texDesc.Width != texDesc2.Width ||
+            texDesc.Height != texDesc2.Height ||
+            texDesc.Format != texDesc2.Format) {
+            av_log(ctx, AV_LOG_ERROR, "User-provided texture has mismatching parameters\n");
+            return AVERROR(EINVAL);
+        }
+    } else if (texDesc.ArraySize > 0) {
+        hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &hwctx->texture);
+        if (FAILED(hr)) {
+            av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
+            return AVERROR_UNKNOWN;
+        }
+    }
+
+    ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(AVD3D11FrameDescriptor),
+                                                        ctx, d3d11va_pool_alloc, NULL);
+    if (!ctx->internal->pool_internal)
+        return AVERROR(ENOMEM);
+
+    return 0;
+}
+
+static int d3d11va_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
+{
+    AVD3D11FrameDescriptor *desc;
+
+    frame->buf[0] = av_buffer_pool_get(ctx->pool);
+    if (!frame->buf[0])
+        return AVERROR(ENOMEM);
+
+    desc = (AVD3D11FrameDescriptor *)frame->buf[0]->data;
+
+    frame->data[0] = (uint8_t *)desc->texture;
+    frame->data[1] = (uint8_t *)desc->index;
+    frame->format  = AV_PIX_FMT_D3D11;
+    frame->width   = ctx->width;
+    frame->height  = ctx->height;
+
+    return 0;
+}
+
+static int d3d11va_transfer_get_formats(AVHWFramesContext *ctx,
+                                        enum AVHWFrameTransferDirection dir,
+                                        enum AVPixelFormat **formats)
+{
+    D3D11VAFramesContext *s = ctx->internal->priv;
+    enum AVPixelFormat *fmts;
+
+    fmts = av_malloc_array(2, sizeof(*fmts));
+    if (!fmts)
+        return AVERROR(ENOMEM);
+
+    fmts[0] = ctx->sw_format;
+    fmts[1] = AV_PIX_FMT_NONE;
+
+    // Don't signal support for opaque formats. Actual access would fail.
+    if (s->format == DXGI_FORMAT_420_OPAQUE)
+        fmts[0] = AV_PIX_FMT_NONE;
+
+    *formats = fmts;
+
+    return 0;
+}
+
+static int d3d11va_create_staging_texture(AVHWFramesContext *ctx)
+{
+    AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
+    D3D11VAFramesContext              *s = ctx->internal->priv;
+    HRESULT hr;
+    D3D11_TEXTURE2D_DESC texDesc = {
+        .Width          = ctx->width,
+        .Height         = ctx->height,
+        .MipLevels      = 1,
+        .Format         = s->format,
+        .SampleDesc     = { .Count = 1 },
+        .ArraySize      = 1,
+        .Usage          = D3D11_USAGE_STAGING,
+        .CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE,
+    };
+
+    hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &s->staging_texture);
+    if (FAILED(hr)) {
+        av_log(ctx, AV_LOG_ERROR, "Could not create the staging texture (%lx)\n", (long)hr);
+        return AVERROR_UNKNOWN;
+    }
+
+    return 0;
+}
+
+static void fill_texture_ptrs(uint8_t *data[4], int linesize[4],
+                              AVHWFramesContext *ctx,
+                              D3D11_TEXTURE2D_DESC *desc,
+                              D3D11_MAPPED_SUBRESOURCE *map)
+{
+    int i;
+
+    for (i = 0; i < 4; i++)
+        linesize[i] = map->RowPitch;
+
+    av_image_fill_pointers(data, ctx->sw_format, desc->Height,
+                           (uint8_t*)map->pData, linesize);
+}
+
+static int d3d11va_transfer_data(AVHWFramesContext *ctx, AVFrame *dst,
+                                 const AVFrame *src)
+{
+    AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
+    D3D11VAFramesContext              *s = ctx->internal->priv;
+    int download = src->format == AV_PIX_FMT_D3D11;
+    const AVFrame *frame = download ? src : dst;
+    const AVFrame *other = download ? dst : src;
+    // (The interface types are compatible.)
+    ID3D11Resource *texture = (ID3D11Resource *)(ID3D11Texture2D *)frame->data[0];
+    int index = (intptr_t)frame->data[1];
+    ID3D11Resource *staging;
+    int w = FFMIN(dst->width,  src->width);
+    int h = FFMIN(dst->height, src->height);
+    uint8_t *map_data[4];
+    int map_linesize[4];
+    D3D11_TEXTURE2D_DESC desc;
+    D3D11_MAPPED_SUBRESOURCE map;
+    HRESULT hr;
+
+    if (frame->hw_frames_ctx->data != (uint8_t *)ctx || other->format != ctx->sw_format)
+        return AVERROR(EINVAL);
+
+    device_hwctx->lock(device_hwctx->lock_ctx);
+
+    if (!s->staging_texture) {
+        int res = d3d11va_create_staging_texture(ctx);
+        if (res < 0)
+            return res;
+    }
+
+    staging = (ID3D11Resource *)s->staging_texture;
+
+    ID3D11Texture2D_GetDesc(s->staging_texture, &desc);
+
+    if (download) {
+        ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
+                                                  staging, 0, 0, 0, 0,
+                                                  texture, index, NULL);
+
+        hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
+                                     staging, 0, D3D11_MAP_READ, 0, &map);
+        if (FAILED(hr))
+            goto map_failed;
+
+        fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
+
+        av_image_copy(dst->data, dst->linesize, map_data, map_linesize,
+                      ctx->sw_format, w, h);
+
+        ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
+    } else {
+        hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
+                                     staging, 0, D3D11_MAP_WRITE, 0, &map);
+        if (FAILED(hr))
+            goto map_failed;
+
+        fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
+
+        av_image_copy(map_data, map_linesize, src->data, src->linesize,
+                      ctx->sw_format, w, h);
+
+        ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
+
+        ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
+                                                  texture, index, 0, 0, 0,
+                                                  staging, 0, NULL);
+    }
+
+    device_hwctx->unlock(device_hwctx->lock_ctx);
+    return 0;
+
+map_failed:
+    av_log(ctx, AV_LOG_ERROR, "Unable to lock D3D11VA surface (%lx)\n", (long)hr);
+    device_hwctx->unlock(device_hwctx->lock_ctx);
+    return AVERROR_UNKNOWN;
+}
+
+static int d3d11va_device_init(AVHWDeviceContext *hwdev)
+{
+    AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
+    HRESULT hr;
+
+    if (!device_hwctx->lock) {
+        device_hwctx->lock_ctx = CreateMutex(NULL, 0, NULL);
+        if (device_hwctx->lock_ctx == INVALID_HANDLE_VALUE) {
+            av_log(NULL, AV_LOG_ERROR, "Failed to create a mutex\n");
+            return AVERROR(EINVAL);
+        }
+        device_hwctx->lock   = d3d11va_default_lock;
+        device_hwctx->unlock = d3d11va_default_unlock;
+    }
+
+    if (!device_hwctx->device_context) {
+        ID3D11Device_GetImmediateContext(device_hwctx->device, &device_hwctx->device_context);
+        if (!device_hwctx->device_context)
+            return AVERROR_UNKNOWN;
+    }
+
+    if (!device_hwctx->video_device) {
+        hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device, &IID_ID3D11VideoDevice,
+                                                (void **)&device_hwctx->video_device);
+        if (FAILED(hr))
+            return AVERROR_UNKNOWN;
+    }
+
+    if (!device_hwctx->video_context) {
+        hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device_context, &IID_ID3D11VideoContext,
+                                                (void **)&device_hwctx->video_context);
+        if (FAILED(hr))
+            return AVERROR_UNKNOWN;
+    }
+
+    return 0;
+}
+
+static void d3d11va_device_uninit(AVHWDeviceContext *hwdev)
+{
+    AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
+
+    if (device_hwctx->device)
+        ID3D11Device_Release(device_hwctx->device);
+
+    if (device_hwctx->device_context)
+        ID3D11DeviceContext_Release(device_hwctx->device_context);
+
+    if (device_hwctx->video_device)
+        ID3D11VideoDevice_Release(device_hwctx->video_device);
+
+    if (device_hwctx->video_context)
+        ID3D11VideoContext_Release(device_hwctx->video_context);
+
+    if (device_hwctx->lock == d3d11va_default_lock)
+        CloseHandle(device_hwctx->lock_ctx);
+}
+
+static int d3d11va_device_create(AVHWDeviceContext *ctx, const char *device,
+                                 AVDictionary *opts, int flags)
+{
+    AVD3D11VADeviceContext *device_hwctx = ctx->hwctx;
+
+    HRESULT hr;
+    IDXGIAdapter           *pAdapter = NULL;
+    ID3D10Multithread      *pMultithread;
+    UINT creationFlags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
+    int is_debug       = !!av_dict_get(opts, "debug", NULL, 0);
+    int ret;
+
+    // (On UWP we can't check this.)
+#if !HAVE_UWP
+    if (!LoadLibrary("d3d11_1sdklayers.dll"))
+        is_debug = 0;
+#endif
+
+    if (is_debug)
+        creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
+
+    if ((ret = ff_thread_once(&functions_loaded, load_functions)) != 0)
+        return AVERROR_UNKNOWN;
+    if (!mD3D11CreateDevice || !mCreateDXGIFactory) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to load D3D11 library or its functions\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    if (device) {
+        IDXGIFactory2 *pDXGIFactory;
+        hr = mCreateDXGIFactory(&IID_IDXGIFactory2, (void **)&pDXGIFactory);
+        if (SUCCEEDED(hr)) {
+            int adapter = atoi(device);
+            if (FAILED(IDXGIFactory2_EnumAdapters(pDXGIFactory, adapter, &pAdapter)))
+                pAdapter = NULL;
+            IDXGIFactory2_Release(pDXGIFactory);
+        }
+    }
+
+    hr = mD3D11CreateDevice(pAdapter, pAdapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE, NULL, creationFlags, NULL, 0,
+                   D3D11_SDK_VERSION, &device_hwctx->device, NULL, NULL);
+    if (pAdapter)
+        IDXGIAdapter_Release(pAdapter);
+    if (FAILED(hr)) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device (%lx)\n", (long)hr);
+        return AVERROR_UNKNOWN;
+    }
+
+    hr = ID3D11Device_QueryInterface(device_hwctx->device, &IID_ID3D10Multithread, (void **)&pMultithread);
+    if (SUCCEEDED(hr)) {
+        ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE);
+        ID3D10Multithread_Release(pMultithread);
+    }
+
+#if !HAVE_UWP && HAVE_DXGIDEBUG_H
+    if (is_debug) {
+        HANDLE dxgidebug_dll = LoadLibrary("dxgidebug.dll");
+        if (dxgidebug_dll) {
+            HRESULT (WINAPI  * pf_DXGIGetDebugInterface)(const GUID *riid, void **ppDebug)
+                = (void *)GetProcAddress(dxgidebug_dll, "DXGIGetDebugInterface");
+            if (pf_DXGIGetDebugInterface) {
+                IDXGIDebug *dxgi_debug = NULL;
+                hr = pf_DXGIGetDebugInterface(&IID_IDXGIDebug, (void**)&dxgi_debug);
+                if (SUCCEEDED(hr) && dxgi_debug)
+                    IDXGIDebug_ReportLiveObjects(dxgi_debug, DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL);
+            }
+        }
+    }
+#endif
+
+    return 0;
+}
+
+const HWContextType ff_hwcontext_type_d3d11va = {
+    .type                 = AV_HWDEVICE_TYPE_D3D11VA,
+    .name                 = "D3D11VA",
+
+    .device_hwctx_size    = sizeof(AVD3D11VADeviceContext),
+    .frames_hwctx_size    = sizeof(AVD3D11VAFramesContext),
+    .frames_priv_size     = sizeof(D3D11VAFramesContext),
+
+    .device_create        = d3d11va_device_create,
+    .device_init          = d3d11va_device_init,
+    .device_uninit        = d3d11va_device_uninit,
+    .frames_init          = d3d11va_frames_init,
+    .frames_uninit        = d3d11va_frames_uninit,
+    .frames_get_buffer    = d3d11va_get_buffer,
+    .transfer_get_formats = d3d11va_transfer_get_formats,
+    .transfer_data_to     = d3d11va_transfer_data,
+    .transfer_data_from   = d3d11va_transfer_data,
+
+    .pix_fmts             = (const enum AVPixelFormat[]){ AV_PIX_FMT_D3D11, AV_PIX_FMT_NONE },
+};
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_d3d11va.h b/mythtv/external/FFmpeg/libavutil/hwcontext_d3d11va.h
new file mode 100644
index 00000000000..98db7ce3431
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_d3d11va.h
@@ -0,0 +1,168 @@
+/*
+ * 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_HWCONTEXT_D3D11VA_H
+#define AVUTIL_HWCONTEXT_D3D11VA_H
+
+/**
+ * @file
+ * An API-specific header for AV_HWDEVICE_TYPE_D3D11VA.
+ *
+ * The default pool implementation will be fixed-size if initial_pool_size is
+ * set (and allocate elements from an array texture). Otherwise it will allocate
+ * individual textures. Be aware that decoding requires a single array texture.
+ *
+ * Using sw_format==AV_PIX_FMT_YUV420P has special semantics, and maps to
+ * DXGI_FORMAT_420_OPAQUE. av_hwframe_transfer_data() is not supported for
+ * this format. Refer to MSDN for details.
+ *
+ * av_hwdevice_ctx_create() for this device type supports a key named "debug"
+ * for the AVDictionary entry. If this is set to any value, the device creation
+ * code will try to load various supported D3D debugging layers.
+ */
+
+#include <d3d11.h>
+
+/**
+ * This struct is allocated as AVHWDeviceContext.hwctx
+ */
+typedef struct AVD3D11VADeviceContext {
+    /**
+     * Device used for texture creation and access. This can also be used to
+     * set the libavcodec decoding device.
+     *
+     * Must be set by the user. This is the only mandatory field - the other
+     * device context fields are set from this and are available for convenience.
+     *
+     * Deallocating the AVHWDeviceContext will always release this interface,
+     * and it does not matter whether it was user-allocated.
+     */
+    ID3D11Device        *device;
+
+    /**
+     * If unset, this will be set from the device field on init.
+     *
+     * Deallocating the AVHWDeviceContext will always release this interface,
+     * and it does not matter whether it was user-allocated.
+     */
+    ID3D11DeviceContext *device_context;
+
+    /**
+     * If unset, this will be set from the device field on init.
+     *
+     * Deallocating the AVHWDeviceContext will always release this interface,
+     * and it does not matter whether it was user-allocated.
+     */
+    ID3D11VideoDevice   *video_device;
+
+    /**
+     * If unset, this will be set from the device_context field on init.
+     *
+     * Deallocating the AVHWDeviceContext will always release this interface,
+     * and it does not matter whether it was user-allocated.
+     */
+    ID3D11VideoContext  *video_context;
+
+    /**
+     * Callbacks for locking. They protect accesses to device_context and
+     * video_context calls. They also protect access to the internal staging
+     * texture (for av_hwframe_transfer_data() calls). They do NOT protect
+     * access to hwcontext or decoder state in general.
+     *
+     * If unset on init, the hwcontext implementation will set them to use an
+     * internal mutex.
+     *
+     * The underlying lock must be recursive. lock_ctx is for free use by the
+     * locking implementation.
+     */
+    void (*lock)(void *lock_ctx);
+    void (*unlock)(void *lock_ctx);
+    void *lock_ctx;
+} AVD3D11VADeviceContext;
+
+/**
+ * D3D11 frame descriptor for pool allocation.
+ *
+ * In user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs
+ * with the data pointer pointing at an object of this type describing the
+ * planes of the frame.
+ *
+ * This has no use outside of custom allocation, and AVFrame AVBufferRef do not
+ * necessarily point to an instance of this struct.
+ */
+typedef struct AVD3D11FrameDescriptor {
+    /**
+     * The texture in which the frame is located. The reference count is
+     * managed by the AVBufferRef, and destroying the reference will release
+     * the interface.
+     *
+     * Normally stored in AVFrame.data[0].
+     */
+    ID3D11Texture2D *texture;
+
+    /**
+     * The index into the array texture element representing the frame, or 0
+     * if the texture is not an array texture.
+     *
+     * Normally stored in AVFrame.data[1] (cast from intptr_t).
+     */
+    intptr_t index;
+} AVD3D11FrameDescriptor;
+
+/**
+ * This struct is allocated as AVHWFramesContext.hwctx
+ */
+typedef struct AVD3D11VAFramesContext {
+    /**
+     * The canonical texture used for pool allocation. If this is set to NULL
+     * on init, the hwframes implementation will allocate and set an array
+     * texture if initial_pool_size > 0.
+     *
+     * The only situation when the API user should set this is:
+     * - the user wants to do manual pool allocation (setting
+     *   AVHWFramesContext.pool), instead of letting AVHWFramesContext
+     *   allocate the pool
+     * - of an array texture
+     * - and wants it to use it for decoding
+     * - this has to be done before calling av_hwframe_ctx_init()
+     *
+     * Deallocating the AVHWFramesContext will always release this interface,
+     * and it does not matter whether it was user-allocated.
+     *
+     * This is in particular used by the libavcodec D3D11VA hwaccel, which
+     * requires a single array texture. It will create ID3D11VideoDecoderOutputView
+     * objects for each array texture element on decoder initialization.
+     */
+    ID3D11Texture2D *texture;
+
+    /**
+     * D3D11_TEXTURE2D_DESC.BindFlags used for texture creation. The user must
+     * at least set D3D11_BIND_DECODER if the frames context is to be used for
+     * video decoding.
+     * This field is ignored/invalid if a user-allocated texture is provided.
+     */
+    UINT BindFlags;
+
+    /**
+     * D3D11_TEXTURE2D_DESC.MiscFlags used for texture creation.
+     * This field is ignored/invalid if a user-allocated texture is provided.
+     */
+    UINT MiscFlags;
+} AVD3D11VAFramesContext;
+
+#endif /* AVUTIL_HWCONTEXT_D3D11VA_H */
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_drm.c b/mythtv/external/FFmpeg/libavutil/hwcontext_drm.c
new file mode 100644
index 00000000000..32cbde82ebf
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_drm.c
@@ -0,0 +1,289 @@
+/*
+ * 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 <fcntl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include <drm.h>
+#include <xf86drm.h>
+
+#include "avassert.h"
+#include "hwcontext.h"
+#include "hwcontext_drm.h"
+#include "hwcontext_internal.h"
+#include "imgutils.h"
+
+
+static void drm_device_free(AVHWDeviceContext *hwdev)
+{
+    AVDRMDeviceContext *hwctx = hwdev->hwctx;
+
+    close(hwctx->fd);
+}
+
+static int drm_device_create(AVHWDeviceContext *hwdev, const char *device,
+                             AVDictionary *opts, int flags)
+{
+    AVDRMDeviceContext *hwctx = hwdev->hwctx;
+    drmVersionPtr version;
+
+    hwctx->fd = open(device, O_RDWR);
+    if (hwctx->fd < 0)
+        return AVERROR(errno);
+
+    version = drmGetVersion(hwctx->fd);
+    if (!version) {
+        av_log(hwdev, AV_LOG_ERROR, "Failed to get version information "
+               "from %s: probably not a DRM device?\n", device);
+        close(hwctx->fd);
+        return AVERROR(EINVAL);
+    }
+
+    av_log(hwdev, AV_LOG_VERBOSE, "Opened DRM device %s: driver %s "
+           "version %d.%d.%d.\n", device, version->name,
+           version->version_major, version->version_minor,
+           version->version_patchlevel);
+
+    drmFreeVersion(version);
+
+    hwdev->free = &drm_device_free;
+
+    return 0;
+}
+
+static int drm_get_buffer(AVHWFramesContext *hwfc, AVFrame *frame)
+{
+    frame->buf[0] = av_buffer_pool_get(hwfc->pool);
+    if (!frame->buf[0])
+        return AVERROR(ENOMEM);
+
+    frame->data[0] = (uint8_t*)frame->buf[0]->data;
+
+    frame->format = AV_PIX_FMT_DRM_PRIME;
+    frame->width  = hwfc->width;
+    frame->height = hwfc->height;
+
+    return 0;
+}
+
+typedef struct DRMMapping {
+    // Address and length of each mmap()ed region.
+    int nb_regions;
+    void *address[AV_DRM_MAX_PLANES];
+    size_t length[AV_DRM_MAX_PLANES];
+} DRMMapping;
+
+static void drm_unmap_frame(AVHWFramesContext *hwfc,
+                            HWMapDescriptor *hwmap)
+{
+    DRMMapping *map = hwmap->priv;
+    int i;
+
+    for (i = 0; i < map->nb_regions; i++)
+        munmap(map->address[i], map->length[i]);
+
+    av_free(map);
+}
+
+static int drm_map_frame(AVHWFramesContext *hwfc,
+                         AVFrame *dst, const AVFrame *src, int flags)
+{
+    const AVDRMFrameDescriptor *desc = (AVDRMFrameDescriptor*)src->data[0];
+    DRMMapping *map;
+    int err, i, p, plane;
+    int mmap_prot;
+    void *addr;
+
+    map = av_mallocz(sizeof(*map));
+    if (!map)
+        return AVERROR(ENOMEM);
+
+    mmap_prot = 0;
+    if (flags & AV_HWFRAME_MAP_READ)
+        mmap_prot |= PROT_READ;
+    if (flags & AV_HWFRAME_MAP_WRITE)
+        mmap_prot |= PROT_WRITE;
+
+    av_assert0(desc->nb_objects <= AV_DRM_MAX_PLANES);
+    for (i = 0; i < desc->nb_objects; i++) {
+        addr = mmap(NULL, desc->objects[i].size, mmap_prot, MAP_SHARED,
+                    desc->objects[i].fd, 0);
+        if (addr == MAP_FAILED) {
+            err = AVERROR(errno);
+            av_log(hwfc, AV_LOG_ERROR, "Failed to map DRM object %d to "
+                   "memory: %d.\n", desc->objects[i].fd, errno);
+            goto fail;
+        }
+
+        map->address[i] = addr;
+        map->length[i]  = desc->objects[i].size;
+    }
+    map->nb_regions = i;
+
+    plane = 0;
+    for (i = 0; i < desc->nb_layers; i++) {
+        const AVDRMLayerDescriptor *layer = &desc->layers[i];
+        for (p = 0; p < layer->nb_planes; p++) {
+            dst->data[plane] =
+                (uint8_t*)map->address[layer->planes[p].object_index] +
+                                       layer->planes[p].offset;
+            dst->linesize[plane] =     layer->planes[p].pitch;
+            ++plane;
+        }
+    }
+    av_assert0(plane <= AV_DRM_MAX_PLANES);
+
+    dst->width  = src->width;
+    dst->height = src->height;
+
+    err = ff_hwframe_map_create(src->hw_frames_ctx, dst, src,
+                                &drm_unmap_frame, map);
+    if (err < 0)
+        goto fail;
+
+    return 0;
+
+fail:
+    for (i = 0; i < desc->nb_objects; i++) {
+        if (map->address[i])
+            munmap(map->address[i], map->length[i]);
+    }
+    av_free(map);
+    return err;
+}
+
+static int drm_transfer_get_formats(AVHWFramesContext *ctx,
+                                    enum AVHWFrameTransferDirection dir,
+                                    enum AVPixelFormat **formats)
+{
+    enum AVPixelFormat *pix_fmts;
+
+    pix_fmts = av_malloc_array(2, sizeof(*pix_fmts));
+    if (!pix_fmts)
+        return AVERROR(ENOMEM);
+
+    pix_fmts[0] = ctx->sw_format;
+    pix_fmts[1] = AV_PIX_FMT_NONE;
+
+    *formats = pix_fmts;
+    return 0;
+}
+
+static int drm_transfer_data_from(AVHWFramesContext *hwfc,
+                                  AVFrame *dst, const AVFrame *src)
+{
+    AVFrame *map;
+    int err;
+
+    if (dst->width > hwfc->width || dst->height > hwfc->height)
+        return AVERROR(EINVAL);
+
+    map = av_frame_alloc();
+    if (!map)
+        return AVERROR(ENOMEM);
+    map->format = dst->format;
+
+    err = drm_map_frame(hwfc, map, src, AV_HWFRAME_MAP_READ);
+    if (err)
+        goto fail;
+
+    map->width  = dst->width;
+    map->height = dst->height;
+
+    err = av_frame_copy(dst, map);
+    if (err)
+        goto fail;
+
+    err = 0;
+fail:
+    av_frame_free(&map);
+    return err;
+}
+
+static int drm_transfer_data_to(AVHWFramesContext *hwfc,
+                                AVFrame *dst, const AVFrame *src)
+{
+    AVFrame *map;
+    int err;
+
+    if (src->width > hwfc->width || src->height > hwfc->height)
+        return AVERROR(EINVAL);
+
+    map = av_frame_alloc();
+    if (!map)
+        return AVERROR(ENOMEM);
+    map->format = src->format;
+
+    err = drm_map_frame(hwfc, map, dst, AV_HWFRAME_MAP_WRITE |
+                                        AV_HWFRAME_MAP_OVERWRITE);
+    if (err)
+        goto fail;
+
+    map->width  = src->width;
+    map->height = src->height;
+
+    err = av_frame_copy(map, src);
+    if (err)
+        goto fail;
+
+    err = 0;
+fail:
+    av_frame_free(&map);
+    return err;
+}
+
+static int drm_map_from(AVHWFramesContext *hwfc, AVFrame *dst,
+                        const AVFrame *src, int flags)
+{
+    int err;
+
+    if (hwfc->sw_format != dst->format)
+        return AVERROR(ENOSYS);
+
+    err = drm_map_frame(hwfc, dst, src, flags);
+    if (err)
+        return err;
+
+    err = av_frame_copy_props(dst, src);
+    if (err)
+        return err;
+
+    return 0;
+}
+
+const HWContextType ff_hwcontext_type_drm = {
+    .type                   = AV_HWDEVICE_TYPE_DRM,
+    .name                   = "DRM",
+
+    .device_hwctx_size      = sizeof(AVDRMDeviceContext),
+
+    .device_create          = &drm_device_create,
+
+    .frames_get_buffer      = &drm_get_buffer,
+
+    .transfer_get_formats   = &drm_transfer_get_formats,
+    .transfer_data_to       = &drm_transfer_data_to,
+    .transfer_data_from     = &drm_transfer_data_from,
+    .map_from               = &drm_map_from,
+
+    .pix_fmts = (const enum AVPixelFormat[]) {
+        AV_PIX_FMT_DRM_PRIME,
+        AV_PIX_FMT_NONE
+    },
+};
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_drm.h b/mythtv/external/FFmpeg/libavutil/hwcontext_drm.h
new file mode 100644
index 00000000000..2e225451e11
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_drm.h
@@ -0,0 +1,166 @@
+/*
+ * 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_HWCONTEXT_DRM_H
+#define AVUTIL_HWCONTEXT_DRM_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * @file
+ * API-specific header for AV_HWDEVICE_TYPE_DRM.
+ *
+ * Internal frame allocation is not currently supported - all frames
+ * must be allocated by the user.  Thus AVHWFramesContext is always
+ * NULL, though this may change if support for frame allocation is
+ * added in future.
+ */
+
+enum {
+    /**
+     * The maximum number of layers/planes in a DRM frame.
+     */
+    AV_DRM_MAX_PLANES = 4
+};
+
+/**
+ * DRM object descriptor.
+ *
+ * Describes a single DRM object, addressing it as a PRIME file
+ * descriptor.
+ */
+typedef struct AVDRMObjectDescriptor {
+    /**
+     * DRM PRIME fd for the object.
+     */
+    int fd;
+    /**
+     * Total size of the object.
+     *
+     * (This includes any parts not which do not contain image data.)
+     */
+    size_t size;
+    /**
+     * Format modifier applied to the object (DRM_FORMAT_MOD_*).
+     */
+    uint64_t format_modifier;
+} AVDRMObjectDescriptor;
+
+/**
+ * DRM plane descriptor.
+ *
+ * Describes a single plane of a layer, which is contained within
+ * a single object.
+ */
+typedef struct AVDRMPlaneDescriptor {
+    /**
+     * Index of the object containing this plane in the objects
+     * array of the enclosing frame descriptor.
+     */
+    int object_index;
+    /**
+     * Offset within that object of this plane.
+     */
+    ptrdiff_t offset;
+    /**
+     * Pitch (linesize) of this plane.
+     */
+    ptrdiff_t pitch;
+} AVDRMPlaneDescriptor;
+
+/**
+ * DRM layer descriptor.
+ *
+ * Describes a single layer within a frame.  This has the structure
+ * defined by its format, and will contain one or more planes.
+ */
+typedef struct AVDRMLayerDescriptor {
+    /**
+     * Format of the layer (DRM_FORMAT_*).
+     */
+    uint32_t format;
+    /**
+     * Number of planes in the layer.
+     *
+     * This must match the number of planes required by format.
+     */
+    int nb_planes;
+    /**
+     * Array of planes in this layer.
+     */
+    AVDRMPlaneDescriptor planes[AV_DRM_MAX_PLANES];
+} AVDRMLayerDescriptor;
+
+/**
+ * DRM frame descriptor.
+ *
+ * This is used as the data pointer for AV_PIX_FMT_DRM_PRIME frames.
+ * It is also used by user-allocated frame pools - allocating in
+ * AVHWFramesContext.pool must return AVBufferRefs which contain
+ * an object of this type.
+ *
+ * The fields of this structure should be set such it can be
+ * imported directly by EGL using the EGL_EXT_image_dma_buf_import
+ * and EGL_EXT_image_dma_buf_import_modifiers extensions.
+ * (Note that the exact layout of a particular format may vary between
+ * platforms - we only specify that the same platform should be able
+ * to import it.)
+ *
+ * The total number of planes must not exceed AV_DRM_MAX_PLANES, and
+ * the order of the planes by increasing layer index followed by
+ * increasing plane index must be the same as the order which would
+ * be used for the data pointers in the equivalent software format.
+ */
+typedef struct AVDRMFrameDescriptor {
+    /**
+     * Number of DRM objects making up this frame.
+     */
+    int nb_objects;
+    /**
+     * Array of objects making up the frame.
+     */
+    AVDRMObjectDescriptor objects[AV_DRM_MAX_PLANES];
+    /**
+     * Number of layers in the frame.
+     */
+    int nb_layers;
+    /**
+     * Array of layers in the frame.
+     */
+    AVDRMLayerDescriptor layers[AV_DRM_MAX_PLANES];
+} AVDRMFrameDescriptor;
+
+/**
+ * DRM device.
+ *
+ * Allocated as AVHWDeviceContext.hwctx.
+ */
+typedef struct AVDRMDeviceContext {
+    /**
+     * File descriptor of DRM device.
+     *
+     * This is used as the device to create frames on, and may also be
+     * used in some derivation and mapping operations.
+     *
+     * If no device is required, set to -1.
+     */
+    int fd;
+} AVDRMDeviceContext;
+
+#endif /* AVUTIL_HWCONTEXT_DRM_H */
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_dxva2.c b/mythtv/external/FFmpeg/libavutil/hwcontext_dxva2.c
index e79254bb347..665c2d6d746 100644
--- a/mythtv/external/FFmpeg/libavutil/hwcontext_dxva2.c
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_dxva2.c
@@ -37,10 +37,29 @@
 #include "imgutils.h"
 #include "pixdesc.h"
 #include "pixfmt.h"
+#include "compat/w32dlfcn.h"
 
 typedef IDirect3D9* WINAPI pDirect3DCreate9(UINT);
+typedef HRESULT WINAPI pDirect3DCreate9Ex(UINT, IDirect3D9Ex **);
 typedef HRESULT WINAPI pCreateDeviceManager9(UINT *, IDirect3DDeviceManager9 **);
 
+#define FF_D3DCREATE_FLAGS (D3DCREATE_SOFTWARE_VERTEXPROCESSING | \
+                            D3DCREATE_MULTITHREADED | \
+                            D3DCREATE_FPU_PRESERVE)
+
+static const D3DPRESENT_PARAMETERS dxva2_present_params = {
+    .Windowed         = TRUE,
+    .BackBufferWidth  = 640,
+    .BackBufferHeight = 480,
+    .BackBufferCount  = 0,
+    .SwapEffect       = D3DSWAPEFFECT_DISCARD,
+    .Flags            = D3DPRESENTFLAG_VIDEO,
+};
+
+typedef struct DXVA2Mapping {
+    uint32_t palette_dummy[256];
+} DXVA2Mapping;
+
 typedef struct DXVA2FramesContext {
     IDirect3DSurface9 **surfaces_internal;
     int              nb_surfaces_used;
@@ -67,6 +86,7 @@ static const struct {
 } supported_formats[] = {
     { MKTAG('N', 'V', '1', '2'), AV_PIX_FMT_NV12 },
     { MKTAG('P', '0', '1', '0'), AV_PIX_FMT_P010 },
+    { D3DFMT_P8,                 AV_PIX_FMT_PAL8 },
 };
 
 DEFINE_GUID(video_decoder_service,   0xfc51a551, 0xd5e7, 0x11d9, 0xaf, 0x55, 0x00, 0x05, 0x4e, 0x43, 0xff, 0x02);
@@ -101,6 +121,13 @@ static void dxva2_frames_uninit(AVHWFramesContext *ctx)
     }
 }
 
+static void dxva2_pool_release_dummy(void *opaque, uint8_t *data)
+{
+    // important not to free anything here--data is a surface object
+    // associated with the call to CreateSurface(), and these surfaces are
+    // released in dxva2_frames_uninit()
+}
+
 static AVBufferRef *dxva2_pool_alloc(void *opaque, int size)
 {
     AVHWFramesContext      *ctx = (AVHWFramesContext*)opaque;
@@ -110,7 +137,7 @@ static AVBufferRef *dxva2_pool_alloc(void *opaque, int size)
     if (s->nb_surfaces_used < hwctx->nb_surfaces) {
         s->nb_surfaces_used++;
         return av_buffer_create((uint8_t*)s->surfaces_internal[s->nb_surfaces_used - 1],
-                                sizeof(*hwctx->surfaces), NULL, 0, 0);
+                                sizeof(*hwctx->surfaces), dxva2_pool_release_dummy, 0, 0);
     }
 
     return NULL;
@@ -242,29 +269,25 @@ static int dxva2_transfer_get_formats(AVHWFramesContext *ctx,
     return 0;
 }
 
-static int dxva2_transfer_data(AVHWFramesContext *ctx, AVFrame *dst,
-                               const AVFrame *src)
+static void dxva2_unmap_frame(AVHWFramesContext *ctx, HWMapDescriptor *hwmap)
+{
+    IDirect3DSurface9 *surface = (IDirect3DSurface9*)hwmap->source->data[3];
+    IDirect3DSurface9_UnlockRect(surface);
+    av_freep(&hwmap->priv);
+}
+
+static int dxva2_map_frame(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src,
+                           int flags)
 {
-    IDirect3DSurface9 *surface;
+    IDirect3DSurface9 *surface = (IDirect3DSurface9*)src->data[3];
+    DXVA2Mapping      *map;
     D3DSURFACE_DESC    surfaceDesc;
     D3DLOCKED_RECT     LockedRect;
     HRESULT            hr;
+    int i, err, nb_planes;
+    int lock_flags = 0;
 
-    int download = !!src->hw_frames_ctx;
-    int bytes_per_component;
-
-    switch (ctx->sw_format) {
-        case AV_PIX_FMT_NV12:
-            bytes_per_component = 1;
-            break;
-        case AV_PIX_FMT_P010:
-            bytes_per_component = 2;
-            break;
-        default:
-            av_assert0(0);
-    }
-
-    surface = (IDirect3DSurface9*)(download ? src->data[3] : dst->data[3]);
+    nb_planes = av_pix_fmt_count_planes(dst->format);
 
     hr = IDirect3DSurface9_GetDesc(surface, &surfaceDesc);
     if (FAILED(hr)) {
@@ -272,30 +295,117 @@ static int dxva2_transfer_data(AVHWFramesContext *ctx, AVFrame *dst,
         return AVERROR_UNKNOWN;
     }
 
-    hr = IDirect3DSurface9_LockRect(surface, &LockedRect, NULL,
-                                    download ? D3DLOCK_READONLY : D3DLOCK_DISCARD);
+    if (!(flags & AV_HWFRAME_MAP_WRITE))
+        lock_flags |= D3DLOCK_READONLY;
+    if (flags & AV_HWFRAME_MAP_OVERWRITE)
+        lock_flags |= D3DLOCK_DISCARD;
+
+    hr = IDirect3DSurface9_LockRect(surface, &LockedRect, NULL, lock_flags);
     if (FAILED(hr)) {
         av_log(ctx, AV_LOG_ERROR, "Unable to lock DXVA2 surface\n");
         return AVERROR_UNKNOWN;
     }
 
-    if (download) {
-        av_image_copy_plane(dst->data[0], dst->linesize[0],
-                            (uint8_t*)LockedRect.pBits, LockedRect.Pitch,
-                            src->width * bytes_per_component, src->height);
-        av_image_copy_plane(dst->data[1], dst->linesize[1],
-                            (uint8_t*)LockedRect.pBits + LockedRect.Pitch * surfaceDesc.Height,
-                            LockedRect.Pitch, src->width * bytes_per_component, src->height / 2);
-    } else {
-        av_image_copy_plane((uint8_t*)LockedRect.pBits, LockedRect.Pitch,
-                            dst->data[0], dst->linesize[0],
-                            src->width * bytes_per_component, src->height);
-        av_image_copy_plane((uint8_t*)LockedRect.pBits + LockedRect.Pitch * surfaceDesc.Height,
-                            LockedRect.Pitch, dst->data[1], dst->linesize[1],
-                            src->width * bytes_per_component, src->height / 2);
+    map = av_mallocz(sizeof(*map));
+    if (!map) {
+        err = AVERROR(ENOMEM);
+        goto fail;
+    }
+
+    err = ff_hwframe_map_create(src->hw_frames_ctx, dst, src,
+                                dxva2_unmap_frame, map);
+    if (err < 0) {
+        av_freep(&map);
+        goto fail;
     }
 
+    for (i = 0; i < nb_planes; i++)
+        dst->linesize[i] = LockedRect.Pitch;
+
+    av_image_fill_pointers(dst->data, dst->format, surfaceDesc.Height,
+                           (uint8_t*)LockedRect.pBits, dst->linesize);
+
+    if (dst->format == AV_PIX_FMT_PAL8)
+        dst->data[1] = (uint8_t*)map->palette_dummy;
+
+    return 0;
+fail:
     IDirect3DSurface9_UnlockRect(surface);
+    return err;
+}
+
+static int dxva2_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
+                                  const AVFrame *src)
+{
+    AVFrame *map;
+    int ret;
+
+    if (src->format != ctx->sw_format)
+        return AVERROR(ENOSYS);
+
+    map = av_frame_alloc();
+    if (!map)
+        return AVERROR(ENOMEM);
+    map->format = dst->format;
+
+    ret = dxva2_map_frame(ctx, map, dst, AV_HWFRAME_MAP_WRITE | AV_HWFRAME_MAP_OVERWRITE);
+    if (ret < 0)
+        goto fail;
+
+    av_image_copy(map->data, map->linesize, src->data, src->linesize,
+                  ctx->sw_format, src->width, src->height);
+
+fail:
+    av_frame_free(&map);
+    return ret;
+}
+
+static int dxva2_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
+                                    const AVFrame *src)
+{
+    AVFrame *map;
+    ptrdiff_t src_linesize[4], dst_linesize[4];
+    int ret, i;
+
+    if (dst->format != ctx->sw_format)
+        return AVERROR(ENOSYS);
+
+    map = av_frame_alloc();
+    if (!map)
+        return AVERROR(ENOMEM);
+    map->format = dst->format;
+
+    ret = dxva2_map_frame(ctx, map, src, AV_HWFRAME_MAP_READ);
+    if (ret < 0)
+        goto fail;
+
+    for (i = 0; i < 4; i++) {
+        dst_linesize[i] = dst->linesize[i];
+        src_linesize[i] = map->linesize[i];
+    }
+    av_image_copy_uc_from(dst->data, dst_linesize, map->data, src_linesize,
+                          ctx->sw_format, src->width, src->height);
+fail:
+    av_frame_free(&map);
+    return ret;
+}
+
+static int dxva2_map_from(AVHWFramesContext *ctx,
+                          AVFrame *dst, const AVFrame *src, int flags)
+{
+    int err;
+
+    if (dst->format != AV_PIX_FMT_NONE && dst->format != ctx->sw_format)
+        return AVERROR(ENOSYS);
+    dst->format = ctx->sw_format;
+
+    err = dxva2_map_frame(ctx, dst, src, flags);
+    if (err < 0)
+        return err;
+
+    err = av_frame_copy_props(dst, src);
+    if (err < 0)
+        return err;
 
     return 0;
 }
@@ -318,27 +428,96 @@ static void dxva2_device_free(AVHWDeviceContext *ctx)
         IDirect3D9_Release(priv->d3d9);
 
     if (priv->d3dlib)
-        FreeLibrary(priv->d3dlib);
+        dlclose(priv->d3dlib);
 
     if (priv->dxva2lib)
-        FreeLibrary(priv->dxva2lib);
+        dlclose(priv->dxva2lib);
 
     av_freep(&ctx->user_opaque);
 }
 
+static int dxva2_device_create9(AVHWDeviceContext *ctx, UINT adapter)
+{
+    DXVA2DevicePriv *priv = ctx->user_opaque;
+    D3DPRESENT_PARAMETERS d3dpp = dxva2_present_params;
+    D3DDISPLAYMODE d3ddm;
+    HRESULT hr;
+    pDirect3DCreate9 *createD3D = (pDirect3DCreate9 *)dlsym(priv->d3dlib, "Direct3DCreate9");
+    if (!createD3D) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to locate Direct3DCreate9\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    priv->d3d9 = createD3D(D3D_SDK_VERSION);
+    if (!priv->d3d9) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to create IDirect3D object\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    IDirect3D9_GetAdapterDisplayMode(priv->d3d9, adapter, &d3ddm);
+
+    d3dpp.BackBufferFormat = d3ddm.Format;
+
+    hr = IDirect3D9_CreateDevice(priv->d3d9, adapter, D3DDEVTYPE_HAL, GetDesktopWindow(),
+                                 FF_D3DCREATE_FLAGS,
+                                 &d3dpp, &priv->d3d9device);
+    if (FAILED(hr)) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    return 0;
+}
+
+static int dxva2_device_create9ex(AVHWDeviceContext *ctx, UINT adapter)
+{
+    DXVA2DevicePriv *priv = ctx->user_opaque;
+    D3DPRESENT_PARAMETERS d3dpp = dxva2_present_params;
+    D3DDISPLAYMODEEX modeex = {0};
+    IDirect3D9Ex *d3d9ex = NULL;
+    IDirect3DDevice9Ex *exdev = NULL;
+    HRESULT hr;
+    pDirect3DCreate9Ex *createD3DEx = (pDirect3DCreate9Ex *)dlsym(priv->d3dlib, "Direct3DCreate9Ex");
+    if (!createD3DEx)
+        return AVERROR(ENOSYS);
+
+    hr = createD3DEx(D3D_SDK_VERSION, &d3d9ex);
+    if (FAILED(hr))
+        return AVERROR_UNKNOWN;
+
+    modeex.Size = sizeof(D3DDISPLAYMODEEX);
+    hr = IDirect3D9Ex_GetAdapterDisplayModeEx(d3d9ex, adapter, &modeex, NULL);
+    if (FAILED(hr)) {
+        IDirect3D9Ex_Release(d3d9ex);
+        return AVERROR_UNKNOWN;
+    }
+
+    d3dpp.BackBufferFormat = modeex.Format;
+
+    hr = IDirect3D9Ex_CreateDeviceEx(d3d9ex, adapter, D3DDEVTYPE_HAL, GetDesktopWindow(),
+                                     FF_D3DCREATE_FLAGS,
+                                     &d3dpp, NULL, &exdev);
+    if (FAILED(hr)) {
+        IDirect3D9Ex_Release(d3d9ex);
+        return AVERROR_UNKNOWN;
+    }
+
+    av_log(ctx, AV_LOG_VERBOSE, "Using D3D9Ex device.\n");
+    priv->d3d9 = (IDirect3D9 *)d3d9ex;
+    priv->d3d9device = (IDirect3DDevice9 *)exdev;
+    return 0;
+}
+
 static int dxva2_device_create(AVHWDeviceContext *ctx, const char *device,
                                AVDictionary *opts, int flags)
 {
     AVDXVA2DeviceContext *hwctx = ctx->hwctx;
     DXVA2DevicePriv *priv;
-
-    pDirect3DCreate9 *createD3D = NULL;
     pCreateDeviceManager9 *createDeviceManager = NULL;
-    D3DPRESENT_PARAMETERS d3dpp = {0};
-    D3DDISPLAYMODE        d3ddm;
     unsigned resetToken = 0;
     UINT adapter = D3DADAPTER_DEFAULT;
     HRESULT hr;
+    int err;
 
     if (device)
         adapter = atoi(device);
@@ -352,50 +531,29 @@ static int dxva2_device_create(AVHWDeviceContext *ctx, const char *device,
 
     priv->device_handle = INVALID_HANDLE_VALUE;
 
-    priv->d3dlib = LoadLibrary("d3d9.dll");
+    priv->d3dlib = dlopen("d3d9.dll", 0);
     if (!priv->d3dlib) {
         av_log(ctx, AV_LOG_ERROR, "Failed to load D3D9 library\n");
         return AVERROR_UNKNOWN;
     }
-    priv->dxva2lib = LoadLibrary("dxva2.dll");
+    priv->dxva2lib = dlopen("dxva2.dll", 0);
     if (!priv->dxva2lib) {
         av_log(ctx, AV_LOG_ERROR, "Failed to load DXVA2 library\n");
         return AVERROR_UNKNOWN;
     }
 
-    createD3D = (pDirect3DCreate9 *)GetProcAddress(priv->d3dlib, "Direct3DCreate9");
-    if (!createD3D) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to locate Direct3DCreate9\n");
-        return AVERROR_UNKNOWN;
-    }
-    createDeviceManager = (pCreateDeviceManager9 *)GetProcAddress(priv->dxva2lib,
-                                                                  "DXVA2CreateDirect3DDeviceManager9");
+    createDeviceManager = (pCreateDeviceManager9 *)dlsym(priv->dxva2lib,
+                                                         "DXVA2CreateDirect3DDeviceManager9");
     if (!createDeviceManager) {
         av_log(ctx, AV_LOG_ERROR, "Failed to locate DXVA2CreateDirect3DDeviceManager9\n");
         return AVERROR_UNKNOWN;
     }
 
-    priv->d3d9 = createD3D(D3D_SDK_VERSION);
-    if (!priv->d3d9) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to create IDirect3D object\n");
-        return AVERROR_UNKNOWN;
-    }
-
-    IDirect3D9_GetAdapterDisplayMode(priv->d3d9, adapter, &d3ddm);
-    d3dpp.Windowed         = TRUE;
-    d3dpp.BackBufferWidth  = 640;
-    d3dpp.BackBufferHeight = 480;
-    d3dpp.BackBufferCount  = 0;
-    d3dpp.BackBufferFormat = d3ddm.Format;
-    d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
-    d3dpp.Flags            = D3DPRESENTFLAG_VIDEO;
-
-    hr = IDirect3D9_CreateDevice(priv->d3d9, adapter, D3DDEVTYPE_HAL, GetDesktopWindow(),
-                                 D3DCREATE_SOFTWARE_VERTEXPROCESSING | D3DCREATE_MULTITHREADED | D3DCREATE_FPU_PRESERVE,
-                                 &d3dpp, &priv->d3d9device);
-    if (FAILED(hr)) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device\n");
-        return AVERROR_UNKNOWN;
+    if (dxva2_device_create9ex(ctx, adapter) < 0) {
+        // Retry with "classic" d3d9
+        err = dxva2_device_create9(ctx, adapter);
+        if (err < 0)
+            return err;
     }
 
     hr = createDeviceManager(&resetToken, &hwctx->devmgr);
@@ -432,8 +590,9 @@ const HWContextType ff_hwcontext_type_dxva2 = {
     .frames_uninit        = dxva2_frames_uninit,
     .frames_get_buffer    = dxva2_get_buffer,
     .transfer_get_formats = dxva2_transfer_get_formats,
-    .transfer_data_to     = dxva2_transfer_data,
-    .transfer_data_from   = dxva2_transfer_data,
+    .transfer_data_to     = dxva2_transfer_data_to,
+    .transfer_data_from   = dxva2_transfer_data_from,
+    .map_from             = dxva2_map_from,
 
     .pix_fmts             = (const enum AVPixelFormat[]){ AV_PIX_FMT_DXVA2_VLD, AV_PIX_FMT_NONE },
 };
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_dxva2.h b/mythtv/external/FFmpeg/libavutil/hwcontext_dxva2.h
index 6c36cb4b6b4..e1b79bc0dee 100644
--- a/mythtv/external/FFmpeg/libavutil/hwcontext_dxva2.h
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_dxva2.h
@@ -65,6 +65,9 @@ typedef struct AVDXVA2FramesContext {
      *
      * If it is non-NULL, libavutil will call IDirectXVideoDecoder_Release() on
      * it just before the internal surface pool is freed.
+     *
+     * This is for convenience only. Some code uses other methods to manage the
+     * decoder reference.
      */
     IDirectXVideoDecoder *decoder_to_release;
 } AVDXVA2FramesContext;
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_internal.h b/mythtv/external/FFmpeg/libavutil/hwcontext_internal.h
index 079e42b37b8..2d75d3db087 100644
--- a/mythtv/external/FFmpeg/libavutil/hwcontext_internal.h
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_internal.h
@@ -66,6 +66,8 @@ typedef struct HWContextType {
 
     int              (*device_create)(AVHWDeviceContext *ctx, const char *device,
                                       AVDictionary *opts, int flags);
+    int              (*device_derive)(AVHWDeviceContext *dst_ctx,
+                                      AVHWDeviceContext *src_ctx, int flags);
 
     int              (*device_init)(AVHWDeviceContext *ctx);
     void             (*device_uninit)(AVHWDeviceContext *ctx);
@@ -85,11 +87,27 @@ typedef struct HWContextType {
                                          const AVFrame *src);
     int              (*transfer_data_from)(AVHWFramesContext *ctx, AVFrame *dst,
                                            const AVFrame *src);
+
+    int              (*map_to)(AVHWFramesContext *ctx, AVFrame *dst,
+                               const AVFrame *src, int flags);
+    int              (*map_from)(AVHWFramesContext *ctx, AVFrame *dst,
+                                 const AVFrame *src, int flags);
+
+    int              (*frames_derive_to)(AVHWFramesContext *dst_ctx,
+                                         AVHWFramesContext *src_ctx, int flags);
+    int              (*frames_derive_from)(AVHWFramesContext *dst_ctx,
+                                           AVHWFramesContext *src_ctx, int flags);
 } HWContextType;
 
 struct AVHWDeviceInternal {
     const HWContextType *hw_type;
     void                *priv;
+
+    /**
+     * For a derived device, a reference to the original device
+     * context it was derived from.
+     */
+    AVBufferRef *source_device;
 };
 
 struct AVHWFramesInternal {
@@ -97,12 +115,55 @@ struct AVHWFramesInternal {
     void                *priv;
 
     AVBufferPool *pool_internal;
+
+    /**
+     * For a derived context, a reference to the original frames
+     * context it was derived from.
+     */
+    AVBufferRef *source_frames;
+    /**
+     * Flags to apply to the mapping from the source to the derived
+     * frame context when trying to allocate in the derived context.
+     */
+    int source_allocation_map_flags;
 };
 
+typedef struct HWMapDescriptor {
+    /**
+     * A reference to the original source of the mapping.
+     */
+    AVFrame *source;
+    /**
+     * A reference to the hardware frames context in which this
+     * mapping was made.  May be the same as source->hw_frames_ctx,
+     * but need not be.
+     */
+    AVBufferRef *hw_frames_ctx;
+    /**
+     * Unmap function.
+     */
+    void (*unmap)(AVHWFramesContext *ctx,
+                  struct HWMapDescriptor *hwmap);
+    /**
+     * Hardware-specific private data associated with the mapping.
+     */
+    void          *priv;
+} HWMapDescriptor;
+
+int ff_hwframe_map_create(AVBufferRef *hwframe_ref,
+                          AVFrame *dst, const AVFrame *src,
+                          void (*unmap)(AVHWFramesContext *ctx,
+                                        HWMapDescriptor *hwmap),
+                          void *priv);
+
+
 extern const HWContextType ff_hwcontext_type_cuda;
+extern const HWContextType ff_hwcontext_type_d3d11va;
+extern const HWContextType ff_hwcontext_type_drm;
 extern const HWContextType ff_hwcontext_type_dxva2;
 extern const HWContextType ff_hwcontext_type_qsv;
 extern const HWContextType ff_hwcontext_type_vaapi;
 extern const HWContextType ff_hwcontext_type_vdpau;
+extern const HWContextType ff_hwcontext_type_videotoolbox;
 
 #endif /* AVUTIL_HWCONTEXT_INTERNAL_H */
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_qsv.c b/mythtv/external/FFmpeg/libavutil/hwcontext_qsv.c
index 13be5b03aa5..f1d16d8bf92 100644
--- a/mythtv/external/FFmpeg/libavutil/hwcontext_qsv.c
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_qsv.c
@@ -90,8 +90,20 @@ static const struct {
     uint32_t           fourcc;
 } supported_pixel_formats[] = {
     { AV_PIX_FMT_NV12, MFX_FOURCC_NV12 },
+    { AV_PIX_FMT_P010, MFX_FOURCC_P010 },
+    { AV_PIX_FMT_PAL8, MFX_FOURCC_P8   },
 };
 
+static uint32_t qsv_fourcc_from_pix_fmt(enum AVPixelFormat pix_fmt)
+{
+    int i;
+    for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++) {
+        if (supported_pixel_formats[i].pix_fmt == pix_fmt)
+            return supported_pixel_formats[i].fourcc;
+    }
+    return 0;
+}
+
 static int qsv_device_init(AVHWDeviceContext *ctx)
 {
     AVQSVDeviceContext *hwctx = ctx->hwctx;
@@ -270,18 +282,48 @@ static int qsv_init_child_ctx(AVHWFramesContext *ctx)
     return ret;
 }
 
+static int qsv_init_surface(AVHWFramesContext *ctx, mfxFrameSurface1 *surf)
+{
+    const AVPixFmtDescriptor *desc;
+    uint32_t fourcc;
+
+    desc = av_pix_fmt_desc_get(ctx->sw_format);
+    if (!desc)
+        return AVERROR(EINVAL);
+
+    fourcc = qsv_fourcc_from_pix_fmt(ctx->sw_format);
+    if (!fourcc)
+        return AVERROR(EINVAL);
+
+    surf->Info.BitDepthLuma   = desc->comp[0].depth;
+    surf->Info.BitDepthChroma = desc->comp[0].depth;
+    surf->Info.Shift          = desc->comp[0].depth > 8;
+
+    if (desc->log2_chroma_w && desc->log2_chroma_h)
+        surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
+    else if (desc->log2_chroma_w)
+        surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV422;
+    else
+        surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV444;
+
+    surf->Info.FourCC         = fourcc;
+    surf->Info.Width          = ctx->width;
+    surf->Info.CropW          = ctx->width;
+    surf->Info.Height         = ctx->height;
+    surf->Info.CropH          = ctx->height;
+    surf->Info.FrameRateExtN  = 25;
+    surf->Info.FrameRateExtD  = 1;
+
+    return 0;
+}
+
 static int qsv_init_pool(AVHWFramesContext *ctx, uint32_t fourcc)
 {
     QSVFramesContext              *s = ctx->internal->priv;
     AVQSVFramesContext *frames_hwctx = ctx->hwctx;
-    const AVPixFmtDescriptor *desc;
 
     int i, ret = 0;
 
-    desc = av_pix_fmt_desc_get(ctx->sw_format);
-    if (!desc)
-        return AVERROR_BUG;
-
     if (ctx->initial_pool_size <= 0) {
         av_log(ctx, AV_LOG_ERROR, "QSV requires a fixed frame pool size\n");
         return AVERROR(EINVAL);
@@ -293,26 +335,9 @@ static int qsv_init_pool(AVHWFramesContext *ctx, uint32_t fourcc)
         return AVERROR(ENOMEM);
 
     for (i = 0; i < ctx->initial_pool_size; i++) {
-        mfxFrameSurface1 *surf = &s->surfaces_internal[i];
-
-        surf->Info.BitDepthLuma   = desc->comp[0].depth;
-        surf->Info.BitDepthChroma = desc->comp[0].depth;
-        surf->Info.Shift          = desc->comp[0].depth > 8;
-
-        if (desc->log2_chroma_w && desc->log2_chroma_h)
-            surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
-        else if (desc->log2_chroma_w)
-            surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV422;
-        else
-            surf->Info.ChromaFormat   = MFX_CHROMAFORMAT_YUV444;
-
-        surf->Info.FourCC         = fourcc;
-        surf->Info.Width          = ctx->width;
-        surf->Info.CropW          = ctx->width;
-        surf->Info.Height         = ctx->height;
-        surf->Info.CropH          = ctx->height;
-        surf->Info.FrameRateExtN  = 25;
-        surf->Info.FrameRateExtD  = 1;
+        ret = qsv_init_surface(ctx, &s->surfaces_internal[i]);
+        if (ret < 0)
+            return ret;
     }
 
     if (!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)) {
@@ -448,8 +473,10 @@ static int qsv_init_internal_session(AVHWFramesContext *ctx,
 
     err = MFXVideoVPP_Init(*session, &par);
     if (err != MFX_ERR_NONE) {
-        av_log(ctx, AV_LOG_ERROR, "Error opening the internal VPP session\n");
-        return AVERROR_UNKNOWN;
+        av_log(ctx, AV_LOG_VERBOSE, "Error opening the internal VPP session."
+               "Surface upload/download will not be possible\n");
+        MFXClose(*session);
+        *session = NULL;
     }
 
     return 0;
@@ -462,15 +489,10 @@ static int qsv_frames_init(AVHWFramesContext *ctx)
 
     int opaque = !!(frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME);
 
-    uint32_t fourcc = 0;
+    uint32_t fourcc;
     int i, ret;
 
-    for (i = 0; i < FF_ARRAY_ELEMS(supported_pixel_formats); i++) {
-        if (supported_pixel_formats[i].pix_fmt == ctx->sw_format) {
-            fourcc = supported_pixel_formats[i].fourcc;
-            break;
-        }
-    }
+    fourcc = qsv_fourcc_from_pix_fmt(ctx->sw_format);
     if (!fourcc) {
         av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format\n");
         return AVERROR(ENOSYS);
@@ -555,6 +577,159 @@ static int qsv_transfer_get_formats(AVHWFramesContext *ctx,
     return 0;
 }
 
+static int qsv_frames_derive_from(AVHWFramesContext *dst_ctx,
+                                  AVHWFramesContext *src_ctx, int flags)
+{
+    AVQSVFramesContext *src_hwctx = src_ctx->hwctx;
+    int i;
+
+    switch (dst_ctx->device_ctx->type) {
+#if CONFIG_VAAPI
+    case AV_HWDEVICE_TYPE_VAAPI:
+        {
+            AVVAAPIFramesContext *dst_hwctx = dst_ctx->hwctx;
+            dst_hwctx->surface_ids = av_mallocz_array(src_hwctx->nb_surfaces,
+                                                      sizeof(*dst_hwctx->surface_ids));
+            if (!dst_hwctx->surface_ids)
+                return AVERROR(ENOMEM);
+            for (i = 0; i < src_hwctx->nb_surfaces; i++)
+                dst_hwctx->surface_ids[i] =
+                    *(VASurfaceID*)src_hwctx->surfaces[i].Data.MemId;
+            dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
+        }
+        break;
+#endif
+#if CONFIG_DXVA2
+    case AV_HWDEVICE_TYPE_DXVA2:
+        {
+            AVDXVA2FramesContext *dst_hwctx = dst_ctx->hwctx;
+            dst_hwctx->surfaces = av_mallocz_array(src_hwctx->nb_surfaces,
+                                                   sizeof(*dst_hwctx->surfaces));
+            if (!dst_hwctx->surfaces)
+                return AVERROR(ENOMEM);
+            for (i = 0; i < src_hwctx->nb_surfaces; i++)
+                dst_hwctx->surfaces[i] =
+                    (IDirect3DSurface9*)src_hwctx->surfaces[i].Data.MemId;
+            dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
+            if (src_hwctx->frame_type == MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET)
+                dst_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;
+            else
+                dst_hwctx->surface_type = DXVA2_VideoProcessorRenderTarget;
+        }
+        break;
+#endif
+    default:
+        return AVERROR(ENOSYS);
+    }
+
+    return 0;
+}
+
+static int qsv_map_from(AVHWFramesContext *ctx,
+                        AVFrame *dst, const AVFrame *src, int flags)
+{
+    QSVFramesContext *s = ctx->internal->priv;
+    mfxFrameSurface1 *surf = (mfxFrameSurface1*)src->data[3];
+    AVHWFramesContext *child_frames_ctx;
+    const AVPixFmtDescriptor *desc;
+    uint8_t *child_data;
+    AVFrame *dummy;
+    int ret = 0;
+
+    if (!s->child_frames_ref)
+        return AVERROR(ENOSYS);
+    child_frames_ctx = (AVHWFramesContext*)s->child_frames_ref->data;
+
+    switch (child_frames_ctx->device_ctx->type) {
+#if CONFIG_VAAPI
+    case AV_HWDEVICE_TYPE_VAAPI:
+        child_data = (uint8_t*)(intptr_t)*(VASurfaceID*)surf->Data.MemId;
+        break;
+#endif
+#if CONFIG_DXVA2
+    case AV_HWDEVICE_TYPE_DXVA2:
+        child_data = surf->Data.MemId;
+        break;
+#endif
+    default:
+        return AVERROR(ENOSYS);
+    }
+
+    if (dst->format == child_frames_ctx->format) {
+        ret = ff_hwframe_map_create(s->child_frames_ref,
+                                    dst, src, NULL, NULL);
+        if (ret < 0)
+            return ret;
+
+        dst->width   = src->width;
+        dst->height  = src->height;
+        dst->data[3] = child_data;
+
+        return 0;
+    }
+
+    desc = av_pix_fmt_desc_get(dst->format);
+    if (desc && desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
+        // This only supports mapping to software.
+        return AVERROR(ENOSYS);
+    }
+
+    dummy = av_frame_alloc();
+    if (!dummy)
+        return AVERROR(ENOMEM);
+
+    dummy->buf[0]        = av_buffer_ref(src->buf[0]);
+    dummy->hw_frames_ctx = av_buffer_ref(s->child_frames_ref);
+    if (!dummy->buf[0] || !dummy->hw_frames_ctx)
+        goto fail;
+
+    dummy->format        = child_frames_ctx->format;
+    dummy->width         = src->width;
+    dummy->height        = src->height;
+    dummy->data[3]       = child_data;
+
+    ret = av_hwframe_map(dst, dummy, flags);
+
+fail:
+    av_frame_free(&dummy);
+
+    return ret;
+}
+
+static int qsv_transfer_data_child(AVHWFramesContext *ctx, AVFrame *dst,
+                                   const AVFrame *src)
+{
+    QSVFramesContext *s = ctx->internal->priv;
+    AVHWFramesContext *child_frames_ctx = (AVHWFramesContext*)s->child_frames_ref->data;
+    int download = !!src->hw_frames_ctx;
+    mfxFrameSurface1 *surf = (mfxFrameSurface1*)(download ? src->data[3] : dst->data[3]);
+
+    AVFrame *dummy;
+    int ret;
+
+    dummy = av_frame_alloc();
+    if (!dummy)
+        return AVERROR(ENOMEM);
+
+    dummy->format        = child_frames_ctx->format;
+    dummy->width         = src->width;
+    dummy->height        = src->height;
+    dummy->buf[0]        = download ? src->buf[0] : dst->buf[0];
+    dummy->data[3]       = surf->Data.MemId;
+    dummy->hw_frames_ctx = s->child_frames_ref;
+
+    ret = download ? av_hwframe_transfer_data(dst, dummy, 0) :
+                     av_hwframe_transfer_data(dummy, src, 0);
+
+    dummy->buf[0]        = NULL;
+    dummy->data[3]       = NULL;
+    dummy->hw_frames_ctx = NULL;
+
+    av_frame_free(&dummy);
+
+    return ret;
+}
+
 static int qsv_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
                                   const AVFrame *src)
 {
@@ -565,6 +740,14 @@ static int qsv_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
     mfxSyncPoint sync = NULL;
     mfxStatus err;
 
+    if (!s->session_download) {
+        if (s->child_frames_ref)
+            return qsv_transfer_data_child(ctx, dst, src);
+
+        av_log(ctx, AV_LOG_ERROR, "Surface download not possible\n");
+        return AVERROR(ENOSYS);
+    }
+
     out.Info = in->Info;
     out.Data.PitchLow = dst->linesize[0];
     out.Data.Y        = dst->data[0];
@@ -604,6 +787,14 @@ static int qsv_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
     mfxSyncPoint sync = NULL;
     mfxStatus err;
 
+    if (!s->session_upload) {
+        if (s->child_frames_ref)
+            return qsv_transfer_data_child(ctx, dst, src);
+
+        av_log(ctx, AV_LOG_ERROR, "Surface upload not possible\n");
+        return AVERROR(ENOSYS);
+    }
+
     in.Info = out->Info;
     in.Data.PitchLow = src->linesize[0];
     in.Data.Y        = src->data[0];
@@ -633,6 +824,96 @@ static int qsv_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
     return 0;
 }
 
+static int qsv_frames_derive_to(AVHWFramesContext *dst_ctx,
+                                AVHWFramesContext *src_ctx, int flags)
+{
+    QSVFramesContext *s = dst_ctx->internal->priv;
+    AVQSVFramesContext *dst_hwctx = dst_ctx->hwctx;
+    int i;
+
+    switch (src_ctx->device_ctx->type) {
+#if CONFIG_VAAPI
+    case AV_HWDEVICE_TYPE_VAAPI:
+        {
+            AVVAAPIFramesContext *src_hwctx = src_ctx->hwctx;
+            s->surfaces_internal = av_mallocz_array(src_hwctx->nb_surfaces,
+                                                    sizeof(*s->surfaces_internal));
+            if (!s->surfaces_internal)
+                return AVERROR(ENOMEM);
+            for (i = 0; i < src_hwctx->nb_surfaces; i++) {
+                qsv_init_surface(dst_ctx, &s->surfaces_internal[i]);
+                s->surfaces_internal[i].Data.MemId = src_hwctx->surface_ids + i;
+            }
+            dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
+            dst_hwctx->frame_type  = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
+        }
+        break;
+#endif
+#if CONFIG_DXVA2
+    case AV_HWDEVICE_TYPE_DXVA2:
+        {
+            AVDXVA2FramesContext *src_hwctx = src_ctx->hwctx;
+            s->surfaces_internal = av_mallocz_array(src_hwctx->nb_surfaces,
+                                                    sizeof(*s->surfaces_internal));
+            if (!s->surfaces_internal)
+                return AVERROR(ENOMEM);
+            for (i = 0; i < src_hwctx->nb_surfaces; i++) {
+                qsv_init_surface(dst_ctx, &s->surfaces_internal[i]);
+                s->surfaces_internal[i].Data.MemId = (mfxMemId)src_hwctx->surfaces[i];
+            }
+            dst_hwctx->nb_surfaces = src_hwctx->nb_surfaces;
+            if (src_hwctx->surface_type == DXVA2_VideoProcessorRenderTarget)
+                dst_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET;
+            else
+                dst_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
+        }
+        break;
+#endif
+    default:
+        return AVERROR(ENOSYS);
+    }
+
+    dst_hwctx->surfaces = s->surfaces_internal;
+
+    return 0;
+}
+
+static int qsv_map_to(AVHWFramesContext *dst_ctx,
+                      AVFrame *dst, const AVFrame *src, int flags)
+{
+    AVQSVFramesContext *hwctx = dst_ctx->hwctx;
+    int i, err;
+
+    for (i = 0; i < hwctx->nb_surfaces; i++) {
+#if CONFIG_VAAPI
+        if (*(VASurfaceID*)hwctx->surfaces[i].Data.MemId ==
+            (VASurfaceID)(uintptr_t)src->data[3])
+            break;
+#endif
+#if CONFIG_DXVA2
+        if ((IDirect3DSurface9*)hwctx->surfaces[i].Data.MemId ==
+            (IDirect3DSurface9*)(uintptr_t)src->data[3])
+            break;
+#endif
+    }
+    if (i >= hwctx->nb_surfaces) {
+        av_log(dst_ctx, AV_LOG_ERROR, "Trying to map from a surface which "
+               "is not in the mapped frames context.\n");
+        return AVERROR(EINVAL);
+    }
+
+    err = ff_hwframe_map_create(dst->hw_frames_ctx,
+                                dst, src, NULL, NULL);
+    if (err)
+        return err;
+
+    dst->width   = src->width;
+    dst->height  = src->height;
+    dst->data[3] = (uint8_t*)&hwctx->surfaces[i];
+
+    return 0;
+}
+
 static int qsv_frames_get_constraints(AVHWDeviceContext *ctx,
                                       const void *hwconfig,
                                       AVHWFramesConstraints *constraints)
@@ -702,21 +983,86 @@ static mfxIMPL choose_implementation(const char *device)
     return impl;
 }
 
-static int qsv_device_create(AVHWDeviceContext *ctx, const char *device,
-                             AVDictionary *opts, int flags)
+static int qsv_device_derive_from_child(AVHWDeviceContext *ctx,
+                                        mfxIMPL implementation,
+                                        AVHWDeviceContext *child_device_ctx,
+                                        int flags)
 {
     AVQSVDeviceContext *hwctx = ctx->hwctx;
-    QSVDevicePriv *priv;
-    enum AVHWDeviceType child_device_type;
-    AVDictionaryEntry *e;
+    QSVDeviceContext       *s = ctx->internal->priv;
 
     mfxVersion    ver = { { 3, 1 } };
-    mfxIMPL       impl;
     mfxHDL        handle;
     mfxHandleType handle_type;
     mfxStatus     err;
     int ret;
 
+    switch (child_device_ctx->type) {
+#if CONFIG_VAAPI
+    case AV_HWDEVICE_TYPE_VAAPI:
+        {
+            AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx;
+            handle_type = MFX_HANDLE_VA_DISPLAY;
+            handle = (mfxHDL)child_device_hwctx->display;
+        }
+        break;
+#endif
+#if CONFIG_DXVA2
+    case AV_HWDEVICE_TYPE_DXVA2:
+        {
+            AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx;
+            handle_type = MFX_HANDLE_D3D9_DEVICE_MANAGER;
+            handle = (mfxHDL)child_device_hwctx->devmgr;
+        }
+        break;
+#endif
+    default:
+        ret = AVERROR(ENOSYS);
+        goto fail;
+    }
+
+    err = MFXInit(implementation, &ver, &hwctx->session);
+    if (err != MFX_ERR_NONE) {
+        av_log(ctx, AV_LOG_ERROR, "Error initializing an MFX session: "
+               "%d.\n", err);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    err = MFXVideoCORE_SetHandle(hwctx->session, handle_type, handle);
+    if (err != MFX_ERR_NONE) {
+        av_log(ctx, AV_LOG_ERROR, "Error setting child device handle: "
+               "%d\n", err);
+        ret = AVERROR_UNKNOWN;
+        goto fail;
+    }
+
+    return 0;
+
+fail:
+    if (hwctx->session)
+        MFXClose(hwctx->session);
+    return ret;
+}
+
+static int qsv_device_derive(AVHWDeviceContext *ctx,
+                             AVHWDeviceContext *child_device_ctx, int flags)
+{
+    return qsv_device_derive_from_child(ctx, MFX_IMPL_HARDWARE_ANY,
+                                        child_device_ctx, flags);
+}
+
+static int qsv_device_create(AVHWDeviceContext *ctx, const char *device,
+                             AVDictionary *opts, int flags)
+{
+    QSVDevicePriv *priv;
+    enum AVHWDeviceType child_device_type;
+    AVHWDeviceContext *child_device;
+    AVDictionaryEntry *e;
+
+    mfxIMPL impl;
+    int ret;
+
     priv = av_mallocz(sizeof(*priv));
     if (!priv)
         return AVERROR(ENOMEM);
@@ -740,32 +1086,11 @@ static int qsv_device_create(AVHWDeviceContext *ctx, const char *device,
     if (ret < 0)
         return ret;
 
-    {
-        AVHWDeviceContext      *child_device_ctx = (AVHWDeviceContext*)priv->child_device_ctx->data;
-#if CONFIG_VAAPI
-        AVVAAPIDeviceContext *child_device_hwctx = child_device_ctx->hwctx;
-        handle_type = MFX_HANDLE_VA_DISPLAY;
-        handle = (mfxHDL)child_device_hwctx->display;
-#elif CONFIG_DXVA2
-        AVDXVA2DeviceContext *child_device_hwctx = child_device_ctx->hwctx;
-        handle_type = MFX_HANDLE_D3D9_DEVICE_MANAGER;
-        handle = (mfxHDL)child_device_hwctx->devmgr;
-#endif
-    }
+    child_device = (AVHWDeviceContext*)priv->child_device_ctx->data;
 
     impl = choose_implementation(device);
 
-    err = MFXInit(impl, &ver, &hwctx->session);
-    if (err != MFX_ERR_NONE) {
-        av_log(ctx, AV_LOG_ERROR, "Error initializing an MFX session\n");
-        return AVERROR_UNKNOWN;
-    }
-
-    err = MFXVideoCORE_SetHandle(hwctx->session, handle_type, handle);
-    if (err != MFX_ERR_NONE)
-        return AVERROR_UNKNOWN;
-
-    return 0;
+    return qsv_device_derive_from_child(ctx, impl, child_device, 0);
 }
 
 const HWContextType ff_hwcontext_type_qsv = {
@@ -778,6 +1103,7 @@ const HWContextType ff_hwcontext_type_qsv = {
     .frames_priv_size       = sizeof(QSVFramesContext),
 
     .device_create          = qsv_device_create,
+    .device_derive          = qsv_device_derive,
     .device_init            = qsv_device_init,
     .frames_get_constraints = qsv_frames_get_constraints,
     .frames_init            = qsv_frames_init,
@@ -786,6 +1112,10 @@ const HWContextType ff_hwcontext_type_qsv = {
     .transfer_get_formats   = qsv_transfer_get_formats,
     .transfer_data_to       = qsv_transfer_data_to,
     .transfer_data_from     = qsv_transfer_data_from,
+    .map_to                 = qsv_map_to,
+    .map_from               = qsv_map_from,
+    .frames_derive_to       = qsv_frames_derive_to,
+    .frames_derive_from     = qsv_frames_derive_from,
 
     .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_QSV, AV_PIX_FMT_NONE },
 };
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_vaapi.c b/mythtv/external/FFmpeg/libavutil/hwcontext_vaapi.c
index cfa25bce62f..cc961f12f89 100644
--- a/mythtv/external/FFmpeg/libavutil/hwcontext_vaapi.c
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_vaapi.c
@@ -25,6 +25,11 @@
 #   include <va/va_drm.h>
 #endif
 
+#if CONFIG_LIBDRM
+#   include <va/va_drmcommon.h>
+#   include <drm_fourcc.h>
+#endif
+
 #include <fcntl.h>
 #if HAVE_UNISTD_H
 #   include <unistd.h>
@@ -41,6 +46,10 @@
 #include "pixdesc.h"
 #include "pixfmt.h"
 
+#if CONFIG_LIBDRM
+#   include "hwcontext_drm.h"
+#endif
+
 typedef struct VAAPIDevicePriv {
 #if HAVE_VAAPI_X11
     Display *x11_display;
@@ -70,20 +79,12 @@ typedef struct VAAPIFramesContext {
     int derive_works;
 } VAAPIFramesContext;
 
-enum {
-    VAAPI_MAP_READ   = 0x01,
-    VAAPI_MAP_WRITE  = 0x02,
-    VAAPI_MAP_DIRECT = 0x04,
-};
-
-typedef struct VAAPISurfaceMap {
-    // The source hardware frame of this mapping (with hw_frames_ctx set).
-    const AVFrame *source;
-    // VAAPI_MAP_* flags which apply to this mapping.
-    int flags;
+typedef struct VAAPIMapping {
     // Handle to the derived or copied image which is mapped.
     VAImage image;
-} VAAPISurfaceMap;
+    // The mapping flags actually used.
+    int flags;
+} VAAPIMapping;
 
 #define MAP(va, rt, av) { \
         VA_FOURCC_ ## va, \
@@ -92,7 +93,7 @@ typedef struct VAAPISurfaceMap {
     }
 // The map fourcc <-> pix_fmt isn't bijective because of the annoying U/V
 // plane swap cases.  The frame handling below tries to hide these.
-static struct {
+static const struct {
     unsigned int fourcc;
     unsigned int rt_format;
     enum AVPixelFormat pix_fmt;
@@ -142,7 +143,8 @@ static int vaapi_get_image_format(AVHWDeviceContext *hwdev,
 
     for (i = 0; i < ctx->nb_formats; i++) {
         if (ctx->formats[i].pix_fmt == pix_fmt) {
-            *image_format = &ctx->formats[i].image_format;
+            if (image_format)
+                *image_format = &ctx->formats[i].image_format;
             return 0;
         }
     }
@@ -162,7 +164,8 @@ static int vaapi_frames_get_constraints(AVHWDeviceContext *hwdev,
     unsigned int fourcc;
     int err, i, j, attr_count, pix_fmt_count;
 
-    if (config) {
+    if (config &&
+        !(hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES)) {
         attr_count = 0;
         vas = vaQuerySurfaceAttributes(hwctx->display, config->config_id,
                                        0, &attr_count);
@@ -265,12 +268,35 @@ static int vaapi_frames_get_constraints(AVHWDeviceContext *hwdev,
     return err;
 }
 
+static const struct {
+    const char *friendly_name;
+    const char *match_string;
+    unsigned int quirks;
+} vaapi_driver_quirks_table[] = {
+    {
+        "Intel i965 (Quick Sync)",
+        "i965",
+        AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS,
+    },
+    {
+        "Intel iHD",
+        "ubit",
+        AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE,
+    },
+    {
+        "VDPAU wrapper",
+        "Splitted-Desktop Systems VDPAU backend for VA-API",
+        AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES,
+    },
+};
+
 static int vaapi_device_init(AVHWDeviceContext *hwdev)
 {
     VAAPIDeviceContext *ctx = hwdev->internal->priv;
     AVVAAPIDeviceContext *hwctx = hwdev->hwctx;
     VAImageFormat *image_list = NULL;
     VAStatus vas;
+    const char *vendor_string;
     int err, i, image_count;
     enum AVPixelFormat pix_fmt;
     unsigned int fourcc;
@@ -312,6 +338,32 @@ static int vaapi_device_init(AVHWDeviceContext *hwdev)
         }
     }
 
+    if (hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_USER_SET) {
+        av_log(hwdev, AV_LOG_VERBOSE, "Not detecting driver: "
+               "quirks set by user.\n");
+    } else {
+        // Detect the driver in use and set quirk flags if necessary.
+        vendor_string = vaQueryVendorString(hwctx->display);
+        hwctx->driver_quirks = 0;
+        if (vendor_string) {
+            for (i = 0; i < FF_ARRAY_ELEMS(vaapi_driver_quirks_table); i++) {
+                if (strstr(vendor_string,
+                           vaapi_driver_quirks_table[i].match_string)) {
+                    av_log(hwdev, AV_LOG_VERBOSE, "Matched \"%s\" as known "
+                           "driver \"%s\".\n", vendor_string,
+                           vaapi_driver_quirks_table[i].friendly_name);
+                    hwctx->driver_quirks |=
+                        vaapi_driver_quirks_table[i].quirks;
+                    break;
+                }
+            }
+            if (!(i < FF_ARRAY_ELEMS(vaapi_driver_quirks_table))) {
+                av_log(hwdev, AV_LOG_VERBOSE, "Unknown driver \"%s\", "
+                       "assuming standard behaviour.\n", vendor_string);
+            }
+        }
+    }
+
     av_free(image_list);
     return 0;
 fail:
@@ -353,6 +405,10 @@ static AVBufferRef *vaapi_pool_alloc(void *opaque, int size)
     VAStatus vas;
     AVBufferRef *ref;
 
+    if (hwfc->initial_pool_size > 0 &&
+        avfc->nb_surfaces >= hwfc->initial_pool_size)
+        return NULL;
+
     vas = vaCreateSurfaces(hwctx->display, ctx->rt_format,
                            hwfc->width, hwfc->height,
                            &surface_id, 1,
@@ -410,42 +466,48 @@ static int vaapi_frames_init(AVHWFramesContext *hwfc)
     }
 
     if (!hwfc->pool) {
-        int need_memory_type = 1, need_pixel_format = 1;
-        for (i = 0; i < avfc->nb_attributes; i++) {
-            if (ctx->attributes[i].type == VASurfaceAttribMemoryType)
-                need_memory_type  = 0;
-            if (ctx->attributes[i].type == VASurfaceAttribPixelFormat)
-                need_pixel_format = 0;
-        }
-        ctx->nb_attributes =
-            avfc->nb_attributes + need_memory_type + need_pixel_format;
+        if (!(hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES)) {
+            int need_memory_type = !(hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE);
+            int need_pixel_format = 1;
+            for (i = 0; i < avfc->nb_attributes; i++) {
+                if (ctx->attributes[i].type == VASurfaceAttribMemoryType)
+                    need_memory_type  = 0;
+                if (ctx->attributes[i].type == VASurfaceAttribPixelFormat)
+                    need_pixel_format = 0;
+            }
+            ctx->nb_attributes =
+                avfc->nb_attributes + need_memory_type + need_pixel_format;
 
-        ctx->attributes = av_malloc(ctx->nb_attributes *
+            ctx->attributes = av_malloc(ctx->nb_attributes *
                                         sizeof(*ctx->attributes));
-        if (!ctx->attributes) {
-            err = AVERROR(ENOMEM);
-            goto fail;
-        }
+            if (!ctx->attributes) {
+                err = AVERROR(ENOMEM);
+                goto fail;
+            }
 
-        for (i = 0; i < avfc->nb_attributes; i++)
-            ctx->attributes[i] = avfc->attributes[i];
-        if (need_memory_type) {
-            ctx->attributes[i++] = (VASurfaceAttrib) {
-                .type          = VASurfaceAttribMemoryType,
-                .flags         = VA_SURFACE_ATTRIB_SETTABLE,
-                .value.type    = VAGenericValueTypeInteger,
-                .value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA,
-            };
-        }
-        if (need_pixel_format) {
-            ctx->attributes[i++] = (VASurfaceAttrib) {
-                .type          = VASurfaceAttribPixelFormat,
-                .flags         = VA_SURFACE_ATTRIB_SETTABLE,
-                .value.type    = VAGenericValueTypeInteger,
-                .value.value.i = fourcc,
-            };
+            for (i = 0; i < avfc->nb_attributes; i++)
+                ctx->attributes[i] = avfc->attributes[i];
+            if (need_memory_type) {
+                ctx->attributes[i++] = (VASurfaceAttrib) {
+                    .type          = VASurfaceAttribMemoryType,
+                    .flags         = VA_SURFACE_ATTRIB_SETTABLE,
+                    .value.type    = VAGenericValueTypeInteger,
+                    .value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA,
+                };
+            }
+            if (need_pixel_format) {
+                ctx->attributes[i++] = (VASurfaceAttrib) {
+                    .type          = VASurfaceAttribPixelFormat,
+                    .flags         = VA_SURFACE_ATTRIB_SETTABLE,
+                    .value.type    = VAGenericValueTypeInteger,
+                    .value.value.i = fourcc,
+                };
+            }
+            av_assert0(i == ctx->nb_attributes);
+        } else {
+            ctx->attributes = NULL;
+            ctx->nb_attributes = 0;
         }
-        av_assert0(i == ctx->nb_attributes);
 
         ctx->rt_format = rt_format;
 
@@ -587,17 +649,15 @@ static int vaapi_transfer_get_formats(AVHWFramesContext *hwfc,
     return 0;
 }
 
-static void vaapi_unmap_frame(void *opaque, uint8_t *data)
+static void vaapi_unmap_frame(AVHWFramesContext *hwfc,
+                              HWMapDescriptor *hwmap)
 {
-    AVHWFramesContext *hwfc = opaque;
     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
-    VAAPISurfaceMap *map = (VAAPISurfaceMap*)data;
-    const AVFrame *src;
+    VAAPIMapping           *map = hwmap->priv;
     VASurfaceID surface_id;
     VAStatus vas;
 
-    src = map->source;
-    surface_id = (VASurfaceID)(uintptr_t)src->data[3];
+    surface_id = (VASurfaceID)(uintptr_t)hwmap->source->data[3];
     av_log(hwfc, AV_LOG_DEBUG, "Unmap surface %#x.\n", surface_id);
 
     vas = vaUnmapBuffer(hwctx->display, map->image.buf);
@@ -606,8 +666,8 @@ static void vaapi_unmap_frame(void *opaque, uint8_t *data)
                "%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
     }
 
-    if ((map->flags & VAAPI_MAP_WRITE) &&
-        !(map->flags & VAAPI_MAP_DIRECT)) {
+    if ((map->flags & AV_HWFRAME_MAP_WRITE) &&
+        !(map->flags & AV_HWFRAME_MAP_DIRECT)) {
         vas = vaPutImage(hwctx->display, surface_id, map->image.image_id,
                          0, 0, hwfc->width, hwfc->height,
                          0, 0, hwfc->width, hwfc->height);
@@ -633,7 +693,7 @@ static int vaapi_map_frame(AVHWFramesContext *hwfc,
     VAAPIFramesContext *ctx = hwfc->internal->priv;
     VASurfaceID surface_id;
     VAImageFormat *image_format;
-    VAAPISurfaceMap *map;
+    VAAPIMapping *map;
     VAStatus vas;
     void *address = NULL;
     int err, i;
@@ -641,13 +701,13 @@ static int vaapi_map_frame(AVHWFramesContext *hwfc,
     surface_id = (VASurfaceID)(uintptr_t)src->data[3];
     av_log(hwfc, AV_LOG_DEBUG, "Map surface %#x.\n", surface_id);
 
-    if (!ctx->derive_works && (flags & VAAPI_MAP_DIRECT)) {
+    if (!ctx->derive_works && (flags & AV_HWFRAME_MAP_DIRECT)) {
         // Requested direct mapping but it is not possible.
         return AVERROR(EINVAL);
     }
     if (dst->format == AV_PIX_FMT_NONE)
         dst->format = hwfc->sw_format;
-    if (dst->format != hwfc->sw_format && (flags & VAAPI_MAP_DIRECT)) {
+    if (dst->format != hwfc->sw_format && (flags & AV_HWFRAME_MAP_DIRECT)) {
         // Requested direct mapping but the formats do not match.
         return AVERROR(EINVAL);
     }
@@ -658,12 +718,10 @@ static int vaapi_map_frame(AVHWFramesContext *hwfc,
         return AVERROR(EINVAL);
     }
 
-    map = av_malloc(sizeof(VAAPISurfaceMap));
+    map = av_malloc(sizeof(*map));
     if (!map)
         return AVERROR(ENOMEM);
-
-    map->source         = src;
-    map->flags          = flags;
+    map->flags = flags;
     map->image.image_id = VA_INVALID_ID;
 
     vas = vaSyncSurface(hwctx->display, surface_id);
@@ -681,8 +739,8 @@ static int vaapi_map_frame(AVHWFramesContext *hwfc,
     // faster with a copy routine which is aware of the limitation, but we
     // assume for now that the user is not aware of that and would therefore
     // prefer not to be given direct-mapped memory if they request read access.
-    if (ctx->derive_works &&
-        ((flags & VAAPI_MAP_DIRECT) || !(flags & VAAPI_MAP_READ))) {
+    if (ctx->derive_works && dst->format == hwfc->sw_format &&
+        ((flags & AV_HWFRAME_MAP_DIRECT) || !(flags & AV_HWFRAME_MAP_READ))) {
         vas = vaDeriveImage(hwctx->display, surface_id, &map->image);
         if (vas != VA_STATUS_SUCCESS) {
             av_log(hwfc, AV_LOG_ERROR, "Failed to derive image from "
@@ -698,7 +756,7 @@ static int vaapi_map_frame(AVHWFramesContext *hwfc,
             err = AVERROR(EIO);
             goto fail;
         }
-        map->flags |= VAAPI_MAP_DIRECT;
+        map->flags |= AV_HWFRAME_MAP_DIRECT;
     } else {
         vas = vaCreateImage(hwctx->display, image_format,
                             hwfc->width, hwfc->height, &map->image);
@@ -709,7 +767,7 @@ static int vaapi_map_frame(AVHWFramesContext *hwfc,
             err = AVERROR(EIO);
             goto fail;
         }
-        if (flags & VAAPI_MAP_READ) {
+        if (!(flags & AV_HWFRAME_MAP_OVERWRITE)) {
             vas = vaGetImage(hwctx->display, surface_id, 0, 0,
                              hwfc->width, hwfc->height, map->image.image_id);
             if (vas != VA_STATUS_SUCCESS) {
@@ -730,6 +788,11 @@ static int vaapi_map_frame(AVHWFramesContext *hwfc,
         goto fail;
     }
 
+    err = ff_hwframe_map_create(src->hw_frames_ctx,
+                                dst, src, &vaapi_unmap_frame, map);
+    if (err < 0)
+        goto fail;
+
     dst->width  = src->width;
     dst->height = src->height;
 
@@ -746,13 +809,6 @@ static int vaapi_map_frame(AVHWFramesContext *hwfc,
         FFSWAP(uint8_t*, dst->data[1], dst->data[2]);
     }
 
-    dst->buf[0] = av_buffer_create((uint8_t*)map, sizeof(*map),
-                                   &vaapi_unmap_frame, hwfc, 0);
-    if (!dst->buf[0]) {
-        err = AVERROR(ENOMEM);
-        goto fail;
-    }
-
     return 0;
 
 fail:
@@ -772,15 +828,21 @@ static int vaapi_transfer_data_from(AVHWFramesContext *hwfc,
     AVFrame *map;
     int err;
 
+    if (dst->width > hwfc->width || dst->height > hwfc->height)
+        return AVERROR(EINVAL);
+
     map = av_frame_alloc();
     if (!map)
         return AVERROR(ENOMEM);
     map->format = dst->format;
 
-    err = vaapi_map_frame(hwfc, map, src, VAAPI_MAP_READ);
+    err = vaapi_map_frame(hwfc, map, src, AV_HWFRAME_MAP_READ);
     if (err)
         goto fail;
 
+    map->width  = dst->width;
+    map->height = dst->height;
+
     err = av_frame_copy(dst, map);
     if (err)
         goto fail;
@@ -797,15 +859,21 @@ static int vaapi_transfer_data_to(AVHWFramesContext *hwfc,
     AVFrame *map;
     int err;
 
+    if (src->width > hwfc->width || src->height > hwfc->height)
+        return AVERROR(EINVAL);
+
     map = av_frame_alloc();
     if (!map)
         return AVERROR(ENOMEM);
     map->format = src->format;
 
-    err = vaapi_map_frame(hwfc, map, dst, VAAPI_MAP_WRITE);
+    err = vaapi_map_frame(hwfc, map, dst, AV_HWFRAME_MAP_WRITE | AV_HWFRAME_MAP_OVERWRITE);
     if (err)
         goto fail;
 
+    map->width  = src->width;
+    map->height = src->height;
+
     err = av_frame_copy(map, src);
     if (err)
         goto fail;
@@ -816,6 +884,232 @@ static int vaapi_transfer_data_to(AVHWFramesContext *hwfc,
     return err;
 }
 
+static int vaapi_map_to_memory(AVHWFramesContext *hwfc, AVFrame *dst,
+                               const AVFrame *src, int flags)
+{
+    int err;
+
+    if (dst->format != AV_PIX_FMT_NONE) {
+        err = vaapi_get_image_format(hwfc->device_ctx, dst->format, NULL);
+        if (err < 0)
+            return AVERROR(ENOSYS);
+    }
+
+    err = vaapi_map_frame(hwfc, dst, src, flags);
+    if (err)
+        return err;
+
+    err = av_frame_copy_props(dst, src);
+    if (err)
+        return err;
+
+    return 0;
+}
+
+#if CONFIG_LIBDRM
+
+#define DRM_MAP(va, layers, ...) { \
+        VA_FOURCC_ ## va, \
+        layers, \
+        { __VA_ARGS__ } \
+    }
+static const struct {
+    uint32_t va_fourcc;
+    int   nb_layer_formats;
+    uint32_t layer_formats[AV_DRM_MAX_PLANES];
+} vaapi_drm_format_map[] = {
+#ifdef DRM_FORMAT_R8
+    DRM_MAP(NV12, 2, DRM_FORMAT_R8,  DRM_FORMAT_RG88),
+#endif
+    DRM_MAP(NV12, 1, DRM_FORMAT_NV12),
+#if defined(VA_FOURCC_P010) && defined(DRM_FORMAT_R16)
+    DRM_MAP(P010, 2, DRM_FORMAT_R16, DRM_FORMAT_RG1616),
+#endif
+    DRM_MAP(BGRA, 1, DRM_FORMAT_ARGB8888),
+    DRM_MAP(BGRX, 1, DRM_FORMAT_XRGB8888),
+    DRM_MAP(RGBA, 1, DRM_FORMAT_ABGR8888),
+    DRM_MAP(RGBX, 1, DRM_FORMAT_XBGR8888),
+#ifdef VA_FOURCC_ABGR
+    DRM_MAP(ABGR, 1, DRM_FORMAT_RGBA8888),
+    DRM_MAP(XBGR, 1, DRM_FORMAT_RGBX8888),
+#endif
+    DRM_MAP(ARGB, 1, DRM_FORMAT_BGRA8888),
+    DRM_MAP(XRGB, 1, DRM_FORMAT_BGRX8888),
+};
+#undef DRM_MAP
+
+static void vaapi_unmap_from_drm(AVHWFramesContext *dst_fc,
+                                 HWMapDescriptor *hwmap)
+{
+    AVVAAPIDeviceContext *dst_dev = dst_fc->device_ctx->hwctx;
+
+    VASurfaceID surface_id = (VASurfaceID)(uintptr_t)hwmap->priv;
+
+    av_log(dst_fc, AV_LOG_DEBUG, "Destroy surface %#x.\n", surface_id);
+
+    vaDestroySurfaces(dst_dev->display, &surface_id, 1);
+}
+
+static int vaapi_map_from_drm(AVHWFramesContext *src_fc, AVFrame *dst,
+                              const AVFrame *src, int flags)
+{
+    AVHWFramesContext      *dst_fc =
+        (AVHWFramesContext*)dst->hw_frames_ctx->data;
+    AVVAAPIDeviceContext  *dst_dev = dst_fc->device_ctx->hwctx;
+    const AVDRMFrameDescriptor *desc;
+    VASurfaceID surface_id;
+    VAStatus vas;
+    uint32_t va_fourcc, va_rt_format;
+    int err, i, j, k;
+
+    unsigned long buffer_handle;
+    VASurfaceAttribExternalBuffers buffer_desc;
+    VASurfaceAttrib attrs[2] = {
+        {
+            .type  = VASurfaceAttribMemoryType,
+            .flags = VA_SURFACE_ATTRIB_SETTABLE,
+            .value.type    = VAGenericValueTypeInteger,
+            .value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME,
+        },
+        {
+            .type  = VASurfaceAttribExternalBufferDescriptor,
+            .flags = VA_SURFACE_ATTRIB_SETTABLE,
+            .value.type    = VAGenericValueTypePointer,
+            .value.value.p = &buffer_desc,
+        }
+    };
+
+    desc = (AVDRMFrameDescriptor*)src->data[0];
+
+    if (desc->nb_objects != 1) {
+        av_log(dst_fc, AV_LOG_ERROR, "VAAPI can only map frames "
+               "made from a single DRM object.\n");
+        return AVERROR(EINVAL);
+    }
+
+    va_fourcc = 0;
+    for (i = 0; i < FF_ARRAY_ELEMS(vaapi_drm_format_map); i++) {
+        if (desc->nb_layers != vaapi_drm_format_map[i].nb_layer_formats)
+            continue;
+        for (j = 0; j < desc->nb_layers; j++) {
+            if (desc->layers[j].format !=
+                vaapi_drm_format_map[i].layer_formats[j])
+                break;
+        }
+        if (j != desc->nb_layers)
+            continue;
+        va_fourcc = vaapi_drm_format_map[i].va_fourcc;
+        break;
+    }
+    if (!va_fourcc) {
+        av_log(dst_fc, AV_LOG_ERROR, "DRM format not supported "
+               "by VAAPI.\n");
+        return AVERROR(EINVAL);
+    }
+
+    av_log(dst_fc, AV_LOG_DEBUG, "Map DRM object %d to VAAPI as "
+           "%08x.\n", desc->objects[0].fd, va_fourcc);
+
+    for (i = 0; i < FF_ARRAY_ELEMS(vaapi_format_map); i++) {
+        if (vaapi_format_map[i].fourcc == va_fourcc)
+            va_rt_format = vaapi_format_map[i].rt_format;
+    }
+
+    buffer_handle = desc->objects[0].fd;
+    buffer_desc.pixel_format = va_fourcc;
+    buffer_desc.width        = src_fc->width;
+    buffer_desc.height       = src_fc->height;
+    buffer_desc.data_size    = desc->objects[0].size;
+    buffer_desc.buffers      = &buffer_handle;
+    buffer_desc.num_buffers  = 1;
+    buffer_desc.flags        = 0;
+
+    k = 0;
+    for (i = 0; i < desc->nb_layers; i++) {
+        for (j = 0; j < desc->layers[i].nb_planes; j++) {
+            buffer_desc.pitches[k] = desc->layers[i].planes[j].pitch;
+            buffer_desc.offsets[k] = desc->layers[i].planes[j].offset;
+            ++k;
+        }
+    }
+    buffer_desc.num_planes = k;
+
+    vas = vaCreateSurfaces(dst_dev->display, va_rt_format,
+                           src->width, src->height,
+                           &surface_id, 1,
+                           attrs, FF_ARRAY_ELEMS(attrs));
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(dst_fc, AV_LOG_ERROR, "Failed to create surface from DRM "
+               "object: %d (%s).\n", vas, vaErrorStr(vas));
+        return AVERROR(EIO);
+    }
+    av_log(dst_fc, AV_LOG_DEBUG, "Create surface %#x.\n", surface_id);
+
+    err = ff_hwframe_map_create(dst->hw_frames_ctx, dst, src,
+                                &vaapi_unmap_from_drm,
+                                (void*)(uintptr_t)surface_id);
+    if (err < 0)
+        return err;
+
+    dst->width   = src->width;
+    dst->height  = src->height;
+    dst->data[3] = (uint8_t*)(uintptr_t)surface_id;
+
+    av_log(dst_fc, AV_LOG_DEBUG, "Mapped DRM object %d to "
+           "surface %#x.\n", desc->objects[0].fd, surface_id);
+
+    return 0;
+}
+
+static void vaapi_unmap_to_drm(AVHWFramesContext *dst_fc,
+                               HWMapDescriptor *hwmap)
+{
+    AVDRMFrameDescriptor *drm_desc = hwmap->priv;
+    int i;
+
+    for (i = 0; i < drm_desc->nb_objects; i++)
+        close(drm_desc->objects[i].fd);
+
+    av_freep(&drm_desc);
+}
+
+static int vaapi_map_to_drm(AVHWFramesContext *hwfc, AVFrame *dst,
+                            const AVFrame *src, int flags)
+{
+    // Older versions without vaExportSurfaceHandle() are not supported -
+    // in theory this is possible with a combination of vaDeriveImage()
+    // and vaAcquireBufferHandle(), but it doesn't carry enough metadata
+    // to actually use the result in a generic way.
+    return AVERROR(ENOSYS);
+}
+#endif
+
+static int vaapi_map_to(AVHWFramesContext *hwfc, AVFrame *dst,
+                        const AVFrame *src, int flags)
+{
+    switch (src->format) {
+#if CONFIG_LIBDRM
+    case AV_PIX_FMT_DRM_PRIME:
+        return vaapi_map_from_drm(hwfc, dst, src, flags);
+#endif
+    default:
+        return AVERROR(ENOSYS);
+    }
+}
+
+static int vaapi_map_from(AVHWFramesContext *hwfc, AVFrame *dst,
+                          const AVFrame *src, int flags)
+{
+    switch (dst->format) {
+#if CONFIG_LIBDRM
+    case AV_PIX_FMT_DRM_PRIME:
+        return vaapi_map_to_drm(hwfc, dst, src, flags);
+#endif
+    default:
+        return vaapi_map_to_memory(hwfc, dst, src, flags);
+    }
+}
+
 static void vaapi_device_free(AVHWDeviceContext *ctx)
 {
     AVVAAPIDeviceContext *hwctx = ctx->hwctx;
@@ -835,14 +1129,53 @@ static void vaapi_device_free(AVHWDeviceContext *ctx)
     av_freep(&priv);
 }
 
+#if CONFIG_VAAPI_1
+static void vaapi_device_log_error(void *context, const char *message)
+{
+    AVHWDeviceContext *ctx = context;
+
+    av_log(ctx, AV_LOG_ERROR, "libva: %s", message);
+}
+
+static void vaapi_device_log_info(void *context, const char *message)
+{
+    AVHWDeviceContext *ctx = context;
+
+    av_log(ctx, AV_LOG_VERBOSE, "libva: %s", message);
+}
+#endif
+
+static int vaapi_device_connect(AVHWDeviceContext *ctx,
+                                VADisplay display)
+{
+    AVVAAPIDeviceContext *hwctx = ctx->hwctx;
+    int major, minor;
+    VAStatus vas;
+
+#if CONFIG_VAAPI_1
+    vaSetErrorCallback(display, &vaapi_device_log_error, ctx);
+    vaSetInfoCallback (display, &vaapi_device_log_info,  ctx);
+#endif
+
+    hwctx->display = display;
+
+    vas = vaInitialize(display, &major, &minor);
+    if (vas != VA_STATUS_SUCCESS) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to initialise VAAPI "
+               "connection: %d (%s).\n", vas, vaErrorStr(vas));
+        return AVERROR(EIO);
+    }
+    av_log(ctx, AV_LOG_VERBOSE, "Initialised VAAPI connection: "
+           "version %d.%d\n", major, minor);
+
+    return 0;
+}
+
 static int vaapi_device_create(AVHWDeviceContext *ctx, const char *device,
                                AVDictionary *opts, int flags)
 {
-    AVVAAPIDeviceContext *hwctx = ctx->hwctx;
     VAAPIDevicePriv *priv;
-    VADisplay display = 0;
-    VAStatus vas;
-    int major, minor;
+    VADisplay display = NULL;
 
     priv = av_mallocz(sizeof(*priv));
     if (!priv)
@@ -875,22 +1208,25 @@ static int vaapi_device_create(AVHWDeviceContext *ctx, const char *device,
 #endif
 
 #if HAVE_VAAPI_DRM
-    if (!display && device) {
+    if (!display) {
         // Try to open the device as a DRM path.
-        priv->drm_fd = open(device, O_RDWR);
+        // Default to using the first render node if the user did not
+        // supply a path.
+        const char *path = device ? device : "/dev/dri/renderD128";
+        priv->drm_fd = open(path, O_RDWR);
         if (priv->drm_fd < 0) {
             av_log(ctx, AV_LOG_VERBOSE, "Cannot open DRM device %s.\n",
-                   device);
+                   path);
         } else {
             display = vaGetDisplayDRM(priv->drm_fd);
             if (!display) {
                 av_log(ctx, AV_LOG_ERROR, "Cannot open a VA display "
-                       "from DRM device %s.\n", device);
+                       "from DRM device %s.\n", path);
                 return AVERROR_UNKNOWN;
             }
 
             av_log(ctx, AV_LOG_VERBOSE, "Opened VA display via "
-                   "DRM device %s.\n", device);
+                   "DRM device %s.\n", path);
         }
     }
 #endif
@@ -901,18 +1237,45 @@ static int vaapi_device_create(AVHWDeviceContext *ctx, const char *device,
         return AVERROR(EINVAL);
     }
 
-    hwctx->display = display;
+    return vaapi_device_connect(ctx, display);
+}
 
-    vas = vaInitialize(display, &major, &minor);
-    if (vas != VA_STATUS_SUCCESS) {
-        av_log(ctx, AV_LOG_ERROR, "Failed to initialise VAAPI "
-               "connection: %d (%s).\n", vas, vaErrorStr(vas));
-        return AVERROR(EIO);
-    }
-    av_log(ctx, AV_LOG_VERBOSE, "Initialised VAAPI connection: "
-           "version %d.%d\n", major, minor);
+static int vaapi_device_derive(AVHWDeviceContext *ctx,
+                               AVHWDeviceContext *src_ctx, int flags)
+{
+#if CONFIG_LIBDRM
+    if (src_ctx->type == AV_HWDEVICE_TYPE_DRM) {
+        AVDRMDeviceContext *src_hwctx = src_ctx->hwctx;
+        VADisplay *display;
+        VAAPIDevicePriv *priv;
+
+        if (src_hwctx->fd < 0) {
+            av_log(ctx, AV_LOG_ERROR, "DRM instance requires an associated "
+                   "device to derive a VA display from.\n");
+            return AVERROR(EINVAL);
+        }
 
-    return 0;
+        priv = av_mallocz(sizeof(*priv));
+        if (!priv)
+            return AVERROR(ENOMEM);
+
+        // Inherits the fd from the source context, which will close it.
+        priv->drm_fd = -1;
+
+        ctx->user_opaque = priv;
+        ctx->free        = &vaapi_device_free;
+
+        display = vaGetDisplayDRM(src_hwctx->fd);
+        if (!display) {
+            av_log(ctx, AV_LOG_ERROR, "Failed to open a VA display from "
+                   "DRM device.\n");
+            return AVERROR(EIO);
+        }
+
+        return vaapi_device_connect(ctx, display);
+    }
+#endif
+    return AVERROR(ENOSYS);
 }
 
 const HWContextType ff_hwcontext_type_vaapi = {
@@ -926,6 +1289,7 @@ const HWContextType ff_hwcontext_type_vaapi = {
     .frames_priv_size       = sizeof(VAAPIFramesContext),
 
     .device_create          = &vaapi_device_create,
+    .device_derive          = &vaapi_device_derive,
     .device_init            = &vaapi_device_init,
     .device_uninit          = &vaapi_device_uninit,
     .frames_get_constraints = &vaapi_frames_get_constraints,
@@ -935,6 +1299,8 @@ const HWContextType ff_hwcontext_type_vaapi = {
     .transfer_get_formats   = &vaapi_transfer_get_formats,
     .transfer_data_to       = &vaapi_transfer_data_to,
     .transfer_data_from     = &vaapi_transfer_data_from,
+    .map_to                 = &vaapi_map_to,
+    .map_from               = &vaapi_map_from,
 
     .pix_fmts = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_VAAPI,
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_vaapi.h b/mythtv/external/FFmpeg/libavutil/hwcontext_vaapi.h
index 7fd1a36e8fb..0b2e071cb33 100644
--- a/mythtv/external/FFmpeg/libavutil/hwcontext_vaapi.h
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_vaapi.h
@@ -33,6 +33,33 @@
  * with the data pointer set to a VASurfaceID.
  */
 
+enum {
+    /**
+     * The quirks field has been set by the user and should not be detected
+     * automatically by av_hwdevice_ctx_init().
+     */
+    AV_VAAPI_DRIVER_QUIRK_USER_SET = (1 << 0),
+    /**
+     * The driver does not destroy parameter buffers when they are used by
+     * vaRenderPicture().  Additional code will be required to destroy them
+     * separately afterwards.
+     */
+    AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS = (1 << 1),
+
+    /**
+     * The driver does not support the VASurfaceAttribMemoryType attribute,
+     * so the surface allocation code will not try to use it.
+     */
+    AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE = (1 << 2),
+
+    /**
+     * The driver does not support surface attributes at all.
+     * The surface allocation code will never pass them to surface allocation,
+     * and the results of the vaQuerySurfaceAttributes() call will be faked.
+     */
+    AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES = (1 << 3),
+};
+
 /**
  * VAAPI connection details.
  *
@@ -43,6 +70,14 @@ typedef struct AVVAAPIDeviceContext {
      * The VADisplay handle, to be filled by the user.
      */
     VADisplay display;
+    /**
+     * Driver quirks to apply - this is filled by av_hwdevice_ctx_init(),
+     * with reference to a table of known drivers, unless the
+     * AV_VAAPI_DRIVER_QUIRK_USER_SET bit is already present.  The user
+     * may need to refer to this field when performing any later
+     * operations using VAAPI with the same VADisplay.
+     */
+    unsigned int driver_quirks;
 } AVVAAPIDeviceContext;
 
 /**
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_vdpau.c b/mythtv/external/FFmpeg/libavutil/hwcontext_vdpau.c
index 49c44fed0d1..9b8f8396474 100644
--- a/mythtv/external/FFmpeg/libavutil/hwcontext_vdpau.c
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_vdpau.c
@@ -127,13 +127,6 @@ static int vdpau_init_pixmfts(AVHWDeviceContext *ctx)
     return 0;
 }
 
-static int vdpau_device_init(AVHWDeviceContext *ctx)
-{
-    AVVDPAUDeviceContext *hwctx = ctx->hwctx;
-    VDPAUDeviceContext   *priv  = ctx->internal->priv;
-    VdpStatus             err;
-    int                   ret;
-
 #define GET_CALLBACK(id, result)                                                \
 do {                                                                            \
     void *tmp;                                                                  \
@@ -142,15 +135,22 @@ do {
         av_log(ctx, AV_LOG_ERROR, "Error getting the " #id " callback.\n");     \
         return AVERROR_UNKNOWN;                                                 \
     }                                                                           \
-    priv->result = tmp;                                                         \
+    result = tmp;                                                               \
 } while (0)
 
+static int vdpau_device_init(AVHWDeviceContext *ctx)
+{
+    AVVDPAUDeviceContext *hwctx = ctx->hwctx;
+    VDPAUDeviceContext   *priv  = ctx->internal->priv;
+    VdpStatus             err;
+    int                   ret;
+
     GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES,
-                 get_transfer_caps);
-    GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR, get_data);
-    GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR, put_data);
-    GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_CREATE,           surf_create);
-    GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_DESTROY,          surf_destroy);
+                 priv->get_transfer_caps);
+    GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR, priv->get_data);
+    GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR, priv->put_data);
+    GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_CREATE,           priv->surf_create);
+    GET_CALLBACK(VDP_FUNC_ID_VIDEO_SURFACE_DESTROY,          priv->surf_destroy);
 
     ret = vdpau_init_pixmfts(ctx);
     if (ret < 0) {
@@ -160,7 +160,6 @@ do {
 
     return 0;
 }
-#undef GET_CALLBACK
 
 static void vdpau_device_uninit(AVHWDeviceContext *ctx)
 {
@@ -305,7 +304,7 @@ static int vdpau_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
 
     for (i = 0; i< FF_ARRAY_ELEMS(data) && dst->data[i]; i++) {
         data[i] = dst->data[i];
-        if (dst->linesize[i] < 0 || (uint64_t)dst->linesize > UINT32_MAX) {
+        if (dst->linesize[i] < 0 || dst->linesize[i] > UINT32_MAX) {
             av_log(ctx, AV_LOG_ERROR,
                    "The linesize %d cannot be represented as uint32\n",
                    dst->linesize[i]);
@@ -356,7 +355,7 @@ static int vdpau_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
 
     for (i = 0; i< FF_ARRAY_ELEMS(data) && src->data[i]; i++) {
         data[i] = src->data[i];
-        if (src->linesize[i] < 0 || (uint64_t)src->linesize > UINT32_MAX) {
+        if (src->linesize[i] < 0 || src->linesize[i] > UINT32_MAX) {
             av_log(ctx, AV_LOG_ERROR,
                    "The linesize %d cannot be represented as uint32\n",
                    src->linesize[i]);
@@ -445,17 +444,6 @@ static int vdpau_device_create(AVHWDeviceContext *ctx, const char *device,
         return AVERROR_UNKNOWN;
     }
 
-#define GET_CALLBACK(id, result)                                                \
-do {                                                                            \
-    void *tmp;                                                                  \
-    err = hwctx->get_proc_address(hwctx->device, id, &tmp);                     \
-    if (err != VDP_STATUS_OK) {                                                 \
-        av_log(ctx, AV_LOG_ERROR, "Error getting the " #id " callback.\n");     \
-        return AVERROR_UNKNOWN;                                                 \
-    }                                                                           \
-    result = tmp;                                                               \
-} while (0)
-
     GET_CALLBACK(VDP_FUNC_ID_GET_INFORMATION_STRING, get_information_string);
     GET_CALLBACK(VDP_FUNC_ID_DEVICE_DESTROY,         priv->device_destroy);
 
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_videotoolbox.c b/mythtv/external/FFmpeg/libavutil/hwcontext_videotoolbox.c
new file mode 100644
index 00000000000..cc00f1f2f23
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_videotoolbox.c
@@ -0,0 +1,243 @@
+/*
+ * 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 <stdint.h>
+#include <string.h>
+
+#include <VideoToolbox/VideoToolbox.h>
+
+#include "buffer.h"
+#include "common.h"
+#include "hwcontext.h"
+#include "hwcontext_internal.h"
+#include "hwcontext_videotoolbox.h"
+#include "mem.h"
+#include "pixfmt.h"
+#include "pixdesc.h"
+
+static const struct {
+    uint32_t cv_fmt;
+    enum AVPixelFormat pix_fmt;
+} cv_pix_fmts[] = {
+    { kCVPixelFormatType_420YpCbCr8Planar,              AV_PIX_FMT_YUV420P },
+    { kCVPixelFormatType_422YpCbCr8,                    AV_PIX_FMT_UYVY422 },
+    { kCVPixelFormatType_32BGRA,                        AV_PIX_FMT_BGRA },
+#ifdef kCFCoreFoundationVersionNumber10_7
+    { kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange,  AV_PIX_FMT_NV12 },
+#endif
+};
+
+enum AVPixelFormat av_map_videotoolbox_format_to_pixfmt(uint32_t cv_fmt)
+{
+    int i;
+    for (i = 0; i < FF_ARRAY_ELEMS(cv_pix_fmts); i++) {
+        if (cv_pix_fmts[i].cv_fmt == cv_fmt)
+            return cv_pix_fmts[i].pix_fmt;
+    }
+    return AV_PIX_FMT_NONE;
+}
+
+uint32_t av_map_videotoolbox_format_from_pixfmt(enum AVPixelFormat pix_fmt)
+{
+    int i;
+    for (i = 0; i < FF_ARRAY_ELEMS(cv_pix_fmts); i++) {
+        if (cv_pix_fmts[i].pix_fmt == pix_fmt)
+            return cv_pix_fmts[i].cv_fmt;
+    }
+    return 0;
+}
+
+static int vt_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
+{
+    frame->buf[0] = av_buffer_pool_get(ctx->pool);
+    if (!frame->buf[0])
+        return AVERROR(ENOMEM);
+
+    frame->data[3] = frame->buf[0]->data;
+    frame->format  = AV_PIX_FMT_VIDEOTOOLBOX;
+    frame->width   = ctx->width;
+    frame->height  = ctx->height;
+
+    return 0;
+}
+
+static int vt_transfer_get_formats(AVHWFramesContext *ctx,
+                                   enum AVHWFrameTransferDirection dir,
+                                   enum AVPixelFormat **formats)
+{
+    enum AVPixelFormat *fmts = av_malloc_array(2, sizeof(*fmts));
+    if (!fmts)
+        return AVERROR(ENOMEM);
+
+    fmts[0] = ctx->sw_format;
+    fmts[1] = AV_PIX_FMT_NONE;
+
+    *formats = fmts;
+    return 0;
+}
+
+static void vt_unmap(AVHWFramesContext *ctx, HWMapDescriptor *hwmap)
+{
+    CVPixelBufferRef pixbuf = (CVPixelBufferRef)hwmap->source->data[3];
+
+    CVPixelBufferUnlockBaseAddress(pixbuf, (uintptr_t)hwmap->priv);
+}
+
+static int vt_map_frame(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src,
+                        int flags)
+{
+    CVPixelBufferRef pixbuf = (CVPixelBufferRef)src->data[3];
+    OSType pixel_format = CVPixelBufferGetPixelFormatType(pixbuf);
+    CVReturn err;
+    uint32_t map_flags = 0;
+    int ret;
+    int i;
+    enum AVPixelFormat format;
+
+    format = av_map_videotoolbox_format_to_pixfmt(pixel_format);
+    if (dst->format != format) {
+        av_log(ctx, AV_LOG_ERROR, "Unsupported or mismatching pixel format: %s\n",
+               av_fourcc2str(pixel_format));
+        return AVERROR_UNKNOWN;
+    }
+
+    if (CVPixelBufferGetWidth(pixbuf) != ctx->width ||
+        CVPixelBufferGetHeight(pixbuf) != ctx->height) {
+        av_log(ctx, AV_LOG_ERROR, "Inconsistent frame dimensions.\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    if (flags == AV_HWFRAME_MAP_READ)
+        map_flags = kCVPixelBufferLock_ReadOnly;
+
+    err = CVPixelBufferLockBaseAddress(pixbuf, map_flags);
+    if (err != kCVReturnSuccess) {
+        av_log(ctx, AV_LOG_ERROR, "Error locking the pixel buffer.\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    if (CVPixelBufferIsPlanar(pixbuf)) {
+        int planes = CVPixelBufferGetPlaneCount(pixbuf);
+        for (i = 0; i < planes; i++) {
+            dst->data[i]     = CVPixelBufferGetBaseAddressOfPlane(pixbuf, i);
+            dst->linesize[i] = CVPixelBufferGetBytesPerRowOfPlane(pixbuf, i);
+        }
+    } else {
+        dst->data[0]     = CVPixelBufferGetBaseAddress(pixbuf);
+        dst->linesize[0] = CVPixelBufferGetBytesPerRow(pixbuf);
+    }
+
+    ret = ff_hwframe_map_create(src->hw_frames_ctx, dst, src, vt_unmap,
+                                (void *)(uintptr_t)map_flags);
+    if (ret < 0)
+        goto unlock;
+
+    return 0;
+
+unlock:
+    CVPixelBufferUnlockBaseAddress(pixbuf, map_flags);
+    return ret;
+}
+
+static int vt_transfer_data_from(AVHWFramesContext *hwfc,
+                                 AVFrame *dst, const AVFrame *src)
+{
+    AVFrame *map;
+    int err;
+
+    if (dst->width > hwfc->width || dst->height > hwfc->height)
+        return AVERROR(EINVAL);
+
+    map = av_frame_alloc();
+    if (!map)
+        return AVERROR(ENOMEM);
+    map->format = dst->format;
+
+    err = vt_map_frame(hwfc, map, src, AV_HWFRAME_MAP_READ);
+    if (err)
+        goto fail;
+
+    map->width  = dst->width;
+    map->height = dst->height;
+
+    err = av_frame_copy(dst, map);
+    if (err)
+        goto fail;
+
+    err = 0;
+fail:
+    av_frame_free(&map);
+    return err;
+}
+
+static int vt_transfer_data_to(AVHWFramesContext *hwfc,
+                               AVFrame *dst, const AVFrame *src)
+{
+    AVFrame *map;
+    int err;
+
+    if (src->width > hwfc->width || src->height > hwfc->height)
+        return AVERROR(EINVAL);
+
+    map = av_frame_alloc();
+    if (!map)
+        return AVERROR(ENOMEM);
+    map->format = src->format;
+
+    err = vt_map_frame(hwfc, map, dst, AV_HWFRAME_MAP_WRITE | AV_HWFRAME_MAP_OVERWRITE);
+    if (err)
+        goto fail;
+
+    map->width  = src->width;
+    map->height = src->height;
+
+    err = av_frame_copy(map, src);
+    if (err)
+        goto fail;
+
+    err = 0;
+fail:
+    av_frame_free(&map);
+    return err;
+}
+
+static int vt_device_create(AVHWDeviceContext *ctx, const char *device,
+                            AVDictionary *opts, int flags)
+{
+    if (device && device[0]) {
+        av_log(ctx, AV_LOG_ERROR, "Device selection unsupported.\n");
+        return AVERROR_UNKNOWN;
+    }
+
+    return 0;
+}
+
+const HWContextType ff_hwcontext_type_videotoolbox = {
+    .type                 = AV_HWDEVICE_TYPE_VIDEOTOOLBOX,
+    .name                 = "videotoolbox",
+
+    .device_create        = vt_device_create,
+    .frames_get_buffer    = vt_get_buffer,
+    .transfer_get_formats = vt_transfer_get_formats,
+    .transfer_data_to     = vt_transfer_data_to,
+    .transfer_data_from   = vt_transfer_data_from,
+
+    .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VIDEOTOOLBOX, AV_PIX_FMT_NONE },
+};
diff --git a/mythtv/external/FFmpeg/libavutil/hwcontext_videotoolbox.h b/mythtv/external/FFmpeg/libavutil/hwcontext_videotoolbox.h
new file mode 100644
index 00000000000..380918d92ee
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/hwcontext_videotoolbox.h
@@ -0,0 +1,54 @@
+/*
+ * 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_HWCONTEXT_VIDEOTOOLBOX_H
+#define AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H
+
+#include <stdint.h>
+
+#include <VideoToolbox/VideoToolbox.h>
+
+#include "pixfmt.h"
+
+/**
+ * @file
+ * An API-specific header for AV_HWDEVICE_TYPE_VIDEOTOOLBOX.
+ *
+ * This API currently does not support frame allocation, as the raw VideoToolbox
+ * API does allocation, and FFmpeg itself never has the need to allocate frames.
+ *
+ * If the API user sets a custom pool, AVHWFramesContext.pool must return
+ * AVBufferRefs whose data pointer is a CVImageBufferRef or CVPixelBufferRef.
+ *
+ * Currently AVHWDeviceContext.hwctx and AVHWFramesContext.hwctx are always
+ * NULL.
+ */
+
+/**
+ * Convert a VideoToolbox (actually CoreVideo) format to AVPixelFormat.
+ * Returns AV_PIX_FMT_NONE if no known equivalent was found.
+ */
+enum AVPixelFormat av_map_videotoolbox_format_to_pixfmt(uint32_t cv_fmt);
+
+/**
+ * Convert an AVPixelFormat to a VideoToolbox (actually CoreVideo) format.
+ * Returns 0 if no known equivalent was found.
+ */
+uint32_t av_map_videotoolbox_format_from_pixfmt(enum AVPixelFormat pix_fmt);
+
+#endif /* AVUTIL_HWCONTEXT_VIDEOTOOLBOX_H */
diff --git a/mythtv/external/FFmpeg/libavutil/imgutils.c b/mythtv/external/FFmpeg/libavutil/imgutils.c
index 37808e53d05..50051788041 100644
--- a/mythtv/external/FFmpeg/libavutil/imgutils.c
+++ b/mythtv/external/FFmpeg/libavutil/imgutils.c
@@ -24,6 +24,7 @@
 #include "avassert.h"
 #include "common.h"
 #include "imgutils.h"
+#include "imgutils_internal.h"
 #include "internal.h"
 #include "intreadwrite.h"
 #include "log.h"
@@ -248,19 +249,38 @@ static const AVClass imgutils_class = {
     .parent_log_context_offset = offsetof(ImgUtils, log_ctx),
 };
 
-int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
+int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
 {
     ImgUtils imgutils = {
         .class      = &imgutils_class,
         .log_offset = log_offset,
         .log_ctx    = log_ctx,
     };
+    int64_t stride = av_image_get_linesize(pix_fmt, w, 0);
+    if (stride <= 0)
+        stride = 8LL*w;
+    stride += 128*8;
 
-    if ((int)w>0 && (int)h>0 && (w+128)*(uint64_t)(h+128) < INT_MAX/8)
-        return 0;
+    if ((int)w<=0 || (int)h<=0 || stride >= INT_MAX || stride*(uint64_t)(h+128) >= INT_MAX) {
+        av_log(&imgutils, AV_LOG_ERROR, "Picture size %ux%u is invalid\n", w, h);
+        return AVERROR(EINVAL);
+    }
 
-    av_log(&imgutils, AV_LOG_ERROR, "Picture size %ux%u is invalid\n", w, h);
-    return AVERROR(EINVAL);
+    if (max_pixels < INT64_MAX) {
+        if (w*(int64_t)h > max_pixels) {
+            av_log(&imgutils, AV_LOG_ERROR,
+                    "Picture size %ux%u exceeds specified max pixel count %"PRId64", see the documentation if you wish to increase it\n",
+                    w, h, max_pixels);
+            return AVERROR(EINVAL);
+        }
+    }
+
+    return 0;
+}
+
+int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
+{
+    return av_image_check_size2(w, h, INT64_MAX, AV_PIX_FMT_NONE, log_offset, log_ctx);
 }
 
 int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
@@ -284,9 +304,9 @@ int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
     return AVERROR(EINVAL);
 }
 
-void av_image_copy_plane(uint8_t       *dst, int dst_linesize,
-                         const uint8_t *src, int src_linesize,
-                         int bytewidth, int height)
+static void image_copy_plane(uint8_t       *dst, ptrdiff_t dst_linesize,
+                             const uint8_t *src, ptrdiff_t src_linesize,
+                             ptrdiff_t bytewidth, int height)
 {
     if (!dst || !src)
         return;
@@ -299,9 +319,33 @@ void av_image_copy_plane(uint8_t       *dst, int dst_linesize,
     }
 }
 
-void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
-                   const uint8_t *src_data[4], const int src_linesizes[4],
-                   enum AVPixelFormat pix_fmt, int width, int height)
+static void image_copy_plane_uc_from(uint8_t       *dst, ptrdiff_t dst_linesize,
+                                     const uint8_t *src, ptrdiff_t src_linesize,
+                                     ptrdiff_t bytewidth, int height)
+{
+    int ret = -1;
+
+#if ARCH_X86
+    ret = ff_image_copy_plane_uc_from_x86(dst, dst_linesize, src, src_linesize,
+                                          bytewidth, height);
+#endif
+
+    if (ret < 0)
+        image_copy_plane(dst, dst_linesize, src, src_linesize, bytewidth, height);
+}
+
+void av_image_copy_plane(uint8_t       *dst, int dst_linesize,
+                         const uint8_t *src, int src_linesize,
+                         int bytewidth, int height)
+{
+    image_copy_plane(dst, dst_linesize, src, src_linesize, bytewidth, height);
+}
+
+static void image_copy(uint8_t *dst_data[4], const ptrdiff_t dst_linesizes[4],
+                       const uint8_t *src_data[4], const ptrdiff_t src_linesizes[4],
+                       enum AVPixelFormat pix_fmt, int width, int height,
+                       void (*copy_plane)(uint8_t *, ptrdiff_t, const uint8_t *,
+                                          ptrdiff_t, ptrdiff_t, int))
 {
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
 
@@ -310,9 +354,9 @@ void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
 
     if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
         desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL) {
-        av_image_copy_plane(dst_data[0], dst_linesizes[0],
-                            src_data[0], src_linesizes[0],
-                            width, height);
+        copy_plane(dst_data[0], dst_linesizes[0],
+                   src_data[0], src_linesizes[0],
+                   width, height);
         /* copy the palette */
         memcpy(dst_data[1], src_data[1], 4*256);
     } else {
@@ -323,7 +367,7 @@ void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
 
         for (i = 0; i < planes_nb; i++) {
             int h = height;
-            int bwidth = av_image_get_linesize(pix_fmt, width, i);
+            ptrdiff_t bwidth = av_image_get_linesize(pix_fmt, width, i);
             if (bwidth < 0) {
                 av_log(NULL, AV_LOG_ERROR, "av_image_get_linesize failed\n");
                 return;
@@ -331,13 +375,37 @@ void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
             if (i == 1 || i == 2) {
                 h = AV_CEIL_RSHIFT(height, desc->log2_chroma_h);
             }
-            av_image_copy_plane(dst_data[i], dst_linesizes[i],
-                                src_data[i], src_linesizes[i],
-                                bwidth, h);
+            copy_plane(dst_data[i], dst_linesizes[i],
+                       src_data[i], src_linesizes[i],
+                       bwidth, h);
         }
     }
 }
 
+void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
+                   const uint8_t *src_data[4], const int src_linesizes[4],
+                   enum AVPixelFormat pix_fmt, int width, int height)
+{
+    ptrdiff_t dst_linesizes1[4], src_linesizes1[4];
+    int i;
+
+    for (i = 0; i < 4; i++) {
+        dst_linesizes1[i] = dst_linesizes[i];
+        src_linesizes1[i] = src_linesizes[i];
+    }
+
+    image_copy(dst_data, dst_linesizes1, src_data, src_linesizes1, pix_fmt,
+               width, height, image_copy_plane);
+}
+
+void av_image_copy_uc_from(uint8_t *dst_data[4], const ptrdiff_t dst_linesizes[4],
+                           const uint8_t *src_data[4], const ptrdiff_t src_linesizes[4],
+                           enum AVPixelFormat pix_fmt, int width, int height)
+{
+    image_copy(dst_data, dst_linesizes, src_data, src_linesizes, pix_fmt,
+               width, height, image_copy_plane_uc_from);
+}
+
 int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4],
                          const uint8_t *src, enum AVPixelFormat pix_fmt,
                          int width, int height, int align)
@@ -423,3 +491,170 @@ int av_image_copy_to_buffer(uint8_t *dst, int dst_size,
 
     return size;
 }
+
+// Fill dst[0..dst_size] with the bytes in clear[0..clear_size]. The clear
+// bytes are repeated until dst_size is reached. If dst_size is unaligned (i.e.
+// dst_size%clear_size!=0), the remaining data will be filled with the beginning
+// of the clear data only.
+static void memset_bytes(uint8_t *dst, size_t dst_size, uint8_t *clear,
+                         size_t clear_size)
+{
+    size_t pos = 0;
+    int same = 1;
+    int i;
+
+    if (!clear_size)
+        return;
+
+    // Reduce to memset() if possible.
+    for (i = 0; i < clear_size; i++) {
+        if (clear[i] != clear[0]) {
+            same = 0;
+            break;
+        }
+    }
+    if (same)
+        clear_size = 1;
+
+    if (clear_size == 1) {
+        memset(dst, clear[0], dst_size);
+        dst_size = 0;
+    } else if (clear_size == 2) {
+        uint16_t val = AV_RN16(clear);
+        for (; dst_size >= 2; dst_size -= 2) {
+            AV_WN16(dst, val);
+            dst += 2;
+        }
+    } else if (clear_size == 4) {
+        uint32_t val = AV_RN32(clear);
+        for (; dst_size >= 4; dst_size -= 4) {
+            AV_WN32(dst, val);
+            dst += 4;
+        }
+    } else if (clear_size == 8) {
+        uint32_t val = AV_RN64(clear);
+        for (; dst_size >= 8; dst_size -= 8) {
+            AV_WN64(dst, val);
+            dst += 8;
+        }
+    }
+
+    for (; dst_size; dst_size--)
+        *dst++ = clear[pos++ % clear_size];
+}
+
+// Maximum size in bytes of a plane element (usually a pixel, or multiple pixels
+// if it's a subsampled packed format).
+#define MAX_BLOCK_SIZE 32
+
+int av_image_fill_black(uint8_t *dst_data[4], const ptrdiff_t dst_linesize[4],
+                        enum AVPixelFormat pix_fmt, enum AVColorRange range,
+                        int width, int height)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+    int nb_planes = av_pix_fmt_count_planes(pix_fmt);
+    // A pixel or a group of pixels on each plane, with a value that represents black.
+    // Consider e.g. AV_PIX_FMT_UYVY422 for non-trivial cases.
+    uint8_t clear_block[4][MAX_BLOCK_SIZE] = {{0}}; // clear padding with 0
+    int clear_block_size[4] = {0};
+    ptrdiff_t plane_line_bytes[4] = {0};
+    int rgb, limited;
+    int plane, c;
+
+    if (!desc || nb_planes < 1 || nb_planes > 4 || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
+        return AVERROR(EINVAL);
+
+    rgb = !!(desc->flags & AV_PIX_FMT_FLAG_RGB);
+    limited = !rgb && range != AVCOL_RANGE_JPEG;
+
+    if (desc->flags & AV_PIX_FMT_FLAG_BITSTREAM) {
+        ptrdiff_t bytewidth = av_image_get_linesize(pix_fmt, width, 0);
+        uint8_t *data;
+        int mono = pix_fmt == AV_PIX_FMT_MONOWHITE || pix_fmt == AV_PIX_FMT_MONOBLACK;
+        int fill = pix_fmt == AV_PIX_FMT_MONOWHITE ? 0xFF : 0;
+        if (nb_planes != 1 || !(rgb || mono) || bytewidth < 1)
+            return AVERROR(EINVAL);
+
+        if (!dst_data)
+            return 0;
+
+        data = dst_data[0];
+
+        // (Bitstream + alpha will be handled incorrectly - it'll remain transparent.)
+        for (;height > 0; height--) {
+            memset(data, fill, bytewidth);
+            data += dst_linesize[0];
+        }
+        return 0;
+    }
+
+    for (c = 0; c < desc->nb_components; c++) {
+        const AVComponentDescriptor comp = desc->comp[c];
+
+        // We try to operate on entire non-subsampled pixel groups (for
+        // AV_PIX_FMT_UYVY422 this would mean two consecutive pixels).
+        clear_block_size[comp.plane] = FFMAX(clear_block_size[comp.plane], comp.step);
+
+        if (clear_block_size[comp.plane] > MAX_BLOCK_SIZE)
+            return AVERROR(EINVAL);
+    }
+
+    // Create a byte array for clearing 1 pixel (sometimes several pixels).
+    for (c = 0; c < desc->nb_components; c++) {
+        const AVComponentDescriptor comp = desc->comp[c];
+        // (Multiple pixels happen e.g. with AV_PIX_FMT_UYVY422.)
+        int w = clear_block_size[comp.plane] / comp.step;
+        uint8_t *c_data[4];
+        const int c_linesize[4] = {0};
+        uint16_t src_array[MAX_BLOCK_SIZE];
+        uint16_t src = 0;
+        int x;
+
+        if (comp.depth > 16)
+            return AVERROR(EINVAL);
+        if (!rgb && comp.depth < 8)
+            return AVERROR(EINVAL);
+        if (w < 1)
+            return AVERROR(EINVAL);
+
+        if (c == 0 && limited) {
+            src = 16 << (comp.depth - 8);
+        } else if ((c == 1 || c == 2) && !rgb) {
+            src = 128 << (comp.depth - 8);
+        } else if (c == 3) {
+            // (Assume even limited YUV uses full range alpha.)
+            src = (1 << comp.depth) - 1;
+        }
+
+        for (x = 0; x < w; x++)
+            src_array[x] = src;
+
+        for (x = 0; x < 4; x++)
+            c_data[x] = &clear_block[x][0];
+
+        av_write_image_line(src_array, c_data, c_linesize, desc, 0, 0, c, w);
+    }
+
+    for (plane = 0; plane < nb_planes; plane++) {
+        plane_line_bytes[plane] = av_image_get_linesize(pix_fmt, width, plane);
+        if (plane_line_bytes[plane] < 0)
+            return AVERROR(EINVAL);
+    }
+
+    if (!dst_data)
+        return 0;
+
+    for (plane = 0; plane < nb_planes; plane++) {
+        size_t bytewidth = plane_line_bytes[plane];
+        uint8_t *data = dst_data[plane];
+        int chroma_div = plane == 1 || plane == 2 ? desc->log2_chroma_h : 0;
+        int plane_h = ((height + ( 1 << chroma_div) - 1)) >> chroma_div;
+
+        for (; plane_h > 0; plane_h--) {
+            memset_bytes(data, bytewidth, &clear_block[plane][0], clear_block_size[plane]);
+            data += dst_linesize[plane];
+        }
+    }
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/imgutils.h b/mythtv/external/FFmpeg/libavutil/imgutils.h
index 23282a38fa7..5b790ecf0ab 100644
--- a/mythtv/external/FFmpeg/libavutil/imgutils.h
+++ b/mythtv/external/FFmpeg/libavutil/imgutils.h
@@ -120,6 +120,24 @@ void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
                    const uint8_t *src_data[4], const int src_linesizes[4],
                    enum AVPixelFormat pix_fmt, int width, int height);
 
+/**
+ * Copy image data located in uncacheable (e.g. GPU mapped) memory. Where
+ * available, this function will use special functionality for reading from such
+ * memory, which may result in greatly improved performance compared to plain
+ * av_image_copy().
+ *
+ * The data pointers and the linesizes must be aligned to the maximum required
+ * by the CPU architecture.
+ *
+ * @note The linesize parameters have the type ptrdiff_t here, while they are
+ *       int for av_image_copy().
+ * @note On x86, the linesizes currently need to be aligned to the cacheline
+ *       size (i.e. 64) to get improved performance.
+ */
+void av_image_copy_uc_from(uint8_t *dst_data[4],       const ptrdiff_t dst_linesizes[4],
+                           const uint8_t *src_data[4], const ptrdiff_t src_linesizes[4],
+                           enum AVPixelFormat pix_fmt, int width, int height);
+
 /**
  * Setup the data pointers and linesizes based on the specified image
  * parameters and the provided array.
@@ -137,7 +155,7 @@ void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4],
  * one call, use av_image_alloc().
  *
  * @param dst_data      data pointers to be filled in
- * @param dst_linesizes linesizes for the image in dst_data to be filled in
+ * @param dst_linesize  linesizes for the image in dst_data to be filled in
  * @param src           buffer which will contain or contains the actual image data, can be NULL
  * @param pix_fmt       the pixel format of the image
  * @param width         the width of the image in pixels
@@ -154,7 +172,11 @@ int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4],
  * Return the size in bytes of the amount of data required to store an
  * image with the given parameters.
  *
- * @param[in] align the assumed linesize alignment
+ * @param pix_fmt  the pixel format of the image
+ * @param width    the width of the image in pixels
+ * @param height   the height of the image in pixels
+ * @param align    the assumed linesize alignment
+ * @return the buffer size in bytes, a negative error code in case of failure
  */
 int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align);
 
@@ -167,7 +189,7 @@ int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height,
  * @param dst           a buffer into which picture data will be copied
  * @param dst_size      the size in bytes of dst
  * @param src_data      pointers containing the source image data
- * @param src_linesizes linesizes for the image in src_data
+ * @param src_linesize  linesizes for the image in src_data
  * @param pix_fmt       the pixel format of the source image
  * @param width         the width of the source image in pixels
  * @param height        the height of the source image in pixels
@@ -191,6 +213,21 @@ int av_image_copy_to_buffer(uint8_t *dst, int dst_size,
  */
 int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx);
 
+/**
+ * Check if the given dimension of an image is valid, meaning that all
+ * bytes of a plane of an image with the specified pix_fmt can be addressed
+ * with a signed int.
+ *
+ * @param w the width of the picture
+ * @param h the height of the picture
+ * @param max_pixels the maximum number of pixels the user wants to accept
+ * @param pix_fmt the pixel format, can be AV_PIX_FMT_NONE if unknown.
+ * @param log_offset the offset to sum to the log level for logging with log_ctx
+ * @param log_ctx the parent logging context, it may be NULL
+ * @return >= 0 if valid, a negative error code otherwise
+ */
+int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx);
+
 /**
  * Check if the given sample aspect ratio of an image is valid.
  *
@@ -205,6 +242,33 @@ int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *lo
  */
 int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar);
 
+/**
+ * Overwrite the image data with black. This is suitable for filling a
+ * sub-rectangle of an image, meaning the padding between the right most pixel
+ * and the left most pixel on the next line will not be overwritten. For some
+ * formats, the image size might be rounded up due to inherent alignment.
+ *
+ * If the pixel format has alpha, the alpha is cleared to opaque.
+ *
+ * This can return an error if the pixel format is not supported. Normally, all
+ * non-hwaccel pixel formats should be supported.
+ *
+ * Passing NULL for dst_data is allowed. Then the function returns whether the
+ * operation would have succeeded. (It can return an error if the pix_fmt is
+ * not supported.)
+ *
+ * @param dst_data      data pointers to destination image
+ * @param dst_linesize  linesizes for the destination image
+ * @param pix_fmt       the pixel format of the image
+ * @param range         the color range of the image (important for colorspaces such as YUV)
+ * @param width         the width of the image in pixels
+ * @param height        the height of the image in pixels
+ * @return 0 if the image data was cleared, a negative AVERROR code otherwise
+ */
+int av_image_fill_black(uint8_t *dst_data[4], const ptrdiff_t dst_linesize[4],
+                        enum AVPixelFormat pix_fmt, enum AVColorRange range,
+                        int width, int height);
+
 /**
  * @}
  */
diff --git a/mythtv/external/FFmpeg/libavutil/imgutils_internal.h b/mythtv/external/FFmpeg/libavutil/imgutils_internal.h
new file mode 100644
index 00000000000..d5158584133
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/imgutils_internal.h
@@ -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_IMGUTILS_INTERNAL_H
+#define AVUTIL_IMGUTILS_INTERNAL_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+int ff_image_copy_plane_uc_from_x86(uint8_t       *dst, ptrdiff_t dst_linesize,
+                                    const uint8_t *src, ptrdiff_t src_linesize,
+                                    ptrdiff_t bytewidth, int height);
+
+
+#endif /* AVUTIL_IMGUTILS_INTERNAL_H */
diff --git a/mythtv/external/FFmpeg/libavutil/internal.h b/mythtv/external/FFmpeg/libavutil/internal.h
index e995af97e47..a2d73e3cc6c 100644
--- a/mythtv/external/FFmpeg/libavutil/internal.h
+++ b/mythtv/external/FFmpeg/libavutil/internal.h
@@ -30,6 +30,9 @@
 #    define NDEBUG
 #endif
 
+// This can be enabled to allow detection of additional integer overflows with ubsan
+//#define CHECKED
+
 #include <limits.h>
 #include <stdint.h>
 #include <stddef.h>
@@ -258,6 +261,16 @@ void avpriv_request_sample(void *avc,
 #   define ff_dlog(ctx, ...) do { if (0) av_log(ctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0)
 #endif
 
+// For debuging we use signed operations so overflows can be detected (by ubsan)
+// For production we use unsigned so there are no undefined operations
+#ifdef CHECKED
+#define SUINT   int
+#define SUINT32 int32_t
+#else
+#define SUINT   unsigned
+#define SUINT32 uint32_t
+#endif
+
 /**
  * Clip and convert a double value into the long long amin-amax range.
  * This function is needed because conversion of floating point to integers when
@@ -340,6 +353,4 @@ void ff_check_pixfmt_descriptors(void);
  */
 int avpriv_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp);
 
-extern const uint8_t ff_reverse[256];
-
 #endif /* AVUTIL_INTERNAL_H */
diff --git a/mythtv/external/FFmpeg/libavutil/intreadwrite.h b/mythtv/external/FFmpeg/libavutil/intreadwrite.h
index 51fbe30a23a..d54d4b91d6c 100644
--- a/mythtv/external/FFmpeg/libavutil/intreadwrite.h
+++ b/mythtv/external/FFmpeg/libavutil/intreadwrite.h
@@ -229,6 +229,11 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
 #   define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))
 #   define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v))
 
+#elif defined(_MSC_VER) && (defined(_M_ARM) || defined(_M_X64)) && AV_HAVE_FAST_UNALIGNED
+
+#   define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p)))
+#   define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v))
+
 #elif AV_HAVE_FAST_UNALIGNED
 
 #   define AV_RN(s, p) (((const av_alias##s*)(p))->u##s)
@@ -242,8 +247,8 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
       ((const uint8_t*)(x))[1])
 #endif
 #ifndef AV_WB16
-#   define AV_WB16(p, darg) do {                \
-        unsigned d = (darg);                    \
+#   define AV_WB16(p, val) do {                 \
+        uint16_t d = (val);                     \
         ((uint8_t*)(p))[1] = (d);               \
         ((uint8_t*)(p))[0] = (d)>>8;            \
     } while(0)
@@ -255,8 +260,8 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
       ((const uint8_t*)(x))[0])
 #endif
 #ifndef AV_WL16
-#   define AV_WL16(p, darg) do {                \
-        unsigned d = (darg);                    \
+#   define AV_WL16(p, val) do {                 \
+        uint16_t d = (val);                     \
         ((uint8_t*)(p))[0] = (d);               \
         ((uint8_t*)(p))[1] = (d)>>8;            \
     } while(0)
@@ -270,8 +275,8 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
                 ((const uint8_t*)(x))[3])
 #endif
 #ifndef AV_WB32
-#   define AV_WB32(p, darg) do {                \
-        unsigned d = (darg);                    \
+#   define AV_WB32(p, val) do {                 \
+        uint32_t d = (val);                     \
         ((uint8_t*)(p))[3] = (d);               \
         ((uint8_t*)(p))[2] = (d)>>8;            \
         ((uint8_t*)(p))[1] = (d)>>16;           \
@@ -287,8 +292,8 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
                 ((const uint8_t*)(x))[0])
 #endif
 #ifndef AV_WL32
-#   define AV_WL32(p, darg) do {                \
-        unsigned d = (darg);                    \
+#   define AV_WL32(p, val) do {                 \
+        uint32_t d = (val);                     \
         ((uint8_t*)(p))[0] = (d);               \
         ((uint8_t*)(p))[1] = (d)>>8;            \
         ((uint8_t*)(p))[2] = (d)>>16;           \
@@ -308,8 +313,8 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
       (uint64_t)((const uint8_t*)(x))[7])
 #endif
 #ifndef AV_WB64
-#   define AV_WB64(p, darg) do {                \
-        uint64_t d = (darg);                    \
+#   define AV_WB64(p, val) do {                 \
+        uint64_t d = (val);                     \
         ((uint8_t*)(p))[7] = (d);               \
         ((uint8_t*)(p))[6] = (d)>>8;            \
         ((uint8_t*)(p))[5] = (d)>>16;           \
@@ -333,8 +338,8 @@ union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias;
       (uint64_t)((const uint8_t*)(x))[0])
 #endif
 #ifndef AV_WL64
-#   define AV_WL64(p, darg) do {                \
-        uint64_t d = (darg);                    \
+#   define AV_WL64(p, val) do {                 \
+        uint64_t d = (val);                     \
         ((uint8_t*)(p))[0] = (d);               \
         ((uint8_t*)(p))[1] = (d)>>8;            \
         ((uint8_t*)(p))[2] = (d)>>16;           \
diff --git a/mythtv/external/FFmpeg/libavutil/lfg.c b/mythtv/external/FFmpeg/libavutil/lfg.c
index 08a4f678e2e..46b04d24039 100644
--- a/mythtv/external/FFmpeg/libavutil/lfg.c
+++ b/mythtv/external/FFmpeg/libavutil/lfg.c
@@ -23,7 +23,9 @@
 #include <limits.h>
 #include <math.h>
 #include "lfg.h"
+#include "crc.h"
 #include "md5.h"
+#include "error.h"
 #include "intreadwrite.h"
 #include "attributes.h"
 
@@ -58,3 +60,28 @@ void av_bmg_get(AVLFG *lfg, double out[2])
     out[0] = x1 * w;
     out[1] = x2 * w;
 }
+
+int av_lfg_init_from_data(AVLFG *c, const uint8_t *data, unsigned int length) {
+    unsigned int beg, end, segm;
+    const AVCRC *avcrc;
+    uint32_t crc = 1;
+
+    /* avoid integer overflow in the loop below. */
+    if (length > (UINT_MAX / 128U)) return AVERROR(EINVAL);
+
+    c->index = 0;
+    avcrc = av_crc_get_table(AV_CRC_32_IEEE); /* This can't fail. It's a well-defined table in crc.c */
+
+    /* across 64 segments of the incoming data,
+     * do a running crc of each segment and store the crc as the state for that slot.
+     * this works even if the length of the segment is 0 bytes. */
+    beg = 0;
+    for (segm = 0;segm < 64;segm++) {
+        end = (((segm + 1) * length) / 64);
+        crc = av_crc(avcrc, crc, data + beg, end - beg);
+        c->state[segm] = (unsigned int)crc;
+        beg = end;
+    }
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/lfg.h b/mythtv/external/FFmpeg/libavutil/lfg.h
index ec90562cf24..03f779ad8a4 100644
--- a/mythtv/external/FFmpeg/libavutil/lfg.h
+++ b/mythtv/external/FFmpeg/libavutil/lfg.h
@@ -22,6 +22,8 @@
 #ifndef AVUTIL_LFG_H
 #define AVUTIL_LFG_H
 
+#include <stdint.h>
+
 typedef struct AVLFG {
     unsigned int state[64];
     int index;
@@ -29,6 +31,13 @@ typedef struct AVLFG {
 
 void av_lfg_init(AVLFG *c, unsigned int seed);
 
+/**
+ * Seed the state of the ALFG using binary data.
+ *
+ * Return value: 0 on success, negative value (AVERROR) on failure.
+ */
+int av_lfg_init_from_data(AVLFG *c, const uint8_t *data, unsigned int length);
+
 /**
  * Get the next random unsigned 32-bit number using an ALFG.
  *
diff --git a/mythtv/external/FFmpeg/libavutil/log.c b/mythtv/external/FFmpeg/libavutil/log.c
index 44c11cb0917..be806202ffb 100644
--- a/mythtv/external/FFmpeg/libavutil/log.c
+++ b/mythtv/external/FFmpeg/libavutil/log.c
@@ -168,19 +168,19 @@ static void colored_fputs(int level, int tint, const char *str)
 #else
     if (local_use_color == 1) {
         fprintf(stderr,
-                "\033[%d;3%dm%s\033[0m",
+                "\033[%"PRIu32";3%"PRIu32"m%s\033[0m",
                 (color[level] >> 4) & 15,
                 color[level] & 15,
                 str);
     } else if (tint && use_color == 256) {
         fprintf(stderr,
-                "\033[48;5;%dm\033[38;5;%dm%s\033[0m",
+                "\033[48;5;%"PRIu32"m\033[38;5;%dm%s\033[0m",
                 (color[level] >> 16) & 0xff,
                 tint,
                 str);
     } else if (local_use_color == 256) {
         fprintf(stderr,
-                "\033[48;5;%dm\033[38;5;%dm%s\033[0m",
+                "\033[48;5;%"PRIu32"m\033[38;5;%"PRIu32"m%s\033[0m",
                 (color[level] >> 16) & 0xff,
                 (color[level] >> 8) & 0xff,
                 str);
diff --git a/mythtv/external/FFmpeg/libavutil/mastering_display_metadata.c b/mythtv/external/FFmpeg/libavutil/mastering_display_metadata.c
index e1683e55c71..60693476177 100644
--- a/mythtv/external/FFmpeg/libavutil/mastering_display_metadata.c
+++ b/mythtv/external/FFmpeg/libavutil/mastering_display_metadata.c
@@ -41,3 +41,26 @@ AVMasteringDisplayMetadata *av_mastering_display_metadata_create_side_data(AVFra
 
     return (AVMasteringDisplayMetadata *)side_data->data;
 }
+
+AVContentLightMetadata *av_content_light_metadata_alloc(size_t *size)
+{
+    AVContentLightMetadata *metadata = av_mallocz(sizeof(AVContentLightMetadata));
+
+    if (size)
+        *size = sizeof(*metadata);
+
+    return metadata;
+}
+
+AVContentLightMetadata *av_content_light_metadata_create_side_data(AVFrame *frame)
+{
+    AVFrameSideData *side_data = av_frame_new_side_data(frame,
+                                                        AV_FRAME_DATA_CONTENT_LIGHT_LEVEL,
+                                                        sizeof(AVContentLightMetadata));
+    if (!side_data)
+        return NULL;
+
+    memset(side_data->data, 0, sizeof(AVContentLightMetadata));
+
+    return (AVContentLightMetadata *)side_data->data;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/mastering_display_metadata.h b/mythtv/external/FFmpeg/libavutil/mastering_display_metadata.h
index 936533fec40..847b0b62c6c 100644
--- a/mythtv/external/FFmpeg/libavutil/mastering_display_metadata.h
+++ b/mythtv/external/FFmpeg/libavutil/mastering_display_metadata.h
@@ -86,4 +86,43 @@ AVMasteringDisplayMetadata *av_mastering_display_metadata_alloc(void);
  */
 AVMasteringDisplayMetadata *av_mastering_display_metadata_create_side_data(AVFrame *frame);
 
+/**
+ * Content light level needed by to transmit HDR over HDMI (CTA-861.3).
+ *
+ * To be used as payload of a AVFrameSideData or AVPacketSideData with the
+ * appropriate type.
+ *
+ * @note The struct should be allocated with av_content_light_metadata_alloc()
+ *       and its size is not a part of the public ABI.
+ */
+typedef struct AVContentLightMetadata {
+    /**
+     * Max content light level (cd/m^2).
+     */
+    unsigned MaxCLL;
+
+    /**
+     * Max average light level per frame (cd/m^2).
+     */
+    unsigned MaxFALL;
+} AVContentLightMetadata;
+
+/**
+ * Allocate an AVContentLightMetadata structure and set its fields to
+ * default values. The resulting struct can be freed using av_freep().
+ *
+ * @return An AVContentLightMetadata filled with default values or NULL
+ *         on failure.
+ */
+AVContentLightMetadata *av_content_light_metadata_alloc(size_t *size);
+
+/**
+ * Allocate a complete AVContentLightMetadata and add it to the frame.
+ *
+ * @param frame The frame which side data is added to.
+ *
+ * @return The AVContentLightMetadata structure to be filled by caller.
+ */
+AVContentLightMetadata *av_content_light_metadata_create_side_data(AVFrame *frame);
+
 #endif /* AVUTIL_MASTERING_DISPLAY_METADATA_H */
diff --git a/mythtv/external/FFmpeg/libavutil/mathematics.c b/mythtv/external/FFmpeg/libavutil/mathematics.c
index 20ff37f5e9d..1bf044cdf11 100644
--- a/mythtv/external/FFmpeg/libavutil/mathematics.c
+++ b/mythtv/external/FFmpeg/libavutil/mathematics.c
@@ -115,15 +115,15 @@ int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
         if (t1 > INT64_MAX)
             return INT64_MIN;
         return t1;
-    }
 #else
+        /* reference code doing (a*b + r) / c, requires libavutil/integer.h */
         AVInteger ai;
         ai = av_mul_i(av_int2i(a), av_int2i(b));
         ai = av_add_i(ai, av_int2i(r));
 
         return av_i2int(av_div_i(ai, av_int2i(c)));
-    }
 #endif
+    }
 }
 
 int64_t av_rescale(int64_t a, int64_t b, int64_t c)
diff --git a/mythtv/external/FFmpeg/libavutil/md5.c b/mythtv/external/FFmpeg/libavutil/md5.c
index 8c36aa80c44..31e69925aed 100644
--- a/mythtv/external/FFmpeg/libavutil/md5.c
+++ b/mythtv/external/FFmpeg/libavutil/md5.c
@@ -86,23 +86,24 @@ static const uint32_t T[64] = { // T[i]= fabs(sin(i+1)<<32)
                                                                         \
         if (i < 32) {                                                   \
             if (i < 16)                                                 \
-                a += (d ^ (b & (c ^ d)))  + X[       i  & 15];          \
+                a += (d ^ (b & (c ^ d)))  + AV_RL32(X+(       i  & 15));\
             else                                                        \
-                a += ((d & b) | (~d & c)) + X[(1 + 5*i) & 15];          \
+                a += ((d & b) | (~d & c)) + AV_RL32(X+((1 + 5*i) & 15));\
         } else {                                                        \
             if (i < 48)                                                 \
-                a += (b ^ c ^ d)          + X[(5 + 3*i) & 15];          \
+                a += (b ^ c ^ d)          + AV_RL32(X+((5 + 3*i) & 15));\
             else                                                        \
-                a += (c ^ (b | ~d))       + X[(    7*i) & 15];          \
+                a += (c ^ (b | ~d))       + AV_RL32(X+((    7*i) & 15));\
         }                                                               \
         a = b + (a << t | a >> (32 - t));                               \
     } while (0)
 
-static void body(uint32_t ABCD[4], uint32_t *src, int nblocks)
+static void body(uint32_t ABCD[4], const uint8_t *src, int nblocks)
 {
     int i av_unused;
     int n;
-    uint32_t a, b, c, d, t, *X;
+    const uint32_t *X;
+    uint32_t a, b, c, d, t;
 
     for (n = 0; n < nblocks; n++) {
         a = ABCD[3];
@@ -110,12 +111,7 @@ static void body(uint32_t ABCD[4], uint32_t *src, int nblocks)
         c = ABCD[1];
         d = ABCD[0];
 
-        X = src + n * 16;
-
-#if HAVE_BIGENDIAN
-        for (i = 0; i < 16; i++)
-            X[i] = av_bswap32(X[i]);
-#endif
+        X = (const uint32_t *)src + n * 16;
 
 #if CONFIG_SMALL
         for (i = 0; i < 64; i++) {
@@ -154,7 +150,11 @@ void av_md5_init(AVMD5 *ctx)
     ctx->ABCD[3] = 0x67452301;
 }
 
+#if FF_API_CRYPTO_SIZE_T
 void av_md5_update(AVMD5 *ctx, const uint8_t *src, int len)
+#else
+void av_md5_update(AVMD5 *ctx, const uint8_t *src, size_t len)
+#endif
 {
     const uint8_t *end;
     int j;
@@ -169,19 +169,19 @@ void av_md5_update(AVMD5 *ctx, const uint8_t *src, int len)
         len -= cnt;
         if (j + cnt < 64)
             return;
-        body(ctx->ABCD, (uint32_t *)ctx->block, 1);
+        body(ctx->ABCD, ctx->block, 1);
     }
 
     end = src + (len & ~63);
-    if (HAVE_BIGENDIAN || (!HAVE_FAST_UNALIGNED && ((intptr_t)src & 3))) {
+    if (!HAVE_FAST_UNALIGNED && ((intptr_t)src & 3)) {
        while (src < end) {
            memcpy(ctx->block, src, 64);
-           body(ctx->ABCD, (uint32_t *) ctx->block, 1);
+           body(ctx->ABCD, ctx->block, 1);
            src += 64;
         }
     } else {
         int nblocks = len / 64;
-        body(ctx->ABCD, (uint32_t *)src, nblocks);
+        body(ctx->ABCD, src, nblocks);
         src = end;
     }
     len &= 63;
@@ -204,7 +204,11 @@ void av_md5_final(AVMD5 *ctx, uint8_t *dst)
         AV_WL32(dst + 4 * i, ctx->ABCD[3 - i]);
 }
 
+#if FF_API_CRYPTO_SIZE_T
 void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len)
+#else
+void av_md5_sum(uint8_t *dst, const uint8_t *src, size_t len)
+#endif
 {
     AVMD5 ctx;
 
diff --git a/mythtv/external/FFmpeg/libavutil/md5.h b/mythtv/external/FFmpeg/libavutil/md5.h
index 9571c1fa467..ca72ccbf837 100644
--- a/mythtv/external/FFmpeg/libavutil/md5.h
+++ b/mythtv/external/FFmpeg/libavutil/md5.h
@@ -27,6 +27,7 @@
 #ifndef AVUTIL_MD5_H
 #define AVUTIL_MD5_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "attributes.h"
@@ -63,7 +64,11 @@ void av_md5_init(struct AVMD5 *ctx);
  * @param src input data to update hash with
  * @param len input data length
  */
+#if FF_API_CRYPTO_SIZE_T
 void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, int len);
+#else
+void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, size_t len);
+#endif
 
 /**
  * Finish hashing and output digest value.
@@ -80,7 +85,11 @@ void av_md5_final(struct AVMD5 *ctx, uint8_t *dst);
  * @param src The data to hash
  * @param len The length of the data, in bytes
  */
+#if FF_API_CRYPTO_SIZE_T
 void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len);
+#else
+void av_md5_sum(uint8_t *dst, const uint8_t *src, size_t len);
+#endif
 
 /**
  * @}
diff --git a/mythtv/external/FFmpeg/libavutil/mem.c b/mythtv/external/FFmpeg/libavutil/mem.c
index 1a8fc21e98f..36740f1154b 100644
--- a/mythtv/external/FFmpeg/libavutil/mem.c
+++ b/mythtv/external/FFmpeg/libavutil/mem.c
@@ -77,22 +77,12 @@ void av_max_alloc(size_t max){
 void *av_malloc(size_t size)
 {
     void *ptr = NULL;
-#if CONFIG_MEMALIGN_HACK
-    long diff;
-#endif
 
     /* let's disallow possibly ambiguous cases */
     if (size > (max_alloc_size - 32))
         return NULL;
 
-#if CONFIG_MEMALIGN_HACK
-    ptr = malloc(size + ALIGN);
-    if (!ptr)
-        return ptr;
-    diff              = ((~(long)ptr)&(ALIGN - 1)) + 1;
-    ptr               = (char *)ptr + diff;
-    ((char *)ptr)[-1] = diff;
-#elif HAVE_POSIX_MEMALIGN
+#if HAVE_POSIX_MEMALIGN
     if (size) //OS X on SDK 10.6 has a broken posix_memalign implementation
     if (posix_memalign(&ptr, ALIGN, size))
         ptr = NULL;
@@ -144,25 +134,11 @@ void *av_malloc(size_t size)
 
 void *av_realloc(void *ptr, size_t size)
 {
-#if CONFIG_MEMALIGN_HACK
-    int diff;
-#endif
-
     /* let's disallow possibly ambiguous cases */
     if (size > (max_alloc_size - 32))
         return NULL;
 
-#if CONFIG_MEMALIGN_HACK
-    //FIXME this isn't aligned correctly, though it probably isn't needed
-    if (!ptr)
-        return av_malloc(size);
-    diff = ((char *)ptr)[-1];
-    av_assert0(diff>0 && diff<=ALIGN);
-    ptr = realloc((char *)ptr - diff, size + diff);
-    if (ptr)
-        ptr = (char *)ptr + diff;
-    return ptr;
-#elif HAVE_ALIGNED_MALLOC
+#if HAVE_ALIGNED_MALLOC
     return _aligned_realloc(ptr, size + !size, ALIGN);
 #else
     return realloc(ptr, size + !size);
@@ -227,13 +203,7 @@ int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
 
 void av_free(void *ptr)
 {
-#if CONFIG_MEMALIGN_HACK
-    if (ptr) {
-        int v= ((char *)ptr)[-1];
-        av_assert0(v>0 && v<=ALIGN);
-        free((char *)ptr - v);
-    }
-#elif HAVE_ALIGNED_MALLOC
+#if HAVE_ALIGNED_MALLOC
     _aligned_free(ptr);
 #else
     free(ptr);
diff --git a/mythtv/external/FFmpeg/libavutil/mem.h b/mythtv/external/FFmpeg/libavutil/mem.h
index f9d88847881..527cd03191a 100644
--- a/mythtv/external/FFmpeg/libavutil/mem.h
+++ b/mythtv/external/FFmpeg/libavutil/mem.h
@@ -97,7 +97,10 @@
     #define DECLARE_ASM_CONST(n,t,v)                    \
         AV_PRAGMA(DATA_ALIGN(v,n))                      \
         static const t __attribute__((aligned(n))) v
-#elif defined(__GNUC__)
+#elif defined(__DJGPP__)
+    #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (FFMIN(n, 16)))) v
+    #define DECLARE_ASM_CONST(n,t,v)    static const t av_used __attribute__ ((aligned (FFMIN(n, 16)))) v
+#elif defined(__GNUC__) || defined(__clang__)
     #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v
     #define DECLARE_ASM_CONST(n,t,v)    static const t av_used __attribute__ ((aligned (n))) v
 #elif defined(_MSC_VER)
diff --git a/mythtv/external/FFmpeg/libavutil/mips/generic_macros_msa.h b/mythtv/external/FFmpeg/libavutil/mips/generic_macros_msa.h
index 0a59619e7b4..c892529f05a 100644
--- a/mythtv/external/FFmpeg/libavutil/mips/generic_macros_msa.h
+++ b/mythtv/external/FFmpeg/libavutil/mips/generic_macros_msa.h
@@ -27,202 +27,163 @@
 #define ALIGNMENT           16
 #define ALLOC_ALIGNED(align) __attribute__ ((aligned((align) << 1)))
 
-#define LD_B(RTYPE, psrc) *((RTYPE *)(psrc))
-#define LD_UB(...) LD_B(v16u8, __VA_ARGS__)
-#define LD_SB(...) LD_B(v16i8, __VA_ARGS__)
-
-#define LD_H(RTYPE, psrc) *((RTYPE *)(psrc))
-#define LD_UH(...) LD_H(v8u16, __VA_ARGS__)
-#define LD_SH(...) LD_H(v8i16, __VA_ARGS__)
-
-#define LD_W(RTYPE, psrc) *((RTYPE *)(psrc))
-#define LD_UW(...) LD_W(v4u32, __VA_ARGS__)
-#define LD_SW(...) LD_W(v4i32, __VA_ARGS__)
-
-#define ST_B(RTYPE, in, pdst) *((RTYPE *)(pdst)) = (in)
-#define ST_UB(...) ST_B(v16u8, __VA_ARGS__)
-#define ST_SB(...) ST_B(v16i8, __VA_ARGS__)
-
-#define ST_H(RTYPE, in, pdst) *((RTYPE *)(pdst)) = (in)
-#define ST_UH(...) ST_H(v8u16, __VA_ARGS__)
-#define ST_SH(...) ST_H(v8i16, __VA_ARGS__)
-
-#define ST_W(RTYPE, in, pdst) *((RTYPE *)(pdst)) = (in)
-#define ST_UW(...) ST_W(v4u32, __VA_ARGS__)
-#define ST_SW(...) ST_W(v4i32, __VA_ARGS__)
+#define LD_V(RTYPE, psrc) *((RTYPE *)(psrc))
+#define LD_UB(...) LD_V(v16u8, __VA_ARGS__)
+#define LD_SB(...) LD_V(v16i8, __VA_ARGS__)
+#define LD_UH(...) LD_V(v8u16, __VA_ARGS__)
+#define LD_SH(...) LD_V(v8i16, __VA_ARGS__)
+#define LD_UW(...) LD_V(v4u32, __VA_ARGS__)
+#define LD_SW(...) LD_V(v4i32, __VA_ARGS__)
+
+#define ST_V(RTYPE, in, pdst) *((RTYPE *)(pdst)) = (in)
+#define ST_UB(...) ST_V(v16u8, __VA_ARGS__)
+#define ST_SB(...) ST_V(v16i8, __VA_ARGS__)
+#define ST_UH(...) ST_V(v8u16, __VA_ARGS__)
+#define ST_SH(...) ST_V(v8i16, __VA_ARGS__)
+#define ST_UW(...) ST_V(v4u32, __VA_ARGS__)
+#define ST_SW(...) ST_V(v4i32, __VA_ARGS__)
 
 #if (__mips_isa_rev >= 6)
-    #define LW(psrc)                           \
-    ( {                                        \
-        uint8_t *psrc_m = (uint8_t *) (psrc);  \
-        uint32_t val_m;                        \
-                                               \
-        __asm__ volatile (                     \
-            "lw  %[val_m],  %[psrc_m]  \n\t"   \
-                                               \
-            : [val_m] "=r" (val_m)             \
-            : [psrc_m] "m" (*psrc_m)           \
-        );                                     \
-                                               \
-        val_m;                                 \
+    #define LH(psrc)                              \
+    ( {                                           \
+        uint16_t val_lh_m = *(uint16_t *)(psrc);  \
+        val_lh_m;                                 \
+    } )
+
+    #define LW(psrc)                              \
+    ( {                                           \
+        uint32_t val_lw_m = *(uint32_t *)(psrc);  \
+        val_lw_m;                                 \
     } )
 
     #if (__mips == 64)
-        #define LD(psrc)                           \
-        ( {                                        \
-            uint8_t *psrc_m = (uint8_t *) (psrc);  \
-            uint64_t val_m = 0;                    \
-                                                   \
-            __asm__ volatile (                     \
-                "ld  %[val_m],  %[psrc_m]  \n\t"   \
-                                                   \
-                : [val_m] "=r" (val_m)             \
-                : [psrc_m] "m" (*psrc_m)           \
-            );                                     \
-                                                   \
-            val_m;                                 \
+        #define LD(psrc)                               \
+        ( {                                            \
+            uint64_t val_ld_m =  *(uint64_t *)(psrc);  \
+            val_ld_m;                                  \
         } )
     #else  // !(__mips == 64)
-        #define LD(psrc)                                              \
-        ( {                                                           \
-            uint8_t *psrc_ld_m = (uint8_t *) (psrc);                  \
-            uint32_t val0_m, val1_m;                                  \
-            uint64_t val_m = 0;                                       \
-                                                                      \
-            val0_m = LW(psrc_ld_m);                                   \
-            val1_m = LW(psrc_ld_m + 4);                               \
-                                                                      \
-            val_m = (uint64_t) (val1_m);                              \
-            val_m = (uint64_t) ((val_m << 32) & 0xFFFFFFFF00000000);  \
-            val_m = (uint64_t) (val_m | (uint64_t) val0_m);           \
-                                                                      \
-            val_m;                                                    \
+        #define LD(psrc)                                                    \
+        ( {                                                                 \
+            uint8_t *psrc_ld_m = (uint8_t *) (psrc);                        \
+            uint32_t val0_ld_m, val1_ld_m;                                  \
+            uint64_t val_ld_m = 0;                                          \
+                                                                            \
+            val0_ld_m = LW(psrc_ld_m);                                      \
+            val1_ld_m = LW(psrc_ld_m + 4);                                  \
+                                                                            \
+            val_ld_m = (uint64_t) (val1_ld_m);                              \
+            val_ld_m = (uint64_t) ((val_ld_m << 32) & 0xFFFFFFFF00000000);  \
+            val_ld_m = (uint64_t) (val_ld_m | (uint64_t) val0_ld_m);        \
+                                                                            \
+            val_ld_m;                                                       \
         } )
     #endif  // (__mips == 64)
 
-    #define SH(val, pdst)                      \
-    {                                          \
-        uint8_t *pdst_m = (uint8_t *) (pdst);  \
-        uint16_t val_m = (val);                \
-                                               \
-        __asm__ volatile (                     \
-            "sh  %[val_m],  %[pdst_m]  \n\t"   \
-                                               \
-            : [pdst_m] "=m" (*pdst_m)          \
-            : [val_m] "r" (val_m)              \
-        );                                     \
-    }
-
-    #define SW(val, pdst)                      \
-    {                                          \
-        uint8_t *pdst_m = (uint8_t *) (pdst);  \
-        uint32_t val_m = (val);                \
-                                               \
-        __asm__ volatile (                     \
-            "sw  %[val_m],  %[pdst_m]  \n\t"   \
-                                               \
-            : [pdst_m] "=m" (*pdst_m)          \
-            : [val_m] "r" (val_m)              \
-        );                                     \
-    }
+    #define SH(val, pdst)  *(uint16_t *)(pdst) = (val);
+    #define SW(val, pdst)  *(uint32_t *)(pdst) = (val);
+    #define SD(val, pdst)  *(uint64_t *)(pdst) = (val);
 
-    #define SD(val, pdst)                      \
-    {                                          \
-        uint8_t *pdst_m = (uint8_t *) (pdst);  \
-        uint64_t val_m = (val);                \
-                                               \
-        __asm__ volatile (                     \
-            "sd  %[val_m],  %[pdst_m]  \n\t"   \
-                                               \
-            : [pdst_m] "=m" (*pdst_m)          \
-            : [val_m] "r" (val_m)              \
-        );                                     \
-    }
 #else  // !(__mips_isa_rev >= 6)
-    #define LW(psrc)                           \
-    ( {                                        \
-        uint8_t *psrc_m = (uint8_t *) (psrc);  \
-        uint32_t val_m;                        \
-                                               \
-        __asm__ volatile (                     \
-            "ulw  %[val_m],  %[psrc_m]  \n\t"  \
-                                               \
-            : [val_m] "=r" (val_m)             \
-            : [psrc_m] "m" (*psrc_m)           \
-        );                                     \
-                                               \
-        val_m;                                 \
+    #define LH(psrc)                                 \
+    ( {                                              \
+        uint8_t *psrc_lh_m = (uint8_t *) (psrc);     \
+        uint16_t val_lh_m;                           \
+                                                     \
+        __asm__ volatile (                           \
+            "ulh  %[val_lh_m],  %[psrc_lh_m]  \n\t"  \
+                                                     \
+            : [val_lh_m] "=r" (val_lh_m)             \
+            : [psrc_lh_m] "m" (*psrc_lh_m)           \
+        );                                           \
+                                                     \
+        val_lh_m;                                    \
+    } )
+
+    #define LW(psrc)                                 \
+    ( {                                              \
+        uint8_t *psrc_lw_m = (uint8_t *) (psrc);     \
+        uint32_t val_lw_m;                           \
+                                                     \
+        __asm__ volatile (                           \
+            "ulw  %[val_lw_m],  %[psrc_lw_m]  \n\t"  \
+                                                     \
+            : [val_lw_m] "=r" (val_lw_m)             \
+            : [psrc_lw_m] "m" (*psrc_lw_m)           \
+        );                                           \
+                                                     \
+        val_lw_m;                                    \
     } )
 
     #if (__mips == 64)
-        #define LD(psrc)                           \
-        ( {                                        \
-            uint8_t *psrc_m = (uint8_t *) (psrc);  \
-            uint64_t val_m = 0;                    \
-                                                   \
-            __asm__ volatile (                     \
-                "uld  %[val_m],  %[psrc_m]  \n\t"  \
-                                                   \
-                : [val_m] "=r" (val_m)             \
-                : [psrc_m] "m" (*psrc_m)           \
-            );                                     \
-                                                   \
-            val_m;                                 \
+        #define LD(psrc)                                 \
+        ( {                                              \
+            uint8_t *psrc_ld_m = (uint8_t *) (psrc);     \
+            uint64_t val_ld_m = 0;                       \
+                                                         \
+            __asm__ volatile (                           \
+                "uld  %[val_ld_m],  %[psrc_ld_m]  \n\t"  \
+                                                         \
+                : [val_ld_m] "=r" (val_ld_m)             \
+                : [psrc_ld_m] "m" (*psrc_ld_m)           \
+            );                                           \
+                                                         \
+            val_ld_m;                                    \
         } )
     #else  // !(__mips == 64)
-        #define LD(psrc)                                              \
-        ( {                                                           \
-            uint8_t *psrc_ld_m = (uint8_t *) (psrc);                  \
-            uint32_t val0_m, val1_m;                                  \
-            uint64_t val_m = 0;                                       \
-                                                                      \
-            val0_m = LW(psrc_ld_m);                                   \
-            val1_m = LW(psrc_ld_m + 4);                               \
-                                                                      \
-            val_m = (uint64_t) (val1_m);                              \
-            val_m = (uint64_t) ((val_m << 32) & 0xFFFFFFFF00000000);  \
-            val_m = (uint64_t) (val_m | (uint64_t) val0_m);           \
-                                                                      \
-            val_m;                                                    \
+        #define LD(psrc)                                                    \
+        ( {                                                                 \
+            uint8_t *psrc_ld_m = (uint8_t *) (psrc);                        \
+            uint32_t val0_ld_m, val1_ld_m;                                  \
+            uint64_t val_ld_m = 0;                                          \
+                                                                            \
+            val0_ld_m = LW(psrc_ld_m);                                      \
+            val1_ld_m = LW(psrc_ld_m + 4);                                  \
+                                                                            \
+            val_ld_m = (uint64_t) (val1_ld_m);                              \
+            val_ld_m = (uint64_t) ((val_ld_m << 32) & 0xFFFFFFFF00000000);  \
+            val_ld_m = (uint64_t) (val_ld_m | (uint64_t) val0_ld_m);        \
+                                                                            \
+            val_ld_m;                                                       \
         } )
     #endif  // (__mips == 64)
 
-    #define SH(val, pdst)                      \
-    {                                          \
-        uint8_t *pdst_m = (uint8_t *) (pdst);  \
-        uint16_t val_m = (val);                \
-                                               \
-        __asm__ volatile (                     \
-            "ush  %[val_m],  %[pdst_m]  \n\t"  \
-                                               \
-            : [pdst_m] "=m" (*pdst_m)          \
-            : [val_m] "r" (val_m)              \
-        );                                     \
+    #define SH(val, pdst)                            \
+    {                                                \
+        uint8_t *pdst_sh_m = (uint8_t *) (pdst);     \
+        uint16_t val_sh_m = (val);                   \
+                                                     \
+        __asm__ volatile (                           \
+            "ush  %[val_sh_m],  %[pdst_sh_m]  \n\t"  \
+                                                     \
+            : [pdst_sh_m] "=m" (*pdst_sh_m)          \
+            : [val_sh_m] "r" (val_sh_m)              \
+        );                                           \
     }
 
-    #define SW(val, pdst)                      \
-    {                                          \
-        uint8_t *pdst_m = (uint8_t *) (pdst);  \
-        uint32_t val_m = (val);                \
-                                               \
-        __asm__ volatile (                     \
-            "usw  %[val_m],  %[pdst_m]  \n\t"  \
-                                               \
-            : [pdst_m] "=m" (*pdst_m)          \
-            : [val_m] "r" (val_m)              \
-        );                                     \
+    #define SW(val, pdst)                            \
+    {                                                \
+        uint8_t *pdst_sw_m = (uint8_t *) (pdst);     \
+        uint32_t val_sw_m = (val);                   \
+                                                     \
+        __asm__ volatile (                           \
+            "usw  %[val_sw_m],  %[pdst_sw_m]  \n\t"  \
+                                                     \
+            : [pdst_sw_m] "=m" (*pdst_sw_m)          \
+            : [val_sw_m] "r" (val_sw_m)              \
+        );                                           \
     }
 
-    #define SD(val, pdst)                                          \
-    {                                                              \
-        uint8_t *pdst_m1 = (uint8_t *) (pdst);                     \
-        uint32_t val0_m, val1_m;                                   \
-                                                                   \
-        val0_m = (uint32_t) ((val) & 0x00000000FFFFFFFF);          \
-        val1_m = (uint32_t) (((val) >> 32) & 0x00000000FFFFFFFF);  \
-                                                                   \
-        SW(val0_m, pdst_m1);                                       \
-        SW(val1_m, pdst_m1 + 4);                                   \
+    #define SD(val, pdst)                                             \
+    {                                                                 \
+        uint8_t *pdst_sd_m = (uint8_t *) (pdst);                      \
+        uint32_t val0_sd_m, val1_sd_m;                                \
+                                                                      \
+        val0_sd_m = (uint32_t) ((val) & 0x00000000FFFFFFFF);          \
+        val1_sd_m = (uint32_t) (((val) >> 32) & 0x00000000FFFFFFFF);  \
+                                                                      \
+        SW(val0_sd_m, pdst_sd_m);                                     \
+        SW(val1_sd_m, pdst_sd_m + 4);                                 \
     }
 #endif // (__mips_isa_rev >= 6)
 
@@ -243,6 +204,12 @@
     out3 = LW((psrc) + 3 * stride);                \
 }
 
+#define LW2(psrc, stride, out0, out1)  \
+{                                      \
+    out0 = LW((psrc));                 \
+    out1 = LW((psrc) + stride);        \
+}
+
 /* Description : Load double words with stride
    Arguments   : Inputs  - psrc    (source pointer to load from)
                          - stride
@@ -291,122 +258,91 @@
     SD(in3, (pdst) + 3 * stride);              \
 }
 
-/* Description : Load vectors with 16 byte elements with stride
+/* Description : Load vector elements with stride
    Arguments   : Inputs  - psrc    (source pointer to load from)
                          - stride
                  Outputs - out0, out1
                  Return Type - as per RTYPE
-   Details     : Loads 16 byte elements in 'out0' from (psrc)
-                 Loads 16 byte elements in 'out1' from (psrc + stride)
+   Details     : Loads elements in 'out0' from (psrc)
+                 Loads elements in 'out1' from (psrc + stride)
 */
-#define LD_B2(RTYPE, psrc, stride, out0, out1)  \
+#define LD_V2(RTYPE, psrc, stride, out0, out1)  \
 {                                               \
-    out0 = LD_B(RTYPE, (psrc));                 \
-    out1 = LD_B(RTYPE, (psrc) + stride);        \
+    out0 = LD_V(RTYPE, (psrc));                 \
+    out1 = LD_V(RTYPE, (psrc) + stride);        \
 }
-#define LD_UB2(...) LD_B2(v16u8, __VA_ARGS__)
-#define LD_SB2(...) LD_B2(v16i8, __VA_ARGS__)
+#define LD_UB2(...) LD_V2(v16u8, __VA_ARGS__)
+#define LD_SB2(...) LD_V2(v16i8, __VA_ARGS__)
+#define LD_UH2(...) LD_V2(v8u16, __VA_ARGS__)
+#define LD_SH2(...) LD_V2(v8i16, __VA_ARGS__)
+#define LD_SW2(...) LD_V2(v4i32, __VA_ARGS__)
 
-#define LD_B3(RTYPE, psrc, stride, out0, out1, out2)  \
+#define LD_V3(RTYPE, psrc, stride, out0, out1, out2)  \
 {                                                     \
-    LD_B2(RTYPE, (psrc), stride, out0, out1);         \
-    out2 = LD_B(RTYPE, (psrc) + 2 * stride);          \
+    LD_V2(RTYPE, (psrc), stride, out0, out1);         \
+    out2 = LD_V(RTYPE, (psrc) + 2 * stride);          \
 }
-#define LD_UB3(...) LD_B3(v16u8, __VA_ARGS__)
-#define LD_SB3(...) LD_B3(v16i8, __VA_ARGS__)
+#define LD_UB3(...) LD_V3(v16u8, __VA_ARGS__)
+#define LD_SB3(...) LD_V3(v16i8, __VA_ARGS__)
 
-#define LD_B4(RTYPE, psrc, stride, out0, out1, out2, out3)   \
+#define LD_V4(RTYPE, psrc, stride, out0, out1, out2, out3)   \
 {                                                            \
-    LD_B2(RTYPE, (psrc), stride, out0, out1);                \
-    LD_B2(RTYPE, (psrc) + 2 * stride , stride, out2, out3);  \
+    LD_V2(RTYPE, (psrc), stride, out0, out1);                \
+    LD_V2(RTYPE, (psrc) + 2 * stride , stride, out2, out3);  \
 }
-#define LD_UB4(...) LD_B4(v16u8, __VA_ARGS__)
-#define LD_SB4(...) LD_B4(v16i8, __VA_ARGS__)
+#define LD_UB4(...) LD_V4(v16u8, __VA_ARGS__)
+#define LD_SB4(...) LD_V4(v16i8, __VA_ARGS__)
+#define LD_UH4(...) LD_V4(v8u16, __VA_ARGS__)
+#define LD_SH4(...) LD_V4(v8i16, __VA_ARGS__)
 
-#define LD_B5(RTYPE, psrc, stride, out0, out1, out2, out3, out4)  \
+#define LD_V5(RTYPE, psrc, stride, out0, out1, out2, out3, out4)  \
 {                                                                 \
-    LD_B4(RTYPE, (psrc), stride, out0, out1, out2, out3);         \
-    out4 = LD_B(RTYPE, (psrc) + 4 * stride);                      \
+    LD_V4(RTYPE, (psrc), stride, out0, out1, out2, out3);         \
+    out4 = LD_V(RTYPE, (psrc) + 4 * stride);                      \
 }
-#define LD_UB5(...) LD_B5(v16u8, __VA_ARGS__)
-#define LD_SB5(...) LD_B5(v16i8, __VA_ARGS__)
+#define LD_UB5(...) LD_V5(v16u8, __VA_ARGS__)
+#define LD_SB5(...) LD_V5(v16i8, __VA_ARGS__)
 
-#define LD_B6(RTYPE, psrc, stride, out0, out1, out2, out3, out4, out5)  \
+#define LD_V6(RTYPE, psrc, stride, out0, out1, out2, out3, out4, out5)  \
 {                                                                       \
-    LD_B4(RTYPE, (psrc), stride, out0, out1, out2, out3);               \
-    LD_B2(RTYPE, (psrc) + 4 * stride, stride, out4, out5);              \
+    LD_V4(RTYPE, (psrc), stride, out0, out1, out2, out3);               \
+    LD_V2(RTYPE, (psrc) + 4 * stride, stride, out4, out5);              \
 }
-#define LD_UB6(...) LD_B6(v16u8, __VA_ARGS__)
-#define LD_SB6(...) LD_B6(v16i8, __VA_ARGS__)
+#define LD_UB6(...) LD_V6(v16u8, __VA_ARGS__)
+#define LD_SB6(...) LD_V6(v16i8, __VA_ARGS__)
+#define LD_UH6(...) LD_V6(v8u16, __VA_ARGS__)
+#define LD_SH6(...) LD_V6(v8i16, __VA_ARGS__)
 
-#define LD_B7(RTYPE, psrc, stride,                               \
+#define LD_V7(RTYPE, psrc, stride,                               \
               out0, out1, out2, out3, out4, out5, out6)          \
 {                                                                \
-    LD_B5(RTYPE, (psrc), stride, out0, out1, out2, out3, out4);  \
-    LD_B2(RTYPE, (psrc) + 5 * stride, stride, out5, out6);       \
+    LD_V5(RTYPE, (psrc), stride, out0, out1, out2, out3, out4);  \
+    LD_V2(RTYPE, (psrc) + 5 * stride, stride, out5, out6);       \
 }
-#define LD_UB7(...) LD_B7(v16u8, __VA_ARGS__)
-#define LD_SB7(...) LD_B7(v16i8, __VA_ARGS__)
+#define LD_UB7(...) LD_V7(v16u8, __VA_ARGS__)
+#define LD_SB7(...) LD_V7(v16i8, __VA_ARGS__)
 
-#define LD_B8(RTYPE, psrc, stride,                                      \
+#define LD_V8(RTYPE, psrc, stride,                                      \
               out0, out1, out2, out3, out4, out5, out6, out7)           \
 {                                                                       \
-    LD_B4(RTYPE, (psrc), stride, out0, out1, out2, out3);               \
-    LD_B4(RTYPE, (psrc) + 4 * stride, stride, out4, out5, out6, out7);  \
-}
-#define LD_UB8(...) LD_B8(v16u8, __VA_ARGS__)
-#define LD_SB8(...) LD_B8(v16i8, __VA_ARGS__)
-
-/* Description : Load vectors with 8 halfword elements with stride
-   Arguments   : Inputs  - psrc    (source pointer to load from)
-                         - stride
-                 Outputs - out0, out1
-   Details     : Loads 8 halfword elements in 'out0' from (psrc)
-                 Loads 8 halfword elements in 'out1' from (psrc + stride)
-*/
-#define LD_H2(RTYPE, psrc, stride, out0, out1)  \
-{                                               \
-    out0 = LD_H(RTYPE, (psrc));                 \
-    out1 = LD_H(RTYPE, (psrc) + (stride));      \
+    LD_V4(RTYPE, (psrc), stride, out0, out1, out2, out3);               \
+    LD_V4(RTYPE, (psrc) + 4 * stride, stride, out4, out5, out6, out7);  \
 }
-#define LD_UH2(...) LD_H2(v8u16, __VA_ARGS__)
-#define LD_SH2(...) LD_H2(v8i16, __VA_ARGS__)
+#define LD_UB8(...) LD_V8(v16u8, __VA_ARGS__)
+#define LD_SB8(...) LD_V8(v16i8, __VA_ARGS__)
+#define LD_UH8(...) LD_V8(v8u16, __VA_ARGS__)
+#define LD_SH8(...) LD_V8(v8i16, __VA_ARGS__)
 
-#define LD_H4(RTYPE, psrc, stride, out0, out1, out2, out3)  \
-{                                                           \
-    LD_H2(RTYPE, (psrc), stride, out0, out1);               \
-    LD_H2(RTYPE, (psrc) + 2 * stride, stride, out2, out3);  \
-}
-#define LD_UH4(...) LD_H4(v8u16, __VA_ARGS__)
-#define LD_SH4(...) LD_H4(v8i16, __VA_ARGS__)
-
-#define LD_H6(RTYPE, psrc, stride, out0, out1, out2, out3, out4, out5)  \
-{                                                                       \
-    LD_H4(RTYPE, (psrc), stride, out0, out1, out2, out3);               \
-    LD_H2(RTYPE, (psrc) + 4 * stride, stride, out4, out5);              \
-}
-#define LD_UH6(...) LD_H6(v8u16, __VA_ARGS__)
-#define LD_SH6(...) LD_H6(v8i16, __VA_ARGS__)
-
-#define LD_H8(RTYPE, psrc, stride,                                      \
-              out0, out1, out2, out3, out4, out5, out6, out7)           \
-{                                                                       \
-    LD_H4(RTYPE, (psrc), stride, out0, out1, out2, out3);               \
-    LD_H4(RTYPE, (psrc) + 4 * stride, stride, out4, out5, out6, out7);  \
-}
-#define LD_UH8(...) LD_H8(v8u16, __VA_ARGS__)
-#define LD_SH8(...) LD_H8(v8i16, __VA_ARGS__)
-
-#define LD_H16(RTYPE, psrc, stride,                                   \
+#define LD_V16(RTYPE, psrc, stride,                                   \
                out0, out1, out2, out3, out4, out5, out6, out7,        \
                out8, out9, out10, out11, out12, out13, out14, out15)  \
 {                                                                     \
-    LD_H8(RTYPE, (psrc), stride,                                      \
+    LD_V8(RTYPE, (psrc), stride,                                      \
           out0, out1, out2, out3, out4, out5, out6, out7);            \
-    LD_H8(RTYPE, (psrc) + 8 * stride, stride,                         \
+    LD_V8(RTYPE, (psrc) + 8 * stride, stride,                         \
           out8, out9, out10, out11, out12, out13, out14, out15);      \
 }
-#define LD_SH16(...) LD_H16(v8i16, __VA_ARGS__)
+#define LD_SH16(...) LD_V16(v8i16, __VA_ARGS__)
 
 /* Description : Load as 4x4 block of signed halfword elements from 1D source
                  data into 4 vectors (Each vector with 4 signed halfwords)
@@ -421,103 +357,48 @@
     out3 = (v8i16) __msa_ilvl_d((v2i64) out2, (v2i64) out2);  \
 }
 
-/* Description : Load 2 vectors of signed word elements with stride
-   Arguments   : Inputs  - psrc    (source pointer to load from)
-                         - stride
-                 Outputs - out0, out1
-                 Return Type - signed word
-*/
-#define LD_SW2(psrc, stride, out0, out1)  \
-{                                         \
-    out0 = LD_SW((psrc));                 \
-    out1 = LD_SW((psrc) + stride);        \
-}
-
-/* Description : Store vectors of 16 byte elements with stride
-   Arguments   : Inputs  - in0, in1, stride
-                 Outputs - pdst    (destination pointer to store to)
-   Details     : Stores 16 byte elements from 'in0' to (pdst)
-                 Stores 16 byte elements from 'in1' to (pdst + stride)
-*/
-#define ST_B2(RTYPE, in0, in1, pdst, stride)  \
-{                                             \
-    ST_B(RTYPE, in0, (pdst));                 \
-    ST_B(RTYPE, in1, (pdst) + stride);        \
-}
-#define ST_UB2(...) ST_B2(v16u8, __VA_ARGS__)
-#define ST_SB2(...) ST_B2(v16i8, __VA_ARGS__)
-
-#define ST_B4(RTYPE, in0, in1, in2, in3, pdst, stride)    \
-{                                                         \
-    ST_B2(RTYPE, in0, in1, (pdst), stride);               \
-    ST_B2(RTYPE, in2, in3, (pdst) + 2 * stride, stride);  \
-}
-#define ST_UB4(...) ST_B4(v16u8, __VA_ARGS__)
-#define ST_SB4(...) ST_B4(v16i8, __VA_ARGS__)
-
-#define ST_B8(RTYPE, in0, in1, in2, in3, in4, in5, in6, in7,        \
-              pdst, stride)                                         \
-{                                                                   \
-    ST_B4(RTYPE, in0, in1, in2, in3, pdst, stride);                 \
-    ST_B4(RTYPE, in4, in5, in6, in7, (pdst) + 4 * stride, stride);  \
-}
-#define ST_UB8(...) ST_B8(v16u8, __VA_ARGS__)
-
-/* Description : Store vectors of 8 halfword elements with stride
+/* Description : Store vectors with stride
    Arguments   : Inputs  - in0, in1, stride
                  Outputs - pdst    (destination pointer to store to)
-   Details     : Stores 8 halfword elements from 'in0' to (pdst)
-                 Stores 8 halfword elements from 'in1' to (pdst + stride)
+   Details     : Stores elements from 'in0' to (pdst)
+                 Stores elements from 'in1' to (pdst + stride)
 */
-#define ST_H2(RTYPE, in0, in1, pdst, stride)  \
+#define ST_V2(RTYPE, in0, in1, pdst, stride)  \
 {                                             \
-    ST_H(RTYPE, in0, (pdst));                 \
-    ST_H(RTYPE, in1, (pdst) + stride);        \
+    ST_V(RTYPE, in0, (pdst));                 \
+    ST_V(RTYPE, in1, (pdst) + stride);        \
 }
-#define ST_UH2(...) ST_H2(v8u16, __VA_ARGS__)
-#define ST_SH2(...) ST_H2(v8i16, __VA_ARGS__)
+#define ST_UB2(...) ST_V2(v16u8, __VA_ARGS__)
+#define ST_SB2(...) ST_V2(v16i8, __VA_ARGS__)
+#define ST_UH2(...) ST_V2(v8u16, __VA_ARGS__)
+#define ST_SH2(...) ST_V2(v8i16, __VA_ARGS__)
+#define ST_SW2(...) ST_V2(v4i32, __VA_ARGS__)
 
-#define ST_H4(RTYPE, in0, in1, in2, in3, pdst, stride)    \
+#define ST_V4(RTYPE, in0, in1, in2, in3, pdst, stride)    \
 {                                                         \
-    ST_H2(RTYPE, in0, in1, (pdst), stride);               \
-    ST_H2(RTYPE, in2, in3, (pdst) + 2 * stride, stride);  \
+    ST_V2(RTYPE, in0, in1, (pdst), stride);               \
+    ST_V2(RTYPE, in2, in3, (pdst) + 2 * stride, stride);  \
 }
-#define ST_SH4(...) ST_H4(v8i16, __VA_ARGS__)
+#define ST_UB4(...) ST_V4(v16u8, __VA_ARGS__)
+#define ST_SB4(...) ST_V4(v16i8, __VA_ARGS__)
+#define ST_SH4(...) ST_V4(v8i16, __VA_ARGS__)
+#define ST_SW4(...) ST_V4(v4i32, __VA_ARGS__)
 
-#define ST_H6(RTYPE, in0, in1, in2, in3, in4, in5, pdst, stride)  \
+#define ST_V6(RTYPE, in0, in1, in2, in3, in4, in5, pdst, stride)  \
 {                                                                 \
-    ST_H4(RTYPE, in0, in1, in2, in3, (pdst), stride);             \
-    ST_H2(RTYPE, in4, in5, (pdst) + 4 * stride, stride);          \
+    ST_V4(RTYPE, in0, in1, in2, in3, (pdst), stride);             \
+    ST_V2(RTYPE, in4, in5, (pdst) + 4 * stride, stride);          \
 }
-#define ST_SH6(...) ST_H6(v8i16, __VA_ARGS__)
+#define ST_SH6(...) ST_V6(v8i16, __VA_ARGS__)
 
-#define ST_H8(RTYPE, in0, in1, in2, in3, in4, in5, in6, in7, pdst, stride)  \
+#define ST_V8(RTYPE, in0, in1, in2, in3, in4, in5, in6, in7, pdst, stride)  \
 {                                                                           \
-    ST_H4(RTYPE, in0, in1, in2, in3, (pdst), stride);                       \
-    ST_H4(RTYPE, in4, in5, in6, in7, (pdst) + 4 * stride, stride);          \
-}
-#define ST_SH8(...) ST_H8(v8i16, __VA_ARGS__)
-
-/* Description : Store vectors of word elements with stride
-   Arguments   : Inputs  - in0, in1, stride
-                 Outputs - pdst    (destination pointer to store to)
-                 Return Type - signed word
-   Details     : Stores 4 word elements from 'in0' to (pdst)
-                 Stores 4 word elements from 'in1' to (pdst + stride)
-*/
-#define ST_SW2(in0, in1, pdst, stride)  \
-{                                       \
-    ST_SW(in0, (pdst));                 \
-    ST_SW(in1, (pdst) + stride);        \
-}
-#define ST_SW8(in0, in1, in2, in3, in4, in5, in6, in7,  \
-               pdst, stride)                            \
-{                                                       \
-    ST_SW2(in0, in1, (pdst), stride);                   \
-    ST_SW2(in2, in3, (pdst) + 2 * stride, stride);      \
-    ST_SW2(in4, in5, (pdst) + 4 * stride, stride);      \
-    ST_SW2(in6, in7, (pdst) + 6 * stride, stride);      \
+    ST_V4(RTYPE, in0, in1, in2, in3, (pdst), stride);                       \
+    ST_V4(RTYPE, in4, in5, in6, in7, (pdst) + 4 * stride, stride);          \
 }
+#define ST_UB8(...) ST_V8(v16u8, __VA_ARGS__)
+#define ST_SH8(...) ST_V8(v8i16, __VA_ARGS__)
+#define ST_SW8(...) ST_V8(v4i32, __VA_ARGS__)
 
 /* Description : Store as 2x4 byte block to destination memory from input vector
    Arguments   : Inputs  - in, stidx, pdst, stride
@@ -776,7 +657,7 @@
 /* Description : average with rounding (in0 + in1 + 1) / 2.
    Arguments   : Inputs  - in0, in1, in2, in3,
                  Outputs - out0, out1
-                 Return Type - signed byte
+                 Return Type - as per RTYPE
    Details     : Each byte element from 'in0' vector is added with each byte
                  element from 'in1' vector. The addition of the elements plus 1
                 (for rounding) is done unsigned with full precision,
@@ -941,7 +822,7 @@
    Arguments   : Inputs  - mult0, mult1
                            cnst0, cnst1
                  Outputs - out0, out1
-                 Return Type - unsigned halfword
+                 Return Type - as per RTYPE
    Details     : Unsigned byte elements from mult0 are multiplied with
                  unsigned byte elements from cnst0 producing a result
                  twice the size of input i.e. unsigned halfword.
@@ -969,7 +850,7 @@
    Arguments   : Inputs  - mult0, mult1
                            cnst0, cnst1
                  Outputs - out0, out1
-                 Return Type - signed halfword
+                 Return Type - as per RTYPE
    Details     : Signed byte elements from mult0 are multiplied with
                  signed byte elements from cnst0 producing a result
                  twice the size of input i.e. signed halfword.
@@ -1004,7 +885,7 @@
    Arguments   : Inputs  - mult0, mult1
                            cnst0, cnst1
                  Outputs - out0, out1
-                 Return Type - signed word
+                 Return Type - as per RTYPE
    Details     : Signed halfword elements from mult0 are multiplied with
                  signed halfword elements from cnst0 producing a result
                  twice the size of input i.e. signed word.
@@ -1032,7 +913,7 @@
    Arguments   : Inputs  - mult0, mult1
                            cnst0, cnst1
                  Outputs - out0, out1
-                 Return Type - signed halfword
+                 Return Type - as per RTYPE
    Details     : Signed byte elements from mult0 are multiplied with
                  signed byte elements from cnst0 producing a result
                  twice the size of input i.e. signed halfword.
@@ -1061,7 +942,7 @@
    Arguments   : Inputs  - mult0, mult1
                            cnst0, cnst1
                  Outputs - out0, out1
-                 Return Type - unsigned halfword
+                 Return Type - as per RTYPE
    Details     : Unsigned byte elements from mult0 are multiplied with
                  unsigned byte elements from cnst0 producing a result
                  twice the size of input i.e. unsigned halfword.
@@ -1082,7 +963,7 @@
    Arguments   : Inputs  - mult0, mult1
                            cnst0, cnst1
                  Outputs - out0, out1
-                 Return Type - signed word
+                 Return Type - as per RTYPE
    Details     : Signed halfword elements from mult0 are multiplied with
                  signed halfword elements from cnst0 producing a result
                  twice the size of input i.e. signed word.
@@ -1111,7 +992,7 @@
                  either vector are copied to the output vector
    Arguments   : Inputs  - in0, in1, min_vec
                  Outputs - in0, in1, (in place)
-                 Return Type - unsigned halfword
+                 Return Type - as per RTYPE
    Details     : Minimum of unsigned halfword element values from 'in0' and
                  'min_value' are written to output vector 'in0'
 */
@@ -1172,6 +1053,25 @@
     CLIP_SH2_0_255(in2, in3);               \
 }
 
+#define CLIP_SH_0_255_MAX_SATU(in)                    \
+( {                                                   \
+    v8i16 out_m;                                      \
+                                                      \
+    out_m = __msa_maxi_s_h((v8i16) in, 0);            \
+    out_m = (v8i16) __msa_sat_u_h((v8u16) out_m, 7);  \
+    out_m;                                            \
+} )
+#define CLIP_SH2_0_255_MAX_SATU(in0, in1)  \
+{                                          \
+    in0 = CLIP_SH_0_255_MAX_SATU(in0);     \
+    in1 = CLIP_SH_0_255_MAX_SATU(in1);     \
+}
+#define CLIP_SH4_0_255_MAX_SATU(in0, in1, in2, in3)  \
+{                                                    \
+    CLIP_SH2_0_255_MAX_SATU(in0, in1);               \
+    CLIP_SH2_0_255_MAX_SATU(in2, in3);               \
+}
+
 /* Description : Clips all signed word elements of input vector
                  between 0 & 255
    Arguments   : Inputs  - in       (input vector)
@@ -1202,7 +1102,7 @@
                                                       \
     res0_m = __msa_hadd_s_d((v4i32) in, (v4i32) in);  \
     res1_m = __msa_splati_d(res0_m, 1);               \
-    res0_m = res0_m + res1_m;                         \
+    res0_m += res1_m;                                 \
     sum_m = __msa_copy_s_w((v4i32) res0_m, 0);        \
     sum_m;                                            \
 } )
@@ -1223,7 +1123,7 @@
     res_m = __msa_hadd_u_w((v8u16) in, (v8u16) in);      \
     res0_m = __msa_hadd_u_d(res_m, res_m);               \
     res1_m = (v2u64) __msa_splati_d((v2i64) res0_m, 1);  \
-    res0_m = res0_m + res1_m;                            \
+    res0_m += res1_m;                                    \
     sum_m = __msa_copy_u_w((v4i32) res0_m, 0);           \
     sum_m;                                               \
 } )
@@ -1352,6 +1252,7 @@
 }
 #define INSERT_W4_UB(...) INSERT_W4(v16u8, __VA_ARGS__)
 #define INSERT_W4_SB(...) INSERT_W4(v16i8, __VA_ARGS__)
+#define INSERT_W4_SH(...) INSERT_W4(v8i16, __VA_ARGS__)
 #define INSERT_W4_SW(...) INSERT_W4(v4i32, __VA_ARGS__)
 
 /* Description : Insert specified double word elements from input vectors to 1
@@ -1367,6 +1268,7 @@
 }
 #define INSERT_D2_UB(...) INSERT_D2(v16u8, __VA_ARGS__)
 #define INSERT_D2_SB(...) INSERT_D2(v16i8, __VA_ARGS__)
+#define INSERT_D2_SH(...) INSERT_D2(v8i16, __VA_ARGS__)
 #define INSERT_D2_SD(...) INSERT_D2(v2i64, __VA_ARGS__)
 
 /* Description : Interleave even byte elements from vectors
@@ -1544,6 +1446,7 @@
     out2 = (RTYPE) __msa_ilvr_b((v16i8) in4, (v16i8) in5);              \
 }
 #define ILVR_B3_UB(...) ILVR_B3(v16u8, __VA_ARGS__)
+#define ILVR_B3_SB(...) ILVR_B3(v16i8, __VA_ARGS__)
 #define ILVR_B3_UH(...) ILVR_B3(v8u16, __VA_ARGS__)
 #define ILVR_B3_SH(...) ILVR_B3(v8i16, __VA_ARGS__)
 
@@ -1573,7 +1476,7 @@
 /* Description : Interleave right half of halfword elements from vectors
    Arguments   : Inputs  - in0, in1, in2, in3, in4, in5, in6, in7
                  Outputs - out0, out1, out2, out3
-                 Return Type - signed halfword
+                 Return Type - as per RTYPE
    Details     : Right half of halfword elements of in0 and right half of
                  halfword elements of in1 are interleaved and copied to out0.
                  Right half of halfword elements of in2 and right half of
@@ -1625,16 +1528,16 @@
 /* Description : Interleave right half of double word elements from vectors
    Arguments   : Inputs  - in0, in1, in2, in3, in4, in5, in6, in7
                  Outputs - out0, out1, out2, out3
-                 Return Type - unsigned double word
+                 Return Type - as per RTYPE
    Details     : Right half of double word elements of in0 and right half of
                  double word elements of in1 are interleaved and copied to out0.
                  Right half of double word elements of in2 and right half of
                  double word elements of in3 are interleaved and copied to out1.
 */
-#define ILVR_D2(RTYPE, in0, in1, in2, in3, out0, out1)          \
-{                                                               \
-    out0 = (RTYPE) __msa_ilvr_d((v2i64) (in0), (v2i64) (in1));  \
-    out1 = (RTYPE) __msa_ilvr_d((v2i64) (in2), (v2i64) (in3));  \
+#define ILVR_D2(RTYPE, in0, in1, in2, in3, out0, out1)      \
+{                                                           \
+    out0 = (RTYPE) __msa_ilvr_d((v2i64) in0, (v2i64) in1);  \
+    out1 = (RTYPE) __msa_ilvr_d((v2i64) in2, (v2i64) in3);  \
 }
 #define ILVR_D2_UB(...) ILVR_D2(v16u8, __VA_ARGS__)
 #define ILVR_D2_SB(...) ILVR_D2(v16i8, __VA_ARGS__)
@@ -1643,7 +1546,7 @@
 #define ILVR_D3(RTYPE, in0, in1, in2, in3, in4, in5, out0, out1, out2)  \
 {                                                                       \
     ILVR_D2(RTYPE, in0, in1, in2, in3, out0, out1);                     \
-    out2 = (RTYPE) __msa_ilvr_d((v2i64) (in4), (v2i64) (in5));          \
+    out2 = (RTYPE) __msa_ilvr_d((v2i64) in4, (v2i64) in5);              \
 }
 #define ILVR_D3_SB(...) ILVR_D3(v16i8, __VA_ARGS__)
 
@@ -1656,6 +1559,24 @@
 #define ILVR_D4_SB(...) ILVR_D4(v16i8, __VA_ARGS__)
 #define ILVR_D4_UB(...) ILVR_D4(v16u8, __VA_ARGS__)
 
+/* Description : Interleave left half of double word elements from vectors
+   Arguments   : Inputs  - in0, in1, in2, in3
+                 Outputs - out0, out1
+                 Return Type - as per RTYPE
+   Details     : Left half of double word elements of in0 and left half of
+                 double word elements of in1 are interleaved and copied to out0.
+                 Left half of double word elements of in2 and left half of
+                 double word elements of in3 are interleaved and copied to out1.
+*/
+#define ILVL_D2(RTYPE, in0, in1, in2, in3, out0, out1)      \
+{                                                           \
+    out0 = (RTYPE) __msa_ilvl_d((v2i64) in0, (v2i64) in1);  \
+    out1 = (RTYPE) __msa_ilvl_d((v2i64) in2, (v2i64) in3);  \
+}
+#define ILVL_D2_UB(...) ILVL_D2(v16u8, __VA_ARGS__)
+#define ILVL_D2_SB(...) ILVL_D2(v16i8, __VA_ARGS__)
+#define ILVL_D2_SH(...) ILVL_D2(v8i16, __VA_ARGS__)
+
 /* Description : Interleave both left and right half of input vectors
    Arguments   : Inputs  - in0, in1
                  Outputs - out0, out1
@@ -1681,6 +1602,7 @@
     out0 = (RTYPE) __msa_ilvr_h((v8i16) in0, (v8i16) in1);  \
     out1 = (RTYPE) __msa_ilvl_h((v8i16) in0, (v8i16) in1);  \
 }
+#define ILVRL_H2_UB(...) ILVRL_H2(v16u8, __VA_ARGS__)
 #define ILVRL_H2_SB(...) ILVRL_H2(v16i8, __VA_ARGS__)
 #define ILVRL_H2_SH(...) ILVRL_H2(v8i16, __VA_ARGS__)
 #define ILVRL_H2_SW(...) ILVRL_H2(v4i32, __VA_ARGS__)
@@ -1698,14 +1620,14 @@
                  5-bit signed immediate value are copied to the output vector
    Arguments   : Inputs  - in0, in1, in2, in3, max_val
                  Outputs - in0, in1, in2, in3 (in place)
-                 Return Type - unsigned halfword
+                 Return Type - as per RTYPE
    Details     : Maximum of signed halfword element values from 'in0' and
                  'max_val' are written to output vector 'in0'
 */
-#define MAXI_SH2(RTYPE, in0, in1, max_val)                 \
-{                                                          \
-    in0 = (RTYPE) __msa_maxi_s_h((v8i16) in0, (max_val));  \
-    in1 = (RTYPE) __msa_maxi_s_h((v8i16) in1, (max_val));  \
+#define MAXI_SH2(RTYPE, in0, in1, max_val)               \
+{                                                        \
+    in0 = (RTYPE) __msa_maxi_s_h((v8i16) in0, max_val);  \
+    in1 = (RTYPE) __msa_maxi_s_h((v8i16) in1, max_val);  \
 }
 #define MAXI_SH2_UH(...) MAXI_SH2(v8u16, __VA_ARGS__)
 #define MAXI_SH2_SH(...) MAXI_SH2(v8i16, __VA_ARGS__)
@@ -1716,13 +1638,22 @@
     MAXI_SH2(RTYPE, in2, in3, max_val);               \
 }
 #define MAXI_SH4_UH(...) MAXI_SH4(v8u16, __VA_ARGS__)
+#define MAXI_SH4_SH(...) MAXI_SH4(v8i16, __VA_ARGS__)
+
+#define MAXI_SH8(RTYPE, in0, in1, in2, in3, in4, in5, in6, in7, max_val)  \
+{                                                                         \
+    MAXI_SH4(RTYPE, in0, in1, in2, in3, max_val);                         \
+    MAXI_SH4(RTYPE, in4, in5, in6, in7, max_val);                         \
+}
+#define MAXI_SH8_UH(...) MAXI_SH8(v8u16, __VA_ARGS__)
+#define MAXI_SH8_SH(...) MAXI_SH8(v8i16, __VA_ARGS__)
 
 /* Description : Saturate the halfword element values to the max
                  unsigned value of (sat_val+1 bits)
                  The element data width remains unchanged
    Arguments   : Inputs  - in0, in1, in2, in3, sat_val
                  Outputs - in0, in1, in2, in3 (in place)
-                 Return Type - unsigned halfword
+                 Return Type - as per RTYPE
    Details     : Each unsigned halfword element from 'in0' is saturated to the
                  value generated with (sat_val+1) bit range
                  Results are in placed to original vectors
@@ -1738,16 +1669,25 @@
 #define SAT_UH4(RTYPE, in0, in1, in2, in3, sat_val)  \
 {                                                    \
     SAT_UH2(RTYPE, in0, in1, sat_val);               \
-    SAT_UH2(RTYPE, in2, in3, sat_val)                \
+    SAT_UH2(RTYPE, in2, in3, sat_val);               \
 }
 #define SAT_UH4_UH(...) SAT_UH4(v8u16, __VA_ARGS__)
+#define SAT_UH4_SH(...) SAT_UH4(v8i16, __VA_ARGS__)
+
+#define SAT_UH8(RTYPE, in0, in1, in2, in3, in4, in5, in6, in7, sat_val)  \
+{                                                                        \
+    SAT_UH4(RTYPE, in0, in1, in2, in3, sat_val);                         \
+    SAT_UH4(RTYPE, in4, in5, in6, in7, sat_val);                         \
+}
+#define SAT_UH8_UH(...) SAT_UH8(v8u16, __VA_ARGS__)
+#define SAT_UH8_SH(...) SAT_UH8(v8i16, __VA_ARGS__)
 
 /* Description : Saturate the halfword element values to the max
                  unsigned value of (sat_val+1 bits)
                  The element data width remains unchanged
    Arguments   : Inputs  - in0, in1, in2, in3, sat_val
                  Outputs - in0, in1, in2, in3 (in place)
-                 Return Type - unsigned halfword
+                 Return Type - as per RTYPE
    Details     : Each unsigned halfword element from 'in0' is saturated to the
                  value generated with (sat_val+1) bit range
                  Results are in placed to original vectors
@@ -1761,7 +1701,7 @@
 
 #define SAT_SH3(RTYPE, in0, in1, in2, sat_val)          \
 {                                                       \
-    SAT_SH2(RTYPE, in0, in1, sat_val)                   \
+    SAT_SH2(RTYPE, in0, in1, sat_val);                  \
     in2 = (RTYPE) __msa_sat_s_h((v8i16) in2, sat_val);  \
 }
 #define SAT_SH3_SH(...) SAT_SH3(v8i16, __VA_ARGS__)
@@ -1778,7 +1718,7 @@
                  The element data width remains unchanged
    Arguments   : Inputs  - in0, in1, in2, in3, sat_val
                  Outputs - in0, in1, in2, in3 (in place)
-                 Return Type - unsigned word
+                 Return Type - as per RTYPE
    Details     : Each unsigned word element from 'in0' is saturated to the
                  value generated with (sat_val+1) bit range
                  Results are in placed to original vectors
@@ -1930,7 +1870,7 @@
 /* Description : Pack even double word elements of vector pairs
    Arguments   : Inputs  - in0, in1, in2, in3
                  Outputs - out0, out1
-                 Return Type - unsigned byte
+                 Return Type - as per RTYPE
    Details     : Even double elements of in0 are copied to the left half of
                  out0 & even double elements of in1 are copied to the right
                  half of out0.
@@ -2037,6 +1977,7 @@
     XORI_B4_128(RTYPE, in4, in5, in6, in7);                         \
 }
 #define XORI_B8_128_SB(...) XORI_B8_128(v16i8, __VA_ARGS__)
+#define XORI_B8_128_UB(...) XORI_B8_128(v16u8, __VA_ARGS__)
 
 /* Description : Addition of signed halfword elements and signed saturation
    Arguments   : Inputs  - in0, in1, in2, in3
@@ -2071,6 +2012,11 @@
                  result is in place written to 'in0'
                  Similar for other pairs
 */
+#define SLLI_2V(in0, in1, shift)  \
+{                                 \
+    in0 = in0 << shift;           \
+    in1 = in1 << shift;           \
+}
 #define SLLI_4V(in0, in1, in2, in3, shift)  \
 {                                           \
     in0 = in0 << shift;                     \
@@ -2100,7 +2046,7 @@
 /* Description : Shift right logical all halfword elements of vector
    Arguments   : Inputs  - in0, in1, in2, in3, shift
                  Outputs - in0, in1, in2, in3 (in place)
-                 Return Type - unsigned halfword
+                 Return Type - as per RTYPE
    Details     : Each element of vector 'in0' is shifted right logical by
                  number of bits respective element holds in vector 'shift' and
                  result is in place written to 'in0'
@@ -2116,10 +2062,28 @@
 }
 #define SRL_H4_UH(...) SRL_H4(v8u16, __VA_ARGS__)
 
+#define SRLR_H4(RTYPE, in0, in1, in2, in3, shift)            \
+{                                                            \
+    in0 = (RTYPE) __msa_srlr_h((v8i16) in0, (v8i16) shift);  \
+    in1 = (RTYPE) __msa_srlr_h((v8i16) in1, (v8i16) shift);  \
+    in2 = (RTYPE) __msa_srlr_h((v8i16) in2, (v8i16) shift);  \
+    in3 = (RTYPE) __msa_srlr_h((v8i16) in3, (v8i16) shift);  \
+}
+#define SRLR_H4_UH(...) SRLR_H4(v8u16, __VA_ARGS__)
+#define SRLR_H4_SH(...) SRLR_H4(v8i16, __VA_ARGS__)
+
+#define SRLR_H8(RTYPE, in0, in1, in2, in3, in4, in5, in6, in7, shift)  \
+{                                                                      \
+    SRLR_H4(RTYPE, in0, in1, in2, in3, shift);                         \
+    SRLR_H4(RTYPE, in4, in5, in6, in7, shift);                         \
+}
+#define SRLR_H8_UH(...) SRLR_H8(v8u16, __VA_ARGS__)
+#define SRLR_H8_SH(...) SRLR_H8(v8i16, __VA_ARGS__)
+
 /* Description : Shift right arithmetic rounded halfwords
    Arguments   : Inputs  - in0, in1, shift
                  Outputs - in0, in1, (in place)
-                 Return Type - unsigned halfword
+                 Return Type - as per RTYPE
    Details     : Each element of vector 'in0' is shifted right arithmetic by
                  number of bits respective element holds in vector 'shift'.
                  The last discarded bit is added to shifted value for rounding
@@ -2445,7 +2409,7 @@
 /* Description : Transposes input 8x4 byte block into 4x8
    Arguments   : Inputs  - in0, in1, in2, in3      (input 8x4 byte block)
                  Outputs - out0, out1, out2, out3  (output 4x8 byte block)
-                 Return Type - unsigned byte
+                 Return Type - as per RTYPE
    Details     :
 */
 #define TRANSPOSE8x4_UB(RTYPE, in0, in1, in2, in3, in4, in5, in6, in7,  \
@@ -2472,7 +2436,7 @@
                            (input 8x8 byte block)
                  Outputs - out0, out1, out2, out3, out4, out5, out6, out7
                            (output 8x8 byte block)
-                 Return Type - unsigned byte
+                 Return Type - as per RTYPE
    Details     :
 */
 #define TRANSPOSE8x8_UB(RTYPE, in0, in1, in2, in3, in4, in5, in6, in7,   \
@@ -2596,7 +2560,7 @@
 /* Description : Transposes 8x8 block with half word elements in vectors
    Arguments   : Inputs  - in0, in1, in2, in3, in4, in5, in6, in7
                  Outputs - out0, out1, out2, out3, out4, out5, out6, out7
-                 Return Type - signed halfword
+                 Return Type - as per RTYPE
    Details     :
 */
 #define TRANSPOSE8x8_H(RTYPE, in0, in1, in2, in3, in4, in5, in6, in7,   \
@@ -2646,8 +2610,6 @@
 /* Description : Average byte elements from pair of vectors and store 8x4 byte
                  block in destination memory
    Arguments   : Inputs  - in0, in1, in2, in3, in4, in5, in6, in7, pdst, stride
-                 Outputs -
-                 Return Type -
    Details     : Each byte element from input vector pair 'in0' and 'in1' are
                  averaged (a + b)/2 and stored in 'tmp0_m'
                  Each byte element from input vector pair 'in2' and 'in3' are
@@ -2679,8 +2641,6 @@
 /* Description : Average byte elements from pair of vectors and store 16x4 byte
                  block in destination memory
    Arguments   : Inputs  - in0, in1, in2, in3, in4, in5, in6, in7, pdst, stride
-                 Outputs -
-                 Return Type -
    Details     : Each byte element from input vector pair 'in0' and 'in1' are
                  averaged (a + b)/2 and stored in 'tmp0_m'
                  Each byte element from input vector pair 'in2' and 'in3' are
@@ -2707,8 +2667,6 @@
 /* Description : Average rounded byte elements from pair of vectors and store
                  8x4 byte block in destination memory
    Arguments   : Inputs  - in0, in1, in2, in3, in4, in5, in6, in7, pdst, stride
-                 Outputs -
-                 Return Type -
    Details     : Each byte element from input vector pair 'in0' and 'in1' are
                  average rounded (a + b + 1)/2 and stored in 'tmp0_m'
                  Each byte element from input vector pair 'in2' and 'in3' are
@@ -2738,8 +2696,6 @@
 /* Description : Average rounded byte elements from pair of vectors and store
                  16x4 byte block in destination memory
    Arguments   : Inputs  - in0, in1, in2, in3, in4, in5, in6, in7, pdst, stride
-                 Outputs -
-                 Return Type -
    Details     : Each byte element from input vector pair 'in0' and 'in1' are
                  average rounded (a + b + 1)/2 and stored in 'tmp0_m'
                  Each byte element from input vector pair 'in2' and 'in3' are
@@ -2764,8 +2720,6 @@
                  average rounded with destination and store 8x4 byte block
                  in destination memory
    Arguments   : Inputs  - in0, in1, in2, in3, in4, in5, in6, in7, pdst, stride
-                 Outputs -
-                 Return Type -
    Details     : Each byte element from input vector pair 'in0' and 'in1' are
                  average rounded (a + b + 1)/2 and stored in 'tmp0_m'
                  Each byte element from input vector pair 'in2' and 'in3' are
@@ -2794,8 +2748,6 @@
                  average rounded with destination and store 16x4 byte block
                  in destination memory
    Arguments   : Inputs  - in0, in1, in2, in3, in4, in5, in6, in7, pdst, stride
-                 Outputs -
-                 Return Type -
    Details     : Each byte element from input vector pair 'in0' and 'in1' are
                  average rounded (a + b + 1)/2 and stored in 'tmp0_m'
                  Each byte element from input vector pair 'in2' and 'in3' are
@@ -2822,8 +2774,6 @@
 
 /* Description : Add block 4x4
    Arguments   : Inputs  - in0, in1, in2, in3, pdst, stride
-                 Outputs -
-                 Return Type - unsigned bytes
    Details     : Least significant 4 bytes from each input vector are added to
                  the destination bytes, clipped between 0-255 and then stored.
 */
@@ -2894,20 +2844,18 @@
 
 /* Description : Converts inputs to unsigned bytes, interleave, average & store
                  as 8x4 unsigned byte block
-   Arguments   : Inputs  - in0, in1, in2, in3, dst0, dst1, dst2, dst3,
-                           pdst, stride
+   Arguments   : Inputs  - in0, in1, in2, in3, dst0, dst1, pdst, stride
 */
-#define CONVERT_UB_AVG_ST8x4_UB(in0, in1, in2, in3,                    \
-                                dst0, dst1, dst2, dst3, pdst, stride)  \
-{                                                                      \
-    v16u8 tmp0_m, tmp1_m, tmp2_m, tmp3_m;                              \
-    uint8_t *pdst_m = (uint8_t *) (pdst);                              \
-                                                                       \
-    tmp0_m = PCKEV_XORI128_UB(in0, in1);                               \
-    tmp1_m = PCKEV_XORI128_UB(in2, in3);                               \
-    ILVR_D2_UB(dst1, dst0, dst3, dst2, tmp2_m, tmp3_m);                \
-    AVER_UB2_UB(tmp0_m, tmp2_m, tmp1_m, tmp3_m, tmp0_m, tmp1_m);       \
-    ST8x4_UB(tmp0_m, tmp1_m, pdst_m, stride);                          \
+#define CONVERT_UB_AVG_ST8x4_UB(in0, in1, in2, in3,           \
+                                dst0, dst1, pdst, stride)     \
+{                                                             \
+    v16u8 tmp0_m, tmp1_m;                                     \
+    uint8_t *pdst_m = (uint8_t *) (pdst);                     \
+                                                              \
+    tmp0_m = PCKEV_XORI128_UB(in0, in1);                      \
+    tmp1_m = PCKEV_XORI128_UB(in2, in3);                      \
+    AVER_UB2_UB(tmp0_m, dst0, tmp1_m, dst1, tmp0_m, tmp1_m);  \
+    ST8x4_UB(tmp0_m, tmp1_m, pdst_m, stride);                 \
 }
 
 /* Description : Pack even byte elements, extract 0 & 2 index words from pair
diff --git a/mythtv/external/FFmpeg/libavutil/opencl.c b/mythtv/external/FFmpeg/libavutil/opencl.c
index af35770e065..202756516b0 100644
--- a/mythtv/external/FFmpeg/libavutil/opencl.c
+++ b/mythtv/external/FFmpeg/libavutil/opencl.c
@@ -169,7 +169,7 @@ const char *av_opencl_errstr(cl_int status)
 static void free_device_list(AVOpenCLDeviceList *device_list)
 {
     int i, j;
-    if (!device_list)
+    if (!device_list || !device_list->platform_node)
         return;
     for (i = 0; i < device_list->platform_num; i++) {
         if (!device_list->platform_node[i])
diff --git a/mythtv/external/FFmpeg/libavutil/opt.c b/mythtv/external/FFmpeg/libavutil/opt.c
index cd16bd1d3f4..df88663e3f0 100644
--- a/mythtv/external/FFmpeg/libavutil/opt.c
+++ b/mythtv/external/FFmpeg/libavutil/opt.c
@@ -74,6 +74,7 @@ static int read_number(const AVOption *o, const void *dst, double *num, int *den
     case AV_OPT_TYPE_CHANNEL_LAYOUT:
     case AV_OPT_TYPE_DURATION:
     case AV_OPT_TYPE_INT64:
+    case AV_OPT_TYPE_UINT64:
         *intnum = *(int64_t *)dst;
         return 0;
     case AV_OPT_TYPE_FLOAT:
@@ -96,8 +97,8 @@ static int read_number(const AVOption *o, const void *dst, double *num, int *den
 static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
 {
     if (o->type != AV_OPT_TYPE_FLAGS &&
-        (o->max * den < num * intnum || o->min * den > num * intnum)) {
-        num = den ? num * intnum / den : (num * intnum ? INFINITY : NAN);
+        (!den || o->max * den < num * intnum || o->min * den > num * intnum)) {
+        num = den ? num * intnum / den : (num && intnum ? INFINITY : NAN);
         av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range [%g - %g]\n",
                num, o->name, o->min, o->max);
         return AVERROR(ERANGE);
@@ -126,9 +127,27 @@ static int write_number(void *obj, const AVOption *o, void *dst, double num, int
         break;
     case AV_OPT_TYPE_DURATION:
     case AV_OPT_TYPE_CHANNEL_LAYOUT:
-    case AV_OPT_TYPE_INT64:
-        *(int64_t *)dst = llrint(num / den) * intnum;
-        break;
+    case AV_OPT_TYPE_INT64:{
+        double d = num / den;
+        if (intnum == 1 && d == (double)INT64_MAX) {
+            *(int64_t *)dst = INT64_MAX;
+        } else
+            *(int64_t *)dst = llrint(d) * intnum;
+        break;}
+    case AV_OPT_TYPE_UINT64:{
+        double d = num / den;
+        // We must special case uint64_t here as llrint() does not support values
+        // outside the int64_t range and there is no portable function which does
+        // "INT64_MAX + 1ULL" is used as it is representable exactly as IEEE double
+        // while INT64_MAX is not
+        if (intnum == 1 && d == (double)UINT64_MAX) {
+            *(uint64_t *)dst = UINT64_MAX;
+        } else if (d > INT64_MAX + 1ULL) {
+            *(uint64_t *)dst = (llrint(d - (INT64_MAX + 1ULL)) + (INT64_MAX + 1ULL))*intnum;
+        } else {
+            *(uint64_t *)dst = llrint(d) * intnum;
+        }
+        break;}
     case AV_OPT_TYPE_FLOAT:
         *(float *)dst = num * intnum / den;
         break;
@@ -200,6 +219,7 @@ static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **d
 }
 
 #define DEFAULT_NUMVAL(opt) ((opt->type == AV_OPT_TYPE_INT64 || \
+                              opt->type == AV_OPT_TYPE_UINT64 || \
                               opt->type == AV_OPT_TYPE_CONST || \
                               opt->type == AV_OPT_TYPE_FLAGS || \
                               opt->type == AV_OPT_TYPE_INT)     \
@@ -291,8 +311,6 @@ static int set_string_number(void *obj, void *target_obj, const AVOption *o, con
         if (!i || !*val)
             return 0;
     }
-
-    return 0;
 }
 
 static int set_string_image_size(void *obj, const AVOption *o, const char *val, int *dst)
@@ -456,6 +474,7 @@ int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
     case AV_OPT_TYPE_FLAGS:
     case AV_OPT_TYPE_INT:
     case AV_OPT_TYPE_INT64:
+    case AV_OPT_TYPE_UINT64:
     case AV_OPT_TYPE_FLOAT:
     case AV_OPT_TYPE_DOUBLE:
     case AV_OPT_TYPE_RATIONAL:
@@ -756,6 +775,9 @@ int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
     case AV_OPT_TYPE_INT64:
         ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t *)dst);
         break;
+    case AV_OPT_TYPE_UINT64:
+        ret = snprintf(buf, sizeof(buf), "%"PRIu64, *(uint64_t *)dst);
+        break;
     case AV_OPT_TYPE_FLOAT:
         ret = snprintf(buf, sizeof(buf), "%f", *(float *)dst);
         break;
@@ -1104,6 +1126,9 @@ static void opt_list(void *obj, void *av_log_obj, const char *unit,
             case AV_OPT_TYPE_INT64:
                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int64>");
                 break;
+            case AV_OPT_TYPE_UINT64:
+                av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<uint64>");
+                break;
             case AV_OPT_TYPE_DOUBLE:
                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<double>");
                 break;
@@ -1164,6 +1189,7 @@ static void opt_list(void *obj, void *av_log_obj, const char *unit,
             switch (opt->type) {
             case AV_OPT_TYPE_INT:
             case AV_OPT_TYPE_INT64:
+            case AV_OPT_TYPE_UINT64:
             case AV_OPT_TYPE_DOUBLE:
             case AV_OPT_TYPE_FLOAT:
             case AV_OPT_TYPE_RATIONAL:
@@ -1208,6 +1234,7 @@ static void opt_list(void *obj, void *av_log_obj, const char *unit,
                 break;
             }
             case AV_OPT_TYPE_INT:
+            case AV_OPT_TYPE_UINT64:
             case AV_OPT_TYPE_INT64: {
                 const char *def_const = get_opt_const_name(obj, opt->unit, opt->default_val.i64);
                 if (def_const)
@@ -1286,6 +1313,7 @@ void av_opt_set_defaults2(void *s, int mask, int flags)
             case AV_OPT_TYPE_FLAGS:
             case AV_OPT_TYPE_INT:
             case AV_OPT_TYPE_INT64:
+            case AV_OPT_TYPE_UINT64:
             case AV_OPT_TYPE_DURATION:
             case AV_OPT_TYPE_CHANNEL_LAYOUT:
             case AV_OPT_TYPE_PIXEL_FMT:
@@ -1646,6 +1674,7 @@ static int opt_size(enum AVOptionType type)
     case AV_OPT_TYPE_DURATION:
     case AV_OPT_TYPE_CHANNEL_LAYOUT:
     case AV_OPT_TYPE_INT64:
+    case AV_OPT_TYPE_UINT64:
         return sizeof(int64_t);
     case AV_OPT_TYPE_DOUBLE:
         return sizeof(double);
@@ -1775,6 +1804,7 @@ int av_opt_query_ranges_default(AVOptionRanges **ranges_arg, void *obj, const ch
     case AV_OPT_TYPE_BOOL:
     case AV_OPT_TYPE_INT:
     case AV_OPT_TYPE_INT64:
+    case AV_OPT_TYPE_UINT64:
     case AV_OPT_TYPE_PIXEL_FMT:
     case AV_OPT_TYPE_SAMPLE_FMT:
     case AV_OPT_TYPE_FLOAT:
@@ -1864,6 +1894,7 @@ int av_opt_is_set_to_default(void *obj, const AVOption *o)
     case AV_OPT_TYPE_CHANNEL_LAYOUT:
     case AV_OPT_TYPE_DURATION:
     case AV_OPT_TYPE_INT64:
+    case AV_OPT_TYPE_UINT64:
         read_number(o, dst, NULL, NULL, &i64);
         return o->default_val.i64 == i64;
     case AV_OPT_TYPE_STRING:
diff --git a/mythtv/external/FFmpeg/libavutil/opt.h b/mythtv/external/FFmpeg/libavutil/opt.h
index 9430b989e92..0d893795dee 100644
--- a/mythtv/external/FFmpeg/libavutil/opt.h
+++ b/mythtv/external/FFmpeg/libavutil/opt.h
@@ -228,6 +228,7 @@ enum AVOptionType{
     AV_OPT_TYPE_RATIONAL,
     AV_OPT_TYPE_BINARY,  ///< offset must point to a pointer immediately followed by an int for the length
     AV_OPT_TYPE_DICT,
+    AV_OPT_TYPE_UINT64,
     AV_OPT_TYPE_CONST = 128,
     AV_OPT_TYPE_IMAGE_SIZE = MKBETAG('S','I','Z','E'), ///< offset must point to two consecutive integers
     AV_OPT_TYPE_PIXEL_FMT  = MKBETAG('P','F','M','T'),
diff --git a/mythtv/external/FFmpeg/libavutil/parseutils.c b/mythtv/external/FFmpeg/libavutil/parseutils.c
index 86d3dac57c1..7ca07b37a19 100644
--- a/mythtv/external/FFmpeg/libavutil/parseutils.c
+++ b/mythtv/external/FFmpeg/libavutil/parseutils.c
@@ -140,6 +140,11 @@ static const VideoRateAbbr video_rate_abbrs[]= {
     { "ntsc-film", { 24000, 1001 } },
 };
 
+static const char *months[12] = {
+    "january", "february", "march", "april", "may", "june", "july", "august",
+    "september", "october", "november", "december"
+};
+
 int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
 {
     int i;
@@ -466,6 +471,21 @@ static int date_get_num(const char **pp,
     return val;
 }
 
+static int date_get_month(const char **pp) {
+    int i = 0;
+    for (; i < 12; i++) {
+        if (!av_strncasecmp(*pp, months[i], 3)) {
+            const char *mo_full = months[i] + 3;
+            int len = strlen(mo_full);
+            *pp += 3;
+            if (len > 0 && !av_strncasecmp(*pp, mo_full, len))
+                *pp += len;
+            return i;
+        }
+    }
+    return -1;
+}
+
 char *av_small_strptime(const char *p, const char *fmt, struct tm *dt)
 {
     int c, val;
@@ -525,6 +545,14 @@ char *av_small_strptime(const char *p, const char *fmt, struct tm *dt)
             if (!p)
                 return NULL;
             break;
+        case 'b':
+        case 'B':
+        case 'h':
+            val = date_get_month(&p);
+            if (val == -1)
+                return NULL;
+            dt->tm_mon = val;
+            break;
         case '%':
             if (*p++ != '%')
                 return NULL;
diff --git a/mythtv/external/FFmpeg/libavutil/pixdesc.c b/mythtv/external/FFmpeg/libavutil/pixdesc.c
index b715fce15dc..2cfab89c030 100644
--- a/mythtv/external/FFmpeg/libavutil/pixdesc.c
+++ b/mythtv/external/FFmpeg/libavutil/pixdesc.c
@@ -560,6 +560,69 @@ static const AVPixFmtDescriptor av_pix_fmt_descriptors[AV_PIX_FMT_NB] = {
         },
         .flags = AV_PIX_FMT_FLAG_RGB,
     },
+    [AV_PIX_FMT_GRAY9BE] = {
+        .name = "gray9be",
+        .nb_components = 1,
+        .log2_chroma_w = 0,
+        .log2_chroma_h = 0,
+        .comp = {
+            { 0, 2, 0, 0, 9, 1, 8, 1 },       /* Y */
+        },
+        .flags = AV_PIX_FMT_FLAG_BE,
+        .alias = "y9be",
+    },
+    [AV_PIX_FMT_GRAY9LE] = {
+        .name = "gray9le",
+        .nb_components = 1,
+        .log2_chroma_w = 0,
+        .log2_chroma_h = 0,
+        .comp = {
+            { 0, 2, 0, 0, 9, 1, 8, 1 },       /* Y */
+        },
+        .alias = "y9le",
+    },
+    [AV_PIX_FMT_GRAY10BE] = {
+        .name = "gray10be",
+        .nb_components = 1,
+        .log2_chroma_w = 0,
+        .log2_chroma_h = 0,
+        .comp = {
+            { 0, 2, 0, 0, 10, 1, 9, 1 },       /* Y */
+        },
+        .flags = AV_PIX_FMT_FLAG_BE,
+        .alias = "y10be",
+    },
+    [AV_PIX_FMT_GRAY10LE] = {
+        .name = "gray10le",
+        .nb_components = 1,
+        .log2_chroma_w = 0,
+        .log2_chroma_h = 0,
+        .comp = {
+            { 0, 2, 0, 0, 10, 1, 9, 1 },       /* Y */
+        },
+        .alias = "y10le",
+    },
+    [AV_PIX_FMT_GRAY12BE] = {
+        .name = "gray12be",
+        .nb_components = 1,
+        .log2_chroma_w = 0,
+        .log2_chroma_h = 0,
+        .comp = {
+            { 0, 2, 0, 0, 12, 1, 11, 1 },       /* Y */
+        },
+        .flags = AV_PIX_FMT_FLAG_BE,
+        .alias = "y12be",
+    },
+    [AV_PIX_FMT_GRAY12LE] = {
+        .name = "gray12le",
+        .nb_components = 1,
+        .log2_chroma_w = 0,
+        .log2_chroma_h = 0,
+        .comp = {
+            { 0, 2, 0, 0, 12, 1, 11, 1 },       /* Y */
+        },
+        .alias = "y12le",
+    },
     [AV_PIX_FMT_GRAY16BE] = {
         .name = "gray16be",
         .nb_components = 1,
@@ -1873,62 +1936,62 @@ static const AVPixFmtDescriptor av_pix_fmt_descriptors[AV_PIX_FMT_NB] = {
     [AV_PIX_FMT_BAYER_BGGR8] = {
         .name = "bayer_bggr8",
         BAYER8_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_BAYER_BGGR16LE] = {
         .name = "bayer_bggr16le",
         BAYER16_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_BAYER_BGGR16BE] = {
         .name = "bayer_bggr16be",
         BAYER16_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_BAYER_RGGB8] = {
         .name = "bayer_rggb8",
         BAYER8_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_BAYER_RGGB16LE] = {
         .name = "bayer_rggb16le",
         BAYER16_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_BAYER_RGGB16BE] = {
         .name = "bayer_rggb16be",
         BAYER16_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_BAYER_GBRG8] = {
         .name = "bayer_gbrg8",
         BAYER8_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_BAYER_GBRG16LE] = {
         .name = "bayer_gbrg16le",
         BAYER16_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_BAYER_GBRG16BE] = {
         .name = "bayer_gbrg16be",
         BAYER16_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_BAYER_GRBG8] = {
         .name = "bayer_grbg8",
         BAYER8_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_BAYER_GRBG16LE] = {
         .name = "bayer_grbg16le",
         BAYER16_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_BAYER_GRBG16BE] = {
         .name = "bayer_grbg16be",
         BAYER16_DESC_COMMON
-        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
+        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_BAYER,
     },
     [AV_PIX_FMT_NV16] = {
         .name = "nv16",
@@ -2036,6 +2099,30 @@ static const AVPixFmtDescriptor av_pix_fmt_descriptors[AV_PIX_FMT_NB] = {
         },
         .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_BE,
     },
+    [AV_PIX_FMT_P016LE] = {
+        .name = "p016le",
+        .nb_components = 3,
+        .log2_chroma_w = 1,
+        .log2_chroma_h = 1,
+        .comp = {
+            { 0, 2, 0, 0, 16, 1, 15, 1 },       /* Y */
+            { 1, 4, 0, 0, 16, 3, 15, 1 },       /* U */
+            { 1, 4, 2, 0, 16, 3, 15, 3 },       /* V */
+        },
+        .flags = AV_PIX_FMT_FLAG_PLANAR,
+    },
+    [AV_PIX_FMT_P016BE] = {
+        .name = "p016be",
+        .nb_components = 3,
+        .log2_chroma_w = 1,
+        .log2_chroma_h = 1,
+        .comp = {
+            { 0, 2, 0, 0, 16, 1, 15, 1 },       /* Y */
+            { 1, 4, 0, 0, 16, 3, 15, 1 },       /* U */
+            { 1, 4, 2, 0, 16, 3, 15, 3 },       /* V */
+        },
+        .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_BE,
+    },
     [AV_PIX_FMT_GBRAP12LE] = {
         .name = "gbrap12le",
         .nb_components = 4,
@@ -2092,18 +2179,80 @@ static const AVPixFmtDescriptor av_pix_fmt_descriptors[AV_PIX_FMT_NB] = {
         .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR |
                  AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_ALPHA,
     },
+    [AV_PIX_FMT_D3D11] = {
+        .name = "d3d11",
+        .flags = AV_PIX_FMT_FLAG_HWACCEL,
+    },
+    [AV_PIX_FMT_GBRPF32BE] = {
+        .name = "gbrpf32be",
+        .nb_components = 3,
+        .log2_chroma_w = 0,
+        .log2_chroma_h = 0,
+        .comp = {
+            { 2, 4, 0, 0, 32, 3, 31, 1 },        /* R */
+            { 0, 4, 0, 0, 32, 3, 31, 1 },        /* G */
+            { 1, 4, 0, 0, 32, 3, 31, 1 },        /* B */
+        },
+        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR |
+                 AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_FLOAT,
+    },
+    [AV_PIX_FMT_GBRPF32LE] = {
+        .name = "gbrpf32le",
+        .nb_components = 3,
+        .log2_chroma_w = 0,
+        .log2_chroma_h = 0,
+        .comp = {
+            { 2, 4, 0, 0, 32, 3, 31, 1 },        /* R */
+            { 0, 4, 0, 0, 32, 3, 31, 1 },        /* G */
+            { 1, 4, 0, 0, 32, 3, 31, 1 },        /* B */
+        },
+        .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_FLOAT | AV_PIX_FMT_FLAG_RGB,
+    },
+    [AV_PIX_FMT_GBRAPF32BE] = {
+        .name = "gbrapf32be",
+        .nb_components = 4,
+        .log2_chroma_w = 0,
+        .log2_chroma_h = 0,
+        .comp = {
+            { 2, 4, 0, 0, 32, 3, 31, 1 },        /* R */
+            { 0, 4, 0, 0, 32, 3, 31, 1 },        /* G */
+            { 1, 4, 0, 0, 32, 3, 31, 1 },        /* B */
+            { 3, 4, 0, 0, 32, 3, 31, 1 },        /* A */
+        },
+        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR |
+                 AV_PIX_FMT_FLAG_ALPHA | AV_PIX_FMT_FLAG_RGB |
+                 AV_PIX_FMT_FLAG_FLOAT,
+    },
+    [AV_PIX_FMT_GBRAPF32LE] = {
+        .name = "gbrapf32le",
+        .nb_components = 4,
+        .log2_chroma_w = 0,
+        .log2_chroma_h = 0,
+        .comp = {
+            { 2, 4, 0, 0, 32, 3, 31, 1 },        /* R */
+            { 0, 4, 0, 0, 32, 3, 31, 1 },        /* G */
+            { 1, 4, 0, 0, 32, 3, 31, 1 },        /* B */
+            { 3, 4, 0, 0, 32, 3, 31, 1 },        /* A */
+        },
+        .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_ALPHA |
+                 AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_FLOAT,
+    },
+    [AV_PIX_FMT_DRM_PRIME] = {
+        .name = "drm_prime",
+        .flags = AV_PIX_FMT_FLAG_HWACCEL,
+    },
 };
 #if FF_API_PLUS1_MINUS1
 FF_ENABLE_DEPRECATION_WARNINGS
 #endif
 
-static const char *color_range_names[] = {
+static const char * const color_range_names[] = {
     [AVCOL_RANGE_UNSPECIFIED] = "unknown",
     [AVCOL_RANGE_MPEG] = "tv",
     [AVCOL_RANGE_JPEG] = "pc",
 };
 
-static const char *color_primaries_names[AVCOL_PRI_NB] = {
+static const char * const color_primaries_names[AVCOL_PRI_NB] = {
     [AVCOL_PRI_RESERVED0] = "reserved",
     [AVCOL_PRI_BT709] = "bt709",
     [AVCOL_PRI_UNSPECIFIED] = "unknown",
@@ -2114,12 +2263,13 @@ static const char *color_primaries_names[AVCOL_PRI_NB] = {
     [AVCOL_PRI_SMPTE240M] = "smpte240m",
     [AVCOL_PRI_FILM] = "film",
     [AVCOL_PRI_BT2020] = "bt2020",
-    [AVCOL_PRI_SMPTEST428_1] = "smpte428-1",
+    [AVCOL_PRI_SMPTE428] = "smpte428",
     [AVCOL_PRI_SMPTE431] = "smpte431",
     [AVCOL_PRI_SMPTE432] = "smpte432",
+    [AVCOL_PRI_JEDEC_P22] = "jedec-p22",
 };
 
-static const char *color_transfer_names[] = {
+static const char * const color_transfer_names[] = {
     [AVCOL_TRC_RESERVED0] = "reserved",
     [AVCOL_TRC_BT709] = "bt709",
     [AVCOL_TRC_UNSPECIFIED] = "unknown",
@@ -2135,13 +2285,13 @@ static const char *color_transfer_names[] = {
     [AVCOL_TRC_BT1361_ECG] = "bt1361e",
     [AVCOL_TRC_IEC61966_2_1] = "iec61966-2-1",
     [AVCOL_TRC_BT2020_10] = "bt2020-10",
-    [AVCOL_TRC_BT2020_12] = "bt2020-20",
-    [AVCOL_TRC_SMPTEST2084] = "smpte2084",
-    [AVCOL_TRC_SMPTEST428_1] = "smpte428-1",
+    [AVCOL_TRC_BT2020_12] = "bt2020-12",
+    [AVCOL_TRC_SMPTE2084] = "smpte2084",
+    [AVCOL_TRC_SMPTE428] = "smpte428",
     [AVCOL_TRC_ARIB_STD_B67] = "arib-std-b67",
 };
 
-static const char *color_space_names[] = {
+static const char * const color_space_names[] = {
     [AVCOL_SPC_RGB] = "gbr",
     [AVCOL_SPC_BT709] = "bt709",
     [AVCOL_SPC_UNSPECIFIED] = "unknown",
@@ -2150,13 +2300,16 @@ static const char *color_space_names[] = {
     [AVCOL_SPC_BT470BG] = "bt470bg",
     [AVCOL_SPC_SMPTE170M] = "smpte170m",
     [AVCOL_SPC_SMPTE240M] = "smpte240m",
-    [AVCOL_SPC_YCOCG] = "ycgco",
+    [AVCOL_SPC_YCGCO] = "ycgco",
     [AVCOL_SPC_BT2020_NCL] = "bt2020nc",
     [AVCOL_SPC_BT2020_CL] = "bt2020c",
     [AVCOL_SPC_SMPTE2085] = "smpte2085",
+    [AVCOL_SPC_CHROMA_DERIVED_NCL] = "chroma-derived-nc",
+    [AVCOL_SPC_CHROMA_DERIVED_CL] = "chroma-derived-c",
+    [AVCOL_SPC_ICTCP] = "ictcp",
 };
 
-static const char *chroma_location_names[] = {
+static const char * const chroma_location_names[] = {
     [AVCHROMA_LOC_UNSPECIFIED] = "unspecified",
     [AVCHROMA_LOC_LEFT] = "left",
     [AVCHROMA_LOC_CENTER] = "center",
@@ -2349,7 +2502,7 @@ void ff_check_pixfmt_descriptors(void){
             } else {
                 av_assert0(8*c->step >= c->depth);
             }
-            if (!strncmp(d->name, "bayer_", 6))
+            if (d->flags & AV_PIX_FMT_FLAG_BAYER)
                 continue;
             av_read_image_line(tmp, (void*)data, linesize, d, 0, 0, j, 2, 0);
             av_assert0(tmp[0] == 0 && tmp[1] == 0);
@@ -2440,8 +2593,16 @@ static int get_pix_fmt_score(enum AVPixelFormat dst_pix_fmt,
     int ret, loss, i, nb_components;
     int score = INT_MAX - 1;
 
-    if (dst_pix_fmt >= AV_PIX_FMT_NB || dst_pix_fmt <= AV_PIX_FMT_NONE)
-        return ~0;
+    if (!src_desc || !dst_desc)
+        return -4;
+
+    if ((src_desc->flags & AV_PIX_FMT_FLAG_HWACCEL) ||
+        (dst_desc->flags & AV_PIX_FMT_FLAG_HWACCEL)) {
+        if (dst_pix_fmt == src_pix_fmt)
+            return -1;
+        else
+            return -2;
+    }
 
     /* compute loss */
     *lossp = loss = 0;
@@ -2450,9 +2611,9 @@ static int get_pix_fmt_score(enum AVPixelFormat dst_pix_fmt,
         return INT_MAX;
 
     if ((ret = get_pix_fmt_depth(&src_min_depth, &src_max_depth, src_pix_fmt)) < 0)
-        return ret;
+        return -3;
     if ((ret = get_pix_fmt_depth(&dst_min_depth, &dst_max_depth, dst_pix_fmt)) < 0)
-        return ret;
+        return -3;
 
     src_color = get_color_type(src_desc);
     dst_color = get_color_type(dst_desc);
@@ -2554,21 +2715,27 @@ enum AVPixelFormat av_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, en
     const AVPixFmtDescriptor *desc2 = av_pix_fmt_desc_get(dst_pix_fmt2);
     int score1, score2;
 
-    loss_mask= loss_ptr?~*loss_ptr:~0; /* use loss mask if provided */
-    if(!has_alpha)
-        loss_mask &= ~FF_LOSS_ALPHA;
+    if (!desc1) {
+        dst_pix_fmt = dst_pix_fmt2;
+    } else if (!desc2) {
+        dst_pix_fmt = dst_pix_fmt1;
+    } else {
+        loss_mask= loss_ptr?~*loss_ptr:~0; /* use loss mask if provided */
+        if(!has_alpha)
+            loss_mask &= ~FF_LOSS_ALPHA;
 
-    score1 = get_pix_fmt_score(dst_pix_fmt1, src_pix_fmt, &loss1, loss_mask);
-    score2 = get_pix_fmt_score(dst_pix_fmt2, src_pix_fmt, &loss2, loss_mask);
+        score1 = get_pix_fmt_score(dst_pix_fmt1, src_pix_fmt, &loss1, loss_mask);
+        score2 = get_pix_fmt_score(dst_pix_fmt2, src_pix_fmt, &loss2, loss_mask);
 
-    if (score1 == score2) {
-        if(av_get_padded_bits_per_pixel(desc2) != av_get_padded_bits_per_pixel(desc1)) {
-            dst_pix_fmt = av_get_padded_bits_per_pixel(desc2) < av_get_padded_bits_per_pixel(desc1) ? dst_pix_fmt2 : dst_pix_fmt1;
+        if (score1 == score2) {
+            if(av_get_padded_bits_per_pixel(desc2) != av_get_padded_bits_per_pixel(desc1)) {
+                dst_pix_fmt = av_get_padded_bits_per_pixel(desc2) < av_get_padded_bits_per_pixel(desc1) ? dst_pix_fmt2 : dst_pix_fmt1;
+            } else {
+                dst_pix_fmt = desc2->nb_components < desc1->nb_components ? dst_pix_fmt2 : dst_pix_fmt1;
+            }
         } else {
-            dst_pix_fmt = desc2->nb_components < desc1->nb_components ? dst_pix_fmt2 : dst_pix_fmt1;
+            dst_pix_fmt = score1 < score2 ? dst_pix_fmt2 : dst_pix_fmt1;
         }
-    } else {
-        dst_pix_fmt = score1 < score2 ? dst_pix_fmt2 : dst_pix_fmt1;
     }
 
     if (loss_ptr)
@@ -2582,26 +2749,91 @@ const char *av_color_range_name(enum AVColorRange range)
         color_range_names[range] : NULL;
 }
 
+int av_color_range_from_name(const char *name)
+{
+    int i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(color_range_names); i++) {
+        size_t len = strlen(color_range_names[i]);
+        if (!strncmp(color_range_names[i], name, len))
+            return i;
+    }
+
+    return AVERROR(EINVAL);
+}
+
 const char *av_color_primaries_name(enum AVColorPrimaries primaries)
 {
     return (unsigned) primaries < AVCOL_PRI_NB ?
         color_primaries_names[primaries] : NULL;
 }
 
+int av_color_primaries_from_name(const char *name)
+{
+    int i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(color_primaries_names); i++) {
+        size_t len = strlen(color_primaries_names[i]);
+        if (!strncmp(color_primaries_names[i], name, len))
+            return i;
+    }
+
+    return AVERROR(EINVAL);
+}
+
 const char *av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
 {
     return (unsigned) transfer < AVCOL_TRC_NB ?
         color_transfer_names[transfer] : NULL;
 }
 
+int av_color_transfer_from_name(const char *name)
+{
+    int i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(color_transfer_names); i++) {
+        size_t len = strlen(color_transfer_names[i]);
+        if (!strncmp(color_transfer_names[i], name, len))
+            return i;
+    }
+
+    return AVERROR(EINVAL);
+}
+
 const char *av_color_space_name(enum AVColorSpace space)
 {
     return (unsigned) space < AVCOL_SPC_NB ?
         color_space_names[space] : NULL;
 }
 
+int av_color_space_from_name(const char *name)
+{
+    int i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(color_space_names); i++) {
+        size_t len = strlen(color_space_names[i]);
+        if (!strncmp(color_space_names[i], name, len))
+            return i;
+    }
+
+    return AVERROR(EINVAL);
+}
+
 const char *av_chroma_location_name(enum AVChromaLocation location)
 {
     return (unsigned) location < AVCHROMA_LOC_NB ?
         chroma_location_names[location] : NULL;
 }
+
+int av_chroma_location_from_name(const char *name)
+{
+    int i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(chroma_location_names); i++) {
+        size_t len = strlen(chroma_location_names[i]);
+        if (!strncmp(chroma_location_names[i], name, len))
+            return i;
+    }
+
+    return AVERROR(EINVAL);
+}
diff --git a/mythtv/external/FFmpeg/libavutil/pixdesc.h b/mythtv/external/FFmpeg/libavutil/pixdesc.h
index a8ad588913c..fc3737c4ade 100644
--- a/mythtv/external/FFmpeg/libavutil/pixdesc.h
+++ b/mythtv/external/FFmpeg/libavutil/pixdesc.h
@@ -172,6 +172,17 @@ typedef struct AVPixFmtDescriptor {
  */
 #define AV_PIX_FMT_FLAG_ALPHA        (1 << 7)
 
+/**
+ * The pixel format is following a Bayer pattern
+ */
+#define AV_PIX_FMT_FLAG_BAYER        (1 << 8)
+
+/**
+ * The pixel format contains IEEE-754 floating point values. Precision (double,
+ * single, or half) should be determined by the pixel size (64, 32, or 16 bits).
+ */
+#define AV_PIX_FMT_FLAG_FLOAT        (1 << 9)
+
 /**
  * Return the number of bits per pixel used by the pixel format
  * described by pixdesc. Note that this is not the same as the number
@@ -239,26 +250,51 @@ int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt);
  */
 const char *av_color_range_name(enum AVColorRange range);
 
+/**
+ * @return the AVColorRange value for name or an AVError if not found.
+ */
+int av_color_range_from_name(const char *name);
+
 /**
  * @return the name for provided color primaries or NULL if unknown.
  */
 const char *av_color_primaries_name(enum AVColorPrimaries primaries);
 
+/**
+ * @return the AVColorPrimaries value for name or an AVError if not found.
+ */
+int av_color_primaries_from_name(const char *name);
+
 /**
  * @return the name for provided color transfer or NULL if unknown.
  */
 const char *av_color_transfer_name(enum AVColorTransferCharacteristic transfer);
 
+/**
+ * @return the AVColorTransferCharacteristic value for name or an AVError if not found.
+ */
+int av_color_transfer_from_name(const char *name);
+
 /**
  * @return the name for provided color space or NULL if unknown.
  */
 const char *av_color_space_name(enum AVColorSpace space);
 
+/**
+ * @return the AVColorSpace value for name or an AVError if not found.
+ */
+int av_color_space_from_name(const char *name);
+
 /**
  * @return the name for provided chroma location or NULL if unknown.
  */
 const char *av_chroma_location_name(enum AVChromaLocation location);
 
+/**
+ * @return the AVChromaLocation value for name or an AVError if not found.
+ */
+int av_chroma_location_from_name(const char *name);
+
 /**
  * Return the pixel format corresponding to name.
  *
diff --git a/mythtv/external/FFmpeg/libavutil/pixfmt.h b/mythtv/external/FFmpeg/libavutil/pixfmt.h
index 7a3f68be7e2..24889c8e528 100644
--- a/mythtv/external/FFmpeg/libavutil/pixfmt.h
+++ b/mythtv/external/FFmpeg/libavutil/pixfmt.h
@@ -240,7 +240,7 @@ enum AVPixelFormat {
      */
     AV_PIX_FMT_MMAL,
 
-    AV_PIX_FMT_D3D11VA_VLD,  ///< HW decoding through Direct3D11, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer
+    AV_PIX_FMT_D3D11VA_VLD,  ///< HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer
 
     /**
      * HW acceleration through CUDA. data[i] contain CUdeviceptr pointers
@@ -306,6 +306,41 @@ enum AVPixelFormat {
 
     AV_PIX_FMT_MEDIACODEC, ///< hardware decoding through MediaCodec
 
+    AV_PIX_FMT_GRAY12BE,   ///<        Y        , 12bpp, big-endian
+    AV_PIX_FMT_GRAY12LE,   ///<        Y        , 12bpp, little-endian
+    AV_PIX_FMT_GRAY10BE,   ///<        Y        , 10bpp, big-endian
+    AV_PIX_FMT_GRAY10LE,   ///<        Y        , 10bpp, little-endian
+
+    AV_PIX_FMT_P016LE, ///< like NV12, with 16bpp per component, little-endian
+    AV_PIX_FMT_P016BE, ///< like NV12, with 16bpp per component, big-endian
+
+    /**
+     * Hardware surfaces for Direct3D11.
+     *
+     * This is preferred over the legacy AV_PIX_FMT_D3D11VA_VLD. The new D3D11
+     * hwaccel API and filtering support AV_PIX_FMT_D3D11 only.
+     *
+     * data[0] contains a ID3D11Texture2D pointer, and data[1] contains the
+     * texture array index of the frame as intptr_t if the ID3D11Texture2D is
+     * an array texture (or always 0 if it's a normal texture).
+     */
+    AV_PIX_FMT_D3D11,
+
+    AV_PIX_FMT_GRAY9BE,   ///<        Y        , 9bpp, big-endian
+    AV_PIX_FMT_GRAY9LE,   ///<        Y        , 9bpp, little-endian
+
+    AV_PIX_FMT_GBRPF32BE,  ///< IEEE-754 single precision planar GBR 4:4:4,     96bpp, big-endian
+    AV_PIX_FMT_GBRPF32LE,  ///< IEEE-754 single precision planar GBR 4:4:4,     96bpp, little-endian
+    AV_PIX_FMT_GBRAPF32BE, ///< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian
+    AV_PIX_FMT_GBRAPF32LE, ///< IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian
+
+    /**
+     * DRM-managed buffers exposed through PRIME buffer sharing.
+     *
+     * data[0] points to an AVDRMFrameDescriptor.
+     */
+    AV_PIX_FMT_DRM_PRIME,
+
     AV_PIX_FMT_NB         ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
 };
 
@@ -322,6 +357,9 @@ enum AVPixelFormat {
 #define AV_PIX_FMT_0RGB32  AV_PIX_FMT_NE(0RGB, BGR0)
 #define AV_PIX_FMT_0BGR32  AV_PIX_FMT_NE(0BGR, RGB0)
 
+#define AV_PIX_FMT_GRAY9  AV_PIX_FMT_NE(GRAY9BE,  GRAY9LE)
+#define AV_PIX_FMT_GRAY10 AV_PIX_FMT_NE(GRAY10BE, GRAY10LE)
+#define AV_PIX_FMT_GRAY12 AV_PIX_FMT_NE(GRAY12BE, GRAY12LE)
 #define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE)
 #define AV_PIX_FMT_YA16   AV_PIX_FMT_NE(YA16BE,   YA16LE)
 #define AV_PIX_FMT_RGB48  AV_PIX_FMT_NE(RGB48BE,  RGB48LE)
@@ -367,6 +405,8 @@ enum AVPixelFormat {
 #define AV_PIX_FMT_BAYER_GBRG16 AV_PIX_FMT_NE(BAYER_GBRG16BE,    BAYER_GBRG16LE)
 #define AV_PIX_FMT_BAYER_GRBG16 AV_PIX_FMT_NE(BAYER_GRBG16BE,    BAYER_GRBG16LE)
 
+#define AV_PIX_FMT_GBRPF32    AV_PIX_FMT_NE(GBRPF32BE,  GBRPF32LE)
+#define AV_PIX_FMT_GBRAPF32   AV_PIX_FMT_NE(GBRAPF32BE, GBRAPF32LE)
 
 #define AV_PIX_FMT_YUVA420P9  AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE)
 #define AV_PIX_FMT_YUVA422P9  AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE)
@@ -382,9 +422,11 @@ enum AVPixelFormat {
 #define AV_PIX_FMT_NV20       AV_PIX_FMT_NE(NV20BE,  NV20LE)
 #define AV_PIX_FMT_AYUV64     AV_PIX_FMT_NE(AYUV64BE, AYUV64LE)
 #define AV_PIX_FMT_P010       AV_PIX_FMT_NE(P010BE,  P010LE)
+#define AV_PIX_FMT_P016       AV_PIX_FMT_NE(P016BE,  P016LE)
 
 /**
   * Chromaticity coordinates of the source primaries.
+  * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.1.
   */
 enum AVColorPrimaries {
     AVCOL_PRI_RESERVED0   = 0,
@@ -398,14 +440,17 @@ enum AVColorPrimaries {
     AVCOL_PRI_SMPTE240M   = 7,  ///< functionally identical to above
     AVCOL_PRI_FILM        = 8,  ///< colour filters using Illuminant C
     AVCOL_PRI_BT2020      = 9,  ///< ITU-R BT2020
-    AVCOL_PRI_SMPTEST428_1 = 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ)
-    AVCOL_PRI_SMPTE431    = 11, ///< SMPTE ST 431-2 (2011)
-    AVCOL_PRI_SMPTE432    = 12, ///< SMPTE ST 432-1 D65 (2010)
+    AVCOL_PRI_SMPTE428    = 10, ///< SMPTE ST 428-1 (CIE 1931 XYZ)
+    AVCOL_PRI_SMPTEST428_1 = AVCOL_PRI_SMPTE428,
+    AVCOL_PRI_SMPTE431    = 11, ///< SMPTE ST 431-2 (2011) / DCI P3
+    AVCOL_PRI_SMPTE432    = 12, ///< SMPTE ST 432-1 (2010) / P3 D65 / Display P3
+    AVCOL_PRI_JEDEC_P22   = 22, ///< JEDEC P22 phosphors
     AVCOL_PRI_NB                ///< Not part of ABI
 };
 
 /**
  * Color Transfer Characteristic.
+ * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.2.
  */
 enum AVColorTransferCharacteristic {
     AVCOL_TRC_RESERVED0    = 0,
@@ -424,14 +469,17 @@ enum AVColorTransferCharacteristic {
     AVCOL_TRC_IEC61966_2_1 = 13, ///< IEC 61966-2-1 (sRGB or sYCC)
     AVCOL_TRC_BT2020_10    = 14, ///< ITU-R BT2020 for 10-bit system
     AVCOL_TRC_BT2020_12    = 15, ///< ITU-R BT2020 for 12-bit system
-    AVCOL_TRC_SMPTEST2084  = 16, ///< SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems
-    AVCOL_TRC_SMPTEST428_1 = 17, ///< SMPTE ST 428-1
+    AVCOL_TRC_SMPTE2084    = 16, ///< SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems
+    AVCOL_TRC_SMPTEST2084  = AVCOL_TRC_SMPTE2084,
+    AVCOL_TRC_SMPTE428     = 17, ///< SMPTE ST 428-1
+    AVCOL_TRC_SMPTEST428_1 = AVCOL_TRC_SMPTE428,
     AVCOL_TRC_ARIB_STD_B67 = 18, ///< ARIB STD-B67, known as "Hybrid log-gamma"
     AVCOL_TRC_NB                 ///< Not part of ABI
 };
 
 /**
  * YUV colorspace type.
+ * These values match the ones defined by ISO/IEC 23001-8_2013 § 7.3.
  */
 enum AVColorSpace {
     AVCOL_SPC_RGB         = 0,  ///< order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
@@ -442,14 +490,16 @@ enum AVColorSpace {
     AVCOL_SPC_BT470BG     = 5,  ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
     AVCOL_SPC_SMPTE170M   = 6,  ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
     AVCOL_SPC_SMPTE240M   = 7,  ///< functionally identical to above
-    AVCOL_SPC_YCOCG       = 8,  ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
+    AVCOL_SPC_YCGCO       = 8,  ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
+    AVCOL_SPC_YCOCG       = AVCOL_SPC_YCGCO,
     AVCOL_SPC_BT2020_NCL  = 9,  ///< ITU-R BT2020 non-constant luminance system
     AVCOL_SPC_BT2020_CL   = 10, ///< ITU-R BT2020 constant luminance system
     AVCOL_SPC_SMPTE2085   = 11, ///< SMPTE 2085, Y'D'zD'x
+    AVCOL_SPC_CHROMA_DERIVED_NCL = 12, ///< Chromaticity-derived non-constant luminance system
+    AVCOL_SPC_CHROMA_DERIVED_CL = 13, ///< Chromaticity-derived constant luminance system
+    AVCOL_SPC_ICTCP       = 14, ///< ITU-R BT.2100-0, ICtCp
     AVCOL_SPC_NB                ///< Not part of ABI
 };
-#define AVCOL_SPC_YCGCO AVCOL_SPC_YCOCG
-
 
 /**
  * MPEG vs JPEG YUV range.
diff --git a/mythtv/external/FFmpeg/libavutil/ppc/cpu.c b/mythtv/external/FFmpeg/libavutil/ppc/cpu.c
index 0f1e9826245..7bb7cd813c9 100644
--- a/mythtv/external/FFmpeg/libavutil/ppc/cpu.c
+++ b/mythtv/external/FFmpeg/libavutil/ppc/cpu.c
@@ -148,3 +148,15 @@ int ff_get_cpu_flags_ppc(void)
 #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 --git a/mythtv/external/FFmpeg/libavutil/ppc/types_altivec.h b/mythtv/external/FFmpeg/libavutil/ppc/types_altivec.h
deleted file mode 100644
index 69d89575094..00000000000
--- a/mythtv/external/FFmpeg/libavutil/ppc/types_altivec.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2006 Guillaume Poirier <gpoirier@mplayerhq.hu>
- *
- * 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_TYPES_ALTIVEC_H
-#define AVUTIL_PPC_TYPES_ALTIVEC_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
-
-#endif /* AVUTIL_PPC_TYPES_ALTIVEC_H */
diff --git a/mythtv/external/FFmpeg/libavutil/ppc/util_altivec.h b/mythtv/external/FFmpeg/libavutil/ppc/util_altivec.h
index 55277400106..6ab7e5083ff 100644
--- a/mythtv/external/FFmpeg/libavutil/ppc/util_altivec.h
+++ b/mythtv/external/FFmpeg/libavutil/ppc/util_altivec.h
@@ -32,7 +32,28 @@
 #include <altivec.h>
 #endif
 
-#include "types_altivec.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
 
diff --git a/mythtv/external/FFmpeg/libavutil/random_seed.c b/mythtv/external/FFmpeg/libavutil/random_seed.c
index d1ded7b5096..d1c9a3f7046 100644
--- a/mythtv/external/FFmpeg/libavutil/random_seed.c
+++ b/mythtv/external/FFmpeg/libavutil/random_seed.c
@@ -64,9 +64,11 @@ static int read_random(uint32_t *dst, const char *file)
 
 static uint32_t get_generic_seed(void)
 {
-    uint8_t tmp[120];
+    uint64_t tmp[120/8];
     struct AVSHA *sha = (void*)tmp;
     clock_t last_t  = 0;
+    clock_t last_td = 0;
+    clock_t init_t = 0;
     static uint64_t i = 0;
     static uint32_t buffer[512] = { 0 };
     unsigned char digest[20];
@@ -86,15 +88,19 @@ static uint32_t get_generic_seed(void)
 
     for (;;) {
         clock_t t = clock();
-
-        if (last_t == t) {
-            buffer[i & 511]++;
+        if (last_t + 2*last_td + (CLOCKS_PER_SEC > 1000) >= t) {
+            last_td = t - last_t;
+            buffer[i & 511] = 1664525*buffer[i & 511] + 1013904223 + (last_td % 3294638521U);
         } else {
-            buffer[++i & 511] += (t - last_t) % 3294638521U;
-            if (last_i && i - last_i > 4 || i - last_i > 64 || TEST && i - last_i > 8)
-                break;
+            last_td = t - last_t;
+            buffer[++i & 511] += last_td % 3294638521U;
+            if ((t - init_t) >= CLOCKS_PER_SEC>>5)
+                if (last_i && i - last_i > 4 || i - last_i > 64 || TEST && i - last_i > 8)
+                    break;
         }
         last_t = t;
+        if (!init_t)
+            init_t = t;
     }
 
     if(TEST) {
diff --git a/mythtv/external/FFmpeg/libavutil/reverse.h b/mythtv/external/FFmpeg/libavutil/reverse.h
new file mode 100644
index 00000000000..4eb61239328
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/reverse.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * 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_REVERSE_H
+#define AVUTIL_REVERSE_H
+
+#include <stdint.h>
+
+extern const uint8_t ff_reverse[256];
+
+#endif /* AVUTIL_REVERSE_H */
diff --git a/mythtv/external/FFmpeg/libavutil/sha.c b/mythtv/external/FFmpeg/libavutil/sha.c
index 5b42ccf1b2f..ef6fa442274 100644
--- a/mythtv/external/FFmpeg/libavutil/sha.c
+++ b/mythtv/external/FFmpeg/libavutil/sha.c
@@ -311,7 +311,11 @@ av_cold int av_sha_init(AVSHA *ctx, int bits)
     return 0;
 }
 
-void av_sha_update(AVSHA* ctx, const uint8_t* data, unsigned int len)
+#if FF_API_CRYPTO_SIZE_T
+void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len)
+#else
+void av_sha_update(struct AVSHA *ctx, const uint8_t *data, size_t len)
+#endif
 {
     unsigned int i, j;
 
diff --git a/mythtv/external/FFmpeg/libavutil/sha.h b/mythtv/external/FFmpeg/libavutil/sha.h
index c7558a89646..c0180e5729a 100644
--- a/mythtv/external/FFmpeg/libavutil/sha.h
+++ b/mythtv/external/FFmpeg/libavutil/sha.h
@@ -27,6 +27,7 @@
 #ifndef AVUTIL_SHA_H
 #define AVUTIL_SHA_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "attributes.h"
@@ -69,11 +70,15 @@ int av_sha_init(struct AVSHA* context, int bits);
 /**
  * Update hash value.
  *
- * @param context hash function context
+ * @param ctx     hash function context
  * @param data    input data to update hash with
  * @param len     input data length
  */
-void av_sha_update(struct AVSHA* context, const uint8_t* data, unsigned int len);
+#if FF_API_CRYPTO_SIZE_T
+void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len);
+#else
+void av_sha_update(struct AVSHA *ctx, const uint8_t *data, size_t len);
+#endif
 
 /**
  * Finish hashing and output digest value.
diff --git a/mythtv/external/FFmpeg/libavutil/sha512.c b/mythtv/external/FFmpeg/libavutil/sha512.c
index 2c5da255918..6d092a7c5c0 100644
--- a/mythtv/external/FFmpeg/libavutil/sha512.c
+++ b/mythtv/external/FFmpeg/libavutil/sha512.c
@@ -239,7 +239,11 @@ av_cold int av_sha512_init(AVSHA512 *ctx, int bits)
     return 0;
 }
 
+#if FF_API_CRYPTO_SIZE_T
 void av_sha512_update(AVSHA512* ctx, const uint8_t* data, unsigned int len)
+#else
+void av_sha512_update(AVSHA512* ctx, const uint8_t* data, size_t len)
+#endif
 {
     unsigned int i, j;
 
diff --git a/mythtv/external/FFmpeg/libavutil/sha512.h b/mythtv/external/FFmpeg/libavutil/sha512.h
index 5bac184cf3e..bef714b41cf 100644
--- a/mythtv/external/FFmpeg/libavutil/sha512.h
+++ b/mythtv/external/FFmpeg/libavutil/sha512.h
@@ -28,6 +28,7 @@
 #ifndef AVUTIL_SHA512_H
 #define AVUTIL_SHA512_H
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include "attributes.h"
@@ -75,7 +76,11 @@ int av_sha512_init(struct AVSHA512* context, int bits);
  * @param data    input data to update hash with
  * @param len     input data length
  */
+#if FF_API_CRYPTO_SIZE_T
 void av_sha512_update(struct AVSHA512* context, const uint8_t* data, unsigned int len);
+#else
+void av_sha512_update(struct AVSHA512* context, const uint8_t* data, size_t len);
+#endif
 
 /**
  * Finish hashing and output digest value.
diff --git a/mythtv/external/FFmpeg/libavutil/slicethread.c b/mythtv/external/FFmpeg/libavutil/slicethread.c
new file mode 100644
index 00000000000..c43f87a2aa4
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/slicethread.c
@@ -0,0 +1,259 @@
+/*
+ * 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 <stdatomic.h>
+#include "slicethread.h"
+#include "mem.h"
+#include "thread.h"
+#include "avassert.h"
+
+#if HAVE_PTHREADS || HAVE_W32THREADS || HAVE_OS2THREADS
+
+typedef struct WorkerContext {
+    AVSliceThread   *ctx;
+    pthread_mutex_t mutex;
+    pthread_cond_t  cond;
+    pthread_t       thread;
+    int             done;
+} WorkerContext;
+
+struct AVSliceThread {
+    WorkerContext   *workers;
+    int             nb_threads;
+    int             nb_active_threads;
+    int             nb_jobs;
+
+    atomic_uint     first_job;
+    atomic_uint     current_job;
+    pthread_mutex_t done_mutex;
+    pthread_cond_t  done_cond;
+    int             done;
+    int             finished;
+
+    void            *priv;
+    void            (*worker_func)(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads);
+    void            (*main_func)(void *priv);
+};
+
+static int run_jobs(AVSliceThread *ctx)
+{
+    unsigned nb_jobs    = ctx->nb_jobs;
+    unsigned nb_active_threads = ctx->nb_active_threads;
+    unsigned first_job    = atomic_fetch_add_explicit(&ctx->first_job, 1, memory_order_acq_rel);
+    unsigned current_job  = first_job;
+
+    do {
+        ctx->worker_func(ctx->priv, current_job, first_job, nb_jobs, nb_active_threads);
+    } while ((current_job = atomic_fetch_add_explicit(&ctx->current_job, 1, memory_order_acq_rel)) < nb_jobs);
+
+    return current_job == nb_jobs + nb_active_threads - 1;
+}
+
+static void *attribute_align_arg thread_worker(void *v)
+{
+    WorkerContext *w = v;
+    AVSliceThread *ctx = w->ctx;
+
+    pthread_mutex_lock(&w->mutex);
+    pthread_cond_signal(&w->cond);
+
+    while (1) {
+        w->done = 1;
+        while (w->done)
+            pthread_cond_wait(&w->cond, &w->mutex);
+
+        if (ctx->finished) {
+            pthread_mutex_unlock(&w->mutex);
+            return NULL;
+        }
+
+        if (run_jobs(ctx)) {
+            pthread_mutex_lock(&ctx->done_mutex);
+            ctx->done = 1;
+            pthread_cond_signal(&ctx->done_cond);
+            pthread_mutex_unlock(&ctx->done_mutex);
+        }
+    }
+}
+
+int avpriv_slicethread_create(AVSliceThread **pctx, void *priv,
+                              void (*worker_func)(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads),
+                              void (*main_func)(void *priv),
+                              int nb_threads)
+{
+    AVSliceThread *ctx;
+    int nb_workers, i;
+
+#if HAVE_W32THREADS
+    w32thread_init();
+#endif
+
+    av_assert0(nb_threads >= 0);
+    if (!nb_threads) {
+        int nb_cpus = av_cpu_count();
+        if (nb_cpus > 1)
+            nb_threads = nb_cpus + 1;
+        else
+            nb_threads = 1;
+    }
+
+    nb_workers = nb_threads;
+    if (!main_func)
+        nb_workers--;
+
+    *pctx = ctx = av_mallocz(sizeof(*ctx));
+    if (!ctx)
+        return AVERROR(ENOMEM);
+
+    if (nb_workers && !(ctx->workers = av_calloc(nb_workers, sizeof(*ctx->workers)))) {
+        av_freep(pctx);
+        return AVERROR(ENOMEM);
+    }
+
+    ctx->priv        = priv;
+    ctx->worker_func = worker_func;
+    ctx->main_func   = main_func;
+    ctx->nb_threads  = nb_threads;
+    ctx->nb_active_threads = 0;
+    ctx->nb_jobs     = 0;
+    ctx->finished    = 0;
+
+    atomic_init(&ctx->first_job, 0);
+    atomic_init(&ctx->current_job, 0);
+    pthread_mutex_init(&ctx->done_mutex, NULL);
+    pthread_cond_init(&ctx->done_cond, NULL);
+    ctx->done        = 0;
+
+    for (i = 0; i < nb_workers; i++) {
+        WorkerContext *w = &ctx->workers[i];
+        int ret;
+        w->ctx = ctx;
+        pthread_mutex_init(&w->mutex, NULL);
+        pthread_cond_init(&w->cond, NULL);
+        pthread_mutex_lock(&w->mutex);
+        w->done = 0;
+
+        if (ret = pthread_create(&w->thread, NULL, thread_worker, w)) {
+            ctx->nb_threads = main_func ? i : i + 1;
+            pthread_mutex_unlock(&w->mutex);
+            pthread_cond_destroy(&w->cond);
+            pthread_mutex_destroy(&w->mutex);
+            avpriv_slicethread_free(pctx);
+            return AVERROR(ret);
+        }
+
+        while (!w->done)
+            pthread_cond_wait(&w->cond, &w->mutex);
+        pthread_mutex_unlock(&w->mutex);
+    }
+
+    return nb_threads;
+}
+
+void avpriv_slicethread_execute(AVSliceThread *ctx, int nb_jobs, int execute_main)
+{
+    int nb_workers, i, is_last = 0;
+
+    av_assert0(nb_jobs > 0);
+    ctx->nb_jobs           = nb_jobs;
+    ctx->nb_active_threads = FFMIN(nb_jobs, ctx->nb_threads);
+    atomic_store_explicit(&ctx->first_job, 0, memory_order_relaxed);
+    atomic_store_explicit(&ctx->current_job, ctx->nb_active_threads, memory_order_relaxed);
+    nb_workers             = ctx->nb_active_threads;
+    if (!ctx->main_func || !execute_main)
+        nb_workers--;
+
+    for (i = 0; i < nb_workers; i++) {
+        WorkerContext *w = &ctx->workers[i];
+        pthread_mutex_lock(&w->mutex);
+        w->done = 0;
+        pthread_cond_signal(&w->cond);
+        pthread_mutex_unlock(&w->mutex);
+    }
+
+    if (ctx->main_func && execute_main)
+        ctx->main_func(ctx->priv);
+    else
+        is_last = run_jobs(ctx);
+
+    if (!is_last) {
+        pthread_mutex_lock(&ctx->done_mutex);
+        while (!ctx->done)
+            pthread_cond_wait(&ctx->done_cond, &ctx->done_mutex);
+        ctx->done = 0;
+        pthread_mutex_unlock(&ctx->done_mutex);
+    }
+}
+
+void avpriv_slicethread_free(AVSliceThread **pctx)
+{
+    AVSliceThread *ctx;
+    int nb_workers, i;
+
+    if (!pctx || !*pctx)
+        return;
+
+    ctx = *pctx;
+    nb_workers = ctx->nb_threads;
+    if (!ctx->main_func)
+        nb_workers--;
+
+    ctx->finished = 1;
+    for (i = 0; i < nb_workers; i++) {
+        WorkerContext *w = &ctx->workers[i];
+        pthread_mutex_lock(&w->mutex);
+        w->done = 0;
+        pthread_cond_signal(&w->cond);
+        pthread_mutex_unlock(&w->mutex);
+    }
+
+    for (i = 0; i < nb_workers; i++) {
+        WorkerContext *w = &ctx->workers[i];
+        pthread_join(w->thread, NULL);
+        pthread_cond_destroy(&w->cond);
+        pthread_mutex_destroy(&w->mutex);
+    }
+
+    pthread_cond_destroy(&ctx->done_cond);
+    pthread_mutex_destroy(&ctx->done_mutex);
+    av_freep(&ctx->workers);
+    av_freep(pctx);
+}
+
+#else /* HAVE_PTHREADS || HAVE_W32THREADS || HAVE_OS32THREADS */
+
+int avpriv_slicethread_create(AVSliceThread **pctx, void *priv,
+                              void (*worker_func)(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads),
+                              void (*main_func)(void *priv),
+                              int nb_threads)
+{
+    *pctx = NULL;
+    return AVERROR(EINVAL);
+}
+
+void avpriv_slicethread_execute(AVSliceThread *ctx, int nb_jobs, int execute_main)
+{
+    av_assert0(0);
+}
+
+void avpriv_slicethread_free(AVSliceThread **pctx)
+{
+    av_assert0(!pctx || !*pctx);
+}
+
+#endif /* HAVE_PTHREADS || HAVE_W32THREADS || HAVE_OS32THREADS */
diff --git a/mythtv/external/FFmpeg/libavutil/slicethread.h b/mythtv/external/FFmpeg/libavutil/slicethread.h
new file mode 100644
index 00000000000..f6f6f302c44
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/slicethread.h
@@ -0,0 +1,52 @@
+/*
+ * 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_SLICETHREAD_H
+#define AVUTIL_SLICETHREAD_H
+
+typedef struct AVSliceThread AVSliceThread;
+
+/**
+ * Create slice threading context.
+ * @param pctx slice threading context returned here
+ * @param priv private pointer to be passed to callback function
+ * @param worker_func callback function to be executed
+ * @param main_func special callback function, called from main thread, may be NULL
+ * @param nb_threads number of threads, 0 for automatic, must be >= 0
+ * @return return number of threads or negative AVERROR on failure
+ */
+int avpriv_slicethread_create(AVSliceThread **pctx, void *priv,
+                              void (*worker_func)(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads),
+                              void (*main_func)(void *priv),
+                              int nb_threads);
+
+/**
+ * Execute slice threading.
+ * @param ctx slice threading context
+ * @param nb_jobs number of jobs, must be > 0
+ * @param execute_main also execute main_func
+ */
+void avpriv_slicethread_execute(AVSliceThread *ctx, int nb_jobs, int execute_main);
+
+/**
+ * Destroy slice threading context.
+ * @param pctx pointer to context
+ */
+void avpriv_slicethread_free(AVSliceThread **pctx);
+
+#endif
diff --git a/mythtv/external/FFmpeg/libavutil/softfloat.h b/mythtv/external/FFmpeg/libavutil/softfloat.h
index a3b22385853..a651406f749 100644
--- a/mythtv/external/FFmpeg/libavutil/softfloat.h
+++ b/mythtv/external/FFmpeg/libavutil/softfloat.h
@@ -27,7 +27,7 @@
 #include "avassert.h"
 #include "softfloat_tables.h"
 
-#define MIN_EXP -126
+#define MIN_EXP -149
 #define MAX_EXP  126
 #define ONE_BITS 29
 
@@ -43,6 +43,7 @@ static const SoftFloat FLOAT_EPSILON    = { 0x29F16B12, -16};
 static const SoftFloat FLOAT_1584893192 = { 0x32B771ED,   1};                   ///< 1.584893192 (10^.2)
 static const SoftFloat FLOAT_100000     = { 0x30D40000,  17};                   ///< 100000
 static const SoftFloat FLOAT_0999999    = { 0x3FFFFBCE,   0};                   ///< 0.999999
+static const SoftFloat FLOAT_MIN        = { 0x20000000,   MIN_EXP};
 
 
 /**
@@ -50,8 +51,7 @@ static const SoftFloat FLOAT_0999999    = { 0x3FFFFBCE,   0};
  */
 static inline av_const double av_sf2double(SoftFloat v) {
     v.exp -= ONE_BITS +1;
-    if(v.exp > 0) return (double)v.mant * (double)(1 << v.exp);
-    else          return (double)v.mant / (double)(1 << (-v.exp));
+    return ldexp(v.mant, v.exp);
 }
 
 static av_const SoftFloat av_normalize_sf(SoftFloat a){
@@ -114,8 +114,15 @@ static inline av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b){
  * @return Will not be more denormalized than a.
  */
 static inline av_const SoftFloat av_div_sf(SoftFloat a, SoftFloat b){
+    int64_t temp = (int64_t)a.mant * (1<<(ONE_BITS+1));
+    temp /= b.mant;
     a.exp -= b.exp;
-    a.mant = ((int64_t)a.mant<<(ONE_BITS+1)) / b.mant;
+    a.mant = temp;
+    while (a.mant != temp) {
+        temp /= 2;
+        a.exp--;
+        a.mant = temp;
+    }
     a = av_normalize1_sf(a);
     if (!a.mant || a.exp < MIN_EXP)
         return FLOAT_0;
@@ -170,12 +177,14 @@ static inline av_const SoftFloat av_sub_sf(SoftFloat a, SoftFloat b){
 //FIXME log, exp, pow
 
 /**
- * Converts a mantisse and exponent to a SoftFloat
- * @returns a SoftFloat with value v * 2^frac_bits
+ * Converts a mantisse and exponent to a SoftFloat.
+ * This converts a fixed point value v with frac_bits fractional bits to a
+ * SoftFloat.
+ * @returns a SoftFloat with value v * 2^-frac_bits
  */
 static inline av_const SoftFloat av_int2sf(int v, int frac_bits){
     int exp_offset = 0;
-    if(v == INT_MIN){
+    if(v <= INT_MIN + 1){
         exp_offset = 1;
         v>>=1;
     }
@@ -235,12 +244,12 @@ static av_unused void av_sincos_sf(int a, int *s, int *c)
     int st, ct;
 
     idx = a >> 26;
-    sign = (idx << 27) >> 31;
+    sign = (int32_t)((unsigned)idx << 27) >> 31;
     cv = av_costbl_1_sf[idx & 0xf];
     cv = (cv ^ sign) - sign;
 
     idx -= 8;
-    sign = (idx << 27) >> 31;
+    sign = (int32_t)((unsigned)idx << 27) >> 31;
     sv = av_costbl_1_sf[idx & 0xf];
     sv = (sv ^ sign) - sign;
 
diff --git a/mythtv/external/FFmpeg/libavutil/softfloat_ieee754.h b/mythtv/external/FFmpeg/libavutil/softfloat_ieee754.h
index f82397b2e32..b8957fb0a91 100644
--- a/mythtv/external/FFmpeg/libavutil/softfloat_ieee754.h
+++ b/mythtv/external/FFmpeg/libavutil/softfloat_ieee754.h
@@ -38,7 +38,7 @@ static const SoftFloat_IEEE754 FLOAT_1 = {0, 0,    0};
 /** Normalize the softfloat as defined by IEEE 754 single-recision floating
  *  point specification
  */
-static SoftFloat_IEEE754 av_normalize_sf_ieee754(SoftFloat_IEEE754 sf) {
+static inline SoftFloat_IEEE754 av_normalize_sf_ieee754(SoftFloat_IEEE754 sf) {
     while( sf.mant >= 0x1000000UL ) {
         sf.exp++;
         sf.mant >>= 1;
@@ -50,7 +50,7 @@ static SoftFloat_IEEE754 av_normalize_sf_ieee754(SoftFloat_IEEE754 sf) {
 /** Convert integer to softfloat.
  *  @return softfloat with value n * 2^e
  */
-static SoftFloat_IEEE754 av_int2sf_ieee754(int64_t n, int e) {
+static inline SoftFloat_IEEE754 av_int2sf_ieee754(int64_t n, int e) {
     int sign = 0;
 
     if (n < 0) {
@@ -63,13 +63,13 @@ static SoftFloat_IEEE754 av_int2sf_ieee754(int64_t n, int e) {
 /** Make a softfloat out of the bitstream. Assumes the bits are in the form as defined
  *  by the IEEE 754 spec.
  */
-static SoftFloat_IEEE754 av_bits2sf_ieee754(uint32_t n) {
+static inline SoftFloat_IEEE754 av_bits2sf_ieee754(uint32_t n) {
     return ((SoftFloat_IEEE754) { (n & 0x80000000UL), (n & 0x7FFFFFUL), (n & 0x7F800000UL) });
 }
 
 /** Convert the softfloat to integer
  */
-static int av_sf2int_ieee754(SoftFloat_IEEE754 a) {
+static inline int av_sf2int_ieee754(SoftFloat_IEEE754 a) {
     if(a.exp >= 0) return a.mant <<  a.exp ;
     else           return a.mant >>(-a.exp);
 }
@@ -77,7 +77,7 @@ static int av_sf2int_ieee754(SoftFloat_IEEE754 a) {
 /** Divide a by b. b should not be zero.
  *  @return normalized result
  */
-static SoftFloat_IEEE754 av_div_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b) {
+static inline SoftFloat_IEEE754 av_div_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b) {
     int32_t mant, exp, sign;
     a    = av_normalize_sf_ieee754(a);
     b    = av_normalize_sf_ieee754(b);
@@ -90,7 +90,7 @@ static SoftFloat_IEEE754 av_div_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE75
 /** Multiply a with b
  *  #return normalized result
  */
-static SoftFloat_IEEE754 av_mul_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b) {
+static inline SoftFloat_IEEE754 av_mul_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b) {
     int32_t sign, mant, exp;
     a    = av_normalize_sf_ieee754(a);
     b    = av_normalize_sf_ieee754(b);
@@ -103,7 +103,7 @@ static SoftFloat_IEEE754 av_mul_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE75
 /** Compare a with b strictly
  *  @returns 1 if the a and b are equal, 0 otherwise.
  */
-static int av_cmp_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b) {
+static inline int av_cmp_sf_ieee754(SoftFloat_IEEE754 a, SoftFloat_IEEE754 b) {
     a = av_normalize_sf_ieee754(a);
     b = av_normalize_sf_ieee754(b);
     if (a.sign != b.sign) return 0;
diff --git a/mythtv/external/FFmpeg/libavutil/spherical.c b/mythtv/external/FFmpeg/libavutil/spherical.c
new file mode 100644
index 00000000000..4be55f36cff
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/spherical.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2016 Vittorio Giovara <vittorio.giovara@gmail.com>
+ *
+ * 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 "mem.h"
+#include "spherical.h"
+
+AVSphericalMapping *av_spherical_alloc(size_t *size)
+{
+    AVSphericalMapping *spherical = av_mallocz(sizeof(AVSphericalMapping));
+    if (!spherical)
+        return NULL;
+
+    if (size)
+        *size = sizeof(*spherical);
+
+    return spherical;
+}
+
+void av_spherical_tile_bounds(const AVSphericalMapping *map,
+                              size_t width, size_t height,
+                              size_t *left, size_t *top,
+                              size_t *right, size_t *bottom)
+{
+    /* conversion from 0.32 coordinates to pixels */
+    uint64_t orig_width  = (uint64_t) width  * UINT32_MAX /
+                           (UINT32_MAX - map->bound_right  - map->bound_left);
+    uint64_t orig_height = (uint64_t) height * UINT32_MAX /
+                           (UINT32_MAX - map->bound_bottom - map->bound_top);
+
+    /* add a (UINT32_MAX - 1) to round up integer division */
+    *left   = (orig_width  * map->bound_left + UINT32_MAX - 1) / UINT32_MAX;
+    *top    = (orig_height * map->bound_top  + UINT32_MAX - 1) / UINT32_MAX;
+    *right  = orig_width  - width  - *left;
+    *bottom = orig_height - height - *top;
+}
+
+static const char *spherical_projection_names[] = {
+    [AV_SPHERICAL_EQUIRECTANGULAR]      = "equirectangular",
+    [AV_SPHERICAL_CUBEMAP]              = "cubemap",
+    [AV_SPHERICAL_EQUIRECTANGULAR_TILE] = "tiled equirectangular",
+};
+
+const char *av_spherical_projection_name(enum AVSphericalProjection projection)
+{
+    if ((unsigned)projection >= FF_ARRAY_ELEMS(spherical_projection_names))
+        return "unknown";
+
+    return spherical_projection_names[projection];
+}
+
+int av_spherical_from_name(const char *name)
+{
+    int i;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(spherical_projection_names); i++) {
+        size_t len = strlen(spherical_projection_names[i]);
+        if (!strncmp(spherical_projection_names[i], name, len))
+            return i;
+    }
+
+    return -1;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/spherical.h b/mythtv/external/FFmpeg/libavutil/spherical.h
new file mode 100644
index 00000000000..cef759cf278
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/spherical.h
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2016 Vittorio Giovara <vittorio.giovara@gmail.com>
+ *
+ * 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
+ * Spherical video
+ */
+
+#ifndef AVUTIL_SPHERICAL_H
+#define AVUTIL_SPHERICAL_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * @addtogroup lavu_video
+ * @{
+ *
+ * @defgroup lavu_video_spherical Spherical video mapping
+ * @{
+ */
+
+/**
+ * @addtogroup lavu_video_spherical
+ * A spherical video file contains surfaces that need to be mapped onto a
+ * sphere. Depending on how the frame was converted, a different distortion
+ * transformation or surface recomposition function needs to be applied before
+ * the video should be mapped and displayed.
+ */
+
+/**
+ * Projection of the video surface(s) on a sphere.
+ */
+enum AVSphericalProjection {
+    /**
+     * Video represents a sphere mapped on a flat surface using
+     * equirectangular projection.
+     */
+    AV_SPHERICAL_EQUIRECTANGULAR,
+
+    /**
+     * Video frame is split into 6 faces of a cube, and arranged on a
+     * 3x2 layout. Faces are oriented upwards for the front, left, right,
+     * and back faces. The up face is oriented so the top of the face is
+     * forwards and the down face is oriented so the top of the face is
+     * to the back.
+     */
+    AV_SPHERICAL_CUBEMAP,
+
+    /**
+     * Video represents a portion of a sphere mapped on a flat surface
+     * using equirectangular projection. The @ref bounding fields indicate
+     * the position of the current video in a larger surface.
+     */
+    AV_SPHERICAL_EQUIRECTANGULAR_TILE,
+};
+
+/**
+ * This structure describes how to handle spherical videos, outlining
+ * information about projection, initial layout, and any other view modifier.
+ *
+ * @note The struct must be allocated with av_spherical_alloc() and
+ *       its size is not a part of the public ABI.
+ */
+typedef struct AVSphericalMapping {
+    /**
+     * Projection type.
+     */
+    enum AVSphericalProjection projection;
+
+    /**
+     * @name Initial orientation
+     * @{
+     * There fields describe additional rotations applied to the sphere after
+     * the video frame is mapped onto it. The sphere is rotated around the
+     * viewer, who remains stationary. The order of transformation is always
+     * yaw, followed by pitch, and finally by roll.
+     *
+     * The coordinate system matches the one defined in OpenGL, where the
+     * forward vector (z) is coming out of screen, and it is equivalent to
+     * a rotation matrix of R = r_y(yaw) * r_x(pitch) * r_z(roll).
+     *
+     * A positive yaw rotates the portion of the sphere in front of the viewer
+     * toward their right. A positive pitch rotates the portion of the sphere
+     * in front of the viewer upwards. A positive roll tilts the portion of
+     * the sphere in front of the viewer to the viewer's right.
+     *
+     * These values are exported as 16.16 fixed point.
+     *
+     * See this equirectangular projection as example:
+     *
+     * @code{.unparsed}
+     *                   Yaw
+     *     -180           0           180
+     *   90 +-------------+-------------+  180
+     *      |             |             |                  up
+     * P    |             |             |                 y|    forward
+     * i    |             ^             |                  |   /z
+     * t  0 +-------------X-------------+    0 Roll        |  /
+     * c    |             |             |                  | /
+     * h    |             |             |                 0|/_____right
+     *      |             |             |                        x
+     *  -90 +-------------+-------------+ -180
+     *
+     * X - the default camera center
+     * ^ - the default up vector
+     * @endcode
+     */
+    int32_t yaw;   ///< Rotation around the up vector [-180, 180].
+    int32_t pitch; ///< Rotation around the right vector [-90, 90].
+    int32_t roll;  ///< Rotation around the forward vector [-180, 180].
+    /**
+     * @}
+     */
+
+    /**
+     * @name Bounding rectangle
+     * @anchor bounding
+     * @{
+     * These fields indicate the location of the current tile, and where
+     * it should be mapped relative to the original surface. They are
+     * exported as 0.32 fixed point, and can be converted to classic
+     * pixel values with av_spherical_bounds().
+     *
+     * @code{.unparsed}
+     *      +----------------+----------+
+     *      |                |bound_top |
+     *      |            +--------+     |
+     *      | bound_left |tile    |     |
+     *      +<---------->|        |<--->+bound_right
+     *      |            +--------+     |
+     *      |                |          |
+     *      |    bound_bottom|          |
+     *      +----------------+----------+
+     * @endcode
+     *
+     * If needed, the original video surface dimensions can be derived
+     * by adding the current stream or frame size to the related bounds,
+     * like in the following example:
+     *
+     * @code{c}
+     *     original_width  = tile->width  + bound_left + bound_right;
+     *     original_height = tile->height + bound_top  + bound_bottom;
+     * @endcode
+     *
+     * @note These values are valid only for the tiled equirectangular
+     *       projection type (@ref AV_SPHERICAL_EQUIRECTANGULAR_TILE),
+     *       and should be ignored in all other cases.
+     */
+    uint32_t bound_left;   ///< Distance from the left edge
+    uint32_t bound_top;    ///< Distance from the top edge
+    uint32_t bound_right;  ///< Distance from the right edge
+    uint32_t bound_bottom; ///< Distance from the bottom edge
+    /**
+     * @}
+     */
+
+    /**
+     * Number of pixels to pad from the edge of each cube face.
+     *
+     * @note This value is valid for only for the cubemap projection type
+     *       (@ref AV_SPHERICAL_CUBEMAP), and should be ignored in all other
+     *       cases.
+     */
+    uint32_t padding;
+} AVSphericalMapping;
+
+/**
+ * Allocate a AVSphericalVideo structure and initialize its fields to default
+ * values.
+ *
+ * @return the newly allocated struct or NULL on failure
+ */
+AVSphericalMapping *av_spherical_alloc(size_t *size);
+
+/**
+ * Convert the @ref bounding fields from an AVSphericalVideo
+ * from 0.32 fixed point to pixels.
+ *
+ * @param map    The AVSphericalVideo map to read bound values from.
+ * @param width  Width of the current frame or stream.
+ * @param height Height of the current frame or stream.
+ * @param left   Pixels from the left edge.
+ * @param top    Pixels from the top edge.
+ * @param right  Pixels from the right edge.
+ * @param bottom Pixels from the bottom edge.
+ */
+void av_spherical_tile_bounds(const AVSphericalMapping *map,
+                              size_t width, size_t height,
+                              size_t *left, size_t *top,
+                              size_t *right, size_t *bottom);
+
+/**
+ * Provide a human-readable name of a given AVSphericalProjection.
+ *
+ * @param projection The input AVSphericalProjection.
+ *
+ * @return The name of the AVSphericalProjection, or "unknown".
+ */
+const char *av_spherical_projection_name(enum AVSphericalProjection projection);
+
+/**
+ * Get the AVSphericalProjection form a human-readable name.
+ *
+ * @param name The input string.
+ *
+ * @return The AVSphericalProjection value, or -1 if not found.
+ */
+int av_spherical_from_name(const char *name);
+/**
+ * @}
+ * @}
+ */
+
+#endif /* AVUTIL_SPHERICAL_H */
diff --git a/mythtv/external/FFmpeg/libavutil/stereo3d.c b/mythtv/external/FFmpeg/libavutil/stereo3d.c
index a53836424df..6edcdb17967 100644
--- a/mythtv/external/FFmpeg/libavutil/stereo3d.c
+++ b/mythtv/external/FFmpeg/libavutil/stereo3d.c
@@ -43,7 +43,7 @@ AVStereo3D *av_stereo3d_create_side_data(AVFrame *frame)
     return (AVStereo3D *)side_data->data;
 }
 
-static const char *stereo3d_type_names[] = {
+static const char * const stereo3d_type_names[] = {
     [AV_STEREO3D_2D]                  = "2D",
     [AV_STEREO3D_SIDEBYSIDE]          = "side by side",
     [AV_STEREO3D_TOPBOTTOM]           = "top and bottom",
diff --git a/mythtv/external/FFmpeg/libavutil/stereo3d.h b/mythtv/external/FFmpeg/libavutil/stereo3d.h
index 19c541643ea..54f4c4c5c78 100644
--- a/mythtv/external/FFmpeg/libavutil/stereo3d.h
+++ b/mythtv/external/FFmpeg/libavutil/stereo3d.h
@@ -18,6 +18,11 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+/**
+ * @file
+ * Stereoscopic video
+ */
+
 #ifndef AVUTIL_STEREO3D_H
 #define AVUTIL_STEREO3D_H
 
@@ -25,6 +30,21 @@
 
 #include "frame.h"
 
+/**
+ * @addtogroup lavu_video
+ * @{
+ *
+ * @defgroup lavu_video_stereo3d Stereo3D types and functions
+ * @{
+ */
+
+/**
+ * @addtogroup lavu_video_stereo3d
+ * A stereoscopic video file consists in multiple views embedded in a single
+ * frame, usually describing two views of a scene. This file describes all
+ * possible codec-independent view arrangements.
+ * */
+
 /**
  * List of possible 3D Types
  */
@@ -37,41 +57,49 @@ enum AVStereo3DType {
     /**
      * Views are next to each other.
      *
+     * @code{.unparsed}
      *    LLLLRRRR
      *    LLLLRRRR
      *    LLLLRRRR
      *    ...
+     * @endcode
      */
     AV_STEREO3D_SIDEBYSIDE,
 
     /**
      * Views are on top of each other.
      *
+     * @code{.unparsed}
      *    LLLLLLLL
      *    LLLLLLLL
      *    RRRRRRRR
      *    RRRRRRRR
+     * @endcode
      */
     AV_STEREO3D_TOPBOTTOM,
 
     /**
      * Views are alternated temporally.
      *
+     * @code{.unparsed}
      *     frame0   frame1   frame2   ...
      *    LLLLLLLL RRRRRRRR LLLLLLLL
      *    LLLLLLLL RRRRRRRR LLLLLLLL
      *    LLLLLLLL RRRRRRRR LLLLLLLL
      *    ...      ...      ...
+     * @endcode
      */
     AV_STEREO3D_FRAMESEQUENCE,
 
     /**
      * Views are packed in a checkerboard-like structure per pixel.
      *
+     * @code{.unparsed}
      *    LRLRLRLR
      *    RLRLRLRL
      *    LRLRLRLR
      *    ...
+     * @endcode
      */
     AV_STEREO3D_CHECKERBOARD,
 
@@ -79,30 +107,36 @@ enum AVStereo3DType {
      * Views are next to each other, but when upscaling
      * apply a checkerboard pattern.
      *
+     * @code{.unparsed}
      *     LLLLRRRR          L L L L    R R R R
      *     LLLLRRRR    =>     L L L L  R R R R
      *     LLLLRRRR          L L L L    R R R R
      *     LLLLRRRR           L L L L  R R R R
+     * @endcode
      */
     AV_STEREO3D_SIDEBYSIDE_QUINCUNX,
 
     /**
      * Views are packed per line, as if interlaced.
      *
+     * @code{.unparsed}
      *    LLLLLLLL
      *    RRRRRRRR
      *    LLLLLLLL
      *    ...
+     * @endcode
      */
     AV_STEREO3D_LINES,
 
     /**
      * Views are packed per column.
      *
+     * @code{.unparsed}
      *    LRLRLRLR
      *    LRLRLRLR
      *    LRLRLRLR
      *    ...
+     * @endcode
      */
     AV_STEREO3D_COLUMNS,
 };
@@ -161,10 +195,15 @@ const char *av_stereo3d_type_name(unsigned int type);
 /**
  * Get the AVStereo3DType form a human-readable name.
  *
- * @param type The input string.
+ * @param name The input string.
  *
  * @return The AVStereo3DType value, or -1 if not found.
  */
 int av_stereo3d_from_name(const char *name);
 
+/**
+ * @}
+ * @}
+ */
+
 #endif /* AVUTIL_STEREO3D_H */
diff --git a/mythtv/external/FFmpeg/libavutil/tests/.gitignore b/mythtv/external/FFmpeg/libavutil/tests/.gitignore
index c23c44b53b2..8ede0708870 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/.gitignore
+++ b/mythtv/external/FFmpeg/libavutil/tests/.gitignore
@@ -1,6 +1,8 @@
 /adler32
 /aes
+/aes_ctr
 /atomic
+/audio_fifo
 /avstring
 /base64
 /blowfish
@@ -9,6 +11,7 @@
 /cast5
 /color_utils
 /cpu
+/cpu_init
 /crc
 /des
 /dict
@@ -17,9 +20,9 @@
 /eval
 /fifo
 /file
-/float_dsp
 /hash
 /hmac
+/imgutils
 /lfg
 /lls
 /log
@@ -31,6 +34,7 @@
 /pca
 /pixdesc
 /pixelutils
+/pixfmt_best
 /random_seed
 /rational
 /ripemd
diff --git a/mythtv/external/FFmpeg/libavutil/tests/adler32.c b/mythtv/external/FFmpeg/libavutil/tests/adler32.c
index 511bf1e401c..13f760b4775 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/adler32.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/adler32.c
@@ -17,10 +17,12 @@
  */
 
 // LCOV_EXCL_START
+
+#include "libavutil/timer.h"
+
 #include <string.h>
 
 #include "libavutil/log.h"
-#include "libavutil/timer.h"
 #include "libavutil/adler32.h"
 
 #define LEN 7001
diff --git a/mythtv/external/FFmpeg/libavutil/tests/aes.c b/mythtv/external/FFmpeg/libavutil/tests/aes.c
index 1291ad66336..c7f842c1c76 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/aes.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/aes.c
@@ -17,6 +17,9 @@
  */
 
 // LCOV_EXCL_START
+
+#include "libavutil/timer.h"
+
 #include <string.h>
 
 #include "libavutil/aes.h"
diff --git a/mythtv/external/FFmpeg/libavutil/tests/aes_ctr.c b/mythtv/external/FFmpeg/libavutil/tests/aes_ctr.c
new file mode 100644
index 00000000000..c5ebeda7ac2
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/tests/aes_ctr.c
@@ -0,0 +1,65 @@
+/*
+ * 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/log.h"
+#include "libavutil/mem.h"
+#include "libavutil/aes_ctr.h"
+
+static const DECLARE_ALIGNED(8, uint8_t, plain)[] = {
+    0x6d, 0x6f, 0x73, 0x74, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d
+};
+static DECLARE_ALIGNED(8, uint8_t, tmp)[11];
+
+int main (void)
+{
+    int ret = 1;
+    struct AVAESCTR *ae, *ad;
+    const uint8_t *iv;
+
+    ae = av_aes_ctr_alloc();
+    ad = av_aes_ctr_alloc();
+
+    if (!ae || !ad)
+        goto ERROR;
+
+    if (av_aes_ctr_init(ae, (const uint8_t*)"0123456789abcdef") < 0)
+        goto ERROR;
+
+    if (av_aes_ctr_init(ad, (const uint8_t*)"0123456789abcdef") < 0)
+        goto ERROR;
+
+    av_aes_ctr_set_random_iv(ae);
+    iv =   av_aes_ctr_get_iv(ae);
+    av_aes_ctr_set_iv(ad, iv);
+
+    av_aes_ctr_crypt(ae, tmp, plain, sizeof(tmp));
+    av_aes_ctr_crypt(ad, tmp, tmp,   sizeof(tmp));
+
+    if (memcmp(tmp, plain, sizeof(tmp)) != 0){
+        av_log(NULL, AV_LOG_ERROR, "test failed\n");
+        goto ERROR;
+    }
+
+    av_log(NULL, AV_LOG_INFO, "test passed\n");
+    ret = 0;
+
+ERROR:
+    av_aes_ctr_free(ae);
+    av_aes_ctr_free(ad);
+    return ret;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/tests/atomic.c b/mythtv/external/FFmpeg/libavutil/tests/atomic.c
index c92f220a7aa..e41bf5a2b94 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/atomic.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/atomic.c
@@ -21,7 +21,9 @@
 
 int main(void)
 {
-    volatile int val = 1;
+    volatile int val      = 1;
+    void *tmp1            = (int *)&val;
+    void * volatile *tmp2 = &tmp1;
     int res;
 
     res = avpriv_atomic_int_add_and_fetch(&val, 1);
@@ -29,6 +31,8 @@ int main(void)
     avpriv_atomic_int_set(&val, 3);
     res = avpriv_atomic_int_get(&val);
     av_assert0(res == 3);
+    avpriv_atomic_ptr_cas(tmp2, tmp1, &res);
+    av_assert0(*tmp2 == &res);
 
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavutil/tests/audio_fifo.c b/mythtv/external/FFmpeg/libavutil/tests/audio_fifo.c
new file mode 100644
index 00000000000..e107166eb15
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/tests/audio_fifo.c
@@ -0,0 +1,200 @@
+/*
+ * 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 <stdlib.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include "libavutil/mem.h"
+#include "libavutil/audio_fifo.c"
+
+#define MAX_CHANNELS    32
+
+
+typedef struct TestStruct {
+    const enum AVSampleFormat format;
+    const int nb_ch;
+    void const *data_planes[MAX_CHANNELS];
+    const int nb_samples_pch;
+} TestStruct;
+
+static const uint8_t data_U8 [] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11                        };
+static const int16_t data_S16[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11                        };
+static const float   data_FLT[] = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0};
+
+static const TestStruct test_struct[] = {
+    {.format = AV_SAMPLE_FMT_U8   , .nb_ch = 1, .data_planes = {data_U8 ,             }, .nb_samples_pch = 12},
+    {.format = AV_SAMPLE_FMT_U8P  , .nb_ch = 2, .data_planes = {data_U8 , data_U8 +6, }, .nb_samples_pch = 6 },
+    {.format = AV_SAMPLE_FMT_S16  , .nb_ch = 1, .data_planes = {data_S16,             }, .nb_samples_pch = 12},
+    {.format = AV_SAMPLE_FMT_S16P , .nb_ch = 2, .data_planes = {data_S16, data_S16+6, }, .nb_samples_pch = 6 },
+    {.format = AV_SAMPLE_FMT_FLT  , .nb_ch = 1, .data_planes = {data_FLT,             }, .nb_samples_pch = 12},
+    {.format = AV_SAMPLE_FMT_FLTP , .nb_ch = 2, .data_planes = {data_FLT, data_FLT+6, }, .nb_samples_pch = 6 }
+};
+
+static void free_data_planes(AVAudioFifo *afifo, void **output_data)
+{
+    int i;
+    for (i = 0; i < afifo->nb_buffers; ++i){
+        av_freep(&output_data[i]);
+    }
+    av_freep(&output_data);
+}
+
+static void ERROR(const char *str)
+{
+    fprintf(stderr, "%s\n", str);
+    exit(1);
+}
+
+static void print_audio_bytes(const TestStruct *test_sample, void **data_planes, int nb_samples)
+{
+    int p, b, f;
+    int byte_offset      = av_get_bytes_per_sample(test_sample->format);
+    int buffers          = av_sample_fmt_is_planar(test_sample->format)
+                                         ? test_sample->nb_ch : 1;
+    int line_size        = (buffers > 1) ? nb_samples * byte_offset
+                                         : nb_samples * byte_offset * test_sample->nb_ch;
+    for (p = 0; p < buffers; ++p){
+        for(b = 0; b < line_size; b+=byte_offset){
+            for (f = 0; f < byte_offset; f++){
+                int order = !HAVE_BIGENDIAN ? (byte_offset - f - 1) : f;
+                printf("%02x", *((uint8_t*)data_planes[p] + b + order));
+            }
+            putchar(' ');
+        }
+        putchar('\n');
+    }
+}
+
+static int read_samples_from_audio_fifo(AVAudioFifo* afifo, void ***output, int nb_samples)
+{
+    int i;
+    int samples        = FFMIN(nb_samples, afifo->nb_samples);
+    int tot_elements   = !av_sample_fmt_is_planar(afifo->sample_fmt)
+                         ? samples : afifo->channels * samples;
+    void **data_planes = av_malloc_array(afifo->nb_buffers, sizeof(void*));
+    if (!data_planes)
+        ERROR("failed to allocate memory!");
+    if (*output)
+        free_data_planes(afifo, *output);
+    *output            = data_planes;
+
+    for (i = 0; i < afifo->nb_buffers; ++i){
+        data_planes[i] = av_malloc_array(tot_elements, afifo->sample_size);
+        if (!data_planes[i])
+            ERROR("failed to allocate memory!");
+    }
+
+    return av_audio_fifo_read(afifo, *output, nb_samples);
+}
+
+static int write_samples_to_audio_fifo(AVAudioFifo* afifo, const TestStruct *test_sample,
+                                       int nb_samples, int offset)
+{
+    int offset_size, i;
+    void *data_planes[MAX_CHANNELS];
+
+    if(nb_samples > test_sample->nb_samples_pch - offset){
+        return 0;
+    }
+    if(offset >= test_sample->nb_samples_pch){
+        return 0;
+    }
+    offset_size  = offset * afifo->sample_size;
+
+    for (i = 0; i < afifo->nb_buffers ; ++i){
+        data_planes[i] = (uint8_t*)test_sample->data_planes[i] + offset_size;
+    }
+
+    return av_audio_fifo_write(afifo, data_planes, nb_samples);
+}
+
+static void test_function(const TestStruct *test_sample)
+{
+    int ret, i;
+    void **output_data  = NULL;
+    AVAudioFifo *afifo  = av_audio_fifo_alloc(test_sample->format, test_sample->nb_ch,
+                                            test_sample->nb_samples_pch);
+    if (!afifo) {
+        ERROR("ERROR: av_audio_fifo_alloc returned NULL!");
+    }
+    ret = write_samples_to_audio_fifo(afifo, test_sample, test_sample->nb_samples_pch, 0);
+    if (ret < 0){
+        ERROR("ERROR: av_audio_fifo_write failed!");
+    }
+    printf("written: %d\n", ret);
+
+    ret = write_samples_to_audio_fifo(afifo, test_sample, test_sample->nb_samples_pch, 0);
+    if (ret < 0){
+        ERROR("ERROR: av_audio_fifo_write failed!");
+    }
+    printf("written: %d\n", ret);
+    printf("remaining samples in audio_fifo: %d\n\n", av_audio_fifo_size(afifo));
+
+    ret = read_samples_from_audio_fifo(afifo, &output_data, test_sample->nb_samples_pch);
+    if (ret < 0){
+        ERROR("ERROR: av_audio_fifo_read failed!");
+    }
+    printf("read: %d\n", ret);
+    print_audio_bytes(test_sample, output_data, ret);
+    printf("remaining samples in audio_fifo: %d\n\n", av_audio_fifo_size(afifo));
+
+    /* test av_audio_fifo_peek */
+    ret = av_audio_fifo_peek(afifo, output_data, afifo->nb_samples);
+    if (ret < 0){
+        ERROR("ERROR: av_audio_fifo_peek failed!");
+    }
+    printf("peek:\n");
+    print_audio_bytes(test_sample, output_data, ret);
+    printf("\n");
+
+    /* test av_audio_fifo_peek_at */
+    printf("peek_at:\n");
+    for (i = 0; i < afifo->nb_samples; ++i){
+        ret = av_audio_fifo_peek_at(afifo, output_data, 1, i);
+        if (ret < 0){
+            ERROR("ERROR: av_audio_fifo_peek_at failed!");
+        }
+        printf("%d:\n", i);
+        print_audio_bytes(test_sample, output_data, ret);
+    }
+    printf("\n");
+
+    /* test av_audio_fifo_drain */
+    ret = av_audio_fifo_drain(afifo, afifo->nb_samples);
+    if (ret < 0){
+        ERROR("ERROR: av_audio_fifo_drain failed!");
+    }
+    if (afifo->nb_samples){
+        ERROR("drain failed to flush all samples in audio_fifo!");
+    }
+
+    /* deallocate */
+    free_data_planes(afifo, output_data);
+    av_audio_fifo_free(afifo);
+}
+
+int main(void)
+{
+    int t, tests = sizeof(test_struct)/sizeof(test_struct[0]);
+
+    for (t = 0; t < tests; ++t){
+        printf("\nTEST: %d\n\n", t+1);
+        test_function(&test_struct[t]);
+    }
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/tests/avstring.c b/mythtv/external/FFmpeg/libavutil/tests/avstring.c
index 1242b3fe8d6..887bd25a126 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/avstring.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/avstring.c
@@ -25,7 +25,7 @@
 int main(void)
 {
     int i;
-    char *fullpath;
+    char *fullpath, *ptr;
     static const char * const strings[] = {
         "''",
         "",
@@ -54,6 +54,8 @@ int main(void)
         "'\\fo\\o:': blahblah",
         "\\'fo\\o\\:':  foo  '  :blahblah"
     };
+    const char *haystack = "Education consists mainly in what we have unlearned.";
+    const char * const needle[] = {"learned.", "unlearned.", "Unlearned"};
 
     printf("Testing av_get_token()\n");
     for (i = 0; i < FF_ARRAY_ELEMS(strings); i++) {
@@ -79,5 +81,45 @@ int main(void)
     TEST_APPEND_PATH_COMPONENT("path", "/comp", "path/comp");
     TEST_APPEND_PATH_COMPONENT("path/", "/comp", "path/comp");
     TEST_APPEND_PATH_COMPONENT("path/path2/", "/comp/comp2", "path/path2/comp/comp2");
+
+    /*Testing av_strnstr()*/
+    #define TEST_STRNSTR(haystack, needle, hay_length, expected) \
+        ptr = av_strnstr(haystack, needle, hay_length); \
+        if (ptr != expected){ \
+            printf("expected: %p, received %p\n", expected, ptr); \
+        }
+    TEST_STRNSTR(haystack, needle [0], strlen(haystack), haystack+44);
+    TEST_STRNSTR(haystack, needle [1], strlen(haystack), haystack+42);
+    TEST_STRNSTR(haystack, needle [2], strlen(haystack), NULL       );
+    TEST_STRNSTR(haystack, strings[1], strlen(haystack), haystack   );
+
+    /*Testing av_strireplace()*/
+    #define TEST_STRIREPLACE(haystack, needle, expected) \
+        ptr = av_strireplace(haystack, needle, "instead"); \
+        if (ptr == NULL) { \
+            printf("error, received null pointer!\n"); \
+        } else { \
+            if (strcmp(ptr, expected) != 0) \
+                printf( "expected: %s, received: %s\n", expected, ptr); \
+            av_free(ptr); \
+        }
+
+    TEST_STRIREPLACE(haystack, needle [0], "Education consists mainly in what we have uninstead");
+    TEST_STRIREPLACE(haystack, needle [1], "Education consists mainly in what we have instead");
+    TEST_STRIREPLACE(haystack, needle [2], "Education consists mainly in what we have instead.");
+    TEST_STRIREPLACE(haystack, needle [1], "Education consists mainly in what we have instead");
+
+    /*Testing av_d2str()*/
+    #define TEST_D2STR(value, expected) \
+        if((ptr = av_d2str(value)) == NULL){ \
+            printf("error, received null pointer!\n"); \
+        } else { \
+            if(strcmp(ptr, expected) != 0) \
+                printf( "expected: %s, received: %s\n", expected, ptr); \
+            av_free(ptr); \
+        }
+    TEST_D2STR(0         ,  "0.000000");
+    TEST_D2STR(-1.2333234, "-1.233323");
+    TEST_D2STR(-1.2333237, "-1.233324");
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavutil/tests/base64.c b/mythtv/external/FFmpeg/libavutil/tests/base64.c
index 88fd55c2203..400e01cefe4 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/base64.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/base64.c
@@ -17,12 +17,14 @@
  */
 
 // LCOV_EXCL_START
+
+#include "libavutil/timer.h"
+
 #include <stdint.h>
 #include <stdio.h>
 
 #include "libavutil/common.h"
 #include "libavutil/base64.h"
-#include "libavutil/timer.h"
 
 #define MAX_DATA_SIZE    1024
 #define MAX_ENCODED_SIZE 2048
diff --git a/mythtv/external/FFmpeg/libavutil/tests/cpu_init.c b/mythtv/external/FFmpeg/libavutil/tests/cpu_init.c
new file mode 100644
index 00000000000..a379e47b138
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/tests/cpu_init.c
@@ -0,0 +1,65 @@
+/*
+ * 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
+ */
+
+/*
+ * This test program tests whether the one-time initialization in
+ * av_get_cpu_flags() has data races.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "libavutil/cpu.h"
+#include "libavutil/thread.h"
+
+static void *thread_main(void *arg)
+{
+    int *flags = arg;
+
+    *flags = av_get_cpu_flags();
+    return NULL;
+}
+
+int main(void)
+{
+    int cpu_flags1;
+    int cpu_flags2;
+    int ret;
+    pthread_t thread1;
+    pthread_t thread2;
+
+    if ((ret = pthread_create(&thread1, NULL, thread_main, &cpu_flags1))) {
+        fprintf(stderr, "pthread_create failed: %s.\n", strerror(ret));
+        return 1;
+    }
+    if ((ret = pthread_create(&thread2, NULL, thread_main, &cpu_flags2))) {
+        fprintf(stderr, "pthread_create failed: %s.\n", strerror(ret));
+        return 1;
+    }
+    pthread_join(thread1, NULL);
+    pthread_join(thread2, NULL);
+
+    if (cpu_flags1 < 0)
+        return 2;
+    if (cpu_flags2 < 0)
+        return 2;
+    if (cpu_flags1 != cpu_flags2)
+        return 3;
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/tests/des.c b/mythtv/external/FFmpeg/libavutil/tests/des.c
index ed04fad5199..f2a5c34f1ab 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/des.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/des.c
@@ -16,6 +16,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/timer.h"
+
 #include "libavutil/des.c"
 
 #include <stdint.h>
@@ -34,7 +36,7 @@ static uint64_t rand64(void)
 
 static const uint8_t test_key[] = { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 };
 static const DECLARE_ALIGNED(8, uint8_t, plain)[] = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 };
-static const DECLARE_ALIGNED(8, uint8_t, crypt)[] = { 0x4a, 0xb6, 0x5b, 0x3d, 0x4b, 0x06, 0x15, 0x18 };
+static const DECLARE_ALIGNED(8, uint8_t, crypt_ref)[] = { 0x4a, 0xb6, 0x5b, 0x3d, 0x4b, 0x06, 0x15, 0x18 };
 static DECLARE_ALIGNED(8, uint8_t, tmp)[8];
 static DECLARE_ALIGNED(8, uint8_t, large_buffer)[10002][8];
 static const uint8_t cbc_key[] = {
@@ -67,25 +69,28 @@ static int run_test(int cbc, int decrypt)
     }
 }
 
+union word_byte {
+    uint64_t word;
+    uint8_t byte[8];
+};
+
 int main(void)
 {
     AVDES d;
     int i;
-    uint64_t key[3];
-    uint64_t data;
-    uint64_t ct;
+    union word_byte key[3], data, ct;
     uint64_t roundkeys[16];
     srand(av_gettime());
-    key[0] = AV_RB64(test_key);
-    data   = AV_RB64(plain);
-    gen_roundkeys(roundkeys, key[0]);
-    if (des_encdec(data, roundkeys, 0) != AV_RB64(crypt)) {
+    key[0].word = AV_RB64(test_key);
+    data.word   = AV_RB64(plain);
+    gen_roundkeys(roundkeys, key[0].word);
+    if (des_encdec(data.word, roundkeys, 0) != AV_RB64(crypt_ref)) {
         printf("Test 1 failed\n");
         return 1;
     }
     av_des_init(&d, test_key, 64, 0);
     av_des_crypt(&d, tmp, plain, 1, NULL, 0);
-    if (memcmp(tmp, crypt, sizeof(crypt))) {
+    if (memcmp(tmp, crypt_ref, sizeof(crypt_ref))) {
         printf("Public API decryption failed\n");
         return 1;
     }
@@ -94,15 +99,15 @@ int main(void)
         return 1;
     }
     for (i = 0; i < 1000; i++) {
-        key[0] = rand64();
-        key[1] = rand64();
-        key[2] = rand64();
-        data   = rand64();
-        av_des_init(&d, (uint8_t *) key, 192, 0);
-        av_des_crypt(&d, (uint8_t *) &ct, (uint8_t *) &data, 1, NULL, 0);
-        av_des_init(&d, (uint8_t *) key, 192, 1);
-        av_des_crypt(&d, (uint8_t *) &ct, (uint8_t *) &ct, 1, NULL, 1);
-        if (ct != data) {
+        key[0].word = rand64();
+        key[1].word = rand64();
+        key[2].word = rand64();
+        data.word   = rand64();
+        av_des_init(&d, key[0].byte, 192, 0);
+        av_des_crypt(&d, ct.byte, data.byte, 1, NULL, 0);
+        av_des_init(&d, key[0].byte, 192, 1);
+        av_des_crypt(&d, ct.byte, ct.byte, 1, NULL, 1);
+        if (ct.word != data.word) {
             printf("Test 2 failed\n");
             return 1;
         }
diff --git a/mythtv/external/FFmpeg/libavutil/tests/dict.c b/mythtv/external/FFmpeg/libavutil/tests/dict.c
index 0039ba5ff96..56e98557a72 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/dict.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/dict.c
@@ -35,12 +35,15 @@ static void test_separators(const AVDictionary *m, const char pair, const char v
     char vals[]  = {val, '\0'};
 
     char *buffer = NULL;
+    int ret;
+
     av_dict_copy(&dict, m, 0);
     print_dict(dict);
     av_dict_get_string(dict, &buffer, val, pair);
     printf("%s\n", buffer);
     av_dict_free(&dict);
-    av_dict_parse_string(&dict, buffer, vals, pairs, 0);
+    ret = av_dict_parse_string(&dict, buffer, vals, pairs, 0);
+    printf("ret %d\n", ret);
     av_freep(&buffer);
     print_dict(dict);
     av_dict_free(&dict);
diff --git a/mythtv/external/FFmpeg/libavutil/tests/eval.c b/mythtv/external/FFmpeg/libavutil/tests/eval.c
index 2a1afcc4dc4..b64c6d635dd 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/eval.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/eval.c
@@ -16,12 +16,13 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/timer.h"
+
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "libavutil/libm.h"
-#include "libavutil/timer.h"
 #include "libavutil/eval.h"
 
 static const double const_values[] = {
diff --git a/mythtv/external/FFmpeg/libavutil/tests/float_dsp.c b/mythtv/external/FFmpeg/libavutil/tests/float_dsp.c
deleted file mode 100644
index 053324dd381..00000000000
--- a/mythtv/external/FFmpeg/libavutil/tests/float_dsp.c
+++ /dev/null
@@ -1,333 +0,0 @@
-/*
- * 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 <float.h>
-#include <math.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#if HAVE_UNISTD_H
-#include <unistd.h> /* for getopt */
-#endif
-#if !HAVE_GETOPT
-#include "compat/getopt.c"
-#endif
-
-#include "libavutil/common.h"
-#include "libavutil/cpu.h"
-#include "libavutil/internal.h"
-#include "libavutil/lfg.h"
-#include "libavutil/log.h"
-#include "libavutil/random_seed.h"
-#include "libavutil/float_dsp.h"
-
-#define LEN 240
-
-static void fill_float_array(AVLFG *lfg, float *a, int len)
-{
-    int i;
-    double bmg[2], stddev = 10.0, mean = 0.0;
-
-    for (i = 0; i < len; i += 2) {
-        av_bmg_get(lfg, bmg);
-        a[i]     = bmg[0] * stddev + mean;
-        a[i + 1] = bmg[1] * stddev + mean;
-    }
-}
-static int compare_floats(const float *a, const float *b, int len,
-                          float max_diff)
-{
-    int i;
-    for (i = 0; i < len; i++) {
-        if (fabsf(a[i] - b[i]) > max_diff) {
-            av_log(NULL, AV_LOG_ERROR, "%d: %- .12f - %- .12f = % .12g\n",
-                   i, a[i], b[i], a[i] - b[i]);
-            return -1;
-        }
-    }
-    return 0;
-}
-
-static void fill_double_array(AVLFG *lfg, double *a, int len)
-{
-    int i;
-    double bmg[2], stddev = 10.0, mean = 0.0;
-
-    for (i = 0; i < len; i += 2) {
-        av_bmg_get(lfg, bmg);
-        a[i]     = bmg[0] * stddev + mean;
-        a[i + 1] = bmg[1] * stddev + mean;
-    }
-}
-
-static int compare_doubles(const double *a, const double *b, int len,
-                           double max_diff)
-{
-    int i;
-
-    for (i = 0; i < len; i++) {
-        if (fabs(a[i] - b[i]) > max_diff) {
-            av_log(NULL, AV_LOG_ERROR, "%d: %- .12f - %- .12f = % .12g\n",
-                   i, a[i], b[i], a[i] - b[i]);
-            return -1;
-        }
-    }
-    return 0;
-}
-
-static int test_vector_fmul(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                            const float *v1, const float *v2)
-{
-    LOCAL_ALIGNED(32, float, cdst, [LEN]);
-    LOCAL_ALIGNED(32, float, odst, [LEN]);
-    int ret;
-
-    cdsp->vector_fmul(cdst, v1, v2, LEN);
-    fdsp->vector_fmul(odst, v1, v2, LEN);
-
-    if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
-        av_log(NULL, AV_LOG_ERROR, "vector_fmul failed\n");
-
-    return ret;
-}
-
-#define ARBITRARY_FMAC_SCALAR_CONST 0.005
-static int test_vector_fmac_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                   const float *v1, const float *src0, float scale)
-{
-    LOCAL_ALIGNED(32, float, cdst, [LEN]);
-    LOCAL_ALIGNED(32, float, odst, [LEN]);
-    int ret;
-
-    memcpy(cdst, v1, LEN * sizeof(*v1));
-    memcpy(odst, v1, LEN * sizeof(*v1));
-
-    cdsp->vector_fmac_scalar(cdst, src0, scale, LEN);
-    fdsp->vector_fmac_scalar(odst, src0, scale, LEN);
-
-    if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMAC_SCALAR_CONST))
-        av_log(NULL, AV_LOG_ERROR, "vector_fmac_scalar failed\n");
-
-    return ret;
-}
-
-static int test_vector_fmul_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                   const float *v1, float scale)
-{
-    LOCAL_ALIGNED(32, float, cdst, [LEN]);
-    LOCAL_ALIGNED(32, float, odst, [LEN]);
-    int ret;
-
-    cdsp->vector_fmul_scalar(cdst, v1, scale, LEN);
-    fdsp->vector_fmul_scalar(odst, v1, scale, LEN);
-
-    if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
-        av_log(NULL, AV_LOG_ERROR, "vector_fmul_scalar failed\n");
-
-    return ret;
-}
-
-static int test_vector_dmul_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                   const double *v1, double scale)
-{
-    LOCAL_ALIGNED(32, double, cdst, [LEN]);
-    LOCAL_ALIGNED(32, double, odst, [LEN]);
-    int ret;
-
-    cdsp->vector_dmul_scalar(cdst, v1, scale, LEN);
-    fdsp->vector_dmul_scalar(odst, v1, scale, LEN);
-
-    if (ret = compare_doubles(cdst, odst, LEN, DBL_EPSILON))
-        av_log(NULL, AV_LOG_ERROR, "vector_dmul_scalar failed\n");
-
-    return ret;
-}
-
-#define ARBITRARY_FMUL_WINDOW_CONST 0.008
-static int test_vector_fmul_window(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                   const float *v1, const float *v2, const float *v3)
-{
-    LOCAL_ALIGNED(32, float, cdst, [LEN]);
-    LOCAL_ALIGNED(32, float, odst, [LEN]);
-    int ret;
-
-    cdsp->vector_fmul_window(cdst, v1, v2, v3, LEN / 2);
-    fdsp->vector_fmul_window(odst, v1, v2, v3, LEN / 2);
-
-    if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMUL_WINDOW_CONST))
-        av_log(NULL, AV_LOG_ERROR, "vector_fmul_window failed\n");
-
-    return ret;
-}
-
-#define ARBITRARY_FMUL_ADD_CONST 0.005
-static int test_vector_fmul_add(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                const float *v1, const float *v2, const float *v3)
-{
-    LOCAL_ALIGNED(32, float, cdst, [LEN]);
-    LOCAL_ALIGNED(32, float, odst, [LEN]);
-    int ret;
-
-    cdsp->vector_fmul_add(cdst, v1, v2, v3, LEN);
-    fdsp->vector_fmul_add(odst, v1, v2, v3, LEN);
-
-    if (ret = compare_floats(cdst, odst, LEN, ARBITRARY_FMUL_ADD_CONST))
-        av_log(NULL, AV_LOG_ERROR, "vector_fmul_add failed\n");
-
-    return ret;
-}
-
-static int test_vector_fmul_reverse(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                    const float *v1, const float *v2)
-{
-    LOCAL_ALIGNED(32, float, cdst, [LEN]);
-    LOCAL_ALIGNED(32, float, odst, [LEN]);
-    int ret;
-
-    cdsp->vector_fmul_reverse(cdst, v1, v2, LEN);
-    fdsp->vector_fmul_reverse(odst, v1, v2, LEN);
-
-    if (ret = compare_floats(cdst, odst, LEN, FLT_EPSILON))
-        av_log(NULL, AV_LOG_ERROR, "vector_fmul_reverse failed\n");
-
-    return ret;
-}
-
-static int test_butterflies_float(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                  const float *v1, const float *v2)
-{
-    LOCAL_ALIGNED(32, float, cv1, [LEN]);
-    LOCAL_ALIGNED(32, float, cv2, [LEN]);
-    LOCAL_ALIGNED(32, float, ov1, [LEN]);
-    LOCAL_ALIGNED(32, float, ov2, [LEN]);
-    int ret;
-
-    memcpy(cv1, v1, LEN * sizeof(*v1));
-    memcpy(cv2, v2, LEN * sizeof(*v2));
-    memcpy(ov1, v1, LEN * sizeof(*v1));
-    memcpy(ov2, v2, LEN * sizeof(*v2));
-
-    cdsp->butterflies_float(cv1, cv2, LEN);
-    fdsp->butterflies_float(ov1, ov2, LEN);
-
-    if ((ret = compare_floats(cv1, ov1, LEN, FLT_EPSILON)) ||
-        (ret = compare_floats(cv2, ov2, LEN, FLT_EPSILON)))
-        av_log(NULL, AV_LOG_ERROR, "butterflies_float failed\n");
-
-    return ret;
-}
-
-#define ARBITRARY_SCALARPRODUCT_CONST 0.2
-static int test_scalarproduct_float(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
-                                    const float *v1, const float *v2)
-{
-    float cprod, oprod;
-    int ret;
-
-    cprod = cdsp->scalarproduct_float(v1, v2, LEN);
-    oprod = fdsp->scalarproduct_float(v1, v2, LEN);
-
-    if (ret = compare_floats(&cprod, &oprod, 1, ARBITRARY_SCALARPRODUCT_CONST))
-        av_log(NULL, AV_LOG_ERROR, "scalarproduct_float failed\n");
-
-    return ret;
-}
-
-int main(int argc, char **argv)
-{
-    int ret = 0, seeded = 0;
-    uint32_t seed;
-    AVFloatDSPContext *fdsp, *cdsp;
-    AVLFG lfg;
-
-    LOCAL_ALIGNED(32, float, src0, [LEN]);
-    LOCAL_ALIGNED(32, float, src1, [LEN]);
-    LOCAL_ALIGNED(32, float, src2, [LEN]);
-    LOCAL_ALIGNED(32, double, dbl_src0, [LEN]);
-    LOCAL_ALIGNED(32, double, dbl_src1, [LEN]);
-
-    for (;;) {
-        int arg = getopt(argc, argv, "s:c:");
-        if (arg == -1)
-            break;
-        switch (arg) {
-        case 's':
-            seed = strtoul(optarg, NULL, 10);
-            seeded = 1;
-            break;
-        case 'c':
-        {
-            int cpuflags = av_get_cpu_flags();
-
-            if (av_parse_cpu_caps(&cpuflags, optarg) < 0)
-                return 1;
-
-            av_force_cpu_flags(cpuflags);
-            break;
-        }
-        }
-    }
-    if (!seeded)
-        seed = av_get_random_seed();
-
-    av_log(NULL, AV_LOG_INFO, "float_dsp-test: %s %u\n", seeded ? "seed" : "random seed", seed);
-
-    fdsp = avpriv_float_dsp_alloc(1);
-    av_force_cpu_flags(0);
-    cdsp = avpriv_float_dsp_alloc(1);
-
-    if (!fdsp || !cdsp) {
-        ret = 1;
-        goto end;
-    }
-
-    av_lfg_init(&lfg, seed);
-
-    fill_float_array(&lfg, src0, LEN);
-    fill_float_array(&lfg, src1, LEN);
-    fill_float_array(&lfg, src2, LEN);
-
-    fill_double_array(&lfg, dbl_src0, LEN);
-    fill_double_array(&lfg, dbl_src1, LEN);
-
-    if (test_vector_fmul(fdsp, cdsp, src0, src1))
-        ret -= 1 << 0;
-    if (test_vector_fmac_scalar(fdsp, cdsp, src2, src0, src1[0]))
-        ret -= 1 << 1;
-    if (test_vector_fmul_scalar(fdsp, cdsp, src0, src1[0]))
-        ret -= 1 << 2;
-    if (test_vector_fmul_window(fdsp, cdsp, src0, src1, src2))
-        ret -= 1 << 3;
-    if (test_vector_fmul_add(fdsp, cdsp, src0, src1, src2))
-        ret -= 1 << 4;
-    if (test_vector_fmul_reverse(fdsp, cdsp, src0, src1))
-        ret -= 1 << 5;
-    if (test_butterflies_float(fdsp, cdsp, src0, src1))
-        ret -= 1 << 6;
-    if (test_scalarproduct_float(fdsp, cdsp, src0, src1))
-        ret -= 1 << 7;
-    if (test_vector_dmul_scalar(fdsp, cdsp, dbl_src0, dbl_src1[0]))
-        ret -= 1 << 8;
-
-end:
-    av_freep(&fdsp);
-    av_freep(&cdsp);
-    return ret;
-}
diff --git a/mythtv/external/FFmpeg/libavutil/tests/imgutils.c b/mythtv/external/FFmpeg/libavutil/tests/imgutils.c
new file mode 100644
index 00000000000..571045c8577
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/tests/imgutils.c
@@ -0,0 +1,36 @@
+/*
+ * 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/imgutils.c"
+
+#undef printf
+
+int main(void)
+{
+    int64_t x, y;
+
+    for (y = -1; y<UINT_MAX; y+= y/2 + 1) {
+        for (x = -1; x<UINT_MAX; x+= x/2 + 1) {
+            int ret = av_image_check_size(x, y, 0, NULL);
+            printf("%d", ret >= 0);
+        }
+        printf("\n");
+    }
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/tests/lfg.c b/mythtv/external/FFmpeg/libavutil/tests/lfg.c
index 1425e026b40..bf127e30316 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/lfg.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/lfg.c
@@ -20,20 +20,96 @@
 #include "libavutil/timer.h"
 #include "libavutil/lfg.h"
 
+static const double Z_TABLE[31][10] = {
+    {0.5000,  0.5040,  0.5080,  0.5120,  0.5160,  0.5199,  0.5239,  0.5279,  0.5319,  0.5359},
+    {0.5398,  0.5438,  0.5478,  0.5517,  0.5557,  0.5596,  0.5636,  0.5675,  0.5714,  0.5753},
+    {0.5793,  0.5832,  0.5871,  0.5910,  0.5948,  0.5987,  0.6026,  0.6064,  0.6103,  0.6141},
+    {0.6179,  0.6217,  0.6255,  0.6293,  0.6331,  0.6368,  0.6406,  0.6443,  0.6480,  0.6517},
+    {0.6554,  0.6591,  0.6628,  0.6664,  0.6700,  0.6736,  0.6772,  0.6808,  0.6844,  0.6879},
+    {0.6915,  0.6950,  0.6985,  0.7019,  0.7054,  0.7088,  0.7123,  0.7157,  0.7190,  0.7224},
+    {0.7257,  0.7291,  0.7324,  0.7357,  0.7389,  0.7422,  0.7454,  0.7486,  0.7517,  0.7549},
+    {0.7580,  0.7611,  0.7642,  0.7673,  0.7704,  0.7734,  0.7764,  0.7794,  0.7823,  0.7852},
+    {0.7881,  0.7910,  0.7939,  0.7967,  0.7995,  0.8023,  0.8051,  0.8078,  0.8106,  0.8133},
+    {0.8159,  0.8186,  0.8212,  0.8238,  0.8264,  0.8289,  0.8315,  0.8340,  0.8365,  0.8389},
+    {0.8413,  0.8438,  0.8461,  0.8485,  0.8508,  0.8531,  0.8554,  0.8577,  0.8599,  0.8621},
+    {0.8643,  0.8665,  0.8686,  0.8708,  0.8729,  0.8749,  0.8770,  0.8790,  0.8810,  0.8830},
+    {0.8849,  0.8869,  0.8888,  0.8907,  0.8925,  0.8944,  0.8962,  0.8980,  0.8997,  0.9015},
+    {0.9032,  0.9049,  0.9066,  0.9082,  0.9099,  0.9115,  0.9131,  0.9147,  0.9162,  0.9177},
+    {0.9192,  0.9207,  0.9222,  0.9236,  0.9251,  0.9265,  0.9279,  0.9292,  0.9306,  0.9319},
+    {0.9332,  0.9345,  0.9357,  0.9370,  0.9382,  0.9394,  0.9406,  0.9418,  0.9429,  0.9441},
+    {0.9452,  0.9463,  0.9474,  0.9484,  0.9495,  0.9505,  0.9515,  0.9525,  0.9535,  0.9545},
+    {0.9554,  0.9564,  0.9573,  0.9582,  0.9591,  0.9599,  0.9608,  0.9616,  0.9625,  0.9633},
+    {0.9641,  0.9649,  0.9656,  0.9664,  0.9671,  0.9678,  0.9686,  0.9693,  0.9699,  0.9706},
+    {0.9713,  0.9719,  0.9726,  0.9732,  0.9738,  0.9744,  0.9750,  0.9756,  0.9761,  0.9767},
+    {0.9772,  0.9778,  0.9783,  0.9788,  0.9793,  0.9798,  0.9803,  0.9808,  0.9812,  0.9817},
+    {0.9821,  0.9826,  0.9830,  0.9834,  0.9838,  0.9842,  0.9846,  0.9850,  0.9854,  0.9857},
+    {0.9861,  0.9864,  0.9868,  0.9871,  0.9875,  0.9878,  0.9881,  0.9884,  0.9887,  0.9890},
+    {0.9893,  0.9896,  0.9898,  0.9901,  0.9904,  0.9906,  0.9909,  0.9911,  0.9913,  0.9916},
+    {0.9918,  0.9920,  0.9922,  0.9925,  0.9927,  0.9929,  0.9931,  0.9932,  0.9934,  0.9936},
+    {0.9938,  0.9940,  0.9941,  0.9943,  0.9945,  0.9946,  0.9948,  0.9949,  0.9951,  0.9952},
+    {0.9953,  0.9955,  0.9956,  0.9957,  0.9959,  0.9960,  0.9961,  0.9962,  0.9963,  0.9964},
+    {0.9965,  0.9966,  0.9967,  0.9968,  0.9969,  0.9970,  0.9971,  0.9972,  0.9973,  0.9974},
+    {0.9974,  0.9975,  0.9976,  0.9977,  0.9977,  0.9978,  0.9979,  0.9979,  0.9980,  0.9981},
+    {0.9981,  0.9982,  0.9982,  0.9983,  0.9984,  0.9984,  0.9985,  0.9985,  0.9986,  0.9986},
+    {0.9987,  0.9987,  0.9987,  0.9988,  0.9988,  0.9989,  0.9989,  0.9989,  0.9990,  0.9990} };
+
+// Inverse cumulative distribution function
+static double inv_cdf(double u)
+{
+    const double a[4] = { 2.50662823884,
+                         -18.61500062529,
+                          41.39119773534,
+                         -25.44106049637};
+
+    const double b[4] = {-8.47351093090,
+                          23.08336743743,
+                         -21.06224101826,
+                           3.13082909833};
+
+    const double c[9] = {0.3374754822726147,
+                          0.9761690190917186,
+                          0.1607979714918209,
+                          0.0276438810333863,
+                          0.0038405729373609,
+                          0.0003951896511919,
+                          0.0000321767881768,
+                          0.0000002888167364,
+                          0.0000003960315187};
+
+    double r;
+    double x = u - 0.5;
+
+    // Beasley-Springer
+     if (fabs(x) < 0.42) {
+
+        double y = x * x;
+        r        = x * (((a[3]*y+a[2])*y+a[1])*y+a[0]) /
+                        ((((b[3]*y+b[2])*y+b[1])*y+b[0])*y+1.0);
+    }
+    else {// Moro
+        r = u;
+        if (x > 0.0)
+            r = 1.0 - u;
+        r = log(-log(r));
+        r = c[0] + r*(c[1]+r*(c[2]+r*(c[3]+r*(c[4]+r*(c[5]+r*(c[6]+
+                                                        r*(c[7]+r*c[8])))))));
+        if (x < 0.0)
+            r = -r;
+    }
+
+    return r;
+}
 int main(void)
 {
     int x = 0;
     int i, j;
     AVLFG state;
-
     av_lfg_init(&state, 0xdeadbeef);
     for (j = 0; j < 10000; j++) {
-        START_TIMER
         for (i = 0; i < 624; i++) {
             //av_log(NULL, AV_LOG_ERROR, "%X\n", av_lfg_get(&state));
             x += av_lfg_get(&state);
         }
-        STOP_TIMER("624 calls of av_lfg_get");
     }
     av_log(NULL, AV_LOG_ERROR, "final value:%X\n", x);
 
@@ -41,34 +117,75 @@ int main(void)
     {
         double mean   = 1000;
         double stddev = 53;
-        double samp_mean = 0.0, samp_stddev = 0.0;
-        double samp0, samp1;
+        double samp_mean = 0.0, samp_stddev = 0.0, QH = 0;
+        double Z, p_value = -1, tot_samp = 1000;
+        double *PRN_arr = av_malloc_array(tot_samp, sizeof(double));
 
-        av_lfg_init(&state, 42);
+        if (!PRN_arr) {
+            fprintf(stderr, "failed to allocate memory!\n");
+            return 1;
+        }
 
-        for (i = 0; i < 1000; i += 2) {
+        av_lfg_init(&state, 42);
+        for (i = 0; i < tot_samp; i += 2) {
             double bmg_out[2];
             av_bmg_get(&state, bmg_out);
-            samp0 = bmg_out[0] * stddev + mean;
-            samp1 = bmg_out[1] * stddev + mean;
-            samp_mean += samp0 + samp1;
-            samp_stddev += samp0 * samp0 + samp1 * samp1;
-            av_log(NULL, AV_LOG_INFO,
-                   "%f\n%f\n",
-                   samp0,
-                   samp1);
+            PRN_arr[i  ] = bmg_out[0] * stddev + mean;
+            PRN_arr[i+1] = bmg_out[1] * stddev + mean;
+            samp_mean   += PRN_arr[i] + PRN_arr[i+1];
+            samp_stddev += PRN_arr[i] * PRN_arr[i] + PRN_arr[i+1] * PRN_arr[i+1];
+            printf("PRN%d : %f\n"
+                   "PRN%d : %f\n",
+                   i, PRN_arr[i], i+1, PRN_arr[i+1]);
         }
-        /* TODO: add proper normality test */
-        samp_mean /= 1000;
-        samp_stddev /= 999;
-        samp_stddev -= (1000.0/999.0)*samp_mean*samp_mean;
+        samp_mean /= tot_samp;
+        samp_stddev /= (tot_samp - 1);
+        samp_stddev -= (tot_samp * 1.0 / (tot_samp - 1))*samp_mean*samp_mean;
         samp_stddev = sqrt(samp_stddev);
-        av_log(NULL, AV_LOG_INFO, "sample mean  : %f\n"
-                                  "true mean    : %f\n"
-                                  "sample stddev: %f\n"
-                                  "true stddev  : %f\n",
-                                   samp_mean, mean, samp_stddev, stddev);
-    }
+        Z = (mean - samp_mean) / (stddev / sqrt(tot_samp));
+        {
+            int x, y, a, b, flag = 0;
+
+            if (Z < 0.0) {
+                flag = !flag;
+                Z = Z * -1.0;
+            }
+
+            a = (int)(Z * 100);
+            b = ((int)Z * 100);
+            x = Z * 10;
+            y = (b > 0) ? a % b : a;
+            y = y % 10;
+            if (x > 30 || y > 9) {
+                av_log(NULL, AV_LOG_INFO, "error: out of bounds! tried to access"
+                                          "Z_TABLE[%d][%d]\n", x, y);
+                goto SKIP;
+            }
+            p_value = flag ? 1 - Z_TABLE[x][y] : Z_TABLE[x][y];
+        }
 
+SKIP:   for (i = 0; i < tot_samp; ++i) {
+
+            if ( i < (tot_samp - 1)) {
+                double H_diff;
+                H_diff  = inv_cdf((i + 2.0 - (3.0/8.0)) / (tot_samp + (1.0/4.0)));
+                H_diff -= inv_cdf((i + 1.0 - (3.0/8.0)) / (tot_samp + (1.0/4.0)));
+
+                QH     += ((PRN_arr[i + 1] - PRN_arr[i]) / H_diff);
+            }
+        }
+        QH = 1.0 - QH / ((tot_samp - 1.0) * samp_stddev);
+
+        printf("sample mean  : %f\n"
+               "true mean    : %f\n"
+               "sample stddev: %f\n"
+               "true stddev  : %f\n"
+               "z-score      : %f\n"
+               "p-value      : %f\n"
+               "QH[normality]: %f\n",
+               samp_mean, mean, samp_stddev, stddev, Z, p_value, QH);
+
+        av_freep(&PRN_arr);
+    }
     return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavutil/tests/parseutils.c b/mythtv/external/FFmpeg/libavutil/tests/parseutils.c
index 682b3907cfc..180f6240023 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/parseutils.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/parseutils.c
@@ -138,6 +138,13 @@ static void test_av_small_strptime(void)
         { "%Y - %m - %d",                "2012-12-21" },
         { "%Y-%m-%d %H:%M:%S",           "2012-12-21 20:12:21" },
         { "  %Y - %m - %d %H : %M : %S", "   2012 - 12 -  21   20 : 12 : 21" },
+        { "  %Y - %b - %d %H : %M : %S", "   2012 - nOV -  21   20 : 12 : 21" },
+        { "  %Y - %B - %d %H : %M : %S", "   2012 - nOVemBeR -  21   20 : 12 : 21" },
+        { "  %Y - %B%d %H : %M : %S", "   2012 - may21   20 : 12 : 21" },
+        { "  %Y - %B%d %H : %M : %S", "   2012 - mby21   20 : 12 : 21" },
+        { "  %Y - %B - %d %H : %M : %S", "   2012 - JunE -  21   20 : 12 : 21" },
+        { "  %Y - %B - %d %H : %M : %S", "   2012 - Jane -  21   20 : 12 : 21" },
+        { "  %Y - %B - %d %H : %M : %S", "   2012 - January -  21   20 : 12 : 21" },
     };
 
     av_log_set_level(AV_LOG_DEBUG);
diff --git a/mythtv/external/FFmpeg/libavutil/tests/pixfmt_best.c b/mythtv/external/FFmpeg/libavutil/tests/pixfmt_best.c
new file mode 100644
index 00000000000..e98fcc19a50
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/tests/pixfmt_best.c
@@ -0,0 +1,139 @@
+/*
+ * 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/pixdesc.c"
+
+static const enum AVPixelFormat pixfmt_list[] = {
+    AV_PIX_FMT_MONOWHITE,
+    AV_PIX_FMT_GRAY8,
+    AV_PIX_FMT_GRAY10,
+    AV_PIX_FMT_GRAY16,
+    AV_PIX_FMT_YUV420P,
+    AV_PIX_FMT_YUV420P10,
+    AV_PIX_FMT_YUV420P16,
+    AV_PIX_FMT_YUV422P,
+    AV_PIX_FMT_YUV422P10,
+    AV_PIX_FMT_YUV422P16,
+    AV_PIX_FMT_YUV444P,
+    AV_PIX_FMT_YUV444P10,
+    AV_PIX_FMT_YUV444P16,
+    AV_PIX_FMT_RGB565,
+    AV_PIX_FMT_RGB24,
+    AV_PIX_FMT_RGB48,
+    AV_PIX_FMT_VDPAU,
+    AV_PIX_FMT_VAAPI,
+};
+
+static enum AVPixelFormat find_best(enum AVPixelFormat pixfmt)
+{
+    enum AVPixelFormat best = AV_PIX_FMT_NONE;
+    int i;
+    for (i = 0; i < FF_ARRAY_ELEMS(pixfmt_list); i++)
+        best = av_find_best_pix_fmt_of_2(best, pixfmt_list[i],
+                                         pixfmt, 0, NULL);
+    return best;
+}
+
+int main(void)
+{
+    enum AVPixelFormat output;
+    int i, pass = 0, fail = 0;
+
+#define TEST(input, expected) do {                              \
+        output = find_best(input);                              \
+        if (output != expected) {                               \
+            printf("Matching %s: got %s, expected %s\n",        \
+                   av_get_pix_fmt_name(input),                  \
+                   av_get_pix_fmt_name(output),                 \
+                   av_get_pix_fmt_name(expected));              \
+            ++fail;                                             \
+        } else                                                  \
+            ++pass;                                             \
+    } while (0)
+
+    // Same formats.
+    for (i = 0; i < FF_ARRAY_ELEMS(pixfmt_list); i++)
+        TEST(pixfmt_list[i], pixfmt_list[i]);
+
+    // Formats containing the same data in different layouts.
+    TEST(AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_MONOWHITE);
+    TEST(AV_PIX_FMT_NV12,      AV_PIX_FMT_YUV420P);
+    TEST(AV_PIX_FMT_P010,      AV_PIX_FMT_YUV420P10);
+    TEST(AV_PIX_FMT_P016,      AV_PIX_FMT_YUV420P16);
+    TEST(AV_PIX_FMT_NV16,      AV_PIX_FMT_YUV422P);
+    TEST(AV_PIX_FMT_YUYV422,   AV_PIX_FMT_YUV422P);
+    TEST(AV_PIX_FMT_UYVY422,   AV_PIX_FMT_YUV422P);
+    TEST(AV_PIX_FMT_BGR565,    AV_PIX_FMT_RGB565);
+    TEST(AV_PIX_FMT_BGR24,     AV_PIX_FMT_RGB24);
+    TEST(AV_PIX_FMT_GBRP,      AV_PIX_FMT_RGB24);
+    TEST(AV_PIX_FMT_0RGB,      AV_PIX_FMT_RGB24);
+    TEST(AV_PIX_FMT_GBRP16,    AV_PIX_FMT_RGB48);
+
+    // Formats additionally containing alpha (here ignored).
+    TEST(AV_PIX_FMT_YA8,       AV_PIX_FMT_GRAY8);
+    TEST(AV_PIX_FMT_YA16,      AV_PIX_FMT_GRAY16);
+    TEST(AV_PIX_FMT_YUVA420P,  AV_PIX_FMT_YUV420P);
+    TEST(AV_PIX_FMT_YUVA422P,  AV_PIX_FMT_YUV422P);
+    TEST(AV_PIX_FMT_YUVA444P,  AV_PIX_FMT_YUV444P);
+    TEST(AV_PIX_FMT_AYUV64,    AV_PIX_FMT_YUV444P16);
+    TEST(AV_PIX_FMT_RGBA,      AV_PIX_FMT_RGB24);
+    TEST(AV_PIX_FMT_ABGR,      AV_PIX_FMT_RGB24);
+    TEST(AV_PIX_FMT_GBRAP,     AV_PIX_FMT_RGB24);
+    TEST(AV_PIX_FMT_RGBA64,    AV_PIX_FMT_RGB48);
+    TEST(AV_PIX_FMT_BGRA64,    AV_PIX_FMT_RGB48);
+    TEST(AV_PIX_FMT_GBRAP16,   AV_PIX_FMT_RGB48);
+
+    // Formats requiring upsampling to represent exactly.
+    TEST(AV_PIX_FMT_GRAY12,    AV_PIX_FMT_GRAY16);
+    TEST(AV_PIX_FMT_YUV410P,   AV_PIX_FMT_YUV420P);
+    TEST(AV_PIX_FMT_YUV411P,   AV_PIX_FMT_YUV422P);
+    TEST(AV_PIX_FMT_UYYVYY411, AV_PIX_FMT_YUV422P);
+    TEST(AV_PIX_FMT_YUV440P,   AV_PIX_FMT_YUV444P);
+    TEST(AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV444P10);
+    TEST(AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV444P16);
+    TEST(AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV420P10);
+    TEST(AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV420P16);
+    TEST(AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV444P10);
+    TEST(AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P16);
+    TEST(AV_PIX_FMT_BGR4,      AV_PIX_FMT_RGB565);
+    TEST(AV_PIX_FMT_RGB444,    AV_PIX_FMT_RGB565);
+    TEST(AV_PIX_FMT_RGB555,    AV_PIX_FMT_RGB565);
+    TEST(AV_PIX_FMT_GBRP10,    AV_PIX_FMT_RGB48);
+    TEST(AV_PIX_FMT_GBRAP10,   AV_PIX_FMT_RGB48);
+    TEST(AV_PIX_FMT_GBRAP12,   AV_PIX_FMT_RGB48);
+
+    // Formats containing the same data in different endianness.
+    TEST(AV_PIX_FMT_GRAY10BE,    AV_PIX_FMT_GRAY10);
+    TEST(AV_PIX_FMT_GRAY10LE,    AV_PIX_FMT_GRAY10);
+    TEST(AV_PIX_FMT_GRAY16BE,    AV_PIX_FMT_GRAY16);
+    TEST(AV_PIX_FMT_GRAY16LE,    AV_PIX_FMT_GRAY16);
+    TEST(AV_PIX_FMT_YUV422P10BE, AV_PIX_FMT_YUV422P10);
+    TEST(AV_PIX_FMT_YUV422P10LE, AV_PIX_FMT_YUV422P10);
+    TEST(AV_PIX_FMT_YUV444P16BE, AV_PIX_FMT_YUV444P16);
+    TEST(AV_PIX_FMT_YUV444P16LE, AV_PIX_FMT_YUV444P16);
+    TEST(AV_PIX_FMT_RGB565BE,    AV_PIX_FMT_RGB565);
+    TEST(AV_PIX_FMT_RGB565LE,    AV_PIX_FMT_RGB565);
+    TEST(AV_PIX_FMT_RGB48BE,     AV_PIX_FMT_RGB48);
+    TEST(AV_PIX_FMT_RGB48LE,     AV_PIX_FMT_RGB48);
+
+    // Opaque formats are least unlike each other.
+    TEST(AV_PIX_FMT_DXVA2_VLD, AV_PIX_FMT_VDPAU);
+
+    printf("%d tests passed, %d tests failed.\n", pass, fail);
+    return !!fail;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/tests/random_seed.c b/mythtv/external/FFmpeg/libavutil/tests/random_seed.c
index ebe9b3e7dd9..78067dbe41a 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/random_seed.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/random_seed.c
@@ -23,24 +23,33 @@
 
 #undef printf
 #define N 256
+#define F 2
 #include <stdio.h>
 
+typedef uint32_t (*random_seed_ptr_t)(void);
+
 int main(void)
 {
-    int i, j, retry;
+    int i, j, rsf, retry;
     uint32_t seeds[N];
+    random_seed_ptr_t random_seed[F] = {av_get_random_seed, get_generic_seed};
 
-    for (retry=0; retry<3; retry++){
-        for (i=0; i<N; i++){
-            seeds[i] = av_get_random_seed();
-            for (j=0; j<i; j++)
-                if (seeds[j] == seeds[i])
-                    goto retry;
+    for (rsf=0; rsf<F; ++rsf){
+        for (retry=0; retry<3; retry++){
+            for (i=0; i<N; i++){
+                seeds[i] = random_seed[rsf]();
+                for (j=0; j<i; j++)
+                    if (seeds[j] == seeds[i])
+                        goto retry;
+            }
+            printf("seeds OK\n");
+            break;
+            retry:;
+        }
+        if (retry >= 3) {
+            printf("rsf %d: FAIL at %d with %X\n", rsf, j, seeds[j]);
+            return 1;
         }
-        printf("seeds OK\n");
-        return 0;
-        retry:;
     }
-    printf("FAIL at %d with %X\n", j, seeds[j]);
-    return 1;
+    return 0;
 }
diff --git a/mythtv/external/FFmpeg/libavutil/tests/softfloat.c b/mythtv/external/FFmpeg/libavutil/tests/softfloat.c
index 16788d4da97..c06de449334 100644
--- a/mythtv/external/FFmpeg/libavutil/tests/softfloat.c
+++ b/mythtv/external/FFmpeg/libavutil/tests/softfloat.c
@@ -18,6 +18,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/timer.h"
+
 #include <inttypes.h>
 
 #include "libavutil/softfloat.h"
diff --git a/mythtv/external/FFmpeg/libavutil/thread.h b/mythtv/external/FFmpeg/libavutil/thread.h
index 32ddf40365a..f108e200526 100644
--- a/mythtv/external/FFmpeg/libavutil/thread.h
+++ b/mythtv/external/FFmpeg/libavutil/thread.h
@@ -26,8 +26,6 @@
 
 #if HAVE_PTHREADS || HAVE_W32THREADS || HAVE_OS2THREADS
 
-#define USE_ATOMICS 0
-
 #if HAVE_PTHREADS
 #include <pthread.h>
 
@@ -38,8 +36,11 @@
 #define ASSERT_PTHREAD_NORET(func, ...) do {                            \
     int ret = func(__VA_ARGS__);                                        \
     if (ret) {                                                          \
+        char errbuf[AV_ERROR_MAX_STRING_SIZE] = "";                     \
         av_log(NULL, AV_LOG_FATAL, AV_STRINGIFY(func)                   \
-               " failed with error: %s\n", av_err2str(AVERROR(ret)));   \
+               " failed with error: %s\n",                              \
+               av_make_error_string(errbuf, AV_ERROR_MAX_STRING_SIZE,   \
+                                    AVERROR(ret)));                     \
         abort();                                                        \
     }                                                                   \
 } while (0)
@@ -146,8 +147,6 @@ static inline int strict_pthread_once(pthread_once_t *once_control, void (*init_
 
 #else
 
-#define USE_ATOMICS 1
-
 #define AVMutex char
 
 #define ff_mutex_init(mutex, attr) (0)
diff --git a/mythtv/external/FFmpeg/libavutil/threadmessage.c b/mythtv/external/FFmpeg/libavutil/threadmessage.c
index 7c5cd2463ce..872e9392b19 100644
--- a/mythtv/external/FFmpeg/libavutil/threadmessage.c
+++ b/mythtv/external/FFmpeg/libavutil/threadmessage.c
@@ -69,7 +69,7 @@ int av_thread_message_queue_alloc(AVThreadMessageQueue **mq,
         pthread_cond_destroy(&rmq->cond_recv);
         pthread_mutex_destroy(&rmq->lock);
         av_free(rmq);
-        return AVERROR(ret);
+        return AVERROR(ENOMEM);
     }
     rmq->elsize = elsize;
     *mq = rmq;
diff --git a/mythtv/external/FFmpeg/libavutil/time.c b/mythtv/external/FFmpeg/libavutil/time.c
index dbaee0264c7..afa6658aa62 100644
--- a/mythtv/external/FFmpeg/libavutil/time.c
+++ b/mythtv/external/FFmpeg/libavutil/time.c
@@ -56,17 +56,25 @@ int64_t av_gettime(void)
 int64_t av_gettime_relative(void)
 {
 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
-    struct timespec ts;
-    clock_gettime(CLOCK_MONOTONIC, &ts);
-    return (int64_t)ts.tv_sec * 1000000 + ts.tv_nsec / 1000;
-#else
-    return av_gettime() + 42 * 60 * 60 * INT64_C(1000000);
+#ifdef __APPLE__
+    if (clock_gettime)
+#endif
+    {
+        struct timespec ts;
+        clock_gettime(CLOCK_MONOTONIC, &ts);
+        return (int64_t)ts.tv_sec * 1000000 + ts.tv_nsec / 1000;
+    }
 #endif
+    return av_gettime() + 42 * 60 * 60 * INT64_C(1000000);
 }
 
 int av_gettime_relative_is_monotonic(void)
 {
 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)
+#ifdef __APPLE__
+    if (!clock_gettime)
+        return 0;
+#endif
     return 1;
 #else
     return 0;
diff --git a/mythtv/external/FFmpeg/libavutil/timecode.c b/mythtv/external/FFmpeg/libavutil/timecode.c
index fa92df1ef98..c0c67c84786 100644
--- a/mythtv/external/FFmpeg/libavutil/timecode.c
+++ b/mythtv/external/FFmpeg/libavutil/timecode.c
@@ -129,7 +129,8 @@ char *av_timecode_make_smpte_tc_string(char *buf, uint32_t tcsmpte, int prevent_
 
 char *av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)
 {
-    snprintf(buf, AV_TIMECODE_STR_SIZE, "%02u:%02u:%02u%c%02u",
+    snprintf(buf, AV_TIMECODE_STR_SIZE,
+             "%02"PRIu32":%02"PRIu32":%02"PRIu32"%c%02"PRIu32,
              tc25bit>>19 & 0x1f,              // 5-bit hours
              tc25bit>>13 & 0x3f,              // 6-bit minutes
              tc25bit>>6  & 0x3f,              // 6-bit seconds
diff --git a/mythtv/external/FFmpeg/libavutil/timecode.h b/mythtv/external/FFmpeg/libavutil/timecode.h
index 56e3975fd89..37c1361bc28 100644
--- a/mythtv/external/FFmpeg/libavutil/timecode.h
+++ b/mythtv/external/FFmpeg/libavutil/timecode.h
@@ -30,7 +30,7 @@
 #include <stdint.h>
 #include "rational.h"
 
-#define AV_TIMECODE_STR_SIZE 16
+#define AV_TIMECODE_STR_SIZE 23
 
 enum AVTimecodeFlag {
     AV_TIMECODE_FLAG_DROPFRAME      = 1<<0, ///< timecode is drop frame
diff --git a/mythtv/external/FFmpeg/libavutil/timer.h b/mythtv/external/FFmpeg/libavutil/timer.h
index ed3b0478708..f7ab455df22 100644
--- a/mythtv/external/FFmpeg/libavutil/timer.h
+++ b/mythtv/external/FFmpeg/libavutil/timer.h
@@ -26,12 +26,22 @@
 #ifndef AVUTIL_TIMER_H
 #define AVUTIL_TIMER_H
 
+#include "config.h"
+
+#if CONFIG_LINUX_PERF
+# ifndef _GNU_SOURCE
+#  define _GNU_SOURCE
+# endif
+# include <unistd.h> // read(3)
+# include <sys/ioctl.h>
+# include <asm/unistd.h>
+# include <linux/perf_event.h>
+#endif
+
 #include <stdlib.h>
 #include <stdint.h>
 #include <inttypes.h>
 
-#include "config.h"
-
 #if HAVE_MACH_MACH_TIME_H
 #include <mach/mach_time.h>
 #endif
@@ -60,23 +70,17 @@
 #   define FF_TIMER_UNITS "UNITS"
 #endif
 
-#ifdef AV_READ_TIME
-#define START_TIMER                             \
-    uint64_t tend;                              \
-    uint64_t tstart = AV_READ_TIME();           \
-
-#define STOP_TIMER(id)                                                    \
-    tend = AV_READ_TIME();                                                \
+#define TIMER_REPORT(id, tdiff)                                           \
     {                                                                     \
         static uint64_t tsum   = 0;                                       \
         static int tcount      = 0;                                       \
         static int tskip_count = 0;                                       \
         static int thistogram[32] = {0};                                  \
-        thistogram[av_log2(tend - tstart)]++;                             \
-        if (tcount < 2                        ||                          \
-            tend - tstart < 8 * tsum / tcount ||                          \
-            tend - tstart < 2000) {                                       \
-            tsum+= tend - tstart;                                         \
+        thistogram[av_log2(tdiff)]++;                                     \
+        if (tcount < 2                ||                                  \
+            (tdiff) < 8 * tsum / tcount ||                                \
+            (tdiff) < 2000) {                                             \
+            tsum += (tdiff);                                              \
             tcount++;                                                     \
         } else                                                            \
             tskip_count++;                                                \
@@ -90,6 +94,45 @@
             av_log(NULL, AV_LOG_ERROR, "\n");                             \
         }                                                                 \
     }
+
+#if CONFIG_LINUX_PERF
+
+#define START_TIMER                                                         \
+    static int linux_perf_fd;                                               \
+    uint64_t tperf;                                                         \
+    if (!linux_perf_fd) {                                                   \
+        struct perf_event_attr attr = {                                     \
+            .type           = PERF_TYPE_HARDWARE,                           \
+            .size           = sizeof(struct perf_event_attr),               \
+            .config         = PERF_COUNT_HW_CPU_CYCLES,                     \
+            .disabled       = 1,                                            \
+            .exclude_kernel = 1,                                            \
+            .exclude_hv     = 1,                                            \
+        };                                                                  \
+        linux_perf_fd = syscall(__NR_perf_event_open, &attr,                \
+                                0, -1, -1, 0);                              \
+    }                                                                       \
+    if (linux_perf_fd == -1) {                                              \
+        av_log(NULL, AV_LOG_ERROR, "perf_event_open failed: %s\n",          \
+               av_err2str(AVERROR(errno)));                                 \
+    } else {                                                                \
+        ioctl(linux_perf_fd, PERF_EVENT_IOC_RESET, 0);                      \
+        ioctl(linux_perf_fd, PERF_EVENT_IOC_ENABLE, 0);                     \
+    }
+
+#define STOP_TIMER(id)                                                      \
+    ioctl(linux_perf_fd, PERF_EVENT_IOC_DISABLE, 0);                        \
+    read(linux_perf_fd, &tperf, sizeof(tperf));                             \
+    TIMER_REPORT(id, tperf)
+
+#elif defined(AV_READ_TIME)
+#define START_TIMER                             \
+    uint64_t tend;                              \
+    uint64_t tstart = AV_READ_TIME();           \
+
+#define STOP_TIMER(id)                                                    \
+    tend = AV_READ_TIME();                                                \
+    TIMER_REPORT(id, tend - tstart)
 #else
 #define START_TIMER
 #define STOP_TIMER(id) { }
diff --git a/mythtv/external/FFmpeg/libavutil/utils.c b/mythtv/external/FFmpeg/libavutil/utils.c
index 36e4dd5fdbe..2c170db2e10 100644
--- a/mythtv/external/FFmpeg/libavutil/utils.c
+++ b/mythtv/external/FFmpeg/libavutil/utils.c
@@ -121,6 +121,29 @@ unsigned av_int_list_length_for_size(unsigned elsize,
     return i;
 }
 
+char *av_fourcc_make_string(char *buf, uint32_t fourcc)
+{
+    int i;
+    char *orig_buf = buf;
+    size_t buf_size = AV_FOURCC_MAX_STRING_SIZE;
+
+    for (i = 0; i < 4; i++) {
+        const int c = fourcc & 0xff;
+        const int print_chr = (c >= '0' && c <= '9') ||
+                              (c >= 'a' && c <= 'z') ||
+                              (c >= 'A' && c <= 'Z') ||
+                              (c && strchr(". -_", c));
+        const int len = snprintf(buf, buf_size, print_chr ? "%c" : "[%d]", c);
+        if (len < 0)
+            break;
+        buf += len;
+        buf_size = buf_size > len ? buf_size - len : 0;
+        fourcc >>= 8;
+    }
+
+    return orig_buf;
+}
+
 AVRational av_get_time_base_q(void)
 {
     return (AVRational){1, AV_TIME_BASE};
@@ -129,7 +152,7 @@ AVRational av_get_time_base_q(void)
 void av_assert0_fpu(void) {
 #if HAVE_MMX_INLINE
     uint16_t state[14];
-     __asm volatile (
+     __asm__ volatile (
         "fstenv %0 \n\t"
         : "+m" (state)
         :
diff --git a/mythtv/external/FFmpeg/libavutil/version.h b/mythtv/external/FFmpeg/libavutil/version.h
index bdd310f855e..f594dc06918 100644
--- a/mythtv/external/FFmpeg/libavutil/version.h
+++ b/mythtv/external/FFmpeg/libavutil/version.h
@@ -78,8 +78,9 @@
  * @{
  */
 
+
 #define LIBAVUTIL_VERSION_MAJOR  55
-#define LIBAVUTIL_VERSION_MINOR  34
+#define LIBAVUTIL_VERSION_MINOR  78
 #define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
@@ -135,6 +136,9 @@
 #ifndef FF_API_PKT_PTS
 #define FF_API_PKT_PTS                  (LIBAVUTIL_VERSION_MAJOR < 56)
 #endif
+#ifndef FF_API_CRYPTO_SIZE_T
+#define FF_API_CRYPTO_SIZE_T            (LIBAVUTIL_VERSION_MAJOR < 56)
+#endif
 
 
 /**
diff --git a/mythtv/external/FFmpeg/libavutil/x86/Makefile b/mythtv/external/FFmpeg/libavutil/x86/Makefile
index 94d88320622..5f5242b5bdd 100644
--- a/mythtv/external/FFmpeg/libavutil/x86/Makefile
+++ b/mythtv/external/FFmpeg/libavutil/x86/Makefile
@@ -1,16 +1,18 @@
 OBJS += x86/cpu.o                                                       \
         x86/fixed_dsp_init.o                                            \
         x86/float_dsp_init.o                                            \
+        x86/imgutils_init.o                                             \
         x86/lls_init.o                                                  \
 
 OBJS-$(CONFIG_PIXELUTILS) += x86/pixelutils_init.o                      \
 
 EMMS_OBJS_$(HAVE_MMX_INLINE)_$(HAVE_MMX_EXTERNAL)_$(HAVE_MM_EMPTY) = x86/emms.o
 
-YASM-OBJS += x86/cpuid.o                                                \
+X86ASM-OBJS += x86/cpuid.o                                              \
              $(EMMS_OBJS__yes_)                                      \
              x86/fixed_dsp.o                                            \
              x86/float_dsp.o                                            \
+             x86/imgutils.o                                             \
              x86/lls.o                                                  \
 
-YASM-OBJS-$(CONFIG_PIXELUTILS) += x86/pixelutils.o                      \
+X86ASM-OBJS-$(CONFIG_PIXELUTILS) += x86/pixelutils.o                    \
diff --git a/mythtv/external/FFmpeg/libavutil/x86/cpu.c b/mythtv/external/FFmpeg/libavutil/x86/cpu.c
index f3a49c67729..f33088c8c73 100644
--- a/mythtv/external/FFmpeg/libavutil/x86/cpu.c
+++ b/mythtv/external/FFmpeg/libavutil/x86/cpu.c
@@ -28,7 +28,7 @@
 #include "libavutil/cpu.h"
 #include "libavutil/cpu_internal.h"
 
-#if HAVE_YASM
+#if HAVE_X86ASM
 
 #define cpuid(index, eax, ebx, ecx, edx)        \
     ff_cpu_cpuid(index, &eax, &ebx, &ecx, &edx)
@@ -66,7 +66,7 @@
 
 #define cpuid_test() 1
 
-#elif HAVE_YASM
+#elif HAVE_X86ASM
 
 #define cpuid_test ff_cpu_cpuid_test
 
@@ -221,9 +221,42 @@ int ff_get_cpu_flags_x86(void)
          * functions on the Atom. */
         if (family == 6 && model == 28)
             rval |= AV_CPU_FLAG_ATOM;
+
+        /* Conroe has a slow shuffle unit. Check the model number to ensure not
+         * to include crippled low-end Penryns and Nehalems that lack SSE4. */
+        if ((rval & AV_CPU_FLAG_SSSE3) && !(rval & AV_CPU_FLAG_SSE4) &&
+            family == 6 && model < 23)
+            rval |= AV_CPU_FLAG_SSSE3SLOW;
     }
 
 #endif /* cpuid */
 
     return rval;
 }
+
+size_t ff_get_cpu_max_align_x86(void)
+{
+    int flags = av_get_cpu_flags();
+
+    if (flags & (AV_CPU_FLAG_AVX2      |
+                 AV_CPU_FLAG_AVX       |
+                 AV_CPU_FLAG_XOP       |
+                 AV_CPU_FLAG_FMA4      |
+                 AV_CPU_FLAG_FMA3      |
+                 AV_CPU_FLAG_AVXSLOW))
+        return 32;
+    if (flags & (AV_CPU_FLAG_AESNI     |
+                 AV_CPU_FLAG_SSE42     |
+                 AV_CPU_FLAG_SSE4      |
+                 AV_CPU_FLAG_SSSE3     |
+                 AV_CPU_FLAG_SSE3      |
+                 AV_CPU_FLAG_SSE2      |
+                 AV_CPU_FLAG_SSE       |
+                 AV_CPU_FLAG_ATOM      |
+                 AV_CPU_FLAG_SSSE3SLOW |
+                 AV_CPU_FLAG_SSE3SLOW  |
+                 AV_CPU_FLAG_SSE2SLOW))
+        return 16;
+
+    return 8;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/x86/cpu.h b/mythtv/external/FFmpeg/libavutil/x86/cpu.h
index f171037f1c7..309b8e746c5 100644
--- a/mythtv/external/FFmpeg/libavutil/x86/cpu.h
+++ b/mythtv/external/FFmpeg/libavutil/x86/cpu.h
@@ -38,6 +38,8 @@
 #define X86_SSE3_FAST(flags)        CPUEXT_FAST(flags, SSE3)
 #define X86_SSE3_SLOW(flags)        CPUEXT_SLOW(flags, SSE3)
 #define X86_SSSE3(flags)            CPUEXT(flags, SSSE3)
+#define X86_SSSE3_FAST(flags)       CPUEXT_FAST(flags, SSSE3)
+#define X86_SSSE3_SLOW(flags)       CPUEXT_SLOW(flags, SSSE3)
 #define X86_SSE4(flags)             CPUEXT(flags, SSE4)
 #define X86_SSE42(flags)            CPUEXT(flags, SSE42)
 #define X86_AVX(flags)              CPUEXT(flags, AVX)
@@ -61,6 +63,8 @@
 #define EXTERNAL_SSE3_FAST(flags)   CPUEXT_SUFFIX_FAST(flags, _EXTERNAL, SSE3)
 #define EXTERNAL_SSE3_SLOW(flags)   CPUEXT_SUFFIX_SLOW(flags, _EXTERNAL, SSE3)
 #define EXTERNAL_SSSE3(flags)       CPUEXT_SUFFIX(flags, _EXTERNAL, SSSE3)
+#define EXTERNAL_SSSE3_FAST(flags)  CPUEXT_SUFFIX_FAST(flags, _EXTERNAL, SSSE3)
+#define EXTERNAL_SSSE3_SLOW(flags)  CPUEXT_SUFFIX_SLOW(flags, _EXTERNAL, SSSE3)
 #define EXTERNAL_SSE4(flags)        CPUEXT_SUFFIX(flags, _EXTERNAL, SSE4)
 #define EXTERNAL_SSE42(flags)       CPUEXT_SUFFIX(flags, _EXTERNAL, SSE42)
 #define EXTERNAL_AVX(flags)         CPUEXT_SUFFIX(flags, _EXTERNAL, AVX)
@@ -88,6 +92,8 @@
 #define INLINE_SSE3_FAST(flags)     CPUEXT_SUFFIX_FAST(flags, _INLINE, SSE3)
 #define INLINE_SSE3_SLOW(flags)     CPUEXT_SUFFIX_SLOW(flags, _INLINE, SSE3)
 #define INLINE_SSSE3(flags)         CPUEXT_SUFFIX(flags, _INLINE, SSSE3)
+#define INLINE_SSSE3_FAST(flags)    CPUEXT_SUFFIX_FAST(flags, _INLINE, SSSE3)
+#define INLINE_SSSE3_SLOW(flags)    CPUEXT_SUFFIX_SLOW(flags, _INLINE, SSSE3)
 #define INLINE_SSE4(flags)          CPUEXT_SUFFIX(flags, _INLINE, SSE4)
 #define INLINE_SSE42(flags)         CPUEXT_SUFFIX(flags, _INLINE, SSE42)
 #define INLINE_AVX(flags)           CPUEXT_SUFFIX(flags, _INLINE, AVX)
diff --git a/mythtv/external/FFmpeg/libavutil/x86/emms.asm b/mythtv/external/FFmpeg/libavutil/x86/emms.asm
index 0aad34af3fa..8611762d737 100644
--- a/mythtv/external/FFmpeg/libavutil/x86/emms.asm
+++ b/mythtv/external/FFmpeg/libavutil/x86/emms.asm
@@ -23,8 +23,8 @@
 SECTION .text
 
 ;-----------------------------------------------------------------------------
-; void avpriv_emms_yasm(void)
+; void avpriv_emms_asm(void)
 ;-----------------------------------------------------------------------------
-cvisible emms_yasm, 0, 0
+cvisible emms_asm, 0, 0
     emms
     RET
diff --git a/mythtv/external/FFmpeg/libavutil/x86/emms.h b/mythtv/external/FFmpeg/libavutil/x86/emms.h
index 42c18e29536..c21e34b4510 100644
--- a/mythtv/external/FFmpeg/libavutil/x86/emms.h
+++ b/mythtv/external/FFmpeg/libavutil/x86/emms.h
@@ -23,7 +23,7 @@
 #include "libavutil/attributes.h"
 #include "libavutil/cpu.h"
 
-void avpriv_emms_yasm(void);
+void avpriv_emms_asm(void);
 
 #if HAVE_MMX_INLINE
 #   define emms_c emms_c
@@ -49,7 +49,7 @@ static av_always_inline void emms_c(void)
 #   include <mmintrin.h>
 #   define emms_c _mm_empty
 #elif HAVE_MMX_EXTERNAL
-#   define emms_c avpriv_emms_yasm
+#   define emms_c avpriv_emms_asm
 #endif /* HAVE_MMX_INLINE */
 
 #endif /* AVUTIL_X86_EMMS_H */
diff --git a/mythtv/external/FFmpeg/libavutil/x86/float_dsp.asm b/mythtv/external/FFmpeg/libavutil/x86/float_dsp.asm
index 021ff03c875..06d2d2cfd1b 100644
--- a/mythtv/external/FFmpeg/libavutil/x86/float_dsp.asm
+++ b/mythtv/external/FFmpeg/libavutil/x86/float_dsp.asm
@@ -22,6 +22,9 @@
 
 %include "x86util.asm"
 
+SECTION_RODATA 32
+pd_reverse: dd 7, 6, 5, 4, 3, 2, 1, 0
+
 SECTION .text
 
 ;-----------------------------------------------------------------------------
@@ -148,6 +151,69 @@ cglobal vector_fmul_scalar, 4,4,3, dst, src, mul, len
 INIT_XMM sse
 VECTOR_FMUL_SCALAR
 
+;------------------------------------------------------------------------------
+; void ff_vector_dmac_scalar(double *dst, const double *src, double mul,
+;                            int len)
+;------------------------------------------------------------------------------
+
+%macro VECTOR_DMAC_SCALAR 0
+%if ARCH_X86_32
+cglobal vector_dmac_scalar, 2,4,5, dst, src, mul, len, lenaddr
+    mov          lenq, lenaddrm
+    VBROADCASTSD m0, mulm
+%else
+%if UNIX64
+cglobal vector_dmac_scalar, 3,3,5, dst, src, len
+%else
+cglobal vector_dmac_scalar, 4,4,5, dst, src, mul, len
+    SWAP 0, 2
+%endif
+    movlhps     xm0, xm0
+%if cpuflag(avx)
+    vinsertf128  m0, m0, xm0, 1
+%endif
+%endif
+    lea    lenq, [lend*8-mmsize*4]
+.loop:
+%if cpuflag(fma3)
+    movaps   m1,     [dstq+lenq]
+    movaps   m2,     [dstq+lenq+1*mmsize]
+    movaps   m3,     [dstq+lenq+2*mmsize]
+    movaps   m4,     [dstq+lenq+3*mmsize]
+    fmaddpd  m1, m0, [srcq+lenq], m1
+    fmaddpd  m2, m0, [srcq+lenq+1*mmsize], m2
+    fmaddpd  m3, m0, [srcq+lenq+2*mmsize], m3
+    fmaddpd  m4, m0, [srcq+lenq+3*mmsize], m4
+%else ; cpuflag
+    mulpd    m1, m0, [srcq+lenq]
+    mulpd    m2, m0, [srcq+lenq+1*mmsize]
+    mulpd    m3, m0, [srcq+lenq+2*mmsize]
+    mulpd    m4, m0, [srcq+lenq+3*mmsize]
+    addpd    m1, m1, [dstq+lenq]
+    addpd    m2, m2, [dstq+lenq+1*mmsize]
+    addpd    m3, m3, [dstq+lenq+2*mmsize]
+    addpd    m4, m4, [dstq+lenq+3*mmsize]
+%endif ; cpuflag
+    movaps [dstq+lenq], m1
+    movaps [dstq+lenq+1*mmsize], m2
+    movaps [dstq+lenq+2*mmsize], m3
+    movaps [dstq+lenq+3*mmsize], m4
+    sub    lenq, mmsize*4
+    jge .loop
+    REP_RET
+%endmacro
+
+INIT_XMM sse2
+VECTOR_DMAC_SCALAR
+%if HAVE_AVX_EXTERNAL
+INIT_YMM avx
+VECTOR_DMAC_SCALAR
+%endif
+%if HAVE_FMA3_EXTERNAL
+INIT_YMM fma3
+VECTOR_DMAC_SCALAR
+%endif
+
 ;------------------------------------------------------------------------------
 ; void ff_vector_dmul_scalar(double *dst, const double *src, double mul,
 ;                            int len)
@@ -177,8 +243,8 @@ cglobal vector_dmul_scalar, 4,4,3, dst, src, mul, len
 .loop:
     mulpd          m1, m0, [srcq+lenq       ]
     mulpd          m2, m0, [srcq+lenq+mmsize]
-    mova   [dstq+lenq       ], m1
-    mova   [dstq+lenq+mmsize], m2
+    movaps [dstq+lenq       ], m1
+    movaps [dstq+lenq+mmsize], m2
     sub          lenq, 2*mmsize
     jge .loop
     REP_RET
@@ -296,10 +362,16 @@ VECTOR_FMUL_ADD
 ;-----------------------------------------------------------------------------
 %macro VECTOR_FMUL_REVERSE 0
 cglobal vector_fmul_reverse, 4,4,2, dst, src0, src1, len
+%if cpuflag(avx2)
+    movaps  m2, [pd_reverse]
+%endif
     lea       lenq, [lend*4 - 2*mmsize]
 ALIGN 16
 .loop:
-%if cpuflag(avx)
+%if cpuflag(avx2)
+    vpermps m0, m2, [src1q]
+    vpermps m1, m2, [src1q+mmsize]
+%elif cpuflag(avx)
     vmovaps     xmm0, [src1q + 16]
     vinsertf128 m0, m0, [src1q], 1
     vshufps     m0, m0, m0, q0123
@@ -314,8 +386,8 @@ ALIGN 16
 %endif
     mulps   m0, m0, [src0q + lenq + mmsize]
     mulps   m1, m1, [src0q + lenq]
-    mova    [dstq + lenq + mmsize], m0
-    mova    [dstq + lenq], m1
+    movaps  [dstq + lenq + mmsize], m0
+    movaps  [dstq + lenq], m1
     add     src1q, 2*mmsize
     sub     lenq,  2*mmsize
     jge     .loop
@@ -328,6 +400,10 @@ VECTOR_FMUL_REVERSE
 INIT_YMM avx
 VECTOR_FMUL_REVERSE
 %endif
+%if HAVE_AVX2_EXTERNAL
+INIT_YMM avx2
+VECTOR_FMUL_REVERSE
+%endif
 
 ; float scalarproduct_float_sse(const float *v1, const float *v2, int len)
 INIT_XMM sse
diff --git a/mythtv/external/FFmpeg/libavutil/x86/float_dsp_init.c b/mythtv/external/FFmpeg/libavutil/x86/float_dsp_init.c
index c836a78e1b9..122087a1962 100644
--- a/mythtv/external/FFmpeg/libavutil/x86/float_dsp_init.c
+++ b/mythtv/external/FFmpeg/libavutil/x86/float_dsp_init.c
@@ -39,6 +39,13 @@ void ff_vector_fmac_scalar_fma3(float *dst, const float *src, float mul,
 void ff_vector_fmul_scalar_sse(float *dst, const float *src, float mul,
                                int len);
 
+void ff_vector_dmac_scalar_sse2(double *dst, const double *src, double mul,
+                                int len);
+void ff_vector_dmac_scalar_avx(double *dst, const double *src, double mul,
+                               int len);
+void ff_vector_dmac_scalar_fma3(double *dst, const double *src, double mul,
+                                int len);
+
 void ff_vector_dmul_scalar_sse2(double *dst, const double *src,
                                 double mul, int len);
 void ff_vector_dmul_scalar_avx(double *dst, const double *src,
@@ -60,10 +67,12 @@ void ff_vector_fmul_reverse_sse(float *dst, const float *src0,
                                 const float *src1, int len);
 void ff_vector_fmul_reverse_avx(float *dst, const float *src0,
                                 const float *src1, int len);
+void ff_vector_fmul_reverse_avx2(float *dst, const float *src0,
+                                 const float *src1, int len);
 
 float ff_scalarproduct_float_sse(const float *v1, const float *v2, int order);
 
-void ff_butterflies_float_sse(float *src0, float *src1, int len);
+void ff_butterflies_float_sse(float *av_restrict src0, float *av_restrict src1, int len);
 
 av_cold void ff_float_dsp_init_x86(AVFloatDSPContext *fdsp)
 {
@@ -83,17 +92,23 @@ av_cold void ff_float_dsp_init_x86(AVFloatDSPContext *fdsp)
         fdsp->butterflies_float   = ff_butterflies_float_sse;
     }
     if (EXTERNAL_SSE2(cpu_flags)) {
+        fdsp->vector_dmac_scalar = ff_vector_dmac_scalar_sse2;
         fdsp->vector_dmul_scalar = ff_vector_dmul_scalar_sse2;
     }
     if (EXTERNAL_AVX_FAST(cpu_flags)) {
         fdsp->vector_fmul = ff_vector_fmul_avx;
         fdsp->vector_fmac_scalar = ff_vector_fmac_scalar_avx;
         fdsp->vector_dmul_scalar = ff_vector_dmul_scalar_avx;
+        fdsp->vector_dmac_scalar = ff_vector_dmac_scalar_avx;
         fdsp->vector_fmul_add    = ff_vector_fmul_add_avx;
         fdsp->vector_fmul_reverse = ff_vector_fmul_reverse_avx;
     }
+    if (EXTERNAL_AVX2_FAST(cpu_flags)) {
+        fdsp->vector_fmul_reverse = ff_vector_fmul_reverse_avx2;
+    }
     if (EXTERNAL_FMA3_FAST(cpu_flags)) {
         fdsp->vector_fmac_scalar = ff_vector_fmac_scalar_fma3;
         fdsp->vector_fmul_add    = ff_vector_fmul_add_fma3;
+        fdsp->vector_dmac_scalar = ff_vector_dmac_scalar_fma3;
     }
 }
diff --git a/mythtv/external/FFmpeg/libavutil/x86/imgutils.asm b/mythtv/external/FFmpeg/libavutil/x86/imgutils.asm
new file mode 100644
index 00000000000..3cca56cdca8
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/x86/imgutils.asm
@@ -0,0 +1,53 @@
+;*****************************************************************************
+;* Copyright 2016 Anton Khirnov
+;*
+;* 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/x86/x86util.asm"
+
+SECTION .text
+
+INIT_XMM sse4
+cglobal image_copy_plane_uc_from, 6, 7, 4, dst, dst_linesize, src, src_linesize, bw, height, rowpos
+    add dstq, bwq
+    add srcq, bwq
+    neg bwq
+
+.row_start:
+    mov rowposq, bwq
+
+.loop:
+    movntdqa m0, [srcq + rowposq + 0 * mmsize]
+    movntdqa m1, [srcq + rowposq + 1 * mmsize]
+    movntdqa m2, [srcq + rowposq + 2 * mmsize]
+    movntdqa m3, [srcq + rowposq + 3 * mmsize]
+
+    mova [dstq + rowposq + 0 * mmsize], m0
+    mova [dstq + rowposq + 1 * mmsize], m1
+    mova [dstq + rowposq + 2 * mmsize], m2
+    mova [dstq + rowposq + 3 * mmsize], m3
+
+    add rowposq, 4 * mmsize
+    jnz .loop
+
+    add srcq, src_linesizeq
+    add dstq, dst_linesizeq
+    dec heightd
+    jnz .row_start
+
+    RET
diff --git a/mythtv/external/FFmpeg/libavutil/x86/imgutils_init.c b/mythtv/external/FFmpeg/libavutil/x86/imgutils_init.c
new file mode 100644
index 00000000000..4ea398205e0
--- /dev/null
+++ b/mythtv/external/FFmpeg/libavutil/x86/imgutils_init.c
@@ -0,0 +1,49 @@
+/*
+ * 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 <stddef.h>
+#include <stdint.h>
+
+#include "libavutil/cpu.h"
+#include "libavutil/error.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/imgutils_internal.h"
+#include "libavutil/internal.h"
+
+#include "cpu.h"
+
+void ff_image_copy_plane_uc_from_sse4(uint8_t *dst, ptrdiff_t dst_linesize,
+                                      const uint8_t *src, ptrdiff_t src_linesize,
+                                      ptrdiff_t bytewidth, int height);
+
+int ff_image_copy_plane_uc_from_x86(uint8_t       *dst, ptrdiff_t dst_linesize,
+                                    const uint8_t *src, ptrdiff_t src_linesize,
+                                    ptrdiff_t bytewidth, int height)
+{
+    int cpu_flags = av_get_cpu_flags();
+    ptrdiff_t bw_aligned = FFALIGN(bytewidth, 64);
+
+    if (EXTERNAL_SSE4(cpu_flags) &&
+        bw_aligned <= dst_linesize && bw_aligned <= src_linesize)
+        ff_image_copy_plane_uc_from_sse4(dst, dst_linesize, src, src_linesize,
+                                         bw_aligned, height);
+    else
+        return AVERROR(ENOSYS);
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libavutil/x86/x86inc.asm b/mythtv/external/FFmpeg/libavutil/x86/x86inc.asm
index b2e9c60195e..6a054a3e092 100644
--- a/mythtv/external/FFmpeg/libavutil/x86/x86inc.asm
+++ b/mythtv/external/FFmpeg/libavutil/x86/x86inc.asm
@@ -1,7 +1,7 @@
 ;*****************************************************************************
 ;* x86inc.asm: x264asm abstraction layer
 ;*****************************************************************************
-;* Copyright (C) 2005-2016 x264 project
+;* Copyright (C) 2005-2017 x264 project
 ;*
 ;* Authors: Loren Merritt <lorenm@u.washington.edu>
 ;*          Anton Mitrofanov <BugMaster@narod.ru>
@@ -87,7 +87,9 @@
 ; keep supporting OS/2.
 %macro SECTION_RODATA 0-1 16
     %ifidn __OUTPUT_FORMAT__,aout
-        section .text
+        SECTION .text
+    %elifidn __OUTPUT_FORMAT__,coff
+        SECTION .text
     %else
         SECTION .rodata align=%1
     %endif
@@ -385,7 +387,14 @@ DECLARE_REG_TMP_SIZE 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14
     %ifnum %1
         %if %1 != 0 && required_stack_alignment > STACK_ALIGNMENT
             %if %1 > 0
+                ; Reserve an additional register for storing the original stack pointer, but avoid using
+                ; eax/rax for this purpose since it can potentially get overwritten as a return value.
                 %assign regs_used (regs_used + 1)
+                %if ARCH_X86_64 && regs_used == 7
+                    %assign regs_used 8
+                %elif ARCH_X86_64 == 0 && regs_used == 1
+                    %assign regs_used 2
+                %endif
             %endif
             %if ARCH_X86_64 && regs_used < 5 + UNIX64 * 3
                 ; Ensure that we don't clobber any registers containing arguments. For UNIX64 we also preserve r6 (rax)
@@ -419,10 +428,10 @@ DECLARE_REG 7,  rdi, 64
 DECLARE_REG 8,  rsi, 72
 DECLARE_REG 9,  rbx, 80
 DECLARE_REG 10, rbp, 88
-DECLARE_REG 11, R12, 96
-DECLARE_REG 12, R13, 104
-DECLARE_REG 13, R14, 112
-DECLARE_REG 14, R15, 120
+DECLARE_REG 11, R14, 96
+DECLARE_REG 12, R15, 104
+DECLARE_REG 13, R12, 112
+DECLARE_REG 14, R13, 120
 
 %macro PROLOGUE 2-5+ 0 ; #args, #regs, #xmm_regs, [stack_size,] arg_names...
     %assign num_args %1
@@ -468,41 +477,42 @@ DECLARE_REG 14, R15, 120
     WIN64_PUSH_XMM
 %endmacro
 
-%macro WIN64_RESTORE_XMM_INTERNAL 1
+%macro WIN64_RESTORE_XMM_INTERNAL 0
     %assign %%pad_size 0
     %if xmm_regs_used > 8
         %assign %%i xmm_regs_used
         %rep xmm_regs_used-8
             %assign %%i %%i-1
-            movaps xmm %+ %%i, [%1 + (%%i-8)*16 + stack_size + 32]
+            movaps xmm %+ %%i, [rsp + (%%i-8)*16 + stack_size + 32]
         %endrep
     %endif
     %if stack_size_padded > 0
         %if stack_size > 0 && required_stack_alignment > STACK_ALIGNMENT
             mov rsp, rstkm
         %else
-            add %1, stack_size_padded
+            add rsp, stack_size_padded
             %assign %%pad_size stack_size_padded
         %endif
     %endif
     %if xmm_regs_used > 7
-        movaps xmm7, [%1 + stack_offset - %%pad_size + 24]
+        movaps xmm7, [rsp + stack_offset - %%pad_size + 24]
     %endif
     %if xmm_regs_used > 6
-        movaps xmm6, [%1 + stack_offset - %%pad_size +  8]
+        movaps xmm6, [rsp + stack_offset - %%pad_size +  8]
     %endif
 %endmacro
 
-%macro WIN64_RESTORE_XMM 1
-    WIN64_RESTORE_XMM_INTERNAL %1
+%macro WIN64_RESTORE_XMM 0
+    WIN64_RESTORE_XMM_INTERNAL
     %assign stack_offset (stack_offset-stack_size_padded)
+    %assign stack_size_padded 0
     %assign xmm_regs_used 0
 %endmacro
 
 %define has_epilogue regs_used > 7 || xmm_regs_used > 6 || mmsize == 32 || stack_size > 0
 
 %macro RET 0
-    WIN64_RESTORE_XMM_INTERNAL rsp
+    WIN64_RESTORE_XMM_INTERNAL
     POP_IF_USED 14, 13, 12, 11, 10, 9, 8, 7
     %if mmsize == 32
         vzeroupper
@@ -523,10 +533,10 @@ DECLARE_REG 7,  R10, 16
 DECLARE_REG 8,  R11, 24
 DECLARE_REG 9,  rbx, 32
 DECLARE_REG 10, rbp, 40
-DECLARE_REG 11, R12, 48
-DECLARE_REG 12, R13, 56
-DECLARE_REG 13, R14, 64
-DECLARE_REG 14, R15, 72
+DECLARE_REG 11, R14, 48
+DECLARE_REG 12, R15, 56
+DECLARE_REG 13, R12, 64
+DECLARE_REG 14, R13, 72
 
 %macro PROLOGUE 2-5+ ; #args, #regs, #xmm_regs, [stack_size,] arg_names...
     %assign num_args %1
@@ -618,7 +628,7 @@ DECLARE_ARG 7, 8, 9, 10, 11, 12, 13, 14
 %if WIN64 == 0
     %macro WIN64_SPILL_XMM 1
     %endmacro
-    %macro WIN64_RESTORE_XMM 1
+    %macro WIN64_RESTORE_XMM 0
     %endmacro
     %macro WIN64_PUSH_XMM 0
     %endmacro
@@ -629,7 +639,7 @@ DECLARE_ARG 7, 8, 9, 10, 11, 12, 13, 14
 ; We can automatically detect "follows a branch", but not a branch target.
 ; (SSSE3 is a sufficient condition to know that your cpu doesn't have this problem.)
 %macro REP_RET 0
-    %if has_epilogue
+    %if has_epilogue || cpuflag(ssse3)
         RET
     %else
         rep ret
@@ -780,25 +790,25 @@ BRANCH_INSTR jz, je, jnz, jne, jl, jle, jnl, jnle, jg, jge, jng, jnge, ja, jae,
 %assign cpuflags_sse      (1<<4) | cpuflags_mmx2
 %assign cpuflags_sse2     (1<<5) | cpuflags_sse
 %assign cpuflags_sse2slow (1<<6) | cpuflags_sse2
-%assign cpuflags_sse3     (1<<7) | cpuflags_sse2
-%assign cpuflags_ssse3    (1<<8) | cpuflags_sse3
-%assign cpuflags_sse4     (1<<9) | cpuflags_ssse3
-%assign cpuflags_sse42    (1<<10)| cpuflags_sse4
-%assign cpuflags_avx      (1<<11)| cpuflags_sse42
-%assign cpuflags_xop      (1<<12)| cpuflags_avx
-%assign cpuflags_fma4     (1<<13)| cpuflags_avx
-%assign cpuflags_fma3     (1<<14)| cpuflags_avx
-%assign cpuflags_avx2     (1<<15)| cpuflags_fma3
-
-%assign cpuflags_cache32  (1<<16)
-%assign cpuflags_cache64  (1<<17)
-%assign cpuflags_slowctz  (1<<18)
-%assign cpuflags_lzcnt    (1<<19)
-%assign cpuflags_aligned  (1<<20) ; not a cpu feature, but a function variant
-%assign cpuflags_atom     (1<<21)
-%assign cpuflags_bmi1     (1<<22)|cpuflags_lzcnt
-%assign cpuflags_bmi2     (1<<23)|cpuflags_bmi1
-%assign cpuflags_aesni    (1<<24)|cpuflags_sse42
+%assign cpuflags_lzcnt    (1<<7) | cpuflags_sse2
+%assign cpuflags_sse3     (1<<8) | cpuflags_sse2
+%assign cpuflags_ssse3    (1<<9) | cpuflags_sse3
+%assign cpuflags_sse4     (1<<10)| cpuflags_ssse3
+%assign cpuflags_sse42    (1<<11)| cpuflags_sse4
+%assign cpuflags_aesni    (1<<12)| cpuflags_sse42
+%assign cpuflags_avx      (1<<13)| cpuflags_sse42
+%assign cpuflags_xop      (1<<14)| cpuflags_avx
+%assign cpuflags_fma4     (1<<15)| cpuflags_avx
+%assign cpuflags_fma3     (1<<16)| cpuflags_avx
+%assign cpuflags_bmi1     (1<<17)| cpuflags_avx|cpuflags_lzcnt
+%assign cpuflags_bmi2     (1<<18)| cpuflags_bmi1
+%assign cpuflags_avx2     (1<<19)| cpuflags_fma3|cpuflags_bmi2
+
+%assign cpuflags_cache32  (1<<20)
+%assign cpuflags_cache64  (1<<21)
+%assign cpuflags_slowctz  (1<<22)
+%assign cpuflags_aligned  (1<<23) ; not a cpu feature, but a function variant
+%assign cpuflags_atom     (1<<24)
 
 ; Returns a boolean value expressing whether or not the specified cpuflag is enabled.
 %define    cpuflag(x) (((((cpuflags & (cpuflags_ %+ x)) ^ (cpuflags_ %+ x)) - 1) >> 31) & 1)
@@ -1030,7 +1040,11 @@ INIT_XMM
 
 ; Append cpuflags to the callee's name iff the appended name is known and the plain name isn't
 %macro call 1
-    call_internal %1 %+ SUFFIX, %1
+    %ifid %1
+        call_internal %1 %+ SUFFIX, %1
+    %else
+        call %1
+    %endif
 %endmacro
 %macro call_internal 2
     %xdefine %%i %2
diff --git a/mythtv/external/FFmpeg/libavutil/x86/x86util.asm b/mythtv/external/FFmpeg/libavutil/x86/x86util.asm
index 44ed750ae50..e1220dfc1a4 100644
--- a/mythtv/external/FFmpeg/libavutil/x86/x86util.asm
+++ b/mythtv/external/FFmpeg/libavutil/x86/x86util.asm
@@ -29,6 +29,21 @@
 
 %include "libavutil/x86/x86inc.asm"
 
+; expands to [base],...,[base+7*stride]
+%define PASS8ROWS(base, base3, stride, stride3) \
+    [base],           [base  + stride],   [base  + 2*stride], [base3], \
+    [base3 + stride], [base3 + 2*stride], [base3 + stride3],  [base3 + stride*4]
+
+; Interleave low src0 with low src1 and store in src0,
+; interleave high src0 with high src1 and store in src1.
+; %1 - types
+; %2 - index of the register with src0
+; %3 - index of the register with src1
+; %4 - index of the register for intermediate results
+; example for %1 - wd: input: src0: x0 x1 x2 x3 z0 z1 z2 z3
+;                             src1: y0 y1 y2 y3 q0 q1 q2 q3
+;                     output: src0: x0 y0 x1 y1 x2 y2 x3 y3
+;                             src1: z0 q0 z1 q1 z2 q2 z3 q3
 %macro SBUTTERFLY 4
 %ifidn %1, dqqq
     vperm2i128  m%4, m%2, m%3, q0301
@@ -56,6 +71,12 @@
     SWAP %1, %3, %2
 %endmacro
 
+%macro SBUTTERFLYPD 3
+    movlhps m%3, m%1, m%2
+    movhlps m%2, m%2, m%1
+    SWAP %1, %3
+%endmacro
+
 %macro TRANSPOSE4x4B 5
     SBUTTERFLY bw, %1, %2, %5
     SBUTTERFLY bw, %3, %4, %5
@@ -102,12 +123,9 @@
 %macro TRANSPOSE4x4PS 5
     SBUTTERFLYPS %1, %2, %5
     SBUTTERFLYPS %3, %4, %5
-    movlhps m%5, m%1, m%3
-    movhlps m%3, m%1
-    SWAP %5, %1
-    movlhps m%5, m%2, m%4
-    movhlps m%4, m%2
-    SWAP %5, %2, %3
+    SBUTTERFLYPD %1, %3, %5
+    SBUTTERFLYPD %2, %4, %5
+    SWAP %2, %3
 %endmacro
 
 %macro TRANSPOSE8x4D 9-11
@@ -260,6 +278,21 @@
     SWAP       %12, %15
 %endmacro
 
+%macro TRANSPOSE_8X8B 8
+    %if mmsize == 8
+        %error "This macro does not support mmsize == 8"
+    %endif
+    punpcklbw m%1, m%2
+    punpcklbw m%3, m%4
+    punpcklbw m%5, m%6
+    punpcklbw m%7, m%8
+    TRANSPOSE4x4W %1, %3, %5, %7, %2
+    MOVHL m%2, m%1
+    MOVHL m%4, m%3
+    MOVHL m%6, m%5
+    MOVHL m%8, m%7
+%endmacro
+
 ; PABSW macro assumes %1 != %2, while ABS1/2 macros work in-place
 %macro PABSW 2
 %if cpuflag(ssse3)
@@ -799,12 +832,25 @@
     pmaxsd  %1, %2
 %endmacro
 
-%macro VBROADCASTSS 2 ; dst xmm/ymm, src m32
-%if cpuflag(avx)
-    vbroadcastss %1, %2
-%else ; sse
-    movss        %1, %2
-    shufps       %1, %1, 0
+%macro VBROADCASTSS 2 ; dst xmm/ymm, src m32/xmm
+%if cpuflag(avx2)
+    vbroadcastss  %1, %2
+%elif cpuflag(avx)
+    %ifnum sizeof%2         ; avx1 register
+        shufps  xmm%1, xmm%2, xmm%2, q0000
+        %if sizeof%1 >= 32  ; mmsize>=32
+            vinsertf128  %1, %1, xmm%1, 1
+        %endif
+    %else                   ; avx1 memory
+        vbroadcastss  %1, %2
+    %endif
+%else
+    %ifnum sizeof%2         ; sse register
+        shufps  %1, %2, %2, q0000
+    %else                   ; sse memory
+        movss   %1, %2
+        shufps  %1, %1, 0
+    %endif
 %endif
 %endmacro
 
@@ -819,6 +865,21 @@
 %endif
 %endmacro
 
+%macro VPBROADCASTD 2 ; dst xmm/ymm, src m32/xmm
+%if cpuflag(avx2)
+    vpbroadcastd  %1, %2
+%elif cpuflag(avx) && sizeof%1 >= 32
+    %error vpbroadcastd not possible with ymm on avx1. try vbroadcastss
+%else
+    %ifnum sizeof%2         ; sse2 register
+        pshufd  %1, %2, q0000
+    %else                   ; sse memory
+        movd    %1, %2
+        pshufd  %1, %1, 0
+    %endif
+%endif
+%endmacro
+
 %macro SHUFFLE_MASK_W 8
     %rep 8
         %if %1>=0x80
@@ -871,3 +932,79 @@
     psrlq   %1, 8*(%2)
 %endif
 %endmacro
+
+%macro MOVHL 2 ; dst, src
+%ifidn %1, %2
+    punpckhqdq %1, %2
+%elif cpuflag(avx)
+    punpckhqdq %1, %2, %2
+%elif cpuflag(sse4)
+    pshufd     %1, %2, q3232 ; pshufd is slow on some older CPUs, so only use it on more modern ones
+%else
+    movhlps    %1, %2        ; may cause an int/float domain transition and has a dependency on dst
+%endif
+%endmacro
+
+; Horizontal Sum of Packed Single precision floats
+; The resulting sum is in all elements.
+%macro HSUMPS 2 ; dst/src, tmp
+%if cpuflag(avx)
+    %if sizeof%1>=32  ; avx
+        vperm2f128  %2, %1, %1, (0)*16+(1)
+        addps       %1, %2
+    %endif
+    shufps      %2, %1, %1, q1032
+    addps       %1, %2
+    shufps      %2, %1, %1, q0321
+    addps       %1, %2
+%else  ; this form is a bit faster than the short avx-like emulation.
+    movaps      %2, %1
+    shufps      %1, %1, q1032
+    addps       %1, %2
+    movaps      %2, %1
+    shufps      %1, %1, q0321
+    addps       %1, %2
+    ; all %1 members should be equal for as long as float a+b==b+a
+%endif
+%endmacro
+
+; Emulate blendvps if not available
+;
+; src_b is destroyed when using emulation with logical operands
+; SSE41 blendv instruction is hard coded to use xmm0 as mask
+%macro BLENDVPS 3 ; dst/src_a, src_b, mask
+%if cpuflag(avx)
+    blendvps  %1, %1, %2, %3
+%elif cpuflag(sse4)
+    %ifnidn %3,xmm0
+        %error sse41 blendvps uses xmm0 as default 3d operand, you used %3
+    %endif
+    blendvps  %1, %2, %3
+%else
+    xorps  %2, %1
+    andps  %2, %3
+    xorps  %1, %2
+%endif
+%endmacro
+
+; Emulate pblendvb if not available
+;
+; src_b is destroyed when using emulation with logical operands
+; SSE41 blendv instruction is hard coded to use xmm0 as mask
+%macro PBLENDVB 3 ; dst/src_a, src_b, mask
+%if cpuflag(avx)
+    %if cpuflag(avx) && notcpuflag(avx2) && sizeof%1 >= 32
+        %error pblendb not possible with ymm on avx1, try blendvps.
+    %endif
+    pblendvb  %1, %1, %2, %3
+%elif cpuflag(sse4)
+    %ifnidn %3,xmm0
+        %error sse41 pblendvd uses xmm0 as default 3d operand, you used %3
+    %endif
+    pblendvb  %1, %2, %3
+%else
+    pxor  %2, %1
+    pand  %2, %3
+    pxor  %1, %2
+%endif
+%endmacro
diff --git a/mythtv/external/FFmpeg/libpostproc/Makefile b/mythtv/external/FFmpeg/libpostproc/Makefile
index 07d04d812cf..4aea9c03b02 100644
--- a/mythtv/external/FFmpeg/libpostproc/Makefile
+++ b/mythtv/external/FFmpeg/libpostproc/Makefile
@@ -1,6 +1,5 @@
-include $(SUBDIR)../config.mak
-
 NAME = postproc
+DESC = FFmpeg postprocessing library
 FFLIBS = avutil
 
 # x86_32 needs -O1 -fomit-frame-pointer to compile inline asm
diff --git a/mythtv/external/FFmpeg/libpostproc/postprocess.c b/mythtv/external/FFmpeg/libpostproc/postprocess.c
index 97158cc1dca..f5347852931 100644
--- a/mythtv/external/FFmpeg/libpostproc/postprocess.c
+++ b/mythtv/external/FFmpeg/libpostproc/postprocess.c
@@ -89,6 +89,7 @@ try to unroll inner for(x=0 ... loop to avoid these damn if(x ... checks
 #include "postprocess.h"
 #include "postprocess_internal.h"
 #include "libavutil/avstring.h"
+#include "libavutil/ppc/util_altivec.h"
 
 #include "libavutil/cpu.h"
 
@@ -112,10 +113,6 @@ const char *postproc_license(void)
     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 }
 
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
-
 #define GET_MODE_BUFFER_SIZE 500
 #define OPTIONS_ARRAY_SIZE 10
 #define BLOCK_SIZE 8
@@ -563,10 +560,10 @@ static av_always_inline void do_a_deblock_C(uint8_t *src, int step,
 #endif
 
 typedef void (*pp_fn)(const uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
-                      const QP_STORE_T QPs[], int QPStride, int isColor, PPContext *c2);
+                      const int8_t QPs[], int QPStride, int isColor, PPContext *c2);
 
 static inline void postProcess(const uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
-        const QP_STORE_T QPs[], int QPStride, int isColor, pp_mode *vm, pp_context *vc)
+        const int8_t QPs[], int QPStride, int isColor, pp_mode *vm, pp_context *vc)
 {
     pp_fn pp = postProcess_C;
     PPContext *c= (PPContext *)vc;
@@ -875,9 +872,9 @@ static void reallocBuffers(PPContext *c, int width, int height, int stride, int
     }
 
     reallocAlign((void **)&c->deintTemp, 2*width+32);
-    reallocAlign((void **)&c->nonBQPTable, qpStride*mbHeight*sizeof(QP_STORE_T));
-    reallocAlign((void **)&c->stdQPTable, qpStride*mbHeight*sizeof(QP_STORE_T));
-    reallocAlign((void **)&c->forcedQPTable, mbWidth*sizeof(QP_STORE_T));
+    reallocAlign((void **)&c->nonBQPTable, qpStride*mbHeight*sizeof(int8_t));
+    reallocAlign((void **)&c->stdQPTable, qpStride*mbHeight*sizeof(int8_t));
+    reallocAlign((void **)&c->forcedQPTable, mbWidth*sizeof(int8_t));
 }
 
 static const char * context_to_name(void * ptr) {
@@ -961,7 +958,7 @@ av_cold void pp_free_context(void *vc){
 void  pp_postprocess(const uint8_t * src[3], const int srcStride[3],
                      uint8_t * dst[3], const int dstStride[3],
                      int width, int height,
-                     const QP_STORE_T *QP_store,  int QPStride,
+                     const int8_t *QP_store,  int QPStride,
                      pp_mode *vm,  void *vc, int pict_type)
 {
     int mbWidth = (width+15)>>4;
diff --git a/mythtv/external/FFmpeg/libpostproc/postprocess_internal.h b/mythtv/external/FFmpeg/libpostproc/postprocess_internal.h
index d128dfbe2f6..765fdeb14ac 100644
--- a/mythtv/external/FFmpeg/libpostproc/postprocess_internal.h
+++ b/mythtv/external/FFmpeg/libpostproc/postprocess_internal.h
@@ -149,9 +149,9 @@ typedef struct PPContext{
     DECLARE_ALIGNED(32, uint64_t, mmxDcOffset)[64];
     DECLARE_ALIGNED(32, uint64_t, mmxDcThreshold)[64];
 
-    QP_STORE_T *stdQPTable;       ///< used to fix MPEG2 style qscale
-    QP_STORE_T *nonBQPTable;
-    QP_STORE_T *forcedQPTable;
+    int8_t *stdQPTable;       ///< used to fix MPEG2 style qscale
+    int8_t *nonBQPTable;
+    int8_t *forcedQPTable;
 
     int QP;
     int nonBQP;
diff --git a/mythtv/external/FFmpeg/libpostproc/postprocess_template.c b/mythtv/external/FFmpeg/libpostproc/postprocess_template.c
index 2a25ce44e33..0a439892668 100644
--- a/mythtv/external/FFmpeg/libpostproc/postprocess_template.c
+++ b/mythtv/external/FFmpeg/libpostproc/postprocess_template.c
@@ -3081,7 +3081,7 @@ static av_always_inline void RENAME(do_a_deblock)(uint8_t *src, int step, int st
 #endif //TEMPLATE_PP_MMX
 
 static void RENAME(postProcess)(const uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
-                                const QP_STORE_T QPs[], int QPStride, int isColor, PPContext *c);
+                                const int8_t QPs[], int QPStride, int isColor, PPContext *c);
 
 /**
  * Copy a block from src to dst and fixes the blacklevel.
@@ -3309,7 +3309,7 @@ static inline void RENAME(prefetcht2)(const void *p)
  * Filter array of bytes (Y or U or V values)
  */
 static void RENAME(postProcess)(const uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
-                                const QP_STORE_T QPs[], int QPStride, int isColor, PPContext *c2)
+                                const int8_t QPs[], int QPStride, int isColor, PPContext *c2)
 {
     DECLARE_ALIGNED(8, PPContext, c)= *c2; //copy to stack for faster access
     int x,y;
diff --git a/mythtv/external/FFmpeg/libpostproc/version.h b/mythtv/external/FFmpeg/libpostproc/version.h
index f387b4bf167..e8f0abe8137 100644
--- a/mythtv/external/FFmpeg/libpostproc/version.h
+++ b/mythtv/external/FFmpeg/libpostproc/version.h
@@ -29,7 +29,7 @@
 #include "libavutil/avutil.h"
 
 #define LIBPOSTPROC_VERSION_MAJOR  54
-#define LIBPOSTPROC_VERSION_MINOR   1
+#define LIBPOSTPROC_VERSION_MINOR   7
 #define LIBPOSTPROC_VERSION_MICRO 100
 
 #define LIBPOSTPROC_VERSION_INT AV_VERSION_INT(LIBPOSTPROC_VERSION_MAJOR, \
diff --git a/mythtv/external/FFmpeg/libswresample/Makefile b/mythtv/external/FFmpeg/libswresample/Makefile
index 120ee3385d8..42666e4dd23 100644
--- a/mythtv/external/FFmpeg/libswresample/Makefile
+++ b/mythtv/external/FFmpeg/libswresample/Makefile
@@ -1,6 +1,5 @@
-include $(SUBDIR)../config.mak
-
 NAME = swresample
+DESC = FFmpeg audio resampling library
 FFLIBS = avutil
 
 HEADERS = swresample.h                       \
diff --git a/mythtv/external/FFmpeg/libswresample/aarch64/Makefile b/mythtv/external/FFmpeg/libswresample/aarch64/Makefile
index 320ed67e82f..5c34f8d9491 100644
--- a/mythtv/external/FFmpeg/libswresample/aarch64/Makefile
+++ b/mythtv/external/FFmpeg/libswresample/aarch64/Makefile
@@ -1,5 +1,7 @@
-OBJS                             += aarch64/audio_convert_init.o
+OBJS                             += aarch64/audio_convert_init.o \
+                                    aarch64/resample_init.o
 
 OBJS-$(CONFIG_NEON_CLOBBER_TEST) += aarch64/neontest.o
 
-NEON-OBJS                        += aarch64/audio_convert_neon.o
+NEON-OBJS                        += aarch64/audio_convert_neon.o \
+                                    aarch64/resample.o
diff --git a/mythtv/external/FFmpeg/libswresample/aarch64/resample.S b/mythtv/external/FFmpeg/libswresample/aarch64/resample.S
new file mode 100644
index 00000000000..bbad619a817
--- /dev/null
+++ b/mythtv/external/FFmpeg/libswresample/aarch64/resample.S
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2017 Matthieu Bouron <matthieu.bouron gmail.com>
+ *
+ * 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/aarch64/asm.S"
+
+function ff_resample_common_apply_filter_x4_float_neon, export=1
+    movi                v0.4S, #0                                      // accumulator
+1:  ld1                 {v1.4S}, [x1], #16                             // src[0..3]
+    ld1                 {v2.4S}, [x2], #16                             // filter[0..3]
+    fmla                v0.4S, v1.4S, v2.4S                            // accumulator += src[0..3] * filter[0..3]
+    subs                w3, w3, #4                                     // filter_length -= 4
+    b.gt                1b                                             // loop until filter_length
+    faddp               v0.4S, v0.4S, v0.4S                            // pair adding of the 4x32-bit accumulated values
+    faddp               v0.4S, v0.4S, v0.4S                            // pair adding of the 4x32-bit accumulated values
+    st1                 {v0.S}[0], [x0], #4                            // write accumulator
+    ret
+endfunc
+
+function ff_resample_common_apply_filter_x8_float_neon, export=1
+    movi                v0.4S, #0                                      // accumulator
+1:  ld1                 {v1.4S}, [x1], #16                             // src[0..3]
+    ld1                 {v2.4S}, [x2], #16                             // filter[0..3]
+    ld1                 {v3.4S}, [x1], #16                             // src[4..7]
+    ld1                 {v4.4S}, [x2], #16                             // filter[4..7]
+    fmla                v0.4S, v1.4S, v2.4S                            // accumulator += src[0..3] * filter[0..3]
+    fmla                v0.4S, v3.4S, v4.4S                            // accumulator += src[4..7] * filter[4..7]
+    subs                w3, w3, #8                                     // filter_length -= 8
+    b.gt                1b                                             // loop until filter_length
+    faddp               v0.4S, v0.4S, v0.4S                            // pair adding of the 4x32-bit accumulated values
+    faddp               v0.4S, v0.4S, v0.4S                            // pair adding of the 4x32-bit accumulated values
+    st1                 {v0.S}[0], [x0], #4                            // write accumulator
+    ret
+endfunc
+
+function ff_resample_common_apply_filter_x4_s16_neon, export=1
+    movi                v0.4S, #0                                      // accumulator
+1:  ld1                 {v1.4H}, [x1], #8                              // src[0..3]
+    ld1                 {v2.4H}, [x2], #8                              // filter[0..3]
+    smlal               v0.4S, v1.4H, v2.4H                            // accumulator += src[0..3] * filter[0..3]
+    subs                w3, w3, #4                                     // filter_length -= 4
+    b.gt                1b                                             // loop until filter_length
+    addp                v0.4S, v0.4S, v0.4S                            // pair adding of the 4x32-bit accumulated values
+    addp                v0.4S, v0.4S, v0.4S                            // pair adding of the 4x32-bit accumulated values
+    st1                 {v0.S}[0], [x0], #4                            // write accumulator
+    ret
+endfunc
+
+function ff_resample_common_apply_filter_x8_s16_neon, export=1
+    movi                v0.4S, #0                                      // accumulator
+1:  ld1                 {v1.8H}, [x1], #16                             // src[0..7]
+    ld1                 {v2.8H}, [x2], #16                             // filter[0..7]
+    smlal               v0.4S, v1.4H, v2.4H                            // accumulator += src[0..3] * filter[0..3]
+    smlal2              v0.4S, v1.8H, v2.8H                            // accumulator += src[4..7] * filter[4..7]
+    subs                w3, w3, #8                                     // filter_length -= 8
+    b.gt                1b                                             // loop until filter_length
+    addp                v0.4S, v0.4S, v0.4S                            // pair adding of the 4x32-bit accumulated values
+    addp                v0.4S, v0.4S, v0.4S                            // pair adding of the 4x32-bit accumulated values
+    st1                 {v0.S}[0], [x0], #4                            // write accumulator
+    ret
+endfunc
diff --git a/mythtv/external/FFmpeg/libswresample/aarch64/resample_init.c b/mythtv/external/FFmpeg/libswresample/aarch64/resample_init.c
new file mode 100644
index 00000000000..d01ec18756b
--- /dev/null
+++ b/mythtv/external/FFmpeg/libswresample/aarch64/resample_init.c
@@ -0,0 +1,120 @@
+/*
+ * Audio resampling
+ *
+ * Copyright (c) 2004-2012 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * 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/avassert.h"
+
+#include "libavutil/aarch64/cpu.h"
+#include "libswresample/resample.h"
+
+#define DECLARE_RESAMPLE_COMMON_TEMPLATE(TYPE, DELEM, FELEM, FELEM2, OUT)                         \
+                                                                                                  \
+void ff_resample_common_apply_filter_x4_##TYPE##_neon(FELEM2 *acc, const DELEM *src,              \
+                                                      const FELEM *filter, int length);           \
+                                                                                                  \
+void ff_resample_common_apply_filter_x8_##TYPE##_neon(FELEM2 *acc, const DELEM *src,              \
+                                                      const FELEM *filter, int length);           \
+                                                                                                  \
+static int ff_resample_common_##TYPE##_neon(ResampleContext *c, void *dest, const void *source,   \
+                                            int n, int update_ctx)                                \
+{                                                                                                 \
+    DELEM *dst = dest;                                                                            \
+    const DELEM *src = source;                                                                    \
+    int dst_index;                                                                                \
+    int index = c->index;                                                                         \
+    int frac = c->frac;                                                                           \
+    int sample_index = 0;                                                                         \
+    int x4_aligned_filter_length = c->filter_length & ~3;                                         \
+    int x8_aligned_filter_length = c->filter_length & ~7;                                         \
+                                                                                                  \
+    while (index >= c->phase_count) {                                                             \
+        sample_index++;                                                                           \
+        index -= c->phase_count;                                                                  \
+    }                                                                                             \
+                                                                                                  \
+    for (dst_index = 0; dst_index < n; dst_index++) {                                             \
+        FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * index;                     \
+                                                                                                  \
+        FELEM2 val = 0;                                                                             \
+        int i = 0;                                                                                \
+        if (x8_aligned_filter_length >= 8) {                                                      \
+            ff_resample_common_apply_filter_x8_##TYPE##_neon(&val, &src[sample_index],            \
+                                                             filter, x8_aligned_filter_length);   \
+            i += x8_aligned_filter_length;                                                        \
+                                                                                                  \
+        } else if (x4_aligned_filter_length >= 4) {                                               \
+            ff_resample_common_apply_filter_x4_##TYPE##_neon(&val, &src[sample_index],            \
+                                                             filter, x4_aligned_filter_length);   \
+            i += x4_aligned_filter_length;                                                        \
+        }                                                                                         \
+        for (; i < c->filter_length; i++) {                                                       \
+            val += src[sample_index + i] * (FELEM2)filter[i];                                     \
+        }                                                                                         \
+        OUT(dst[dst_index], val);                                                                 \
+                                                                                                  \
+        frac  += c->dst_incr_mod;                                                                 \
+        index += c->dst_incr_div;                                                                 \
+        if (frac >= c->src_incr) {                                                                \
+            frac -= c->src_incr;                                                                  \
+            index++;                                                                              \
+        }                                                                                         \
+                                                                                                  \
+        while (index >= c->phase_count) {                                                         \
+            sample_index++;                                                                       \
+            index -= c->phase_count;                                                              \
+        }                                                                                         \
+    }                                                                                             \
+                                                                                                  \
+    if (update_ctx) {                                                                             \
+        c->frac = frac;                                                                           \
+        c->index = index;                                                                         \
+    }                                                                                             \
+                                                                                                  \
+    return sample_index;                                                                          \
+}                                                                                                 \
+
+#define OUT(d, v) d = v
+DECLARE_RESAMPLE_COMMON_TEMPLATE(float, float, float, float, OUT)
+#undef OUT
+
+#define OUT(d, v) (v) = ((v) + (1<<(14)))>>15; (d) = av_clip_int16(v)
+DECLARE_RESAMPLE_COMMON_TEMPLATE(s16, int16_t, int16_t, int32_t, OUT)
+#undef OUT
+
+av_cold void swri_resample_dsp_aarch64_init(ResampleContext *c)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (!have_neon(cpu_flags))
+        return;
+
+    switch(c->format) {
+    case AV_SAMPLE_FMT_FLTP:
+        c->dsp.resample_common = ff_resample_common_float_neon;
+        break;
+    case AV_SAMPLE_FMT_S16P:
+        c->dsp.resample_common = ff_resample_common_s16_neon;
+        break;
+    }
+}
diff --git a/mythtv/external/FFmpeg/libswresample/arm/resample.S b/mythtv/external/FFmpeg/libswresample/arm/resample.S
index c231301b2b6..3ce7623246a 100644
--- a/mythtv/external/FFmpeg/libswresample/arm/resample.S
+++ b/mythtv/external/FFmpeg/libswresample/arm/resample.S
@@ -22,9 +22,9 @@
 
 function ff_resample_common_apply_filter_x4_float_neon, export=1
     vmov.f32            q0, #0.0                                       @ accumulator
-1:  vld1.32             {q1}, [r1]!                                    @ src
-    vld1.32             {q2}, [r2]!                                    @ filter
-    vmla.f32            q0, q1, q2                                     @ accumulator += src + {0..3} * filter + {0..3}
+1:  vld1.32             {q1}, [r1]!                                    @ src[0..3]
+    vld1.32             {q2}, [r2]!                                    @ filter[0..3]
+    vmla.f32            q0, q1, q2                                     @ accumulator += src[0..3] * filter[0..3]
     subs                r3, #4                                         @ filter_length -= 4
     bgt                 1b                                             @ loop until filter_length
     vpadd.f32           d0, d0, d1                                     @ pair adding of the 4x32-bit accumulated values
@@ -35,12 +35,12 @@ endfunc
 
 function ff_resample_common_apply_filter_x8_float_neon, export=1
     vmov.f32            q0, #0.0                                       @ accumulator
-1:  vld1.32             {q1}, [r1]!                                    @ src
-    vld1.32             {q2}, [r2]!                                    @ filter
-    vld1.32             {q8}, [r1]!                                    @ src
-    vld1.32             {q9}, [r2]!                                    @ filter
-    vmla.f32            q0, q1, q2                                     @ accumulator += src + {0..3} * filter + {0..3}
-    vmla.f32            q0, q8, q9                                     @ accumulator += src + {4..7} * filter + {4..7}
+1:  vld1.32             {q1}, [r1]!                                    @ src[0..3]
+    vld1.32             {q2}, [r2]!                                    @ filter[0..3]
+    vld1.32             {q8}, [r1]!                                    @ src[4..7]
+    vld1.32             {q9}, [r2]!                                    @ filter[4..7]
+    vmla.f32            q0, q1, q2                                     @ accumulator += src[0..3] * filter[0..3]
+    vmla.f32            q0, q8, q9                                     @ accumulator += src[4..7] * filter[4..7]
     subs                r3, #8                                         @ filter_length -= 8
     bgt                 1b                                             @ loop until filter_length
     vpadd.f32           d0, d0, d1                                     @ pair adding of the 4x32-bit accumulated values
@@ -51,9 +51,9 @@ endfunc
 
 function ff_resample_common_apply_filter_x4_s16_neon, export=1
     vmov.s32            q0, #0                                         @ accumulator
-1:  vld1.16             {d2}, [r1]!                                    @ src
-    vld1.16             {d4}, [r2]!                                    @ filter
-    vmlal.s16           q0, d2, d4                                     @ accumulator += src + {0..3} * filter + {0..3}
+1:  vld1.16             {d2}, [r1]!                                    @ src[0..3]
+    vld1.16             {d4}, [r2]!                                    @ filter[0..3]
+    vmlal.s16           q0, d2, d4                                     @ accumulator += src[0..3] * filter[0..3]
     subs                r3, #4                                         @ filter_length -= 4
     bgt                 1b                                             @ loop until filter_length
     vpadd.s32           d0, d0, d1                                     @ pair adding of the 4x32-bit accumulated values
@@ -64,10 +64,10 @@ endfunc
 
 function ff_resample_common_apply_filter_x8_s16_neon, export=1
     vmov.s32            q0, #0                                         @ accumulator
-1:  vld1.16             {q1}, [r1]!                                    @ src
-    vld1.16             {q2}, [r2]!                                    @ filter
-    vmlal.s16           q0, d2, d4                                     @ accumulator += src + {0..3} * filter + {0..3}
-    vmlal.s16           q0, d3, d5                                     @ accumulator += src + {4..7} * filter + {4..7}
+1:  vld1.16             {q1}, [r1]!                                    @ src[0..7]
+    vld1.16             {q2}, [r2]!                                    @ filter[0..7]
+    vmlal.s16           q0, d2, d4                                     @ accumulator += src[0..3] * filter[0..3]
+    vmlal.s16           q0, d3, d5                                     @ accumulator += src[4..7] * filter[4..7]
     subs                r3, #8                                         @ filter_length -= 8
     bgt                 1b                                             @ loop until filter_length
     vpadd.s32           d0, d0, d1                                     @ pair adding of the 4x32-bit accumulated values
diff --git a/mythtv/external/FFmpeg/libswresample/arm/resample_init.c b/mythtv/external/FFmpeg/libswresample/arm/resample_init.c
index 003fafd29bb..09b9766ff3e 100644
--- a/mythtv/external/FFmpeg/libswresample/arm/resample_init.c
+++ b/mythtv/external/FFmpeg/libswresample/arm/resample_init.c
@@ -42,8 +42,8 @@ static int ff_resample_common_##TYPE##_neon(ResampleContext *c, void *dest, cons
     DELEM *dst = dest;                                                                            \
     const DELEM *src = source;                                                                    \
     int dst_index;                                                                                \
-    int index= c->index;                                                                          \
-    int frac= c->frac;                                                                            \
+    int index = c->index;                                                                         \
+    int frac = c->frac;                                                                           \
     int sample_index = 0;                                                                         \
     int x4_aligned_filter_length = c->filter_length & ~3;                                         \
     int x8_aligned_filter_length = c->filter_length & ~7;                                         \
@@ -56,7 +56,7 @@ static int ff_resample_common_##TYPE##_neon(ResampleContext *c, void *dest, cons
     for (dst_index = 0; dst_index < n; dst_index++) {                                             \
         FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * index;                     \
                                                                                                   \
-        FELEM2 val=0;                                                                             \
+        FELEM2 val = 0;                                                                             \
         int i = 0;                                                                                \
         if (x8_aligned_filter_length >= 8) {                                                      \
             ff_resample_common_apply_filter_x8_##TYPE##_neon(&val, &src[sample_index],            \
@@ -86,9 +86,9 @@ static int ff_resample_common_##TYPE##_neon(ResampleContext *c, void *dest, cons
         }                                                                                         \
     }                                                                                             \
                                                                                                   \
-    if(update_ctx){                                                                               \
-        c->frac= frac;                                                                            \
-        c->index= index;                                                                          \
+    if (update_ctx) {                                                                             \
+        c->frac = frac;                                                                           \
+        c->index = index;                                                                         \
     }                                                                                             \
                                                                                                   \
     return sample_index;                                                                          \
@@ -111,12 +111,10 @@ av_cold void swri_resample_dsp_arm_init(ResampleContext *c)
 
     switch(c->format) {
     case AV_SAMPLE_FMT_FLTP:
-        if (!c->linear)
-            c->dsp.resample = ff_resample_common_float_neon;
+        c->dsp.resample_common = ff_resample_common_float_neon;
         break;
     case AV_SAMPLE_FMT_S16P:
-        if (!c->linear)
-            c->dsp.resample = ff_resample_common_s16_neon;
+        c->dsp.resample_common = ff_resample_common_s16_neon;
         break;
     }
 }
diff --git a/mythtv/external/FFmpeg/libswresample/audioconvert.c b/mythtv/external/FFmpeg/libswresample/audioconvert.c
index 542bd01242a..96ce84ac44a 100644
--- a/mythtv/external/FFmpeg/libswresample/audioconvert.c
+++ b/mythtv/external/FFmpeg/libswresample/audioconvert.c
@@ -176,7 +176,7 @@ AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt,
         }
     }
 
-    if(HAVE_YASM && HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);
+    if(HAVE_X86ASM && HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);
     if(ARCH_ARM)              swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);
     if(ARCH_AARCH64)          swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);
 
diff --git a/mythtv/external/FFmpeg/libswresample/options.c b/mythtv/external/FFmpeg/libswresample/options.c
index 4abf5e05189..00d4f7c1c90 100644
--- a/mythtv/external/FFmpeg/libswresample/options.c
+++ b/mythtv/external/FFmpeg/libswresample/options.c
@@ -84,8 +84,8 @@ static const AVOption options[]={
 
 {"filter_size"          , "set swr resampling filter size", OFFSET(filter_size)  , AV_OPT_TYPE_INT  , {.i64=32                    }, 0      , INT_MAX   , PARAM },
 {"phase_shift"          , "set swr resampling phase shift", OFFSET(phase_shift)  , AV_OPT_TYPE_INT  , {.i64=10                    }, 0      , 24        , PARAM },
-{"linear_interp"        , "enable linear interpolation" , OFFSET(linear_interp)  , AV_OPT_TYPE_BOOL , {.i64=0                     }, 0      , 1         , PARAM },
-{"exact_rational"       , "enable exact rational"       , OFFSET(exact_rational) , AV_OPT_TYPE_BOOL , {.i64=0                     }, 0      , 1         , PARAM },
+{"linear_interp"        , "enable linear interpolation" , OFFSET(linear_interp)  , AV_OPT_TYPE_BOOL , {.i64=1                     }, 0      , 1         , PARAM },
+{"exact_rational"       , "enable exact rational"       , OFFSET(exact_rational) , AV_OPT_TYPE_BOOL , {.i64=1                     }, 0      , 1         , PARAM },
 {"cutoff"               , "set cutoff frequency ratio"  , OFFSET(cutoff)         , AV_OPT_TYPE_DOUBLE,{.dbl=0.                    }, 0      , 1         , PARAM },
 
 /* duplicate option in order to work with avconv */
diff --git a/mythtv/external/FFmpeg/libswresample/rematrix.c b/mythtv/external/FFmpeg/libswresample/rematrix.c
index 4721063a134..66a43c16c16 100644
--- a/mythtv/external/FFmpeg/libswresample/rematrix.c
+++ b/mythtv/external/FFmpeg/libswresample/rematrix.c
@@ -371,9 +371,10 @@ av_cold static int auto_matrix(SwrContext *s)
                            s->matrix[1] - s->matrix[0], s->matrix_encoding, s);
 
     if (ret >= 0 && s->int_sample_fmt == AV_SAMPLE_FMT_FLTP) {
-        int i;
-        for (i = 0; i < FF_ARRAY_ELEMS(s->matrix[0])*FF_ARRAY_ELEMS(s->matrix[0]); i++)
-            s->matrix_flt[0][i] = s->matrix[0][i];
+        int i, j;
+        for (i = 0; i < FF_ARRAY_ELEMS(s->matrix[0]); i++)
+            for (j = 0; j < FF_ARRAY_ELEMS(s->matrix[0]); j++)
+                s->matrix_flt[i][j] = s->matrix[i][j];
     }
 
     return ret;
@@ -469,7 +470,7 @@ av_cold int swri_rematrix_init(SwrContext *s){
         s->matrix_ch[i][0]= ch_in;
     }
 
-    if(HAVE_YASM && HAVE_MMX)
+    if(HAVE_X86ASM && HAVE_MMX)
         return swri_rematrix_init_x86(s);
 
     return 0;
diff --git a/mythtv/external/FFmpeg/libswresample/resample.c b/mythtv/external/FFmpeg/libswresample/resample.c
index 8635bf1bed4..df49505bf95 100644
--- a/mythtv/external/FFmpeg/libswresample/resample.c
+++ b/mythtv/external/FFmpeg/libswresample/resample.c
@@ -149,23 +149,25 @@ static int build_filter(ResampleContext *c, void *filter, double factor, int tap
     double *tab = av_malloc_array(tap_count+1,  sizeof(*tab));
     double *sin_lut = av_malloc_array(ph_nb, sizeof(*sin_lut));
     const int center= (tap_count-1)/2;
+    double norm = 0;
     int ret = AVERROR(ENOMEM);
 
     if (!tab || !sin_lut)
         goto fail;
 
+    av_assert0(tap_count == 1 || tap_count % 2 == 0);
+
     /* if upsampling, only need to interpolate, no filter */
     if (factor > 1.0)
         factor = 1.0;
 
     if (factor == 1.0) {
         for (ph = 0; ph < ph_nb; ph++)
-            sin_lut[ph] = sin(M_PI * ph / phase_count);
+            sin_lut[ph] = sin(M_PI * ph / phase_count) * (center & 1 ? 1 : -1);
     }
     for(ph = 0; ph < ph_nb; ph++) {
-        double norm = 0;
         s = sin_lut[ph];
-        for(i=0;i<=tap_count;i++) {
+        for(i=0;i<tap_count;i++) {
             x = M_PI * ((double)(i - center) - (double)ph / phase_count) * factor;
             if (x == 0) y = 1.0;
             else if (factor == 1.0)
@@ -194,7 +196,7 @@ static int build_filter(ResampleContext *c, void *filter, double factor, int tap
 
             tab[i] = y;
             s = -s;
-            if (i < tap_count)
+            if (!ph)
                 norm += y;
         }
 
@@ -204,55 +206,29 @@ static int build_filter(ResampleContext *c, void *filter, double factor, int tap
             for(i=0;i<tap_count;i++)
                 ((int16_t*)filter)[ph * alloc + i] = av_clip_int16(lrintf(tab[i] * scale / norm));
             if (phase_count % 2) break;
-            if (tap_count % 2 == 0 || tap_count == 1) {
-                for (i = 0; i < tap_count; i++)
-                    ((int16_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int16_t*)filter)[ph * alloc + i];
-            }
-            else {
-                for (i = 1; i <= tap_count; i++)
-                    ((int16_t*)filter)[(phase_count-ph) * alloc + tap_count-i] =
-                        av_clip_int16(lrintf(tab[i] * scale / (norm - tab[0] + tab[tap_count])));
-            }
+            for (i = 0; i < tap_count; i++)
+                ((int16_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int16_t*)filter)[ph * alloc + i];
             break;
         case AV_SAMPLE_FMT_S32P:
             for(i=0;i<tap_count;i++)
                 ((int32_t*)filter)[ph * alloc + i] = av_clipl_int32(llrint(tab[i] * scale / norm));
             if (phase_count % 2) break;
-            if (tap_count % 2 == 0 || tap_count == 1) {
-                for (i = 0; i < tap_count; i++)
-                    ((int32_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int32_t*)filter)[ph * alloc + i];
-            }
-            else {
-                for (i = 1; i <= tap_count; i++)
-                    ((int32_t*)filter)[(phase_count-ph) * alloc + tap_count-i] =
-                        av_clipl_int32(llrint(tab[i] * scale / (norm - tab[0] + tab[tap_count])));
-            }
+            for (i = 0; i < tap_count; i++)
+                ((int32_t*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((int32_t*)filter)[ph * alloc + i];
             break;
         case AV_SAMPLE_FMT_FLTP:
             for(i=0;i<tap_count;i++)
                 ((float*)filter)[ph * alloc + i] = tab[i] * scale / norm;
             if (phase_count % 2) break;
-            if (tap_count % 2 == 0 || tap_count == 1) {
-                for (i = 0; i < tap_count; i++)
-                    ((float*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((float*)filter)[ph * alloc + i];
-            }
-            else {
-                for (i = 1; i <= tap_count; i++)
-                    ((float*)filter)[(phase_count-ph) * alloc + tap_count-i] = tab[i] * scale / (norm - tab[0] + tab[tap_count]);
-            }
+            for (i = 0; i < tap_count; i++)
+                ((float*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((float*)filter)[ph * alloc + i];
             break;
         case AV_SAMPLE_FMT_DBLP:
             for(i=0;i<tap_count;i++)
                 ((double*)filter)[ph * alloc + i] = tab[i] * scale / norm;
             if (phase_count % 2) break;
-            if (tap_count % 2 == 0 || tap_count == 1) {
-                for (i = 0; i < tap_count; i++)
-                    ((double*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((double*)filter)[ph * alloc + i];
-            }
-            else {
-                for (i = 1; i <= tap_count; i++)
-                    ((double*)filter)[(phase_count-ph) * alloc + tap_count-i] = tab[i] * scale / (norm - tab[0] + tab[tap_count]);
-            }
+            for (i = 0; i < tap_count; i++)
+                ((double*)filter)[(phase_count-ph) * alloc + tap_count-1-i] = ((double*)filter)[ph * alloc + i];
             break;
         }
     }
@@ -300,6 +276,14 @@ static int build_filter(ResampleContext *c, void *filter, double factor, int tap
     return ret;
 }
 
+static void resample_free(ResampleContext **cc){
+    ResampleContext *c = *cc;
+    if(!c)
+        return;
+    av_freep(&c->filter_bank);
+    av_freep(cc);
+}
+
 static ResampleContext *resample_init(ResampleContext *c, int out_rate, int in_rate, int filter_size, int phase_shift, int linear,
                                     double cutoff0, enum AVSampleFormat format, enum SwrFilterType filter_type, double kaiser_beta,
                                     double precision, int cheby, int exact_rational)
@@ -308,6 +292,10 @@ static ResampleContext *resample_init(ResampleContext *c, int out_rate, int in_r
     double factor= FFMIN(out_rate * cutoff / in_rate, 1.0);
     int phase_count= 1<<phase_shift;
     int phase_count_compensation = phase_count;
+    int filter_length = FFMAX((int)ceil(filter_size/factor), 1);
+
+    if (filter_length > 1)
+        filter_length = FFALIGN(filter_length, 2);
 
     if (exact_rational) {
         int phase_count_exact, phase_count_exact_den;
@@ -320,8 +308,9 @@ static ResampleContext *resample_init(ResampleContext *c, int out_rate, int in_r
     }
 
     if (!c || c->phase_count != phase_count || c->linear!=linear || c->factor != factor
-           || c->filter_length != FFMAX((int)ceil(filter_size/factor), 1) || c->format != format
+           || c->filter_length != filter_length || c->format != format
            || c->filter_type != filter_type || c->kaiser_beta != kaiser_beta) {
+        resample_free(&c);
         c = av_mallocz(sizeof(*c));
         if (!c)
             return NULL;
@@ -354,7 +343,7 @@ static ResampleContext *resample_init(ResampleContext *c, int out_rate, int in_r
         c->phase_count   = phase_count;
         c->linear        = linear;
         c->factor        = factor;
-        c->filter_length = FFMAX((int)ceil(filter_size/factor), 1);
+        c->filter_length = filter_length;
         c->filter_alloc  = FFALIGN(c->filter_length, 8);
         c->filter_bank   = av_calloc(c->filter_alloc, (phase_count+1)*c->felem_size);
         c->filter_type   = filter_type;
@@ -391,13 +380,6 @@ static ResampleContext *resample_init(ResampleContext *c, int out_rate, int in_r
     return NULL;
 }
 
-static void resample_free(ResampleContext **c){
-    if(!*c)
-        return;
-    av_freep(&(*c)->filter_bank);
-    av_freep(c);
-}
-
 static int rebuild_filter_bank_with_compensation(ResampleContext *c)
 {
     uint8_t *new_filter_bank;
@@ -408,7 +390,7 @@ static int rebuild_filter_bank_with_compensation(ResampleContext *c)
     if (phase_count == c->phase_count)
         return 0;
 
-    av_assert0(!c->frac && !c->dst_incr_mod && !c->compensation_distance);
+    av_assert0(!c->frac && !c->dst_incr_mod);
 
     new_filter_bank = av_calloc(c->filter_alloc, (phase_count + 1) * c->felem_size);
     if (!new_filter_bank)
@@ -449,7 +431,7 @@ static int rebuild_filter_bank_with_compensation(ResampleContext *c)
 static int set_compensation(ResampleContext *c, int sample_delta, int compensation_distance){
     int ret;
 
-    if (compensation_distance) {
+    if (compensation_distance && sample_delta) {
         ret = rebuild_filter_bank_with_compensation(c);
         if (ret < 0)
             return ret;
@@ -467,64 +449,61 @@ static int set_compensation(ResampleContext *c, int sample_delta, int compensati
     return 0;
 }
 
-static int swri_resample(ResampleContext *c,
-                         uint8_t *dst, const uint8_t *src, int *consumed,
-                         int src_size, int dst_size, int update_ctx)
-{
+static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed){
+    int i;
+    int av_unused mm_flags = av_get_cpu_flags();
+    int need_emms = c->format == AV_SAMPLE_FMT_S16P && ARCH_X86_32 &&
+                    (mm_flags & (AV_CPU_FLAG_MMX2 | AV_CPU_FLAG_SSE2)) == AV_CPU_FLAG_MMX2;
+    int64_t max_src_size = (INT64_MAX/2 / c->phase_count) / c->src_incr;
+
+    if (c->compensation_distance)
+        dst_size = FFMIN(dst_size, c->compensation_distance);
+    src_size = FFMIN(src_size, max_src_size);
+
+    *consumed = 0;
+
     if (c->filter_length == 1 && c->phase_count == 1) {
-        int index= c->index;
-        int frac= c->frac;
-        int64_t index2= (1LL<<32)*c->frac/c->src_incr + (1LL<<32)*index;
+        int64_t index2= (1LL<<32)*c->frac/c->src_incr + (1LL<<32)*c->index;
         int64_t incr= (1LL<<32) * c->dst_incr / c->src_incr;
-        int new_size = (src_size * (int64_t)c->src_incr - frac + c->dst_incr - 1) / c->dst_incr;
-
-        dst_size= FFMIN(dst_size, new_size);
-        c->dsp.resample_one(dst, src, dst_size, index2, incr);
-
-        index += dst_size * c->dst_incr_div;
-        index += (frac + dst_size * (int64_t)c->dst_incr_mod) / c->src_incr;
-        av_assert2(index >= 0);
-        *consumed= index;
-        if (update_ctx) {
-            c->frac   = (frac + dst_size * (int64_t)c->dst_incr_mod) % c->src_incr;
-            c->index = 0;
+        int new_size = (src_size * (int64_t)c->src_incr - c->frac + c->dst_incr - 1) / c->dst_incr;
+
+        dst_size = FFMAX(FFMIN(dst_size, new_size), 0);
+        if (dst_size > 0) {
+            for (i = 0; i < dst->ch_count; i++) {
+                c->dsp.resample_one(dst->ch[i], src->ch[i], dst_size, index2, incr);
+                if (i+1 == dst->ch_count) {
+                    c->index += dst_size * c->dst_incr_div;
+                    c->index += (c->frac + dst_size * (int64_t)c->dst_incr_mod) / c->src_incr;
+                    av_assert2(c->index >= 0);
+                    *consumed = c->index;
+                    c->frac   = (c->frac + dst_size * (int64_t)c->dst_incr_mod) % c->src_incr;
+                    c->index = 0;
+                }
+            }
         }
     } else {
         int64_t end_index = (1LL + src_size - c->filter_length) * c->phase_count;
         int64_t delta_frac = (end_index - c->index) * c->src_incr - c->frac;
         int delta_n = (delta_frac + c->dst_incr - 1) / c->dst_incr;
+        int (*resample_func)(struct ResampleContext *c, void *dst,
+                             const void *src, int n, int update_ctx);
 
-        dst_size = FFMIN(dst_size, delta_n);
+        dst_size = FFMAX(FFMIN(dst_size, delta_n), 0);
         if (dst_size > 0) {
-            *consumed = c->dsp.resample(c, dst, src, dst_size, update_ctx);
-        } else {
-            *consumed = 0;
+            /* resample_linear and resample_common should have same behavior
+             * when frac and dst_incr_mod are zero */
+            resample_func = (c->linear && (c->frac || c->dst_incr_mod)) ?
+                            c->dsp.resample_linear : c->dsp.resample_common;
+            for (i = 0; i < dst->ch_count; i++)
+                *consumed = resample_func(c, dst->ch[i], src->ch[i], dst_size, i+1 == dst->ch_count);
         }
     }
 
-    return dst_size;
-}
-
-static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed){
-    int i, ret= -1;
-    int av_unused mm_flags = av_get_cpu_flags();
-    int need_emms = c->format == AV_SAMPLE_FMT_S16P && ARCH_X86_32 &&
-                    (mm_flags & (AV_CPU_FLAG_MMX2 | AV_CPU_FLAG_SSE2)) == AV_CPU_FLAG_MMX2;
-    int64_t max_src_size = (INT64_MAX/2 / c->phase_count) / c->src_incr;
-
-    if (c->compensation_distance)
-        dst_size = FFMIN(dst_size, c->compensation_distance);
-    src_size = FFMIN(src_size, max_src_size);
-
-    for(i=0; i<dst->ch_count; i++){
-        ret= swri_resample(c, dst->ch[i], src->ch[i],
-                           consumed, src_size, dst_size, i+1==dst->ch_count);
-    }
     if(need_emms)
         emms_c();
 
     if (c->compensation_distance) {
-        c->compensation_distance -= ret;
+        c->compensation_distance -= dst_size;
         if (!c->compensation_distance) {
             c->dst_incr     = c->ideal_dst_incr;
             c->dst_incr_div = c->dst_incr / c->src_incr;
@@ -532,7 +511,7 @@ static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, A
         }
     }
 
-    return ret;
+    return dst_size;
 }
 
 static int64_t get_delay(struct SwrContext *s, int64_t base){
@@ -565,18 +544,21 @@ static int64_t get_out_samples(struct SwrContext *s, int in_samples) {
 }
 
 static int resample_flush(struct SwrContext *s) {
+    ResampleContext *c = s->resample;
     AudioData *a= &s->in_buffer;
     int i, j, ret;
-    if((ret = swri_realloc_audio(a, s->in_buffer_index + 2*s->in_buffer_count)) < 0)
+    int reflection = (FFMIN(s->in_buffer_count, c->filter_length) + 1) / 2;
+
+    if((ret = swri_realloc_audio(a, s->in_buffer_index + s->in_buffer_count + reflection)) < 0)
         return ret;
     av_assert0(a->planar);
     for(i=0; i<a->ch_count; i++){
-        for(j=0; j<s->in_buffer_count; j++){
+        for(j=0; j<reflection; j++){
             memcpy(a->ch[i] + (s->in_buffer_index+s->in_buffer_count+j  )*a->bps,
                 a->ch[i] + (s->in_buffer_index+s->in_buffer_count-j-1)*a->bps, a->bps);
         }
     }
-    s->in_buffer_count += (s->in_buffer_count+1)/2;
+    s->in_buffer_count += reflection;
     return 0;
 }
 
diff --git a/mythtv/external/FFmpeg/libswresample/resample.h b/mythtv/external/FFmpeg/libswresample/resample.h
index 7fe9b97f7f8..1731dad3cf8 100644
--- a/mythtv/external/FFmpeg/libswresample/resample.h
+++ b/mythtv/external/FFmpeg/libswresample/resample.h
@@ -53,13 +53,16 @@ typedef struct ResampleContext {
     struct {
         void (*resample_one)(void *dst, const void *src,
                              int n, int64_t index, int64_t incr);
-        int (*resample)(struct ResampleContext *c, void *dst,
-                        const void *src, int n, int update_ctx);
+        int (*resample_common)(struct ResampleContext *c, void *dst,
+                               const void *src, int n, int update_ctx);
+        int (*resample_linear)(struct ResampleContext *c, void *dst,
+                               const void *src, int n, int update_ctx);
     } dsp;
 } ResampleContext;
 
 void swri_resample_dsp_init(ResampleContext *c);
 void swri_resample_dsp_x86_init(ResampleContext *c);
 void swri_resample_dsp_arm_init(ResampleContext *c);
+void swri_resample_dsp_aarch64_init(ResampleContext *c);
 
 #endif /* SWRESAMPLE_RESAMPLE_H */
diff --git a/mythtv/external/FFmpeg/libswresample/resample_dsp.c b/mythtv/external/FFmpeg/libswresample/resample_dsp.c
index 41369f3f8a8..b2424eb6f7c 100644
--- a/mythtv/external/FFmpeg/libswresample/resample_dsp.c
+++ b/mythtv/external/FFmpeg/libswresample/resample_dsp.c
@@ -48,22 +48,27 @@ void swri_resample_dsp_init(ResampleContext *c)
     switch(c->format){
     case AV_SAMPLE_FMT_S16P:
         c->dsp.resample_one = resample_one_int16;
-        c->dsp.resample     = c->linear ? resample_linear_int16 : resample_common_int16;
+        c->dsp.resample_common = resample_common_int16;
+        c->dsp.resample_linear = resample_linear_int16;
         break;
     case AV_SAMPLE_FMT_S32P:
         c->dsp.resample_one = resample_one_int32;
-        c->dsp.resample     = c->linear ? resample_linear_int32 : resample_common_int32;
+        c->dsp.resample_common = resample_common_int32;
+        c->dsp.resample_linear = resample_linear_int32;
         break;
     case AV_SAMPLE_FMT_FLTP:
         c->dsp.resample_one = resample_one_float;
-        c->dsp.resample     = c->linear ? resample_linear_float : resample_common_float;
+        c->dsp.resample_common = resample_common_float;
+        c->dsp.resample_linear = resample_linear_float;
         break;
     case AV_SAMPLE_FMT_DBLP:
         c->dsp.resample_one = resample_one_double;
-        c->dsp.resample     = c->linear ? resample_linear_double : resample_common_double;
+        c->dsp.resample_common = resample_common_double;
+        c->dsp.resample_linear = resample_linear_double;
         break;
     }
 
     if (ARCH_X86) swri_resample_dsp_x86_init(c);
     else if (ARCH_ARM) swri_resample_dsp_arm_init(c);
+    else if (ARCH_AARCH64) swri_resample_dsp_aarch64_init(c);
 }
diff --git a/mythtv/external/FFmpeg/libswresample/resample_template.c b/mythtv/external/FFmpeg/libswresample/resample_template.c
index 1636f4e95d8..4c227b99401 100644
--- a/mythtv/external/FFmpeg/libswresample/resample_template.c
+++ b/mythtv/external/FFmpeg/libswresample/resample_template.c
@@ -32,6 +32,7 @@
 #    define DELEM  double
 #    define FELEM  double
 #    define FELEM2 double
+#    define FOFFSET 0
 #    define OUT(d, v) d = v
 
 #elif    defined(TEMPLATE_RESAMPLE_FLT)
@@ -41,6 +42,7 @@
 #    define DELEM  float
 #    define FELEM  float
 #    define FELEM2 float
+#    define FOFFSET 0
 #    define OUT(d, v) d = v
 
 #elif defined(TEMPLATE_RESAMPLE_S32)
@@ -52,8 +54,8 @@
 #    define FELEM2 int64_t
 #    define FELEM_MAX INT32_MAX
 #    define FELEM_MIN INT32_MIN
-#    define OUT(d, v) (v) = ((v) + (1<<(FILTER_SHIFT-1)))>>FILTER_SHIFT;\
-                      (d) = av_clipl_int32(v)
+#    define FOFFSET (1<<(FILTER_SHIFT-1))
+#    define OUT(d, v) (d) = av_clipl_int32((v)>>FILTER_SHIFT)
 
 #elif    defined(TEMPLATE_RESAMPLE_S16)
 
@@ -65,8 +67,8 @@
 #    define FELEML int64_t
 #    define FELEM_MAX INT16_MAX
 #    define FELEM_MIN INT16_MIN
-#    define OUT(d, v) (v) = ((v) + (1<<(FILTER_SHIFT-1)))>>FILTER_SHIFT;\
-                      (d) = av_clip_int16(v)
+#    define FOFFSET (1<<(FILTER_SHIFT-1))
+#    define OUT(d, v) (d) = av_clip_int16((v)>>FILTER_SHIFT)
 
 #endif
 
@@ -102,12 +104,20 @@ static int RENAME(resample_common)(ResampleContext *c,
     for (dst_index = 0; dst_index < n; dst_index++) {
         FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * index;
 
-        FELEM2 val=0;
+        FELEM2 val = FOFFSET;
+        FELEM2 val2= 0;
         int i;
-        for (i = 0; i < c->filter_length; i++) {
-            val += src[sample_index + i] * (FELEM2)filter[i];
+        for (i = 0; i + 1 < c->filter_length; i+=2) {
+            val  += src[sample_index + i    ] * (FELEM2)filter[i    ];
+            val2 += src[sample_index + i + 1] * (FELEM2)filter[i + 1];
         }
-        OUT(dst[dst_index], val);
+        if (i < c->filter_length)
+            val  += src[sample_index + i    ] * (FELEM2)filter[i    ];
+#ifdef FELEML
+        OUT(dst[dst_index], val + (FELEML)val2);
+#else
+        OUT(dst[dst_index], val + val2);
+#endif
 
         frac  += c->dst_incr_mod;
         index += c->dst_incr_div;
@@ -151,7 +161,7 @@ static int RENAME(resample_linear)(ResampleContext *c,
 
     for (dst_index = 0; dst_index < n; dst_index++) {
         FELEM *filter = ((FELEM *) c->filter_bank) + c->filter_alloc * index;
-        FELEM2 val=0, v2 = 0;
+        FELEM2 val = FOFFSET, v2 = FOFFSET;
 
         int i;
         for (i = 0; i < c->filter_length; i++) {
@@ -199,3 +209,4 @@ static int RENAME(resample_linear)(ResampleContext *c,
 #undef FELEM_MAX
 #undef FELEM_MIN
 #undef OUT
+#undef FOFFSET
diff --git a/mythtv/external/FFmpeg/libswresample/soxr_resample.c b/mythtv/external/FFmpeg/libswresample/soxr_resample.c
index b9c6735028d..8181c749b86 100644
--- a/mythtv/external/FFmpeg/libswresample/soxr_resample.c
+++ b/mythtv/external/FFmpeg/libswresample/soxr_resample.c
@@ -46,7 +46,7 @@ static struct ResampleContext *create(struct ResampleContext *c, int out_rate, i
     soxr_io_spec_t io_spec = soxr_io_spec(type, type);
 
     soxr_quality_spec_t q_spec = soxr_quality_spec((int)((precision-2)/4), (SOXR_HI_PREC_CLOCK|SOXR_ROLLOFF_NONE)*!!cheby);
-    q_spec.precision = linear? 0 : precision;
+    q_spec.precision = precision;
 #if !defined SOXR_VERSION /* Deprecated @ March 2013: */
     q_spec.bw_pc = cutoff? FFMAX(FFMIN(cutoff,.995),.8)*100 : q_spec.bw_pc;
 #else
diff --git a/mythtv/external/FFmpeg/libswresample/swresample.c b/mythtv/external/FFmpeg/libswresample/swresample.c
index 0ef4dea91b8..74c96dce605 100644
--- a/mythtv/external/FFmpeg/libswresample/swresample.c
+++ b/mythtv/external/FFmpeg/libswresample/swresample.c
@@ -84,9 +84,6 @@ struct SwrContext *swr_alloc_set_opts(struct SwrContext *s,
     if (av_opt_set_int(s, "isr", in_sample_rate,  0) < 0)
         goto fail;
 
-    if (av_opt_set_int(s, "tsf", AV_SAMPLE_FMT_NONE,   0) < 0)
-        goto fail;
-
     if (av_opt_set_int(s, "ich", av_get_channel_layout_nb_channels(s-> user_in_ch_layout), 0) < 0)
         goto fail;
 
@@ -226,6 +223,8 @@ av_cold int swr_init(struct SwrContext *s){
         }else if(   av_get_planar_sample_fmt(s-> in_sample_fmt) == AV_SAMPLE_FMT_S32P
                  && av_get_planar_sample_fmt(s->out_sample_fmt) == AV_SAMPLE_FMT_S32P
                  && !s->rematrix
+                 && s->out_sample_rate == s->in_sample_rate
+                 && !(s->flags & SWR_FLAG_RESAMPLE)
                  && s->engine != SWR_ENGINE_SOXR){
             s->int_sample_fmt= AV_SAMPLE_FMT_S32P;
         }else if(av_get_bytes_per_sample(s->in_sample_fmt) <= 4){
@@ -413,9 +412,9 @@ int swri_realloc_audio(AudioData *a, int count){
         return AVERROR(ENOMEM);
     for(i=0; i<a->ch_count; i++){
         a->ch[i]= a->data + i*(a->planar ? countb : a->bps);
-        if(a->planar) memcpy(a->ch[i], old.ch[i], a->count*a->bps);
+        if(a->count && a->planar) memcpy(a->ch[i], old.ch[i], a->count*a->bps);
     }
-    if(!a->planar) memcpy(a->ch[0], old.ch[0], a->count*a->ch_count*a->bps);
+    if(a->count && !a->planar) memcpy(a->ch[0], old.ch[0], a->count*a->ch_count*a->bps);
     av_freep(&old.data);
     a->count= count;
 
diff --git a/mythtv/external/FFmpeg/libswresample/swresample.h b/mythtv/external/FFmpeg/libswresample/swresample.h
index a8db5c2490b..c7b84fbcac5 100644
--- a/mythtv/external/FFmpeg/libswresample/swresample.h
+++ b/mythtv/external/FFmpeg/libswresample/swresample.h
@@ -126,10 +126,6 @@
 
 #include "libswresample/version.h"
 
-#if LIBSWRESAMPLE_VERSION_MAJOR < 1
-#define SWR_CH_MAX 32   ///< Maximum number of channels
-#endif
-
 /**
  * @name Option constants
  * These constants are used for the @ref avoptions interface for lswr.
diff --git a/mythtv/external/FFmpeg/libswresample/swresample_frame.c b/mythtv/external/FFmpeg/libswresample/swresample_frame.c
index 71d3ed711ac..2853266d6ca 100644
--- a/mythtv/external/FFmpeg/libswresample/swresample_frame.c
+++ b/mythtv/external/FFmpeg/libswresample/swresample_frame.c
@@ -139,9 +139,10 @@ int swr_convert_frame(SwrContext *s,
 
     if (out) {
         if (!out->linesize[0]) {
-            out->nb_samples =   swr_get_delay(s, s->out_sample_rate)
-                              + in->nb_samples*(int64_t)s->out_sample_rate / s->in_sample_rate
-                              + 3;
+            out->nb_samples = swr_get_delay(s, s->out_sample_rate) + 3;
+            if (in) {
+                out->nb_samples += in->nb_samples*(int64_t)s->out_sample_rate / s->in_sample_rate;
+            }
             if ((ret = av_frame_get_buffer(out, 0)) < 0) {
                 if (setup)
                     swr_close(s);
diff --git a/mythtv/external/FFmpeg/libswresample/version.h b/mythtv/external/FFmpeg/libswresample/version.h
index 685154982c5..6a66173f3bd 100644
--- a/mythtv/external/FFmpeg/libswresample/version.h
+++ b/mythtv/external/FFmpeg/libswresample/version.h
@@ -29,7 +29,7 @@
 #include "libavutil/avutil.h"
 
 #define LIBSWRESAMPLE_VERSION_MAJOR   2
-#define LIBSWRESAMPLE_VERSION_MINOR   3
+#define LIBSWRESAMPLE_VERSION_MINOR   9
 #define LIBSWRESAMPLE_VERSION_MICRO 100
 
 #define LIBSWRESAMPLE_VERSION_INT  AV_VERSION_INT(LIBSWRESAMPLE_VERSION_MAJOR, \
diff --git a/mythtv/external/FFmpeg/libswresample/x86/Makefile b/mythtv/external/FFmpeg/libswresample/x86/Makefile
index be44df56aa6..fa0641f03fd 100644
--- a/mythtv/external/FFmpeg/libswresample/x86/Makefile
+++ b/mythtv/external/FFmpeg/libswresample/x86/Makefile
@@ -1,4 +1,4 @@
-YASM-OBJS                       += x86/audio_convert.o\
+X86ASM-OBJS                     += x86/audio_convert.o\
                                    x86/rematrix.o\
                                    x86/resample.o\
 
diff --git a/mythtv/external/FFmpeg/libswresample/x86/rematrix_init.c b/mythtv/external/FFmpeg/libswresample/x86/rematrix_init.c
index 5f2c5fe170a..d71b41a73e4 100644
--- a/mythtv/external/FFmpeg/libswresample/x86/rematrix_init.c
+++ b/mythtv/external/FFmpeg/libswresample/x86/rematrix_init.c
@@ -31,7 +31,7 @@ D(int16, mmx)
 D(int16, sse2)
 
 av_cold int swri_rematrix_init_x86(struct SwrContext *s){
-#if HAVE_YASM
+#if HAVE_X86ASM
     int mm_flags = av_get_cpu_flags();
     int nb_in  = av_get_channel_layout_nb_channels(s->in_ch_layout);
     int nb_out = av_get_channel_layout_nb_channels(s->out_ch_layout);
diff --git a/mythtv/external/FFmpeg/libswresample/x86/resample.asm b/mythtv/external/FFmpeg/libswresample/x86/resample.asm
index 4163df1aa1a..7107cf9d42a 100644
--- a/mythtv/external/FFmpeg/libswresample/x86/resample.asm
+++ b/mythtv/external/FFmpeg/libswresample/x86/resample.asm
@@ -203,7 +203,7 @@ cglobal resample_common_%1, 1, 7, 2, ctx, phase_count, dst, frac, \
     ; horizontal sum & store
 %if mmsize == 32
     vextractf128                 xm1, m0, 0x1
-    addps                        xm0, xm1
+    addp%4                       xm0, xm1
 %endif
     movhlps                      xm1, xm0
 %ifidn %1, float
@@ -489,8 +489,8 @@ cglobal resample_linear_%1, 1, 7, 5, ctx, min_filter_length_x4, filter2, \
 %if mmsize == 32
     vextractf128                 xm1, m0, 0x1
     vextractf128                 xm3, m2, 0x1
-    addps                        xm0, xm1
-    addps                        xm2, xm3
+    addp%4                       xm0, xm1
+    addp%4                       xm2, xm3
 %endif
     cvtsi2s%4                    xm1, fracd
     subp%4                       xm2, xm0
@@ -608,3 +608,12 @@ RESAMPLE_FNS int16, 2, 1
 
 INIT_XMM sse2
 RESAMPLE_FNS double, 8, 3, d, pdbl_1
+
+%if HAVE_AVX_EXTERNAL
+INIT_YMM avx
+RESAMPLE_FNS double, 8, 3, d, pdbl_1
+%endif
+%if HAVE_FMA3_EXTERNAL
+INIT_YMM fma3
+RESAMPLE_FNS double, 8, 3, d, pdbl_1
+%endif
diff --git a/mythtv/external/FFmpeg/libswresample/x86/resample_init.c b/mythtv/external/FFmpeg/libswresample/x86/resample_init.c
index 9d7d5cf89e2..c6b2a36060d 100644
--- a/mythtv/external/FFmpeg/libswresample/x86/resample_init.c
+++ b/mythtv/external/FFmpeg/libswresample/x86/resample_init.c
@@ -42,6 +42,8 @@ RESAMPLE_FUNCS(float,  avx);
 RESAMPLE_FUNCS(float,  fma3);
 RESAMPLE_FUNCS(float,  fma4);
 RESAMPLE_FUNCS(double, sse2);
+RESAMPLE_FUNCS(double, avx);
+RESAMPLE_FUNCS(double, fma3);
 
 av_cold void swri_resample_dsp_x86_init(ResampleContext *c)
 {
@@ -50,40 +52,48 @@ av_cold void swri_resample_dsp_x86_init(ResampleContext *c)
     switch(c->format){
     case AV_SAMPLE_FMT_S16P:
         if (ARCH_X86_32 && EXTERNAL_MMXEXT(mm_flags)) {
-            c->dsp.resample = c->linear ? ff_resample_linear_int16_mmxext
-                                        : ff_resample_common_int16_mmxext;
+            c->dsp.resample_linear = ff_resample_linear_int16_mmxext;
+            c->dsp.resample_common = ff_resample_common_int16_mmxext;
         }
         if (EXTERNAL_SSE2(mm_flags)) {
-            c->dsp.resample = c->linear ? ff_resample_linear_int16_sse2
-                                        : ff_resample_common_int16_sse2;
+            c->dsp.resample_linear = ff_resample_linear_int16_sse2;
+            c->dsp.resample_common = ff_resample_common_int16_sse2;
         }
         if (EXTERNAL_XOP(mm_flags)) {
-            c->dsp.resample = c->linear ? ff_resample_linear_int16_xop
-                                        : ff_resample_common_int16_xop;
+            c->dsp.resample_linear = ff_resample_linear_int16_xop;
+            c->dsp.resample_common = ff_resample_common_int16_xop;
         }
         break;
     case AV_SAMPLE_FMT_FLTP:
         if (EXTERNAL_SSE(mm_flags)) {
-            c->dsp.resample = c->linear ? ff_resample_linear_float_sse
-                                        : ff_resample_common_float_sse;
+            c->dsp.resample_linear = ff_resample_linear_float_sse;
+            c->dsp.resample_common = ff_resample_common_float_sse;
         }
         if (EXTERNAL_AVX_FAST(mm_flags)) {
-            c->dsp.resample = c->linear ? ff_resample_linear_float_avx
-                                        : ff_resample_common_float_avx;
+            c->dsp.resample_linear = ff_resample_linear_float_avx;
+            c->dsp.resample_common = ff_resample_common_float_avx;
         }
         if (EXTERNAL_FMA3_FAST(mm_flags)) {
-            c->dsp.resample = c->linear ? ff_resample_linear_float_fma3
-                                        : ff_resample_common_float_fma3;
+            c->dsp.resample_linear = ff_resample_linear_float_fma3;
+            c->dsp.resample_common = ff_resample_common_float_fma3;
         }
         if (EXTERNAL_FMA4(mm_flags)) {
-            c->dsp.resample = c->linear ? ff_resample_linear_float_fma4
-                                        : ff_resample_common_float_fma4;
+            c->dsp.resample_linear = ff_resample_linear_float_fma4;
+            c->dsp.resample_common = ff_resample_common_float_fma4;
         }
         break;
     case AV_SAMPLE_FMT_DBLP:
         if (EXTERNAL_SSE2(mm_flags)) {
-            c->dsp.resample = c->linear ? ff_resample_linear_double_sse2
-                                        : ff_resample_common_double_sse2;
+            c->dsp.resample_linear = ff_resample_linear_double_sse2;
+            c->dsp.resample_common = ff_resample_common_double_sse2;
+        }
+        if (EXTERNAL_AVX_FAST(mm_flags)) {
+            c->dsp.resample_linear = ff_resample_linear_double_avx;
+            c->dsp.resample_common = ff_resample_common_double_avx;
+        }
+        if (EXTERNAL_FMA3_FAST(mm_flags)) {
+            c->dsp.resample_linear = ff_resample_linear_double_fma3;
+            c->dsp.resample_common = ff_resample_common_double_fma3;
         }
         break;
     }
diff --git a/mythtv/external/FFmpeg/libswscale/Makefile b/mythtv/external/FFmpeg/libswscale/Makefile
index 0272039a6c8..5e03e6fa0a2 100644
--- a/mythtv/external/FFmpeg/libswscale/Makefile
+++ b/mythtv/external/FFmpeg/libswscale/Makefile
@@ -1,6 +1,5 @@
-include $(SUBDIR)../config.mak
-
 NAME = swscale
+DESC = FFmpeg image rescaling library
 
 HEADERS = swscale.h                                                     \
           version.h                                                     \
@@ -26,4 +25,5 @@ OBJS-$(CONFIG_SHARED)        += log2_tab.o
 SLIBOBJS-$(HAVE_GNU_WINDRES) += swscaleres.o
 
 TESTPROGS = colorspace                                                  \
+            pixdesc_query                                               \
             swscale                                                     \
diff --git a/mythtv/external/FFmpeg/libswscale/input.c b/mythtv/external/FFmpeg/libswscale/input.c
index 14ab5abb3a0..bb2f4933ec4 100644
--- a/mythtv/external/FFmpeg/libswscale/input.c
+++ b/mythtv/external/FFmpeg/libswscale/input.c
@@ -719,6 +719,28 @@ static void p010BEToUV_c(uint8_t *dstU, uint8_t *dstV,
     }
 }
 
+static void p016LEToUV_c(uint8_t *dstU, uint8_t *dstV,
+                       const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
+                       int width, uint32_t *unused)
+{
+    int i;
+    for (i = 0; i < width; i++) {
+        AV_WN16(dstU + i * 2, AV_RL16(src1 + i * 4 + 0));
+        AV_WN16(dstV + i * 2, AV_RL16(src1 + i * 4 + 2));
+    }
+}
+
+static void p016BEToUV_c(uint8_t *dstU, uint8_t *dstV,
+                       const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
+                       int width, uint32_t *unused)
+{
+    int i;
+    for (i = 0; i < width; i++) {
+        AV_WN16(dstU + i * 2, AV_RB16(src1 + i * 4 + 0));
+        AV_WN16(dstV + i * 2, AV_RB16(src1 + i * 4 + 2));
+    }
+}
+
 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
 
 static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
@@ -926,17 +948,24 @@ static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *s
 {                                                                                                   \
     planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv);                                         \
 }                                                                                                   \
-static void planar_rgb##nbits##endian_name##_to_a(uint8_t *dst, const uint8_t *src[4],              \
-                                                  int w, int32_t *rgb2yuv)                          \
-{                                                                                                   \
-    planar_rgb16_to_a(dst, src, w, nbits, endian, rgb2yuv);                                         \
-}                                                                                                   \
 static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV,                    \
                                                    const uint8_t *src[4], int w, int32_t *rgb2yuv)  \
 {                                                                                                   \
     planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv);                                 \
 }                                                                                                   \
 
+#define rgb9plus_planar_transparency_funcs(nbits)                           \
+static void planar_rgb##nbits##le_to_a(uint8_t *dst, const uint8_t *src[4], \
+                                       int w, int32_t *rgb2yuv)             \
+{                                                                           \
+    planar_rgb16_to_a(dst, src, w, nbits, 0, rgb2yuv);                      \
+}                                                                           \
+static void planar_rgb##nbits##be_to_a(uint8_t *dst, const uint8_t *src[4], \
+                                       int w, int32_t *rgb2yuv)             \
+{                                                                           \
+    planar_rgb16_to_a(dst, src, w, nbits, 1, rgb2yuv);                      \
+}
+
 #define rgb9plus_planar_funcs(nbits)            \
     rgb9plus_planar_funcs_endian(nbits, le, 0)  \
     rgb9plus_planar_funcs_endian(nbits, be, 1)
@@ -947,6 +976,10 @@ rgb9plus_planar_funcs(12)
 rgb9plus_planar_funcs(14)
 rgb9plus_planar_funcs(16)
 
+rgb9plus_planar_transparency_funcs(10)
+rgb9plus_planar_transparency_funcs(12)
+rgb9plus_planar_transparency_funcs(16)
+
 av_cold void ff_sws_init_input_funcs(SwsContext *c)
 {
     enum AVPixelFormat srcFormat = c->srcFormat;
@@ -1016,60 +1049,60 @@ av_cold void ff_sws_init_input_funcs(SwsContext *c)
         c->readChrPlanar = planar_rgb_to_uv;
         break;
 #if HAVE_BIGENDIAN
-    case AV_PIX_FMT_YUV444P9LE:
-    case AV_PIX_FMT_YUV422P9LE:
     case AV_PIX_FMT_YUV420P9LE:
+    case AV_PIX_FMT_YUV422P9LE:
+    case AV_PIX_FMT_YUV444P9LE:
+    case AV_PIX_FMT_YUV420P10LE:
     case AV_PIX_FMT_YUV422P10LE:
     case AV_PIX_FMT_YUV440P10LE:
     case AV_PIX_FMT_YUV444P10LE:
-    case AV_PIX_FMT_YUV420P10LE:
+    case AV_PIX_FMT_YUV420P12LE:
     case AV_PIX_FMT_YUV422P12LE:
     case AV_PIX_FMT_YUV440P12LE:
     case AV_PIX_FMT_YUV444P12LE:
-    case AV_PIX_FMT_YUV420P12LE:
+    case AV_PIX_FMT_YUV420P14LE:
     case AV_PIX_FMT_YUV422P14LE:
     case AV_PIX_FMT_YUV444P14LE:
-    case AV_PIX_FMT_YUV420P14LE:
     case AV_PIX_FMT_YUV420P16LE:
     case AV_PIX_FMT_YUV422P16LE:
     case AV_PIX_FMT_YUV444P16LE:
 
-    case AV_PIX_FMT_YUVA444P9LE:
-    case AV_PIX_FMT_YUVA422P9LE:
     case AV_PIX_FMT_YUVA420P9LE:
-    case AV_PIX_FMT_YUVA444P10LE:
-    case AV_PIX_FMT_YUVA422P10LE:
+    case AV_PIX_FMT_YUVA422P9LE:
+    case AV_PIX_FMT_YUVA444P9LE:
     case AV_PIX_FMT_YUVA420P10LE:
+    case AV_PIX_FMT_YUVA422P10LE:
+    case AV_PIX_FMT_YUVA444P10LE:
     case AV_PIX_FMT_YUVA420P16LE:
     case AV_PIX_FMT_YUVA422P16LE:
     case AV_PIX_FMT_YUVA444P16LE:
         c->chrToYV12 = bswap16UV_c;
         break;
 #else
-    case AV_PIX_FMT_YUV444P9BE:
-    case AV_PIX_FMT_YUV422P9BE:
     case AV_PIX_FMT_YUV420P9BE:
+    case AV_PIX_FMT_YUV422P9BE:
+    case AV_PIX_FMT_YUV444P9BE:
+    case AV_PIX_FMT_YUV420P10BE:
+    case AV_PIX_FMT_YUV422P10BE:
     case AV_PIX_FMT_YUV440P10BE:
     case AV_PIX_FMT_YUV444P10BE:
-    case AV_PIX_FMT_YUV422P10BE:
-    case AV_PIX_FMT_YUV420P10BE:
+    case AV_PIX_FMT_YUV420P12BE:
+    case AV_PIX_FMT_YUV422P12BE:
     case AV_PIX_FMT_YUV440P12BE:
     case AV_PIX_FMT_YUV444P12BE:
-    case AV_PIX_FMT_YUV422P12BE:
-    case AV_PIX_FMT_YUV420P12BE:
-    case AV_PIX_FMT_YUV444P14BE:
-    case AV_PIX_FMT_YUV422P14BE:
     case AV_PIX_FMT_YUV420P14BE:
+    case AV_PIX_FMT_YUV422P14BE:
+    case AV_PIX_FMT_YUV444P14BE:
     case AV_PIX_FMT_YUV420P16BE:
     case AV_PIX_FMT_YUV422P16BE:
     case AV_PIX_FMT_YUV444P16BE:
 
-    case AV_PIX_FMT_YUVA444P9BE:
-    case AV_PIX_FMT_YUVA422P9BE:
     case AV_PIX_FMT_YUVA420P9BE:
-    case AV_PIX_FMT_YUVA444P10BE:
-    case AV_PIX_FMT_YUVA422P10BE:
+    case AV_PIX_FMT_YUVA422P9BE:
+    case AV_PIX_FMT_YUVA444P9BE:
     case AV_PIX_FMT_YUVA420P10BE:
+    case AV_PIX_FMT_YUVA422P10BE:
+    case AV_PIX_FMT_YUVA444P10BE:
     case AV_PIX_FMT_YUVA420P16BE:
     case AV_PIX_FMT_YUVA422P16BE:
     case AV_PIX_FMT_YUVA444P16BE:
@@ -1085,6 +1118,12 @@ av_cold void ff_sws_init_input_funcs(SwsContext *c)
     case AV_PIX_FMT_P010BE:
         c->chrToYV12 = p010BEToUV_c;
         break;
+    case AV_PIX_FMT_P016LE:
+        c->chrToYV12 = p016LEToUV_c;
+        break;
+    case AV_PIX_FMT_P016BE:
+        c->chrToYV12 = p016BEToUV_c;
+        break;
     }
     if (c->chrSrcHSubSample) {
         switch (srcFormat) {
@@ -1305,33 +1344,38 @@ av_cold void ff_sws_init_input_funcs(SwsContext *c)
         c->readLumPlanar = planar_rgb_to_y;
         break;
 #if HAVE_BIGENDIAN
-    case AV_PIX_FMT_YUV444P9LE:
-    case AV_PIX_FMT_YUV422P9LE:
     case AV_PIX_FMT_YUV420P9LE:
-    case AV_PIX_FMT_YUV444P10LE:
-    case AV_PIX_FMT_YUV440P10LE:
-    case AV_PIX_FMT_YUV422P10LE:
+    case AV_PIX_FMT_YUV422P9LE:
+    case AV_PIX_FMT_YUV444P9LE:
     case AV_PIX_FMT_YUV420P10LE:
-    case AV_PIX_FMT_YUV444P12LE:
-    case AV_PIX_FMT_YUV440P12LE:
-    case AV_PIX_FMT_YUV422P12LE:
+    case AV_PIX_FMT_YUV422P10LE:
+    case AV_PIX_FMT_YUV440P10LE:
+    case AV_PIX_FMT_YUV444P10LE:
     case AV_PIX_FMT_YUV420P12LE:
-    case AV_PIX_FMT_YUV444P14LE:
-    case AV_PIX_FMT_YUV422P14LE:
+    case AV_PIX_FMT_YUV422P12LE:
+    case AV_PIX_FMT_YUV440P12LE:
+    case AV_PIX_FMT_YUV444P12LE:
     case AV_PIX_FMT_YUV420P14LE:
+    case AV_PIX_FMT_YUV422P14LE:
+    case AV_PIX_FMT_YUV444P14LE:
     case AV_PIX_FMT_YUV420P16LE:
     case AV_PIX_FMT_YUV422P16LE:
     case AV_PIX_FMT_YUV444P16LE:
 
+    case AV_PIX_FMT_GRAY9LE:
+    case AV_PIX_FMT_GRAY10LE:
+    case AV_PIX_FMT_GRAY12LE:
     case AV_PIX_FMT_GRAY16LE:
+
+    case AV_PIX_FMT_P016LE:
         c->lumToYV12 = bswap16Y_c;
         break;
-    case AV_PIX_FMT_YUVA444P9LE:
-    case AV_PIX_FMT_YUVA422P9LE:
     case AV_PIX_FMT_YUVA420P9LE:
-    case AV_PIX_FMT_YUVA444P10LE:
-    case AV_PIX_FMT_YUVA422P10LE:
+    case AV_PIX_FMT_YUVA422P9LE:
+    case AV_PIX_FMT_YUVA444P9LE:
     case AV_PIX_FMT_YUVA420P10LE:
+    case AV_PIX_FMT_YUVA422P10LE:
+    case AV_PIX_FMT_YUVA444P10LE:
     case AV_PIX_FMT_YUVA420P16LE:
     case AV_PIX_FMT_YUVA422P16LE:
     case AV_PIX_FMT_YUVA444P16LE:
@@ -1339,33 +1383,38 @@ av_cold void ff_sws_init_input_funcs(SwsContext *c)
         c->alpToYV12 = bswap16Y_c;
         break;
 #else
-    case AV_PIX_FMT_YUV444P9BE:
-    case AV_PIX_FMT_YUV422P9BE:
     case AV_PIX_FMT_YUV420P9BE:
-    case AV_PIX_FMT_YUV444P10BE:
-    case AV_PIX_FMT_YUV440P10BE:
-    case AV_PIX_FMT_YUV422P10BE:
+    case AV_PIX_FMT_YUV422P9BE:
+    case AV_PIX_FMT_YUV444P9BE:
     case AV_PIX_FMT_YUV420P10BE:
-    case AV_PIX_FMT_YUV444P12BE:
-    case AV_PIX_FMT_YUV440P12BE:
-    case AV_PIX_FMT_YUV422P12BE:
+    case AV_PIX_FMT_YUV422P10BE:
+    case AV_PIX_FMT_YUV440P10BE:
+    case AV_PIX_FMT_YUV444P10BE:
     case AV_PIX_FMT_YUV420P12BE:
-    case AV_PIX_FMT_YUV444P14BE:
-    case AV_PIX_FMT_YUV422P14BE:
+    case AV_PIX_FMT_YUV422P12BE:
+    case AV_PIX_FMT_YUV440P12BE:
+    case AV_PIX_FMT_YUV444P12BE:
     case AV_PIX_FMT_YUV420P14BE:
+    case AV_PIX_FMT_YUV422P14BE:
+    case AV_PIX_FMT_YUV444P14BE:
     case AV_PIX_FMT_YUV420P16BE:
     case AV_PIX_FMT_YUV422P16BE:
     case AV_PIX_FMT_YUV444P16BE:
 
+    case AV_PIX_FMT_GRAY9BE:
+    case AV_PIX_FMT_GRAY10BE:
+    case AV_PIX_FMT_GRAY12BE:
     case AV_PIX_FMT_GRAY16BE:
+
+    case AV_PIX_FMT_P016BE:
         c->lumToYV12 = bswap16Y_c;
         break;
-    case AV_PIX_FMT_YUVA444P9BE:
-    case AV_PIX_FMT_YUVA422P9BE:
     case AV_PIX_FMT_YUVA420P9BE:
-    case AV_PIX_FMT_YUVA444P10BE:
-    case AV_PIX_FMT_YUVA422P10BE:
+    case AV_PIX_FMT_YUVA422P9BE:
+    case AV_PIX_FMT_YUVA444P9BE:
     case AV_PIX_FMT_YUVA420P10BE:
+    case AV_PIX_FMT_YUVA422P10BE:
+    case AV_PIX_FMT_YUVA444P10BE:
     case AV_PIX_FMT_YUVA420P16BE:
     case AV_PIX_FMT_YUVA422P16BE:
     case AV_PIX_FMT_YUVA444P16BE:
@@ -1490,7 +1539,7 @@ av_cold void ff_sws_init_input_funcs(SwsContext *c)
     }
     if (c->needAlpha) {
         if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
-            if (HAVE_BIGENDIAN == !isBE(srcFormat))
+            if (HAVE_BIGENDIAN == !isBE(srcFormat) && !c->readAlpPlanar)
                 c->alpToYV12 = bswap16Y_c;
         }
         switch (srcFormat) {
diff --git a/mythtv/external/FFmpeg/libswscale/options.c b/mythtv/external/FFmpeg/libswscale/options.c
index c1ea33620d7..7eb27525432 100644
--- a/mythtv/external/FFmpeg/libswscale/options.c
+++ b/mythtv/external/FFmpeg/libswscale/options.c
@@ -57,8 +57,8 @@ static const AVOption swscale_options[] = {
     { "srch",            "source height",                 OFFSET(srcH),      AV_OPT_TYPE_INT,    { .i64 = 16                 }, 1,       INT_MAX,        VE },
     { "dstw",            "destination width",             OFFSET(dstW),      AV_OPT_TYPE_INT,    { .i64 = 16                 }, 1,       INT_MAX,        VE },
     { "dsth",            "destination height",            OFFSET(dstH),      AV_OPT_TYPE_INT,    { .i64 = 16                 }, 1,       INT_MAX,        VE },
-    { "src_format",      "source format",                 OFFSET(srcFormat), AV_OPT_TYPE_INT,    { .i64 = DEFAULT            }, 0,       AV_PIX_FMT_NB - 1, VE },
-    { "dst_format",      "destination format",            OFFSET(dstFormat), AV_OPT_TYPE_INT,    { .i64 = DEFAULT            }, 0,       AV_PIX_FMT_NB - 1, VE },
+    { "src_format",      "source format",                 OFFSET(srcFormat), AV_OPT_TYPE_PIXEL_FMT,{ .i64 = DEFAULT          }, 0,       INT_MAX, VE },
+    { "dst_format",      "destination format",            OFFSET(dstFormat), AV_OPT_TYPE_PIXEL_FMT,{ .i64 = DEFAULT          }, 0,       INT_MAX, VE },
     { "src_range",       "source is full range",          OFFSET(srcRange),  AV_OPT_TYPE_BOOL,   { .i64 = DEFAULT            }, 0,       1,              VE },
     { "dst_range",       "destination is full range",     OFFSET(dstRange),  AV_OPT_TYPE_BOOL,   { .i64 = DEFAULT            }, 0,       1,              VE },
     { "param0",          "scaler param 0",                OFFSET(param[0]),  AV_OPT_TYPE_DOUBLE, { .dbl = SWS_PARAM_DEFAULT  }, INT_MIN, INT_MAX,        VE },
diff --git a/mythtv/external/FFmpeg/libswscale/output.c b/mythtv/external/FFmpeg/libswscale/output.c
index 62cbe2ffaaf..f30bce8dd3c 100644
--- a/mythtv/external/FFmpeg/libswscale/output.c
+++ b/mythtv/external/FFmpeg/libswscale/output.c
@@ -1979,10 +1979,8 @@ yuv2gbrp_full_X_c(SwsContext *c, const int16_t *lumFilter,
             for (j = 0; j < lumFilterSize; j++)
                 A += alpSrc[j][i] * lumFilter[j];
 
-            A >>= 19;
-
-            if (A & 0x100)
-                A = av_clip_uint8(A);
+            if (A & 0xF8000000)
+                A =  av_clip_uintp2(A, 27);
         }
 
         Y -= c->yuv2rgb_y_offset;
@@ -2003,13 +2001,13 @@ yuv2gbrp_full_X_c(SwsContext *c, const int16_t *lumFilter,
             dest16[1][i] = B >> SH;
             dest16[2][i] = R >> SH;
             if (hasAlpha)
-                dest16[3][i] = A;
+                dest16[3][i] = A >> (SH - 3);
         } else {
             dest[0][i] = G >> 22;
             dest[1][i] = B >> 22;
             dest[2][i] = R >> 22;
             if (hasAlpha)
-                dest[3][i] = A;
+                dest[3][i] = A >> 19;
         }
     }
     if (SH != 22 && (!isBE(c->dstFormat)) != (!HAVE_BIGENDIAN)) {
@@ -2023,6 +2021,81 @@ yuv2gbrp_full_X_c(SwsContext *c, const int16_t *lumFilter,
     }
 }
 
+static void
+yuv2gbrp16_full_X_c(SwsContext *c, const int16_t *lumFilter,
+                    const int16_t **lumSrcx, int lumFilterSize,
+                    const int16_t *chrFilter, const int16_t **chrUSrcx,
+                    const int16_t **chrVSrcx, int chrFilterSize,
+                    const int16_t **alpSrcx, uint8_t **dest,
+                    int dstW, int y)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->dstFormat);
+    int i;
+    int hasAlpha = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) && alpSrcx;
+    uint16_t **dest16 = (uint16_t**)dest;
+    const int32_t **lumSrc  = (const int32_t**)lumSrcx;
+    const int32_t **chrUSrc = (const int32_t**)chrUSrcx;
+    const int32_t **chrVSrc = (const int32_t**)chrVSrcx;
+    const int32_t **alpSrc  = (const int32_t**)alpSrcx;
+
+    for (i = 0; i < dstW; i++) {
+        int j;
+        int Y = -0x40000000;
+        int U = -(128 << 23);
+        int V = -(128 << 23);
+        int R, G, B, A;
+
+        for (j = 0; j < lumFilterSize; j++)
+            Y += lumSrc[j][i] * (unsigned)lumFilter[j];
+
+        for (j = 0; j < chrFilterSize; j++) {
+            U += chrUSrc[j][i] * (unsigned)chrFilter[j];
+            V += chrVSrc[j][i] * (unsigned)chrFilter[j];
+        }
+
+        Y >>= 14;
+        Y += 0x10000;
+        U >>= 14;
+        V >>= 14;
+
+        if (hasAlpha) {
+            A = -0x40000000;
+
+            for (j = 0; j < lumFilterSize; j++)
+                A += alpSrc[j][i] * lumFilter[j];
+
+            A >>= 1;
+            A += 0x20002000;
+        }
+
+        Y -= c->yuv2rgb_y_offset;
+        Y *= c->yuv2rgb_y_coeff;
+        Y += 1 << 13;
+        R = V * c->yuv2rgb_v2r_coeff;
+        G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
+        B =                            U * c->yuv2rgb_u2b_coeff;
+
+        R = av_clip_uintp2(Y + R, 30);
+        G = av_clip_uintp2(Y + G, 30);
+        B = av_clip_uintp2(Y + B, 30);
+
+        dest16[0][i] = G >> 14;
+        dest16[1][i] = B >> 14;
+        dest16[2][i] = R >> 14;
+        if (hasAlpha)
+            dest16[3][i] = av_clip_uintp2(A, 30) >> 14;
+    }
+    if ((!isBE(c->dstFormat)) != (!HAVE_BIGENDIAN)) {
+        for (i = 0; i < dstW; i++) {
+            dest16[0][i] = av_bswap16(dest16[0][i]);
+            dest16[1][i] = av_bswap16(dest16[1][i]);
+            dest16[2][i] = av_bswap16(dest16[2][i]);
+            if (hasAlpha)
+                dest16[3][i] = av_bswap16(dest16[3][i]);
+        }
+    }
+}
+
 static void
 yuv2ya8_1_c(SwsContext *c, const int16_t *buf0,
             const int16_t *ubuf[2], const int16_t *vbuf[2],
@@ -2184,7 +2257,7 @@ av_cold void ff_sws_init_output_funcs(SwsContext *c,
     } else if (is16BPS(dstFormat)) {
         *yuv2planeX = isBE(dstFormat) ? yuv2planeX_16BE_c  : yuv2planeX_16LE_c;
         *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_16BE_c  : yuv2plane1_16LE_c;
-    } else if (is9_OR_10BPS(dstFormat)) {
+    } else if (isNBPS(dstFormat)) {
         if (desc->comp[0].depth == 9) {
             *yuv2planeX = isBE(dstFormat) ? yuv2planeX_9BE_c  : yuv2planeX_9LE_c;
             *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_9BE_c  : yuv2plane1_9LE_c;
@@ -2404,11 +2477,19 @@ av_cold void ff_sws_init_output_funcs(SwsContext *c,
         case AV_PIX_FMT_GBRP12LE:
         case AV_PIX_FMT_GBRP14BE:
         case AV_PIX_FMT_GBRP14LE:
-        case AV_PIX_FMT_GBRP16BE:
-        case AV_PIX_FMT_GBRP16LE:
         case AV_PIX_FMT_GBRAP:
+        case AV_PIX_FMT_GBRAP10BE:
+        case AV_PIX_FMT_GBRAP10LE:
+        case AV_PIX_FMT_GBRAP12BE:
+        case AV_PIX_FMT_GBRAP12LE:
             *yuv2anyX = yuv2gbrp_full_X_c;
             break;
+        case AV_PIX_FMT_GBRP16BE:
+        case AV_PIX_FMT_GBRP16LE:
+        case AV_PIX_FMT_GBRAP16BE:
+        case AV_PIX_FMT_GBRAP16LE:
+            *yuv2anyX = yuv2gbrp16_full_X_c;
+            break;
         }
         if (!*yuv2packedX && !*yuv2anyX)
             goto YUV_PACKED;
diff --git a/mythtv/external/FFmpeg/libswscale/ppc/swscale_altivec.c b/mythtv/external/FFmpeg/libswscale/ppc/swscale_altivec.c
index 35a08c47934..9438a63ff2d 100644
--- a/mythtv/external/FFmpeg/libswscale/ppc/swscale_altivec.c
+++ b/mythtv/external/FFmpeg/libswscale/ppc/swscale_altivec.c
@@ -337,7 +337,7 @@ av_cold void ff_sws_init_swscale_ppc(SwsContext *c)
     if (c->srcBpc == 8 && c->dstBpc <= 14) {
         c->hyScale = c->hcScale = hScale_altivec_real;
     }
-    if (!is16BPS(dstFormat) && !is9_OR_10BPS(dstFormat) &&
+    if (!is16BPS(dstFormat) && !isNBPS(dstFormat) &&
         dstFormat != AV_PIX_FMT_NV12 && dstFormat != AV_PIX_FMT_NV21 &&
         !c->needAlpha) {
         c->yuv2planeX = yuv2planeX_altivec;
diff --git a/mythtv/external/FFmpeg/libswscale/rgb2rgb.c b/mythtv/external/FFmpeg/libswscale/rgb2rgb.c
index f7f8188af1a..04b7908b5e7 100644
--- a/mythtv/external/FFmpeg/libswscale/rgb2rgb.c
+++ b/mythtv/external/FFmpeg/libswscale/rgb2rgb.c
@@ -391,3 +391,41 @@ void rgb64to48_ ## need_bswap(const uint8_t *src,                       \
 
 DEFINE_RGB64TO48(nobswap, 0)
 DEFINE_RGB64TO48(bswap, 1)
+
+#define DEFINE_RGB48TOBGR64(need_bswap, swap)                           \
+void rgb48tobgr64_ ## need_bswap(const uint8_t *src,                    \
+                                 uint8_t *dst, int src_size)            \
+{                                                                       \
+    uint16_t *d = (uint16_t *)dst;                                      \
+    uint16_t *s = (uint16_t *)src;                                      \
+    int i, num_pixels = src_size / 6;                                   \
+                                                                        \
+    for (i = 0; i < num_pixels; i++) {                                  \
+        d[4 * i    ] = swap ? av_bswap16(s[3 * i + 2]) : s[3 * i + 2];  \
+        d[4 * i + 1] = swap ? av_bswap16(s[3 * i + 1]) : s[3 * i + 1];  \
+        d[4 * i + 2] = swap ? av_bswap16(s[3 * i    ]) : s[3 * i    ];  \
+        d[4 * i + 3] = 0xFFFF;                                          \
+    }                                                                   \
+}
+
+DEFINE_RGB48TOBGR64(nobswap, 0)
+DEFINE_RGB48TOBGR64(bswap, 1)
+
+#define DEFINE_RGB48TO64(need_bswap, swap)                              \
+void rgb48to64_ ## need_bswap(const uint8_t *src,                       \
+                              uint8_t *dst, int src_size)               \
+{                                                                       \
+    uint16_t *d = (uint16_t *)dst;                                      \
+    uint16_t *s = (uint16_t *)src;                                      \
+    int i, num_pixels = src_size / 6;                                   \
+                                                                        \
+    for (i = 0; i < num_pixels; i++) {                                  \
+        d[4 * i    ] = swap ? av_bswap16(s[3 * i    ]) : s[3 * i    ];  \
+        d[4 * i + 1] = swap ? av_bswap16(s[3 * i + 1]) : s[3 * i + 1];  \
+        d[4 * i + 2] = swap ? av_bswap16(s[3 * i + 2]) : s[3 * i + 2];  \
+        d[4 * i + 3] = 0xFFFF;                                          \
+    }                                                                   \
+}
+
+DEFINE_RGB48TO64(nobswap, 0)
+DEFINE_RGB48TO64(bswap, 1)
diff --git a/mythtv/external/FFmpeg/libswscale/rgb2rgb.h b/mythtv/external/FFmpeg/libswscale/rgb2rgb.h
index 0645404eee7..6994839299d 100644
--- a/mythtv/external/FFmpeg/libswscale/rgb2rgb.h
+++ b/mythtv/external/FFmpeg/libswscale/rgb2rgb.h
@@ -59,6 +59,10 @@ void rgb48tobgr48_nobswap(const uint8_t *src, uint8_t *dst, int src_size);
 void   rgb48tobgr48_bswap(const uint8_t *src, uint8_t *dst, int src_size);
 void    rgb64to48_nobswap(const uint8_t *src, uint8_t *dst, int src_size);
 void      rgb64to48_bswap(const uint8_t *src, uint8_t *dst, int src_size);
+void rgb48tobgr64_nobswap(const uint8_t *src, uint8_t *dst, int src_size);
+void   rgb48tobgr64_bswap(const uint8_t *src, uint8_t *dst, int src_size);
+void    rgb48to64_nobswap(const uint8_t *src, uint8_t *dst, int src_size);
+void      rgb48to64_bswap(const uint8_t *src, uint8_t *dst, int src_size);
 void    rgb24to32(const uint8_t *src, uint8_t *dst, int src_size);
 void    rgb32to24(const uint8_t *src, uint8_t *dst, int src_size);
 void rgb16tobgr32(const uint8_t *src, uint8_t *dst, int src_size);
diff --git a/mythtv/external/FFmpeg/libswscale/slice.c b/mythtv/external/FFmpeg/libswscale/slice.c
index e14456f75f3..db4fa874ffc 100644
--- a/mythtv/external/FFmpeg/libswscale/slice.c
+++ b/mythtv/external/FFmpeg/libswscale/slice.c
@@ -158,7 +158,7 @@ int ff_init_slice_from_src(SwsSlice * s, uint8_t *src[4], int stride[4], int src
                         chrY + chrH,
                         lumY + lumH};
 
-    const uint8_t *src_[4] = {src[0] + (relative ? 0 : start[0]) * stride[0],
+    uint8_t *const src_[4] = {src[0] + (relative ? 0 : start[0]) * stride[0],
                               src[1] + (relative ? 0 : start[1]) * stride[1],
                               src[2] + (relative ? 0 : start[2]) * stride[2],
                               src[3] + (relative ? 0 : start[3]) * stride[3]};
diff --git a/mythtv/external/FFmpeg/libswscale/swscale.c b/mythtv/external/FFmpeg/libswscale/swscale.c
index c3a8d0efd42..7f3e22355fe 100644
--- a/mythtv/external/FFmpeg/libswscale/swscale.c
+++ b/mythtv/external/FFmpeg/libswscale/swscale.c
@@ -254,7 +254,7 @@ static int swscale(SwsContext *c, const uint8_t *src[],
     yuv2anyX_fn yuv2anyX             = c->yuv2anyX;
     const int chrSrcSliceY           =                srcSliceY >> c->chrSrcVSubSample;
     const int chrSrcSliceH           = AV_CEIL_RSHIFT(srcSliceH,   c->chrSrcVSubSample);
-    int should_dither                = is9_OR_10BPS(c->srcFormat) ||
+    int should_dither                = isNBPS(c->srcFormat) ||
                                        is16BPS(c->srcFormat);
     int lastDstY;
 
@@ -326,7 +326,7 @@ static int swscale(SwsContext *c, const uint8_t *src[],
         static int warnedAlready=0;
         int cpu_flags = av_get_cpu_flags();
         if (HAVE_MMXEXT && (cpu_flags & AV_CPU_FLAG_SSE2) && !warnedAlready){
-            av_log(c, AV_LOG_WARNING, "Warning: data is not aligned! This can lead to a speedloss\n");
+            av_log(c, AV_LOG_WARNING, "Warning: data is not aligned! This can lead to a speed loss\n");
             warnedAlready=1;
         }
     }
@@ -762,10 +762,8 @@ int attribute_align_arg sws_scale(struct SwsContext *c,
     uint8_t *rgb0_tmp = NULL;
     int macro_height = isBayer(c->srcFormat) ? 2 : (1 << c->chrSrcVSubSample);
     // copy strides, so they can safely be modified
-    int srcStride2[4] = { srcStride[0], srcStride[1], srcStride[2],
-                            srcStride[3] };
-    int dstStride2[4] = { dstStride[0], dstStride[1], dstStride[2],
-                            dstStride[3] };
+    int srcStride2[4];
+    int dstStride2[4];
     int srcSliceY_internal = srcSliceY;
 
     if (!srcStride || !dstStride || !dst || !srcSlice) {
@@ -773,6 +771,11 @@ int attribute_align_arg sws_scale(struct SwsContext *c,
         return 0;
     }
 
+    for (i=0; i<4; i++) {
+        srcStride2[i] = srcStride[i];
+        dstStride2[i] = dstStride[i];
+    }
+
     if ((srcSliceY & (macro_height-1)) ||
         ((srcSliceH& (macro_height-1)) && srcSliceY + srcSliceH != c->srcH) ||
         srcSliceY + srcSliceH > c->srcH) {
diff --git a/mythtv/external/FFmpeg/libswscale/swscale_internal.h b/mythtv/external/FFmpeg/libswscale/swscale_internal.h
index 54cd85cce38..0f51df95d75 100644
--- a/mythtv/external/FFmpeg/libswscale/swscale_internal.h
+++ b/mythtv/external/FFmpeg/libswscale/swscale_internal.h
@@ -22,11 +22,6 @@
 #define SWSCALE_SWSCALE_INTERNAL_H
 
 #include "config.h"
-
-#if HAVE_ALTIVEC_H
-#include <altivec.h>
-#endif
-
 #include "version.h"
 
 #include "libavutil/avassert.h"
@@ -36,6 +31,7 @@
 #include "libavutil/log.h"
 #include "libavutil/pixfmt.h"
 #include "libavutil/pixdesc.h"
+#include "libavutil/ppc/util_altivec.h"
 
 #define STR(s) AV_TOSTRING(s) // AV_STRINGIFY is too long
 
@@ -652,15 +648,13 @@ static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
     return desc->comp[0].depth == 16;
 }
 
-static av_always_inline int is9_OR_10BPS(enum AVPixelFormat pix_fmt)
+static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
 {
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     av_assert0(desc);
     return desc->comp[0].depth >= 9 && desc->comp[0].depth <= 14;
 }
 
-#define isNBPS(x) is9_OR_10BPS(x)
-
 static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
 {
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
@@ -689,104 +683,75 @@ static av_always_inline int isRGB(enum AVPixelFormat pix_fmt)
     return (desc->flags & AV_PIX_FMT_FLAG_RGB);
 }
 
-#if 0 // FIXME
-#define isGray(x) \
-    (!(av_pix_fmt_desc_get(x)->flags & AV_PIX_FMT_FLAG_PAL) && \
-     av_pix_fmt_desc_get(x)->nb_components <= 2)
-#else
-#define isGray(x)                      \
-    ((x) == AV_PIX_FMT_GRAY8       ||  \
-     (x) == AV_PIX_FMT_YA8         ||  \
-     (x) == AV_PIX_FMT_GRAY16BE    ||  \
-     (x) == AV_PIX_FMT_GRAY16LE    ||  \
-     (x) == AV_PIX_FMT_YA16BE      ||  \
-     (x) == AV_PIX_FMT_YA16LE)
-#endif
+static av_always_inline int isGray(enum AVPixelFormat pix_fmt)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+    av_assert0(desc);
+    return !(desc->flags & AV_PIX_FMT_FLAG_PAL) &&
+           !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
+           desc->nb_components <= 2 &&
+           pix_fmt != AV_PIX_FMT_MONOBLACK &&
+           pix_fmt != AV_PIX_FMT_MONOWHITE;
+}
 
-#define isRGBinInt(x) \
-    (           \
-     (x) == AV_PIX_FMT_RGB48BE     ||  \
-     (x) == AV_PIX_FMT_RGB48LE     ||  \
-     (x) == AV_PIX_FMT_RGB32       ||  \
-     (x) == AV_PIX_FMT_RGB32_1     ||  \
-     (x) == AV_PIX_FMT_RGB24       ||  \
-     (x) == AV_PIX_FMT_RGB565BE    ||  \
-     (x) == AV_PIX_FMT_RGB565LE    ||  \
-     (x) == AV_PIX_FMT_RGB555BE    ||  \
-     (x) == AV_PIX_FMT_RGB555LE    ||  \
-     (x) == AV_PIX_FMT_RGB444BE    ||  \
-     (x) == AV_PIX_FMT_RGB444LE    ||  \
-     (x) == AV_PIX_FMT_RGB8        ||  \
-     (x) == AV_PIX_FMT_RGB4        ||  \
-     (x) == AV_PIX_FMT_RGB4_BYTE   ||  \
-     (x) == AV_PIX_FMT_RGBA64BE    ||  \
-     (x) == AV_PIX_FMT_RGBA64LE    ||  \
-     (x) == AV_PIX_FMT_MONOBLACK   ||  \
-     (x) == AV_PIX_FMT_MONOWHITE   \
-    )
-#define isBGRinInt(x) \
-    (           \
-     (x) == AV_PIX_FMT_BGR48BE     ||  \
-     (x) == AV_PIX_FMT_BGR48LE     ||  \
-     (x) == AV_PIX_FMT_BGR32       ||  \
-     (x) == AV_PIX_FMT_BGR32_1     ||  \
-     (x) == AV_PIX_FMT_BGR24       ||  \
-     (x) == AV_PIX_FMT_BGR565BE    ||  \
-     (x) == AV_PIX_FMT_BGR565LE    ||  \
-     (x) == AV_PIX_FMT_BGR555BE    ||  \
-     (x) == AV_PIX_FMT_BGR555LE    ||  \
-     (x) == AV_PIX_FMT_BGR444BE    ||  \
-     (x) == AV_PIX_FMT_BGR444LE    ||  \
-     (x) == AV_PIX_FMT_BGR8        ||  \
-     (x) == AV_PIX_FMT_BGR4        ||  \
-     (x) == AV_PIX_FMT_BGR4_BYTE   ||  \
-     (x) == AV_PIX_FMT_BGRA64BE    ||  \
-     (x) == AV_PIX_FMT_BGRA64LE    ||  \
-     (x) == AV_PIX_FMT_MONOBLACK   ||  \
-     (x) == AV_PIX_FMT_MONOWHITE   \
-    )
-
-#define isRGBinBytes(x) (           \
-           (x) == AV_PIX_FMT_RGB48BE     \
-        || (x) == AV_PIX_FMT_RGB48LE     \
-        || (x) == AV_PIX_FMT_RGBA64BE    \
-        || (x) == AV_PIX_FMT_RGBA64LE    \
-        || (x) == AV_PIX_FMT_RGBA        \
-        || (x) == AV_PIX_FMT_ARGB        \
-        || (x) == AV_PIX_FMT_RGB24       \
-    )
-#define isBGRinBytes(x) (           \
-           (x) == AV_PIX_FMT_BGR48BE     \
-        || (x) == AV_PIX_FMT_BGR48LE     \
-        || (x) == AV_PIX_FMT_BGRA64BE    \
-        || (x) == AV_PIX_FMT_BGRA64LE    \
-        || (x) == AV_PIX_FMT_BGRA        \
-        || (x) == AV_PIX_FMT_ABGR        \
-        || (x) == AV_PIX_FMT_BGR24       \
-    )
-
-#define isBayer(x) ( \
-           (x)==AV_PIX_FMT_BAYER_BGGR8    \
-        || (x)==AV_PIX_FMT_BAYER_BGGR16LE \
-        || (x)==AV_PIX_FMT_BAYER_BGGR16BE \
-        || (x)==AV_PIX_FMT_BAYER_RGGB8    \
-        || (x)==AV_PIX_FMT_BAYER_RGGB16LE \
-        || (x)==AV_PIX_FMT_BAYER_RGGB16BE \
-        || (x)==AV_PIX_FMT_BAYER_GBRG8    \
-        || (x)==AV_PIX_FMT_BAYER_GBRG16LE \
-        || (x)==AV_PIX_FMT_BAYER_GBRG16BE \
-        || (x)==AV_PIX_FMT_BAYER_GRBG8    \
-        || (x)==AV_PIX_FMT_BAYER_GRBG16LE \
-        || (x)==AV_PIX_FMT_BAYER_GRBG16BE \
-    )
-
-#define isAnyRGB(x) \
-    (           \
-          isBayer(x)          ||    \
-          isRGBinInt(x)       ||    \
-          isBGRinInt(x)       ||    \
-          isRGB(x)      \
-    )
+static av_always_inline int isRGBinInt(enum AVPixelFormat pix_fmt)
+{
+    return pix_fmt == AV_PIX_FMT_RGB48BE     ||
+           pix_fmt == AV_PIX_FMT_RGB48LE     ||
+           pix_fmt == AV_PIX_FMT_RGB32       ||
+           pix_fmt == AV_PIX_FMT_RGB32_1     ||
+           pix_fmt == AV_PIX_FMT_RGB24       ||
+           pix_fmt == AV_PIX_FMT_RGB565BE    ||
+           pix_fmt == AV_PIX_FMT_RGB565LE    ||
+           pix_fmt == AV_PIX_FMT_RGB555BE    ||
+           pix_fmt == AV_PIX_FMT_RGB555LE    ||
+           pix_fmt == AV_PIX_FMT_RGB444BE    ||
+           pix_fmt == AV_PIX_FMT_RGB444LE    ||
+           pix_fmt == AV_PIX_FMT_RGB8        ||
+           pix_fmt == AV_PIX_FMT_RGB4        ||
+           pix_fmt == AV_PIX_FMT_RGB4_BYTE   ||
+           pix_fmt == AV_PIX_FMT_RGBA64BE    ||
+           pix_fmt == AV_PIX_FMT_RGBA64LE    ||
+           pix_fmt == AV_PIX_FMT_MONOBLACK   ||
+           pix_fmt == AV_PIX_FMT_MONOWHITE;
+}
+
+static av_always_inline int isBGRinInt(enum AVPixelFormat pix_fmt)
+{
+    return pix_fmt == AV_PIX_FMT_BGR48BE     ||
+           pix_fmt == AV_PIX_FMT_BGR48LE     ||
+           pix_fmt == AV_PIX_FMT_BGR32       ||
+           pix_fmt == AV_PIX_FMT_BGR32_1     ||
+           pix_fmt == AV_PIX_FMT_BGR24       ||
+           pix_fmt == AV_PIX_FMT_BGR565BE    ||
+           pix_fmt == AV_PIX_FMT_BGR565LE    ||
+           pix_fmt == AV_PIX_FMT_BGR555BE    ||
+           pix_fmt == AV_PIX_FMT_BGR555LE    ||
+           pix_fmt == AV_PIX_FMT_BGR444BE    ||
+           pix_fmt == AV_PIX_FMT_BGR444LE    ||
+           pix_fmt == AV_PIX_FMT_BGR8        ||
+           pix_fmt == AV_PIX_FMT_BGR4        ||
+           pix_fmt == AV_PIX_FMT_BGR4_BYTE   ||
+           pix_fmt == AV_PIX_FMT_BGRA64BE    ||
+           pix_fmt == AV_PIX_FMT_BGRA64LE    ||
+           pix_fmt == AV_PIX_FMT_MONOBLACK   ||
+           pix_fmt == AV_PIX_FMT_MONOWHITE;
+}
+
+static av_always_inline int isBayer(enum AVPixelFormat pix_fmt)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+    av_assert0(desc);
+    return !!(desc->flags & AV_PIX_FMT_FLAG_BAYER);
+}
+
+static av_always_inline int isAnyRGB(enum AVPixelFormat pix_fmt)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
+    av_assert0(desc);
+    return (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
+            pix_fmt == AV_PIX_FMT_MONOBLACK || pix_fmt == AV_PIX_FMT_MONOWHITE;
+}
 
 static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
 {
@@ -797,30 +762,15 @@ static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
     return desc->flags & AV_PIX_FMT_FLAG_ALPHA;
 }
 
-#if 1
-#define isPacked(x)         (       \
-           (x)==AV_PIX_FMT_PAL8        \
-        || (x)==AV_PIX_FMT_YUYV422     \
-        || (x)==AV_PIX_FMT_YVYU422     \
-        || (x)==AV_PIX_FMT_UYVY422     \
-        || (x)==AV_PIX_FMT_YA8       \
-        || (x)==AV_PIX_FMT_YA16LE      \
-        || (x)==AV_PIX_FMT_YA16BE      \
-        || (x)==AV_PIX_FMT_AYUV64LE    \
-        || (x)==AV_PIX_FMT_AYUV64BE    \
-        ||  isRGBinInt(x)           \
-        ||  isBGRinInt(x)           \
-    )
-#else
 static av_always_inline int isPacked(enum AVPixelFormat pix_fmt)
 {
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     av_assert0(desc);
-    return ((desc->nb_components >= 2 && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) ||
-            pix_fmt == AV_PIX_FMT_PAL8);
+    return (desc->nb_components >= 2 && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR)) ||
+            pix_fmt == AV_PIX_FMT_PAL8 ||
+            pix_fmt == AV_PIX_FMT_MONOBLACK || pix_fmt == AV_PIX_FMT_MONOWHITE;
 }
 
-#endif
 static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
 {
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
diff --git a/mythtv/external/FFmpeg/libswscale/swscale_unscaled.c b/mythtv/external/FFmpeg/libswscale/swscale_unscaled.c
index e46763c8c16..ef36aec500b 100644
--- a/mythtv/external/FFmpeg/libswscale/swscale_unscaled.c
+++ b/mythtv/external/FFmpeg/libswscale/swscale_unscaled.c
@@ -1292,6 +1292,23 @@ static rgbConvFn findRgbConvFn(SwsContext *c)
               || CONV_IS(BGR48LE, RGB48BE)
               || CONV_IS(RGB48BE, BGR48LE)
               || CONV_IS(BGR48BE, RGB48LE)) conv = rgb48tobgr48_bswap;
+    } else if (isRGB48(srcFormat) && isRGBA64(dstFormat)) {
+        if      (CONV_IS(RGB48LE, BGRA64LE)
+              || CONV_IS(BGR48LE, RGBA64LE)
+              || CONV_IS(RGB48BE, BGRA64BE)
+              || CONV_IS(BGR48BE, RGBA64BE)) conv = rgb48tobgr64_nobswap;
+        else if (CONV_IS(RGB48LE, BGRA64BE)
+              || CONV_IS(BGR48LE, RGBA64BE)
+              || CONV_IS(RGB48BE, BGRA64LE)
+              || CONV_IS(BGR48BE, RGBA64LE)) conv = rgb48tobgr64_bswap;
+        if      (CONV_IS(RGB48LE, RGBA64LE)
+              || CONV_IS(BGR48LE, BGRA64LE)
+              || CONV_IS(RGB48BE, RGBA64BE)
+              || CONV_IS(BGR48BE, BGRA64BE)) conv = rgb48to64_nobswap;
+        else if (CONV_IS(RGB48LE, RGBA64BE)
+              || CONV_IS(BGR48LE, BGRA64BE)
+              || CONV_IS(RGB48BE, RGBA64LE)
+              || CONV_IS(BGR48BE, BGRA64LE)) conv = rgb48to64_bswap;
     } else if (isRGBA64(srcFormat) && isRGB48(dstFormat)) {
         if      (CONV_IS(RGBA64LE, BGR48LE)
               || CONV_IS(BGRA64LE, RGB48LE)
@@ -1796,6 +1813,9 @@ void ff_get_unscaled_swscale(SwsContext *c)
         IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR555) ||
         IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGR565) ||
         IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_BGRA64) ||
+        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY9)  ||
+        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY10) ||
+        IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY12) ||
         IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_GRAY16) ||
         IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_YA16)   ||
         IS_DIFFERENT_ENDIANESS(srcFormat, dstFormat, AV_PIX_FMT_AYUV64) ||
@@ -1876,8 +1896,10 @@ void ff_get_unscaled_swscale(SwsContext *c)
          c->chrDstVSubSample == c->chrSrcVSubSample &&
          dstFormat != AV_PIX_FMT_NV12 && dstFormat != AV_PIX_FMT_NV21 &&
          dstFormat != AV_PIX_FMT_P010LE && dstFormat != AV_PIX_FMT_P010BE &&
+         dstFormat != AV_PIX_FMT_P016LE && dstFormat != AV_PIX_FMT_P016BE &&
          srcFormat != AV_PIX_FMT_NV12 && srcFormat != AV_PIX_FMT_NV21 &&
-         srcFormat != AV_PIX_FMT_P010LE && srcFormat != AV_PIX_FMT_P010BE))
+         srcFormat != AV_PIX_FMT_P010LE && srcFormat != AV_PIX_FMT_P010BE &&
+         srcFormat != AV_PIX_FMT_P016LE && srcFormat != AV_PIX_FMT_P016BE))
     {
         if (isPacked(c->srcFormat))
             c->swscale = packedCopyWrapper;
diff --git a/mythtv/external/FFmpeg/libswscale/tests/.gitignore b/mythtv/external/FFmpeg/libswscale/tests/.gitignore
index 0ac3691ecdd..1a26f038c45 100644
--- a/mythtv/external/FFmpeg/libswscale/tests/.gitignore
+++ b/mythtv/external/FFmpeg/libswscale/tests/.gitignore
@@ -1,2 +1,3 @@
 /colorspace
+/pixdesc_query
 /swscale
diff --git a/mythtv/external/FFmpeg/libswscale/tests/pixdesc_query.c b/mythtv/external/FFmpeg/libswscale/tests/pixdesc_query.c
new file mode 100644
index 00000000000..a5585c43149
--- /dev/null
+++ b/mythtv/external/FFmpeg/libswscale/tests/pixdesc_query.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2017 Clément Bœsch <u pkh me>
+ *
+ * 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 <stdlib.h>
+
+#include "libavutil/mem.h"
+#include "libswscale/swscale_internal.h"
+
+static const struct {
+    const char *class;
+    int (*cond)(enum AVPixelFormat pix_fmt);
+} query_tab[] = {
+    {"is16BPS",     is16BPS},
+    {"isNBPS",      isNBPS},
+    {"isBE",        isBE},
+    {"isYUV",       isYUV},
+    {"isPlanarYUV", isPlanarYUV},
+    {"isRGB",       isRGB},
+    {"Gray",        isGray},
+    {"RGBinInt",    isRGBinInt},
+    {"BGRinInt",    isBGRinInt},
+    {"Bayer",       isBayer},
+    {"AnyRGB",      isAnyRGB},
+    {"ALPHA",       isALPHA},
+    {"Packed",      isPacked},
+    {"Planar",      isPlanar},
+    {"PackedRGB",   isPackedRGB},
+    {"PlanarRGB",   isPlanarRGB},
+    {"usePal",      usePal},
+};
+
+static int cmp_str(const void *a, const void *b)
+{
+    const char *s1 = *(const char **)a;
+    const char *s2 = *(const char **)b;
+    return strcmp(s1, s2);
+}
+
+int main(void)
+{
+    int i, j;
+
+    for (i = 0; i < FF_ARRAY_ELEMS(query_tab); i++) {
+        const char **pix_fmts = NULL;
+        int nb_pix_fmts = 0;
+        const AVPixFmtDescriptor *pix_desc = NULL;
+
+        while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
+            enum AVPixelFormat pix_fmt = av_pix_fmt_desc_get_id(pix_desc);
+            if (query_tab[i].cond(pix_fmt)) {
+                const char *pix_name = pix_desc->name;
+                if      (pix_fmt == AV_PIX_FMT_RGB32)   pix_name = "rgb32";
+                else if (pix_fmt == AV_PIX_FMT_RGB32_1) pix_name = "rgb32_1";
+                else if (pix_fmt == AV_PIX_FMT_BGR32)   pix_name = "bgr32";
+                else if (pix_fmt == AV_PIX_FMT_BGR32_1) pix_name = "bgr32_1";
+
+                av_dynarray_add(&pix_fmts, &nb_pix_fmts, (void *)pix_name);
+            }
+        }
+
+        if (pix_fmts) {
+            qsort(pix_fmts, nb_pix_fmts, sizeof(*pix_fmts), cmp_str);
+
+            printf("%s:\n", query_tab[i].class);
+            for (j = 0; j < nb_pix_fmts; j++)
+                printf("  %s\n", pix_fmts[j]);
+            printf("\n");
+
+            av_free(pix_fmts);
+        }
+    }
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/libswscale/tests/swscale.c b/mythtv/external/FFmpeg/libswscale/tests/swscale.c
index da6a41b779c..b4b8173a314 100644
--- a/mythtv/external/FFmpeg/libswscale/tests/swscale.c
+++ b/mythtv/external/FFmpeg/libswscale/tests/swscale.c
@@ -309,16 +309,16 @@ static int fileTest(uint8_t *ref[4], int refStride[4], int w, int h, FILE *fp,
         struct Results r;
         enum AVPixelFormat srcFormat;
         char srcStr[12];
-        int srcW, srcH;
+        int srcW = 0, srcH = 0;
         enum AVPixelFormat dstFormat;
         char dstStr[12];
-        int dstW, dstH;
+        int dstW = 0, dstH = 0;
         int flags;
         int ret;
 
         ret = sscanf(buf,
                      " %12s %dx%d -> %12s %dx%d flags=%d CRC=%x"
-                     " SSD=%"SCNd64 ", %"SCNd64 ", %"SCNd64 ", %"SCNd64 "\n",
+                     " SSD=%"SCNu64 ", %"SCNu64 ", %"SCNu64 ", %"SCNu64 "\n",
                      srcStr, &srcW, &srcH, dstStr, &dstW, &dstH,
                      &flags, &r.crc, &r.ssdY, &r.ssdU, &r.ssdV, &r.ssdA);
         if (ret != 12) {
diff --git a/mythtv/external/FFmpeg/libswscale/utils.c b/mythtv/external/FFmpeg/libswscale/utils.c
index 0aef672041a..dcab707de64 100644
--- a/mythtv/external/FFmpeg/libswscale/utils.c
+++ b/mythtv/external/FFmpeg/libswscale/utils.c
@@ -131,6 +131,12 @@ static const FormatEntry format_entries[AV_PIX_FMT_NB] = {
     [AV_PIX_FMT_RGB0]        = { 1, 1 },
     [AV_PIX_FMT_0BGR]        = { 1, 1 },
     [AV_PIX_FMT_BGR0]        = { 1, 1 },
+    [AV_PIX_FMT_GRAY9BE]     = { 1, 1 },
+    [AV_PIX_FMT_GRAY9LE]     = { 1, 1 },
+    [AV_PIX_FMT_GRAY10BE]    = { 1, 1 },
+    [AV_PIX_FMT_GRAY10LE]    = { 1, 1 },
+    [AV_PIX_FMT_GRAY12BE]    = { 1, 1 },
+    [AV_PIX_FMT_GRAY12LE]    = { 1, 1 },
     [AV_PIX_FMT_GRAY16BE]    = { 1, 1 },
     [AV_PIX_FMT_GRAY16LE]    = { 1, 1 },
     [AV_PIX_FMT_YUV440P]     = { 1, 1 },
@@ -218,19 +224,19 @@ static const FormatEntry format_entries[AV_PIX_FMT_NB] = {
     [AV_PIX_FMT_GBRP9BE]     = { 1, 1 },
     [AV_PIX_FMT_GBRP10LE]    = { 1, 1 },
     [AV_PIX_FMT_GBRP10BE]    = { 1, 1 },
-    [AV_PIX_FMT_GBRAP10LE]   = { 1, 0 },
-    [AV_PIX_FMT_GBRAP10BE]   = { 1, 0 },
+    [AV_PIX_FMT_GBRAP10LE]   = { 1, 1 },
+    [AV_PIX_FMT_GBRAP10BE]   = { 1, 1 },
     [AV_PIX_FMT_GBRP12LE]    = { 1, 1 },
     [AV_PIX_FMT_GBRP12BE]    = { 1, 1 },
-    [AV_PIX_FMT_GBRAP12LE]   = { 1, 0 },
-    [AV_PIX_FMT_GBRAP12BE]   = { 1, 0 },
+    [AV_PIX_FMT_GBRAP12LE]   = { 1, 1 },
+    [AV_PIX_FMT_GBRAP12BE]   = { 1, 1 },
     [AV_PIX_FMT_GBRP14LE]    = { 1, 1 },
     [AV_PIX_FMT_GBRP14BE]    = { 1, 1 },
-    [AV_PIX_FMT_GBRP16LE]    = { 1, 0 },
-    [AV_PIX_FMT_GBRP16BE]    = { 1, 0 },
+    [AV_PIX_FMT_GBRP16LE]    = { 1, 1 },
+    [AV_PIX_FMT_GBRP16BE]    = { 1, 1 },
     [AV_PIX_FMT_GBRAP]       = { 1, 1 },
-    [AV_PIX_FMT_GBRAP16LE]   = { 1, 0 },
-    [AV_PIX_FMT_GBRAP16BE]   = { 1, 0 },
+    [AV_PIX_FMT_GBRAP16LE]   = { 1, 1 },
+    [AV_PIX_FMT_GBRAP16BE]   = { 1, 1 },
     [AV_PIX_FMT_BAYER_BGGR8] = { 1, 0 },
     [AV_PIX_FMT_BAYER_RGGB8] = { 1, 0 },
     [AV_PIX_FMT_BAYER_GBRG8] = { 1, 0 },
@@ -248,6 +254,8 @@ static const FormatEntry format_entries[AV_PIX_FMT_NB] = {
     [AV_PIX_FMT_AYUV64LE]    = { 1, 1},
     [AV_PIX_FMT_P010LE]      = { 1, 1 },
     [AV_PIX_FMT_P010BE]      = { 1, 1 },
+    [AV_PIX_FMT_P016LE]      = { 1, 0 },
+    [AV_PIX_FMT_P016BE]      = { 1, 0 },
 };
 
 int sws_isSupportedInput(enum AVPixelFormat pix_fmt)
@@ -440,15 +448,7 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos,
                                       (8 * B + 24 * C) * (1 << 30);
                     }
                     coeff /= (1LL<<54)/fone;
-                }
-#if 0
-                else if (flags & SWS_X) {
-                    double p  = param ? param * 0.01 : 0.3;
-                    coeff     = d ? sin(d * M_PI) / (d * M_PI) : 1.0;
-                    coeff    *= pow(2.0, -p * d * d);
-                }
-#endif
-                else if (flags & SWS_X) {
+                } else if (flags & SWS_X) {
                     double A = param[0] != SWS_PARAM_DEFAULT ? param[0] : 1.0;
                     double c;
 
@@ -1018,6 +1018,12 @@ static int handle_jpeg(enum AVPixelFormat *format)
         return 1;
     case AV_PIX_FMT_GRAY8:
     case AV_PIX_FMT_YA8:
+    case AV_PIX_FMT_GRAY9LE:
+    case AV_PIX_FMT_GRAY9BE:
+    case AV_PIX_FMT_GRAY10LE:
+    case AV_PIX_FMT_GRAY10BE:
+    case AV_PIX_FMT_GRAY12LE:
+    case AV_PIX_FMT_GRAY12BE:
     case AV_PIX_FMT_GRAY16LE:
     case AV_PIX_FMT_GRAY16BE:
     case AV_PIX_FMT_YA16BE:
@@ -1568,7 +1574,11 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
         }
     }
 
-#define USE_MMAP (HAVE_MMAP && HAVE_MPROTECT && defined MAP_ANONYMOUS)
+#if HAVE_MMAP && HAVE_MPROTECT && defined(MAP_ANONYMOUS)
+#define USE_MMAP 1
+#else
+#define USE_MMAP 0
+#endif
 
     /* precalculate horizontal scaler filter coefficients */
     {
diff --git a/mythtv/external/FFmpeg/libswscale/version.h b/mythtv/external/FFmpeg/libswscale/version.h
index ee536723cb5..474e93b2615 100644
--- a/mythtv/external/FFmpeg/libswscale/version.h
+++ b/mythtv/external/FFmpeg/libswscale/version.h
@@ -27,7 +27,7 @@
 #include "libavutil/version.h"
 
 #define LIBSWSCALE_VERSION_MAJOR   4
-#define LIBSWSCALE_VERSION_MINOR   2
+#define LIBSWSCALE_VERSION_MINOR   8
 #define LIBSWSCALE_VERSION_MICRO 100
 
 #define LIBSWSCALE_VERSION_INT  AV_VERSION_INT(LIBSWSCALE_VERSION_MAJOR, \
diff --git a/mythtv/external/FFmpeg/libswscale/x86/Makefile b/mythtv/external/FFmpeg/libswscale/x86/Makefile
index 69012077bbd..b50c7f265a6 100644
--- a/mythtv/external/FFmpeg/libswscale/x86/Makefile
+++ b/mythtv/external/FFmpeg/libswscale/x86/Makefile
@@ -8,6 +8,6 @@ MMX-OBJS                        += x86/hscale_fast_bilinear_simd.o      \
 
 OBJS-$(CONFIG_XMM_CLOBBER_TEST) += x86/w64xmmtest.o
 
-YASM-OBJS                       += x86/input.o                          \
+X86ASM-OBJS                     += x86/input.o                          \
                                    x86/output.o                         \
                                    x86/scale.o                          \
diff --git a/mythtv/external/FFmpeg/libswscale/x86/hscale_fast_bilinear_simd.c b/mythtv/external/FFmpeg/libswscale/x86/hscale_fast_bilinear_simd.c
index 2cba5f0a1c9..60a2cbfc509 100644
--- a/mythtv/external/FFmpeg/libswscale/x86/hscale_fast_bilinear_simd.c
+++ b/mythtv/external/FFmpeg/libswscale/x86/hscale_fast_bilinear_simd.c
@@ -199,7 +199,7 @@ void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst,
 #if ARCH_X86_64
     uint64_t retsave;
 #else
-#if defined(PIC)
+#if !HAVE_EBX_AVAILABLE
     uint64_t ebxsave;
 #endif
 #endif
@@ -209,7 +209,7 @@ void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst,
         "mov               -8(%%rsp), %%"FF_REG_a"    \n\t"
         "mov            %%"FF_REG_a", %5              \n\t"  // retsave
 #else
-#if defined(PIC)
+#if !HAVE_EBX_AVAILABLE
         "mov            %%"FF_REG_b", %5              \n\t"  // ebxsave
 #endif
 #endif
@@ -255,7 +255,7 @@ void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst,
         "mov                      %5, %%"FF_REG_a" \n\t"
         "mov            %%"FF_REG_a", -8(%%rsp)    \n\t"
 #else
-#if defined(PIC)
+#if !HAVE_EBX_AVAILABLE
         "mov                      %5, %%"FF_REG_b" \n\t"
 #endif
 #endif
@@ -264,12 +264,12 @@ void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst,
 #if ARCH_X86_64
           ,"m"(retsave)
 #else
-#if defined(PIC)
+#if !HAVE_EBX_AVAILABLE
           ,"m" (ebxsave)
 #endif
 #endif
         : "%"FF_REG_a, "%"FF_REG_c, "%"FF_REG_d, "%"FF_REG_S, "%"FF_REG_D
-#if ARCH_X86_64 || !defined(PIC)
+#if ARCH_X86_64 || HAVE_EBX_AVAILABLE
          ,"%"FF_REG_b
 #endif
     );
@@ -289,7 +289,7 @@ void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2,
 #if ARCH_X86_64
     DECLARE_ALIGNED(8, uint64_t, retsave);
 #else
-#if defined(PIC)
+#if !HAVE_EBX_AVAILABLE
     DECLARE_ALIGNED(8, uint64_t, ebxsave);
 #endif
 #endif
@@ -298,7 +298,7 @@ void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2,
         "mov          -8(%%rsp), %%"FF_REG_a"    \n\t"
         "mov       %%"FF_REG_a", %7              \n\t"  // retsave
 #else
-#if defined(PIC)
+#if !HAVE_EBX_AVAILABLE
         "mov       %%"FF_REG_b", %7              \n\t"  // ebxsave
 #endif
 #endif
@@ -332,7 +332,7 @@ void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2,
         "mov                    %7, %%"FF_REG_a" \n\t"
         "mov          %%"FF_REG_a", -8(%%rsp)    \n\t"
 #else
-#if defined(PIC)
+#if !HAVE_EBX_AVAILABLE
         "mov %7, %%"FF_REG_b"    \n\t"
 #endif
 #endif
@@ -341,12 +341,12 @@ void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2,
 #if ARCH_X86_64
           ,"m"(retsave)
 #else
-#if defined(PIC)
+#if !HAVE_EBX_AVAILABLE
           ,"m" (ebxsave)
 #endif
 #endif
         : "%"FF_REG_a, "%"FF_REG_c, "%"FF_REG_d, "%"FF_REG_S, "%"FF_REG_D
-#if ARCH_X86_64 || !defined(PIC)
+#if ARCH_X86_64 || HAVE_EBX_AVAILABLE
          ,"%"FF_REG_b
 #endif
     );
diff --git a/mythtv/external/FFmpeg/libswscale/x86/rgb2rgb_template.c b/mythtv/external/FFmpeg/libswscale/x86/rgb2rgb_template.c
index c655ae1ac9d..d59bd5679e1 100644
--- a/mythtv/external/FFmpeg/libswscale/x86/rgb2rgb_template.c
+++ b/mythtv/external/FFmpeg/libswscale/x86/rgb2rgb_template.c
@@ -1961,7 +1961,7 @@ static void RENAME(interleaveBytes)(const uint8_t *src1, const uint8_t *src2, ui
 #endif /* !COMPILE_TEMPLATE_AMD3DNOW && !COMPILE_TEMPLATE_AVX */
 
 #if !COMPILE_TEMPLATE_AVX || HAVE_AVX_EXTERNAL
-#if !COMPILE_TEMPLATE_AMD3DNOW && (ARCH_X86_32 || COMPILE_TEMPLATE_SSE2) && COMPILE_TEMPLATE_MMXEXT == COMPILE_TEMPLATE_SSE2 && HAVE_YASM
+#if !COMPILE_TEMPLATE_AMD3DNOW && (ARCH_X86_32 || COMPILE_TEMPLATE_SSE2) && COMPILE_TEMPLATE_MMXEXT == COMPILE_TEMPLATE_SSE2 && HAVE_X86ASM
 void RENAME(ff_nv12ToUV)(uint8_t *dstU, uint8_t *dstV,
                          const uint8_t *unused,
                          const uint8_t *src1,
@@ -2601,7 +2601,7 @@ static av_cold void RENAME(rgb2rgb_init)(void)
     interleaveBytes    = RENAME(interleaveBytes);
 #endif /* !COMPILE_TEMPLATE_AMD3DNOW && !COMPILE_TEMPLATE_AVX */
 #if !COMPILE_TEMPLATE_AVX || HAVE_AVX_EXTERNAL
-#if !COMPILE_TEMPLATE_AMD3DNOW && (ARCH_X86_32 || COMPILE_TEMPLATE_SSE2) && COMPILE_TEMPLATE_MMXEXT == COMPILE_TEMPLATE_SSE2 && HAVE_YASM
+#if !COMPILE_TEMPLATE_AMD3DNOW && (ARCH_X86_32 || COMPILE_TEMPLATE_SSE2) && COMPILE_TEMPLATE_MMXEXT == COMPILE_TEMPLATE_SSE2 && HAVE_X86ASM
     deinterleaveBytes  = RENAME(deinterleaveBytes);
 #endif
 #endif
diff --git a/mythtv/external/FFmpeg/libswscale/x86/swscale_template.c b/mythtv/external/FFmpeg/libswscale/x86/swscale_template.c
index 1a102271c19..b8bdcd4d036 100644
--- a/mythtv/external/FFmpeg/libswscale/x86/swscale_template.c
+++ b/mythtv/external/FFmpeg/libswscale/x86/swscale_template.c
@@ -1499,7 +1499,7 @@ static av_cold void RENAME(sws_init_swscale)(SwsContext *c)
     enum AVPixelFormat dstFormat = c->dstFormat;
 
     c->use_mmx_vfilter= 0;
-    if (!is16BPS(dstFormat) && !is9_OR_10BPS(dstFormat) && dstFormat != AV_PIX_FMT_NV12
+    if (!is16BPS(dstFormat) && !isNBPS(dstFormat) && dstFormat != AV_PIX_FMT_NV12
         && dstFormat != AV_PIX_FMT_NV21 && !(c->flags & SWS_BITEXACT)) {
             if (c->flags & SWS_ACCURATE_RND) {
                 if (!(c->flags & SWS_FULL_CHR_H_INT)) {
diff --git a/mythtv/external/FFmpeg/tests/Makefile b/mythtv/external/FFmpeg/tests/Makefile
index 8e810ff1951..278be24ccbc 100644
--- a/mythtv/external/FFmpeg/tests/Makefile
+++ b/mythtv/external/FFmpeg/tests/Makefile
@@ -12,12 +12,12 @@ FFMPEG=ffmpeg$(PROGSSUF)$(EXESUF)
 $(AREF): CMP=
 
 ffservertest: export PROGSUF = $(PROGSSUF)
-ffservertest: ffserver$(PROGSSUF)$(EXESUF) tests/vsynth1/00.pgm tests/data/asynth1.sw
+ffservertest: ffserver$(PROGSSUF)$(EXESUF) ffmpeg$(PROGSSUF)$(EXESUF) tests/vsynth1/00.pgm tests/data/asynth1.sw
 	@echo
 	@echo "Unfortunately ffserver is broken and therefore its regression"
 	@echo "test fails randomly. Treat the results accordingly."
 	@echo
-	$(SRC_PATH)/tests/ffserver-regression.sh $(FFSERVER_REFFILE) $(SRC_PATH)/tests/ffserver.conf
+	$(SRC_PATH)/tests/ffserver-regression.sh $(FFSERVER_REFFILE) $(SRC_PATH)/tests/ffserver.conf "$(TARGET_SAMPLES)" "$(TARGET_EXEC)" "$(TARGET_PATH)"
 
 APITESTSDIR := tests/api
 OBJDIRS += tests/data tests/vsynth1 tests/data/filtergraphs $(APITESTSDIR)/
@@ -131,7 +131,9 @@ include $(SRC_PATH)/tests/fate/fft.mak
 include $(SRC_PATH)/tests/fate/fifo-muxer.mak
 include $(SRC_PATH)/tests/fate/filter-audio.mak
 include $(SRC_PATH)/tests/fate/filter-video.mak
+include $(SRC_PATH)/tests/fate/fits.mak
 include $(SRC_PATH)/tests/fate/flac.mak
+include $(SRC_PATH)/tests/fate/flvenc.mak
 include $(SRC_PATH)/tests/fate/gapless.mak
 include $(SRC_PATH)/tests/fate/gif.mak
 include $(SRC_PATH)/tests/fate/h264.mak
@@ -144,6 +146,7 @@ include $(SRC_PATH)/tests/fate/libavformat.mak
 include $(SRC_PATH)/tests/fate/libavresample.mak
 include $(SRC_PATH)/tests/fate/libavutil.mak
 include $(SRC_PATH)/tests/fate/libswresample.mak
+include $(SRC_PATH)/tests/fate/libswscale.mak
 include $(SRC_PATH)/tests/fate/lossless-audio.mak
 include $(SRC_PATH)/tests/fate/lossless-video.mak
 include $(SRC_PATH)/tests/fate/matroska.mak
@@ -153,9 +156,11 @@ include $(SRC_PATH)/tests/fate/mov.mak
 include $(SRC_PATH)/tests/fate/mp3.mak
 include $(SRC_PATH)/tests/fate/mpc.mak
 include $(SRC_PATH)/tests/fate/mpeg4.mak
+include $(SRC_PATH)/tests/fate/mpegts.mak
 include $(SRC_PATH)/tests/fate/mxf.mak
 include $(SRC_PATH)/tests/fate/opus.mak
 include $(SRC_PATH)/tests/fate/pcm.mak
+include $(SRC_PATH)/tests/fate/pixlet.mak
 include $(SRC_PATH)/tests/fate/probe.mak
 include $(SRC_PATH)/tests/fate/prores.mak
 include $(SRC_PATH)/tests/fate/qt.mak
@@ -163,6 +168,7 @@ include $(SRC_PATH)/tests/fate/qtrle.mak
 include $(SRC_PATH)/tests/fate/real.mak
 include $(SRC_PATH)/tests/fate/screen.mak
 include $(SRC_PATH)/tests/fate/source.mak
+include $(SRC_PATH)/tests/fate/speedhq.mak
 include $(SRC_PATH)/tests/fate/subtitles.mak
 include $(SRC_PATH)/tests/fate/utvideo.mak
 include $(SRC_PATH)/tests/fate/video.mak
@@ -210,12 +216,14 @@ FATE_UTILS = base64 tiny_psnr tiny_ssim audiomatch
 
 TOOL = ffmpeg
 
+$(addprefix fate-, $(IGNORE_TESTS)): REPORT=ignore
+
 fate:: $(FATE)
 
 $(FATE) $(FATE_TESTS-no): export PROGSUF = $(PROGSSUF)
 $(FATE) $(FATE_TESTS-no): $(FATE_UTILS:%=tests/%$(HOSTEXESUF))
 	@echo "TEST    $(@:fate-%=%)"
-	$(Q)$(SRC_PATH)/tests/fate-run.sh $@ "$(TARGET_SAMPLES)" "$(TARGET_EXEC)" "$(TARGET_PATH)" '$(CMD)' '$(CMP)' '$(REF)' '$(FUZZ)' '$(THREADS)' '$(THREAD_TYPE)' '$(CPUFLAGS)' '$(CMP_SHIFT)' '$(CMP_TARGET)' '$(SIZE_TOLERANCE)' '$(CMP_UNIT)' '$(GEN)' '$(HWACCEL)'
+	$(Q)$(SRC_PATH)/tests/fate-run.sh $@ "$(TARGET_SAMPLES)" "$(TARGET_EXEC)" "$(TARGET_PATH)" '$(CMD)' '$(CMP)' '$(REF)' '$(FUZZ)' '$(THREADS)' '$(THREAD_TYPE)' '$(CPUFLAGS)' '$(CMP_SHIFT)' '$(CMP_TARGET)' '$(SIZE_TOLERANCE)' '$(CMP_UNIT)' '$(GEN)' '$(HWACCEL)' '$(REPORT)'
 
 fate-list:
 	@printf '%s\n' $(sort $(FATE))
diff --git a/mythtv/external/FFmpeg/tests/api/Makefile b/mythtv/external/FFmpeg/tests/api/Makefile
index ec0e125c01a..759dd9d243a 100644
--- a/mythtv/external/FFmpeg/tests/api/Makefile
+++ b/mythtv/external/FFmpeg/tests/api/Makefile
@@ -14,7 +14,7 @@ $(APITESTOBJS): | $(sort $(dir $(APITESTOBJS)))
 $(APITESTOBJS) $(APITESTOBJS:.o=.i): CPPFLAGS += -DTEST
 $(APITESTOBJS) $(APITESTOBJS:.o=.i): CFLAGS += -Umain
 
-$(APITESTPROGS): %$(EXESUF): %.o $(EXEOBJS) $(FF_DEP_LIBS)
+$(APITESTPROGS): %$(EXESUF): %.o $(FF_DEP_LIBS)
 	$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $(filter %.o,$^) $(FF_EXTRALIBS) $(ELIBS)
 
 testclean::
diff --git a/mythtv/external/FFmpeg/tests/api/api-flac-test.c b/mythtv/external/FFmpeg/tests/api/api-flac-test.c
index 7b480594b7d..c5a37f03e11 100644
--- a/mythtv/external/FFmpeg/tests/api/api-flac-test.c
+++ b/mythtv/external/FFmpeg/tests/api/api-flac-test.c
@@ -156,7 +156,7 @@ static int run_test(AVCodec *enc, AVCodec *dec, AVCodecContext *enc_ctx,
 
         generate_raw_frame((uint16_t*)(in_frame->data[0]), i, enc_ctx->sample_rate,
                            enc_ctx->channels, enc_ctx->frame_size);
-        in_frame_bytes = in_frame->nb_samples * av_frame_get_channels(in_frame) * sizeof(uint16_t);
+        in_frame_bytes = in_frame->nb_samples * in_frame->channels * sizeof(uint16_t);
         if (in_frame_bytes > in_frame->linesize[0]) {
             av_log(NULL, AV_LOG_ERROR, "Incorrect value of input frame linesize\n");
             return 1;
@@ -197,7 +197,7 @@ static int run_test(AVCodec *enc, AVCodec *dec, AVCodecContext *enc_ctx,
                     av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different sample format\n");
                     return AVERROR_UNKNOWN;
                 }
-                out_frame_bytes = out_frame->nb_samples * av_frame_get_channels(out_frame) * sizeof(uint16_t);
+                out_frame_bytes = out_frame->nb_samples * out_frame->channels * sizeof(uint16_t);
                 if (out_frame_bytes > out_frame->linesize[0]) {
                     av_log(NULL, AV_LOG_ERROR, "Incorrect value of output frame linesize\n");
                     return 1;
diff --git a/mythtv/external/FFmpeg/tests/api/api-h264-test.c b/mythtv/external/FFmpeg/tests/api/api-h264-test.c
index 7bdf92bb89c..52282e00074 100644
--- a/mythtv/external/FFmpeg/tests/api/api-h264-test.c
+++ b/mythtv/external/FFmpeg/tests/api/api-h264-test.c
@@ -132,7 +132,7 @@ static int video_decode_example(const char *input_filename)
                     return number_of_written_bytes;
                 }
                 printf("%d, %10"PRId64", %10"PRId64", %8"PRId64", %8d, 0x%08lx\n", video_stream,
-                        fr->pts, fr->pkt_dts, av_frame_get_pkt_duration(fr),
+                        fr->pts, fr->pkt_dts, fr->pkt_duration,
                         number_of_written_bytes, av_adler32_update(0, (const uint8_t*)byte_buffer, number_of_written_bytes));
             }
             av_packet_unref(&pkt);
diff --git a/mythtv/external/FFmpeg/tests/api/api-seek-test.c b/mythtv/external/FFmpeg/tests/api/api-seek-test.c
index 8117df46fdb..2b32cb9e4f3 100644
--- a/mythtv/external/FFmpeg/tests/api/api-seek-test.c
+++ b/mythtv/external/FFmpeg/tests/api/api-seek-test.c
@@ -30,18 +30,18 @@
 #include "libavutil/imgutils.h"
 
 int64_t *pts_array;
-int64_t *crc_array;
+uint32_t *crc_array;
 int size_of_array;
 int number_of_elements;
 
-static int add_crc_to_array(int64_t crc, int64_t pts)
+static int add_crc_to_array(uint32_t crc, int64_t pts)
 {
     if (size_of_array <= number_of_elements) {
         if (size_of_array == 0)
             size_of_array = 10;
         size_of_array *= 2;
-        crc_array = av_realloc(crc_array, size_of_array * sizeof(int64_t));
-        pts_array = av_realloc(pts_array, size_of_array * sizeof(int64_t));
+        crc_array = av_realloc_f(crc_array, size_of_array, sizeof(uint32_t));
+        pts_array = av_realloc_f(pts_array, size_of_array, sizeof(int64_t));
         if ((crc_array == NULL) || (pts_array == NULL)) {
             av_log(NULL, AV_LOG_ERROR, "Can't allocate array to store crcs\n");
             return AVERROR(ENOMEM);
@@ -53,13 +53,13 @@ static int add_crc_to_array(int64_t crc, int64_t pts)
     return 0;
 }
 
-static int compare_crc_in_array(int64_t crc, int64_t pts)
+static int compare_crc_in_array(uint32_t crc, int64_t pts)
 {
     int i;
     for (i = 0; i < number_of_elements; i++) {
         if (pts_array[i] == pts) {
             if (crc_array[i] == crc) {
-                printf("Comparing 0x%08lx %"PRId64" %d is OK\n", crc, pts, i);
+                printf("Comparing 0x%08"PRIx32" %"PRId64" %d is OK\n", crc, pts, i);
                 return 0;
             }
             else {
@@ -81,7 +81,7 @@ static int compute_crc_of_packets(AVFormatContext *fmt_ctx, int video_stream,
     int end_of_stream = 0;
     int byte_buffer_size;
     uint8_t *byte_buffer;
-    int64_t crc;
+    uint32_t crc;
     AVPacket pkt;
 
     byte_buffer_size = av_image_get_buffer_size(ctx->pix_fmt, ctx->width, ctx->height, 16);
@@ -129,10 +129,10 @@ static int compute_crc_of_packets(AVFormatContext *fmt_ctx, int video_stream,
                     av_log(NULL, AV_LOG_ERROR, "Can't copy image to buffer\n");
                     return number_of_written_bytes;
                 }
-                if ((fr->pts > ts_end) && (!no_seeking))
+                if ((!no_seeking) && (fr->pts > ts_end))
                     break;
                 crc = av_adler32_update(0, (const uint8_t*)byte_buffer, number_of_written_bytes);
-                printf("%10"PRId64", 0x%08lx\n", fr->pts, crc);
+                printf("%10"PRId64", 0x%08"PRIx32"\n", fr->pts, crc);
                 if (no_seeking) {
                     if (add_crc_to_array(crc, fr->pts) < 0)
                         return -1;
@@ -145,7 +145,7 @@ static int compute_crc_of_packets(AVFormatContext *fmt_ctx, int video_stream,
         }
         av_packet_unref(&pkt);
         av_init_packet(&pkt);
-    } while ((!end_of_stream || got_frame) && (no_seeking || (fr->pts + av_frame_get_pkt_duration(fr) <= ts_end)));
+    } while ((!end_of_stream || got_frame) && (no_seeking || (fr->pts + fr->pkt_duration <= ts_end)));
 
     av_packet_unref(&pkt);
     av_freep(&byte_buffer);
@@ -185,7 +185,8 @@ static int seek_test(const char *input_filename, const char *start, const char *
 
     size_of_array = 0;
     number_of_elements = 0;
-    crc_array = pts_array = NULL;
+    crc_array = NULL;
+    pts_array = NULL;
 
     result = avformat_open_input(&fmt_ctx, input_filename, NULL, NULL);
     if (result < 0) {
@@ -196,19 +197,22 @@ static int seek_test(const char *input_filename, const char *start, const char *
     result = avformat_find_stream_info(fmt_ctx, NULL);
     if (result < 0) {
         av_log(NULL, AV_LOG_ERROR, "Can't get stream info\n");
-        return result;
+        goto end;
     }
 
     start_ts = read_seek_range(start);
     end_ts = read_seek_range(end);
-    if ((start_ts < 0) || (end_ts < 0))
-        return -1;
+    if ((start_ts < 0) || (end_ts < 0)) {
+        result = -1;
+        goto end;
+    }
 
     //TODO: add ability to work with audio format
     video_stream = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
     if (video_stream < 0) {
       av_log(NULL, AV_LOG_ERROR, "Can't find video stream in input file\n");
-      return -1;
+      result = video_stream;
+      goto end;
     }
 
     origin_par = fmt_ctx->streams[video_stream]->codecpar;
@@ -216,51 +220,56 @@ static int seek_test(const char *input_filename, const char *start, const char *
     codec = avcodec_find_decoder(origin_par->codec_id);
     if (!codec) {
         av_log(NULL, AV_LOG_ERROR, "Can't find decoder\n");
-        return -1;
+        result = AVERROR_DECODER_NOT_FOUND;
+        goto end;
     }
 
     ctx = avcodec_alloc_context3(codec);
     if (!ctx) {
         av_log(NULL, AV_LOG_ERROR, "Can't allocate decoder context\n");
-        return AVERROR(ENOMEM);
+        result = AVERROR(ENOMEM);
+        goto end;
     }
 
     result = avcodec_parameters_to_context(ctx, origin_par);
     if (result) {
         av_log(NULL, AV_LOG_ERROR, "Can't copy decoder context\n");
-        return result;
+        goto end;
     }
 
     result = avcodec_open2(ctx, codec, NULL);
     if (result < 0) {
         av_log(ctx, AV_LOG_ERROR, "Can't open decoder\n");
-        return result;
+        goto end;
     }
 
     fr = av_frame_alloc();
     if (!fr) {
         av_log(NULL, AV_LOG_ERROR, "Can't allocate frame\n");
-        return AVERROR(ENOMEM);
+        result = AVERROR(ENOMEM);
+        goto end;
     }
 
-    result = compute_crc_of_packets(fmt_ctx, video_stream, ctx, fr, i, j, 1);
+    result = compute_crc_of_packets(fmt_ctx, video_stream, ctx, fr, 0, 0, 1);
     if (result != 0)
-        return -1;
+        goto end;
 
     for (i = start_ts; i < end_ts; i += 100) {
-        for (j = i + 100; j < end_ts; j += 100)
-        result = compute_crc_of_packets(fmt_ctx, video_stream, ctx, fr, i, j, 0);
-        if (result != 0)
-            return -1;
+        for (j = i + 100; j < end_ts; j += 100) {
+            result = compute_crc_of_packets(fmt_ctx, video_stream, ctx, fr, i, j, 0);
+            if (result != 0)
+                break;
+        }
     }
 
+end:
     av_freep(&crc_array);
     av_freep(&pts_array);
     av_frame_free(&fr);
     avcodec_close(ctx);
     avformat_close_input(&fmt_ctx);
     avcodec_free_context(&ctx);
-    return 0;
+    return result;
 }
 
 int main(int argc, char **argv)
diff --git a/mythtv/external/FFmpeg/tests/api/api-threadmessage-test.c b/mythtv/external/FFmpeg/tests/api/api-threadmessage-test.c
index 3e0ac5cf191..05a8062b8c1 100644
--- a/mythtv/external/FFmpeg/tests/api/api-threadmessage-test.c
+++ b/mythtv/external/FFmpeg/tests/api/api-threadmessage-test.c
@@ -95,7 +95,7 @@ static void *sender_thread(void *arg)
                 av_frame_free(&msg.frame);
                 break;
             }
-            av_frame_set_metadata(msg.frame, meta);
+            msg.frame->metadata = meta;
 
             /* allocate a real frame in order to simulate "real" work */
             msg.frame->format = AV_PIX_FMT_RGBA;
@@ -141,7 +141,7 @@ static void *receiver_thread(void *arg)
             if (ret < 0)
                 break;
             av_assert0(msg.magic == MAGIC);
-            meta = av_frame_get_metadata(msg.frame);
+            meta = msg.frame->metadata;
             e = av_dict_get(meta, "sig", NULL, 0);
             av_log(NULL, AV_LOG_INFO, "got \"%s\" (%p)\n", e->value, msg.frame);
             av_frame_free(&msg.frame);
diff --git a/mythtv/external/FFmpeg/tests/checkasm/Makefile b/mythtv/external/FFmpeg/tests/checkasm/Makefile
index b886cb0c45e..14916e5100c 100644
--- a/mythtv/external/FFmpeg/tests/checkasm/Makefile
+++ b/mythtv/external/FFmpeg/tests/checkasm/Makefile
@@ -1,18 +1,27 @@
 # libavcodec tests
 # subsystems
+AVCODECOBJS-$(CONFIG_AUDIODSP)          += audiodsp.o
+AVCODECOBJS-$(CONFIG_BLOCKDSP)          += blockdsp.o
 AVCODECOBJS-$(CONFIG_BSWAPDSP)          += bswapdsp.o
 AVCODECOBJS-$(CONFIG_FLACDSP)           += flacdsp.o
 AVCODECOBJS-$(CONFIG_FMTCONVERT)        += fmtconvert.o
+AVCODECOBJS-$(CONFIG_G722DSP)           += g722dsp.o
 AVCODECOBJS-$(CONFIG_H264DSP)           += h264dsp.o
 AVCODECOBJS-$(CONFIG_H264PRED)          += h264pred.o
 AVCODECOBJS-$(CONFIG_H264QPEL)          += h264qpel.o
+AVCODECOBJS-$(CONFIG_LLVIDDSP)          += llviddsp.o
+AVCODECOBJS-$(CONFIG_VP8DSP)            += vp8dsp.o
 AVCODECOBJS-$(CONFIG_VIDEODSP)          += videodsp.o
 
 # decoders/encoders
+AVCODECOBJS-$(CONFIG_AAC_DECODER)       += aacpsdsp.o \
+                                           sbrdsp.o
 AVCODECOBJS-$(CONFIG_ALAC_DECODER)      += alacdsp.o
 AVCODECOBJS-$(CONFIG_DCA_DECODER)       += synth_filter.o
+AVCODECOBJS-$(CONFIG_EXR_DECODER)       += exrdsp.o
 AVCODECOBJS-$(CONFIG_JPEG2000_DECODER)  += jpeg2000dsp.o
 AVCODECOBJS-$(CONFIG_PIXBLOCKDSP)       += pixblockdsp.o
+AVCODECOBJS-$(CONFIG_HEVC_DECODER)      += hevc_add_res.o hevc_idct.o
 AVCODECOBJS-$(CONFIG_V210_ENCODER)      += v210enc.o
 AVCODECOBJS-$(CONFIG_VP9_DECODER)       += vp9dsp.o
 
@@ -24,8 +33,14 @@ AVFILTEROBJS-$(CONFIG_COLORSPACE_FILTER) += vf_colorspace.o
 
 CHECKASMOBJS-$(CONFIG_AVFILTER) += $(AVFILTEROBJS-yes)
 
+AVUTILOBJS                              += fixed_dsp.o
+AVUTILOBJS                              += float_dsp.o
 
--include $(SRC_PATH)/tests/checkasm/$(ARCH)/Makefile
+CHECKASMOBJS-$(CONFIG_AVUTIL)  += $(AVUTILOBJS)
+
+CHECKASMOBJS-$(ARCH_AARCH64)            += aarch64/checkasm.o
+CHECKASMOBJS-$(HAVE_ARMV5TE_EXTERNAL)   += arm/checkasm.o
+CHECKASMOBJS-$(HAVE_X86ASM)             += x86/checkasm.o
 
 CHECKASMOBJS += $(CHECKASMOBJS-yes) checkasm.o
 CHECKASMOBJS := $(sort $(CHECKASMOBJS:%=tests/checkasm/%))
@@ -40,7 +55,7 @@ tests/checkasm/checkasm.o: CFLAGS += -Umain
 
 CHECKASM := tests/checkasm/checkasm$(EXESUF)
 
-$(CHECKASM): $(EXEOBJS) $(CHECKASMOBJS) $(FF_STATIC_DEP_LIBS)
+$(CHECKASM): $(CHECKASMOBJS) $(FF_STATIC_DEP_LIBS)
 	$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $(CHECKASMOBJS) $(FF_STATIC_DEP_LIBS) $(EXTRALIBS)
 
 checkasm: $(CHECKASM)
diff --git a/mythtv/external/FFmpeg/tests/checkasm/aacpsdsp.c b/mythtv/external/FFmpeg/tests/checkasm/aacpsdsp.c
new file mode 100644
index 00000000000..ea68b39fa97
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/aacpsdsp.c
@@ -0,0 +1,243 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 "libavcodec/aacpsdsp.h"
+
+#include "checkasm.h"
+
+#define N 32
+#define STRIDE 128
+#define BUF_SIZE (N * STRIDE)
+
+#define randomize(buf, len) do {                                \
+    int i;                                                      \
+    for (i = 0; i < len; i++) {                                 \
+        const INTFLOAT f = (INTFLOAT)rnd() / UINT_MAX;          \
+        (buf)[i] = f;                                           \
+    }                                                           \
+} while (0)
+
+#define EPS 0.005
+
+static void test_add_squares(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE]);
+    LOCAL_ALIGNED_16(INTFLOAT, src, [BUF_SIZE], [2]);
+
+    declare_func(void, INTFLOAT *dst,
+                 const INTFLOAT (*src)[2], int n);
+
+    randomize((INTFLOAT *)src, BUF_SIZE * 2);
+    randomize(dst0, BUF_SIZE);
+    memcpy(dst1, dst0, BUF_SIZE * sizeof(INTFLOAT));
+    call_ref(dst0, src, BUF_SIZE);
+    call_new(dst1, src, BUF_SIZE);
+    if (!float_near_abs_eps_array(dst0, dst1, EPS, BUF_SIZE))
+        fail();
+    bench_new(dst1, src, BUF_SIZE);
+}
+
+static void test_mul_pair_single(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, src0, [BUF_SIZE], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, src1, [BUF_SIZE]);
+
+    declare_func(void, INTFLOAT (*dst)[2],
+                       INTFLOAT (*src0)[2], INTFLOAT *src1, int n);
+
+    randomize((INTFLOAT *)src0, BUF_SIZE * 2);
+    randomize(src1, BUF_SIZE);
+    call_ref(dst0, src0, src1, BUF_SIZE);
+    call_new(dst1, src0, src1, BUF_SIZE);
+    if (!float_near_abs_eps_array((float *)dst0, (float *)dst1, EPS, BUF_SIZE * 2))
+        fail();
+    bench_new(dst1, src0, src1, BUF_SIZE);
+}
+
+static void test_hybrid_analysis(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, in, [13], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, filter, [N], [8][2]);
+
+    declare_func(void, INTFLOAT (*out)[2], INTFLOAT (*in)[2],
+                 const INTFLOAT (*filter)[8][2],
+                 ptrdiff_t stride, int n);
+
+    randomize((INTFLOAT *)in, 13 * 2);
+    randomize((INTFLOAT *)filter, N * 8 * 2);
+
+    randomize((INTFLOAT *)dst0, BUF_SIZE * 2);
+    memcpy(dst1, dst0, BUF_SIZE * 2 * sizeof(INTFLOAT));
+
+    call_ref(dst0, in, filter, STRIDE, N);
+    call_new(dst1, in, filter, STRIDE, N);
+
+    if (!float_near_abs_eps_array((float *)dst0, (float *)dst1, EPS, BUF_SIZE * 2))
+        fail();
+    bench_new(dst1, in, filter, STRIDE, N);
+}
+
+static void test_hybrid_analysis_ileave(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, in,   [2], [38][64]);
+    LOCAL_ALIGNED_16(INTFLOAT, out0, [91], [32][2]);
+    LOCAL_ALIGNED_16(INTFLOAT, out1, [91], [32][2]);
+
+    declare_func(void, INTFLOAT (*out)[32][2], INTFLOAT L[2][38][64],
+                       int i, int len);
+
+    randomize((INTFLOAT *)out0, 91 * 32 * 2);
+    randomize((INTFLOAT *)in,    2 * 38 * 64);
+    memcpy(out1, out0, 91 * 32 * 2 * sizeof(INTFLOAT));
+
+    /* len is hardcoded to 32 as that's the only value used in
+       libavcodec. asm functions are likely to be optimized
+       hardcoding this value in their loops and could fail with
+       anything else.
+       i is hardcoded to the two values currently used by the
+       aac decoder because the arm neon implementation is
+       micro-optimized for them and will fail for almost every
+       other value. */
+    call_ref(out0, in, 3, 32);
+    call_new(out1, in, 3, 32);
+
+    /* the function just moves data around, so memcmp is enough */
+    if (memcmp(out0, out1, 91 * 32 * 2 * sizeof(INTFLOAT)))
+        fail();
+
+    call_ref(out0, in, 5, 32);
+    call_new(out1, in, 5, 32);
+
+    if (memcmp(out0, out1, 91 * 32 * 2 * sizeof(INTFLOAT)))
+        fail();
+
+    bench_new(out1, in, 3, 32);
+}
+
+static void test_hybrid_synthesis_deint(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, out0, [2], [38][64]);
+    LOCAL_ALIGNED_16(INTFLOAT, out1, [2], [38][64]);
+    LOCAL_ALIGNED_16(INTFLOAT, in,  [91], [32][2]);
+
+    declare_func(void, INTFLOAT out[2][38][64], INTFLOAT (*in)[32][2],
+                       int i, int len);
+
+    randomize((INTFLOAT *)in,  91 * 32 * 2);
+    randomize((INTFLOAT *)out0, 2 * 38 * 64);
+    memcpy(out1, out0, 2 * 38 * 64 * sizeof(INTFLOAT));
+
+    /* len is hardcoded to 32 as that's the only value used in
+       libavcodec. asm functions are likely to be optimized
+       hardcoding this value in their loops and could fail with
+       anything else.
+       i is hardcoded to the two values currently used by the
+       aac decoder because the arm neon implementation is
+       micro-optimized for them and will fail for almost every
+       other value. */
+    call_ref(out0, in, 3, 32);
+    call_new(out1, in, 3, 32);
+
+    /* the function just moves data around, so memcmp is enough */
+    if (memcmp(out0, out1, 2 * 38 * 64 * sizeof(INTFLOAT)))
+        fail();
+
+    call_ref(out0, in, 5, 32);
+    call_new(out1, in, 5, 32);
+
+    if (memcmp(out0, out1, 2 * 38 * 64 * sizeof(INTFLOAT)))
+        fail();
+
+    bench_new(out1, in, 3, 32);
+}
+
+static void test_stereo_interpolate(PSDSPContext *psdsp)
+{
+    int i;
+    LOCAL_ALIGNED_16(INTFLOAT, l,  [BUF_SIZE], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, r,  [BUF_SIZE], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, l0, [BUF_SIZE], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, r0, [BUF_SIZE], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, l1, [BUF_SIZE], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, r1, [BUF_SIZE], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, h, [2], [4]);
+    LOCAL_ALIGNED_16(INTFLOAT, h_step, [2], [4]);
+
+    declare_func(void, INTFLOAT (*l)[2], INTFLOAT (*r)[2],
+                       INTFLOAT h[2][4], INTFLOAT h_step[2][4], int len);
+
+    randomize((INTFLOAT *)l, BUF_SIZE * 2);
+    randomize((INTFLOAT *)r, BUF_SIZE * 2);
+
+    for (i = 0; i < 2; i++) {
+        if (check_func(psdsp->stereo_interpolate[i], "ps_stereo_interpolate%s", i ? "_ipdopd" : "")) {
+            memcpy(l0, l, BUF_SIZE * 2 * sizeof(INTFLOAT));
+            memcpy(l1, l, BUF_SIZE * 2 * sizeof(INTFLOAT));
+            memcpy(r0, r, BUF_SIZE * 2 * sizeof(INTFLOAT));
+            memcpy(r1, r, BUF_SIZE * 2 * sizeof(INTFLOAT));
+
+            randomize((INTFLOAT *)h, 2 * 4);
+            randomize((INTFLOAT *)h_step, 2 * 4);
+
+            call_ref(l0, r0, h, h_step, BUF_SIZE);
+            call_new(l1, r1, h, h_step, BUF_SIZE);
+            if (!float_near_abs_eps_array((float *)l0, (float *)l1, EPS, BUF_SIZE * 2) ||
+                !float_near_abs_eps_array((float *)r0, (float *)r1, EPS, BUF_SIZE * 2))
+                fail();
+
+            memcpy(l1, l, BUF_SIZE * 2 * sizeof(INTFLOAT));
+            memcpy(r1, r, BUF_SIZE * 2 * sizeof(INTFLOAT));
+            bench_new(l1, r1, h, h_step, BUF_SIZE);
+        }
+    }
+}
+
+void checkasm_check_aacpsdsp(void)
+{
+    PSDSPContext psdsp;
+
+    ff_psdsp_init(&psdsp);
+
+    if (check_func(psdsp.add_squares, "ps_add_squares"))
+        test_add_squares();
+    report("add_squares");
+
+    if (check_func(psdsp.mul_pair_single, "ps_mul_pair_single"))
+        test_mul_pair_single();
+    report("mul_pair_single");
+
+    if (check_func(psdsp.hybrid_analysis, "ps_hybrid_analysis"))
+        test_hybrid_analysis();
+    report("hybrid_analysis");
+
+    if (check_func(psdsp.hybrid_analysis_ileave, "ps_hybrid_analysis_ileave"))
+        test_hybrid_analysis_ileave();
+    report("hybrid_analysis_ileave");
+
+    if (check_func(psdsp.hybrid_synthesis_deint, "ps_hybrid_synthesis_deint"))
+        test_hybrid_synthesis_deint();
+    report("hybrid_synthesis_deint");
+
+    test_stereo_interpolate(&psdsp);
+    report("stereo_interpolate");
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/aarch64/Makefile b/mythtv/external/FFmpeg/tests/checkasm/aarch64/Makefile
deleted file mode 100644
index 02ba6cafa98..00000000000
--- a/mythtv/external/FFmpeg/tests/checkasm/aarch64/Makefile
+++ /dev/null
@@ -1 +0,0 @@
-CHECKASMOBJS += aarch64/checkasm.o
diff --git a/mythtv/external/FFmpeg/tests/checkasm/aarch64/checkasm.S b/mythtv/external/FFmpeg/tests/checkasm/aarch64/checkasm.S
index 6317d806119..75a9a561439 100644
--- a/mythtv/external/FFmpeg/tests/checkasm/aarch64/checkasm.S
+++ b/mythtv/external/FFmpeg/tests/checkasm/aarch64/checkasm.S
@@ -52,7 +52,20 @@ endconst
 // max number of args used by any asm function.
 #define MAX_ARGS 15
 
-#define ARG_STACK ((8*(MAX_ARGS - 7) + 15) & ~15)
+#define CLOBBER_STACK ((8*MAX_ARGS + 15) & ~15)
+
+function checkasm_stack_clobber, export=1
+    mov         x3,  sp
+    mov         x2,  #CLOBBER_STACK
+1:
+    stp         x0,  x1,  [sp, #-16]!
+    subs        x2,  x2,  #16
+    b.gt        1b
+    mov         sp,  x3
+    ret
+endfunc
+
+#define ARG_STACK ((8*(MAX_ARGS - 8) + 15) & ~15)
 
 function checkasm_checked_call, export=1
     stp         x29, x30, [sp, #-16]!
@@ -80,22 +93,18 @@ function checkasm_checked_call, export=1
 
     sub         sp,  sp,  #ARG_STACK
 .equ pos, 0
-// the first stacked arg is copied to x7
-.rept MAX_ARGS-7
-    ldr         x9, [x29, #16 + 8 + pos]
+.rept MAX_ARGS-8
+    // Skip the first 8 args, that are loaded into registers
+    ldr         x9, [x29, #16 + 8*8 + pos]
     str         x9, [sp, #pos]
 .equ pos, pos + 8
 .endr
 
     mov         x12, x0
-    mov         x0,  x1
-    mov         x1,  x2
-    mov         x2,  x3
-    mov         x3,  x4
-    mov         x4,  x5
-    mov         x5,  x6
-    mov         x6,  x7
-    ldr         x7,  [x29, #16]
+    ldp         x0,  x1,  [x29, #16]
+    ldp         x2,  x3,  [x29, #32]
+    ldp         x4,  x5,  [x29, #48]
+    ldp         x6,  x7,  [x29, #64]
     blr         x12
     add         sp,  sp,  #ARG_STACK
     stp         x0,  x1,  [sp, #-16]!
@@ -103,10 +112,10 @@ function checkasm_checked_call, export=1
     movi        v3.8h,  #0
 
 .macro check_reg_neon reg1, reg2
-    ldr         q0,  [x9], #16
-    uzp1        v1.2d,  v\reg1\().2d, v\reg2\().2d
-    eor         v0.16b, v0.16b, v1.16b
-    orr         v3.16b, v3.16b, v0.16b
+    ldr         q1,  [x9], #16
+    uzp1        v2.2d,  v\reg1\().2d, v\reg2\().2d
+    eor         v1.16b, v1.16b, v2.16b
+    orr         v3.16b, v3.16b, v1.16b
 .endm
     check_reg_neon  8,  9
     check_reg_neon  10, 11
diff --git a/mythtv/external/FFmpeg/tests/checkasm/arm/Makefile b/mythtv/external/FFmpeg/tests/checkasm/arm/Makefile
deleted file mode 100644
index 55f2383d4c2..00000000000
--- a/mythtv/external/FFmpeg/tests/checkasm/arm/Makefile
+++ /dev/null
@@ -1 +0,0 @@
-CHECKASMOBJS-$(HAVE_ARMV5TE_EXTERNAL) += arm/checkasm.o
diff --git a/mythtv/external/FFmpeg/tests/checkasm/arm/checkasm.S b/mythtv/external/FFmpeg/tests/checkasm/arm/checkasm.S
index 3e3806b2a78..2051b290f69 100644
--- a/mythtv/external/FFmpeg/tests/checkasm/arm/checkasm.S
+++ b/mythtv/external/FFmpeg/tests/checkasm/arm/checkasm.S
@@ -22,7 +22,13 @@
 
 #include "libavutil/arm/asm.S"
 
-const register_init
+/* override fpu so that NEON instructions are rejected */
+#if HAVE_VFP
+FPU     .fpu            vfp
+ELF     .eabi_attribute 10, 0           @ suppress Tag_FP_arch
+#endif
+
+const register_init, align=3
     .quad 0x21f86d66c8ca00ce
     .quad 0x75b6ba21077c48ad
     .quad 0xed56bb2dcb3c7736
@@ -33,14 +39,21 @@ const register_init
     .quad 0x249214109d5d1c88
 endconst
 
-const error_message
-    .asciz "failed to preserve register"
+const error_message_fpscr
+    .asciz "failed to preserve register FPSCR, changed bits: %x"
+error_message_gpr:
+    .asciz "failed to preserve register r%d"
+error_message_vfp:
+    .asciz "failed to preserve register d%d"
 endconst
 
 @ max number of args used by any asm function.
 #define MAX_ARGS 15
 
-#define ARG_STACK 4*(MAX_ARGS - 2)
+#define ARG_STACK 4*(MAX_ARGS - 4)
+
+@ align the used stack space to 8 to preserve the stack alignment
+#define ARG_STACK_A (((ARG_STACK + pushed + 7) & ~7) - pushed)
 
 .macro clobbercheck variant
 .equ pushed, 4*9
@@ -59,10 +72,10 @@ function checkasm_checked_call_\variant, export=1
 .endif
     ldm         r12, {r4-r11}
 
-    sub         sp,  sp,  #ARG_STACK
+    sub         sp,  sp,  #ARG_STACK_A
 .equ pos, 0
-.rept MAX_ARGS-2
-    ldr         r12, [sp, #ARG_STACK + pushed + 8 + pos]
+.rept MAX_ARGS-4
+    ldr         r12, [sp, #ARG_STACK_A + pushed + 8 + pos]
     str         r12, [sp, #pos]
 .equ pos, pos + 4
 .endr
@@ -70,45 +83,51 @@ function checkasm_checked_call_\variant, export=1
     mov         r12, r0
     mov         r0,  r2
     mov         r1,  r3
-    ldrd        r2,  r3,  [sp, #ARG_STACK + pushed]
+    ldrd        r2,  r3,  [sp, #ARG_STACK_A + pushed]
     blx         r12
-    add         sp,  sp,  #ARG_STACK
+    add         sp,  sp,  #ARG_STACK_A
 
     push        {r0, r1}
     movrel      r12, register_init
-    mov         r3,  #0
 .ifc \variant, vfp
-.macro check_reg_vfp, dreg, inc=8
-    ldrd        r0,  r1,  [r12], #\inc
-    vmov        r2,  lr,  \dreg
-    eor         r0,  r0,  r2
-    eor         r1,  r1,  lr
-    orr         r3,  r3,  r0
-    orr         r3,  r3,  r1
+.macro check_reg_vfp, dreg, offset
+    ldrd        r2,  r3,  [r12, #8 * (\offset)]
+    vmov        r0,  lr,  \dreg
+    eor         r2,  r2,  r0
+    eor         r3,  r3,  lr
+    orrs        r2,  r2,  r3
+    bne         4f
 .endm
 
-.irp n, 8, 9, 10, 11, 12, 13, 14
-    check_reg_vfp d\n
+.irp n, 8, 9, 10, 11, 12, 13, 14, 15
+    @ keep track of the checked double/SIMD register
+    mov         r1,  #\n
+    check_reg_vfp d\n, \n-8
 .endr
-    check_reg_vfp d15, -56
 .purgem check_reg_vfp
 
-    fmrx        r0,  FPSCR
-    ldr         r1,  [sp, #8]
-    eor         r0,  r0,  r1
+    fmrx        r1,  FPSCR
+    ldr         r3,  [sp, #8]
+    eor         r1,  r1,  r3
+    @ Ignore changes in bits 0-4 and 7
+    bic         r1,  r1,  #0x9f
     @ Ignore changes in the topmost 5 bits
-    lsl         r0,  r0,  #5
-    orr         r3,  r3,  r0
+    bics        r1,  r1,  #0xf8000000
+    bne         3f
 .endif
 
+    @ keep track of the checked GPR
+    mov         r1,  #4
 .macro check_reg reg1, reg2=
-    ldrd        r0,  r1,  [r12], #8
-    eor         r0,  r0,  \reg1
-    orrs        r3,  r3,  r0
+    ldrd        r2,  r3,  [r12], #8
+    eors        r2,  r2,  \reg1
+    bne         2f
+    add         r1,  r1,  #1
 .ifnb \reg2
-    eor         r1,  r1,  \reg2
-    orrs        r3,  r3,  r1
+    eors        r3,  r3,  \reg2
+    bne         2f
 .endif
+    add         r1,  r1,  #1
 .endm
     check_reg   r4,  r5
     check_reg   r6,  r7
@@ -121,9 +140,16 @@ function checkasm_checked_call_\variant, export=1
     check_reg   r10, r11
 .purgem check_reg
 
-    beq         0f
-
-    movrel      r0, error_message
+    b           0f
+4:
+    movrel      r0, error_message_vfp
+    b           1f
+3:
+    movrel      r0, error_message_fpscr
+    b           1f
+2:
+    movrel      r0, error_message_gpr
+1:
     blx         X(checkasm_fail_func)
 0:
     pop         {r0, r1}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/audiodsp.c b/mythtv/external/FFmpeg/tests/checkasm/audiodsp.c
new file mode 100644
index 00000000000..7c4e16e40d5
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/audiodsp.c
@@ -0,0 +1,146 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 <math.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "libavcodec/audiodsp.h"
+
+#include "libavutil/common.h"
+#include "libavutil/intreadwrite.h"
+
+#include "checkasm.h"
+
+#define MAX_SIZE (32 * 128)
+
+#define randomize_float(buf, len)                               \
+    do {                                                        \
+        int i;                                                  \
+        for (i = 0; i < len; i++) {                             \
+            float f = (float)rnd() / (UINT_MAX >> 5) - 16.0f;   \
+            buf[i] = f;                                         \
+        }                                                       \
+    } while (0)
+
+#define randomize_int(buf, len, size, bits)                         \
+    do {                                                            \
+        int i;                                                      \
+        for (i = 0; i < len; i++) {                                 \
+            uint ## size ## _t r = rnd() & ((1LL << bits) - 1);     \
+            AV_WN ## size ## A(buf + i, -(1LL << (bits - 1)) + r);  \
+        }                                                           \
+    } while (0)
+
+void checkasm_check_audiodsp(void)
+{
+    AudioDSPContext adsp;
+
+    ff_audiodsp_init(&adsp);
+
+    if (check_func(adsp.scalarproduct_int16, "audiodsp.scalarproduct_int16")) {
+        LOCAL_ALIGNED(32, int16_t, v1, [MAX_SIZE]);
+        LOCAL_ALIGNED(32, int16_t, v2, [MAX_SIZE]);
+        unsigned int len_bits_minus4, v1_bits, v2_bits, len;
+        int32_t res0, res1;
+
+        declare_func_emms(AV_CPU_FLAG_MMX, int32_t, const int16_t *v1, const int16_t *v2, int len);
+
+        // generate random 5-12bit vector length
+        len_bits_minus4 = rnd() % 8;
+        len = rnd() & ((1 << len_bits_minus4) - 1);
+        len = 16 * FFMAX(len, 1);
+
+        // generate the bit counts for each of the vectors such that the result
+        // fits into int32
+        v1_bits = 1 + rnd() % 15;
+        v2_bits = FFMIN(32 - (len_bits_minus4 + 4) - v1_bits - 1, 15);
+
+        randomize_int(v1, MAX_SIZE, 16, v1_bits + 1);
+        randomize_int(v2, MAX_SIZE, 16, v2_bits + 1);
+
+        res0 = call_ref(v1, v2, len);
+        res1 = call_new(v1, v2, len);
+        if (res0 != res1)
+            fail();
+        bench_new(v1, v2, MAX_SIZE);
+    }
+
+    if (check_func(adsp.vector_clip_int32, "audiodsp.vector_clip_int32")) {
+        LOCAL_ALIGNED(32, int32_t, src,  [MAX_SIZE]);
+        LOCAL_ALIGNED(32, int32_t, dst0, [MAX_SIZE]);
+        LOCAL_ALIGNED(32, int32_t, dst1, [MAX_SIZE]);
+        int32_t val1, val2, min, max;
+        int len;
+
+        declare_func_emms(AV_CPU_FLAG_MMX, void, int32_t *dst, const int32_t *src,
+                          int32_t min, int32_t max, unsigned int len);
+
+        val1 = ((int32_t)rnd());
+        val1 = FFSIGN(val1) * (val1 & ((1 << 24) - 1));
+        val2 = ((int32_t)rnd());
+        val2 = FFSIGN(val2) * (val2 & ((1 << 24) - 1));
+
+        min = FFMIN(val1, val2);
+        max = FFMAX(val1, val2);
+
+        randomize_int(src, MAX_SIZE, 32, 32);
+
+        len = rnd() % 128;
+        len = 32 * FFMAX(len, 1);
+
+        call_ref(dst0, src, min, max, len);
+        call_new(dst1, src, min, max, len);
+        if (memcmp(dst0, dst1, len * sizeof(*dst0)))
+            fail();
+        bench_new(dst1, src, min, max, MAX_SIZE);
+    }
+
+    if (check_func(adsp.vector_clipf, "audiodsp.vector_clipf")) {
+        LOCAL_ALIGNED(32, float, src, [MAX_SIZE]);
+        LOCAL_ALIGNED(32, float, dst0, [MAX_SIZE]);
+        LOCAL_ALIGNED(32, float, dst1, [MAX_SIZE]);
+        float val1, val2, min, max;
+        int i, len;
+
+        declare_func_emms(AV_CPU_FLAG_MMX, void, float *dst, const float *src,
+                          int len, float min, float max);
+
+        val1 = (float)rnd() / (UINT_MAX >> 1) - 1.0f;
+        val2 = (float)rnd() / (UINT_MAX >> 1) - 1.0f;
+
+        min = FFMIN(val1, val2);
+        max = FFMAX(val1, val2);
+
+        randomize_float(src, MAX_SIZE);
+
+        len = rnd() % 128;
+        len = 16 * FFMAX(len, 1);
+
+        call_ref(dst0, src, len, min, max);
+        call_new(dst1, src, len, min, max);
+        for (i = 0; i < len; i++) {
+            if (!float_near_ulp_array(dst0, dst1, 3, len))
+                fail();
+        }
+        bench_new(dst1, src, MAX_SIZE, min, max);
+    }
+
+    report("audiodsp");
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/blockdsp.c b/mythtv/external/FFmpeg/tests/checkasm/blockdsp.c
new file mode 100644
index 00000000000..c753506b3cc
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/blockdsp.c
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2015 Henrik Gramner
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 <string.h>
+
+#include "checkasm.h"
+
+#include "libavcodec/blockdsp.h"
+
+#include "libavutil/common.h"
+#include "libavutil/internal.h"
+#include "libavutil/intreadwrite.h"
+
+#define randomize_buffers(size)             \
+    do {                                    \
+        int i;                              \
+        for (i = 0; i < size; i++) {        \
+            uint16_t r = rnd();             \
+            AV_WN16A(buf0 + i, r);          \
+            AV_WN16A(buf1 + i, r);          \
+        }                                   \
+    } while (0)
+
+#define check_clear(func, size)                                     \
+do {                                                                \
+    if (check_func(h.func, "blockdsp." #func)) {                    \
+        declare_func_emms(AV_CPU_FLAG_MMX, void, int16_t *block);   \
+        randomize_buffers(size);                                    \
+        call_ref(buf0);                                             \
+        call_new(buf1);                                             \
+        if (memcmp(buf0, buf1, sizeof(*buf0) * size))               \
+            fail();                                                 \
+        bench_new(buf0);                                            \
+    }                                                               \
+} while (0)
+
+void checkasm_check_blockdsp(void)
+{
+    LOCAL_ALIGNED_32(uint16_t, buf0, [6 * 8 * 8]);
+    LOCAL_ALIGNED_32(uint16_t, buf1, [6 * 8 * 8]);
+
+    AVCodecContext avctx = { 0 };
+    BlockDSPContext h;
+
+    ff_blockdsp_init(&h, &avctx);
+
+    check_clear(clear_block,  8 * 8);
+    check_clear(clear_blocks, 8 * 8 * 6);
+
+    report("blockdsp");
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/checkasm.c b/mythtv/external/FFmpeg/tests/checkasm/checkasm.c
index cca227aa5a0..b8b0e32dbd4 100644
--- a/mythtv/external/FFmpeg/tests/checkasm/checkasm.c
+++ b/mythtv/external/FFmpeg/tests/checkasm/checkasm.c
@@ -20,6 +20,14 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
+#include "config.h"
+
+#if CONFIG_LINUX_PERF
+# ifndef _GNU_SOURCE
+#  define _GNU_SOURCE // for syscall (performance monitoring API)
+# endif
+#endif
+
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -65,21 +73,37 @@ static const struct {
     void (*func)(void);
 } tests[] = {
 #if CONFIG_AVCODEC
+    #if CONFIG_AAC_DECODER
+        { "aacpsdsp", checkasm_check_aacpsdsp },
+        { "sbrdsp",   checkasm_check_sbrdsp },
+    #endif
     #if CONFIG_ALAC_DECODER
         { "alacdsp", checkasm_check_alacdsp },
     #endif
+    #if CONFIG_AUDIODSP
+        { "audiodsp", checkasm_check_audiodsp },
+    #endif
+    #if CONFIG_BLOCKDSP
+        { "blockdsp", checkasm_check_blockdsp },
+    #endif
     #if CONFIG_BSWAPDSP
         { "bswapdsp", checkasm_check_bswapdsp },
     #endif
     #if CONFIG_DCA_DECODER
         { "synth_filter", checkasm_check_synth_filter },
     #endif
+    #if CONFIG_EXR_DECODER
+        { "exrdsp", checkasm_check_exrdsp },
+    #endif
     #if CONFIG_FLACDSP
         { "flacdsp", checkasm_check_flacdsp },
     #endif
     #if CONFIG_FMTCONVERT
         { "fmtconvert", checkasm_check_fmtconvert },
     #endif
+    #if CONFIG_G722DSP
+        { "g722dsp", checkasm_check_g722dsp },
+    #endif
     #if CONFIG_H264DSP
         { "h264dsp", checkasm_check_h264dsp },
     #endif
@@ -89,15 +113,25 @@ static const struct {
     #if CONFIG_H264QPEL
         { "h264qpel", checkasm_check_h264qpel },
     #endif
+    #if CONFIG_HEVC_DECODER
+        { "hevc_add_res", checkasm_check_hevc_add_res },
+        { "hevc_idct", checkasm_check_hevc_idct },
+    #endif
     #if CONFIG_JPEG2000_DECODER
         { "jpeg2000dsp", checkasm_check_jpeg2000dsp },
     #endif
+    #if CONFIG_HUFFYUVDSP
+        { "llviddsp", checkasm_check_llviddsp },
+    #endif
     #if CONFIG_PIXBLOCKDSP
         { "pixblockdsp", checkasm_check_pixblockdsp },
     #endif
     #if CONFIG_V210_ENCODER
         { "v210enc", checkasm_check_v210enc },
     #endif
+    #if CONFIG_VP8DSP
+        { "vp8dsp", checkasm_check_vp8dsp },
+    #endif
     #if CONFIG_VP9_DECODER
         { "vp9dsp", checkasm_check_vp9dsp },
     #endif
@@ -112,6 +146,10 @@ static const struct {
     #if CONFIG_COLORSPACE_FILTER
         { "vf_colorspace", checkasm_check_colorspace },
     #endif
+#endif
+#if CONFIG_AVUTIL
+        { "fixed_dsp", checkasm_check_fixed_dsp },
+        { "float_dsp", checkasm_check_float_dsp },
 #endif
     { NULL }
 };
@@ -163,8 +201,7 @@ typedef struct CheckasmFuncVersion {
     void *func;
     int ok;
     int cpu;
-    int iterations;
-    uint64_t cycles;
+    CheckasmPerf perf;
 } CheckasmFuncVersion;
 
 /* Binary search tree node */
@@ -185,9 +222,14 @@ static struct {
     int bench_pattern_len;
     int num_checked;
     int num_failed;
+
+    /* perf */
     int nop_time;
+    int sysfd;
+
     int cpu_flag;
     const char *cpu_flag_name;
+    const char *test_name;
 } state;
 
 /* PRNG state */
@@ -211,7 +253,7 @@ int float_near_ulp(float a, float b, unsigned max_ulp)
         return a == b;
     }
 
-    if (abs(x.i - y.i) <= max_ulp)
+    if (llabs((int64_t)x.i - y.i) <= max_ulp)
         return 1;
 
     return 0;
@@ -265,6 +307,25 @@ int float_near_abs_eps_array_ulp(const float *a, const float *b, float eps,
     return 1;
 }
 
+int double_near_abs_eps(double a, double b, double eps)
+{
+    double abs_diff = fabs(a - b);
+
+    return abs_diff < eps;
+}
+
+int double_near_abs_eps_array(const double *a, const double *b, double eps,
+                              unsigned len)
+{
+    unsigned i;
+
+    for (i = 0; i < len; i++) {
+        if (!double_near_abs_eps(a[i], b[i], eps))
+            return 0;
+    }
+    return 1;
+}
+
 /* Print colored text to stderr if the terminal supports it */
 static void color_printf(int color, const char *fmt, ...)
 {
@@ -349,7 +410,6 @@ static const char *cpu_suffix(int cpu)
     return "c";
 }
 
-#ifdef AV_READ_TIME
 static int cmp_nop(const void *a, const void *b)
 {
     return *(const uint16_t*)a - *(const uint16_t*)b;
@@ -360,10 +420,13 @@ static int measure_nop_time(void)
 {
     uint16_t nops[10000];
     int i, nop_sum = 0;
+    av_unused const int sysfd = state.sysfd;
 
+    uint64_t t = 0;
     for (i = 0; i < 10000; i++) {
-        uint64_t t = AV_READ_TIME();
-        nops[i] = AV_READ_TIME() - t;
+        PERF_START(t);
+        PERF_STOP(t);
+        nops[i] = t;
     }
 
     qsort(nops, 10000, sizeof(uint16_t), cmp_nop);
@@ -383,8 +446,9 @@ static void print_benchs(CheckasmFunc *f)
         if (f->versions.cpu || f->versions.next) {
             CheckasmFuncVersion *v = &f->versions;
             do {
-                if (v->iterations) {
-                    int decicycles = (10*v->cycles/v->iterations - state.nop_time) / 4;
+                CheckasmPerf *p = &v->perf;
+                if (p->iterations) {
+                    int decicycles = (10*p->cycles/p->iterations - state.nop_time) / 4;
                     printf("%s_%s: %d.%d\n", f->name, cpu_suffix(v->cpu), decicycles/10, decicycles%10);
                 }
             } while ((v = v->next));
@@ -393,7 +457,6 @@ static void print_benchs(CheckasmFunc *f)
         print_benchs(f->child[1]);
     }
 }
-#endif
 
 /* ASCIIbetical sort except preserving natural order for numbers */
 static int cmp_func_names(const char *a, const char *b)
@@ -479,6 +542,8 @@ static void check_cpu_flag(const char *name, int flag)
 
         state.cpu_flag_name = name;
         for (i = 0; tests[i].func; i++) {
+            if (state.test_name && strcmp(tests[i].name, state.test_name))
+                continue;
             state.current_test_name = tests[i].name;
             tests[i].func();
         }
@@ -494,9 +559,67 @@ static void print_cpu_name(void)
     }
 }
 
+#if CONFIG_LINUX_PERF
+static int bench_init_linux(void)
+{
+    struct perf_event_attr attr = {
+        .type           = PERF_TYPE_HARDWARE,
+        .size           = sizeof(struct perf_event_attr),
+        .config         = PERF_COUNT_HW_CPU_CYCLES,
+        .disabled       = 1, // start counting only on demand
+        .exclude_kernel = 1,
+        .exclude_hv     = 1,
+    };
+
+    printf("benchmarking with Linux Perf Monitoring API\n");
+
+    state.sysfd = syscall(__NR_perf_event_open, &attr, 0, -1, -1, 0);
+    if (state.sysfd == -1) {
+        perror("syscall");
+        return -1;
+    }
+    return 0;
+}
+#endif
+
+static int bench_init_ffmpeg(void)
+{
+#ifdef AV_READ_TIME
+    printf("benchmarking with native FFmpeg timers\n");
+    return 0;
+#else
+    fprintf(stderr, "checkasm: --bench is not supported on your system\n");
+    return -1;
+#endif
+}
+
+static int bench_init(void)
+{
+#if CONFIG_LINUX_PERF
+    int ret = bench_init_linux();
+#else
+    int ret = bench_init_ffmpeg();
+#endif
+    if (ret < 0)
+        return ret;
+
+    state.nop_time = measure_nop_time();
+    printf("nop: %d.%d\n", state.nop_time/10, state.nop_time%10);
+    return 0;
+}
+
+static void bench_uninit(void)
+{
+#if CONFIG_LINUX_PERF
+    if (state.sysfd > 0)
+        close(state.sysfd);
+#endif
+}
+
 int main(int argc, char *argv[])
 {
-    int i, seed, ret = 0;
+    unsigned int seed = av_get_random_seed();
+    int i, ret = 0;
 
 #if ARCH_ARM && HAVE_ARMV5TE_EXTERNAL
     if (have_vfp(av_get_cpu_flags()) || have_neon(av_get_cpu_flags()))
@@ -508,22 +631,25 @@ int main(int argc, char *argv[])
         return 0;
     }
 
-    if (argc > 1 && !strncmp(argv[1], "--bench", 7)) {
-#ifndef AV_READ_TIME
-        fprintf(stderr, "checkasm: --bench is not supported on your system\n");
-        return 1;
-#endif
-        if (argv[1][7] == '=') {
-            state.bench_pattern = argv[1] + 8;
-            state.bench_pattern_len = strlen(state.bench_pattern);
-        } else
-            state.bench_pattern = "";
+    while (argc > 1) {
+        if (!strncmp(argv[1], "--bench", 7)) {
+            if (bench_init() < 0)
+                return 1;
+            if (argv[1][7] == '=') {
+                state.bench_pattern = argv[1] + 8;
+                state.bench_pattern_len = strlen(state.bench_pattern);
+            } else
+                state.bench_pattern = "";
+        } else if (!strncmp(argv[1], "--test=", 7)) {
+            state.test_name = argv[1] + 7;
+        } else {
+            seed = strtoul(argv[1], NULL, 10);
+        }
 
         argc--;
         argv++;
     }
 
-    seed = (argc > 1) ? atoi(argv[1]) : av_get_random_seed();
     fprintf(stderr, "checkasm: using random seed %u\n", seed);
     av_lfg_init(&checkasm_lfg, seed);
 
@@ -536,16 +662,13 @@ int main(int argc, char *argv[])
         ret = 1;
     } else {
         fprintf(stderr, "checkasm: all %d tests passed\n", state.num_checked);
-#ifdef AV_READ_TIME
         if (state.bench_pattern) {
-            state.nop_time = measure_nop_time();
-            printf("nop: %d.%d\n", state.nop_time/10, state.nop_time%10);
             print_benchs(state.funcs);
         }
-#endif
     }
 
     destroy_func_tree(state.funcs);
+    bench_uninit();
     return ret;
 }
 
@@ -623,11 +746,13 @@ void checkasm_fail_func(const char *msg, ...)
     }
 }
 
-/* Update benchmark results of the current function */
-void checkasm_update_bench(int iterations, uint64_t cycles)
+/* Get the benchmark context of the current function */
+CheckasmPerf *checkasm_get_perf_context(void)
 {
-    state.current_func_ver->iterations += iterations;
-    state.current_func_ver->cycles += cycles;
+    CheckasmPerf *perf = &state.current_func_ver->perf;
+    memset(perf, 0, sizeof(*perf));
+    perf->sysfd = state.sysfd;
+    return perf;
 }
 
 /* Print the outcome of all tests performed since the last time this function was called */
diff --git a/mythtv/external/FFmpeg/tests/checkasm/checkasm.h b/mythtv/external/FFmpeg/tests/checkasm/checkasm.h
index 78772511426..e5b1877dc00 100644
--- a/mythtv/external/FFmpeg/tests/checkasm/checkasm.h
+++ b/mythtv/external/FFmpeg/tests/checkasm/checkasm.h
@@ -25,32 +25,54 @@
 
 #include <stdint.h>
 #include "config.h"
+
+#if CONFIG_LINUX_PERF
+#include <unistd.h> // read(3)
+#include <sys/ioctl.h>
+#include <asm/unistd.h>
+#include <linux/perf_event.h>
+#endif
+
 #include "libavutil/avstring.h"
 #include "libavutil/cpu.h"
 #include "libavutil/internal.h"
 #include "libavutil/lfg.h"
 #include "libavutil/timer.h"
 
+void checkasm_check_aacpsdsp(void);
 void checkasm_check_alacdsp(void);
+void checkasm_check_audiodsp(void);
 void checkasm_check_blend(void);
+void checkasm_check_blockdsp(void);
 void checkasm_check_bswapdsp(void);
 void checkasm_check_colorspace(void);
+void checkasm_check_exrdsp(void);
+void checkasm_check_fixed_dsp(void);
 void checkasm_check_flacdsp(void);
+void checkasm_check_float_dsp(void);
 void checkasm_check_fmtconvert(void);
+void checkasm_check_g722dsp(void);
 void checkasm_check_h264dsp(void);
 void checkasm_check_h264pred(void);
 void checkasm_check_h264qpel(void);
+void checkasm_check_hevc_add_res(void);
+void checkasm_check_hevc_idct(void);
 void checkasm_check_jpeg2000dsp(void);
+void checkasm_check_llviddsp(void);
 void checkasm_check_pixblockdsp(void);
+void checkasm_check_sbrdsp(void);
 void checkasm_check_synth_filter(void);
 void checkasm_check_v210enc(void);
+void checkasm_check_vp8dsp(void);
 void checkasm_check_vp9dsp(void);
 void checkasm_check_videodsp(void);
 
+struct CheckasmPerf;
+
 void *checkasm_check_func(void *func, const char *name, ...) av_printf_format(2, 3);
 int checkasm_bench_func(void);
 void checkasm_fail_func(const char *msg, ...) av_printf_format(1, 2);
-void checkasm_update_bench(int iterations, uint64_t cycles);
+struct CheckasmPerf *checkasm_get_perf_context(void);
 void checkasm_report(const char *name, ...) av_printf_format(1, 2);
 
 /* float compare utilities */
@@ -63,6 +85,9 @@ int float_near_abs_eps_array(const float *a, const float *b, float eps,
                              unsigned len);
 int float_near_abs_eps_array_ulp(const float *a, const float *b, float eps,
                                  unsigned max_ulp, unsigned len);
+int double_near_abs_eps(double a, double b, double eps);
+int double_near_abs_eps_array(const double *a, const double *b, double eps,
+                              unsigned len);
 
 extern AVLFG checkasm_lfg;
 #define rnd() av_lfg_get(&checkasm_lfg)
@@ -77,6 +102,7 @@ static av_unused void *func_ref, *func_new;
 /* Declare the function prototype. The first argument is the return value, the remaining
  * arguments are the function parameters. Naming parameters is optional. */
 #define declare_func(ret, ...) declare_new(ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
+#define declare_func_float(ret, ...) declare_new_float(ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
 #define declare_func_emms(cpu_flags, ret, ...) declare_new_emms(cpu_flags, ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
 
 /* Indicate that the current test has failed */
@@ -88,13 +114,16 @@ static av_unused void *func_ref, *func_new;
 /* Call the reference function */
 #define call_ref(...) ((func_type *)func_ref)(__VA_ARGS__)
 
-#if ARCH_X86 && HAVE_YASM
+#if ARCH_X86 && HAVE_X86ASM
 /* Verifies that clobbered callee-saved registers are properly saved and restored
  * and that either no MMX registers are touched or emms is issued */
 void checkasm_checked_call(void *func, ...);
 /* Verifies that clobbered callee-saved registers are properly saved and restored
  * and issues emms for asm functions which are not required to do so */
 void checkasm_checked_call_emms(void *func, ...);
+/* Verifies that clobbered callee-saved registers are properly saved and restored
+ * but doesn't issue emms. Meant for dsp functions returning float or double */
+void checkasm_checked_call_float(void *func, ...);
 
 #if ARCH_X86_64
 /* Evil hack: detect incorrect assumptions that 32-bit ints are zero-extended to 64-bit.
@@ -109,6 +138,8 @@ void checkasm_checked_call_emms(void *func, ...);
 void checkasm_stack_clobber(uint64_t clobber, ...);
 #define declare_new(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__)\
                               = (void *)checkasm_checked_call;
+#define declare_new_float(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__)\
+                                    = (void *)checkasm_checked_call_float;
 #define declare_new_emms(cpu_flags, ret, ...) \
     ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__) = \
         ((cpu_flags) & av_get_cpu_flags()) ? (void *)checkasm_checked_call_emms : \
@@ -119,6 +150,7 @@ void checkasm_stack_clobber(uint64_t clobber, ...);
                       checked_call(func_new, 0, 0, 0, 0, 0, __VA_ARGS__))
 #elif ARCH_X86_32
 #define declare_new(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call;
+#define declare_new_float(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call_float;
 #define declare_new_emms(cpu_flags, ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = \
         ((cpu_flags) & av_get_cpu_flags()) ? (void *)checkasm_checked_call_emms :        \
                                              (void *)checkasm_checked_call;
@@ -134,11 +166,17 @@ extern void (*checkasm_checked_call)(void *func, int dummy, ...);
 #define declare_new(ret, ...) ret (*checked_call)(void *, int dummy, __VA_ARGS__) = (void *)checkasm_checked_call;
 #define call_new(...) checked_call(func_new, 0, __VA_ARGS__)
 #elif ARCH_AARCH64 && !defined(__APPLE__)
+void checkasm_stack_clobber(uint64_t clobber, ...);
 void checkasm_checked_call(void *func, ...);
-#define declare_new(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call;
-#define call_new(...) checked_call(func_new, __VA_ARGS__)
+#define declare_new(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, int, int, __VA_ARGS__)\
+                              = (void *)checkasm_checked_call;
+#define CLOB (UINT64_C(0xdeadbeefdeadbeef))
+#define call_new(...) (checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\
+                                              CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\
+                      checked_call(func_new, 0, 0, 0, 0, 0, 0, 0, __VA_ARGS__))
 #else
 #define declare_new(ret, ...)
+#define declare_new_float(ret, ...)
 #define declare_new_emms(cpu_flags, ret, ...)
 /* Call the function */
 #define call_new(...) ((func_type *)func_new)(__VA_ARGS__)
@@ -147,33 +185,63 @@ void checkasm_checked_call(void *func, ...);
 #ifndef declare_new_emms
 #define declare_new_emms(cpu_flags, ret, ...) declare_new(ret, __VA_ARGS__)
 #endif
+#ifndef declare_new_float
+#define declare_new_float(ret, ...) declare_new(ret, __VA_ARGS__)
+#endif
+
+typedef struct CheckasmPerf {
+    int sysfd;
+    uint64_t cycles;
+    int iterations;
+} CheckasmPerf;
+
+#if defined(AV_READ_TIME) || CONFIG_LINUX_PERF
+
+#if CONFIG_LINUX_PERF
+#define PERF_START(t) do {                              \
+    ioctl(sysfd, PERF_EVENT_IOC_RESET, 0);              \
+    ioctl(sysfd, PERF_EVENT_IOC_ENABLE, 0);             \
+} while (0)
+#define PERF_STOP(t) do {                               \
+    ioctl(sysfd, PERF_EVENT_IOC_DISABLE, 0);            \
+    read(sysfd, &t, sizeof(t));                         \
+} while (0)
+#else
+#define PERF_START(t) t = AV_READ_TIME()
+#define PERF_STOP(t)  t = AV_READ_TIME() - t
+#endif
 
 /* Benchmark the function */
-#ifdef AV_READ_TIME
 #define bench_new(...)\
     do {\
         if (checkasm_bench_func()) {\
+            struct CheckasmPerf *perf = checkasm_get_perf_context();\
+            av_unused const int sysfd = perf->sysfd;\
             func_type *tfunc = func_new;\
             uint64_t tsum = 0;\
             int ti, tcount = 0;\
+            uint64_t t = 0; \
             for (ti = 0; ti < BENCH_RUNS; ti++) {\
-                uint64_t t = AV_READ_TIME();\
+                PERF_START(t);\
                 tfunc(__VA_ARGS__);\
                 tfunc(__VA_ARGS__);\
                 tfunc(__VA_ARGS__);\
                 tfunc(__VA_ARGS__);\
-                t = AV_READ_TIME() - t;\
+                PERF_STOP(t);\
                 if (t*tcount <= tsum*4 && ti > 0) {\
                     tsum += t;\
                     tcount++;\
                 }\
             }\
             emms_c();\
-            checkasm_update_bench(tcount, tsum);\
+            perf->cycles += t;\
+            perf->iterations++;\
         }\
     } while (0)
 #else
 #define bench_new(...) while(0)
+#define PERF_START(t)  while(0)
+#define PERF_STOP(t)   while(0)
 #endif
 
 #endif /* TESTS_CHECKASM_CHECKASM_H */
diff --git a/mythtv/external/FFmpeg/tests/checkasm/exrdsp.c b/mythtv/external/FFmpeg/tests/checkasm/exrdsp.c
new file mode 100644
index 00000000000..754a079f834
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/exrdsp.c
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2017 James Almer
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 <string.h>
+
+#include "checkasm.h"
+#include "libavcodec/avcodec.h"
+#include "libavcodec/exrdsp.h"
+#include "libavutil/intreadwrite.h"
+
+#define BUF_SIZE 5120
+#define PADDED_BUF_SIZE BUF_SIZE+AV_INPUT_BUFFER_PADDING_SIZE*2
+
+#define randomize_buffers()                 \
+    do {                                    \
+        int i;                              \
+        for (i = 0; i < BUF_SIZE; i += 4) { \
+            uint32_t r = rnd();             \
+            AV_WN32A(src + i, r);           \
+        }                                   \
+    } while (0)
+
+static void check_reorder_pixels(void) {
+    LOCAL_ALIGNED_32(uint8_t, src,     [PADDED_BUF_SIZE]);
+    LOCAL_ALIGNED_32(uint8_t, dst_ref, [PADDED_BUF_SIZE]);
+    LOCAL_ALIGNED_32(uint8_t, dst_new, [PADDED_BUF_SIZE]);
+
+    declare_func(void, uint8_t *dst, const uint8_t *src, ptrdiff_t size);
+
+    memset(src,     0, PADDED_BUF_SIZE);
+    memset(dst_ref, 0, PADDED_BUF_SIZE);
+    memset(dst_new, 0, PADDED_BUF_SIZE);
+    randomize_buffers();
+    call_ref(dst_ref, src, BUF_SIZE);
+    call_new(dst_new, src, BUF_SIZE);
+    if (memcmp(dst_ref, dst_new, BUF_SIZE))
+        fail();
+    bench_new(dst_new, src, BUF_SIZE);
+}
+
+static void check_predictor(void) {
+    LOCAL_ALIGNED_32(uint8_t, src,     [PADDED_BUF_SIZE]);
+    LOCAL_ALIGNED_32(uint8_t, dst_ref, [PADDED_BUF_SIZE]);
+    LOCAL_ALIGNED_32(uint8_t, dst_new, [PADDED_BUF_SIZE]);
+
+    declare_func(void, uint8_t *src, ptrdiff_t size);
+
+    memset(src,     0, PADDED_BUF_SIZE);
+    randomize_buffers();
+    memcpy(dst_ref, src, PADDED_BUF_SIZE);
+    memcpy(dst_new, src, PADDED_BUF_SIZE);
+    call_ref(dst_ref, BUF_SIZE);
+    call_new(dst_new, BUF_SIZE);
+    if (memcmp(dst_ref, dst_new, BUF_SIZE))
+        fail();
+    bench_new(dst_new, BUF_SIZE);
+}
+
+void checkasm_check_exrdsp(void)
+{
+    ExrDSPContext h;
+
+    ff_exrdsp_init(&h);
+
+    if (check_func(h.reorder_pixels, "reorder_pixels"))
+        check_reorder_pixels();
+
+    report("reorder_pixels");
+
+    if (check_func(h.predictor, "predictor"))
+        check_predictor();
+
+    report("predictor");
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/fixed_dsp.c b/mythtv/external/FFmpeg/tests/checkasm/fixed_dsp.c
new file mode 100644
index 00000000000..fa11f2e23fd
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/fixed_dsp.c
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2015 James Almer
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 "checkasm.h"
+#include "libavutil/common.h"
+#include "libavutil/fixed_dsp.h"
+#include "libavutil/internal.h"
+#include "libavutil/mem.h"
+
+#define BUF_SIZE 256
+
+#define randomize_buffers()                   \
+    do {                                      \
+        int i;                                \
+        for (i = 0; i < BUF_SIZE; i++) {      \
+            src0[i] = sign_extend(rnd(), 24); \
+            src1[i] = sign_extend(rnd(), 24); \
+            src2[i] = sign_extend(rnd(), 24); \
+        }                                     \
+    } while (0)
+
+static void check_vector_fmul(const int *src0, const int *src1)
+{
+    LOCAL_ALIGNED_32(int, ref, [BUF_SIZE]);
+    LOCAL_ALIGNED_32(int, new, [BUF_SIZE]);
+
+    declare_func(void, int *dst, const int *src0, const int *src1, int len);
+
+    call_ref(ref, src0, src1, BUF_SIZE);
+    call_new(new, src0, src1, BUF_SIZE);
+    if (memcmp(ref, new, BUF_SIZE * sizeof(int)))
+        fail();
+    bench_new(new, src0, src1, BUF_SIZE);
+}
+
+static void check_vector_fmul_add(const int *src0, const int *src1, const int *src2)
+{
+    LOCAL_ALIGNED_32(int, ref, [BUF_SIZE]);
+    LOCAL_ALIGNED_32(int, new, [BUF_SIZE]);
+
+    declare_func(void, int *dst, const int *src0, const int *src1, const int *src2, int len);
+
+    call_ref(ref, src0, src1, src2, BUF_SIZE);
+    call_new(new, src0, src1, src2, BUF_SIZE);
+    if (memcmp(ref, new, BUF_SIZE * sizeof(int)))
+        fail();
+    bench_new(new, src0, src1, src2, BUF_SIZE);
+}
+
+static void check_vector_fmul_window(const int32_t *src0, const int32_t *src1, const int32_t *win)
+{
+    LOCAL_ALIGNED_32(int32_t, ref, [BUF_SIZE]);
+    LOCAL_ALIGNED_32(int32_t, new, [BUF_SIZE]);
+
+    declare_func(void, int32_t *dst, const int32_t *src0, const int32_t *src1, const int32_t *win, int len);
+
+    call_ref(ref, src0, src1, win, BUF_SIZE / 2);
+    call_new(new, src0, src1, win, BUF_SIZE / 2);
+    if (memcmp(ref, new, BUF_SIZE * sizeof(int32_t)))
+        fail();
+    bench_new(new, src0, src1, win, BUF_SIZE / 2);
+}
+
+static void check_vector_fmul_window_scaled(const int32_t *src0, const int32_t *src1, const int32_t *win)
+{
+    LOCAL_ALIGNED_16(int16_t, ref, [BUF_SIZE]);
+    LOCAL_ALIGNED_16(int16_t, new, [BUF_SIZE]);
+
+    declare_func(void, int16_t *dst, const int32_t *src0, const int32_t *src1, const int32_t *win, int len, uint8_t bits);
+
+    call_ref(ref, src0, src1, win, BUF_SIZE / 2, 2);
+    call_new(new, src0, src1, win, BUF_SIZE / 2, 2);
+    if (memcmp(ref, new, BUF_SIZE * sizeof(int16_t)))
+        fail();
+    bench_new(new, src0, src1, win, BUF_SIZE / 2, 2);
+}
+
+static void check_butterflies(const int *src0, const int *src1)
+{
+    LOCAL_ALIGNED_16(int, ref0, [BUF_SIZE]);
+    LOCAL_ALIGNED_16(int, ref1, [BUF_SIZE]);
+    LOCAL_ALIGNED_16(int, new0, [BUF_SIZE]);
+    LOCAL_ALIGNED_16(int, new1, [BUF_SIZE]);
+
+    declare_func(void, int *av_restrict src0, int *av_restrict src1, int len);
+
+    memcpy(ref0, src0, BUF_SIZE * sizeof(*src0));
+    memcpy(ref1, src1, BUF_SIZE * sizeof(*src1));
+    memcpy(new0, src0, BUF_SIZE * sizeof(*src0));
+    memcpy(new1, src1, BUF_SIZE * sizeof(*src1));
+
+    call_ref(ref0, ref1, BUF_SIZE);
+    call_new(new0, new1, BUF_SIZE);
+    if (memcmp(ref0, new0, BUF_SIZE * sizeof(*ref0)) ||
+        memcmp(ref1, new1, BUF_SIZE * sizeof(*ref1)))
+        fail();
+    memcpy(new0, src0, BUF_SIZE * sizeof(*src0));
+    memcpy(new1, src1, BUF_SIZE * sizeof(*src1));
+    bench_new(new0, new1, BUF_SIZE);
+}
+
+static void check_scalarproduct_fixed(const int *src0, const int *src1)
+{
+    int ref, new;
+
+    declare_func(int, const int *src0, const int *src1, int len);
+
+    ref = call_ref(src0, src1, BUF_SIZE);
+    new = call_new(src0, src1, BUF_SIZE);
+    if (ref != new)
+        fail();
+    bench_new(src0, src1, BUF_SIZE);
+}
+
+void checkasm_check_fixed_dsp(void)
+{
+    LOCAL_ALIGNED_32(int32_t, src0, [BUF_SIZE]);
+    LOCAL_ALIGNED_32(int32_t, src1, [BUF_SIZE]);
+    LOCAL_ALIGNED_32(int32_t, src2, [BUF_SIZE]);
+    AVFixedDSPContext *fdsp = avpriv_alloc_fixed_dsp(1);
+
+    randomize_buffers();
+    if (check_func(fdsp->vector_fmul, "vector_fmul_fixed"))
+        check_vector_fmul(src0, src1);
+    if (check_func(fdsp->vector_fmul_add, "vector_fmul_add_fixed"))
+        check_vector_fmul_add(src0, src1, src2);
+    if (check_func(fdsp->vector_fmul_reverse, "vector_fmul_reverse_fixed"))
+        check_vector_fmul(src0, src1);
+    if (check_func(fdsp->vector_fmul_window, "vector_fmul_window_fixed"))
+        check_vector_fmul_window(src0, src1, src2);
+    if (check_func(fdsp->vector_fmul_window_scaled, "vector_fmul_window_scaled_fixed"))
+        check_vector_fmul_window_scaled(src0, src1, src2);
+    report("vector_fmul");
+    if (check_func(fdsp->butterflies_fixed, "butterflies_fixed"))
+        check_butterflies(src0, src1);
+    report("butterflies_fixed");
+    if (check_func(fdsp->scalarproduct_fixed, "scalarproduct_fixed"))
+        check_scalarproduct_fixed(src0, src1);
+    report("scalarproduct_fixed");
+
+    av_freep(&fdsp);
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/float_dsp.c b/mythtv/external/FFmpeg/tests/checkasm/float_dsp.c
new file mode 100644
index 00000000000..9b0a221c25d
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/float_dsp.c
@@ -0,0 +1,310 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 <float.h>
+#include <stdint.h>
+
+#include "libavutil/float_dsp.h"
+#include "libavutil/internal.h"
+#include "checkasm.h"
+
+#define LEN 256
+
+#define randomize_buffer(buf)                 \
+do {                                          \
+    int i;                                    \
+    double bmg[2], stddev = 10.0, mean = 0.0; \
+                                              \
+    for (i = 0; i < LEN; i += 2) {            \
+        av_bmg_get(&checkasm_lfg, bmg);       \
+        buf[i]     = bmg[0] * stddev + mean;  \
+        buf[i + 1] = bmg[1] * stddev + mean;  \
+    }                                         \
+} while(0);
+
+static void test_vector_fmul(const float *src0, const float *src1)
+{
+    LOCAL_ALIGNED_32(float, cdst, [LEN]);
+    LOCAL_ALIGNED_32(float, odst, [LEN]);
+    int i;
+
+    declare_func(void, float *dst, const float *src0, const float *src1,
+                 int len);
+
+    call_ref(cdst, src0, src1, LEN);
+    call_new(odst, src0, src1, LEN);
+    for (i = 0; i < LEN; i++) {
+        if (!float_near_abs_eps(cdst[i], odst[i], FLT_EPSILON)) {
+            fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
+                    i, cdst[i], odst[i], cdst[i] - odst[i]);
+            fail();
+            break;
+        }
+    }
+    bench_new(odst, src0, src1, LEN);
+}
+
+#define ARBITRARY_FMUL_ADD_CONST 0.005
+static void test_vector_fmul_add(const float *src0, const float *src1, const float *src2)
+{
+    LOCAL_ALIGNED_32(float, cdst, [LEN]);
+    LOCAL_ALIGNED_32(float, odst, [LEN]);
+    int i;
+
+    declare_func(void, float *dst, const float *src0, const float *src1,
+                     const float *src2, int len);
+
+    call_ref(cdst, src0, src1, src2, LEN);
+    call_new(odst, src0, src1, src2, LEN);
+    for (i = 0; i < LEN; i++) {
+        if (!float_near_abs_eps(cdst[i], odst[i], ARBITRARY_FMUL_ADD_CONST)) {
+            fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
+                    i, cdst[i], odst[i], cdst[i] - odst[i]);
+            fail();
+            break;
+        }
+    }
+    bench_new(odst, src0, src1, src2, LEN);
+}
+
+static void test_vector_fmul_scalar(const float *src0, const float *src1)
+{
+    LOCAL_ALIGNED_16(float, cdst, [LEN]);
+    LOCAL_ALIGNED_16(float, odst, [LEN]);
+    int i;
+
+    declare_func(void, float *dst, const float *src, float mul, int len);
+
+    call_ref(cdst, src0, src1[0], LEN);
+    call_new(odst, src0, src1[0], LEN);
+        for (i = 0; i < LEN; i++) {
+            if (!float_near_abs_eps(cdst[i], odst[i], FLT_EPSILON)) {
+                fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
+                        i, cdst[i], odst[i], cdst[i] - odst[i]);
+                fail();
+                break;
+            }
+        }
+    bench_new(odst, src0, src1[0], LEN);
+}
+
+#define ARBITRARY_FMUL_WINDOW_CONST 0.008
+static void test_vector_fmul_window(const float *src0, const float *src1, const float *win)
+{
+    LOCAL_ALIGNED_16(float, cdst, [LEN]);
+    LOCAL_ALIGNED_16(float, odst, [LEN]);
+    int i;
+
+    declare_func(void, float *dst, const float *src0, const float *src1,
+                 const float *win, int len);
+
+    call_ref(cdst, src0, src1, win, LEN / 2);
+    call_new(odst, src0, src1, win, LEN / 2);
+    for (i = 0; i < LEN; i++) {
+        if (!float_near_abs_eps(cdst[i], odst[i], ARBITRARY_FMUL_WINDOW_CONST)) {
+            fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
+                    i, cdst[i], odst[i], cdst[i] - odst[i]);
+            fail();
+            break;
+        }
+    }
+    bench_new(odst, src0, src1, win, LEN / 2);
+}
+
+#define ARBITRARY_FMAC_SCALAR_CONST 0.005
+static void test_vector_fmac_scalar(const float *src0, const float *src1, const float *src2)
+{
+    LOCAL_ALIGNED_32(float, cdst, [LEN]);
+    LOCAL_ALIGNED_32(float, odst, [LEN]);
+    int i;
+
+    declare_func(void, float *dst, const float *src, float mul, int len);
+
+    memcpy(cdst, src2, LEN * sizeof(*src2));
+    memcpy(odst, src2, LEN * sizeof(*src2));
+
+    call_ref(cdst, src0, src1[0], LEN);
+    call_new(odst, src0, src1[0], LEN);
+    for (i = 0; i < LEN; i++) {
+        if (!float_near_abs_eps(cdst[i], odst[i], ARBITRARY_FMAC_SCALAR_CONST)) {
+            fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
+                    i, cdst[i], odst[i], cdst[i] - odst[i]);
+            fail();
+            break;
+        }
+    }
+    memcpy(odst, src2, LEN * sizeof(*src2));
+    bench_new(odst, src0, src1[0], LEN);
+}
+
+static void test_vector_dmul_scalar(const double *src0, const double *src1)
+{
+    LOCAL_ALIGNED_32(double, cdst, [LEN]);
+    LOCAL_ALIGNED_32(double, odst, [LEN]);
+    int i;
+
+    declare_func(void, double *dst, const double *src, double mul, int len);
+
+    call_ref(cdst, src0, src1[0], LEN);
+    call_new(odst, src0, src1[0], LEN);
+    for (i = 0; i < LEN; i++) {
+        if (!double_near_abs_eps(cdst[i], odst[i], DBL_EPSILON)) {
+            fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n", i,
+                    cdst[i], odst[i], cdst[i] - odst[i]);
+            fail();
+            break;
+        }
+    }
+    bench_new(odst, src0, src1[0], LEN);
+}
+
+#define ARBITRARY_DMAC_SCALAR_CONST 0.005
+static void test_vector_dmac_scalar(const double *src0, const double *src1, const double *src2)
+{
+    LOCAL_ALIGNED_32(double, cdst, [LEN]);
+    LOCAL_ALIGNED_32(double, odst, [LEN]);
+    int i;
+
+    declare_func(void, double *dst, const double *src, double mul, int len);
+
+    memcpy(cdst, src2, LEN * sizeof(*src2));
+    memcpy(odst, src2, LEN * sizeof(*src2));
+    call_ref(cdst, src0, src1[0], LEN);
+    call_new(odst, src0, src1[0], LEN);
+    for (i = 0; i < LEN; i++) {
+        if (!double_near_abs_eps(cdst[i], odst[i], ARBITRARY_DMAC_SCALAR_CONST)) {
+            fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
+                    i, cdst[i], odst[i], cdst[i] - odst[i]);
+            fail();
+            break;
+        }
+    }
+    memcpy(odst, src2, LEN * sizeof(*src2));
+    bench_new(odst, src0, src1[0], LEN);
+}
+
+static void test_butterflies_float(const float *src0, const float *src1)
+{
+    LOCAL_ALIGNED_16(float,  cdst,  [LEN]);
+    LOCAL_ALIGNED_16(float,  odst,  [LEN]);
+    LOCAL_ALIGNED_16(float,  cdst1, [LEN]);
+    LOCAL_ALIGNED_16(float,  odst1, [LEN]);
+    int i;
+
+    declare_func(void, float *av_restrict src0, float *av_restrict src1,
+    int len);
+
+    memcpy(cdst,  src0, LEN * sizeof(*src0));
+    memcpy(cdst1, src1, LEN * sizeof(*src1));
+    memcpy(odst,  src0, LEN * sizeof(*src0));
+    memcpy(odst1, src1, LEN * sizeof(*src1));
+
+    call_ref(cdst, cdst1, LEN);
+    call_new(odst, odst1, LEN);
+    for (i = 0; i < LEN; i++) {
+        if (!float_near_abs_eps(cdst[i],  odst[i],  FLT_EPSILON) ||
+            !float_near_abs_eps(cdst1[i], odst1[i], FLT_EPSILON)) {
+            fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
+                    i, cdst[i], odst[i], cdst[i] - odst[i]);
+            fprintf(stderr, "%d: %- .12f - %- .12f = % .12g\n",
+                    i, cdst1[i], odst1[i], cdst1[i] - odst1[i]);
+            fail();
+            break;
+        }
+    }
+    memcpy(odst,  src0, LEN * sizeof(*src0));
+    memcpy(odst1, src1, LEN * sizeof(*src1));
+    bench_new(odst, odst1, LEN);
+}
+
+#define ARBITRARY_SCALARPRODUCT_CONST 0.2
+static void test_scalarproduct_float(const float *src0, const float *src1)
+{
+    float cprod, oprod;
+
+    declare_func_float(float, const float *src0, const float *src1, int len);
+
+    cprod = call_ref(src0, src1, LEN);
+    oprod = call_new(src0, src1, LEN);
+    if (!float_near_abs_eps(cprod, oprod, ARBITRARY_SCALARPRODUCT_CONST)) {
+        fprintf(stderr, "%- .12f - %- .12f = % .12g\n",
+                cprod, oprod, cprod - oprod);
+        fail();
+    }
+    bench_new(src0, src1, LEN);
+}
+
+void checkasm_check_float_dsp(void)
+{
+    LOCAL_ALIGNED_32(float,  src0,     [LEN]);
+    LOCAL_ALIGNED_32(float,  src1,     [LEN]);
+    LOCAL_ALIGNED_32(float,  src2,     [LEN]);
+    LOCAL_ALIGNED_16(float,  src3,     [LEN]);
+    LOCAL_ALIGNED_16(float,  src4,     [LEN]);
+    LOCAL_ALIGNED_16(float,  src5,     [LEN]);
+    LOCAL_ALIGNED_32(double, dbl_src0, [LEN]);
+    LOCAL_ALIGNED_32(double, dbl_src1, [LEN]);
+    LOCAL_ALIGNED_32(double, dbl_src2, [LEN]);
+    AVFloatDSPContext *fdsp = avpriv_float_dsp_alloc(1);
+
+    if (!fdsp) {
+        fprintf(stderr, "floatdsp: Out of memory error\n");
+        return;
+    }
+
+    randomize_buffer(src0);
+    randomize_buffer(src1);
+    randomize_buffer(src2);
+    randomize_buffer(src3);
+    randomize_buffer(src4);
+    randomize_buffer(src5);
+    randomize_buffer(dbl_src0);
+    randomize_buffer(dbl_src1);
+    randomize_buffer(dbl_src2);
+
+    if (check_func(fdsp->vector_fmul, "vector_fmul"))
+        test_vector_fmul(src0, src1);
+    if (check_func(fdsp->vector_fmul_add, "vector_fmul_add"))
+        test_vector_fmul_add(src0, src1, src2);
+    if (check_func(fdsp->vector_fmul_scalar, "vector_fmul_scalar"))
+        test_vector_fmul_scalar(src3, src4);
+    if (check_func(fdsp->vector_fmul_reverse, "vector_fmul_reverse"))
+        test_vector_fmul(src0, src1);
+    if (check_func(fdsp->vector_fmul_window, "vector_fmul_window"))
+        test_vector_fmul_window(src3, src4, src5);
+    report("vector_fmul");
+    if (check_func(fdsp->vector_fmac_scalar, "vector_fmac_scalar"))
+        test_vector_fmac_scalar(src0, src1, src2);
+    report("vector_fmac");
+    if (check_func(fdsp->vector_dmul_scalar, "vector_dmul_scalar"))
+        test_vector_dmul_scalar(dbl_src0, dbl_src1);
+    report("vector_dmul");
+    if (check_func(fdsp->vector_dmac_scalar, "vector_dmac_scalar"))
+        test_vector_dmac_scalar(dbl_src0, dbl_src1, dbl_src2);
+    report("vector_dmac");
+    if (check_func(fdsp->butterflies_float, "butterflies_float"))
+        test_butterflies_float(src3, src4);
+    report("butterflies_float");
+    if (check_func(fdsp->scalarproduct_float, "scalarproduct_float"))
+        test_scalarproduct_float(src3, src4);
+    report("scalarproduct_float");
+
+    av_freep(&fdsp);
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/g722dsp.c b/mythtv/external/FFmpeg/tests/checkasm/g722dsp.c
new file mode 100644
index 00000000000..6bcff11e3de
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/g722dsp.c
@@ -0,0 +1,63 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 <string.h>
+#include "checkasm.h"
+#include "libavcodec/g722.h"
+#include "libavcodec/g722dsp.h"
+#include "libavcodec/mathops.h"
+
+#define randomize_buffers()                             \
+    do {                                                \
+        int i;                                          \
+        for (i = 0; i < PREV_SAMPLES_BUF_SIZE; i++) {   \
+            src0[i] = src1[i] = sign_extend(rnd(), 16); \
+        }                                               \
+    } while (0)
+
+static void check_qmf(void) {
+    int16_t src0[PREV_SAMPLES_BUF_SIZE];
+    int16_t src1[PREV_SAMPLES_BUF_SIZE];
+    const int16_t *tmp0 = src0;
+    const int16_t *tmp1 = src1;
+    int dst0[2], dst1[2];
+    int i;
+
+    declare_func(void, const int16_t *prev_samples, int xout[2]);
+
+    randomize_buffers();
+    for (i = 0; i < PREV_SAMPLES_BUF_SIZE - 24; i++) {
+        call_ref(tmp0++, dst0);
+        call_new(tmp1++, dst1);
+        if (memcmp(dst0, dst1, sizeof(dst0)))
+            fail();
+    }
+    bench_new(src1, dst1);
+}
+
+void checkasm_check_g722dsp(void)
+{
+    G722DSPContext h;
+
+    ff_g722dsp_init(&h);
+
+    if (check_func(h.apply_qmf, "g722_apply_qmf"))
+        check_qmf();
+
+    report("apply_qmf");
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/h264dsp.c b/mythtv/external/FFmpeg/tests/checkasm/h264dsp.c
index 2c2603b2cab..945423703f9 100644
--- a/mythtv/external/FFmpeg/tests/checkasm/h264dsp.c
+++ b/mythtv/external/FFmpeg/tests/checkasm/h264dsp.c
@@ -34,6 +34,7 @@ static const uint32_t pixel_mask[3] = { 0xffffffff, 0x01ff01ff, 0x03ff03ff };
 
 #define randomize_buffers()                                                  \
     do {                                                                     \
+        int x, y;                                                            \
         uint32_t mask = pixel_mask[bit_depth - 8];                           \
         for (y = 0; y < sz; y++) {                                           \
             for (x = 0; x < PIXEL_STRIDE; x += 4) {                          \
@@ -178,8 +179,7 @@ static void check_idct(void)
     LOCAL_ALIGNED_16(int16_t, subcoef0, [8 * 8 * 2]);
     LOCAL_ALIGNED_16(int16_t, subcoef1, [8 * 8 * 2]);
     H264DSPContext h;
-    int bit_depth, sz, align;
-    int x, y, dc;
+    int bit_depth, sz, align, dc;
     declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t *block, int stride);
 
     for (bit_depth = 8; bit_depth <= 10; bit_depth++) {
diff --git a/mythtv/external/FFmpeg/tests/checkasm/hevc_add_res.c b/mythtv/external/FFmpeg/tests/checkasm/hevc_add_res.c
new file mode 100644
index 00000000000..185656ae8c6
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/hevc_add_res.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2016 Alexandra Hájková
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 <string.h>
+
+#include "libavutil/intreadwrite.h"
+
+#include "libavcodec/hevcdsp.h"
+
+#include "checkasm.h"
+
+#define randomize_buffers(buf, size)            \
+    do {                                        \
+        int j;                                  \
+        for (j = 0; j < size; j++) {            \
+            int16_t r = rnd();                  \
+            AV_WN16A(buf + j, r >> 3);          \
+        }                                       \
+    } while (0)
+
+#define randomize_buffers2(buf, size)             \
+    do {                                          \
+        int j;                                    \
+        for (j = 0; j < size; j++)                \
+            AV_WN16A(buf + j * 2, rnd() & 0x3FF); \
+    } while (0)
+
+static void check_add_res(HEVCDSPContext h, int bit_depth)
+{
+    int i;
+    LOCAL_ALIGNED_32(int16_t, res0, [32 * 32]);
+    LOCAL_ALIGNED_32(int16_t, res1, [32 * 32]);
+    LOCAL_ALIGNED_32(uint8_t, dst0, [32 * 32 * 2]);
+    LOCAL_ALIGNED_32(uint8_t, dst1, [32 * 32 * 2]);
+
+    for (i = 2; i <= 5; i++) {
+        int block_size = 1 << i;
+        int size = block_size * block_size;
+        ptrdiff_t stride = block_size << (bit_depth > 8);
+        declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t *res, ptrdiff_t stride);
+
+        randomize_buffers(res0, size);
+        randomize_buffers2(dst0, size);
+        memcpy(res1, res0, sizeof(*res0) * size);
+        memcpy(dst1, dst0, sizeof(int16_t) * size);
+
+        if (check_func(h.add_residual[i - 2], "add_res_%dx%d_%d", block_size, block_size, bit_depth)) {
+            call_ref(dst0, res0, stride);
+            call_new(dst1, res1, stride);
+            if (memcmp(dst0, dst1, size))
+                fail();
+            bench_new(dst1, res1, stride);
+        }
+    }
+}
+
+void checkasm_check_hevc_add_res(void)
+{
+    int bit_depth;
+
+    for (bit_depth = 8; bit_depth <= 10; bit_depth++) {
+        HEVCDSPContext h;
+
+        ff_hevc_dsp_init(&h, bit_depth);
+        check_add_res(h, bit_depth);
+    }
+    report("add_residual");
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/hevc_idct.c b/mythtv/external/FFmpeg/tests/checkasm/hevc_idct.c
new file mode 100644
index 00000000000..eea712101d3
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/hevc_idct.c
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2016 Alexandra Hájková
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 <string.h>
+
+#include "libavutil/intreadwrite.h"
+
+#include "libavcodec/hevcdsp.h"
+
+#include "checkasm.h"
+
+#define randomize_buffers(buf, size)            \
+    do {                                        \
+        int j;                                  \
+        for (j = 0; j < size; j++) {            \
+            int16_t r = rnd();                  \
+            AV_WN16A(buf + j, r);               \
+        }                                       \
+    } while (0)
+
+static void check_idct(HEVCDSPContext h, int bit_depth)
+{
+    int i;
+    LOCAL_ALIGNED(32, int16_t, coeffs0, [32 * 32]);
+    LOCAL_ALIGNED(32, int16_t, coeffs1, [32 * 32]);
+
+    for (i = 2; i <= 5; i++) {
+        int block_size = 1 << i;
+        int size = block_size * block_size;
+        int col_limit = block_size;
+        declare_func(void, int16_t *coeffs, int col_limit);
+
+        randomize_buffers(coeffs0, size);
+        memcpy(coeffs1, coeffs0, sizeof(*coeffs0) * size);
+        if (check_func(h.idct[i - 2], "hevc_idct_%dx%d_%d", block_size, block_size, bit_depth)) {
+            call_ref(coeffs0, col_limit);
+            call_new(coeffs1, col_limit);
+            if (memcmp(coeffs0, coeffs1, sizeof(*coeffs0) * size))
+                fail();
+            bench_new(coeffs1, col_limit);
+        }
+    }
+}
+
+static void check_idct_dc(HEVCDSPContext h, int bit_depth)
+{
+    int i;
+    LOCAL_ALIGNED(32, int16_t, coeffs0, [32 * 32]);
+    LOCAL_ALIGNED(32, int16_t, coeffs1, [32 * 32]);
+
+    for (i = 2; i <= 5; i++) {
+        int block_size = 1 << i;
+        int size = block_size * block_size;
+        declare_func_emms(AV_CPU_FLAG_MMXEXT, void, int16_t *coeffs);
+
+        randomize_buffers(coeffs0, size);
+        memcpy(coeffs1, coeffs0, sizeof(*coeffs0) * size);
+
+        if (check_func(h.idct_dc[i - 2], "hevc_idct_%dx%d_dc_%d", block_size, block_size, bit_depth)) {
+            call_ref(coeffs0);
+            call_new(coeffs1);
+            if (memcmp(coeffs0, coeffs1, sizeof(*coeffs0) * size))
+                fail();
+            bench_new(coeffs1);
+        }
+    }
+}
+
+void checkasm_check_hevc_idct(void)
+{
+    int bit_depth;
+
+    for (bit_depth = 8; bit_depth <= 10; bit_depth++) {
+        HEVCDSPContext h;
+
+        ff_hevc_dsp_init(&h, bit_depth);
+        check_idct_dc(h, bit_depth);
+    }
+    report("idct_dc");
+
+    for (bit_depth = 8; bit_depth <= 10; bit_depth++) {
+        HEVCDSPContext h;
+
+        ff_hevc_dsp_init(&h, bit_depth);
+        check_idct(h, bit_depth);
+    }
+    report("idct");
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/llviddsp.c b/mythtv/external/FFmpeg/tests/checkasm/llviddsp.c
new file mode 100644
index 00000000000..b1f3b83b43b
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/llviddsp.c
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2016 Alexandra Hájková
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 <string.h>
+
+#include "libavutil/common.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/mem.h"
+
+#include "libavcodec/lossless_videodsp.h"
+
+#include "checkasm.h"
+
+#define randomize_buffers(buf, size)     \
+    do {                                 \
+        int j;                           \
+        for (j = 0; j < size; j++)       \
+            buf[j] = rnd() & 0xFF;       \
+    } while (0)
+
+static void check_add_bytes(LLVidDSPContext c, int width)
+{
+    uint8_t *src0 = av_mallocz(width);
+    uint8_t *src1 = av_mallocz(width);
+    uint8_t *dst0 = av_mallocz(width);
+    uint8_t *dst1 = av_mallocz(width);
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, uint8_t *src, ptrdiff_t w);
+
+    if (!src0 || !src1 || !dst0 || !dst1)
+        fail();
+
+    randomize_buffers(src0, width);
+    memcpy(src1, src0, width);
+
+    if (check_func(c.add_bytes, "add_bytes")) {
+        call_ref(dst0, src0, width);
+        call_new(dst1, src1, width);
+        if (memcmp(dst0, dst1, width))
+            fail();
+        bench_new(dst1, src1, width);
+    }
+
+    av_free(src0);
+    av_free(src1);
+    av_free(dst0);
+    av_free(dst1);
+}
+
+void checkasm_check_llviddsp(void)
+{
+    LLVidDSPContext c;
+    int width = 16 * av_clip(rnd(), 16, 128);
+
+    ff_llviddsp_init(&c);
+
+    check_add_bytes(c, width);
+
+    report("add_bytes");
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/pixblockdsp.c b/mythtv/external/FFmpeg/tests/checkasm/pixblockdsp.c
index 2b88e7d1aca..e14b0a90ded 100644
--- a/mythtv/external/FFmpeg/tests/checkasm/pixblockdsp.c
+++ b/mythtv/external/FFmpeg/tests/checkasm/pixblockdsp.c
@@ -64,7 +64,7 @@
 #define check_diff_pixels(type)                                                            \
     do {                                                                                   \
         int i;                                                                             \
-        declare_func_emms(AV_CPU_FLAG_MMX, void, int16_t *av_restrict block, const uint8_t *s1, const uint8_t *s2, int stride); \
+        declare_func_emms(AV_CPU_FLAG_MMX, void, int16_t *av_restrict block, const uint8_t *s1, const uint8_t *s2, ptrdiff_t stride); \
                                                                                            \
         for (i = 0; i < BUF_UNITS; i++) {                                              \
             int src_offset = i * 64 * sizeof(type) + 8 * i; /* Test various alignments */      \
diff --git a/mythtv/external/FFmpeg/tests/checkasm/sbrdsp.c b/mythtv/external/FFmpeg/tests/checkasm/sbrdsp.c
new file mode 100644
index 00000000000..558f452c9bd
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/sbrdsp.c
@@ -0,0 +1,298 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 "libavcodec/sbrdsp.h"
+
+#include "checkasm.h"
+
+#define randomize(buf, len) do {                                \
+    int i;                                                      \
+    for (i = 0; i < len; i++) {                                 \
+        const INTFLOAT f = (INTFLOAT)rnd() / UINT_MAX;          \
+        (buf)[i] = f;                                           \
+    }                                                           \
+} while (0)
+
+#define EPS 0.0001
+
+static void test_sum64x5(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [64 + 256]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [64 + 256]);
+
+    declare_func(void, INTFLOAT *z);
+
+    randomize((INTFLOAT *)dst0, 64 + 256);
+    memcpy(dst1, dst0, (64 + 256) * sizeof(INTFLOAT));
+    call_ref(dst0);
+    call_new(dst1);
+    if (!float_near_abs_eps_array(dst0, dst1, EPS, 64 + 256))
+        fail();
+    bench_new(dst1);
+}
+
+static void test_sum_square(void)
+{
+    INTFLOAT res0;
+    INTFLOAT res1;
+    LOCAL_ALIGNED_16(INTFLOAT, src, [256], [2]);
+
+    declare_func_float(INTFLOAT, INTFLOAT (*x)[2], int n);
+
+    randomize((INTFLOAT *)src, 256 * 2);
+    res0 = call_ref(src, 256);
+    res1 = call_new(src, 256);
+    if (!float_near_abs_eps(res0, res1, EPS))
+        fail();
+    bench_new(src, 256);
+}
+
+static void test_neg_odd_64(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [64]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [64]);
+
+    declare_func(void, INTFLOAT *x);
+
+    randomize((INTFLOAT *)dst0, 64);
+    memcpy(dst1, dst0, (64) * sizeof(INTFLOAT));
+    call_ref(dst0);
+    call_new(dst1);
+    if (!float_near_abs_eps_array(dst0, dst1, EPS, 64))
+        fail();
+    bench_new(dst1);
+}
+
+static void test_qmf_pre_shuffle(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [128]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [128]);
+
+    declare_func(void, INTFLOAT *z);
+
+    randomize((INTFLOAT *)dst0, 128);
+    memcpy(dst1, dst0, (128) * sizeof(INTFLOAT));
+    call_ref(dst0);
+    call_new(dst1);
+    if (!float_near_abs_eps_array(dst0, dst1, EPS, 128))
+        fail();
+    bench_new(dst1);
+}
+
+static void test_qmf_post_shuffle(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, src, [64]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [32], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [32], [2]);
+
+    declare_func(void, INTFLOAT W[32][2], const INTFLOAT *z);
+
+    randomize((INTFLOAT *)src, 64);
+    call_ref(dst0, src);
+    call_new(dst1, src);
+    if (!float_near_abs_eps_array((INTFLOAT *)dst0, (INTFLOAT *)dst1, EPS, 64))
+        fail();
+    bench_new(dst1, src);
+}
+
+static void test_qmf_deint_neg(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, src, [64]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [64]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [64]);
+
+    declare_func(void, INTFLOAT *v, const INTFLOAT *src);
+
+    randomize((INTFLOAT *)src, 64);
+    call_ref(dst0, src);
+    call_new(dst1, src);
+    if (!float_near_abs_eps_array(dst0, dst1, EPS, 64))
+        fail();
+    bench_new(dst1, src);
+}
+
+static void test_qmf_deint_bfly(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, src0, [64]);
+    LOCAL_ALIGNED_16(INTFLOAT, src1, [64]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [128]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [128]);
+
+    declare_func(void, INTFLOAT *v, const INTFLOAT *src0, const INTFLOAT *src1);
+
+    memset(dst0, 0, 128 * sizeof(INTFLOAT));
+    memset(dst1, 0, 128 * sizeof(INTFLOAT));
+
+    randomize((INTFLOAT *)src0, 64);
+    randomize((INTFLOAT *)src1, 64);
+    call_ref(dst0, src0, src1);
+    call_new(dst1, src0, src1);
+    if (!float_near_abs_eps_array(dst0, dst1, EPS, 128))
+        fail();
+    bench_new(dst1, src0, src1);
+}
+
+static void test_autocorrelate(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, src, [40], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [3], [2][2]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [3], [2][2]);
+
+    declare_func(void, const INTFLOAT x[40][2], INTFLOAT phi[3][2][2]);
+
+    memset(dst0, 0, 3 * 2 * 2 * sizeof(INTFLOAT));
+    memset(dst1, 0, 3 * 2 * 2 * sizeof(INTFLOAT));
+
+    randomize((INTFLOAT *)src, 80);
+    call_ref(src, dst0);
+    call_new(src, dst1);
+    if (!float_near_abs_eps_array((INTFLOAT *)dst0, (INTFLOAT *)dst1, EPS, 3 * 2 * 2))
+        fail();
+    bench_new(src, dst1);
+}
+
+static void test_hf_gen(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, low, [128], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, alpha0, [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, alpha1, [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [128], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [128], [2]);
+    INTFLOAT bw = (INTFLOAT)rnd() / UINT_MAX;
+    int i;
+
+    declare_func(void, INTFLOAT (*X_high)[2], const INTFLOAT (*X_low)[2],
+                       const INTFLOAT alpha0[2], const INTFLOAT alpha1[2],
+                       INTFLOAT bw, int start, int end);
+
+    randomize((INTFLOAT *)low, 128 * 2);
+    randomize((INTFLOAT *)alpha0, 2);
+    randomize((INTFLOAT *)alpha1, 2);
+    for (i = 2; i < 64; i += 2) {
+        memset(dst0, 0, 128 * 2 * sizeof(INTFLOAT));
+        memset(dst1, 0, 128 * 2 * sizeof(INTFLOAT));
+        call_ref(dst0, low, alpha0, alpha1, 0.0, i, 128);
+        call_new(dst1, low, alpha0, alpha1, 0.0, i, 128);
+        if (!float_near_abs_eps_array((INTFLOAT *)dst0, (INTFLOAT *)dst1, EPS, 128 * 2))
+            fail();
+        bench_new(dst1, low, alpha0, alpha1, bw, i, 128);
+    }
+}
+
+static void test_hf_g_filt(void)
+{
+    LOCAL_ALIGNED_16(INTFLOAT, high, [128], [40][2]);
+    LOCAL_ALIGNED_16(INTFLOAT, g_filt, [128]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [128], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [128], [2]);
+
+    declare_func(void, INTFLOAT (*Y)[2], const INTFLOAT (*X_high)[40][2],
+                       const INTFLOAT *g_filt, int m_max, intptr_t ixh);
+
+    randomize((INTFLOAT *)high, 128 * 40 * 2);
+    randomize((INTFLOAT *)g_filt, 128);
+
+    call_ref(dst0, high, g_filt, 128, 20);
+    call_new(dst1, high, g_filt, 128, 20);
+    if (!float_near_abs_eps_array((INTFLOAT *)dst0, (INTFLOAT *)dst1, EPS, 128 * 2))
+        fail();
+    bench_new(dst1, high, g_filt, 128, 20);
+}
+
+static void test_hf_apply_noise(const SBRDSPContext *sbrdsp)
+{
+    LOCAL_ALIGNED_16(AAC_FLOAT, s_m, [128]);
+    LOCAL_ALIGNED_16(AAC_FLOAT, q_filt, [128]);
+    LOCAL_ALIGNED_16(INTFLOAT, ref, [128], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst0, [128], [2]);
+    LOCAL_ALIGNED_16(INTFLOAT, dst1, [128], [2]);
+    int noise = 0x2a;
+    int i, j;
+
+    declare_func(void, INTFLOAT (*Y)[2], const AAC_FLOAT *s_m,
+                       const AAC_FLOAT *q_filt, int noise,
+                       int kx, int m_max);
+
+    randomize((INTFLOAT *)ref, 128 * 2);
+    randomize((INTFLOAT *)s_m, 128);
+    randomize((INTFLOAT *)q_filt, 128);
+
+    for (i = 0; i < 4; i++) {
+        if (check_func(sbrdsp->hf_apply_noise[i], "hf_apply_noise_%d", i)) {
+            for (j = 0; j < 2; j++) {
+                memcpy(dst0, ref, 128 * 2 * sizeof(INTFLOAT));
+                memcpy(dst1, ref, 128 * 2 * sizeof(INTFLOAT));
+                call_ref(dst0, s_m, q_filt, noise, j, 128);
+                call_new(dst1, s_m, q_filt, noise, j, 128);
+                if (!float_near_abs_eps_array((INTFLOAT *)dst0, (INTFLOAT *)dst1, EPS, 128 * 2))
+                    fail();
+                bench_new(dst1, s_m, q_filt, noise, j, 128);
+            }
+        }
+    }
+}
+
+void checkasm_check_sbrdsp(void)
+{
+    SBRDSPContext sbrdsp;
+
+    ff_sbrdsp_init(&sbrdsp);
+
+    if (check_func(sbrdsp.sum64x5, "sum64x5"))
+        test_sum64x5();
+    report("sum64x5");
+
+    if (check_func(sbrdsp.sum_square, "sum_square"))
+        test_sum_square();
+    report("sum_square");
+
+    if (check_func(sbrdsp.neg_odd_64, "neg_odd_64"))
+        test_neg_odd_64();
+    report("neg_odd_64");
+
+    if (check_func(sbrdsp.qmf_pre_shuffle, "qmf_pre_shuffle"))
+        test_qmf_pre_shuffle();
+    report("qmf_pre_shuffle");
+
+    if (check_func(sbrdsp.qmf_post_shuffle, "qmf_post_shuffle"))
+        test_qmf_post_shuffle();
+    report("qmf_post_shuffle");
+
+    if (check_func(sbrdsp.qmf_deint_neg, "qmf_deint_neg"))
+        test_qmf_deint_neg();
+    report("qmf_deint_neg");
+
+    if (check_func(sbrdsp.qmf_deint_bfly, "qmf_deint_bfly"))
+        test_qmf_deint_bfly();
+    report("qmf_deint_bfly");
+
+    if (check_func(sbrdsp.autocorrelate, "autocorrelate"))
+        test_autocorrelate();
+    report("autocorrelate");
+
+    if (check_func(sbrdsp.hf_gen, "hf_gen"))
+        test_hf_gen();
+    report("hf_gen");
+
+    if (check_func(sbrdsp.hf_g_filt, "hf_g_filt"))
+        test_hf_g_filt();
+    report("hf_g_filt");
+
+    test_hf_apply_noise(&sbrdsp);
+    report("hf_apply_noise");
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/vf_blend.c b/mythtv/external/FFmpeg/tests/checkasm/vf_blend.c
index aa568c0de01..be657304528 100644
--- a/mythtv/external/FFmpeg/tests/checkasm/vf_blend.c
+++ b/mythtv/external/FFmpeg/tests/checkasm/vf_blend.c
@@ -103,11 +103,11 @@ void checkasm_check_blend(void)
         check_blend_func();
 
     check_and_report(addition, BLEND_ADDITION)
-    check_and_report(addition128, BLEND_ADDITION128)
+    check_and_report(grainmerge, BLEND_GRAINMERGE)
     check_and_report(and, BLEND_AND)
     check_and_report(average, BLEND_AVERAGE)
     check_and_report(darken, BLEND_DARKEN)
-    check_and_report(difference128, BLEND_DIFFERENCE128)
+    check_and_report(grainextract, BLEND_GRAINEXTRACT)
     check_and_report(hardmix, BLEND_HARDMIX)
     check_and_report(lighten, BLEND_LIGHTEN)
     check_and_report(multiply, BLEND_MULTIPLY)
@@ -117,6 +117,7 @@ void checkasm_check_blend(void)
     check_and_report(subtract, BLEND_SUBTRACT)
     check_and_report(xor, BLEND_XOR)
     check_and_report(difference, BLEND_DIFFERENCE)
+    check_and_report(extremity, BLEND_EXTREMITY)
     check_and_report(negation, BLEND_NEGATION)
 
     report("8bit");
diff --git a/mythtv/external/FFmpeg/tests/checkasm/vp8dsp.c b/mythtv/external/FFmpeg/tests/checkasm/vp8dsp.c
new file mode 100644
index 00000000000..d93f73087f0
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/checkasm/vp8dsp.c
@@ -0,0 +1,519 @@
+/*
+ * Copyright (c) 2016 Martin Storsjo
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 <string.h>
+
+#include "libavcodec/avcodec.h"
+#include "libavcodec/vp8dsp.h"
+
+#include "libavutil/common.h"
+#include "libavutil/intreadwrite.h"
+
+#include "checkasm.h"
+
+#define PIXEL_STRIDE 16
+
+#define randomize_buffers(src, dst, stride, coef)                            \
+    do {                                                                     \
+        int x, y;                                                            \
+        for (y = 0; y < 4; y++) {                                            \
+            AV_WN32A((src) + y * (stride), rnd());                           \
+            AV_WN32A((dst) + y * (stride), rnd());                           \
+            for (x = 0; x < 4; x++)                                          \
+                (coef)[y * 4 + x] = (src)[y * (stride) + x] -                \
+                                    (dst)[y * (stride) + x];                 \
+        }                                                                    \
+    } while (0)
+
+static void dct4x4(int16_t *coef)
+{
+    int i;
+    for (i = 0; i < 4; i++) {
+        const int a1 = (coef[i*4 + 0] + coef[i*4 + 3]) * 8;
+        const int b1 = (coef[i*4 + 1] + coef[i*4 + 2]) * 8;
+        const int c1 = (coef[i*4 + 1] - coef[i*4 + 2]) * 8;
+        const int d1 = (coef[i*4 + 0] - coef[i*4 + 3]) * 8;
+        coef[i*4 + 0] =  a1 + b1;
+        coef[i*4 + 1] = (c1 * 2217 + d1 * 5352 + 14500) >> 12;
+        coef[i*4 + 2] =  a1 - b1;
+        coef[i*4 + 3] = (d1 * 2217 - c1 * 5352 +  7500) >> 12;
+    }
+    for (i = 0; i < 4; i++) {
+        const int a1 = coef[i + 0*4] + coef[i + 3*4];
+        const int b1 = coef[i + 1*4] + coef[i + 2*4];
+        const int c1 = coef[i + 1*4] - coef[i + 2*4];
+        const int d1 = coef[i + 0*4] - coef[i + 3*4];
+        coef[i + 0*4] =  (a1 + b1 + 7) >> 4;
+        coef[i + 1*4] = ((c1 * 2217 + d1 * 5352 + 12000) >> 16) + !!d1;
+        coef[i + 2*4] =  (a1 - b1 + 7) >> 4;
+        coef[i + 3*4] =  (d1 * 2217 - c1 * 5352 + 51000) >> 16;
+    }
+}
+
+static void wht4x4(int16_t *coef)
+{
+    int i;
+    for (i = 0; i < 4; i++) {
+        int a1 = coef[0 * 4 + i];
+        int b1 = coef[1 * 4 + i];
+        int c1 = coef[2 * 4 + i];
+        int d1 = coef[3 * 4 + i];
+        int e1;
+        a1 += b1;
+        d1 -= c1;
+        e1 = (a1 - d1) >> 1;
+        b1 = e1 - b1;
+        c1 = e1 - c1;
+        a1 -= c1;
+        d1 += b1;
+        coef[0 * 4 + i] = a1;
+        coef[1 * 4 + i] = c1;
+        coef[2 * 4 + i] = d1;
+        coef[3 * 4 + i] = b1;
+    }
+    for (i = 0; i < 4; i++) {
+        int a1 = coef[i * 4 + 0];
+        int b1 = coef[i * 4 + 1];
+        int c1 = coef[i * 4 + 2];
+        int d1 = coef[i * 4 + 3];
+        int e1;
+        a1 += b1;
+        d1 -= c1;
+        e1 = (a1 - d1) >> 1;
+        b1 = e1 - b1;
+        c1 = e1 - c1;
+        a1 -= c1;
+        d1 += b1;
+        coef[i * 4 + 0] = a1 * 2;
+        coef[i * 4 + 1] = c1 * 2;
+        coef[i * 4 + 2] = d1 * 2;
+        coef[i * 4 + 3] = b1 * 2;
+    }
+}
+
+static void check_idct(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, src,  [4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst,  [4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst0, [4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst1, [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, coef, [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, subcoef0, [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, subcoef1, [4 * 4]);
+    VP8DSPContext d;
+    int dc;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t *block, ptrdiff_t stride);
+
+    ff_vp8dsp_init(&d);
+    randomize_buffers(src, dst, 4, coef);
+
+    dct4x4(coef);
+
+    for (dc = 0; dc <= 1; dc++) {
+        void (*idct)(uint8_t *, int16_t *, ptrdiff_t) = dc ? d.vp8_idct_dc_add : d.vp8_idct_add;
+
+        if (check_func(idct, "vp8_idct_%sadd", dc ? "dc_" : "")) {
+            if (dc) {
+                memset(subcoef0, 0, 4 * 4 * sizeof(int16_t));
+                subcoef0[0] = coef[0];
+            } else {
+                memcpy(subcoef0, coef, 4 * 4 * sizeof(int16_t));
+            }
+            memcpy(dst0, dst, 4 * 4);
+            memcpy(dst1, dst, 4 * 4);
+            memcpy(subcoef1, subcoef0, 4 * 4 * sizeof(int16_t));
+            // Note, this uses a pixel stride of 4, even though the real decoder uses a stride as a
+            // multiple of 16. If optimizations want to take advantage of that, this test needs to be
+            // updated to make it more like the h264dsp tests.
+            call_ref(dst0, subcoef0, 4);
+            call_new(dst1, subcoef1, 4);
+            if (memcmp(dst0, dst1, 4 * 4) ||
+                memcmp(subcoef0, subcoef1, 4 * 4 * sizeof(int16_t)))
+                fail();
+
+            bench_new(dst1, subcoef1, 4);
+        }
+    }
+}
+
+static void check_idct_dc4(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, src,  [4 * 4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst,  [4 * 4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst0, [4 * 4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst1, [4 * 4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, coef, [4], [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, subcoef0, [4], [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, subcoef1, [4], [4 * 4]);
+    VP8DSPContext d;
+    int i, chroma;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t block[4][16], ptrdiff_t stride);
+
+    ff_vp8dsp_init(&d);
+
+    for (chroma = 0; chroma <= 1; chroma++) {
+        void (*idct4dc)(uint8_t *, int16_t[4][16], ptrdiff_t) = chroma ? d.vp8_idct_dc_add4uv : d.vp8_idct_dc_add4y;
+        if (check_func(idct4dc, "vp8_idct_dc_add4%s", chroma ? "uv" : "y")) {
+            ptrdiff_t stride = chroma ? 8 : 16;
+            int w      = chroma ? 2 : 4;
+            for (i = 0; i < 4; i++) {
+                int blockx = 4 * (i % w);
+                int blocky = 4 * (i / w);
+                randomize_buffers(src + stride * blocky + blockx, dst + stride * blocky + blockx, stride, coef[i]);
+                dct4x4(coef[i]);
+                memset(&coef[i][1], 0, 15 * sizeof(int16_t));
+            }
+
+            memcpy(dst0, dst, 4 * 4 * 4);
+            memcpy(dst1, dst, 4 * 4 * 4);
+            memcpy(subcoef0, coef, 4 * 4 * 4 * sizeof(int16_t));
+            memcpy(subcoef1, coef, 4 * 4 * 4 * sizeof(int16_t));
+            call_ref(dst0, subcoef0, stride);
+            call_new(dst1, subcoef1, stride);
+            if (memcmp(dst0, dst1, 4 * 4 * 4) ||
+                memcmp(subcoef0, subcoef1, 4 * 4 * 4 * sizeof(int16_t)))
+                fail();
+            bench_new(dst1, subcoef1, stride);
+        }
+    }
+
+}
+
+static void check_luma_dc_wht(void)
+{
+    LOCAL_ALIGNED_16(int16_t, dc, [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, dc0, [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, dc1, [4 * 4]);
+    int16_t block[4][4][16];
+    LOCAL_ALIGNED_16(int16_t, block0, [4], [4][16]);
+    LOCAL_ALIGNED_16(int16_t, block1, [4], [4][16]);
+    VP8DSPContext d;
+    int dc_only;
+    int blockx, blocky;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, int16_t block[4][4][16], int16_t dc[16]);
+
+    ff_vp8dsp_init(&d);
+
+    for (blocky = 0; blocky < 4; blocky++) {
+        for (blockx = 0; blockx < 4; blockx++) {
+            uint8_t src[16], dst[16];
+            randomize_buffers(src, dst, 4, block[blocky][blockx]);
+
+            dct4x4(block[blocky][blockx]);
+            dc[blocky * 4 + blockx] = block[blocky][blockx][0];
+            block[blocky][blockx][0] = rnd();
+        }
+    }
+    wht4x4(dc);
+
+    for (dc_only = 0; dc_only <= 1; dc_only++) {
+        void (*idct)(int16_t [4][4][16], int16_t [16]) = dc_only ? d.vp8_luma_dc_wht_dc : d.vp8_luma_dc_wht;
+
+        if (check_func(idct, "vp8_luma_dc_wht%s", dc_only ? "_dc" : "")) {
+            if (dc_only) {
+                memset(dc0, 0, 16 * sizeof(int16_t));
+                dc0[0] = dc[0];
+            } else {
+                memcpy(dc0, dc, 16 * sizeof(int16_t));
+            }
+            memcpy(dc1, dc0, 16 * sizeof(int16_t));
+            memcpy(block0, block, 4 * 4 * 16 * sizeof(int16_t));
+            memcpy(block1, block, 4 * 4 * 16 * sizeof(int16_t));
+            call_ref(block0, dc0);
+            call_new(block1, dc1);
+            if (memcmp(block0, block1, 4 * 4 * 16 * sizeof(int16_t)) ||
+                memcmp(dc0, dc1, 16 * sizeof(int16_t)))
+                fail();
+            bench_new(block1, dc1);
+        }
+    }
+}
+
+#define SRC_BUF_STRIDE 32
+#define SRC_BUF_SIZE (((size << (size < 16)) + 5) * SRC_BUF_STRIDE)
+// The mc subpixel interpolation filter needs the 2 previous pixels in either
+// direction, the +1 is to make sure the actual load addresses always are
+// unaligned.
+#define src (buf + 2 * SRC_BUF_STRIDE + 2 + 1)
+
+#undef randomize_buffers
+#define randomize_buffers()                               \
+    do {                                                  \
+        int k;                                            \
+        for (k = 0; k < SRC_BUF_SIZE; k += 4) {           \
+            AV_WN32A(buf + k, rnd());                     \
+        }                                                 \
+    } while (0)
+
+static void check_mc(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, buf, [32 * 32]);
+    LOCAL_ALIGNED_16(uint8_t, dst0, [16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, dst1, [16 * 16]);
+    VP8DSPContext d;
+    int type, k, dx, dy;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, uint8_t *, ptrdiff_t, int, int, int);
+
+    ff_vp78dsp_init(&d);
+
+    for (type = 0; type < 2; type++) {
+        vp8_mc_func (*tab)[3][3] = type ? d.put_vp8_bilinear_pixels_tab : d.put_vp8_epel_pixels_tab;
+        for (k = 1; k < 8; k++) {
+            int hsize  = k / 3;
+            int size   = 16 >> hsize;
+            int height = (size << 1) >> (k % 3);
+            for (dy = 0; dy < 3; dy++) {
+                for (dx = 0; dx < 3; dx++) {
+                    char str[100];
+                    if (dx || dy) {
+                        if (type == 0) {
+                            static const char *dx_names[] = { "", "h4", "h6" };
+                            static const char *dy_names[] = { "", "v4", "v6" };
+                            snprintf(str, sizeof(str), "epel%d_%s%s", size, dx_names[dx], dy_names[dy]);
+                        } else {
+                            snprintf(str, sizeof(str), "bilin%d_%s%s", size, dx ? "h" : "", dy ? "v" : "");
+                        }
+                    } else {
+                        snprintf(str, sizeof(str), "pixels%d", size);
+                    }
+                    if (check_func(tab[hsize][dy][dx], "vp8_put_%s", str)) {
+                        int mx, my;
+                        int i;
+                        if (type == 0) {
+                            mx = dx == 2 ? 2 + 2 * (rnd() % 3) : dx == 1 ? 1 + 2 * (rnd() % 4) : 0;
+                            my = dy == 2 ? 2 + 2 * (rnd() % 3) : dy == 1 ? 1 + 2 * (rnd() % 4) : 0;
+                        } else {
+                            mx = dx ? 1 + (rnd() % 7) : 0;
+                            my = dy ? 1 + (rnd() % 7) : 0;
+                        }
+                        randomize_buffers();
+                        for (i = -2; i <= 3; i++) {
+                            int val = (i == -1 || i == 2) ? 0 : 0xff;
+                            // Set pixels in the first row and column to the maximum pattern,
+                            // to test for potential overflows in the filter.
+                            src[i                 ] = val;
+                            src[i * SRC_BUF_STRIDE] = val;
+                        }
+                        call_ref(dst0, size, src, SRC_BUF_STRIDE, height, mx, my);
+                        call_new(dst1, size, src, SRC_BUF_STRIDE, height, mx, my);
+                        if (memcmp(dst0, dst1, size * height))
+                            fail();
+                        bench_new(dst1, size, src, SRC_BUF_STRIDE, height, mx, my);
+                    }
+                }
+            }
+        }
+    }
+}
+
+#undef randomize_buffers
+
+#define setpx(a, b, c) buf[(a) + (b) * jstride] = av_clip_uint8(c)
+// Set the pixel to c +/- [0,d]
+#define setdx(a, b, c, d) setpx(a, b, c - (d) + (rnd() % ((d) * 2 + 1)))
+// Set the pixel to c +/- [d,d+e] (making sure it won't be clipped)
+#define setdx2(a, b, o, c, d, e) setpx(a, b, o = c + ((d) + (rnd() % (e))) * (c >= 128 ? -1 : 1))
+
+static void randomize_loopfilter_buffers(int lineoff, int str,
+                                         int dir, int flim_E, int flim_I,
+                                         int hev_thresh, uint8_t *buf,
+                                         int force_hev)
+{
+    uint32_t mask = 0xff;
+    int off = dir ? lineoff : lineoff * str;
+    int istride = dir ? 1 : str;
+    int jstride = dir ? str : 1;
+    int i;
+    for (i = 0; i < 8; i += 2) {
+        // Row 0 will trigger hev for q0/q1, row 2 will trigger hev for p0/p1,
+        // rows 4 and 6 will not trigger hev.
+        // force_hev 1 will make sure all rows trigger hev, while force_hev -1
+        // makes none of them trigger it.
+        int idx = off + i * istride, p2, p1, p0, q0, q1, q2;
+        setpx(idx,  0, q0 = rnd() & mask);
+        if (i == 0 && force_hev >= 0 || force_hev > 0)
+            setdx2(idx, 1, q1, q0, hev_thresh + 1, flim_I - hev_thresh - 1);
+        else
+            setdx(idx,  1, q1 = q0, hev_thresh);
+        setdx(idx,  2, q2 = q1, flim_I);
+        setdx(idx,  3, q2,      flim_I);
+        setdx(idx, -1, p0 = q0, flim_E >> 2);
+        if (i == 2 && force_hev >= 0 || force_hev > 0)
+            setdx2(idx, -2, p1, p0, hev_thresh + 1, flim_I - hev_thresh - 1);
+        else
+            setdx(idx, -2, p1 = p0, hev_thresh);
+        setdx(idx, -3, p2 = p1, flim_I);
+        setdx(idx, -4, p2,      flim_I);
+    }
+}
+
+// Fill the buffer with random pixels
+static void fill_loopfilter_buffers(uint8_t *buf, ptrdiff_t stride, int w, int h)
+{
+    int x, y;
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            buf[y * stride + x] = rnd() & 0xff;
+}
+
+#define randomize_buffers(buf, lineoff, str, force_hev) \
+    randomize_loopfilter_buffers(lineoff, str, dir, flim_E, flim_I, hev_thresh, buf, force_hev)
+
+static void check_loopfilter_16y(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, base0, [32 + 16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, base1, [32 + 16 * 16]);
+    VP8DSPContext d;
+    int dir, edge, force_hev;
+    int flim_E = 20, flim_I = 10, hev_thresh = 7;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, int, int, int);
+
+    ff_vp8dsp_init(&d);
+
+    for (dir = 0; dir < 2; dir++) {
+        int midoff = dir ? 4 * 16 : 4;
+        int midoff_aligned = dir ? 4 * 16 : 16;
+        uint8_t *buf0 = base0 + midoff_aligned;
+        uint8_t *buf1 = base1 + midoff_aligned;
+        for (edge = 0; edge < 2; edge++) {
+            void (*func)(uint8_t *, ptrdiff_t, int, int, int) = NULL;
+            switch (dir << 1 | edge) {
+            case (0 << 1) | 0: func = d.vp8_h_loop_filter16y; break;
+            case (1 << 1) | 0: func = d.vp8_v_loop_filter16y; break;
+            case (0 << 1) | 1: func = d.vp8_h_loop_filter16y_inner; break;
+            case (1 << 1) | 1: func = d.vp8_v_loop_filter16y_inner; break;
+            }
+            if (check_func(func, "vp8_loop_filter16y%s_%s", edge ? "_inner" : "", dir ? "v" : "h")) {
+                for (force_hev = -1; force_hev <= 1; force_hev++) {
+                    fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
+                    randomize_buffers(buf0, 0, 16, force_hev);
+                    randomize_buffers(buf0, 8, 16, force_hev);
+                    memcpy(buf1 - midoff, buf0 - midoff, 16 * 16);
+                    call_ref(buf0, 16, flim_E, flim_I, hev_thresh);
+                    call_new(buf1, 16, flim_E, flim_I, hev_thresh);
+                    if (memcmp(buf0 - midoff, buf1 - midoff, 16 * 16))
+                        fail();
+                }
+                fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
+                randomize_buffers(buf0, 0, 16, 0);
+                randomize_buffers(buf0, 8, 16, 0);
+                bench_new(buf0, 16, flim_E, flim_I, hev_thresh);
+            }
+        }
+    }
+}
+
+static void check_loopfilter_8uv(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, base0u, [32 + 16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, base0v, [32 + 16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, base1u, [32 + 16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, base1v, [32 + 16 * 16]);
+    VP8DSPContext d;
+    int dir, edge, force_hev;
+    int flim_E = 20, flim_I = 10, hev_thresh = 7;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, uint8_t *, ptrdiff_t, int, int, int);
+
+    ff_vp8dsp_init(&d);
+
+    for (dir = 0; dir < 2; dir++) {
+        int midoff = dir ? 4 * 16 : 4;
+        int midoff_aligned = dir ? 4 * 16 : 16;
+        uint8_t *buf0u = base0u + midoff_aligned;
+        uint8_t *buf0v = base0v + midoff_aligned;
+        uint8_t *buf1u = base1u + midoff_aligned;
+        uint8_t *buf1v = base1v + midoff_aligned;
+        for (edge = 0; edge < 2; edge++) {
+            void (*func)(uint8_t *, uint8_t *, ptrdiff_t, int, int, int) = NULL;
+            switch (dir << 1 | edge) {
+            case (0 << 1) | 0: func = d.vp8_h_loop_filter8uv; break;
+            case (1 << 1) | 0: func = d.vp8_v_loop_filter8uv; break;
+            case (0 << 1) | 1: func = d.vp8_h_loop_filter8uv_inner; break;
+            case (1 << 1) | 1: func = d.vp8_v_loop_filter8uv_inner; break;
+            }
+            if (check_func(func, "vp8_loop_filter8uv%s_%s", edge ? "_inner" : "", dir ? "v" : "h")) {
+                for (force_hev = -1; force_hev <= 1; force_hev++) {
+                    fill_loopfilter_buffers(buf0u - midoff, 16, 16, 16);
+                    fill_loopfilter_buffers(buf0v - midoff, 16, 16, 16);
+                    randomize_buffers(buf0u, 0, 16, force_hev);
+                    randomize_buffers(buf0v, 0, 16, force_hev);
+                    memcpy(buf1u - midoff, buf0u - midoff, 16 * 16);
+                    memcpy(buf1v - midoff, buf0v - midoff, 16 * 16);
+
+                    call_ref(buf0u, buf0v, 16, flim_E, flim_I, hev_thresh);
+                    call_new(buf1u, buf1v, 16, flim_E, flim_I, hev_thresh);
+                    if (memcmp(buf0u - midoff, buf1u - midoff, 16 * 16) ||
+                        memcmp(buf0v - midoff, buf1v - midoff, 16 * 16))
+                        fail();
+                }
+                fill_loopfilter_buffers(buf0u - midoff, 16, 16, 16);
+                fill_loopfilter_buffers(buf0v - midoff, 16, 16, 16);
+                randomize_buffers(buf0u, 0, 16, 0);
+                randomize_buffers(buf0v, 0, 16, 0);
+                bench_new(buf0u, buf0v, 16, flim_E, flim_I, hev_thresh);
+            }
+        }
+    }
+}
+
+static void check_loopfilter_simple(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, base0, [32 + 16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, base1, [32 + 16 * 16]);
+    VP8DSPContext d;
+    int dir;
+    int flim_E = 20, flim_I = 30, hev_thresh = 0;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, int);
+
+    ff_vp8dsp_init(&d);
+
+    for (dir = 0; dir < 2; dir++) {
+        int midoff = dir ? 4 * 16 : 4;
+        int midoff_aligned = dir ? 4 * 16 : 16;
+        uint8_t *buf0 = base0 + midoff_aligned;
+        uint8_t *buf1 = base1 + midoff_aligned;
+        void (*func)(uint8_t *, ptrdiff_t, int) = dir ? d.vp8_v_loop_filter_simple : d.vp8_h_loop_filter_simple;
+        if (check_func(func, "vp8_loop_filter_simple_%s", dir ? "v" : "h")) {
+            fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
+            randomize_buffers(buf0, 0, 16, -1);
+            randomize_buffers(buf0, 8, 16, -1);
+            memcpy(buf1 - midoff, buf0 - midoff, 16 * 16);
+            call_ref(buf0, 16, flim_E);
+            call_new(buf1, 16, flim_E);
+            if (memcmp(buf0 - midoff, buf1 - midoff, 16 * 16))
+                fail();
+            bench_new(buf0, 16, flim_E);
+        }
+    }
+}
+
+void checkasm_check_vp8dsp(void)
+{
+    check_idct();
+    check_idct_dc4();
+    check_luma_dc_wht();
+    report("idct");
+    check_mc();
+    report("mc");
+    check_loopfilter_16y();
+    check_loopfilter_8uv();
+    check_loopfilter_simple();
+    report("loopfilter");
+}
diff --git a/mythtv/external/FFmpeg/tests/checkasm/vp9dsp.c b/mythtv/external/FFmpeg/tests/checkasm/vp9dsp.c
index 441041c2b0e..a91577b94ed 100644
--- a/mythtv/external/FFmpeg/tests/checkasm/vp9dsp.c
+++ b/mythtv/external/FFmpeg/tests/checkasm/vp9dsp.c
@@ -22,7 +22,7 @@
 #include <string.h>
 #include "checkasm.h"
 #include "libavcodec/vp9data.h"
-#include "libavcodec/vp9dsp.h"
+#include "libavcodec/vp9.h"
 #include "libavutil/common.h"
 #include "libavutil/internal.h"
 #include "libavutil/intreadwrite.h"
@@ -259,7 +259,7 @@ static int copy_subcoefs(int16_t *out, const int16_t *in, enum TxfmMode tx,
     // test
 
     int n;
-    const int16_t *scan = vp9_scans[tx][txtp];
+    const int16_t *scan = ff_vp9_scans[tx][txtp];
     int eob;
 
     for (n = 0; n < sz * sz; n++) {
@@ -331,15 +331,22 @@ static void check_itxfm(void)
             int n_txtps = tx < TX_32X32 ? N_TXFM_TYPES : 1;
 
             for (txtp = 0; txtp < n_txtps; txtp++) {
-                if (check_func(dsp.itxfm_add[tx][txtp], "vp9_inv_%s_%dx%d_add_%d",
-                               tx == 4 ? "wht_wht" : txtp_types[txtp], sz, sz,
-                               bit_depth)) {
-                    randomize_buffers();
-                    ftx(coef, tx, txtp, sz, bit_depth);
-
-                    for (sub = (txtp == 0) ? 1 : 2; sub <= sz; sub <<= 1) {
+                // skip testing sub-IDCTs for WHT or ADST since they don't
+                // implement it in any of the SIMD functions. If they do,
+                // consider changing this to ensure we have complete test
+                // coverage. Test sub=1 for dc-only, then 2, 4, 8, 12, etc,
+                // since the arm version can distinguish them at that level.
+                for (sub = (txtp == 0 && tx < 4) ? 1 : sz; sub <= sz;
+                     sub < 4 ? (sub <<= 1) : (sub += 4)) {
+                    if (check_func(dsp.itxfm_add[tx][txtp],
+                                   "vp9_inv_%s_%dx%d_sub%d_add_%d",
+                                   tx == 4 ? "wht_wht" : txtp_types[txtp],
+                                   sz, sz, sub, bit_depth)) {
                         int eob;
 
+                        randomize_buffers();
+                        ftx(coef, tx, txtp, sz, bit_depth);
+
                         if (sub < sz) {
                             eob = copy_subcoefs(subcoef0, coef, tx, txtp,
                                                 sz, sub, bit_depth);
@@ -357,8 +364,9 @@ static void check_itxfm(void)
                             !iszero(subcoef0, sz * sz * SIZEOF_COEF) ||
                             !iszero(subcoef1, sz * sz * SIZEOF_COEF))
                             fail();
+
+                        bench_new(dst, sz * SIZEOF_PIXEL, coef, eob);
                     }
-                    bench_new(dst, sz * SIZEOF_PIXEL, coef, sz * sz);
                 }
             }
         }
diff --git a/mythtv/external/FFmpeg/tests/checkasm/x86/Makefile b/mythtv/external/FFmpeg/tests/checkasm/x86/Makefile
deleted file mode 100644
index befe088dcfb..00000000000
--- a/mythtv/external/FFmpeg/tests/checkasm/x86/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-CHECKASMOBJS-$(HAVE_YASM) += x86/checkasm.o
-
-tests/checkasm/x86/%.o: tests/checkasm/x86/%.asm
-	$(DEPYASM) $(YASMFLAGS) -I $(<D)/ -M -o $@ $< > $(@:.o=.d)
-	$(YASM) $(YASMFLAGS) -I $(<D)/ -o $@ $<
-	-$(STRIP) $(ASMSTRIPFLAGS) $@
diff --git a/mythtv/external/FFmpeg/tests/checkasm/x86/checkasm.asm b/mythtv/external/FFmpeg/tests/checkasm/x86/checkasm.asm
index d12333b3087..683aae80e36 100644
--- a/mythtv/external/FFmpeg/tests/checkasm/x86/checkasm.asm
+++ b/mythtv/external/FFmpeg/tests/checkasm/x86/checkasm.asm
@@ -169,15 +169,15 @@ cglobal checked_call%1, 2,15,16,max_args*8+8
     jz .clobber_ok
     report_fail error_message
 .clobber_ok:
-%ifnid %1, _emms
+%ifidn %1, _emms
+    emms
+%elifnidn %1, _float
     fstenv [rsp]
     cmp  word [rsp + 8], 0xffff
     je   .emms_ok
     report_fail error_message_emms
     emms
 .emms_ok:
-%else
-    emms
 %endif
     RET
 %endmacro
@@ -223,15 +223,15 @@ cglobal checked_call%1, 1,7
     jz .clobber_ok
     report_fail error_message
 .clobber_ok:
-%ifnid %1, _emms
+%ifidn %1, _emms
+    emms
+%elifnidn %1, _float
     fstenv [esp]
     cmp  word [esp + 8], 0xffff
     je   .emms_ok
     report_fail error_message_emms
     emms
 .emms_ok:
-%else
-    emms
 %endif
     add  esp, max_args*4
     REP_RET
@@ -241,3 +241,4 @@ cglobal checked_call%1, 1,7
 
 CHECKED_CALL
 CHECKED_CALL _emms
+CHECKED_CALL _float
diff --git a/mythtv/external/FFmpeg/tests/fate-run.sh b/mythtv/external/FFmpeg/tests/fate-run.sh
index c640cc5794a..4641640d42b 100755
--- a/mythtv/external/FFmpeg/tests/fate-run.sh
+++ b/mythtv/external/FFmpeg/tests/fate-run.sh
@@ -24,6 +24,7 @@ size_tolerance=${14:-0}
 cmp_unit=${15:-2}
 gen=${16:-no}
 hwaccel=${17:-none}
+report_type=${18:-standard}
 
 outdir="tests/data/fate"
 outfile="${outdir}/${test}"
@@ -107,7 +108,7 @@ probegaplessinfo(){
     pktfile1="${outdir}/${test}.pkts"
     framefile1="${outdir}/${test}.frames"
     cleanfiles="$cleanfiles $pktfile1 $framefile1"
-    run ffprobe${PROGSUF} -bitexact -select_streams a -of compact -count_packets -show_entries packet=pts,dts,duration:stream=nb_read_packets -v 0 "$filename" "$@" > "$pktfile1"
+    run ffprobe${PROGSUF} -bitexact -select_streams a -of compact -count_packets -show_entries packet=pts,dts,duration,flags:stream=nb_read_packets -v 0 "$filename" "$@" > "$pktfile1"
     head -n 8 "$pktfile1"
     tail -n 9 "$pktfile1"
     run ffprobe${PROGSUF} -bitexact -select_streams a -of compact -count_frames -show_entries frame=pkt_pts,pkt_dts,best_effort_timestamp,pkt_duration,nb_samples:stream=nb_read_frames -v 0 "$filename" "$@" > "$framefile1"
@@ -129,6 +130,10 @@ framecrc(){
     ffmpeg "$@" -flags +bitexact -fflags +bitexact -f framecrc -
 }
 
+ffmetadata(){
+    ffmpeg "$@" -flags +bitexact -fflags +bitexact -f ffmetadata -
+}
+
 framemd5(){
     ffmpeg "$@" -flags +bitexact -fflags +bitexact -f framemd5 -
 }
@@ -137,10 +142,17 @@ crc(){
     ffmpeg "$@" -f crc -
 }
 
-md5(){
+md5pipe(){
     ffmpeg "$@" md5:
 }
 
+md5(){
+    encfile="${outdir}/${test}.out"
+    cleanfiles="$cleanfiles $encfile"
+    ffmpeg "$@" $encfile
+    do_md5sum $encfile | awk '{print $1}'
+}
+
 pcm(){
     ffmpeg "$@" -vn -f s16le -
 }
@@ -222,6 +234,15 @@ lavftest(){
     ${base}/lavf-regression.sh $t lavf tests/vsynth1 "$target_exec" "$target_path" "$threads" "$thread_type" "$cpuflags" "$target_samples"
 }
 
+refcmp_metadata(){
+    refcmp=$1
+    pixfmt=$2
+    fuzz=${3:-0.001}
+    ffmpeg $FLAGS $ENC_OPTS \
+        -lavfi "testsrc2=size=300x200:rate=1:duration=5,format=${pixfmt},split[ref][tmp];[tmp]avgblur=4[enc];[enc][ref]${refcmp},metadata=print:file=-" \
+        -f null /dev/null | awk -v ref=${ref} -v fuzz=${fuzz} -f ${base}/refcmp-metadata.awk -
+}
+
 video_filter(){
     filters=$1
     shift
@@ -346,7 +367,7 @@ if [ $err -gt 128 ]; then
     test "${sig}" = "${sig%[!A-Za-z]*}" || unset sig
 fi
 
-if test -e "$ref" || test $cmp = "oneline" || test $cmp = "grep" ; then
+if test -e "$ref" || test $cmp = "oneline" || test $cmp = "null" || test $cmp = "grep" ; then
     case $cmp in
         diff)   diff -u -b "$ref" "$outfile"            >$cmpfile ;;
         rawdiff)diff -u    "$ref" "$outfile"            >$cmpfile ;;
@@ -358,13 +379,17 @@ if test -e "$ref" || test $cmp = "oneline" || test $cmp = "grep" ; then
     esac
     cmperr=$?
     test $err = 0 && err=$cmperr
-    test $err = 0 || cat $cmpfile
+    if [ "$report_type" = "ignore" ]; then
+        test $err = 0 || echo "IGNORE\t${test}" && err=0 && unset sig
+    else
+        test $err = 0 || cat $cmpfile
+    fi
 else
     echo "reference file '$ref' not found"
     err=1
 fi
 
-if [ $err -eq 0 ]; then
+if [ $err -eq 0 ] && test $report_type = "standard" ; then
     unset cmpo erro
 else
     cmpo="$($base64 <$cmpfile)"
diff --git a/mythtv/external/FFmpeg/tests/fate.sh b/mythtv/external/FFmpeg/tests/fate.sh
index 885ea17a1b6..0edee7f22e3 100755
--- a/mythtv/external/FFmpeg/tests/fate.sh
+++ b/mythtv/external/FFmpeg/tests/fate.sh
@@ -49,6 +49,7 @@ configure()(
         --enable-gpl                                                    \
         --enable-memory-poisoning                                       \
         --enable-avresample                                             \
+        ${ignore_tests:+--ignore-tests="$ignore_tests"}                 \
         ${arch:+--arch=$arch}                                           \
         ${cpu:+--cpu="$cpu"}                                            \
         ${toolchain:+--toolchain="$toolchain"}                          \
@@ -75,7 +76,7 @@ compile()(
 fate()(
     test "$build_only" = "yes" && return
     cd ${build} || return
-    ${make} ${makeopts} -k fate
+    ${make} ${makeopts_fate-${makeopts}} -k fate
 )
 
 clean(){
@@ -85,8 +86,8 @@ clean(){
 report(){
     date=$(date -u +%Y%m%d%H%M%S)
     echo "fate:1:${date}:${slot}:${version}:$1:$2:${branch}:${comment}" >report
-    cat ${build}/config.fate >>report
-    cat ${build}/tests/data/fate/*.rep >>report || for i in ${build}/tests/data/fate/*.rep ; do cat "$i" >>report 2>/dev/null; done
+    cat ${build}/ffbuild/config.fate >>report
+    cat ${build}/tests/data/fate/*.rep >>report 2>/dev/null || for i in ${build}/tests/data/fate/*.rep ; do cat "$i" >>report 2>/dev/null; done
     test -n "$fate_recv" && $tar report *.log | gzip | $fate_recv
 }
 
@@ -108,7 +109,7 @@ test -d "$src" && update || checkout || die "Error fetching source"
 
 cd ${workdir}
 
-version=$(${src}/version.sh ${src})
+version=$(${src}/ffbuild/version.sh ${src})
 test "$version" = "$(cat version-$slot 2>/dev/null)" && exit 0
 echo ${version} >version-$slot
 
diff --git a/mythtv/external/FFmpeg/tests/fate/aac.mak b/mythtv/external/FFmpeg/tests/fate/aac.mak
index 9ce8efb23a0..e8cbcef54d7 100644
--- a/mythtv/external/FFmpeg/tests/fate/aac.mak
+++ b/mythtv/external/FFmpeg/tests/fate/aac.mak
@@ -2,6 +2,10 @@ FATE_AAC += fate-aac-al04_44
 fate-aac-al04_44: CMD = pcm -i $(TARGET_SAMPLES)/aac/al04_44.mp4
 fate-aac-al04_44: REF = $(SAMPLES)/aac/al04_44.s16
 
+FATE_AAC += fate-aac-al04sf_48
+fate-aac-al04sf_48: CMD = pcm -i $(TARGET_SAMPLES)/aac/al04sf_48.mp4
+fate-aac-al04sf_48: REF = $(SAMPLES)/aac/al04sf_48.s16
+
 FATE_AAC += fate-aac-al05_44
 fate-aac-al05_44: CMD = pcm -i $(TARGET_SAMPLES)/aac/al05_44.mp4
 fate-aac-al05_44: REF = $(SAMPLES)/aac/al05_44.s16
@@ -46,6 +50,10 @@ FATE_AAC += fate-aac-al_sbr_hq_sr_48_2_fsaac48
 fate-aac-al_sbr_hq_sr_48_2_fsaac48: CMD = pcm -i $(TARGET_SAMPLES)/aac/al_sbr_sr_48_2_fsaac48.mp4
 fate-aac-al_sbr_hq_sr_48_2_fsaac48: REF = $(SAMPLES)/aac/al_sbr_hq_sr_48_2_fsaac48.s16
 
+FATE_AAC += fate-aac-al_sbr_ps_04_ur
+fate-aac-al_sbr_ps_04_ur: CMD = pcm -i $(TARGET_SAMPLES)/aac/al_sbr_ps_04_new.mp4
+fate-aac-al_sbr_ps_04_ur: REF = $(SAMPLES)/aac/al_sbr_ps_04_ur.s16
+
 FATE_AAC += fate-aac-al_sbr_ps_06_ur
 fate-aac-al_sbr_ps_06_ur: CMD = pcm -i $(TARGET_SAMPLES)/aac/al_sbr_ps_06_new.mp4
 fate-aac-al_sbr_ps_06_ur: REF = $(SAMPLES)/aac/al_sbr_ps_06_ur.s16
@@ -241,9 +249,8 @@ FATE_AAC_LATM += fate-aac-latm_stereo_to_51
 fate-aac-latm_stereo_to_51: CMD = pcm -i $(TARGET_SAMPLES)/aac/latm_stereo_to_51.ts -channel_layout 5.1
 fate-aac-latm_stereo_to_51: REF = $(SAMPLES)/aac/latm_stereo_to_51_ref.s16
 
-fate-aac-autobsf-adtstoasc: CMD = md5 -i $(TARGET_SAMPLES)/audiomatch/tones_afconvert_16000_mono_aac_lc.adts -acodec copy -fflags +bitexact -f matroska
-fate-aac-autobsf-adtstoasc: CMP = oneline
-fate-aac-autobsf-adtstoasc: REF = 8c6fbebb64ebbe9e01b345d77844d7cd
+fate-aac-autobsf-adtstoasc: CMD = transcode "aac" $(TARGET_SAMPLES)/audiomatch/tones_afconvert_16000_mono_aac_lc.adts \
+                                            matroska "-c:a copy" "-c:a copy"
 
 FATE_AAC-$(call      DEMDEC, AAC,    AAC)      += $(FATE_AAC_CT_RAW)
 FATE_AAC-$(call      DEMDEC, MOV,    AAC)      += $(FATE_AAC)
diff --git a/mythtv/external/FFmpeg/tests/fate/ac3.mak b/mythtv/external/FFmpeg/tests/fate/ac3.mak
index e6362718ea8..76be2e869a3 100644
--- a/mythtv/external/FFmpeg/tests/fate/ac3.mak
+++ b/mythtv/external/FFmpeg/tests/fate/ac3.mak
@@ -36,6 +36,14 @@ FATE_AC3 += fate-ac3-fixed-4.0-downmix-mono
 fate-ac3-fixed-4.0-downmix-mono: CMD = pcm -c ac3_fixed -request_channel_layout 4 -i $(TARGET_SAMPLES)/ac3/millers_crossing_4.0.ac3
 fate-ac3-fixed-4.0-downmix-mono: REF = $(SAMPLES)/ac3/millers_crossing_4.0_mono_v2.pcm
 
+FATE_AC3 += fate-ac3-fixed-5.1-downmix-mono
+fate-ac3-fixed-5.1-downmix-mono: CMD = pcm -c ac3_fixed -request_channel_layout 4 -i $(TARGET_SAMPLES)/ac3/monsters_inc_5.1_448_small.ac3
+fate-ac3-fixed-5.1-downmix-mono: REF = $(SAMPLES)/ac3/monsters_inc_5.1_448_small_mono_v2.pcm
+
+FATE_AC3 += fate-ac3-fixed-5.1-downmix-stereo
+fate-ac3-fixed-5.1-downmix-stereo: CMD = pcm -c ac3_fixed -request_channel_layout 3 -i $(TARGET_SAMPLES)/ac3/monsters_inc_5.1_448_small.ac3
+fate-ac3-fixed-5.1-downmix-stereo: REF = $(SAMPLES)/ac3/monsters_inc_5.1_448_small_stereo_v2.pcm
+
 FATE_EAC3 += fate-eac3-1
 fate-eac3-1: CMD = pcm -i $(TARGET_SAMPLES)/eac3/csi_miami_5.1_256_spx_small.eac3
 fate-eac3-1: REF = $(SAMPLES)/eac3/csi_miami_5.1_256_spx_small_v2.pcm
diff --git a/mythtv/external/FFmpeg/tests/fate/acodec.mak b/mythtv/external/FFmpeg/tests/fate/acodec.mak
index c7d4d269cbb..5c3fea90c58 100644
--- a/mythtv/external/FFmpeg/tests/fate/acodec.mak
+++ b/mythtv/external/FFmpeg/tests/fate/acodec.mak
@@ -104,7 +104,7 @@ fate-acodec-dca: tests/data/asynth-44100-2.wav
 fate-acodec-dca: SRC = tests/data/asynth-44100-2.wav
 fate-acodec-dca: CMD = md5 -i $(TARGET_PATH)/$(SRC) -c:a dca -strict -2 -f dts -flags +bitexact
 fate-acodec-dca: CMP = oneline
-fate-acodec-dca: REF = 7ffdefdf47069289990755c79387cc90
+fate-acodec-dca: REF = 7cd79a3717943a06b217f1130223a86f
 
 FATE_ACODEC-$(call ENCDEC, DCA, WAV) += fate-acodec-dca2
 fate-acodec-dca2: CMD = enc_dec_pcm dts wav s16le $(SRC) -c:a dca -strict -2 -flags +bitexact
diff --git a/mythtv/external/FFmpeg/tests/fate/api.mak b/mythtv/external/FFmpeg/tests/fate/api.mak
index 266f6f9f593..eb656e68a38 100644
--- a/mythtv/external/FFmpeg/tests/fate/api.mak
+++ b/mythtv/external/FFmpeg/tests/fate/api.mak
@@ -2,23 +2,20 @@ FATE_API_LIBAVCODEC-$(call ENCDEC, FLAC, FLAC) += fate-api-flac
 fate-api-flac: $(APITESTSDIR)/api-flac-test$(EXESUF)
 fate-api-flac: CMD = run $(APITESTSDIR)/api-flac-test
 fate-api-flac: CMP = null
-fate-api-flac: REF = /dev/null
 
 FATE_API_SAMPLES_LIBAVFORMAT-$(call DEMDEC, FLV, FLV) += fate-api-band
 fate-api-band: $(APITESTSDIR)/api-band-test$(EXESUF)
 fate-api-band: CMD = run $(APITESTSDIR)/api-band-test $(TARGET_SAMPLES)/mpeg4/resize_down-up.h263
 fate-api-band: CMP = null
-fate-api-band: REF = /dev/null
 
 FATE_API_SAMPLES_LIBAVFORMAT-$(call DEMDEC, H264, H264) += fate-api-h264
 fate-api-h264: $(APITESTSDIR)/api-h264-test$(EXESUF)
 fate-api-h264: CMD = run $(APITESTSDIR)/api-h264-test $(TARGET_SAMPLES)/h264-conformance/SVA_NL2_E.264
 
 FATE_API_LIBAVFORMAT-$(call DEMDEC, FLV, FLV) += fate-api-seek
-fate-api-seek: $(APITESTSDIR)/api-seek-test$(EXESUF) fate-lavf
+fate-api-seek: $(APITESTSDIR)/api-seek-test$(EXESUF) fate-lavf-flv_fmt
 fate-api-seek: CMD = run $(APITESTSDIR)/api-seek-test $(TARGET_PATH)/tests/data/lavf/lavf.flv 0 720
 fate-api-seek: CMP = null
-fate-api-seek: REF = /dev/null
 
 FATE_API_SAMPLES_LIBAVFORMAT-$(call DEMDEC, IMAGE2, PNG) += fate-api-png-codec-param
 fate-api-png-codec-param: $(APITESTSDIR)/api-codec-param-test$(EXESUF)
@@ -32,7 +29,6 @@ FATE_API-$(HAVE_THREADS) += fate-api-threadmessage
 fate-api-threadmessage: $(APITESTSDIR)/api-threadmessage-test$(EXESUF)
 fate-api-threadmessage: CMD = run $(APITESTSDIR)/api-threadmessage-test 3 10 30 50 2 20 40
 fate-api-threadmessage: CMP = null
-fate-api-threadmessage: REF = /dev/null
 
 FATE_API_SAMPLES-$(CONFIG_AVFORMAT) += $(FATE_API_SAMPLES_LIBAVFORMAT-yes)
 
diff --git a/mythtv/external/FFmpeg/tests/fate/audio.mak b/mythtv/external/FFmpeg/tests/fate/audio.mak
index e882acedf6b..40c4ca7b750 100644
--- a/mythtv/external/FFmpeg/tests/fate/audio.mak
+++ b/mythtv/external/FFmpeg/tests/fate/audio.mak
@@ -26,7 +26,7 @@ fate-dss-sp: CMD = framecrc -i $(TARGET_SAMPLES)/dss/sp.dss -frames 30
 FATE_SAMPLES_AUDIO-$(call DEMDEC, AVI, IMC) += fate-imc
 fate-imc: CMD = pcm -i $(TARGET_SAMPLES)/imc/imc.avi
 fate-imc: CMP = oneoff
-fate-imc: REF = $(SAMPLES)/imc/imc.pcm
+fate-imc: REF = $(SAMPLES)/imc/imc-201706.pcm
 
 FATE_SAMPLES_AUDIO-$(call DEMDEC, FLV, NELLYMOSER) += fate-nellymoser
 fate-nellymoser: CMD = pcm -i $(TARGET_SAMPLES)/nellymoser/nellymoser.flv
@@ -57,7 +57,11 @@ fate-smacker-audio: CMD = framecrc -i $(TARGET_SAMPLES)/smacker/wetlogo.smk -vn
 FATE_SAMPLES_AUDIO-$(call DEMDEC, WSVQA, WS_SND1) += fate-ws_snd
 fate-ws_snd: CMD = md5 -i $(TARGET_SAMPLES)/vqa/ws_snd.vqa -f s16le
 
+fate-flcl1905: CMD = run ffprobe$(PROGSSUF)$(EXESUF) -show_frames -show_packets -print_format compact $(TARGET_SAMPLES)/wav/FLCL_Ending_My-short.wav
+
 FATE_SAMPLES_AUDIO += $(FATE_SAMPLES_AUDIO-yes)
 
+FATE_SAMPLES_FFPROBE += fate-flcl1905
+
 FATE_SAMPLES_FFMPEG += $(FATE_SAMPLES_AUDIO)
-fate-audio: $(FATE_SAMPLES_AUDIO)
+fate-audio: $(FATE_SAMPLES_AUDIO) fate-flcl1905
diff --git a/mythtv/external/FFmpeg/tests/fate/avformat.mak b/mythtv/external/FFmpeg/tests/fate/avformat.mak
index 3760e414578..c9ea99ad1b1 100644
--- a/mythtv/external/FFmpeg/tests/fate/avformat.mak
+++ b/mythtv/external/FFmpeg/tests/fate/avformat.mak
@@ -1,5 +1,6 @@
 FATE_LAVF-$(call ENCDEC,  PCM_S16BE,             AIFF)               += aiff
 FATE_LAVF-$(call ENCDEC,  PCM_ALAW,              PCM_ALAW)           += alaw
+FATE_LAVF-$(call ENCDEC,  APNG,                  APNG)               += apng
 FATE_LAVF-$(call ENCDEC2, MSMPEG4V3,  MP2,       ASF)                += asf
 FATE_LAVF-$(call ENCDEC,  PCM_S16BE_PLANAR,      AST)                += ast
 FATE_LAVF-$(call ENCDEC,  PCM_S16BE,             AU)                 += au
@@ -9,6 +10,7 @@ FATE_LAVF-$(call ENCDEC,  PCM_S16BE,             CAF)                += caf
 FATE_LAVF-$(call ENCDEC,  DPX,                   IMAGE2)             += dpx
 FATE_LAVF-$(call ENCDEC2, DVVIDEO,    PCM_S16LE, AVI)                += dv_fmt
 FATE_LAVF-$(call ENCDEC2, MPEG1VIDEO, MP2,       FFM)                += ffm
+FATE_LAVF-$(call ENCDEC,  FITS,                  FITS)               += fits
 FATE_LAVF-$(call ENCDEC,  RAWVIDEO,              FILMSTRIP)          += flm
 FATE_LAVF-$(call ENCDEC,  FLV,                   FLV)                += flv_fmt
 FATE_LAVF-$(call ENCDEC,  GIF,                   IMAGE2)             += gif
@@ -23,6 +25,8 @@ FATE_LAVF-$(call ENCDEC2, MPEG1VIDEO, MP2,       MPEG1SYSTEM MPEGPS) += mpg
 FATE_LAVF-$(call ENCDEC,  PCM_MULAW,             PCM_MULAW)          += mulaw
 FATE_LAVF-$(call ENCDEC2, MPEG2VIDEO, PCM_S16LE, MXF)                += mxf
 FATE_LAVF-$(call ENCDEC2, MPEG2VIDEO, PCM_S16LE, MXF_D10 MXF)        += mxf_d10
+FATE_LAVF-$(call ENCDEC2, DVVIDEO,    PCM_S16LE, MXF)                += mxf_dv25
+FATE_LAVF-$(call ENCDEC2, DVVIDEO,    PCM_S16LE, MXF)                += mxf_dvcpro50
 FATE_LAVF-$(call ENCDEC2, DNXHD,      PCM_S16LE, MXF_OPATOM MXF)     += mxf_opatom
 FATE_LAVF-$(call ENCDEC2, DNXHD,      PCM_S16LE, MXF_OPATOM MXF)     += mxf_opatom_audio
 FATE_LAVF-$(call ENCDEC2, MPEG4,      MP2,       NUT)                += nut
@@ -53,6 +57,7 @@ FATE_LAVF-$(call ENCDEC,  PCM_S16LE,             WAV)                += wav_peak
 FATE_LAVF-$(call ENCDEC,  PCM_S16LE,             WAV)                += wav_peak_only
 FATE_LAVF-$(call ENCMUX,  PCM_S16LE,             W64)                += w64
 FATE_LAVF-$(call ENCDEC,  MP2,                   WTV)                += wtv
+FATE_LAVF-$(call ENCDEC,  WAVPACK,               WV)                 += wv
 FATE_LAVF-$(call ENCDEC,  XBM,                   IMAGE2)             += xbm
 FATE_LAVF-$(call ENCDEC,  XWD,                   IMAGE2)             += xwd
 FATE_LAVF-$(CONFIG_YUV4MPEGPIPE_MUXER)                               += yuv4mpeg
@@ -80,3 +85,59 @@ $(FATE_LAVF_FATE): CMD = lavffatetest
 
 FATE_SAMPLES_FFMPEG += $(FATE_LAVF_FATE)
 fate-lavf-fate:        $(FATE_LAVF_FATE)
+
+tests/data/mp4-to-ts.m3u8: TAG = GEN
+tests/data/mp4-to-ts.m3u8: ffmpeg$(PROGSSUF)$(EXESUF) | tests/data
+	$(M)$(TARGET_EXEC) $(TARGET_PATH)/$< \
+        -i $(TARGET_SAMPLES)/h264/interlaced_crop.mp4 \
+        -f ssegment -segment_time 1 -map 0 -flags +bitexact -codec copy \
+        -segment_list $(TARGET_PATH)/$@ -y $(TARGET_PATH)/tests/data/mp4-to-ts-%03d.ts 2>/dev/null
+
+tests/data/adts-to-mkv.m3u8: TAG = GEN
+tests/data/adts-to-mkv.m3u8: ffmpeg$(PROGSSUF)$(EXESUF) | tests/data
+	$(M)$(TARGET_EXEC) $(TARGET_PATH)/$< \
+        -i $(TARGET_SAMPLES)/audiomatch/tones_afconvert_16000_mono_aac_lc.m4a \
+        -f segment -segment_time 1 -map 0 -flags +bitexact -codec copy -segment_format_options live=1 \
+        -segment_list $(TARGET_PATH)/$@ -y $(TARGET_PATH)/tests/data/adts-to-mkv-%03d.mkv 2>/dev/null
+
+tests/data/adts-to-mkv-header.mkv: TAG = GEN
+tests/data/adts-to-mkv-header.mkv: ffmpeg$(PROGSSUF)$(EXESUF) | tests/data
+	$(M)$(TARGET_EXEC) $(TARGET_PATH)/$< \
+        -i $(TARGET_SAMPLES)/audiomatch/tones_afconvert_16000_mono_aac_lc.m4a \
+        -f segment -segment_time 1 -map 0 -flags +bitexact -codec copy -segment_format_options live=1 \
+        -segment_header_filename $(TARGET_PATH)/tests/data/adts-to-mkv-header.mkv \
+        -y $(TARGET_PATH)/tests/data/adts-to-mkv-header-%03d.mkv 2>/dev/null
+
+tests/data/adts-to-mkv-header-%.mkv: tests/data/adts-to-mkv-header.mkv ;
+
+FATE_SEGMENT_PARTS += 000 001 002
+
+tests/data/adts-to-mkv-cated-all.mkv: TAG = GEN
+tests/data/adts-to-mkv-cated-all.mkv: tests/data/adts-to-mkv-header.mkv $(FATE_SEGMENT_PARTS:%=tests/data/adts-to-mkv-header-%.mkv) | tests/data
+	$(M)cat $^ >$@
+
+tests/data/adts-to-mkv-cated-%.mkv: TAG = GEN
+tests/data/adts-to-mkv-cated-%.mkv: tests/data/adts-to-mkv-header.mkv tests/data/adts-to-mkv-header-%.mkv | tests/data
+	$(M)cat $^ >$@
+
+FATE_SEGMENT += fate-segment-mp4-to-ts
+fate-segment-mp4-to-ts: tests/data/mp4-to-ts.m3u8
+fate-segment-mp4-to-ts: CMD = framecrc -flags +bitexact -i $(TARGET_PATH)/tests/data/mp4-to-ts.m3u8 -c copy
+FATE_SEGMENT-$(call ALLYES, MOV_DEMUXER H264_MP4TOANNEXB_BSF MPEGTS_MUXER MATROSKA_DEMUXER SEGMENT_MUXER HLS_DEMUXER) += fate-segment-mp4-to-ts
+
+FATE_SEGMENT += fate-segment-adts-to-mkv
+fate-segment-adts-to-mkv: tests/data/adts-to-mkv.m3u8
+fate-segment-adts-to-mkv: CMD = framecrc -flags +bitexact -i $(TARGET_PATH)/tests/data/adts-to-mkv.m3u8 -c copy
+fate-segment-adts-to-mkv: REF = $(SRC_PATH)/tests/ref/fate/segment-adts-to-mkv-header-all
+FATE_SEGMENT-$(call ALLYES, AAC_DEMUXER AAC_ADTSTOASC_BSF MATROSKA_MUXER MATROSKA_DEMUXER SEGMENT_MUXER HLS_DEMUXER) += fate-segment-adts-to-mkv
+
+FATE_SEGMENT_ALLPARTS = $(FATE_SEGMENT_PARTS)
+FATE_SEGMENT_ALLPARTS += all
+FATE_SEGMENT_SPLIT += $(FATE_SEGMENT_ALLPARTS:%=fate-segment-adts-to-mkv-header-%)
+$(foreach N,$(FATE_SEGMENT_ALLPARTS),$(eval $(N:%=fate-segment-adts-to-mkv-header-%): tests/data/adts-to-mkv-cated-$(N).mkv))
+fate-segment-adts-to-mkv-header-%: CMD = framecrc -flags +bitexact -i $(TARGET_PATH)/tests/data/$(@:fate-segment-adts-to-mkv-header-%=adts-to-mkv-cated-%).mkv -c copy
+FATE_SEGMENT-$(call ALLYES, AAC_DEMUXER AAC_ADTSTOASC_BSF MATROSKA_MUXER MATROSKA_DEMUXER SEGMENT_MUXER HLS_DEMUXER) += $(FATE_SEGMENT_SPLIT)
+
+FATE_SAMPLES_FFMPEG += $(FATE_SEGMENT-yes)
+
+fate-segment: $(FATE_SEGMENT-yes)
diff --git a/mythtv/external/FFmpeg/tests/fate/checkasm.mak b/mythtv/external/FFmpeg/tests/fate/checkasm.mak
index daefe69404b..fbf60e98484 100644
--- a/mythtv/external/FFmpeg/tests/fate/checkasm.mak
+++ b/mythtv/external/FFmpeg/tests/fate/checkasm.mak
@@ -1,5 +1,34 @@
-fate-checkasm: tests/checkasm/checkasm$(EXESUF)
-fate-checkasm: CMD = run tests/checkasm/checkasm
-fate-checkasm: REF = /dev/null
+FATE_CHECKASM = fate-checkasm-aacpsdsp                                  \
+                fate-checkasm-alacdsp                                   \
+                fate-checkasm-audiodsp                                  \
+                fate-checkasm-blockdsp                                  \
+                fate-checkasm-bswapdsp                                  \
+                fate-checkasm-exrdsp                                    \
+                fate-checkasm-fixed_dsp                                 \
+                fate-checkasm-flacdsp                                   \
+                fate-checkasm-float_dsp                                 \
+                fate-checkasm-fmtconvert                                \
+                fate-checkasm-g722dsp                                   \
+                fate-checkasm-h264dsp                                   \
+                fate-checkasm-h264pred                                  \
+                fate-checkasm-h264qpel                                  \
+                fate-checkasm-hevc_add_res                              \
+                fate-checkasm-hevc_idct                                 \
+                fate-checkasm-jpeg2000dsp                               \
+                fate-checkasm-llviddsp                                  \
+                fate-checkasm-pixblockdsp                               \
+                fate-checkasm-sbrdsp                                    \
+                fate-checkasm-synth_filter                              \
+                fate-checkasm-v210enc                                   \
+                fate-checkasm-vf_blend                                  \
+                fate-checkasm-vf_colorspace                             \
+                fate-checkasm-videodsp                                  \
+                fate-checkasm-vp8dsp                                    \
+                fate-checkasm-vp9dsp                                    \
 
-FATE += fate-checkasm
+$(FATE_CHECKASM): tests/checkasm/checkasm$(EXESUF)
+$(FATE_CHECKASM): CMD = run tests/checkasm/checkasm --test=$(@:fate-checkasm-%=%)
+$(FATE_CHECKASM): CMP = null
+
+FATE-$(CONFIG_STATIC) += $(FATE_CHECKASM)
+fate-checkasm: $(FATE_CHECKASM)
diff --git a/mythtv/external/FFmpeg/tests/fate/demux.mak b/mythtv/external/FFmpeg/tests/fate/demux.mak
index cee4bd4bf9f..9427ac30c8c 100644
--- a/mythtv/external/FFmpeg/tests/fate/demux.mak
+++ b/mythtv/external/FFmpeg/tests/fate/demux.mak
@@ -1,54 +1,59 @@
 FATE_SAMPLES_DEMUX-$(call DEMDEC, AVI, FRAPS) += fate-avio-direct
 fate-avio-direct: CMD = framecrc -avioflags direct -i $(TARGET_SAMPLES)/fraps/fraps-v5-bouncing-balls-partial.avi -avioflags direct
 
-FATE_SAMPLES_DEMUX-$(DEMDEC, AAC, AAC) += fate-adts-demux
-fate-adts-demux: CMD = crc -i $(TARGET_SAMPLES)/aac/ct_faac-adts.aac -acodec copy
+FATE_SAMPLES_DEMUX-$(call DEMDEC, AAC, AAC) += fate-adts-demux fate-adts-id3v1-demux
+fate-adts-demux: CMD = crc -i $(TARGET_SAMPLES)/aac/ct_faac-adts.aac -c:a copy
+fate-adts-id3v1-demux: CMD = framecrc -f aac -i $(TARGET_SAMPLES)/aac/id3v1.aac -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_AEA_DEMUXER) += fate-aea-demux
-fate-aea-demux: CMD = crc -i $(TARGET_SAMPLES)/aea/chirp.aea -acodec copy
+fate-aea-demux: CMD = crc -i $(TARGET_SAMPLES)/aea/chirp.aea -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_AST_DEMUXER) += fate-ast
 fate-ast: CMD = crc -i $(TARGET_SAMPLES)/ast/demo11_02_partial.ast -c copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_BINK_DEMUXER) += fate-bink-demux
-fate-bink-demux: CMD = crc -i $(TARGET_SAMPLES)/bink/Snd0a7d9b58.dee -vn -acodec copy
+fate-bink-demux: CMD = crc -i $(TARGET_SAMPLES)/bink/Snd0a7d9b58.dee -vn -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_BFSTM_DEMUXER) += fate-bfstm fate-bcstm
-fate-bfstm: CMD = crc -i $(TARGET_SAMPLES)/bfstm/spl-forest-day.bfstm -acodec copy
-fate-bcstm: CMD = crc -i $(TARGET_SAMPLES)/bfstm/loz-mm-mikau.bcstm -acodec copy
+fate-bfstm: CMD = crc -i $(TARGET_SAMPLES)/bfstm/spl-forest-day.bfstm -c:a copy
+fate-bcstm: CMD = crc -i $(TARGET_SAMPLES)/bfstm/loz-mm-mikau.bcstm -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_BRSTM_DEMUXER) += fate-brstm
-fate-brstm: CMD = crc -i $(TARGET_SAMPLES)/brstm/lozswd_partial.brstm -acodec copy
+fate-brstm: CMD = crc -i $(TARGET_SAMPLES)/brstm/lozswd_partial.brstm -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_CAF_DEMUXER) += fate-caf
 fate-caf: CMD = crc -i $(TARGET_SAMPLES)/caf/caf-pcm16.caf -c copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_CDXL_DEMUXER) += fate-cdxl-demux
-fate-cdxl-demux: CMD = framecrc -i $(TARGET_SAMPLES)/cdxl/mirage.cdxl -vcodec copy -acodec copy
+fate-cdxl-demux: CMD = framecrc -i $(TARGET_SAMPLES)/cdxl/mirage.cdxl -c:v copy -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_CINE_DEMUXER) += fate-cine-demux
 fate-cine-demux: CMD = crc -i $(TARGET_SAMPLES)/cine/bayer_gbrg8.cine -c copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_DAUD_DEMUXER) += fate-d-cinema-demux
-fate-d-cinema-demux: CMD = framecrc -i $(TARGET_SAMPLES)/d-cinema/THX_Science_FLT_1920-partial.302 -acodec copy
+fate-d-cinema-demux: CMD = framecrc -i $(TARGET_SAMPLES)/d-cinema/THX_Science_FLT_1920-partial.302 -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_EA_DEMUXER) += fate-d-eavp6-demux
-fate-d-eavp6-demux: CMD = framecrc -i $(TARGET_SAMPLES)/ea-vp6/SmallRing.vp6 -map 0 -vcodec copy
+fate-d-eavp6-demux: CMD = framecrc -i $(TARGET_SAMPLES)/ea-vp6/SmallRing.vp6 -map 0 -c:v copy
+
+FATE_SAMPLES_DEMUX-$(call ALLYES, GIF_DEMUXER FITS_DEMUXER GIF_DECODER FITS_ENCODER FITS_MUXER) += fate-fits-demux
+fate-fits-demux: tests/data/fits-multi.fits
+fate-fits-demux: CMD = framecrc -i $(TARGET_PATH)/tests/data/fits-multi.fits -c:v copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_FLV_DEMUXER) += fate-flv-demux
 fate-flv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/flv/Enigma_Principles_of_Lust-part.flv -codec copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_GIF_DEMUXER) += fate-gif-demux
-fate-gif-demux: CMD = framecrc -i $(TARGET_SAMPLES)/gif/Newtons_cradle_animation_book_2.gif -vcodec copy
+fate-gif-demux: CMD = framecrc -i $(TARGET_SAMPLES)/gif/Newtons_cradle_animation_book_2.gif -c:v copy
 
 FATE_SAMPLES_DEMUX-$(call ALLYES, IV8_DEMUXER MPEG4VIDEO_PARSER) += fate-iv8-demux
-fate-iv8-demux: CMD = framecrc -i $(TARGET_SAMPLES)/iv8/zzz-partial.mpg -vcodec copy
+fate-iv8-demux: CMD = framecrc -i $(TARGET_SAMPLES)/iv8/zzz-partial.mpg -c:v copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_JV_DEMUXER) += fate-jv-demux
-fate-jv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/jv/intro.jv -vcodec copy -acodec copy
+fate-jv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/jv/intro.jv -c:v copy -c:a copy
 
 FATE_SAMPLES_DEMUX-$(call ALLYES, LMLM4_DEMUXER MPEG4VIDEO_PARSER) += fate-lmlm4-demux
-fate-lmlm4-demux: CMD = framecrc -i $(TARGET_SAMPLES)/lmlm4/LMLM4_CIFat30fps.divx -t 3 -acodec copy -vcodec copy
+fate-lmlm4-demux: CMD = framecrc -i $(TARGET_SAMPLES)/lmlm4/LMLM4_CIFat30fps.divx -t 3 -c:a copy -c:v copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_XA_DEMUXER) += fate-maxis-xa
 fate-maxis-xa: CMD = framecrc -i $(TARGET_SAMPLES)/maxis-xa/SC2KBUG.XA -frames:a 30 -c:a copy
@@ -58,7 +63,7 @@ fate-mkv: CMD = framecrc -i $(TARGET_SAMPLES)/mkv/test7_cut.mkv -c copy
 
 #No dts errors or duplicate DTS should be in this
 FATE_SAMPLES_DEMUX-$(call DEMDEC, MATROSKA, H264) += fate-mkv-1242
-fate-mkv-1242: CMD = framecrc -i $(TARGET_SAMPLES)/mkv/1242-small.mkv -c copy -vframes 11
+fate-mkv-1242: CMD = framecrc -i $(TARGET_SAMPLES)/mkv/1242-small.mkv -c copy -frames:v 11
 
 FATE_SAMPLES_DEMUX-$(CONFIG_MLV_DEMUXER) += fate-mlv-demux
 fate-mlv-demux: CMD = crc -i $(TARGET_SAMPLES)/mlv/M19-0333-cut.MLV -c copy
@@ -73,16 +78,16 @@ FATE_SAMPLES_DEMUX-$(CONFIG_MTV_DEMUXER) += fate-mtv
 fate-mtv: CMD = framecrc -i $(TARGET_SAMPLES)/mtv/comedian_auto-partial.mtv -c copy
 
 FATE_SAMPLES_DEMUX-$(call DEMDEC, MXF, MPEG4) += fate-mxf-demux
-fate-mxf-demux: CMD = framecrc -i $(TARGET_SAMPLES)/mxf/C0023S01.mxf -acodec copy -vcodec copy
+fate-mxf-demux: CMD = framecrc -i $(TARGET_SAMPLES)/mxf/C0023S01.mxf -c:a copy -c:v copy
 
 FATE_SAMPLES_DEMUX-$(call ALLYES, NC_DEMUXER MPEG4VIDEO_PARSER) += fate-nc-demux
-fate-nc-demux: CMD = framecrc -i $(TARGET_SAMPLES)/nc-camera/nc-sample-partial -vcodec copy
+fate-nc-demux: CMD = framecrc -i $(TARGET_SAMPLES)/nc-camera/nc-sample-partial -c:v copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_NISTSPHERE_DEMUXER) += fate-nistsphere-demux
-fate-nistsphere-demux: CMD = crc -i $(TARGET_SAMPLES)/nistsphere/nist-ulaw.nist -acodec copy
+fate-nistsphere-demux: CMD = crc -i $(TARGET_SAMPLES)/nistsphere/nist-ulaw.nist -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_NSV_DEMUXER) += fate-nsv-demux
-fate-nsv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/nsv/witchblade-51kbps.nsv -t 6 -vcodec copy -acodec copy
+fate-nsv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/nsv/witchblade-51kbps.nsv -t 6 -c:v copy -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_OGG_DEMUXER) += fate-oggopus-demux
 fate-oggopus-demux: CMD = framecrc -i $(TARGET_SAMPLES)/ogg/intro-partial.opus -c:a copy
@@ -91,10 +96,10 @@ FATE_SAMPLES_DEMUX-$(CONFIG_OGG_DEMUXER) += fate-oggvp8-demux
 fate-oggvp8-demux: CMD = framecrc -i $(TARGET_SAMPLES)/ogg/videotest.ogv -c:v copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_OMA_DEMUXER) += fate-oma-demux
-fate-oma-demux: CMD = crc -i $(TARGET_SAMPLES)/oma/01-Untitled-partial.oma -acodec copy
+fate-oma-demux: CMD = crc -i $(TARGET_SAMPLES)/oma/01-Untitled-partial.oma -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_PAF_DEMUXER) += fate-paf-demux
-fate-paf-demux: CMD = framecrc -i $(TARGET_SAMPLES)/paf/hod1-partial.paf -vcodec copy -acodec copy
+fate-paf-demux: CMD = framecrc -i $(TARGET_SAMPLES)/paf/hod1-partial.paf -c:v copy -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_PMP_DEMUXER) += fate-pmp-demux
 fate-pmp-demux: CMD = framecrc -i $(TARGET_SAMPLES)/pmp/demo.pmp -vn -c:a copy
@@ -109,13 +114,13 @@ FATE_SAMPLES_DEMUX-$(CONFIG_STR_DEMUXER) += fate-psx-str-demux
 fate-psx-str-demux: CMD = framecrc -i $(TARGET_SAMPLES)/psx-str/descent-partial.str -c copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_PVA_DEMUXER) += fate-pva-demux
-fate-pva-demux: CMD = framecrc -idct simple -i $(TARGET_SAMPLES)/pva/PVA_test-partial.pva -t 0.6 -acodec copy
+fate-pva-demux: CMD = framecrc -idct simple -i $(TARGET_SAMPLES)/pva/PVA_test-partial.pva -t 0.6 -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_QCP_DEMUXER) += fate-qcp-demux
-fate-qcp-demux: CMD = crc -i $(TARGET_SAMPLES)/qcp/0036580847.QCP -acodec copy
+fate-qcp-demux: CMD = crc -i $(TARGET_SAMPLES)/qcp/0036580847.QCP -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_R3D_DEMUXER) += fate-redcode-demux
-fate-redcode-demux: CMD = framecrc -i $(TARGET_SAMPLES)/r3d/4MB-sample.r3d -vcodec copy -acodec copy
+fate-redcode-demux: CMD = framecrc -i $(TARGET_SAMPLES)/r3d/4MB-sample.r3d -c:v copy -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_SIFF_DEMUXER) += fate-siff-demux
 fate-siff-demux: CMD = framecrc -i $(TARGET_SAMPLES)/SIFF/INTRO_B.VB -c copy
@@ -130,13 +135,13 @@ FATE_SAMPLES_DEMUX-$(CONFIG_WSAUD_DEMUXER) += fate-westwood-aud
 fate-westwood-aud: CMD = framecrc -i $(TARGET_SAMPLES)/westwood-aud/excellent.aud -c copy
 
 FATE_SAMPLES_DEMUX-$(call ALLYES, WTV_DEMUXER MPEGVIDEO_PARSER) += fate-wtv-demux
-fate-wtv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/wtv/law-and-order-partial.wtv -vcodec copy -acodec copy
+fate-wtv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/wtv/law-and-order-partial.wtv -c:v copy -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_XMV_DEMUXER) += fate-xmv-demux
-fate-xmv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/xmv/logos1p.fmv -vcodec copy -acodec copy
+fate-xmv-demux: CMD = framecrc -i $(TARGET_SAMPLES)/xmv/logos1p.fmv -c:v copy -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_XWMA_DEMUXER) += fate-xwma-demux
-fate-xwma-demux: CMD = crc -i $(TARGET_SAMPLES)/xwma/ergon.xwma -acodec copy
+fate-xwma-demux: CMD = crc -i $(TARGET_SAMPLES)/xwma/ergon.xwma -c:a copy
 
 FATE_SAMPLES_DEMUX-$(CONFIG_MPEGTS_DEMUXER) += fate-ts-demux
 fate-ts-demux: CMD = framecrc -i $(TARGET_SAMPLES)/ac3/mp3ac325-4864-small.ts -codec copy
diff --git a/mythtv/external/FFmpeg/tests/fate/ffmpeg.mak b/mythtv/external/FFmpeg/tests/fate/ffmpeg.mak
index b58a46dab3c..d8f2e715901 100644
--- a/mythtv/external/FFmpeg/tests/fate/ffmpeg.mak
+++ b/mythtv/external/FFmpeg/tests/fate/ffmpeg.mak
@@ -10,6 +10,14 @@ FATE_MAPCHAN-$(CONFIG_CHANNELMAP_FILTER) += fate-mapchan-silent-mono
 fate-mapchan-silent-mono: tests/data/asynth-22050-1.wav
 fate-mapchan-silent-mono: CMD = md5 -i $(TARGET_PATH)/tests/data/asynth-22050-1.wav -map_channel -1 -map_channel 0.0.0 -fflags +bitexact -f wav
 
+FATE_MAPCHAN-$(CONFIG_CHANNELMAP_FILTER) += fate-mapchan-2ch-extract-ch0-ch2-trailing
+fate-mapchan-2ch-extract-ch0-ch2-trailing: tests/data/asynth-44100-2.wav
+fate-mapchan-2ch-extract-ch0-ch2-trailing: CMD = md5 -i $(TARGET_PATH)/tests/data/asynth-44100-2.wav -map_channel 0.0.0 -map_channel 0.0.2? -fflags +bitexact -f wav
+
+FATE_MAPCHAN-$(CONFIG_CHANNELMAP_FILTER) += fate-mapchan-3ch-extract-ch0-ch2-trailing
+fate-mapchan-3ch-extract-ch0-ch2-trailing: tests/data/asynth-44100-3.wav
+fate-mapchan-3ch-extract-ch0-ch2-trailing: CMD = md5 -i $(TARGET_PATH)/tests/data/asynth-44100-3.wav -map_channel 0.0.0 -map_channel 0.0.2? -fflags +bitexact -f wav
+
 FATE_MAPCHAN = $(FATE_MAPCHAN-yes)
 
 FATE_FFMPEG += $(FATE_MAPCHAN)
@@ -20,7 +28,7 @@ fate-ffmpeg-filter_complex: CMD = framecrc -filter_complex color=d=1:r=5 -fflags
 
 FATE_SAMPLES_FFMPEG-$(CONFIG_COLORKEY_FILTER) += fate-ffmpeg-filter_colorkey
 fate-ffmpeg-filter_colorkey: tests/data/filtergraphs/colorkey
-fate-ffmpeg-filter_colorkey: CMD = framecrc -idct simple -fflags +bitexact -flags +bitexact  -sws_flags +accurate_rnd+bitexact -i $(TARGET_SAMPLES)/cavs/cavs.mpg -fflags +bitexact -flags +bitexact -sws_flags +accurate_rnd+bitexact -i $(TARGET_SAMPLES)/lena.pnm -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/colorkey -sws_flags +accurate_rnd+bitexact -fflags +bitexact -flags +bitexact -qscale 2 -vframes 10
+fate-ffmpeg-filter_colorkey: CMD = framecrc -idct simple -fflags +bitexact -flags +bitexact  -sws_flags +accurate_rnd+bitexact -i $(TARGET_SAMPLES)/cavs/cavs.mpg -fflags +bitexact -flags +bitexact -sws_flags +accurate_rnd+bitexact -i $(TARGET_SAMPLES)/lena.pnm -an -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/colorkey -sws_flags +accurate_rnd+bitexact -fflags +bitexact -flags +bitexact -qscale 2 -frames:v 10
 
 FATE_FFMPEG-$(CONFIG_COLOR_FILTER) += fate-ffmpeg-lavfi
 fate-ffmpeg-lavfi: CMD = framecrc -lavfi color=d=1:r=5 -fflags +bitexact
@@ -51,6 +59,12 @@ fate-unknown_layout-ac3: CMD = md5 \
   -guess_layout_max 0 -f s16le -ac 1 -ar 44100 -i $(TARGET_PATH)/$(AREF) \
   -f ac3 -flags +bitexact -c ac3_fixed
 
+
+FATE_STREAMCOPY-$(call ALLYES, EAC3_DEMUXER MOV_MUXER) += fate-copy-trac3074
+fate-copy-trac3074: $(TARGET_SAMPLES)/eac3/csi_miami_stereo_128_spx.eac3
+fate-copy-trac3074: CMD = transcode eac3 $(TARGET_SAMPLES)/eac3/csi_miami_stereo_128_spx.eac3\
+                     mp4 "-codec copy -map 0" "-codec copy"
+
 FATE_STREAMCOPY-$(call ALLYES, MOV_DEMUXER MOV_MUXER) += fate-copy-trac236
 fate-copy-trac236: $(TARGET_SAMPLES)/mov/fcp_export8-236.mov
 fate-copy-trac236: CMD = transcode mov $(TARGET_SAMPLES)/mov/fcp_export8-236.mov\
@@ -87,7 +101,7 @@ fate-streamcopy: $(FATE_STREAMCOPY-yes)
 FATE_SAMPLES_FFMPEG-$(call ALLYES, MOV_DEMUXER MATROSKA_MUXER) += fate-rgb24-mkv
 fate-rgb24-mkv: $(TARGET_SAMPLES)/qtrle/aletrek-rle.mov
 fate-rgb24-mkv: CMD = transcode "mov" $(TARGET_SAMPLES)/qtrle/aletrek-rle.mov\
-                      matroska "-vcodec rawvideo -pix_fmt rgb24 -allow_raw_vfw 1 -vframes 1"
+                      matroska "-c:v rawvideo -pix_fmt rgb24 -allow_raw_vfw 1 -frames:v 1"
 
 FATE_SAMPLES_FFMPEG-$(call ALLYES, AAC_DEMUXER MOV_MUXER) += fate-adtstoasc_ticket3715
 fate-adtstoasc_ticket3715: $(TARGET_SAMPLES)/aac/foo.aac
@@ -99,6 +113,12 @@ fate-h264_mp4toannexb_ticket2991: $(TARGET_SAMPLES)/h264/wwwq_cut.mp4
 fate-h264_mp4toannexb_ticket2991: CMD = transcode "mp4" $(TARGET_SAMPLES)/h264/wwwq_cut.mp4\
                                   h264 "-c:v copy -bsf:v h264_mp4toannexb" "-codec copy"
 
+FATE_SAMPLES_FFMPEG-$(call ALLYES, MOV_DEMUXER H264_MUXER H264_MP4TOANNEXB_BSF) += fate-h264_mp4toannexb_ticket5927 fate-h264_mp4toannexb_ticket5927_2
+fate-h264_mp4toannexb_ticket5927:   CMD = transcode "mp4" $(TARGET_SAMPLES)/h264/thezerotheorem-cut.mp4 \
+                                          h264 "-c:v copy -bsf:v h264_mp4toannexb -an" "-c:v copy"
+fate-h264_mp4toannexb_ticket5927_2: CMD = transcode "mp4" $(TARGET_SAMPLES)/h264/thezerotheorem-cut.mp4 \
+                                          h264 "-c:v copy -an" "-c:v copy"
+
 FATE_SAMPLES_FFMPEG-$(call ALLYES, MPEGPS_DEMUXER AVI_MUXER REMOVE_EXTRADATA_BSF) += fate-ffmpeg-bsf-remove-k fate-ffmpeg-bsf-remove-r fate-ffmpeg-bsf-remove-e
 fate-ffmpeg-bsf-remove-k: $(TARGET_SAMPLES)/mpeg2/matrixbench_mpeg2.lq1.mpg
 fate-ffmpeg-bsf-remove-k: CMD = transcode "mpeg" $(TARGET_SAMPLES)/mpeg2/matrixbench_mpeg2.lq1.mpg\
@@ -112,3 +132,9 @@ fate-ffmpeg-bsf-remove-e: CMD = transcode "mpeg" $(TARGET_SAMPLES)/mpeg2/matrixb
 
 
 FATE_SAMPLES_FFMPEG-yes += $(FATE_STREAMCOPY-yes)
+
+FATE_TIME_BASE-$(call ALLYES, MPEGPS_DEMUXER MXF_MUXER) += fate-time_base
+fate-time_base: $(TARGET_SAMPLES)/mpeg2/dvd_single_frame.vob
+fate-time_base: CMD = md5 -i $(TARGET_SAMPLES)/mpeg2/dvd_single_frame.vob -an -sn -c:v copy -r 25 -time_base 1001:30000 -fflags +bitexact -f mxf
+
+FATE_SAMPLES_FFMPEG-yes += $(FATE_TIME_BASE-yes)
diff --git a/mythtv/external/FFmpeg/tests/fate/fft.mak b/mythtv/external/FFmpeg/tests/fate/fft.mak
index 6ca430d0204..c7c26cd634f 100644
--- a/mythtv/external/FFmpeg/tests/fate/fft.mak
+++ b/mythtv/external/FFmpeg/tests/fate/fft.mak
@@ -46,7 +46,7 @@ FATE_FFT_FIXED_ALL = $(FATE_FFT_FIXED-yes) $(FATE_MDCT_FIXED-yes)
 $(FATE_FFT_FIXED_ALL): libavcodec/tests/fft-fixed$(EXESUF)
 $(FATE_FFT_FIXED_ALL): CMD = run libavcodec/tests/fft-fixed $(CPUFLAGS:%=-c%) $(ARGS)
 
-$(FATE_FFT_ALL) $(FATE_FFT_FIXED_ALL): REF = /dev/null
+$(FATE_FFT_ALL) $(FATE_FFT_FIXED_ALL): CMP = null
 
 define DEF_FFT_FIXED32
 FATE_FFT_FIXED32 += fate-fft-fixed32-$(1)   fate-ifft-fixed32-$(1)  \
@@ -63,7 +63,7 @@ $(foreach N, 4 5 6 7 8 9 10 11 12, $(eval $(call DEF_FFT_FIXED32,$(N))))
 fate-fft-fixed32: $(FATE_FFT_FIXED32)
 $(FATE_FFT_FIXED32): libavcodec/tests/fft-fixed32$(EXESUF)
 $(FATE_FFT_FIXED32): CMD = run libavcodec/tests/fft-fixed32 $(CPUFLAGS:%=-c%) $(ARGS)
-$(FATE_FFT_FIXED32): REF = /dev/null
+$(FATE_FFT_FIXED32): CMP = null
 
 define DEF_AV_FFT
 FATE_AV_DCT-$(CONFIG_DCT)   += fate-av-dct1d-$(1) fate-av-idct1d-$(1)
@@ -92,7 +92,7 @@ FATE_AV_FFT_ALL = $(FATE_AV_DCT-yes) $(FATE_AV_FFT-yes) $(FATE_AV_MDCT-yes) $(FA
 
 $(FATE_AV_FFT_ALL): libavcodec/tests/avfft$(EXESUF)
 $(FATE_AV_FFT_ALL): CMD = run libavcodec/tests/avfft $(CPUFLAGS:%=-c%) $(ARGS)
-$(FATE_AV_FFT_ALL): REF = /dev/null
+$(FATE_AV_FFT_ALL): CMP = null
 
 fate-dct: fate-dct-float
 fate-fft: fate-fft-float fate-fft-fixed fate-fft-fixed32
diff --git a/mythtv/external/FFmpeg/tests/fate/fifo-muxer.mak b/mythtv/external/FFmpeg/tests/fate/fifo-muxer.mak
index fb68d5910b5..9c13954cf77 100644
--- a/mythtv/external/FFmpeg/tests/fate/fifo-muxer.mak
+++ b/mythtv/external/FFmpeg/tests/fate/fifo-muxer.mak
@@ -1,4 +1,4 @@
-fate-fifo-muxer-h264: CMD = ffmpeg -i $(TARGET_SAMPLES)/mkv/1242-small.mkv -vframes 11\
+fate-fifo-muxer-h264: CMD = ffmpeg -i $(TARGET_SAMPLES)/mkv/1242-small.mkv -frames:v 11\
                             -c:v copy -c:a copy -map v:0 -map a:0 -flags +bitexact\
                             -fflags +bitexact -f fifo -fifo_format framecrc -
 fate-fifo-muxer-h264: REF = $(SRC_PATH)/tests/ref/fate/mkv-1242
@@ -13,7 +13,7 @@ FATE_SAMPLES_FIFO_MUXER-$(call ALLYES, FIFO_MUXER, WAV_DEMUXER) += fate-fifo-mux
 
 fate-fifo-muxer-tst: libavformat/tests/fifo_muxer$(EXESUF)
 fate-fifo-muxer-tst: CMD = run libavformat/tests/fifo_muxer$(EXESUF)
-FATE_FIFO_MUXER-$(CONFIG_FIFO_MUXER) += fate-fifo-muxer-tst
+FATE_FIFO_MUXER-$(call ALLYES, FIFO_MUXER NETWORK) += fate-fifo-muxer-tst
 
 FATE_SAMPLES_FFMPEG += $(FATE_SAMPLES_FIFO_MUXER-yes)
 FATE_FFMPEG += $(FATE_FIFO_MUXER-yes)
diff --git a/mythtv/external/FFmpeg/tests/fate/filter-audio.mak b/mythtv/external/FFmpeg/tests/fate/filter-audio.mak
index 9c6f7cd6286..bd8b3d3c351 100644
--- a/mythtv/external/FFmpeg/tests/fate/filter-audio.mak
+++ b/mythtv/external/FFmpeg/tests/fate/filter-audio.mak
@@ -84,68 +84,73 @@ fate-filter-anequalizer: tests/data/filtergraphs/anequalizer
 fate-filter-anequalizer: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.wav
 fate-filter-anequalizer: CMD = framecrc -i $(SRC) -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/anequalizer
 
-FATE_AFILTER-$(call FILTERDEMDECENCMUX, ASETNSAMPLES, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-asetnsamples
-fate-filter-asetnsamples: tests/data/asynth-44100-2.wav
-fate-filter-asetnsamples: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.wav
-fate-filter-asetnsamples: CMD = framecrc -i $(SRC) -af asetnsamples=512:p=1
+FATE_AFILTER-$(call FILTERDEMDECENCMUX, ASETNSAMPLES, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-asetnsamples-pad
+fate-filter-asetnsamples-pad: tests/data/asynth-44100-2.wav
+fate-filter-asetnsamples-pad: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.wav
+fate-filter-asetnsamples-pad: CMD = framecrc -i $(SRC) -af asetnsamples=512:p=1
+
+FATE_AFILTER-$(call FILTERDEMDECENCMUX, ASETNSAMPLES, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-asetnsamples-nopad
+fate-filter-asetnsamples-nopad: tests/data/asynth-44100-2.wav
+fate-filter-asetnsamples-nopad: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.wav
+fate-filter-asetnsamples-nopad: CMD = framecrc -i $(SRC) -af asetnsamples=512:p=0
 
 FATE_AFILTER-$(call FILTERDEMDECENCMUX, ASETRATE, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-asetrate
 fate-filter-asetrate: tests/data/asynth-44100-2.wav
 fate-filter-asetrate: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.wav
-fate-filter-asetrate: CMD = framecrc -i $(SRC) -aframes 20 -af asetrate=20000
+fate-filter-asetrate: CMD = framecrc -i $(SRC) -frames:a 20 -af asetrate=20000
 
 FATE_AFILTER-$(call FILTERDEMDECENCMUX, CHORUS, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-chorus
 fate-filter-chorus: tests/data/asynth-22050-1.wav
 fate-filter-chorus: SRC = $(TARGET_PATH)/tests/data/asynth-22050-1.wav
-fate-filter-chorus: CMD = framecrc -i $(SRC) -aframes 10 -af chorus=0.050001:0.050002:64:0.050001:0.025003:2.00004
+fate-filter-chorus: CMD = framecrc -i $(SRC) -frames:a 10 -af chorus=0.050001:0.050002:64:0.050001:0.025003:2.00004
 
 FATE_AFILTER-$(call FILTERDEMDECENCMUX, DCSHIFT, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-dcshift
 fate-filter-dcshift: tests/data/asynth-44100-2.wav
 fate-filter-dcshift: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.wav
-fate-filter-dcshift: CMD = framecrc -i $(SRC) -aframes 20 -af dcshift=shift=0.25:limitergain=0.05
+fate-filter-dcshift: CMD = framecrc -i $(SRC) -frames:a 20 -af dcshift=shift=0.25:limitergain=0.05
 
 FATE_AFILTER-$(call FILTERDEMDECENCMUX, EARWAX, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-earwax
 fate-filter-earwax: tests/data/asynth-44100-2.wav
 fate-filter-earwax: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.wav
-fate-filter-earwax: CMD = framecrc -i $(SRC) -aframes 20 -af earwax
+fate-filter-earwax: CMD = framecrc -i $(SRC) -frames:a 20 -af earwax
 
 FATE_AFILTER-$(call FILTERDEMDECENCMUX, EXTRASTEREO, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-extrastereo
 fate-filter-extrastereo: tests/data/asynth-44100-2.wav
 fate-filter-extrastereo: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.wav
-fate-filter-extrastereo: CMD = framecrc -i $(SRC) -aframes 20 -af extrastereo=m=2
+fate-filter-extrastereo: CMD = framecrc -i $(SRC) -frames:a 20 -af extrastereo=m=2
 
 FATE_AFILTER-$(call FILTERDEMDECENCMUX, FIREQUALIZER ATRIM VOLUME, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-firequalizer
 fate-filter-firequalizer: tests/data/asynth-44100-2.wav
 fate-filter-firequalizer: tests/data/filtergraphs/firequalizer
 fate-filter-firequalizer: REF = tests/data/asynth-44100-2.wav
-fate-filter-firequalizer: CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-44100-2.wav -filter_script $(TARGET_PATH)/tests/data/filtergraphs/firequalizer -f wav -acodec pcm_s16le -
+fate-filter-firequalizer: CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-44100-2.wav -filter_script $(TARGET_PATH)/tests/data/filtergraphs/firequalizer -f wav -c:a pcm_s16le -
 fate-filter-firequalizer: CMP = oneoff
 fate-filter-firequalizer: CMP_UNIT = s16
 fate-filter-firequalizer: SIZE_TOLERANCE = 1058400 - 1097208
 
 FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, SILENCEREMOVE, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-silenceremove
 fate-filter-silenceremove: SRC = $(TARGET_SAMPLES)/audio-reference/divertimenti_2ch_96kHz_s24.wav
-fate-filter-silenceremove: CMD = framecrc -i $(SRC) -aframes 30 -af silenceremove=0:0:0:-1:0:-90dB
+fate-filter-silenceremove: CMD = framecrc -i $(SRC) -frames:a 30 -af silenceremove=0:0:0:-1:0:-90dB
 
 FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, STEREOTOOLS, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-stereotools
 fate-filter-stereotools: SRC = $(TARGET_SAMPLES)/audio-reference/luckynight_2ch_44kHz_s16.wav
-fate-filter-stereotools: CMD = framecrc -i $(SRC) -aframes 20 -af stereotools=mlev=0.015625
+fate-filter-stereotools: CMD = framecrc -i $(SRC) -frames:a 20 -af stereotools=mlev=0.015625
 
 FATE_AFILTER-$(call FILTERDEMDECENCMUX, TREMOLO, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-tremolo
 fate-filter-tremolo: tests/data/asynth-44100-2.wav
 fate-filter-tremolo: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.wav
-fate-filter-tremolo: CMD = framecrc -i $(SRC) -aframes 20 -af tremolo
+fate-filter-tremolo: CMD = framecrc -i $(SRC) -frames:a 20 -af tremolo
 
 FATE_AFILTER-$(call FILTERDEMDECENCMUX, COMPAND, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-filter-compand
 fate-filter-compand: tests/data/asynth-44100-2.wav
 fate-filter-compand: tests/data/filtergraphs/compand
 fate-filter-compand: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.wav
-fate-filter-compand: CMD = framecrc -i $(SRC) -aframes 20 -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/compand
+fate-filter-compand: CMD = framecrc -i $(SRC) -frames:a 20 -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/compand
 
 tests/data/hls-list.m3u8: TAG = GEN
 tests/data/hls-list.m3u8: ffmpeg$(PROGSSUF)$(EXESUF) | tests/data
 	$(M)$(TARGET_EXEC) $(TARGET_PATH)/$< \
-        -f lavfi -i "aevalsrc=cos(2*PI*t)*sin(2*PI*(440+4*t)*t)::d=20" -f segment -segment_time 10 -map 0 -flags +bitexact -codec:a mp2fixed \
+        -f lavfi -i "aevalsrc=cos(2*PI*t)*sin(2*PI*(440+4*t)*t):d=20" -f segment -segment_time 10 -map 0 -flags +bitexact -codec:a mp2fixed \
         -segment_list $(TARGET_PATH)/$@ -y $(TARGET_PATH)/tests/data/hls-out-%03d.ts 2>/dev/null
 
 FATE_AFILTER-$(call ALLYES, HLS_DEMUXER MPEGTS_MUXER MPEGTS_DEMUXER AEVALSRC_FILTER LAVFI_INDEV MP2FIXED_ENCODER) += fate-filter-hls
@@ -155,10 +160,10 @@ fate-filter-hls: CMD = framecrc -flags +bitexact -i $(TARGET_PATH)/tests/data/hl
 tests/data/hls-list-append.m3u8: TAG = GEN
 tests/data/hls-list-append.m3u8: ffmpeg$(PROGSSUF)$(EXESUF) | tests/data
 	$(M)$(TARGET_EXEC) $(TARGET_PATH)/$< \
-        -f lavfi -i "aevalsrc=cos(2*PI*t)*sin(2*PI*(440+4*t)*t)::d=20" -f segment -segment_time 10 -map 0 -flags +bitexact -codec:a mp2fixed \
+        -f lavfi -i "aevalsrc=cos(2*PI*t)*sin(2*PI*(440+4*t)*t):d=20" -f segment -segment_time 10 -map 0 -flags +bitexact -codec:a mp2fixed \
         -segment_list $(TARGET_PATH)/$@ -y $(TARGET_PATH)/tests/data/hls-append-out-%03d.ts 2>/dev/null; \
         $(TARGET_EXEC) $(TARGET_PATH)/$< \
-        -f lavfi -i "aevalsrc=cos(2*PI*t)*sin(2*PI*(440+4*t)*t)::d=20" -f hls -hls_time 10 -map 0 -flags +bitexact \
+        -f lavfi -i "aevalsrc=cos(2*PI*t)*sin(2*PI*(440+4*t)*t):d=20" -f hls -hls_time 10 -map 0 -flags +bitexact \
         -hls_flags append_list -codec:a mp2fixed -hls_segment_filename $(TARGET_PATH)/tests/data/hls-append-out-%03d.ts \
         $(TARGET_PATH)/tests/data/hls-list-append.m3u8 2>/dev/null
 
@@ -187,12 +192,6 @@ $(FATE_AMIX): SRC1 = $(TARGET_PATH)/tests/data/asynth-44100-2-2.wav
 $(FATE_AMIX): CMP  = oneoff
 $(FATE_AMIX): CMP_UNIT = f32
 
-FATE_AFILTER_SAMPLES-$(call FILTERDEMDECMUX, ASYNCTS, FLV, NELLYMOSER, PCM_S16LE) += fate-filter-asyncts
-fate-filter-asyncts: SRC = $(TARGET_SAMPLES)/nellymoser/nellymoser-discont.flv
-fate-filter-asyncts: CMD = pcm -analyzeduration 10000000 -i $(SRC) -af asyncts
-fate-filter-asyncts: CMP = oneoff
-fate-filter-asyncts: REF = $(SAMPLES)/nellymoser/nellymoser-discont-async-v3.pcm
-
 FATE_AFILTER_SAMPLES-$(CONFIG_ARESAMPLE_FILTER) += fate-filter-aresample
 fate-filter-aresample: SRC = $(TARGET_SAMPLES)/nellymoser/nellymoser-discont.flv
 fate-filter-aresample: CMD = pcm -analyzeduration 10000000 -i $(SRC) -af aresample=min_comp=0.001:min_hard_comp=0.1:first_pts=0
@@ -221,7 +220,7 @@ fate-filter-channelmap-one-int: SRC = $(TARGET_PATH)/tests/data/asynth-44100-6.w
 fate-filter-channelmap-one-int: tests/data/asynth-44100-6.wav
 fate-filter-channelmap-one-int: CMD = md5 -i $(SRC) -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/channelmap_one_int -f wav -fflags +bitexact
 fate-filter-channelmap-one-int: CMP = oneline
-fate-filter-channelmap-one-int: REF = 428b8f9fac6d57147069b97335019ef5
+fate-filter-channelmap-one-int: REF = 8cfe553d65ed4696756d8c1b824fcdd3
 
 FATE_FILTER_CHANNELMAP += fate-filter-channelmap-one-str
 fate-filter-channelmap-one-str: tests/data/filtergraphs/channelmap_one_str
@@ -229,7 +228,7 @@ fate-filter-channelmap-one-str: SRC = $(TARGET_PATH)/tests/data/asynth-44100-2.w
 fate-filter-channelmap-one-str: tests/data/asynth-44100-2.wav
 fate-filter-channelmap-one-str: CMD = md5 -i $(SRC) -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/channelmap_one_str -f wav -fflags +bitexact
 fate-filter-channelmap-one-str: CMP = oneline
-fate-filter-channelmap-one-str: REF = e788890db6a11c2fb29d7c4229072d49
+fate-filter-channelmap-one-str: REF = 0ea3052e482c95d5d3bd9da6dac1b5fa
 
 FATE_AFILTER-$(call FILTERDEMDECENCMUX, CHANNELMAP, WAV, PCM_S16LE, PCM_S16LE, WAV) += $(FATE_FILTER_CHANNELMAP)
 
@@ -255,17 +254,55 @@ fate-filter-volume: CMD = md5 -i $(SRC) -af aperms=random,volume=precision=fixed
 fate-filter-volume: CMP = oneline
 fate-filter-volume: REF = 4d6ba75ef3e32d305d066b9bc771d6f4
 
-FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd
-fate-filter-hdcd: SRC = $(TARGET_SAMPLES)/filter/hdcd.flac
-fate-filter-hdcd: CMD = md5 -i $(SRC) -af hdcd -f s24le
-fate-filter-hdcd: CMP = oneline
-fate-filter-hdcd: REF = 5db465a58d2fd0d06ca944b883b33476
-
-FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd-analyze
-fate-filter-hdcd-analyze: SRC = $(TARGET_SAMPLES)/filter/hdcd.flac
-fate-filter-hdcd-analyze: CMD = md5 -i $(SRC) -af hdcd=analyze_mode=pe -f s24le
-fate-filter-hdcd-analyze: CMP = oneline
-fate-filter-hdcd-analyze: REF = 6e39dc4629c1e84321c0d8bc069b42f6
+# hdcd-mix.flac is a mix of three different sources which are interesting for various reasons:
+# first 5 seconds uses packet format A and max LLE of -7.0db
+# second 5 seconds uses packet format B and has a gain mismatch between channels
+# last 10 seconds is not HDCD but has a coincidental HDCD packet, it needs to be 10 seconds because it also tests the cdt expiration
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd-mix
+fate-filter-hdcd-mix: SRC = $(TARGET_SAMPLES)/filter/hdcd-mix.flac
+fate-filter-hdcd-mix: CMD = md5 -i $(SRC) -af hdcd -f s24le
+fate-filter-hdcd-mix: CMP = oneline
+fate-filter-hdcd-mix: REF = e7079913e90c124460cdbc712df5b84c
+
+# output will be different because of the gain mismatch in the second and third parts
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd-mix-psoff
+fate-filter-hdcd-mix-psoff: SRC = $(TARGET_SAMPLES)/filter/hdcd-mix.flac
+fate-filter-hdcd-mix-psoff: CMD = md5 -i $(SRC) -af hdcd=process_stereo=false -f s24le
+fate-filter-hdcd-mix-psoff: CMP = oneline
+fate-filter-hdcd-mix-psoff: REF = bd0e81fe17696b825ee3515ab928e6bb
+
+# test the different analyze modes
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd-analyze-pe
+fate-filter-hdcd-analyze-pe: SRC = $(TARGET_SAMPLES)/filter/hdcd-mix.flac
+fate-filter-hdcd-analyze-pe: CMD = md5 -i $(SRC) -af hdcd=analyze_mode=pe -f s24le
+fate-filter-hdcd-analyze-pe: CMP = oneline
+fate-filter-hdcd-analyze-pe: REF = bb83e97bbd0064b9b1c0ef2f2c8f0c77
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd-analyze-lle
+fate-filter-hdcd-analyze-lle: SRC = $(TARGET_SAMPLES)/filter/hdcd-mix.flac
+fate-filter-hdcd-analyze-lle: CMD = md5 -i $(SRC) -af hdcd=analyze_mode=lle -f s24le
+fate-filter-hdcd-analyze-lle: CMP = oneline
+fate-filter-hdcd-analyze-lle: REF = 121cc4a681aa0caef5c664fece7a3ddc
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd-analyze-cdt
+fate-filter-hdcd-analyze-cdt: SRC = $(TARGET_SAMPLES)/filter/hdcd-mix.flac
+fate-filter-hdcd-analyze-cdt: CMD = md5 -i $(SRC) -af hdcd=analyze_mode=cdt -f s24le
+fate-filter-hdcd-analyze-cdt: CMP = oneline
+fate-filter-hdcd-analyze-cdt: REF = 12136e6a00dd532994f6edcc347af1d4
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd-analyze-tgm
+fate-filter-hdcd-analyze-tgm: SRC = $(TARGET_SAMPLES)/filter/hdcd-mix.flac
+fate-filter-hdcd-analyze-tgm: CMD = md5 -i $(SRC) -af hdcd=analyze_mode=tgm -f s24le
+fate-filter-hdcd-analyze-tgm: CMP = oneline
+fate-filter-hdcd-analyze-tgm: REF = a3c39f62e9b9b42c9c440d0045d5fb2f
+# the two additional analyze modes from libhdcd
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd-analyze-ltgm
+fate-filter-hdcd-analyze-ltgm: SRC = $(TARGET_SAMPLES)/filter/hdcd-mix.flac
+fate-filter-hdcd-analyze-ltgm: CMD = md5 -i $(SRC) -af hdcd=analyze_mode=lle:process_stereo=false -f s24le
+fate-filter-hdcd-analyze-ltgm: CMP = oneline
+fate-filter-hdcd-analyze-ltgm: REF = 76ffd86b762b5a93332039f27e4c0c0e
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd-analyze-pel
+fate-filter-hdcd-analyze-pel: SRC = $(TARGET_SAMPLES)/filter/hdcd-mix.flac
+fate-filter-hdcd-analyze-pel: CMD = md5 -i $(SRC) -af hdcd=analyze_mode=pe:force_pe=true -f s24le
+fate-filter-hdcd-analyze-pel: CMP = oneline
+fate-filter-hdcd-analyze-pel: REF = 8156c5a3658d789ab46447d62151f5e9
 
 FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd-false-positive
 fate-filter-hdcd-false-positive: SRC = $(TARGET_SAMPLES)/filter/hdcd-false-positive.flac
@@ -279,6 +316,30 @@ fate-filter-hdcd-detect-errors: CMD = md5 -i $(SRC) -af hdcd -f s24le
 fate-filter-hdcd-detect-errors: CMP = grep
 fate-filter-hdcd-detect-errors: REF = detectable errors: [1-9]
 
+# 20bit HDCD
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, FLAC, FLAC, PCM_S32LE, PCM_S32LE) += fate-filter-hdcd-20bit
+fate-filter-hdcd-20bit: SRC = $(TARGET_SAMPLES)/filter/hdcd-fake20bit.flac
+fate-filter-hdcd-20bit: CMD = md5 -i $(SRC) -af hdcd=bits_per_sample=20 -f s32le
+fate-filter-hdcd-20bit: CMP = oneline
+fate-filter-hdcd-20bit: REF = 365ded883a4a92483b15b69babc81390
+
+# non-hdcd tests of different input formats for code coverage
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, WAV, PCM_S16LE, PCM_S24LE, PCM_S24LE) += fate-filter-hdcd-mono
+fate-filter-hdcd-mono: SRC = $(TARGET_SAMPLES)/audiomatch/tones_44100_mono.wav
+fate-filter-hdcd-mono: CMD = md5 -i $(SRC) -af hdcd -f s24le
+fate-filter-hdcd-mono: CMP = oneline
+fate-filter-hdcd-mono: REF = f51b114b20728e6a463a9491c643d166
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, WV, WAVPACK, PCM_S32LE, PCM_S32LE) += fate-filter-hdcd-s16p
+fate-filter-hdcd-s16p: SRC = $(TARGET_SAMPLES)/wavpack/lossless/16bit-partial.wv
+fate-filter-hdcd-s16p: CMD = md5 -i $(SRC) -af hdcd -f s32le
+fate-filter-hdcd-s16p: CMP = oneline
+fate-filter-hdcd-s16p: REF = 4e767f436b891ac59810a8b2b1d7e96b
+FATE_AFILTER_SAMPLES-$(call FILTERDEMDECENCMUX, HDCD, WV, WAVPACK, PCM_S32LE, PCM_S32LE) += fate-filter-hdcd-s32p
+fate-filter-hdcd-s32p: SRC = $(TARGET_SAMPLES)/wavpack/lossless/24bit-partial.wv
+fate-filter-hdcd-s32p: CMD = md5 -i $(SRC) -af hdcd -f s32le
+fate-filter-hdcd-s32p: CMP = oneline
+fate-filter-hdcd-s32p: REF = 0c5513e83eedaa10ab6fac9ddc173cf5
+
 FATE_AFILTER-yes += fate-filter-formats
 fate-filter-formats: libavfilter/tests/formats$(EXESUF)
 fate-filter-formats: CMD = run libavfilter/tests/formats
diff --git a/mythtv/external/FFmpeg/tests/fate/filter-video.mak b/mythtv/external/FFmpeg/tests/fate/filter-video.mak
index e2513f52496..c19f301ff8d 100644
--- a/mythtv/external/FFmpeg/tests/fate/filter-video.mak
+++ b/mythtv/external/FFmpeg/tests/fate/filter-video.mak
@@ -1,38 +1,45 @@
+FATE_FILTER_SAMPLES-$(call ALLYES, SMJPEG_DEMUXER MJPEG_DECODER PERMS_FILTER OWDENOISE_FILTER) += fate-filter-owdenoise-sample
+fate-filter-owdenoise-sample: CMD = ffmpeg -idct simple -i $(TARGET_SAMPLES)/smjpeg/scenwin.mjpg -vf "trim=duration=0.5,perms=random,owdenoise=10:20:20:enable=not(between(t\,0.2\,1.2))" -an -f rawvideo -
+fate-filter-owdenoise-sample: REF = $(TARGET_SAMPLES)/filter-reference/owdenoise-scenwin.raw
+fate-filter-owdenoise-sample: CMP_TARGET = 1
+fate-filter-owdenoise-sample: FUZZ = 3539
+fate-filter-owdenoise-sample: CMP = oneoff
+
 FATE_FILTER_SAMPLES-$(call ALLYES, PERMS_FILTER DELOGO_FILTER RM_DEMUXER RV30_DECODER) += fate-filter-delogo
 fate-filter-delogo: CMD = framecrc -i $(TARGET_SAMPLES)/real/rv30.rm -vf perms=random,delogo=show=0:x=290:y=25:w=26:h=16 -an
 
 FATE_YADIF += fate-filter-yadif-mode0
-fate-filter-yadif-mode0: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -vframes 30 -vf yadif=0
+fate-filter-yadif-mode0: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -frames:v 30 -vf yadif=0
 
 FATE_YADIF += fate-filter-yadif-mode1
-fate-filter-yadif-mode1: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -vframes 59 -vf yadif=1
+fate-filter-yadif-mode1: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -frames:v 59 -vf yadif=1
 
 FATE_YADIF += fate-filter-yadif10
-fate-filter-yadif10: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -flags bitexact -pix_fmt yuv420p10le -vframes 30 -vf yadif=0
+fate-filter-yadif10: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -flags bitexact -pix_fmt yuv420p10le -frames:v 30 -vf yadif=0
 
 FATE_YADIF += fate-filter-yadif16
-fate-filter-yadif16: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -flags bitexact -pix_fmt yuv420p16le -vframes 30 -vf yadif=0
+fate-filter-yadif16: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -flags bitexact -pix_fmt yuv420p16le -frames:v 30 -vf yadif=0
 
 FATE_FILTER_SAMPLES-$(call FILTERDEMDEC, YADIF, MPEGTS, MPEG2VIDEO) += $(FATE_YADIF)
 
 FATE_W3FDIF += fate-filter-w3fdif-simple
-fate-filter-w3fdif-simple: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -vframes 30 -vf w3fdif=0
+fate-filter-w3fdif-simple: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -frames:v 30 -vf w3fdif=0
 
 FATE_W3FDIF += fate-filter-w3fdif-complex
-fate-filter-w3fdif-complex: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -vframes 30 -vf w3fdif=1
+fate-filter-w3fdif-complex: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -frames:v 30 -vf w3fdif=1
 
 FATE_FILTER_SAMPLES-$(call FILTERDEMDEC, W3FDIF, MPEGTS, MPEG2VIDEO) += $(FATE_W3FDIF)
 
 FATE_MCDEINT += fate-filter-mcdeint-fast
-fate-filter-mcdeint-fast: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -vframes 30 -vf mcdeint=fast
+fate-filter-mcdeint-fast: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -frames:v 30 -vf mcdeint=fast
 
 FATE_MCDEINT += fate-filter-mcdeint-medium
-fate-filter-mcdeint-medium: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -vframes 30 -vf mcdeint=mode=medium
+fate-filter-mcdeint-medium: CMD = framecrc -flags bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -frames:v 30 -vf mcdeint=mode=medium
 
 FATE_FILTER_SAMPLES-$(call ALLYES, MCDEINT_FILTER, MPEGTS_DEMUXER, MPEG2VIDEO_DECODER SNOW_ENCODER) += $(FATE_MCDEINT)
 
 FATE_FILTER_SAMPLES-$(call ALLYES, CODECVIEW_FILTER RM_DEMUXER RV40_DECODER) += fate-filter-codecview-mvs
-fate-filter-codecview-mvs: CMD = framecrc -flags2 +export_mvs -i $(TARGET_SAMPLES)/real/spygames-2MB.rmvb -vf codecview=mv=pf+bf+bb -vframes 60 -an
+fate-filter-codecview-mvs: CMD = framecrc -flags2 +export_mvs -i $(TARGET_SAMPLES)/real/spygames-2MB.rmvb -vf codecview=mv=pf+bf+bb -frames:v 60 -an
 
 FATE_FILTER_SAMPLES-$(call ALLYES, SHOWPALETTE_FILTER FLIC_DEMUXER FLIC_DECODER) += fate-filter-showpalette
 fate-filter-showpalette: CMD = framecrc -i $(TARGET_SAMPLES)/fli/fli-engines.fli -vf showpalette=3 -pix_fmt bgra
@@ -73,11 +80,39 @@ fate-filter-testsrc2-yuv444p: CMD = framecrc -lavfi testsrc2=r=7:d=10 -pix_fmt y
 FATE_FILTER-$(call ALLYES, TESTSRC2_FILTER) += fate-filter-testsrc2-rgb24
 fate-filter-testsrc2-rgb24: CMD = framecrc -lavfi testsrc2=r=7:d=10 -pix_fmt rgb24
 
+FATE_FILTER-$(call ALLYES, LAVFI_INDEV TESTSRC2_FILTER) += fate-filter-testsrc2-rgba
+fate-filter-testsrc2-rgba: CMD = framecrc -lavfi testsrc2=r=7:d=10 -pix_fmt rgba
+
+FATE_FILTER-$(call ALLYES, LAVFI_INDEV ALLRGB_FILTER) += fate-filter-allrgb
+fate-filter-allrgb: CMD = framecrc -lavfi allrgb=rate=5:duration=1 -pix_fmt rgb24
+
+FATE_FILTER-$(call ALLYES, LAVFI_INDEV ALLYUV_FILTER) += fate-filter-allyuv
+fate-filter-allyuv: CMD = framecrc -lavfi allyuv=rate=5:duration=1 -pix_fmt yuv444p
+
+FATE_FILTER-$(call ALLYES, LAVFI_INDEV RGBTESTSRC_FILTER) += fate-filter-rgbtestsrc
+fate-filter-rgbtestsrc: CMD = framecrc -lavfi rgbtestsrc=rate=5:duration=1 -pix_fmt rgb24
+
+FATE_FILTER-$(call ALLYES, LAVFI_INDEV SMPTEBARS_FILTER) += fate-filter-smptebars
+fate-filter-smptebars: CMD = framecrc -lavfi smptebars=rate=5:duration=1 -pix_fmt yuv420p
+
+FATE_FILTER-$(call ALLYES, LAVFI_INDEV SMPTEHDBARS_FILTER) += fate-filter-smptehdbars
+fate-filter-smptehdbars: CMD = framecrc -lavfi smptehdbars=rate=5:duration=1 -pix_fmt yuv444p
+
+FATE_FILTER-$(call ALLYES, LAVFI_INDEV YUVTESTSRC_FILTER) += fate-filter-yuvtestsrc-yuv444p
+fate-filter-yuvtestsrc-yuv444p: CMD = framecrc -lavfi yuvtestsrc=rate=5:duration=1 -pix_fmt yuv444p
+
+FATE_FILTER-$(call ALLYES, LAVFI_INDEV YUVTESTSRC_FILTER) += fate-filter-yuvtestsrc-yuv444p12
+fate-filter-yuvtestsrc-yuv444p12: CMD = framecrc -lavfi yuvtestsrc=rate=5:duration=1,format=yuv444p12 -pix_fmt yuv444p12le
+
 FATE_FILTER-$(call ALLYES, AVDEVICE TESTSRC_FILTER FORMAT_FILTER CONCAT_FILTER SCALE_FILTER) += fate-filter-lavd-scalenorm
 fate-filter-lavd-scalenorm: tests/data/filtergraphs/scalenorm
 fate-filter-lavd-scalenorm: CMD = framecrc -f lavfi -graph_file $(TARGET_PATH)/tests/data/filtergraphs/scalenorm -i dummy
 
 
+FATE_FILTER-$(call ALLYES, FRAMERATE_FILTER TESTSRC2_FILTER) += fate-filter-framerate-up fate-filter-framerate-down
+fate-filter-framerate-up: CMD = framecrc -lavfi testsrc2=r=2:d=10,framerate=fps=10 -t 1
+fate-filter-framerate-down: CMD = framecrc -lavfi testsrc2=r=2:d=10,framerate=fps=1 -t 1
+
 FATE_FILTER_VSYNTH-$(CONFIG_BOXBLUR_FILTER) += fate-filter-boxblur
 fate-filter-boxblur: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf boxblur=2:1
 
@@ -112,6 +147,9 @@ fate-filter-hqdn3d: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf hqdn3d
 FATE_FILTER_VSYNTH-$(CONFIG_INTERLACE_FILTER) += fate-filter-interlace
 fate-filter-interlace: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf interlace
 
+FATE_FILTER_VSYNTH-$(CONFIG_INTERLACE_FILTER) += fate-filter-interlace-complex
+fate-filter-interlace-complex: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf interlace=lowpass=complex
+
 FATE_FILTER_VSYNTH-$(call ALLYES, NEGATE_FILTER PERMS_FILTER) += fate-filter-negate
 fate-filter-negate: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf perms=random,negate
 
@@ -131,22 +169,22 @@ FATE_FILTER_VSYNTH-$(CONFIG_WAVEFORM_FILTER) += fate-filter-waveform_uv
 fate-filter-waveform_uv: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf waveform=c=6 -flags +bitexact -sws_flags +accurate_rnd+bitexact
 
 FATE_FILTER_VSYNTH-$(CONFIG_VECTORSCOPE_FILTER) += fate-filter-vectorscope_gray
-fate-filter-vectorscope_gray: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=gray -sws_flags +accurate_rnd+bitexact -vframes 3
+fate-filter-vectorscope_gray: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=gray -sws_flags +accurate_rnd+bitexact -frames:v 3
 
 FATE_FILTER_VSYNTH-$(CONFIG_VECTORSCOPE_FILTER) += fate-filter-vectorscope_color
-fate-filter-vectorscope_color: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=color -sws_flags +accurate_rnd+bitexact -vframes 3
+fate-filter-vectorscope_color: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=color -sws_flags +accurate_rnd+bitexact -frames:v 3
 
 FATE_FILTER_VSYNTH-$(CONFIG_VECTORSCOPE_FILTER) += fate-filter-vectorscope_color2
-fate-filter-vectorscope_color2: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=color2 -sws_flags +accurate_rnd+bitexact -vframes 3
+fate-filter-vectorscope_color2: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=color2 -sws_flags +accurate_rnd+bitexact -frames:v 3
 
 FATE_FILTER_VSYNTH-$(CONFIG_VECTORSCOPE_FILTER) += fate-filter-vectorscope_color3
-fate-filter-vectorscope_color3: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=color3 -sws_flags +accurate_rnd+bitexact -vframes 3
+fate-filter-vectorscope_color3: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=color3 -sws_flags +accurate_rnd+bitexact -frames:v 3
 
 FATE_FILTER_VSYNTH-$(CONFIG_VECTORSCOPE_FILTER) += fate-filter-vectorscope_color4
-fate-filter-vectorscope_color4: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=color4 -sws_flags +accurate_rnd+bitexact -vframes 3
+fate-filter-vectorscope_color4: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=color4 -sws_flags +accurate_rnd+bitexact -frames:v 3
 
 FATE_FILTER_VSYNTH-$(CONFIG_VECTORSCOPE_FILTER) += fate-filter-vectorscope_xy
-fate-filter-vectorscope_xy: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=x=0:y=1 -sws_flags +accurate_rnd+bitexact -vframes 3
+fate-filter-vectorscope_xy: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf vectorscope=x=0:y=1 -sws_flags +accurate_rnd+bitexact -frames:v 3
 
 FATE_FILTER_VSYNTH-$(CONFIG_MERGEPLANES_FILTER) += fate-filter-mergeplanes
 fate-filter-mergeplanes: tests/data/filtergraphs/mergeplanes
@@ -172,6 +210,16 @@ FATE_FILTER_VSYNTH-$(call ALLYES, SPLIT_FILTER SCALE_FILTER PAD_FILTER OVERLAY_F
 fate-filter-overlay_yuv420: tests/data/filtergraphs/overlay_yuv420
 fate-filter-overlay_yuv420: CMD = framecrc -c:v pgmyuv -i $(SRC) -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/overlay_yuv420
 
+FATE_FILTER_VSYNTH-$(call ALLYES, SPLIT_FILTER SCALE_FILTER PAD_FILTER OVERLAY_FILTER) += fate-filter-overlay_nv12
+fate-filter-overlay_nv12: tests/data/filtergraphs/overlay_nv12
+fate-filter-overlay_nv12: CMD = framecrc -c:v pgmyuv -i $(SRC) -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/overlay_nv12
+fate-filter-overlay_nv12: REF = $(SRC_PATH)/tests/ref/fate/filter-overlay_yuv420
+
+FATE_FILTER_VSYNTH-$(call ALLYES, SPLIT_FILTER SCALE_FILTER PAD_FILTER OVERLAY_FILTER) += fate-filter-overlay_nv21
+fate-filter-overlay_nv21: tests/data/filtergraphs/overlay_nv21
+fate-filter-overlay_nv21: CMD = framecrc -c:v pgmyuv -i $(SRC) -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/overlay_nv21
+fate-filter-overlay_nv21: REF = $(SRC_PATH)/tests/ref/fate/filter-overlay_yuv420
+
 FATE_FILTER_VSYNTH-$(call ALLYES, SPLIT_FILTER SCALE_FILTER PAD_FILTER OVERLAY_FILTER) += fate-filter-overlay_yuv422
 fate-filter-overlay_yuv422: tests/data/filtergraphs/overlay_yuv422
 fate-filter-overlay_yuv422: CMD = framecrc -c:v pgmyuv -i $(SRC) -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/overlay_yuv422
@@ -180,83 +228,102 @@ FATE_FILTER_VSYNTH-$(call ALLYES, SPLIT_FILTER SCALE_FILTER PAD_FILTER OVERLAY_F
 fate-filter-overlay_yuv444: tests/data/filtergraphs/overlay_yuv444
 fate-filter-overlay_yuv444: CMD = framecrc -c:v pgmyuv -i $(SRC) -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/overlay_yuv444
 
+FATE_FILTER_OVERLAY_ALPHA += fate-filter-overlay_yuv420_yuva420  fate-filter-overlay_yuv422_yuva422  fate-filter-overlay_yuv444_yuva444  fate-filter-overlay_rgb_rgba  fate-filter-overlay_gbrp_gbrap
+FATE_FILTER_OVERLAY_ALPHA += fate-filter-overlay_yuva420_yuva420 fate-filter-overlay_yuva422_yuva422 fate-filter-overlay_yuva444_yuva444 fate-filter-overlay_rgba_rgba fate-filter-overlay_gbrap_gbrap
+$(FATE_FILTER_OVERLAY_ALPHA): SRC = $(TARGET_SAMPLES)/png1/lena-rgba.png
+$(FATE_FILTER_OVERLAY_ALPHA): CMD = framecrc -i $(SRC) -sws_flags +accurate_rnd+bitexact -vf $(FILTER) -frames:v 1
+
+fate-filter-overlay_yuv420_yuva420:  FILTER = "format=yuva420p[over];color=black:128x128,format=yuv420p[main];[main][over]overlay=format=yuv420"
+fate-filter-overlay_yuv422_yuva422:  FILTER = "format=yuva422p[over];color=black:128x128,format=yuv422p[main];[main][over]overlay=format=yuv422"
+fate-filter-overlay_yuv444_yuva444:  FILTER = "format=yuva444p[over];color=black:128x128,format=yuv444p[main];[main][over]overlay=format=yuv444"
+fate-filter-overlay_rgb_rgba:        FILTER = "format=rgba[over];color=black:128x128,format=rgb24[main];[main][over]overlay=format=rgb"
+fate-filter-overlay_gbrp_gbrap:      FILTER = "format=gbrap[over];color=black:128x128,format=gbrp[main];[main][over]overlay=format=gbrp"
+
+fate-filter-overlay_yuva420_yuva420: FILTER = "format=yuva420p[over];color=black:128x128,format=yuva420p[main];[main][over]overlay=format=yuv420"
+fate-filter-overlay_yuva422_yuva422: FILTER = "format=yuva422p[over];color=black:128x128,format=yuva422p[main];[main][over]overlay=format=yuv422"
+fate-filter-overlay_yuva444_yuva444: FILTER = "format=yuva444p[over];color=black:128x128,format=yuva444p[main];[main][over]overlay=format=yuv444"
+fate-filter-overlay_rgba_rgba:       FILTER = "format=rgba[over];color=black:128x128,format=rgba[main];[main][over]overlay=format=rgb"
+fate-filter-overlay_gbrap_gbrap:     FILTER = "format=gbrap[over];color=black:128x128,format=gbrap[main];[main][over]overlay=format=gbrp"
+
+FATE_FILTER_SAMPLES-$(call ALLYES, PNG_DECODER APNG_DEMUXER FORMAT_FILTER COLOR_FILTER OVERLAY_FILTER) += $(FATE_FILTER_OVERLAY_ALPHA)
+
 FATE_FILTER_VSYNTH-$(CONFIG_PHASE_FILTER) += fate-filter-phase
 fate-filter-phase: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf phase
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-00
-fate-filter-removegrain-mode-00: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=0:0:0
+fate-filter-removegrain-mode-00: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=0:0:0
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-01
-fate-filter-removegrain-mode-01: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=1:1:1
+fate-filter-removegrain-mode-01: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=1:1:1
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-02
-fate-filter-removegrain-mode-02: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=2:2:2
+fate-filter-removegrain-mode-02: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=2:2:2
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-03
-fate-filter-removegrain-mode-03: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=3:3:3
+fate-filter-removegrain-mode-03: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=3:3:3
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-04
-fate-filter-removegrain-mode-04: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=4:4:4
+fate-filter-removegrain-mode-04: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=4:4:4
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-05
-fate-filter-removegrain-mode-05: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=5:5:5
+fate-filter-removegrain-mode-05: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=5:5:5
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-06
-fate-filter-removegrain-mode-06: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=6:6:6
+fate-filter-removegrain-mode-06: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=6:6:6
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-07
-fate-filter-removegrain-mode-07: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=7:7:7
+fate-filter-removegrain-mode-07: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=7:7:7
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-08
-fate-filter-removegrain-mode-08: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=8:8:8
+fate-filter-removegrain-mode-08: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=8:8:8
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-09
-fate-filter-removegrain-mode-09: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=9:9:9
+fate-filter-removegrain-mode-09: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=9:9:9
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-10
-fate-filter-removegrain-mode-10: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=10:10:10
+fate-filter-removegrain-mode-10: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=10:10:10
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-11
-fate-filter-removegrain-mode-11: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=11:11:11
+fate-filter-removegrain-mode-11: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=11:11:11
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-12
-fate-filter-removegrain-mode-12: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=12:12:12
+fate-filter-removegrain-mode-12: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=12:12:12
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-13
-fate-filter-removegrain-mode-13: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=13:13:13
+fate-filter-removegrain-mode-13: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=13:13:13
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-14
-fate-filter-removegrain-mode-14: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=14:14:14
+fate-filter-removegrain-mode-14: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=14:14:14
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-15
-fate-filter-removegrain-mode-15: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=15:15:15
+fate-filter-removegrain-mode-15: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=15:15:15
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-16
-fate-filter-removegrain-mode-16: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=16:16:16
+fate-filter-removegrain-mode-16: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=16:16:16
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-17
-fate-filter-removegrain-mode-17: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=17:17:17
+fate-filter-removegrain-mode-17: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=17:17:17
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-18
-fate-filter-removegrain-mode-18: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=18:18:18
+fate-filter-removegrain-mode-18: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=18:18:18
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-19
-fate-filter-removegrain-mode-19: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=19:19:19
+fate-filter-removegrain-mode-19: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=19:19:19
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-20
-fate-filter-removegrain-mode-20: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=20:20:20
+fate-filter-removegrain-mode-20: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=20:20:20
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-21
-fate-filter-removegrain-mode-21: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=21:21:21
+fate-filter-removegrain-mode-21: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=21:21:21
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-22
-fate-filter-removegrain-mode-22: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=22:22:22
+fate-filter-removegrain-mode-22: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=22:22:22
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-23
-fate-filter-removegrain-mode-23: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=23:23:23
+fate-filter-removegrain-mode-23: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=23:23:23
 
 FATE_REMOVEGRAIN += fate-filter-removegrain-mode-24
-fate-filter-removegrain-mode-24: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 1 -vf removegrain=24:24:24
+fate-filter-removegrain-mode-24: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 1 -vf removegrain=24:24:24
 
 fate-filter-removegrain: $(FATE_REMOVEGRAIN)
 FATE_FILTER_VSYNTH-$(CONFIG_REMOVEGRAIN_FILTER) += $(FATE_REMOVEGRAIN)
@@ -265,7 +332,7 @@ FATE_FILTER_VSYNTH-$(CONFIG_SEPARATEFIELDS_FILTER) += fate-filter-separatefields
 fate-filter-separatefields: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf separatefields
 
 FATE_FILTER_VSYNTH-$(CONFIG_WEAVE_FILTER) += fate-filter-weave
-fate-filter-weave: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf weave
+fate-filter-weave: CMD = framecrc -c:v pgmyuv -i $(SRC) -vf weave=bottom
 
 FATE_FILTER_VSYNTH-$(CONFIG_SELECT_FILTER) += fate-filter-select-alternate
 fate-filter-select-alternate: tests/data/filtergraphs/select-alternate
@@ -389,6 +456,10 @@ fate-filter-scale200: CMD = video_filter "scale=w=200:h=200"
 FATE_FILTER_VSYNTH-$(CONFIG_SCALE_FILTER) += fate-filter-scale500
 fate-filter-scale500: CMD = video_filter "scale=w=500:h=500"
 
+FATE_FILTER_VSYNTH-$(CONFIG_SCALE2REF_FILTER) += fate-filter-scale2ref_keep_aspect
+fate-filter-scale2ref_keep_aspect: tests/data/filtergraphs/scale2ref_keep_aspect
+fate-filter-scale2ref_keep_aspect: CMD = framemd5 -frames:v 5 -filter_complex_script $(TARGET_PATH)/tests/data/filtergraphs/scale2ref_keep_aspect -map "[main]"
+
 FATE_FILTER_VSYNTH-$(CONFIG_SCALE_FILTER) += fate-filter-scalechroma
 fate-filter-scalechroma: tests/data/vsynth1.yuv
 fate-filter-scalechroma: CMD = framecrc -flags bitexact -s 352x288 -pix_fmt yuv444p -i tests/data/vsynth1.yuv -pix_fmt yuv420p -sws_flags +bitexact -vf scale=out_v_chr_pos=33:out_h_chr_pos=151
@@ -409,16 +480,16 @@ FATE_FILTER_VSYNTH-$(CONFIG_VFLIP_FILTER) += fate-filter-vflip_vflip
 fate-filter-vflip_vflip: CMD = video_filter "vflip,vflip"
 
 FATE_FILTER_VSYNTH-$(call ALLYES, FORMAT_FILTER PERMS_FILTER EDGEDETECT_FILTER) += fate-filter-edgedetect
-fate-filter-edgedetect: CMD = video_filter "format=gray,perms=random,edgedetect" -vframes 20
+fate-filter-edgedetect: CMD = video_filter "format=gray,perms=random,edgedetect" -frames:v 20
 
 FATE_FILTER_VSYNTH-$(call ALLYES, FORMAT_FILTER PERMS_FILTER EDGEDETECT_FILTER) += fate-filter-edgedetect-colormix
-fate-filter-edgedetect-colormix: CMD = video_filter "format=gbrp,perms=random,edgedetect=mode=colormix" -vframes 20
+fate-filter-edgedetect-colormix: CMD = video_filter "format=gbrp,perms=random,edgedetect=mode=colormix" -frames:v 20
 
 FATE_FILTER_VSYNTH-$(call ALLYES, PERMS_FILTER HUE_FILTER) += fate-filter-hue
-fate-filter-hue: CMD = video_filter "perms=random,hue=s=sin(2*PI*t)+1" -vframes 20
+fate-filter-hue: CMD = video_filter "perms=random,hue=s=sin(2*PI*t)+1" -frames:v 20
 
 FATE_FILTER_VSYNTH-$(CONFIG_IDET_FILTER) += fate-filter-idet
-fate-filter-idet: CMD = framecrc -flags bitexact -idct simple -i $(SRC) -vf idet -vframes 25 -flags +bitexact
+fate-filter-idet: CMD = framecrc -flags bitexact -idct simple -i $(SRC) -vf idet -frames:v 25 -flags +bitexact
 
 FATE_FILTER_VSYNTH-$(CONFIG_PAD_FILTER) += fate-filter-pad
 fate-filter-pad: CMD = video_filter "pad=iw*1.5:ih*1.5:iw*0.3:ih*0.2"
@@ -427,7 +498,7 @@ FATE_FILTER_PP = fate-filter-pp fate-filter-pp1 fate-filter-pp2 fate-filter-pp3
 FATE_FILTER_VSYNTH-$(CONFIG_PP_FILTER) += $(FATE_FILTER_PP)
 $(FATE_FILTER_PP): fate-vsynth1-mpeg4-qprd
 
-fate-filter-pp:  CMD = framecrc -flags bitexact -idct simple -i $(TARGET_PATH)/tests/data/fate/vsynth1-mpeg4-qprd.avi -vframes 5 -flags +bitexact -vf "pp=be/hb/vb/tn/l5/al"
+fate-filter-pp:  CMD = framecrc -flags bitexact -idct simple -i $(TARGET_PATH)/tests/data/fate/vsynth1-mpeg4-qprd.avi -frames:v 5 -flags +bitexact -vf "pp=be/hb/vb/tn/l5/al"
 fate-filter-pp1: CMD = video_filter "pp=fq|4/be/hb/vb/tn/l5/al"
 fate-filter-pp2: CMD = video_filter "qp=x+y,pp=be/h1/v1/lb"
 fate-filter-pp3: CMD = video_filter "qp=x+y,pp=be/ha|128|7/va/li"
@@ -439,7 +510,7 @@ FATE_FILTER_VSYNTH-$(call ALLYES, QP_FILTER PP_FILTER) += fate-filter-qp
 fate-filter-qp: CMD = video_filter "qp=17,pp=be/hb/vb/tn/l5/al"
 
 FATE_FILTER_VSYNTH-$(CONFIG_SELECT_FILTER) += fate-filter-select
-fate-filter-select: CMD = framecrc -flags bitexact -idct simple -i $(SRC) -vf "select=not(eq(mod(n\,2)\,0)+eq(mod(n\,3)\,0))" -vframes 25 -flags +bitexact
+fate-filter-select: CMD = framecrc -flags bitexact -idct simple -i $(SRC) -vf "select=not(eq(mod(n\,2)\,0)+eq(mod(n\,3)\,0))" -frames:v 25 -flags +bitexact
 
 FATE_FILTER_VSYNTH-$(CONFIG_SETDAR_FILTER) += fate-filter-setdar
 fate-filter-setdar: CMD = video_filter "setdar=dar=16/9"
@@ -448,70 +519,70 @@ FATE_FILTER_VSYNTH-$(CONFIG_SETSAR_FILTER) += fate-filter-setsar
 fate-filter-setsar: CMD = video_filter "setsar=sar=16/11"
 
 FATE_STEREO3D += fate-filter-stereo3d-al-sbsl
-fate-filter-stereo3d-al-sbsl: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=al:sbsl
+fate-filter-stereo3d-al-sbsl: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=al:sbsl
 
 FATE_STEREO3D += fate-filter-stereo3d-ar-abl
-fate-filter-stereo3d-ar-abl: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=ar:abl
+fate-filter-stereo3d-ar-abl: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=ar:abl
 
 FATE_STEREO3D += fate-filter-stereo3d-abr-mr
-fate-filter-stereo3d-abr-mr: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=abr:mr
+fate-filter-stereo3d-abr-mr: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=abr:mr
 
 FATE_STEREO3D += fate-filter-stereo3d-abr-ml
-fate-filter-stereo3d-abr-ml: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=abr:ml
+fate-filter-stereo3d-abr-ml: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=abr:ml
 
 FATE_STEREO3D  += fate-filter-stereo3d-sbsl-abl
-fate-filter-stereo3d-sbsl-abl: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:abl
+fate-filter-stereo3d-sbsl-abl: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:abl
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-abr
-fate-filter-stereo3d-sbsl-abr: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:abr
+fate-filter-stereo3d-sbsl-abr: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:abr
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-al
-fate-filter-stereo3d-sbsl-al: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:al
+fate-filter-stereo3d-sbsl-al: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:al
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-sbsr
-fate-filter-stereo3d-sbsl-sbsr: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:sbsr
+fate-filter-stereo3d-sbsl-sbsr: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:sbsr
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-agmc
-fate-filter-stereo3d-sbsl-agmc: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:agmc
+fate-filter-stereo3d-sbsl-agmc: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:agmc
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-agmd
-fate-filter-stereo3d-sbsl-agmd: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:agmd
+fate-filter-stereo3d-sbsl-agmd: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:agmd
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-agmg
-fate-filter-stereo3d-sbsl-agmg: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:agmg
+fate-filter-stereo3d-sbsl-agmg: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:agmg
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-agmh
-fate-filter-stereo3d-sbsl-agmh: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:agmh
+fate-filter-stereo3d-sbsl-agmh: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:agmh
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-arbg
-fate-filter-stereo3d-sbsl-arbg: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:arbg
+fate-filter-stereo3d-sbsl-arbg: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:arbg
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-arcc
-fate-filter-stereo3d-sbsl-arcc: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:arcc
+fate-filter-stereo3d-sbsl-arcc: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:arcc
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-arcd
-fate-filter-stereo3d-sbsl-arcd: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:arcd
+fate-filter-stereo3d-sbsl-arcd: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:arcd
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-arcg
-fate-filter-stereo3d-sbsl-arcg: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:arcg
+fate-filter-stereo3d-sbsl-arcg: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:arcg
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-arch
-fate-filter-stereo3d-sbsl-arch: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:arch
+fate-filter-stereo3d-sbsl-arch: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:arch
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-argg
-fate-filter-stereo3d-sbsl-argg: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:argg
+fate-filter-stereo3d-sbsl-argg: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:argg
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-aybc
-fate-filter-stereo3d-sbsl-aybc: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:aybc
+fate-filter-stereo3d-sbsl-aybc: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:aybc
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-aybd
-fate-filter-stereo3d-sbsl-aybd: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:aybd
+fate-filter-stereo3d-sbsl-aybd: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:aybd
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-aybg
-fate-filter-stereo3d-sbsl-aybg: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:aybg
+fate-filter-stereo3d-sbsl-aybg: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:aybg
 
 FATE_STEREO3D += fate-filter-stereo3d-sbsl-aybh
-fate-filter-stereo3d-sbsl-aybh: CMD = framecrc -c:v pgmyuv -i $(SRC) -vframes 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:aybh
+fate-filter-stereo3d-sbsl-aybh: CMD = framecrc -c:v pgmyuv -i $(SRC) -frames:v 5 -flags +bitexact -sws_flags +accurate_rnd+bitexact -vf stereo3d=sbsl:aybh
 
 fate-filter-stereo3d: $(FATE_STEREO3D)
 FATE_FILTER_VSYNTH-$(CONFIG_STEREO3D_FILTER) += $(FATE_STEREO3D)
@@ -524,7 +595,7 @@ fate-filter-tile: CMD = video_filter "tile=3x3:nb_frames=5:padding=7:margin=2"
 
 
 tests/pixfmts.mak: TAG = GEN
-tests/pixfmts.mak: ffmpeg$(PROGSSUF)$(EXESUF)
+tests/pixfmts.mak: ffmpeg$(PROGSSUF)$(EXESUF) | tests
 	$(M)printf "PIXFMTS = " > $@
 	$(Q)$(TARGET_EXEC) $(TARGET_PATH)/$< -pix_fmts list 2> /dev/null | awk 'NR > 8 && /^IO/ { printf $$2 " " }' >> $@
 	$(Q)printf "\n" >> $@
@@ -597,12 +668,18 @@ fate-filter-pixfmts-super2xsai: CMD = pixfmts
 FATE_FILTER_PIXFMTS-$(CONFIG_SWAPUV_FILTER) += fate-filter-pixfmts-swapuv
 fate-filter-pixfmts-swapuv: CMD = pixfmts
 
+FATE_FILTER_PIXFMTS-$(CONFIG_TINTERLACE_FILTER) += fate-filter-pixfmts-tinterlace_cvlpf
+fate-filter-pixfmts-tinterlace_cvlpf: CMD = pixfmts "interleave_top:cvlpf"
+
 FATE_FILTER_PIXFMTS-$(CONFIG_TINTERLACE_FILTER) += fate-filter-pixfmts-tinterlace_merge
 fate-filter-pixfmts-tinterlace_merge: CMD = pixfmts "merge"
 
 FATE_FILTER_PIXFMTS-$(CONFIG_TINTERLACE_FILTER) += fate-filter-pixfmts-tinterlace_pad
 fate-filter-pixfmts-tinterlace_pad: CMD = pixfmts "pad"
 
+FATE_FILTER_PIXFMTS-$(CONFIG_TINTERLACE_FILTER) += fate-filter-pixfmts-tinterlace_vlpf
+fate-filter-pixfmts-tinterlace_vlpf: CMD = pixfmts "interleave_top:vlpf"
+
 FATE_FILTER_PIXFMTS-$(CONFIG_VFLIP_FILTER) += fate-filter-pixfmts-vflip
 fate-filter-pixfmts-vflip: CMD = pixfmts
 
@@ -653,6 +730,14 @@ FATE_METADATA_FILTER-$(call ALLYES, $(READVITC_METADATA_DEPS)) += fate-filter-me
 fate-filter-metadata-readvitc-thr: SRC = $(TARGET_SAMPLES)/filter/sample-vitc.avi
 fate-filter-metadata-readvitc-thr: CMD = run $(FILTER_METADATA_COMMAND) "movie='$(SRC)',readvitc=thr_b=0.3:thr_w=0.5"
 
+AVF_PHASE_METER_DEPS = FFPROBE AVDEVICE LAVFI_INDEV AMOVIE_FILTER FLAC_DEMUXER FLAC_DECODER SINE_FILTER APHASEMETER_FILTER
+FATE_METADATA_FILTER-$(call ALLYES, $(AVF_PHASE_METER_DEPS)) += fate-filter-metadata-avf-aphase-meter-mono
+fate-filter-metadata-avf-aphase-meter-mono: CMD = run $(FILTER_METADATA_COMMAND) sine="frequency=1000:sample_rate=48000:duration=1,aphasemeter=video=0"
+
+FATE_METADATA_FILTER-$(call ALLYES, $(AVF_PHASE_METER_DEPS)) += fate-filter-metadata-avf-aphase-meter-out-of-phase
+fate-filter-metadata-avf-aphase-meter-out-of-phase: SRC = $(TARGET_SAMPLES)/filter/out-of-phase-1000hz.flac
+fate-filter-metadata-avf-aphase-meter-out-of-phase: CMD = run $(FILTER_METADATA_COMMAND) "amovie='$(SRC)',aphasemeter=video=0"
+
 tests/data/file4560-override2rotate0.mov: TAG = GEN
 tests/data/file4560-override2rotate0.mov: ffmpeg$(PROGSSUF)$(EXESUF) | tests/data
 	$(M)$(TARGET_EXEC) $(TARGET_PATH)/$< \
@@ -662,6 +747,20 @@ FATE_FILTER_SAMPLES-$(call ALLYES, MOV_DEMUXER H264_DECODER AAC_FIXED_DECODER PC
 fate-filter-meta-4560-rotate0: tests/data/file4560-override2rotate0.mov
 fate-filter-meta-4560-rotate0: CMD = framecrc -flags +bitexact -c:a aac_fixed -i $(TARGET_PATH)/tests/data/file4560-override2rotate0.mov
 
+REFCMP_DEPS = FFMPEG LAVFI_INDEV TESTSRC2_FILTER AVGBLUR_FILTER METADATA_FILTER
+
+FATE_FILTER_SAMPLES-$(call ALLYES, $(REFCMP_DEPS) PSNR_FILTER) += fate-filter-refcmp-psnr-rgb
+fate-filter-refcmp-psnr-rgb: CMD = refcmp_metadata psnr rgb24 0.001
+
+FATE_FILTER_SAMPLES-$(call ALLYES, $(REFCMP_DEPS) PSNR_FILTER) += fate-filter-refcmp-psnr-yuv
+fate-filter-refcmp-psnr-yuv: CMD = refcmp_metadata psnr yuv422p 0.0015
+
+FATE_FILTER_SAMPLES-$(call ALLYES, $(REFCMP_DEPS) SSIM_FILTER) += fate-filter-refcmp-ssim-rgb
+fate-filter-refcmp-ssim-rgb: CMD = refcmp_metadata ssim rgb24 0.015
+
+FATE_FILTER_SAMPLES-$(call ALLYES, $(REFCMP_DEPS) SSIM_FILTER) += fate-filter-refcmp-ssim-yuv
+fate-filter-refcmp-ssim-yuv: CMD = refcmp_metadata ssim yuv422p 0.015
+
 FATE_SAMPLES_FFPROBE += $(FATE_METADATA_FILTER-yes)
 FATE_SAMPLES_FFMPEG += $(FATE_FILTER_SAMPLES-yes)
 FATE_FFMPEG += $(FATE_FILTER-yes)
diff --git a/mythtv/external/FFmpeg/tests/fate/fits.mak b/mythtv/external/FFmpeg/tests/fate/fits.mak
new file mode 100644
index 00000000000..3d58f988070
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/fate/fits.mak
@@ -0,0 +1,59 @@
+tests/data/fits-multi.fits: TAG = GEN
+tests/data/fits-multi.fits: ffmpeg$(PROGSSUF)$(EXESUF) | tests/data
+	$(M)$(TARGET_EXEC) $(TARGET_PATH)/$< \
+        -i $(TARGET_SAMPLES)/gif/m4nb.gif \
+        -y $(TARGET_PATH)/$(@) 2>/dev/null
+
+#mapping of fits file formats to png filenames
+map.tests/data/lena-gray.fits    := gray8
+map.tests/data/lena-gbrp.fits    := rgb24
+map.tests/data/lena-gbrp16.fits  := rgb48
+map.tests/data/lena-gbrap16.fits := rgba64
+
+tests/data/lena%.fits: TAG = GEN
+tests/data/lena%.fits: NAME = $(map.$(@))
+tests/data/lena%.fits: ffmpeg$(PROGSSUF)$(EXESUF) | tests/data
+	$(M)$(TARGET_EXEC) $(TARGET_PATH)/$< \
+        -i $(TARGET_SAMPLES)/png1/lena-$(map.$(@)).png \
+        -y $(TARGET_PATH)/$(@) 2>/dev/null
+
+FATE_FITS_DEC-$(call DEMDEC, FITS, FITS) += fate-fitsdec-ext_data_min_max
+fate-fitsdec-ext_data_min_max: CMD = framecrc -i $(TARGET_SAMPLES)/fits/x0cj010ct_d0h.fit -pix_fmt gray16
+
+FATE_FITS_DEC-$(call DEMDEC, FITS, FITS) += fate-fitsdec-blank_bitpix32
+fate-fitsdec-blank_bitpix32: CMD = framecrc -blank_value 65535 -i $(TARGET_SAMPLES)/fits/file008.fits -pix_fmt gray16
+
+FATE_FITS_DEC-$(call DEMDEC, FITS, FITS) += fate-fitsdec-bitpix-32
+fate-fitsdec-bitpix-32: CMD = framecrc -i $(TARGET_SAMPLES)/fits/tst0005.fits -pix_fmt gray16
+
+FATE_FITS_DEC-$(call DEMDEC, FITS, FITS) += fate-fitsdec-bitpix-64
+fate-fitsdec-bitpix-64: CMD = framecrc -i $(TARGET_SAMPLES)/fits/tst0006.fits -pix_fmt gray16
+
+FATE_FITS_DEC-$(call ALLYES, GIF_DEMUXER FITS_DEMUXER GIF_DECODER FITS_DECODER FITS_ENCODER FITS_MUXER) += fate-fitsdec-multi
+fate-fitsdec-multi: tests/data/fits-multi.fits
+fate-fitsdec-multi: CMD = framecrc -i $(TARGET_PATH)/tests/data/fits-multi.fits -pix_fmt gbrap
+
+fate-fitsdec%: PIXFMT = $(word 3, $(subst -, ,$(@)))
+fate-fitsdec%: SRC = $(TARGET_PATH)/tests/data/lena-$(PIXFMT).fits
+fate-fitsdec%: CMD = framecrc -i $(SRC) -pix_fmt $(PIXFMT)
+
+FATE_FITS_DEC_PIXFMT = gray gbrp gbrp16 gbrap16
+$(FATE_FITS_DEC_PIXFMT:%=fate-fitsdec-%): fate-fitsdec-%: tests/data/lena-%.fits
+FATE_FITS_DEC-$(call ALLYES, FITS_DEMUXER IMAGE2_DEMUXER FITS_DECODER PNG_DECODER FITS_ENCODER FITS_MUXER) += $(FATE_FITS_DEC_PIXFMT:%=fate-fitsdec-%)
+
+FATE_FITS += $(FATE_FITS_DEC-yes)
+fate-fitsdec: $(FATE_FITS_DEC-yes)
+
+fate-fitsenc%: PIXFMT = $(word 3, $(subst -, ,$(@)))
+fate-fitsenc%: SRC = $(TARGET_PATH)/tests/data/fits-multi.fits
+fate-fitsenc%: CMD = framecrc -i $(SRC) -c:v fits -pix_fmt $(PIXFMT)
+
+FATE_FITS_ENC_PIXFMT = gray gray16be gbrp gbrap gbrp16be gbrap16be
+$(FATE_FITS_ENC_PIXFMT:%=fate-fitsenc-%): tests/data/fits-multi.fits
+FATE_FITS_ENC-$(call ALLYES, GIF_DEMUXER GIF_DECODER FITS_ENCODER FITS_MUXER) += $(FATE_FITS_ENC_PIXFMT:%=fate-fitsenc-%)
+
+FATE_FITS += $(FATE_FITS_ENC-yes)
+fate-fitsenc: $(FATE_FITS_ENC-yes)
+
+FATE_SAMPLES_FFMPEG += $(FATE_FITS)
+fate-fits: $(FATE_FITS)
diff --git a/mythtv/external/FFmpeg/tests/fate/flvenc.mak b/mythtv/external/FFmpeg/tests/fate/flvenc.mak
new file mode 100644
index 00000000000..4fdeeff4c15
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/fate/flvenc.mak
@@ -0,0 +1,11 @@
+tests/data/add_keyframe_index.flv: TAG = GEN
+tests/data/add_keyframe_index.flv: ffmpeg$(PROGSSUF)$(EXESUF) | tests/data
+	$(M)$(TARGET_EXEC) $(TARGET_PATH)/$< \
+		-f lavfi -i "sws_flags=+accurate_rnd+bitexact;testsrc=r=7:n=2:d=20" -sws_flags '+accurate_rnd+bitexact' -metadata "encoder=Lavf" -pix_fmt yuv420p -c:v flv1 -g 7 -f flv -flags +bitexact -fflags +bitexact \
+		-flvflags add_keyframe_index -idct simple -dct int -y $(TARGET_PATH)/tests/data/add_keyframe_index.flv 2> /dev/null;
+
+FATE_AFILTER-$(call ALLYES, FLV_MUXER FLV_DEMUXER AVDEVICE TESTSRC_FILTER LAVFI_INDEV FLV_ENCODER) += fate-flv-add_keyframe_index
+fate-flv-add_keyframe_index: tests/data/add_keyframe_index.flv
+fate-flv-add_keyframe_index: CMD = ffmetadata -flags +bitexact -i $(TARGET_PATH)/tests/data/add_keyframe_index.flv
+
+
diff --git a/mythtv/external/FFmpeg/tests/fate/h264.mak b/mythtv/external/FFmpeg/tests/fate/h264.mak
index b4d7f7a6b20..043e1f2d19d 100644
--- a/mythtv/external/FFmpeg/tests/fate/h264.mak
+++ b/mythtv/external/FFmpeg/tests/fate/h264.mak
@@ -191,20 +191,33 @@ FATE_H264_REINIT_TESTS := large_420_8-to-small_420_8                    \
 FATE_H264  := $(FATE_H264:%=fate-h264-conformance-%)                    \
               $(FATE_H264_REINIT_TESTS:%=fate-h264-reinit-%)            \
               fate-h264-extreme-plane-pred                              \
+              fate-h264-intra-refresh-recovery                          \
               fate-h264-lossless                                        \
               fate-h264-3386                                            \
+              fate-h264-missing-frame                                   \
 
 FATE_H264-$(call DEMDEC, H264, H264) += $(FATE_H264)
 FATE_H264-$(call DEMDEC,  MOV, H264) += fate-h264-crop-to-container
+
+# this sample has two stsd entries and needs to reload extradata
+FATE_H264-$(call DEMDEC,  MOV, H264) += fate-h264-extradata-reload
+
 FATE_H264-$(call DEMDEC,  MOV, H264) += fate-h264-interlace-crop
 
 # this sample has invalid reference list modification, but decodes fine
 # by using a previous ref frame instead of a missing one
 FATE_H264-$(call DEMDEC,  MOV, H264) += fate-h264-invalid-ref-mod
 
+# this sample gives an explicit size for a single NAL unit, but contains
+# several NAL units
+FATE_H264-$(call DEMDEC,  MOV, H264) += fate-h264-mixed-nal-coding
+
 # this sample has invalid extradata that is not escaped
 FATE_H264-$(call DEMDEC,  MOV, H264) += fate-h264-unescaped-extradata
 
+# this sample contains field-coded frames, with both fields in a single packet
+FATE_H264-$(call DEMDEC,  MOV, H264) += fate-h264-twofields-packet
+
 FATE_H264-$(call ALLYES, MOV_DEMUXER H264_MP4TOANNEXB_BSF H264_MUXER) += fate-h264-bsf-mp4toannexb
 FATE_H264-$(call DEMDEC, MATROSKA, H264) += fate-h264-direct-bff
 FATE_H264-$(call DEMDEC, FLV, H264) += fate-h264-brokensps-2580
@@ -405,21 +418,26 @@ fate-h264-conformance-sva_fm1_e:                  CMD = framecrc -vsync drop -i
 fate-h264-conformance-sva_nl1_b:                  CMD = framecrc -vsync drop -i $(TARGET_SAMPLES)/h264-conformance/SVA_NL1_B.264
 fate-h264-conformance-sva_nl2_e:                  CMD = framecrc -vsync drop -i $(TARGET_SAMPLES)/h264-conformance/SVA_NL2_E.264
 
-fate-h264-bsf-mp4toannexb:                        CMD = md5 -i $(TARGET_SAMPLES)/h264/interlaced_crop.mp4 -vcodec copy -f h264
+fate-h264-bsf-mp4toannexb:                        CMD = md5 -i $(TARGET_SAMPLES)/h264/interlaced_crop.mp4 -c:v copy -f h264
 
 fate-h264-crop-to-container:                      CMD = framemd5 -i $(TARGET_SAMPLES)/h264/crop-to-container-dims-canon.mov
-fate-h264-extreme-plane-pred:                     CMD = framemd5 -i $(TARGET_SAMPLES)/h264/extreme-plane-pred.h264
-fate-h264-interlace-crop:                         CMD = framecrc -i $(TARGET_SAMPLES)/h264/interlaced_crop.mp4 -vframes 3
-fate-h264-lossless:                               CMD = framecrc -i $(TARGET_SAMPLES)/h264/lossless.h264
 fate-h264-direct-bff:                             CMD = framecrc -i $(TARGET_SAMPLES)/h264/direct-bff.mkv
+fate-h264-extradata-reload:                       CMD = framemd5 -i $(TARGET_SAMPLES)/h264/extradata-reload-multi-stsd.mov
+fate-h264-extreme-plane-pred:                     CMD = framemd5 -i $(TARGET_SAMPLES)/h264/extreme-plane-pred.h264
+fate-h264-interlace-crop:                         CMD = framecrc -i $(TARGET_SAMPLES)/h264/interlaced_crop.mp4 -frames:v 3
 fate-h264-brokensps-2580:                         CMD = framecrc -i $(TARGET_SAMPLES)/h264/brokensps.flv -vf format=yuv420p,scale=w=192:h=144 -sws_flags bitexact+bilinear
 fate-h264-xavc-4389:                              CMD = framecrc -i $(TARGET_SAMPLES)/h264/SonyXAVC_LongGOP_green_pixelation_early_Frames.MXF -pix_fmt yuv422p10le
-fate-h264-attachment-631:                         CMD = framecrc -i $(TARGET_SAMPLES)/h264/attachment631-small.mp4 -an -max_error_rate 0.95
+fate-h264-attachment-631:                         CMD = framecrc -i $(TARGET_SAMPLES)/h264/attachment631-small.mp4 -an -max_error_rate 0.96
 fate-h264-skip-nokey:                             CMD = framecrc -skip_frame nokey -i $(TARGET_SAMPLES)/h264/h264_intra_first-small.ts
 fate-h264-skip-nointra:                           CMD = framecrc -skip_frame nointra -i $(TARGET_SAMPLES)/h264/h264_intra_first-small.ts
+fate-h264-intra-refresh-recovery:                 CMD = framecrc -i $(TARGET_SAMPLES)/h264/intra_refresh.h264 -frames:v 10
 fate-h264-invalid-ref-mod:                        CMD = framecrc -i $(TARGET_SAMPLES)/h264/h264refframeregression.mp4 -an -frames 10 -pix_fmt yuv420p10le
+fate-h264-lossless:                               CMD = framecrc -i $(TARGET_SAMPLES)/h264/lossless.h264
+fate-h264-mixed-nal-coding:                       CMD = framecrc -i $(TARGET_SAMPLES)/h264/mixed-nal-coding.mp4
+fate-h264-twofields-packet:                       CMD = framecrc -i $(TARGET_SAMPLES)/h264/twofields_packet.mp4 -an -frames 30
 fate-h264-unescaped-extradata:                    CMD = framecrc -i $(TARGET_SAMPLES)/h264/unescaped_extradata.mp4 -an -frames 10
 fate-h264-3386:                                   CMD = framecrc -i $(TARGET_SAMPLES)/h264/bbc2.sample.h264
+fate-h264-missing-frame:                          CMD = framecrc -i $(TARGET_SAMPLES)/h264/nondeterministic_cut.h264
 
 fate-h264-reinit-%:                               CMD = framecrc -i $(TARGET_SAMPLES)/h264/$(@:fate-h264-%=%).h264 -vf format=yuv444p10le,scale=w=352:h=288
 
diff --git a/mythtv/external/FFmpeg/tests/fate/hevc.mak b/mythtv/external/FFmpeg/tests/fate/hevc.mak
index bd09ab3e71f..2e798eca605 100644
--- a/mythtv/external/FFmpeg/tests/fate/hevc.mak
+++ b/mythtv/external/FFmpeg/tests/fate/hevc.mak
@@ -192,27 +192,27 @@ endef
 
 define FATE_HEVC_TEST_10BIT
 FATE_HEVC += fate-hevc-conformance-$(1)
-fate-hevc-conformance-$(1): CMD = framecrc -flags unaligned -vsync drop -i $(TARGET_SAMPLES)/hevc-conformance/$(1).bit -pix_fmt yuv420p10le
+fate-hevc-conformance-$(1): CMD = framecrc -flags unaligned -i $(TARGET_SAMPLES)/hevc-conformance/$(1).bit -pix_fmt yuv420p10le
 endef
 
 define FATE_HEVC_TEST_422_10BIT
 FATE_HEVC += fate-hevc-conformance-$(1)
-fate-hevc-conformance-$(1): CMD = framecrc -flags unaligned -vsync drop -i $(TARGET_SAMPLES)/hevc-conformance/$(1).bit -pix_fmt yuv422p10le
+fate-hevc-conformance-$(1): CMD = framecrc -flags unaligned -i $(TARGET_SAMPLES)/hevc-conformance/$(1).bit -pix_fmt yuv422p10le
 endef
 
 define FATE_HEVC_TEST_422_10BIN
 FATE_HEVC += fate-hevc-conformance-$(1)
-fate-hevc-conformance-$(1): CMD = framecrc -flags unaligned -vsync drop -i $(TARGET_SAMPLES)/hevc-conformance/$(1).bin -pix_fmt yuv422p10le
+fate-hevc-conformance-$(1): CMD = framecrc -flags unaligned -i $(TARGET_SAMPLES)/hevc-conformance/$(1).bin -pix_fmt yuv422p10le
 endef
 
 define FATE_HEVC_TEST_444_8BIT
 FATE_HEVC += fate-hevc-conformance-$(1)
-fate-hevc-conformance-$(1): CMD = framecrc -flags unaligned -vsync drop -i $(TARGET_SAMPLES)/hevc-conformance/$(1).bit
+fate-hevc-conformance-$(1): CMD = framecrc -flags unaligned -i $(TARGET_SAMPLES)/hevc-conformance/$(1).bit
 endef
 
 define FATE_HEVC_TEST_444_12BIT
 FATE_HEVC += fate-hevc-conformance-$(1)
-fate-hevc-conformance-$(1): CMD = framecrc -flags unaligned -vsync drop -i $(TARGET_SAMPLES)/hevc-conformance/$(1).bit -pix_fmt yuv444p12le
+fate-hevc-conformance-$(1): CMD = framecrc -flags unaligned -i $(TARGET_SAMPLES)/hevc-conformance/$(1).bit -pix_fmt yuv444p12le
 endef
 
 $(foreach N,$(HEVC_SAMPLES),$(eval $(call FATE_HEVC_TEST,$(N))))
@@ -225,6 +225,9 @@ $(foreach N,$(HEVC_SAMPLES_444_12BIT),$(eval $(call FATE_HEVC_TEST_444_12BIT,$(N
 fate-hevc-paramchange-yuv420p-yuv420p10: CMD = framecrc -vsync 0 -i $(TARGET_SAMPLES)/hevc/paramchange_yuv420p_yuv420p10.hevc -sws_flags area+accurate_rnd+bitexact
 FATE_HEVC += fate-hevc-paramchange-yuv420p-yuv420p10
 
+fate-hevc-paired-fields: CMD = probeframes -show_entries frame=interlaced_frame,top_field_first $(TARGET_SAMPLES)/hevc/paired_fields.hevc
+FATE_HEVC_FFPROBE-$(call DEMDEC, HEVC, HEVC) += fate-hevc-paired-fields
+
 tests/data/hevc-mp4.mov: TAG = GEN
 tests/data/hevc-mp4.mov: ffmpeg$(PROGSSUF)$(EXESUF) | tests/data
 	$(M)$(TARGET_EXEC) $(TARGET_PATH)/$< \
@@ -232,12 +235,18 @@ tests/data/hevc-mp4.mov: ffmpeg$(PROGSSUF)$(EXESUF) | tests/data
 
 FATE_HEVC-$(call ALLYES, HEVC_DEMUXER MOV_DEMUXER HEVC_MP4TOANNEXB_BSF MOV_MUXER HEVC_MUXER) += fate-hevc-bsf-mp4toannexb
 fate-hevc-bsf-mp4toannexb: tests/data/hevc-mp4.mov
-fate-hevc-bsf-mp4toannexb: CMD = md5 -i $(TARGET_PATH)/tests/data/hevc-mp4.mov -vcodec copy -fflags +bitexact -f hevc
+fate-hevc-bsf-mp4toannexb: CMD = md5 -i $(TARGET_PATH)/tests/data/hevc-mp4.mov -c:v copy -fflags +bitexact -f hevc
 fate-hevc-bsf-mp4toannexb: CMP = oneline
 fate-hevc-bsf-mp4toannexb: REF = 1873662a3af1848c37e4eb25722c8df9
 
 FATE_HEVC-$(call DEMDEC, HEVC, HEVC) += $(FATE_HEVC)
 
+# this sample has two stsd entries and needs to reload extradata
+FATE_HEVC-$(call DEMDEC, MOV, HEVC) += fate-hevc-extradata-reload
+
+fate-hevc-extradata-reload: CMD = framemd5 -i $(TARGET_SAMPLES)/hevc/extradata-reload-multi-stsd.mov -sws_flags bitexact
+
 FATE_SAMPLES_AVCONV += $(FATE_HEVC-yes)
+FATE_SAMPLES_FFPROBE += $(FATE_HEVC_FFPROBE-yes)
 
-fate-hevc: $(FATE_HEVC-yes)
+fate-hevc: $(FATE_HEVC-yes) $(FATE_HEVC_FFPROBE-yes)
diff --git a/mythtv/external/FFmpeg/tests/fate/image.mak b/mythtv/external/FFmpeg/tests/fate/image.mak
index c19312a2e2c..7e7be3f119e 100644
--- a/mythtv/external/FFmpeg/tests/fate/image.mak
+++ b/mythtv/external/FFmpeg/tests/fate/image.mak
@@ -220,6 +220,9 @@ fate-exr-rgb-scanline-pxr24-float-half-l1: CMD = framecrc -i $(TARGET_SAMPLES)/e
 FATE_EXR += fate-exr-rgb-scanline-pxr24-float-half-l2
 fate-exr-rgb-scanline-pxr24-float-half-l2: CMD = framecrc -layer "VRaySamplerInfo" -i $(TARGET_SAMPLES)/exr/rgb_scanline_pxr24_float_half.exr -pix_fmt rgba64le
 
+FATE_EXR += fate-exr-rgb-scanline-pxr24-half-uint32-13x9
+fate-exr-rgb-scanline-pxr24-half-uint32-13x9: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_scanline_pxr24_half_uint32_13x9.exr -pix_fmt rgb48le
+
 FATE_EXR += fate-exr-rgb-scanline-zip-half-float-l1
 fate-exr-rgb-scanline-zip-half-float-l1: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_scanline_zip_half_float.exr -pix_fmt rgb48le
 
@@ -244,6 +247,43 @@ fate-exr-rgb-scanline-raw-half-float-l1: CMD = framecrc -i $(TARGET_SAMPLES)/exr
 FATE_EXR += fate-exr-rgb-scanline-raw-half-float-l2
 fate-exr-rgb-scanline-raw-half-float-l2: CMD = framecrc -layer "VRaySamplerInfo" -i $(TARGET_SAMPLES)/exr/rgb_scanline_raw_half_float.exr -pix_fmt rgba64le
 
+FATE_EXR += fate-exr-rgb-scanline-b44-uint32
+fate-exr-rgb-scanline-b44-uint32: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_scanline_b44_uint32.exr -pix_fmt rgb48le
+
+FATE_EXR += fate-exr-rgb-scanline-pxr24-uint32
+fate-exr-rgb-scanline-pxr24-uint32: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_scanline_pxr24_uint32.exr -pix_fmt rgb48le
+
+FATE_EXR += fate-exr-rgb-scanline-zip1-half-float-l1-zero-offsets
+fate-exr-rgb-scanline-zip1-half-float-l1-zero-offsets: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_scanline_zip1_half_float_zero_offsets.exr -pix_fmt rgb48le
+
+FATE_EXR += fate-exr-rgb-scanline-half-piz-bw
+fate-exr-rgb-scanline-half-piz-bw: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_scanline_half_piz_bw.exr -pix_fmt rgb48le
+
+FATE_EXR += fate-exr-rgb-scanline-half-piz-color
+fate-exr-rgb-scanline-half-piz-color: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_scanline_half_piz_color.exr -pix_fmt rgb48le
+
+FATE_EXR += fate-exr-rgb-scanline-half-piz-dw-t01
+fate-exr-rgb-scanline-half-piz-dw-t01: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_scanline_half_piz_dw_t01.exr -pix_fmt rgb48le
+
+FATE_EXR += fate-exr-rgb-scanline-float-piz-48x32
+fate-exr-rgb-scanline-float-piz-48x32: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_scanline_float_piz_48x32.exr -pix_fmt rgb48le
+
+FATE_EXR += fate-exr-rgb-scanline-none-negative-red
+fate-exr-rgb-scanline-none-negative-red: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_scanline_none_negative_red.exr -pix_fmt rgb48le
+
+
+FATE_EXR += fate-exr-rgb-b44a-half-negative-4x4
+fate-exr-rgb-b44a-half-negative-4x4: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_b44a_half_negative_4x4.exr -pix_fmt rgb48le
+
+FATE_EXR += fate-exr-y-tile-zip-half-12x8
+fate-exr-y-tile-zip-half-12x8: CMD = framecrc -i $(TARGET_SAMPLES)/exr/y_tile_zip_half_12x8.exr -pix_fmt gray16le
+
+FATE_EXR += fate-exr-y-scanline-zip-half-12x8
+fate-exr-y-scanline-zip-half-12x8: CMD = framecrc -i $(TARGET_SAMPLES)/exr/y_scanline_zip_half_12x8.exr -pix_fmt gray16le
+
+FATE_EXR += fate-exr-rgb-scanline-half-piz-dw-t08
+fate-exr-rgb-scanline-half-piz-dw-t08: CMD = framecrc -i $(TARGET_SAMPLES)/exr/rgb_scanline_half_piz_dw_t08.exr -pix_fmt rgb48le
+
 FATE_EXR-$(call DEMDEC, IMAGE2, EXR) += $(FATE_EXR)
 
 FATE_IMAGE += $(FATE_EXR-yes)
@@ -286,6 +326,40 @@ fate-png: $(FATE_PNG-yes)
 FATE_IMAGE-$(call DEMDEC, IMAGE2, PTX) += fate-ptx
 fate-ptx: CMD = framecrc -i $(TARGET_SAMPLES)/ptx/_113kw_pic.ptx -pix_fmt rgb24
 
+define FATE_IMGSUITE_PSD
+FATE_PSD += fate-psd-$(1)
+fate-psd-$(1): CMD = framecrc -i $(TARGET_SAMPLES)/psd/lena-$(1).psd -sws_flags +accurate_rnd+bitexact -pix_fmt rgb24
+endef
+
+PSD_COLORSPACES = gray8 gray16 rgb24 rgb48 rgba rgba64 ya8 ya16
+$(foreach CLSP,$(PSD_COLORSPACES),$(eval $(call FATE_IMGSUITE_PSD,$(CLSP))))
+
+FATE_PSD += fate-psd-lena-127x127-rgb24
+fate-psd-lena-127x127-rgb24: CMD = framecrc -i $(TARGET_SAMPLES)/psd/lena-127x127_rgb24.psd
+
+FATE_PSD += fate-psd-lena-rgb-rle-127x127-16b
+fate-psd-lena-rgb-rle-127x127-16b: CMD = framecrc -i $(TARGET_SAMPLES)/psd/lena-rgb_rle_127x127_16b.psd
+
+FATE_PSD += fate-psd-lena-rgb-rle-127x127-8b
+fate-psd-lena-rgb-rle-127x127-8b: CMD = framecrc -i $(TARGET_SAMPLES)/psd/lena-rgb_rle_127x127_8b.psd
+
+FATE_PSD += fate-psd-lena-rgba-rle-128x128-8b
+fate-psd-lena-rgba-rle-128x128-8b: CMD = framecrc -i $(TARGET_SAMPLES)/psd/lena-rgba_rle_128x128_8b.psd
+
+FATE_PSD += fate-psd-lena-256c
+fate-psd-lena-256c: CMD = framecrc -i $(TARGET_SAMPLES)/psd/lena-256c.psd
+
+FATE_PSD += fate-psd-lena-bitmap
+fate-psd-lena-bitmap: CMD = framecrc -i $(TARGET_SAMPLES)/psd/lena-bitmap.psd
+
+FATE_PSD += fate-psd-duo-tone-color
+fate-psd-duo-tone-color: CMD = framecrc -i $(TARGET_SAMPLES)/psd/duotone-color.psd
+
+FATE_PSD-$(call DEMDEC, IMAGE2, PSD) += $(FATE_PSD)
+
+FATE_IMAGE += $(FATE_PSD-yes)
+fate-psd: $(FATE_PSD-yes)
+
 define FATE_IMGSUITE_SGI
 FATE_SGI += fate-sgi-$(1) fate-sgi-$(1)-rle
 fate-sgi-$(1): CMD = framecrc -i $(TARGET_SAMPLES)/sgi/libav_$(1).sgi -sws_flags +accurate_rnd+bitexact
diff --git a/mythtv/external/FFmpeg/tests/fate/libavcodec.mak b/mythtv/external/FFmpeg/tests/fate/libavcodec.mak
index cf252858dec..27d631d16c4 100644
--- a/mythtv/external/FFmpeg/tests/fate/libavcodec.mak
+++ b/mythtv/external/FFmpeg/tests/fate/libavcodec.mak
@@ -1,18 +1,45 @@
+FATE_LIBAVCODEC-yes += fate-avpacket
+fate-avpacket: libavcodec/tests/avpacket$(EXESUF)
+fate-avpacket: CMD = run libavcodec/tests/avpacket
+fate-avpacket: CMP = null
+
 FATE_LIBAVCODEC-$(CONFIG_CABAC) += fate-cabac
 fate-cabac: libavcodec/tests/cabac$(EXESUF)
 fate-cabac: CMD = run libavcodec/tests/cabac
-fate-cabac: REF = /dev/null
+fate-cabac: CMP = null
+
+FATE_LIBAVCODEC-yes += fate-celp_math
+fate-celp_math: libavcodec/tests/celp_math$(EXESUF)
+fate-celp_math: CMD = run libavcodec/tests/celp_math
+fate-celp_math: CMP = null
 
 FATE_LIBAVCODEC-$(CONFIG_GOLOMB) += fate-golomb
 fate-golomb: libavcodec/tests/golomb$(EXESUF)
 fate-golomb: CMD = run libavcodec/tests/golomb
-fate-golomb: REF = /dev/null
+fate-golomb: CMP = null
+
+FATE_LIBAVCODEC-$(CONFIG_IDCTDSP) += fate-idct8x8-0 fate-idct8x8-1 fate-idct8x8-2 fate-idct248
+
+fate-idct8x8-0: libavcodec/tests/dct$(EXESUF)
+fate-idct8x8-0: CMD = run libavcodec/tests/dct -i 0
+fate-idct8x8-0: CMP = null
+
+fate-idct8x8-1: libavcodec/tests/dct$(EXESUF)
+fate-idct8x8-1: CMD = run libavcodec/tests/dct -i 1
+fate-idct8x8-1: CMP = null
 
-FATE_LIBAVCODEC-$(CONFIG_IDCTDSP) += fate-idct8x8
-fate-idct8x8: libavcodec/tests/dct$(EXESUF)
-fate-idct8x8: CMD = run libavcodec/tests/dct -i
-fate-idct8x8: CMP = null
-fate-idct8x8: REF = /dev/null
+fate-idct8x8-2: libavcodec/tests/dct$(EXESUF)
+fate-idct8x8-2: CMD = run libavcodec/tests/dct -i 2
+fate-idct8x8-2: CMP = null
+
+fate-idct248: libavcodec/tests/dct$(EXESUF)
+fate-idct248: CMD = run libavcodec/tests/dct -4
+fate-idct248: CMP = null
+
+FATE_LIBAVCODEC-$(CONFIG_IDCTDSP) += fate-dct8x8
+fate-dct8x8: libavcodec/tests/dct$(EXESUF)
+fate-dct8x8: CMD = run libavcodec/tests/dct
+fate-dct8x8: CMP = null
 
 FATE_LIBAVCODEC-$(CONFIG_IIRFILTER) += fate-iirfilter
 fate-iirfilter: libavcodec/tests/iirfilter$(EXESUF)
@@ -26,13 +53,11 @@ FATE_LIBAVCODEC-$(CONFIG_RANGECODER) += fate-rangecoder
 fate-rangecoder: libavcodec/tests/rangecoder$(EXESUF)
 fate-rangecoder: CMD = run libavcodec/tests/rangecoder
 fate-rangecoder: CMP = null
-fate-rangecoder: REF = /dev/null
 
 FATE_LIBAVCODEC-yes += fate-mathops
 fate-mathops: libavcodec/tests/mathops$(EXESUF)
 fate-mathops: CMD = run libavcodec/tests/mathops
 fate-mathops: CMP = null
-fate-mathops: REF = /dev/null
 
 FATE_LIBAVCODEC-$(CONFIG_JPEG2000_ENCODER) += fate-j2k-dwt
 fate-j2k-dwt: libavcodec/tests/jpeg2000dwt$(EXESUF)
@@ -42,7 +67,15 @@ FATE_LIBAVCODEC-yes += fate-libavcodec-utils
 fate-libavcodec-utils: libavcodec/tests/utils$(EXESUF)
 fate-libavcodec-utils: CMD = run libavcodec/tests/utils
 fate-libavcodec-utils: CMP = null
-fate-libavcodec-utils: REF = /dev/null
+
+FATE_LIBAVCODEC-yes += fate-libavcodec-huffman
+fate-libavcodec-huffman: libavcodec/tests/mjpegenc_huffman$(EXESUF)
+fate-libavcodec-huffman: CMD = run libavcodec/tests/mjpegenc_huffman
+fate-libavcodec-huffman: CMP = null
+
+FATE_LIBAVCODEC-yes += fate-libavcodec-htmlsubtitles
+fate-libavcodec-htmlsubtitles: libavcodec/tests/htmlsubtitles$(EXESUF)
+fate-libavcodec-htmlsubtitles: CMD = run libavcodec/tests/htmlsubtitles
 
 FATE-$(CONFIG_AVCODEC) += $(FATE_LIBAVCODEC-yes)
 fate-libavcodec: $(FATE_LIBAVCODEC-yes)
diff --git a/mythtv/external/FFmpeg/tests/fate/libavutil.mak b/mythtv/external/FFmpeg/tests/fate/libavutil.mak
index 6fbad641b83..591cab9b583 100644
--- a/mythtv/external/FFmpeg/tests/fate/libavutil.mak
+++ b/mythtv/external/FFmpeg/tests/fate/libavutil.mak
@@ -1,27 +1,36 @@
 FATE_LIBAVUTIL += fate-adler32
 fate-adler32: libavutil/tests/adler32$(EXESUF)
 fate-adler32: CMD = run libavutil/tests/adler32
-fate-adler32: REF = /dev/null
+fate-adler32: CMP = null
 
 FATE_LIBAVUTIL += fate-aes
 fate-aes: libavutil/tests/aes$(EXESUF)
 fate-aes: CMD = run libavutil/tests/aes
-fate-aes: REF = /dev/null
+fate-aes: CMP = null
+
+FATE_LIBAVUTIL += fate-aes_ctr
+fate-aes_ctr: libavutil/tests/aes_ctr$(EXESUF)
+fate-aes_ctr: CMD = run libavutil/tests/aes_ctr
+fate-aes_ctr: CMP = null
 
 FATE_LIBAVUTIL += fate-camellia
 fate-camellia: libavutil/tests/camellia$(EXESUF)
 fate-camellia: CMD = run libavutil/tests/camellia
-fate-camellia: REF = /dev/null
+fate-camellia: CMP = null
 
 FATE_LIBAVUTIL += fate-cast5
 fate-cast5: libavutil/tests/cast5$(EXESUF)
 fate-cast5: CMD = run libavutil/tests/cast5
-fate-cast5: REF = /dev/null
+fate-cast5: CMP = null
 
 FATE_LIBAVUTIL += fate-atomic
 fate-atomic: libavutil/tests/atomic$(EXESUF)
 fate-atomic: CMD = run libavutil/tests/atomic
-fate-atomic: REF = /dev/null
+fate-atomic: CMP = null
+
+FATE_LIBAVUTIL += fate-audio_fifo
+fate-audio_fifo: libavutil/tests/audio_fifo$(EXESUF)
+fate-audio_fifo: CMD = run libavutil/tests/audio_fifo
 
 FATE_LIBAVUTIL += fate-avstring
 fate-avstring: libavutil/tests/avstring$(EXESUF)
@@ -42,7 +51,12 @@ fate-bprint: CMD = run libavutil/tests/bprint
 FATE_LIBAVUTIL += fate-cpu
 fate-cpu: libavutil/tests/cpu$(EXESUF)
 fate-cpu: CMD = runecho libavutil/tests/cpu $(CPUFLAGS:%=-c%) $(THREADS:%=-t%)
-fate-cpu: REF = /dev/null
+fate-cpu: CMP = null
+
+FATE_LIBAVUTIL-$(HAVE_THREADS) += fate-cpu_init
+fate-cpu_init: libavutil/tests/cpu_init$(EXESUF)
+fate-cpu_init: CMD = run libavutil/tests/cpu_init
+fate-cpu_init: CMP = null
 
 FATE_LIBAVUTIL += fate-crc
 fate-crc: libavutil/tests/crc$(EXESUF)
@@ -55,7 +69,7 @@ fate-color_utils: CMD = run libavutil/tests/color_utils
 FATE_LIBAVUTIL += fate-des
 fate-des: libavutil/tests/des$(EXESUF)
 fate-des: CMD = run libavutil/tests/des
-fate-des: REF = /dev/null
+fate-des: CMP = null
 
 FATE_LIBAVUTIL += fate-dict
 fate-dict: libavutil/tests/dict$(EXESUF)
@@ -69,12 +83,6 @@ FATE_LIBAVUTIL += fate-fifo
 fate-fifo: libavutil/tests/fifo$(EXESUF)
 fate-fifo: CMD = run libavutil/tests/fifo
 
-FATE_LIBAVUTIL += fate-float-dsp
-fate-float-dsp: libavutil/tests/float_dsp$(EXESUF)
-fate-float-dsp: CMD = run libavutil/tests/float_dsp $(CPUFLAGS:%=-c%)
-fate-float-dsp: CMP = null
-fate-float-dsp: REF = /dev/null
-
 FATE_LIBAVUTIL += fate-hash
 fate-hash: libavutil/tests/hash$(EXESUF)
 fate-hash: CMD = run libavutil/tests/hash
@@ -83,6 +91,14 @@ FATE_LIBAVUTIL += fate-hmac
 fate-hmac: libavutil/tests/hmac$(EXESUF)
 fate-hmac: CMD = run libavutil/tests/hmac
 
+FATE_LIBAVUTIL += fate-imgutils
+fate-imgutils: libavutil/tests/imgutils$(EXESUF)
+fate-imgutils: CMD = run libavutil/tests/imgutils
+
+FATE_LIBAVUTIL += fate-lfg
+fate-lfg: libavutil/tests/lfg$(EXESUF)
+fate-lfg: CMD = run libavutil/tests/lfg
+
 FATE_LIBAVUTIL += fate-md5
 fate-md5: libavutil/tests/md5$(EXESUF)
 fate-md5: CMD = run libavutil/tests/md5
@@ -99,6 +115,10 @@ FATE_LIBAVUTIL-$(CONFIG_PIXELUTILS) += fate-pixelutils
 fate-pixelutils: libavutil/tests/pixelutils$(EXESUF)
 fate-pixelutils: CMD = run libavutil/tests/pixelutils
 
+FATE_LIBAVUTIL += fate-pixfmt_best
+fate-pixfmt_best: libavutil/tests/pixfmt_best$(EXESUF)
+fate-pixfmt_best: CMD = run libavutil/tests/pixfmt_best
+
 FATE_LIBAVUTIL += fate-display
 fate-display: libavutil/tests/display$(EXESUF)
 fate-display: CMD = run libavutil/tests/display
@@ -122,12 +142,12 @@ fate-sha512: CMD = run libavutil/tests/sha512
 FATE_LIBAVUTIL += fate-tree
 fate-tree: libavutil/tests/tree$(EXESUF)
 fate-tree: CMD = run libavutil/tests/tree
-fate-tree: REF = /dev/null
+fate-tree: CMP = null
 
 FATE_LIBAVUTIL += fate-twofish
 fate-twofish: libavutil/tests/twofish$(EXESUF)
 fate-twofish: CMD = run libavutil/tests/twofish
-fate-twofish: REF = /dev/null
+fate-twofish: CMP = null
 
 FATE_LIBAVUTIL += fate-xtea
 fate-xtea: libavutil/tests/xtea$(EXESUF)
diff --git a/mythtv/external/FFmpeg/tests/fate/libswresample.mak b/mythtv/external/FFmpeg/tests/fate/libswresample.mak
index 7cb3bdb29f6..fed481b3d51 100644
--- a/mythtv/external/FFmpeg/tests/fate/libswresample.mak
+++ b/mythtv/external/FFmpeg/tests/fate/libswresample.mak
@@ -11,10 +11,11 @@ SAMPLERATES_LITE = 8000 44100 48000
 
 SAMPLERATES_NN = 8000 44100
 
+#note that the default is ARESAMPLE_EXACT_LIN
 define ARESAMPLE
 FATE_SWR_RESAMPLE += fate-swr-resample-$(3)-$(1)-$(2)
 fate-swr-resample-$(3)-$(1)-$(2): tests/data/asynth-$(1)-1.wav
-fate-swr-resample-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,aresample=$(2):internal_sample_fmt=$(3),aformat=$(3),aresample=$(1):internal_sample_fmt=$(3) -f wav -acodec pcm_s16le -
+fate-swr-resample-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,aresample=$(2):internal_sample_fmt=$(3):exact_rational=0:linear_interp=0,aformat=$(3),aresample=$(1):internal_sample_fmt=$(3):exact_rational=0:linear_interp=0 -f wav -c:a pcm_s16le -
 
 fate-swr-resample-$(3)-$(1)-$(2): CMP = stddev
 fate-swr-resample-$(3)-$(1)-$(2): CMP_UNIT = $(5)
@@ -26,13 +27,13 @@ endef
 #you can use this if you need to update it!
 #make -k  `make fate-list | grep swr` | egrep 'TEST|stddev' | tr '\n' '@' | sed 's#TEST *\([^@]*\)@stddev: *\([0-9.]*\)[^b@]*bytes: *\([0-9]*\) */ *\([0-9]*\)@#fate-\1: CMP_TARGET = \2@fate-\1: SIZE_TOLERANCE = \3 - \4@@#g' | tr '@' '\n'
 
-fate-swr-resample-dblp-2626-44100: CMP_TARGET = 1352.68
+fate-swr-resample-dblp-2626-44100: CMP_TARGET = 1352.67
 fate-swr-resample-dblp-2626-44100: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample-dblp-2626-48000: CMP_TARGET = 1352.65
+fate-swr-resample-dblp-2626-48000: CMP_TARGET = 1352.66
 fate-swr-resample-dblp-2626-48000: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample-dblp-2626-8000: CMP_TARGET = 1353.08
+fate-swr-resample-dblp-2626-8000: CMP_TARGET = 1352.56
 fate-swr-resample-dblp-2626-8000: SIZE_TOLERANCE = 31512 - 20482
 
 fate-swr-resample-dblp-2626-96000: CMP_TARGET = 1352.67
@@ -41,19 +42,19 @@ fate-swr-resample-dblp-2626-96000: SIZE_TOLERANCE = 31512 - 20480
 fate-swr-resample-dblp-44100-2626: CMP_TARGET = 185.82
 fate-swr-resample-dblp-44100-2626: SIZE_TOLERANCE = 529200 - 20490
 
-fate-swr-resample-dblp-44100-48000: CMP_TARGET = 9.70
+fate-swr-resample-dblp-44100-48000: CMP_TARGET = 9.69
 fate-swr-resample-dblp-44100-48000: SIZE_TOLERANCE = 529200 - 20482
 
 fate-swr-resample-dblp-44100-8000: CMP_TARGET = 75.45
 fate-swr-resample-dblp-44100-8000: SIZE_TOLERANCE = 529200 - 20486
 
-fate-swr-resample-dblp-44100-96000: CMP_TARGET = 11.47
+fate-swr-resample-dblp-44100-96000: CMP_TARGET = 11.46
 fate-swr-resample-dblp-44100-96000: SIZE_TOLERANCE = 529200 - 20482
 
 fate-swr-resample-dblp-48000-2626: CMP_TARGET = 456.51
 fate-swr-resample-dblp-48000-2626: SIZE_TOLERANCE = 576000 - 20510
 
-fate-swr-resample-dblp-48000-44100: CMP_TARGET = 1.02
+fate-swr-resample-dblp-48000-44100: CMP_TARGET = 1.00
 fate-swr-resample-dblp-48000-44100: SIZE_TOLERANCE = 576000 - 20480
 
 fate-swr-resample-dblp-48000-8000: CMP_TARGET = 62.38
@@ -62,7 +63,7 @@ fate-swr-resample-dblp-48000-8000: SIZE_TOLERANCE = 576000 - 20484
 fate-swr-resample-dblp-48000-96000: CMP_TARGET = 0.47
 fate-swr-resample-dblp-48000-96000: SIZE_TOLERANCE = 576000 - 20480
 
-fate-swr-resample-dblp-8000-2626: CMP_TARGET = 2506.02
+fate-swr-resample-dblp-8000-2626: CMP_TARGET = 2503.33
 fate-swr-resample-dblp-8000-2626: SIZE_TOLERANCE = 96000 - 20486
 
 fate-swr-resample-dblp-8000-44100: CMP_TARGET = 15.09
@@ -74,25 +75,25 @@ fate-swr-resample-dblp-8000-48000: SIZE_TOLERANCE = 96000 - 20480
 fate-swr-resample-dblp-8000-96000: CMP_TARGET = 13.81
 fate-swr-resample-dblp-8000-96000: SIZE_TOLERANCE = 96000 - 20480
 
-fate-swr-resample-dblp-96000-2626: CMP_TARGET = 675.08
+fate-swr-resample-dblp-96000-2626: CMP_TARGET = 675.07
 fate-swr-resample-dblp-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
 
-fate-swr-resample-dblp-96000-44100: CMP_TARGET = 1.45
+fate-swr-resample-dblp-96000-44100: CMP_TARGET = 1.44
 fate-swr-resample-dblp-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
 
-fate-swr-resample-dblp-96000-48000: CMP_TARGET = 1.00
+fate-swr-resample-dblp-96000-48000: CMP_TARGET = 0.99
 fate-swr-resample-dblp-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
 
 fate-swr-resample-dblp-96000-8000: CMP_TARGET = 58.57
 fate-swr-resample-dblp-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
 
-fate-swr-resample-fltp-2626-44100: CMP_TARGET = 1352.68
+fate-swr-resample-fltp-2626-44100: CMP_TARGET = 1352.67
 fate-swr-resample-fltp-2626-44100: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample-fltp-2626-48000: CMP_TARGET = 1352.65
+fate-swr-resample-fltp-2626-48000: CMP_TARGET = 1352.66
 fate-swr-resample-fltp-2626-48000: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample-fltp-2626-8000: CMP_TARGET = 1353.08
+fate-swr-resample-fltp-2626-8000: CMP_TARGET = 1352.56
 fate-swr-resample-fltp-2626-8000: SIZE_TOLERANCE = 31512 - 20482
 
 fate-swr-resample-fltp-2626-96000: CMP_TARGET = 1352.67
@@ -101,19 +102,19 @@ fate-swr-resample-fltp-2626-96000: SIZE_TOLERANCE = 31512 - 20480
 fate-swr-resample-fltp-44100-2626: CMP_TARGET = 185.82
 fate-swr-resample-fltp-44100-2626: SIZE_TOLERANCE = 529200 - 20490
 
-fate-swr-resample-fltp-44100-48000: CMP_TARGET = 9.70
+fate-swr-resample-fltp-44100-48000: CMP_TARGET = 9.69
 fate-swr-resample-fltp-44100-48000: SIZE_TOLERANCE = 529200 - 20482
 
 fate-swr-resample-fltp-44100-8000: CMP_TARGET = 75.45
 fate-swr-resample-fltp-44100-8000: SIZE_TOLERANCE = 529200 - 20486
 
-fate-swr-resample-fltp-44100-96000: CMP_TARGET = 11.47
+fate-swr-resample-fltp-44100-96000: CMP_TARGET = 11.46
 fate-swr-resample-fltp-44100-96000: SIZE_TOLERANCE = 529200 - 20482
 
 fate-swr-resample-fltp-48000-2626: CMP_TARGET = 456.51
 fate-swr-resample-fltp-48000-2626: SIZE_TOLERANCE = 576000 - 20510
 
-fate-swr-resample-fltp-48000-44100: CMP_TARGET = 1.02
+fate-swr-resample-fltp-48000-44100: CMP_TARGET = 1.00
 fate-swr-resample-fltp-48000-44100: SIZE_TOLERANCE = 576000 - 20480
 
 fate-swr-resample-fltp-48000-8000: CMP_TARGET = 62.38
@@ -122,7 +123,7 @@ fate-swr-resample-fltp-48000-8000: SIZE_TOLERANCE = 576000 - 20484
 fate-swr-resample-fltp-48000-96000: CMP_TARGET = 0.47
 fate-swr-resample-fltp-48000-96000: SIZE_TOLERANCE = 576000 - 20480
 
-fate-swr-resample-fltp-8000-2626: CMP_TARGET = 2506.02
+fate-swr-resample-fltp-8000-2626: CMP_TARGET = 2503.33
 fate-swr-resample-fltp-8000-2626: SIZE_TOLERANCE = 96000 - 20486
 
 fate-swr-resample-fltp-8000-44100: CMP_TARGET = 15.09
@@ -134,28 +135,28 @@ fate-swr-resample-fltp-8000-48000: SIZE_TOLERANCE = 96000 - 20480
 fate-swr-resample-fltp-8000-96000: CMP_TARGET = 13.81
 fate-swr-resample-fltp-8000-96000: SIZE_TOLERANCE = 96000 - 20480
 
-fate-swr-resample-fltp-96000-2626: CMP_TARGET = 675.08
+fate-swr-resample-fltp-96000-2626: CMP_TARGET = 675.07
 fate-swr-resample-fltp-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
 
-fate-swr-resample-fltp-96000-44100: CMP_TARGET = 1.45
+fate-swr-resample-fltp-96000-44100: CMP_TARGET = 1.44
 fate-swr-resample-fltp-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
 
-fate-swr-resample-fltp-96000-48000: CMP_TARGET = 1.00
+fate-swr-resample-fltp-96000-48000: CMP_TARGET = 0.99
 fate-swr-resample-fltp-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
 
 fate-swr-resample-fltp-96000-8000: CMP_TARGET = 58.57
 fate-swr-resample-fltp-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
 
-fate-swr-resample-s16p-2626-44100: CMP_TARGET = 1393.01
+fate-swr-resample-s16p-2626-44100: CMP_TARGET = 1392.98
 fate-swr-resample-s16p-2626-44100: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample-s16p-2626-48000: CMP_TARGET = 1392.99
+fate-swr-resample-s16p-2626-48000: CMP_TARGET = 1393.01
 fate-swr-resample-s16p-2626-48000: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample-s16p-2626-8000: CMP_TARGET = 1393.90
+fate-swr-resample-s16p-2626-8000: CMP_TARGET = 1393.36
 fate-swr-resample-s16p-2626-8000: SIZE_TOLERANCE = 31512 - 20482
 
-fate-swr-resample-s16p-2626-96000: CMP_TARGET = 1393.08
+fate-swr-resample-s16p-2626-96000: CMP_TARGET = 1393.07
 fate-swr-resample-s16p-2626-96000: SIZE_TOLERANCE = 31512 - 20480
 
 fate-swr-resample-s16p-44100-2626: CMP_TARGET = 185.84
@@ -173,19 +174,19 @@ fate-swr-resample-s16p-44100-96000: SIZE_TOLERANCE = 529200 - 20482
 fate-swr-resample-s16p-48000-2626: CMP_TARGET = 456.55
 fate-swr-resample-s16p-48000-2626: SIZE_TOLERANCE = 576000 - 20510
 
-fate-swr-resample-s16p-48000-44100: CMP_TARGET = 1.22
+fate-swr-resample-s16p-48000-44100: CMP_TARGET = 1.20
 fate-swr-resample-s16p-48000-44100: SIZE_TOLERANCE = 576000 - 20480
 
 fate-swr-resample-s16p-48000-8000: CMP_TARGET = 62.41
 fate-swr-resample-s16p-48000-8000: SIZE_TOLERANCE = 576000 - 20484
 
-fate-swr-resample-s16p-48000-96000: CMP_TARGET = 0.50
+fate-swr-resample-s16p-48000-96000: CMP_TARGET = 0.73
 fate-swr-resample-s16p-48000-96000: SIZE_TOLERANCE = 576000 - 20480
 
-fate-swr-resample-s16p-8000-2626: CMP_TARGET = 2506.02
+fate-swr-resample-s16p-8000-2626: CMP_TARGET = 2503.32
 fate-swr-resample-s16p-8000-2626: SIZE_TOLERANCE = 96000 - 20486
 
-fate-swr-resample-s16p-8000-44100: CMP_TARGET = 15.12
+fate-swr-resample-s16p-8000-44100: CMP_TARGET = 15.13
 fate-swr-resample-s16p-8000-44100: SIZE_TOLERANCE = 96000 - 20480
 
 fate-swr-resample-s16p-8000-48000: CMP_TARGET = 14.69
@@ -194,31 +195,31 @@ fate-swr-resample-s16p-8000-48000: SIZE_TOLERANCE = 96000 - 20480
 fate-swr-resample-s16p-8000-96000: CMP_TARGET = 13.83
 fate-swr-resample-s16p-8000-96000: SIZE_TOLERANCE = 96000 - 20480
 
-fate-swr-resample-s16p-96000-2626: CMP_TARGET = 675.14
+fate-swr-resample-s16p-96000-2626: CMP_TARGET = 675.15
 fate-swr-resample-s16p-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
 
 fate-swr-resample-s16p-96000-44100: CMP_TARGET = 1.62
 fate-swr-resample-s16p-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
 
-fate-swr-resample-s16p-96000-48000: CMP_TARGET = 1.03
+fate-swr-resample-s16p-96000-48000: CMP_TARGET = 1.12
 fate-swr-resample-s16p-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
 
 fate-swr-resample-s16p-96000-8000: CMP_TARGET = 58.60
 fate-swr-resample-s16p-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
 
-fate-swr-resample-s32p-2626-44100: CMP_TARGET = 1393.01
+fate-swr-resample-s32p-2626-44100: CMP_TARGET = 1392.99
 fate-swr-resample-s32p-2626-44100: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample-s32p-2626-48000: CMP_TARGET = 1392.99
+fate-swr-resample-s32p-2626-48000: CMP_TARGET = 1393.01
 fate-swr-resample-s32p-2626-48000: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample-s32p-2626-8000: CMP_TARGET = 1393.89
+fate-swr-resample-s32p-2626-8000: CMP_TARGET = 1393.36
 fate-swr-resample-s32p-2626-8000: SIZE_TOLERANCE = 31512 - 20482
 
 fate-swr-resample-s32p-2626-96000: CMP_TARGET = 1393.00
 fate-swr-resample-s32p-2626-96000: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample-s32p-44100-2626: CMP_TARGET = 185.82
+fate-swr-resample-s32p-44100-2626: CMP_TARGET = 185.81
 fate-swr-resample-s32p-44100-2626: SIZE_TOLERANCE = 529200 - 20490
 
 fate-swr-resample-s32p-44100-48000: CMP_TARGET = 9.70
@@ -230,47 +231,47 @@ fate-swr-resample-s32p-44100-8000: SIZE_TOLERANCE = 529200 - 20486
 fate-swr-resample-s32p-44100-96000: CMP_TARGET = 11.47
 fate-swr-resample-s32p-44100-96000: SIZE_TOLERANCE = 529200 - 20482
 
-fate-swr-resample-s32p-48000-2626: CMP_TARGET = 456.51
+fate-swr-resample-s32p-48000-2626: CMP_TARGET = 456.49
 fate-swr-resample-s32p-48000-2626: SIZE_TOLERANCE = 576000 - 20510
 
-fate-swr-resample-s32p-48000-44100: CMP_TARGET = 1.02
+fate-swr-resample-s32p-48000-44100: CMP_TARGET = 1.12
 fate-swr-resample-s32p-48000-44100: SIZE_TOLERANCE = 576000 - 20480
 
-fate-swr-resample-s32p-48000-8000: CMP_TARGET = 62.38
+fate-swr-resample-s32p-48000-8000: CMP_TARGET = 62.37
 fate-swr-resample-s32p-48000-8000: SIZE_TOLERANCE = 576000 - 20484
 
-fate-swr-resample-s32p-48000-96000: CMP_TARGET = 0.47
+fate-swr-resample-s32p-48000-96000: CMP_TARGET = 0.85
 fate-swr-resample-s32p-48000-96000: SIZE_TOLERANCE = 576000 - 20480
 
-fate-swr-resample-s32p-8000-2626: CMP_TARGET = 2506.02
+fate-swr-resample-s32p-8000-2626: CMP_TARGET = 2503.33
 fate-swr-resample-s32p-8000-2626: SIZE_TOLERANCE = 96000 - 20486
 
 fate-swr-resample-s32p-8000-44100: CMP_TARGET = 15.09
 fate-swr-resample-s32p-8000-44100: SIZE_TOLERANCE = 96000 - 20480
 
-fate-swr-resample-s32p-8000-48000: CMP_TARGET = 14.69
+fate-swr-resample-s32p-8000-48000: CMP_TARGET = 14.68
 fate-swr-resample-s32p-8000-48000: SIZE_TOLERANCE = 96000 - 20480
 
 fate-swr-resample-s32p-8000-96000: CMP_TARGET = 13.81
 fate-swr-resample-s32p-8000-96000: SIZE_TOLERANCE = 96000 - 20480
 
-fate-swr-resample-s32p-96000-2626: CMP_TARGET = 675.08
+fate-swr-resample-s32p-96000-2626: CMP_TARGET = 675.05
 fate-swr-resample-s32p-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
 
-fate-swr-resample-s32p-96000-44100: CMP_TARGET = 1.45
+fate-swr-resample-s32p-96000-44100: CMP_TARGET = 1.54
 fate-swr-resample-s32p-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
 
-fate-swr-resample-s32p-96000-48000: CMP_TARGET = 1.00
+fate-swr-resample-s32p-96000-48000: CMP_TARGET = 1.21
 fate-swr-resample-s32p-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
 
-fate-swr-resample-s32p-96000-8000: CMP_TARGET = 58.57
+fate-swr-resample-s32p-96000-8000: CMP_TARGET = 58.59
 fate-swr-resample-s32p-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
 
 
 define ARESAMPLE_LIN
 FATE_SWR_RESAMPLE += fate-swr-resample_lin-$(3)-$(1)-$(2)
 fate-swr-resample_lin-$(3)-$(1)-$(2): tests/data/asynth-$(1)-1.wav
-fate-swr-resample_lin-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,aresample=$(2):linear_interp=1:internal_sample_fmt=$(3),aformat=$(3),aresample=$(1):linear_interp=1:internal_sample_fmt=$(3) -f wav -acodec pcm_s16le -
+fate-swr-resample_lin-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,aresample=$(2):linear_interp=1:exact_rational=0:internal_sample_fmt=$(3),aformat=$(3),aresample=$(1):linear_interp=1:exact_rational=0:internal_sample_fmt=$(3) -f wav -c:a pcm_s16le -
 
 fate-swr-resample_lin-$(3)-$(1)-$(2): CMP = stddev
 fate-swr-resample_lin-$(3)-$(1)-$(2): CMP_UNIT = $(5)
@@ -290,10 +291,10 @@ fate-swr-resample_lin-s16p-44100-8000: SIZE_TOLERANCE = 529200 - 20486
 fate-swr-resample_lin-s16p-44100-48000: CMP_TARGET = 9.66
 fate-swr-resample_lin-s16p-44100-48000: SIZE_TOLERANCE = 529200 - 20482
 
-fate-swr-resample_lin-s16p-48000-8000: CMP_TARGET = 62.39
+fate-swr-resample_lin-s16p-48000-8000: CMP_TARGET = 62.38
 fate-swr-resample_lin-s16p-48000-8000: SIZE_TOLERANCE = 576000 - 20484
 
-fate-swr-resample_lin-s16p-48000-44100: CMP_TARGET = 0.68
+fate-swr-resample_lin-s16p-48000-44100: CMP_TARGET = 0.65
 fate-swr-resample_lin-s16p-48000-44100: SIZE_TOLERANCE = 576000 - 20480
 
 fate-swr-resample_lin-fltp-8000-44100: CMP_TARGET = 14.59
@@ -305,13 +306,13 @@ fate-swr-resample_lin-fltp-8000-48000: SIZE_TOLERANCE = 96000 - 20480
 fate-swr-resample_lin-fltp-44100-8000: CMP_TARGET = 75.38
 fate-swr-resample_lin-fltp-44100-8000: SIZE_TOLERANCE = 529200 - 20486
 
-fate-swr-resample_lin-fltp-44100-48000: CMP_TARGET = 9.65
+fate-swr-resample_lin-fltp-44100-48000: CMP_TARGET = 9.64
 fate-swr-resample_lin-fltp-44100-48000: SIZE_TOLERANCE = 529200 - 20482
 
 fate-swr-resample_lin-fltp-48000-8000: CMP_TARGET = 62.36
 fate-swr-resample_lin-fltp-48000-8000: SIZE_TOLERANCE = 576000 - 20484
 
-fate-swr-resample_lin-fltp-48000-44100: CMP_TARGET = 0.26
+fate-swr-resample_lin-fltp-48000-44100: CMP_TARGET = 0.23
 fate-swr-resample_lin-fltp-48000-44100: SIZE_TOLERANCE = 576000 - 20480
 
 fate-swr-resample_lin-dblp-8000-44100: CMP_TARGET = 14.59
@@ -323,19 +324,19 @@ fate-swr-resample_lin-dblp-8000-48000: SIZE_TOLERANCE = 96000 - 20480
 fate-swr-resample_lin-dblp-44100-8000: CMP_TARGET = 75.38
 fate-swr-resample_lin-dblp-44100-8000: SIZE_TOLERANCE = 529200 - 20486
 
-fate-swr-resample_lin-dblp-44100-48000: CMP_TARGET = 9.65
+fate-swr-resample_lin-dblp-44100-48000: CMP_TARGET = 9.64
 fate-swr-resample_lin-dblp-44100-48000: SIZE_TOLERANCE = 529200 - 20482
 
 fate-swr-resample_lin-dblp-48000-8000: CMP_TARGET = 62.36
 fate-swr-resample_lin-dblp-48000-8000: SIZE_TOLERANCE = 576000 - 20484
 
-fate-swr-resample_lin-dblp-48000-44100: CMP_TARGET = 0.26
+fate-swr-resample_lin-dblp-48000-44100: CMP_TARGET = 0.23
 fate-swr-resample_lin-dblp-48000-44100: SIZE_TOLERANCE = 576000 - 20480
 
 define ARESAMPLE_NN
 FATE_SWR_RESAMPLE += fate-swr-resample_nn-$(3)-$(1)-$(2)
 fate-swr-resample_nn-$(3)-$(1)-$(2): tests/data/asynth-$(1)-1.wav
-fate-swr-resample_nn-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,aresample=$(2):filter_size=1:phase_shift=0:internal_sample_fmt=$(3),aformat=$(3),aresample=$(1):internal_sample_fmt=$(3) -f wav -acodec pcm_s16le -
+fate-swr-resample_nn-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,aresample=$(2):filter_size=1:phase_shift=0:linear_interp=0:internal_sample_fmt=$(3),aformat=$(3),aresample=$(1):linear_interp=0:exact_rational=0:internal_sample_fmt=$(3) -f wav -c:a pcm_s16le -
 
 fate-swr-resample_nn-$(3)-$(1)-$(2): CMP = stddev
 fate-swr-resample_nn-$(3)-$(1)-$(2): CMP_UNIT = $(5)
@@ -343,13 +344,13 @@ fate-swr-resample_nn-$(3)-$(1)-$(2): FUZZ = 0.1
 fate-swr-resample_nn-$(3)-$(1)-$(2): REF = tests/data/asynth-$(1)-1.wav
 endef
 
-fate-swr-resample_nn-fltp-44100-8000: CMP_TARGET = 590.98
+fate-swr-resample_nn-fltp-44100-8000: CMP_TARGET = 591.03
 fate-swr-resample_nn-fltp-44100-8000: SIZE_TOLERANCE = 529200 - 20486
 
 fate-swr-resample_nn-fltp-8000-44100: CMP_TARGET = 3163.32
 fate-swr-resample_nn-fltp-8000-44100: SIZE_TOLERANCE = 96000 - 20480
 
-fate-swr-resample_nn-s16p-44100-8000: CMP_TARGET = 590.97
+fate-swr-resample_nn-s16p-44100-8000: CMP_TARGET = 590.98
 fate-swr-resample_nn-s16p-44100-8000: SIZE_TOLERANCE = 529200 - 20486
 
 fate-swr-resample_nn-s16p-8000-44100: CMP_TARGET = 3163.39
@@ -358,7 +359,7 @@ fate-swr-resample_nn-s16p-8000-44100: SIZE_TOLERANCE = 96000 - 20480
 define ARESAMPLE_ASYNC
 FATE_SWR_RESAMPLE += fate-swr-resample_async-$(3)-$(1)-$(2)
 fate-swr-resample_async-$(3)-$(1)-$(2): tests/data/asynth-$(1)-1.wav
-fate-swr-resample_async-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,asetpts=PTS+random\(0\)*200-100,aresample=$(2):async=50:min_hard_comp=0.100000:first_pts=0:internal_sample_fmt=$(3),aformat=$(3),aresample=$(1):internal_sample_fmt=$(3) -f wav -acodec pcm_s16le -
+fate-swr-resample_async-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,asetpts=PTS+random\(0\)*200-100,aresample=$(2):async=50:min_hard_comp=0.100000:first_pts=0:linear_interp=0:exact_rational=0:internal_sample_fmt=$(3),aformat=$(3),aresample=$(1):linear_interp=0:exact_rational=0:internal_sample_fmt=$(3) -f wav -c:a pcm_s16le -
 
 fate-swr-resample_async-$(3)-$(1)-$(2): CMP = stddev
 fate-swr-resample_async-$(3)-$(1)-$(2): CMP_UNIT = $(5)
@@ -366,22 +367,22 @@ fate-swr-resample_async-$(3)-$(1)-$(2): FUZZ = 0.1
 fate-swr-resample_async-$(3)-$(1)-$(2): REF = tests/data/asynth-$(1)-1.wav
 endef
 
-fate-swr-resample_async-fltp-44100-8000: CMP_TARGET = 4020.62
+fate-swr-resample_async-fltp-44100-8000: CMP_TARGET = 4020.60
 fate-swr-resample_async-fltp-44100-8000: SIZE_TOLERANCE = 529200 - 20310
 
-fate-swr-resample_async-fltp-8000-44100: CMP_TARGET = 11186.69
+fate-swr-resample_async-fltp-8000-44100: CMP_TARGET = 11186.66
 fate-swr-resample_async-fltp-8000-44100: SIZE_TOLERANCE = 96000 - 20344
 
-fate-swr-resample_async-s16p-44100-8000: CMP_TARGET = 4020.73
+fate-swr-resample_async-s16p-44100-8000: CMP_TARGET = 4020.71
 fate-swr-resample_async-s16p-44100-8000: SIZE_TOLERANCE = 529200 - 20310
 
-fate-swr-resample_async-s16p-8000-44100: CMP_TARGET = 11187.01
+fate-swr-resample_async-s16p-8000-44100: CMP_TARGET = 11186.94
 fate-swr-resample_async-s16p-8000-44100: SIZE_TOLERANCE = 96000 - 20344
 
 define ARESAMPLE_EXACT
 FATE_SWR_RESAMPLE += fate-swr-resample_exact-$(3)-$(1)-$(2)
 fate-swr-resample_exact-$(3)-$(1)-$(2): tests/data/asynth-$(1)-1.wav
-fate-swr-resample_exact-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,aresample=$(2):internal_sample_fmt=$(3):exact_rational=on,aformat=$(3),aresample=$(1):internal_sample_fmt=$(3):exact_rational=on -f wav -acodec pcm_s16le -
+fate-swr-resample_exact-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,aresample=$(2):internal_sample_fmt=$(3):exact_rational=on:linear_interp=0,aformat=$(3),aresample=$(1):internal_sample_fmt=$(3):exact_rational=on:linear_interp=0 -f wav -c:a pcm_s16le -
 
 fate-swr-resample_exact-$(3)-$(1)-$(2): CMP = stddev
 fate-swr-resample_exact-$(3)-$(1)-$(2): CMP_UNIT = $(5)
@@ -389,13 +390,13 @@ fate-swr-resample_exact-$(3)-$(1)-$(2): FUZZ = 0.1
 fate-swr-resample_exact-$(3)-$(1)-$(2): REF = tests/data/asynth-$(1)-1.wav
 endef
 
-fate-swr-resample_exact-dblp-2626-44100: CMP_TARGET = 1352.68
+fate-swr-resample_exact-dblp-2626-44100: CMP_TARGET = 1352.67
 fate-swr-resample_exact-dblp-2626-44100: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample_exact-dblp-2626-48000: CMP_TARGET = 1352.65
+fate-swr-resample_exact-dblp-2626-48000: CMP_TARGET = 1352.66
 fate-swr-resample_exact-dblp-2626-48000: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample_exact-dblp-2626-8000: CMP_TARGET = 1353.08
+fate-swr-resample_exact-dblp-2626-8000: CMP_TARGET = 1352.56
 fate-swr-resample_exact-dblp-2626-8000: SIZE_TOLERANCE = 31512 - 20482
 
 fate-swr-resample_exact-dblp-2626-96000: CMP_TARGET = 1352.67
@@ -404,7 +405,7 @@ fate-swr-resample_exact-dblp-2626-96000: SIZE_TOLERANCE = 31512 - 20480
 fate-swr-resample_exact-dblp-44100-2626: CMP_TARGET = 185.82
 fate-swr-resample_exact-dblp-44100-2626: SIZE_TOLERANCE = 529200 - 20490
 
-fate-swr-resample_exact-dblp-44100-48000: CMP_TARGET = 9.65
+fate-swr-resample_exact-dblp-44100-48000: CMP_TARGET = 9.64
 fate-swr-resample_exact-dblp-44100-48000: SIZE_TOLERANCE = 529200 - 20482
 
 fate-swr-resample_exact-dblp-44100-8000: CMP_TARGET = 75.38
@@ -416,7 +417,7 @@ fate-swr-resample_exact-dblp-44100-96000: SIZE_TOLERANCE = 529200 - 20482
 fate-swr-resample_exact-dblp-48000-2626: CMP_TARGET = 456.51
 fate-swr-resample_exact-dblp-48000-2626: SIZE_TOLERANCE = 576000 - 20510
 
-fate-swr-resample_exact-dblp-48000-44100: CMP_TARGET = 0.26
+fate-swr-resample_exact-dblp-48000-44100: CMP_TARGET = 0.23
 fate-swr-resample_exact-dblp-48000-44100: SIZE_TOLERANCE = 576000 - 20480
 
 fate-swr-resample_exact-dblp-48000-8000: CMP_TARGET = 62.36
@@ -425,7 +426,7 @@ fate-swr-resample_exact-dblp-48000-8000: SIZE_TOLERANCE = 576000 - 20484
 fate-swr-resample_exact-dblp-48000-96000: CMP_TARGET = 0.47
 fate-swr-resample_exact-dblp-48000-96000: SIZE_TOLERANCE = 576000 - 20480
 
-fate-swr-resample_exact-dblp-8000-2626: CMP_TARGET = 2506.02
+fate-swr-resample_exact-dblp-8000-2626: CMP_TARGET = 2503.33
 fate-swr-resample_exact-dblp-8000-2626: SIZE_TOLERANCE = 96000 - 20486
 
 fate-swr-resample_exact-dblp-8000-44100: CMP_TARGET = 14.59
@@ -437,25 +438,25 @@ fate-swr-resample_exact-dblp-8000-48000: SIZE_TOLERANCE = 96000 - 20480
 fate-swr-resample_exact-dblp-8000-96000: CMP_TARGET = 13.62
 fate-swr-resample_exact-dblp-8000-96000: SIZE_TOLERANCE = 96000 - 20480
 
-fate-swr-resample_exact-dblp-96000-2626: CMP_TARGET = 675.08
+fate-swr-resample_exact-dblp-96000-2626: CMP_TARGET = 675.07
 fate-swr-resample_exact-dblp-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
 
-fate-swr-resample_exact-dblp-96000-44100: CMP_TARGET = 1.26
+fate-swr-resample_exact-dblp-96000-44100: CMP_TARGET = 1.24
 fate-swr-resample_exact-dblp-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
 
-fate-swr-resample_exact-dblp-96000-48000: CMP_TARGET = 1.00
+fate-swr-resample_exact-dblp-96000-48000: CMP_TARGET = 0.99
 fate-swr-resample_exact-dblp-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
 
 fate-swr-resample_exact-dblp-96000-8000: CMP_TARGET = 58.52
 fate-swr-resample_exact-dblp-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
 
-fate-swr-resample_exact-fltp-2626-44100: CMP_TARGET = 1352.68
+fate-swr-resample_exact-fltp-2626-44100: CMP_TARGET = 1352.67
 fate-swr-resample_exact-fltp-2626-44100: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample_exact-fltp-2626-48000: CMP_TARGET = 1352.65
+fate-swr-resample_exact-fltp-2626-48000: CMP_TARGET = 1352.66
 fate-swr-resample_exact-fltp-2626-48000: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample_exact-fltp-2626-8000: CMP_TARGET = 1353.08
+fate-swr-resample_exact-fltp-2626-8000: CMP_TARGET = 1352.56
 fate-swr-resample_exact-fltp-2626-8000: SIZE_TOLERANCE = 31512 - 20482
 
 fate-swr-resample_exact-fltp-2626-96000: CMP_TARGET = 1352.67
@@ -464,7 +465,7 @@ fate-swr-resample_exact-fltp-2626-96000: SIZE_TOLERANCE = 31512 - 20480
 fate-swr-resample_exact-fltp-44100-2626: CMP_TARGET = 185.82
 fate-swr-resample_exact-fltp-44100-2626: SIZE_TOLERANCE = 529200 - 20490
 
-fate-swr-resample_exact-fltp-44100-48000: CMP_TARGET = 9.65
+fate-swr-resample_exact-fltp-44100-48000: CMP_TARGET = 9.64
 fate-swr-resample_exact-fltp-44100-48000: SIZE_TOLERANCE = 529200 - 20482
 
 fate-swr-resample_exact-fltp-44100-8000: CMP_TARGET = 75.38
@@ -476,7 +477,7 @@ fate-swr-resample_exact-fltp-44100-96000: SIZE_TOLERANCE = 529200 - 20482
 fate-swr-resample_exact-fltp-48000-2626: CMP_TARGET = 456.51
 fate-swr-resample_exact-fltp-48000-2626: SIZE_TOLERANCE = 576000 - 20510
 
-fate-swr-resample_exact-fltp-48000-44100: CMP_TARGET = 0.26
+fate-swr-resample_exact-fltp-48000-44100: CMP_TARGET = 0.23
 fate-swr-resample_exact-fltp-48000-44100: SIZE_TOLERANCE = 576000 - 20480
 
 fate-swr-resample_exact-fltp-48000-8000: CMP_TARGET = 62.36
@@ -485,7 +486,7 @@ fate-swr-resample_exact-fltp-48000-8000: SIZE_TOLERANCE = 576000 - 20484
 fate-swr-resample_exact-fltp-48000-96000: CMP_TARGET = 0.47
 fate-swr-resample_exact-fltp-48000-96000: SIZE_TOLERANCE = 576000 - 20480
 
-fate-swr-resample_exact-fltp-8000-2626: CMP_TARGET = 2506.02
+fate-swr-resample_exact-fltp-8000-2626: CMP_TARGET = 2503.33
 fate-swr-resample_exact-fltp-8000-2626: SIZE_TOLERANCE = 96000 - 20486
 
 fate-swr-resample_exact-fltp-8000-44100: CMP_TARGET = 14.59
@@ -497,34 +498,34 @@ fate-swr-resample_exact-fltp-8000-48000: SIZE_TOLERANCE = 96000 - 20480
 fate-swr-resample_exact-fltp-8000-96000: CMP_TARGET = 13.62
 fate-swr-resample_exact-fltp-8000-96000: SIZE_TOLERANCE = 96000 - 20480
 
-fate-swr-resample_exact-fltp-96000-2626: CMP_TARGET = 675.08
+fate-swr-resample_exact-fltp-96000-2626: CMP_TARGET = 675.07
 fate-swr-resample_exact-fltp-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
 
-fate-swr-resample_exact-fltp-96000-44100: CMP_TARGET = 1.26
+fate-swr-resample_exact-fltp-96000-44100: CMP_TARGET = 1.23
 fate-swr-resample_exact-fltp-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
 
-fate-swr-resample_exact-fltp-96000-48000: CMP_TARGET = 1.00
+fate-swr-resample_exact-fltp-96000-48000: CMP_TARGET = 0.99
 fate-swr-resample_exact-fltp-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
 
 fate-swr-resample_exact-fltp-96000-8000: CMP_TARGET = 58.52
 fate-swr-resample_exact-fltp-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
 
-fate-swr-resample_exact-s16p-2626-44100: CMP_TARGET = 1393.01
+fate-swr-resample_exact-s16p-2626-44100: CMP_TARGET = 1392.98
 fate-swr-resample_exact-s16p-2626-44100: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample_exact-s16p-2626-48000: CMP_TARGET = 1392.99
+fate-swr-resample_exact-s16p-2626-48000: CMP_TARGET = 1393.01
 fate-swr-resample_exact-s16p-2626-48000: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample_exact-s16p-2626-8000: CMP_TARGET = 1393.90
+fate-swr-resample_exact-s16p-2626-8000: CMP_TARGET = 1393.36
 fate-swr-resample_exact-s16p-2626-8000: SIZE_TOLERANCE = 31512 - 20482
 
-fate-swr-resample_exact-s16p-2626-96000: CMP_TARGET = 1393.08
+fate-swr-resample_exact-s16p-2626-96000: CMP_TARGET = 1393.07
 fate-swr-resample_exact-s16p-2626-96000: SIZE_TOLERANCE = 31512 - 20480
 
 fate-swr-resample_exact-s16p-44100-2626: CMP_TARGET = 185.84
 fate-swr-resample_exact-s16p-44100-2626: SIZE_TOLERANCE = 529200 - 20490
 
-fate-swr-resample_exact-s16p-44100-48000: CMP_TARGET = 9.67
+fate-swr-resample_exact-s16p-44100-48000: CMP_TARGET = 9.66
 fate-swr-resample_exact-s16p-44100-48000: SIZE_TOLERANCE = 529200 - 20482
 
 fate-swr-resample_exact-s16p-44100-8000: CMP_TARGET = 75.43
@@ -536,16 +537,16 @@ fate-swr-resample_exact-s16p-44100-96000: SIZE_TOLERANCE = 529200 - 20482
 fate-swr-resample_exact-s16p-48000-2626: CMP_TARGET = 456.55
 fate-swr-resample_exact-s16p-48000-2626: SIZE_TOLERANCE = 576000 - 20510
 
-fate-swr-resample_exact-s16p-48000-44100: CMP_TARGET = 0.72
+fate-swr-resample_exact-s16p-48000-44100: CMP_TARGET = 0.68
 fate-swr-resample_exact-s16p-48000-44100: SIZE_TOLERANCE = 576000 - 20480
 
 fate-swr-resample_exact-s16p-48000-8000: CMP_TARGET = 62.39
 fate-swr-resample_exact-s16p-48000-8000: SIZE_TOLERANCE = 576000 - 20484
 
-fate-swr-resample_exact-s16p-48000-96000: CMP_TARGET = 0.50
+fate-swr-resample_exact-s16p-48000-96000: CMP_TARGET = 0.73
 fate-swr-resample_exact-s16p-48000-96000: SIZE_TOLERANCE = 576000 - 20480
 
-fate-swr-resample_exact-s16p-8000-2626: CMP_TARGET = 2506.02
+fate-swr-resample_exact-s16p-8000-2626: CMP_TARGET = 2503.32
 fate-swr-resample_exact-s16p-8000-2626: SIZE_TOLERANCE = 96000 - 20486
 
 fate-swr-resample_exact-s16p-8000-44100: CMP_TARGET = 14.63
@@ -557,82 +558,82 @@ fate-swr-resample_exact-s16p-8000-48000: SIZE_TOLERANCE = 96000 - 20480
 fate-swr-resample_exact-s16p-8000-96000: CMP_TARGET = 13.65
 fate-swr-resample_exact-s16p-8000-96000: SIZE_TOLERANCE = 96000 - 20480
 
-fate-swr-resample_exact-s16p-96000-2626: CMP_TARGET = 675.14
+fate-swr-resample_exact-s16p-96000-2626: CMP_TARGET = 675.15
 fate-swr-resample_exact-s16p-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
 
-fate-swr-resample_exact-s16p-96000-44100: CMP_TARGET = 1.45
+fate-swr-resample_exact-s16p-96000-44100: CMP_TARGET = 1.44
 fate-swr-resample_exact-s16p-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
 
-fate-swr-resample_exact-s16p-96000-48000: CMP_TARGET = 1.03
+fate-swr-resample_exact-s16p-96000-48000: CMP_TARGET = 1.12
 fate-swr-resample_exact-s16p-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
 
 fate-swr-resample_exact-s16p-96000-8000: CMP_TARGET = 58.56
 fate-swr-resample_exact-s16p-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
 
-fate-swr-resample_exact-s32p-2626-44100: CMP_TARGET = 1393.01
+fate-swr-resample_exact-s32p-2626-44100: CMP_TARGET = 1392.99
 fate-swr-resample_exact-s32p-2626-44100: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample_exact-s32p-2626-48000: CMP_TARGET = 1392.99
+fate-swr-resample_exact-s32p-2626-48000: CMP_TARGET = 1393.01
 fate-swr-resample_exact-s32p-2626-48000: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample_exact-s32p-2626-8000: CMP_TARGET = 1393.89
+fate-swr-resample_exact-s32p-2626-8000: CMP_TARGET = 1393.36
 fate-swr-resample_exact-s32p-2626-8000: SIZE_TOLERANCE = 31512 - 20482
 
 fate-swr-resample_exact-s32p-2626-96000: CMP_TARGET = 1393.00
 fate-swr-resample_exact-s32p-2626-96000: SIZE_TOLERANCE = 31512 - 20480
 
-fate-swr-resample_exact-s32p-44100-2626: CMP_TARGET = 185.82
+fate-swr-resample_exact-s32p-44100-2626: CMP_TARGET = 185.81
 fate-swr-resample_exact-s32p-44100-2626: SIZE_TOLERANCE = 529200 - 20490
 
-fate-swr-resample_exact-s32p-44100-48000: CMP_TARGET = 9.65
+fate-swr-resample_exact-s32p-44100-48000: CMP_TARGET = 9.66
 fate-swr-resample_exact-s32p-44100-48000: SIZE_TOLERANCE = 529200 - 20482
 
-fate-swr-resample_exact-s32p-44100-8000: CMP_TARGET = 75.38
+fate-swr-resample_exact-s32p-44100-8000: CMP_TARGET = 75.37
 fate-swr-resample_exact-s32p-44100-8000: SIZE_TOLERANCE = 529200 - 20486
 
-fate-swr-resample_exact-s32p-44100-96000: CMP_TARGET = 11.45
+fate-swr-resample_exact-s32p-44100-96000: CMP_TARGET = 11.46
 fate-swr-resample_exact-s32p-44100-96000: SIZE_TOLERANCE = 529200 - 20482
 
-fate-swr-resample_exact-s32p-48000-2626: CMP_TARGET = 456.51
+fate-swr-resample_exact-s32p-48000-2626: CMP_TARGET = 456.49
 fate-swr-resample_exact-s32p-48000-2626: SIZE_TOLERANCE = 576000 - 20510
 
-fate-swr-resample_exact-s32p-48000-44100: CMP_TARGET = 0.26
+fate-swr-resample_exact-s32p-48000-44100: CMP_TARGET = 0.74
 fate-swr-resample_exact-s32p-48000-44100: SIZE_TOLERANCE = 576000 - 20480
 
-fate-swr-resample_exact-s32p-48000-8000: CMP_TARGET = 62.36
+fate-swr-resample_exact-s32p-48000-8000: CMP_TARGET = 62.35
 fate-swr-resample_exact-s32p-48000-8000: SIZE_TOLERANCE = 576000 - 20484
 
-fate-swr-resample_exact-s32p-48000-96000: CMP_TARGET = 0.47
+fate-swr-resample_exact-s32p-48000-96000: CMP_TARGET = 0.85
 fate-swr-resample_exact-s32p-48000-96000: SIZE_TOLERANCE = 576000 - 20480
 
-fate-swr-resample_exact-s32p-8000-2626: CMP_TARGET = 2506.02
+fate-swr-resample_exact-s32p-8000-2626: CMP_TARGET = 2503.33
 fate-swr-resample_exact-s32p-8000-2626: SIZE_TOLERANCE = 96000 - 20486
 
-fate-swr-resample_exact-s32p-8000-44100: CMP_TARGET = 14.59
+fate-swr-resample_exact-s32p-8000-44100: CMP_TARGET = 14.61
 fate-swr-resample_exact-s32p-8000-44100: SIZE_TOLERANCE = 96000 - 20480
 
-fate-swr-resample_exact-s32p-8000-48000: CMP_TARGET = 14.50
+fate-swr-resample_exact-s32p-8000-48000: CMP_TARGET = 14.52
 fate-swr-resample_exact-s32p-8000-48000: SIZE_TOLERANCE = 96000 - 20480
 
 fate-swr-resample_exact-s32p-8000-96000: CMP_TARGET = 13.62
 fate-swr-resample_exact-s32p-8000-96000: SIZE_TOLERANCE = 96000 - 20480
 
-fate-swr-resample_exact-s32p-96000-2626: CMP_TARGET = 675.08
+fate-swr-resample_exact-s32p-96000-2626: CMP_TARGET = 675.05
 fate-swr-resample_exact-s32p-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
 
-fate-swr-resample_exact-s32p-96000-44100: CMP_TARGET = 1.26
+fate-swr-resample_exact-s32p-96000-44100: CMP_TARGET = 1.41
 fate-swr-resample_exact-s32p-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
 
-fate-swr-resample_exact-s32p-96000-48000: CMP_TARGET = 1.00
+fate-swr-resample_exact-s32p-96000-48000: CMP_TARGET = 1.21
 fate-swr-resample_exact-s32p-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
 
-fate-swr-resample_exact-s32p-96000-8000: CMP_TARGET = 58.52
+fate-swr-resample_exact-s32p-96000-8000: CMP_TARGET = 58.54
 fate-swr-resample_exact-s32p-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
 
 define ARESAMPLE_EXACT_ASYNC
 FATE_SWR_RESAMPLE += fate-swr-resample_exact_async-$(3)-$(1)-$(2)
 fate-swr-resample_exact_async-$(3)-$(1)-$(2): tests/data/asynth-$(1)-1.wav
-fate-swr-resample_exact_async-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,asetpts=PTS+random\(0\)*200-100,aresample=$(2):async=50:min_hard_comp=0.100000:first_pts=0:internal_sample_fmt=$(3):exact_rational=on,aformat=$(3),aresample=$(1):internal_sample_fmt=$(3):exact_rational=on -f wav -acodec pcm_s16le -
+fate-swr-resample_exact_async-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,asetpts=PTS+random\(0\)*200-100,aresample=$(2):async=50:min_hard_comp=0.100000:first_pts=0:internal_sample_fmt=$(3):exact_rational=on:linear_interp=0,aformat=$(3),aresample=$(1):internal_sample_fmt=$(3):exact_rational=on:linear_interp=0 -f wav -c:a pcm_s16le -
 
 fate-swr-resample_exact_async-$(3)-$(1)-$(2): CMP = stddev
 fate-swr-resample_exact_async-$(3)-$(1)-$(2): CMP_UNIT = $(5)
@@ -640,78 +641,412 @@ fate-swr-resample_exact_async-$(3)-$(1)-$(2): FUZZ = 0.1
 fate-swr-resample_exact_async-$(3)-$(1)-$(2): REF = tests/data/asynth-$(1)-1.wav
 endef
 
-fate-swr-resample_exact_async-dblp-44100-48000: CMP_TARGET = 7791.55
+fate-swr-resample_exact_async-dblp-44100-48000: CMP_TARGET = 7791.50
 fate-swr-resample_exact_async-dblp-44100-48000: SIZE_TOLERANCE = 529200 - 20300
 
-fate-swr-resample_exact_async-dblp-44100-8000: CMP_TARGET = 4022.89
+fate-swr-resample_exact_async-dblp-44100-8000: CMP_TARGET = 4022.87
 fate-swr-resample_exact_async-dblp-44100-8000: SIZE_TOLERANCE = 529200 - 20310
 
-fate-swr-resample_exact_async-dblp-48000-44100: CMP_TARGET = 1923.99
+fate-swr-resample_exact_async-dblp-48000-44100: CMP_TARGET = 1923.97
 fate-swr-resample_exact_async-dblp-48000-44100: SIZE_TOLERANCE = 576000 - 20298
 
-fate-swr-resample_exact_async-dblp-48000-8000: CMP_TARGET = 2592.02
+fate-swr-resample_exact_async-dblp-48000-8000: CMP_TARGET = 2592.00
 fate-swr-resample_exact_async-dblp-48000-8000: SIZE_TOLERANCE = 576000 - 20304
 
-fate-swr-resample_exact_async-dblp-8000-44100: CMP_TARGET = 11187.37
+fate-swr-resample_exact_async-dblp-8000-44100: CMP_TARGET = 11187.24
 fate-swr-resample_exact_async-dblp-8000-44100: SIZE_TOLERANCE = 96000 - 20344
 
-fate-swr-resample_exact_async-dblp-8000-48000: CMP_TARGET = 11326.82
+fate-swr-resample_exact_async-dblp-8000-48000: CMP_TARGET = 11326.80
 fate-swr-resample_exact_async-dblp-8000-48000: SIZE_TOLERANCE = 96000 - 20344
 
-fate-swr-resample_exact_async-fltp-44100-48000: CMP_TARGET = 7791.55
+fate-swr-resample_exact_async-fltp-44100-48000: CMP_TARGET = 7791.50
 fate-swr-resample_exact_async-fltp-44100-48000: SIZE_TOLERANCE = 529200 - 20300
 
-fate-swr-resample_exact_async-fltp-44100-8000: CMP_TARGET = 4022.89
+fate-swr-resample_exact_async-fltp-44100-8000: CMP_TARGET = 4022.87
 fate-swr-resample_exact_async-fltp-44100-8000: SIZE_TOLERANCE = 529200 - 20310
 
-fate-swr-resample_exact_async-fltp-48000-44100: CMP_TARGET = 1923.98
+fate-swr-resample_exact_async-fltp-48000-44100: CMP_TARGET = 1923.97
 fate-swr-resample_exact_async-fltp-48000-44100: SIZE_TOLERANCE = 576000 - 20298
 
-fate-swr-resample_exact_async-fltp-48000-8000: CMP_TARGET = 2592.02
+fate-swr-resample_exact_async-fltp-48000-8000: CMP_TARGET = 2592.00
 fate-swr-resample_exact_async-fltp-48000-8000: SIZE_TOLERANCE = 576000 - 20304
 
-fate-swr-resample_exact_async-fltp-8000-44100: CMP_TARGET = 11187.37
+fate-swr-resample_exact_async-fltp-8000-44100: CMP_TARGET = 11187.24
 fate-swr-resample_exact_async-fltp-8000-44100: SIZE_TOLERANCE = 96000 - 20344
 
-fate-swr-resample_exact_async-fltp-8000-48000: CMP_TARGET = 11326.82
+fate-swr-resample_exact_async-fltp-8000-48000: CMP_TARGET = 11326.80
 fate-swr-resample_exact_async-fltp-8000-48000: SIZE_TOLERANCE = 96000 - 20344
 
-fate-swr-resample_exact_async-s16p-44100-48000: CMP_TARGET = 7791.56
+fate-swr-resample_exact_async-s16p-44100-48000: CMP_TARGET = 7791.50
 fate-swr-resample_exact_async-s16p-44100-48000: SIZE_TOLERANCE = 529200 - 20300
 
-fate-swr-resample_exact_async-s16p-44100-8000: CMP_TARGET = 4023.06
+fate-swr-resample_exact_async-s16p-44100-8000: CMP_TARGET = 4023.05
 fate-swr-resample_exact_async-s16p-44100-8000: SIZE_TOLERANCE = 529200 - 20310
 
-fate-swr-resample_exact_async-s16p-48000-44100: CMP_TARGET = 1923.98
+fate-swr-resample_exact_async-s16p-48000-44100: CMP_TARGET = 1923.96
 fate-swr-resample_exact_async-s16p-48000-44100: SIZE_TOLERANCE = 576000 - 20298
 
 fate-swr-resample_exact_async-s16p-48000-8000: CMP_TARGET = 2592.15
 fate-swr-resample_exact_async-s16p-48000-8000: SIZE_TOLERANCE = 576000 - 20304
 
-fate-swr-resample_exact_async-s16p-8000-44100: CMP_TARGET = 11187.62
+fate-swr-resample_exact_async-s16p-8000-44100: CMP_TARGET = 11187.58
 fate-swr-resample_exact_async-s16p-8000-44100: SIZE_TOLERANCE = 96000 - 20344
 
-fate-swr-resample_exact_async-s16p-8000-48000: CMP_TARGET = 11327.50
+fate-swr-resample_exact_async-s16p-8000-48000: CMP_TARGET = 11327.48
 fate-swr-resample_exact_async-s16p-8000-48000: SIZE_TOLERANCE = 96000 - 20344
 
-fate-swr-resample_exact_async-s32p-44100-48000: CMP_TARGET = 7791.55
+fate-swr-resample_exact_async-s32p-44100-48000: CMP_TARGET = 7791.50
 fate-swr-resample_exact_async-s32p-44100-48000: SIZE_TOLERANCE = 529200 - 20300
 
-fate-swr-resample_exact_async-s32p-44100-8000: CMP_TARGET = 4022.89
+fate-swr-resample_exact_async-s32p-44100-8000: CMP_TARGET = 4022.87
 fate-swr-resample_exact_async-s32p-44100-8000: SIZE_TOLERANCE = 529200 - 20310
 
-fate-swr-resample_exact_async-s32p-48000-44100: CMP_TARGET = 1923.98
+fate-swr-resample_exact_async-s32p-48000-44100: CMP_TARGET = 1923.96
 fate-swr-resample_exact_async-s32p-48000-44100: SIZE_TOLERANCE = 576000 - 20298
 
-fate-swr-resample_exact_async-s32p-48000-8000: CMP_TARGET = 2592.02
+fate-swr-resample_exact_async-s32p-48000-8000: CMP_TARGET = 2592.00
 fate-swr-resample_exact_async-s32p-48000-8000: SIZE_TOLERANCE = 576000 - 20304
 
-fate-swr-resample_exact_async-s32p-8000-44100: CMP_TARGET = 11187.37
+fate-swr-resample_exact_async-s32p-8000-44100: CMP_TARGET = 11187.24
 fate-swr-resample_exact_async-s32p-8000-44100: SIZE_TOLERANCE = 96000 - 20344
 
-fate-swr-resample_exact_async-s32p-8000-48000: CMP_TARGET = 11326.82
+fate-swr-resample_exact_async-s32p-8000-48000: CMP_TARGET = 11326.79
 fate-swr-resample_exact_async-s32p-8000-48000: SIZE_TOLERANCE = 96000 - 20344
 
+define ARESAMPLE_EXACT_LIN
+FATE_SWR_RESAMPLE += fate-swr-resample_exact_lin-$(3)-$(1)-$(2)
+fate-swr-resample_exact_lin-$(3)-$(1)-$(2): tests/data/asynth-$(1)-1.wav
+fate-swr-resample_exact_lin-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,aresample=$(2):internal_sample_fmt=$(3):exact_rational=on:linear_interp=on,aformat=$(3),aresample=$(1):internal_sample_fmt=$(3):exact_rational=on:linear_interp=on -f wav -c:a pcm_s16le -
+
+fate-swr-resample_exact_lin-$(3)-$(1)-$(2): CMP = stddev
+fate-swr-resample_exact_lin-$(3)-$(1)-$(2): CMP_UNIT = $(5)
+fate-swr-resample_exact_lin-$(3)-$(1)-$(2): FUZZ = 0.1
+fate-swr-resample_exact_lin-$(3)-$(1)-$(2): REF = tests/data/asynth-$(1)-1.wav
+endef
+
+fate-swr-resample_exact_lin-dblp-44100-48000: CMP_TARGET = 9.64
+fate-swr-resample_exact_lin-dblp-44100-48000: SIZE_TOLERANCE = 529200 - 20482
+
+fate-swr-resample_exact_lin-dblp-44100-8000: CMP_TARGET = 75.38
+fate-swr-resample_exact_lin-dblp-44100-8000: SIZE_TOLERANCE = 529200 - 20486
+
+fate-swr-resample_exact_lin-dblp-48000-44100: CMP_TARGET = 0.23
+fate-swr-resample_exact_lin-dblp-48000-44100: SIZE_TOLERANCE = 576000 - 20480
+
+fate-swr-resample_exact_lin-dblp-48000-8000: CMP_TARGET = 62.36
+fate-swr-resample_exact_lin-dblp-48000-8000: SIZE_TOLERANCE = 576000 - 20484
+
+fate-swr-resample_exact_lin-dblp-8000-44100: CMP_TARGET = 14.59
+fate-swr-resample_exact_lin-dblp-8000-44100: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-dblp-8000-48000: CMP_TARGET = 14.50
+fate-swr-resample_exact_lin-dblp-8000-48000: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-fltp-44100-48000: CMP_TARGET = 9.64
+fate-swr-resample_exact_lin-fltp-44100-48000: SIZE_TOLERANCE = 529200 - 20482
+
+fate-swr-resample_exact_lin-fltp-44100-8000: CMP_TARGET = 75.38
+fate-swr-resample_exact_lin-fltp-44100-8000: SIZE_TOLERANCE = 529200 - 20486
+
+fate-swr-resample_exact_lin-fltp-48000-44100: CMP_TARGET = 0.23
+fate-swr-resample_exact_lin-fltp-48000-44100: SIZE_TOLERANCE = 576000 - 20480
+
+fate-swr-resample_exact_lin-fltp-48000-8000: CMP_TARGET = 62.36
+fate-swr-resample_exact_lin-fltp-48000-8000: SIZE_TOLERANCE = 576000 - 20484
+
+fate-swr-resample_exact_lin-fltp-8000-44100: CMP_TARGET = 14.59
+fate-swr-resample_exact_lin-fltp-8000-44100: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-fltp-8000-48000: CMP_TARGET = 14.50
+fate-swr-resample_exact_lin-fltp-8000-48000: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-s16p-44100-48000: CMP_TARGET = 9.66
+fate-swr-resample_exact_lin-s16p-44100-48000: SIZE_TOLERANCE = 529200 - 20482
+
+fate-swr-resample_exact_lin-s16p-44100-8000: CMP_TARGET = 75.43
+fate-swr-resample_exact_lin-s16p-44100-8000: SIZE_TOLERANCE = 529200 - 20486
+
+fate-swr-resample_exact_lin-s16p-48000-44100: CMP_TARGET = 0.68
+fate-swr-resample_exact_lin-s16p-48000-44100: SIZE_TOLERANCE = 576000 - 20480
+
+fate-swr-resample_exact_lin-s16p-48000-8000: CMP_TARGET = 62.39
+fate-swr-resample_exact_lin-s16p-48000-8000: SIZE_TOLERANCE = 576000 - 20484
+
+fate-swr-resample_exact_lin-s16p-8000-44100: CMP_TARGET = 14.63
+fate-swr-resample_exact_lin-s16p-8000-44100: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-s16p-8000-48000: CMP_TARGET = 14.54
+fate-swr-resample_exact_lin-s16p-8000-48000: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-s32p-44100-48000: CMP_TARGET = 9.66
+fate-swr-resample_exact_lin-s32p-44100-48000: SIZE_TOLERANCE = 529200 - 20482
+
+fate-swr-resample_exact_lin-s32p-44100-8000: CMP_TARGET = 75.37
+fate-swr-resample_exact_lin-s32p-44100-8000: SIZE_TOLERANCE = 529200 - 20486
+
+fate-swr-resample_exact_lin-s32p-48000-44100: CMP_TARGET = 0.74
+fate-swr-resample_exact_lin-s32p-48000-44100: SIZE_TOLERANCE = 576000 - 20480
+
+fate-swr-resample_exact_lin-s32p-48000-8000: CMP_TARGET = 62.35
+fate-swr-resample_exact_lin-s32p-48000-8000: SIZE_TOLERANCE = 576000 - 20484
+
+fate-swr-resample_exact_lin-s32p-8000-44100: CMP_TARGET = 14.61
+fate-swr-resample_exact_lin-s32p-8000-44100: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-s32p-8000-48000: CMP_TARGET = 14.52
+fate-swr-resample_exact_lin-s32p-8000-48000: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-dblp-2626-44100: CMP_TARGET = 1352.60
+fate-swr-resample_exact_lin-dblp-2626-44100: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-dblp-2626-48000: CMP_TARGET = 1352.62
+fate-swr-resample_exact_lin-dblp-2626-48000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-dblp-2626-8000: CMP_TARGET = 1352.49
+fate-swr-resample_exact_lin-dblp-2626-8000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-dblp-2626-96000: CMP_TARGET = 1352.62
+fate-swr-resample_exact_lin-dblp-2626-96000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-dblp-44100-2626: CMP_TARGET = 185.49
+fate-swr-resample_exact_lin-dblp-44100-2626: SIZE_TOLERANCE = 529200 - 20490
+
+fate-swr-resample_exact_lin-dblp-44100-96000: CMP_TARGET = 11.45
+fate-swr-resample_exact_lin-dblp-44100-96000: SIZE_TOLERANCE = 529200 - 20482
+
+fate-swr-resample_exact_lin-dblp-48000-2626: CMP_TARGET = 456.50
+fate-swr-resample_exact_lin-dblp-48000-2626: SIZE_TOLERANCE = 576000 - 20510
+
+fate-swr-resample_exact_lin-dblp-48000-96000: CMP_TARGET = 0.47
+fate-swr-resample_exact_lin-dblp-48000-96000: SIZE_TOLERANCE = 576000 - 20480
+
+fate-swr-resample_exact_lin-dblp-8000-2626: CMP_TARGET = 2503.28
+fate-swr-resample_exact_lin-dblp-8000-2626: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-dblp-8000-96000: CMP_TARGET = 13.62
+fate-swr-resample_exact_lin-dblp-8000-96000: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-dblp-96000-2626: CMP_TARGET = 675.02
+fate-swr-resample_exact_lin-dblp-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
+
+fate-swr-resample_exact_lin-dblp-96000-44100: CMP_TARGET = 1.24
+fate-swr-resample_exact_lin-dblp-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
+
+fate-swr-resample_exact_lin-dblp-96000-48000: CMP_TARGET = 0.99
+fate-swr-resample_exact_lin-dblp-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
+
+fate-swr-resample_exact_lin-dblp-96000-8000: CMP_TARGET = 58.52
+fate-swr-resample_exact_lin-dblp-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
+
+fate-swr-resample_exact_lin-fltp-2626-44100: CMP_TARGET = 1352.60
+fate-swr-resample_exact_lin-fltp-2626-44100: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-fltp-2626-48000: CMP_TARGET = 1352.62
+fate-swr-resample_exact_lin-fltp-2626-48000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-fltp-2626-8000: CMP_TARGET = 1352.49
+fate-swr-resample_exact_lin-fltp-2626-8000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-fltp-2626-96000: CMP_TARGET = 1352.62
+fate-swr-resample_exact_lin-fltp-2626-96000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-fltp-44100-2626: CMP_TARGET = 185.49
+fate-swr-resample_exact_lin-fltp-44100-2626: SIZE_TOLERANCE = 529200 - 20490
+
+fate-swr-resample_exact_lin-fltp-44100-96000: CMP_TARGET = 11.45
+fate-swr-resample_exact_lin-fltp-44100-96000: SIZE_TOLERANCE = 529200 - 20482
+
+fate-swr-resample_exact_lin-fltp-48000-2626: CMP_TARGET = 456.50
+fate-swr-resample_exact_lin-fltp-48000-2626: SIZE_TOLERANCE = 576000 - 20510
+
+fate-swr-resample_exact_lin-fltp-48000-96000: CMP_TARGET = 0.47
+fate-swr-resample_exact_lin-fltp-48000-96000: SIZE_TOLERANCE = 576000 - 20480
+
+fate-swr-resample_exact_lin-fltp-8000-2626: CMP_TARGET = 2503.28
+fate-swr-resample_exact_lin-fltp-8000-2626: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-fltp-8000-96000: CMP_TARGET = 13.62
+fate-swr-resample_exact_lin-fltp-8000-96000: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-fltp-96000-2626: CMP_TARGET = 675.02
+fate-swr-resample_exact_lin-fltp-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
+
+fate-swr-resample_exact_lin-fltp-96000-44100: CMP_TARGET = 1.23
+fate-swr-resample_exact_lin-fltp-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
+
+fate-swr-resample_exact_lin-fltp-96000-48000: CMP_TARGET = 0.99
+fate-swr-resample_exact_lin-fltp-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
+
+fate-swr-resample_exact_lin-fltp-96000-8000: CMP_TARGET = 58.52
+fate-swr-resample_exact_lin-fltp-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
+
+fate-swr-resample_exact_lin-s16p-2626-44100: CMP_TARGET = 1392.93
+fate-swr-resample_exact_lin-s16p-2626-44100: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-s16p-2626-48000: CMP_TARGET = 1392.97
+fate-swr-resample_exact_lin-s16p-2626-48000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-s16p-2626-8000: CMP_TARGET = 1393.28
+fate-swr-resample_exact_lin-s16p-2626-8000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-s16p-2626-96000: CMP_TARGET = 1393.04
+fate-swr-resample_exact_lin-s16p-2626-96000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-s16p-44100-2626: CMP_TARGET = 185.51
+fate-swr-resample_exact_lin-s16p-44100-2626: SIZE_TOLERANCE = 529200 - 20490
+
+fate-swr-resample_exact_lin-s16p-44100-96000: CMP_TARGET = 11.46
+fate-swr-resample_exact_lin-s16p-44100-96000: SIZE_TOLERANCE = 529200 - 20482
+
+fate-swr-resample_exact_lin-s16p-48000-2626: CMP_TARGET = 456.56
+fate-swr-resample_exact_lin-s16p-48000-2626: SIZE_TOLERANCE = 576000 - 20510
+
+fate-swr-resample_exact_lin-s16p-48000-96000: CMP_TARGET = 0.73
+fate-swr-resample_exact_lin-s16p-48000-96000: SIZE_TOLERANCE = 576000 - 20480
+
+fate-swr-resample_exact_lin-s16p-8000-2626: CMP_TARGET = 2503.28
+fate-swr-resample_exact_lin-s16p-8000-2626: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-s16p-8000-96000: CMP_TARGET = 13.65
+fate-swr-resample_exact_lin-s16p-8000-96000: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-s16p-96000-2626: CMP_TARGET = 675.07
+fate-swr-resample_exact_lin-s16p-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
+
+fate-swr-resample_exact_lin-s16p-96000-44100: CMP_TARGET = 1.44
+fate-swr-resample_exact_lin-s16p-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
+
+fate-swr-resample_exact_lin-s16p-96000-48000: CMP_TARGET = 1.12
+fate-swr-resample_exact_lin-s16p-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
+
+fate-swr-resample_exact_lin-s16p-96000-8000: CMP_TARGET = 58.56
+fate-swr-resample_exact_lin-s16p-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
+
+fate-swr-resample_exact_lin-s32p-2626-44100: CMP_TARGET = 1392.95
+fate-swr-resample_exact_lin-s32p-2626-44100: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-s32p-2626-48000: CMP_TARGET = 1392.98
+fate-swr-resample_exact_lin-s32p-2626-48000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-s32p-2626-8000: CMP_TARGET = 1393.29
+fate-swr-resample_exact_lin-s32p-2626-8000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-s32p-2626-96000: CMP_TARGET = 1392.96
+fate-swr-resample_exact_lin-s32p-2626-96000: SIZE_TOLERANCE = 31512 - 20480
+
+fate-swr-resample_exact_lin-s32p-44100-2626: CMP_TARGET = 185.48
+fate-swr-resample_exact_lin-s32p-44100-2626: SIZE_TOLERANCE = 529200 - 20490
+
+fate-swr-resample_exact_lin-s32p-44100-96000: CMP_TARGET = 11.46
+fate-swr-resample_exact_lin-s32p-44100-96000: SIZE_TOLERANCE = 529200 - 20482
+
+fate-swr-resample_exact_lin-s32p-48000-2626: CMP_TARGET = 456.48
+fate-swr-resample_exact_lin-s32p-48000-2626: SIZE_TOLERANCE = 576000 - 20510
+
+fate-swr-resample_exact_lin-s32p-48000-96000: CMP_TARGET = 0.85
+fate-swr-resample_exact_lin-s32p-48000-96000: SIZE_TOLERANCE = 576000 - 20480
+
+fate-swr-resample_exact_lin-s32p-8000-2626: CMP_TARGET = 2503.28
+fate-swr-resample_exact_lin-s32p-8000-2626: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-s32p-8000-96000: CMP_TARGET = 13.62
+fate-swr-resample_exact_lin-s32p-8000-96000: SIZE_TOLERANCE = 96000 - 20480
+
+fate-swr-resample_exact_lin-s32p-96000-2626: CMP_TARGET = 675.00
+fate-swr-resample_exact_lin-s32p-96000-2626: SIZE_TOLERANCE = 1152000 - 20474
+
+fate-swr-resample_exact_lin-s32p-96000-44100: CMP_TARGET = 1.41
+fate-swr-resample_exact_lin-s32p-96000-44100: SIZE_TOLERANCE = 1152000 - 20480
+
+fate-swr-resample_exact_lin-s32p-96000-48000: CMP_TARGET = 1.21
+fate-swr-resample_exact_lin-s32p-96000-48000: SIZE_TOLERANCE = 1152000 - 20480
+
+fate-swr-resample_exact_lin-s32p-96000-8000: CMP_TARGET = 58.54
+fate-swr-resample_exact_lin-s32p-96000-8000: SIZE_TOLERANCE = 1152000 - 20496
+
+define ARESAMPLE_EXACT_LIN_ASYNC
+FATE_SWR_RESAMPLE += fate-swr-resample_exact_lin_async-$(3)-$(1)-$(2)
+fate-swr-resample_exact_lin_async-$(3)-$(1)-$(2): tests/data/asynth-$(1)-1.wav
+fate-swr-resample_exact_lin_async-$(3)-$(1)-$(2): CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-$(1)-1.wav -af atrim=end_sample=10240,asetpts=PTS+random\(0\)*200-100,aresample=$(2):async=50:min_hard_comp=0.100000:first_pts=0:internal_sample_fmt=$(3):exact_rational=on:linear_interp=on,aformat=$(3),aresample=$(1):internal_sample_fmt=$(3):exact_rational=on:linear_interp=on -f wav -c:a pcm_s16le -
+
+fate-swr-resample_exact_lin_async-$(3)-$(1)-$(2): CMP = stddev
+fate-swr-resample_exact_lin_async-$(3)-$(1)-$(2): CMP_UNIT = $(5)
+fate-swr-resample_exact_lin_async-$(3)-$(1)-$(2): FUZZ = 0.1
+fate-swr-resample_exact_lin_async-$(3)-$(1)-$(2): REF = tests/data/asynth-$(1)-1.wav
+endef
+
+fate-swr-resample_exact_lin_async-dblp-44100-48000: CMP_TARGET = 7791.72
+fate-swr-resample_exact_lin_async-dblp-44100-48000: SIZE_TOLERANCE = 529200 - 20300
+
+fate-swr-resample_exact_lin_async-dblp-44100-8000: CMP_TARGET = 4023.01
+fate-swr-resample_exact_lin_async-dblp-44100-8000: SIZE_TOLERANCE = 529200 - 20310
+
+fate-swr-resample_exact_lin_async-dblp-48000-44100: CMP_TARGET = 1923.79
+fate-swr-resample_exact_lin_async-dblp-48000-44100: SIZE_TOLERANCE = 576000 - 20298
+
+fate-swr-resample_exact_lin_async-dblp-48000-8000: CMP_TARGET = 2591.72
+fate-swr-resample_exact_lin_async-dblp-48000-8000: SIZE_TOLERANCE = 576000 - 20304
+
+fate-swr-resample_exact_lin_async-dblp-8000-44100: CMP_TARGET = 11187.24
+fate-swr-resample_exact_lin_async-dblp-8000-44100: SIZE_TOLERANCE = 96000 - 20344
+
+fate-swr-resample_exact_lin_async-dblp-8000-48000: CMP_TARGET = 11326.80
+fate-swr-resample_exact_lin_async-dblp-8000-48000: SIZE_TOLERANCE = 96000 - 20344
+
+fate-swr-resample_exact_lin_async-fltp-44100-48000: CMP_TARGET = 7791.72
+fate-swr-resample_exact_lin_async-fltp-44100-48000: SIZE_TOLERANCE = 529200 - 20300
+
+fate-swr-resample_exact_lin_async-fltp-44100-8000: CMP_TARGET = 4023.01
+fate-swr-resample_exact_lin_async-fltp-44100-8000: SIZE_TOLERANCE = 529200 - 20310
+
+fate-swr-resample_exact_lin_async-fltp-48000-44100: CMP_TARGET = 1923.79
+fate-swr-resample_exact_lin_async-fltp-48000-44100: SIZE_TOLERANCE = 576000 - 20298
+
+fate-swr-resample_exact_lin_async-fltp-48000-8000: CMP_TARGET = 2591.72
+fate-swr-resample_exact_lin_async-fltp-48000-8000: SIZE_TOLERANCE = 576000 - 20304
+
+fate-swr-resample_exact_lin_async-fltp-8000-44100: CMP_TARGET = 11187.25
+fate-swr-resample_exact_lin_async-fltp-8000-44100: SIZE_TOLERANCE = 96000 - 20344
+
+fate-swr-resample_exact_lin_async-fltp-8000-48000: CMP_TARGET = 11326.80
+fate-swr-resample_exact_lin_async-fltp-8000-48000: SIZE_TOLERANCE = 96000 - 20344
+
+fate-swr-resample_exact_lin_async-s16p-44100-48000: CMP_TARGET = 7791.72
+fate-swr-resample_exact_lin_async-s16p-44100-48000: SIZE_TOLERANCE = 529200 - 20300
+
+fate-swr-resample_exact_lin_async-s16p-44100-8000: CMP_TARGET = 4023.19
+fate-swr-resample_exact_lin_async-s16p-44100-8000: SIZE_TOLERANCE = 529200 - 20310
+
+fate-swr-resample_exact_lin_async-s16p-48000-44100: CMP_TARGET = 1923.79
+fate-swr-resample_exact_lin_async-s16p-48000-44100: SIZE_TOLERANCE = 576000 - 20298
+
+fate-swr-resample_exact_lin_async-s16p-48000-8000: CMP_TARGET = 2591.85
+fate-swr-resample_exact_lin_async-s16p-48000-8000: SIZE_TOLERANCE = 576000 - 20304
+
+fate-swr-resample_exact_lin_async-s16p-8000-44100: CMP_TARGET = 11187.57
+fate-swr-resample_exact_lin_async-s16p-8000-44100: SIZE_TOLERANCE = 96000 - 20344
+
+fate-swr-resample_exact_lin_async-s16p-8000-48000: CMP_TARGET = 11327.48
+fate-swr-resample_exact_lin_async-s16p-8000-48000: SIZE_TOLERANCE = 96000 - 20344
+
+fate-swr-resample_exact_lin_async-s32p-44100-48000: CMP_TARGET = 7791.72
+fate-swr-resample_exact_lin_async-s32p-44100-48000: SIZE_TOLERANCE = 529200 - 20300
+
+fate-swr-resample_exact_lin_async-s32p-44100-8000: CMP_TARGET = 4023.02
+fate-swr-resample_exact_lin_async-s32p-44100-8000: SIZE_TOLERANCE = 529200 - 20310
+
+fate-swr-resample_exact_lin_async-s32p-48000-44100: CMP_TARGET = 1923.77
+fate-swr-resample_exact_lin_async-s32p-48000-44100: SIZE_TOLERANCE = 576000 - 20298
+
+fate-swr-resample_exact_lin_async-s32p-48000-8000: CMP_TARGET = 2591.71
+fate-swr-resample_exact_lin_async-s32p-48000-8000: SIZE_TOLERANCE = 576000 - 20304
+
+fate-swr-resample_exact_lin_async-s32p-8000-44100: CMP_TARGET = 11187.25
+fate-swr-resample_exact_lin_async-s32p-8000-44100: SIZE_TOLERANCE = 96000 - 20344
+
+fate-swr-resample_exact_lin_async-s32p-8000-48000: CMP_TARGET = 11326.81
+fate-swr-resample_exact_lin_async-s32p-8000-48000: SIZE_TOLERANCE = 96000 - 20344
+
 $(call CROSS_TEST,$(SAMPLERATES),ARESAMPLE,s16p,s16le,s16)
 $(call CROSS_TEST,$(SAMPLERATES),ARESAMPLE,s32p,s32le,s16)
 $(call CROSS_TEST,$(SAMPLERATES),ARESAMPLE,fltp,f32le,s16)
@@ -737,6 +1072,16 @@ $(call CROSS_TEST,$(SAMPLERATES_LITE),ARESAMPLE_EXACT_ASYNC,s32p,s32le,s16)
 $(call CROSS_TEST,$(SAMPLERATES_LITE),ARESAMPLE_EXACT_ASYNC,fltp,f32le,s16)
 $(call CROSS_TEST,$(SAMPLERATES_LITE),ARESAMPLE_EXACT_ASYNC,dblp,f64le,s16)
 
+$(call CROSS_TEST,$(SAMPLERATES),ARESAMPLE_EXACT_LIN,s16p,s16le,s16)
+$(call CROSS_TEST,$(SAMPLERATES),ARESAMPLE_EXACT_LIN,s32p,s32le,s16)
+$(call CROSS_TEST,$(SAMPLERATES),ARESAMPLE_EXACT_LIN,fltp,f32le,s16)
+$(call CROSS_TEST,$(SAMPLERATES),ARESAMPLE_EXACT_LIN,dblp,f64le,s16)
+
+$(call CROSS_TEST,$(SAMPLERATES_LITE),ARESAMPLE_EXACT_LIN_ASYNC,s16p,s16le,s16)
+$(call CROSS_TEST,$(SAMPLERATES_LITE),ARESAMPLE_EXACT_LIN_ASYNC,s32p,s32le,s16)
+$(call CROSS_TEST,$(SAMPLERATES_LITE),ARESAMPLE_EXACT_LIN_ASYNC,fltp,f32le,s16)
+$(call CROSS_TEST,$(SAMPLERATES_LITE),ARESAMPLE_EXACT_LIN_ASYNC,dblp,f64le,s16)
+
 FATE_SWR_RESAMPLE-$(call FILTERDEMDECENCMUX, ARESAMPLE, WAV, PCM_S16LE, PCM_S16LE, WAV) += $(FATE_SWR_RESAMPLE)
 fate-swr-resample: $(FATE_SWR_RESAMPLE-yes)
 FATE_SWR += $(FATE_SWR_RESAMPLE-yes)
@@ -744,7 +1089,7 @@ FATE_SWR += $(FATE_SWR_RESAMPLE-yes)
 FATE_SWR_AUDIOCONVERT-$(call FILTERDEMDECENCMUX, AFORMAT AEVAL, WAV, PCM_S16LE, PCM_S16LE, WAV) += fate-swr-audioconvert
 fate-swr-audioconvert: tests/data/asynth-44100-1.wav
 fate-swr-audioconvert: REF = tests/data/asynth-44100-1.wav
-fate-swr-audioconvert: CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-44100-1.wav -af "aformat=fltp,aeval=val(0)+(random(0)-0.5)/33000,aformat=fltp" -f wav -acodec pcm_s16le -
+fate-swr-audioconvert: CMD = ffmpeg -i $(TARGET_PATH)/tests/data/asynth-44100-1.wav -af "aformat=fltp,aeval=val(0)+(random(0)-0.5)/33000,aformat=fltp" -f wav -c:a pcm_s16le -
 fate-swr-audioconvert: CMP = stddev
 fate-swr-audioconvert: FUZZ = 0
 
diff --git a/mythtv/external/FFmpeg/tests/fate/libswscale.mak b/mythtv/external/FFmpeg/tests/fate/libswscale.mak
new file mode 100644
index 00000000000..e72fe590a81
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/fate/libswscale.mak
@@ -0,0 +1,7 @@
+FATE_LIBSWSCALE += fate-sws-pixdesc-query
+fate-sws-pixdesc-query: libswscale/tests/pixdesc_query$(EXESUF)
+fate-sws-pixdesc-query: CMD = run libswscale/tests/pixdesc_query
+
+FATE_LIBSWSCALE += $(FATE_LIBSWSCALE-yes)
+FATE-$(CONFIG_SWSCALE) += $(FATE_LIBSWSCALE)
+fate-libswscale: $(FATE_LIBSWSCALE)
diff --git a/mythtv/external/FFmpeg/tests/fate/matroska.mak b/mythtv/external/FFmpeg/tests/fate/matroska.mak
index 35ed41f3541..2747496e1ea 100644
--- a/mythtv/external/FFmpeg/tests/fate/matroska.mak
+++ b/mythtv/external/FFmpeg/tests/fate/matroska.mak
@@ -2,8 +2,12 @@
 # properties in remuxing (-c:v copy)
 # It also tests automatic insertion of the vp9_superframe bitstream filter
 FATE_MATROSKA-$(call DEMMUX, MATROSKA, MATROSKA) += fate-matroska-remux
-fate-matroska-remux: CMD = md5 -i $(TARGET_SAMPLES)/vp9-test-vectors/vp90-2-2pass-akiyo.webm -color_trc 4 -c:v copy -fflags +bitexact -strict -2 -f matroska
+fate-matroska-remux: CMD = md5pipe -i $(TARGET_SAMPLES)/vp9-test-vectors/vp90-2-2pass-akiyo.webm -color_trc 4 -c:v copy -fflags +bitexact -strict -2 -f matroska
 fate-matroska-remux: CMP = oneline
-fate-matroska-remux: REF = 9b8398b42804ba12c39d2f47299a0996
+fate-matroska-remux: REF = 1ed49a4f2b6790357fac268938357353
+
+FATE_MATROSKA_FFPROBE-$(call ALLYES, MATROSKA_DEMUXER) += fate-matroska-spherical-mono
+fate-matroska-spherical-mono: CMD = run ffprobe$(PROGSSUF)$(EXESUF) -show_entries stream_side_data_list -select_streams v -v 0 $(TARGET_SAMPLES)/mkv/spherical.mkv
 
 FATE_SAMPLES_AVCONV += $(FATE_MATROSKA-yes)
+FATE_SAMPLES_FFPROBE += $(FATE_MATROSKA_FFPROBE-yes)
diff --git a/mythtv/external/FFmpeg/tests/fate/microsoft.mak b/mythtv/external/FFmpeg/tests/fate/microsoft.mak
index 2354f4d31c7..c450c0d8ea9 100644
--- a/mythtv/external/FFmpeg/tests/fate/microsoft.mak
+++ b/mythtv/external/FFmpeg/tests/fate/microsoft.mak
@@ -40,15 +40,15 @@ fate-msvideo1: $(FATE_MSVIDEO1)
 FATE_SAMPLES_AVCONV-$(call DEMDEC, ASF, MTS2) += fate-mts2
 fate-mts2: CMD = framecrc -i $(TARGET_SAMPLES)/mts2/ScreenCapture.xesc
 
-FATE_WMV8_DRM += fate-wmv8-drm
+FATE_WMV3_DRM += fate-wmv3-drm-dec
 # discard last packet to avoid fails due to overread of VC-1 decoder
-fate-wmv8-drm: CMD = framecrc -cryptokey 137381538c84c068111902a59c5cf6c340247c39 -i $(TARGET_SAMPLES)/wmv8/wmv_drm.wmv -an -frames:v 129
+fate-wmv3-drm-dec: CMD = framecrc -cryptokey 137381538c84c068111902a59c5cf6c340247c39 -i $(TARGET_SAMPLES)/wmv8/wmv_drm.wmv -an -frames:v 129
 
-FATE_WMV8_DRM += fate-wmv8-drm-nodec
-fate-wmv8-drm-nodec: CMD = framecrc -cryptokey 137381538c84c068111902a59c5cf6c340247c39 -i $(TARGET_SAMPLES)/wmv8/wmv_drm.wmv -acodec copy -vcodec copy
+FATE_WMV3_DRM += fate-wmv3-drm-nodec
+fate-wmv3-drm-nodec: CMD = framecrc -cryptokey 137381538c84c068111902a59c5cf6c340247c39 -i $(TARGET_SAMPLES)/wmv8/wmv_drm.wmv -c:a copy -c:v copy
 
-FATE_MICROSOFT-$(call DEMDEC, ASF, WMV3) += $(FATE_WMV8_DRM)
-fate-wmv8_drm: $(FATE_WMV8_DRM)
+FATE_SAMPLES_AVCONV-$(call DEMDEC, ASF, WMV3) += $(FATE_WMV3_DRM)
+fate-wmv3-drm: $(FATE_WMV3_DRM)
 
 FATE_MICROSOFT-$(call DEMDEC, ASF, WMV2) += fate-wmv8-x8intra
 fate-wmv8-x8intra: CMD = framecrc -flags +bitexact -i $(TARGET_SAMPLES)/wmv8/wmv8_x8intra.wmv -an
diff --git a/mythtv/external/FFmpeg/tests/fate/mov.mak b/mythtv/external/FFmpeg/tests/fate/mov.mak
index 4b5885b4627..cfdada7a2e0 100644
--- a/mythtv/external/FFmpeg/tests/fate/mov.mak
+++ b/mythtv/external/FFmpeg/tests/fate/mov.mak
@@ -4,11 +4,20 @@ FATE_MOV = fate-mov-3elist \
            fate-mov-1elist-noctts \
            fate-mov-elist-starts-ctts-2ndsample \
            fate-mov-1elist-ends-last-bframe \
-           fate-mov-2elist-elist1-ends-bframe
+           fate-mov-2elist-elist1-ends-bframe \
+           fate-mov-3elist-encrypted \
+           fate-mov-gpmf-remux \
+
+FATE_MOV_FFPROBE = fate-mov-aac-2048-priming \
+                   fate-mov-zombie \
+                   fate-mov-init-nonkeyframe \
+                   fate-mov-displaymatrix \
+                   fate-mov-spherical-mono \
 
 FATE_SAMPLES_AVCONV += $(FATE_MOV)
+FATE_SAMPLES_FFPROBE += $(FATE_MOV_FFPROBE)
 
-fate-mov: $(FATE_MOV)
+fate-mov: $(FATE_MOV) $(FATE_MOV_FFPROBE)
 
 # Make sure we handle edit lists correctly in normal cases.
 fate-mov-1elist-noctts: CMD = framemd5 -i $(TARGET_SAMPLES)/mov/mov-1elist-noctts.mov
@@ -16,6 +25,9 @@ fate-mov-1elist-1ctts: CMD = framemd5 -i $(TARGET_SAMPLES)/mov/mov-1elist-1ctts.
 fate-mov-3elist: CMD = framemd5 -i $(TARGET_SAMPLES)/mov/mov-3elist.mov
 fate-mov-3elist-1ctts: CMD = framemd5 -i $(TARGET_SAMPLES)/mov/mov-3elist-1ctts.mov
 
+# Edit list with encryption
+fate-mov-3elist-encrypted: CMD = framemd5 -decryption_key 12345678901234567890123456789012 -i $(TARGET_SAMPLES)/mov/mov-3elist-encrypted.mov
+
 # Makes sure that the CTTS is also modified when we fix avindex in mov.c while parsing edit lists.
 fate-mov-elist-starts-ctts-2ndsample: CMD = framemd5 -i $(TARGET_SAMPLES)/mov/mov-elist-starts-ctts-2ndsample.mov
 
@@ -26,3 +38,17 @@ fate-mov-1elist-ends-last-bframe: CMD = framemd5 -i $(TARGET_SAMPLES)/mov/mov-1e
 
 # Makes sure that we handle timestamps of packets in case of multiple edit lists with one of them ending on a B-frame correctly.
 fate-mov-2elist-elist1-ends-bframe: CMD = framemd5 -i $(TARGET_SAMPLES)/mov/mov-2elist-elist1-ends-bframe.mov
+
+fate-mov-aac-2048-priming: CMD = run ffprobe$(PROGSSUF)$(EXESUF) -show_packets -print_format compact $(TARGET_SAMPLES)/mov/aac-2048-priming.mov
+
+fate-mov-zombie: CMD = run ffprobe$(PROGSSUF)$(EXESUF) -show_streams -show_packets -show_frames -bitexact -print_format compact $(TARGET_SAMPLES)/mov/white_zombie_scrunch-part.mov
+
+fate-mov-init-nonkeyframe: CMD = run ffprobe$(PROGSSUF)$(EXESUF) -show_packets -print_format compact -select_streams v $(TARGET_SAMPLES)/mov/mp4-init-nonkeyframe.mp4
+
+fate-mov-displaymatrix: CMD = run ffprobe$(PROGSSUF)$(EXESUF) -show_entries stream=display_aspect_ratio,sample_aspect_ratio:stream_side_data_list -select_streams v -v 0 $(TARGET_SAMPLES)/mov/displaymatrix.mov
+
+fate-mov-spherical-mono: CMD = run ffprobe$(PROGSSUF)$(EXESUF) -show_entries stream_side_data_list -select_streams v -v 0 $(TARGET_SAMPLES)/mov/spherical.mov
+
+fate-mov-gpmf-remux: CMD = md5 -i $(TARGET_SAMPLES)/mov/fake-gp-media-with-real-gpmf.mp4 -map 0 -c copy -fflags +bitexact -f mp4
+fate-mov-gpmf-remux: CMP = oneline
+fate-mov-gpmf-remux: REF = 8f48e435ee1f6b7e173ea756141eabf3
diff --git a/mythtv/external/FFmpeg/tests/fate/mp3.mak b/mythtv/external/FFmpeg/tests/fate/mp3.mak
index a9164f846f6..b8fde55a8f7 100644
--- a/mythtv/external/FFmpeg/tests/fate/mp3.mak
+++ b/mythtv/external/FFmpeg/tests/fate/mp3.mak
@@ -1,29 +1,29 @@
 FATE_MP3 += fate-mp3-float-conf-compl
-fate-mp3-float-conf-compl: CMD = ffmpeg -acodec mp3float -i $(TARGET_SAMPLES)/mp3-conformance/compl.bit -f f32le -
+fate-mp3-float-conf-compl: CMD = ffmpeg -c:a mp3float -i $(TARGET_SAMPLES)/mp3-conformance/compl.bit -f f32le -
 fate-mp3-float-conf-compl: REF = $(SAMPLES)/mp3-conformance/compl.f32
 
 FATE_MP3 += fate-mp3-float-conf-he_32khz
-fate-mp3-float-conf-he_32khz: CMD = ffmpeg -acodec mp3float -i $(TARGET_SAMPLES)/mp3-conformance/he_32khz.bit -af atrim=end_sample=171648 -f f32le -
+fate-mp3-float-conf-he_32khz: CMD = ffmpeg -c:a mp3float -i $(TARGET_SAMPLES)/mp3-conformance/he_32khz.bit -af atrim=end_sample=171648 -f f32le -
 fate-mp3-float-conf-he_32khz: REF = $(SAMPLES)/mp3-conformance/he_32khz.f32
 
 FATE_MP3 += fate-mp3-float-conf-he_44khz
-fate-mp3-float-conf-he_44khz: CMD = ffmpeg -acodec mp3float -i $(TARGET_SAMPLES)/mp3-conformance/he_44khz.bit -af atrim=end_sample=471168 -f f32le -
+fate-mp3-float-conf-he_44khz: CMD = ffmpeg -c:a mp3float -i $(TARGET_SAMPLES)/mp3-conformance/he_44khz.bit -af atrim=end_sample=471168 -f f32le -
 fate-mp3-float-conf-he_44khz: REF = $(SAMPLES)/mp3-conformance/he_44khz.f32
 
 FATE_MP3 += fate-mp3-float-conf-he_48khz
-fate-mp3-float-conf-he_48khz: CMD = ffmpeg -acodec mp3float -i $(TARGET_SAMPLES)/mp3-conformance/he_48khz.bit -af atrim=end_sample=171648 -f f32le -
+fate-mp3-float-conf-he_48khz: CMD = ffmpeg -c:a mp3float -i $(TARGET_SAMPLES)/mp3-conformance/he_48khz.bit -af atrim=end_sample=171648 -f f32le -
 fate-mp3-float-conf-he_48khz: REF = $(SAMPLES)/mp3-conformance/he_48khz.f32
 
 FATE_MP3 += fate-mp3-float-conf-hecommon
-fate-mp3-float-conf-hecommon: CMD = ffmpeg -acodec mp3float -i $(TARGET_SAMPLES)/mp3-conformance/hecommon.bit -af atrim=end_sample=33408 -f f32le -
+fate-mp3-float-conf-hecommon: CMD = ffmpeg -c:a mp3float -i $(TARGET_SAMPLES)/mp3-conformance/hecommon.bit -af atrim=end_sample=33408 -f f32le -
 fate-mp3-float-conf-hecommon: REF = $(SAMPLES)/mp3-conformance/hecommon.f32
 
 FATE_MP3 += fate-mp3-float-conf-si
-fate-mp3-float-conf-si: CMD = ffmpeg -acodec mp3float -i $(TARGET_SAMPLES)/mp3-conformance/si.bit -af atrim=end_sample=134784 -f f32le -
+fate-mp3-float-conf-si: CMD = ffmpeg -c:a mp3float -i $(TARGET_SAMPLES)/mp3-conformance/si.bit -af atrim=end_sample=134784 -f f32le -
 fate-mp3-float-conf-si: REF = $(SAMPLES)/mp3-conformance/si.f32
 
 FATE_MP3 += fate-mp3-float-conf-si_block
-fate-mp3-float-conf-si_block: CMD = ffmpeg -acodec mp3float -i $(TARGET_SAMPLES)/mp3-conformance/si_block.bit -af atrim=end_sample=72576 -f f32le -
+fate-mp3-float-conf-si_block: CMD = ffmpeg -c:a mp3float -i $(TARGET_SAMPLES)/mp3-conformance/si_block.bit -af atrim=end_sample=72576 -f f32le -
 fate-mp3-float-conf-si_block: REF = $(SAMPLES)/mp3-conformance/si_block.f32
 
 FATE_MP3 += fate-mp3-float-extra_overread
diff --git a/mythtv/external/FFmpeg/tests/fate/mpc.mak b/mythtv/external/FFmpeg/tests/fate/mpc.mak
index 4a012737d20..294dffeabf9 100644
--- a/mythtv/external/FFmpeg/tests/fate/mpc.mak
+++ b/mythtv/external/FFmpeg/tests/fate/mpc.mak
@@ -1,8 +1,8 @@
 FATE_MPC-$(CONFIG_MPC_DEMUXER) += fate-mpc7-demux
-fate-mpc7-demux: CMD = crc -i $(TARGET_SAMPLES)/musepack/inside-mp7.mpc -acodec copy
+fate-mpc7-demux: CMD = crc -i $(TARGET_SAMPLES)/musepack/inside-mp7.mpc -c:a copy
 
 FATE_MPC-$(CONFIG_MPC8_DEMUXER) += fate-mpc8-demux
-fate-mpc8-demux: CMD = crc -i $(TARGET_SAMPLES)/musepack/inside-mp8.mpc -acodec copy
+fate-mpc8-demux: CMD = crc -i $(TARGET_SAMPLES)/musepack/inside-mp8.mpc -c:a copy
 
 FATE_MPC-$(call DEMDEC, MPC, MPC7) += fate-musepack7
 fate-musepack7: CMD = pcm -i $(TARGET_SAMPLES)/musepack/inside-mp7.mpc
diff --git a/mythtv/external/FFmpeg/tests/fate/mpegts.mak b/mythtv/external/FFmpeg/tests/fate/mpegts.mak
new file mode 100644
index 00000000000..bb0d9d98a77
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/fate/mpegts.mak
@@ -0,0 +1,14 @@
+#
+# Test probing MPEGTS format and codecs
+#
+PROBE_CODEC_NAME_COMMAND = \
+    ffprobe$(PROGSSUF)$(EXESUF) -show_entries stream=codec_name \
+    -print_format default -bitexact -v 0
+
+FATE_MPEGTS_PROBE-$(call DEMDEC, MPEGTS, HEVC, AAC_LATM) += fate-mpegts-probe-latm
+fate-mpegts-probe-latm: SRC = $(TARGET_SAMPLES)/mpegts/loewe.ts
+fate-mpegts-probe-latm: CMD = run $(PROBE_CODEC_NAME_COMMAND) -i "$(SRC)"
+
+FATE_SAMPLES_FFPROBE += $(FATE_MPEGTS_PROBE-yes)
+
+fate-mpegts: $(FATE_MPEGTS_PROBE-yes)
diff --git a/mythtv/external/FFmpeg/tests/fate/mxf.mak b/mythtv/external/FFmpeg/tests/fate/mxf.mak
index 201cb930b42..7714b615694 100644
--- a/mythtv/external/FFmpeg/tests/fate/mxf.mak
+++ b/mythtv/external/FFmpeg/tests/fate/mxf.mak
@@ -1,12 +1,12 @@
 
 FATE_MXF += fate-mxf-missing-index-demux
-fate-mxf-missing-index-demux: CMD = crc -i $(TARGET_SAMPLES)/mxf/opatom_missing_index.mxf -acodec copy
+fate-mxf-missing-index-demux: CMD = crc -i $(TARGET_SAMPLES)/mxf/opatom_missing_index.mxf -c:a copy
 
 FATE_MXF += fate-mxf-essencegroup-demux
-fate-mxf-essencegroup-demux: CMD = framecrc -i $(TARGET_SAMPLES)/mxf/opatom_essencegroup_alpha_raw.mxf -vcodec copy
+fate-mxf-essencegroup-demux: CMD = framecrc -i $(TARGET_SAMPLES)/mxf/opatom_essencegroup_alpha_raw.mxf -c:v copy
 
 FATE_MXF += fate-mxf-multiple-components-demux
-fate-mxf-multiple-components-demux: CMD = framecrc -i $(TARGET_SAMPLES)/mxf/multiple_components.mxf -vcodec copy
+fate-mxf-multiple-components-demux: CMD = framecrc -i $(TARGET_SAMPLES)/mxf/multiple_components.mxf -c:v copy
 
 FATE_MXF += fate-mxf-metadata-source-ref1
 fate-mxf-metadata-source-ref1: CMD = fmtstdout ffmetadata -i $(TARGET_SAMPLES)/mxf/track_01_v02.mxf -fflags +bitexact -flags +bitexact -map 0:0 -map 0:2 -map 0:3  -map_metadata:g -1
diff --git a/mythtv/external/FFmpeg/tests/fate/pcm.mak b/mythtv/external/FFmpeg/tests/fate/pcm.mak
index e6502aae691..053f310b26a 100644
--- a/mythtv/external/FFmpeg/tests/fate/pcm.mak
+++ b/mythtv/external/FFmpeg/tests/fate/pcm.mak
@@ -25,7 +25,7 @@ fate-w64: CMD = crc -i $(TARGET_SAMPLES)/w64/w64-pcm16.w64
 FATE_PCM-$(call ENCMUX, PCM_S24DAUD, DAUD) += fate-dcinema-encode
 fate-dcinema-encode: tests/data/asynth-96000-6.wav
 fate-dcinema-encode: SRC = tests/data/asynth-96000-6.wav
-fate-dcinema-encode: CMD = enc_dec_pcm daud framemd5 s16le $(SRC) -c:a pcm_s24daud -aframes 20
+fate-dcinema-encode: CMD = enc_dec_pcm daud framemd5 s16le $(SRC) -c:a pcm_s24daud -frames:a 20
 
 FATE_FFMPEG += $(FATE_PCM-yes)
 FATE_SAMPLES_AVCONV += $(FATE_SAMPLES_PCM-yes)
diff --git a/mythtv/external/FFmpeg/tests/fate/pixlet.mak b/mythtv/external/FFmpeg/tests/fate/pixlet.mak
new file mode 100644
index 00000000000..c720f326169
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/fate/pixlet.mak
@@ -0,0 +1,5 @@
+FATE_PIXLET += fate-pixlet-rgb
+fate-pixlet-rgb: CMD = framecrc -i $(TARGET_SAMPLES)/pixlet/pixlet_rgb.mov -an -pix_fmt yuv420p16le
+
+FATE_SAMPLES_AVCONV-$(call DEMDEC, MOV, PIXLET) += $(FATE_PIXLET)
+fate-pixlet: $(FATE_PIXLET)
diff --git a/mythtv/external/FFmpeg/tests/fate/prores.mak b/mythtv/external/FFmpeg/tests/fate/prores.mak
index fe1e7724d53..f7f52ca7fce 100644
--- a/mythtv/external/FFmpeg/tests/fate/prores.mak
+++ b/mythtv/external/FFmpeg/tests/fate/prores.mak
@@ -19,4 +19,4 @@ fate-prores-alpha:     CMD = framecrc -flags +bitexact -i $(TARGET_SAMPLES)/pror
 fate-prores-alpha_skip: CMD = framecrc -flags +bitexact -skip_alpha 1 -i $(TARGET_SAMPLES)/prores/Sequence_1-Apple_ProRes_with_Alpha.mov -pix_fmt yuv444p10le
 fate-prores-transparency: CMD = framecrc -flags +bitexact -i $(TARGET_SAMPLES)/prores/prores4444_with_transparency.mov -pix_fmt yuva444p10le
 fate-prores-transparency_skip: CMD = framecrc -flags +bitexact -skip_alpha 1 -i $(TARGET_SAMPLES)/prores/prores4444_with_transparency.mov -pix_fmt yuv444p10le
-fate-prores-gray:      CMD = framecrc -flags +bitexact -acodec aac_fixed -i $(TARGET_SAMPLES)/prores/gray.mov -pix_fmt yuv422p10le
+fate-prores-gray:      CMD = framecrc -flags +bitexact -c:a aac_fixed -i $(TARGET_SAMPLES)/prores/gray.mov -pix_fmt yuv422p10le
diff --git a/mythtv/external/FFmpeg/tests/fate/qt.mak b/mythtv/external/FFmpeg/tests/fate/qt.mak
index 335ec44dc2d..c054129f082 100644
--- a/mythtv/external/FFmpeg/tests/fate/qt.mak
+++ b/mythtv/external/FFmpeg/tests/fate/qt.mak
@@ -49,10 +49,19 @@ fate-svq1: CMD = framecrc -i $(TARGET_SAMPLES)/svq1/marymary-shackles.mov -an -t
 FATE_QT-$(call DEMDEC, MOV, SVQ1) += fate-svq1-headerswap
 fate-svq1-headerswap: CMD = framecrc -i $(TARGET_SAMPLES)/svq1/ct_ending_cut.mov -frames 4
 
-FATE_QT-$(call ALLYES, MOV_DEMUXER SVQ3_DECODER ZLIB) += fate-svq3 fate-svq3-watermark
-fate-svq3: CMD = framecrc -i $(TARGET_SAMPLES)/svq3/Vertical400kbit.sorenson3.mov -t 6 -an
+FATE_SVQ3 += fate-svq3-1
+fate-svq3-1: CMD = framecrc -i $(TARGET_SAMPLES)/svq3/Vertical400kbit.sorenson3.mov -t 6 -an
+
+#FATE_SVQ3 += fate-svq3-2
+#FIXME: first frame changes depending on --enable-memory-poisoning being used to configure or not
+fate-svq3-2: CMD = framecrc -flags +bitexact -ignore_editlist 1 -i $(TARGET_SAMPLES)/svq3/svq3_decoding_regression.mov -an
+
+FATE_SVQ3 += fate-svq3-watermark
 fate-svq3-watermark: CMD = framecrc -flags +bitexact -i $(TARGET_SAMPLES)/svq3/svq3_watermark.mov
 
+FATE_QT-$(call ALLYES, MOV_DEMUXER SVQ3_DECODER ZLIB) += $(FATE_SVQ3)
+fate-svq3: $(FATE_SVQ3)
+
 FATE_QT += $(FATE_QT-yes)
 
 FATE_SAMPLES_FFMPEG += $(FATE_QT)
diff --git a/mythtv/external/FFmpeg/tests/fate/real.mak b/mythtv/external/FFmpeg/tests/fate/real.mak
index f9073dde8f1..dd5f9c61db7 100644
--- a/mythtv/external/FFmpeg/tests/fate/real.mak
+++ b/mythtv/external/FFmpeg/tests/fate/real.mak
@@ -42,7 +42,7 @@ fate-sipr-8k5: CMD = pcm -i $(TARGET_SAMPLES)/sipr/sipr_8k5.rm
 fate-sipr-8k5: REF = $(SAMPLES)/sipr/sipr_8k5.pcm
 
 FATE_SIPR += fate-sipr-16k
-fate-sipr-16k: CMD = pcm -i $(TARGET_SAMPLES)/sipr/sipr_16k.rm -aframes 3250
+fate-sipr-16k: CMD = pcm -i $(TARGET_SAMPLES)/sipr/sipr_16k.rm -frames:a 3250
 fate-sipr-16k: REF = $(SAMPLES)/sipr/sipr_16k.pcm
 fate-sipr-16k: SIZE_TOLERANCE = 40000
 
diff --git a/mythtv/external/FFmpeg/tests/fate/screen.mak b/mythtv/external/FFmpeg/tests/fate/screen.mak
index eb70ea2cbaf..66dfa6ba7fa 100644
--- a/mythtv/external/FFmpeg/tests/fate/screen.mak
+++ b/mythtv/external/FFmpeg/tests/fate/screen.mak
@@ -44,6 +44,9 @@ fate-g2m: $(FATE_G2M)
 FATE_RSCC += fate-iscc
 fate-iscc: CMD = framecrc -i $(TARGET_SAMPLES)/rscc/pip.avi -an
 
+FATE_RSCC += fate-rscc-8bit
+fate-rscc-8bit: CMD = framecrc -i $(TARGET_SAMPLES)/rscc/8bpp.avi -an -pix_fmt rgb24
+
 FATE_RSCC += fate-rscc-16bit
 fate-rscc-16bit: CMD = framecrc -i $(TARGET_SAMPLES)/rscc/16bpp_555.avi -an
 
diff --git a/mythtv/external/FFmpeg/tests/fate/seek.mak b/mythtv/external/FFmpeg/tests/fate/seek.mak
index f835da5226e..c863b2aaa45 100644
--- a/mythtv/external/FFmpeg/tests/fate/seek.mak
+++ b/mythtv/external/FFmpeg/tests/fate/seek.mak
@@ -180,6 +180,8 @@ FATE_SEEK_LAVF-$(call ENCDEC2, MPEG1VIDEO, MP2,       MPEG1SYSTEM MPEGPS) += mpg
 FATE_SEEK_LAVF-$(call ENCDEC,  PCM_MULAW,             PCM_MULAW)   += mulaw
 FATE_SEEK_LAVF-$(call ENCDEC2, MPEG2VIDEO, PCM_S16LE, MXF)         += mxf
 FATE_SEEK_LAVF-$(call ENCDEC2, MPEG2VIDEO, PCM_S16LE, MXF_D10 MXF) += mxf_d10
+FATE_SEEK_LAVF-$(call ENCDEC2, DVVIDEO,    PCM_S16LE, MXF)         += mxf_dv25
+FATE_SEEK_LAVF-$(call ENCDEC2, DVVIDEO,    PCM_S16LE, MXF)         += mxf_dvcpro50
 FATE_SEEK_LAVF-$(call ENCDEC2, DNXHD,      PCM_S16LE, MXF_OPATOM MXF) += mxf_opatom
 FATE_SEEK_LAVF-$(call ENCDEC2, DNXHD,      PCM_S16LE, MXF_OPATOM MXF) += mxf_opatom_audio
 FATE_SEEK_LAVF-$(call ENCDEC2, MPEG4,      MP2,       NUT)         += nut
@@ -220,6 +222,8 @@ fate-seek-lavf-mpg:      SRC = lavf/lavf.mpg
 fate-seek-lavf-mulaw:    SRC = lavf/lavf.ul
 fate-seek-lavf-mxf:      SRC = lavf/lavf.mxf
 fate-seek-lavf-mxf_d10:  SRC = lavf/lavf.mxf_d10
+fate-seek-lavf-mxf_dv25: SRC = lavf/lavf.mxf_dv25
+fate-seek-lavf-mxf_dvcpro50: SRC = lavf/lavf.mxf_dvcpro50
 fate-seek-lavf-mxf_opatom: SRC = lavf/lavf.mxf_opatom
 fate-seek-lavf-mxf_opatom_audio: SRC = lavf/lavf.mxf_opatom_audio
 fate-seek-lavf-nut:      SRC = lavf/lavf.nut
@@ -248,7 +252,10 @@ FATE_SEEK += $(FATE_SEEK_LAVF-yes:%=fate-seek-lavf-%)
 FATE_SEEK_EXTRA-$(CONFIG_MP3_DEMUXER)   += fate-seek-extra-mp3
 FATE_SEEK_EXTRA-$(call ALLYES, CACHE_PROTOCOL PIPE_PROTOCOL MP3_DEMUXER) += fate-seek-cache-pipe
 FATE_SEEK_EXTRA-$(CONFIG_MATROSKA_DEMUXER) += fate-seek-mkv-codec-delay
+FATE_SEEK_EXTRA-$(CONFIG_MOV_DEMUXER) += fate-seek-extra-mp4
+
 fate-seek-extra-mp3:  CMD = run libavformat/tests/seek$(EXESUF) $(TARGET_SAMPLES)/gapless/gapless.mp3 -fastseek 1
+fate-seek-extra-mp4:  CMD = run libavformat/tests/seek$(EXESUF) $(TARGET_SAMPLES)/mov/buck480p30_na.mp4 -duration 180 -frames 4
 fate-seek-cache-pipe: CMD = cat $(TARGET_SAMPLES)/gapless/gapless.mp3 | run libavformat/tests/seek$(EXESUF) cache:pipe:0 -read_ahead_limit -1
 fate-seek-mkv-codec-delay:   CMD = run libavformat/tests/seek$(EXESUF) $(TARGET_SAMPLES)/mkv/codec_delay_opus.mkv
 
diff --git a/mythtv/external/FFmpeg/tests/fate/source-check.sh b/mythtv/external/FFmpeg/tests/fate/source-check.sh
index ac2878d9f7e..5f3fd8960e8 100755
--- a/mythtv/external/FFmpeg/tests/fate/source-check.sh
+++ b/mythtv/external/FFmpeg/tests/fate/source-check.sh
@@ -27,7 +27,21 @@ for f in `git ls-files | grep '\.h$'` ; do
         -e 's/_vaf_/_/' \
     | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ`"
 
-    grep -L "^#define $macro$" $f
+    git grep -L "^#define $macro$" $f
 done
 
+echo "Use of av_clip() where av_clip_uintp2() could be used:"
+git grep -E 'av_clip *\(.*, *0 *, *(3|7|15|31|63|127|255|511|1023|2047|4095|8191|'\
+'16383|32767|65535|131071|262143|524287|1048575|2097151|4194303|8388607|16777215|'\
+'33554431|67108863|134217727|268435455|536870911|1073741823) *\)' | grep -v fate/source
+
+echo "Use of av_clip() where av_clip_intp2() could be used:"
+git grep -E 'av_clip *\(.*, *(-2 *, *1|-4 *, *3|-8 *, *7|-16 *, *15|-32 *, *31|-64'\
+' *, *63|-128 *, *127|-256 *, *255|-512 *, *511|-1024 *, *1023|-2048 *, *2047|-4096'\
+' *, *4095|-8192 *, *8191|-16384 *, *16383|-32768 *, *32767|-65536 *, *65535|-131072'\
+' *, *131071|-262144 *, *262143|-524288 *, *524287|-1048576 *, *1048575|-2097152 *,'\
+' *2097151|-4194304 *, *4194303|-8388608 *, *8388607|-16777216 *, *16777215|-33554432'\
+' *, *33554431|-67108864 *, *67108863|-134217728 *, *134217727|-268435456 *, *'\
+'268435455|-536870912 *, *536870911|-1073741824 *, *1073741823) *\)'| grep -v fate/source
+
 exit 0
diff --git a/mythtv/external/FFmpeg/tests/fate/speedhq.mak b/mythtv/external/FFmpeg/tests/fate/speedhq.mak
new file mode 100644
index 00000000000..32405b710f1
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/fate/speedhq.mak
@@ -0,0 +1,8 @@
+FATE_SPEEDHQ = fate-speedhq-422                                           \
+               fate-speedhq-422-singlefield
+
+fate-speedhq-422:             CMD = framecrc -flags +bitexact -f rawvideo -c:v speedhq -tag:v SHQ2 -video_size 112x64 -i $(TARGET_SAMPLES)/speedhq/progressive.shq2 -pix_fmt yuv422p
+fate-speedhq-422-singlefield: CMD = framecrc -flags +bitexact -f rawvideo -c:v speedhq -tag:v SHQ2 -video_size 112x32 -i $(TARGET_SAMPLES)/speedhq/singlefield.shq2 -pix_fmt yuv422p
+
+FATE_SAMPLES_FFMPEG-$(call DEMDEC, RAWVIDEO, SPEEDHQ) += $(FATE_SPEEDHQ)
+fate-speedhq: $(FATE_SPEEDHQ)
diff --git a/mythtv/external/FFmpeg/tests/fate/subtitles.mak b/mythtv/external/FFmpeg/tests/fate/subtitles.mak
index 8aa0279a321..8c310adeff0 100644
--- a/mythtv/external/FFmpeg/tests/fate/subtitles.mak
+++ b/mythtv/external/FFmpeg/tests/fate/subtitles.mak
@@ -14,7 +14,7 @@ FATE_SUBTITLES_ASS-$(CONFIG_ASS_DEMUXER) += fate-sub-ssa-to-ass-remux
 fate-sub-ssa-to-ass-remux: CMD = fmtstdout ass -i $(TARGET_SAMPLES)/sub/a9-misc.ssa -c copy
 
 FATE_SUBTITLES-$(call ALLYES, ASS_DEMUXER, MATROSKA_MUXER) += fate-binsub-mksenc
-fate-binsub-mksenc: CMD = md5 -i $(TARGET_SAMPLES)/sub/1ededcbd7b.ass -c copy -f matroska -flags +bitexact -fflags +bitexact
+fate-binsub-mksenc: CMD = md5pipe -i $(TARGET_SAMPLES)/sub/1ededcbd7b.ass -c copy -f matroska -flags +bitexact -fflags +bitexact
 
 FATE_SUBTITLES_ASS-$(call DEMDEC, JACOSUB, JACOSUB) += fate-sub-jacosub
 fate-sub-jacosub: CMD = fmtstdout ass -i $(TARGET_SAMPLES)/sub/JACOsub_capability_tester.jss
@@ -55,6 +55,9 @@ fate-sub-sami2: CMD = fmtstdout ass -i $(TARGET_SAMPLES)/sub/SAMI_multilang_twea
 FATE_SUBTITLES_ASS-$(call DEMDEC, SRT, SUBRIP) += fate-sub-srt
 fate-sub-srt: CMD = fmtstdout ass -i $(TARGET_SAMPLES)/sub/SubRip_capability_tester.srt
 
+FATE_SUBTITLES_ASS-$(call DEMDEC, SRT, SUBRIP) += fate-sub-srt-badsyntax
+fate-sub-srt-badsyntax: CMD = fmtstdout ass -i $(TARGET_SAMPLES)/sub/badsyntax.srt
+
 FATE_SUBTITLES-$(call ALLYES, SRT_DEMUXER SUBRIP_DECODER SRT_MUXER) += fate-sub-srt-rrn-remux
 fate-sub-srt-rrn-remux: CMD = fmtstdout srt -i $(TARGET_SAMPLES)/sub/ticket5032-rrn.srt -c:s copy
 
@@ -94,6 +97,9 @@ fate-sub-textenc: CMD = fmtstdout srt -i $(TARGET_SAMPLES)/sub/SubRip_capability
 FATE_SUBTITLES_ASS-$(call ALLYES, MICRODVD_DEMUXER MICRODVD_DECODER ICONV) += fate-sub-charenc
 fate-sub-charenc: CMD = fmtstdout ass -sub_charenc cp1251 -i $(TARGET_SAMPLES)/sub/cp1251-subtitles.sub
 
+FATE_SUBTITLES-$(call DEMDEC, SCC, CCAPTION) += fate-sub-scc
+fate-sub-scc: CMD = fmtstdout ass -ss 57 -i $(TARGET_SAMPLES)/sub/witch.scc
+
 FATE_SUBTITLES-$(call ENCMUX, ASS, ASS) += $(FATE_SUBTITLES_ASS-yes)
 FATE_SUBTITLES += $(FATE_SUBTITLES-yes)
 
diff --git a/mythtv/external/FFmpeg/tests/fate/utvideo.mak b/mythtv/external/FFmpeg/tests/fate/utvideo.mak
index 1acef9ae3ec..2cf06b36f58 100644
--- a/mythtv/external/FFmpeg/tests/fate/utvideo.mak
+++ b/mythtv/external/FFmpeg/tests/fate/utvideo.mak
@@ -28,7 +28,7 @@ fate-utvideo_yuv422_median: CMD = framecrc -i $(TARGET_SAMPLES)/utvideo/utvideo_
 FATE_SAMPLES_AVCONV-$(call DEMDEC, AVI, UTVIDEO) += $(FATE_UTVIDEO)
 fate-utvideo: $(FATE_UTVIDEO)
 
-fate-utvideoenc%: CMD = framemd5 -f image2 -vcodec pgmyuv -i $(TARGET_PATH)/tests/vsynth1/%02d.pgm -vcodec utvideo -slices 1 -sws_flags +accurate_rnd+bitexact ${OPTS}
+fate-utvideoenc%: CMD = framemd5 -f image2 -c:v pgmyuv -i $(TARGET_PATH)/tests/vsynth1/%02d.pgm -c:v utvideo -slices 1 -sws_flags +accurate_rnd+bitexact ${OPTS}
 
 FATE_UTVIDEOENC += fate-utvideoenc_rgba_left
 fate-utvideoenc_rgba_left: OPTS = -pix_fmt rgba -pred left
diff --git a/mythtv/external/FFmpeg/tests/fate/vcodec.mak b/mythtv/external/FFmpeg/tests/fate/vcodec.mak
index a51f16c9c16..c0344550f9d 100644
--- a/mythtv/external/FFmpeg/tests/fate/vcodec.mak
+++ b/mythtv/external/FFmpeg/tests/fate/vcodec.mak
@@ -19,7 +19,7 @@ FATE_VCODEC-$(call ENCDEC, ASV2, AVI)   += asv2
 fate-vsynth%-asv2:               ENCOPTS = -qscale 10
 
 FATE_VCODEC-$(call ENCDEC, CINEPAK, MOV) += cinepak
-fate-vsynth%-cinepak:            ENCOPTS  = -vcodec cinepak -frames 3
+fate-vsynth%-cinepak:            ENCOPTS  = -c:v cinepak -frames 3
 fate-vsynth%-cinepak:            FMT      = mov
 
 FATE_VCODEC-$(call ENCDEC, CLJR, AVI)   += cljr
@@ -41,13 +41,13 @@ FATE_VCODEC-$(call ENCDEC, VC2 DIRAC, MOV) += vc2-420p vc2-420p10 vc2-420p12 \
                                               vc2-444p vc2-444p10 vc2-444p12
 fate-vsynth1-vc2-%:              FMT      = mov
 fate-vsynth1-vc2-%:              ENCOPTS = -pix_fmt yuv$(@:fate-vsynth1-vc2-%=%) \
-                                           -vcodec vc2 -frames 5 -strict -1
+                                           -c:v vc2 -frames 5 -strict -1
 fate-vsynth2-vc2-%:              FMT      = mov
 fate-vsynth2-vc2-%:              ENCOPTS = -pix_fmt yuv$(@:fate-vsynth2-vc2-%=%) \
-                                           -vcodec vc2 -frames 5 -strict -1
+                                           -c:v vc2 -frames 5 -strict -1
 fate-vsynth_lena-vc2-%:          FMT      = mov
 fate-vsynth_lena-vc2-%:          ENCOPTS = -pix_fmt yuv$(@:fate-vsynth_lena-vc2-%=%) \
-                                           -vcodec vc2 -frames 5 -strict -1
+                                           -c:v vc2 -frames 5 -strict -1
 
 fate-vsynth%-dnxhd-720p:         ENCOPTS = -s hd720 -b 90M              \
                                            -pix_fmt yuv422p -frames 5 -qmax 8
@@ -164,10 +164,10 @@ fate-vsynth%-ffv1-v3-rgb48:      ENCOPTS = -level 3 -pix_fmt rgb48 -strict -2 \
 fate-vsynth%-ffv1-v3-rgb48:      DECOPTS = -sws_flags neighbor+bitexact
 
 FATE_VCODEC-$(call ENCDEC, FFVHUFF, AVI) += ffvhuff ffvhuff444 ffvhuff420p12 ffvhuff422p10left ffvhuff444p16
-fate-vsynth%-ffvhuff444:         ENCOPTS = -vcodec ffvhuff -pix_fmt yuv444p
-fate-vsynth%-ffvhuff420p12:      ENCOPTS = -vcodec ffvhuff -pix_fmt yuv420p12le
-fate-vsynth%-ffvhuff422p10left:  ENCOPTS = -vcodec ffvhuff -pix_fmt yuv422p10le -pred left
-fate-vsynth%-ffvhuff444p16:      ENCOPTS = -vcodec ffvhuff -pix_fmt yuv444p16le -pred plane
+fate-vsynth%-ffvhuff444:         ENCOPTS = -c:v ffvhuff -pix_fmt yuv444p
+fate-vsynth%-ffvhuff420p12:      ENCOPTS = -c:v ffvhuff -pix_fmt yuv420p12le
+fate-vsynth%-ffvhuff422p10left:  ENCOPTS = -c:v ffvhuff -pix_fmt yuv422p10le -pred left
+fate-vsynth%-ffvhuff444p16:      ENCOPTS = -c:v ffvhuff -pix_fmt yuv444p16le -pred plane
 
 FATE_VCODEC-$(call ENCDEC, FLASHSV, FLV) += flashsv
 fate-vsynth%-flashsv:            ENCOPTS = -sws_flags neighbor+full_chroma_int
@@ -193,11 +193,11 @@ fate-vsynth%-h263-obmc:          ENCOPTS = -qscale 10 -obmc 1
 fate-vsynth%-h263p:              ENCOPTS = -qscale 2 -flags +aic -umv 1 -aiv 1 -ps 300
 
 FATE_VCODEC-$(call ENCDEC, HUFFYUV, AVI) += huffyuv huffyuvbgr24 huffyuvbgra
-fate-vsynth%-huffyuv:            ENCOPTS = -vcodec huffyuv -pix_fmt yuv422p -sws_flags neighbor
+fate-vsynth%-huffyuv:            ENCOPTS = -c:v huffyuv -pix_fmt yuv422p -sws_flags neighbor
 fate-vsynth%-huffyuv:            DECOPTS = -sws_flags neighbor
-fate-vsynth%-huffyuvbgr24:       ENCOPTS = -vcodec huffyuv -pix_fmt bgr24 -sws_flags neighbor
+fate-vsynth%-huffyuvbgr24:       ENCOPTS = -c:v huffyuv -pix_fmt bgr24 -sws_flags neighbor
 fate-vsynth%-huffyuvbgr24:       DECOPTS = -sws_flags neighbor
-fate-vsynth%-huffyuvbgra:        ENCOPTS = -vcodec huffyuv -pix_fmt bgr32 -sws_flags neighbor
+fate-vsynth%-huffyuvbgra:        ENCOPTS = -c:v huffyuv -pix_fmt bgr32 -sws_flags neighbor
 fate-vsynth%-huffyuvbgra:        DECOPTS = -sws_flags neighbor
 
 FATE_VCODEC-$(call ENCDEC, JPEGLS, AVI) += jpegls
@@ -206,18 +206,20 @@ fate-vsynth%-jpegls:             DECOPTS = -sws_flags area
 
 FATE_VCODEC-$(call ENCDEC, JPEG2000, AVI) += jpeg2000 jpeg2000-97
 fate-vsynth%-jpeg2000:                ENCOPTS = -qscale 7 -strict experimental -pred 1 -pix_fmt rgb24
-fate-vsynth%-jpeg2000:                DECINOPTS = -vcodec jpeg2000
+fate-vsynth%-jpeg2000:                DECINOPTS = -c:v jpeg2000
 fate-vsynth%-jpeg2000-97:             ENCOPTS = -qscale 7 -strict experimental -pix_fmt rgb24
-fate-vsynth%-jpeg2000-97:             DECINOPTS = -vcodec jpeg2000
+fate-vsynth%-jpeg2000-97:             DECINOPTS = -c:v jpeg2000
 
 FATE_VCODEC-$(call ENCDEC, LJPEG MJPEG, AVI) += ljpeg
 fate-vsynth%-ljpeg:              ENCOPTS = -strict -1
 
-FATE_VCODEC-$(call ENCDEC, MJPEG, AVI)  += mjpeg mjpeg-422 mjpeg-444 mjpeg-trell
-fate-vsynth%-mjpeg:              ENCOPTS = -qscale 9 -pix_fmt yuvj420p
-fate-vsynth%-mjpeg-422:          ENCOPTS = -qscale 9 -pix_fmt yuvj422p
-fate-vsynth%-mjpeg-444:          ENCOPTS = -qscale 9 -pix_fmt yuvj444p
-fate-vsynth%-mjpeg-trell:        ENCOPTS = -qscale 9 -pix_fmt yuvj420p -trellis 1
+FATE_VCODEC-$(call ENCDEC, MJPEG, AVI)  += mjpeg mjpeg-422 mjpeg-444 mjpeg-trell mjpeg-huffman mjpeg-trell-huffman
+fate-vsynth%-mjpeg:                   ENCOPTS = -qscale 9 -pix_fmt yuvj420p
+fate-vsynth%-mjpeg-422:               ENCOPTS = -qscale 9 -pix_fmt yuvj422p
+fate-vsynth%-mjpeg-444:               ENCOPTS = -qscale 9 -pix_fmt yuvj444p
+fate-vsynth%-mjpeg-trell:             ENCOPTS = -qscale 9 -pix_fmt yuvj420p -trellis 1
+fate-vsynth%-mjpeg-huffman:           ENCOPTS = -qscale 9 -pix_fmt yuvj420p -huffman optimal
+fate-vsynth%-mjpeg-trell-huffman:     ENCOPTS = -qscale 9 -pix_fmt yuvj420p -trellis 1 -huffman optimal
 
 FATE_VCODEC-$(call ENCDEC, MPEG1VIDEO, MPEG1VIDEO MPEGVIDEO) += mpeg1 mpeg1b
 fate-vsynth%-mpeg1:              FMT     = mpeg1video
@@ -374,11 +376,11 @@ fate-vsynth%-rv20:               FMT     = rm
 
 FATE_VCODEC-$(call ENCDEC, SNOW, AVI)   += snow snow-hpel snow-ll
 fate-vsynth%-snow:               ENCOPTS = -qscale 2 -flags +qpel \
-                                           -me_method iter -dia_size 2       \
+                                           -motion_est iter -dia_size 2      \
                                            -cmp 12 -subcmp 12 -s 128x64
 
 fate-vsynth%-snow-hpel:          ENCOPTS = -qscale 2              \
-                                           -me_method iter -dia_size 2       \
+                                           -motion_est iter -dia_size 2      \
                                            -cmp 12 -subcmp 12 -s 128x64
 
 fate-vsynth%-snow-ll:            ENCOPTS = -qscale .001 -pred 1 \
diff --git a/mythtv/external/FFmpeg/tests/fate/video.mak b/mythtv/external/FFmpeg/tests/fate/video.mak
index f8936885ee3..930eece2cab 100644
--- a/mythtv/external/FFmpeg/tests/fate/video.mak
+++ b/mythtv/external/FFmpeg/tests/fate/video.mak
@@ -14,7 +14,7 @@ FATE_VIDEO-$(call DEMDEC, AVI, AASC) += fate-aasc
 fate-aasc: CMD = framecrc -i $(TARGET_SAMPLES)/aasc/AASC-1.5MB.AVI -pix_fmt rgb24
 
 FATE_VIDEO-$(call DEMDEC, MOV, AIC) += fate-aic
-fate-aic: CMD = framecrc -idct simple -i $(TARGET_SAMPLES)/aic/small_apple_intermediate_codec.mov -an -vframes 15
+fate-aic: CMD = framecrc -idct simple -i $(TARGET_SAMPLES)/aic/small_apple_intermediate_codec.mov -an -frames:v 15
 
 FATE_VIDEO-$(call DEMDEC, MOV, AIC) += fate-aic-oddsize
 fate-aic-oddsize: CMD = framecrc -idct simple -i $(TARGET_SAMPLES)/aic/aic_odd_dimensions.mov
@@ -108,6 +108,9 @@ fate-deluxepaint-anm: CMD = framecrc -i $(TARGET_SAMPLES)/deluxepaint-anm/INTRO1
 FATE_VIDEO-$(call DEMDEC, DIRAC, DIRAC) += fate-dirac
 fate-dirac: CMD = framecrc -i $(TARGET_SAMPLES)/dirac/vts.profile-main.drc
 
+FATE_VIDEO-$(call DEMDEC, DIRAC, DIRAC) += fate-dirac-low-delay
+fate-dirac-low-delay: CMD = framecrc -i $(TARGET_SAMPLES)/dirac/vts.profile-vc2-low-delay.drc
+
 FATE_DXA += fate-dxa-feeble
 fate-dxa-feeble: CMD = framecrc -i $(TARGET_SAMPLES)/dxa/meetsquid.dxa -t 2 -pix_fmt rgb24 -an
 
@@ -154,7 +157,7 @@ FATE_VIDEO-$(call DEMDEC, IDCIN, IDCIN) += fate-id-cin-video
 fate-id-cin-video: CMD = framecrc -i $(TARGET_SAMPLES)/idcin/idlog-2MB.cin -pix_fmt rgb24
 
 FATE_VIDEO-$(call ENCDEC, ROQ PGMYUV, ROQ IMAGE2) += fate-idroq-video-encode
-fate-idroq-video-encode: CMD = md5 -f image2 -vcodec pgmyuv -i $(TARGET_SAMPLES)/ffmpeg-synthetic/vsynth1/%02d.pgm -r 30 -sws_flags +bitexact -vf pad=512:512:80:112 -f roq -t 0.2
+fate-idroq-video-encode: CMD = md5 -f image2 -c:v pgmyuv -i $(TARGET_SAMPLES)/ffmpeg-synthetic/vsynth1/%02d.pgm -r 30 -sws_flags +bitexact -vf pad=512:512:80:112 -f roq -t 0.2
 
 FATE_HAP += fate-hap1
 fate-hap1: CMD = framecrc -i $(TARGET_SAMPLES)/hap/hap1.mov
@@ -190,7 +193,7 @@ FATE_VIDEO-$(call DEMDEC, IPMOVIE, INTERPLAY_VIDEO) += fate-interplay-mve-16bit
 fate-interplay-mve-16bit: CMD = framecrc -i $(TARGET_SAMPLES)/interplay-mve/descent3-level5-16bit-partial.mve -pix_fmt rgb24 -an
 
 FATE_VIDEO-$(call DEMDEC, MXF, JPEG2000) += fate-jpeg2000-dcinema
-fate-jpeg2000-dcinema: CMD = framecrc -flags +bitexact -vcodec jpeg2000 -i $(TARGET_SAMPLES)/jpeg2000/chiens_dcinema2K.mxf -pix_fmt xyz12le
+fate-jpeg2000-dcinema: CMD = framecrc -flags +bitexact -c:v jpeg2000 -i $(TARGET_SAMPLES)/jpeg2000/chiens_dcinema2K.mxf -pix_fmt xyz12le
 
 FATE_VIDEO-$(call DEMDEC, JV, JV) += fate-jv
 fate-jv: CMD = framecrc -i $(TARGET_SAMPLES)/jv/intro.jv -an -pix_fmt rgb24
@@ -233,12 +236,15 @@ FATE_VIDEO-$(call DEMDEC, MOV, MJPEGB) += fate-mjpegb
 fate-mjpegb: CMD = framecrc -idct simple -fflags +bitexact -i $(TARGET_SAMPLES)/mjpegb/mjpegb_part.mov -an
 
 FATE_VIDEO-$(call DEMDEC, MVI, MOTIONPIXELS) += fate-motionpixels
-fate-motionpixels: CMD = framecrc -i $(TARGET_SAMPLES)/motion-pixels/INTRO-partial.MVI -an -pix_fmt rgb24 -vframes 111
+fate-motionpixels: CMD = framecrc -i $(TARGET_SAMPLES)/motion-pixels/INTRO-partial.MVI -an -pix_fmt rgb24 -frames:v 111
 
 FATE_VIDEO-$(call DEMDEC, MPEGTS, MPEG2VIDEO) += fate-mpeg2-field-enc fate-mpeg2-ticket186
-fate-mpeg2-field-enc: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -an -vframes 30
+fate-mpeg2-field-enc: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/mpeg2_field_encoding.ts -an -frames:v 30
 fate-mpeg2-ticket186: CMD = framecrc -flags +bitexact -idct simple -i $(TARGET_SAMPLES)/mpeg2/t.mpg -an
 
+FATE_VIDEO-$(call DEMDEC, MPEGPS, MPEG2VIDEO) += fate-mpeg2-ticket6024
+fate-mpeg2-ticket6024: CMD = framecrc -flags +bitexact -idct simple -flags +truncated -i $(TARGET_SAMPLES)/mpeg2/matrixbench_mpeg2.lq1.mpg -an
+
 FATE_VIDEO-$(call DEMDEC, MV, MVC1) += fate-mv-mvc1
 fate-mv-mvc1: CMD = framecrc -i $(TARGET_SAMPLES)/mv/posture.mv -an -frames 25 -pix_fmt rgb555le
 
@@ -323,7 +329,7 @@ fate-v410dec: CMD = framecrc -i $(TARGET_SAMPLES)/v410/lenav410.mov -pix_fmt yuv
 
 FATE_VIDEO-$(call ENCDEC, V410 PGMYUV, AVI IMAGE2) += fate-v410enc
 fate-v410enc: $(VREF)
-fate-v410enc: CMD = md5 -f image2 -vcodec pgmyuv -i $(TARGET_PATH)/tests/vsynth1/%02d.pgm -fflags +bitexact -vcodec v410 -f avi
+fate-v410enc: CMD = md5 -f image2 -c:v pgmyuv -i $(TARGET_PATH)/tests/vsynth1/%02d.pgm -fflags +bitexact -c:v v410 -f avi
 
 FATE_VIDEO-$(call DEMDEC, SIFF, VB) += fate-vb
 fate-vb: CMD = framecrc -i $(TARGET_SAMPLES)/SIFF/INTRO_B.VB -t 3 -pix_fmt rgb24 -an
diff --git a/mythtv/external/FFmpeg/tests/fate/vpx.mak b/mythtv/external/FFmpeg/tests/fate/vpx.mak
index 46658ec2f15..0be5aa2aaa0 100644
--- a/mythtv/external/FFmpeg/tests/fate/vpx.mak
+++ b/mythtv/external/FFmpeg/tests/fate/vpx.mak
@@ -53,7 +53,7 @@ FATE_VP6-$(call DEMDEC, FLV, VP6F) += fate-vp6f
 fate-vp6f: CMD = framecrc -flags +bitexact -i $(TARGET_SAMPLES)/flash-vp6/clip1024.flv
 
 FATE_VP8-$(CONFIG_MATROSKA_DEMUXER) += fate-vp8-alpha
-fate-vp8-alpha: CMD = framecrc -i $(TARGET_SAMPLES)/vp8_alpha/vp8_video_with_alpha.webm -vcodec copy
+fate-vp8-alpha: CMD = framecrc -i $(TARGET_SAMPLES)/vp8_alpha/vp8_video_with_alpha.webm -c:v copy
 
 FATE_VP8-$(CONFIG_WEBM_DASH_MANIFEST_DEMUXER) += fate-webm-dash-manifest
 fate-webm-dash-manifest: CMD = run $(FFMPEG) -nostdin -f webm_dash_manifest -i $(TARGET_SAMPLES)/vp8/dash_video1.webm -f webm_dash_manifest -i $(TARGET_SAMPLES)/vp8/dash_video2.webm -f webm_dash_manifest -i $(TARGET_SAMPLES)/vp8/dash_audio1.webm -f webm_dash_manifest -i $(TARGET_SAMPLES)/vp8/dash_audio2.webm -c copy -map 0 -map 1 -map 2 -map 3 -f webm_dash_manifest -adaptation_sets "id=0,streams=0,1 id=1,streams=2,3" -
@@ -70,6 +70,9 @@ fate-webm-dash-manifest-representations: CMD = run $(FFMPEG) -nostdin -f webm_da
 FATE_VP8-$(CONFIG_WEBM_DASH_MANIFEST_DEMUXER) += fate-webm-dash-manifest-live
 fate-webm-dash-manifest-live: CMD = run $(FFMPEG) -nostdin -f webm_dash_manifest -live 1 -i $(TARGET_SAMPLES)/vp8/dash_live_video_360.hdr -f webm_dash_manifest -live 1 -i $(TARGET_SAMPLES)/vp8/dash_live_audio_171.hdr -c copy -map 0 -map 1 -f webm_dash_manifest -live 1 -adaptation_sets "id=0,streams=0 id=1,streams=1" -chunk_start_index 1 -chunk_duration_ms 5000 -time_shift_buffer_depth 7200 -minimum_update_period 60 -debug_mode 1 -
 
+FATE_VP8-$(CONFIG_WEBM_DASH_MANIFEST_DEMUXER) += fate-webm-dash-manifest-live-bandwidth
+fate-webm-dash-manifest-live-bandwidth: CMD = run $(FFMPEG) -nostdin -f webm_dash_manifest -live 1 -bandwidth 100 -i $(TARGET_SAMPLES)/vp8/dash_live_video_360.hdr -f webm_dash_manifest -live 1 -bandwidth 200 -i $(TARGET_SAMPLES)/vp8/dash_live_audio_171.hdr -c copy -map 0 -map 1 -f webm_dash_manifest -live 1 -adaptation_sets "id=0,streams=0 id=1,streams=1" -chunk_start_index 1 -chunk_duration_ms 5000 -time_shift_buffer_depth 7200 -minimum_update_period 60 -debug_mode 1 -
+
 FATE_VP8-$(call DEMDEC, MATROSKA, VP8) += fate-vp8-2451
 fate-vp8-2451: CMD = framecrc -flags +bitexact -i $(TARGET_SAMPLES)/vp8/RRSF49-short.webm -vsync cfr -an
 
diff --git a/mythtv/external/FFmpeg/tests/fate/vqf.mak b/mythtv/external/FFmpeg/tests/fate/vqf.mak
index 40e70219454..df5ff44f9d1 100644
--- a/mythtv/external/FFmpeg/tests/fate/vqf.mak
+++ b/mythtv/external/FFmpeg/tests/fate/vqf.mak
@@ -4,7 +4,7 @@ fate-twinvq: CMP = oneoff
 fate-twinvq: REF = $(SAMPLES)/vqf/achterba.pcm
 
 FATE_VQF-$(CONFIG_VQF_DEMUXER) += fate-vqf-demux
-fate-vqf-demux: CMD = md5 -i $(TARGET_SAMPLES)/vqf/achterba.vqf -acodec copy -flags bitexact -fflags +bitexact -f framecrc
+fate-vqf-demux: CMD = md5 -i $(TARGET_SAMPLES)/vqf/achterba.vqf -c:a copy -flags bitexact -fflags +bitexact -f framecrc
 
 FATE_VQF += $(FATE_VQF-yes)
 
diff --git a/mythtv/external/FFmpeg/tests/fate/wavpack.mak b/mythtv/external/FFmpeg/tests/fate/wavpack.mak
index 32ae3f6100b..e4e8d471288 100644
--- a/mythtv/external/FFmpeg/tests/fate/wavpack.mak
+++ b/mythtv/external/FFmpeg/tests/fate/wavpack.mak
@@ -89,12 +89,12 @@ FATE_WAVPACK-$(call DEMDEC, MATROSKA, WAVPACK) += fate-wavpack-matroskamode
 fate-wavpack-matroskamode: CMD = md5 -i $(TARGET_SAMPLES)/wavpack/special/matroska_mode.mka -f s16le
 
 FATE_WAVPACK-$(call DEMMUX, WV, MATROSKA) += fate-wavpack-matroska_mux-mono
-fate-wavpack-matroska_mux-mono: CMD = md5 -i $(TARGET_SAMPLES)/wavpack/num_channels/mono_16bit_int.wv -c copy -fflags +bitexact -f matroska
+fate-wavpack-matroska_mux-mono: CMD = md5pipe -i $(TARGET_SAMPLES)/wavpack/num_channels/mono_16bit_int.wv -c copy -fflags +bitexact -f matroska
 fate-wavpack-matroska_mux-mono: CMP = oneline
 fate-wavpack-matroska_mux-mono: REF = 11773e2a518edc788475f3880d849230
 
 FATE_WAVPACK-$(call DEMMUX, WV, MATROSKA) += fate-wavpack-matroska_mux-61
-fate-wavpack-matroska_mux-61: CMD = md5 -i $(TARGET_SAMPLES)/wavpack/num_channels/eva_2.22_6.1_16bit-partial.wv -c copy -fflags +bitexact -f matroska
+fate-wavpack-matroska_mux-61: CMD = md5pipe -i $(TARGET_SAMPLES)/wavpack/num_channels/eva_2.22_6.1_16bit-partial.wv -c copy -fflags +bitexact -f matroska
 fate-wavpack-matroska_mux-61: CMP = oneline
 fate-wavpack-matroska_mux-61: REF = 9641abdf596c10c2e21bd9b026d4bade
 
diff --git a/mythtv/external/FFmpeg/tests/ffserver-regression.sh b/mythtv/external/FFmpeg/tests/ffserver-regression.sh
index 192d362a625..9007fe37ca8 100755
--- a/mythtv/external/FFmpeg/tests/ffserver-regression.sh
+++ b/mythtv/external/FFmpeg/tests/ffserver-regression.sh
@@ -1,5 +1,9 @@
 #!/bin/sh
 
+target_samples=$3
+target_exec=$4
+target_path=$5
+
 #perl -e 'chomp($wd = `pwd`); print map { s!tests/data/!!; "<Stream $_>\nFile $wd/tests/data/$_\n</Stream>\n\n" } @ARGV' tests/data/a* >> tests/data/ffserver.conf
 #perl -e 'chomp($wd = `pwd`); print map { s!tests/data/!!; "<Stream $_.asf>\nFile $wd/tests/data/$_\n</Stream>\n\n" } @ARGV' tests/data/a* >> tests/data/ffserver.conf
 
@@ -8,22 +12,24 @@
 FILES=$(sed -n 's/^[^#]*<Stream \(.*\)>.*/\1/p' $2 | grep -v html)
 
 rm -f tests/feed1.ffm
-./ffserver${PROGSUF} -d -f "$2" 2> /dev/null &
+$target_exec ${target_path}/ffserver${PROGSUF} -f "$2" &
 FFSERVER_PID=$!
 echo "Waiting for feeds to startup..."
 sleep 2
 (
     cd tests/data || exit $?
     rm -f ff-* ffserver.regression
-    WGET_OPTIONS="--user-agent=NSPlayer -q --proxy=off -e verbose=off -e server_response=off"
+    WGET_OPTIONS="--user-agent=NSPlayer -q --proxy=off -e verbose=off -e server_response=off -T3 --tries=1"
     for file in $FILES; do
         if [ $(expr $file : "a-*") != 0 ]; then
             wget $WGET_OPTIONS -O - http://localhost:9999/$file > ff-$file
         else
-            wget $WGET_OPTIONS -O - http://localhost:9999/$file?date=19700101T000000Z | dd bs=1 count=20000 > ff-$file 2>/dev/null
+            wget $WGET_OPTIONS -O - http://localhost:9999/$file?date=19700101T000000Z | dd bs=1 count=100000 > ff-$file 2>/dev/null
         fi
         do_md5sum ff-$file >>ffserver.regression
     done
+    wget  $WGET_OPTIONS -O - 'http://localhost:9999/teststat.html?abc' > ff-stat 2>/dev/null
+    do_md5sum ff-stat >>ffserver.regression
 )
 kill $FFSERVER_PID
 wait > /dev/null 2>&1
diff --git a/mythtv/external/FFmpeg/tests/ffserver.conf b/mythtv/external/FFmpeg/tests/ffserver.conf
index ae35d7f5da8..3495d959e25 100644
--- a/mythtv/external/FFmpeg/tests/ffserver.conf
+++ b/mythtv/external/FFmpeg/tests/ffserver.conf
@@ -57,7 +57,7 @@ FileMaxSize 100M
 
 # Fire up ffmpeg pointing at this stream
 
-Launch ./ffmpeg -v 0 -y -f image2 -i tests/vsynth1/%02d.pgm
+Launch ./ffmpeg -v 0 -y -f image2 -flags +bitexact -fflags +bitexact -i tests/vsynth1/%02d.pgm -flags +bitexact -fflags +bitexact
 
 ACL allow localhost
 </Feed>
diff --git a/mythtv/external/FFmpeg/tests/ffserver.regression.ref b/mythtv/external/FFmpeg/tests/ffserver.regression.ref
index 9fc749763b7..fd8536c853f 100644
--- a/mythtv/external/FFmpeg/tests/ffserver.regression.ref
+++ b/mythtv/external/FFmpeg/tests/ffserver.regression.ref
@@ -1,10 +1,11 @@
-18c4ba0e8e7adb781216e38de61c2e39  ff-test_h.avi
-f84767c7af61f360f4b443c2c73f322f  ff-test_l.avi
-d976848a9e4d5d8fc2659e4841cdece5  ff-test.swf
-28fd87d5075b9b011aad57292f271a04  ff-test_h.asf
-a31ccd3aba2551e60b9fb1c156fca2f8  ff-test_l.asf
-3279d3ed0ef2d1347b5eda84db2cf3e6  ff-test_h.rm
-440231fe3cf0849887390b4d67d6894a  ff-test_l.rm
-e0dc91430660c619e97b5c82e0f398fc  ff-test.jpg
-0d6c98fc8a4f00560fe34e94e26880a9  ff-test_small.jpg
-e2a315d7ac0576279f8b4d917999615a  ff-test.mjpg
+0c9639f09decbc54c9f091dcf1ca0e8f *ff-test_h.avi
+e28ba75853caf975e06d92955c9f7f73 *ff-test_l.avi
+a767dbdf5d1bded3450279f812f97b37 *ff-test.swf
+ca209a0c67afbd3bc3bcde0840f313fc *ff-test_h.asf
+f97a91609bfc8a1857455f17c5ec101c *ff-test_l.asf
+06f5a6a4c5d1c6735f4d0068e825c91f *ff-test_h.rm
+1f57580f02f0317407b3b82a3d5e093f *ff-test_l.rm
+e04e6ebf9584654df131f5eec881ac38 *ff-test.jpg
+f15d43e9d3630601b61a024023249bb8 *ff-test_small.jpg
+4735c72cde67000f12e9d1dbfbd975a7 *ff-test.mjpg
+fd038af80560e15271ce42651093ee43 *ff-stat
diff --git a/mythtv/external/FFmpeg/tests/filtergraphs/firequalizer b/mythtv/external/FFmpeg/tests/filtergraphs/firequalizer
index ee432e287fb..777dfddc37c 100644
--- a/mythtv/external/FFmpeg/tests/filtergraphs/firequalizer
+++ b/mythtv/external/FFmpeg/tests/filtergraphs/firequalizer
@@ -1,4 +1,5 @@
 firequalizer    =
+    fft2        = on:
     gain        = 'sin(0.001*f) - 1':
     delay       = 0.05,
 
@@ -10,14 +11,15 @@ firequalizer    =
     zero_phase  = on:
     wfunc       = nuttall,
 
+firequalizer    =
+    fft2        = on:
+    gain_entry  = 'entry(1000, 0); entry(5000, 0.1); entry(10000, 0.2)',
+
 firequalizer    =
     gain        = 'if (ch, -0.3 * sin(0.001*f), -0.8 * sin(0.001*f)) - 1':
     delay       = 0.05:
     multi       = on,
 
-firequalizer    =
-    gain_entry  = 'entry(1000, 0); entry(5000, 0.1); entry(10000, 0.2)',
-
 firequalizer    =
     gain_entry  = 'entry(1000, 0.2); entry(5000, 0.1); entry(10000, 0)',
 
diff --git a/mythtv/external/FFmpeg/tests/filtergraphs/overlay_nv12 b/mythtv/external/FFmpeg/tests/filtergraphs/overlay_nv12
new file mode 100644
index 00000000000..ec82cbef2e5
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/filtergraphs/overlay_nv12
@@ -0,0 +1,5 @@
+sws_flags=+accurate_rnd+bitexact;
+split [main][over];
+[over] scale=88:72, pad=96:80:4:4 [overf];
+[main] format=nv12 [mainf];
+[mainf][overf] overlay=240:16:format=yuv420, format=yuv420p
diff --git a/mythtv/external/FFmpeg/tests/filtergraphs/overlay_nv21 b/mythtv/external/FFmpeg/tests/filtergraphs/overlay_nv21
new file mode 100644
index 00000000000..9c30d07b263
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/filtergraphs/overlay_nv21
@@ -0,0 +1,5 @@
+sws_flags=+accurate_rnd+bitexact;
+split [main][over];
+[over] scale=88:72, pad=96:80:4:4 [overf];
+[main] format=nv21 [mainf];
+[mainf][overf] overlay=240:16:format=yuv420, format=yuv420p
diff --git a/mythtv/external/FFmpeg/tests/filtergraphs/scale2ref_keep_aspect b/mythtv/external/FFmpeg/tests/filtergraphs/scale2ref_keep_aspect
new file mode 100644
index 00000000000..f407460ec7c
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/filtergraphs/scale2ref_keep_aspect
@@ -0,0 +1,5 @@
+sws_flags=+accurate_rnd+bitexact;
+testsrc=size=320x240 [main];
+testsrc=size=640x360 [ref];
+[main][ref] scale2ref=iw/4:ow/mdar [main][ref];
+[ref] nullsink
diff --git a/mythtv/external/FFmpeg/tests/lavf-regression.sh b/mythtv/external/FFmpeg/tests/lavf-regression.sh
index 8d961781d9b..45c877e4ac1 100755
--- a/mythtv/external/FFmpeg/tests/lavf-regression.sh
+++ b/mythtv/external/FFmpeg/tests/lavf-regression.sh
@@ -90,6 +90,14 @@ if [ -n "$do_mxf_d10" ]; then
 do_lavf mxf_d10 "-ar 48000 -ac 2" "-r 25 -vf scale=720:576,pad=720:608:0:32 -vcodec mpeg2video -g 0 -flags +ildct+low_delay -dc 10 -non_linear_quant 1 -intra_vlc 1 -qscale 1 -ps 1 -qmin 1 -rc_max_vbv_use 1 -rc_min_vbv_use 1 -pix_fmt yuv422p -minrate 30000k -maxrate 30000k -b 30000k -bufsize 1200000 -top 1 -rc_init_occupancy 1200000 -qmax 12 -f mxf_d10"
 fi
 
+if [ -n "$do_mxf_dv25" ]; then
+do_lavf mxf_dv25 "-ar 48000 -ac 2" "-r 25 -vf scale=720:576,setdar=4/3 -vcodec dvvideo -pix_fmt yuv420p -b 25000k -top 0 -f mxf"
+fi
+
+if [ -n "$do_mxf_dvcpro50" ]; then
+do_lavf mxf_dvcpro50 "-ar 48000 -ac 2" "-r 25 -vf scale=720:576,setdar=16/9 -vcodec dvvideo -pix_fmt yuv422p -b 50000k -top 0 -f mxf"
+fi
+
 if [ -n "$do_mxf_opatom" ]; then
 do_lavf mxf_opatom "" "-s 1920x1080 -vcodec dnxhd -pix_fmt yuv422p -vb 36M -f mxf_opatom -map 0"
 fi
@@ -212,12 +220,33 @@ do_avconv $file $DEC_OPTS -f image2 -vcodec pgmyuv -i $raw_src $ENC_OPTS -t 1 -q
 do_avconv_crc $file $DEC_OPTS -i $target_path/$file -pix_fmt rgb24
 fi
 
+if [ -n "$do_apng" ] ; then
+file=${outfile}lavf.apng
+do_avconv $file $DEC_OPTS -f image2 -vcodec pgmyuv -i $raw_src $ENC_OPTS -t 1 -pix_fmt rgb24
+do_avconv_crc $file $DEC_OPTS -i $target_path/$file -pix_fmt rgb24
+file_copy=${outfile}lavf.copy.apng
+do_avconv $file_copy $DEC_OPTS -i $file $ENC_OPTS -c copy
+do_avconv_crc $file_copy $DEC_OPTS -i $target_path/$file_copy
+file=${outfile}lavf.png
+do_avconv $file $DEC_OPTS -f image2 -vcodec pgmyuv -i $raw_src $ENC_OPTS -pix_fmt rgb24 -frames:v 1 -f apng
+do_avconv_crc $file $DEC_OPTS -i $target_path/$file -pix_fmt rgb24
+fi
+
 if [ -n "$do_yuv4mpeg" ] ; then
 file=${outfile}lavf.y4m
 do_avconv $file $DEC_OPTS -f image2 -vcodec pgmyuv -i $raw_src $ENC_OPTS -t 1 -qscale 10
 #do_avconv_crc $file -i $target_path/$file
 fi
 
+if [ -n "$do_fits" ] ; then
+pix_fmts="gray gray16be gbrp gbrap gbrp16be gbrap16be"
+for pix_fmt in $pix_fmts ; do
+    file=${outfile}${pix_fmt}lavf.fits
+    do_avconv $file $DEC_OPTS -f image2 -vcodec pgmyuv -i $raw_src $ENC_OPTS -pix_fmt $pix_fmt
+    do_avconv_crc $file $DEC_OPTS -i $target_path/$file -pix_fmt $pix_fmt
+done
+fi
+
 # image formats
 
 if [ -n "$do_pgm" ] ; then
@@ -374,6 +403,10 @@ if [ -n "$do_w64" ] ; then
 do_audio_only w64
 fi
 
+if [ -n "$do_wv" ] ; then
+do_audio_only wv
+fi
+
 # pix_fmt conversions
 
 if [ -n "$do_pixfmt" ] ; then
diff --git a/mythtv/external/FFmpeg/tests/ref/acodec/adpcm-yamaha b/mythtv/external/FFmpeg/tests/ref/acodec/adpcm-yamaha
index 27410585465..f3e6dbede20 100644
--- a/mythtv/external/FFmpeg/tests/ref/acodec/adpcm-yamaha
+++ b/mythtv/external/FFmpeg/tests/ref/acodec/adpcm-yamaha
@@ -1,4 +1,4 @@
-e9c14f701d25947317db9367b9dc772d *tests/data/fate/acodec-adpcm-yamaha.wav
+245c194e84d482a70ca89de9c0bbd591 *tests/data/fate/acodec-adpcm-yamaha.wav
 265274 tests/data/fate/acodec-adpcm-yamaha.wav
-93b95a663ec8799e0c4db18467b21234 *tests/data/fate/acodec-adpcm-yamaha.out.wav
-stddev: 1247.60 PSNR: 34.41 MAXDIFF:39895 bytes:  1058400/  1060864
+758b4aee62964831d0a335ada9672104 *tests/data/fate/acodec-adpcm-yamaha.out.wav
+stddev: 1242.71 PSNR: 34.44 MAXDIFF:39960 bytes:  1058400/  1060864
diff --git a/mythtv/external/FFmpeg/tests/ref/acodec/adpcm-yamaha-trellis b/mythtv/external/FFmpeg/tests/ref/acodec/adpcm-yamaha-trellis
index a099ec54c58..909a95139bc 100644
--- a/mythtv/external/FFmpeg/tests/ref/acodec/adpcm-yamaha-trellis
+++ b/mythtv/external/FFmpeg/tests/ref/acodec/adpcm-yamaha-trellis
@@ -1,4 +1,4 @@
-247a06c3f26c57abd2db1a793174cb66 *tests/data/fate/acodec-adpcm-yamaha-trellis.wav
+c8306ada93ef52b1e87b6758853f4937 *tests/data/fate/acodec-adpcm-yamaha-trellis.wav
 265274 tests/data/fate/acodec-adpcm-yamaha-trellis.wav
-a42b5fa74b39a07691b0df80ce67f77e *tests/data/fate/acodec-adpcm-yamaha-trellis.out.wav
-stddev:  928.29 PSNR: 36.98 MAXDIFF:33557 bytes:  1058400/  1060864
+8ad27b0ea7e13e70ed334b5ec26c62ef *tests/data/fate/acodec-adpcm-yamaha-trellis.out.wav
+stddev:  926.56 PSNR: 36.99 MAXDIFF:33570 bytes:  1058400/  1060864
diff --git a/mythtv/external/FFmpeg/tests/ref/acodec/roqaudio b/mythtv/external/FFmpeg/tests/ref/acodec/roqaudio
index 61cb27a38a0..f513a03975e 100644
--- a/mythtv/external/FFmpeg/tests/ref/acodec/roqaudio
+++ b/mythtv/external/FFmpeg/tests/ref/acodec/roqaudio
@@ -1,4 +1,4 @@
 75859976d7098588aeaebbc5551484a9 *tests/data/fate/acodec-roqaudio.roq
 265992 tests/data/fate/acodec-roqaudio.roq
-73d5aaaab9488e63f1cf6fc324c7a9a2 *tests/data/fate/acodec-roqaudio.out.wav
+2057ed235e9d4e727e13bf57f3891093 *tests/data/fate/acodec-roqaudio.out.wav
 stddev: 4481.70 PSNR: 23.30 MAXDIFF:46250 bytes:  1058400/  1058400
diff --git a/mythtv/external/FFmpeg/tests/ref/acodec/s302m b/mythtv/external/FFmpeg/tests/ref/acodec/s302m
index 5eca9e3a6bc..63e39edef91 100644
--- a/mythtv/external/FFmpeg/tests/ref/acodec/s302m
+++ b/mythtv/external/FFmpeg/tests/ref/acodec/s302m
@@ -1,4 +1,4 @@
-f6908214498489799b50e332ac42ebf3 *tests/data/fate/acodec-s302m.mpegts
+165d022ab86306d069797acff0c1e295 *tests/data/fate/acodec-s302m.mpegts
 1589164 tests/data/fate/acodec-s302m.mpegts
-f9b6528eee1aea04640ee83400c78689 *tests/data/fate/acodec-s302m.out.wav
-stddev:  986.97 PSNR: 36.44 MAXDIFF:18642 bytes:  1058400/  1056708
+31f25a0020fd9017de9c3c608316854b *tests/data/fate/acodec-s302m.out.wav
+stddev:  986.94 PSNR: 36.44 MAXDIFF:18571 bytes:  1058400/  1056708
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/8bps b/mythtv/external/FFmpeg/tests/ref/fate/8bps
index c6287ffae04..dab2b908db8 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/8bps
+++ b/mythtv/external/FFmpeg/tests/ref/fate/8bps
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 22050
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   259200, 0x7e91df07
 1,          0,          0,     1024,     2048, 0x3d042426
 1,       1024,       1024,     1024,     2048, 0x5bcae456
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/aac-autobsf-adtstoasc b/mythtv/external/FFmpeg/tests/ref/fate/aac-autobsf-adtstoasc
new file mode 100644
index 00000000000..9ca8e7ed9ed
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/aac-autobsf-adtstoasc
@@ -0,0 +1,43 @@
+b0375ba00bcbd55023a176255b8d4ba2 *tests/data/fate/aac-autobsf-adtstoasc.matroska
+6728 tests/data/fate/aac-autobsf-adtstoasc.matroska
+#extradata 0:        2, 0x0030001c
+#tb 0: 1/1000
+#media_type 0: audio
+#codec_id 0: aac
+#sample_rate 0: 16000
+#channel_layout 0: 4
+#channel_layout_name 0: mono
+0,          0,          0,       64,        4, 0x02f70117
+0,         64,         64,       64,      163, 0xd5f85007
+0,        128,        128,       64,      127, 0x66484065
+0,        192,        192,       64,       94, 0x55222bd6
+0,        256,        256,       64,      314, 0x3c7e923a
+0,        320,        320,       64,      207, 0x1efc5d1b
+0,        384,        384,       64,      119, 0xb2a13601
+0,        448,        448,       64,      184, 0xcafc6091
+0,        512,        512,       64,      132, 0xddd33c0b
+0,        576,        576,       64,      152, 0x83935031
+0,        640,        640,       64,      227, 0x32a86bc4
+0,        704,        704,       64,      122, 0xd04e3571
+0,        768,        768,       64,      163, 0x57d44d16
+0,        832,        832,       64,      147, 0x226043d7
+0,        896,        896,       64,      119, 0x8ad931ed
+0,        960,        960,       64,      153, 0xbb6e432f
+0,       1024,       1024,       64,      185, 0xa01f4ff3
+0,       1088,       1088,       64,      126, 0x85503ce6
+0,       1152,       1152,       64,      246, 0x652c7b59
+0,       1216,       1216,       64,      162, 0xc9f04da0
+0,       1280,       1280,       64,      135, 0x71fa3be0
+0,       1344,       1344,       64,      246, 0x7a6f7788
+0,       1408,       1408,       64,      262, 0xd3097781
+0,       1472,       1472,       64,       60, 0x09a118f5
+0,       1536,       1536,       64,      255, 0xbab5793c
+0,       1600,       1600,       64,      153, 0x6b6a44fb
+0,       1664,       1664,       64,      160, 0x550e4530
+0,       1728,       1728,       64,      215, 0x7fe66144
+0,       1792,       1792,       64,      144, 0xcd723f7d
+0,       1856,       1856,       64,      187, 0x2a0b5c1b
+0,       1920,       1920,       64,      177, 0xb8c355d5
+0,       1984,       1984,       64,      156, 0x867d4f3a
+0,       2048,       2048,       64,      201, 0x62745ff9
+0,       2112,       2112,       64,      137, 0x90c639e0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-4xm b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-4xm
index cb725e5d97e..cfde412da80 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-4xm
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-4xm
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1472,     5888, 0x9086e310
 0,       1476,       1476,     1472,     5888, 0xac8491f5
 0,       2952,       2952,     1472,     5888, 0xc9a08b6b
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-afc b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-afc
index 0cf61a98b6d..6d8e7324541 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-afc
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-afc
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,    17920,    71680, 0x52373bc9
 0,      17920,      17920,    17920,    71680, 0x1f854b27
 0,      35840,      35840,    17920,    71680, 0x3d265a6d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-dtk b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-dtk
index acdf0333b20..f3ade6d5054 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-dtk
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-dtk
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 48000
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,      896,     3584, 0xdae789d5
 0,        896,        896,      896,     3584, 0x168ed9b6
 0,       1792,       1792,      896,     3584, 0x8920c8d5
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-1 b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-1
index fa9906c09cb..76be8e8511a 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-1
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-1
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1484,     5936, 0x00000000
 0,       1484,       1484,     1456,     5824, 0x00000000
 0,       2940,       2940,     1484,     5936, 0x00000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-2 b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-2
index 4743e3d6cd4..91440874a0e 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-2
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1484,     5936, 0xea261a29
 0,       1484,       1484,     1456,     5824, 0x253df061
 0,       2940,       2940,     1484,     5936, 0x603a5bd7
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-maxis-xa b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-maxis-xa
index b300c320ad9..c919a675457 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-maxis-xa
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-maxis-xa
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,       28,      112, 0x291d1be4
 0,         28,         28,       28,      112, 0xf08d33cc
 0,         56,         56,       28,      112, 0x5b1521de
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-r1 b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-r1
index 2208eb0cb8c..4e5fb6788f1 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-r1
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ea-r1
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 48000
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1624,     6496, 0x00000000
 0,       1624,       1624,     1596,     6384, 0x00000000
 0,       3220,       3220,     1596,     6384, 0x00000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-amv b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-amv
index def9279099b..eb174dfa810 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-amv
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-amv
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,     1378,     2756, 0x0af35034
 0,       1378,       1378,     1378,     2756, 0x8462443f
 0,       2756,       2756,     1378,     2756, 0x9f493ba6
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ea-eacs b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ea-eacs
index d5ea2e53089..fcfcbeb1753 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ea-eacs
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ea-eacs
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1468,     5872, 0x00000000
 0,       1468,       1468,     1468,     5872, 0x00000000
 0,       2936,       2936,     1468,     5872, 0x00000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ea-sead b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ea-sead
index 563bb49f58c..2d52efe3c0b 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ea-sead
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ea-sead
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,      736,     2944, 0x00000000
 0,        736,        736,     1472,     5888, 0x5ae3c2a4
 0,       2208,       2208,     1472,     5888, 0x158fbcb4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-smjpeg b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-smjpeg
index f88520d9a6e..d56014ea013 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-smjpeg
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-smjpeg
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      512,     1024, 0x00000000
 0,        512,        512,      512,     1024, 0x00000000
 0,       1024,       1024,      512,     1024, 0xed2d3f6b
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ws b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ws
index 0e41e1eb0c2..d1e6b615dcd 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ws
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ima-ws
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,    11024,    22048, 0x0665d7f4
 0,      11024,      11024,     1470,     2940, 0x0f3c64cb
 0,      12494,      12494,     1470,     2940, 0xc90b9e78
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ms-mono b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ms-mono
index 254dc8a5864..e3f217d18ec 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ms-mono
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-ms-mono
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 11025
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      500,     1000, 0x64cd9403
 0,        500,        500,      500,     1000, 0xa4ef8a9d
 0,       1000,       1000,      500,     1000, 0x75c19868
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-thp b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-thp
index ff49303980e..592c6610adf 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-thp
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-thp
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 32000
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1078,     4312, 0x469714f6
 0,       1078,       1078,     1064,     4256, 0x6ca28f25
 0,       2142,       2142,     1078,     4312, 0xd466f806
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-vima b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-vima
index 5bc62c39e99..b22f128be5d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-vima
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-vima
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,    73500,   294000, 0x37d439ee
 0,      73500,      73500,     1470,     5880, 0xe524b177
 0,      74970,      74970,     1470,     5880, 0x9e784af1
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-xa b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-xa
index e3652278409..15b62ec4a5b 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adpcm-xa
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adpcm-xa
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 37800
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     2016,     8064, 0xa307ed8c
 0,       2016,       2016,     2016,     8064, 0xd2551927
 0,       4032,       4032,     2016,     8064, 0x3264a799
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adts-id3v1-demux b/mythtv/external/FFmpeg/tests/ref/fate/adts-id3v1-demux
new file mode 100644
index 00000000000..7caa5d6870c
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adts-id3v1-demux
@@ -0,0 +1,11 @@
+#tb 0: 1/28224000
+#media_type 0: audio
+#codec_id 0: aac
+#sample_rate 0: 48000
+#channel_layout 0: 3
+#channel_layout_name 0: stereo
+0,          0,          0,   602112,      474, 0x4c90e7c4
+0,     602112,     602112,   602112,      471, 0xb8b5e75d
+0,    1204224,    1204224,   602112,      502, 0xe943efd1
+0,    1806336,    1806336,   602112,      495, 0x9c3cec74
+0,    2408448,    2408448,   602112,      493, 0x03b2fa4b
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/adtstoasc_ticket3715 b/mythtv/external/FFmpeg/tests/ref/fate/adtstoasc_ticket3715
index ff8e8abdbb1..96795a2ca39 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/adtstoasc_ticket3715
+++ b/mythtv/external/FFmpeg/tests/ref/fate/adtstoasc_ticket3715
@@ -1,11 +1,12 @@
-ef8ce3cbd1d86113e7c991a816086068 *tests/data/fate/adtstoasc_ticket3715.mov
-33270 tests/data/fate/adtstoasc_ticket3715.mov
+0221e04333e6ac432fa42960502f0d5a *tests/data/fate/adtstoasc_ticket3715.mov
+33324 tests/data/fate/adtstoasc_ticket3715.mov
 #extradata 0:        2, 0x00340022
 #tb 0: 1/44100
 #media_type 0: audio
 #codec_id 0: aac
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,      371, 0x14b11a4f
 0,       1024,       1024,     1024,      402, 0x2f00c487
 0,       2048,       2048,     1024,      403, 0x1959c0d4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/api-mjpeg-codec-param b/mythtv/external/FFmpeg/tests/ref/fate/api-mjpeg-codec-param
index c67d1b1ab04..02f656df25a 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/api-mjpeg-codec-param
+++ b/mythtv/external/FFmpeg/tests/ref/fate/api-mjpeg-codec-param
@@ -149,12 +149,15 @@ stream=0, decode=0
     sub_text_format=1
     refcounted_frames=false
     side_data_only_packets=true
+    apply_cropping=true
     skip_alpha=false
     field_order=0
     dump_separator=
     codec_whitelist=
     pixel_format=yuvj422p
     video_size=400x225
+    max_pixels=2147483647
+    hwaccel_flags=0x00000001
 stream=0, decode=1
     b=0
     ab=0
@@ -306,9 +309,12 @@ stream=0, decode=1
     sub_text_format=1
     refcounted_frames=false
     side_data_only_packets=true
+    apply_cropping=true
     skip_alpha=false
     field_order=0
     dump_separator=
     codec_whitelist=
     pixel_format=yuvj422p
     video_size=400x225
+    max_pixels=2147483647
+    hwaccel_flags=0x00000001
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/api-png-codec-param b/mythtv/external/FFmpeg/tests/ref/fate/api-png-codec-param
index bd534418947..de86f1b25d9 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/api-png-codec-param
+++ b/mythtv/external/FFmpeg/tests/ref/fate/api-png-codec-param
@@ -149,12 +149,15 @@ stream=0, decode=0
     sub_text_format=1
     refcounted_frames=false
     side_data_only_packets=true
+    apply_cropping=true
     skip_alpha=false
     field_order=0
     dump_separator=
     codec_whitelist=
     pixel_format=rgba
     video_size=128x128
+    max_pixels=2147483647
+    hwaccel_flags=0x00000001
 stream=0, decode=1
     b=0
     ab=0
@@ -306,9 +309,12 @@ stream=0, decode=1
     sub_text_format=1
     refcounted_frames=false
     side_data_only_packets=true
+    apply_cropping=true
     skip_alpha=false
     field_order=0
     dump_separator=
     codec_whitelist=
     pixel_format=rgba
     video_size=128x128
+    max_pixels=2147483647
+    hwaccel_flags=0x00000001
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/apng-clock b/mythtv/external/FFmpeg/tests/ref/fate/apng-clock
index 54db0944b70..c0480fd4e6c 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/apng-clock
+++ b/mythtv/external/FFmpeg/tests/ref/fate/apng-clock
@@ -1,4 +1,4 @@
-#tb 0: 6667/100000
+#tb 0: 1/25
 #media_type 0: video
 #codec_id 0: rawvideo
 #dimensions 0: 150x150
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/armovie-escape124 b/mythtv/external/FFmpeg/tests/ref/fate/armovie-escape124
index 5c8f0519b13..398ff767b65 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/armovie-escape124
+++ b/mythtv/external/FFmpeg/tests/ref/fate/armovie-escape124
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 44100
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,        1,   230400, 0xd133e177
 1,          0,          0,    44100,   176400, 0xdd61578c
 0,          1,          1,        1,   230400, 0xe3501bb2
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/audio_fifo b/mythtv/external/FFmpeg/tests/ref/fate/audio_fifo
new file mode 100644
index 00000000000..6c6538b566d
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/audio_fifo
@@ -0,0 +1,228 @@
+
+TEST: 1
+
+written: 12
+written: 12
+remaining samples in audio_fifo: 24
+
+read: 12
+00 01 02 03 04 05 06 07 08 09 0a 0b
+remaining samples in audio_fifo: 12
+
+peek:
+00 01 02 03 04 05 06 07 08 09 0a 0b
+
+peek_at:
+0:
+00
+1:
+01
+2:
+02
+3:
+03
+4:
+04
+5:
+05
+6:
+06
+7:
+07
+8:
+08
+9:
+09
+10:
+0a
+11:
+0b
+
+
+TEST: 2
+
+written: 6
+written: 6
+remaining samples in audio_fifo: 12
+
+read: 6
+00 01 02 03 04 05
+06 07 08 09 0a 0b
+remaining samples in audio_fifo: 6
+
+peek:
+00 01 02 03 04 05
+06 07 08 09 0a 0b
+
+peek_at:
+0:
+00
+06
+1:
+01
+07
+2:
+02
+08
+3:
+03
+09
+4:
+04
+0a
+5:
+05
+0b
+
+
+TEST: 3
+
+written: 12
+written: 12
+remaining samples in audio_fifo: 24
+
+read: 12
+0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000a 000b
+remaining samples in audio_fifo: 12
+
+peek:
+0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 000a 000b
+
+peek_at:
+0:
+0000
+1:
+0001
+2:
+0002
+3:
+0003
+4:
+0004
+5:
+0005
+6:
+0006
+7:
+0007
+8:
+0008
+9:
+0009
+10:
+000a
+11:
+000b
+
+
+TEST: 4
+
+written: 6
+written: 6
+remaining samples in audio_fifo: 12
+
+read: 6
+0000 0001 0002 0003 0004 0005
+0006 0007 0008 0009 000a 000b
+remaining samples in audio_fifo: 6
+
+peek:
+0000 0001 0002 0003 0004 0005
+0006 0007 0008 0009 000a 000b
+
+peek_at:
+0:
+0000
+0006
+1:
+0001
+0007
+2:
+0002
+0008
+3:
+0003
+0009
+4:
+0004
+000a
+5:
+0005
+000b
+
+
+TEST: 5
+
+written: 12
+written: 12
+remaining samples in audio_fifo: 24
+
+read: 12
+00000000 3f800000 40000000 40400000 40800000 40a00000 40c00000 40e00000 41000000 41100000 41200000 41300000
+remaining samples in audio_fifo: 12
+
+peek:
+00000000 3f800000 40000000 40400000 40800000 40a00000 40c00000 40e00000 41000000 41100000 41200000 41300000
+
+peek_at:
+0:
+00000000
+1:
+3f800000
+2:
+40000000
+3:
+40400000
+4:
+40800000
+5:
+40a00000
+6:
+40c00000
+7:
+40e00000
+8:
+41000000
+9:
+41100000
+10:
+41200000
+11:
+41300000
+
+
+TEST: 6
+
+written: 6
+written: 6
+remaining samples in audio_fifo: 12
+
+read: 6
+00000000 3f800000 40000000 40400000 40800000 40a00000
+40c00000 40e00000 41000000 41100000 41200000 41300000
+remaining samples in audio_fifo: 6
+
+peek:
+00000000 3f800000 40000000 40400000 40800000 40a00000
+40c00000 40e00000 41000000 41100000 41200000 41300000
+
+peek_at:
+0:
+00000000
+40c00000
+1:
+3f800000
+40e00000
+2:
+40000000
+41000000
+3:
+40400000
+41100000
+4:
+40800000
+41200000
+5:
+40a00000
+41300000
+
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/bethsoft-vid b/mythtv/external/FFmpeg/tests/ref/fate/bethsoft-vid
index ccb0d377a32..25a62ae5158 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/bethsoft-vid
+++ b/mythtv/external/FFmpeg/tests/ref/fate/bethsoft-vid
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 11111
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   192000, 0x00000000
 1,          0,          0,      740,     1480, 0x00000000
 1,        740,        740,      740,     1480, 0x20a92bd4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/bfi b/mythtv/external/FFmpeg/tests/ref/fate/bfi
index 807615c88c4..277c93543e5 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/bfi
+++ b/mythtv/external/FFmpeg/tests/ref/fate/bfi
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 11025
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   134400, 0xc218b00c
 1,          0,          0,     8884,    17768, 0x07df135c
 0,          1,          1,        1,   134400, 0x114daf7c
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/binsub-movtextenc b/mythtv/external/FFmpeg/tests/ref/fate/binsub-movtextenc
index 6efe2c015a0..22ee85a2f8f 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/binsub-movtextenc
+++ b/mythtv/external/FFmpeg/tests/ref/fate/binsub-movtextenc
@@ -1 +1 @@
-ef264064c522389d0cf267c4d6235561
+af6a8f38d7c11d9af7823cc44554d2ad
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/bmv-audio b/mythtv/external/FFmpeg/tests/ref/fate/bmv-audio
index 62f9c5e56ef..6e1a4c2fe9e 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/bmv-audio
+++ b/mythtv/external/FFmpeg/tests/ref/fate/bmv-audio
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1856,     7424, 0x18540b36
 0,       1856,       1856,     1824,     7296, 0x5acd2484
 0,       3680,       3680,     1856,     7424, 0xa1bc5c5a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/cdxl-demux b/mythtv/external/FFmpeg/tests/ref/fate/cdxl-demux
index 828b2c91fa7..f1334755aad 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/cdxl-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/cdxl-demux
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s8
 #sample_rate 1: 11025
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,     1884,    22688, 0xc954a244
 1,          0,          0,     1884,     1884, 0x06925e3e
 0,       1884,       1884,     1884,    22688, 0x3ee4a304
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-extended-lavf-mxf b/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-extended-lavf-mxf
index f6b1010bea9..c47f14faa15 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-extended-lavf-mxf
+++ b/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-extended-lavf-mxf
@@ -1 +1 @@
-32fe9ae5b89c7802c804ac51f62d89cb *tests/data/fate/concat-demuxer-extended-lavf-mxf.ffprobe
+7e53f4c5cb0c9afda2771c9f0c697d9c *tests/data/fate/concat-demuxer-extended-lavf-mxf.ffprobe
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-extended-lavf-mxf_d10 b/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-extended-lavf-mxf_d10
index 6d84589fbdb..75d386e3c17 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-extended-lavf-mxf_d10
+++ b/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-extended-lavf-mxf_d10
@@ -1 +1 @@
-0724a00f35550e4ae1e87240a5c95050 *tests/data/fate/concat-demuxer-extended-lavf-mxf_d10.ffprobe
+44810fc2eeee0072d9d7011b0d2afe59 *tests/data/fate/concat-demuxer-extended-lavf-mxf_d10.ffprobe
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple1-lavf-mxf b/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple1-lavf-mxf
index d71acbe7b1b..1174a1e1831 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple1-lavf-mxf
+++ b/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple1-lavf-mxf
@@ -79,46 +79,46 @@ audio|1|53760|1.120000|53760|1.120000|1920|0.040000|N/A|N/A|3840|501248|K_
 video|0|28|1.120000|28|1.120000|1|0.040000|N/A|N/A|13350|505856|__
 audio|1|55680|1.160000|55680|1.160000|1920|0.040000|N/A|N/A|3840|519680|K_
 video|0|25|1.000000|24|0.960000|1|0.040000|N/A|N/A|24801|6144|K_|1
-Strings Metadata|8
+Strings Metadata
 audio|1|48000|1.000000|48000|1.000000|1920|0.040000|N/A|N/A|3840|31232|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|28|1.120000|25|1.000000|1|0.040000|N/A|N/A|16743|35840|__|1
-Strings Metadata|8
+Strings Metadata
 audio|1|49920|1.040000|49920|1.040000|1920|0.040000|N/A|N/A|3840|52736|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|26|1.040000|26|1.040000|1|0.040000|N/A|N/A|13812|57344|__|1
-Strings Metadata|8
+Strings Metadata
 audio|1|51840|1.080000|51840|1.080000|1920|0.040000|N/A|N/A|3840|71680|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|27|1.080000|27|1.080000|1|0.040000|N/A|N/A|13607|76288|__|1
-Strings Metadata|8
+Strings Metadata
 audio|1|53760|1.120000|53760|1.120000|1920|0.040000|N/A|N/A|3840|90112|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|31|1.240000|28|1.120000|1|0.040000|N/A|N/A|16158|94720|__|1
-Strings Metadata|8
+Strings Metadata
 audio|1|55680|1.160000|55680|1.160000|1920|0.040000|N/A|N/A|3840|111104|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|29|1.160000|29|1.160000|1|0.040000|N/A|N/A|13943|115712|__|1
-Strings Metadata|8
+Strings Metadata
 audio|1|57600|1.200000|57600|1.200000|1920|0.040000|N/A|N/A|3840|130048|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|30|1.200000|30|1.200000|1|0.040000|N/A|N/A|11223|134656|__|1
-Strings Metadata|8
+Strings Metadata
 audio|1|59520|1.240000|59520|1.240000|1920|0.040000|N/A|N/A|3840|145920|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|34|1.360000|31|1.240000|1|0.040000|N/A|N/A|20298|150528|__|1
-Strings Metadata|8
+Strings Metadata
 audio|1|61440|1.280000|61440|1.280000|1920|0.040000|N/A|N/A|3840|171008|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|32|1.280000|32|1.280000|1|0.040000|N/A|N/A|13341|175616|__|1
-Strings Metadata|8
+Strings Metadata
 audio|1|63360|1.320000|63360|1.320000|1920|0.040000|N/A|N/A|3840|189440|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|33|1.320000|33|1.320000|1|0.040000|N/A|N/A|12362|194048|__|1
-Strings Metadata|8
+Strings Metadata
 audio|1|65280|1.360000|65280|1.360000|1920|0.040000|N/A|N/A|3840|206848|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|37|1.480000|34|1.360000|1|0.040000|N/A|N/A|24786|211456|K_|1
-Strings Metadata|8
+Strings Metadata
 0|mpeg2video|4|video|1/25|[0][0][0][0]|0x0000|352|288|0|0|1|1:1|11:9|yuv420p|8|tv|unknown|unknown|unknown|left|progressive|N/A|1|N/A|25/1|25/1|1/25|N/A|N/A|N/A|N/A|N/A|N/A|N/A|N/A|N/A|51|0|0|0|0|0|0|0|0|0|0|0|0|0x060A2B340101010501010D001300000000000000000000000000000000000001
 1|pcm_s16le|unknown|audio|1/48000|[0][0][0][0]|0x0000|s16|48000|1|unknown|16|N/A|0/0|0/0|1/48000|0|0.000000|N/A|N/A|768000|N/A|N/A|N/A|N/A|50|0|0|0|0|0|0|0|0|0|0|0|0|0x060A2B340101010501010D001300000000000000000000000000000000000001
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple1-lavf-mxf_d10 b/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple1-lavf-mxf_d10
index 4c78bb2ab90..bd0e5e2a747 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple1-lavf-mxf_d10
+++ b/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple1-lavf-mxf_d10
@@ -59,24 +59,24 @@ audio|1|53760|1.120000|53760|1.120000|1920|0.040000|N/A|N/A|7680|5055488|K_
 video|0|29|1.160000|29|1.160000|1|0.040000|N/A|N/A|150000|5117952|K_
 audio|1|55680|1.160000|55680|1.160000|1920|0.040000|N/A|N/A|7680|5268480|K_
 video|0|30|1.200000|30|1.200000|1|0.040000|N/A|N/A|150000|1071104|K_|1
-Strings Metadata|8
+Strings Metadata
 audio|1|57600|1.200000|57600|1.200000|1920|0.040000|N/A|N/A|7680|1221632|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|31|1.240000|31|1.240000|1|0.040000|N/A|N/A|150000|1284096|K_|1
-Strings Metadata|8
+Strings Metadata
 audio|1|59520|1.240000|59520|1.240000|1920|0.040000|N/A|N/A|7680|1434624|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|32|1.280000|32|1.280000|1|0.040000|N/A|N/A|150000|1497088|K_|1
-Strings Metadata|8
+Strings Metadata
 audio|1|61440|1.280000|61440|1.280000|1920|0.040000|N/A|N/A|7680|1647616|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|33|1.320000|33|1.320000|1|0.040000|N/A|N/A|150000|1710080|K_|1
-Strings Metadata|8
+Strings Metadata
 audio|1|63360|1.320000|63360|1.320000|1920|0.040000|N/A|N/A|7680|1860608|K_|1
-Strings Metadata|8
+Strings Metadata
 video|0|34|1.360000|34|1.360000|1|0.040000|N/A|N/A|150000|1923072|K_|1
-Strings Metadata|8
+Strings Metadata
 audio|1|65280|1.360000|65280|1.360000|1920|0.040000|N/A|N/A|7680|2073600|K_|1
-Strings Metadata|8
+Strings Metadata
 0|mpeg2video|0|video|1/25|[0][0][0][0]|0x0000|720|608|0|0|0|1:1|45:38|yuv422p|5|tv|unknown|unknown|unknown|topleft|tt|N/A|1|N/A|25/1|25/1|1/25|0|0.000000|N/A|N/A|30000000|N/A|N/A|N/A|N/A|35|0|0|0|0|0|0|0|0|0|0|0|0|0x060A2B340101010501010D001300000000000000000000000000000000000001
 1|pcm_s16le|unknown|audio|1/48000|[0][0][0][0]|0x0000|s16|48000|2|unknown|16|N/A|0/0|0/0|1/48000|0|0.000000|N/A|N/A|1536000|N/A|N/A|N/A|N/A|35|0|0|0|0|0|0|0|0|0|0|0|0|0x060A2B340101010501010D001300000000000000000000000000000000000001
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple2-lavf-ts b/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple2-lavf-ts
index 4cb9f5ca7a0..e5cf18bbcee 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple2-lavf-ts
+++ b/mythtv/external/FFmpeg/tests/ref/fate/concat-demuxer-simple2-lavf-ts
@@ -1,12 +1,21 @@
-video|1|982|0.010911|-2618|-0.029089|3600|0.040000|N/A|N/A|24815|564|K_
-video|1|4582|0.050911|982|0.010911|3600|0.040000|N/A|N/A|16443|27072|__
-video|1|8182|0.090911|4582|0.050911|3600|0.040000|N/A|N/A|14522|44932|__
-video|1|11782|0.130911|8182|0.090911|3600|0.040000|N/A|N/A|12636|60536|__
-video|1|15382|0.170911|11782|0.130911|3600|0.040000|N/A|N/A|13407|74260|__
-video|1|18982|0.210911|15382|0.170911|3600|0.040000|N/A|N/A|13106|88924|__
-video|1|22582|0.250911|18982|0.210911|3600|0.040000|N/A|N/A|12769|102836|__
-video|1|26182|0.290911|22582|0.250911|3600|0.040000|N/A|N/A|12037|116748|__
-audio|0|0|0.000000|0|0.000000|2351|0.026122|N/A|N/A|222|159988|K_
+video|1|982|0.010911|-2618|-0.029089|3600|0.040000|N/A|N/A|24801|564|K_MPEGTS Stream ID
+
+video|1|4582|0.050911|982|0.010911|3600|0.040000|N/A|N/A|16429|27072|__MPEGTS Stream ID
+
+video|1|8182|0.090911|4582|0.050911|3600|0.040000|N/A|N/A|14508|44932|__MPEGTS Stream ID
+
+video|1|11782|0.130911|8182|0.090911|3600|0.040000|N/A|N/A|12622|60536|__MPEGTS Stream ID
+
+video|1|15382|0.170911|11782|0.130911|3600|0.040000|N/A|N/A|13393|74260|__MPEGTS Stream ID
+
+video|1|18982|0.210911|15382|0.170911|3600|0.040000|N/A|N/A|13092|88924|__MPEGTS Stream ID
+
+video|1|22582|0.250911|18982|0.210911|3600|0.040000|N/A|N/A|12755|102836|__MPEGTS Stream ID
+
+video|1|26182|0.290911|22582|0.250911|3600|0.040000|N/A|N/A|12023|116748|__MPEGTS Stream ID
+
+audio|0|0|0.000000|0|0.000000|2351|0.026122|N/A|N/A|208|159988|K_MPEGTS Stream ID
+
 audio|0|2351|0.026122|2351|0.026122|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|4702|0.052244|4702|0.052244|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|7053|0.078367|7053|0.078367|2351|0.026122|N/A|N/A|209|N/A|K_
@@ -20,17 +29,28 @@ audio|0|23510|0.261222|23510|0.261222|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|25861|0.287344|25861|0.287344|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|28212|0.313467|28212|0.313467|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|30563|0.339589|30563|0.339589|2351|0.026122|N/A|N/A|209|N/A|K_
-video|1|29782|0.330911|26182|0.290911|3600|0.040000|N/A|N/A|14112|130096|__
-video|1|33382|0.370911|29782|0.330911|3600|0.040000|N/A|N/A|13343|145324|__
-video|1|36982|0.410911|33382|0.370911|3600|0.040000|N/A|N/A|12149|162996|__
-video|1|40582|0.450911|36982|0.410911|3600|0.040000|N/A|N/A|12296|176344|__
-video|1|44182|0.490911|40582|0.450911|3600|0.040000|N/A|N/A|24800|189692|K_
-video|1|47782|0.530911|44182|0.490911|3600|0.040000|N/A|N/A|17454|216388|__
-video|1|51382|0.570911|47782|0.530911|3600|0.040000|N/A|N/A|15033|235000|__
-video|1|54982|0.610911|51382|0.570911|3600|0.040000|N/A|N/A|13463|251356|__
-video|1|58582|0.650911|54982|0.610911|3600|0.040000|N/A|N/A|12412|266020|__
-video|1|62182|0.690911|58582|0.650911|3600|0.040000|N/A|N/A|13469|279744|__
-audio|0|32915|0.365722|32915|0.365722|2351|0.026122|N/A|N/A|223|322608|K_
+video|1|29782|0.330911|26182|0.290911|3600|0.040000|N/A|N/A|14098|130096|__MPEGTS Stream ID
+
+video|1|33382|0.370911|29782|0.330911|3600|0.040000|N/A|N/A|13329|145324|__MPEGTS Stream ID
+
+video|1|36982|0.410911|33382|0.370911|3600|0.040000|N/A|N/A|12135|162996|__MPEGTS Stream ID
+
+video|1|40582|0.450911|36982|0.410911|3600|0.040000|N/A|N/A|12282|176344|__MPEGTS Stream ID
+
+video|1|44182|0.490911|40582|0.450911|3600|0.040000|N/A|N/A|24786|189692|K_MPEGTS Stream ID
+
+video|1|47782|0.530911|44182|0.490911|3600|0.040000|N/A|N/A|17440|216388|__MPEGTS Stream ID
+
+video|1|51382|0.570911|47782|0.530911|3600|0.040000|N/A|N/A|15019|235000|__MPEGTS Stream ID
+
+video|1|54982|0.610911|51382|0.570911|3600|0.040000|N/A|N/A|13449|251356|__MPEGTS Stream ID
+
+video|1|58582|0.650911|54982|0.610911|3600|0.040000|N/A|N/A|12398|266020|__MPEGTS Stream ID
+
+video|1|62182|0.690911|58582|0.650911|3600|0.040000|N/A|N/A|13455|279744|__MPEGTS Stream ID
+
+audio|0|32915|0.365722|32915|0.365722|2351|0.026122|N/A|N/A|209|322608|K_MPEGTS Stream ID
+
 audio|0|35266|0.391844|35266|0.391844|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|37617|0.417967|37617|0.417967|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|39968|0.444089|39968|0.444089|2351|0.026122|N/A|N/A|209|N/A|K_
@@ -44,12 +64,18 @@ audio|0|56425|0.626944|56425|0.626944|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|58776|0.653067|58776|0.653067|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|61127|0.679189|61127|0.679189|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|63478|0.705311|63478|0.705311|2351|0.026122|N/A|N/A|209|N/A|K_
-video|1|65782|0.730911|62182|0.690911|3600|0.040000|N/A|N/A|13850|294408|__
-video|1|69382|0.770911|65782|0.730911|3600|0.040000|N/A|N/A|12177|309448|__
-video|1|72982|0.810911|69382|0.770911|3600|0.040000|N/A|N/A|12706|325992|__
-video|1|76582|0.850911|72982|0.810911|3600|0.040000|N/A|N/A|10838|339528|__
-video|1|80182|0.890911|76582|0.850911|3600|0.040000|N/A|N/A|11300|351372|__
-audio|0|65829|0.731433|65829|0.731433|2351|0.026122|N/A|N/A|223|404576|K_
+video|1|65782|0.730911|62182|0.690911|3600|0.040000|N/A|N/A|13836|294408|__MPEGTS Stream ID
+
+video|1|69382|0.770911|65782|0.730911|3600|0.040000|N/A|N/A|12163|309448|__MPEGTS Stream ID
+
+video|1|72982|0.810911|69382|0.770911|3600|0.040000|N/A|N/A|12692|325992|__MPEGTS Stream ID
+
+video|1|76582|0.850911|72982|0.810911|3600|0.040000|N/A|N/A|10824|339528|__MPEGTS Stream ID
+
+video|1|80182|0.890911|76582|0.850911|3600|0.040000|N/A|N/A|11286|351372|__MPEGTS Stream ID
+
+audio|0|65829|0.731433|65829|0.731433|2351|0.026122|N/A|N/A|209|404576|K_MPEGTS Stream ID
+
 audio|0|68180|0.757556|68180|0.757556|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|70531|0.783678|70531|0.783678|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|72882|0.809800|72882|0.809800|2351|0.026122|N/A|N/A|209|N/A|K_
@@ -60,17 +86,27 @@ audio|0|82286|0.914289|82286|0.914289|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|84637|0.940411|84637|0.940411|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|86988|0.966533|86988|0.966533|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|89339|0.992656|89339|0.992656|2351|0.026122|N/A|N/A|209|N/A|K_
-video|1|83782|0.930911|80182|0.890911|3600|0.040000|N/A|N/A|12692|363592|__
+video|1|83782|0.930911|80182|0.890911|3600|0.040000|N/A|N/A|12678|363592|__MPEGTS Stream ID
+
 video|1|87382|0.970911|83782|0.930911|3600|0.040000|N/A|N/A|24711|377880|K_
-video|1|91964|1.021822|88364|0.981822|3600|0.040000|N/A|N/A|24815|564|K_
-video|1|95564|1.061822|91964|1.021822|3600|0.040000|N/A|N/A|16443|27072|__
-video|1|99164|1.101822|95564|1.061822|3600|0.040000|N/A|N/A|14522|44932|__
-video|1|102764|1.141822|99164|1.101822|3600|0.040000|N/A|N/A|12636|60536|__
-video|1|106364|1.181822|102764|1.141822|3600|0.040000|N/A|N/A|13407|74260|__
-video|1|109964|1.221822|106364|1.181822|3600|0.040000|N/A|N/A|13106|88924|__
-video|1|113564|1.261822|109964|1.221822|3600|0.040000|N/A|N/A|12769|102836|__
-video|1|117164|1.301822|113564|1.261822|3600|0.040000|N/A|N/A|12037|116748|__
-audio|0|90982|1.010911|90982|1.010911|2351|0.026122|N/A|N/A|222|159988|K_
+video|1|91964|1.021822|88364|0.981822|3600|0.040000|N/A|N/A|24801|564|K_MPEGTS Stream ID
+
+video|1|95564|1.061822|91964|1.021822|3600|0.040000|N/A|N/A|16429|27072|__MPEGTS Stream ID
+
+video|1|99164|1.101822|95564|1.061822|3600|0.040000|N/A|N/A|14508|44932|__MPEGTS Stream ID
+
+video|1|102764|1.141822|99164|1.101822|3600|0.040000|N/A|N/A|12622|60536|__MPEGTS Stream ID
+
+video|1|106364|1.181822|102764|1.141822|3600|0.040000|N/A|N/A|13393|74260|__MPEGTS Stream ID
+
+video|1|109964|1.221822|106364|1.181822|3600|0.040000|N/A|N/A|13092|88924|__MPEGTS Stream ID
+
+video|1|113564|1.261822|109964|1.221822|3600|0.040000|N/A|N/A|12755|102836|__MPEGTS Stream ID
+
+video|1|117164|1.301822|113564|1.261822|3600|0.040000|N/A|N/A|12023|116748|__MPEGTS Stream ID
+
+audio|0|90982|1.010911|90982|1.010911|2351|0.026122|N/A|N/A|208|159988|K_MPEGTS Stream ID
+
 audio|0|93333|1.037033|93333|1.037033|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|95684|1.063156|95684|1.063156|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|98035|1.089278|98035|1.089278|2351|0.026122|N/A|N/A|209|N/A|K_
@@ -84,17 +120,28 @@ audio|0|114492|1.272133|114492|1.272133|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|116843|1.298256|116843|1.298256|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|119194|1.324378|119194|1.324378|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|121545|1.350500|121545|1.350500|2351|0.026122|N/A|N/A|209|N/A|K_
-video|1|120764|1.341822|117164|1.301822|3600|0.040000|N/A|N/A|14112|130096|__
-video|1|124364|1.381822|120764|1.341822|3600|0.040000|N/A|N/A|13343|145324|__
-video|1|127964|1.421822|124364|1.381822|3600|0.040000|N/A|N/A|12149|162996|__
-video|1|131564|1.461822|127964|1.421822|3600|0.040000|N/A|N/A|12296|176344|__
-video|1|135164|1.501822|131564|1.461822|3600|0.040000|N/A|N/A|24800|189692|K_
-video|1|138764|1.541822|135164|1.501822|3600|0.040000|N/A|N/A|17454|216388|__
-video|1|142364|1.581822|138764|1.541822|3600|0.040000|N/A|N/A|15033|235000|__
-video|1|145964|1.621822|142364|1.581822|3600|0.040000|N/A|N/A|13463|251356|__
-video|1|149564|1.661822|145964|1.621822|3600|0.040000|N/A|N/A|12412|266020|__
-video|1|153164|1.701822|149564|1.661822|3600|0.040000|N/A|N/A|13469|279744|__
-audio|0|123897|1.376633|123897|1.376633|2351|0.026122|N/A|N/A|223|322608|K_
+video|1|120764|1.341822|117164|1.301822|3600|0.040000|N/A|N/A|14098|130096|__MPEGTS Stream ID
+
+video|1|124364|1.381822|120764|1.341822|3600|0.040000|N/A|N/A|13329|145324|__MPEGTS Stream ID
+
+video|1|127964|1.421822|124364|1.381822|3600|0.040000|N/A|N/A|12135|162996|__MPEGTS Stream ID
+
+video|1|131564|1.461822|127964|1.421822|3600|0.040000|N/A|N/A|12282|176344|__MPEGTS Stream ID
+
+video|1|135164|1.501822|131564|1.461822|3600|0.040000|N/A|N/A|24786|189692|K_MPEGTS Stream ID
+
+video|1|138764|1.541822|135164|1.501822|3600|0.040000|N/A|N/A|17440|216388|__MPEGTS Stream ID
+
+video|1|142364|1.581822|138764|1.541822|3600|0.040000|N/A|N/A|15019|235000|__MPEGTS Stream ID
+
+video|1|145964|1.621822|142364|1.581822|3600|0.040000|N/A|N/A|13449|251356|__MPEGTS Stream ID
+
+video|1|149564|1.661822|145964|1.621822|3600|0.040000|N/A|N/A|12398|266020|__MPEGTS Stream ID
+
+video|1|153164|1.701822|149564|1.661822|3600|0.040000|N/A|N/A|13455|279744|__MPEGTS Stream ID
+
+audio|0|123897|1.376633|123897|1.376633|2351|0.026122|N/A|N/A|209|322608|K_MPEGTS Stream ID
+
 audio|0|126248|1.402756|126248|1.402756|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|128599|1.428878|128599|1.428878|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|130950|1.455000|130950|1.455000|2351|0.026122|N/A|N/A|209|N/A|K_
@@ -108,12 +155,18 @@ audio|0|147407|1.637856|147407|1.637856|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|149758|1.663978|149758|1.663978|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|152109|1.690100|152109|1.690100|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|154460|1.716222|154460|1.716222|2351|0.026122|N/A|N/A|209|N/A|K_
-video|1|156764|1.741822|153164|1.701822|3600|0.040000|N/A|N/A|13850|294408|__
-video|1|160364|1.781822|156764|1.741822|3600|0.040000|N/A|N/A|12177|309448|__
-video|1|163964|1.821822|160364|1.781822|3600|0.040000|N/A|N/A|12706|325992|__
-video|1|167564|1.861822|163964|1.821822|3600|0.040000|N/A|N/A|10838|339528|__
-video|1|171164|1.901822|167564|1.861822|3600|0.040000|N/A|N/A|11300|351372|__
-audio|0|156811|1.742344|156811|1.742344|2351|0.026122|N/A|N/A|223|404576|K_
+video|1|156764|1.741822|153164|1.701822|3600|0.040000|N/A|N/A|13836|294408|__MPEGTS Stream ID
+
+video|1|160364|1.781822|156764|1.741822|3600|0.040000|N/A|N/A|12163|309448|__MPEGTS Stream ID
+
+video|1|163964|1.821822|160364|1.781822|3600|0.040000|N/A|N/A|12692|325992|__MPEGTS Stream ID
+
+video|1|167564|1.861822|163964|1.821822|3600|0.040000|N/A|N/A|10824|339528|__MPEGTS Stream ID
+
+video|1|171164|1.901822|167564|1.861822|3600|0.040000|N/A|N/A|11286|351372|__MPEGTS Stream ID
+
+audio|0|156811|1.742344|156811|1.742344|2351|0.026122|N/A|N/A|209|404576|K_MPEGTS Stream ID
+
 audio|0|159162|1.768467|159162|1.768467|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|161513|1.794589|161513|1.794589|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|163864|1.820711|163864|1.820711|2351|0.026122|N/A|N/A|209|N/A|K_
@@ -124,12 +177,17 @@ audio|0|173268|1.925200|173268|1.925200|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|175619|1.951322|175619|1.951322|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|177970|1.977444|177970|1.977444|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|180321|2.003567|180321|2.003567|2351|0.026122|N/A|N/A|209|N/A|K_
-video|1|174764|1.941822|171164|1.901822|3600|0.040000|N/A|N/A|12692|363592|__
+video|1|174764|1.941822|171164|1.901822|3600|0.040000|N/A|N/A|12678|363592|__MPEGTS Stream ID
+
 video|1|178364|1.981822|174764|1.941822|3600|0.040000|N/A|N/A|24711|377880|K_
-video|1|139582|1.550911|135982|1.510911|3600|0.040000|N/A|N/A|12706|325992|__
-video|1|143182|1.590911|139582|1.550911|3600|0.040000|N/A|N/A|10838|339528|__
-video|1|146782|1.630911|143182|1.590911|3600|0.040000|N/A|N/A|11300|351372|__
-audio|0|132429|1.471433|132429|1.471433|2351|0.026122|N/A|N/A|223|404576|K_
+video|1|139582|1.550911|135982|1.510911|3600|0.040000|N/A|N/A|12692|325992|__MPEGTS Stream ID
+
+video|1|143182|1.590911|139582|1.550911|3600|0.040000|N/A|N/A|10824|339528|__MPEGTS Stream ID
+
+video|1|146782|1.630911|143182|1.590911|3600|0.040000|N/A|N/A|11286|351372|__MPEGTS Stream ID
+
+audio|0|132429|1.471433|132429|1.471433|2351|0.026122|N/A|N/A|209|404576|K_MPEGTS Stream ID
+
 audio|0|134780|1.497556|134780|1.497556|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|137131|1.523678|137131|1.523678|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|139482|1.549800|139482|1.549800|2351|0.026122|N/A|N/A|209|N/A|K_
@@ -140,12 +198,18 @@ audio|0|148886|1.654289|148886|1.654289|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|151237|1.680411|151237|1.680411|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|153588|1.706533|153588|1.706533|2351|0.026122|N/A|N/A|209|N/A|K_
 audio|0|155939|1.732656|155939|1.732656|2351|0.026122|N/A|N/A|209|N/A|K_
-video|1|150382|1.670911|146782|1.630911|3600|0.040000|N/A|N/A|12692|363592|__
+video|1|150382|1.670911|146782|1.630911|3600|0.040000|N/A|N/A|12678|363592|__MPEGTS Stream ID
+
 video|1|153982|1.710911|150382|1.670911|3600|0.040000|N/A|N/A|24711|377880|K_
-video|1|161182|1.790911|157582|1.750911|3600|0.040000|N/A|N/A|12149|162996|__
-video|1|164782|1.830911|161182|1.790911|3600|0.040000|N/A|N/A|12296|176344|__
-video|1|168382|1.870911|164782|1.830911|3600|0.040000|N/A|N/A|24800|189692|K_
-video|1|171982|1.910911|168382|1.870911|3600|0.040000|N/A|N/A|17454|216388|__
-video|1|175582|1.950911|171982|1.910911|3600|0.040000|N/A|N/A|15033|235000|__
+video|1|161182|1.790911|157582|1.750911|3600|0.040000|N/A|N/A|12135|162996|__MPEGTS Stream ID
+
+video|1|164782|1.830911|161182|1.790911|3600|0.040000|N/A|N/A|12282|176344|__MPEGTS Stream ID
+
+video|1|168382|1.870911|164782|1.830911|3600|0.040000|N/A|N/A|24786|189692|K_MPEGTS Stream ID
+
+video|1|171982|1.910911|168382|1.870911|3600|0.040000|N/A|N/A|17440|216388|__MPEGTS Stream ID
+
+video|1|175582|1.950911|171982|1.910911|3600|0.040000|N/A|N/A|15019|235000|__MPEGTS Stream ID
+
 0|mp2|unknown|audio|1/44100|[3][0][0][0]|0x0003|s16p|44100|1|mono|0|N/A|0/0|0/0|1/90000|0|0.000000|N/A|N/A|64000|N/A|N/A|N/A|N/A|89|0|0|0|0|0|0|0|0|0|0|0|0
 1|mpeg2video|4|video|1/25|[2][0][0][0]|0x0002|352|288|0|0|1|1:1|11:9|yuv420p|8|tv|unknown|unknown|unknown|left|progressive|N/A|1|N/A|25/1|25/1|1/90000|N/A|N/A|N/A|N/A|N/A|N/A|N/A|N/A|N/A|60|0|0|0|0|0|0|0|0|0|0|0|0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/copy-psp b/mythtv/external/FFmpeg/tests/ref/fate/copy-psp
index 7089f489376..81eb172549d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/copy-psp
+++ b/mythtv/external/FFmpeg/tests/ref/fate/copy-psp
@@ -1,5 +1,5 @@
-6889223644fc560069c8591984175a62 *tests/data/fate/copy-psp.psp
-2041379 tests/data/fate/copy-psp.psp
+cada61453a2483ef8ba1fb82c8bbff25 *tests/data/fate/copy-psp.psp
+2041433 tests/data/fate/copy-psp.psp
 #extradata 0:       51, 0xaf6d1012
 #extradata 1:        2, 0x00b200a1
 #tb 0: 1/90000
@@ -12,6 +12,7 @@
 #codec_id 1: aac
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,     3003,    37084, 0x021a0d3f
 1,          0,          0,     1024,       10, 0x0e270398
 1,       1024,       1024,     1025,       10, 0x0f4703b8
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/copy-trac2211-avi b/mythtv/external/FFmpeg/tests/ref/fate/copy-trac2211-avi
index c22ca3d4da7..007349e5727 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/copy-trac2211-avi
+++ b/mythtv/external/FFmpeg/tests/ref/fate/copy-trac2211-avi
@@ -1,5 +1,5 @@
-dd199ecb167b2fa0fc0c17638a655e1c *tests/data/fate/copy-trac2211-avi.avi
-1777926 tests/data/fate/copy-trac2211-avi.avi
+6f6b211cbc8de9871e8e09e64048e2f9 *tests/data/fate/copy-trac2211-avi.avi
+1777924 tests/data/fate/copy-trac2211-avi.avi
 #tb 0: 1/14
 #media_type 0: video
 #codec_id 0: rawvideo
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/copy-trac236 b/mythtv/external/FFmpeg/tests/ref/fate/copy-trac236
index 167446c27ea..c5240ca3d37 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/copy-trac236
+++ b/mythtv/external/FFmpeg/tests/ref/fate/copy-trac236
@@ -10,6 +10,7 @@ d6e3d97b522ce881ed29c5da74cc7e63 *tests/data/fate/copy-trac236.mov
 #codec_id 1: pcm_s16le
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,        1,   518400, 0x81ab2140
 1,          0,          0,     1024,     4096, 0x67dc99a3
 1,       1024,       1024,     1024,     4096, 0xf115a681
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/copy-trac3074 b/mythtv/external/FFmpeg/tests/ref/fate/copy-trac3074
new file mode 100644
index 00000000000..5ce56942604
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/copy-trac3074
@@ -0,0 +1,659 @@
+39aef1afff761d673fd1be07182941d1 *tests/data/fate/copy-trac3074.mp4
+333991 tests/data/fate/copy-trac3074.mp4
+#tb 0: 1/48000
+#media_type 0: audio
+#codec_id 0: eac3
+#sample_rate 0: 48000
+#channel_layout 0: 3
+#channel_layout_name 0: stereo
+0,          0,          0,     1536,      512, 0x2beaf79f, S=1,        4, 0x00000000
+0,       1536,       1536,     1536,      512, 0x29ddf9d6
+0,       3072,       3072,     1536,      512, 0xba0afa79
+0,       4608,       4608,     1536,      512, 0xe019f394
+0,       6144,       6144,     1536,      512, 0xf501f5ab
+0,       7680,       7680,     1536,      512, 0x5ed3f35c
+0,       9216,       9216,     1536,      512, 0xb2a5f67b
+0,      10752,      10752,     1536,      512, 0xdab3f328
+0,      12288,      12288,     1536,      512, 0x490dfa2e
+0,      13824,      13824,     1536,      512, 0x26dffa1d
+0,      15360,      15360,     1536,      512, 0xa8daf5cd
+0,      16896,      16896,     1536,      512, 0x823a01e1
+0,      18432,      18432,     1536,      512, 0xf2feee89
+0,      19968,      19968,     1536,      512, 0x58f5ebe2
+0,      21504,      21504,     1536,      512, 0x8618f679
+0,      23040,      23040,     1536,      512, 0xfbe3f0e9
+0,      24576,      24576,     1536,      512, 0xadc3f479
+0,      26112,      26112,     1536,      512, 0xe85ef861
+0,      27648,      27648,     1536,      512, 0x788cf985
+0,      29184,      29184,     1536,      512, 0x44cf00c1
+0,      30720,      30720,     1536,      512, 0x3398fbf8
+0,      32256,      32256,     1536,      512, 0xfbfafc32
+0,      33792,      33792,     1536,      512, 0x68fdf9db
+0,      35328,      35328,     1536,      512, 0xb848f4fa
+0,      36864,      36864,     1536,      512, 0x245af55e
+0,      38400,      38400,     1536,      512, 0x5027f295
+0,      39936,      39936,     1536,      512, 0x7d74f988
+0,      41472,      41472,     1536,      512, 0x7179f92d
+0,      43008,      43008,     1536,      512, 0xb2eff797
+0,      44544,      44544,     1536,      512, 0x1625f5fa
+0,      46080,      46080,     1536,      512, 0x3682f8b4
+0,      47616,      47616,     1536,      512, 0xc9e3f9a6
+0,      49152,      49152,     1536,      512, 0x1fd50294
+0,      50688,      50688,     1536,      512, 0xacd0f967
+0,      52224,      52224,     1536,      512, 0xfce1f614
+0,      53760,      53760,     1536,      512, 0x8a96f555
+0,      55296,      55296,     1536,      512, 0xeb93e8eb
+0,      56832,      56832,     1536,      512, 0x3d63f049
+0,      58368,      58368,     1536,      512, 0x92ffefa2
+0,      59904,      59904,     1536,      512, 0x634ced64
+0,      61440,      61440,     1536,      512, 0xf372f256
+0,      62976,      62976,     1536,      512, 0xef28ec45
+0,      64512,      64512,     1536,      512, 0x0973f647
+0,      66048,      66048,     1536,      512, 0x11e1f7d9
+0,      67584,      67584,     1536,      512, 0x63ccf4f7
+0,      69120,      69120,     1536,      512, 0xa0e4f3c8
+0,      70656,      70656,     1536,      512, 0x0ab3f11a
+0,      72192,      72192,     1536,      512, 0xcbf8f8a2
+0,      73728,      73728,     1536,      512, 0xb102ff6f
+0,      75264,      75264,     1536,      512, 0xbfa6ff2f
+0,      76800,      76800,     1536,      512, 0xc88301c4
+0,      78336,      78336,     1536,      512, 0xab08f52a
+0,      79872,      79872,     1536,      512, 0x9401f177
+0,      81408,      81408,     1536,      512, 0xd8faf12c
+0,      82944,      82944,     1536,      512, 0x9f19f770
+0,      84480,      84480,     1536,      512, 0x27eaf637
+0,      86016,      86016,     1536,      512, 0xdaa4f256
+0,      87552,      87552,     1536,      512, 0x6170f6ef
+0,      89088,      89088,     1536,      512, 0xeaf8fee4
+0,      90624,      90624,     1536,      512, 0xd438f881
+0,      92160,      92160,     1536,      512, 0x9970f701
+0,      93696,      93696,     1536,      512, 0x9d9af25c
+0,      95232,      95232,     1536,      512, 0xa9ee049e
+0,      96768,      96768,     1536,      512, 0xe87af4a7
+0,      98304,      98304,     1536,      512, 0x5776f68a
+0,      99840,      99840,     1536,      512, 0xce3af291
+0,     101376,     101376,     1536,      512, 0x4994f1e9
+0,     102912,     102912,     1536,      512, 0x97d8f8e4
+0,     104448,     104448,     1536,      512, 0x1b03f2bb
+0,     105984,     105984,     1536,      512, 0xa674ede4
+0,     107520,     107520,     1536,      512, 0x9607eede
+0,     109056,     109056,     1536,      512, 0xf225ed64
+0,     110592,     110592,     1536,      512, 0xa59ff1af
+0,     112128,     112128,     1536,      512, 0xa73cf082
+0,     113664,     113664,     1536,      512, 0xb504f86f
+0,     115200,     115200,     1536,      512, 0x3e7cf849
+0,     116736,     116736,     1536,      512, 0x2625f150
+0,     118272,     118272,     1536,      512, 0x8dc7fa6c
+0,     119808,     119808,     1536,      512, 0x4116f6fb
+0,     121344,     121344,     1536,      512, 0xfb41f025
+0,     122880,     122880,     1536,      512, 0xf2ddf047
+0,     124416,     124416,     1536,      512, 0x3e3af43d
+0,     125952,     125952,     1536,      512, 0xbd12031c
+0,     127488,     127488,     1536,      512, 0x144bfa82
+0,     129024,     129024,     1536,      512, 0x4221f8b4
+0,     130560,     130560,     1536,      512, 0x95e1f375
+0,     132096,     132096,     1536,      512, 0x15a1e638
+0,     133632,     133632,     1536,      512, 0x3945f461
+0,     135168,     135168,     1536,      512, 0xa95ef996
+0,     136704,     136704,     1536,      512, 0x84caee4a
+0,     138240,     138240,     1536,      512, 0x0339f13a
+0,     139776,     139776,     1536,      512, 0x010c01b5
+0,     141312,     141312,     1536,      512, 0xb042eb63
+0,     142848,     142848,     1536,      512, 0x1d30f50b
+0,     144384,     144384,     1536,      512, 0x8ef1f411
+0,     145920,     145920,     1536,      512, 0x1f68f161
+0,     147456,     147456,     1536,      512, 0xc2a002e2
+0,     148992,     148992,     1536,      512, 0x87bef3a3
+0,     150528,     150528,     1536,      512, 0xee24fc34
+0,     152064,     152064,     1536,      512, 0x0de2f86f
+0,     153600,     153600,     1536,      512, 0xda6ef5c5
+0,     155136,     155136,     1536,      512, 0x538ef1b3
+0,     156672,     156672,     1536,      512, 0x059befac
+0,     158208,     158208,     1536,      512, 0x0fedfa87
+0,     159744,     159744,     1536,      512, 0x8f04f38c
+0,     161280,     161280,     1536,      512, 0x4195f4fa
+0,     162816,     162816,     1536,      512, 0x36e5fa8a
+0,     164352,     164352,     1536,      512, 0x27cdf74e
+0,     165888,     165888,     1536,      512, 0x0a7dee39
+0,     167424,     167424,     1536,      512, 0xb143f9fe
+0,     168960,     168960,     1536,      512, 0x57dff4eb
+0,     170496,     170496,     1536,      512, 0xbf56ee82
+0,     172032,     172032,     1536,      512, 0x8752f6a5
+0,     173568,     173568,     1536,      512, 0xa647fd42
+0,     175104,     175104,     1536,      512, 0xe8f9eb59
+0,     176640,     176640,     1536,      512, 0xba0aeb49
+0,     178176,     178176,     1536,      512, 0xaa42f9f6
+0,     179712,     179712,     1536,      512, 0xc664ed11
+0,     181248,     181248,     1536,      512, 0xbcaaf855
+0,     182784,     182784,     1536,      512, 0x2631f9ed
+0,     184320,     184320,     1536,      512, 0xc4f8f251
+0,     185856,     185856,     1536,      512, 0x1fc2f2af
+0,     187392,     187392,     1536,      512, 0xdd2ff3c7
+0,     188928,     188928,     1536,      512, 0xb783f7f9
+0,     190464,     190464,     1536,      512, 0xf6acf1cb
+0,     192000,     192000,     1536,      512, 0x1db2fb58
+0,     193536,     193536,     1536,      512, 0x2241e93d
+0,     195072,     195072,     1536,      512, 0x619bf1bf
+0,     196608,     196608,     1536,      512, 0xe3ddf0ce
+0,     198144,     198144,     1536,      512, 0xd94af1be
+0,     199680,     199680,     1536,      512, 0xc899f2ab
+0,     201216,     201216,     1536,      512, 0xd044f1f7
+0,     202752,     202752,     1536,      512, 0xce7507a7
+0,     204288,     204288,     1536,      512, 0x2421e95b
+0,     205824,     205824,     1536,      512, 0x2c52f48c
+0,     207360,     207360,     1536,      512, 0xda31fc4e
+0,     208896,     208896,     1536,      512, 0xb8dcfdda
+0,     210432,     210432,     1536,      512, 0xccc6f055
+0,     211968,     211968,     1536,      512, 0x8c01f9d9
+0,     213504,     213504,     1536,      512, 0xcf36ec40
+0,     215040,     215040,     1536,      512, 0x5bcafa5c
+0,     216576,     216576,     1536,      512, 0xb756f560
+0,     218112,     218112,     1536,      512, 0x1849f744
+0,     219648,     219648,     1536,      512, 0x9d9bf5ac
+0,     221184,     221184,     1536,      512, 0xaea3f847
+0,     222720,     222720,     1536,      512, 0xfd84f817
+0,     224256,     224256,     1536,      512, 0x5ba0ed29
+0,     225792,     225792,     1536,      512, 0xd3b3f400
+0,     227328,     227328,     1536,      512, 0x6156f6d9
+0,     228864,     228864,     1536,      512, 0xdbc8f4b9
+0,     230400,     230400,     1536,      512, 0x4a48fbe3
+0,     231936,     231936,     1536,      512, 0x7c3cf3ed
+0,     233472,     233472,     1536,      512, 0x078eefa2
+0,     235008,     235008,     1536,      512, 0x6b02ec30
+0,     236544,     236544,     1536,      512, 0xa0daf283
+0,     238080,     238080,     1536,      512, 0x6c33f746
+0,     239616,     239616,     1536,      512, 0x38cff4c4
+0,     241152,     241152,     1536,      512, 0xe84cf3fe
+0,     242688,     242688,     1536,      512, 0x1a4cfda0
+0,     244224,     244224,     1536,      512, 0x5590f98b
+0,     245760,     245760,     1536,      512, 0xbf90f59b
+0,     247296,     247296,     1536,      512, 0x3f14f53c
+0,     248832,     248832,     1536,      512, 0x12c2ef31
+0,     250368,     250368,     1536,      512, 0xd743f1b0
+0,     251904,     251904,     1536,      512, 0x0ee4f04e
+0,     253440,     253440,     1536,      512, 0x0c26f820
+0,     254976,     254976,     1536,      512, 0x4049eb94
+0,     256512,     256512,     1536,      512, 0x89f5f9a2
+0,     258048,     258048,     1536,      512, 0x17d6f6b0
+0,     259584,     259584,     1536,      512, 0x4d2bf5ae
+0,     261120,     261120,     1536,      512, 0x2c20f897
+0,     262656,     262656,     1536,      512, 0xe544f11f
+0,     264192,     264192,     1536,      512, 0xcaa8f65c
+0,     265728,     265728,     1536,      512, 0x1fe6f579
+0,     267264,     267264,     1536,      512, 0x0e85f278
+0,     268800,     268800,     1536,      512, 0x8eddf38c
+0,     270336,     270336,     1536,      512, 0x1ea0f289
+0,     271872,     271872,     1536,      512, 0xd76b0034
+0,     273408,     273408,     1536,      512, 0xbe49f9d1
+0,     274944,     274944,     1536,      512, 0xdc3dfded
+0,     276480,     276480,     1536,      512, 0x8143f179
+0,     278016,     278016,     1536,      512, 0x6af6f624
+0,     279552,     279552,     1536,      512, 0x638cf7c9
+0,     281088,     281088,     1536,      512, 0xe1e7f4f1
+0,     282624,     282624,     1536,      512, 0xcfbdefd2
+0,     284160,     284160,     1536,      512, 0xae49ecfe
+0,     285696,     285696,     1536,      512, 0xdfc8ed5f
+0,     287232,     287232,     1536,      512, 0xedd9f0b0
+0,     288768,     288768,     1536,      512, 0xc192f77b
+0,     290304,     290304,     1536,      512, 0x88330350
+0,     291840,     291840,     1536,      512, 0x589cfdcc
+0,     293376,     293376,     1536,      512, 0x722afae6
+0,     294912,     294912,     1536,      512, 0x5ab9f3cf
+0,     296448,     296448,     1536,      512, 0x2dc20161
+0,     297984,     297984,     1536,      512, 0x5117f4e7
+0,     299520,     299520,     1536,      512, 0xaa010049
+0,     301056,     301056,     1536,      512, 0xb5fcf73e
+0,     302592,     302592,     1536,      512, 0x66afe3ef
+0,     304128,     304128,     1536,      512, 0x3d7bf815
+0,     305664,     305664,     1536,      512, 0x6895ea7c
+0,     307200,     307200,     1536,      512, 0x26bbf14e
+0,     308736,     308736,     1536,      512, 0x5856ed50
+0,     310272,     310272,     1536,      512, 0x86e4eb6d
+0,     311808,     311808,     1536,      512, 0xf68dfbf7
+0,     313344,     313344,     1536,      512, 0x201ff70d
+0,     314880,     314880,     1536,      512, 0xdd15e87a
+0,     316416,     316416,     1536,      512, 0x50e8fa44
+0,     317952,     317952,     1536,      512, 0x1442f398
+0,     319488,     319488,     1536,      512, 0xe2e9f40b
+0,     321024,     321024,     1536,      512, 0xcbfdf354
+0,     322560,     322560,     1536,      512, 0x631100f3
+0,     324096,     324096,     1536,      512, 0x3aa6f9ea
+0,     325632,     325632,     1536,      512, 0xb6c5f5e6
+0,     327168,     327168,     1536,      512, 0xe98df623
+0,     328704,     328704,     1536,      512, 0x449dfb59
+0,     330240,     330240,     1536,      512, 0x4faefbb6
+0,     331776,     331776,     1536,      512, 0xcef1eb38
+0,     333312,     333312,     1536,      512, 0x94fcfcf5
+0,     334848,     334848,     1536,      512, 0x2bcaf97f
+0,     336384,     336384,     1536,      512, 0xba8af49c
+0,     337920,     337920,     1536,      512, 0xad64fc39
+0,     339456,     339456,     1536,      512, 0xb2a2f9fe
+0,     340992,     340992,     1536,      512, 0xc96105a3
+0,     342528,     342528,     1536,      512, 0x20c2f7ca
+0,     344064,     344064,     1536,      512, 0x5ccdfa46
+0,     345600,     345600,     1536,      512, 0x95eef21c
+0,     347136,     347136,     1536,      512, 0xafa9fad1
+0,     348672,     348672,     1536,      512, 0x3134f5cd
+0,     350208,     350208,     1536,      512, 0xbb08f702
+0,     351744,     351744,     1536,      512, 0x2829f1a0
+0,     353280,     353280,     1536,      512, 0x1a16fe88
+0,     354816,     354816,     1536,      512, 0x6d87f5cd
+0,     356352,     356352,     1536,      512, 0x8170f89a
+0,     357888,     357888,     1536,      512, 0xc99df656
+0,     359424,     359424,     1536,      512, 0x2015f2f0
+0,     360960,     360960,     1536,      512, 0x093df67d
+0,     362496,     362496,     1536,      512, 0xaa35ee1a
+0,     364032,     364032,     1536,      512, 0xc6caee7e
+0,     365568,     365568,     1536,      512, 0xc97bf536
+0,     367104,     367104,     1536,      512, 0x7a37f73b
+0,     368640,     368640,     1536,      512, 0xa2cdee4d
+0,     370176,     370176,     1536,      512, 0xefd5016c
+0,     371712,     371712,     1536,      512, 0x562ef6da
+0,     373248,     373248,     1536,      512, 0x4203f1ed
+0,     374784,     374784,     1536,      512, 0x5ec7f7f0
+0,     376320,     376320,     1536,      512, 0x156ff026
+0,     377856,     377856,     1536,      512, 0xcba8fc0a
+0,     379392,     379392,     1536,      512, 0x420b03c3
+0,     380928,     380928,     1536,      512, 0x37f0f2be
+0,     382464,     382464,     1536,      512, 0x35d0fc17
+0,     384000,     384000,     1536,      512, 0x1d30f537
+0,     385536,     385536,     1536,      512, 0x5a84e506
+0,     387072,     387072,     1536,      512, 0x2fd8eba5
+0,     388608,     388608,     1536,      512, 0x3271f624
+0,     390144,     390144,     1536,      512, 0xdcc4ea3b
+0,     391680,     391680,     1536,      512, 0x0d76ee13
+0,     393216,     393216,     1536,      512, 0xba46f2a5
+0,     394752,     394752,     1536,      512, 0xb1540424
+0,     396288,     396288,     1536,      512, 0x0c88fae6
+0,     397824,     397824,     1536,      512, 0xe879f89b
+0,     399360,     399360,     1536,      512, 0xae96f934
+0,     400896,     400896,     1536,      512, 0xc17405ec
+0,     402432,     402432,     1536,      512, 0x95b8f486
+0,     403968,     403968,     1536,      512, 0x03bbf5a9
+0,     405504,     405504,     1536,      512, 0x63eaf8d6
+0,     407040,     407040,     1536,      512, 0x7a6bfa96
+0,     408576,     408576,     1536,      512, 0x2eabee80
+0,     410112,     410112,     1536,      512, 0x8693f3c1
+0,     411648,     411648,     1536,      512, 0xc8b6f42a
+0,     413184,     413184,     1536,      512, 0x9b5bf344
+0,     414720,     414720,     1536,      512, 0xda81f513
+0,     416256,     416256,     1536,      512, 0x4789fa4d
+0,     417792,     417792,     1536,      512, 0xe70aed30
+0,     419328,     419328,     1536,      512, 0x0e51f579
+0,     420864,     420864,     1536,      512, 0x171503c9
+0,     422400,     422400,     1536,      512, 0xc965f98c
+0,     423936,     423936,     1536,      512, 0x816ef627
+0,     425472,     425472,     1536,      512, 0x441ceb6c
+0,     427008,     427008,     1536,      512, 0xedbcf1e5
+0,     428544,     428544,     1536,      512, 0x1168fec7
+0,     430080,     430080,     1536,      512, 0x488afa1e
+0,     431616,     431616,     1536,      512, 0x6d1dec39
+0,     433152,     433152,     1536,      512, 0x54c7f611
+0,     434688,     434688,     1536,      512, 0x0803eae6
+0,     436224,     436224,     1536,      512, 0xcd85eb6d
+0,     437760,     437760,     1536,      512, 0x3f920034
+0,     439296,     439296,     1536,      512, 0x4b55ea47
+0,     440832,     440832,     1536,      512, 0xdfd7f681
+0,     442368,     442368,     1536,      512, 0x20ccef96
+0,     443904,     443904,     1536,      512, 0x122cf656
+0,     445440,     445440,     1536,      512, 0xe38fef19
+0,     446976,     446976,     1536,      512, 0xa11ff565
+0,     448512,     448512,     1536,      512, 0x931cf83e
+0,     450048,     450048,     1536,      512, 0xb854010c
+0,     451584,     451584,     1536,      512, 0xf607f233
+0,     453120,     453120,     1536,      512, 0xfd9de7e9
+0,     454656,     454656,     1536,      512, 0xe401fa53
+0,     456192,     456192,     1536,      512, 0x15aef9f2
+0,     457728,     457728,     1536,      512, 0x0071f50e
+0,     459264,     459264,     1536,      512, 0xa3c7f029
+0,     460800,     460800,     1536,      512, 0x9b73ed64
+0,     462336,     462336,     1536,      512, 0x0087fbea
+0,     463872,     463872,     1536,      512, 0x9871effb
+0,     465408,     465408,     1536,      512, 0x0e36ebe3
+0,     466944,     466944,     1536,      512, 0x982e015e
+0,     468480,     468480,     1536,      512, 0xca67f667
+0,     470016,     470016,     1536,      512, 0xc504fd51
+0,     471552,     471552,     1536,      512, 0xf5c7f167
+0,     473088,     473088,     1536,      512, 0x75aaece8
+0,     474624,     474624,     1536,      512, 0x288effcf
+0,     476160,     476160,     1536,      512, 0xb640f057
+0,     477696,     477696,     1536,      512, 0xbb7cf4a9
+0,     479232,     479232,     1536,      512, 0xccf200d6
+0,     480768,     480768,     1536,      512, 0x1a00f229
+0,     482304,     482304,     1536,      512, 0xa95bf1be
+0,     483840,     483840,     1536,      512, 0x3c1af28d
+0,     485376,     485376,     1536,      512, 0x11d1ef54
+0,     486912,     486912,     1536,      512, 0xf9ae02aa
+0,     488448,     488448,     1536,      512, 0x4476ee68
+0,     489984,     489984,     1536,      512, 0x7f43eb80
+0,     491520,     491520,     1536,      512, 0x245af906
+0,     493056,     493056,     1536,      512, 0xbb06f0a8
+0,     494592,     494592,     1536,      512, 0xe51bf461
+0,     496128,     496128,     1536,      512, 0xd767f7fd
+0,     497664,     497664,     1536,      512, 0xd517f1ca
+0,     499200,     499200,     1536,      512, 0x3311eb45
+0,     500736,     500736,     1536,      512, 0xee0ef61e
+0,     502272,     502272,     1536,      512, 0x9e7cfe9b
+0,     503808,     503808,     1536,      512, 0x353ef03a
+0,     505344,     505344,     1536,      512, 0x92f6fcfa
+0,     506880,     506880,     1536,      512, 0xe458f3d0
+0,     508416,     508416,     1536,      512, 0xebf3f8af
+0,     509952,     509952,     1536,      512, 0xc0f6f981
+0,     511488,     511488,     1536,      512, 0x3e31fb6c
+0,     513024,     513024,     1536,      512, 0xd679031b
+0,     514560,     514560,     1536,      512, 0x6571f361
+0,     516096,     516096,     1536,      512, 0xf410f507
+0,     517632,     517632,     1536,      512, 0x2217f817
+0,     519168,     519168,     1536,      512, 0xaa53f6ee
+0,     520704,     520704,     1536,      512, 0xa574fa14
+0,     522240,     522240,     1536,      512, 0xcd7ff09d
+0,     523776,     523776,     1536,      512, 0xa650f7d6
+0,     525312,     525312,     1536,      512, 0x6b4ff467
+0,     526848,     526848,     1536,      512, 0x9355f3cb
+0,     528384,     528384,     1536,      512, 0x7546eb8b
+0,     529920,     529920,     1536,      512, 0x4ac6f4c8
+0,     531456,     531456,     1536,      512, 0xcf69f62c
+0,     532992,     532992,     1536,      512, 0x93a0e35d
+0,     534528,     534528,     1536,      512, 0x60c5f0f5
+0,     536064,     536064,     1536,      512, 0x75a4fb42
+0,     537600,     537600,     1536,      512, 0x2615ff1f
+0,     539136,     539136,     1536,      512, 0xb95df9a2
+0,     540672,     540672,     1536,      512, 0xb8c5fafb
+0,     542208,     542208,     1536,      512, 0x3465fd2b
+0,     543744,     543744,     1536,      512, 0xa758f489
+0,     545280,     545280,     1536,      512, 0xe4bafd7f
+0,     546816,     546816,     1536,      512, 0xfa45f603
+0,     548352,     548352,     1536,      512, 0x875b04f1
+0,     549888,     549888,     1536,      512, 0x171bf602
+0,     551424,     551424,     1536,      512, 0x557cf2fd
+0,     552960,     552960,     1536,      512, 0x3a4303c0
+0,     554496,     554496,     1536,      512, 0xbd0feef3
+0,     556032,     556032,     1536,      512, 0x3ca3ed7f
+0,     557568,     557568,     1536,      512, 0x4a4bf0b3
+0,     559104,     559104,     1536,      512, 0xdef5f4a3
+0,     560640,     560640,     1536,      512, 0x96a7f939
+0,     562176,     562176,     1536,      512, 0x3dc4f2fb
+0,     563712,     563712,     1536,      512, 0xa323ec80
+0,     565248,     565248,     1536,      512, 0x8b49eebf
+0,     566784,     566784,     1536,      512, 0xb4a3f983
+0,     568320,     568320,     1536,      512, 0x5a61ecf5
+0,     569856,     569856,     1536,      512, 0x10b0dbda
+0,     571392,     571392,     1536,      512, 0x4836f474
+0,     572928,     572928,     1536,      512, 0xe6f1ee87
+0,     574464,     574464,     1536,      512, 0x1e1bf474
+0,     576000,     576000,     1536,      512, 0xe25bf263
+0,     577536,     577536,     1536,      512, 0x29a9f348
+0,     579072,     579072,     1536,      512, 0x8cf6f85d
+0,     580608,     580608,     1536,      512, 0x3690f40a
+0,     582144,     582144,     1536,      512, 0x072dfcb5
+0,     583680,     583680,     1536,      512, 0x9611f8c7
+0,     585216,     585216,     1536,      512, 0x3ee7f622
+0,     586752,     586752,     1536,      512, 0xdb37f787
+0,     588288,     588288,     1536,      512, 0xc09bf2e3
+0,     589824,     589824,     1536,      512, 0xae37f9ea
+0,     591360,     591360,     1536,      512, 0x2764f6b0
+0,     592896,     592896,     1536,      512, 0x871be490
+0,     594432,     594432,     1536,      512, 0x2e7cefca
+0,     595968,     595968,     1536,      512, 0x000dece5
+0,     597504,     597504,     1536,      512, 0xbe9bea16
+0,     599040,     599040,     1536,      512, 0x202cf37c
+0,     600576,     600576,     1536,      512, 0xae02fa29
+0,     602112,     602112,     1536,      512, 0x5eb4efc9
+0,     603648,     603648,     1536,      512, 0x7a82ffce
+0,     605184,     605184,     1536,      512, 0x4c0fefb2
+0,     606720,     606720,     1536,      512, 0x0d55fd52
+0,     608256,     608256,     1536,      512, 0x00c8f568
+0,     609792,     609792,     1536,      512, 0x9d9ef306
+0,     611328,     611328,     1536,      512, 0x53bbf79c
+0,     612864,     612864,     1536,      512, 0xf1fbf3f4
+0,     614400,     614400,     1536,      512, 0x0ae0ed0b
+0,     615936,     615936,     1536,      512, 0x3374ffc1
+0,     617472,     617472,     1536,      512, 0xbba1f546
+0,     619008,     619008,     1536,      512, 0xaffeee35
+0,     620544,     620544,     1536,      512, 0x81dff38d
+0,     622080,     622080,     1536,      512, 0x29edeafb
+0,     623616,     623616,     1536,      512, 0x406fecbe
+0,     625152,     625152,     1536,      512, 0xee28f8dc
+0,     626688,     626688,     1536,      512, 0x4b1af28a
+0,     628224,     628224,     1536,      512, 0x83ab0058
+0,     629760,     629760,     1536,      512, 0x25d0f735
+0,     631296,     631296,     1536,      512, 0xec5ff319
+0,     632832,     632832,     1536,      512, 0x1723f121
+0,     634368,     634368,     1536,      512, 0x266cedd8
+0,     635904,     635904,     1536,      512, 0x15b1031a
+0,     637440,     637440,     1536,      512, 0x4a83f6b6
+0,     638976,     638976,     1536,      512, 0x8cd1fb9f
+0,     640512,     640512,     1536,      512, 0x76f4f696
+0,     642048,     642048,     1536,      512, 0x9c04fa16
+0,     643584,     643584,     1536,      512, 0x5d1600ce
+0,     645120,     645120,     1536,      512, 0x40d9f905
+0,     646656,     646656,     1536,      512, 0xb9eef26c
+0,     648192,     648192,     1536,      512, 0x5557ed03
+0,     649728,     649728,     1536,      512, 0xa3b0f348
+0,     651264,     651264,     1536,      512, 0xac9ffa65
+0,     652800,     652800,     1536,      512, 0xbb49fcf1
+0,     654336,     654336,     1536,      512, 0xc324f4da
+0,     655872,     655872,     1536,      512, 0xe9d2e875
+0,     657408,     657408,     1536,      512, 0x822cef30
+0,     658944,     658944,     1536,      512, 0x56f6f7a8
+0,     660480,     660480,     1536,      512, 0xf82cf718
+0,     662016,     662016,     1536,      512, 0xb75bfaa1
+0,     663552,     663552,     1536,      512, 0xdd4dfed6
+0,     665088,     665088,     1536,      512, 0x4392f531
+0,     666624,     666624,     1536,      512, 0xf50cf9fa
+0,     668160,     668160,     1536,      512, 0x1181ead9
+0,     669696,     669696,     1536,      512, 0x4925fb83
+0,     671232,     671232,     1536,      512, 0x53a7faf8
+0,     672768,     672768,     1536,      512, 0x0042f4f9
+0,     674304,     674304,     1536,      512, 0x0ed8fa2c
+0,     675840,     675840,     1536,      512, 0x9a1ef892
+0,     677376,     677376,     1536,      512, 0x4b35ee26
+0,     678912,     678912,     1536,      512, 0x6596fc07
+0,     680448,     680448,     1536,      512, 0xd3fcf908
+0,     681984,     681984,     1536,      512, 0x4f3ce991
+0,     683520,     683520,     1536,      512, 0xd8f7fc2a
+0,     685056,     685056,     1536,      512, 0x3dd4f26c
+0,     686592,     686592,     1536,      512, 0x4f49fc77
+0,     688128,     688128,     1536,      512, 0x3e08e521
+0,     689664,     689664,     1536,      512, 0xd180f348
+0,     691200,     691200,     1536,      512, 0xebeaf520
+0,     692736,     692736,     1536,      512, 0xed06f763
+0,     694272,     694272,     1536,      512, 0x9766ef09
+0,     695808,     695808,     1536,      512, 0xc4a6fc00
+0,     697344,     697344,     1536,      512, 0x5547f0ae
+0,     698880,     698880,     1536,      512, 0x300cf213
+0,     700416,     700416,     1536,      512, 0x35ba0678
+0,     701952,     701952,     1536,      512, 0xa8baf485
+0,     703488,     703488,     1536,      512, 0xc0cbe8e8
+0,     705024,     705024,     1536,      512, 0x081aeed1
+0,     706560,     706560,     1536,      512, 0x2017ec33
+0,     708096,     708096,     1536,      512, 0x8739f958
+0,     709632,     709632,     1536,      512, 0xb797f52e
+0,     711168,     711168,     1536,      512, 0x818afdf2
+0,     712704,     712704,     1536,      512, 0xbbabf0fe
+0,     714240,     714240,     1536,      512, 0x843600db
+0,     715776,     715776,     1536,      512, 0x610b02c9
+0,     717312,     717312,     1536,      512, 0x0bf8edfe
+0,     718848,     718848,     1536,      512, 0x9310edea
+0,     720384,     720384,     1536,      512, 0x08c2f355
+0,     721920,     721920,     1536,      512, 0x1b23f44c
+0,     723456,     723456,     1536,      512, 0x4be9f384
+0,     724992,     724992,     1536,      512, 0x5fbef21d
+0,     726528,     726528,     1536,      512, 0x7412ef5e
+0,     728064,     728064,     1536,      512, 0x9ae7f608
+0,     729600,     729600,     1536,      512, 0x0f41f270
+0,     731136,     731136,     1536,      512, 0x42c1f982
+0,     732672,     732672,     1536,      512, 0x4538f04b
+0,     734208,     734208,     1536,      512, 0x09baf2e1
+0,     735744,     735744,     1536,      512, 0xed8ff3ba
+0,     737280,     737280,     1536,      512, 0xb110f516
+0,     738816,     738816,     1536,      512, 0x3837f06a
+0,     740352,     740352,     1536,      512, 0x54aef484
+0,     741888,     741888,     1536,      512, 0xb047f61d
+0,     743424,     743424,     1536,      512, 0xdff4fb98
+0,     744960,     744960,     1536,      512, 0x9da60009
+0,     746496,     746496,     1536,      512, 0x7bb6f236
+0,     748032,     748032,     1536,      512, 0x9f96ea0e
+0,     749568,     749568,     1536,      512, 0xc5adf19a
+0,     751104,     751104,     1536,      512, 0x2e9cf6f8
+0,     752640,     752640,     1536,      512, 0xada8fadc
+0,     754176,     754176,     1536,      512, 0x100a07fd
+0,     755712,     755712,     1536,      512, 0xa26af433
+0,     757248,     757248,     1536,      512, 0xc82cf15e
+0,     758784,     758784,     1536,      512, 0x7f88f10d
+0,     760320,     760320,     1536,      512, 0x776df377
+0,     761856,     761856,     1536,      512, 0x30b0f60d
+0,     763392,     763392,     1536,      512, 0xcecbf9a3
+0,     764928,     764928,     1536,      512, 0xffa8f5c2
+0,     766464,     766464,     1536,      512, 0x9052e7cb
+0,     768000,     768000,     1536,      512, 0x0048f2cc
+0,     769536,     769536,     1536,      512, 0xc8fff912
+0,     771072,     771072,     1536,      512, 0xf22debb8
+0,     772608,     772608,     1536,      512, 0x7b4beb82
+0,     774144,     774144,     1536,      512, 0x428ff33e
+0,     775680,     775680,     1536,      512, 0xb3c1f426
+0,     777216,     777216,     1536,      512, 0xb08af561
+0,     778752,     778752,     1536,      512, 0xaf62ee68
+0,     780288,     780288,     1536,      512, 0xdb25f226
+0,     781824,     781824,     1536,      512, 0xa577f9d5
+0,     783360,     783360,     1536,      512, 0xd21af205
+0,     784896,     784896,     1536,      512, 0x8734f052
+0,     786432,     786432,     1536,      512, 0xcb0bf009
+0,     787968,     787968,     1536,      512, 0xde0bf8a7
+0,     789504,     789504,     1536,      512, 0x9fbefd0d
+0,     791040,     791040,     1536,      512, 0xc329ee26
+0,     792576,     792576,     1536,      512, 0xfc6007a0
+0,     794112,     794112,     1536,      512, 0x6782004b
+0,     795648,     795648,     1536,      512, 0x4adbf43c
+0,     797184,     797184,     1536,      512, 0x5b85f198
+0,     798720,     798720,     1536,      512, 0x1576fbfe
+0,     800256,     800256,     1536,      512, 0x62ebf217
+0,     801792,     801792,     1536,      512, 0xd8a9f5fe
+0,     803328,     803328,     1536,      512, 0x3270f500
+0,     804864,     804864,     1536,      512, 0x99e9eca2
+0,     806400,     806400,     1536,      512, 0x0d3c02c9
+0,     807936,     807936,     1536,      512, 0x8769f484
+0,     809472,     809472,     1536,      512, 0xd6cef92a
+0,     811008,     811008,     1536,      512, 0x9150f4b7
+0,     812544,     812544,     1536,      512, 0x760d00ce
+0,     814080,     814080,     1536,      512, 0xc595f17d
+0,     815616,     815616,     1536,      512, 0x3720fd55
+0,     817152,     817152,     1536,      512, 0x28e5f02b
+0,     818688,     818688,     1536,      512, 0x9e87f7bd
+0,     820224,     820224,     1536,      512, 0x4571fe9a
+0,     821760,     821760,     1536,      512, 0xbf06f83f
+0,     823296,     823296,     1536,      512, 0xb6bff67e
+0,     824832,     824832,     1536,      512, 0x582cfa1b
+0,     826368,     826368,     1536,      512, 0x9277f53b
+0,     827904,     827904,     1536,      512, 0xd541fa0e
+0,     829440,     829440,     1536,      512, 0xb9f7f791
+0,     830976,     830976,     1536,      512, 0xb5ccf6d3
+0,     832512,     832512,     1536,      512, 0xb03ef2a1
+0,     834048,     834048,     1536,      512, 0x6970fb11
+0,     835584,     835584,     1536,      512, 0x478df6bd
+0,     837120,     837120,     1536,      512, 0x7ce4eff2
+0,     838656,     838656,     1536,      512, 0x5f8af8bb
+0,     840192,     840192,     1536,      512, 0xa990f10c
+0,     841728,     841728,     1536,      512, 0x0b5e0603
+0,     843264,     843264,     1536,      512, 0x5f5ff667
+0,     844800,     844800,     1536,      512, 0xf3f1f7e5
+0,     846336,     846336,     1536,      512, 0xb7b1f92c
+0,     847872,     847872,     1536,      512, 0x5c5afc2d
+0,     849408,     849408,     1536,      512, 0xc389ecc8
+0,     850944,     850944,     1536,      512, 0x86edf4a8
+0,     852480,     852480,     1536,      512, 0x31cfeba8
+0,     854016,     854016,     1536,      512, 0xea9cf360
+0,     855552,     855552,     1536,      512, 0xbc04f016
+0,     857088,     857088,     1536,      512, 0x6617ed55
+0,     858624,     858624,     1536,      512, 0xe20afad2
+0,     860160,     860160,     1536,      512, 0x4706f61a
+0,     861696,     861696,     1536,      512, 0xa6a8fd93
+0,     863232,     863232,     1536,      512, 0x9655e7ae
+0,     864768,     864768,     1536,      512, 0x0ac2f354
+0,     866304,     866304,     1536,      512, 0x62e2f89a
+0,     867840,     867840,     1536,      512, 0x35baf1cb
+0,     869376,     869376,     1536,      512, 0xc02ff90e
+0,     870912,     870912,     1536,      512, 0xf3f8f24b
+0,     872448,     872448,     1536,      512, 0x10b9ebd6
+0,     873984,     873984,     1536,      512, 0x0482084b
+0,     875520,     875520,     1536,      512, 0xc14cee2e
+0,     877056,     877056,     1536,      512, 0x21ddf5ea
+0,     878592,     878592,     1536,      512, 0x8090f51f
+0,     880128,     880128,     1536,      512, 0x6496ed68
+0,     881664,     881664,     1536,      512, 0x4bb3fa69
+0,     883200,     883200,     1536,      512, 0x1e18e8d7
+0,     884736,     884736,     1536,      512, 0xb758fa60
+0,     886272,     886272,     1536,      512, 0xa5c6f671
+0,     887808,     887808,     1536,      512, 0x6dbcf15e
+0,     889344,     889344,     1536,      512, 0x56c4f227
+0,     890880,     890880,     1536,      512, 0x17280149
+0,     892416,     892416,     1536,      512, 0x8c57f584
+0,     893952,     893952,     1536,      512, 0x518ef2b4
+0,     895488,     895488,     1536,      512, 0x8a69ebe6
+0,     897024,     897024,     1536,      512, 0xf954e97c
+0,     898560,     898560,     1536,      512, 0x62e1f8db
+0,     900096,     900096,     1536,      512, 0x637af9fa
+0,     901632,     901632,     1536,      512, 0xecbcf846
+0,     903168,     903168,     1536,      512, 0x2481ecac
+0,     904704,     904704,     1536,      512, 0x7d3cf940
+0,     906240,     906240,     1536,      512, 0x4823efc4
+0,     907776,     907776,     1536,      512, 0x31d5f1ca
+0,     909312,     909312,     1536,      512, 0x3024f40f
+0,     910848,     910848,     1536,      512, 0xf172f644
+0,     912384,     912384,     1536,      512, 0x2502f1b9
+0,     913920,     913920,     1536,      512, 0x9ee8f50b
+0,     915456,     915456,     1536,      512, 0x0605fcc0
+0,     916992,     916992,     1536,      512, 0xf202f11d
+0,     918528,     918528,     1536,      512, 0x449df7a2
+0,     920064,     920064,     1536,      512, 0x16e8f468
+0,     921600,     921600,     1536,      512, 0xceeafba5
+0,     923136,     923136,     1536,      512, 0xc8410340
+0,     924672,     924672,     1536,      512, 0xc0e5fe5a
+0,     926208,     926208,     1536,      512, 0x60cafeb7
+0,     927744,     927744,     1536,      512, 0x8277fb6a
+0,     929280,     929280,     1536,      512, 0xa77dfac9
+0,     930816,     930816,     1536,      512, 0x7b2bf1d1
+0,     932352,     932352,     1536,      512, 0x63aafabd
+0,     933888,     933888,     1536,      512, 0xf56cf575
+0,     935424,     935424,     1536,      512, 0x2048f966
+0,     936960,     936960,     1536,      512, 0x392b0c6a
+0,     938496,     938496,     1536,      512, 0x7d87f244
+0,     940032,     940032,     1536,      512, 0xecbcfedc
+0,     941568,     941568,     1536,      512, 0x4780f2ef
+0,     943104,     943104,     1536,      512, 0x1a28f8ff
+0,     944640,     944640,     1536,      512, 0xda51fcc5
+0,     946176,     946176,     1536,      512, 0x7009f7ff
+0,     947712,     947712,     1536,      512, 0x1e5af6a2
+0,     949248,     949248,     1536,      512, 0xcb83e8c3
+0,     950784,     950784,     1536,      512, 0x2cbbe8ae
+0,     952320,     952320,     1536,      512, 0x5cc0ebbd
+0,     953856,     953856,     1536,      512, 0x5e13f33b
+0,     955392,     955392,     1536,      512, 0x2ef1ef3d
+0,     956928,     956928,     1536,      512, 0x4aaef05f
+0,     958464,     958464,     1536,      512, 0xf6adf321
+0,     960000,     960000,     1536,      512, 0x0041e985
+0,     961536,     961536,     1536,      512, 0x4539eb83
+0,     963072,     963072,     1536,      512, 0xa642f144
+0,     964608,     964608,     1536,      512, 0xf58dfb44
+0,     966144,     966144,     1536,      512, 0xcdf2f3b2
+0,     967680,     967680,     1536,      512, 0xebd9f1d4
+0,     969216,     969216,     1536,      512, 0xf39afcca
+0,     970752,     970752,     1536,      512, 0x4392fb8e
+0,     972288,     972288,     1536,      512, 0xe23df8bb
+0,     973824,     973824,     1536,      512, 0xdedaf23a
+0,     975360,     975360,     1536,      512, 0x1c46f7bc
+0,     976896,     976896,     1536,      512, 0x47e0f873
+0,     978432,     978432,     1536,      512, 0x5e55eb42
+0,     979968,     979968,     1536,      512, 0x5f08f8a0
+0,     981504,     981504,     1536,      512, 0xf391f9f8
+0,     983040,     983040,     1536,      512, 0x3d4afcd1
+0,     984576,     984576,     1536,      512, 0x07b8f3d4
+0,     986112,     986112,     1536,      512, 0xa7cdfea4
+0,     987648,     987648,     1536,      512, 0x4072ffda
+0,     989184,     989184,     1536,      512, 0xe96df73f
+0,     990720,     990720,     1536,      512, 0x6170f3a3
+0,     992256,     992256,     1536,      512, 0x743cf509
+0,     993792,     993792,     1536,      512, 0x3525fe8e
+0,     995328,     995328,     1536,      512, 0xd345ed02
+0,     996864,     996864,     1536,      512, 0x3c15f37f
+0,     998400,     998400,     1536,      512, 0x9df1facd
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/copy-trac4914 b/mythtv/external/FFmpeg/tests/ref/fate/copy-trac4914
index 3a6eee4dd23..e0864a0035c 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/copy-trac4914
+++ b/mythtv/external/FFmpeg/tests/ref/fate/copy-trac4914
@@ -1,4 +1,4 @@
-8868ae16d99ed03916e9dc7105285471 *tests/data/fate/copy-trac4914.mxf
+d51f6bcc96885a2ce8517ae8c774f610 *tests/data/fate/copy-trac4914.mxf
 560697 tests/data/fate/copy-trac4914.mxf
 #tb 0: 1001/30000
 #media_type 0: video
@@ -10,6 +10,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,        1,   259200, 0xf36957da
 1,          0,          0,     1602,     6408, 0x1dd7b37c
 0,          1,          1,        1,   259200, 0x29a1f586
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/copy-trac4914-avi b/mythtv/external/FFmpeg/tests/ref/fate/copy-trac4914-avi
index e02744d7d47..0358ead6b80 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/copy-trac4914-avi
+++ b/mythtv/external/FFmpeg/tests/ref/fate/copy-trac4914-avi
@@ -10,6 +10,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 1,          0,          0,     1152,     4608, 0xb24f5c9d
 1,       1152,       1152,     1152,     4608, 0xe2da5c32
 1,       2304,       2304,     1152,     4608, 0xd76023d9
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/corepng b/mythtv/external/FFmpeg/tests/ref/fate/corepng
index 4c106ed410f..74bb9201080 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/corepng
+++ b/mythtv/external/FFmpeg/tests/ref/fate/corepng
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 11025
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   230400, 0x03e25ead
 1,          0,          0,     5513,    11026, 0x27ad637c
 0,          1,          1,        1,   230400, 0x0a520ffd
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/creatureshock-avs b/mythtv/external/FFmpeg/tests/ref/fate/creatureshock-avs
index 82460b243f1..c8e08c9ff79 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/creatureshock-avs
+++ b/mythtv/external/FFmpeg/tests/ref/fate/creatureshock-avs
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 22222
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   188892, 0x9f47a5ec
 1,          0,          0,     8186,    16372, 0xfaaab59d
 0,          1,          1,        1,   188892, 0xdece0269
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/cyberia-c93 b/mythtv/external/FFmpeg/tests/ref/fate/cyberia-c93
index 5eb433649be..e7a5b5a08d9 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/cyberia-c93
+++ b/mythtv/external/FFmpeg/tests/ref/fate/cyberia-c93
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 16129
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   184320, 0x8433f0f8
 1,          0,          0,    14184,    28368, 0xaacc96a5
 0,          1,          1,        1,   184320, 0xd0d480f7
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/d-cinema-demux b/mythtv/external/FFmpeg/tests/ref/fate/d-cinema-demux
index 8e747de2a1c..74d00f7bb26 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/d-cinema-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/d-cinema-demux
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s24daud
 #sample_rate 0: 96000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 0,          0,          0,     1875,    36000, 0xd592781d
 0,       1875,       1875,     1875,    36000, 0xd592781d
 0,       3750,       3750,     1875,    36000, 0xd592781d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0
index acbae84ffe5..6e62c616e29 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 192000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     2048,    24576, 91ff0dac5df86e798bfef5e573536b08
 0,       2048,       2048,     2048,    24576, 91ff0dac5df86e798bfef5e573536b08
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0-dmix_2 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0-dmix_2
index acbae84ffe5..6e62c616e29 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0-dmix_2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0-dmix_2
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 192000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     2048,    24576, 91ff0dac5df86e798bfef5e573536b08
 0,       2048,       2048,     2048,    24576, 91ff0dac5df86e798bfef5e573536b08
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0-dmix_6 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0-dmix_6
index acbae84ffe5..6e62c616e29 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0-dmix_6
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_0-dmix_6
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 192000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     2048,    24576, 91ff0dac5df86e798bfef5e573536b08
 0,       2048,       2048,     2048,    24576, 91ff0dac5df86e798bfef5e573536b08
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1
index acbae84ffe5..6e62c616e29 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 192000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     2048,    24576, 91ff0dac5df86e798bfef5e573536b08
 0,       2048,       2048,     2048,    24576, 91ff0dac5df86e798bfef5e573536b08
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1-dmix_2 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1-dmix_2
index 3486971ce60..17896a7cca6 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1-dmix_2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1-dmix_2
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 192000
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     2048,     8192, 0829f71740aab1ab98b33eae21dee122
 0,       2048,       2048,     2048,     8192, c8ca1cff44674809d464ec39cf1bd1e9
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1-dmix_6 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1-dmix_6
index acbae84ffe5..6e62c616e29 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1-dmix_6
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_16_192_768_1-dmix_6
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 192000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     2048,    24576, 91ff0dac5df86e798bfef5e573536b08
 0,       2048,       2048,     2048,    24576, 91ff0dac5df86e798bfef5e573536b08
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768
index 8e7be8b2fc1..2d10583b49a 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,     9216, 13a95890b5f0947d6f058ca9c30a3e01
 0,        512,        512,      512,     9216, 13a95890b5f0947d6f058ca9c30a3e01
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768-dmix_2 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768-dmix_2
index 5f576192cc7..be22d7d98ec 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768-dmix_2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768-dmix_2
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,     3072, d2a70550489de356a2cd6bfc40711204
 0,        512,        512,      512,     3072, d2a70550489de356a2cd6bfc40711204
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768-dmix_6 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768-dmix_6
index 8e7be8b2fc1..2d10583b49a 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768-dmix_6
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_768-dmix_6
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,     9216, 13a95890b5f0947d6f058ca9c30a3e01
 0,        512,        512,      512,     9216, 13a95890b5f0947d6f058ca9c30a3e01
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none
index a1994e7dfef..17cfd0edb29 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     1024,    18432, f9debe3f07be68533bf0295e3d2ba68a
 0,       1024,       1024,     1024,    18432, 6707daa7724fdc552869e522a7936f26
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none-dmix_2 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none-dmix_2
index a1994e7dfef..17cfd0edb29 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none-dmix_2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none-dmix_2
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     1024,    18432, f9debe3f07be68533bf0295e3d2ba68a
 0,       1024,       1024,     1024,    18432, 6707daa7724fdc552869e522a7936f26
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none-dmix_6 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none-dmix_6
index a1994e7dfef..17cfd0edb29 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none-dmix_6
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_51_24_48_none-dmix_6
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     1024,    18432, f9debe3f07be68533bf0295e3d2ba68a
 0,       1024,       1024,     1024,    18432, 6707daa7724fdc552869e522a7936f26
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0
index 387b07e2ff5..a295d41a921 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 63f
+#channel_layout_name 0: 7.1
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,    12288, ca9f8c8eb1b9b311cb79999fa376c7f0
 0,        512,        512,      512,    12288, 4072783b8efb99a9e5817067d68f61c6
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0-dmix_2 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0-dmix_2
index e1169e10832..f9b7b655a5c 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0-dmix_2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0-dmix_2
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,     9216, a2b724b146069938f0e2cb82490dea54
 0,        512,        512,      512,     9216, 13a95890b5f0947d6f058ca9c30a3e01
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0-dmix_6 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0-dmix_6
index e1169e10832..f9b7b655a5c 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0-dmix_6
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_0-dmix_6
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,     9216, a2b724b146069938f0e2cb82490dea54
 0,        512,        512,      512,     9216, 13a95890b5f0947d6f058ca9c30a3e01
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1
index 387b07e2ff5..a295d41a921 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 63f
+#channel_layout_name 0: 7.1
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,    12288, ca9f8c8eb1b9b311cb79999fa376c7f0
 0,        512,        512,      512,    12288, 4072783b8efb99a9e5817067d68f61c6
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1-dmix_2 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1-dmix_2
index 44bc5a038a9..5b017462584 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1-dmix_2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1-dmix_2
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,     3072, d2a70550489de356a2cd6bfc40711204
 0,        512,        512,      512,     3072, d2a70550489de356a2cd6bfc40711204
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1-dmix_6 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1-dmix_6
index ef6a1130b31..246b5e01333 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1-dmix_6
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_48_768_1-dmix_6
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,     9216, a2b724b146069938f0e2cb82490dea54
 0,        512,        512,      512,     9216, 13a95890b5f0947d6f058ca9c30a3e01
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768
index a2a02e02122..418b4b136d5 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 96000
 #channel_layout 0: 63f
+#channel_layout_name 0: 7.1
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     1024,    24576, 0b24a527d66f2b0cab97f37e4cd79987
 0,       1024,       1024,     1024,    24576, 91ff0dac5df86e798bfef5e573536b08
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768-dmix_2 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768-dmix_2
index 9f2877d3f79..9bd0256c312 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768-dmix_2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768-dmix_2
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 96000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     1024,    18432, 0a675f172b0e1a171c46dfaa4f1d0f00
 0,       1024,       1024,     1024,    18432, f9debe3f07be68533bf0295e3d2ba68a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768-dmix_6 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768-dmix_6
index 9f2877d3f79..9bd0256c312 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768-dmix_6
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_71_24_96_768-dmix_6
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 96000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     1024,    18432, 0a675f172b0e1a171c46dfaa4f1d0f00
 0,       1024,       1024,     1024,    18432, f9debe3f07be68533bf0295e3d2ba68a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509
index 39a9e7970a0..bc83f793a00 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 96000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     1024,    18432, f9debe3f07be68533bf0295e3d2ba68a
 0,       1024,       1024,     1024,    18432, f9debe3f07be68533bf0295e3d2ba68a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509-dmix_2 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509-dmix_2
index 39a9e7970a0..bc83f793a00 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509-dmix_2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509-dmix_2
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 96000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     1024,    18432, f9debe3f07be68533bf0295e3d2ba68a
 0,       1024,       1024,     1024,    18432, f9debe3f07be68533bf0295e3d2ba68a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509-dmix_6 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509-dmix_6
index 39a9e7970a0..bc83f793a00 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509-dmix_6
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_x96_51_24_96_1509-dmix_6
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 96000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     1024,    18432, f9debe3f07be68533bf0295e3d2ba68a
 0,       1024,       1024,     1024,    18432, f9debe3f07be68533bf0295e3d2ba68a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768
index e3ac859662e..19816d93d35 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 70f
+#channel_layout_name 0: 6.1
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,    10752, c3c5b236c266a9090378def1ad497a21
 0,        512,        512,      512,    10752, 36eb6749f8d9ce9f94860dcc447253ac
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768-dmix_2 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768-dmix_2
index b53a528b2cb..1f6989fbe42 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768-dmix_2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768-dmix_2
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,     9216, 652c4e61f9abe9fba9de792242e2d31d
 0,        512,        512,      512,     9216, 13a95890b5f0947d6f058ca9c30a3e01
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768-dmix_6 b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768-dmix_6
index b53a528b2cb..1f6989fbe42 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768-dmix_6
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dca-xll_xch_61_24_48_768-dmix_6
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s24le
 #sample_rate 0: 48000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      512,     9216, 652c4e61f9abe9fba9de792242e2d31d
 0,        512,        512,      512,     9216, 13a95890b5f0947d6f058ca9c30a3e01
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dcinema-encode b/mythtv/external/FFmpeg/tests/ref/fate/dcinema-encode
index 27865d63e22..03e6e6ef6c6 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dcinema-encode
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dcinema-encode
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 96000
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,      341,     4092, 697cddfcd0e21f24782af0705b7048f3
 0,        341,        341,      341,     4092, a057b18cd493923fed33c18578f61e0b
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/delphine-cin-audio b/mythtv/external/FFmpeg/tests/ref/fate/delphine-cin-audio
index 5a69640a4c5..6fdc8048e42 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/delphine-cin-audio
+++ b/mythtv/external/FFmpeg/tests/ref/fate/delphine-cin-audio
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,    88224,   176448, 0x541ddc55
 0,      88224,      88224,     1838,     3676, 0xaf455081
 0,      90062,      90062,     1838,     3676, 0x27ef4e91
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dict b/mythtv/external/FFmpeg/tests/ref/fate/dict
index 837f7b02e50..7205e4c8455 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dict
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dict
@@ -2,24 +2,31 @@ Testing av_dict_get_string() and av_dict_parse_string()
 
 aaa aaa   b,b bbb   c=c ccc   ddd d,d   eee e=e   f,f f=f   g=g g,g
 aaa=aaa,b\,b=bbb,c\=c=ccc,ddd=d\,d,eee=e\=e,f\,f=f\=f,g\=g=g\,g
+ret 0
 aaa aaa   b,b bbb   c=c ccc   ddd d,d   eee e=e   f,f f=f   g=g g,g
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 aaa=aaa"bbb=bbb"ccc=ccc"\\,\=\'\"=\\,\=\'\"
+ret 0
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 aaa=aaa'bbb=bbb'ccc=ccc'\\,\=\'"=\\,\=\'"
+ret 0
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 aaa"aaa,bbb"bbb,ccc"ccc,\\\,=\'\""\\\,=\'\"
+ret 0
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 aaa'aaa,bbb'bbb,ccc'ccc,\\\,=\'"'\\\,=\'"
+ret 0
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 aaa"aaa'bbb"bbb'ccc"ccc'\\,=\'\""\\,=\'\"
+ret 0
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 aaa'aaa"bbb'bbb"ccc'ccc"\\,=\'\"'\\,=\'\"
+ret 0
 aaa aaa   bbb bbb   ccc ccc   \,='" \,='"
 
 Testing av_dict_set()
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dirac-low-delay b/mythtv/external/FFmpeg/tests/ref/fate/dirac-low-delay
new file mode 100644
index 00000000000..13bf8e8517c
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dirac-low-delay
@@ -0,0 +1,7 @@
+#tb 0: 1/30
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 320x240
+#sar 0: 1/1
+0,          0,          0,        1,   115200, 0x2599a172
+0,          1,          1,        1,   115200, 0x08a8c08d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dpcm-idroq b/mythtv/external/FFmpeg/tests/ref/fate/dpcm-idroq
index 39f2c799a37..fb45ace2c63 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dpcm-idroq
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dpcm-idroq
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     7456,    29824, 0x77e265b7
 0,       7456,       7456,      736,     2944, 0x8dcdf50b
 0,       8192,       8192,      736,     2944, 0xb135cd2a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dpcm-interplay b/mythtv/external/FFmpeg/tests/ref/fate/dpcm-interplay
index 87a28620a59..720a98f3899 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dpcm-interplay
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dpcm-interplay
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1462,     5848, 0xea04292b
 0,       1462,       1462,     1472,     5888, 0x0e59e942
 0,       2934,       2934,     1472,     5888, 0x56d480f6
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dss-lp b/mythtv/external/FFmpeg/tests/ref/fate/dss-lp
index 6b5a7db8f50..ab1d5344b5b 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dss-lp
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dss-lp
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      240,      480, 0xf1107658
 0,        240,        240,      240,      480, 0x50dee179
 0,        480,        480,      240,      480, 0x40090802
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/dss-sp b/mythtv/external/FFmpeg/tests/ref/fate/dss-sp
index 5caa46999a1..f407ce7da0c 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/dss-sp
+++ b/mythtv/external/FFmpeg/tests/ref/fate/dss-sp
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 11025
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      264,      528, 0xa2579e96
 0,        264,        264,      264,      528, 0xf9b23172
 0,        528,        528,      264,      528, 0x5571a0fe
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exif-image-embedded b/mythtv/external/FFmpeg/tests/ref/fate/exif-image-embedded
index 22a74e1f3fb..306ae0854b1 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exif-image-embedded
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exif-image-embedded
@@ -22,6 +22,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=pc
+color_space=bt470bg
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=center
 TAG:UserComment=AppleMark
 
 [/FRAME]
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exif-image-jpg b/mythtv/external/FFmpeg/tests/ref/fate/exif-image-jpg
index adbd752ffae..b266501191b 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exif-image-jpg
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exif-image-jpg
@@ -22,6 +22,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=pc
+color_space=bt470bg
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=center
 TAG:ImageDescription=
 TAG:Make=Canon
 TAG:Model=Canon PowerShot SX200 IS
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exif-image-tiff b/mythtv/external/FFmpeg/tests/ref/fate/exif-image-tiff
index 85067983483..51580601e19 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exif-image-tiff
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exif-image-tiff
@@ -22,6 +22,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 TAG:document_name=image_small.tiff
 TAG:page_number=    0 /     1
 TAG:software=ImageMagick 6.5.8-0 2010-02-09 Q16 http://www.imagemagick.org
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exif-image-webp b/mythtv/external/FFmpeg/tests/ref/fate/exif-image-webp
index b8891cd1ea2..d520ecd0dba 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exif-image-webp
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exif-image-webp
@@ -22,6 +22,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=tv
+color_space=bt470bg
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 TAG:ImageDescription=
 TAG:Make=Canon
 TAG:Model=Canon PowerShot SX200 IS
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-b44a-half-negative-4x4 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-b44a-half-negative-4x4
new file mode 100644
index 00000000000..2ff4e9742b7
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-b44a-half-negative-4x4
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 4x4
+#sar 0: 1/1
+0,          0,          0,        1,       96, 0x70600260
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-b44-uint32 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-b44-uint32
new file mode 100644
index 00000000000..abe41b8a7a7
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-b44-uint32
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 12x8
+#sar 0: 1/1
+0,          0,          0,        1,      576, 0x6b950ce3
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-float-piz-48x32 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-float-piz-48x32
new file mode 100644
index 00000000000..d1a5d90ee2f
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-float-piz-48x32
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 48x32
+#sar 0: 1/1
+0,          0,          0,        1,     9216, 0x5b3f7a8e
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-bw b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-bw
new file mode 100644
index 00000000000..6e08d528eba
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-bw
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 34x27
+#sar 0: 1/1
+0,          0,          0,        1,     5508, 0x36d15e2e
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-color b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-color
new file mode 100644
index 00000000000..21510792ff1
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-color
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 34x40
+#sar 0: 1/1
+0,          0,          0,        1,     8160, 0x9dd67b7d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-dw-t01 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-dw-t01
new file mode 100644
index 00000000000..e135aed3ba4
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-dw-t01
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 400x300
+#sar 0: 1/1
+0,          0,          0,        1,   720000, 0xe50fc9f8
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-dw-t08 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-dw-t08
new file mode 100644
index 00000000000..a443c98d9de
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-half-piz-dw-t08
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 501x401
+#sar 0: 1/1
+0,          0,          0,        1,  1205406, 0xc45cc9f8
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-none-negative-red b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-none-negative-red
new file mode 100644
index 00000000000..8c399b2f5e6
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-none-negative-red
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 4x4
+#sar 0: 1/1
+0,          0,          0,        1,       96, 0x27bc131b
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-pxr24-half-uint32-13x9 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-pxr24-half-uint32-13x9
new file mode 100644
index 00000000000..50b85c8d1c9
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-pxr24-half-uint32-13x9
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 13x9
+#sar 0: 9/10
+0,          0,          0,        1,      702, 0xf0212f1d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-pxr24-uint32 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-pxr24-uint32
new file mode 100644
index 00000000000..abe41b8a7a7
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-pxr24-uint32
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 12x8
+#sar 0: 1/1
+0,          0,          0,        1,      576, 0x6b950ce3
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-zip1-half-float-l1-zero-offsets b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-zip1-half-float-l1-zero-offsets
new file mode 100644
index 00000000000..af042043e7e
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgb-scanline-zip1-half-float-l1-zero-offsets
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 12x8
+#sar 0: 1/1
+0,          0,          0,        1,      576, 0x5ede004c
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-12x8-l1 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-12x8-l1
index c84d388fff6..cd25f618f41 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-12x8-l1
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-12x8-l1
@@ -2,5 +2,5 @@
 #media_type 0: video
 #codec_id 0: rawvideo
 #dimensions 0: 12x8
-#sar 0: 0/1
+#sar 0: 9/10
 0,          0,          0,        1,      768, 0x1de5c7f1
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-12x8-l2 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-12x8-l2
index 1dd42d9175b..ecfba85e83d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-12x8-l2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-12x8-l2
@@ -2,5 +2,5 @@
 #media_type 0: video
 #codec_id 0: rawvideo
 #dimensions 0: 12x8
-#sar 0: 0/1
+#sar 0: 9/10
 0,          0,          0,        1,      768, 0xe08ca6d3
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-13x9-l1 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-13x9-l1
index 595c721d509..3e82e2aaa43 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-13x9-l1
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-13x9-l1
@@ -2,5 +2,5 @@
 #media_type 0: video
 #codec_id 0: rawvideo
 #dimensions 0: 13x9
-#sar 0: 0/1
+#sar 0: 9/10
 0,          0,          0,        1,      936, 0xdcb42186
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-13x9-l2 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-13x9-l2
index 079d1d877f7..f237d17d3f4 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-13x9-l2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44-13x9-l2
@@ -2,5 +2,5 @@
 #media_type 0: video
 #codec_id 0: rawvideo
 #dimensions 0: 13x9
-#sar 0: 0/1
+#sar 0: 9/10
 0,          0,          0,        1,      936, 0x7f710bf5
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-12x8-l1 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-12x8-l1
index 6d202af8084..43313e37126 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-12x8-l1
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-12x8-l1
@@ -2,5 +2,5 @@
 #media_type 0: video
 #codec_id 0: rawvideo
 #dimensions 0: 12x8
-#sar 0: 0/1
+#sar 0: 9/10
 0,          0,          0,        1,      768, 0xe200c160
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-12x8-l2 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-12x8-l2
index 1dd42d9175b..ecfba85e83d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-12x8-l2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-12x8-l2
@@ -2,5 +2,5 @@
 #media_type 0: video
 #codec_id 0: rawvideo
 #dimensions 0: 12x8
-#sar 0: 0/1
+#sar 0: 9/10
 0,          0,          0,        1,      768, 0xe08ca6d3
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-13x9-l1 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-13x9-l1
index 9fcf3093683..e43c31ebd54 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-13x9-l1
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-13x9-l1
@@ -2,5 +2,5 @@
 #media_type 0: video
 #codec_id 0: rawvideo
 #dimensions 0: 13x9
-#sar 0: 0/1
+#sar 0: 9/10
 0,          0,          0,        1,      936, 0x911718ac
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-13x9-l2 b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-13x9-l2
index 079d1d877f7..f237d17d3f4 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-13x9-l2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-rgba-scanline-float-half-b44a-13x9-l2
@@ -2,5 +2,5 @@
 #media_type 0: video
 #codec_id 0: rawvideo
 #dimensions 0: 13x9
-#sar 0: 0/1
+#sar 0: 9/10
 0,          0,          0,        1,      936, 0x7f710bf5
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-y-scanline-zip-half-12x8 b/mythtv/external/FFmpeg/tests/ref/fate/exr-y-scanline-zip-half-12x8
new file mode 100644
index 00000000000..2a62164256c
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-y-scanline-zip-half-12x8
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 12x8
+#sar 0: 1/1
+0,          0,          0,        1,      192, 0xdd5759b5
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/exr-y-tile-zip-half-12x8 b/mythtv/external/FFmpeg/tests/ref/fate/exr-y-tile-zip-half-12x8
new file mode 100644
index 00000000000..2a62164256c
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/exr-y-tile-zip-half-12x8
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 12x8
+#sar 0: 1/1
+0,          0,          0,        1,      192, 0xdd5759b5
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/ffmpeg-filter_colorkey b/mythtv/external/FFmpeg/tests/ref/fate/ffmpeg-filter_colorkey
index 9fbdfebb42d..effc13b12f3 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/ffmpeg-filter_colorkey
+++ b/mythtv/external/FFmpeg/tests/ref/fate/ffmpeg-filter_colorkey
@@ -3,17 +3,8 @@
 #codec_id 0: rawvideo
 #dimensions 0: 720x576
 #sar 0: 0/1
-#tb 1: 1/48000
-#media_type 1: audio
-#codec_id 1: pcm_s16le
-#sample_rate 1: 48000
-#channel_layout 1: 3
 0,          0,          0,        1,   622080, 0x4e30accb
-1,          0,          0,     1152,     4608, 0x00000000
-1,       1152,       1152,     1152,     4608, 0xbca29063
 0,          1,          1,        1,   622080, 0x7d941c14
-1,       2304,       2304,     1152,     4608, 0x6e70df10
-1,       3456,       3456,     1152,     4608, 0x95e6a535
 0,          2,          2,        1,   622080, 0xf7451c5b
 0,          3,          3,        1,   622080, 0xb2c74319
 0,          4,          4,        1,   622080, 0xc9b80b79
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_compact b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_compact
index e81fce440d5..4a0f4ee7764 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_compact
+++ b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_compact
@@ -1,32 +1,32 @@
 packet|codec_type=audio|stream_index=0|pts=0|pts_time=0.000000|dts=0|dts_time=0.000000|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=2048|pos=647|flags=K_
 frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=0|pkt_pts_time=0.000000|pkt_dts=0|pkt_dts_time=0.000000|best_effort_timestamp=0|best_effort_timestamp_time=0.000000|pkt_duration=1024|pkt_duration_time=0.023220|pkt_pos=647|pkt_size=2048|sample_fmt=s16|nb_samples=1024|channels=1|channel_layout=unknown
 packet|codec_type=video|stream_index=1|pts=0|pts_time=0.000000|dts=0|dts_time=0.000000|duration=2048|duration_time=0.040000|convergence_duration=N/A|convergence_duration_time=N/A|size=230400|pos=2722|flags=K_
-frame|media_type=video|stream_index=1|key_frame=1|pkt_pts=0|pkt_pts_time=0.000000|pkt_dts=0|pkt_dts_time=0.000000|best_effort_timestamp=0|best_effort_timestamp_time=0.000000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=2722|pkt_size=230400|width=320|height=240|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0
+frame|media_type=video|stream_index=1|key_frame=1|pkt_pts=0|pkt_pts_time=0.000000|pkt_dts=0|pkt_dts_time=0.000000|best_effort_timestamp=0|best_effort_timestamp_time=0.000000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=2722|pkt_size=230400|width=320|height=240|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=unknown|color_space=unknown|color_primaries=unknown|color_transfer=unknown|chroma_location=unspecified
 packet|codec_type=video|stream_index=2|pts=0|pts_time=0.000000|dts=0|dts_time=0.000000|duration=2048|duration_time=0.040000|convergence_duration=N/A|convergence_duration_time=N/A|size=30000|pos=233143|flags=K_
-frame|media_type=video|stream_index=2|key_frame=1|pkt_pts=0|pkt_pts_time=0.000000|pkt_dts=0|pkt_dts_time=0.000000|best_effort_timestamp=0|best_effort_timestamp_time=0.000000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=233143|pkt_size=30000|width=100|height=100|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0
+frame|media_type=video|stream_index=2|key_frame=1|pkt_pts=0|pkt_pts_time=0.000000|pkt_dts=0|pkt_dts_time=0.000000|best_effort_timestamp=0|best_effort_timestamp_time=0.000000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=233143|pkt_size=30000|width=100|height=100|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=unknown|color_space=unknown|color_primaries=unknown|color_transfer=unknown|chroma_location=unspecified
 packet|codec_type=audio|stream_index=0|pts=1024|pts_time=0.023220|dts=1024|dts_time=0.023220|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=2048|pos=263148|flags=K_
 frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=1024|pkt_pts_time=0.023220|pkt_dts=1024|pkt_dts_time=0.023220|best_effort_timestamp=1024|best_effort_timestamp_time=0.023220|pkt_duration=1024|pkt_duration_time=0.023220|pkt_pos=263148|pkt_size=2048|sample_fmt=s16|nb_samples=1024|channels=1|channel_layout=unknown
 packet|codec_type=video|stream_index=1|pts=2048|pts_time=0.040000|dts=2048|dts_time=0.040000|duration=2048|duration_time=0.040000|convergence_duration=N/A|convergence_duration_time=N/A|size=230400|pos=265226|flags=K_
-frame|media_type=video|stream_index=1|key_frame=1|pkt_pts=2048|pkt_pts_time=0.040000|pkt_dts=2048|pkt_dts_time=0.040000|best_effort_timestamp=2048|best_effort_timestamp_time=0.040000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=265226|pkt_size=230400|width=320|height=240|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0
+frame|media_type=video|stream_index=1|key_frame=1|pkt_pts=2048|pkt_pts_time=0.040000|pkt_dts=2048|pkt_dts_time=0.040000|best_effort_timestamp=2048|best_effort_timestamp_time=0.040000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=265226|pkt_size=230400|width=320|height=240|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=unknown|color_space=unknown|color_primaries=unknown|color_transfer=unknown|chroma_location=unspecified
 packet|codec_type=video|stream_index=2|pts=2048|pts_time=0.040000|dts=2048|dts_time=0.040000|duration=2048|duration_time=0.040000|convergence_duration=N/A|convergence_duration_time=N/A|size=30000|pos=495650|flags=K_
-frame|media_type=video|stream_index=2|key_frame=1|pkt_pts=2048|pkt_pts_time=0.040000|pkt_dts=2048|pkt_dts_time=0.040000|best_effort_timestamp=2048|best_effort_timestamp_time=0.040000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=495650|pkt_size=30000|width=100|height=100|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0
+frame|media_type=video|stream_index=2|key_frame=1|pkt_pts=2048|pkt_pts_time=0.040000|pkt_dts=2048|pkt_dts_time=0.040000|best_effort_timestamp=2048|best_effort_timestamp_time=0.040000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=495650|pkt_size=30000|width=100|height=100|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=unknown|color_space=unknown|color_primaries=unknown|color_transfer=unknown|chroma_location=unspecified
 packet|codec_type=audio|stream_index=0|pts=2048|pts_time=0.046440|dts=2048|dts_time=0.046440|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=2048|pos=525655|flags=K_
 frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=2048|pkt_pts_time=0.046440|pkt_dts=2048|pkt_dts_time=0.046440|best_effort_timestamp=2048|best_effort_timestamp_time=0.046440|pkt_duration=1024|pkt_duration_time=0.023220|pkt_pos=525655|pkt_size=2048|sample_fmt=s16|nb_samples=1024|channels=1|channel_layout=unknown
 packet|codec_type=audio|stream_index=0|pts=3072|pts_time=0.069660|dts=3072|dts_time=0.069660|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=2048|pos=527726|flags=K_
 frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=3072|pkt_pts_time=0.069660|pkt_dts=3072|pkt_dts_time=0.069660|best_effort_timestamp=3072|best_effort_timestamp_time=0.069660|pkt_duration=1024|pkt_duration_time=0.023220|pkt_pos=527726|pkt_size=2048|sample_fmt=s16|nb_samples=1024|channels=1|channel_layout=unknown
 packet|codec_type=video|stream_index=1|pts=4096|pts_time=0.080000|dts=4096|dts_time=0.080000|duration=2048|duration_time=0.040000|convergence_duration=N/A|convergence_duration_time=N/A|size=230400|pos=529804|flags=K_
-frame|media_type=video|stream_index=1|key_frame=1|pkt_pts=4096|pkt_pts_time=0.080000|pkt_dts=4096|pkt_dts_time=0.080000|best_effort_timestamp=4096|best_effort_timestamp_time=0.080000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=529804|pkt_size=230400|width=320|height=240|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0
+frame|media_type=video|stream_index=1|key_frame=1|pkt_pts=4096|pkt_pts_time=0.080000|pkt_dts=4096|pkt_dts_time=0.080000|best_effort_timestamp=4096|best_effort_timestamp_time=0.080000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=529804|pkt_size=230400|width=320|height=240|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=unknown|color_space=unknown|color_primaries=unknown|color_transfer=unknown|chroma_location=unspecified
 packet|codec_type=video|stream_index=2|pts=4096|pts_time=0.080000|dts=4096|dts_time=0.080000|duration=2048|duration_time=0.040000|convergence_duration=N/A|convergence_duration_time=N/A|size=30000|pos=760228|flags=K_
-frame|media_type=video|stream_index=2|key_frame=1|pkt_pts=4096|pkt_pts_time=0.080000|pkt_dts=4096|pkt_dts_time=0.080000|best_effort_timestamp=4096|best_effort_timestamp_time=0.080000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=760228|pkt_size=30000|width=100|height=100|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0
+frame|media_type=video|stream_index=2|key_frame=1|pkt_pts=4096|pkt_pts_time=0.080000|pkt_dts=4096|pkt_dts_time=0.080000|best_effort_timestamp=4096|best_effort_timestamp_time=0.080000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=760228|pkt_size=30000|width=100|height=100|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=unknown|color_space=unknown|color_primaries=unknown|color_transfer=unknown|chroma_location=unspecified
 packet|codec_type=audio|stream_index=0|pts=4096|pts_time=0.092880|dts=4096|dts_time=0.092880|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=2048|pos=790233|flags=K_
 frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=4096|pkt_pts_time=0.092880|pkt_dts=4096|pkt_dts_time=0.092880|best_effort_timestamp=4096|best_effort_timestamp_time=0.092880|pkt_duration=1024|pkt_duration_time=0.023220|pkt_pos=790233|pkt_size=2048|sample_fmt=s16|nb_samples=1024|channels=1|channel_layout=unknown
-packet|codec_type=audio|stream_index=0|pts=5120|pts_time=0.116100|dts=5120|dts_time=0.116100|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=2048|pos=792304|flags=K_
-frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=5120|pkt_pts_time=0.116100|pkt_dts=5120|pkt_dts_time=0.116100|best_effort_timestamp=5120|best_effort_timestamp_time=0.116100|pkt_duration=1024|pkt_duration_time=0.023220|pkt_pos=792304|pkt_size=2048|sample_fmt=s16|nb_samples=1024|channels=1|channel_layout=unknown
-packet|codec_type=video|stream_index=1|pts=6144|pts_time=0.120000|dts=6144|dts_time=0.120000|duration=2048|duration_time=0.040000|convergence_duration=N/A|convergence_duration_time=N/A|size=230400|pos=794382|flags=K_
-frame|media_type=video|stream_index=1|key_frame=1|pkt_pts=6144|pkt_pts_time=0.120000|pkt_dts=6144|pkt_dts_time=0.120000|best_effort_timestamp=6144|best_effort_timestamp_time=0.120000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=794382|pkt_size=230400|width=320|height=240|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0
-packet|codec_type=video|stream_index=2|pts=6144|pts_time=0.120000|dts=6144|dts_time=0.120000|duration=2048|duration_time=0.040000|convergence_duration=N/A|convergence_duration_time=N/A|size=30000|pos=1024806|flags=K_
-frame|media_type=video|stream_index=2|key_frame=1|pkt_pts=6144|pkt_pts_time=0.120000|pkt_dts=6144|pkt_dts_time=0.120000|best_effort_timestamp=6144|best_effort_timestamp_time=0.120000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=1024806|pkt_size=30000|width=100|height=100|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0
+packet|codec_type=audio|stream_index=0|pts=5120|pts_time=0.116100|dts=5120|dts_time=0.116100|duration=393|duration_time=0.008912|convergence_duration=N/A|convergence_duration_time=N/A|size=786|pos=792304|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=5120|pkt_pts_time=0.116100|pkt_dts=5120|pkt_dts_time=0.116100|best_effort_timestamp=5120|best_effort_timestamp_time=0.116100|pkt_duration=393|pkt_duration_time=0.008912|pkt_pos=792304|pkt_size=786|sample_fmt=s16|nb_samples=393|channels=1|channel_layout=unknown
+packet|codec_type=video|stream_index=1|pts=6144|pts_time=0.120000|dts=6144|dts_time=0.120000|duration=2048|duration_time=0.040000|convergence_duration=N/A|convergence_duration_time=N/A|size=230400|pos=793120|flags=K_
+frame|media_type=video|stream_index=1|key_frame=1|pkt_pts=6144|pkt_pts_time=0.120000|pkt_dts=6144|pkt_dts_time=0.120000|best_effort_timestamp=6144|best_effort_timestamp_time=0.120000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=793120|pkt_size=230400|width=320|height=240|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=unknown|color_space=unknown|color_primaries=unknown|color_transfer=unknown|chroma_location=unspecified
+packet|codec_type=video|stream_index=2|pts=6144|pts_time=0.120000|dts=6144|dts_time=0.120000|duration=2048|duration_time=0.040000|convergence_duration=N/A|convergence_duration_time=N/A|size=30000|pos=1023544|flags=K_
+frame|media_type=video|stream_index=2|key_frame=1|pkt_pts=6144|pkt_pts_time=0.120000|pkt_dts=6144|pkt_dts_time=0.120000|best_effort_timestamp=6144|best_effort_timestamp_time=0.120000|pkt_duration=2048|pkt_duration_time=0.040000|pkt_pos=1023544|pkt_size=30000|width=100|height=100|pix_fmt=rgb24|sample_aspect_ratio=1:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=unknown|color_space=unknown|color_primaries=unknown|color_transfer=unknown|chroma_location=unspecified
 stream|index=0|codec_name=pcm_s16le|profile=unknown|codec_type=audio|codec_time_base=1/44100|codec_tag_string=PSD[16]|codec_tag=0x10445350|sample_fmt=s16|sample_rate=44100|channels=1|channel_layout=unknown|bits_per_sample=16|id=N/A|r_frame_rate=0/0|avg_frame_rate=0/0|time_base=1/44100|start_pts=0|start_time=0.000000|duration_ts=N/A|duration=N/A|bit_rate=705600|max_bit_rate=N/A|bits_per_raw_sample=N/A|nb_frames=N/A|nb_read_frames=6|nb_read_packets=6|disposition:default=0|disposition:dub=0|disposition:original=0|disposition:comment=0|disposition:lyrics=0|disposition:karaoke=0|disposition:forced=0|disposition:hearing_impaired=0|disposition:visual_impaired=0|disposition:clean_effects=0|disposition:attached_pic=0|disposition:timed_thumbnails=0|tag:E=mc²|tag:encoder=Lavc pcm_s16le
-stream|index=1|codec_name=rawvideo|profile=unknown|codec_type=video|codec_time_base=1/25|codec_tag_string=RGB[24]|codec_tag=0x18424752|width=320|height=240|coded_width=320|coded_height=240|has_b_frames=0|sample_aspect_ratio=1:1|display_aspect_ratio=4:3|pix_fmt=rgb24|level=-99|color_range=N/A|color_space=unknown|color_transfer=unknown|color_primaries=unknown|chroma_location=unspecified|field_order=unknown|timecode=N/A|refs=1|id=N/A|r_frame_rate=25/1|avg_frame_rate=25/1|time_base=1/51200|start_pts=0|start_time=0.000000|duration_ts=N/A|duration=N/A|bit_rate=N/A|max_bit_rate=N/A|bits_per_raw_sample=N/A|nb_frames=N/A|nb_read_frames=4|nb_read_packets=4|disposition:default=0|disposition:dub=0|disposition:original=0|disposition:comment=0|disposition:lyrics=0|disposition:karaoke=0|disposition:forced=0|disposition:hearing_impaired=0|disposition:visual_impaired=0|disposition:clean_effects=0|disposition:attached_pic=0|disposition:timed_thumbnails=0|tag:title=foobar|tag:duration_ts=field-and-tags-conflict-attempt|tag:encoder=Lavc rawvideo
-stream|index=2|codec_name=rawvideo|profile=unknown|codec_type=video|codec_time_base=1/25|codec_tag_string=RGB[24]|codec_tag=0x18424752|width=100|height=100|coded_width=100|coded_height=100|has_b_frames=0|sample_aspect_ratio=1:1|display_aspect_ratio=1:1|pix_fmt=rgb24|level=-99|color_range=N/A|color_space=unknown|color_transfer=unknown|color_primaries=unknown|chroma_location=unspecified|field_order=unknown|timecode=N/A|refs=1|id=N/A|r_frame_rate=25/1|avg_frame_rate=25/1|time_base=1/51200|start_pts=0|start_time=0.000000|duration_ts=N/A|duration=N/A|bit_rate=N/A|max_bit_rate=N/A|bits_per_raw_sample=N/A|nb_frames=N/A|nb_read_frames=4|nb_read_packets=4|disposition:default=0|disposition:dub=0|disposition:original=0|disposition:comment=0|disposition:lyrics=0|disposition:karaoke=0|disposition:forced=0|disposition:hearing_impaired=0|disposition:visual_impaired=0|disposition:clean_effects=0|disposition:attached_pic=0|disposition:timed_thumbnails=0|tag:encoder=Lavc rawvideo
-format|filename=tests/data/ffprobe-test.nut|nb_streams=3|nb_programs=0|format_name=nut|start_time=0.000000|duration=0.120000|size=1054887|bit_rate=70325800|probe_score=100|tag:title=ffprobe test file|tag:comment='A comment with CSV, XML & JSON special chars': <tag value="x">|tag:comment2=I ♥ Üñîçød€
+stream|index=1|codec_name=rawvideo|profile=unknown|codec_type=video|codec_time_base=1/25|codec_tag_string=RGB[24]|codec_tag=0x18424752|width=320|height=240|coded_width=320|coded_height=240|has_b_frames=0|sample_aspect_ratio=1:1|display_aspect_ratio=4:3|pix_fmt=rgb24|level=-99|color_range=unknown|color_space=unknown|color_transfer=unknown|color_primaries=unknown|chroma_location=unspecified|field_order=unknown|timecode=N/A|refs=1|id=N/A|r_frame_rate=25/1|avg_frame_rate=25/1|time_base=1/51200|start_pts=0|start_time=0.000000|duration_ts=N/A|duration=N/A|bit_rate=N/A|max_bit_rate=N/A|bits_per_raw_sample=N/A|nb_frames=N/A|nb_read_frames=4|nb_read_packets=4|disposition:default=0|disposition:dub=0|disposition:original=0|disposition:comment=0|disposition:lyrics=0|disposition:karaoke=0|disposition:forced=0|disposition:hearing_impaired=0|disposition:visual_impaired=0|disposition:clean_effects=0|disposition:attached_pic=0|disposition:timed_thumbnails=0|tag:title=foobar|tag:duration_ts=field-and-tags-conflict-attempt|tag:encoder=Lavc rawvideo
+stream|index=2|codec_name=rawvideo|profile=unknown|codec_type=video|codec_time_base=1/25|codec_tag_string=RGB[24]|codec_tag=0x18424752|width=100|height=100|coded_width=100|coded_height=100|has_b_frames=0|sample_aspect_ratio=1:1|display_aspect_ratio=1:1|pix_fmt=rgb24|level=-99|color_range=unknown|color_space=unknown|color_transfer=unknown|color_primaries=unknown|chroma_location=unspecified|field_order=unknown|timecode=N/A|refs=1|id=N/A|r_frame_rate=25/1|avg_frame_rate=25/1|time_base=1/51200|start_pts=0|start_time=0.000000|duration_ts=N/A|duration=N/A|bit_rate=N/A|max_bit_rate=N/A|bits_per_raw_sample=N/A|nb_frames=N/A|nb_read_frames=4|nb_read_packets=4|disposition:default=0|disposition:dub=0|disposition:original=0|disposition:comment=0|disposition:lyrics=0|disposition:karaoke=0|disposition:forced=0|disposition:hearing_impaired=0|disposition:visual_impaired=0|disposition:clean_effects=0|disposition:attached_pic=0|disposition:timed_thumbnails=0|tag:encoder=Lavc rawvideo
+format|filename=tests/data/ffprobe-test.nut|nb_streams=3|nb_programs=0|format_name=nut|start_time=0.000000|duration=0.120000|size=1053624|bit_rate=70241600|probe_score=100|tag:title=ffprobe test file|tag:comment='A comment with CSV, XML & JSON special chars': <tag value="x">|tag:comment2=I ♥ Üñîçød€
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_csv b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_csv
index 6265b3b1b28..dfbeb40e20e 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_csv
+++ b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_csv
@@ -1,32 +1,32 @@
 packet,audio,0,0,0.000000,0,0.000000,1024,0.023220,N/A,N/A,2048,647,K_
 frame,audio,0,1,0,0.000000,0,0.000000,0,0.000000,1024,0.023220,647,2048,s16,1024,1,unknown
 packet,video,1,0,0.000000,0,0.000000,2048,0.040000,N/A,N/A,230400,2722,K_
-frame,video,1,1,0,0.000000,0,0.000000,0,0.000000,2048,0.040000,2722,230400,320,240,rgb24,1:1,I,0,0,0,0,0
+frame,video,1,1,0,0.000000,0,0.000000,0,0.000000,2048,0.040000,2722,230400,320,240,rgb24,1:1,I,0,0,0,0,0,unknown,unknown,unknown,unknown,unspecified
 packet,video,2,0,0.000000,0,0.000000,2048,0.040000,N/A,N/A,30000,233143,K_
-frame,video,2,1,0,0.000000,0,0.000000,0,0.000000,2048,0.040000,233143,30000,100,100,rgb24,1:1,I,0,0,0,0,0
+frame,video,2,1,0,0.000000,0,0.000000,0,0.000000,2048,0.040000,233143,30000,100,100,rgb24,1:1,I,0,0,0,0,0,unknown,unknown,unknown,unknown,unspecified
 packet,audio,0,1024,0.023220,1024,0.023220,1024,0.023220,N/A,N/A,2048,263148,K_
 frame,audio,0,1,1024,0.023220,1024,0.023220,1024,0.023220,1024,0.023220,263148,2048,s16,1024,1,unknown
 packet,video,1,2048,0.040000,2048,0.040000,2048,0.040000,N/A,N/A,230400,265226,K_
-frame,video,1,1,2048,0.040000,2048,0.040000,2048,0.040000,2048,0.040000,265226,230400,320,240,rgb24,1:1,I,0,0,0,0,0
+frame,video,1,1,2048,0.040000,2048,0.040000,2048,0.040000,2048,0.040000,265226,230400,320,240,rgb24,1:1,I,0,0,0,0,0,unknown,unknown,unknown,unknown,unspecified
 packet,video,2,2048,0.040000,2048,0.040000,2048,0.040000,N/A,N/A,30000,495650,K_
-frame,video,2,1,2048,0.040000,2048,0.040000,2048,0.040000,2048,0.040000,495650,30000,100,100,rgb24,1:1,I,0,0,0,0,0
+frame,video,2,1,2048,0.040000,2048,0.040000,2048,0.040000,2048,0.040000,495650,30000,100,100,rgb24,1:1,I,0,0,0,0,0,unknown,unknown,unknown,unknown,unspecified
 packet,audio,0,2048,0.046440,2048,0.046440,1024,0.023220,N/A,N/A,2048,525655,K_
 frame,audio,0,1,2048,0.046440,2048,0.046440,2048,0.046440,1024,0.023220,525655,2048,s16,1024,1,unknown
 packet,audio,0,3072,0.069660,3072,0.069660,1024,0.023220,N/A,N/A,2048,527726,K_
 frame,audio,0,1,3072,0.069660,3072,0.069660,3072,0.069660,1024,0.023220,527726,2048,s16,1024,1,unknown
 packet,video,1,4096,0.080000,4096,0.080000,2048,0.040000,N/A,N/A,230400,529804,K_
-frame,video,1,1,4096,0.080000,4096,0.080000,4096,0.080000,2048,0.040000,529804,230400,320,240,rgb24,1:1,I,0,0,0,0,0
+frame,video,1,1,4096,0.080000,4096,0.080000,4096,0.080000,2048,0.040000,529804,230400,320,240,rgb24,1:1,I,0,0,0,0,0,unknown,unknown,unknown,unknown,unspecified
 packet,video,2,4096,0.080000,4096,0.080000,2048,0.040000,N/A,N/A,30000,760228,K_
-frame,video,2,1,4096,0.080000,4096,0.080000,4096,0.080000,2048,0.040000,760228,30000,100,100,rgb24,1:1,I,0,0,0,0,0
+frame,video,2,1,4096,0.080000,4096,0.080000,4096,0.080000,2048,0.040000,760228,30000,100,100,rgb24,1:1,I,0,0,0,0,0,unknown,unknown,unknown,unknown,unspecified
 packet,audio,0,4096,0.092880,4096,0.092880,1024,0.023220,N/A,N/A,2048,790233,K_
 frame,audio,0,1,4096,0.092880,4096,0.092880,4096,0.092880,1024,0.023220,790233,2048,s16,1024,1,unknown
-packet,audio,0,5120,0.116100,5120,0.116100,1024,0.023220,N/A,N/A,2048,792304,K_
-frame,audio,0,1,5120,0.116100,5120,0.116100,5120,0.116100,1024,0.023220,792304,2048,s16,1024,1,unknown
-packet,video,1,6144,0.120000,6144,0.120000,2048,0.040000,N/A,N/A,230400,794382,K_
-frame,video,1,1,6144,0.120000,6144,0.120000,6144,0.120000,2048,0.040000,794382,230400,320,240,rgb24,1:1,I,0,0,0,0,0
-packet,video,2,6144,0.120000,6144,0.120000,2048,0.040000,N/A,N/A,30000,1024806,K_
-frame,video,2,1,6144,0.120000,6144,0.120000,6144,0.120000,2048,0.040000,1024806,30000,100,100,rgb24,1:1,I,0,0,0,0,0
+packet,audio,0,5120,0.116100,5120,0.116100,393,0.008912,N/A,N/A,786,792304,K_
+frame,audio,0,1,5120,0.116100,5120,0.116100,5120,0.116100,393,0.008912,792304,786,s16,393,1,unknown
+packet,video,1,6144,0.120000,6144,0.120000,2048,0.040000,N/A,N/A,230400,793120,K_
+frame,video,1,1,6144,0.120000,6144,0.120000,6144,0.120000,2048,0.040000,793120,230400,320,240,rgb24,1:1,I,0,0,0,0,0,unknown,unknown,unknown,unknown,unspecified
+packet,video,2,6144,0.120000,6144,0.120000,2048,0.040000,N/A,N/A,30000,1023544,K_
+frame,video,2,1,6144,0.120000,6144,0.120000,6144,0.120000,2048,0.040000,1023544,30000,100,100,rgb24,1:1,I,0,0,0,0,0,unknown,unknown,unknown,unknown,unspecified
 stream,0,pcm_s16le,unknown,audio,1/44100,PSD[16],0x10445350,s16,44100,1,unknown,16,N/A,0/0,0/0,1/44100,0,0.000000,N/A,N/A,705600,N/A,N/A,N/A,6,6,0,0,0,0,0,0,0,0,0,0,0,0,mc²,Lavc pcm_s16le
-stream,1,rawvideo,unknown,video,1/25,RGB[24],0x18424752,320,240,320,240,0,1:1,4:3,rgb24,-99,N/A,unknown,unknown,unknown,unspecified,unknown,N/A,1,N/A,25/1,25/1,1/51200,0,0.000000,N/A,N/A,N/A,N/A,N/A,N/A,4,4,0,0,0,0,0,0,0,0,0,0,0,0,foobar,field-and-tags-conflict-attempt,Lavc rawvideo
-stream,2,rawvideo,unknown,video,1/25,RGB[24],0x18424752,100,100,100,100,0,1:1,1:1,rgb24,-99,N/A,unknown,unknown,unknown,unspecified,unknown,N/A,1,N/A,25/1,25/1,1/51200,0,0.000000,N/A,N/A,N/A,N/A,N/A,N/A,4,4,0,0,0,0,0,0,0,0,0,0,0,0,Lavc rawvideo
-format,tests/data/ffprobe-test.nut,3,0,nut,0.000000,0.120000,1054887,70325800,100,ffprobe test file,"'A comment with CSV, XML & JSON special chars': <tag value=""x"">",I ♥ Üñîçød€
+stream,1,rawvideo,unknown,video,1/25,RGB[24],0x18424752,320,240,320,240,0,1:1,4:3,rgb24,-99,unknown,unknown,unknown,unknown,unspecified,unknown,N/A,1,N/A,25/1,25/1,1/51200,0,0.000000,N/A,N/A,N/A,N/A,N/A,N/A,4,4,0,0,0,0,0,0,0,0,0,0,0,0,foobar,field-and-tags-conflict-attempt,Lavc rawvideo
+stream,2,rawvideo,unknown,video,1/25,RGB[24],0x18424752,100,100,100,100,0,1:1,1:1,rgb24,-99,unknown,unknown,unknown,unknown,unspecified,unknown,N/A,1,N/A,25/1,25/1,1/51200,0,0.000000,N/A,N/A,N/A,N/A,N/A,N/A,4,4,0,0,0,0,0,0,0,0,0,0,0,0,Lavc rawvideo
+format,tests/data/ffprobe-test.nut,3,0,nut,0.000000,0.120000,1053624,70241600,100,ffprobe test file,"'A comment with CSV, XML & JSON special chars': <tag value=""x"">",I ♥ Üñîçød€
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_default b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_default
index deaaae58b44..7562867e19c 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_default
+++ b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_default
@@ -71,6 +71,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 [/FRAME]
 [PACKET]
 codec_type=video
@@ -111,6 +116,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 [/FRAME]
 [PACKET]
 codec_type=audio
@@ -185,6 +195,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 [/FRAME]
 [PACKET]
 codec_type=video
@@ -225,6 +240,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 [/FRAME]
 [PACKET]
 codec_type=audio
@@ -333,6 +353,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 [/FRAME]
 [PACKET]
 codec_type=video
@@ -373,6 +398,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 [/FRAME]
 [PACKET]
 codec_type=audio
@@ -415,11 +445,11 @@ pts=5120
 pts_time=0.116100
 dts=5120
 dts_time=0.116100
-duration=1024
-duration_time=0.023220
+duration=393
+duration_time=0.008912
 convergence_duration=N/A
 convergence_duration_time=N/A
-size=2048
+size=786
 pos=792304
 flags=K_
 [/PACKET]
@@ -433,12 +463,12 @@ pkt_dts=5120
 pkt_dts_time=0.116100
 best_effort_timestamp=5120
 best_effort_timestamp_time=0.116100
-pkt_duration=1024
-pkt_duration_time=0.023220
+pkt_duration=393
+pkt_duration_time=0.008912
 pkt_pos=792304
-pkt_size=2048
+pkt_size=786
 sample_fmt=s16
-nb_samples=1024
+nb_samples=393
 channels=1
 channel_layout=unknown
 [/FRAME]
@@ -454,7 +484,7 @@ duration_time=0.040000
 convergence_duration=N/A
 convergence_duration_time=N/A
 size=230400
-pos=794382
+pos=793120
 flags=K_
 [/PACKET]
 [FRAME]
@@ -469,7 +499,7 @@ best_effort_timestamp=6144
 best_effort_timestamp_time=0.120000
 pkt_duration=2048
 pkt_duration_time=0.040000
-pkt_pos=794382
+pkt_pos=793120
 pkt_size=230400
 width=320
 height=240
@@ -481,6 +511,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 [/FRAME]
 [PACKET]
 codec_type=video
@@ -494,7 +529,7 @@ duration_time=0.040000
 convergence_duration=N/A
 convergence_duration_time=N/A
 size=30000
-pos=1024806
+pos=1023544
 flags=K_
 [/PACKET]
 [FRAME]
@@ -509,7 +544,7 @@ best_effort_timestamp=6144
 best_effort_timestamp_time=0.120000
 pkt_duration=2048
 pkt_duration_time=0.040000
-pkt_pos=1024806
+pkt_pos=1023544
 pkt_size=30000
 width=100
 height=100
@@ -521,6 +556,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 [/FRAME]
 [STREAM]
 index=0
@@ -581,7 +621,7 @@ sample_aspect_ratio=1:1
 display_aspect_ratio=4:3
 pix_fmt=rgb24
 level=-99
-color_range=N/A
+color_range=unknown
 color_space=unknown
 color_transfer=unknown
 color_primaries=unknown
@@ -636,7 +676,7 @@ sample_aspect_ratio=1:1
 display_aspect_ratio=1:1
 pix_fmt=rgb24
 level=-99
-color_range=N/A
+color_range=unknown
 color_space=unknown
 color_transfer=unknown
 color_primaries=unknown
@@ -679,8 +719,8 @@ nb_programs=0
 format_name=nut
 start_time=0.000000
 duration=0.120000
-size=1054887
-bit_rate=70325800
+size=1053624
+bit_rate=70241600
 probe_score=100
 TAG:title=ffprobe test file
 TAG:comment='A comment with CSV, XML & JSON special chars': <tag value="x">
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_flat b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_flat
index 69f25b49134..fc82ee925d2 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_flat
+++ b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_flat
@@ -64,6 +64,11 @@ packets_and_frames.frame.1.display_picture_number=0
 packets_and_frames.frame.1.interlaced_frame=0
 packets_and_frames.frame.1.top_field_first=0
 packets_and_frames.frame.1.repeat_pict=0
+packets_and_frames.frame.1.color_range="unknown"
+packets_and_frames.frame.1.color_space="unknown"
+packets_and_frames.frame.1.color_primaries="unknown"
+packets_and_frames.frame.1.color_transfer="unknown"
+packets_and_frames.frame.1.chroma_location="unspecified"
 packets_and_frames.packet.2.codec_type="video"
 packets_and_frames.packet.2.stream_index=2
 packets_and_frames.packet.2.pts=0
@@ -100,6 +105,11 @@ packets_and_frames.frame.2.display_picture_number=0
 packets_and_frames.frame.2.interlaced_frame=0
 packets_and_frames.frame.2.top_field_first=0
 packets_and_frames.frame.2.repeat_pict=0
+packets_and_frames.frame.2.color_range="unknown"
+packets_and_frames.frame.2.color_space="unknown"
+packets_and_frames.frame.2.color_primaries="unknown"
+packets_and_frames.frame.2.color_transfer="unknown"
+packets_and_frames.frame.2.chroma_location="unspecified"
 packets_and_frames.packet.3.codec_type="audio"
 packets_and_frames.packet.3.stream_index=0
 packets_and_frames.packet.3.pts=1024
@@ -166,6 +176,11 @@ packets_and_frames.frame.4.display_picture_number=0
 packets_and_frames.frame.4.interlaced_frame=0
 packets_and_frames.frame.4.top_field_first=0
 packets_and_frames.frame.4.repeat_pict=0
+packets_and_frames.frame.4.color_range="unknown"
+packets_and_frames.frame.4.color_space="unknown"
+packets_and_frames.frame.4.color_primaries="unknown"
+packets_and_frames.frame.4.color_transfer="unknown"
+packets_and_frames.frame.4.chroma_location="unspecified"
 packets_and_frames.packet.5.codec_type="video"
 packets_and_frames.packet.5.stream_index=2
 packets_and_frames.packet.5.pts=2048
@@ -202,6 +217,11 @@ packets_and_frames.frame.5.display_picture_number=0
 packets_and_frames.frame.5.interlaced_frame=0
 packets_and_frames.frame.5.top_field_first=0
 packets_and_frames.frame.5.repeat_pict=0
+packets_and_frames.frame.5.color_range="unknown"
+packets_and_frames.frame.5.color_space="unknown"
+packets_and_frames.frame.5.color_primaries="unknown"
+packets_and_frames.frame.5.color_transfer="unknown"
+packets_and_frames.frame.5.chroma_location="unspecified"
 packets_and_frames.packet.6.codec_type="audio"
 packets_and_frames.packet.6.stream_index=0
 packets_and_frames.packet.6.pts=2048
@@ -298,6 +318,11 @@ packets_and_frames.frame.8.display_picture_number=0
 packets_and_frames.frame.8.interlaced_frame=0
 packets_and_frames.frame.8.top_field_first=0
 packets_and_frames.frame.8.repeat_pict=0
+packets_and_frames.frame.8.color_range="unknown"
+packets_and_frames.frame.8.color_space="unknown"
+packets_and_frames.frame.8.color_primaries="unknown"
+packets_and_frames.frame.8.color_transfer="unknown"
+packets_and_frames.frame.8.chroma_location="unspecified"
 packets_and_frames.packet.9.codec_type="video"
 packets_and_frames.packet.9.stream_index=2
 packets_and_frames.packet.9.pts=4096
@@ -334,6 +359,11 @@ packets_and_frames.frame.9.display_picture_number=0
 packets_and_frames.frame.9.interlaced_frame=0
 packets_and_frames.frame.9.top_field_first=0
 packets_and_frames.frame.9.repeat_pict=0
+packets_and_frames.frame.9.color_range="unknown"
+packets_and_frames.frame.9.color_space="unknown"
+packets_and_frames.frame.9.color_primaries="unknown"
+packets_and_frames.frame.9.color_transfer="unknown"
+packets_and_frames.frame.9.chroma_location="unspecified"
 packets_and_frames.packet.10.codec_type="audio"
 packets_and_frames.packet.10.stream_index=0
 packets_and_frames.packet.10.pts=4096
@@ -370,11 +400,11 @@ packets_and_frames.packet.11.pts=5120
 packets_and_frames.packet.11.pts_time="0.116100"
 packets_and_frames.packet.11.dts=5120
 packets_and_frames.packet.11.dts_time="0.116100"
-packets_and_frames.packet.11.duration=1024
-packets_and_frames.packet.11.duration_time="0.023220"
+packets_and_frames.packet.11.duration=393
+packets_and_frames.packet.11.duration_time="0.008912"
 packets_and_frames.packet.11.convergence_duration="N/A"
 packets_and_frames.packet.11.convergence_duration_time="N/A"
-packets_and_frames.packet.11.size="2048"
+packets_and_frames.packet.11.size="786"
 packets_and_frames.packet.11.pos="792304"
 packets_and_frames.packet.11.flags="K_"
 packets_and_frames.frame.11.media_type="audio"
@@ -386,12 +416,12 @@ packets_and_frames.frame.11.pkt_dts=5120
 packets_and_frames.frame.11.pkt_dts_time="0.116100"
 packets_and_frames.frame.11.best_effort_timestamp=5120
 packets_and_frames.frame.11.best_effort_timestamp_time="0.116100"
-packets_and_frames.frame.11.pkt_duration=1024
-packets_and_frames.frame.11.pkt_duration_time="0.023220"
+packets_and_frames.frame.11.pkt_duration=393
+packets_and_frames.frame.11.pkt_duration_time="0.008912"
 packets_and_frames.frame.11.pkt_pos="792304"
-packets_and_frames.frame.11.pkt_size="2048"
+packets_and_frames.frame.11.pkt_size="786"
 packets_and_frames.frame.11.sample_fmt="s16"
-packets_and_frames.frame.11.nb_samples=1024
+packets_and_frames.frame.11.nb_samples=393
 packets_and_frames.frame.11.channels=1
 packets_and_frames.frame.11.channel_layout="unknown"
 packets_and_frames.packet.12.codec_type="video"
@@ -405,7 +435,7 @@ packets_and_frames.packet.12.duration_time="0.040000"
 packets_and_frames.packet.12.convergence_duration="N/A"
 packets_and_frames.packet.12.convergence_duration_time="N/A"
 packets_and_frames.packet.12.size="230400"
-packets_and_frames.packet.12.pos="794382"
+packets_and_frames.packet.12.pos="793120"
 packets_and_frames.packet.12.flags="K_"
 packets_and_frames.frame.12.media_type="video"
 packets_and_frames.frame.12.stream_index=1
@@ -418,7 +448,7 @@ packets_and_frames.frame.12.best_effort_timestamp=6144
 packets_and_frames.frame.12.best_effort_timestamp_time="0.120000"
 packets_and_frames.frame.12.pkt_duration=2048
 packets_and_frames.frame.12.pkt_duration_time="0.040000"
-packets_and_frames.frame.12.pkt_pos="794382"
+packets_and_frames.frame.12.pkt_pos="793120"
 packets_and_frames.frame.12.pkt_size="230400"
 packets_and_frames.frame.12.width=320
 packets_and_frames.frame.12.height=240
@@ -430,6 +460,11 @@ packets_and_frames.frame.12.display_picture_number=0
 packets_and_frames.frame.12.interlaced_frame=0
 packets_and_frames.frame.12.top_field_first=0
 packets_and_frames.frame.12.repeat_pict=0
+packets_and_frames.frame.12.color_range="unknown"
+packets_and_frames.frame.12.color_space="unknown"
+packets_and_frames.frame.12.color_primaries="unknown"
+packets_and_frames.frame.12.color_transfer="unknown"
+packets_and_frames.frame.12.chroma_location="unspecified"
 packets_and_frames.packet.13.codec_type="video"
 packets_and_frames.packet.13.stream_index=2
 packets_and_frames.packet.13.pts=6144
@@ -441,7 +476,7 @@ packets_and_frames.packet.13.duration_time="0.040000"
 packets_and_frames.packet.13.convergence_duration="N/A"
 packets_and_frames.packet.13.convergence_duration_time="N/A"
 packets_and_frames.packet.13.size="30000"
-packets_and_frames.packet.13.pos="1024806"
+packets_and_frames.packet.13.pos="1023544"
 packets_and_frames.packet.13.flags="K_"
 packets_and_frames.frame.13.media_type="video"
 packets_and_frames.frame.13.stream_index=2
@@ -454,7 +489,7 @@ packets_and_frames.frame.13.best_effort_timestamp=6144
 packets_and_frames.frame.13.best_effort_timestamp_time="0.120000"
 packets_and_frames.frame.13.pkt_duration=2048
 packets_and_frames.frame.13.pkt_duration_time="0.040000"
-packets_and_frames.frame.13.pkt_pos="1024806"
+packets_and_frames.frame.13.pkt_pos="1023544"
 packets_and_frames.frame.13.pkt_size="30000"
 packets_and_frames.frame.13.width=100
 packets_and_frames.frame.13.height=100
@@ -466,6 +501,11 @@ packets_and_frames.frame.13.display_picture_number=0
 packets_and_frames.frame.13.interlaced_frame=0
 packets_and_frames.frame.13.top_field_first=0
 packets_and_frames.frame.13.repeat_pict=0
+packets_and_frames.frame.13.color_range="unknown"
+packets_and_frames.frame.13.color_space="unknown"
+packets_and_frames.frame.13.color_primaries="unknown"
+packets_and_frames.frame.13.color_transfer="unknown"
+packets_and_frames.frame.13.chroma_location="unspecified"
 streams.stream.0.index=0
 streams.stream.0.codec_name="pcm_s16le"
 streams.stream.0.profile="unknown"
@@ -522,7 +562,7 @@ streams.stream.1.sample_aspect_ratio="1:1"
 streams.stream.1.display_aspect_ratio="4:3"
 streams.stream.1.pix_fmt="rgb24"
 streams.stream.1.level=-99
-streams.stream.1.color_range="N/A"
+streams.stream.1.color_range="unknown"
 streams.stream.1.color_space="unknown"
 streams.stream.1.color_transfer="unknown"
 streams.stream.1.color_primaries="unknown"
@@ -575,7 +615,7 @@ streams.stream.2.sample_aspect_ratio="1:1"
 streams.stream.2.display_aspect_ratio="1:1"
 streams.stream.2.pix_fmt="rgb24"
 streams.stream.2.level=-99
-streams.stream.2.color_range="N/A"
+streams.stream.2.color_range="unknown"
 streams.stream.2.color_space="unknown"
 streams.stream.2.color_transfer="unknown"
 streams.stream.2.color_primaries="unknown"
@@ -616,8 +656,8 @@ format.nb_programs=0
 format.format_name="nut"
 format.start_time="0.000000"
 format.duration="0.120000"
-format.size="1054887"
-format.bit_rate="70325800"
+format.size="1053624"
+format.bit_rate="70241600"
 format.probe_score=100
 format.tags.title="ffprobe test file"
 format.tags.comment="'A comment with CSV, XML & JSON special chars': <tag value=\"x\">"
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_ini b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_ini
index 986dd083f92..a78690cc29a 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_ini
+++ b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_ini
@@ -73,6 +73,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 
 [packets_and_frames.packet.2]
 codec_type=video
@@ -113,6 +118,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 
 [packets_and_frames.packet.3]
 codec_type=audio
@@ -187,6 +197,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 
 [packets_and_frames.packet.5]
 codec_type=video
@@ -227,6 +242,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 
 [packets_and_frames.packet.6]
 codec_type=audio
@@ -335,6 +355,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 
 [packets_and_frames.packet.9]
 codec_type=video
@@ -375,6 +400,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 
 [packets_and_frames.packet.10]
 codec_type=audio
@@ -417,11 +447,11 @@ pts=5120
 pts_time=0.116100
 dts=5120
 dts_time=0.116100
-duration=1024
-duration_time=0.023220
+duration=393
+duration_time=0.008912
 convergence_duration=N/A
 convergence_duration_time=N/A
-size=2048
+size=786
 pos=792304
 flags=K_
 
@@ -435,12 +465,12 @@ pkt_dts=5120
 pkt_dts_time=0.116100
 best_effort_timestamp=5120
 best_effort_timestamp_time=0.116100
-pkt_duration=1024
-pkt_duration_time=0.023220
+pkt_duration=393
+pkt_duration_time=0.008912
 pkt_pos=792304
-pkt_size=2048
+pkt_size=786
 sample_fmt=s16
-nb_samples=1024
+nb_samples=393
 channels=1
 channel_layout=unknown
 
@@ -456,7 +486,7 @@ duration_time=0.040000
 convergence_duration=N/A
 convergence_duration_time=N/A
 size=230400
-pos=794382
+pos=793120
 flags=K_
 
 [packets_and_frames.frame.12]
@@ -471,7 +501,7 @@ best_effort_timestamp=6144
 best_effort_timestamp_time=0.120000
 pkt_duration=2048
 pkt_duration_time=0.040000
-pkt_pos=794382
+pkt_pos=793120
 pkt_size=230400
 width=320
 height=240
@@ -483,6 +513,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 
 [packets_and_frames.packet.13]
 codec_type=video
@@ -496,7 +531,7 @@ duration_time=0.040000
 convergence_duration=N/A
 convergence_duration_time=N/A
 size=30000
-pos=1024806
+pos=1023544
 flags=K_
 
 [packets_and_frames.frame.13]
@@ -511,7 +546,7 @@ best_effort_timestamp=6144
 best_effort_timestamp_time=0.120000
 pkt_duration=2048
 pkt_duration_time=0.040000
-pkt_pos=1024806
+pkt_pos=1023544
 pkt_size=30000
 width=100
 height=100
@@ -523,6 +558,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=unspecified
 
 [streams.stream.0]
 index=0
@@ -587,7 +627,7 @@ sample_aspect_ratio=1\:1
 display_aspect_ratio=4\:3
 pix_fmt=rgb24
 level=-99
-color_range=N/A
+color_range=unknown
 color_space=unknown
 color_transfer=unknown
 color_primaries=unknown
@@ -646,7 +686,7 @@ sample_aspect_ratio=1\:1
 display_aspect_ratio=1\:1
 pix_fmt=rgb24
 level=-99
-color_range=N/A
+color_range=unknown
 color_space=unknown
 color_transfer=unknown
 color_primaries=unknown
@@ -693,8 +733,8 @@ nb_programs=0
 format_name=nut
 start_time=0.000000
 duration=0.120000
-size=1054887
-bit_rate=70325800
+size=1053624
+bit_rate=70241600
 probe_score=100
 
 [format.tags]
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_json b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_json
index 25f97bdc831..4bb93d07e16 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_json
+++ b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_json
@@ -413,9 +413,9 @@
             "pts_time": "0.116100",
             "dts": 5120,
             "dts_time": "0.116100",
-            "duration": 1024,
-            "duration_time": "0.023220",
-            "size": "2048",
+            "duration": 393,
+            "duration_time": "0.008912",
+            "size": "786",
             "pos": "792304",
             "flags": "K_"
         },
@@ -430,12 +430,12 @@
             "pkt_dts_time": "0.116100",
             "best_effort_timestamp": 5120,
             "best_effort_timestamp_time": "0.116100",
-            "pkt_duration": 1024,
-            "pkt_duration_time": "0.023220",
+            "pkt_duration": 393,
+            "pkt_duration_time": "0.008912",
             "pkt_pos": "792304",
-            "pkt_size": "2048",
+            "pkt_size": "786",
             "sample_fmt": "s16",
-            "nb_samples": 1024,
+            "nb_samples": 393,
             "channels": 1
         },
         {
@@ -449,7 +449,7 @@
             "duration": 2048,
             "duration_time": "0.040000",
             "size": "230400",
-            "pos": "794382",
+            "pos": "793120",
             "flags": "K_"
         },
         {
@@ -465,7 +465,7 @@
             "best_effort_timestamp_time": "0.120000",
             "pkt_duration": 2048,
             "pkt_duration_time": "0.040000",
-            "pkt_pos": "794382",
+            "pkt_pos": "793120",
             "pkt_size": "230400",
             "width": 320,
             "height": 240,
@@ -489,7 +489,7 @@
             "duration": 2048,
             "duration_time": "0.040000",
             "size": "30000",
-            "pos": "1024806",
+            "pos": "1023544",
             "flags": "K_"
         },
         {
@@ -505,7 +505,7 @@
             "best_effort_timestamp_time": "0.120000",
             "pkt_duration": 2048,
             "pkt_duration_time": "0.040000",
-            "pkt_pos": "1024806",
+            "pkt_pos": "1023544",
             "pkt_size": "30000",
             "width": 100,
             "height": 100,
@@ -652,8 +652,8 @@
         "format_name": "nut",
         "start_time": "0.000000",
         "duration": "0.120000",
-        "size": "1054887",
-        "bit_rate": "70325800",
+        "size": "1053624",
+        "bit_rate": "70241600",
         "probe_score": 100,
         "tags": {
             "title": "ffprobe test file",
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_xml b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_xml
index c574ca8fa2d..d2c5ecdf734 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_xml
+++ b/mythtv/external/FFmpeg/tests/ref/fate/ffprobe_xml
@@ -23,12 +23,12 @@
         <frame media_type="video" stream_index="2" key_frame="1" pkt_pts="4096" pkt_pts_time="0.080000" pkt_dts="4096" pkt_dts_time="0.080000" best_effort_timestamp="4096" best_effort_timestamp_time="0.080000" pkt_duration="2048" pkt_duration_time="0.040000" pkt_pos="760228" pkt_size="30000" width="100" height="100" pix_fmt="rgb24" sample_aspect_ratio="1:1" pict_type="I" coded_picture_number="0" display_picture_number="0" interlaced_frame="0" top_field_first="0" repeat_pict="0"/>
         <packet codec_type="audio" stream_index="0" pts="4096" pts_time="0.092880" dts="4096" dts_time="0.092880" duration="1024" duration_time="0.023220" size="2048" pos="790233" flags="K_"/>
         <frame media_type="audio" stream_index="0" key_frame="1" pkt_pts="4096" pkt_pts_time="0.092880" pkt_dts="4096" pkt_dts_time="0.092880" best_effort_timestamp="4096" best_effort_timestamp_time="0.092880" pkt_duration="1024" pkt_duration_time="0.023220" pkt_pos="790233" pkt_size="2048" sample_fmt="s16" nb_samples="1024" channels="1"/>
-        <packet codec_type="audio" stream_index="0" pts="5120" pts_time="0.116100" dts="5120" dts_time="0.116100" duration="1024" duration_time="0.023220" size="2048" pos="792304" flags="K_"/>
-        <frame media_type="audio" stream_index="0" key_frame="1" pkt_pts="5120" pkt_pts_time="0.116100" pkt_dts="5120" pkt_dts_time="0.116100" best_effort_timestamp="5120" best_effort_timestamp_time="0.116100" pkt_duration="1024" pkt_duration_time="0.023220" pkt_pos="792304" pkt_size="2048" sample_fmt="s16" nb_samples="1024" channels="1"/>
-        <packet codec_type="video" stream_index="1" pts="6144" pts_time="0.120000" dts="6144" dts_time="0.120000" duration="2048" duration_time="0.040000" size="230400" pos="794382" flags="K_"/>
-        <frame media_type="video" stream_index="1" key_frame="1" pkt_pts="6144" pkt_pts_time="0.120000" pkt_dts="6144" pkt_dts_time="0.120000" best_effort_timestamp="6144" best_effort_timestamp_time="0.120000" pkt_duration="2048" pkt_duration_time="0.040000" pkt_pos="794382" pkt_size="230400" width="320" height="240" pix_fmt="rgb24" sample_aspect_ratio="1:1" pict_type="I" coded_picture_number="0" display_picture_number="0" interlaced_frame="0" top_field_first="0" repeat_pict="0"/>
-        <packet codec_type="video" stream_index="2" pts="6144" pts_time="0.120000" dts="6144" dts_time="0.120000" duration="2048" duration_time="0.040000" size="30000" pos="1024806" flags="K_"/>
-        <frame media_type="video" stream_index="2" key_frame="1" pkt_pts="6144" pkt_pts_time="0.120000" pkt_dts="6144" pkt_dts_time="0.120000" best_effort_timestamp="6144" best_effort_timestamp_time="0.120000" pkt_duration="2048" pkt_duration_time="0.040000" pkt_pos="1024806" pkt_size="30000" width="100" height="100" pix_fmt="rgb24" sample_aspect_ratio="1:1" pict_type="I" coded_picture_number="0" display_picture_number="0" interlaced_frame="0" top_field_first="0" repeat_pict="0"/>
+        <packet codec_type="audio" stream_index="0" pts="5120" pts_time="0.116100" dts="5120" dts_time="0.116100" duration="393" duration_time="0.008912" size="786" pos="792304" flags="K_"/>
+        <frame media_type="audio" stream_index="0" key_frame="1" pkt_pts="5120" pkt_pts_time="0.116100" pkt_dts="5120" pkt_dts_time="0.116100" best_effort_timestamp="5120" best_effort_timestamp_time="0.116100" pkt_duration="393" pkt_duration_time="0.008912" pkt_pos="792304" pkt_size="786" sample_fmt="s16" nb_samples="393" channels="1"/>
+        <packet codec_type="video" stream_index="1" pts="6144" pts_time="0.120000" dts="6144" dts_time="0.120000" duration="2048" duration_time="0.040000" size="230400" pos="793120" flags="K_"/>
+        <frame media_type="video" stream_index="1" key_frame="1" pkt_pts="6144" pkt_pts_time="0.120000" pkt_dts="6144" pkt_dts_time="0.120000" best_effort_timestamp="6144" best_effort_timestamp_time="0.120000" pkt_duration="2048" pkt_duration_time="0.040000" pkt_pos="793120" pkt_size="230400" width="320" height="240" pix_fmt="rgb24" sample_aspect_ratio="1:1" pict_type="I" coded_picture_number="0" display_picture_number="0" interlaced_frame="0" top_field_first="0" repeat_pict="0"/>
+        <packet codec_type="video" stream_index="2" pts="6144" pts_time="0.120000" dts="6144" dts_time="0.120000" duration="2048" duration_time="0.040000" size="30000" pos="1023544" flags="K_"/>
+        <frame media_type="video" stream_index="2" key_frame="1" pkt_pts="6144" pkt_pts_time="0.120000" pkt_dts="6144" pkt_dts_time="0.120000" best_effort_timestamp="6144" best_effort_timestamp_time="0.120000" pkt_duration="2048" pkt_duration_time="0.040000" pkt_pos="1023544" pkt_size="30000" width="100" height="100" pix_fmt="rgb24" sample_aspect_ratio="1:1" pict_type="I" coded_picture_number="0" display_picture_number="0" interlaced_frame="0" top_field_first="0" repeat_pict="0"/>
     </packets_and_frames>
 
     <streams>
@@ -49,7 +49,7 @@
         </stream>
     </streams>
 
-    <format filename="tests/data/ffprobe-test.nut" nb_streams="3" nb_programs="0" format_name="nut" start_time="0.000000" duration="0.120000" size="1054887" bit_rate="70325800" probe_score="100">
+    <format filename="tests/data/ffprobe-test.nut" nb_streams="3" nb_programs="0" format_name="nut" start_time="0.000000" duration="0.120000" size="1053624" bit_rate="70241600" probe_score="100">
         <tag key="title" value="ffprobe test file"/>
         <tag key="comment" value="&apos;A comment with CSV, XML &amp; JSON special chars&apos;: &lt;tag value=&quot;x&quot;&gt;"/>
         <tag key="comment2" value="I ♥ Üñîçød€"/>
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-acrossfade b/mythtv/external/FFmpeg/tests/ref/fate/filter-acrossfade
index b89f25d757c..0567b022e87 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-acrossfade
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-acrossfade
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,      888,     3552, 0x592ce6cc
 0,        888,        888,     1024,     4096, 0x20f6f6a9
 0,       1912,       1912,     1024,     4096, 0x3f840122
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-adelay b/mythtv/external/FFmpeg/tests/ref/fate/filter-adelay
index a03f516e4ae..e3ff763602b 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-adelay
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-adelay
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x9d7bf760
 0,       1024,       1024,     1024,     4096, 0xdf42c46b
 0,       2048,       2048,     1024,     4096, 0x2214fd20
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-aecho b/mythtv/external/FFmpeg/tests/ref/fate/filter-aecho
index f564fcca5d9..2c88c37fbc2 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-aecho
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-aecho
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x3019edd5
 0,       1024,       1024,     1024,     4096, 0x2df2fe2f
 0,       2048,       2048,     1024,     4096, 0xde37ff37
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-aemphasis-50fm b/mythtv/external/FFmpeg/tests/ref/fate/filter-aemphasis-50fm
index bae123cc89d..649cd449be5 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-aemphasis-50fm
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-aemphasis-50fm
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0xb9c5fefd
 0,       1024,       1024,     1024,     4096, 0xb2ae0a90
 0,       2048,       2048,     1024,     4096, 0x97e6e9f3
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-aemphasis-75kf b/mythtv/external/FFmpeg/tests/ref/fate/filter-aemphasis-75kf
index c40a38958a3..5705e983385 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-aemphasis-75kf
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-aemphasis-75kf
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x7b2101ec
 0,       1024,       1024,     1024,     4096, 0x5c16fc93
 0,       2048,       2048,     1024,     4096, 0x62bdee5d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-esin b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-esin
index b02c7ff92cc..f9b910c693a 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-esin
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-esin
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x06e0d68a
 0,       1024,       1024,     1024,     4096, 0xb325d915
 0,       2048,       2048,     1024,     4096, 0xc0a5f1f1
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-exp b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-exp
index f98db38d245..a0c519cd8b0 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-exp
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-exp
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x00000000
 0,       1024,       1024,     1024,     4096, 0x00000000
 0,       2048,       2048,     1024,     4096, 0x00000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-hsin b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-hsin
index 7e51a8c362c..2c6a0e3a1ed 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-hsin
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-hsin
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x2042232e
 0,       1024,       1024,     1024,     4096, 0x2c073cf7
 0,       2048,       2048,     1024,     4096, 0x92fecae5
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-iqsin b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-iqsin
index aa7eea709f8..fc22baf913b 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-iqsin
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-iqsin
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x220e908d
 0,       1024,       1024,     1024,     4096, 0xdd65002e
 0,       2048,       2048,     1024,     4096, 0x8072fb25
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-log b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-log
index 03d57940982..99ac0b36d81 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-log
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-log
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0xf01adbd3
 0,       1024,       1024,     1024,     4096, 0xbbe10f8e
 0,       2048,       2048,     1024,     4096, 0xbf04fccf
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-qsin b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-qsin
index a6586b1687b..026fbbcc44e 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-qsin
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-afade-qsin
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0xd977ce0f
 0,       1024,       1024,     1024,     4096, 0x9333f5b1
 0,       2048,       2048,     1024,     4096, 0xf1a30794
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-agate b/mythtv/external/FFmpeg/tests/ref/fate/filter-agate
index 4f7b10e7116..b6e732a86e3 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-agate
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-agate
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x1af20090
 0,       1024,       1024,     1024,     4096, 0x0b05ef2d
 0,       2048,       2048,     1024,     4096, 0x574bf11d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-alimiter b/mythtv/external/FFmpeg/tests/ref/fate/filter-alimiter
index 06e23f104cc..aef9765a83e 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-alimiter
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-alimiter
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0xd4194af4
 0,       1024,       1024,     1024,     4096, 0x686af4ab
 0,       2048,       2048,     1024,     4096, 0xe80cee61
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-allrgb b/mythtv/external/FFmpeg/tests/ref/fate/filter-allrgb
new file mode 100644
index 00000000000..b54efc55043
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-allrgb
@@ -0,0 +1,10 @@
+#tb 0: 1/5
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 4096x4096
+#sar 0: 1/1
+0,          0,          0,        1, 50331648, 0x9cc26aca
+0,          1,          1,        1, 50331648, 0x9cc26aca
+0,          2,          2,        1, 50331648, 0x9cc26aca
+0,          3,          3,        1, 50331648, 0x9cc26aca
+0,          4,          4,        1, 50331648, 0x9cc26aca
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-allyuv b/mythtv/external/FFmpeg/tests/ref/fate/filter-allyuv
new file mode 100644
index 00000000000..477992f0ea4
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-allyuv
@@ -0,0 +1,10 @@
+#tb 0: 1/5
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 4096x4096
+#sar 0: 1/1
+0,          0,          0,        1, 50331648, 0x70b16aca
+0,          1,          1,        1, 50331648, 0x70b16aca
+0,          2,          2,        1, 50331648, 0x70b16aca
+0,          3,          3,        1, 50331648, 0x70b16aca
+0,          4,          4,        1, 50331648, 0x70b16aca
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-amerge b/mythtv/external/FFmpeg/tests/ref/fate/filter-amerge
index 006383af571..b3e5eb50cc8 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-amerge
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-amerge
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     2048,     8192, 0x120efa65
 0,       2048,       2048,     2048,     8192, 0x7b3cebf7
 0,       4096,       4096,     2048,     8192, 0x0fb8ee01
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-anequalizer b/mythtv/external/FFmpeg/tests/ref/fate/filter-anequalizer
index 21c7aaf31f6..caed836bdf2 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-anequalizer
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-anequalizer
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x8e1bf8e0
 0,       1024,       1024,     1024,     4096, 0xe315f564
 0,       2048,       2048,     1024,     4096, 0x3d0efa98
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-apad b/mythtv/external/FFmpeg/tests/ref/fate/filter-apad
index 194a459540f..9bf662d46ab 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-apad
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-apad
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x29e3eecf
 0,       1024,       1024,     1024,     4096, 0x18390b96
 0,       2048,       2048,     1024,     4096, 0xc477fa99
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-asetnsamples-nopad b/mythtv/external/FFmpeg/tests/ref/fate/filter-asetnsamples-nopad
new file mode 100644
index 00000000000..c1cc01a7102
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-asetnsamples-nopad
@@ -0,0 +1,523 @@
+#tb 0: 1/44100
+#media_type 0: audio
+#codec_id 0: pcm_s16le
+#sample_rate 0: 44100
+#channel_layout 0: 3
+#channel_layout_name 0: stereo
+0,          0,          0,      512,     2048, 0xd2dbf701
+0,        512,        512,      512,     2048, 0xdb22f7bf
+0,       1024,       1024,      512,     2048, 0x82a103be
+0,       1536,       1536,      512,     2048, 0xa3c707d8
+0,       2048,       2048,      512,     2048, 0x8aaafb8f
+0,       2560,       2560,      512,     2048, 0x4bdafefb
+0,       3072,       3072,      512,     2048, 0x75a3e833
+0,       3584,       3584,      512,     2048, 0xc130091c
+0,       4096,       4096,      512,     2048, 0x99d8f36d
+0,       4608,       4608,      512,     2048, 0xaf6efa15
+0,       5120,       5120,      512,     2048, 0xff5f0506
+0,       5632,       5632,      512,     2048, 0xcba4fb5b
+0,       6144,       6144,      512,     2048, 0x729309c6
+0,       6656,       6656,      512,     2048, 0x63cdeb09
+0,       7168,       7168,      512,     2048, 0x386cfccb
+0,       7680,       7680,      512,     2048, 0x602100c8
+0,       8192,       8192,      512,     2048, 0x3573f565
+0,       8704,       8704,      512,     2048, 0x47b9fce7
+0,       9216,       9216,      512,     2048, 0xd1e90b7a
+0,       9728,       9728,      512,     2048, 0xf4c3ef77
+0,      10240,      10240,      512,     2048, 0x59ebfe3f
+0,      10752,      10752,      512,     2048, 0x02d4f161
+0,      11264,      11264,      512,     2048, 0xbbf5ff05
+0,      11776,      11776,      512,     2048, 0xe26a047c
+0,      12288,      12288,      512,     2048, 0x5452f02b
+0,      12800,      12800,      512,     2048, 0x961e1056
+0,      13312,      13312,      512,     2048, 0x9192f803
+0,      13824,      13824,      512,     2048, 0x08d7ff49
+0,      14336,      14336,      512,     2048, 0x7c64ee03
+0,      14848,      14848,      512,     2048, 0xd303f4ff
+0,      15360,      15360,      512,     2048, 0xda5902be
+0,      15872,      15872,      512,     2048, 0x4096fe6b
+0,      16384,      16384,      512,     2048, 0x178e016a
+0,      16896,      16896,      512,     2048, 0x046700ac
+0,      17408,      17408,      512,     2048, 0x5f20f4ad
+0,      17920,      17920,      512,     2048, 0x40e2f093
+0,      18432,      18432,      512,     2048, 0x5c37fccd
+0,      18944,      18944,      512,     2048, 0x9f85f963
+0,      19456,      19456,      512,     2048, 0x69461038
+0,      19968,      19968,      512,     2048, 0x1ff1ef4f
+0,      20480,      20480,      512,     2048, 0x409304fc
+0,      20992,      20992,      512,     2048, 0x36d3fe47
+0,      21504,      21504,      512,     2048, 0xea01f367
+0,      22016,      22016,      512,     2048, 0x11f5fd01
+0,      22528,      22528,      512,     2048, 0x6deeeea5
+0,      23040,      23040,      512,     2048, 0x7eec0d62
+0,      23552,      23552,      512,     2048, 0xb47bfb93
+0,      24064,      24064,      512,     2048, 0x87b8f7a3
+0,      24576,      24576,      512,     2048, 0xcba0fefb
+0,      25088,      25088,      512,     2048, 0xa02efb77
+0,      25600,      25600,      512,     2048, 0x1030ecf1
+0,      26112,      26112,      512,     2048, 0xef7f08f4
+0,      26624,      26624,      512,     2048, 0x8d4efa1d
+0,      27136,      27136,      512,     2048, 0xe88b070c
+0,      27648,      27648,      512,     2048, 0x229cf957
+0,      28160,      28160,      512,     2048, 0xf7f2f3ed
+0,      28672,      28672,      512,     2048, 0x8f5f0840
+0,      29184,      29184,      512,     2048, 0x4fcbe815
+0,      29696,      29696,      512,     2048, 0x57dd006a
+0,      30208,      30208,      512,     2048, 0xd51af913
+0,      30720,      30720,      512,     2048, 0x63c50a68
+0,      31232,      31232,      512,     2048, 0x100e036c
+0,      31744,      31744,      512,     2048, 0x0af0f5ad
+0,      32256,      32256,      512,     2048, 0x99d5f9ef
+0,      32768,      32768,      512,     2048, 0xd2dbf701
+0,      33280,      33280,      512,     2048, 0xdb22f7bf
+0,      33792,      33792,      512,     2048, 0x82a103be
+0,      34304,      34304,      512,     2048, 0xa3c707d8
+0,      34816,      34816,      512,     2048, 0x8aaafb8f
+0,      35328,      35328,      512,     2048, 0x4bdafefb
+0,      35840,      35840,      512,     2048, 0x75a3e833
+0,      36352,      36352,      512,     2048, 0xc130091c
+0,      36864,      36864,      512,     2048, 0x99d8f36d
+0,      37376,      37376,      512,     2048, 0xaf6efa15
+0,      37888,      37888,      512,     2048, 0xff5f0506
+0,      38400,      38400,      512,     2048, 0xcba4fb5b
+0,      38912,      38912,      512,     2048, 0x729309c6
+0,      39424,      39424,      512,     2048, 0x63cdeb09
+0,      39936,      39936,      512,     2048, 0x386cfccb
+0,      40448,      40448,      512,     2048, 0x602100c8
+0,      40960,      40960,      512,     2048, 0x3573f565
+0,      41472,      41472,      512,     2048, 0x47b9fce7
+0,      41984,      41984,      512,     2048, 0xd1e90b7a
+0,      42496,      42496,      512,     2048, 0xf4c3ef77
+0,      43008,      43008,      512,     2048, 0x59ebfe3f
+0,      43520,      43520,      512,     2048, 0x02d4f161
+0,      44032,      44032,      512,     2048, 0x2c09f943
+0,      44544,      44544,      512,     2048, 0x2158dd3f
+0,      45056,      45056,      512,     2048, 0x9c150cf4
+0,      45568,      45568,      512,     2048, 0x2f66dfcb
+0,      46080,      46080,      512,     2048, 0xd62c05c4
+0,      46592,      46592,      512,     2048, 0x755d0472
+0,      47104,      47104,      512,     2048, 0x4aece261
+0,      47616,      47616,      512,     2048, 0xa4b704ac
+0,      48128,      48128,      512,     2048, 0x18410020
+0,      48640,      48640,      512,     2048, 0xa94ff9f5
+0,      49152,      49152,      512,     2048, 0xddf705ba
+0,      49664,      49664,      512,     2048, 0xca7af583
+0,      50176,      50176,      512,     2048, 0xf57af029
+0,      50688,      50688,      512,     2048, 0x2cb60d16
+0,      51200,      51200,      512,     2048, 0x97f2f90b
+0,      51712,      51712,      512,     2048, 0xd49cfd33
+0,      52224,      52224,      512,     2048, 0x4f56f1dd
+0,      52736,      52736,      512,     2048, 0x343bfbc1
+0,      53248,      53248,      512,     2048, 0x2058fd6b
+0,      53760,      53760,      512,     2048, 0x243bf921
+0,      54272,      54272,      512,     2048, 0x658b1272
+0,      54784,      54784,      512,     2048, 0xd68fe547
+0,      55296,      55296,      512,     2048, 0xab63068c
+0,      55808,      55808,      512,     2048, 0x8f860afa
+0,      56320,      56320,      512,     2048, 0x290de797
+0,      56832,      56832,      512,     2048, 0x9b990640
+0,      57344,      57344,      512,     2048, 0x859920bc
+0,      57856,      57856,      512,     2048, 0x343f12ae
+0,      58368,      58368,      512,     2048, 0xddf318e4
+0,      58880,      58880,      512,     2048, 0x55a6f535
+0,      59392,      59392,      512,     2048, 0x48ce08f6
+0,      59904,      59904,      512,     2048, 0x4e7ff8c3
+0,      60416,      60416,      512,     2048, 0xde8803c0
+0,      60928,      60928,      512,     2048, 0x1b79fe81
+0,      61440,      61440,      512,     2048, 0x853be72f
+0,      61952,      61952,      512,     2048, 0xf4cff117
+0,      62464,      62464,      512,     2048, 0xb61df45f
+0,      62976,      62976,      512,     2048, 0x6e38fdf7
+0,      63488,      63488,      512,     2048, 0x41c6042c
+0,      64000,      64000,      512,     2048, 0xfbb2fd87
+0,      64512,      64512,      512,     2048, 0x6da4eb69
+0,      65024,      65024,      512,     2048, 0x8ff8054e
+0,      65536,      65536,      512,     2048, 0x8c44ef81
+0,      66048,      66048,      512,     2048, 0x47faf17b
+0,      66560,      66560,      512,     2048, 0x0bd5012a
+0,      67072,      67072,      512,     2048, 0xe2d6fd37
+0,      67584,      67584,      512,     2048, 0x128ffedd
+0,      68096,      68096,      512,     2048, 0x02f7facd
+0,      68608,      68608,      512,     2048, 0x3f43f77d
+0,      69120,      69120,      512,     2048, 0x7d65fe19
+0,      69632,      69632,      512,     2048, 0x66c705ba
+0,      70144,      70144,      512,     2048, 0x182efbb7
+0,      70656,      70656,      512,     2048, 0xf718e481
+0,      71168,      71168,      512,     2048, 0xbfa10444
+0,      71680,      71680,      512,     2048, 0xc3aa0360
+0,      72192,      72192,      512,     2048, 0x90e0fa59
+0,      72704,      72704,      512,     2048, 0x903706c2
+0,      73216,      73216,      512,     2048, 0xff70001e
+0,      73728,      73728,      512,     2048, 0x9240ef79
+0,      74240,      74240,      512,     2048, 0xd72c05c8
+0,      74752,      74752,      512,     2048, 0x9655f5f5
+0,      75264,      75264,      512,     2048, 0x27b60a0e
+0,      75776,      75776,      512,     2048, 0x5917f885
+0,      76288,      76288,      512,     2048, 0xe39c107e
+0,      76800,      76800,      512,     2048, 0x2a4812c0
+0,      77312,      77312,      512,     2048, 0x39180ac8
+0,      77824,      77824,      512,     2048, 0x8b9efe57
+0,      78336,      78336,      512,     2048, 0xf9eefd25
+0,      78848,      78848,      512,     2048, 0xd3660cae
+0,      79360,      79360,      512,     2048, 0xa7ebf7d5
+0,      79872,      79872,      512,     2048, 0x4baaf59f
+0,      80384,      80384,      512,     2048, 0x659ff209
+0,      80896,      80896,      512,     2048, 0x1cf80e0e
+0,      81408,      81408,      512,     2048, 0x2df9ea69
+0,      81920,      81920,      512,     2048, 0xff8ffa2d
+0,      82432,      82432,      512,     2048, 0xdd2732d8
+0,      82944,      82944,      512,     2048, 0xcd6e31ec
+0,      83456,      83456,      512,     2048, 0x66d0fb9f
+0,      83968,      83968,      512,     2048, 0xbc11f229
+0,      84480,      84480,      512,     2048, 0x3ae00cec
+0,      84992,      84992,      512,     2048, 0xb032fb19
+0,      85504,      85504,      512,     2048, 0xb2c90414
+0,      86016,      86016,      512,     2048, 0xb7a1eeaf
+0,      86528,      86528,      512,     2048, 0x7a5d0e70
+0,      87040,      87040,      512,     2048, 0x16f11516
+0,      87552,      87552,      512,     2048, 0xfa95fc7f
+0,      88064,      88064,      512,     2048, 0x4fe705a6
+0,      88576,      88576,      512,     2048, 0x93d1c311
+0,      89088,      89088,      512,     2048, 0x8230f4f1
+0,      89600,      89600,      512,     2048, 0x6985e58f
+0,      90112,      90112,      512,     2048, 0xc4d8f07f
+0,      90624,      90624,      512,     2048, 0xb6b4c477
+0,      91136,      91136,      512,     2048, 0xc95bce8b
+0,      91648,      91648,      512,     2048, 0x57efd56f
+0,      92160,      92160,      512,     2048, 0xd453c295
+0,      92672,      92672,      512,     2048, 0x83c0da97
+0,      93184,      93184,      512,     2048, 0xf6bfe307
+0,      93696,      93696,      512,     2048, 0x0ce8ce27
+0,      94208,      94208,      512,     2048, 0xc925e53f
+0,      94720,      94720,      512,     2048, 0x7fe9d121
+0,      95232,      95232,      512,     2048, 0x00d3dcf9
+0,      95744,      95744,      512,     2048, 0x9743d637
+0,      96256,      96256,      512,     2048, 0x5163f37f
+0,      96768,      96768,      512,     2048, 0x9736dc27
+0,      97280,      97280,      512,     2048, 0xb0b1e85b
+0,      97792,      97792,      512,     2048, 0x589f0c2c
+0,      98304,      98304,      512,     2048, 0xb3b7aab9
+0,      98816,      98816,      512,     2048, 0x4df0d46d
+0,      99328,      99328,      512,     2048, 0xb917d4db
+0,      99840,      99840,      512,     2048, 0x6efdfe65
+0,     100352,     100352,      512,     2048, 0x426bd85d
+0,     100864,     100864,      512,     2048, 0x824313f6
+0,     101376,     101376,      512,     2048, 0xe755cf47
+0,     101888,     101888,      512,     2048, 0xe4e8f157
+0,     102400,     102400,      512,     2048, 0x05a8d1cb
+0,     102912,     102912,      512,     2048, 0xa405094a
+0,     103424,     103424,      512,     2048, 0x5060e40d
+0,     103936,     103936,      512,     2048, 0x3a17e253
+0,     104448,     104448,      512,     2048, 0xb8cdd80f
+0,     104960,     104960,      512,     2048, 0x7073c517
+0,     105472,     105472,      512,     2048, 0x634b00c4
+0,     105984,     105984,      512,     2048, 0xd8ebd025
+0,     106496,     106496,      512,     2048, 0x3a65cff7
+0,     107008,     107008,      512,     2048, 0x1e61b661
+0,     107520,     107520,      512,     2048, 0x3a1dcae9
+0,     108032,     108032,      512,     2048, 0x8d280542
+0,     108544,     108544,      512,     2048, 0xe918f499
+0,     109056,     109056,      512,     2048, 0x701bd98b
+0,     109568,     109568,      512,     2048, 0xd2a8e72f
+0,     110080,     110080,      512,     2048, 0x16ededdb
+0,     110592,     110592,      512,     2048, 0xfeb1fdbb
+0,     111104,     111104,      512,     2048, 0x36b1f4f1
+0,     111616,     111616,      512,     2048, 0x5bc5f27b
+0,     112128,     112128,      512,     2048, 0xb72605ee
+0,     112640,     112640,      512,     2048, 0x718d112e
+0,     113152,     113152,      512,     2048, 0x1ff7f25b
+0,     113664,     113664,      512,     2048, 0x1dd115cc
+0,     114176,     114176,      512,     2048, 0x1ff7fb15
+0,     114688,     114688,      512,     2048, 0xeb61f241
+0,     115200,     115200,      512,     2048, 0xc3bdeb83
+0,     115712,     115712,      512,     2048, 0xea80011a
+0,     116224,     116224,      512,     2048, 0x8d3cee71
+0,     116736,     116736,      512,     2048, 0x8cfbf589
+0,     117248,     117248,      512,     2048, 0xba23f8e3
+0,     117760,     117760,      512,     2048, 0x87a1e86d
+0,     118272,     118272,      512,     2048, 0x38e6f1a5
+0,     118784,     118784,      512,     2048, 0xe05a12fe
+0,     119296,     119296,      512,     2048, 0x9a14e835
+0,     119808,     119808,      512,     2048, 0x11a11780
+0,     120320,     120320,      512,     2048, 0x0c2308e6
+0,     120832,     120832,      512,     2048, 0xc8adfa4b
+0,     121344,     121344,      512,     2048, 0xfe4c118a
+0,     121856,     121856,      512,     2048, 0xa6240ac0
+0,     122368,     122368,      512,     2048, 0x3ff3ee2b
+0,     122880,     122880,      512,     2048, 0xc6aaf769
+0,     123392,     123392,      512,     2048, 0x4adafcdd
+0,     123904,     123904,      512,     2048, 0xabd6e845
+0,     124416,     124416,      512,     2048, 0x25e6076a
+0,     124928,     124928,      512,     2048, 0xb6e6d4b9
+0,     125440,     125440,      512,     2048, 0x7251f225
+0,     125952,     125952,      512,     2048, 0xc3b5f751
+0,     126464,     126464,      512,     2048, 0x4f27cecd
+0,     126976,     126976,      512,     2048, 0x237c020c
+0,     127488,     127488,      512,     2048, 0xb0580556
+0,     128000,     128000,      512,     2048, 0x717008a4
+0,     128512,     128512,      512,     2048, 0xf683e3fb
+0,     129024,     129024,      512,     2048, 0x1ddefd33
+0,     129536,     129536,      512,     2048, 0x4c6c1496
+0,     130048,     130048,      512,     2048, 0x67f907fe
+0,     130560,     130560,      512,     2048, 0x5bb10938
+0,     131072,     131072,      512,     2048, 0x24a20eac
+0,     131584,     131584,      512,     2048, 0xf251effb
+0,     132096,     132096,      512,     2048, 0xafd7eb04
+0,     132608,     132608,      512,     2048, 0xa1950245
+0,     133120,     133120,      512,     2048, 0x8cdefb0d
+0,     133632,     133632,      512,     2048, 0x5694fa32
+0,     134144,     134144,      512,     2048, 0x0942eeb6
+0,     134656,     134656,      512,     2048, 0x715a01c1
+0,     135168,     135168,      512,     2048, 0x4531f63e
+0,     135680,     135680,      512,     2048, 0x214ffbbc
+0,     136192,     136192,      512,     2048, 0x0f50fe21
+0,     136704,     136704,      512,     2048, 0xe456046b
+0,     137216,     137216,      512,     2048, 0xd6eaff4d
+0,     137728,     137728,      512,     2048, 0xd8140634
+0,     138240,     138240,      512,     2048, 0x608e0bff
+0,     138752,     138752,      512,     2048, 0x76610cee
+0,     139264,     139264,      512,     2048, 0x6b48f0ff
+0,     139776,     139776,      512,     2048, 0x03c7f9ce
+0,     140288,     140288,      512,     2048, 0xf718fad1
+0,     140800,     140800,      512,     2048, 0x296bef29
+0,     141312,     141312,      512,     2048, 0x2311f2bf
+0,     141824,     141824,      512,     2048, 0x069ffe60
+0,     142336,     142336,      512,     2048, 0x6126055d
+0,     142848,     142848,      512,     2048, 0x9330eda6
+0,     143360,     143360,      512,     2048, 0xdfbeedc1
+0,     143872,     143872,      512,     2048, 0x8536f1b8
+0,     144384,     144384,      512,     2048, 0xfe30fd72
+0,     144896,     144896,      512,     2048, 0x13320264
+0,     145408,     145408,      512,     2048, 0x83ad09db
+0,     145920,     145920,      512,     2048, 0xc08b0b31
+0,     146432,     146432,      512,     2048, 0xda8afea0
+0,     146944,     146944,      512,     2048, 0x0cb3f040
+0,     147456,     147456,      512,     2048, 0x80c0fc17
+0,     147968,     147968,      512,     2048, 0x9d80fdfb
+0,     148480,     148480,      512,     2048, 0x9f1af1fd
+0,     148992,     148992,      512,     2048, 0x92fef102
+0,     149504,     149504,      512,     2048, 0x5b62f7be
+0,     150016,     150016,      512,     2048, 0x25800a5b
+0,     150528,     150528,      512,     2048, 0xc660fba3
+0,     151040,     151040,      512,     2048, 0x0e21fbda
+0,     151552,     151552,      512,     2048, 0x2e7f027d
+0,     152064,     152064,      512,     2048, 0xcf65feb4
+0,     152576,     152576,      512,     2048, 0x4e0ffa6d
+0,     153088,     153088,      512,     2048, 0x732bff36
+0,     153600,     153600,      512,     2048, 0x3df20e7e
+0,     154112,     154112,      512,     2048, 0x2a5006e5
+0,     154624,     154624,      512,     2048, 0xfd3bfa2a
+0,     155136,     155136,      512,     2048, 0x8e73f755
+0,     155648,     155648,      512,     2048, 0x6f93ece1
+0,     156160,     156160,      512,     2048, 0x78a4f735
+0,     156672,     156672,      512,     2048, 0x3a7cfc1c
+0,     157184,     157184,      512,     2048, 0xbfc0f795
+0,     157696,     157696,      512,     2048, 0x7a8cfed2
+0,     158208,     158208,      512,     2048, 0x3d0fdee5
+0,     158720,     158720,      512,     2048, 0x902afc78
+0,     159232,     159232,      512,     2048, 0x51dcf0e2
+0,     159744,     159744,      512,     2048, 0x1f59fc00
+0,     160256,     160256,      512,     2048, 0x2dd0f390
+0,     160768,     160768,      512,     2048, 0x2ff30f7c
+0,     161280,     161280,      512,     2048, 0x36f508b8
+0,     161792,     161792,      512,     2048, 0x51e8ef2d
+0,     162304,     162304,      512,     2048, 0xf9660ed7
+0,     162816,     162816,      512,     2048, 0x50f3fd4d
+0,     163328,     163328,      512,     2048, 0x366ef6b9
+0,     163840,     163840,      512,     2048, 0xf023f17a
+0,     164352,     164352,      512,     2048, 0xf6c6f1f0
+0,     164864,     164864,      512,     2048, 0x6d1dfebf
+0,     165376,     165376,      512,     2048, 0xead60e1d
+0,     165888,     165888,      512,     2048, 0xbe5201a6
+0,     166400,     166400,      512,     2048, 0xb1940269
+0,     166912,     166912,      512,     2048, 0xb6cdf350
+0,     167424,     167424,      512,     2048, 0x7c44f80e
+0,     167936,     167936,      512,     2048, 0x1fff03ef
+0,     168448,     168448,      512,     2048, 0x514807c6
+0,     168960,     168960,      512,     2048, 0xe04eede7
+0,     169472,     169472,      512,     2048, 0x347e0272
+0,     169984,     169984,      512,     2048, 0x8c00fb96
+0,     170496,     170496,      512,     2048, 0x6660f607
+0,     171008,     171008,      512,     2048, 0xe9a7017d
+0,     171520,     171520,      512,     2048, 0xca58e8ae
+0,     172032,     172032,      512,     2048, 0x795af92a
+0,     172544,     172544,      512,     2048, 0x7d6aee1b
+0,     173056,     173056,      512,     2048, 0x4ab9f58f
+0,     173568,     173568,      512,     2048, 0x3b91f617
+0,     174080,     174080,      512,     2048, 0x09e1f7d7
+0,     174592,     174592,      512,     2048, 0xc9280753
+0,     175104,     175104,      512,     2048, 0x8620f662
+0,     175616,     175616,      512,     2048, 0x6bb103fa
+0,     176128,     176128,      512,     2048, 0xcfee0371
+0,     176640,     176640,      512,     2048, 0xe1e20294
+0,     177152,     177152,      512,     2048, 0xdb98fea4
+0,     177664,     177664,      512,     2048, 0x8d1fddeb
+0,     178176,     178176,      512,     2048, 0x4e7501bf
+0,     178688,     178688,      512,     2048, 0x68d0fb95
+0,     179200,     179200,      512,     2048, 0xf685001e
+0,     179712,     179712,      512,     2048, 0x75dafa10
+0,     180224,     180224,      512,     2048, 0x534fe772
+0,     180736,     180736,      512,     2048, 0x28b4fe18
+0,     181248,     181248,      512,     2048, 0x2ba00678
+0,     181760,     181760,      512,     2048, 0xc884e0b7
+0,     182272,     182272,      512,     2048, 0x6ae40787
+0,     182784,     182784,      512,     2048, 0xc53cf35d
+0,     183296,     183296,      512,     2048, 0x738d06b4
+0,     183808,     183808,      512,     2048, 0xb551f582
+0,     184320,     184320,      512,     2048, 0x8a5a8764
+0,     184832,     184832,      512,     2048, 0x711f175e
+0,     185344,     185344,      512,     2048, 0xe5e1ed43
+0,     185856,     185856,      512,     2048, 0x34adfaeb
+0,     186368,     186368,      512,     2048, 0x79fb0142
+0,     186880,     186880,      512,     2048, 0xf4f6ffeb
+0,     187392,     187392,      512,     2048, 0xd3540a6b
+0,     187904,     187904,      512,     2048, 0x49caf3c6
+0,     188416,     188416,      512,     2048, 0xc1db05b7
+0,     188928,     188928,      512,     2048, 0x26f0114a
+0,     189440,     189440,      512,     2048, 0x576eead9
+0,     189952,     189952,      512,     2048, 0xb87f00e9
+0,     190464,     190464,      512,     2048, 0x470d030f
+0,     190976,     190976,      512,     2048, 0x60ec02b2
+0,     191488,     191488,      512,     2048, 0xb84a0b44
+0,     192000,     192000,      512,     2048, 0x39b6ec45
+0,     192512,     192512,      512,     2048, 0x1e07e580
+0,     193024,     193024,      512,     2048, 0xfa3cf5d6
+0,     193536,     193536,      512,     2048, 0x0801f9b8
+0,     194048,     194048,      512,     2048, 0x55981a80
+0,     194560,     194560,      512,     2048, 0x9510f6ad
+0,     195072,     195072,      512,     2048, 0x7d03fcc7
+0,     195584,     195584,      512,     2048, 0xf17bf84e
+0,     196096,     196096,      512,     2048, 0x6d1ffe4c
+0,     196608,     196608,      512,     2048, 0x91e210f9
+0,     197120,     197120,      512,     2048, 0xb881fa44
+0,     197632,     197632,      512,     2048, 0xb7cdf1f3
+0,     198144,     198144,      512,     2048, 0x1e9b17b5
+0,     198656,     198656,      512,     2048, 0x74dff0e3
+0,     199168,     199168,      512,     2048, 0x1f55050e
+0,     199680,     199680,      512,     2048, 0x7498f1b8
+0,     200192,     200192,      512,     2048, 0x2d7c02e9
+0,     200704,     200704,      512,     2048, 0x8c84a5c4
+0,     201216,     201216,      512,     2048, 0x6feae10d
+0,     201728,     201728,      512,     2048, 0xfda90b28
+0,     202240,     202240,      512,     2048, 0xb230fd72
+0,     202752,     202752,      512,     2048, 0x6298f728
+0,     203264,     203264,      512,     2048, 0xef60f871
+0,     203776,     203776,      512,     2048, 0x14e7ee01
+0,     204288,     204288,      512,     2048, 0x98d704a5
+0,     204800,     204800,      512,     2048, 0x1ccaf2b4
+0,     205312,     205312,      512,     2048, 0xb9ede721
+0,     205824,     205824,      512,     2048, 0x8c570d92
+0,     206336,     206336,      512,     2048, 0x2d7ef782
+0,     206848,     206848,      512,     2048, 0xa84cf55e
+0,     207360,     207360,      512,     2048, 0x8033f5b9
+0,     207872,     207872,      512,     2048, 0x27f3ed27
+0,     208384,     208384,      512,     2048, 0xa6730c25
+0,     208896,     208896,      512,     2048, 0x489bf2fd
+0,     209408,     209408,      512,     2048, 0xe1e20294
+0,     209920,     209920,      512,     2048, 0xdb98fea4
+0,     210432,     210432,      512,     2048, 0x8d1fddeb
+0,     210944,     210944,      512,     2048, 0x4e7501bf
+0,     211456,     211456,      512,     2048, 0x68d0fb95
+0,     211968,     211968,      512,     2048, 0xf685001e
+0,     212480,     212480,      512,     2048, 0x75dafa10
+0,     212992,     212992,      512,     2048, 0x534fe772
+0,     213504,     213504,      512,     2048, 0x28b4fe18
+0,     214016,     214016,      512,     2048, 0x2ba00678
+0,     214528,     214528,      512,     2048, 0xc884e0b7
+0,     215040,     215040,      512,     2048, 0x6ae40787
+0,     215552,     215552,      512,     2048, 0xc53cf35d
+0,     216064,     216064,      512,     2048, 0x738d06b4
+0,     216576,     216576,      512,     2048, 0xb551f582
+0,     217088,     217088,      512,     2048, 0x8a5a8764
+0,     217600,     217600,      512,     2048, 0x711f175e
+0,     218112,     218112,      512,     2048, 0xe5e1ed43
+0,     218624,     218624,      512,     2048, 0x34adfaeb
+0,     219136,     219136,      512,     2048, 0x79fb0142
+0,     219648,     219648,      512,     2048, 0xf4f6ffeb
+0,     220160,     220160,      512,     2048, 0xd3540a6b
+0,     220672,     220672,      512,     2048, 0x49caf3c6
+0,     221184,     221184,      512,     2048, 0xc1db05b7
+0,     221696,     221696,      512,     2048, 0x26f0114a
+0,     222208,     222208,      512,     2048, 0x576eead9
+0,     222720,     222720,      512,     2048, 0xb87f00e9
+0,     223232,     223232,      512,     2048, 0x470d030f
+0,     223744,     223744,      512,     2048, 0x60ec02b2
+0,     224256,     224256,      512,     2048, 0xb84a0b44
+0,     224768,     224768,      512,     2048, 0x39b6ec45
+0,     225280,     225280,      512,     2048, 0x1e07e580
+0,     225792,     225792,      512,     2048, 0xfa3cf5d6
+0,     226304,     226304,      512,     2048, 0x0801f9b8
+0,     226816,     226816,      512,     2048, 0x55981a80
+0,     227328,     227328,      512,     2048, 0x9510f6ad
+0,     227840,     227840,      512,     2048, 0x7d03fcc7
+0,     228352,     228352,      512,     2048, 0xf17bf84e
+0,     228864,     228864,      512,     2048, 0x6d1ffe4c
+0,     229376,     229376,      512,     2048, 0x91e210f9
+0,     229888,     229888,      512,     2048, 0xb881fa44
+0,     230400,     230400,      512,     2048, 0xb7cdf1f3
+0,     230912,     230912,      512,     2048, 0x1e9b17b5
+0,     231424,     231424,      512,     2048, 0x74dff0e3
+0,     231936,     231936,      512,     2048, 0x1f55050e
+0,     232448,     232448,      512,     2048, 0x7498f1b8
+0,     232960,     232960,      512,     2048, 0x2d7c02e9
+0,     233472,     233472,      512,     2048, 0x8c84a5c4
+0,     233984,     233984,      512,     2048, 0x6feae10d
+0,     234496,     234496,      512,     2048, 0xfda90b28
+0,     235008,     235008,      512,     2048, 0xb230fd72
+0,     235520,     235520,      512,     2048, 0x6298f728
+0,     236032,     236032,      512,     2048, 0xef60f871
+0,     236544,     236544,      512,     2048, 0x14e7ee01
+0,     237056,     237056,      512,     2048, 0x98d704a5
+0,     237568,     237568,      512,     2048, 0x1ccaf2b4
+0,     238080,     238080,      512,     2048, 0xb9ede721
+0,     238592,     238592,      512,     2048, 0x8c570d92
+0,     239104,     239104,      512,     2048, 0x2d7ef782
+0,     239616,     239616,      512,     2048, 0xa84cf55e
+0,     240128,     240128,      512,     2048, 0x8033f5b9
+0,     240640,     240640,      512,     2048, 0x27f3ed27
+0,     241152,     241152,      512,     2048, 0xa6730c25
+0,     241664,     241664,      512,     2048, 0x489bf2fd
+0,     242176,     242176,      512,     2048, 0xe1e20294
+0,     242688,     242688,      512,     2048, 0xdb98fea4
+0,     243200,     243200,      512,     2048, 0x8d1fddeb
+0,     243712,     243712,      512,     2048, 0x4e7501bf
+0,     244224,     244224,      512,     2048, 0x68d0fb95
+0,     244736,     244736,      512,     2048, 0xf685001e
+0,     245248,     245248,      512,     2048, 0x75dafa10
+0,     245760,     245760,      512,     2048, 0x534fe772
+0,     246272,     246272,      512,     2048, 0x28b4fe18
+0,     246784,     246784,      512,     2048, 0x2ba00678
+0,     247296,     247296,      512,     2048, 0xc884e0b7
+0,     247808,     247808,      512,     2048, 0x6ae40787
+0,     248320,     248320,      512,     2048, 0xc53cf35d
+0,     248832,     248832,      512,     2048, 0x738d06b4
+0,     249344,     249344,      512,     2048, 0xb551f582
+0,     249856,     249856,      512,     2048, 0x8a5a8764
+0,     250368,     250368,      512,     2048, 0x711f175e
+0,     250880,     250880,      512,     2048, 0xe5e1ed43
+0,     251392,     251392,      512,     2048, 0x34adfaeb
+0,     251904,     251904,      512,     2048, 0x79fb0142
+0,     252416,     252416,      512,     2048, 0xf4f6ffeb
+0,     252928,     252928,      512,     2048, 0xd3540a6b
+0,     253440,     253440,      512,     2048, 0x49caf3c6
+0,     253952,     253952,      512,     2048, 0xc1db05b7
+0,     254464,     254464,      512,     2048, 0x26f0114a
+0,     254976,     254976,      512,     2048, 0x576eead9
+0,     255488,     255488,      512,     2048, 0xb87f00e9
+0,     256000,     256000,      512,     2048, 0x470d030f
+0,     256512,     256512,      512,     2048, 0x60ec02b2
+0,     257024,     257024,      512,     2048, 0xb84a0b44
+0,     257536,     257536,      512,     2048, 0x39b6ec45
+0,     258048,     258048,      512,     2048, 0x1e07e580
+0,     258560,     258560,      512,     2048, 0xfa3cf5d6
+0,     259072,     259072,      512,     2048, 0x0801f9b8
+0,     259584,     259584,      512,     2048, 0x55981a80
+0,     260096,     260096,      512,     2048, 0x9510f6ad
+0,     260608,     260608,      512,     2048, 0x7d03fcc7
+0,     261120,     261120,      512,     2048, 0xf17bf84e
+0,     261632,     261632,      512,     2048, 0x6d1ffe4c
+0,     262144,     262144,      512,     2048, 0x91e210f9
+0,     262656,     262656,      512,     2048, 0xb881fa44
+0,     263168,     263168,      512,     2048, 0xb7cdf1f3
+0,     263680,     263680,      512,     2048, 0x1e9b17b5
+0,     264192,     264192,      408,     1632, 0xf412313e
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-asetnsamples b/mythtv/external/FFmpeg/tests/ref/fate/filter-asetnsamples-pad
similarity index 99%
rename from mythtv/external/FFmpeg/tests/ref/fate/filter-asetnsamples
rename to mythtv/external/FFmpeg/tests/ref/fate/filter-asetnsamples-pad
index 5e246ec8f8d..23cf11b8af4 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-asetnsamples
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-asetnsamples-pad
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,      512,     2048, 0xd2dbf701
 0,        512,        512,      512,     2048, 0xdb22f7bf
 0,       1024,       1024,      512,     2048, 0x82a103be
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-asetrate b/mythtv/external/FFmpeg/tests/ref/fate/filter-asetrate
index e4487aec117..6ffa9403616 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-asetrate
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-asetrate
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 20000
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x29e3eecf
 0,       1024,       1024,     1024,     4096, 0x18390b96
 0,       2048,       2048,     1024,     4096, 0xc477fa99
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-duration b/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-duration
index 6f16c8f5e0c..fafda1717f1 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-duration
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-duration
@@ -3,4 +3,5 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,       4410,       4410,      441,     1764, 0x61e374f7
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-mixed b/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-mixed
index 8f8b4ed62c3..4cd1d8004f3 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-mixed
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-mixed
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,       1025,       1025,     1023,     4092, 0x78560a4c
 0,       2048,       2048,     1024,     4096, 0xc477fa99
 0,       3072,       3072,     1024,     4096, 0x3bc0f14f
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-samples b/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-samples
index 4dcb333b7e2..2d8c9a52356 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-samples
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-samples
@@ -3,4 +3,5 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,         26,         26,       54,      216, 0x6b376c6c
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-time b/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-time
index 4ca3d7353d7..a0c626c4ba3 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-time
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-atrim-time
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,       4410,       4410,      710,     2840, 0x658982a3
 0,       5120,       5120,     1024,     4096, 0xfd6a0070
 0,       6144,       6144,     1024,     4096, 0x0b01f4cf
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-chorus b/mythtv/external/FFmpeg/tests/ref/fate/filter-chorus
index 3fc4d734983..211e60ecb13 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-chorus
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-chorus
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,     2048,     4096, 0x1fc6f1f1
 0,       2048,       2048,     2048,     4096, 0xe5f7f442
 0,       4096,       4096,     2048,     4096, 0x4f14ecb9
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-compand b/mythtv/external/FFmpeg/tests/ref/fate/filter-compand
index 14fe0b2fdd2..ac9095f4e36 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-compand
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-compand
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0xfc10e61b
 0,       1024,       1024,     1024,     4096, 0x8801ef13
 0,       2048,       2048,     1024,     4096, 0xba55fc17
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-concat b/mythtv/external/FFmpeg/tests/ref/fate/filter-concat
index f8f7353c976..022697ec5bc 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-concat
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-concat
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 44100
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   230400, 0x88c4d19a
 1,          0,          0,     1024,     2048, 0xb3f10192
 1,       1024,       1024,     1024,     2048, 0xb340fe4e
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-dcshift b/mythtv/external/FFmpeg/tests/ref/fate/filter-dcshift
index d04aa926cbe..dad3df3ff05 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-dcshift
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-dcshift
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x96868842
 0,       1024,       1024,     1024,     4096, 0xeff98700
 0,       2048,       2048,     1024,     4096, 0x6ea28e1e
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-earwax b/mythtv/external/FFmpeg/tests/ref/fate/filter-earwax
index 8d4eaa8be8b..855f579cacf 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-earwax
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-earwax
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x900af751
 0,       1024,       1024,     1024,     4096, 0xad570065
 0,       2048,       2048,     1024,     4096, 0x93d5f494
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-extrastereo b/mythtv/external/FFmpeg/tests/ref/fate/filter-extrastereo
index e43de2d784a..179c1677927 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-extrastereo
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-extrastereo
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x29e3eecf
 0,       1024,       1024,     1024,     4096, 0x18390b96
 0,       2048,       2048,     1024,     4096, 0xc477fa99
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-formats b/mythtv/external/FFmpeg/tests/ref/fate/filter-formats
index 4c303d86efd..ea85eed23d3 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-formats
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-formats
@@ -77,6 +77,9 @@ quad(side)
 -1 = ff_parse_channel_layout(FFFFFFFFFFFFFFFF, -1, -1c);
 0 = ff_parse_channel_layout(0000000000000000, 60, 60c);
 -1 = ff_parse_channel_layout(FFFFFFFFFFFFFFFF, -1, 65c);
+0 = ff_parse_channel_layout(0000000000000000,  2, 2C);
+0 = ff_parse_channel_layout(0000000000000000, 60, 60C);
+-1 = ff_parse_channel_layout(FFFFFFFFFFFFFFFF, -1, 65C);
 0 = ff_parse_channel_layout(000000000000003F,  6, 5.1);
 0 = ff_parse_channel_layout(0000000000000003,  2, stereo);
 0 = ff_parse_channel_layout(0000000000000001,  1, 1+1+1+1);
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-fps b/mythtv/external/FFmpeg/tests/ref/fate/filter-fps
index 55712cfb1cf..242fb04e85d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-fps
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-fps
@@ -85,3 +85,9 @@
 0,         79,         79,        1,    30576, 0xa2fcd06f
 0,         80,         80,        1,    30576, 0xa2fcd06f
 0,         81,         81,        1,    30576, 0xd4150aad
+0,         82,         82,        1,    30576, 0xd4150aad
+0,         83,         83,        1,    30576, 0xd4150aad
+0,         84,         84,        1,    30576, 0xd4150aad
+0,         85,         85,        1,    30576, 0xd4150aad
+0,         86,         86,        1,    30576, 0xd4150aad
+0,         87,         87,        1,    30576, 0xd4150aad
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-fps-r b/mythtv/external/FFmpeg/tests/ref/fate/filter-fps-r
index 826b1ed6c64..c1bc7d15479 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-fps-r
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-fps-r
@@ -72,3 +72,7 @@
 0,         79,         79,        1,    30576, 0xa2fcd06f
 0,         80,         80,        1,    30576, 0xa2fcd06f
 0,         82,         82,        1,    30576, 0xd4150aad
+0,         83,         83,        1,    30576, 0xd4150aad
+0,         84,         84,        1,    30576, 0xd4150aad
+0,         85,         85,        1,    30576, 0xd4150aad
+0,         86,         86,        1,    30576, 0xd4150aad
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-framerate-down b/mythtv/external/FFmpeg/tests/ref/fate/filter-framerate-down
new file mode 100644
index 00000000000..4eab7aab85f
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-framerate-down
@@ -0,0 +1,6 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 320x240
+#sar 0: 1/1
+0,          0,          0,        1,   115200, 0x3744b3ed
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-framerate-up b/mythtv/external/FFmpeg/tests/ref/fate/filter-framerate-up
new file mode 100644
index 00000000000..b2af9cb879d
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-framerate-up
@@ -0,0 +1,15 @@
+#tb 0: 1/10
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 320x240
+#sar 0: 1/1
+0,          0,          0,        1,   115200, 0x3744b3ed
+0,          1,          1,        1,   115200, 0xc44bdc65
+0,          2,          2,        1,   115200, 0xa17f0d74
+0,          3,          3,        1,   115200, 0xb0c83274
+0,          4,          4,        1,   115200, 0x232d6368
+0,          5,          5,        1,   115200, 0x6e318ba0
+0,          6,          6,        1,   115200, 0x247e846e
+0,          7,          7,        1,   115200, 0x89e27599
+0,          8,          8,        1,   115200, 0x31c5704e
+0,          9,          9,        1,   115200, 0x97e45fec
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-hls b/mythtv/external/FFmpeg/tests/ref/fate/filter-hls
index 47bc51444c5..ee3c7b2c62a 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-hls
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-hls
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,     1152,     2304, 0x907cb7fa
 0,       1152,       1152,     1152,     2304, 0xb8dc7525
 0,       2304,       2304,     1152,     2304, 0x3e7d6905
@@ -768,5 +769,4 @@
 0,     877824,     877824,     1152,     2304, 0xb2ae7741
 0,     878976,     878976,     1152,     2304, 0x4de169e4
 0,     880128,     880128,     1152,     2304, 0x3cb18530
-0,     881280,     881280,     1152,     2304, 0x48b95d6c
-0,     882432,     882432,     1152,     2304, 0xcff707ef
+0,     881280,     881280,     1152,     2304, 0x5a0c5e7b
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-hls-append b/mythtv/external/FFmpeg/tests/ref/fate/filter-hls-append
index 4a88b867f64..be65c82f51f 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-hls-append
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-hls-append
@@ -3,1154 +3,1536 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 4
-0,          0,          0,     1152,     2304, 0x593ea430
-0,       1152,       1152,     1152,     2304, 0xde328304
-0,       2304,       2304,     1152,     2304, 0x12f673c9
-0,       3456,       3456,     1152,     2304, 0x4c7672a1
-0,       4608,       4608,     1152,     2304, 0xd38577f4
-0,       5760,       5760,     1152,     2304, 0xc9d677cc
-0,       6912,       6912,     1152,     2304, 0xc97e882a
-0,       8064,       8064,     1152,     2304, 0xaacf67ec
-0,       9216,       9216,     1152,     2304, 0x3a9b7ea5
-0,      10368,      10368,     1152,     2304, 0x30258348
-0,      11520,      11520,     1152,     2304, 0x08da8783
-0,      12672,      12672,     1152,     2304, 0x4830619e
-0,      13824,      13824,     1152,     2304, 0xcf476f69
-0,      14976,      14976,     1152,     2304, 0x377e7ce5
-0,      16128,      16128,     1152,     2304, 0x00a27fad
-0,      17280,      17280,     1152,     2304, 0xe4a46de3
-0,      18432,      18432,     1152,     2304, 0x938c8751
-0,      19584,      19584,     1152,     2304, 0x239982b5
-0,      20736,      20736,     1152,     2304, 0x9a0d7655
-0,      21888,      21888,     1152,     2304, 0x4adf7fbf
-0,      23040,      23040,     1152,     2304, 0xdb8b7b16
-0,      24192,      24192,     1152,     2304, 0x25908560
-0,      25344,      25344,     1152,     2304, 0xb5dd7be7
-0,      26496,      26496,     1152,     2304, 0x4368796d
-0,      27648,      27648,     1152,     2304, 0xba3a7fd0
-0,      28800,      28800,     1152,     2304, 0x5aae7456
-0,      29952,      29952,     1152,     2304, 0x40b58040
-0,      31104,      31104,     1152,     2304, 0x0d9d7783
-0,      32256,      32256,     1152,     2304, 0x44ae7b60
-0,      33408,      33408,     1152,     2304, 0xdd6366bd
-0,      34560,      34560,     1152,     2304, 0x04dc6e61
-0,      35712,      35712,     1152,     2304, 0x61b2783b
-0,      36864,      36864,     1152,     2304, 0x7bd47e7f
-0,      38016,      38016,     1152,     2304, 0x3e687793
-0,      39168,      39168,     1152,     2304, 0x92757bbb
-0,      40320,      40320,     1152,     2304, 0x05378308
-0,      41472,      41472,     1152,     2304, 0x1b1d7db8
-0,      42624,      42624,     1152,     2304, 0x983285f8
-0,      43776,      43776,     1152,     2304, 0xab2b7726
-0,      44928,      44928,     1152,     2304, 0xe9947717
-0,      46080,      46080,     1152,     2304, 0x21cb966e
-0,      47232,      47232,     1152,     2304, 0xb59b81b2
-0,      48384,      48384,     1152,     2304, 0xef036fd5
-0,      49536,      49536,     1152,     2304, 0xec468526
-0,      50688,      50688,     1152,     2304, 0x292873f2
-0,      51840,      51840,     1152,     2304, 0x455d77a2
-0,      52992,      52992,     1152,     2304, 0x61e0854d
-0,      54144,      54144,     1152,     2304, 0x416c8372
-0,      55296,      55296,     1152,     2304, 0x82dc7022
-0,      56448,      56448,     1152,     2304, 0x88d383d1
-0,      57600,      57600,     1152,     2304, 0x94fc8981
-0,      58752,      58752,     1152,     2304, 0x1e4e98c5
-0,      59904,      59904,     1152,     2304, 0xc4737b03
-0,      61056,      61056,     1152,     2304, 0xf8f789f5
-0,      62208,      62208,     1152,     2304, 0x0d5188be
-0,      63360,      63360,     1152,     2304, 0xc4e47843
-0,      64512,      64512,     1152,     2304, 0xbbd38b37
-0,      65664,      65664,     1152,     2304, 0xeaa5753d
-0,      66816,      66816,     1152,     2304, 0x1396730a
-0,      67968,      67968,     1152,     2304, 0x1fd47e14
-0,      69120,      69120,     1152,     2304, 0x1f2b7541
-0,      70272,      70272,     1152,     2304, 0xdbaf728d
-0,      71424,      71424,     1152,     2304, 0x02966ff6
-0,      72576,      72576,     1152,     2304, 0x391f862c
-0,      73728,      73728,     1152,     2304, 0x98d96794
-0,      74880,      74880,     1152,     2304, 0xa8367e21
-0,      76032,      76032,     1152,     2304, 0x5c33790a
-0,      77184,      77184,     1152,     2304, 0x26728b13
-0,      78336,      78336,     1152,     2304, 0x2c3980e9
-0,      79488,      79488,     1152,     2304, 0x0d27871a
-0,      80640,      80640,     1152,     2304, 0xa4da7ac8
-0,      81792,      81792,     1152,     2304, 0x7ffd6a94
-0,      82944,      82944,     1152,     2304, 0x71af8b5f
-0,      84096,      84096,     1152,     2304, 0xaa368cab
-0,      85248,      85248,     1152,     2304, 0xba4a784d
-0,      86400,      86400,     1152,     2304, 0x8c7269ac
-0,      87552,      87552,     1152,     2304, 0xd5a07581
-0,      88704,      88704,     1152,     2304, 0xe05978b2
-0,      89856,      89856,     1152,     2304, 0xe2417e60
-0,      91008,      91008,     1152,     2304, 0x18b679a5
-0,      92160,      92160,     1152,     2304, 0x81627543
-0,      93312,      93312,     1152,     2304, 0xf9006f2b
-0,      94464,      94464,     1152,     2304, 0xd49485c6
-0,      95616,      95616,     1152,     2304, 0x9d397f15
-0,      96768,      96768,     1152,     2304, 0x08d17de8
-0,      97920,      97920,     1152,     2304, 0xbb6a92a7
-0,      99072,      99072,     1152,     2304, 0xd4656d5c
-0,     100224,     100224,     1152,     2304, 0xafa08243
-0,     101376,     101376,     1152,     2304, 0x874b8276
-0,     102528,     102528,     1152,     2304, 0x8fee76b1
-0,     103680,     103680,     1152,     2304, 0x38d7713e
-0,     104832,     104832,     1152,     2304, 0x0dc0790e
-0,     105984,     105984,     1152,     2304, 0xebb67ce1
-0,     107136,     107136,     1152,     2304, 0x00e48593
-0,     108288,     108288,     1152,     2304, 0xd7f382d6
-0,     109440,     109440,     1152,     2304, 0xc5b38328
-0,     110592,     110592,     1152,     2304, 0xca0797c0
-0,     111744,     111744,     1152,     2304, 0xf162749c
-0,     112896,     112896,     1152,     2304, 0x3137829f
-0,     114048,     114048,     1152,     2304, 0xf1b07f58
-0,     115200,     115200,     1152,     2304, 0xe044721a
-0,     116352,     116352,     1152,     2304, 0xe1387323
-0,     117504,     117504,     1152,     2304, 0xabdc6e2b
-0,     118656,     118656,     1152,     2304, 0x2ee67795
-0,     119808,     119808,     1152,     2304, 0x87187611
-0,     120960,     120960,     1152,     2304, 0xd7d284c1
-0,     122112,     122112,     1152,     2304, 0x34e96a8d
-0,     123264,     123264,     1152,     2304, 0x08857dfb
-0,     124416,     124416,     1152,     2304, 0xdf738b2a
-0,     125568,     125568,     1152,     2304, 0xee887465
-0,     126720,     126720,     1152,     2304, 0x4e5174f4
-0,     127872,     127872,     1152,     2304, 0x7688784c
-0,     129024,     129024,     1152,     2304, 0x5f1b80c0
-0,     130176,     130176,     1152,     2304, 0xf7778e6e
-0,     131328,     131328,     1152,     2304, 0x1b6383ac
-0,     132480,     132480,     1152,     2304, 0x98fe8302
-0,     133632,     133632,     1152,     2304, 0xbf5477b4
-0,     134784,     134784,     1152,     2304, 0xd3756dad
-0,     135936,     135936,     1152,     2304, 0x2e1b7777
-0,     137088,     137088,     1152,     2304, 0xa49c824b
-0,     138240,     138240,     1152,     2304, 0xe3f07d98
-0,     139392,     139392,     1152,     2304, 0x325e73cf
-0,     140544,     140544,     1152,     2304, 0xe06b8572
-0,     141696,     141696,     1152,     2304, 0xe7e07821
-0,     142848,     142848,     1152,     2304, 0xb2f87600
-0,     144000,     144000,     1152,     2304, 0x91a28bab
-0,     145152,     145152,     1152,     2304, 0x0d2674b5
-0,     146304,     146304,     1152,     2304, 0xcf5662ff
-0,     147456,     147456,     1152,     2304, 0xa7be8477
-0,     148608,     148608,     1152,     2304, 0x3f9d7bd3
-0,     149760,     149760,     1152,     2304, 0x1674773d
-0,     150912,     150912,     1152,     2304, 0x96e08fc5
-0,     152064,     152064,     1152,     2304, 0x5a5878ad
-0,     153216,     153216,     1152,     2304, 0x4f426f66
-0,     154368,     154368,     1152,     2304, 0xcc367ef4
-0,     155520,     155520,     1152,     2304, 0x3d607c4a
-0,     156672,     156672,     1152,     2304, 0x3fc28286
-0,     157824,     157824,     1152,     2304, 0xc4788063
-0,     158976,     158976,     1152,     2304, 0x21fe7dd8
-0,     160128,     160128,     1152,     2304, 0x75cb7680
-0,     161280,     161280,     1152,     2304, 0x31b274ad
-0,     162432,     162432,     1152,     2304, 0x8cfa88c3
-0,     163584,     163584,     1152,     2304, 0xd816650d
-0,     164736,     164736,     1152,     2304, 0xb7f17a6a
-0,     165888,     165888,     1152,     2304, 0xb4187db0
-0,     167040,     167040,     1152,     2304, 0xccf77c9d
-0,     168192,     168192,     1152,     2304, 0xa1b3619f
-0,     169344,     169344,     1152,     2304, 0x1c298fec
-0,     170496,     170496,     1152,     2304, 0x2bb17416
-0,     171648,     171648,     1152,     2304, 0x44e37e00
-0,     172800,     172800,     1152,     2304, 0x449b723f
-0,     173952,     173952,     1152,     2304, 0x9bc47abe
-0,     175104,     175104,     1152,     2304, 0x6cbe7dcf
-0,     176256,     176256,     1152,     2304, 0xadcc7b4d
-0,     177408,     177408,     1152,     2304, 0xbe046f69
-0,     178560,     178560,     1152,     2304, 0x6f927d23
-0,     179712,     179712,     1152,     2304, 0x1fc87d99
-0,     180864,     180864,     1152,     2304, 0xf77b81ef
-0,     182016,     182016,     1152,     2304, 0x2d446ca8
-0,     183168,     183168,     1152,     2304, 0x957888ec
-0,     184320,     184320,     1152,     2304, 0x057067f4
-0,     185472,     185472,     1152,     2304, 0xe808943d
-0,     186624,     186624,     1152,     2304, 0x88417570
-0,     187776,     187776,     1152,     2304, 0x838c7224
-0,     188928,     188928,     1152,     2304, 0x8c8e82a4
-0,     190080,     190080,     1152,     2304, 0x687a723f
-0,     191232,     191232,     1152,     2304, 0xc3468c7a
-0,     192384,     192384,     1152,     2304, 0xa4f47213
-0,     193536,     193536,     1152,     2304, 0xd8ec8ca7
-0,     194688,     194688,     1152,     2304, 0x5c5b7006
-0,     195840,     195840,     1152,     2304, 0x63fc7359
-0,     196992,     196992,     1152,     2304, 0x0ce37f4e
-0,     198144,     198144,     1152,     2304, 0xedf287c7
-0,     199296,     199296,     1152,     2304, 0x5e6e7cd1
-0,     200448,     200448,     1152,     2304, 0xdd3571be
-0,     201600,     201600,     1152,     2304, 0x0834630c
-0,     202752,     202752,     1152,     2304, 0x99ed89d7
-0,     203904,     203904,     1152,     2304, 0x076971cf
-0,     205056,     205056,     1152,     2304, 0x38e0782b
-0,     206208,     206208,     1152,     2304, 0x5c177342
-0,     207360,     207360,     1152,     2304, 0xe7c57032
-0,     208512,     208512,     1152,     2304, 0xe37e7d50
-0,     209664,     209664,     1152,     2304, 0xf23988de
-0,     210816,     210816,     1152,     2304, 0x77f06c1f
-0,     211968,     211968,     1152,     2304, 0x1d3c87ee
-0,     213120,     213120,     1152,     2304, 0x98686ac5
-0,     214272,     214272,     1152,     2304, 0x2a54816e
-0,     215424,     215424,     1152,     2304, 0xc4dc7b1c
-0,     216576,     216576,     1152,     2304, 0xbb027c49
-0,     217728,     217728,     1152,     2304, 0x46bb8325
-0,     218880,     218880,     1152,     2304, 0x53ab7122
-0,     220032,     220032,     1152,     2304, 0xfa01759b
-0,     221184,     221184,     1152,     2304, 0xce177271
-0,     222336,     222336,     1152,     2304, 0x939f7a96
-0,     223488,     223488,     1152,     2304, 0x0c508d51
-0,     224640,     224640,     1152,     2304, 0x09188492
-0,     225792,     225792,     1152,     2304, 0x59a56b10
-0,     226944,     226944,     1152,     2304, 0x3fe67a92
-0,     228096,     228096,     1152,     2304, 0x867d7793
-0,     229248,     229248,     1152,     2304, 0xa48f6d1f
-0,     230400,     230400,     1152,     2304, 0x02018949
-0,     231552,     231552,     1152,     2304, 0xa02d6e65
-0,     232704,     232704,     1152,     2304, 0x0ff280e4
-0,     233856,     233856,     1152,     2304, 0x32ad71cf
-0,     235008,     235008,     1152,     2304, 0x1ccd7777
-0,     236160,     236160,     1152,     2304, 0x0ee78f97
-0,     237312,     237312,     1152,     2304, 0x4ed7707d
-0,     238464,     238464,     1152,     2304, 0xb4d06b75
-0,     239616,     239616,     1152,     2304, 0xd3648038
-0,     240768,     240768,     1152,     2304, 0x69ff76f1
-0,     241920,     241920,     1152,     2304, 0xdf497685
-0,     243072,     243072,     1152,     2304, 0x64615c92
-0,     244224,     244224,     1152,     2304, 0x9c8b7e6e
-0,     245376,     245376,     1152,     2304, 0x1b447b3e
-0,     246528,     246528,     1152,     2304, 0x7a4c64c0
-0,     247680,     247680,     1152,     2304, 0xf6fe67ea
-0,     248832,     248832,     1152,     2304, 0x08f78261
-0,     249984,     249984,     1152,     2304, 0xeb568301
-0,     251136,     251136,     1152,     2304, 0x62ec8a0a
-0,     252288,     252288,     1152,     2304, 0x52d07277
-0,     253440,     253440,     1152,     2304, 0x1eed84b4
-0,     254592,     254592,     1152,     2304, 0x52ad791f
-0,     255744,     255744,     1152,     2304, 0x6989846e
-0,     256896,     256896,     1152,     2304, 0x8b0684ec
-0,     258048,     258048,     1152,     2304, 0x830e7dbe
-0,     259200,     259200,     1152,     2304, 0xb6677b4b
-0,     260352,     260352,     1152,     2304, 0xfeaf75e1
-0,     261504,     261504,     1152,     2304, 0x64bb7421
-0,     262656,     262656,     1152,     2304, 0x8ddd7d2e
-0,     263808,     263808,     1152,     2304, 0xfa5d7a27
-0,     264960,     264960,     1152,     2304, 0xd6867c97
-0,     266112,     266112,     1152,     2304, 0xb0318460
-0,     267264,     267264,     1152,     2304, 0x024c717b
-0,     268416,     268416,     1152,     2304, 0x09907a04
-0,     269568,     269568,     1152,     2304, 0xebb07b90
-0,     270720,     270720,     1152,     2304, 0x84d47e83
-0,     271872,     271872,     1152,     2304, 0x71e18652
-0,     273024,     273024,     1152,     2304, 0xc8647f89
-0,     274176,     274176,     1152,     2304, 0x990382ba
-0,     275328,     275328,     1152,     2304, 0x3d857028
-0,     276480,     276480,     1152,     2304, 0x52568dc4
-0,     277632,     277632,     1152,     2304, 0x37e276be
-0,     278784,     278784,     1152,     2304, 0xad8f854a
-0,     279936,     279936,     1152,     2304, 0x727a6a22
-0,     281088,     281088,     1152,     2304, 0x2ac97320
-0,     282240,     282240,     1152,     2304, 0x200c7351
-0,     283392,     283392,     1152,     2304, 0x0ba677ae
-0,     284544,     284544,     1152,     2304, 0x6653722d
-0,     285696,     285696,     1152,     2304, 0x9a5f75c1
-0,     286848,     286848,     1152,     2304, 0x16f37be1
-0,     288000,     288000,     1152,     2304, 0x215a82e4
-0,     289152,     289152,     1152,     2304, 0xa7c58158
-0,     290304,     290304,     1152,     2304, 0xd478864a
-0,     291456,     291456,     1152,     2304, 0xa5f273b3
-0,     292608,     292608,     1152,     2304, 0x5d7c75cb
-0,     293760,     293760,     1152,     2304, 0x55c06524
-0,     294912,     294912,     1152,     2304, 0xbbf97aae
-0,     296064,     296064,     1152,     2304, 0xba0b7e65
-0,     297216,     297216,     1152,     2304, 0x71087c06
-0,     298368,     298368,     1152,     2304, 0x277d85de
-0,     299520,     299520,     1152,     2304, 0x1e126eb6
-0,     300672,     300672,     1152,     2304, 0x19766d6e
-0,     301824,     301824,     1152,     2304, 0x04237828
-0,     302976,     302976,     1152,     2304, 0x2268843c
-0,     304128,     304128,     1152,     2304, 0xdac68003
-0,     305280,     305280,     1152,     2304, 0x6d8174a9
-0,     306432,     306432,     1152,     2304, 0x5b487901
-0,     307584,     307584,     1152,     2304, 0x31da752c
-0,     308736,     308736,     1152,     2304, 0xf8b37add
-0,     309888,     309888,     1152,     2304, 0xefd97011
-0,     311040,     311040,     1152,     2304, 0xc71b72d0
-0,     312192,     312192,     1152,     2304, 0xc44a84a6
-0,     313344,     313344,     1152,     2304, 0x36a76737
-0,     314496,     314496,     1152,     2304, 0xe9296bde
-0,     315648,     315648,     1152,     2304, 0x5f0c7964
-0,     316800,     316800,     1152,     2304, 0x115a7b1b
-0,     317952,     317952,     1152,     2304, 0xa0bb78fc
-0,     319104,     319104,     1152,     2304, 0x480289cb
-0,     320256,     320256,     1152,     2304, 0x89437407
-0,     321408,     321408,     1152,     2304, 0xcac27303
-0,     322560,     322560,     1152,     2304, 0x36e37b15
-0,     323712,     323712,     1152,     2304, 0x6bd77fe7
-0,     324864,     324864,     1152,     2304, 0xb51d7d90
-0,     326016,     326016,     1152,     2304, 0x11908b31
-0,     327168,     327168,     1152,     2304, 0x71717e81
-0,     328320,     328320,     1152,     2304, 0x84047f9c
-0,     329472,     329472,     1152,     2304, 0x539380cf
-0,     330624,     330624,     1152,     2304, 0xddbb8002
-0,     331776,     331776,     1152,     2304, 0x52ad7e5c
-0,     332928,     332928,     1152,     2304, 0x2c467c8a
-0,     334080,     334080,     1152,     2304, 0x2d298829
-0,     335232,     335232,     1152,     2304, 0x114870e9
-0,     336384,     336384,     1152,     2304, 0x678a7c34
-0,     337536,     337536,     1152,     2304, 0xb8c273e8
-0,     338688,     338688,     1152,     2304, 0x65a27c6d
-0,     339840,     339840,     1152,     2304, 0xc4ea916b
-0,     340992,     340992,     1152,     2304, 0x86e96ceb
-0,     342144,     342144,     1152,     2304, 0xc4078a91
-0,     343296,     343296,     1152,     2304, 0x58ae7f6d
-0,     344448,     344448,     1152,     2304, 0x6d3270be
-0,     345600,     345600,     1152,     2304, 0x8d2d6df1
-0,     346752,     346752,     1152,     2304, 0xfbfc81f4
-0,     347904,     347904,     1152,     2304, 0xa7936fea
-0,     349056,     349056,     1152,     2304, 0xd5dd7e5a
-0,     350208,     350208,     1152,     2304, 0xfb4580e8
-0,     351360,     351360,     1152,     2304, 0x29926e9f
-0,     352512,     352512,     1152,     2304, 0x5c317e40
-0,     353664,     353664,     1152,     2304, 0x2bb379ad
-0,     354816,     354816,     1152,     2304, 0xc8697c8b
-0,     355968,     355968,     1152,     2304, 0xbcaf81ba
-0,     357120,     357120,     1152,     2304, 0xa0c99d00
-0,     358272,     358272,     1152,     2304, 0x79096f7c
-0,     359424,     359424,     1152,     2304, 0x44a77d97
-0,     360576,     360576,     1152,     2304, 0x157d982f
-0,     361728,     361728,     1152,     2304, 0x0c8183d1
-0,     362880,     362880,     1152,     2304, 0x80086a82
-0,     364032,     364032,     1152,     2304, 0x0c537cc3
-0,     365184,     365184,     1152,     2304, 0x19027c3c
-0,     366336,     366336,     1152,     2304, 0xb67f78dd
-0,     367488,     367488,     1152,     2304, 0x72797b57
-0,     368640,     368640,     1152,     2304, 0xad938420
-0,     369792,     369792,     1152,     2304, 0x68627b30
-0,     370944,     370944,     1152,     2304, 0x569371fb
-0,     372096,     372096,     1152,     2304, 0x4e9b7550
-0,     373248,     373248,     1152,     2304, 0xe1729143
-0,     374400,     374400,     1152,     2304, 0xbc6f7e76
-0,     375552,     375552,     1152,     2304, 0x5bfd954b
-0,     376704,     376704,     1152,     2304, 0x1c8c8420
-0,     377856,     377856,     1152,     2304, 0x00e78af7
-0,     379008,     379008,     1152,     2304, 0x2a9882dd
-0,     380160,     380160,     1152,     2304, 0xfc2b7986
-0,     381312,     381312,     1152,     2304, 0x2aee8137
-0,     382464,     382464,     1152,     2304, 0x836e8f91
-0,     383616,     383616,     1152,     2304, 0xe7f76feb
-0,     384768,     384768,     1152,     2304, 0xdf4e838a
-0,     385920,     385920,     1152,     2304, 0x7d4c71c9
-0,     387072,     387072,     1152,     2304, 0x85387f6c
-0,     388224,     388224,     1152,     2304, 0x87d27d7a
-0,     389376,     389376,     1152,     2304, 0x4fd57d9a
-0,     390528,     390528,     1152,     2304, 0xec1f7c43
-0,     391680,     391680,     1152,     2304, 0x974a86a7
-0,     392832,     392832,     1152,     2304, 0x5479747e
-0,     393984,     393984,     1152,     2304, 0xf15776bc
-0,     395136,     395136,     1152,     2304, 0xe06e7ebb
-0,     396288,     396288,     1152,     2304, 0x0d3f709b
-0,     397440,     397440,     1152,     2304, 0x3b167f0a
-0,     398592,     398592,     1152,     2304, 0x4dc57327
-0,     399744,     399744,     1152,     2304, 0x5fa381d8
-0,     400896,     400896,     1152,     2304, 0x404e798f
-0,     402048,     402048,     1152,     2304, 0x8ef87756
-0,     403200,     403200,     1152,     2304, 0xc6116d2f
-0,     404352,     404352,     1152,     2304, 0x3ba27e5b
-0,     405504,     405504,     1152,     2304, 0x9aa56fed
-0,     406656,     406656,     1152,     2304, 0x73b38c76
-0,     407808,     407808,     1152,     2304, 0xe4fe7d66
-0,     408960,     408960,     1152,     2304, 0xe42e6c68
-0,     410112,     410112,     1152,     2304, 0x5c3f8b9f
-0,     411264,     411264,     1152,     2304, 0x41177545
-0,     412416,     412416,     1152,     2304, 0x049985fa
-0,     413568,     413568,     1152,     2304, 0xb8c380cd
-0,     414720,     414720,     1152,     2304, 0x30f08190
-0,     415872,     415872,     1152,     2304, 0x13897077
-0,     417024,     417024,     1152,     2304, 0x64887621
-0,     418176,     418176,     1152,     2304, 0xb5fa8304
-0,     419328,     419328,     1152,     2304, 0xe57784d9
-0,     420480,     420480,     1152,     2304, 0xdeae7f45
-0,     421632,     421632,     1152,     2304, 0xe0719636
-0,     422784,     422784,     1152,     2304, 0x8f6a7a7b
-0,     423936,     423936,     1152,     2304, 0x1d127592
-0,     425088,     425088,     1152,     2304, 0xc4f46a24
-0,     426240,     426240,     1152,     2304, 0xf5b57e3d
-0,     427392,     427392,     1152,     2304, 0x7e167f33
-0,     428544,     428544,     1152,     2304, 0x30f27901
-0,     429696,     429696,     1152,     2304, 0x02a57a27
-0,     430848,     430848,     1152,     2304, 0x36888409
-0,     432000,     432000,     1152,     2304, 0x83f5822c
-0,     433152,     433152,     1152,     2304, 0x7d878379
-0,     434304,     434304,     1152,     2304, 0x82288ef8
-0,     435456,     435456,     1152,     2304, 0xb0d476e1
-0,     436608,     436608,     1152,     2304, 0xb88a7742
-0,     437760,     437760,     1152,     2304, 0xba816ae3
-0,     438912,     438912,     1152,     2304, 0x3bb98530
-0,     440064,     440064,     1152,     2304, 0x4a215d6c
-0,     441216,     441216,     1152,     2304, 0x184cfde4
-0,     442368,     442368,     1152,     2304, 0x116eaf00
-0,     443520,     443520,     1152,     2304, 0xf81c7623
-0,     444672,     444672,     1152,     2304, 0xc52c6707
-0,     445824,     445824,     1152,     2304, 0xf67a877c
-0,     446976,     446976,     1152,     2304, 0xcc886d7c
-0,     448128,     448128,     1152,     2304, 0x25178edb
-0,     449280,     449280,     1152,     2304, 0x898f83d3
-0,     450432,     450432,     1152,     2304, 0xbe7b7093
-0,     451584,     451584,     1152,     2304, 0x863e7c27
-0,     452736,     452736,     1152,     2304, 0xc8b883d5
-0,     453888,     453888,     1152,     2304, 0x8dfd74f7
-0,     455040,     455040,     1152,     2304, 0xb5d28623
-0,     456192,     456192,     1152,     2304, 0x3efc62db
-0,     457344,     457344,     1152,     2304, 0x392d7ad6
-0,     458496,     458496,     1152,     2304, 0xb0ca7410
-0,     459648,     459648,     1152,     2304, 0x73f97ab5
-0,     460800,     460800,     1152,     2304, 0x387a8844
-0,     461952,     461952,     1152,     2304, 0x0a337b9d
-0,     463104,     463104,     1152,     2304, 0x8b5a81b1
-0,     464256,     464256,     1152,     2304, 0xbab77a4e
-0,     465408,     465408,     1152,     2304, 0xf3e58f2a
-0,     466560,     466560,     1152,     2304, 0x368676eb
-0,     467712,     467712,     1152,     2304, 0x12ec7a5d
-0,     468864,     468864,     1152,     2304, 0x5d807e3a
-0,     470016,     470016,     1152,     2304, 0x00467830
-0,     471168,     471168,     1152,     2304, 0x8f4e8191
-0,     472320,     472320,     1152,     2304, 0x76797800
-0,     473472,     473472,     1152,     2304, 0x84a77e6d
-0,     474624,     474624,     1152,     2304, 0x5f05798a
-0,     475776,     475776,     1152,     2304, 0x81447dd5
-0,     476928,     476928,     1152,     2304, 0x13df81d7
-0,     478080,     478080,     1152,     2304, 0x2df17050
-0,     479232,     479232,     1152,     2304, 0xe76474ce
-0,     480384,     480384,     1152,     2304, 0x96cb737c
-0,     481536,     481536,     1152,     2304, 0x5f0a5840
-0,     482688,     482688,     1152,     2304, 0x5fda7fad
-0,     483840,     483840,     1152,     2304, 0xe74573a1
-0,     484992,     484992,     1152,     2304, 0x7be67e2e
-0,     486144,     486144,     1152,     2304, 0x810d7842
-0,     487296,     487296,     1152,     2304, 0xc2757f6c
-0,     488448,     488448,     1152,     2304, 0xa7bb76a0
-0,     489600,     489600,     1152,     2304, 0x57ea7573
-0,     490752,     490752,     1152,     2304, 0x0f367900
-0,     491904,     491904,     1152,     2304, 0x1b3a798f
-0,     493056,     493056,     1152,     2304, 0xdeff7fc6
-0,     494208,     494208,     1152,     2304, 0xdc0a77cf
-0,     495360,     495360,     1152,     2304, 0x240e7ee1
-0,     496512,     496512,     1152,     2304, 0x3e9a9272
-0,     497664,     497664,     1152,     2304, 0x84086cf0
-0,     498816,     498816,     1152,     2304, 0x930992a9
-0,     499968,     499968,     1152,     2304, 0x558a87df
-0,     501120,     501120,     1152,     2304, 0x0f2b653c
-0,     502272,     502272,     1152,     2304, 0xba5276f2
-0,     503424,     503424,     1152,     2304, 0xd3be8572
-0,     504576,     504576,     1152,     2304, 0x08677859
-0,     505728,     505728,     1152,     2304, 0x57ed810f
-0,     506880,     506880,     1152,     2304, 0xda0c91d1
-0,     508032,     508032,     1152,     2304, 0xc3848c45
-0,     509184,     509184,     1152,     2304, 0xb2017a69
-0,     510336,     510336,     1152,     2304, 0x39657ecc
-0,     511488,     511488,     1152,     2304, 0x40908523
-0,     512640,     512640,     1152,     2304, 0x460d7d38
-0,     513792,     513792,     1152,     2304, 0xc9c379a8
-0,     514944,     514944,     1152,     2304, 0x0041894d
-0,     516096,     516096,     1152,     2304, 0x43bb7334
-0,     517248,     517248,     1152,     2304, 0x8ac18b06
-0,     518400,     518400,     1152,     2304, 0x01167b9d
-0,     519552,     519552,     1152,     2304, 0x40d075b5
-0,     520704,     520704,     1152,     2304, 0x6df87489
-0,     521856,     521856,     1152,     2304, 0x44318667
-0,     523008,     523008,     1152,     2304, 0x56c67e0e
-0,     524160,     524160,     1152,     2304, 0x60717b43
-0,     525312,     525312,     1152,     2304, 0x33aa7c12
-0,     526464,     526464,     1152,     2304, 0xce247abb
-0,     527616,     527616,     1152,     2304, 0x7b56813c
-0,     528768,     528768,     1152,     2304, 0x309573ee
-0,     529920,     529920,     1152,     2304, 0x700e869d
-0,     531072,     531072,     1152,     2304, 0x4cb8764f
-0,     532224,     532224,     1152,     2304, 0xdca06ddd
-0,     533376,     533376,     1152,     2304, 0x5ca274ff
-0,     534528,     534528,     1152,     2304, 0x427971cd
-0,     535680,     535680,     1152,     2304, 0xd6466659
-0,     536832,     536832,     1152,     2304, 0xacee6694
-0,     537984,     537984,     1152,     2304, 0xa5ec8629
-0,     539136,     539136,     1152,     2304, 0xac687866
-0,     540288,     540288,     1152,     2304, 0xaa6a8a4c
-0,     541440,     541440,     1152,     2304, 0x9b9e8582
-0,     542592,     542592,     1152,     2304, 0x0ab67dd0
-0,     543744,     543744,     1152,     2304, 0x838b7af6
-0,     544896,     544896,     1152,     2304, 0xc2758b4e
-0,     546048,     546048,     1152,     2304, 0x40007a6f
-0,     547200,     547200,     1152,     2304, 0x4d1d8928
-0,     548352,     548352,     1152,     2304, 0x10a373a4
-0,     549504,     549504,     1152,     2304, 0xd7ab7747
-0,     550656,     550656,     1152,     2304, 0x703972cb
-0,     551808,     551808,     1152,     2304, 0x8c387dda
-0,     552960,     552960,     1152,     2304, 0x88236a53
-0,     554112,     554112,     1152,     2304, 0xcbd38433
-0,     555264,     555264,     1152,     2304, 0x1af270f2
-0,     556416,     556416,     1152,     2304, 0x542f84d8
-0,     557568,     557568,     1152,     2304, 0xd0fb8aa8
-0,     558720,     558720,     1152,     2304, 0x34dc7c8f
-0,     559872,     559872,     1152,     2304, 0xc2348275
-0,     561024,     561024,     1152,     2304, 0x2fde77aa
-0,     562176,     562176,     1152,     2304, 0x1ccc7b31
-0,     563328,     563328,     1152,     2304, 0x50218492
-0,     564480,     564480,     1152,     2304, 0x2ff97ada
-0,     565632,     565632,     1152,     2304, 0xeb7a77e4
-0,     566784,     566784,     1152,     2304, 0xe6fa809f
-0,     567936,     567936,     1152,     2304, 0xc99676e7
-0,     569088,     569088,     1152,     2304, 0xb6448669
-0,     570240,     570240,     1152,     2304, 0x4525826c
-0,     571392,     571392,     1152,     2304, 0x1b3f8443
-0,     572544,     572544,     1152,     2304, 0xb4e882c6
-0,     573696,     573696,     1152,     2304, 0x5ddd719b
-0,     574848,     574848,     1152,     2304, 0x4425767d
-0,     576000,     576000,     1152,     2304, 0xc63a7f7f
-0,     577152,     577152,     1152,     2304, 0x1df1714c
-0,     578304,     578304,     1152,     2304, 0x4bd27e9f
-0,     579456,     579456,     1152,     2304, 0xd94a72a0
-0,     580608,     580608,     1152,     2304, 0x8e4a7f18
-0,     581760,     581760,     1152,     2304, 0x6e35777c
-0,     582912,     582912,     1152,     2304, 0xe6d584e5
-0,     584064,     584064,     1152,     2304, 0x33c572e0
-0,     585216,     585216,     1152,     2304, 0x2fb883bc
-0,     586368,     586368,     1152,     2304, 0xeae186de
-0,     587520,     587520,     1152,     2304, 0x6d4c71bd
-0,     588672,     588672,     1152,     2304, 0x70e176a4
-0,     589824,     589824,     1152,     2304, 0xe8cb7b71
-0,     590976,     590976,     1152,     2304, 0x8e058965
-0,     592128,     592128,     1152,     2304, 0xa05378a5
-0,     593280,     593280,     1152,     2304, 0xe7e27774
-0,     594432,     594432,     1152,     2304, 0xa8f4625b
-0,     595584,     595584,     1152,     2304, 0x9ef37d29
-0,     596736,     596736,     1152,     2304, 0xdc7783be
-0,     597888,     597888,     1152,     2304, 0x4b2a7f8e
-0,     599040,     599040,     1152,     2304, 0x5dfd886d
-0,     600192,     600192,     1152,     2304, 0xba5f7081
-0,     601344,     601344,     1152,     2304, 0x0c6a80ac
-0,     602496,     602496,     1152,     2304, 0x6dc080cb
-0,     603648,     603648,     1152,     2304, 0x7ec587fc
-0,     604800,     604800,     1152,     2304, 0x7f325dec
-0,     605952,     605952,     1152,     2304, 0xee5f8906
-0,     607104,     607104,     1152,     2304, 0xa4496b14
-0,     608256,     608256,     1152,     2304, 0x63ad8471
-0,     609408,     609408,     1152,     2304, 0x97ca7377
-0,     610560,     610560,     1152,     2304, 0xb06e72b1
-0,     611712,     611712,     1152,     2304, 0x312e83d3
-0,     612864,     612864,     1152,     2304, 0x6b1477ac
-0,     614016,     614016,     1152,     2304, 0x73177ec5
-0,     615168,     615168,     1152,     2304, 0x10de7c5c
-0,     616320,     616320,     1152,     2304, 0x35a37026
-0,     617472,     617472,     1152,     2304, 0xb023707f
-0,     618624,     618624,     1152,     2304, 0xbaa36f99
-0,     619776,     619776,     1152,     2304, 0x23007888
-0,     620928,     620928,     1152,     2304, 0x752f7b17
-0,     622080,     622080,     1152,     2304, 0xebfc81c5
-0,     623232,     623232,     1152,     2304, 0x2db790bb
-0,     624384,     624384,     1152,     2304, 0x991a68dc
-0,     625536,     625536,     1152,     2304, 0x772177d8
-0,     626688,     626688,     1152,     2304, 0x994e7173
-0,     627840,     627840,     1152,     2304, 0x28897acd
-0,     628992,     628992,     1152,     2304, 0x84d38aab
-0,     630144,     630144,     1152,     2304, 0xebf08b72
-0,     631296,     631296,     1152,     2304, 0x544e9053
-0,     632448,     632448,     1152,     2304, 0x59e07bac
-0,     633600,     633600,     1152,     2304, 0xdd2f7e71
-0,     634752,     634752,     1152,     2304, 0xaa3f8777
-0,     635904,     635904,     1152,     2304, 0xd58d7734
-0,     637056,     637056,     1152,     2304, 0xed5e6e77
-0,     638208,     638208,     1152,     2304, 0xe2af6dab
-0,     639360,     639360,     1152,     2304, 0xd855837e
-0,     640512,     640512,     1152,     2304, 0x3df76b87
-0,     641664,     641664,     1152,     2304, 0x234a78d2
-0,     642816,     642816,     1152,     2304, 0x303c84d5
-0,     643968,     643968,     1152,     2304, 0x6cb67caa
-0,     645120,     645120,     1152,     2304, 0x19e66c6f
-0,     646272,     646272,     1152,     2304, 0xfc737e51
-0,     647424,     647424,     1152,     2304, 0x0ae87cd6
-0,     648576,     648576,     1152,     2304, 0xa11172b4
-0,     649728,     649728,     1152,     2304, 0x8bfb71fd
-0,     650880,     650880,     1152,     2304, 0x74f279e9
-0,     652032,     652032,     1152,     2304, 0x97ca700e
-0,     653184,     653184,     1152,     2304, 0xa9a68333
-0,     654336,     654336,     1152,     2304, 0x68466d75
-0,     655488,     655488,     1152,     2304, 0x81c57ad6
-0,     656640,     656640,     1152,     2304, 0xdd55776e
-0,     657792,     657792,     1152,     2304, 0x03be7a8a
-0,     658944,     658944,     1152,     2304, 0x14c372f2
-0,     660096,     660096,     1152,     2304, 0x534f7b3a
-0,     661248,     661248,     1152,     2304, 0x96207e40
-0,     662400,     662400,     1152,     2304, 0xfdbf778d
-0,     663552,     663552,     1152,     2304, 0x7efb758a
-0,     664704,     664704,     1152,     2304, 0x946a80be
-0,     665856,     665856,     1152,     2304, 0x01ad7eb7
-0,     667008,     667008,     1152,     2304, 0x05d774b9
-0,     668160,     668160,     1152,     2304, 0x2a378428
-0,     669312,     669312,     1152,     2304, 0xe08470f6
-0,     670464,     670464,     1152,     2304, 0x70507bb4
-0,     671616,     671616,     1152,     2304, 0x327a8579
-0,     672768,     672768,     1152,     2304, 0x47437303
-0,     673920,     673920,     1152,     2304, 0x070e7821
-0,     675072,     675072,     1152,     2304, 0x67ff8207
-0,     676224,     676224,     1152,     2304, 0x068279af
-0,     677376,     677376,     1152,     2304, 0x8d8a7d89
-0,     678528,     678528,     1152,     2304, 0x0d3c7235
-0,     679680,     679680,     1152,     2304, 0x1d7e6f08
-0,     680832,     680832,     1152,     2304, 0xe8db7d89
-0,     681984,     681984,     1152,     2304, 0x9e47674d
-0,     683136,     683136,     1152,     2304, 0xfb84790b
-0,     684288,     684288,     1152,     2304, 0x8d5b812d
-0,     685440,     685440,     1152,     2304, 0x49c4744b
-0,     686592,     686592,     1152,     2304, 0xd8f47475
-0,     687744,     687744,     1152,     2304, 0x647b84a9
-0,     688896,     688896,     1152,     2304, 0x4957706c
-0,     690048,     690048,     1152,     2304, 0x61f189b1
-0,     691200,     691200,     1152,     2304, 0xcd13975c
-0,     692352,     692352,     1152,     2304, 0xf06d6b55
-0,     693504,     693504,     1152,     2304, 0xd0088107
-0,     694656,     694656,     1152,     2304, 0x20f28400
-0,     695808,     695808,     1152,     2304, 0x1de872df
-0,     696960,     696960,     1152,     2304, 0x62347b27
-0,     698112,     698112,     1152,     2304, 0x9ba36e22
-0,     699264,     699264,     1152,     2304, 0x08807ba7
-0,     700416,     700416,     1152,     2304, 0x436681fd
-0,     701568,     701568,     1152,     2304, 0xf87d74be
-0,     702720,     702720,     1152,     2304, 0xc0cb7e8d
-0,     703872,     703872,     1152,     2304, 0x5d9287b0
-0,     705024,     705024,     1152,     2304, 0xc7df7d4a
-0,     706176,     706176,     1152,     2304, 0x681b924a
-0,     707328,     707328,     1152,     2304, 0xddee7c4c
-0,     708480,     708480,     1152,     2304, 0x2e096d0a
-0,     709632,     709632,     1152,     2304, 0x1a8876dd
-0,     710784,     710784,     1152,     2304, 0x75f591bb
-0,     711936,     711936,     1152,     2304, 0x68d0774c
-0,     713088,     713088,     1152,     2304, 0xc0f485a0
-0,     714240,     714240,     1152,     2304, 0x92388082
-0,     715392,     715392,     1152,     2304, 0x894c76b1
-0,     716544,     716544,     1152,     2304, 0x76777281
-0,     717696,     717696,     1152,     2304, 0x7aaa8a19
-0,     718848,     718848,     1152,     2304, 0x199c7293
-0,     720000,     720000,     1152,     2304, 0xac0f8013
-0,     721152,     721152,     1152,     2304, 0xdeaa7e1c
-0,     722304,     722304,     1152,     2304, 0xf7bf7d45
-0,     723456,     723456,     1152,     2304, 0x9b467cc9
-0,     724608,     724608,     1152,     2304, 0xf4767446
-0,     725760,     725760,     1152,     2304, 0x7a886acb
-0,     726912,     726912,     1152,     2304, 0xaa607797
-0,     728064,     728064,     1152,     2304, 0xd8e58389
-0,     729216,     729216,     1152,     2304, 0x22b883b6
-0,     730368,     730368,     1152,     2304, 0xdab67e42
-0,     731520,     731520,     1152,     2304, 0x14827c73
-0,     732672,     732672,     1152,     2304, 0xebcf66d9
-0,     733824,     733824,     1152,     2304, 0x8b118930
-0,     734976,     734976,     1152,     2304, 0x233c8195
-0,     736128,     736128,     1152,     2304, 0x91f57455
-0,     737280,     737280,     1152,     2304, 0x7d757984
-0,     738432,     738432,     1152,     2304, 0x63af7deb
-0,     739584,     739584,     1152,     2304, 0x30e26d20
-0,     740736,     740736,     1152,     2304, 0x4148802b
-0,     741888,     741888,     1152,     2304, 0x8cad7fc4
-0,     743040,     743040,     1152,     2304, 0x4db786a7
-0,     744192,     744192,     1152,     2304, 0x5fe3743f
-0,     745344,     745344,     1152,     2304, 0x7e367794
-0,     746496,     746496,     1152,     2304, 0x10e27b4e
-0,     747648,     747648,     1152,     2304, 0x8c7a76a8
-0,     748800,     748800,     1152,     2304, 0xf6e28a86
-0,     749952,     749952,     1152,     2304, 0xe41c714a
-0,     751104,     751104,     1152,     2304, 0x28317c6d
-0,     752256,     752256,     1152,     2304, 0x3b746f4e
-0,     753408,     753408,     1152,     2304, 0xa1e782cc
-0,     754560,     754560,     1152,     2304, 0x5e536cc8
-0,     755712,     755712,     1152,     2304, 0x50fc73d7
-0,     756864,     756864,     1152,     2304, 0x04d37a90
-0,     758016,     758016,     1152,     2304, 0x6c927dde
-0,     759168,     759168,     1152,     2304, 0x16ca8584
-0,     760320,     760320,     1152,     2304, 0x923378e8
-0,     761472,     761472,     1152,     2304, 0x22ed6804
-0,     762624,     762624,     1152,     2304, 0x87f883d5
-0,     763776,     763776,     1152,     2304, 0x50869120
-0,     764928,     764928,     1152,     2304, 0x8b987ded
-0,     766080,     766080,     1152,     2304, 0x345d7de9
-0,     767232,     767232,     1152,     2304, 0x814d7ac3
-0,     768384,     768384,     1152,     2304, 0x03596aa9
-0,     769536,     769536,     1152,     2304, 0x5943757a
-0,     770688,     770688,     1152,     2304, 0x42f3801c
-0,     771840,     771840,     1152,     2304, 0x8442810a
-0,     772992,     772992,     1152,     2304, 0x4f1b8ba2
-0,     774144,     774144,     1152,     2304, 0x8f7d8860
-0,     775296,     775296,     1152,     2304, 0x2c5a839f
-0,     776448,     776448,     1152,     2304, 0x9e228894
-0,     777600,     777600,     1152,     2304, 0xd497691e
-0,     778752,     778752,     1152,     2304, 0x04016f7a
-0,     779904,     779904,     1152,     2304, 0xb61c72c0
-0,     781056,     781056,     1152,     2304, 0xee437bf3
-0,     782208,     782208,     1152,     2304, 0x3592774f
-0,     783360,     783360,     1152,     2304, 0xbbd7786d
-0,     784512,     784512,     1152,     2304, 0x629c826a
-0,     785664,     785664,     1152,     2304, 0x77b978d8
-0,     786816,     786816,     1152,     2304, 0x9106799a
-0,     787968,     787968,     1152,     2304, 0x2fe58630
-0,     789120,     789120,     1152,     2304, 0x90e38130
-0,     790272,     790272,     1152,     2304, 0x6ff28045
-0,     791424,     791424,     1152,     2304, 0x45d287d0
-0,     792576,     792576,     1152,     2304, 0x7c537697
-0,     793728,     793728,     1152,     2304, 0x54286e40
-0,     794880,     794880,     1152,     2304, 0xc27f71a7
-0,     796032,     796032,     1152,     2304, 0x17af704b
-0,     797184,     797184,     1152,     2304, 0x5d167dbd
-0,     798336,     798336,     1152,     2304, 0x7b268e31
-0,     799488,     799488,     1152,     2304, 0x3dc18433
-0,     800640,     800640,     1152,     2304, 0xa6827a83
-0,     801792,     801792,     1152,     2304, 0x541c7747
-0,     802944,     802944,     1152,     2304, 0x8dea8785
-0,     804096,     804096,     1152,     2304, 0x6b5181d0
-0,     805248,     805248,     1152,     2304, 0xd9047116
-0,     806400,     806400,     1152,     2304, 0xf22a7145
-0,     807552,     807552,     1152,     2304, 0x39327c3a
-0,     808704,     808704,     1152,     2304, 0xcd457691
-0,     809856,     809856,     1152,     2304, 0xe4b063d6
-0,     811008,     811008,     1152,     2304, 0x3ae88337
-0,     812160,     812160,     1152,     2304, 0x9f01810e
-0,     813312,     813312,     1152,     2304, 0xbfae7f51
-0,     814464,     814464,     1152,     2304, 0x5328815e
-0,     815616,     815616,     1152,     2304, 0xe9c47d11
-0,     816768,     816768,     1152,     2304, 0xe9db857d
-0,     817920,     817920,     1152,     2304, 0x615579eb
-0,     819072,     819072,     1152,     2304, 0x61ac7b82
-0,     820224,     820224,     1152,     2304, 0xd60481d2
-0,     821376,     821376,     1152,     2304, 0xaebb7a22
-0,     822528,     822528,     1152,     2304, 0x975f7075
-0,     823680,     823680,     1152,     2304, 0xa7e98197
-0,     824832,     824832,     1152,     2304, 0xaef57c3d
-0,     825984,     825984,     1152,     2304, 0xd5fe7a27
-0,     827136,     827136,     1152,     2304, 0xfdaf872c
-0,     828288,     828288,     1152,     2304, 0x7d62751b
-0,     829440,     829440,     1152,     2304, 0x3e628f11
-0,     830592,     830592,     1152,     2304, 0xd0ba72d8
-0,     831744,     831744,     1152,     2304, 0x0d367a38
-0,     832896,     832896,     1152,     2304, 0x6dde819d
-0,     834048,     834048,     1152,     2304, 0x6bc37faa
-0,     835200,     835200,     1152,     2304, 0x6fc667fb
-0,     836352,     836352,     1152,     2304, 0x77327cad
-0,     837504,     837504,     1152,     2304, 0xb4027bfa
-0,     838656,     838656,     1152,     2304, 0xd23681b7
-0,     839808,     839808,     1152,     2304, 0xe14a91ac
-0,     840960,     840960,     1152,     2304, 0xbaef75f4
-0,     842112,     842112,     1152,     2304, 0xc79f7507
-0,     843264,     843264,     1152,     2304, 0x84d277b3
-0,     844416,     844416,     1152,     2304, 0xb1b78637
-0,     845568,     845568,     1152,     2304, 0x326f755a
-0,     846720,     846720,     1152,     2304, 0x5b9c5cd2
-0,     847872,     847872,     1152,     2304, 0x6a1e8d47
-0,     849024,     849024,     1152,     2304, 0xe2d6886f
-0,     850176,     850176,     1152,     2304, 0xaab57fee
-0,     851328,     851328,     1152,     2304, 0xd0eb8337
-0,     852480,     852480,     1152,     2304, 0xca9d7a41
-0,     853632,     853632,     1152,     2304, 0xdb8c6c4b
-0,     854784,     854784,     1152,     2304, 0x920f88ec
-0,     855936,     855936,     1152,     2304, 0xbb5d778f
-0,     857088,     857088,     1152,     2304, 0x8c3390ea
-0,     858240,     858240,     1152,     2304, 0x8f6680ba
-0,     859392,     859392,     1152,     2304, 0x472a74f4
-0,     860544,     860544,     1152,     2304, 0x0dab6dcc
-0,     861696,     861696,     1152,     2304, 0xecf17d69
-0,     862848,     862848,     1152,     2304, 0x73f77584
-0,     864000,     864000,     1152,     2304, 0x08057f16
-0,     865152,     865152,     1152,     2304, 0x392382fb
-0,     866304,     866304,     1152,     2304, 0x8a928264
-0,     867456,     867456,     1152,     2304, 0x3c388075
-0,     868608,     868608,     1152,     2304, 0x51177e8f
-0,     869760,     869760,     1152,     2304, 0xc159743c
-0,     870912,     870912,     1152,     2304, 0xf08c8145
-0,     872064,     872064,     1152,     2304, 0x1ecc7111
-0,     873216,     873216,     1152,     2304, 0x5ec76a71
-0,     874368,     874368,     1152,     2304, 0x1e5287d3
-0,     875520,     875520,     1152,     2304, 0x2abd7076
-0,     876672,     876672,     1152,     2304, 0xaacd898c
-0,     877824,     877824,     1152,     2304, 0x7098718e
-0,     878976,     878976,     1152,     2304, 0xc2197937
-0,     880128,     880128,     1152,     2304, 0x16e38f8d
-0,     881280,     881280,     1152,     2304, 0x4c2a7d70
-0,     882432,     882432,     1152,     2304, 0x3c1478ed
-0,     883584,     883584,     1152,     2304, 0x9e817a51
-0,     884736,     884736,     1152,     2304, 0xdc8a8304
-0,     885888,     885888,     1152,     2304, 0x22d973c9
-0,     887040,     887040,     1152,     2304, 0x4b1a71a1
-0,     888192,     888192,     1152,     2304, 0x40a876f6
-0,     889344,     889344,     1152,     2304, 0x99f176cd
-0,     890496,     890496,     1152,     2304, 0xc882882a
-0,     891648,     891648,     1152,     2304, 0xaa3f67ec
-0,     892800,     892800,     1152,     2304, 0x3b897ea5
-0,     893952,     893952,     1152,     2304, 0x2e8f8348
-0,     895104,     895104,     1152,     2304, 0x089e8782
-0,     896256,     896256,     1152,     2304, 0x5979639d
-0,     897408,     897408,     1152,     2304, 0x73be7067
-0,     898560,     898560,     1152,     2304, 0x3daa7ce6
-0,     899712,     899712,     1152,     2304, 0x1afa7fad
-0,     900864,     900864,     1152,     2304, 0xe4da6de3
-0,     902016,     902016,     1152,     2304, 0x6d7b884f
-0,     903168,     903168,     1152,     2304, 0xdb9681b6
-0,     904320,     904320,     1152,     2304, 0x9e187755
-0,     905472,     905472,     1152,     2304, 0x493380be
-0,     906624,     906624,     1152,     2304, 0xd89d7b16
-0,     907776,     907776,     1152,     2304, 0x60328461
-0,     908928,     908928,     1152,     2304, 0x4ba37ce6
-0,     910080,     910080,     1152,     2304, 0x41fa796d
-0,     911232,     911232,     1152,     2304, 0x27b37fd0
-0,     912384,     912384,     1152,     2304, 0x58c07456
-0,     913536,     913536,     1152,     2304, 0xefb48040
-0,     914688,     914688,     1152,     2304, 0xdab37882
-0,     915840,     915840,     1152,     2304, 0xa4357c5f
-0,     916992,     916992,     1152,     2304, 0x6e3b67bc
-0,     918144,     918144,     1152,     2304, 0x057e6e61
-0,     919296,     919296,     1152,     2304, 0x173c783b
-0,     920448,     920448,     1152,     2304, 0x7a3a7e7e
-0,     921600,     921600,     1152,     2304, 0xadbb7992
-0,     922752,     922752,     1152,     2304, 0x93257bba
-0,     923904,     923904,     1152,     2304, 0x0e3f8309
-0,     925056,     925056,     1152,     2304, 0x395d7cb9
-0,     926208,     926208,     1152,     2304, 0xb77487f6
-0,     927360,     927360,     1152,     2304, 0xa9657725
-0,     928512,     928512,     1152,     2304, 0x3ced751a
-0,     929664,     929664,     1152,     2304, 0x0a85976d
-0,     930816,     930816,     1152,     2304, 0xb3a781b2
-0,     931968,     931968,     1152,     2304, 0x365070d4
-0,     933120,     933120,     1152,     2304, 0x20d88526
-0,     934272,     934272,     1152,     2304, 0x33f672f3
-0,     935424,     935424,     1152,     2304, 0x465177a1
-0,     936576,     936576,     1152,     2304, 0x69a6854e
-0,     937728,     937728,     1152,     2304, 0x41748372
-0,     938880,     938880,     1152,     2304, 0x01356e23
-0,     940032,     940032,     1152,     2304, 0x2b4e83d1
-0,     941184,     941184,     1152,     2304, 0x92608980
-0,     942336,     942336,     1152,     2304, 0x251498c5
-0,     943488,     943488,     1152,     2304, 0xcaad7b03
-0,     944640,     944640,     1152,     2304, 0x0e6d88f7
-0,     945792,     945792,     1152,     2304, 0xb84c87bf
-0,     946944,     946944,     1152,     2304, 0xc5a27843
-0,     948096,     948096,     1152,     2304, 0xba828a38
-0,     949248,     949248,     1152,     2304, 0x25af743e
-0,     950400,     950400,     1152,     2304, 0x20b5730a
-0,     951552,     951552,     1152,     2304, 0x16217f13
-0,     952704,     952704,     1152,     2304, 0x1d2d7541
-0,     953856,     953856,     1152,     2304, 0x4e0e718e
-0,     955008,     955008,     1152,     2304, 0xff756ff5
-0,     956160,     956160,     1152,     2304, 0x3e1f862d
-0,     957312,     957312,     1152,     2304, 0x1ada6893
-0,     958464,     958464,     1152,     2304, 0xa6347e21
-0,     959616,     959616,     1152,     2304, 0x5b8f790a
-0,     960768,     960768,     1152,     2304, 0x4e468c13
-0,     961920,     961920,     1152,     2304, 0x4e1c7fea
-0,     963072,     963072,     1152,     2304, 0x0d5f8719
-0,     964224,     964224,     1152,     2304, 0xd0ef7bc8
-0,     965376,     965376,     1152,     2304, 0x7e756a94
-0,     966528,     966528,     1152,     2304, 0xc2848a60
-0,     967680,     967680,     1152,     2304, 0xa6cc8cab
-0,     968832,     968832,     1152,     2304, 0xb70c784d
-0,     969984,     969984,     1152,     2304, 0x93c569ac
-0,     971136,     971136,     1152,     2304, 0xd6087581
-0,     972288,     972288,     1152,     2304, 0xdd0978b2
-0,     973440,     973440,     1152,     2304, 0xe2977e5f
-0,     974592,     974592,     1152,     2304, 0x07f17aa5
-0,     975744,     975744,     1152,     2304, 0x55447642
-0,     976896,     976896,     1152,     2304, 0xfac46f2b
-0,     978048,     978048,     1152,     2304, 0xfbe184c7
-0,     979200,     979200,     1152,     2304, 0xc15d7f14
-0,     980352,     980352,     1152,     2304, 0x66707ce9
-0,     981504,     981504,     1152,     2304, 0x132f94a6
-0,     982656,     982656,     1152,     2304, 0xd3816d5c
-0,     983808,     983808,     1152,     2304, 0xae068243
-0,     984960,     984960,     1152,     2304, 0x86fd8276
-0,     986112,     986112,     1152,     2304, 0x8ef876b1
-0,     987264,     987264,     1152,     2304, 0x9e8c723d
-0,     988416,     988416,     1152,     2304, 0x1052790d
-0,     989568,     989568,     1152,     2304, 0xf17a7ce2
-0,     990720,     990720,     1152,     2304, 0x5c168593
-0,     991872,     991872,     1152,     2304, 0xd4e081d7
-0,     993024,     993024,     1152,     2304, 0x34808427
-0,     994176,     994176,     1152,     2304, 0x984d97c0
-0,     995328,     995328,     1152,     2304, 0x6bc3759b
-0,     996480,     996480,     1152,     2304, 0x9c56839e
-0,     997632,     997632,     1152,     2304, 0xb5178156
-0,     998784,     998784,     1152,     2304, 0x2929721a
-0,     999936,     999936,     1152,     2304, 0xe0c87323
-0,    1001088,    1001088,     1152,     2304, 0xab046e2b
-0,    1002240,    1002240,     1152,     2304, 0x2d027795
-0,    1003392,    1003392,     1152,     2304, 0x857c7611
-0,    1004544,    1004544,     1152,     2304, 0xd6cc84c1
-0,    1005696,    1005696,     1152,     2304, 0x34ed6a8d
-0,    1006848,    1006848,     1152,     2304, 0x9df97efa
-0,    1008000,    1008000,     1152,     2304, 0xdfe38b2a
-0,    1009152,    1009152,     1152,     2304, 0xecc47465
-0,    1010304,    1010304,     1152,     2304, 0x4c0b74f4
-0,    1011456,    1011456,     1152,     2304, 0x766c784c
-0,    1012608,    1012608,     1152,     2304, 0x98977fc1
-0,    1013760,    1013760,     1152,     2304, 0x19d48d6f
-0,    1014912,    1014912,     1152,     2304, 0x1ad983ac
-0,    1016064,    1016064,     1152,     2304, 0xddf98401
-0,    1017216,    1017216,     1152,     2304, 0x6fc878b3
-0,    1018368,    1018368,     1152,     2304, 0xfc976cae
-0,    1019520,    1019520,     1152,     2304, 0x2c1b7777
-0,    1020672,    1020672,     1152,     2304, 0xe3c0814b
-0,    1021824,    1021824,     1152,     2304, 0x15ba7e98
-0,    1022976,    1022976,     1152,     2304, 0x30d073cf
-0,    1024128,    1024128,     1152,     2304, 0x6d988374
-0,    1025280,    1025280,     1152,     2304, 0xb7827920
-0,    1026432,    1026432,     1152,     2304, 0xafd47600
-0,    1027584,    1027584,     1152,     2304, 0x8fbc8bab
-0,    1028736,    1028736,     1152,     2304, 0x13f674b5
-0,    1029888,    1029888,     1152,     2304, 0xcbea62ff
-0,    1031040,    1031040,     1152,     2304, 0xfc828378
-0,    1032192,    1032192,     1152,     2304, 0x1a4d7ad4
-0,    1033344,    1033344,     1152,     2304, 0x8bcb753f
-0,    1034496,    1034496,     1152,     2304, 0x97108fc5
-0,    1035648,    1035648,     1152,     2304, 0x243f77ae
-0,    1036800,    1036800,     1152,     2304, 0x4eec6f66
-0,    1037952,    1037952,     1152,     2304, 0xcb167ef4
-0,    1039104,    1039104,     1152,     2304, 0x3b1c7c49
-0,    1040256,    1040256,     1152,     2304, 0x6b6a8287
-0,    1041408,    1041408,     1152,     2304, 0xc2aa8063
-0,    1042560,    1042560,     1152,     2304, 0xd40c7ed7
-0,    1043712,    1043712,     1152,     2304, 0x03b3777e
-0,    1044864,    1044864,     1152,     2304, 0x414075ac
-0,    1046016,    1046016,     1152,     2304, 0x44af86c6
-0,    1047168,    1047168,     1152,     2304, 0x7e6c640e
-0,    1048320,    1048320,     1152,     2304, 0xb5c97a6a
-0,    1049472,    1049472,     1152,     2304, 0x92837eaf
-0,    1050624,    1050624,     1152,     2304, 0xa9657a9f
-0,    1051776,    1051776,     1152,     2304, 0xa18d619f
-0,    1052928,    1052928,     1152,     2304, 0x194d8fec
-0,    1054080,    1054080,     1152,     2304, 0x29eb7416
-0,    1055232,    1055232,     1152,     2304, 0x437d7e00
-0,    1056384,    1056384,     1152,     2304, 0xa1957140
-0,    1057536,    1057536,     1152,     2304, 0xd4b279bf
-0,    1058688,    1058688,     1152,     2304, 0xbd507ecd
-0,    1059840,    1059840,     1152,     2304, 0x3cea7c4d
-0,    1060992,    1060992,     1152,     2304, 0x8fe07265
-0,    1062144,    1062144,     1152,     2304, 0x773a7d24
-0,    1063296,    1063296,     1152,     2304, 0x83867c9a
-0,    1064448,    1064448,     1152,     2304, 0x22fa82ee
-0,    1065600,    1065600,     1152,     2304, 0xa67f6da7
-0,    1066752,    1066752,     1152,     2304, 0x251787ed
-0,    1067904,    1067904,     1152,     2304, 0x6e3c68f3
-0,    1069056,    1069056,     1152,     2304, 0xe7e6943d
-0,    1070208,    1070208,     1152,     2304, 0xcc62766f
-0,    1071360,    1071360,     1152,     2304, 0x1d2e7224
-0,    1072512,    1072512,     1152,     2304, 0x8c6c82a4
-0,    1073664,    1073664,     1152,     2304, 0x528d7140
-0,    1074816,    1074816,     1152,     2304, 0xfc558d79
-0,    1075968,    1075968,     1152,     2304, 0xcd537312
-0,    1077120,    1077120,     1152,     2304, 0xdb248ca7
-0,    1078272,    1078272,     1152,     2304, 0xed376f07
-0,    1079424,    1079424,     1152,     2304, 0x5b8a715b
-0,    1080576,    1080576,     1152,     2304, 0x07157e4f
-0,    1081728,    1081728,     1152,     2304, 0xeba087c7
-0,    1082880,    1082880,     1152,     2304, 0x5ebc7cd1
-0,    1084032,    1084032,     1152,     2304, 0xc6a372bd
-0,    1085184,    1085184,     1152,     2304, 0x0838630c
-0,    1086336,    1086336,     1152,     2304, 0x984589d7
-0,    1087488,    1087488,     1152,     2304, 0x08f171cf
-0,    1088640,    1088640,     1152,     2304, 0x6846772c
-0,    1089792,    1089792,     1152,     2304, 0x1ac37243
-0,    1090944,    1090944,     1152,     2304, 0xcf406f33
-0,    1092096,    1092096,     1152,     2304, 0xefe97e4f
-0,    1093248,    1093248,     1152,     2304, 0xf16988de
-0,    1094400,    1094400,     1152,     2304, 0x62c86d1d
-0,    1095552,    1095552,     1152,     2304, 0xaa5787ef
-0,    1096704,    1096704,     1152,     2304, 0xdbea69c6
-0,    1097856,    1097856,     1152,     2304, 0x2786816e
-0,    1099008,    1099008,     1152,     2304, 0x4ca97a1d
-0,    1100160,    1100160,     1152,     2304, 0xe6467b49
-0,    1101312,    1101312,     1152,     2304, 0x4ff18326
-0,    1102464,    1102464,     1152,     2304, 0xfde07023
-0,    1103616,    1103616,     1152,     2304, 0x5157759b
-0,    1104768,    1104768,     1152,     2304, 0x388b7271
-0,    1105920,    1105920,     1152,     2304, 0x93037a95
-0,    1107072,    1107072,     1152,     2304, 0x71fd8e51
-0,    1108224,    1108224,     1152,     2304, 0x61b78492
-0,    1109376,    1109376,     1152,     2304, 0xe0956c0f
-0,    1110528,    1110528,     1152,     2304, 0x3e9a7a92
-0,    1111680,    1111680,     1152,     2304, 0x84b57793
-0,    1112832,    1112832,     1152,     2304, 0xe1b16c20
-0,    1113984,    1113984,     1152,     2304, 0x00ab8949
-0,    1115136,    1115136,     1152,     2304, 0x9fb16e65
-0,    1116288,    1116288,     1152,     2304, 0x0dee80e3
-0,    1117440,    1117440,     1152,     2304, 0x3a5f71d0
-0,    1118592,    1118592,     1152,     2304, 0x1d2b7777
-0,    1119744,    1119744,     1152,     2304, 0x0fcb8f97
-0,    1120896,    1120896,     1152,     2304, 0x4ea3707d
-0,    1122048,    1122048,     1152,     2304, 0x68dd6c74
-0,    1123200,    1123200,     1152,     2304, 0xd3328038
-0,    1124352,    1124352,     1152,     2304, 0x68b176f1
-0,    1125504,    1125504,     1152,     2304, 0xd17a7585
-0,    1126656,    1126656,     1152,     2304, 0xd1895c93
-0,    1127808,    1127808,     1152,     2304, 0x15a17c70
-0,    1128960,    1128960,     1152,     2304, 0xec447a3f
-0,    1130112,    1130112,     1152,     2304, 0xafb566be
-0,    1131264,    1131264,     1152,     2304, 0xf50c67ea
-0,    1132416,    1132416,     1152,     2304, 0xe86e8162
-0,    1133568,    1133568,     1152,     2304, 0xc5888400
-0,    1134720,    1134720,     1152,     2304, 0x28d18a0a
-0,    1135872,    1135872,     1152,     2304, 0x83bc7178
-0,    1137024,    1137024,     1152,     2304, 0x1e9384b4
-0,    1138176,    1138176,     1152,     2304, 0x163b7a1e
-0,    1139328,    1139328,     1152,     2304, 0x6a7d846e
-0,    1140480,    1140480,     1152,     2304, 0x7b2583ed
-0,    1141632,    1141632,     1152,     2304, 0x82b27dbe
-0,    1142784,    1142784,     1152,     2304, 0xb3eb7b4b
-0,    1143936,    1143936,     1152,     2304, 0x69d676e0
-0,    1145088,    1145088,     1152,     2304, 0x43cb751f
-0,    1146240,    1146240,     1152,     2304, 0x79907c30
-0,    1147392,    1147392,     1152,     2304, 0xf9537a26
-0,    1148544,    1148544,     1152,     2304, 0xdfc07c98
-0,    1149696,    1149696,     1152,     2304, 0x6bd68361
-0,    1150848,    1150848,     1152,     2304, 0x00c2717b
-0,    1152000,    1152000,     1152,     2304, 0x8c5b7707
-0,    1153152,    1153152,     1152,     2304, 0xeb427b90
-0,    1154304,    1154304,     1152,     2304, 0x57207d84
-0,    1155456,    1155456,     1152,     2304, 0x722d8652
-0,    1156608,    1156608,     1152,     2304, 0xd9bd7e8a
-0,    1157760,    1157760,     1152,     2304, 0x707e83b8
-0,    1158912,    1158912,     1152,     2304, 0xc14b6b2c
-0,    1160064,    1160064,     1152,     2304, 0xde6a8cc4
-0,    1161216,    1161216,     1152,     2304, 0x101a75c0
-0,    1162368,    1162368,     1152,     2304, 0xad768649
-0,    1163520,    1163520,     1152,     2304, 0x7d236a22
-0,    1164672,    1164672,     1152,     2304, 0xbab97221
-0,    1165824,    1165824,     1152,     2304, 0x0ba2754f
-0,    1166976,    1166976,     1152,     2304, 0x09c077ae
-0,    1168128,    1168128,     1152,     2304, 0xf086712e
-0,    1169280,    1169280,     1152,     2304, 0x99a775c1
-0,    1170432,    1170432,     1152,     2304, 0xc3b27ae2
-0,    1171584,    1171584,     1152,     2304, 0x221482e4
-0,    1172736,    1172736,     1152,     2304, 0x12cd8059
-0,    1173888,    1173888,     1152,     2304, 0xa797854b
-0,    1175040,    1175040,     1152,     2304, 0xa4f673b3
-0,    1176192,    1176192,     1152,     2304, 0x5e8e75cb
-0,    1177344,    1177344,     1152,     2304, 0xdb866722
-0,    1178496,    1178496,     1152,     2304, 0x13cb79af
-0,    1179648,    1179648,     1152,     2304, 0x66987f64
-0,    1180800,    1180800,     1152,     2304, 0x6d947c06
-0,    1181952,    1181952,     1152,     2304, 0x8efd85de
-0,    1183104,    1183104,     1152,     2304, 0x438c6eb6
-0,    1184256,    1184256,     1152,     2304, 0x4d1a6e6d
-0,    1185408,    1185408,     1152,     2304, 0x45747729
-0,    1186560,    1186560,     1152,     2304, 0x5f82833d
-0,    1187712,    1187712,     1152,     2304, 0xd8608003
-0,    1188864,    1188864,     1152,     2304, 0x92b175a8
-0,    1190016,    1190016,     1152,     2304, 0x5a1a7901
-0,    1191168,    1191168,     1152,     2304, 0x319c752c
-0,    1192320,    1192320,     1152,     2304, 0x45c978df
-0,    1193472,    1193472,     1152,     2304, 0xee577010
-0,    1194624,    1194624,     1152,     2304, 0xcde372d0
-0,    1195776,    1195776,     1152,     2304, 0xfa7d85a6
-0,    1196928,    1196928,     1152,     2304, 0x83f26935
-0,    1198080,    1198080,     1152,     2304, 0xa0d86ade
-0,    1199232,    1199232,     1152,     2304, 0x3bd77767
-0,    1200384,    1200384,     1152,     2304, 0x39f0781e
-0,    1201536,    1201536,     1152,     2304, 0x9e8b78fc
-0,    1202688,    1202688,     1152,     2304, 0x465889cb
-0,    1203840,    1203840,     1152,     2304, 0x3ef47308
-0,    1204992,    1204992,     1152,     2304, 0x660f7600
-0,    1206144,    1206144,     1152,     2304, 0x37217b15
-0,    1207296,    1207296,     1152,     2304, 0x6a277fe6
-0,    1208448,    1208448,     1152,     2304, 0x40947c92
-0,    1209600,    1209600,     1152,     2304, 0x323f8933
-0,    1210752,    1210752,     1152,     2304, 0x7c27807f
-0,    1211904,    1211904,     1152,     2304, 0x335f7e9d
-0,    1213056,    1213056,     1152,     2304, 0x54e180ce
-0,    1214208,    1214208,     1152,     2304, 0xe4958003
-0,    1215360,    1215360,     1152,     2304, 0x51217e5c
-0,    1216512,    1216512,     1152,     2304, 0xae127b8b
-0,    1217664,    1217664,     1152,     2304, 0x505b8928
-0,    1218816,    1218816,     1152,     2304, 0xb0606fe9
-0,    1219968,    1219968,     1152,     2304, 0x701c7c35
-0,    1221120,    1221120,     1152,     2304, 0xb68273e8
-0,    1222272,    1222272,     1152,     2304, 0x64807c6d
-0,    1223424,    1223424,     1152,     2304, 0xb650926a
-0,    1224576,    1224576,     1152,     2304, 0x83bb6ceb
-0,    1225728,    1225728,     1152,     2304, 0xc3998a91
-0,    1226880,    1226880,     1152,     2304, 0x4a4a806c
-0,    1228032,    1228032,     1152,     2304, 0x6d6c70be
-0,    1229184,    1229184,     1152,     2304, 0x3ca06cf2
-0,    1230336,    1230336,     1152,     2304, 0xfb3e81f4
-0,    1231488,    1231488,     1152,     2304, 0xa6636fea
-0,    1232640,    1232640,     1152,     2304, 0xd4917e59
-0,    1233792,    1233792,     1152,     2304, 0x03f480e9
-0,    1234944,    1234944,     1152,     2304, 0x29ca6e9e
-0,    1236096,    1236096,     1152,     2304, 0x64c17e41
-0,    1237248,    1237248,     1152,     2304, 0x386778ae
-0,    1238400,    1238400,     1152,     2304, 0x3ad77c8a
-0,    1239552,    1239552,     1152,     2304, 0x477481bb
-0,    1240704,    1240704,     1152,     2304, 0x65e69d00
-0,    1241856,    1241856,     1152,     2304, 0x77856f7c
-0,    1243008,    1243008,     1152,     2304, 0x46317d97
-0,    1244160,    1244160,     1152,     2304, 0x1393982f
-0,    1245312,    1245312,     1152,     2304, 0x0a4f83d1
-0,    1246464,    1246464,     1152,     2304, 0x2bfc6982
-0,    1247616,    1247616,     1152,     2304, 0x125b7cc4
-0,    1248768,    1248768,     1152,     2304, 0xbd987b3c
-0,    1249920,    1249920,     1152,     2304, 0xc05b78de
-0,    1251072,    1251072,     1152,     2304, 0xd8ca7b57
-0,    1252224,    1252224,     1152,     2304, 0x01788222
-0,    1253376,    1253376,     1152,     2304, 0xc4307c2f
-0,    1254528,    1254528,     1152,     2304, 0x55fd71fb
-0,    1255680,    1255680,     1152,     2304, 0xdd42764f
-0,    1256832,    1256832,     1152,     2304, 0xdc1f9341
-0,    1257984,    1257984,     1152,     2304, 0xbc3b7e76
-0,    1259136,    1259136,     1152,     2304, 0x5d25954b
-0,    1260288,    1260288,     1152,     2304, 0xeb438321
-0,    1261440,    1261440,     1152,     2304, 0xbe3a8bf6
-0,    1262592,    1262592,     1152,     2304, 0x2bb282dd
-0,    1263744,    1263744,     1152,     2304, 0x4e627986
-0,    1264896,    1264896,     1152,     2304, 0xbc748335
-0,    1266048,    1266048,     1152,     2304, 0xaec08e92
-0,    1267200,    1267200,     1152,     2304, 0xe8fb6feb
-0,    1268352,    1268352,     1152,     2304, 0xdb92838a
-0,    1269504,    1269504,     1152,     2304, 0x7c5c71c9
-0,    1270656,    1270656,     1152,     2304, 0x81c47f6c
-0,    1271808,    1271808,     1152,     2304, 0x86367d7a
-0,    1272960,    1272960,     1152,     2304, 0xbe2c7c9b
-0,    1274112,    1274112,     1152,     2304, 0xec7d7c43
-0,    1275264,    1275264,     1152,     2304, 0x942886a7
-0,    1276416,    1276416,     1152,     2304, 0xf8a7737f
-0,    1277568,    1277568,     1152,     2304, 0x43fd77bb
-0,    1278720,    1278720,     1152,     2304, 0xde967ebb
-0,    1279872,    1279872,     1152,     2304, 0x0c75709a
-0,    1281024,    1281024,     1152,     2304, 0xe6ae8208
-0,    1282176,    1282176,     1152,     2304, 0x4a957327
-0,    1283328,    1283328,     1152,     2304, 0x320e82d7
-0,    1284480,    1284480,     1152,     2304, 0x8ef07a8e
-0,    1285632,    1285632,     1152,     2304, 0x8d747755
-0,    1286784,    1286784,     1152,     2304, 0x39386d30
-0,    1287936,    1287936,     1152,     2304, 0xf4727e5b
-0,    1289088,    1289088,     1152,     2304, 0xeb5370ec
-0,    1290240,    1290240,     1152,     2304, 0x8b1f8d75
-0,    1291392,    1291392,     1152,     2304, 0xe4687d65
-0,    1292544,    1292544,     1152,     2304, 0x952b6e67
-0,    1293696,    1293696,     1152,     2304, 0xb16a8c9e
-0,    1294848,    1294848,     1152,     2304, 0x417d7545
-0,    1296000,    1296000,     1152,     2304, 0x037b85fa
-0,    1297152,    1297152,     1152,     2304, 0x95bc7fce
-0,    1298304,    1298304,     1152,     2304, 0x5b42838d
-0,    1299456,    1299456,     1152,     2304, 0xd6196f79
-0,    1300608,    1300608,     1152,     2304, 0x651e7621
-0,    1301760,    1301760,     1152,     2304, 0xefa28205
-0,    1302912,    1302912,     1152,     2304, 0xe43984d9
-0,    1304064,    1304064,     1152,     2304, 0xbb887e46
-0,    1305216,    1305216,     1152,     2304, 0x4c6b9735
-0,    1306368,    1306368,     1152,     2304, 0x8b687a7b
-0,    1307520,    1307520,     1152,     2304, 0x59ff7691
-0,    1308672,    1308672,     1152,     2304, 0xc2686a24
-0,    1309824,    1309824,     1152,     2304, 0xa13c7d3e
-0,    1310976,    1310976,     1152,     2304, 0x74ff7d34
-0,    1312128,    1312128,     1152,     2304, 0x36687902
-0,    1313280,    1313280,     1152,     2304, 0xfa827a27
-0,    1314432,    1314432,     1152,     2304, 0x3dac840a
-0,    1315584,    1315584,     1152,     2304, 0xee04832b
-0,    1316736,    1316736,     1152,     2304, 0xa2778478
-0,    1317888,    1317888,     1152,     2304, 0xa1c68ef8
-0,    1319040,    1319040,     1152,     2304, 0x2fff78df
-0,    1320192,    1320192,     1152,     2304, 0xb8187742
-0,    1321344,    1321344,     1152,     2304, 0xf42d6be2
-0,    1322496,    1322496,     1152,     2304, 0x39378530
-0,    1323648,    1323648,     1152,     2304, 0x48775d6c
-0,    1324800,    1324800,     1152,     2304, 0x5ea6f8e8
+#channel_layout_name 0: mono
+0,          0,          0,     1152,     2304, 0x907cb7fa
+0,       1152,       1152,     1152,     2304, 0xb8dc7525
+0,       2304,       2304,     1152,     2304, 0x3e7d6905
+0,       3456,       3456,     1152,     2304, 0xef47877b
+0,       4608,       4608,     1152,     2304, 0xfe916b7e
+0,       5760,       5760,     1152,     2304, 0xe3d08cde
+0,       6912,       6912,     1152,     2304, 0xff7f86cf
+0,       8064,       8064,     1152,     2304, 0x843e6f95
+0,       9216,       9216,     1152,     2304, 0x81577c26
+0,      10368,      10368,     1152,     2304, 0x04a085d5
+0,      11520,      11520,     1152,     2304, 0x1c5a76f5
+0,      12672,      12672,     1152,     2304, 0x4ee78623
+0,      13824,      13824,     1152,     2304, 0x8ec861dc
+0,      14976,      14976,     1152,     2304, 0x0ca179d8
+0,      16128,      16128,     1152,     2304, 0xc6da750f
+0,      17280,      17280,     1152,     2304, 0xf6bf79b5
+0,      18432,      18432,     1152,     2304, 0x97b88a43
+0,      19584,      19584,     1152,     2304, 0xf13c7b9c
+0,      20736,      20736,     1152,     2304, 0xdfba83af
+0,      21888,      21888,     1152,     2304, 0xc9467d4b
+0,      23040,      23040,     1152,     2304, 0xbbb58e2b
+0,      24192,      24192,     1152,     2304, 0x3a1078ea
+0,      25344,      25344,     1152,     2304, 0xe9587a5c
+0,      26496,      26496,     1152,     2304, 0xef5a8039
+0,      27648,      27648,     1152,     2304, 0x9d5f782f
+0,      28800,      28800,     1152,     2304, 0x1a548291
+0,      29952,      29952,     1152,     2304, 0x07517701
+0,      31104,      31104,     1152,     2304, 0x78127d6e
+0,      32256,      32256,     1152,     2304, 0x62e2788a
+0,      33408,      33408,     1152,     2304, 0x29397ad9
+0,      34560,      34560,     1152,     2304, 0x45da82d6
+0,      35712,      35712,     1152,     2304, 0x8ed66e51
+0,      36864,      36864,     1152,     2304, 0x660775cd
+0,      38016,      38016,     1152,     2304, 0x802c767a
+0,      39168,      39168,     1152,     2304, 0xcc055840
+0,      40320,      40320,     1152,     2304, 0x701b7eaf
+0,      41472,      41472,     1152,     2304, 0x8290749f
+0,      42624,      42624,     1152,     2304, 0x2c7b7d30
+0,      43776,      43776,     1152,     2304, 0xe4f17743
+0,      44928,      44928,     1152,     2304, 0x0e747d6e
+0,      46080,      46080,     1152,     2304, 0xbe7775a0
+0,      47232,      47232,     1152,     2304, 0xcf797673
+0,      48384,      48384,     1152,     2304, 0x29cb7800
+0,      49536,      49536,     1152,     2304, 0xfc947890
+0,      50688,      50688,     1152,     2304, 0x62757fc6
+0,      51840,      51840,     1152,     2304, 0x098876d0
+0,      52992,      52992,     1152,     2304, 0xa9567ee2
+0,      54144,      54144,     1152,     2304, 0xe3bb9173
+0,      55296,      55296,     1152,     2304, 0xcc2d6dee
+0,      56448,      56448,     1152,     2304, 0xe94591ab
+0,      57600,      57600,     1152,     2304, 0x5c7588de
+0,      58752,      58752,     1152,     2304, 0xfd83643c
+0,      59904,      59904,     1152,     2304, 0x528177f1
+0,      61056,      61056,     1152,     2304, 0x65d08474
+0,      62208,      62208,     1152,     2304, 0x738d765b
+0,      63360,      63360,     1152,     2304, 0xdd3d810e
+0,      64512,      64512,     1152,     2304, 0xef4f90d3
+0,      65664,      65664,     1152,     2304, 0x61e28d43
+0,      66816,      66816,     1152,     2304, 0x9a11796b
+0,      67968,      67968,     1152,     2304, 0x96c97dcd
+0,      69120,      69120,     1152,     2304, 0xa8fe8621
+0,      70272,      70272,     1152,     2304, 0x499b7d38
+0,      71424,      71424,     1152,     2304, 0xfcb078a9
+0,      72576,      72576,     1152,     2304, 0x40d78651
+0,      73728,      73728,     1152,     2304, 0xa4af7234
+0,      74880,      74880,     1152,     2304, 0x6831870a
+0,      76032,      76032,     1152,     2304, 0x030e7b9d
+0,      77184,      77184,     1152,     2304, 0x445a75b6
+0,      78336,      78336,     1152,     2304, 0x09857389
+0,      79488,      79488,     1152,     2304, 0x0d018866
+0,      80640,      80640,     1152,     2304, 0x2afe810a
+0,      81792,      81792,     1152,     2304, 0x0bcf7c43
+0,      82944,      82944,     1152,     2304, 0x13737c12
+0,      84096,      84096,     1152,     2304, 0x716c7bba
+0,      85248,      85248,     1152,     2304, 0xb801823b
+0,      86400,      86400,     1152,     2304, 0x0fd573ee
+0,      87552,      87552,     1152,     2304, 0xe1ab879c
+0,      88704,      88704,     1152,     2304, 0x49e6764f
+0,      89856,      89856,     1152,     2304, 0xd5f26ddc
+0,      91008,      91008,     1152,     2304, 0x076775ff
+0,      92160,      92160,     1152,     2304, 0xfbb86fce
+0,      93312,      93312,     1152,     2304, 0x20c56858
+0,      94464,      94464,     1152,     2304, 0x043e6891
+0,      95616,      95616,     1152,     2304, 0x59648729
+0,      96768,      96768,     1152,     2304, 0xd4907a63
+0,      97920,      97920,     1152,     2304, 0xd0208a4c
+0,      99072,      99072,     1152,     2304, 0xce968383
+0,     100224,     100224,     1152,     2304, 0x3cfc7cd1
+0,     101376,     101376,     1152,     2304, 0x628a7bf5
+0,     102528,     102528,     1152,     2304, 0x9cfe8a4f
+0,     103680,     103680,     1152,     2304, 0xdf6f7c6d
+0,     104832,     104832,     1152,     2304, 0x6cf6882a
+0,     105984,     105984,     1152,     2304, 0x099773a3
+0,     107136,     107136,     1152,     2304, 0x4a1c7649
+0,     108288,     108288,     1152,     2304, 0x31ea71cb
+0,     109440,     109440,     1152,     2304, 0xed127ed9
+0,     110592,     110592,     1152,     2304, 0x5b156954
+0,     111744,     111744,     1152,     2304, 0xdd638532
+0,     112896,     112896,     1152,     2304, 0xf1a271f2
+0,     114048,     114048,     1152,     2304, 0x779184d7
+0,     115200,     115200,     1152,     2304, 0x49a88aa8
+0,     116352,     116352,     1152,     2304, 0xa11b7c90
+0,     117504,     117504,     1152,     2304, 0xbf488274
+0,     118656,     118656,     1152,     2304, 0x002f79a8
+0,     119808,     119808,     1152,     2304, 0x0ed97e2f
+0,     120960,     120960,     1152,     2304, 0x7845878f
+0,     122112,     122112,     1152,     2304, 0x46d777dc
+0,     123264,     123264,     1152,     2304, 0x8d0179e3
+0,     124416,     124416,     1152,     2304, 0x38917f9f
+0,     125568,     125568,     1152,     2304, 0x449876e7
+0,     126720,     126720,     1152,     2304, 0x001a8769
+0,     127872,     127872,     1152,     2304, 0x06c1826b
+0,     129024,     129024,     1152,     2304, 0x41b68047
+0,     130176,     130176,     1152,     2304, 0xeb9782c6
+0,     131328,     131328,     1152,     2304, 0x7cd9719c
+0,     132480,     132480,     1152,     2304, 0x3a4a767c
+0,     133632,     133632,     1152,     2304, 0x7f887e81
+0,     134784,     134784,     1152,     2304, 0xf75d714b
+0,     135936,     135936,     1152,     2304, 0x33b57e9f
+0,     137088,     137088,     1152,     2304, 0xc732749e
+0,     138240,     138240,     1152,     2304, 0x386f7e1a
+0,     139392,     139392,     1152,     2304, 0x6b9c767d
+0,     140544,     140544,     1152,     2304, 0x701c83e5
+0,     141696,     141696,     1152,     2304, 0xb92571e1
+0,     142848,     142848,     1152,     2304, 0x833a84bc
+0,     144000,     144000,     1152,     2304, 0x1b6984e0
+0,     145152,     145152,     1152,     2304, 0x1b2474ba
+0,     146304,     146304,     1152,     2304, 0xc22775a6
+0,     147456,     147456,     1152,     2304, 0x3e8f7972
+0,     148608,     148608,     1152,     2304, 0x17a28a65
+0,     149760,     149760,     1152,     2304, 0x9b6178a4
+0,     150912,     150912,     1152,     2304, 0x5d707873
+0,     152064,     152064,     1152,     2304, 0x68e2645a
+0,     153216,     153216,     1152,     2304, 0x1e377d28
+0,     154368,     154368,     1152,     2304, 0x54b384be
+0,     155520,     155520,     1152,     2304, 0x0617808c
+0,     156672,     156672,     1152,     2304, 0xbc2b8a6c
+0,     157824,     157824,     1152,     2304, 0x7ced7180
+0,     158976,     158976,     1152,     2304, 0xf22180ab
+0,     160128,     160128,     1152,     2304, 0xf13682c9
+0,     161280,     161280,     1152,     2304, 0x7eff87fd
+0,     162432,     162432,     1152,     2304, 0x5a0b5cec
+0,     163584,     163584,     1152,     2304, 0x57c18906
+0,     164736,     164736,     1152,     2304, 0xb55a6a16
+0,     165888,     165888,     1152,     2304, 0xf2608371
+0,     167040,     167040,     1152,     2304, 0x36df7576
+0,     168192,     168192,     1152,     2304, 0xdb106fb4
+0,     169344,     169344,     1152,     2304, 0x7e4f85d0
+0,     170496,     170496,     1152,     2304, 0xe3ee78ab
+0,     171648,     171648,     1152,     2304, 0xd36b7dc7
+0,     172800,     172800,     1152,     2304, 0xadab7c5c
+0,     173952,     173952,     1152,     2304, 0x70786f26
+0,     175104,     175104,     1152,     2304, 0xcd5d717e
+0,     176256,     176256,     1152,     2304, 0xc1a96f9a
+0,     177408,     177408,     1152,     2304, 0xad777887
+0,     178560,     178560,     1152,     2304, 0x98277c16
+0,     179712,     179712,     1152,     2304, 0x868882c5
+0,     180864,     180864,     1152,     2304, 0xc48092b9
+0,     182016,     182016,     1152,     2304, 0x230069da
+0,     183168,     183168,     1152,     2304, 0x14147ad6
+0,     184320,     184320,     1152,     2304, 0xc9007172
+0,     185472,     185472,     1152,     2304, 0x85d67bcc
+0,     186624,     186624,     1152,     2304, 0x22418bab
+0,     187776,     187776,     1152,     2304, 0xe53c8b71
+0,     188928,     188928,     1152,     2304, 0x5a1a9053
+0,     190080,     190080,     1152,     2304, 0x9cd179af
+0,     191232,     191232,     1152,     2304, 0xbb3c7d72
+0,     192384,     192384,     1152,     2304, 0x477a8677
+0,     193536,     193536,     1152,     2304, 0xe3337834
+0,     194688,     194688,     1152,     2304, 0x1cb56d77
+0,     195840,     195840,     1152,     2304, 0xe89d6dac
+0,     196992,     196992,     1152,     2304, 0xd468827e
+0,     198144,     198144,     1152,     2304, 0xebc46b87
+0,     199296,     199296,     1152,     2304, 0x5fbb78d2
+0,     200448,     200448,     1152,     2304, 0xa1b483d6
+0,     201600,     201600,     1152,     2304, 0x6fec7cab
+0,     202752,     202752,     1152,     2304, 0xd86d6f6c
+0,     203904,     203904,     1152,     2304, 0x8c2c7d51
+0,     205056,     205056,     1152,     2304, 0xe8377cd7
+0,     206208,     206208,     1152,     2304, 0xb57071b4
+0,     207360,     207360,     1152,     2304, 0xc35c71fd
+0,     208512,     208512,     1152,     2304, 0x789079e9
+0,     209664,     209664,     1152,     2304, 0x413b710e
+0,     210816,     210816,     1152,     2304, 0x82678332
+0,     211968,     211968,     1152,     2304, 0xe1576e75
+0,     213120,     213120,     1152,     2304, 0x7c0b7ad6
+0,     214272,     214272,     1152,     2304, 0xc6b6786d
+0,     215424,     215424,     1152,     2304, 0x736f7b89
+0,     216576,     216576,     1152,     2304, 0x0ded72f1
+0,     217728,     217728,     1152,     2304, 0xcb877a3c
+0,     218880,     218880,     1152,     2304, 0x7c497d40
+0,     220032,     220032,     1152,     2304, 0xaefc798c
+0,     221184,     221184,     1152,     2304, 0x4cce748c
+0,     222336,     222336,     1152,     2304, 0xaa187fbe
+0,     223488,     223488,     1152,     2304, 0x1aa77db9
+0,     224640,     224640,     1152,     2304, 0x9e0074b8
+0,     225792,     225792,     1152,     2304, 0x74ee822b
+0,     226944,     226944,     1152,     2304, 0x975c6ff6
+0,     228096,     228096,     1152,     2304, 0xe1847bb4
+0,     229248,     229248,     1152,     2304, 0xe0828777
+0,     230400,     230400,     1152,     2304, 0xf4027205
+0,     231552,     231552,     1152,     2304, 0x535e7a20
+0,     232704,     232704,     1152,     2304, 0x5bd88404
+0,     233856,     233856,     1152,     2304, 0xf29478b1
+0,     235008,     235008,     1152,     2304, 0x9b7c7d88
+0,     236160,     236160,     1152,     2304, 0xaeb07335
+0,     237312,     237312,     1152,     2304, 0xbef06e08
+0,     238464,     238464,     1152,     2304, 0x795f7b8c
+0,     239616,     239616,     1152,     2304, 0x435a674d
+0,     240768,     240768,     1152,     2304, 0xd8ee7a09
+0,     241920,     241920,     1152,     2304, 0x9059812e
+0,     243072,     243072,     1152,     2304, 0x7481744a
+0,     244224,     244224,     1152,     2304, 0xdff27475
+0,     245376,     245376,     1152,     2304, 0xb17783ab
+0,     246528,     246528,     1152,     2304, 0x42e9706b
+0,     247680,     247680,     1152,     2304, 0x9f0d86b4
+0,     248832,     248832,     1152,     2304, 0x2963955f
+0,     249984,     249984,     1152,     2304, 0x059a6957
+0,     251136,     251136,     1152,     2304, 0x85948206
+0,     252288,     252288,     1152,     2304, 0x185e8400
+0,     253440,     253440,     1152,     2304, 0xe98e70df
+0,     254592,     254592,     1152,     2304, 0x69057b27
+0,     255744,     255744,     1152,     2304, 0x49e26f21
+0,     256896,     256896,     1152,     2304, 0xb0867da5
+0,     258048,     258048,     1152,     2304, 0x785980ff
+0,     259200,     259200,     1152,     2304, 0xf4b774be
+0,     260352,     260352,     1152,     2304, 0x63897e8c
+0,     261504,     261504,     1152,     2304, 0x248b89af
+0,     262656,     262656,     1152,     2304, 0xd3627c4a
+0,     263808,     263808,     1152,     2304, 0x5a4d9349
+0,     264960,     264960,     1152,     2304, 0xe2ce7c4c
+0,     266112,     266112,     1152,     2304, 0x321f6c0b
+0,     267264,     267264,     1152,     2304, 0x51ac74e0
+0,     268416,     268416,     1152,     2304, 0x8efa91ba
+0,     269568,     269568,     1152,     2304, 0x8b4b784c
+0,     270720,     270720,     1152,     2304, 0xe9e4879e
+0,     271872,     271872,     1152,     2304, 0x8dc28081
+0,     273024,     273024,     1152,     2304, 0x44b477b0
+0,     274176,     274176,     1152,     2304, 0xf7b67084
+0,     275328,     275328,     1152,     2304, 0x4b198c17
+0,     276480,     276480,     1152,     2304, 0x9c947194
+0,     277632,     277632,     1152,     2304, 0x6eaa7f15
+0,     278784,     278784,     1152,     2304, 0x119f7c1d
+0,     279936,     279936,     1152,     2304, 0x157b7f43
+0,     281088,     281088,     1152,     2304, 0xcd2e7acc
+0,     282240,     282240,     1152,     2304, 0x97597247
+0,     283392,     283392,     1152,     2304, 0x7ba06acb
+0,     284544,     284544,     1152,     2304, 0x233c7995
+0,     285696,     285696,     1152,     2304, 0x08e28587
+0,     286848,     286848,     1152,     2304, 0x92be84b5
+0,     288000,     288000,     1152,     2304, 0xbb857d43
+0,     289152,     289152,     1152,     2304, 0x168e7c74
+0,     290304,     290304,     1152,     2304, 0xac5465d9
+0,     291456,     291456,     1152,     2304, 0x18f58831
+0,     292608,     292608,     1152,     2304, 0x19b48196
+0,     293760,     293760,     1152,     2304, 0x20297653
+0,     294912,     294912,     1152,     2304, 0x93397a82
+0,     296064,     296064,     1152,     2304, 0x65ea7deb
+0,     297216,     297216,     1152,     2304, 0xd7316e20
+0,     298368,     298368,     1152,     2304, 0x94107f2b
+0,     299520,     299520,     1152,     2304, 0xec3b7dc6
+0,     300672,     300672,     1152,     2304, 0x2d3783aa
+0,     301824,     301824,     1152,     2304, 0x07e47340
+0,     302976,     302976,     1152,     2304, 0xbc117893
+0,     304128,     304128,     1152,     2304, 0x8bd97851
+0,     305280,     305280,     1152,     2304, 0xc27376a9
+0,     306432,     306432,     1152,     2304, 0x30d88c83
+0,     307584,     307584,     1152,     2304, 0x19c2704c
+0,     308736,     308736,     1152,     2304, 0x093b7b6e
+0,     309888,     309888,     1152,     2304, 0x221a7349
+0,     311040,     311040,     1152,     2304, 0xa4fd82cd
+0,     312192,     312192,     1152,     2304, 0x762e6bc9
+0,     313344,     313344,     1152,     2304, 0x270075d4
+0,     314496,     314496,     1152,     2304, 0xa5f27b90
+0,     315648,     315648,     1152,     2304, 0xf72e7edc
+0,     316800,     316800,     1152,     2304, 0x42178486
+0,     317952,     317952,     1152,     2304, 0x5f7978e8
+0,     319104,     319104,     1152,     2304, 0x5d7c6703
+0,     320256,     320256,     1152,     2304, 0x2c4483d5
+0,     321408,     321408,     1152,     2304, 0x31bd951d
+0,     322560,     322560,     1152,     2304, 0x99487af0
+0,     323712,     323712,     1152,     2304, 0x0bd27ee7
+0,     324864,     324864,     1152,     2304, 0xc3e07ac4
+0,     326016,     326016,     1152,     2304, 0x98a16ba7
+0,     327168,     327168,     1152,     2304, 0xd7a5747b
+0,     328320,     328320,     1152,     2304, 0x96fb811c
+0,     329472,     329472,     1152,     2304, 0x7cee8109
+0,     330624,     330624,     1152,     2304, 0x52b18ba2
+0,     331776,     331776,     1152,     2304, 0x33be8861
+0,     332928,     332928,     1152,     2304, 0xf41282a0
+0,     334080,     334080,     1152,     2304, 0xb4268993
+0,     335232,     335232,     1152,     2304, 0x52126a1c
+0,     336384,     336384,     1152,     2304, 0x050b6f7a
+0,     337536,     337536,     1152,     2304, 0x67a26fc3
+0,     338688,     338688,     1152,     2304, 0x966c7cf2
+0,     339840,     339840,     1152,     2304, 0x22097750
+0,     340992,     340992,     1152,     2304, 0xfbb0796c
+0,     342144,     342144,     1152,     2304, 0xbd508964
+0,     343296,     343296,     1152,     2304, 0xc24478d8
+0,     344448,     344448,     1152,     2304, 0x3913769d
+0,     345600,     345600,     1152,     2304, 0x8aab872f
+0,     346752,     346752,     1152,     2304, 0x7cb4822f
+0,     347904,     347904,     1152,     2304, 0xea318144
+0,     349056,     349056,     1152,     2304, 0xaf0f86d2
+0,     350208,     350208,     1152,     2304, 0x24f27598
+0,     351360,     351360,     1152,     2304, 0xd76f6d40
+0,     352512,     352512,     1152,     2304, 0x085071a7
+0,     353664,     353664,     1152,     2304, 0x1d11704c
+0,     354816,     354816,     1152,     2304, 0x21517cbd
+0,     355968,     355968,     1152,     2304, 0xcdca8d32
+0,     357120,     357120,     1152,     2304, 0x71c18433
+0,     358272,     358272,     1152,     2304, 0xd39d7d81
+0,     359424,     359424,     1152,     2304, 0x7a0d7a43
+0,     360576,     360576,     1152,     2304, 0x007c8884
+0,     361728,     361728,     1152,     2304, 0x403282d0
+0,     362880,     362880,     1152,     2304, 0xe3737214
+0,     364032,     364032,     1152,     2304, 0xaf906f47
+0,     365184,     365184,     1152,     2304, 0x54f57b3b
+0,     366336,     366336,     1152,     2304, 0x29be7791
+0,     367488,     367488,     1152,     2304, 0xe3c663d5
+0,     368640,     368640,     1152,     2304, 0xd7258238
+0,     369792,     369792,     1152,     2304, 0x3719820d
+0,     370944,     370944,     1152,     2304, 0xbe04814f
+0,     372096,     372096,     1152,     2304, 0x556c815e
+0,     373248,     373248,     1152,     2304, 0xb2447e10
+0,     374400,     374400,     1152,     2304, 0x7c16867c
+0,     375552,     375552,     1152,     2304, 0x6a7b78ed
+0,     376704,     376704,     1152,     2304, 0x5d307b81
+0,     377856,     377856,     1152,     2304, 0xaab680d3
+0,     379008,     379008,     1152,     2304, 0xb5d37a23
+0,     380160,     380160,     1152,     2304, 0x7f7d6f76
+0,     381312,     381312,     1152,     2304, 0x317a8296
+0,     382464,     382464,     1152,     2304, 0x8a987b3d
+0,     383616,     383616,     1152,     2304, 0x4f317a27
+0,     384768,     384768,     1152,     2304, 0xfc65852f
+0,     385920,     385920,     1152,     2304, 0x40527719
+0,     387072,     387072,     1152,     2304, 0x84988e13
+0,     388224,     388224,     1152,     2304, 0x318b6ddc
+0,     389376,     389376,     1152,     2304, 0x94cf7939
+0,     390528,     390528,     1152,     2304, 0x6f22819d
+0,     391680,     391680,     1152,     2304, 0xa7dd80a9
+0,     392832,     392832,     1152,     2304, 0x1c7968fa
+0,     393984,     393984,     1152,     2304, 0xd9937bae
+0,     395136,     395136,     1152,     2304, 0xf7137cf9
+0,     396288,     396288,     1152,     2304, 0xeadb84b5
+0,     397440,     397440,     1152,     2304, 0x9a2390ac
+0,     398592,     398592,     1152,     2304, 0xdb6a73f6
+0,     399744,     399744,     1152,     2304, 0x69e07507
+0,     400896,     400896,     1152,     2304, 0xbc8478b2
+0,     402048,     402048,     1152,     2304, 0x32cf8638
+0,     403200,     403200,     1152,     2304, 0x2b8d755a
+0,     404352,     404352,     1152,     2304, 0x52e05bd2
+0,     405504,     405504,     1152,     2304, 0x2aed8c49
+0,     406656,     406656,     1152,     2304, 0x587a896e
+0,     407808,     407808,     1152,     2304, 0x6dd87dee
+0,     408960,     408960,     1152,     2304, 0xd2858338
+0,     410112,     410112,     1152,     2304, 0xd90f7842
+0,     411264,     411264,     1152,     2304, 0xd6fb6d4a
+0,     412416,     412416,     1152,     2304, 0x85498aea
+0,     413568,     413568,     1152,     2304, 0x18597790
+0,     414720,     414720,     1152,     2304, 0x3cd78fea
+0,     415872,     415872,     1152,     2304, 0x94377fbc
+0,     417024,     417024,     1152,     2304, 0xf9db73f5
+0,     418176,     418176,     1152,     2304, 0x14fb6fca
+0,     419328,     419328,     1152,     2304, 0xe9d17d69
+0,     420480,     420480,     1152,     2304, 0xdeb57286
+0,     421632,     421632,     1152,     2304, 0xa5d37e17
+0,     422784,     422784,     1152,     2304, 0xcf6882fb
+0,     423936,     423936,     1152,     2304, 0x31758066
+0,     425088,     425088,     1152,     2304, 0x6b4d8175
+0,     426240,     426240,     1152,     2304, 0x2a3d7f8e
+0,     427392,     427392,     1152,     2304, 0xc066743b
+0,     428544,     428544,     1152,     2304, 0xcab88146
+0,     429696,     429696,     1152,     2304, 0x2b4c6e13
+0,     430848,     430848,     1152,     2304, 0x00b36b6f
+0,     432000,     432000,     1152,     2304, 0x664a88d3
+0,     433152,     433152,     1152,     2304, 0x18a66f76
+0,     434304,     434304,     1152,     2304, 0x4f828a8b
+0,     435456,     435456,     1152,     2304, 0x9cc7728e
+0,     436608,     436608,     1152,     2304, 0xbe357936
+0,     437760,     437760,     1152,     2304, 0x19878f8d
+0,     438912,     438912,     1152,     2304, 0x227b7c71
+0,     440064,     440064,     1152,     2304, 0xf7c879ec
+0,     441216,     441216,     1152,     2304, 0x0bca7b50
+0,     442368,     442368,     1152,     2304, 0xe4398304
+0,     443520,     443520,     1152,     2304, 0xf5da75c7
+0,     444672,     444672,     1152,     2304, 0x9f9070a3
+0,     445824,     445824,     1152,     2304, 0x789076f6
+0,     446976,     446976,     1152,     2304, 0x362977cc
+0,     448128,     448128,     1152,     2304, 0x4d0a8928
+0,     449280,     449280,     1152,     2304, 0x1bb767ec
+0,     450432,     450432,     1152,     2304, 0xbe727fa5
+0,     451584,     451584,     1152,     2304, 0x27f38347
+0,     452736,     452736,     1152,     2304, 0x0a3c8783
+0,     453888,     453888,     1152,     2304, 0x8249639c
+0,     455040,     455040,     1152,     2304, 0x3b076f69
+0,     456192,     456192,     1152,     2304, 0xd9597ee3
+0,     457344,     457344,     1152,     2304, 0x026e7fad
+0,     458496,     458496,     1152,     2304, 0xbd7a6de4
+0,     459648,     459648,     1152,     2304, 0x7d718a4d
+0,     460800,     460800,     1152,     2304, 0x1f5e83b4
+0,     461952,     461952,     1152,     2304, 0x597d7755
+0,     463104,     463104,     1152,     2304, 0x3fb080bd
+0,     464256,     464256,     1152,     2304, 0xdcbd7b16
+0,     465408,     465408,     1152,     2304, 0x5c48865f
+0,     466560,     466560,     1152,     2304, 0xcda37ae8
+0,     467712,     467712,     1152,     2304, 0x4810796d
+0,     468864,     468864,     1152,     2304, 0x34317fd0
+0,     470016,     470016,     1152,     2304, 0x5c0e7456
+0,     471168,     471168,     1152,     2304, 0x44d78040
+0,     472320,     472320,     1152,     2304, 0x88587882
+0,     473472,     473472,     1152,     2304, 0x77687d5e
+0,     474624,     474624,     1152,     2304, 0x116d68bb
+0,     475776,     475776,     1152,     2304, 0x3e5b6f60
+0,     476928,     476928,     1152,     2304, 0x64ea783c
+0,     478080,     478080,     1152,     2304, 0x23547f7d
+0,     479232,     479232,     1152,     2304, 0x2eee7892
+0,     480384,     480384,     1152,     2304, 0xfb837cba
+0,     481536,     481536,     1152,     2304, 0x86518209
+0,     482688,     482688,     1152,     2304, 0x672f7bba
+0,     483840,     483840,     1152,     2304, 0x6ab583fb
+0,     484992,     484992,     1152,     2304, 0xc1297428
+0,     486144,     486144,     1152,     2304, 0x164e7717
+0,     487296,     487296,     1152,     2304, 0xb754976d
+0,     488448,     488448,     1152,     2304, 0xb99d81b2
+0,     489600,     489600,     1152,     2304, 0x79046fd6
+0,     490752,     490752,     1152,     2304, 0x9a3f8426
+0,     491904,     491904,     1152,     2304, 0x896371f5
+0,     493056,     493056,     1152,     2304, 0x63d1799f
+0,     494208,     494208,     1152,     2304, 0x4842844e
+0,     495360,     495360,     1152,     2304, 0x850e8372
+0,     496512,     496512,     1152,     2304, 0x85d07022
+0,     497664,     497664,     1152,     2304, 0x9e6683d1
+0,     498816,     498816,     1152,     2304, 0x301b8981
+0,     499968,     499968,     1152,     2304, 0x1f1e98c5
+0,     501120,     501120,     1152,     2304, 0xc8797b03
+0,     502272,     502272,     1152,     2304, 0xf9d189f5
+0,     503424,     503424,     1152,     2304, 0x0e0d88be
+0,     504576,     504576,     1152,     2304, 0x6c1d7843
+0,     505728,     505728,     1152,     2304, 0xd13b8a38
+0,     506880,     506880,     1152,     2304, 0x9b8f773c
+0,     508032,     508032,     1152,     2304, 0x9acd7309
+0,     509184,     509184,     1152,     2304, 0x5e7d7d15
+0,     510336,     510336,     1152,     2304, 0xf09d7640
+0,     511488,     511488,     1152,     2304, 0xaebb718f
+0,     512640,     512640,     1152,     2304, 0x0c8570f4
+0,     513792,     513792,     1152,     2304, 0x3c93862c
+0,     514944,     514944,     1152,     2304, 0xcee46696
+0,     516096,     516096,     1152,     2304, 0x01ba7e20
+0,     517248,     517248,     1152,     2304, 0x7fcb7a09
+0,     518400,     518400,     1152,     2304, 0xddf18c14
+0,     519552,     519552,     1152,     2304, 0xd2e97eeb
+0,     520704,     520704,     1152,     2304, 0x514d8719
+0,     521856,     521856,     1152,     2304, 0xe89279c9
+0,     523008,     523008,     1152,     2304, 0x806d6a95
+0,     524160,     524160,     1152,     2304, 0xbc7a8a60
+0,     525312,     525312,     1152,     2304, 0x302f8fa8
+0,     526464,     526464,     1152,     2304, 0xb136784c
+0,     527616,     527616,     1152,     2304, 0x9b0f6aab
+0,     528768,     528768,     1152,     2304, 0xd8e27582
+0,     529920,     529920,     1152,     2304, 0xdaaf78b1
+0,     531072,     531072,     1152,     2304, 0x65967f5f
+0,     532224,     532224,     1152,     2304, 0x6f917aa4
+0,     533376,     533376,     1152,     2304, 0x7f607444
+0,     534528,     534528,     1152,     2304, 0xfd316f2c
+0,     535680,     535680,     1152,     2304, 0x776e83c7
+0,     536832,     536832,     1152,     2304, 0xb9c17e16
+0,     537984,     537984,     1152,     2304, 0xdf287de8
+0,     539136,     539136,     1152,     2304, 0xf33d96a3
+0,     540288,     540288,     1152,     2304, 0xad216e5b
+0,     541440,     541440,     1152,     2304, 0x4a328342
+0,     542592,     542592,     1152,     2304, 0xcf3f8079
+0,     543744,     543744,     1152,     2304, 0xb46f77b0
+0,     544896,     544896,     1152,     2304, 0x3199713d
+0,     546048,     546048,     1152,     2304, 0x5e667a0d
+0,     547200,     547200,     1152,     2304, 0xa3047ae3
+0,     548352,     548352,     1152,     2304, 0x9edf8594
+0,     549504,     549504,     1152,     2304, 0xd16382d5
+0,     550656,     550656,     1152,     2304, 0x6e838328
+0,     551808,     551808,     1152,     2304, 0xa1f697c1
+0,     552960,     552960,     1152,     2304, 0xefcc749c
+0,     554112,     554112,     1152,     2304, 0x1f94839e
+0,     555264,     555264,     1152,     2304, 0x429e7c5b
+0,     556416,     556416,     1152,     2304, 0x9b59711c
+0,     557568,     557568,     1152,     2304, 0xdac27323
+0,     558720,     558720,     1152,     2304, 0xa4856d2b
+0,     559872,     559872,     1152,     2304, 0x07a37498
+0,     561024,     561024,     1152,     2304, 0xe1ce7512
+0,     562176,     562176,     1152,     2304, 0x15e182c3
+0,     563328,     563328,     1152,     2304, 0x0fa46b8c
+0,     564480,     564480,     1152,     2304, 0xbdf07bfd
+0,     565632,     565632,     1152,     2304, 0xe0238b2a
+0,     566784,     566784,     1152,     2304, 0xab537267
+0,     567936,     567936,     1152,     2304, 0xd46b75f3
+0,     569088,     569088,     1152,     2304, 0xec73794b
+0,     570240,     570240,     1152,     2304, 0x680580c1
+0,     571392,     571392,     1152,     2304, 0x1ace8f6c
+0,     572544,     572544,     1152,     2304, 0x19d583ac
+0,     573696,     573696,     1152,     2304, 0x4b6b8105
+0,     574848,     574848,     1152,     2304, 0x392a78b2
+0,     576000,     576000,     1152,     2304, 0xd3916dad
+0,     577152,     577152,     1152,     2304, 0x569c7a75
+0,     578304,     578304,     1152,     2304, 0xf5ac814b
+0,     579456,     579456,     1152,     2304, 0x18d77e98
+0,     580608,     580608,     1152,     2304, 0x007074ce
+0,     581760,     581760,     1152,     2304, 0x0fe38373
+0,     582912,     582912,     1152,     2304, 0x5a967920
+0,     584064,     584064,     1152,     2304, 0x22167501
+0,     585216,     585216,     1152,     2304, 0xf0828cab
+0,     586368,     586368,     1152,     2304, 0xaeec71b7
+0,     587520,     587520,     1152,     2304, 0xc47b62ff
+0,     588672,     588672,     1152,     2304, 0xab688478
+0,     589824,     589824,     1152,     2304, 0xf35e7bd2
+0,     590976,     590976,     1152,     2304, 0x9cff763e
+0,     592128,     592128,     1152,     2304, 0x59568dc8
+0,     593280,     593280,     1152,     2304, 0x51a278ac
+0,     594432,     594432,     1152,     2304, 0xc08a6e68
+0,     595584,     595584,     1152,     2304, 0xd3067ef4
+0,     596736,     596736,     1152,     2304, 0x54767c49
+0,     597888,     597888,     1152,     2304, 0xf8ff8386
+0,     599040,     599040,     1152,     2304, 0xef267f63
+0,     600192,     600192,     1152,     2304, 0xe2537cd9
+0,     601344,     601344,     1152,     2304, 0x77a57680
+0,     602496,     602496,     1152,     2304, 0x325c74ad
+0,     603648,     603648,     1152,     2304, 0xd7fe87c4
+0,     604800,     604800,     1152,     2304, 0x2e756310
+0,     605952,     605952,     1152,     2304, 0x6a81796b
+0,     607104,     607104,     1152,     2304, 0x2f057daf
+0,     608256,     608256,     1152,     2304, 0xcd9f7c9d
+0,     609408,     609408,     1152,     2304, 0xc91560a0
+0,     610560,     610560,     1152,     2304, 0x962a91eb
+0,     611712,     611712,     1152,     2304, 0xa0ff7416
+0,     612864,     612864,     1152,     2304, 0xcb5c7dff
+0,     614016,     614016,     1152,     2304, 0xd3527041
+0,     615168,     615168,     1152,     2304, 0xc89d77c2
+0,     616320,     616320,     1152,     2304, 0xe1ce7ccf
+0,     617472,     617472,     1152,     2304, 0xe3417c4c
+0,     618624,     618624,     1152,     2304, 0x3f1a7166
+0,     619776,     619776,     1152,     2304, 0xcdcc7e23
+0,     620928,     620928,     1152,     2304, 0x4e727e97
+0,     622080,     622080,     1152,     2304, 0x53427ff1
+0,     623232,     623232,     1152,     2304, 0x173f6ca9
+0,     624384,     624384,     1152,     2304, 0x962887ec
+0,     625536,     625536,     1152,     2304, 0xcbec67f4
+0,     626688,     626688,     1152,     2304, 0x7a2c943d
+0,     627840,     627840,     1152,     2304, 0x8b877570
+0,     628992,     628992,     1152,     2304, 0xcf337323
+0,     630144,     630144,     1152,     2304, 0x8c8682a4
+0,     631296,     631296,     1152,     2304, 0x94c3753c
+0,     632448,     632448,     1152,     2304, 0x86898d79
+0,     633600,     633600,     1152,     2304, 0xdf667312
+0,     634752,     634752,     1152,     2304, 0x062f8ba8
+0,     635904,     635904,     1152,     2304, 0xa2c36f08
+0,     637056,     637056,     1152,     2304, 0x5bca7358
+0,     638208,     638208,     1152,     2304, 0x5648804d
+0,     639360,     639360,     1152,     2304, 0xefac87c8
+0,     640512,     640512,     1152,     2304, 0x66bf7dcf
+0,     641664,     641664,     1152,     2304, 0x62ad73bc
+0,     642816,     642816,     1152,     2304, 0x72fe630c
+0,     643968,     643968,     1152,     2304, 0xeebe87da
+0,     645120,     645120,     1152,     2304, 0x11c870cf
+0,     646272,     646272,     1152,     2304, 0x18fb7c27
+0,     647424,     647424,     1152,     2304, 0x39047145
+0,     648576,     648576,     1152,     2304, 0xdcf07032
+0,     649728,     649728,     1152,     2304, 0x61027c50
+0,     650880,     650880,     1152,     2304, 0x6e2e89de
+0,     652032,     652032,     1152,     2304, 0xc50c6d1d
+0,     653184,     653184,     1152,     2304, 0xeed587ee
+0,     654336,     654336,     1152,     2304, 0xe38269c7
+0,     655488,     655488,     1152,     2304, 0xcf66806e
+0,     656640,     656640,     1152,     2304, 0x2d3b7c1b
+0,     657792,     657792,     1152,     2304, 0xa4127d48
+0,     658944,     658944,     1152,     2304, 0x480b8325
+0,     660096,     660096,     1152,     2304, 0xc1527221
+0,     661248,     661248,     1152,     2304, 0x94c1769a
+0,     662400,     662400,     1152,     2304, 0xcfb37271
+0,     663552,     663552,     1152,     2304, 0x946d7a96
+0,     664704,     664704,     1152,     2304, 0xdfc18e50
+0,     665856,     665856,     1152,     2304, 0x10c48393
+0,     667008,     667008,     1152,     2304, 0x58556b10
+0,     668160,     668160,     1152,     2304, 0x997b7993
+0,     669312,     669312,     1152,     2304, 0x4a787992
+0,     670464,     670464,     1152,     2304, 0x11406c20
+0,     671616,     671616,     1152,     2304, 0x04a4874a
+0,     672768,     672768,     1152,     2304, 0xf3077164
+0,     673920,     673920,     1152,     2304, 0x08ac80e3
+0,     675072,     675072,     1152,     2304, 0x268370d0
+0,     676224,     676224,     1152,     2304, 0x1d137778
+0,     677376,     677376,     1152,     2304, 0xfa148e97
+0,     678528,     678528,     1152,     2304, 0xec50717c
+0,     679680,     679680,     1152,     2304, 0xcbf46b75
+0,     680832,     680832,     1152,     2304, 0xd4168038
+0,     681984,     681984,     1152,     2304, 0xdd9577f0
+0,     683136,     683136,     1152,     2304, 0xc7077685
+0,     684288,     684288,     1152,     2304, 0x34d25e91
+0,     685440,     685440,     1152,     2304, 0x96537e6d
+0,     686592,     686592,     1152,     2304, 0xb12e7940
+0,     687744,     687744,     1152,     2304, 0x861d64c0
+0,     688896,     688896,     1152,     2304, 0xa2bc64ed
+0,     690048,     690048,     1152,     2304, 0x0c5f8261
+0,     691200,     691200,     1152,     2304, 0x540584ff
+0,     692352,     692352,     1152,     2304, 0xe8328b09
+0,     693504,     693504,     1152,     2304, 0x1e777079
+0,     694656,     694656,     1152,     2304, 0x453483b4
+0,     695808,     695808,     1152,     2304, 0x1cab7a1e
+0,     696960,     696960,     1152,     2304, 0xcb37856d
+0,     698112,     698112,     1152,     2304, 0x5a4883ed
+0,     699264,     699264,     1152,     2304, 0xd1f27cbf
+0,     700416,     700416,     1152,     2304, 0x0d377a4d
+0,     701568,     701568,     1152,     2304, 0x264e76df
+0,     702720,     702720,     1152,     2304, 0x2a68771e
+0,     703872,     703872,     1152,     2304, 0xcb317a31
+0,     705024,     705024,     1152,     2304, 0xfc5d7a27
+0,     706176,     706176,     1152,     2304, 0x6e067d96
+0,     707328,     707328,     1152,     2304, 0x0c538560
+0,     708480,     708480,     1152,     2304, 0xfbad717a
+0,     709632,     709632,     1152,     2304, 0xf9fc7608
+0,     710784,     710784,     1152,     2304, 0xb1817c8f
+0,     711936,     711936,     1152,     2304, 0x57c37f82
+0,     713088,     713088,     1152,     2304, 0x8cac8356
+0,     714240,     714240,     1152,     2304, 0x97108186
+0,     715392,     715392,     1152,     2304, 0x095d81bb
+0,     716544,     716544,     1152,     2304, 0x475f6b2b
+0,     717696,     717696,     1152,     2304, 0xdf7c8cc5
+0,     718848,     718848,     1152,     2304, 0x979c77be
+0,     720000,     720000,     1152,     2304, 0x56a7844b
+0,     721152,     721152,     1152,     2304, 0x7ee46b21
+0,     722304,     722304,     1152,     2304, 0x05b67220
+0,     723456,     723456,     1152,     2304, 0x25787252
+0,     724608,     724608,     1152,     2304, 0x8ad278ad
+0,     725760,     725760,     1152,     2304, 0x67bd722e
+0,     726912,     726912,     1152,     2304, 0x204f77be
+0,     728064,     728064,     1152,     2304, 0x82d27ae2
+0,     729216,     729216,     1152,     2304, 0x23fa82e4
+0,     730368,     730368,     1152,     2304, 0xa9cf8159
+0,     731520,     731520,     1152,     2304, 0x13f08749
+0,     732672,     732672,     1152,     2304, 0xf84f71b5
+0,     733824,     733824,     1152,     2304, 0x1cb777c8
+0,     734976,     734976,     1152,     2304, 0x11236722
+0,     736128,     736128,     1152,     2304, 0x10197cac
+0,     737280,     737280,     1152,     2304, 0xbd417e65
+0,     738432,     738432,     1152,     2304, 0x9a1c7d05
+0,     739584,     739584,     1152,     2304, 0x4c3a85de
+0,     740736,     740736,     1152,     2304, 0x03816eb7
+0,     741888,     741888,     1152,     2304, 0x80186e6c
+0,     743040,     743040,     1152,     2304, 0x5c097928
+0,     744192,     744192,     1152,     2304, 0x94aa823d
+0,     745344,     745344,     1152,     2304, 0xa1c27f04
+0,     746496,     746496,     1152,     2304, 0x6ddb74a9
+0,     747648,     747648,     1152,     2304, 0x5ea67901
+0,     748800,     748800,     1152,     2304, 0xd710742d
+0,     749952,     749952,     1152,     2304, 0xf8c27add
+0,     751104,     751104,     1152,     2304, 0xf1717011
+0,     752256,     752256,     1152,     2304, 0xb59072d0
+0,     753408,     753408,     1152,     2304, 0xc8dc84a7
+0,     754560,     754560,     1152,     2304, 0x33116737
+0,     755712,     755712,     1152,     2304, 0x86216bdd
+0,     756864,     756864,     1152,     2304, 0xa2f87866
+0,     758016,     758016,     1152,     2304, 0x5d77771e
+0,     759168,     759168,     1152,     2304, 0x5d8c77fd
+0,     760320,     760320,     1152,     2304, 0x23cc89cb
+0,     761472,     761472,     1152,     2304, 0x334e7407
+0,     762624,     762624,     1152,     2304, 0x01c976ff
+0,     763776,     763776,     1152,     2304, 0x3a3b7b15
+0,     764928,     764928,     1152,     2304, 0xfa427de9
+0,     766080,     766080,     1152,     2304, 0xbeaa7c91
+0,     767232,     767232,     1152,     2304, 0xd6988b31
+0,     768384,     768384,     1152,     2304, 0x4db47f80
+0,     769536,     769536,     1152,     2304, 0xea687d9e
+0,     770688,     770688,     1152,     2304, 0x1a6281ce
+0,     771840,     771840,     1152,     2304, 0xe1958003
+0,     772992,     772992,     1152,     2304, 0xb4ae7c5e
+0,     774144,     774144,     1152,     2304, 0x28827c8a
+0,     775296,     775296,     1152,     2304, 0x1fb88b25
+0,     776448,     776448,     1152,     2304, 0x588d71e8
+0,     777600,     777600,     1152,     2304, 0x68227c34
+0,     778752,     778752,     1152,     2304, 0xee4d73e8
+0,     779904,     779904,     1152,     2304, 0x69287c6d
+0,     781056,     781056,     1152,     2304, 0xbb04926a
+0,     782208,     782208,     1152,     2304, 0x89456cec
+0,     783360,     783360,     1152,     2304, 0xabe18992
+0,     784512,     784512,     1152,     2304, 0x50cc7f6c
+0,     785664,     785664,     1152,     2304, 0x6d7270be
+0,     786816,     786816,     1152,     2304, 0x664c6fef
+0,     787968,     787968,     1152,     2304, 0x7f7982f3
+0,     789120,     789120,     1152,     2304, 0x6ca170e9
+0,     790272,     790272,     1152,     2304, 0x36437d5b
+0,     791424,     791424,     1152,     2304, 0xfd2380e8
+0,     792576,     792576,     1152,     2304, 0x2e3c6e9f
+0,     793728,     793728,     1152,     2304, 0xc8427f3f
+0,     794880,     794880,     1152,     2304, 0x962a79ad
+0,     796032,     796032,     1152,     2304, 0xc9597c8b
+0,     797184,     797184,     1152,     2304, 0x899580bb
+0,     798336,     798336,     1152,     2304, 0x2d179dff
+0,     799488,     799488,     1152,     2304, 0x4ac1707c
+0,     800640,     800640,     1152,     2304, 0x32ea7e95
+0,     801792,     801792,     1152,     2304, 0x265e9a2d
+0,     802944,     802944,     1152,     2304, 0x1c6484d0
+0,     804096,     804096,     1152,     2304, 0x39ae6884
+0,     805248,     805248,     1152,     2304, 0x82ed7bc5
+0,     806400,     806400,     1152,     2304, 0x556b7b3c
+0,     807552,     807552,     1152,     2304, 0xb7f778dd
+0,     808704,     808704,     1152,     2304, 0x74447d55
+0,     809856,     809856,     1152,     2304, 0x0c66861e
+0,     811008,     811008,     1152,     2304, 0x15ba7932
+0,     812160,     812160,     1152,     2304, 0xb19170fc
+0,     813312,     813312,     1152,     2304, 0x19d37551
+0,     814464,     814464,     1152,     2304, 0xdc529142
+0,     815616,     815616,     1152,     2304, 0xf2637e77
+0,     816768,     816768,     1152,     2304, 0xd065944b
+0,     817920,     817920,     1152,     2304, 0x22878123
+0,     819072,     819072,     1152,     2304, 0xc21a8bf7
+0,     820224,     820224,     1152,     2304, 0x2e3582dc
+0,     821376,     821376,     1152,     2304, 0xd42f7987
+0,     822528,     822528,     1152,     2304, 0x69b88236
+0,     823680,     823680,     1152,     2304, 0x7c988f90
+0,     824832,     824832,     1152,     2304, 0x2cd66ded
+0,     825984,     825984,     1152,     2304, 0x3e65828b
+0,     827136,     827136,     1152,     2304, 0x7e9871c9
+0,     828288,     828288,     1152,     2304, 0xf1f2806b
+0,     829440,     829440,     1152,     2304, 0xf5087c7b
+0,     830592,     830592,     1152,     2304, 0x62b98097
+0,     831744,     831744,     1152,     2304, 0xec457c43
+0,     832896,     832896,     1152,     2304, 0x87af87a6
+0,     834048,     834048,     1152,     2304, 0x97cc757d
+0,     835200,     835200,     1152,     2304, 0x08ca76bd
+0,     836352,     836352,     1152,     2304, 0x14ae7cbd
+0,     837504,     837504,     1152,     2304, 0x1f79709a
+0,     838656,     838656,     1152,     2304, 0x17948207
+0,     839808,     839808,     1152,     2304, 0x16ee7228
+0,     840960,     840960,     1152,     2304, 0x76cc82d7
+0,     842112,     842112,     1152,     2304, 0x8f327a8e
+0,     843264,     843264,     1152,     2304, 0x14ee7756
+0,     844416,     844416,     1152,     2304, 0x15996d2f
+0,     845568,     845568,     1152,     2304, 0x4c707d5c
+0,     846720,     846720,     1152,     2304, 0x268c6fee
+0,     847872,     847872,     1152,     2304, 0x6d838c76
+0,     849024,     849024,     1152,     2304, 0xafa17e64
+0,     850176,     850176,     1152,     2304, 0xb6546e66
+0,     851328,     851328,     1152,     2304, 0x945d8b9f
+0,     852480,     852480,     1152,     2304, 0x5bfb7446
+0,     853632,     853632,     1152,     2304, 0xae6086f9
+0,     854784,     854784,     1152,     2304, 0xa01380cd
+0,     855936,     855936,     1152,     2304, 0x06f0828f
+0,     857088,     857088,     1152,     2304, 0x0ae07176
+0,     858240,     858240,     1152,     2304, 0x66f07522
+0,     859392,     859392,     1152,     2304, 0x44018106
+0,     860544,     860544,     1152,     2304, 0x8cd283da
+0,     861696,     861696,     1152,     2304, 0x14257f45
+0,     862848,     862848,     1152,     2304, 0x04979537
+0,     864000,     864000,     1152,     2304, 0x8b5f797c
+0,     865152,     865152,     1152,     2304, 0x12d67493
+0,     866304,     866304,     1152,     2304, 0xc8886a25
+0,     867456,     867456,     1152,     2304, 0x614b803a
+0,     868608,     868608,     1152,     2304, 0x75667d35
+0,     869760,     869760,     1152,     2304, 0xe42c7b00
+0,     870912,     870912,     1152,     2304, 0x37787927
+0,     872064,     872064,     1152,     2304, 0x85db8409
+0,     873216,     873216,     1152,     2304, 0x823b822c
+0,     874368,     874368,     1152,     2304, 0xa1658479
+0,     875520,     875520,     1152,     2304, 0xdbe58ff7
+0,     876672,     876672,     1152,     2304, 0x725175e2
+0,     877824,     877824,     1152,     2304, 0xb2ae7741
+0,     878976,     878976,     1152,     2304, 0x4de169e4
+0,     880128,     880128,     1152,     2304, 0x3cb18530
+0,     881280,     881280,     1152,     2304, 0x5a0c5e7b
+0,     882432,     882432,     1152,     2304, 0x4e1f68b6
+0,     883584,     883584,     1152,     2304, 0x9a0c7525
+0,     884736,     884736,     1152,     2304, 0x86ae6a04
+0,     885888,     885888,     1152,     2304, 0xf508877c
+0,     887040,     887040,     1152,     2304, 0x29746d7c
+0,     888192,     888192,     1152,     2304, 0x24078edb
+0,     889344,     889344,     1152,     2304, 0x4f9784d2
+0,     890496,     890496,     1152,     2304, 0x24186e95
+0,     891648,     891648,     1152,     2304, 0xd1927b28
+0,     892800,     892800,     1152,     2304, 0xc77283d5
+0,     893952,     893952,     1152,     2304, 0xc0ad73f8
+0,     895104,     895104,     1152,     2304, 0x0de78524
+0,     896256,     896256,     1152,     2304, 0x8b0061dc
+0,     897408,     897408,     1152,     2304, 0x37c77ad6
+0,     898560,     898560,     1152,     2304, 0x5eae7410
+0,     899712,     899712,     1152,     2304, 0x72d97ab5
+0,     900864,     900864,     1152,     2304, 0x1afd8745
+0,     902016,     902016,     1152,     2304, 0xe30b7c9b
+0,     903168,     903168,     1152,     2304, 0xe86480b3
+0,     904320,     904320,     1152,     2304, 0xb9c77a4e
+0,     905472,     905472,     1152,     2304, 0x64508f2a
+0,     906624,     906624,     1152,     2304, 0x839a74ed
+0,     907776,     907776,     1152,     2304, 0x12147a5d
+0,     908928,     908928,     1152,     2304, 0x33b07d3b
+0,     910080,     910080,     1152,     2304, 0x65e67731
+0,     911232,     911232,     1152,     2304, 0x8d1c8191
+0,     912384,     912384,     1152,     2304, 0xada17701
+0,     913536,     913536,     1152,     2304, 0x49d47f6c
+0,     914688,     914688,     1152,     2304, 0x5df97989
+0,     915840,     915840,     1152,     2304, 0x0db17ad9
+0,     916992,     916992,     1152,     2304, 0x0d3281d7
+0,     918144,     918144,     1152,     2304, 0x2503704f
+0,     919296,     919296,     1152,     2304, 0xdf7c73d0
+0,     920448,     920448,     1152,     2304, 0x93dd737c
+0,     921600,     921600,     1152,     2304, 0x48ed5740
+0,     922752,     922752,     1152,     2304, 0x6d477eaf
+0,     923904,     923904,     1152,     2304, 0xe72373a1
+0,     925056,     925056,     1152,     2304, 0x7d3e7e2e
+0,     926208,     926208,     1152,     2304, 0x0d167743
+0,     927360,     927360,     1152,     2304, 0xc2d97f6c
+0,     928512,     928512,     1152,     2304, 0xc66175a0
+0,     929664,     929664,     1152,     2304, 0xd0127475
+0,     930816,     930816,     1152,     2304, 0xdbf57801
+0,     931968,     931968,     1152,     2304, 0x52b47a8e
+0,     933120,     933120,     1152,     2304, 0xc96b80c5
+0,     934272,     934272,     1152,     2304, 0x070c76cf
+0,     935424,     935424,     1152,     2304, 0x2aa07ee2
+0,     936576,     936576,     1152,     2304, 0x04059074
+0,     937728,     937728,     1152,     2304, 0x228f6def
+0,     938880,     938880,     1152,     2304, 0x927893a8
+0,     940032,     940032,     1152,     2304, 0x581a87df
+0,     941184,     941184,     1152,     2304, 0x0d3f653c
+0,     942336,     942336,     1152,     2304, 0xc0e775f3
+0,     943488,     943488,     1152,     2304, 0x41d98473
+0,     944640,     944640,     1152,     2304, 0x68fb775a
+0,     945792,     945792,     1152,     2304, 0x81e0810e
+0,     946944,     946944,     1152,     2304, 0xf35790d3
+0,     948096,     948096,     1152,     2304, 0xc1468c45
+0,     949248,     949248,     1152,     2304, 0x6949796a
+0,     950400,     950400,     1152,     2304, 0xa0bb7dcd
+0,     951552,     951552,     1152,     2304, 0x50af8424
+0,     952704,     952704,     1152,     2304, 0x449b7d37
+0,     953856,     953856,     1152,     2304, 0xcf2779a8
+0,     955008,     955008,     1152,     2304, 0x069d894e
+0,     956160,     956160,     1152,     2304, 0x41bd7334
+0,     957312,     957312,     1152,     2304, 0x0dfd8c05
+0,     958464,     958464,     1152,     2304, 0x2ce27b9d
+0,     959616,     959616,     1152,     2304, 0x422875b5
+0,     960768,     960768,     1152,     2304, 0xd5297389
+0,     961920,     961920,     1152,     2304, 0x49ed8668
+0,     963072,     963072,     1152,     2304, 0x2a9a810b
+0,     964224,     964224,     1152,     2304, 0x5a3f7b43
+0,     965376,     965376,     1152,     2304, 0x32087c12
+0,     966528,     966528,     1152,     2304, 0x759c7bba
+0,     967680,     967680,     1152,     2304, 0x5b26823b
+0,     968832,     968832,     1152,     2304, 0xeeb872ef
+0,     969984,     969984,     1152,     2304, 0x6eb0869d
+0,     971136,     971136,     1152,     2304, 0x4b3e764f
+0,     972288,     972288,     1152,     2304, 0x30a66fdb
+0,     973440,     973440,     1152,     2304, 0x958374ff
+0,     974592,     974592,     1152,     2304, 0x411b71cc
+0,     975744,     975744,     1152,     2304, 0x80136759
+0,     976896,     976896,     1152,     2304, 0x05ed6793
+0,     978048,     978048,     1152,     2304, 0x48f18827
+0,     979200,     979200,     1152,     2304, 0xb40d7866
+0,     980352,     980352,     1152,     2304, 0xcad18c4a
+0,     981504,     981504,     1152,     2304, 0x9ad68582
+0,     982656,     982656,     1152,     2304, 0x3ad17fce
+0,     983808,     983808,     1152,     2304, 0x824b7af6
+0,     984960,     984960,     1152,     2304, 0xcc9d894f
+0,     986112,     986112,     1152,     2304, 0x46167a70
+0,     987264,     987264,     1152,     2304, 0x2479872a
+0,     988416,     988416,     1152,     2304, 0x58cb72a5
+0,     989568,     989568,     1152,     2304, 0x01957747
+0,     990720,     990720,     1152,     2304, 0x6df172cb
+0,     991872,     991872,     1152,     2304, 0x9ebd7ed9
+0,     993024,     993024,     1152,     2304, 0x89436a53
+0,     994176,     994176,     1152,     2304, 0xcce78433
+0,     995328,     995328,     1152,     2304, 0x1b7a70f2
+0,     996480,     996480,     1152,     2304, 0x530584d7
+0,     997632,     997632,     1152,     2304, 0xda158aa9
+0,     998784,     998784,     1152,     2304, 0xe85e7b90
+0,     999936,     999936,     1152,     2304, 0xa8ac8176
+0,    1001088,    1001088,     1152,     2304, 0xe43578a9
+0,    1002240,    1002240,     1152,     2304, 0x9ecc7c30
+0,    1003392,    1003392,     1152,     2304, 0x1cbd8591
+0,    1004544,    1004544,     1152,     2304, 0x84917bd9
+0,    1005696,    1005696,     1152,     2304, 0xea8477e4
+0,    1006848,    1006848,     1152,     2304, 0xf50c7ea1
+0,    1008000,    1008000,     1152,     2304, 0xc85e76e7
+0,    1009152,    1009152,     1152,     2304, 0xa5148768
+0,    1010304,    1010304,     1152,     2304, 0x2bd5846a
+0,    1011456,    1011456,     1152,     2304, 0x1cd88641
+0,    1012608,    1012608,     1152,     2304, 0x04b883c5
+0,    1013760,    1013760,     1152,     2304, 0x5bf1719b
+0,    1014912,    1014912,     1152,     2304, 0x0abe777c
+0,    1016064,    1016064,     1152,     2304, 0xc74a7f7f
+0,    1017216,    1017216,     1152,     2304, 0xd36a724b
+0,    1018368,    1018368,     1152,     2304, 0x4ae67e9e
+0,    1019520,    1019520,     1152,     2304, 0xfb6173a0
+0,    1020672,    1020672,     1152,     2304, 0x31d77e19
+0,    1021824,    1021824,     1152,     2304, 0x6153767d
+0,    1022976,    1022976,     1152,     2304, 0xe40d84e4
+0,    1024128,    1024128,     1152,     2304, 0xc8ef71e2
+0,    1025280,    1025280,     1152,     2304, 0xdeca81be
+0,    1026432,    1026432,     1152,     2304, 0x75da85df
+0,    1027584,    1027584,     1152,     2304, 0x6c8e71bd
+0,    1028736,    1028736,     1152,     2304, 0x6f8576a4
+0,    1029888,    1029888,     1152,     2304, 0xe6637b71
+0,    1031040,    1031040,     1152,     2304, 0xddfe8866
+0,    1032192,    1032192,     1152,     2304, 0xa08578a5
+0,    1033344,    1033344,     1152,     2304, 0x72af7873
+0,    1034496,    1034496,     1152,     2304, 0xb550615c
+0,    1035648,    1035648,     1152,     2304, 0x9ef87d28
+0,    1036800,    1036800,     1152,     2304, 0xe30d83bf
+0,    1037952,    1037952,     1152,     2304, 0xf030818c
+0,    1039104,    1039104,     1152,     2304, 0x1e23896c
+0,    1040256,    1040256,     1152,     2304, 0xf4c87180
+0,    1041408,    1041408,     1152,     2304, 0xe34181aa
+0,    1042560,    1042560,     1152,     2304, 0x660681cb
+0,    1043712,    1043712,     1152,     2304, 0x7ebb87fc
+0,    1044864,    1044864,     1152,     2304, 0xa8305eeb
+0,    1046016,    1046016,     1152,     2304, 0xea898906
+0,    1047168,    1047168,     1152,     2304, 0x342b6c13
+0,    1048320,    1048320,     1152,     2304, 0x7fd18372
+0,    1049472,    1049472,     1152,     2304, 0x965c7377
+0,    1050624,    1050624,     1152,     2304, 0xb53b70b3
+0,    1051776,    1051776,     1152,     2304, 0xd54884d1
+0,    1052928,    1052928,     1152,     2304, 0x546d77ac
+0,    1054080,    1054080,     1152,     2304, 0xd7a77dc7
+0,    1055232,    1055232,     1152,     2304, 0x4b0e7c5c
+0,    1056384,    1056384,     1152,     2304, 0x346d7026
+0,    1057536,    1057536,     1152,     2304, 0x3f346e81
+0,    1058688,    1058688,     1152,     2304, 0x3f167098
+0,    1059840,    1059840,     1152,     2304, 0x1c857987
+0,    1060992,    1060992,     1152,     2304, 0xf9317c16
+0,    1062144,    1062144,     1152,     2304, 0x25ea82c4
+0,    1063296,    1063296,     1152,     2304, 0x2b0f90bb
+0,    1064448,    1064448,     1152,     2304, 0x999668db
+0,    1065600,    1065600,     1152,     2304, 0x9a0676da
+0,    1066752,    1066752,     1152,     2304, 0x97a87172
+0,    1067904,    1067904,     1152,     2304, 0x323d7ace
+0,    1069056,    1069056,     1152,     2304, 0x1b538baa
+0,    1070208,    1070208,     1152,     2304, 0xeb208b72
+0,    1071360,    1071360,     1152,     2304, 0x36c69152
+0,    1072512,    1072512,     1152,     2304, 0x570c7bac
+0,    1073664,    1073664,     1152,     2304, 0xd7287c72
+0,    1074816,    1074816,     1152,     2304, 0xc4d78776
+0,    1075968,    1075968,     1152,     2304, 0xdcbb7735
+0,    1077120,    1077120,     1152,     2304, 0x08066d78
+0,    1078272,    1078272,     1152,     2304, 0x5cb96bad
+0,    1079424,    1079424,     1152,     2304, 0x30d58180
+0,    1080576,    1080576,     1152,     2304, 0x3ac96b87
+0,    1081728,    1081728,     1152,     2304, 0x1fc878d2
+0,    1082880,    1082880,     1152,     2304, 0x2c7c85d4
+0,    1084032,    1084032,     1152,     2304, 0x6c307caa
+0,    1085184,    1085184,     1152,     2304, 0x647b6d6e
+0,    1086336,    1086336,     1152,     2304, 0xfbef7e51
+0,    1087488,    1087488,     1152,     2304, 0x27867bd7
+0,    1088640,    1088640,     1152,     2304, 0xa2b875b1
+0,    1089792,    1089792,     1152,     2304, 0xc7dd73fb
+0,    1090944,    1090944,     1152,     2304, 0x717e79e9
+0,    1092096,    1092096,     1152,     2304, 0xfecb710d
+0,    1093248,    1093248,     1152,     2304, 0xa5308333
+0,    1094400,    1094400,     1152,     2304, 0x92fe6b77
+0,    1095552,    1095552,     1152,     2304, 0x7db17ad6
+0,    1096704,    1096704,     1152,     2304, 0x1248786d
+0,    1097856,    1097856,     1152,     2304, 0xf3647a8a
+0,    1099008,    1099008,     1152,     2304, 0x7b2173f0
+0,    1100160,    1100160,     1152,     2304, 0xfd1f7a3c
+0,    1101312,    1101312,     1152,     2304, 0x09e57f3e
+0,    1102464,    1102464,     1152,     2304, 0x13d7798d
+0,    1103616,    1103616,     1152,     2304, 0x7d4d758a
+0,    1104768,    1104768,     1152,     2304, 0xdf1a80be
+0,    1105920,    1105920,     1152,     2304, 0xb91b7cb9
+0,    1107072,    1107072,     1152,     2304, 0x102e73ba
+0,    1108224,    1108224,     1152,     2304, 0x8dce8428
+0,    1109376,    1109376,     1152,     2304, 0xdf9070f6
+0,    1110528,    1110528,     1152,     2304, 0x27d77bb4
+0,    1111680,    1111680,     1152,     2304, 0x2f8a8579
+0,    1112832,    1112832,     1152,     2304, 0xd1e27204
+0,    1113984,    1113984,     1152,     2304, 0x4f087920
+0,    1115136,    1115136,     1152,     2304, 0x69f58306
+0,    1116288,    1116288,     1152,     2304, 0xfc7378b0
+0,    1117440,    1117440,     1152,     2304, 0x8b167d89
+0,    1118592,    1118592,     1152,     2304, 0x0c867235
+0,    1119744,    1119744,     1152,     2304, 0xc3126e09
+0,    1120896,    1120896,     1152,     2304, 0x7d097d89
+0,    1122048,    1122048,     1152,     2304, 0x73dc664e
+0,    1123200,    1123200,     1152,     2304, 0xdc247a0a
+0,    1124352,    1124352,     1152,     2304, 0xaa8d7f2f
+0,    1125504,    1125504,     1152,     2304, 0x9a1d744b
+0,    1126656,    1126656,     1152,     2304, 0xd9e87475
+0,    1127808,    1127808,     1152,     2304, 0xf6f182ab
+0,    1128960,    1128960,     1152,     2304, 0x4937706b
+0,    1130112,    1130112,     1152,     2304, 0x837189b1
+0,    1131264,    1131264,     1152,     2304, 0xd565975d
+0,    1132416,    1132416,     1152,     2304, 0xc6156a56
+0,    1133568,    1133568,     1152,     2304, 0xcd9c8107
+0,    1134720,    1134720,     1152,     2304, 0x1f868400
+0,    1135872,    1135872,     1152,     2304, 0xeddb71e0
+0,    1137024,    1137024,     1152,     2304, 0x5fa2782a
+0,    1138176,    1138176,     1152,     2304, 0x9b076e22
+0,    1139328,    1139328,     1152,     2304, 0x90027ba7
+0,    1140480,    1140480,     1152,     2304, 0x40a481fd
+0,    1141632,    1141632,     1152,     2304, 0x240873bf
+0,    1142784,    1142784,     1152,     2304, 0x28cd7d8e
+0,    1143936,    1143936,     1152,     2304, 0x5d4287b0
+0,    1145088,    1145088,     1152,     2304, 0xf9567c4b
+0,    1146240,    1146240,     1152,     2304, 0x67dd924a
+0,    1147392,    1147392,     1152,     2304, 0x33d37b4c
+0,    1148544,    1148544,     1152,     2304, 0x37316d0b
+0,    1149696,    1149696,     1152,     2304, 0x43a877dc
+0,    1150848,    1150848,     1152,     2304, 0x44fc90bc
+0,    1152000,    1152000,     1152,     2304, 0x90f5774c
+0,    1153152,    1153152,     1152,     2304, 0x106e85a0
+0,    1154304,    1154304,     1152,     2304, 0xb78b7f83
+0,    1155456,    1155456,     1152,     2304, 0x3c3a77af
+0,    1156608,    1156608,     1152,     2304, 0x7a5f7282
+0,    1157760,    1157760,     1152,     2304, 0x164d891a
+0,    1158912,    1158912,     1152,     2304, 0x930a7194
+0,    1160064,    1160064,     1152,     2304, 0xb2628013
+0,    1161216,    1161216,     1152,     2304, 0x3adf7e1c
+0,    1162368,    1162368,     1152,     2304, 0x48627c45
+0,    1163520,    1163520,     1152,     2304, 0xa3367cca
+0,    1164672,    1164672,     1152,     2304, 0x9cf77248
+0,    1165824,    1165824,     1152,     2304, 0x75a86acb
+0,    1166976,    1166976,     1152,     2304, 0x75487698
+0,    1168128,    1168128,     1152,     2304, 0xd65b8389
+0,    1169280,    1169280,     1152,     2304, 0xb71d84b5
+0,    1170432,    1170432,     1152,     2304, 0xdca87e42
+0,    1171584,    1171584,     1152,     2304, 0x44dd7d72
+0,    1172736,    1172736,     1152,     2304, 0xb29465da
+0,    1173888,    1173888,     1152,     2304, 0x88ed8930
+0,    1175040,    1175040,     1152,     2304, 0xabdd8096
+0,    1176192,    1176192,     1152,     2304, 0xe5f57653
+0,    1177344,    1177344,     1152,     2304, 0x7c777984
+0,    1178496,    1178496,     1152,     2304, 0x631d7deb
+0,    1179648,    1179648,     1152,     2304, 0x70d36e1f
+0,    1180800,    1180800,     1152,     2304, 0x412c802b
+0,    1181952,    1181952,     1152,     2304, 0xacc281c1
+0,    1183104,    1183104,     1152,     2304, 0x569d86a8
+0,    1184256,    1184256,     1152,     2304, 0x5c69743f
+0,    1185408,    1185408,     1152,     2304, 0x29637794
+0,    1186560,    1186560,     1152,     2304, 0x0d1b7a4f
+0,    1187712,    1187712,     1152,     2304, 0xfc6978a6
+0,    1188864,    1188864,     1152,     2304, 0x9b178987
+0,    1190016,    1190016,     1152,     2304, 0xe436714a
+0,    1191168,    1191168,     1152,     2304, 0x783a7b6e
+0,    1192320,    1192320,     1152,     2304, 0x6ff16f4e
+0,    1193472,    1193472,     1152,     2304, 0x9fd582cc
+0,    1194624,    1194624,     1152,     2304, 0xff0d6bc9
+0,    1195776,    1195776,     1152,     2304, 0x6f4975d5
+0,    1196928,    1196928,     1152,     2304, 0x94a77a90
+0,    1198080,    1198080,     1152,     2304, 0x764f80db
+0,    1199232,    1199232,     1152,     2304, 0x68e88782
+0,    1200384,    1200384,     1152,     2304, 0x91a378e8
+0,    1201536,    1201536,     1152,     2304, 0x29f26903
+0,    1202688,    1202688,     1152,     2304, 0xc3b684d4
+0,    1203840,    1203840,     1152,     2304, 0x7d95921f
+0,    1204992,    1204992,     1152,     2304, 0x876a7ded
+0,    1206144,    1206144,     1152,     2304, 0x0fbe7ee8
+0,    1207296,    1207296,     1152,     2304, 0x7d0f78c5
+0,    1208448,    1208448,     1152,     2304, 0xce906ba8
+0,    1209600,    1209600,     1152,     2304, 0xd281747b
+0,    1210752,    1210752,     1152,     2304, 0xec38811b
+0,    1211904,    1211904,     1152,     2304, 0x8170810a
+0,    1213056,    1213056,     1152,     2304, 0x4d858ba2
+0,    1214208,    1214208,     1152,     2304, 0x8c798662
+0,    1215360,    1215360,     1152,     2304, 0x23a8879b
+0,    1216512,    1216512,     1152,     2304, 0x9d0c8894
+0,    1217664,    1217664,     1152,     2304, 0xf07c681f
+0,    1218816,    1218816,     1152,     2304, 0x03ab6f7a
+0,    1219968,    1219968,     1152,     2304, 0x88c170c2
+0,    1221120,    1221120,     1152,     2304, 0xeb977bf3
+0,    1222272,    1222272,     1152,     2304, 0x33b6774f
+0,    1223424,    1223424,     1152,     2304, 0x534c776e
+0,    1224576,    1224576,     1152,     2304, 0x33c4826a
+0,    1225728,    1225728,     1152,     2304, 0xdb9878d8
+0,    1226880,    1226880,     1152,     2304, 0xeffd789b
+0,    1228032,    1228032,     1152,     2304, 0x2cc9862f
+0,    1229184,    1229184,     1152,     2304, 0x9bf18131
+0,    1230336,    1230336,     1152,     2304, 0xfa078144
+0,    1231488,    1231488,     1152,     2304, 0x922885d2
+0,    1232640,    1232640,     1152,     2304, 0x29ad7796
+0,    1233792,    1233792,     1152,     2304, 0x62766f3f
+0,    1234944,    1234944,     1152,     2304, 0x72a873a5
+0,    1236096,    1236096,     1152,     2304, 0x65176e4d
+0,    1237248,    1237248,     1152,     2304, 0x75447cbd
+0,    1238400,    1238400,     1152,     2304, 0x83528e32
+0,    1239552,    1239552,     1152,     2304, 0x0c758531
+0,    1240704,    1240704,     1152,     2304, 0x4a5c7a84
+0,    1241856,    1241856,     1152,     2304, 0xd5937648
+0,    1243008,    1243008,     1152,     2304, 0xef5c8983
+0,    1244160,    1244160,     1152,     2304, 0x24b281d0
+0,    1245312,    1245312,     1152,     2304, 0xc0af7017
+0,    1246464,    1246464,     1152,     2304, 0xf1cc7145
+0,    1247616,    1247616,     1152,     2304, 0x7ddb7a3b
+0,    1248768,    1248768,     1152,     2304, 0xd2e57692
+0,    1249920,    1249920,     1152,     2304, 0x7abc61d6
+0,    1251072,    1251072,     1152,     2304, 0x44a68338
+0,    1252224,    1252224,     1152,     2304, 0x9cad810e
+0,    1253376,    1253376,     1152,     2304, 0xbf3a7f51
+0,    1254528,    1254528,     1152,     2304, 0x52ac815e
+0,    1255680,    1255680,     1152,     2304, 0xdf327e10
+0,    1256832,    1256832,     1152,     2304, 0x797c867b
+0,    1257984,    1257984,     1152,     2304, 0x685b79ec
+0,    1259136,    1259136,     1152,     2304, 0x60267b82
+0,    1260288,    1260288,     1152,     2304, 0xe70e7fd4
+0,    1261440,    1261440,     1152,     2304, 0xaf197a22
+0,    1262592,    1262592,     1152,     2304, 0xf5e57075
+0,    1263744,    1263744,     1152,     2304, 0xa86f8197
+0,    1264896,    1264896,     1152,     2304, 0x922c7b3d
+0,    1266048,    1266048,     1152,     2304, 0x8e3b7929
+0,    1267200,    1267200,     1152,     2304, 0x816f862d
+0,    1268352,    1268352,     1152,     2304, 0xc09c761a
+0,    1269504,    1269504,     1152,     2304, 0xf1cd9010
+0,    1270656,    1270656,     1152,     2304, 0xcf5c72d8
+0,    1271808,    1271808,     1152,     2304, 0x0e607a38
+0,    1272960,    1272960,     1152,     2304, 0x6cb0819c
+0,    1274112,    1274112,     1152,     2304, 0x9e2880aa
+0,    1275264,    1275264,     1152,     2304, 0xb46f69f9
+0,    1276416,    1276416,     1152,     2304, 0xbc807eab
+0,    1277568,    1277568,     1152,     2304, 0x91237cf9
+0,    1278720,    1278720,     1152,     2304, 0xb6bf82b6
+0,    1279872,    1279872,     1152,     2304, 0xfcd58daf
+0,    1281024,    1281024,     1152,     2304, 0x53b176f4
+0,    1282176,    1282176,     1152,     2304, 0xc79d7507
+0,    1283328,    1283328,     1152,     2304, 0x810677b2
+0,    1284480,    1284480,     1152,     2304, 0x13148737
+0,    1285632,    1285632,     1152,     2304, 0x2eb5755a
+0,    1286784,    1286784,     1152,     2304, 0x5bec5cd2
+0,    1287936,    1287936,     1152,     2304, 0x66c68d47
+0,    1289088,    1289088,     1152,     2304, 0x55d18770
+0,    1290240,    1290240,     1152,     2304, 0x13997def
+0,    1291392,    1291392,     1152,     2304, 0x23cd8437
+0,    1292544,    1292544,     1152,     2304, 0x5cd07942
+0,    1293696,    1293696,     1152,     2304, 0x43ab6b4c
+0,    1294848,    1294848,     1152,     2304, 0xc55788ec
+0,    1296000,    1296000,     1152,     2304, 0x6b69788e
+0,    1297152,    1297152,     1152,     2304, 0xcacb8fea
+0,    1298304,    1298304,     1152,     2304, 0x83407ebd
+0,    1299456,    1299456,     1152,     2304, 0x998275f3
+0,    1300608,    1300608,     1152,     2304, 0x0ca76dcc
+0,    1301760,    1301760,     1152,     2304, 0xa1ff7c6a
+0,    1302912,    1302912,     1152,     2304, 0x4a597683
+0,    1304064,    1304064,     1152,     2304, 0xc8e57f16
+0,    1305216,    1305216,     1152,     2304, 0x376d82fb
+0,    1306368,    1306368,     1152,     2304, 0x489b8164
+0,    1307520,    1307520,     1152,     2304, 0xece27f77
+0,    1308672,    1308672,     1152,     2304, 0x4c197e8f
+0,    1309824,    1309824,     1152,     2304, 0x6eb07739
+0,    1310976,    1310976,     1152,     2304, 0xef628145
+0,    1312128,    1312128,     1152,     2304, 0x549d6f12
+0,    1313280,    1313280,     1152,     2304, 0xbe566b70
+0,    1314432,    1314432,     1152,     2304, 0x2bde87d3
+0,    1315584,    1315584,     1152,     2304, 0x0ffd7175
+0,    1316736,    1316736,     1152,     2304, 0x47d28a8b
+0,    1317888,    1317888,     1152,     2304, 0x6f6c718e
+0,    1319040,    1319040,     1152,     2304, 0x665e7937
+0,    1320192,    1320192,     1152,     2304, 0x73538e8d
+0,    1321344,    1321344,     1152,     2304, 0x56167d71
+0,    1322496,    1322496,     1152,     2304, 0x3d0278ed
+0,    1323648,    1323648,     1152,     2304, 0x9baf7a51
+0,    1324800,    1324800,     1152,     2304, 0x8c058105
+0,    1325952,    1325952,     1152,     2304, 0x2b9573ca
+0,    1327104,    1327104,     1152,     2304, 0x4a2271a1
+0,    1328256,    1328256,     1152,     2304, 0x3d5276f6
+0,    1329408,    1329408,     1152,     2304, 0x43c076cd
+0,    1330560,    1330560,     1152,     2304, 0x4fec8929
+0,    1331712,    1331712,     1152,     2304, 0xaa7167ec
+0,    1332864,    1332864,     1152,     2304, 0x39ff7ea5
+0,    1334016,    1334016,     1152,     2304, 0x2dd58348
+0,    1335168,    1335168,     1152,     2304, 0x03fc8782
+0,    1336320,    1336320,     1152,     2304, 0x55a4649c
+0,    1337472,    1337472,     1152,     2304, 0x71407067
+0,    1338624,    1338624,     1152,     2304, 0x3b667ce6
+0,    1339776,    1339776,     1152,     2304, 0xb12e81aa
+0,    1340928,    1340928,     1152,     2304, 0xc1646ee3
+0,    1342080,    1342080,     1152,     2304, 0x6b55884f
+0,    1343232,    1343232,     1152,     2304, 0x292382b5
+0,    1344384,    1344384,     1152,     2304, 0x18f97854
+0,    1345536,    1345536,     1152,     2304, 0x47a480be
+0,    1346688,    1346688,     1152,     2304, 0xe0857b16
+0,    1347840,    1347840,     1152,     2304, 0xe3368462
+0,    1348992,    1348992,     1152,     2304, 0xced17ae8
+0,    1350144,    1350144,     1152,     2304, 0x4020796d
+0,    1351296,    1351296,     1152,     2304, 0x26797fd0
+0,    1352448,    1352448,     1152,     2304, 0x0e087554
+0,    1353600,    1353600,     1152,     2304, 0xf8868040
+0,    1354752,    1354752,     1152,     2304, 0x3f0a7784
+0,    1355904,    1355904,     1152,     2304, 0xbe517d5e
+0,    1357056,    1357056,     1152,     2304, 0xed0b66bc
+0,    1358208,    1358208,     1152,     2304, 0x79b96d63
+0,    1359360,    1359360,     1152,     2304, 0x1ab4793a
+0,    1360512,    1360512,     1152,     2304, 0xd2db7f7d
+0,    1361664,    1361664,     1152,     2304, 0x91017992
+0,    1362816,    1362816,     1152,     2304, 0xf88f7cb9
+0,    1363968,    1363968,     1152,     2304, 0x0cc98309
+0,    1365120,    1365120,     1152,     2304, 0x38b77cb8
+0,    1366272,    1366272,     1152,     2304, 0x0cb185f9
+0,    1367424,    1367424,     1152,     2304, 0xc4a27824
+0,    1368576,    1368576,     1152,     2304, 0x1ce97618
+0,    1369728,    1369728,     1152,     2304, 0x1423976e
+0,    1370880,    1370880,     1152,     2304, 0xdbb781b2
+0,    1372032,    1372032,     1152,     2304, 0x156d71d3
+0,    1373184,    1373184,     1152,     2304, 0xce228625
+0,    1374336,    1374336,     1152,     2304, 0x318072f3
+0,    1375488,    1375488,     1152,     2304, 0x464b77a1
+0,    1376640,    1376640,     1152,     2304, 0x0204854d
+0,    1377792,    1377792,     1152,     2304, 0x498c8373
+0,    1378944,    1378944,     1152,     2304, 0xfe1a6e23
+0,    1380096,    1380096,     1152,     2304, 0x705284d0
+0,    1381248,    1381248,     1152,     2304, 0x91848980
+0,    1382400,    1382400,     1152,     2304, 0x259098c5
+0,    1383552,    1383552,     1152,     2304, 0x52b07c02
+0,    1384704,    1384704,     1152,     2304, 0x017289f6
+0,    1385856,    1385856,     1152,     2304, 0xb87687bf
+0,    1387008,    1387008,     1152,     2304, 0x72de7843
+0,    1388160,    1388160,     1152,     2304, 0x3daf8939
+0,    1389312,    1389312,     1152,     2304, 0x0dfb763c
+0,    1390464,    1390464,     1152,     2304, 0xc3017408
+0,    1391616,    1391616,     1152,     2304, 0x73f27f14
+0,    1392768,    1392768,     1152,     2304, 0x1c517541
+0,    1393920,    1393920,     1152,     2304, 0xf390748b
+0,    1395072,    1395072,     1152,     2304, 0xe6ac71f3
+0,    1396224,    1396224,     1152,     2304, 0x6277862d
+0,    1397376,    1397376,     1152,     2304, 0x923d6794
+0,    1398528,    1398528,     1152,     2304, 0x320a7f20
+0,    1399680,    1399680,     1152,     2304, 0x12f07a09
+0,    1400832,    1400832,     1152,     2304, 0xf9568b14
+0,    1401984,    1401984,     1152,     2304, 0x4d787fea
+0,    1403136,    1403136,     1152,     2304, 0x57c5861a
+0,    1404288,    1404288,     1152,     2304, 0x826b7cc7
+0,    1405440,    1405440,     1152,     2304, 0x7d056a94
+0,    1406592,    1406592,     1152,     2304, 0xbf3e8a60
+0,    1407744,    1407744,     1152,     2304, 0x5e518cab
+0,    1408896,    1408896,     1152,     2304, 0x64e7794b
+0,    1410048,    1410048,     1152,     2304, 0x9c9569ac
+0,    1411200,    1411200,     1152,     2304, 0xde167582
+0,    1412352,    1412352,     1152,     2304, 0xdd8f78b1
+0,    1413504,    1413504,     1152,     2304, 0xec577e60
+0,    1414656,    1414656,     1152,     2304, 0x06877aa4
+0,    1415808,    1415808,     1152,     2304, 0xb5157742
+0,    1416960,    1416960,     1152,     2304, 0xf9be6f2b
+0,    1418112,    1418112,     1152,     2304, 0xf95784c7
+0,    1419264,    1419264,     1152,     2304, 0x5aec7e15
+0,    1420416,    1420416,     1152,     2304, 0x666e7ce9
+0,    1421568,    1421568,     1152,     2304, 0xa76393a7
+0,    1422720,    1422720,     1152,     2304, 0xd1bb6d5c
+0,    1423872,    1423872,     1152,     2304, 0x48d88144
+0,    1425024,    1425024,     1152,     2304, 0xa7df8177
+0,    1426176,    1426176,     1152,     2304, 0x906476b1
+0,    1427328,    1427328,     1152,     2304, 0x9f46723d
+0,    1428480,    1428480,     1152,     2304, 0xa6d37a0c
+0,    1429632,    1429632,     1152,     2304, 0x73e57be2
+0,    1430784,    1430784,     1152,     2304, 0x666e8594
+0,    1431936,    1431936,     1152,     2304, 0xd4b481d7
+0,    1433088,    1433088,     1152,     2304, 0xfced8427
+0,    1434240,    1434240,     1152,     2304, 0x743999bd
+0,    1435392,    1435392,     1152,     2304, 0x71dd759b
+0,    1436544,    1436544,     1152,     2304, 0x54a2849e
+0,    1437696,    1437696,     1152,     2304, 0x07377f58
+0,    1438848,    1438848,     1152,     2304, 0xfd8f721a
+0,    1440000,    1440000,     1152,     2304, 0x4d917422
+0,    1441152,    1441152,     1152,     2304, 0xaaa46e2b
+0,    1442304,    1442304,     1152,     2304, 0x49e57597
+0,    1443456,    1443456,     1152,     2304, 0x29337511
+0,    1444608,    1444608,     1152,     2304, 0xdfee84c2
+0,    1445760,    1445760,     1152,     2304, 0x57266b8c
+0,    1446912,    1446912,     1152,     2304, 0x5bf27cfc
+0,    1448064,    1448064,     1152,     2304, 0xdc4b8b29
+0,    1449216,    1449216,     1152,     2304, 0xf49e7466
+0,    1450368,    1450368,     1152,     2304, 0xf1d975f3
+0,    1451520,    1451520,     1152,     2304, 0xc863774d
+0,    1452672,    1452672,     1152,     2304, 0x5fab80c0
+0,    1453824,    1453824,     1152,     2304, 0x19548d6f
+0,    1454976,    1454976,     1152,     2304, 0x165983ac
+0,    1456128,    1456128,     1152,     2304, 0x2d658203
+0,    1457280,    1457280,     1152,     2304, 0x717678b2
+0,    1458432,    1458432,     1152,     2304, 0x1ed26dae
+0,    1459584,    1459584,     1152,     2304, 0xecef7975
+0,    1460736,    1460736,     1152,     2304, 0xcd2b804c
+0,    1461888,    1461888,     1152,     2304, 0xf4597f97
+0,    1463040,    1463040,     1152,     2304, 0x904b75cd
+0,    1464192,    1464192,     1152,     2304, 0x6b508374
+0,    1465344,    1465344,     1152,     2304, 0xb6b4791f
+0,    1466496,    1466496,     1152,     2304, 0xce6d7501
+0,    1467648,    1467648,     1152,     2304, 0x99ec8bac
+0,    1468800,    1468800,     1152,     2304, 0x65d772b7
+0,    1469952,    1469952,     1152,     2304, 0xbc2762ff
+0,    1471104,    1471104,     1152,     2304, 0xf8a48378
+0,    1472256,    1472256,     1152,     2304, 0x18057ad4
+0,    1473408,    1473408,     1152,     2304, 0x89af753f
+0,    1474560,    1474560,     1152,     2304, 0x95a48fc5
+0,    1475712,    1475712,     1152,     2304, 0x8b7576af
+0,    1476864,    1476864,     1152,     2304, 0xcdcb6e67
+0,    1478016,    1478016,     1152,     2304, 0xe02a7ff3
+0,    1479168,    1479168,     1152,     2304, 0x4f0a7d48
+0,    1480320,    1480320,     1152,     2304, 0x9bab8287
+0,    1481472,    1481472,     1152,     2304, 0xc1fa8063
+0,    1482624,    1482624,     1152,     2304, 0x410e7dd7
+0,    1483776,    1483776,     1152,     2304, 0xd4de777f
+0,    1484928,    1484928,     1152,     2304, 0x403675ac
+0,    1486080,    1486080,     1152,     2304, 0x4d7687c5
+0,    1487232,    1487232,     1152,     2304, 0x10c6650d
+0,    1488384,    1488384,     1152,     2304, 0xd7e67b69
+0,    1489536,    1489536,     1152,     2304, 0x42b97fae
+0,    1490688,    1490688,     1152,     2304, 0xa8b57a9f
+0,    1491840,    1491840,     1152,     2304, 0xc24960a0
+0,    1492992,    1492992,     1152,     2304, 0x16198fec
+0,    1494144,    1494144,     1152,     2304, 0x29297416
+0,    1495296,    1495296,     1152,     2304, 0x129b7d00
+0,    1496448,    1496448,     1152,     2304, 0xa9677141
+0,    1497600,    1497600,     1152,     2304, 0x86a779bf
+0,    1498752,    1498752,     1152,     2304, 0xa3857dce
+0,    1499904,    1499904,     1152,     2304, 0xee6d7c4d
+0,    1501056,    1501056,     1152,     2304, 0x97127166
+0,    1502208,    1502208,     1152,     2304, 0x6e407c25
+0,    1503360,    1503360,     1152,     2304, 0x82a07c9a
+0,    1504512,    1504512,     1152,     2304, 0xf62381ef
+0,    1505664,    1505664,     1152,     2304, 0x2ab86ca8
+0,    1506816,    1506816,     1152,     2304, 0x97ca87ed
+0,    1507968,    1507968,     1152,     2304, 0x6b4868f2
+0,    1509120,    1509120,     1152,     2304, 0xdb2a953c
+0,    1510272,    1510272,     1152,     2304, 0x061e7770
+0,    1511424,    1511424,     1152,     2304, 0xae067224
+0,    1512576,    1512576,     1152,     2304, 0x88a282a3
+0,    1513728,    1513728,     1152,     2304, 0x4e14743e
+0,    1514880,    1514880,     1152,     2304, 0x3dbd8b7b
+0,    1516032,    1516032,     1152,     2304, 0xcae57312
+0,    1517184,    1517184,     1152,     2304, 0xf9038ca7
+0,    1518336,    1518336,     1152,     2304, 0x03ec6f07
+0,    1519488,    1519488,     1152,     2304, 0x8c297359
+0,    1520640,    1520640,     1152,     2304, 0x8af1804c
+0,    1521792,    1521792,     1152,     2304, 0xf30087c8
+0,    1522944,    1522944,     1152,     2304, 0x21127cd1
+0,    1524096,    1524096,     1152,     2304, 0xc66772bd
+0,    1525248,    1525248,     1152,     2304, 0x05e6630b
+0,    1526400,    1526400,     1152,     2304, 0x020688d9
+0,    1527552,    1527552,     1152,     2304, 0xee3873cd
+0,    1528704,    1528704,     1152,     2304, 0xf263782b
+0,    1529856,    1529856,     1152,     2304, 0xf8877144
+0,    1531008,    1531008,     1152,     2304, 0xce1e6f33
+0,    1532160,    1532160,     1152,     2304, 0xf0457e4f
+0,    1533312,    1533312,     1152,     2304, 0xde9387df
+0,    1534464,    1534464,     1152,     2304, 0x5df86d1d
+0,    1535616,    1535616,     1152,     2304, 0x949087ef
+0,    1536768,    1536768,     1152,     2304, 0xdbd269c6
+0,    1537920,    1537920,     1152,     2304, 0xd530806e
+0,    1539072,    1539072,     1152,     2304, 0x80027b1d
+0,    1540224,    1540224,     1152,     2304, 0xccb47c48
+0,    1541376,    1541376,     1152,     2304, 0x4f2f8326
+0,    1542528,    1542528,     1152,     2304, 0xfe046f23
+0,    1543680,    1543680,     1152,     2304, 0x5939759b
+0,    1544832,    1544832,     1152,     2304, 0x83147073
+0,    1545984,    1545984,     1152,     2304, 0xc9e77b95
+0,    1547136,    1547136,     1152,     2304, 0x702d8e51
+0,    1548288,    1548288,     1152,     2304, 0x5f5f8492
+0,    1549440,    1549440,     1152,     2304, 0x10116d0e
+0,    1550592,    1550592,     1152,     2304, 0xb8587894
+0,    1551744,    1551744,     1152,     2304, 0x2b357892
+0,    1552896,    1552896,     1152,     2304, 0x160e6c20
+0,    1554048,    1554048,     1152,     2304, 0x0534874b
+0,    1555200,    1555200,     1152,     2304, 0xde687064
+0,    1556352,    1556352,     1152,     2304, 0x91ef7fe4
+0,    1557504,    1557504,     1152,     2304, 0x077473ce
+0,    1558656,    1558656,     1152,     2304, 0x1be77777
+0,    1559808,    1559808,     1152,     2304, 0xaada9096
+0,    1560960,    1560960,     1152,     2304, 0xeac96f7e
+0,    1562112,    1562112,     1152,     2304, 0xe9ca6e72
+0,    1563264,    1563264,     1152,     2304, 0xd0868038
+0,    1564416,    1564416,     1152,     2304, 0x689176f1
+0,    1565568,    1565568,     1152,     2304, 0xdfdb7684
+0,    1566720,    1566720,     1152,     2304, 0x83c55d92
+0,    1567872,    1567872,     1152,     2304, 0x77587b70
+0,    1569024,    1569024,     1152,     2304, 0x60937941
+0,    1570176,    1570176,     1152,     2304, 0xb00267bd
+0,    1571328,    1571328,     1152,     2304, 0xd0a166eb
+0,    1572480,    1572480,     1152,     2304, 0x88718162
+0,    1573632,    1573632,     1152,     2304, 0xf9e084ff
+0,    1574784,    1574784,     1152,     2304, 0x2ddc8c08
+0,    1575936,    1575936,     1152,     2304, 0x843a7178
+0,    1577088,    1577088,     1152,     2304, 0x1d9784b4
+0,    1578240,    1578240,     1152,     2304, 0x98aa7b1d
+0,    1579392,    1579392,     1152,     2304, 0x583e846e
+0,    1580544,    1580544,     1152,     2304, 0xa6d284ec
+0,    1581696,    1581696,     1152,     2304, 0xa0147cbf
+0,    1582848,    1582848,     1152,     2304, 0xb3bf7b4b
+0,    1584000,    1584000,     1152,     2304, 0x7f8b78dd
+0,    1585152,    1585152,     1152,     2304, 0xd3fb761f
+0,    1586304,    1586304,     1152,     2304, 0x78147c2f
+0,    1587456,    1587456,     1152,     2304, 0x5e747b26
+0,    1588608,    1588608,     1152,     2304, 0x0d8e7d96
+0,    1589760,    1589760,     1152,     2304, 0x73728362
+0,    1590912,    1590912,     1152,     2304, 0x7c54707b
+0,    1592064,    1592064,     1152,     2304, 0xb89c7806
+0,    1593216,    1593216,     1152,     2304, 0x5f0f7a91
+0,    1594368,    1594368,     1152,     2304, 0x35217e84
+0,    1595520,    1595520,     1152,     2304, 0xb3798553
+0,    1596672,    1596672,     1152,     2304, 0xd8377e8a
+0,    1597824,    1597824,     1152,     2304, 0x339181ba
+0,    1598976,    1598976,     1152,     2304, 0xbe196b2c
+0,    1600128,    1600128,     1152,     2304, 0xdc708cc4
+0,    1601280,    1601280,     1152,     2304, 0x649c74c1
+0,    1602432,    1602432,     1152,     2304, 0xac128649
+0,    1603584,    1603584,     1152,     2304, 0xcd266a22
+0,    1604736,    1604736,     1152,     2304, 0xdfde7023
+0,    1605888,    1605888,     1152,     2304, 0xf92d7450
+0,    1607040,    1607040,     1152,     2304, 0x9ce379ac
+0,    1608192,    1608192,     1152,     2304, 0xee5e712e
+0,    1609344,    1609344,     1152,     2304, 0xa12676c0
+0,    1610496,    1610496,     1152,     2304, 0x4cee7be1
+0,    1611648,    1611648,     1152,     2304, 0x90c881e5
+0,    1612800,    1612800,     1152,     2304, 0xa6a78158
+0,    1613952,    1613952,     1152,     2304, 0xd248864a
+0,    1615104,    1615104,     1152,     2304, 0x7a8972b4
+0,    1616256,    1616256,     1152,     2304, 0x5c8a75cb
+0,    1617408,    1617408,     1152,     2304, 0x07606722
+0,    1618560,    1618560,     1152,     2304, 0xbf497aae
+0,    1619712,    1619712,     1152,     2304, 0xffab7d66
+0,    1620864,    1620864,     1152,     2304, 0xefdc7d05
+0,    1622016,    1622016,     1152,     2304, 0x02d686dd
+0,    1623168,    1623168,     1152,     2304, 0x852e6eb6
+0,    1624320,    1624320,     1152,     2304, 0x3445706b
+0,    1625472,    1625472,     1152,     2304, 0x04677828
+0,    1626624,    1626624,     1152,     2304, 0x5d5c833c
+0,    1627776,    1627776,     1152,     2304, 0xf4277e06
+0,    1628928,    1628928,     1152,     2304, 0xcece72ab
+0,    1630080,    1630080,     1152,     2304, 0x10837aff
+0,    1631232,    1631232,     1152,     2304, 0x0265762b
+0,    1632384,    1632384,     1152,     2304, 0x0fc979de
+0,    1633536,    1633536,     1152,     2304, 0xeecf7010
+0,    1634688,    1634688,     1152,     2304, 0x313975cd
+0,    1635840,    1635840,     1152,     2304, 0xccce84a7
+0,    1636992,    1636992,     1152,     2304, 0x823e6935
+0,    1638144,    1638144,     1152,     2304, 0xa0606ade
+0,    1639296,    1639296,     1152,     2304, 0x2c2d7866
+0,    1640448,    1640448,     1152,     2304, 0x3a5a781e
+0,    1641600,    1641600,     1152,     2304, 0xdaf677fd
+0,    1642752,    1642752,     1152,     2304, 0x79d88aca
+0,    1643904,    1643904,     1152,     2304, 0x3db27308
+0,    1645056,    1645056,     1152,     2304, 0x627175ff
+0,    1646208,    1646208,     1152,     2304, 0x40697b16
+0,    1647360,    1647360,     1152,     2304, 0x40e47ee7
+0,    1648512,    1648512,     1152,     2304, 0x6a6a7d91
+0,    1649664,    1649664,     1152,     2304, 0x8d3e8a32
+0,    1650816,    1650816,     1152,     2304, 0x576a817e
+0,    1651968,    1651968,     1152,     2304, 0x86287f9b
+0,    1653120,    1653120,     1152,     2304, 0x43e081ce
+0,    1654272,    1654272,     1152,     2304, 0xe44b8003
+0,    1655424,    1655424,     1152,     2304, 0xfb237f5b
+0,    1656576,    1656576,     1152,     2304, 0x28967c8a
+0,    1657728,    1657728,     1152,     2304, 0x97478829
+0,    1658880,    1658880,     1152,     2304, 0x615570e8
+0,    1660032,    1660032,     1152,     2304, 0xa52c7d34
+0,    1661184,    1661184,     1152,     2304, 0xb55473e8
+0,    1662336,    1662336,     1152,     2304, 0x08a07d6c
+0,    1663488,    1663488,     1152,     2304, 0x2eed916a
+0,    1664640,    1664640,     1152,     2304, 0x8ce36cec
+0,    1665792,    1665792,     1152,     2304, 0x775e8992
+0,    1666944,    1666944,     1152,     2304, 0x99ad816b
+0,    1668096,    1668096,     1152,     2304, 0x697a70be
+0,    1669248,    1669248,     1152,     2304, 0x38c46cf2
+0,    1670400,    1670400,     1152,     2304, 0xf9d681f4
+0,    1671552,    1671552,     1152,     2304, 0xa7336fea
+0,    1672704,    1672704,     1152,     2304, 0xd2a97e59
+0,    1673856,    1673856,     1152,     2304, 0x02b880e9
+0,    1675008,    1675008,     1152,     2304, 0x2a486e9e
+0,    1676160,    1676160,     1152,     2304, 0x5f197c43
+0,    1677312,    1677312,     1152,     2304, 0x266679ad
+0,    1678464,    1678464,     1152,     2304, 0x7cfd7c8a
+0,    1679616,    1679616,     1152,     2304, 0x43b681bb
+0,    1680768,    1680768,     1152,     2304, 0x63309cff
+0,    1681920,    1681920,     1152,     2304, 0x80f36f7d
+0,    1683072,    1683072,     1152,     2304, 0xcead7b98
+0,    1684224,    1684224,     1152,     2304, 0x8475992f
+0,    1685376,    1685376,     1152,     2304, 0x746782d2
+0,    1686528,    1686528,     1152,     2304, 0x2b486982
+0,    1687680,    1687680,     1152,     2304, 0xc80c7fc2
+0,    1688832,    1688832,     1152,     2304, 0x148c7c3b
+0,    1689984,    1689984,     1152,     2304, 0x49c477df
+0,    1691136,    1691136,     1152,     2304, 0x1bf97c56
+0,    1692288,    1692288,     1152,     2304, 0x89a38221
+0,    1693440,    1693440,     1152,     2304, 0xcb757a31
+0,    1694592,    1694592,     1152,     2304, 0xd3bb72fa
+0,    1695744,    1695744,     1152,     2304, 0xe5727650
+0,    1696896,    1696896,     1152,     2304, 0x5d4e9242
+0,    1698048,    1698048,     1152,     2304, 0x29207f75
+0,    1699200,    1699200,     1152,     2304, 0x5b1d954a
+0,    1700352,    1700352,     1152,     2304, 0xa2888223
+0,    1701504,    1701504,     1152,     2304, 0xe31d8af7
+0,    1702656,    1702656,     1152,     2304, 0x29ee82dd
+0,    1703808,    1703808,     1152,     2304, 0x4b1d7887
+0,    1704960,    1704960,     1152,     2304, 0xc0308236
+0,    1706112,    1706112,     1152,     2304, 0xaed68e92
+0,    1707264,    1707264,     1152,     2304, 0xbc1171e9
+0,    1708416,    1708416,     1152,     2304, 0x379f828b
+0,    1709568,    1709568,     1152,     2304, 0x83de72c8
+0,    1710720,    1710720,     1152,     2304, 0xb11a806a
+0,    1711872,    1711872,     1152,     2304, 0x7ac17e7a
+0,    1713024,    1713024,     1152,     2304, 0x031b7d9a
+0,    1714176,    1714176,     1152,     2304, 0xebc97c43
+0,    1715328,    1715328,     1152,     2304, 0x914e86a7
+0,    1716480,    1716480,     1152,     2304, 0x88e2747e
+0,    1717632,    1717632,     1152,     2304, 0x153076bc
+0,    1718784,    1718784,     1152,     2304, 0xdacc7ebb
+0,    1719936,    1719936,     1152,     2304, 0x0905709a
+0,    1721088,    1721088,     1152,     2304, 0x13358109
+0,    1722240,    1722240,     1152,     2304, 0x18227228
+0,    1723392,    1723392,     1152,     2304, 0x318082d7
+0,    1724544,    1724544,     1152,     2304, 0x8aec7a8e
+0,    1725696,    1725696,     1152,     2304, 0x8c9c7755
+0,    1726848,    1726848,     1152,     2304, 0xdba46e2f
+0,    1728000,    1728000,     1152,     2304, 0xd47d7f5a
+0,    1729152,    1729152,     1152,     2304, 0xeb1370ec
+0,    1730304,    1730304,     1152,     2304, 0xf6d68e74
+0,    1731456,    1731456,     1152,     2304, 0x3d5a7c66
+0,    1732608,    1732608,     1152,     2304, 0x264b6d68
+0,    1733760,    1733760,     1152,     2304, 0x7cde8b9f
+0,    1734912,    1734912,     1152,     2304, 0xba467347
+0,    1736064,    1736064,     1152,     2304, 0x921987f7
+0,    1737216,    1737216,     1152,     2304, 0x9c6c7fce
+0,    1738368,    1738368,     1152,     2304, 0x02cb828f
+0,    1739520,    1739520,     1152,     2304, 0x3b427077
+0,    1740672,    1740672,     1152,     2304, 0x6f9c7523
+0,    1741824,    1741824,     1152,     2304, 0xef688204
+0,    1742976,    1742976,     1152,     2304, 0x263782dc
+0,    1744128,    1744128,     1152,     2304, 0xb6ca7e46
+0,    1745280,    1745280,     1152,     2304, 0xb0929636
+0,    1746432,    1746432,     1152,     2304, 0x60a97b7a
+0,    1747584,    1747584,     1152,     2304, 0xcf037690
+0,    1748736,    1748736,     1152,     2304, 0xc9046a25
+0,    1749888,    1749888,     1152,     2304, 0xbf247f3c
+0,    1751040,    1751040,     1152,     2304, 0x71e77d34
+0,    1752192,    1752192,     1152,     2304, 0x96ce7a01
+0,    1753344,    1753344,     1152,     2304, 0xf9b07a27
+0,    1754496,    1754496,     1152,     2304, 0x984b830b
+0,    1755648,    1755648,     1152,     2304, 0xff11822b
+0,    1756800,    1756800,     1152,     2304, 0xb0a18578
+0,    1757952,    1757952,     1152,     2304, 0xa9d98ef8
+0,    1759104,    1759104,     1152,     2304, 0x4f9076e1
+0,    1760256,    1760256,     1152,     2304, 0xb63c7742
+0,    1761408,    1761408,     1152,     2304, 0xb4c06ae2
+0,    1762560,    1762560,     1152,     2304, 0x41738531
+0,    1763712,    1763712,     1152,     2304, 0x55125e7b
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-interlace-complex b/mythtv/external/FFmpeg/tests/ref/fate/filter-interlace-complex
new file mode 100644
index 00000000000..e8db46a9348
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-interlace-complex
@@ -0,0 +1,30 @@
+#tb 0: 2/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 352x288
+#sar 0: 0/1
+0,          0,          0,        1,   152064, 0x778ab0c1
+0,          1,          1,        1,   152064, 0xdc30f7c3
+0,          2,          2,        1,   152064, 0xcb637467
+0,          3,          3,        1,   152064, 0xcbf778ce
+0,          4,          4,        1,   152064, 0x573d9f6d
+0,          5,          5,        1,   152064, 0xd794df2c
+0,          6,          6,        1,   152064, 0x3e885448
+0,          7,          7,        1,   152064, 0xccec1794
+0,          8,          8,        1,   152064, 0x6f32f51a
+0,          9,          9,        1,   152064, 0x0657f5ac
+0,         10,         10,        1,   152064, 0xfa82d600
+0,         11,         11,        1,   152064, 0x15ff7f32
+0,         12,         12,        1,   152064, 0x1cac0342
+0,         13,         13,        1,   152064, 0x6afb7c49
+0,         14,         14,        1,   152064, 0x6c47d554
+0,         15,         15,        1,   152064, 0xe0fbd132
+0,         16,         16,        1,   152064, 0x4f891e8d
+0,         17,         17,        1,   152064, 0x88554045
+0,         18,         18,        1,   152064, 0x0c8e6192
+0,         19,         19,        1,   152064, 0xf73c91c3
+0,         20,         20,        1,   152064, 0x49ac328d
+0,         21,         21,        1,   152064, 0xf18ebd82
+0,         22,         22,        1,   152064, 0x3359760d
+0,         23,         23,        1,   152064, 0x5c85601a
+0,         24,         24,        1,   152064, 0x28c1657b
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-meta-4560-rotate0 b/mythtv/external/FFmpeg/tests/ref/fate/filter-meta-4560-rotate0
index 6e870c7afe5..97552ffb970 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-meta-4560-rotate0
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-meta-4560-rotate0
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 44100
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   195840, 0x0602351d
 1,          0,          0,     1024,     2048, 0x00000000
 1,       1024,       1024,     1024,     2048, 0xe6b00ffc
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-metadata-avf-aphase-meter-mono b/mythtv/external/FFmpeg/tests/ref/fate/filter-metadata-avf-aphase-meter-mono
new file mode 100644
index 00000000000..4a537555c0f
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-metadata-avf-aphase-meter-mono
@@ -0,0 +1,47 @@
+pkt_pts=0|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=1024|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=2048|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=3072|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=4096|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=5120|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=6144|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=7168|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=8192|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=9216|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=10240|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=11264|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=12288|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=13312|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=14336|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=15360|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=16384|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=17408|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=18432|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=19456|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=20480|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=21504|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=22528|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=23552|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=24576|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=25600|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=26624|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=27648|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=28672|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=29696|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=30720|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=31744|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=32768|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=33792|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=34816|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=35840|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=36864|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=37888|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=38912|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=39936|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=40960|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=41984|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=43008|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=44032|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=45056|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=46080|tag:lavfi.aphasemeter.phase=1.000000
+pkt_pts=47104|tag:lavfi.aphasemeter.phase=1.000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-metadata-avf-aphase-meter-out-of-phase b/mythtv/external/FFmpeg/tests/ref/fate/filter-metadata-avf-aphase-meter-out-of-phase
new file mode 100644
index 00000000000..a200e934d23
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-metadata-avf-aphase-meter-out-of-phase
@@ -0,0 +1,11 @@
+pkt_pts=0|tag:lavfi.aphasemeter.phase=-1.000000
+pkt_pts=4608|tag:lavfi.aphasemeter.phase=-1.000000
+pkt_pts=9216|tag:lavfi.aphasemeter.phase=-1.000000
+pkt_pts=13824|tag:lavfi.aphasemeter.phase=-1.000000
+pkt_pts=18432|tag:lavfi.aphasemeter.phase=-1.000000
+pkt_pts=23040|tag:lavfi.aphasemeter.phase=-1.000000
+pkt_pts=27648|tag:lavfi.aphasemeter.phase=-1.000000
+pkt_pts=32256|tag:lavfi.aphasemeter.phase=-1.000000
+pkt_pts=36864|tag:lavfi.aphasemeter.phase=-1.000000
+pkt_pts=41472|tag:lavfi.aphasemeter.phase=-1.000000
+pkt_pts=46080|tag:lavfi.aphasemeter.phase=-1.000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-mpdecimate b/mythtv/external/FFmpeg/tests/ref/fate/filter-mpdecimate
index d438dacc2ee..9c1dc365626 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-mpdecimate
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-mpdecimate
@@ -22,4 +22,3 @@
 0,         24,         24,        1,   115200, 0x056d40ca
 0,         26,         26,        1,   115200, 0xa4374737
 0,         27,         27,        1,   115200, 0x3eaa3ae8
-0,         29,         29,        1,   115200, 0x7551e9ee
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay-dvdsub-2397 b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay-dvdsub-2397
index 0e0444dd06e..b86a2184b72 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay-dvdsub-2397
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay-dvdsub-2397
@@ -8,6 +8,7 @@
 #codec_id 1: dts
 #sample_rate 1: 48000
 #channel_layout 1: 60f
+#channel_layout_name 1: 5.1(side)
 0,          0,          0,        1,   518400, 0x6b05d48a
 1,         27,         27,       10,     2013, 0x68e7b03a
 0,          1,          1,        1,   518400, 0x2c2219cd
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_gbrap_gbrap b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_gbrap_gbrap
new file mode 100644
index 00000000000..49e14c643c3
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_gbrap_gbrap
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 1/1
+0,          0,          0,        1,    65536, 0xbac99946
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_gbrp_gbrap b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_gbrp_gbrap
new file mode 100644
index 00000000000..204c9d06251
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_gbrp_gbrap
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 1/1
+0,          0,          0,        1,    49152, 0xa905d586
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_rgb_rgba b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_rgb_rgba
new file mode 100644
index 00000000000..d7dc6980cc3
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_rgb_rgba
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 1/1
+0,          0,          0,        1,    49152, 0xb0e3d586
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_rgba_rgba b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_rgba_rgba
new file mode 100644
index 00000000000..a1c85e69e41
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_rgba_rgba
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 1/1
+0,          0,          0,        1,    65536, 0x33549946
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuv420_yuva420 b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuv420_yuva420
new file mode 100644
index 00000000000..ee0c82e0625
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuv420_yuva420
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 1/1
+0,          0,          0,        1,    24576, 0x1505f000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuv422_yuva422 b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuv422_yuva422
new file mode 100644
index 00000000000..7d21e1b84a5
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuv422_yuva422
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 1/1
+0,          0,          0,        1,    32768, 0x2d88b114
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuv444_yuva444 b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuv444_yuva444
new file mode 100644
index 00000000000..e1e5db2d7dd
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuv444_yuva444
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 1/1
+0,          0,          0,        1,    49152, 0x92da3b63
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuva420_yuva420 b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuva420_yuva420
new file mode 100644
index 00000000000..a17cc5c2e54
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuva420_yuva420
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 1/1
+0,          0,          0,        1,    40960, 0x0a1ab3c0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuva422_yuva422 b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuva422_yuva422
new file mode 100644
index 00000000000..e4d2e3977ec
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuva422_yuva422
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 1/1
+0,          0,          0,        1,    49152, 0x369974d4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuva444_yuva444 b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuva444_yuva444
new file mode 100644
index 00000000000..f2d9c564376
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-overlay_yuva444_yuva444
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 1/1
+0,          0,          0,        1,    65536, 0xa279ff14
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap10be b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap10be
new file mode 100644
index 00000000000..fbdaf693092
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap10be
@@ -0,0 +1 @@
+pixdesc-gbrap10be   95487536cdc73e10e06d739e03427390
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap10le b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap10le
new file mode 100644
index 00000000000..f53ed5e2127
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap10le
@@ -0,0 +1 @@
+pixdesc-gbrap10le   bf2ce9a1b3cfd56667c19b30a1a51181
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap12be b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap12be
new file mode 100644
index 00000000000..be7c1390f56
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap12be
@@ -0,0 +1 @@
+pixdesc-gbrap12be   419eca7130f22b62fd50cab347a56459
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap12le b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap12le
new file mode 100644
index 00000000000..99c5901064d
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap12le
@@ -0,0 +1 @@
+pixdesc-gbrap12le   01fff1419a76749e214056618a43f8b1
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap16be b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap16be
new file mode 100644
index 00000000000..b01c4047c43
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap16be
@@ -0,0 +1 @@
+pixdesc-gbrap16be   7874e7fd35419ef212a450ea637ffb24
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap16le b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap16le
new file mode 100644
index 00000000000..71ef29f056e
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrap16le
@@ -0,0 +1 @@
+pixdesc-gbrap16le   a83c7d0bbbfb1c1a8208f75680358387
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrp16be b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrp16be
new file mode 100644
index 00000000000..a7e98000c9c
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrp16be
@@ -0,0 +1 @@
+pixdesc-gbrp16be    daccdd0a7d41d566ab40c4d00e552cbe
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrp16le b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrp16le
new file mode 100644
index 00000000000..952c0aff92f
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gbrp16le
@@ -0,0 +1 @@
+pixdesc-gbrp16le    04f40ad1a27963be3125624446ed195e
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray10be b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray10be
new file mode 100644
index 00000000000..5ef8032e702
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray10be
@@ -0,0 +1 @@
+pixdesc-gray10be    987bee0355054fcfc915e1e41aad523a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray10le b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray10le
new file mode 100644
index 00000000000..ea86b22dc5c
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray10le
@@ -0,0 +1 @@
+pixdesc-gray10le    674bed2aa8686b78dd5fa4b15c15c655
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray12be b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray12be
new file mode 100644
index 00000000000..6388f147648
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray12be
@@ -0,0 +1 @@
+pixdesc-gray12be    29aeecc116c4b3e0c5109810fbd9ca17
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray12le b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray12le
new file mode 100644
index 00000000000..28e900f68ec
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray12le
@@ -0,0 +1 @@
+pixdesc-gray12le    030882d5b4a502210644f2d520f7b92c
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray9be b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray9be
new file mode 100644
index 00000000000..bf92e299b55
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray9be
@@ -0,0 +1 @@
+pixdesc-gray9be     19aef736657607fdc6191f5338860580
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray9le b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray9le
new file mode 100644
index 00000000000..4c65fb97c27
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixdesc-gray9le
@@ -0,0 +1 @@
+pixdesc-gray9le     f2a28bb71966f5d6e44eedef67e0118a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-copy b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-copy
index f19dcb09baf..124dddeacbe 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-copy
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-copy
@@ -19,6 +19,12 @@ bgra                3934fb81a602dfa7d29420b1a66f0fd8
 bgra64be            c8d3217bf58d34f080ac88c0b0012c77
 bgra64le            b71d75a928aac14cb768403e6f6a9910
 gbrap               98d30987407c51e5620921e11d40a4ff
+gbrap10be           edcffb185e44b6dae5c2ead5505b7125
+gbrap10le           2a7392e14b21b1f9457526a071236a6d
+gbrap12be           0c4c1f8af361571265ca259d5f70f026
+gbrap12le           5f1d8c663d4c28863e687192433b34a4
+gbrap16be           e4edca4361d643794034e5aa9ef290b1
+gbrap16le           9a95b389d2bf556179e8f4b27fb550ab
 gbrp                5fbc319e30110d19d539f5b274eddb6d
 gbrp10be            703a17591a2a5c236675c5101c349bcc
 gbrp10le            ee014153f55c011918df5b2394815780
@@ -26,11 +32,19 @@ gbrp12be            527d337eb5813ebba7cf969ee660d423
 gbrp12le            fd192920b171a0cf88d61e8310e95d81
 gbrp14be            46d502db6dc5eb7e9da3c60016b2df91
 gbrp14le            1607f5c8f13360b53b8186f523996b1b
+gbrp16be            7b6764a504c853b09f5c7d0b2223c5a4
+gbrp16le            fb9323a5bd060282bec7bfd7d38dc230
 gbrp9be             a4dc6f6f9bb051de2dc348b592ad4282
 gbrp9le             699da3a3b324f3fd001a56aee9683384
 gray                188590b1231afd231ea910815aef2b25
+gray10be            d486558ecd2e27afc17930be861f0e4c
+gray10le            917d687103b2adcca7132bfc070ca54a
+gray12be            9685614450f1282be433d2b07234ca1f
+gray12le            2700bd7fb3fea56e54eb03e31d6d4e57
 gray16be            08d997a3faa25a3db9d6be272d282eef
 gray16le            df65eb804360795e3e38a2701fa9641a
+gray9be             6382a14594a8b68f0ec7de25531f9334
+gray9le             4eb1dda58706436e3b69aef29b0089db
 monob               8b04f859fee6a0be856be184acd7a0b5
 monow               54d16d2c01abfd72ecdb5e51e283937c
 nv12                8e24feb2c544dc26a20047a71e4c27aa
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-crop b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-crop
index 86b3f022a74..e21479ceb00 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-crop
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-crop
@@ -19,6 +19,12 @@ bgra                e66a5f68ba463cbc89fce23a61bb5203
 bgra64be            1ad8dd02714cafec793fb89577ddde47
 bgra64le            dd29ec9aba43aa3e8f9f5b9a93ca8831
 gbrap               188cd467fe7ae7d85ae9ca8bdfa07739
+gbrap10be           1880c4856d9cc6492b8b859f2711aaf1
+gbrap10le           c2b6e35f8b7ca363a7ec021ccdf31d1f
+gbrap12be           c9769d18733cdc2664d8b9af09a03f6d
+gbrap12le           3f80453c1ac6c5d1b2febf3ef141b476
+gbrap16be           21c98d0d7e7de2a93f9f095e5bb5c227
+gbrap16le           ea9a96870c1b742dd9f065c5db568184
 gbrp                ec671f573c2105072ab68a1933c58fee
 gbrp10be            6f0130a41f01e58593d3840446dd94b7
 gbrp10le            9c152b7dfb7ad7bc477518d97316d04f
@@ -26,11 +32,19 @@ gbrp12be            561516202a6e37dd19543f9bb3af339f
 gbrp12le            3e7f87d834748844ab326e22eb2b7487
 gbrp14be            057232bca98c472a003cc46b3fd939e4
 gbrp14le            d4764dba3c3efd1263c2c8e0f5ac9f6a
+gbrp16be            59e4c27ee33520e23dbceafbec27aa9b
+gbrp16le            0768a2462783829f63ed0bfd53d01222
 gbrp9be             4af43999e5e9742992b6550ea5ad9b23
 gbrp9le             b4cbfa7878706a14295f09212e41f7fe
 gray                0d70b54b4b888ec4dbd89713620ac1ee
+gray10be            18ed76cab145ab9058cc353fcec6d3c4
+gray10le            fd83f7489880160783ddb125615b4638
+gray12be            472700c26cc49b8d5f74af141f6a0d38
+gray12le            4f6537fe1f32b3963350f8c435009433
 gray16be            38f599da990224de86e3dc7a543121a9
 gray16le            9ff7c866bd98def4e6c91542c1c45f80
+gray9be             8ffcb18d699480f55414bfc21ab33321
+gray9le             4d1932d4968a248584f5e39c25f1dd43
 nv12                92cda427f794374731ec0321ee00caac
 nv21                1bcfc197f4fb95de85ba58182d8d2f69
 p010be              8b2de2eb6b099bbf355bfc55a0694ddc
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-field b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-field
index 7f3abf60672..ba2af6e76fc 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-field
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-field
@@ -19,6 +19,12 @@ bgra                66d6e0846990fff0f09a07c43c3add71
 bgra64be            ec0bdef8663dc9d73818a48419cb4764
 bgra64le            9e2def541e51bc6e77fbffbff7fa146a
 gbrap               08a28b79dbd19246d1a94e3466af3624
+gbrap10be           29d46cbf021b233f5f1886e5d5fe21b4
+gbrap10le           4017c5d8c124438eb9aefa107db58d3b
+gbrap12be           e7f471132628b1c034199cc109b84bc2
+gbrap12le           886207e5aa379a0312485b94e5fd5edd
+gbrap16be           eaa0158f27ebc40cde9e3d6eef1e2ba1
+gbrap16le           6cf68992d4fcac2aa025d1014b669d24
 gbrp                838025a3062f7f31e99196ce66961ad7
 gbrp10be            f63c2555ea19fc78b00fd5b3e2b48e8c
 gbrp10le            be64c374ab318235d912372e99a0516a
@@ -26,11 +32,19 @@ gbrp12be            ef164a1c062dc3572c61b9ef10897ca1
 gbrp12le            0527fdb6f75b1cb0d380809eb7a7589a
 gbrp14be            6aff3ad388e2ed97d59b71a75029746d
 gbrp14le            ed9ccbc7a4f3e269a2ec37d210359fd8
+gbrp16be            020eff1626415ea726c55b23162ce59a
+gbrp16le            0ab77b498d4a39905515b6e1f0329ed2
 gbrp9be             170da3a8644cbea61c3caeadc45354c5
 gbrp9le             da5d80e6f12cabaa7081bb85d3b7fd30
 gray                57fd8e6e00f6be8752726005974cce1b
+gray10be            437713f3d081238cddb738e106e5a27d
+gray10le            c749b80049b152f4ba3e66a72c0c5acc
+gray12be            d34c50810b37e6f97dffdf6a8ab958de
+gray12le            cf71b8fee47ce7821f3ae9f9b62ae39a
 gray16be            e1700e056de9917744a7ff4ab2ca63fd
 gray16le            338de7ac5f7d36d5ad5ac2c8d5bbea68
+gray9be             25e50940fa300a8f09edfb6eba4fd250
+gray9le             1146cfc1b92bfd07ed238e65ffcd134f
 monob               2129cc72a484d7e10a44de9117aa9f80
 monow               03d783611d265cae78293f88ea126ea1
 nv12                16f7a46708ef25ebd0b72e47920cc11e
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-fieldorder b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-fieldorder
index 6dac63846a7..84a9e003c7e 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-fieldorder
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-fieldorder
@@ -19,6 +19,12 @@ bgra                5967b559257dbb6784f93b9d2bef4edd
 bgra64be            64a4ec15bc35ede2018f650b50c2429b
 bgra64le            5029192d0f32383c9f25f8e7da7cb5a0
 gbrap               00afb65d44bea99c31b318fdbeb3be10
+gbrap10be           8b27254a69cd0e25fa55262a743f95e6
+gbrap10le           52278021718ec370903dccc923dc8bf6
+gbrap12be           302b353dff696ec9fd0d85a0cc14802b
+gbrap12le           ae2d6db2c9c825f06d92389de21263d2
+gbrap16be           52c10d8046d123dfc4a478276906467c
+gbrap16le           2317737b8f5140add27d121de8f5ba95
 gbrp                506dea2fe492e985a396d1b11ccd8db3
 gbrp10be            55bbfe2d472780dcbadf3027778caa0e
 gbrp10le            13a39077ab1b2c3b49afd3e250b84a77
@@ -26,11 +32,19 @@ gbrp12be            f1b59334c687a39ba076fe47e6ee9515
 gbrp12le            e64ab4d290eb10476db165054720173f
 gbrp14be            b3806ade527ef7452c29106054946cd1
 gbrp14le            b01b1a05d8de36f51a133d25102fe1f3
+gbrp16be            f82e4bda468275f51becf70f3880be52
+gbrp16le            c7813a905f94aabb2bcade79c9b7e39e
 gbrp9be             b8d294d4bc81ceef1fb529e917c02e48
 gbrp9le             0d42cc9e222d806c33172781b45cb3e3
 gray                d96e0f1c73d3f0b9506d691b5cd36c73
+gray10be            c26c73de96b630f1207ff589b6553ebd
+gray10le            16e4db1d611ec3fa5c9fd8fbdbf1ffcc
+gray12be            1c3285c150e1dddcf0fbee405cfb068e
+gray12le            a57b6199f5690add0ac0150fa95c4988
 gray16be            293a36548ce16543494790f8f7f76a05
 gray16le            84f83f5fcbb5d458efb8395a50a3797e
+gray9be             ec877f5bcf0ea275a6f36c12cc9adf11
+gray9le             fba944fde7923d5089f4f52d12988b9e
 rgb0                2e3d8c91c7a83d451593dfd06607ff39
 rgb24               b82577f8215d3dc2681be60f1da247af
 rgb444be            1c3afc3a0c53c51139c76504f59bb1f4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-hflip b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-hflip
index f069fc67c7c..875980d8928 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-hflip
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-hflip
@@ -19,6 +19,12 @@ bgra                275f05a382bcbc9bc77c06b79e1d8a71
 bgra64be            1cabeafe9c21a4f7ccd976220f22ee5a
 bgra64le            1b15c01c94cf9af89273da1d1f994cff
 gbrap               bf6a2b2f206fbbb332a718fb570d7cb7
+gbrap10be           f188dc23756469cbdd172fe97ad58121
+gbrap10le           262f0501633ea4670020fae8ac6835e2
+gbrap12be           ffe9aa4cbcc42f71757efe18826764ac
+gbrap12le           88a85c1b3c5e19e299fdd209b73ac1ba
+gbrap16be           3117e84b258433a7efb9288bbb8815d4
+gbrap16le           3ad08cf8b49d8eb31a1b356ec4b7b88b
 gbrp                0ecfeca171ba3a1a2ff4e92f572b71cf
 gbrp10be            774398c2f81757a536c094f16cfc541a
 gbrp10le            e9a6434d691be541f789f850963da181
@@ -26,11 +32,19 @@ gbrp12be            13d819d869f8e84aadca57e21883030e
 gbrp12le            22046339442c155fbb9b02ceff5e1c15
 gbrp14be            7e1d2f9d9bb7cc90d88540f36998acd6
 gbrp14le            91bb636f4e1f5d50312b136c185542e9
+gbrp16be            46cf9473646a4b9dbcb05661ade658ec
+gbrp16le            6ce6093b24d09c0edcd55b2d6fec89a0
 gbrp9be             174de037c2a9f2b6fb4d9444ae0ff82f
 gbrp9le             ba7c2631fb2967aa909c66509bd243fe
 gray                8bd4ece1dbf89b20ee785e0515356e07
+gray10be            160dd03e30d33379de92c70ee52c01fd
+gray10le            6baac1da6be3789409b67cd506afe7da
+gray12be            de7b5ef4b513e7e8270c617249d1cbdf
+gray12le            e8d0739ff61649bd82722b3134cbe776
 gray16be            cf7294d9aa23e1b838692ec01ade587b
 gray16le            d91ce41e304419bcf32ac792f01bd64f
+gray9be             ac8d260669479ae720a5b6d4d8639e34
+gray9le             424fc581947bc8c357c9ec5e3c1c04d1
 nv12                801e58f1be5fd0b5bc4bf007c604b0b4
 nv21                9f10dfff8963dc327d3395af21f0554f
 p010be              744b13e44d39e1ff7588983fa03e0101
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-il b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-il
index 640a75a8557..c6885b970ef 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-il
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-il
@@ -19,6 +19,12 @@ bgra                e6ae08f06f157297296b319a249dddf5
 bgra64be            de7c036f20fc54d89690239cc6239678
 bgra64le            d1aa975fa03ce226008396b30a653420
 gbrap               575ff1fe5d7585ed82da1db35f106e4c
+gbrap10be           bafa57a2e4331d8a39f6f0087c85d4b1
+gbrap10le           553a1f439d8184dc400432d3f786fbce
+gbrap12be           48609d6b61ff6313939fa2d9c3ebb6d9
+gbrap12le           e3b5342c8e47820f2de7e2dd61872312
+gbrap16be           696c84c8b009c7320cad7f3847bb35da
+gbrap16le           9bacb81fbbe9cdfd04d71eb55a9719d2
 gbrp                dc06edb62e70024a216c8e303b79b328
 gbrp10be            321e7f061d8b9b5801221b6cf3c99666
 gbrp10le            799ed3afca01076439a0b6785b3dc4bb
@@ -26,11 +32,19 @@ gbrp12be            7ca179ad8f7b018de48a48bdb0776965
 gbrp12le            c69843651e7e60e85c5e8a2fe4ecb290
 gbrp14be            5dc5e8131c25125347758e03d15b69e6
 gbrp14le            bf3d5dec9b58cecd4ca1c5d3a4d57c31
+gbrp16be            c8c95027703c680ed8f8f91c725db40a
+gbrp16le            c95c9d7c2b19826b73ff1811d9fe6bdb
 gbrp9be             f029d87fa642f4261160471ad27fd53f
 gbrp9le             b310d3cf37f7b41d706155993f8f0584
 gray                52ae18648161ac43144f5c9cd2127786
+gray10be            8400dec0eefb172849b785d35fc55674
+gray10le            b7d6e49e8d1291f2b0a57d55e9478ef1
+gray12be            c62bc3def5ea217dfb68433905cb9d64
+gray12le            5bd0fef836928e1e19a315782a8c1302
 gray16be            92c3b09f371b610cc1b6a9776034f4d0
 gray16le            1db278d23a554e01910cedacc6c02521
+gray9be             ed7db5bb2ddc09bc26068c8b858db204
+gray9le             2ec9188f0dcfefef76a09f371d7beb8e
 monob               faba75df28033ba7ce3d82ff2a99ee68
 monow               6e9cfb8d3a344c5f0c3e1d5e1297e580
 nv12                3c3ba9b1b4c4dfff09c26f71b51dd146
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-lut b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-lut
index 1f7c2eaa0f3..db3fd417b7d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-lut
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-lut
@@ -3,44 +3,48 @@ argb                4f575be3cd02799389f581df99c4de38
 bgr24               fa43e3b2abfde8d9e60e157a9acc553d
 bgra                4e2e689897ee7a8e42b16234597bab35
 gbrap               0d1eb2c39e291c53c57302cdc653c2fc
+gbrap10le           fed58af6d557a7069a4a39e6d8f5f4e0
+gbrap12le           43fec231bd1d3dd957cdd8478cab9259
+gbrap16le           22ca3644658ae306541116c31e135074
 gbrp                e572d53183f3f2ed3951aa9940d440a1
 gbrp10le            a8fd1ebbc36a477e2b134241fed91687
 gbrp12le            c5a4b89571f7095eb737ad9fd6b1ee08
 gbrp14le            bdfdfd6f36c60497d1cdae791f3cc117
+gbrp16le            df095ef3a20995935cfcaf144afc68b6
 gbrp9le             a8c4e29f4cb627db81ba053e0853e702
 rgb24               a356171207723a580e7d277078072005
 rgb48le             5c7dd8575836d18c91e09f1915cf9aa9
 rgba                7bc854c2698b78af3e9159a19c2d9d21
 rgba64le            3a087ecab583d1930220592731f282b4
-yuv410p             51b39a0e33f108e652457a26667319ea
-yuv411p             9204c5af92aef4922a05f58c1f6c095e
-yuv420p             7c43bb0cae8dee633375c89295598508
-yuv420p10le         1352712dd31cce78bd5441294004cf85
-yuv420p12le         c66f82da9fda458ba3abda057c58e591
-yuv420p14le         e45cb5e2a75bf6143da0b55004767f78
-yuv420p16le         eff54782c51770edfd6b84c958ac7120
-yuv420p9le          4a6776b3379f12ad45caee8072a13695
-yuv422p             67df35da0c35e54882492b2365438254
-yuv422p10le         0158371a800294015def7f0ef66c78ea
-yuv422p12le         bc49d3863ffb89658a17bf8c4fe773b0
-yuv422p14le         b55cb791d286b0b3391fe7481785e5b3
-yuv422p16le         fc3b2ba889ffaf1633000fc774307c33
-yuv422p9le          6e2a42ae36ed5e8b5112987639728af5
-yuv440p             5e41adcfc27be4369afd217b61b2ffe3
-yuv440p10le         8b49714bba268fb4a79b5a84223ad17a
-yuv440p12le         15ab4f453238bd9c13b18af81e22f060
-yuv444p             a2b58590aef88db2c1f14a1a3a3b0359
-yuv444p10le         c076c20fc808f95b34adb88aca442f48
-yuv444p12le         af8d4dd88169d5cffc2f3fce6333a94c
-yuv444p14le         93367133e25d088d4535199ed1f1ed58
-yuv444p16le         800940feec14365ccd9b4863e38f6991
-yuv444p9le          c120044350852c4cd16a302dd1ceda79
-yuva420p            518a380bf1af60ef2ecf4754eec088e9
-yuva420p16le        72ad4fa535b007d122666ce103ef9c8b
-yuva422p            7110ac2e37377b05b6fc5ad967dfabb5
-yuva422p16le        e2867210660ada5784a60b4339ac52c0
-yuva444p            642f3958f141dece9e99407945e2ef43
-yuva444p16le        ab04ba8acbe38085b0df650d82065eb0
+yuv410p             10cf5dbbccb858a9ab51e0b8bf278f6d
+yuv411p             3f0bfa543ba513c6b6d7fff785fbe150
+yuv420p             ad99204ace669a383f8ae03a1ea5b98f
+yuv420p10le         f1e6cc4c2a5e9665dedd7ac0f2a4d551
+yuv420p12le         d9dfe871483b6a26512d427cb048ff65
+yuv420p14le         cd8bb4803f8e99c6cd31149bf848c30c
+yuv420p16le         4bb13820cf2de9b40ca47adeb7fea356
+yuv420p9le          f12c98b599e667fc45126d6dea7f0fd9
+yuv422p             c57e304bb3f4a1d30bf4ced5e829cdc6
+yuv422p10le         9d95b03f75ae5778804279f3c3135837
+yuv422p12le         08e73e233793740ad68a939b9886dd32
+yuv422p14le         bea6b54ec3e33eadfbd317a175b96288
+yuv422p16le         5438e5738ab3e1e5f7fce5faaac036c4
+yuv422p9le          222a699b69ba8d511518a61d77a10c25
+yuv440p             f8105ff9433ecdedf2645f3370a575d8
+yuv440p10le         6e104ac6c33b00185bb6d95b371e1354
+yuv440p12le         636834efcba838d74337b2ebb9dbffb3
+yuv444p             ca662e7bd7a28805650f25b1537d50a2
+yuv444p10le         c301eb2763e0f74fde94388046c437fa
+yuv444p12le         9482b13de4a9fbce176e8344c9332139
+yuv444p14le         fb558c97e59e884fe5ba407df158ebd5
+yuv444p16le         be9b3ce54168159b132746f7ac9088fe
+yuv444p9le          fa4b9bd6b8cac96e10322e613c8e7149
+yuva420p            7284cbf9eacf1ca5ce9e2efebcadf999
+yuva420p16le        b37d34212c2a79e91b675bc87dac6cc6
+yuva422p            5938a7c7588febb069bd0cd4c447305e
+yuva422p16le        c5ccfdc1a0dc6cb130c07ea61df6f727
+yuva444p            fbcbdc3521d17c702ee521b0893098e4
+yuva444p16le        b7142d28d4d069d7eb019dcaf8b323b1
 yuvj420p            65bc88887c7f06a6221155ca7f9cfca4
 yuvj422p            ff5baffefc8ffe4547653092fd7da200
 yuvj440p            ef3f27270e60ac06582e3ac7c2f3e6fa
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-null b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-null
index f19dcb09baf..124dddeacbe 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-null
@@ -19,6 +19,12 @@ bgra                3934fb81a602dfa7d29420b1a66f0fd8
 bgra64be            c8d3217bf58d34f080ac88c0b0012c77
 bgra64le            b71d75a928aac14cb768403e6f6a9910
 gbrap               98d30987407c51e5620921e11d40a4ff
+gbrap10be           edcffb185e44b6dae5c2ead5505b7125
+gbrap10le           2a7392e14b21b1f9457526a071236a6d
+gbrap12be           0c4c1f8af361571265ca259d5f70f026
+gbrap12le           5f1d8c663d4c28863e687192433b34a4
+gbrap16be           e4edca4361d643794034e5aa9ef290b1
+gbrap16le           9a95b389d2bf556179e8f4b27fb550ab
 gbrp                5fbc319e30110d19d539f5b274eddb6d
 gbrp10be            703a17591a2a5c236675c5101c349bcc
 gbrp10le            ee014153f55c011918df5b2394815780
@@ -26,11 +32,19 @@ gbrp12be            527d337eb5813ebba7cf969ee660d423
 gbrp12le            fd192920b171a0cf88d61e8310e95d81
 gbrp14be            46d502db6dc5eb7e9da3c60016b2df91
 gbrp14le            1607f5c8f13360b53b8186f523996b1b
+gbrp16be            7b6764a504c853b09f5c7d0b2223c5a4
+gbrp16le            fb9323a5bd060282bec7bfd7d38dc230
 gbrp9be             a4dc6f6f9bb051de2dc348b592ad4282
 gbrp9le             699da3a3b324f3fd001a56aee9683384
 gray                188590b1231afd231ea910815aef2b25
+gray10be            d486558ecd2e27afc17930be861f0e4c
+gray10le            917d687103b2adcca7132bfc070ca54a
+gray12be            9685614450f1282be433d2b07234ca1f
+gray12le            2700bd7fb3fea56e54eb03e31d6d4e57
 gray16be            08d997a3faa25a3db9d6be272d282eef
 gray16le            df65eb804360795e3e38a2701fa9641a
+gray9be             6382a14594a8b68f0ec7de25531f9334
+gray9le             4eb1dda58706436e3b69aef29b0089db
 monob               8b04f859fee6a0be856be184acd7a0b5
 monow               54d16d2c01abfd72ecdb5e51e283937c
 nv12                8e24feb2c544dc26a20047a71e4c27aa
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-pad b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-pad
index 88236b26b09..e777211cd9a 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-pad
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-pad
@@ -6,13 +6,20 @@ bgr0                32207a2de1b2ac7937e940a8459b97c0
 bgr24               f8b65ad845905c7d0c93ca28dfbb826f
 bgra                929aac15e848038e367c250037575f9f
 gbrap               5f16cccab5a17cb766c882e865995167
+gbrap10le           a677322100409f9b1d22136b14bfb534
+gbrap12le           e0e43f838cfbe98086042ba54b5f70be
+gbrap16le           0f4414db67b84a720106d7a3b2435766
 gbrp                3c94d39256db2409015df913fd330a90
 gbrp10le            5b356737cd8a396f39bbdadb7cb35e06
 gbrp12le            91fdad0d1edf7bfa2805e2041e8da3cd
 gbrp14le            deb2c3af6b48faa52f6a1f6590a0cdf7
+gbrp16le            a6156d1a37e05ee621b2a343fb158bd6
 gbrp9le             9e827f438e081d334a6cae7e282698b0
 gray                ddc663a0491df3959d9c5795dceaa72e
+gray10le            e6559c1c8c05ce89f44b465573db44e7
+gray12le            1e6c6757658c7ae8a1f830432c5b7722
 gray16le            468bda6155bdc7a7a20c34d6e599fd16
+gray9le             f8f3dfe31ca5fcba828285bceefdab9a
 nv12                381574979cb04be10c9168540310afad
 nv21                0fdeb2cdd56cf5a7147dc273456fa217
 rgb0                78d500c8361ab6423a4826a00268c908
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-scale b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-scale
index 63205577bba..f43c5194286 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-scale
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-scale
@@ -19,6 +19,12 @@ bgra                d8316272bc3a360ef9dff3ecc84520a3
 bgra64be            4e6a1b9f9c18b881c27d76611d45f737
 bgra64le            efeee0abcc658ebcff049d5e74d74943
 gbrap               4a100f750ac846b34bfeef0d6893c3de
+gbrap10be           6d89abb9248006c3e9017545e9474654
+gbrap10le           cf974e23f485a10740f5de74a5c8c3df
+gbrap12be           1d9b57766ba9c2192403f43967cb9af0
+gbrap12le           bb1ba1c157717db3dd612a76d38a018e
+gbrap16be           c72b935a6e57a8e1c37bff08c2db55b1
+gbrap16le           13eb0e62b1ac9c1c86c81521eaefab5f
 gbrp                dc3387f925f972c61aae7eb23cdc19f0
 gbrp10be            0277d4c3a8498d75e2783fb81379e481
 gbrp10le            f3d70f8ab845c3c9b8f7452e4a6e285a
@@ -26,11 +32,19 @@ gbrp12be            fbd4e149c452c351c6d1c11d6b6e176a
 gbrp12le            c51d51c3b753d735eb22983397262c88
 gbrp14be            cd20808592e62cc439786c18a14b3e70
 gbrp14le            456f7d1ff5990aa6379137d84dd63862
+gbrp16be            5fc826cfabebfc1442cb793c4b6303e2
+gbrp16le            1b3e0b63d47a3e1b6b20931316883bf2
 gbrp9be             d9c88968001e1452ff31fbc8d16b18a0
 gbrp9le             2ccfed0816bf6bd4bb3a5b7591d9603a
 gray                221201cc7cfc4964eacd8b3e426fd276
+gray10be            9452756d0b37f4f5c7cae7635e22d747
+gray10le            37fd2e1ec6b66410212d39a342e864df
+gray12be            950de5d1b6b943a26c51f6a157e19a14
+gray12le            9c3b154a8bb0a73a3b465892dbc23b36
 gray16be            32891cb0928b1119d8d43a6e1bef0e2b
 gray16le            f96cfb5652b090dad52615930f0ce65f
+gray9be             779dec0c6c2df008128b91622a20daf8
+gray9le             fa87a96ca275f82260358635f838b514
 monob               f01cb0b623357387827902d9d0963435
 monow               35c68b86c226d6990b2dcb573a05ff6b
 nv12                b118d24a3653fe66e5d9e079033aef79
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_cvlpf b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_cvlpf
new file mode 100644
index 00000000000..99703fa1afd
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_cvlpf
@@ -0,0 +1,25 @@
+gray                9849d71519ae9c584ae8abfa8adb2f8e
+yuv410p             44ee4b74b95c82d6f79ddf53b5e3aa9d
+yuv411p             5fa9d1fba7adfd6f7fa04464332b631a
+yuv420p             ee9591ea3ab06c73be902c4b8868c69e
+yuv420p10le         19b2dcf5e82725b2c9e366d5d3a4b67b
+yuv420p12le         e5b76eb58cab2dfa42738f665d8b8059
+yuv422p             b1be7b55567bde86d655adf80fac1257
+yuv422p10le         66f7433c7423d6289ee20c19c4e8dd90
+yuv422p12le         b4a4b5ed81341b36f685b14b2bb8a798
+yuv440p             ddf6ee697f4ff4f90d501e6869392309
+yuv440p10le         7e44a92d9e47e15f0728b125725ccd41
+yuv440p12le         c2cac82661e10be4917bd9dacb419fce
+yuv444p             7cb5d0c0997c8c2545a16bfc4cb9fd6d
+yuv444p10le         08fb13c69b40229014a6ccf0bdd5498f
+yuv444p12le         796c5559b9f426470eb2997c21be5d14
+yuva420p            ee0761e2f76ec441c545feede77103e4
+yuva420p10le        4bb6b3a1cbf2fd1fe5aefcc11ce8029f
+yuva422p            a8da2806e21a88449079faa7f4303ffa
+yuva422p10le        d2965b5b5a43a7165badaff0718a17d8
+yuva444p            a3f57734d6f72bdf37f8f612ea7cce63
+yuva444p10le        e020512901fd9ac7088898a4e3a8c7c1
+yuvj420p            9f358e311b694bcd01e1a07d1120ade5
+yuvj422p            9a7628a9f1630d35c7176951ddc1b2f6
+yuvj440p            112fe35292c687746ec0c622a42c611b
+yuvj444p            f894438f40950229baa02545daa8812a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_merge b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_merge
index e5d3bf0383b..fa6151c2728 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_merge
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_merge
@@ -2,12 +2,23 @@ gray                fab3a7abc4f076cf926205aeacadbe51
 yuv410p             d4506e49eeb64c7ce714c07597e7dd69
 yuv411p             2e8bb385cb4a53a0f3771815020f7213
 yuv420p             c967d3d5f3200d1b2417b0f2356f12fc
+yuv420p10le         404d90eca9b93f7c0949be23187804c7
+yuv420p12le         eb2ef81b82f1342618e4c9fe8e086592
 yuv422p             febaa84ea2e3246af742a7ed37c030f6
+yuv422p10le         0dc5f3833c0f11a0fcd0422d76508c10
+yuv422p12le         190eb7e76af5fc481588ded472901b58
 yuv440p             13a934b42df65f11e153314ebb4f311e
+yuv440p10le         7fabea51d6e52b718ef3ab919b24f8d2
+yuv440p12le         c7b138374a18f258bdd1a2d21b4421b0
 yuv444p             45d4466f5689942a4effb0fd23e44949
+yuv444p10le         fde95627ba0e66be7ec863386b3e5ca6
+yuv444p12le         c1e15c934ce3bc562a869dd78c75db17
 yuva420p            dc1173a07c3f993b277ea0c94d513e1f
+yuva420p10le        d85972762437105a932759c4bb9759c9
 yuva422p            ca200be80e5bfdb159e1aea57129ed3a
+yuva422p10le        06d4f79ee2ddf31d9fe15af8ca573f46
 yuva444p            9f39c35d6899dcb8b9a9b07c339ca365
+yuva444p10le        b0c54fc3efad73f252d86127407aa1fd
 yuvj420p            844359293bb6ff81549f3fc0090cc587
 yuvj422p            526af049d43974822baa7b48aa1e1098
 yuvj440p            af9285194da8efbc40d93bf8109f9dc5
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_pad b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_pad
index dcf2168fe1b..8f6b1c42e20 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_pad
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_pad
@@ -2,12 +2,23 @@ gray                7ef396fecd8d1c9fe32173e4415ba671
 yuv410p             35bc11d0d32efc9e9a969be7d720f4e6
 yuv411p             17ef3cd22a74f7368b5e02f68779f294
 yuv420p             93d5b6a4c44d67e4d4447e8dd0bf3d33
+yuv420p10le         14e754c6e9d41cb048ce3c93512d7d35
+yuv420p12le         ce54a2e38d121a7575dff30542facaad
 yuv422p             3ee40b0b6533b9183764b85c853ec3f9
+yuv422p10le         d4b61a84b93e74b07b7020ceed40e39e
+yuv422p12le         8fd90be12a97307645ecfcd09d576643
 yuv440p             1d3c1258a51d09e778cd8368b1a4126f
+yuv440p10le         29d116cb550a05920e5619ab58284d30
+yuv440p12le         d7518f941a3b2c137f944afe9da816a1
 yuv444p             1093568ad8f479ec20e738d018dd3f8f
+yuv444p10le         c65233e1d8b01f3369c20738f7386801
+yuv444p12le         70dc51a857bfb215b3a81fceb114b74c
 yuva420p            4588aef20c0010e514550c9391219724
+yuva420p10le        3181e84fd7aaed606bb86eecd2e13f20
 yuva422p            3426ed1ac9429202d8c29fa62a04d4c3
+yuva422p10le        c00acd7c437d41755dff09c5ca3642cf
 yuva444p            1b9fc791c7d774b4ba8c9dc836f78cf5
+yuva444p10le        616b42a232c83b8f9e5c5168ec4b5da5
 yuvj420p            9a872e0c1b3c0b6fe856415696b758bd
 yuvj422p            da3c9ef25528a2ee96746ce44e6969f3
 yuvj440p            a9a5495c6b0e2bf6e561998ea1c356a7
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_vlpf b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_vlpf
new file mode 100644
index 00000000000..5a5f80b115e
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-tinterlace_vlpf
@@ -0,0 +1,25 @@
+gray                b79791449947c25cd5b36d9d3b9d1831
+yuv410p             5bc03f4cf6b441b421f0fdaeeff1e9ed
+yuv411p             19046df1876c46ed1ef0458680270bd3
+yuv420p             69c743b84996be9430b051a55cfbcb29
+yuv420p10le         85948ad609abded6b50882d459f5a2f8
+yuv420p12le         7cebe45f51bdadc766f66c68db8d347d
+yuv422p             d710ccd1941f6f389c97a09bc977e709
+yuv422p10le         c54873f77dac1d710fb2aa1b0ce2669c
+yuv422p12le         94a527bb787b9d121ffbbcb3a6c545d8
+yuv440p             1a482a23fe5a9b7d02388c299fd0a423
+yuv440p10le         506efa287ecce9c951da2039fa1de2ae
+yuv440p12le         631bcf190f409ccbc5c27b9f0f6ba5e2
+yuv444p             c968a92f4b7ab6706ee9b425eb5345b5
+yuv444p10le         0af437e635d49feccf7dfae201e6dfc5
+yuv444p12le         2e9e9f7caae1fae3b026810246fc6ac1
+yuva420p            3f89a166f309c0cda8b91a9e8a0ce937
+yuva420p10le        79de1cc549c03d4893cf6f1aca86e057
+yuva422p            ef8fdbe910d68e88e98227b0e99fb5a6
+yuva422p10le        257a4aec41f9b5412179272d8a7fb6f7
+yuva444p            3662eadd5f61a6edbc9d715ea8591415
+yuva444p10le        0905cf5b7f42c11be3f0486a66533c71
+yuvj420p            14c4390b319c5d679184503309060ac3
+yuvj422p            bbe00a26526931b72a024febe1cd6b90
+yuvj440p            f654cf28b7879c6a6c950c3cb9612580
+yuvj444p            c162a4fe7a665f4abf257443703f0d72
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-vflip b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-vflip
index 57dbca8bab1..84b9d56858a 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-vflip
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-pixfmts-vflip
@@ -19,6 +19,12 @@ bgra                0af63cc2ffd61af252df93cc767de358
 bgra64be            31af33833f6d8f2e4a62683288770aa4
 bgra64le            45feb93863055282447d1ff89c5158bf
 gbrap               421c56a25f88d58b9361f5c7bb368e21
+gbrap10be           e8134b72acc090b093b4d9b4d4703c7e
+gbrap10le           43bde7bd6a676c6ac33dbcc4c72762f3
+gbrap12be           16a3d105ba852a9fa23ea5232db51b48
+gbrap12le           6ef8a3ac4129ec23c34aec14ac41f249
+gbrap16be           70b020b6b9e1896b72f890de3570ffda
+gbrap16le           e0cf341cdbaf1f5c40016f181bc9d7d4
 gbrp                413b0f6ea51588d4be5f0c76d43d8796
 gbrp10be            d02bd50db83213667808f5bacefe667c
 gbrp10le            2d4a5ebc773ffc3d857a6ef24afbe10e
@@ -26,11 +32,19 @@ gbrp12be            a668b7dba68817736501386ffe9f3adc
 gbrp12le            299695016c22a4947d94b16f0975536b
 gbrp14be            eeebacfb19c970dd76ad044ef85e8fe5
 gbrp14le            6e93b87047e433995111eb5397751c3f
+gbrp16be            3fef87fe67bf1fd0e2f5056dc0db2ef4
+gbrp16le            f3b2b76fe707f77eb1376640759f5168
 gbrp9be             99c694dd47d12ae48fc8f47a0c410333
 gbrp9le             26e103a4ab99fb3f58667df490997a36
 gray                41811422d5819ed69389357294384c10
+gray10be            52710b3ab3ccf6101d28109f58cd48c4
+gray10le            9c432a163f0cfe9ee2a4b72ae8a7c307
+gray12be            7423ce8a77fbc40c5d4776eb28fec60a
+gray12le            808158633559d7deebc7dac2d79e88f8
 gray16be            29f24ba7cb0fc4fd2ae78963d008f6e6
 gray16le            a37e9c4ea76e8eeddc2af8f600ba2c10
+gray9be             dda11d4ffd62b414012ffc4667fb4971
+gray9le             159bf6482d217b2b8276eb2216cd7a09
 monob               7810c4857822ccfc844d78f5e803269a
 monow               90a947bfcd5f2261e83b577f48ec57b1
 nv12                261ebe585ae2aa4e70d39a10c1679294
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-psnr-rgb b/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-psnr-rgb
new file mode 100644
index 00000000000..f06db575ac4
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-psnr-rgb
@@ -0,0 +1,45 @@
+frame:0    pts:0       pts_time:0
+lavfi.psnr.mse.r=1381.80
+lavfi.psnr.psnr.r=16.73
+lavfi.psnr.mse.g=896.00
+lavfi.psnr.psnr.g=18.61
+lavfi.psnr.mse.b=277.38
+lavfi.psnr.psnr.b=23.70
+lavfi.psnr.mse_avg=851.73
+lavfi.psnr.psnr_avg=18.83
+frame:1    pts:1       pts_time:1
+lavfi.psnr.mse.r=1380.37
+lavfi.psnr.psnr.r=16.73
+lavfi.psnr.mse.g=975.91
+lavfi.psnr.psnr.g=18.24
+lavfi.psnr.mse.b=435.72
+lavfi.psnr.psnr.b=21.74
+lavfi.psnr.mse_avg=930.67
+lavfi.psnr.psnr_avg=18.44
+frame:2    pts:2       pts_time:2
+lavfi.psnr.mse.r=1403.20
+lavfi.psnr.psnr.r=16.66
+lavfi.psnr.mse.g=954.05
+lavfi.psnr.psnr.g=18.34
+lavfi.psnr.mse.b=494.22
+lavfi.psnr.psnr.b=21.19
+lavfi.psnr.mse_avg=950.49
+lavfi.psnr.psnr_avg=18.35
+frame:3    pts:3       pts_time:3
+lavfi.psnr.mse.r=1452.80
+lavfi.psnr.psnr.r=16.51
+lavfi.psnr.mse.g=1001.02
+lavfi.psnr.psnr.g=18.13
+lavfi.psnr.mse.b=557.39
+lavfi.psnr.psnr.b=20.67
+lavfi.psnr.mse_avg=1003.74
+lavfi.psnr.psnr_avg=18.11
+frame:4    pts:4       pts_time:4
+lavfi.psnr.mse.r=1401.25
+lavfi.psnr.psnr.r=16.67
+lavfi.psnr.mse.g=1009.80
+lavfi.psnr.psnr.g=18.09
+lavfi.psnr.mse.b=602.42
+lavfi.psnr.psnr.b=20.33
+lavfi.psnr.mse_avg=1004.49
+lavfi.psnr.psnr_avg=18.11
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-psnr-yuv b/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-psnr-yuv
new file mode 100644
index 00000000000..0e634ed0e45
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-psnr-yuv
@@ -0,0 +1,45 @@
+frame:0    pts:0       pts_time:0
+lavfi.psnr.mse.y=222.06
+lavfi.psnr.psnr.y=24.67
+lavfi.psnr.mse.u=339.38
+lavfi.psnr.psnr.u=22.82
+lavfi.psnr.mse.v=705.41
+lavfi.psnr.psnr.v=19.65
+lavfi.psnr.mse_avg=372.23
+lavfi.psnr.psnr_avg=22.42
+frame:1    pts:1       pts_time:1
+lavfi.psnr.mse.y=236.74
+lavfi.psnr.psnr.y=24.39
+lavfi.psnr.mse.u=416.17
+lavfi.psnr.psnr.u=21.94
+lavfi.psnr.mse.v=704.98
+lavfi.psnr.psnr.v=19.65
+lavfi.psnr.mse_avg=398.66
+lavfi.psnr.psnr_avg=22.12
+frame:2    pts:2       pts_time:2
+lavfi.psnr.mse.y=234.79
+lavfi.psnr.psnr.y=24.42
+lavfi.psnr.mse.u=435.72
+lavfi.psnr.psnr.u=21.74
+lavfi.psnr.mse.v=699.60
+lavfi.psnr.psnr.v=19.68
+lavfi.psnr.mse_avg=401.23
+lavfi.psnr.psnr_avg=22.10
+frame:3    pts:3       pts_time:3
+lavfi.psnr.mse.y=250.88
+lavfi.psnr.psnr.y=24.14
+lavfi.psnr.mse.u=479.73
+lavfi.psnr.psnr.u=21.32
+lavfi.psnr.mse.v=707.55
+lavfi.psnr.psnr.v=19.63
+lavfi.psnr.mse_avg=422.26
+lavfi.psnr.psnr_avg=21.88
+frame:4    pts:4       pts_time:4
+lavfi.psnr.mse.y=241.05
+lavfi.psnr.psnr.y=24.31
+lavfi.psnr.mse.u=505.04
+lavfi.psnr.psnr.u=21.10
+lavfi.psnr.mse.v=716.00
+lavfi.psnr.psnr.v=19.58
+lavfi.psnr.mse_avg=425.79
+lavfi.psnr.psnr_avg=21.84
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-ssim-rgb b/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-ssim-rgb
new file mode 100644
index 00000000000..8c23c60b371
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-ssim-rgb
@@ -0,0 +1,30 @@
+frame:0    pts:0       pts_time:0
+lavfi.ssim.R=0.72
+lavfi.ssim.G=0.76
+lavfi.ssim.B=0.89
+lavfi.ssim.All=0.79
+lavfi.ssim.dB=6.74
+frame:1    pts:1       pts_time:1
+lavfi.ssim.R=0.70
+lavfi.ssim.G=0.74
+lavfi.ssim.B=0.85
+lavfi.ssim.All=0.77
+lavfi.ssim.dB=6.31
+frame:2    pts:2       pts_time:2
+lavfi.ssim.R=0.71
+lavfi.ssim.G=0.75
+lavfi.ssim.B=0.84
+lavfi.ssim.All=0.76
+lavfi.ssim.dB=6.29
+frame:3    pts:3       pts_time:3
+lavfi.ssim.R=0.70
+lavfi.ssim.G=0.73
+lavfi.ssim.B=0.83
+lavfi.ssim.All=0.76
+lavfi.ssim.dB=6.11
+frame:4    pts:4       pts_time:4
+lavfi.ssim.R=0.71
+lavfi.ssim.G=0.74
+lavfi.ssim.B=0.80
+lavfi.ssim.All=0.75
+lavfi.ssim.dB=6.05
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-ssim-yuv b/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-ssim-yuv
new file mode 100644
index 00000000000..5c8ffb94830
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-refcmp-ssim-yuv
@@ -0,0 +1,30 @@
+frame:0    pts:0       pts_time:0
+lavfi.ssim.Y=0.80
+lavfi.ssim.U=0.76
+lavfi.ssim.V=0.69
+lavfi.ssim.All=0.76
+lavfi.ssim.dB=6.25
+frame:1    pts:1       pts_time:1
+lavfi.ssim.Y=0.80
+lavfi.ssim.U=0.73
+lavfi.ssim.V=0.68
+lavfi.ssim.All=0.75
+lavfi.ssim.dB=6.08
+frame:2    pts:2       pts_time:2
+lavfi.ssim.Y=0.80
+lavfi.ssim.U=0.73
+lavfi.ssim.V=0.68
+lavfi.ssim.All=0.75
+lavfi.ssim.dB=6.10
+frame:3    pts:3       pts_time:3
+lavfi.ssim.Y=0.79
+lavfi.ssim.U=0.72
+lavfi.ssim.V=0.68
+lavfi.ssim.All=0.75
+lavfi.ssim.dB=5.94
+frame:4    pts:4       pts_time:4
+lavfi.ssim.Y=0.80
+lavfi.ssim.U=0.72
+lavfi.ssim.V=0.68
+lavfi.ssim.All=0.75
+lavfi.ssim.dB=5.97
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-rgbtestsrc b/mythtv/external/FFmpeg/tests/ref/fate/filter-rgbtestsrc
new file mode 100644
index 00000000000..e18d364fdb3
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-rgbtestsrc
@@ -0,0 +1,10 @@
+#tb 0: 1/5
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 320x240
+#sar 0: 1/1
+0,          0,          0,        1,   230400, 0x8c0018bb
+0,          1,          1,        1,   230400, 0x8c0018bb
+0,          2,          2,        1,   230400, 0x8c0018bb
+0,          3,          3,        1,   230400, 0x8c0018bb
+0,          4,          4,        1,   230400, 0x8c0018bb
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-scale2ref_keep_aspect b/mythtv/external/FFmpeg/tests/ref/fate/filter-scale2ref_keep_aspect
new file mode 100644
index 00000000000..8dd0dbb13bb
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-scale2ref_keep_aspect
@@ -0,0 +1,14 @@
+#format: frame checksums
+#version: 2
+#hash: MD5
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 160x120
+#sar 0: 1/1
+#stream#, dts,        pts, duration,     size, hash
+0,          0,          0,        1,    57600, 9a19c23dc3a557786840d0098606d5f1
+0,          1,          1,        1,    57600, e6fbdabaf1bb0d28afc648ed4d27e9f0
+0,          2,          2,        1,    57600, 52924ed0a751214c50fb2e7a626c8cc5
+0,          3,          3,        1,    57600, 67d5fd6ee71793f1cf8794d1c27afdce
+0,          4,          4,        1,    57600, 85f7775f7b01afd369fc8919dc759d30
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-silenceremove b/mythtv/external/FFmpeg/tests/ref/fate/filter-silenceremove
index 43360e8dbc5..81647c60ba8 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-silenceremove
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-silenceremove
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 192000
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,        1,        4, 0x00200008
 0,          1,          1,        1,        4, 0x00180006
 0,          2,          2,        1,        4, 0x001c0007
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-smptebars b/mythtv/external/FFmpeg/tests/ref/fate/filter-smptebars
new file mode 100644
index 00000000000..2242aef5760
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-smptebars
@@ -0,0 +1,10 @@
+#tb 0: 1/5
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 320x240
+#sar 0: 1/1
+0,          0,          0,        1,   115200, 0x87d91dc5
+0,          1,          1,        1,   115200, 0x87d91dc5
+0,          2,          2,        1,   115200, 0x87d91dc5
+0,          3,          3,        1,   115200, 0x87d91dc5
+0,          4,          4,        1,   115200, 0x87d91dc5
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-smptehdbars b/mythtv/external/FFmpeg/tests/ref/fate/filter-smptehdbars
new file mode 100644
index 00000000000..7a105fb69ed
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-smptehdbars
@@ -0,0 +1,10 @@
+#tb 0: 1/5
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 320x240
+#sar 0: 1/1
+0,          0,          0,        1,   230400, 0x85f40706
+0,          1,          1,        1,   230400, 0x85f40706
+0,          2,          2,        1,   230400, 0x85f40706
+0,          3,          3,        1,   230400, 0x85f40706
+0,          4,          4,        1,   230400, 0x85f40706
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-stereotools b/mythtv/external/FFmpeg/tests/ref/fate/filter-stereotools
index 89babd693dd..60acaf81b27 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-stereotools
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-stereotools
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x48b6d241
 0,       1024,       1024,     1024,     4096, 0xe0c4ca9a
 0,       2048,       2048,     1024,     4096, 0x6dd8e26c
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-testsrc2-rgba b/mythtv/external/FFmpeg/tests/ref/fate/filter-testsrc2-rgba
new file mode 100644
index 00000000000..42ecfe571d0
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-testsrc2-rgba
@@ -0,0 +1,75 @@
+#tb 0: 1/7
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 320x240
+#sar 0: 1/1
+0,          0,          0,        1,   307200, 0xa2e60897
+0,          1,          1,        1,   307200, 0x67f03406
+0,          2,          2,        1,   307200, 0x683843a1
+0,          3,          3,        1,   307200, 0x285a682c
+0,          4,          4,        1,   307200, 0x7444a71e
+0,          5,          5,        1,   307200, 0xde9e40d7
+0,          6,          6,        1,   307200, 0xc8bbd13d
+0,          7,          7,        1,   307200, 0x6f179555
+0,          8,          8,        1,   307200, 0x274254c9
+0,          9,          9,        1,   307200, 0xb3ee50db
+0,         10,         10,        1,   307200, 0x0ebe40d8
+0,         11,         11,        1,   307200, 0xa8216930
+0,         12,         12,        1,   307200, 0x467778e2
+0,         13,         13,        1,   307200, 0xe6b02e74
+0,         14,         14,        1,   307200, 0x18a5a923
+0,         15,         15,        1,   307200, 0x3ff2086b
+0,         16,         16,        1,   307200, 0x71ebe464
+0,         17,         17,        1,   307200, 0x671cf604
+0,         18,         18,        1,   307200, 0xe55dfee7
+0,         19,         19,        1,   307200, 0xc9c497ea
+0,         20,         20,        1,   307200, 0xb263b768
+0,         21,         21,        1,   307200, 0xd24ee5a8
+0,         22,         22,        1,   307200, 0x9b77a2b7
+0,         23,         23,        1,   307200, 0x729c1b08
+0,         24,         24,        1,   307200, 0x725574db
+0,         25,         25,        1,   307200, 0x413cf660
+0,         26,         26,        1,   307200, 0xe8db86b0
+0,         27,         27,        1,   307200, 0xf538a378
+0,         28,         28,        1,   307200, 0x89638534
+0,         29,         29,        1,   307200, 0x0858618b
+0,         30,         30,        1,   307200, 0x8b5f961c
+0,         31,         31,        1,   307200, 0xddbb5e48
+0,         32,         32,        1,   307200, 0x9352a610
+0,         33,         33,        1,   307200, 0xcf466635
+0,         34,         34,        1,   307200, 0xaf69099c
+0,         35,         35,        1,   307200, 0x18811110
+0,         36,         36,        1,   307200, 0x7b7dcbd1
+0,         37,         37,        1,   307200, 0x27e2f523
+0,         38,         38,        1,   307200, 0x563debe1
+0,         39,         39,        1,   307200, 0x48c71784
+0,         40,         40,        1,   307200, 0x4b6476b4
+0,         41,         41,        1,   307200, 0xa7a21b13
+0,         42,         42,        1,   307200, 0xd14d86c0
+0,         43,         43,        1,   307200, 0x12b1caef
+0,         44,         44,        1,   307200, 0xae58ad7e
+0,         45,         45,        1,   307200, 0x908bbb66
+0,         46,         46,        1,   307200, 0xc6d4f77e
+0,         47,         47,        1,   307200, 0x08a90cdf
+0,         48,         48,        1,   307200, 0x6c344d22
+0,         49,         49,        1,   307200, 0xb351a388
+0,         50,         50,        1,   307200, 0x8209bbff
+0,         51,         51,        1,   307200, 0xfa1e34e0
+0,         52,         52,        1,   307200, 0x76dd4c48
+0,         53,         53,        1,   307200, 0xb01ab30f
+0,         54,         54,        1,   307200, 0x2e2ec7c5
+0,         55,         55,        1,   307200, 0x6382f929
+0,         56,         56,        1,   307200, 0xa5cfce14
+0,         57,         57,        1,   307200, 0xd9339546
+0,         58,         58,        1,   307200, 0xf5b9a815
+0,         59,         59,        1,   307200, 0x99bbc602
+0,         60,         60,        1,   307200, 0x642242e6
+0,         61,         61,        1,   307200, 0x9626ad04
+0,         62,         62,        1,   307200, 0xba276036
+0,         63,         63,        1,   307200, 0x04bb2e18
+0,         64,         64,        1,   307200, 0x57bf0cc6
+0,         65,         65,        1,   307200, 0xce4c0f05
+0,         66,         66,        1,   307200, 0x9fa71634
+0,         67,         67,        1,   307200, 0xb0525b7f
+0,         68,         68,        1,   307200, 0x5a6c7523
+0,         69,         69,        1,   307200, 0x1dfc11fa
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-tremolo b/mythtv/external/FFmpeg/tests/ref/fate/filter-tremolo
index ed0e662a60a..c6cff52c0e1 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/filter-tremolo
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-tremolo
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1024,     4096, 0x5d3be907
 0,       1024,       1024,     1024,     4096, 0xea151fbe
 0,       2048,       2048,     1024,     4096, 0xa5bc19f4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-yuvtestsrc-yuv444p b/mythtv/external/FFmpeg/tests/ref/fate/filter-yuvtestsrc-yuv444p
new file mode 100644
index 00000000000..44fcf084411
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-yuvtestsrc-yuv444p
@@ -0,0 +1,10 @@
+#tb 0: 1/5
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 320x240
+#sar 0: 1/1
+0,          0,          0,        1,   230400, 0x0e1e2a4f
+0,          1,          1,        1,   230400, 0x0e1e2a4f
+0,          2,          2,        1,   230400, 0x0e1e2a4f
+0,          3,          3,        1,   230400, 0x0e1e2a4f
+0,          4,          4,        1,   230400, 0x0e1e2a4f
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/filter-yuvtestsrc-yuv444p12 b/mythtv/external/FFmpeg/tests/ref/fate/filter-yuvtestsrc-yuv444p12
new file mode 100644
index 00000000000..8abac6f9d9e
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/filter-yuvtestsrc-yuv444p12
@@ -0,0 +1,10 @@
+#tb 0: 1/5
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 320x240
+#sar 0: 1/1
+0,          0,          0,        1,   460800, 0x3ec49be7
+0,          1,          1,        1,   460800, 0x3ec49be7
+0,          2,          2,        1,   460800, 0x3ec49be7
+0,          3,          3,        1,   460800, 0x3ec49be7
+0,          4,          4,        1,   460800, 0x3ec49be7
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fits-demux b/mythtv/external/FFmpeg/tests/ref/fate/fits-demux
new file mode 100644
index 00000000000..85605ab11ae
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fits-demux
@@ -0,0 +1,10 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: fits
+#dimensions 0: 72x36
+#sar 0: 0/1
+0,          0,          0,        1,    14320, 0x0ecf72e0
+0,          1,          1,        1,    14320, 0xd94af6eb
+0,          2,          2,        1,    14320, 0x15c21892
+0,          3,          3,        1,    14320, 0xb18adc01
+0,          4,          4,        1,    14320, 0xc2be706d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-bitpix-32 b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-bitpix-32
new file mode 100644
index 00000000000..9bce3615550
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-bitpix-32
@@ -0,0 +1,6 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 102x109
+#sar 0: 0/1
+0,          0,          0,        1,    22236, 0x34490902
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-bitpix-64 b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-bitpix-64
new file mode 100644
index 00000000000..9febdd68f4d
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-bitpix-64
@@ -0,0 +1,6 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 77x173
+#sar 0: 0/1
+0,          0,          0,        1,    26642, 0x0ad2a46a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-blank_bitpix32 b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-blank_bitpix32
new file mode 100644
index 00000000000..184fd41c59e
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-blank_bitpix32
@@ -0,0 +1,6 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 256x256
+#sar 0: 0/1
+0,          0,          0,        1,   131072, 0x7fb22427
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-ext_data_min_max b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-ext_data_min_max
new file mode 100644
index 00000000000..9009a4efb34
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-ext_data_min_max
@@ -0,0 +1,6 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 512x512
+#sar 0: 0/1
+0,          0,          0,        1,   524288, 0xc327ed23
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gbrap16 b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gbrap16
new file mode 100644
index 00000000000..78abb5cde7e
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gbrap16
@@ -0,0 +1,6 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,   131072, 0x487894b2
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gbrp b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gbrp
new file mode 100644
index 00000000000..8767b6715f1
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gbrp
@@ -0,0 +1,6 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    49152, 0x565c3dee
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gbrp16 b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gbrp16
new file mode 100644
index 00000000000..f6368f2c024
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gbrp16
@@ -0,0 +1,6 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    98304, 0x1b917bdc
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gray b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gray
new file mode 100644
index 00000000000..425b31fc0f1
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-gray
@@ -0,0 +1,6 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    16384, 0xd788a2d2
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-multi b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-multi
new file mode 100644
index 00000000000..f24f0adaab1
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsdec-multi
@@ -0,0 +1,10 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 72x36
+#sar 0: 0/1
+0,          0,          0,        1,    10368, 0xb4490cc8
+0,          1,          1,        1,    10368, 0x37198e4f
+0,          2,          2,        1,    10368, 0x1e89afe7
+0,          3,          3,        1,    10368, 0x80127365
+0,          4,          4,        1,    10368, 0xfd2d07d1
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrap b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrap
new file mode 100644
index 00000000000..3e32fc687e3
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrap
@@ -0,0 +1,10 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: fits
+#dimensions 0: 72x36
+#sar 0: 0/1
+0,          0,          0,        1,    11520, 0xeb0a0cc8
+0,          1,          1,        1,    11520, 0x9d7d8e4f
+0,          2,          2,        1,    11520, 0xd9e6afe7
+0,          3,          3,        1,    11520, 0x75bd7365
+0,          4,          4,        1,    11520, 0x86f107d1
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrap16be b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrap16be
new file mode 100644
index 00000000000..1f74f4e750b
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrap16be
@@ -0,0 +1,10 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: fits
+#dimensions 0: 72x36
+#sar 0: 0/1
+0,          0,          0,        1,    23040, 0xfa4ff4f0
+0,          1,          1,        1,    23040, 0xf57102d4
+0,          2,          2,        1,    23040, 0x58e0294d
+0,          3,          3,        1,    23040, 0x8097502a
+0,          4,          4,        1,    23040, 0x65fd7b54
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrp b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrp
new file mode 100644
index 00000000000..4101a0e4522
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrp
@@ -0,0 +1,10 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: fits
+#dimensions 0: 72x36
+#sar 0: 0/1
+0,          0,          0,        1,     8640, 0xf6b9f643
+0,          1,          1,        1,     8640, 0x250d77d9
+0,          2,          2,        1,     8640, 0x652595e5
+0,          3,          3,        1,     8640, 0x4b8e5963
+0,          4,          4,        1,     8640, 0xd8d611ab
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrp16be b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrp16be
new file mode 100644
index 00000000000..d4b043ffe68
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gbrp16be
@@ -0,0 +1,10 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: fits
+#dimensions 0: 72x36
+#sar 0: 0/1
+0,          0,          0,        1,    17280, 0x6b87eec5
+0,          1,          1,        1,    17280, 0x1bf0fc9a
+0,          2,          2,        1,    17280, 0xaf071b1e
+0,          3,          3,        1,    17280, 0xfbe941fb
+0,          4,          4,        1,    17280, 0xbbc26d01
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gray b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gray
new file mode 100644
index 00000000000..46eb76c43ba
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gray
@@ -0,0 +1,10 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: fits
+#dimensions 0: 72x36
+#sar 0: 0/1
+0,          0,          0,        1,     2880, 0xd2d83752
+0,          1,          1,        1,     2880, 0x77246e79
+0,          2,          2,        1,     2880, 0xdf480c1f
+0,          3,          3,        1,     2880, 0x559247a9
+0,          4,          4,        1,     2880, 0xc3df2cc4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gray16be b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gray16be
new file mode 100644
index 00000000000..ec4e0efd3c8
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/fitsenc-gray16be
@@ -0,0 +1,10 @@
+#tb 0: 1/1
+#media_type 0: video
+#codec_id 0: fits
+#dimensions 0: 72x36
+#sar 0: 0/1
+0,          0,          0,        1,     5760, 0x317ba180
+0,          1,          1,        1,     5760, 0x439c9e40
+0,          2,          2,        1,     5760, 0x6136ff8f
+0,          3,          3,        1,     5760, 0x2c331324
+0,          4,          4,        1,     5760, 0x2f0816c1
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/flcl1905 b/mythtv/external/FFmpeg/tests/ref/fate/flcl1905
new file mode 100644
index 00000000000..de42921863c
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/flcl1905
@@ -0,0 +1,193 @@
+packet|codec_type=audio|stream_index=0|pts=0|pts_time=0.000000|dts=0|dts_time=0.000000|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=56|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=0|pkt_pts_time=0.000000|pkt_dts=0|pkt_dts_time=0.000000|best_effort_timestamp=0|best_effort_timestamp_time=0.000000|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=56|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=56|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=56|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=56|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=56|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=56|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=56|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=56|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=56|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=56|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=56|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=22528|pts_time=0.510839|dts=22528|dts_time=0.510839|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=4148|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=22528|pkt_pts_time=0.510839|pkt_dts=22528|pkt_dts_time=0.510839|best_effort_timestamp=22528|best_effort_timestamp_time=0.510839|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=4148|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=4148|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=4148|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=4148|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=4148|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=4148|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=4148|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=4148|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=4148|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=4148|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=4148|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=45056|pts_time=1.021678|dts=45056|dts_time=1.021678|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=8240|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=45056|pkt_pts_time=1.021678|pkt_dts=45056|pkt_dts_time=1.021678|best_effort_timestamp=45056|best_effort_timestamp_time=1.021678|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=8240|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=8240|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=8240|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=8240|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=8240|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=8240|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=8240|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=8240|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=8240|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=8240|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=8240|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=67584|pts_time=1.532517|dts=67584|dts_time=1.532517|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=12332|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=67584|pkt_pts_time=1.532517|pkt_dts=67584|pkt_dts_time=1.532517|best_effort_timestamp=67584|best_effort_timestamp_time=1.532517|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=12332|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=12332|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=12332|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=12332|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=12332|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=12332|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=12332|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=12332|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=12332|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=12332|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=12332|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=90112|pts_time=2.043356|dts=90112|dts_time=2.043356|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=16424|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=90112|pkt_pts_time=2.043356|pkt_dts=90112|pkt_dts_time=2.043356|best_effort_timestamp=90112|best_effort_timestamp_time=2.043356|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=16424|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=16424|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=16424|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=16424|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=16424|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=16424|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=16424|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=16424|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=16424|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=16424|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=16424|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=112640|pts_time=2.554195|dts=112640|dts_time=2.554195|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=20516|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=112640|pkt_pts_time=2.554195|pkt_dts=112640|pkt_dts_time=2.554195|best_effort_timestamp=112640|best_effort_timestamp_time=2.554195|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=20516|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=20516|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=20516|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=20516|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=20516|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=20516|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=20516|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=20516|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=20516|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=20516|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=20516|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=135168|pts_time=3.065034|dts=135168|dts_time=3.065034|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=24608|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=135168|pkt_pts_time=3.065034|pkt_dts=135168|pkt_dts_time=3.065034|best_effort_timestamp=135168|best_effort_timestamp_time=3.065034|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=24608|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=24608|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=24608|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=24608|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=24608|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=24608|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=24608|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=24608|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=24608|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=24608|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=24608|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=157696|pts_time=3.575873|dts=157696|dts_time=3.575873|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=28700|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=157696|pkt_pts_time=3.575873|pkt_dts=157696|pkt_dts_time=3.575873|best_effort_timestamp=157696|best_effort_timestamp_time=3.575873|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=28700|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=28700|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=28700|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=28700|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=28700|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=28700|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=28700|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=28700|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=28700|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=28700|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=28700|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=180224|pts_time=4.086712|dts=180224|dts_time=4.086712|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=32792|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=180224|pkt_pts_time=4.086712|pkt_dts=180224|pkt_dts_time=4.086712|best_effort_timestamp=180224|best_effort_timestamp_time=4.086712|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=32792|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=32792|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=32792|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=32792|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=32792|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=32792|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=32792|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=32792|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=32792|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=32792|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=32792|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=202752|pts_time=4.597551|dts=202752|dts_time=4.597551|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=36884|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=202752|pkt_pts_time=4.597551|pkt_dts=202752|pkt_dts_time=4.597551|best_effort_timestamp=202752|best_effort_timestamp_time=4.597551|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=36884|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=36884|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=36884|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=36884|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=36884|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=36884|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=36884|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=36884|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=36884|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=36884|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=36884|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=225280|pts_time=5.108390|dts=225280|dts_time=5.108390|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=40976|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=225280|pkt_pts_time=5.108390|pkt_dts=225280|pkt_dts_time=5.108390|best_effort_timestamp=225280|best_effort_timestamp_time=5.108390|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=40976|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=40976|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=40976|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=40976|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=40976|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=40976|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=40976|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=40976|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=40976|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=40976|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=40976|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=247808|pts_time=5.619229|dts=247808|dts_time=5.619229|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=45068|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=247808|pkt_pts_time=5.619229|pkt_dts=247808|pkt_dts_time=5.619229|best_effort_timestamp=247808|best_effort_timestamp_time=5.619229|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=45068|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=45068|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=45068|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=45068|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=45068|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=45068|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=45068|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=45068|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=45068|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=45068|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=45068|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=270336|pts_time=6.130068|dts=270336|dts_time=6.130068|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=49160|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=270336|pkt_pts_time=6.130068|pkt_dts=270336|pkt_dts_time=6.130068|best_effort_timestamp=270336|best_effort_timestamp_time=6.130068|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=49160|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=49160|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=49160|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=49160|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=49160|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=49160|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=49160|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=49160|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=49160|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=49160|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=49160|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=292864|pts_time=6.640907|dts=292864|dts_time=6.640907|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=53252|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=292864|pkt_pts_time=6.640907|pkt_dts=292864|pkt_dts_time=6.640907|best_effort_timestamp=292864|best_effort_timestamp_time=6.640907|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=53252|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=53252|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=53252|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=53252|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=53252|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=53252|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=53252|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=53252|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=53252|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=53252|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=53252|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=315392|pts_time=7.151746|dts=315392|dts_time=7.151746|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=57344|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=315392|pkt_pts_time=7.151746|pkt_dts=315392|pkt_dts_time=7.151746|best_effort_timestamp=315392|best_effort_timestamp_time=7.151746|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=57344|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=57344|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=57344|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=57344|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=57344|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=57344|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=57344|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=57344|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=57344|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=57344|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=57344|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=337920|pts_time=7.662585|dts=337920|dts_time=7.662585|duration=22528|duration_time=0.510839|convergence_duration=N/A|convergence_duration_time=N/A|size=4092|pos=61436|flags=K_
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=337920|pkt_pts_time=7.662585|pkt_dts=337920|pkt_dts_time=7.662585|best_effort_timestamp=337920|best_effort_timestamp_time=7.662585|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=61436|pkt_size=4092|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=61436|pkt_size=3720|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=61436|pkt_size=3348|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=61436|pkt_size=2976|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=61436|pkt_size=2604|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=61436|pkt_size=2232|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=61436|pkt_size=1860|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=61436|pkt_size=1488|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=61436|pkt_size=1116|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=61436|pkt_size=744|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+frame|media_type=audio|stream_index=0|key_frame=1|pkt_pts=N/A|pkt_pts_time=N/A|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=N/A|best_effort_timestamp_time=N/A|pkt_duration=22528|pkt_duration_time=0.510839|pkt_pos=61436|pkt_size=372|sample_fmt=fltp|nb_samples=2048|channels=2|channel_layout=unknown
+packet|codec_type=audio|stream_index=0|pts=360448|pts_time=8.173424|dts=360448|dts_time=8.173424|duration=44|duration_time=0.000998|convergence_duration=N/A|convergence_duration_time=N/A|size=8|pos=65528|flags=K_
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/flv-add_keyframe_index b/mythtv/external/FFmpeg/tests/ref/fate/flv-add_keyframe_index
new file mode 100644
index 00000000000..1c4da65d909
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/flv-add_keyframe_index
@@ -0,0 +1,12 @@
+;FFMETADATA1
+hasVideo=true
+hasKeyframes=true
+hasAudio=false
+hasMetadata=true
+canSeekToEnd=true
+datasize=629776
+videosize=629381
+audiosize=0
+lasttimestamp=20
+lastkeyframetimestamp=19
+lastkeyframelocation=597963
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/flv-demux b/mythtv/external/FFmpeg/tests/ref/fate/flv-demux
index 0a4598c01b2..4a791754cb5 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/flv-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/flv-demux
@@ -10,6 +10,7 @@
 #codec_id 1: aac
 #sample_rate 1: 22050
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,       33,      135, 0x78b33078, S=1,       39, 0xf8aa0d44
 1,          0,          0,       46,        9, 0x07bc01b8, S=1,        2, 0x00b600a3
 0,         33,         33,       33,       92, 0x0d891dd0, F=0x0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g722-encode b/mythtv/external/FFmpeg/tests/ref/fate/g722-encode
index ddf97c97df6..d84d62701c1 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g722-encode
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g722-encode
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 16000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     8192,    16384, 1dd9c285eb608038f3257d1a8e02eb75
 0,       8192,       8192,     8192,    16384, f7459334cbe70c06bc0897edfe64e840
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g722dec-1 b/mythtv/external/FFmpeg/tests/ref/fate/g722dec-1
index b7ec0d3753b..a97fc81fb06 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g722dec-1
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g722dec-1
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 16000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,     2048,     4096, 0x4f9228b3
 0,       2048,       2048,     2048,     4096, 0xfab58157
 0,       4096,       4096,     2048,     4096, 0x0b641c78
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-1 b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-1
index 01176fdba5d..f7daad1b499 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-1
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-1
@@ -3,5 +3,6 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      240,      480, 0x7f6f3970
 0,        240,        240,      240,      480, 0x1105a0d3
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-2 b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-2
index 0711ae44b1d..a403e565d09 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-2
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      240,      480, 0x5d9d9091
 0,        240,        240,      240,      480, 0x425095b7
 0,        480,        480,      240,      480, 0xe7b6a1a7
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-3 b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-3
index c1dde0c75b0..e3d39781381 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-3
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-3
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      240,      480, 0xce908869
 0,        240,        240,      240,      480, 0xfa63588e
 0,        480,        480,      240,      480, 0x11ce850c
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-4 b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-4
index 34817eecff6..309b3afea56 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-4
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-4
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      240,      480, 0xa697b314
 0,        240,        240,      240,      480, 0x43c5dc5a
 0,        480,        480,      240,      480, 0xd2438147
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-5 b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-5
index 7076fac3229..9e37c861a2d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-5
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-5
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      240,      480, 0x4dce9773
 0,        240,        240,      240,      480, 0xe6367ab8
 0,        480,        480,      240,      480, 0xf36a589d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-6 b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-6
index b493b373386..a51e8df9c8b 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-6
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-6
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      240,      480, 0x4fa1aed9
 0,        240,        240,      240,      480, 0x6d7ef391
 0,        480,        480,      240,      480, 0xaecaf2c1
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-7 b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-7
index bd960f5aec1..db0ceb85ef0 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-7
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-7
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      240,      480, 0x35e4a1fd
 0,        240,        240,      240,      480, 0x2f7bdd60
 0,        480,        480,      240,      480, 0x0407e499
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-8 b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-8
index 3399d7ae9fe..740ed2b4c7f 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-8
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g723_1-dec-8
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      240,      480, 0x17930e0f
 0,        240,        240,      240,      480, 0x7c7f4247
 0,        480,        480,      240,      480, 0xbf3489e5
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-2bit b/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-2bit
index fdb42ff63c9..4a83c957602 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-2bit
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-2bit
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,    16384,    32768, b28b116d2315323aeba6b66b58b7f4ed
 0,      16384,      16384,    16384,    32768, e9cfbebe99490bd4987341ee748291c4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-3bit b/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-3bit
index 92ea73d199a..c551ae608f2 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-3bit
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-3bit
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,    10920,    21840, 517dd6d1ce566b998251f0d215fa69c0
 0,      10920,      10920,    10920,    21840, b0268e2bcc67acb524753790123c65fd
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-4bit b/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-4bit
index ce7e1cb2547..ea277e12c54 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-4bit
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-4bit
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     8192,    16384, a0cf3a0953adce1a1032a4fd2da00a52
 0,       8192,       8192,     8192,    16384, c750c1b76a203556dd60d73d261529e9
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-5bit b/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-5bit
index bd0946f73a2..30c456e8644 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-5bit
+++ b/mythtv/external/FFmpeg/tests/ref/fate/g726-encode-5bit
@@ -6,6 +6,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 #stream#, dts,        pts, duration,     size, hash
 0,          0,          0,     6552,    13104, 6fe3f75df1262c5f956887de9c32df40
 0,       6552,       6552,     6552,    13104, f955518de6f61f94253280d11d64d68b
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/gapless-mp3 b/mythtv/external/FFmpeg/tests/ref/fate/gapless-mp3
index ebe7bfa2d60..ab4f1a04568 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/gapless-mp3
+++ b/mythtv/external/FFmpeg/tests/ref/fate/gapless-mp3
@@ -1,5 +1,5 @@
-37534a3bcc3ef306e8c5ebfcfedfc41c *tests/data/fate/gapless-mp3.out-1
+44b42cc3a898b45507d856d0813f4f26 *tests/data/fate/gapless-mp3.out-1
 c96c3ae7bd3300fd2f4debac222de5b7
-0cd1cdbcfd5cdbf6270cd98219bf31cd *tests/data/fate/gapless-mp3.out-2
+ec876434ed65e338e07234e54d136caf *tests/data/fate/gapless-mp3.out-2
 c96c3ae7bd3300fd2f4debac222de5b7
-9d3d8ba8a61b534f2d02ee648d6a8229 *tests/data/fate/gapless-mp3.out-3
+806fd80eba887b46a1eba1eeff63df28 *tests/data/fate/gapless-mp3.out-3
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/gaplessenc-itunes-to-ipod-aac b/mythtv/external/FFmpeg/tests/ref/fate/gaplessenc-itunes-to-ipod-aac
index 789681fb822..76cbf223587 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/gaplessenc-itunes-to-ipod-aac
+++ b/mythtv/external/FFmpeg/tests/ref/fate/gaplessenc-itunes-to-ipod-aac
@@ -7,22 +7,22 @@ duration_ts=103326
 start_time=0.000000
 duration=2.367000
 [/FORMAT]
-packet|pts=-1024|dts=-1024|duration=1024
-packet|pts=0|dts=0|duration=1024
-packet|pts=1024|dts=1024|duration=1024
-packet|pts=2048|dts=2048|duration=1024
-packet|pts=3072|dts=3072|duration=1024
-packet|pts=4096|dts=4096|duration=1024
-packet|pts=5120|dts=5120|duration=1024
-packet|pts=6144|dts=6144|duration=1024
-packet|pts=95232|dts=95232|duration=1024
-packet|pts=96256|dts=96256|duration=1024
-packet|pts=97280|dts=97280|duration=1024
-packet|pts=98304|dts=98304|duration=1024
-packet|pts=99328|dts=99328|duration=1024
-packet|pts=100352|dts=100352|duration=1024
-packet|pts=101376|dts=101376|duration=1024
-packet|pts=102400|dts=102400|duration=926
+packet|pts=-1024|dts=-1024|duration=1024|flags=KDside_data|
+
+packet|pts=0|dts=0|duration=1024|flags=K_
+packet|pts=1024|dts=1024|duration=1024|flags=K_
+packet|pts=2048|dts=2048|duration=1024|flags=K_
+packet|pts=3072|dts=3072|duration=1024|flags=K_
+packet|pts=4096|dts=4096|duration=1024|flags=K_
+packet|pts=5120|dts=5120|duration=1024|flags=K_
+packet|pts=95232|dts=95232|duration=1024|flags=K_
+packet|pts=96256|dts=96256|duration=1024|flags=K_
+packet|pts=97280|dts=97280|duration=1024|flags=K_
+packet|pts=98304|dts=98304|duration=1024|flags=K_
+packet|pts=99328|dts=99328|duration=1024|flags=K_
+packet|pts=100352|dts=100352|duration=1024|flags=K_
+packet|pts=101376|dts=101376|duration=1024|flags=K_
+packet|pts=102400|dts=102400|duration=926|flags=K_
 stream|nb_read_packets=102
 frame|pkt_pts=0|pkt_dts=0|best_effort_timestamp=0|pkt_duration=1024|nb_samples=1024
 frame|pkt_pts=1024|pkt_dts=1024|best_effort_timestamp=1024|pkt_duration=1024|nb_samples=1024
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/gaplessenc-pcm-to-mov-aac b/mythtv/external/FFmpeg/tests/ref/fate/gaplessenc-pcm-to-mov-aac
index 8702611abd8..2b17956e2b1 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/gaplessenc-pcm-to-mov-aac
+++ b/mythtv/external/FFmpeg/tests/ref/fate/gaplessenc-pcm-to-mov-aac
@@ -7,22 +7,22 @@ duration_ts=529200
 start_time=0.000000
 duration=12.024000
 [/FORMAT]
-packet|pts=-1024|dts=-1024|duration=1024
-packet|pts=0|dts=0|duration=1024
-packet|pts=1024|dts=1024|duration=1024
-packet|pts=2048|dts=2048|duration=1024
-packet|pts=3072|dts=3072|duration=1024
-packet|pts=4096|dts=4096|duration=1024
-packet|pts=5120|dts=5120|duration=1024
-packet|pts=6144|dts=6144|duration=1024
-packet|pts=521216|dts=521216|duration=1024
-packet|pts=522240|dts=522240|duration=1024
-packet|pts=523264|dts=523264|duration=1024
-packet|pts=524288|dts=524288|duration=1024
-packet|pts=525312|dts=525312|duration=1024
-packet|pts=526336|dts=526336|duration=1024
-packet|pts=527360|dts=527360|duration=1024
-packet|pts=528384|dts=528384|duration=816
+packet|pts=-1024|dts=-1024|duration=1024|flags=KDside_data|
+
+packet|pts=0|dts=0|duration=1024|flags=K_
+packet|pts=1024|dts=1024|duration=1024|flags=K_
+packet|pts=2048|dts=2048|duration=1024|flags=K_
+packet|pts=3072|dts=3072|duration=1024|flags=K_
+packet|pts=4096|dts=4096|duration=1024|flags=K_
+packet|pts=5120|dts=5120|duration=1024|flags=K_
+packet|pts=521216|dts=521216|duration=1024|flags=K_
+packet|pts=522240|dts=522240|duration=1024|flags=K_
+packet|pts=523264|dts=523264|duration=1024|flags=K_
+packet|pts=524288|dts=524288|duration=1024|flags=K_
+packet|pts=525312|dts=525312|duration=1024|flags=K_
+packet|pts=526336|dts=526336|duration=1024|flags=K_
+packet|pts=527360|dts=527360|duration=1024|flags=K_
+packet|pts=528384|dts=528384|duration=816|flags=K_
 stream|nb_read_packets=518
 frame|pkt_pts=0|pkt_dts=0|best_effort_timestamp=0|pkt_duration=1024|nb_samples=1024
 frame|pkt_pts=1024|pkt_dts=1024|best_effort_timestamp=1024|pkt_duration=1024|nb_samples=1024
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/gaplessinfo-itunes1 b/mythtv/external/FFmpeg/tests/ref/fate/gaplessinfo-itunes1
index 717a2a8adf6..bb5c09ad349 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/gaplessinfo-itunes1
+++ b/mythtv/external/FFmpeg/tests/ref/fate/gaplessinfo-itunes1
@@ -7,22 +7,22 @@ duration_ts=1294336
 start_time=0.047889
 duration=29.350023
 [/FORMAT]
-packet|pts=0|dts=0|duration=1024
-packet|pts=1024|dts=1024|duration=1024
-packet|pts=2048|dts=2048|duration=1024
-packet|pts=3072|dts=3072|duration=1024
-packet|pts=4096|dts=4096|duration=1024
-packet|pts=5120|dts=5120|duration=1024
-packet|pts=6144|dts=6144|duration=1024
-packet|pts=7168|dts=7168|duration=1024
-packet|pts=1286144|dts=1286144|duration=1024
-packet|pts=1287168|dts=1287168|duration=1024
-packet|pts=1288192|dts=1288192|duration=1024
-packet|pts=1289216|dts=1289216|duration=1024
-packet|pts=1290240|dts=1290240|duration=1024
-packet|pts=1291264|dts=1291264|duration=1024
-packet|pts=1292288|dts=1292288|duration=1024
-packet|pts=1293312|dts=1293312|duration=1024
+packet|pts=0|dts=0|duration=1024|flags=K_side_data|
+
+packet|pts=1024|dts=1024|duration=1024|flags=K_
+packet|pts=2048|dts=2048|duration=1024|flags=K_
+packet|pts=3072|dts=3072|duration=1024|flags=K_
+packet|pts=4096|dts=4096|duration=1024|flags=K_
+packet|pts=5120|dts=5120|duration=1024|flags=K_
+packet|pts=6144|dts=6144|duration=1024|flags=K_
+packet|pts=1286144|dts=1286144|duration=1024|flags=K_
+packet|pts=1287168|dts=1287168|duration=1024|flags=K_
+packet|pts=1288192|dts=1288192|duration=1024|flags=K_
+packet|pts=1289216|dts=1289216|duration=1024|flags=K_
+packet|pts=1290240|dts=1290240|duration=1024|flags=K_
+packet|pts=1291264|dts=1291264|duration=1024|flags=K_
+packet|pts=1292288|dts=1292288|duration=1024|flags=K_
+packet|pts=1293312|dts=1293312|duration=1024|flags=K_
 stream|nb_read_packets=1264
 frame|pkt_pts=2112|pkt_dts=2112|best_effort_timestamp=2048|pkt_duration=960|nb_samples=960
 frame|pkt_pts=3072|pkt_dts=3072|best_effort_timestamp=3072|pkt_duration=1024|nb_samples=1024
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/gaplessinfo-itunes2 b/mythtv/external/FFmpeg/tests/ref/fate/gaplessinfo-itunes2
index be15113df7e..0603ba8bf28 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/gaplessinfo-itunes2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/gaplessinfo-itunes2
@@ -7,22 +7,22 @@ duration_ts=105472
 start_time=0.047891
 duration=2.391655
 [/FORMAT]
-packet|pts=0|dts=0|duration=1024
-packet|pts=1024|dts=1024|duration=1024
-packet|pts=2048|dts=2048|duration=1024
-packet|pts=3072|dts=3072|duration=1024
-packet|pts=4096|dts=4096|duration=1024
-packet|pts=5120|dts=5120|duration=1024
-packet|pts=6144|dts=6144|duration=1024
-packet|pts=7168|dts=7168|duration=1024
-packet|pts=97280|dts=97280|duration=1024
-packet|pts=98304|dts=98304|duration=1024
-packet|pts=99328|dts=99328|duration=1024
-packet|pts=100352|dts=100352|duration=1024
-packet|pts=101376|dts=101376|duration=1024
-packet|pts=102400|dts=102400|duration=1024
-packet|pts=103424|dts=103424|duration=1024
-packet|pts=104448|dts=104448|duration=1024
+packet|pts=0|dts=0|duration=1024|flags=K_side_data|
+
+packet|pts=1024|dts=1024|duration=1024|flags=K_
+packet|pts=2048|dts=2048|duration=1024|flags=K_
+packet|pts=3072|dts=3072|duration=1024|flags=K_
+packet|pts=4096|dts=4096|duration=1024|flags=K_
+packet|pts=5120|dts=5120|duration=1024|flags=K_
+packet|pts=6144|dts=6144|duration=1024|flags=K_
+packet|pts=97280|dts=97280|duration=1024|flags=K_
+packet|pts=98304|dts=98304|duration=1024|flags=K_
+packet|pts=99328|dts=99328|duration=1024|flags=K_
+packet|pts=100352|dts=100352|duration=1024|flags=K_
+packet|pts=101376|dts=101376|duration=1024|flags=K_
+packet|pts=102400|dts=102400|duration=1024|flags=K_
+packet|pts=103424|dts=103424|duration=1024|flags=K_
+packet|pts=104448|dts=104448|duration=1024|flags=K_
 stream|nb_read_packets=103
 frame|pkt_pts=2112|pkt_dts=2112|best_effort_timestamp=2048|pkt_duration=960|nb_samples=960
 frame|pkt_pts=3072|pkt_dts=3072|best_effort_timestamp=3072|pkt_duration=1024|nb_samples=1024
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/gsm-ms b/mythtv/external/FFmpeg/tests/ref/fate/gsm-ms
index 92d78f3602a..0acf9f6e692 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/gsm-ms
+++ b/mythtv/external/FFmpeg/tests/ref/fate/gsm-ms
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      320,      640, 0xf79c59ee
 0,        320,        320,      320,      640, 0x6e6248be
 0,        640,        640,      320,      640, 0x2a5b3aed
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/gsm-toast b/mythtv/external/FFmpeg/tests/ref/fate/gsm-toast
index 46aab790f89..df5e824408f 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/gsm-toast
+++ b/mythtv/external/FFmpeg/tests/ref/fate/gsm-toast
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,       64,      128, 0x3ef33f6f
 0,         64,         64,      160,      320, 0x2052a4e7
 0,        224,        224,      160,      320, 0xe9aeafca
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264-dts_5frames b/mythtv/external/FFmpeg/tests/ref/fate/h264-dts_5frames
index 1c4c349bff3..6049b9ff323 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/h264-dts_5frames
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264-dts_5frames
@@ -22,6 +22,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=left
 [/FRAME]
 [FRAME]
 media_type=video
@@ -47,6 +52,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=left
 [/FRAME]
 [FRAME]
 media_type=video
@@ -72,6 +82,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=left
 [/FRAME]
 [FRAME]
 media_type=video
@@ -97,6 +112,11 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=left
 [/FRAME]
 [FRAME]
 media_type=video
@@ -122,4 +142,9 @@ display_picture_number=0
 interlaced_frame=0
 top_field_first=0
 repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=left
 [/FRAME]
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264-extradata-reload b/mythtv/external/FFmpeg/tests/ref/fate/h264-extradata-reload
new file mode 100644
index 00000000000..c70f8056873
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264-extradata-reload
@@ -0,0 +1,13 @@
+#format: frame checksums
+#version: 2
+#hash: MD5
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 256x128
+#sar 0: 1/1
+#stream#, dts,        pts, duration,     size, hash
+0,          0,          0,        1,    49152, ae09c88e87e3ea0aa8ad267ee91222e5
+0,          1,          1,        1,    49152, 7ccd8321a6e23ae1f82bd323c8376524
+0,          2,          2,        1,    49152, 8ed93ab585ff9848801cc28b75b5e12d
+0,          3,          3,        1,    49152, 0049913870ddb62ffc535282018766f4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264-intra-refresh-recovery b/mythtv/external/FFmpeg/tests/ref/fate/h264-intra-refresh-recovery
new file mode 100644
index 00000000000..e85fe7bae86
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264-intra-refresh-recovery
@@ -0,0 +1,15 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 320x240
+#sar 0: 0/1
+0,         57,         57,        1,   115200, 0x4a17d50b
+0,         58,         58,        1,   115200, 0x1283d05b
+0,         59,         59,        1,   115200, 0x2747c650
+0,         60,         60,        1,   115200, 0xba23c933
+0,         61,         61,        1,   115200, 0x8a96c54b
+0,         62,         62,        1,   115200, 0x748ac6d3
+0,         63,         63,        1,   115200, 0x719ca491
+0,         64,         64,        1,   115200, 0x3d259d4d
+0,         65,         65,        1,   115200, 0xe3599aa8
+0,         66,         66,        1,   115200, 0x6fd4affe
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264-missing-frame b/mythtv/external/FFmpeg/tests/ref/fate/h264-missing-frame
new file mode 100644
index 00000000000..04d229913dc
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264-missing-frame
@@ -0,0 +1,35 @@
+#tb 0: 1/30
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 1440x1080
+#sar 0: 1/1
+0,          0,          0,        1,  2332800, 0x009dacb8
+0,          1,          1,        1,  2332800, 0xb1e50764
+0,          2,          2,        1,  2332800, 0xe29481e0
+0,          3,          3,        1,  2332800, 0x0b1b4de4
+0,          4,          4,        1,  2332800, 0x726a644c
+0,          5,          5,        1,  2332800, 0x7a09c4a5
+0,          6,          6,        1,  2332800, 0x2e9059ea
+0,          7,          7,        1,  2332800, 0x52071fdc
+0,          8,          8,        1,  2332800, 0x4fa00417
+0,          9,          9,        1,  2332800, 0x6037fb4d
+0,         10,         10,        1,  2332800, 0x887ffae2
+0,         11,         11,        1,  2332800, 0x887ffae2
+0,         12,         12,        1,  2332800, 0x887ffae2
+0,         13,         13,        1,  2332800, 0x887ffae2
+0,         14,         14,        1,  2332800, 0x887ffae2
+0,         15,         15,        1,  2332800, 0x887ffae2
+0,         16,         16,        1,  2332800, 0x887ffae2
+0,         17,         17,        1,  2332800, 0x887ffae2
+0,         18,         18,        1,  2332800, 0x887ffae2
+0,         19,         19,        1,  2332800, 0x887ffae2
+0,         20,         20,        1,  2332800, 0x887ffae2
+0,         21,         21,        1,  2332800, 0x887ffae2
+0,         22,         22,        1,  2332800, 0x887ffae2
+0,         23,         23,        1,  2332800, 0x887ffae2
+0,         24,         24,        1,  2332800, 0x887ffae2
+0,         25,         25,        1,  2332800, 0x887ffae2
+0,         26,         26,        1,  2332800, 0x887ffae2
+0,         27,         27,        1,  2332800, 0x887ffae2
+0,         28,         28,        1,  2332800, 0x887ffae2
+0,         29,         29,        1,  2332800, 0x824bb91b
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264-mixed-nal-coding b/mythtv/external/FFmpeg/tests/ref/fate/h264-mixed-nal-coding
new file mode 100644
index 00000000000..24b6b4cb560
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264-mixed-nal-coding
@@ -0,0 +1,10 @@
+#tb 0: 1001/30000
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 720x480
+#sar 0: 40/33
+0,          0,          0,        1,   518400, 0x8f882e4d
+0,          1,          1,        1,   518400, 0xc5694144
+0,          2,          2,        1,   518400, 0xcf0e9e3a
+0,          3,          3,        1,   518400, 0xf620e459
+0,          4,          4,        1,   518400, 0x4566453e
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264-skip-nointra b/mythtv/external/FFmpeg/tests/ref/fate/h264-skip-nointra
index 40b5bb26d4e..02599029270 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/h264-skip-nointra
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264-skip-nointra
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 1,          0,          0,     1152,     4608, 0x00000000
 1,       1152,       1152,     1152,     4608, 0x00000000
 1,       2304,       2304,     1152,     4608, 0x00000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264-skip-nokey b/mythtv/external/FFmpeg/tests/ref/fate/h264-skip-nokey
index 40b5bb26d4e..02599029270 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/h264-skip-nokey
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264-skip-nokey
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 1,          0,          0,     1152,     4608, 0x00000000
 1,       1152,       1152,     1152,     4608, 0x00000000
 1,       2304,       2304,     1152,     4608, 0x00000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264-twofields-packet b/mythtv/external/FFmpeg/tests/ref/fate/h264-twofields-packet
new file mode 100644
index 00000000000..db12498f15a
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264-twofields-packet
@@ -0,0 +1,35 @@
+#tb 0: 1001/30000
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 1920x1080
+#sar 0: 1/1
+0,          0,          0,        1,  3110400, 0x48e39acd
+0,          1,          1,        1,  3110400, 0x40d65f69
+0,          2,          2,        1,  3110400, 0xdcbc50bf
+0,          3,          3,        1,  3110400, 0x73a2276a
+0,          4,          4,        1,  3110400, 0x84a2b3c6
+0,          5,          5,        1,  3110400, 0x7cf3b570
+0,          6,          6,        1,  3110400, 0xa2d1e03a
+0,          7,          7,        1,  3110400, 0x03220fb1
+0,          8,          8,        1,  3110400, 0x89cd526a
+0,          9,          9,        1,  3110400, 0xbb4b7531
+0,         10,         10,        1,  3110400, 0x0a69f053
+0,         11,         11,        1,  3110400, 0x0187994b
+0,         12,         12,        1,  3110400, 0x26ed49fa
+0,         13,         13,        1,  3110400, 0xbe8966d4
+0,         14,         14,        1,  3110400, 0x248d203c
+0,         15,         15,        1,  3110400, 0x3139c754
+0,         16,         16,        1,  3110400, 0xf22380c4
+0,         17,         17,        1,  3110400, 0x3e00dcc1
+0,         18,         18,        1,  3110400, 0x8cbe2483
+0,         19,         19,        1,  3110400, 0x6951cd63
+0,         20,         20,        1,  3110400, 0x36aca4c5
+0,         21,         21,        1,  3110400, 0x4d4f6fbe
+0,         22,         22,        1,  3110400, 0x997247aa
+0,         23,         23,        1,  3110400, 0x0fd40e06
+0,         24,         24,        1,  3110400, 0xa10d2d67
+0,         25,         25,        1,  3110400, 0x87c481da
+0,         26,         26,        1,  3110400, 0xe3dca3cd
+0,         27,         27,        1,  3110400, 0x5f77b078
+0,         28,         28,        1,  3110400, 0xf1ddd098
+0,         29,         29,        1,  3110400, 0xedcd1754
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264-xavc-4389 b/mythtv/external/FFmpeg/tests/ref/fate/h264-xavc-4389
index b1158b8e572..5c76bc222f9 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/h264-xavc-4389
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264-xavc-4389
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 48000
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,  8294400, 0x9a02ecf2
 1,          0,          0,     1920,     3840, 0x38074ac8
 0,          1,          1,        1,  8294400, 0x626f870a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264_mp4toannexb_ticket2991 b/mythtv/external/FFmpeg/tests/ref/fate/h264_mp4toannexb_ticket2991
index 4c73d7da44a..76bdf3cae79 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/h264_mp4toannexb_ticket2991
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264_mp4toannexb_ticket2991
@@ -1,6 +1,6 @@
 05d66e60ab22ee004720e0051af0fe74 *tests/data/fate/h264_mp4toannexb_ticket2991.h264
 1985815 tests/data/fate/h264_mp4toannexb_ticket2991.h264
-#extradata 0:       79, 0x1ec61105
+#extradata 0:       47, 0x3a590d55
 #tb 0: 1/1200000
 #media_type 0: video
 #codec_id 0: h264
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264_mp4toannexb_ticket5927 b/mythtv/external/FFmpeg/tests/ref/fate/h264_mp4toannexb_ticket5927
new file mode 100644
index 00000000000..95e35c4d802
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264_mp4toannexb_ticket5927
@@ -0,0 +1,21 @@
+a3b02fd09392e01619cebc959d4d9ff2 *tests/data/fate/h264_mp4toannexb_ticket5927.h264
+595583 tests/data/fate/h264_mp4toannexb_ticket5927.h264
+#extradata 0:       33, 0x84fe08f8
+#tb 0: 1/1200000
+#media_type 0: video
+#codec_id 0: h264
+#dimensions 0: 1920x1080
+#sar 0: 0/1
+0,     -48000, -9223372036854775808,    48000,   247993, 0x1ce821ea
+0,          0, -9223372036854775808,    48000,    43354, 0xa05dca6f, F=0x0
+0,      48000, -9223372036854775808,    48000,    11423, 0x5e8086dd, F=0x0
+0,      96000, -9223372036854775808,    48000,    50798, 0x145fbe4f, F=0x0
+0,     144000, -9223372036854775808,    48000,    12567, 0x1e3d5304, F=0x0
+0,     192000, -9223372036854775808,    48000,    52444, 0x1a6c1a64, F=0x0
+0,     240000, -9223372036854775808,    48000,    12575, 0x2fff484b, F=0x0
+0,     288000, -9223372036854775808,    48000,    54025, 0xb3bf0ce6, F=0x0
+0,     336000, -9223372036854775808,    48000,    13539, 0xfdb16c57, F=0x0
+0,     384000, -9223372036854775808,    48000,    54483, 0xefead99f, F=0x0
+0,     432000, -9223372036854775808,    48000,    13705, 0x23cd27e8, F=0x0
+0,     480000, -9223372036854775808,    48000,    22308, 0x4093b5af, F=0x0
+0,     528000, -9223372036854775808,    48000,     6369, 0x858b2aa1
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/h264_mp4toannexb_ticket5927_2 b/mythtv/external/FFmpeg/tests/ref/fate/h264_mp4toannexb_ticket5927_2
new file mode 100644
index 00000000000..8db6a7e54a7
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/h264_mp4toannexb_ticket5927_2
@@ -0,0 +1,21 @@
+a3b02fd09392e01619cebc959d4d9ff2 *tests/data/fate/h264_mp4toannexb_ticket5927_2.h264
+595583 tests/data/fate/h264_mp4toannexb_ticket5927_2.h264
+#extradata 0:       33, 0x84fe08f8
+#tb 0: 1/1200000
+#media_type 0: video
+#codec_id 0: h264
+#dimensions 0: 1920x1080
+#sar 0: 0/1
+0,     -48000, -9223372036854775808,    48000,   247993, 0x1ce821ea
+0,          0, -9223372036854775808,    48000,    43354, 0xa05dca6f, F=0x0
+0,      48000, -9223372036854775808,    48000,    11423, 0x5e8086dd, F=0x0
+0,      96000, -9223372036854775808,    48000,    50798, 0x145fbe4f, F=0x0
+0,     144000, -9223372036854775808,    48000,    12567, 0x1e3d5304, F=0x0
+0,     192000, -9223372036854775808,    48000,    52444, 0x1a6c1a64, F=0x0
+0,     240000, -9223372036854775808,    48000,    12575, 0x2fff484b, F=0x0
+0,     288000, -9223372036854775808,    48000,    54025, 0xb3bf0ce6, F=0x0
+0,     336000, -9223372036854775808,    48000,    13539, 0xfdb16c57, F=0x0
+0,     384000, -9223372036854775808,    48000,    54483, 0xefead99f, F=0x0
+0,     432000, -9223372036854775808,    48000,    13705, 0x23cd27e8, F=0x0
+0,     480000, -9223372036854775808,    48000,    22308, 0x4093b5af, F=0x0
+0,     528000, -9223372036854775808,    48000,     6369, 0x858b2aa1
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/hevc-extradata-reload b/mythtv/external/FFmpeg/tests/ref/fate/hevc-extradata-reload
new file mode 100644
index 00000000000..b08754ed2bd
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/hevc-extradata-reload
@@ -0,0 +1,13 @@
+#format: frame checksums
+#version: 2
+#hash: MD5
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 1/1
+#stream#, dts,        pts, duration,     size, hash
+0,          0,          0,        1,    24576, 0d01217c5d1ec6799643fc7d75ba2337
+0,          1,          1,        1,    24576, f73d9cca9b4c1765d0ead242c3f0c339
+0,          2,          2,        1,    24576, 39a8714d763c623ae7f6faae34e107d1
+0,          3,          3,        1,    24576, 5db2600aa268b4fd28b64ab28a096f32
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/hevc-paired-fields b/mythtv/external/FFmpeg/tests/ref/fate/hevc-paired-fields
new file mode 100644
index 00000000000..f2223e770b6
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/hevc-paired-fields
@@ -0,0 +1,16 @@
+[FRAME]
+interlaced_frame=1
+top_field_first=1
+[/FRAME]
+[FRAME]
+interlaced_frame=1
+top_field_first=0
+[/FRAME]
+[FRAME]
+interlaced_frame=1
+top_field_first=1
+[/FRAME]
+[FRAME]
+interlaced_frame=1
+top_field_first=0
+[/FRAME]
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/id-cin-video b/mythtv/external/FFmpeg/tests/ref/fate/id-cin-video
index 469e2393fa8..671b396a113 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/id-cin-video
+++ b/mythtv/external/FFmpeg/tests/ref/fate/id-cin-video
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 22050
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,        1,   230400, 0x00000000
 1,          0,          0,     1575,     6300, 0xdd759df8
 0,          1,          1,        1,   230400, 0x3a3486b4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/imgutils b/mythtv/external/FFmpeg/tests/ref/fate/imgutils
new file mode 100644
index 00000000000..aba482221f3
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/imgutils
@@ -0,0 +1,55 @@
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0011111111111111111111111111111111110000000000000000000
+0011111111111111111111111111111111110000000000000000000
+0011111111111111111111111111111111110000000000000000000
+0011111111111111111111111111111111110000000000000000000
+0011111111111111111111111111111111110000000000000000000
+0011111111111111111111111111111111110000000000000000000
+0011111111111111111111111111111111110000000000000000000
+0011111111111111111111111111111111110000000000000000000
+0011111111111111111111111111111111100000000000000000000
+0011111111111111111111111111111111100000000000000000000
+0011111111111111111111111111111111000000000000000000000
+0011111111111111111111111111111111000000000000000000000
+0011111111111111111111111111111110000000000000000000000
+0011111111111111111111111111111100000000000000000000000
+0011111111111111111111111111111100000000000000000000000
+0011111111111111111111111111111000000000000000000000000
+0011111111111111111111111111110000000000000000000000000
+0011111111111111111111111111100000000000000000000000000
+0011111111111111111111111111000000000000000000000000000
+0011111111111111111111111110000000000000000000000000000
+0011111111111111111111111100000000000000000000000000000
+0011111111111111111111111000000000000000000000000000000
+0011111111111111111111110000000000000000000000000000000
+0011111111111111111111100000000000000000000000000000000
+0011111111111111111111000000000000000000000000000000000
+0011111111111111111110000000000000000000000000000000000
+0011111111111111111100000000000000000000000000000000000
+0011111111111111111000000000000000000000000000000000000
+0011111111111111110000000000000000000000000000000000000
+0011111111111111100000000000000000000000000000000000000
+0011111111111110000000000000000000000000000000000000000
+0011111111111100000000000000000000000000000000000000000
+0011111111110000000000000000000000000000000000000000000
+0011111111000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/jv-demux b/mythtv/external/FFmpeg/tests/ref/fate/jv-demux
index 280528c5ed6..bf8211074c5 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/jv-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/jv-demux
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_u8
 #sample_rate 1: 22050
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,        6, 0x000a0003
 1,          0,          0,   131072,   131072, 0x14c664d6
 0,          1,          1,        1,      773, 0x11802a51
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/lfg b/mythtv/external/FFmpeg/tests/ref/fate/lfg
new file mode 100644
index 00000000000..2d00f4d8a20
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/lfg
@@ -0,0 +1,1007 @@
+PRN0 : 993.985459
+PRN1 : 1033.987435
+PRN2 : 1047.662570
+PRN3 : 1063.912250
+PRN4 : 991.171781
+PRN5 : 981.734708
+PRN6 : 970.361179
+PRN7 : 998.599410
+PRN8 : 1001.562108
+PRN9 : 1094.675286
+PRN10 : 1026.730733
+PRN11 : 1001.794662
+PRN12 : 1063.992962
+PRN13 : 1003.176291
+PRN14 : 975.451418
+PRN15 : 963.164272
+PRN16 : 1035.042964
+PRN17 : 936.289221
+PRN18 : 1031.696061
+PRN19 : 1033.960882
+PRN20 : 970.449088
+PRN21 : 910.742009
+PRN22 : 1062.832837
+PRN23 : 972.315035
+PRN24 : 1094.553302
+PRN25 : 1004.366061
+PRN26 : 1067.940967
+PRN27 : 954.763340
+PRN28 : 923.089263
+PRN29 : 1053.286222
+PRN30 : 1012.639887
+PRN31 : 948.568149
+PRN32 : 1027.339362
+PRN33 : 953.080426
+PRN34 : 1035.425106
+PRN35 : 966.976740
+PRN36 : 1064.841657
+PRN37 : 904.714740
+PRN38 : 1054.112231
+PRN39 : 986.084454
+PRN40 : 964.995134
+PRN41 : 1064.898415
+PRN42 : 1049.385860
+PRN43 : 946.010664
+PRN44 : 914.563520
+PRN45 : 1054.057798
+PRN46 : 921.007266
+PRN47 : 1055.600575
+PRN48 : 984.003285
+PRN49 : 1064.479044
+PRN50 : 989.128936
+PRN51 : 972.772486
+PRN52 : 1028.824527
+PRN53 : 948.999392
+PRN54 : 926.982512
+PRN55 : 1028.107269
+PRN56 : 1018.971292
+PRN57 : 979.049159
+PRN58 : 1078.652930
+PRN59 : 1059.268785
+PRN60 : 966.062302
+PRN61 : 952.298249
+PRN62 : 965.484659
+PRN63 : 957.131298
+PRN64 : 1101.631483
+PRN65 : 991.328207
+PRN66 : 947.868071
+PRN67 : 977.329736
+PRN68 : 1039.860026
+PRN69 : 1005.357641
+PRN70 : 926.524754
+PRN71 : 1065.337110
+PRN72 : 1016.266500
+PRN73 : 1005.771115
+PRN74 : 1013.342260
+PRN75 : 1016.421157
+PRN76 : 918.857846
+PRN77 : 1084.126406
+PRN78 : 1013.273197
+PRN79 : 1009.859699
+PRN80 : 953.978276
+PRN81 : 966.195381
+PRN82 : 966.041526
+PRN83 : 1034.313935
+PRN84 : 1028.006502
+PRN85 : 988.667994
+PRN86 : 951.447243
+PRN87 : 950.197401
+PRN88 : 1004.492867
+PRN89 : 1018.726549
+PRN90 : 1002.135383
+PRN91 : 1015.553223
+PRN92 : 968.825638
+PRN93 : 909.251629
+PRN94 : 927.430200
+PRN95 : 1026.839173
+PRN96 : 1001.209732
+PRN97 : 903.997372
+PRN98 : 1029.582853
+PRN99 : 998.221588
+PRN100 : 874.533368
+PRN101 : 1008.158727
+PRN102 : 1064.130097
+PRN103 : 1020.425429
+PRN104 : 914.904591
+PRN105 : 1050.711960
+PRN106 : 1019.491585
+PRN107 : 968.062305
+PRN108 : 946.755388
+PRN109 : 1012.508705
+PRN110 : 997.922624
+PRN111 : 962.447265
+PRN112 : 1065.410496
+PRN113 : 1059.470790
+PRN114 : 1036.427789
+PRN115 : 963.516351
+PRN116 : 970.000982
+PRN117 : 978.030226
+PRN118 : 1041.883687
+PRN119 : 924.311759
+PRN120 : 987.574757
+PRN121 : 1020.188441
+PRN122 : 979.109616
+PRN123 : 1076.652961
+PRN124 : 905.994009
+PRN125 : 999.425282
+PRN126 : 1012.521111
+PRN127 : 893.443447
+PRN128 : 978.578327
+PRN129 : 1068.476732
+PRN130 : 960.687195
+PRN131 : 954.211448
+PRN132 : 1031.587651
+PRN133 : 1069.561334
+PRN134 : 948.293168
+PRN135 : 999.185195
+PRN136 : 967.284970
+PRN137 : 1004.112868
+PRN138 : 989.683149
+PRN139 : 1008.154639
+PRN140 : 1043.953748
+PRN141 : 1082.131379
+PRN142 : 1006.528611
+PRN143 : 942.893040
+PRN144 : 1120.072970
+PRN145 : 908.369273
+PRN146 : 1039.338207
+PRN147 : 1011.429056
+PRN148 : 1058.020374
+PRN149 : 1007.346274
+PRN150 : 916.830032
+PRN151 : 1000.237008
+PRN152 : 977.470622
+PRN153 : 985.066693
+PRN154 : 1020.675449
+PRN155 : 1026.074199
+PRN156 : 1087.961390
+PRN157 : 993.836698
+PRN158 : 1008.510268
+PRN159 : 1013.336576
+PRN160 : 1022.611211
+PRN161 : 996.211550
+PRN162 : 1025.772152
+PRN163 : 1058.268017
+PRN164 : 911.997787
+PRN165 : 1052.556722
+PRN166 : 998.536098
+PRN167 : 915.837410
+PRN168 : 979.313138
+PRN169 : 1045.691152
+PRN170 : 1018.832329
+PRN171 : 1086.959291
+PRN172 : 1065.875576
+PRN173 : 1018.341432
+PRN174 : 1101.511906
+PRN175 : 1130.164468
+PRN176 : 1043.232574
+PRN177 : 1086.907863
+PRN178 : 1025.378136
+PRN179 : 999.601323
+PRN180 : 1036.776794
+PRN181 : 988.653272
+PRN182 : 973.274518
+PRN183 : 1000.807655
+PRN184 : 1057.386211
+PRN185 : 960.735035
+PRN186 : 904.872645
+PRN187 : 889.117280
+PRN188 : 983.809186
+PRN189 : 912.874411
+PRN190 : 975.589269
+PRN191 : 948.421999
+PRN192 : 947.657566
+PRN193 : 950.000738
+PRN194 : 962.922561
+PRN195 : 1026.301488
+PRN196 : 1029.353812
+PRN197 : 1047.303674
+PRN198 : 1028.695557
+PRN199 : 1070.200632
+PRN200 : 947.575145
+PRN201 : 876.904616
+PRN202 : 1017.701430
+PRN203 : 1049.267498
+PRN204 : 958.139948
+PRN205 : 967.417379
+PRN206 : 968.274143
+PRN207 : 1000.864388
+PRN208 : 1066.802181
+PRN209 : 1014.463051
+PRN210 : 1026.799870
+PRN211 : 1018.450824
+PRN212 : 988.633963
+PRN213 : 904.749119
+PRN214 : 937.323052
+PRN215 : 1037.391158
+PRN216 : 1026.099281
+PRN217 : 907.667691
+PRN218 : 1010.454766
+PRN219 : 1019.473463
+PRN220 : 1005.177530
+PRN221 : 997.361757
+PRN222 : 954.628248
+PRN223 : 1061.917463
+PRN224 : 1039.311045
+PRN225 : 983.843948
+PRN226 : 968.679422
+PRN227 : 970.518863
+PRN228 : 963.038929
+PRN229 : 1086.210292
+PRN230 : 1022.961948
+PRN231 : 964.149961
+PRN232 : 949.462428
+PRN233 : 959.221279
+PRN234 : 987.151293
+PRN235 : 959.017697
+PRN236 : 996.893693
+PRN237 : 965.063094
+PRN238 : 1000.468116
+PRN239 : 1004.755878
+PRN240 : 995.674256
+PRN241 : 996.723454
+PRN242 : 966.714381
+PRN243 : 992.601460
+PRN244 : 1041.656776
+PRN245 : 1061.690153
+PRN246 : 1103.650456
+PRN247 : 1055.668922
+PRN248 : 1052.582092
+PRN249 : 953.461917
+PRN250 : 1006.433285
+PRN251 : 955.606772
+PRN252 : 1039.688043
+PRN253 : 1088.653591
+PRN254 : 942.093968
+PRN255 : 1031.071161
+PRN256 : 946.110148
+PRN257 : 932.761874
+PRN258 : 1052.693974
+PRN259 : 1008.479381
+PRN260 : 1063.720881
+PRN261 : 992.478541
+PRN262 : 915.981089
+PRN263 : 992.027282
+PRN264 : 1024.266535
+PRN265 : 919.165065
+PRN266 : 1010.516440
+PRN267 : 997.213969
+PRN268 : 1021.925225
+PRN269 : 978.883278
+PRN270 : 981.515166
+PRN271 : 980.281886
+PRN272 : 1053.161093
+PRN273 : 912.521231
+PRN274 : 953.132131
+PRN275 : 1004.643842
+PRN276 : 1058.794186
+PRN277 : 984.215138
+PRN278 : 1042.304270
+PRN279 : 972.388973
+PRN280 : 1033.185530
+PRN281 : 969.133442
+PRN282 : 1027.169707
+PRN283 : 1061.483306
+PRN284 : 960.680868
+PRN285 : 1001.272929
+PRN286 : 1017.813674
+PRN287 : 983.331085
+PRN288 : 932.052156
+PRN289 : 1004.348693
+PRN290 : 1086.961051
+PRN291 : 1038.181141
+PRN292 : 1050.191404
+PRN293 : 997.767778
+PRN294 : 1080.797673
+PRN295 : 976.782991
+PRN296 : 1031.633723
+PRN297 : 1011.128806
+PRN298 : 1008.380640
+PRN299 : 1087.552272
+PRN300 : 962.484066
+PRN301 : 942.301619
+PRN302 : 983.039469
+PRN303 : 962.689056
+PRN304 : 947.296230
+PRN305 : 1070.666154
+PRN306 : 1032.115321
+PRN307 : 1021.567324
+PRN308 : 953.506490
+PRN309 : 1002.026680
+PRN310 : 1008.181860
+PRN311 : 1025.392684
+PRN312 : 968.955019
+PRN313 : 1049.458891
+PRN314 : 957.676990
+PRN315 : 1035.683512
+PRN316 : 1112.131175
+PRN317 : 1055.138933
+PRN318 : 1078.236814
+PRN319 : 1125.693872
+PRN320 : 1022.131166
+PRN321 : 1116.997957
+PRN322 : 1089.131000
+PRN323 : 1077.159289
+PRN324 : 945.536432
+PRN325 : 1075.404651
+PRN326 : 946.487332
+PRN327 : 1024.258871
+PRN328 : 1031.225842
+PRN329 : 1016.780255
+PRN330 : 1103.910936
+PRN331 : 1000.846691
+PRN332 : 984.532087
+PRN333 : 1005.306673
+PRN334 : 1113.067840
+PRN335 : 964.786705
+PRN336 : 1031.129909
+PRN337 : 1102.032227
+PRN338 : 1032.427500
+PRN339 : 915.287948
+PRN340 : 1069.521468
+PRN341 : 1037.884311
+PRN342 : 1022.783172
+PRN343 : 1010.113843
+PRN344 : 936.663822
+PRN345 : 967.568134
+PRN346 : 998.248532
+PRN347 : 970.595103
+PRN348 : 1059.133013
+PRN349 : 1002.450372
+PRN350 : 1041.569244
+PRN351 : 1071.151467
+PRN352 : 1074.430879
+PRN353 : 1024.192522
+PRN354 : 1027.316098
+PRN355 : 903.837437
+PRN356 : 1025.087981
+PRN357 : 1078.239201
+PRN358 : 947.160744
+PRN359 : 943.791880
+PRN360 : 982.419379
+PRN361 : 1015.326413
+PRN362 : 930.457683
+PRN363 : 1056.989164
+PRN364 : 1048.214411
+PRN365 : 1011.714309
+PRN366 : 973.561885
+PRN367 : 938.897489
+PRN368 : 898.131351
+PRN369 : 1089.422229
+PRN370 : 1000.737285
+PRN371 : 943.187609
+PRN372 : 980.631385
+PRN373 : 1026.612456
+PRN374 : 914.530023
+PRN375 : 989.137431
+PRN376 : 936.013065
+PRN377 : 1037.484721
+PRN378 : 1005.741041
+PRN379 : 1079.121866
+PRN380 : 1055.031055
+PRN381 : 967.647139
+PRN382 : 1073.874913
+PRN383 : 987.676314
+PRN384 : 1064.291410
+PRN385 : 1036.029393
+PRN386 : 1021.885249
+PRN387 : 971.958380
+PRN388 : 1060.807076
+PRN389 : 944.558349
+PRN390 : 936.791120
+PRN391 : 986.203862
+PRN392 : 934.815474
+PRN393 : 950.177863
+PRN394 : 1053.566520
+PRN395 : 955.717211
+PRN396 : 914.562496
+PRN397 : 1021.237741
+PRN398 : 985.669335
+PRN399 : 1049.267052
+PRN400 : 1096.201981
+PRN401 : 871.290446
+PRN402 : 1056.942788
+PRN403 : 991.680777
+PRN404 : 987.094995
+PRN405 : 1030.857572
+PRN406 : 1014.738174
+PRN407 : 1122.789424
+PRN408 : 1057.378717
+PRN409 : 852.638284
+PRN410 : 979.034993
+PRN411 : 1050.776805
+PRN412 : 1013.760119
+PRN413 : 1013.442288
+PRN414 : 1056.335907
+PRN415 : 1003.833582
+PRN416 : 952.287368
+PRN417 : 983.410711
+PRN418 : 981.610215
+PRN419 : 955.751367
+PRN420 : 1026.024405
+PRN421 : 913.215405
+PRN422 : 1039.587952
+PRN423 : 934.420327
+PRN424 : 1048.085188
+PRN425 : 1069.984971
+PRN426 : 1022.569605
+PRN427 : 994.967729
+PRN428 : 978.231174
+PRN429 : 1091.191368
+PRN430 : 1110.565525
+PRN431 : 993.099640
+PRN432 : 943.356916
+PRN433 : 1008.520337
+PRN434 : 1039.057948
+PRN435 : 995.518711
+PRN436 : 923.381630
+PRN437 : 1008.525954
+PRN438 : 1074.725786
+PRN439 : 973.831465
+PRN440 : 992.850511
+PRN441 : 915.574772
+PRN442 : 935.268901
+PRN443 : 1030.668761
+PRN444 : 1006.389624
+PRN445 : 1070.532520
+PRN446 : 1044.161059
+PRN447 : 1009.868970
+PRN448 : 995.488179
+PRN449 : 1003.676963
+PRN450 : 1036.281447
+PRN451 : 1034.663850
+PRN452 : 1016.940948
+PRN453 : 1041.761449
+PRN454 : 1036.179308
+PRN455 : 927.147021
+PRN456 : 1015.267516
+PRN457 : 1025.120602
+PRN458 : 1003.012895
+PRN459 : 1017.405398
+PRN460 : 1084.152015
+PRN461 : 938.100545
+PRN462 : 982.848682
+PRN463 : 971.208439
+PRN464 : 1024.169902
+PRN465 : 984.026162
+PRN466 : 885.734952
+PRN467 : 970.662665
+PRN468 : 966.626383
+PRN469 : 970.630895
+PRN470 : 1065.729526
+PRN471 : 1087.725051
+PRN472 : 934.663676
+PRN473 : 982.326660
+PRN474 : 1028.573796
+PRN475 : 1042.602736
+PRN476 : 919.644128
+PRN477 : 1117.592528
+PRN478 : 973.727786
+PRN479 : 1017.035309
+PRN480 : 985.948508
+PRN481 : 993.332284
+PRN482 : 913.783006
+PRN483 : 1036.292614
+PRN484 : 944.347075
+PRN485 : 993.774520
+PRN486 : 1004.501737
+PRN487 : 975.074516
+PRN488 : 960.381723
+PRN489 : 1032.461979
+PRN490 : 965.849830
+PRN491 : 959.343865
+PRN492 : 998.303510
+PRN493 : 1098.972429
+PRN494 : 978.774732
+PRN495 : 923.587406
+PRN496 : 934.194464
+PRN497 : 1019.233725
+PRN498 : 998.978470
+PRN499 : 969.151090
+PRN500 : 1008.850844
+PRN501 : 1002.711126
+PRN502 : 991.872449
+PRN503 : 948.998513
+PRN504 : 985.482935
+PRN505 : 1064.356664
+PRN506 : 920.085989
+PRN507 : 957.924976
+PRN508 : 1059.586657
+PRN509 : 948.912499
+PRN510 : 969.734926
+PRN511 : 991.121045
+PRN512 : 980.425651
+PRN513 : 1002.105883
+PRN514 : 1044.420229
+PRN515 : 1050.108383
+PRN516 : 1055.666511
+PRN517 : 1050.562993
+PRN518 : 918.954103
+PRN519 : 1031.398881
+PRN520 : 1015.533157
+PRN521 : 982.110348
+PRN522 : 911.625140
+PRN523 : 908.261708
+PRN524 : 892.515101
+PRN525 : 999.272597
+PRN526 : 1063.535795
+PRN527 : 1001.036057
+PRN528 : 1054.891358
+PRN529 : 970.513392
+PRN530 : 1009.957719
+PRN531 : 994.077721
+PRN532 : 1094.151066
+PRN533 : 987.039498
+PRN534 : 973.811047
+PRN535 : 959.839155
+PRN536 : 961.322994
+PRN537 : 1051.549887
+PRN538 : 931.006138
+PRN539 : 1090.452240
+PRN540 : 967.033966
+PRN541 : 991.451211
+PRN542 : 1042.788825
+PRN543 : 1075.910278
+PRN544 : 1009.225010
+PRN545 : 1005.631562
+PRN546 : 972.521547
+PRN547 : 1001.788406
+PRN548 : 1026.096292
+PRN549 : 943.517653
+PRN550 : 1043.297977
+PRN551 : 1068.734900
+PRN552 : 971.528905
+PRN553 : 1101.736300
+PRN554 : 1064.997347
+PRN555 : 1036.258822
+PRN556 : 921.038528
+PRN557 : 1009.332591
+PRN558 : 908.767369
+PRN559 : 950.432316
+PRN560 : 1025.848851
+PRN561 : 1026.275418
+PRN562 : 1027.138158
+PRN563 : 891.008164
+PRN564 : 966.635315
+PRN565 : 1105.694983
+PRN566 : 901.168653
+PRN567 : 1005.085680
+PRN568 : 986.376781
+PRN569 : 1021.988728
+PRN570 : 1032.032304
+PRN571 : 1066.922843
+PRN572 : 978.165759
+PRN573 : 985.471003
+PRN574 : 1018.542739
+PRN575 : 1104.217604
+PRN576 : 993.366411
+PRN577 : 908.428162
+PRN578 : 1030.181215
+PRN579 : 959.654949
+PRN580 : 1001.943741
+PRN581 : 1024.829762
+PRN582 : 912.207242
+PRN583 : 1016.092124
+PRN584 : 944.519752
+PRN585 : 1115.606496
+PRN586 : 884.228571
+PRN587 : 1080.684296
+PRN588 : 1000.544389
+PRN589 : 1018.277531
+PRN590 : 1069.476533
+PRN591 : 972.380515
+PRN592 : 979.162973
+PRN593 : 1040.650719
+PRN594 : 962.376923
+PRN595 : 929.303273
+PRN596 : 977.208942
+PRN597 : 1009.877287
+PRN598 : 946.361825
+PRN599 : 937.358872
+PRN600 : 1045.706701
+PRN601 : 1001.353164
+PRN602 : 1071.691606
+PRN603 : 1020.971714
+PRN604 : 957.623404
+PRN605 : 970.896382
+PRN606 : 941.442249
+PRN607 : 945.406684
+PRN608 : 980.972425
+PRN609 : 969.174424
+PRN610 : 1031.894081
+PRN611 : 1029.095046
+PRN612 : 957.535746
+PRN613 : 943.186463
+PRN614 : 955.065383
+PRN615 : 988.925782
+PRN616 : 969.603025
+PRN617 : 976.321914
+PRN618 : 1081.982260
+PRN619 : 1021.381110
+PRN620 : 978.594813
+PRN621 : 991.522599
+PRN622 : 1056.221346
+PRN623 : 1005.261003
+PRN624 : 938.437253
+PRN625 : 1005.952092
+PRN626 : 1034.131845
+PRN627 : 1026.000397
+PRN628 : 1056.506798
+PRN629 : 1007.883782
+PRN630 : 948.805620
+PRN631 : 926.033432
+PRN632 : 929.683971
+PRN633 : 1084.549770
+PRN634 : 939.995126
+PRN635 : 1017.329087
+PRN636 : 929.734793
+PRN637 : 968.947835
+PRN638 : 992.543787
+PRN639 : 1051.439605
+PRN640 : 962.215123
+PRN641 : 934.669279
+PRN642 : 873.191979
+PRN643 : 978.156276
+PRN644 : 1036.169440
+PRN645 : 1009.123122
+PRN646 : 1042.696787
+PRN647 : 1004.992474
+PRN648 : 985.307029
+PRN649 : 914.993369
+PRN650 : 883.268853
+PRN651 : 978.492871
+PRN652 : 1037.468856
+PRN653 : 903.697832
+PRN654 : 1016.299145
+PRN655 : 1032.662729
+PRN656 : 971.860043
+PRN657 : 876.217640
+PRN658 : 1076.128497
+PRN659 : 967.662496
+PRN660 : 1118.152109
+PRN661 : 959.402400
+PRN662 : 931.127652
+PRN663 : 963.395502
+PRN664 : 985.039373
+PRN665 : 1130.966014
+PRN666 : 1015.222803
+PRN667 : 979.416557
+PRN668 : 1044.451714
+PRN669 : 1013.521435
+PRN670 : 986.434595
+PRN671 : 1081.668437
+PRN672 : 1118.515896
+PRN673 : 989.972971
+PRN674 : 966.293542
+PRN675 : 960.277413
+PRN676 : 1000.049668
+PRN677 : 1082.002407
+PRN678 : 993.898160
+PRN679 : 1026.534251
+PRN680 : 962.202086
+PRN681 : 1004.697585
+PRN682 : 945.449849
+PRN683 : 1036.296061
+PRN684 : 1025.414145
+PRN685 : 1063.165272
+PRN686 : 993.281842
+PRN687 : 1024.850451
+PRN688 : 978.756895
+PRN689 : 1000.348903
+PRN690 : 886.538615
+PRN691 : 1044.053091
+PRN692 : 1011.514352
+PRN693 : 977.162158
+PRN694 : 1040.123413
+PRN695 : 1049.348768
+PRN696 : 1070.281599
+PRN697 : 994.095158
+PRN698 : 998.311277
+PRN699 : 996.305247
+PRN700 : 926.604115
+PRN701 : 1000.046728
+PRN702 : 992.973540
+PRN703 : 1001.014210
+PRN704 : 950.900234
+PRN705 : 1074.602127
+PRN706 : 987.731174
+PRN707 : 946.971275
+PRN708 : 1027.578158
+PRN709 : 1024.011220
+PRN710 : 959.145194
+PRN711 : 1006.423937
+PRN712 : 981.213721
+PRN713 : 1044.065461
+PRN714 : 979.223485
+PRN715 : 1008.857033
+PRN716 : 1043.892450
+PRN717 : 1060.529980
+PRN718 : 933.250802
+PRN719 : 1061.461152
+PRN720 : 961.259637
+PRN721 : 1058.283064
+PRN722 : 1011.319119
+PRN723 : 996.167947
+PRN724 : 1037.665974
+PRN725 : 865.574895
+PRN726 : 1002.911144
+PRN727 : 978.886205
+PRN728 : 1002.302369
+PRN729 : 945.213366
+PRN730 : 1049.330526
+PRN731 : 1011.089995
+PRN732 : 911.273000
+PRN733 : 1030.796132
+PRN734 : 1101.699446
+PRN735 : 868.524288
+PRN736 : 951.807712
+PRN737 : 997.957367
+PRN738 : 953.791979
+PRN739 : 954.430760
+PRN740 : 993.834055
+PRN741 : 1021.300808
+PRN742 : 891.272906
+PRN743 : 879.577939
+PRN744 : 1093.176950
+PRN745 : 961.198091
+PRN746 : 976.086349
+PRN747 : 900.514535
+PRN748 : 911.711376
+PRN749 : 975.997454
+PRN750 : 1007.292432
+PRN751 : 1023.266464
+PRN752 : 1066.723102
+PRN753 : 1060.468262
+PRN754 : 1115.673922
+PRN755 : 1041.290534
+PRN756 : 912.248040
+PRN757 : 1034.518587
+PRN758 : 967.154895
+PRN759 : 1043.478493
+PRN760 : 1026.025257
+PRN761 : 997.795632
+PRN762 : 948.207823
+PRN763 : 970.366980
+PRN764 : 973.390941
+PRN765 : 1008.249734
+PRN766 : 965.810614
+PRN767 : 1034.368743
+PRN768 : 969.130435
+PRN769 : 939.525153
+PRN770 : 939.346863
+PRN771 : 1098.433434
+PRN772 : 973.913623
+PRN773 : 994.629391
+PRN774 : 1019.029751
+PRN775 : 999.068601
+PRN776 : 952.374565
+PRN777 : 1005.413476
+PRN778 : 1008.606450
+PRN779 : 949.586928
+PRN780 : 984.336007
+PRN781 : 966.334220
+PRN782 : 952.353697
+PRN783 : 1081.685083
+PRN784 : 1148.865924
+PRN785 : 1043.881782
+PRN786 : 950.747262
+PRN787 : 1013.342099
+PRN788 : 1021.841738
+PRN789 : 943.202183
+PRN790 : 1018.658753
+PRN791 : 1039.519748
+PRN792 : 1066.745417
+PRN793 : 991.922297
+PRN794 : 989.993508
+PRN795 : 935.256770
+PRN796 : 1049.355101
+PRN797 : 984.271969
+PRN798 : 1046.060384
+PRN799 : 1044.170052
+PRN800 : 920.720627
+PRN801 : 938.453295
+PRN802 : 980.425711
+PRN803 : 974.857425
+PRN804 : 1016.266917
+PRN805 : 1039.658764
+PRN806 : 925.171481
+PRN807 : 982.577139
+PRN808 : 997.552114
+PRN809 : 1063.108389
+PRN810 : 927.965656
+PRN811 : 1049.828313
+PRN812 : 1012.506665
+PRN813 : 962.613627
+PRN814 : 915.580235
+PRN815 : 1003.806599
+PRN816 : 1086.454522
+PRN817 : 968.915000
+PRN818 : 1008.546559
+PRN819 : 856.499306
+PRN820 : 960.536031
+PRN821 : 1025.778766
+PRN822 : 1071.326673
+PRN823 : 993.205599
+PRN824 : 1052.750624
+PRN825 : 1040.987166
+PRN826 : 1034.039072
+PRN827 : 963.048804
+PRN828 : 970.510949
+PRN829 : 1049.829816
+PRN830 : 934.945358
+PRN831 : 980.925084
+PRN832 : 1037.321718
+PRN833 : 1031.532551
+PRN834 : 1049.045828
+PRN835 : 1086.751941
+PRN836 : 1036.770670
+PRN837 : 1032.479988
+PRN838 : 957.264581
+PRN839 : 982.586134
+PRN840 : 1002.144549
+PRN841 : 856.221346
+PRN842 : 1077.732261
+PRN843 : 1023.844204
+PRN844 : 1049.015013
+PRN845 : 1109.868706
+PRN846 : 1032.030843
+PRN847 : 994.431051
+PRN848 : 999.263384
+PRN849 : 1052.311112
+PRN850 : 955.831734
+PRN851 : 958.864423
+PRN852 : 1016.728795
+PRN853 : 1004.874796
+PRN854 : 1004.259084
+PRN855 : 963.819718
+PRN856 : 949.755330
+PRN857 : 987.900168
+PRN858 : 995.226017
+PRN859 : 1098.708859
+PRN860 : 1009.514337
+PRN861 : 948.777253
+PRN862 : 982.680500
+PRN863 : 996.028285
+PRN864 : 1029.124415
+PRN865 : 942.101818
+PRN866 : 1034.222040
+PRN867 : 949.348550
+PRN868 : 965.963597
+PRN869 : 995.021503
+PRN870 : 889.653326
+PRN871 : 951.899055
+PRN872 : 1038.667756
+PRN873 : 1088.885329
+PRN874 : 979.471141
+PRN875 : 1027.647348
+PRN876 : 1054.157446
+PRN877 : 1003.472116
+PRN878 : 914.016815
+PRN879 : 1034.862598
+PRN880 : 936.253104
+PRN881 : 962.254857
+PRN882 : 1042.166034
+PRN883 : 934.618156
+PRN884 : 939.923222
+PRN885 : 998.649324
+PRN886 : 986.753492
+PRN887 : 1095.450118
+PRN888 : 982.660119
+PRN889 : 947.149665
+PRN890 : 893.930985
+PRN891 : 956.589953
+PRN892 : 1067.312301
+PRN893 : 952.406240
+PRN894 : 986.728920
+PRN895 : 1030.999219
+PRN896 : 993.306628
+PRN897 : 972.230094
+PRN898 : 993.227094
+PRN899 : 1008.926188
+PRN900 : 976.391192
+PRN901 : 952.545561
+PRN902 : 1011.157462
+PRN903 : 1056.357455
+PRN904 : 1027.929510
+PRN905 : 986.749151
+PRN906 : 963.462803
+PRN907 : 988.772926
+PRN908 : 1031.930882
+PRN909 : 981.130300
+PRN910 : 1073.463235
+PRN911 : 1081.696380
+PRN912 : 1020.678551
+PRN913 : 906.544270
+PRN914 : 1097.495849
+PRN915 : 1113.146380
+PRN916 : 1058.443029
+PRN917 : 902.487848
+PRN918 : 1009.914281
+PRN919 : 1057.100054
+PRN920 : 940.428079
+PRN921 : 941.473058
+PRN922 : 905.716759
+PRN923 : 997.789107
+PRN924 : 962.306176
+PRN925 : 1072.504216
+PRN926 : 946.554822
+PRN927 : 972.932223
+PRN928 : 1024.961360
+PRN929 : 1080.513692
+PRN930 : 1047.137658
+PRN931 : 1012.824933
+PRN932 : 976.404512
+PRN933 : 895.604509
+PRN934 : 1114.446905
+PRN935 : 1051.342533
+PRN936 : 1027.204609
+PRN937 : 917.811842
+PRN938 : 882.306487
+PRN939 : 1010.444766
+PRN940 : 978.686109
+PRN941 : 1020.585581
+PRN942 : 989.944335
+PRN943 : 1010.484323
+PRN944 : 936.727744
+PRN945 : 1038.631446
+PRN946 : 1012.530572
+PRN947 : 961.577357
+PRN948 : 988.253770
+PRN949 : 1054.353206
+PRN950 : 964.120426
+PRN951 : 943.486864
+PRN952 : 1052.650937
+PRN953 : 980.334313
+PRN954 : 1137.186817
+PRN955 : 1125.255968
+PRN956 : 964.830093
+PRN957 : 930.646626
+PRN958 : 1043.519941
+PRN959 : 1088.829938
+PRN960 : 1024.017051
+PRN961 : 1065.574266
+PRN962 : 1008.740833
+PRN963 : 972.421950
+PRN964 : 1082.991316
+PRN965 : 963.163028
+PRN966 : 1040.184197
+PRN967 : 865.234238
+PRN968 : 1026.703665
+PRN969 : 991.758625
+PRN970 : 1091.021716
+PRN971 : 1079.872892
+PRN972 : 1042.401875
+PRN973 : 1085.624604
+PRN974 : 1055.314437
+PRN975 : 1138.344149
+PRN976 : 906.958400
+PRN977 : 954.641162
+PRN978 : 1014.840472
+PRN979 : 991.906864
+PRN980 : 947.716713
+PRN981 : 1075.346169
+PRN982 : 913.043943
+PRN983 : 1006.107228
+PRN984 : 940.937691
+PRN985 : 925.827770
+PRN986 : 870.001279
+PRN987 : 1093.348026
+PRN988 : 990.938631
+PRN989 : 1067.552107
+PRN990 : 936.441162
+PRN991 : 956.066787
+PRN992 : 1001.705214
+PRN993 : 1007.198453
+PRN994 : 956.883661
+PRN995 : 1033.645356
+PRN996 : 1036.395999
+PRN997 : 954.941658
+PRN998 : 1015.720547
+PRN999 : 1023.147999
+sample mean  : 1000.303825
+true mean    : 1000.000000
+sample stddev: 53.233584
+true stddev  : 53.000000
+z-score      : 0.181279
+p-value      : 0.428600
+QH[normality]: 1.015347
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/libavcodec-htmlsubtitles b/mythtv/external/FFmpeg/tests/ref/fate/libavcodec-htmlsubtitles
new file mode 100644
index 00000000000..66dd8e8d48d
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/libavcodec-htmlsubtitles
@@ -0,0 +1,8 @@
+<<hello>> --> <<hello>>
+<<<b>hello</b>>> --> <<{\b1}hello{\b0}>>
+< hello < 2000 > world > --> < hello < 2000 > world >
+<h1>TITLE</h1> --> TITLE
+< font color=red >red</font> --> {\c&HFF&}red{\c}
+Foo <foo@bar.com> --> Foo <foo@bar.com>
+<b> foo <I> bar </B> bla </i> --> {\b1} foo {\i1} bar {\b0} bla {\i0}
+A<br>B<BR/>C<br  / >D<  Br >E<brk><brk/> --> A\NB\NC\ND\NE
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/lmlm4-demux b/mythtv/external/FFmpeg/tests/ref/fate/lmlm4-demux
index 79cb53998b8..b0276d53e9a 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/lmlm4-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/lmlm4-demux
@@ -9,6 +9,7 @@
 #codec_id 1: mp2
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0, -9223372036854775808,        1,     5951, 0xe9118e0d
 1,          0,          0,     2160,      768, 0xaebcbebb
 1,       2160,       2160,     2160,      768, 0xaebcbebb
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/m4v-cfr b/mythtv/external/FFmpeg/tests/ref/fate/m4v-cfr
index 4eee84d01b9..e2d02032feb 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/m4v-cfr
+++ b/mythtv/external/FFmpeg/tests/ref/fate/m4v-cfr
@@ -44,4 +44,3 @@
 0,         38,         38,        1,   115200, 0xf30825d5
 0,         39,         39,        1,   115200, 0xe3c944a1
 0,         40,         40,        1,   115200, 0x8fec4420
-0,         41,         41,        1,   115200, 0x9381fdab
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mapchan-2ch-extract-ch0-ch2-trailing b/mythtv/external/FFmpeg/tests/ref/fate/mapchan-2ch-extract-ch0-ch2-trailing
new file mode 100644
index 00000000000..a5400373cf7
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mapchan-2ch-extract-ch0-ch2-trailing
@@ -0,0 +1 @@
+b6e1d142b4e484221562e7b66b9bbbdc
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mapchan-3ch-extract-ch0-ch2-trailing b/mythtv/external/FFmpeg/tests/ref/fate/mapchan-3ch-extract-ch0-ch2-trailing
new file mode 100644
index 00000000000..6237a988be0
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mapchan-3ch-extract-ch0-ch2-trailing
@@ -0,0 +1 @@
+ae533985186cab287309c04f6b3e866c
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mapchan-6ch-extract-2-downmix-mono b/mythtv/external/FFmpeg/tests/ref/fate/mapchan-6ch-extract-2-downmix-mono
index a47c85cd6b2..9ac4dba2612 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/mapchan-6ch-extract-2-downmix-mono
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mapchan-6ch-extract-2-downmix-mono
@@ -1 +1 @@
-2727e5418eb5b8f89954f140d9f3a19a
+6ededcfc9f0b26d200a7295205e87663
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mapchan-silent-mono b/mythtv/external/FFmpeg/tests/ref/fate/mapchan-silent-mono
index f720c318f46..93f519e0ee0 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/mapchan-silent-mono
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mapchan-silent-mono
@@ -1 +1 @@
-16dc73c037897dff9b1d3e3d8561dc73
+b6b034fffa8639e64d79be84f16d9ebe
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/matroska-spherical-mono b/mythtv/external/FFmpeg/tests/ref/fate/matroska-spherical-mono
new file mode 100644
index 00000000000..bd57d94514b
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/matroska-spherical-mono
@@ -0,0 +1,18 @@
+[STREAM]
+[SIDE_DATA]
+side_data_type=Stereo 3D
+type=2D
+inverted=0
+[/SIDE_DATA]
+[SIDE_DATA]
+side_data_type=Spherical Mapping
+projection=tiled equirectangular
+bound_left=148
+bound_top=73
+bound_right=147
+bound_bottom=72
+yaw=45
+pitch=30
+roll=15
+[/SIDE_DATA]
+[/STREAM]
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/maxis-xa b/mythtv/external/FFmpeg/tests/ref/fate/maxis-xa
index ae8124da705..ad9d73278ba 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/maxis-xa
+++ b/mythtv/external/FFmpeg/tests/ref/fate/maxis-xa
@@ -3,6 +3,7 @@
 #codec_id 0: adpcm_ea_maxis_xa
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,       28,       30, 0x51750711
 0,         28,         28,       28,       30, 0x9ca20c2a
 0,         56,         56,       28,       30, 0x7551081f
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mkv b/mythtv/external/FFmpeg/tests/ref/fate/mkv
index 0e7f6514d08..f9c3037f099 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/mkv
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mkv
@@ -10,6 +10,7 @@
 #codec_id 1: aac
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,        -42,          0,       41,    63501, 0x139d4c99
 0,          0,         84,       41,     5368, 0xd964b678, F=0x0
 1,          8,          8,       21,      528, 0x3c990ddf
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mkv-1242 b/mythtv/external/FFmpeg/tests/ref/fate/mkv-1242
index 1ba41a04a44..34e5b4aa9c6 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/mkv-1242
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mkv-1242
@@ -10,6 +10,7 @@
 #codec_id 1: aac
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,        -42,          0,       41,     2969, 0xa7016742
 0,          0,         42,       41,      135, 0x33af1a9e, F=0x0
 1,          0,          0,       21,        6, 0x027e00e8
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mov-3elist-encrypted b/mythtv/external/FFmpeg/tests/ref/fate/mov-3elist-encrypted
new file mode 100644
index 00000000000..daf4927e0f7
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mov-3elist-encrypted
@@ -0,0 +1,57 @@
+#format: frame checksums
+#version: 2
+#hash: MD5
+#tb 0: 1/24
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 640x480
+#sar 0: 0/1
+#stream#, dts,        pts, duration,     size, hash
+0,          0,          0,        1,   460800, 80fbbdec589e15e6c493b44d243f92a9
+0,          1,          1,        1,   460800, f4b23293bb2ecf69cc3570853d8c56a1
+0,          2,          2,        1,   460800, 0c03ce2c1c6ec405d7455465ecd559a3
+0,          3,          3,        1,   460800, 7921791695537fba2c3c123da4834cb9
+0,          4,          4,        1,   460800, 30c8e2903a561b84d4cbaf95c668d236
+0,          5,          5,        1,   460800, 7ff42e998217c17592ddf6b584f26cef
+0,          6,          6,        1,   460800, 5e402c48bf097db2d31b82bb4194a382
+0,          7,          7,        1,   460800, 824c49e92c8ae6d99a0207b514dd756c
+0,          8,          8,        1,   460800, 24f189216a1d9cf2313b2d6dbe3dbdd3
+0,          9,          9,        1,   460800, 519179a8e74275d26b183374637e003f
+0,         10,         10,        1,   460800, f18331ddcef0adf5b069bfa98baf8db4
+0,         11,         11,        1,   460800, 081f61688690d47dbdddd5384e5d5a70
+0,         12,         12,        1,   460800, 90dbf019b9035433371a8df41a9268b7
+0,         13,         13,        1,   460800, bb5adfb9c66732898b34186eca1667ba
+0,         14,         14,        1,   460800, cc08cfd64f37783ecddaf143f6ad78bc
+0,         15,         15,        1,   460800, b8ae21d024fe4df903d56f4521993c72
+0,         16,         16,        1,   460800, b45a99907f045dcadf0a2befc11555e3
+0,         17,         17,        1,   460800, 603ba935845e65ab6cccbbec88bbf60d
+0,         18,         18,        1,   460800, df80c8d3e6a77258a306903f17995a18
+0,         19,         19,        1,   460800, 4b7e90c0a5fd0e0cd958d47f0afac636
+0,         20,         20,        1,   460800, 9feb6e36182f1745be6387edea240eb6
+0,         21,         21,        1,   460800, 86e6de4bd0a5ff7558f4cf6c1ec3930d
+0,         22,         22,        1,   460800, 726b69df77edbe7b503d4698656d1320
+0,         23,         23,        1,   460800, d282fb7a953ac205b0a43d00c2d60a33
+0,         24,         24,        1,   460800, eece3daa70cc20208dd75d91ac84c8fd
+0,         25,         25,        1,   460800, c86d23e73bcce351fc315fb1f13348da
+0,         26,         26,        1,   460800, 93497b4f7c5ad9d61212239b7c9d2770
+0,         27,         27,        1,   460800, eb217d2c12de67903835a8c58f620488
+0,         28,         28,        1,   460800, d966480867bb54c8cd044f18388ed486
+0,         29,         29,        1,   460800, 3ea6207942b3181fdd8e8aa6cae1062a
+0,         30,         30,        1,   460800, 2620df54aca086ec0fb9527c6e6f5135
+0,         31,         31,        1,   460800, 43bb7320f0bb583188dc965ddbfade90
+0,         32,         32,        1,   460800, 0cddaa04645f804e02f65b0836412113
+0,         33,         33,        1,   460800, 83b2dc95807289d7f4a4632bf18c2e97
+0,         34,         34,        1,   460800, 98134d0e41e6dd12827049ccf33b4669
+0,         35,         35,        1,   460800, 56f55631731fa39c7acbab0afeb2eb1b
+0,         36,         36,        1,   460800, 379c1105be09d836a515dc909455ddf4
+0,         37,         37,        1,   460800, 1df87c47e9d98731faf1c3885b77e5da
+0,         38,         38,        1,   460800, 9a8734bcbfdb4d97e530683b8b556a26
+0,         39,         39,        1,   460800, c7a7990d0cddc5adfbe27da7a42e025e
+0,         40,         40,        1,   460800, 0c81e46011e03be410feaf056207fd55
+0,         41,         41,        1,   460800, ca76e4e63016ff29d8aeeb9cb053bb6c
+0,         42,         42,        1,   460800, cebfbe299c17c1f8fc1e6b189555c3c2
+0,         43,         43,        1,   460800, 4f002c5feca5e75f07089e0df47507dd
+0,         44,         44,        1,   460800, c5fd83fc4a745abee9b3d9a6eec9dd3e
+0,         45,         45,        1,   460800, 57d9bad9b45aa2746de5d8bdc2c24969
+0,         46,         46,        1,   460800, 9831673ad7dec167af4a959f64258949
+0,         47,         47,        1,   460800, 77a1cb208f70f51bcb01e28d8cba73b4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mov-aac-2048-priming b/mythtv/external/FFmpeg/tests/ref/fate/mov-aac-2048-priming
new file mode 100644
index 00000000000..2616944de34
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mov-aac-2048-priming
@@ -0,0 +1,218 @@
+packet|codec_type=audio|stream_index=0|pts=-2048|pts_time=-0.046440|dts=-2048|dts_time=-0.046440|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=258|pos=36|flags=KDside_data|side_data_type=Skip Samples|skip_samples=2048|discard_padding=0|skip_reason=0|discard_reason=0
+
+packet|codec_type=audio|stream_index=0|pts=-1024|pts_time=-0.023220|dts=-1024|dts_time=-0.023220|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=258|pos=294|flags=KD
+packet|codec_type=audio|stream_index=0|pts=0|pts_time=0.000000|dts=0|dts_time=0.000000|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=146|pos=552|flags=K_
+packet|codec_type=audio|stream_index=0|pts=1024|pts_time=0.023220|dts=1024|dts_time=0.023220|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=186|pos=698|flags=K_
+packet|codec_type=audio|stream_index=0|pts=2048|pts_time=0.046440|dts=2048|dts_time=0.046440|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=222|pos=884|flags=K_
+packet|codec_type=audio|stream_index=0|pts=3072|pts_time=0.069660|dts=3072|dts_time=0.069660|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=186|pos=1106|flags=K_
+packet|codec_type=audio|stream_index=0|pts=4096|pts_time=0.092880|dts=4096|dts_time=0.092880|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=206|pos=1292|flags=K_
+packet|codec_type=audio|stream_index=0|pts=5120|pts_time=0.116100|dts=5120|dts_time=0.116100|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=199|pos=1498|flags=K_
+packet|codec_type=audio|stream_index=0|pts=6144|pts_time=0.139320|dts=6144|dts_time=0.139320|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=236|pos=1697|flags=K_
+packet|codec_type=audio|stream_index=0|pts=7168|pts_time=0.162540|dts=7168|dts_time=0.162540|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=208|pos=1933|flags=K_
+packet|codec_type=audio|stream_index=0|pts=8192|pts_time=0.185760|dts=8192|dts_time=0.185760|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=238|pos=2141|flags=K_
+packet|codec_type=audio|stream_index=0|pts=9216|pts_time=0.208980|dts=9216|dts_time=0.208980|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=222|pos=2379|flags=K_
+packet|codec_type=audio|stream_index=0|pts=10240|pts_time=0.232200|dts=10240|dts_time=0.232200|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=211|pos=2601|flags=K_
+packet|codec_type=audio|stream_index=0|pts=11264|pts_time=0.255420|dts=11264|dts_time=0.255420|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=153|pos=2812|flags=K_
+packet|codec_type=audio|stream_index=0|pts=12288|pts_time=0.278639|dts=12288|dts_time=0.278639|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=191|pos=2965|flags=K_
+packet|codec_type=audio|stream_index=0|pts=13312|pts_time=0.301859|dts=13312|dts_time=0.301859|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=208|pos=3156|flags=K_
+packet|codec_type=audio|stream_index=0|pts=14336|pts_time=0.325079|dts=14336|dts_time=0.325079|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=188|pos=3364|flags=K_
+packet|codec_type=audio|stream_index=0|pts=15360|pts_time=0.348299|dts=15360|dts_time=0.348299|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=170|pos=3552|flags=K_
+packet|codec_type=audio|stream_index=0|pts=16384|pts_time=0.371519|dts=16384|dts_time=0.371519|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=221|pos=3722|flags=K_
+packet|codec_type=audio|stream_index=0|pts=17408|pts_time=0.394739|dts=17408|dts_time=0.394739|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=247|pos=3943|flags=K_
+packet|codec_type=audio|stream_index=0|pts=18432|pts_time=0.417959|dts=18432|dts_time=0.417959|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=202|pos=4190|flags=K_
+packet|codec_type=audio|stream_index=0|pts=19456|pts_time=0.441179|dts=19456|dts_time=0.441179|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=186|pos=4392|flags=K_
+packet|codec_type=audio|stream_index=0|pts=20480|pts_time=0.464399|dts=20480|dts_time=0.464399|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=196|pos=4578|flags=K_
+packet|codec_type=audio|stream_index=0|pts=21504|pts_time=0.487619|dts=21504|dts_time=0.487619|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=200|pos=4774|flags=K_
+packet|codec_type=audio|stream_index=0|pts=22528|pts_time=0.510839|dts=22528|dts_time=0.510839|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=170|pos=4974|flags=K_
+packet|codec_type=audio|stream_index=0|pts=23552|pts_time=0.534059|dts=23552|dts_time=0.534059|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=172|pos=5144|flags=K_
+packet|codec_type=audio|stream_index=0|pts=24576|pts_time=0.557279|dts=24576|dts_time=0.557279|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=206|pos=5316|flags=K_
+packet|codec_type=audio|stream_index=0|pts=25600|pts_time=0.580499|dts=25600|dts_time=0.580499|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=208|pos=5522|flags=K_
+packet|codec_type=audio|stream_index=0|pts=26624|pts_time=0.603719|dts=26624|dts_time=0.603719|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=217|pos=5730|flags=K_
+packet|codec_type=audio|stream_index=0|pts=27648|pts_time=0.626939|dts=27648|dts_time=0.626939|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=252|pos=5947|flags=K_
+packet|codec_type=audio|stream_index=0|pts=28672|pts_time=0.650159|dts=28672|dts_time=0.650159|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=171|pos=6199|flags=K_
+packet|codec_type=audio|stream_index=0|pts=29696|pts_time=0.673379|dts=29696|dts_time=0.673379|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=206|pos=6370|flags=K_
+packet|codec_type=audio|stream_index=0|pts=30720|pts_time=0.696599|dts=30720|dts_time=0.696599|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=237|pos=6576|flags=K_
+packet|codec_type=audio|stream_index=0|pts=31744|pts_time=0.719819|dts=31744|dts_time=0.719819|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=210|pos=6813|flags=K_
+packet|codec_type=audio|stream_index=0|pts=32768|pts_time=0.743039|dts=32768|dts_time=0.743039|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=166|pos=7023|flags=K_
+packet|codec_type=audio|stream_index=0|pts=33792|pts_time=0.766259|dts=33792|dts_time=0.766259|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=166|pos=7189|flags=K_
+packet|codec_type=audio|stream_index=0|pts=34816|pts_time=0.789478|dts=34816|dts_time=0.789478|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=177|pos=7355|flags=K_
+packet|codec_type=audio|stream_index=0|pts=35840|pts_time=0.812698|dts=35840|dts_time=0.812698|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=188|pos=7532|flags=K_
+packet|codec_type=audio|stream_index=0|pts=36864|pts_time=0.835918|dts=36864|dts_time=0.835918|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=193|pos=7720|flags=K_
+packet|codec_type=audio|stream_index=0|pts=37888|pts_time=0.859138|dts=37888|dts_time=0.859138|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=7913|flags=K_
+packet|codec_type=audio|stream_index=0|pts=38912|pts_time=0.882358|dts=38912|dts_time=0.882358|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=211|pos=8108|flags=K_
+packet|codec_type=audio|stream_index=0|pts=39936|pts_time=0.905578|dts=39936|dts_time=0.905578|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=249|pos=8319|flags=K_
+packet|codec_type=audio|stream_index=0|pts=40960|pts_time=0.928798|dts=40960|dts_time=0.928798|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=223|pos=8568|flags=K_
+packet|codec_type=audio|stream_index=0|pts=41984|pts_time=0.952018|dts=41984|dts_time=0.952018|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=230|pos=8791|flags=K_
+packet|codec_type=audio|stream_index=0|pts=43008|pts_time=0.975238|dts=43008|dts_time=0.975238|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=203|pos=9021|flags=K_
+packet|codec_type=audio|stream_index=0|pts=44032|pts_time=0.998458|dts=44032|dts_time=0.998458|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=180|pos=9224|flags=K_
+packet|codec_type=audio|stream_index=0|pts=45056|pts_time=1.021678|dts=45056|dts_time=1.021678|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=172|pos=9404|flags=K_
+packet|codec_type=audio|stream_index=0|pts=46080|pts_time=1.044898|dts=46080|dts_time=1.044898|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=240|pos=9576|flags=K_
+packet|codec_type=audio|stream_index=0|pts=47104|pts_time=1.068118|dts=47104|dts_time=1.068118|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=179|pos=9816|flags=K_
+packet|codec_type=audio|stream_index=0|pts=48128|pts_time=1.091338|dts=48128|dts_time=1.091338|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=191|pos=9995|flags=K_
+packet|codec_type=audio|stream_index=0|pts=49152|pts_time=1.114558|dts=49152|dts_time=1.114558|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=184|pos=10186|flags=K_
+packet|codec_type=audio|stream_index=0|pts=50176|pts_time=1.137778|dts=50176|dts_time=1.137778|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=214|pos=10370|flags=K_
+packet|codec_type=audio|stream_index=0|pts=51200|pts_time=1.160998|dts=51200|dts_time=1.160998|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=194|pos=10584|flags=K_
+packet|codec_type=audio|stream_index=0|pts=52224|pts_time=1.184218|dts=52224|dts_time=1.184218|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=235|pos=10778|flags=K_
+packet|codec_type=audio|stream_index=0|pts=53248|pts_time=1.207438|dts=53248|dts_time=1.207438|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=11013|flags=K_
+packet|codec_type=audio|stream_index=0|pts=54272|pts_time=1.230658|dts=54272|dts_time=1.230658|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=220|pos=11208|flags=K_
+packet|codec_type=audio|stream_index=0|pts=55296|pts_time=1.253878|dts=55296|dts_time=1.253878|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=187|pos=11428|flags=K_
+packet|codec_type=audio|stream_index=0|pts=56320|pts_time=1.277098|dts=56320|dts_time=1.277098|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=238|pos=11615|flags=K_
+packet|codec_type=audio|stream_index=0|pts=57344|pts_time=1.300317|dts=57344|dts_time=1.300317|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=175|pos=11853|flags=K_
+packet|codec_type=audio|stream_index=0|pts=58368|pts_time=1.323537|dts=58368|dts_time=1.323537|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=178|pos=12028|flags=K_
+packet|codec_type=audio|stream_index=0|pts=59392|pts_time=1.346757|dts=59392|dts_time=1.346757|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=219|pos=12206|flags=K_
+packet|codec_type=audio|stream_index=0|pts=60416|pts_time=1.369977|dts=60416|dts_time=1.369977|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=179|pos=12425|flags=K_
+packet|codec_type=audio|stream_index=0|pts=61440|pts_time=1.393197|dts=61440|dts_time=1.393197|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=193|pos=12604|flags=K_
+packet|codec_type=audio|stream_index=0|pts=62464|pts_time=1.416417|dts=62464|dts_time=1.416417|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=200|pos=12797|flags=K_
+packet|codec_type=audio|stream_index=0|pts=63488|pts_time=1.439637|dts=63488|dts_time=1.439637|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=218|pos=12997|flags=K_
+packet|codec_type=audio|stream_index=0|pts=64512|pts_time=1.462857|dts=64512|dts_time=1.462857|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=215|pos=13215|flags=K_
+packet|codec_type=audio|stream_index=0|pts=65536|pts_time=1.486077|dts=65536|dts_time=1.486077|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=209|pos=13430|flags=K_
+packet|codec_type=audio|stream_index=0|pts=66560|pts_time=1.509297|dts=66560|dts_time=1.509297|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=171|pos=13639|flags=K_
+packet|codec_type=audio|stream_index=0|pts=67584|pts_time=1.532517|dts=67584|dts_time=1.532517|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=179|pos=13810|flags=K_
+packet|codec_type=audio|stream_index=0|pts=68608|pts_time=1.555737|dts=68608|dts_time=1.555737|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=185|pos=13989|flags=K_
+packet|codec_type=audio|stream_index=0|pts=69632|pts_time=1.578957|dts=69632|dts_time=1.578957|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=225|pos=14174|flags=K_
+packet|codec_type=audio|stream_index=0|pts=70656|pts_time=1.602177|dts=70656|dts_time=1.602177|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=221|pos=14399|flags=K_
+packet|codec_type=audio|stream_index=0|pts=71680|pts_time=1.625397|dts=71680|dts_time=1.625397|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=201|pos=14620|flags=K_
+packet|codec_type=audio|stream_index=0|pts=72704|pts_time=1.648617|dts=72704|dts_time=1.648617|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=206|pos=14821|flags=K_
+packet|codec_type=audio|stream_index=0|pts=73728|pts_time=1.671837|dts=73728|dts_time=1.671837|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=182|pos=15027|flags=K_
+packet|codec_type=audio|stream_index=0|pts=74752|pts_time=1.695057|dts=74752|dts_time=1.695057|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=176|pos=15209|flags=K_
+packet|codec_type=audio|stream_index=0|pts=75776|pts_time=1.718277|dts=75776|dts_time=1.718277|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=233|pos=15385|flags=K_
+packet|codec_type=audio|stream_index=0|pts=76800|pts_time=1.741497|dts=76800|dts_time=1.741497|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=199|pos=15618|flags=K_
+packet|codec_type=audio|stream_index=0|pts=77824|pts_time=1.764717|dts=77824|dts_time=1.764717|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=220|pos=15817|flags=K_
+packet|codec_type=audio|stream_index=0|pts=78848|pts_time=1.787937|dts=78848|dts_time=1.787937|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=190|pos=16037|flags=K_
+packet|codec_type=audio|stream_index=0|pts=79872|pts_time=1.811156|dts=79872|dts_time=1.811156|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=210|pos=16227|flags=K_
+packet|codec_type=audio|stream_index=0|pts=80896|pts_time=1.834376|dts=80896|dts_time=1.834376|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=204|pos=16437|flags=K_
+packet|codec_type=audio|stream_index=0|pts=81920|pts_time=1.857596|dts=81920|dts_time=1.857596|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=171|pos=16641|flags=K_
+packet|codec_type=audio|stream_index=0|pts=82944|pts_time=1.880816|dts=82944|dts_time=1.880816|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=167|pos=16812|flags=K_
+packet|codec_type=audio|stream_index=0|pts=83968|pts_time=1.904036|dts=83968|dts_time=1.904036|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=200|pos=16979|flags=K_
+packet|codec_type=audio|stream_index=0|pts=84992|pts_time=1.927256|dts=84992|dts_time=1.927256|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=254|pos=17179|flags=K_
+packet|codec_type=audio|stream_index=0|pts=86016|pts_time=1.950476|dts=86016|dts_time=1.950476|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=205|pos=17433|flags=K_
+packet|codec_type=audio|stream_index=0|pts=87040|pts_time=1.973696|dts=87040|dts_time=1.973696|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=196|pos=17638|flags=K_
+packet|codec_type=audio|stream_index=0|pts=88064|pts_time=1.996916|dts=88064|dts_time=1.996916|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=190|pos=17834|flags=K_
+packet|codec_type=audio|stream_index=0|pts=89088|pts_time=2.020136|dts=89088|dts_time=2.020136|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=197|pos=18024|flags=K_
+packet|codec_type=audio|stream_index=0|pts=90112|pts_time=2.043356|dts=90112|dts_time=2.043356|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=186|pos=18221|flags=K_
+packet|codec_type=audio|stream_index=0|pts=91136|pts_time=2.066576|dts=91136|dts_time=2.066576|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=194|pos=18407|flags=K_
+packet|codec_type=audio|stream_index=0|pts=92160|pts_time=2.089796|dts=92160|dts_time=2.089796|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=227|pos=18601|flags=K_
+packet|codec_type=audio|stream_index=0|pts=93184|pts_time=2.113016|dts=93184|dts_time=2.113016|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=18828|flags=K_
+packet|codec_type=audio|stream_index=0|pts=94208|pts_time=2.136236|dts=94208|dts_time=2.136236|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=228|pos=19023|flags=K_
+packet|codec_type=audio|stream_index=0|pts=95232|pts_time=2.159456|dts=95232|dts_time=2.159456|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=196|pos=19251|flags=K_
+packet|codec_type=audio|stream_index=0|pts=96256|pts_time=2.182676|dts=96256|dts_time=2.182676|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=197|pos=19447|flags=K_
+packet|codec_type=audio|stream_index=0|pts=97280|pts_time=2.205896|dts=97280|dts_time=2.205896|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=186|pos=19644|flags=K_
+packet|codec_type=audio|stream_index=0|pts=98304|pts_time=2.229116|dts=98304|dts_time=2.229116|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=191|pos=19830|flags=K_
+packet|codec_type=audio|stream_index=0|pts=99328|pts_time=2.252336|dts=99328|dts_time=2.252336|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=215|pos=20021|flags=K_
+packet|codec_type=audio|stream_index=0|pts=100352|pts_time=2.275556|dts=100352|dts_time=2.275556|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=203|pos=20236|flags=K_
+packet|codec_type=audio|stream_index=0|pts=101376|pts_time=2.298776|dts=101376|dts_time=2.298776|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=205|pos=20439|flags=K_
+packet|codec_type=audio|stream_index=0|pts=102400|pts_time=2.321995|dts=102400|dts_time=2.321995|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=205|pos=20644|flags=K_
+packet|codec_type=audio|stream_index=0|pts=103424|pts_time=2.345215|dts=103424|dts_time=2.345215|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=213|pos=20849|flags=K_
+packet|codec_type=audio|stream_index=0|pts=104448|pts_time=2.368435|dts=104448|dts_time=2.368435|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=198|pos=21062|flags=K_
+packet|codec_type=audio|stream_index=0|pts=105472|pts_time=2.391655|dts=105472|dts_time=2.391655|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=178|pos=21260|flags=K_
+packet|codec_type=audio|stream_index=0|pts=106496|pts_time=2.414875|dts=106496|dts_time=2.414875|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=21438|flags=K_
+packet|codec_type=audio|stream_index=0|pts=107520|pts_time=2.438095|dts=107520|dts_time=2.438095|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=227|pos=21633|flags=K_
+packet|codec_type=audio|stream_index=0|pts=108544|pts_time=2.461315|dts=108544|dts_time=2.461315|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=185|pos=21860|flags=K_
+packet|codec_type=audio|stream_index=0|pts=109568|pts_time=2.484535|dts=109568|dts_time=2.484535|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=206|pos=22045|flags=K_
+packet|codec_type=audio|stream_index=0|pts=110592|pts_time=2.507755|dts=110592|dts_time=2.507755|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=183|pos=22251|flags=K_
+packet|codec_type=audio|stream_index=0|pts=111616|pts_time=2.530975|dts=111616|dts_time=2.530975|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=208|pos=22434|flags=K_
+packet|codec_type=audio|stream_index=0|pts=112640|pts_time=2.554195|dts=112640|dts_time=2.554195|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=204|pos=22642|flags=K_
+packet|codec_type=audio|stream_index=0|pts=113664|pts_time=2.577415|dts=113664|dts_time=2.577415|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=192|pos=22846|flags=K_
+packet|codec_type=audio|stream_index=0|pts=114688|pts_time=2.600635|dts=114688|dts_time=2.600635|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=190|pos=23038|flags=K_
+packet|codec_type=audio|stream_index=0|pts=115712|pts_time=2.623855|dts=115712|dts_time=2.623855|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=199|pos=23228|flags=K_
+packet|codec_type=audio|stream_index=0|pts=116736|pts_time=2.647075|dts=116736|dts_time=2.647075|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=229|pos=23427|flags=K_
+packet|codec_type=audio|stream_index=0|pts=117760|pts_time=2.670295|dts=117760|dts_time=2.670295|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=208|pos=23656|flags=K_
+packet|codec_type=audio|stream_index=0|pts=118784|pts_time=2.693515|dts=118784|dts_time=2.693515|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=23864|flags=K_
+packet|codec_type=audio|stream_index=0|pts=119808|pts_time=2.716735|dts=119808|dts_time=2.716735|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=190|pos=24059|flags=K_
+packet|codec_type=audio|stream_index=0|pts=120832|pts_time=2.739955|dts=120832|dts_time=2.739955|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=190|pos=24249|flags=K_
+packet|codec_type=audio|stream_index=0|pts=121856|pts_time=2.763175|dts=121856|dts_time=2.763175|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=192|pos=24439|flags=K_
+packet|codec_type=audio|stream_index=0|pts=122880|pts_time=2.786395|dts=122880|dts_time=2.786395|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=226|pos=24631|flags=K_
+packet|codec_type=audio|stream_index=0|pts=123904|pts_time=2.809615|dts=123904|dts_time=2.809615|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=24857|flags=K_
+packet|codec_type=audio|stream_index=0|pts=124928|pts_time=2.832834|dts=124928|dts_time=2.832834|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=230|pos=25052|flags=K_
+packet|codec_type=audio|stream_index=0|pts=125952|pts_time=2.856054|dts=125952|dts_time=2.856054|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=198|pos=25282|flags=K_
+packet|codec_type=audio|stream_index=0|pts=126976|pts_time=2.879274|dts=126976|dts_time=2.879274|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=183|pos=25480|flags=K_
+packet|codec_type=audio|stream_index=0|pts=128000|pts_time=2.902494|dts=128000|dts_time=2.902494|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=199|pos=25663|flags=K_
+packet|codec_type=audio|stream_index=0|pts=129024|pts_time=2.925714|dts=129024|dts_time=2.925714|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=196|pos=25862|flags=K_
+packet|codec_type=audio|stream_index=0|pts=130048|pts_time=2.948934|dts=130048|dts_time=2.948934|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=186|pos=26058|flags=K_
+packet|codec_type=audio|stream_index=0|pts=131072|pts_time=2.972154|dts=131072|dts_time=2.972154|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=200|pos=26244|flags=K_
+packet|codec_type=audio|stream_index=0|pts=132096|pts_time=2.995374|dts=132096|dts_time=2.995374|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=210|pos=26444|flags=K_
+packet|codec_type=audio|stream_index=0|pts=133120|pts_time=3.018594|dts=133120|dts_time=3.018594|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=196|pos=26654|flags=K_
+packet|codec_type=audio|stream_index=0|pts=134144|pts_time=3.041814|dts=134144|dts_time=3.041814|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=214|pos=26850|flags=K_
+packet|codec_type=audio|stream_index=0|pts=135168|pts_time=3.065034|dts=135168|dts_time=3.065034|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=185|pos=27064|flags=K_
+packet|codec_type=audio|stream_index=0|pts=136192|pts_time=3.088254|dts=136192|dts_time=3.088254|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=198|pos=27249|flags=K_
+packet|codec_type=audio|stream_index=0|pts=137216|pts_time=3.111474|dts=137216|dts_time=3.111474|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=200|pos=27447|flags=K_
+packet|codec_type=audio|stream_index=0|pts=138240|pts_time=3.134694|dts=138240|dts_time=3.134694|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=208|pos=27647|flags=K_
+packet|codec_type=audio|stream_index=0|pts=139264|pts_time=3.157914|dts=139264|dts_time=3.157914|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=212|pos=27855|flags=K_
+packet|codec_type=audio|stream_index=0|pts=140288|pts_time=3.181134|dts=140288|dts_time=3.181134|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=208|pos=28067|flags=K_
+packet|codec_type=audio|stream_index=0|pts=141312|pts_time=3.204354|dts=141312|dts_time=3.204354|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=192|pos=28275|flags=K_
+packet|codec_type=audio|stream_index=0|pts=142336|pts_time=3.227574|dts=142336|dts_time=3.227574|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=192|pos=28467|flags=K_
+packet|codec_type=audio|stream_index=0|pts=143360|pts_time=3.250794|dts=143360|dts_time=3.250794|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=211|pos=28659|flags=K_
+packet|codec_type=audio|stream_index=0|pts=144384|pts_time=3.274014|dts=144384|dts_time=3.274014|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=28870|flags=K_
+packet|codec_type=audio|stream_index=0|pts=145408|pts_time=3.297234|dts=145408|dts_time=3.297234|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=208|pos=29065|flags=K_
+packet|codec_type=audio|stream_index=0|pts=146432|pts_time=3.320454|dts=146432|dts_time=3.320454|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=29273|flags=K_
+packet|codec_type=audio|stream_index=0|pts=147456|pts_time=3.343673|dts=147456|dts_time=3.343673|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=204|pos=29468|flags=K_
+packet|codec_type=audio|stream_index=0|pts=148480|pts_time=3.366893|dts=148480|dts_time=3.366893|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=209|pos=29672|flags=K_
+packet|codec_type=audio|stream_index=0|pts=149504|pts_time=3.390113|dts=149504|dts_time=3.390113|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=29881|flags=K_
+packet|codec_type=audio|stream_index=0|pts=150528|pts_time=3.413333|dts=150528|dts_time=3.413333|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=191|pos=30076|flags=K_
+packet|codec_type=audio|stream_index=0|pts=151552|pts_time=3.436553|dts=151552|dts_time=3.436553|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=210|pos=30267|flags=K_
+packet|codec_type=audio|stream_index=0|pts=152576|pts_time=3.459773|dts=152576|dts_time=3.459773|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=209|pos=30477|flags=K_
+packet|codec_type=audio|stream_index=0|pts=153600|pts_time=3.482993|dts=153600|dts_time=3.482993|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=175|pos=30686|flags=K_
+packet|codec_type=audio|stream_index=0|pts=154624|pts_time=3.506213|dts=154624|dts_time=3.506213|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=244|pos=30861|flags=K_
+packet|codec_type=audio|stream_index=0|pts=155648|pts_time=3.529433|dts=155648|dts_time=3.529433|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=177|pos=31105|flags=K_
+packet|codec_type=audio|stream_index=0|pts=156672|pts_time=3.552653|dts=156672|dts_time=3.552653|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=217|pos=31282|flags=K_
+packet|codec_type=audio|stream_index=0|pts=157696|pts_time=3.575873|dts=157696|dts_time=3.575873|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=182|pos=31499|flags=K_
+packet|codec_type=audio|stream_index=0|pts=158720|pts_time=3.599093|dts=158720|dts_time=3.599093|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=181|pos=31681|flags=K_
+packet|codec_type=audio|stream_index=0|pts=159744|pts_time=3.622313|dts=159744|dts_time=3.622313|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=203|pos=31862|flags=K_
+packet|codec_type=audio|stream_index=0|pts=160768|pts_time=3.645533|dts=160768|dts_time=3.645533|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=198|pos=32065|flags=K_
+packet|codec_type=audio|stream_index=0|pts=161792|pts_time=3.668753|dts=161792|dts_time=3.668753|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=217|pos=32263|flags=K_
+packet|codec_type=audio|stream_index=0|pts=162816|pts_time=3.691973|dts=162816|dts_time=3.691973|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=32480|flags=K_
+packet|codec_type=audio|stream_index=0|pts=163840|pts_time=3.715193|dts=163840|dts_time=3.715193|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=198|pos=32675|flags=K_
+packet|codec_type=audio|stream_index=0|pts=164864|pts_time=3.738413|dts=164864|dts_time=3.738413|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=202|pos=32873|flags=K_
+packet|codec_type=audio|stream_index=0|pts=165888|pts_time=3.761633|dts=165888|dts_time=3.761633|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=185|pos=33075|flags=K_
+packet|codec_type=audio|stream_index=0|pts=166912|pts_time=3.784853|dts=166912|dts_time=3.784853|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=196|pos=33260|flags=K_
+packet|codec_type=audio|stream_index=0|pts=167936|pts_time=3.808073|dts=167936|dts_time=3.808073|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=226|pos=33456|flags=K_
+packet|codec_type=audio|stream_index=0|pts=168960|pts_time=3.831293|dts=168960|dts_time=3.831293|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=187|pos=33682|flags=K_
+packet|codec_type=audio|stream_index=0|pts=169984|pts_time=3.854512|dts=169984|dts_time=3.854512|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=193|pos=33869|flags=K_
+packet|codec_type=audio|stream_index=0|pts=171008|pts_time=3.877732|dts=171008|dts_time=3.877732|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=218|pos=34062|flags=K_
+packet|codec_type=audio|stream_index=0|pts=172032|pts_time=3.900952|dts=172032|dts_time=3.900952|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=200|pos=34280|flags=K_
+packet|codec_type=audio|stream_index=0|pts=173056|pts_time=3.924172|dts=173056|dts_time=3.924172|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=200|pos=34480|flags=K_
+packet|codec_type=audio|stream_index=0|pts=174080|pts_time=3.947392|dts=174080|dts_time=3.947392|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=198|pos=34680|flags=K_
+packet|codec_type=audio|stream_index=0|pts=175104|pts_time=3.970612|dts=175104|dts_time=3.970612|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=200|pos=34878|flags=K_
+packet|codec_type=audio|stream_index=0|pts=176128|pts_time=3.993832|dts=176128|dts_time=3.993832|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=197|pos=35078|flags=K_
+packet|codec_type=audio|stream_index=0|pts=177152|pts_time=4.017052|dts=177152|dts_time=4.017052|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=209|pos=35275|flags=K_
+packet|codec_type=audio|stream_index=0|pts=178176|pts_time=4.040272|dts=178176|dts_time=4.040272|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=205|pos=35484|flags=K_
+packet|codec_type=audio|stream_index=0|pts=179200|pts_time=4.063492|dts=179200|dts_time=4.063492|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=199|pos=35689|flags=K_
+packet|codec_type=audio|stream_index=0|pts=180224|pts_time=4.086712|dts=180224|dts_time=4.086712|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=192|pos=35888|flags=K_
+packet|codec_type=audio|stream_index=0|pts=181248|pts_time=4.109932|dts=181248|dts_time=4.109932|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=201|pos=36080|flags=K_
+packet|codec_type=audio|stream_index=0|pts=182272|pts_time=4.133152|dts=182272|dts_time=4.133152|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=200|pos=36281|flags=K_
+packet|codec_type=audio|stream_index=0|pts=183296|pts_time=4.156372|dts=183296|dts_time=4.156372|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=202|pos=36481|flags=K_
+packet|codec_type=audio|stream_index=0|pts=184320|pts_time=4.179592|dts=184320|dts_time=4.179592|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=196|pos=36683|flags=K_
+packet|codec_type=audio|stream_index=0|pts=185344|pts_time=4.202812|dts=185344|dts_time=4.202812|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=200|pos=36879|flags=K_
+packet|codec_type=audio|stream_index=0|pts=186368|pts_time=4.226032|dts=186368|dts_time=4.226032|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=209|pos=37079|flags=K_
+packet|codec_type=audio|stream_index=0|pts=187392|pts_time=4.249252|dts=187392|dts_time=4.249252|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=201|pos=37288|flags=K_
+packet|codec_type=audio|stream_index=0|pts=188416|pts_time=4.272472|dts=188416|dts_time=4.272472|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=201|pos=37489|flags=K_
+packet|codec_type=audio|stream_index=0|pts=189440|pts_time=4.295692|dts=189440|dts_time=4.295692|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=201|pos=37690|flags=K_
+packet|codec_type=audio|stream_index=0|pts=190464|pts_time=4.318912|dts=190464|dts_time=4.318912|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=199|pos=37891|flags=K_
+packet|codec_type=audio|stream_index=0|pts=191488|pts_time=4.342132|dts=191488|dts_time=4.342132|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=198|pos=38090|flags=K_
+packet|codec_type=audio|stream_index=0|pts=192512|pts_time=4.365351|dts=192512|dts_time=4.365351|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=205|pos=38288|flags=K_
+packet|codec_type=audio|stream_index=0|pts=193536|pts_time=4.388571|dts=193536|dts_time=4.388571|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=190|pos=38493|flags=K_
+packet|codec_type=audio|stream_index=0|pts=194560|pts_time=4.411791|dts=194560|dts_time=4.411791|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=207|pos=38683|flags=K_
+packet|codec_type=audio|stream_index=0|pts=195584|pts_time=4.435011|dts=195584|dts_time=4.435011|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=204|pos=38890|flags=K_
+packet|codec_type=audio|stream_index=0|pts=196608|pts_time=4.458231|dts=196608|dts_time=4.458231|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=192|pos=39094|flags=K_
+packet|codec_type=audio|stream_index=0|pts=197632|pts_time=4.481451|dts=197632|dts_time=4.481451|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=211|pos=39286|flags=K_
+packet|codec_type=audio|stream_index=0|pts=198656|pts_time=4.504671|dts=198656|dts_time=4.504671|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=39497|flags=K_
+packet|codec_type=audio|stream_index=0|pts=199680|pts_time=4.527891|dts=199680|dts_time=4.527891|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=214|pos=39692|flags=K_
+packet|codec_type=audio|stream_index=0|pts=200704|pts_time=4.551111|dts=200704|dts_time=4.551111|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=195|pos=39906|flags=K_
+packet|codec_type=audio|stream_index=0|pts=201728|pts_time=4.574331|dts=201728|dts_time=4.574331|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=199|pos=40101|flags=K_
+packet|codec_type=audio|stream_index=0|pts=202752|pts_time=4.597551|dts=202752|dts_time=4.597551|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=183|pos=40300|flags=K_
+packet|codec_type=audio|stream_index=0|pts=203776|pts_time=4.620771|dts=203776|dts_time=4.620771|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=211|pos=40483|flags=K_
+packet|codec_type=audio|stream_index=0|pts=204800|pts_time=4.643991|dts=204800|dts_time=4.643991|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=200|pos=40694|flags=K_
+packet|codec_type=audio|stream_index=0|pts=205824|pts_time=4.667211|dts=205824|dts_time=4.667211|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=199|pos=40894|flags=K_
+packet|codec_type=audio|stream_index=0|pts=206848|pts_time=4.690431|dts=206848|dts_time=4.690431|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=213|pos=41093|flags=K_
+packet|codec_type=audio|stream_index=0|pts=207872|pts_time=4.713651|dts=207872|dts_time=4.713651|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=191|pos=41306|flags=K_
+packet|codec_type=audio|stream_index=0|pts=208896|pts_time=4.736871|dts=208896|dts_time=4.736871|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=211|pos=41497|flags=K_
+packet|codec_type=audio|stream_index=0|pts=209920|pts_time=4.760091|dts=209920|dts_time=4.760091|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=198|pos=41708|flags=K_
+packet|codec_type=audio|stream_index=0|pts=210944|pts_time=4.783311|dts=210944|dts_time=4.783311|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=203|pos=41906|flags=K_
+packet|codec_type=audio|stream_index=0|pts=211968|pts_time=4.806531|dts=211968|dts_time=4.806531|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=196|pos=42109|flags=K_
+packet|codec_type=audio|stream_index=0|pts=212992|pts_time=4.829751|dts=212992|dts_time=4.829751|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=197|pos=42305|flags=K_
+packet|codec_type=audio|stream_index=0|pts=214016|pts_time=4.852971|dts=214016|dts_time=4.852971|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=190|pos=42502|flags=K_
+packet|codec_type=audio|stream_index=0|pts=215040|pts_time=4.876190|dts=215040|dts_time=4.876190|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=208|pos=42692|flags=K_
+packet|codec_type=audio|stream_index=0|pts=216064|pts_time=4.899410|dts=216064|dts_time=4.899410|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=203|pos=42900|flags=K_
+packet|codec_type=audio|stream_index=0|pts=217088|pts_time=4.922630|dts=217088|dts_time=4.922630|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=198|pos=43103|flags=K_
+packet|codec_type=audio|stream_index=0|pts=218112|pts_time=4.945850|dts=218112|dts_time=4.945850|duration=1024|duration_time=0.023220|convergence_duration=N/A|convergence_duration_time=N/A|size=284|pos=43301|flags=K_
+packet|codec_type=audio|stream_index=0|pts=219136|pts_time=4.969070|dts=219136|dts_time=4.969070|duration=1364|duration_time=0.030930|convergence_duration=N/A|convergence_duration_time=N/A|size=5|pos=43585|flags=K_
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mov-displaymatrix b/mythtv/external/FFmpeg/tests/ref/fate/mov-displaymatrix
new file mode 100644
index 00000000000..a40fcf6db7c
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mov-displaymatrix
@@ -0,0 +1,13 @@
+[STREAM]
+sample_aspect_ratio=1:2
+display_aspect_ratio=1:3
+[SIDE_DATA]
+side_data_type=Display Matrix
+displaymatrix=
+00000000:            0      131072           0
+00000001:       -65536           0           0
+00000002:     47185920           0  1073741824
+
+rotation=-90
+[/SIDE_DATA]
+[/STREAM]
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mov-init-nonkeyframe b/mythtv/external/FFmpeg/tests/ref/fate/mov-init-nonkeyframe
new file mode 100644
index 00000000000..0e8184643a4
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mov-init-nonkeyframe
@@ -0,0 +1,120 @@
+packet|codec_type=video|stream_index=0|pts=0|pts_time=0.000000|dts=0|dts_time=0.000000|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=599|pos=48|flags=__
+packet|codec_type=video|stream_index=0|pts=2002|pts_time=0.066733|dts=1001|dts_time=0.033367|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2944|pos=1674|flags=__
+packet|codec_type=video|stream_index=0|pts=7007|pts_time=0.233567|dts=2002|dts_time=0.066733|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=21987|pos=5335|flags=__
+packet|codec_type=video|stream_index=0|pts=5005|pts_time=0.166833|dts=3003|dts_time=0.100100|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=4145|pos=28605|flags=__
+packet|codec_type=video|stream_index=0|pts=4004|pts_time=0.133467|dts=4004|dts_time=0.133467|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3093|pos=33425|flags=__
+packet|codec_type=video|stream_index=0|pts=6006|pts_time=0.200200|dts=5005|dts_time=0.166833|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=572|pos=37769|flags=__
+packet|codec_type=video|stream_index=0|pts=11011|pts_time=0.367033|dts=6006|dts_time=0.200200|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=21599|pos=38999|flags=__
+packet|codec_type=video|stream_index=0|pts=9009|pts_time=0.300300|dts=7007|dts_time=0.233567|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=6287|pos=61922|flags=__
+packet|codec_type=video|stream_index=0|pts=8008|pts_time=0.266933|dts=8008|dts_time=0.266933|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2720|pos=68909|flags=__
+packet|codec_type=video|stream_index=0|pts=10010|pts_time=0.333667|dts=9009|dts_time=0.300300|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2715|pos=72301|flags=__
+packet|codec_type=video|stream_index=0|pts=15015|pts_time=0.500500|dts=10010|dts_time=0.333667|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=20221|pos=76433|flags=__
+packet|codec_type=video|stream_index=0|pts=13013|pts_time=0.433767|dts=11011|dts_time=0.367033|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=9505|pos=97381|flags=__
+packet|codec_type=video|stream_index=0|pts=12012|pts_time=0.400400|dts=12012|dts_time=0.400400|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=522|pos=108391|flags=__
+packet|codec_type=video|stream_index=0|pts=14014|pts_time=0.467133|dts=13013|dts_time=0.433767|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2360|pos=109683|flags=__
+packet|codec_type=video|stream_index=0|pts=17017|pts_time=0.567233|dts=14014|dts_time=0.467133|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=22156|pos=113572|flags=__
+packet|codec_type=video|stream_index=0|pts=16016|pts_time=0.533867|dts=15015|dts_time=0.500500|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1801|pos=136496|flags=__
+packet|codec_type=video|stream_index=0|pts=21021|pts_time=0.700700|dts=16016|dts_time=0.533867|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=20181|pos=139074|flags=__
+packet|codec_type=video|stream_index=0|pts=19019|pts_time=0.633967|dts=17017|dts_time=0.567233|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3608|pos=160959|flags=__
+packet|codec_type=video|stream_index=0|pts=18018|pts_time=0.600600|dts=18018|dts_time=0.600600|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=368|pos=165305|flags=__
+packet|codec_type=video|stream_index=0|pts=20020|pts_time=0.667333|dts=19019|dts_time=0.633967|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2989|pos=167054|flags=__
+packet|codec_type=video|stream_index=0|pts=25025|pts_time=0.834167|dts=20020|dts_time=0.667333|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=24475|pos=170801|flags=__
+packet|codec_type=video|stream_index=0|pts=23023|pts_time=0.767433|dts=21021|dts_time=0.700700|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=10682|pos=196732|flags=__
+packet|codec_type=video|stream_index=0|pts=22022|pts_time=0.734067|dts=22022|dts_time=0.734067|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3198|pos=208151|flags=__
+packet|codec_type=video|stream_index=0|pts=24024|pts_time=0.800800|dts=23023|dts_time=0.767433|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=479|pos=212958|flags=__
+packet|codec_type=video|stream_index=0|pts=29029|pts_time=0.967633|dts=24024|dts_time=0.800800|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=21240|pos=214384|flags=__
+packet|codec_type=video|stream_index=0|pts=27027|pts_time=0.900900|dts=25025|dts_time=0.834167|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=4409|pos=236946|flags=__
+packet|codec_type=video|stream_index=0|pts=26026|pts_time=0.867533|dts=26026|dts_time=0.867533|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3106|pos=242647|flags=__
+packet|codec_type=video|stream_index=0|pts=28028|pts_time=0.934267|dts=27027|dts_time=0.900900|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=453|pos=246428|flags=__
+packet|codec_type=video|stream_index=0|pts=33033|pts_time=1.101100|dts=28028|dts_time=0.934267|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=20668|pos=248308|flags=__
+packet|codec_type=video|stream_index=0|pts=31031|pts_time=1.034367|dts=29029|dts_time=0.967633|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=6668|pos=269708|flags=__
+packet|codec_type=video|stream_index=0|pts=30030|pts_time=1.001000|dts=30030|dts_time=1.001000|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3027|pos=277789|flags=__
+packet|codec_type=video|stream_index=0|pts=32032|pts_time=1.067733|dts=31031|dts_time=1.034367|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2884|pos=281613|flags=__
+packet|codec_type=video|stream_index=0|pts=37037|pts_time=1.234567|dts=32032|dts_time=1.067733|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=21313|pos=285261|flags=__
+packet|codec_type=video|stream_index=0|pts=35035|pts_time=1.167833|dts=33033|dts_time=1.101100|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=9890|pos=308303|flags=__
+packet|codec_type=video|stream_index=0|pts=34034|pts_time=1.134467|dts=34034|dts_time=1.134467|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=501|pos=318919|flags=__
+packet|codec_type=video|stream_index=0|pts=36036|pts_time=1.201200|dts=35035|dts_time=1.167833|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3123|pos=320824|flags=__
+packet|codec_type=video|stream_index=0|pts=39039|pts_time=1.301300|dts=36036|dts_time=1.201200|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=21768|pos=324664|flags=__
+packet|codec_type=video|stream_index=0|pts=38038|pts_time=1.267933|dts=37037|dts_time=1.234567|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2664|pos=347922|flags=__
+packet|codec_type=video|stream_index=0|pts=43043|pts_time=1.434767|dts=38038|dts_time=1.267933|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=19144|pos=351354|flags=__
+packet|codec_type=video|stream_index=0|pts=41041|pts_time=1.368033|dts=39039|dts_time=1.301300|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=4118|pos=371991|flags=__
+packet|codec_type=video|stream_index=0|pts=40040|pts_time=1.334667|dts=40040|dts_time=1.334667|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=423|pos=376899|flags=__
+packet|codec_type=video|stream_index=0|pts=42042|pts_time=1.401400|dts=41041|dts_time=1.368033|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2785|pos=378037|flags=__
+packet|codec_type=video|stream_index=0|pts=45045|pts_time=1.501500|dts=42042|dts_time=1.401400|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=24489|pos=382144|flags=__
+packet|codec_type=video|stream_index=0|pts=44044|pts_time=1.468133|dts=43043|dts_time=1.434767|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2984|pos=407344|flags=__
+packet|codec_type=video|stream_index=0|pts=49049|pts_time=1.634967|dts=44044|dts_time=1.468133|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=19174|pos=411791|flags=__
+packet|codec_type=video|stream_index=0|pts=47047|pts_time=1.568233|dts=45045|dts_time=1.501500|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=4905|pos=431740|flags=__
+packet|codec_type=video|stream_index=0|pts=46046|pts_time=1.534867|dts=46046|dts_time=1.534867|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=412|pos=438183|flags=__
+packet|codec_type=video|stream_index=0|pts=48048|pts_time=1.601600|dts=47047|dts_time=1.568233|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3215|pos=439373|flags=__
+packet|codec_type=video|stream_index=0|pts=51051|pts_time=1.701700|dts=48048|dts_time=1.601600|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=21572|pos=443371|flags=__
+packet|codec_type=video|stream_index=0|pts=50050|pts_time=1.668333|dts=49049|dts_time=1.634967|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2644|pos=466486|flags=__
+packet|codec_type=video|stream_index=0|pts=55055|pts_time=1.835167|dts=50050|dts_time=1.668333|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=19417|pos=470462|flags=__
+packet|codec_type=video|stream_index=0|pts=53053|pts_time=1.768433|dts=51051|dts_time=1.701700|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3685|pos=491335|flags=__
+packet|codec_type=video|stream_index=0|pts=52052|pts_time=1.735067|dts=52052|dts_time=1.735067|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=355|pos=495771|flags=__
+packet|codec_type=video|stream_index=0|pts=54054|pts_time=1.801800|dts=53053|dts_time=1.768433|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3021|pos=497714|flags=__
+packet|codec_type=video|stream_index=0|pts=59059|pts_time=1.968633|dts=54054|dts_time=1.801800|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=21464|pos=501431|flags=__
+packet|codec_type=video|stream_index=0|pts=57057|pts_time=1.901900|dts=55055|dts_time=1.835167|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=9340|pos=524392|flags=__
+packet|codec_type=video|stream_index=0|pts=56056|pts_time=1.868533|dts=56056|dts_time=1.868533|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=406|pos=534504|flags=__
+packet|codec_type=video|stream_index=0|pts=58058|pts_time=1.935267|dts=57057|dts_time=1.901900|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3277|pos=535694|flags=__
+packet|codec_type=video|stream_index=0|pts=63063|pts_time=2.102100|dts=58058|dts_time=1.935267|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=21388|pos=541090|flags=__
+packet|codec_type=video|stream_index=0|pts=61061|pts_time=2.035367|dts=59059|dts_time=1.968633|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=4466|pos=563132|flags=__
+packet|codec_type=video|stream_index=0|pts=60060|pts_time=2.002000|dts=60060|dts_time=2.002000|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3467|pos=569245|flags=__
+packet|codec_type=video|stream_index=0|pts=62062|pts_time=2.068733|dts=61061|dts_time=2.035367|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=499|pos=573478|flags=__
+packet|codec_type=video|stream_index=0|pts=67067|pts_time=2.235567|dts=62062|dts_time=2.068733|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=25972|pos=575469|flags=__
+packet|codec_type=video|stream_index=0|pts=65065|pts_time=2.168833|dts=63063|dts_time=2.102100|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=6643|pos=602163|flags=__
+packet|codec_type=video|stream_index=0|pts=64064|pts_time=2.135467|dts=64064|dts_time=2.135467|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3069|pos=609558|flags=__
+packet|codec_type=video|stream_index=0|pts=66066|pts_time=2.202200|dts=65065|dts_time=2.168833|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3049|pos=614133|flags=__
+packet|codec_type=video|stream_index=0|pts=68068|pts_time=2.268933|dts=66066|dts_time=2.202200|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=4559|pos=618551|flags=__
+packet|codec_type=video|stream_index=0|pts=72072|pts_time=2.402400|dts=67067|dts_time=2.235567|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=21251|pos=624621|flags=__
+packet|codec_type=video|stream_index=0|pts=70070|pts_time=2.335667|dts=68068|dts_time=2.268933|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=7108|pos=646657|flags=__
+packet|codec_type=video|stream_index=0|pts=69069|pts_time=2.302300|dts=69069|dts_time=2.302300|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3250|pos=655299|flags=__
+packet|codec_type=video|stream_index=0|pts=71071|pts_time=2.369033|dts=70070|dts_time=2.335667|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3365|pos=659310|flags=__
+packet|codec_type=video|stream_index=0|pts=73073|pts_time=2.435767|dts=71071|dts_time=2.369033|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=24803|pos=664201|flags=__
+packet|codec_type=video|stream_index=0|pts=77077|pts_time=2.569233|dts=72072|dts_time=2.402400|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=22185|pos=689763|flags=__
+packet|codec_type=video|stream_index=0|pts=75075|pts_time=2.502500|dts=73073|dts_time=2.435767|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=5088|pos=712679|flags=__
+packet|codec_type=video|stream_index=0|pts=74074|pts_time=2.469133|dts=74074|dts_time=2.469133|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=537|pos=719128|flags=__
+packet|codec_type=video|stream_index=0|pts=76076|pts_time=2.535867|dts=75075|dts_time=2.502500|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3765|pos=720413|flags=__
+packet|codec_type=video|stream_index=0|pts=81081|pts_time=2.702700|dts=76076|dts_time=2.535867|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=20654|pos=725583|flags=__
+packet|codec_type=video|stream_index=0|pts=79079|pts_time=2.635967|dts=77077|dts_time=2.569233|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=10202|pos=746999|flags=__
+packet|codec_type=video|stream_index=0|pts=78078|pts_time=2.602600|dts=78078|dts_time=2.602600|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3970|pos=758705|flags=__
+packet|codec_type=video|stream_index=0|pts=80080|pts_time=2.669333|dts=79079|dts_time=2.635967|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=421|pos=763442|flags=__
+packet|codec_type=video|stream_index=0|pts=84084|pts_time=2.802800|dts=80080|dts_time=2.669333|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=25685|pos=764653|flags=__
+packet|codec_type=video|stream_index=0|pts=82082|pts_time=2.736067|dts=81081|dts_time=2.702700|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=4077|pos=791911|flags=__
+packet|codec_type=video|stream_index=0|pts=83083|pts_time=2.769433|dts=82082|dts_time=2.736067|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3049|pos=796780|flags=__
+packet|codec_type=video|stream_index=0|pts=88088|pts_time=2.936267|dts=83083|dts_time=2.769433|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=8924|pos=801473|flags=__
+packet|codec_type=video|stream_index=0|pts=86086|pts_time=2.869533|dts=84084|dts_time=2.802800|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2512|pos=811078|flags=__
+packet|codec_type=video|stream_index=0|pts=85085|pts_time=2.836167|dts=85085|dts_time=2.836167|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=163|pos=815033|flags=__
+packet|codec_type=video|stream_index=0|pts=87087|pts_time=2.902900|dts=86086|dts_time=2.869533|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1734|pos=815934|flags=__
+packet|codec_type=video|stream_index=0|pts=90090|pts_time=3.003000|dts=87087|dts_time=2.902900|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=11505|pos=819088|flags=__
+packet|codec_type=video|stream_index=0|pts=89089|pts_time=2.969633|dts=88088|dts_time=2.936267|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1431|pos=831367|flags=__
+packet|codec_type=video|stream_index=0|pts=92092|pts_time=3.069733|dts=89089|dts_time=2.969633|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=5269|pos=833580|flags=__
+packet|codec_type=video|stream_index=0|pts=91091|pts_time=3.036367|dts=90090|dts_time=3.003000|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=199|pos=840352|flags=__
+packet|codec_type=video|stream_index=0|pts=93093|pts_time=3.103100|dts=91091|dts_time=3.036367|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=85650|pos=841722|flags=K_
+packet|codec_type=video|stream_index=0|pts=95095|pts_time=3.169833|dts=92092|dts_time=3.069733|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=13261|pos=928747|flags=__
+packet|codec_type=video|stream_index=0|pts=94094|pts_time=3.136467|dts=93093|dts_time=3.103100|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1667|pos=942741|flags=__
+packet|codec_type=video|stream_index=0|pts=99099|pts_time=3.303300|dts=94094|dts_time=3.136467|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=20143|pos=945841|flags=__
+packet|codec_type=video|stream_index=0|pts=97097|pts_time=3.236567|dts=95095|dts_time=3.169833|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2484|pos=966681|flags=__
+packet|codec_type=video|stream_index=0|pts=96096|pts_time=3.203200|dts=96096|dts_time=3.203200|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=278|pos=969887|flags=__
+packet|codec_type=video|stream_index=0|pts=98098|pts_time=3.269933|dts=97097|dts_time=3.236567|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1539|pos=971696|flags=__
+packet|codec_type=video|stream_index=0|pts=101101|pts_time=3.370033|dts=98098|dts_time=3.269933|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=20270|pos=974088|flags=__
+packet|codec_type=video|stream_index=0|pts=100100|pts_time=3.336667|dts=99099|dts_time=3.303300|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1754|pos=995975|flags=__
+packet|codec_type=video|stream_index=0|pts=105105|pts_time=3.503500|dts=100100|dts_time=3.336667|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=19154|pos=998420|flags=__
+packet|codec_type=video|stream_index=0|pts=103103|pts_time=3.436767|dts=101101|dts_time=3.370033|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3359|pos=1019010|flags=__
+packet|codec_type=video|stream_index=0|pts=102102|pts_time=3.403400|dts=102102|dts_time=3.403400|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=287|pos=1023138|flags=__
+packet|codec_type=video|stream_index=0|pts=104104|pts_time=3.470133|dts=103103|dts_time=3.436767|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2111|pos=1024928|flags=__
+packet|codec_type=video|stream_index=0|pts=109109|pts_time=3.636967|dts=104104|dts_time=3.470133|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=17178|pos=1027833|flags=__
+packet|codec_type=video|stream_index=0|pts=107107|pts_time=3.570233|dts=105105|dts_time=3.503500|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=7205|pos=1045716|flags=__
+packet|codec_type=video|stream_index=0|pts=106106|pts_time=3.536867|dts=106106|dts_time=3.536867|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2209|pos=1054354|flags=__
+packet|codec_type=video|stream_index=0|pts=108108|pts_time=3.603600|dts=107107|dts_time=3.570233|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=359|pos=1057226|flags=__
+packet|codec_type=video|stream_index=0|pts=113113|pts_time=3.770433|dts=108108|dts_time=3.603600|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=18469|pos=1059024|flags=__
+packet|codec_type=video|stream_index=0|pts=111111|pts_time=3.703700|dts=109109|dts_time=3.636967|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3314|pos=1078213|flags=__
+packet|codec_type=video|stream_index=0|pts=110110|pts_time=3.670333|dts=110110|dts_time=3.670333|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2556|pos=1083059|flags=__
+packet|codec_type=video|stream_index=0|pts=112112|pts_time=3.737067|dts=111111|dts_time=3.703700|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=437|pos=1086388|flags=__
+packet|codec_type=video|stream_index=0|pts=117117|pts_time=3.903900|dts=112112|dts_time=3.737067|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=19707|pos=1087610|flags=__
+packet|codec_type=video|stream_index=0|pts=115115|pts_time=3.837167|dts=113113|dts_time=3.770433|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=5917|pos=1108845|flags=__
+packet|codec_type=video|stream_index=0|pts=114114|pts_time=3.803800|dts=114114|dts_time=3.803800|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2613|pos=1115495|flags=__
+packet|codec_type=video|stream_index=0|pts=116116|pts_time=3.870533|dts=115115|dts_time=3.837167|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2672|pos=1119530|flags=__
+packet|codec_type=video|stream_index=0|pts=121121|pts_time=4.037367|dts=116116|dts_time=3.870533|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=19091|pos=1122970|flags=_D
+packet|codec_type=video|stream_index=0|pts=119119|pts_time=3.970633|dts=117117|dts_time=3.903900|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=9244|pos=1143585|flags=__
+packet|codec_type=video|stream_index=0|pts=118118|pts_time=3.937267|dts=118118|dts_time=3.937267|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=284|pos=1153587|flags=__
+packet|codec_type=video|stream_index=0|pts=120120|pts_time=4.004000|dts=119119|dts_time=3.970633|duration=1001|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2381|pos=1155393|flags=_D
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mov-mp3-demux b/mythtv/external/FFmpeg/tests/ref/fate/mov-mp3-demux
index fc96c587986..19309606404 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/mov-mp3-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mov-mp3-demux
@@ -3,6 +3,7 @@
 #codec_id 0: mp3
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1152,       36, 0x8e260589
 0,       1152,       1152,     1152,       36, 0x8e260589
 0,       2304,       2304,     1152,       36, 0x8e260589
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mov-spherical-mono b/mythtv/external/FFmpeg/tests/ref/fate/mov-spherical-mono
new file mode 100644
index 00000000000..bd57d94514b
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mov-spherical-mono
@@ -0,0 +1,18 @@
+[STREAM]
+[SIDE_DATA]
+side_data_type=Stereo 3D
+type=2D
+inverted=0
+[/SIDE_DATA]
+[SIDE_DATA]
+side_data_type=Spherical Mapping
+projection=tiled equirectangular
+bound_left=148
+bound_top=73
+bound_right=147
+bound_bottom=72
+yaw=45
+pitch=30
+roll=15
+[/SIDE_DATA]
+[/STREAM]
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mov-zombie b/mythtv/external/FFmpeg/tests/ref/fate/mov-zombie
new file mode 100644
index 00000000000..e89abb11676
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mov-zombie
@@ -0,0 +1,133 @@
+packet|codec_type=video|stream_index=0|pts=0|pts_time=0.000000|dts=-3004|dts_time=-0.033378|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=4133|pos=11309|flags=K_
+frame|media_type=video|stream_index=0|key_frame=1|pkt_pts=0|pkt_pts_time=0.000000|pkt_dts=-3004|pkt_dts_time=-0.033378|best_effort_timestamp=0|best_effort_timestamp_time=0.000000|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=11309|pkt_size=4133|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=I|coded_picture_number=0|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=5440|pts_time=0.060444|dts=-567|dts_time=-0.006300|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1077|pos=15442|flags=__
+packet|codec_type=video|stream_index=0|pts=2437|pts_time=0.027078|dts=2436|dts_time=0.027067|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=355|pos=16519|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=2437|pkt_pts_time=0.027078|pkt_dts=2436|pkt_dts_time=0.027067|best_effort_timestamp=2437|best_effort_timestamp_time=0.027078|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=16519|pkt_size=355|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=2|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=11446|pts_time=0.127178|dts=5439|dts_time=0.060433|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1110|pos=16874|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=5440|pkt_pts_time=0.060444|pkt_dts=5439|pkt_dts_time=0.060433|best_effort_timestamp=5440|best_effort_timestamp_time=0.060444|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=15442|pkt_size=1077|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=1|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=8443|pts_time=0.093811|dts=8442|dts_time=0.093800|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=430|pos=17984|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=8443|pkt_pts_time=0.093811|pkt_dts=8442|pkt_dts_time=0.093800|best_effort_timestamp=8443|best_effort_timestamp_time=0.093811|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=17984|pkt_size=430|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=4|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=17452|pts_time=0.193911|dts=11445|dts_time=0.127167|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1485|pos=18414|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=11446|pkt_pts_time=0.127178|pkt_dts=11445|pkt_dts_time=0.127167|best_effort_timestamp=11446|best_effort_timestamp_time=0.127178|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=16874|pkt_size=1110|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=3|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=14449|pts_time=0.160544|dts=14448|dts_time=0.160533|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1005|pos=19899|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=14449|pkt_pts_time=0.160544|pkt_dts=14448|pkt_dts_time=0.160533|best_effort_timestamp=14449|best_effort_timestamp_time=0.160544|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=19899|pkt_size=1005|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=6|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=23458|pts_time=0.260644|dts=17451|dts_time=0.193900|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1976|pos=20904|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=17452|pkt_pts_time=0.193911|pkt_dts=17451|pkt_dts_time=0.193900|best_effort_timestamp=17452|best_effort_timestamp_time=0.193911|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=18414|pkt_size=1485|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=5|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=20455|pts_time=0.227278|dts=20454|dts_time=0.227267|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=904|pos=22880|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=20455|pkt_pts_time=0.227278|pkt_dts=20454|pkt_dts_time=0.227267|best_effort_timestamp=20455|best_effort_timestamp_time=0.227278|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=22880|pkt_size=904|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=8|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=29464|pts_time=0.327378|dts=23457|dts_time=0.260633|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1254|pos=23784|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=23458|pkt_pts_time=0.260644|pkt_dts=23457|pkt_dts_time=0.260633|best_effort_timestamp=23458|best_effort_timestamp_time=0.260644|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=20904|pkt_size=1976|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=7|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=26461|pts_time=0.294011|dts=26460|dts_time=0.294000|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=700|pos=25038|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=26461|pkt_pts_time=0.294011|pkt_dts=26460|pkt_dts_time=0.294000|best_effort_timestamp=26461|best_effort_timestamp_time=0.294011|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=25038|pkt_size=700|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=10|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=35470|pts_time=0.394111|dts=29463|dts_time=0.327367|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1311|pos=25738|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=29464|pkt_pts_time=0.327378|pkt_dts=29463|pkt_dts_time=0.327367|best_effort_timestamp=29464|best_effort_timestamp_time=0.327378|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=23784|pkt_size=1254|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=9|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=32467|pts_time=0.360744|dts=32466|dts_time=0.360733|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=631|pos=27049|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=32467|pkt_pts_time=0.360744|pkt_dts=32466|pkt_dts_time=0.360733|best_effort_timestamp=32467|best_effort_timestamp_time=0.360744|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=27049|pkt_size=631|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=12|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=41476|pts_time=0.460844|dts=35469|dts_time=0.394100|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1296|pos=27680|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=35470|pkt_pts_time=0.394111|pkt_dts=35469|pkt_dts_time=0.394100|best_effort_timestamp=35470|best_effort_timestamp_time=0.394111|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=25738|pkt_size=1311|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=11|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=38473|pts_time=0.427478|dts=38472|dts_time=0.427467|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=466|pos=28976|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=38473|pkt_pts_time=0.427478|pkt_dts=38472|pkt_dts_time=0.427467|best_effort_timestamp=38473|best_effort_timestamp_time=0.427478|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=28976|pkt_size=466|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=14|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=47482|pts_time=0.527578|dts=41475|dts_time=0.460833|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1638|pos=29442|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=41476|pkt_pts_time=0.460844|pkt_dts=41475|pkt_dts_time=0.460833|best_effort_timestamp=41476|best_effort_timestamp_time=0.460844|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=27680|pkt_size=1296|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=13|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=44479|pts_time=0.494211|dts=44478|dts_time=0.494200|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=907|pos=31080|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=44479|pkt_pts_time=0.494211|pkt_dts=44478|pkt_dts_time=0.494200|best_effort_timestamp=44479|best_effort_timestamp_time=0.494211|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=31080|pkt_size=907|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=16|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=53488|pts_time=0.594311|dts=47481|dts_time=0.527567|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1362|pos=31987|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=47482|pkt_pts_time=0.527578|pkt_dts=47481|pkt_dts_time=0.527567|best_effort_timestamp=47482|best_effort_timestamp_time=0.527578|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=29442|pkt_size=1638|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=15|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=50485|pts_time=0.560944|dts=50484|dts_time=0.560933|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=682|pos=33349|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=50485|pkt_pts_time=0.560944|pkt_dts=50484|pkt_dts_time=0.560933|best_effort_timestamp=50485|best_effort_timestamp_time=0.560944|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=33349|pkt_size=682|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=18|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=59494|pts_time=0.661044|dts=53487|dts_time=0.594300|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2917|pos=34031|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=53488|pkt_pts_time=0.594311|pkt_dts=53487|pkt_dts_time=0.594300|best_effort_timestamp=53488|best_effort_timestamp_time=0.594311|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=31987|pkt_size=1362|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=17|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=56491|pts_time=0.627678|dts=56490|dts_time=0.627667|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1174|pos=36948|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=56491|pkt_pts_time=0.627678|pkt_dts=56490|pkt_dts_time=0.627667|best_effort_timestamp=56491|best_effort_timestamp_time=0.627678|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=36948|pkt_size=1174|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=20|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=65500|pts_time=0.727778|dts=59493|dts_time=0.661033|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1748|pos=38122|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=59494|pkt_pts_time=0.661044|pkt_dts=59493|pkt_dts_time=0.661033|best_effort_timestamp=59494|best_effort_timestamp_time=0.661044|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=34031|pkt_size=2917|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=19|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=62497|pts_time=0.694411|dts=62496|dts_time=0.694400|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=926|pos=39870|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=62497|pkt_pts_time=0.694411|pkt_dts=62496|pkt_dts_time=0.694400|best_effort_timestamp=62497|best_effort_timestamp_time=0.694411|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=39870|pkt_size=926|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=22|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=68503|pts_time=0.761144|dts=65499|dts_time=0.727767|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=918|pos=40796|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=65500|pkt_pts_time=0.727778|pkt_dts=65499|pkt_dts_time=0.727767|best_effort_timestamp=65500|best_effort_timestamp_time=0.727778|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=38122|pkt_size=1748|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=21|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=71506|pts_time=0.794511|dts=68502|dts_time=0.761133|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=3846|pos=41714|flags=K_
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=68503|pkt_pts_time=0.761144|pkt_dts=68502|pkt_dts_time=0.761133|best_effort_timestamp=68503|best_effort_timestamp_time=0.761144|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=40796|pkt_size=918|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=23|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=77512|pts_time=0.861244|dts=71505|dts_time=0.794500|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1932|pos=45560|flags=__
+frame|media_type=video|stream_index=0|key_frame=1|pkt_pts=71506|pkt_pts_time=0.794511|pkt_dts=71505|pkt_dts_time=0.794500|best_effort_timestamp=71506|best_effort_timestamp_time=0.794511|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=41714|pkt_size=3846|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=I|coded_picture_number=24|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=74509|pts_time=0.827878|dts=74508|dts_time=0.827867|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1159|pos=47492|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=74509|pkt_pts_time=0.827878|pkt_dts=74508|pkt_dts_time=0.827867|best_effort_timestamp=74509|best_effort_timestamp_time=0.827878|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=47492|pkt_size=1159|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=26|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=83518|pts_time=0.927978|dts=77511|dts_time=0.861233|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1522|pos=48651|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=77512|pkt_pts_time=0.861244|pkt_dts=77511|pkt_dts_time=0.861233|best_effort_timestamp=77512|best_effort_timestamp_time=0.861244|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=45560|pkt_size=1932|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=25|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=80515|pts_time=0.894611|dts=80514|dts_time=0.894600|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=719|pos=50173|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=80515|pkt_pts_time=0.894611|pkt_dts=80514|pkt_dts_time=0.894600|best_effort_timestamp=80515|best_effort_timestamp_time=0.894611|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=50173|pkt_size=719|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=28|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=89524|pts_time=0.994711|dts=83517|dts_time=0.927967|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1700|pos=50892|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=83518|pkt_pts_time=0.927978|pkt_dts=83517|pkt_dts_time=0.927967|best_effort_timestamp=83518|best_effort_timestamp_time=0.927978|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=48651|pkt_size=1522|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=27|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=86521|pts_time=0.961344|dts=86520|dts_time=0.961333|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1099|pos=52592|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=86521|pkt_pts_time=0.961344|pkt_dts=86520|pkt_dts_time=0.961333|best_effort_timestamp=86521|best_effort_timestamp_time=0.961344|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=52592|pkt_size=1099|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=30|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=95530|pts_time=1.061444|dts=89523|dts_time=0.994700|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2558|pos=53691|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=89524|pkt_pts_time=0.994711|pkt_dts=89523|pkt_dts_time=0.994700|best_effort_timestamp=89524|best_effort_timestamp_time=0.994711|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=50892|pkt_size=1700|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=29|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=92527|pts_time=1.028078|dts=92526|dts_time=1.028067|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1008|pos=56249|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=92527|pkt_pts_time=1.028078|pkt_dts=92526|pkt_dts_time=1.028067|best_effort_timestamp=92527|best_effort_timestamp_time=1.028078|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=56249|pkt_size=1008|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=32|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=101536|pts_time=1.128178|dts=95529|dts_time=1.061433|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1236|pos=57257|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=95530|pkt_pts_time=1.061444|pkt_dts=95529|pkt_dts_time=1.061433|best_effort_timestamp=95530|best_effort_timestamp_time=1.061444|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=53691|pkt_size=2558|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=31|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=98533|pts_time=1.094811|dts=98532|dts_time=1.094800|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=607|pos=58493|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=98533|pkt_pts_time=1.094811|pkt_dts=98532|pkt_dts_time=1.094800|best_effort_timestamp=98533|best_effort_timestamp_time=1.094811|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=58493|pkt_size=607|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=34|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=107542|pts_time=1.194911|dts=101535|dts_time=1.128167|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1883|pos=59100|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=101536|pkt_pts_time=1.128178|pkt_dts=101535|pkt_dts_time=1.128167|best_effort_timestamp=101536|best_effort_timestamp_time=1.128178|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=57257|pkt_size=1236|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=33|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=104539|pts_time=1.161544|dts=104538|dts_time=1.161533|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=893|pos=60983|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=104539|pkt_pts_time=1.161544|pkt_dts=104538|pkt_dts_time=1.161533|best_effort_timestamp=104539|best_effort_timestamp_time=1.161544|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=60983|pkt_size=893|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=36|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=113548|pts_time=1.261644|dts=107541|dts_time=1.194900|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1305|pos=61876|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=107542|pkt_pts_time=1.194911|pkt_dts=107541|pkt_dts_time=1.194900|best_effort_timestamp=107542|best_effort_timestamp_time=1.194911|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=59100|pkt_size=1883|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=35|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=110545|pts_time=1.228278|dts=110544|dts_time=1.228267|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=472|pos=63181|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=110545|pkt_pts_time=1.228278|pkt_dts=110544|pkt_dts_time=1.228267|best_effort_timestamp=110545|best_effort_timestamp_time=1.228278|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=63181|pkt_size=472|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=38|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=119554|pts_time=1.328378|dts=113547|dts_time=1.261633|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1411|pos=63653|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=113548|pkt_pts_time=1.261644|pkt_dts=113547|pkt_dts_time=1.261633|best_effort_timestamp=113548|best_effort_timestamp_time=1.261644|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=61876|pkt_size=1305|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=37|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=116551|pts_time=1.295011|dts=116550|dts_time=1.295000|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=616|pos=65064|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=116551|pkt_pts_time=1.295011|pkt_dts=116550|pkt_dts_time=1.295000|best_effort_timestamp=116551|best_effort_timestamp_time=1.295011|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=65064|pkt_size=616|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=40|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=125560|pts_time=1.395111|dts=119553|dts_time=1.328367|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1291|pos=65680|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=119554|pkt_pts_time=1.328378|pkt_dts=119553|pkt_dts_time=1.328367|best_effort_timestamp=119554|best_effort_timestamp_time=1.328378|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=63653|pkt_size=1411|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=39|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=122557|pts_time=1.361744|dts=122556|dts_time=1.361733|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=470|pos=66971|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=122557|pkt_pts_time=1.361744|pkt_dts=122556|pkt_dts_time=1.361733|best_effort_timestamp=122557|best_effort_timestamp_time=1.361744|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=66971|pkt_size=470|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=42|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=131566|pts_time=1.461844|dts=125559|dts_time=1.395100|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1977|pos=67441|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=125560|pkt_pts_time=1.395111|pkt_dts=125559|pkt_dts_time=1.395100|best_effort_timestamp=125560|best_effort_timestamp_time=1.395111|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=65680|pkt_size=1291|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=41|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=128563|pts_time=1.428478|dts=128562|dts_time=1.428467|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=436|pos=69418|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=128563|pkt_pts_time=1.428478|pkt_dts=128562|pkt_dts_time=1.428467|best_effort_timestamp=128563|best_effort_timestamp_time=1.428478|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=69418|pkt_size=436|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=44|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=137572|pts_time=1.528578|dts=131565|dts_time=1.461833|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2566|pos=69854|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=131566|pkt_pts_time=1.461844|pkt_dts=131565|pkt_dts_time=1.461833|best_effort_timestamp=131566|best_effort_timestamp_time=1.461844|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=67441|pkt_size=1977|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=43|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=134569|pts_time=1.495211|dts=134568|dts_time=1.495200|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=886|pos=72420|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=134569|pkt_pts_time=1.495211|pkt_dts=134568|pkt_dts_time=1.495200|best_effort_timestamp=134569|best_effort_timestamp_time=1.495211|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=72420|pkt_size=886|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=46|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=140575|pts_time=1.561944|dts=137571|dts_time=1.528567|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1330|pos=73306|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=137572|pkt_pts_time=1.528578|pkt_dts=137571|pkt_dts_time=1.528567|best_effort_timestamp=137572|best_effort_timestamp_time=1.528578|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=69854|pkt_size=2566|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=45|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=143578|pts_time=1.595311|dts=140574|dts_time=1.561933|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2227|pos=74636|flags=K_
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=140575|pkt_pts_time=1.561944|pkt_dts=140574|pkt_dts_time=1.561933|best_effort_timestamp=140575|best_effort_timestamp_time=1.561944|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=73306|pkt_size=1330|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=47|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=149584|pts_time=1.662044|dts=143577|dts_time=1.595300|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2210|pos=76863|flags=__
+frame|media_type=video|stream_index=0|key_frame=1|pkt_pts=143578|pkt_pts_time=1.595311|pkt_dts=143577|pkt_dts_time=1.595300|best_effort_timestamp=143578|best_effort_timestamp_time=1.595311|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=74636|pkt_size=2227|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=I|coded_picture_number=48|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=146581|pts_time=1.628678|dts=146580|dts_time=1.628667|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1498|pos=79073|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=146581|pkt_pts_time=1.628678|pkt_dts=146580|pkt_dts_time=1.628667|best_effort_timestamp=146581|best_effort_timestamp_time=1.628678|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=79073|pkt_size=1498|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=50|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=155590|pts_time=1.728778|dts=149583|dts_time=1.662033|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1721|pos=80571|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=149584|pkt_pts_time=1.662044|pkt_dts=149583|pkt_dts_time=1.662033|best_effort_timestamp=149584|best_effort_timestamp_time=1.662044|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=76863|pkt_size=2210|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=49|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=152587|pts_time=1.695411|dts=152586|dts_time=1.695400|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1238|pos=82292|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=152587|pkt_pts_time=1.695411|pkt_dts=152586|pkt_dts_time=1.695400|best_effort_timestamp=152587|best_effort_timestamp_time=1.695411|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=82292|pkt_size=1238|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=52|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=161596|pts_time=1.795511|dts=155589|dts_time=1.728767|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1753|pos=83530|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=155590|pkt_pts_time=1.728778|pkt_dts=155589|pkt_dts_time=1.728767|best_effort_timestamp=155590|best_effort_timestamp_time=1.728778|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=80571|pkt_size=1721|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=51|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=158593|pts_time=1.762144|dts=158592|dts_time=1.762133|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1014|pos=85283|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=158593|pkt_pts_time=1.762144|pkt_dts=158592|pkt_dts_time=1.762133|best_effort_timestamp=158593|best_effort_timestamp_time=1.762144|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=85283|pkt_size=1014|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=54|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=167602|pts_time=1.862244|dts=161595|dts_time=1.795500|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=2408|pos=86297|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=161596|pkt_pts_time=1.795511|pkt_dts=161595|pkt_dts_time=1.795500|best_effort_timestamp=161596|best_effort_timestamp_time=1.795511|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=83530|pkt_size=1753|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=53|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=164599|pts_time=1.828878|dts=164598|dts_time=1.828867|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1727|pos=88705|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=164599|pkt_pts_time=1.828878|pkt_dts=164598|pkt_dts_time=1.828867|best_effort_timestamp=164599|best_effort_timestamp_time=1.828878|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=88705|pkt_size=1727|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=56|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=173608|pts_time=1.928978|dts=167601|dts_time=1.862233|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1504|pos=90432|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=167602|pkt_pts_time=1.862244|pkt_dts=167601|pkt_dts_time=1.862233|best_effort_timestamp=167602|best_effort_timestamp_time=1.862244|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=86297|pkt_size=2408|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=55|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=170605|pts_time=1.895611|dts=170604|dts_time=1.895600|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=957|pos=91936|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=170605|pkt_pts_time=1.895611|pkt_dts=170604|pkt_dts_time=1.895600|best_effort_timestamp=170605|best_effort_timestamp_time=1.895611|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=91936|pkt_size=957|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=58|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=179614|pts_time=1.995711|dts=173607|dts_time=1.928967|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1890|pos=92893|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=173608|pkt_pts_time=1.928978|pkt_dts=173607|pkt_dts_time=1.928967|best_effort_timestamp=173608|best_effort_timestamp_time=1.928978|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=90432|pkt_size=1504|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=57|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=176611|pts_time=1.962344|dts=176610|dts_time=1.962333|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1239|pos=94783|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=176611|pkt_pts_time=1.962344|pkt_dts=176610|pkt_dts_time=1.962333|best_effort_timestamp=176611|best_effort_timestamp_time=1.962344|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=94783|pkt_size=1239|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=60|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=185620|pts_time=2.062444|dts=179613|dts_time=1.995700|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1856|pos=96022|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=179614|pkt_pts_time=1.995711|pkt_dts=179613|pkt_dts_time=1.995700|best_effort_timestamp=179614|best_effort_timestamp_time=1.995711|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=92893|pkt_size=1890|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=59|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=182617|pts_time=2.029078|dts=182616|dts_time=2.029067|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1302|pos=97878|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=182617|pkt_pts_time=2.029078|pkt_dts=182616|pkt_dts_time=2.029067|best_effort_timestamp=182617|best_effort_timestamp_time=2.029078|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=97878|pkt_size=1302|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=62|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=191626|pts_time=2.129178|dts=185619|dts_time=2.062433|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=1666|pos=99180|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=185620|pkt_pts_time=2.062444|pkt_dts=185619|pkt_dts_time=2.062433|best_effort_timestamp=185620|best_effort_timestamp_time=2.062444|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=96022|pkt_size=1856|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=61|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=188623|pts_time=2.095811|dts=188622|dts_time=2.095800|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=974|pos=100846|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=188623|pkt_pts_time=2.095811|pkt_dts=188622|pkt_dts_time=2.095800|best_effort_timestamp=188623|best_effort_timestamp_time=2.095811|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=100846|pkt_size=974|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=B|coded_picture_number=64|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+packet|codec_type=video|stream_index=0|pts=197632|pts_time=2.195911|dts=191625|dts_time=2.129167|duration=3003|duration_time=0.033367|convergence_duration=N/A|convergence_duration_time=N/A|size=580|pos=101820|flags=__
+frame|media_type=video|stream_index=0|key_frame=0|pkt_pts=191626|pkt_pts_time=2.129178|pkt_dts=N/A|pkt_dts_time=N/A|best_effort_timestamp=191626|best_effort_timestamp_time=2.129178|pkt_duration=3003|pkt_duration_time=0.033367|pkt_pos=99180|pkt_size=1666|width=160|height=240|pix_fmt=yuv420p|sample_aspect_ratio=2:1|pict_type=P|coded_picture_number=63|display_picture_number=0|interlaced_frame=0|top_field_first=0|repeat_pict=0|color_range=tv|color_space=smpte170m|color_primaries=smpte170m|color_transfer=bt709|chroma_location=topleft
+stream|index=0|codec_name=h264|profile=77|codec_type=video|codec_time_base=212521/12744000|codec_tag_string=avc1|codec_tag=0x31637661|width=160|height=240|coded_width=160|coded_height=240|has_b_frames=0|sample_aspect_ratio=2:1|display_aspect_ratio=4:3|pix_fmt=yuv420p|level=12|color_range=tv|color_space=smpte170m|color_transfer=bt709|color_primaries=smpte170m|chroma_location=topleft|field_order=unknown|timecode=N/A|refs=2|is_avc=true|nal_length_size=4|id=N/A|r_frame_rate=30000/1001|avg_frame_rate=6372000/212521|time_base=1/90000|start_pts=0|start_time=0.000000|duration_ts=2125200|duration=23.613333|bit_rate=333874|max_bit_rate=N/A|bits_per_raw_sample=8|nb_frames=708|nb_read_frames=65|nb_read_packets=66|disposition:default=1|disposition:dub=0|disposition:original=0|disposition:comment=0|disposition:lyrics=0|disposition:karaoke=0|disposition:forced=0|disposition:hearing_impaired=0|disposition:visual_impaired=0|disposition:clean_effects=0|disposition:attached_pic=0|disposition:timed_thumbnails=0|tag:rotate=0|tag:creation_time=2008-05-12T20:59:27.000000Z|tag:language=eng|tag:handler_name=Apple Alias Data Handler|tag:encoder=H.264
+side_data|side_data_type=Display Matrix|displaymatrix=\n00000000:       131072           0           0\n00000001:            0       65536           0\n00000002:            0           0  1073741824\n|rotation=0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/movenc b/mythtv/external/FFmpeg/tests/ref/fate/movenc
index 09e603aeb74..872796ebce6 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/movenc
+++ b/mythtv/external/FFmpeg/tests/ref/fate/movenc
@@ -1,18 +1,18 @@
 write_data len 36, time nopts, type header atom ftyp
-write_data len 2335, time nopts, type header atom -
+write_data len 2389, time nopts, type header atom -
 write_data len 788, time 1000000, type sync atom moof
 write_data len 110, time nopts, type trailer atom -
-214242e9c7c93171d2f47f5b47776559 3269 non-empty-moov
+17a37691eba8b858cf15e60aa9a7dbf7 3323 non-empty-moov
 write_data len 36, time nopts, type header atom ftyp
-write_data len 2667, time nopts, type header atom -
+write_data len 2721, time nopts, type header atom -
 write_data len 908, time 966667, type sync atom moof
 write_data len 110, time nopts, type trailer atom -
-44467d568a3cc38d414fd8ed4b2a968f 3721 non-empty-moov-elst
+0026ffe059c06c592021f972bf2c5e79 3775 non-empty-moov-elst
 write_data len 36, time nopts, type header atom ftyp
-write_data len 2575, time nopts, type header atom -
+write_data len 2629, time nopts, type header atom -
 write_data len 908, time 1000000, type sync atom moof
 write_data len 110, time nopts, type trailer atom -
-de22b98a3885f9b4b83cdd48ff46aeb9 3629 non-empty-moov-no-elst
+c184e168ac1e5bb3d9c70e580ab6179c 3683 non-empty-moov-no-elst
 write_data len 20, time nopts, type header atom ftyp
 write_data len 1171, time nopts, type header atom -
 write_data len 728, time 0, type sync atom moof
@@ -140,3 +140,14 @@ write_data len 668, time 1566667, type sync atom moof
 write_data len 440, time 2233333, type boundary atom moof
 write_data len 262, time nopts, type trailer atom -
 edd19deae2b70afcf2cd744b89b7013d 4209 vfr-noduration-interleave
+write_data len 1231, time nopts, type header atom ftyp
+write_data len 916, time 0, type sync atom moof
+write_data len 908, time 1000000, type sync atom moof
+write_data len 148, time nopts, type trailer atom -
+781dbfd228f36903178e29faa727d78b 3203 delay-moov-elst-neg-cts
+write_data len 36, time nopts, type header atom ftyp
+write_data len 1123, time nopts, type header atom -
+write_data len 1188, time 0, type sync atom moof
+write_data len 908, time 1033333, type sync atom moof
+write_data len 148, time nopts, type trailer atom -
+7630fdf358e02c79e88f312f82a260b7 3403 empty-moov-neg-cts
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mpeg2-ticket6024 b/mythtv/external/FFmpeg/tests/ref/fate/mpeg2-ticket6024
new file mode 100644
index 00000000000..bd416240f3b
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mpeg2-ticket6024
@@ -0,0 +1,27 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 716x236
+#sar 0: 1/1
+0,          2,          2,        1,   253464, 0xc51a46f9
+0,          4,          4,        1,   253464, 0xd0661651
+0,          5,          5,        1,   253464, 0x38a213b3
+0,          6,          6,        1,   253464, 0x038a5118
+0,          7,          7,        1,   253464, 0xebd8de64
+0,          8,          8,        1,   253464, 0x0b319ee0
+0,          9,          9,        1,   253464, 0x37b03a45
+0,         10,         10,        1,   253464, 0x5f9c89ae
+0,         11,         11,        1,   253464, 0x88ad9c08
+0,         12,         12,        1,   253464, 0x387198bc
+0,         13,         13,        1,   253464, 0xf3933eb6
+0,         14,         14,        1,   253464, 0x9bd27b98
+0,         15,         15,        1,   253464, 0x9442c538
+0,         16,         16,        1,   253464, 0x330be2a4
+0,         17,         17,        1,   253464, 0xb4b8c1df
+0,         18,         18,        1,   253464, 0xc97ded34
+0,         19,         19,        1,   253464, 0xcad936e0
+0,         20,         20,        1,   253464, 0x11a2850d
+0,         21,         21,        1,   253464, 0x2545ad23
+0,         22,         22,        1,   253464, 0xa5e17c47
+0,         23,         23,        1,   253464, 0x39452689
+0,         24,         24,        1,   253464, 0x1daefd72
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mpeg4-bsf-unpack-bframes b/mythtv/external/FFmpeg/tests/ref/fate/mpeg4-bsf-unpack-bframes
index 162d436625d..703ae3a8e81 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/mpeg4-bsf-unpack-bframes
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mpeg4-bsf-unpack-bframes
@@ -1 +1 @@
-c9535e459c2ee4ead6d84b93bc7e9f46
+a0c4ba21ab9d68966b8fce7cc848e2c6
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mpegts-probe-latm b/mythtv/external/FFmpeg/tests/ref/fate/mpegts-probe-latm
new file mode 100644
index 00000000000..13aea2bcfdc
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mpegts-probe-latm
@@ -0,0 +1,14 @@
+[PROGRAM]
+[STREAM]
+codec_name=hevc
+[/STREAM]
+[STREAM]
+codec_name=aac_latm
+[/STREAM]
+[/PROGRAM]
+[STREAM]
+codec_name=hevc
+[/STREAM]
+[STREAM]
+codec_name=aac_latm
+[/STREAM]
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mtv b/mythtv/external/FFmpeg/tests/ref/fate/mtv
index 81711f72936..7b17bc1b6ce 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/mtv
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mtv
@@ -9,6 +9,7 @@
 #codec_id 1: mp3
 #sample_rate 1: 44100
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,        1,    12288, 0xc2258ebc
 1,          0,          0,     1152,      417, 0xae1cc66a
 1,       1152,       1152,     1152,      418, 0xdc3ec850
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mxf-demux b/mythtv/external/FFmpeg/tests/ref/fate/mxf-demux
index 66dea1027ed..906a6d06385 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/mxf-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mxf-demux
@@ -9,6 +9,7 @@
 #codec_id 1: pcm_alaw
 #sample_rate 1: 8000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0, -9223372036854775808,        1,     8468, 0xc0855553
 1,          0,          0,    16000,    32000, 0x479155e6
 0,          1, -9223372036854775808,        1,     3814, 0xa10783b4, F=0x0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mxf-probe-dnxhd b/mythtv/external/FFmpeg/tests/ref/fate/mxf-probe-dnxhd
index 6c7f4addcf0..c4de291d324 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/mxf-probe-dnxhd
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mxf-probe-dnxhd
@@ -123,7 +123,7 @@ sample_aspect_ratio=1:1
 display_aspect_ratio=4:3
 pix_fmt=yuv422p
 level=-99
-color_range=N/A
+color_range=unknown
 color_space=bt709
 color_transfer=unknown
 color_primaries=unknown
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/mxf-probe-dv25 b/mythtv/external/FFmpeg/tests/ref/fate/mxf-probe-dv25
index 036069191f9..6e02dd9802c 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/mxf-probe-dv25
+++ b/mythtv/external/FFmpeg/tests/ref/fate/mxf-probe-dv25
@@ -15,7 +15,7 @@ sample_aspect_ratio=16:15
 display_aspect_ratio=4:3
 pix_fmt=yuv420p
 level=-99
-color_range=N/A
+color_range=unknown
 color_space=unknown
 color_transfer=unknown
 color_primaries=unknown
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/nsv-demux b/mythtv/external/FFmpeg/tests/ref/fate/nsv-demux
index 7b9c000d9d6..bff871dabee 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/nsv-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/nsv-demux
@@ -8,6 +8,7 @@
 #codec_id 1: mp3
 #sample_rate 1: 11025
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,       12, 0x1396035f
 0,          1,          1,        1,       24, 0x8ab80ac7, F=0x0
 0,          2,          2,        1,      208, 0x1de1603e, F=0x0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/oggopus-demux b/mythtv/external/FFmpeg/tests/ref/fate/oggopus-demux
index 4621af6a389..91927607000 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/oggopus-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/oggopus-demux
@@ -4,6 +4,7 @@
 #codec_id 0: opus
 #sample_rate 0: 48000
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,       -356,       -356,      960,      402, 0x89b1c40f
 0,        604,        604,      960,      216, 0x7bf97146
 0,       1564,       1564,      960,      215, 0x6cb86d8b
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/on2avc b/mythtv/external/FFmpeg/tests/ref/fate/on2avc
index 2125cc6837e..a9d6cbcea9b 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/on2avc
+++ b/mythtv/external/FFmpeg/tests/ref/fate/on2avc
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 16000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,     1024,     2048, 0x00000000
 0,       1024,       1024,     1024,     2048, 0x96ee1301
 0,       2048,       2048,     1024,     2048, 0xe2a81605
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/paf-audio b/mythtv/external/FFmpeg/tests/ref/fate/paf-audio
index bb93ad50e25..a9ed9e99fe2 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/paf-audio
+++ b/mythtv/external/FFmpeg/tests/ref/fate/paf-audio
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,    57330,   229320, 0x062508b4
 0,      57330,      57330,    57330,   229320, 0x0a966cbf
 0,     114660,     114660,    57330,   229320, 0xee9bad45
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/paf-demux b/mythtv/external/FFmpeg/tests/ref/fate/paf-demux
index 0f281fe7767..6a66697af8c 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/paf-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/paf-demux
@@ -8,6 +8,7 @@
 #codec_id 1: paf_audio
 #sample_rate 1: 22050
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,        1,   262144, 0x7f9a3c6a
 1,          0,          0,    57330,   131072, 0x255a6ac2
 0,          1,          1,        1,   260600, 0x0329e6f4, F=0x0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/parseutils b/mythtv/external/FFmpeg/tests/ref/fate/parseutils
index 1aad5ec8239..568b6d28be5 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/parseutils
+++ b/mythtv/external/FFmpeg/tests/ref/fate/parseutils
@@ -68,6 +68,13 @@ fmt:'%Y-%m-%d' spec:'2012-12-21' -> 2012-12-21 00:00:00
 fmt:'%Y - %m - %d' spec:'2012-12-21' -> 2012-12-21 00:00:00
 fmt:'%Y-%m-%d %H:%M:%S' spec:'2012-12-21 20:12:21' -> 2012-12-21 20:12:21
 fmt:'  %Y - %m - %d %H : %M : %S' spec:'   2012 - 12 -  21   20 : 12 : 21' -> 2012-12-21 20:12:21
+fmt:'  %Y - %b - %d %H : %M : %S' spec:'   2012 - nOV -  21   20 : 12 : 21' -> 2012-11-21 20:12:21
+fmt:'  %Y - %B - %d %H : %M : %S' spec:'   2012 - nOVemBeR -  21   20 : 12 : 21' -> 2012-11-21 20:12:21
+fmt:'  %Y - %B%d %H : %M : %S' spec:'   2012 - may21   20 : 12 : 21' -> 2012-05-21 20:12:21
+fmt:'  %Y - %B%d %H : %M : %S' spec:'   2012 - mby21   20 : 12 : 21' -> error
+fmt:'  %Y - %B - %d %H : %M : %S' spec:'   2012 - JunE -  21   20 : 12 : 21' -> 2012-06-21 20:12:21
+fmt:'  %Y - %B - %d %H : %M : %S' spec:'   2012 - Jane -  21   20 : 12 : 21' -> error
+fmt:'  %Y - %B - %d %H : %M : %S' spec:'   2012 - January -  21   20 : 12 : 21' -> 2012-01-21 20:12:21
 
 Testing av_parse_time()
 (now is 2012-03-17 09:14:13.2 +0100, local time is UTC+1)
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/pcm-planar b/mythtv/external/FFmpeg/tests/ref/fate/pcm-planar
index 53394470844..8b6c96181ac 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/pcm-planar
+++ b/mythtv/external/FFmpeg/tests/ref/fate/pcm-planar
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1471,     5884, 0x00000000
 0,       1471,       1471,     1471,     5884, 0x00000000
 0,       2942,       2942,     1472,     5888, 0x00000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/pcm_dvd b/mythtv/external/FFmpeg/tests/ref/fate/pcm_dvd
index 8aa87cdea57..2a241562845 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/pcm_dvd
+++ b/mythtv/external/FFmpeg/tests/ref/fate/pcm_dvd
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 48000
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,      334,     1336, 0x8e3c0abc
 0,        400,        400,      334,     1336, 0x99c41108
 0,        720,        720,      334,     1336, 0xd65be322
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/pixfmt_best b/mythtv/external/FFmpeg/tests/ref/fate/pixfmt_best
new file mode 100644
index 00000000000..699e2e4213c
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/pixfmt_best
@@ -0,0 +1 @@
+72 tests passed, 0 tests failed.
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/pixlet-rgb b/mythtv/external/FFmpeg/tests/ref/fate/pixlet-rgb
new file mode 100644
index 00000000000..a445fddfa77
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/pixlet-rgb
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 13x9
+#sar 0: 1/1
+0,          0,          0,        1,      374, 0x93f1ba6d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/pmp-demux b/mythtv/external/FFmpeg/tests/ref/fate/pmp-demux
index 4b66427c432..5c51b8b453b 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/pmp-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/pmp-demux
@@ -3,6 +3,7 @@
 #codec_id 0: mp3
 #sample_rate 0: 44100
 #channel_layout 0: 3
+#channel_layout_name 0: stereo
 0,          0,          0,     1152,      417, 0xcb873fba
 0,       1152,       1152,     1152,      104, 0x6d521c5a
 0,       2304,       2304,     1152,      104, 0xb3af1d64
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/prores-gray b/mythtv/external/FFmpeg/tests/ref/fate/prores-gray
index 22b79b953e4..a1a63fa945d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/prores-gray
+++ b/mythtv/external/FFmpeg/tests/ref/fate/prores-gray
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,        1,  1658880, 0x43d9c9e2
 1,          0,          0,     1024,     4096, 0x6c8a9a18
 1,       1024,       1024,     1024,     4096, 0x960dadcf
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/prores-transparency b/mythtv/external/FFmpeg/tests/ref/fate/prores-transparency
index 6a9c786f293..7b3efc63359 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/prores-transparency
+++ b/mythtv/external/FFmpeg/tests/ref/fate/prores-transparency
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,        1, 16588800, 0x7163b01a
 1,          0,          0,     1024,     4096, 0x00000000
 1,       1024,       1024,      896,     3584, 0x00000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/prores-transparency_skip b/mythtv/external/FFmpeg/tests/ref/fate/prores-transparency_skip
index 569d2ba2c75..5c98d3e4383 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/prores-transparency_skip
+++ b/mythtv/external/FFmpeg/tests/ref/fate/prores-transparency_skip
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,        1, 12441600, 0x627d1548
 1,          0,          0,     1024,     4096, 0x00000000
 1,       1024,       1024,      896,     3584, 0x00000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-duo-tone-color b/mythtv/external/FFmpeg/tests/ref/fate/psd-duo-tone-color
new file mode 100644
index 00000000000..3490e005ea7
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-duo-tone-color
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    16384, 0xe0cfa680
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-gray16 b/mythtv/external/FFmpeg/tests/ref/fate/psd-gray16
new file mode 100644
index 00000000000..668af669adf
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-gray16
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    49152, 0xce3477d3
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-gray8 b/mythtv/external/FFmpeg/tests/ref/fate/psd-gray8
new file mode 100644
index 00000000000..1d8dc49f8d8
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-gray8
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    49152, 0x55121b03
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-127x127-rgb24 b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-127x127-rgb24
new file mode 100644
index 00000000000..2644f40c12f
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-127x127-rgb24
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 127x127
+#sar 0: 0/1
+0,          0,          0,        1,    48387, 0xd7b6bec4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-256c b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-256c
new file mode 100644
index 00000000000..fdf13900a1d
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-256c
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    17408, 0x4d80bf4f
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-bitmap b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-bitmap
new file mode 100644
index 00000000000..03725d5d3b2
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-bitmap
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,     2048, 0x40a72c4f
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-rgb-rle-127x127-16b b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-rgb-rle-127x127-16b
new file mode 100644
index 00000000000..c0659395814
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-rgb-rle-127x127-16b
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 127x127
+#sar 0: 0/1
+0,          0,          0,        1,    96774, 0xaab6cc1d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-rgb-rle-127x127-8b b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-rgb-rle-127x127-8b
new file mode 100644
index 00000000000..ac3b4a9473d
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-rgb-rle-127x127-8b
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 127x127
+#sar 0: 0/1
+0,          0,          0,        1,    48387, 0x35b27b60
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-rgba-rle-128x128-8b b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-rgba-rle-128x128-8b
new file mode 100644
index 00000000000..f3a11b7c5c0
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-lena-rgba-rle-128x128-8b
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    65536, 0xaaacdff3
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-rgb24 b/mythtv/external/FFmpeg/tests/ref/fate/psd-rgb24
new file mode 100644
index 00000000000..7f8f550afe1
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-rgb24
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    49152, 0xe0013dee
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-rgb48 b/mythtv/external/FFmpeg/tests/ref/fate/psd-rgb48
new file mode 100644
index 00000000000..f60cbab0786
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-rgb48
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    49152, 0x0bc6503a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-rgba b/mythtv/external/FFmpeg/tests/ref/fate/psd-rgba
new file mode 100644
index 00000000000..672898093d9
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-rgba
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    49152, 0xb2563b4a
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-rgba64 b/mythtv/external/FFmpeg/tests/ref/fate/psd-rgba64
new file mode 100644
index 00000000000..e51686767e8
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-rgba64
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    49152, 0xb847fd73
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-ya16 b/mythtv/external/FFmpeg/tests/ref/fate/psd-ya16
new file mode 100644
index 00000000000..96582ebe7fe
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-ya16
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    49152, 0xe8f08af3
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psd-ya8 b/mythtv/external/FFmpeg/tests/ref/fate/psd-ya8
new file mode 100644
index 00000000000..9a59fbf5a82
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psd-ya8
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 128x128
+#sar 0: 0/1
+0,          0,          0,        1,    49152, 0xfa0ee1d0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/psx-str-demux b/mythtv/external/FFmpeg/tests/ref/fate/psx-str-demux
index e346c525093..a47c86952fb 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/psx-str-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/psx-str-demux
@@ -8,6 +8,7 @@
 #codec_id 1: adpcm_xa
 #sample_rate 1: 37800
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,        1,     8832, 0x01ad3eeb
 1,          0,          0,        1,     2304, 0xf0ad1000
 1,          1,          1,        1,     2304, 0x69269ce6
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/pva-demux b/mythtv/external/FFmpeg/tests/ref/fate/pva-demux
index 4059af4f75d..3f1c74f3665 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/pva-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/pva-demux
@@ -8,6 +8,7 @@
 #codec_id 1: mp2
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 1,          0,          0,     2160,      384, 0x071abcc8
 1,       2160,       2160,     2160,      384, 0x31c9aee0
 1,       4320,       4320,     2160,      384, 0xa50eaa94
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/ra3-144 b/mythtv/external/FFmpeg/tests/ref/fate/ra3-144
index b5fb47baae1..75e7bbfc7ad 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/ra3-144
+++ b/mythtv/external/FFmpeg/tests/ref/fate/ra3-144
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 8000
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,      160,      320, 0x00000000
 0,        160,        160,      160,      320, 0x4cfd5d74
 0,        320,        320,      160,      320, 0xbb60fa3d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/random_seed b/mythtv/external/FFmpeg/tests/ref/fate/random_seed
index 2b5b3afe720..ef0eef2603c 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/random_seed
+++ b/mythtv/external/FFmpeg/tests/ref/fate/random_seed
@@ -1 +1,2 @@
 seeds OK
+seeds OK
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/redcode-demux b/mythtv/external/FFmpeg/tests/ref/fate/redcode-demux
index c08bbc87d06..45119ec71ec 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/redcode-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/redcode-demux
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s32be
 #sample_rate 1: 48000
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,    10010,  1626280, 0x5768c7d6
 1,          0,          0,    18140,    14816, 0xd185e8c7
 0,      10010,      10010,    10010,  1626092, 0x070bd882
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/rgb24-mkv b/mythtv/external/FFmpeg/tests/ref/fate/rgb24-mkv
index 88d22c14e64..4c357accaf2 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/rgb24-mkv
+++ b/mythtv/external/FFmpeg/tests/ref/fate/rgb24-mkv
@@ -1,5 +1,5 @@
-94cce0d7d5b14b4c86e74a1ca454c5aa *tests/data/fate/rgb24-mkv.matroska
-58361 tests/data/fate/rgb24-mkv.matroska
+55270be3b5d393d770a1dfcb19b68271 *tests/data/fate/rgb24-mkv.matroska
+58345 tests/data/fate/rgb24-mkv.matroska
 #tb 0: 1/10
 #media_type 0: video
 #codec_id 0: rawvideo
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/rscc-8bit b/mythtv/external/FFmpeg/tests/ref/fate/rscc-8bit
new file mode 100644
index 00000000000..8a9ffe3f07c
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/rscc-8bit
@@ -0,0 +1,6 @@
+#tb 0: 100/2997
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 854x480
+#sar 0: 0/1
+0,          0,          0,        1,  1229760, 0xfdf2e538
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-000 b/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-000
new file mode 100644
index 00000000000..294aa2346f7
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-000
@@ -0,0 +1,22 @@
+#extradata 0:        2, 0x0030001c
+#tb 0: 1/1000
+#media_type 0: audio
+#codec_id 0: aac
+#sample_rate 0: 16000
+#channel_layout 0: 4
+#channel_layout_name 0: mono
+0,          0,          0,       64,        4, 0x02f70117
+0,         64,         64,       64,      163, 0xd5f85007
+0,        128,        128,       64,      127, 0x66484065
+0,        192,        192,       64,       94, 0x55222bd6
+0,        256,        256,       64,      314, 0x3c7e923a
+0,        320,        320,       64,      207, 0x1efc5d1b
+0,        384,        384,       64,      119, 0xb2a13601
+0,        448,        448,       64,      184, 0xcafc6091
+0,        512,        512,       64,      132, 0xddd33c0b
+0,        576,        576,       64,      152, 0x83935031
+0,        640,        640,       64,      227, 0x32a86bc4
+0,        704,        704,       64,      122, 0xd04e3571
+0,        768,        768,       64,      163, 0x57d44d16
+0,        832,        832,       64,      147, 0x226043d7
+0,        896,        896,       64,      119, 0x8ad931ed
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-001 b/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-001
new file mode 100644
index 00000000000..ec4669f12cf
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-001
@@ -0,0 +1,23 @@
+#extradata 0:        2, 0x0030001c
+#tb 0: 1/1000
+#media_type 0: audio
+#codec_id 0: aac
+#sample_rate 0: 16000
+#channel_layout 0: 4
+#channel_layout_name 0: mono
+0,          0,          0,       64,      153, 0xbb6e432f
+0,         64,         64,       64,      185, 0xa01f4ff3
+0,        128,        128,       64,      126, 0x85503ce6
+0,        192,        192,       64,      246, 0x652c7b59
+0,        256,        256,       64,      162, 0xc9f04da0
+0,        320,        320,       64,      135, 0x71fa3be0
+0,        384,        384,       64,      246, 0x7a6f7788
+0,        448,        448,       64,      262, 0xd3097781
+0,        512,        512,       64,       60, 0x09a118f5
+0,        576,        576,       64,      255, 0xbab5793c
+0,        640,        640,       64,      153, 0x6b6a44fb
+0,        704,        704,       64,      160, 0x550e4530
+0,        768,        768,       64,      215, 0x7fe66144
+0,        832,        832,       64,      144, 0xcd723f7d
+0,        896,        896,       64,      187, 0x2a0b5c1b
+0,        960,        960,       64,      177, 0xb8c355d5
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-002 b/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-002
new file mode 100644
index 00000000000..06df8245652
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-002
@@ -0,0 +1,10 @@
+#extradata 0:        2, 0x0030001c
+#tb 0: 1/1000
+#media_type 0: audio
+#codec_id 0: aac
+#sample_rate 0: 16000
+#channel_layout 0: 4
+#channel_layout_name 0: mono
+0,          0,          0,       64,      156, 0x867d4f3a
+0,         64,         64,       64,      201, 0x62745ff9
+0,        128,        128,       64,      137, 0x90c639e0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-all b/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-all
new file mode 100644
index 00000000000..9c78d334771
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/segment-adts-to-mkv-header-all
@@ -0,0 +1,41 @@
+#extradata 0:        2, 0x0030001c
+#tb 0: 1/1000
+#media_type 0: audio
+#codec_id 0: aac
+#sample_rate 0: 16000
+#channel_layout 0: 4
+#channel_layout_name 0: mono
+0,          0,          0,       64,        4, 0x02f70117
+0,         64,         64,       64,      163, 0xd5f85007
+0,        128,        128,       64,      127, 0x66484065
+0,        192,        192,       64,       94, 0x55222bd6
+0,        256,        256,       64,      314, 0x3c7e923a
+0,        320,        320,       64,      207, 0x1efc5d1b
+0,        384,        384,       64,      119, 0xb2a13601
+0,        448,        448,       64,      184, 0xcafc6091
+0,        512,        512,       64,      132, 0xddd33c0b
+0,        576,        576,       64,      152, 0x83935031
+0,        640,        640,       64,      227, 0x32a86bc4
+0,        704,        704,       64,      122, 0xd04e3571
+0,        768,        768,       64,      163, 0x57d44d16
+0,        832,        832,       64,      147, 0x226043d7
+0,        896,        896,       64,      119, 0x8ad931ed
+0,        960,        960,       64,      153, 0xbb6e432f
+0,       1024,       1024,       64,      185, 0xa01f4ff3
+0,       1088,       1088,       64,      126, 0x85503ce6
+0,       1152,       1152,       64,      246, 0x652c7b59
+0,       1216,       1216,       64,      162, 0xc9f04da0
+0,       1280,       1280,       64,      135, 0x71fa3be0
+0,       1344,       1344,       64,      246, 0x7a6f7788
+0,       1408,       1408,       64,      262, 0xd3097781
+0,       1472,       1472,       64,       60, 0x09a118f5
+0,       1536,       1536,       64,      255, 0xbab5793c
+0,       1600,       1600,       64,      153, 0x6b6a44fb
+0,       1664,       1664,       64,      160, 0x550e4530
+0,       1728,       1728,       64,      215, 0x7fe66144
+0,       1792,       1792,       64,      144, 0xcd723f7d
+0,       1856,       1856,       64,      187, 0x2a0b5c1b
+0,       1920,       1920,       64,      177, 0xb8c355d5
+0,       1984,       1984,       64,      156, 0x867d4f3a
+0,       2048,       2048,       64,      201, 0x62745ff9
+0,       2112,       2112,       64,      137, 0x90c639e0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/segment-mp4-to-ts b/mythtv/external/FFmpeg/tests/ref/fate/segment-mp4-to-ts
new file mode 100644
index 00000000000..847c1a297db
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/segment-mp4-to-ts
@@ -0,0 +1,132 @@
+#extradata 0:       50, 0x4f1b0df9
+#tb 0: 1/90000
+#media_type 0: video
+#codec_id 0: h264
+#dimensions 0: 640x360
+#sar 0: 1/1
+0,      -7200,          0,        0,    22630, 0x9b109541, S=1,        1, 0x00e000e0
+0,      -3600,      14400,        0,     4021, 0xbf7cdb02, F=0x0, S=1,        1, 0x00e000e0
+0,          0,       7200,        0,     1096, 0x4f162690, F=0x0, S=1,        1, 0x00e000e0
+0,       3600,       3600,        0,      687, 0x00394b95, F=0x0, S=1,        1, 0x00e000e0
+0,       7200,      10800,        0,      445, 0x08c3d065, F=0x0, S=1,        1, 0x00e000e0
+0,      10800,      28800,        0,     4212, 0x56d12b8f, F=0x0, S=1,        1, 0x00e000e0
+0,      14400,      21600,        0,     1117, 0xd521260b, F=0x0, S=1,        1, 0x00e000e0
+0,      18000,      18000,        0,      892, 0x4262bdbc, F=0x0, S=1,        1, 0x00e000e0
+0,      21600,      25200,        0,      480, 0x3be1ef0b, F=0x0, S=1,        1, 0x00e000e0
+0,      25200,      43200,        0,     4065, 0x40dee237, F=0x0, S=1,        1, 0x00e000e0
+0,      28800,      36000,        0,      962, 0x31a4ceb1, F=0x0, S=1,        1, 0x00e000e0
+0,      32400,      32400,        0,      651, 0xb2aa317a, F=0x0, S=1,        1, 0x00e000e0
+0,      36000,      39600,        0,      543, 0x9c4e0024, F=0x0, S=1,        1, 0x00e000e0
+0,      39600,      57600,        0,     4221, 0x77c23977, F=0x0, S=1,        1, 0x00e000e0
+0,      43200,      50400,        0,     1040, 0x482cfa34, F=0x0, S=1,        1, 0x00e000e0
+0,      46800,      46800,        0,      576, 0x2686136a, F=0x0, S=1,        1, 0x00e000e0
+0,      50400,      54000,        0,      607, 0xc53c2339, F=0x0, S=1,        1, 0x00e000e0
+0,      54000,      72000,        0,     4755, 0x2f642b58, F=0x0, S=1,        1, 0x00e000e0
+0,      57600,      64800,        0,     1182, 0xbe1a4847, F=0x0, S=1,        1, 0x00e000e0
+0,      61200,      61200,        0,      809, 0x8d948a4e, F=0x0, S=1,        1, 0x00e000e0
+0,      64800,      68400,        0,      656, 0x4fa03c2b, F=0x0, S=1,        1, 0x00e000e0
+0,      68400,      86400,        0,    26555, 0x5629b584, S=1,        1, 0x00e000e0
+0,      72000,      79200,        0,     1141, 0x761b31e8, F=0x0, S=1,        1, 0x00e000e0
+0,      75600,      75600,        0,      717, 0x57746351, F=0x0, S=1,        1, 0x00e000e0
+0,      79200,      82800,        0,      693, 0x78b24263, F=0x0, S=1,        1, 0x00e000e0
+0,      82800,     100800,        0,     3417, 0x560dbc89, F=0x0, S=1,        1, 0x00e000e0
+0,      86400,      93600,        0,     1128, 0xc0f1383c, F=0x0, S=1,        1, 0x00e000e0
+0,      90000,      90000,        0,      650, 0xc3ad485e, F=0x0, S=1,        1, 0x00e000e0
+0,      93600,      97200,        0,      766, 0xd3e9757d, F=0x0, S=1,        1, 0x00e000e0
+0,      97200,     115200,     3600,     4268, 0xec1235b5, F=0x0, S=1,        1, 0x00e000e0
+0,     100800,     108000,     3600,     1119, 0x65f51fb7, F=0x0, S=1,        1, 0x00e000e0
+0,     104400,     104400,     3600,      766, 0x213b78d3, F=0x0, S=1,        1, 0x00e000e0
+0,     108000,     111600,     3600,      770, 0xa7537e6d, F=0x0, S=1,        1, 0x00e000e0
+0,     111600,     129600,     3600,     6349, 0xec225cf9, F=0x0, S=1,        1, 0x00e000e0
+0,     115200,     122400,     3600,     1188, 0x9dea396c, F=0x0, S=1,        1, 0x00e000e0
+0,     118800,     118800,     3600,      805, 0xdd9e88d0, F=0x0, S=1,        1, 0x00e000e0
+0,     122400,     126000,     3600,      752, 0x1f93730a, F=0x0, S=1,        1, 0x00e000e0
+0,     126000,     144000,     3600,     5502, 0x501bda5c, F=0x0, S=1,        1, 0x00e000e0
+0,     129600,     136800,     3600,     1240, 0x7e3661ea, F=0x0, S=1,        1, 0x00e000e0
+0,     133200,     133200,     3600,      830, 0xa8249f38, F=0x0, S=1,        1, 0x00e000e0
+0,     136800,     140400,     3600,      754, 0xab1c815e, F=0x0, S=1,        1, 0x00e000e0
+0,     140400,     158400,     3600,     5328, 0xd2c55ac6, F=0x0, S=1,        1, 0x00e000e0
+0,     144000,     151200,     3600,     1271, 0x46006870, F=0x0, S=1,        1, 0x00e000e0
+0,     147600,     147600,     3600,      849, 0x94dc99c7, F=0x0, S=1,        1, 0x00e000e0
+0,     151200,     154800,     3600,      753, 0xf4236cab, F=0x0, S=1,        1, 0x00e000e0
+0,     154800,     172800,     3600,    25825, 0xd5464dee, S=1,        1, 0x00e000e0
+0,     158400,     165600,     3600,     1206, 0x8ce84344, F=0x0, S=1,        1, 0x00e000e0
+0,     162000,     162000,     3600,      867, 0x312fa07d, F=0x0, S=1,        1, 0x00e000e0
+0,     165600,     169200,     3600,      719, 0x810666d1, F=0x0, S=1,        1, 0x00e000e0
+0,     169200,     187200,     3600,     3786, 0xa96a6825, F=0x0, S=1,        1, 0x00e000e0
+0,     172800,     180000,     3600,     1187, 0x77e649a2, F=0x0, S=1,        1, 0x00e000e0
+0,     176400,     176400,     3600,      750, 0x86da6d2e, F=0x0, S=1,        1, 0x00e000e0
+0,     180000,     183600,     3600,      815, 0xf09a9881, F=0x0, S=1,        1, 0x00e000e0
+0,     183600,     201600,     3600,     5275, 0xee3450bb, F=0x0, S=1,        1, 0x00e000e0
+0,     187200,     194400,     3600,     1352, 0x150a96e1, F=0x0, S=1,        1, 0x00e000e0
+0,     190800,     190800,     3600,      877, 0x6062a120, F=0x0, S=1,        1, 0x00e000e0
+0,     194400,     198000,     3600,      829, 0x5180988c, F=0x0, S=1,        1, 0x00e000e0
+0,     198000,     216000,     3600,     4421, 0x623aad33, F=0x0, S=1,        1, 0x00e000e0
+0,     201600,     208800,     3600,     1464, 0xd34dc851, F=0x0, S=1,        1, 0x00e000e0
+0,     205200,     205200,     3600,      903, 0xf63bbed0, F=0x0, S=1,        1, 0x00e000e0
+0,     208800,     212400,     3600,      717, 0xc17054b8, F=0x0, S=1,        1, 0x00e000e0
+0,     212400,     230400,     3600,     4787, 0x75e9400e, F=0x0, S=1,        1, 0x00e000e0
+0,     216000,     223200,     3600,     1435, 0xb01ccabb, F=0x0, S=1,        1, 0x00e000e0
+0,     219600,     219600,     3600,      851, 0x54bda291, F=0x0, S=1,        1, 0x00e000e0
+0,     223200,     226800,     3600,      809, 0x84e37fee, F=0x0, S=1,        1, 0x00e000e0
+0,     226800,     244800,     3600,     4541, 0xd4e5c0de, F=0x0, S=1,        1, 0x00e000e0
+0,     230400,     237600,     3600,     1545, 0x0099fc98, F=0x0, S=1,        1, 0x00e000e0
+0,     234000,     234000,     3600,      929, 0xfd72d049, F=0x0, S=1,        1, 0x00e000e0
+0,     237600,     241200,     3600,      829, 0xcfda9e96, F=0x0, S=1,        1, 0x00e000e0
+0,     241200,     259200,     3600,    24220, 0x5ca21d71, S=1,        1, 0x00e000e0
+0,     244800,     252000,     3600,     1422, 0xcde6cc34, F=0x0, S=1,        1, 0x00e000e0
+0,     248400,     248400,     3600,      883, 0xedacbe25, F=0x0, S=1,        1, 0x00e000e0
+0,     252000,     255600,     3600,      768, 0x89d774bc, F=0x0, S=1,        1, 0x00e000e0
+0,     255600,     273600,     3600,     3802, 0xea1d70d4, F=0x0, S=1,        1, 0x00e000e0
+0,     259200,     266400,     3600,     1284, 0x2c927097, F=0x0, S=1,        1, 0x00e000e0
+0,     262800,     262800,     3600,      745, 0x81076a7f, F=0x0, S=1,        1, 0x00e000e0
+0,     266400,     270000,     3600,      931, 0x3675dbfe, F=0x0, S=1,        1, 0x00e000e0
+0,     270000,     288000,     3600,     4830, 0x7a807a68, F=0x0, S=1,        1, 0x00e000e0
+0,     273600,     280800,     3600,     1446, 0x6224bc81, F=0x0, S=1,        1, 0x00e000e0
+0,     277200,     277200,     3600,      833, 0x56f78ae2, F=0x0, S=1,        1, 0x00e000e0
+0,     280800,     284400,     3600,      873, 0x9caeaf00, F=0x0, S=1,        1, 0x00e000e0
+0,     284400,     302400,     3600,     5167, 0x1703151f, F=0x0, S=1,        1, 0x00e000e0
+0,     288000,     295200,     3600,     1449, 0x0881b0d6, F=0x0, S=1,        1, 0x00e000e0
+0,     291600,     291600,     3600,      866, 0x0bffa719, F=0x0, S=1,        1, 0x00e000e0
+0,     295200,     298800,     3600,      874, 0xc243a65f, F=0x0, S=1,        1, 0x00e000e0
+0,     298800,     316800,     3600,     5426, 0x7c899c30, F=0x0, S=1,        1, 0x00e000e0
+0,     302400,     309600,     3600,     1574, 0x03b00f0d, F=0x0, S=1,        1, 0x00e000e0
+0,     306000,     306000,     3600,      860, 0x65cea74e, F=0x0, S=1,        1, 0x00e000e0
+0,     309600,     313200,     3600,      829, 0xffd795cd, F=0x0, S=1,        1, 0x00e000e0
+0,     313200,     331200,     3600,     5352, 0x59997996, F=0x0, S=1,        1, 0x00e000e0
+0,     316800,     324000,     3600,     1501, 0xb3b8f001, F=0x0, S=1,        1, 0x00e000e0
+0,     320400,     320400,     3600,      941, 0x92b0cb18, F=0x0, S=1,        1, 0x00e000e0
+0,     324000,     327600,     3600,      823, 0x3d548355, F=0x0, S=1,        1, 0x00e000e0
+0,     327600,     345600,     3600,    24042, 0x441e94fb, S=1,        1, 0x00e000e0
+0,     331200,     338400,     3600,     1582, 0x4f5d1049, F=0x0, S=1,        1, 0x00e000e0
+0,     334800,     334800,     3600,      945, 0x4f3cc9e8, F=0x0, S=1,        1, 0x00e000e0
+0,     338400,     342000,     3600,      815, 0x0ca790a4, F=0x0, S=1,        1, 0x00e000e0
+0,     342000,     360000,     3600,     4425, 0x1db2a088, F=0x0, S=1,        1, 0x00e000e0
+0,     345600,     352800,     3600,     1492, 0x881ce798, F=0x0, S=1,        1, 0x00e000e0
+0,     349200,     349200,     3600,      905, 0xbdd9c278, F=0x0, S=1,        1, 0x00e000e0
+0,     352800,     356400,     3600,      870, 0x64fbb0e1, F=0x0, S=1,        1, 0x00e000e0
+0,     356400,     374400,     3600,     5194, 0x138b1e1d, F=0x0, S=1,        1, 0x00e000e0
+0,     360000,     367200,     3600,     1483, 0xc5c9d717, F=0x0, S=1,        1, 0x00e000e0
+0,     363600,     363600,     3600,      977, 0x3648d9fc, F=0x0, S=1,        1, 0x00e000e0
+0,     367200,     370800,     3600,      834, 0x6c5d8969, F=0x0, S=1,        1, 0x00e000e0
+0,     370800,     388800,     3600,     6956, 0x6a548e0b, F=0x0, S=1,        1, 0x00e000e0
+0,     374400,     381600,     3600,     1187, 0x795f4163, F=0x0, S=1,        1, 0x00e000e0
+0,     378000,     378000,     3600,      925, 0x92bfc2fb, F=0x0, S=1,        1, 0x00e000e0
+0,     381600,     385200,     3600,      747, 0xea9978fc, F=0x0, S=1,        1, 0x00e000e0
+0,     385200,     403200,     3600,     5005, 0xc558c189, F=0x0, S=1,        1, 0x00e000e0
+0,     388800,     396000,     3600,      452, 0x7d92d9d8, F=0x0, S=1,        1, 0x00e000e0
+0,     392400,     392400,     3600,      784, 0xfd597a5f, F=0x0, S=1,        1, 0x00e000e0
+0,     396000,     399600,     3600,      199, 0x79b06355, F=0x0, S=1,        1, 0x00e000e0
+0,     399600,     417600,     3600,     1862, 0x22a2a06c, F=0x0, S=1,        1, 0x00e000e0
+0,     403200,     410400,     3600,      359, 0x11bdae52, F=0x0, S=1,        1, 0x00e000e0
+0,     406800,     406800,     3600,      235, 0xbec26964, F=0x0, S=1,        1, 0x00e000e0
+0,     410400,     414000,     3600,      221, 0x8380682c, F=0x0, S=1,        1, 0x00e000e0
+0,     414000,     432000,     3600,    22588, 0xf0ecf072, S=1,        1, 0x00e000e0
+0,     417600,     424800,     3600,      383, 0x4f3bb571, F=0x0, S=1,        1, 0x00e000e0
+0,     421200,     421200,     3600,      257, 0x22e87802, F=0x0, S=1,        1, 0x00e000e0
+0,     424800,     428400,     3600,      261, 0xdb988134, F=0x0, S=1,        1, 0x00e000e0
+0,     428400,     435600,     3600,      156, 0xd2c3406c, F=0x0, S=1,        1, 0x00e000e0
+0,     432000,     439200,     3600,      330, 0x150d9b60, F=0x0, S=1,        1, 0x00e000e0
+0,     435600,     446400,     3600,      324, 0x558194ee, F=0x0, S=1,        1, 0x00e000e0
+0,     439200,     442800,     3600,      191, 0x108e54d1, F=0x0, S=1,        1, 0x00e000e0
+0,     442800,     450000,     3600,      233, 0xac5b6486, F=0x0
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/sierra-vmd-audio b/mythtv/external/FFmpeg/tests/ref/fate/sierra-vmd-audio
index 2b9f8e84f22..9c0e6b2db1c 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/sierra-vmd-audio
+++ b/mythtv/external/FFmpeg/tests/ref/fate/sierra-vmd-audio
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,    61740,   123480, 0x3a794c13
 0,      61740,      61740,     2205,     4410, 0x109d04e0
 0,      63945,      63945,     2205,     4410, 0x224d244f
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/siff-demux b/mythtv/external/FFmpeg/tests/ref/fate/siff-demux
index 687a51828fc..f8e98979318 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/siff-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/siff-demux
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_u8
 #sample_rate 1: 22050
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,    15152, 0x14fc0f1f
 1,          0,          0,    22050,    22050, 0xa7d60d27
 0,          1,          1,        1,    15344, 0x31614bd7
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/smacker-audio b/mythtv/external/FFmpeg/tests/ref/fate/smacker-audio
index fbeb4be584b..6b867874d9e 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/smacker-audio
+++ b/mythtv/external/FFmpeg/tests/ref/fate/smacker-audio
@@ -3,6 +3,7 @@
 #codec_id 0: pcm_s16le
 #sample_rate 0: 22050
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,    23620,    47240, 0x9974897c
 0,      23620,      23620,     1564,     3128, 0x7e4064b4
 0,      25184,      25184,     1564,     3128, 0x80883301
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/smjpeg-demux b/mythtv/external/FFmpeg/tests/ref/fate/smjpeg-demux
index 242a22fd6cf..042f9ff9ec0 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/smjpeg-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/smjpeg-demux
@@ -8,6 +8,7 @@
 #codec_id 1: adpcm_ima_smjpeg
 #sample_rate 1: 22050
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        0,      734, 0x5a042c2c
 1,          0,          0,       23,      260, 0x00000000
 1,         23,         23,       23,      260, 0x00000000
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/source b/mythtv/external/FFmpeg/tests/ref/fate/source
index 4ee8a58dc25..2def03495be 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/source
+++ b/mythtv/external/FFmpeg/tests/ref/fate/source
@@ -1,5 +1,4 @@
 Files without standard license headers:
-cmdutils_common_opts.h
 compat/avisynth/windowsPorts/basicDataTypeConversions.h
 compat/avisynth/windowsPorts/windows2linux.h
 libavcodec/file_open.c
@@ -7,6 +6,7 @@ libavcodec/interplayacm.c
 libavcodec/log2_tab.c
 libavcodec/reverse.c
 libavdevice/file_open.c
+libavdevice/reverse.c
 libavfilter/log2_tab.c
 libavformat/file_open.c
 libavformat/golomb_tab.c
@@ -16,7 +16,6 @@ libswscale/log2_tab.c
 tools/uncoded_frame.c
 tools/yuvcmp.c
 Headers without standard inclusion guards:
-cmdutils_common_opts.h
 compat/avisynth/avisynth_c.h
 compat/avisynth/avs/capi.h
 compat/avisynth/avs/config.h
@@ -24,8 +23,12 @@ compat/avisynth/avs/types.h
 compat/avisynth/avxsynth_c.h
 compat/avisynth/windowsPorts/basicDataTypeConversions.h
 compat/avisynth/windowsPorts/windows2linux.h
-compat/cuda/cuviddec.h
-compat/cuda/nvcuvid.h
+compat/cuda/dynlink_cuda.h
+compat/cuda/dynlink_cuviddec.h
+compat/cuda/dynlink_loader.h
+compat/cuda/dynlink_nvcuvid.h
 compat/float/float.h
 compat/float/limits.h
 compat/nvenc/nvEncodeAPI.h
+Use of av_clip() where av_clip_uintp2() could be used:
+Use of av_clip() where av_clip_intp2() could be used:
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/sp5x b/mythtv/external/FFmpeg/tests/ref/fate/sp5x
index 603535bad24..2ca79815eeb 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/sp5x
+++ b/mythtv/external/FFmpeg/tests/ref/fate/sp5x
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 8000
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   115200, 0x8ebcb7f8
 1,          0,          0,     1024,     2048, 0x366ee71c
 0,          1,          1,        1,   115200, 0x1fa8e673
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/speedhq-422 b/mythtv/external/FFmpeg/tests/ref/fate/speedhq-422
new file mode 100644
index 00000000000..7bb0d2388d1
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/speedhq-422
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 112x64
+#sar 0: 0/1
+0,          0,          0,        1,    14336, 0x9bb6dc6d
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/speedhq-422-singlefield b/mythtv/external/FFmpeg/tests/ref/fate/speedhq-422-singlefield
new file mode 100644
index 00000000000..343c52645c8
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/speedhq-422-singlefield
@@ -0,0 +1,6 @@
+#tb 0: 1/25
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 112x32
+#sar 0: 0/1
+0,          0,          0,        1,     7168, 0x75de4109
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/sub-sami2 b/mythtv/external/FFmpeg/tests/ref/fate/sub-sami2
index 9e9c80870d7..64656f06cbd 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/sub-sami2
+++ b/mythtv/external/FFmpeg/tests/ref/fate/sub-sami2
@@ -19,7 +19,7 @@ Dialogue: 0,0:00:17.67,0:00:21.72,Default,,0,0,0,,\N{\c&HCBC0FF&}{\fs6}It's{\fs}
 Dialogue: 0,0:00:21.84,0:00:21.84,Default,,0,0,0,,\N{\u1}매력적인 세계에서\N이 모든 것이 펼쳐집니다{\u1}
 Dialogue: 0,0:00:21.84,0:00:23.58,Default,,0,0,0,,\N{\i1}{\c&H9966CC&}of{\c}{\c&HC2A3E0&} what's{\c} {\c&HE0D1F0&}right{\c} {\c&HFCFAFE&}and{\c} wrong.{\i0}
 Dialogue: 0,0:00:23.69,0:00:23.69,Default,,0,0,0,,\N{\i1}이 주제를 심오한 철학으로\N담아내고 있어요{\i0}
-Dialogue: 0,0:00:23.69,0:00:25.67,Default,,0,0,0,,\N{\fs20}{\c&HFF0000&}{\s1}It{\s0}{\c}{\fs} has {\fs15}{\c&HFFFF00&}a{\c}{\fs} great {\fs16}{\c&HFFCC00&}philosophy{\c}{\fs} about it.
+Dialogue: 0,0:00:23.69,0:00:25.67,Default,,0,0,0,,\N{\c&HFF0000&}{\fs20}{\s1}It{\s0}{\fs}{\c} has {\c&HFFFF00&}{\fs15}a{\fs}{\c} great {\c&HFFCC00&}{\fs16}philosophy{\fs}{\c} about it.
 Dialogue: 0,0:00:40.22,0:00:40.22,Default,,0,0,0,,\N{\s1}"왕좌의 게임"은 웨스테로스라는 가상왕국의\N권력 분쟁 이야기입니다{\s0}
 Dialogue: 0,0:00:40.22,0:00:47.94,Default,,0,0,0,,\N{\c&HA5FF&}{\fs26}"Game of Thrones"{\fs}{\c} {\c&H2A2AA5&}{\b1}is{\b0}{\c}{\c&HFFFF&}{\fs24}{\i1} about{\i0}{\fs}{\c} {\c&H336699&}{\fs14}power{\fs}{\c}{\c&HFF&} struggles{\c}\N{\c&HA5FF&}{\fs8}in a fantasy{\fs}{\c&HCBC0FF&} kingdom{\c&HA5FF&}, called {\fs6}Westeros.{\fs}{\c}
 Dialogue: 0,0:00:48.06,0:00:48.06,Default,,0,0,0,,\N철의 왕좌를 둘러싼\N권력 분쟁이죠
@@ -51,7 +51,7 @@ Dialogue: 0,0:01:28.98,0:01:33.89,Default,,0,0,0,,\N{\u1}this common threat, tha
 Dialogue: 0,0:01:34.01,0:01:35.24,Default,,0,0,0,,\Npursuing their own interests.
 Dialogue: 0,0:01:35.36,0:01:35.36,Default,,0,0,0,,\N한편, 일곱 왕국의 밖에서는\N두 개의 거대한 위협이 부상합니다
 Dialogue: 0,0:01:35.36,0:01:40.23,Default,,0,0,0,,\N{\fs30}And meanwhile, outside the Seven\NKingdoms, two great threats arising.{\fs}
-Dialogue: 0,0:01:40.35,0:01:40.35,Default,,0,0,0,,\N<sup>하나는 바다 건너\N타가리엔 일족 유배자들이며</sub>
+Dialogue: 0,0:01:40.35,0:01:40.35,Default,,0,0,0,,\N하나는 바다 건너\N타가리엔 일족 유배자들이며
 Dialogue: 0,0:01:40.35,0:01:44.06,Default,,0,0,0,,\NOne across the sea, in the exile\NTargaryen siblings,
 Dialogue: 0,0:01:44.17,0:01:44.17,Default,,0,0,0,,\N또 하나는 일곱 왕국의\N국경이 자리잡은
 Dialogue: 0,0:01:44.17,0:01:47.39,Default,,0,0,0,,\Nand another far to the north,\Nbeyond the Wall,
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/sub-scc b/mythtv/external/FFmpeg/tests/ref/fate/sub-scc
new file mode 100644
index 00000000000..5c3e1880afc
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/sub-scc
@@ -0,0 +1,104 @@
+[Script Info]
+; Script generated by FFmpeg/Lavc
+ScriptType: v4.00+
+PlayResX: 384
+PlayResY: 288
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,Monospace,16,&Hffffff,&Hffffff,&H0,&H0,0,0,0,0,100,100,0,0,3,1,0,2,10,10,10,0
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+Dialogue: 0,0:00:-2.-47,0:00:00.70,Default,,0,0,0,,{\an7}{\pos(76,228)}WE HAVE FOUND A WITCH !\N{\an7}{\pos(76,243)}MAY WE BURN HER ?
+Dialogue: 0,0:00:00.69,0:00:03.29,Default,,0,0,0,,{\an7}{\pos(115,228)}[ Crowd ]\N{\an7}{\pos(115,243)}BURN HER !  BURN HER !
+Dialogue: 0,0:00:03.30,0:00:07.07,Default,,0,0,0,,{\an7}{\pos(38,197)}HOW DO YOU KNOW\N{\an7}{\pos(38,213)}SHE IS A WITCH ?\N{\an7}{\pos(153,243)}SHE LOOKS LIKE ONE !
+Dialogue: 0,0:00:07.07,0:00:09.27,Default,,0,0,0,,{\an7}{\pos(192,228)}[ Shouting\N{\an7}{\pos(192,243)}\h\hAffirmations ]
+Dialogue: 0,0:00:09.26,0:00:11.06,Default,,0,0,0,,{\an7}{\pos(38,243)}BRING HER FORWARD.
+Dialogue: 0,0:00:11.07,0:00:14.27,Default,,0,0,0,,{\an7}{\pos(115,228)}I’M NOT A WITCH.\N{\an7}{\pos(115,243)}\hI’M{\i1} NOT{\i0} A WITCH.
+Dialogue: 0,0:00:14.26,0:00:16.03,Default,,0,0,0,,{\an7}{\pos(38,228)}BUT YOU ARE DRESSED\N{\an7}{\pos(38,243)}AS ONE.
+Dialogue: 0,0:00:16.03,0:00:19.03,Default,,0,0,0,,{\an7}{\pos(76,197)}THEY DRESSED ME UP\N{\an7}{\pos(76,213)}LIKE THIS.\N{\an7}{\pos(76,243)}\h\h\h\h\h\h\h\hNO !  WE DIDN’T !
+Dialogue: 0,0:00:19.03,0:00:22.95,Default,,0,0,0,,{\an7}{\pos(115,228)}AND THIS ISN’T MY NOSE.\N{\an7}{\pos(115,243)}IT’S A FALSE ONE.
+Dialogue: 0,0:00:25.30,0:00:28.43,Default,,0,0,0,,{\an7}{\pos(76,197)}WELL ?\N{\an7}{\pos(76,228)}\h\h\h\h\h\h\h\hWELL, WE DID\N{\an7}{\pos(76,243)}\h\h\h\h\h\h\h\hDO THE NOSE.
+Dialogue: 0,0:00:28.43,0:00:30.07,Default,,0,0,0,,{\an7}{\pos(76,197)}THE NOSE ?\N{\an7}{\pos(76,243)}\h\h\h\h\h\h\h\hAND THE HAT.
+Dialogue: 0,0:00:30.07,0:00:35.50,Default,,0,0,0,,{\an7}{\pos(115,197)}BUT SHE IS A WITCH.\N{\an7}{\pos(115,228)}YEAH !  BURN HER !\N{\an7}{\pos(115,243)}BURN HER !  BURN HER !
+Dialogue: 0,0:00:35.50,0:00:38.47,Default,,0,0,0,,{\an7}{\pos(76,213)}- DID YOU DRESS HER UP\N{\an7}{\pos(76,228)}\h\hLIKE THIS ?\N{\an7}{\pos(76,243)}- NO !
+Dialogue: 0,0:00:38.46,0:00:39.86,Default,,0,0,0,,{\an7}{\pos(192,197)}\h\h\h\h\h\h\h\hNO !\N{\an7}{\pos(192,213)}NO !\N{\an7}{\pos(192,243)}\h\h\h\hNO !
+Dialogue: 0,0:00:39.86,0:00:41.63,Default,,0,0,0,,{\an7}{\pos(153,228)}YES.  YES.\N{\an7}{\pos(153,243)}YEAH, A BIT.
+Dialogue: 0,0:00:41.63,0:00:44.83,Default,,0,0,0,,{\an7}{\pos(153,197)}\h\h\h\h\h\h\h\hA BIT.\N{\an7}{\pos(153,213)}\h\h\h\h\h\h\h\h\hA BIT.\N{\an7}{\pos(153,243)}SHE HAS GOT A WART.
+Dialogue: 0,0:00:44.83,0:00:47.04,Default,,0,0,0,,{\an7}{\pos(38,228)}WHAT MAKES YOU THINK\N{\an7}{\pos(38,243)}SHE IS A WITCH ?
+Dialogue: 0,0:00:47.03,0:00:49.53,Default,,0,0,0,,{\an7}{\pos(115,228)}WELL, SHE TURNED ME\N{\an7}{\pos(115,243)}INTO A NEWT !
+Dialogue: 0,0:00:49.53,0:00:52.30,Default,,0,0,0,,{\an7}{\pos(76,243)}A NEWT ?
+Dialogue: 0,0:00:55.46,0:00:57.39,Default,,0,0,0,,{\an7}{\pos(115,243)}I GOT BETTER.
+Dialogue: 0,0:00:57.40,0:00:58.90,Default,,0,0,0,,{\an7}{\pos(153,243)}BURN HER ANYWAY !
+Dialogue: 0,0:00:58.89,0:01:01.03,Default,,0,0,0,,{\an7}{\pos(76,197)}BURN HER !\N{\an7}{\pos(76,228)}\h\h\h\h\h\h\h\hBURN HER !\N{\an7}{\pos(76,243)}\h\h\h\h\h\h\h\hCRACKLE, CRACKLE !
+Dialogue: 0,0:01:01.03,0:01:04.00,Default,,0,0,0,,{\an7}{\pos(38,197)}\h\h\h\h[ Shouting\N{\an7}{\pos(38,213)}\h\h\h\h\h\hContinues ]\N{\an7}{\pos(38,243)}QUIET.  QUIET.
+Dialogue: 0,0:01:04.00,0:01:05.43,Default,,0,0,0,,{\an7}{\pos(38,228)}QUIET !\N{\an7}{\pos(48,243)}QUIET !
+Dialogue: 0,0:01:05.43,0:01:09.13,Default,,0,0,0,,{\an7}{\pos(38,228)}THERE ARE WAYS OF TELLING\N{\an7}{\pos(38,243)}WHETHER SHE IS A WITCH.
+Dialogue: 0,0:01:09.13,0:01:10.96,Default,,0,0,0,,{\an7}{\pos(38,228)}ARE THERE ?\N{\an7}{\pos(38,243)}WHAT ARE THEY ?
+Dialogue: 0,0:01:10.96,0:01:13.30,Default,,0,0,0,,{\an7}{\pos(38,197)}TELL US !\N{\an7}{\pos(153,213)}TELL US !\N{\an7}{\pos(153,243)}\h\h\h\hDO THEY HURT ?
+Dialogue: 0,0:01:13.30,0:01:16.23,Default,,0,0,0,,{\an7}{\pos(38,228)}TELL ME,\N{\an7}{\pos(38,243)}WHAT DO YOU DO WITH WITCHES ?
+Dialogue: 0,0:01:16.23,0:01:19.20,Default,,0,0,0,,{\an7}{\pos(76,213)}\h\h\h\h\h\h\h\h\h\h\h\hBURN THEM !\N{\an7}{\pos(76,228)}\h\h\h\h\h\h\h\h\h\h\h\h\hBURN THEM UP !\N{\an7}{\pos(76,243)}BURN !
+Dialogue: 0,0:01:19.20,0:01:22.33,Default,,0,0,0,,{\an7}{\pos(38,228)}AND WHAT DO YOU BURN,\N{\an7}{\pos(38,243)}APART FROM WITCHES ?
+Dialogue: 0,0:01:22.33,0:01:24.59,Default,,0,0,0,,{\an7}{\pos(38,197)}MORE WITCHES !\N{\an7}{\pos(153,243)}SHH !
+Dialogue: 0,0:01:24.59,0:01:25.62,Default,,0,0,0,,{\an7}{\pos(192,243)}WOOD !
+Dialogue: 0,0:01:25.63,0:01:29.33,Default,,0,0,0,,{\an7}{\pos(38,228)}SO,\N{\an7}{\pos(38,243)}WHY DO WITCHES BURN ?
+Dialogue: 0,0:01:32.69,0:01:35.03,Default,,0,0,0,,{\an7}{\pos(192,243)}B--
+Dialogue: 0,0:01:39.13,0:01:42.46,Default,,0,0,0,,{\an7}{\pos(76,213)}- ’CAUSE THEY’RE\N{\an7}{\pos(76,228)}\h\hMADE OF W-- WOOD ?\N{\an7}{\pos(76,243)}- GOOD !
+Dialogue: 0,0:01:42.46,0:01:44.00,Default,,0,0,0,,{\an7}{\pos(192,213)}OH, YEAH.\N{\an7}{\pos(192,243)}[ Murmuring ]
+Dialogue: 0,0:01:44.00,0:01:48.50,Default,,0,0,0,,{\an7}{\pos(38,213)}SO, HOW DO WE TELL\N{\an7}{\pos(38,228)}WHETHER SHE\N{\an7}{\pos(38,243)}IS MADE OF WOOD ?
+Dialogue: 0,0:01:48.50,0:01:50.10,Default,,0,0,0,,{\an7}{\pos(153,228)}BUILD A BRIDGE\N{\an7}{\pos(153,243)}OUT OF HER !
+Dialogue: 0,0:01:50.10,0:01:54.13,Default,,0,0,0,,{\an7}{\pos(38,228)}AH, BUT CAN YOU NOT ALSO\N{\an7}{\pos(38,243)}MAKE BRIDGES OUT OF STONE ?
+Dialogue: 0,0:01:54.13,0:01:57.26,Default,,0,0,0,,{\an7}{\pos(76,197)}OH, YEAH.\N{\an7}{\pos(76,228)}\h\h\h\h\h\h\h\hOH, YEAH.\N{\an7}{\pos(76,243)}\h\h\h\h\h\h\h\hTRUE.  UH--
+Dialogue: 0,0:01:57.26,0:01:59.72,Default,,0,0,0,,{\an7}{\pos(38,228)}{\i1}DOES WOOD\N{\an7}{\pos(38,243)}SINK IN WATER ?
+Dialogue: 0,0:01:59.73,0:02:02.17,Default,,0,0,0,,{\an7}{\pos(76,197)}NO, NO.\N{\an7}{\pos(76,228)}\h\h\h\h\h\h\h\hNO, IT FLOATS !\N{\an7}{\pos(76,243)}\h\h\h\h\h\h\h\hIT FLOATS !
+Dialogue: 0,0:02:02.17,0:02:07.04,Default,,0,0,0,,{\an7}{\pos(76,197)}THROW HER INTO THE POND !\N{\an7}{\pos(76,243)}\h\h\h\h\h\h\h\h[ All Shouting ]
+Dialogue: 0,0:02:07.36,0:02:10.49,Default,,0,0,0,,{\an7}{\pos(38,228)}WHAT ALSO FLOATS\N{\an7}{\pos(38,243)}IN WATER ?
+Dialogue: 0,0:02:10.50,0:02:12.14,Default,,0,0,0,,{\an7}{\pos(76,197)}BREAD !\N{\an7}{\pos(76,243)}\h\h\h\h\h\h\h\h\h\h\h\hAPPLES !
+Dialogue: 0,0:02:12.13,0:02:13.23,Default,,0,0,0,,{\an7}{\pos(76,243)}UH, VERY SMALL ROCKS.
+Dialogue: 0,0:02:13.23,0:02:16.49,Default,,0,0,0,,{\an7}{\pos(86,228)}{\i1}- CIDER !  CHERRIES !\N{\an7}{\pos(86,243)}{\i0}- UH, GRA-- GRAVY !  MUD !
+Dialogue: 0,0:02:16.50,0:02:18.76,Default,,0,0,0,,{\an7}{\pos(86,228)}- CHURCHES !  CHURCHES !\N{\an7}{\pos(86,243)}{\i1}- LEAD !  LEAD !
+Dialogue: 0,0:02:18.76,0:02:22.30,Default,,0,0,0,,{\an7}{\pos(76,228)}- A DUCK !\N{\an7}{\pos(76,243)}- [ Crowd Gasps, Murmurs ]
+Dialogue: 0,0:02:22.30,0:02:24.63,Default,,0,0,0,,{\an7}{\pos(115,243)}EXACTLY !
+Dialogue: 0,0:02:25.36,0:02:27.59,Default,,0,0,0,,{\an7}{\pos(76,243)}SO, LOGICALLY--
+Dialogue: 0,0:02:27.59,0:02:29.76,Default,,0,0,0,,{\an7}{\pos(192,243)}IF... SHE...
+Dialogue: 0,0:02:29.76,0:02:33.56,Default,,0,0,0,,{\an7}{\pos(192,213)}WEIGHS...\N{\an7}{\pos(192,228)}THE SAME\N{\an7}{\pos(192,243)}AS A DUCK...
+Dialogue: 0,0:02:34.40,0:02:36.50,Default,,0,0,0,,{\an7}{\pos(153,243)}SHE’S MADE OF WOOD !
+Dialogue: 0,0:02:36.50,0:02:38.47,Default,,0,0,0,,{\an7}{\pos(38,243)}AND THEREFORE ?
+Dialogue: 0,0:02:39.50,0:02:42.17,Default,,0,0,0,,{\an7}{\pos(38,228)}- A WITCH !\N{\an7}{\pos(38,243)}{\i1}- [ All ]  A WITCH !  A WITCH !
+Dialogue: 0,0:02:42.17,0:02:44.07,Default,,0,0,0,,{\an7}{\pos(76,243)}[ Shouting Continues ]
+Dialogue: 0,0:02:44.07,0:02:45.76,Default,,0,0,0,,{\an7}{\pos(192,213)}HERE’S A DUCK !\N{\an7}{\pos(192,243)}[ Quacking ]
+Dialogue: 0,0:02:45.76,0:02:49.79,Default,,0,0,0,,{\an7}{\pos(76,213)}VERY GOOD.\N{\an7}{\pos(76,228)}WE SHALL USE\N{\an7}{\pos(76,243)}MY LARGEST SCALES.
+Dialogue: 0,0:02:49.79,0:02:52.72,Default,,0,0,0,,{\an7}{\pos(76,243)}[ Shouting Continues ]
+Dialogue: 0,0:02:52.73,0:02:55.17,Default,,0,0,0,,{\an7}{\pos(115,228)}BURN !\N{\an7}{\pos(115,243)}\hBURN THE WITCH !
+Dialogue: 0,0:02:55.17,0:02:57.63,Default,,0,0,0,,{\an7}{\pos(153,228)}BURN HER !\N{\an7}{\pos(153,243)}\hBURN THE WITCH !
+Dialogue: 0,0:02:57.63,0:03:01.63,Default,,0,0,0,,{\an7}{\pos(115,228)}BURN HER !\N{\an7}{\pos(115,243)}\hBURN HER !  BURN HER !
+Dialogue: 0,0:03:01.63,0:03:04.14,Default,,0,0,0,,{\an7}{\pos(115,228)}BURN HER !\N{\an7}{\pos(115,243)}\hBURN HER !
+Dialogue: 0,0:03:04.13,0:03:06.59,Default,,0,0,0,,{\an7}{\pos(230,228)}BURN HER !\N{\an7}{\pos(230,243)}\hBURN HER !
+Dialogue: 0,0:03:06.59,0:03:08.00,Default,,0,0,0,,{\an7}{\pos(201,243)}{\i1}[ Man Grunts ]
+Dialogue: 0,0:03:08.00,0:03:14.30,Default,,0,0,0,,{\an7}{\pos(38,228)}{\i1}RIGHT !\N{\an7}{\pos(38,243)}REMOVE THE SUPPORTS !
+Dialogue: 0,0:03:17.07,0:03:19.17,Default,,0,0,0,,{\an7}{\pos(38,197)}A WITCH !\N{\an7}{\pos(230,243)}A WITCH !
+Dialogue: 0,0:03:19.17,0:03:20.04,Default,,0,0,0,,{\an7}{\pos(76,243)}IT’S A FAIR COP.
+Dialogue: 0,0:03:20.03,0:03:25.29,Default,,0,0,0,,{\an7}{\pos(38,213)}- BURN HER !\N{\an7}{\pos(38,228)}- [ Crowd Continues Shouting ]\N{\an7}{\pos(57,243)}BURN HER !  BURN HER !
+Dialogue: 0,0:03:28.86,0:03:32.73,Default,,0,0,0,,{\an7}{\pos(38,213)}WHO ARE YOU,\N{\an7}{\pos(38,228)}WHO ARE SO WISE\N{\an7}{\pos(38,243)}IN THE WAYS OF SCIENCE ?
+Dialogue: 0,0:03:32.73,0:03:35.76,Default,,0,0,0,,{\an7}{\pos(153,228)}I AM ARTHUR,\N{\an7}{\pos(153,243)}KING OF THE BRITONS.
+Dialogue: 0,0:03:35.76,0:03:36.96,Default,,0,0,0,,{\an7}{\pos(76,243)}MY LIEGE !
+Dialogue: 0,0:03:36.96,0:03:40.37,Default,,0,0,0,,{\an7}{\pos(115,213)}GOOD SIR KNIGHT,\N{\an7}{\pos(115,228)}WILL YOU COME WITH ME\N{\an7}{\pos(115,243)}TO CAMELOT...
+Dialogue: 0,0:03:40.36,0:03:43.39,Default,,0,0,0,,{\an7}{\pos(153,228)}AND JOIN US\N{\an7}{\pos(153,243)}AT THE ROUND TABLE ?
+Dialogue: 0,0:03:43.40,0:03:45.53,Default,,0,0,0,,{\an7}{\pos(38,228)}MY LIEGE,\N{\an7}{\pos(38,243)}I WOULD BE HONORED !
+Dialogue: 0,0:03:45.53,0:03:48.70,Default,,0,0,0,,{\an7}{\pos(38,197)}\h\h\h\h\h\h\h\h\h\h\h\hWHAT IS YOUR NAME ?\N{\an7}{\pos(38,243)}BEDEVERE, MY LIEGE.
+Dialogue: 0,0:03:48.69,0:03:52.49,Default,,0,0,0,,{\an7}{\pos(163,228)}THEN I DUB YOU\N{\an7}{\pos(163,243)}{\i1}SIR{\i0} BEDEVERE,
+Dialogue: 0,0:03:52.50,0:03:54.86,Default,,0,0,0,,{\an7}{\pos(153,228)}KNIGHT\N{\an7}{\pos(153,243)}OF THE ROUND TABLE.
+Dialogue: 0,0:03:54.86,0:03:56.76,Default,,0,0,0,,{\an7}{\pos(38,228)}{\i1}[ Narrator ]\N{\an7}{\pos(38,243)}THE WISE SIR BEDEVERE...
+Dialogue: 0,0:03:56.76,0:03:59.69,Default,,0,0,0,,{\an7}{\pos(38,228)}{\i1}WAS THE FIRST TO JOIN\N{\an7}{\pos(38,243)}KING ARTHUR’S KNIGHTS.
+Dialogue: 0,0:03:59.69,0:04:03.26,Default,,0,0,0,,{\an7}{\pos(38,228)}{\i1}BUT OTHER ILLUSTRIOUS NAMES\N{\an7}{\pos(38,243)}WERE SOON TO FOLLOW:
+Dialogue: 0,0:04:03.26,0:04:06.03,Default,,0,0,0,,{\an7}{\pos(38,243)}{\i1}SIR LAUNCELOT THE BRAVE;
+Dialogue: 0,0:04:06.03,0:04:07.95,Default,,0,0,0,,{\an7}{\pos(38,243)}{\i1}SIR GALAHAD THE PURE;
+Dialogue: 0,0:04:07.96,0:04:11.27,Default,,0,0,0,,{\an7}{\pos(38,213)}{\i1}AND SIR ROBIN\N{\an7}{\pos(38,228)}THE NOT-QUITE-SO-BRAVE-\N{\an7}{\pos(38,243)}AS-SIR-LAUNCELOT,
+Dialogue: 0,0:04:11.26,0:04:13.92,Default,,0,0,0,,{\an7}{\pos(38,228)}{\i1}WHO HAD NEARLY FOUGHT\N{\an7}{\pos(38,243)}THE DRAGON OF ANGNOR,
+Dialogue: 0,0:04:13.92,0:04:16.89,Default,,0,0,0,,{\an7}{\pos(38,213)}{\i1}WHO HAD NEARLY\N{\an7}{\pos(38,228)}STOOD UP TO THE VICIOUS\N{\an7}{\pos(38,243)}CHICKEN OF BRISTOL...
+Dialogue: 0,0:04:16.89,0:04:20.73,Default,,0,0,0,,{\an7}{\pos(38,213)}{\i1}AND WHO HAD\N{\an7}{\pos(38,228)}PERSONALLY WET HIMSELF\N{\an7}{\pos(38,243)}AT THE BATTLE OF BADON HILL;
+Dialogue: 0,0:04:20.73,0:04:25.43,Default,,0,0,0,,{\an7}{\pos(38,228)}{\i1}AND THE APTLY NAMED\N{\an7}{\pos(38,243)}SIR NOT-APPEARING-IN-THIS-FILM.
+Dialogue: 0,0:04:25.59,0:04:29.03,Default,,0,0,0,,{\an7}{\pos(38,228)}{\i1}TOGETHER THEY FORMED A BAND\N{\an7}{\pos(38,243)}WHOSE NAMES AND DEEDS...
+Dialogue: 0,0:04:29.03,0:04:31.72,Default,,0,0,0,,{\an7}{\pos(38,228)}{\i1}WERE TO BE RETOLD\N{\an7}{\pos(38,243)}THROUGHOUT THE CENTURIES.
+Dialogue: 0,0:04:31.73,0:04:33.86,Default,,0,0,0,,{\an7}{\pos(38,228)}{\i1}THE KNIGHTS\N{\an7}{\pos(38,243)}OF THE ROUND TABLE.
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/sub-srt b/mythtv/external/FFmpeg/tests/ref/fate/sub-srt
index 40b20cde904..fd602909299 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/sub-srt
+++ b/mythtv/external/FFmpeg/tests/ref/fate/sub-srt
@@ -14,10 +14,10 @@ Dialogue: 0,0:00:00.00,0:00:00.00,Default,,0,0,0,,Don't show this text it may be
 Dialogue: 0,0:00:01.50,0:00:04.50,Default,,0,0,0,,SubRip subtitles capability tester 1.3o by ale5000\N{\b1}{\i1}Use VLC 1.1 or higher as reference for most things and MPC Home Cinema for others{\i0}{\b0}\N{\c&HFF0000&}This text should be blue{\c}\N{\c&HFF&}This text should be red{\c}\N{\c&H0&}This text should be black{\c}\N{\fnWebdings}If you see this with the normal font, the player don't (fully) support font face{\fn}
 Dialogue: 0,0:00:04.50,0:00:04.50,Default,,0,0,0,,Hidden
 Dialogue: 0,0:00:04.50,0:00:07.50,Default,,0,0,0,,{\fs8}This text should be small{\fs}\NThis text should be normal\N{\fs35}This text should be big{\fs}
-Dialogue: 0,0:00:07.50,0:00:11.50,Default,,0,0,0,,This should be an E with an accent: È\N日本語\N{\fs30}{\b1}{\i1}{\u1}This text should be bold, italics and underline{\u0}{\i0}{\b0}{\fs}\N{\fs9}{\c&HFF00&}This text should be small and green{\c}{\fs}\N{\fs9}{\c&HFF&}This text should be small and red{\c}{\fs}\N{\fs24}{\c&H2A2AA5&}This text should be big and brown{\c}{\fs}
+Dialogue: 0,0:00:07.50,0:00:11.50,Default,,0,0,0,,This should be an E with an accent: È\N日本語\N{\fs30}{\b1}{\i1}{\u1}This text should be bold, italics and underline{\u0}{\i0}{\b0}{\fs}\N{\fs9}{\c&HFF00&}This text should be small and green{\fs}{\c}\N{\c&HFF&}{\fs9}This text should be small and red{\fs}{\c}\N{\c&H2A2AA5&}{\fs24}This text should be big and brown{\fs}{\c}
 Dialogue: 0,0:00:11.50,0:00:14.50,Default,,0,0,0,,{\b1}This line should be bold{\b0}\N{\i1}This line should be italics{\i0}\N{\u1}This line should be underline{\u0}\N{\s1}This line should be strikethrough{\s0}\N{\u1}Both lines\Nshould be underline{\u0}
-Dialogue: 0,0:00:14.50,0:00:17.50,Default,,0,0,0,,>\NIt would be a good thing to\Nhide invalid html tags that are closed and show the text in them\N<invalid_tag_unclosed>but show un-closed invalid html tags\NShow not opened tags</invalid_tag_not_opened>\N<
-Dialogue: 0,0:00:17.50,0:00:20.50,Default,,0,0,0,,and also\Nhide invalid html tags with parameters that are closed and show the text in them\N<invalid_tag_uc par=5>but show un-closed invalid html tags\N{\u1}This text should be showed underlined without problems also: 2<3,5>1,4<6{\u0}\NThis shouldn't be underlined
+Dialogue: 0,0:00:14.50,0:00:17.50,Default,,0,0,0,,>\NIt would be a good thing to\Nhide invalid html tags that are closed and show the text in them\Nbut show un-closed invalid html tags\NShow not opened tags\N<
+Dialogue: 0,0:00:17.50,0:00:20.50,Default,,0,0,0,,and also\Nhide invalid html tags with parameters that are closed and show the text in them\Nbut show un-closed invalid html tags\N{\u1}This text should be showed underlined without problems also: 2<3,5>1,4<6{\u0}\NThis shouldn't be underlined
 Dialogue: 0,0:00:20.50,0:00:21.50,Default,,0,0,0,,This text should be in the normal position...
 Dialogue: 0,0:00:21.50,0:00:22.50,Default,,0,0,0,,{\an5}{\pos(0,45)}This text should NOT be in the normal position
 Dialogue: 0,0:00:22.50,0:00:24.50,Default,,0,0,0,,Implementation is the same of the ASS tag\N{\an8}This text should be at the\Ntop and horizontally centered
@@ -29,7 +29,7 @@ Dialogue: 0,0:00:24.50,0:00:26.50,Default,,0,0,0,,{\an1}This text should be at t
 Dialogue: 0,0:00:26.50,0:00:28.50,Default,,0,0,0,,{\an9}This text should be at the\Ntop and horizontally at the right
 Dialogue: 0,0:00:26.50,0:00:28.50,Default,,0,0,0,,{\an6}This text should be at the\Nmiddle and horizontally at the right
 Dialogue: 0,0:00:26.50,0:00:28.50,Default,,0,0,0,,{\an3}This text should be at the\Nbottom and horizontally at the right
-Dialogue: 0,0:00:28.50,0:00:31.50,Default,,0,0,0,,{\fs6}{\c&HFF00&}This could be the {\fs35}m{\c&H0&}o{\c&HFF00&}st{\fs6} difficult thing to implement{\c}{\fs}
+Dialogue: 0,0:00:28.50,0:00:31.50,Default,,0,0,0,,{\c&HFF00&}{\fs6}This could be the {\fs35}m{\c&H0&}o{\c&HFF00&}st{\fs6} difficult thing to implement{\fs}{\c}
 Dialogue: 0,0:00:31.50,0:00:50.50,Default,,0,0,0,,First text
 Dialogue: 0,0:00:33.50,0:00:35.50,Default,,0,0,0,,Second, it shouldn't overlap first
 Dialogue: 0,0:00:35.50,0:00:37.50,Default,,0,0,0,,Third, it should replace second
@@ -44,6 +44,6 @@ Dialogue: 0,0:00:54.50,0:00:56.50,Default,,0,0,0,,{\an1}\N\h\h\h\h\hA (05 hard s
 Dialogue: 0,0:00:56.50,0:00:58.50,Default,,0,0,0,,\h\h\h\h\hA (05 hard spaces followed by a letter)\NA (Normal  spaces followed by a letter)\NA (No hard spaces followed by a letter)\NShow this: \TEST and this: \-)
 Dialogue: 0,0:00:58.50,0:01:00.50,Default,,0,0,0,,{\an3}\NA letter followed by 05 hard spaces: A\h\h\h\h\h\NA letter followed by normal  spaces: A\NA letter followed by no hard spaces: A\N05 hard  spaces between letters: A\h\h\h\h\hA\N5 normal spaces between letters: A     A\N\N^--Forced line break
 Dialogue: 0,0:01:00.50,0:01:02.50,Default,,0,0,0,,{\s1}Both line should be strikethrough,\Nyes.{\s0}\NCorrectly closed tags\Nshould be hidden.
-Dialogue: 0,0:01:02.50,0:01:04.50,Default,,0,0,0,,It shouldn't be strikethrough,\Nnot opened tag showed as text.</s>\NNot opened tag showed as text.</xxxxx>
-Dialogue: 0,0:01:04.50,0:01:06.50,Default,,0,0,0,,{\s1}Three lines should be strikethrough,\Nyes.\N<yyyy>Not closed tags showed as text
-Dialogue: 0,0:01:06.50,0:01:08.50,Default,,0,0,0,,{\s1}Both line should be strikethrough but\Nthe wrong closing tag should be showed</b>
+Dialogue: 0,0:01:02.50,0:01:04.50,Default,,0,0,0,,It shouldn't be strikethrough,\Nnot opened tag showed as text.{\s0}\NNot opened tag showed as text.
+Dialogue: 0,0:01:04.50,0:01:06.50,Default,,0,0,0,,{\s1}Three lines should be strikethrough,\Nyes.\NNot closed tags showed as text
+Dialogue: 0,0:01:06.50,0:01:08.50,Default,,0,0,0,,{\s1}Both line should be strikethrough but\Nthe wrong closing tag should be showed{\b0}
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/sub-srt-badsyntax b/mythtv/external/FFmpeg/tests/ref/fate/sub-srt-badsyntax
new file mode 100644
index 00000000000..1561d3f2f25
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/sub-srt-badsyntax
@@ -0,0 +1,22 @@
+[Script Info]
+; Script generated by FFmpeg/Lavc
+ScriptType: v4.00+
+PlayResX: 384
+PlayResY: 288
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,Arial,16,&Hffffff,&Hffffff,&H0,&H0,0,0,0,0,100,100,0,0,1,1,0,2,10,10,10,0
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+Dialogue: 0,0:00:01.00,0:00:02.31,Default,,0,0,0,,<<<<<< Antes <<<<<<\NEla é hum...
+Dialogue: 0,0:01:10.00,0:01:14.50,Default,,0,0,0,,>>> RebelSubTeam <<<
+Dialogue: 0,0:02:37.75,0:02:43.70,Default,,0,0,0,,{\b1}~ASUKO MARCH!~\N>>:<<\Ntranslation by: cangii\NRetiming by: furransu{\b0}
+Dialogue: 0,0:03:38.32,0:03:42.78,Default,,0,0,0,,<<THE HIGH ROLLERS>>\N<<Grandes Jogadores>>
+Dialogue: 0,0:04:50.43,0:05:01.03,Default,,0,0,0,,<<flash gordon\Npisode 4\Nsaison 1>\Nwww.SeriesSub.com>
+Dialogue: 0,0:20:31.85,0:20:56.84,Default,,0,0,0,,{\c&HFFFF&}\N<<<<www.egfire.com>>>>{\c}
+Dialogue: 0,0:37:59.69,0:38:01.59,Default,,0,0,0,,mint asztalt foglaltatni\Na <<>Le Cirque-ben.
+Dialogue: 0,0:53:43.78,0:53:45.94,Default,,0,0,0,,<<That's OK, >> - he calmed himself.
+Dialogue: 0,0:53:46.22,0:53:49.09,Default,,0,0,0,,<<lt's not a long way to the hotel,\Nthe hotel is within easy reach.
+Dialogue: 0,2:11:00.74,2:11:05.54,Default,,0,0,0,,{\b1}<<< ÓÍÀÊÑ ÒÈÉÌ < 2015 > UNACS TEAM >>>{\b0}
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/sub-textenc b/mythtv/external/FFmpeg/tests/ref/fate/sub-textenc
index f7d82ce79a6..3ea56b38f01 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/sub-textenc
+++ b/mythtv/external/FFmpeg/tests/ref/fate/sub-textenc
@@ -44,15 +44,15 @@ should be underline
 >
 It would be a good thing to
 hide invalid html tags that are closed and show the text in them
-<invalid_tag_unclosed>but show un-closed invalid html tags
-Show not opened tags</invalid_tag_not_opened>
+but show un-closed invalid html tags
+Show not opened tags
 <
 
 8
 00:00:17,501 --> 00:00:20,500
 and also
 hide invalid html tags with parameters that are closed and show the text in them
-<invalid_tag_uc par=5>but show un-closed invalid html tags
+but show un-closed invalid html tags
 This text should be showed underlined without problems also: 2<3,5>1,4<6
 This shouldn't be underlined
 
@@ -197,17 +197,17 @@ should be hidden.
 35
 00:01:02,501 --> 00:01:04,500
 It shouldn't be strikethrough,
-not opened tag showed as text.</s>
-Not opened tag showed as text.</xxxxx>
+not opened tag showed as text.
+Not opened tag showed as text.
 
 36
 00:01:04,501 --> 00:01:06,500
 Three lines should be strikethrough,
 yes.
-<yyyy>Not closed tags showed as text
+Not closed tags showed as text
 
 37
 00:01:06,501 --> 00:01:08,500
 Both line should be strikethrough but
-the wrong closing tag should be showed</b>
+the wrong closing tag should be showed
 
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/sub-webvttenc b/mythtv/external/FFmpeg/tests/ref/fate/sub-webvttenc
index ba567c33f68..45ae0b6131b 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/sub-webvttenc
+++ b/mythtv/external/FFmpeg/tests/ref/fate/sub-webvttenc
@@ -39,14 +39,14 @@ should be underline</u>
 >
 It would be a good thing to
 hide invalid html tags that are closed and show the text in them
-<invalid_tag_unclosed>but show un-closed invalid html tags
-Show not opened tags</invalid_tag_not_opened>
+but show un-closed invalid html tags
+Show not opened tags
 <
 
 00:17.501 --> 00:20.500
 and also
 hide invalid html tags with parameters that are closed and show the text in them
-<invalid_tag_uc par=5>but show un-closed invalid html tags
+but show un-closed invalid html tags
 <u>This text should be showed underlined without problems also: 2<3,5>1,4<6</u>
 This shouldn't be underlined
 
@@ -164,14 +164,14 @@ should be hidden.
 
 01:02.501 --> 01:04.500
 It shouldn't be strikethrough,
-not opened tag showed as text.</s>
-Not opened tag showed as text.</xxxxx>
+not opened tag showed as text.
+Not opened tag showed as text.
 
 01:04.501 --> 01:06.500
 Three lines should be strikethrough,
 yes.
-<yyyy>Not closed tags showed as text
+Not closed tags showed as text
 
 01:06.501 --> 01:08.500
 Both line should be strikethrough but
-the wrong closing tag should be showed</b>
+the wrong closing tag should be showed
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/sub2video b/mythtv/external/FFmpeg/tests/ref/fate/sub2video
index ace6d38538d..4e034a5e91d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/sub2video
+++ b/mythtv/external/FFmpeg/tests/ref/fate/sub2video
@@ -4,13 +4,13 @@
 #codec_id 0: rawvideo
 #dimensions 0: 720x480
 #sar 0: 0/1
-#tb 1: 1/1000
+#tb 1: 1/1000000
 #media_type 1: subtitle
 #codec_id 1: dvd_subtitle
 0,          0,          0,        1,   518400, 0x83c27b82
 0,          1,          1,        1,   518400, 0x4051c7f9
 0,          2,          2,        1,   518400, 0xfb00e17e
-1,        499,        499,     4960,     1015, 0x19e092d2, F=0x0
+1,     499000,     499000,  4960000,     1015, 0x19e092d2, F=0x0
 0,          3,          3,        1,   518400, 0x192abb74
 0,          4,          4,        1,   518400, 0x4669a88b
 0,          5,          5,        1,   518400, 0xaababe00
@@ -58,129 +58,129 @@
 0,         47,         47,        1,   518400, 0xde69683f
 0,         48,         48,        1,   518400, 0x7df08fba
 0,         49,         49,        1,   518400, 0xbab197ea
-1,      15355,      15355,     4733,     2094, 0x3c171425, F=0x0
+1,   15355000,   15355000,  4733000,     2094, 0x3c171425, F=0x0
 0,         77,         77,        1,   518400, 0x902285d9
 0,        100,        100,        1,   518400, 0xbab197ea
-1,      48797,      48797,     2560,     2480, 0x7c0edf21, F=0x0
+1,   48797000,   48797000,  2560000,     2480, 0x7c0edf21, F=0x0
 0,        244,        244,        1,   518400, 0x7a11c812
 0,        257,        257,        1,   518400, 0xbab197ea
-1,      51433,      51433,     2366,     3059, 0xc95b8a05, F=0x0
+1,   51433000,   51433000,  2366000,     3059, 0xc95b8a05, F=0x0
 0,        258,        258,        1,   518400, 0x34cdddee
 0,        269,        269,        1,   518400, 0xbab197ea
-1,      53910,      53910,     2696,     2095, 0x61bb15ed, F=0x0
+1,   53910000,   53910000,  2696000,     2095, 0x61bb15ed, F=0x0
 0,        270,        270,        1,   518400, 0x4db4ce51
 0,        283,        283,        1,   518400, 0xbab197ea
-1,      56663,      56663,     1262,     1013, 0xc9ae89b7, F=0x0
+1,   56663000,   56663000,  1262000,     1013, 0xc9ae89b7, F=0x0
 0,        284,        284,        1,   518400, 0xe6bc0ea9
 0,        290,        290,        1,   518400, 0xbab197ea
-1,      58014,      58014,     1661,      969, 0xe01878f0, F=0x0
+1,   58014000,   58014000,  1661000,      969, 0xe01878f0, F=0x0
 0,        291,        291,        1,   518400, 0xa8643af7
 0,        298,        298,        1,   518400, 0xbab197ea
-1,      67724,      67724,     1365,      844, 0xe7db4fc1, F=0x0
+1,   67724000,   67724000,  1365000,      844, 0xe7db4fc1, F=0x0
 0,        339,        339,        1,   518400, 0xb1885c67
 0,        345,        345,        1,   518400, 0xbab197ea
-1,      69175,      69175,     1558,      802, 0xf48531ba, F=0x0
+1,   69175000,   69175000,  1558000,      802, 0xf48531ba, F=0x0
 0,        346,        346,        1,   518400, 0x378e3fd0
 0,        354,        354,        1,   518400, 0xbab197ea
-1,      70819,      70819,     1865,     1709, 0xb4d5a1bd, F=0x0
+1,   70819000,   70819000,  1865000,     1709, 0xb4d5a1bd, F=0x0
 0,        355,        355,        1,   518400, 0xa3782469
 0,        363,        363,        1,   518400, 0xbab197ea
-1,      72762,      72762,     1968,     2438, 0x99d7bc82, F=0x0
+1,   72762000,   72762000,  1968000,     2438, 0x99d7bc82, F=0x0
 0,        364,        364,        1,   518400, 0xba23a0d5
 0,        374,        374,        1,   518400, 0xbab197ea
-1,      74806,      74806,     1831,     2116, 0x96514097, F=0x0
+1,   74806000,   74806000,  1831000,     2116, 0x96514097, F=0x0
 0,        375,        375,        1,   518400, 0x129de2f8
 0,        383,        383,        1,   518400, 0xbab197ea
-1,      76716,      76716,     1262,     1822, 0xefccc72e, F=0x0
+1,   76716000,   76716000,  1262000,     1822, 0xefccc72e, F=0x0
 0,        384,        384,        1,   518400, 0x19772f0f
 0,        390,        390,        1,   518400, 0xbab197ea
-1,      78051,      78051,     1524,      987, 0x7b927a27, F=0x0
+1,   78051000,   78051000,  1524000,      987, 0x7b927a27, F=0x0
 0,        391,        391,        1,   518400, 0x56f54e73
 0,        398,        398,        1,   518400, 0xbab197ea
-1,      79644,      79644,     2662,     2956, 0x190778f7, F=0x0
+1,   79644000,   79644000,  2662000,     2956, 0x190778f7, F=0x0
 0,        399,        399,        1,   518400, 0x300b5247
-1,      82380,      82380,     2764,     3094, 0xc021b7d3, F=0x0
+1,   82380000,   82380000,  2764000,     3094, 0xc021b7d3, F=0x0
 0,        412,        412,        1,   518400, 0xbab197ea
 0,        413,        413,        1,   518400, 0x6fd028fa
 0,        426,        426,        1,   518400, 0xbab197ea
-1,      85225,      85225,     2366,     2585, 0x74d0048f, F=0x0
+1,   85225000,   85225000,  2366000,     2585, 0x74d0048f, F=0x0
 0,        427,        427,        1,   518400, 0x01f80e9d
 0,        438,        438,        1,   518400, 0xbab197ea
-1,      87652,      87652,     1831,      634, 0x8832fda1, F=0x0
+1,   87652000,   87652000,  1831000,      634, 0x8832fda1, F=0x0
 0,        439,        439,        1,   518400, 0xb48d90c0
 0,        447,        447,        1,   518400, 0xbab197ea
-1,      91531,      91531,     2332,     2080, 0x97a1146f, F=0x0
+1,   91531000,   91531000,  2332000,     2080, 0x97a1146f, F=0x0
 0,        458,        458,        1,   518400, 0xcb5a0173
 0,        469,        469,        1,   518400, 0xbab197ea
-1,      95510,      95510,     3299,     2964, 0x8b8f6684, F=0x0
+1,   95510000,   95510000,  3299000,     2964, 0x8b8f6684, F=0x0
 0,        478,        478,        1,   518400, 0xb8a323e4
 0,        494,        494,        1,   518400, 0xbab197ea
-1,      98872,      98872,     2161,     1875, 0x9002ef71, F=0x0
+1,   98872000,   98872000,  2161000,     1875, 0x9002ef71, F=0x0
 0,        495,        495,        1,   518400, 0xc43518ba
 0,        505,        505,        1,   518400, 0xbab197ea
-1,     101124,     101124,     4096,     3872, 0x20c6ed9c, F=0x0
+1,  101124000,  101124000,  4096000,     3872, 0x20c6ed9c, F=0x0
 0,        506,        506,        1,   518400, 0x04e38692
 0,        526,        526,        1,   518400, 0xbab197ea
-1,     105303,     105303,     2730,     3094, 0xf203a663, F=0x0
+1,  105303000,  105303000,  2730000,     3094, 0xf203a663, F=0x0
 0,        527,        527,        1,   518400, 0x856b0ee5
 0,        540,        540,        1,   518400, 0xbab197ea
-1,     108106,     108106,     2059,     2404, 0x41a7b429, F=0x0
+1,  108106000,  108106000,  2059000,     2404, 0x41a7b429, F=0x0
 0,        541,        541,        1,   518400, 0x3e5beee2
 0,        551,        551,        1,   518400, 0xbab197ea
-1,     141556,     141556,     1661,     1088, 0xde20aa20, F=0x0
+1,  141556000,  141556000,  1661000,     1088, 0xde20aa20, F=0x0
 0,        708,        708,        1,   518400, 0xb8bc1365
 0,        716,        716,        1,   518400, 0xbab197ea
 0,        817,        817,        1,   518400, 0x83efa32d
-1,     163445,     163445,     1331,      339, 0x8bd186ef, F=0x0
+1,  163445000,  163445000,  1331000,      339, 0x8bd186ef, F=0x0
 0,        824,        824,        1,   518400, 0xbab197ea
 0,        840,        840,        1,   518400, 0x03ea0e90
-1,     168049,     168049,     1900,     1312, 0x0bf20e8d, F=0x0
+1,  168049000,  168049000,  1900000,     1312, 0x0bf20e8d, F=0x0
 0,        850,        850,        1,   518400, 0xbab197ea
-1,     170035,     170035,     1524,     1279, 0xb6c2dafe, F=0x0
+1,  170035000,  170035000,  1524000,     1279, 0xb6c2dafe, F=0x0
 0,        851,        851,        1,   518400, 0x8780239e
 0,        858,        858,        1,   518400, 0xbab197ea
 0,        861,        861,        1,   518400, 0x6eb72347
-1,     172203,     172203,     1695,     1826, 0x9a1ac769, F=0x0
+1,  172203000,  172203000,  1695000,     1826, 0x9a1ac769, F=0x0
 0,        869,        869,        1,   518400, 0xbab197ea
-1,     173947,     173947,     1934,     1474, 0xa9b03cdc, F=0x0
+1,  173947000,  173947000,  1934000,     1474, 0xa9b03cdc, F=0x0
 0,        870,        870,        1,   518400, 0x9c4a3a3d
 0,        879,        879,        1,   518400, 0xbab197ea
-1,     175957,     175957,     1763,     1019, 0x20409355, F=0x0
+1,  175957000,  175957000,  1763000,     1019, 0x20409355, F=0x0
 0,        880,        880,        1,   518400, 0xc9ebfa89
 0,        889,        889,        1,   518400, 0xbab197ea
 0,        946,        946,        1,   518400, 0xbaf801ef
-1,     189295,     189295,     1968,     1596, 0x408c726e, F=0x0
+1,  189295000,  189295000,  1968000,     1596, 0x408c726e, F=0x0
 0,        956,        956,        1,   518400, 0xbab197ea
-1,     191356,     191356,     1228,     1517, 0xae8c5c2b, F=0x0
+1,  191356000,  191356000,  1228000,     1517, 0xae8c5c2b, F=0x0
 0,        957,        957,        1,   518400, 0x59f4e72f
 0,        963,        963,        1,   518400, 0xbab197ea
-1,     192640,     192640,     1763,     2506, 0xa458d6d4, F=0x0
+1,  192640000,  192640000,  1763000,     2506, 0xa458d6d4, F=0x0
 0,        964,        964,        1,   518400, 0x9d5b9d69
 0,        972,        972,        1,   518400, 0xbab197ea
-1,     195193,     195193,     1092,     1074, 0x397ba9a8, F=0x0
+1,  195193000,  195193000,  1092000,     1074, 0x397ba9a8, F=0x0
 0,        976,        976,        1,   518400, 0x923d1ce7
 0,        981,        981,        1,   518400, 0xbab197ea
-1,     196361,     196361,     1524,     1715, 0x695ca41e, F=0x0
+1,  196361000,  196361000,  1524000,     1715, 0x695ca41e, F=0x0
 0,        982,        982,        1,   518400, 0x6e652cd2
 0,        989,        989,        1,   518400, 0xbab197ea
-1,     197946,     197946,     1160,      789, 0xc63a189e, F=0x0
+1,  197946000,  197946000,  1160000,      789, 0xc63a189e, F=0x0
 0,        990,        990,        1,   518400, 0x25113966
 0,        996,        996,        1,   518400, 0xbab197ea
-1,     199230,     199230,     1627,     1846, 0xeea8c599, F=0x0
+1,  199230000,  199230000,  1627000,     1846, 0xeea8c599, F=0x0
 0,        997,        997,        1,   518400, 0x2dc83609
 0,       1004,       1004,        1,   518400, 0xbab197ea
-1,     200924,     200924,     1763,      922, 0xd4a87222, F=0x0
+1,  200924000,  200924000,  1763000,      922, 0xd4a87222, F=0x0
 0,       1005,       1005,        1,   518400, 0x90483bc6
 0,       1013,       1013,        1,   518400, 0xbab197ea
 0,       1053,       1053,        1,   518400, 0x3de86ab7
-1,     210600,     210600,     1831,      665, 0x55580135, F=0x0
+1,  210600000,  210600000,  1831000,      665, 0x55580135, F=0x0
 0,       1062,       1062,        1,   518400, 0xbab197ea
-1,     214771,     214771,     1558,     1216, 0x50d1f6c5, F=0x0
+1,  214771000,  214771000,  1558000,     1216, 0x50d1f6c5, F=0x0
 0,       1074,       1074,        1,   518400, 0x8c320e68
 0,       1082,       1082,        1,   518400, 0xbab197ea
 0,       1128,       1128,        1,   518400, 0x81e977b2
-1,     225640,     225640,     2127,     2133, 0x670c11a5, F=0x0
+1,  225640000,  225640000,  2127000,     2133, 0x670c11a5, F=0x0
 0,       1139,       1139,        1,   518400, 0xbab197ea
-1,     227834,     227834,     1262,     1264, 0xc1d9fc57, F=0x0
+1,  227834000,  227834000,  1262000,     1264, 0xc1d9fc57, F=0x0
 0,       1140,       1140,        1,   518400, 0xb046dd30
 0,       1145,       1145,        1,   518400, 0xbab197ea
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/svq3 b/mythtv/external/FFmpeg/tests/ref/fate/svq3-1
similarity index 100%
rename from mythtv/external/FFmpeg/tests/ref/fate/svq3
rename to mythtv/external/FFmpeg/tests/ref/fate/svq3-1
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/svq3-2 b/mythtv/external/FFmpeg/tests/ref/fate/svq3-2
new file mode 100644
index 00000000000..1d89c059712
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/svq3-2
@@ -0,0 +1,24 @@
+#tb 0: 1/24
+#media_type 0: video
+#codec_id 0: rawvideo
+#dimensions 0: 480x257
+#sar 0: 0/1
+0,          1,          1,        1,   185280, 0x044209c4
+0,          2,          2,        1,   185280, 0x427ef9a7
+0,          3,          3,        1,   185280, 0x8f771cc8
+0,          4,          4,        1,   185280, 0xb40d0e52
+0,          5,          5,        1,   185280, 0x2e6ee461
+0,          6,          6,        1,   185280, 0x681ba513
+0,          7,          7,        1,   185280, 0x998c5676
+0,          8,          8,        1,   185280, 0xf91003ec
+0,          9,          9,        1,   185280, 0x322ed3de
+0,         10,         10,        1,   185280, 0xb1c9370a
+0,         11,         11,        1,   185280, 0x41423b36
+0,         12,         12,        1,   185280, 0x0b9284e4
+0,         13,         13,        1,   185280, 0x185789b2
+0,         14,         14,        1,   185280, 0x8f0bece0
+0,         15,         15,        1,   185280, 0xfcd9450e
+0,         16,         16,        1,   185280, 0x509d868b
+0,         17,         17,        1,   185280, 0x71fd9ae3
+0,         18,         18,        1,   185280, 0x3dad1b3c
+0,         19,         19,        1,   185280, 0x69ba37dd
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/sws-pixdesc-query b/mythtv/external/FFmpeg/tests/ref/fate/sws-pixdesc-query
new file mode 100644
index 00000000000..0adfdcaf985
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/sws-pixdesc-query
@@ -0,0 +1,832 @@
+is16BPS:
+  ayuv64be
+  ayuv64le
+  bgr48be
+  bgr48le
+  bgra64be
+  bgra64le
+  gbrap16be
+  gbrap16le
+  gbrp16be
+  gbrp16le
+  gray16be
+  gray16le
+  p016be
+  p016le
+  rgb48be
+  rgb48le
+  rgba64be
+  rgba64le
+  ya16be
+  ya16le
+  yuv420p16be
+  yuv420p16le
+  yuv422p16be
+  yuv422p16le
+  yuv444p16be
+  yuv444p16le
+  yuva420p16be
+  yuva420p16le
+  yuva422p16be
+  yuva422p16le
+  yuva444p16be
+  yuva444p16le
+
+isNBPS:
+  gbrap10be
+  gbrap10le
+  gbrap12be
+  gbrap12le
+  gbrp10be
+  gbrp10le
+  gbrp12be
+  gbrp12le
+  gbrp14be
+  gbrp14le
+  gbrp9be
+  gbrp9le
+  gray10be
+  gray10le
+  gray12be
+  gray12le
+  gray9be
+  gray9le
+  nv20be
+  nv20le
+  p010be
+  p010le
+  xyz12be
+  xyz12le
+  yuv420p10be
+  yuv420p10le
+  yuv420p12be
+  yuv420p12le
+  yuv420p14be
+  yuv420p14le
+  yuv420p9be
+  yuv420p9le
+  yuv422p10be
+  yuv422p10le
+  yuv422p12be
+  yuv422p12le
+  yuv422p14be
+  yuv422p14le
+  yuv422p9be
+  yuv422p9le
+  yuv440p10be
+  yuv440p10le
+  yuv440p12be
+  yuv440p12le
+  yuv444p10be
+  yuv444p10le
+  yuv444p12be
+  yuv444p12le
+  yuv444p14be
+  yuv444p14le
+  yuv444p9be
+  yuv444p9le
+  yuva420p10be
+  yuva420p10le
+  yuva420p9be
+  yuva420p9le
+  yuva422p10be
+  yuva422p10le
+  yuva422p9be
+  yuva422p9le
+  yuva444p10be
+  yuva444p10le
+  yuva444p9be
+  yuva444p9le
+
+isBE:
+  ayuv64be
+  bayer_bggr16be
+  bayer_gbrg16be
+  bayer_grbg16be
+  bayer_rggb16be
+  bgr444be
+  bgr48be
+  bgr555be
+  bgr565be
+  bgra64be
+  gbrap10be
+  gbrap12be
+  gbrap16be
+  gbrapf32be
+  gbrp10be
+  gbrp12be
+  gbrp14be
+  gbrp16be
+  gbrp9be
+  gbrpf32be
+  gray10be
+  gray12be
+  gray16be
+  gray9be
+  nv20be
+  p010be
+  p016be
+  rgb444be
+  rgb48be
+  rgb555be
+  rgb565be
+  rgba64be
+  xyz12be
+  ya16be
+  yuv420p10be
+  yuv420p12be
+  yuv420p14be
+  yuv420p16be
+  yuv420p9be
+  yuv422p10be
+  yuv422p12be
+  yuv422p14be
+  yuv422p16be
+  yuv422p9be
+  yuv440p10be
+  yuv440p12be
+  yuv444p10be
+  yuv444p12be
+  yuv444p14be
+  yuv444p16be
+  yuv444p9be
+  yuva420p10be
+  yuva420p16be
+  yuva420p9be
+  yuva422p10be
+  yuva422p16be
+  yuva422p9be
+  yuva444p10be
+  yuva444p16be
+  yuva444p9be
+
+isYUV:
+  ayuv64be
+  ayuv64le
+  nv12
+  nv16
+  nv20be
+  nv20le
+  nv21
+  p010be
+  p010le
+  p016be
+  p016le
+  uyvy422
+  uyyvyy411
+  xyz12be
+  xyz12le
+  ya16be
+  ya16le
+  ya8
+  yuv410p
+  yuv411p
+  yuv420p
+  yuv420p10be
+  yuv420p10le
+  yuv420p12be
+  yuv420p12le
+  yuv420p14be
+  yuv420p14le
+  yuv420p16be
+  yuv420p16le
+  yuv420p9be
+  yuv420p9le
+  yuv422p
+  yuv422p10be
+  yuv422p10le
+  yuv422p12be
+  yuv422p12le
+  yuv422p14be
+  yuv422p14le
+  yuv422p16be
+  yuv422p16le
+  yuv422p9be
+  yuv422p9le
+  yuv440p
+  yuv440p10be
+  yuv440p10le
+  yuv440p12be
+  yuv440p12le
+  yuv444p
+  yuv444p10be
+  yuv444p10le
+  yuv444p12be
+  yuv444p12le
+  yuv444p14be
+  yuv444p14le
+  yuv444p16be
+  yuv444p16le
+  yuv444p9be
+  yuv444p9le
+  yuva420p
+  yuva420p10be
+  yuva420p10le
+  yuva420p16be
+  yuva420p16le
+  yuva420p9be
+  yuva420p9le
+  yuva422p
+  yuva422p10be
+  yuva422p10le
+  yuva422p16be
+  yuva422p16le
+  yuva422p9be
+  yuva422p9le
+  yuva444p
+  yuva444p10be
+  yuva444p10le
+  yuva444p16be
+  yuva444p16le
+  yuva444p9be
+  yuva444p9le
+  yuvj411p
+  yuvj420p
+  yuvj422p
+  yuvj440p
+  yuvj444p
+  yuyv422
+  yvyu422
+
+isPlanarYUV:
+  nv12
+  nv16
+  nv20be
+  nv20le
+  nv21
+  p010be
+  p010le
+  p016be
+  p016le
+  yuv410p
+  yuv411p
+  yuv420p
+  yuv420p10be
+  yuv420p10le
+  yuv420p12be
+  yuv420p12le
+  yuv420p14be
+  yuv420p14le
+  yuv420p16be
+  yuv420p16le
+  yuv420p9be
+  yuv420p9le
+  yuv422p
+  yuv422p10be
+  yuv422p10le
+  yuv422p12be
+  yuv422p12le
+  yuv422p14be
+  yuv422p14le
+  yuv422p16be
+  yuv422p16le
+  yuv422p9be
+  yuv422p9le
+  yuv440p
+  yuv440p10be
+  yuv440p10le
+  yuv440p12be
+  yuv440p12le
+  yuv444p
+  yuv444p10be
+  yuv444p10le
+  yuv444p12be
+  yuv444p12le
+  yuv444p14be
+  yuv444p14le
+  yuv444p16be
+  yuv444p16le
+  yuv444p9be
+  yuv444p9le
+  yuva420p
+  yuva420p10be
+  yuva420p10le
+  yuva420p16be
+  yuva420p16le
+  yuva420p9be
+  yuva420p9le
+  yuva422p
+  yuva422p10be
+  yuva422p10le
+  yuva422p16be
+  yuva422p16le
+  yuva422p9be
+  yuva422p9le
+  yuva444p
+  yuva444p10be
+  yuva444p10le
+  yuva444p16be
+  yuva444p16le
+  yuva444p9be
+  yuva444p9le
+  yuvj411p
+  yuvj420p
+  yuvj422p
+  yuvj440p
+  yuvj444p
+
+isRGB:
+  0bgr
+  0rgb
+  bayer_bggr16be
+  bayer_bggr16le
+  bayer_bggr8
+  bayer_gbrg16be
+  bayer_gbrg16le
+  bayer_gbrg8
+  bayer_grbg16be
+  bayer_grbg16le
+  bayer_grbg8
+  bayer_rggb16be
+  bayer_rggb16le
+  bayer_rggb8
+  bgr0
+  bgr24
+  bgr32
+  bgr32_1
+  bgr4
+  bgr444be
+  bgr444le
+  bgr48be
+  bgr48le
+  bgr4_byte
+  bgr555be
+  bgr555le
+  bgr565be
+  bgr565le
+  bgr8
+  bgra64be
+  bgra64le
+  gbrap
+  gbrap10be
+  gbrap10le
+  gbrap12be
+  gbrap12le
+  gbrap16be
+  gbrap16le
+  gbrapf32be
+  gbrapf32le
+  gbrp
+  gbrp10be
+  gbrp10le
+  gbrp12be
+  gbrp12le
+  gbrp14be
+  gbrp14le
+  gbrp16be
+  gbrp16le
+  gbrp9be
+  gbrp9le
+  gbrpf32be
+  gbrpf32le
+  rgb0
+  rgb24
+  rgb32
+  rgb32_1
+  rgb4
+  rgb444be
+  rgb444le
+  rgb48be
+  rgb48le
+  rgb4_byte
+  rgb555be
+  rgb555le
+  rgb565be
+  rgb565le
+  rgb8
+  rgba64be
+  rgba64le
+
+Gray:
+  gray
+  gray10be
+  gray10le
+  gray12be
+  gray12le
+  gray16be
+  gray16le
+  gray9be
+  gray9le
+  ya16be
+  ya16le
+  ya8
+
+RGBinInt:
+  monob
+  monow
+  rgb24
+  rgb32
+  rgb32_1
+  rgb4
+  rgb444be
+  rgb444le
+  rgb48be
+  rgb48le
+  rgb4_byte
+  rgb555be
+  rgb555le
+  rgb565be
+  rgb565le
+  rgb8
+  rgba64be
+  rgba64le
+
+BGRinInt:
+  bgr24
+  bgr32
+  bgr32_1
+  bgr4
+  bgr444be
+  bgr444le
+  bgr48be
+  bgr48le
+  bgr4_byte
+  bgr555be
+  bgr555le
+  bgr565be
+  bgr565le
+  bgr8
+  bgra64be
+  bgra64le
+  monob
+  monow
+
+Bayer:
+  bayer_bggr16be
+  bayer_bggr16le
+  bayer_bggr8
+  bayer_gbrg16be
+  bayer_gbrg16le
+  bayer_gbrg8
+  bayer_grbg16be
+  bayer_grbg16le
+  bayer_grbg8
+  bayer_rggb16be
+  bayer_rggb16le
+  bayer_rggb8
+
+AnyRGB:
+  0bgr
+  0rgb
+  bayer_bggr16be
+  bayer_bggr16le
+  bayer_bggr8
+  bayer_gbrg16be
+  bayer_gbrg16le
+  bayer_gbrg8
+  bayer_grbg16be
+  bayer_grbg16le
+  bayer_grbg8
+  bayer_rggb16be
+  bayer_rggb16le
+  bayer_rggb8
+  bgr0
+  bgr24
+  bgr32
+  bgr32_1
+  bgr4
+  bgr444be
+  bgr444le
+  bgr48be
+  bgr48le
+  bgr4_byte
+  bgr555be
+  bgr555le
+  bgr565be
+  bgr565le
+  bgr8
+  bgra64be
+  bgra64le
+  gbrap
+  gbrap10be
+  gbrap10le
+  gbrap12be
+  gbrap12le
+  gbrap16be
+  gbrap16le
+  gbrapf32be
+  gbrapf32le
+  gbrp
+  gbrp10be
+  gbrp10le
+  gbrp12be
+  gbrp12le
+  gbrp14be
+  gbrp14le
+  gbrp16be
+  gbrp16le
+  gbrp9be
+  gbrp9le
+  gbrpf32be
+  gbrpf32le
+  monob
+  monow
+  rgb0
+  rgb24
+  rgb32
+  rgb32_1
+  rgb4
+  rgb444be
+  rgb444le
+  rgb48be
+  rgb48le
+  rgb4_byte
+  rgb555be
+  rgb555le
+  rgb565be
+  rgb565le
+  rgb8
+  rgba64be
+  rgba64le
+
+ALPHA:
+  ayuv64be
+  ayuv64le
+  bgr32
+  bgr32_1
+  bgra64be
+  bgra64le
+  gbrap
+  gbrap10be
+  gbrap10le
+  gbrap12be
+  gbrap12le
+  gbrap16be
+  gbrap16le
+  gbrapf32be
+  gbrapf32le
+  pal8
+  rgb32
+  rgb32_1
+  rgba64be
+  rgba64le
+  ya16be
+  ya16le
+  ya8
+  yuva420p
+  yuva420p10be
+  yuva420p10le
+  yuva420p16be
+  yuva420p16le
+  yuva420p9be
+  yuva420p9le
+  yuva422p
+  yuva422p10be
+  yuva422p10le
+  yuva422p16be
+  yuva422p16le
+  yuva422p9be
+  yuva422p9le
+  yuva444p
+  yuva444p10be
+  yuva444p10le
+  yuva444p16be
+  yuva444p16le
+  yuva444p9be
+  yuva444p9le
+
+Packed:
+  0bgr
+  0rgb
+  ayuv64be
+  ayuv64le
+  bayer_bggr16be
+  bayer_bggr16le
+  bayer_bggr8
+  bayer_gbrg16be
+  bayer_gbrg16le
+  bayer_gbrg8
+  bayer_grbg16be
+  bayer_grbg16le
+  bayer_grbg8
+  bayer_rggb16be
+  bayer_rggb16le
+  bayer_rggb8
+  bgr0
+  bgr24
+  bgr32
+  bgr32_1
+  bgr4
+  bgr444be
+  bgr444le
+  bgr48be
+  bgr48le
+  bgr4_byte
+  bgr555be
+  bgr555le
+  bgr565be
+  bgr565le
+  bgr8
+  bgra64be
+  bgra64le
+  monob
+  monow
+  pal8
+  rgb0
+  rgb24
+  rgb32
+  rgb32_1
+  rgb4
+  rgb444be
+  rgb444le
+  rgb48be
+  rgb48le
+  rgb4_byte
+  rgb555be
+  rgb555le
+  rgb565be
+  rgb565le
+  rgb8
+  rgba64be
+  rgba64le
+  uyvy422
+  uyyvyy411
+  xyz12be
+  xyz12le
+  ya16be
+  ya16le
+  ya8
+  yuyv422
+  yvyu422
+
+Planar:
+  gbrap
+  gbrap10be
+  gbrap10le
+  gbrap12be
+  gbrap12le
+  gbrap16be
+  gbrap16le
+  gbrapf32be
+  gbrapf32le
+  gbrp
+  gbrp10be
+  gbrp10le
+  gbrp12be
+  gbrp12le
+  gbrp14be
+  gbrp14le
+  gbrp16be
+  gbrp16le
+  gbrp9be
+  gbrp9le
+  gbrpf32be
+  gbrpf32le
+  nv12
+  nv16
+  nv20be
+  nv20le
+  nv21
+  p010be
+  p010le
+  p016be
+  p016le
+  yuv410p
+  yuv411p
+  yuv420p
+  yuv420p10be
+  yuv420p10le
+  yuv420p12be
+  yuv420p12le
+  yuv420p14be
+  yuv420p14le
+  yuv420p16be
+  yuv420p16le
+  yuv420p9be
+  yuv420p9le
+  yuv422p
+  yuv422p10be
+  yuv422p10le
+  yuv422p12be
+  yuv422p12le
+  yuv422p14be
+  yuv422p14le
+  yuv422p16be
+  yuv422p16le
+  yuv422p9be
+  yuv422p9le
+  yuv440p
+  yuv440p10be
+  yuv440p10le
+  yuv440p12be
+  yuv440p12le
+  yuv444p
+  yuv444p10be
+  yuv444p10le
+  yuv444p12be
+  yuv444p12le
+  yuv444p14be
+  yuv444p14le
+  yuv444p16be
+  yuv444p16le
+  yuv444p9be
+  yuv444p9le
+  yuva420p
+  yuva420p10be
+  yuva420p10le
+  yuva420p16be
+  yuva420p16le
+  yuva420p9be
+  yuva420p9le
+  yuva422p
+  yuva422p10be
+  yuva422p10le
+  yuva422p16be
+  yuva422p16le
+  yuva422p9be
+  yuva422p9le
+  yuva444p
+  yuva444p10be
+  yuva444p10le
+  yuva444p16be
+  yuva444p16le
+  yuva444p9be
+  yuva444p9le
+  yuvj411p
+  yuvj420p
+  yuvj422p
+  yuvj440p
+  yuvj444p
+
+PackedRGB:
+  0bgr
+  0rgb
+  bayer_bggr16be
+  bayer_bggr16le
+  bayer_bggr8
+  bayer_gbrg16be
+  bayer_gbrg16le
+  bayer_gbrg8
+  bayer_grbg16be
+  bayer_grbg16le
+  bayer_grbg8
+  bayer_rggb16be
+  bayer_rggb16le
+  bayer_rggb8
+  bgr0
+  bgr24
+  bgr32
+  bgr32_1
+  bgr4
+  bgr444be
+  bgr444le
+  bgr48be
+  bgr48le
+  bgr4_byte
+  bgr555be
+  bgr555le
+  bgr565be
+  bgr565le
+  bgr8
+  bgra64be
+  bgra64le
+  rgb0
+  rgb24
+  rgb32
+  rgb32_1
+  rgb4
+  rgb444be
+  rgb444le
+  rgb48be
+  rgb48le
+  rgb4_byte
+  rgb555be
+  rgb555le
+  rgb565be
+  rgb565le
+  rgb8
+  rgba64be
+  rgba64le
+
+PlanarRGB:
+  gbrap
+  gbrap10be
+  gbrap10le
+  gbrap12be
+  gbrap12le
+  gbrap16be
+  gbrap16le
+  gbrapf32be
+  gbrapf32le
+  gbrp
+  gbrp10be
+  gbrp10le
+  gbrp12be
+  gbrp12le
+  gbrp14be
+  gbrp14le
+  gbrp16be
+  gbrp16le
+  gbrp9be
+  gbrp9le
+  gbrpf32be
+  gbrpf32le
+
+usePal:
+  bgr4_byte
+  bgr8
+  gray
+  pal8
+  rgb4_byte
+  rgb8
+
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/tiertex-seq b/mythtv/external/FFmpeg/tests/ref/fate/tiertex-seq
index 3504dd42fc4..1db906ad33f 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/tiertex-seq
+++ b/mythtv/external/FFmpeg/tests/ref/fate/tiertex-seq
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 22050
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 1,          0,          0,      882,     1764, 0x00000000
 1,        882,        882,      882,     1764, 0x80a253d9
 0,          2,          2,        1,    98304, 0x2e5db4a4
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/time_base b/mythtv/external/FFmpeg/tests/ref/fate/time_base
new file mode 100644
index 00000000000..7923556b351
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/time_base
@@ -0,0 +1 @@
+d26a35b141551b36c5b8bd716451cfcb
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/tmv b/mythtv/external/FFmpeg/tests/ref/fate/tmv
index 94437fa754b..09198fab2b6 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/tmv
+++ b/mythtv/external/FFmpeg/tests/ref/fate/tmv
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 22058
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   192000, 0xc698297a
 1,          0,          0,      368,      736, 0xf63db497
 0,          1,          1,        1,   192000, 0x8d5bd6be
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/ts-demux b/mythtv/external/FFmpeg/tests/ref/fate/ts-demux
index c66e9075b83..e2931af4273 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/ts-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/ts-demux
@@ -9,6 +9,7 @@
 #codec_id 1: ac3
 #sample_rate 1: 48000
 #channel_layout 1: 60f
+#channel_layout_name 1: 5.1(side)
 1,          0,          0,     2880,     1536, 0x773ffeea, S=1,        1, 0x00bd00bd
 1,       2880,       2880,     2880,     1536, 0x6dc10748
 1,       5760,       5760,     2880,     1536, 0xbab5129c
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/ts-opus-demux b/mythtv/external/FFmpeg/tests/ref/fate/ts-opus-demux
index 9d2da43feaa..3c5edffb2cc 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/ts-opus-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/ts-opus-demux
@@ -4,6 +4,7 @@
 #codec_id 0: opus
 #sample_rate 0: 48000
 #channel_layout 0: 63f
+#channel_layout_name 0: 7.1
 0,          0,          0,     1800,      744, 0x172b615b, S=1,        1, 0x00bd00bd
 0,       1800,       1800,     1800,      743, 0x3f5b673d, S=1,        1, 0x00bd00bd
 0,       3600,       3600,     1800,      747, 0xe54e735d, S=1,        1, 0x00bd00bd
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/tscc-15bit b/mythtv/external/FFmpeg/tests/ref/fate/tscc-15bit
index e8543205711..abfe6a6aeea 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/tscc-15bit
+++ b/mythtv/external/FFmpeg/tests/ref/fate/tscc-15bit
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 11025
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   657600, 0x50b3a0c2
 1,          0,          0,    11025,    22050, 0x1740aaec
 0,          1,          1,        1,   657600, 0x50b3a0c2
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/tscc2-avi b/mythtv/external/FFmpeg/tests/ref/fate/tscc2-avi
index 6f0e8a53d39..09ed8973375 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/tscc2-avi
+++ b/mythtv/external/FFmpeg/tests/ref/fate/tscc2-avi
@@ -5,33 +5,25 @@
 #sar 0: 0/1
 0,          0,          0,        1,   230400, 0x7a2103c0
 0,          1,          1,        1,   230400, 0xd381c279
-0,          2,          2,        1,   230400, 0xd381c279
 0,          3,          3,        1,   230400, 0x110aec27
 0,          4,          4,        1,   230400, 0x4be67ee7
 0,          5,          5,        1,   230400, 0xd87fe4b4
-0,          6,          6,        1,   230400, 0xd87fe4b4
 0,          7,          7,        1,   230400, 0x9bc6a398
 0,          8,          8,        1,   230400, 0xd67d92db
 0,          9,          9,        1,   230400, 0x3df6559e
-0,         10,         10,        1,   230400, 0x3df6559e
 0,         11,         11,        1,   230400, 0x2136ff25
 0,         12,         12,        1,   230400, 0x94573fe6
 0,         13,         13,        1,   230400, 0xbf67d3f5
-0,         14,         14,        1,   230400, 0xbf67d3f5
 0,         15,         15,        1,   230400, 0x2592b5cf
 0,         16,         16,        1,   230400, 0x5b23cd93
 0,         17,         17,        1,   230400, 0x9b76d079
-0,         18,         18,        1,   230400, 0x9b76d079
 0,         19,         19,        1,   230400, 0x771a017e
 0,         20,         20,        1,   230400, 0xacfee1d0
 0,         21,         21,        1,   230400, 0x6b9ff4eb
-0,         22,         22,        1,   230400, 0x6b9ff4eb
 0,         23,         23,        1,   230400, 0xbaf643e1
 0,         24,         24,        1,   230400, 0x052efe59
 0,         25,         25,        1,   230400, 0xd751f901
-0,         26,         26,        1,   230400, 0xd751f901
 0,         27,         27,        1,   230400, 0x6f94e11f
 0,         28,         28,        1,   230400, 0x17eeabb9
 0,         29,         29,        1,   230400, 0x3733a035
-0,         30,         30,        1,   230400, 0x3733a035
 0,         31,         31,        1,   230400, 0xb0829f45
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgb_left b/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgb_left
index d2ccbcea03b..23e48c426d5 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgb_left
+++ b/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgb_left
@@ -3,7 +3,7 @@
 #codec_id 0: rawvideo
 #dimensions 0: 640x480
 #sar 0: 0/1
-0,          0,          0,        1,   921600, 0x27e6001e
-0,          1,          1,        1,   921600, 0x7c0a92bc
-0,          2,          2,        1,   921600, 0x4d2be42c
-0,          3,          3,        1,   921600, 0x58ddd0be
+0,          0,          0,        1,   921600, 0xb457001e
+0,          1,          1,        1,   921600, 0xceff92bc
+0,          2,          2,        1,   921600, 0x762de42c
+0,          3,          3,        1,   921600, 0xef14d0be
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgb_median b/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgb_median
index 913b697be2f..e7c623a8da3 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgb_median
+++ b/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgb_median
@@ -3,8 +3,8 @@
 #codec_id 0: rawvideo
 #dimensions 0: 640x480
 #sar 0: 0/1
-0,          0,          0,        1,   921600, 0x9776611f
-0,          1,          1,        1,   921600, 0xdbfa64f4
-0,          2,          2,        1,   921600, 0xed2a0580
-0,          3,          3,        1,   921600, 0x6ecc80bc
-0,          4,          4,        1,   921600, 0x58ddd0be
+0,          0,          0,        1,   921600, 0x85af611f
+0,          1,          1,        1,   921600, 0xc97a64f4
+0,          2,          2,        1,   921600, 0xb1db0580
+0,          3,          3,        1,   921600, 0xa18d80bc
+0,          4,          4,        1,   921600, 0xef14d0be
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_left b/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_left
index cb7876f1a7c..b24b7f4bfa1 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_left
+++ b/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_left
@@ -3,8 +3,8 @@
 #codec_id 0: rawvideo
 #dimensions 0: 640x480
 #sar 0: 0/1
-0,          0,          0,        1,  1228800, 0xf1bc9432
-0,          1,          1,        1,  1228800, 0x8480d1e5
-0,          2,          2,        1,  1228800, 0xb01d5fb2
-0,          3,          3,        1,  1228800, 0x53cb42c4
-0,          4,          4,        1,  1228800, 0x2b2ea176
+0,          0,          0,        1,  1228800, 0xf9f49432
+0,          1,          1,        1,  1228800, 0xf089d1e5
+0,          2,          2,        1,  1228800, 0xbd025fb2
+0,          3,          3,        1,  1228800, 0x17bf42c4
+0,          4,          4,        1,  1228800, 0xe31ea176
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_median b/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_median
index cb7876f1a7c..b24b7f4bfa1 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_median
+++ b/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_median
@@ -3,8 +3,8 @@
 #codec_id 0: rawvideo
 #dimensions 0: 640x480
 #sar 0: 0/1
-0,          0,          0,        1,  1228800, 0xf1bc9432
-0,          1,          1,        1,  1228800, 0x8480d1e5
-0,          2,          2,        1,  1228800, 0xb01d5fb2
-0,          3,          3,        1,  1228800, 0x53cb42c4
-0,          4,          4,        1,  1228800, 0x2b2ea176
+0,          0,          0,        1,  1228800, 0xf9f49432
+0,          1,          1,        1,  1228800, 0xf089d1e5
+0,          2,          2,        1,  1228800, 0xbd025fb2
+0,          3,          3,        1,  1228800, 0x17bf42c4
+0,          4,          4,        1,  1228800, 0xe31ea176
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_single_symbol b/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_single_symbol
index 553c83552ea..a20dc3dda4d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_single_symbol
+++ b/mythtv/external/FFmpeg/tests/ref/fate/utvideo_rgba_single_symbol
@@ -3,4 +3,4 @@
 #codec_id 0: rawvideo
 #dimensions 0: 1024x768
 #sar 0: 0/1
-0,          0,          0,        1,  3145728, 0xac95c593
+0,          0,          0,        1,  3145728, 0xa07dc593
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/v410enc b/mythtv/external/FFmpeg/tests/ref/fate/v410enc
index b2c728e9b24..9fddf5a35c9 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/v410enc
+++ b/mythtv/external/FFmpeg/tests/ref/fate/v410enc
@@ -1 +1 @@
-f7cf1b743c18f74d047ce8d6ea05d3d9
+465bcc7477104a8295f47b35f1b987df
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/vp5 b/mythtv/external/FFmpeg/tests/ref/fate/vp5
index 2116fb9b81b..2469a3ec21a 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/vp5
+++ b/mythtv/external/FFmpeg/tests/ref/fate/vp5
@@ -249,4 +249,4 @@
 0,        243,        243,        1,   233472, 0x6f530ac6
 0,        244,        244,        1,   233472, 0x94f7466c
 0,        245,        245,        1,   233472, 0xa8c1d365
-0,        246,        246,        1,   233472, 0xedcff050
+0,        246,        246,        1,   233472, 0xbf73f1b7
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/vp8-size-change b/mythtv/external/FFmpeg/tests/ref/fate/vp8-size-change
index 741b6d65fb3..5105bc6f556 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/vp8-size-change
+++ b/mythtv/external/FFmpeg/tests/ref/fate/vp8-size-change
@@ -4,36 +4,36 @@
 #tb 0: 1/30
 #media_type 0: video
 #codec_id 0: rawvideo
-#dimensions 0: 1920x1080
+#dimensions 0: 160x90
 #sar 0: 1/1
 #stream#, dts,        pts, duration,     size, hash
-0,          0,          0,        1,  3110400, 7dde8cd136ab4b04a95d9856b941697e
-0,          1,          1,        1,  3110400, aa885f78cb6374b5bfcc66a4fc57026f
-0,          2,          2,        1,  3110400, b69b7b56f549a3f9b0a603940bac85ed
-0,          3,          3,        1,  3110400, 20e2e0f0c89c58828b6a3b10d9e175e5
-0,          4,          4,        1,  3110400, 483997936e7d6bb849e64d50426ec689
-0,          5,          5,        1,  3110400, c85ef97a853ff594e2bfdf0a0a581dcc
-0,          6,          6,        1,  3110400, c5e7b9ff4c25391793446da788cb83a9
-0,          7,          7,        1,  3110400, 63f93e89d24162e2f6328edbc6716b33
-0,          8,          8,        1,  3110400, 0e346ab4831ce8c69001153c72b7b827
-0,          9,          9,        1,  3110400, c526c21511d8bec2659d3d43d93734f2
-0,         10,         10,        1,  3110400, e95d01d5f9fb81a98bd34305c7ab30f8
-0,         11,         11,        1,  3110400, 177e75e7516e8746d31b43ea9d39e6b1
-0,         12,         12,        1,  3110400, 489d2bc0da93f118dc9a2697275697a7
-0,         13,         13,        1,  3110400, a2dc00d627350ff1ab302bcbad5ca5ac
-0,         14,         14,        1,  3110400, 20ce143831b0189f763ee5bee9c51188
-0,         15,         15,        1,  3110400, 7822fd908bd81b521c23fa4a639caf9e
-0,         16,         16,        1,  3110400, dabc4febbe09734126ac6f5a5180ba8c
-0,         17,         17,        1,  3110400, ef88f0d6667feefac1471b065208e1c8
-0,         18,         18,        1,  3110400, 7c7fc665a6fd9e19af9358bbdc162a51
-0,         19,         19,        1,  3110400, f2bcf32f734f99506bdd0a0376badf82
-0,         20,         20,        1,  3110400, 06809c2d277fd3b3918ebb4b65c27661
-0,         21,         21,        1,  3110400, e403e9e86fa5d519f65c565b3add84b5
-0,         22,         22,        1,  3110400, d2b876730e12245cacb578307794349a
-0,         23,         23,        1,  3110400, dfdfd8cb626a96138f6a2c1953dcf5ec
-0,         24,         24,        1,  3110400, 0ac58c28575b804d9e63395653c3aef2
-0,         25,         25,        1,  3110400, 641f2a78e338c733ef159bd36ec7966f
-0,         26,         26,        1,  3110400, 9402d455fa5bd556b85f479c42c3a4d2
-0,         27,         27,        1,  3110400, 0044d42b4048bc93112aa59789dbdc2d
-0,         28,         28,        1,  3110400, 5d9e5c5ba35f6f452e5f31ccff9e819c
-0,         29,         29,        1,  3110400, 307a55a94739b4cfdf41f7da7e5c0135
+0,          0,          0,        1,    21600, 5abd6c163522c7e882f7e9c369293bf9
+0,          1,          1,        1,    21600, 5c11d8cc9cc9102d0ef5afd1dc64aff1
+0,          2,          2,        1,    21600, cbeffa9ea9d682af77d3fd0fdf12c8c1
+0,          3,          3,        1,    21600, ea7cec515fcf8ccbc932d9e9b472cdc7
+0,          4,          4,        1,    21600, 23038b711dbac95ce710657b1fef5901
+0,          5,          5,        1,    21600, e0d6fb46bb5c0d939ee33af82b887668
+0,          6,          6,        1,    21600, 694518f14d3a2bd3c319bc0b098c78bb
+0,          7,          7,        1,    21600, c1c7394bd4236afbc773af52ef7a10ea
+0,          8,          8,        1,    21600, 4d8d3b2c9a637f963521585ea879357b
+0,          9,          9,        1,    21600, b4444dc3cbf1b6cdd8047d3dcd497ffd
+0,         10,         10,        1,    21600, 65e5d667ec9ceb636e21357f032ce800
+0,         11,         11,        1,    21600, fd9a4c67598051074387b640df7edaa9
+0,         12,         12,        1,    21600, 0e54e22d90f6296ae6989c83846272cd
+0,         13,         13,        1,    21600, db4b1727450243b202bfec5ed6c73ae0
+0,         14,         14,        1,    21600, ab37a84be075ca42cc7351ff9fb1cb47
+0,         15,         15,        1,    21600, ae4d2d297e646bd8e05e76b457d9b576
+0,         16,         16,        1,    21600, e7cfd580e3c3d7c3f2f5136d1e548595
+0,         17,         17,        1,    21600, cbec09314a0b7ad53f4893eb474e1c65
+0,         18,         18,        1,    21600, e1fa89cd63c37496bc86f18694324d88
+0,         19,         19,        1,    21600, e9655b151253950313810228278ca104
+0,         20,         20,        1,    21600, 69ba31c0eff7bc93f4180173d8e64c60
+0,         21,         21,        1,    21600, 368a1f6a1172d7d56f695153b234a330
+0,         22,         22,        1,    21600, 6c298b196e16c64f7c2f407ba1242937
+0,         23,         23,        1,    21600, bf54474112ed5592c4d890e3313881a0
+0,         24,         24,        1,    21600, 945d49abedb0606b6a009c8b5d8face3
+0,         25,         25,        1,    21600, dd6ebef7b6f24619910de811918d3437
+0,         26,         26,        1,    21600, 7952346fc0f1eff3914e0d7646b3cf28
+0,         27,         27,        1,    21600, 26bd0d6b21e8a2df17af8d1446fba745
+0,         28,         28,        1,    21600, b0d91600416716d81c1f73ac141a0b62
+0,         29,         29,        1,    21600, 08f16698beb9cc15f7115961bd69e995
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/vqf-demux b/mythtv/external/FFmpeg/tests/ref/fate/vqf-demux
index 2d26a729f99..d768ddbb69d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/vqf-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/vqf-demux
@@ -1 +1 @@
-643ac05caf7ef16a8837933bf45281d5
+5f4cd9a6a8bea0040db6732a7830e9d7
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/wav-ac3 b/mythtv/external/FFmpeg/tests/ref/fate/wav-ac3
index fd27f744bf1..039e155dafb 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/wav-ac3
+++ b/mythtv/external/FFmpeg/tests/ref/fate/wav-ac3
@@ -3,6 +3,7 @@
 #codec_id 0: ac3
 #sample_rate 0: 44100
 #channel_layout 0: 60f
+#channel_layout_name 0: 5.1(side)
 0,          0,          0,     1536,     2786, 0xe2fd0f40
 0,       1536,       1536,     1536,     2786, 0x7a6207c2
 0,       3072,       3072,     1536,     2786, 0x7a6207c2
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/wc3movie-xan b/mythtv/external/FFmpeg/tests/ref/fate/wc3movie-xan
index 58125034348..052dbbce7d5 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/wc3movie-xan
+++ b/mythtv/external/FFmpeg/tests/ref/fate/wc3movie-xan
@@ -8,6 +8,7 @@
 #codec_id 1: pcm_s16le
 #sample_rate 1: 22050
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        1,   158400, 0x25aec781
 1,          0,          0,     1470,     2940, 0x92cee2a6
 0,          1,          1,        1,   158400, 0xda4dbf70
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/webm-dash-manifest-live-bandwidth b/mythtv/external/FFmpeg/tests/ref/fate/webm-dash-manifest-live-bandwidth
new file mode 100644
index 00000000000..18b89512837
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/fate/webm-dash-manifest-live-bandwidth
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<MPD
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns="urn:mpeg:DASH:schema:MPD:2011"
+  xsi:schemaLocation="urn:mpeg:DASH:schema:MPD:2011"
+  type="dynamic"
+  minBufferTime="PT1S"
+  profiles="urn:mpeg:dash:profile:isoff-live:2011"
+  availabilityStartTime=""
+  timeShiftBufferDepth="PT7200S"
+  minimumUpdatePeriod="PT60S">
+<Period id="0" start="PT0S" >
+<AdaptationSet id="0" mimeType="video/webm" codecs="vp9" bitstreamSwitching="true" subsegmentAlignment="true" subsegmentStartsWithSAP="1">
+<ContentComponent id="1" type="video"/>
+<SegmentTemplate timescale="1000" duration="5000" media="dash_live_video_$RepresentationID$_$Number$.chk" startNumber="1" initialization="dash_live_video_$RepresentationID$.hdr"/>
+<Representation id="360" bandwidth="100" width="640" height="360" codecs="vp9" mimeType="video/webm" startsWithSAP="1"></Representation>
+</AdaptationSet>
+<AdaptationSet id="1" mimeType="audio/webm" codecs="vorbis" bitstreamSwitching="true" subsegmentAlignment="true" subsegmentStartsWithSAP="1">
+<ContentComponent id="1" type="audio"/>
+<SegmentTemplate timescale="1000" duration="5000" media="dash_live_audio_$RepresentationID$_$Number$.chk" startNumber="1" initialization="dash_live_audio_$RepresentationID$.hdr"/>
+<Representation id="171" bandwidth="200" audioSamplingRate="32000" codecs="vorbis" mimeType="audio/webm" startsWithSAP="1"></Representation>
+</AdaptationSet>
+</Period>
+</MPD>
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/westwood-aud b/mythtv/external/FFmpeg/tests/ref/fate/westwood-aud
index fedcd5d6cb9..b719c50a4d4 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/westwood-aud
+++ b/mythtv/external/FFmpeg/tests/ref/fate/westwood-aud
@@ -3,6 +3,7 @@
 #codec_id 0: adpcm_ima_ws
 #sample_rate 0: 22050
 #channel_layout 0: 4
+#channel_layout_name 0: mono
 0,          0,          0,     1024,      512, 0x6694cc55
 0,       1024,       1024,     1024,      512, 0xdbc5cb22
 0,       2048,       2048,     1024,      512, 0x8e5bcbfd
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/wmv8-drm b/mythtv/external/FFmpeg/tests/ref/fate/wmv3-drm-dec
similarity index 100%
rename from mythtv/external/FFmpeg/tests/ref/fate/wmv8-drm
rename to mythtv/external/FFmpeg/tests/ref/fate/wmv3-drm-dec
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/wmv8-drm-nodec b/mythtv/external/FFmpeg/tests/ref/fate/wmv3-drm-nodec
similarity index 99%
rename from mythtv/external/FFmpeg/tests/ref/fate/wmv8-drm-nodec
rename to mythtv/external/FFmpeg/tests/ref/fate/wmv3-drm-nodec
index 83aa92d2357..a46c338d54e 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/wmv8-drm-nodec
+++ b/mythtv/external/FFmpeg/tests/ref/fate/wmv3-drm-nodec
@@ -10,6 +10,7 @@
 #codec_id 1: wmavoice
 #sample_rate 1: 22050
 #channel_layout 1: 4
+#channel_layout_name 1: mono
 0,          0,          0,        0,      282, 0x000d949a
 1,          0,          0,        0,     1088, 0x5cd379bb
 1,        435,        435,        0,     1088, 0x8dfa1368
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/wtv-demux b/mythtv/external/FFmpeg/tests/ref/fate/wtv-demux
index 306fe00ed5d..abe85a4ab6d 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/wtv-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/wtv-demux
@@ -10,6 +10,7 @@
 #codec_id 1: mp2
 #sample_rate 1: 48000
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 1,         -2,         -2,   240000,      576, 0x9b6e1638
 1,     239998,     239998,   240000,      576, 0x0ca91183
 1,     479998,     479998,   240000,      576, 0xec6a180f
diff --git a/mythtv/external/FFmpeg/tests/ref/fate/xmv-demux b/mythtv/external/FFmpeg/tests/ref/fate/xmv-demux
index 5840129f8ac..6da2b1a7011 100644
--- a/mythtv/external/FFmpeg/tests/ref/fate/xmv-demux
+++ b/mythtv/external/FFmpeg/tests/ref/fate/xmv-demux
@@ -9,6 +9,7 @@
 #codec_id 1: adpcm_ima_wav
 #sample_rate 1: 44100
 #channel_layout 1: 3
+#channel_layout_name 1: stereo
 0,          0,          0,        0,     1508, 0xefceba48
 1,          0,          0,       83,     5976, 0xfa2c2db9
 1,         83,         83,       83,     5976, 0x256b935c
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/apng b/mythtv/external/FFmpeg/tests/ref/lavf/apng
new file mode 100644
index 00000000000..8e9e5e6b73d
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/apng
@@ -0,0 +1,9 @@
+a4c46fad7716ad094eb3c78b74ca0244 *./tests/data/lavf/lavf.apng
+6209864 ./tests/data/lavf/lavf.apng
+./tests/data/lavf/lavf.apng CRC=0x87b3c15f
+a4c46fad7716ad094eb3c78b74ca0244 *./tests/data/lavf/lavf.copy.apng
+6209864 ./tests/data/lavf/lavf.copy.apng
+./tests/data/lavf/lavf.copy.apng CRC=0x87b3c15f
+c5900fdd1b2fc30b985793f5226fd0c4 *./tests/data/lavf/lavf.png
+248854 ./tests/data/lavf/lavf.png
+./tests/data/lavf/lavf.png CRC=0xd8c7b7a1
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/dv_fmt b/mythtv/external/FFmpeg/tests/ref/lavf/dv_fmt
index b152c84ca82..0263202c8e8 100644
--- a/mythtv/external/FFmpeg/tests/ref/lavf/dv_fmt
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/dv_fmt
@@ -1,9 +1,9 @@
-11be3e5caa2892236b3475c3f7807b76 *./tests/data/lavf/lavf.dv
+7830f9c6716ceb6011f865f1e521b951 *./tests/data/lavf/lavf.dv
 3600000 ./tests/data/lavf/lavf.dv
-./tests/data/lavf/lavf.dv CRC=0x0b2cd3ec
-e9949bc767924e1e7d28856029fee024 *./tests/data/lavf/lavf.dv
+./tests/data/lavf/lavf.dv CRC=0xd428d3ee
+5569626370c7c72d40de2c4559e32856 *./tests/data/lavf/lavf.dv
 3480000 ./tests/data/lavf/lavf.dv
-./tests/data/lavf/lavf.dv CRC=0xfab17c4a
-87d3b20f656235671383a7eaa2f66330 *./tests/data/lavf/lavf.dv
+./tests/data/lavf/lavf.dv CRC=0xa0088163
+2fb332aab8f2ba9c33b1b2368194392a *./tests/data/lavf/lavf.dv
 3600000 ./tests/data/lavf/lavf.dv
-./tests/data/lavf/lavf.dv CRC=0xf3e6873c
+./tests/data/lavf/lavf.dv CRC=0xbdaf7f52
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/ffm b/mythtv/external/FFmpeg/tests/ref/lavf/ffm
index c4d7e1f8078..d9fa8d52cbc 100644
--- a/mythtv/external/FFmpeg/tests/ref/lavf/ffm
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/ffm
@@ -1,3 +1,3 @@
-e63c16b5f0ad5015304fc4009fdb33ca *./tests/data/lavf/lavf.ffm
+ca2a450cd0d1e299514a345923b4c82a *./tests/data/lavf/lavf.ffm
 376832 ./tests/data/lavf/lavf.ffm
 ./tests/data/lavf/lavf.ffm CRC=0x000e23ae
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/fits b/mythtv/external/FFmpeg/tests/ref/lavf/fits
new file mode 100644
index 00000000000..489542b32be
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/fits
@@ -0,0 +1,18 @@
+ed9fd697d0d782df6201f6a2db184552 *./tests/data/lavf/graylavf.fits
+5328000 ./tests/data/lavf/graylavf.fits
+./tests/data/lavf/graylavf.fits CRC=0xbacf446c
+48e6caf6a59e32f9a8a39979c9183a7f *./tests/data/lavf/gray16belavf.fits
+10368000 ./tests/data/lavf/gray16belavf.fits
+./tests/data/lavf/gray16belavf.fits CRC=0xae2b58d4
+be2f7112fd193c9a909304c81e662769 *./tests/data/lavf/gbrplavf.fits
+15408000 ./tests/data/lavf/gbrplavf.fits
+./tests/data/lavf/gbrplavf.fits CRC=0x04ed3828
+c89a72185cfad363aa9cc42e84fed301 *./tests/data/lavf/gbraplavf.fits
+20448000 ./tests/data/lavf/gbraplavf.fits
+./tests/data/lavf/gbraplavf.fits CRC=0x032a6409
+d539b9e02f5ab8fb85717c8adb60b6cc *./tests/data/lavf/gbrp16belavf.fits
+30672000 ./tests/data/lavf/gbrp16belavf.fits
+./tests/data/lavf/gbrp16belavf.fits CRC=0x81897ff7
+3dc3622fb09a338b406d8a12a30f2545 *./tests/data/lavf/gbrap16belavf.fits
+40752000 ./tests/data/lavf/gbrap16belavf.fits
+./tests/data/lavf/gbrap16belavf.fits CRC=0x247dd7b9
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/gxf b/mythtv/external/FFmpeg/tests/ref/lavf/gxf
index d356f208113..4dd463cd2a5 100644
--- a/mythtv/external/FFmpeg/tests/ref/lavf/gxf
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/gxf
@@ -1,9 +1,9 @@
-7993da95d8bfe04832e27892c163e562 *./tests/data/lavf/lavf.gxf
+6ef34e8bedf699cd1601022c4a0a4910 *./tests/data/lavf/lavf.gxf
 795876 ./tests/data/lavf/lavf.gxf
-./tests/data/lavf/lavf.gxf CRC=0xda7cebbc
-9e873074b5c3ef1d80d233a38e7de156 *./tests/data/lavf/lavf.gxf
+./tests/data/lavf/lavf.gxf CRC=0x1dbfef76
+7780c428dde2c93a9ff04794f7168440 *./tests/data/lavf/lavf.gxf
 794656 ./tests/data/lavf/lavf.gxf
-./tests/data/lavf/lavf.gxf CRC=0x7f0c9089
+./tests/data/lavf/lavf.gxf CRC=0xdcd39443
 0638c4d073ac224608baaba16732b68f *./tests/data/lavf/lavf.gxf
 795876 ./tests/data/lavf/lavf.gxf
 ./tests/data/lavf/lavf.gxf CRC=0x5ade0285
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/jpg b/mythtv/external/FFmpeg/tests/ref/lavf/jpg
index 1309d742c82..508066747f7 100644
--- a/mythtv/external/FFmpeg/tests/ref/lavf/jpg
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/jpg
@@ -1,3 +1,3 @@
-131878fee153a086d740543fbf2ab359 *./tests/data/images/jpg/02.jpg
+1e7c6d937f21c045e0b238a83f62f3c5 *./tests/data/images/jpg/02.jpg
 ./tests/data/images/jpg/%02d.jpg CRC=0xe3509f33
-28406 ./tests/data/images/jpg/02.jpg
+26037 ./tests/data/images/jpg/02.jpg
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/mxf b/mythtv/external/FFmpeg/tests/ref/lavf/mxf
index e1c0c79b055..b9c37334a97 100644
--- a/mythtv/external/FFmpeg/tests/ref/lavf/mxf
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/mxf
@@ -1,9 +1,9 @@
-f9b570c7b4fbbc2b71f2236b32e7cbb6 *./tests/data/lavf/lavf.mxf
+1c06a9d69b6e309579784db5ecb0b69f *./tests/data/lavf/lavf.mxf
 525369 ./tests/data/lavf/lavf.mxf
-./tests/data/lavf/lavf.mxf CRC=0xdbfff6f1
-8f6a9a6b409f0f5a0bf003f8dea26314 *./tests/data/lavf/lavf.mxf
+./tests/data/lavf/lavf.mxf CRC=0x8dddfaab
+50b4f9ca0493e6d83f4c52dc3aa2b7a5 *./tests/data/lavf/lavf.mxf
 560697 ./tests/data/lavf/lavf.mxf
-./tests/data/lavf/lavf.mxf CRC=0x11a6178e
-10ac0f158fc0af356439b818de7601e3 *./tests/data/lavf/lavf.mxf
+./tests/data/lavf/lavf.mxf CRC=0xf21b1b48
+4b71b154ae37364c8028cb50850a54c5 *./tests/data/lavf/lavf.mxf
 525369 ./tests/data/lavf/lavf.mxf
-./tests/data/lavf/lavf.mxf CRC=0xdbfff6f1
+./tests/data/lavf/lavf.mxf CRC=0x8dddfaab
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/mxf_dv25 b/mythtv/external/FFmpeg/tests/ref/lavf/mxf_dv25
new file mode 100644
index 00000000000..85094828d15
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/mxf_dv25
@@ -0,0 +1,3 @@
+1871bd11947924116776201f24fd0adf *./tests/data/lavf/lavf.mxf_dv25
+3833389 ./tests/data/lavf/lavf.mxf_dv25
+./tests/data/lavf/lavf.mxf_dv25 CRC=0xbdaf7f52
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/mxf_dvcpro50 b/mythtv/external/FFmpeg/tests/ref/lavf/mxf_dvcpro50
new file mode 100644
index 00000000000..1d0cf799961
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/mxf_dvcpro50
@@ -0,0 +1,3 @@
+6c9cb62911ac16c3b55f0ad0b052c05b *./tests/data/lavf/lavf.mxf_dvcpro50
+7430189 ./tests/data/lavf/lavf.mxf_dvcpro50
+./tests/data/lavf/lavf.mxf_dvcpro50 CRC=0xe3bbe4b4
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/smjpeg b/mythtv/external/FFmpeg/tests/ref/lavf/smjpeg
index a2eeb975785..fb8c6542fac 100644
--- a/mythtv/external/FFmpeg/tests/ref/lavf/smjpeg
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/smjpeg
@@ -1,3 +1,3 @@
-a95982a2d390f4dcdc72a41d8920abb9 *./tests/data/lavf/lavf.smjpeg
-789551 ./tests/data/lavf/lavf.smjpeg
+3fe90213ac4f5275eb85ad0a4e4bdb44 *./tests/data/lavf/lavf.smjpeg
+728642 ./tests/data/lavf/lavf.smjpeg
 ./tests/data/lavf/lavf.smjpeg CRC=0x54bf6147
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/tta b/mythtv/external/FFmpeg/tests/ref/lavf/tta
index 745e8d21bd2..d86d097e3db 100644
--- a/mythtv/external/FFmpeg/tests/ref/lavf/tta
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/tta
@@ -1,3 +1,3 @@
-f2721d06704ac43d89fdd25835b43598 *./tests/data/lavf/lavf.tta
+d86c5cccb2554143d34d1786ab460a31 *./tests/data/lavf/lavf.tta
 43200 ./tests/data/lavf/lavf.tta
 ./tests/data/lavf/lavf.tta CRC=0x3a1da17e
diff --git a/mythtv/external/FFmpeg/tests/ref/lavf/wv b/mythtv/external/FFmpeg/tests/ref/lavf/wv
new file mode 100644
index 00000000000..323c5df6d5a
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/lavf/wv
@@ -0,0 +1,3 @@
+47d9a381d9c3f99b8b059f3b17f1dc11 *./tests/data/lavf/lavf.wv
+59560 ./tests/data/lavf/lavf.wv
+./tests/data/lavf/lavf.wv CRC=0x3a1da17e
diff --git a/mythtv/external/FFmpeg/tests/ref/seek/cache-pipe b/mythtv/external/FFmpeg/tests/ref/seek/cache-pipe
index b6a42e84d84..ebe5946601b 100644
--- a/mythtv/external/FFmpeg/tests/ref/seek/cache-pipe
+++ b/mythtv/external/FFmpeg/tests/ref/seek/cache-pipe
@@ -1,6 +1,6 @@
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st:-1 flags:0  ts:-1.000000
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st:-1 flags:1  ts: 1.894167
 ret: 0         st: 0 flags:1 dts: 1.880816 pts: 1.880816 pos:  31544 size:   418
 ret: 0         st: 0 flags:0  ts: 0.788334
@@ -18,7 +18,7 @@ ret: 0         st: 0 flags:1 dts: 2.168163 pts: 2.168163 pos:  36141 size:   418
 ret: 0         st:-1 flags:1  ts: 1.047503
 ret: 0         st: 0 flags:1 dts: 1.044898 pts: 1.044898 pos:  18169 size:   418
 ret: 0         st: 0 flags:0  ts:-0.058330
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st: 0 flags:1  ts: 2.835837
 ret: 0         st: 0 flags:1 dts: 2.821224 pts: 2.821224 pos:  46590 size:   418
 ret: 0         st:-1 flags:0  ts: 1.730004
@@ -26,7 +26,7 @@ ret: 0         st: 0 flags:1 dts: 1.750204 pts: 1.750204 pos:  29454 size:   418
 ret: 0         st:-1 flags:1  ts: 0.624171
 ret: 0         st: 0 flags:1 dts: 0.600816 pts: 0.600816 pos:  11064 size:   418
 ret: 0         st: 0 flags:0  ts:-0.481662
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st: 0 flags:1  ts: 2.412505
 ret: 0         st: 0 flags:1 dts: 2.403265 pts: 2.403265 pos:  39903 size:   418
 ret: 0         st:-1 flags:0  ts: 1.306672
@@ -34,7 +34,7 @@ ret: 0         st: 0 flags:1 dts: 1.332245 pts: 1.332245 pos:  22766 size:   418
 ret: 0         st:-1 flags:1  ts: 0.200839
 ret: 0         st: 0 flags:1 dts: 0.182857 pts: 0.182857 pos:   4376 size:   418
 ret: 0         st: 0 flags:0  ts:-0.904994
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st: 0 flags:1  ts: 1.989173
 ret: 0         st: 0 flags:1 dts: 1.985306 pts: 1.985306 pos:  33215 size:   418
 ret: 0         st:-1 flags:0  ts: 0.883340
diff --git a/mythtv/external/FFmpeg/tests/ref/seek/extra-mp3 b/mythtv/external/FFmpeg/tests/ref/seek/extra-mp3
index 981ac02ca8f..fdfb1a7c661 100644
--- a/mythtv/external/FFmpeg/tests/ref/seek/extra-mp3
+++ b/mythtv/external/FFmpeg/tests/ref/seek/extra-mp3
@@ -1,12 +1,12 @@
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st:-1 flags:0  ts:-1.000000
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st:-1 flags:1  ts: 1.894167
 ret: 0         st: 0 flags:1 dts: 1.880816 pts: 1.880816 pos:  31544 size:   418
 ret: 0         st: 0 flags:0  ts: 0.788334
 ret: 0         st: 0 flags:1 dts: 0.809796 pts: 0.809796 pos:  14407 size:   418
 ret: 0         st: 0 flags:1  ts:-0.317499
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st:-1 flags:0  ts: 2.576668
 ret: 0         st: 0 flags:1 dts: 2.586122 pts: 2.586122 pos:  42828 size:   418
 ret: 0         st:-1 flags:1  ts: 1.470835
@@ -14,13 +14,13 @@ ret: 0         st: 0 flags:1 dts: 1.462857 pts: 1.462857 pos:  24856 size:   418
 ret: 0         st: 0 flags:0  ts: 0.365002
 ret: 0         st: 0 flags:1 dts: 0.365714 pts: 0.365714 pos:   7302 size:   418
 ret: 0         st: 0 flags:1  ts:-0.740831
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st:-1 flags:0  ts: 2.153336
 ret: 0         st: 0 flags:1 dts: 2.168163 pts: 2.168163 pos:  36141 size:   418
 ret: 0         st:-1 flags:1  ts: 1.047503
 ret: 0         st: 0 flags:1 dts: 1.044898 pts: 1.044898 pos:  18169 size:   418
 ret: 0         st: 0 flags:0  ts:-0.058330
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st: 0 flags:1  ts: 2.835837
 ret: 0         st: 0 flags:1 dts: 2.821224 pts: 2.821224 pos:  46590 size:   418
 ret: 0         st:-1 flags:0  ts: 1.730004
@@ -28,7 +28,7 @@ ret: 0         st: 0 flags:1 dts: 1.750204 pts: 1.750204 pos:  29454 size:   418
 ret: 0         st:-1 flags:1  ts: 0.624171
 ret: 0         st: 0 flags:1 dts: 0.600816 pts: 0.600816 pos:  11064 size:   418
 ret: 0         st: 0 flags:0  ts:-0.481662
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st: 0 flags:1  ts: 2.412505
 ret: 0         st: 0 flags:1 dts: 2.403265 pts: 2.403265 pos:  39903 size:   418
 ret: 0         st:-1 flags:0  ts: 1.306672
@@ -36,13 +36,13 @@ ret: 0         st: 0 flags:1 dts: 1.332245 pts: 1.332245 pos:  22766 size:   418
 ret: 0         st:-1 flags:1  ts: 0.200839
 ret: 0         st: 0 flags:1 dts: 0.182857 pts: 0.182857 pos:   4376 size:   418
 ret: 0         st: 0 flags:0  ts:-0.904994
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st: 0 flags:1  ts: 1.989173
 ret: 0         st: 0 flags:1 dts: 1.985306 pts: 1.985306 pos:  33215 size:   418
 ret: 0         st:-1 flags:0  ts: 0.883340
 ret: 0         st: 0 flags:1 dts: 0.888163 pts: 0.888163 pos:  15661 size:   418
 ret: 0         st:-1 flags:1  ts:-0.222493
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
 ret: 0         st: 0 flags:0  ts: 2.671674
 ret: 0         st: 0 flags:1 dts: 2.690612 pts: 2.690612 pos:  44500 size:   418
 ret: 0         st: 0 flags:1  ts: 1.565841
@@ -50,4 +50,4 @@ ret: 0         st: 0 flags:1 dts: 1.567347 pts: 1.567347 pos:  26528 size:   418
 ret: 0         st:-1 flags:0  ts: 0.460008
 ret: 0         st: 0 flags:1 dts: 0.470204 pts: 0.470204 pos:   8974 size:   418
 ret: 0         st:-1 flags:1  ts:-0.645825
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   440
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   1451 size:   417
diff --git a/mythtv/external/FFmpeg/tests/ref/seek/extra-mp4 b/mythtv/external/FFmpeg/tests/ref/seek/extra-mp4
new file mode 100644
index 00000000000..c25544c0954
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/seek/extra-mp4
@@ -0,0 +1,134 @@
+ret: 0         st: 0 flags:1 dts:-0.033333 pts: 0.000000 pos:   1287 size:   183
+ret: 0         st: 0 flags:0 dts: 0.000000 pts: 0.033333 pos:   1470 size:    24
+ret: 0         st: 0 flags:0 dts: 0.033333 pts: 0.066667 pos:   1494 size:  6779
+ret: 0         st: 0 flags:0 dts: 0.066667 pts: 0.100000 pos:   8273 size: 11041
+ret: 0         st:-1 flags:0  ts:-1.000000
+ret: 0         st: 0 flags:1 dts:-0.033333 pts: 0.000000 pos:   1287 size:   183
+ret: 0         st: 0 flags:0 dts: 0.000000 pts: 0.033333 pos:   1470 size:    24
+ret: 0         st: 0 flags:0 dts: 0.033333 pts: 0.066667 pos:   1494 size:  6779
+ret: 0         st: 0 flags:0 dts: 0.066667 pts: 0.100000 pos:   8273 size: 11041
+ret: 0         st:-1 flags:1  ts: 101.894167
+ret: 0         st: 0 flags:1 dts: 101.300000 pts: 101.333333 pos:10982311 size: 67237
+ret: 0         st: 0 flags:0 dts: 101.333333 pts: 101.433333 pos:11049548 size:  3524
+ret: 0         st: 0 flags:0 dts: 101.366667 pts: 101.366667 pos:11053072 size:   562
+ret: 0         st: 0 flags:0 dts: 101.400000 pts: 101.400000 pos:11053634 size:   599
+ret: 0         st: 0 flags:0  ts: 24.788333
+ret: 0         st: 0 flags:1 dts: 25.300000 pts: 25.333333 pos:2607246 size: 40273
+ret: 0         st: 0 flags:0 dts: 25.333333 pts: 25.433333 pos:2647519 size:  2959
+ret: 0         st: 0 flags:0 dts: 25.366667 pts: 25.366667 pos:2650478 size:   197
+ret: 0         st: 0 flags:0 dts: 25.400000 pts: 25.400000 pos:2650675 size:   230
+ret: 0         st: 0 flags:1  ts: 127.682500
+ret: 0         st: 0 flags:1 dts: 126.633333 pts: 126.666667 pos:13359975 size: 68741
+ret: 0         st: 0 flags:0 dts: 126.666667 pts: 126.766667 pos:13428716 size:  2914
+ret: 0         st: 0 flags:0 dts: 126.700000 pts: 126.700000 pos:13431630 size:   781
+ret: 0         st: 0 flags:0 dts: 126.733333 pts: 126.733333 pos:13432411 size:   817
+ret: 0         st:-1 flags:0  ts: 50.576668
+ret: 0         st: 0 flags:1 dts: 50.600000 pts: 50.633333 pos:5858254 size: 67903
+ret: 0         st: 0 flags:0 dts: 50.633333 pts: 50.733333 pos:5926157 size:  1307
+ret: 0         st: 0 flags:0 dts: 50.666667 pts: 50.666667 pos:5927464 size:   150
+ret: 0         st: 0 flags:0 dts: 50.700000 pts: 50.700000 pos:5927614 size:   176
+ret: 0         st:-1 flags:1  ts: 153.470835
+ret: 0         st: 0 flags:1 dts: 153.466667 pts: 153.500000 pos:15867700 size: 96169
+ret: 0         st: 0 flags:0 dts: 153.500000 pts: 153.533333 pos:15963869 size:   785
+ret: 0         st: 0 flags:0 dts: 153.533333 pts: 153.633333 pos:15964654 size:  3135
+ret: 0         st: 0 flags:0 dts: 153.566667 pts: 153.566667 pos:15967789 size:   859
+ret: 0         st: 0 flags:0  ts: 76.365000
+ret: 0         st: 0 flags:1 dts: 77.833333 pts: 77.866667 pos:8659657 size: 41182
+ret: 0         st: 0 flags:0 dts: 77.866667 pts: 77.966667 pos:8700839 size:  4197
+ret: 0         st: 0 flags:0 dts: 77.900000 pts: 77.900000 pos:8705036 size:   653
+ret: 0         st: 0 flags:0 dts: 77.933333 pts: 77.933333 pos:8705689 size:   751
+ret: 0         st: 0 flags:1  ts:-0.740833
+ret: 0         st: 0 flags:1 dts:-0.033333 pts: 0.000000 pos:   1287 size:   183
+ret: 0         st: 0 flags:0 dts: 0.000000 pts: 0.033333 pos:   1470 size:    24
+ret: 0         st: 0 flags:0 dts: 0.033333 pts: 0.066667 pos:   1494 size:  6779
+ret: 0         st: 0 flags:0 dts: 0.066667 pts: 0.100000 pos:   8273 size: 11041
+ret: 0         st:-1 flags:0  ts: 102.153336
+ret: 0         st: 0 flags:1 dts: 104.066667 pts: 104.100000 pos:11116461 size:112929
+ret: 0         st: 0 flags:0 dts: 104.100000 pts: 104.133333 pos:11229390 size:   585
+ret: 0         st: 0 flags:0 dts: 104.133333 pts: 104.166667 pos:11229975 size:   797
+ret: 0         st: 0 flags:0 dts: 104.166667 pts: 104.200000 pos:11230772 size:   810
+ret: 0         st:-1 flags:1  ts: 25.047503
+ret: 0         st: 0 flags:1 dts: 20.233333 pts: 20.266667 pos:2223959 size: 51823
+ret: 0         st: 0 flags:0 dts: 20.266667 pts: 20.300000 pos:2275782 size:   488
+ret: 0         st: 0 flags:0 dts: 20.300000 pts: 20.400000 pos:2276270 size:   670
+ret: 0         st: 0 flags:0 dts: 20.333333 pts: 20.333333 pos:2276940 size:    84
+ret: 0         st: 0 flags:0  ts: 127.941667
+ret: 0         st: 0 flags:1 dts: 131.233333 pts: 131.266667 pos:13727953 size: 62229
+ret: 0         st: 0 flags:0 dts: 131.266667 pts: 131.366667 pos:13790182 size:  2349
+ret: 0         st: 0 flags:0 dts: 131.300000 pts: 131.300000 pos:13792531 size:   571
+ret: 0         st: 0 flags:0 dts: 131.333333 pts: 131.333333 pos:13793102 size:  1190
+ret: 0         st: 0 flags:1  ts: 50.835833
+ret: 0         st: 0 flags:1 dts: 50.600000 pts: 50.633333 pos:5858254 size: 67903
+ret: 0         st: 0 flags:0 dts: 50.633333 pts: 50.733333 pos:5926157 size:  1307
+ret: 0         st: 0 flags:0 dts: 50.666667 pts: 50.666667 pos:5927464 size:   150
+ret: 0         st: 0 flags:0 dts: 50.700000 pts: 50.700000 pos:5927614 size:   176
+ret: 0         st:-1 flags:0  ts: 153.730004
+ret: 0         st: 0 flags:1 dts: 157.033333 pts: 157.066667 pos:16225365 size: 82738
+ret: 0         st: 0 flags:0 dts: 157.066667 pts: 157.166667 pos:16308103 size:  2273
+ret: 0         st: 0 flags:0 dts: 157.100000 pts: 157.100000 pos:16310376 size:   350
+ret: 0         st: 0 flags:0 dts: 157.133333 pts: 157.133333 pos:16310726 size:   337
+ret: 0         st:-1 flags:1  ts: 76.624171
+ret: 0         st: 0 flags:1 dts: 75.966667 pts: 76.000000 pos:8520178 size: 94395
+ret: 0         st: 0 flags:0 dts: 76.000000 pts: 76.100000 pos:8614573 size:   483
+ret: 0         st: 0 flags:0 dts: 76.033333 pts: 76.033333 pos:8615056 size:    37
+ret: 0         st: 0 flags:0 dts: 76.066667 pts: 76.066667 pos:8615093 size:    56
+ret: 0         st: 0 flags:0  ts:-0.481667
+ret: 0         st: 0 flags:1 dts:-0.033333 pts: 0.000000 pos:   1287 size:   183
+ret: 0         st: 0 flags:0 dts: 0.000000 pts: 0.033333 pos:   1470 size:    24
+ret: 0         st: 0 flags:0 dts: 0.033333 pts: 0.066667 pos:   1494 size:  6779
+ret: 0         st: 0 flags:0 dts: 0.066667 pts: 0.100000 pos:   8273 size: 11041
+ret: 0         st: 0 flags:1  ts: 102.412500
+ret: 0         st: 0 flags:1 dts: 101.300000 pts: 101.333333 pos:10982311 size: 67237
+ret: 0         st: 0 flags:0 dts: 101.333333 pts: 101.433333 pos:11049548 size:  3524
+ret: 0         st: 0 flags:0 dts: 101.366667 pts: 101.366667 pos:11053072 size:   562
+ret: 0         st: 0 flags:0 dts: 101.400000 pts: 101.400000 pos:11053634 size:   599
+ret: 0         st:-1 flags:0  ts: 25.306672
+ret: 0         st: 0 flags:1 dts: 27.400000 pts: 27.433333 pos:2674605 size:127383
+ret: 0         st: 0 flags:0 dts: 27.433333 pts: 27.466667 pos:2801988 size:    68
+ret: 0         st: 0 flags:0 dts: 27.466667 pts: 27.500000 pos:2802268 size:  1754
+ret: 0         st: 0 flags:0 dts: 27.500000 pts: 27.533333 pos:2804022 size:  4071
+ret: 0         st:-1 flags:1  ts: 128.200839
+ret: 0         st: 0 flags:1 dts: 127.833333 pts: 127.866667 pos:13514072 size: 67382
+ret: 0         st: 0 flags:0 dts: 127.866667 pts: 127.966667 pos:13581454 size:  2936
+ret: 0         st: 0 flags:0 dts: 127.900000 pts: 127.900000 pos:13584390 size:   451
+ret: 0         st: 0 flags:0 dts: 127.933333 pts: 127.933333 pos:13584841 size:   537
+ret: 0         st: 0 flags:0  ts: 51.095011
+ret: 0         st: 0 flags:1 dts: 52.033333 pts: 52.066667 pos:6028050 size:115809
+ret: 0         st: 0 flags:0 dts: 52.066667 pts: 52.166667 pos:6143859 size:  1620
+ret: 0         st: 0 flags:0 dts: 52.100000 pts: 52.100000 pos:6145479 size:    92
+ret: 0         st: 0 flags:0 dts: 52.133333 pts: 52.133333 pos:6145571 size:   533
+ret: 0         st: 0 flags:1  ts: 153.989178
+ret: 0         st: 0 flags:1 dts: 153.466667 pts: 153.500000 pos:15867700 size: 96169
+ret: 0         st: 0 flags:0 dts: 153.500000 pts: 153.533333 pos:15963869 size:   785
+ret: 0         st: 0 flags:0 dts: 153.533333 pts: 153.633333 pos:15964654 size:  3135
+ret: 0         st: 0 flags:0 dts: 153.566667 pts: 153.566667 pos:15967789 size:   859
+ret: 0         st:-1 flags:0  ts: 76.883340
+ret: 0         st: 0 flags:1 dts: 77.833333 pts: 77.866667 pos:8659657 size: 41182
+ret: 0         st: 0 flags:0 dts: 77.866667 pts: 77.966667 pos:8700839 size:  4197
+ret: 0         st: 0 flags:0 dts: 77.900000 pts: 77.900000 pos:8705036 size:   653
+ret: 0         st: 0 flags:0 dts: 77.933333 pts: 77.933333 pos:8705689 size:   751
+ret: 0         st:-1 flags:1  ts:-0.222493
+ret: 0         st: 0 flags:1 dts:-0.033333 pts: 0.000000 pos:   1287 size:   183
+ret: 0         st: 0 flags:0 dts: 0.000000 pts: 0.033333 pos:   1470 size:    24
+ret: 0         st: 0 flags:0 dts: 0.033333 pts: 0.066667 pos:   1494 size:  6779
+ret: 0         st: 0 flags:0 dts: 0.066667 pts: 0.100000 pos:   8273 size: 11041
+ret: 0         st: 0 flags:0  ts: 102.671678
+ret: 0         st: 0 flags:1 dts: 104.066667 pts: 104.100000 pos:11116461 size:112929
+ret: 0         st: 0 flags:0 dts: 104.100000 pts: 104.133333 pos:11229390 size:   585
+ret: 0         st: 0 flags:0 dts: 104.133333 pts: 104.166667 pos:11229975 size:   797
+ret: 0         st: 0 flags:0 dts: 104.166667 pts: 104.200000 pos:11230772 size:   810
+ret: 0         st: 0 flags:1  ts: 25.565844
+ret: 0         st: 0 flags:1 dts: 25.300000 pts: 25.333333 pos:2607246 size: 40273
+ret: 0         st: 0 flags:0 dts: 25.333333 pts: 25.433333 pos:2647519 size:  2959
+ret: 0         st: 0 flags:0 dts: 25.366667 pts: 25.366667 pos:2650478 size:   197
+ret: 0         st: 0 flags:0 dts: 25.400000 pts: 25.400000 pos:2650675 size:   230
+ret: 0         st:-1 flags:0  ts: 128.460008
+ret: 0         st: 0 flags:1 dts: 131.233333 pts: 131.266667 pos:13727953 size: 62229
+ret: 0         st: 0 flags:0 dts: 131.266667 pts: 131.366667 pos:13790182 size:  2349
+ret: 0         st: 0 flags:0 dts: 131.300000 pts: 131.300000 pos:13792531 size:   571
+ret: 0         st: 0 flags:0 dts: 131.333333 pts: 131.333333 pos:13793102 size:  1190
+ret: 0         st:-1 flags:1  ts: 51.354175
+ret: 0         st: 0 flags:1 dts: 50.600000 pts: 50.633333 pos:5858254 size: 67903
+ret: 0         st: 0 flags:0 dts: 50.633333 pts: 50.733333 pos:5926157 size:  1307
+ret: 0         st: 0 flags:0 dts: 50.666667 pts: 50.666667 pos:5927464 size:   150
+ret: 0         st: 0 flags:0 dts: 50.700000 pts: 50.700000 pos:5927614 size:   176
diff --git a/mythtv/external/FFmpeg/tests/ref/seek/lavf-jpg b/mythtv/external/FFmpeg/tests/ref/seek/lavf-jpg
index 4f3a14ca84d..545f59da57c 100644
--- a/mythtv/external/FFmpeg/tests/ref/seek/lavf-jpg
+++ b/mythtv/external/FFmpeg/tests/ref/seek/lavf-jpg
@@ -1,4 +1,4 @@
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:     -1 size: 28070
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:     -1 size: 25641
 ret:-EINVAL    st:-1 flags:0  ts:-1.000000
 ret:-EINVAL    st:-1 flags:1  ts: 1.894167
 ret:-EINVAL    st: 0 flags:0  ts: 0.800000
@@ -6,7 +6,7 @@ ret:-EINVAL    st: 0 flags:1  ts:-0.320000
 ret:-EINVAL    st:-1 flags:0  ts: 2.576668
 ret:-EINVAL    st:-1 flags:1  ts: 1.470835
 ret: 0         st: 0 flags:0  ts: 0.360000
-ret: 0         st: 0 flags:1 dts: 0.360000 pts: 0.360000 pos:     -1 size: 27771
+ret: 0         st: 0 flags:1 dts: 0.360000 pts: 0.360000 pos:     -1 size: 25316
 ret:-EINVAL    st: 0 flags:1  ts:-0.760000
 ret:-EINVAL    st:-1 flags:0  ts: 2.153336
 ret:-EINVAL    st:-1 flags:1  ts: 1.047503
@@ -18,7 +18,7 @@ ret:-EINVAL    st: 0 flags:0  ts:-0.480000
 ret:-EINVAL    st: 0 flags:1  ts: 2.400000
 ret:-EINVAL    st:-1 flags:0  ts: 1.306672
 ret: 0         st:-1 flags:1  ts: 0.200839
-ret: 0         st: 0 flags:1 dts: 0.200000 pts: 0.200000 pos:     -1 size: 28197
+ret: 0         st: 0 flags:1 dts: 0.200000 pts: 0.200000 pos:     -1 size: 25788
 ret:-EINVAL    st: 0 flags:0  ts:-0.920000
 ret:-EINVAL    st: 0 flags:1  ts: 2.000000
 ret:-EINVAL    st:-1 flags:0  ts: 0.883340
@@ -26,5 +26,5 @@ ret:-EINVAL    st:-1 flags:1  ts:-0.222493
 ret:-EINVAL    st: 0 flags:0  ts: 2.680000
 ret:-EINVAL    st: 0 flags:1  ts: 1.560000
 ret: 0         st:-1 flags:0  ts: 0.460008
-ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos:     -1 size: 27950
+ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos:     -1 size: 25487
 ret:-EINVAL    st:-1 flags:1  ts:-0.645825
diff --git a/mythtv/external/FFmpeg/tests/ref/seek/lavf-mxf_dv25 b/mythtv/external/FFmpeg/tests/ref/seek/lavf-mxf_dv25
new file mode 100644
index 00000000000..42b3bbdfce9
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/seek/lavf-mxf_dv25
@@ -0,0 +1,53 @@
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:144000
+ret: 0         st:-1 flags:0  ts:-1.000000
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:144000
+ret: 0         st:-1 flags:1  ts: 1.894167
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:3680256 size:144000
+ret: 0         st: 0 flags:0  ts: 0.800000
+ret: 0         st: 0 flags:1 dts: 0.800000 pts: 0.800000 pos:3067904 size:144000
+ret: 0         st: 0 flags:1  ts:-0.320000
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:144000
+ret: 0         st: 1 flags:0  ts: 2.576667
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:3680256 size:144000
+ret: 0         st: 1 flags:1  ts: 1.470833
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:3680256 size:144000
+ret: 0         st:-1 flags:0  ts: 0.365002
+ret: 0         st: 0 flags:1 dts: 0.360000 pts: 0.360000 pos:1383936 size:144000
+ret: 0         st:-1 flags:1  ts:-0.740831
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:144000
+ret: 0         st: 0 flags:0  ts: 2.160000
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:3680256 size:144000
+ret: 0         st: 0 flags:1  ts: 1.040000
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:3680256 size:144000
+ret: 0         st: 1 flags:0  ts:-0.058333
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:144000
+ret: 0         st: 1 flags:1  ts: 2.835833
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:3680256 size:144000
+ret: 0         st:-1 flags:0  ts: 1.730004
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:3680256 size:144000
+ret: 0         st:-1 flags:1  ts: 0.624171
+ret: 0         st: 0 flags:1 dts: 0.640000 pts: 0.640000 pos:2455552 size:144000
+ret: 0         st: 0 flags:0  ts:-0.480000
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:144000
+ret: 0         st: 0 flags:1  ts: 2.400000
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:3680256 size:144000
+ret: 0         st: 1 flags:0  ts: 1.306667
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:3680256 size:144000
+ret: 0         st: 1 flags:1  ts: 0.200833
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos: 771584 size:144000
+ret: 0         st:-1 flags:0  ts:-0.904994
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:144000
+ret: 0         st:-1 flags:1  ts: 1.989173
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:3680256 size:144000
+ret: 0         st: 0 flags:0  ts: 0.880000
+ret: 0         st: 0 flags:1 dts: 0.880000 pts: 0.880000 pos:3374080 size:144000
+ret: 0         st: 0 flags:1  ts:-0.240000
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:144000
+ret: 0         st: 1 flags:0  ts: 2.671667
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:3680256 size:144000
+ret: 0         st: 1 flags:1  ts: 1.565833
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:3680256 size:144000
+ret: 0         st:-1 flags:0  ts: 0.460008
+ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos:1843200 size:144000
+ret: 0         st:-1 flags:1  ts:-0.645825
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:144000
diff --git a/mythtv/external/FFmpeg/tests/ref/seek/lavf-mxf_dvcpro50 b/mythtv/external/FFmpeg/tests/ref/seek/lavf-mxf_dvcpro50
new file mode 100644
index 00000000000..c3d9d3afd72
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/seek/lavf-mxf_dvcpro50
@@ -0,0 +1,53 @@
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:288000
+ret: 0         st:-1 flags:0  ts:-1.000000
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:288000
+ret: 0         st:-1 flags:1  ts: 1.894167
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:7133184 size:288000
+ret: 0         st: 0 flags:0  ts: 0.800000
+ret: 0         st: 0 flags:1 dts: 0.800000 pts: 0.800000 pos:5945344 size:288000
+ret: 0         st: 0 flags:1  ts:-0.320000
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:288000
+ret: 0         st: 1 flags:0  ts: 2.576667
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:7133184 size:288000
+ret: 0         st: 1 flags:1  ts: 1.470833
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:7133184 size:288000
+ret: 0         st:-1 flags:0  ts: 0.365002
+ret: 0         st: 0 flags:1 dts: 0.360000 pts: 0.360000 pos:2678784 size:288000
+ret: 0         st:-1 flags:1  ts:-0.740831
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:288000
+ret: 0         st: 0 flags:0  ts: 2.160000
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:7133184 size:288000
+ret: 0         st: 0 flags:1  ts: 1.040000
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:7133184 size:288000
+ret: 0         st: 1 flags:0  ts:-0.058333
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:288000
+ret: 0         st: 1 flags:1  ts: 2.835833
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:7133184 size:288000
+ret: 0         st:-1 flags:0  ts: 1.730004
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:7133184 size:288000
+ret: 0         st:-1 flags:1  ts: 0.624171
+ret: 0         st: 0 flags:1 dts: 0.640000 pts: 0.640000 pos:4757504 size:288000
+ret: 0         st: 0 flags:0  ts:-0.480000
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:288000
+ret: 0         st: 0 flags:1  ts: 2.400000
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:7133184 size:288000
+ret: 0         st: 1 flags:0  ts: 1.306667
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:7133184 size:288000
+ret: 0         st: 1 flags:1  ts: 0.200833
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:1490944 size:288000
+ret: 0         st:-1 flags:0  ts:-0.904994
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:288000
+ret: 0         st:-1 flags:1  ts: 1.989173
+ret: 0         st: 0 flags:1 dts: 0.960000 pts: 0.960000 pos:7133184 size:288000
+ret: 0         st: 0 flags:0  ts: 0.880000
+ret: 0         st: 0 flags:1 dts: 0.880000 pts: 0.880000 pos:6539264 size:288000
+ret: 0         st: 0 flags:1  ts:-0.240000
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:288000
+ret: 0         st: 1 flags:0  ts: 2.671667
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:7133184 size:288000
+ret: 0         st: 1 flags:1  ts: 1.565833
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:7133184 size:288000
+ret: 0         st:-1 flags:0  ts: 0.460008
+ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos:3569664 size:288000
+ret: 0         st:-1 flags:1  ts:-0.645825
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   6144 size:288000
diff --git a/mythtv/external/FFmpeg/tests/ref/seek/lavf-ts b/mythtv/external/FFmpeg/tests/ref/seek/lavf-ts
index f9808242f07..e57651ef9c6 100644
--- a/mythtv/external/FFmpeg/tests/ref/seek/lavf-ts
+++ b/mythtv/external/FFmpeg/tests/ref/seek/lavf-ts
@@ -1,53 +1,53 @@
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st:-1 flags:0  ts:-1.000000
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st:-1 flags:1  ts: 1.894167
-ret: 0         st: 0 flags:1 dts: 1.880000 pts: 1.920000 pos: 189692 size: 24800
+ret: 0         st: 0 flags:1 dts: 1.880000 pts: 1.920000 pos: 189692 size: 24786
 ret: 0         st: 0 flags:0  ts: 0.788333
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st: 0 flags:1  ts:-0.317500
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st: 1 flags:0  ts: 2.576667
-ret: 0         st: 1 flags:1 dts: 2.160522 pts: 2.160522 pos: 404576 size:   223
+ret: 0         st: 1 flags:1 dts: 2.160522 pts: 2.160522 pos: 404576 size:   209
 ret: 0         st: 1 flags:1  ts: 1.470833
-ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   222
+ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   208
 ret: 0         st:-1 flags:0  ts: 0.365002
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st:-1 flags:1  ts:-0.740831
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st: 0 flags:0  ts: 2.153333
-ret: 0         st: 1 flags:1 dts: 1.794811 pts: 1.794811 pos: 322608 size:   223
+ret: 0         st: 1 flags:1 dts: 1.794811 pts: 1.794811 pos: 322608 size:   209
 ret: 0         st: 0 flags:1  ts: 1.047500
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st: 1 flags:0  ts:-0.058333
-ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   222
+ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   208
 ret: 0         st: 1 flags:1  ts: 2.835833
-ret: 0         st: 1 flags:1 dts: 2.160522 pts: 2.160522 pos: 404576 size:   223
+ret: 0         st: 1 flags:1 dts: 2.160522 pts: 2.160522 pos: 404576 size:   209
 ret: 0         st:-1 flags:0  ts: 1.730004
-ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   222
+ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   208
 ret: 0         st:-1 flags:1  ts: 0.624171
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st: 0 flags:0  ts:-0.481667
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st: 0 flags:1  ts: 2.412500
-ret: 0         st: 1 flags:1 dts: 2.160522 pts: 2.160522 pos: 404576 size:   223
+ret: 0         st: 1 flags:1 dts: 2.160522 pts: 2.160522 pos: 404576 size:   209
 ret: 0         st: 1 flags:0  ts: 1.306667
-ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   222
+ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   208
 ret: 0         st: 1 flags:1  ts: 0.200844
-ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   222
+ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   208
 ret: 0         st:-1 flags:0  ts:-0.904994
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st:-1 flags:1  ts: 1.989173
-ret: 0         st: 0 flags:0 dts: 1.960000 pts: 2.000000 pos: 235000 size: 15033
+ret: 0         st: 0 flags:0 dts: 1.960000 pts: 2.000000 pos: 235000 size: 15019
 ret: 0         st: 0 flags:0  ts: 0.883344
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st: 0 flags:1  ts:-0.222489
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st: 1 flags:0  ts: 2.671678
-ret: 0         st: 1 flags:1 dts: 2.160522 pts: 2.160522 pos: 404576 size:   223
+ret: 0         st: 1 flags:1 dts: 2.160522 pts: 2.160522 pos: 404576 size:   209
 ret: 0         st: 1 flags:1  ts: 1.565844
-ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   222
+ret: 0         st: 1 flags:1 dts: 1.429089 pts: 1.429089 pos: 159988 size:   208
 ret: 0         st:-1 flags:0  ts: 0.460008
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
 ret: 0         st:-1 flags:1  ts:-0.645825
-ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24815
+ret: 0         st: 0 flags:1 dts: 1.400000 pts: 1.440000 pos:    564 size: 24801
diff --git a/mythtv/external/FFmpeg/tests/ref/seek/mkv-codec-delay b/mythtv/external/FFmpeg/tests/ref/seek/mkv-codec-delay
index 9d4582c139e..04561eb8765 100644
--- a/mythtv/external/FFmpeg/tests/ref/seek/mkv-codec-delay
+++ b/mythtv/external/FFmpeg/tests/ref/seek/mkv-codec-delay
@@ -2,46 +2,46 @@ ret: 0         st: 0 flags:1 dts:-0.007000 pts:-0.007000 pos:    748 size:   320
 ret: 0         st:-1 flags:0  ts:-1.000000
 ret: 0         st: 0 flags:1 dts:-0.007000 pts:-0.007000 pos:    748 size:   320
 ret: 0         st:-1 flags:1  ts: 1.894167
-ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   291
+ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   268
 ret: 0         st: 0 flags:0  ts: 0.788000
 ret: 0         st: 0 flags:1 dts: 0.794000 pts: 0.794000 pos:   7358 size:   154
 ret: 0         st: 0 flags:1  ts:-0.317000
 ret: 0         st: 0 flags:1 dts:-0.007000 pts:-0.007000 pos:    748 size:   320
 ret:-1         st:-1 flags:0  ts: 2.576668
 ret: 0         st:-1 flags:1  ts: 1.470835
-ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   291
+ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   268
 ret: 0         st: 0 flags:0  ts: 0.365000
 ret: 0         st: 0 flags:1 dts: 0.374000 pts: 0.374000 pos:   3963 size:   150
 ret: 0         st: 0 flags:1  ts:-0.741000
 ret: 0         st: 0 flags:1 dts:-0.007000 pts:-0.007000 pos:    748 size:   320
 ret:-1         st:-1 flags:0  ts: 2.153336
 ret: 0         st:-1 flags:1  ts: 1.047503
-ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   291
+ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   268
 ret: 0         st: 0 flags:0  ts:-0.058000
 ret: 0         st: 0 flags:1 dts:-0.007000 pts:-0.007000 pos:    748 size:   320
 ret: 0         st: 0 flags:1  ts: 2.836000
-ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   291
+ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   268
 ret:-1         st:-1 flags:0  ts: 1.730004
 ret: 0         st:-1 flags:1  ts: 0.624171
 ret: 0         st: 0 flags:1 dts: 0.614000 pts: 0.614000 pos:   5903 size:   159
 ret: 0         st: 0 flags:0  ts:-0.482000
 ret: 0         st: 0 flags:1 dts:-0.007000 pts:-0.007000 pos:    748 size:   320
 ret: 0         st: 0 flags:1  ts: 2.413000
-ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   291
+ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   268
 ret:-1         st:-1 flags:0  ts: 1.306672
 ret: 0         st:-1 flags:1  ts: 0.200839
 ret: 0         st: 0 flags:1 dts: 0.194000 pts: 0.194000 pos:   2512 size:   159
 ret: 0         st: 0 flags:0  ts:-0.905000
 ret: 0         st: 0 flags:1 dts:-0.007000 pts:-0.007000 pos:    748 size:   320
 ret: 0         st: 0 flags:1  ts: 1.989000
-ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   291
+ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   268
 ret: 0         st:-1 flags:0  ts: 0.883340
 ret: 0         st: 0 flags:1 dts: 0.894000 pts: 0.894000 pos:   8154 size:   155
 ret: 0         st:-1 flags:1  ts:-0.222493
 ret: 0         st: 0 flags:1 dts:-0.007000 pts:-0.007000 pos:    748 size:   320
 ret:-1         st: 0 flags:0  ts: 2.672000
 ret: 0         st: 0 flags:1  ts: 1.566000
-ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   291
+ret: 0         st: 0 flags:1 dts: 1.014000 pts: 1.014000 pos:   9306 size:   268
 ret: 0         st:-1 flags:0  ts: 0.460008
 ret: 0         st: 0 flags:1 dts: 0.474000 pts: 0.474000 pos:   4768 size:   153
 ret: 0         st:-1 flags:1  ts:-0.645825
diff --git a/mythtv/external/FFmpeg/tests/ref/seek/vsynth_lena-mjpeg b/mythtv/external/FFmpeg/tests/ref/seek/vsynth_lena-mjpeg
index 08cbd88eb9a..71f798e9296 100644
--- a/mythtv/external/FFmpeg/tests/ref/seek/vsynth_lena-mjpeg
+++ b/mythtv/external/FFmpeg/tests/ref/seek/vsynth_lena-mjpeg
@@ -1,46 +1,46 @@
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size: 12096
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size: 11209
 ret: 0         st:-1 flags:0  ts:-1.000000
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size: 12096
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size: 11209
 ret: 0         st:-1 flags:1  ts: 1.894167
-ret: 0         st: 0 flags:1 dts: 1.880000 pts: 1.880000 pos: 627818 size: 14806
+ret: 0         st: 0 flags:1 dts: 1.880000 pts: 1.880000 pos: 592412 size: 14066
 ret: 0         st: 0 flags:0  ts: 0.800000
-ret: 0         st: 0 flags:1 dts: 0.800000 pts: 0.800000 pos: 247502 size: 12959
+ret: 0         st: 0 flags:1 dts: 0.800000 pts: 0.800000 pos: 232652 size: 12269
 ret:-1         st: 0 flags:1  ts:-0.320000
 ret:-1         st:-1 flags:0  ts: 2.576668
 ret: 0         st:-1 flags:1  ts: 1.470835
-ret: 0         st: 0 flags:1 dts: 1.480000 pts: 1.480000 pos: 480740 size: 14519
+ret: 0         st: 0 flags:1 dts: 1.480000 pts: 1.480000 pos: 453104 size: 13735
 ret: 0         st: 0 flags:0  ts: 0.360000
-ret: 0         st: 0 flags:1 dts: 0.360000 pts: 0.360000 pos: 111000 size: 11924
+ret: 0         st: 0 flags:1 dts: 0.360000 pts: 0.360000 pos: 104118 size: 11213
 ret:-1         st: 0 flags:1  ts:-0.760000
 ret:-1         st:-1 flags:0  ts: 2.153336
 ret: 0         st:-1 flags:1  ts: 1.047503
-ret: 0         st: 0 flags:1 dts: 1.040000 pts: 1.040000 pos: 326684 size: 13491
+ret: 0         st: 0 flags:1 dts: 1.040000 pts: 1.040000 pos: 307404 size: 12723
 ret: 0         st: 0 flags:0  ts:-0.040000
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size: 12096
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size: 11209
 ret: 0         st: 0 flags:1  ts: 2.840000
-ret: 0         st: 0 flags:1 dts: 1.960000 pts: 1.960000 pos: 657472 size: 14897
+ret: 0         st: 0 flags:1 dts: 1.960000 pts: 1.960000 pos: 620564 size: 14125
 ret: 0         st:-1 flags:0  ts: 1.730004
-ret: 0         st: 0 flags:1 dts: 1.720000 pts: 1.720000 pos: 568610 size: 14751
+ret: 0         st: 0 flags:1 dts: 1.720000 pts: 1.720000 pos: 536264 size: 13966
 ret: 0         st:-1 flags:1  ts: 0.624171
-ret: 0         st: 0 flags:1 dts: 0.640000 pts: 0.640000 pos: 196424 size: 12720
+ret: 0         st: 0 flags:1 dts: 0.640000 pts: 0.640000 pos: 184478 size: 11981
 ret: 0         st: 0 flags:0  ts:-0.480000
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size: 12096
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size: 11209
 ret: 0         st: 0 flags:1  ts: 2.400000
-ret: 0         st: 0 flags:1 dts: 1.960000 pts: 1.960000 pos: 657472 size: 14897
+ret: 0         st: 0 flags:1 dts: 1.960000 pts: 1.960000 pos: 620564 size: 14125
 ret: 0         st:-1 flags:0  ts: 1.306672
-ret: 0         st: 0 flags:1 dts: 1.320000 pts: 1.320000 pos: 423474 size: 14114
+ret: 0         st: 0 flags:1 dts: 1.320000 pts: 1.320000 pos: 398934 size: 13340
 ret: 0         st:-1 flags:1  ts: 0.200839
-ret: 0         st: 0 flags:1 dts: 0.200000 pts: 0.200000 pos:  63866 size: 11715
+ret: 0         st: 0 flags:1 dts: 0.200000 pts: 0.200000 pos:  59904 size: 10972
 ret: 0         st: 0 flags:0  ts:-0.920000
-ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size: 12096
+ret: 0         st: 0 flags:1 dts: 0.000000 pts: 0.000000 pos:   5652 size: 11209
 ret: 0         st: 0 flags:1  ts: 2.000000
-ret: 0         st: 0 flags:1 dts: 1.960000 pts: 1.960000 pos: 657472 size: 14897
+ret: 0         st: 0 flags:1 dts: 1.960000 pts: 1.960000 pos: 620564 size: 14125
 ret: 0         st:-1 flags:0  ts: 0.883340
-ret: 0         st: 0 flags:1 dts: 0.880000 pts: 0.880000 pos: 273516 size: 13122
+ret: 0         st: 0 flags:1 dts: 0.880000 pts: 0.880000 pos: 257220 size: 12407
 ret:-1         st:-1 flags:1  ts:-0.222493
 ret:-1         st: 0 flags:0  ts: 2.680000
 ret: 0         st: 0 flags:1  ts: 1.560000
-ret: 0         st: 0 flags:1 dts: 1.560000 pts: 1.560000 pos: 509896 size: 14594
+ret: 0         st: 0 flags:1 dts: 1.560000 pts: 1.560000 pos: 480710 size: 13831
 ret: 0         st:-1 flags:0  ts: 0.460008
-ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos: 146954 size: 12173
+ret: 0         st: 0 flags:1 dts: 0.480000 pts: 0.480000 pos: 137920 size: 11458
 ret:-1         st:-1 flags:1  ts:-0.645825
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-bpp1 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-bpp1
index af1fb0ecd4c..b647ba0a140 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-bpp1
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-bpp1
@@ -1,4 +1,4 @@
-a0b35707a9aa7144e3e1c70c1d01f4ce *tests/data/fate/vsynth1-bpp1.avi
+1c78e77c971b1ce31f229c6fc23d0902 *tests/data/fate/vsynth1-bpp1.avi
 640460 tests/data/fate/vsynth1-bpp1.avi
 cd1e1448d9895561347ceb66d0add34d *tests/data/fate/vsynth1-bpp1.out.rawvideo
 stddev:   84.48 PSNR:  9.60 MAXDIFF:  218 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-bpp15 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-bpp15
index 855383810eb..d687b963d69 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-bpp15
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-bpp15
@@ -1,4 +1,4 @@
-dc37d1db0429f44000a03a60862751cd *tests/data/fate/vsynth1-bpp15.avi
+6147f5f235657fa9ced6ec6146be6ff0 *tests/data/fate/vsynth1-bpp15.avi
 10144452 tests/data/fate/vsynth1-bpp15.avi
 3aee2d6e82a9507d7f01844c04d2b57b *tests/data/fate/vsynth1-bpp15.out.rawvideo
 stddev:   38.44 PSNR: 16.43 MAXDIFF:  159 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dnxhd-720p-hr-lb b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dnxhd-720p-hr-lb
index 3490d4aeef2..27e593120a0 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dnxhd-720p-hr-lb
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dnxhd-720p-hr-lb
@@ -1,4 +1,4 @@
 08cbfe9b9f671cdb9dddc9307121d107 *tests/data/fate/vsynth1-dnxhd-720p-hr-lb.dnxhd
 409600 tests/data/fate/vsynth1-dnxhd-720p-hr-lb.dnxhd
-22eb87f0f8a50278355006fef70073a9 *tests/data/fate/vsynth1-dnxhd-720p-hr-lb.out.rawvideo
-stddev:    7.49 PSNR: 30.63 MAXDIFF:   64 bytes:  7603200/   608256
+77e510e3538313b1cbafb86ed248d2df *tests/data/fate/vsynth1-dnxhd-720p-hr-lb.out.rawvideo
+stddev:    7.50 PSNR: 30.62 MAXDIFF:   64 bytes:  7603200/   760320
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv
index 6237b078c5a..ea357b77234 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv
@@ -1,4 +1,4 @@
-4d572f758b55a1756adf9f54132f3b9e *tests/data/fate/vsynth1-dv.dv
+4246668d61439617101d051d7a995108 *tests/data/fate/vsynth1-dv.dv
 7200000 tests/data/fate/vsynth1-dv.dv
-1cda5a62c3a2f17cc7d5b4cddccf2524 *tests/data/fate/vsynth1-dv.out.rawvideo
+d52e7a9eac459ade9561d0b89bba58e7 *tests/data/fate/vsynth1-dv.out.rawvideo
 stddev:    6.90 PSNR: 31.34 MAXDIFF:   76 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv-411 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv-411
index 48e01a14034..ec88d67ece0 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv-411
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv-411
@@ -1,4 +1,4 @@
-f179899efba432c6f01149c36c709092 *tests/data/fate/vsynth1-dv-411.dv
+df067afe65f1712d9e8efa7117aab6ea *tests/data/fate/vsynth1-dv-411.dv
 7200000 tests/data/fate/vsynth1-dv-411.dv
-48904744fabbbc3421a762f615ef6456 *tests/data/fate/vsynth1-dv-411.out.rawvideo
-stddev:    9.44 PSNR: 28.62 MAXDIFF:   84 bytes:  7603200/  7603200
+ed493bad827dc903188fce8d3b597fcb *tests/data/fate/vsynth1-dv-411.out.rawvideo
+stddev:    9.45 PSNR: 28.62 MAXDIFF:   84 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv-50 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv-50
index d5da88d78c0..4a2ff001104 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv-50
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-dv-50
@@ -1,4 +1,4 @@
-a193c5f92bf6e74c604e759d5f4f0f94 *tests/data/fate/vsynth1-dv-50.dv
+adb1df1a65cecab225677003a5de9f28 *tests/data/fate/vsynth1-dv-50.dv
 14400000 tests/data/fate/vsynth1-dv-50.dv
-41c4df5f2d876fcd5245643b9ded6711 *tests/data/fate/vsynth1-dv-50.out.rawvideo
-stddev:    1.72 PSNR: 43.38 MAXDIFF:   29 bytes:  7603200/  7603200
+4ab1f5b7aad15fab9e3c1ea5b96da39b *tests/data/fate/vsynth1-dv-50.out.rawvideo
+stddev:    1.72 PSNR: 43.37 MAXDIFF:   29 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg
index 11de0207f61..aa441d312af 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg
@@ -1,4 +1,4 @@
-9ff18b19d12bb9bb2ed434a79f212888 *tests/data/fate/vsynth1-mjpeg.avi
-1515906 tests/data/fate/vsynth1-mjpeg.avi
+63ea9bd494e16bad8f3a0c8dbb3dc11e *tests/data/fate/vsynth1-mjpeg.avi
+1391380 tests/data/fate/vsynth1-mjpeg.avi
 9a3b8169c251d19044f7087a95458c55 *tests/data/fate/vsynth1-mjpeg.out.rawvideo
 stddev:    7.87 PSNR: 30.21 MAXDIFF:   63 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-422 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-422
index bd760a1c8de..dda3928a4b9 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-422
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-422
@@ -1,4 +1,4 @@
-3b19da06ffe23cb804bca7a9a86eb3d5 *tests/data/fate/vsynth1-mjpeg-422.avi
-1756304 tests/data/fate/vsynth1-mjpeg-422.avi
+82d8874bfe13f56ec466b206a08a4402 *tests/data/fate/vsynth1-mjpeg-422.avi
+1611832 tests/data/fate/vsynth1-mjpeg-422.avi
 c35eea486c6d72050f4848eab64032b5 *tests/data/fate/vsynth1-mjpeg-422.out.rawvideo
 stddev:    7.45 PSNR: 30.69 MAXDIFF:   63 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-444 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-444
index 42a9be32781..66a0efcf95a 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-444
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-444
@@ -1,4 +1,4 @@
-9591b754ca151f3802738840fa5c26c0 *tests/data/fate/vsynth1-mjpeg-444.avi
-1989784 tests/data/fate/vsynth1-mjpeg-444.avi
+2dd741cbee9b3499826beca7c7d3b8dc *tests/data/fate/vsynth1-mjpeg-444.avi
+1831614 tests/data/fate/vsynth1-mjpeg-444.avi
 313a4a76af13d5879ea4910107b7ea74 *tests/data/fate/vsynth1-mjpeg-444.out.rawvideo
 stddev:    7.37 PSNR: 30.77 MAXDIFF:   63 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-huffman b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-huffman
new file mode 100644
index 00000000000..e8c3f0fb636
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-huffman
@@ -0,0 +1,4 @@
+63ea9bd494e16bad8f3a0c8dbb3dc11e *tests/data/fate/vsynth1-mjpeg-huffman.avi
+1391380 tests/data/fate/vsynth1-mjpeg-huffman.avi
+9a3b8169c251d19044f7087a95458c55 *tests/data/fate/vsynth1-mjpeg-huffman.out.rawvideo
+stddev:    7.87 PSNR: 30.21 MAXDIFF:   63 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-trell b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-trell
index b97efcbf749..cf2a7ff16e8 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-trell
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-trell
@@ -1,4 +1,4 @@
-03d14b3db6232f46c0d931477801a7a6 *tests/data/fate/vsynth1-mjpeg-trell.avi
-1454308 tests/data/fate/vsynth1-mjpeg-trell.avi
-218d4dc8086fdef15d5382e6ba97df0b *tests/data/fate/vsynth1-mjpeg-trell.out.rawvideo
-stddev:    7.71 PSNR: 30.39 MAXDIFF:   62 bytes:  7603200/  7603200
+d9410fa80c07edbd2a2b44ceb06086ca *tests/data/fate/vsynth1-mjpeg-trell.avi
+1360456 tests/data/fate/vsynth1-mjpeg-trell.avi
+0266b223bdd7928426a951164bb4a366 *tests/data/fate/vsynth1-mjpeg-trell.out.rawvideo
+stddev:    7.68 PSNR: 30.42 MAXDIFF:   62 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-trell-huffman b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-trell-huffman
new file mode 100644
index 00000000000..20ce783a6b2
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-mjpeg-trell-huffman
@@ -0,0 +1,4 @@
+d9410fa80c07edbd2a2b44ceb06086ca *tests/data/fate/vsynth1-mjpeg-trell-huffman.avi
+1360456 tests/data/fate/vsynth1-mjpeg-trell-huffman.avi
+0266b223bdd7928426a951164bb4a366 *tests/data/fate/vsynth1-mjpeg-trell-huffman.out.rawvideo
+stddev:    7.68 PSNR: 30.42 MAXDIFF:   62 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-r210 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-r210
index e25b1de6d26..825e1d47896 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-r210
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-r210
@@ -1,4 +1,4 @@
-fd2bb8b3d3e47f5ea7769443324ee0ae *tests/data/fate/vsynth1-r210.avi
+1ea72f280b110ed65fc535c3438d27f9 *tests/data/fate/vsynth1-r210.avi
 22125252 tests/data/fate/vsynth1-r210.avi
 ecaafa9eec11b5e1453a63ed6d194eed *tests/data/fate/vsynth1-r210.out.rawvideo
 stddev:    3.23 PSNR: 37.94 MAXDIFF:   48 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-rgb b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-rgb
index 0a3947c7ebc..6d9629b5e9b 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-rgb
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-rgb
@@ -1,4 +1,4 @@
-c8a4b8648436e73ced7fe32f6f65a1b3 *tests/data/fate/vsynth1-rgb.avi
+9d2bd1fa569a803c41b5dc5dd03f088e *tests/data/fate/vsynth1-rgb.avi
 15213252 tests/data/fate/vsynth1-rgb.avi
 93695a27c24a61105076ca7b1f010bbd *tests/data/fate/vsynth1-rgb.out.rawvideo
 stddev:    3.42 PSNR: 37.44 MAXDIFF:   48 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v210 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v210
index 388e8b66886..1b69da4e9f1 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v210
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v210
@@ -1,4 +1,4 @@
-0712d60b3a00cf2d5a7e39aa21e2547a *tests/data/fate/vsynth1-v210.avi
+767471c71d60daf46ca3a758771c4f8e *tests/data/fate/vsynth1-v210.avi
 14752452 tests/data/fate/vsynth1-v210.avi
 2ba7f4ca302f3c4147860b9dfb12b6e4 *tests/data/fate/vsynth1-v210.out.rawvideo
 stddev:    1.84 PSNR: 42.81 MAXDIFF:   29 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v210-10 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v210-10
index 4621b9d69ad..f459cfa8e18 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v210-10
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v210-10
@@ -1,4 +1,4 @@
-230bbd31c82d4fbb92d5ea2ac591ded5 *tests/data/fate/vsynth1-v210-10.avi
+9269ce2a5294a4c9a8346328d06b23af *tests/data/fate/vsynth1-v210-10.avi
 14752452 tests/data/fate/vsynth1-v210-10.avi
 50973792d3f1abe04a51ee0121f077f2 *tests/data/fate/vsynth1-v210-10.out.rawvideo
 stddev:    1.85 PSNR: 42.78 MAXDIFF:   29 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v308 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v308
index 9eb29110065..162624e2865 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v308
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v308
@@ -1,4 +1,4 @@
-58ea26d3060f9d47cf95056ed9361c90 *tests/data/fate/vsynth1-v308.avi
+5d868b73c554a9a2422d6c8a18ce9c02 *tests/data/fate/vsynth1-v308.avi
 15213252 tests/data/fate/vsynth1-v308.avi
 10fb42f1abf40a289c3edafc0390482c *tests/data/fate/vsynth1-v308.out.rawvideo
 stddev:    2.67 PSNR: 39.60 MAXDIFF:   43 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v408 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v408
index bf16cbd489a..5d5f816fc09 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v408
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-v408
@@ -1,4 +1,4 @@
-4ac68e91ac25bc422abb3febe86a4acd *tests/data/fate/vsynth1-v408.avi
+4e977bec707cda2b09edb717805cb960 *tests/data/fate/vsynth1-v408.avi
 20282052 tests/data/fate/vsynth1-v408.avi
 c5ccac874dbf808e9088bc3107860042 *tests/data/fate/vsynth1-v408.out.rawvideo
 stddev:    0.00 PSNR:999.99 MAXDIFF:    0 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-y41p b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-y41p
index cb4c001f097..84e790b4a0f 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-y41p
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-y41p
@@ -1,4 +1,4 @@
-862ffddd90c82163d2505031e5bbcd9a *tests/data/fate/vsynth1-y41p.avi
+7355fc7614e1ba50d364fc13af5fc3e1 *tests/data/fate/vsynth1-y41p.avi
 7610052 tests/data/fate/vsynth1-y41p.avi
 3aef1d83732a3f9835ee2523a11c95c1 *tests/data/fate/vsynth1-y41p.out.rawvideo
 stddev:    5.98 PSNR: 32.59 MAXDIFF:   87 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-yuv b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-yuv
index 8498d68e6ac..9f73c6fc26f 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-yuv
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth1-yuv
@@ -1,4 +1,4 @@
-2b930d809c19e8d50eb4c92474085c27 *tests/data/fate/vsynth1-yuv.avi
+795ce63f1fe371b98822b1cb385b062f *tests/data/fate/vsynth1-yuv.avi
 7610052 tests/data/fate/vsynth1-yuv.avi
 c5ccac874dbf808e9088bc3107860042 *tests/data/fate/vsynth1-yuv.out.rawvideo
 stddev:    0.00 PSNR:999.99 MAXDIFF:    0 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-bpp1 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-bpp1
index 4005755662f..3b512e9a6ab 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-bpp1
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-bpp1
@@ -1,4 +1,4 @@
-a0330430d7dbd76cbd6d099b778397e8 *tests/data/fate/vsynth2-bpp1.avi
+22664dc7e6cefc580b1456502c46eb10 *tests/data/fate/vsynth2-bpp1.avi
 640460 tests/data/fate/vsynth2-bpp1.avi
 f0dfc0e87e5d96bce29a5944b1bd7471 *tests/data/fate/vsynth2-bpp1.out.rawvideo
 stddev:   68.98 PSNR: 11.36 MAXDIFF:  218 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-bpp15 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-bpp15
index 153b21e5554..9236c25b950 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-bpp15
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-bpp15
@@ -1,4 +1,4 @@
-4bf0992de6b40389a35cd744f76bb213 *tests/data/fate/vsynth2-bpp15.avi
+1760b76ddf1df0092333434f1a97407b *tests/data/fate/vsynth2-bpp15.avi
 10144452 tests/data/fate/vsynth2-bpp15.avi
 9a40133384e3f22c960d70c8cfe51781 *tests/data/fate/vsynth2-bpp15.out.rawvideo
 stddev:   33.97 PSNR: 17.51 MAXDIFF:  154 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv
index bb0602a70f4..3127b562885 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv
@@ -1,4 +1,4 @@
-9002a5769a7744a4b8d24b01787abc3b *tests/data/fate/vsynth2-dv.dv
+6a059698f1f619312dd91504697cca98 *tests/data/fate/vsynth2-dv.dv
 7200000 tests/data/fate/vsynth2-dv.dv
-22a62dc9108c4a8b1a3c708e5d383748 *tests/data/fate/vsynth2-dv.out.rawvideo
-stddev:    1.99 PSNR: 42.12 MAXDIFF:   38 bytes:  7603200/  7603200
+528fd407b6d19f5fe3b3446a3080d148 *tests/data/fate/vsynth2-dv.out.rawvideo
+stddev:    1.99 PSNR: 42.13 MAXDIFF:   38 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv-411 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv-411
index bdda6367bc3..3cee4de3036 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv-411
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv-411
@@ -1,4 +1,4 @@
-701dac8c1d3fe69957eab7ba8d5ecb25 *tests/data/fate/vsynth2-dv-411.dv
+a4afd3c595b4242fb5f1329c82a0b0c2 *tests/data/fate/vsynth2-dv-411.dv
 7200000 tests/data/fate/vsynth2-dv-411.dv
-bf821931bb81f4e92dc38f86d8187300 *tests/data/fate/vsynth2-dv-411.out.rawvideo
-stddev:    3.48 PSNR: 37.28 MAXDIFF:   56 bytes:  7603200/  7603200
+1ef9bd89b72a942c02571f32af03bb04 *tests/data/fate/vsynth2-dv-411.out.rawvideo
+stddev:    3.48 PSNR: 37.29 MAXDIFF:   56 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv-50 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv-50
index c21c525df4c..707fd5c734e 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv-50
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-dv-50
@@ -1,4 +1,4 @@
-9b9ebdf35911dad62203dfdf1f56754e *tests/data/fate/vsynth2-dv-50.dv
+8774632954e780697c472d945c597daf *tests/data/fate/vsynth2-dv-50.dv
 14400000 tests/data/fate/vsynth2-dv-50.dv
-b4d324b2095bc919ad16891891d40b36 *tests/data/fate/vsynth2-dv-50.out.rawvideo
-stddev:    0.88 PSNR: 49.20 MAXDIFF:   17 bytes:  7603200/  7603200
+11167de05c205f974d462f91f56eb837 *tests/data/fate/vsynth2-dv-50.out.rawvideo
+stddev:    0.86 PSNR: 49.43 MAXDIFF:   17 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg
index 98b257ef017..cf80937dc6d 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg
@@ -1,4 +1,4 @@
-c76100bdc3f4c8e2580bb263accda9ec *tests/data/fate/vsynth2-mjpeg.avi
-830154 tests/data/fate/vsynth2-mjpeg.avi
+9bf00cd3188b7395b798bb10df376243 *tests/data/fate/vsynth2-mjpeg.avi
+792742 tests/data/fate/vsynth2-mjpeg.avi
 2b8c59c59e33d6ca7c85d31c5eeab7be *tests/data/fate/vsynth2-mjpeg.out.rawvideo
 stddev:    4.87 PSNR: 34.37 MAXDIFF:   55 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-422 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-422
index ddedda68fec..b162bb32c70 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-422
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-422
@@ -1,4 +1,4 @@
-1c8dd65c901ce48ef82d73b80e38c735 *tests/data/fate/vsynth2-mjpeg-422.avi
-920364 tests/data/fate/vsynth2-mjpeg-422.avi
+e37720892c9ee9d02842cc50bf20181e *tests/data/fate/vsynth2-mjpeg-422.avi
+877786 tests/data/fate/vsynth2-mjpeg-422.avi
 4a1b18eeb8b0f3dccc2c0e6a9f8c876d *tests/data/fate/vsynth2-mjpeg-422.out.rawvideo
 stddev:    4.69 PSNR: 34.69 MAXDIFF:   55 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-444 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-444
index 428fedcc80d..c461e87cbf1 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-444
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-444
@@ -1,4 +1,4 @@
-0ac6d33ef31d07eecf65955eabf241f7 *tests/data/fate/vsynth2-mjpeg-444.avi
-1060070 tests/data/fate/vsynth2-mjpeg-444.avi
+28c9331da946a4ba76947cef290fe184 *tests/data/fate/vsynth2-mjpeg-444.avi
+1005052 tests/data/fate/vsynth2-mjpeg-444.avi
 6417f5a4be03ca7854f0a1be429a286e *tests/data/fate/vsynth2-mjpeg-444.out.rawvideo
 stddev:    4.57 PSNR: 34.93 MAXDIFF:   55 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-huffman b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-huffman
new file mode 100644
index 00000000000..0cf998b4fe1
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-huffman
@@ -0,0 +1,4 @@
+9bf00cd3188b7395b798bb10df376243 *tests/data/fate/vsynth2-mjpeg-huffman.avi
+792742 tests/data/fate/vsynth2-mjpeg-huffman.avi
+2b8c59c59e33d6ca7c85d31c5eeab7be *tests/data/fate/vsynth2-mjpeg-huffman.out.rawvideo
+stddev:    4.87 PSNR: 34.37 MAXDIFF:   55 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-trell b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-trell
index ce6d917c188..e1acb33d88a 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-trell
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-trell
@@ -1,4 +1,4 @@
-4fdbd2327ed16fc4448eb421def22b5e *tests/data/fate/vsynth2-mjpeg-trell.avi
-765628 tests/data/fate/vsynth2-mjpeg-trell.avi
-ce145393bece26d49076b26cf1a2e52e *tests/data/fate/vsynth2-mjpeg-trell.out.rawvideo
+a59d99d31d24875161504820d4266e4d *tests/data/fate/vsynth2-mjpeg-trell.avi
+734728 tests/data/fate/vsynth2-mjpeg-trell.avi
+42376126213c73c86b408882e24ba015 *tests/data/fate/vsynth2-mjpeg-trell.out.rawvideo
 stddev:    5.03 PSNR: 34.09 MAXDIFF:   67 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-trell-huffman b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-trell-huffman
new file mode 100644
index 00000000000..36867400d23
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-mjpeg-trell-huffman
@@ -0,0 +1,4 @@
+a59d99d31d24875161504820d4266e4d *tests/data/fate/vsynth2-mjpeg-trell-huffman.avi
+734728 tests/data/fate/vsynth2-mjpeg-trell-huffman.avi
+42376126213c73c86b408882e24ba015 *tests/data/fate/vsynth2-mjpeg-trell-huffman.out.rawvideo
+stddev:    5.03 PSNR: 34.09 MAXDIFF:   67 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-r210 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-r210
index 3e19ef840d8..dc5ff1849c2 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-r210
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-r210
@@ -1,4 +1,4 @@
-50e82830a941457a3cade01394e34dd0 *tests/data/fate/vsynth2-r210.avi
+2f928096d892ce0239832afc369e117c *tests/data/fate/vsynth2-r210.avi
 22125252 tests/data/fate/vsynth2-r210.avi
 2ade5f6167d7a4a1589e168ddbbc35d0 *tests/data/fate/vsynth2-r210.out.rawvideo
 stddev:    1.17 PSNR: 46.71 MAXDIFF:   15 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-rgb b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-rgb
index 93fe634b9eb..6d44b254895 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-rgb
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-rgb
@@ -1,4 +1,4 @@
-707159e45a20b22d383e71d3e5960753 *tests/data/fate/vsynth2-rgb.avi
+3f8f04636aa027d1fc8245b08c7a8414 *tests/data/fate/vsynth2-rgb.avi
 15213252 tests/data/fate/vsynth2-rgb.avi
 32fae3e665407bb4317b3f90fedb903c *tests/data/fate/vsynth2-rgb.out.rawvideo
 stddev:    1.54 PSNR: 44.37 MAXDIFF:   17 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v210 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v210
index cc72bb22200..3bd4598b406 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v210
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v210
@@ -1,4 +1,4 @@
-211a901d7e6327cc7a48a80250acf4f8 *tests/data/fate/vsynth2-v210.avi
+7a4f5840860ae0bec0c354025b488118 *tests/data/fate/vsynth2-v210.avi
 14752452 tests/data/fate/vsynth2-v210.avi
 99e367a50da75c2c187230889bee8e2e *tests/data/fate/vsynth2-v210.out.rawvideo
 stddev:    0.40 PSNR: 56.06 MAXDIFF:    9 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v210-10 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v210-10
index db38b2f598b..4e973aa2a46 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v210-10
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v210-10
@@ -1,4 +1,4 @@
-02a5d983deb4bc91bb273c2b26c3100f *tests/data/fate/vsynth2-v210-10.avi
+d078cb3cbbbc022ed7c5c448026b050a *tests/data/fate/vsynth2-v210-10.avi
 14752452 tests/data/fate/vsynth2-v210-10.avi
 8bb1c449e1a2a94fd0d98841c04246bb *tests/data/fate/vsynth2-v210-10.out.rawvideo
 stddev:    0.39 PSNR: 56.17 MAXDIFF:    9 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v308 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v308
index f1fee2d7d49..cc36d8a3a10 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v308
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v308
@@ -1,4 +1,4 @@
-a07c9e12508dec90a414a4a6119c5ae4 *tests/data/fate/vsynth2-v308.avi
+866fb5095976d62279c402023526d7a9 *tests/data/fate/vsynth2-v308.avi
 15213252 tests/data/fate/vsynth2-v308.avi
 8394327c14ef0b6fbaae3b69fcc5572a *tests/data/fate/vsynth2-v308.out.rawvideo
 stddev:    0.50 PSNR: 54.10 MAXDIFF:   13 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v408 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v408
index 808135ff2d8..688e4e469a7 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v408
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-v408
@@ -1,4 +1,4 @@
-01612752a44782cd99bf6399875d313c *tests/data/fate/vsynth2-v408.avi
+a9b25bf6f9559cdbe795913cc69d5c0f *tests/data/fate/vsynth2-v408.avi
 20282052 tests/data/fate/vsynth2-v408.avi
 36d7ca943916e1743cefa609eba0205c *tests/data/fate/vsynth2-v408.out.rawvideo
 stddev:    0.00 PSNR:999.99 MAXDIFF:    0 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-y41p b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-y41p
index e40a0f3359a..164a84581ef 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-y41p
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-y41p
@@ -1,4 +1,4 @@
-34425303a27433cfa2cf077258c21c68 *tests/data/fate/vsynth2-y41p.avi
+4eda6db518001a8f2bbb2ec4b414b05a *tests/data/fate/vsynth2-y41p.avi
 7610052 tests/data/fate/vsynth2-y41p.avi
 7c760febffcf1c2e43e494f38b010af1 *tests/data/fate/vsynth2-y41p.out.rawvideo
 stddev:    1.32 PSNR: 45.72 MAXDIFF:   34 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-yuv b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-yuv
index 08c9593c8e4..71999680246 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-yuv
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth2-yuv
@@ -1,4 +1,4 @@
-3d7ecff63ce4863a3d299ff82d910d78 *tests/data/fate/vsynth2-yuv.avi
+5eda550fac21e8913cbb2c88e4f0791a *tests/data/fate/vsynth2-yuv.avi
 7610052 tests/data/fate/vsynth2-yuv.avi
 36d7ca943916e1743cefa609eba0205c *tests/data/fate/vsynth2-yuv.out.rawvideo
 stddev:    0.00 PSNR:999.99 MAXDIFF:    0 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-bpp1 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-bpp1
index 3c8c47ac86d..639a2b15ded 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-bpp1
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-bpp1
@@ -1,4 +1,4 @@
-4c8777a88a9e52b99d5a345acffcbf06 *tests/data/fate/vsynth3-bpp1.avi
+7eafab02a501b3b0ac9f854cd334f47a *tests/data/fate/vsynth3-bpp1.avi
 20460 tests/data/fate/vsynth3-bpp1.avi
 52ae74ef7910e5b603c12288d425b9ae *tests/data/fate/vsynth3-bpp1.out.rawvideo
 stddev:   84.76 PSNR:  9.57 MAXDIFF:  232 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-bpp15 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-bpp15
index fff803721c8..fe67e1a980d 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-bpp15
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-bpp15
@@ -1,4 +1,4 @@
-9ac236c12757cbf9ee6f95c24a374524 *tests/data/fate/vsynth3-bpp15.avi
+ad67910bcee1f3fe49ba7312499a3b16 *tests/data/fate/vsynth3-bpp15.avi
 122452 tests/data/fate/vsynth3-bpp15.avi
 85ac2fa98252ae907b97a7a561ca676f *tests/data/fate/vsynth3-bpp15.out.rawvideo
 stddev:   37.76 PSNR: 16.59 MAXDIFF:  156 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg
index c69338fbc02..4b3371ec220 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg
@@ -1,4 +1,4 @@
-7d7a2fa8559a3652db52b7a70267d1a3 *tests/data/fate/vsynth3-mjpeg.avi
-64808 tests/data/fate/vsynth3-mjpeg.avi
+eec435352485fec167179a63405505be *tests/data/fate/vsynth3-mjpeg.avi
+48156 tests/data/fate/vsynth3-mjpeg.avi
 c4fe7a2669afbd96c640748693fc4e30 *tests/data/fate/vsynth3-mjpeg.out.rawvideo
 stddev:    8.60 PSNR: 29.43 MAXDIFF:   58 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-422 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-422
index b50e4792ed8..c364c79a112 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-422
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-422
@@ -1,4 +1,4 @@
-34c57632d23c4322d2e508368e7c8e36 *tests/data/fate/vsynth3-mjpeg-422.avi
-69462 tests/data/fate/vsynth3-mjpeg-422.avi
+396394fab0d456443a3929a33f8c0d59 *tests/data/fate/vsynth3-mjpeg-422.avi
+52606 tests/data/fate/vsynth3-mjpeg-422.avi
 a332893cb0603f2f505fe5d3bf105519 *tests/data/fate/vsynth3-mjpeg-422.out.rawvideo
 stddev:    8.23 PSNR: 29.82 MAXDIFF:   58 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-444 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-444
index d701f667cc3..0e38744fd21 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-444
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-444
@@ -1,4 +1,4 @@
-0900258953e90ab97a95ccaccb7b0d8a *tests/data/fate/vsynth3-mjpeg-444.avi
-70588 tests/data/fate/vsynth3-mjpeg-444.avi
+3f2dca7be789eb7818c69ec716c0d831 *tests/data/fate/vsynth3-mjpeg-444.avi
+53958 tests/data/fate/vsynth3-mjpeg-444.avi
 79a901f2ed85d82cf1c674fab3d3ef72 *tests/data/fate/vsynth3-mjpeg-444.out.rawvideo
 stddev:    8.21 PSNR: 29.84 MAXDIFF:   58 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-huffman b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-huffman
new file mode 100644
index 00000000000..634a1a52fc6
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-huffman
@@ -0,0 +1,4 @@
+eec435352485fec167179a63405505be *tests/data/fate/vsynth3-mjpeg-huffman.avi
+48156 tests/data/fate/vsynth3-mjpeg-huffman.avi
+c4fe7a2669afbd96c640748693fc4e30 *tests/data/fate/vsynth3-mjpeg-huffman.out.rawvideo
+stddev:    8.60 PSNR: 29.43 MAXDIFF:   58 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-trell b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-trell
index 9178d024750..5b386c7eedb 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-trell
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-trell
@@ -1,4 +1,4 @@
-6f815acb8fce5458561aa902703e6189 *tests/data/fate/vsynth3-mjpeg-trell.avi
-63994 tests/data/fate/vsynth3-mjpeg-trell.avi
-4fed1e12c80df7b67df292b153c3cf16 *tests/data/fate/vsynth3-mjpeg-trell.out.rawvideo
-stddev:    8.27 PSNR: 29.77 MAXDIFF:   61 bytes:    86700/    86700
+484fa337b71c06a0206243814c4894b0 *tests/data/fate/vsynth3-mjpeg-trell.avi
+47816 tests/data/fate/vsynth3-mjpeg-trell.avi
+f0ccfe4584d193fd6d690a85a70db188 *tests/data/fate/vsynth3-mjpeg-trell.out.rawvideo
+stddev:    8.27 PSNR: 29.78 MAXDIFF:   55 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-trell-huffman b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-trell-huffman
new file mode 100644
index 00000000000..719029f37a4
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-mjpeg-trell-huffman
@@ -0,0 +1,4 @@
+484fa337b71c06a0206243814c4894b0 *tests/data/fate/vsynth3-mjpeg-trell-huffman.avi
+47816 tests/data/fate/vsynth3-mjpeg-trell-huffman.avi
+f0ccfe4584d193fd6d690a85a70db188 *tests/data/fate/vsynth3-mjpeg-trell-huffman.out.rawvideo
+stddev:    8.27 PSNR: 29.78 MAXDIFF:   55 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-r210 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-r210
index cdbdb283bc4..75c424cf286 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-r210
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-r210
@@ -1,4 +1,4 @@
-40b93804d521e2b7c82a3060dec81221 *tests/data/fate/vsynth3-r210.avi
+229e700e0fab4e81481e99a70e00bec9 *tests/data/fate/vsynth3-r210.avi
 442052 tests/data/fate/vsynth3-r210.avi
 e1d882babc8754f7418aa91ce48f7ab0 *tests/data/fate/vsynth3-r210.out.rawvideo
 stddev:    3.48 PSNR: 37.28 MAXDIFF:   42 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-rgb b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-rgb
index f67d2858025..1a882ce1041 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-rgb
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-rgb
@@ -1,4 +1,4 @@
-000bd5f3251bfd6a2a2b590b2d16fe0b *tests/data/fate/vsynth3-rgb.avi
+3e2909a69865eb88df72916c38d265de *tests/data/fate/vsynth3-rgb.avi
 183652 tests/data/fate/vsynth3-rgb.avi
 693aff10c094f8bd31693f74cf79d2b2 *tests/data/fate/vsynth3-rgb.out.rawvideo
 stddev:    3.67 PSNR: 36.82 MAXDIFF:   43 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v210 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v210
index 658f90c31eb..f5282eee4b9 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v210
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v210
@@ -1,4 +1,4 @@
-df0ae6cafc1aedbf17176eb44a732e4d *tests/data/fate/vsynth3-v210.avi
+6824f941ed079952cdf22cc9cdfaa35d *tests/data/fate/vsynth3-v210.avi
 224452 tests/data/fate/vsynth3-v210.avi
 198ffb24c06927d8aaac5e59d81a0934 *tests/data/fate/vsynth3-v210.out.rawvideo
 stddev:    2.11 PSNR: 41.61 MAXDIFF:   27 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v210-10 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v210-10
index 1a664afdcc2..46fe24dc7ed 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v210-10
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v210-10
@@ -1,4 +1,4 @@
-b68ad16e3bfd78556b816ec1a676445c *tests/data/fate/vsynth3-v210-10.avi
+83eef7004f81a2f9529941ed27554509 *tests/data/fate/vsynth3-v210-10.avi
 224452 tests/data/fate/vsynth3-v210-10.avi
 0cf7cf68724fa5146b1667e4fa08b0e1 *tests/data/fate/vsynth3-v210-10.out.rawvideo
 stddev:    2.12 PSNR: 41.58 MAXDIFF:   26 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v308 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v308
index 347d4755dc8..b823c7bad4c 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v308
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v308
@@ -1,4 +1,4 @@
-073e24cc00a27436e97e0b242d4fd077 *tests/data/fate/vsynth3-v308.avi
+e1259287375d05431ee718e50eb7f37b *tests/data/fate/vsynth3-v308.avi
 180252 tests/data/fate/vsynth3-v308.avi
 02a85ec07377df6b483281038f8882ee *tests/data/fate/vsynth3-v308.out.rawvideo
 stddev:    3.06 PSNR: 38.40 MAXDIFF:   40 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v408 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v408
index 2da09e18255..b64f7d8e1ae 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v408
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-v408
@@ -1,4 +1,4 @@
-e74a1abf73b9df90f5103d901b37185f *tests/data/fate/vsynth3-v408.avi
+c75fc69c19c6c578ec95c3972f4af339 *tests/data/fate/vsynth3-v408.avi
 238052 tests/data/fate/vsynth3-v408.avi
 a038ad7c3c09f776304ef7accdea9c74 *tests/data/fate/vsynth3-v408.out.rawvideo
 stddev:    0.00 PSNR:999.99 MAXDIFF:    0 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-yuv b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-yuv
index aa2cf2fad2b..ceeb1059c64 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-yuv
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth3-yuv
@@ -1,4 +1,4 @@
-080401647f4b08df4fb44a253c914cc0 *tests/data/fate/vsynth3-yuv.avi
+7935fee60d3eb567baf312900616dec0 *tests/data/fate/vsynth3-yuv.avi
 93552 tests/data/fate/vsynth3-yuv.avi
 a038ad7c3c09f776304ef7accdea9c74 *tests/data/fate/vsynth3-yuv.out.rawvideo
 stddev:    0.00 PSNR:999.99 MAXDIFF:    0 bytes:    86700/    86700
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-bpp1 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-bpp1
index 34899892683..a3772551ba9 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-bpp1
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-bpp1
@@ -1,4 +1,4 @@
-32673399a8442e397a608839eb3e95cb *tests/data/fate/vsynth_lena-bpp1.avi
+8dc90696dabf220a8f4413af20e93073 *tests/data/fate/vsynth_lena-bpp1.avi
 640460 tests/data/fate/vsynth_lena-bpp1.avi
 6183ba861d4e48d4aaefc514fde270e5 *tests/data/fate/vsynth_lena-bpp1.out.rawvideo
 stddev:   83.28 PSNR:  9.72 MAXDIFF:  215 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-bpp15 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-bpp15
index 96dbf6d4932..65bff0bfd01 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-bpp15
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-bpp15
@@ -1,4 +1,4 @@
-b1b2dd35bcb3d5c20651ffe0da55cb46 *tests/data/fate/vsynth_lena-bpp15.avi
+64516ba947d531db2bccc2ecc338b7be *tests/data/fate/vsynth_lena-bpp15.avi
 10144452 tests/data/fate/vsynth_lena-bpp15.avi
 ccf6fc507e938e8cc5c2a97b644de51c *tests/data/fate/vsynth_lena-bpp15.out.rawvideo
 stddev:   32.84 PSNR: 17.80 MAXDIFF:   92 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv
index ad0549f6e64..a8041f36a5c 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv
@@ -1,4 +1,4 @@
-85b8d55b0b68bb3fc2e90babb580f9b7 *tests/data/fate/vsynth_lena-dv.dv
+ab03241e988dcd5bd36a76b25372343f *tests/data/fate/vsynth_lena-dv.dv
 7200000 tests/data/fate/vsynth_lena-dv.dv
-7dac420637360b031ccae7c5a69c5e0c *tests/data/fate/vsynth_lena-dv.out.rawvideo
-stddev:    1.70 PSNR: 43.47 MAXDIFF:   33 bytes:  7603200/  7603200
+6e4b90be39ad408ddc1c0dc4ced40bf0 *tests/data/fate/vsynth_lena-dv.out.rawvideo
+stddev:    1.69 PSNR: 43.54 MAXDIFF:   33 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv-411 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv-411
index 736a35da569..164dd359b2f 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv-411
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv-411
@@ -1,4 +1,4 @@
-e428508f400327aeb96969c08fb9e1b5 *tests/data/fate/vsynth_lena-dv-411.dv
+1a7f091993eb6fe5b6f9d927ba60387d *tests/data/fate/vsynth_lena-dv-411.dv
 7200000 tests/data/fate/vsynth_lena-dv-411.dv
-713ed907fde448c603d6e9aee5efedd1 *tests/data/fate/vsynth_lena-dv-411.out.rawvideo
-stddev:    2.89 PSNR: 38.91 MAXDIFF:   45 bytes:  7603200/  7603200
+e5624f3d4de96e514ac9b96c2b4b447c *tests/data/fate/vsynth_lena-dv-411.out.rawvideo
+stddev:    2.87 PSNR: 38.97 MAXDIFF:   45 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv-50 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv-50
index adee628b67f..2149fd553c0 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv-50
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-dv-50
@@ -1,4 +1,4 @@
-0032a07167199e6f49e07fa7ed4d5f62 *tests/data/fate/vsynth_lena-dv-50.dv
+c678b291e58a277725aa4557387efc58 *tests/data/fate/vsynth_lena-dv-50.dv
 14400000 tests/data/fate/vsynth_lena-dv-50.dv
-56c77e537291536b242857d1056de30c *tests/data/fate/vsynth_lena-dv-50.out.rawvideo
-stddev:    0.82 PSNR: 49.82 MAXDIFF:   12 bytes:  7603200/  7603200
+bda4f98f387f82986e521b78a9bc1eef *tests/data/fate/vsynth_lena-dv-50.out.rawvideo
+stddev:    0.78 PSNR: 50.28 MAXDIFF:   12 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg
index 14876418310..e30ddc76779 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg
@@ -1,4 +1,4 @@
-40c5ba1b15006799773617f888c2808b *tests/data/fate/vsynth_lena-mjpeg.avi
-673178 tests/data/fate/vsynth_lena-mjpeg.avi
+007c989af621445dc7c9bd248b9df3b4 *tests/data/fate/vsynth_lena-mjpeg.avi
+635498 tests/data/fate/vsynth_lena-mjpeg.avi
 9d4bd90e9abfa18192383b4adc23c8d4 *tests/data/fate/vsynth_lena-mjpeg.out.rawvideo
 stddev:    4.32 PSNR: 35.40 MAXDIFF:   49 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-422 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-422
index 23dd1a257d4..f94ae5815de 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-422
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-422
@@ -1,4 +1,4 @@
-4a1f72cf4c8e562f4e805f0c7912515b *tests/data/fate/vsynth_lena-mjpeg-422.avi
-746534 tests/data/fate/vsynth_lena-mjpeg-422.avi
+e867bc5e8e4e4555846c61b3cb4580a6 *tests/data/fate/vsynth_lena-mjpeg-422.avi
+707376 tests/data/fate/vsynth_lena-mjpeg-422.avi
 451ac80989c4e14445cf951fd7f83b6d *tests/data/fate/vsynth_lena-mjpeg-422.out.rawvideo
 stddev:    4.18 PSNR: 35.70 MAXDIFF:   49 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-444 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-444
index 1dc103c1994..cb4c0a12db1 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-444
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-444
@@ -1,4 +1,4 @@
-969ac14cbc77d5475f4871cefe3cc6b0 *tests/data/fate/vsynth_lena-mjpeg-444.avi
-851446 tests/data/fate/vsynth_lena-mjpeg-444.avi
+9a36b201c4f68051441b1ee1307a2cc2 *tests/data/fate/vsynth_lena-mjpeg-444.avi
+807628 tests/data/fate/vsynth_lena-mjpeg-444.avi
 34edcb9c87ff7aac456a4fb07f43504b *tests/data/fate/vsynth_lena-mjpeg-444.out.rawvideo
 stddev:    4.05 PSNR: 35.96 MAXDIFF:   49 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-huffman b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-huffman
new file mode 100644
index 00000000000..6ac1b740a4f
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-huffman
@@ -0,0 +1,4 @@
+007c989af621445dc7c9bd248b9df3b4 *tests/data/fate/vsynth_lena-mjpeg-huffman.avi
+635498 tests/data/fate/vsynth_lena-mjpeg-huffman.avi
+9d4bd90e9abfa18192383b4adc23c8d4 *tests/data/fate/vsynth_lena-mjpeg-huffman.out.rawvideo
+stddev:    4.32 PSNR: 35.40 MAXDIFF:   49 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-trell b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-trell
index d37d5a2714f..86332b20103 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-trell
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-trell
@@ -1,4 +1,4 @@
-61c12b5e0f95c352c1ff2f3b95d88274 *tests/data/fate/vsynth_lena-mjpeg-trell.avi
-613612 tests/data/fate/vsynth_lena-mjpeg-trell.avi
-ee4999fcc0913e01e69fe689b4229cbe *tests/data/fate/vsynth_lena-mjpeg-trell.out.rawvideo
-stddev:    4.51 PSNR: 35.03 MAXDIFF:   60 bytes:  7603200/  7603200
+6eb36ab28a082f496f1f3bc165704a68 *tests/data/fate/vsynth_lena-mjpeg-trell.avi
+582534 tests/data/fate/vsynth_lena-mjpeg-trell.avi
+dcb183a6a5fa06e7234d46dd97ceb8ec *tests/data/fate/vsynth_lena-mjpeg-trell.out.rawvideo
+stddev:    4.51 PSNR: 35.05 MAXDIFF:   60 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-trell-huffman b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-trell-huffman
new file mode 100644
index 00000000000..91fcd199945
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-mjpeg-trell-huffman
@@ -0,0 +1,4 @@
+6eb36ab28a082f496f1f3bc165704a68 *tests/data/fate/vsynth_lena-mjpeg-trell-huffman.avi
+582534 tests/data/fate/vsynth_lena-mjpeg-trell-huffman.avi
+dcb183a6a5fa06e7234d46dd97ceb8ec *tests/data/fate/vsynth_lena-mjpeg-trell-huffman.out.rawvideo
+stddev:    4.51 PSNR: 35.05 MAXDIFF:   60 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-r210 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-r210
index 3ed30ff5061..8fd1a666afc 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-r210
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-r210
@@ -1,4 +1,4 @@
-e5f96a1d0fe5c519f6cb954838e105bc *tests/data/fate/vsynth_lena-r210.avi
+94874a48987fd401494f4d7ca8e1273b *tests/data/fate/vsynth_lena-r210.avi
 22125252 tests/data/fate/vsynth_lena-r210.avi
 6ea4fcd93fc83defc8770e85b64b60bb *tests/data/fate/vsynth_lena-r210.out.rawvideo
 stddev:    0.70 PSNR: 51.12 MAXDIFF:   12 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-rgb b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-rgb
index 9706ffba83c..f3d232e76c8 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-rgb
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-rgb
@@ -1,4 +1,4 @@
-f083e812216195c1e9454b5fac681c92 *tests/data/fate/vsynth_lena-rgb.avi
+6ffbbd6939b3fe9f5dcf036ee46aad2d *tests/data/fate/vsynth_lena-rgb.avi
 15213252 tests/data/fate/vsynth_lena-rgb.avi
 98d0e2854731472c5bf13d8638502d0a *tests/data/fate/vsynth_lena-rgb.out.rawvideo
 stddev:    1.26 PSNR: 46.10 MAXDIFF:   13 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v210 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v210
index ef5020b3f30..549bf43fe13 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v210
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v210
@@ -1,4 +1,4 @@
-20af8b986704b9713cd75d3e6e41efa4 *tests/data/fate/vsynth_lena-v210.avi
+0e0db58fa269cffbfb15f81277fa2828 *tests/data/fate/vsynth_lena-v210.avi
 14752452 tests/data/fate/vsynth_lena-v210.avi
 7ba6e411e43c6b57c95c49d6848f41e6 *tests/data/fate/vsynth_lena-v210.out.rawvideo
 stddev:    0.34 PSNR: 57.41 MAXDIFF:    6 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v210-10 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v210-10
index 1e5732bd550..9541b57d7f1 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v210-10
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v210-10
@@ -1,4 +1,4 @@
-a3913b719397fae870c1d9bc35053259 *tests/data/fate/vsynth_lena-v210-10.avi
+0d638c575c7784c2d445f7f7e3b889bc *tests/data/fate/vsynth_lena-v210-10.avi
 14752452 tests/data/fate/vsynth_lena-v210-10.avi
 a627fb50c8276200fd71383977d87ca3 *tests/data/fate/vsynth_lena-v210-10.out.rawvideo
 stddev:    0.34 PSNR: 57.43 MAXDIFF:    6 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v308 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v308
index 6de15b5aa49..81766df82fc 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v308
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v308
@@ -1,4 +1,4 @@
-5bff4d7763e624272835e056c9faf4c2 *tests/data/fate/vsynth_lena-v308.avi
+eabb002088244fa802b67aea78271641 *tests/data/fate/vsynth_lena-v308.avi
 15213252 tests/data/fate/vsynth_lena-v308.avi
 d43cb310c130c69214332d74f6ee5f9a *tests/data/fate/vsynth_lena-v308.out.rawvideo
 stddev:    0.41 PSNR: 55.80 MAXDIFF:    7 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v408 b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v408
index ba19e28d2ee..2c67dcdac85 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v408
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-v408
@@ -1,4 +1,4 @@
-e2a1c097a78f1a5c8ad1bccc4077844b *tests/data/fate/vsynth_lena-v408.avi
+ba166cd36099177b3942b16cd2c200fc *tests/data/fate/vsynth_lena-v408.avi
 20282052 tests/data/fate/vsynth_lena-v408.avi
 dde5895817ad9d219f79a52d0bdfb001 *tests/data/fate/vsynth_lena-v408.out.rawvideo
 stddev:    0.00 PSNR:999.99 MAXDIFF:    0 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-y41p b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-y41p
index 9cc09573b0a..325d7520731 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-y41p
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-y41p
@@ -1,4 +1,4 @@
-3b958734c653d265cd42e31d6a22230f *tests/data/fate/vsynth_lena-y41p.avi
+159548ec0881286674e4a1bd75b89f9e *tests/data/fate/vsynth_lena-y41p.avi
 7610052 tests/data/fate/vsynth_lena-y41p.avi
 d27a84ccdac09055724d122e03fea82a *tests/data/fate/vsynth_lena-y41p.out.rawvideo
 stddev:    1.07 PSNR: 47.54 MAXDIFF:   21 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-yuv b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-yuv
index bc27dcf6ae1..645ef8bb8d2 100644
--- a/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-yuv
+++ b/mythtv/external/FFmpeg/tests/ref/vsynth/vsynth_lena-yuv
@@ -1,4 +1,4 @@
-0d061b0b7bedcd59e5c90a99f58ceeae *tests/data/fate/vsynth_lena-yuv.avi
+2f4102cd4375383c0a3b6114a502996f *tests/data/fate/vsynth_lena-yuv.avi
 7610052 tests/data/fate/vsynth_lena-yuv.avi
 dde5895817ad9d219f79a52d0bdfb001 *tests/data/fate/vsynth_lena-yuv.out.rawvideo
 stddev:    0.00 PSNR:999.99 MAXDIFF:    0 bytes:  7603200/  7603200
diff --git a/mythtv/external/FFmpeg/tests/refcmp-metadata.awk b/mythtv/external/FFmpeg/tests/refcmp-metadata.awk
new file mode 100644
index 00000000000..fa21aad0e04
--- /dev/null
+++ b/mythtv/external/FFmpeg/tests/refcmp-metadata.awk
@@ -0,0 +1,64 @@
+# Compare metadata filter output containing float value strings to reference
+# output data. Returns the whole reference data if delta of each value is below
+# threshold, else returns the whole input data.
+
+function abs(val) {
+    return ((val < 0.0) ? -val : val);
+}
+
+function max(val1, val2) {
+    return ((val1 >= val2) ? val1 : val2);
+}
+
+function is_numeric_str(str) {
+    return (str ~ /^[+-]?[0-9]*\.?[0-9]+$/);
+}
+
+BEGIN {
+    FS = "=";
+    # check for "fuzz" (threshold) program parameter, else use default
+    if (fuzz <= 0.0) {
+        fuzz = 0.1;
+    }
+    # check for "ref" (reference file) program parameter
+    if (ref) {
+        ref_nr = 0;
+        while ((getline line < ref) > 0) {
+            ref_nr++;
+            ref_lines[ref_nr] = line;
+            if (split(line, fields) == 2 && is_numeric_str(fields[2])) {
+                ref_keys[ref_nr] = fields[1];
+                ref_vals[ref_nr] = fields[2] + 0;  # convert to number
+            }
+        }
+        close(ref);
+    }
+    delta_max = 0;
+    result = (ref ? 1 : 0);
+}
+
+{
+    cmp_lines[NR] = $0;
+    if (NF == 2 && is_numeric_str($2) && ref_vals[NR]) {
+        val = $2 + 0;  # convert to number
+        delta = abs((val / ref_vals[NR]) - 1);
+        delta_max = max(delta_max, delta);
+        result = result && ($1 == ref_keys[NR]) && (delta <= fuzz);
+    } else {
+        result = result && ($0 == ref_lines[NR]);
+    }
+}
+
+END {
+    if (result) {
+        for (i = 1; i <= ref_nr; i++)
+            print ref_lines[i];
+    } else {
+        for (i = 1; i <= NR; i++)
+            print cmp_lines[i];
+        if (NR != ref_nr)
+            print "[refcmp] lines: " NR " != " ref_nr > "/dev/stderr";
+        if (delta_max >= fuzz)
+            print "[refcmp] delta_max: " delta_max " >= " fuzz > "/dev/stderr";
+    }
+}
diff --git a/mythtv/external/FFmpeg/tools/Makefile b/mythtv/external/FFmpeg/tools/Makefile
new file mode 100644
index 00000000000..3909e7cfdd9
--- /dev/null
+++ b/mythtv/external/FFmpeg/tools/Makefile
@@ -0,0 +1,13 @@
+TOOLS = qt-faststart trasher uncoded_frame
+TOOLS-$(CONFIG_LIBMYSOFA) += sofa2wavs
+TOOLS-$(CONFIG_ZLIB) += cws2fws
+
+tools/target_dec_%_fuzzer.o: tools/target_dec_fuzzer.c
+	$(COMPILE_C) -DFFMPEG_DECODER=$*
+
+OBJDIRS += tools
+
+clean::
+	$(RM) $(CLEANSUFFIXES:%=tools/%)
+
+-include $(wildcard tools/*.d)
diff --git a/mythtv/external/FFmpeg/tools/aviocat.c b/mythtv/external/FFmpeg/tools/aviocat.c
index 3bd62b7b48b..983108a64a7 100644
--- a/mythtv/external/FFmpeg/tools/aviocat.c
+++ b/mythtv/external/FFmpeg/tools/aviocat.c
@@ -26,7 +26,8 @@
 
 static int usage(const char *argv0, int ret)
 {
-    fprintf(stderr, "%s [-b bytespersec] [-d duration] input_url output_url\n", argv0);
+    fprintf(stderr, "%s [-b bytespersec] [-d duration] [-oi <options>] [-oo <options>] input_url output_url\n", argv0);
+    fprintf(stderr, "<options>: AVOptions expressed as key=value, :-separated\n");
     return ret;
 }
 
@@ -38,6 +39,8 @@ int main(int argc, char **argv)
     int64_t start_time;
     char errbuf[50];
     AVIOContext *input, *output;
+    AVDictionary *in_opts = NULL;
+    AVDictionary *out_opts = NULL;
 
     av_register_all();
     avformat_network_init();
@@ -49,6 +52,20 @@ int main(int argc, char **argv)
         } else if (!strcmp(argv[i], "-d") && i + 1 < argc) {
             duration = atoi(argv[i + 1]);
             i++;
+        } else if (!strcmp(argv[i], "-oi") && i + 1 < argc) {
+            if (av_dict_parse_string(&in_opts, argv[i + 1], "=", ":", 0) < 0) {
+                fprintf(stderr, "Cannot parse option string %s\n",
+                        argv[i + 1]);
+                return usage(argv[0], 1);
+            }
+            i++;
+        } else if (!strcmp(argv[i], "-oo") && i + 1 < argc) {
+            if (av_dict_parse_string(&out_opts, argv[i + 1], "=", ":", 0) < 0) {
+                fprintf(stderr, "Cannot parse option string %s\n",
+                        argv[i + 1]);
+                return usage(argv[0], 1);
+            }
+            i++;
         } else if (!input_url) {
             input_url = argv[i];
         } else if (!output_url) {
@@ -60,7 +77,7 @@ int main(int argc, char **argv)
     if (!output_url)
         return usage(argv[0], 1);
 
-    ret = avio_open2(&input, input_url, AVIO_FLAG_READ, NULL, NULL);
+    ret = avio_open2(&input, input_url, AVIO_FLAG_READ, NULL, &in_opts);
     if (ret) {
         av_strerror(ret, errbuf, sizeof(errbuf));
         fprintf(stderr, "Unable to open %s: %s\n", input_url, errbuf);
@@ -75,7 +92,7 @@ int main(int argc, char **argv)
         }
         bps = size / duration;
     }
-    ret = avio_open2(&output, output_url, AVIO_FLAG_WRITE, NULL, NULL);
+    ret = avio_open2(&output, output_url, AVIO_FLAG_WRITE, NULL, &out_opts);
     if (ret) {
         av_strerror(ret, errbuf, sizeof(errbuf));
         fprintf(stderr, "Unable to open %s: %s\n", output_url, errbuf);
@@ -102,6 +119,8 @@ int main(int argc, char **argv)
     avio_close(output);
 
 fail:
+    av_dict_free(&in_opts);
+    av_dict_free(&out_opts);
     avio_close(input);
     avformat_network_deinit();
     return ret ? 1 : 0;
diff --git a/mythtv/external/FFmpeg/tools/coverity.c b/mythtv/external/FFmpeg/tools/coverity.c
index 80fc1c2ad5d..19a132a9767 100644
--- a/mythtv/external/FFmpeg/tools/coverity.c
+++ b/mythtv/external/FFmpeg/tools/coverity.c
@@ -35,8 +35,45 @@
 void *av_malloc(size_t size) {
     int has_memory;
     __coverity_negative_sink__(size);
-    if(has_memory)
-        return __coverity_alloc__(size);
-    else
+    if (has_memory) {
+        void *ptr = __coverity_alloc__(size);
+        __coverity_mark_as_uninitialized_buffer__(ptr);
+        __coverity_mark_as_afm_allocated__(ptr, "av_free");
+         return ptr;
+    } else {
         return 0;
+    }
 }
+
+void *av_mallocz(size_t size) {
+    int has_memory;
+    __coverity_negative_sink__(size);
+    if (has_memory) {
+        void *ptr = __coverity_alloc__(size);
+        __coverity_writeall0__(ptr);
+        __coverity_mark_as_afm_allocated__(ptr, "av_free");
+        return ptr;
+    } else {
+        return 0;
+    }
+}
+
+void *av_realloc(void *ptr, size_t size) {
+    int has_memory;
+    __coverity_negative_sink__(size);
+    if (has_memory) {
+        __coverity_escape__(ptr);
+        ptr = __coverity_alloc__(size);
+        __coverity_writeall__(ptr);
+        __coverity_mark_as_afm_allocated__(ptr, "av_free");
+        return ptr;
+    } else {
+        return 0;
+    }
+}
+
+void *av_free(void *ptr) {
+    __coverity_free__(ptr);
+    __coverity_mark_as_afm_freed__(ptr, "av_free");
+}
+
diff --git a/mythtv/external/FFmpeg/tools/fourcc2pixfmt.c b/mythtv/external/FFmpeg/tools/fourcc2pixfmt.c
index 625f531f5c8..75bb6077b5f 100644
--- a/mythtv/external/FFmpeg/tools/fourcc2pixfmt.c
+++ b/mythtv/external/FFmpeg/tools/fourcc2pixfmt.c
@@ -51,13 +51,9 @@ static void print_pix_fmt_fourccs(enum AVPixelFormat pix_fmt, const PixelFormatT
 {
     int i;
 
-    for (i = 0; pix_fmt_tags[i].pix_fmt != AV_PIX_FMT_NONE; i++) {
-        if (pix_fmt_tags[i].pix_fmt == pix_fmt) {
-            char buf[32];
-            av_get_codec_tag_string(buf, sizeof(buf), pix_fmt_tags[i].fourcc);
-            printf("%s%c", buf, sep);
-        }
-    }
+    for (i = 0; pix_fmt_tags[i].pix_fmt != AV_PIX_FMT_NONE; i++)
+        if (pix_fmt_tags[i].pix_fmt == pix_fmt)
+            printf("%s%c", av_fourcc2str(pix_fmt_tags[i].fourcc), sep);
 }
 
 int main(int argc, char **argv)
@@ -92,13 +88,10 @@ int main(int argc, char **argv)
         }
     }
 
-    if (list_fourcc_pix_fmt) {
-        for (i = 0; pix_fmt_tags[i].pix_fmt != AV_PIX_FMT_NONE; i++) {
-            char buf[32];
-            av_get_codec_tag_string(buf, sizeof(buf), pix_fmt_tags[i].fourcc);
-            printf("%s: %s\n", buf, av_get_pix_fmt_name(pix_fmt_tags[i].pix_fmt));
-        }
-    }
+    if (list_fourcc_pix_fmt)
+        for (i = 0; pix_fmt_tags[i].pix_fmt != AV_PIX_FMT_NONE; i++)
+            printf("%s: %s\n", av_fourcc2str(pix_fmt_tags[i].fourcc),
+                   av_get_pix_fmt_name(pix_fmt_tags[i].pix_fmt));
 
     if (list_pix_fmt_fourccs) {
         for (i = 0; av_pix_fmt_desc_get(i); i++) {
diff --git a/mythtv/external/FFmpeg/tools/ismindex.c b/mythtv/external/FFmpeg/tools/ismindex.c
index c16e2f26706..0254a98ff71 100644
--- a/mythtv/external/FFmpeg/tools/ismindex.c
+++ b/mythtv/external/FFmpeg/tools/ismindex.c
@@ -47,8 +47,6 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "cmdutils.h"
-
 #include "libavformat/avformat.h"
 #include "libavformat/isom.h"
 #include "libavformat/os_support.h"
diff --git a/mythtv/external/FFmpeg/tools/loudnorm.rb b/mythtv/external/FFmpeg/tools/loudnorm.rb
new file mode 100755
index 00000000000..4ad374a2477
--- /dev/null
+++ b/mythtv/external/FFmpeg/tools/loudnorm.rb
@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'open3'
+require 'json'
+
+ffmpeg_bin = 'ffmpeg'
+target_il  = -24.0
+target_lra = +11.0
+target_tp  = -2.0
+samplerate = '48k'
+
+if ARGF.argv.count != 2
+  puts "Usage: #{$PROGRAM_NAME} input.wav output.wav"
+  exit 1
+end
+
+ff_cmd = Array.new([
+  ffmpeg_bin,
+  '-hide_banner',
+  '-i', ARGF.argv[0],
+  '-af', "loudnorm='I=#{target_il}:LRA=#{target_lra}:tp=#{target_tp}:print_format=json'",
+  '-f', 'null',
+  '-']);
+
+_stdin, _stdout, stderr, wait_thr = Open3.popen3(*ff_cmd)
+
+if wait_thr.value.success?
+  stats = JSON.parse(stderr.read.lines[-12, 12].join)
+  loudnorm_string  = 'loudnorm='
+  loudnorm_string += 'print_format=summary:'
+  loudnorm_string += 'linear=true:'
+  loudnorm_string += "I=#{target_il}:"
+  loudnorm_string += "LRA=#{target_lra}:"
+  loudnorm_string += "tp=#{target_tp}:"
+  loudnorm_string += "measured_I=#{stats['input_i']}:"
+  loudnorm_string += "measured_LRA=#{stats['input_lra']}:"
+  loudnorm_string += "measured_tp=#{stats['input_tp']}:"
+  loudnorm_string += "measured_thresh=#{stats['input_thresh']}:"
+  loudnorm_string += "offset=#{stats['target_offset']}"
+else
+  puts stderr.read
+  exit 1
+end
+
+ff_cmd = Array.new([
+  ffmpeg_bin,
+  '-y', '-hide_banner',
+  '-i', ARGF.argv[0],
+  '-af', loudnorm_string,
+  '-ar', samplerate,
+  ARGF.argv[1].to_s]);
+
+_stdin, _stdout, stderr, wait_thr = Open3.popen3(*ff_cmd)
+
+if wait_thr.value.success?
+  puts stderr.read.lines[-12, 12].join
+  exit 0
+else
+  puts stderr.read
+  exit 1
+end
diff --git a/mythtv/external/FFmpeg/tools/qt-faststart.c b/mythtv/external/FFmpeg/tools/qt-faststart.c
index 97be019c585..728f80c39c7 100644
--- a/mythtv/external/FFmpeg/tools/qt-faststart.c
+++ b/mythtv/external/FFmpeg/tools/qt-faststart.c
@@ -29,7 +29,10 @@
 #include <inttypes.h>
 #include <string.h>
 
-#ifdef __MINGW32__
+#ifdef __MINGW32CE__
+#define fseeko(x, y, z) fseek(x, y, z)
+#define ftello(x)       ftell(x)
+#elif defined(__MINGW32__)
 #undef fseeko
 #define fseeko(x, y, z) fseeko64(x, y, z)
 #undef ftello
diff --git a/mythtv/external/FFmpeg/tools/sofa2wavs.c b/mythtv/external/FFmpeg/tools/sofa2wavs.c
new file mode 100644
index 00000000000..1f1075b22f8
--- /dev/null
+++ b/mythtv/external/FFmpeg/tools/sofa2wavs.c
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2017 Paul B Mahol
+ *
+ * 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 <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <mysofa.h>
+
+int main(int argc, char **argv)
+{
+    struct MYSOFA_HRTF *hrtf;
+    int sample_rate;
+    int err, i, j;
+
+    if (argc < 3) {
+        printf("usage: %s input_SOFA_file output_directory\n", argv[0]);
+        return 1;
+    }
+
+    hrtf = mysofa_load(argv[1], &err);
+    if (!hrtf || err) {
+        printf("invalid input SOFA file: %s\n", argv[1]);
+        return 1;
+    }
+
+    if (hrtf->DataSamplingRate.elements != 1)
+        goto fail;
+    sample_rate = hrtf->DataSamplingRate.values[0];
+
+    err = mkdir(argv[2], 0744);
+    if (err)
+        goto fail;
+
+    err = chdir(argv[2]);
+    if (err)
+        goto fail;
+
+    for (i = 0; i < hrtf->M; i++) {
+        FILE *file;
+        int bps = 32;
+        int blkalign = 8;
+        int bytespersec = blkalign * sample_rate;
+        char filename[1024];
+        int azi = hrtf->SourcePosition.values[i * 3];
+        int ele = hrtf->SourcePosition.values[i * 3 + 1];
+        int dis = hrtf->SourcePosition.values[i * 3 + 2];
+        int size = 8 * hrtf->N;
+        int offset = i * 2 * hrtf->N;
+
+        snprintf(filename, sizeof(filename), "azi_%d_ele_%d_dis_%d.wav", azi, ele, dis);
+        file = fopen(filename, "w+");
+        fwrite("RIFF", 4, 1, file);
+        fwrite("\xFF\xFF\xFF\xFF", 4, 1, file);
+        fwrite("WAVE", 4, 1, file);
+        fwrite("fmt ", 4, 1, file);
+        fwrite("\x10\x00\00\00", 4, 1, file);
+        fwrite("\x03\x00", 2, 1, file);
+        fwrite("\x02\x00", 2, 1, file);
+        fwrite(&sample_rate, 4, 1, file);
+        fwrite(&bytespersec, 4, 1, file);
+        fwrite(&blkalign, 2, 1, file);
+        fwrite(&bps, 2, 1, file);
+        fwrite("data", 4, 1, file);
+        fwrite(&size, 4, 1, file);
+
+        for (j = 0; j < hrtf->N; j++) {
+            float l, r;
+
+            l = hrtf->DataIR.values[offset + j];
+            r = hrtf->DataIR.values[offset + j + hrtf->N];
+            fwrite(&l, 4, 1, file);
+            fwrite(&r, 4, 1, file);
+        }
+        fclose(file);
+    }
+
+fail:
+    mysofa_free(hrtf);
+
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/tools/target_dec_fuzzer.c b/mythtv/external/FFmpeg/tools/target_dec_fuzzer.c
new file mode 100644
index 00000000000..a8696f9fc73
--- /dev/null
+++ b/mythtv/external/FFmpeg/tools/target_dec_fuzzer.c
@@ -0,0 +1,244 @@
+/*
+ * 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
+ */
+
+/* Targeted fuzzer that targets specific codecs depending on two
+   compile-time flags.
+  INSTRUCTIONS:
+
+  * Get the very fresh clang, e.g. see http://libfuzzer.info#versions
+  * Get and build libFuzzer:
+     svn co http://llvm.org/svn/llvm-project/llvm/trunk/lib/Fuzzer
+     ./Fuzzer/build.sh
+  * build ffmpeg for fuzzing:
+    FLAGS="-fsanitize=address -fsanitize-coverage=trace-pc-guard,trace-cmp -g" CC="clang $FLAGS" CXX="clang++ $FLAGS" ./configure  --disable-x86asm
+    make clean && make -j
+  * build the fuzz target.
+    Choose the value of FFMPEG_CODEC (e.g. AV_CODEC_ID_DVD_SUBTITLE) and
+    choose one of FUZZ_FFMPEG_VIDEO, FUZZ_FFMPEG_AUDIO, FUZZ_FFMPEG_SUBTITLE.
+    clang -fsanitize=address -fsanitize-coverage=trace-pc-guard,trace-cmp tools/target_dec_fuzzer.c -o target_dec_fuzzer -I.   -DFFMPEG_CODEC=AV_CODEC_ID_MPEG1VIDEO -DFUZZ_FFMPEG_VIDEO ../../libfuzzer/libFuzzer.a   -Llibavcodec -Llibavdevice -Llibavfilter -Llibavformat -Llibavresample -Llibavutil -Llibpostproc -Llibswscale -Llibswresample -Wl,--as-needed -Wl,-z,noexecstack -Wl,--warn-common -Wl,-rpath-link=libpostproc:libswresample:libswscale:libavfilter:libavdevice:libavformat:libavcodec:libavutil:libavresample -lavdevice -lavfilter -lavformat -lavcodec -lswresample -lswscale -lavutil -ldl -lxcb -lxcb-shm -lxcb -lxcb-xfixes  -lxcb -lxcb-shape -lxcb -lX11 -lasound -lm -lbz2 -lz -pthread
+  * create a corpus directory and put some samples there (empty dir is ok too):
+    mkdir CORPUS && cp some-files CORPUS
+
+  * Run fuzzing:
+    ./target_dec_fuzzer -max_len=100000 CORPUS
+
+   More info:
+   http://libfuzzer.info
+   http://tutorial.libfuzzer.info
+   https://github.com/google/oss-fuzz
+   http://lcamtuf.coredump.cx/afl/
+   https://security.googleblog.com/2016/08/guided-in-process-fuzzing-of-chrome.html
+*/
+
+#include "config.h"
+#include "libavutil/avassert.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/intreadwrite.h"
+
+#include "libavcodec/avcodec.h"
+#include "libavcodec/bytestream.h"
+#include "libavformat/avformat.h"
+
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
+
+static void error(const char *err)
+{
+    fprintf(stderr, "%s", err);
+    exit(1);
+}
+
+static AVCodec *c = NULL;
+static AVCodec *AVCodecInitialize(enum AVCodecID codec_id)
+{
+    AVCodec *res;
+
+    res = avcodec_find_decoder(codec_id);
+    if (!res)
+        error("Failed to find decoder");
+    return res;
+}
+
+static int subtitle_handler(AVCodecContext *avctx, void *frame,
+                            int *got_sub_ptr, AVPacket *avpkt)
+{
+    AVSubtitle sub;
+    int ret = avcodec_decode_subtitle2(avctx, &sub, got_sub_ptr, avpkt);
+    if (ret >= 0 && *got_sub_ptr)
+        avsubtitle_free(&sub);
+    return ret;
+}
+
+// Class to handle buffer allocation and resize for each frame
+typedef struct FuzzDataBuffer {
+    size_t size_;
+    uint8_t *data_;
+} FuzzDataBuffer;
+
+static void FDBCreate(FuzzDataBuffer *FDB) {
+    FDB->size_ = 0x1000;
+    FDB->data_ = av_malloc(FDB->size_);
+    if (!FDB->data_)
+        error("Failed memory allocation");
+}
+
+static void FDBDesroy(FuzzDataBuffer *FDB) { av_free(FDB->data_); }
+
+static void FDBRealloc(FuzzDataBuffer *FDB, size_t size) {
+    size_t needed = size + FF_INPUT_BUFFER_PADDING_SIZE;
+    av_assert0(needed > size);
+    if (needed > FDB->size_) {
+        av_free(FDB->data_);
+        FDB->size_ = needed;
+        FDB->data_ = av_malloc(FDB->size_);
+        if (!FDB->data_)
+            error("Failed memory allocation");
+    }
+}
+
+static void FDBPrepare(FuzzDataBuffer *FDB, AVPacket *dst, const uint8_t *data,
+                size_t size)
+{
+    FDBRealloc(FDB, size);
+    memcpy(FDB->data_, data, size);
+    size_t padd = FDB->size_ - size;
+    if (padd > FF_INPUT_BUFFER_PADDING_SIZE)
+        padd = FF_INPUT_BUFFER_PADDING_SIZE;
+    memset(FDB->data_ + size, 0, padd);
+    av_init_packet(dst);
+    dst->data = FDB->data_;
+    dst->size = size;
+}
+
+// Ensure we don't loop forever
+const uint32_t maxiteration = 8096;
+
+static const uint64_t FUZZ_TAG = 0x4741542D5A5A5546ULL;
+
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+    const uint64_t fuzz_tag = FUZZ_TAG;
+    FuzzDataBuffer buffer;
+    const uint8_t *last = data;
+    const uint8_t *end = data + size;
+    uint32_t it = 0;
+    int (*decode_handler)(AVCodecContext *avctx, AVFrame *picture,
+                          int *got_picture_ptr,
+                          const AVPacket *avpkt) = NULL;
+
+    if (!c) {
+#ifdef FFMPEG_DECODER
+#define DECODER_SYMBOL0(CODEC) ff_##CODEC##_decoder
+#define DECODER_SYMBOL(CODEC) DECODER_SYMBOL0(CODEC)
+        extern AVCodec DECODER_SYMBOL(FFMPEG_DECODER);
+        avcodec_register(&DECODER_SYMBOL(FFMPEG_DECODER));
+
+        c = &DECODER_SYMBOL(FFMPEG_DECODER);
+#else
+        avcodec_register_all();
+        c = AVCodecInitialize(FFMPEG_CODEC);  // Done once.
+#endif
+        av_log_set_level(AV_LOG_PANIC);
+    }
+
+    // Unsupported
+    if (c->capabilities & AV_CODEC_CAP_HWACCEL_VDPAU)
+        return 0;
+
+    switch (c->type) {
+    case AVMEDIA_TYPE_AUDIO   : decode_handler = avcodec_decode_audio4; break;
+    case AVMEDIA_TYPE_VIDEO   : decode_handler = avcodec_decode_video2; break;
+    case AVMEDIA_TYPE_SUBTITLE: decode_handler = subtitle_handler     ; break;
+    }
+
+    AVCodecContext* ctx = avcodec_alloc_context3(NULL);
+    if (!ctx)
+        error("Failed memory allocation");
+
+    ctx->max_pixels = 4096 * 4096; //To reduce false positive OOM and hangs
+
+    if (size > 1024) {
+        GetByteContext gbc;
+        bytestream2_init(&gbc, data + size - 1024, 1024);
+        ctx->width                              = bytestream2_get_le32(&gbc);
+        ctx->height                             = bytestream2_get_le32(&gbc);
+        ctx->bit_rate                           = bytestream2_get_le64(&gbc);
+        ctx->bits_per_coded_sample              = bytestream2_get_le32(&gbc);
+        if (av_image_check_size(ctx->width, ctx->height, 0, ctx))
+            ctx->width = ctx->height = 0;
+        size -= 1024;
+    }
+
+    int res = avcodec_open2(ctx, c, NULL);
+    if (res < 0) {
+        av_free(ctx);
+        return 0; // Failure of avcodec_open2() does not imply that a issue was found
+    }
+
+    FDBCreate(&buffer);
+    int got_frame;
+    AVFrame *frame = av_frame_alloc();
+    if (!frame)
+        error("Failed memory allocation");
+
+    // Read very simple container
+    AVPacket avpkt;
+    while (data < end && it < maxiteration) {
+        // Search for the TAG
+        while (data + sizeof(fuzz_tag) < end) {
+            if (data[0] == (fuzz_tag & 0xFF) && AV_RN64(data) == fuzz_tag)
+                break;
+            data++;
+        }
+        if (data + sizeof(fuzz_tag) > end)
+            data = end;
+
+        FDBPrepare(&buffer, &avpkt, last, data - last);
+        data += sizeof(fuzz_tag);
+        last = data;
+
+        // Iterate through all data
+        while (avpkt.size > 0 && it++ < maxiteration) {
+            av_frame_unref(frame);
+            int ret = decode_handler(ctx, frame, &got_frame, &avpkt);
+
+            if (it > 20)
+                ctx->error_concealment = 0;
+
+            if (ret <= 0 || ret > avpkt.size)
+               break;
+            if (ctx->codec_type != AVMEDIA_TYPE_AUDIO)
+                ret = avpkt.size;
+            avpkt.data += ret;
+            avpkt.size -= ret;
+        }
+    }
+
+    av_init_packet(&avpkt);
+    avpkt.data = NULL;
+    avpkt.size = 0;
+
+    do {
+        got_frame = 0;
+        decode_handler(ctx, frame, &got_frame, &avpkt);
+    } while (got_frame == 1 && it++ < maxiteration);
+
+    av_frame_free(&frame);
+    avcodec_free_context(&ctx);
+    av_freep(&ctx);
+    FDBDesroy(&buffer);
+    return 0;
+}
diff --git a/mythtv/external/FFmpeg/tools/zmqsend.c b/mythtv/external/FFmpeg/tools/zmqsend.c
index d47bf216b47..7bd7fe4199c 100644
--- a/mythtv/external/FFmpeg/tools/zmqsend.c
+++ b/mythtv/external/FFmpeg/tools/zmqsend.c
@@ -52,8 +52,9 @@ static void usage(void)
 int main(int argc, char **argv)
 {
     AVBPrint src;
-    char c, *src_buf, *recv_buf;
-    int recv_buf_size, ret;
+    char *src_buf, *recv_buf;
+    int c;
+    int recv_buf_size, ret = 0;
     void *zmq_ctx, *socket;
     const char *bind_address = "tcp://localhost:5555";
     const char *infilename = NULL;